1637 lines
46 KiB
Python
1637 lines
46 KiB
Python
"""
|
|
Other than changing the load commands in such a way that they do not
|
|
contain the load command itself, this is largely a by-hand conversion
|
|
of the C headers. Hopefully everything in here should be at least as
|
|
obvious as the C headers, and you should be using the C headers as a real
|
|
reference because the documentation didn't come along for the ride.
|
|
|
|
Doing much of anything with the symbol tables or segments is really
|
|
not covered at this point.
|
|
|
|
See /usr/include/mach-o and friends.
|
|
"""
|
|
|
|
import time
|
|
|
|
from macholib.ptypes import (
|
|
Structure,
|
|
p_int32,
|
|
p_int64,
|
|
p_long,
|
|
p_short,
|
|
p_uint8,
|
|
p_uint32,
|
|
p_uint64,
|
|
p_ulong,
|
|
pypackable,
|
|
)
|
|
|
|
_CPU_ARCH_ABI64 = 0x01000000
|
|
|
|
CPU_TYPE_NAMES = {
|
|
-1: "ANY",
|
|
1: "VAX",
|
|
6: "MC680x0",
|
|
7: "i386",
|
|
_CPU_ARCH_ABI64 | 7: "x86_64",
|
|
8: "MIPS",
|
|
10: "MC98000",
|
|
11: "HPPA",
|
|
12: "ARM",
|
|
_CPU_ARCH_ABI64 | 12: "ARM64",
|
|
13: "MC88000",
|
|
14: "SPARC",
|
|
15: "i860",
|
|
16: "Alpha",
|
|
18: "PowerPC",
|
|
_CPU_ARCH_ABI64 | 18: "PowerPC64",
|
|
}
|
|
|
|
INTEL64_SUBTYPE = {
|
|
3: "CPU_SUBTYPE_X86_64_ALL",
|
|
4: "CPU_SUBTYPE_X86_ARCH1",
|
|
8: "CPU_SUBTYPE_X86_64_H",
|
|
}
|
|
|
|
# define CPU_SUBTYPE_INTEL(f, m) ((cpu_subtype_t) (f) + ((m) << 4))
|
|
INTEL_SUBTYPE = {
|
|
0: "CPU_SUBTYPE_INTEL_MODEL_ALL",
|
|
1: "CPU_THREADTYPE_INTEL_HTT",
|
|
3: "CPU_SUBTYPE_I386_ALL",
|
|
4: "CPU_SUBTYPE_486",
|
|
5: "CPU_SUBTYPE_586",
|
|
8: "CPU_SUBTYPE_PENTIUM_3",
|
|
9: "CPU_SUBTYPE_PENTIUM_M",
|
|
10: "CPU_SUBTYPE_PENTIUM_4",
|
|
11: "CPU_SUBTYPE_ITANIUM",
|
|
12: "CPU_SUBTYPE_XEON",
|
|
34: "CPU_SUBTYPE_XEON_MP",
|
|
42: "CPU_SUBTYPE_PENTIUM_4_M",
|
|
43: "CPU_SUBTYPE_ITANIUM_2",
|
|
38: "CPU_SUBTYPE_PENTPRO",
|
|
40: "CPU_SUBTYPE_PENTIUM_3_M",
|
|
52: "CPU_SUBTYPE_PENTIUM_3_XEON",
|
|
102: "CPU_SUBTYPE_PENTII_M3",
|
|
132: "CPU_SUBTYPE_486SX",
|
|
166: "CPU_SUBTYPE_PENTII_M5",
|
|
199: "CPU_SUBTYPE_CELERON",
|
|
231: "CPU_SUBTYPE_CELERON_MOBILE",
|
|
}
|
|
|
|
MC680_SUBTYPE = {
|
|
1: "CPU_SUBTYPE_MC680x0_ALL",
|
|
2: "CPU_SUBTYPE_MC68040",
|
|
3: "CPU_SUBTYPE_MC68030_ONLY",
|
|
}
|
|
|
|
MIPS_SUBTYPE = {
|
|
0: "CPU_SUBTYPE_MIPS_ALL",
|
|
1: "CPU_SUBTYPE_MIPS_R2300",
|
|
2: "CPU_SUBTYPE_MIPS_R2600",
|
|
3: "CPU_SUBTYPE_MIPS_R2800",
|
|
4: "CPU_SUBTYPE_MIPS_R2000a",
|
|
5: "CPU_SUBTYPE_MIPS_R2000",
|
|
6: "CPU_SUBTYPE_MIPS_R3000a",
|
|
7: "CPU_SUBTYPE_MIPS_R3000",
|
|
}
|
|
|
|
MC98000_SUBTYPE = {0: "CPU_SUBTYPE_MC98000_ALL", 1: "CPU_SUBTYPE_MC98601"}
|
|
|
|
HPPA_SUBTYPE = {0: "CPU_SUBTYPE_HPPA_7100", 1: "CPU_SUBTYPE_HPPA_7100LC"}
|
|
|
|
MC88_SUBTYPE = {
|
|
0: "CPU_SUBTYPE_MC88000_ALL",
|
|
1: "CPU_SUBTYPE_MC88100",
|
|
2: "CPU_SUBTYPE_MC88110",
|
|
}
|
|
|
|
SPARC_SUBTYPE = {0: "CPU_SUBTYPE_SPARC_ALL"}
|
|
|
|
I860_SUBTYPE = {0: "CPU_SUBTYPE_I860_ALL", 1: "CPU_SUBTYPE_I860_860"}
|
|
|
|
POWERPC_SUBTYPE = {
|
|
0: "CPU_SUBTYPE_POWERPC_ALL",
|
|
1: "CPU_SUBTYPE_POWERPC_601",
|
|
2: "CPU_SUBTYPE_POWERPC_602",
|
|
3: "CPU_SUBTYPE_POWERPC_603",
|
|
4: "CPU_SUBTYPE_POWERPC_603e",
|
|
5: "CPU_SUBTYPE_POWERPC_603ev",
|
|
6: "CPU_SUBTYPE_POWERPC_604",
|
|
7: "CPU_SUBTYPE_POWERPC_604e",
|
|
8: "CPU_SUBTYPE_POWERPC_620",
|
|
9: "CPU_SUBTYPE_POWERPC_750",
|
|
10: "CPU_SUBTYPE_POWERPC_7400",
|
|
11: "CPU_SUBTYPE_POWERPC_7450",
|
|
100: "CPU_SUBTYPE_POWERPC_970",
|
|
}
|
|
|
|
ARM_SUBTYPE = {
|
|
0: "CPU_SUBTYPE_ARM_ALL12",
|
|
5: "CPU_SUBTYPE_ARM_V4T",
|
|
6: "CPU_SUBTYPE_ARM_V6",
|
|
7: "CPU_SUBTYPE_ARM_V5TEJ",
|
|
8: "CPU_SUBTYPE_ARM_XSCALE",
|
|
9: "CPU_SUBTYPE_ARM_V7",
|
|
10: "CPU_SUBTYPE_ARM_V7F",
|
|
11: "CPU_SUBTYPE_ARM_V7S",
|
|
12: "CPU_SUBTYPE_ARM_V7K",
|
|
13: "CPU_SUBTYPE_ARM_V8",
|
|
14: "CPU_SUBTYPE_ARM_V6M",
|
|
15: "CPU_SUBTYPE_ARM_V7M",
|
|
16: "CPU_SUBTYPE_ARM_V7EM",
|
|
}
|
|
|
|
ARM64_SUBTYPE = {0: "CPU_SUBTYPE_ARM64_ALL", 1: "CPU_SUBTYPE_ARM64_V8"}
|
|
|
|
VAX_SUBTYPE = {
|
|
0: "CPU_SUBTYPE_VAX_ALL",
|
|
1: "CPU_SUBTYPE_VAX780",
|
|
2: "CPU_SUBTYPE_VAX785",
|
|
3: "CPU_SUBTYPE_VAX750",
|
|
4: "CPU_SUBTYPE_VAX730",
|
|
5: "CPU_SUBTYPE_UVAXI",
|
|
6: "CPU_SUBTYPE_UVAXII",
|
|
7: "CPU_SUBTYPE_VAX8200",
|
|
8: "CPU_SUBTYPE_VAX8500",
|
|
9: "CPU_SUBTYPE_VAX8600",
|
|
10: "CPU_SUBTYPE_VAX8650",
|
|
11: "CPU_SUBTYPE_VAX8800",
|
|
12: "CPU_SUBTYPE_UVAXIII",
|
|
}
|
|
|
|
|
|
def get_cpu_subtype(cpu_type, cpu_subtype):
|
|
st = cpu_subtype & 0x0FFFFFFF
|
|
|
|
if cpu_type == 1:
|
|
subtype = VAX_SUBTYPE.get(st, st)
|
|
elif cpu_type == 6:
|
|
subtype = MC680_SUBTYPE.get(st, st)
|
|
elif cpu_type == 7:
|
|
subtype = INTEL_SUBTYPE.get(st, st)
|
|
elif cpu_type == 7 | _CPU_ARCH_ABI64:
|
|
subtype = INTEL64_SUBTYPE.get(st, st)
|
|
elif cpu_type == 8:
|
|
subtype = MIPS_SUBTYPE.get(st, st)
|
|
elif cpu_type == 10:
|
|
subtype = MC98000_SUBTYPE.get(st, st)
|
|
elif cpu_type == 11:
|
|
subtype = HPPA_SUBTYPE.get(st, st)
|
|
elif cpu_type == 12:
|
|
subtype = ARM_SUBTYPE.get(st, st)
|
|
elif cpu_type == 12 | _CPU_ARCH_ABI64:
|
|
subtype = ARM64_SUBTYPE.get(st, st)
|
|
elif cpu_type == 13:
|
|
subtype = MC88_SUBTYPE.get(st, st)
|
|
elif cpu_type == 14:
|
|
subtype = SPARC_SUBTYPE.get(st, st)
|
|
elif cpu_type == 15:
|
|
subtype = I860_SUBTYPE.get(st, st)
|
|
elif cpu_type == 16:
|
|
subtype = MIPS_SUBTYPE.get(st, st)
|
|
elif cpu_type == 18:
|
|
subtype = POWERPC_SUBTYPE.get(st, st)
|
|
elif cpu_type == 18 | _CPU_ARCH_ABI64:
|
|
subtype = POWERPC_SUBTYPE.get(st, st)
|
|
else:
|
|
subtype = str(st)
|
|
|
|
return subtype
|
|
|
|
|
|
_MH_EXECUTE_SYM = "__mh_execute_header"
|
|
MH_EXECUTE_SYM = "_mh_execute_header"
|
|
_MH_BUNDLE_SYM = "__mh_bundle_header"
|
|
MH_BUNDLE_SYM = "_mh_bundle_header"
|
|
_MH_DYLIB_SYM = "__mh_dylib_header"
|
|
MH_DYLIB_SYM = "_mh_dylib_header"
|
|
_MH_DYLINKER_SYM = "__mh_dylinker_header"
|
|
MH_DYLINKER_SYM = "_mh_dylinker_header"
|
|
|
|
(
|
|
MH_OBJECT,
|
|
MH_EXECUTE,
|
|
MH_FVMLIB,
|
|
MH_CORE,
|
|
MH_PRELOAD,
|
|
MH_DYLIB,
|
|
MH_DYLINKER,
|
|
MH_BUNDLE,
|
|
MH_DYLIB_STUB,
|
|
MH_DSYM,
|
|
) = range(0x1, 0xB)
|
|
|
|
MH_FILESET = 0xC
|
|
|
|
(
|
|
MH_NOUNDEFS,
|
|
MH_INCRLINK,
|
|
MH_DYLDLINK,
|
|
MH_BINDATLOAD,
|
|
MH_PREBOUND,
|
|
MH_SPLIT_SEGS,
|
|
MH_LAZY_INIT,
|
|
MH_TWOLEVEL,
|
|
MH_FORCE_FLAT,
|
|
MH_NOMULTIDEFS,
|
|
MH_NOFIXPREBINDING,
|
|
MH_PREBINDABLE,
|
|
MH_ALLMODSBOUND,
|
|
MH_SUBSECTIONS_VIA_SYMBOLS,
|
|
MH_CANONICAL,
|
|
MH_WEAK_DEFINES,
|
|
MH_BINDS_TO_WEAK,
|
|
MH_ALLOW_STACK_EXECUTION,
|
|
MH_ROOT_SAFE,
|
|
MH_SETUID_SAFE,
|
|
MH_NO_REEXPORTED_DYLIBS,
|
|
MH_PIE,
|
|
MH_DEAD_STRIPPABLE_DYLIB,
|
|
MH_HAS_TLV_DESCRIPTORS,
|
|
MH_NO_HEAP_EXECUTION,
|
|
MH_APP_EXTENSION_SAFE,
|
|
) = map((1).__lshift__, range(26))
|
|
|
|
MH_MAGIC = 0xFEEDFACE
|
|
MH_CIGAM = 0xCEFAEDFE
|
|
MH_MAGIC_64 = 0xFEEDFACF
|
|
MH_CIGAM_64 = 0xCFFAEDFE
|
|
|
|
integer_t = p_int32
|
|
cpu_type_t = integer_t
|
|
cpu_subtype_t = p_uint32
|
|
|
|
MH_FILETYPE_NAMES = {
|
|
MH_OBJECT: "relocatable object",
|
|
MH_EXECUTE: "demand paged executable",
|
|
MH_FVMLIB: "fixed vm shared library",
|
|
MH_CORE: "core",
|
|
MH_PRELOAD: "preloaded executable",
|
|
MH_DYLIB: "dynamically bound shared library",
|
|
MH_DYLINKER: "dynamic link editor",
|
|
MH_BUNDLE: "dynamically bound bundle",
|
|
MH_DYLIB_STUB: "shared library stub for static linking",
|
|
MH_DSYM: "symbol information",
|
|
MH_FILESET: "fileset object",
|
|
}
|
|
|
|
MH_FILETYPE_SHORTNAMES = {
|
|
MH_OBJECT: "object",
|
|
MH_EXECUTE: "execute",
|
|
MH_FVMLIB: "fvmlib",
|
|
MH_CORE: "core",
|
|
MH_PRELOAD: "preload",
|
|
MH_DYLIB: "dylib",
|
|
MH_DYLINKER: "dylinker",
|
|
MH_BUNDLE: "bundle",
|
|
MH_DYLIB_STUB: "dylib_stub",
|
|
MH_DSYM: "dsym",
|
|
}
|
|
|
|
MH_FLAGS_NAMES = {
|
|
MH_NOUNDEFS: "MH_NOUNDEFS",
|
|
MH_INCRLINK: "MH_INCRLINK",
|
|
MH_DYLDLINK: "MH_DYLDLINK",
|
|
MH_BINDATLOAD: "MH_BINDATLOAD",
|
|
MH_PREBOUND: "MH_PREBOUND",
|
|
MH_SPLIT_SEGS: "MH_SPLIT_SEGS",
|
|
MH_LAZY_INIT: "MH_LAZY_INIT",
|
|
MH_TWOLEVEL: "MH_TWOLEVEL",
|
|
MH_FORCE_FLAT: "MH_FORCE_FLAT",
|
|
MH_NOMULTIDEFS: "MH_NOMULTIDEFS",
|
|
MH_NOFIXPREBINDING: "MH_NOFIXPREBINDING",
|
|
MH_PREBINDABLE: "MH_PREBINDABLE",
|
|
MH_ALLMODSBOUND: "MH_ALLMODSBOUND",
|
|
MH_SUBSECTIONS_VIA_SYMBOLS: "MH_SUBSECTIONS_VIA_SYMBOLS",
|
|
MH_CANONICAL: "MH_CANONICAL",
|
|
MH_WEAK_DEFINES: "MH_WEAK_DEFINES",
|
|
MH_BINDS_TO_WEAK: "MH_BINDS_TO_WEAK",
|
|
MH_ALLOW_STACK_EXECUTION: "MH_ALLOW_STACK_EXECUTION",
|
|
MH_ROOT_SAFE: "MH_ROOT_SAFE",
|
|
MH_SETUID_SAFE: "MH_SETUID_SAFE",
|
|
MH_NO_REEXPORTED_DYLIBS: "MH_NO_REEXPORTED_DYLIBS",
|
|
MH_PIE: "MH_PIE",
|
|
MH_DEAD_STRIPPABLE_DYLIB: "MH_DEAD_STRIPPABLE_DYLIB",
|
|
MH_HAS_TLV_DESCRIPTORS: "MH_HAS_TLV_DESCRIPTORS",
|
|
MH_NO_HEAP_EXECUTION: "MH_NO_HEAP_EXECUTION",
|
|
MH_APP_EXTENSION_SAFE: "MH_APP_EXTENSION_SAFE",
|
|
}
|
|
|
|
MH_FLAGS_DESCRIPTIONS = {
|
|
MH_NOUNDEFS: "no undefined references",
|
|
MH_INCRLINK: "output of an incremental link",
|
|
MH_DYLDLINK: "input for the dynamic linker",
|
|
MH_BINDATLOAD: "undefined references bound dynamically when loaded",
|
|
MH_PREBOUND: "dynamic undefined references prebound",
|
|
MH_SPLIT_SEGS: "split read-only and read-write segments",
|
|
MH_LAZY_INIT: "(obsolete)",
|
|
MH_TWOLEVEL: "using two-level name space bindings",
|
|
MH_FORCE_FLAT: "forcing all imagges to use flat name space bindings",
|
|
MH_NOMULTIDEFS: "umbrella guarantees no multiple definitions",
|
|
MH_NOFIXPREBINDING: "do not notify prebinding agent about this executable",
|
|
MH_PREBINDABLE: "the binary is not prebound but can have its prebinding redone",
|
|
MH_ALLMODSBOUND: "indicates that this binary binds to all "
|
|
"two-level namespace modules of its dependent libraries",
|
|
MH_SUBSECTIONS_VIA_SYMBOLS: "safe to divide up the sections into "
|
|
"sub-sections via symbols for dead code stripping",
|
|
MH_CANONICAL: "the binary has been canonicalized via the unprebind operation",
|
|
MH_WEAK_DEFINES: "the final linked image contains external weak symbols",
|
|
MH_BINDS_TO_WEAK: "the final linked image uses weak symbols",
|
|
MH_ALLOW_STACK_EXECUTION: "all stacks in the task will be given "
|
|
"stack execution privilege",
|
|
MH_ROOT_SAFE: "the binary declares it is safe for use in processes with uid zero",
|
|
MH_SETUID_SAFE: "the binary declares it is safe for use in processes "
|
|
"when issetugid() is true",
|
|
MH_NO_REEXPORTED_DYLIBS: "the static linker does not need to examine dependent "
|
|
"dylibs to see if any are re-exported",
|
|
MH_PIE: "the OS will load the main executable at a random address",
|
|
MH_DEAD_STRIPPABLE_DYLIB: "the static linker will automatically not create a "
|
|
"LC_LOAD_DYLIB load command to the dylib if no symbols are being "
|
|
"referenced from the dylib",
|
|
MH_HAS_TLV_DESCRIPTORS: "contains a section of type S_THREAD_LOCAL_VARIABLES",
|
|
MH_NO_HEAP_EXECUTION: "the OS will run the main executable with a "
|
|
"non-executable heap even on platforms that don't require it",
|
|
MH_APP_EXTENSION_SAFE: "the code was linked for use in an application extension.",
|
|
}
|
|
|
|
|
|
class mach_version_helper(Structure):
|
|
_fields_ = (("_version", p_uint32),)
|
|
|
|
@property
|
|
def major(self):
|
|
return self._version >> 16 & 0xFFFF
|
|
|
|
@major.setter
|
|
def major(self, v):
|
|
self._version = (self._version & 0xFFFF) | (v << 16)
|
|
|
|
@property
|
|
def minor(self):
|
|
return self._version >> 8 & 0xFF
|
|
|
|
@minor.setter
|
|
def minor(self, v):
|
|
self._version = (self._version & 0xFFFF00FF) | (v << 8)
|
|
|
|
@property
|
|
def rev(self):
|
|
return self._version & 0xFF
|
|
|
|
@rev.setter
|
|
def rev(self, v):
|
|
return (self._version & 0xFFFFFF00) | v
|
|
|
|
def __str__(self):
|
|
return "%s.%s.%s" % (self.major, self.minor, self.rev)
|
|
|
|
|
|
class mach_timestamp_helper(p_uint32):
|
|
def __str__(self):
|
|
return time.ctime(self)
|
|
|
|
|
|
def read_struct(f, s, **kw):
|
|
return s.from_fileobj(f, **kw)
|
|
|
|
|
|
class mach_header(Structure):
|
|
_fields_ = (
|
|
("magic", p_uint32),
|
|
("cputype", cpu_type_t),
|
|
("cpusubtype", cpu_subtype_t),
|
|
("filetype", p_uint32),
|
|
("ncmds", p_uint32),
|
|
("sizeofcmds", p_uint32),
|
|
("flags", p_uint32),
|
|
)
|
|
|
|
def _describe(self):
|
|
bit = 1
|
|
flags = self.flags
|
|
dflags = []
|
|
while flags and bit < (1 << 32):
|
|
if flags & bit:
|
|
dflags.append(
|
|
{
|
|
"name": MH_FLAGS_NAMES.get(bit, str(bit)),
|
|
"description": MH_FLAGS_DESCRIPTIONS.get(bit, str(bit)),
|
|
}
|
|
)
|
|
flags = flags ^ bit
|
|
bit <<= 1
|
|
return (
|
|
("magic", int(self.magic)),
|
|
("cputype_string", CPU_TYPE_NAMES.get(self.cputype, self.cputype)),
|
|
("cputype", int(self.cputype)),
|
|
("cpusubtype_string", get_cpu_subtype(self.cputype, self.cpusubtype)),
|
|
("cpusubtype", int(self.cpusubtype)),
|
|
("filetype_string", MH_FILETYPE_NAMES.get(self.filetype, self.filetype)),
|
|
("filetype", int(self.filetype)),
|
|
("ncmds", self.ncmds),
|
|
("sizeofcmds", self.sizeofcmds),
|
|
("flags", dflags),
|
|
("raw_flags", int(self.flags)),
|
|
)
|
|
|
|
|
|
class mach_header_64(mach_header):
|
|
_fields_ = mach_header._fields_ + (("reserved", p_uint32),)
|
|
|
|
|
|
class load_command(Structure):
|
|
_fields_ = (("cmd", p_uint32), ("cmdsize", p_uint32))
|
|
|
|
def get_cmd_name(self):
|
|
return LC_NAMES.get(self.cmd, self.cmd)
|
|
|
|
|
|
LC_REQ_DYLD = 0x80000000
|
|
|
|
(
|
|
LC_SEGMENT,
|
|
LC_SYMTAB,
|
|
LC_SYMSEG,
|
|
LC_THREAD,
|
|
LC_UNIXTHREAD,
|
|
LC_LOADFVMLIB,
|
|
LC_IDFVMLIB,
|
|
LC_IDENT,
|
|
LC_FVMFILE,
|
|
LC_PREPAGE,
|
|
LC_DYSYMTAB,
|
|
LC_LOAD_DYLIB,
|
|
LC_ID_DYLIB,
|
|
LC_LOAD_DYLINKER,
|
|
LC_ID_DYLINKER,
|
|
LC_PREBOUND_DYLIB,
|
|
LC_ROUTINES,
|
|
LC_SUB_FRAMEWORK,
|
|
LC_SUB_UMBRELLA,
|
|
LC_SUB_CLIENT,
|
|
LC_SUB_LIBRARY,
|
|
LC_TWOLEVEL_HINTS,
|
|
LC_PREBIND_CKSUM,
|
|
) = range(0x1, 0x18)
|
|
|
|
LC_LOAD_WEAK_DYLIB = LC_REQ_DYLD | 0x18
|
|
|
|
LC_SEGMENT_64 = 0x19
|
|
LC_ROUTINES_64 = 0x1A
|
|
LC_UUID = 0x1B
|
|
LC_RPATH = 0x1C | LC_REQ_DYLD
|
|
LC_CODE_SIGNATURE = 0x1D
|
|
LC_CODE_SEGMENT_SPLIT_INFO = 0x1E
|
|
LC_REEXPORT_DYLIB = 0x1F | LC_REQ_DYLD
|
|
LC_LAZY_LOAD_DYLIB = 0x20
|
|
LC_ENCRYPTION_INFO = 0x21
|
|
LC_DYLD_INFO = 0x22
|
|
LC_DYLD_INFO_ONLY = 0x22 | LC_REQ_DYLD
|
|
LC_LOAD_UPWARD_DYLIB = 0x23 | LC_REQ_DYLD
|
|
LC_VERSION_MIN_MACOSX = 0x24
|
|
LC_VERSION_MIN_IPHONEOS = 0x25
|
|
LC_FUNCTION_STARTS = 0x26
|
|
LC_DYLD_ENVIRONMENT = 0x27
|
|
LC_MAIN = 0x28 | LC_REQ_DYLD
|
|
LC_DATA_IN_CODE = 0x29
|
|
LC_SOURCE_VERSION = 0x2A
|
|
LC_DYLIB_CODE_SIGN_DRS = 0x2B
|
|
LC_ENCRYPTION_INFO_64 = 0x2C
|
|
LC_LINKER_OPTION = 0x2D
|
|
LC_LINKER_OPTIMIZATION_HINT = 0x2E
|
|
LC_VERSION_MIN_TVOS = 0x2F
|
|
LC_VERSION_MIN_WATCHOS = 0x30
|
|
LC_NOTE = 0x31
|
|
LC_BUILD_VERSION = 0x32
|
|
LC_DYLD_EXPORTS_TRIE = 0x33 | LC_REQ_DYLD
|
|
LC_DYLD_CHAINED_FIXUPS = 0x34 | LC_REQ_DYLD
|
|
LC_FILESET_ENTRY = 0x35 | LC_REQ_DYLD
|
|
|
|
|
|
# this is really a union.. but whatever
|
|
class lc_str(p_uint32):
|
|
pass
|
|
|
|
|
|
p_str16 = pypackable("p_str16", bytes, "16s")
|
|
|
|
vm_prot_t = p_int32
|
|
|
|
|
|
class segment_command(Structure):
|
|
_fields_ = (
|
|
("segname", p_str16),
|
|
("vmaddr", p_uint32),
|
|
("vmsize", p_uint32),
|
|
("fileoff", p_uint32),
|
|
("filesize", p_uint32),
|
|
("maxprot", vm_prot_t),
|
|
("initprot", vm_prot_t),
|
|
("nsects", p_uint32), # read the section structures ?
|
|
("flags", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["segname"] = self.segname.rstrip("\x00")
|
|
s["vmaddr"] = int(self.vmaddr)
|
|
s["vmsize"] = int(self.vmsize)
|
|
s["fileoff"] = int(self.fileoff)
|
|
s["filesize"] = int(self.filesize)
|
|
s["initprot"] = self.get_initial_virtual_memory_protections()
|
|
s["initprot_raw"] = int(self.initprot)
|
|
s["maxprot"] = self.get_max_virtual_memory_protections()
|
|
s["maxprot_raw"] = int(self.maxprot)
|
|
s["nsects"] = int(self.nsects)
|
|
s["flags"] = self.flags
|
|
return s
|
|
|
|
def get_initial_virtual_memory_protections(self):
|
|
vm = []
|
|
if self.initprot == 0:
|
|
vm.append("VM_PROT_NONE")
|
|
if self.initprot & 1:
|
|
vm.append("VM_PROT_READ")
|
|
if self.initprot & 2:
|
|
vm.append("VM_PROT_WRITE")
|
|
if self.initprot & 4:
|
|
vm.append("VM_PROT_EXECUTE")
|
|
return vm
|
|
|
|
def get_max_virtual_memory_protections(self):
|
|
vm = []
|
|
if self.maxprot == 0:
|
|
vm.append("VM_PROT_NONE")
|
|
if self.maxprot & 1:
|
|
vm.append("VM_PROT_READ")
|
|
if self.maxprot & 2:
|
|
vm.append("VM_PROT_WRITE")
|
|
if self.maxprot & 4:
|
|
vm.append("VM_PROT_EXECUTE")
|
|
return vm
|
|
|
|
|
|
class segment_command_64(Structure):
|
|
_fields_ = (
|
|
("segname", p_str16),
|
|
("vmaddr", p_uint64),
|
|
("vmsize", p_uint64),
|
|
("fileoff", p_uint64),
|
|
("filesize", p_uint64),
|
|
("maxprot", vm_prot_t),
|
|
("initprot", vm_prot_t),
|
|
("nsects", p_uint32), # read the section structures ?
|
|
("flags", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["segname"] = self.segname.rstrip("\x00")
|
|
s["vmaddr"] = int(self.vmaddr)
|
|
s["vmsize"] = int(self.vmsize)
|
|
s["fileoff"] = int(self.fileoff)
|
|
s["filesize"] = int(self.filesize)
|
|
s["initprot"] = self.get_initial_virtual_memory_protections()
|
|
s["initprot_raw"] = int(self.initprot)
|
|
s["maxprot"] = self.get_max_virtual_memory_protections()
|
|
s["maxprot_raw"] = int(self.maxprot)
|
|
s["nsects"] = int(self.nsects)
|
|
s["flags"] = self.flags
|
|
return s
|
|
|
|
def get_initial_virtual_memory_protections(self):
|
|
vm = []
|
|
if self.initprot == 0:
|
|
vm.append("VM_PROT_NONE")
|
|
if self.initprot & 1:
|
|
vm.append("VM_PROT_READ")
|
|
if self.initprot & 2:
|
|
vm.append("VM_PROT_WRITE")
|
|
if self.initprot & 4:
|
|
vm.append("VM_PROT_EXECUTE")
|
|
return vm
|
|
|
|
def get_max_virtual_memory_protections(self):
|
|
vm = []
|
|
if self.maxprot == 0:
|
|
vm.append("VM_PROT_NONE")
|
|
if self.maxprot & 1:
|
|
vm.append("VM_PROT_READ")
|
|
if self.maxprot & 2:
|
|
vm.append("VM_PROT_WRITE")
|
|
if self.maxprot & 4:
|
|
vm.append("VM_PROT_EXECUTE")
|
|
return vm
|
|
|
|
|
|
SG_HIGHVM = 0x1
|
|
SG_FVMLIB = 0x2
|
|
SG_NORELOC = 0x4
|
|
SG_PROTECTED_VERSION_1 = 0x8
|
|
|
|
|
|
class section(Structure):
|
|
_fields_ = (
|
|
("sectname", p_str16),
|
|
("segname", p_str16),
|
|
("addr", p_uint32),
|
|
("size", p_uint32),
|
|
("offset", p_uint32),
|
|
("align", p_uint32),
|
|
("reloff", p_uint32),
|
|
("nreloc", p_uint32),
|
|
("flags", p_uint32),
|
|
("reserved1", p_uint32),
|
|
("reserved2", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["sectname"] = self.sectname.rstrip("\x00")
|
|
s["segname"] = self.segname.rstrip("\x00")
|
|
s["addr"] = int(self.addr)
|
|
s["size"] = int(self.size)
|
|
s["offset"] = int(self.offset)
|
|
s["align"] = int(self.align)
|
|
s["reloff"] = int(self.reloff)
|
|
s["nreloc"] = int(self.nreloc)
|
|
f = {}
|
|
f["type"] = FLAG_SECTION_TYPES[int(self.flags) & 0xFF]
|
|
f["attributes"] = []
|
|
for k in FLAG_SECTION_ATTRIBUTES:
|
|
if k & self.flags:
|
|
f["attributes"].append(FLAG_SECTION_ATTRIBUTES[k])
|
|
if not f["attributes"]:
|
|
del f["attributes"]
|
|
s["flags"] = f
|
|
s["reserved1"] = int(self.reserved1)
|
|
s["reserved2"] = int(self.reserved2)
|
|
return s
|
|
|
|
def add_section_data(self, data):
|
|
self.section_data = data
|
|
|
|
|
|
class section_64(Structure):
|
|
_fields_ = (
|
|
("sectname", p_str16),
|
|
("segname", p_str16),
|
|
("addr", p_uint64),
|
|
("size", p_uint64),
|
|
("offset", p_uint32),
|
|
("align", p_uint32),
|
|
("reloff", p_uint32),
|
|
("nreloc", p_uint32),
|
|
("flags", p_uint32),
|
|
("reserved1", p_uint32),
|
|
("reserved2", p_uint32),
|
|
("reserved3", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["sectname"] = self.sectname.rstrip("\x00")
|
|
s["segname"] = self.segname.rstrip("\x00")
|
|
s["addr"] = int(self.addr)
|
|
s["size"] = int(self.size)
|
|
s["offset"] = int(self.offset)
|
|
s["align"] = int(self.align)
|
|
s["reloff"] = int(self.reloff)
|
|
s["nreloc"] = int(self.nreloc)
|
|
f = {}
|
|
f["type"] = FLAG_SECTION_TYPES[int(self.flags) & 0xFF]
|
|
f["attributes"] = []
|
|
for k in FLAG_SECTION_ATTRIBUTES:
|
|
if k & self.flags:
|
|
f["attributes"].append(FLAG_SECTION_ATTRIBUTES[k])
|
|
if not f["attributes"]:
|
|
del f["attributes"]
|
|
s["flags"] = f
|
|
s["reserved1"] = int(self.reserved1)
|
|
s["reserved2"] = int(self.reserved2)
|
|
s["reserved3"] = int(self.reserved3)
|
|
return s
|
|
|
|
def add_section_data(self, data):
|
|
self.section_data = data
|
|
|
|
|
|
SECTION_TYPE = 0xFF
|
|
SECTION_ATTRIBUTES = 0xFFFFFF00
|
|
S_REGULAR = 0x0
|
|
S_ZEROFILL = 0x1
|
|
S_CSTRING_LITERALS = 0x2
|
|
S_4BYTE_LITERALS = 0x3
|
|
S_8BYTE_LITERALS = 0x4
|
|
S_LITERAL_POINTERS = 0x5
|
|
S_NON_LAZY_SYMBOL_POINTERS = 0x6
|
|
S_LAZY_SYMBOL_POINTERS = 0x7
|
|
S_SYMBOL_STUBS = 0x8
|
|
S_MOD_INIT_FUNC_POINTERS = 0x9
|
|
S_MOD_TERM_FUNC_POINTERS = 0xA
|
|
S_COALESCED = 0xB
|
|
S_GB_ZEROFILL = 0xC
|
|
S_INTERPOSING = 0xD
|
|
S_16BYTE_LITERALS = 0xE
|
|
S_DTRACE_DOF = 0xF
|
|
S_LAZY_DYLIB_SYMBOL_POINTERS = 0x10
|
|
S_THREAD_LOCAL_REGULAR = 0x11
|
|
S_THREAD_LOCAL_ZEROFILL = 0x12
|
|
S_THREAD_LOCAL_VARIABLES = 0x13
|
|
S_THREAD_LOCAL_VARIABLE_POINTERS = 0x14
|
|
S_THREAD_LOCAL_INIT_FUNCTION_POINTERS = 0x15
|
|
|
|
FLAG_SECTION_TYPES = {
|
|
S_REGULAR: "S_REGULAR",
|
|
S_ZEROFILL: "S_ZEROFILL",
|
|
S_CSTRING_LITERALS: "S_CSTRING_LITERALS",
|
|
S_4BYTE_LITERALS: "S_4BYTE_LITERALS",
|
|
S_8BYTE_LITERALS: "S_8BYTE_LITERALS",
|
|
S_LITERAL_POINTERS: "S_LITERAL_POINTERS",
|
|
S_NON_LAZY_SYMBOL_POINTERS: "S_NON_LAZY_SYMBOL_POINTERS",
|
|
S_LAZY_SYMBOL_POINTERS: "S_LAZY_SYMBOL_POINTERS",
|
|
S_SYMBOL_STUBS: "S_SYMBOL_STUBS",
|
|
S_MOD_INIT_FUNC_POINTERS: "S_MOD_INIT_FUNC_POINTERS",
|
|
S_MOD_TERM_FUNC_POINTERS: "S_MOD_TERM_FUNC_POINTERS",
|
|
S_COALESCED: "S_COALESCED",
|
|
S_GB_ZEROFILL: "S_GB_ZEROFILL",
|
|
S_INTERPOSING: "S_INTERPOSING",
|
|
S_16BYTE_LITERALS: "S_16BYTE_LITERALS",
|
|
S_DTRACE_DOF: "S_DTRACE_DOF",
|
|
S_LAZY_DYLIB_SYMBOL_POINTERS: "S_LAZY_DYLIB_SYMBOL_POINTERS",
|
|
S_THREAD_LOCAL_REGULAR: "S_THREAD_LOCAL_REGULAR",
|
|
S_THREAD_LOCAL_ZEROFILL: "S_THREAD_LOCAL_ZEROFILL",
|
|
S_THREAD_LOCAL_VARIABLES: "S_THREAD_LOCAL_VARIABLES",
|
|
S_THREAD_LOCAL_VARIABLE_POINTERS: "S_THREAD_LOCAL_VARIABLE_POINTERS",
|
|
S_THREAD_LOCAL_INIT_FUNCTION_POINTERS: "S_THREAD_LOCAL_INIT_FUNCTION_POINTERS",
|
|
}
|
|
|
|
SECTION_ATTRIBUTES_USR = 0xFF000000
|
|
S_ATTR_PURE_INSTRUCTIONS = 0x80000000
|
|
S_ATTR_NO_TOC = 0x40000000
|
|
S_ATTR_STRIP_STATIC_SYMS = 0x20000000
|
|
S_ATTR_NO_DEAD_STRIP = 0x10000000
|
|
S_ATTR_LIVE_SUPPORT = 0x08000000
|
|
S_ATTR_SELF_MODIFYING_CODE = 0x04000000
|
|
S_ATTR_DEBUG = 0x02000000
|
|
|
|
SECTION_ATTRIBUTES_SYS = 0x00FFFF00
|
|
S_ATTR_SOME_INSTRUCTIONS = 0x00000400
|
|
S_ATTR_EXT_RELOC = 0x00000200
|
|
S_ATTR_LOC_RELOC = 0x00000100
|
|
|
|
FLAG_SECTION_ATTRIBUTES = {
|
|
S_ATTR_PURE_INSTRUCTIONS: "S_ATTR_PURE_INSTRUCTIONS",
|
|
S_ATTR_NO_TOC: "S_ATTR_NO_TOC",
|
|
S_ATTR_STRIP_STATIC_SYMS: "S_ATTR_STRIP_STATIC_SYMS",
|
|
S_ATTR_NO_DEAD_STRIP: "S_ATTR_NO_DEAD_STRIP",
|
|
S_ATTR_LIVE_SUPPORT: "S_ATTR_LIVE_SUPPORT",
|
|
S_ATTR_SELF_MODIFYING_CODE: "S_ATTR_SELF_MODIFYING_CODE",
|
|
S_ATTR_DEBUG: "S_ATTR_DEBUG",
|
|
S_ATTR_SOME_INSTRUCTIONS: "S_ATTR_SOME_INSTRUCTIONS",
|
|
S_ATTR_EXT_RELOC: "S_ATTR_EXT_RELOC",
|
|
S_ATTR_LOC_RELOC: "S_ATTR_LOC_RELOC",
|
|
}
|
|
|
|
SEG_PAGEZERO = "__PAGEZERO"
|
|
SEG_TEXT = "__TEXT"
|
|
SECT_TEXT = "__text"
|
|
SECT_FVMLIB_INIT0 = "__fvmlib_init0"
|
|
SECT_FVMLIB_INIT1 = "__fvmlib_init1"
|
|
SEG_DATA = "__DATA"
|
|
SECT_DATA = "__data"
|
|
SECT_BSS = "__bss"
|
|
SECT_COMMON = "__common"
|
|
SEG_OBJC = "__OBJC"
|
|
SECT_OBJC_SYMBOLS = "__symbol_table"
|
|
SECT_OBJC_MODULES = "__module_info"
|
|
SECT_OBJC_STRINGS = "__selector_strs"
|
|
SECT_OBJC_REFS = "__selector_refs"
|
|
SEG_ICON = "__ICON"
|
|
SECT_ICON_HEADER = "__header"
|
|
SECT_ICON_TIFF = "__tiff"
|
|
SEG_LINKEDIT = "__LINKEDIT"
|
|
SEG_UNIXSTACK = "__UNIXSTACK"
|
|
SEG_IMPORT = "__IMPORT"
|
|
|
|
#
|
|
# I really should remove all these _command classes because they
|
|
# are no different. I decided to keep the load commands separate,
|
|
# so classes like fvmlib and fvmlib_command are equivalent.
|
|
#
|
|
|
|
|
|
class fvmlib(Structure):
|
|
_fields_ = (
|
|
("name", lc_str),
|
|
("minor_version", mach_version_helper),
|
|
("header_addr", p_uint32),
|
|
)
|
|
|
|
|
|
class fvmlib_command(Structure):
|
|
_fields_ = fvmlib._fields_
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["header_addr"] = int(self.header_addr)
|
|
return s
|
|
|
|
|
|
class dylib(Structure):
|
|
_fields_ = (
|
|
("name", lc_str),
|
|
("timestamp", mach_timestamp_helper),
|
|
("current_version", mach_version_helper),
|
|
("compatibility_version", mach_version_helper),
|
|
)
|
|
|
|
|
|
# merged dylib structure
|
|
class dylib_command(Structure):
|
|
_fields_ = dylib._fields_
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["timestamp"] = str(self.timestamp)
|
|
s["current_version"] = str(self.current_version)
|
|
s["compatibility_version"] = str(self.compatibility_version)
|
|
return s
|
|
|
|
|
|
class sub_framework_command(Structure):
|
|
_fields_ = (("umbrella", lc_str),)
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class sub_client_command(Structure):
|
|
_fields_ = (("client", lc_str),)
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class sub_umbrella_command(Structure):
|
|
_fields_ = (("sub_umbrella", lc_str),)
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class sub_library_command(Structure):
|
|
_fields_ = (("sub_library", lc_str),)
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class prebound_dylib_command(Structure):
|
|
_fields_ = (("name", lc_str), ("nmodules", p_uint32), ("linked_modules", lc_str))
|
|
|
|
def describe(self):
|
|
return {"nmodules": int(self.nmodules)}
|
|
|
|
|
|
class dylinker_command(Structure):
|
|
_fields_ = (("name", lc_str),)
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class thread_command(Structure):
|
|
_fields_ = (("flavor", p_uint32), ("count", p_uint32))
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["flavor"] = int(self.flavor)
|
|
s["count"] = int(self.count)
|
|
return s
|
|
|
|
|
|
class entry_point_command(Structure):
|
|
_fields_ = (("entryoff", p_uint64), ("stacksize", p_uint64))
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["entryoff"] = int(self.entryoff)
|
|
s["stacksize"] = int(self.stacksize)
|
|
return s
|
|
|
|
|
|
class routines_command(Structure):
|
|
_fields_ = (
|
|
("init_address", p_uint32),
|
|
("init_module", p_uint32),
|
|
("reserved1", p_uint32),
|
|
("reserved2", p_uint32),
|
|
("reserved3", p_uint32),
|
|
("reserved4", p_uint32),
|
|
("reserved5", p_uint32),
|
|
("reserved6", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["init_address"] = int(self.init_address)
|
|
s["init_module"] = int(self.init_module)
|
|
s["reserved1"] = int(self.reserved1)
|
|
s["reserved2"] = int(self.reserved2)
|
|
s["reserved3"] = int(self.reserved3)
|
|
s["reserved4"] = int(self.reserved4)
|
|
s["reserved5"] = int(self.reserved5)
|
|
s["reserved6"] = int(self.reserved6)
|
|
return s
|
|
|
|
|
|
class routines_command_64(Structure):
|
|
_fields_ = (
|
|
("init_address", p_uint64),
|
|
("init_module", p_uint64),
|
|
("reserved1", p_uint64),
|
|
("reserved2", p_uint64),
|
|
("reserved3", p_uint64),
|
|
("reserved4", p_uint64),
|
|
("reserved5", p_uint64),
|
|
("reserved6", p_uint64),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["init_address"] = int(self.init_address)
|
|
s["init_module"] = int(self.init_module)
|
|
s["reserved1"] = int(self.reserved1)
|
|
s["reserved2"] = int(self.reserved2)
|
|
s["reserved3"] = int(self.reserved3)
|
|
s["reserved4"] = int(self.reserved4)
|
|
s["reserved5"] = int(self.reserved5)
|
|
s["reserved6"] = int(self.reserved6)
|
|
return s
|
|
|
|
|
|
class symtab_command(Structure):
|
|
_fields_ = (
|
|
("symoff", p_uint32),
|
|
("nsyms", p_uint32),
|
|
("stroff", p_uint32),
|
|
("strsize", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["symoff"] = int(self.symoff)
|
|
s["nsyms"] = int(self.nsyms)
|
|
s["stroff"] = int(self.stroff)
|
|
s["strsize"] = int(self.strsize)
|
|
return s
|
|
|
|
|
|
class dysymtab_command(Structure):
|
|
_fields_ = (
|
|
("ilocalsym", p_uint32),
|
|
("nlocalsym", p_uint32),
|
|
("iextdefsym", p_uint32),
|
|
("nextdefsym", p_uint32),
|
|
("iundefsym", p_uint32),
|
|
("nundefsym", p_uint32),
|
|
("tocoff", p_uint32),
|
|
("ntoc", p_uint32),
|
|
("modtaboff", p_uint32),
|
|
("nmodtab", p_uint32),
|
|
("extrefsymoff", p_uint32),
|
|
("nextrefsyms", p_uint32),
|
|
("indirectsymoff", p_uint32),
|
|
("nindirectsyms", p_uint32),
|
|
("extreloff", p_uint32),
|
|
("nextrel", p_uint32),
|
|
("locreloff", p_uint32),
|
|
("nlocrel", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
dys = {}
|
|
dys["ilocalsym"] = int(self.ilocalsym)
|
|
dys["nlocalsym"] = int(self.nlocalsym)
|
|
dys["iextdefsym"] = int(self.iextdefsym)
|
|
dys["nextdefsym"] = int(self.nextdefsym)
|
|
dys["iundefsym"] = int(self.iundefsym)
|
|
dys["nundefsym"] = int(self.nundefsym)
|
|
dys["tocoff"] = int(self.tocoff)
|
|
dys["ntoc"] = int(self.ntoc)
|
|
dys["modtaboff"] = int(self.modtaboff)
|
|
dys["nmodtab"] = int(self.nmodtab)
|
|
dys["extrefsymoff"] = int(self.extrefsymoff)
|
|
dys["nextrefsyms"] = int(self.nextrefsyms)
|
|
dys["indirectsymoff"] = int(self.indirectsymoff)
|
|
dys["nindirectsyms"] = int(self.nindirectsyms)
|
|
dys["extreloff"] = int(self.extreloff)
|
|
dys["nextrel"] = int(self.nextrel)
|
|
dys["locreloff"] = int(self.locreloff)
|
|
dys["nlocrel"] = int(self.nlocrel)
|
|
return dys
|
|
|
|
|
|
INDIRECT_SYMBOL_LOCAL = 0x80000000
|
|
INDIRECT_SYMBOL_ABS = 0x40000000
|
|
|
|
|
|
class dylib_table_of_contents(Structure):
|
|
_fields_ = (("symbol_index", p_uint32), ("module_index", p_uint32))
|
|
|
|
|
|
class dylib_module(Structure):
|
|
_fields_ = (
|
|
("module_name", p_uint32),
|
|
("iextdefsym", p_uint32),
|
|
("nextdefsym", p_uint32),
|
|
("irefsym", p_uint32),
|
|
("nrefsym", p_uint32),
|
|
("ilocalsym", p_uint32),
|
|
("nlocalsym", p_uint32),
|
|
("iextrel", p_uint32),
|
|
("nextrel", p_uint32),
|
|
("iinit_iterm", p_uint32),
|
|
("ninit_nterm", p_uint32),
|
|
("objc_module_info_addr", p_uint32),
|
|
("objc_module_info_size", p_uint32),
|
|
)
|
|
|
|
|
|
class dylib_module_64(Structure):
|
|
_fields_ = (
|
|
("module_name", p_uint32),
|
|
("iextdefsym", p_uint32),
|
|
("nextdefsym", p_uint32),
|
|
("irefsym", p_uint32),
|
|
("nrefsym", p_uint32),
|
|
("ilocalsym", p_uint32),
|
|
("nlocalsym", p_uint32),
|
|
("iextrel", p_uint32),
|
|
("nextrel", p_uint32),
|
|
("iinit_iterm", p_uint32),
|
|
("ninit_nterm", p_uint32),
|
|
("objc_module_info_size", p_uint32),
|
|
("objc_module_info_addr", p_uint64),
|
|
)
|
|
|
|
|
|
class dylib_reference(Structure):
|
|
_fields_ = (
|
|
("isym_flags", p_uint32),
|
|
# ('isym', p_uint8 * 3),
|
|
# ('flags', p_uint8),
|
|
)
|
|
|
|
|
|
class twolevel_hints_command(Structure):
|
|
_fields_ = (("offset", p_uint32), ("nhints", p_uint32))
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["offset"] = int(self.offset)
|
|
s["nhints"] = int(self.nhints)
|
|
return s
|
|
|
|
|
|
class twolevel_hint(Structure):
|
|
_fields_ = (
|
|
("isub_image_itoc", p_uint32),
|
|
# ('isub_image', p_uint8),
|
|
# ('itoc', p_uint8 * 3),
|
|
)
|
|
|
|
|
|
class prebind_cksum_command(Structure):
|
|
_fields_ = (("cksum", p_uint32),)
|
|
|
|
def describe(self):
|
|
return {"cksum": int(self.cksum)}
|
|
|
|
|
|
class symseg_command(Structure):
|
|
_fields_ = (("offset", p_uint32), ("size", p_uint32))
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["offset"] = int(self.offset)
|
|
s["size"] = int(self.size)
|
|
|
|
|
|
class ident_command(Structure):
|
|
_fields_ = ()
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class fvmfile_command(Structure):
|
|
_fields_ = (("name", lc_str), ("header_addr", p_uint32))
|
|
|
|
def describe(self):
|
|
return {"header_addr": int(self.header_addr)}
|
|
|
|
|
|
class uuid_command(Structure):
|
|
_fields_ = (("uuid", p_str16),)
|
|
|
|
def describe(self):
|
|
return {"uuid": self.uuid.rstrip("\x00")}
|
|
|
|
|
|
class rpath_command(Structure):
|
|
_fields_ = (("path", lc_str),)
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class linkedit_data_command(Structure):
|
|
_fields_ = (("dataoff", p_uint32), ("datasize", p_uint32))
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["dataoff"] = int(self.dataoff)
|
|
s["datasize"] = int(self.datasize)
|
|
return s
|
|
|
|
|
|
class version_min_command(Structure):
|
|
_fields_ = (
|
|
("version", p_uint32), # X.Y.Z is encoded in nibbles xxxx.yy.zz
|
|
("sdk", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
v = int(self.version)
|
|
v3 = v & 0xFF
|
|
v = v >> 8
|
|
v2 = v & 0xFF
|
|
v = v >> 8
|
|
v1 = v & 0xFFFF
|
|
s = int(self.sdk)
|
|
s3 = s & 0xFF
|
|
s = s >> 8
|
|
s2 = s & 0xFF
|
|
s = s >> 8
|
|
s1 = s & 0xFFFF
|
|
return {
|
|
"version": str(int(v1)) + "." + str(int(v2)) + "." + str(int(v3)),
|
|
"sdk": str(int(s1)) + "." + str(int(s2)) + "." + str(int(s3)),
|
|
}
|
|
|
|
|
|
class source_version_command(Structure):
|
|
_fields_ = (("version", p_uint64),)
|
|
|
|
def describe(self):
|
|
v = int(self.version)
|
|
a = v >> 40
|
|
b = (v >> 30) & 0x3FF
|
|
c = (v >> 20) & 0x3FF
|
|
d = (v >> 10) & 0x3FF
|
|
e = v & 0x3FF
|
|
r = str(a) + "." + str(b) + "." + str(c) + "." + str(d) + "." + str(e)
|
|
return {"version": r}
|
|
|
|
|
|
class note_command(Structure):
|
|
_fields_ = (("data_owner", p_str16), ("offset", p_uint64), ("size", p_uint64))
|
|
|
|
|
|
class build_version_command(Structure):
|
|
_fields_ = (
|
|
("platform", p_uint32),
|
|
("minos", p_uint32),
|
|
("sdk", p_uint32),
|
|
("ntools", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
return {}
|
|
|
|
|
|
class build_tool_version(Structure):
|
|
_fields_ = (("tool", p_uint32), ("version", p_uint32))
|
|
|
|
|
|
class data_in_code_entry(Structure):
|
|
_fields_ = (("offset", p_uint32), ("length", p_uint32), ("kind", p_uint32))
|
|
|
|
def describe(self):
|
|
return {"offset": self.offset, "length": self.length, "kind": self.kind}
|
|
|
|
|
|
DICE_KIND_DATA = 0x0001
|
|
DICE_KIND_JUMP_TABLE8 = 0x0002
|
|
DICE_KIND_JUMP_TABLE16 = 0x0003
|
|
DICE_KIND_JUMP_TABLE32 = 0x0004
|
|
DICE_KIND_ABS_JUMP_TABLE32 = 0x0005
|
|
|
|
DATA_IN_CODE_KINDS = {
|
|
DICE_KIND_DATA: "DICE_KIND_DATA",
|
|
DICE_KIND_JUMP_TABLE8: "DICE_KIND_JUMP_TABLE8",
|
|
DICE_KIND_JUMP_TABLE16: "DICE_KIND_JUMP_TABLE16",
|
|
DICE_KIND_JUMP_TABLE32: "DICE_KIND_JUMP_TABLE32",
|
|
DICE_KIND_ABS_JUMP_TABLE32: "DICE_KIND_ABS_JUMP_TABLE32",
|
|
}
|
|
|
|
|
|
class tlv_descriptor(Structure):
|
|
_fields_ = (
|
|
("thunk", p_long), # Actually a pointer to a function
|
|
("key", p_ulong),
|
|
("offset", p_ulong),
|
|
)
|
|
|
|
def describe(self):
|
|
return {"thunk": self.thunk, "key": self.key, "offset": self.offset}
|
|
|
|
|
|
class encryption_info_command(Structure):
|
|
_fields_ = (("cryptoff", p_uint32), ("cryptsize", p_uint32), ("cryptid", p_uint32))
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["cryptoff"] = int(self.cryptoff)
|
|
s["cryptsize"] = int(self.cryptsize)
|
|
s["cryptid"] = int(self.cryptid)
|
|
return s
|
|
|
|
|
|
class encryption_info_command_64(Structure):
|
|
_fields_ = (
|
|
("cryptoff", p_uint32),
|
|
("cryptsize", p_uint32),
|
|
("cryptid", p_uint32),
|
|
("pad", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
s = {}
|
|
s["cryptoff"] = int(self.cryptoff)
|
|
s["cryptsize"] = int(self.cryptsize)
|
|
s["cryptid"] = int(self.cryptid)
|
|
s["pad"] = int(self.pad)
|
|
return s
|
|
|
|
|
|
class dyld_info_command(Structure):
|
|
_fields_ = (
|
|
("rebase_off", p_uint32),
|
|
("rebase_size", p_uint32),
|
|
("bind_off", p_uint32),
|
|
("bind_size", p_uint32),
|
|
("weak_bind_off", p_uint32),
|
|
("weak_bind_size", p_uint32),
|
|
("lazy_bind_off", p_uint32),
|
|
("lazy_bind_size", p_uint32),
|
|
("export_off", p_uint32),
|
|
("export_size", p_uint32),
|
|
)
|
|
|
|
def describe(self):
|
|
dyld = {}
|
|
dyld["rebase_off"] = int(self.rebase_off)
|
|
dyld["rebase_size"] = int(self.rebase_size)
|
|
dyld["bind_off"] = int(self.bind_off)
|
|
dyld["bind_size"] = int(self.bind_size)
|
|
dyld["weak_bind_off"] = int(self.weak_bind_off)
|
|
dyld["weak_bind_size"] = int(self.weak_bind_size)
|
|
dyld["lazy_bind_off"] = int(self.lazy_bind_off)
|
|
dyld["lazy_bind_size"] = int(self.lazy_bind_size)
|
|
dyld["export_off"] = int(self.export_off)
|
|
dyld["export_size"] = int(self.export_size)
|
|
return dyld
|
|
|
|
|
|
class linker_option_command(Structure):
|
|
_fields_ = (("count", p_uint32),)
|
|
|
|
def describe(self):
|
|
return {"count": int(self.count)}
|
|
|
|
|
|
class fileset_entry_command(Structure):
|
|
_fields_ = (
|
|
("vmaddr", p_uint64),
|
|
("fileoff", p_uint64),
|
|
("entry_id", lc_str),
|
|
("reserved", p_uint32),
|
|
)
|
|
|
|
|
|
LC_REGISTRY = {
|
|
LC_SEGMENT: segment_command,
|
|
LC_IDFVMLIB: fvmlib_command,
|
|
LC_LOADFVMLIB: fvmlib_command,
|
|
LC_ID_DYLIB: dylib_command,
|
|
LC_LOAD_DYLIB: dylib_command,
|
|
LC_LOAD_WEAK_DYLIB: dylib_command,
|
|
LC_SUB_FRAMEWORK: sub_framework_command,
|
|
LC_SUB_CLIENT: sub_client_command,
|
|
LC_SUB_UMBRELLA: sub_umbrella_command,
|
|
LC_SUB_LIBRARY: sub_library_command,
|
|
LC_PREBOUND_DYLIB: prebound_dylib_command,
|
|
LC_ID_DYLINKER: dylinker_command,
|
|
LC_LOAD_DYLINKER: dylinker_command,
|
|
LC_THREAD: thread_command,
|
|
LC_UNIXTHREAD: thread_command,
|
|
LC_ROUTINES: routines_command,
|
|
LC_SYMTAB: symtab_command,
|
|
LC_DYSYMTAB: dysymtab_command,
|
|
LC_TWOLEVEL_HINTS: twolevel_hints_command,
|
|
LC_PREBIND_CKSUM: prebind_cksum_command,
|
|
LC_SYMSEG: symseg_command,
|
|
LC_IDENT: ident_command,
|
|
LC_FVMFILE: fvmfile_command,
|
|
LC_SEGMENT_64: segment_command_64,
|
|
LC_ROUTINES_64: routines_command_64,
|
|
LC_UUID: uuid_command,
|
|
LC_RPATH: rpath_command,
|
|
LC_CODE_SIGNATURE: linkedit_data_command,
|
|
LC_CODE_SEGMENT_SPLIT_INFO: linkedit_data_command,
|
|
LC_REEXPORT_DYLIB: dylib_command,
|
|
LC_LAZY_LOAD_DYLIB: dylib_command,
|
|
LC_ENCRYPTION_INFO: encryption_info_command,
|
|
LC_DYLD_INFO: dyld_info_command,
|
|
LC_DYLD_INFO_ONLY: dyld_info_command,
|
|
LC_LOAD_UPWARD_DYLIB: dylib_command,
|
|
LC_VERSION_MIN_MACOSX: version_min_command,
|
|
LC_VERSION_MIN_IPHONEOS: version_min_command,
|
|
LC_FUNCTION_STARTS: linkedit_data_command,
|
|
LC_DYLD_ENVIRONMENT: dylinker_command,
|
|
LC_MAIN: entry_point_command,
|
|
LC_DATA_IN_CODE: linkedit_data_command,
|
|
LC_SOURCE_VERSION: source_version_command,
|
|
LC_DYLIB_CODE_SIGN_DRS: linkedit_data_command,
|
|
LC_ENCRYPTION_INFO_64: encryption_info_command_64,
|
|
LC_LINKER_OPTION: linker_option_command,
|
|
LC_LINKER_OPTIMIZATION_HINT: linkedit_data_command,
|
|
LC_VERSION_MIN_TVOS: version_min_command,
|
|
LC_VERSION_MIN_WATCHOS: version_min_command,
|
|
LC_NOTE: note_command,
|
|
LC_BUILD_VERSION: build_version_command,
|
|
LC_DYLD_EXPORTS_TRIE: linkedit_data_command,
|
|
LC_DYLD_CHAINED_FIXUPS: linkedit_data_command,
|
|
LC_FILESET_ENTRY: fileset_entry_command,
|
|
}
|
|
|
|
LC_NAMES = {
|
|
LC_SEGMENT: "LC_SEGMENT",
|
|
LC_IDFVMLIB: "LC_IDFVMLIB",
|
|
LC_LOADFVMLIB: "LC_LOADFVMLIB",
|
|
LC_ID_DYLIB: "LC_ID_DYLIB",
|
|
LC_LOAD_DYLIB: "LC_LOAD_DYLIB",
|
|
LC_LOAD_WEAK_DYLIB: "LC_LOAD_WEAK_DYLIB",
|
|
LC_SUB_FRAMEWORK: "LC_SUB_FRAMEWORK",
|
|
LC_SUB_CLIENT: "LC_SUB_CLIENT",
|
|
LC_SUB_UMBRELLA: "LC_SUB_UMBRELLA",
|
|
LC_SUB_LIBRARY: "LC_SUB_LIBRARY",
|
|
LC_PREBOUND_DYLIB: "LC_PREBOUND_DYLIB",
|
|
LC_ID_DYLINKER: "LC_ID_DYLINKER",
|
|
LC_LOAD_DYLINKER: "LC_LOAD_DYLINKER",
|
|
LC_THREAD: "LC_THREAD",
|
|
LC_UNIXTHREAD: "LC_UNIXTHREAD",
|
|
LC_ROUTINES: "LC_ROUTINES",
|
|
LC_SYMTAB: "LC_SYMTAB",
|
|
LC_DYSYMTAB: "LC_DYSYMTAB",
|
|
LC_TWOLEVEL_HINTS: "LC_TWOLEVEL_HINTS",
|
|
LC_PREBIND_CKSUM: "LC_PREBIND_CKSUM",
|
|
LC_SYMSEG: "LC_SYMSEG",
|
|
LC_IDENT: "LC_IDENT",
|
|
LC_FVMFILE: "LC_FVMFILE",
|
|
LC_SEGMENT_64: "LC_SEGMENT_64",
|
|
LC_ROUTINES_64: "LC_ROUTINES_64",
|
|
LC_UUID: "LC_UUID",
|
|
LC_RPATH: "LC_RPATH",
|
|
LC_CODE_SIGNATURE: "LC_CODE_SIGNATURE",
|
|
LC_CODE_SEGMENT_SPLIT_INFO: "LC_CODE_SEGMENT_SPLIT_INFO",
|
|
LC_REEXPORT_DYLIB: "LC_REEXPORT_DYLIB",
|
|
LC_LAZY_LOAD_DYLIB: "LC_LAZY_LOAD_DYLIB",
|
|
LC_ENCRYPTION_INFO: "LC_ENCRYPTION_INFO",
|
|
LC_DYLD_INFO: "LC_DYLD_INFO",
|
|
LC_DYLD_INFO_ONLY: "LC_DYLD_INFO_ONLY",
|
|
LC_LOAD_UPWARD_DYLIB: "LC_LOAD_UPWARD_DYLIB",
|
|
LC_VERSION_MIN_MACOSX: "LC_VERSION_MIN_MACOSX",
|
|
LC_VERSION_MIN_IPHONEOS: "LC_VERSION_MIN_IPHONEOS",
|
|
LC_FUNCTION_STARTS: "LC_FUNCTION_STARTS",
|
|
LC_DYLD_ENVIRONMENT: "LC_DYLD_ENVIRONMENT",
|
|
LC_MAIN: "LC_MAIN",
|
|
LC_DATA_IN_CODE: "LC_DATA_IN_CODE",
|
|
LC_SOURCE_VERSION: "LC_SOURCE_VERSION",
|
|
LC_DYLIB_CODE_SIGN_DRS: "LC_DYLIB_CODE_SIGN_DRS",
|
|
LC_LINKER_OPTIMIZATION_HINT: "LC_LINKER_OPTIMIZATION_HINT",
|
|
LC_VERSION_MIN_TVOS: "LC_VERSION_MIN_TVOS",
|
|
LC_VERSION_MIN_WATCHOS: "LC_VERSION_MIN_WATCHOS",
|
|
LC_NOTE: "LC_NOTE",
|
|
LC_BUILD_VERSION: "LC_BUILD_VERSION",
|
|
LC_DYLD_EXPORTS_TRIE: "LC_DYLD_EXPORTS_TRIE",
|
|
LC_DYLD_CHAINED_FIXUPS: "LC_DYLD_CHAINED_FIXUPS",
|
|
LC_ENCRYPTION_INFO_64: "LC_ENCRYPTION_INFO_64",
|
|
LC_LINKER_OPTION: "LC_LINKER_OPTION",
|
|
LC_PREPAGE: "LC_PREPAGE",
|
|
LC_FILESET_ENTRY: "LC_FILESET_ENTRY",
|
|
}
|
|
|
|
|
|
# this is another union.
|
|
class n_un(p_int32):
|
|
pass
|
|
|
|
|
|
class nlist(Structure):
|
|
_fields_ = (
|
|
("n_un", n_un),
|
|
("n_type", p_uint8),
|
|
("n_sect", p_uint8),
|
|
("n_desc", p_short),
|
|
("n_value", p_uint32),
|
|
)
|
|
|
|
|
|
class nlist_64(Structure):
|
|
_fields_ = [
|
|
("n_un", n_un),
|
|
("n_type", p_uint8),
|
|
("n_sect", p_uint8),
|
|
("n_desc", p_short),
|
|
("n_value", p_int64),
|
|
]
|
|
|
|
|
|
N_STAB = 0xE0
|
|
N_PEXT = 0x10
|
|
N_TYPE = 0x0E
|
|
N_EXT = 0x01
|
|
|
|
N_UNDF = 0x0
|
|
N_ABS = 0x2
|
|
N_SECT = 0xE
|
|
N_PBUD = 0xC
|
|
N_INDR = 0xA
|
|
|
|
NO_SECT = 0
|
|
MAX_SECT = 255
|
|
|
|
|
|
class relocation_info(Structure):
|
|
_fields_ = (("r_address", p_uint32), ("_r_bitfield", p_uint32))
|
|
|
|
def _describe(self):
|
|
return (("r_address", self.r_address), ("_r_bitfield", self._r_bitfield))
|
|
|
|
|
|
def GET_COMM_ALIGN(n_desc):
|
|
return (n_desc >> 8) & 0x0F
|
|
|
|
|
|
def SET_COMM_ALIGN(n_desc, align):
|
|
return (n_desc & 0xF0FF) | ((align & 0x0F) << 8)
|
|
|
|
|
|
REFERENCE_TYPE = 0xF
|
|
REFERENCE_FLAG_UNDEFINED_NON_LAZY = 0
|
|
REFERENCE_FLAG_UNDEFINED_LAZY = 1
|
|
REFERENCE_FLAG_DEFINED = 2
|
|
REFERENCE_FLAG_PRIVATE_DEFINED = 3
|
|
REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY = 4
|
|
REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY = 5
|
|
|
|
REFERENCED_DYNAMICALLY = 0x0010
|
|
|
|
|
|
def GET_LIBRARY_ORDINAL(n_desc):
|
|
return ((n_desc) >> 8) & 0xFF
|
|
|
|
|
|
def SET_LIBRARY_ORDINAL(n_desc, ordinal):
|
|
return ((n_desc) & 0x00FF) | (((ordinal & 0xFF) << 8))
|
|
|
|
|
|
SELF_LIBRARY_ORDINAL = 0x0
|
|
MAX_LIBRARY_ORDINAL = 0xFD
|
|
DYNAMIC_LOOKUP_ORDINAL = 0xFE
|
|
EXECUTABLE_ORDINAL = 0xFF
|
|
|
|
N_NO_DEAD_STRIP = 0x0020
|
|
N_DESC_DISCARDED = 0x0020
|
|
N_WEAK_REF = 0x0040
|
|
N_WEAK_DEF = 0x0080
|
|
N_REF_TO_WEAK = 0x0080
|
|
N_ARM_THUMB_DEF = 0x0008
|
|
N_SYMBOL_RESOLVER = 0x0100
|
|
N_ALT_ENTRY = 0x0200
|
|
|
|
# /usr/include/mach-o/fat.h
|
|
FAT_MAGIC = 0xCAFEBABE
|
|
FAT_CIGAM = 0xBEBAFECA
|
|
FAT_MAGIC_64 = 0xCAFEBABF
|
|
FAT_CIGAM_64 = 0xBFBAFECA
|
|
|
|
|
|
class fat_header(Structure):
|
|
_fields_ = (("magic", p_uint32), ("nfat_arch", p_uint32))
|
|
|
|
|
|
class fat_arch(Structure):
|
|
_fields_ = (
|
|
("cputype", cpu_type_t),
|
|
("cpusubtype", cpu_subtype_t),
|
|
("offset", p_uint32),
|
|
("size", p_uint32),
|
|
("align", p_uint32),
|
|
)
|
|
|
|
|
|
class fat_arch64(Structure):
|
|
_fields_ = (
|
|
("cputype", cpu_type_t),
|
|
("cpusubtype", cpu_subtype_t),
|
|
("offset", p_uint64),
|
|
("size", p_uint64),
|
|
("align", p_uint32),
|
|
("reserved", p_uint32),
|
|
)
|
|
|
|
|
|
REBASE_TYPE_POINTER = 1 # noqa: E221
|
|
REBASE_TYPE_TEXT_ABSOLUTE32 = 2 # noqa: E221
|
|
REBASE_TYPE_TEXT_PCREL32 = 3 # noqa: E221
|
|
|
|
REBASE_OPCODE_MASK = 0xF0 # noqa: E221
|
|
REBASE_IMMEDIATE_MASK = 0x0F # noqa: E221
|
|
REBASE_OPCODE_DONE = 0x00 # noqa: E221
|
|
REBASE_OPCODE_SET_TYPE_IMM = 0x10 # noqa: E221
|
|
REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x20 # noqa: E221
|
|
REBASE_OPCODE_ADD_ADDR_ULEB = 0x30 # noqa: E221
|
|
REBASE_OPCODE_ADD_ADDR_IMM_SCALED = 0x40 # noqa: E221
|
|
REBASE_OPCODE_DO_REBASE_IMM_TIMES = 0x50 # noqa: E221
|
|
REBASE_OPCODE_DO_REBASE_ULEB_TIMES = 0x60 # noqa: E221
|
|
REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB = 0x70 # noqa: E221
|
|
REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB = 0x80 # noqa: E221
|
|
|
|
BIND_TYPE_POINTER = 1 # noqa: E221
|
|
BIND_TYPE_TEXT_ABSOLUTE32 = 2 # noqa: E221
|
|
BIND_TYPE_TEXT_PCREL32 = 3 # noqa: E221
|
|
|
|
BIND_SPECIAL_DYLIB_SELF = 0 # noqa: E221
|
|
BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE = -1 # noqa: E221
|
|
BIND_SPECIAL_DYLIB_FLAT_LOOKUP = -2 # noqa: E221
|
|
|
|
BIND_SYMBOL_FLAGS_WEAK_IMPORT = 0x1 # noqa: E221
|
|
BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION = 0x8 # noqa: E221
|
|
|
|
BIND_OPCODE_MASK = 0xF0 # noqa: E221
|
|
BIND_IMMEDIATE_MASK = 0x0F # noqa: E221
|
|
BIND_OPCODE_DONE = 0x00 # noqa: E221
|
|
BIND_OPCODE_SET_DYLIB_ORDINAL_IMM = 0x10 # noqa: E221
|
|
BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB = 0x20 # noqa: E221
|
|
BIND_OPCODE_SET_DYLIB_SPECIAL_IMM = 0x30 # noqa: E221
|
|
BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM = 0x40 # noqa: E221
|
|
BIND_OPCODE_SET_TYPE_IMM = 0x50 # noqa: E221
|
|
BIND_OPCODE_SET_ADDEND_SLEB = 0x60 # noqa: E221
|
|
BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x70 # noqa: E221
|
|
BIND_OPCODE_ADD_ADDR_ULEB = 0x80 # noqa: E221
|
|
BIND_OPCODE_DO_BIND = 0x90 # noqa: E221
|
|
BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB = 0xA0 # noqa: E221
|
|
BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED = 0xB0 # noqa: E221
|
|
BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 0xC0 # noqa: E221
|
|
|
|
EXPORT_SYMBOL_FLAGS_KIND_MASK = 0x03 # noqa: E221
|
|
EXPORT_SYMBOL_FLAGS_KIND_REGULAR = 0x00 # noqa: E221
|
|
EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL = 0x01 # noqa: E221
|
|
EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION = 0x04 # noqa: E221
|
|
EXPORT_SYMBOL_FLAGS_REEXPORT = 0x08 # noqa: E221
|
|
EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER = 0x10 # noqa: E221
|
|
|
|
PLATFORM_MACOS = 1
|
|
PLATFORM_IOS = 2
|
|
PLATFORM_TVOS = 3
|
|
PLATFORM_WATCHOS = 4
|
|
PLATFORM_BRIDGEOS = 5
|
|
PLATFORM_IOSMAC = 6
|
|
PLATFORM_MACCATALYST = 6
|
|
PLATFORM_IOSSIMULATOR = 7
|
|
PLATFORM_TVOSSIMULATOR = 8
|
|
PLATFORM_WATCHOSSIMULATOR = 9
|
|
|
|
PLATFORM_NAMES = {
|
|
PLATFORM_MACOS: "macOS",
|
|
PLATFORM_IOS: "iOS",
|
|
PLATFORM_TVOS: "tvOS",
|
|
PLATFORM_WATCHOS: "watchOS",
|
|
PLATFORM_BRIDGEOS: "bridgeOS",
|
|
PLATFORM_MACCATALYST: "catalyst",
|
|
PLATFORM_IOSSIMULATOR: "iOS simulator",
|
|
PLATFORM_TVOSSIMULATOR: "tvOS simulator",
|
|
PLATFORM_WATCHOSSIMULATOR: "watchOS simulator",
|
|
}
|
|
|
|
TOOL_CLANG = 1
|
|
TOOL_SWIFT = 2
|
|
TOOL_LD = 3
|
|
|
|
TOOL_NAMES = {TOOL_CLANG: "clang", TOOL_SWIFT: "swift", TOOL_LD: "ld"}
|