[逆向]0ctf2015-slimming

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[逆向]0ctf2015-slimming相关的知识,希望对你有一定的参考价值。

slimming是一个64位的ELF文件。由于是逆向题,拿到文件后首先想到用IDA进行静态代码分析,但是发现该程序是静态链接的,其中含有大量的库函数代码,在无法进行符号解析的情况下,对其进行静态代码分析是不太可能的,因此转而进行动态分析。

0x01 初步分析

这个题目的名称slimming字面意思是“减肥”,猜测应该是一个与压缩解压缩有关的题目。运行elf后,构造一些输入,观察输出结果:

[email protected]:/home/ctf/0ctf2015/slimming# python -c print "A"*100 > in; ./slimming in out; hd out
Done!
00000000  30 6f 70 73 8e 43 54 47  62 31 4f 51 51 32 77 34  |0ops.CTGb1OQQ2w4|
00000010  31 30 61 4e 75 30 7c 49  64 6c 39 4c 4e 65 33 01  |10aNu0|Idl9LNe3.|
00000020  c5 43                                             |.C|
00000022
[email protected]:/home/ctf/0ctf2015/slimming# echo -n "ABC" > in; ./slimming in out; hd out
Done!
00000000  30 6f 70 73 8e 43 e9 46  df 30                    |0ops.C.F.0|
0000000a
[email protected]:/home/ctf/0ctf2015/slimming# echo -n "BCA" > in; ./slimming in out; hd out
Done!
00000000  30 6f 70 73 8d 43 e8 46  dd 30                    |0ops.C.F.0|
0000000a
[email protected]:/home/ctf/0ctf2015/slimming# echo -n "CAB" > in; ./slimming in out; hd out
Done!
00000000  30 6f 70 73 8c 43 ea 46  de 30                    |0ops.C.F.0|
0000000a

这些输出印证了我们的想法:

  • 当输入含有大量重复内容的字符串时(100个A),输出的长度大幅减小了(即被压缩了)
  • 当输入不含有重复内容的字符串时,输出的长度增大了,猜想是对其中的字进行编码导致的

因此我们大致确定slimming是一个实现数据压缩的程序。继续观察上述输出来寻找规律:

  • 在所有的输出中,前四个字节是相同的,为”0ops”,很明显,这是压缩文件的magic code。在压缩算法的实现中这很常见,比如zip压缩文件的magic code为“PK”。我们在后续进行解压缩时,略过这4个字节即可。
  • 第5个字节是变化的,但第6个字节是固定的,为”C”,猜想该字符代表”Compress”,“压缩“的意思,这应该是出题人向我们传递的线索,也印证了我们此前的想法
  • 当输入的内容不可压缩(下称literal)时,呈现出很强的规律性,比如在有效载荷的第1个字节,’A’对应0x8e,’B’对应0x8d, ‘C’对应0x8c,但是在不同的位置相同的literal被编码的内容不同,但大都呈现类似的规律

第三个规律是我们要详细分析的。在简单的压缩算法中,literal应该是不会被编码的,那么这些编码应该是通过某种方式映射而来。不难发现,在相同的位置,literal与编码值异或的结果是相同的,比如:

第一字节(有效载荷,下同):

0x8e ^ ord(‘A’) = 0x8d ^ ord(‘B’) = 0x8c ^ ord(‘C’) = 0xcf

第三字节:

0xe9 ^ ord(‘A’) = 0xe8 ^ ord(‘B’) = 0xe7 ^ ord(‘C’) = 0xab

其他奇数字节呈现相同的规律。因此我们推测,对于literal的编码,应该是literal与确定的值异或而来。那么对于偶数字节,又有什么规律呢?规律也很明显,就是该字节仅与位置有关,与literal无关,貌似也是某个值与与确定的值异或而来,我们假设是0与某个值异或而来。

我们可以构造一段较长的、不含有重复内容的负载来观察一下,原始负载呈现什么规律:

编写如下代码:

def getxorstream():
    data = ""
    for i in xrange(0, 256):
        data += chr(i)
    with open("./in", "wb") as fin:
        fin.write(data)
        fin.close()
    
    os.system("./slimming ./in ./out")
    
    with open("./out", "rb") as fout:
        data = fout.read()
        fout.close()
    
    data = data[4:]
    origindata = []
    for i in xrange(0, len(data), 2):
        origindata.append(ord(data[i]) ^ (i/2))
        origindata.append(ord(data[i+1]) ^ 0)
    print origindata

运行该函数后,打印信息如下:

[email protected]:/home/ctf/0ctf2015/slimming# ./slim.py 
Done!
[207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0, 207, 67, 171, 70, 156, 48, 178, 80]

结果也呈现出很强的规律性,可以看到,结果是如下数组的循环:

207, 67, 171, 70, 156, 48, 178, 80, 173, 51, 140, 53, 203, 49, 152, 79, 141, 49, 139, 72, 146, 109, 204, 77, 186, 100, 203, 0

因此我们能够得出结论,slimming程序在将压缩结果输出到文件之前,首先会将结果循环地与上述流做异或,后续我们在做解压缩时,也需要先将最终结果与上述流做异或才能得到压缩后的数据。

0x02 压缩算法分析

压缩的核心问题,是将载荷中重复出现的字用较短的编码进行替代,以达到降低载荷长度的目的,接下来我们要确定的问题是对于重复出现的负载,slimming是如何进行编码的。

我们先写一个脚本,将特定负载进行压缩,然后取出压缩后的负载与上述流进行异或,看看实际压缩后的负载是怎样的。脚本如下:

#!/usr/bin/python

import os
import sys
from pwn import *

#The stream to xor with when output compressed data
xorstream = [0xcf,0x43,0xab,0x46,0x9c,0x30,0xb2,0x50,0xad,0x33,0x8c,0x35,0xcb,0x31,0x98,0x4f,0x8d,0x31,0x8b,0x48,0x92,0x6d,0xcc,0x4d,0xba,0x64,0xcb,0x00]

#Get compressed data
def compress(s):
    with open("in", "wb") as fin:
        fin.write(s.strip(\\n))
        fin.close()
    
    os.system("./slimming in out")
    with open("out", "rb") as fout:
        data = fout.read()
        fout.close()
    return data[4:]

#Undo xor toward compressed data
def unxor(s):
    print ordlist(xor(s, xorstream, cut=left))

def main():
    data = compress(sys.argv[1])
    unxor(data)
    
if __name__ == "__main__":
    main()

然后我们执行下列命令:

[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py a
Done!
[97, 0]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aa
Done!
[97, 0, 97, 0]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaa
Done!
[97, 0, 255, 1]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaa
Done!
[97, 0, 255, 1, 97, 0]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaaa
Done!
[97, 0, 255, 1, 255, 1]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaaaa
Done!
[97, 0, 255, 1, 254, 1]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaaaaa
Done!
[97, 0, 255, 1, 254, 1, 97, 0]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaaaaaa
Done!
[97, 0, 255, 1, 254, 1, 255, 1]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaaaaaaa
Done!
[97, 0, 255, 1, 254, 1, 254, 1]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaaaaaaaa
Done!
[97, 0, 255, 1, 254, 1, 253, 1]
[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py aaaaaaaaaaa
Done!
[97, 0, 255, 1, 254, 1, 253, 1, 97, 0]

可以发现:

  • ‘a’被编码为literal(‘a’) + 0
  • ‘aa’被编码为literal(‘a’) + 0 + literal(‘a’) + 0
  • ‘aaa’被编码为Literal(‘a’) + 0 + reference(‘aa’) + 1
  • ‘aaaa’ 被编码为Literal(‘a’) + 0 + reference(‘aa’) + 1 + literal(‘a’) + 0

通过观察编码情况,可以总结出压缩规律如下:

  • 当字长超过(含)2时,会被编码
  • 偶数位字节为0或1,当为0时,表示这个是一个literal,当为非0时,表示这是一个reference
  • 编码中出现的255,254,253等数字看上去是字的索引,出现新的字时,会产生新的索引,从当前来看,最大索引号是255

slimming应该解析了负载中所有的字(长度超过2的缓冲区,下同),并将每一个字放到字典中,每个字对应着一个索引,索引编号从大到小,最大索引号为255。在压缩过程中,如果遇到了一个已经存在的字,将使用其索引号进行引用。

那么字是如何选取的,负载又是如何压缩的呢?

不断构造负载,观察压缩情况,可以发现压缩过程很简单:

在某个位置,会从该位置向后寻找一个在字典中已经存在的最长的字W(为什么要找最长的字?因为对最长的字进行压缩会产生最大的压缩比),对W根据其索引进行编码,同时在W后取出一个字节P,将W+P作为一个新的字添加到字典中。跳过W到P的位置,继续这个过程。

整个压缩过程和字的产生过程比较简单,也很好理解。写一段python代码模拟这个过程如下:

#emulate the compression process
def compress (data):
    print "To compress %s"%(data)
    out,dictionary = [],[]
    i,j = 0,0
    while i < len(data):
        j = i + 1
        #Search the longest word already in dictionary from current position
        while j < len(data) and data[i:j+1] in dictionary:
            j = j + 1
        
        #Add the new word
        if j < len(data):
            dictionary.append(data[i:j+1])
        
        #If we find a word(word‘s length must be longer than 2) in the dictionary, compress this word with its reference
        if len(data[i:j]) > 1:
            out += [0xFF - dictionary.index(data[i:j]), 1]
        #Else just use literal
        else:
            out += [ord(data[i]), 0]
        
        i = j
                
    return out

对于压缩过程,这里还遗留一个问题。上面提到,最大的索引编号是255,那么如果字的个数超过255,该如何建立索引呢?这是很容易出现的问题,大一点的文件,很容易出现字数超过255的情况。我们可以构造一段负载,让字的个数超过255个,看看是如何编码的,如下:

#!/usr/bin/python

import os
from pwn import *

#The stream to xor with when output compressed data
xorstream = [0xcf,0x43,0xab,0x46,0x9c,0x30,0xb2,0x50,0xad,0x33,0x8c,0x35,0xcb,0x31,0x98,0x4f,0x8d,0x31,0x8b,0x48,0x92,0x6d,0xcc,0x4d,0xba,0x64,0xcb,0x00]

#Get compressed data
def compress(s):
    with open("in", "wb") as fin:
        fin.write(s.strip(\\n))
        fin.close()
    
    os.system("./slimming in out")
    with open("out", "rb") as fout:
        data = fout.read()
        fout.close()
    return data[4:]

#Undo xor toward compressed data
def unxor(s):
    print ordlist(xor(s, xorstream, cut=left))

def main():
    data = ‘‘.join(chr(x) for x in range(256))
    data = compress(data + "AAA")
    unxor(data)
    
if __name__ == "__main__":
    main()

负载为”\\x00\\x01\\x02\\x03…\\x255AAA”,脚本输出如下:

[email protected]:/home/ctf/0ctf2015/slimming# ./s1.py 
Done!
[0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0, 17, 0, 18, 0, 19, 0, 20, 0, 21, 0, 22, 0, 23, 0, 24, 0, 25, 0, 26, 0, 27, 0, 28, 0, 29, 0, 30, 0, 31, 0, 32, 0, 33, 0, 34, 0, 35, 0, 36, 0, 37, 0, 38, 0, 39, 0, 40, 0, 41, 0, 42, 0, 43, 0, 44, 0, 45, 0, 46, 0, 47, 0, 48, 0, 49, 0, 50, 0, 51, 0, 52, 0, 53, 0, 54, 0, 55, 0, 56, 0, 57, 0, 58, 0, 59, 0, 60, 0, 61, 0, 62, 0, 63, 0, 64, 0, 65, 0, 66, 0, 67, 0, 68, 0, 69, 0, 70, 0, 71, 0, 72, 0, 73, 0, 74, 0, 75, 0, 76, 0, 77, 0, 78, 0, 79, 0, 80, 0, 81, 0, 82, 0, 83, 0, 84, 0, 85, 0, 86, 0, 87, 0, 88, 0, 89, 0, 90, 0, 91, 0, 92, 0, 93, 0, 94, 0, 95, 0, 96, 0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102, 0, 103, 0, 104, 0, 105, 0, 106, 0, 107, 0, 108, 0, 109, 0, 110, 0, 111, 0, 112, 0, 113, 0, 114, 0, 115, 0, 116, 0, 117, 0, 118, 0, 119, 0, 120, 0, 121, 0, 122, 0, 123, 0, 124, 0, 125, 0, 126, 0, 127, 0, 128, 0, 129, 0, 130, 0, 131, 0, 132, 0, 133, 0, 134, 0, 135, 0, 136, 0, 137, 0, 138, 0, 139, 0, 140, 0, 141, 0, 142, 0, 143, 0, 144, 0, 145, 0, 146, 0, 147, 0, 148, 0, 149, 0, 150, 0, 151, 0, 152, 0, 153, 0, 154, 0, 155, 0, 156, 0, 157, 0, 158, 0, 159, 0, 160, 0, 161, 0, 162, 0, 163, 0, 164, 0, 165, 0, 166, 0, 167, 0, 168, 0, 169, 0, 170, 0, 171, 0, 172, 0, 173, 0, 174, 0, 175, 0, 176, 0, 177, 0, 178, 0, 179, 0, 180, 0, 181, 0, 182, 0, 183, 0, 184, 0, 185, 0, 186, 0, 187, 0, 188, 0, 189, 0, 190, 0, 191, 0, 192, 0, 193, 0, 194, 0, 195, 0, 196, 0, 197, 0, 198, 0, 199, 0, 200, 0, 201, 0, 202, 0, 203, 0, 204, 0, 205, 0, 206, 0, 207, 0, 208, 0, 209, 0, 210, 0, 211, 0, 212, 0, 213, 0, 214, 0, 215, 0, 216, 0, 217, 0, 218, 0, 219, 0, 220, 0, 221, 0, 222, 0, 223, 0, 224, 0, 225, 0, 226, 0, 227, 0, 228, 0, 229, 0, 230, 0, 231, 0, 232, 0, 233, 0, 234, 0, 235, 0, 236, 0, 237, 0, 238, 0, 239, 0, 240, 0, 241, 0, 242, 0, 243, 0, 244, 0, 245, 0, 246, 0, 247, 0, 248, 0, 249, 0, 250, 0, 251, 0, 252, 0, 253, 0, 254, 0, 255, 0, 65, 0, 255, 2]

可以看到,其实对于一个reference来说,编码的第二个字节也是索引的一部分,假设某个reference编码的第一字节为a,第二字节为b,我们可以得出索引的计算方法为:

index = (b - 1) << 8 | (255 – a)

0x03 压缩实例

至此,我们已经分析出了slimming的压缩算法。下面以一个实例说明压缩过程。

假设待压缩内容为“ABABABABAB”,详细压缩过程如下:

Step 1 从开头的A处查找当前字典中最长的字,因为此时字典为空,所以新的字为“AB”,将”AB”放入字典,索引值为255。将A(literal)进行编码,此时编码负载为[65,0]。完成后,跳转到红色的B处:ABABABABAB

Step 2 从红色的B处查找当前字典中最长的字,由于“BA”不在字典中,索引新的字为“BA”,将“BA”放入字典,索引值为254。将B(literal)进行编码,此时编码负载为[65,0,66,0]。完成后,跳转到红色的A处:ABABABABAB

Step 3从红色的A处查找当前字典中最长的字,找到字典中最长的字为“AB”。将“AB”(reference)进行编码,此时编码负载为[65,0,66,0,255,1]。此时新的不在字典中的字为“ABA”,将“ABA”放入字典,索引值为253。完成后跳转到红色的A处:ABABABABAB

Step 4从红色的A处查找当前字典中最长的字,找到字典中最长的字为“ABA”。将“ABA”(reference)进行编码,此时编码负载为[65,0,66,0,255,1,253,1]。此时新的不在字典中的字为“ABAB”,将“ABAB”放入字典,索引值为252。完成后跳转到红色的B处:ABABABABAB

Step 5从红色的B处查找当前字典中最长的字,找到字典中最长的字为“BA”,索引为254。将“BA”(reference)进行编码,此时编码负载为[65,0,66,0,255,1,253,1,254,1]。此时新的不在字典中的字为“BAB”,将“BAB”放入字典,索引值为251。完成后跳转到红色的B处:ABABABABAB

Step 6 此时只剩下B(literal),将其编码,此时编码负载为[65,0,66,0,255,1,253,1,254,1,66,0]

将编码负载与xorstream进行异或后,便可得到最终的输出。

0x04 解压缩

解压缩是压缩过程的逆过程,解压缩过程中,我们可以根据一个字节对的第二个字节来判断解码的是literal还是reference,如果第二个字节为0,说明是literal,如果大于0,说明是reference,根据索引值从字典中取出相应的字即可。

可能存在的问题是,当指定索引值的字在字典中不存在怎么办?此时,这个字必然是将要添加到字典中的字。

从压缩的角度看,如下图:

技术分享

当压缩到word时,下一个需要加入字典的新字为word+X,即绿色加上橙色的部分。

但是从解压的角度看,如下图:

技术分享

当解压到word时,下一个需要解压的字为X+????,即橙色加上红色的部分。这说明,新的字首尾两个字节是相同的,且等于word的第一个字节,即:

新字 = word + word[0]

至此,我们可以写出解压脚本了,如下:

#!/usr/bin/python

import sys
from pwn import *

xorstream = [0xcf,0x43,0xab,0x46,0x9c,0x30,0xb2,0x50,0xad,0x33,0x8c,0x35,0xcb,0x31,0x98,0x4f,0x8d,0x31,0x8b,0x48,0x92,0x6d,0xcc,0x4d,0xba,0x64,0xcb,0x00]

def decompress (data):
    out,dictionary = [],[]
    
    pword = None
    
    for i in xrange(0, len(data), 2):
        pair0 = ord(data[i])
        pair1 = ord(data[i+1])
        
        #It is literal
        if pair1 == 0:
            word = chr(pair0)
        else:
            idx = (0xFF - pair0) | (pair1 - 1) << 8
            if idx == len(dictionary):
                word = pword + pword[0]
            else:
                word = dictionary[idx]
        
        if pword:
            dictionary.append(pword + word[0])

        pword = word
        out += word
    return out
    
def main():
    fin = open(sys.argv[1], "rb")
    data = fin.read()
    fin.close()
    
    unmasked = xor(data[4:], xorstream, cut=left)
    decompressed = decompress (unmasked)
    
    fout = open(sys.argv[2], "wb")
    fout.write(‘‘.join(decompressed))
    fout.close()

if __name__ == "__main__":
    main ()
    

运行该脚本,对slimming_data进行加压缩,将输出保存到名称为“decompressed”的文件中:

[email protected]:/home/ctf/0ctf2015/slimming# ./slim.py ./slimming_data decompressed
[email protected]:/home/ctf/0ctf2015/slimming# file decompressed 
decompressed: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, stripped
[email protected]:/home/ctf/0ctf2015/slimming# chmod +x decompressed 
[email protected]:/home/ctf/0ctf2015/slimming# ./decompressed 
sdfsfdsfsf
No.No..No...

解压缩出的内容为一个ELF文件,执行后会接收用户输入,之后提示错误。用IDA分析这个释放出来的ELF文件,发现非常简单,这个ELF会接收用户输入,并与一个特定的字符串比较,这个字符串即为flag:

技术分享

至此,任务完成,非常有意思的一道题目。

以上是关于[逆向]0ctf2015-slimming的主要内容,如果未能解决你的问题,请参考以下文章

babyheap_0ctf_2017 堆技巧 fastbin-attack

0ctf2017-pages-recurse

suctf逆向部分

Android 逆向类加载器 ClassLoader ( 类加载器源码简介 | BaseDexClassLoader | DexClassLoader | PathClassLoader )(代码片段

Android 逆向Android 逆向通用工具开发 ( Android 平台运行的 cmd 程序类型 | Android 平台运行的 cmd 程序编译选项 | 编译 cmd 可执行程序 )(代码片段

Android 逆向整体加固脱壳 ( DEX 优化流程分析 | DexPrepare.cpp 中 dvmOptimizeDexFile() 方法分析 | /bin/dexopt 源码分析 )(代码片段