ANDROID 逆向实例（六）－ 梆梆加固（2015.08）

还是从网上找到的样本，拿来做加固分析的例子。

可以看到，加固之后多了两个 .so 文件、一个 com.edog 的 smali 文件夹，My.XuanAo.LiuYao 这个目录是本身 apk 的代码结构，所以猜测加固全是在 com.edog 和 .so 文件里做的。

看下 AndroidManifest.xml。

可以看到原 apk 的 activity 没变，还是 .main，但是 application 变成新增的 com.edog.AppWrapper，因为 application 会在 activity 之前加载，所以判断加固正是在这里做的。

看下 smali，这里比较简单，不做过多的展开，直接跳到关键的内容。

可以看到这里在 libedog.so 里定义了一个 native 函数 d1，然后在 Utils.smali 调用了这个函数，IDA 动态调试跟进看一下。

在加载 libedog.so 的时候下断电，可以看到右侧的的 Java_com_edog_Elibrary_d1 函数，并且这个 .so 加载之后没有 .init(_array) 和 JNI_Onload 段，所以该函数就是之前定义的 native d1。

F5。

可以看到 d1 的大体结构，还算比较简单，具体的每个函数的功能不详细分析了，有反调试的，有解密的，等等。比较关键的是 restore 这个函数。

“dvmResolveClass”，看到这个可以明确使用的是 Dex 的类抽取做加固，通过动态地替换 DexCode 里的内容（见 Android 逆向学习笔记 （八）－ Classes.dex 结构简单介绍）打到加固的目的。

如果这种加固在还原正确的 DexCode 之后没有擦出 insns 的话，可以使用 Qever 提供的一个小脚本来脱壳。

__author__ = 'QEver'

DUMP_FILE_PREFIX = r'd:/'
USER_DEX_FILES_OFFSET = 0x334
LOADED_CLASSES_OFFSET = 0xAC
JAR_NAME_OFFSET = 0x24
SIZE_OF_DEY_HEADER = 0x28
DESC_OFFSET_OF_CLASS_OBJECT = 0x18
METHOD_OFFSET_OF_CLASS_OBJECT = 0x60
SIZE_OF_STRUCT_METHOD = 0x38

import os
import idaapi
import binascii


def read_data(ea, size):
    return idaapi.dbg_read_memory(ea, size)


def read_dword(ea):
    val = int(binascii.hexlify(idaapi.dbg_read_memory(ea, 4)), 16)
    r = (val & 0xff) << 24 | (val & 0xff00) << 8 | (val & 0xff0000) >> 8 | (val & 0xff000000) >> 24
    return r


def read_bool(ea):
    val = int(binascii.hexlify(idaapi.dbg_read_memory(ea, 1)), 16)
    return val


def read_str(ea, max=256):
    c = ''
    while True:
        x = idaapi.dbg_read_memory(ea, 1)
        ea = ea + 1
        max = max - 1
        if x == '\0' or max < 0:
            break
        c += x
    return c


class DvmDex:
    def __init__(self, ea):
        self.ea = ea
        self.pDexFile = read_dword(ea)
        self.baseAddr = read_dword(self.pDexFile + 0x2c)

    def p(self):
        print 'pDexFile = %x' % self.pDexFile
        print 'baseAddr = %x' % self.baseAddr


class ClassObject:
    def __init__(self, ea):
        self.ea = ea
        self.desc_addr = read_dword(ea + DESC_OFFSET_OF_CLASS_OBJECT)

    def get_descriptor(self):
        return read_str(self.desc_addr)


class DexOrJar:
    def __init__(self, ea):
        self.ea = ea
        self.filename = read_dword(ea)
        self.isDex = read_bool(ea + 4)
        self.pRawDexFile = read_dword(ea + 8)
        self.pJarFile = read_dword(ea + 12)

    def get_filename(self):
        if self.isDex == 0:
            return read_str(read_dword(self.pJarFile + JAR_NAME_OFFSET))
        return read_str(self.filename)

    def get_dvmdex(self):
        if self.isDex == 0:
            return read_dword(self.pJarFile + JAR_NAME_OFFSET + 4)
        return read_dword(self.pRawDexFile + 4)

    def p(self):
        print 'filename = %s' % read_str(self.filename)
        print 'isDex = %d' % self.isDex
        print 'pRawDexFile = %x' % self.pRawDexFile
        print 'pJarFile = %x' % self.pJarFile


class HashTable:
    def __init__(self, ea):
        self.ea = ea
        self.tableSize = -1
        self.numEntries = -1
        self.pEntries = None
        self.do_init()

    def do_init(self):
        self.tableSize = read_dword(self.ea)
        self.numEntries = read_dword(self.ea + 4)
        self.pEntries = read_dword(self.ea + 12)

    def get_table_size(self):
        return self.tableSize

    def get_num_entries(self):
        return self.numEntries

    def get_pentries(self):
        return self.pEntries

    def p(self):
        print 'tableSize = %d' % self.tableSize
        print 'numEntries = %d' % self.numEntries
        print 'pEntries = %x' % self.pEntries


class Method:
    def __init__(self, ea):
        self.ea = ea

    def get_name(self):
        addr = self.ea + 0x10
        return read_str(read_dword(addr))

    def get_insns(self):
        addr = self.ea + 0x20
        return read_dword(addr)

    def get_address(self):
        return self.ea


def get_gdvm_address():
    return idaapi.get_debug_name_ea("gDvm")


def dump_all_dex(prefix=DUMP_FILE_PREFIX):
    gdvm = get_gdvm_address()
    print '[*] gDvm = 0x%x' % gdvm
    user_dex_files = read_dword(gdvm + USER_DEX_FILES_OFFSET)
    print '[*] gDvm.user_dex_files = 0x%x' % user_dex_files

    ht = HashTable(user_dex_files)

    max_size = ht.get_table_size()
    size = ht.get_num_entries()
    p = ht.get_pentries()
    print '[*] Found %s items in Dex Table' % size
    for i in range(max_size):
        x = read_dword(p)

        p += 8
        if x == 0:
            continue
        doj = DexOrJar(x)
        print '[*] Dex in Address 0x%x, isDex = %d' % (x, doj.isDex)
        addr = doj.get_dvmdex()
        name = doj.get_filename()
        print '[*] found file : %s , dvmdex = 0x%x' % (name, addr)

        dd = DvmDex(addr)
        addr = dd.baseAddr
        base = addr - SIZE_OF_DEY_HEADER
        size = read_dword(addr + 0x20) + SIZE_OF_DEY_HEADER
        flag = read_str(base, 3)
        if flag != 'dey':
            base = addr
            size = size = read_dword(addr + 0x20)

        print '[*] found odex file = 0x%x <%s>, size = 0x%x' % (base, read_str(base, 7).replace('\n', '.'), size)

        name = os.path.basename(name)
        path = os.path.join(prefix, name)

        print '[*] Write to %s' % path
        data = read_data(base, size)

        f = open(path, 'wb')
        f.write(data)
        f.close()
        print '[*] Finish Write'


def find_class(name):
    gDvm = get_gdvm_address()
    loaded_classes = read_dword(gDvm + LOADED_CLASSES_OFFSET)

    ht = HashTable(loaded_classes)
    max_size = ht.get_table_size()
    size = ht.get_num_entries()
    p = ht.get_pentries() + 4
    print 'Finding for %d items, may take a long time...' % max_size
    for i in range(max_size):
        x = read_dword(p)
        p = p + 8
        if x == 0:
            continue
        c = ClassObject(x)
        s = c.get_descriptor()
        if s == name:
            print '[*] Found Class <%s> : 0x%x' % (name, x)
            return x
        if s.find(name) != -1:
            print '[*] Found Class <%s> : 0x%x' % (s, x)


def list_method(class_addr):
    x = ClassObject(class_addr)
    print '[*] List All Method of %s' % x.get_descriptor()
    m = class_addr + METHOD_OFFSET_OF_CLASS_OBJECT
    directMethodCount = read_dword(m)
    directMethodTable = read_dword(m + 4)
    virtualMethodCount = read_dword(m + 8)
    virtualMethodTable = read_dword(m + 12)

    for i in range(directMethodCount):
        method = Method(directMethodTable)
        directMethodTable = directMethodTable + SIZE_OF_STRUCT_METHOD
        print method.get_name(), hex(method.get_address())

    for i in range(virtualMethodCount):
        method = Method(virtualMethodTable)
        virtualMethodTable = virtualMethodTable + SIZE_OF_STRUCT_METHOD
        print method.get_name()


def list_all_class():
    gDvm = get_gdvm_address()
    loaded_classes = read_dword(gDvm + LOADED_CLASSES_OFFSET)

    ht = HashTable(loaded_classes)
    max_size = ht.get_table_size()
    size = ht.get_num_entries()
    p = ht.get_pentries() + 4
    for i in range(max_size):
        x = read_dword(p)
        p = p + 8
        if x == 0:
            continue
        c = ClassObject(x)
        print c.get_descriptor()

if __name__ == '__main__':
    #list_all_class()
    #find_class('alibaba')
    #list_method(class_addr) 
    dump_all_dex('c:/test/')

使用这个脚本有一个需要注意的问题，这里是通过对应的 gDvm.userDexFile 来找到不同方法的 DexCode，所以使用不同型号、版本的测试机时 USER_DEX_FILES_OFFSET 需要做对应修改。

另外，也可以使用 find_class 来实现查找对应 Method 的 DexCode。

使用 QEver 的脚本脱壳具有一定的局限性，如果 Method 调用之后擦除 insns 那么就没法使用该脚本，不过可以通过 DexHunter 脱壳，他们的原理类似，只不过 DexHunter 增加了动态脱壳时机的判断。

其实，每一种脱壳都有 easy way and hard way，上面说的都是 easy way，hard way 则是通过理解 dvmResolveClass 的实现方式，通过对应的解密方式来还原。这种方式不在此讨论，详细脱壳方法可以在下面参考链接中看到。

Reference

* gDvm.userDexFile 偏移的获取

* QEver： 一个dex脱壳脚本
* APK加固之类抽取分析与修复

Android 逆向学习笔记 （八）－ Classes.dex 结构简单介绍

Classes.dex 作为安卓 Dalvik 虚拟机的可执行文件有很多神奇的特性，部分特性也常被用来做加固方法，所以学习安卓逆向时，了解 Classes.dex 是很有必要的。

首先先来看一下 Classes.dex 的文件结构，如下图所示：

大概是这么样的一个结构，主要分成了七个部分：

Dex Header              # Dex 文件头部，记录整个 Dex 文件的相关属性
String Table            # 字符串数据索引，记录每个字符串在数据区的偏移量
Type Table              # 类型数据索引，记录每个类型的
Proto Table             # 原型数据索引，记录了方法生命的字符串、返回类型和参数列表
Field Table             # 字段数据索引，记录了所属类，类名及方法名
Method Table            # 类方法索引，记录方法所属类名，方法声明以及方法名称等信息
Class Def Table         # 类定义数据索引，记录指定类各类信息，包括借口，超类，类数据偏移量
Data Section            # 数据区，保存了各个类的真实数据

而这七个部分，在解析 Classes.dex 的安卓源码中，每个部分是由一个或多个结构体( struct ) 组成的，具体哪部分是由哪些结构体组成的不细说了，对现阶段安卓逆向来说用处不大，不过可以自己看看具体是什么样子的。

这里推荐一下一个二进制查看工具：010 Editor，可以打开二进制文件并且以多种格式显示，Classes.dex 也可以利用这个工具查看。值得一提的是，它支持解析很多种不同的二进制文件格式，非常方便。

Dalvik 虚拟机运行 Classes.dex 时有一个很奇妙的特性：不会马上生成所有 Class 里的 Method，而是在上文种提到的 Class Def Table 内有一个特殊的 DexMethod(struct) 里面有一个 codeOff(u4) 元素，保存的就是对应 Method 的 DexCode(struct) 的偏移地址。每次需要运行某个 Method 时，就根据各种索引查找到对应的 DexCode。在 DexCode 结构体里有很多个 insns[n](u2) 元素，而最终 Dalvik 执行的字节码就保存在 insns 里面。

现在有很多是通过 .so 通过 HOOK libdvm.so 里的 ClassResolver 实现代码还原，不过也有像娜迦这样，利用 static Method 提前初始化的特性进行代码还原。

因为上面这个特性，Classes.dex 变得非常灵活，可以通过 Native Library 在运行状态中对 insns 重新赋值，达到 Dalvik 执行过程中自篡改的目的；也可以通过修改 CodeOff 来切换指向的内存空间，达到重定义 DexCode 的目的；等等。

很多加固频繁使用的 Dex 类抽取其实就是用的这个特性，这种情况如果没有在调用后擦除 insns 那么则可以在加载成功后进行静态dump，否则，DexHunter 是个不错的选择。

Reference

* apk 自我保护的一种方式 —— 运行时自篡改 Dalvik 指令

* Android Dex 文件结构解析