aboutsummaryrefslogtreecommitdiffstats
path: root/load.py
diff options
context:
space:
mode:
Diffstat (limited to 'load.py')
-rwxr-xr-xload.py1058
1 files changed, 725 insertions, 333 deletions
diff --git a/load.py b/load.py
index df06d6e..091926d 100755
--- a/load.py
+++ b/load.py
@@ -19,10 +19,14 @@
# MA 02110-1301, USA.*/
# *****************************************************************************/
import argparse
-import sys
import code
+import os
import signal
+import subprocess
+import sys
+
from capstone import CS_ARCH_X86, CS_MODE_64, Cs
+
# from capstone.x86 import Cs
@@ -60,69 +64,152 @@ class ExceptionHandler(object):
class CLIArgParser(object):
def __init__(self):
parser = argparse.ArgumentParser()
- parser.add_argument("--dbg", action="store_true",
- help="debug", default=False)
parser.add_argument(
- "--obj", type=str, help="path to the executbale, shared object "
- "or object you want to load in bruiser")
- parser.add_argument("--header", action='store_true',
- help="dump headers", default=False)
- parser.add_argument("--symboltable", action='store_true',
- help="dump symbol table", default=False)
- parser.add_argument("--phdrs", action='store_true',
- help="dump program haeders", default=False)
- parser.add_argument("--shdrs", action='store_true',
- help="dump section haeders", default=False)
- parser.add_argument("--symbolindex", action='store_true',
- help="dump symbol index", default=False)
- parser.add_argument("--stentries", action='store_true',
- help="dump section table entries", default=False)
- parser.add_argument("--objcode", action='store_true',
- help="dump objects", default=False)
- parser.add_argument("--test", action='store_true',
- help="test switch", default=False)
- parser.add_argument("--test2", action='store_true',
- help="test switch 2", default=False)
- parser.add_argument("--funcs", action='store_true',
- help="dump functions", default=False)
- parser.add_argument("--objs", action='store_true',
- help="dump objects", default=False)
- parser.add_argument("--dynsym", action='store_true',
- help="dump dynamic symbol table", default=False)
- parser.add_argument("--dlpath", action='store_true',
- help="dump dynamic linker path", default=False)
- parser.add_argument("--phdynent", action='store_true',
- help="dump ph PT_DYNAMIC entries", default=False)
+ "--dbg", action="store_true", help="debug", default=False
+ )
+ parser.add_argument(
+ "--obj",
+ type=str,
+ help="path to the executbale, shared object "
+ "or object you want to load in bruiser",
+ )
+ parser.add_argument(
+ "--header", action="store_true", help="dump headers", default=False
+ )
+ parser.add_argument(
+ "--symboltable",
+ action="store_true",
+ help="dump symbol table",
+ default=False,
+ )
+ parser.add_argument(
+ "--phdrs",
+ action="store_true",
+ help="dump program haeders",
+ default=False,
+ )
+ parser.add_argument(
+ "--shdrs",
+ action="store_true",
+ help="dump section haeders",
+ default=False,
+ )
+ parser.add_argument(
+ "--symbolindex",
+ action="store_true",
+ help="dump symbol index",
+ default=False,
+ )
+ parser.add_argument(
+ "--stentries",
+ action="store_true",
+ help="dump section table entries",
+ default=False,
+ )
+ parser.add_argument(
+ "--objcode",
+ action="store_true",
+ help="dump objects",
+ default=False,
+ )
+ parser.add_argument(
+ "--test", action="store_true", help="test switch", default=False
+ )
+ parser.add_argument(
+ "--test2", action="store_true", help="test switch 2", default=False
+ )
+ parser.add_argument(
+ "--listdso", action="store_true", help="list DSOs", default=False
+ )
+ parser.add_argument(
+ "--funcs",
+ action="store_true",
+ help="dump functions",
+ default=False,
+ )
+ parser.add_argument(
+ "--objs", action="store_true", help="dump objects", default=False
+ )
+ parser.add_argument(
+ "--dynsym",
+ action="store_true",
+ help="dump dynamic symbol table",
+ default=False,
+ )
+ parser.add_argument(
+ "--dlpath",
+ action="store_true",
+ help="dump dynamic linker path",
+ default=False,
+ )
+ parser.add_argument(
+ "--phdynent",
+ action="store_true",
+ help="dump ph PT_DYNAMIC entries",
+ default=False,
+ )
parser.add_argument("--section", type=str, help="dump a section")
- parser.add_argument("--dumpfunc", type=str,
- help="dump a functions machine code")
- parser.add_argument("--dumpfuncasm", type=str,
- help="dump a functions assembly code")
- parser.add_argument("--textasm", action='store_true',
- help="disassemble the text section", default=False)
- parser.add_argument("--dynsecents", action='store_true',
- help="dynamic section entries", default=False)
- parser.add_argument("--reladyn", action='store_true',
- help=".rela.dyn entries", default=False)
- parser.add_argument("--relaplt", action='store_true',
- help=".rela.plt entries", default=False)
- parser.add_argument("--rodata", action='store_true',
- help="dump .rodata", default=False)
parser.add_argument(
- "--disass", type=str, help="disassembls a section by "
- "name in section headers")
+ "--dumpfunc", type=str, help="dump a functions machine code"
+ )
+ parser.add_argument(
+ "--dumpfuncasm", type=str, help="dump a functions assembly code"
+ )
+ parser.add_argument(
+ "--textasm",
+ action="store_true",
+ help="disassemble the text section",
+ default=False,
+ )
+ parser.add_argument(
+ "--dynsecents",
+ action="store_true",
+ help="dynamic section entries",
+ default=False,
+ )
+ parser.add_argument(
+ "--reladyn",
+ action="store_true",
+ help=".rela.dyn entries",
+ default=False,
+ )
+ parser.add_argument(
+ "--relaplt",
+ action="store_true",
+ help=".rela.plt entries",
+ default=False,
+ )
parser.add_argument(
- "--disassp", type=int, help="disassembls a section "
- "by index in program headers")
- parser.add_argument("--got", action="store_true",
- help="dump .got section", default=False)
- parser.add_argument("--gotplt", action="store_true",
- help="dump .got.plt section", default=False)
+ "--rodata", action="store_true", help="dump .rodata", default=False
+ )
+ parser.add_argument(
+ "--disass",
+ type=str,
+ help="disassembls a section by " "name in section headers",
+ )
+ parser.add_argument(
+ "--disassp",
+ type=int,
+ help="disassembls a section " "by index in program headers",
+ )
+ parser.add_argument(
+ "--got",
+ action="store_true",
+ help="dump .got section",
+ default=False,
+ )
+ parser.add_argument(
+ "--gotplt",
+ action="store_true",
+ help="dump .got.plt section",
+ default=False,
+ )
self.args = parser.parse_args()
if self.args.obj is None:
raise Exception(
"no object file provided. "
- "please specify an object with --obj.")
+ "please specify an object with --obj."
+ )
def byte2int(value, sign=False):
@@ -137,25 +224,25 @@ def LEB128UnsignedDecode(bytelist):
result = 0
shift = 0
for byte in bytelist:
- result |= (byte & 0x7f) << shift
+ result |= (byte & 0x7F) << shift
if (byte & 0x80) == 0:
break
shift += 7
- return(result)
+ return result
def LEB128SignedDecode(bytelist):
result = 0
shift = 0
for byte in bytelist:
- result |= (byte & 0x7f) << shift
+ result |= (byte & 0x7F) << shift
last_byte = byte
shift += 7
if (byte & 0x80) == 0:
break
if last_byte & 0x40:
- result |= - (1 << shift)
- return(result)
+ result |= -(1 << shift)
+ return result
def LEB128UnsignedEncode(int_val):
@@ -165,33 +252,34 @@ def LEB128UnsignedEncode(int_val):
return bytes([0])
byte_array = bytearray()
while int_val:
- byte = int_val & 0x7f
+ byte = int_val & 0x7F
byte_array.append(byte | 0x80)
int_val >>= 7
byte_array[-1] ^= 0x80
- return(byte_array)
+ return byte_array
def LEB128SignedEncode(int_val):
byte_array = bytearray()
while True:
- byte = int_val & 0x7f
+ byte = int_val & 0x7F
byte_array.append(byte | 0x80)
int_val >>= 7
- if ((int_val == 0 and byte & 0x40 == 0) or
- (int_val == -1 and byte & 0x40)):
+ if (int_val == 0 and byte & 0x40 == 0) or (
+ int_val == -1 and byte & 0x40
+ ):
byte_array[-1] ^= 0x80
break
- return(byte_array)
+ return byte_array
-class ELF_REL():
+class ELF_REL:
def __init__(self, r_offset, r_info):
self.r_offset = r_offset
self.r_info = r_info
-class ELF_RELA():
+class ELF_RELA:
def __init__(self, r_offset, r_info, r_addend):
self.r_offset = r_offset
self.r_info = r_info
@@ -211,15 +299,18 @@ def ffs(offset, header_list, numbered, *args):
dummy = []
if numbered:
- numbers_f.extend(range(1, len(args[-1])+1))
+ numbers_f.extend(range(1, len(args[-1]) + 1))
max_column_width.append(
- max([len(repr(number))
- for number in numbers_f]) if numbers_f else 6)
+ max([len(repr(number)) for number in numbers_f])
+ if numbers_f
+ else 6
+ )
header_list.insert(0, "idx")
for arg in args:
max_column_width.append(
- max([len(repr(argette)) for argette in arg]) if arg else 6)
+ max([len(repr(argette)) for argette in arg]) if arg else 6
+ )
index = range(0, len(header_list))
for header, width, i in zip(header_list, max_column_width, index):
@@ -233,12 +324,12 @@ def ffs(offset, header_list, numbered, *args):
index2 = range(0, len(args[-1]))
for i in index2:
if numbered:
- dummy.append(ci+cb+repr(i).ljust(max_column_width[0])+ce)
+ dummy.append(ci + cb + repr(i).ljust(max_column_width[0]) + ce)
for arg, width in zip(args, max_column_width[1:]):
- dummy.append(cd+repr(arg[i]).ljust(width)+ce)
+ dummy.append(cd + repr(arg[i]).ljust(width) + ce)
else:
for arg, width in zip(args, max_column_width):
- dummy.append(cd+repr(arg[i]).ljust(width)+ce)
+ dummy.append(cd + repr(arg[i]).ljust(width) + ce)
lines.append("".join(dummy))
dummy.clear()
return lines
@@ -265,13 +356,13 @@ def get_section_type_string(number):
return "NOBITS"
if number == 0x9:
return "REL"
- if number == 0xa:
+ if number == 0xA:
return "SHLIB"
- if number == 0xb:
+ if number == 0xB:
return "DYNSYM"
- if number == 0xe:
+ if number == 0xE:
return "INIT_ARRAY"
- if number == 0xf:
+ if number == 0xF:
return "FINI_ARRAY"
if number == 0x10:
return "PREINIT"
@@ -283,11 +374,11 @@ def get_section_type_string(number):
return "NUM"
if number == 0x60000000:
return "LOOS"
- if number == 0x6ffffff6:
+ if number == 0x6FFFFFF6:
return "GNU_HASH"
- if number == 0x6fffffff:
+ if number == 0x6FFFFFFF:
return "VERSYM"
- if number == 0x6ffffffe:
+ if number == 0x6FFFFFFE:
return "VERNEED"
@@ -302,18 +393,18 @@ class sh_type_e:
SHT_NOTE = 0x7
SHT_NOBITS = 0x8
SHT_REL = 0x9
- SHT_SHLIB = 0xa
- SHT_DYNSYM = 0xb
- SHT_INIT_ARRAY = 0xe
- SHT_FINI_ARRAY = 0xf
+ SHT_SHLIB = 0xA
+ SHT_DYNSYM = 0xB
+ SHT_INIT_ARRAY = 0xE
+ SHT_FINI_ARRAY = 0xF
SHT_PREINIT = 0x10
SHT_GROUP = 0x11
SHT_SYMTAB_SHNDX = 0x12
SHT_NUM = 0x13
SHT_LOOS = 0x60000000
- GNU_HASH = 0x6ffffff6
- VERSYM = 0x6fffffff
- VERNEED = 0x6ffffffe
+ GNU_HASH = 0x6FFFFFF6
+ VERSYM = 0x6FFFFFFF
+ VERNEED = 0x6FFFFFFE
class sh_flags_e:
@@ -327,8 +418,8 @@ class sh_flags_e:
SHF_OS_NONCONFORMING = 0x100
SHF_GROUP = 0x200
SHF_TLS = 0x400
- SHF_MASKOS = 0x0ff00000
- SHF_MASKPROC = 0xf0000000
+ SHF_MASKOS = 0x0FF00000
+ SHF_MASKPROC = 0xF0000000
SHF_ORDERED = 0x4000000
SHF_EXCLUDE = 0x8000000
@@ -345,9 +436,9 @@ class p_type_e:
PT_HIOS = 0x6FFFFFFF
PT_LOPROC = 0x70000000
PT_HIPROC = 0x7FFFFFFF
- GNU_EH_FRAME = 0x6474e550
- GNU_STACK = 0x6474e551
- GNU_RELRO = 0x6474e552
+ GNU_EH_FRAME = 0x6474E550
+ GNU_STACK = 0x6474E551
+ GNU_RELRO = 0x6474E552
def get_ph_type(value):
@@ -403,7 +494,7 @@ def get_elf_seg_flag(value):
ret.append("W")
if (value & 0x04) >> 2 == 1:
ret.append("R")
- return ''.join(ret)
+ return "".join(ret)
class PH_DYN_TAG_TYPE:
@@ -444,49 +535,49 @@ class PH_DYN_TAG_TYPE:
DT_PREINIT_ARRAY = 32
DT_PREINIT_ARRAYSZ = 33
DT_NUM = 34
- DT_LOOS = 0x6000000d
- DT_HIOS = 0x6ffff000
+ DT_LOOS = 0x6000000D
+ DT_HIOS = 0x6FFFF000
DT_PROC_NUM = 0x0
DT_MIPS_NUM = 0x0
- DT_VALRNGLO = 0x6ffffd00
- DT_GNU_PRELINKED = 0x6ffffdf5
- DT_GNU_CONFLICTSZ = 0x6ffffdf6
- DT_GNU_LIBLISTSZ = 0x6ffffdf7
- DT_CHECKSUM = 0x6ffffdf8
- DT_PLTPADSZ = 0x6ffffdf9
- DT_MOVEENT = 0x6ffffdfa
- DT_MOVESZ = 0x6ffffdfb
- DT_FEATURE_1 = 0x6ffffdfc
- DT_POSFLAG_1 = 0x6ffffdfd
- DT_SYMINSZ = 0x6ffffdfe
- DT_SYMINENT = 0x6ffffdff
- DT_VALRNGHI = 0x6ffffdff
+ DT_VALRNGLO = 0x6FFFFD00
+ DT_GNU_PRELINKED = 0x6FFFFDF5
+ DT_GNU_CONFLICTSZ = 0x6FFFFDF6
+ DT_GNU_LIBLISTSZ = 0x6FFFFDF7
+ DT_CHECKSUM = 0x6FFFFDF8
+ DT_PLTPADSZ = 0x6FFFFDF9
+ DT_MOVEENT = 0x6FFFFDFA
+ DT_MOVESZ = 0x6FFFFDFB
+ DT_FEATURE_1 = 0x6FFFFDFC
+ DT_POSFLAG_1 = 0x6FFFFDFD
+ DT_SYMINSZ = 0x6FFFFDFE
+ DT_SYMINENT = 0x6FFFFDFF
+ DT_VALRNGHI = 0x6FFFFDFF
DT_VALNUM = 12
- DT_ADDRRNGLO = 0x6ffffe00
- DT_GNU_HASH = 0x6ffffef5
- DT_TLSDESC_PLT = 0x6ffffef6
- DT_TLSDESC_GOT = 0x6ffffef7
- DT_GNU_CONFLICT = 0x6ffffef8
- DT_GNU_LIBLIST = 0x6ffffef9
- DT_CONFIG = 0x6ffffefa
- DT_DEPAUDIT = 0x6ffffefb
- DT_AUDIT = 0x6ffffefc
- DT_PLTPAD = 0x6ffffefd
- DT_MOVETAB = 0x6ffffefe
- DT_SYMINFO = 0x6ffffeff
- DT_ADDRRNGHI = 0x6ffffeff
+ DT_ADDRRNGLO = 0x6FFFFE00
+ DT_GNU_HASH = 0x6FFFFEF5
+ DT_TLSDESC_PLT = 0x6FFFFEF6
+ DT_TLSDESC_GOT = 0x6FFFFEF7
+ DT_GNU_CONFLICT = 0x6FFFFEF8
+ DT_GNU_LIBLIST = 0x6FFFFEF9
+ DT_CONFIG = 0x6FFFFEFA
+ DT_DEPAUDIT = 0x6FFFFEFB
+ DT_AUDIT = 0x6FFFFEFC
+ DT_PLTPAD = 0x6FFFFEFD
+ DT_MOVETAB = 0x6FFFFEFE
+ DT_SYMINFO = 0x6FFFFEFF
+ DT_ADDRRNGHI = 0x6FFFFEFF
DT_ADDRNUM = 11
- DT_VERSYM = 0x6ffffff0
- DT_RELACOUNT = 0x6ffffff9
- DT_RELCOUNT = 0x6ffffffa
- DT_FLAGS_1 = 0x6ffffffb
- DT_VERDEF = 0x6ffffffc
- DT_VERDEFNUM = 0x6ffffffd
- DT_VERNEED = 0x6ffffffe
- DT_VERNEEDNUM = 0x6fffffff
+ DT_VERSYM = 0x6FFFFFF0
+ DT_RELACOUNT = 0x6FFFFFF9
+ DT_RELCOUNT = 0x6FFFFFFA
+ DT_FLAGS_1 = 0x6FFFFFFB
+ DT_VERDEF = 0x6FFFFFFC
+ DT_VERDEFNUM = 0x6FFFFFFD
+ DT_VERNEED = 0x6FFFFFFE
+ DT_VERNEEDNUM = 0x6FFFFFFF
DT_VERSIONTAGNUM = 16
- DT_AUXILIARY = 0x7ffffffd
- DT_FILTER = 0x7fffffff
+ DT_AUXILIARY = 0x7FFFFFFD
+ DT_FILTER = 0x7FFFFFFF
DT_EXTRANUM = 3
@@ -821,71 +912,71 @@ def get_x86_64_rel_type(val):
def get_x86_64_rel_type_2(val):
if val == X86_64_REL_TYPE_2.R_X86_64_NONE:
- return"R_X86_64_NONE"
+ return "R_X86_64_NONE"
elif val == X86_64_REL_TYPE_2.R_X86_64_64:
- return"R_X86_64_64"
+ return "R_X86_64_64"
elif val == X86_64_REL_TYPE_2.R_X86_64_PC32:
- return"R_X86_64_PC32"
+ return "R_X86_64_PC32"
elif val == X86_64_REL_TYPE_2.R_X86_64_GOT32:
- return"R_X86_64_GOT32"
+ return "R_X86_64_GOT32"
elif val == X86_64_REL_TYPE_2.R_X86_64_PLT32:
- return"R_X86_64_PLT32"
+ return "R_X86_64_PLT32"
elif val == X86_64_REL_TYPE_2.R_X86_64_COPY:
- return"R_X86_64_COPY"
+ return "R_X86_64_COPY"
elif val == X86_64_REL_TYPE_2.R_X86_64_GLOB_DAT:
- return"R_X86_64_GLOB_DAT"
+ return "R_X86_64_GLOB_DAT"
elif val == X86_64_REL_TYPE_2.R_X86_64_JUMP_SLOT:
- return"R_X86_64_JUMP_SLOT"
+ return "R_X86_64_JUMP_SLOT"
elif val == X86_64_REL_TYPE_2.R_X86_64_RELATIVE:
- return"R_X86_64_RELATIVE"
+ return "R_X86_64_RELATIVE"
elif val == X86_64_REL_TYPE_2.R_X86_64_GOTPCREL:
- return"R_X86_64_GOTPCREL"
+ return "R_X86_64_GOTPCREL"
elif val == X86_64_REL_TYPE_2.R_X86_64_32:
- return"R_X86_64_32"
+ return "R_X86_64_32"
elif val == X86_64_REL_TYPE_2.R_X86_64_32S:
- return"R_X86_64_32S"
+ return "R_X86_64_32S"
elif val == X86_64_REL_TYPE_2.R_X86_64_16:
- return"R_X86_64_16"
+ return "R_X86_64_16"
elif val == X86_64_REL_TYPE_2.R_X86_64_PC16:
- return"R_X86_64_PC16"
+ return "R_X86_64_PC16"
elif val == X86_64_REL_TYPE_2.R_X86_64_64_8:
- return"R_X86_64_64_8"
+ return "R_X86_64_64_8"
elif val == X86_64_REL_TYPE_2.R_X86_64_PC8:
- return"R_X86_64_PC8"
+ return "R_X86_64_PC8"
elif val == X86_64_REL_TYPE_2.R_X86_64_DTPMOD64:
- return"R_X86_64_DTPMOD64"
+ return "R_X86_64_DTPMOD64"
elif val == X86_64_REL_TYPE_2.R_X86_64_DTPOFF64:
- return"R_X86_64_DTPOFF64"
+ return "R_X86_64_DTPOFF64"
elif val == X86_64_REL_TYPE_2.R_X86_64_TPOFF64:
- return"R_X86_64_TPOFF64"
+ return "R_X86_64_TPOFF64"
elif val == X86_64_REL_TYPE_2.R_X86_64_TLSGD:
- return"R_X86_64_TLSGD"
+ return "R_X86_64_TLSGD"
elif val == X86_64_REL_TYPE_2.R_X86_64_TLSLD:
- return"R_X86_64_TLSLD"
+ return "R_X86_64_TLSLD"
elif val == X86_64_REL_TYPE_2.R_X86_64_DTPOFF32:
- return"R_X86_64_DTPOFF32"
+ return "R_X86_64_DTPOFF32"
elif val == X86_64_REL_TYPE_2.R_X86_64_GOTTPOFF:
- return"R_X86_64_GOTTPOFF"
+ return "R_X86_64_GOTTPOFF"
elif val == X86_64_REL_TYPE_2.R_X86_64_TPOFF32:
- return"R_X86_64_TPOFF32"
+ return "R_X86_64_TPOFF32"
elif val == X86_64_REL_TYPE_2.R_X86_64_PC64:
- return"R_X86_64_PC64"
+ return "R_X86_64_PC64"
elif val == X86_64_REL_TYPE_2.R_X86_64_GOTOFF64:
- return"R_X86_64_GOTOFF64"
+ return "R_X86_64_GOTOFF64"
elif val == X86_64_REL_TYPE_2.R_X86_64_GOTPC32:
- return"R_X86_64_GOTPC32"
+ return "R_X86_64_GOTPC32"
elif val == X86_64_REL_TYPE_2.R_X86_64_SIZE32:
- return"R_X86_64_SIZE32"
+ return "R_X86_64_SIZE32"
elif val == X86_64_REL_TYPE_2.R_X86_64_SIZE64:
- return"R_X86_64_SIZE64"
+ return "R_X86_64_SIZE64"
elif val == X86_64_REL_TYPE_2.R_X86_64_GOTPC32_TLDSEC:
- return"R_X86_64_GOTPC32_TLDSEC"
+ return "R_X86_64_GOTPC32_TLDSEC"
elif val == X86_64_REL_TYPE_2.R_X86_64_TLDSEC_CALL:
- return"R_X86_64_TLDSEC_CALL"
+ return "R_X86_64_TLDSEC_CALL"
elif val == X86_64_REL_TYPE_2.R_X86_64_TLDSEC:
- return"R_X86_64_TLDSEC"
+ return "R_X86_64_TLDSEC"
elif val == X86_64_REL_TYPE_2.R_X86_64_IRELATIVE:
- return"R_X86_64_IRELATIVE"
+ return "R_X86_64_IRELATIVE"
else:
return "UNKNOWN"
@@ -993,17 +1084,17 @@ def get_elf_vis_string(value):
class Colors:
- purple = '\033[95m'
- blue = '\033[94m'
- green = '\033[92m'
- yellow = '\033[93m'
- red = '\033[91m'
- grey = '\033[1;37m'
- darkgrey = '\033[1;30m'
- cyan = '\033[1;36m'
- ENDC = '\033[0m'
- BOLD = '\033[1m'
- UNDERLINE = '\033[4m'
+ purple = "\033[95m"
+ blue = "\033[94m"
+ green = "\033[92m"
+ yellow = "\033[93m"
+ red = "\033[91m"
+ grey = "\033[1;37m"
+ darkgrey = "\033[1;30m"
+ cyan = "\033[1;36m"
+ ENDC = "\033[0m"
+ BOLD = "\033[1m"
+ UNDERLINE = "\033[4m"
def openSO_r(path):
@@ -1016,11 +1107,30 @@ def openSO_w(path):
return so
-class ELFHDR():
- def __init__(self, ei_mag, ei_class, ei_data, ei_version, ei_osabi,
- ei_abiversion, ei_pad, e_type, e_machine, e_version, e_entry,
- e_phoff, e_shoff, e_flags, e_ehsize, e_phentsize, e_phnum,
- e_shentsize, e_shnum, e_shstrndx):
+class ELFHDR:
+ def __init__(
+ self,
+ ei_mag,
+ ei_class,
+ ei_data,
+ ei_version,
+ ei_osabi,
+ ei_abiversion,
+ ei_pad,
+ e_type,
+ e_machine,
+ e_version,
+ e_entry,
+ e_phoff,
+ e_shoff,
+ e_flags,
+ e_ehsize,
+ e_phentsize,
+ e_phnum,
+ e_shentsize,
+ e_shnum,
+ e_shstrndx,
+ ):
self.ei_mag = ei_mag
self.ei_class = ei_class
self.ei_data = ei_data
@@ -1043,9 +1153,19 @@ class ELFHDR():
self.e_shstrndx = e_shstrndx
-class PHDR():
- def __init__(self, p_type, p_flags, p_offset, p_vaddr, p_paddr, p_filesz,
- p_memsz, p_flags2, p_align):
+class PHDR:
+ def __init__(
+ self,
+ p_type,
+ p_flags,
+ p_offset,
+ p_vaddr,
+ p_paddr,
+ p_filesz,
+ p_memsz,
+ p_flags2,
+ p_align,
+ ):
self.p_type = p_type
self.p_flags = p_flags
self.p_offset = p_offset
@@ -1057,9 +1177,20 @@ class PHDR():
self.p_align = p_align
-class SHDR():
- def __init__(self, sh_name, sh_type, sh_flags, sh_addr, sh_offset, sh_size,
- sh_link, sh_info, sh_addralign, sh_entsize):
+class SHDR:
+ def __init__(
+ self,
+ sh_name,
+ sh_type,
+ sh_flags,
+ sh_addr,
+ sh_offset,
+ sh_size,
+ sh_link,
+ sh_info,
+ sh_addralign,
+ sh_entsize,
+ ):
self.sh_name = sh_name
self.sh_type = sh_type
self.sh_flags = sh_flags
@@ -1072,9 +1203,18 @@ class SHDR():
self.sh_entsize = sh_entsize
-class Symbol_Table_Entry64():
- def __init__(self, st_name, st_info, st_other, st_shndx, st_value,
- st_size, st_bind, st_type):
+class Symbol_Table_Entry64:
+ def __init__(
+ self,
+ st_name,
+ st_info,
+ st_other,
+ st_shndx,
+ st_value,
+ st_size,
+ st_bind,
+ st_type,
+ ):
self.st_name = st_name
self.st_info = st_info
self.st_other = st_other
@@ -1089,8 +1229,9 @@ class ELF(object):
def __init__(self, so):
self.so = so
self.so.seek(0, 0)
- self.elfhdr = ELFHDR(0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+ self.elfhdr = ELFHDR(
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ )
self.phdr = []
self.shhdr = []
self.size = int()
@@ -1137,7 +1278,8 @@ class ELF(object):
num = int(byte2int(self.shhdr[i].sh_size) / 24)
for j in range(0, num):
self.read_st_entry(
- symbol_tb[offset:offset + 24], self.string_tb_e)
+ symbol_tb[offset : offset + 24], self.string_tb_e
+ )
offset += 24
if type == sh_type_e.SHT_DYNSYM:
self.so.seek(byte2int(self.shhdr[i].sh_offset), 0)
@@ -1146,7 +1288,8 @@ class ELF(object):
num = int(byte2int(self.shhdr[i].sh_size) / 24)
for j in range(0, num):
self.read_st_entry(
- symbol_tb[offset:offset + 24], self.string_tb_e_dyn)
+ symbol_tb[offset : offset + 24], self.string_tb_e_dyn
+ )
offset += 24
self.pop_data_section()
self.pop_text_section()
@@ -1263,7 +1406,7 @@ class ELF(object):
dummy.st_value = st[8:16]
dummy.st_size = st[16:24]
dummy.st_bind = byte2int(dummy.st_info) >> 4
- dummy.st_type = byte2int(dummy.st_info) & 0x0f
+ dummy.st_type = byte2int(dummy.st_info) & 0x0F
entry_list.append(dummy)
def read_section_name(self, index):
@@ -1276,7 +1419,7 @@ class ELF(object):
index += 1
name.append(chr(char))
char = strings[index]
- return ''.join(name)
+ return "".join(name)
def get_ph_dyn_entries(self):
size = 0
@@ -1285,15 +1428,16 @@ class ELF(object):
self.so.seek(byte2int(phdr.p_offset), 0)
size = byte2int(phdr.p_filesz)
ph_dyn = self.so.read(size)
- for i in range(int(size/8)):
- d_tag = byte2int(ph_dyn[8*i:8*i + 4])
- d_un = byte2int(ph_dyn[8*i + 4:8*i + 8])
+ for i in range(int(size / 8)):
+ d_tag = byte2int(ph_dyn[8 * i : 8 * i + 4])
+ d_un = byte2int(ph_dyn[8 * i + 4 : 8 * i + 8])
self.ph_dyn_ent.append(ph_dynamic_entry(d_tag, d_un))
def dump_ph_dyn_entries(self):
header = ["d_tag", "d_un"]
- tag_list = [get_ph_dynamic_ent_tag_type(
- ph.d_tag) for ph in self.ph_dyn_ent]
+ tag_list = [
+ get_ph_dynamic_ent_tag_type(ph.d_tag) for ph in self.ph_dyn_ent
+ ]
un_list = [ph.d_un for ph in self.ph_dyn_ent]
lines = ffs(2, header, True, tag_list, un_list)
for line in lines:
@@ -1306,8 +1450,9 @@ class ELF(object):
for iter in self.string_tb_e:
if iter.st_type == ELF_ST_TYPE.STT_FUNC:
self.so.seek(int.from_bytes(iter.st_value, byteorder="little"))
- obj = self.so.read(int.from_bytes(
- iter.st_size, byteorder="little"))
+ obj = self.so.read(
+ int.from_bytes(iter.st_size, byteorder="little")
+ )
ret_list.append(obj)
for byte in obj:
dummy.append(int(byte))
@@ -1325,8 +1470,13 @@ class ELF(object):
ret_list = []
for entry in self.string_tb_e:
if entry.st_type == stt_type:
- ret_list.append("".join(self.get_st_entry_symbol_string(
- byte2int(entry.st_name), ".strtab")))
+ ret_list.append(
+ "".join(
+ self.get_st_entry_symbol_string(
+ byte2int(entry.st_name), ".strtab"
+ )
+ )
+ )
if dump_b:
for name in ret_list:
print(name)
@@ -1349,23 +1499,23 @@ class ELF(object):
if count % 16 == 0:
for ch in strrep:
if ord(ch) > 32 and ord(ch) < 127:
- print(ch, end='')
+ print(ch, end="")
else:
print(" ", end="")
print()
strrep = []
- print(format(count, "06x"), ': ', end='')
+ print(format(count, "06x"), ": ", end="")
strrep.append(str(chr(byte)))
- print(format(byte, '02x') + ' ', end='')
+ print(format(byte, "02x") + " ", end="")
else:
strrep += str(chr(byte))
- print(format(byte, '02x') + ' ', end='')
+ print(format(byte, "02x") + " ", end="")
count += 1
- for i in range(0, 16-count % 16):
+ for i in range(0, 16 - count % 16):
print(" ", end="")
for ch in strrep:
if ord(ch) > 32 and ord(ch) < 127:
- print(ch, end='')
+ print(ch, end="")
else:
print(" ", end="")
print()
@@ -1376,8 +1526,12 @@ class ELF(object):
# print(ret_dummy)
return ret_dummy
if not hit:
- print(Colors.red + Colors.BOLD +
- "section is not present" + Colors.ENDC)
+ print(
+ Colors.red
+ + Colors.BOLD
+ + "section is not present"
+ + Colors.ENDC
+ )
def dump_obj_size(self, stt_type, dump_b):
ret_list = []
@@ -1397,8 +1551,17 @@ class ELF(object):
info_list = [byte2int(st.st_info) for st in self.string_tb_e]
other_list = [byte2int(st.st_other) for st in self.string_tb_e]
shndx_list = [byte2int(st.st_shndx) for st in self.string_tb_e]
- lines = ffs(2, header, True, name_list, size_list,
- value_list, info_list, other_list, shndx_list)
+ lines = ffs(
+ 2,
+ header,
+ True,
+ name_list,
+ size_list,
+ value_list,
+ info_list,
+ other_list,
+ shndx_list,
+ )
print(Colors.green + Colors.BOLD + "symbol:" + Colors.ENDC)
for line in lines:
print(line)
@@ -1410,17 +1573,44 @@ class ELF(object):
info_list = [byte2int(st.st_info) for st in self.string_tb_e_dyn]
other_list = [byte2int(st.st_other) for st in self.string_tb_e_dyn]
shndx_list = [byte2int(st.st_shndx) for st in self.string_tb_e_dyn]
- lines = ffs(2, header, True, name_list, size_list,
- value_list, info_list, other_list, shndx_list)
+ lines = ffs(
+ 2,
+ header,
+ True,
+ name_list,
+ size_list,
+ value_list,
+ info_list,
+ other_list,
+ shndx_list,
+ )
for line in lines:
print(line)
def dump_header(self):
- header = ["ei_mag", "ei_class", "ei_data", "ei_version", "ei_osabi",
- "ei_abiversion", "ei_pad", "e_type", "e_machine",
- "e_version", "e_version", "e_entry", "e_phoff", "e_shoff",
- "e_flags", "e_entsize", "e_phentsize", "e_phnum",
- "e_shentsize", "e_shnum", "e_shstrndx"]
+ header = [
+ "ei_mag",
+ "ei_class",
+ "ei_data",
+ "ei_version",
+ "ei_osabi",
+ "ei_abiversion",
+ "ei_pad",
+ "e_type",
+ "e_machine",
+ "e_version",
+ "e_version",
+ "e_entry",
+ "e_phoff",
+ "e_shoff",
+ "e_flags",
+ "e_entsize",
+ "e_phentsize",
+ "e_phnum",
+ "e_shentsize",
+ "e_shnum",
+ "e_shstrndx",
+ ]
mag_list = [self.elfhdr.ei_mag]
class_list = [byte2int(self.elfhdr.ei_class)]
data_list = [byte2int(self.elfhdr.ei_data)]
@@ -1441,22 +1631,52 @@ class ELF(object):
shentsize_list = [byte2int(self.elfhdr.e_shentsize)]
shnum_list = [byte2int(self.elfhdr.e_shnum)]
shstrndx_list = [byte2int(self.elfhdr.e_shstrndx)]
- lines = ffs(2, header, True, mag_list, class_list, data_list,
- version_list, osabi_list, abiversion_list,
- pad_list, type_list, machine_list, version_list,
- entry_list, phoff_list, shoff_list,
- flags_list, ehsize_list, phentsize_list, phnum_list,
- shentsize_list, phnum_list, shentsize_list,
- shnum_list, shstrndx_list)
+ lines = ffs(
+ 2,
+ header,
+ True,
+ mag_list,
+ class_list,
+ data_list,
+ version_list,
+ osabi_list,
+ abiversion_list,
+ pad_list,
+ type_list,
+ machine_list,
+ version_list,
+ entry_list,
+ phoff_list,
+ shoff_list,
+ flags_list,
+ ehsize_list,
+ phentsize_list,
+ phnum_list,
+ shentsize_list,
+ phnum_list,
+ shentsize_list,
+ shnum_list,
+ shstrndx_list,
+ )
for line in lines:
print(line)
def dump_phdrs(self):
- header = ["p_type", "p_flags", "p_offset", "p_vaddr",
- "p_paddr", "p_filesz", "p_memsz", "p_flags2", "p_align"]
+ header = [
+ "p_type",
+ "p_flags",
+ "p_offset",
+ "p_vaddr",
+ "p_paddr",
+ "p_filesz",
+ "p_memsz",
+ "p_flags2",
+ "p_align",
+ ]
type_list = [get_ph_type(byte2int(phdr.p_type)) for phdr in self.phdr]
- flags_list = [get_elf_seg_flag(byte2int(phdr.p_type))
- for phdr in self.phdr]
+ flags_list = [
+ get_elf_seg_flag(byte2int(phdr.p_type)) for phdr in self.phdr
+ ]
offset_list = [byte2int(phdr.p_offset) for phdr in self.phdr]
vaddr_list = [byte2int(phdr.p_vaddr) for phdr in self.phdr]
paddr_list = [byte2int(phdr.p_paddr) for phdr in self.phdr]
@@ -1465,20 +1685,44 @@ class ELF(object):
flags2_list = [phdr.p_flags2 for phdr in self.phdr]
align_list = [byte2hex(phdr.p_align) for phdr in self.phdr]
- lines = ffs(2, header, True, type_list, flags_list, offset_list,
- vaddr_list, paddr_list, filesz_list, memsz_list,
- flags2_list, align_list)
+ lines = ffs(
+ 2,
+ header,
+ True,
+ type_list,
+ flags_list,
+ offset_list,
+ vaddr_list,
+ paddr_list,
+ filesz_list,
+ memsz_list,
+ flags2_list,
+ align_list,
+ )
for line in lines:
print(line)
def dump_shdrs(self):
- header = ["sh_name", "sh_type", "sh_flags", "sh_addr", "sh_offset",
- "sh_size", "sh_link", "sh_info", "sh_addralign",
- "sh_entsize"]
- name_list = [self.read_section_name(
- byte2int(shhdr.sh_name)) for shhdr in self.shhdr]
- type_list = [get_section_type_string(
- byte2int(shhdr.sh_type)) for shhdr in self.shhdr]
+ header = [
+ "sh_name",
+ "sh_type",
+ "sh_flags",
+ "sh_addr",
+ "sh_offset",
+ "sh_size",
+ "sh_link",
+ "sh_info",
+ "sh_addralign",
+ "sh_entsize",
+ ]
+ name_list = [
+ self.read_section_name(byte2int(shhdr.sh_name))
+ for shhdr in self.shhdr
+ ]
+ type_list = [
+ get_section_type_string(byte2int(shhdr.sh_type))
+ for shhdr in self.shhdr
+ ]
flag_list = [byte2int(shhdr.sh_flags) for shhdr in self.shhdr]
addr_list = [byte2int(shhdr.sh_addr) for shhdr in self.shhdr]
offset_list = [byte2int(shhdr.sh_offset) for shhdr in self.shhdr]
@@ -1488,71 +1732,148 @@ class ELF(object):
allign_list = [byte2int(shhdr.sh_addralign) for shhdr in self.shhdr]
entsize_list = [byte2int(shhdr.sh_entsize) for shhdr in self.shhdr]
- lines = ffs(2, header, True, name_list, type_list, flag_list,
- addr_list, offset_list, size_list, link_list,
- info_list, allign_list, entsize_list)
+ lines = ffs(
+ 2,
+ header,
+ True,
+ name_list,
+ type_list,
+ flag_list,
+ addr_list,
+ offset_list,
+ size_list,
+ link_list,
+ info_list,
+ allign_list,
+ entsize_list,
+ )
for line in lines:
print(line)
def dump_symbol_tb(self, name, type):
for i in range(0, byte2int(self.elfhdr.e_shnum)):
if byte2int(self.shhdr[i].sh_type) == type:
- if (name == self.read_section_name(
- byte2int(self.shhdr[i].sh_name))):
- print(Colors.BOLD + Colors.yellow +
- "STRING TABLE:" + Colors.ENDC)
+ if name == self.read_section_name(
+ byte2int(self.shhdr[i].sh_name)
+ ):
+ print(
+ Colors.BOLD
+ + Colors.yellow
+ + "STRING TABLE:"
+ + Colors.ENDC
+ )
self.so.seek(byte2int(self.shhdr[i].sh_offset), 0)
symbol_tb = self.so.read(byte2int(self.shhdr[i].sh_size))
for byte in symbol_tb:
- print(chr(byte), end='')
- if chr(byte) == '\0':
+ print(chr(byte), end="")
+ if chr(byte) == "\0":
print()
def dump_st_entries(self):
- header = ["name_index", "name", "value", "size",
- "info", "other", "shndx", "bind", "type"]
+ header = [
+ "name_index",
+ "name",
+ "value",
+ "size",
+ "info",
+ "other",
+ "shndx",
+ "bind",
+ "type",
+ ]
idx_list = [byte2int(entry.st_name) for entry in self.string_tb_e]
- name_list = ["".join(self.get_st_entry_symbol_string(
- byte2int(entry.st_name), ".strtab")) for entry in self.string_tb_e]
+ name_list = [
+ "".join(
+ self.get_st_entry_symbol_string(
+ byte2int(entry.st_name), ".strtab"
+ )
+ )
+ for entry in self.string_tb_e
+ ]
value_list = [byte2int(entry.st_value) for entry in self.string_tb_e]
size_list = [byte2int(entry.st_size) for entry in self.string_tb_e]
info_list = [byte2int(entry.st_info) for entry in self.string_tb_e]
other_list = [byte2int(entry.st_other) for entry in self.string_tb_e]
shndx_list = [byte2int(entry.st_shndx) for entry in self.string_tb_e]
- bind_list = [get_elf_st_bind_string(
- entry.st_bind) for entry in self.string_tb_e]
- type_list = [get_elf_st_type_string(
- entry.st_type) for entry in self.string_tb_e]
-
- lines = ffs(2, header, True, idx_list, name_list, value_list,
- size_list, info_list, other_list, shndx_list, bind_list,
- type_list)
+ bind_list = [
+ get_elf_st_bind_string(entry.st_bind) for entry in self.string_tb_e
+ ]
+ type_list = [
+ get_elf_st_type_string(entry.st_type) for entry in self.string_tb_e
+ ]
+
+ lines = ffs(
+ 2,
+ header,
+ True,
+ idx_list,
+ name_list,
+ value_list,
+ size_list,
+ info_list,
+ other_list,
+ shndx_list,
+ bind_list,
+ type_list,
+ )
for line in lines:
print(line)
def dump_st_entries_dyn(self):
- header = ["name_index", "name", "value", "size",
- "info", "other", "shndx", "bind", "type"]
+ header = [
+ "name_index",
+ "name",
+ "value",
+ "size",
+ "info",
+ "other",
+ "shndx",
+ "bind",
+ "type",
+ ]
idx_list = [byte2int(entry.st_name) for entry in self.string_tb_e_dyn]
- name_list = ["".join(self.get_st_entry_symbol_string(
- byte2int(entry.st_name), ".dynstr"))
- for entry in self.string_tb_e_dyn]
- value_list = [byte2int(entry.st_value)
- for entry in self.string_tb_e_dyn]
+ name_list = [
+ "".join(
+ self.get_st_entry_symbol_string(
+ byte2int(entry.st_name), ".dynstr"
+ )
+ )
+ for entry in self.string_tb_e_dyn
+ ]
+ value_list = [
+ byte2int(entry.st_value) for entry in self.string_tb_e_dyn
+ ]
size_list = [byte2int(entry.st_size) for entry in self.string_tb_e_dyn]
info_list = [byte2int(entry.st_info) for entry in self.string_tb_e_dyn]
- other_list = [byte2int(entry.st_other)
- for entry in self.string_tb_e_dyn]
- shndx_list = [byte2int(entry.st_shndx)
- for entry in self.string_tb_e_dyn]
- bind_list = [get_elf_st_bind_string(
- entry.st_bind) for entry in self.string_tb_e_dyn]
- type_list = [get_elf_st_type_string(
- entry.st_type) for entry in self.string_tb_e_dyn]
-
- lines = ffs(2, header, True, idx_list, name_list, value_list,
- size_list, info_list, other_list, shndx_list, bind_list,
- type_list)
+ other_list = [
+ byte2int(entry.st_other) for entry in self.string_tb_e_dyn
+ ]
+ shndx_list = [
+ byte2int(entry.st_shndx) for entry in self.string_tb_e_dyn
+ ]
+ bind_list = [
+ get_elf_st_bind_string(entry.st_bind)
+ for entry in self.string_tb_e_dyn
+ ]
+ type_list = [
+ get_elf_st_type_string(entry.st_type)
+ for entry in self.string_tb_e_dyn
+ ]
+
+ lines = ffs(
+ 2,
+ header,
+ True,
+ idx_list,
+ name_list,
+ value_list,
+ size_list,
+ info_list,
+ other_list,
+ shndx_list,
+ bind_list,
+ type_list,
+ )
for line in lines:
print(line)
@@ -1562,8 +1883,15 @@ class ELF(object):
tag_list = [entry["tag"] for entry in who]
value_list = [entry["value"] for entry in who]
value_list_hex = [hex(entry["value"]) for entry in who]
- lines = ffs(2, header, True, tag_string_list,
- tag_list, value_list, value_list_hex)
+ lines = ffs(
+ 2,
+ header,
+ True,
+ tag_string_list,
+ tag_list,
+ value_list,
+ value_list_hex,
+ )
for line in lines:
print(line)
@@ -1588,8 +1916,10 @@ class ELF(object):
symbol = []
for i in range(0, byte2int(self.elfhdr.e_shnum)):
name = self.read_section_name(byte2int(self.shhdr[i].sh_name))
- if (byte2int(self.shhdr[i].sh_type) == sh_type_e.SHT_STRTAB and
- name == section_name):
+ if (
+ byte2int(self.shhdr[i].sh_type) == sh_type_e.SHT_STRTAB
+ and name == section_name
+ ):
self.so.seek(byte2int(self.shhdr[i].sh_offset) + index, 0)
byte = self.so.read(1)
while chr(byte[0]) != "\0":
@@ -1600,14 +1930,28 @@ class ELF(object):
def get_symbol_string_table(self, offset):
symbol = []
- for i in range(0, int.from_bytes(self.elfhdr.e_shnum,
- byteorder="little", signed=False)):
- if (int.from_bytes(self.shhdr[i].sh_type,
- byteorder="little",
- signed=False) == sh_type_e.SHT_STRTAB):
- self.so.seek(int.from_bytes(
- self.shhdr[i].sh_offset, byteorder="little",
- signed=False) + offset - 0, 0)
+ for i in range(
+ 0,
+ int.from_bytes(
+ self.elfhdr.e_shnum, byteorder="little", signed=False
+ ),
+ ):
+ if (
+ int.from_bytes(
+ self.shhdr[i].sh_type, byteorder="little", signed=False
+ )
+ == sh_type_e.SHT_STRTAB
+ ):
+ self.so.seek(
+ int.from_bytes(
+ self.shhdr[i].sh_offset,
+ byteorder="little",
+ signed=False,
+ )
+ + offset
+ - 0,
+ 0,
+ )
byte = self.so.read(1)
while chr(byte[0]) != "\0":
if chr(byte[0]) != "\0":
@@ -1618,11 +1962,16 @@ class ELF(object):
def dump_inst_sections(self):
indices = []
for section in self.shhdr:
- if (int.from_bytes(section.sh_flags,
- byteorder="little", signed=False) &
- sh_flags_e.SHF_EXECINSTR == sh_flags_e.SHF_EXECINSTR):
- indices.append(int.from_bytes(
- section.sh_name, byteorder="little"))
+ if (
+ int.from_bytes(
+ section.sh_flags, byteorder="little", signed=False
+ )
+ & sh_flags_e.SHF_EXECINSTR
+ == sh_flags_e.SHF_EXECINSTR
+ ):
+ indices.append(
+ int.from_bytes(section.sh_name, byteorder="little")
+ )
return indices
def pop_data_section(self):
@@ -1653,13 +2002,16 @@ class ELF(object):
jmp_val = 4
else:
jmp_val = 8
- print("self.size is not set for class "
- "elf.going with 8 as a default.")
- for offset in range(0, length, jmp_val*2):
- tag_type = byte2int(self.dyn_section[offset:offset+jmp_val])
+ print(
+ "self.size is not set for class "
+ "elf.going with 8 as a default."
+ )
+ for offset in range(0, length, jmp_val * 2):
+ tag_type = byte2int(self.dyn_section[offset : offset + jmp_val])
dummy["tag"] = tag_type
value = byte2int(
- self.dyn_section[offset+jmp_val:offset+(jmp_val*2)])
+ self.dyn_section[offset + jmp_val : offset + (jmp_val * 2)]
+ )
dummy["value"] = value
type_string = get_ph_dynamic_ent_tag_type(tag_type)
dummy["type_string"] = type_string
@@ -1684,14 +2036,21 @@ class ELF(object):
size = byte2int(section.sh_size)
entsize = byte2int(section.sh_entsize)
if entsize != 0:
- for i in range(0, int(size/entsize)):
+ for i in range(0, int(size / entsize)):
dummy["r_offset"] = byte2int(
- section_whole[i*entsize:i*entsize+step])
+ section_whole[i * entsize : i * entsize + step]
+ )
dummy["r_info"] = byte2int(
- section_whole[i*entsize+step:i*entsize+(step*2)])
+ section_whole[
+ i * entsize + step : i * entsize + (step * 2)
+ ]
+ )
dummy["r_addend"] = byte2int(
- section_whole[i*entsize+(step*2):i*entsize+(step*3)],
- sign=True)
+ section_whole[
+ i * entsize + (step * 2) : i * entsize + (step * 3)
+ ],
+ sign=True,
+ )
to_pop.append(dummy)
dummy = {}
@@ -1711,11 +2070,13 @@ class ELF(object):
section_whole = self.so.read(byte2int(section.sh_size))
size = byte2int(section.sh_size)
entsize = byte2int(section.sh_entsize)
- for i in range(0, int(size/entsize)):
+ for i in range(0, int(size / entsize)):
dummy["r_offset"] = byte2int(
- section_whole[i*entsize:i*entsize+step])
+ section_whole[i * entsize : i * entsize + step]
+ )
dummy["r_info"] = byte2int(
- section_whole[i*entsize+step:i*entsize+(step*2)])
+ section_whole[i * entsize + step : i * entsize + (step * 2)]
+ )
to_pop.append(dummy)
dummy = {}
@@ -1727,7 +2088,7 @@ class ELF(object):
self.so.seek(byte2int(shhdr.sh_offset))
self.got = self.so.read(byte2int(shhdr.sh_size))
self.so.seek(byte2int(shhdr.sh_offset))
- for i in range(0, int(byte2int(shhdr.sh_size)/8)):
+ for i in range(0, int(byte2int(shhdr.sh_size) / 8)):
self.got_ents.append(byte2int(self.so.read(8)))
# FIXME-ELF64 only
@@ -1738,7 +2099,7 @@ class ELF(object):
self.so.seek(byte2int(shhdr.sh_offset))
self.got_plt = self.so.read(byte2int(shhdr.sh_size))
self.so.seek(byte2int(shhdr.sh_offset))
- for i in range(0, int(byte2int(shhdr.sh_size)/8)):
+ for i in range(0, int(byte2int(shhdr.sh_size) / 8)):
self.got_plt_ents.append(byte2int(self.so.read(8)))
def dump_got(self):
@@ -1756,7 +2117,7 @@ class ELF(object):
print(line)
-class obj_loader():
+class obj_loader:
def __init__(self, bytes):
self.memory = bytes()
@@ -1814,6 +2175,7 @@ def elf_get_rodata_section():
elf.init(64)
return elf.dump_section(".rodata", False)
+
# obj here means variables or what the C standard means by objects
@@ -1823,6 +2185,7 @@ def elf_get_obj_names():
elf.init(64)
return elf.dump_symbol_string(ELF_ST_TYPE.STT_OBJECT, False)
+
# obj here means variables or what the C standard means by objects
@@ -1889,13 +2252,15 @@ class Rewriter(object):
self.shdr_new_size = []
self.shdr_new_offset = []
- def fix_section_offsets(self, section_name, new_size: int,
- new_section: bytes):
+ def fix_section_offsets(
+ self, section_name, new_size: int, new_section: bytes
+ ):
# file_w = open(self.new_name, "wb")
# magic_number = int()
for i in range(0, byte2int(self.elf.elfhdr.e_shnum)):
name = self.elf.read_section_name(
- byte2int(self.elf.shhdr[i].sh_name))
+ byte2int(self.elf.shhdr[i].sh_name)
+ )
if section_name == name:
self.magic_section_number = i
print(self.magic_section_number)
@@ -1908,23 +2273,27 @@ class Rewriter(object):
for i in range(0, byte2int(self.elf.elfhdr.e_shnum)):
if i > self.magic_section_number:
extra_chunk = end % byte2int(self.elf.shhdr[i].sh_addralign)
- missing_chunk = byte2int(
- self.elf.shhdr[i].sh_addralign) - extra_chunk
+ missing_chunk = (
+ byte2int(self.elf.shhdr[i].sh_addralign) - extra_chunk
+ )
assert missing_chunk > 0, "missing chunk is negative"
self.shdr_new_size.append(byte2int(self.elf.shhdr[i].sh_size))
self.shdr_new_offset.append(
- end + missing_chunk %
- byte2int(self.elf.shhdr[i].sh_addralign))
+ end
+ + missing_chunk % byte2int(self.elf.shhdr[i].sh_addralign)
+ )
end = self.shdr_new_offset[-1] + self.shdr_new_size[-1]
elif i < self.magic_section_number:
self.shdr_new_size.append(byte2int(self.elf.shhdr[i].sh_size))
self.shdr_new_offset.append(
- byte2int(self.elf.shhdr[i].sh_offset))
+ byte2int(self.elf.shhdr[i].sh_offset)
+ )
elif i == self.magic_section_number:
self.shdr_new_size.append(new_size)
self.shdr_new_offset.append(
- byte2int(self.elf.shhdr[i].sh_offset))
+ byte2int(self.elf.shhdr[i].sh_offset)
+ )
end = byte2int(self.elf.shhdr[i].sh_offset) + new_size
for size in self.shdr_new_size:
print(repr(i) + " new size is " + repr(size))
@@ -1964,7 +2333,7 @@ def premain(argparser):
elif argparser.args.test2:
rewriter = Rewriter(argparser.args.obj, "new_exe")
new_text = bytes()
- rewriter.fix_section_offsets(".text", 1000, new_text)
+ rewriter.fix_section_offsets(".text", 1000, new_text)
elif argparser.args.dumpfunc:
counter = 0
for name in elf.dump_symbol_string(ELF_ST_TYPE.STT_FUNC, False):
@@ -1994,19 +2363,23 @@ def premain(argparser):
if byte2int(section.sh_flags) & 0x4 != 0x04:
print(
"section is not executable...but, "
- "since you asked, here you go...")
+ "since you asked, here you go..."
+ )
elf.so.seek(byte2int(section.sh_offset))
code = elf.so.read(byte2int(section.sh_size))
md = Cs(CS_ARCH_X86, CS_MODE_64)
for i in md.disasm(bytes(code), 0x0):
- print(hex(i.address).ljust(7),
- i.mnemonic.ljust(7), i.op_str)
+ print(
+ hex(i.address).ljust(7), i.mnemonic.ljust(7), i.op_str
+ )
elif argparser.args.disassp is not None:
index = argparser.args.disassp
# section not executable message
if byte2int(elf.phdr[index].p_flags) & 0x1 != 1:
- print("program header section is not "
- "executable but since you asked...")
+ print(
+ "program header section is not "
+ "executable but since you asked..."
+ )
header_offset = elf.phdr[index].p_offset
header_size = elf.phdr[index].p_filesz
elf.so.seek(byte2int(header_offset))
@@ -2030,6 +2403,25 @@ def premain(argparser):
elif argparser.args.gotplt:
elf.pop_got_plt()
elf.dump_got_plt()
+ elif argparser.args.listdso:
+ os.environ["LD_TRACE_LOADED_OBJECTS"] = "1"
+ os.environ["LD_WARN"] = "yes"
+ os.environ["LD_BIND_NOW"] = "yes"
+ # os.environ["LD_VERBOSE"] = "yes"
+ # os.environ["LD_DEBUG"] = "all"
+ rtldlist = [
+ "/usr/lib/ld-linux.so.2",
+ "/usr/lib64/ld-linux-x86-64.so.2",
+ "/usr/libx32/ld-linux-x32.so.2",
+ ]
+ for rtld in rtldlist:
+ if os.path.exists(rtld):
+ result = subprocess.run(
+ [rtld, argparser.args.obj],
+ capture_output=True,
+ )
+ print(result.stdout.decode("utf-8"))
+ break
else:
print("why even bother if you were not gonna type anythng decent in?")
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 16:54:00 +0000