Dex文件分析2

水深无声 2022-05-29 06:43 210阅读 0赞

# 一、前言 #

新的一年又开始了，大家是否还记得去年年末的时候，我们还有一件事没有做，那就是解析Android中编译之后的classes.dex文件格式，我们在去年的时候已经介绍了：

如何解析编译之后的xml文件格式：

[http://blog.csdn.net/jiangwei0910410003/article/details/50568487][http_blog.csdn.net_jiangwei0910410003_article_details_50568487]

如何解析编译之后的resource.arsc文件格式：

[http://blog.csdn.net/jiangwei0910410003/article/details/50628894][http_blog.csdn.net_jiangwei0910410003_article_details_50628894]

那么我们还剩下一个文件格式就是classes.dex了，那么今天我们就来看看最后一个文件格式解析，关于Android中的dex文件的相关知识这里就不做太多的解释了，网上有很多资料可以参考，而且，我们在之前介绍的一篇加固apk的那篇文章中也介绍了一点dex的格式知识点：[http://blog.csdn.net/jiangwei0910410003/article/details/48415225][http_blog.csdn.net_jiangwei0910410003_article_details_48415225]，我们按照之前的解析思路来，首先还是来一张神图(**非虫大大的杰作**)：

![Center][]

有了这张神图，那么接下来我们就可以来介绍dex的文件结构了，首先还是来看一张大体的结构图：

![Center 1][]

# 二、准备工作 #

我们在讲解数据结构之前，我们需要先创建一个简单的例子来帮助我们来解析，我们需要得到一个简单的dex文件，这里我们不借助任何的IDE工具，就可以构造一个dex文件出来。借助的工具很简单：javac,dx命令即可。

创建 java 源文件 ，内容如下  
代码:  
**public class Hello  
\{  
public static void main(String\[\] argc)  
\{  
System.out.println(“Hello, Android!\\n”);  
\}  
\}**  
在当前工作路径下 ， 编译方法如下 ：  
(1) 编译成 java class 文件  
执行命令 ： javac Hello.java  
编译完成后 ，目录下生成 Hello.class 文件 。可以使用命令 java Hello 来测试下 ，会输出代码中的 “Hello， Android！” 的字符串 。  
(2) 编译成 dex 文件  
编译工具在 Android SDK 的路径如下 ，其中 19.0.1 是Android SDK build\_tools 的版本 ，请按照在本地安装的 build\_tools 版本来 。建议该路径加载到 PATH 路径下 ，否则引用 dx 工具时需要使用绝对路径 ：**./build-tools/19.0.1/dx**  
执行命令 ： **dx –dex –output=Hello.dex Hello.class**  
编译正常会生成 Hello.dex 文件 。  
3. 使用 ADB 运行测试  
测试命令和输出结果如下 ：  
**adbroot<br> adb push Hello.dex /sdcard/  
$ adb shell  
root@maguro:/ \# dalvikvm -cp /sdcard/Hello.dex Hello  
Hello, Android!**  
4. 重要说明  
(1) 测试环境使用真机和 Android 虚拟机都可以的 。核心的命令是  
**dalvikvm -cp /sdcard/Hello.dex Hello**  
\-cp 是 class path 的缩写 ，后面的 Hello 是要运行的 Class 的名称 。网上有描述说输入 dalvikvm –help  
可以看到 dalvikvm 的帮助文档 ，但是在 Android4.4 的官方模拟器和自己的手机上测试都提示找不到  
Class 路径 ，在Android 老的版本 （ 4.3 ) 上测试还是有输出的 。  
(2) 因为命令在执行时 ， dalvikvm 会在 /data/dalvik-cache/ 目录下创建 .dex 文件 ，因此要求 ADB 的  
执行 Shell 对目录 /data/dalvik-cache/ 有读、写和执行的权限 ，否则无法达到预期效果 。

# 三、讲解数据结构 #

下面我们按照这张大体的思路图来一一讲解各个数据结构

## **第一、头部信息Header结构** ##

dex文件里的header。除了描述.dex文件的文件信息外，还有文件里其它各个区域的索引。header对应成结构体类型，逻辑上的描述我用结构体header\_item来理解它。先给出结构体里面用到的数据类型ubyte和uint的解释，然后再是结构体的描述，后面对各种结构描述的时候也是用的这种方法。

代码定义：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import com.wjdiankong.parsedex.Utils;  
4.    
5.  public class HeaderType \{  
6.        
7.      /\*\* 
8.       \* struct header\_item 
9.          \{  
10.         ubyte\[8\] magic; 
11.         unit checksum; 
12.         ubyte\[20\] siganature; 
13.         uint file\_size; 
14.         uint header\_size; 
15.         unit endian\_tag; 
16.         uint link\_size; 
17.         uint link\_off; 
18.         uint map\_off; 
19.         uint string\_ids\_size; 
20.         uint string\_ids\_off; 
21.         uint type\_ids\_size; 
22.         uint type\_ids\_off; 
23.         uint proto\_ids\_size; 
24.         uint proto\_ids\_off; 
25.         uint method\_ids\_size; 
26.         uint method\_ids\_off; 
27.         uint class\_defs\_size; 
28.         uint class\_defs\_off; 
29.         uint data\_size; 
30.         uint data\_off; 
31.         \} 
32.      \*/  
33.     public byte\[\] magic = new byte\[8\];  
34.     public int checksum;  
35.     public byte\[\] siganature = new byte\[20\];  
36.     public int file\_size;  
37.     public int header\_size;  
38.     public int endian\_tag;  
39.     public int link\_size;  
40.     public int link\_off;  
41.     public int map\_off;  
42.     public int string\_ids\_size;  
43.     public int string\_ids\_off;  
44.     public int type\_ids\_size;  
45.     public int type\_ids\_off;  
46.     public int proto\_ids\_size;  
47.     public int proto\_ids\_off;  
48.     public int field\_ids\_size;  
49.     public int field\_ids\_off;  
50.     public int method\_ids\_size;  
51.     public int method\_ids\_off;  
52.     public int class\_defs\_size;  
53.     public int class\_defs\_off;  
54.     public int data\_size;  
55.     public int data\_off;  
56.       
57.     @Override  
58.     public String toString()\{  
59.         return “magic:”\+Utils.bytesToHexString(magic)+“\\n”  
60.                 + ”checksum:”\+checksum + “\\n”  
61.                 + ”siganature:”\+Utils.bytesToHexString(siganature) + “\\n”  
62.                 + ”file\_size:”\+file\_size + “\\n”  
63.                 + ”header\_size:”\+header\_size + “\\n”  
64.                 + ”endian\_tag:”\+endian\_tag + “\\n”  
65.                 + ”link\_size:”\+link\_size + “\\n”  
66.                 + ”link\_off:”\+Utils.bytesToHexString(Utils.int2Byte(link\_off)) + “\\n”  
67.                 + ”map\_off:”\+Utils.bytesToHexString(Utils.int2Byte(map\_off)) + “\\n”  
68.                 + ”string\_ids\_size:”\+string\_ids\_size + “\\n”  
69.                 + ”string\_ids\_off:”\+Utils.bytesToHexString(Utils.int2Byte(string\_ids\_off)) + “\\n”  
70.                 + ”type\_ids\_size:”\+type\_ids\_size + “\\n”  
71.                 + ”type\_ids\_off:”\+Utils.bytesToHexString(Utils.int2Byte(type\_ids\_off)) + “\\n”  
72.                 + ”proto\_ids\_size:”\+proto\_ids\_size + “\\n”  
73.                 + ”proto\_ids\_off:”\+Utils.bytesToHexString(Utils.int2Byte(proto\_ids\_off)) + “\\n”  
74.                 + ”field\_ids\_size:”\+field\_ids\_size + “\\n”  
75.                 + ”field\_ids\_off:”\+Utils.bytesToHexString(Utils.int2Byte(field\_ids\_off)) + “\\n”  
76.                 + ”method\_ids\_size:”\+method\_ids\_size + “\\n”  
77.                 + ”method\_ids\_off:”\+Utils.bytesToHexString(Utils.int2Byte(method\_ids\_off)) + “\\n”  
78.                 + ”class\_defs\_size:”\+class\_defs\_size + “\\n”  
79.                 + ”class\_defs\_off:”\+Utils.bytesToHexString(Utils.int2Byte(class\_defs\_off)) + “\\n”  
80.                 + ”data\_size:”\+data\_size + “\\n”  
81.                 + ”data\_off:”\+Utils.bytesToHexString(Utils.int2Byte(data\_off));  
82.                   
83.                   
84.     \}  
85.   
86. \}

package com.wjdiankong.parsedex.struct;
    
    import com.wjdiankong.parsedex.Utils;
    
    public class HeaderType {
    
        /**
         * struct header_item
            {
            ubyte[8] magic;
            unit checksum;
            ubyte[20] siganature;
            uint file_size;
            uint header_size;
            unit endian_tag;
            uint link_size;
            uint link_off;
            uint map_off;
            uint string_ids_size;
            uint string_ids_off;
            uint type_ids_size;
            uint type_ids_off;
            uint proto_ids_size;
            uint proto_ids_off;
            uint method_ids_size;
            uint method_ids_off;
            uint class_defs_size;
            uint class_defs_off;
            uint data_size;
            uint data_off;
            }
         */
        public byte[] magic = new byte[8];
        public int checksum;
        public byte[] siganature = new byte[20];
        public int file_size;
        public int header_size;
        public int endian_tag;
        public int link_size;
        public int link_off;
        public int map_off;
        public int string_ids_size;
        public int string_ids_off;
        public int type_ids_size;
        public int type_ids_off;
        public int proto_ids_size;
        public int proto_ids_off;
        public int field_ids_size;
        public int field_ids_off;
        public int method_ids_size;
        public int method_ids_off;
        public int class_defs_size;
        public int class_defs_off;
        public int data_size;
        public int data_off;
    
        @Override
        public String toString(){
            return "magic:"+Utils.bytesToHexString(magic)+"\n"
                    + "checksum:"+checksum + "\n"
                    + "siganature:"+Utils.bytesToHexString(siganature) + "\n"
                    + "file_size:"+file_size + "\n"
                    + "header_size:"+header_size + "\n"
                    + "endian_tag:"+endian_tag + "\n"
                    + "link_size:"+link_size + "\n"
                    + "link_off:"+Utils.bytesToHexString(Utils.int2Byte(link_off)) + "\n"
                    + "map_off:"+Utils.bytesToHexString(Utils.int2Byte(map_off)) + "\n"
                    + "string_ids_size:"+string_ids_size + "\n"
                    + "string_ids_off:"+Utils.bytesToHexString(Utils.int2Byte(string_ids_off)) + "\n"
                    + "type_ids_size:"+type_ids_size + "\n"
                    + "type_ids_off:"+Utils.bytesToHexString(Utils.int2Byte(type_ids_off)) + "\n"
                    + "proto_ids_size:"+proto_ids_size + "\n"
                    + "proto_ids_off:"+Utils.bytesToHexString(Utils.int2Byte(proto_ids_off)) + "\n"
                    + "field_ids_size:"+field_ids_size + "\n"
                    + "field_ids_off:"+Utils.bytesToHexString(Utils.int2Byte(field_ids_off)) + "\n"
                    + "method_ids_size:"+method_ids_size + "\n"
                    + "method_ids_off:"+Utils.bytesToHexString(Utils.int2Byte(method_ids_off)) + "\n"
                    + "class_defs_size:"+class_defs_size + "\n"
                    + "class_defs_off:"+Utils.bytesToHexString(Utils.int2Byte(class_defs_off)) + "\n"
                    + "data_size:"+data_size + "\n"
                    + "data_off:"+Utils.bytesToHexString(Utils.int2Byte(data_off));
    
    
        }
    
    }

查看Hex如下：

![Center 2][]

我们用一张图来描述各个字段的长度：

![Center 3][]  
里面一对一对以\_size和\_off为后缀的描述：data\_size是以Byte为单位描述data区的大小，其余的  
\_size都是描述该区里元素的个数；\_off描述相对与文件起始位置的偏移量。其余的6个是描述.dex文件信  
息的，各项说明如下：  
**(1) magic value**  
这 8 个 字节一般是常量 ，为了使 .dex 文件能够被识别出来 ，它必须出现在 .dex 文件的最开头的  
位置 。数组的值可以转换为一个字符串如下 ：  
\{ 0x64 0x65 0x78 0x0a 0x30 0x33 0x35 0x00 \} = “dex\\n035\\0”  
中间是一个 ‘\\n’ 符号 ，后面 035 是 Dex 文件格式的版本 。  
**(2) checksum 和 signature**  
文件校验码 ，使用alder32 算法校验文件除去 maigc ，checksum 外余下的所有文件区域 ，用于检  
查文件错误 。  
signature , 使用 SHA-1 算法 hash 除去 magic ,checksum 和 signature 外余下的所有文件区域 ，  
用于唯一识别本文件 。  
**(3) file\_size**  
Dex 文件的大小 。  
**(4) header\_size**  
header 区域的大小 ，单位 Byte ，一般固定为 0x70 常量 。  
**(5) endian\_tag**  
大小端标签 ，标准 .dex 文件格式为 小端 ，此项一般固定为 0x1234 5678 常量 。

**(6) link\_size和link\_off**

这个两个字段是表示链接数据的大小和偏移值

**(7) map\_off**  
map item 的偏移地址 ，该 item 属于 data 区里的内容 ，值要大于等于 data\_off 的大小 。结构如  
map\_list 描述 ：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import java.util.ArrayList;  
4.  import java.util.List;  
5.    
6.  public class MapList \{  
7.        
8.      /\*\* 
9.       \* struct maplist 
10.         \{  
11.         uint size; 
12.         map\_item list \[size\]; 
13.         \} 
14.      \*/  
15.       
16.     public int size;  
17.     public List<MapItem> map\_item = new ArrayList<MapItem>();  
18.   
19. \}

package com.wjdiankong.parsedex.struct;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class MapList {
    
        /**
         * struct maplist
            {
            uint size;
            map_item list [size];
            }
         */
    
        public int size;
        public List<MapItem> map_item = new ArrayList<MapItem>();
    
    }

定义位置 ： data区  
引用位置 ：header 区 。  
map\_list 里先用一个 uint 描述后面有 size 个 map\_item , 后续就是对应的 size 个 map\_item 描述 。  
map\_item 结构有 4 个元素 ： type 表示该 map\_item 的类型 ，本节能用到的描述如下 ，详细Dalvik  
Executable Format 里 Type Code 的定义 ；size 表示再细分此 item ， 该类型的个数 ；offset 是第一个元  
素的针对文件初始位置的偏移量 ； unuse 是用对齐字节的 ，无实际用处 。结构定义如下：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  public class MapItem \{  
4.        
5.      /\*\* 
6.       \* struct map\_item 
7.          \{  
8.          ushort type; 
9.          ushort unuse; 
10.         uint size; 
11.         uint offset; 
12.         \} 
13.      \*/  
14.       
15.     public short type;  
16.     public short unuse;  
17.     public int size;  
18.     public int offset;  
19.       
20.     public static int getSize()\{  
21.         return 2 + 2 + 4 + 4;  
22.     \}  
23.       
24.     @Override  
25.     public String toString()\{  
26.         return “type:”\+type+“,unuse:”\+unuse+“,size:”\+size+“,offset:”\+offset;  
27.     \}  
28.   
29. \}

package com.wjdiankong.parsedex.struct;
    
    public class MapItem {
    
        /**
         * struct map_item
            {
            ushort type;
            ushort unuse;
            uint size;
            uint offset;
            }
         */
    
        public short type;
        public short unuse;
        public int size;
        public int offset;
    
        public static int getSize(){
            return 2 + 2 + 4 + 4;
        }
    
        @Override
        public String toString(){
            return "type:"+type+",unuse:"+unuse+",size:"+size+",offset:"+offset;
        }
    
    }

header->map\_off = 0x0244 , 偏移为 0244 的位置值为 0x 000d 。

每个 map\_item 描述占用 12 Byte ， 整个 map\_list 占用 12 \* size + 4 个字节 。所以整个 map\_list 占用空  
间为 12 \* 13 + 4 = 160 = 0x00a0 ， 占用空间为 0x 0244 ~ 0x 02E3 。从文件内容上看 ，也是从 0x 0244  
到文件结束的位置 。  
![Center 4][]  
地址 0x0244 的一个 uinit 的值为 0x0000 000d ，map\_list - > size = 0x0d = 13 ，说明后续有 13 个  
map\_item 。根据 map\_item 的结构描述在0x0248 ~ 0x02e3 里的值 ，整理出这段二进制所表示的 13 个  
map\_item 内容 ，汇成表格如下 ：  
map\_list - > map\_item 里的内容 ，有部分 item 跟 header 里面相应 item 的 offset 地址描述相同 。但  
map\_list 描述的更为全面些 ，又包括了 HEADER\_ITEM , TYPE\_LIST , STRING\_DATA\_ITEM 等 ，  
最后还有它自己 TYPE\_MAP\_LIST 。  
至此 ， header 部分描述完毕 ，它包括描述 .dex 文件的信息 ，其余各索引区和 data 区的偏移信息 ， 一个  
map\_list 结构 。map\_list 里除了对索引区和数据区的偏移地址又一次描述 ，也有其它诸如 HEAD\_ITEM ,  
DEBUG\_INFO\_ITEM 等信息 。

**(8) string\_ids\_size和string\_ids\_off**

这两个字段表示dex中用到的所有的字符串内容的大小和偏移值，我们需要解析完这部分，然后用一个字符串池存起来，后面有其他的数据结构会用索引值来访问字符串，这个池子也是非常重要的。后面会详细介绍string\_ids的数据结构

**(9) type\_ids\_size和type\_ids\_off**

这两个字段表示dex中的类型数据结构的大小和偏移值，比如类类型，基本类型等信息，后面会详细介绍type\_ids的数据结构

**(10) proto\_ids\_size和type\_ids\_off**

这两个字段表示dex中的元数据信息数据结构的大小和偏移值，描述方法的元数据信息，比如方法的返回类型，参数类型等信息，后面会详细介绍proto\_ids的数据结构

**(11) field\_ids\_size和field\_ids\_off**

这两个字段表示dex中的字段信息数据结构的大小和偏移值，后面会详细介绍field\_ids的数据结构

**(12) method\_ids\_size和method\_ids\_off**

这两个字段表示dex中的方法信息数据结构的大小和偏移值，后面会详细介绍method\_ids的数据结构

**(13) class\_defs\_size和class\_defs\_off**

这两个字段表示dex中的类信息数据结构的大小和偏移值，这个数据结构是整个dex中最复杂的数据结构，他内部层次很深，包含了很多其他的数据结构，所以解析起来也很麻烦，所以后面会着重讲解这个数据结构

**(14) data\_size和data\_off**

这两个字段表示dex中数据区域的结构信息的大小和偏移值，这个结构中存放的是数据区域，比如我们定义的常量值等信息。

到这里我们就看完了dex的头部信息，头部包含的信息还是很多的，主要就两个个部分：

1) 魔数+签名+文件大小等信息

2) 后面的各个数据结构的大小和偏移值，都是成对出现的

下面我们就来开始介绍各个数据结构的信息

## **第二、string\_ids数据结构** ##

string\_ids 区索引了 .dex 文件所有的字符串 。 本区里的元素格式为 string\_ids\_item , 可以使用结  
构体如下描述 。

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import com.wjdiankong.parsedex.Utils;  
4.    
5.  public class StringIdsItem \{  
6.        
7.      /\*\* 
8.       \* struct string\_ids\_item 
9.          \{  
10.         uint string\_data\_off; 
11.         \} 
12.      \*/  
13.       
14.     public int string\_data\_off;  
15.       
16.     public static int getSize()\{  
17.         return 4;  
18.     \}  
19.       
20.     @Override  
21.     public String toString()\{  
22.         return Utils.bytesToHexString(Utils.int2Byte(string\_data\_off));  
23.     \}  
24.   
25. \}

package com.wjdiankong.parsedex.struct;
    
    import com.wjdiankong.parsedex.Utils;
    
    public class StringIdsItem {
    
        /**
         * struct string_ids_item
            {
            uint string_data_off;
            }
         */
    
        public int string_data_off;
    
        public static int getSize(){
            return 4;
        }
    
        @Override
        public String toString(){
            return Utils.bytesToHexString(Utils.int2Byte(string_data_off));
        }
    
    }

以 \_ids 结尾的各个 section 里放置的都是对应数据的偏移地址 ，只是一个索引 ，所以才会在 dex文件布局里把这些区归类为 “索引区” 。  
string\_data\_off 只是一个偏移地址 ，它指向的数据结构为 string\_data\_item

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import java.util.ArrayList;  
4.  import java.util.List;  
5.    
6.  public class StringDataItem \{  
7.        
8.      /\*\* 
9.       \* struct string\_data\_item 
10.         \{  
11.         uleb128 utf16\_size; 
12.         ubyte data; 
13.         \} 
14.      \*/  
15.       
16.     /\*\* 
17.      \*  上述描述里提到了 LEB128 （ little endian base 128 ) 格式 ，是基于 1 个 Byte 的一种不定长度的 
18.         编码方式 。若第一个 Byte 的最高位为 1 ，则表示还需要下一个 Byte 来描述 ，直至最后一个 Byte 的最高 
19.         位为 0 。每个 Byte 的其余 Bit 用来表示数据 
20.      \*/  
21.       
22.     public List<Byte> utf16\_size = new ArrayList<Byte>();  
23.     public byte data;  
24.   
25. \}

package com.wjdiankong.parsedex.struct;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class StringDataItem {
    
        /**
         * struct string_data_item
            {
            uleb128 utf16_size;
            ubyte data;
            }
         */
    
        /**
         *  上述描述里提到了 LEB128 （ little endian base 128 ) 格式 ，是基于 1 个 Byte 的一种不定长度的
            编码方式 。若第一个 Byte 的最高位为 1 ，则表示还需要下一个 Byte 来描述 ，直至最后一个 Byte 的最高
            位为 0 。每个 Byte 的其余 Bit 用来表示数据
         */
    
        public List<Byte> utf16_size = new ArrayList<Byte>();
        public byte data;
    
    }

**延展**

上述描述里提到了 LEB128 （ little endian base 128 ) 格式 ，是基于 1 个 Byte 的一种不定长度的编码方式 。若第一个 Byte 的最高位为 1 ，则表示还需要下一个 Byte 来描述 ，直至最后一个 Byte 的最高位为 0 。每个 Byte 的其余 Bit 用来表示数据 。这里既然介绍了uleb128这种数据类型，就在这里解释一下，因为后面会经常用到这个数据类型，这个数据类型的出现其实就是为了解决一个问题，那就是减少内存的浪费，他就是表示int类型的数值，但是int类型四个字节有时候在使用的时候有点浪费，所以就应运而生了，他的原理也很简单：

![Center 5][]  
图只是指示性的用两个字节表示。编码的每个字节有效部分只有低7bits，每个字节的最高bit用来指示是否是最后一个字节。  
非最高字节的bit7为0  
最高字节的bit7为1  
将leb128编码的数字转换为可读数字的规则是：除去每个字节的bit7，将每个字节剩余的7个bits拼接在一起，即为数字。  
比如：  
LEB128编码的0x02b0 —> 转换后的数字0x0130  
转换过程：  
0x02b0 => 0000 0010 1011 0000 =>去除最高位=> 000 0010 011 0000 =>按4bits重排 => 00 0001 0011 0000 => 0x130

底层代码位于：**android/dalvik/libdex/leb128.h**

Java中也写了一个工具类：

**\[java\]** view plain copy

print ?

1.  /\*\* 
2.   \* 读取C语言中的uleb类型 
3.   \* 目的是解决整型数值浪费问题 
4.   \* 长度不固定，在1~5个字节中浮动 
5.   \* @param srcByte 
6.   \* @param offset 
7.   \* @return 
8.   \*/  
9.  public static byte\[\] readUnsignedLeb128(byte\[\] srcByte, int offset)\{  
10.     List<Byte> byteAryList = new ArrayList<Byte>();  
11.     byte bytes = Utils.copyByte(srcByte, offset, 1)\[0\];  
12.     byte highBit = (byte)(bytes & 0x80);  
13.     byteAryList.add(bytes);  
14.     offset ++;  
15.     while(highBit != 0)\{  
16.         bytes = Utils.copyByte(srcByte, offset, 1)\[0\];  
17.         highBit = (byte)(bytes & 0x80);  
18.         offset ++;  
19.         byteAryList.add(bytes);  
20.     \}  
21.     byte\[\] byteAry = new byte\[byteAryList.size()\];  
22.     for(int j=0;j<byteAryList.size();j++)\{  
23.         byteAry\[j\] = byteAryList.get(j);  
24.     \}  
25.     return byteAry;  
26. \}

/**
     * 读取C语言中的uleb类型
     * 目的是解决整型数值浪费问题
     * 长度不固定，在1~5个字节中浮动
     * @param srcByte
     * @param offset
     * @return
     */
    public static byte[] readUnsignedLeb128(byte[] srcByte, int offset){
        List<Byte> byteAryList = new ArrayList<Byte>();
        byte bytes = Utils.copyByte(srcByte, offset, 1)[0];
        byte highBit = (byte)(bytes & 0x80);
        byteAryList.add(bytes);
        offset ++;
        while(highBit != 0){
            bytes = Utils.copyByte(srcByte, offset, 1)[0];
            highBit = (byte)(bytes & 0x80);
            offset ++;
            byteAryList.add(bytes);
        }
        byte[] byteAry = new byte[byteAryList.size()];
        for(int j=0;j<byteAryList.size();j++){
            byteAry[j] = byteAryList.get(j);
        }
        return byteAry;
    }

这个方法是读取dex中uleb128类型的数据，遇到一个字节最高位=0就停止读下个字节的原理来实现即可

还有一个方法就是解码uleb128类型的数据：

**\[java\]** view plain copy

print ?

1.  /\*\* 
2.   \* 解码leb128数据 
3.   \* 每个字节去除最高位，然后进行拼接，重新构造一个int类型数值，从低位开始 
4.   \* @param byteAry 
5.   \* @return 
6.   \*/  
7.  public static int decodeUleb128(byte\[\] byteAry) \{  
8.      int index = 0, cur;  
9.      int result = byteAry\[index\];  
10.     index++;  
11.   
12.     if(byteAry.length == 1)\{  
13.         return result;  
14.     \}  
15.   
16.     if(byteAry.length == 2)\{  
17.         cur = byteAry\[index\];  
18.         index++;  
19.         result = (result & 0x7f) | ((cur & 0x7f) << 7);  
20.         return result;  
21.     \}  
22.   
23.     if(byteAry.length == 3)\{  
24.         cur = byteAry\[index\];  
25.         index++;  
26.         result |= (cur & 0x7f) << 14;  
27.         return result;  
28.     \}  
29.   
30.     if(byteAry.length == 4)\{  
31.         cur = byteAry\[index\];  
32.         index++;  
33.         result |= (cur & 0x7f) << 21;  
34.         return result;  
35.     \}  
36.   
37.     if(byteAry.length == 5)\{  
38.         cur = byteAry\[index\];  
39.         index++;  
40.         result |= cur << 28;  
41.         return result;  
42.     \}  
43.   
44.     return result;  
45.   
46. \}

/**
     * 解码leb128数据
     * 每个字节去除最高位，然后进行拼接，重新构造一个int类型数值，从低位开始
     * @param byteAry
     * @return
     */
    public static int decodeUleb128(byte[] byteAry) {
        int index = 0, cur;
        int result = byteAry[index];
        index++;
    
        if(byteAry.length == 1){
            return result;
        }
    
        if(byteAry.length == 2){
            cur = byteAry[index];
            index++;
            result = (result & 0x7f) | ((cur & 0x7f) << 7);
            return result;
        }
    
        if(byteAry.length == 3){
            cur = byteAry[index];
            index++;
            result |= (cur & 0x7f) << 14;
            return result;
        }
    
        if(byteAry.length == 4){
            cur = byteAry[index];
            index++;
            result |= (cur & 0x7f) << 21;
            return result;
        }
    
        if(byteAry.length == 5){
            cur = byteAry[index];
            index++;
            result |= cur << 28;
            return result;
        }
    
        return result;
    
    }

这个原理很简单，就是去除每个字节的最高位，然后拼接剩下的7位，然后从新构造一个int类型的数据，位不够就从低位开始左移。

**我们通过上面的uleb128的解释来看，其实uleb128类型就是1~5个字节来回浮动，为什么是5呢？因为他要表示一个4个字节的int类型，但是每个字节要去除最高位，那么肯定最多只需要5个字节就可以表示4个字节的int类型数据了。这里就解释了uleb128数据类型，下面我们回归正题，继续来看string\_ids数据结构**

根据 string\_ids\_item 和 string\_data\_item 的描述 ，加上 header 里提供的入口位置 string\_ids\_size  
= 0x0e , string\_ids\_off = 0x70 ，我们可以整理出 string\_ids 及其对应的数据如下 ：

![Center 6][]

string\_ids\_item 和 string\_data\_item 里提取出的对应数据表格 ：

![Center 7][]  
string 里的各种标志符号 ，诸如 L ， V ， VL , \[ 等在 .dex 文件里有特殊的意思 。  
string\_ids 的终极奥义就是找到这些字符串 。其实使用二进制编辑器打开 .dex 文件时 ，一般工具默认翻译成 ASCII 码 ，总会一大片熟悉的字符白生生地很是亲切， 也很是晃眼 。刚才走过的一路子分析流程 ，就是顺藤摸瓜找到它们是怎么来的。以后的一些 type-ids , method\_ids 也会引用到这一片熟悉的字符串。

注意：我们后面的解析代码会看到，其实我们没必要用那么复杂的去解析uleb128类型，因为我们会看到这个字符串和我们之前解析xml和resource.arsc格式一样，每个字符串的第一个字节表示字符串的长度，那么我们只要知道每个字符串的偏移地址就可以解析出字符串的内容了，而每个字符串的偏移地址是存放在string\_ids\_item中的。

到这里我们就解析完了dex中所有的字符串内容，我们用一个字符串池来进行存储即可。下面我们来继续看type\_ids数据结构

## **第三、type\_ids数据结构** ##

这个数据结构中存放的数据主要是描述dex中所有的类型，比如类类型，基本类型等信息。type\_ids 区索引了 dex 文件里的所有数据类型 ，包括 class 类型 ，数组类型（array types）和基本类型(primitive types) 。 本区域里的元素格式为 type\_ids\_item , 结构描述如下 ：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import com.wjdiankong.parsedex.Utils;  
4.    
5.  public class TypeIdsItem \{  
6.        
7.      /\*\* 
8.       \* struct type\_ids\_item 
9.          \{  
10.         uint descriptor\_idx; 
11.         \} 
12.      \*/  
13.       
14.     public int descriptor\_idx;  
15.       
16.     public static int getSize()\{  
17.         return 4;  
18.     \}  
19.       
20.     @Override  
21.     public String toString()\{  
22.         return Utils.bytesToHexString(Utils.int2Byte(descriptor\_idx));  
23.     \}  
24.   
25. \}

package com.wjdiankong.parsedex.struct;
    
    import com.wjdiankong.parsedex.Utils;
    
    public class TypeIdsItem {
    
        /**
         * struct type_ids_item
            {
            uint descriptor_idx;
            }
         */
    
        public int descriptor_idx;
    
        public static int getSize(){
            return 4;
        }
    
        @Override
        public String toString(){
            return Utils.bytesToHexString(Utils.int2Byte(descriptor_idx));
        }
    
    }

type\_ids\_item 里面 descriptor\_idx 的值的意思 ，是 string\_ids 里的 index 序号 ，是用来描述此type 的字符串 。

根据 header 里 type\_ids\_size = 0x07 , type\_ids\_off = 0xa8 , 找到对应的二进制描述区 。00000a0: 1a02

![Center 8][]  
根据 type\_id\_item 的描述 ，整理出表格如下 。因为 type\_id\_item - > descriptor\_idx 里存放的是指向 string\_ids 的 index 号 ，所以我们也能得到该 type 的字符串描述 。这里出现了 3 个 type descriptor :  
L 表示 class 的详细描述 ，一般以分号表示 class 描述结束 ；  
V 表示 void 返回类型 ，只有在返回值的时候有效 ；  
\[ 表示数组 ，\[Ljava/lang/String; 可以对应到 java 语言里的 java.lang.String\[\] 类型 。

![Center 9][]

我们后面的其他数据结构也会使用到type\_ids类型，所以我们这里解析完type\_ids也是需要用一个池子来存放的，后面直接用索引index来访问即可。

## **第四、proto\_ids数据结构** ##

proto 的意思是 method prototype 代表 java 语言里的一个 method 的原型 。proto\_ids 里的元素为 proto\_id\_item , 结构如下 。

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import java.util.ArrayList;  
4.  import java.util.List;  
5.    
6.  public class ProtoIdsItem \{  
7.        
8.      /\*\* 
9.       \* struct proto\_id\_item 
10.         \{  
11.         uint shorty\_idx; 
12.         uint return\_type\_idx; 
13.         uint parameters\_off; 
14.         \} 
15.      \*/  
16.       
17.     public int shorty\_idx;  
18.     public int return\_type\_idx;  
19.     public int parameters\_off;  
20.       
21.     //这个不是公共字段，而是为了存储方法原型中的参数类型名和参数个数  
22.     public List<String> parametersList = new ArrayList<String>();  
23.     public int parameterCount;  
24.       
25.     public static int getSize()\{  
26.         return 4 + 4 + 4;  
27.     \}  
28.       
29.     @Override  
30.     public String toString()\{  
31.         return “shorty\_idx:”\+shorty\_idx+“,return\_type\_idx:”\+return\_type\_idx+“,parameters\_off:”\+parameters\_off;  
32.     \}  
33.   
34. \}

package com.wjdiankong.parsedex.struct;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ProtoIdsItem {
    
        /**
         * struct proto_id_item
            {
            uint shorty_idx;
            uint return_type_idx;
            uint parameters_off;
            }
         */
    
        public int shorty_idx;
        public int return_type_idx;
        public int parameters_off;
    
        //这个不是公共字段，而是为了存储方法原型中的参数类型名和参数个数
        public List<String> parametersList = new ArrayList<String>();
        public int parameterCount;
    
        public static int getSize(){
            return 4 + 4 + 4;
        }
    
        @Override
        public String toString(){
            return "shorty_idx:"+shorty_idx+",return_type_idx:"+return_type_idx+",parameters_off:"+parameters_off;
        }
    
    }

**shorty\_idx ：**跟 type\_ids 一样 ，它的值是一个 string\_ids 的 index 号 ，最终是一个简短的字符串描述 ，用来说明该 method 原型   
**return\_type\_idx ：**它的值是一个 type\_ids 的 index 号 ，表示该 method 原型的返回值类型 。  
**parameters\_off ：**后缀 off 是 offset , 指向 method 原型的参数列表 type\_list ; 若 method 没有参数 ，值为0 。参数列表的格式是 type\_list ，结构从逻辑上如下描述 。size 表示参数的个数 ；type\_idx 是对应参数的类型 ，它的值是一个 type\_ids 的 index 号 ，跟 return\_type\_idx 是同一个品种的东西 。

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import java.util.ArrayList;  
4.  import java.util.List;  
5.    
6.  public class TypeList \{  
7.        
8.      /\*\* 
9.       \* struct type\_list 
10.         \{  
11.         uint size; 
12.         ushort type\_idx\[size\]; 
13.         \} 
14.      \*/  
15.       
16.     public int size;//参数的个数  
17.     public List<Short> type\_idx = new ArrayList<Short>();//参数的类型  
18.       
19. \}

package com.wjdiankong.parsedex.struct;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class TypeList {
    
        /**
         * struct type_list
            {
            uint size;
            ushort type_idx[size];
            }
         */
    
        public int size;//参数的个数
        public List<Short> type_idx = new ArrayList<Short>();//参数的类型
    
    }

header 里 proto\_ids\_size = 0x03 , proto\_ids\_off = 0xc4 , 它的二进制描述区如下 ：

![Center 10][]

根据 proto\_id\_item 和 type\_list 的格式 ，对照这它们的二进制部分 ，整理出表格如下 ：

![Center 11][]  
可以看出 ，有 3 个 method 原型 ，返回值都为 void ，index = 0 的没有参数传入 ，index = 1 的传入一个  
String 参数 ，index=2 的传入一个 String\[\] 类型的参数 。

**注意：**我们在这里会看到很多idx结尾的字段，这个一般都是索引值，所以我们要注意的是，区分这个索引值到底是对应的哪张表格，是字符串池，还是类型池等信息，这个如果弄混淆的话，那么解析就会出现混乱了。这个后面其他数据结构都是需要注意的。

## 第五、field\_ids数据结构 ##

filed\_ids 区里面存放的是dex 文件引用的所有的 field 。本区的元素格式是 field\_id\_item ，逻辑结构描述如

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  public class FieldIdsItem \{  
4.        
5.      /\*\* 
6.       \* struct filed\_id\_item 
7.          \{  
8.          ushort class\_idx; 
9.          ushort type\_idx; 
10.         uint name\_idx; 
11.         \} 
12.      \*/  
13.       
14.     public short class\_idx;  
15.     public short type\_idx;  
16.     public int name\_idx;  
17.       
18.     public static int getSize()\{  
19.         return 2 + 2 + 4;  
20.     \}  
21.   
22.     @Override  
23.     public String toString()\{  
24.         return “class\_idx:”\+class\_idx+“,type\_idx:”\+type\_idx+“,name\_idx:”\+name\_idx;  
25.     \}  
26.       
27. \}

package com.wjdiankong.parsedex.struct;
    
    public class FieldIdsItem {
    
        /**
         * struct filed_id_item
            {
            ushort class_idx;
            ushort type_idx;
            uint name_idx;
            }
         */
    
        public short class_idx;
        public short type_idx;
        public int name_idx;
    
        public static int getSize(){
            return 2 + 2 + 4;
        }
    
        @Override
        public String toString(){
            return "class_idx:"+class_idx+",type_idx:"+type_idx+",name_idx:"+name_idx;
        }
    
    }

**class\_idx ：**表示本 field 所属的 class 类型 , class\_idx 的值是 type\_ids 的一个 index ， 并且必须指向一个class 类型 。  
**type\_idx ：**表示本 field 的类型 ，它的值也是 type\_ids 的一个 index 。  
**name\_idx ：** 表示本 field 的名称 ，它的值是 string\_ids 的一个 index 。

header 里 field\_ids\_size = 1 , field\_ids\_off = 0xe8 。说明本 .dex 只有一个 field ，这部分的二进制描述如下 ：

![Center 12][]

**注意：**这里的字段都是索引值，一定要区分是哪个池子的索引值，还有就是，这个数据结构我们后面也要使用到，所以需要用一个池子来存储。

## 第六、 method\_ids数据结构 ##

method\_ids 是索引区的最后一个条目 ，它索引了 dex 文件里的所有的 method.  
method\_ids 的元素格式是 method\_id\_item ， 结构跟 fields\_ids 很相似：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  public class MethodIdsItem \{  
4.        
5.      /\*\* 
6.       \* struct filed\_id\_item 
7.          \{  
8.          ushort class\_idx; 
9.          ushort proto\_idx; 
10.         uint name\_idx; 
11.         \} 
12.      \*/  
13.       
14.     public short class\_idx;  
15.     public short proto\_idx;  
16.     public int name\_idx;  
17.       
18.     public static int getSize()\{  
19.         return 2 + 2 + 4;  
20.     \}  
21.       
22.     @Override  
23.     public String toString()\{  
24.         return “class\_idx:”\+class\_idx+“,proto\_idx:”\+proto\_idx+“,name\_idx:”\+name\_idx;  
25.     \}  
26.   
27. \}

package com.wjdiankong.parsedex.struct;
    
    public class MethodIdsItem {
    
        /**
         * struct filed_id_item
            {
            ushort class_idx;
            ushort proto_idx;
            uint name_idx;
            }
         */
    
        public short class_idx;
        public short proto_idx;
        public int name_idx;
    
        public static int getSize(){
            return 2 + 2 + 4;
        }
    
        @Override
        public String toString(){
            return "class_idx:"+class_idx+",proto_idx:"+proto_idx+",name_idx:"+name_idx;
        }
    
    }

**class\_idx ：**表示本 method 所属的 class 类型 , class\_idx 的值是 type\_ids 的一个 index ， 并且必须指向一个 class 类型 。  
**name\_idx ：**表示本 method 的名称 ，它的值是 string\_ids 的一个 index 。  
**proto\_idx ：**描述该 method 的原型 ，指向 proto\_ids 的一个 index 。  
header 里 method\_ids\_size = 0x04 , method\_ids\_off = 0xf0 。本部分的二进制描述如下 ：

![Center 13][]

对 dex 反汇编的时候 ，常用的 method 表示方法是这种形式 :  
**Lpackage/name/ObjectName;->MethodName(III)Z**  
将上述表格里的字符串再次整理下 ，method 的描述分别为 ：  
0：Lhello; -> <init>()V  
1：LHello; -> main(\[Ljava/lang/String;)V  
2：Ljava/io/PrintStream; -> println(Ljava/lang/String;)V  
3： Ljava/lang/Object; -> <init>()V  
至此 ，索引区的内容描述完毕 ，包括 string\_ids , type\_ids，proto\_ids , field\_ids , method\_ids 。每个索引区域里存放着指向具体数据的偏移地址 （如 string\_ids ) ， 或者存放的数据是其它索引区域里面的 index 号。

**注意：**这里的字段都是索引值，一定要区分是哪个池子的索引值，还有就是，这个数据结构我们后面也要使用到，所以需要用一个池子来存储。

## 第八、class\_defs数据结构 ##

上面我们介绍了所有的索引区域，终于到了最后一个数据结构了，但是我们现在还不能开心，因为这个数据结构是最复杂的，所以解析下来还是很费劲的。因为他的层次太深了。

**1、class\_def\_item**  
从字面意思解释 ，class\_defs 区域里存放着 class definitions , class 的定义 。它的结构较 dex 区都要复杂些 ,因为有些数据都直接指向了data 区里面 。  
class\_defs 的数据格式为 class\_def\_item ， 结构描述如下 ：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  public class ClassDefItem \{  
4.        
5.      /\*\* 
6.       \* struct class\_def\_item 
7.          \{  
8.          uint class\_idx; 
9.          uint access\_flags; 
10.         uint superclass\_idx; 
11.         uint interfaces\_off; 
12.         uint source\_file\_idx; 
13.         uint annotations\_off; 
14.         uint class\_data\_off; 
15.         uint static\_value\_off; 
16.         \} 
17.      \*/  
18.       
19.     public int class\_idx;  
20.     public int access\_flags;  
21.     public int superclass\_idx;  
22.     public int iterfaces\_off;  
23.     public int source\_file\_idx;  
24.     public int annotations\_off;  
25.     public int class\_data\_off;  
26.     public int static\_value\_off;  
27.       
28.     public final static int   
29.             ACC\_PUBLIC       = 0x00000001,       // class, field, method, ic  
30.             ACC\_PRIVATE      = 0x00000002,       // field, method, ic  
31.             ACC\_PROTECTED    = 0x00000004,       // field, method, ic  
32.             ACC\_STATIC       = 0x00000008,       // field, method, ic  
33.             ACC\_FINAL        = 0x00000010,       // class, field, method, ic  
34.             ACC\_SYNCHRONIZED = 0x00000020,       // method (only allowed on natives)  
35.             ACC\_SUPER        = 0x00000020,       // class (not used in Dalvik)  
36.             ACC\_VOLATILE     = 0x00000040,       // field  
37.             ACC\_BRIDGE       = 0x00000040,       // method (1.5)  
38.             ACC\_TRANSIENT    = 0x00000080,       // field  
39.             ACC\_VARARGS      = 0x00000080,       // method (1.5)  
40.             ACC\_NATIVE       = 0x00000100,       // method  
41.             ACC\_INTERFACE    = 0x00000200,       // class, ic  
42.             ACC\_ABSTRACT     = 0x00000400,       // class, method, ic  
43.             ACC\_STRICT       = 0x00000800,       // method  
44.             ACC\_SYNTHETIC    = 0x00001000,       // field, method, ic  
45.             ACC\_ANNOTATION   = 0x00002000,       // class, ic (1.5)  
46.             ACC\_ENUM         = 0x00004000,       // class, field, ic (1.5)  
47.             ACC\_CONSTRUCTOR  = 0x00010000,       // method (Dalvik only)  
48.             ACC\_DECLARED\_SYNCHRONIZED = 0x00020000,       // method (Dalvik only)  
49.             ACC\_CLASS\_MASK =  
50.             (ACC\_PUBLIC | ACC\_FINAL | ACC\_INTERFACE | ACC\_ABSTRACT  
51.                     | ACC\_SYNTHETIC | ACC\_ANNOTATION | ACC\_ENUM),  
52.                     ACC\_INNER\_CLASS\_MASK =  
53.                     (ACC\_CLASS\_MASK | ACC\_PRIVATE | ACC\_PROTECTED | ACC\_STATIC),  
54.                     ACC\_FIELD\_MASK =  
55.                     (ACC\_PUBLIC | ACC\_PRIVATE | ACC\_PROTECTED | ACC\_STATIC | ACC\_FINAL  
56.                             | ACC\_VOLATILE | ACC\_TRANSIENT | ACC\_SYNTHETIC | ACC\_ENUM),  
57.                             ACC\_METHOD\_MASK =  
58.                             (ACC\_PUBLIC | ACC\_PRIVATE | ACC\_PROTECTED | ACC\_STATIC | ACC\_FINAL  
59.                                     | ACC\_SYNCHRONIZED | ACC\_BRIDGE | ACC\_VARARGS | ACC\_NATIVE  
60.                                     | ACC\_ABSTRACT | ACC\_STRICT | ACC\_SYNTHETIC | ACC\_CONSTRUCTOR  
61.                                     | ACC\_DECLARED\_SYNCHRONIZED);  
62.       
63.     public static int getSize()\{  
64.         return 4 \* 8;  
65.     \}  
66.       
67.     @Override  
68.     public String toString()\{  
69.         return “class\_idx:”\+class\_idx+“,access\_flags:”\+access\_flags+“,superclass\_idx:”\+superclass\_idx+“,iterfaces\_off:”\+iterfaces\_off  
70.                 +”,source\_file\_idx:”\+source\_file\_idx+“,annotations\_off:”\+annotations\_off+“,class\_data\_off:”\+class\_data\_off  
71.                 +”,static\_value\_off:”\+static\_value\_off;  
72.     \}  
73.   
74. \}

package com.wjdiankong.parsedex.struct;
    
    public class ClassDefItem {
    
        /**
         * struct class_def_item
            {
            uint class_idx;
            uint access_flags;
            uint superclass_idx;
            uint interfaces_off;
            uint source_file_idx;
            uint annotations_off;
            uint class_data_off;
            uint static_value_off;
            }
         */
    
        public int class_idx;
        public int access_flags;
        public int superclass_idx;
        public int iterfaces_off;
        public int source_file_idx;
        public int annotations_off;
        public int class_data_off;
        public int static_value_off;
    
        public final static int 
                ACC_PUBLIC       = 0x00000001,       // class, field, method, ic
                ACC_PRIVATE      = 0x00000002,       // field, method, ic
                ACC_PROTECTED    = 0x00000004,       // field, method, ic
                ACC_STATIC       = 0x00000008,       // field, method, ic
                ACC_FINAL        = 0x00000010,       // class, field, method, ic
                ACC_SYNCHRONIZED = 0x00000020,       // method (only allowed on natives)
                ACC_SUPER        = 0x00000020,       // class (not used in Dalvik)
                ACC_VOLATILE     = 0x00000040,       // field
                ACC_BRIDGE       = 0x00000040,       // method (1.5)
                ACC_TRANSIENT    = 0x00000080,       // field
                ACC_VARARGS      = 0x00000080,       // method (1.5)
                ACC_NATIVE       = 0x00000100,       // method
                ACC_INTERFACE    = 0x00000200,       // class, ic
                ACC_ABSTRACT     = 0x00000400,       // class, method, ic
                ACC_STRICT       = 0x00000800,       // method
                ACC_SYNTHETIC    = 0x00001000,       // field, method, ic
                ACC_ANNOTATION   = 0x00002000,       // class, ic (1.5)
                ACC_ENUM         = 0x00004000,       // class, field, ic (1.5)
                ACC_CONSTRUCTOR  = 0x00010000,       // method (Dalvik only)
                ACC_DECLARED_SYNCHRONIZED = 0x00020000,       // method (Dalvik only)
                ACC_CLASS_MASK =
                (ACC_PUBLIC | ACC_FINAL | ACC_INTERFACE | ACC_ABSTRACT
                        | ACC_SYNTHETIC | ACC_ANNOTATION | ACC_ENUM),
                        ACC_INNER_CLASS_MASK =
                        (ACC_CLASS_MASK | ACC_PRIVATE | ACC_PROTECTED | ACC_STATIC),
                        ACC_FIELD_MASK =
                        (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED | ACC_STATIC | ACC_FINAL
                                | ACC_VOLATILE | ACC_TRANSIENT | ACC_SYNTHETIC | ACC_ENUM),
                                ACC_METHOD_MASK =
                                (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED | ACC_STATIC | ACC_FINAL
                                        | ACC_SYNCHRONIZED | ACC_BRIDGE | ACC_VARARGS | ACC_NATIVE
                                        | ACC_ABSTRACT | ACC_STRICT | ACC_SYNTHETIC | ACC_CONSTRUCTOR
                                        | ACC_DECLARED_SYNCHRONIZED);
    
        public static int getSize(){
            return 4 * 8;
        }
    
        @Override
        public String toString(){
            return "class_idx:"+class_idx+",access_flags:"+access_flags+",superclass_idx:"+superclass_idx+",iterfaces_off:"+iterfaces_off
                    +",source_file_idx:"+source_file_idx+",annotations_off:"+annotations_off+",class_data_off:"+class_data_off
                    +",static_value_off:"+static_value_off;
        }
    
    }

**(1) class\_idx：**描述具体的 class 类型 ，值是 type\_ids 的一个 index 。值必须是一个 class 类型 ，不能是数组类型或者基本类型 。  
**(2) access\_flags：** 描述 class 的访问类型 ，诸如 public , final , static 等 。在 dex-format.html 里 “access\_flagsDefinitions” 有具体的描述 。  
**(3) superclass\_idx：**描述 supperclass 的类型 ，值的形式跟 class\_idx 一样 。  
**(4) interfaces\_off：**值为偏移地址 ，指向 class 的 interfaces , 被指向的数据结构为 type\_list 。class 若没有interfaces ,值为 0。  
**(5) source\_file\_idx：**表示源代码文件的信息 ，值是 string\_ids 的一个 index 。若此项信息缺失 ，此项值赋值为NO\_INDEX=0xffff ffff   
**(6) annotions\_off：**值是一个偏移地址 ，指向的内容是该 class 的注释 ，位置在 data 区，格式为annotations\_direcotry\_item 。若没有此项内容 ，值为 0 。  
**(7) class\_data\_off：**值是一个偏移地址 ，指向的内容是该 class 的使用到的数据 ，位置在 data 区，格式为class\_data\_item 。若没有此项内容 ，值为 0 。该结构里有很多内容 ，详细描述该 class 的 field ，method, method 里的执行代码等信息 ，后面有一个比较大的篇幅来讲述 class\_data\_item 。  
**(8) static\_value\_off：**值是一个偏移地址 ，指向 data 区里的一个列表 ( list ) ，格式为 encoded\_array\_item。若没有此项内容 ，值为 0 。

header 里 class\_defs\_size = 0x01 , class\_defs\_off = 0x 0110 。则此段二进制描述为 ：

![Center 14][]  
  
其实最初被编译的源码只有几行 ，和 class\_def\_item 的表格对照下 ，一目了然 。  
source file : Hello.java  
public class Hello  
\{  
element value associated strinigs  
class\_idx 0x00 LHello;  
access\_flags 0x01 ACC\_PUBLIC  
superclass\_idx 0x02 Ljava/lang/Object;  
interface\_off 0x00  
source\_file\_idx 0x02 Hello.java  
annotations\_off 0x00  
class\_data\_off 0x0234  
static\_value\_off 0x00  
  
public static void main(String\[\] argc)  
\{  
System.out.println(“Hello, Android!\\n”);  
\}  
\}

**2、 class\_def\_item => class\_data\_item**  
class\_data\_off 指向 data 区里的 class\_data\_item 结构 ,class\_data\_item 里存放着本 class 使用到的各种数据 ，下面是 class\_data\_item 的逻辑结构 ：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  public class ClassDataItem \{  
4.        
5.      /\*\* 
6.       \*  uleb128 unsigned little-endian base 128 
7.          struct class\_data\_item 
8.          \{  
9.              uleb128 static\_fields\_size; 
10.             uleb128 instance\_fields\_size; 
11.             uleb128 direct\_methods\_size; 
12.             uleb128 virtual\_methods\_size; 
13.             encoded\_field static\_fields \[ static\_fields\_size \]; 
14.             encoded\_field instance\_fields \[ instance\_fields\_size \]; 
15.             encoded\_method direct\_methods \[ direct\_method\_size \]; 
16.             encoded\_method virtual\_methods \[ virtual\_methods\_size \]; 
17.         \} 
18.      \*/  
19.       
20.     //uleb128只用来编码32位的整型数  
21.     public int static\_fields\_size;  
22.     public int instance\_fields\_size;  
23.     public int direct\_methods\_size;  
24.     public int virtual\_methods\_size;  
25.       
26.     public EncodedField\[\] static\_fields;  
27.     public EncodedField\[\] instance\_fields;  
28.     public EncodedMethod\[\] direct\_methods;  
29.     public EncodedMethod\[\] virtual\_methods;  
30.       
31.     @Override  
32.     public String toString()\{  
33.         return “static\_fields\_size:”\+static\_fields\_size+“,instance\_fields\_size:”  
34.                 +instance\_fields\_size+”,direct\_methods\_size:”\+direct\_methods\_size+“,virtual\_methods\_size:”\+virtual\_methods\_size  
35.                 +”\\n”\+getFieldsAndMethods();  
36.     \}  
37.       
38.     private String getFieldsAndMethods()\{  
39.         StringBuilder sb = new StringBuilder();  
40.         sb.append(”static\_fields:\\n”);  
41.         for(int i=0;i<static\_fields.length;i++)\{  
42.             sb.append(static\_fields\[i\]+”\\n”);  
43.         \}  
44.         sb.append(”instance\_fields:\\n”);  
45.         for(int i=0;i<instance\_fields.length;i++)\{  
46.             sb.append(instance\_fields\[i\]+”\\n”);  
47.         \}  
48.         sb.append(”direct\_methods:\\n”);  
49.         for(int i=0;i<direct\_methods.length;i++)\{  
50.             sb.append(direct\_methods\[i\]+”\\n”);  
51.         \}  
52.         sb.append(”virtual\_methods:\\n”);  
53.         for(int i=0;i<virtual\_methods.length;i++)\{  
54.             sb.append(virtual\_methods\[i\]+”\\n”);  
55.         \}  
56.         return sb.toString();  
57.     \}  
58.   
59. \}

package com.wjdiankong.parsedex.struct;
    
    public class ClassDataItem {
    
        /**
         *  uleb128 unsigned little-endian base 128
            struct class_data_item
            {
                uleb128 static_fields_size;
                uleb128 instance_fields_size;
                uleb128 direct_methods_size;
                uleb128 virtual_methods_size;
                encoded_field static_fields [ static_fields_size ];
                encoded_field instance_fields [ instance_fields_size ];
                encoded_method direct_methods [ direct_method_size ];
                encoded_method virtual_methods [ virtual_methods_size ];
            }
         */
    
        //uleb128只用来编码32位的整型数
        public int static_fields_size;
        public int instance_fields_size;
        public int direct_methods_size;
        public int virtual_methods_size;
    
        public EncodedField[] static_fields;
        public EncodedField[] instance_fields;
        public EncodedMethod[] direct_methods;
        public EncodedMethod[] virtual_methods;
    
        @Override
        public String toString(){
            return "static_fields_size:"+static_fields_size+",instance_fields_size:"
                    +instance_fields_size+",direct_methods_size:"+direct_methods_size+",virtual_methods_size:"+virtual_methods_size
                    +"\n"+getFieldsAndMethods();
        }
    
        private String getFieldsAndMethods(){
            StringBuilder sb = new StringBuilder();
            sb.append("static_fields:\n");
            for(int i=0;i<static_fields.length;i++){
                sb.append(static_fields[i]+"\n");
            }
            sb.append("instance_fields:\n");
            for(int i=0;i<instance_fields.length;i++){
                sb.append(instance_fields[i]+"\n");
            }
            sb.append("direct_methods:\n");
            for(int i=0;i<direct_methods.length;i++){
                sb.append(direct_methods[i]+"\n");
            }
            sb.append("virtual_methods:\n");
            for(int i=0;i<virtual_methods.length;i++){
                sb.append(virtual_methods[i]+"\n");
            }
            return sb.toString();
        }
    
    }

关于元素的格式 uleb128 在 string\_ids 里有讲述过 ，不赘述 。  
encoded\_field 的结构如下 ：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import com.wjdiankong.parsedex.Utils;  
4.    
5.  public class EncodedField \{  
6.        
7.      /\*\* 
8.       \* struct encoded\_field 
9.          \{  
10.             uleb128 filed\_idx\_diff; // index into filed\_ids for ID of this filed 
11.             uleb128 access\_flags; // access flags like public, static etc. 
12.         \} 
13.      \*/  
14.     public byte\[\] filed\_idx\_diff;  
15.     public byte\[\] access\_flags;  
16.       
17.     @Override  
18.     public String toString()\{  
19.         return “field\_idx\_diff:”\+Utils.bytesToHexString(filed\_idx\_diff) + “,access\_flags:”\+Utils.bytesToHexString(filed\_idx\_diff);  
20.     \}  
21.   
22. \}

package com.wjdiankong.parsedex.struct;
    
    import com.wjdiankong.parsedex.Utils;
    
    public class EncodedField {
    
        /**
         * struct encoded_field
            {
                uleb128 filed_idx_diff; // index into filed_ids for ID of this filed
                uleb128 access_flags; // access flags like public, static etc.
            }
         */
        public byte[] filed_idx_diff;
        public byte[] access_flags;
    
        @Override
        public String toString(){
            return "field_idx_diff:"+Utils.bytesToHexString(filed_idx_diff) + ",access_flags:"+Utils.bytesToHexString(filed_idx_diff);
        }
    
    }

encoded\_method 的结构如下 ：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import com.wjdiankong.parsedex.Utils;  
4.    
5.  public class EncodedMethod \{  
6.        
7.      /\*\* 
8.       \* struct encoded\_method 
9.          \{  
10.             uleb128 method\_idx\_diff; 
11.             uleb128 access\_flags; 
12.             uleb128 code\_off; 
13.         \} 
14.      \*/  
15.       
16.     public byte\[\] method\_idx\_diff;  
17.     public byte\[\] access\_flags;  
18.     public byte\[\] code\_off;  
19.       
20.     @Override  
21.     public String toString()\{  
22.         return “method\_idx\_diff:”\+Utils.bytesToHexString(method\_idx\_diff)+“,”\+Utils.bytesToHexString(Utils.int2Byte(Utils.decodeUleb128(method\_idx\_diff)))  
23.                 +”,access\_flags:”\+Utils.bytesToHexString(access\_flags)+“,”\+Utils.bytesToHexString(Utils.int2Byte(Utils.decodeUleb128(access\_flags)))  
24.                 +”,code\_off:”\+Utils.bytesToHexString(code\_off)+“,”\+Utils.bytesToHexString(Utils.int2Byte(Utils.decodeUleb128(code\_off)));  
25.     \}  
26.   
27. \}

package com.wjdiankong.parsedex.struct;
    
    import com.wjdiankong.parsedex.Utils;
    
    public class EncodedMethod {
    
        /**
         * struct encoded_method
            {
                uleb128 method_idx_diff;
                uleb128 access_flags;
                uleb128 code_off;
            }
         */
    
        public byte[] method_idx_diff;
        public byte[] access_flags;
        public byte[] code_off;
    
        @Override
        public String toString(){
            return "method_idx_diff:"+Utils.bytesToHexString(method_idx_diff)+","+Utils.bytesToHexString(Utils.int2Byte(Utils.decodeUleb128(method_idx_diff)))
                    +",access_flags:"+Utils.bytesToHexString(access_flags)+","+Utils.bytesToHexString(Utils.int2Byte(Utils.decodeUleb128(access_flags)))
                    +",code_off:"+Utils.bytesToHexString(code_off)+","+Utils.bytesToHexString(Utils.int2Byte(Utils.decodeUleb128(code_off)));
        }
    
    }

**(1) method\_idx\_diff：**前缀 methd\_idx 表示它的值是 method\_ids 的一个 index ，后缀 \_diff 表示它是于另外一个 method\_idx 的一个差值 ，就是相对于 encodeed\_method \[\] 数组里上一个元素的 method\_idx 的差值 。其实 encoded\_filed - > field\_idx\_diff 表示的也是相同的意思 ，只是编译出来的 Hello.dex 文件里没有使用到class filed 所以没有仔细讲 ，详细的参考 dex\_format.html 的官网文档   
**(2) access\_flags：**访问权限 ， 比如 public、private、static、final 等 。  
**(3) code\_off：**一个指向 data 区的偏移地址 ，目标是本 method 的代码实现 。被指向的结构是  
code\_item ，有近 10 项元素 ，后面再详细解释 。  
class\_def\_item – > class\_data\_off = 0x 0234 。  
![Center 15][]  
名称为 LHello; 的 class 里只有 2 个 directive methods 。 directive\_methods 里的值都是 uleb128 的原始二  
进制值 。按照 directive\_methods 的格式 encoded\_method 再整理一次这 2 个 method 描述 ，得到结果如下  
表格所描述 ：

![Center 16][]

method 一个是 <init> , 一个是 main ， 这里我们需要用我们在string\_ids那块介绍到的一个方法就是解码uleb125类型的方法得到正确的value值。

**3、class\_def\_item => class\_data\_item => code\_item**  
到这里 ，逻辑的描述有点深入了 。我自己都有点分析不过来 ，先理一下是怎么走到这一步的 ，code\_item  
在 dex 里处于一个什么位置 。  
(1) 一个 .dex 文件被分成了 9 个区 ，详细见 “1. dex 整个文件的布局 ” 。其中有一个索引区叫做  
class\_defs ， 索引了 .dex 里面用到的 class ，以及对这个 class 的描述 。  
(2) class\_defs 区 ， 这里面其实是class\_def\_item 结构 。这个结构里描述了 LHello; 的各种信息 ，诸如名称 ，superclass , access flag， interface 等 。class\_def\_item 里有一个元素 class\_data\_off , 指向data 区里的一个 class\_data\_item 结构 ，用来描述 class 使用到的各种数据 。自此以后的结构都归于 data区了 。  
(3) class\_data\_item 结构 ，里描述值着 class 里使用到的 static field , instance field , direct\_method ，和 virtual\_method 的数目和描述 。例子 Hello.dex 里 ，只有 2 个 direct\_method , 其余的 field 和method 的数目都为 0 。描述 direct\_method 的结构叫做 encoded\_method ，是用来详细描述某个 method的 。  
(4) encoded\_method 结构 ，描述某个 method 的 method 类型 ， access flags 和一个指向 code\_item的偏移地址 ，里面存放的是该 method 的具体实现 。  
(5) code\_item ， 一层又一层 ，盗梦空间啊！简要的说 ，code\_item 结构里描述着某个 method 的具体实现 。它的结构如下描述 ：

**\[java\]** view plain copy

print ?

1.  package com.wjdiankong.parsedex.struct;  
2.    
3.  import com.wjdiankong.parsedex.Utils;  
4.    
5.  public class CodeItem \{  
6.        
7.      /\*\* 
8.       \* struct code\_item 
9.          \{  
10.             ushort registers\_size; 
11.             ushort ins\_size; 
12.             ushort outs\_size; 
13.             ushort tries\_size; 
14.             uint debug\_info\_off; 
15.             uint insns\_size; 
16.             ushort insns \[ insns\_size \]; 
17.             ushort paddding; // optional 
18.             try\_item tries \[ tyies\_size \]; // optional 
19.             encoded\_catch\_handler\_list handlers; // optional 
20.         \} 
21.      \*/  
22.       
23.     public short registers\_size;  
24.     public short ins\_size;  
25.     public short outs\_size;  
26.     public short tries\_size;  
27.     public int debug\_info\_off;  
28.     public int insns\_size;  
29.     public short\[\] insns;  
30.       
31.     @Override  
32.     public String toString()\{  
33.         return “regsize:”\+registers\_size+“,ins\_size:”\+ins\_size  
34.                 +”,outs\_size:”\+outs\_size+“,tries\_size:”\+tries\_size+“,debug\_info\_off:”\+debug\_info\_off  
35.                 +”,insns\_size:”\+insns\_size + “\\ninsns:”\+getInsnsStr();  
36.     \}  
37.       
38.     private String getInsnsStr()\{  
39.         StringBuilder sb = new StringBuilder();  
40.         for(int i=0;i<insns.length;i++)\{  
41.             sb.append(Utils.bytesToHexString(Utils.short2Byte(insns\[i\]))+”,”);  
42.         \}  
43.         return sb.toString();  
44.     \}  
45.       
46. \}

package com.wjdiankong.parsedex.struct;
    
    import com.wjdiankong.parsedex.Utils;
    
    public class CodeItem {
    
        /**
         * struct code_item
            {
                ushort registers_size;
                ushort ins_size;
                ushort outs_size;
                ushort tries_size;
                uint debug_info_off;
                uint insns_size;
                ushort insns [ insns_size ];
                ushort paddding; // optional
                try_item tries [ tyies_size ]; // optional
                encoded_catch_handler_list handlers; // optional
            }
         */
    
        public short registers_size;
        public short ins_size;
        public short outs_size;
        public short tries_size;
        public int debug_info_off;
        public int insns_size;
        public short[] insns;
    
        @Override
        public String toString(){
            return "regsize:"+registers_size+",ins_size:"+ins_size
                    +",outs_size:"+outs_size+",tries_size:"+tries_size+",debug_info_off:"+debug_info_off
                    +",insns_size:"+insns_size + "\ninsns:"+getInsnsStr();
        }
    
        private String getInsnsStr(){
            StringBuilder sb = new StringBuilder();
            for(int i=0;i<insns.length;i++){
                sb.append(Utils.bytesToHexString(Utils.short2Byte(insns[i]))+",");
            }
            return sb.toString();
        }
    
    }

末尾的 3 项标志为 optional , 表示可能有 ，也可能没有 ，根据具体的代码来 。  
**(1) registers\_size：**本段代码使用到的寄存器数目。  
**(2) ins\_size：**method传入参数的数目 。  
( **3) outs\_size：** 本段代码调用其它method 时需要的参数个数 。  
**(4) tries\_size：** try\_item 结构的个数 。  
**(5) debug\_off：**偏移地址 ，指向本段代码的 debug 信息存放位置 ，是一个 debug\_info\_item 结构。  
**(6) insns\_size：**指令列表的大小 ，以 16-bit 为单位 。 insns 是 instructions 的缩写 。  
**(7) padding：**值为 0 ，用于对齐字节 。  
**(8) tries 和 handlers：**用于处理 java 中的 exception , 常见的语法有 try catch 。

**4、 分析 main method 的执行代码并与 smali 反编译的结果比较**  
在 8.2 节里有 2 个 method , 因为 main 里的执行代码是自己写的 ，分析它会熟悉很多 。偏移地址是  
directive\_method \[1\] -> code\_off = 0x0148 ，二进制描述如下 ：  
![Center 17][]  
insns 数组里的 8 个二进制原始数据 ， 对这些数据的解析 ，需要对照官网的文档 《Dalvik VM Instruction  
Format》和《Bytecode for Dalvik VM》。  
分析思路整理如下  
(1) 《Dalvik VM Instruction Format》 里操作符 op 都是位于首个 16bit 数据的低 8 bit ，起始的是 op =0x62。  
(2) 在 《Bytecode for Dalvik VM》 里找到对应的 Syntax 和 format 。  
syntax = sget\_object  
format = 0x21c 。  
(3） 在《Dalvik VM Instruction Format》里查找 21c ， 得知 op = 0x62 的指令占据 2 个 16 bit 数据 ，格式是 AA|op BBBB ，解释为 op vAA, type@BBBB 。因此这 8 组 16 bit 数据里 ，前 2 个是一组 。对比数据得 AA=0x00, BBBB = 0x0000。  
(4)返回《Bytecode for Dalvik VM》里查阅对 sget\_object 的解释， AA 的值表示 Value Register ，即0 号寄存器； BBBB 表示 static field 的 index ，就是之前分析的field\_ids 区里 Index = 0 指向的那个东西 ，当时的 fields\_ids 的分析结果如下 ：  
![Center 18][]  
对 field 常用的表述是  
包含 field 的类型 -> field 名称 ：field 类型 。  
此次指向的就是 Ljava/lang/System; -> out:Ljava/io/printStream;  
(5) 综上 ，前 2 个 16 bit 数据 0x 0062 0000 , 解释为  
sget\_object v0, Ljava/lang/System; -> out:Ljava/io/printStream;  
其余的 6 个 16 bit 数据分析思路跟这个一样 ，依次整理如下 ：  
**0x011a 0x0001:** const-string v1, “Hello, Android!”

**0x206e 0x0002 0x0010:**

**invoke-virtual \{v0, v1\}, Ljava/io/PrintStream; -> println(Ljava/lang/String;)V**

**0x000e: return-void**  
(6) 最后再整理下 main method , 用容易理解的方式表示出来就是 。  
ACC\_PUBLIC ACC\_STATIC LHello;->main(\[Ljava/lang/String;)V  
\{  
sget\_object v0, Ljava/lang/System; -> out:Ljava/io/printStream;  
const-string v1,Hello, Android!  
invoke-virtual \{v0, v1\}, Ljava/io/PrintStream; -> println(Ljava/lang/String;)V  
return-void  
\}  
看起来很像 smali 格式语言 ，不妨使用 smali 反编译下 Hello.dex , 看看 smali 生成的代码跟方才推导出  
来的有什么差异 。  
.method public static main(\[Ljava/lang/String;)V  
.registers 3  
.prologue  
.line 5  
sget-object v0, Ljava/lang/System;->out:Ljava/io/PrintStream;  
const-string v1, “Hello, Android!\\n”  
index 0  
class\_idx 0x04  
type\_idx 0x01  
name\_idx 0x0c  
class string Ljava/lang/System;  
type string Ljava/io/PrintStream;  
name string out  
invoke-virtual \{v0, v1\}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V  
.line 6  
return-void  
从内容上看 ，二者形式上有些差异 ，但表述的是同一个 method 。这说明刚才的分析走的路子是没有跑偏  
的 。另外一个 method 是 <init> , 若是分析的话 ，思路和流程跟 main 一样 。走到这里，心里很踏实了。

# 四、解析代码 #

上面我们解析完了所有的数据结构区域，下面就来看看具体的解析代码，由于篇幅的原因，这里就不贴出全部的代码了，只贴出核心的代码：

## **1、解析头部信息：** ##

**\[java\]** view plain copy

print ?

1.  public static void praseDexHeader(byte\[\] byteSrc)\{  
2.      HeaderType headerType = new HeaderType();  
3.      //解析魔数  
4.      byte\[\] magic = Utils.copyByte(byteSrc, 0, 8);  
5.      headerType.magic = magic;  
6.    
7.      //解析checksum  
8.      byte\[\] checksumByte = Utils.copyByte(byteSrc, 8, 4);  
9.      headerType.checksum = Utils.byte2int(checksumByte);  
10.   
11.     //解析siganature  
12.     byte\[\] siganature = Utils.copyByte(byteSrc, 12, 20);  
13.     headerType.siganature = siganature;  
14.   
15.     //解析file\_size  
16.     byte\[\] fileSizeByte = Utils.copyByte(byteSrc, 32, 4);  
17.     headerType.file\_size = Utils.byte2int(fileSizeByte);  
18.   
19.     //解析header\_size  
20.     byte\[\] headerSizeByte = Utils.copyByte(byteSrc, 36, 4);  
21.     headerType.header\_size = Utils.byte2int(headerSizeByte);  
22.   
23.     //解析endian\_tag  
24.     byte\[\] endianTagByte = Utils.copyByte(byteSrc, 40, 4);  
25.     headerType.endian\_tag = Utils.byte2int(endianTagByte);  
26.   
27.     //解析link\_size  
28.     byte\[\] linkSizeByte = Utils.copyByte(byteSrc, 44, 4);  
29.     headerType.link\_size = Utils.byte2int(linkSizeByte);  
30.   
31.     //解析link\_off  
32.     byte\[\] linkOffByte = Utils.copyByte(byteSrc, 48, 4);  
33.     headerType.link\_off = Utils.byte2int(linkOffByte);  
34.   
35.     //解析map\_off  
36.     byte\[\] mapOffByte = Utils.copyByte(byteSrc, 52, 4);  
37.     headerType.map\_off = Utils.byte2int(mapOffByte);  
38.   
39.     //解析string\_ids\_size  
40.     byte\[\] stringIdsSizeByte = Utils.copyByte(byteSrc, 56, 4);  
41.     headerType.string\_ids\_size = Utils.byte2int(stringIdsSizeByte);  
42.   
43.     //解析string\_ids\_off  
44.     byte\[\] stringIdsOffByte = Utils.copyByte(byteSrc, 60, 4);  
45.     headerType.string\_ids\_off = Utils.byte2int(stringIdsOffByte);  
46.   
47.     //解析type\_ids\_size  
48.     byte\[\] typeIdsSizeByte = Utils.copyByte(byteSrc, 64, 4);  
49.     headerType.type\_ids\_size = Utils.byte2int(typeIdsSizeByte);  
50.   
51.     //解析type\_ids\_off  
52.     byte\[\] typeIdsOffByte = Utils.copyByte(byteSrc, 68, 4);  
53.     headerType.type\_ids\_off = Utils.byte2int(typeIdsOffByte);  
54.   
55.     //解析proto\_ids\_size  
56.     byte\[\] protoIdsSizeByte = Utils.copyByte(byteSrc, 72, 4);  
57.     headerType.proto\_ids\_size = Utils.byte2int(protoIdsSizeByte);  
58.   
59.     //解析proto\_ids\_off  
60.     byte\[\] protoIdsOffByte = Utils.copyByte(byteSrc, 76, 4);  
61.     headerType.proto\_ids\_off = Utils.byte2int(protoIdsOffByte);  
62.   
63.     //解析field\_ids\_size  
64.     byte\[\] fieldIdsSizeByte = Utils.copyByte(byteSrc, 80, 4);  
65.     headerType.field\_ids\_size = Utils.byte2int(fieldIdsSizeByte);  
66.   
67.     //解析field\_ids\_off  
68.     byte\[\] fieldIdsOffByte = Utils.copyByte(byteSrc, 84, 4);  
69.     headerType.field\_ids\_off = Utils.byte2int(fieldIdsOffByte);  
70.   
71.     //解析method\_ids\_size  
72.     byte\[\] methodIdsSizeByte = Utils.copyByte(byteSrc, 88, 4);  
73.     headerType.method\_ids\_size = Utils.byte2int(methodIdsSizeByte);  
74.   
75.     //解析method\_ids\_off  
76.     byte\[\] methodIdsOffByte = Utils.copyByte(byteSrc, 92, 4);  
77.     headerType.method\_ids\_off = Utils.byte2int(methodIdsOffByte);  
78.   
79.     //解析class\_defs\_size  
80.     byte\[\] classDefsSizeByte = Utils.copyByte(byteSrc, 96, 4);  
81.     headerType.class\_defs\_size = Utils.byte2int(classDefsSizeByte);  
82.   
83.     //解析class\_defs\_off  
84.     byte\[\] classDefsOffByte = Utils.copyByte(byteSrc, 100, 4);  
85.     headerType.class\_defs\_off = Utils.byte2int(classDefsOffByte);  
86.   
87.     //解析data\_size  
88.     byte\[\] dataSizeByte = Utils.copyByte(byteSrc, 104, 4);  
89.     headerType.data\_size = Utils.byte2int(dataSizeByte);  
90.   
91.     //解析data\_off  
92.     byte\[\] dataOffByte = Utils.copyByte(byteSrc, 108, 4);  
93.     headerType.data\_off = Utils.byte2int(dataOffByte);  
94.   
95.     System.out.println(”header:”\+headerType);  
96.   
97.     stringIdOffset = headerType.header\_size;//header之后就是string ids  
98.   
99.     stringIdsSize = headerType.string\_ids\_size;  
100.     stringIdsOffset = headerType.string\_ids\_off;  
101.     typeIdsSize = headerType.type\_ids\_size;  
102.     typeIdsOffset = headerType.type\_ids\_off;  
103.     fieldIdsSize = headerType.field\_ids\_size;  
104.     fieldIdsOffset = headerType.field\_ids\_off;  
105.     protoIdsSize = headerType.proto\_ids\_size;  
106.     protoIdsOffset = headerType.proto\_ids\_off;  
107.     methodIdsSize = headerType.method\_ids\_size;  
108.     methodIdsOffset = headerType.method\_ids\_off;  
109.     classIdsSize = headerType.class\_defs\_size;  
110.     classIdsOffset = headerType.class\_defs\_off;  
111.   
112.     mapListOffset = headerType.map\_off;  
113.   
114. \}

public static void praseDexHeader(byte[] byteSrc){
        HeaderType headerType = new HeaderType();
        //解析魔数
        byte[] magic = Utils.copyByte(byteSrc, 0, 8);
        headerType.magic = magic;
    
        //解析checksum
        byte[] checksumByte = Utils.copyByte(byteSrc, 8, 4);
        headerType.checksum = Utils.byte2int(checksumByte);
    
        //解析siganature
        byte[] siganature = Utils.copyByte(byteSrc, 12, 20);
        headerType.siganature = siganature;
    
        //解析file_size
        byte[] fileSizeByte = Utils.copyByte(byteSrc, 32, 4);
        headerType.file_size = Utils.byte2int(fileSizeByte);
    
        //解析header_size
        byte[] headerSizeByte = Utils.copyByte(byteSrc, 36, 4);
        headerType.header_size = Utils.byte2int(headerSizeByte);
    
        //解析endian_tag
        byte[] endianTagByte = Utils.copyByte(byteSrc, 40, 4);
        headerType.endian_tag = Utils.byte2int(endianTagByte);
    
        //解析link_size
        byte[] linkSizeByte = Utils.copyByte(byteSrc, 44, 4);
        headerType.link_size = Utils.byte2int(linkSizeByte);
    
        //解析link_off
        byte[] linkOffByte = Utils.copyByte(byteSrc, 48, 4);
        headerType.link_off = Utils.byte2int(linkOffByte);
    
        //解析map_off
        byte[] mapOffByte = Utils.copyByte(byteSrc, 52, 4);
        headerType.map_off = Utils.byte2int(mapOffByte);
    
        //解析string_ids_size
        byte[] stringIdsSizeByte = Utils.copyByte(byteSrc, 56, 4);
        headerType.string_ids_size = Utils.byte2int(stringIdsSizeByte);
    
        //解析string_ids_off
        byte[] stringIdsOffByte = Utils.copyByte(byteSrc, 60, 4);
        headerType.string_ids_off = Utils.byte2int(stringIdsOffByte);
    
        //解析type_ids_size
        byte[] typeIdsSizeByte = Utils.copyByte(byteSrc, 64, 4);
        headerType.type_ids_size = Utils.byte2int(typeIdsSizeByte);
    
        //解析type_ids_off
        byte[] typeIdsOffByte = Utils.copyByte(byteSrc, 68, 4);
        headerType.type_ids_off = Utils.byte2int(typeIdsOffByte);
    
        //解析proto_ids_size
        byte[] protoIdsSizeByte = Utils.copyByte(byteSrc, 72, 4);
        headerType.proto_ids_size = Utils.byte2int(protoIdsSizeByte);
    
        //解析proto_ids_off
        byte[] protoIdsOffByte = Utils.copyByte(byteSrc, 76, 4);
        headerType.proto_ids_off = Utils.byte2int(protoIdsOffByte);
    
        //解析field_ids_size
        byte[] fieldIdsSizeByte = Utils.copyByte(byteSrc, 80, 4);
        headerType.field_ids_size = Utils.byte2int(fieldIdsSizeByte);
    
        //解析field_ids_off
        byte[] fieldIdsOffByte = Utils.copyByte(byteSrc, 84, 4);
        headerType.field_ids_off = Utils.byte2int(fieldIdsOffByte);
    
        //解析method_ids_size
        byte[] methodIdsSizeByte = Utils.copyByte(byteSrc, 88, 4);
        headerType.method_ids_size = Utils.byte2int(methodIdsSizeByte);
    
        //解析method_ids_off
        byte[] methodIdsOffByte = Utils.copyByte(byteSrc, 92, 4);
        headerType.method_ids_off = Utils.byte2int(methodIdsOffByte);
    
        //解析class_defs_size
        byte[] classDefsSizeByte = Utils.copyByte(byteSrc, 96, 4);
        headerType.class_defs_size = Utils.byte2int(classDefsSizeByte);
    
        //解析class_defs_off
        byte[] classDefsOffByte = Utils.copyByte(byteSrc, 100, 4);
        headerType.class_defs_off = Utils.byte2int(classDefsOffByte);
    
        //解析data_size
        byte[] dataSizeByte = Utils.copyByte(byteSrc, 104, 4);
        headerType.data_size = Utils.byte2int(dataSizeByte);
    
        //解析data_off
        byte[] dataOffByte = Utils.copyByte(byteSrc, 108, 4);
        headerType.data_off = Utils.byte2int(dataOffByte);
    
        System.out.println("header:"+headerType);
    
        stringIdOffset = headerType.header_size;//header之后就是string ids
    
        stringIdsSize = headerType.string_ids_size;
        stringIdsOffset = headerType.string_ids_off;
        typeIdsSize = headerType.type_ids_size;
        typeIdsOffset = headerType.type_ids_off;
        fieldIdsSize = headerType.field_ids_size;
        fieldIdsOffset = headerType.field_ids_off;
        protoIdsSize = headerType.proto_ids_size;
        protoIdsOffset = headerType.proto_ids_off;
        methodIdsSize = headerType.method_ids_size;
        methodIdsOffset = headerType.method_ids_off;
        classIdsSize = headerType.class_defs_size;
        classIdsOffset = headerType.class_defs_off;
    
        mapListOffset = headerType.map_off;
    
    }

这里没啥说的，就是记录几个索引区的偏移值和大小信息。

解析结果：

![Center 19][]

## 2、解析string\_ids索引区 ##

**\[java\]** view plain copy

print ?

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*解析字符串\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
2.  public static void parseStringIds(byte\[\] srcByte)\{  
3.      int idSize = StringIdsItem.getSize();  
4.      int countIds = stringIdsSize;  
5.      for(int i=0;i<countIds;i++)\{  
6.          stringIdsList.add(parseStringIdsItem(Utils.copyByte(srcByte, stringIdsOffset+i\*idSize, idSize)));  
7.      \}  
8.      System.out.println(”string size:”\+stringIdsList.size());  
9.  \}  
10.   
11. public static void parseStringList(byte\[\] srcByte)\{  
12.     //第一个字节还是字符串的长度  
13.     for(StringIdsItem item : stringIdsList)\{  
14.         String str = getString(srcByte, item.string\_data\_off);  
15.         System.out.println(”str:”\+str);  
16.         stringList.add(str);  
17.     \}  
18. \}

/************************解析字符串********************************/
    public static void parseStringIds(byte[] srcByte){
        int idSize = StringIdsItem.getSize();
        int countIds = stringIdsSize;
        for(int i=0;i<countIds;i++){
            stringIdsList.add(parseStringIdsItem(Utils.copyByte(srcByte, stringIdsOffset+i*idSize, idSize)));
        }
        System.out.println("string size:"+stringIdsList.size());
    }
    
    public static void parseStringList(byte[] srcByte){
        //第一个字节还是字符串的长度
        for(StringIdsItem item : stringIdsList){
            String str = getString(srcByte, item.string_data_off);
            System.out.println("str:"+str);
            stringList.add(str);
        }
    }

解析结果：

![Center 20][]

## 3、解析type\_ids索引区 ##

**\[java\]** view plain copy

print ?

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*解析类型\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
2.  public static void parseTypeIds(byte\[\] srcByte)\{  
3.      int idSize = TypeIdsItem.getSize();  
4.      int countIds = typeIdsSize;  
5.      for(int i=0;i<countIds;i++)\{  
6.          typeIdsList.add(parseTypeIdsItem(Utils.copyByte(srcByte, typeIdsOffset+i\*idSize, idSize)));  
7.      \}  
8.    
9.      //这里的descriptor\_idx就是解析之后的字符串中的索引值  
10.     for(TypeIdsItem item : typeIdsList)\{  
11.         System.out.println(”typeStr:”\+stringList.get(item.descriptor\_idx));  
12.     \}  
13. \}

/***************************解析类型******************************/
    public static void parseTypeIds(byte[] srcByte){
        int idSize = TypeIdsItem.getSize();
        int countIds = typeIdsSize;
        for(int i=0;i<countIds;i++){
            typeIdsList.add(parseTypeIdsItem(Utils.copyByte(srcByte, typeIdsOffset+i*idSize, idSize)));
        }
    
        //这里的descriptor_idx就是解析之后的字符串中的索引值
        for(TypeIdsItem item : typeIdsList){
            System.out.println("typeStr:"+stringList.get(item.descriptor_idx));
        }
    }

解析结果：

![Center 21][]

## 4、解析proto\_ids索引区 ##

**\[html\]** view plain copy

print ?

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*解析Proto\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
2.  public static void parseProtoIds(byte\[\] srcByte)\{  
3.      int idSize = ProtoIdsItem.getSize();  
4.      int countIds = protoIdsSize;  
5.      for(int i=0;i<countIds;i++)\{  
6.          protoIdsList.add(parseProtoIdsItem(Utils.copyByte(srcByte, protoIdsOffset+i\*idSize, idSize)));  
7.      \}  
8.    
9.      for(ProtoIdsItem item : protoIdsList)\{  
10.         System.out.println(“proto:”+stringList.get(item.shorty\_idx)+”,”+stringList.get(item.return\_type\_idx));  
11.         //有的方法没有参数，这个值就是0  
12.         if(item.parameters\_off != 0)\{  
13.             item = parseParameterTypeList(srcByte, item.parameters\_off, item);  
14.         \}  
15.     \}  
16. \}  
17.   
18. //解析方法的所有参数类型  
19. private static ProtoIdsItem parseParameterTypeList(byte\[\] srcByte, int startOff, ProtoIdsItem item)\{  
20.     //解析size和size大小的List中的内容  
21.     byte\[\] sizeByte = Utils.copyByte(srcByte, startOff, 4);  
22.     int size = Utils.byte2int(sizeByte);  
23.     List<String> parametersList = new ArrayList<String>();  
24.     List<Short> typeList = new ArrayList<Short>(size);  
25.     for(int i=0;i<size;i++)\{  
26.         byte\[\] typeByte = Utils.copyByte(srcByte, startOff+4+2\*i, 2);  
27.         typeList.add(Utils.byte2Short(typeByte));  
28.     \}  
29.     System.out.println(“param count:”+size);  
30.     for(int i=0;i<typeList.size();i++)\{  
31.         System.out.println(“type:”+stringList.get(typeList.get(i)));  
32.         int index = typeIdsList.get(typeList.get(i)).descriptor\_idx;  
33.         parametersList.add(stringList.get(index));  
34.     \}  
35.   
36.     item.parameterCount = size;  
37.     item.parametersList = parametersList;  
38.   
39.     return item;  
40. \}

/***************************解析Proto***************************/
    public static void parseProtoIds(byte[] srcByte){
        int idSize = ProtoIdsItem.getSize();
        int countIds = protoIdsSize;
        for(int i=0;i<countIds;i++){
            protoIdsList.add(parseProtoIdsItem(Utils.copyByte(srcByte, protoIdsOffset+i*idSize, idSize)));
        }
    
        for(ProtoIdsItem item : protoIdsList){
            System.out.println("proto:"+stringList.get(item.shorty_idx)+","+stringList.get(item.return_type_idx));
            //有的方法没有参数，这个值就是0
            if(item.parameters_off != 0){
                item = parseParameterTypeList(srcByte, item.parameters_off, item);
            }
        }
    }
    
    //解析方法的所有参数类型
    private static ProtoIdsItem parseParameterTypeList(byte[] srcByte, int startOff, ProtoIdsItem item){
        //解析size和size大小的List中的内容
        byte[] sizeByte = Utils.copyByte(srcByte, startOff, 4);
        int size = Utils.byte2int(sizeByte);
        List<String> parametersList = new ArrayList<String>();
        List<Short> typeList = new ArrayList<Short>(size);
        for(int i=0;i<size;i++){
            byte[] typeByte = Utils.copyByte(srcByte, startOff+4+2*i, 2);
            typeList.add(Utils.byte2Short(typeByte));
        }
        System.out.println("param count:"+size);
        for(int i=0;i<typeList.size();i++){
            System.out.println("type:"+stringList.get(typeList.get(i)));
            int index = typeIdsList.get(typeList.get(i)).descriptor_idx;
            parametersList.add(stringList.get(index));
        }
    
        item.parameterCount = size;
        item.parametersList = parametersList;
    
        return item;
    }

解析结果：

![Center 22][]

## 5、解析field\_ids索引区 ##

**\[java\]** view plain copy

print ?

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*解析字段\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
2.  public static void parseFieldIds(byte\[\] srcByte)\{  
3.      int idSize = FieldIdsItem.getSize();  
4.      int countIds = fieldIdsSize;  
5.      for(int i=0;i<countIds;i++)\{  
6.          fieldIdsList.add(parseFieldIdsItem(Utils.copyByte(srcByte, fieldIdsOffset+i\*idSize, idSize)));  
7.      \}  
8.    
9.      for(FieldIdsItem item : fieldIdsList)\{  
10.         int classIndex = typeIdsList.get(item.class\_idx).descriptor\_idx;  
11.         int typeIndex = typeIdsList.get(item.type\_idx).descriptor\_idx;  
12.         System.out.println(”class:”\+stringList.get(classIndex)+“,name:”\+stringList.get(item.name\_idx)+“,type:”\+stringList.get(typeIndex));  
13.     \}  
14. \}

/***************************解析字段****************************/
    public static void parseFieldIds(byte[] srcByte){
        int idSize = FieldIdsItem.getSize();
        int countIds = fieldIdsSize;
        for(int i=0;i<countIds;i++){
            fieldIdsList.add(parseFieldIdsItem(Utils.copyByte(srcByte, fieldIdsOffset+i*idSize, idSize)));
        }
    
        for(FieldIdsItem item : fieldIdsList){
            int classIndex = typeIdsList.get(item.class_idx).descriptor_idx;
            int typeIndex = typeIdsList.get(item.type_idx).descriptor_idx;
            System.out.println("class:"+stringList.get(classIndex)+",name:"+stringList.get(item.name_idx)+",type:"+stringList.get(typeIndex));
        }
    }

解析结果：

![Center 22][]

## 6、解析method\_ids索引区 ##

**\[java\]** view plain copy

print ?

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*解析方法\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
2.  public static void parseMethodIds(byte\[\] srcByte)\{  
3.      int idSize = MethodIdsItem.getSize();  
4.      int countIds = methodIdsSize;  
5.      for(int i=0;i<countIds;i++)\{  
6.          methodIdsList.add(parseMethodIdsItem(Utils.copyByte(srcByte, methodIdsOffset+i\*idSize, idSize)));  
7.      \}  
8.    
9.      for(MethodIdsItem item : methodIdsList)\{  
10.         int classIndex = typeIdsList.get(item.class\_idx).descriptor\_idx;  
11.         int returnIndex = protoIdsList.get(item.proto\_idx).return\_type\_idx;  
12.         String returnTypeStr = stringList.get(typeIdsList.get(returnIndex).descriptor\_idx);  
13.         int shortIndex = protoIdsList.get(item.proto\_idx).shorty\_idx;  
14.         String shortStr = stringList.get(shortIndex);  
15.         List<String> paramList = protoIdsList.get(item.proto\_idx).parametersList;  
16.         StringBuilder parameters = new StringBuilder();  
17.         parameters.append(returnTypeStr+”(“);  
18.         for(String str : paramList)\{  
19.             parameters.append(str+”,”);  
20.         \}  
21.         parameters.append(”)”\+shortStr);  
22.         System.out.println(”class:”\+stringList.get(classIndex)+“,name:”\+stringList.get(item.name\_idx)+“,proto:”\+parameters);  
23.     \}  
24.   
25. \}

/***************************解析方法*****************************/
    public static void parseMethodIds(byte[] srcByte){
        int idSize = MethodIdsItem.getSize();
        int countIds = methodIdsSize;
        for(int i=0;i<countIds;i++){
            methodIdsList.add(parseMethodIdsItem(Utils.copyByte(srcByte, methodIdsOffset+i*idSize, idSize)));
        }
    
        for(MethodIdsItem item : methodIdsList){
            int classIndex = typeIdsList.get(item.class_idx).descriptor_idx;
            int returnIndex = protoIdsList.get(item.proto_idx).return_type_idx;
            String returnTypeStr = stringList.get(typeIdsList.get(returnIndex).descriptor_idx);
            int shortIndex = protoIdsList.get(item.proto_idx).shorty_idx;
            String shortStr = stringList.get(shortIndex);
            List<String> paramList = protoIdsList.get(item.proto_idx).parametersList;
            StringBuilder parameters = new StringBuilder();
            parameters.append(returnTypeStr+"(");
            for(String str : paramList){
                parameters.append(str+",");
            }
            parameters.append(")"+shortStr);
            System.out.println("class:"+stringList.get(classIndex)+",name:"+stringList.get(item.name_idx)+",proto:"+parameters);
        }
    
    }

![Center 23][]

## 7、解析class\_def区域 ##

**\[java\]** view plain copy

print ?

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*解析类\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
2.  public static void parseClassIds(byte\[\] srcByte)\{  
3.      System.out.println(”classIdsOffset:”\+Utils.bytesToHexString(Utils.int2Byte(classIdsOffset)));  
4.      System.out.println(”classIds:”\+classIdsSize);  
5.      int idSize = ClassDefItem.getSize();  
6.      int countIds = classIdsSize;  
7.      for(int i=0;i<countIds;i++)\{  
8.          classIdsList.add(parseClassDefItem(Utils.copyByte(srcByte, classIdsOffset+i\*idSize, idSize)));  
9.      \}  
10.     for(ClassDefItem item : classIdsList)\{  
11.         System.out.println(”item:”\+item);  
12.         int classIdx = item.class\_idx;  
13.         TypeIdsItem typeItem = typeIdsList.get(classIdx);  
14.         System.out.println(”classIdx:”\+stringList.get(typeItem.descriptor\_idx));  
15.         int superClassIdx = item.superclass\_idx;  
16.         TypeIdsItem superTypeItem = typeIdsList.get(superClassIdx);  
17.         System.out.println(”superitem:”\+stringList.get(superTypeItem.descriptor\_idx));  
18.         int sourceIdx = item.source\_file\_idx;  
19.         String sourceFile = stringList.get(sourceIdx);  
20.         System.out.println(”sourceFile:”\+sourceFile);  
21.         classDataMap.put(sourceFile, item);  
22.     \}  
23. \}

/****************************解析类*****************************/
    public static void parseClassIds(byte[] srcByte){
        System.out.println("classIdsOffset:"+Utils.bytesToHexString(Utils.int2Byte(classIdsOffset)));
        System.out.println("classIds:"+classIdsSize);
        int idSize = ClassDefItem.getSize();
        int countIds = classIdsSize;
        for(int i=0;i<countIds;i++){
            classIdsList.add(parseClassDefItem(Utils.copyByte(srcByte, classIdsOffset+i*idSize, idSize)));
        }
        for(ClassDefItem item : classIdsList){
            System.out.println("item:"+item);
            int classIdx = item.class_idx;
            TypeIdsItem typeItem = typeIdsList.get(classIdx);
            System.out.println("classIdx:"+stringList.get(typeItem.descriptor_idx));
            int superClassIdx = item.superclass_idx;
            TypeIdsItem superTypeItem = typeIdsList.get(superClassIdx);
            System.out.println("superitem:"+stringList.get(superTypeItem.descriptor_idx));
            int sourceIdx = item.source_file_idx;
            String sourceFile = stringList.get(sourceIdx);
            System.out.println("sourceFile:"+sourceFile);
            classDataMap.put(sourceFile, item);
        }
    }

解析结果：

![Center 24][]  
这里我们看到解析结果我们可能有点看不懂，其实这里我是没有在继续解读下去了，为什么，因为我们通过class\_def的数据结构解析可以看到，我们需要借助《Bytecode for Dalvik VM》这个来进行查阅具体的指令，然后翻译成具体的指令代码，关于这个指令表可以参考这里：[http://www.netmite.com/android/mydroid/dalvik/docs/dalvik-bytecode.html][http_www.netmite.com_android_mydroid_dalvik_docs_dalvik-bytecode.html]，所以具体解析并不复杂，所以这里就不在详细解析了，具体的解析思路，可以参考class\_def的数据结构解析那一块的内容，上面又说道。

**项目下载地址：[https://github.com/fourbrother/parse\_androiddex][https_github.com_fourbrother_parse_androiddex]**

**注意：**

我们到这里算是解析完了dex文件了，但是我现在要告诉大家，其实Android中有一个工具可以为我们做这个事，不知道大家还记得我们之前介绍解析AndroidManifest.xml和resource.arsc文件格式的时候，也是一样的，直接用aapt命令就可以查看了，这里也是一样的，只是这个工具是：**dexdump**

这个命令也是在AndroidSdk目录下的build-tools下面，这里我们可以将打印的结果重定向到demo.txt文件中

![Center 25][]

那么我们上面做的解析工作是不是就没有用了呢？当然不是，我们在后面会说道我们解析dex格式有很多用途的。

# 五、技术总结和概述 #

到这里我们就解析完了dex文件的所有东东，讲解的内容有点多，在这里就来总结一下：

## 第一、学习到的技术 ##

1、我们学习到了如何不是用任何的IDE工具，就可以构造一个dex文件出来，主要借助于java和dx命令。同时，我们也学会了一个可以执行dex文件的命令：dalvikvm；不过这个命令需要root权限。

2、我们了解到了Android中的DVM指令，如何翻译指令代码。

3、学习了一个数据类型：uleb128，如何将uleb128类型和int类型进行转化。

## 第二、未解决的问题 ##

我们在整个解析的过程中会发现，我们这里只是用一个非常简单的dex来做案例解析，所以解析起来也很容易，但是我们实际的过程中，不会这么简单的，一个类可能实现多个接口，内部类，注解等信息的时候，解析起来肯定还要复杂，那么我们这篇文章主要的目的是介绍一下dex的文件格式，目的不是说去解决实际中项目的问题，所以后面在解析复杂的dex的时候，我们也只能遇到什么问题就去解决一下。

## 第三、我们解析dex的目的是啥？ ##

我们开始的时候，并没有介绍说解析dex干啥？那么现在可以说，解析完dex之后我们有很多事都可以做了。

1、我们可以检测一个apk中是否包含了指定系统的api(当然这些api没有被混淆)，同样也可以检测这个apk是否包含了广告，以前我们可以通过解析AndroidManifest.xml文件中的service，activity，receiver，meta等信息来判断，因为现在的广告sdk都需要添加这些东西，如果我们可以解析dex的话，那么我们可以得到他的所有字符串内容，就是string\_ids池，这样就可以判断调用了哪些api。那么就可以判断这个apk的一些行为了，当然这里还有一个问题，假如dex加密了我们就蛋疼了。好吧，那就牵涉出第二件事了。

2、我们在之前说过如何对apk进行加固，其实就是加密apk/dex文件内容，那么这时候我们必须要了解dex的文件结构信息，因为我们先加密dex,然后在动态加载dex进行解密即可。

3、我们可以更好的逆向工作，其实说到这里，我们看看apktool源码也知道，他内部的反编译原理就是这些，只是他会将指令翻译成smail代码，这个网上是有相对应的jar包api的，所以我们知道了dex的数据结构，那么原理肯定就知道了，同样还有一个dex2jar工具原理也是类似的。

# 六、总结 #

到这里我们就介绍完了dex文件格式的解析工作，至此我们也解析完了Android中编译之后的所有文件格式，我之所以介绍这几篇文章，一来是更好的了解Android中生成apk的流程，其次是我们能更好的的解决反编译过程中遇到的问题，我们需要去解决。这篇文章解析起来还是很费劲的，累死了，也是2016年第一篇文章，谢谢大家的支持~~。记得点赞呀~~

#  #

# 《Android应用安全防护和逆向分析》 #

# 点击立即购买：[京东][Link 1]  [天猫 ][Link 2] [亚马逊][Link 3] [当当][Link 4] #

![20171218164959450][]