Android Linker(二)

so链接

链接过程由soinfo_link_image函数完成,主要可以分为四个主要步骤:
1.定位dynamic section 由函数phdr_table_get_dynamic_section完成,该函数会遍历program header,找到为类型为PT_DYNAMIC的header, 从中获取的是dynamic section的信息,主要就是虚拟地址和项数。
2.解析dynamic section dynamic section本质上是类型为Elf32_Dyn的数组,Elf32_Dyn结构如下:

1
2
3
4
5
6
7
typedef struct {
Elf32_Sword d_tag; /* 类型(例如,DT_SYMTAB),决定d_un表示的意义*/
union {
Elf32_Word d_val; /* 根据d_tag的不同,有不同的意义 */
Elf32_Addr d_ptr; /* 虚拟地址 */
} d_un;
} Elf32_Dyn;

Elf32_Dyn结构的d_tag属性表示该项的类型,类型决定了d_un中信息的意义,例如,当d_tag = DT_SYMTAB表示该项存储的是符号表的信息,d_un.d_ptr表示符号表的虚拟地址的偏移,当d_tag = DT_RELSZ时,d_un.d_val表示重定位表rel的项数。
解析的过程就是遍历数组中的每一项,根据d_tag的不同,获取到不同的信息。
dynamic section中包含的信息主要包括以下3类:
(1)符号信息
(2)重定位信息
(3)init&finit funcs
3.加载needed so 调用find_library获取所有依赖的so的soinfo指针,如果so还没有加载,则会将so加载到内存,分配一个soinfo*[]指针数组,用于存放soinfo指针。
4.重定位 重定位so链接中最复杂同时也是最关键的一步。重定位做的工作主要是修复导入符号的引用,下面一节将对重定位过程进行详细分析。
soinfo_link_image的示意代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
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);

重定位relocate

Android ARM下需要处理两个重定位表,plt_relrelplt指的是延迟绑定,但是Android目前并不对延迟绑定做特殊处理,直接与普通的重定位同时处理。两个重定位的表都由soinfo_relocate函数处理。
soinfo_relocate函数需要遍历重定位表,处理每个重定位项,每个重定位项的处理过程可已分为4步:
1.解析重定位项和导入符号的信息
重定位项的结构如下:

1
2
3
4
typedef struct {
Elf32_Addr r_offset; /* 需要重定位的位置的偏移 */
Elf32_Word r_info; /* 高24位为符号在符号表中的index,低8位为重定位类型 */
} Elf32_Rel;

首先从重定位项获取的信息如下:
(1)重定位的类型type
(2)符号在符号表中的索引号sym,sym为0表示为本so内部的重定位,如果不为0,意味着该符号为导入符号
(3)重定位的目标地址reloc,使用r_offset + si_load_bias,相当于:偏移地址+基地址
符号表表项的结构为elf32_sym:

1
2
3
4
5
6
7
8
typedef struct elf32_sym {
Elf32_Word st_name; /* 名称 – index into string table */
Elf32_Addr st_value; /* 偏移地址 */
Elf32_Word st_size; /* 符号长度( 例如,函数的长度) */
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 ),如果查找成功则该导入符号的地址为:

1
sym_addr = s->st_value + lsi->load_bias;

3.修正需要重定位的地址
根据重定位类型的不同,修正重定位地址,具体的重定位类型定义和计算方法可以参考aaelf文档的 4.6.1.2 节。
对于导入符号,则使用根据第二步得到sym_addr去修正,对于so内部的相对偏移修正,则直接将reloc的地址加上so的基址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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) {
unsigned type = ELFW(R_TYPE)(rel->r_info);
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) {
sym_name = reinterpret_cast<const char*>(si->strtab + si->symtab[sym].st_name);
s = soinfo_do_lookup(si, sym_name, &lsi, needed);
if (s == NULL) {}
} else {
sym_addr = static_cast<ElfW(Addr)>(s->st_value + lsi->load_bias);}
} else {
s = NULL;}
switch (type) {
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:
DL_ERR("%s R_ARM_COPY relocations are not supported", si->name);
return -1;
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;
}

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

1
2
3
4
5
6
7
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文件的CallConstructors函数,接着调用自己的soinfo成员变量init和看init_array指定的函数,这两个变量在解析dynamic section时赋值。

1
2
3
4
5
6
7
8
9
10
void soinfo::CallConstructors() {
if (constructors_called) {
return;
}
get_children().for_each([] (soinfo* si) {
si->CallConstructors();
};
CallFunction("DT_INIT", init_func);
CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);
}

有了以上分析基础后,在需要动态跟踪初始化函数时,我们就知道可以将断点设在do_dlopen或是CallConstructors

加壳技术

在病毒和版权保护领域,“壳”一直扮演着极为重要的角色。通过加壳可以对代码进行压缩和加密,同时再辅以虚拟化、代码混淆和反调试等手段,达到防止静态和动态分析。 在Android环境中,Native层的加壳主要是针对动态链接库so,so加壳的示意图如下:

  • so:即被保护的目标so。
  • loader:自身也是一个so,系统加载时首先加载loader,loader首先还原出经过加密、压缩、变换的so,再将so加载到内存,并完成链接过程,使so可以正常被其他模块使用。
  • 加壳工具:将被保护的so加密、压缩、变换,并将结果作为数据与loader整合为packed so。

下面对so加壳的关键技术进行简单介绍。

loader执行时机

Linker加载完loader后,loader需要将被保护的so加载起来,这就要求loader的代码需要被执行,而且要在被保护so被使用之前,前文介绍了so的初始化函数便可以满足这个要求,同时在Android系统下还可以使用JNI_ONLOAD函数,因此loader的执行时机有两个选择:

  • so的init或initarray
  • jni_onload

loader完成so的加载链接

loader开始执行后,首先需要在内存中还原出so,so可以是经过加密、压缩、变换等手段,也可已单纯的以完全明文的数据存储,这与so加壳的技术没有必要的关系,在此不进行讨论。
在内存中还原出so后,loader还需要执行装载和链接,这两个过程可以完全模仿Linker来实现,下面主要介绍一下相对Linker,loader执行这两个过程有哪些变化。

装载

还原后的so在内存中,所以装载时的主要变化就是从文件装载到从内存装载。
Linker在装载PT_LAOD segment时,使用so文件的描述符fd:

1
2
3
4
5
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时,需要分为两步:

1
2
3
4
5
6
void* seg_addr = mmap(reinterpret_cast<void*>(seg_page_start),
file_length,
PFLAGS_TO_PROT(phdr->p_flags),
MAP_FIXED|MAP_PRIVATE,
-1,0);
memcpy(seg_addr+seg_page_offset, elf_data_buf + phdr->p_offset, phdr->p_filesz);

注意第2步复制segment时,目标地址需要加上seg_page_offsetseg_page_offset是segment相对与页面起始地址的偏移。
其他的步骤基本按照Linker的实现即可,只需要将一些从文件读取修改为从内存读取,比如读elfheader和program header时。

分配soinfo

soinfo保存了so装载链接和运行时需要的所有信息,为了维护相关的信息,loader可以照搬Linker的soinfo结构,用于存储中间信息,装载链接结束后,还需要将soinfo的信息修复到Linker维护的soinfo,下面进行详细说明。

链接

链接过程完全是操作内存,不论是从文件装载还是内存装载,链接过程都是一样,完全模仿Linker即可。
另外链接后记得顺便调用so初始化函数(init和init_array)。

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

reference
http://yaq.qq.com/blog/15