BruceFan's Blog

Stay hungry, stay foolish

0%

Android Linker（一）

发表于 Edited on

目前Android应用加固可以分为dex加固和Native加固，Native加固的保护对象为Native层的so文件，使用加壳、反调试、混淆、VM等手段增加so文件的反编译难度。目前最主流的so文件保护方案还是加壳技术， 在so文件加壳和脱壳的攻防技术领域，最重要的基础的便是对于Linker即装载链接机制的理解。本文分析了so文件的装载和链接过程，也就是在调用dlopen(“libxx.so”)之后，Linker的处理过程，还对so加壳的关键技术进行了简要介绍。
本文基于Android5.0 AOSP源码，仅针对ARM平台。

so装载

整体流程说明

Java层调用so中的native函数都会有一个调用语句：

1
2
3
Static {
  System.loadLibrary("name");
}

从这条语句开始的调用流程如下：

1
2
3
4
5
6
7
/libcore/luni/src/main/java/java/lang/System.java:loadLibrary()
/libcore/luni/src/main/java/java/lang/Runtime.java:loadLibrary()
/libcore/luni/src/main/java/java/lang/Runtime.java:doLoad()
/libcore/luni/src/main/java/java/lang/Runtime.java:nativeLoad()
/dalvik/vm/native/java_lang_Runtime.cpp:Dalvik_java_lang_Runtime_nativeLoad()
/dalvik/vm/Native.cpp:dvmLoadNativeCode()
/bionic/linker/dlfcn.cpp:dlopen()

整个流程是通过查看Android源码，进行交叉引用，代码跟踪找到的。至此开始正式的分析。

do_dlopen

调用dlopen后，中间经过dlopen_ext, 到达第一个主要函数do_dlopen:

1
2
3
4
5
6
7
8
9
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的装载链接后，通过 CallConstructors调用so的初始化函数。

find_library_internal

find_library直接调用了find_library_internal，下面直接看find_library_internal函数： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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函数。

load_library

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
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的装载和链接过程。

装载

在load_library中，首先初始化elf_reader对象，第一个参数为so的名字，第二个参数为文件描述符fd，之后调用ElfReader的Load方法装载so。 

1
2
3
4
5
6
ElfReader elf_reader(name, fd)
...
// Read the ELF header and load the segments.
if (!elf_reader.Load(extinfo)) {
  return NULL;
}

ElfReader::Load方法如下: 

1
2
3
4
5
6
7
8
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的这几个成员函数进行详细介绍。

read & verify elfheader

1
2
3
4
5
6
7
8
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…

有任何错误都会导致加载失败。

Read ProgramHeader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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。

reserve space & 计算load size

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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。 

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
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
}

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。 

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
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;
}

分配 soinfo

load_library在调用load_segments完成装载后，接着调用soinfo_alloc函数为目标so分配soinfo，soinfo_alloc函数实现如下： 

1
2
3
4
5
6
7
8
9
10
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时，返回的handler其实就是一个指向该so的soinfo指针。soinfo保存了so加载链接以及运行期间所需的各类信息，简单列举一下:
装载链接期间主要使用的成员:

  • 装载信息
    1
    2
    3
    4
    const ElfW(Phdr)* phdr;
    size_t phnum;
    ElfW(Addr) base;
    size_t size;
  • 符号信息
    1
    2
    const char* strtab;
    ElfW(Sym)* symtab;
  • 重定位信息
    1
    2
    3
    4
    ElfW(Rel)* plt_rel;
    size_t plt_rel_count;
    ElfW(Rel)* rel;
    size_t rel_count;
  • init函数和finit函数
    1
    2
    3
    4
    5
    6
    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）
    1
    2
    3
    4
    5
    6
    7
    const char* strtab;
    ElfW(Sym)* symtab;
    size_t nbucket;
    size_t nchain;
    unsigned* bucket;
    unsigned* chain;
    ElfW(Addr) load_bias;
  • 异常处理
    1
    2
    unsigned* ARM_exidx;
    size_t ARM_exidx_count;

load_library在为so分配soinfo后，会将装载结果更新到soinfo中，后面的链接过程就可以直接使用soinfo的相关字段去访问so中的信息。 

1
2
3
4
5
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();

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