#include "sleela/decompiler/pe.hpp" #include #include #include #include #include // PE parsing is intentionally isolated here. It records the container boundary and then // recovers sections, imports, exports, and relocation-directory evidence without mapping // or executing the image. All directory walks are bounds-checked against the file size. 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;} struct Sec{std::string name;std::uint32_t vsize,vaddr,rawsize,rawptr,flags;}; // Translate a relative virtual address to a file offset through the section table. std::uint64_t rva_to_off(const std::vector& secs,std::uint64_t rva){ for(const auto& s:secs){const std::uint64_t end=s.vaddr+std::max(s.vsize,s.rawsize); if(rva>=s.vaddr&&rva& b,std::uint64_t off){ if(off==0||off>=b.size()) return {}; auto e=off; while(e(b.data()+off),e-off); } } PeAnalysis analyze_pe(std::span in,const std::string& name){ PeAnalysis out; std::vector b(in.begin(),in.end()); if(b.size()<0x40||b[0]!='M'||b[1]!='Z') return out; const std::uint32_t pe=rd32(b.data()+0x3c); if(!range(b.size(),pe,24)||b[pe]!='P'||b[pe+1]!='E'||b[pe+2]||b[pe+3]) return out; const std::uint16_t machine=rd16(b.data()+pe+4); const std::uint16_t nsec=rd16(b.data()+pe+6); const std::uint16_t optsz=rd16(b.data()+pe+20); const std::uint16_t chars=rd16(b.data()+pe+22); if(machine==0x14c) out.architecture=Architecture::X86; else if(machine==0x8664) out.architecture=Architecture::X86_64; else if(machine==0xaa64) out.architecture=Architecture::ARM64; else if(machine==0x1c0||machine==0x1c4) out.architecture=Architecture::ARM; const std::uint64_t opt=pe+24; if(!range(b.size(),opt,optsz)||optsz<2) return out; const std::uint16_t magic=rd16(b.data()+opt); const bool pe32plus=(magic==0x20b); // Optional-header fields: entry point, image base, and the data-directory array. std::uint32_t entry=rd32(b.data()+opt+16); std::uint16_t subsystem=0; std::uint32_t ndir=0; std::uint64_t dir_base=0; if(pe32plus){ out.image_base=range(b.size(),opt+24,8)?rd64(b.data()+opt+24):0; if(range(b.size(),opt+68,2))subsystem=rd16(b.data()+opt+68); ndir=range(b.size(),opt+108,4)?rd32(b.data()+opt+108):0; dir_base=opt+112; } else { out.image_base=range(b.size(),opt+28,4)?rd32(b.data()+opt+28):0; if(range(b.size(),opt+68,2))subsystem=rd16(b.data()+opt+68); ndir=range(b.size(),opt+92,4)?rd32(b.data()+opt+92):0; dir_base=opt+96; } out.entry_point=out.image_base+entry; auto dir=[&](std::uint32_t i,std::uint32_t& rva,std::uint32_t& sz){rva=sz=0; if(i=4&&name.compare(name.size()-4,4,".sys")==0)); out.artifact_class=(chars&0x2000)?ArtifactClass::DynamicLibrary:(out.is_driver?ArtifactClass::Driver:ArtifactClass::Executable); // Section table follows the optional header. const std::uint64_t sectab=opt+optsz; std::vector secs; for(std::uint16_t i=0;i