1. 关于Android dex文件

dex文件作为Android APK的组成部分，其主要是Android的Java代码经过编译生成class文件，再经过dx命令生成的。这里面包括了APK的源码，反编译时最主要就是对这个文件进行反编译。有人会问，知道了dex的文件结构有什么用呢？

在Android安全方面来说，dex是安全的重头戏，如果能够了解了dex文件的格式，那么对于dex文件的加固原理也就有简单的了解（关于加固应该不会写了）。

话不多说，写下dex文件解析过程吧！

2. dex文件格式

关于dex文件格式，官方的文件格式如下：

关于dex文件格式，可以分为三类：

• 头部信息 header
• 引用信息 string_ids（字符串索引）、type_ids（类型索引）、proto_ids（方法原型索引）、field_ids（方法原型索引）、method_ids（方法索引）、call_site_ids（根本没有找到）
• 数据信息 class_defs（类定义列表）、method_handles（方法句柄列表）、data（数据区，所有数据都在这里）、link_data（静态链接文件中使用的数据）

3. header信息

头部信息位于文件的头位置，用于表示文件的基本信息，比如文件大小、格式等等。dex文件的header格式如下：

可以看到文件格式非常之多，这可比之前解析的resources文件庞大的多了，我们先定义下对应的实体：

class header_item(
        var magic: Array<uint8_t>,
        var checksum: uint32_t, //文件剩余内容（除 magic 和此字段之外的所有内容）的 adler32 校验和；用于检测文件损坏情况
        var signature: ByteArray, //文件剩余内容（除 magic、checksum 和此字段之外的所有内容）的 SHA-1 签名（哈希）；用于对文件进行唯一标识
        var file_size: uint32_t, //    整个文件（包括标头）的大小，以字节为单位
        var header_size: uint32_t, //    标头（整个区段）的大小，以字节为单位。这一项允许至少一定程度的向后/向前兼容性，而不必让格式失效。
        var endian_tag: uint32_t, // ENDIAN_CONSTANT    字节序标记。更多详情，请参阅上文中“ENDIAN_CONSTANT 和 REVERSE_ENDIAN_CONSTANT”下的讨论。
        var link_size: uint32_t, //  链接区段的大小；如果此文件未进行静态链接，则该值为 0
        var link_off: uint32_t, //  从文件开头到链接区段的偏移量；如果 link_size == 0，则该值为 0。该偏移量（如果为非零值）应该是到 link_data 区段的偏移量。本文档尚未指定此处所指的数据格式；此标头字段（和之前的字段）会被保留为钩子，以供运行时实现使用。
        var map_off: uint32_t, //  从文件开头到映射项的偏移量。该偏移量（必须为非零）应该是到 data 区段的偏移量，而数据应采用下文中“map_list”指定的格式。
        var string_ids_size: uint32_t, //   字符串标识符列表中的字符串数量
        var string_ids_off: uint32_t, //   从文件开头到字符串标识符列表的偏移量；如果 string_ids_size == 0（不可否认是一种奇怪的极端情况），则该值为 0。该偏移量（如果为非零值）应该是到 string_ids 区段开头的偏移量。
        var type_ids_size: uint32_t, //  类型标识符列表中的元素数量，最多为 65535
        var type_ids_off: uint32_t, //  从文件开头到类型标识符列表的偏移量；如果 type_ids_size == 0（不可否认是一种奇怪的极端情况），则该值为 0。该偏移量（如果为非零值）应该是到 type_ids 区段开头的偏移量。
        var proto_ids_size: uint32_t, //    原型标识符列表中的元素数量，最多为 65535
        var proto_ids_off: uint32_t, //  从文件开头到原型标识符列表的偏移量；如果 proto_ids_size == 0（不可否认是一种奇怪的极端情况），则该值为 0。该偏移量（如果为非零值）应该是到 proto_ids 区段开头的偏移量。
        var field_ids_size: uint32_t, //   字段标识符列表中的元素数量
        var field_ids_off: uint32_t, //  从文件开头到字段标识符列表的偏移量；如果 field_ids_size == 0，则该值为 0。该偏移量（如果为非零值）应该是到 field_ids 区段开头的偏移量。
        var method_ids_size: uint32_t, //   方法标识符列表中的元素数量
        var method_ids_off: uint32_t, //   从文件开头到方法标识符列表的偏移量；如果 method_ids_size == 0，则该值为 0。该偏移量（如果为非零值）应该是到 method_ids 区段开头的偏移量。
        var class_defs_size: uint32_t, //   类定义列表中的元素数量
        var class_defs_off: uint32_t, //   从文件开头到类定义列表的偏移量；如果 class_defs_size == 0（不可否认是一种奇怪的极端情况），则该值为 0。该偏移量（如果为非零值）应该是到 class_defs 区段开头的偏移量。
        var data_size: uint32_t, // data 区段的大小（以字节为单位）。该数值必须是 sizeof(uint) 的偶数倍。
        var data_off: uint32_t //从文件开头到 data 区段开头的偏移量。
) : base_item() {
    override fun toString(): String {
        super.toString()
        val b = ByteArray(magic.size, { i -> magic[i].getValue() })
        val string = java.lang.String(b)
        return "magic = $string\n" +
                "checksum = ${getHexValue(checksum)},value = ${getUUnitValue(checksum)}\n" +
                "checksum = ${getHexValue(checksum)},value = ${getUUnitValue(checksum)}\n" +
                "file_size = ${getHexValue(file_size)},value = ${getUUnitValue(file_size)}\n" +
                "header_size = ${getHexValue(header_size)},value = ${getUUnitValue(header_size)}\n" +
                "endian_tag = ${getHexValue(endian_tag)},value = ${getUUnitValue(endian_tag)}\n" +
                "link_size = ${getHexValue(link_size)},value = ${getUUnitValue(link_size)}\n" +
                "link_off = ${getHexValue(link_off)},value = ${getUUnitValue(link_off)}\n" +
                "map_off = ${getHexValue(map_off)},value = ${getUUnitValue(map_off)}\n" +
                "string_ids_size = ${getHexValue(string_ids_size)},value = ${getUUnitValue(string_ids_size)}\n" +
                "string_ids_off = ${getHexValue(string_ids_off)},value = ${getUUnitValue(string_ids_off)}\n" +
                "type_ids_size = ${getHexValue(type_ids_size)},value = ${getUUnitValue(type_ids_size)}\n" +
                "type_ids_off = ${getHexValue(type_ids_off)},value = ${getUUnitValue(type_ids_off)}\n" +
                "proto_ids_size = ${getHexValue(proto_ids_size)},value = ${getUUnitValue(proto_ids_size)}\n" +
                "proto_ids_off = ${getHexValue(proto_ids_off)},value = ${getUUnitValue(proto_ids_off)}\n" +
                "field_ids_size = ${getHexValue(field_ids_size)},value = ${getUUnitValue(field_ids_size)}\n" +
                "field_ids_off = ${getHexValue(field_ids_off)},value = ${getUUnitValue(field_ids_off)}\n" +
                "method_ids_size = ${getHexValue(method_ids_size)},value = ${getUUnitValue(method_ids_size)}\n" +
                "method_ids_off = ${getHexValue(method_ids_off)},value = ${getUUnitValue(method_ids_off)}\n" +
                "class_defs_size = ${getHexValue(class_defs_size)},value = ${getUUnitValue(class_defs_size)}\n" +
                "class_defs_off = ${getHexValue(class_defs_off)},value = ${getUUnitValue(class_defs_off)}\n" +
                "data_size = ${getHexValue(data_size)},value = ${getUUnitValue(data_size)}\n" +
                "data_off = ${getHexValue(data_off)},value = ${getUUnitValue(data_off)}\n"
    }
}

接着我们先解析一波，这里要清楚下源码中都是采用的小端顺序（自行百度）：

val stream = File(File("").absolutePath + "//..//dexAnalyzer//src//com//nick//classes.dex").inputStream()
    val os = ByteArrayOutputStream()
    var bytes = ByteArray(1024)
    var len = stream.read(bytes)
    while (len != -1) {
        os.write(bytes, 0, len)
        len = stream.read(bytes)
    }
    // 将文件转成二进制字节数组操作
    bytes = os.toByteArray()
    // 创建header_item
    val header_item = header_item(
            Array(8, { i -> read_uint8_t(bytes, i) }), // 1
            read_uint32_t(bytes, 8), // 4
            kotlin.ByteArray(20, { // 20
                b ->
                bytes[b + 12]
            }),
            read_uint32_t(bytes, 32), // 4
            read_uint32_t(bytes, 32 + 4), // 4
            read_uint32_t(bytes, 32 + 4 * 2), // 4
            read_uint32_t(bytes, 32 + 4 * 3), // 4
            read_uint32_t(bytes, 32 + 4 * 4), // 4
            read_uint32_t(bytes, 32 + 4 * 5), // 4
            read_uint32_t(bytes, 32 + 4 * 6), // 4
            read_uint32_t(bytes, 32 + 4 * 7), // 4
            read_uint32_t(bytes, 32 + 4 * 8), // 4
            read_uint32_t(bytes, 32 + 4 * 9), // 4
            read_uint32_t(bytes, 32 + 4 * 10), // 4
            read_uint32_t(bytes, 32 + 4 * 11), // 4
            read_uint32_t(bytes, 32 + 4 * 12), // 4
            read_uint32_t(bytes, 32 + 4 * 13), // 4
            read_uint32_t(bytes, 32 + 4 * 14), // 4
            read_uint32_t(bytes, 32 + 4 * 15), // 4
            read_uint32_t(bytes, 32 + 4 * 16), // 4
            read_uint32_t(bytes, 32 + 4 * 17), // 4
            read_uint32_t(bytes, 32 + 4 * 18), // 4
            read_uint32_t(bytes, 32 + 4 * 19) // 4
    )
    println(header_item)

这里说明下read_uint32_t()方法是用于读取四个字节的byte，并将其转为uint32_t格式，其实也就是int。看下打印结果：

头部信息结果

二进制文件

4 string_ids信息

上面看完了头部的信息，下面看下很重要的一部分信息string_ids信息，还是先看下格式：

string_id_item

string_data_item

这里又有问题了：

1. uleb128格式如何获取？
   从Android源码中获取

    /**
     * Gets the number of bytes in the unsigned LEB128 encoding of the
     * given value.
     *
     * @param value the value in question
     * @return its write size, in bytes
     */
    public static int unsignedLeb128Size(int value) {
        // TODO: This could be much cleverer.

        int remaining = value >> 7;
        int count = 0;

        while (remaining != 0) {
            remaining >>= 7;
            count++;
        }

        return count + 1;
    }

    /**
     * Gets the number of bytes in the signed LEB128 encoding of the
     * given value.
     *
     * @param value the value in question
     * @return its write size, in bytes
     */
    public static int signedLeb128Size(int value) {
        // TODO: This could be much cleverer.

        int remaining = value >> 7;
        int count = 0;
        boolean hasMore = true;
        int end = ((value & Integer.MIN_VALUE) == 0) ? 0 : -1;

        while (hasMore) {
            hasMore = (remaining != end)
                || ((remaining & 1) != ((value >> 6) & 1));

            value = remaining;
            remaining >>= 7;
            count++;
        }

        return count;
    }

2. MUTF-8又是怎样的？
   可以看下这篇博客，解释的很清楚。

格式分析完了，下面来解析吧：

    // 偏移量
    var offset = header_item.header_size.getValue()
    // 字符串偏移量的数组
    string_ids = Array(header_item.string_ids_size.getValue(), {
        i ->
        string_id_item(read_uint32_t(bytes, offset + i * 4))
    })

    // 字符串数组数组
    string_ids?.forEach {
        val value = it.string_data_off.getValue()
        val unsignedLeb128 = readUnsignedLeb128(bytes, value)

        val string_data_item = string_data_item(it.string_data_off, uleb128(unsignedLeb128.second), coypByte(bytes, unsignedLeb128.first, unsignedLeb128.second))
        list.add(string_data_item)
        println(string_data_item)
    }

部分结果如下：

截取部分

5 已解析部分

header
string_ids
type_ids
proto_ids
field_ids
method_ids
class_defs

6 未解析部分

call_site_ids
method_handles
link_data
源码就在这里

7 总结

解析这个dex文件大概花了一个星期的时间，从Android官网看文档、查资料。一点点从零到大部分解析完成，感觉还是挺有趣的。