apktool

#!/usr/bin/env python
# -*- mode: python; coding: utf-8 -*-

import os
import sys
import glob
import zipfile
import functools

# fix sys path to include our lib
DIR_PATH = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
sys.path.insert(0, DIR_PATH)

from atool.apk import sysresource
from atool.apk.axml import AXMLParser
from atool.apk.axml import ResourceParser
from atool.apk.axml import ResObject

TOOL_NAME = 'apktool'
COMMANDS = ['dumpapk', 'dumpxml', 'cat', 'resolve', 'resolve_string', 'catr', 'dump_dex', 'dex_sum', 'get_icon']

usage = '''usage: apktool <command> [args]
Type 'apktool <command> -h' for help of specific command.

Available commands:
   dumpxml         dump android binary xml
   dumpapk         dump all xml files in given apk file to current directory
   cat             dump specified xml from given apk file
   catr            dump R.java
   resolve         resolve resource name of given numeric id
   resolve_string  resolve value of given string id
   dump_dex        dump class name from dex file
'''

def get_cmd_path(cmd):
    '''Get absolute path of given command with PATH environment'''
    if cmd == "":
        return None
    path = os.environ.get("PATH")
    if path == None:
        path = os.environ.get("path")
    if path == None:
        return None
    for p in path.split(':'):
        f = p + "/" + cmd
        if os.access(f, os.X_OK):
            return f
    return None

def cmp_version(v1, v2):
    if v1 == v2:
        return 0
    a1 = v1.split(".")
    a2 = v2.split(".")
    while a1 or a2:
        if not a1:
            return -1
        if not a2:
            return 1
        c1 = a1.pop(0)
        c2 = a2.pop(0)
        if c1.isdigit() and c2.isdigit():
            tmp1 = int(c1)
            tmp2 = int(c2)
            return (tmp1 > tmp2) - (tmp1 < tmp2)
        else:
            return (c1 > c2) - (c1 < c2)

def get_android_jar(sdk_dir):
    '''Get android system resource file (android.jar)'''
    if not (os.path.isdir(sdk_dir + "/platforms")
            and os.path.isfile(sdk_dir + "/tools/android")):
        return None
    prefix = sdk_dir + "/platforms/android-"
    i = len(prefix)
    platforms = glob.glob(prefix + "*")
    if not platforms:
        return None
    vs = [item[i:] for item in platforms]
    vs.sort(key=functools.cmp_to_key(cmp_version))
    jar = prefix + vs[-1] + "/android.jar"
    if os.path.isfile(jar):
        return jar
    else:
        return None

def get_android_resource():
    android = get_cmd_path("android")
    if android:
        android = os.path.realpath(android)
    jar = None
    if android:
        sdk_dir = os.path.dirname(os.path.dirname(android))
        jar = get_android_jar(sdk_dir)
    if jar == None:
        sdk_dir = os.environ.get("ANDROID_HOME")
        if sdk_dir:
            jar = get_android_jar(sdk_dir)
    return jar

def dump_xml(cmd, argv):
    usage = 'usage: %s %s <binary-xml> [<resources.arsc-or-.apk>]' % (TOOL_NAME, cmd)
    detail = '''
  Dump given xml file to stdout.

  If resources file (typically resources.arsc extracted from the
  same apk file) not specified, most xml attributes will be dumped
  as numeric value.

  System resources will be auto loaded (android sdk directory is
  resolved by path of command 'android', then try environment
  variable 'ANDROID_HOME'). If system resources can not be found,
  most xml attributes will be dumped as numeric value.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)

    if len(argv) < 1 or len(argv) > 2:
        print(usage, file=sys.stderr)
        sys.exit(1)
    restable = ResObject()
    androidjar = get_android_resource()
    if androidjar:
        res = get_archived_resource(androidjar)
        if res:
            restable.update(res)

    if len(argv) > 1:
        try:
            infile = open(argv[1], "rb")
            indata = infile.read()
            infile.close()
            if len(indata) > 4 and indata[0:4] == '\x50\x4b\x03\x04':
                res = get_archived_resource(argv[1])
                if res:
                    restable.update(res)
            else:
                parser = ResourceParser(indata)
                res = parser.parse_resources()
                if res:
                    restable.update(res)
        except Exception as e:
            print("failed to process resource: ", e, file=sys.stderr)

    infile = open(argv[0], "rb")
    indata = infile.read()
    infile.close()
    parser = AXMLParser(indata)
    parser.set_restable(restable)
    (xml, ns) = parser.parsexml()
    xml.dump(sys.stdout, ns)

def get_archived_resource(archive):
    zfile = None
    try:
        try:
            zfile = zipfile.ZipFile(archive, "r")
        except Exception as e1:
            print("failed to open zip archive:", archive, e1, file=sys.stderr)
            return None
        data = zfile.read("resources.arsc")
        zfile.close()
        zfile = None
        parser = ResourceParser(data)
        return parser.parse_resources()
    except Exception as e:
        if zfile:
            zfile.close()
        print("failed to process resources.arsc:", e, file=sys.stderr)
    return None

def make_res_id(pkgid, typeid, entryid):
    return ((0xff000000 & (pkgid << 24)) |
            (0x00ff0000 & ((typeid) << 16)) |
            (0x0000ffff & (entryid)) )

def dump_r(pkg, outfile=sys.stdout):
    print("package %s\n" % (pkg.name), file=outfile)
    print("public final class R {", file=outfile)
    for tname in sorted(pkg.name_map.keys()):
        t = pkg.name_map[tname]
        print("    public static final class %s {" % (t.name), file=outfile)
        for k in sorted(t.id_map.keys()):
            e = t.id_map[k]
            eid = make_res_id(pkg.id, t.id, e.id)
            print("        public static final int %s = 0x%08x;  // %d" % (e.name, eid, eid), file=outfile)
        print("    }\n", file=outfile)
    print("}", file=outfile)

def cat_r(cmd, argv):
    usage = 'usage: %s %s <resources.arsc-or-.apk>' % (TOOL_NAME, cmd)
    detail = '''
  Dump R.java to stdout.

  resources file or apk file must specified.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)

    if len(argv) != 1:
        print(usage, file=sys.stderr)
        sys.exit(1)

    res = None
    try:
        infile = open(argv[0], "rb")
        indata = infile.read()
        infile.close()
        if len(indata) > 4 and indata[0:4] == '\x50\x4b\x03\x04':
            res = get_archived_resource(argv[1])
        else:
            parser = ResourceParser(indata)
            res = parser.parse_resources()
        if res == None or len(res.id_map) < 1:
            print("no package in restable", file=std.err)
            return
        if len(res.id_map) != 1:
            print("multiple package in restable", file=std.err)
            return
        ids = list(res.id_map.keys())
        pkg = res.id_map[ids[0]]
        dump_r(pkg)
    except Exception as e:
        print("failed to process resource: ", e, file=sys.stderr)
        sys.exit(1)
    
def dump_apk(cmd, argv):
    usage = 'usage: %s %s <file.apk>' % (TOOL_NAME, cmd)
    detail = '''
  Dump all xml files in given apk file into current directory.

  System resources will be auto loaded (android sdk directory is
  resolved by path of command 'android', then try environment
  variable 'ANDROID_HOME'). If system resources can not be found,
  most xml attributes will be dumped as numeric value.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)

    if len(argv) != 1:
        print(usage, file=sys.stderr)
        sys.exit(1)
    apkfile = argv[0]
    restable = ResObject()
    androidjar = get_android_resource()
    if androidjar:
        # print >> sys.stderr, androidjar
        res = get_archived_resource(androidjar)
        if res:
            restable.update(res)
    infile = open(apkfile, "rb")
    indata = infile.read(4)
    infile.close()
    if len(indata) < 4 or indata[0:4] != "\x50\x4b\x03\x04":
        print("not a apk file: %s" % (apkfile), file=sys.stderr)
        sys.exit(1)
    res = get_archived_resource(apkfile)
    if res:
        restable.update(res)
    zfile = zipfile.ZipFile(apkfile, "r")
    zfile.getinfo("resources.arsc")
    flist = zfile.namelist()
    for fname in flist:
        if not fname.endswith(".xml"):
            continue
        # if not (fname == 'AndroidManifest.xml' or fname.startswith("res/")):
        #     continue
        data = zfile.read(fname)
        fname = fname.lstrip("/")
        print("processing", fname)
        try:
            parser = AXMLParser(data)
            parser.set_restable(restable)
            (xml, ns) = parser.parsexml()
            dirname = os.path.dirname(fname)
            if dirname and not os.path.exists(dirname):
                os.makedirs(dirname, 0o755)
            outfile = open(fname, "wb")
            xml.dump(outfile, ns)
            outfile.close()
        except Exception as e:
            print("  Error:", e, file=sys.stderr)
    zfile.close()


def cat_xml(cmd, argv):
    usage = 'usage: %s %s <file.apk> [<name.xml>]' % (TOOL_NAME, cmd)
    detail = '''
  Dump specified xml file from given apk file, default to AndroidManifest.xml.

  System resources will be auto loaded (android sdk directory is
  resolved by path of command 'android', then try environment
  variable 'ANDROID_HOME'). If system resources can not be found,
  most xml attributes will be dumped as numeric value.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)

    if len(argv) < 1 or len(argv) > 2:
        print(usage, file=sys.stderr)
        sys.exit(1)
    apkfile = argv[0]
    zfile = zipfile.ZipFile(apkfile, "r")
    if len(argv) > 1:
        xmlfile = argv[1]
    else:
        xmlfile = 'AndroidManifest.xml'
    data = zfile.read(xmlfile)
    zfile.close()
    if not data:
        sys.exit(0)
    restable = ResObject()
    #androidjar = None
    androidjar = get_android_resource()
    if androidjar:
        res = get_archived_resource(androidjar)
        if res:
            restable.update(res)
    res = get_archived_resource(apkfile)
    if res:
        restable.update(res)
    parser = AXMLParser(data)
    parser.set_restable(restable)
    (xml, ns) = parser.parsexml()
    xml.dump(sys.stdout, ns)


def get_icon(cmd, argv):
    usage = 'usage: %s %s <file.apk>' % (TOOL_NAME, cmd)
    detail = '''
  get icon file name from given apk file.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)

    if len(argv) != 1:
        print(usage, file=sys.stderr)
        sys.exit(1)
    apkfile = argv[0]
    zfile = zipfile.ZipFile(apkfile, "r")
    xmlfile = 'AndroidManifest.xml'
    data = zfile.read(xmlfile)
    zfile.close()
    if not data:
        sys.exit(0)
    restable = get_archived_resource(apkfile)
    parser = AXMLParser(data)
    parser.set_restable(restable)
    (xml, ns) = parser.parsexml()
    app_node = None
    for c in xml.children:
        if c.name == 'application':
            app_node = c
            break
    if not app_node:
        raise ValidationError("invalid apk, can not find 'application' in manifest")
    name_attr = None
    icon_attr = None
    for attr in app_node.attributes:
        if attr.name == 'android:label':
            name_attr = attr
        elif attr.name == 'android:icon':
            icon_attr = attr
    if icon_attr:
        s = restable.get_entry_value(icon_attr.entry)
        if s == None:
            s = '?'
        print("%s=%s, file: %s" % (icon_attr.name, icon_attr.value, s))
    else:
        print("icon file can not found")


def resolve_name(cmd, argv):
    usage = 'usage: %s %s <numeric_id> [<apk_or_arsc>]' % (TOOL_NAME, cmd)
    detail = '''
  Resolve resource name of given id.

  System resources will be auto loaded, optional apk file or resource file
  will also be searched.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)

    if len(argv) < 1 or len(argv) > 2:
        print(usage, file=sys.stderr)
        sys.exit(1)
    idstr = argv[0]
    radix = 10
    if idstr.startswith("0x") or idstr.startswith("0X"):
        radix = 16
    rid = 0
    try:
        rid = int(idstr, radix)
    except:
        print("invalid id, not a number: ", idstr, file=sys.stderr)
        sys.exit(1)
    if rid <= 0 or rid >= 0xffffffff:
        print("invalid id: ", idstr, file=sys.stderr)
        sys.exit(1)

    restable = ResObject()
    androidjar = get_android_resource()
    if androidjar:
        res = get_archived_resource(androidjar)
        if res:
            restable.update(res)
    if len(argv) > 1:
        try:
            infile = open(argv[1], "rb")
            indata = infile.read()
            infile.close()
            if len(indata) > 4 and indata[0:4] == "\x50\x4b\x03\x04":
                m = get_archived_resource(argv[1])
            else:
                parser = ResourceParser(indata)
                m = parser.parse_resources()
            restable.update(m)
        except Exception as e:
            print("failed to process resource: ", e, file=sys.stderr)

    parser = ResourceParser("")
    parser.set_restable(restable)
    result = parser.dereference_resource(rid)
    if result == None:
        print("can not resolve given id: 0x%08x" % (rid), file=sys.stderr)
        sys.exit(1)
    print("0x%08x %s %s %s" % (rid, result[0], result[1], result[2]))

def resolve_string(cmd, argv):
    usage = 'usage: %s %s <apk_or_arsc> <string_name>' % (TOOL_NAME, cmd)
    detail = '''
  Resolve value of given string name.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)
    if len(argv) != 2:
        print(usage, file=sys.stderr)
        sys.exit(1)
    string_name = argv[1]
    res_file = argv[0]
    try:
        infile = open(res_file, "rb")
        indata = infile.read()
        infile.close()
        if len(indata) > 4 and indata[0:4] == "\x50\x4b\x03\x04":
            zfile = None
            indata = None
            try:
                zfile = zipfile.ZipFile(res_file, 'r')
                indata = zfile.read('resources.arsc')
                zfile.close()
                zfile = None
            except Exception as e1:
                print("failed to process resource: ", e1, file=sys.stderr)
                return None
        if indata:
            parser = ResourceParser(indata)
            restable = parser.parse_resources()
            if not restable.name_map:
                return None
            package = list(restable.name_map.values())[0]
            parser.set_restable(restable)
            print(parser.resolve_string(package.name, string_name))
    except Exception as e:
        print("failed to process resource: ", e, file=sys.stderr)
        return None

def dump_dex(cmd, argv):
    usage = 'usage: %s %s  <.dex-or-.apk>' % (TOOL_NAME, cmd)
    detail = '''
  Dump class names to stdout.

  dex file or apk file must specified.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)
    if len(argv) != 1:
        print(usage, file=sys.stderr)
        sys.exit(1)
    fname = argv[0]
    try:
        from atool.apk import dex
        infile = open(fname, "rb")
        indata = infile.read()
        infile.close()
        data = None
        if len(indata) > 4 and indata[0:4] == '\x50\x4b\x03\x04':
            zfile = zipfile.ZipFile(fname, "r")
            flist = zfile.namelist()
            for fname in flist:
                if not fname.endswith(".dex"):
                    continue
                data = zfile.read(fname)
                (field_ids_size, method_ids_size, class_defs_size) = dex.parsedex(data, True)
                print("--", fname, "--")
                print("  field_size:  %5d" % (field_ids_size))
                print("  method_size: %5d" % (method_ids_size))
                print("  classs_size: %5d" % (class_defs_size))
            zfile.close()
        elif len(indata) > 8 and data[0:8] == 'dex\n0350x00':
            data = indata
            print("field_size:  %5d" % (field_ids_size))
            print("method_size: %5d" % (method_ids_size))
            print("classs_size: %5d" % (class_defs_size))
        else:
            print("input file is not dex or apk file", file=sys.stderr)
            sys.exit(1)
        if not data:
            print("can not read dex data", file=sys.stderr)
            sys.exit(1)
    except Exception as e:
        print("failed to dump class: ", e, file=sys.stderr)
        sys.exit(1)

def dex_sum(cmd, argv):
    usage = 'usage: %s %s <.dex-or-.apk>' % (TOOL_NAME, cmd)
    detail = '''
  Dump dex summary stdout.

  dex file or apk file must specified.
'''
    if len(argv) > 0 and argv[0] in ['-h', '--help']:
        print(usage)
        print(detail)
        sys.exit(0)
    if len(argv) != 1:
        print(usage, file=sys.stderr)
        sys.exit(1)
    fname = argv[0]
    try:
        infile = open(fname, "rb")
        indata = infile.read()
        infile.close()
        data = None
        if len(indata) > 4 and indata[0:4] == '\x50\x4b\x03\x04':
            zfile = zipfile.ZipFile(fname, "r")
            data = zfile.read("classes.dex")
            zfile.close()
        elif len(indata) > 8 and indata[0:8] == 'dex\n035\x00':
            data = indata
        else:
            print("input file is not dex or apk file", file=sys.stderr)
            sys.exit(1)
        if not data:
            print("can not read dex data", file=sys.stderr)
            sys.exit(1)
        if len(data) < 0x70:
            error("incomplete header with size %d (min %d)" % (len(data), 0x70))
        if data[0:8] != 'dex\n035\x00':
            error("dex magic unmatch")
        from struct import unpack
        off = 56
        (str_ids_size, str_ids_off, type_ids_size, type_ids_off) = unpack('<IIII', data[off:off+16])
        off = 72
        (proto_ids_size, proto_ids_off, field_ids_size, field_ids_off) = unpack('<IIII', data[off:off+16])
        off = 88
        (method_ids_size, method_ids_off) = unpack('<II', data[off:off+8])
        off = 96
        (class_defs_size, class_defs_off) = unpack('<II', data[off:off+8])
        off = 104
        (data_size, data_off) = unpack('<II', data[off:off+8])
        va = (
            ('str_ids_size', str_ids_size),
            ('str_ids_off', str_ids_off),
            ('type_ids_size', type_ids_size),
            ('type_ids_off', type_ids_off),
            ('proto_ids_size', proto_ids_size),
            ('proto_ids_off', proto_ids_off),
            ('field_ids_size', field_ids_size),
            ('field_ids_off', field_ids_off),
            ('method_ids_size', method_ids_size),
            ('method_ids_off', method_ids_off),
            ('class_defs_size', class_defs_size),
            ('class_defs_off', class_defs_off),
            ('data_size', data_size),
            ('data_off', data_off)
        )
        for (k, v) in va:
            if k.endswith('_off'):
                print('%s\t : %d (0x%06x)' % (k, v, v))
            else:
                print('%s\t : %d' % (k, v))

    except Exception as e:
        print("failed to dump class: ", e, file=sys.stderr)
        sys.exit(1)

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("no command specified, type 'apktool help' for usage.", file=sys.stderr)
        sys.exit(1)

    command = sys.argv[1]
    argv = sys.argv[2:]

    if command in ['-h', '-help', '--help', 'help']:
        print(usage, end=' ')
        sys.exit(0)

    if command not in COMMANDS:
        print("apktool: unknown command '%s'. See 'apktool help'." % (command), file=sys.stderr)
    elif command == 'dumpxml':
        dump_xml(command, argv)
    elif command == 'dumpapk':
        dump_apk(command, argv)
    elif command == 'resolve':
        resolve_name(command, argv)
    elif command == 'resolve_string':
        resolve_string(command, argv)
    elif command == 'cat':
        cat_xml(command, argv)
    elif command == 'catr':
        cat_r(command, argv)
    elif command == 'dump_dex':
        dump_dex(command, argv)
    elif command == 'dex_sum':
        dex_sum(command, argv)
    elif command == 'get_icon':
        get_icon(command, argv)