【转】玩转ptrace(一)

关注

转载最新推荐文章于 2026-07-11 09:10:27 发布 568 阅读 AI 写同款· GEO 优化 ›

在Android使用上ptrace的尝试（一） Ptrace功能强大，可以用于调试跟踪。跑了蒸米大神写的例子，学习一下。实验1：获取system call的编号要ptrace的目标程序target，用来一直循环输出 #include int count = 0; void sevenWeapons(int number){ char* str = "hello!"; printf("%s, %d\n",str,n 阅读详情

原文：http://blog.youkuaiyun.com/silentvoid/archive/2007/01/08/1477439.aspx

by Pradeep Padala

Created 2002-11-01 02:00

翻译 : Magic.D E-mail: adamgic@163.com

译者序：在开发Hust Online Judge的过程中，查阅了不少资料，关于调试器技术的资料在网上是很少，即便是UNIX编程巨著《UNIX环境高级编程》中，相关内容也不多，直到我在http://www.linuxjournal.com上找到这篇文章，如获至宝，特翻译之，作为鄙人翻译技术文档的第一次尝试，必定会有不少蹩脚之处，各位就将就一下吧，欢迎大力拍砖。

你想过怎么实现对系统调用的拦截吗？你尝试过通过改变系统调用的参数来愚弄你的系统 kernel 吗？你想过调试器是如何使运行中的进程暂停并且控制它吗？

你可能会开始考虑怎么使用复杂的 kernel 编程来达到目的，那么，你错了。实际上 Linux 提供了一种优雅的机制来完成这些： ptrace 系统函数。 ptrace 提供了一种使父进程得以监视和控制其它进程的方式，它还能够改变子进程中的寄存器和内核映像，因而可以实现断点调试和系统调用的跟踪。

使用 ptrace ，你可以在用户层拦截和修改系统调用 (sys call)

在这篇文章中，我们将学习如何拦截一个系统调用，然后修改它的参数。在本文的第二部分我们将学习更先进的技术：设置断点，插入代码到一个正在运行的程序中；我们将潜入到机器内部，偷窥和纂改进程的寄存器和数据段。

基本知识

操作系统提供了一种标准的服务来让程序员实现对底层硬件和服务的控制（比如文件系统），叫做系统调用 (system calls) 。当一个程序需要作系统调用的时候，它将相关参数放进系统调用相关的寄存器，然后调用软中断 0x80 ，这个中断就像一个让程序得以接触到内核模式的窗口，程序将参数和系统调用号交给内核，内核来完成系统调用的执行。

在 i386 体系中 ( 本文中所有的代码都是面向 i386 体系 ) ，系统调用号将放入 %eax, 它的参数则依次放入 %ebx, %ecx, %edx, %esi 和 %edi 。比如，在以下的调用

Write(2, “Hello”, 5)

的汇编形式大概是这样的

movl $4, %eax

movl $2, %ebx

movl $hello, %ecx

movl $5, %edx

int $0x80

这里的 $hello 指向的是标准字符串 ”Hello” 。

那么， ptrace 会在什么时候出现呢？在执行系统调用之前，内核会先检查当前进程是否处于被“跟踪” (traced) 的状态。如果是的话，内核暂停当前进程并将控制权交给跟踪进程，使跟踪进程得以察看或者修改被跟踪进程的寄存器。

让我们来看一个例子，演示这个跟踪程序的过程

#include < sys / ptrace.h >

#include < sys / types.h >

#include < sys / wait.h >

#include < unistd.h >

#include < linux / user.h > /* For constants

ORIG_EAX etc */

int main()

{

pid_t child;

long orig_eax;

child = fork();

if (child == 0 ) {

ptrace(PTRACE_TRACEME, 0 , NULL, NULL);

execl( " /bin/ls " , " ls " , NULL);

}

else {

wait(NULL);

orig_eax = ptrace(PTRACE_PEEKUSER,

child, 4 * ORIG_EAX,

NULL);

printf( " The child made a "

" system call %ld " , orig_eax);

ptrace(PTRACE_CONT, child, NULL, NULL);

}

return 0 ;

}

运行这个程序，将会在输出 ls 命令的结果的同时，输出 :

The child made a system call 11

说明： 11 是 execve 的系统调用号，这是该程序调用的第一个系统调用。

想知道系统调用号的详细内容，察看 /usr/include/asm/unistd.h 。

在以上的示例中，父进程 fork 出了一个子进程，然后跟踪它。在调用 exec 函数之前，子进程用 PTRACE_TRACEME 作为第一个参数调用了 ptrace 函数，它告诉内核：让别人跟踪我吧！然后，在子进程调用了 execve() 之后，它将控制权交还给父进程。当时父进程正使用 wait() 函数来等待来自内核的通知，现在它得到了通知，于是它可以开始察看子进程都作了些什么，比如看看寄存器的值之类。

出现系统调用之后，内核会将 eax 中的值（此时存的是系统调用号）保存起来，我们可以使用 PTRACE_PEEKUSER 作为 ptrace 的第一个参数来读到这个值。

我们察看完系统调用的信息后，可以使用 PTRACE_CONT 作为 ptrace 的第一个参数，调用 ptrace 使子进程继续系统调用的过程。

ptrace 函数的参数

Ptrace 有四个参数

long ptrace(enum __ptrace_request request,

            


pid_t pid,

            


void *addr,

            


void *data);

第一个参数决定了 ptrace 的行为与其它参数的使用方法，可取的值有 :

PTRACE_ME

PTRACE_PEEKTEXT

PTRACE_PEEKDATA

PTRACE_PEEKUSER

PTRACE_POKETEXT

PTRACE_POKEDATA

PTRACE_POKEUSER

PTRACE_GETREGS

PTRACE_GETFPREGS,

PTRACE_SETREGS

PTRACE_SETFPREGS

PTRACE_CONT

PTRACE_SYSCALL,

PTRACE_SINGLESTEP

PTRACE_DETACH

在下文中将对这些常量的用法进行说明。

读取系统调用的参数

通过将 PTRACE_PEEKUSER 作为 ptrace 的第一个参数进行调用，可以取得与子进程相关的寄存器值。

先看下面这个例子

#include < sys / ptrace.h >

#include < sys / types.h >

#include < sys / wait.h >

#include < unistd.h >

#include < linux / user.h >

#include < sys / syscall.h > /* For SYS_write etc */

int main()

{

pid_t child;

long orig_eax, eax;

long params [ 3 ];

int status;

int insyscall = 0 ;

child = fork();

if (child == 0 ) {

ptrace(PTRACE_TRACEME, 0 , NULL, NULL);

execl( " /bin/ls " , " ls " , NULL);

}

else {

while ( 1 ) {

wait( & status);

if (WIFEXITED(status))

break ;

orig_eax = ptrace(PTRACE_PEEKUSER,

child, 4 * ORIG_EAX, NULL);

if (orig_eax == SYS_write) {

if (insyscall == 0 ) {

/* Syscall entry */

insyscall = 1 ;

params [ 0 ] = ptrace(PTRACE_PEEKUSER,

child, 4 * EBX,

NULL);

params [ 1 ] = ptrace(PTRACE_PEEKUSER,

child, 4 * ECX,

NULL);

params [ 2 ] = ptrace(PTRACE_PEEKUSER,

child, 4 * EDX,

NULL);

printf( " Write called with "

" %ld, %ld, %ld " ,

params [ 0 ], params [ 1 ],

params [ 2 ]);

}

else { /* Syscall exit */

eax = ptrace(PTRACE_PEEKUSER,

child, 4 * EAX, NULL);

printf( " Write returned "

" with %ld " , eax);

insyscall = 0 ;

}

ptrace(PTRACE_SYSCALL,

child, NULL, NULL);

}

return 0 ;

}

这个程序的输出是这样的

ppadala@linux:~/ptrace > ls

a.out        


dummy.s      


ptrace.txt

libgpm.html  


registers.c  


syscallparams.c

dummy        


ptrace.html  


simple.c

ppadala@linux:~/ptrace > ./a.out

Write called with 1, 1075154944, 48

a.out        


dummy.s      


ptrace.txt

Write returned with 48

Write called with 1, 1075154944, 59

libgpm.html  


registers.c  


syscallparams.c

Write returned with 59

Write called with 1, 1075154944, 30

dummy        


ptrace.html  


simple.c

Write returned with 30

以上的例子中我们跟踪了 write 系统调用，而 ls 命令的执行将产生三个 write 系统调用。使用 PTRACE_SYSCALL 作为 ptrace 的第一个参数，使内核在子进程做出系统调用或者准备退出的时候暂停它。这种行为与使用 PTRACE_CONT ，然后在下一个系统调用 / 进程退出时暂停它是等价的。

在前一个例子中，我们用 PTRACE_PEEKUSER 来察看 write 系统调用的参数。系统调用的返回值会被放入 %eax 。

wait 函数使用 status 变量来检查子进程是否已退出。它是用来判断子进程是被 ptrace 暂停掉还是已经运行结束并退出。有一组宏可以通过 status 的值来判断进程的状态，比如 WIFEXITED 等，详情可以察看 wait(2) man 。

读取寄存器的值

如果你想在系统调用或者进程终止的时候读取它的寄存器，使用前面那个例子的方法是可以的，但是这是笨拙的方法。使用 PRACE_GETREGS 作为 ptrace 的第一个参数来调用，可以只需一次函数调用就取得所有的相关寄存器值。

获得寄存器值得例子如下：

#include < sys / ptrace.h >

#include < sys / types.h >

#include < sys / wait.h >

#include < unistd.h >

#include < linux / user.h >

#include < sys / syscall.h >

int main()

{

pid_t child;

long orig_eax, eax;

long params [ 3 ];

int status;

int insyscall = 0 ;

struct user_regs_struct regs;

child = fork();

if (child == 0 ) {

ptrace(PTRACE_TRACEME, 0 , NULL, NULL);

execl( " /bin/ls " , " ls " , NULL);

}

else {

while ( 1 ) {

wait( & status);

if (WIFEXITED(status))

break ;

orig_eax = ptrace(PTRACE_PEEKUSER,

child, 4 * ORIG_EAX,

NULL);

if (orig_eax == SYS_write) {

if (insyscall == 0 ) {

/* Syscall entry */

insyscall = 1 ;

ptrace(PTRACE_GETREGS, child,

NULL, & regs);

printf( " Write called with "

" %ld, %ld, %ld " ,

regs.ebx, regs.ecx,

regs.edx);

}

else { /* Syscall exit */

eax = ptrace(PTRACE_PEEKUSER,

child, 4 * EAX,

NULL);

printf( " Write returned "

" with %ld " , eax);

insyscall = 0 ;

}

ptrace(PTRACE_SYSCALL, child,

NULL, NULL);

}

return 0 ;

}

这段代码与前面的例子是比较相似的，不同的是它使用了 PTRACE_GETREGS 。其中的 user_regs_struct 结构是在 <linux/user.h> 中定义的。

来点好玩的

现在该做点有意思的事情了，我们将要把传给 write 系统调用的字符串给反转。

#include < sys / ptrace.h >

#include < sys / types.h >

#include < sys / wait.h >

#include < unistd.h >

#include < linux / user.h >

#include < sys / syscall.h >

const int long_size = sizeof ( long );

void reverse( char * str)

{

int i, j;

char temp;

for (i = 0 , j = strlen(str) - 2 ;

i <= j; ++ i, -- j) {

temp = str[i];

str[i] = str[j];

str[j] = temp;

}

void getdata(pid_t child, long addr,

char * str, int len)

{

char * laddr;

int i, j;

union u {

long val;

char chars[long_size];

} data;

i = 0 ;

j = len / long_size;

laddr = str;

while (i < j) {

data.val = ptrace(PTRACE_PEEKDATA,

child, addr + i * 4 ,

NULL);

memcpy(laddr, data.chars, long_size);

++ i;

laddr += long_size;

}

j = len % long_size;

if (j != 0 ) {

data.val = ptrace(PTRACE_PEEKDATA,

child, addr + i * 4 ,

NULL);

memcpy(laddr, data.chars, j);

}

str[len] = ' ' ;

}

void putdata(pid_t child, long addr,

char * str, int len)

{

char * laddr;

int i, j;

union u {

long val;

char chars[long_size];

} data;

i = 0 ;

j = len / long_size;

laddr = str;

while (i < j) {

memcpy(data.chars, laddr, long_size);

ptrace(PTRACE_POKEDATA, child,

addr + i * 4 , data.val);

++ i;

laddr += long_size;

}

j = len % long_size;

if (j != 0 ) {

memcpy(data.chars, laddr, j);

ptrace(PTRACE_POKEDATA, child,

addr + i * 4 , data.val);

}

int main()

{

pid_t child;

child = fork();

if (child == 0 ) {

ptrace(PTRACE_TRACEME, 0 , NULL, NULL);

execl( " /bin/ls " , " ls " , NULL);

}

else {

long orig_eax;

long params [ 3 ];

int status;

char * str, * laddr;

int toggle = 0 ;

while ( 1 ) {

wait( & status);

if (WIFEXITED(status))

break ;

orig_eax = ptrace(PTRACE_PEEKUSER,

child, 4 * ORIG_EAX,

NULL);

if (orig_eax == SYS_write) {

if (toggle == 0 ) {

toggle = 1 ;

params [ 0 ] = ptrace(PTRACE_PEEKUSER,

child, 4 * EBX,

NULL);

params [ 1 ] = ptrace(PTRACE_PEEKUSER,

child, 4 * ECX,

NULL);

params [ 2 ] = ptrace(PTRACE_PEEKUSER,

child, 4 * EDX,

NULL);

str = ( char * )calloc(( params [ 2 ] + 1 )

* sizeof ( char ));

getdata(child, params [ 1 ], str,

params [ 2 ]);

reverse(str);

putdata(child, params [ 1 ], str,

params [ 2 ]);

}

else {

toggle = 0 ;

}

ptrace(PTRACE_SYSCALL, child, NULL, NULL);

}

return 0 ;

}

输出是这样的：

ppadala@linux:~/ptrace > ls

a.out        


dummy.s      


ptrace.txt

libgpm.html  


registers.c  


syscallparams.c

dummy        


ptrace.html  


simple.c

ppadala@linux:~/ptrace > ./a.out

txt.ecartp      


s.ymmud      


tuo.a

c.sretsiger     


lmth.mpgbil  


c.llacys_egnahc

c.elpmis        lmth.ecartp  ymmud

这个例子中涵盖了前面讨论过的所有知识点，当然还有些新的内容。这里我们用 PTRACE_POKEDATA 作为第一个参数，以此来改变子进程中的变量值。它以与 PTRACE_PEEKDATA 相似的方式工作，当然，它不只是偷窥变量的值了，它可以修改它们。

单步

ptrace 提供了对子进程进行单步的功能。 ptrace(PTRACE_SINGLESTEP, …) 会使内核在子进程的每一条指令执行前先将其阻塞，然后将控制权交给父进程。下面的例子可以查出子进程当前将要执行的指令。为了便于理解，我用汇编写了这个受控程序，而不是让你为 c 的库函数到底会作那些系统调用而头痛。

以下是被控程序的代码 dummy1.s ，使用 gcc –o dummy1 dummy1.s 来编译