玩转Hook——Android权限管理功能探讨（二）

　　距离我上一篇研究ptrace的随笔http://www.cnblogs.com/zealotrouge/p/3544147.html已经过去半年了，最近不忙的时候抽空继续研究了下。同样，参考了Pradeep Padala的博文http://www.linuxjournal.com/article/6210，对其中断点部分比较感兴趣。因为从开始学习编程之日起，调试就是我们不可或缺的重要工具，而调试的基础就在于断点，那么，断点是如何让一个运行中的程序暂停的呢？背后的机制又是什么？为了探寻这个问题，我研究了上面的文章，并在自己的机器上（环境为Ubuntu12.04 + Intel x86_64 i5）动手实现了一下x64版本。

　　下面是整个问题研究的思路，按这个思路来给大家展示代码。首先，我们有一个简单的源程序tracedProcess.c，简单到仅仅是每隔1s输出一行"I'm running"，这种简单的程序比较适合初学者分析汇编代码的语义，并找到容易设置断点的地方：

/*
  tracedProcess.c
  author: pengyiming
*/

#include <stdio.h>

void main()
{
  while(1)
  {
    printf("I'm running
");

    sleep(1);
  }
}

　　gcc编译如上代码：

gcc -o tracedProcess.o tracedProcess.c

　　objdump分析目标文件tracedProcess.o，得到如下输出（截取main部分）：

objdump -d tracedProcess.o

0000000000400544 <main>:
  400544:    55                       push   %rbp
  400545:    48 89 e5                 mov    %rsp,%rbp
  400548:    bf 5c 06 40 00           mov    $0x40065c,%edi
  40054d:    e8 de fe ff ff           callq  400430 <puts@plt>
  400552:    bf 01 00 00 00           mov    $0x1,%edi
  400557:    b8 00 00 00 00           mov    $0x0,%eax
  40055c:    e8 ef fe ff ff           callq  400450 <sleep@plt>
  400561:    eb e5                    jmp    400548 <main+0x4>

　　简单分析下：

　　0x400544  这个虚地址是main函数的入口

　　0x400544~0x400547  是所有函数的默认动作，新建一个函数栈

　　0x400548~0x40054c  将0x40065c传给edi寄存器，edi是字符串操作寄存器，存储的是字符串地址，0x40065c是只读区地址，用后面的getData()函数可以打出来，发现就是"I'm running"这个字符串

　　0x40054d~0x400551  callq执行一个函数调用，0x400430是此函数的入口，不难看出就是printf()函数链接到此目标文件的地址

　　0x400552~0x400556  清空edi寄存器

      0x400557~0x40055b  printf()无返回值，无需传递返回值地址给eax

      0x40055c~0x400560  callq执行一个函数调用，sleep()

      0x400561  跳转到0x400548进入下一个循环

　　分析完后，可以分析出，如果想把断点加在printf("I'm running ");这条语句上，我们可以把0x400548作为断点。

　　合适打断点的地址找到后，我们就要想想如何让程序暂停，继续参考上一篇博客中提到的Intel处理器开发手册，发现可以使用Trap指令使程序暂停运行。具体是使用int 0x80进入内核态，然后调用Trap指令——int3，只要CPU执行了这个指令，即可让程序暂停并处于一直等待状态，所以我们需要用ptrace在tracedProcess.o运行时，操作CPU寄存器和注入int 0x80 int3指令，一旦程序执行完int3，即可断点成功；当然，在断点后，我们希望程序能恢复运行，我们还需要备份CPU寄存器和原来代码段中的指令，以便之后的恢复。

　　小结一下，断点+恢复需要两次注入来实现：

　　一、断点注入步骤

　　（1）PTRACE_ATTACH附着被注入进程（会暂停被注入进程），备份当前的寄存器值

　　（2）备份注入地址处指令

　　（3）替换注入地址处指令为Trap指令

　　（4）PTRACE_CONT使被注入进程继续执行，直到执行完Trap指令

　　二、恢复注入步骤

　　（1）恢复之前的寄存器值（注：为了方便，所有的寄存器都备份了，实质上是为了恢复栈指针rsp&rbp和指令指针rip）

　　（2）恢复注入地址处指令

　　（3）PTRACE_DETACH使被注入进程继续执行，并脱离被注入进程

　　代码如下：

/*
  ptrace4.c
  author: pengyiming
  description:
  1, attach a test process, insert a break point
  2, sleep for 5s then continue it
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/reg.h>
#include <sys/user.h>
#include <sys/syscall.h>
#include <unistd.h>

#define WORD_SIZE sizeof(long)

static unsigned long injectAddress = 0x400548;

// converter long to char[]
union
{
  long rawData;
  char strData[WORD_SIZE];
} converter;

void getData(pid_t pid, unsigned long dataAddr, unsigned long dataLen, char * const p_data)
{
  // PEEKDATA counter
  int counter = 0;
  // PEEKDATA max count
  int maxCount = dataLen / WORD_SIZE;
  if (dataLen % WORD_SIZE != 0)
  {
    maxCount++;
  }
  // moving pointer
  void * p_moving = p_data;

  while (counter < maxCount)
  {
    memset(&converter, 0, WORD_SIZE);
    converter.rawData = ptrace(PTRACE_PEEKDATA, pid, dataAddr + counter * WORD_SIZE, NULL);

    memcpy(p_moving, converter.strData, WORD_SIZE);
    p_moving += WORD_SIZE;
    counter++;
  }
  p_data[dataLen] = '';
}

void setData(pid_t pid, unsigned long dataAddr, unsigned long dataLen, char * const p_data)
{
  // POKEDATA counter
  int counter = 0;
  // POKEDATA max count
  int maxCount = dataLen / WORD_SIZE;
  // data left length (prevent out of range in memory when written)
  int dataLeftLen = dataLen % WORD_SIZE;
  // moving pointer
  void * p_moving = p_data;

  // write part of data which align to WORD_SIZE
  int ret;
  while (counter < maxCount)
  {
    memset(&converter, 0, WORD_SIZE);
    memcpy(converter.strData, p_moving, WORD_SIZE);
    ret = ptrace(PTRACE_POKEDATA, pid, dataAddr + counter * WORD_SIZE, converter.rawData);

    p_moving += WORD_SIZE;
    counter++;
  }

  // write data left
  if (dataLeftLen != 0)
  {
    memset(&converter, 0, WORD_SIZE);
    memcpy(converter.strData, p_moving, dataLeftLen);
    ret = ptrace(PTRACE_POKEDATA, pid, dataAddr + counter * WORD_SIZE, converter.rawData);
  }
}

void debugRegs(char * pTag, pid_t pid)
{
    struct user_regs_struct regs;
  memset(&regs, 0, sizeof(struct user_regs_struct));
  ptrace(PTRACE_GETREGS, pid, NULL, &regs);

  printf("----%s -----
", pTag);
  printf("regs.cs = 0x%lx
", regs.cs);
  printf("regs.rip = 0x%lx
", regs.rip);
  printf("regs.rsp = 0x%lx
", regs.rsp);
  printf("regs.rbp = 0x%lx
", regs.rbp);

  printf("regs.rax = 0x%lx
", regs.rax);
  printf("regs.rbx = 0x%lx
", regs.rbx);
  printf("regs.rcx = 0x%lx
", regs.rcx);
  printf("regs.rdx = 0x%lx
", regs.rdx);
  printf("regs.rsi = 0x%lx
", regs.rsi);
  printf("regs.rdi = 0x%lx
", regs.rdi);
  printf("regs.orig_rax = 0x%lx
", regs.orig_rax);
  printf("regs.eflags = 0x%lx
", regs.eflags);
  printf("regs.ds = 0x%lx
", regs.ds);
  printf("regs.es = 0x%lx
", regs.es);
  printf("regs.fs = 0x%lx
", regs.fs);
  printf("regs.gs = 0x%lx
", regs.gs);
  printf("regs.fs_base = 0x%lx
", regs.fs_base);
  printf("regs.gs_base = 0x%lx
", regs.gs_base);
  printf("----%s -----
", pTag);
}

void debugInstructionByAddr(char * pTag, pid_t pid, unsigned long addr)
{
  char instruction[WORD_SIZE];
  memset(instruction, 0, WORD_SIZE);
  getData(pid, addr, WORD_SIZE, instruction);

  printf("0x%lx, %s instruction =", addr, pTag);
  int index;
  for (index = 0; index < WORD_SIZE; index++)
  {
    printf(" 0x%02x ", (unsigned char) instruction[index]);
  }
  printf("
");
}

int main()
{
  pid_t pid = 0;
  int waitStatus = -1;

  // enter the pid of the process you want attach
  printf("enter pid that you want attach : ");
  scanf("%d", &pid);

  int ret = ptrace(PTRACE_ATTACH, pid, NULL, NULL);
  if (ret == -1)
  {
    printf("attach error
");
    return 1;
  }
  printf("attach success
");

  // wait
  waitpid(pid, &waitStatus, 0);

  /* pause the process */
  // 1, backup the orignal regs
  struct user_regs_struct backupRegs;
  memset(&backupRegs, 0, sizeof(struct user_regs_struct));
  ptrace(PTRACE_GETREGS, pid, NULL, &backupRegs);
  // 2, backup the instruction
  char backupInstruction[WORD_SIZE];
  memset(backupInstruction, 0, WORD_SIZE);
  getData(pid, injectAddress, WORD_SIZE, backupInstruction);
    // 3, insert break instruction —— "int 0x80, int3"
  char breakInstruction[WORD_SIZE] = { 0xcd, 0x80, 0xcc, 0x0, 0x0, 0x0, 0x0, 0x0 };
  setData(pid, injectAddress, WORD_SIZE, breakInstruction);
  // 4, PTRACE_CONT for execute "int 0x80, int3" instruction
  ret = ptrace(PTRACE_CONT, pid, NULL, NULL);
  if (ret == -1)
  {
    printf("continue error
");
    return 1;
  }
  printf("continue success
");

  // wait
  waitpid(pid, &waitStatus, 0);
  /* pause the process */

  // wait for 5 seconds
  printf("the process is paused for 5s...
");
  sleep(5);

  /* continue the process */
  // 1, restore regs to the orignal address
  ptrace(PTRACE_SETREGS, pid, NULL, &backupRegs);
  // 2, restore instruction
  setData(pid, injectAddress, WORD_SIZE, backupInstruction);
  // 3, PTRACE_DETACH for execute the orignal code
  ret = ptrace(PTRACE_DETACH, pid, NULL, NULL);
  if (ret == -1)
  {
    printf("detach error
");
    return 1;
  }
  printf("detach success
");
  /* continue the process */

  return 0;
}

　　代码执行结果：被注入进程输出"I'm running"，ptrace4进程注入后，被注入进程暂停输出"I'm running"，5s后恢复。

　　最后说下调试过程中遇到的一个问题，在恢复被注入进程的运行时，总是会导致被注入进程segment fault，代码中加入了大量的debug函数用于分析问题，最后利用dmesg工具发现原因是恢复时写入注入地址指令有误，根本原因是之前认为breakInstruction只有3bytes，所以备份指令也只需要3bytes，于是便存储在char backupInstruction[3]中，而ptrace的读写单位都是word，在x64下是8bytes，所以在恢复时写入的指令为了3bytes的正确指令+5bytes的0x00空指令所致~