import os, struct class NotELFFileError(Exception): pass class ELFFile: EI_NIDENT = 16 EI_CLASS = 4 EI_DATA = 5 EI_VERSION = 6 EI_OSABI = 7 EI_ABIVERSION = 8 E_MACHINE = 0x12 # possible values for EI_CLASS ELFCLASSNONE = 0 ELFCLASS32 = 1 ELFCLASS64 = 2 # possible value for EI_VERSION EV_CURRENT = 1 # possible values for EI_DATA ELFDATANONE = 0 ELFDATA2LSB = 1 ELFDATA2MSB = 2 PT_INTERP = 3 def my_assert(self, expectation, result): if not expectation == result: #print "'%x','%x' %s" % (ord(expectation), ord(result), self.name) raise NotELFFileError("%s is not an ELF" % self.name) def __init__(self, name, bits = 0): self.name = name self.bits = bits self.objdump_output = {} def open(self): if not os.path.isfile(self.name): raise NotELFFileError("%s is not a normal file" % self.name) with open(self.name, "rb") as f: # Read 4k which should cover most of the headers we're after self.data = f.read(4096) if len(self.data) < ELFFile.EI_NIDENT + 4: raise NotELFFileError("%s is not an ELF" % self.name) self.my_assert(self.data[0], 0x7f) self.my_assert(self.data[1], ord('E')) self.my_assert(self.data[2], ord('L')) self.my_assert(self.data[3], ord('F')) if self.bits == 0: if self.data[ELFFile.EI_CLASS] == ELFFile.ELFCLASS32: self.bits = 32 elif self.data[ELFFile.EI_CLASS] == ELFFile.ELFCLASS64: self.bits = 64 else: # Not 32-bit or 64.. lets assert raise NotELFFileError("ELF but not 32 or 64 bit.") elif self.bits == 32: self.my_assert(self.data[ELFFile.EI_CLASS], ELFFile.ELFCLASS32) elif self.bits == 64: self.my_assert(self.data[ELFFile.EI_CLASS], ELFFile.ELFCLASS64) else: raise NotELFFileError("Must specify unknown, 32 or 64 bit size.") self.my_assert(self.data[ELFFile.EI_VERSION], ELFFile.EV_CURRENT) self.sex = self.data[ELFFile.EI_DATA] if self.sex == ELFFile.ELFDATANONE: raise NotELFFileError("self.sex == ELFDATANONE") elif self.sex == ELFFile.ELFDATA2LSB: self.sex = "<" elif self.sex == ELFFile.ELFDATA2MSB: self.sex = ">" else: raise NotELFFileError("Unknown self.sex") def osAbi(self): return self.data[ELFFile.EI_OSABI] def abiVersion(self): return self.data[ELFFile.EI_ABIVERSION] def abiSize(self): return self.bits def isLittleEndian(self): return self.sex == "<" def isBigEndian(self): return self.sex == ">" def getShort(self, offset): return struct.unpack_from(self.sex+"H", self.data, offset)[0] def getWord(self, offset): return struct.unpack_from(self.sex+"i", self.data, offset)[0] def isDynamic(self): """ Return True if there is a .interp segment (therefore dynamically linked), otherwise False (statically linked). """ offset = self.getWord(self.bits == 32 and 0x1C or 0x20) size = self.getShort(self.bits == 32 and 0x2A or 0x36) count = self.getShort(self.bits == 32 and 0x2C or 0x38) for i in range(0, count): p_type = self.getWord(offset + i * size) if p_type == ELFFile.PT_INTERP: return True return False def machine(self): """ We know the sex stored in self.sex and we know the position """ return self.getShort(ELFFile.E_MACHINE) def run_objdump(self, cmd, d): import bb.process import sys if cmd in self.objdump_output: return self.objdump_output[cmd] objdump = d.getVar('OBJDUMP', True) env = os.environ.copy() env["LC_ALL"] = "C" env["PATH"] = d.getVar('PATH', True) try: bb.note("%s %s %s" % (objdump, cmd, self.name)) self.objdump_output[cmd] = bb.process.run([objdump, cmd, self.name], env=env, shell=False)[0] return self.objdump_output[cmd] except Exception as e: bb.note("%s %s %s failed: %s" % (objdump, cmd, self.name, e)) return "" def elf_machine_to_string(machine): """ Return the name of a given ELF e_machine field or the hex value as a string if it isn't recognised. """ try: return { 0x02: "SPARC", 0x03: "x86", 0x08: "MIPS", 0x14: "PowerPC", 0x28: "ARM", 0x2A: "SuperH", 0x32: "IA-64", 0x3E: "x86-64", 0xB7: "AArch64" }[machine] except: return "Unknown (%s)" % repr(machine) if __name__ == "__main__": import sys elf = ELFFile(sys.argv[1]) elf.open() print(elf.isDynamic())