调试器的原理-详解ptrace函数及fork父子进程跟踪实例

最近仔细研究了一下linux调试程序的原理.gdb是linux下最为强大的调试工具,而strace可以拦截程序执行过程中的系统调用.他们的背后都隐藏了一个强悍的支持函数ptrace().调试程序过程中我们可以单步执行,逐步检查程序的输入输出,从而判断程序错误,当然我们也可以抛弃gdb,自己实现一个"外挂程序",拦截主程序中我们感兴趣的东西,比如ssh或ftp登录密码.

先看一个简单的程序:

#include
int main(void){
	char buf[1024];
	gets(buf);
	puts(buf);
	return 0;
}

我们感兴趣的是他输入了什么,使用strace输出如下(部分):

fstat64(0, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 2), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb77a9000
read(0, AAAAAAAAAAAA
"AAAAAAAAAAAA\n", 1024)         = 13
fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 2), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb77a8000
write(1, "AAAAAAAAAAAA\n", 13AAAAAAAAAAAA
)          = 13
exit_group(0)                           = ?
+++ exited with 0 +++

可以看到,在系统调用层面,程序使用了read函数实现了数据输入,所以"外挂"程序可以利用这一点,只针对read调用进行拦截:

/*
*该程序仅能在32位x86 linux中使用.64位系统需要修改struct user_regs_struct regs中寄存器格式.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
void getdata(pid_t pid,long addr, char *str,int len){
	int i;
	long data;
	for(i=0;i<(len+sizeof(long)-1)/sizeof(long);i++){
		data=ptrace(PTRACE_PEEKDATA,pid,addr+i*sizeof(long),NULL);
		*(long *)(str+i*sizeof(long))=data;
	}
	*(str+len)='\0';
	printf("%s",str);
}
int main(int argc,char **argv){
	pid_t pid;
	int status,buf_len,i;
	struct user_regs_struct regs;
	char *buf;
	int insyscall=0;	
	
	if (argc<2){
		printf("Usage:./a.out prog \n");
		return 1;
	}
	if ((pid=fork())==0){  //子进程运行被跟踪程序
		ptrace(PTRACE_TRACEME,0,NULL,NULL);
		status=execvp(argv[1],argv+1);
		if(status<0){
			printf("execvp %s error:%s\n",argv[1],strerror(errno));
			return -1;
		}
	}else if(pid>0){  //父进程拦截子进程所有系统调用
		while(1){
			wait(&status);
			if(WIFEXITED(status))  //如果子进程正常退出,则父进程退出循环
				break;
			ptrace(PTRACE_GETREGS, pid, 0, ®s);  //dump子进程寄存器
			if (regs.orig_eax!=SYS_read){  //判断子进程系统调用号,非read调用继续循环
				ptrace(PTRACE_SYSCALL,pid,NULL,NULL);
				continue;
			}			
/*
			if (regs.ebx!=0){  //判断输入是否来自stdin
				ptrace(PTRACE_SYSCALL,pid,NULL,NULL);
				continue;
			}
*/
			if (insyscall==0){  //一次系统调用会触发两次,第一次是刚进入read调用,另一次是刚退出read调用			
				ptrace(PTRACE_SYSCALL,pid,NULL,NULL);
				insyscall=1;
			}else{  //这里需要的是刚进入调用时的情况,因为这里有用户刚输入的数据
				buf_len=(regs.edx+sizeof(long)-1)/sizeof(long)*sizeof(long)+1;
				if((buf=(char *)malloc(buf_len))==NULL){
					printf("malloc error!\n");
					return 1;
				}
				bzero(buf,buf_len); //分配buf空间,并清空
				getdata(pid,regs.ecx,buf,regs.edx);  //定位到输入数据的内存地址和长度,进行dump
				free(buf);
				ptrace(PTRACE_SYSCALL,pid,NULL,NULL);
				insyscall=0;
			}
		} 
		return 0;
	}else{
		printf("fork error!\n");
		return 1;
	}
}

需要说明一下

getdata(pid,regs.ecx,buf,regs.edx);

ecx保存了数据地址,edx保存了数据长度.这里可以回顾一下read系统调用格式:SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count);编译成汇编后就成了如下的指令(注意gcc参数从右向左压栈):

伪指令!!!!
pushl count
pushl buf
pushl fd
pushl read
int $0x80

而进入系统调用后,内核从栈内取出read调用参数:eax取到read,即系统调用号,ebx对应fd,ecx对应buf,edx对应count.有兴趣的可以参考linux系统调用过程,这里不再赘述.

运行结果如下:

可以看到输入被成功捕获,用ssh试验,ssh同样不能幸免:

进一步,如果被跟踪程序使用了fork,那么我们如何跟踪其子进程或父进程呢?gdb中可以通过follow-fork-mode参数选择跟踪对象.那么具体反映到ptrace函数,该如何自己编写程序使用ptrace函数实现呢?

被跟踪程序:

#include
#include
#include
#include 
int main(){
    int pid;
    if (pid=fork()){
        waitpid(pid,NULL,0);
        return 0;
    }else{
        char buf[1024];
        scanf("%s",buf);
        printf("%s\n",buf);
        return 0;
    }
}

对应的外挂程序:

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
void getdata(pid_t pid,long addr, char *str,int len){
    int i;
    long data;
    for(i=0;i<(len+sizeof(long)-1)/sizeof(long);i++){
        data=ptrace(PTRACE_PEEKDATA,pid,addr+i*sizeof(long),NULL);
        *(long *)(str+i*sizeof(long))=data;
    }
    *(str+len)='\0';
    printf("%s",str);
}
int main(int argc,char **argv){
    pid_t pid;
    int status,buf_len,i;
    struct user_regs_struct regs;
    char *buf;
    int insyscall=0;    
    
    if (argc<2){
        printf("Usage:./a.out prog \n");
        return 1;
    }
    if ((pid=fork())==0){
        ptrace(PTRACE_TRACEME,0,NULL,NULL);
        status=execvp(argv[1],argv+1);
        if(status<0){
            printf("execvp %s error:%s\n",argv[1],strerror(errno));
            return -1;
        }
    }else if(pid>0){
        wait(NULL);
        long ptraceOption = PTRACE_O_TRACEFORK;
        ptrace(PTRACE_SETOPTIONS, pid, NULL, ptraceOption); //设置ptrace属性
        ptrace(PTRACE_CONT, pid, NULL, NULL);  //设置好了后让被跟踪程序继续运行
        while(1){
            pid_t pid_waited=waitpid(-1,&status,0);  //等待信号
            if (pid_waited == -1)
                break;
            if(WIFEXITED(status))
                continue;
            if (pid_waited==pid){  //如果发出信号进程的进程号跟pid一致，则说明它是被跟踪程序的父进程，否则是被跟踪程序的子进程
                if(WIFSTOPPED(status)){
                    ptrace(PTRACE_CONT,pid_waited,NULL,NULL);
                    continue;
                }
            }
            //下面是被跟踪程序的子进程,开始dump子进程的输入数据
            ptrace(PTRACE_GETREGS, pid_waited, 0, ®s);
            if (regs.orig_eax!=SYS_read){
                ptrace(PTRACE_SYSCALL,pid_waited,NULL,NULL);
                continue;
            }
            if (insyscall==0){
                ptrace(PTRACE_SYSCALL,pid_waited,NULL,NULL);
                insyscall=1;
            }else{
                buf_len=(regs.edx+sizeof(long)-1)/sizeof(long)*sizeof(long)+1;
                if((buf=(char *)malloc(buf_len))==NULL){
                    printf("malloc error!\n");
                    return 1;
                }
                bzero(buf,buf_len);
                getdata(pid_waited,regs.ecx,buf,regs.edx);
                free(buf);
                ptrace(PTRACE_SYSCALL,pid_waited,NULL,NULL);
                insyscall=0;
            }
        }
        return 0;
    }else{
        printf("fork error!\n");
        return 1;
    }
}

关键在于ptrace(PTRACE_SETOPTIONS, pid, NULL, ptraceOption)函数,可以设置被跟踪的对象.这里需要说明一下,当设置ptraceOption后,被跟踪程序父进程收到SIGTRAP信号暂停,子进程收到SIGSTOP信号暂停.因此都需要跟踪程序显式启动它们.另外,这个程序中判断被跟踪程序的父子进程是通过与waitpid返回的进程号比较得知的，这也是strace中使用的方法。另一种方法是在被跟踪程序的父进程中调用ptrace的PTRACE_GETEVENTMSG获得子进程的进程号。

运行结果：

其中第一行是我们在键盘上的输入，一行为被跟踪程序的输出，还有一行为“外挂”程序的输出。