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

dynamic section本質上是類型為Elf32_Dyn的數組，Elf32_Dyn 結構如下

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 類:

- 符號信息

- 重定位信息

- init&finit funcs

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(base + d->d_un.d_ptr)[0];

si->nchain = reinterpret_cast(base + d->d_un.d_ptr)[1];

si->bucket = reinterpret_cast(base + d->d_un.d_ptr + 8);

si->chain = reinterpret_cast(base + d->d_un.d_ptr + 8 + si->nbucket * 4);

break;

case DT_SYMTAB:

si->symtab = reinterpret_cast(base + d->d_un.d_ptr);

break;

case DT_STRTAB:

si->strtab = reinterpret_cast(base + d->d_un.d_ptr);

break;

// 以下為重定位信息

case DT_JMPREL:

si->plt_rel = reinterpret_cast(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(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(base + d->d_un.d_ptr);

break;

case DT_FINI:

...

case DT_INIT_ARRAY:

si->init_array = reinterpret_cast(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(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(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(s->st_value + lsi->load_bias);}

} else {

s = NULL;}

// 3. 根據重定位類型，修正需要重定位的地址

switch (type) {

// 判斷重定位類型，將需要重定位的地址 reloc 修正為目標符號地址

// 修正導入符號

case R_ARM_JUMP_SLOT:

*reinterpret_cast(reloc) = sym_addr;

break;

case R_ARM_GLOB_DAT:

*reinterpret_cast(reloc) = sym_addr;

break;

case R_ARM_ABS32:

*reinterpret_cast(reloc) += sym_addr;

break;

case R_ARM_REL32:

*reinterpret_cast(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(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 加殼的示意圖如下:

加殼工具、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(seg_page_start),

file_length,

PFLAGS_TO_PROT(phdr->p_flags),

MAP_FIXED|MAP_PRIVATE,

fd_,

file_page_start);

按照 Linker 裝載，PT_LAOD segment時，需要分為兩步：

// 1、改用匿名映射

void* seg_addr = mmap(reinterpret_cast(seg_page_start),

file_length,

PFLAGS_TO_PROT(phdr->p_flags),

MAP_FIXED|MAP_PRIVATE,

-1,

0);

// 2、將內存中的 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。

修復過程如下：

00001. 獲取 Linker 維護的 soinfo，可以通過 dlopen 打開自己來獲得：self_soinfo = dlopen(self)。

00002. 將 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

（騰訊御安全團隊）

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容