kk Blog —— 通用基础

date [-d @int|str] [+%s|"+%F %T"]

一个简单的 ptrace 例子

1
2
3
4
5
6
7
8
9
10
11
// test.cpp

#include <stdio.h>

int main()
{
	printf("---------- test 1 ----------\n");
	printf("---------- test 2 ----------\n");
	printf("---------- test 3 ----------\n");
	return 0;
}

编译 g++ test.cpp -o test –static

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// ptrace.cpp

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

int main()
{
	pid_t pid;
	int orig_eax, eax, ebx, ecx, edx;
   
	pid = fork();
	if(pid == 0)
	{
		ptrace(PTRACE_TRACEME, 0, NULL, NULL);
		printf("execve = %d\n", execve("./test", NULL, NULL));
		exit(0);
	}
	while(1)
	{
		int status;
		wait(&status);
		if(WIFEXITED(status)) break;

		orig_eax = ptrace(PTRACE_PEEKUSER, pid, ORIG_EAX<<2, NULL);
		eax = ptrace(PTRACE_PEEKUSER, pid, EAX<<2, NULL);
		ebx = ptrace(PTRACE_PEEKUSER, pid, EBX<<2, NULL);
       
		printf("ORIG_EAX = %d,        EAX = %d,        EBX = %d\n", orig_eax, eax, ebx);

		ptrace(PTRACE_SYSCALL, pid, NULL, NULL);
	}
	return 0;
}

编译 g++ ptrace.cpp -o ptrace --static
测试 ./ptrace 输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
ORIG_EAX = 11,        EAX = 0,        EBX = 0
ORIG_EAX = 122,        EAX = -38,        EBX = -1074643290
ORIG_EAX = 122,        EAX = 0,        EBX = -1074643290
ORIG_EAX = 45,        EAX = -38,        EBX = 0
ORIG_EAX = 45,        EAX = 161513472,        EBX = 0
ORIG_EAX = 45,        EAX = -38,        EBX = 161516752
ORIG_EAX = 45,        EAX = 161516752,        EBX = 161516752
ORIG_EAX = 243,        EAX = -38,        EBX = -1074642896
ORIG_EAX = 243,        EAX = 0,        EBX = -1074642896
ORIG_EAX = 45,        EAX = -38,        EBX = 161651920
ORIG_EAX = 45,        EAX = 161651920,        EBX = 161651920
ORIG_EAX = 45,        EAX = -38,        EBX = 161652736
ORIG_EAX = 45,        EAX = 161652736,        EBX = 161652736
ORIG_EAX = 197,        EAX = -38,        EBX = 1
ORIG_EAX = 197,        EAX = 0,        EBX = 1
ORIG_EAX = 192,        EAX = -38,        EBX = 0
ORIG_EAX = 192,        EAX = -1217093632,        EBX = 0
ORIG_EAX = 4,        EAX = -38,        EBX = 1
---------- test 1 ----------
ORIG_EAX = 4,        EAX = 29,        EBX = 1
ORIG_EAX = 4,        EAX = -38,        EBX = 1
---------- test 2 ----------
ORIG_EAX = 4,        EAX = 29,        EBX = 1
ORIG_EAX = 4,        EAX = -38,        EBX = 1
---------- test 3 ----------
ORIG_EAX = 4,        EAX = 29,        EBX = 1
ORIG_EAX = 252,        EAX = -38,        EBX = 0

内核 Linux 2.6.32-35-generic

ubuntu 10.04 linux 系统调用号 /usr/include/asm/unistd_32.h
linux 系统EAX等值 /usr/include/sys/reg.h

Playing with ptrace, Part I — 玩转ptrace(二)

本文地址

版权所有 © 转载时必须以链接形式注明作者和原始出处!

Playing with ptrace, Part II
by Pradeep Padala p_padala@yahoo.com http://www.cise.ufl.edu/~ppadala
Created 2002-11-01 02:00

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

在第一部分中我们已经看到ptrace怎么获取子进程的系统调用以及改变系统调用的参数。在这篇文章中,我们将要研究如何在子进程中设置断点和往运行中的程序里插入代码。实际上调试器就是用这种方法来设置断点和执行调试句柄。与前面一样,这里的所有代码都是针对i386平台的。
附着在进程上

在第一部分钟,我们使用ptrace(PTRACE_TRACEME, …)来跟踪一个子进程,如果你只是想要看进程是怎么进行系统调用和跟踪程序的,这个做法是不错的。但如果你要对运行中的进程进行调试,则需要使用 ptrace( PTRACE_ATTACH, ….)

当 ptrace( PTRACE_ATTACH, …)在被调用的时候传入了子进程的pid时, 它大体是与ptrace( PTRACE_TRACEME, …)的行为相同的,它会向子进程发送SIGSTOP信号,于是我们可以察看和修改子进程,然后使用 ptrace( PTRACE_DETACH, …)来使子进程继续运行下去。

下面是调试程序的一个简单例子

1
2
3
4
5
6
7
8
9
int main()
{
	int i;
	for(i = 0;i < 10; ++i) {
		printf("My counter: %d ", i);
		sleep(2);
	}
	return 0;
}

将上面的代码保存为dummy2.c。按下面的方法编译运行:
gcc -o dummy2 dummy2.c
./dummy2 &

现在我们可以用下面的代码来附着到dummy2上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <linux/user.h>   /* For user_regs_struct
							 etc. */
int main(int argc, char *argv[])
{
	pid_t traced_process;
	struct user_regs_struct regs;
	long ins;
	if(argc != 2) {
		printf("Usage: %s <pid to be traced>\n",
			argv[0], argv[1]);
		exit(1);
	}
	traced_process = atoi(argv[1]);
	ptrace(PTRACE_ATTACH, traced_process,
		NULL, NULL);
	wait(NULL);
	ptrace(PTRACE_GETREGS, traced_process,
		NULL, ®s);
	ins = ptrace(PTRACE_PEEKTEXT, traced_process,
		regs.eip, NULL);
	printf("EIP: %lx Instruction executed: %lx\n",
		regs.eip, ins);
	ptrace(PTRACE_DETACH, traced_process,
		NULL, NULL);
	return 0;
}

上面的程序仅仅是附着在子进程上,等待它结束,并测量它的eip( 指令指针)然后释放子进程。 设置断点

调试器是怎么设置断点的呢?通常是将当前将要执行的指令替换成trap指令,于是被调试的程序就会在这里停滞,这时调试器就可以察看被调试程序的信息了。被调试程序恢复运行以后调试器会把原指令再放回来。这里是一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <linux/user.h>
const int long_size = sizeof(long);
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] = '\0';
}
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(int argc, char *argv[])
{
	pid_t traced_process;
	struct user_regs_struct regs, newregs;
	long ins;
	/* int 0x80, int3 */
	char code[] = {0xcd,0x80,0xcc,0};
	char backup[4];
	if(argc != 2) {
		printf("Usage: %s <pid to be traced>\n",
			argv[0], argv[1]);
		exit(1);
	}
	traced_process = atoi(argv[1]);
	ptrace(PTRACE_ATTACH, traced_process,
		NULL, NULL);
	wait(NULL);
	ptrace(PTRACE_GETREGS, traced_process,
		NULL, ®s);
	/* Copy instructions into a backup variable */
	getdata(traced_process, regs.eip, backup, 3);
	/* Put the breakpoint */
	putdata(traced_process, regs.eip, code, 3);
	/* Let the process continue and execute
	   the int 3 instruction */
	ptrace(PTRACE_CONT, traced_process, NULL, NULL);
	wait(NULL);
	printf("The process stopped, putting back "
		"the original instructions\n");
	printf("Press <enter> to continue\n");
	getchar();
	putdata(traced_process, regs.eip, backup, 3);
	/* Setting the eip back to the original
	   instruction to let the process continue */
	ptrace(PTRACE_SETREGS, traced_process,
		NULL, ®s);
	ptrace(PTRACE_DETACH, traced_process,
		NULL, NULL);
	return 0;
}

上面的程序将把三个byte的内容进行替换以执行trap指令,等被调试进程停滞以后,我们把原指令再替换回来并把eip修改为原来的值。下面的图中演示了指令的执行过程
1. 进程停滞后
2. 替换入trap指令
3.断点成功,控制权交给了调试器
4. 继续运行,将原指令替换回来并将eip复原
在了解了断点的机制以后,往运行中的程序里面添加指令也不再是难事了,下面的代码会使原程序多出一个”hello world”的输出

这时一个简单的”hello world”程序,当然为了我们的特殊需要作了点修改:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void main()
{
	__asm__("
		jmp forward
		backward:
			popl   %esi   # Get the address of
					# hello world string
			movl   $4, %eax   # Do write system call
			movl   $2, %ebx
			movl   %esi, %ecx
			movl   $12, %edx
			int   $0x80
			int3      # Breakpoint. Here the
					# program will stop and
					# give control back to
					# the parent
		forward:
			call   backward
			.string \"Hello World\\n\""
	);
}

使用 gcc -o hello hello.c
来编译它。
在backward和forward之间的跳转是为了使程序能够找到”hello world” 字符串的地址。
使用GDB我们可以得到上面那段程序的机器码。启动GDB,然后对程序进行反汇编:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
(gdb) disassemble main
Dump of assembler code forfunction main:
0x80483e0<main>:       push   %ebp
0x80483e1<main+1>:   mov    %esp,%ebp
0x80483e3<main+3>:   jmp    0x80483fa<forward>
End of assembler dump.
(gdb) disassemble forward
Dump of assembler code forfunction forward:
0x80483fa<forward>: call   0x80483e5<backward>
0x80483ff<forward+5>:  dec  %eax
0x8048400<forward+6>:  gs
0x8048401<forward+7>:  insb   (%dx),%es:(%edi)
0x8048402<forward+8>:  insb   (%dx),%es:(%edi)
0x8048403<forward+9>:  outsl  %ds:(%esi),(%dx)
0x8048404<forward+10>: and  %dl,0x6f(%edi)
0x8048407<forward+13>: jb    0x8048475
0x8048409<forward+15>: or    %fs:(%eax),%al
0x804840c<forward+18>: mov  %ebp,%esp
0x804840e<forward+20>: pop  %ebp
0x804840f<forward+21>: ret
End of assembler dump.
(gdb) disassemble backward
Dump of assembler code forfunction backward:
0x80483e5<backward>:   pop  %esi
0x80483e6<backward+1>: mov  $0x4,%eax
0x80483eb<backward+6>: mov  $0x2,%ebx
0x80483f0<backward+11>:     mov %esi,%ecx
0x80483f2<backward+13>:     mov $0xc,%edx
0x80483f7<backward+18>:int  $0x80
0x80483f9<backward+20>:     int3
End of assembler dump.

我们需要使用从man+3到backward+20之间的字节码,总共41字节。使用GDB中的x命令来察看机器码。

1
2
3
4
5
6
(gdb) x/40bx main+3
<main+3>: eb 15 5e b8 04000000
<backward+6>: bb 0200000089 f1 ba
<backward+14>: 0c 000000 cd 80 cc
<forward+1>: e6 ff ff ff 4865 6c 6c
<forward+9>:6f20576f72 6c 64 0a

已经有了我们想要执行的指令,还等什么呢?只管把它们根前面那个例子一样插入到被调试程序中去!

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
int main(int argc,char*argv[])
{
	pid_t traced_process;
	struct user_regs_struct regs, newregs;
	long ins;
	int len =41;
	char insertcode[]=
		"\xeb\x15\x5e\xb8\x04\x00"
		"\x00\x00\xbb\x02\x00\x00\x00\x89\xf1\xba"
		"\x0c\x00\x00\x00\xcd\x80\xcc\xe8\xe6\xff"
		"\xff\xff\x48\x65\x6c\x6c\x6f\x20\x57\x6f"
		"\x72\x6c\x64\x0a\x00";
	char backup[len];
	if(argc != 2) {
		printf("Usage: %s <pid to be traced>\n",
			argv[0], argv[1]);
		exit(1);
	}
	traced_process = atoi(argv[1]);
	ptrace(PTRACE_ATTACH, traced_process,
		NULL, NULL);
	wait(NULL);
	ptrace(PTRACE_GETREGS, traced_process,
		NULL,®s);
	getdata(traced_process, regs.eip, backup, len);
	putdata(traced_process, regs.eip,
		insertcode, len);
	ptrace(PTRACE_SETREGS, traced_process,
		NULL,®s);
	ptrace(PTRACE_CONT, traced_process,
		NULL, NULL);
	wait(NULL);
	printf("The process stopped, Putting back the original instructions\n");
	putdata(traced_process, regs.eip, backup, len);
	ptrace(PTRACE_SETREGS, traced_process,
		NULL,®s);
	printf("Letting it continue with original flow\n");
	ptrace(PTRACE_DETACH, traced_process,
		NULL, NULL);
	return0;
}

将代码插入到自由空间

在前面的例子中我们将代码直接插入到了正在执行的指令流中,然而,调试器可能会被这种行为弄糊涂,所以我们决定把指令插入到进程中的自由空间中去。通过察看/proc/pid/maps可以知道这个进程中自由空间的分布。接下来这个函数可以找到这个内存映射的起始点:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
long freespaceaddr(pid_t pid)
{
	FILE *fp;
	char filename[30];
	char line[85];
	long addr;
	char str[20];
	sprintf(filename,"/proc/%d/maps", pid);
	fp = fopen(filename,"r");
	if(fp == NULL)
		exit(1);
	while(fgets(line,85, fp) != NULL) {
		sscanf(line,"%lx-%*lx %*s %*s %s",&addr,
			str, str, str, str);
		if(strcmp(str,"00:00")==0)
			break;
	}
	fclose(fp);
	return addr;
}

在/proc/pid/maps中的每一行都对应了进程中一段内存区域。主函数的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
int main(int argc,char*argv[])
{
	pid_t traced_process;
	struct user_regs_struct oldregs, regs;
	long ins;
	int len =41;
	char insertcode[]=
		"\xeb\x15\x5e\xb8\x04\x00"
		"\x00\x00\xbb\x02\x00\x00\x00\x89\xf1\xba"
		"\x0c\x00\x00\x00\xcd\x80\xcc\xe8\xe6\xff"
		"\xff\xff\x48\x65\x6c\x6c\x6f\x20\x57\x6f"
		"\x72\x6c\x64\x0a\x00";
	char backup[len];
	long addr;
	if(argc !=2){
		printf("Usage: %s <pid to be traced>\n",
			argv[0], argv[1]);
			exit(1);
	}
	traced_process = atoi(argv[1]);
	ptrace(PTRACE_ATTACH, traced_process,
		NULL, NULL);
	wait(NULL);
	ptrace(PTRACE_GETREGS, traced_process,
		NULL,®s);
	addr = freespaceaddr(traced_process);
	getdata(traced_process, addr, backup, len);
	putdata(traced_process, addr, insertcode, len);
	memcpy(&oldregs,®s,sizeof(regs));
	regs.eip= addr;
	ptrace(PTRACE_SETREGS, traced_process,
		NULL,®s);
	ptrace(PTRACE_CONT, traced_process,
		NULL, NULL);
	wait(NULL);
	printf("The process stopped, Putting back the original instructions\n");
	putdata(traced_process, addr, backup, len);
	ptrace(PTRACE_SETREGS, traced_process,
		NULL,&oldregs);
	printf("Letting it continue with original flow\n");
	ptrace(PTRACE_DETACH, traced_process,
		NULL, NULL);
	return0;
}

ptrace的幕后工作

那么,在使用ptrace的时候,内核里发生了声么呢?这里有一段简要的说明:当一个进程调用了 ptrace( PTRACE_TRACEME, …)之后,内核为该进程设置了一个标记,注明该进程将被跟踪。内核中的相关原代码如下:

1
2
3
4
5
6
7
8
9
10
Source: arch/i386/kernel/ptrace.c
  if(request == PTRACE_TRACEME){
      /* are we already being traced? */
      if(current->ptrace & PT_PTRACED)
          goto out;
      /* set the ptrace bit in the process flags. */
      current->ptrace |= PT_PTRACED;
      ret =0;
      goto out;
  }

一次系统调用完成之后,内核察看那个标记,然后执行trace系统调用(如果这个进程正处于被跟踪状态的话)。其汇编的细节可以在 arh/i386/kernel/entry.S中找到。

现在让我们来看看这个sys_trace()函数(位于 arch/i386/kernel/ptrace.c )。它停止子进程,然后发送一个信号给父进程,告诉它子进程已经停滞,这个信号会激活正处于等待状态的父进程,让父进程进行相关处理。父进程在完成相关操作以后就调用ptrace( PTRACE_CONT, …)或者 ptrace( PTRACE_SYSCALL, …), 这将唤醒子进程,内核此时所作的是调用一个叫wake_up_process() 的进程调度函数。其他的一些系统架构可能会通过发送SIGCHLD给子进程来达到这个目的。 小结:

ptrace函数可能会让人们觉得很奇特,因为它居然可以检测和修改一个运行中的程序。这种技术主要是在调试器和系统调用跟踪程序中使用。它使程序员可以在用户级别做更多有意思的事情。已经有过很多在用户级别下扩展操作系统得尝试,比如UFO,一个用户级别的文件系统扩展,它使用ptrace来实现一些安全机制。

Playing with ptrace, Part I — 玩转ptrace(一)

原文
版权所有 © 转载时必须以链接形式注明作者和原始出处!

Playing with ptrace, Part I
by Pradeep Padala p_padala@yahoo.com http://www.cise.ufl.edu/~ppadala
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)。当一个程序需要作系统调用的时候,它将相关参数放进系统调用相关的寄存器,然后调用软中断0×80,这个中断就像一个让程序得以接触到内核模式的窗口,程序将参数和系统调用号交给内核,内核来完成系统调用的执行。

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

1
Write(2, “Hello”, 5)

的汇编形式大概是这样的

1
2
3
4
5
movl $4, %eax
movl $2, %ebx
movl $hello, %ecx
movl $5, %edx
int $0×80

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#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\n", orig_eax);
		ptrace(PTRACE_CONT, child, NULL, NULL);
	}
	return0;
}

运行这个程序,将会在输出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有四个参数

1
2
3
4
long ptrace(enum __ptrace_request request,
	pid_t pid,
	void *addr,
	void *data);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 的第一个参数进行调用,可以取得与子进程相关的寄存器值。

先看下面这个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#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\n",
							params[0], params[1],
							params[2]);
				} else {/* Syscall exit */
					eax = ptrace(PTRACE_PEEKUSER,
						child,4* EAX, NULL);
					printf("Write returned "
						"with %ld\n", eax);
							insyscall =0;
				}
			}
			ptrace(PTRACE_SYSCALL,
				child, NULL, NULL);
		}
	}
	return0;
}

这个程序的输出是这样的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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的第一个参数来调用,可以只需一次函数调用就取得所有的相关寄存器值。 获得寄存器值得例子如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#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,®s);
					printf("Write called with "
						"%ld, %ld, %ld\n",
						regs.ebx, regs.ecx,
						regs.edx);
				} else { /* Syscall exit */
					eax = ptrace(PTRACE_PEEKUSER,
						child,4* EAX,
						NULL);
					printf("Write returned "
						"with %ld\n", eax);
						insyscall =0;
				}
			}
			ptrace(PTRACE_SYSCALL, child,
				NULL, NULL);
		}
	}
	return0;
}

这段代码与前面的例子是比较相似的,不同的是它使用了PTRACE_GETREGS。 其中的user_regs_struct结构是在中定义的。
来点好玩的

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <linux/user.h>
#include <sys/syscall.h>
constint 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]='\0';
}
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);
		}
	}
	return0;
}

输出是这样的:

1
2
3
4
5
6
7
8
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来编译

1
2
3
4
5
6
7
8
9
10
11
12
13
14
.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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#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,®s);
		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);
		}
	}
	return0;
}

程序的输出是这样的:
你可能需要察看Intel的用户手册来了解这些指令代码的意思。
更复杂的单步,比如设置断点,则需要很仔细的设计和更复杂的代码才可以实现。

在第二部分,我们将会看到如何在程序中加入断点,以及将代码插入到已经在运行的程序中

linux ptrace函数

1
2
#include <sys/ptrace.h>
int ptrace(int request, int pid, int addr, int data);
描述

Ptrace提供了一种父进程可以控制子进程运行,并可以检查和改变它的核心image。它主要用于实现断点调试。一个被跟踪的进程运行中,直到发生一个信号。则进程被中止,并且通知其父进程。在进程中止的状态下,进程的内存空间可以被读写。父进程还可以使子进程继续执行,并选择是否是否忽略引起中止的信号。

AT&T 汇编

AT&T 汇编

1.Register Reference

引用寄存器要在寄存器号前加百分号%,如“movl %eax, %ebx”。
80386 有如下寄存器:

1
2
3
4
5
6
7
8
9
10
[1] 8 个 32-bit 寄存器 %eax,%ebx,%ecx,%edx,%edi,%esi,%ebp,%esp;
( 8 个 16-bit 寄存器,它们事实上是上面 8 个 32-bit 寄存器的低 16 位:%ax,%bx,
%cx,%dx,%di,%si,%bp,%sp;
8 个 8-bit 寄存器:%ah,%al,%bh,%bl,%ch,%cl,%dh,%dl。它们事实上
是寄存器%ax,%bx,%cx,%dx 的高 8 位和低 8 位;)
[2] 6 个段寄存器:%cs(code),%ds(data),%ss(stack), %es,%fs,%gs;
[3] 3 个控制寄存器:%cr0,%cr2,%cr3;
[4] 6 个 debug 寄存器:%db0,%db1,%db2,%db3,%db6,%db7;
[5] 2 个测试寄存器:%tr6,%tr7;
[6] 8 个浮点寄存器栈:%st(0),%st(1),%st(2),%st(3),%st(4),%st(5),%st(6),%st(7)。

2. Operator Sequence

操作数排列是从源(左)到目的(右),如“movl %eax(源), %ebx(目的)”

3. Immediately Operator

使用立即数,要在数前面加符号$, 如“movl $0x04, %ebx”
或者:

1
2
para = 0x04
movl $para, %ebx

指令执行的结果是将立即数 0x04 装入寄存器 ebx。

4. Symbol Constant

符号常数直接引用 如

1
2
value: .long 0x12a3f2de
movl value , %ebx

指令执行的结果是将常数 0x12a3f2de 装入寄存器 ebx。
引用符号地址在符号前加符号$, 如“movl $value, % ebx”则是将符号 value 的地址装入寄存器 ebx。

5. Length of Operator

操作数的长度用加在指令后的符号表示 b(byte, 8-bit), w(word, 16-bits), l(long,32-bits) ,如“movb %al, %bl” ,“movw %ax, %bx”,“movl %eax, %ebx ”。
如 果没有指定操作数长度的话,编译器将按照目标操作数的长度来设置。比如指令“mov %ax, %bx”,由于目标操作数 bx 的长度为 word , 那 么 编 译 器 将 把 此 指 令 等 同 于 “ movw %ax,%bx” 。 同 样 道 理 , 指 令 “ mov $4, %ebx” 等 同 于 指 令 “ movl $4, %ebx”,“push %al”等同于“pushb %al”。对于没有指定操作数长度,但编译器又无法猜测的指令,编译器将会报错,比如指令 “push $4”。

6. Sign and Zero Extension

绝大多数面向 80386 的 AT&T 汇编指令与 Intel 格式的汇编指令都是相同的,但符号扩展指令和零扩展指令有不同格式。符号扩展指令 和零扩展指令需要指定源操作数长度和目的操作数长度,即使在某些指令中这些操作数是隐含的。

在 AT&T 语法中,符号扩展和零扩展指令的格式为,基本部分"movs"和"movz"(对应 Intel 语法的 movsx 和 movzx),后面跟 上源操作数长度和目的操作数长度。 movsbl 意味着 movs (from)byte (to)long;movbw 意味着 movs (from)byte (to)word;movswl 意味着 movs (from)word (to)long。对于 movz 指令也一样。比如指令“movsbl %al,%edx”意味着将 al 寄存器的内容进行符号扩展后放置到 edx 寄存器中。

其它的 Intel 格式的符号扩展指令还有:

1
2
3
4
cbw -- sign-extend byte in %al to word in %ax;
cwde -- sign-extend word in %ax to long in %eax;
cwd -- sign-extend word in %ax to long in %dx:%ax;
cdq -- sign-extend dword in %eax to quad in %edx:%eax;

对应的 AT&T 语法的指令为 cbtw,cwtl,cwtd,cltd。

7. Call and Jump

段内调用和跳转指令为 “call” , “ret” 和 “jmp”,段间调用和跳转指令为 “lcall” , “lret” 和 “ljmp” 。段间调用和跳转指令的格式为
“lcall/ljmp $SECTION, $OFFSET”,而段间返回指令则为“lret $STACK-ADJUST”。

8. Prefix

操作码前缀被用在下列的情况:

1
2
3
4
[1]字符串重复操作指令(rep,repne);
[2]指定被操作的段(cs,ds,ss,es,fs,gs);
[3]进行总线加锁(lock);
[4]指定地址和操作的大小(data16,addr16);

在 AT&T 汇编语法中,操作码前缀通常被单独放在一行,后面不跟任何操作数。例如,对于重复 scas 指令,其写法为:

1
2
repne
scas

上述操作码前缀的意义和用法如下:

1
2
3
4
5
6
7
8
9
[1]指定被操作的段前缀为 cs,ds,ss,es,fs,和 gs。在 AT&T 语法中,只需要按照
section:memory-operand 的格式就指定了相应的段前缀。比如:
lcall %cs:realmode_swtch
[2]操作数/地址大小前缀是“data16”和"addr16",它们被用来在 32-bit 操作数/地址代码中指定 16-bit 的操作数/地址。
[3]总线加锁前缀“lock”,它是为了在多处理器环境中,保证在当前指令执行期间禁止一切中断。这个前缀仅仅对 ADD, ADC, AND,
BTC, BTR, BTS, CMPXCHG,DEC,
INC, NEG, NOT, OR, SBB, SUB, XOR, XADD,XCHG 指令有效,如果将 Lock 前
缀用在其它指令之前,将会引起异常。
[4]字符串重复操作前缀"rep","repe","repne"用来让字符串操作重复“%ecx”次。

9. Memory Reference

Intel 语法的间接内存引用的格式为:

1
section:[base+index*scale+displacement]

而在 AT&T 语法中对应的形式为:

1
section:displacement(base,index,scale)

其中,base 和 index 是任意的 32-bit base 和 index 寄存器。scale 可以取值 1,2,4,8。如果不指定 scale 值,则默认值为 1。 section 可以指定任意的段寄存器作为段前缀,默认的段寄存器在不同的情况下不一样。如果在指令中指定了默认的段前缀,则编译器在 目标代码中不会产生此段前缀代码。

下面是一些例子:
-4(%ebp):base=%ebp,displacement=-4,section 没有指定,由于 base=%ebp,所以默认的 section=%ss,index,scale 没有指定,则 index 为 0。
foo(,%eax,4):index=%eax,scale=4,displacement=foo。其它域没有指定。这里默认的 section=%ds。
foo(,1):这个表达式引用的是指针 foo 指向的地址所存放的值。注意这个表达式中没有 base 和 index,并且只有一个逗号,这是一种 异常语法,但却合法。
%gs:foo:这个表达式引用的是放置于%gs 段里变量 foo 的值。
如果 call 和 jump 操作在操作数前指定前缀“”,则表示是一个绝对地址调用/跳转,也就是说 jmp/call 指令指定的是一个绝对地址。
如果没有指定"
“,则操作数是一个相对地址。
任何指令如果其操作数是一个内存操作, 则指令必须指定它的操作尺寸
(byte,word,long),也就是说必须带有指令后缀(b,w,l)。
Linux 工作在保护模式下,用的是 32 位线性地址,所以在计算地址时不用考虑段基址和偏移量,而是采用如下的地
址计算方法:
disp + base + index * scale
下面是一些内存操作数的例子:

1
2
3
4
5
AT&T 格式
movl -4(%ebp), %eax
movl array(, %eax, 4), %eax
movw array(%ebx, %eax, 4), %cx
movb $4, %fs:(%eax)

其中下面这些省略了浮点数及 IA-32 如 SSE FPU 等特殊的指令集部分, 我觉得重要的是学习 linux 汇编的语法及编译原理和程序控制流程, 具体的指令细节就不那么重要了。