예제 #1
0
        private static uint GetSymValue(Elf_Header *aHeader, int aTableIdx, int aSymIdx)
        {
            uint       BaseAddress = (uint)aHeader;
            Elf_Shdr * SymSection  = (Elf_Shdr *)(BaseAddress + aHeader->e_shoff) + aTableIdx;
            Elf32_Sym *SymTab      = (Elf32_Sym *)(SymSection->sh_addr) + aSymIdx;

            switch (SymTab->st_shndx)
            {
            case SHN_UNDEF:
            {
                var    StrTabAdd = ((Elf_Shdr *)(BaseAddress + aHeader->e_shoff) + SymSection->sh_link)->sh_addr;
                string SymName   = new string((sbyte *)(StrTabAdd + SymTab->st_name));

                Debug.Write("Undefined Symbol: %s\n", SymName);
                Heap.Free(SymName);
                throw new Exception("[ELF]: Extern Symbol not supported");
            }

            case SHN_ABS:
                return(SymTab->st_value);

            default:
                Elf_Shdr *TargetSection = (Elf_Shdr *)(BaseAddress + aHeader->e_shoff) + SymTab->st_shndx;
                return(TargetSection->sh_addr + SymTab->st_value);
            }
        }
예제 #2
0
        private static void RegisterSymbol(Elf_Header *aHeader, Elf_Shdr *aShdr, string aPath)
        {
            uint       BaseAddress = (uint)aHeader;
            Elf32_Sym *SymTab      = (Elf32_Sym *)aShdr->sh_addr;
            var        StrTabAdd   = ((Elf_Shdr *)(BaseAddress + aHeader->e_shoff) + aShdr->sh_link)->sh_addr;

            uint count = aShdr->sh_size / aShdr->sh_entsize;

            uint Address;

            for (uint i = 0; i < count; i++, SymTab++)
            {
                uint flag = (uint)(SymTab->st_info >> 4);
                if (flag == STB_GLOBAL)
                {
                    switch (SymTab->st_shndx)
                    {
                    case SHN_UNDEF:
                        continue;     // for now ignore UNDEF Symbols

                    case SHN_ABS:
                        Address = SymTab->st_value;
                        break;

                    default:
                        var TargetSection = (Elf_Shdr *)(BaseAddress + aHeader->e_shoff) + SymTab->st_shndx;
                        Address = TargetSection->sh_addr + SymTab->st_value;
                        break;
                    }

                    string SymName = new string((sbyte *)(StrTabAdd + SymTab->st_name));
                    Debug.Write("Symbol: %s\n", SymName);
                }
            }
        }
예제 #3
0
        const uint STB_WEAK   = 2;                  /* Weak, (ie. __attribute__((weak))) */

        internal static uint Load(string aPath)
        {
            Stream xStream = VirtualFileSystem.GetFile(aPath);

            if (xStream == null)
            {
                throw new Exception("[ELF]: File not found!");
            }

            var xData = new byte[xStream.FileSize];

            xStream.Read(xData, xData.Length);

            uint        BaseAddress = xData.GetDataOffset();
            Elf_Header *Header      = (Elf_Header *)BaseAddress;

            /* verify ELF header and if this code support this type of elf */
            CheckHeader(Header);

            /* prepare sections and allocate memory (if required) */
            Elf_Shdr *Shdr = (Elf_Shdr *)(BaseAddress + Header->e_shoff);

            for (int i = 0; i < Header->e_shnum; i++, Shdr++)
            {
                Shdr->sh_addr = BaseAddress + Shdr->sh_offset;
                if ((Shdr->sh_flags & SHF_ALLOC) != 0)
                {
                    LoadSection(BaseAddress, Shdr);
                }
            }

            /* Iterate over all sections and perform relocations */
            Shdr = (Elf_Shdr *)(BaseAddress + Header->e_shoff);
            for (int i = 0; i < Header->e_shnum; i++, Shdr++)
            {
                switch (Shdr->sh_type)
                {
                case SHT_SYMTAB:
                {
                    RegisterSymbol(Header, Shdr, aPath);
                }
                break;

                case SHT_REL:
                {
                    Shdr->sh_addr = BaseAddress + Shdr->sh_offset;
                    Relocate(Header, Shdr);
                }
                break;
                }
            }

            uint LoadAddress = Header->e_entry;

            Heap.Free(xData);

            return(LoadAddress);
        }
예제 #4
0
        private static void Relocate(Elf_Header *aHeader, Elf_Shdr *aShdr)
        {
            uint       BaseAddress   = (uint)aHeader;
            Elf32_Rel *Reloc         = (Elf32_Rel *)aShdr->sh_addr;
            Elf_Shdr * TargetSection = (Elf_Shdr *)(BaseAddress + aHeader->e_shoff) + aShdr->sh_info;

            uint RelocCount = aShdr->sh_size / aShdr->sh_entsize;

            byte SymIdx;
            uint SymVal, RelocType;

            for (uint i = 0; i < RelocCount; i++, Reloc++)
            {
                SymVal    = 0;
                SymIdx    = (byte)(Reloc->r_info >> 8);
                RelocType = Reloc->r_info & 0xFF;

                if (SymIdx != SHN_UNDEF)
                {
                    if (RelocType == R_386_PLT32)
                    {
                        SymVal = 0;
                    }
                    else
                    {
                        SymVal = GetSymValue(aHeader, TargetSection->sh_link, SymIdx);
                    }
                }

                uint *add_ref = (uint *)(TargetSection->sh_addr + Reloc->r_offset);
                switch (RelocType)
                {
                case R_386_32:
                    *add_ref = SymVal + *add_ref;     // S + A
                    break;

                case R_386_PLT32:       // L + A - P
                case R_386_PC32:        // S + A - P
                default:
                    throw new Exception("[ELF]: Unsupported Relocation type");
                }
            }
        }
예제 #5
0
        private static void CheckHeader(Elf_Header *aHeader)
        {
            /* Check if we are supporting this standard */
            var ident = aHeader->e_ident;

            if ((ident[EI_MAG0] != ELFMAG0) ||
                (ident[EI_MAG1] != ELFMAG1) ||
                (ident[EI_MAG2] != ELFMAG2) ||
                (ident[EI_MAG3] != ELFMAG3))
            {
                throw new Exception("[ELF]: Invalid File format");
            }

            if (ident[EI_CLASS] != ELFCLASS32)
            {
                throw new Exception("[ELF]: Unsupported EI_CLASS");
            }

            if (ident[EI_DATA] != ELFDATA2LSB)
            {
                throw new Exception("[ELF]: Unsupported EI_DATA");
            }

            if (aHeader->e_machine != EM_386)
            {
                throw new Exception("[ELF]: Unsupported Machine Type");
            }

            if (aHeader->e_type != ET_REL)
            {
                throw new Exception("[ELF]: Unsupported ELF Type");
            }

            if (aHeader->e_version != EV_CURRENT)
            {
                throw new Exception("[ELF]: Unsupported ELF Version");
            }
        }