Mercurial > paraspace
annotate paraspace/dexfile.py @ 2:add64d56b0e2
Parse code items
author | Thinker K.F. Li <thinker@codemud.net> |
---|---|
date | Mon, 23 May 2011 21:11:11 +0800 |
parents | 05346b632adb |
children | a78db169b0c8 |
rev | line source |
---|---|
0 | 1 class _DEX_header(object): |
2 magic = None # 0x00, 8 bytes | |
3 checksum = None # 0x08, 4 bytes | |
4 signature = None # 0x0c, 20 bytes | |
5 fileSize = None # 0x20, 4 bytes | |
6 headerSize = None # 0x24 | |
7 endianTag = None # 0x28 | |
8 linkSize = None # 0x2c | |
9 linkOff = None # 0x30 | |
10 mapOff = None # 0x34 | |
11 stringIdsSize = None # 0x38 | |
12 stringIdsOff = None # 0x3c | |
13 typeIdsSize = None # 0x40 | |
14 typeIdsOff = None # 0x44 | |
15 protoIdsSize = None # 0x48 | |
16 protoIdsOff = None # 0x4c | |
17 fieldIdsSize = None # 0x50 | |
18 fieldIdsOff = None # 0x54 | |
19 methodIdsSize = None # 0x58 | |
20 methodIdsOff = None # 0x5c | |
21 classDefsSize = None # 0x60 | |
22 classDefsOff = None # 0x64 | |
23 dataSize = None # 0x68 | |
24 dataOff = None # 0x6c | |
25 | |
2 | 26 header_fields = \ |
27 'magic checksum signature fileSize headerSize endianTag ' \ | |
28 'linkSize linkOff mapOff stringIdsSize stringIdsOff typeIdsSize ' \ | |
29 'typeIdsOff protoIdsSize protoIdsOff fieldIdsSize fieldIdsOff ' \ | |
30 'methodIdsSize methodIdsOff classDefsSize classDefsOff ' \ | |
31 'dataSize dataOff'.split() | |
32 | |
0 | 33 def parse(self, data): |
34 self.magic = data[:8] | |
35 self.checksum = data[8: 0x0c] | |
36 self.signature = data[0x0c: 0x20] | |
37 | |
38 idx = 0x20 | |
39 fields = 'fileSize headerSize endianTag linkSize linkOff mapOff ' \ | |
40 'stringIdsSize stringIdsOff typeIdsSize typeIdsOff ' \ | |
41 'protoIdsSize protoIdsOff fieldIdsSize fieldIdsOff ' \ | |
42 'methodIdsSize methodIdsOff classDefsSize classDefsOff ' \ | |
43 'dataSize dataOff'.split() | |
44 for field in fields: | |
45 d = data[idx: idx + 4] | |
46 value = _to_uint(d) | |
47 setattr(self, field, value) | |
48 idx = idx + 4 | |
49 pass | |
50 pass | |
51 pass | |
52 | |
53 | |
54 def _to_uint(data): | |
55 v = 0 | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
56 sh = 0 |
0 | 57 for c in data: |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
58 v = v + (ord(c) << sh) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
59 sh = sh + 8 |
0 | 60 pass |
61 return v | |
62 | |
63 | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
64 def _uleb128(data): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
65 sh = 0 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
66 v = 0 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
67 for c in data: |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
68 cv = ord(c) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
69 v = v + ((cv & 0x7f) << sh) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
70 sh = sh + 7 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
71 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
72 if cv <= 0x7f: |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
73 break |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
74 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
75 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
76 nbytes = sh / 7 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
77 return v, nbytes |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
78 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
79 |
2 | 80 def _leb128(data): |
81 v, sh = _uleb128(data) | |
82 if v & (1 << (sh * 7 - 1)): | |
83 v = -((1 << (sh * 7)) - v) | |
84 pass | |
85 return v, sh | |
86 | |
87 | |
0 | 88 class _DEX_MapItem(object): |
89 type = None # 2 bytes | |
90 unused = None # 2 bytes | |
91 size = None # 4 bytes | |
92 offset = None # 4 bytes | |
93 | |
94 data_size = 12 | |
2 | 95 types = { |
96 0x0000: 'kDexTypeHeaderItem', | |
97 0x0001: 'kDexTypeStringIdItem', | |
98 0x0002: 'kDexTypeTypeIdItem', | |
99 0x0003: 'kDexTypeProtoIdItem', | |
100 0x0004: 'kDexTypeFieldIdItem', | |
101 0x0005: 'kDexTypeMethodIdItem', | |
102 0x0006: 'kDexTypeClassDefItem', | |
103 0x1000: 'kDexTypeMapList', | |
104 0x1001: 'kDexTypeTypeList', | |
105 0x1002: 'kDexTypeAnnotationSetRefList', | |
106 0x1003: 'kDexTypeAnnotationSetItem', | |
107 0x2000: 'kDexTypeClassDataItem', | |
108 0x2001: 'kDexTypeCodeItem', | |
109 0x2002: 'kDexTypeStringDataItem', | |
110 0x2003: 'kDexTypeDebugInfoItem', | |
111 0x2004: 'kDexTypeAnnotationItem', | |
112 0x2005: 'kDexTypeEncodedArrayItem', | |
113 0x2006: 'kDexTypeAnnotationsDirectoryItem' | |
114 } | |
0 | 115 |
116 def parse(self, data): | |
117 self.type = _to_uint(data[:2]) | |
118 self.size = _to_uint(data[4:8]) | |
119 self.offset = _to_uint(data[8:12]) | |
120 pass | |
121 pass | |
122 | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
123 |
0 | 124 class _DEX_TypeId(object): |
125 descriptorIdx = None # 4 bytes | |
126 | |
127 data_size = 4 | |
128 | |
129 def parse(self, data): | |
130 self.descriptorIdx = _to_uint(data[:4]) | |
131 pass | |
132 pass | |
133 | |
134 | |
135 class _DEX_ProtoId(object): | |
136 shortyIdx = None # 4 bytes | |
137 returnTypeIdx = None # 4 bytes | |
138 parametersOff = None # 4 bytes | |
139 | |
140 data_size = 12 | |
141 | |
142 def parse(self, data): | |
143 self.shortyIdx = _to_uint(data[:4]) | |
144 self.returnTypeIdx = _to_uint(data[4:8]) | |
145 self.parametersOff = _to_uint(data[8:12]) | |
146 pass | |
147 pass | |
148 | |
149 | |
150 class _DEX_FieldId(object): | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
151 classIdx = None # 2 bytes |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
152 typeIdx = None # 2 bytes |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
153 nameIdx = None # 4 bytes |
0 | 154 |
155 data_size = 8 | |
156 | |
157 def parse(self, data): | |
158 self.classIdx = _to_uint(data[:2]) | |
159 self.typeIdx = _to_uint(data[2:4]) | |
160 self.nameIdx = _to_uint(data[4:8]) | |
161 pass | |
162 pass | |
163 | |
164 | |
165 class _DEX_MethodId(object): | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
166 classIdx = None # 2 bytes |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
167 protoIdx = None # 2 bytes |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
168 nameIdx = None # 4 bytes |
0 | 169 |
170 data_size = 8 | |
171 | |
172 def parse(self, data): | |
173 self.classIdx = _to_uint(data[:2]) | |
174 self.protoIdx = _to_uint(data[2:4]) | |
175 self.nameIdx = _to_uint(data[4:8]) | |
176 pass | |
177 pass | |
178 | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
179 |
0 | 180 class _DEX_ClassDef(object): |
181 classIdx = None # 0x00 | |
182 accessFlags = None # 0x04 | |
183 superclassIdx = None # 0x08 | |
184 interfacesOff = None # 0x0c | |
185 sourceFileIdx = None # 0x10 | |
186 annotationsOff = None # 0x14 | |
187 classDataOff = None # 0x18 | |
188 staticValuesOff = None # 0x1c | |
189 | |
190 data_size = 0x20 | |
191 | |
192 def parse(self, data): | |
193 self.classIdx = _to_uint(data[:4]) | |
194 self.accessFlags = _to_uint(data[4:8]) | |
195 self.superclassIdx = _to_uint(data[8:0xc]) | |
196 self.interfacesOff = _to_uint(data[0xc:0x10]) | |
197 self.sourceFileIdx = _to_uint(data[0x10:0x14]) | |
198 self.annotationsOff = _to_uint(data[0x14:0x18]) | |
199 self.classDataOff = _to_uint(data[0x18:0x1c]) | |
200 self.staticValuesOff = _to_uint(data[0x1c:0x20]) | |
201 pass | |
202 pass | |
203 | |
204 | |
2 | 205 class _DEX_ClassDataHeader(object): |
206 staticFieldsSize = None | |
207 instanceFieldsSize = None | |
208 directMethodsSize = None | |
209 virtualMethodsSize = None | |
210 | |
211 data_size = None | |
212 | |
213 def parse(self, data, off): | |
214 self.staticFieldsSize, sh = _uleb128(data[off:off + 10]) | |
215 sz = sh | |
216 off = off + sh | |
217 self.instanceFieldsSize, sh = _uleb128(data[off:off + 10]) | |
218 sz = sz + sh | |
219 off = off + sh | |
220 self.directMethodsSize, sh = _uleb128(data[off:off + 10]) | |
221 sz = sz + sh | |
222 off = off + sh | |
223 self.virtualMethodsSize, sh = _uleb128(data[off:off + 10]) | |
224 sz = sz + sh | |
225 | |
226 self.data_size = sz | |
227 pass | |
228 pass | |
229 | |
230 | |
231 class _DEX_Field(object): | |
232 fieldIdx = None | |
233 accessFlags = None | |
234 | |
235 data_size = None | |
236 | |
237 def parse(self, data, off): | |
238 self.fieldIdx, sh = _uleb128(data[off:off + 10]) | |
239 sz = sh | |
240 off = off + sh | |
241 self.accessFlags, sh = _uleb128(data[off:off + 10]) | |
242 sz = sz + sh | |
243 | |
244 self.data_size = sz | |
245 pass | |
246 pass | |
247 | |
248 | |
249 class _DEX_Method(object): | |
250 methodIdx = None | |
251 accessFlags = None | |
252 codeOff = None | |
253 | |
254 data_size = None | |
255 | |
256 def parse(self, data, off): | |
257 self.methodIdx, sh = _uleb128(data[off:off + 10]) | |
258 sz = sh | |
259 off = off + sh | |
260 | |
261 self.accessFlags, sh = _uleb128(data[off:off + 10]) | |
262 sz = sz + sh | |
263 off = off + sh | |
264 | |
265 self.codeOff, sh = _uleb128(data[off:off + 10]) | |
266 sz = sz + sh | |
267 | |
268 self.data_size = sz | |
269 pass | |
270 pass | |
271 | |
272 class _DEX_ClassData(object): | |
273 header = None # DexClassDataHeader | |
274 staticFields = None # DexField* | |
275 instanceFields = None # DexField* | |
276 directMethods = None # DexMethod* | |
277 virtualMethods = None # DexMethod* | |
278 | |
279 data_size = None | |
280 | |
281 def parse(self, data, off): | |
282 header = _DEX_ClassDataHeader() | |
283 header.parse(data, off) | |
284 self.header = header | |
285 | |
286 cur_off = [off + header.data_size] | |
287 | |
288 def parse_field(): | |
289 field = _DEX_Field() | |
290 off = cur_off[0] | |
291 field.parse(data, off) | |
292 cur_off[0] = cur_off[0] + field.data_size | |
293 | |
294 # | |
295 # field index depends previous one to reduce size | |
296 # | |
297 field.fieldIdx = field.fieldIdx + idx[0] | |
298 idx[0] = field.fieldIdx | |
299 | |
300 return field | |
301 | |
302 def parse_method(): | |
303 method = _DEX_Method() | |
304 off = cur_off[0] | |
305 method.parse(data, off) | |
306 cur_off[0] = cur_off[0] + method.data_size | |
307 | |
308 # | |
309 # method index depends previous one to reduce size | |
310 # | |
311 method.methodIdx = method.methodIdx + idx[0] | |
312 idx[0] = method.methodIdx | |
313 | |
314 return method | |
315 | |
316 idx = [0] | |
317 self.staticFields = [parse_field() | |
318 for i in range(header.staticFieldsSize)] | |
319 idx = [0] | |
320 self.instanceFields = [parse_field() | |
321 for i in range(header.instanceFieldsSize)] | |
322 idx = [0] | |
323 self.directMethods = [parse_method() | |
324 for i in range(header.directMethodsSize)] | |
325 idx = [0] | |
326 self.virtualMethods = [parse_method() | |
327 for i in range(header.virtualMethodsSize)] | |
328 | |
329 self.data_size = cur_off[0] - off | |
330 pass | |
331 pass | |
332 | |
333 | |
334 class _DEX_TypeList(object): | |
335 typeItems = None | |
336 | |
337 data_size = None | |
338 | |
339 def parse(self, data, off): | |
340 size = _to_uint(data[off:off + 4]) | |
341 | |
342 item_off = off + 4 | |
343 typeItems = [_to_uint(data[cur_off:cur_off + 2]) | |
344 for cur_off in range(item_off, item_off + size * 2, 2)] | |
345 data_size = 4 + size * 2 | |
346 | |
347 self.typeItems = typeItems | |
348 self.data_size = data_size | |
349 pass | |
350 pass | |
351 | |
352 | |
353 class _DEX_TypeLists(object): | |
354 typeLists = None | |
355 | |
356 data_size = None | |
357 | |
358 def parse(self, num, data, off): | |
359 def parse(): | |
360 off = (cur_off[0] + 3) & ~0x3 | |
361 typeList = _DEX_TypeList() | |
362 typeList.parse(data, off) | |
363 cur_off[0] = off + typeList.data_size | |
364 | |
365 return typeList | |
366 | |
367 cur_off = [off] | |
368 typeLists = [parse() for i in range(num)] | |
369 | |
370 self.typeLists = typeLists | |
371 self.data_size = cur_off[0] - off | |
372 pass | |
373 pass | |
374 | |
375 | |
376 class _DEX_Try(object): | |
377 startAddr = None # 4 bytes | |
378 insnCount = None # 2 bytes | |
379 handlerOff = None # 2 bytes | |
380 | |
381 data_size = 8 | |
382 | |
383 def parse(self, data, off): | |
384 cur_off = off | |
385 self.startAddr = _to_uint(data[cur_off:cur_off + 4]) | |
386 cur_off = cur_off + 4 | |
387 self.insnCount = _to_uint(data[cur_off:cur_off + 2]) | |
388 cur_off = cur_off + 2 | |
389 self.handlerOff = _to_uint(data[cur_off:cur_off + 2]) | |
390 pass | |
391 pass | |
392 | |
393 | |
394 class _DEX_CatchHandler(object): | |
395 typeIdx = None | |
396 address = None | |
397 | |
398 data_size = None | |
399 | |
400 def parse(self, data, off): | |
401 cur_off = off | |
402 self.typeIdx, sh = _uleb128(data[cur_off:cur_off + 5]) | |
403 cur_off = cur_off + sh | |
404 self.address, sh = _uleb128(data[cur_off:cur_off + 5]) | |
405 cur_off = cur_off + sh | |
406 | |
407 self.data_size = cur_off - off | |
408 pass | |
409 | |
410 def parse1(self, data, off): | |
411 self.address, sh = _uleb128(data[off:off + 5]) | |
412 | |
413 self.data_size = sh | |
414 pass | |
415 pass | |
416 | |
417 | |
418 class _DEX_Catch(object): | |
419 catchesAll = None | |
420 handlers = None | |
421 | |
422 data_size = None | |
423 | |
424 def parse(self, data, off): | |
425 def move_off(sz): | |
426 off = move_off.off | |
427 move_off.off = off + sz | |
428 return off | |
429 move_off.off = off | |
430 moff = move_off | |
431 | |
432 count, sh = _leb128(data[moff.off:moff.off + 5]) | |
433 moff(sh) | |
434 | |
435 if count > 0: | |
436 self.catchesAll = False | |
437 else: | |
438 self.catchesAll = True | |
439 count = -count | |
440 pass | |
441 | |
442 def parse_handler(): | |
443 handler = _DEX_CatchHandler() | |
444 handler.parse(data, moff.off) | |
445 moff(handler.data_size) | |
446 return handler | |
447 | |
448 self.handlers = [parse_handler() for i in range(count)] | |
449 | |
450 if self.catchesAll: | |
451 # | |
452 # Additional handler for catching all | |
453 # | |
454 handler = _DEX_CatchHandler() | |
455 handler.parse1(data, moff.off) | |
456 moff(handler.data_size) | |
457 self.handlers.append(handler) | |
458 pass | |
459 | |
460 self.data_size = moff.off - off | |
461 pass | |
462 pass | |
463 | |
464 | |
465 class _DEX_Code(object): | |
466 registersSize = None # 2 bytes | |
467 insSize = None # 2 bytes | |
468 outsSize = None # 2 bytes | |
469 triesSize = None # 2 bytes | |
470 debugInfoOff = None # 4 bytes | |
471 insnsSize = None # 4 bytes | |
472 insns = None | |
473 try_items = None | |
474 catch_handler_items = None | |
475 | |
476 data_size = None | |
477 | |
478 def parse(self, data, off): | |
479 def move_off(sz): | |
480 off = move_off.off | |
481 move_off.off = off + sz | |
482 return off | |
483 move_off.off = off | |
484 moff = move_off | |
485 | |
486 self.registersSize = _to_uint(data[moff.off:moff.off + 2]) | |
487 moff(2) | |
488 self.insSize = _to_uint(data[moff.off:moff.off + 2]) | |
489 moff(2) | |
490 self.outsSize = _to_uint(data[moff.off:moff.off + 2]) | |
491 moff(2) | |
492 self.triesSize = _to_uint(data[moff.off:moff.off + 2]) | |
493 moff(2) | |
494 self.debugInfoOff = _to_uint(data[moff.off:moff.off + 4]) | |
495 moff(4) | |
496 self.insnsSize = _to_uint(data[moff.off:moff.off + 4]) | |
497 moff(4) | |
498 | |
499 moff(self.insnsSize * 2) # skip insns | |
500 | |
501 if self.triesSize > 0: | |
502 def parse_try_item(): | |
503 try_item = _DEX_Try() | |
504 try_item.parse(data, moff.off) | |
505 moff(try_item.data_size) | |
506 return try_item | |
507 | |
508 moff.off = (moff.off + 3) & ~0x3 | |
509 self.try_items = [parse_try_item() for i in range(self.triesSize)] | |
510 | |
511 def parse_catch_handler(): | |
512 catch = _DEX_Catch() | |
513 catch.parse(data, moff.off) | |
514 moff(catch.data_size) | |
515 return catch | |
516 | |
517 # | |
518 # No tries, no catch handlers | |
519 # | |
520 handlersSize, sh = _uleb128(data[moff.off:moff.off + 5]) | |
521 moff(sh) | |
522 self.catch_handler_items = [parse_catch_handler() | |
523 for i in range(handlersSize)] | |
524 pass | |
525 | |
526 moff.off = (moff.off + 3) & ~0x3 | |
527 self.data_size = moff.off - off | |
528 pass | |
529 pass | |
530 | |
531 | |
0 | 532 class DEXFile(object): |
533 _data = None | |
534 _header = None | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
535 _maps = None |
0 | 536 _strings = None |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
537 _typeIds = None |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
538 _protoIds = None |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
539 _fieldIds = None |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
540 _methodIds = None |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
541 _classDefs = None |
2 | 542 _classDatas = None |
543 _typeLists = None | |
544 _codeItems = None | |
0 | 545 |
546 def __init__(self): | |
547 pass | |
548 | |
549 def open(self, filename): | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
550 fo = file(filename, 'r') |
0 | 551 data = fo.read() |
552 | |
553 self.parse(data) | |
554 pass | |
555 | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
556 def _parse_maps(self): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
557 data = self._data |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
558 header = self._header |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
559 off = header.mapOff |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
560 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
561 num = _to_uint(data[off:off + 4]) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
562 off = off + 4 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
563 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
564 maps = [] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
565 for i in range(num): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
566 item_data = data[off:off + _DEX_MapItem.data_size] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
567 item = _DEX_MapItem() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
568 item.parse(item_data) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
569 maps.append(item) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
570 off = off + _DEX_MapItem.data_size |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
571 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
572 |
2 | 573 self._maps = maps |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
574 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
575 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
576 def _parse_strings(self): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
577 data = self._data |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
578 header = self._header |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
579 strings = [] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
580 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
581 num = header.stringIdsSize |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
582 off = header.stringIdsOff |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
583 for i in range(num): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
584 str_start_off = _to_uint(data[off:off + 4]) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
585 str_stop_off = data.index('\x00', str_start_off) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
586 string = data[str_start_off:str_stop_off] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
587 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
588 sz, sh = _uleb128(string) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
589 string = string[sh:] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
590 strings.append(string) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
591 off = off + 4 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
592 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
593 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
594 self._strings = strings |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
595 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
596 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
597 def _parse_typeIds(self): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
598 data = self._data |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
599 header = self._header |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
600 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
601 num = header.typeIdsSize |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
602 off = header.typeIdsOff |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
603 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
604 def parse(item_data): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
605 type_id = _DEX_TypeId() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
606 type_id.parse(item_data) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
607 return type_id |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
608 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
609 item_size = _DEX_TypeId.data_size |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
610 item_offs = range(off, off + item_size * num, item_size) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
611 item_datas = [data[item_off:item_off + item_size] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
612 for item_off in item_offs] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
613 typeIds = [parse(item_data) for item_data in item_datas] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
614 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
615 self._typeIds = typeIds |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
616 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
617 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
618 def _parse_protoIds(self): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
619 data = self._data |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
620 header = self._header |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
621 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
622 num = header.protoIdsSize |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
623 off = header.protoIdsOff |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
624 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
625 def parse(item_data): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
626 proto_id = _DEX_ProtoId() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
627 proto_id.parse(item_data) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
628 return proto_id |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
629 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
630 item_size = _DEX_ProtoId.data_size |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
631 item_offs = range(off, off + item_size * num, item_size) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
632 item_datas = [data[item_off:item_off + item_size] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
633 for item_off in item_offs] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
634 protoIds = [parse(item_data) for item_data in item_datas] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
635 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
636 self._protoIds = protoIds |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
637 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
638 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
639 def _parse_fieldIds(self): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
640 data = self._data |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
641 header = self._header |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
642 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
643 num = header.fieldIdsSize |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
644 off = header.fieldIdsOff |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
645 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
646 def parse(item_data): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
647 field_id = _DEX_FieldId() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
648 field_id.parse(item_data) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
649 return field_id |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
650 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
651 item_size = _DEX_FieldId.data_size |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
652 item_offs = range(off, off + item_size * num, item_size) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
653 item_datas = [data[item_off:item_off + item_size] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
654 for item_off in item_offs] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
655 fieldIds = [parse(item_data) for item_data in item_datas] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
656 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
657 self._fieldIds = fieldIds |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
658 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
659 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
660 def _parse_methodIds(self): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
661 data = self._data |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
662 header = self._header |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
663 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
664 num = header.methodIdsSize |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
665 off = header.methodIdsOff |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
666 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
667 def parse(item_data): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
668 method_id = _DEX_MethodId() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
669 method_id.parse(item_data) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
670 return method_id |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
671 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
672 item_size = _DEX_MethodId.data_size |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
673 item_offs = range(off, off + item_size * num, item_size) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
674 item_datas = [data[item_off:item_off + item_size] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
675 for item_off in item_offs] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
676 methodIds = [parse(item_data) for item_data in item_datas] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
677 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
678 self._methodIds = methodIds |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
679 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
680 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
681 def _parse_classDefs(self): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
682 data = self._data |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
683 header = self._header |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
684 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
685 num = header.classDefsSize |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
686 off = header.classDefsOff |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
687 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
688 def parse(item_data): |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
689 class_def = _DEX_ClassDef() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
690 class_def.parse(item_data) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
691 return class_def |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
692 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
693 item_size = _DEX_ClassDef.data_size |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
694 item_offs = range(off, off + item_size * num, item_size) |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
695 item_datas = [data[item_off:item_off + item_size] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
696 for item_off in item_offs] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
697 classDefs = [parse(item_data) for item_data in item_datas] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
698 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
699 self._classDefs = classDefs |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
700 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
701 |
2 | 702 def _parse_classDatas(self): |
703 header = self._header | |
704 data = self._data | |
705 maps = self._maps | |
706 | |
707 kDexTypeClassDataItem = [type | |
708 for type, name in _DEX_MapItem.types.items() | |
709 if name == 'kDexTypeClassDataItem'][0] | |
710 class_data_map = [map | |
711 for map in maps | |
712 if map.type == kDexTypeClassDataItem][0] | |
713 | |
714 off = [class_data_map.offset] | |
715 def parse_class_data(): | |
716 class_data = _DEX_ClassData() | |
717 class_data.parse(data, off[0]) | |
718 off[0] = off[0] + class_data.data_size | |
719 return class_data | |
720 class_datas = [parse_class_data() for i in range(class_data_map.size)] | |
721 | |
722 self._classDatas = class_datas | |
723 pass | |
724 | |
725 def _parse_typeLists(self): | |
726 maps = self._maps | |
727 data = self._data | |
728 | |
729 kDexTypeTypeList = [type | |
730 for type, name in _DEX_MapItem.types.items() | |
731 if name == 'kDexTypeTypeList'][0] | |
732 typeList_map = [map for map in maps if map.type == kDexTypeTypeList][0] | |
733 num_typeLists = typeList_map.size | |
734 | |
735 typeLists = _DEX_TypeLists() | |
736 typeLists.parse(num_typeLists, data, typeList_map.offset) | |
737 | |
738 self._typeLists = typeLists | |
739 pass | |
740 | |
741 def _parse_codeItems(self): | |
742 maps = self._maps | |
743 data = self._data | |
744 | |
745 kDexTypeCodeItem = [type | |
746 for type, name in _DEX_MapItem.types.items() | |
747 if name == 'kDexTypeCodeItem'][0] | |
748 codeItem_map = [map for map in maps if map.type == kDexTypeCodeItem][0] | |
749 num_codeItems = codeItem_map.size | |
750 | |
751 cur_off = [codeItem_map.offset] | |
752 def parse_code(): | |
753 off = cur_off[0] | |
754 code = _DEX_Code() | |
755 code.parse(data, off) | |
756 cur_off[0] = off + code.data_size | |
757 return code | |
758 | |
759 codeItems = [parse_code() for i in range(num_codeItems)] | |
760 | |
761 self._codeItems = codeItems | |
762 pass | |
763 | |
0 | 764 def parse(self, data): |
765 self._data = data | |
766 header = _DEX_header() | |
767 header.parse(data) | |
768 self._header = header | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
769 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
770 self._parse_maps() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
771 self._parse_strings() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
772 self._parse_typeIds() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
773 self._parse_protoIds() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
774 self._parse_fieldIds() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
775 self._parse_methodIds() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
776 self._parse_classDefs() |
2 | 777 self._parse_classDatas() |
778 self._parse_typeLists() | |
779 self._parse_codeItems() | |
0 | 780 pass |
781 pass | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
782 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
783 if __name__ == '__main__': |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
784 dex = DEXFile() |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
785 dex.open('test.dex') |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
786 |
2 | 787 print 'Header' |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
788 h = dex._header |
2 | 789 for attr in h.header_fields: |
790 print '\t%s: %s' % (attr, repr(getattr(h, attr))) | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
791 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
792 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
793 print |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
794 print 'Define Classes' |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
795 strings = dex._strings |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
796 classDefs = dex._classDefs |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
797 typeIds = dex._typeIds |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
798 for classDef in classDefs: |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
799 typeId = typeIds[classDef.classIdx] |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
800 descriptor = strings[typeId.descriptorIdx] |
2 | 801 data_off = classDef.classDataOff |
802 print '\t%s @0x%x' % (descriptor, data_off) | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
803 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
804 |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
805 print |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
806 print 'Reference Classes' |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
807 for typeId in typeIds: |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
808 descriptor = strings[typeId.descriptorIdx] |
2 | 809 print '\t%s' % (descriptor) |
810 pass | |
811 | |
812 print | |
813 print 'Class data' | |
814 methodIds = dex._methodIds | |
815 classDatas = dex._classDatas | |
816 for classData in classDatas: | |
817 print '\tclass' | |
818 for method in classData.directMethods: | |
819 code_off = method.codeOff | |
820 methodId = methodIds[method.methodIdx] | |
821 name = strings[methodId.nameIdx] | |
822 print '\t\t%s@0x%x' % (name, code_off) | |
823 pass | |
824 for method in classData.virtualMethods: | |
825 code_off = method.codeOff | |
826 methodId = methodIds[method.methodIdx] | |
827 name = strings[methodId.nameIdx] | |
828 print '\t\t%s@0x%x' % (name, code_off) | |
829 pass | |
830 pass | |
831 | |
832 print | |
833 print 'TypeLists size is %d bytes' % (dex._typeLists.data_size) | |
834 | |
835 bytes = sum([code.data_size for code in dex._codeItems]) | |
836 print | |
837 print 'CodeItems size is %d bytes' % (bytes) | |
838 | |
839 print | |
840 print 'Data maps' | |
841 maps = dex._maps | |
842 for map in maps: | |
843 print '\t0x%04x(%s) size=%d offset=0x%08x' % (map.type, | |
844 map.types[map.type], | |
845 map.size, | |
846 map.offset) | |
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
847 pass |
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
848 pass |