DexHunter--2

                                                                                转载自：http://blog.csdn.net/qq1084283172/article/details/53715325

前面的博文《Android通用脱壳工具DexHunter的原理分析和使用说明（一）》中已经记录了很多关于DexHunter脱壳工具的脱壳原理和思考的思路问题并没有涉及到DexHunter脱壳工具的代码的分析，今天我就代码分析、理解和DexHunter脱壳工具的使用以及需要注意的地方进行博文的记录。

在阅读DexHunter的代码之前，复习下几个须知：

1>. POSIX定时器编程相关的知识

struct sigevent

The <signal.h> header shall define the sigevent structure, which shall include at least the following members:

struct sigevent {
    int           sigev_notify;            //Notification type. 
    int           sigev_signo;            //Signal number. 
    union       sigval  sigev_value;             //Signal value. 
    void         (*sigev_notify_function)(union sigval); //Notification function. 
    pthread_attr_t *sigev_notify_attributes;  //Notification attributes. 
}; 

sigev_notify

 sigev_notify 的取值范围如下,只有3种情况（对应的宏在<signal.h>中定义）。

SIGEV_NONE

事件发生时,什么也不做.

SIGEV_SIGNAL 事件发生时,将sigev_signo 指定的信号(A queued signal)发送给指定的进程. SIGEV_THREAD

事件发生时,内核会(在此进程内)以sigev_notification_attributes为线程属性创建一个线程，并且让它执行sigev_notify_function，

传入sigev_value作为为一个参数.

sigev_signo

 在sigev_notify = SIGEV_SIGNAL 时使用,指定信号的种别(number).

sigev_value

在sigev_notify = SIGEV_THREAD 时使用,作为sigev_notify_function 即定时器线程回调函数的参数.

union sigval
{
    int sival_int;
    void *sival_ptr;
};  

(*sigev_notify_function)(union sigval)

函数指针(指向通知执行函数即定时器线程回调函数),在sigev_notify = SIGEV_THREAD 时使用, 其他情况下置为NULL.

sigev_notify_attributes

指向线程属性的指针,在sigev_notify = SIGEV_THREAD 时使用,指定创建线程的属性, 其他情况下置为NULL. 

---

 struct timespec

The <time.h> header shall declare the timespec structure, which shall include at least the following members: 

struct timespec 
{
    time_t tv_sec;        /* Seconds */
    long    tv_nsec;        /* Nanoseconds(纳秒:十亿分之一秒) */
};

struct itimerspec

The <time.h> header shall also declare the itimerspec structure, which shall include at least the following members:

struct itimerspec 
{
    struct timespec it_interval;  /* Timer interval(timer循环时间间隔) */
    struct timespec it_value;     /* Initial expiration(timer初次到期时间间隔) */
};

clockid_t

clockid_t is used for clock ID type in the clock and timer functions, 取值范围如下(前4个是POSIX定义的,灰色部分为Linux的扩展),

/* Identifier for system-wide realtime clock, Setting this clock requires appropriate privileges */
#define CLOCK_REALTIME        0
/* Monotonic system-wide clock, Clock that cannot be set and represents monotonic time since some unspecified starting point  */
#define CLOCK_MONOTONIC        1
/* High-resolution timer from the CPU. (since Linux 2.6.12) */
#define CLOCK_PROCESS_CPUTIME_ID  2    
/* Thread-specific CPU-time clock. (since Linux 2.6.12) */
#define CLOCK_THREAD_CPUTIME_ID    3
/* Monotonic system-wide clock, not adjusted for frequency scaling.  */
#define CLOCK_MONOTONIC_RAW        4
/* Identifier for system-wide realtime clock, updated only on ticks.  */
#define CLOCK_REALTIME_COARSE    5
/* Monotonic system-wide clock, updated only on ticks.  */
#define CLOCK_MONOTONIC_COARSE    6

CLOCK_REALTIME : 这种时钟表示的是绝对时间, 指的是从1970年1月1月0:00到目前经过多少秒, 相当于你的linux系统中显示的时间, 所以这个时间是可以更改的, 当系统的时钟源被改变，或者系统管理员重置了系统时间之后，这种类型的时钟可以得到相应的调整, 对设定为此类型的timer是有影响的.

CLOCK_MONOTONIC : 这种时钟表示的是相对时间, 其值对通过累积时钟节拍(嘀嗒)计算出来的, 不受时钟源等的影响, 从系统启动这一刻起开始计时, 如果你想计算出在一台计算机上不受重启的影响，两个事件发生的间隔时间的话，那么它将是最好的选择。

CLOCK_PROCESS_CPUTIME_ID : 测量调用进程(包括该进程内所有的线程)用户和系统消耗的总CPU时间.

CLOCK_THREAD_CPUTIME_ID : 测量调用线程消耗的CPU时间.

---

 struct timeval

The <sys/time.h> header shall define the timeval structure, which shall include at least the following members:

struct timeval
{
    time_t         tv_sec;    // Seconds(秒). 
    suseconds_t    tv_usec;   // Microseconds(微秒:千分之一毫秒). 
};

struct itimerval

The <sys/time.h> header shall define the itimerval structure, which shall include at least the following members:

struct itimerval
{
    struct timeval it_interval;  /* Timer interval(timer循环时间间隔) */
    struct timeval it_value;     /* Initial expiration(timer初次到期时间间隔) */
};

POSIX时钟创建、初始化以及删除一个定时器的操作被分为三个不同的函数：timer_create()(创建定时器)、timer_settime()(初始化定时器)以及timer_delete(销毁它)。

使用timer定时器时注意两点：

1.定时器创建的线程回调函数，如果不是C函数而是C++的类成员函数，则不能用普通成员函数，必须用静态成员函数，因为普通成员函数含有隐含参数--this指针

2.timer定时器的时间间隔，第一次是ts.it_value这么长，后面每次时间间隔是ts.it_interval这么长

    ts.it_interval.tv_sec = 0;            //定时器第一次之后的每次时间间隔

    ts.it_interval.tv_nsec = 200000000; //200ms 

    ts.it_value.tv_sec = 0;             //定时器第一次定时的时间

    ts.it_value.tv_nsec = 200000000; //200ms 

感谢链接：

http://www.cnblogs.com/LubinLew/p/POSIX-DataStructure.html

http://blog.csdn.NET/ustcxiangchun/article/details/6339762

http://www.ccvita.com/508.html

http://www.linuxidc.com/Linux/2011-08/41862.htm

2>. Android的Dex文件相关的重要结构体

[cpp] view plain copy

print ?

1. //Use this to keep track of mapped segments.  
2. struct MemMapping   
3. {  
4.     void*  addr;        //start of data  
5.     size_t length;      //length of data  
6.     void*  baseAddr;    //page-aligned base address  
7.     size_t baseLength;  //length of mapping  
8. };  

//Use this to keep track of mapped segments.
struct MemMapping 
{
	void*  addr;		//start of data
	size_t length;		//length of data
	void*  baseAddr;	//page-aligned base address
	size_t baseLength; 	//length of mapping
};

[cpp] view plain copy

print ?

1. // odex文件在内存中的存放地址memMap->addr和长度memMap->length  
2. struct DvmDex   
3. {  
4.     DexFile*               pDexFile;            // odex文件的信息  
5.     const  DexHeader*      pHeader;             // dex文件头相关信息  
6.     struct StringObject**  pResStrings;         // dex文件的字符串结构体  
7.     struct ClassObject**   pResClasses;         // 通过DexFile里的ClassDefItem构造出来的一个结构体（类信息）  
8.     struct Method**        pResMethods;         // 通过Method_Item构造出来的结构体(方法信息)  
9.     struct Field**         pResFields;  
10.     struct AtomicCache*    pInterfaceCache;  
11.     bool                   isMappedReadOnly;  
12.     MemMapping             memMap;              // memMap->addr为odex文件的内存存放位置，memMap->length为odex文件的长度  
13.     jobject                dex_object;  
14.     pthread_mutex_t        modLock;  
15. };  

// odex文件在内存中的存放地址memMap->addr和长度memMap->length
struct DvmDex 
{
    DexFile*               pDexFile;            // odex文件的信息
    const  DexHeader*      pHeader;             // dex文件头相关信息
    struct StringObject**  pResStrings;         // dex文件的字符串结构体
    struct ClassObject**   pResClasses;         // 通过DexFile里的ClassDefItem构造出来的一个结构体（类信息）
    struct Method**        pResMethods;         // 通过Method_Item构造出来的结构体(方法信息)
    struct Field**         pResFields;
    struct AtomicCache*    pInterfaceCache;
    bool                   isMappedReadOnly;
    MemMapping             memMap;				// memMap->addr为odex文件的内存存放位置，memMap->length为odex文件的长度
    jobject                dex_object;
    pthread_mutex_t        modLock;
};

[cpp] view plain copy

print ?

1. // DexFile结构体存储了整个odex文件在内存的一些信息。  
2. struct DexFile   
3. {  
4.     //directly-mapped "opt" header   
5.     const DexOptHeader*         pOptHeader;             //指向odex文件的文件头DexOptHeader的信息  
6.   
7.     //pointers to directly-mapped structs and arrays in base DEX  
8.     const DexHeader*            pHeader;                // dex文件的文件头DexHeader的信息  
9.     const DexStringId*          pStringIds;  
10.     const DexTypeId*            pTypeIds;  
11.     const DexFieldId*           pFieldIds;  
12.     const DexMethodId*          pMethodIds;  
13.     const DexProtoId*           pProtoIds;  
14.     const DexClassDef*          pClassDefs;             // 指向dex文件的DexClassDef结构体的指针  
15.     const DexLink*              pLinkData;  
16.     const DexClassLookup*       pClassLookup;  
17.     const void*                 pRegisterMapPool;       // RegisterMapClassPool  
18.     const u1*                   baseAddr;               // dex文件在内存中的存放地址  
19.     int                         overhead;  
20. };  

// DexFile结构体存储了整个odex文件在内存的一些信息。
struct DexFile 
{
    //directly-mapped "opt" header 
    const DexOptHeader*         pOptHeader;				//指向odex文件的文件头DexOptHeader的信息

    //pointers to directly-mapped structs and arrays in base DEX
    const DexHeader*            pHeader;				// dex文件的文件头DexHeader的信息
    const DexStringId*          pStringIds;
    const DexTypeId*            pTypeIds;
    const DexFieldId*           pFieldIds;
    const DexMethodId*          pMethodIds;
    const DexProtoId*           pProtoIds;
    const DexClassDef*          pClassDefs;				// 指向dex文件的DexClassDef结构体的指针
    const DexLink*              pLinkData;
    const DexClassLookup*       pClassLookup;
    const void*                 pRegisterMapPool;       // RegisterMapClassPool
    const u1*                   baseAddr;				// dex文件在内存中的存放地址
    int                         overhead;
};

[cpp] view plain copy

print ?

1. // 类成员方法的结构体  
2. struct Method {    
3.     ClassObject*        clazz;          // 该方法所在的类  
4.     u4                  accessFlags;    // 该方法对应的访问属性（native对应0x00100）    
5.     u2                  methodIndex;    // 该方法在函数表或者接口表中的偏移  
6.     
7.     u2                  registersSize;  // 该方法总共用到的寄存器个数  
8.     u2                  outsSize;       // 当该方法要调用其它方法时，用作参数传递而使用的寄存器个数  
9.     u2                  insSize;        // 作为调用该方法时，参数传递而使用到的寄存器个数  
10.     
11.     const char*         name;           // 该方法的名称  
12.     DexProto            prototype;      // 对该方法调用参数类型、顺序还有返回类型的描述  
13.     const char*         shorty;         // 方法对应协议的短表示法，一个字符代表一种类型  
14.     const u2*           insns;          // 该方法对应的实现的字节码的内存地址  
15.     
16.     int                 jniArgInfo;       
17.     DalvikBridgeFunc    nativeFunc;     // 本地方法的内存地址  
18.     
19.     bool                fastJni;    
20.     bool                noRef;    
21.     bool                shouldTrace;    
22.     const RegisterMap*  registerMap;    
23.     bool                inProfile;    
24. };    

// 类成员方法的结构体
struct Method {  
    ClassObject*        clazz;  		// 该方法所在的类
    u4                  accessFlags;	// 该方法对应的访问属性（native对应0x00100）  
    u2                  methodIndex;  	// 该方法在函数表或者接口表中的偏移
  
    u2                  registersSize;  // 该方法总共用到的寄存器个数
    u2                  outsSize;  		// 当该方法要调用其它方法时，用作参数传递而使用的寄存器个数
    u2                  insSize;  		// 作为调用该方法时，参数传递而使用到的寄存器个数
  
    const char*         name;  			// 该方法的名称
    DexProto            prototype;  	// 对该方法调用参数类型、顺序还有返回类型的描述
    const char*         shorty;  		// 方法对应协议的短表示法，一个字符代表一种类型
    const u2*           insns;  		// 该方法对应的实现的字节码的内存地址
  
    int                 jniArgInfo;  	
    DalvikBridgeFunc    nativeFunc;  	// 本地方法的内存地址
  
    bool                fastJni;  
    bool                noRef;  
    bool                shouldTrace;  
    const RegisterMap*  registerMap;  
    bool                inProfile;  
};  

[cpp] view plain copy

print ?

1. // DexOrJar->fileName当前apk进程的文件路径  
2. typedef struct DexOrJar {  
3.     char*          fileName;    // 当前apk文件的文件路径  
4.     bool           isDex;       // 是dex文件还是jar包  
5.     bool           okayToFree;  
6.     RawDexFile*    pRawDexFile;  
7.     JarFile*       pJarFile;    // 如果是jar包，则指向JarFile结构  
8.     u1*            pDexMemory;  // 如果是dex文件，则指向dex文件存放的内存区  
9. } DexOrJar;  

// DexOrJar->fileName当前apk进程的文件路径
typedef struct DexOrJar {
    char*          fileName;	// 当前apk文件的文件路径
    bool           isDex; 		// 是dex文件还是jar包
    bool           okayToFree;
    RawDexFile*    pRawDexFile;
    JarFile*       pJarFile;  	// 如果是jar包，则指向JarFile结构
    u1* 		   pDexMemory; 	// 如果是dex文件，则指向dex文件存放的内存区
} DexOrJar;

3>. Android的Dex文件重要的结构体在内存中的对应关系图：

Dex文件与Odex文件结构对比图

DexClassLookup数据结构的定义

struct DexFile 结构体成员变量

Dex 文件与 DexFile 数据结构映射关系图

struct ClassObject 结构体的定义

类加载的工作流程以及 ClassObject 结构体的结构图

findClassNoInit 函数执行流程图

DexClassDef 数据结构的定义

loadClassFromDex 函数的执行流程图

Method 数据结构的定义

类成员方法的method->insns字段的说明:

感谢连接：

http://blog.csdn.Net/roland_sun/article/details/38640297

http://blog.csdn.net/zhangyun438/article/details/17193411

http://blog.csdn.net/qq1084283172/article/details/53584495

http://www.blogfshare.com/defineclassnative.html

Android软件安全与逆向分析

Android Dalvik虚拟机结构及机制剖析(第2卷):Dalvik虚拟机各模块机制分析(有不少小错误，推荐)

4>. DexHunter脱壳工具代码分析

dvm情况下的代码分析，见下面，整个DexHunter脱壳工具代码大分部都理解清楚了，极个别函数的实现不是很理解，后期有时间在看看，代码的注释很全，但是有些地方表述的不是很明白，将就着看吧。art模式下的修改的class_linker.cpp文件的大部分代码一样，但是有一些细节的地方处理不一样，后期再分析了。dvm情况下的DexHunter脱壳工具代码只要是修改Android源码文件/dalvik/vm/native/dalvik_system_DexFile.cpp里的Dalvik_dalvik_system_DexFile_defineClassNative函数的实现，具体操作是在Android系统代码调用函数dvmDefineClass进行类加载之前，主动地一次性加载并初始化Dex文件所有的类。

[cpp] view plain copy

print ?

1. //------------------------added begin----------------------//  
2.   
3. #include <asm/siginfo.h>  
4. #include "libdex/DexClass.h"  
5. #include <sys/stat.h>  
6. #include <fcntl.h>  
7. #include <sys/mman.h>  
8.   
9.   
10. // 保存加固类型的特征字符串，其实是由pDexOrJar->fileName决定的  
11. static char dexname[100]={0};  
12. // 保存需要脱壳的apk文件的内存dump出来的part1、data等文件的保存路径  
13. static char dumppath[100]={0};  
14.   
15. static bool readable=true;  
16.   
17. static pthread_mutex_t read_mutex;  
18.   
19. static bool flag=true;  
20.   
21. static pthread_mutex_t mutex;  
22.   
23. static bool timer_flag=true;  
24.   
25. static timer_t timerId;  
26.   
27. /*** 
28.  * dexname-----特征字符串，由pDexOrJar->fileName决定的（the feature string） 
29.  * dumppath----内存dump文件的保存路径（the data path of the target app ） 
30.  * /data/dexname文件的示例： 
31.  * /data/data/com.example.seventyfour.tencenttest/files/libmobisecy1.zip 
32.  * /data/data/com.example.seventyfour.tencenttest/ 
33.  *  
34.  * dexname（the feature string）的引用，具体参见作者zyq8709给出的slide.pptx 
35.  * 重要的提醒： 
36.  * Its line ending should be in the style of Unix/Linux 
37.  * 意思就是/data/dexname文件中的字符串的结尾换行必须是Unix/Linux格式0A的不能是windows的0D0A 
38.  ***/  
39.   
40. struct arg  
41. {  
42.     DvmDex* pDvmDex;  
43.     Object * loader;  
44. } param;  
45.   
46. /*******删除定时器********/   
47. void timer_thread(sigval_t)  
48. {  
49.     timer_flag = false;  
50.     timer_delete(timerId);  
51.     ALOGI("GOT IT time up");  
52. }  
53.   
54. /*****读取配置文件/data/dexname中的数据信息并创建初始化定时器******/  
55. void* ReadThread(void *arg)   
56. {  
57.       
58.     FILE *fp = NULL;  
59.     while (dexname[0]==0 || dumppath[0]==0)   
60.     {  
61.         // 打开脱壳的配置文件/data/dexname  
62.         // 脱壳的时，需要adb push dexname /data到Andrid系统里  
63.         // 配置文件/data/dexname是可以自定义的，一些加固如梆梆可能会检测这个路径  
64.         fp=fopen("/data/dexname", "r");  
65.         if (fp==NULL)   
66.         {  
67.             sleep(1);  
68.             continue;  
69.         }  
70.           
71.         // 读取文件中的第1行字符串---加固的特征字符串  
72.         fgets(dexname, 99, fp);  
73.         dexname[strlen(dexname)-1]=0;  
74.           
75.         // 读取文件中的第2行字符串---需要脱壳的apk文件的数据路径  
76.         fgets(dumppath,99,fp);  
77.         dumppath[strlen(dumppath)-1]=0;  
78.           
79.         fclose(fp);  
80.         fp=NULL;  
81.     }  
82.   
83.     struct sigevent sev;  
84.     // 定时器事件类型为创建线程  
85.     sev.sigev_notify=SIGEV_THREAD;  
86.     // 设置事件的线程回调函数的传入参数  
87.     sev.sigev_value.sival_ptr=&timerId;  
88.     // 设置事件的线程回调函数--删除定时器  
89.     sev.sigev_notify_function=timer_thread;  
90.     // 设置事件的线程回调函数的属性  
91.     sev.sigev_notify_attributes = NULL;  
92.   
93.     // 创建定时器  
94.     timer_create(CLOCK_REALTIME, &sev, &timerId);  
95.   
96.     struct itimerspec ts;  
97.     // 定时器的第一次时间间隔  
98.     ts.it_value.tv_sec=5;  
99.     ts.it_value.tv_nsec=0;  
100.     // 定时器的第一次之后的每次时间间隔  
101.     ts.it_interval.tv_sec=0;  
102.     ts.it_interval.tv_nsec=0;  
103.   
104.     // 初始化定时器  
105.     timer_settime(timerId, 0, &ts, NULL);  
106.   
107.     return NULL;  
108. }  
109.   
110. /****获取一个类中静态字段，实例字段，直接方法和虚方法的个数*****/  
111. void ReadClassDataHeader(const uint8_t** pData,  
112.         DexClassDataHeader *pHeader)   
113. {  
114.     // 静态成员变量的个数  
115.     pHeader->staticFieldsSize = readUnsignedLeb128(pData);  
116.     // 实例成员变量的个数  
117.     pHeader->instanceFieldsSize = readUnsignedLeb128(pData);  
118.     // 直接成员方法的个数  
119.     pHeader->directMethodsSize = readUnsignedLeb128(pData);  
120.     // 虚成员方法的个数  
121.     pHeader->virtualMethodsSize = readUnsignedLeb128(pData);  
122. }  
123.   
124. /****获取一个类中成员变量的信息****/  
125. void ReadClassDataField(const uint8_t** pData, DexField* pField)   
126. {  
127.     // 成员变量的DexFieldId索引  
128.     pField->fieldIdx = readUnsignedLeb128(pData);  
129.     // 成员变量的访问权限   
130.     pField->accessFlags = readUnsignedLeb128(pData);  
131. }  
132.   
133. /***获取一个类中成员方法的信息****/  
134. void ReadClassDataMethod(const uint8_t** pData, DexMethod* pMethod)   
135. {  
136.     // 成员方法的DexMethodId索引  
137.     pMethod->methodIdx = readUnsignedLeb128(pData);  
138.     // 成员方法的访问权限  
139.     pMethod->accessFlags = readUnsignedLeb128(pData);  
140.     // 成员方法的实现字节码DexCode的数据结构  
141.     pMethod->codeOff = readUnsignedLeb128(pData);  
142. }  
143.   
144. /***获取一个类的DexClassData和所有成员变量以及个数、成员方法以及个数的结构体的信息*****/  
145. DexClassData* ReadClassData(const uint8_t** pData)   
146. {  
147.     // 类信息的数据头  
148.     DexClassDataHeader header;  
149.   
150.     if (*pData == NULL)   
151.     {  
152.         return NULL;  
153.     }  
154.     // 读取类的数据头信息DexClassDataHeader  
155.     ReadClassDataHeader(pData, &header);  
156.       
157.     // 获取保存整个类的所有的成员变量和成员方法的结构信息需要的内存空间大小  
158.     size_t resultSize = sizeof(DexClassData)   
159.                     + (header.staticFieldsSize * sizeof(DexField))   
160.                     + (header.instanceFieldsSize * sizeof(DexField))   
161.                     + (header.directMethodsSize * sizeof(DexMethod))   
162.                     + (header.virtualMethodsSize * sizeof(DexMethod));  
163.   
164.     // 为保存整个类的全部结构信息申请内存空间  
165.     DexClassData* result = (DexClassData*) malloc(resultSize);  
166.     if (result == NULL) {  
167.         return NULL;  
168.     }  
169.   
170.     // 申请的内存中，指向类的实际存储成员变量DexField和成员方法DexMethod的内存起始地址  
171.     uint8_t* ptr = ((uint8_t*) result) + sizeof(DexClassData);  
172.   
173.     // 内存浅拷贝获取类的数据头信息  
174.     result->header = header;  
175.       
176.     // 判断类是否有静态成员变量  
177.     if (header.staticFieldsSize != 0)   
178.     {  
179.         // 设置保存静态成员变量的DexField的起始地址  
180.         result->staticFields = (DexField*) ptr;  
181.         ptr += header.staticFieldsSize * sizeof(DexField);  
182.     }   
183.     else   
184.     {  
185.         result->staticFields = NULL;  
186.     }  
187.       
188.     // 判断类是否有实例成员变量  
189.     if (header.instanceFieldsSize != 0)   
190.     {  
191.         // 设置保存实例成员变量的DexField的起始地址  
192.         result->instanceFields = (DexField*) ptr;  
193.         ptr += header.instanceFieldsSize * sizeof(DexField);  
194.     }   
195.     else   
196.     {  
197.         result->instanceFields = NULL;  
198.     }  
199.       
200.     // 判断类是否有直接成员方法  
201.     if (header.directMethodsSize != 0)   
202.     {  
203.         // 设置保存直接成员方法的DexMethod的起始地址  
204.         result->directMethods = (DexMethod*) ptr;  
205.         ptr += header.directMethodsSize * sizeof(DexMethod);  
206.     }  
207.     else   
208.     {  
209.         result->directMethods = NULL;  
210.     }  
211.       
212.     // 判断类是否有虚成员方法  
213.     if (header.virtualMethodsSize != 0)   
214.     {  
215.         // 设置保存虚成员方法的DexMethod的起始地址  
216.         result->virtualMethods = (DexMethod*) ptr;  
217.     }   
218.     else   
219.     {  
220.         result->virtualMethods = NULL;  
221.     }  
222.   
223.     // 从内存中读取类的所有的静态成员变量的DexField  
224.     for (uint32_t i = 0; i < header.staticFieldsSize; i++)   
225.     {  
226.         ReadClassDataField(pData, &result->staticFields[i]);  
227.     }  
228.   
229.     // 从内存中读取类的所有的实例成员变量的DexField  
230.     for (uint32_t i = 0; i < header.instanceFieldsSize; i++)   
231.     {  
232.         ReadClassDataField(pData, &result->instanceFields[i]);  
233.     }  
234.   
235.     // 从内存中读取类的所有的直接成员方法的DexMethod  
236.     for (uint32_t i = 0; i < header.directMethodsSize; i++)   
237.     {  
238.         ReadClassDataMethod(pData, &result->directMethods[i]);  
239.     }  
240.       
241.     // 从内存中读取类的所有的虚成员方法的DexMethod  
242.     for (uint32_t i = 0; i < header.virtualMethodsSize; i++)   
243.     {  
244.         ReadClassDataMethod(pData, &result->virtualMethods[i]);  
245.     }  
246.   
247.     return result;  
248. }  
249.   
250.   
251. /*****Leb128类型数据的写入*****/  
252. void writeLeb128(uint8_t ** ptr, uint32_t data)  
253. {  
254.     while (true)   
255.     {  
256.         uint8_t out = data & 0x7f;  
257.         if (out != data)   
258.         {  
259.             *(*ptr)++ = out | 0x80;  
260.             data >>= 7;  
261.         }   
262.         else   
263.         {  
264.             *(*ptr)++ = out;  
265.             break;  
266.         }  
267.     }  
268. }  
269.   
270. /****获取一个类的所有成员变量以及个数、成员方法以及个数的结构体的信息（自定义数据保存格式）*******/  
271. uint8_t* EncodeClassData(DexClassData *pData, int& len)  
272. {  
273.     len = 0;  
274.       
275.     // 获取保存整个类的所有成员变量和成员方法的个数需要的内存大小  
276.     len+=unsignedLeb128Size(pData->header.staticFieldsSize);  
277.     len+=unsignedLeb128Size(pData->header.instanceFieldsSize);  
278.     len+=unsignedLeb128Size(pData->header.directMethodsSize);  
279.     len+=unsignedLeb128Size(pData->header.virtualMethodsSize);  
280.   
281.     // 继续获取保存类的静态成员变量的DexField的大小  
282.     if (pData->staticFields)   
283.     {  
284.         for (uint32_t i = 0; i < pData->header.staticFieldsSize; i++)   
285.         {  
286.             len+=unsignedLeb128Size(pData->staticFields[i].fieldIdx);  
287.             len+=unsignedLeb128Size(pData->staticFields[i].accessFlags);  
288.         }  
289.     }  
290.   
291.     // 继续获取保存类的实例成员变量的DexField的大小  
292.     if (pData->instanceFields)   
293.     {  
294.         for (uint32_t i = 0; i < pData->header.instanceFieldsSize; i++)   
295.         {  
296.             len+=unsignedLeb128Size(pData->instanceFields[i].fieldIdx);  
297.             len+=unsignedLeb128Size(pData->instanceFields[i].accessFlags);  
298.         }  
299.     }  
300.   
301.     // 继续获取保存类的直接成员方法的DexMethod的大小  
302.     if (pData->directMethods) {  
303.         for (uint32_t i=0; i<pData->header.directMethodsSize; i++)   
304.         {  
305.             len+=unsignedLeb128Size(pData->directMethods[i].methodIdx);  
306.             len+=unsignedLeb128Size(pData->directMethods[i].accessFlags);  
307.             len+=unsignedLeb128Size(pData->directMethods[i].codeOff);  
308.         }  
309.     }  
310.   
311.     // 继续获取保存类的虚成员方法的DexMethod的大小  
312.     if (pData->virtualMethods)   
313.     {  
314.         for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++)   
315.         {  
316.             len+=unsignedLeb128Size(pData->virtualMethods[i].methodIdx);  
317.             len+=unsignedLeb128Size(pData->virtualMethods[i].accessFlags);  
318.             len+=unsignedLeb128Size(pData->virtualMethods[i].codeOff);  
319.         }  
320.     }  
321.   
322.     // 为存储整个类的所有的类成员和类方法申请内存空间  
323.     uint8_t * store = (uint8_t *) malloc(len);  
324.     if (!store)   
325.     {  
326.         // 申请内存空间失败  
327.         return NULL;  
328.     }  
329.   
330.     uint8_t * result=store;  
331.   
332.     // 保存整个类所有的静态成员变量的数量大小  
333.     writeLeb128(&store,pData->header.staticFieldsSize);  
334.     // 保存整个类所有的实例成员变量的数量大小  
335.     writeLeb128(&store,pData->header.instanceFieldsSize);  
336.     // 保存整个类的所有的直接成员方法的数量大小  
337.     writeLeb128(&store,pData->header.directMethodsSize);  
338.     // 保存整个类的所有的虚成员方法的数量大小  
339.     writeLeb128(&store,pData->header.virtualMethodsSize);  
340.   
341.     // 保存整个类所有的静态成员变量的DexField  
342.     if (pData->staticFields)   
343.     {  
344.         for (uint32_t i = 0; i < pData->header.staticFieldsSize; i++)   
345.         {  
346.             writeLeb128(&store,pData->staticFields[i].fieldIdx);  
347.             writeLeb128(&store,pData->staticFields[i].accessFlags);  
348.         }  
349.     }  
350.   
351.     // 保存整个类所有的实例成员变量的DexField  
352.     if (pData->instanceFields)   
353.     {  
354.         for (uint32_t i = 0; i < pData->header.instanceFieldsSize; i++)   
355.         {  
356.             // 指向成员变量索引表中的一个表项，即一个DexFieldId的数据结构  
357.             writeLeb128(&store,pData->instanceFields[i].fieldIdx);  
358.             // 访问权限  
359.             writeLeb128(&store,pData->instanceFields[i].accessFlags);  
360.         }  
361.     }  
362.   
363.     // 保存整个类所有的直接成员方法的DexMethod  
364.     if (pData->directMethods)   
365.     {  
366.         for (uint32_t i=0; i<pData->header.directMethodsSize; i++)   
367.         {  
368.             // 指向成员方法索引表中的一个表项，即一个DexMethodId数据结构  
369.             writeLeb128(&store,pData->directMethods[i].methodIdx);  
370.             // 访问权限  
371.             writeLeb128(&store,pData->directMethods[i].accessFlags);  
372.             // 成员方法的指向一个DexCode的数据结构  
373.             writeLeb128(&store,pData->directMethods[i].codeOff);  
374.         }  
375.     }  
376.   
377.     // 保存整个类所有的静虚成员方法的DexMethod  
378.     if (pData->virtualMethods)   
379.     {  
380.         for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++)   
381.         {  
382.             writeLeb128(&store,pData->virtualMethods[i].methodIdx);  
383.             writeLeb128(&store,pData->virtualMethods[i].accessFlags);  
384.             writeLeb128(&store,pData->virtualMethods[i].codeOff);  
385.         }  
386.     }  
387.   
388.     // 释放内存空间  
389.     free(pData);  
390.       
391.     return result;  
392. }  
393.   
394. /***这个函数暂时还是不太理解，与try/catch语句解析有关***/  
395. uint8_t* codeitem_end(const u1** pData)  
396. {  
397.     uint32_t num_of_list = readUnsignedLeb128(pData);  
398.       
399.     for (; num_of_list > 0; num_of_list--)   
400.     {  
401.         int32_t num_of_handlers = readSignedLeb128(pData);  
402.         int num = num_of_handlers;  
403.           
404.         if (num_of_handlers <= 0)   
405.         {  
406.             num =- num_of_handlers;  
407.         }  
408.           
409.         for (; num > 0; num--)   
410.         {  
411.             readUnsignedLeb128(pData);  
412.             readUnsignedLeb128(pData);  
413.         }  
414.           
415.         if (num_of_handlers <= 0)   
416.         {  
417.             readUnsignedLeb128(pData);  
418.         }  
419.     }  
420.       
421.     return (uint8_t*)(*pData);  
422. }  
423.   
424. /*** Use this to keep track of mapped segments. 
425. struct MemMapping  
426. { 
427.     void*  addr;        //start of data 
428.     size_t length;      //length of data 
429.     void*  baseAddr;    //page-aligned base address 
430.     size_t baseLength;  //length of mapping 
431. }; 
432. ***/  
433.   
434. /*** 
435. struct DvmDex  
436. { 
437.     DexFile*               pDexFile;            //odex文件的信息 
438.     const DexHeader*       pHeader;             //dex文件头相关信息 
439.     struct StringObject**  pResStrings;         //字符串 
440.     struct ClassObject**   pResClasses;         //通过DexFile里的ClassDefItem构造出来的一个结构体（类信息） 
441.     struct Method**        pResMethods;         //通过Method_Item构造出来的结构体(方法信息) 
442.     struct Field**         pResFields; 
443.     struct AtomicCache*    pInterfaceCache; 
444.     bool                   isMappedReadOnly; 
445.     MemMapping             memMap;              // memMap->addr为odex文件的内存位置，memMap->length为odex文件的长度 
446.     jobject                dex_object; 
447.     pthread_mutex_t        modLock; 
448. }; 
449. ****/  
450.   
451. /******* 
452. //DexFile结构体存储了odex文件的一些信息。 
453. struct DexFile  
454. { 
455.     //directly-mapped "opt" header  
456.     const DexOptHeader*         pOptHeader; 
457.  
458.     //pointers to directly-mapped structs and arrays in base DEX 
459.     const DexHeader*            pHeader; 
460.     const DexStringId*          pStringIds; 
461.     const DexTypeId*            pTypeIds; 
462.     const DexFieldId*           pFieldIds; 
463.     const DexMethodId*          pMethodIds; 
464.     const DexProtoId*           pProtoIds; 
465.     const DexClassDef*          pClassDefs; 
466.     const DexLink*              pLinkData; 
467.     const DexClassLookup*       pClassLookup; 
468.     const void*                 pRegisterMapPool;       // RegisterMapClassPool 
469.     const u1*                   baseAddr; 
470.     int                         overhead; 
471. }; 
472. *****/  
473.   
474. /**** 
475. struct ClassObject : Object { 
476.  
477.     u4                      instanceData[CLASS_FIELD_SLOTS]; 
478.     const char*             descriptor; 
479.     char*                   descriptorAlloc; 
480.     u4                      accessFlags; 
481.     u4                      serialNumber; 
482.     DvmDex*                 pDvmDex; 
483.     ClassStatus             status; 
484.     ClassObject*            verifyErrorClass; 
485.     u4                      initThreadId; 
486.     size_t                  objectSize; 
487.     ClassObject*            elementClass; 
488.     int                     arrayDim; 
489.     PrimitiveType           primitiveType; 
490.     ClassObject*            super; 
491.     Object*                 classLoader; 
492.     InitiatingLoaderList    initiatingLoaderList; 
493.     int                     interfaceCount; 
494.     ClassObject**           interfaces; 
495.     int                     directMethodCount; 
496.     Method*                 directMethods; 
497.     int                     virtualMethodCount; 
498.     Method*                 virtualMethods; 
499.     int                     vtableCount; 
500.     Method**                vtable; 
501.     int                     iftableCount; 
502.     InterfaceEntry*         iftable; 
503.     int                     ifviPoolCount; 
504.     int*                    ifviPool; 
505.     int                     ifieldCount; 
506.     int                     ifieldRefCount; 
507.     InstField*              ifields; 
508.     u4                      refOffsets; 
509.     const char*             sourceFile; 
510.     int                     sfieldCount; 
511.     StaticField             sfields[0]; 
512. }; 
513. ***/  
514.   
515. void* DumpClass(void *parament)  
516. {  
517.   // 休眠一段时间  
518.   while (timer_flag)   
519.   {  
520.       sleep(5);  
521.   }  
522.     
523.   // 获取odex文件的内存描述结构DvmDex  
524.   DvmDex* pDvmDex=((struct arg*)parament)->pDvmDex;  
525.   Object *loader=((struct arg*)parament)->loader;  
526.     
527.   // 获取指向odex文件的指针  
528.   DexFile* pDexFile = pDvmDex->pDexFile;  
529.   // 获取内存存放odex文件的内存信息描述  
530.   MemMapping * mem = &pDvmDex->memMap;  
531.   
532.   // 获取当前时间  
533.   u4 time = dvmGetRelativeTimeMsec();  
534.   ALOGI("GOT IT begin: %d ms", time);  
535.   
536.   // 申请内存空间  
537.   char *path = new char[100];  
538.     
539.   // 获取需要脱壳的apk的数据目录的路径  
540.   strcpy(path, dumppath);  
541.   // 拼接字符串  
542.   strcat(path, "classdef");  
543.     
544.   // 打开文件xxxx/classdef  
545.   FILE *fp = fopen(path, "wb+");  
546.   
547.   strcpy(path, dumppath);  
548.   //  拼接字符串  
549.   strcat(path, "extra");  
550.     
551.   // 打开文件xxxx/extra  
552.   FILE *fp1 = fopen(path,"wb+");  
553.   
554.   uint32_t mask = 0x3ffff;  
555.   char padding = 0;  
556.   const char* header = "Landroid";  
557.     
558.   // 获取dex文件的DexClassDef的数量classDefsSize  
559.   unsigned int num_class_defs = pDexFile->pHeader->classDefsSize;  
560.     
561.   // pDexFile->baseAddr为存放dex文件的内存地址，  
562.   //mem->addr为存放odex的文件的数据的内存地址,mem->length为存放的odex文件的长度   
563.   // 获取dex文件起始到odex文件结束在内存区域的长度  
564.   uint32_t total_pointer = mem->length - uint32_t(pDexFile->baseAddr-(const u1*)mem->addr);  
565.   // 保存dex文件起始到odex文件结束在内存区域的长度  
566.   uint32_t rec = total_pointer;  
567.   // 鉴于dex文件在内存中的4字节对齐问题  
568.   while (total_pointer&3)   
569.   {  
570.       total_pointer++;  
571.   }  
572.   
573.   // 增加的内存字节数inc  
574.   int inc = total_pointer - rec;  
575.     
576.   // 在内存中dex文件存放DexClassData的起始文件相对偏移#############  
577.   uint32_t start = pDexFile->pHeader->classDefsOff+sizeof(DexClassDef)*num_class_defs;  
578.   // 在内存中dex文件存放DexClassData的结束文件相对偏移#############  
579.   uint32_t end = (uint32_t)((const u1*)mem->addr+mem->length - pDexFile->baseAddr);  
580.   
581.   // 遍历dex文件的所有的DexClassDef  
582.   for (size_t i = 0; i < num_class_defs; i++)  //Loop start ----------  
583.   {  
584.       bool need_extra = false;  
585.       const u1* data = NULL;  
586.       DexClassData* pData = NULL;  
587.       bool pass = false;  
588.         
589.       // 获取dex文件的第i个DexClassDef的结构体信息  
590.       const DexClassDef *pClassDef = dexGetClassDef(pDvmDex->pDexFile, i);  
591.       // 获取类的描述符信息即类类型字符串如：Landroid/xxx/yyy;  
592.       const char *descriptor = dexGetClassDescriptor(pDvmDex->pDexFile, pClassDef);  
593.   
594.       // 判断该类是否是Landroid开头的系统类，是否是一个有效的类  
595.       if(!strncmp(header, descriptor, 8) || !pClassDef->classDataOff)  
596.       {  
597.           // 设置跳过过滤标签  
598.           pass = true;  
599.             
600.           // ******是系统类或者当前类不是有效的类，直接跳转******  
601.           goto classdef;  
602.       }  
603.   
604.       ClassObject * clazz=NULL;  
605.       // ########加载类描述符指定的类#####################  
606.       clazz = dvmDefineClass(pDvmDex, descriptor, loader);  
607.       if (!clazz)   
608.       {  
609.          continue;  
610.       }  
611.       //#################################################  
612.   
613.       // 打印加载的类描述符信息  
614.       ALOGI("GOT IT 加载class: %s", descriptor);  
615.   
616.       // 判断加载的指定的类是否已经初始化完成  
617.       if (!dvmIsClassInitialized(clazz))   
618.       {  
619.           if(dvmInitClass(clazz))  
620.           {  
621.               ALOGI("GOT IT init: %s", descriptor);  
622.           }  
623.       }  
624.         
625.       // 判断类的classData的偏移classDataOff是否在正常的内存范围      
626.       if(pClassDef->classDataOff < start || pClassDef->classDataOff > end)  
627.       {  
628.           need_extra = true;  
629.       }  
630.   
631.       // 获取dex文件的一个类的类数据DexClassData的内存地址  
632.       data = dexGetClassData(pDexFile, pClassDef);  
633.       // 获取dex文件的一个类的类数据DexClassData以及成员变量DexField和成员方法DexMethod的结构  
634.       pData = ReadClassData(&data);  
635.       if (!pData)   
636.       {  
637.           // 获取失败，继续下次循环  
638.           continue;  
639.       }  
640.   
641.       // 获取类成员直接方法  
642.       if (pData->directMethods) // looop start++++++++++++++++++++++++++++  
643.       {  
644.           for (uint32_t i = 0; i < pData->header.directMethodsSize; i++)   
645.           {  
646.               // 获取类成员的直接方法的指针  
647.               Method *method = &(clazz->directMethods[i]);  
648.               // 用于判断函数是否是native函数相关  
649.               uint32_t ac = (method->accessFlags) & mask;  
650.   
651.               // 打印类成员直接方法的名称  
652.               ALOGI("GOT IT direct method name %s.%s", descriptor, method->name);  
653.   
654.               // method->insns为Dalvik虚拟机自带的Native函数（Internal Native）则值为Null  
655.               // method->insns为普通的Native函数则为指向JNI实际函数机器码的首地址  
656.               if (!method->insns || ac&ACC_NATIVE)   
657.               {  
658.                   // 获取指向类成员直接方法字节码的指针  
659.                   if (pData->directMethods[i].codeOff)   
660.                   {  
661.                       // 设置需要额外数据的标志  
662.                       need_extra = true;  
663.                         
664.                       // 设置类成员直接方法的访问权限值  
665.                       pData->directMethods[i].accessFlags=ac;  
666.                       // 设置类成员直接方法的字节码指针为0  
667.                       pData->directMethods[i].codeOff=0;  
668.                   }  
669.                     
670.                   // 继续下次循环  
671.                   continue;  
672.               }  
673.   
674.               /****  
675.                method->insns不是Native方法的情况，则为指向方法具体的Dalvik指令的指针 
676.               （指向的是实际加载到内存中的Dalvik指令，而不是在Dex文件中的） 
677.               ****/  
678.               // 获取method->insns不是Native方法的情况下，方法的字节码实际相对偏移codeOff  
679.               u4 codeitem_off = u4((const u1*)method->insns-16-pDexFile->baseAddr);  
680.                 
681.               // 修正method->insns不是Native方法的accessFlags  
682.               if (ac != pData->directMethods[i].accessFlags)  
683.               {  
684.                   ALOGI("GOT IT method ac");  
685.                   need_extra=true;  
686.                   pData->directMethods[i].accessFlags=ac;  
687.               }  
688.               // 修正method->insns不是Native方法的字节码正常相对偏移codeOff  
689.               if (codeitem_off!=pData->directMethods[i].codeOff && ((codeitem_off>=start&&codeitem_off<=end) || codeitem_off==0))   
690.               {  
691.                   ALOGI("GOT IT method code");  
692.                   need_extra = true;  
693.                   pData->directMethods[i].codeOff=codeitem_off;  
694.               }  
695.   
696.               // 修正method->insns不是Native方法但是codeOff被app加固修改的情况下的codeOff  
697.               // 此种情况的方法的dex文件在内存中被分开存放了，codeOff的相对偏移值超出了正常dex文件的内存范围  
698.               if ((codeitem_off < start || codeitem_off > end) && codeitem_off != 0)   
699.               {  
700.                   need_extra=true;  
701.                   // 设置类方法的codeOff值为total_pointer#############  
702.                   pData->directMethods[i].codeOff = total_pointer;  
703.                   // 获取类方法的信息结构体DexCode  
704.                   DexCode *code = (DexCode*)((const u1*)method->insns-16);  
705.                   // item保存类方法的字节码指令集内存指针  
706.                   uint8_t *item=(uint8_t *) code;  
707.                     
708.                   // 获取类方法的实际字节码的长度  
709.                   int code_item_len = 0;  
710.                   if (code->triesSize)   
711.                   {  
712.                       // 类方法中有Try/Catch语句存在的情况  
713.                       // 获取DexCode中的try/catch语句的hander数据信息  
714.                       const u1 * handler_data = dexGetCatchHandlerData(code);  
715.                       const u1** phandler=(const u1**)&handler_data;  
716.                       // 计算DexCode结构体中insns字节码指令集的结束地址偏移  
717.                       uint8_t * tail = codeitem_end(phandler);  
718.                         
719.                       // 获取到类方法的DexCode中的字节码指令集的长度  
720.                       code_item_len = (int)(tail-item);  
721.                   }  
722.                   else  
723.                   {  
724.                       // 计算DexCode中的字节码指令集的长度  
725.                       code_item_len = 16+code->insnsSize*2;  
726.                   }  
727.   
728.                   ALOGI("GOT IT method code changed");  
729.   
730.                   // 将类方法的字节码指令集method->insns写入文件xxxx/extra中  
731.                   fwrite(item, 1, code_item_len, fp1);  
732.                   // 刷新文件流  
733.                   fflush(fp1);  
734.                     
735.                   // 设置下一个method->insns的内存地址  
736.                   total_pointer+=code_item_len;  
737.                   // method->insns的4字节对齐问题  
738.                   while (total_pointer&3)  
739.                   {  
740.                       // 写入0填充，处理4字节的对齐的问题  
741.                       fwrite(&padding, 1, 1, fp1);  
742.                       // 刷新文件流  
743.                       fflush(fp1);  
744.                         
745.                       total_pointer++;  
746.                   }  
747.               }  
748.                 
749.           }  
750.       } // looop over++++++++++++++++++++++++++++  
751.   
752.       // 获取类成员虚方法的method->insns字节码指令保存到文件xxxx/extra  
753.       if (pData->virtualMethods)    // looop start========================  
754.       {  
755.           for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++)   
756.           {  
757.               Method *method = &(clazz->virtualMethods[i]);  
758.               uint32_t ac = (method->accessFlags) & mask;  
759.   
760.               ALOGI("GOT IT virtual method name %s.%s", descriptor, method->name);  
761.   
762.               if (!method->insns||ac&ACC_NATIVE)   
763.               {  
764.                   if (pData->virtualMethods[i].codeOff)   
765.                   {  
766.                       need_extra = true;  
767.   
768.                       pData->virtualMethods[i].accessFlags = ac;  
769.                       pData->virtualMethods[i].codeOff = 0;  
770.                   }  
771.                     
772.                   continue;  
773.               }  
774.   
775.               u4 codeitem_off = u4((const u1 *)method->insns - 16 - pDexFile->baseAddr);  
776.   
777.               if (ac != pData->virtualMethods[i].accessFlags)  
778.               {  
779.                   ALOGI("GOT IT method ac");  
780.   
781.                   need_extra = true;  
782.                   pData->virtualMethods[i].accessFlags=ac;  
783.               }  
784.   
785.               if (codeitem_off!=pData->virtualMethods[i].codeOff&&((codeitem_off>=start&&codeitem_off<=end)||codeitem_off==0))   
786.               {  
787.                   ALOGI("GOT IT method code");  
788.                   need_extra=true;  
789.                   pData->virtualMethods[i].codeOff=codeitem_off;  
790.               }  
791.   
792.               // 类成员方法的codeOff被加固修改了，dex文件在内存中分成了2份  
793.               if ((codeitem_off < start || codeitem_off > end) && codeitem_off!=0)   
794.               {  
795.                   need_extra = true;  
796.   
797.                   // 将这部分类方法的DexCode数据保存到odex文件末尾的后面  
798.                   pData->virtualMethods[i].codeOff = total_pointer;  
799.                   DexCode *code = (DexCode*)((const u1*)method->insns-16);  
800.                   uint8_t *item=(uint8_t *) code;  
801.                   int code_item_len = 0;  
802.                     
803.                   if (code->triesSize)   
804.                   {  
805.                       const u1 *handler_data = dexGetCatchHandlerData(code);  
806.                       const u1** phandler=(const u1**)&handler_data;  
807.                       uint8_t * tail=codeitem_end(phandler);  
808.                       code_item_len = (int)(tail-item);  
809.                   }  
810.                   else  
811.                   {  
812.                       code_item_len = 16+code->insnsSize*2;  
813.                   }  
814.   
815.                   ALOGI("GOT IT method code changed");  
816.   
817.                   // 将这部分类方法的DexCode数据暂时保存到文件ata/data/xxxx.xxxx.xxx/extra中  
818.                   fwrite(item, 1, code_item_len, fp1);  
819.                   fflush(fp1);  
820.   
821.                   total_pointer += code_item_len;  
822.                   while (total_pointer&3)   
823.                   {  
824.                       fwrite(&padding, 1, 1, fp1);  
825.                       fflush(fp1);  
826.   
827.                       total_pointer++;  
828.                   }  
829.               }  
830.           }  
831.       } // looop over========================  
832.   
833.   
834. // 系统类或者当前类不是有效的类情况  
835. classdef:  
836.        // 获取类的整体信息结构DexClassDef  
837.        DexClassDef temp = *pClassDef;  
838.        uint8_t *p = (uint8_t *)&temp;  
839.   
840.        // 判断是否需要额外的dex文件的类数据信息  
841.        if (need_extra)   
842.        {  
843.            ALOGI("GOT IT classdata before");  
844.            int class_data_len = 0;  
845.              
846.            // 将类数据信息如成员变量的DexField和成员方法的DexMethod进行编码保存到申请的内存中  
847.            // pData = ReadClassData(&data);  
848.            uint8_t *out = EncodeClassData(pData, class_data_len);  
849.            if (!out)   
850.            {  
851.                // 保存到申请的内存中失败  
852.                continue;  
853.            }  
854.              
855.            // 设置类成员方法的DexClassData的相对文件偏移  
856.            temp.classDataOff = total_pointer;  
857.              
858.            // 将类的成员方法的信息写入xxxx/extra文件  
859.            fwrite(out, 1, class_data_len, fp1);  
860.            // 刷新文件流  
861.            fflush(fp1);  
862.              
863.            // 继续更新指向的类成员方法存储位置的指针  
864.            total_pointer += class_data_len;  
865.            // 处理dex文件在内存中4字节对齐的问题  
866.            while (total_pointer&3)   
867.            {  
868.                // 写入填充的数据0  
869.                fwrite(&padding,1,1,fp1);  
870.                // 刷新文件流  
871.                fflush(fp1);  
872.                  
873.                total_pointer++;  
874.            }  
875.            free(out);  
876.              
877.            ALOGI("GOT IT classdata written");  
878.        }  
879.        else  
880.        {  
881.            // pData = ReadClassData(&data);  
882.            if (pData)   
883.            {  
884.                free(pData);  
885.            }  
886.        }  
887.   
888.        // 对系统类或者当前类不是有效的类的情况，修改classDataOff和annotationsOff值为0  
889.        if (pass)   
890.        {  
891.            // 设置类信息结构体的classDataOff和annotationsOff为0  
892.            temp.classDataOff = 0;  
893.            temp.annotationsOff = 0;  
894.        }  
895.   
896.        ALOGI("GOT IT classdef");  
897.          
898.        // 将DexClassDef结构体的大小写入到文件xxxx/classdef中  
899.        fwrite(p, sizeof(DexClassDef), 1, fp);  
900.        // 刷新文件流  
901.        fflush(fp);  
902.          
903.   } //Loop over ----------  
904.   
905.   // 关闭文件  
906.   fclose(fp1);  
907.   fclose(fp);  
908.   
909.   strcpy(path, dumppath);  
910.   // 拼接字符串  
911.   strcat(path, "whole.dex");  
912.     
913.   // 打开文件xxxx/whole.dex  
914.   fp = fopen(path,"wb+");  
915.   // 设置文件指针在文件头的位置  
916.   rewind(fp);  
917.   
918.   int fd = -1;  
919.   int r = -1;  
920.   int len = 0;    
921.   char *addr = NULL;  
922.   struct stat st;  
923.   
924.   // ******************************************  
925.   strcpy(path, dumppath);  
926.   // 拼接字符串  
927.   strcat(path, "part1");  
928.   
929.   // 打开文件xxxx/part1  
930.   fd = open(path, O_RDONLY, 0666);  
931.   if (fd==-1)   
932.   {  
933.       return NULL;  
934.   }  
935.   
936.   // 获取文件的文件状态信息  
937.   r = fstat(fd, &st);    
938.   if(r==-1)  
939.   {    
940.       close(fd);    
941.       return NULL;  
942.   }  
943.   
944.   // 获取文件的大小  
945.   len = st.st_size;  
946.     
947.   // 为文件创建内存映射  
948.   addr = (char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);  
949.   // 将odex文件的开头到dex文件classDefsOff之间的文件数据写入到文件xxxx/whole.dex中  
950.   fwrite(addr, 1, len, fp);  
951.   // 刷新文件流  
952.   fflush(fp);  
953.     
954.   // 取消内存映射  
955.   munmap(addr, len);  
956.   // 关闭文件  
957.   close(fd);  
958.   // ******************************************  
959.   
960.   strcpy(path, dumppath);  
961.   // 拼接字符串  
962.   strcat(path,"classdef");  
963.   // 打开文件xxxx/classdef  
964.   fd = open(path, O_RDONLY, 0666);  
965.   if(fd==-1)   
966.   {  
967.       return NULL;  
968.   }  
969.   
970.   // 获取文件的文件状态信息  
971.   r = fstat(fd,&st);    
972.   if(r==-1)  
973.   {    
974.       close(fd);    
975.       return NULL;  
976.   }  
977.   
978.   // 获取文件的大小  
979.   len=st.st_size;  
980.   // 为文件创建内存映射  
981.   addr = (char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);  
982.   // 将addr中的数据写入到文件xxxx/whole.dex中  
983.   fwrite(addr, 1, len, fp);  
984.   // 刷新文件流  
985.   fflush(fp);  
986.     
987.   // 取消内存映射  
988.   munmap(addr, len);  
989.   // 关闭文件  
990.   close(fd);  
991.   
992.   // *********************************************  
993.   strcpy(path, dumppath);  
994.   // 拼接字符串  
995.   strcat(path, "data");  
996.   
997.   // 打开文件xxxx/data  
998.   fd = open(path, O_RDONLY, 0666);  
999.   if (fd==-1)   
1000.   {  
1001.       return NULL;  
1002.   }  
1003.   
1004.   // 获取文件的文件状态信息  
1005.   r = fstat(fd, &st);    
1006.   if(r==-1)  
1007.   {    
1008.       close(fd);    
1009.       return NULL;  
1010.   }  
1011.   
1012.   // 获取文件的大小  
1013.   len=st.st_size;  
1014.   // 创建文件的内存映射  
1015.   addr=(char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);  
1016.   // 将内存odex文件中存放DexClassDef结构体以后的所有的文件数据写入到文件xxxx/whole.dex中  
1017.   fwrite(addr, 1, len, fp);  
1018.   // 刷新文件流  
1019.   fflush(fp);  
1020.     
1021.   // 取消内存映射  
1022.   munmap(addr,len);  
1023.   // 关闭文件  
1024.   close(fd);  
1025.   
1026.   // 4字节对齐导致的0填充  
1027.   while (inc > 0)   
1028.   {  
1029.       // 向文件中写入填充数据0  
1030.       fwrite(&padding, 1, 1, fp);  
1031.       // 刷新文件流  
1032.       fflush(fp);  
1033.         
1034.       inc--;  
1035.   }  
1036.   
1037.   // ******************************************  
1038.   strcpy(path,dumppath);  
1039.   // 拼接字符串  
1040.   strcat(path,"extra");  
1041.   
1042.   // 打开文件xxxx/extra  
1043.   fd=open(path, O_RDONLY, 0666);  
1044.   if (fd==-1)   
1045.   {  
1046.       return NULL;  
1047.   }  
1048.   
1049.   // 获取文件的文件状态信息  
1050.   r = fstat(fd, &st);    
1051.   if(r==-1)  
1052.   {    
1053.       close(fd);    
1054.       return NULL;  
1055.   }  
1056.   
1057.   // 获取文件的大小  
1058.   len=st.st_size;  
1059.   // 创建文件内存映射  
1060.   addr=(char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);  
1061.   // 将addr中的数据写入到文件xxxx/whole.dex中  
1062.   fwrite(addr,1,len,fp);  
1063.   // 刷新文件流  
1064.   fflush(fp);  
1065.     
1066.   // 取消文件文件内存映射  
1067.   munmap(addr,len);  
1068.   // 关闭文件  
1069.   close(fd);  
1070.   
1071.   // 关闭文件  
1072.   fclose(fp);  
1073.     
1074.   // 释放申请的内存空间  
1075.   delete path;  
1076.   
1077.   // 获取此时的时间  
1078.   time = dvmGetRelativeTimeMsec();  
1079.   ALOGI("GOT IT end: %d ms", time);  
1080.   
1081.   return NULL;  
1082. }  
1083. //------------------------added end----------------------//  
1084.   
1085. /**** 
1086. typedef struct DexOrJar { 
1087.     char*          fileName; 
1088.     bool           isDex;       //是dex文件还是jar包 
1089.     bool           okayToFree; 
1090.     RawDexFile*    pRawDexFile; 
1091.     JarFile*       pJarFile;    //如果是jar包，则指向JarFile结构 
1092.     u1*            pDexMemory;  //如果是dex，则指向dex内存区 
1093. } DexOrJar; 
1094. ***/  
1095.   
1096.   
1097. static void Dalvik_dalvik_system_DexFile_defineClassNative(const u4* args,  
1098.     JValue* pResult)  
1099. {  
1100.     StringObject* nameObj = (StringObject*) args[0];  
1101.     Object* loader = (Object*) args[1];  
1102.     int cookie = args[2];  
1103.     ClassObject* clazz = NULL;  
1104.     DexOrJar* pDexOrJar = (DexOrJar*) cookie;  
1105.     DvmDex* pDvmDex;  
1106.     char* name;  
1107.     char* descriptor;  
1108.   
1109.     name = dvmCreateCstrFromString(nameObj);  
1110.     descriptor = dvmDotToDescriptor(name);  
1111.     ALOGV("--- Explicit class load '%s' l=%p c=0x%08x",  
1112.         descriptor, loader, cookie);  
1113.     free(name);  
1114.   
1115.     if (!validateCookie(cookie))  
1116.         RETURN_VOID();  
1117.   
1118.     if (pDexOrJar->isDex)  
1119.         pDvmDex = dvmGetRawDexFileDex(pDexOrJar->pRawDexFile);  
1120.     else  
1121.         pDvmDex = dvmGetJarFileDex(pDexOrJar->pJarFile);  
1122.   
1123.     /* once we load something, we can't unmap the storage */  
1124.     pDexOrJar->okayToFree = false;  
1125.   
1126.   
1127. //------------------------added begin----------------------//  
1128.     int uid = getuid();  
1129.     if (uid)   
1130.     {  
1131.         // 非root情况下执行  
1132.         if (readable)   
1133.         {  
1134.             // 创建互斥信号通量  
1135.             pthread_mutex_lock(&read_mutex);  
1136.             if (readable)   
1137.             {  
1138.                 readable = false;  
1139.                 // 释放互斥信号通量  
1140.                 pthread_mutex_unlock(&read_mutex);  
1141.   
1142.                 pthread_t read_thread;  
1143.                 // 创建线程，读取脱壳的配置文件/data/dexname以及等待定时器timer  
1144.                 pthread_create(&read_thread, NULL, ReadThread, NULL);  
1145.   
1146.             }  
1147.             else  
1148.             {  
1149.                 // 释放互斥信号通量  
1150.                 pthread_mutex_unlock(&read_mutex);  
1151.             }  
1152.         }  
1153.     }  
1154.   
1155.     // 非root情况且特征字符串不为空的情况下  
1156.     if(uid && strcmp(dexname, ""))  
1157.     {  
1158.         // 判断当前进程的apk是否是需要被脱壳的apk  
1159.         char * res = strstr(pDexOrJar->fileName, dexname);  
1160.         if (res&&flag)   
1161.         {  
1162.             // 创建互斥信号通量  
1163.             pthread_mutex_lock(&mutex);  
1164.             if (flag)   
1165.             {  
1166.                 // 设置脱壳操作的开关为闭  
1167.                 flag = false;  
1168.                 // 释放互斥信号通量  
1169.                 pthread_mutex_unlock(&mutex);  
1170.    
1171.                 // 获取内存中odex文件的结构信息  
1172.                 DexFile* pDexFile = pDvmDex->pDexFile;  
1173.                 // 获取odex文件在内存中的存放信息  
1174.                 MemMapping * mem = &pDvmDex->memMap;  
1175.   
1176.                 char * temp = new char[100];  
1177.                   
1178.                 //-----------------第1步-----------------------  
1179.                   
1180.                 // 获取当前进程apk的数据目录路径/data/data/xxxx/  
1181.                 strcpy(temp, dumppath);  
1182.                 // 拼接字符串  
1183.                 strcat(temp, "part1");  
1184.                 // 打开文件/data/data/xxxx/part1  
1185.                 FILE *fp = fopen(temp, "wb+");  
1186.                   
1187.                 // 获取odex文件在内存中的存放指针  
1188.                 const u1 *addr = (const u1*)mem->addr;  
1189.                 // 获取odex文件的开头到dex文件classDefsOff之间的文件数据的长度  
1190.                 int length = int(pDexFile->baseAddr+pDexFile->pHeader->classDefsOff-addr);  
1191.                 // 将这部分文件数据写入到文件/data/data/xxxx/part1中  
1192.                 fwrite(addr,1,length,fp);  
1193.                 // 刷新文件流  
1194.                 fflush(fp);  
1195.                 // 关闭文件  
1196.                 fclose(fp);  
1197.                   
1198.                 //-----------------第2步-----------------------  
1199.   
1200.                 // 获取当前进程apk的数据目录路径/data/data/xxxx/  
1201.                 strcpy(temp, dumppath);  
1202.                 // 拼接字符串  
1203.                 strcat(temp,"data");  
1204.                 // 打开文件/data/data/xxxx/data  
1205.                 fp = fopen(temp, "wb+");  
1206.                 // 获取内存中dex文件存放DexClassDef结构体的结束内存地址  
1207.                 addr = pDexFile->baseAddr+pDexFile->pHeader->classDefsOff+sizeof(DexClassDef)*pDexFile->pHeader->classDefsSize;  
1208.                 // 获取内存中odex文件存放DexClassDef结构体以后的所有的文件的数据的长度  
1209.                 length = int((const u1*)mem->addr+mem->length-addr);  
1210.                 // 将这部分数据写入到文件/data/data/xxxx/data中  
1211.                 fwrite(addr, 1, length, fp);  
1212.                 // 刷新文件流  
1213.                 fflush(fp);  
1214.                 // 关闭文件  
1215.                 fclose(fp);  
1216.                   
1217.                 // 删除申请的内存空间  
1218.                 delete temp;  
1219.                   
1220.                 //-----------------第3步-----------------------  
1221.                   
1222.                 // 用于保存线程id  
1223.                 pthread_t dumpthread;  
1224.   
1225.                 //  构建线程的传入参数  
1226.                 param.loader = loader;  
1227.                 param.pDvmDex = pDvmDex;  
1228.                   
1229.                 // 创建线程进行类class的内存dump  
1230.                 dvmCreateInternalThread(&dumpthread, "ClassDumper", DumpClass, (void*)¶m);                               
1231.   
1232.             }  
1233.             else  
1234.             {  
1235.                 // 释放互斥信号通量  
1236.                 pthread_mutex_unlock(&mutex);  
1237.             }  
1238.         }  
1239.     }  
1240. //------------------------added end----------------------//  
1241.   
1242.   
1243.     clazz = dvmDefineClass(pDvmDex, descriptor, loader);  
1244.     Thread* self = dvmThreadSelf();  
1245.     if (dvmCheckException(self)) {  
1246.         /* 
1247.          * If we threw a "class not found" exception, stifle it, since the 
1248.          * contract in the higher method says we simply return null if 
1249.          * the class is not found. 
1250.          */  
1251.         Object* excep = dvmGetException(self);  
1252.         if (strcmp(excep->clazz->descriptor,  
1253.                    "Ljava/lang/ClassNotFoundException;") == 0 ||  
1254.             strcmp(excep->clazz->descriptor,  
1255.                    "Ljava/lang/NoClassDefFoundError;") == 0)  
1256.         {  
1257.             dvmClearException(self);  
1258.         }  
1259.         clazz = NULL;  
1260.     }  
1261.   
1262.     free(descriptor);  
1263.     RETURN_PTR(clazz);  
1264. }  

//------------------------added begin----------------------//

#include <asm/siginfo.h>
#include "libdex/DexClass.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>


// 保存加固类型的特征字符串，其实是由pDexOrJar->fileName决定的
static char dexname[100]={0};
// 保存需要脱壳的apk文件的内存dump出来的part1、data等文件的保存路径
static char dumppath[100]={0};

static bool readable=true;

static pthread_mutex_t read_mutex;

static bool flag=true;

static pthread_mutex_t mutex;

static bool timer_flag=true;

static timer_t timerId;

/***
 * dexname-----特征字符串，由pDexOrJar->fileName决定的（the feature string）
 * dumppath----内存dump文件的保存路径（the data path of the target app ）
 * /data/dexname文件的示例：
 * /data/data/com.example.seventyfour.tencenttest/files/libmobisecy1.zip
 * /data/data/com.example.seventyfour.tencenttest/
 * 
 * dexname（the feature string）的引用，具体参见作者zyq8709给出的slide.pptx
 * 重要的提醒：
 * Its line ending should be in the style of Unix/Linux
 * 意思就是/data/dexname文件中的字符串的结尾换行必须是Unix/Linux格式0A的不能是windows的0D0A
 ***/

struct arg
{
    DvmDex* pDvmDex;
    Object * loader;
} param;

/*******删除定时器********/ 
void timer_thread(sigval_t)
{
    timer_flag = false;
    timer_delete(timerId);
    ALOGI("GOT IT time up");
}

/*****读取配置文件/data/dexname中的数据信息并创建初始化定时器******/
void* ReadThread(void *arg) 
{
	
    FILE *fp = NULL;
    while (dexname[0]==0 || dumppath[0]==0) 
    {
		// 打开脱壳的配置文件/data/dexname
		// 脱壳的时，需要adb push dexname /data到Andrid系统里
		// 配置文件/data/dexname是可以自定义的，一些加固如梆梆可能会检测这个路径
        fp=fopen("/data/dexname", "r");
        if (fp==NULL) 
        {
            sleep(1);
            continue;
        }
        
        // 读取文件中的第1行字符串---加固的特征字符串
        fgets(dexname, 99, fp);
        dexname[strlen(dexname)-1]=0;
        
        // 读取文件中的第2行字符串---需要脱壳的apk文件的数据路径
        fgets(dumppath,99,fp);
        dumppath[strlen(dumppath)-1]=0;
        
        fclose(fp);
        fp=NULL;
    }

    struct sigevent sev;
    // 定时器事件类型为创建线程
    sev.sigev_notify=SIGEV_THREAD;
    // 设置事件的线程回调函数的传入参数
    sev.sigev_value.sival_ptr=&timerId;
    // 设置事件的线程回调函数--删除定时器
    sev.sigev_notify_function=timer_thread;
    // 设置事件的线程回调函数的属性
    sev.sigev_notify_attributes = NULL;

    // 创建定时器
    timer_create(CLOCK_REALTIME, &sev, &timerId);

    struct itimerspec ts;
    // 定时器的第一次时间间隔
    ts.it_value.tv_sec=5;
    ts.it_value.tv_nsec=0;
    // 定时器的第一次之后的每次时间间隔
    ts.it_interval.tv_sec=0;
    ts.it_interval.tv_nsec=0;

	// 初始化定时器
    timer_settime(timerId, 0, &ts, NULL);

    return NULL;
}

/****获取一个类中静态字段，实例字段，直接方法和虚方法的个数*****/
void ReadClassDataHeader(const uint8_t** pData,
        DexClassDataHeader *pHeader) 
{
	// 静态成员变量的个数
    pHeader->staticFieldsSize = readUnsignedLeb128(pData);
    // 实例成员变量的个数
    pHeader->instanceFieldsSize = readUnsignedLeb128(pData);
    // 直接成员方法的个数
    pHeader->directMethodsSize = readUnsignedLeb128(pData);
    // 虚成员方法的个数
    pHeader->virtualMethodsSize = readUnsignedLeb128(pData);
}

/****获取一个类中成员变量的信息****/
void ReadClassDataField(const uint8_t** pData, DexField* pField) 
{
	// 成员变量的DexFieldId索引
    pField->fieldIdx = readUnsignedLeb128(pData);
    // 成员变量的访问权限 
    pField->accessFlags = readUnsignedLeb128(pData);
}

/***获取一个类中成员方法的信息****/
void ReadClassDataMethod(const uint8_t** pData, DexMethod* pMethod) 
{
	// 成员方法的DexMethodId索引
    pMethod->methodIdx = readUnsignedLeb128(pData);
    // 成员方法的访问权限
    pMethod->accessFlags = readUnsignedLeb128(pData);
    // 成员方法的实现字节码DexCode的数据结构
    pMethod->codeOff = readUnsignedLeb128(pData);
}

/***获取一个类的DexClassData和所有成员变量以及个数、成员方法以及个数的结构体的信息*****/
DexClassData* ReadClassData(const uint8_t** pData) 
{
	// 类信息的数据头
    DexClassDataHeader header;

    if (*pData == NULL) 
    {
        return NULL;
    }
	// 读取类的数据头信息DexClassDataHeader
    ReadClassDataHeader(pData, &header);
	
	// 获取保存整个类的所有的成员变量和成员方法的结构信息需要的内存空间大小
    size_t resultSize = sizeof(DexClassData) 
					+ (header.staticFieldsSize * sizeof(DexField)) 
					+ (header.instanceFieldsSize * sizeof(DexField)) 
					+ (header.directMethodsSize * sizeof(DexMethod)) 
					+ (header.virtualMethodsSize * sizeof(DexMethod));

	// 为保存整个类的全部结构信息申请内存空间
    DexClassData* result = (DexClassData*) malloc(resultSize);
    if (result == NULL) {
        return NULL;
    }

	// 申请的内存中，指向类的实际存储成员变量DexField和成员方法DexMethod的内存起始地址
    uint8_t* ptr = ((uint8_t*) result) + sizeof(DexClassData);

	// 内存浅拷贝获取类的数据头信息
    result->header = header;
    
    // 判断类是否有静态成员变量
    if (header.staticFieldsSize != 0) 
    {
		// 设置保存静态成员变量的DexField的起始地址
        result->staticFields = (DexField*) ptr;
        ptr += header.staticFieldsSize * sizeof(DexField);
    } 
    else 
    {
        result->staticFields = NULL;
    }
    
	// 判断类是否有实例成员变量
    if (header.instanceFieldsSize != 0) 
    {
		// 设置保存实例成员变量的DexField的起始地址
        result->instanceFields = (DexField*) ptr;
        ptr += header.instanceFieldsSize * sizeof(DexField);
    } 
    else 
    {
        result->instanceFields = NULL;
    }
    
	// 判断类是否有直接成员方法
    if (header.directMethodsSize != 0) 
    {
		// 设置保存直接成员方法的DexMethod的起始地址
        result->directMethods = (DexMethod*) ptr;
        ptr += header.directMethodsSize * sizeof(DexMethod);
    }
    else 
    {
        result->directMethods = NULL;
    }
    
	// 判断类是否有虚成员方法
    if (header.virtualMethodsSize != 0) 
    {
		// 设置保存虚成员方法的DexMethod的起始地址
        result->virtualMethods = (DexMethod*) ptr;
    } 
    else 
    {
        result->virtualMethods = NULL;
    }

	// 从内存中读取类的所有的静态成员变量的DexField
    for (uint32_t i = 0; i < header.staticFieldsSize; i++) 
    {
        ReadClassDataField(pData, &result->staticFields[i]);
    }

	// 从内存中读取类的所有的实例成员变量的DexField
    for (uint32_t i = 0; i < header.instanceFieldsSize; i++) 
    {
        ReadClassDataField(pData, &result->instanceFields[i]);
    }

	// 从内存中读取类的所有的直接成员方法的DexMethod
    for (uint32_t i = 0; i < header.directMethodsSize; i++) 
    {
        ReadClassDataMethod(pData, &result->directMethods[i]);
    }
    
	// 从内存中读取类的所有的虚成员方法的DexMethod
    for (uint32_t i = 0; i < header.virtualMethodsSize; i++) 
    {
        ReadClassDataMethod(pData, &result->virtualMethods[i]);
    }

    return result;
}


/*****Leb128类型数据的写入*****/
void writeLeb128(uint8_t ** ptr, uint32_t data)
{
    while (true) 
    {
        uint8_t out = data & 0x7f;
        if (out != data) 
        {
            *(*ptr)++ = out | 0x80;
            data >>= 7;
        } 
        else 
        {
            *(*ptr)++ = out;
            break;
        }
    }
}

/****获取一个类的所有成员变量以及个数、成员方法以及个数的结构体的信息（自定义数据保存格式）*******/
uint8_t* EncodeClassData(DexClassData *pData, int& len)
{
    len = 0;
	
	// 获取保存整个类的所有成员变量和成员方法的个数需要的内存大小
    len+=unsignedLeb128Size(pData->header.staticFieldsSize);
    len+=unsignedLeb128Size(pData->header.instanceFieldsSize);
    len+=unsignedLeb128Size(pData->header.directMethodsSize);
    len+=unsignedLeb128Size(pData->header.virtualMethodsSize);

	// 继续获取保存类的静态成员变量的DexField的大小
    if (pData->staticFields) 
    {
        for (uint32_t i = 0; i < pData->header.staticFieldsSize; i++) 
        {
            len+=unsignedLeb128Size(pData->staticFields[i].fieldIdx);
            len+=unsignedLeb128Size(pData->staticFields[i].accessFlags);
        }
    }

	// 继续获取保存类的实例成员变量的DexField的大小
    if (pData->instanceFields) 
    {
        for (uint32_t i = 0; i < pData->header.instanceFieldsSize; i++) 
        {
            len+=unsignedLeb128Size(pData->instanceFields[i].fieldIdx);
            len+=unsignedLeb128Size(pData->instanceFields[i].accessFlags);
        }
    }

	// 继续获取保存类的直接成员方法的DexMethod的大小
    if (pData->directMethods) {
        for (uint32_t i=0; i<pData->header.directMethodsSize; i++) 
        {
            len+=unsignedLeb128Size(pData->directMethods[i].methodIdx);
            len+=unsignedLeb128Size(pData->directMethods[i].accessFlags);
            len+=unsignedLeb128Size(pData->directMethods[i].codeOff);
        }
    }

	// 继续获取保存类的虚成员方法的DexMethod的大小
    if (pData->virtualMethods) 
    {
        for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++) 
        {
            len+=unsignedLeb128Size(pData->virtualMethods[i].methodIdx);
            len+=unsignedLeb128Size(pData->virtualMethods[i].accessFlags);
            len+=unsignedLeb128Size(pData->virtualMethods[i].codeOff);
        }
    }

	// 为存储整个类的所有的类成员和类方法申请内存空间
    uint8_t * store = (uint8_t *) malloc(len);
    if (!store) 
    {
		// 申请内存空间失败
        return NULL;
    }

    uint8_t * result=store;

	// 保存整个类所有的静态成员变量的数量大小
    writeLeb128(&store,pData->header.staticFieldsSize);
	// 保存整个类所有的实例成员变量的数量大小
    writeLeb128(&store,pData->header.instanceFieldsSize);
	// 保存整个类的所有的直接成员方法的数量大小
    writeLeb128(&store,pData->header.directMethodsSize);
    // 保存整个类的所有的虚成员方法的数量大小
    writeLeb128(&store,pData->header.virtualMethodsSize);

	// 保存整个类所有的静态成员变量的DexField
    if (pData->staticFields) 
    {
        for (uint32_t i = 0; i < pData->header.staticFieldsSize; i++) 
        {
            writeLeb128(&store,pData->staticFields[i].fieldIdx);
            writeLeb128(&store,pData->staticFields[i].accessFlags);
        }
    }

	// 保存整个类所有的实例成员变量的DexField
    if (pData->instanceFields) 
    {
        for (uint32_t i = 0; i < pData->header.instanceFieldsSize; i++) 
        {
			// 指向成员变量索引表中的一个表项，即一个DexFieldId的数据结构
            writeLeb128(&store,pData->instanceFields[i].fieldIdx);
            // 访问权限
            writeLeb128(&store,pData->instanceFields[i].accessFlags);
        }
    }

	// 保存整个类所有的直接成员方法的DexMethod
    if (pData->directMethods) 
    {
        for (uint32_t i=0; i<pData->header.directMethodsSize; i++) 
        {
			// 指向成员方法索引表中的一个表项，即一个DexMethodId数据结构
            writeLeb128(&store,pData->directMethods[i].methodIdx);
            // 访问权限
            writeLeb128(&store,pData->directMethods[i].accessFlags);
            // 成员方法的指向一个DexCode的数据结构
            writeLeb128(&store,pData->directMethods[i].codeOff);
        }
    }

	// 保存整个类所有的静虚成员方法的DexMethod
    if (pData->virtualMethods) 
    {
        for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++) 
        {
            writeLeb128(&store,pData->virtualMethods[i].methodIdx);
            writeLeb128(&store,pData->virtualMethods[i].accessFlags);
            writeLeb128(&store,pData->virtualMethods[i].codeOff);
        }
    }

	// 释放内存空间
    free(pData);
    
    return result;
}

/***这个函数暂时还是不太理解，与try/catch语句解析有关***/
uint8_t* codeitem_end(const u1** pData)
{
    uint32_t num_of_list = readUnsignedLeb128(pData);
    
    for (; num_of_list > 0; num_of_list--) 
    {
        int32_t num_of_handlers = readSignedLeb128(pData);
        int num = num_of_handlers;
        
        if (num_of_handlers <= 0) 
        {
            num =- num_of_handlers;
        }
        
        for (; num > 0; num--) 
        {
            readUnsignedLeb128(pData);
            readUnsignedLeb128(pData);
        }
        
        if (num_of_handlers <= 0) 
        {
            readUnsignedLeb128(pData);
        }
    }
    
    return (uint8_t*)(*pData);
}

/*** Use this to keep track of mapped segments.
struct MemMapping 
{
	void*  addr;		//start of data
	size_t length;		//length of data
	void*  baseAddr;	//page-aligned base address
	size_t baseLength; 	//length of mapping
};
***/

/***
struct DvmDex 
{
    DexFile*               pDexFile;            //odex文件的信息
    const DexHeader*       pHeader;             //dex文件头相关信息
    struct StringObject**  pResStrings;         //字符串
    struct ClassObject**   pResClasses;         //通过DexFile里的ClassDefItem构造出来的一个结构体（类信息）
    struct Method**        pResMethods;         //通过Method_Item构造出来的结构体(方法信息)
    struct Field**         pResFields;
    struct AtomicCache*    pInterfaceCache;
    bool                   isMappedReadOnly;
    MemMapping             memMap;				// memMap->addr为odex文件的内存位置，memMap->length为odex文件的长度
    jobject                dex_object;
    pthread_mutex_t        modLock;
};
****/

/*******
//DexFile结构体存储了odex文件的一些信息。
struct DexFile 
{
    //directly-mapped "opt" header 
    const DexOptHeader*         pOptHeader;

    //pointers to directly-mapped structs and arrays in base DEX
    const DexHeader*            pHeader;
    const DexStringId*          pStringIds;
    const DexTypeId*            pTypeIds;
    const DexFieldId*           pFieldIds;
    const DexMethodId*          pMethodIds;
    const DexProtoId*           pProtoIds;
    const DexClassDef*          pClassDefs;
    const DexLink*              pLinkData;
    const DexClassLookup*       pClassLookup;
    const void*                 pRegisterMapPool;       // RegisterMapClassPool
    const u1*                   baseAddr;
    int                         overhead;
};
*****/

/****
struct ClassObject : Object {

    u4                      instanceData[CLASS_FIELD_SLOTS];
    const char*             descriptor;
    char*                   descriptorAlloc;
    u4                      accessFlags;
    u4                      serialNumber;
    DvmDex*                 pDvmDex;
    ClassStatus             status;
    ClassObject*            verifyErrorClass;
    u4                      initThreadId;
    size_t                  objectSize;
    ClassObject*            elementClass;
    int                     arrayDim;
    PrimitiveType           primitiveType;
    ClassObject*            super;
    Object*                 classLoader;
    InitiatingLoaderList    initiatingLoaderList;
    int                     interfaceCount;
    ClassObject**           interfaces;
    int                     directMethodCount;
    Method*                 directMethods;
    int                     virtualMethodCount;
    Method*                 virtualMethods;
    int                     vtableCount;
    Method**                vtable;
    int                     iftableCount;
    InterfaceEntry*         iftable;
    int                     ifviPoolCount;
    int*                    ifviPool;
    int                     ifieldCount;
    int                     ifieldRefCount;
    InstField*              ifields;
    u4              		refOffsets;
    const char*             sourceFile;
    int                     sfieldCount;
    StaticField             sfields[0];
};
***/

void* DumpClass(void *parament)
{
  // 休眠一段时间
  while (timer_flag) 
  {
      sleep(5);
  }
  
  // 获取odex文件的内存描述结构DvmDex
  DvmDex* pDvmDex=((struct arg*)parament)->pDvmDex;
  Object *loader=((struct arg*)parament)->loader;
  
  // 获取指向odex文件的指针
  DexFile* pDexFile = pDvmDex->pDexFile;
  // 获取内存存放odex文件的内存信息描述
  MemMapping * mem = &pDvmDex->memMap;

  // 获取当前时间
  u4 time = dvmGetRelativeTimeMsec();
  ALOGI("GOT IT begin: %d ms", time);

  // 申请内存空间
  char *path = new char[100];
  
  // 获取需要脱壳的apk的数据目录的路径
  strcpy(path, dumppath);
  // 拼接字符串
  strcat(path, "classdef");
  
  // 打开文件xxxx/classdef
  FILE *fp = fopen(path, "wb+");

  strcpy(path, dumppath);
  //  拼接字符串
  strcat(path, "extra");
  
  // 打开文件xxxx/extra
  FILE *fp1 = fopen(path,"wb+");

  uint32_t mask = 0x3ffff;
  char padding = 0;
  const char* header = "Landroid";
  
  // 获取dex文件的DexClassDef的数量classDefsSize
  unsigned int num_class_defs = pDexFile->pHeader->classDefsSize;
  
  // pDexFile->baseAddr为存放dex文件的内存地址，
  //mem->addr为存放odex的文件的数据的内存地址,mem->length为存放的odex文件的长度 
  // 获取dex文件起始到odex文件结束在内存区域的长度
  uint32_t total_pointer = mem->length - uint32_t(pDexFile->baseAddr-(const u1*)mem->addr);
  // 保存dex文件起始到odex文件结束在内存区域的长度
  uint32_t rec = total_pointer;
  // 鉴于dex文件在内存中的4字节对齐问题
  while (total_pointer&3) 
  {
      total_pointer++;
  }

  // 增加的内存字节数inc
  int inc = total_pointer - rec;
  
  // 在内存中dex文件存放DexClassData的起始文件相对偏移#############
  uint32_t start = pDexFile->pHeader->classDefsOff+sizeof(DexClassDef)*num_class_defs;
  // 在内存中dex文件存放DexClassData的结束文件相对偏移#############
  uint32_t end = (uint32_t)((const u1*)mem->addr+mem->length - pDexFile->baseAddr);

  // 遍历dex文件的所有的DexClassDef
  for (size_t i = 0; i < num_class_defs; i++)  //Loop start ----------
  {
      bool need_extra = false;
      const u1* data = NULL;
      DexClassData* pData = NULL;
      bool pass = false;
      
      // 获取dex文件的第i个DexClassDef的结构体信息
      const DexClassDef *pClassDef = dexGetClassDef(pDvmDex->pDexFile, i);
      // 获取类的描述符信息即类类型字符串如：Landroid/xxx/yyy;
      const char *descriptor = dexGetClassDescriptor(pDvmDex->pDexFile, pClassDef);

	  // 判断该类是否是Landroid开头的系统类，是否是一个有效的类
      if(!strncmp(header, descriptor, 8) || !pClassDef->classDataOff)
      {
		  // 设置跳过过滤标签
          pass = true;
          
          // ******是系统类或者当前类不是有效的类，直接跳转******
          goto classdef;
      }

	  ClassObject * clazz=NULL;
	  // ########加载类描述符指定的类#####################
      clazz = dvmDefineClass(pDvmDex, descriptor, loader);
      if (!clazz) 
      {
         continue;
      }
      //#################################################

	  // 打印加载的类描述符信息
      ALOGI("GOT IT 加载class: %s", descriptor);

	  // 判断加载的指定的类是否已经初始化完成
      if (!dvmIsClassInitialized(clazz)) 
      {
          if(dvmInitClass(clazz))
          {
              ALOGI("GOT IT init: %s", descriptor);
          }
      }
      
      // 判断类的classData的偏移classDataOff是否在正常的内存范围    
      if(pClassDef->classDataOff < start || pClassDef->classDataOff > end)
      {
          need_extra = true;
      }

	  // 获取dex文件的一个类的类数据DexClassData的内存地址
      data = dexGetClassData(pDexFile, pClassDef);
      // 获取dex文件的一个类的类数据DexClassData以及成员变量DexField和成员方法DexMethod的结构
      pData = ReadClassData(&data);
      if (!pData) 
      {
		  // 获取失败，继续下次循环
          continue;
      }

	  // 获取类成员直接方法
      if (pData->directMethods) // looop start++++++++++++++++++++++++++++
      {
          for (uint32_t i = 0; i < pData->header.directMethodsSize; i++) 
          {
			  // 获取类成员的直接方法的指针
              Method *method = &(clazz->directMethods[i]);
              // 用于判断函数是否是native函数相关
              uint32_t ac = (method->accessFlags) & mask;

			  // 打印类成员直接方法的名称
              ALOGI("GOT IT direct method name %s.%s", descriptor, method->name);

			  // method->insns为Dalvik虚拟机自带的Native函数（Internal Native）则值为Null
			  // method->insns为普通的Native函数则为指向JNI实际函数机器码的首地址
              if (!method->insns || ac&ACC_NATIVE) 
              {
				  // 获取指向类成员直接方法字节码的指针
                  if (pData->directMethods[i].codeOff) 
                  {
					  // 设置需要额外数据的标志
                      need_extra = true;
                      
                      // 设置类成员直接方法的访问权限值
                      pData->directMethods[i].accessFlags=ac;
                      // 设置类成员直接方法的字节码指针为0
                      pData->directMethods[i].codeOff=0;
                  }
                  
                  // 继续下次循环
                  continue;
              }

			  /**** 
			   method->insns不是Native方法的情况，则为指向方法具体的Dalvik指令的指针
			  （指向的是实际加载到内存中的Dalvik指令，而不是在Dex文件中的）
			  ****/
			  // 获取method->insns不是Native方法的情况下，方法的字节码实际相对偏移codeOff
              u4 codeitem_off = u4((const u1*)method->insns-16-pDexFile->baseAddr);
			  
			  // 修正method->insns不是Native方法的accessFlags
              if (ac != pData->directMethods[i].accessFlags)
              {
                  ALOGI("GOT IT method ac");
                  need_extra=true;
                  pData->directMethods[i].accessFlags=ac;
              }
			  // 修正method->insns不是Native方法的字节码正常相对偏移codeOff
              if (codeitem_off!=pData->directMethods[i].codeOff && ((codeitem_off>=start&&codeitem_off<=end) || codeitem_off==0)) 
              {
                  ALOGI("GOT IT method code");
                  need_extra = true;
                  pData->directMethods[i].codeOff=codeitem_off;
              }

			  // 修正method->insns不是Native方法但是codeOff被app加固修改的情况下的codeOff
			  // 此种情况的方法的dex文件在内存中被分开存放了，codeOff的相对偏移值超出了正常dex文件的内存范围
              if ((codeitem_off < start || codeitem_off > end) && codeitem_off != 0) 
              {
                  need_extra=true;
                  // 设置类方法的codeOff值为total_pointer#############
                  pData->directMethods[i].codeOff = total_pointer;
                  // 获取类方法的信息结构体DexCode
                  DexCode *code = (DexCode*)((const u1*)method->insns-16);
                  // item保存类方法的字节码指令集内存指针
                  uint8_t *item=(uint8_t *) code;
                  
                  // 获取类方法的实际字节码的长度
                  int code_item_len = 0;
                  if (code->triesSize) 
                  {
					  // 类方法中有Try/Catch语句存在的情况
					  // 获取DexCode中的try/catch语句的hander数据信息
                      const u1 * handler_data = dexGetCatchHandlerData(code);
                      const u1** phandler=(const u1**)&handler_data;
                      // 计算DexCode结构体中insns字节码指令集的结束地址偏移
                      uint8_t * tail = codeitem_end(phandler);
                      
                      // 获取到类方法的DexCode中的字节码指令集的长度
                      code_item_len = (int)(tail-item);
                  }
                  else
                  {
					  // 计算DexCode中的字节码指令集的长度
                      code_item_len = 16+code->insnsSize*2;
                  }

                  ALOGI("GOT IT method code changed");

				  // 将类方法的字节码指令集method->insns写入文件xxxx/extra中
                  fwrite(item, 1, code_item_len, fp1);
                  // 刷新文件流
                  fflush(fp1);
                  
                  // 设置下一个method->insns的内存地址
                  total_pointer+=code_item_len;
                  // method->insns的4字节对齐问题
                  while (total_pointer&3)
                  {
					  // 写入0填充，处理4字节的对齐的问题
                      fwrite(&padding, 1, 1, fp1);
                      // 刷新文件流
                      fflush(fp1);
                      
                      total_pointer++;
                  }
              }
              
          }
      } // looop over++++++++++++++++++++++++++++

	  // 获取类成员虚方法的method->insns字节码指令保存到文件xxxx/extra
      if (pData->virtualMethods)    // looop start========================
      {
          for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++) 
          {
              Method *method = &(clazz->virtualMethods[i]);
              uint32_t ac = (method->accessFlags) & mask;

              ALOGI("GOT IT virtual method name %s.%s", descriptor, method->name);

              if (!method->insns||ac&ACC_NATIVE) 
              {
                  if (pData->virtualMethods[i].codeOff) 
                  {
                      need_extra = true;

                      pData->virtualMethods[i].accessFlags = ac;
                      pData->virtualMethods[i].codeOff = 0;
                  }
                  
                  continue;
              }

              u4 codeitem_off = u4((const u1 *)method->insns - 16 - pDexFile->baseAddr);

              if (ac != pData->virtualMethods[i].accessFlags)
              {
                  ALOGI("GOT IT method ac");

                  need_extra = true;
                  pData->virtualMethods[i].accessFlags=ac;
              }

              if (codeitem_off!=pData->virtualMethods[i].codeOff&&((codeitem_off>=start&&codeitem_off<=end)||codeitem_off==0)) 
              {
                  ALOGI("GOT IT method code");
                  need_extra=true;
                  pData->virtualMethods[i].codeOff=codeitem_off;
              }

              // 类成员方法的codeOff被加固修改了，dex文件在内存中分成了2份
              if ((codeitem_off < start || codeitem_off > end) && codeitem_off!=0) 
              {
                  need_extra = true;

                  // 将这部分类方法的DexCode数据保存到odex文件末尾的后面
                  pData->virtualMethods[i].codeOff = total_pointer;
                  DexCode *code = (DexCode*)((const u1*)method->insns-16);
                  uint8_t *item=(uint8_t *) code;
                  int code_item_len = 0;
                  
                  if (code->triesSize) 
                  {
                      const u1 *handler_data = dexGetCatchHandlerData(code);
                      const u1** phandler=(const u1**)&handler_data;
                      uint8_t * tail=codeitem_end(phandler);
                      code_item_len = (int)(tail-item);
                  }
                  else
                  {
                      code_item_len = 16+code->insnsSize*2;
                  }

                  ALOGI("GOT IT method code changed");

                  // 将这部分类方法的DexCode数据暂时保存到文件ata/data/xxxx.xxxx.xxx/extra中
                  fwrite(item, 1, code_item_len, fp1);
                  fflush(fp1);

                  total_pointer += code_item_len;
                  while (total_pointer&3) 
                  {
                      fwrite(&padding, 1, 1, fp1);
                      fflush(fp1);

                      total_pointer++;
                  }
              }
          }
      } // looop over========================


// 系统类或者当前类不是有效的类情况
classdef:
	   // 获取类的整体信息结构DexClassDef
       DexClassDef temp = *pClassDef;
       uint8_t *p = (uint8_t *)&temp;

	   // 判断是否需要额外的dex文件的类数据信息
       if (need_extra) 
       {
           ALOGI("GOT IT classdata before");
           int class_data_len = 0;
           
           // 将类数据信息如成员变量的DexField和成员方法的DexMethod进行编码保存到申请的内存中
           // pData = ReadClassData(&data);
           uint8_t *out = EncodeClassData(pData, class_data_len);
           if (!out) 
           {
			   // 保存到申请的内存中失败
               continue;
           }
           
           // 设置类成员方法的DexClassData的相对文件偏移
           temp.classDataOff = total_pointer;
           
           // 将类的成员方法的信息写入xxxx/extra文件
           fwrite(out, 1, class_data_len, fp1);
           // 刷新文件流
           fflush(fp1);
           
           // 继续更新指向的类成员方法存储位置的指针
           total_pointer += class_data_len;
           // 处理dex文件在内存中4字节对齐的问题
           while (total_pointer&3) 
           {
			   // 写入填充的数据0
               fwrite(&padding,1,1,fp1);
               // 刷新文件流
               fflush(fp1);
               
               total_pointer++;
           }
           free(out);
           
           ALOGI("GOT IT classdata written");
       }
       else
       {
		   // pData = ReadClassData(&data);
           if (pData) 
           {
               free(pData);
           }
       }

       // 对系统类或者当前类不是有效的类的情况，修改classDataOff和annotationsOff值为0
       if (pass) 
       {
		   // 设置类信息结构体的classDataOff和annotationsOff为0
           temp.classDataOff = 0;
           temp.annotationsOff = 0;
       }

       ALOGI("GOT IT classdef");
       
       // 将DexClassDef结构体的大小写入到文件xxxx/classdef中
       fwrite(p, sizeof(DexClassDef), 1, fp);
       // 刷新文件流
       fflush(fp);
       
  }	//Loop over ----------

  // 关闭文件
  fclose(fp1);
  fclose(fp);

  strcpy(path, dumppath);
  // 拼接字符串
  strcat(path, "whole.dex");
  
  // 打开文件xxxx/whole.dex
  fp = fopen(path,"wb+");
  // 设置文件指针在文件头的位置
  rewind(fp);

  int fd = -1;
  int r = -1;
  int len = 0;  
  char *addr = NULL;
  struct stat st;

  // ******************************************
  strcpy(path, dumppath);
  // 拼接字符串
  strcat(path, "part1");

  // 打开文件xxxx/part1
  fd = open(path, O_RDONLY, 0666);
  if (fd==-1) 
  {
      return NULL;
  }

  // 获取文件的文件状态信息
  r = fstat(fd, &st);  
  if(r==-1)
  {  
      close(fd);  
      return NULL;
  }

  // 获取文件的大小
  len = st.st_size;
  
  // 为文件创建内存映射
  addr = (char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
  // 将odex文件的开头到dex文件classDefsOff之间的文件数据写入到文件xxxx/whole.dex中
  fwrite(addr, 1, len, fp);
  // 刷新文件流
  fflush(fp);
  
  // 取消内存映射
  munmap(addr, len);
  // 关闭文件
  close(fd);
  // ******************************************

  strcpy(path, dumppath);
  // 拼接字符串
  strcat(path,"classdef");
  // 打开文件xxxx/classdef
  fd = open(path, O_RDONLY, 0666);
  if(fd==-1) 
  {
      return NULL;
  }

  // 获取文件的文件状态信息
  r = fstat(fd,&st);  
  if(r==-1)
  {  
      close(fd);  
      return NULL;
  }

  // 获取文件的大小
  len=st.st_size;
  // 为文件创建内存映射
  addr = (char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
  // 将addr中的数据写入到文件xxxx/whole.dex中
  fwrite(addr, 1, len, fp);
  // 刷新文件流
  fflush(fp);
  
  // 取消内存映射
  munmap(addr, len);
  // 关闭文件
  close(fd);

  // *********************************************
  strcpy(path, dumppath);
  // 拼接字符串
  strcat(path, "data");

  // 打开文件xxxx/data
  fd = open(path, O_RDONLY, 0666);
  if (fd==-1) 
  {
      return NULL;
  }

  // 获取文件的文件状态信息
  r = fstat(fd, &st);  
  if(r==-1)
  {  
      close(fd);  
      return NULL;
  }

  // 获取文件的大小
  len=st.st_size;
  // 创建文件的内存映射
  addr=(char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
  // 将内存odex文件中存放DexClassDef结构体以后的所有的文件数据写入到文件xxxx/whole.dex中
  fwrite(addr, 1, len, fp);
  // 刷新文件流
  fflush(fp);
  
  // 取消内存映射
  munmap(addr,len);
  // 关闭文件
  close(fd);

  // 4字节对齐导致的0填充
  while (inc > 0) 
  {
	  // 向文件中写入填充数据0
      fwrite(&padding, 1, 1, fp);
      // 刷新文件流
      fflush(fp);
      
      inc--;
  }

  // ******************************************
  strcpy(path,dumppath);
  // 拼接字符串
  strcat(path,"extra");

  // 打开文件xxxx/extra
  fd=open(path, O_RDONLY, 0666);
  if (fd==-1) 
  {
      return NULL;
  }

  // 获取文件的文件状态信息
  r = fstat(fd, &st);  
  if(r==-1)
  {  
      close(fd);  
      return NULL;
  }

  // 获取文件的大小
  len=st.st_size;
  // 创建文件内存映射
  addr=(char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
  // 将addr中的数据写入到文件xxxx/whole.dex中
  fwrite(addr,1,len,fp);
  // 刷新文件流
  fflush(fp);
  
  // 取消文件文件内存映射
  munmap(addr,len);
  // 关闭文件
  close(fd);

  // 关闭文件
  fclose(fp);
  
  // 释放申请的内存空间
  delete path;

  // 获取此时的时间
  time = dvmGetRelativeTimeMsec();
  ALOGI("GOT IT end: %d ms", time);

  return NULL;
}
//------------------------added end----------------------//

/****
typedef struct DexOrJar {
    char*          fileName;
    bool           isDex; 		//是dex文件还是jar包
    bool           okayToFree;
    RawDexFile*    pRawDexFile;
    JarFile*       pJarFile;  	//如果是jar包，则指向JarFile结构
    u1* 		   pDexMemory; 	//如果是dex，则指向dex内存区
} DexOrJar;
***/


static void Dalvik_dalvik_system_DexFile_defineClassNative(const u4* args,
    JValue* pResult)
{
    StringObject* nameObj = (StringObject*) args[0];
    Object* loader = (Object*) args[1];
    int cookie = args[2];
    ClassObject* clazz = NULL;
    DexOrJar* pDexOrJar = (DexOrJar*) cookie;
    DvmDex* pDvmDex;
    char* name;
    char* descriptor;

    name = dvmCreateCstrFromString(nameObj);
    descriptor = dvmDotToDescriptor(name);
    ALOGV("--- Explicit class load '%s' l=%p c=0x%08x",
        descriptor, loader, cookie);
    free(name);

    if (!validateCookie(cookie))
        RETURN_VOID();

    if (pDexOrJar->isDex)
        pDvmDex = dvmGetRawDexFileDex(pDexOrJar->pRawDexFile);
    else
        pDvmDex = dvmGetJarFileDex(pDexOrJar->pJarFile);

    /* once we load something, we can't unmap the storage */
    pDexOrJar->okayToFree = false;


//------------------------added begin----------------------//
    int uid = getuid();
    if (uid) 
    {
		// 非root情况下执行
        if (readable) 
        {
			// 创建互斥信号通量
            pthread_mutex_lock(&read_mutex);
            if (readable) 
            {
                readable = false;
                // 释放互斥信号通量
                pthread_mutex_unlock(&read_mutex);

                pthread_t read_thread;
                // 创建线程，读取脱壳的配置文件/data/dexname以及等待定时器timer
                pthread_create(&read_thread, NULL, ReadThread, NULL);

            }
            else
            {
				// 释放互斥信号通量
                pthread_mutex_unlock(&read_mutex);
            }
        }
    }

	// 非root情况且特征字符串不为空的情况下
    if(uid && strcmp(dexname, ""))
    {
		// 判断当前进程的apk是否是需要被脱壳的apk
        char * res = strstr(pDexOrJar->fileName, dexname);
        if (res&&flag) 
        {
			// 创建互斥信号通量
            pthread_mutex_lock(&mutex);
            if (flag) 
            {
				// 设置脱壳操作的开关为闭
                flag = false;
                // 释放互斥信号通量
                pthread_mutex_unlock(&mutex);
 
                // 获取内存中odex文件的结构信息
                DexFile* pDexFile = pDvmDex->pDexFile;
                // 获取odex文件在内存中的存放信息
                MemMapping * mem = &pDvmDex->memMap;

                char * temp = new char[100];
                
                //-----------------第1步-----------------------
                
                // 获取当前进程apk的数据目录路径/data/data/xxxx/
                strcpy(temp, dumppath);
                // 拼接字符串
                strcat(temp, "part1");
                // 打开文件/data/data/xxxx/part1
                FILE *fp = fopen(temp, "wb+");
                
                // 获取odex文件在内存中的存放指针
                const u1 *addr = (const u1*)mem->addr;
                // 获取odex文件的开头到dex文件classDefsOff之间的文件数据的长度
                int length = int(pDexFile->baseAddr+pDexFile->pHeader->classDefsOff-addr);
                // 将这部分文件数据写入到文件/data/data/xxxx/part1中
                fwrite(addr,1,length,fp);
                // 刷新文件流
                fflush(fp);
                // 关闭文件
                fclose(fp);
                
				//-----------------第2步-----------------------

                // 获取当前进程apk的数据目录路径/data/data/xxxx/
                strcpy(temp, dumppath);
                // 拼接字符串
                strcat(temp,"data");
				// 打开文件/data/data/xxxx/data
                fp = fopen(temp, "wb+");
                // 获取内存中dex文件存放DexClassDef结构体的结束内存地址
                addr = pDexFile->baseAddr+pDexFile->pHeader->classDefsOff+sizeof(DexClassDef)*pDexFile->pHeader->classDefsSize;
                // 获取内存中odex文件存放DexClassDef结构体以后的所有的文件的数据的长度
                length = int((const u1*)mem->addr+mem->length-addr);
                // 将这部分数据写入到文件/data/data/xxxx/data中
                fwrite(addr, 1, length, fp);
                // 刷新文件流
                fflush(fp);
                // 关闭文件
                fclose(fp);
                
                // 删除申请的内存空间
                delete temp;
                
				//-----------------第3步-----------------------
				
				// 用于保存线程id
                pthread_t dumpthread;

				//  构建线程的传入参数
                param.loader = loader;
                param.pDvmDex = pDvmDex;
                
                // 创建线程进行类class的内存dump
                dvmCreateInternalThread(&dumpthread, "ClassDumper", DumpClass, (void*)¶m);                             

            }
            else
            {
				// 释放互斥信号通量
                pthread_mutex_unlock(&mutex);
            }
        }
    }
//------------------------added end----------------------//


    clazz = dvmDefineClass(pDvmDex, descriptor, loader);
    Thread* self = dvmThreadSelf();
    if (dvmCheckException(self)) {
        /*
         * If we threw a "class not found" exception, stifle it, since the
         * contract in the higher method says we simply return null if
         * the class is not found.
         */
        Object* excep = dvmGetException(self);
        if (strcmp(excep->clazz->descriptor,
                   "Ljava/lang/ClassNotFoundException;") == 0 ||
            strcmp(excep->clazz->descriptor,
                   "Ljava/lang/NoClassDefFoundError;") == 0)
        {
            dvmClearException(self);
        }
        clazz = NULL;
    }

    free(descriptor);
    RETURN_PTR(clazz);
}

5>. DexHunter脱壳工具的需要的配置文件dexname的说明

DexHunter脱壳工具的在脱壳的时候需要构造配置文件dexname并且dexname文件中的字符换行必须是Unix/Linux格式0A的不能是windows的0D0A，特别是在windows平台上使用DexHunter作者提供的system.img镜像的同学要注意了。DexHunter脱壳工具的配置文件的dexname在使用的时候，需要adb push 到Android设备的/data/路径下[/data/dexname]。

脱壳配置文件/data/dexname的路径和文件名称是可以自定修改的，具体的使用位置见下面的代码截图。dexname文件中包含2行字符串，第一行字符串（the feature string）--特征字符串，是有加固app的pDexOrJar->fileName决定的，第2行字符串是用于内存dump文件如：part1、data、classdef和extra以及最终脱壳文件whole.dex存放位置也即目标加固app的数据目录。特别说下，DexHunter工具的作者在github上说特征字符串（the feature string）在其演讲的ppt--slide.pptx上，但是呢，我觉的不能死板，还是要根据作者的DexHunter中的代码引用为准，按照加固app的实际pDexOrJar->fileName来确定。

脱壳配置文件/data/dexname中的2行字符串内容被引用的位置：

DexHunter作者在slide.pptx上给出的特征字符串（the feature string）：

DexHunter脱壳工具内存dump文件产生的文件part1、data、classdef和extra合成脱壳后的whole.dex文件的过程：

重建加固前的app的dex文件

6>. DexHunter脱壳工具的个人DIY

DexHunter脱壳工具的作者提供给读者的DexHunter工具的Android镜像文件是基于Android 4.4.3的源码编译的。根据作者zyq8709提供的有关DexHunter脱壳工具的详细信息，我们可以自己按照的作者的脱壳思路和实现手法修改自己版本的Android源码/dalvik/vm/native/dalvik_system_DexFile.cpp里的Dalvik_dalvik_system_DexFile_defineClassNative函数的实现，来打造自己的DexHunter脱壳工具，有能力的大牛甚至可以根据最近的加固对抗思路，扩展DexHunter的代码，打造终极Android通用脱壳工具。DIY自己的DexHunter工具的时，既可以使用make命令编译一遍所有的Android源码产生system.img镜像文件部署到Android真机或者Android模拟器上测试，也可以使用Android源码的模块编译命令mm或者mmm（使用前提Android源码已经make编译一次成功）只编译Android源码的dalvik模块产生libdvm.so库文件然后通过修改Android系统的内存分区属性替换掉Android真机或者模拟器上原来的system/lib/libdvm.so文件，然后进行DexHunter的脱壳测试。

7>. DexHunter工具的几点说明

1.DexHunter作者zyq8709在github上给的建议:

2.DexHunter脱壳工具的第1行---特征字符串（the feature string）一直是在随着加固的对抗在变化的，具体是由当前加固app的pDexOrJar->fileName决定的，按照实际情况来；一些加固像梆梆什么的，会对DexHunter进行检测，检测的方法是检测Android系统的/data/目录下是否有文件/data/dexname，过掉的方式也比较简单，将DexHunter脱壳需要的配置文件dexname改为其他的名称就行；一些加固像梆梆什么的，会Hook一些系统的调用函数如fread、fwrite、fopen等，过掉方式是直接使用系统调用替代掉如：open、write等；一些加固像梆梆、百度什么的，还会采用类成员方法的实现代码抽取的方式对抗脱壳工具（只有代码在需要执行的时候才会被还原，执行完成以后又会被抽去掉）可能会采用比Dalvik_dalvik_system_DexFile_defineClassNative函数更深层的调用函数的Hook，如Hook掉libdvm.so库中dvmResolveClass 函数什么的，导致DexHunter内存dump获取不到dex文件的原代码，因此需要对Hook的dvmResolveClass 函数进行修改才能使DexHunter工具发挥作用。

Dalvik_dalvik_system_DexFile_defineClassNative函数到dvmResolveClass函数的整个调用过程：

在dvmResolveClass中进行修改的代码片段如下（以directMethod为例）：

感谢链接：

https://github.com/zyq8709/DexHunter

http://www.liuhaihua.cn/archives/377032.html

http://blog.csdn.net/zhangyun438/article/details/17192787

http://www.cnblogs.com/vendanner/p/4844235.html

http://blog.csdn.net/qq1084283172/article/details/53710357

http://blog.csdn.net/zhangyun438/article/details/17193411

http://blog.csdn.net/justfwd/article/details/51164281

http://www.cnblogs.com/vendanner/p/4884969.html

http://bbs.pediy.com/showthread.PHP?t=203776

3.其他的大牛对DexHunter工具的弱点的总结：

感谢链接：

https://my.oschina.net/cve2015/blog/734360

OK，完成了，格式有点乱。DexHunter脱壳工具的DVM模式下的原理代码已经搞得比较清楚了，后面再补补课分析一下ART模式下DexHunter脱壳工具的原理的代码及其细节。