AndroidLinker与SO加壳技术之下篇
主页内可搜索查看《AndroidLinker与SO加壳技术之上篇》数组
2.4 连接
连接过程由 soinfo_link_image 函数完成，主要能够分为四个主要步骤:
1.定位 dynamic section
由函数 phdr_table_get_dynamic_section 完成，该函数会遍历 program header，找到为类型为 PT_DYNAMIC 的 header, 从中获取的是 dynamic section 的信息，主要就是虚拟地址和项数。安全
2.解析 dynamic section
本质上是类型为Elf32_Dyn的数组，Elf32_Dyn 结构以下app
typedef struct {
Elf32_Sword d_tag; /* 类型(e.g. DT_SYMTAB)，决定 d_un 表示的意义*/
union {
Elf32_Word d_val; /* 根据 d_tag的不一样，有不一样的意义*/
Elf32_Addr d_ptr; /* 虚拟地址 */
} d_un;
} Elf32_Dyn;
Elf32_Dyn结构的d_tag属性表示该项的类型，类型决定了dun中信息的意义，e.g.:当d_tag = DT_SYMTAB表示该项存储的是符号表的信息，d_un.d_ptr 表示符号表的虚拟地址的偏移，当d_tag = DT_RELSZ时，d_un.d_val 表示重定位表rel的项数。
解析的过程就是遍历数组中的每一项，根据d_tag的不一样，获取到不一样的信息。
dynamic section 中包含的信息主要包括如下 3 类:函数
符号信息工具
重定位信息ui
init&finit funcsthis
3.加载 needed SO
调用 find_library 获取全部依赖的 SO 的 soinfo 指针，若是 SO 尚未加载，则会将 SO 加载到内存，分配一个soinfo*[]指针数组，用于存放 soinfo 指针。加密
4.重定位
重定位SO 连接中最复杂同时也是最关键的一步。重定位作的工做主要是修复导入符号的引用，下面一节将对重定位过程进行详细分析。
soinfo_link_image 的示意代码:指针
static bool soinfo_link_image(soinfo* si, const Android_dlextinfo* extinfo) {
...
// 1. 获取 dynamic section 的信息，si->dynamic 指向 dynamic section
phdr_table_get_dynamic_section(phdr, phnum, base, &si->dynamic,
&dynamic_count, &dynamic_flags);
...
// 2. 解析dynamic section
uint32_t needed_count = 0;
for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
switch (d->d_tag) {
// 如下为符号信息
case DT_HASH:
si->nbucket = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr)[0];
si->nchain = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr)[1];
si->bucket = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr + 8);
si->chain = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr + 8 + si->nbucket * 4);
break;
case DT_SYMTAB:
si->symtab = reinterpret_cast<ElfW(Sym)*>(base + d->d_un.d_ptr);
break;
case DT_STRTAB:
si->strtab = reinterpret_cast<const char*>(base + d->d_un.d_ptr);
break;
// 如下为重定位信息
case DT_JMPREL:
si->plt_rel = reinterpret_cast<ElfW(Rel)*>(base + d->d_un.d_ptr);
break;
case DT_PLTRELSZ:
si->plt_rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
break;
case DT_REL:
si->rel = reinterpret_cast<ElfW(Rel)*>(base + d->d_un.d_ptr);
break;
case DT_RELSZ:
si->rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
break;
// 如下为 init&finit funcs
case DT_INIT:
si->init_func = reinterpret_cast<Linker_function_t>(base + d->d_un.d_ptr);
break;
case DT_FINI:
...
case DT_INIT_ARRAY:
si->init_array = reinterpret_cast<Linker_function_t*>(base + d->d_un.d_ptr);
break;
case DT_INIT_ARRAYSZ:
...
case DT_FINI_ARRAY:
...
case DT_FINI_ARRAYSZ:
...
// SO 依赖
case DT_NEEDED:
...
...
}
// 3. 加载依赖的SO
for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
if (d->d_tag == DT_NEEDED) {
soinfo* lsi = find_library(library_name, 0, NULL);
si->add_child(lsi);
*pneeded++ = lsi;
}
}
*pneeded = NULL;
...
// 4. 重定位
soinfo_relocate(si, si->plt_rel, si->plt_rel_count, needed);
soinfo_relocate(si, si->rel, si->rel_count, needed);
...
// 设置已连接标志
si->flags |= FLAG_LINKED;
DEBUG("[ finished linking %s ]", si->name);
｝
2.4.1 重定位 relocate
Android ARM 下须要处理两个重定位表，plt_rel 和 rel，plt 指的是延迟绑定，可是 Android 目前并不对延迟绑定作特殊处理，直接与普通的重定位同时处理。两个重定位的表都由 soinfo_relocate 函数处理。
soinfo_relocate 函数须要遍历重定位表，处理每一个重定位项，每一个重定位项的处理过程可已分为 4 步:
1.解析重定位项和导入符号的信息
重定位项的结构以下：调试
typedef struct {
Elf32_Addr r_offset; /* 须要重定位的位置的偏移 */
Elf32_Word r_info; /* 高24位为符号在符号表中的index，低8位为重定位类型 */
} Elf32_Rel;
首先从重定位项获取的信息以下:
· 重定位的类型 type
· 符号在符号表中的索引号 sym，sym 为0表示为本SO内部的重定位，若是不为0，意味着该符号为导入符号
· 重定位的目标地址 reloc，使用r_offset + si_load_bias，至关于 偏移地址+基地址
符号表表项的结构为elf32_sym:
typedef struct elf32_sym {
Elf32_Word st_name; /* 名称 - index into string table */
Elf32_Addr st_value; /* 偏移地址 */
Elf32_Word st_size; /* 符号长度（ e.g. 函数的长度） */
unsigned char st_info; /* 类型和绑定类型 */
unsigned char st_other; /* 未定义 */
Elf32_Half st_shndx; /* section header的索引号，表示位于哪一个 section 中 */
} Elf32_Sym;
2.若是 sym 不为0，则查找导入符号的信息
若是 sym 不为0，则继续使用 sym 在符号表中获取符号信息，从符号信息中进一步获取符号的名称。随后调用 soinfo_do_lookup 函数在全部依赖的 SO 中根据符号名称查找符号信息，返回值类型为 elf32_sym，同时还会返回含有该符号的 SO 的 soinfo( lsi )，若是查找成功则该导入符号的地址为:sym_addr = s->st_value + lsi->load_bias;
3.修正须要重定位的地址
根据重定位类型的不一样，修正重定位地址，具体的重定位类型定义和计算方法能够参考 aaelf 文档的 4.6.1.2 节。对于导入符号，则使用根据第二步获得 sym_addr 去修正，对于 SO 内部的相对偏移修正，则直接将reloc的地址加上 SO 的基址。
static int soinfo_relocate(soinfo* si, ElfW(Rel)* rel, unsigned count, soinfo* needed[]) {
ElfW(Sym)* s;
soinfo* lsi;
// 遍历重定位表
for (size_t idx = 0; idx < count; ++idx, ++rel) {
// 1. 解析重定位项和导入符号的信息
// 重定位类型
unsigned type = ELFW(R_TYPE)(rel->r_info);
// 导入符号在符号表中的 index，能够为0,(修正 SO 内部的相对偏移)
unsigned sym = ELFW(R_SYM)(rel->r_info);
// 须要重定位的地址
ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + si->load_bias);
ElfW(Addr) sym_addr = 0;
const char* sym_name = NULL;
if (type == 0) { // R_*_NONE
continue;
}
if (sym != 0) {
// 2. 若是 sym 有效，则查找导入符号
// 从符号表中得到符号信息，在根据符号信息从字符串表中获取字符串名
sym_name = reinterpret_cast<const char*>(si->strtab + si->symtab[sym].st_name);
// 在依赖的 SO 中查找符号，返回值为 Elf32_Sym 类型
s = soinfo_do_lookup(si, sym_name, &lsi, needed);
if (s == NULL) {}
// 查找失败，不关心
} else {
// 查找成功，最终的符号地址 = s->st_value + lsi->load_bias
// s->st_value 是符号在依赖 SO 中的偏移，lsi->load_bias 为依赖 SO 的基址
sym_addr = static_cast<ElfW(Addr)>(s->st_value + lsi->load_bias);}
} else {
s = NULL;}
// 3. 根据重定位类型，修正须要重定位的地址
switch (type) {
// 判断重定位类型，将须要重定位的地址 reloc 修正为目标符号地址
// 修正导入符号
case R_ARM_JUMP_SLOT:
*reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
break;
case R_ARM_GLOB_DAT:
*reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
break;
case R_ARM_ABS32:
*reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
break;
case R_ARM_REL32:
*reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset;
break;
// 不支持
case R_ARM_COPY:
/*
* ET_EXEC is not supported SO this should not happen.
*/
DL_ERR("%s R_ARM_COPY relocations are not supported", si->name);
return -1;
// SO 内部的偏移修正
case R_ARM_RELATIVE:
if (sym) {
DL_ERR("odd RELATIVE form...");
return -1;
}
*reinterpret_cast<ElfW(Addr)*>(reloc) += si->base;
break;
default:
DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx);
return -1;}
}
return 0;
}
2.5 CallConstructors
在编译 SO 时，能够经过连接选项-init或是给函数添加属性__attribute__((constructor))来指定 SO 的初始化函数，这些初始化函数在 SO 装载连接后便会被调用，再以后才会将 SO 的 soinfo 指针返回给 dl_open 的调用者。SO 层面的保护手段，有两个介入点, 一个是 jni_onload, 另外一个就是初始化函数，好比反调试、脱壳等，逆向分析时常常须要动态调试分析这些初始化函数。完成 SO 的装载连接后，返回到 do_dlopen 函数, do_open 得到 find_library 返回的刚刚加载的 SO 的 soinfo，在将 soinfo 返回给其余模块使用以前，最后还须要调用 soinfo 的成员函数 CallConstructors。
soinfo* do_dlopen(const char* name, int flags, const Android_dlextinfo* extinfo) {
soinfo* si = find_library(name, flags, extinfo);
if (si != NULL) {
si->CallConstructors();}
return si;...
}
CallConstructors 函数会调用 SO 的首先调用全部依赖的 SO 的 soinfo 的 CallConstructors 函数，接着调用本身的 soinfo 成员变量 init 和 看 init_array 指定的函数，这两个变量在在解析 dynamic section 时赋值。
void soinfo::CallConstructors() {
//若是已经调用过，则直接返回
if (constructors_called) {
return; }
// 调用依赖 SO 的 Constructors 函数
get_children().for_each([] (soinfo* si) {
si->CallConstructors(); };
// 调用 init_func
CallFunction("DT_INIT", init_func);
// 调用 init_array 中的函数
CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);
}
有了以上分析基础后，在须要动态跟踪初始化函数时，咱们就知道能够将断点设在 do_dlopen 或是CallConstructors。
3. 加壳技术
在病毒和版权保护领域，“壳”一直扮演着极为重要的角色。经过加壳能够对代码进行压缩和加密，同时再辅以虚拟化、代码混淆和反调试等手段，达到防止静态和动态分析。
在 Android 环境中，Native 层的加壳主要是针对动态连接库 SO，SO 加壳的示意图以下:
971d553b96f870722f47063126db1083.png
加壳工具、loader、被保护SO。
· SO: 即被保护的目标 SO。
· loader: 自身也是一个 SO，系统加载时首先加载 loader，loader 首先还原出通过加密、压缩、变换的 SO，再将 SO 加载到内存，并完成连接过程，使 SO 能够正常被其余模块使用。
· 加壳工具: 将被保护的 SO 加密、压缩、变换，并将结果做为数据与 loader 整合为 packed SO。
下面对 SO 加壳的关键技术进行简单介绍。
3.1 loader 执行时机
Linker 加载完 loader 后，loader 须要将被保护的 SO 加载起来，这就要求 loader 的代码须要被执行，并且要在 被保护 SO 被使用以前，前文介绍了 SO 的初始化函数即可以知足这个要求，同时在 Android 系统下还可使用 JNI_ONLOAD 函数，所以 loader 的执行时机有两个选择:
· SO 的 init 或 initarray
· jni_onload
3.2 loader 完成 SO 的加载连接
loader 开始执行后，首先须要在内存中还原出 SO，SO 能够是通过加密、压缩、变换等手段，也可已单纯的以彻底明文的数据存储，这与 SO 加壳的技术没有必要的关系，在此不进行讨论。
在内存中还原出 SO 后，loader 还须要执行装载和连接，这两个过程能够彻底模仿 Linker 来实现，下面主要介绍一下相对 Linker，loader 执行这两个过程有哪些变化。
3.2.1 装载
还原后的 SO 在内存中，因此装载时的主要变化就是从文件装载到从内存装载。
Linker 在装载 PT_LAOD segment时，使用 SO 文件的描述符 fd：
void* seg_addr = mmap(reinterpret_cast<void*>(seg_page_start), file_length, PFLAGS_TO_PROT(phdr->p_flags), MAP_FIXED|MAP_PRIVATE, fd_,file_page_start); 按照 Linker 装载，PT_LAOD segment时，须要分为两步： // 一、改用匿名映射 void* seg_addr = mmap(reinterpret_cast<void*>(seg_page_start), file_length, PFLAGS_TO_PROT(phdr->p_flags), MAP_FIXED|MAP_PRIVATE, -1,0); // 二、将内存中的 segment 复制到映射的内存中 memcpy(seg_addr+seg_page_offset, elf_data_buf + phdr->p_offset, phdr->p_filesz);
注意第2步复制 segment 时，目标地址须要加上 seg_page_offset，seg_page_offset 是 segment 相对与页面起始地址的偏移。
其余的步骤基本按照 Linker 的实现便可，只须要将一些从文件读取修改成从内存读取，好比读 elfheader和program header时。
3.2.2 分配 soinfo
soinfo 保存了 SO 装载连接和运行时须要的全部信息，为了维护相关的信息，loader 能够照搬 Linker 的 soinfo 结构，用于存储中间信息，装载连接结束后，还须要将 soinfo 的信息修复到 Linker 维护的soinfo，3.3节进行详细说明。
3.2.3 连接
连接过程彻底是操做内存，不管是从文件装载仍是内存装载，连接过程都是同样，彻底模仿 Linker 便可。
另外连接后记得顺便调用 SO 初始化函数( init 和 init_array )。
3.3 soinfo 修复
SO 加壳的最关键技术点在于 soinfo 的修复，因为 Linker 加载的是 loader，而实际对外使用的是被保护的 SO，因此 Linker 维护的 soinfo 能够说是错误，loader 须要将本身维护的 soinfo 中的部分信息导出给 Linker 的soinfo。
修复过程以下：
获取 Linker 维护的 soinfo，能够经过 dlopen 打开本身来得到：self_soinfo = dlopen(self)。
将 loader soinfo 中的信息导出到 self_soinfo，最简单粗暴的方式就是直接赋值，好比：self_soinfo.base = soinfo.base。须要导出的主要有如下几项：
· SO地址范围：base、size、load_bias
· 符号信息:sym_tab、str_tab、· 符号查找信息：nbucket、nchain、bucket、chain· 异常处理：ARM_exidx、ARM_exidx_count参考· <<Linkers and loaders>>· <<ELF for the ARM Architecture>>（腾讯御安全）
- 1. AndroidLinker与SO加壳技术之下篇
- 2. AndroidLinker与SO加壳技术之上篇
- 3. Android Linker 与 SO 加壳技术
- 4. Android SO 加壳(加密)与脱壳思路
- 5. android apk 防止反编译技术第一篇-加壳技术
- 6. Android Apk加壳技术实战详解
- 7. Android APK加壳技术方案【1】
- 8. Android APK加壳技术方案
- 9. 360加固保so动态脱壳
- 10. 脱壳之加密壳
- 更多相关文章...
- • XML 相关技术 - XML 教程
- • Hibernate的快照技术 - Hibernate教程
- • 三篇文章了解 TiDB 技术内幕——说存储
- • 三篇文章了解 TiDB 技术内幕 —— 说计算
-
每一个你不满意的现在，都有一个你没有努力的曾经。