This page hosts a formal specification of Executable and Linkable Format using Kaitai Struct. This specification can be automatically translated into a variety of programming languages to get a parsing library.
# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
# type: ignore
import kaitaistruct
from kaitaistruct import ReadWriteKaitaiStruct, KaitaiStream, BytesIO
from enum import IntEnum
if getattr(kaitaistruct, 'API_VERSION', (0, 9)) < (0, 11):
raise Exception("Incompatible Kaitai Struct Python API: 0.11 or later is required, but you have %s" % (kaitaistruct.__version__))
class Elf(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h
.. seealso::
Source - https://refspecs.linuxfoundation.org/elf/gabi4+/contents.html
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/elf-application-binary-interface.html
"""
class Bits(IntEnum):
b32 = 1
b64 = 2
class DynamicArrayTags(IntEnum):
null = 0
needed = 1
pltrelsz = 2
pltgot = 3
hash = 4
strtab = 5
symtab = 6
rela = 7
relasz = 8
relaent = 9
strsz = 10
syment = 11
init = 12
fini = 13
soname = 14
rpath = 15
symbolic = 16
rel = 17
relsz = 18
relent = 19
pltrel = 20
debug = 21
textrel = 22
jmprel = 23
bind_now = 24
init_array = 25
fini_array = 26
init_arraysz = 27
fini_arraysz = 28
runpath = 29
flags = 30
preinit_array = 32
preinit_arraysz = 33
symtab_shndx = 34
relrsz = 35
relr = 36
relrent = 37
deprecated_sparc_register = 117440513
sunw_auxiliary = 1610612749
sunw_rtldinf = 1610612750
sunw_filter = 1610612751
sunw_cap = 1610612752
sunw_symtab = 1610612753
sunw_symsz = 1610612754
sunw_sortent = 1610612755
sunw_symsort = 1610612756
sunw_symsortsz = 1610612757
sunw_tlssort = 1610612758
sunw_tlssortsz = 1610612759
sunw_capinfo = 1610612760
sunw_strpad = 1610612761
sunw_capchain = 1610612762
sunw_ldmach = 1610612763
sunw_symtab_shndx = 1610612764
sunw_capchainent = 1610612765
sunw_deferred = 1610612766
sunw_capchainsz = 1610612767
sunw_phname = 1610612768
sunw_parent = 1610612769
sunw_sx_aslr = 1610612771
sunw_relax = 1610612773
sunw_kmod = 1610612775
sunw_sx_nxheap = 1610612777
sunw_sx_nxstack = 1610612779
sunw_sx_adiheap = 1610612781
sunw_sx_adistack = 1610612783
sunw_sx_ssbd = 1610612785
sunw_symnsort = 1610612786
sunw_symnsortsz = 1610612787
gnu_flags_1 = 1879047668
gnu_prelinked = 1879047669
gnu_conflictsz = 1879047670
gnu_liblistsz = 1879047671
checksum = 1879047672
pltpadsz = 1879047673
moveent = 1879047674
movesz = 1879047675
feature_1 = 1879047676
posflag_1 = 1879047677
syminsz = 1879047678
syminent = 1879047679
gnu_hash = 1879047925
tlsdesc_plt = 1879047926
tlsdesc_got = 1879047927
gnu_conflict = 1879047928
gnu_liblist = 1879047929
config = 1879047930
depaudit = 1879047931
audit = 1879047932
pltpad = 1879047933
movetab = 1879047934
syminfo = 1879047935
versym = 1879048176
relacount = 1879048185
relcount = 1879048186
flags_1 = 1879048187
verdef = 1879048188
verdefnum = 1879048189
verneed = 1879048190
verneednum = 1879048191
sparc_register = 1879048193
auxiliary = 2147483645
used = 2147483646
filter = 2147483647
class Endian(IntEnum):
le = 1
be = 2
class Machine(IntEnum):
no_machine = 0
m32 = 1
sparc = 2
i386 = 3
m68k = 4
m88k = 5
iamcu = 6
i860 = 7
mips = 8
s370 = 9
mips_rs3_le = 10
old_sparc_v9 = 11
parisc = 15
vpp500 = 17
sparc32plus = 18
i960 = 19
powerpc = 20
powerpc64 = 21
s390 = 22
spu = 23
v800 = 36
fr20 = 37
rh32 = 38
mcore = 39
arm = 40
old_alpha = 41
superh = 42
sparc_v9 = 43
tricore = 44
arc = 45
h8_300 = 46
h8_300h = 47
h8s = 48
h8_500 = 49
ia_64 = 50
mips_x = 51
coldfire = 52
m68hc12 = 53
mma = 54
pcp = 55
ncpu = 56
ndr1 = 57
starcore = 58
me16 = 59
st100 = 60
tinyj = 61
x86_64 = 62
pdsp = 63
pdp10 = 64
pdp11 = 65
fx66 = 66
st9plus = 67
st7 = 68
m68hc16 = 69
m68hc11 = 70
m68hc08 = 71
m68hc05 = 72
svx = 73
st19 = 74
vax = 75
cris = 76
javelin = 77
firepath = 78
zsp = 79
mmix = 80
huany = 81
prism = 82
avr = 83
fr30 = 84
d10v = 85
d30v = 86
v850 = 87
m32r = 88
mn10300 = 89
mn10200 = 90
picojava = 91
or1k = 92
arc_compact = 93
xtensa = 94
videocore = 95
tmm_gpp = 96
ns32k = 97
tpc = 98
snp1k = 99
st200 = 100
ip2k = 101
max = 102
cr = 103
f2mc16 = 104
msp430 = 105
blackfin = 106
se_c33 = 107
sep = 108
arca = 109
unicore = 110
excess = 111
dxp = 112
altera_nios2 = 113
crx = 114
xgate = 115
c166 = 116
m16c = 117
dspic30f = 118
freescale_ce = 119
m32c = 120
tsk3000 = 131
rs08 = 132
sharc = 133
ecog2 = 134
score7 = 135
dsp24 = 136
videocore3 = 137
latticemico32 = 138
se_c17 = 139
ti_c6000 = 140
ti_c2000 = 141
ti_c5500 = 142
ti_arp32 = 143
ti_pru = 144
mmdsp_plus = 160
cypress_m8c = 161
r32c = 162
trimedia = 163
qdsp6 = 164
i8051 = 165
stxp7x = 166
nds32 = 167
ecog1x = 168
maxq30 = 169
ximo16 = 170
manik = 171
cray_nv2 = 172
rx = 173
metag = 174
mcst_elbrus = 175
ecog16 = 176
cr16 = 177
etpu = 178
sle9x = 179
l1om = 180
k1om = 181
intel182 = 182
aarch64 = 183
arm184 = 184
avr32 = 185
stm8 = 186
tile64 = 187
tilepro = 188
microblaze = 189
cuda = 190
tilegx = 191
cloudshield = 192
corea_1st = 193
corea_2nd = 194
arc_compact2 = 195
open8 = 196
rl78 = 197
videocore5 = 198
renesas_78k0r = 199
freescale_56800ex = 200
ba1 = 201
ba2 = 202
xcore = 203
mchp_pic = 204
intelgt = 205
intel206 = 206
intel207 = 207
intel208 = 208
intel209 = 209
km32 = 210
kmx32 = 211
kmx16 = 212
kmx8 = 213
kvarc = 214
cdp = 215
coge = 216
cool = 217
norc = 218
csr_kalimba = 219
z80 = 220
visium = 221
ft32 = 222
moxie = 223
amdgpu = 224
riscv = 243
lanai = 244
ceva = 245
ceva_x2 = 246
bpf = 247
graphcore_ipu = 248
img1 = 249
nfp = 250
ve = 251
csky = 252
arc_compact3_64 = 253
mcs6502 = 254
arc_compact3 = 255
kvx = 256
wdc_65816 = 257
loongarch = 258
kf32 = 259
u16_u8core = 260
tachyum = 261
nxp_56800ef = 262
sbf = 263
ai_engine = 264
sima_mla = 265
bang = 266
loonggpu = 267
sw64 = 268
ai_engine_ctrlcode = 269
ppu = 270
avr_old = 4183
msp430_old = 4185
adapteva_epiphany = 4643
mt = 9520
cygnus_fr30 = 13104
webassembly = 16727
xc16x = 18056
s12z = 19951
cygnus_frv = 21569
dlx = 23205
cygnus_d10v = 30288
cygnus_d30v = 30326
ip2k_old = 33303
cygnus_powerpc = 36901
alpha = 36902
cygnus_m32r = 36929
cygnus_v850 = 36992
s390_old = 41872
xtensa_old = 43975
xstormy16 = 44357
microblaze_old = 47787
cygnus_mn10300 = 48879
cygnus_mn10200 = 57005
cygnus_mep = 61453
m32c_old = 65200
iq2000 = 65210
nios32 = 65211
moxie_old = 65261
class ObjType(IntEnum):
no_file_type = 0
relocatable = 1
executable = 2
shared = 3
core = 4
class OsAbi(IntEnum):
system_v = 0
hp_ux = 1
netbsd = 2
gnu = 3
solaris = 6
aix = 7
irix = 8
freebsd = 9
tru64 = 10
modesto = 11
openbsd = 12
openvms = 13
nsk = 14
aros = 15
fenixos = 16
cloudabi = 17
openvos = 18
cuda = 51
arm_aeabi = 64
arm_fdpic = 65
amdgpu_mesa3d = 66
arm = 97
standalone = 255
class PhType(IntEnum):
null_type = 0
load = 1
dynamic = 2
interp = 3
note = 4
shlib = 5
phdr = 6
tls = 7
sunw_unwind = 1684333904
gnu_eh_frame = 1685382480
gnu_stack = 1685382481
gnu_relro = 1685382482
gnu_property = 1685382483
gnu_sframe = 1685382484
pax_flags = 1694766464
openbsd_mutable = 1705237477
openbsd_randomize = 1705237478
openbsd_wxneeded = 1705237479
openbsd_nobtcfi = 1705237480
openbsd_syscalls = 1705237481
openbsd_bootdata = 1705253862
sunw_sysstat_zone = 1879048183
sunw_sysstat = 1879048184
sunw_reserve = 1879048185
sunw_bss = 1879048186
sunw_stack = 1879048187
sunw_dtrace = 1879048188
sunw_cap = 1879048189
arm_archext = 1879048192
arm_exidx = 1879048193
aarch64_memtag_mte = 1879048194
riscv_attributes = 1879048195
class SectionHeaderIdxSpecial(IntEnum):
undefined = 0
before = 65280
after = 65281
amd64_lcommon = 65282
sunw_ignore = 65343
abs = 65521
common = 65522
xindex = 65535
class ShType(IntEnum):
null_type = 0
progbits = 1
symtab = 2
strtab = 3
rela = 4
hash = 5
dynamic = 6
note = 7
nobits = 8
rel = 9
shlib = 10
dynsym = 11
init_array = 14
fini_array = 15
preinit_array = 16
group = 17
symtab_shndx = 18
relr = 19
android_rel = 1610612737
android_rela = 1610612738
gnu_incremental_inputs = 1879000832
llvm_odrtab = 1879002112
llvm_linker_options = 1879002113
llvm_addrsig = 1879002115
llvm_dependent_libraries = 1879002116
llvm_sympart = 1879002117
llvm_part_ehdr = 1879002118
llvm_part_phdr = 1879002119
llvm_bb_addr_map_v0 = 1879002120
llvm_call_graph_profile = 1879002121
llvm_bb_addr_map = 1879002122
llvm_offloading = 1879002123
llvm_lto = 1879002124
llvm_jt_sizes = 1879002125
llvm_cfi_jump_table = 1879002126
llvm_call_graph = 1879002127
llvm_dyndbg_elf = 1879002128
android_relr = 1879047936
sunw_ctf = 1879048171
sunw_symnsort = 1879048172
sunw_phname = 1879048173
sunw_ancillary = 1879048174
sunw_capchain = 1879048175
sunw_capinfo = 1879048176
sunw_symsort = 1879048177
sunw_tlssort = 1879048178
sunw_ldynsym = 1879048179
gnu_sframe = 1879048180
gnu_attributes = 1879048181
gnu_hash = 1879048182
gnu_liblist = 1879048183
checksum = 1879048184
gnu_object_only = 1879048185
sunw_move = 1879048186
sunw_comdat = 1879048187
sunw_syminfo = 1879048188
gnu_verdef = 1879048189
gnu_verneed = 1879048190
gnu_versym = 1879048191
sparc_gotdata = 1879048192
x86_64_unwind = 1879048193
arm_preemptmap = 1879048194
arm_attributes = 1879048195
arm_debugoverlay = 1879048196
arm_overlaysection = 1879048197
aarch64_memtag_globals_static = 1879048199
aarch64_memtag_globals_dynamic = 1879048200
class SymbolBinding(IntEnum):
local = 0
global_symbol = 1
weak = 2
os10 = 10
os11 = 11
os12 = 12
proc13 = 13
proc14 = 14
proc15 = 15
class SymbolType(IntEnum):
no_type = 0
object = 1
func = 2
section = 3
file = 4
common = 5
tls = 6
relc = 8
srelc = 9
gnu_ifunc = 10
os11 = 11
os12 = 12
proc13 = 13
proc14 = 14
proc15 = 15
class SymbolVisibility(IntEnum):
default = 0
internal = 1
hidden = 2
protected = 3
exported = 4
singleton = 5
eliminate = 6
class VersionIndexSpecial(IntEnum):
local = 0
global_symbol = 1
eliminate = 65281
def __init__(self, _io=None, _parent=None, _root=None):
super(Elf, self).__init__(_io)
self._parent = _parent
self._root = _root or self
def _read(self):
self.magic = self._io.read_bytes(4)
if not self.magic == b"\x7F\x45\x4C\x46":
raise kaitaistruct.ValidationNotEqualError(b"\x7F\x45\x4C\x46", self.magic, self._io, u"/seq/0")
self.bits = KaitaiStream.resolve_enum(Elf.Bits, self._io.read_u1())
self.endian = KaitaiStream.resolve_enum(Elf.Endian, self._io.read_u1())
self.ei_version = self._io.read_u1()
if not self.ei_version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.ei_version, self._io, u"/seq/3")
self.abi = KaitaiStream.resolve_enum(Elf.OsAbi, self._io.read_u1())
self.abi_version = self._io.read_u1()
self.pad = self._io.read_bytes(7)
if not self.pad == b"\x00\x00\x00\x00\x00\x00\x00":
raise kaitaistruct.ValidationNotEqualError(b"\x00\x00\x00\x00\x00\x00\x00", self.pad, self._io, u"/seq/6")
self.header = Elf.EndianElf(self._io, self, self._root)
self.header._read()
self._dirty = False
def _fetch_instances(self):
pass
self.header._fetch_instances()
def _write__seq(self, io=None):
super(Elf, self)._write__seq(io)
self._io.write_bytes(self.magic)
self._io.write_u1(int(self.bits))
self._io.write_u1(int(self.endian))
self._io.write_u1(self.ei_version)
self._io.write_u1(int(self.abi))
self._io.write_u1(self.abi_version)
self._io.write_bytes(self.pad)
self.header._write__seq(self._io)
def _check(self):
if len(self.magic) != 4:
raise kaitaistruct.ConsistencyError(u"magic", 4, len(self.magic))
if not self.magic == b"\x7F\x45\x4C\x46":
raise kaitaistruct.ValidationNotEqualError(b"\x7F\x45\x4C\x46", self.magic, None, u"/seq/0")
if not self.ei_version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.ei_version, None, u"/seq/3")
if len(self.pad) != 7:
raise kaitaistruct.ConsistencyError(u"pad", 7, len(self.pad))
if not self.pad == b"\x00\x00\x00\x00\x00\x00\x00":
raise kaitaistruct.ValidationNotEqualError(b"\x00\x00\x00\x00\x00\x00\x00", self.pad, None, u"/seq/6")
if self.header._root != self._root:
raise kaitaistruct.ConsistencyError(u"header", self._root, self.header._root)
if self.header._parent != self:
raise kaitaistruct.ConsistencyError(u"header", self, self.header._parent)
self._dirty = False
class DtFlag1Values(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L1008
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/dynamic-section.html#GUID-4336A69A-D905-4FCE-A398-80375A9E6464__CHAPTER6-TBL-53
"""
def __init__(self, value, _io=None, _parent=None, _root=None):
super(Elf.DtFlag1Values, self).__init__(_io)
self._parent = _parent
self._root = _root
self.value = value
def _read(self):
pass
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.DtFlag1Values, self)._write__seq(io)
def _check(self):
self._dirty = False
@property
def conf_alt(self):
"""Configuration alternative created.
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L1023
"""
if hasattr(self, '_m_conf_alt'):
return self._m_conf_alt
self._m_conf_alt = self.value & 8192 != 0
return getattr(self, '_m_conf_alt', None)
def _invalidate_conf_alt(self):
del self._m_conf_alt
@property
def direct(self):
"""Direct binding enabled."""
if hasattr(self, '_m_direct'):
return self._m_direct
self._m_direct = self.value & 256 != 0
return getattr(self, '_m_direct', None)
def _invalidate_direct(self):
del self._m_direct
@property
def disp_rel_dne(self):
"""Displacement relocation done (applied at build time)."""
if hasattr(self, '_m_disp_rel_dne'):
return self._m_disp_rel_dne
self._m_disp_rel_dne = self.value & 32768 != 0
return getattr(self, '_m_disp_rel_dne', None)
def _invalidate_disp_rel_dne(self):
del self._m_disp_rel_dne
@property
def disp_rel_pnd(self):
"""Displacement relocation pending (applied at runtime)."""
if hasattr(self, '_m_disp_rel_pnd'):
return self._m_disp_rel_pnd
self._m_disp_rel_pnd = self.value & 65536 != 0
return getattr(self, '_m_disp_rel_pnd', None)
def _invalidate_disp_rel_pnd(self):
del self._m_disp_rel_pnd
@property
def edited(self):
"""Object is modified after built."""
if hasattr(self, '_m_edited'):
return self._m_edited
self._m_edited = self.value & 2097152 != 0
return getattr(self, '_m_edited', None)
def _invalidate_edited(self):
del self._m_edited
@property
def end_filtee(self):
"""Filtee terminates filters search."""
if hasattr(self, '_m_end_filtee'):
return self._m_end_filtee
self._m_end_filtee = self.value & 16384 != 0
return getattr(self, '_m_end_filtee', None)
def _invalidate_end_filtee(self):
del self._m_end_filtee
@property
def glob_audit(self):
"""Global auditing required."""
if hasattr(self, '_m_glob_audit'):
return self._m_glob_audit
self._m_glob_audit = self.value & 16777216 != 0
return getattr(self, '_m_glob_audit', None)
def _invalidate_glob_audit(self):
del self._m_glob_audit
@property
def group(self):
"""Set `RTLD_GROUP` for this object."""
if hasattr(self, '_m_group'):
return self._m_group
self._m_group = self.value & 4 != 0
return getattr(self, '_m_group', None)
def _invalidate_group(self):
del self._m_group
@property
def ign_mul_def(self):
if hasattr(self, '_m_ign_mul_def'):
return self._m_ign_mul_def
self._m_ign_mul_def = self.value & 262144 != 0
return getattr(self, '_m_ign_mul_def', None)
def _invalidate_ign_mul_def(self):
del self._m_ign_mul_def
@property
def init_first(self):
"""Set `RTLD_INITFIRST` for this object."""
if hasattr(self, '_m_init_first'):
return self._m_init_first
self._m_init_first = self.value & 32 != 0
return getattr(self, '_m_init_first', None)
def _invalidate_init_first(self):
del self._m_init_first
@property
def interpose(self):
"""Object is used to interpose."""
if hasattr(self, '_m_interpose'):
return self._m_interpose
self._m_interpose = self.value & 1024 != 0
return getattr(self, '_m_interpose', None)
def _invalidate_interpose(self):
del self._m_interpose
@property
def kmod(self):
"""Object is a kernel module."""
if hasattr(self, '_m_kmod'):
return self._m_kmod
self._m_kmod = self.value & 268435456 != 0
return getattr(self, '_m_kmod', None)
def _invalidate_kmod(self):
del self._m_kmod
@property
def load_fltr(self):
"""Trigger filtee loading at runtime."""
if hasattr(self, '_m_load_fltr'):
return self._m_load_fltr
self._m_load_fltr = self.value & 16 != 0
return getattr(self, '_m_load_fltr', None)
def _invalidate_load_fltr(self):
del self._m_load_fltr
@property
def no_common(self):
"""No COMMON symbols exist.
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L1040
"""
if hasattr(self, '_m_no_common'):
return self._m_no_common
self._m_no_common = self.value & 1073741824 != 0
return getattr(self, '_m_no_common', None)
def _invalidate_no_common(self):
del self._m_no_common
@property
def no_def_lib(self):
"""Ignore the default library search path."""
if hasattr(self, '_m_no_def_lib'):
return self._m_no_def_lib
self._m_no_def_lib = self.value & 2048 != 0
return getattr(self, '_m_no_def_lib', None)
def _invalidate_no_def_lib(self):
del self._m_no_def_lib
@property
def no_delete(self):
"""Set `RTLD_NODELETE` for this object."""
if hasattr(self, '_m_no_delete'):
return self._m_no_delete
self._m_no_delete = self.value & 8 != 0
return getattr(self, '_m_no_delete', None)
def _invalidate_no_delete(self):
del self._m_no_delete
@property
def no_direct(self):
"""Object contains non-direct bindings."""
if hasattr(self, '_m_no_direct'):
return self._m_no_direct
self._m_no_direct = self.value & 131072 != 0
return getattr(self, '_m_no_direct', None)
def _invalidate_no_direct(self):
del self._m_no_direct
@property
def no_dump(self):
"""Object can't be dldump'ed."""
if hasattr(self, '_m_no_dump'):
return self._m_no_dump
self._m_no_dump = self.value & 4096 != 0
return getattr(self, '_m_no_dump', None)
def _invalidate_no_dump(self):
del self._m_no_dump
@property
def no_hdr(self):
if hasattr(self, '_m_no_hdr'):
return self._m_no_hdr
self._m_no_hdr = self.value & 1048576 != 0
return getattr(self, '_m_no_hdr', None)
def _invalidate_no_hdr(self):
del self._m_no_hdr
@property
def no_ksyms(self):
if hasattr(self, '_m_no_ksyms'):
return self._m_no_ksyms
self._m_no_ksyms = self.value & 524288 != 0
return getattr(self, '_m_no_ksyms', None)
def _invalidate_no_ksyms(self):
del self._m_no_ksyms
@property
def no_open(self):
"""Set `RTLD_NOOPEN` for this object."""
if hasattr(self, '_m_no_open'):
return self._m_no_open
self._m_no_open = self.value & 64 != 0
return getattr(self, '_m_no_open', None)
def _invalidate_no_open(self):
del self._m_no_open
@property
def no_reloc(self):
if hasattr(self, '_m_no_reloc'):
return self._m_no_reloc
self._m_no_reloc = self.value & 4194304 != 0
return getattr(self, '_m_no_reloc', None)
def _invalidate_no_reloc(self):
del self._m_no_reloc
@property
def now(self):
"""Set `RTLD_NOW` for this object."""
if hasattr(self, '_m_now'):
return self._m_now
self._m_now = self.value & 1 != 0
return getattr(self, '_m_now', None)
def _invalidate_now(self):
del self._m_now
@property
def origin(self):
"""`$ORIGIN` must be handled.
"""
if hasattr(self, '_m_origin'):
return self._m_origin
self._m_origin = self.value & 128 != 0
return getattr(self, '_m_origin', None)
def _invalidate_origin(self):
del self._m_origin
@property
def pie(self):
"""Object is a Position Independent Executable (PIE)."""
if hasattr(self, '_m_pie'):
return self._m_pie
self._m_pie = self.value & 134217728 != 0
return getattr(self, '_m_pie', None)
def _invalidate_pie(self):
del self._m_pie
@property
def rtld_global(self):
"""Set `RTLD_GLOBAL` for this object."""
if hasattr(self, '_m_rtld_global'):
return self._m_rtld_global
self._m_rtld_global = self.value & 2 != 0
return getattr(self, '_m_rtld_global', None)
def _invalidate_rtld_global(self):
del self._m_rtld_global
@property
def singleton(self):
"""Singleton symbols are used."""
if hasattr(self, '_m_singleton'):
return self._m_singleton
self._m_singleton = self.value & 33554432 != 0
return getattr(self, '_m_singleton', None)
def _invalidate_singleton(self):
del self._m_singleton
@property
def stub(self):
"""Object is a stub.
See [Stub Objects](https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/stub-objects.html).
"""
if hasattr(self, '_m_stub'):
return self._m_stub
self._m_stub = self.value & 67108864 != 0
return getattr(self, '_m_stub', None)
def _invalidate_stub(self):
del self._m_stub
@property
def sym_intpose(self):
"""Object has individual symbol interposers."""
if hasattr(self, '_m_sym_intpose'):
return self._m_sym_intpose
self._m_sym_intpose = self.value & 8388608 != 0
return getattr(self, '_m_sym_intpose', None)
def _invalidate_sym_intpose(self):
del self._m_sym_intpose
@property
def trans(self):
"""
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L1019
"""
if hasattr(self, '_m_trans'):
return self._m_trans
self._m_trans = self.value & 512 != 0
return getattr(self, '_m_trans', None)
def _invalidate_trans(self):
del self._m_trans
@property
def weak_filter(self):
"""Object is a weak standard filter."""
if hasattr(self, '_m_weak_filter'):
return self._m_weak_filter
self._m_weak_filter = self.value & 536870912 != 0
return getattr(self, '_m_weak_filter', None)
def _invalidate_weak_filter(self):
del self._m_weak_filter
class DtFlagValues(ReadWriteKaitaiStruct):
"""
.. seealso::
Figure 5-11: DT_FLAGS values - https://refspecs.linuxbase.org/elf/gabi4+/ch5.dynamic.html
.. seealso::
Source - https://github.com/golang/go/blob/48dfddbab3/src/debug/elf/elf.go#L1079-L1095
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/dynamic-section.html#GUID-4336A69A-D905-4FCE-A398-80375A9E6464__CHAPTER7-TBL-5
"""
def __init__(self, value, _io=None, _parent=None, _root=None):
super(Elf.DtFlagValues, self).__init__(_io)
self._parent = _parent
self._root = _root
self.value = value
def _read(self):
pass
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.DtFlagValues, self)._write__seq(io)
def _check(self):
self._dirty = False
@property
def bind_now(self):
"""all relocations for this object must be processed before returning
control to the program
"""
if hasattr(self, '_m_bind_now'):
return self._m_bind_now
self._m_bind_now = self.value & 8 != 0
return getattr(self, '_m_bind_now', None)
def _invalidate_bind_now(self):
del self._m_bind_now
@property
def origin(self):
"""object may reference the $ORIGIN substitution string."""
if hasattr(self, '_m_origin'):
return self._m_origin
self._m_origin = self.value & 1 != 0
return getattr(self, '_m_origin', None)
def _invalidate_origin(self):
del self._m_origin
@property
def static_tls(self):
"""object uses static thread-local storage scheme."""
if hasattr(self, '_m_static_tls'):
return self._m_static_tls
self._m_static_tls = self.value & 16 != 0
return getattr(self, '_m_static_tls', None)
def _invalidate_static_tls(self):
del self._m_static_tls
@property
def symbolic(self):
"""symbolic linking."""
if hasattr(self, '_m_symbolic'):
return self._m_symbolic
self._m_symbolic = self.value & 2 != 0
return getattr(self, '_m_symbolic', None)
def _invalidate_symbolic(self):
del self._m_symbolic
@property
def textrel(self):
"""relocation entries might request modifications to a non-writable segment."""
if hasattr(self, '_m_textrel'):
return self._m_textrel
self._m_textrel = self.value & 4 != 0
return getattr(self, '_m_textrel', None)
def _invalidate_textrel(self):
del self._m_textrel
class EndianElf(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/02-eheader.html
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/elf-header.html
"""
def __init__(self, _io=None, _parent=None, _root=None):
super(Elf.EndianElf, self).__init__(_io)
self._parent = _parent
self._root = _root
self._should_write_program_headers = False
self.program_headers__enabled = True
self._should_write_section_headers = False
self.section_headers__enabled = True
self._should_write_section_names = False
self.section_names__enabled = True
def _read(self):
_on = self._root.endian
if _on == Elf.Endian.le:
pass
self._is_le = True
elif _on == Elf.Endian.be:
pass
self._is_le = False
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.e_type = KaitaiStream.resolve_enum(Elf.ObjType, self._io.read_u2le())
self.machine = KaitaiStream.resolve_enum(Elf.Machine, self._io.read_u2le())
if not isinstance(self.machine, Elf.Machine):
raise kaitaistruct.ValidationNotInEnumError(self.machine, self._io, u"/types/endian_elf/seq/1")
self.e_version = self._io.read_u4le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.entry_point = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.entry_point = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_program_headers = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.ofs_program_headers = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_section_headers = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.ofs_section_headers = self._io.read_u8le()
self.flags = self._io.read_bytes(4)
self.e_ehsize = self._io.read_u2le()
self.program_header_size = self._io.read_u2le()
self.num_program_headers = self._io.read_u2le()
self.section_header_size = self._io.read_u2le()
self.num_section_headers = self._io.read_u2le()
self.section_names_idx = self._io.read_u2le()
self._dirty = False
def _read_be(self):
self.e_type = KaitaiStream.resolve_enum(Elf.ObjType, self._io.read_u2be())
self.machine = KaitaiStream.resolve_enum(Elf.Machine, self._io.read_u2be())
if not isinstance(self.machine, Elf.Machine):
raise kaitaistruct.ValidationNotInEnumError(self.machine, self._io, u"/types/endian_elf/seq/1")
self.e_version = self._io.read_u4be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.entry_point = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.entry_point = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_program_headers = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.ofs_program_headers = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_section_headers = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.ofs_section_headers = self._io.read_u8be()
self.flags = self._io.read_bytes(4)
self.e_ehsize = self._io.read_u2be()
self.program_header_size = self._io.read_u2be()
self.num_program_headers = self._io.read_u2be()
self.section_header_size = self._io.read_u2be()
self.num_section_headers = self._io.read_u2be()
self.section_names_idx = self._io.read_u2be()
self._dirty = False
def _fetch_instances(self):
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_ = self.program_headers
if hasattr(self, '_m_program_headers'):
pass
for i in range(len(self._m_program_headers)):
pass
self._m_program_headers[i]._fetch_instances()
_ = self.section_headers
if hasattr(self, '_m_section_headers'):
pass
for i in range(len(self._m_section_headers)):
pass
self._m_section_headers[i]._fetch_instances()
_ = self.section_names
if hasattr(self, '_m_section_names'):
pass
self._m_section_names._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_program_headers = self.program_headers__enabled
self._should_write_section_headers = self.section_headers__enabled
self._should_write_section_names = self.section_names__enabled
self._io.write_u2le(int(self.e_type))
self._io.write_u2le(int(self.machine))
self._io.write_u4le(self.e_version)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.entry_point)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.entry_point)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.ofs_program_headers)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.ofs_program_headers)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.ofs_section_headers)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.ofs_section_headers)
self._io.write_bytes(self.flags)
self._io.write_u2le(self.e_ehsize)
self._io.write_u2le(self.program_header_size)
self._io.write_u2le(self.num_program_headers)
self._io.write_u2le(self.section_header_size)
self._io.write_u2le(self.num_section_headers)
self._io.write_u2le(self.section_names_idx)
def _write__seq_be(self):
self._should_write_program_headers = self.program_headers__enabled
self._should_write_section_headers = self.section_headers__enabled
self._should_write_section_names = self.section_names__enabled
self._io.write_u2be(int(self.e_type))
self._io.write_u2be(int(self.machine))
self._io.write_u4be(self.e_version)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.entry_point)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.entry_point)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.ofs_program_headers)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.ofs_program_headers)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.ofs_section_headers)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.ofs_section_headers)
self._io.write_bytes(self.flags)
self._io.write_u2be(self.e_ehsize)
self._io.write_u2be(self.program_header_size)
self._io.write_u2be(self.num_program_headers)
self._io.write_u2be(self.section_header_size)
self._io.write_u2be(self.num_section_headers)
self._io.write_u2be(self.section_names_idx)
def _check(self):
if not isinstance(self.machine, Elf.Machine):
raise kaitaistruct.ValidationNotInEnumError(self.machine, None, u"/types/endian_elf/seq/1")
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if len(self.flags) != 4:
raise kaitaistruct.ConsistencyError(u"flags", 4, len(self.flags))
if self.program_headers__enabled:
pass
if len(self._m_program_headers) != self.num_program_headers:
raise kaitaistruct.ConsistencyError(u"program_headers", self.num_program_headers, len(self._m_program_headers))
for i in range(len(self._m_program_headers)):
pass
if self._m_program_headers[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"program_headers", self._root, self._m_program_headers[i]._root)
if self._m_program_headers[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"program_headers", self, self._m_program_headers[i]._parent)
if self.section_headers__enabled:
pass
if len(self._m_section_headers) != self.num_section_headers:
raise kaitaistruct.ConsistencyError(u"section_headers", self.num_section_headers, len(self._m_section_headers))
for i in range(len(self._m_section_headers)):
pass
if self._m_section_headers[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"section_headers", self._root, self._m_section_headers[i]._root)
if self._m_section_headers[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"section_headers", self, self._m_section_headers[i]._parent)
if self.section_names__enabled:
pass
if ((self.section_names_idx != int(Elf.SectionHeaderIdxSpecial.undefined)) and (self.section_names_idx < self._root.header.num_section_headers)) :
pass
if self._m_section_names._root != self._root:
raise kaitaistruct.ConsistencyError(u"section_names", self._root, self._m_section_names._root)
if self._m_section_names._parent != self:
raise kaitaistruct.ConsistencyError(u"section_names", self, self._m_section_names._parent)
self._dirty = False
class DynsymSection(ReadWriteKaitaiStruct):
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.DynsymSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/dynsym_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.DynsymSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _read_be(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.DynsymSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _fetch_instances(self):
pass
for i in range(len(self.entries)):
pass
self.entries[i]._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.DynsymSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/dynsym_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _write__seq_be(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _check(self):
for i in range(len(self.entries)):
pass
if self.entries[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"entries", self._root, self.entries[i]._root)
if self.entries[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"entries", self, self.entries[i]._parent)
self._dirty = False
@property
def is_string_table_linked(self):
if hasattr(self, '_m_is_string_table_linked'):
return self._m_is_string_table_linked
self._m_is_string_table_linked = self._parent.linked_section.type == Elf.ShType.strtab
return getattr(self, '_m_is_string_table_linked', None)
def _invalidate_is_string_table_linked(self):
del self._m_is_string_table_linked
class DynsymSectionEntry(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://gabi.xinuos.com/elf/05-symtab.html
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/symbol-table-section.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.DynsymSectionEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_name = False
self.name__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/dynsym_section_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.ofs_name = self._io.read_u4le()
if self._root.bits == Elf.Bits.b32:
pass
self.value_b32 = self._io.read_u4le()
if self._root.bits == Elf.Bits.b32:
pass
self.size_b32 = self._io.read_u4le()
self.bind = KaitaiStream.resolve_enum(Elf.SymbolBinding, self._io.read_bits_int_be(4))
self.type = KaitaiStream.resolve_enum(Elf.SymbolType, self._io.read_bits_int_be(4))
self.other = self._io.read_u1()
self.sh_idx = self._io.read_u2le()
if self._root.bits == Elf.Bits.b64:
pass
self.value_b64 = self._io.read_u8le()
if self._root.bits == Elf.Bits.b64:
pass
self.size_b64 = self._io.read_u8le()
self._dirty = False
def _read_be(self):
self.ofs_name = self._io.read_u4be()
if self._root.bits == Elf.Bits.b32:
pass
self.value_b32 = self._io.read_u4be()
if self._root.bits == Elf.Bits.b32:
pass
self.size_b32 = self._io.read_u4be()
self.bind = KaitaiStream.resolve_enum(Elf.SymbolBinding, self._io.read_bits_int_be(4))
self.type = KaitaiStream.resolve_enum(Elf.SymbolType, self._io.read_bits_int_be(4))
self.other = self._io.read_u1()
self.sh_idx = self._io.read_u2be()
if self._root.bits == Elf.Bits.b64:
pass
self.value_b64 = self._io.read_u8be()
if self._root.bits == Elf.Bits.b64:
pass
self.size_b64 = self._io.read_u8be()
self._dirty = False
def _fetch_instances(self):
pass
if self._root.bits == Elf.Bits.b32:
pass
if self._root.bits == Elf.Bits.b32:
pass
if self._root.bits == Elf.Bits.b64:
pass
if self._root.bits == Elf.Bits.b64:
pass
_ = self.name
if hasattr(self, '_m_name'):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.DynsymSectionEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/dynsym_section_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_name = self.name__enabled
self._io.write_u4le(self.ofs_name)
if self._root.bits == Elf.Bits.b32:
pass
self._io.write_u4le(self.value_b32)
if self._root.bits == Elf.Bits.b32:
pass
self._io.write_u4le(self.size_b32)
self._io.write_bits_int_be(4, int(self.bind))
self._io.write_bits_int_be(4, int(self.type))
self._io.write_u1(self.other)
self._io.write_u2le(self.sh_idx)
if self._root.bits == Elf.Bits.b64:
pass
self._io.write_u8le(self.value_b64)
if self._root.bits == Elf.Bits.b64:
pass
self._io.write_u8le(self.size_b64)
def _write__seq_be(self):
self._should_write_name = self.name__enabled
self._io.write_u4be(self.ofs_name)
if self._root.bits == Elf.Bits.b32:
pass
self._io.write_u4be(self.value_b32)
if self._root.bits == Elf.Bits.b32:
pass
self._io.write_u4be(self.size_b32)
self._io.write_bits_int_be(4, int(self.bind))
self._io.write_bits_int_be(4, int(self.type))
self._io.write_u1(self.other)
self._io.write_u2be(self.sh_idx)
if self._root.bits == Elf.Bits.b64:
pass
self._io.write_u8be(self.value_b64)
if self._root.bits == Elf.Bits.b64:
pass
self._io.write_u8be(self.size_b64)
def _check(self):
if self._root.bits == Elf.Bits.b32:
pass
if self._root.bits == Elf.Bits.b32:
pass
if self._root.bits == Elf.Bits.b64:
pass
if self._root.bits == Elf.Bits.b64:
pass
if self.name__enabled:
pass
if ((self.ofs_name != 0) and (self._parent.is_string_table_linked)) :
pass
if KaitaiStream.byte_array_index_of((self._m_name).encode(u"UTF-8"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"name", -1, KaitaiStream.byte_array_index_of((self._m_name).encode(u"UTF-8"), 0))
self._dirty = False
@property
def is_sh_idx_os(self):
if hasattr(self, '_m_is_sh_idx_os'):
return self._m_is_sh_idx_os
self._m_is_sh_idx_os = ((self.sh_idx >= self._root.sh_idx_lo_os) and (self.sh_idx <= self._root.sh_idx_hi_os))
return getattr(self, '_m_is_sh_idx_os', None)
def _invalidate_is_sh_idx_os(self):
del self._m_is_sh_idx_os
@property
def is_sh_idx_proc(self):
if hasattr(self, '_m_is_sh_idx_proc'):
return self._m_is_sh_idx_proc
self._m_is_sh_idx_proc = ((self.sh_idx >= self._root.sh_idx_lo_proc) and (self.sh_idx <= self._root.sh_idx_hi_proc))
return getattr(self, '_m_is_sh_idx_proc', None)
def _invalidate_is_sh_idx_proc(self):
del self._m_is_sh_idx_proc
@property
def is_sh_idx_reserved(self):
if hasattr(self, '_m_is_sh_idx_reserved'):
return self._m_is_sh_idx_reserved
self._m_is_sh_idx_reserved = ((self.sh_idx >= self._root.sh_idx_lo_reserved) and (self.sh_idx <= self._root.sh_idx_hi_reserved))
return getattr(self, '_m_is_sh_idx_reserved', None)
def _invalidate_is_sh_idx_reserved(self):
del self._m_is_sh_idx_reserved
@property
def name(self):
if self._should_write_name:
self._write_name()
if hasattr(self, '_m_name'):
return self._m_name
if not self.name__enabled:
return None
if ((self.ofs_name != 0) and (self._parent.is_string_table_linked)) :
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
else:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
io.seek(_pos)
return getattr(self, '_m_name', None)
@name.setter
def name(self, v):
self._dirty = True
self._m_name = v
def _write_name(self):
self._should_write_name = False
if ((self.ofs_name != 0) and (self._parent.is_string_table_linked)) :
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
io.write_bytes((self._m_name).encode(u"UTF-8"))
io.write_u1(0)
else:
io.write_bytes((self._m_name).encode(u"UTF-8"))
io.write_u1(0)
io.seek(_pos)
@property
def sh_idx_special(self):
if hasattr(self, '_m_sh_idx_special'):
return self._m_sh_idx_special
self._m_sh_idx_special = KaitaiStream.resolve_enum(Elf.SectionHeaderIdxSpecial, self.sh_idx)
return getattr(self, '_m_sh_idx_special', None)
def _invalidate_sh_idx_special(self):
del self._m_sh_idx_special
@property
def size(self):
if hasattr(self, '_m_size'):
return self._m_size
self._m_size = (self.size_b32 if self._root.bits == Elf.Bits.b32 else (self.size_b64 if self._root.bits == Elf.Bits.b64 else 0))
return getattr(self, '_m_size', None)
def _invalidate_size(self):
del self._m_size
@property
def value(self):
if hasattr(self, '_m_value'):
return self._m_value
self._m_value = (self.value_b32 if self._root.bits == Elf.Bits.b32 else (self.value_b64 if self._root.bits == Elf.Bits.b64 else 0))
return getattr(self, '_m_value', None)
def _invalidate_value(self):
del self._m_value
@property
def visibility(self):
"""
.. seealso::
Source - https://github.com/xinuos/gabi/commit/acd5ebb2962cf243dca4983bc934442b42ef96f5
"""
if hasattr(self, '_m_visibility'):
return self._m_visibility
self._m_visibility = KaitaiStream.resolve_enum(Elf.SymbolVisibility, self.other & 7)
return getattr(self, '_m_visibility', None)
def _invalidate_visibility(self):
del self._m_visibility
class NoteSection(ReadWriteKaitaiStruct):
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.NoteSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/note_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.NoteSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _read_be(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.NoteSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _fetch_instances(self):
pass
for i in range(len(self.entries)):
pass
self.entries[i]._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.NoteSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/note_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _write__seq_be(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _check(self):
for i in range(len(self.entries)):
pass
if self.entries[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"entries", self._root, self.entries[i]._root)
if self.entries[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"entries", self, self.entries[i]._parent)
self._dirty = False
class NoteSectionEntry(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/note-section.html
.. seealso::
Source - https://refspecs.linuxfoundation.org/elf/gabi4+/ch5.pheader.html#note_section
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.NoteSectionEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/note_section_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.len_name = self._io.read_u4le()
self.len_descriptor = self._io.read_u4le()
self.type = self._io.read_u4le()
self.name = KaitaiStream.bytes_terminate(self._io.read_bytes(self.len_name), 0, False)
self.name_padding = self._io.read_bytes(-(self.len_name) % 4)
self.descriptor = self._io.read_bytes(self.len_descriptor)
self.descriptor_padding = self._io.read_bytes(-(self.len_descriptor) % 4)
self._dirty = False
def _read_be(self):
self.len_name = self._io.read_u4be()
self.len_descriptor = self._io.read_u4be()
self.type = self._io.read_u4be()
self.name = KaitaiStream.bytes_terminate(self._io.read_bytes(self.len_name), 0, False)
self.name_padding = self._io.read_bytes(-(self.len_name) % 4)
self.descriptor = self._io.read_bytes(self.len_descriptor)
self.descriptor_padding = self._io.read_bytes(-(self.len_descriptor) % 4)
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.NoteSectionEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/note_section_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._io.write_u4le(self.len_name)
self._io.write_u4le(self.len_descriptor)
self._io.write_u4le(self.type)
self._io.write_bytes_limit(self.name, self.len_name, 0, 0)
self._io.write_bytes(self.name_padding)
self._io.write_bytes(self.descriptor)
self._io.write_bytes(self.descriptor_padding)
def _write__seq_be(self):
self._io.write_u4be(self.len_name)
self._io.write_u4be(self.len_descriptor)
self._io.write_u4be(self.type)
self._io.write_bytes_limit(self.name, self.len_name, 0, 0)
self._io.write_bytes(self.name_padding)
self._io.write_bytes(self.descriptor)
self._io.write_bytes(self.descriptor_padding)
def _check(self):
if len(self.name) > self.len_name:
raise kaitaistruct.ConsistencyError(u"name", self.len_name, len(self.name))
if KaitaiStream.byte_array_index_of(self.name, 0) != -1:
raise kaitaistruct.ConsistencyError(u"name", -1, KaitaiStream.byte_array_index_of(self.name, 0))
if len(self.name_padding) != -(self.len_name) % 4:
raise kaitaistruct.ConsistencyError(u"name_padding", -(self.len_name) % 4, len(self.name_padding))
if len(self.descriptor) != self.len_descriptor:
raise kaitaistruct.ConsistencyError(u"descriptor", self.len_descriptor, len(self.descriptor))
if len(self.descriptor_padding) != -(self.len_descriptor) % 4:
raise kaitaistruct.ConsistencyError(u"descriptor_padding", -(self.len_descriptor) % 4, len(self.descriptor_padding))
self._dirty = False
class PhDynamicSection(ReadWriteKaitaiStruct):
"""Same type as `sh_dynamic_section`, but it does not use
`_parent.linked_section`, which is available only in section headers
(i.e. when `_parent` is of type `section_header`). This allows it to
be used in program headers (i.e. from the `program_header` type).
The inability to access `linked_section` means that offsets in the
string table (which should be stored in the `.dynstr` section) will
not be resolved to strings and will be provided only in raw form in
the `value_or_ptr` field. In other words, the
`ph_dynamic_section_entry` type has no `value_str` instance, unlike
the `sh_dynamic_section_entry` type.
There is another way to find the string table referenced by the
dynamic section entries that does not rely on `linked_section`, but is
a bit more complex (and is therefore considered out of scope of this
.ksy spec): the mandatory dynamic tag `dynamic_array_tags::strtab`
(`DT_STRTAB`) specifies the virtual address of the string table, and
`dynamic_array_tags::strsz` (`DT_STRSZ`) specifies its size in bytes.
The virtual address can be converted to a file offset by reading the
program headers - see the source code for the `readelf` command:
1. [`offset_from_vma` call site with an address from `DT_STRTAB` as an
argument](https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/binutils/readelf.c#L13018)
2. [`offset_from_vma` function
definition](https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/binutils/readelf.c#L7788)
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/08-dynamic.html#dynamic-section
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/dynamic-section.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.PhDynamicSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/ph_dynamic_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.entries = []
i = 0
while True:
_t_entries = Elf.EndianElf.PhDynamicSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
_ = _t_entries
self.entries.append(_)
if _.tag_enum == Elf.DynamicArrayTags.null:
break
i += 1
self._dirty = False
def _read_be(self):
self.entries = []
i = 0
while True:
_t_entries = Elf.EndianElf.PhDynamicSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
_ = _t_entries
self.entries.append(_)
if _.tag_enum == Elf.DynamicArrayTags.null:
break
i += 1
self._dirty = False
def _fetch_instances(self):
pass
for i in range(len(self.entries)):
pass
self.entries[i]._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.PhDynamicSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/ph_dynamic_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
for i in range(len(self.entries)):
pass
self.entries[i]._write__seq(self._io)
def _write__seq_be(self):
for i in range(len(self.entries)):
pass
self.entries[i]._write__seq(self._io)
def _check(self):
if len(self.entries) == 0:
raise kaitaistruct.ConsistencyError(u"entries", 0, len(self.entries))
for i in range(len(self.entries)):
pass
if self.entries[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"entries", self._root, self.entries[i]._root)
if self.entries[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"entries", self, self.entries[i]._parent)
_ = self.entries[i]
if (_.tag_enum == Elf.DynamicArrayTags.null) != (i == len(self.entries) - 1):
raise kaitaistruct.ConsistencyError(u"entries", i == len(self.entries) - 1, _.tag_enum == Elf.DynamicArrayTags.null)
self._dirty = False
class PhDynamicSectionEntry(ReadWriteKaitaiStruct):
"""Same type as `sh_dynamic_section_entry`, but without the `value_str`
instance - see the documentation for `ph_dynamic_section` for more
details.
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/08-dynamic.html#dynamic-section
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/dynamic-section.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.PhDynamicSectionEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_flag_1_values = False
self.flag_1_values__enabled = True
self._should_write_flag_values = False
self.flag_values__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/ph_dynamic_section_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.tag = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.tag = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.value_or_ptr = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.value_or_ptr = self._io.read_u8le()
self._dirty = False
def _read_be(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.tag = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.tag = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.value_or_ptr = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.value_or_ptr = self._io.read_u8be()
self._dirty = False
def _fetch_instances(self):
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_ = self.flag_1_values
if hasattr(self, '_m_flag_1_values'):
pass
self._m_flag_1_values._fetch_instances()
_ = self.flag_values
if hasattr(self, '_m_flag_values'):
pass
self._m_flag_values._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.PhDynamicSectionEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/ph_dynamic_section_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_flag_1_values = self.flag_1_values__enabled
self._should_write_flag_values = self.flag_values__enabled
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.tag)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.tag)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.value_or_ptr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.value_or_ptr)
def _write__seq_be(self):
self._should_write_flag_1_values = self.flag_1_values__enabled
self._should_write_flag_values = self.flag_values__enabled
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.tag)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.tag)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.value_or_ptr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.value_or_ptr)
def _check(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self.flag_1_values__enabled:
pass
if self.tag_enum == Elf.DynamicArrayTags.flags_1:
pass
if self._m_flag_1_values._root != self._root:
raise kaitaistruct.ConsistencyError(u"flag_1_values", self._root, self._m_flag_1_values._root)
if self._m_flag_1_values._parent != self:
raise kaitaistruct.ConsistencyError(u"flag_1_values", self, self._m_flag_1_values._parent)
if self._m_flag_1_values.value != self.value_or_ptr:
raise kaitaistruct.ConsistencyError(u"flag_1_values", self.value_or_ptr, self._m_flag_1_values.value)
if self.flag_values__enabled:
pass
if self.tag_enum == Elf.DynamicArrayTags.flags:
pass
if self._m_flag_values._root != self._root:
raise kaitaistruct.ConsistencyError(u"flag_values", self._root, self._m_flag_values._root)
if self._m_flag_values._parent != self:
raise kaitaistruct.ConsistencyError(u"flag_values", self, self._m_flag_values._parent)
if self._m_flag_values.value != self.value_or_ptr:
raise kaitaistruct.ConsistencyError(u"flag_values", self.value_or_ptr, self._m_flag_values.value)
self._dirty = False
@property
def flag_1_values(self):
if self._should_write_flag_1_values:
self._write_flag_1_values()
if hasattr(self, '_m_flag_1_values'):
return self._m_flag_1_values
if not self.flag_1_values__enabled:
return None
if self.tag_enum == Elf.DynamicArrayTags.flags_1:
pass
if self._is_le:
self._m_flag_1_values = Elf.DtFlag1Values(self.value_or_ptr, self._io, self, self._root)
self._m_flag_1_values._read()
else:
self._m_flag_1_values = Elf.DtFlag1Values(self.value_or_ptr, self._io, self, self._root)
self._m_flag_1_values._read()
return getattr(self, '_m_flag_1_values', None)
@flag_1_values.setter
def flag_1_values(self, v):
self._dirty = True
self._m_flag_1_values = v
def _write_flag_1_values(self):
self._should_write_flag_1_values = False
if self.tag_enum == Elf.DynamicArrayTags.flags_1:
pass
if self._is_le:
self._m_flag_1_values._write__seq(self._io)
else:
self._m_flag_1_values._write__seq(self._io)
@property
def flag_values(self):
if self._should_write_flag_values:
self._write_flag_values()
if hasattr(self, '_m_flag_values'):
return self._m_flag_values
if not self.flag_values__enabled:
return None
if self.tag_enum == Elf.DynamicArrayTags.flags:
pass
if self._is_le:
self._m_flag_values = Elf.DtFlagValues(self.value_or_ptr, self._io, self, self._root)
self._m_flag_values._read()
else:
self._m_flag_values = Elf.DtFlagValues(self.value_or_ptr, self._io, self, self._root)
self._m_flag_values._read()
return getattr(self, '_m_flag_values', None)
@flag_values.setter
def flag_values(self, v):
self._dirty = True
self._m_flag_values = v
def _write_flag_values(self):
self._should_write_flag_values = False
if self.tag_enum == Elf.DynamicArrayTags.flags:
pass
if self._is_le:
self._m_flag_values._write__seq(self._io)
else:
self._m_flag_values._write__seq(self._io)
@property
def is_value_str(self):
if hasattr(self, '_m_is_value_str'):
return self._m_is_value_str
self._m_is_value_str = ((self.value_or_ptr != 0) and ( ((self.tag_enum == Elf.DynamicArrayTags.needed) or (self.tag_enum == Elf.DynamicArrayTags.soname) or (self.tag_enum == Elf.DynamicArrayTags.rpath) or (self.tag_enum == Elf.DynamicArrayTags.runpath) or (self.tag_enum == Elf.DynamicArrayTags.sunw_auxiliary) or (self.tag_enum == Elf.DynamicArrayTags.sunw_filter) or (self.tag_enum == Elf.DynamicArrayTags.auxiliary) or (self.tag_enum == Elf.DynamicArrayTags.filter) or (self.tag_enum == Elf.DynamicArrayTags.config) or (self.tag_enum == Elf.DynamicArrayTags.depaudit) or (self.tag_enum == Elf.DynamicArrayTags.audit)) ))
return getattr(self, '_m_is_value_str', None)
def _invalidate_is_value_str(self):
del self._m_is_value_str
@property
def tag_enum(self):
if hasattr(self, '_m_tag_enum'):
return self._m_tag_enum
self._m_tag_enum = KaitaiStream.resolve_enum(Elf.DynamicArrayTags, self.tag)
return getattr(self, '_m_tag_enum', None)
def _invalidate_tag_enum(self):
del self._m_tag_enum
class ProgramHeader(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/07-pheader.html#program-header-entry
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/program-header.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.ProgramHeader, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_body = False
self.body__enabled = True
self._should_write_flags_obj = False
self.flags_obj__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/program_header")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.type = KaitaiStream.resolve_enum(Elf.PhType, self._io.read_u4le())
if self._root.bits == Elf.Bits.b64:
pass
self.flags64 = self._io.read_u4le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_body = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.ofs_body = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.virt_addr = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.virt_addr = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.phys_addr = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.phys_addr = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.len_body = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.len_body = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.memory_size = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.memory_size = self._io.read_u8le()
if self._root.bits == Elf.Bits.b32:
pass
self.flags32 = self._io.read_u4le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.align = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.align = self._io.read_u8le()
self._dirty = False
def _read_be(self):
self.type = KaitaiStream.resolve_enum(Elf.PhType, self._io.read_u4be())
if self._root.bits == Elf.Bits.b64:
pass
self.flags64 = self._io.read_u4be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_body = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.ofs_body = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.virt_addr = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.virt_addr = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.phys_addr = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.phys_addr = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.len_body = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.len_body = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.memory_size = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.memory_size = self._io.read_u8be()
if self._root.bits == Elf.Bits.b32:
pass
self.flags32 = self._io.read_u4be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.align = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.align = self._io.read_u8be()
self._dirty = False
def _fetch_instances(self):
pass
if self._root.bits == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self._root.bits == Elf.Bits.b32:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_ = self.body
if hasattr(self, '_m_body'):
pass
_on = self.type
if _on == Elf.PhType.dynamic:
pass
self._m_body._fetch_instances()
elif _on == Elf.PhType.interp:
pass
self._m_body._fetch_instances()
elif _on == Elf.PhType.note:
pass
self._m_body._fetch_instances()
else:
pass
_ = self.flags_obj
if hasattr(self, '_m_flags_obj'):
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._m_flags_obj._fetch_instances()
elif _on == Elf.Bits.b64:
pass
self._m_flags_obj._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.ProgramHeader, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/program_header")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_body = self.body__enabled
self._should_write_flags_obj = self.flags_obj__enabled
self._io.write_u4le(int(self.type))
if self._root.bits == Elf.Bits.b64:
pass
self._io.write_u4le(self.flags64)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.ofs_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.ofs_body)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.virt_addr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.virt_addr)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.phys_addr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.phys_addr)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.len_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.len_body)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.memory_size)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.memory_size)
if self._root.bits == Elf.Bits.b32:
pass
self._io.write_u4le(self.flags32)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.align)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.align)
def _write__seq_be(self):
self._should_write_body = self.body__enabled
self._should_write_flags_obj = self.flags_obj__enabled
self._io.write_u4be(int(self.type))
if self._root.bits == Elf.Bits.b64:
pass
self._io.write_u4be(self.flags64)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.ofs_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.ofs_body)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.virt_addr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.virt_addr)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.phys_addr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.phys_addr)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.len_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.len_body)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.memory_size)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.memory_size)
if self._root.bits == Elf.Bits.b32:
pass
self._io.write_u4be(self.flags32)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.align)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.align)
def _check(self):
if self._root.bits == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self._root.bits == Elf.Bits.b32:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self.body__enabled:
pass
if self.len_body != 0:
pass
_on = self.type
if _on == Elf.PhType.dynamic:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.PhType.interp:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.PhType.note:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
else:
pass
if len(self._m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"body", self.len_body, len(self._m_body))
if self.flags_obj__enabled:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
if self._m_flags_obj._root != self._root:
raise kaitaistruct.ConsistencyError(u"flags_obj", self._root, self._m_flags_obj._root)
if self._m_flags_obj._parent != self:
raise kaitaistruct.ConsistencyError(u"flags_obj", self, self._m_flags_obj._parent)
if self._m_flags_obj.value != self.flags32:
raise kaitaistruct.ConsistencyError(u"flags_obj", self.flags32, self._m_flags_obj.value)
elif _on == Elf.Bits.b64:
pass
if self._m_flags_obj._root != self._root:
raise kaitaistruct.ConsistencyError(u"flags_obj", self._root, self._m_flags_obj._root)
if self._m_flags_obj._parent != self:
raise kaitaistruct.ConsistencyError(u"flags_obj", self, self._m_flags_obj._parent)
if self._m_flags_obj.value != self.flags64:
raise kaitaistruct.ConsistencyError(u"flags_obj", self.flags64, self._m_flags_obj.value)
self._dirty = False
class PhInterpreter(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/08-dynamic.html#program-interpreter
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/program-interpreter.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.ProgramHeader.PhInterpreter, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/program_header/types/ph_interpreter")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.path_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
self._dirty = False
def _read_be(self):
self.path_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.ProgramHeader.PhInterpreter, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/program_header/types/ph_interpreter")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._io.write_bytes((self.path_name).encode(u"ASCII"))
self._io.write_u1(0)
def _write__seq_be(self):
self._io.write_bytes((self.path_name).encode(u"ASCII"))
self._io.write_u1(0)
def _check(self):
if KaitaiStream.byte_array_index_of((self.path_name).encode(u"ASCII"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"path_name", -1, KaitaiStream.byte_array_index_of((self.path_name).encode(u"ASCII"), 0))
self._dirty = False
@property
def body(self):
"""Note: a program header may not have a valid body in the same ELF
file, so accessing `body` may result in reading garbage or
triggering EOF errors.
In particular, `*.debug` files produced by elfutils'
`eu-strip --strip-debug` (as used by Fedora/RHEL and other
RPM-based distros for their `*-debuginfo` packages, e.g.
`glibc-debuginfo`) copy the original binary's program header table
verbatim, including `ofs_body`/`len_body` (i.e.
`p_offset`/`p_filesz`), while dropping the actual contents of most
segments. Such segments can be recognized by the fact that the
corresponding section headers have type `sh_type::nobits`
(`SHT_NOBITS`). However, this Kaitai Struct implementation doesn't
know the mapping between program headers and section headers, so
this must be handled externally.
`*.debug` files from Debian/Ubuntu `*-dbg` packages (e.g.
`libc6-dbg`) are usually not affected by this issue, because they
are produced using GNU Binutils (`objcopy --only-keep-debug`),
which zeroes `len_body` for segments whose contents were omitted
(which reliably tells us that there is no `body`).
"""
if self._should_write_body:
self._write_body()
if hasattr(self, '_m_body'):
return self._m_body
if not self.body__enabled:
return None
if self.len_body != 0:
pass
io = self._root._io
_pos = io.pos()
io.seek(self.ofs_body)
if self._is_le:
_on = self.type
if _on == Elf.PhType.dynamic:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.PhDynamicSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.PhType.interp:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.ProgramHeader.PhInterpreter(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.PhType.note:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.NoteSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
else:
pass
self._m_body = io.read_bytes(self.len_body)
else:
_on = self.type
if _on == Elf.PhType.dynamic:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.PhDynamicSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.PhType.interp:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.ProgramHeader.PhInterpreter(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.PhType.note:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.NoteSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
else:
pass
self._m_body = io.read_bytes(self.len_body)
io.seek(_pos)
return getattr(self, '_m_body', None)
@body.setter
def body(self, v):
self._dirty = True
self._m_body = v
def _write_body(self):
self._should_write_body = False
if self.len_body != 0:
pass
io = self._root._io
_pos = io.pos()
io.seek(self.ofs_body)
if self._is_le:
_on = self.type
if _on == Elf.PhType.dynamic:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.PhType.interp:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.PhType.note:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
else:
pass
io.write_bytes(self._m_body)
else:
_on = self.type
if _on == Elf.PhType.dynamic:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.PhType.interp:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.PhType.note:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
else:
pass
io.write_bytes(self._m_body)
io.seek(_pos)
@property
def flags_obj(self):
if self._should_write_flags_obj:
self._write_flags_obj()
if hasattr(self, '_m_flags_obj'):
return self._m_flags_obj
if not self.flags_obj__enabled:
return None
if self._is_le:
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._m_flags_obj = Elf.PhdrTypeFlags(self.flags32, self._io, self, self._root)
self._m_flags_obj._read()
elif _on == Elf.Bits.b64:
pass
self._m_flags_obj = Elf.PhdrTypeFlags(self.flags64, self._io, self, self._root)
self._m_flags_obj._read()
else:
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._m_flags_obj = Elf.PhdrTypeFlags(self.flags32, self._io, self, self._root)
self._m_flags_obj._read()
elif _on == Elf.Bits.b64:
pass
self._m_flags_obj = Elf.PhdrTypeFlags(self.flags64, self._io, self, self._root)
self._m_flags_obj._read()
return getattr(self, '_m_flags_obj', None)
@flags_obj.setter
def flags_obj(self, v):
self._dirty = True
self._m_flags_obj = v
def _write_flags_obj(self):
self._should_write_flags_obj = False
if self._is_le:
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._m_flags_obj._write__seq(self._io)
elif _on == Elf.Bits.b64:
pass
self._m_flags_obj._write__seq(self._io)
else:
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._m_flags_obj._write__seq(self._io)
elif _on == Elf.Bits.b64:
pass
self._m_flags_obj._write__seq(self._io)
class RelocationSection(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/relocation-sections.html
.. seealso::
Source - https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.reloc.html
"""
def __init__(self, has_addend, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.RelocationSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self.has_addend = has_addend
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/relocation_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.RelocationSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _read_be(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.RelocationSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _fetch_instances(self):
pass
for i in range(len(self.entries)):
pass
self.entries[i]._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.RelocationSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/relocation_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _write__seq_be(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _check(self):
for i in range(len(self.entries)):
pass
if self.entries[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"entries", self._root, self.entries[i]._root)
if self.entries[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"entries", self, self.entries[i]._parent)
self._dirty = False
class RelocationSectionEntry(ReadWriteKaitaiStruct):
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.RelocationSectionEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/relocation_section_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.offset = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.offset = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.info = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.info = self._io.read_u8le()
if self._parent.has_addend:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.addend = self._io.read_s4le()
elif _on == Elf.Bits.b64:
pass
self.addend = self._io.read_s8le()
self._dirty = False
def _read_be(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.offset = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.offset = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.info = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.info = self._io.read_u8be()
if self._parent.has_addend:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.addend = self._io.read_s4be()
elif _on == Elf.Bits.b64:
pass
self.addend = self._io.read_s8be()
self._dirty = False
def _fetch_instances(self):
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self._parent.has_addend:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.RelocationSectionEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/relocation_section_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.offset)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.offset)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.info)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.info)
if self._parent.has_addend:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_s4le(self.addend)
elif _on == Elf.Bits.b64:
pass
self._io.write_s8le(self.addend)
def _write__seq_be(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.offset)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.offset)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.info)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.info)
if self._parent.has_addend:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_s4be(self.addend)
elif _on == Elf.Bits.b64:
pass
self._io.write_s8be(self.addend)
def _check(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self._parent.has_addend:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
self._dirty = False
class SectionHeader(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/03-sheader.html#section-header-table-entry
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/section-headers.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.SectionHeader, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_body = False
self.body__enabled = True
self._should_write_flags_obj = False
self.flags_obj__enabled = True
self._should_write_name = False
self.name__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/section_header")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.ofs_name = self._io.read_u4le()
self.type = KaitaiStream.resolve_enum(Elf.ShType, self._io.read_u4le())
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.flags = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.flags = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.addr = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.addr = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_body = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.ofs_body = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.len_body = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.len_body = self._io.read_u8le()
self.linked_section_idx = self._io.read_u4le()
self.info = self._io.read_u4le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.align = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.align = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.entry_size = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.entry_size = self._io.read_u8le()
self._dirty = False
def _read_be(self):
self.ofs_name = self._io.read_u4be()
self.type = KaitaiStream.resolve_enum(Elf.ShType, self._io.read_u4be())
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.flags = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.flags = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.addr = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.addr = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.ofs_body = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.ofs_body = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.len_body = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.len_body = self._io.read_u8be()
self.linked_section_idx = self._io.read_u4be()
self.info = self._io.read_u4be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.align = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.align = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.entry_size = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.entry_size = self._io.read_u8be()
self._dirty = False
def _fetch_instances(self):
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_ = self.body
if hasattr(self, '_m_body'):
pass
_on = self.type
if _on == Elf.ShType.dynamic:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.dynsym:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.gnu_verdef:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.gnu_verneed:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.gnu_versym:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.note:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.rel:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.rela:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.strtab:
pass
self._m_body._fetch_instances()
elif _on == Elf.ShType.symtab:
pass
self._m_body._fetch_instances()
else:
pass
_ = self.flags_obj
if hasattr(self, '_m_flags_obj'):
pass
self._m_flags_obj._fetch_instances()
_ = self.name
if hasattr(self, '_m_name'):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.SectionHeader, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/section_header")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_body = self.body__enabled
self._should_write_flags_obj = self.flags_obj__enabled
self._should_write_name = self.name__enabled
self._io.write_u4le(self.ofs_name)
self._io.write_u4le(int(self.type))
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.flags)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.flags)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.addr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.addr)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.ofs_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.ofs_body)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.len_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.len_body)
self._io.write_u4le(self.linked_section_idx)
self._io.write_u4le(self.info)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.align)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.align)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.entry_size)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.entry_size)
def _write__seq_be(self):
self._should_write_body = self.body__enabled
self._should_write_flags_obj = self.flags_obj__enabled
self._should_write_name = self.name__enabled
self._io.write_u4be(self.ofs_name)
self._io.write_u4be(int(self.type))
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.flags)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.flags)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.addr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.addr)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.ofs_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.ofs_body)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.len_body)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.len_body)
self._io.write_u4be(self.linked_section_idx)
self._io.write_u4be(self.info)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.align)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.align)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.entry_size)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.entry_size)
def _check(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self.body__enabled:
pass
if self.type != Elf.ShType.nobits:
pass
_on = self.type
if _on == Elf.ShType.dynamic:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.ShType.dynsym:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.ShType.gnu_verdef:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.ShType.gnu_verneed:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.ShType.gnu_versym:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.ShType.note:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.ShType.rel:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
if self._m_body.has_addend != False:
raise kaitaistruct.ConsistencyError(u"body", False, self._m_body.has_addend)
elif _on == Elf.ShType.rela:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
if self._m_body.has_addend != True:
raise kaitaistruct.ConsistencyError(u"body", True, self._m_body.has_addend)
elif _on == Elf.ShType.strtab:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
elif _on == Elf.ShType.symtab:
pass
if self._m_body._root != self._root:
raise kaitaistruct.ConsistencyError(u"body", self._root, self._m_body._root)
if self._m_body._parent != self:
raise kaitaistruct.ConsistencyError(u"body", self, self._m_body._parent)
else:
pass
if len(self._m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"body", self.len_body, len(self._m_body))
if self.flags_obj__enabled:
pass
if self._m_flags_obj._root != self._root:
raise kaitaistruct.ConsistencyError(u"flags_obj", self._root, self._m_flags_obj._root)
if self._m_flags_obj._parent != self:
raise kaitaistruct.ConsistencyError(u"flags_obj", self, self._m_flags_obj._parent)
if self._m_flags_obj.value != self.flags:
raise kaitaistruct.ConsistencyError(u"flags_obj", self.flags, self._m_flags_obj.value)
if self.name__enabled:
pass
if KaitaiStream.byte_array_index_of((self._m_name).encode(u"ASCII"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"name", -1, KaitaiStream.byte_array_index_of((self._m_name).encode(u"ASCII"), 0))
self._dirty = False
@property
def body(self):
if self._should_write_body:
self._write_body()
if hasattr(self, '_m_body'):
return self._m_body
if not self.body__enabled:
return None
if self.type != Elf.ShType.nobits:
pass
io = self._root._io
_pos = io.pos()
io.seek(self.ofs_body)
if self._is_le:
_on = self.type
if _on == Elf.ShType.dynamic:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.ShDynamicSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.dynsym:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.DynsymSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.gnu_verdef:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.VerdefSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.gnu_verneed:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.VerneedSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.gnu_versym:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.VersymSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.note:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.NoteSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.rel:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.RelocationSection(False, _io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.rela:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.RelocationSection(True, _io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.strtab:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.StringsStruct(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.symtab:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.DynsymSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
else:
pass
self._m_body = io.read_bytes(self.len_body)
else:
_on = self.type
if _on == Elf.ShType.dynamic:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.ShDynamicSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.dynsym:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.DynsymSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.gnu_verdef:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.VerdefSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.gnu_verneed:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.VerneedSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.gnu_versym:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.VersymSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.note:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.NoteSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.rel:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.RelocationSection(False, _io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.rela:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.RelocationSection(True, _io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.strtab:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.StringsStruct(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
elif _on == Elf.ShType.symtab:
pass
self._raw__m_body = io.read_bytes(self.len_body)
_io__raw__m_body = KaitaiStream(BytesIO(self._raw__m_body))
self._m_body = Elf.EndianElf.DynsymSection(_io__raw__m_body, self, self._root, self._is_le)
self._m_body._read()
else:
pass
self._m_body = io.read_bytes(self.len_body)
io.seek(_pos)
return getattr(self, '_m_body', None)
@body.setter
def body(self, v):
self._dirty = True
self._m_body = v
def _write_body(self):
self._should_write_body = False
if self.type != Elf.ShType.nobits:
pass
io = self._root._io
_pos = io.pos()
io.seek(self.ofs_body)
if self._is_le:
_on = self.type
if _on == Elf.ShType.dynamic:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.dynsym:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.gnu_verdef:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.gnu_verneed:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.gnu_versym:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.note:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.rel:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.rela:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.strtab:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.symtab:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
else:
pass
io.write_bytes(self._m_body)
else:
_on = self.type
if _on == Elf.ShType.dynamic:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.dynsym:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.gnu_verdef:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.gnu_verneed:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.gnu_versym:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.note:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.rel:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.rela:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.strtab:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
elif _on == Elf.ShType.symtab:
pass
_io__raw__m_body = KaitaiStream(BytesIO(bytearray(self.len_body)))
io.add_child_stream(_io__raw__m_body)
_pos2 = io.pos()
io.seek(io.pos() + (self.len_body))
def handler(parent, _io__raw__m_body=_io__raw__m_body):
self._raw__m_body = _io__raw__m_body.to_byte_array()
if len(self._raw__m_body) != self.len_body:
raise kaitaistruct.ConsistencyError(u"raw(body)", self.len_body, len(self._raw__m_body))
parent.write_bytes(self._raw__m_body)
_io__raw__m_body.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_body._write__seq(_io__raw__m_body)
else:
pass
io.write_bytes(self._m_body)
io.seek(_pos)
@property
def flags_obj(self):
if self._should_write_flags_obj:
self._write_flags_obj()
if hasattr(self, '_m_flags_obj'):
return self._m_flags_obj
if not self.flags_obj__enabled:
return None
if self._is_le:
self._m_flags_obj = Elf.SectionHeaderFlags(self.flags, self._io, self, self._root)
self._m_flags_obj._read()
else:
self._m_flags_obj = Elf.SectionHeaderFlags(self.flags, self._io, self, self._root)
self._m_flags_obj._read()
return getattr(self, '_m_flags_obj', None)
@flags_obj.setter
def flags_obj(self, v):
self._dirty = True
self._m_flags_obj = v
def _write_flags_obj(self):
self._should_write_flags_obj = False
if self._is_le:
self._m_flags_obj._write__seq(self._io)
else:
self._m_flags_obj._write__seq(self._io)
@property
def linked_section(self):
"""may reference a later section header, so don't try to access too early (use only lazy `instances`).
.. seealso::
Source - https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.sheader.html#sh_link
"""
if hasattr(self, '_m_linked_section'):
return self._m_linked_section
if ((self.linked_section_idx != int(Elf.SectionHeaderIdxSpecial.undefined)) and (self.linked_section_idx < self._root.header.num_section_headers)) :
pass
self._m_linked_section = self._root.header.section_headers[self.linked_section_idx]
return getattr(self, '_m_linked_section', None)
def _invalidate_linked_section(self):
del self._m_linked_section
@property
def name(self):
if self._should_write_name:
self._write_name()
if hasattr(self, '_m_name'):
return self._m_name
if not self.name__enabled:
return None
io = self._root.header.section_names._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
else:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
io.seek(_pos)
return getattr(self, '_m_name', None)
@name.setter
def name(self, v):
self._dirty = True
self._m_name = v
def _write_name(self):
self._should_write_name = False
io = self._root.header.section_names._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
io.write_bytes((self._m_name).encode(u"ASCII"))
io.write_u1(0)
else:
io.write_bytes((self._m_name).encode(u"ASCII"))
io.write_u1(0)
io.seek(_pos)
class ShDynamicSection(ReadWriteKaitaiStruct):
"""Same type as `ph_dynamic_section`, but it depends on
`_parent.linked_section`, so it can be used only in the
`section_header` type. See the documentation for `ph_dynamic_section`
for more details.
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/08-dynamic.html#dynamic-section
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/dynamic-section.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.ShDynamicSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/sh_dynamic_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.entries = []
i = 0
while True:
_t_entries = Elf.EndianElf.ShDynamicSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
_ = _t_entries
self.entries.append(_)
if _.tag_enum == Elf.DynamicArrayTags.null:
break
i += 1
self._dirty = False
def _read_be(self):
self.entries = []
i = 0
while True:
_t_entries = Elf.EndianElf.ShDynamicSectionEntry(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
_ = _t_entries
self.entries.append(_)
if _.tag_enum == Elf.DynamicArrayTags.null:
break
i += 1
self._dirty = False
def _fetch_instances(self):
pass
for i in range(len(self.entries)):
pass
self.entries[i]._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.ShDynamicSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/sh_dynamic_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
for i in range(len(self.entries)):
pass
self.entries[i]._write__seq(self._io)
def _write__seq_be(self):
for i in range(len(self.entries)):
pass
self.entries[i]._write__seq(self._io)
def _check(self):
if len(self.entries) == 0:
raise kaitaistruct.ConsistencyError(u"entries", 0, len(self.entries))
for i in range(len(self.entries)):
pass
if self.entries[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"entries", self._root, self.entries[i]._root)
if self.entries[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"entries", self, self.entries[i]._parent)
_ = self.entries[i]
if (_.tag_enum == Elf.DynamicArrayTags.null) != (i == len(self.entries) - 1):
raise kaitaistruct.ConsistencyError(u"entries", i == len(self.entries) - 1, _.tag_enum == Elf.DynamicArrayTags.null)
self._dirty = False
@property
def is_string_table_linked(self):
if hasattr(self, '_m_is_string_table_linked'):
return self._m_is_string_table_linked
self._m_is_string_table_linked = self._parent.linked_section.type == Elf.ShType.strtab
return getattr(self, '_m_is_string_table_linked', None)
def _invalidate_is_string_table_linked(self):
del self._m_is_string_table_linked
class ShDynamicSectionEntry(ReadWriteKaitaiStruct):
"""Same type as `ph_dynamic_section_entry`, but with the `value_str`
instance - see the documentation for `ph_dynamic_section` for more
details.
.. seealso::
Source - https://gabi.xinuos.com/v42/elf/08-dynamic.html#dynamic-section
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/dynamic-section.html
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.ShDynamicSectionEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_flag_1_values = False
self.flag_1_values__enabled = True
self._should_write_flag_values = False
self.flag_values__enabled = True
self._should_write_value_str = False
self.value_str__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/sh_dynamic_section_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.tag = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.tag = self._io.read_u8le()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.value_or_ptr = self._io.read_u4le()
elif _on == Elf.Bits.b64:
pass
self.value_or_ptr = self._io.read_u8le()
self._dirty = False
def _read_be(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.tag = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.tag = self._io.read_u8be()
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self.value_or_ptr = self._io.read_u4be()
elif _on == Elf.Bits.b64:
pass
self.value_or_ptr = self._io.read_u8be()
self._dirty = False
def _fetch_instances(self):
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_ = self.flag_1_values
if hasattr(self, '_m_flag_1_values'):
pass
self._m_flag_1_values._fetch_instances()
_ = self.flag_values
if hasattr(self, '_m_flag_values'):
pass
self._m_flag_values._fetch_instances()
_ = self.value_str
if hasattr(self, '_m_value_str'):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.ShDynamicSectionEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/sh_dynamic_section_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_flag_1_values = self.flag_1_values__enabled
self._should_write_flag_values = self.flag_values__enabled
self._should_write_value_str = self.value_str__enabled
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.tag)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.tag)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4le(self.value_or_ptr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8le(self.value_or_ptr)
def _write__seq_be(self):
self._should_write_flag_1_values = self.flag_1_values__enabled
self._should_write_flag_values = self.flag_values__enabled
self._should_write_value_str = self.value_str__enabled
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.tag)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.tag)
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
self._io.write_u4be(self.value_or_ptr)
elif _on == Elf.Bits.b64:
pass
self._io.write_u8be(self.value_or_ptr)
def _check(self):
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
_on = self._root.bits
if _on == Elf.Bits.b32:
pass
elif _on == Elf.Bits.b64:
pass
if self.flag_1_values__enabled:
pass
if self.tag_enum == Elf.DynamicArrayTags.flags_1:
pass
if self._m_flag_1_values._root != self._root:
raise kaitaistruct.ConsistencyError(u"flag_1_values", self._root, self._m_flag_1_values._root)
if self._m_flag_1_values._parent != self:
raise kaitaistruct.ConsistencyError(u"flag_1_values", self, self._m_flag_1_values._parent)
if self._m_flag_1_values.value != self.value_or_ptr:
raise kaitaistruct.ConsistencyError(u"flag_1_values", self.value_or_ptr, self._m_flag_1_values.value)
if self.flag_values__enabled:
pass
if self.tag_enum == Elf.DynamicArrayTags.flags:
pass
if self._m_flag_values._root != self._root:
raise kaitaistruct.ConsistencyError(u"flag_values", self._root, self._m_flag_values._root)
if self._m_flag_values._parent != self:
raise kaitaistruct.ConsistencyError(u"flag_values", self, self._m_flag_values._parent)
if self._m_flag_values.value != self.value_or_ptr:
raise kaitaistruct.ConsistencyError(u"flag_values", self.value_or_ptr, self._m_flag_values.value)
if self.value_str__enabled:
pass
if ((self.is_value_str) and (self._parent.is_string_table_linked)) :
pass
if KaitaiStream.byte_array_index_of((self._m_value_str).encode(u"ASCII"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"value_str", -1, KaitaiStream.byte_array_index_of((self._m_value_str).encode(u"ASCII"), 0))
self._dirty = False
@property
def flag_1_values(self):
if self._should_write_flag_1_values:
self._write_flag_1_values()
if hasattr(self, '_m_flag_1_values'):
return self._m_flag_1_values
if not self.flag_1_values__enabled:
return None
if self.tag_enum == Elf.DynamicArrayTags.flags_1:
pass
if self._is_le:
self._m_flag_1_values = Elf.DtFlag1Values(self.value_or_ptr, self._io, self, self._root)
self._m_flag_1_values._read()
else:
self._m_flag_1_values = Elf.DtFlag1Values(self.value_or_ptr, self._io, self, self._root)
self._m_flag_1_values._read()
return getattr(self, '_m_flag_1_values', None)
@flag_1_values.setter
def flag_1_values(self, v):
self._dirty = True
self._m_flag_1_values = v
def _write_flag_1_values(self):
self._should_write_flag_1_values = False
if self.tag_enum == Elf.DynamicArrayTags.flags_1:
pass
if self._is_le:
self._m_flag_1_values._write__seq(self._io)
else:
self._m_flag_1_values._write__seq(self._io)
@property
def flag_values(self):
if self._should_write_flag_values:
self._write_flag_values()
if hasattr(self, '_m_flag_values'):
return self._m_flag_values
if not self.flag_values__enabled:
return None
if self.tag_enum == Elf.DynamicArrayTags.flags:
pass
if self._is_le:
self._m_flag_values = Elf.DtFlagValues(self.value_or_ptr, self._io, self, self._root)
self._m_flag_values._read()
else:
self._m_flag_values = Elf.DtFlagValues(self.value_or_ptr, self._io, self, self._root)
self._m_flag_values._read()
return getattr(self, '_m_flag_values', None)
@flag_values.setter
def flag_values(self, v):
self._dirty = True
self._m_flag_values = v
def _write_flag_values(self):
self._should_write_flag_values = False
if self.tag_enum == Elf.DynamicArrayTags.flags:
pass
if self._is_le:
self._m_flag_values._write__seq(self._io)
else:
self._m_flag_values._write__seq(self._io)
@property
def is_value_str(self):
if hasattr(self, '_m_is_value_str'):
return self._m_is_value_str
self._m_is_value_str = ((self.value_or_ptr != 0) and ( ((self.tag_enum == Elf.DynamicArrayTags.needed) or (self.tag_enum == Elf.DynamicArrayTags.soname) or (self.tag_enum == Elf.DynamicArrayTags.rpath) or (self.tag_enum == Elf.DynamicArrayTags.runpath) or (self.tag_enum == Elf.DynamicArrayTags.sunw_auxiliary) or (self.tag_enum == Elf.DynamicArrayTags.sunw_filter) or (self.tag_enum == Elf.DynamicArrayTags.auxiliary) or (self.tag_enum == Elf.DynamicArrayTags.filter) or (self.tag_enum == Elf.DynamicArrayTags.config) or (self.tag_enum == Elf.DynamicArrayTags.depaudit) or (self.tag_enum == Elf.DynamicArrayTags.audit)) ))
return getattr(self, '_m_is_value_str', None)
def _invalidate_is_value_str(self):
del self._m_is_value_str
@property
def tag_enum(self):
if hasattr(self, '_m_tag_enum'):
return self._m_tag_enum
self._m_tag_enum = KaitaiStream.resolve_enum(Elf.DynamicArrayTags, self.tag)
return getattr(self, '_m_tag_enum', None)
def _invalidate_tag_enum(self):
del self._m_tag_enum
@property
def value_str(self):
if self._should_write_value_str:
self._write_value_str()
if hasattr(self, '_m_value_str'):
return self._m_value_str
if not self.value_str__enabled:
return None
if ((self.is_value_str) and (self._parent.is_string_table_linked)) :
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.value_or_ptr)
if self._is_le:
self._m_value_str = (io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
else:
self._m_value_str = (io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
io.seek(_pos)
return getattr(self, '_m_value_str', None)
@value_str.setter
def value_str(self, v):
self._dirty = True
self._m_value_str = v
def _write_value_str(self):
self._should_write_value_str = False
if ((self.is_value_str) and (self._parent.is_string_table_linked)) :
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.value_or_ptr)
if self._is_le:
io.write_bytes((self._m_value_str).encode(u"ASCII"))
io.write_u1(0)
else:
io.write_bytes((self._m_value_str).encode(u"ASCII"))
io.write_u1(0)
io.seek(_pos)
class StringsStruct(ReadWriteKaitaiStruct):
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.StringsStruct, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/strings_struct")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.entries = []
i = 0
while not self._io.is_eof():
self.entries.append((self._io.read_bytes_term(0, False, True, True)).decode(u"UTF-8"))
i += 1
self._dirty = False
def _read_be(self):
self.entries = []
i = 0
while not self._io.is_eof():
self.entries.append((self._io.read_bytes_term(0, False, True, True)).decode(u"UTF-8"))
i += 1
self._dirty = False
def _fetch_instances(self):
pass
for i in range(len(self.entries)):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.StringsStruct, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/strings_struct")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self._io.write_bytes((self.entries[i]).encode(u"UTF-8"))
self._io.write_u1(0)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _write__seq_be(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self._io.write_bytes((self.entries[i]).encode(u"UTF-8"))
self._io.write_u1(0)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _check(self):
for i in range(len(self.entries)):
pass
if KaitaiStream.byte_array_index_of((self.entries[i]).encode(u"UTF-8"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"entries", -1, KaitaiStream.byte_array_index_of((self.entries[i]).encode(u"UTF-8"), 0))
self._dirty = False
class VerdauxEntry(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFEXTS
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-definition-section.html
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VerdauxEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_name = False
self.name__enabled = True
self._should_write_next = False
self.next__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verdaux_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.ofs_name = self._io.read_u4le()
self.ofs_next = self._io.read_u4le()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 8)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/verdaux_entry/seq/2")
self._dirty = False
def _read_be(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.ofs_name = self._io.read_u4be()
self.ofs_next = self._io.read_u4be()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 8)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/verdaux_entry/seq/2")
self._dirty = False
def _fetch_instances(self):
pass
if self.ofs_start < 0:
pass
_ = self.name
if hasattr(self, '_m_name'):
pass
_ = self.next
if hasattr(self, '_m_next'):
pass
self._m_next._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.VerdauxEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verdaux_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_name = self.name__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u4le(self.ofs_name)
self._io.write_u4le(self.ofs_next)
def _write__seq_be(self):
self._should_write_name = self.name__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u4be(self.ofs_name)
self._io.write_u4be(self.ofs_next)
def _check(self):
_ = self.ofs_next
if not ((_ == 0) or (_ >= 8)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, None, u"/types/endian_elf/types/verdaux_entry/seq/2")
if self.name__enabled:
pass
if self._parent.is_string_table_linked:
pass
if KaitaiStream.byte_array_index_of((self._m_name).encode(u"UTF-8"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"name", -1, KaitaiStream.byte_array_index_of((self._m_name).encode(u"UTF-8"), 0))
if self.next__enabled:
pass
if self.ofs_next != 0:
pass
if self._m_next._root != self._root:
raise kaitaistruct.ConsistencyError(u"next", self._root, self._m_next._root)
if self._m_next._parent != self._parent:
raise kaitaistruct.ConsistencyError(u"next", self._parent, self._m_next._parent)
self._dirty = False
@property
def name(self):
if self._should_write_name:
self._write_name()
if hasattr(self, '_m_name'):
return self._m_name
if not self.name__enabled:
return None
if self._parent.is_string_table_linked:
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
else:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
io.seek(_pos)
return getattr(self, '_m_name', None)
@name.setter
def name(self, v):
self._dirty = True
self._m_name = v
def _write_name(self):
self._should_write_name = False
if self._parent.is_string_table_linked:
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
io.write_bytes((self._m_name).encode(u"UTF-8"))
io.write_u1(0)
else:
io.write_bytes((self._m_name).encode(u"UTF-8"))
io.write_u1(0)
io.seek(_pos)
@property
def next(self):
if self._should_write_next:
self._write_next()
if hasattr(self, '_m_next'):
return self._m_next
if not self.next__enabled:
return None
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next = Elf.EndianElf.VerdauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
else:
self._m_next = Elf.EndianElf.VerdauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
self._io.seek(_pos)
return getattr(self, '_m_next', None)
@next.setter
def next(self, v):
self._dirty = True
self._m_next = v
def _write_next(self):
self._should_write_next = False
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next._write__seq(self._io)
else:
self._m_next._write__seq(self._io)
self._io.seek(_pos)
@property
def ofs_start(self):
if hasattr(self, '_m_ofs_start'):
return self._m_ofs_start
self._m_ofs_start = self._io.pos()
return getattr(self, '_m_ofs_start', None)
def _invalidate_ofs_start(self):
del self._m_ofs_start
class VerdefSection(ReadWriteKaitaiStruct):
"""Version Definitions, contained in the special section named
`.gnu.version_d` with the section type `sh_type::gnu_verdef`
(`SHT_GNU_verdef`).
The number of entries in this section must match the value of the
dynamic tag `dynamic_array_tags::verdefnum` (`DT_VERDEFNUM`) in the
Dynamic Section (`.dynamic`).
`_parent.linked_section` must be the string table that contains the
strings referenced by this section. Specifically, the string table in
the `.dynstr` section should be used (side note: the `readelf` command
doesn't even check which string table `sh_link` points to, and always
uses `.dynstr` for the lookups - see
<https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/binutils/readelf.c#L13787>).
The `is_string_table_linked` value instance indicates whether the
string table is linked. If it is not, version names (the `name`
instance in the `verdaux_entry` type) will not be available.
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERDEFS
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-definition-section.html
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VerdefSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verdef_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.first_entry = Elf.EndianElf.VerdefSectionEntry(self._io, self, self._root, self._is_le)
self.first_entry._read()
self._dirty = False
def _read_be(self):
self.first_entry = Elf.EndianElf.VerdefSectionEntry(self._io, self, self._root, self._is_le)
self.first_entry._read()
self._dirty = False
def _fetch_instances(self):
pass
self.first_entry._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.VerdefSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verdef_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self.first_entry._write__seq(self._io)
def _write__seq_be(self):
self.first_entry._write__seq(self._io)
def _check(self):
if self.first_entry._root != self._root:
raise kaitaistruct.ConsistencyError(u"first_entry", self._root, self.first_entry._root)
if self.first_entry._parent != self:
raise kaitaistruct.ConsistencyError(u"first_entry", self, self.first_entry._parent)
self._dirty = False
@property
def is_string_table_linked(self):
"""Indicates whether a string table is linked. This should always be
`true` in spec-compliant ELF files. If it is `false`, the string
offsets in this section will not be resolved to strings.
"""
if hasattr(self, '_m_is_string_table_linked'):
return self._m_is_string_table_linked
self._m_is_string_table_linked = self._parent.linked_section.type == Elf.ShType.strtab
return getattr(self, '_m_is_string_table_linked', None)
def _invalidate_is_string_table_linked(self):
del self._m_is_string_table_linked
@property
def num_entries(self):
"""Number of entries (version definitions).
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/section-headers.html#GUID-2CBE4879-2E76-426E-BB7F-CF0CB1D87C52__CHAPTER6-47976
"""
if hasattr(self, '_m_num_entries'):
return self._m_num_entries
self._m_num_entries = self._parent.info
return getattr(self, '_m_num_entries', None)
def _invalidate_num_entries(self):
del self._m_num_entries
class VerdefSectionEntry(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERDEFENTRIES
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-definition-section.html
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VerdefSectionEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_first_aux = False
self.first_aux__enabled = True
self._should_write_flags_obj = False
self.flags_obj__enabled = True
self._should_write_next = False
self.next__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verdef_section_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.version = self._io.read_u2le()
if not self.version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.version, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/1")
self.flags = self._io.read_u2le()
self.version_index = self._io.read_u2le()
_ = self.version_index
if not _ & 32768 == 0:
raise kaitaistruct.ValidationExprError(self.version_index, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/3")
self.num_aux_entries = self._io.read_u2le()
if not self.num_aux_entries >= 1:
raise kaitaistruct.ValidationLessThanError(1, self.num_aux_entries, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/4")
self.hash = self._io.read_u4le()
self.ofs_first_aux = self._io.read_u4le()
if not self.ofs_first_aux >= 20:
raise kaitaistruct.ValidationLessThanError(20, self.ofs_first_aux, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/6")
self.ofs_next = self._io.read_u4le()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 20)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/7")
self._dirty = False
def _read_be(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.version = self._io.read_u2be()
if not self.version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.version, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/1")
self.flags = self._io.read_u2be()
self.version_index = self._io.read_u2be()
_ = self.version_index
if not _ & 32768 == 0:
raise kaitaistruct.ValidationExprError(self.version_index, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/3")
self.num_aux_entries = self._io.read_u2be()
if not self.num_aux_entries >= 1:
raise kaitaistruct.ValidationLessThanError(1, self.num_aux_entries, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/4")
self.hash = self._io.read_u4be()
self.ofs_first_aux = self._io.read_u4be()
if not self.ofs_first_aux >= 20:
raise kaitaistruct.ValidationLessThanError(20, self.ofs_first_aux, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/6")
self.ofs_next = self._io.read_u4be()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 20)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/verdef_section_entry/seq/7")
self._dirty = False
def _fetch_instances(self):
pass
if self.ofs_start < 0:
pass
_ = self.first_aux
if hasattr(self, '_m_first_aux'):
pass
self._m_first_aux._fetch_instances()
_ = self.flags_obj
if hasattr(self, '_m_flags_obj'):
pass
self._m_flags_obj._fetch_instances()
_ = self.next
if hasattr(self, '_m_next'):
pass
self._m_next._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.VerdefSectionEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verdef_section_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_first_aux = self.first_aux__enabled
self._should_write_flags_obj = self.flags_obj__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u2le(self.version)
self._io.write_u2le(self.flags)
self._io.write_u2le(self.version_index)
self._io.write_u2le(self.num_aux_entries)
self._io.write_u4le(self.hash)
self._io.write_u4le(self.ofs_first_aux)
self._io.write_u4le(self.ofs_next)
def _write__seq_be(self):
self._should_write_first_aux = self.first_aux__enabled
self._should_write_flags_obj = self.flags_obj__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u2be(self.version)
self._io.write_u2be(self.flags)
self._io.write_u2be(self.version_index)
self._io.write_u2be(self.num_aux_entries)
self._io.write_u4be(self.hash)
self._io.write_u4be(self.ofs_first_aux)
self._io.write_u4be(self.ofs_next)
def _check(self):
if not self.version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.version, None, u"/types/endian_elf/types/verdef_section_entry/seq/1")
_ = self.version_index
if not _ & 32768 == 0:
raise kaitaistruct.ValidationExprError(self.version_index, None, u"/types/endian_elf/types/verdef_section_entry/seq/3")
if not self.num_aux_entries >= 1:
raise kaitaistruct.ValidationLessThanError(1, self.num_aux_entries, None, u"/types/endian_elf/types/verdef_section_entry/seq/4")
if not self.ofs_first_aux >= 20:
raise kaitaistruct.ValidationLessThanError(20, self.ofs_first_aux, None, u"/types/endian_elf/types/verdef_section_entry/seq/6")
_ = self.ofs_next
if not ((_ == 0) or (_ >= 20)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, None, u"/types/endian_elf/types/verdef_section_entry/seq/7")
if self.first_aux__enabled:
pass
if self._m_first_aux._root != self._root:
raise kaitaistruct.ConsistencyError(u"first_aux", self._root, self._m_first_aux._root)
if self._m_first_aux._parent != self._parent:
raise kaitaistruct.ConsistencyError(u"first_aux", self._parent, self._m_first_aux._parent)
if self.flags_obj__enabled:
pass
if self._m_flags_obj._root != self._root:
raise kaitaistruct.ConsistencyError(u"flags_obj", self._root, self._m_flags_obj._root)
if self._m_flags_obj._parent != self:
raise kaitaistruct.ConsistencyError(u"flags_obj", self, self._m_flags_obj._parent)
if self._m_flags_obj.value != self.flags:
raise kaitaistruct.ConsistencyError(u"flags_obj", self.flags, self._m_flags_obj.value)
if self.next__enabled:
pass
if self.ofs_next != 0:
pass
if self._m_next._root != self._root:
raise kaitaistruct.ConsistencyError(u"next", self._root, self._m_next._root)
if self._m_next._parent != self._parent:
raise kaitaistruct.ConsistencyError(u"next", self._parent, self._m_next._parent)
self._dirty = False
@property
def first_aux(self):
"""First auxiliary entry of type `verdaux_entry` (`Elfxx_Verdaux`).
The rest follow its `next` instance.
"""
if self._should_write_first_aux:
self._write_first_aux()
if hasattr(self, '_m_first_aux'):
return self._m_first_aux
if not self.first_aux__enabled:
return None
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_first_aux)
if self._is_le:
self._m_first_aux = Elf.EndianElf.VerdauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_first_aux._read()
else:
self._m_first_aux = Elf.EndianElf.VerdauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_first_aux._read()
self._io.seek(_pos)
return getattr(self, '_m_first_aux', None)
@first_aux.setter
def first_aux(self, v):
self._dirty = True
self._m_first_aux = v
def _write_first_aux(self):
self._should_write_first_aux = False
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_first_aux)
if self._is_le:
self._m_first_aux._write__seq(self._io)
else:
self._m_first_aux._write__seq(self._io)
self._io.seek(_pos)
@property
def flags_obj(self):
if self._should_write_flags_obj:
self._write_flags_obj()
if hasattr(self, '_m_flags_obj'):
return self._m_flags_obj
if not self.flags_obj__enabled:
return None
if self._is_le:
self._m_flags_obj = Elf.EndianElf.VersionFlags(self.flags, self._io, self, self._root, self._is_le)
self._m_flags_obj._read()
else:
self._m_flags_obj = Elf.EndianElf.VersionFlags(self.flags, self._io, self, self._root, self._is_le)
self._m_flags_obj._read()
return getattr(self, '_m_flags_obj', None)
@flags_obj.setter
def flags_obj(self, v):
self._dirty = True
self._m_flags_obj = v
def _write_flags_obj(self):
self._should_write_flags_obj = False
if self._is_le:
self._m_flags_obj._write__seq(self._io)
else:
self._m_flags_obj._write__seq(self._io)
@property
def next(self):
if self._should_write_next:
self._write_next()
if hasattr(self, '_m_next'):
return self._m_next
if not self.next__enabled:
return None
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next = Elf.EndianElf.VerdefSectionEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
else:
self._m_next = Elf.EndianElf.VerdefSectionEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
self._io.seek(_pos)
return getattr(self, '_m_next', None)
@next.setter
def next(self, v):
self._dirty = True
self._m_next = v
def _write_next(self):
self._should_write_next = False
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next._write__seq(self._io)
else:
self._m_next._write__seq(self._io)
self._io.seek(_pos)
@property
def ofs_start(self):
if hasattr(self, '_m_ofs_start'):
return self._m_ofs_start
self._m_ofs_start = self._io.pos()
return getattr(self, '_m_ofs_start', None)
def _invalidate_ofs_start(self):
del self._m_ofs_start
@property
def version_index_special(self):
if hasattr(self, '_m_version_index_special'):
return self._m_version_index_special
self._m_version_index_special = KaitaiStream.resolve_enum(Elf.VersionIndexSpecial, self.version_index)
return getattr(self, '_m_version_index_special', None)
def _invalidate_version_index_special(self):
del self._m_version_index_special
class VernauxEntry(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDEXTFIG
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-dependency-section.html
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VernauxEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_flags_obj = False
self.flags_obj__enabled = True
self._should_write_name = False
self.name__enabled = True
self._should_write_next = False
self.next__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/vernaux_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.hash = self._io.read_u4le()
self.flags = self._io.read_u2le()
self.version_index = Elf.EndianElf.VersionIndex(self._io, self, self._root, self._is_le)
self.version_index._read()
self.ofs_name = self._io.read_u4le()
self.ofs_next = self._io.read_u4le()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 16)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/vernaux_entry/seq/5")
self._dirty = False
def _read_be(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.hash = self._io.read_u4be()
self.flags = self._io.read_u2be()
self.version_index = Elf.EndianElf.VersionIndex(self._io, self, self._root, self._is_le)
self.version_index._read()
self.ofs_name = self._io.read_u4be()
self.ofs_next = self._io.read_u4be()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 16)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/vernaux_entry/seq/5")
self._dirty = False
def _fetch_instances(self):
pass
if self.ofs_start < 0:
pass
self.version_index._fetch_instances()
_ = self.flags_obj
if hasattr(self, '_m_flags_obj'):
pass
self._m_flags_obj._fetch_instances()
_ = self.name
if hasattr(self, '_m_name'):
pass
_ = self.next
if hasattr(self, '_m_next'):
pass
self._m_next._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.VernauxEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/vernaux_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_flags_obj = self.flags_obj__enabled
self._should_write_name = self.name__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u4le(self.hash)
self._io.write_u2le(self.flags)
self.version_index._write__seq(self._io)
self._io.write_u4le(self.ofs_name)
self._io.write_u4le(self.ofs_next)
def _write__seq_be(self):
self._should_write_flags_obj = self.flags_obj__enabled
self._should_write_name = self.name__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u4be(self.hash)
self._io.write_u2be(self.flags)
self.version_index._write__seq(self._io)
self._io.write_u4be(self.ofs_name)
self._io.write_u4be(self.ofs_next)
def _check(self):
if self.version_index._root != self._root:
raise kaitaistruct.ConsistencyError(u"version_index", self._root, self.version_index._root)
if self.version_index._parent != self:
raise kaitaistruct.ConsistencyError(u"version_index", self, self.version_index._parent)
_ = self.ofs_next
if not ((_ == 0) or (_ >= 16)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, None, u"/types/endian_elf/types/vernaux_entry/seq/5")
if self.flags_obj__enabled:
pass
if self._m_flags_obj._root != self._root:
raise kaitaistruct.ConsistencyError(u"flags_obj", self._root, self._m_flags_obj._root)
if self._m_flags_obj._parent != self:
raise kaitaistruct.ConsistencyError(u"flags_obj", self, self._m_flags_obj._parent)
if self._m_flags_obj.value != self.flags:
raise kaitaistruct.ConsistencyError(u"flags_obj", self.flags, self._m_flags_obj.value)
if self.name__enabled:
pass
if self._parent.is_string_table_linked:
pass
if KaitaiStream.byte_array_index_of((self._m_name).encode(u"UTF-8"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"name", -1, KaitaiStream.byte_array_index_of((self._m_name).encode(u"UTF-8"), 0))
if self.next__enabled:
pass
if self.ofs_next != 0:
pass
if self._m_next._root != self._root:
raise kaitaistruct.ConsistencyError(u"next", self._root, self._m_next._root)
if self._m_next._parent != self._parent:
raise kaitaistruct.ConsistencyError(u"next", self._parent, self._m_next._parent)
self._dirty = False
@property
def flags_obj(self):
if self._should_write_flags_obj:
self._write_flags_obj()
if hasattr(self, '_m_flags_obj'):
return self._m_flags_obj
if not self.flags_obj__enabled:
return None
if self._is_le:
self._m_flags_obj = Elf.EndianElf.VersionFlags(self.flags, self._io, self, self._root, self._is_le)
self._m_flags_obj._read()
else:
self._m_flags_obj = Elf.EndianElf.VersionFlags(self.flags, self._io, self, self._root, self._is_le)
self._m_flags_obj._read()
return getattr(self, '_m_flags_obj', None)
@flags_obj.setter
def flags_obj(self, v):
self._dirty = True
self._m_flags_obj = v
def _write_flags_obj(self):
self._should_write_flags_obj = False
if self._is_le:
self._m_flags_obj._write__seq(self._io)
else:
self._m_flags_obj._write__seq(self._io)
@property
def name(self):
if self._should_write_name:
self._write_name()
if hasattr(self, '_m_name'):
return self._m_name
if not self.name__enabled:
return None
if self._parent.is_string_table_linked:
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
else:
self._m_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
io.seek(_pos)
return getattr(self, '_m_name', None)
@name.setter
def name(self, v):
self._dirty = True
self._m_name = v
def _write_name(self):
self._should_write_name = False
if self._parent.is_string_table_linked:
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_name)
if self._is_le:
io.write_bytes((self._m_name).encode(u"UTF-8"))
io.write_u1(0)
else:
io.write_bytes((self._m_name).encode(u"UTF-8"))
io.write_u1(0)
io.seek(_pos)
@property
def next(self):
if self._should_write_next:
self._write_next()
if hasattr(self, '_m_next'):
return self._m_next
if not self.next__enabled:
return None
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next = Elf.EndianElf.VernauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
else:
self._m_next = Elf.EndianElf.VernauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
self._io.seek(_pos)
return getattr(self, '_m_next', None)
@next.setter
def next(self, v):
self._dirty = True
self._m_next = v
def _write_next(self):
self._should_write_next = False
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next._write__seq(self._io)
else:
self._m_next._write__seq(self._io)
self._io.seek(_pos)
@property
def ofs_start(self):
if hasattr(self, '_m_ofs_start'):
return self._m_ofs_start
self._m_ofs_start = self._io.pos()
return getattr(self, '_m_ofs_start', None)
def _invalidate_ofs_start(self):
del self._m_ofs_start
class VerneedSection(ReadWriteKaitaiStruct):
"""Version Requirements, contained in the special section named
`.gnu.version_r` with the section type `sh_type::gnu_verneed`
(`SHT_GNU_verneed`). This section defines the required versions of
dynamic symbols from other shared objects.
The number of entries in this section must match the value of the
dynamic tag `dynamic_array_tags::verneednum` (`DT_VERNEEDNUM`) in the
Dynamic Section (`.dynamic`).
`_parent.linked_section` must be the string table that contains the
strings referenced by this section. Specifically, the string table in
the `.dynstr` section should be used (side note: the `readelf` command
doesn't even check which string table `sh_link` points to, and always
uses `.dynstr` for the lookups - see
<https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/binutils/readelf.c#L13941>).
The `is_string_table_linked` value instance indicates whether the
string table is linked. If it is not, file names (the `file_name`
instance in the `verneed_section_entry` type) or version names (the
`name` instance in the `vernaux_entry` type) will not be available.
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERRQMTS
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-dependency-section.html
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VerneedSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verneed_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.first_entry = Elf.EndianElf.VerneedSectionEntry(self._io, self, self._root, self._is_le)
self.first_entry._read()
self._dirty = False
def _read_be(self):
self.first_entry = Elf.EndianElf.VerneedSectionEntry(self._io, self, self._root, self._is_le)
self.first_entry._read()
self._dirty = False
def _fetch_instances(self):
pass
self.first_entry._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.VerneedSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verneed_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self.first_entry._write__seq(self._io)
def _write__seq_be(self):
self.first_entry._write__seq(self._io)
def _check(self):
if self.first_entry._root != self._root:
raise kaitaistruct.ConsistencyError(u"first_entry", self._root, self.first_entry._root)
if self.first_entry._parent != self:
raise kaitaistruct.ConsistencyError(u"first_entry", self, self.first_entry._parent)
self._dirty = False
@property
def is_string_table_linked(self):
"""Indicates whether a string table is linked. This should always be
`true` in spec-compliant ELF files. If it is `false`, the string
offsets in this section will not be resolved to strings.
"""
if hasattr(self, '_m_is_string_table_linked'):
return self._m_is_string_table_linked
self._m_is_string_table_linked = self._parent.linked_section.type == Elf.ShType.strtab
return getattr(self, '_m_is_string_table_linked', None)
def _invalidate_is_string_table_linked(self):
del self._m_is_string_table_linked
@property
def num_entries(self):
"""Number of entries (dependency versions).
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/section-headers.html#GUID-2CBE4879-2E76-426E-BB7F-CF0CB1D87C52__CHAPTER6-47976
"""
if hasattr(self, '_m_num_entries'):
return self._m_num_entries
self._m_num_entries = self._parent.info
return getattr(self, '_m_num_entries', None)
def _invalidate_num_entries(self):
del self._m_num_entries
class VerneedSectionEntry(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#VERNEEDFIG
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-dependency-section.html
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VerneedSectionEntry, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self._should_write_file_name = False
self.file_name__enabled = True
self._should_write_first_aux = False
self.first_aux__enabled = True
self._should_write_next = False
self.next__enabled = True
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verneed_section_entry")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.version = self._io.read_u2le()
if not self.version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.version, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/1")
self.num_aux_entries = self._io.read_u2le()
if not self.num_aux_entries >= 1:
raise kaitaistruct.ValidationLessThanError(1, self.num_aux_entries, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/2")
self.ofs_file_name = self._io.read_u4le()
self.ofs_first_aux = self._io.read_u4le()
if not self.ofs_first_aux >= 16:
raise kaitaistruct.ValidationLessThanError(16, self.ofs_first_aux, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/4")
self.ofs_next = self._io.read_u4le()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 16)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/5")
self._dirty = False
def _read_be(self):
if self.ofs_start < 0:
pass
self._unnamed0 = self._io.read_bytes(0)
self.version = self._io.read_u2be()
if not self.version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.version, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/1")
self.num_aux_entries = self._io.read_u2be()
if not self.num_aux_entries >= 1:
raise kaitaistruct.ValidationLessThanError(1, self.num_aux_entries, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/2")
self.ofs_file_name = self._io.read_u4be()
self.ofs_first_aux = self._io.read_u4be()
if not self.ofs_first_aux >= 16:
raise kaitaistruct.ValidationLessThanError(16, self.ofs_first_aux, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/4")
self.ofs_next = self._io.read_u4be()
_ = self.ofs_next
if not ((_ == 0) or (_ >= 16)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, self._io, u"/types/endian_elf/types/verneed_section_entry/seq/5")
self._dirty = False
def _fetch_instances(self):
pass
if self.ofs_start < 0:
pass
_ = self.file_name
if hasattr(self, '_m_file_name'):
pass
_ = self.first_aux
if hasattr(self, '_m_first_aux'):
pass
self._m_first_aux._fetch_instances()
_ = self.next
if hasattr(self, '_m_next'):
pass
self._m_next._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.VerneedSectionEntry, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/verneed_section_entry")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._should_write_file_name = self.file_name__enabled
self._should_write_first_aux = self.first_aux__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u2le(self.version)
self._io.write_u2le(self.num_aux_entries)
self._io.write_u4le(self.ofs_file_name)
self._io.write_u4le(self.ofs_first_aux)
self._io.write_u4le(self.ofs_next)
def _write__seq_be(self):
self._should_write_file_name = self.file_name__enabled
self._should_write_first_aux = self.first_aux__enabled
self._should_write_next = self.next__enabled
if self.ofs_start < 0:
pass
if len(self._unnamed0) != 0:
raise kaitaistruct.ConsistencyError(u"_unnamed0", 0, len(self._unnamed0))
self._io.write_bytes(self._unnamed0)
self._io.write_u2be(self.version)
self._io.write_u2be(self.num_aux_entries)
self._io.write_u4be(self.ofs_file_name)
self._io.write_u4be(self.ofs_first_aux)
self._io.write_u4be(self.ofs_next)
def _check(self):
if not self.version == 1:
raise kaitaistruct.ValidationNotEqualError(1, self.version, None, u"/types/endian_elf/types/verneed_section_entry/seq/1")
if not self.num_aux_entries >= 1:
raise kaitaistruct.ValidationLessThanError(1, self.num_aux_entries, None, u"/types/endian_elf/types/verneed_section_entry/seq/2")
if not self.ofs_first_aux >= 16:
raise kaitaistruct.ValidationLessThanError(16, self.ofs_first_aux, None, u"/types/endian_elf/types/verneed_section_entry/seq/4")
_ = self.ofs_next
if not ((_ == 0) or (_ >= 16)) :
raise kaitaistruct.ValidationExprError(self.ofs_next, None, u"/types/endian_elf/types/verneed_section_entry/seq/5")
if self.file_name__enabled:
pass
if self._parent.is_string_table_linked:
pass
if KaitaiStream.byte_array_index_of((self._m_file_name).encode(u"UTF-8"), 0) != -1:
raise kaitaistruct.ConsistencyError(u"file_name", -1, KaitaiStream.byte_array_index_of((self._m_file_name).encode(u"UTF-8"), 0))
if self.first_aux__enabled:
pass
if self._m_first_aux._root != self._root:
raise kaitaistruct.ConsistencyError(u"first_aux", self._root, self._m_first_aux._root)
if self._m_first_aux._parent != self._parent:
raise kaitaistruct.ConsistencyError(u"first_aux", self._parent, self._m_first_aux._parent)
if self.next__enabled:
pass
if self.ofs_next != 0:
pass
if self._m_next._root != self._root:
raise kaitaistruct.ConsistencyError(u"next", self._root, self._m_next._root)
if self._m_next._parent != self._parent:
raise kaitaistruct.ConsistencyError(u"next", self._parent, self._m_next._parent)
self._dirty = False
@property
def file_name(self):
if self._should_write_file_name:
self._write_file_name()
if hasattr(self, '_m_file_name'):
return self._m_file_name
if not self.file_name__enabled:
return None
if self._parent.is_string_table_linked:
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_file_name)
if self._is_le:
self._m_file_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
else:
self._m_file_name = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
io.seek(_pos)
return getattr(self, '_m_file_name', None)
@file_name.setter
def file_name(self, v):
self._dirty = True
self._m_file_name = v
def _write_file_name(self):
self._should_write_file_name = False
if self._parent.is_string_table_linked:
pass
io = self._parent._parent.linked_section.body._io
_pos = io.pos()
io.seek(self.ofs_file_name)
if self._is_le:
io.write_bytes((self._m_file_name).encode(u"UTF-8"))
io.write_u1(0)
else:
io.write_bytes((self._m_file_name).encode(u"UTF-8"))
io.write_u1(0)
io.seek(_pos)
@property
def first_aux(self):
"""First auxiliary entry of type `vernaux_entry` (`Elfxx_Vernaux`).
The rest follow its `next` instance.
"""
if self._should_write_first_aux:
self._write_first_aux()
if hasattr(self, '_m_first_aux'):
return self._m_first_aux
if not self.first_aux__enabled:
return None
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_first_aux)
if self._is_le:
self._m_first_aux = Elf.EndianElf.VernauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_first_aux._read()
else:
self._m_first_aux = Elf.EndianElf.VernauxEntry(self._io, self._parent, self._root, self._is_le)
self._m_first_aux._read()
self._io.seek(_pos)
return getattr(self, '_m_first_aux', None)
@first_aux.setter
def first_aux(self, v):
self._dirty = True
self._m_first_aux = v
def _write_first_aux(self):
self._should_write_first_aux = False
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_first_aux)
if self._is_le:
self._m_first_aux._write__seq(self._io)
else:
self._m_first_aux._write__seq(self._io)
self._io.seek(_pos)
@property
def next(self):
if self._should_write_next:
self._write_next()
if hasattr(self, '_m_next'):
return self._m_next
if not self.next__enabled:
return None
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next = Elf.EndianElf.VerneedSectionEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
else:
self._m_next = Elf.EndianElf.VerneedSectionEntry(self._io, self._parent, self._root, self._is_le)
self._m_next._read()
self._io.seek(_pos)
return getattr(self, '_m_next', None)
@next.setter
def next(self, v):
self._dirty = True
self._m_next = v
def _write_next(self):
self._should_write_next = False
if self.ofs_next != 0:
pass
_pos = self._io.pos()
self._io.seek(self.ofs_start + self.ofs_next)
if self._is_le:
self._m_next._write__seq(self._io)
else:
self._m_next._write__seq(self._io)
self._io.seek(_pos)
@property
def ofs_start(self):
if hasattr(self, '_m_ofs_start'):
return self._m_ofs_start
self._m_ofs_start = self._io.pos()
return getattr(self, '_m_ofs_start', None)
def _invalidate_ofs_start(self):
del self._m_ofs_start
class VersionFlags(ReadWriteKaitaiStruct):
"""Version information flag bitmask, shared by the `flags` (`vd_flags`)
field of `verdef_section_entry` (`Elfxx_Verdef`) and the `flags`
(`vna_flags`) field of `vernaux_entry` (`Elfxx_Vernaux`).
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMSTARTSEQ
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L1078
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, value, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VersionFlags, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
self.value = value
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/version_flags")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
pass
self._dirty = False
def _read_be(self):
pass
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.VersionFlags, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/version_flags")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
pass
def _write__seq_be(self):
pass
def _check(self):
self._dirty = False
@property
def base(self):
"""Version definition of the file itself (the base definition)."""
if hasattr(self, '_m_base'):
return self._m_base
self._m_base = self.value & 1 != 0
return getattr(self, '_m_base', None)
def _invalidate_base(self):
del self._m_base
@property
def info(self):
"""Version reference exists for informational purposes and does not
need to be validated at runtime.
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-dependency-section.html
"""
if hasattr(self, '_m_info'):
return self._m_info
self._m_info = self.value & 4 != 0
return getattr(self, '_m_info', None)
def _invalidate_info(self):
del self._m_info
@property
def weak(self):
"""Weak version identifier.
A weak version definition has no symbols associated with the
version. See [Creating a Weak Version
Definition](https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/creating-weak-version-definition.html).
"""
if hasattr(self, '_m_weak'):
return self._m_weak
self._m_weak = self.value & 2 != 0
return getattr(self, '_m_weak', None)
def _invalidate_weak(self):
del self._m_weak
class VersionIndex(ReadWriteKaitaiStruct):
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VersionIndex, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/version_index")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.raw = self._io.read_u2le()
self._dirty = False
def _read_be(self):
self.raw = self._io.read_u2be()
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.EndianElf.VersionIndex, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/version_index")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
self._io.write_u2le(self.raw)
def _write__seq_be(self):
self._io.write_u2be(self.raw)
def _check(self):
self._dirty = False
@property
def is_hidden(self):
"""This bit is set if the symbol is hidden, and is only visible with
an explicit version number. This is a GNU extension.
.. seealso::
Source - https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/include/elf/common.h#L1379
"""
if hasattr(self, '_m_is_hidden'):
return self._m_is_hidden
self._m_is_hidden = self.raw & 32768 != 0
return getattr(self, '_m_is_hidden', None)
def _invalidate_is_hidden(self):
del self._m_is_hidden
@property
def value(self):
"""The values `version_index_special::local` (0) and
`version_index_special::global_symbol` (1) have special meanings.
The `version_index_special` value instance converts the integer
value to the `version_index_special` enum.
"""
if hasattr(self, '_m_value'):
return self._m_value
self._m_value = self.raw & 32767
return getattr(self, '_m_value', None)
def _invalidate_value(self):
del self._m_value
@property
def version_index_special(self):
"""Note: we match special constants against the full 16-bit integer
value (called `raw` in this .ksy implementation), because that's
what the `readelf` command does when deciding whether to print
`0 (*local*)` or `1 (*global*)` in the `.gnu.version`
(`SHT_GNU_versym`) section - see
<https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/binutils/readelf.c#L14079>.
Besides, `version_index_special::eliminate` (`VER_NDX_ELIMINATE`)
has a value of `0xff01`, which is a 16-bit value. If we matched
against `value` instead, `version_index_special::eliminate` would
be unreachable, because `value` contains only the lower 15 bits,
so its maximum possible value is `0x7fff`.
"""
if hasattr(self, '_m_version_index_special'):
return self._m_version_index_special
self._m_version_index_special = KaitaiStream.resolve_enum(Elf.VersionIndexSpecial, self.raw)
return getattr(self, '_m_version_index_special', None)
def _invalidate_version_index_special(self):
del self._m_version_index_special
class VersymSection(ReadWriteKaitaiStruct):
"""Symbol Version Table, contained in the special section named
`.gnu.version` with the section type `sh_type::gnu_versym`
(`SHT_GNU_versym`).
This section must have the same number of entries as the Dynamic
Symbol Table in the `.dynsym` section (section type `sh_type::dynsym`
/ `SHT_DYNSYM`). Each entry specifies the version defined for or
required by the corresponding symbol in the Dynamic Symbol Table.
.. seealso::
Source - https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html#SYMVERTBL
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/version-symbol-section.html
.. seealso::
Source - https://www.akkadia.org/drepper/symbol-versioning
"""
def __init__(self, _io=None, _parent=None, _root=None, _is_le=None):
super(Elf.EndianElf.VersymSection, self).__init__(_io)
self._parent = _parent
self._root = _root
self._is_le = _is_le
def _read(self):
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/versym_section")
elif self._is_le == True:
self._read_le()
elif self._is_le == False:
self._read_be()
self._dirty = False
def _read_le(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.VersionIndex(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _read_be(self):
self.entries = []
i = 0
while not self._io.is_eof():
_t_entries = Elf.EndianElf.VersionIndex(self._io, self, self._root, self._is_le)
try:
_t_entries._read()
finally:
self.entries.append(_t_entries)
i += 1
self._dirty = False
def _fetch_instances(self):
pass
for i in range(len(self.entries)):
pass
self.entries[i]._fetch_instances()
def _write__seq(self, io=None):
super(Elf.EndianElf.VersymSection, self)._write__seq(io)
if not hasattr(self, '_is_le'):
raise kaitaistruct.UndecidedEndiannessError("/types/endian_elf/types/versym_section")
elif self._is_le == True:
self._write__seq_le()
elif self._is_le == False:
self._write__seq_be()
def _write__seq_le(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _write__seq_be(self):
for i in range(len(self.entries)):
pass
if self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
self.entries[i]._write__seq(self._io)
if not self._io.is_eof():
raise kaitaistruct.ConsistencyError(u"entries", 0, self._io.size() - self._io.pos())
def _check(self):
for i in range(len(self.entries)):
pass
if self.entries[i]._root != self._root:
raise kaitaistruct.ConsistencyError(u"entries", self._root, self.entries[i]._root)
if self.entries[i]._parent != self:
raise kaitaistruct.ConsistencyError(u"entries", self, self.entries[i]._parent)
self._dirty = False
@property
def program_headers(self):
if self._should_write_program_headers:
self._write_program_headers()
if hasattr(self, '_m_program_headers'):
return self._m_program_headers
if not self.program_headers__enabled:
return None
_pos = self._io.pos()
self._io.seek(self.ofs_program_headers)
if self._is_le:
self._raw__m_program_headers = []
self._m_program_headers = []
for i in range(self.num_program_headers):
self._raw__m_program_headers.append(self._io.read_bytes(self.program_header_size))
_io__raw__m_program_headers = KaitaiStream(BytesIO(self._raw__m_program_headers[i]))
_t__m_program_headers = Elf.EndianElf.ProgramHeader(_io__raw__m_program_headers, self, self._root, self._is_le)
try:
_t__m_program_headers._read()
finally:
self._m_program_headers.append(_t__m_program_headers)
else:
self._raw__m_program_headers = []
self._m_program_headers = []
for i in range(self.num_program_headers):
self._raw__m_program_headers.append(self._io.read_bytes(self.program_header_size))
_io__raw__m_program_headers = KaitaiStream(BytesIO(self._raw__m_program_headers[i]))
_t__m_program_headers = Elf.EndianElf.ProgramHeader(_io__raw__m_program_headers, self, self._root, self._is_le)
try:
_t__m_program_headers._read()
finally:
self._m_program_headers.append(_t__m_program_headers)
self._io.seek(_pos)
return getattr(self, '_m_program_headers', None)
@program_headers.setter
def program_headers(self, v):
self._dirty = True
self._m_program_headers = v
def _write_program_headers(self):
self._should_write_program_headers = False
_pos = self._io.pos()
self._io.seek(self.ofs_program_headers)
if self._is_le:
self._raw__m_program_headers = []
for i in range(len(self._m_program_headers)):
pass
_io__raw__m_program_headers = KaitaiStream(BytesIO(bytearray(self.program_header_size)))
self._io.add_child_stream(_io__raw__m_program_headers)
_pos2 = self._io.pos()
self._io.seek(self._io.pos() + (self.program_header_size))
def handler(parent, _io__raw__m_program_headers=_io__raw__m_program_headers, i=i):
self._raw__m_program_headers.append(_io__raw__m_program_headers.to_byte_array())
if len(self._raw__m_program_headers[i]) != self.program_header_size:
raise kaitaistruct.ConsistencyError(u"raw(program_headers)", self.program_header_size, len(self._raw__m_program_headers[i]))
parent.write_bytes(self._raw__m_program_headers[i])
_io__raw__m_program_headers.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_program_headers[i]._write__seq(_io__raw__m_program_headers)
else:
self._raw__m_program_headers = []
for i in range(len(self._m_program_headers)):
pass
_io__raw__m_program_headers = KaitaiStream(BytesIO(bytearray(self.program_header_size)))
self._io.add_child_stream(_io__raw__m_program_headers)
_pos2 = self._io.pos()
self._io.seek(self._io.pos() + (self.program_header_size))
def handler(parent, _io__raw__m_program_headers=_io__raw__m_program_headers, i=i):
self._raw__m_program_headers.append(_io__raw__m_program_headers.to_byte_array())
if len(self._raw__m_program_headers[i]) != self.program_header_size:
raise kaitaistruct.ConsistencyError(u"raw(program_headers)", self.program_header_size, len(self._raw__m_program_headers[i]))
parent.write_bytes(self._raw__m_program_headers[i])
_io__raw__m_program_headers.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_program_headers[i]._write__seq(_io__raw__m_program_headers)
self._io.seek(_pos)
@property
def section_headers(self):
if self._should_write_section_headers:
self._write_section_headers()
if hasattr(self, '_m_section_headers'):
return self._m_section_headers
if not self.section_headers__enabled:
return None
_pos = self._io.pos()
self._io.seek(self.ofs_section_headers)
if self._is_le:
self._raw__m_section_headers = []
self._m_section_headers = []
for i in range(self.num_section_headers):
self._raw__m_section_headers.append(self._io.read_bytes(self.section_header_size))
_io__raw__m_section_headers = KaitaiStream(BytesIO(self._raw__m_section_headers[i]))
_t__m_section_headers = Elf.EndianElf.SectionHeader(_io__raw__m_section_headers, self, self._root, self._is_le)
try:
_t__m_section_headers._read()
finally:
self._m_section_headers.append(_t__m_section_headers)
else:
self._raw__m_section_headers = []
self._m_section_headers = []
for i in range(self.num_section_headers):
self._raw__m_section_headers.append(self._io.read_bytes(self.section_header_size))
_io__raw__m_section_headers = KaitaiStream(BytesIO(self._raw__m_section_headers[i]))
_t__m_section_headers = Elf.EndianElf.SectionHeader(_io__raw__m_section_headers, self, self._root, self._is_le)
try:
_t__m_section_headers._read()
finally:
self._m_section_headers.append(_t__m_section_headers)
self._io.seek(_pos)
return getattr(self, '_m_section_headers', None)
@section_headers.setter
def section_headers(self, v):
self._dirty = True
self._m_section_headers = v
def _write_section_headers(self):
self._should_write_section_headers = False
_pos = self._io.pos()
self._io.seek(self.ofs_section_headers)
if self._is_le:
self._raw__m_section_headers = []
for i in range(len(self._m_section_headers)):
pass
_io__raw__m_section_headers = KaitaiStream(BytesIO(bytearray(self.section_header_size)))
self._io.add_child_stream(_io__raw__m_section_headers)
_pos2 = self._io.pos()
self._io.seek(self._io.pos() + (self.section_header_size))
def handler(parent, _io__raw__m_section_headers=_io__raw__m_section_headers, i=i):
self._raw__m_section_headers.append(_io__raw__m_section_headers.to_byte_array())
if len(self._raw__m_section_headers[i]) != self.section_header_size:
raise kaitaistruct.ConsistencyError(u"raw(section_headers)", self.section_header_size, len(self._raw__m_section_headers[i]))
parent.write_bytes(self._raw__m_section_headers[i])
_io__raw__m_section_headers.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_section_headers[i]._write__seq(_io__raw__m_section_headers)
else:
self._raw__m_section_headers = []
for i in range(len(self._m_section_headers)):
pass
_io__raw__m_section_headers = KaitaiStream(BytesIO(bytearray(self.section_header_size)))
self._io.add_child_stream(_io__raw__m_section_headers)
_pos2 = self._io.pos()
self._io.seek(self._io.pos() + (self.section_header_size))
def handler(parent, _io__raw__m_section_headers=_io__raw__m_section_headers, i=i):
self._raw__m_section_headers.append(_io__raw__m_section_headers.to_byte_array())
if len(self._raw__m_section_headers[i]) != self.section_header_size:
raise kaitaistruct.ConsistencyError(u"raw(section_headers)", self.section_header_size, len(self._raw__m_section_headers[i]))
parent.write_bytes(self._raw__m_section_headers[i])
_io__raw__m_section_headers.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_section_headers[i]._write__seq(_io__raw__m_section_headers)
self._io.seek(_pos)
@property
def section_names(self):
if self._should_write_section_names:
self._write_section_names()
if hasattr(self, '_m_section_names'):
return self._m_section_names
if not self.section_names__enabled:
return None
if ((self.section_names_idx != int(Elf.SectionHeaderIdxSpecial.undefined)) and (self.section_names_idx < self._root.header.num_section_headers)) :
pass
_pos = self._io.pos()
self._io.seek(self.section_headers[self.section_names_idx].ofs_body)
if self._is_le:
self._raw__m_section_names = self._io.read_bytes(self.section_headers[self.section_names_idx].len_body)
_io__raw__m_section_names = KaitaiStream(BytesIO(self._raw__m_section_names))
self._m_section_names = Elf.EndianElf.StringsStruct(_io__raw__m_section_names, self, self._root, self._is_le)
self._m_section_names._read()
else:
self._raw__m_section_names = self._io.read_bytes(self.section_headers[self.section_names_idx].len_body)
_io__raw__m_section_names = KaitaiStream(BytesIO(self._raw__m_section_names))
self._m_section_names = Elf.EndianElf.StringsStruct(_io__raw__m_section_names, self, self._root, self._is_le)
self._m_section_names._read()
self._io.seek(_pos)
return getattr(self, '_m_section_names', None)
@section_names.setter
def section_names(self, v):
self._dirty = True
self._m_section_names = v
def _write_section_names(self):
self._should_write_section_names = False
if ((self.section_names_idx != int(Elf.SectionHeaderIdxSpecial.undefined)) and (self.section_names_idx < self._root.header.num_section_headers)) :
pass
_pos = self._io.pos()
self._io.seek(self.section_headers[self.section_names_idx].ofs_body)
if self._is_le:
_io__raw__m_section_names = KaitaiStream(BytesIO(bytearray(self.section_headers[self.section_names_idx].len_body)))
self._io.add_child_stream(_io__raw__m_section_names)
_pos2 = self._io.pos()
self._io.seek(self._io.pos() + (self.section_headers[self.section_names_idx].len_body))
def handler(parent, _io__raw__m_section_names=_io__raw__m_section_names):
self._raw__m_section_names = _io__raw__m_section_names.to_byte_array()
if len(self._raw__m_section_names) != self.section_headers[self.section_names_idx].len_body:
raise kaitaistruct.ConsistencyError(u"raw(section_names)", self.section_headers[self.section_names_idx].len_body, len(self._raw__m_section_names))
parent.write_bytes(self._raw__m_section_names)
_io__raw__m_section_names.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_section_names._write__seq(_io__raw__m_section_names)
else:
_io__raw__m_section_names = KaitaiStream(BytesIO(bytearray(self.section_headers[self.section_names_idx].len_body)))
self._io.add_child_stream(_io__raw__m_section_names)
_pos2 = self._io.pos()
self._io.seek(self._io.pos() + (self.section_headers[self.section_names_idx].len_body))
def handler(parent, _io__raw__m_section_names=_io__raw__m_section_names):
self._raw__m_section_names = _io__raw__m_section_names.to_byte_array()
if len(self._raw__m_section_names) != self.section_headers[self.section_names_idx].len_body:
raise kaitaistruct.ConsistencyError(u"raw(section_names)", self.section_headers[self.section_names_idx].len_body, len(self._raw__m_section_names))
parent.write_bytes(self._raw__m_section_names)
_io__raw__m_section_names.write_back_handler = KaitaiStream.WriteBackHandler(_pos2, handler)
self._m_section_names._write__seq(_io__raw__m_section_names)
self._io.seek(_pos)
class PhdrTypeFlags(ReadWriteKaitaiStruct):
def __init__(self, value, _io=None, _parent=None, _root=None):
super(Elf.PhdrTypeFlags, self).__init__(_io)
self._parent = _parent
self._root = _root
self.value = value
def _read(self):
pass
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.PhdrTypeFlags, self)._write__seq(io)
def _check(self):
self._dirty = False
@property
def execute(self):
if hasattr(self, '_m_execute'):
return self._m_execute
self._m_execute = self.value & 1 != 0
return getattr(self, '_m_execute', None)
def _invalidate_execute(self):
del self._m_execute
@property
def mask_proc(self):
if hasattr(self, '_m_mask_proc'):
return self._m_mask_proc
self._m_mask_proc = self.value & 4026531840 != 0
return getattr(self, '_m_mask_proc', None)
def _invalidate_mask_proc(self):
del self._m_mask_proc
@property
def read(self):
if hasattr(self, '_m_read'):
return self._m_read
self._m_read = self.value & 4 != 0
return getattr(self, '_m_read', None)
def _invalidate_read(self):
del self._m_read
@property
def write(self):
if hasattr(self, '_m_write'):
return self._m_write
self._m_write = self.value & 2 != 0
return getattr(self, '_m_write', None)
def _invalidate_write(self):
del self._m_write
class SectionHeaderFlags(ReadWriteKaitaiStruct):
"""
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/section-headers.html#GUID-2CBE4879-2E76-426E-BB7F-CF0CB1D87C52__CHAPTER6-10675
.. seealso::
Source - https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/include/elf/common.h#L614
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L468
"""
def __init__(self, value, _io=None, _parent=None, _root=None):
super(Elf.SectionHeaderFlags, self).__init__(_io)
self._parent = _parent
self._root = _root
self.value = value
def _read(self):
pass
self._dirty = False
def _fetch_instances(self):
pass
def _write__seq(self, io=None):
super(Elf.SectionHeaderFlags, self)._write__seq(io)
def _check(self):
self._dirty = False
@property
def alloc(self):
"""Occupies memory during execution."""
if hasattr(self, '_m_alloc'):
return self._m_alloc
self._m_alloc = self.value & 2 != 0
return getattr(self, '_m_alloc', None)
def _invalidate_alloc(self):
del self._m_alloc
@property
def compressed(self):
"""Section with compressed data."""
if hasattr(self, '_m_compressed'):
return self._m_compressed
self._m_compressed = self.value & 2048 != 0
return getattr(self, '_m_compressed', None)
def _invalidate_compressed(self):
del self._m_compressed
@property
def exclude(self):
"""Section is excluded unless referenced or allocated (Solaris)."""
if hasattr(self, '_m_exclude'):
return self._m_exclude
self._m_exclude = self.value & 2147483648 != 0
return getattr(self, '_m_exclude', None)
def _invalidate_exclude(self):
del self._m_exclude
@property
def exec_instr(self):
"""Executable machine instructions."""
if hasattr(self, '_m_exec_instr'):
return self._m_exec_instr
self._m_exec_instr = self.value & 4 != 0
return getattr(self, '_m_exec_instr', None)
def _invalidate_exec_instr(self):
del self._m_exec_instr
@property
def gnu_mbind(self):
"""Mbind section.
.. seealso::
Source - https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/include/elf/common.h#L631
"""
if hasattr(self, '_m_gnu_mbind'):
return self._m_gnu_mbind
self._m_gnu_mbind = self.value & 16777216 != 0
return getattr(self, '_m_gnu_mbind', None)
def _invalidate_gnu_mbind(self):
del self._m_gnu_mbind
@property
def group(self):
"""Member of a section group."""
if hasattr(self, '_m_group'):
return self._m_group
self._m_group = self.value & 512 != 0
return getattr(self, '_m_group', None)
def _invalidate_group(self):
del self._m_group
@property
def info_link(self):
"""Section header's `sh_info` field holds a section header table index
"""
if hasattr(self, '_m_info_link'):
return self._m_info_link
self._m_info_link = self.value & 64 != 0
return getattr(self, '_m_info_link', None)
def _invalidate_info_link(self):
del self._m_info_link
@property
def link_order(self):
"""Preserve section ordering when linking."""
if hasattr(self, '_m_link_order'):
return self._m_link_order
self._m_link_order = self.value & 128 != 0
return getattr(self, '_m_link_order', None)
def _invalidate_link_order(self):
del self._m_link_order
@property
def mask_os(self):
"""OS-specific semantics."""
if hasattr(self, '_m_mask_os'):
return self._m_mask_os
self._m_mask_os = self.value & 267386880 != 0
return getattr(self, '_m_mask_os', None)
def _invalidate_mask_os(self):
del self._m_mask_os
@property
def mask_proc(self):
"""Processor-specific semantics."""
if hasattr(self, '_m_mask_proc'):
return self._m_mask_proc
self._m_mask_proc = self.value & 4026531840 != 0
return getattr(self, '_m_mask_proc', None)
def _invalidate_mask_proc(self):
del self._m_mask_proc
@property
def merge(self):
"""Data in this section can be merged to eliminate duplication."""
if hasattr(self, '_m_merge'):
return self._m_merge
self._m_merge = self.value & 16 != 0
return getattr(self, '_m_merge', None)
def _invalidate_merge(self):
del self._m_merge
@property
def ordered(self):
"""Special ordering requirement (Solaris)
From <https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/section-headers.html#GUID-2CBE4879-2E76-426E-BB7F-CF0CB1D87C52__CHAPTER6-10675>:
> `SHF_ORDERED` is an older version of the functionality provided by
> `SHF_LINK_ORDER`, and has been superseded by `SHF_LINK_ORDER`.
> `SHF_ORDERED` is no longer supported.
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L485
.. seealso::
Source - https://docs.oracle.com/en/operating-systems/solaris/oracle-solaris/11.4/linkers-libraries/section-headers.html#GUID-2CBE4879-2E76-426E-BB7F-CF0CB1D87C52__CHAPTER6-10675
"""
if hasattr(self, '_m_ordered'):
return self._m_ordered
self._m_ordered = self.value & 1073741824 != 0
return getattr(self, '_m_ordered', None)
def _invalidate_ordered(self):
del self._m_ordered
@property
def os_nonconforming(self):
"""Special OS-specific handling required."""
if hasattr(self, '_m_os_nonconforming'):
return self._m_os_nonconforming
self._m_os_nonconforming = self.value & 256 != 0
return getattr(self, '_m_os_nonconforming', None)
def _invalidate_os_nonconforming(self):
del self._m_os_nonconforming
@property
def retain(self):
"""Section should not be garbage collected by the linker.
.. seealso::
Source - https://forge.sourceware.org/binutils-gdb/binutils-gdb-mirror/src/tag/binutils-2_46_1/include/elf/common.h#L630
.. seealso::
Source - https://forge.sourceware.org/glibc/glibc-mirror/src/tag/glibc-2.43/elf/elf.h#L484
"""
if hasattr(self, '_m_retain'):
return self._m_retain
self._m_retain = self.value & 2097152 != 0
return getattr(self, '_m_retain', None)
def _invalidate_retain(self):
del self._m_retain
@property
def strings(self):
"""Contains null-terminated character strings."""
if hasattr(self, '_m_strings'):
return self._m_strings
self._m_strings = self.value & 32 != 0
return getattr(self, '_m_strings', None)
def _invalidate_strings(self):
del self._m_strings
@property
def tls(self):
"""Thread-local storage section (`.tbss` or `.tdata` according to [ELF
Handling For Thread-Local
Storage](https://www.akkadia.org/drepper/tls.pdf))
"""
if hasattr(self, '_m_tls'):
return self._m_tls
self._m_tls = self.value & 1024 != 0
return getattr(self, '_m_tls', None)
def _invalidate_tls(self):
del self._m_tls
@property
def write(self):
"""Writable during execution."""
if hasattr(self, '_m_write'):
return self._m_write
self._m_write = self.value & 1 != 0
return getattr(self, '_m_write', None)
def _invalidate_write(self):
del self._m_write
@property
def sh_idx_hi_os(self):
if hasattr(self, '_m_sh_idx_hi_os'):
return self._m_sh_idx_hi_os
self._m_sh_idx_hi_os = 65343
return getattr(self, '_m_sh_idx_hi_os', None)
def _invalidate_sh_idx_hi_os(self):
del self._m_sh_idx_hi_os
@property
def sh_idx_hi_proc(self):
if hasattr(self, '_m_sh_idx_hi_proc'):
return self._m_sh_idx_hi_proc
self._m_sh_idx_hi_proc = 65311
return getattr(self, '_m_sh_idx_hi_proc', None)
def _invalidate_sh_idx_hi_proc(self):
del self._m_sh_idx_hi_proc
@property
def sh_idx_hi_reserved(self):
if hasattr(self, '_m_sh_idx_hi_reserved'):
return self._m_sh_idx_hi_reserved
self._m_sh_idx_hi_reserved = 65535
return getattr(self, '_m_sh_idx_hi_reserved', None)
def _invalidate_sh_idx_hi_reserved(self):
del self._m_sh_idx_hi_reserved
@property
def sh_idx_lo_os(self):
if hasattr(self, '_m_sh_idx_lo_os'):
return self._m_sh_idx_lo_os
self._m_sh_idx_lo_os = 65312
return getattr(self, '_m_sh_idx_lo_os', None)
def _invalidate_sh_idx_lo_os(self):
del self._m_sh_idx_lo_os
@property
def sh_idx_lo_proc(self):
if hasattr(self, '_m_sh_idx_lo_proc'):
return self._m_sh_idx_lo_proc
self._m_sh_idx_lo_proc = 65280
return getattr(self, '_m_sh_idx_lo_proc', None)
def _invalidate_sh_idx_lo_proc(self):
del self._m_sh_idx_lo_proc
@property
def sh_idx_lo_reserved(self):
if hasattr(self, '_m_sh_idx_lo_reserved'):
return self._m_sh_idx_lo_reserved
self._m_sh_idx_lo_reserved = 65280
return getattr(self, '_m_sh_idx_lo_reserved', None)
def _invalidate_sh_idx_lo_reserved(self):
del self._m_sh_idx_lo_reserved