AndroidLinker與SO加殼技術之下篇

時間  2019-11-09
標籤 androidlinker 技術 下篇 简体版
原文   原文鏈接

主頁內可搜索查看《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。
修復過程以下：

  1. 獲取 Linker 維護的 soinfo，能夠經過 dlopen 打開本身來得到：self_soinfo = dlopen(self)。

  2. 將 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>>（騰訊御安全）

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程