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 總體流程說明
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.1.2 find_library_internal
find_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 函數。

2.13 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步:
1裝載:建立ElfReader對象，經過 ElfReader 對象的 Load 方法將 SO 文件裝載到內存
2分配soinfo:調用 soinfo_alloc 函數爲 SO 分配新的 soinfo 結構，並按照裝載結果更新相應的成員變量
3連接: 調用 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、x8六、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<ElfW(Phdr)*>(reinterpret_cast<char*>(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<uint8_t*>(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<uint8_t*>(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 < phdr_count; ++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) {
      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 < phdr_num_; ++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<void*>(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<void*>(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<void*>(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();
...

(下篇將繼續更新) 

（騰訊御安全團隊）