#!/usr/bin/env python3
# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Utilities for optimistically parsing DEX files.
This file is not meant to provide a generic tool for analyzing DEX files.
A DexFile class that exposes access to several memory items in the DEX format
is provided, but it does not include error handling or validation.
"""
import abc
import argparse
import collections
import errno
import functools
import os
import re
import struct
import sys
import zipfile
import dalvik_bytecode
import stream_reader
# https://source.android.com/devices/tech/dalvik/dex-format#header-item
_DEX_HEADER_FMT = (
('magic', '8s'),
('checksum', 'I'),
('signature', '20s'),
('file_size', 'I'),
('header_size', 'I'),
('endian_tag', 'I'),
('link_size', 'I'),
('link_off', 'I'),
('map_off', 'I'),
('string_ids_size', 'I'),
('string_ids_off', 'I'),
('type_ids_size', 'I'),
('type_ids_off', 'I'),
('proto_ids_size', 'I'),
('proto_ids_off', 'I'),
('field_ids_size', 'I'),
('field_ids_off', 'I'),
('method_ids_size', 'I'),
('method_ids_off', 'I'),
('class_defs_size', 'I'),
('class_defs_off', 'I'),
('data_size', 'I'),
('data_off', 'I'),
)
class TypeCode:
LOOKUP = {}
def __init__(self, name, value):
assert value not in TypeCode.LOOKUP
self.name = name
self.value = value
TypeCode.LOOKUP[value] = self
# Full list of type codes:
# https://source.android.com/devices/tech/dalvik/dex-format#type-codes
_TYPE_HEADER_ITEM = TypeCode('HEADER', 0x0000)
_TYPE_STRING_ID_ITEM = TypeCode('STRING_ID', 0x0001)
_TYPE_TYPE_ID_ITEM = TypeCode('TYPE_ID', 0x0002)
_TYPE_PROTO_ID_ITEM = TypeCode('PROTO_ID', 0x0003)
_TYPE_FIELD_ID_ITEM = TypeCode('FIELD_ID', 0x0004)
_TYPE_METHOD_ID_ITEM = TypeCode('METHOD_ID', 0x0005)
_TYPE_CLASS_DEF_ITEM = TypeCode('CLASS_DEF', 0x0006)
_TYPE_CALL_SITE_ID_ITEM = TypeCode('CALL_SITE_ID', 0x0007)
_TYPE_METHOD_HANDLE_ITEM = TypeCode('METHOD_HANDLE', 0x0008)
_TYPE_MAP_LIST = TypeCode('MAP', 0x1000)
_TYPE_TYPE_LIST = TypeCode('TYPE', 0x1001)
_TYPE_ANNOTATION_SET_REF_LIST = TypeCode('ANNOTATION_SET_REF', 0x1002)
_TYPE_ANNOTATION_SET_ITEM = TypeCode('ANNOTATION_SET', 0x1003)
_TYPE_CLASS_DATA_ITEM = TypeCode('CLASS_DATA', 0x2000)
_TYPE_CODE_ITEM = TypeCode('CODE', 0x2001)
_TYPE_STRING_DATA_ITEM = TypeCode('STRING_DATA', 0x2002)
_TYPE_DEBUG_INFO_ITEM = TypeCode('DEBUG_INFO', 0x2003)
_TYPE_ANNOTATION_ITEM = TypeCode('ANNOTATION', 0x2004)
_TYPE_ENCODED_ARRAY_ITEM = TypeCode('ENCODED_ARRAY', 0x2005)
_TYPE_ANNOTATIONS_DIRECTORY_ITEM = TypeCode('ANNOTATIONS_DIRECTORY', 0x2006)
_TYPE_HIDDENAPI_CLASS_DATA_ITEM = TypeCode('HIDDENAPI_CLASS_DATA', 0xF000)
_CLASS_ACCESS_FLAGS = {
0x1: 'public',
0x2: 'private',
0x4: 'protected',
0x8: 'static',
0x10: 'final',
0x200: 'interface',
0x400: 'abstract',
0x1000: 'synthetic',
0x2000: 'annotation',
0x4000: 'enum',
}
DexHeader = collections.namedtuple('DexHeader',
','.join(t[0] for t in _DEX_HEADER_FMT))
# Simple memory items.
_StringDataItem = collections.namedtuple('StringDataItem',
'utf16_size,data,byte_size')
_TypeIdItem = collections.namedtuple('TypeIdItem', 'descriptor_idx')
_ProtoIdItem = collections.namedtuple(
'ProtoIdItem', 'shorty_idx,return_type_idx,parameters_off')
_FieldIdItem = collections.namedtuple('FieldIdItem',
'class_idx,type_idx,name_idx')
_MethodIdItem = collections.namedtuple('MethodIdItem',
'type_idx,proto_idx,name_idx')
_ClassDefItem = collections.namedtuple(
'ClassDefItem',
'class_idx,access_flags,superclass_idx,interfaces_off,source_file_idx,'
'annotations_off,class_data_off,static_values_off')
_ClassDataItem = collections.namedtuple(
'ClassDataItem',
'offset,static_fields_size,instance_fields_size,direct_methods_size,'
'virtual_methods_size,static_fields,instance_fields,direct_methods,'
'virtual_methods')
_EncodedField = collections.namedtuple('EncodedField', 'field_idx,access_flags')
_EncodedMethod = collections.namedtuple('EncodedMethod',
'method_idx,access_flags,code_off')
_TypeItem = collections.namedtuple('TypeItem', 'type_idx')
_CodeItem = collections.namedtuple(
'CodeItem',
'offset,registers_size,ins_size,outs_size,tries_size,debug_info_off,'
'insns_size,insns,tries,handlers')
_TryItem = collections.namedtuple('TryItem',
'start_addr,insn_count,handler_off')
_EncodedCatchHandlerList = collections.namedtuple('_EncodedCatchHandlerList',
'size,list')
_EncodedCatchHandler = collections.namedtuple('_EncodedCatchHandler',
'size,handlers,catch_all_addr')
_EncodedTypeAddrPair = collections.namedtuple('_EncodedTypeAddrPair',
'type_idx,addr')
class _DexReader(stream_reader.StreamReader):
def NextDexHeader(self):
header_fmt = '<' + ''.join(t[1] for t in _DEX_HEADER_FMT)
return DexHeader._make(self.NextStruct(header_fmt))
def NextClassDataItem(self):
offset = self.Tell()
static_fields_size = self.NextULeb128()
instance_fields_size = self.NextULeb128()
direct_methods_size = self.NextULeb128()
virtual_methods_size = self.NextULeb128()
static_fields = self.NextEncodedFieldList(static_fields_size)
instance_fields = self.NextEncodedFieldList(instance_fields_size)
direct_methods = self.NextEncodedMethodList(direct_methods_size)
virtual_methods = self.NextEncodedMethodList(virtual_methods_size)
return _ClassDataItem(offset, static_fields_size, instance_fields_size,
direct_methods_size, virtual_methods_size,
static_fields, instance_fields, direct_methods,
virtual_methods)
def NextEncodedFieldList(self, count):
ret = []
field_idx = 0
for _ in range(count):
field_idx += self.NextULeb128()
ret.append(_EncodedField(field_idx, self.NextULeb128()))
return ret
def NextEncodedMethodList(self, count):
ret = []
method_idx = 0
for _ in range(count):
method_idx += self.NextULeb128()
ret.append(
_EncodedMethod(method_idx, self.NextULeb128(), self.NextULeb128()))
return ret
def NextCodeItem(self):
item_offset = self.Tell()
registers_size = self.NextUShort()
ins_size = self.NextUShort()
outs_size = self.NextUShort()
tries_size = self.NextUShort()
debug_info_off = self.NextUInt()
insns_size = self.NextUInt()
insns = self.NextBytes(insns_size * 2)
if tries_size > 0:
self.AlignUpTo(4)
tries = [self.NextTryItem() for _ in range(tries_size)]
handlers = None
if tries_size != 0:
handlers = self.NextEncodedCatchHandlerList()
self.AlignUpTo(4)
return _CodeItem(item_offset, registers_size, ins_size, outs_size,
tries_size, debug_info_off, insns_size, insns, tries,
handlers)
def NextTryItem(self):
return _TryItem(self.NextUInt(), self.NextUShort(), self.NextUShort())
def NextEncodedCatchHandlerList(self):
size = self.NextULeb128()
handler_list = [self.NextEncodedCatchHandler() for _ in range(size)]
return _EncodedCatchHandlerList(size, handler_list)
def NextEncodedCatchHandler(self):
size = self.NextSLeb128()
handlers = [self.NextEncodedTypeAddrPair() for _ in range(abs(size))]
catch_all_addr = self.NextULeb128() if size <= 0 else None
return _EncodedCatchHandler(size, handlers, catch_all_addr)
def NextEncodedTypeAddrPair(self):
return _EncodedTypeAddrPair(self.NextULeb128(), self.NextULeb128())
class _MemoryItemList:
"""Base class for repeated memory items."""
def __init__(self,
reader,
offset,
size,
factory,
alignment=None,
first_item_offset=None):
"""Creates the item list using the specific item factory.
Args:
reader: _DexReader used for decoding the memory item.
offset: Offset from start of the file to the item list, serving as the
key for some item types.
size: Number of memory items in the list.
factory: Function to extract each memory item from a _DexReader.
alignment: Optional integer specifying the alignment for the memory
section represented by this list.
first_item_offset: Optional, specifies a different offset to use for
extracting memory items (default is to use offset).
"""
self.offset = offset
self.size = size
if self.size > 0:
reader.Seek(first_item_offset or offset)
self._items = reader.NextList(size, factory)
else:
self._items = []
if alignment:
reader.AlignUpTo(alignment)
def __iter__(self):
return iter(self._items)
def __getitem__(self, key):
return self._items[key]
def __len__(self):
return len(self._items)
def __repr__(self):
item_type_part = ''
if self.size != 0:
item_type = type(self._items[0])
item_type_part = ', item type={}'.format(item_type.__name__)
return '{}(offset={:#x}, size={}{})'.format(
type(self).__name__, self.offset, self.size, item_type_part)
class _StringItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
reader.Seek(offset)
string_data_item_offsets = iter([reader.NextUInt() for _ in range(size)])
def factory(x):
start_pos = next(string_data_item_offsets)
x.Seek(start_pos)
string = x.NextString()
byte_size = x.Tell() - start_pos
return _StringDataItem(len(string), string, byte_size)
super().__init__(reader, offset, size, factory)
class _TypeIdItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
factory = lambda x: _TypeIdItem(x.NextUInt())
super().__init__(reader, offset, size, factory)
class _ProtoIdItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
factory = lambda x: _ProtoIdItem(x.NextUInt(), x.NextUInt(), x.NextUInt())
super().__init__(reader, offset, size, factory)
class _FieldIdItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
factory = (
lambda x: _FieldIdItem(x.NextUShort(), x.NextUShort(), x.NextUInt()))
super().__init__(reader, offset, size, factory)
class _MethodIdItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
factory = (
lambda x: _MethodIdItem(x.NextUShort(), x.NextUShort(), x.NextUInt()))
super().__init__(reader, offset, size, factory)
class _ClassDefItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
reader.Seek(offset)
def factory(x):
return _ClassDefItem(*(x.NextUInt()
for _ in range(len(_ClassDefItem._fields))))
super().__init__(reader, offset, size, factory)
class _ClassDataItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
reader.Seek(offset)
super().__init__(reader, offset, size, lambda x: x.NextClassDataItem())
class _TypeListItem(_MemoryItemList):
def __init__(self, reader):
offset = reader.Tell()
size = reader.NextUInt()
factory = lambda x: _TypeItem(x.NextUShort())
# This is necessary because we need to extract the size of the type list
# (in other cases the list size is provided in the header).
first_item_offset = reader.Tell()
super().__init__(reader,
offset,
size,
factory,
alignment=4,
first_item_offset=first_item_offset)
class _TypeListItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
super().__init__(reader, offset, size, _TypeListItem)
class _CodeItemList(_MemoryItemList):
def __init__(self, reader, offset, size):
reader.Seek(offset)
super().__init__(reader, offset, size, lambda x: x.NextCodeItem())
class _DexMapItem:
def __init__(self, reader):
if reader:
self.type = reader.NextUShort()
reader.NextUShort() # Unused.
self.size = reader.NextUInt()
self.offset = reader.NextUInt()
else:
self.type = None
self.size = 0
self.offset = 0
def GetName(self):
type_code = TypeCode.LOOKUP.get(self.type)
return type_code.name if type_code else ('(Type code %04x)' % self.type)
def __repr__(self):
return '_DexMapItem(type={}, size={}, offset={:#x})'.format(
self.type, self.size, self.offset)
class _DexMapList:
def __init__(self, reader, offset):
self._map = {}
reader.Seek(offset)
self._size = reader.NextUInt()
for _ in range(self._size):
item = _DexMapItem(reader)
self._map[item.type] = item
def get(self, key):
return self._map.get(key)
def GetMapItemsSortedByOffset(self):
return sorted(self._map.values(), key=lambda x: x.offset)
def __repr__(self):
return '_DexMapList(size={}, items={})'.format(self._size, self._map)
class DexFile:
"""Represents a single DEX file.
Parses and exposes access to DEX file structure and contents, as described
at https://source.android.com/devices/tech/dalvik/dex-format
Fields:
reader: _DexReader object used to decode DEX file contents.
header: DexHeader for this DEX file.
map_list: _DexMapList object containing list of DEX file contents.
string_data_item_list: _StringItemList containing _StringDataItems that are
referenced by index in other sections.
type_id_item_list: _TypeIdItemList containing _TypeIdItems.
proto_id_item_list: _ProtoIdItemList containing _ProtoIdItems.
field_id_item_list: _FieldIdItemList containing _FieldIdItems.
method_id_item_list: _MethodIdItemList containing _MethodIdItems.
type_list_item_list: _TypeListItemList containing _TypeListItems.
_TypeListItems are referenced by their offsets from other DEX items.
class_def_item_list: _ClassDefItemList containing _ClassDefItems.
class_data_item_list: _ClassDataItemList containing _ClassDataItems.
code_item_list: _CodeItemList containing _CodeItems.
"""
def __init__(self, data, is_eager=False):
"""Decodes dex file memory sections.
Args:
data: bytearray containing the contents of a DEX file.
is_eager: Whether to parse |data| fully (slower) instead of lazy parsing.
"""
self.size = len(data)
self.reader = _DexReader(data)
self.header = self.reader.NextDexHeader()
self.map_list = _DexMapList(self.reader, self.header.map_off)
# Data that require nontrivial processing are lazily initialized by default,
# with support for eager initialization if desired.
if is_eager:
_ = self.string_data_item_list
_ = self.type_id_item_list
_ = self.proto_id_item_list
_ = self.field_id_item_list
_ = self.method_id_item_list
_ = self.class_def_item_list
_ = self.type_list_item_list
_ = self.class_data_item_list
_ = self.code_item_list
_ = self._type_lists_by_offset
_ = self._class_data_item_by_offset
_ = self._code_item_by_offset
@property
@functools.lru_cache
def string_data_item_list(self):
return _StringItemList(self.reader, self.header.string_ids_off,
self.header.string_ids_size)
@property
@functools.lru_cache
def type_id_item_list(self):
return _TypeIdItemList(self.reader, self.header.type_ids_off,
self.header.type_ids_size)
@property
@functools.lru_cache
def proto_id_item_list(self):
return _ProtoIdItemList(self.reader, self.header.proto_ids_off,
self.header.proto_ids_size)
@property
@functools.lru_cache
def field_id_item_list(self):
return _FieldIdItemList(self.reader, self.header.field_ids_off,
self.header.field_ids_size)
@property
@functools.lru_cache
def method_id_item_list(self):
return _MethodIdItemList(self.reader, self.header.method_ids_off,
self.header.method_ids_size)
@property
@functools.lru_cache
def class_def_item_list(self):
return _ClassDefItemList(self.reader, self.header.class_defs_off,
self.header.class_defs_size)
@property
@functools.lru_cache
def type_list_item_list(self):
item = self.map_list.get(_TYPE_TYPE_LIST.value) or _DexMapItem(None)
return _TypeListItemList(self.reader, item.offset, item.size)
@property
@functools.lru_cache
def class_data_item_list(self):
item = self.map_list.get(_TYPE_CLASS_DATA_ITEM.value) or _DexMapItem(None)
return _ClassDataItemList(self.reader, item.offset, item.size)
@property
@functools.lru_cache
def code_item_list(self):
item = self.map_list.get(_TYPE_CODE_ITEM.value) or _DexMapItem(None)
return _CodeItemList(self.reader, item.offset, item.size)
@property
@functools.lru_cache
def _type_lists_by_offset(self):
return {
type_list.offset: type_list
for type_list in self.type_list_item_list
}
@property
@functools.lru_cache
def _class_data_item_by_offset(self):
return {
class_data_item.offset: class_data_item
for class_data_item in self.class_data_item_list
}
@property
@functools.lru_cache
def _code_item_by_offset(self):
return {code_item.offset: code_item for code_item in self.code_item_list}
def ComputeMapItemSizes(self):
"""Returns map item offsets and sizes.
Returns: A list of dicts containing offsets and sizes of each DEX map item
(i.e., DEX section). Fields:
* name: Simplified item type code name (FOO = TYPE_FOO_ITEM).
* offset: Byte offset of map item.
* size: Number of elements in map item.
* byte_size: Number of bytes spanned by map item, estimated by subtracting
element offsets (and file length for the last map item). Therefore this
also includes alignment paddings.
"""
map_items = self.map_list.GetMapItemsSortedByOffset()
n = len(map_items)
ret = []
for i in range(n):
end = self.size if i + 1 >= n else map_items[i + 1].offset
item = map_items[i]
ret.append({
'name': item.GetName(),
'offset': item.offset,
'size': item.size,
'byte_size': end - item.offset
})
return ret
def GetString(self, string_idx):
string_data_item = self.string_data_item_list[string_idx]
return string_data_item.data
def GetTypeString(self, type_idx):
type_id_item = self.type_id_item_list[type_idx]
return self.GetString(type_id_item.descriptor_idx)
def GetTypeListStringsByOffset(self, offset):
if not offset:
return ()
type_list = self._type_lists_by_offset[offset]
return tuple(self.GetTypeString(item.type_idx) for item in type_list)
def GetClassDataItemByOffset(self, offset):
return self._class_data_item_by_offset.get(offset)
def GetCodeItemByOffset(self, offset):
return self._code_item_by_offset.get(offset)
def IterAllStringIdsUsedByCodeItem(self, code_item):
if not code_item:
return
for bytecode in dalvik_bytecode.Split(code_item.insns):
if bytecode[0] in (0x1a, 0x1b):
# 1a 21c const-string vAA, string@BBBB
# 1b 31c const-string/jumbo vAA, string@BBBBBBBB
fmt = '<H' if bytecode[0] == 0x1a else '<L'
yield struct.unpack_from(fmt, bytecode, 2)[0]
@staticmethod
def ResolveClassAccessFlags(access_flags):
return tuple(flag_string
for flag, flag_string in _CLASS_ACCESS_FLAGS.items()
if flag & access_flags)
def IterMethodSignatureParts(self):
"""Yields the string components of DEX methods in a DEX file.
Yields:
Tuples that look like:
(class name, return type, method name, (parameter type, ...)).
"""
for method_id_item in self.method_id_item_list:
class_name = self.GetTypeString(method_id_item.type_idx)
method_name = self.GetString(method_id_item.name_idx)
proto_id_item = self.proto_id_item_list[method_id_item.proto_idx]
return_type_name = self.GetTypeString(proto_id_item.return_type_idx)
parameter_types = self.GetTypeListStringsByOffset(
proto_id_item.parameters_off)
yield (class_name, return_type_name, method_name, parameter_types)
def __repr__(self):
items = [
self.header,
self.map_list,
self.string_data_item_list,
self.type_id_item_list,
self.proto_id_item_list,
self.field_id_item_list,
self.method_id_item_list,
self.type_list_item_list,
self.class_def_item_list,
self.class_data_item_list,
self.code_item_list,
]
return '\n'.join(str(item) for item in items)
class _DumpCommand:
def __init__(self, dexfile):
self._dexfile = dexfile
@abc.abstractmethod
def Run(self):
pass
class _DumpSummary(_DumpCommand):
def Run(self):
print(self._dexfile)
class _DumpStrings(_DumpCommand):
def Run(self):
for (i, string_data_item) in enumerate(self._dexfile.string_data_item_list):
# Some strings are likely to be non-ascii (vs. methods/classes).
s = string_data_item.data
rep_str = (repr(s) if s.isprintable() else s.encode(
'utf-8', errors='surrogatepass'))
print('string(%08X): %s' % (i, rep_str))
class _DumpMap(_DumpCommand):
def Run(self):
for item_info in self._dexfile.ComputeMapItemSizes():
print(item_info)
class _DumpFields(_DumpCommand):
def Run(self):
dexfile = self._dexfile
for (i, field_id_item) in enumerate(dexfile.field_id_item_list):
class_name = dexfile.GetTypeString(field_id_item.class_idx)
type_name = dexfile.GetTypeString(field_id_item.type_idx)
name = dexfile.GetString(field_id_item.name_idx)
print('field(%08x): (class=%s, name=%s, type=%s)' %
(i, class_name, name, type_name))
class _DumpMethods(_DumpCommand):
def Run(self):
for (i, parts) in enumerate(self._dexfile.IterMethodSignatureParts()):
class_name, return_type_name, method_name, parameter_types = parts
print('method(%08x): (class=%s, name=%s, return_type=%s, params=%s)' %
(i, class_name, method_name, return_type_name, parameter_types))
class _DumpClasses(_DumpCommand):
def Run(self):
dexfile = self._dexfile
fmt = ('class(%08x): (name=%s, superclass=%s, interfaces=%s, ' +
'access_flags=%s)')
for (i, class_item) in enumerate(dexfile.class_def_item_list):
name = dexfile.GetTypeString(class_item.class_idx)
superclass_name = dexfile.GetTypeString(class_item.superclass_idx)
interfaces = dexfile.GetTypeListStringsByOffset(class_item.interfaces_off)
access_flags = DexFile.ResolveClassAccessFlags(class_item.access_flags)
print(fmt % (i, name, superclass_name, interfaces, access_flags))
class _DumpCodes(_DumpCommand):
def Run(self):
dexfile = self._dexfile
total_insns_bytes = 0
total_insns_count = 0
total_code_bytes = 0
total_tries_count = 0
insns_popu = [0] * 256
attrs = [
'registers_size', 'ins_size', 'outs_size', 'tries_size', 'insns_size'
]
for i, code_item in enumerate(dexfile.code_item_list):
total_insns_bytes += len(code_item.insns)
total_tries_count += code_item.tries_size
insns_count = 0
actual_insns_bytes = 0
for bytecode in dalvik_bytecode.Split(code_item.insns):
insns_popu[bytecode[0]] += 1
insns_count += 1
actual_insns_bytes += len(bytecode)
total_insns_count += insns_count
total_code_bytes += actual_insns_bytes
details = ', '.join('{}={}'.format(a, getattr(code_item, a))
for a in attrs if getattr(code_item, a) > 0)
print('code(%08x) o:%08X: (%s)' % (i, code_item.offset, details))
total_data_bytes = total_insns_bytes - total_code_bytes
print('\n*** Summary ***')
print('Code item count: %d' % len(dexfile.code_item_list))
print('Total instruction count: %d' % total_insns_count)
print('Total instruction bytes: %d' % total_insns_bytes)
print(' Code: %d' % total_code_bytes)
print(' Data: %d' % total_data_bytes)
print('Total tries count: %d' % total_tries_count)
print('Total tries bytes: %d' % (total_tries_count * (4 + 2 + 2)))
def _DumpDexItems(dexfile_data, name, item, is_eager):
dexfile = DexFile(data=bytearray(dexfile_data), is_eager=is_eager)
print('dex_parser: Dumping {} for {}'.format(item, name))
cmds = {
'summary': _DumpSummary,
'map': _DumpMap,
'strings': _DumpStrings,
'fields': _DumpFields,
'methods': _DumpMethods,
'classes': _DumpClasses,
'codes': _DumpCodes,
}
try:
cmds[item](dexfile).Run()
except IOError as e:
if e.errno == errno.EPIPE:
# Assume we're piping to "less", do nothing.
pass
def main():
parser = argparse.ArgumentParser(description='Dump DEX contents to stdout.')
parser.add_argument('input',
help='Input (.dex, .jar, .zip, .aab, .apk) file path.')
parser.add_argument('item',
choices=('summary', 'map', 'strings', 'fields', 'methods',
'classes', 'codes'),
help='Item to dump',
nargs='?',
default='summary')
parser.add_argument('--eager', action='store_true')
args = parser.parse_args()
if args.item == 'summary':
args.eager = True
if os.path.splitext(args.input)[1] in ('.apk', '.jar', '.zip', '.aab'):
with zipfile.ZipFile(args.input) as z:
dex_file_paths = [
f for f in z.namelist() if re.match(r'.*classes[0-9]*\.dex$', f)
]
if not dex_file_paths:
print('Error: {} does not contain any classes.dex files'.format(
args.input))
sys.exit(1)
for path in dex_file_paths:
_DumpDexItems(z.read(path), path, args.item, args.eager)
else:
with open(args.input, 'rb') as f:
_DumpDexItems(f.read(), args.input, args.item, args.eager)
if __name__ == '__main__':
main()
Codebase Browser
chromium