本文博客地址：http://blog.csdn.net/qq1084283172/article/details/78077603
Android应用的so库文件的加固一直存在，也比较常见，特地花时间整理了一下Android so库文件加固方面的知识。本篇文章主要是对看雪论坛《简单的so脱壳器》这篇文章的思路和代码的分析，很久之前就阅读过这篇文章但是一直没有时间来详细分析它的代码，最近比较有空来分析一下这篇文章中提到的Android
so脱壳器的代码udog，github下载地址为：https://github.com/devilogic/udog，Android so加固的一般手法就是去除掉外壳Android so库文件的 ELF 链接视图 相关的信息，例如区节头表的偏移、区节头表的项数、区节头表名称字符串表的序号等，这样处理以后将Android so加固的外壳so库文件拖到IDA中去分析的时候，直接提示区节头表无效的错误，IDA工具不能对Android
so加固的外壳so库文件进行分析，达到抗IDA工具静态分析的目的。
Android so加固中被保护的Android so库文件是由外壳Android so库文件在.init段或者.init_array段的构造函数里自定linker进行内存加载和解密的，被保护的Android so库文件自定义内存加载、映射完成以后将外壳Android so库文件的soinfo*（dlopen函数返回的）修改为被保护Android so库文件的soinfo*，这样被保护的Android so库文件的内存加载就成功了并且就可以被调用了。尽管被加固保护的Android
so库文件被加密保护起来了，但是该Android so库文件还是会在内存中进行解密出来，因此我们可以在被加固保护的Android so库文件内存解密时进行内存dump处理，然后对dump出来的Android so库文件进行ELF文件格式的调整和修复以及section区节头表的重建，就可以实现被保护的Android so库文件的脱壳了。
简单so脱壳器这篇文章中提到的so脱壳器udog的代码比较简单，之前以为udog的代码比较复杂，后来整理了一下作者玩命的代码发现很多代码都是废弃的，核心关键的代码部分不是很复杂但是对于学习Android so加固的脱壳很有作用，也是Android so加固脱壳和内存dump后修复的第一步，玩命版主主要实现了被加固Android so库文件的内存dump和ELF文件格式部分参数的修复处理，对于脱壳后ELF文件的section区节头表等的重建并没有实现。
udog代码的入口 main函数 在linker.cpp文件中如下图所示：
在linker.cpp文件中，main函数工作流程是: 先对用户输入的命令行参数进行解析处理得到 用户参数解析结果描述结构体options_t，然后根据用户输入的命令参数解析的结果options_t 进行Android so的脱壳相关的操作。udog脱壳器中帮助命令行在文件options.cpp中实现，如下图所示：
用户输入的命令行参数解析结果保存结构体options_t中，如下图代码所示：
// 保存用户输入命令行参数的解析结果
struct options_t {
bool call_dt_init;
bool call_dt_init_array;
bool call_dt_finit;
bool call_dt_finit_array;
bool load_pre_libs;
bool load_needed_libs;
bool load;
bool not_relocal; /* 不对重定位表进行修复 */
bool make_sectabs; /* 重建elf文件的区节头表 */
bool dump;
bool help;
bool version;
bool debug;
bool check;
bool clear_entry;
int debuglevel;
unsigned xct_offset;
unsigned xct_size;
char dump_file[128];
char target_file[128];
};对用户输入的命令行参数进行解析处理的操作在函数handle_arguments中实现，如下图代码所示：
// main函数在linker.cpp类
int main(int argc, char* argv[]) {
// 解析用户输入的命令行参数
g_opts = handle_arguments(argc, argv);// 解析用户输入的命令行参数
struct options_t* handle_arguments(int argc, char* argv[]) {
// 保存命令行参数解析后的结果
static struct options_t opts;
// 清零
memset(&opts, 0, sizeof(opts));
// 默认参数的设置
opts.call_dt_init = true;
opts.call_dt_init_array = true;
opts.call_dt_finit = true;
opts.call_dt_finit_array = true;
opts.load_pre_libs = true;
opts.load_needed_libs = true;
int opt;
int longidx;
int dump = 0, help = 0, version = 0,
debug = 0, check = 0, xcto = 0,
xcts = 0, clear_entry = 0;
if (argc == 1) {
return NULL;
}
// 输入参数选项的解析顺序和规则
// 该数据结构包括了所有要定义的短选项，每一个选项都只用单个字母表示。
// 如果该选项需要参数，则其后跟一个冒号
const char* short_opts = ":hvcd:";
// 解析参数的长选项
struct option long_opts[] = {
// 1--选项需要参数
{ "dump", 1, &dump, 1 },
// 0--选项无参数
{ "help", 0, &help, 2 },
{ "version", 0, &version, 3 },
{ "debug", 1, &debug, 4 },
{ "check", 0, &check, 5 },
{ "xcto", 1, &xcto, 6 },
{ "xcts", 1, &xcts, 7 },
{ "clear-entry",0, &clear_entry, 8 },
// 2--选项参数可选
{ 0, 0, 0, 0 }
};
// 对输入的命令行参数进行解析,longidx为解析参数长选项中的序号数
// 参考:https://baike.baidu.com/item/getopt_long/5634851?fr=aladdin
// 参考:http://blog.csdn.net/ast_224/article/details/3861625
while ((opt = getopt_long(argc, argv, short_opts, long_opts, &longidx)) != -1) {
switch (opt) {
case 0:
// 进行so库文件的dump处理
if (dump == 1) {
opts.dump = true;
// 暂时不对dump的so库文件的重定位表进行修复
opts.not_relocal = false;
// 对dump的so库文件的区节头表进行重建
opts.make_sectabs = true;
// 当处理一个带参数的选项时，全局变量optarg会指向它的参数
// optarg为目标so库文件dump后的文件保存路径
strcpy(opts.dump_file, optarg);
// 加载dump的so库文件
opts.load = true;
dump = 0;
} else if (help == 2) {
opts.help = true;
help = 0;
} else if (version == 3) {
opts.version = true;
version = 0;
} else if (debug == 4) {
opts.debug = true;
opts.debuglevel = atoi(optarg);
debug = 0;
} else if (check == 5) {
opts.check = true;
check = 0;
} else if (xcto == 6) {
opts.xct_offset = strtol(optarg, NULL, 16);
xcto = 0;
} else if (xcts == 7) {
opts.xct_size = strtol(optarg, NULL, 16);
xcts = 0;
} else if (clear_entry == 8) {
opts.clear_entry = true;
clear_entry = 0;
} else {
//printf("unknow options: %c\n", optopt);
return NULL;
}
break;
case 'c':
opts.check = true;
break;
case 'h':
opts.help = true;
break;
case 'v':
opts.version = true;
break;
case 'd':
opts.dump = true;
opts.not_relocal = false;
opts.make_sectabs = true;
strcpy(opts.dump_file, optarg);
opts.load = true;
break;
case '?':
//printf("unknow options: %c\n", optopt);
return NULL;
break;
case ':':
//printf("option need a option\n");
return NULL;
break;
}/* end switch */
}/* end while */
/* 无文件 */
if (optind == argc) {
return NULL;
}
// 当函数分析完所有参数时，全局变量optind（into argv）会指向第一个‘非选项’的位置
// 需要被dump的so库文件的文件路径
strcpy(opts.target_file, argv[optind]);
// 返回的引用
return &opts;
}根据对用户输入命令行参数的解析结果options_t，进行Android so加固脱壳相关的操作，这里主要关注的是被加固的Android so库文件的内存dump相关的处理部分，如下图所示：
// 加载需要dump的so库文件
if (g_opts->load) {
// 清零处理
memset(&g_infos, 0, sizeof(g_infos));
// 构建libdl.so库文件系统符号表symtab的填充
fill_libdl_symtab();
// 构建libdl_info结构体的填充
fill_libdl_info();
// unsigned ret = __linker_init((unsigned **)(argv-1));
// if (ret == 0) return ret;
// 获取到需要被dump的so库文件的文件路径
char* fname = g_opts->target_file;
// 动态加载需要被dump的so库文件返回信息描述结构体soinfo指针
soinfo* lib = (soinfo*)dlopen(fname, 0);
if (lib == NULL) {
// 动态库加载失败的情况
return -1;
}
//void* handle = dlsym(lib, "prepare_key");
//if (handle) {
// printf("%x\n", *(unsigned*)handle);
//}
// 从加载后的外壳so库文件中dump出解密后的被保护的so库文件
if (g_opts->dump) {
// dump出被保护的so库文件
if (dump_file(lib) != 0) {
return -1;
}
// 对dump出来被保护的so库文件进行区节头表的重建(玩命版主没有处理)
// if (g_opts->make_sectabs) {
//
// if (make_sectables(g_opts->dump_file) != 0) {
// return -1;
// }
// }
} else {
/* 打印代码CRC */
if (g_opts->check) {
checkcode_by_x((unsigned char*)(lib->base),
"code text crc32",
g_opts->xct_offset,
g_opts->xct_size);
}
}
// 卸载外壳so库文件的加载
dlclose(lib);
// 不加载外壳so库文件的处理，crc32的校验
} else {
/* 未加载的功能 */
if (g_opts->check) {
checkcode(g_opts->target_file, "code text crc32",
g_opts->xct_offset,
g_opts->xct_size);
}
}在进行被加固Android so库文件的内存dump处理之前，还需要了解一下Android so库文件内存加载相关的知识。一般情况下，调用 dlopen函数 实现对Android so库文件的内存加载，调用dlopen函数成功以后返回Android so库文件内存加载后的模块句柄，其实该句柄就是 soinfo* (soinfo结构体的指针)，Android so库文件内存加载成功的内存镜像就是由结构体soinfo来描述的，soinfo结构体在进程内存中比较完整的描述了ELF文件的执行视图相关的信息。
/* so信息结构 */
struct soinfo
{
char name[SOINFO_NAME_LEN]; /* so库文件的文件路径 */
const Elf32_Phdr *phdr; /* 指向程序段头表 */
int phnum; /* 程序段头表的数量 */
unsigned entry; /* so库文件的代码执行入口地址 */
unsigned base; /* so库文件内存加载后的基地址 */
unsigned size; /* so库文件所有可加载段的长度 */
int unused; // DO NOT USE, maintained for compatibility.
unsigned *dynamic; /* .dynamic段描述结构体所在的起始地址*/
unsigned unused2; // DO NOT USE, maintained for compatibility
unsigned unused3; // DO NOT USE, maintained for compatibility
soinfo *next;
unsigned flags;
const char *strtab; /* .strtab段所在的内存地址 */
Elf32_Sym *symtab; /* .symtab段所在的内存地址 */
unsigned nbucket;
unsigned nchain;
unsigned *bucket;
unsigned *chain;
unsigned *plt_got;
Elf32_Rel *plt_rel;
unsigned plt_rel_count;
Elf32_Rel *rel;
unsigned rel_count;
unsigned *preinit_array;
unsigned preinit_array_count;
unsigned *init_array;
unsigned init_array_count;
unsigned *fini_array;
unsigned fini_array_count;
void (*init_func)(void);
void (*fini_func)(void);
#if defined(ANDROID_ARM_LINKER)
/* ARM EABI section used for stack unwinding. */
unsigned *ARM_exidx;
unsigned ARM_exidx_count;
#elif defined(ANDROID_MIPS_LINKER)
#if 0
/* not yet */
unsigned *mips_pltgot
#endif
unsigned mips_symtabno;
unsigned mips_local_gotno;
unsigned mips_gotsym;
#endif /* ANDROID_*_LINKER */
unsigned refcount;
struct link_map linkmap;
int constructors_called; /* 构造函数已经被调用 */
/* When you read a virtual address from the ELF file, add this
* value to get the corresponding address in the process' address space */
Elf32_Addr load_bias;
int has_text_relocations;
/* 表明是否是从主程序中调用 */
//int loader_is_main;
};被加固Android so库文件脱壳操作的流程: 调用dlopen函数加载外壳Android so库文件，dlopen函数成功返回（即被加固保护的Android so库文件在内存中解密、自定义加载成功得到soinfo*，替换掉外壳Android so库文件返回的soinfo结构体指针 soinfo* 为被加固保护的Android so库文件加载成功后得到的 soinfo* ，实现被加固保护的Android so与外壳Android so的无缝衔接）得到被加固保护的Android
so库文件的soinfo*（被加固保护Android so库文件内存镜像的描述结构体），然后对被加固保护的Android so库文件的内存soinfo结构体指针进行解析，获取到被加固保护的Android so库文件ELF文件格式执行视图的描述信息，并根据获取到的这些信息对被加固Android so库文件进行内存dump处理。
被加固保护Android so库文件的内存dump操作在 函数dump_file 中实现，代码如下图所示：
// 从外壳so动态加载返回的soinfo中dump出被加固so库文件
// 参考的源码文件: /bionic/linker/linker.h
int dump_file(soinfo* lib) {
// 创建新文件，用以保存dump出来的so库文件
FILE* fp = fopen(g_opts->dump_file, "w");
if (NULL ==fp) {
printf("create new file: %s error !", g_opts->dump_file);
return -1;
}
// 修改外壳so库文件的整个内存加载区域为可读可写可执行
int ret = mprotect((void*)lib->base, lib->size, 7 /**全部权限打开**/);
// 打印外壳so库文件内存加载返回的soinfo中的信息
printf("--------------------------------------------------\n");
// so库文件的内存加载地址
printf("base = 0x%x\n", lib->base);
// so库文件的内存加载映射大小
printf("size = 0x%x\n", lib->size);
// so库文件的代码指令的入口地址
printf("entry = 0x%x\n", lib->entry);
// so库文件的程序段头表的数量
printf("program header count = %d\n", lib->phnum);
printf("--------------------------------------------------\n");
// dump出来的so库文件的大小
unsigned dump_size = lib->size;
unsigned buf_size = dump_size + 0x10;
// 申请内存空间
unsigned char* buf = new unsigned char [buf_size];
if (NULL == buf) {
printf("size = alloc memery err !\n");
return -1;
}
// 将soinfo描述的so库文件的内存数据拷贝到申请的内存空间中
memcpy(buf, (void*)lib->base, lib->size);
// 定位到soinfo描述的so库文件(ELF)的文件头Elf32_Ehdr
Elf32_Ehdr* elfhdr = (Elf32_Ehdr*)(void*)buf;
// 修改区节头表的数量为0
elfhdr->e_shnum = 0;
// 修改该elf文件的区节数据的文件偏移为0
elfhdr->e_shoff = 0;
// 修改该elf文件区节表名称字符串所在的区节头表的序号为0
elfhdr->e_shstrndx = 0;
// 获取到该elf文件的程序段头表的文件偏移
unsigned phoff = elfhdr->e_phoff;
// 定位到该elf文件的程序段头表的位置
Elf32_Phdr* phdr = (Elf32_Phdr*)(void*)(buf + phoff);
// 遍历该elf文件的程序段头表
for (int i = 0; i < lib->phnum; i++, phdr++) {
// 获取该程序段头描述的程序段所在的相对虚拟内存地址
unsigned v = phdr->p_vaddr;
// 修正该程序段的文件偏移地址为虚拟内存地址
phdr->p_offset = v;
// 获取该程序段头描述的程序段的内存对齐后的数据长度大小
unsigned s = phdr->p_memsz;
// 修正该程序段的文件数据长度大小为内存对齐后的数据长度大小
phdr->p_filesz = s;
}
/* 是否清除DT_INIT入口点 */
if (g_opts->clear_entry)
fix_entry(buf, lib);
// 将该soinfo描述的so库文件修正后的内存数据写入到新创建的g_opts->dump_file文件中
ret = fwrite((void*)buf, 1, dump_size, fp);
// 刷新文件流
fflush(fp);
// 资源的清理
if (buf) delete [] buf;
// 关闭文件
fclose(fp);
printf("Dump so Successful\n");
return 0;
}根据被加固保护Android so库文件内存镜像描述结构体 soinfo* 从进程内存中dump出so库文件的初步操作流程梳理如下：
1. 根据 传入参数soinfo* 获取到被加固Android so库文件的内存加载基地址和内存所有段的长度并修改该so库文件所在内存区域的内存属性为可读可写可执行。
2. 定位到soinfo描述的so库文件(ELF)的文件头Elf32_Ehdr，由于在Android so库文件内存加载时是基于ELF文件的可执行视图，因此该so库文件的链接视图的信息都会被去掉。为了避免so库文件内存dump后被IDA分析出错一般会将Android so库文件中seciton区节头表相关描述信息的参数设置为0，注意：Android 7.0版本的linker在进行Android so库文件的加载时会进行seciton区节头表相关描述信息参数的检查。
3. 由于ELF文件加载内存时需要进行内存对齐的处理，因此内存中的Android so库的程序段的文件偏移和文件数据长度的大小需要进行修正处理。（从Android so库文件比较完整修复的角度来考虑，这一步不是必须甚至是应该去掉的，参考《ELF section修复的一些思考》。）
// elf32文件的程序段的描述头结构
typedef struct elf32_phdr{
Elf32_Word p_type; // 程序段的属性值
Elf32_Off p_offset; // 程序段的文件偏移
Elf32_Addr p_vaddr; // 程序段的相对虚拟地址RVA
Elf32_Addr p_paddr; // 程序段的物理地址
Elf32_Word p_filesz; // 程序段的文件数据长度大小
Elf32_Word p_memsz; // 程序段的文件数据内存对齐处理后的长度大小
Elf32_Word p_flags; // 程序段加载到内存后的可读可写可执行等内存属性值
Elf32_Word p_align; // 程序需要内存对齐的数值
} Elf32_Phdr;4. Android so库文件的 .init段构造函数地址是否清除 的处理。
void fix_entry(unsigned char* buf, soinfo* lib) {
// 获取.dynamic段所在的内存地址
unsigned* d = lib->dynamic;
// 遍历.dynamic段的描述结构体
while (*d) {
// 获取到so库文件的初始化代码地址的描述结构体
if (*d == DT_INIT) {
// 获取到so库文件的初始化代码地址所在的文件偏移
unsigned offset = (unsigned)(d+1) - lib->base;
// 设置so库文件的初始化代码地址的相对虚拟地址为0
*(unsigned*)(void*)(buf + offset) = 0;
break;
}
d += 2;
}
}5. Android so库文件脱壳的修复还缺少的步骤：对比较简单的Android so脱壳和修复来说，上面的这些脱壳步骤已经可以了，IDA已经能够比较正常的分析了，但是基于Android so脱壳和修复进一步处理而言，上面的步骤3应该去掉。udog作者进行了Android so库文件的内存dump和初步的ELF文件修复处理，关于ELF文件的section区节头表相关信息的重建还没有完成，留给读者自己来完成，但是作者玩命已经给出了大致的修复思路。关于Android
so库文件内存dump后修复的详细处理思路可以参考文章《ELF section修复的一些思考》、《从零打造简单的SODUMP工具》、《基于init_array加密的SO的脱壳》、《安卓so文件脱壳思路（java版）附源代码》、《ELF文件格式学习，section修复》，后面有时间我也会对这几篇文章进行学习和分析。
6. Android so库文件内存dump处理操作的说明：自我感觉文章中，对于 dump_file函数 处理的Android so库文件的描述不是很准确（这里提到的被内存dump处理的Android so库文件不一定是被加固保护的Android so库文件的，因为 dlopen函数返回的soinfo* 也可能是外壳so加载器的Android so库文件的，具体以实际操作得到的结果为准，与Android so加固的对抗思路有一定的关系，不好准确描述。）
完整注释版udog代码下载地址：http://download.csdn.net/download/qq1084283172/9997375
