Home /Modules/decompiler/elf.cpp

elf.cpp

decompiler/src/elf.cpp · 198 line(s) · c

#include "sleela/decompiler/elf.hpp"
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <sstream>
#include <unordered_map>
#include <unordered_set>

namespace sleela::decompiler {
namespace {
std::uint16_t rd16(const std::uint8_t* p){return std::uint16_t(p[0])|(std::uint16_t(p[1])<<8);}
std::uint32_t rd32(const std::uint8_t* p){return std::uint32_t(p[0])|(std::uint32_t(p[1])<<8)|(std::uint32_t(p[2])<<16)|(std::uint32_t(p[3])<<24);}
std::uint64_t rd64(const std::uint8_t* p){return std::uint64_t(rd32(p))|(std::uint64_t(rd32(p+4))<<32);}
bool range(std::size_t n,std::uint64_t o,std::uint64_t s){return o<=n&&s<=n-o;}
std::string str(const std::vector<std::uint8_t>& b,std::uint64_t off,std::uint64_t tab,std::uint64_t size){
    if(off>=size||tab>=b.size()) return {};
    const auto p=tab+off; if(p>=b.size()) return {};
    const auto e=std::min<std::uint64_t>(b.size(),tab+size);
    auto q=p; while(q<e&&b[q]) ++q;
    return std::string(reinterpret_cast<const char*>(b.data()+p),q-p);
}
std::string hex(const std::uint8_t* p,std::size_t n){
    static constexpr char d[]="0123456789abcdef"; std::string s; s.reserve(n*2);
    for(std::size_t i=0;i<n;++i){s.push_back(d[p[i]>>4]);s.push_back(d[p[i]&15]);} return s;
}
const char* reloc_name(std::uint16_t machine,std::uint64_t type){
    if(machine==62){
        switch(type){case 1:return "R_X86_64_64";case 2:return "R_X86_64_PC32";case 6:return "R_X86_64_GLOB_DAT";case 7:return "R_X86_64_JUMP_SLOT";case 8:return "R_X86_64_RELATIVE";case 10:return "R_X86_64_32";case 11:return "R_X86_64_32S";case 37:return "R_X86_64_IRELATIVE";default:return "R_X86_64_UNKNOWN";}
    }
    if(machine==3){
        switch(type){case 1:return "R_386_32";case 2:return "R_386_PC32";case 6:return "R_386_GLOB_DAT";case 7:return "R_386_JMP_SLOT";case 8:return "R_386_RELATIVE";default:return "R_386_UNKNOWN";}
    }
    if(machine==183){
        switch(type){case 257:return "R_AARCH64_ABS64";case 258:return "R_AARCH64_ABS32";case 275:return "R_AARCH64_JUMP26";case 282:return "R_AARCH64_JUMP_SLOT";case 283:return "R_AARCH64_RELATIVE";default:return "R_AARCH64_UNKNOWN";}
    }
    if(machine==40){
        switch(type){case 2:return "R_ARM_ABS32";case 3:return "R_ARM_REL32";case 21:return "R_ARM_GLOB_DAT";case 22:return "R_ARM_JUMP_SLOT";case 23:return "R_ARM_RELATIVE";default:return "R_ARM_UNKNOWN";}
    }
    return "ELF_RELOC_UNKNOWN";
}
std::string dyn_tag_name(std::int64_t tag){
    switch(tag){case 3:return "DT_PLTGOT";case 12:return "DT_INIT";case 13:return "DT_FINI";case 23:return "DT_JMPREL";case 25:return "DT_INIT_ARRAY";case 26:return "DT_FINI_ARRAY";case 27:return "DT_INIT_ARRAYSZ";case 28:return "DT_FINI_ARRAYSZ";case 30:return "DT_FLAGS";case 0x6ffffffb:return "DT_FLAGS_1";default:return {};}
}
}
ElfAnalysis analyze_elf(std::span<const std::uint8_t> in,const std::string& name){
    ElfAnalysis out; std::vector<std::uint8_t> b(in.begin(),in.end());
    if(b.size()<0x40||b[0]!=0x7f||b[1]!='E'||b[2]!='L'||b[3]!='F'||b[5]!=1||(b[4]!=1&&b[4]!=2)) return out;
    const bool x64=b[4]==2;
    const std::uint16_t type=rd16(b.data()+16), machine=rd16(b.data()+18);
    const std::uint64_t entry=x64?rd64(b.data()+24):rd32(b.data()+24);
    const std::uint64_t phoff=x64?rd64(b.data()+32):rd32(b.data()+28);
    const std::uint16_t phentsz=x64?rd16(b.data()+54):rd16(b.data()+42), phnum=x64?rd16(b.data()+56):rd16(b.data()+44);
    const std::uint64_t shoff=x64?rd64(b.data()+40):rd32(b.data()+32);
    const std::uint16_t shentsz=x64?rd16(b.data()+58):rd16(b.data()+46), shnum=x64?rd16(b.data()+60):rd16(b.data()+48), shstr=x64?rd16(b.data()+62):rd16(b.data()+50);
    if(phnum&&(!range(b.size(),phoff,std::uint64_t(phentsz)*phnum)||phentsz<(x64?56:32))) return out;
    struct S{std::uint32_t name,type;std::uint64_t flags,addr,off,size,entsize;std::uint32_t link,info;};
    std::vector<S> ss;
    if(shnum){
        if(shentsz<(x64?64:40)||!range(b.size(),shoff,std::uint64_t(shentsz)*shnum)) return out;
        ss.resize(shnum);
        for(std::size_t i=0;i<shnum;++i){auto p=b.data()+shoff+i*shentsz;
            if(x64) ss[i]={rd32(p),rd32(p+4),rd64(p+8),rd64(p+16),rd64(p+24),rd64(p+32),rd64(p+56),rd32(p+40),rd32(p+44)};
            else ss[i]={rd32(p),rd32(p+4),rd32(p+8),rd32(p+12),rd32(p+16),rd32(p+20),rd32(p+36),rd32(p+24),rd32(p+28)};
        }
        if(shstr>=shnum||!range(b.size(),ss[shstr].off,ss[shstr].size)) return out;
    }
    // Program headers provide the load/permission model and are also used for GNU build-id notes.
    constexpr std::uint32_t PT_LOAD=1,PT_DYNAMIC=2,PT_NOTE=4,PT_GNU_STACK=0x6474e551,PT_GNU_RELRO=0x6474e552;
    std::uint32_t dynamic_flags=0, dynamic_flags1=0;
    std::uint64_t dynamic_file=0,dynamic_size=0,dynamic_ent=0;
    for(std::size_t i=0;i<phnum;++i){auto p=b.data()+phoff+i*phentsz;ProgramSegment seg{};
        if(x64){seg.type=rd32(p);seg.flags=rd32(p+4);seg.file_offset=rd64(p+8);seg.virtual_address=rd64(p+16);seg.file_size=rd64(p+32);seg.memory_size=rd64(p+40);seg.alignment=rd64(p+48);}
        else{seg.type=rd32(p);seg.file_offset=rd32(p+4);seg.virtual_address=rd32(p+8);seg.file_size=rd32(p+16);seg.memory_size=rd32(p+20);seg.flags=rd32(p+24);seg.alignment=rd32(p+28);}
        if(!range(b.size(),seg.file_offset,seg.file_size)) continue;
        out.segments.push_back(seg);
        if(seg.type==PT_DYNAMIC){dynamic_file=seg.file_offset;dynamic_size=seg.file_size;dynamic_ent=x64?16:8;}
        if(seg.type==PT_GNU_RELRO) out.library.relro_present=true;
        if(seg.type==PT_GNU_STACK) out.library.nx_stack=(seg.flags&1)==0;
        if(seg.type==PT_NOTE){
            std::uint64_t q=seg.file_offset,end=seg.file_offset+seg.file_size;
            while(q+12<=end){auto namesz=rd32(b.data()+q),descsz=rd32(b.data()+q+4),ntype=rd32(b.data()+q+8);q+=12;
                auto np=(namesz+3)&~std::uint32_t(3), dp=(descsz+3)&~std::uint32_t(3);
                if(q+np+dp>end) break;
                std::string owner(reinterpret_cast<const char*>(b.data()+q),std::min<std::uint32_t>(namesz,4));
                if(ntype==3&&owner.rfind("GNU",0)==0&&descsz) out.library.build_id=hex(b.data()+q+np,descsz);
                q+=np+dp;
            }
        }
    }
    if(ss.empty()){out.valid=true; return out;}
    for(const auto&s:ss) if(range(b.size(),s.off,s.size))
        out.sections.push_back({str(b,s.name,ss[shstr].off,ss[shstr].size),s.off,s.size,s.addr,s.size,std::uint32_t(s.flags)});
    std::uint64_t dynstr_off=0,dynstr_size=0,symoff=0,symsize=0,symentsz=0,modinfo_off=0,modinfo_size=0;
    std::uint64_t symtab_off=0,symtab_size=0,symtab_ent=0,strtab_off=0,strtab_size=0;
    std::unordered_map<std::string,std::size_t> section_index;
    for(std::size_t i=0;i<ss.size();++i){auto n=str(b,ss[i].name,ss[shstr].off,ss[shstr].size);section_index[n]=i;
        if(n==".dynstr"){dynstr_off=ss[i].off;dynstr_size=ss[i].size;}
        else if(n==".dynsym"){symoff=ss[i].off;symsize=ss[i].size;symentsz=ss[i].entsize?ss[i].entsize:(x64?24:16);}
        else if(n==".symtab"){symtab_off=ss[i].off;symtab_size=ss[i].size;symtab_ent=ss[i].entsize?ss[i].entsize:(x64?24:16);}
        else if(n==".strtab"){strtab_off=ss[i].off;strtab_size=ss[i].size;}
        else if(n==".modinfo"){modinfo_off=ss[i].off;modinfo_size=ss[i].size;}
        if(n==".tdata"||n==".tbss") out.library.tls_present=true;
    }
    // ARM mapping symbols live in the static .symtab and partition code into A32/Thumb/data
    // regions. $a = ARM (A32), $t = Thumb, $d = data; suffixed forms ($a.0, $t.1) are the
    // same marker. We collect them only for EM_ARM and leave the list sorted by address.
    if(machine==40&&symtab_off&&symtab_ent&&strtab_off&&range(b.size(),symtab_off,symtab_size)){
        for(std::uint64_t p=symtab_off;p+symtab_ent<=symtab_off+symtab_size;p+=symtab_ent){
            std::uint32_t no; std::uint64_t val;
            if(x64){no=rd32(b.data()+p);val=rd64(b.data()+p+8);}else{no=rd32(b.data()+p);val=rd32(b.data()+p+4);}
            const std::string sn=str(b,no,strtab_off,strtab_size);
            if(sn.size()>=2&&sn[0]=='$'&&(sn[1]=='a'||sn[1]=='t'||sn[1]=='d')&&(sn.size()==2||sn[2]=='.')){
                const CodeKind k=sn[1]=='a'?CodeKind::Arm:(sn[1]=='t'?CodeKind::Thumb:CodeKind::Data);
                out.code_mappings.push_back({val&~std::uint64_t(1),k}); // clear the Thumb low-bit if present
            }
        }
        std::sort(out.code_mappings.begin(),out.code_mappings.end(),[](const CodeMapping&a2,const CodeMapping&b2){return a2.address<b2.address;});
    }
    std::vector<std::string> symbol_names; symbol_names.reserve(1024);
    std::vector<std::uint64_t> symbol_values;
    std::vector<std::uint8_t> symbol_info;
    if(symoff&&symentsz&&range(b.size(),symoff,symsize)){
        for(std::uint64_t p=symoff;p+symentsz<=symoff+symsize;p+=symentsz){
            std::uint32_t no;std::uint8_t info;std::uint64_t val;
            if(x64){no=rd32(b.data()+p);info=b[p+4];val=rd64(b.data()+p+8);}else{no=rd32(b.data()+p);val=rd32(b.data()+p+4);info=b[p+12];}
            auto sn=str(b,no,dynstr_off,dynstr_size); symbol_names.push_back(sn);symbol_values.push_back(val);symbol_info.push_back(info);
            if(sn.empty()) continue;
            const bool ext=val==0; out.symbols.push_back({sn,val,ext,{0,val,name,0.9}});
            const auto kind=info&15; if(!ext&&(kind==2||kind==1)) out.exports.push_back({sn,val}); else if(ext) out.imports.push_back({"",sn,val});
        }
    }
    // Dynamic table metadata. Virtual addresses are translated to file offsets through PT_LOAD.
    auto vaddr_to_file=[&](std::uint64_t va)->std::uint64_t{
        for(const auto&seg:out.segments) if(seg.type==PT_LOAD&&va>=seg.virtual_address&&va-seg.virtual_address<seg.file_size) return seg.file_offset+(va-seg.virtual_address);
        return 0;
    };
    std::uint64_t pltgot=0,jmprel=0,pltrelsz=0,initarr=0,finiarr=0,initsz=0,finisz=0;
    if(dynamic_file&&range(b.size(),dynamic_file,dynamic_size)){
        for(std::uint64_t p=dynamic_file;p+dynamic_ent<=dynamic_file+dynamic_size;p+=dynamic_ent){
            const std::int64_t tag=x64?std::int64_t(rd64(b.data()+p)):std::int32_t(rd32(b.data()+p));
            const std::uint64_t val=x64?rd64(b.data()+p+8):rd32(b.data()+p+4); if(tag==0) break;
            if(tag==1&&dynstr_off) out.library.needed_libraries.push_back(str(b,val,dynstr_off,dynstr_size));
            else if(tag==14&&dynstr_off) out.library.soname=str(b,val,dynstr_off,dynstr_size);
            else if(tag==3) pltgot=val;
            else if(tag==23) jmprel=val;
            else if(tag==2) pltrelsz=val;
            else if(tag==12) out.library.init_functions.push_back("0x"+[] (std::uint64_t x){std::ostringstream s;s<<std::hex<<x;return s.str();}(val));
            else if(tag==13) out.library.fini_functions.push_back("0x"+[] (std::uint64_t x){std::ostringstream s;s<<std::hex<<x;return s.str();}(val));
            else if(tag==25) initarr=val; else if(tag==26) finiarr=val; else if(tag==27) initsz=val; else if(tag==28) finisz=val;
            else if(tag==30) dynamic_flags=std::uint32_t(val); else if(tag==0x6ffffffb) dynamic_flags1=std::uint32_t(val);
        }
    }
    out.library.got_address=pltgot; out.library.plt_address=jmprel;
    out.library.bind_now=(dynamic_flags&8)!=0||(dynamic_flags1&1)!=0;
    out.library.position_independent=(type==3)||type==1||type==2;
    out.library.pie=(type==3?false:(dynamic_flags1&0x08000000u)!=0)||(type==3);
    auto parse_array=[&](std::uint64_t va,std::uint64_t sz,std::vector<std::string>& dst){
        auto off=vaddr_to_file(va); auto word=x64?8u:4u; if(!off||!sz||!range(b.size(),off,sz)) return;
        for(std::uint64_t p=off;p+word<=off+sz;p+=word){auto x=x64?rd64(b.data()+p):rd32(b.data()+p); if(x) dst.push_back("0x"+[] (std::uint64_t y){std::ostringstream s;s<<std::hex<<y;return s.str();}(x));}
    };
    parse_array(initarr,initsz,out.library.init_functions); parse_array(finiarr,finisz,out.library.fini_functions);
    // GNU symbol version tables.
    std::vector<std::uint16_t> versym; std::unordered_map<std::uint16_t,std::string> verdef,verneed;
    auto secdata=[&](const std::string& n)->std::pair<std::uint64_t,std::uint64_t>{auto it=section_index.find(n);return it==section_index.end()?std::pair<std::uint64_t,std::uint64_t>{}:std::pair<std::uint64_t,std::uint64_t>{ss[it->second].off,ss[it->second].size};};
    auto [vo,vs]=secdata(".gnu.version"); if(vo&&vs&&range(b.size(),vo,vs)) for(std::uint64_t p=vo;p+2<=vo+vs;p+=2) versym.push_back(rd16(b.data()+p));
    auto [vdo,vds]=secdata(".gnu.version_d"); if(vdo&&vds&&range(b.size(),vdo,vds)){
        std::uint64_t p=vdo; while(p+20<=vdo+vds){std::uint16_t ndx=rd16(b.data()+p+4),cnt=rd16(b.data()+p+6);std::uint32_t aux=rd32(b.data()+p+12),next=rd32(b.data()+p+16);if(aux&&dynstr_off){auto ap=p+aux; if(ap+8<=vdo+vds){auto no=rd32(b.data()+ap+4);verdef[ndx]=str(b,no,dynstr_off,dynstr_size);}}if(!next)break;p+=next;if(!cnt)break;}
    }
    auto [vro,vrs]=secdata(".gnu.version_r"); if(vro&&vrs&&range(b.size(),vro,vrs)){
        std::uint64_t p=vro; while(p+16<=vro+vrs){std::uint16_t cnt=rd16(b.data()+p+2);std::uint32_t aux=rd32(b.data()+p+8),next=rd32(b.data()+p+12);auto ap=p+aux;for(std::uint16_t i=0;i<cnt&&ap+16<=vro+vrs;++i){std::uint16_t ndx=rd16(b.data()+ap+6);std::uint32_t no=rd32(b.data()+ap+8);auto vn=str(b,no,dynstr_off,dynstr_size);if(!vn.empty()){verneed[ndx]=vn;out.library.required_symbol_versions.push_back(vn);}auto an=rd32(b.data()+ap+12);if(!an)break;ap+=an;}if(!next)break;p+=next;}
    }
    for(std::size_t i=0;i<versym.size()&&i<symbol_names.size();++i){auto v=versym[i]&0x7fff;auto it=verdef.find(v);if(it!=verdef.end()&&!it->second.empty())out.library.symbol_versions.push_back(it->second);auto ir=verneed.find(v);if(ir!=verneed.end()&&!ir->second.empty())out.library.required_symbol_versions.push_back(ir->second);}
    std::sort(out.library.symbol_versions.begin(),out.library.symbol_versions.end());out.library.symbol_versions.erase(std::unique(out.library.symbol_versions.begin(),out.library.symbol_versions.end()),out.library.symbol_versions.end());
    std::sort(out.library.required_symbol_versions.begin(),out.library.required_symbol_versions.end());out.library.required_symbol_versions.erase(std::unique(out.library.required_symbol_versions.begin(),out.library.required_symbol_versions.end()),out.library.required_symbol_versions.end());
    // Relocations, including PLT relocations, are mapped back to dynamic symbols.
    for(std::size_t si=0;si<ss.size();++si){auto n=str(b,ss[si].name,ss[shstr].off,ss[shstr].size);const auto t=ss[si].type;
        if(t!=4&&t!=9) continue; // SHT_RELA / SHT_REL
        const auto es=ss[si].entsize?ss[si].entsize:(x64?(t==4?24:16):(t==4?12:8)); if(!es||!range(b.size(),ss[si].off,ss[si].size)) continue;
        const auto count=ss[si].size/es;
        for(std::uint64_t j=0;j<count;++j){auto p=ss[si].off+j*es;std::uint64_t addr=0,info=0;if(x64){addr=rd64(b.data()+p);info=rd64(b.data()+p+8);}else{addr=rd32(b.data()+p);info=rd32(b.data()+p+4);}
            const auto sym=x64?info>>32:info>>8;const auto rt=x64?info&0xffffffffu:info&0xffu;std::string sn=sym<symbol_names.size()?symbol_names[sym]:"";
            out.relocations.push_back({addr,reloc_name(machine,rt),sn,n});
        }
    }
    // Relocation-backed imports now retain their relocation address, which is the key evidence
    // needed later for PLT/GOT and external-call recovery.
    for(const auto& r : out.relocations) {
        if(r.symbol.empty()) continue;
        for(auto& imp : out.imports)
            if(imp.name==r.symbol && imp.address==0) imp.address=r.address;
    }
    // Kernel module exports/imports are represented by ksymtab sections and ordinary undefined symbols.
    if(section_index.count("__ksymtab")||section_index.count("__ksymtab_gpl")) out.kernel_module.module_name=out.kernel_module.module_name.empty()?name:out.kernel_module.module_name;
    if(modinfo_off&&range(b.size(),modinfo_off,modinfo_size)) for(std::uint64_t p=modinfo_off;p<modinfo_off+modinfo_size;){auto q=p;while(q<modinfo_off+modinfo_size&&b[q])++q;std::string v(reinterpret_cast<const char*>(b.data()+p),q-p);auto eq=v.find('=');if(eq!=std::string::npos){auto k=v.substr(0,eq),val=v.substr(eq+1);if(k=="name")out.kernel_module.module_name=val;else if(k=="vermagic")out.kernel_module.vermagic=val;else if(k=="license")out.kernel_module.license=val;else if(k=="author")out.kernel_module.author=val;else if(k=="description")out.kernel_module.description=val;else if(k=="alias")out.kernel_module.aliases.push_back(val);else if(k=="depends"&&!val.empty()){std::size_t s=0;while(s<val.size()){auto e=val.find(',',s);out.kernel_module.dependencies.push_back(val.substr(s,e==std::string::npos?val.size()-s:e-s));if(e==std::string::npos)break;s=e+1;}}}p=q+1;}
    out.valid=true; return out;
}
}