本文博客地址：http://blog.csdn.net/qq1084283172/article/details/78513483
一般情况下，Android Dex文件在加载到内存之前需要先对dex文件进行优化处理（如果Android Dex文件已经优化过，则不需要进行优化处理操作，后面进行加载到内存即可）,在Dalvik虚拟机模式下，Android dex文件经过dex2oat进程优化为odex文件，在ART虚拟机模式下，Android dex文件经过dex2oat进程优化为oat文件-OAT文件为一种私有的ELF格式文件，和一般的ELF文件稍有一些不同。Dalvik虚拟机模式下，Android Dex文件优化为odex文件的处理比较简单，即使Android
Dex文件被Android加固所加固处理，只要Android应用运行时能保证dex文件的类方法的数据是完整的就没有问题，Dalvik虚拟机模式下Android dex文件的优化对Android加固的处理影响不是很大；ART虚拟机模式下，Android dex文件的优化处理比价复杂，在Android dex文件优化处理时要保证dex文件类方法的数据完整，因此ART虚拟机模式下的dex文件优化对Android加固还是有比较大的影响，ART虚拟机模式下dex文件的加载也比较复杂，也致使一些Android加固厂商对ART虚拟机模式下dex文件优化的疏忽，最终导致ART虚拟机模式下可以在dex文件优化时进行dex文件的内存dump操作。
ART模式下基于dex2oat脱壳的文章整理：
Dex2oatHunter github：https://github.com/spriteviki/Dex2oatHunter
《分享一个360加固脱壳模拟器（2017/07/17更新）》
《记一次APP脱壳重打包过程》主要讲360加固dex2oat脱壳后的重打包修复，对于360加固的重打包修复有必要学习研究和实践一下。
ART虚拟机模式下，Android dex文件的加载 openDexFileNative函数 对应的Native实现函数为Jni函数动态注册的
DexFile_openDexFileNative函数 ，也就是说ART虚拟机模式下Android dex文件的加载最终调用的是DexFile_openDexFileNative函数来实现的。
static jint DexFile_openDexFileNative(JNIEnv* env, jclass, jstring javaSourceName, jstring javaOutputName, jint) {
// 得到需要加载的dex文件的文件路径
ScopedUtfChars sourceName(env, javaSourceName);
if (sourceName.c_str() == NULL) {
return 0;
}
// 构建dex文件加载的路径字符串
std::string dex_location(sourceName.c_str());
// dex文件优化后的存放路径字符串
NullableScopedUtfChars outputName(env, javaOutputName);
if (env->ExceptionCheck()) {
return 0;
}
ScopedObjectAccess soa(env);
// 保存dex文件的Checksum
uint32_t dex_location_checksum;
// 获取dex文件的Checksum进行校验检查
if (!DexFile::GetChecksum(dex_location, &dex_location_checksum)) {
LOG(WARNING) << "Failed to compute checksum: " << dex_location;
ThrowLocation throw_location = soa.Self()->GetCurrentLocationForThrow();
soa.Self()->ThrowNewExceptionF(throw_location, "Ljava/io/IOException;",
"Unable to get checksum of dex file: %s", dex_location.c_str());
return 0;
}
// 获取当前进程的运行时的ClassLinker实例对象
ClassLinker* linker = Runtime::Current()->GetClassLinker();
// dex文件格式的简单结构体描述?
const DexFile* dex_file;
// 判断存放优化后dex文件的文件路径是否为NULL
if (outputName.c_str() == NULL) {
// 获取优化后的oat文件并加载到内存，返回dex文件加载到内存后的描述结构体dex_file
dex_file = linker->FindDexFileInOatFileFromDexLocation(dex_location, dex_location_checksum);
} else {
// 构建存放优化后的dex文件oat的路径字符串
std::string oat_location(outputName.c_str());
// 获取优化后的oat文件并加载到内存，返回dex文件加载到内存后的描述结构体dex_file
dex_file = linker->FindOrCreateOatFileForDexLocation(dex_location, dex_location_checksum, oat_location);
}
if (dex_file == NULL) {
LOG(WARNING) << "Failed to open dex file: " << dex_location;
ThrowLocation throw_location = soa.Self()->GetCurrentLocationForThrow();
soa.Self()->ThrowNewExceptionF(throw_location, "Ljava/io/IOException;",
"Unable to open dex file: %s", dex_location.c_str());
return 0;
}
// 设置函数返回值，返回dex文件加载到内存后的描述结构体DexFile*指针
return static_cast<jint>(reinterpret_cast<uintptr_t>(dex_file));
}ART虚拟机模式下，Android dex文件的加载有DexFile_openDexFileNative函数来实现，在dex文件被 加载之前，先进行dex文件的校验处理，dex文件的校验通过之后，当没有指定dex文件优化后的文件路径，调用 FindDexFileInOatFileFromDexLocation函数
进行dex文件的优化和加载处理；当指定了dex文件优化后的文件路径则调用 函数FindOrCreateOatFileForDexLocation 进行dex文件的优化和加载处理。FindDexFileInOatFileFromDexLocation函数 和 FindOrCreateOatFileForDexLocation函数 在被加载的dex文件没被优化时，最终都会调用 GenerateOatFile函数创建dex2oat进程执行dex文件的优化处理，将原始的dex文件优化处理为私有ELF文件格式的oat文件。
FindOrCreateOatFileForDexLocationLocked函数 的实现代码如下，首先创建的新文件用于存放优化的oat文件并保持该文件锁定，然后进行优化的oat文件的查找，如果没有找到dex文件优化后的oat文件，则进行dex文件的优化处理得到oat文件，后面进行oat文件加载到内存的处理，其他的操作暂时不关注。
const DexFile* ClassLinker::FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
uint32_t dex_location_checksum,
const std::string& oat_location) {
// We play a locking game here so that if two different processes
// race to generate (or worse, one tries to open a partial generated
// file) we will be okay. This is actually common with apps that use
// DexClassLoader to work around the dex method reference limit and
// that have a background service running in a separate process.
ScopedFlock scoped_flock;
// 打开或者创建优化后oat文件并保持oat文件锁定
if (!scoped_flock.Init(oat_location)) {
LOG(ERROR) << "Failed to open locked oat file: " << oat_location;
return NULL;
}
// Check if we already have an up-to-date output file
// 判断优化后的oat文件是否存在
const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
dex_location_checksum,
oat_location);
if (dex_file != NULL) {
// 存在，直接返回优化后的oat文件的描述结构体信息
return dex_file;
}
// Generate the output oat file for the dex file
VLOG(class_linker) << "Generating oat file " << oat_location << " for " << dex_location;
// 创建dex2oat进程优化dex文件为oat文件
if (!GenerateOatFile(dex_location, scoped_flock.GetFile().Fd(), oat_location)) {
LOG(ERROR) << "Failed to generate oat file: " << oat_location;
return NULL;
}
// 加载oat文件到内存中
const OatFile* oat_file = OatFile::Open(oat_location, oat_location, NULL,
!Runtime::Current()->IsCompiler());
if (oat_file == NULL) {
LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
return NULL;
}
RegisterOatFileLocked(*oat_file);
const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, &dex_location_checksum);
if (oat_dex_file == NULL) {
LOG(ERROR) << "Failed to find dex file " << dex_location
<< " (checksum " << dex_location_checksum
<< ") in generated oat file: " << oat_location;
return NULL;
}
const DexFile* result = oat_dex_file->OpenDexFile();
CHECK_EQ(dex_location_checksum, result->GetLocationChecksum())
<< "dex_location=" << dex_location << " oat_location=" << oat_location << std::hex
<< " dex_location_checksum=" << dex_location_checksum
<< " DexFile::GetLocationChecksum()=" << result->GetLocationChecksum();
return result;
}有关ART虚拟机模式下，OAT文件加载到Android进程内存中的详细分析，可以参考老罗的博客《Android运行时ART加载OAT文件的过程分析》。GenerateOatFile函数 的代码实现分析如下。
// dex_filename为被加载的dex文件的路径字符串
// oat_fd为dex文件优化的oat文件的文件指针
// oat_cache_filename为存放优化后dex文件oat的文件路径
bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
int oat_fd,
const std::string& oat_cache_filename) {
// 获取Android系统的根路径"/system"
std::string dex2oat_string(GetAndroidRoot());
// 拼接字符串得到优化dex文件的程序dex2oat文件的路径字符串
dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
// 获取到优化dex文件的程序dex2oat文件的路径字符串
const char* dex2oat = dex2oat_string.c_str();
// 获取到当前进程的ClassPath的路径字符串
const char* class_path = Runtime::Current()->GetClassPathString().c_str();
// 获取到当前进程的堆Heap指针
gc::Heap* heap = Runtime::Current()->GetHeap();
// 得到boot_image的优化字符串参数选项"--boot-image="
std::string boot_image_option_string("--boot-image=");
// 设置imageSpace文件的路径字符串
boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
const char* boot_image_option = boot_image_option_string.c_str();
std::string dex_file_option_string("--dex-file=");
// 设置需要优化的dex文件的路径字符串
dex_file_option_string += dex_filename;
const char* dex_file_option = dex_file_option_string.c_str();
std::string oat_fd_option_string("--oat-fd=");
// 设置被优化的oat文件的文件指针
StringAppendF(&oat_fd_option_string, "%d", oat_fd);
const char* oat_fd_option = oat_fd_option_string.c_str();
std::string oat_location_option_string("--oat-location=");
// 设置被优化后的dex文件oat的存放路径
oat_location_option_string += oat_cache_filename;
const char* oat_location_option = oat_location_option_string.c_str();
std::string oat_compiler_filter_string("-compiler-filter:");
// 设置编译选项参数
switch (Runtime::Current()->GetCompilerFilter()) {
case Runtime::kInterpretOnly:
oat_compiler_filter_string += "interpret-only";
break;
case Runtime::kSpace:
oat_compiler_filter_string += "space";
break;
case Runtime::kBalanced:
oat_compiler_filter_string += "balanced";
break;
case Runtime::kSpeed:
oat_compiler_filter_string += "speed";
break;
case Runtime::kEverything:
oat_compiler_filter_string += "everything";
break;
default:
LOG(FATAL) << "Unexpected case.";
}
const char* oat_compiler_filter_option = oat_compiler_filter_string.c_str();
// fork and exec dex2oat
// fork新进程对dex文件进行优化处理
pid_t pid = fork();
if (pid == 0) {
// no allocation allowed between fork and exec
// change process groups, so we don't get reaped by ProcessManager
setpgid(0, 0);
// gLogVerbosity.class_linker = true;
VLOG(class_linker) << dex2oat
<< " --runtime-arg -Xms64m"
<< " --runtime-arg -Xmx64m"
<< " --runtime-arg -classpath"
<< " --runtime-arg " << class_path
<< " --runtime-arg " << oat_compiler_filter_option
#if !defined(ART_TARGET)
<< " --host"
#endif
<< " " << boot_image_option
<< " " << dex_file_option
<< " " << oat_fd_option
<< " " << oat_location_option;
// 创建dex2oat进程对dex文件进行优化为oat文件
execl(dex2oat, dex2oat,
"--runtime-arg", "-Xms64m",
"--runtime-arg", "-Xmx64m",
"--runtime-arg", "-classpath",
"--runtime-arg", class_path,
"--runtime-arg", oat_compiler_filter_option,
#if !defined(ART_TARGET)
"--host",
#endif
boot_image_option, // imageSpace文件的路径
dex_file_option, // 被优化的dex文件的路径
oat_fd_option, // 优化后oat文件的文件指针
oat_location_option, // 优化后dex文件oat的存放文件路径
NULL);
PLOG(FATAL) << "execl(" << dex2oat << ") failed";
return false;
} else {
// wait for dex2oat to finish
// 等待dex文件被优化为oat成功完成
int status;
pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
if (got_pid != pid) {
PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
return false;
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
return false;
}
}
return true;
}ART模式下基于dex2oat脱壳就是在创建dex2oat进程进行dex文件优化具体处理之前进行dex文件的内存dump处理，实现Android加固的dex文件脱壳。以Android 4.4.4 r1的源码为例，ART虚拟机模式下，dex文件的优化处理进程dex2oat的源码实现在文件 /art/dex2oat/dex2oat.cc 中，在调用
dex2oat函数 进行dex的优化之前会先判断dex文件是否可写。因此，选择在这个代码点进行原始dex文件的内存dump处理。
http://androidxref.com/4.4.4_r1/xref/art/dex2oat/dex2oat.cc
Dex2oatHunter脱壳工具添加的dump dex文件的代码如下所示，主要是针对早些时候的360加固和腾讯乐加固的脱壳处理。Dex2oatHunter脱壳工具作者提供的脱壳代码是应用在Android 4.4系统的ART虚拟机模式下的，因此在编译后修改后的dex2aot程序后，在进行360加固和腾讯乐加固的脱壳时，需要将Android系统切换到ART虚拟机模式下才能生效。
https://github.com/spriteviki/Dex2oatHunter/blob/master/art/dex2oat/dex2oat.cc
for (const auto& dex_file : dex_files) {
if (!dex_file->EnableWrite()) {
PLOG(ERROR) << "Failed to make .dex file writeable '" << dex_file->GetLocation() << "'\n";
}
///////////////////////////////////////////
std::string dex_name = dex_file->GetLocation();
LOG(INFO) << "Finding:dex file name-->" << dex_name;
// dump 360加固宝的dex文件
if (dex_name.find("jiagu") != std::string::npos)
{
LOG(INFO) << "Finding:dex file from qihoo-->" << dex_name;
int len = dex_file->Size();
char filename[256] = {0};
sprintf(filename, "%s_%d.dex", dex_name.c_str(), len);
int fd = open(filename , O_WRONLY | O_CREAT | O_TRUNC , S_IRWXU);
if (fd > 0)
{
if (write(fd, (char*)dex_file->Begin(), len) <= 0)
{
LOG(INFO) << "Finding:write target dex file failed-->" << filename;
}
LOG(INFO) << "Finding:write target dex file successfully-->" << filename;
close(fd);
}else
{
LOG(INFO) << "Finding:open target dex file failed-->" << filename;
}
}
// dump 腾讯乐固的dex文件
if (tx_oat_filename.find("libshellc") != std::string::npos)
{
LOG(INFO) << "Finding:dex file from legu-->" << dex_name;
int len = dex_file->Size();
char filename[256] = {0};
sprintf(filename, "%s_%d.dex", tx_oat_filename.c_str(), len);
int fd = open(filename , O_WRONLY | O_CREAT | O_TRUNC , S_IRWXU);
if (fd > 0)
{
if (write(fd, (char*)dex_file->Begin(), len) <= 0)
{
LOG(INFO) << "Finding:write target dex file failed-->" << filename;
}
LOG(INFO) << "Finding:write target dex file successfully-->" << filename;
close(fd);
}else
{
LOG(INFO) << "Finding:open target dex file failed-->" << filename;
}
///////////////////////////////////////////
}
}经过测试，上面添加的脱壳代码在Android 5.1系统的源码上也适用，并且修改的代码点位置也是这个地方。尽管上面添加的脱壳代码能对360加固和腾讯乐固进行dump脱壳，但是感觉灵活性不够，只能对360加固和腾讯加固进行处理，过滤的字符串是固定的，一旦修改后的dex2oat程序编译好，过滤字符串一改变又得重新编译dex2oat程序，重新打包Android的镜像文件。基于这些麻烦和通用性不够的问题，对上面的代码进行了修改，增加了脱壳的通用性，动态的配置脱壳的过滤字符串，代码实现如下。在没有设置脱壳过滤字符串的情况下，默认只支持对360加固进行脱壳；如果需要配置脱壳过滤字符串，可以构建和编辑
/data/dex_dump_filter 配置文件 在Android 5.1 的系统源码上测试通过。
/******Android加固dex文件的dump*******/
// 获取被优化的Android dex文件的文件路径
std::string dex_file_name = dex_file->GetLocation();
LOG(INFO) << "Fly---get Dex File Name: " << dex_file_name;
// dex dump的过滤词
std::string str_dex_dump_filter;
FILE *fp = NULL;
std::string filter_path_name = "/data/dex_dump_filter";
if (access(filter_path_name.c_str(), F_OK) == 0) {
// 打开配置文件/data/dex_dump_filter
fp = fopen("/data/dex_dump_filter", "r");
if (fp == NULL) {
LOG(INFO) << "Fly---get /data/dex_dump_filter ";
// 默认dump 360加固dex的oat文件
str_dex_dump_filter = ".jiagu";
} else {
char szFilterBuffer[128] = {0};
// 读取文件中的第1行字符串---dex dump的过滤词
fgets(szFilterBuffer, strlen(szFilterBuffer), fp);
szFilterBuffer[strlen(szFilterBuffer) - 1]=0;
// 进行字符串的拷贝
str_dex_dump_filter.copy(szFilterBuffer, 0, strlen(szFilterBuffer) - 1);
fclose(fp);
fp = NULL;
}
} else {
// 默认dump 360加固dex的oat文件
str_dex_dump_filter = ".jiagu";
}
// 进行dex dump的过滤
if (dex_file_name.find(str_dex_dump_filter.c_str()) != std::string::npos) {
// 获取优化后的oat文件的大小
int nLenth = dex_file->Size();
char szBuffer[256] = {0};
// 格式化字符串得到dump的dex文件（OAT）的名称
sprintf(szBuffer, "%s_%d.dex", dex_file_name.c_str(), nLenth);
// 打开或者创建文件
int fopen = open(szBuffer, O_WRONLY | O_CREAT | O_TRUNC , S_IRWXU);
// 判断文件是否打开成功
if (fopen > 0) {
// 将优化后dex的oat文件保存到指定名称文件中。
if (write(fopen, (char*)(dex_file->Begin()), nLenth) <= 0) {
LOG(INFO) << "Fly---write target dex file failed: " << szBuffer;
} else {
// 将优化后dex的oat文件保存到dex文件优化目录下成功
LOG(INFO) << "Fly---write target dex file OK: " << szBuffer;
}
// 关闭文件
close(fopen);
} else {
LOG(INFO) << "Fly---open target dex file failed: " << szBuffer;
}
}
/******Android加固dex文件的dump*******/ART虚拟机模式下基于dex2oat脱壳是有必要条件的：1. 需要脱壳的Android加固应用必须运行ART虚拟机模式下；2.需要脱壳的Android加固应用通过DexClassLoader加载的dex文件必须是没有经过优化处理的，比如 梆梆加固加载的dex文件是已经经过优化处理的oat文件，因此针对这类情况的Android加固应用使用ART虚拟机模式下基于dex2oat脱壳是无效的。
在Android 5.1系统的源码情况下，按照上面我提供的脱壳代码修改Android 5.1系统的 dex2oat的源码，然后编译生成Android 5.1模拟器的系统镜像文件，进行360加固Android应用的脱壳测试，结果如下图所示：
Android系统的 /data/data/com.emate.shop/.jiagu 目录下360加固 dump出来的dex文件截图如下：
经过验证dex文件发现 classes.dex_7766528.dex 文件 就是原始的dex文件，如下图：
后记：尽管这种脱壳的方法不是很通用也不能脱最新版的360加固和腾讯乐固了，但是提供了一种ART虚拟机模式下基于dex2oat脱壳的思路。知识很多，整理真的很需要时间~