1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
import struct
import os
import io
import sys
from dataclasses import dataclass, field
from typing import IO, Dict, Optional, List, Set, Tuple
from functools import reduce
from collections import defaultdict
from . import elf
from .section import *
from .relocation import *
from .symbol import *
class ElfException(Exception):
...
@dataclass
class Object:
header: elf.Header = None
sections: Dict[str, Section] = field(default_factory=dict)
sym_sections: Dict[int, SymbolTableSection] = field(default_factory=dict)
str_sections: Dict[int, StringTableSection] = field(default_factory=dict)
rel_sections: Dict[int, Section] = field(default_factory=dict)
rela_sections: Dict[int, RelocationASection] = field(default_factory=dict)
symbols: List[Symbol] = field(default_factory=list)
symbol_map: Dict[str, Symbol] = field(default_factory=lambda: defaultdict(list))
section_relocations: List[Tuple[str, List[Relocation]]] = field(default_factory=list)
relocations: List[Relocation] = field(default_factory=list)
name: str = None
path: Path = None
executable: bool = False
def load_object_from_file(path, name, file, skip_symbols = False, skip_relocations = False) -> Object:
obj = Object()
obj.path = path
obj.name = name
header = elf.Header()
header.read(file)
obj.header = header
if header.e_ident[elf.EI_MAG] != 2135247942:
raise ElfException("invalid elf file: 0x%08X == 0x7F454C46 '%s'" % (header.e_ident[elf.EI_MAG], name))
if header.e_ident[elf.EI_CLASS] != 1:
raise ElfException("only support elf 32-bit")
if header.e_ident[elf.EI_DATA] != 2:
raise ElfException("only support big-endianess")
if header.e_ident[elf.EI_VERSION] != 1:
raise ElfException("invalid elf version")
if header.e_type != 1 and header.e_type != 2:
raise ElfException("invalid object file type")
if header.e_machine != 20:
raise ElfException("invalid target")
if header.e_version != 1:
raise ElfException("invalid elf version")
if header.e_phnum > 0 and header.e_phentsize != 0x20:
raise ElfException("invalid program header size")
if header.e_shnum > 0 and header.e_shentsize != 0x28:
raise ElfException("invalid section header size")
if header.e_type == elf.ET_EXEC:
obj.executable = True
program_headers = []
section_headers = []
# Read program headers
file.seek(header.e_phoff, os.SEEK_SET)
for _ in range(header.e_phnum):
program_header = elf.ProgramHeader()
program_header.read(file)
# Read sections headers
file.seek(header.e_shoff, os.SEEK_SET)
for i in range(header.e_shnum):
section_header = elf.SectionHeader()
section_header.read(i, file)
if not (section_header.sh_type == elf.SHT_NULL
or section_header.sh_type == elf.SHT_PROGBITS
or section_header.sh_type == elf.SHT_SYMTAB
or section_header.sh_type == elf.SHT_STRTAB
or section_header.sh_type == elf.SHT_RELA
or section_header.sh_type == elf.SHT_NOBITS
or section_header.sh_type == elf.SHT_MW_CATS):
raise ElfException("unsupport section type: 0x%08X = %s (%s)" % (
section_header.sh_type,
elf.SH_TYPES[section_header.sh_type] if section_header.sh_type in elf.SH_TYPES else "????",
path))
section_headers.append(section_header)
# Create sections
idx_sections = dict()
for i, sheader in enumerate(section_headers):
section = None
if sheader.sh_type == elf.SHT_PROGBITS:
section = ProgBitsSection(sheader, file)
elif sheader.sh_type == elf.SHT_NOBITS:
section = NoBitsSection(sheader)
elif sheader.sh_type == elf.SHT_STRTAB:
section = StringTableSection(sheader, file)
obj.str_sections[i] = section
elif sheader.sh_type == elf.SHT_SYMTAB:
section = SymbolTableSection(sheader, file)
obj.sym_sections[i] = section
elif sheader.sh_type == elf.SHT_RELA:
section = RelocationASection(sheader, file)
obj.rela_sections[i] = section
elif sheader.sh_type == elf.SHT_NULL:
section = Section(sheader)
elif sheader.sh_type == elf.SHT_MW_CATS:
section = Section(sheader)
assert section
idx_sections[i] = section
# Find .shstrtab containing section names
if not header.e_shstrndx in idx_sections:
raise ElfException("header.e_shstrndx out-of-bounds")
shstrtab_section = idx_sections[header.e_shstrndx]
if not isinstance(shstrtab_section, StringTableSection):
raise ElfException("header.e_shstrndx is not a string table")
# Get section names
for i, section in idx_sections.items():
if section.header.sh_type == elf.SHT_NULL:
continue
section.name = shstrtab_section.readString(section.header.sh_name)
if section.name:
obj.sections[section.name] = section
if not skip_symbols:
# Find all symbols
for symtab in obj.sym_sections.values():
if not symtab.header.sh_link in obj.str_sections:
raise ElfException("symbol table '%s' is not referenceing a valid string table section (sh_link: %i)" % (
symtab.name, symtab.header.sh_link))
symtab.object_offset = len(obj.symbols)
strtab = obj.str_sections[symtab.header.sh_link]
for i,sym in enumerate(symtab.symbols):
if i == 0:
symbol = NullSymbol(sym)
symbol.object = obj
obj.symbols.append(symbol)
continue
name = None
if sym.st_name:
name = strtab.readString(sym.st_name)
symbol = None
if sym.st_shndx == elf.SHN_UNDEF:
symbol = UndefSymbol(sym, name)
elif sym.st_shndx == elf.SHN_ABS:
symbol = AbsoluteSymbol(sym, name, sym.st_value)
else:
if not sym.st_shndx in idx_sections:
raise ElfException("symbol '%s' has invalid section-id (st_shndx: %i)" % (name, sym.st_shndx))
s = idx_sections[sym.st_shndx]
symbol = OffsetSymbol(sym, name, idx_sections[sym.st_shndx], sym.st_value)
assert symbol
symbol.object = obj
if symbol.name:
obj.symbol_map[symbol.name].append(symbol)
obj.symbols.append(symbol)
if not skip_relocations:
# Find all relocations
for rela_section in obj.rela_sections.values():
if not rela_section.header.sh_link in obj.sym_sections:
raise ElfException("relocation section '%s' is not referenceing a valid symbol table section (sh_link: %i)" % (
symtab.name, rela_section.header.sh_link))
if not rela_section.header.sh_info in idx_sections:
raise ElfException("relocation section '%s' is not referenceing a valid section (sh_info: %i)" % (
symtab.name, rela_section.header.sh_info))
symtab = obj.sym_sections[rela_section.header.sh_link]
modify = idx_sections[rela_section.header.sh_info]
section_relocations = []
for rela in rela_section.relocations:
type = elf.R_TYPE(rela.r_info)
sym_id = elf.R_SYM(rela.r_info)
if not type in RELOCATION_NAMES:
raise ElfException("unsupported relocation type: 0x%02X (in '%s')" % (type, path))
if sym_id < 0 or sym_id >= len(symtab.symbols):
# report warning?
# main.elf will generate relocation sections with invalid symbol indices
# raise ElfException("invalid symbol index: %i (%i symbols)" % (sym_id, len(symtab.symbols)))
continue
symbol = obj.symbols[symtab.object_offset + sym_id]
relocation = None
if type == 1:
relocation = R_PPC_ADDR32(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 3:
relocation = R_PPC_ADDR16(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 4:
relocation = R_PPC_ADDR16_LO(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 5:
relocation = R_PPC_ADDR16_HI(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 6:
relocation = R_PPC_ADDR16_HA(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 10:
relocation = R_PPC_REL24(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 11:
relocation = R_PPC_REL14(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 109:
relocation = R_PPC_EMB_SDA21(type, symbol, modify, rela.r_offset, rela.r_addend)
elif type == 24:
continue
else:
print("unsupported relocation type: 0x%02X \"%s\" (in '%s')" % (type, RELOCATION_NAMES[type], path), file = sys.stderr)
continue
assert relocation
section_relocations.append(relocation)
obj.relocations.append(relocation)
obj.section_relocations.append((rela_section.name, section_relocations))
return obj
def load_object_from_path(path, skip_symbols = False, skip_relocations = False) -> Object:
with open(path, 'rb') as file:
return load_object_from_file(path, path.parts[-1], file, skip_symbols, skip_relocations)
|
