def __bytes__(self): st_name = uint32(self.st_name, little=self.little) st_value = uint32(self.st_value, little=self.little) st_size = uint32(self.st_size, little=self.little) st_info = uint8(self.st_info, little=self.little) st_other = uint8(self.st_other, little=self.little) st_shndx = uint16(self.st_shndx, little=self.little) return bytes(st_name) + bytes(st_value) + bytes(st_size) + \ bytes(st_info) + bytes(st_other) + bytes(st_shndx)
def __bytes__(self): d_tag = bytes(self.d_tag) d_val = uint32(self.d_val, little=self.little) d_ptr = uint32(self.d_ptr, little=self.little) # make sure d_tag is enum, before reversing bytes # other way it may be already reversed if self.little and isinstance(self.d_tag, DT): d_tag = bytes(reversed(d_tag)) return bytes(d_tag) + bytes(d_val)
def __init__(self, d_tag=DT.DT_NULL, d_val=None, d_ptr=None, little=False): if isinstance(d_tag, DT): ## Value of type \link DT \endlink # \details Controls if d_val or d_ptr is present self.d_tag = d_tag elif d_tag in map(int, DT): self.d_tag = DT(d_tag) elif isinstance(d_tag, int): # TODO: log warning message self.d_tag = uint32(d_tag, little) else: self.d_tag = DT[d_tag] # TODO: set only one of d_val or d_ptr ## Integer of various interpretations self.d_val = d_val ## Program virtual addresses self.d_ptr = d_ptr ## Header endianness indicator # \details Is true, if header values are meant to be stored as # little-endian or false otherwise self.little = little # should not be used, but for consistency set it
def __bytes__(self): p_type = uint32(self.p_type, little=self.little) p_offset = uint32(self.p_offset, little=self.little) p_vaddr = uint32(self.p_vaddr, little=self.little) p_paddr = uint32(self.p_paddr, little=self.little) p_filesz = uint32(self.p_filesz, little=self.little) p_memsz = uint32(self.p_memsz, little=self.little) p_flags = uint32(self.p_flags, little=self.little) p_align = uint32(self.p_align, little=self.little) return bytes(p_type) + bytes(p_offset) + bytes(p_vaddr) + \ bytes(p_paddr) + bytes(p_filesz) + bytes(p_memsz) + \ bytes(p_flags) + bytes(p_align)
def __bytes__(self): little = self.little e_type = bytes(self.e_type) e_machine = bytes(self.e_machine) e_version = uint32(self.e_version, little) e_entry = uint32(self.e_entry, little) e_phoff = uint32(self.e_phoff, little) e_shoff = uint32(self.e_shoff, little) e_flags = uint32(self.e_flags, little) e_ehsize = uint16(self.e_ehsize, little) e_phentsize = uint16(self.e_phentsize, little) e_phnum = uint16(self.e_phnum, little) e_shentsize = uint16(self.e_shentsize, little) e_shnum = uint16(self.e_shnum, little) e_shstrndx = uint16(self.e_shstrndx, little) if self.little: e_type = bytes(reversed(e_type)) e_machine = bytes(reversed(e_machine)) b = bytes(self.e_ident) + bytes(e_type) + bytes(e_machine) + \ bytes(e_version) + bytes(e_entry) + bytes(e_phoff) + \ bytes(e_shoff) + bytes(e_flags) + bytes(e_ehsize) + \ bytes(e_phentsize) + bytes(e_phnum) + bytes(e_shentsize) + \ bytes(e_shnum) + bytes(e_shstrndx) return b
def __bytes__(self): sh_name = uint32(self.sh_name, little=self.little) sh_type = bytes(self.sh_type) sh_flags = uint32(self.sh_flags, little=self.little) sh_addr = uint32(self.sh_addr, little=self.little) sh_offset = uint32(self.sh_offset, little=self.little) sh_size = uint32(self.sh_size, little=self.little) sh_link = uint32(self.sh_link, little=self.little) sh_info = uint32(self.sh_info, little=self.little) sh_addralign = uint32(self.sh_addralign, little=self.little) sh_entsize = uint32(self.sh_entsize, little=self.little) # make sure sh_type is enum, before reversing bytes # other way it may be already reversed if self.little and isinstance(self.sh_type, SHT): sh_type = bytes(reversed(sh_type)) return bytes(sh_name) + bytes(sh_type) + bytes(sh_flags) + \ bytes(sh_addr) + bytes(sh_offset) + bytes(sh_size) + \ bytes(sh_link) + bytes(sh_info) + bytes(sh_addralign) + \ bytes(sh_entsize)
def __init__(self, sh_name=0, sh_type=SHT.SHT_NULL, sh_flags=0, sh_addr=0, sh_offset=0, sh_size=0, sh_link=0, sh_info=0, sh_addralign=0, sh_entsize=0, little=False): ## Offset of section name in .shstrtab self.sh_name = sh_name if isinstance(sh_type, SHT): ## Value of type \link SHT \endlink self.sh_type = sh_type elif sh_type in map(int, SHT): self.sh_type = SHT(sh_type) elif isinstance(sh_type, int): # TODO: log warning message self.sh_type = uint32(sh_type, little) else: self.sh_type = SHT[sh_type] ## Value of type \link SHF \endlink self.sh_flags = sh_flags ## Address of first byte of segment in memory self.sh_addr = sh_addr ## Address of first byte of segment in file self.sh_offset = sh_offset ## Size of section in file self.sh_size = sh_size ## Section type dependent value self.sh_link = sh_link ## Section type dependent value self.sh_info = sh_info ## Section alignment # \details Value of 0 or 1 means no aligment is required self.sh_addralign = sh_addralign ## Entry size, if section holds fixed-size entries self.sh_entsize = sh_entsize ## Header endianness indicator # \details Is true, if header values are meant to be stored as # little-endian or false otherwise self.little = little
def __bytes__(self): r_offset = uint32(self.r_offset, little=self.little) r_info = uint32(self.r_info, little=self.little) r_addend = sint32(self.r_addend, little=self.little) return bytes(r_offset) + bytes(r_info) + bytes(r_addend)