AndroidLinker與SO加殼技術之上篇－IT工程師數位筆記本

文章出處

AndroidLinker與SO加殼技術之上篇。

1. 前言

Android 系統安全愈發重要，像傳統pc安全的可執行文件加固一樣，應用加固是Android系統安全中非常重要的一環。目前Android 應用加固可以分為dex加固和Native加固，Native 加固的保護對象為 Native 層的 SO 文件，使用加殼、反調試、混淆、VM 等手段增加SO文件的反編譯難度。目前最主流的 SO 文件保護方案還是加殼技術，在SO文件加殼和脫殼的攻防技術領域，最重要的基礎的便是對于 Linker 即裝載鏈接機制的理解。對于非安全方向開發者，深刻理解系統的裝載與鏈接機制也是進階的必要條件。

本文詳細分析了 Linker 對 SO 文件的裝載和鏈接過程，最后對 SO 加殼的關鍵技術進行了簡要的介紹。

對于 Linker 的學習，還應該包括 Linker 自舉、可執行文件的加載等技術，但是限于本人的技術水平，本文的討論范圍限定在 SO 文件的加載，也就是在調用dlopen("libxx.SO")之后，Linker 的處理過程。

本文基于 Android 5.0 AOSP 源碼，僅針對 ARM 平臺，為了增強可讀性，文中列舉的源碼均經過刪減，去除了其他 CPU 架構的相關源碼以及錯誤處理。

另:閱讀本文的讀者需要對 ELF 文件結構有一定的了解。

2. SO 的裝載與鏈接

2.1 整體流程說明

1. do_dlopen調用 dl_open 后，中間經過 dlopen_ext, 到達第一個主要函數 do_dlopen:

soinfo* do_dlopen(const char* name, int flags, const Android_dlextinfo* extinfo) { protect_data(PROT_READ | PROT_WRITE); soinfo* si = find_library(name, flags, extinfo); // 查找 SO if (si != NULL) { si->CallConstructors(); // 調用 SO 的 init 函數 } protect_data(PROT_READ); return si;}

do_dlopen 調用了兩個重要的函數，第一個是find_library, 第二個是 soinfo 的成員函數 CallConstructors，find_library 函數是 SO 裝載鏈接的后續函數，完成 SO 的裝載鏈接后，通過 CallConstructors 調用 SO 的初始化函數。

2. find_library_internalfind_library 直接調用了 find_library_internal，下面直接看 find_library_internal函數:

static soinfo* find_library_internal(const char* name, int dlflags, const Android_dlextinfo* extinfo) { if (name == NULL) { return somain; } soinfo* si = find_loaded_library_by_name(name); // 判斷 SO 是否已經加載 if (si == NULL) { TRACE("[ '%s' has not been found by name. Trying harder...]", name); si = load_library(name, dlflags, extinfo); // 繼續 SO 的加載流程 } if (si != NULL && (si->flags & FLAG_LINKED) == 0) { DL_ERR("recursive link to \"%s\"", si->name); return NULL; } return si;}

find_library_internal 首先通過 find_loaded_library_by_name 函數判斷目標 SO 是否已經加載，如果已經加載則直接返回對應的soinfo指針，沒有加載的話則調用 load_library 繼續加載流程，下面看 load_library 函數。

3. load_library

static soinfo* load_library(const char* name, int dlflags, const Android_dlextinfo* extinfo) { int fd = -1; ... // Open the file. fd = open_library(name); // 打開 SO 文件，獲得文件描述符 fd ElfReader elf_reader(name, fd); // 創建 ElfReader 對象 ... // Read the ELF header and load the segments. if (!elf_reader.Load(extinfo)) { // 使用 ElfReader 的 Load 方法，完成 SO 裝載 return NULL; } soinfo* si = soinfo_alloc(SEARCH_NAME(name), &file_stat); // 為 SO 分配新的 soinfo 結構 if (si == NULL) { return NULL; } si->base = elf_reader.load_start(); // 根據裝載結果，更新 soinfo 的成員變量 si->size = elf_reader.load_size(); si->load_bias = elf_reader.load_bias(); si->phnum = elf_reader.phdr_count(); si->phdr = elf_reader.loaded_phdr(); ... if (!soinfo_link_image(si, extinfo)) { // 調用 soinfo_link_image 完成 SO 的鏈接過程 soinfo_free(si); return NULL; } return si;}

load_library 函數呈現了 SO 裝載鏈接的整個流程，主要有3步:

裝載:創建ElfReader對象，通過 ElfReader 對象的 Load 方法將 SO 文件裝載到內存

分配soinfo:調用 soinfo_alloc 函數為 SO 分配新的 soinfo 結構，并按照裝載結果更新相應的成員變量

鏈接: 調用 soinfo_link_image 完成 SO 的鏈接

通過前面的分析，可以看到， load_library 函數中包含了 SO 裝載鏈接的主要過程, 后文主要通過分析 ElfReader 類和 soinfo_link_image 函數, 來分別介紹 SO 的裝載和鏈接過程。

2.2 裝載

在 load_library 中，首先初始化 elf_reader 對象, 第一個參數為 SO 的名字，第二個參數為文件描述符 fd:ElfReader elf_reader(name, fd)之后調用 ElfReader 的 load 方法裝載 SO。

... // Read the ELF header and load the segments. if (!elf_reader.Load(extinfo)) { return NULL; } ...

ElfReader::Load 方法如下:

bool ElfReader::Load(const Android_dlextinfo* extinfo) { return ReadElfHeader() && // 讀取 elf header VerifyElfHeader() && // 驗證 elf header ReadProgramHeader() && // 讀取 program header ReserveAddressSpace(extinfo) &&// 分配空間 LoadSegments() && // 按照 program header 指示裝載 segments FindPhdr(); // 找到裝載后的 phdr 地址}

ElfReader::Load 方法首先讀取 SO 的elf header，再對elf header進行驗證，之后讀取program header，根據program header 計算 SO 需要的內存大小并分配相應的空間，緊接著將 SO 按照以 segment 為單位裝載到內存，最后在裝載到內存的 SO 中找到program header，方便之后的鏈接過程使用。下面深入 ElfReader 的這幾個成員函數進行詳細介紹。

2.2.1 read&verify elfheader

bool ElfReader::ReadElfHeader() { ssize_t rc = read(fd_, &header_, sizeof(header_)); if (rc != sizeof(header_)) { return false; } return true;}

ReadElfHeader 使用 read 直接從 SO 文件中將 elfheader 讀取 header 中，header_ 為 ElfReader 的成員變量，類型為 Elf32_Ehdr，通過 header 可以方便的訪問 elf header中各個字段，elf header中包含有 program header table、section header table等重要信息。對 elf header 的驗證包括:

magic字節

32/64 bit 與當前平臺是否一致

大小端

類型:可執行文件、SO …

版本:一般為 1，表示當前版本

平臺:ARM、x86、amd64 …

有任何錯誤都會導致加載失敗。

2.2.2 Read ProgramHeader

bool ElfReader::ReadProgramHeader() { phdr_num_ = header_.e_phnum; // program header 數量 // mmap 要求頁對齊 ElfW(Addr) page_min = PAGE_START(header_.e_phoff); ElfW(Addr) page_max = PAGE_END(header_.e_phoff + (phdr_num_ * sizeof(ElfW(Phdr)))); ElfW(Addr) page_offset = PAGE_OFFSET(header_.e_phoff); phdr_size_ = page_max - page_min; // 使用 mmap 將 program header 映射到內存 void* mmap_result = mmap(NULL, phdr_size_, PROT_READ, MAP_PRIVATE, fd_, page_min); phdr_mmap_ = mmap_result; // ElfReader 的成員變量 phdr_table_ 指向program header table phdr_table_ = reinterpret_cast(reinterpret_cast(mmap_result) + page_offset); return true;}

將 program header 在內存中單獨映射一份，用于解析program header 時臨時使用，在 SO 裝載到內存后，便會釋放這塊內存，轉而使用裝載后的 SO 中的program header。

2.2.3 reserve space & 計算 load size

bool ElfReader::ReserveAddressSpace(const Android_dlextinfo* extinfo) { ElfW(Addr) min_vaddr; // 計算加載SO 需要的空間大小 load_size_ = phdr_table_get_load_size(phdr_table_, phdr_num_, &min_vaddr); // min_vaddr 一般情況為零，如果不是則表明 SO 指定了加載基址 uint8_t* addr = reinterpret_cast(min_vaddr); void* start; int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS; start = mmap(addr, load_size_, PROT_NONE, mmap_flags, -1, 0); load_start_ = start; load_bias_ = reinterpret_cast(start) - addr; return true;}

首先調用 phdr_table_get_load_size 函數獲取 SO 在內存中需要的空間load_size，然后使用 mmap 匿名映射，預留出相應的空間。

關于loadbias: SO 可以指定加載基址，但是 SO 指定的加載基址可能不是頁對齊的，這種情況會導致實際映射地址和指定的加載地址有一個偏差，這個偏差便是 load_bias_，之后在針對虛擬地址進行計算時需要使用 load_bias_ 修正。普通的 SO 都不會指定加載基址，這時min_vaddr = 0，則 load_bias_ = load_start_，即load_bias_ 等于加載基址，下文會將load_bias_ 直接稱為基址。

下面深入phdr_table_get_load_size分析一下 load_size 的計算:使用成員變量 phdr_table 遍歷所有的program header，找到所有類型為 PT_LOAD 的 segment 的 p_vaddr 的最小值，p_vaddr + p_memsz 的最大值，分別作為 min_vaddr 和 max_vaddr，在將兩個值分別對齊到頁首和頁尾，最終使用對齊后的 max_vaddr - min_vaddr 得到 load_size。

size_t phdr_table_get_load_size(const ElfW(Phdr)* phdr_table, size_t phdr_count, ElfW(Addr)* out_min_vaddr, ElfW(Addr)* out_max_vaddr) { ElfW(Addr) min_vaddr = UINTPTR_MAX; ElfW(Addr) max_vaddr = 0; bool found_pt_load = false; for (size_t i = 0; i const ElfW(Phdr)* phdr = &phdr_table[i]; if (phdr->p_type != PT_LOAD) { continue; } found_pt_load = true; if (phdr->p_vaddr min_vaddr = phdr->p_vaddr; // 記錄最小的虛擬地址 } if (phdr->p_vaddr + phdr->p_memsz > max_vaddr) { max_vaddr = phdr->p_vaddr + phdr->p_memsz; // 記錄最大的虛擬地址 } } if (!found_pt_load) { min_vaddr = 0; } min_vaddr = PAGE_START(min_vaddr); // 頁對齊 max_vaddr = PAGE_END(max_vaddr); // 頁對齊 if (out_min_vaddr != NULL) { *out_min_vaddr = min_vaddr; } if (out_max_vaddr != NULL) { *out_max_vaddr = max_vaddr; } return max_vaddr - min_vaddr; // load_size = max_vaddr - min_vaddr}

2.2.4 Load Segments

遍歷 program header table，找到類型為 PT_LOAD 的 segment:

計算 segment 在內存空間中的起始地址 segstart 和結束地址 seg_end，seg_start 等于虛擬偏移加上基址load_bias，同時由于 mmap 的要求，都要對齊到頁邊界得到 seg_page_start 和 seg_page_end。

計算 segment 在文件中的頁對齊后的起始地址 file_page_start 和長度 file_length。

使用 mmap 將 segment 映射到內存，指定映射地址為 seg_page_start，長度為 file_length，文件偏移為 file_page_start。

bool ElfReader::LoadSegments() { for (size_t i = 0; i const ElfW(Phdr)* phdr = &phdr_table_[i]; if (phdr->p_type != PT_LOAD) { continue; } // Segment 在內存中的地址. ElfW(Addr) seg_start = phdr->p_vaddr + load_bias_; ElfW(Addr) seg_end = seg_start + phdr->p_memsz; ElfW(Addr) seg_page_start = PAGE_START(seg_start); ElfW(Addr) seg_page_end = PAGE_END(seg_end); ElfW(Addr) seg_file_end = seg_start + phdr->p_filesz; // 文件偏移 ElfW(Addr) file_start = phdr->p_offset; ElfW(Addr) file_end = file_start + phdr->p_filesz; ElfW(Addr) file_page_start = PAGE_START(file_start); ElfW(Addr) file_length = file_end - file_page_start; if (file_length != 0) { // 將文件中的 segment 映射到內存 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); } // 如果 segment 可寫, 并且沒有在頁邊界結束，那么就將 segemnt end 到頁邊界的內存清零。 if ((phdr->p_flags & PF_W) != 0 && PAGE_OFFSET(seg_file_end) > 0) { memset(reinterpret_cast(seg_file_end), 0, PAGE_SIZE - PAGE_OFFSET(seg_file_end)); } seg_file_end = PAGE_END(seg_file_end); // 將 (內存長度 - 文件長度) 對應的內存進行匿名映射 if (seg_page_end > seg_file_end) { void* zeromap = mmap(reinterpret_cast(seg_file_end), seg_page_end - seg_file_end, PFLAGS_TO_PROT(phdr->p_flags), MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); } } return true;}

2.3 分配 soinfo

load_library 在調用 load_segments 完成裝載后，接著調用 soinfo_alloc 函數為目標SO分配soinfo，soinfo_alloc 函數實現如下:

static soinfo* soinfo_alloc(const char* name, struct stat* file_stat) { soinfo* si = g_soinfo_allocator.alloc(); //分配空間，可以簡單理解為 malloc // Initialize the new element. memset(si, 0, sizeof(soinfo)); strlcpy(si->name, name, sizeof(si->name)); si->flags = FLAG_NEW_SOINFO; sonext->next = si; // 加入到存有所有 soinfo 的鏈表中 sonext = si; return si;}

Linker 為每個 SO 維護了一個soinfo結構，調用 dlopen時，返回的句柄其實就是一個指向該 SO 的 soinfo 指針。soinfo 保存了 SO 加載鏈接以及運行期間所需的各類信息，簡單列舉一下:

裝載鏈接期間主要使用的成員:

裝載信息

const ElfW(Phdr)* phdr;

size_t phnum;

ElfW(Addr) base;

size_t size;

符號信息

const char* strtab;

ElfW(Sym)* symtab;

重定位信息

ElfW(Rel)* plt_rel;

size_t plt_rel_count;

ElfW(Rel)* rel;

size_t rel_count;

init 函數和 finit 函數

Linker_function_t* init_array;

size_t init_array_count;

Linker_function_t* fini_array;

size_t fini_array_count;

Linker_function_t init_func;

Linker_function_t fini_func;

運行期間主要使用的成員:

導出符號查找(dlsym):

const char* strtab;

ElfW(Sym)* symtab;

size_t nbucket;

size_t nchain;

unsigned* bucket;

unsigned* chain;

ElfW(Addr) load_bias;

異常處理:

unsigned* ARM_exidx;

size_t ARM_exidx_count;

load_library 在為 SO 分配 soinfo 后，會將裝載結果更新到 soinfo 中，后面的鏈接過程就可以直接使用soinfo的相關字段去訪問 SO 中的信息。

... si->base = elf_reader.load_start(); si->size = elf_reader.load_size(); si->load_bias = elf_reader.load_bias(); si->phnum = elf_reader.phdr_count(); si->phdr = elf_reader.loaded_phdr(); ...

看文倉www.kanwencang.com網友整理上傳,為您提供最全的知識大全,期待您的分享，轉載請注明出處。
歡迎轉載：http://www.kanwencang.com/bangong/20170220/104370.html

文章列表