adbi(The Android Dynamic Binary Instrumentation Toolkit)是一个Android平台通用hook框架,基于动态库注入与inline hook技术实现。
该框架由两个主要模块构成,1.hijack负责将动态库注入到目标进程;2.libbase提供动态库本身,它实现了通用的hook功能。
而example则是一个使用adbi进行epoll_wait hook的demo。
[email protected]:~/Android/adbi-master$ tree
.
├── build.sh
├── clean.sh
├── hijack
│ ├── hijack.c
│ └── jni
│ └── Android.mk
├── instruments
│ ├── base
│ │ ├── base.c
│ │ ├── base.h
│ │ ├── hook.c
│ │ ├── hook.h
│ │ ├── jni
│ │ │ ├── Android.mk
│ │ │ └── Application.mk
│ │ ├── util.c
│ │ └── util.h
│ └── example
│ ├── epoll_arm.c
│ ├── epoll.c
│ └── jni
│ └── Android.mk
└── README.md
7 directories, 16 files
[email protected]:~/Android/adbi-master$
一、hijack
hijack实现进程注入功能,通过在目标进程插入dlopen()调用序列,加载指定SO动态库文件。要实现这个功能,主要做两件事情:1.获得目标进程中dlopen()地址;2.在目标进程的栈空间上构造一处dlopen()调用;下面分别解决这两个问题。
1.获得目标进程中dlopen()地址
在adbi中,通过下面代码来获得目标进程中dlopen()函数地址:
void *ldl = dlopen("libdl.so", RTLD_LAZY);
if (ldl) {
dlopenaddr = (unsigned long)dlsym(ldl, "dlopen");
dlclose(ldl);
}
unsigned long int lkaddr;
unsigned long int lkaddr2;
find_linker(getpid(), &lkaddr);
//printf("own linker: 0x%x\n", lkaddr);
//printf("offset %x\n", dlopenaddr - lkaddr);
find_linker(pid, &lkaddr2);
//printf("tgt linker: %x\n", lkaddr2);
//printf("tgt dlopen : %x\n", lkaddr2 + (dlopenaddr - lkaddr));
dlopenaddr = lkaddr2 + (dlopenaddr - lkaddr);
首先调用 void *ldl = dlopen(“libdl.so”, RTLD_LAZY); 返回动态库libdl.so地址,我们的目标函数dlopen()就在这个库中实现。但是libdl.so是动态加载的,在每个进程中地址并不固定。看一下adbi如何解决这个问题:
static int find_linker(pid_t pid, unsigned long *addr)
{
struct mm mm[1000];
unsigned long libcaddr;
int nmm;
char libc[256];
symtab_t s;
if (0 > load_memmap(pid, mm, &nmm)) {
printf("cannot read memory map\n");
return -1;
}
if (0 > find_linker_mem(libc, sizeof(libc), &libcaddr, mm, nmm)) {
printf("cannot find libc\n");
return -1;
}
*addr = libcaddr;
return 1;
}
主要调用了load_memmap和find_linker_mem两个函数。
首先分析load_memmap函数,这个函数分3个步骤:
static int load_memmap(pid_t pid, struct mm *mm, int *nmmp)
{
char raw[80000]; // increase this if needed for larger "maps"
char name[MAX_NAME_LEN];
char *p;
unsigned long start, end;
struct mm *m;
int nmm = 0;
int fd, rv;
int i;
sprintf(raw, "/proc/%d/maps", pid);
fd = open(raw, O_RDONLY);
if (0 > fd) {
//printf("Can‘t open %s for reading\n", raw);
return -1;
}
(1)首先通过/proc//maps读取目标进程的内存映射信息,其格式大致如下:
2a002000-2a003000 r–p 00001000 1f:00 933 /system/bin/app_process
2a003000-2a1df000 rw-p 2a003000 00:00 0 [heap]
40000000-4000f000 r-xp 00000000 1f:00 984 /system/bin/linker
接下来一行行读取文件内容并解析:
/* (2)读文件内容 */
/* Zero to ensure data is null terminated */
memset(raw, 0, sizeof(raw));
p = raw;
while (1) {
rv = read(fd, p, sizeof(raw)-(p-raw));
if (0 > rv) {
//perror("read");
return -1;
}
if (0 == rv)
break;
p += rv;
if (p-raw >= sizeof(raw)) {
//printf("Too many memory mapping\n");
return -1;
}
}
close(fd);
/* (3)解析之 */
p = strtok(raw, "\n");
m = mm;
while (p) {
/* parse current map line */
rv = sscanf(p, "%08lx-%08lx %*s %*s %*s %*s %s\n",
&start, &end, name); /* 分割每行内容 */
p = strtok(NULL, "\n");
if (rv == 2) {
m = &mm[nmm++];
m->start = start;
m->end = end;
strcpy(m->name, MEMORY_ONLY); /* 40012000-40014000 r–p 40012000 00:00 0为空的情况 */
continue;
}
/* search backward for other mapping with same name */
for (i = nmm-1; i >= 0; i--) {
m = &mm[i];
if (!strcmp(m->name, name))
break;
}
if (i >= 0) { /* 对名称相同行进行合并 */
if (start start)
m->start = start;
if (end > m->end)
m->end = end;
} else {
/* new entry */
m = &mm[nmm++];
m->start = start;
m->end = end;
strcpy(m->name, name); /* 取每行最后的名称段 */
}
}
*nmmp = nmm;
return 0;
}
继续看find_linker_mem()功能:
static int
find_linker_mem(char *name, int len, unsigned long *start,
struct mm *mm, int nmm)
{
int i;
struct mm *m;
char *p;
for (i = 0, m = mm; i
//printf("name = %s\n", m->name);
//printf("start = %x\n", m->start);
if (!strcmp(m->name, MEMORY_ONLY))
continue;
p = strrchr(m->name, ‘/‘);
if (!p)
continue;
p++;
if (strncmp("linker", p, 6))
continue;
break; // ‘libc.so‘ or ‘libc-[0-9]‘ */
if (!strncmp(".so", p, 3) || (p[0] == ‘-‘ && isdigit(p[1])))
break;
} /* 获取/system/bin/linker加载地址 */
if (i >= nmm)
/* not found */
return -1;
*start = m->start;
strncpy(name, m->name, len);
if (strlen(m->name) >= len)
name[len-1] = ‘\0‘;
return 0;
}
这段代码的作用是获取/system/bin/linker在目标进程的加载地址。
linker是android提供的动态链接器,被各进程间共用。dlopen()函数就是在linker里面定义,所以其内部的dlopen()函数相对于linker头的偏移量是固定的,这样计算其它进程内dlopen()函数的地址就非常简单了,先在本进程内计算出dlopen()相对于linker头的偏移量,再加上目标进程中linker的加载地址。
而linker的加载地址,就是上面通过/proc/>/maps读到的40000000-4000f000 r-xp 00000000 1f:00 984 /system/bin/linker开始地址。
2.在目标进程的栈空间上构造一处dlopen()调用
要修改目标进程寄存器等信息,需使用到ptrace()函数,gdb等程序拥有查看、修改调试进程寄存器等的能力就是因为使用了ptrace()。
首先将hijack attach到目标进程上去:
if (0 > ptrace(PTRACE_ATTACH, pid, 0, 0)) {
printf("cannot attach to %d, error!\n", pid);
exit(1);
}
waitpid(pid, NULL, 0);
这时目标进程暂停,就可以通过ptrace对其进行修改了,如获取寄存器值:
ptrace(PTRACE_GETREGS, pid, 0, ®s);
接下来要做的就是修改寄存器的值,在目标进程的栈空间上构造一处dlopen()调用,关键在于一个sc数组:
unsigned int sc[] = {
0xe59f0040, // ldr r0, [pc, #64] ; 48 <.text>
0xe3a01000, // mov r1, #0 ; 0x0
0xe1a0e00f, // mov lr, pc
0xe59ff038, // ldr pc, [pc, #56] ; 4c <.text>
0xe59fd02c, // ldr sp, [pc, #44] ; 44 <.text>
0xe59f0010, // ldr r0, [pc, #16] ; 30 <.text>
0xe59f1010, // ldr r1, [pc, #16] ; 34 <.text>
0xe59f2010, // ldr r2, [pc, #16] ; 38 <.text>
0xe59f3010, // ldr r3, [pc, #16] ; 3c <.text>
0xe59fe010, // ldr lr, [pc, #16] ; 40 <.text>
0xe59ff010, // ldr pc, [pc, #16] ; 44 <.text>
0xe1a00000, // nop r0
0xe1a00000, // nop r1
0xe1a00000, // nop r2
0xe1a00000, // nop r3
0xe1a00000, // nop lr
0xe1a00000, // nop pc
0xe1a00000, // nop sp
0xe1a00000, // nop addr of libname
0xe1a00000, // nop dlopenaddr
};
可以发现,这里使用了上文获取到的寄存器值,初始化了部分数组元素:
sc[11] = regs.ARM_r0;
sc[12] = regs.ARM_r1;
sc[13] = regs.ARM_r2;
sc[14] = regs.ARM_r3;
sc[15] = regs.ARM_lr;
sc[16] = regs.ARM_pc;
sc[17] = regs.ARM_sp;
sc[19] = dlopenaddr;
libaddr = regs.ARM_sp - n*4 - sizeof(sc);
sc[18] = libaddr;
上面代码数组内容,其实就是我们要写入到目标进程当前栈空间的指令即一份shellcode,通过一张图帮助我们理解:
来看一下,这段shellcode实现了什么样的功能。
1.首先指令从2处开始执行,ldr r0,[pc,#64] 将pc+64指向地址的内容存入r0寄存器,即图中libaddr(.so地址)项,对其取值则r0指向.SO库路径名字符串。(说明:对ARM指令集而言,PC总是指向当前指令的下两条指令的地址,即PC的值为当前指令的地址值加8个字节。所以[pc,#64]指向第(64+8)/4=18个元素处)
2.mov r1,#0 将0赋值给r1寄存器。
3.ldr pc,[pc,#56] 调用dlopen()函数,第一个入参为r0:so库路径名字符串,第二个参数为r1:0。
4.函数执行完后,通过设置PC回到1处继续执行,依次恢复pc/sp/r0/r1/r2/r3寄存器。
下面就可以将我们精心构造好的shellcode写入到目标进程栈空间上:
// write library name to stack
if (0 > write_mem(pid, (unsigned long*)arg, n, libaddr)) {
printf("cannot write library name (%s) to stack, error!\n", arg);
exit(1);
}
// write code to stack
codeaddr = regs.ARM_sp - sizeof(sc);
if (0 > write_mem(pid, (unsigned long*)&amp;sc, sizeof(sc)/sizeof(long), codeaddr)) {
printf("cannot write code, error!\n");
exit(1);
}
/* Write NLONG 4 byte words from BUF into PID starting
at address POS. Calling process must be attached to PID. */
static int
write_mem(pid_t pid, unsigned long *buf, int nlong, unsigned long pos)
{
unsigned long *p;
int i;
for (p = buf, i = 0; i
if (0 > ptrace(PTRACE_POKETEXT, pid, (void *)(pos+(i*4)), (void *)*p))
return -1;
return 0;
}
写入栈空间后,shellcode并不能执行,因为当前linux都开启了栈执行保护的功能。可以查看栈属性进行印证,没有x位:
beeaf000-beec4000 rw-p befeb000 00:00 0 [stack]
但我们可以通过mprotect()函数,来修改栈内存的可执行权限:
// calc stack pointer
regs.ARM_sp = regs.ARM_sp - n*4 - sizeof(sc);
// call mprotect() to make stack executable
regs.ARM_r0 = stack_start; // want to make stack executable
//printf("r0 %x\n", regs.ARM_r0);
regs.ARM_r1 = stack_end - stack_start; // stack size
//printf("mprotect(%x, %d, ALL)\n", regs.ARM_r0, regs.ARM_r1);
regs.ARM_r2 = PROT_READ|PROT_WRITE|PROT_EXEC; // protections
// normal mode, first call mprotect
if (nomprotect == 0) {
if (debug)
printf("calling mprotect\n");
regs.ARM_lr = codeaddr; // points to loading and fixing code
regs.ARM_pc = mprotectaddr; // execute mprotect()
}
// no need to execute mprotect on old Android versions
else {
regs.ARM_pc = codeaddr; // just execute the ‘shellcode‘
}
这段代码首先计算栈顶位置,接着将 栈起始地址/栈大小/权限位 3个参数压栈,然后调用mprotect()设置代码所在栈区的可执行权限,最后将lr寄存器设置为栈上代码的起始地址,这样当调用mprotect()函数返回后就可以正常执行栈上代码了。
最后,恢复目标进程的寄存器值,并恢复被ptrace()暂停的进程:
// detach and continue
ptrace(PTRACE_SETREGS, pid, 0, &amp;regs);
ptrace(PTRACE_DETACH, pid, 0, (void *)SIGCONT);
if (debug)
printf("library injection completed!\n");
到目前为止,我们已经能够在指定进程加载任意SO库了!