玩转ptrace(一)

最新推荐文章于 2020-09-24 08:28:22 发布
最新推荐文章于 2020-09-24 08:28:22 发布
阅读量940 收藏 2
点赞数
分类专栏： Linux 文章标签： null struct constants linux 汇编 编程
玩转ptrace(一)

http://blog.chinaunix.net/u/19651/showart_362901.html

 

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来编译

 

. data
hello:
    . string "hello world/n"
. globl main
main:
    movl $4, %eax
    movl $2, %ebx
    movl $hello, %ecx
    movl $12, %edx
    int $0x80
    movl $1, %eax
    xorl %ebx , %ebx
    int $0x80
    ret

以下的程序则用来完成单步：

 

# 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;
     const int long_size = sizeof ( long ) ;
     child = fork( ) ;
      if ( child = = 0) {
         ptrace( PTRACE_TRACEME, 0, NULL , NULL ) ;
         execl( "./dummy1" , "dummy1" , NULL ) ;
     }
      else {
         int status;
          union u {
             long val;
             char chars[ long_size] ;
         } data;
         struct user_regs_struct regs;
         int start = 0;
         long ins;
          while ( 1) {
             wait( & status) ;
             if ( WIFEXITED( status) )
                 break ;
             ptrace( PTRACE_GETREGS,
                    child, NULL , & regs) ;
              if ( start = = 1) {
                 ins = ptrace( PTRACE_PEEKTEXT,
                              child, regs. eip,
                              NULL ) ;
                 printf ( "EIP: %lx Instruction "
                        "executed: %lx " ,
                        regs. eip, ins) ;
             }
              if ( regs. orig_eax = = SYS_write) {
                 start = 1;
                 ptrace( PTRACE_SINGLESTEP, child,
                        NULL , NULL ) ;
             }
             else
                 ptrace( PTRACE_SYSCALL, child,
                        NULL , NULL ) ;
         }
     }
     return 0;
 }

程序的输出是这样的：
你可能需要察看Intel的用户手册来了解这些指令代码的意思。
更复杂的单步，比如设置断点，则需要很仔细的设计和更复杂的代码才可以实现。
 
 
在第二部分，我们将会看到如何在程序中加入断点，以及将代码插入到已经在运行的程序中
carry1314lele
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
玩转ptrace(一) [转]
scancsdn的专栏
08-07 480
原文:http://blog.chinaunix.net/u/19651/showart_362901.html英文原文:http://www.linuxjournal.com/article/6100code：ftp.ssc.com/pub/lj/listings/issue103/6011.tgz-------------------------------------------------
ptrace使用和调试
&Ψ的博客
06-12 5092
1. 文章参考 [原创]一窥GDB原理-Pwn Linux ptrace系统调用详解：利用 ptrace 设置硬件断点 <<软件调试>> 张银奎 2. ptrace函数原型 enum __ptrace_request { PTRACE_TRACEME = 0, //被调试进程调用 PTRACE_PEEKDATA = 2, //查看内存 PTRACE_PEEKUSER = 3, //查看struct user 结构体的值 PTRACE_POKEDATA = 5, //
ptrace学习笔记（1）
anyaoyu9926的博客
02-25 101
参考博客http://blog.csdn.net/sealyao/article/details/6710772本人操作系统：ubuntu-14.04在执行系统调用之前，内核会先检查当前进程是否处于被“跟踪”(traced)的状态。如果是的话，内核暂停当前进程并将控制权交给跟踪进程，使跟踪进程得以察看或者修改被跟踪进程的寄存器。文中第一个例子，linux/user.h头文件找不到，替换成...
ptrace注入实例
01-01
在IT行业中，ptrace是一个非常重要的系统调用，主要用于进程调试和系统监控。它允许一个进程（tracer）观察和控制另一个进程（tracee），从而获取其执行细节或影响其行为。"ptrace注入"则是利用ptrace系统调用来实现...
ptrace防护.zip
12-28
在iOS系统中，ptrace是一个重要的系统调用，它允许一个进程（称为tracer）挂载、跟踪另一个进程（称为tracee）的系统调用和信号处理。ptrace被广泛用于调试、性能分析以及安全监控等领域。然而，由于其强大的功能，...
ptracer:一个用于基于ptrace的Python程序跟踪的库
05-10
ptracer-一个用于基于ptrace的Python程序跟踪的库 Ptracer是一个库，可在Python程序中提供按需系统调用跟踪。 基本用法 import traceback import ptracer def callback ( syscall ): print ( '{}({}) -> {}' . ...
ptrace的小demo
03-17
PTRACE函数代码分析
07-03
Ptrace是一个强大的系统调用，它允许父进程对子进程进行深入的监控和控制，特别是在调试场景中。这个功能强大的工具提供了多种请求类型，允许父进程查看和修改子进程的内存、寄存器以及控制执行流程。 Ptrace的工作...
ptrace的些许总结
helloworlddm的博客
08-06 1068
所有的操作系统都提供多种服务的入口点，由此程序向内核请求服务，各种版本的 unix 实 现都提供良好定义，数量有限，直接进入内核的入口点，这些入口点被称为系统调用。内核 的接口被称作系统调用。 实际上 Linux 提供了一种优雅的机制来完成这些：ptrace 系统函数。 ptrace 提供了一种使 父进程得以监视和控制其它进程的方式， 它还能够改变子进程中的寄存器和内核映像， 因而 可以
玩转ptrace（译文）
07-17 436
玩转ptrace（一）：http://blog.csdn.net/SilentVoid/article/details/1477439 玩转ptrace（二）：http://blog.csdn.net/silentvoid/article/details/1477515
调试器工作原理——基础篇
老程序员专栏
09-05 979
#include int main() { printf(“Hello, world!n”); return 0; } 本文是一系列探究调试器工作原理的文章的第一篇。我还不确定这个系列需要包括多少篇文章以及它们所涵盖的主题，但我打算从基础知识开始说起。 关于本文 我打算在这篇文章中介绍关于Linux下的调试器实现的主要组成部分——ptrace系统调用。本文中出现的代码都在
ptrace跟踪子进程
zuihoudebingwen的专栏
06-17 4769
引子: 1.在Linux系统中，进程状态除了我们所熟知的TASK_RUNNING，TASK_INTERRUPTIBLE，TASK_STOPPED等，还有一个TASK_TRACED。这表明这个进程处于什么状态？ 2.strace可以方便的帮助我们记录进程所执行的系统调用，它是如何跟踪到进程执行的？ 3.gdb是我们调试程序的利器，可以设置断点，单步跟踪程序。它的实现原理又是什么？ 所有这
ptrace系统调用的实现
imred的专栏
05-12 2672
最近遇到这样一个问题，机器跑着跑着画面冻结了，打开top看到Xorg的cpu占用率100%。想用gdb挂上去看一下，结果gdb一直卡着挂不上去。后来又换用perf分析，结果发现进程99%的时间花在了一个ioctl调用。这个ioctl操作的是nvidia显卡，进程实际上是卡在了nvidia的驱动中。 我对gdb挂不上去这件事感到很好奇，之前除了因为进程已经被另一个gdb调试而导致gdb挂不上去之外，...
玩转ptrace(一) [z](转帖真的很好)
zgl07的专栏
01-12 730
 玩转ptrace(一) [z]  by Pradeep Padala Created 2002-11-01 02:00翻译: Magic.D E-mail: adamgic@163.com译者序：在开发Hust Online Judge的过程中，查阅了不少资料，关于调试器技术的资料在网上是
Linux系统调用--ptrace函数详解
sourthstar的专栏
09-19 2604
http://hi.baidu.com/ordeder/item/77cf1cdc8ca93fe3795daab0 【ptrace系统调用】 功能描述： 提供父进程观察和控制另一个进程执行的机制，同时提供查询和修改另一进程的核心影像与寄存器的能力。主要用于执行断点调试和系统调用跟踪。父进程可通过调用fork，接着指定所产生的子进程的PTRACE_TRACEME行为
如何利用Ptrace拦截和模拟Linux系统调用
sunshineywz的博客
09-24 560
strace 在开始之前，我们先看一看strace的实现骨架。Ptrace一直都没有相应的使用标准，但在不同的操作系统中它的接口都是类似的，尤其是它的核心功能，但多多少少都会有一些细微的差别。Ptrace(2)的原型类似如下： long ptrace(int request, pid_t pid, void *addr, void *data); pid是tracee的进程ID，一个tracee一...
Linux 系统调用 Ptrace 详解
freeking101的博客
06-19 1633
From：https://blog.csdn.net/u012417380/article/details/60470075 一、系统调用 操作系统提供一系列系统调用函数来为应用程序提供服务。关于系统调用的详细相关知识，可以查看<<程序员的自我修养》第十二章。 对于x86操作系统来说，用中断命令“int 0x80”来进行系统调用，系统调用前，需要将系统调用号放入到%EAX寄存器中，将系统的参数依次放入到寄存器%ebx、%ecx、%edx以及%esi和%edi中。...
帮忙写一个ptrace的示例
最新发布
06-08
好的，下面是一个简单的 ptrace 示例代码： ```c++ #include <sys/ptrace.h> #include <sys/wait.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <signal.h> #include <errno.h> #include <sys/user.h> int main(int argc, char* argv[]) { if (argc < 2) { printf("Usage: %s <pid>\n", argv[0]); exit(1); } pid_t pid = atoi(argv[1]); if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) { perror("ptrace attach error"); exit(1); } int status; if (waitpid(pid, &status, 0) < 0) { perror("waitpid error"); exit(1); } struct user_regs_struct regs; if (ptrace(PTRACE_GETREGS, pid, NULL, &regs) < 0) { perror("ptrace getregs error"); exit(1); } printf("EAX: %llx\n", regs.orig_rax); printf("EBX: %llx\n", regs.rbx); printf("ECX: %llx\n", regs.rcx); printf("EDX: %llx\n", regs.rdx); if (ptrace(PTRACE_DETACH, pid, NULL, NULL) < 0) { perror("ptrace detach error"); exit(1); } return 0; } ``` 这个示例程序的功能是，通过 ptrace() 调用来监控指定进程的系统调用，并输出寄存器的值。具体实现步骤如下： 1. 通过 atoi() 函数将命令行参数中传入的进程 ID 转化为整数。 2. 使用 ptrace() 调用的 PTRACE_ATTACH 参数来将当前进程附加到指定进程上，以便进行监控和控制。 3. 使用 waitpid() 函数等待指定进程的系统调用结束，并获取进程的状态信息。 4. 使用 PTRACE_GETREGS 参数来获取指定进程的寄存器信息，如 EAX、EBX、ECX、EDX 等。 5. 输出获取到的寄存器信息。 6. 使用 PTRACE_DETACH 参数来将当前进程从指定进程上分离，结束监控和控制操作。 需要注意的是，这个示例程序只是一个简单的示例，实际上在使用 ptrace() 进行进程监控和控制时，需要考虑更多的因素，如信号处理、系统调用的参数和返回值、进程的安全性等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值