Android so 文件进阶<二> 从dlsym()源码看android 动态链接过程

0x00  前言

这篇文章其实是我之前学习elf文件关于符号表的学习笔记，网上也有很多关于符号表的文章，怎么说呢，感觉像是在翻译elf文件格式的文档一样，千篇一律，因此把自己的学习笔记分享出来。dlsym()的源码是分析的android4.4的源码，android自己实现的bonic C库。

0x01  基本流程

android中关于elf文件，关于so文件信息的结构体：

struct soinfo {
 public:
  char name[SOINFO_NAME_LEN];
  const Elf32_Phdr* phdr;
  size_t phnum;
  Elf32_Addr entry;
  Elf32_Addr base;
  unsigned size;

  uint32_t unused1;  // DO NOT USE, maintained for compatibility.

  Elf32_Dyn* dynamic;

  uint32_t unused2; // DO NOT USE, maintained for compatibility
  uint32_t unused3; // DO NOT USE, maintained for compatibility

  soinfo* next;
  unsigned flags;

  const char* strtab;
  Elf32_Sym* symtab;

  size_t nbucket;
  size_t nchain;
  unsigned* bucket;
  unsigned* chain;

  unsigned* plt_got;

  Elf32_Rel* plt_rel;
  size_t plt_rel_count;

  Elf32_Rel* rel;
  size_t rel_count;

  linker_function_t* preinit_array;
  size_t preinit_array_count;

  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;

#if defined(ANDROID_ARM_LINKER)
  // ARM EABI section used for stack unwinding.
  unsigned* ARM_exidx;
  size_t ARM_exidx_count;
#elif defined(ANDROID_MIPS_LINKER)
  unsigned mips_symtabno;
  unsigned mips_local_gotno;
  unsigned mips_gotsym;
#endif

  size_t ref_count;
  link_map_t link_map;

  bool constructors_called;

  // When you read a virtual address from the ELF file, add this
  // value to get the corresponding address in the process' address space.
  Elf32_Addr load_bias;

  bool has_text_relocations;
  bool has_DT_SYMBOLIC;

  void CallConstructors();
  void CallDestructors();
  void CallPreInitConstructors();

 private:
  void CallArray(const char* array_name, linker_function_t* functions, size_t count, bool reverse);
  void CallFunction(const char* function_name, linker_function_t function);
};

soinfo

然后就是我们关心的dlsym()函数，

void*dlsym(void*handle,constchar*symbol)

dlsym()的实现对于handle是分三种情况

(1)  handle = RTLD_DEFAULT；

(2)  handle = RTLD_NEXT；

(3) 其他，也就是我们平常调用dlopen()的返回值。

0x02  RTLD_DEFAFULT

  soinfo* found = NULL;
  Elf32_Sym* sym = NULL;
  if (handle == RTLD_DEFAULT) {
    sym = dlsym_linear_lookup(symbol, &found, NULL);
  }

///bonic/linker/Linker.cpp
Elf32_Sym* dlsym_linear_lookup(const char* name, soinfo** found, soinfo* start) {
  unsigned elf_hash = elfhash(name);   //计算符号名称的hash值
  if (start == NULL) {
//static soinfo* solist = &libdl_info;   libdl_info是soinfo类型的全局变量包含libdl.so的信息
    start = solist;
  }

接下来就开始循环调用soinfo_elf_lookup() 遍历soinfo的链表

  Elf32_Sym* s = NULL;
  for (soinfo* si = start; (s == NULL) && (si != NULL); si = si->next) {
    s = soinfo_elf_lookup(si, elf_hash, name);
    if (s != NULL) {
      *found = si;
      break;
    }
  }

soinfo_elf_lookup()函数的源码：

// /bonic/linker/Linker.cpp
//soinfo_elf_lookup()在指定模块查找指定的符号项
static Elf32_Sym* soinfo_elf_lookup(soinfo* si, unsigned hash, const char* name) {
    Elf32_Sym* symtab = si->symtab;  //这里实际上是.dynsym 不要被名字误导
    const char* strtab = si->strtab;   //这里实际上是.dynstr
    TRACE_TYPE(LOOKUP, "SEARCH %s in %s@0x%08x %08x %d",
               name, si->name, si->base, hash, hash % si->nbucket);

    for (unsigned n = si->bucket[hash % si->nbucket]; n != ; n = si->chain[n]) {
        Elf32_Sym* s = symtab + n;
        if (strcmp(strtab + s->st_name, name)) continue;

            /* only concern ourselves with global and weak symbol definitions */
        switch(ELF32_ST_BIND(s->st_info)){
        case STB_GLOBAL:
        case STB_WEAK:
            if (s->st_shndx == SHN_UNDEF) {
                continue;
            }

            TRACE_TYPE(LOOKUP, "FOUND %s in %s (%08x) %d",
                       name, si->name, s->st_value, s->st_size);
            return s;
        }
    }

    return NULL;
}
  if (s != NULL) {
    TRACE_TYPE(LOOKUP, "%s s->st_value = 0x%08x, found->base = 0x%08x",
               name, s->st_value, (*found)->base);
  }

  return s;
}

需要说明的两点：

1. symtab 和strtab

Elf32_Sym* symtab = si->symtab;

const char* strtab = si->strtab;

这两句代码，可以跟入dlopen()的源码看到soinfo_link_image()函数中对si->symtab和si->strtab的赋值，这里只截取部分代码：

  for (Elf32_Dyn* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
    switch(d->d_tag){
        case DT_HASH:
            si->nbucket = ((unsigned *) (base + d->d_un.d_ptr))[];
            si->nchain = ((unsigned *) (base + d->d_un.d_ptr))[];
            si->bucket = (unsigned *) (base + d->d_un.d_ptr + );
            si->chain = (unsigned *) (base + d->d_un.d_ptr +  + si->nbucket * );
            break;
        case DT_STRTAB:  //.dynsym
            si->strtab = (const char *) (base + d->d_un.d_ptr);
            break;
        case DT_SYMTAB: //.dynstr
            si->symtab = (Elf32_Sym *) (base + d->d_un.d_ptr);
            break;
    }
}

可以看到strtab和symtab实际是.dynsym 和.dynstr。

可以看到循环条件中的si->dynamic，.dynamic section 保存了动态链接需要的基本信息，比如依赖哪些共享对象，动态链接符号表(.dynsym)的位置，动态链接重定位表(.rel.dyn)的位置，共享对象初始化代码的地址等等。.dynamic section可以看成动态链接下的类似的ELF“文件头”。

typedef struct {
         Elf32_Word        d_tag;      /* entry tag value */
         union {
             Elf32_Addr    d_ptr;
             Elf32_Word    d_val;
         } d_un;
} Elf32_Dyn;

typedef struct {
         Elf64_Xword       d_tag;      /* entry tag value */
         union {
            Elf64_Addr     d_ptr;
            Elf64_Xword    d_val;
         } d_un;
} Elf64_Dyn;

d_un联合体的取值很据d_tag来定，这里列举常用的一些：

d_tag	d_un	作用
DT_SYMTAB	d_ptr   .dynsym section addr	确定.dynsym section
DT_STRTAB	d_ptr   .dynstr section addr	确定 .dynstr
DT_STRSZ	d_val   .dynstr section size (byte)
DT_REL	d_ptr   .rel.dyn addr	确定.rel.dyn
DT_RELSZ	d_val   .rel.dyn size (byte)
DT_JMPREL	d_ptr   .rel.plt  addr	确定.rel.plt
DT_PLTRELSZ	d_val   .rel.plt  size (byte)
DT_INIT_ARRAY	d_ptr   .init_array  addr	确定 .init_array
DT_INIT_ARRAYSZ	d_val   .init_arrary size (byte)
DT_FINT_ARRAY	d_ptr   .fint_array  addr	确定.finit_array
DT_FINT_ARRAYSZ	d_val   .fint_array size (byte)

2. 迭代的条件

for (unsigned n = si->bucket[hash % si->nbucket]; n != 0; n = si->chain[n])

迭代的条件根据符号表(这里就是.dynsym)中Elf32_Sym的存储结构来的

举个很简单的例子来理解这个结构：

一个由函数名hash获得的值为X，那么bucket[X%nbucket]将给出一个索引Y，即是符号表项的索引也是chain表的索引，如果根据Y得到符号表项不满足条件，chain[Y]将给出下一个符号表项(同样的哈希变量)，可以一直沿着“chain链”直到选择到期望名字的符号表项。

android 源码下的elfhash函数/bonic/linker/Linker.cpp

static unsigned elfhash(const char* _name) {
    const unsigned char* name = (const unsigned char*) _name;
    unsigned h = , g;
    while(*name) {
        h = (h << ) + *name++;
        g = h & 0xf0000000;
        h ^= g;
        h ^= g >> ;
    }
    return h;
}

0x03   RTLD_NEXT

else if (handle == RTLD_NEXT) {
    void* ret_addr = __builtin_return_address();
    soinfo* si = find_containing_library(ret_addr);
    sym = NULL;
    if (si && si->next) {
      sym = dlsym_linear_lookup(symbol, &found, si->next);
    }
  } 

__builtin_return_address(0)是什么？

它其实是一个gcc的内置函数，用于帮助获取给定函数的调用地址，此处即是要获取dlsym()函数的调用地址。

__builtin_return_address()接收一个称为level的参数。这个参数定义希望获取返回地址的调用堆栈级别。例如，如果指定level为0，那么就是请求当前函数的返回地址。如果指定level为1，那么就是请求调用了当前函数的函数的返回地址，以此类推。

接下来的find_containing_library()

soinfo* find_containing_library(const void* p) {
  Elf32_Addr address = reinterpret_cast<Elf32_Addr>(p);  //类型转换
  for (soinfo* si = solist; si != NULL; si = si->next) {
    if (address >= si->base && address - si->base < si->size) {
      return si;
    }
  }
  return NULL;
}

//static soinfo* solist = &libdl_info;

这里的solist是不是很熟悉，就是之前在dym_linear_lookup()也使用soinfo结构的链表。

很明显find_containing_library()就是获得调用dlsym()函数的模块信息soinfo。

接下来也同样是调用dlsym_linear_lookup()函数，与RTLD_DEAFULT不同的是start参数的不同，从指定的soinfo开始查询，也就是dlsym()的调用模块。

0x04  dlopen()

else {
    found = reinterpret_cast<soinfo*>(handle);  //类型转换
    sym = dlsym_handle_lookup(found, symbol);
  }

很明显dlopen()返回值其实就是指定模块对应的信息soinfo结构体的地址。

Elf32_Sym* dlsym_handle_lookup(soinfo* si, const char* name)
{
    return soinfo_elf_lookup(si, elfhash(name), name);
}

在dlsym_handle_lookup()也知道简单的封装，只是调用了一次soinfo_elf_lookup()来查找指定的符号项。而soinfo_elf_lookup()的具体实现之前已经讨论了。

0x05  剩下的部分

 if (sym != NULL) {
    unsigned bind = ELF32_ST_BIND(sym->st_info);
    //是全局符号，并且不是section索引不是SHN_UNDEF(如果是SHN_UNDEF)说明这个
    //符号的定义并不在本文件中)
    if (bind == STB_GLOBAL && sym->st_shndx != ) {
      unsigned ret = sym->st_value + found->load_bias;
    //load_bias :.so文件加载的虚拟基地址
      return (void*) ret;
    }

    __bionic_format_dlerror("symbol found but not global", symbol);
    return NULL;
  } else {
    __bionic_format_dlerror("undefined symbol", symbol);
    return NULL;
  }
}

#define SHN_UNDEF        0                /* Undefined section */
#define ELF_ST_BIND(info)               ((uint32_t)(info) >> 4)
#define ELF32_ST_BIND(info)           ELF_ST_BIND(info)

剩下的代码需要了解Elf32_Sym结构体各个字段的含义

typedef struct {
    Elf32_Word    st_name;    /* Symbol name (.strtab index) */
    Elf32_Word    st_value;    /* value of symbol */
    Elf32_Word    st_size;    /* size of symbol */
    Elf_Byte      st_info;    /* type / binding attrs */
    Elf_Byte      st_other;    /* unused */
    Elf32_Half    st_shndx;    /* section index of symbol */
} Elf32_Sym;

st_name:

符号的名字,但它并不是一个字符串,而是字符串表(.strtab或者.dynstr)中的一个索引值,在字符串表中该索引值的位置上存放的字符串就是该符号名字的实际文本。如果此值不为0,则它就代表符号名字在字符串表中的索引值;如果此值为0,则表示此符号没有名字。

st_value:

符号的值;这个字段的值没有固定的类型,它可能代表一个数值,也可能是一个地址,具体要依据上下文来确定;

• 在可重定位文件中，st_value 包含节索引为 SHN_COMMON 的符号的对齐约束。

• 在可重定位文件中，st_value 包含所定义符号的节偏移。st_value 表示从 st_shndx 所标识的节的起始位置的偏移。

• 在可执行文件和共享目标文件中，st_value 包含虚拟地址。为使这些文件的符号更适用于运行时链接程序，节偏移（文件解释）会替换为与节编号无关的虚拟地址（内存解释）。(根据源码，显然在android的bonic中这里的虚拟地址是指相对于加载基地址的偏移)。

例如：一个可执行文件中含有一个函数的引用,而这个函数被定义在一个共享目标文件中,那么在可执行文件中,针对那个共享目标文件的符号表中就应该含有这个函数的符号;符号表的st_shndx字段的值为SHN_UNDEF,这就告诉动态链接器,这个函数的符号定义并不在可执行文件中;如果已经在可执行文件中给这个符号申请了一个函数连接表项,而且符号表项的st_value字段的值不是0,那么st_value字段的值就将是函数连接表项中第一条指令的地址;否则,st_value字段的值就是0;这个函数连接表项的地址被动态链接器用来解析函数地址;

st_size:

符号的大小;各种符号的大小各不相同,比如一个对象的大小就是它实际占用的字节数;如果一个符号的大小为0,或者大小未知,则这个值为0;

0x06  小结

android 下打包进apk的so文件不存在.symtab和.strtab section ，dlsym()函数所做的就是解析so文件的.dynamic 通过符号表来获得函数的地址。而Windows下的应用层用GetProcAddress()获得动态链接库(dll)获得导出函数地址，内核层用MmGetSystemRoutinAddr()获的ntoskrnl.exe的导出表中的地址。Windows下的与elf不同，Windwos是通过PE文件的导出表获得函数地址。这里给出《0day》里面关于自己实现GetProcAddress()功能的汇编代码。

#include <IOSTREAM>
#include <WINDOWS.H>
using namespace std;

//GetProcAddress() 的汇编层实现

//MessageBoxA    GetHash--->0x1e380a6a
//ExitProcess    GetHash--->0x4fd18963
//LoadLibraryA   GetHash--->0x0c917432

DWORD GetHash(char *pFuncName)
{
    DWORD digest = ;
    while(*pFuncName)
    {
        digest = ((digest<<)|digest>>);
        digest += *pFuncName;
        pFuncName++;
    }

    return digest;
}

//在将hash压入栈中之前，注意先将增量标志位DF清零，
//当shellcode 是利用异常处理机制植入的时候，
//往往产生标志位的变化，使shellcode中的字符处理方向发生变化而发生错误

void Func()
{

    _asm{

    //    ;find base addr of kernel32.dll
        mov ebx , fs:[edx+0x30]  //ebx = addr of PEB
        mov ecx , [ebx+0x0c]     //Ldr

// typedef struct _PEB_LDR_DATA32
// {
//         ULONG Length;                                +0x00
//         BOOLEAN Initialized;                        +0x04
//         HANDLE SsHandle;                            +0x08
//         LIST_ENTRY InLoadOrderModuleList;            +0x0c        //按模块的加载顺序
//         LIST_ENTRY InMemoryOrderModuleList;            +0x14        //按模块在内存中的地址顺序
//         LIST_ENTRY InInitializationOrderModuleList;    +0x1c        //按初始化顺序
//         PVOID EntryInProgress;                        +0x24
// } PEB_LDR_DATA32, *PPEB_LDR_DATA32;
        mov ecx , [ecx+0x1c]         //ecx -->xxx.exe
        mov ebp , [ecx+0x08]         //ebp = addr of kernel32
    }
}

int main()
{

    _asm{
        CLD
        push 0x1e380a6a      //MessageBoxA
        push 0x4fd18963         //ExitProcess
        push 0x0c917432         //LoadLibraryA
        mov esi ,esp
        lea edi ,[esi-0x0c]

        //抬高栈顶
        xor ebx ,ebx
        sub esp ,0x04

        //?????
        //push a pointer to "user32" onto stack
        mov bx , 0x3233   //reset of ebx is null
        push ebx
        push 0x72657375
        push esp
        xor  edx , edx

        //find base addr of kernel32.dll
        mov ebx , fs:[edx+0x30]  //ebx = address of PEB
        mov ecx , [ebx+0x0c]     //ecx = pointer to loader data
        mov ecx , [ecx+0x1c]     //ecx = first entry in initialization order list
        mov ecx , [ecx]             //ecx = second entry in list (kernel32.dll)
        mov ebp , [ecx+0x08]     //ebp = base address of kernel32.dll

find_lib_function:
        lodsd                     //load next hash into al and increment esi
        cmp eax , 0x1e380a6a      //hash of MessageBoxA - trigger
                                  //LoadLibrary("user32")
        jne find_functions
        schg eax , ebp              //save current hash
        call [edi-0x08]              //LoadLibraryA
        xchg eax , ebp              //restore current hash, and update ebp
                                  //with base address of user32.dll

find_function:
        pushed                        //preserve registers
        mov eax , [ebp+0x3c]        //eax = start of PE header
        mov ecx , [ebp+eax+0x78]    //ecx = relative offset of export table
        add ecx , ebp                //ecx = absolute addr of export table
        mov ebx , [ecx+0x20]        //ebx = relative offset of name table
        add ebx , ebp                //ebx = absolute addr of name table
        xor edi , edi                //edi will count throght the function

next_function_loop:
        inc edi                        //increment function counter
        mov esi , [ebx+edi*]
        add esi , ebp
        cdq

hash_loop:
        movsx eax , byte ptr[esi]
        cmp al , ah
        jz compare_hsah
        ror edx ,
        add edx , eax
        inc esi
        jmp hash_loop

compare_hash:
        cmp edx , [esp+0x1c]

    }
    return ;
}

asm GetProcAddr()

dlsym()是通过解析符号来获得函数地址的，可以考虑一下，在写native代码时，函数声明加 extern"C" 和不加extern "C"通过dlsym()获得地址有什么不同？dlsym()什么时候会失败？

Windows下开发dll程序时，加extern"C" 和__delspec(dllexport) 有什么用？如果不加为什么GetProcAddress()会崩溃？