DexHunter在ART虚拟机模式下的脱壳原理分析

本文博客地址: http://blog.csdn.net/qq1084283172/article/details/78494620

DexHunter脱壳工具在Dalvik虚拟机模式下的脱壳原理分析，在前面的博客中已经提到了，但是自我感觉分析和理解的还不够透彻，后面又对DexHunter脱壳工具的源码再阅读了几遍，总算是把DexHunter脱壳工具在Dalvik虚拟机模式下和ART虚拟机模式下的脱壳原理理解清楚了。关于DexHunter脱壳工具在Dalvik虚拟机模式下的脱壳原理分析，已经准备了一篇博客想详细和深入的讲一讲，一直搁置了没有完成；本来还计划把DexHunter脱壳工具在ART虚拟机模式下的脱壳原理也详细说一说，看来是不可能了。有关Android加固脱壳和Hook的好几个源码工程都看的差不多了，因为各种事情和状态不好，懒得动笔了。

在理解DexHunter脱壳工具在ART虚拟机模式下的脱壳原理之前，建议先阅读一下老罗的博客了解一下Android的ART虚拟机模式下的类加载和dex文件的优化过程，《Android运行时ART加载OAT文件的过程分析》这篇博客需要好好读一读。DexHunter在ART虚拟机模式下的脱壳编译配置主要是针对源码文件 /art/runtime/class_linker.cc  进行修改，以Android
4.4.4 r1的源码文件为示例 http://androidxref.com/4.4.4_r1/xref/art/runtime/class_linker.cc，然后对Android系统源码进行重新编译生成Android系统的镜像文件，刷到手机设备或者Android模拟器上使用，用来进行DexHunter在ART虚拟机模式下的脱壳操作。

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

/**
 *
 // OAT文件里面的oatdata段的开始储存着一个OAT头OatHeader
   const OatHeader& OatFile::GetOatHeader() const {
	  return *reinterpret_cast<const OatHeader*>(Begin());
	}

	// OAT文件里面的oatdata段开始地址
	const byte* OatFile::Begin() const {
	  CHECK(begin_ != NULL);
	  return begin_;
	}

	//  OAT文件里面的oatexec段的结束地址
	const byte* OatFile::End() const {
	  CHECK(end_ != NULL);
	  return end_;
	}

 // OAT文件里面的oatdata段的开始储存着一个OAT头，这个OAT头通过类OatHeader描述
 class PACKED(4) OatHeader {
	 public:
	   ......
	 private:
	  uint8_t magic_[4];	// 标识OAT文件的魔法数，等于‘oat\n’
	  uint8_t version_[4];	// OAT文件版本号，目前的值等于‘007、0’。
	  uint32_t adler32_checksum_;	// OAT头部检验和

	  // 本地机指令集，有四种取值，分别为  kArm(1)、kThumb2(2)、kX86(3)和kMips(4)。
	  InstructionSet instruction_set_;
	  // OAT文件包含的DEX文件个数。
	  uint32_t dex_file_count_;
	  // oatexec段开始位置与oatdata段开始位置的相对偏移值。
	  uint32_t executable_offset_;

	  // 在由打包在应用程序里面的classes.dex生成的OAT文件的oatdata段头部中，下述七个成员变量的值均等于0。
	  uint32_t interpreter_to_interpreter_bridge_offset_;
	  uint32_t interpreter_to_compiled_code_bridge_offset_;
	  uint32_t jni_dlsym_lookup_offset_;
	  uint32_t portable_resolution_trampoline_offset_;
	  uint32_t portable_to_interpreter_bridge_offset_;
	  uint32_t quick_resolution_trampoline_offset_;
	  uint32_t quick_to_interpreter_bridge_offset_;

	  // 用来创建Image空间的OAT文件的检验和。
	  uint32_t image_file_location_oat_checksum_;
	  // 用来创建Image空间的OAT文件的oatdata段在内存的位置。
	  uint32_t image_file_location_oat_data_begin_;

	  // 用来创建Image空间的文件的路径的大小。
	  uint32_t image_file_location_size_;
	  // 用来创建Image空间的文件的路径的在内存中的地址。
	  uint8_t image_file_location_data_[0];  // note variable width data at end

	  ......
 };
 // 参考:http://blog.csdn.net/Luoshengyang/article/details/39307813
 **/

#include <asm/siginfo.h>
#define LOGI

static char dexname[100]={0};

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;

// 自定义的线程回调的传入参数
struct arg{
    const DexFile* dex_file;
    mirror::ClassLoader* class_loader;
    ClassLinker* cl;
}param;

// 类成员信息
struct DexField {
    uint32_t delta_fieldIdx;
    uint32_t accessFlags;
};

// 类方法信息
struct DexMethod {
    uint32_t delta_methodIdx;
    uint32_t accessFlags;
    uint32_t codeOff;
};

struct DexClassDataHeader {
    uint32_t staticFieldsSize;
    uint32_t instanceFieldsSize;
    uint32_t directMethodsSize;
    uint32_t virtualMethodsSize;
};

// 整个类的方法和成员信息
struct DexClassData {
    DexClassDataHeader header;
    DexField*          staticFields;
    DexField*          instanceFields;
    DexMethod*         directMethods;
    DexMethod*         virtualMethods;
};

// 等待dump任务执行的等待定时器
void timer_thread(::sigval_t)
{
    timer_flag=false;
    timer_delete(timerId);
    #ifdef LOGI
    LOG(INFO)<<"GOT IT time up";
    #endif
}

// 读取脱壳配置文件
void* ReadThread(void *arg){

    FILE *fp = NULL;
    while (dexname[0]==0||dumppath[0]==0) {

		// 打开apk脱壳配置文件/data/dexname
		// 一些加固会检测这个配置文件/data/dexname
        fp=fopen("/data/dexname", "r");
        if (fp==NULL) {

            sleep(1);
            continue;
        }

		// 获取被加固的dex文件内存加载的文件路径
        fgets(dexname, 99, fp);
        dexname[strlen(dexname)-1]=0;

		// 保存被加固dex文件的dump路径
        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;
}

// leb128数据的写
void writeUnsignedLeb128(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;
        }
    }
}

// leb128数据的字节长度
int unsignedLeb128Size(uint32_t data)
{
    int count = 0;
    do {
        data >>= 7;
        count++;
    } while (data != 0);

    return count;
}

// 获取DexClassDataHeader结构体的各个成员的数据信息
void dexReadClassDataHeader(const uint8_t** pData,
        DexClassDataHeader *pHeader) {
    pHeader->staticFieldsSize = DecodeUnsignedLeb128(pData);
    pHeader->instanceFieldsSize = DecodeUnsignedLeb128(pData);
    pHeader->directMethodsSize = DecodeUnsignedLeb128(pData);
    pHeader->virtualMethodsSize = DecodeUnsignedLeb128(pData);
}

// 获取DexClassData结构体DexFiled的数据信息
void dexReadClassDataField(const uint8_t** pData, DexField* pField) {
    pField->delta_fieldIdx = DecodeUnsignedLeb128(pData);
    pField->accessFlags = DecodeUnsignedLeb128(pData);
}

// 获取DexClassData结构体DexMethod的数据信息
void dexReadClassDataMethod(const uint8_t** pData, DexMethod* pMethod) {
    pMethod->delta_methodIdx = DecodeUnsignedLeb128(pData);
    pMethod->accessFlags = DecodeUnsignedLeb128(pData);
    pMethod->codeOff = DecodeUnsignedLeb128(pData);
}

// 从内存dex文件中读取指定DexFile::ClassDef对应的DexClassData即类成员和类方法描述数据到申请内存空间中
DexClassData* dexReadClassData(const uint8_t** pData) {

    DexClassDataHeader header;

    if (*pData == NULL) {
        return NULL;
    }

	// 获取DexClassDataHeader结构体的各个成员的数据信息（）
    dexReadClassDataHeader(pData,&header);

    // 计算DexClassData结构体及其所有DexFiled和所有DexMethod占用的内存空间
    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;
    }

	// 更新指针的位置，用于存放类静态成员变量、类实例成员变量、类直接方法以及类虚拟方法
    uint8_t* ptr = ((uint8_t*) result) + sizeof(DexClassData);
    result->header = header;

    if (header.staticFieldsSize != 0) {
		// 设置存放静态类成员变量的内存起始地址
        result->staticFields = (DexField*) ptr;
		// 存放所有类静态成员变量需要的内存大小
        ptr += header.staticFieldsSize * sizeof(DexField);
    } else {
        result->staticFields = NULL;
    }

    if (header.instanceFieldsSize != 0) {
		// 设置存放实例类成员变量的内存起始地址
        result->instanceFields = (DexField*) ptr;
        ptr += header.instanceFieldsSize * sizeof(DexField);
    } else {
        result->instanceFields = NULL;
    }

    if (header.directMethodsSize != 0) {
		// 设置存放直接类成员方法的内存起始地址
        result->directMethods = (DexMethod*) ptr;
        ptr += header.directMethodsSize * sizeof(DexMethod);
    } else {
        result->directMethods = NULL;
    }

    if (header.virtualMethodsSize != 0) {
		// 设置存放虚拟类成员方法的内存起始地址
        result->virtualMethods = (DexMethod*) ptr;
    } else {
        result->virtualMethods = NULL;
    }

	// 获取DexClassData中类静态变量和类实例变量以及类直接方法和类虚方法的数据
	// 存放到指定的申请内存空间中
    for (uint32_t i = 0; i < header.staticFieldsSize; i++) {
        dexReadClassDataField(pData, &result->staticFields[i]);
    }
    for (uint32_t i = 0; i < header.instanceFieldsSize; i++) {
        dexReadClassDataField(pData, &result->instanceFields[i]);
    }
    for (uint32_t i = 0; i < header.directMethodsSize; i++) {
        dexReadClassDataMethod(pData, &result->directMethods[i]);
    }
    for (uint32_t i = 0; i < header.virtualMethodsSize; i++) {
        dexReadClassDataMethod(pData, &result->virtualMethods[i]);
    }

    return result;
}

// 将整个DexClassData所表示的类数据leb128编码写入到申请的内存空间中
uint8_t* dexEncodeClassData(DexClassData *pData, int& len)
{
    len=0;

	// 获取整个DexClassData所表示类数据的内存占用大小
    len+=unsignedLeb128Size(pData->header.staticFieldsSize);
    len+=unsignedLeb128Size(pData->header.instanceFieldsSize);
    len+=unsignedLeb128Size(pData->header.directMethodsSize);
    len+=unsignedLeb128Size(pData->header.virtualMethodsSize);
    if (pData->staticFields) {
        for (uint32_t i = 0; i < pData->header.staticFieldsSize; i++) {
            len+=unsignedLeb128Size(pData->staticFields[i].delta_fieldIdx);
            len+=unsignedLeb128Size(pData->staticFields[i].accessFlags);
        }
    }
    if (pData->instanceFields) {
        for (uint32_t i = 0; i < pData->header.instanceFieldsSize; i++) {
            len+=unsignedLeb128Size(pData->instanceFields[i].delta_fieldIdx);
            len+=unsignedLeb128Size(pData->instanceFields[i].accessFlags);
        }
    }
    if (pData->directMethods) {
        for (uint32_t i=0; i<pData->header.directMethodsSize; i++) {
            len+=unsignedLeb128Size(pData->directMethods[i].delta_methodIdx);
            len+=unsignedLeb128Size(pData->directMethods[i].accessFlags);
            len+=unsignedLeb128Size(pData->directMethods[i].codeOff);
        }
    }
    if (pData->virtualMethods) {
        for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++) {
            len+=unsignedLeb128Size(pData->virtualMethods[i].delta_methodIdx);
            len+=unsignedLeb128Size(pData->virtualMethods[i].accessFlags);
            len+=unsignedLeb128Size(pData->virtualMethods[i].codeOff);
        }
    }

	// 根据整个DexClassData所示类数据的大小申请内存空间
    uint8_t * store = (uint8_t *) malloc(len);
    if (!store) {

		// 申请内存失败的情况
        return NULL;
    }

    uint8_t * result=store;

	// 将整个DexClassData所表示的类数据写入到申请的内存空间中
    writeUnsignedLeb128(&store,pData->header.staticFieldsSize);
    writeUnsignedLeb128(&store,pData->header.instanceFieldsSize);
    writeUnsignedLeb128(&store,pData->header.directMethodsSize);
    writeUnsignedLeb128(&store,pData->header.virtualMethodsSize);
	// 类静态成员变量
    if (pData->staticFields) {
        for (uint32_t i = 0; i < pData->header.staticFieldsSize; i++) {
            writeUnsignedLeb128(&store,pData->staticFields[i].delta_fieldIdx);
            writeUnsignedLeb128(&store,pData->staticFields[i].accessFlags);
        }
    }
	// 类实例变量
    if (pData->instanceFields) {
        for (uint32_t i = 0; i < pData->header.instanceFieldsSize; i++) {
            writeUnsignedLeb128(&store,pData->instanceFields[i].delta_fieldIdx);
            writeUnsignedLeb128(&store,pData->instanceFields[i].accessFlags);
        }
    }
	// 类直接方法
    if (pData->directMethods) {
        for (uint32_t i=0; i<pData->header.directMethodsSize; i++) {
            writeUnsignedLeb128(&store,pData->directMethods[i].delta_methodIdx);
            writeUnsignedLeb128(&store,pData->directMethods[i].accessFlags);
            writeUnsignedLeb128(&store,pData->directMethods[i].codeOff);
        }
    }
	// 类虚拟方法
    if (pData->virtualMethods) {
        for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++) {
            writeUnsignedLeb128(&store,pData->virtualMethods[i].delta_methodIdx);
            writeUnsignedLeb128(&store,pData->virtualMethods[i].accessFlags);
            writeUnsignedLeb128(&store,pData->virtualMethods[i].codeOff);
        }
    }

    free(pData);
    return result;
}

// 根据try...catch{}的处理语句计算DexFile::CodeItem结构体的结束地址
uint8_t* codeitem_end(const uint8_t **pData)
{
    uint32_t num_of_list = DecodeUnsignedLeb128(pData);
    for (;num_of_list>0;num_of_list--) {
        int32_t num_of_handlers=DecodeSignedLeb128(pData);
        int num=num_of_handlers;
        if (num_of_handlers<=0) {
            num=-num_of_handlers;
        }
        for (; num > 0; num--) {
            DecodeUnsignedLeb128(pData);
            DecodeUnsignedLeb128(pData);
        }
        if (num_of_handlers<=0) {
            DecodeUnsignedLeb128(pData);
        }
    }
    return (uint8_t*)(*pData);
}

// 内存dump加固的dex文件的类数据信息
void* DumpClass(void *parament)
{

  while (timer_flag) {
      sleep(5);
  }

  // 获取当前art虚拟机的运行时Runtime
  Runtime* runtime = Runtime::Current();
  // 附加到art虚拟机线程
  runtime->AttachCurrentThread("ClassDumper", false, NULL,false);
  // 获取当前art虚拟机的线程描述结构体Thread
  Thread *self=Thread::Current();

  #ifdef LOGI
  LOG(INFO)<<"GOT IT DumpingClass";
  #endif

  #ifdef LOGI
  // 获取当前时间
  uint64_t time = MilliTime();
  LOG(INFO)<<"GOT IT begin "<<time<<" ms";
  #endif

  // 当前Dex文件的内存镜像OAT描述相关的结构体
  const DexFile &dex_file=(*((struct arg*)parament)->dex_file);
  mirror::ClassLoader *class_loader=((struct arg*)parament)->class_loader;
  ClassLinker *cl = ((struct arg*)parament)->cl;

  char *path = new char[100];
  strcpy(path, dumppath);
  // 拼接字符串得到文件路径 xxxx/classdef
  strcat(path, "classdef");
  // 打开文件xxxx/classdef
  FILE *fp = fopen(path, "wb+");

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

  uint32_t mask=0x3ffff;
  char padding=0;
  const char* header="Landroid";
  bool pass=false;

  // 锁
  Locks::mutator_lock_->SharedLock(self);
  // 获取当前dex文件的ClassDef的数量
  size_t num_class_defs = dex_file.NumClassDefs();
  // 获取整个OAT文件的文件大小
  uint32_t total_pointer = dex_file.Size();
  uint32_t rec = total_pointer;

  // 获取OAT文件内存4字节对齐后的文件大小
  while (total_pointer&3) {
      total_pointer++;
  }
  // 获取OAT文件4字节对齐需要填充'0'的数量
  int inc = total_pointer - rec;

  // 获取OAT文件里dex文件的ClassDef结构体表Table的结束地址
  uint32_t start = dex_file.class_defs_off_ + sizeof(DexFile::ClassDef)*num_class_defs;
  // 获取OAT文件的文件大小即文件偏移
  uint32_t end = dex_file.Size();

  // 遍历获取OAT文件里的dex文件的ClassDef并加载
  for (size_t i = 0; i < num_class_defs; i++)
  {
	  // 获取OAT文件里的dex文件的第i个ClassDef结构体
      const DexFile::ClassDef &class_def = dex_file.GetClassDef(i);
      // 获取ClassDef结构体描述的类的类签名字符串，例如:Landroid/xxx/yyy;
      const char* descriptor = dex_file.GetClassDescriptor(class_def);

      // 描述dump的类是否需要额外的类数据信息
      bool need_extra = false;

      // ART下dex文件的类内存加载后的描述结构体为mirror::Class
      mirror::Class* klass=NULL;
      const byte * data=NULL;
      DexClassData* pData = NULL;

      #ifdef LOGI
      LOG(INFO) << "GOT IT " << descriptor;
      #endif

      // 过滤掉Android系统("Landroid")的类和没有类数据的无效类（这两中情况不处理）
      if(!strncmp(header, descriptor, 8)||!class_def.class_data_off_)
      {
          pass = true;
          // 此种情况，need_extra = false
          goto classdef;
      }

      // 查找指定类签名描述的目标类
      /** mirror::Class* **/klass = cl->FindClass(descriptor, class_loader);
      // 查找的目标类没有找到的情况
      if (!klass) {

          #ifdef LOGI
          LOG(INFO)<<"GOT IT class Find Fail";
          #endif

          // 异常处理
          self->ClearException();
          continue;
      }

      // 成功查找到指定类签名描述的目标类
      if(klass){

          if(cl->EnsureInitialized(klass, true, true)){
              #ifdef LOGI
              LOG(INFO)<<"GOT IT "<<descriptor<<" Initialized";
              #endif
          }else{
              self->ClearException();
          }
      }

      // OAT文件里dex文件的Class_Data数据存放在OAT文件的结尾或者Class_Def结构体表开始地址之前位置
      if(class_def.class_data_off_<start || class_def.class_data_off_>end)
      {
          #ifdef LOGI
          LOG(INFO)<<"GOT IT class data off exceeding "<<descriptor;
          #endif
          // 需要额外的处理Class_Def
          need_extra=true;
      }

      // 获取Class_Def描述的类的ClassData数据class_data_item
      data = dex_file.GetClassData(class_def);
      // 读取OAT文件里dex文件的类描述DexClassData描述的类成员和类方法的数据到申请的内存空间中
      pData = dexReadClassData(&data);
      if (!pData) {

    	  // 失败情况
          continue;
      }

      // 针对类直接方法的处理
      if (pData->directMethods) {

    	  // 遍历art下类的直接方法
          for (uint32_t i = 0; i < pData->header.directMethodsSize; i++) {

        	  // art::mirror::ArtMethod是art下dex文件类经过内存加载后的描述结构体
        	  // 获取指定类的第i个直接类方法描述结构体art::mirror::ArtMethod
              art::mirror::ArtMethod *method = klass->GetDirectMethod(i);

              // 获取类方法的函数属性值AccessFlag
              uint32_t ac = (method->GetAccessFlags()) & mask;
              // 获取类方法的字节码偏移地址CodeItemOffset
              uint32_t codeitem_off = method->GetCodeItemOffset();

              // 通过类方法的DexMethodIndex获取到类方法的名称字符串
              uint32_t dex_method_idx = method->GetDexMethodIndex();
              const char * name = dex_file.GetMethodName(dex_file.GetMethodId(dex_method_idx));

              // 判断dex文件中的类方法函数属性值AccessFlag与实际类运行时art::mirror::ArtMethod中函数属性值是否一致
              if (ac != pData->directMethods[i].accessFlags)
              {
                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT direct method AF changed "<<name;
                  #endif

                  // 腾讯加固有这种情况，运行时native函数恢复为java函数
                  need_extra=true;
                  // 进行类方法函数属性的更正（以运行时为准）
                  pData->directMethods[i].accessFlags=ac;
              }

              // 根据类方法实际运行时的codeitem_off与dex文件中的codeOff偏移地址的不同，进行类方法字节码DexCode偏移地址的修正
              if (codeitem_off != pData->directMethods[i].codeOff&&((codeitem_off>=start&&codeitem_off<=end)||codeitem_off==0)) {
                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT direct method code changed "<<name;
                  #endif
                  need_extra=true;

                  // 以类方法实际运行时的codeitem_off为准，对dex文件中的类方法字节码DexCode的偏移地址进行修正
                  pData->directMethods[i].codeOff=codeitem_off;
              }

              // 类方法的字节码DexCode被存放在了OAT文件的文件末尾或者dex文件的ClassDef结构体表开始地址之前的位置
              // 阿里加固出现过这种情况
              if ((codeitem_off<start || codeitem_off>end) && codeitem_off!=0) {

                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT direct method code changed "<<name;
                  #endif

                  need_extra=true;
                  // 统计将dex文件的类方法字节码DexFile::CodeItem从OAT文件结尾的位置开始存放（注意内存4字节对齐）
                  pData->directMethods[i].codeOff = total_pointer;
                  // 获取类方法字节码描述结构体指针DexFile::CodeItem
                  const DexFile::CodeItem * code = dex_file.GetCodeItem(codeitem_off);

                  // 类方法字节码描述结构体DexFile::CodeItem存放的起始地址
                  uint8_t *item=(uint8_t *) code;
                  int code_item_len = 0;

                  // 判断类方法是否有try...catch{}语句
                  if (code->tries_size_) {

                	  // 获取有try...catch{}语句情况下，类方法的字节码DexFile::CodeItem结构体的结束地址
                      const byte *handler_data = (const byte *)(DexFile::GetTryItems(*code, code->tries_size_));
                      uint8_t * tail = codeitem_end(&handler_data);

                      // 有try...catch{}语句情况下，类方法的字节码DexFile::CodeItem结构体的字节大小
                      code_item_len = (int)(tail - item);
                  }else{

                	  // 无try...catch{}语句情况下，类方法的字节码DexFile::CodeItem结构体的字节大小
                      code_item_len = 16+code->insns_size_in_code_units_*2;
                  }

                  // 将不在正常dex文件偏移存放位置的类方法字节码DexFile::CodeItem结构体的数据写入到xxxx/extra文件中
                  fwrite(item, 1, code_item_len, fp1);
                  fflush(fp1);

                  // 更新存放类方法字节码DexFile::CodeItem的文件偏移指针
                  total_pointer += code_item_len;
                  // 进行内存4字节对齐的填充处理
                  while (total_pointer&3) {

                      fwrite(&padding,1,1,fp1);
                      fflush(fp1);

                      total_pointer++;
                  }
                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT total_pointer "<<total_pointer;
                  #endif
              }

          }
      }

      // 针对类虚方法的处理（和上面类直接方法的处理一样）
      if (pData->virtualMethods) {

    	  // 遍历类的虚方法
          for (uint32_t i=0; i<pData->header.virtualMethodsSize; i++) {
              art::mirror::ArtMethod *method = klass->GetVirtualMethod(i);
              uint32_t ac = (method->GetAccessFlags()) & mask;
              uint32_t codeitem_off = method->GetCodeItemOffset();
              uint32_t dex_method_idx = method->GetDexMethodIndex();
              const char * name = dex_file.GetMethodName(dex_file.GetMethodId(dex_method_idx));

              // 类方法函数属性accessFlags的修复
              if (ac != pData->virtualMethods[i].accessFlags)
              {
                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT virtual method AF changed "<<name;
                  #endif
                  need_extra=true;
                  pData->virtualMethods[i].accessFlags=ac;
              }

              // 类方法codeitem_off的修正，以类方法运行时的数据为准
              if (codeitem_off!=pData->virtualMethods[i].codeOff&&((codeitem_off>=start&&codeitem_off<=end)||codeitem_off==0)) {
                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT virtual method code changed "<<name;
                  #endif
                  need_extra=true;
                  pData->virtualMethods[i].codeOff=codeitem_off;
              }

              // 类方法的字节码DexCode被存放在了OAT文件的文件末尾或者dex文件的ClassDef结构体表开始地址之前的位置
              if ((codeitem_off<start || codeitem_off>end)&&codeitem_off!=0) {

                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT virtual method code changed "<<name;
                  #endif

                  need_extra=true;
                  // 统计将dex文件的类方法字节码DexFile::CodeItem从OAT文件结尾的位置开始存放（注意内存4字节对齐）
                  pData->virtualMethods[i].codeOff = total_pointer;
                  const art::DexFile::CodeItem * code = dex_file.GetCodeItem(codeitem_off);
                  uint8_t *item=(uint8_t *) code;
                  int code_item_len = 0;

                  // 判断类方法是否有try...catch{}语句
                  if (code->tries_size_) {

                      const byte *handler_data = (const byte *)(DexFile::GetTryItems(*code, code->tries_size_));
                      uint8_t * tail=codeitem_end(&handler_data);

                      // 有try...catch{}语句情况下，类方法的字节码DexFile::CodeItem结构体的字节大小
                      code_item_len = (int)(tail-item);
                  }else{

                	  // 无try...catch{}语句情况下，类方法的字节码DexFile::CodeItem结构体的字节大小
                      code_item_len = 16+code->insns_size_in_code_units_*2;
                  }

                  // 将不在正常dex文件偏移存放位置的类方法字节码DexFile::CodeItem结构体的数据写入到xxxx/extra文件中
                  fwrite(item,1,code_item_len,fp1);
                  fflush(fp1);

                  // 更新存放类方法字节码DexFile::CodeItem的文件偏移指针
                  total_pointer+=code_item_len;
                  // 进行内存4字节对齐的填充处理
                  while (total_pointer&3) {
                      fwrite(&padding,1,1,fp1);
                      fflush(fp1);
                      total_pointer++;
                  }

                  #ifdef LOGI
                  LOG(INFO)<<"GOT IT total_pointer "<<total_pointer;
                  #endif
              }

          }
      }

// 上面是针对dex文件类方法的字节码DexFile::CodeItem的修正处理并保存到xxxx/extra文件中
// 以及对dex文件的ClassDef对应的ClassData的数据修正处理（以运行时的类描述信息为准）

// 下面是针对dex文件的
classdef:
       DexFile::ClassDef *temp = (DexFile::ClassDef*) malloc(sizeof(DexFile::ClassDef));
       if (!temp) {
           continue;
       }

       temp->class_idx_ = class_def.class_idx_;
       temp->pad1_=class_def.pad1_;
       temp->pad2_=class_def.pad2_;
       temp->access_flags_=class_def.access_flags_;
       temp->annotations_off_= class_def.annotations_off_;
       temp->class_data_off_=class_def.class_data_off_;
       temp->interfaces_off_=class_def.interfaces_off_;
       temp->source_file_idx_=class_def.source_file_idx_;
       temp->static_values_off_=class_def.static_values_off_;
       temp->superclass_idx_=class_def.superclass_idx_;

       if (pass) {

    	   // Android系统类和无效类的情况处理
           temp->class_data_off_=0;
           temp->annotations_off_=0;
       }

       uint8_t *p = (uint8_t *)temp;
       if (need_extra) {

    	   // dex文件的类DexClassData需要修正情况
           int class_data_len = 0;
           // 将DexClassData所表示的类数据pData进行leb128编码写入到申请的内存空间中
           // class_data_len为保存DexClassData进行leb128编码后的数据长度
           uint8_t *out = dexEncodeClassData(pData, class_data_len);
           if (!out) {
               continue;
           }

           // 修正DexFile::ClassDef中指向DexClassData的文件偏移指针
           temp->class_data_off_ = total_pointer;
           #ifdef LOGI
           LOG(INFO)<<"GOT IT write extra";
           #endif

           // 将正确修正后的dex文件的类DexClassData数据保存到xxxx/extra文件中
           fwrite(out, 1, class_data_len, fp1);
           fflush(fp1);

           // 更新在xxxx/extra文件中存放DexClassData或者DexFile::CodeItem的文件偏移指针
           total_pointer += class_data_len;
           // 内存4字节对齐的填充处理
           while (total_pointer&3) {

               fwrite(&padding, 1, 1, fp1);
               fflush(fp1);

               total_pointer++;
           }
           #ifdef LOGI
           LOG(INFO)<<"GOT IT total_pointer "<<total_pointer;
           #endif
           free(out);

       } else {
           if (pData) {
               free(pData);
           }
       }

       #ifdef LOGI
       LOG(INFO)<<"GOT IT write classdef";
       #endif

       // 将根据上面xxxx/extra文件中存放的DexClassData数据修正的DexFile::ClassDef结构体数据保存到xxxx/classdef文件中
       fwrite(p, sizeof(DexFile::ClassDef), 1, fp);
       fflush(fp);
       free(temp);
  }

  // 释放锁
  Locks::mutator_lock_->SharedUnlock(self);
  // 关闭文件
  fclose(fp1);
  fclose(fp);

  #ifdef LOGI
  LOG(INFO)<<"GOT IT ClassDumped";
  #endif
  self->SetState(kSleeping);
  // 取消对art虚拟机线程的附加
  runtime->DetachCurrentThread();

  // 需要脱壳的dex文件的内存dump已经全部完成，后面是dump后的dex文件重组处理

  // 拼接字符串得到文件路径xxxx/whole.dex
  strcpy(path,dumppath);
  strcat(path,"whole.dex");

  // 打开文件xxxx/whole.dex(用以存放dump重组后的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,"part0");
  // 打开文件xxxx/part0
  fp1 = fopen(path,"rb");
  char reg=0;

  // 读取文件xxxx/part0中的数据内容保存到文件xxxx/whole.dex中
  for (uint32_t i = 0; i < 16; i++) {

      fread(&reg, 1, 1, fp1);
      fwrite(&reg, 1, 1, fp);
      fflush(fp);
  }
  fclose(fp1);

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

  // 获取文件xxxx/part1的数据大小
  r = fstat(fd, &st);
  if(r == -1){
      close(fd);
      return NULL;
  }
  len = st.st_size;
  // 为文件xxxx/part1创建内存映射进行文件的读取操作
  addr = (char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);

  // 将文件xxxx/part1的数据内容写入保存到文件xxxx/whole.dex中
  fwrite(addr, 1, len, fp);
  // 刷新文件流
  fflush(fp);
  // 取消内存映射
  munmap(addr,len);
  close(fd);

  #ifdef LOGI
  LOG(INFO)<<"GOT IT part1 over ";
  #endif

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

  // 获取文件xxxx/classdef的数据大小
  r = fstat(fd,&st);
  if(r==-1){
      close(fd);
      return NULL;
  }
  len=st.st_size;

  // 为文件xxxx/classdef创建内存映射实现文件的读取操作
  addr = (char*)mmap(NULL,len,PROT_READ,MAP_PRIVATE,fd,0);

  // 将文件xxxx/classdef的数据内容写入到文件xxxx/whole.dex中
  fwrite(addr,1,len,fp);
  fflush(fp);
  munmap(addr,len);
  close(fd);

  #ifdef LOGI
  LOG(INFO)<<"GOT IT classdef over ";
  #endif

  strcpy(path,dumppath);
  strcat(path,"data");

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

  // 获取文件xxxx/data的文件大小
  r = fstat(fd, &st);
  if(r==-1){
      close(fd);
      return NULL;
  }
  len=st.st_size;

  // 为文件xxxx/data创建文件内存映射
  addr=(char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
  // 将文件xxxx/data的数据内容写入到文件xxxx/whole.dex中
  fwrite(addr,1,len,fp);
  fflush(fp);
  munmap(addr,len);
  close(fd);

  #ifdef LOGI
  LOG(INFO)<<"GOT IT data over ";
  #endif

  // 对 xxxx/data 进行内存4字节对齐的'0'填充处理
  while (inc>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;
  }

  // 获取文件xxxx/extra的文件大小
  r = fstat(fd,&st);
  if(r == -1){
      close(fd);
      return NULL;
  }
  len=st.st_size;

  // 为文件xxxx/extra创建文件内存映射实现文件的读取操作
  addr = (char*)mmap(NULL,len,PROT_READ,MAP_PRIVATE,fd,0);
  // 将文件xxxx/extra的数据内容保存写入到文件xxxx/whole.dex中
  fwrite(addr, 1, len, fp);
  fflush(fp);
  munmap(addr,len);
  close(fd);

  /****
  xxxx/part0
  xxxx/part1
  xxxx/classdef    （dex文件的重组）-------->    xxxx/whole.dex
  xxxx/data
  xxxx/extra
  *****/

  #ifdef LOGI
  LOG(INFO)<<"GOT IT extra over ";
  #endif

  fclose(fp);
  delete path;

  #ifdef LOGI
  time = MilliTime();
  LOG(INFO)<<"GOT IT end "<<time<<" ms";
  #endif

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

// art下的类加载函数
mirror::Class* ClassLinker::DefineClass(const char* descriptor,
                                        mirror::ClassLoader* class_loader,
                                        const DexFile& dex_file,
                                        const DexFile::ClassDef& dex_class_def) {

//-----------------------added begin-----------------------//
  int uid=::art::GetUid();

  // compiler用来指定当前要创建的ART虚拟机是用来将DEX字节码编译成本地机器指令的
  // 因此排除掉Runtime::Current()->IsCompiler()为true的优化dex文件的art虚拟机情况
  // 参考:http://blog.csdn.net/Luoshengyang/article/details/39307813
  if (Runtime::Current()->IsCompiler()) {
      goto there;
  }

  // 排除掉系统进程(uid == 0的情况)
  if (uid) {
      if (readable) {

		  // 锁
          pthread_mutex_lock(&read_mutex);
          if (readable) {

              readable=false;
              pthread_mutex_unlock(&read_mutex);
              pthread_t read_thread;

			  // 创建线程，读取脱壳配置文件/data/dexname的信息
			  // 获取需要脱壳dex文件的加载路径dexname以及存放脱壳后dex文件dump文件路径dumppath
              pthread_create(&read_thread, NULL, ReadThread, NULL);

          }else{
              pthread_mutex_unlock(&read_mutex);
          }
      }
  }

  // 排除掉uid==0的进程以及被dump的加固dex文件的内存加载路径不能为空
  if(uid && strcmp(dexname,"")){

	 // dex_file.GetLocation().c_str()获取到art下dex文件的加载路径
	 // 通过加固dex文件的加载路径判断是否是需要脱壳的dex文件
     char * res = strstr(dex_file.GetLocation().c_str(), dexname);
     if (res && flag) {

        pthread_mutex_lock(&mutex);
        if (flag) {

           flag=false;
           pthread_mutex_unlock(&mutex);

           char * temp = new char[100];
           strcpy(temp, dumppath);
		   // 拼接字符串得到文件路径 xxxx/part0
           strcat(temp,"part0");

		   // 打开文件xxxx/part0
           FILE *fp = fopen(temp, "wb+");

           // ART下的OAT文件是一个私有的ELF文件格式
		   // 获取OAT文件的内存映射的起始地址即dex优化后私有ELF文件的内存映射地址
           const byte *addr = dex_file.Begin();

           int length = 16;
           // 将OAT文件（即私有ELF文件的）前16字节数据保存到xxxx/part0中
           for (int i = 0; i < 16; i++) {

               fwrite(addr+i, 1 ,1 ,fp);
               fflush(fp);
           }
           fclose(fp);

           strcpy(temp, dumppath);
		   // 得到路径字符串xxxx/part1
           strcat(temp,"part1");

		   // 打开文件xxxx/part1
           fp = fopen(temp, "wb+");
           // 内存地址指针移动到OAT文件即私有ELF文件的第17个字节的位置
           addr = dex_file.Begin() + 16;
           // 获取到OAT文件里即私有ELF文件的第17个字节到dex文件class_defs_off_开始地址之间的数据长度
           length = dex_file.class_defs_off_ - 16;

           // 将OAT文件里即私有ELF文件的第17个字节到dex文件class_defs_off_开始地址的数据写入到xxxx/part1中
           fwrite(addr, 1, length, fp);
           // 刷新文件流
           fflush(fp);
           fclose(fp);

           // 拼接得到字符串xxxx/data
           strcpy(temp, dumppath);
           strcat(temp,"data");

           // 打开文件xxxx/data
           fp = fopen(temp,"wb+");

           // 将OAT文件里的dex文件指针移动到dex文件的ClassDef结构体表Table的结尾位置
           addr = dex_file.Begin()+dex_file.class_defs_off_+sizeof(DexFile::ClassDef)*dex_file.NumClassDefs();
           // 获取OAT文件里dex文件的ClassDef结构体表Table的结尾位置到OAT文件的结尾数据长度
           length=dex_file.Size()-dex_file.class_defs_off_-sizeof(DexFile::ClassDef)*dex_file.NumClassDefs();

           // 将OAT文件里dex文件的ClassDef结构体表Table的结束位置到OAT文件的结尾数据写入到xxxx/data文件中
           fwrite(addr, 1, length, fp);
           fflush(fp);
           fclose(fp);
           delete temp;

           // 当前dex文件所在的class_loader
           param.class_loader = class_loader;
           // 当前dex文件的内存加载的镜像描述结构体
           param.dex_file = &dex_file;
           // 当前dex文件所在的ClassLinker
           param.cl = this;

           pthread_t dumpthread;
           // 创建线程对需要脱壳dex的OAT文件里的类数据进行内存dump处理
           pthread_create(&dumpthread, NULL, DumpClass, (void*)&param);

         }else{
           pthread_mutex_unlock(&mutex);
        }
     }
  }
//-----------------------added end-----------------------//

there:
  Thread* self = Thread::Current();
  SirtRef<mirror::Class> klass(self, NULL);
  // Load the class from the dex file.
  if (UNLIKELY(!init_done_)) {
    // finish up init of hand crafted class_roots_
    if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
      klass.reset(GetClassRoot(kJavaLangObject));
    } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
      klass.reset(GetClassRoot(kJavaLangClass));
    } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
      klass.reset(GetClassRoot(kJavaLangString));
    } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
      klass.reset(GetClassRoot(kJavaLangDexCache));
    } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtField;") == 0) {
      klass.reset(GetClassRoot(kJavaLangReflectArtField));
    } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) {
      klass.reset(GetClassRoot(kJavaLangReflectArtMethod));
    } else {
      klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
    }
  } else {
    klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
  }
  if (UNLIKELY(klass.get() == NULL)) {
    CHECK(self->IsExceptionPending());  // Expect an OOME.
    return NULL;
  }
  klass->SetDexCache(FindDexCache(dex_file));
  LoadClass(dex_file, dex_class_def, klass, class_loader);
  // Check for a pending exception during load
  if (self->IsExceptionPending()) {
    klass->SetStatus(mirror::Class::kStatusError, self);
    return NULL;
  }
  ObjectLock lock(self, klass.get());
  klass->SetClinitThreadId(self->GetTid());
  {
    // Add the newly loaded class to the loaded classes table.
    mirror::Class* existing = InsertClass(descriptor, klass.get(), Hash(descriptor));
    if (existing != NULL) {
      // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
      // this thread to block.
      return EnsureResolved(self, existing);
    }
  }
  // Finish loading (if necessary) by finding parents
  CHECK(!klass->IsLoaded());
  if (!LoadSuperAndInterfaces(klass, dex_file)) {
    // Loading failed.
    klass->SetStatus(mirror::Class::kStatusError, self);
    return NULL;
  }
  CHECK(klass->IsLoaded());
  // Link the class (if necessary)
  CHECK(!klass->IsResolved());
  if (!LinkClass(klass, NULL, self)) {
    // Linking failed.
    klass->SetStatus(mirror::Class::kStatusError, self);
    return NULL;
  }
  CHECK(klass->IsResolved());

  /*
   * We send CLASS_PREPARE events to the debugger from here.  The
   * definition of "preparation" is creating the static fields for a
   * class and initializing them to the standard default values, but not
   * executing any code (that comes later, during "initialization").
   *
   * We did the static preparation in LinkClass.
   *
   * The class has been prepared and resolved but possibly not yet verified
   * at this point.
   */
  Dbg::PostClassPrepare(klass.get());

  return klass.get();
}