Пример #1
0
        public ModHeader(Nso nso)
        {
            baseAddr = nso.GetModAddr();

            byte[] buffer = nso.ReadNso((uint)baseAddr, 0x1C);
            using (MemoryStream ms = new MemoryStream(buffer))
            {
                BinaryReader br = new BinaryReader(ms);

                string magic = Encoding.ASCII.GetString(br.ReadBytes(4));
                if (magic != HEADER_MAGIC)
                {
                    throw new NsoException("Invalid MOD0 header");
                }

                dynAddr      = br.ReadInt32();
                bssStart     = br.ReadInt32();
                bssEnd       = br.ReadInt32();
                ehFrameStart = br.ReadInt32();
                ehFrameEnd   = br.ReadInt32();
                moduleObj    = br.ReadInt32();

                DynInfo = new DynamicInfo(nso, DynamicAddr);
            }
        }
Пример #2
0
        public byte[] ReadExeFs(long addr, int size)
        {
            long pos = addr;

            byte[] fullBuffer = new byte[size];

            while (pos < addr + size)
            {
                var page = GetAddressPage(pos);
                if ((page.Permission & SegPerm.R) == SegPerm.R)
                {
                    Nso  curNso   = GetAddressNso(pos);
                    long baseAddr = GetNsoAddress((NsoTypeEnum)Nsos.ToList().IndexOf(curNso));
                    long off      = pos - page.Address;
                    int  curSize  = (int)Math.Min(page.Size - off, size);

                    byte[] sub = curNso.ReadNso((uint)(pos - baseAddr), curSize);
                    Buffer.BlockCopy(sub, 0, fullBuffer, (int)(pos - addr), sub.Length);
                    pos += curSize;
                }
                else
                {
                    pos += page.Size;
                }
            }

            return(fullBuffer);
        }
Пример #3
0
        public override int Read(byte[] buffer, int offset, int count)
        {
            int newSize = (pos + count) > Length
            ? (int)(Length - (pos + count))
            : count;

            if (IgnoreReadPerm)
            {
                byte[] buff = new byte[count];
                var    seg  = nso.GetAddressSegment(pos);
                Buffer.BlockCopy(nso.ReadNso(pos, newSize), 0, buff, 0, count);
                Buffer.BlockCopy(buff, 0, buffer, offset, newSize);
                return(count);
            }
            else
            {
                byte[] buff = nso.ReadNso(pos, newSize);
                Buffer.BlockCopy(buff, 0, buffer, offset, newSize);
                return(newSize);
            }
            Position += newSize;
        }
Пример #4
0
 public Elf64_Sym(Nso nso, uint addr)
 {
     byte[] buffer = nso.ReadNso(addr, ELF64_SYM_SIZE);
     using (MemoryStream ms = new MemoryStream(buffer))
     {
         BinaryReader br = new BinaryReader(ms);
         st_name  = br.ReadUInt32();
         st_info  = br.ReadByte();
         st_other = br.ReadByte();
         st_shndx = br.ReadUInt16();
         st_value = br.ReadUInt64();
         st_size  = br.ReadUInt64();
     }
 }
Пример #5
0
        public DynamicInfo(Nso nso, long addr)
        {
            byte[] buffer = nso.ReadNso((uint)addr, 0x200);
            using (MemoryStream ms = new MemoryStream(buffer))
            {
                BinaryReader br  = new BinaryReader(ms);
                Elf64_Dyn    dyn = new Elf64_Dyn(br);

                while (dyn.d_tag != DtTagEnum.DT_NULL)
                {
                    foreach (var item in fields)
                    {
                        if (dyn.d_tag == item.Item1)
                        {
                            this.GetType().GetProperty(item.Item2).SetValue(this, dyn.d_un);
                        }
                    }

                    dyn = new Elf64_Dyn(br);
                }
            }
        }