#include "sleela/decompiler/macho.hpp" #include #include #include #include // Mach-O parsing is isolated here. It reads the header and load commands to recover // architecture, sections, dylib dependencies, and symbol-table evidence. FAT/universal // containers are reported as a slice count with the first analyzable slice lifted. namespace sleela::decompiler { namespace { std::uint32_t rd32(const std::uint8_t* p,bool be){return be?(std::uint32_t(p[0])<<24)|(std::uint32_t(p[1])<<16)|(std::uint32_t(p[2])<<8)|p[3]:(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 rd64le(const std::uint8_t* p){std::uint64_t v=0;for(int i=0;i<8;++i)v|=std::uint64_t(p[i])<<(8*i);return v;} bool range(std::size_t n,std::uint64_t o,std::uint64_t s){return o<=n&&s<=n-o;} Architecture cpu_arch(std::uint32_t cputype){ switch(cputype){case 7:return Architecture::X86;case 0x01000007:return Architecture::X86_64; case 12:return Architecture::ARM;case 0x0100000c:return Architecture::ARM64;default:return Architecture::Unknown;} } std::string cstr(const std::vector& b,std::uint64_t off){ if(off==0||off>=b.size())return{};auto e=off;while(e(b.data()+off),e-off); } // Analyze a single thin slice beginning at file offset `base`. void analyze_slice(const std::vector& b,std::uint64_t base,const std::string& name,MachoAnalysis& out){ if(!range(b.size(),base,28))return; const std::uint8_t* h=b.data()+base; const std::uint32_t magic=rd32(h,false); const bool be=(magic==0xfeedface||magic==0xfeedfacf)&&(h[0]==0xfe); const bool is64=(h[0]==0xfe?h[3]==0xcf:h[0]==0xcf); // MH_MAGIC_64 variants const std::uint32_t cputype=rd32(h+4,be); const std::uint32_t filetype=rd32(h+12,be); const std::uint32_t ncmds=rd32(h+16,be); out.architecture=cpu_arch(cputype); switch(filetype){case 2:out.artifact_class=ArtifactClass::Executable;break; // MH_EXECUTE case 6:out.artifact_class=ArtifactClass::DynamicLibrary;break; // MH_DYLIB case 8:out.artifact_class=ArtifactClass::DynamicLibrary;break; // MH_BUNDLE case 1:out.artifact_class=ArtifactClass::RelocatableObject;break;// MH_OBJECT case 11:out.artifact_class=ArtifactClass::KernelModule;break;} // MH_KEXT_BUNDLE const std::uint64_t cmd0=base+(is64?32:28); std::uint64_t symoff=0,nsyms=0,stroff=0,strsize=0; std::uint64_t p=cmd0; for(std::uint32_t i=0;i in,const std::string& name){ MachoAnalysis out; std::vector b(in.begin(),in.end()); if(b.size()<8)return out; const std::uint8_t* h=b.data(); if(h[0]==0xca&&h[1]==0xfe&&h[2]==0xba&&(h[3]==0xbe||h[3]==0xbf)){ // FAT/universal (big-endian count) out.fat=true; const bool fat64=h[3]==0xbf; const std::uint32_t nfat=rd32(h+4,true); out.slice_count=nfat; const std::uint64_t ent=fat64?32:20,hdr=8; for(std::uint32_t i=0;i0; return out; } analyze_slice(b,0,name,out); return out; } }