1.ptrace基础

函数原型
long ptrace(enum __ptrace_request request, pid_t pid, void *addr,void *data);

参数详解
主要是参数一
PTRACE_ATTACH，表示附加到指定远程进程
PTRACE_DETACH，表示从指定远程进程分离
PTRACE_GETREGS，表示读取远程进程当前寄存器环境
PTRACE_SETREGS，表示设置远程进程的寄存器环境
PTRACE_CONT，表示使远程进程继续运行
PTRACE_PEEKTEXT，从远程进程指定内存地址读取一个word大小的数据
PTRACE_POKETEXT，往远程进程指定内存地址写入一个word大小的数据

在注入需求下都是应用这两个参数的PTRACE_ATTACH、PTRACE_DETACH

参数二 需要附加注入的pid数据

参数三、参数四 都直接用NULL填充就可以

2.ptrace注入的步骤

1.调用ptrace系统函数进行附加到远程进程
2.保存寄存器的环境数据
3.通过调mmap系统函数进行分配内存空间
4.想附加的进程写入模块名称和要执行的函数名称
5.调用dlopen系统函数进行打开注入的模块
6.调用dlsym系统函数获取需调用函数的地址信息
7.远程调用被注入模块的函数
8.恢复寄存器的环境数据
9.调用ptrace系统函数进行和附加进程进行剥离

3.ptrace注入源码实现

3.1附加进程

/*******************
 函数功能n:   使用ptrace函数 Attach到指定远程进程
 参数:        pid表示远程进程的ID
 返回值:      返回0表示attach成功，返回-1表示失败
********************/  
int ptrace_attach(pid_t pid)    
{
	int status = 0;
	
    if (ptrace(PTRACE_ATTACH, pid, NULL, 0) < 0) {    
        LOGD("attach process error, pid:%d", pid);    
        return -1;    
    }    
	
 	LOGD("attach process pid:%d", pid);          
    waitpid(pid, &status , WUNTRACED);       	
    
    return 0;    
} 
复制代码

3.2剥离进程

/******************
  函数功能n:    使用ptrace函数 DETACH到剥离进程
  参数:         pid表示远程进程的ID
  返回值:       返回0表示DETACH成功，返回-1表示失败
******************/    
int ptrace_detach(pid_t pid)    
{    
    if (ptrace(PTRACE_DETACH, pid, NULL, 0) < 0) {    
        LOGD("detach process error, pid:%d", pid);     
        return -1;    
    }    
    
	LOGD("detach process pid:%d", pid);  
    return 0;    
}
复制代码

3.2ptrace注入so功能

/**************************
  函数功能: 通过远程直接调用dlopen\dlsym的方法ptrace注入so模块到远程进程中
  参数1:    pid表示远程进程的pid，
  参数2：LibPath为被远程注入的so模块路径，
  参数3：FunctionName为远程注入的模块后调用的函数
  参数4：:FuncParameter指向被远程调用函数的参数（若传递字符串，需要先将字符串写入到远程进程空间中），NumParameter为参数的个数
  Return:  返回0表示注入成功，返回-1表示失败

**********************/ 
int inject_remote_process(pid_t pid, char *LibPath, char *FunctionName, long *FuncParameter, long NumParameter)
{
	int iRet = -1;
	struct pt_regs CurrentRegs, OriginalRegs;  // CurrentRegs表示远程进程中当前的寄存器值，OriginalRegs存储注入前的寄存器值，方便恢复
	void *mmap_addr, *dlopen_addr, *dlsym_addr, *dlclose_addr, *dlerror_addr;   // 远程进程中需要调用函数的地址
	void *RemoteMapMemoryAddr, *RemoteModuleAddr, *RemoteModuleFuncAddr; // RemoteMapMemoryAddr为远程进程空间中映射的内存基址，RemoteModuleAddr为远程注入的so模块加载基址，RemoteModuleFuncAddr为注入模块中需要调用的函数地址
	long parameters[6];  
	
	// Attach远程进程
	if (ptrace_attach(pid) == -1)
		return iRet;
	
	// 获取远程进程的寄存器值
	if (ptrace_getregs(pid, &CurrentRegs) == -1)
	{
		ptrace_detach(pid);
		return iRet;
	}

	
	// 保存远程进程空间中当前的上下文寄存器环境
	memcpy(&OriginalRegs, &CurrentRegs, sizeof(CurrentRegs)); 
	
	// 获取mmap函数在远程进程中的地址
	mmap_addr = GetRemoteFuncAddr(pid, libc_path, (void *)mmap);
	LOGD("mmap RemoteFuncAddr:0x%lx", (long)mmap_addr);
	
	// 设置mmap的参数
	// void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offsize);
    parameters[0] = 0;  // 设置为NULL表示让系统自动选择分配内存的地址    
    parameters[1] = 0x1000; // 映射内存的大小    
    parameters[2] = PROT_READ | PROT_WRITE | PROT_EXEC;  // 表示映射内存区域可读可写可执行   
    parameters[3] =  MAP_ANONYMOUS | MAP_PRIVATE; // 建立匿名映射    
    parameters[4] = 0; //  若需要映射文件到内存中，则为文件的fd  
    parameters[5] = 0; //文件映射偏移量 	
	
	// 调用远程进程的mmap函数，建立远程进程的内存映射
	if (ptrace_call(pid, (long)mmap_addr, parameters, 6, &CurrentRegs) == -1)
	{
		LOGD("Call Remote mmap Func Failed");
		ptrace_detach(pid);
		return iRet;
	}
	
	// 获取mmap函数执行后的返回值，也就是内存映射的起始地址
	RemoteMapMemoryAddr = (void *)ptrace_getret(&CurrentRegs);
	LOGD("Remote Process Map Memory Addr:0x%lx", (long)RemoteMapMemoryAddr);
	
	// 分别获取dlopen、dlsym、dlclose等函数的地址
	dlopen_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlopen);
	dlsym_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlsym);
	dlclose_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlclose);
	dlerror_addr = GetRemoteFuncAddr(pid, linker_path, (void *)dlerror);
	

	
	// 将要加载的so库路径写入到远程进程内存空间中
	if (ptrace_writedata(pid, RemoteMapMemoryAddr, LibPath, strlen(LibPath) + 1) == -1)
	{
		
		ptrace_detach(pid);
		return iRet;
	}
	
	// 设置dlopen的参数,返回值为模块加载的地址
	// void *dlopen(const char *filename, int flag);
	parameters[0] = (long)RemoteMapMemoryAddr;
	parameters[1] = RTLD_NOW| RTLD_GLOBAL;
	
	if (ptrace_call(pid, (long)dlopen_addr, parameters, 2, &CurrentRegs) == -1)
	{
		
		ptrace_detach(pid);
		return iRet;
	}

	// RemoteModuleAddr为远程进程加载注入模块的地址
	RemoteModuleAddr = (void *)ptrace_getret(&CurrentRegs);

	
	if ((long)RemoteModuleAddr == 0x0)   // dlopen 错误
	{
		LOGD("dlopen error");
		if (ptrace_call(pid, (long)dlerror_addr, parameters, 0, &CurrentRegs) == -1)
		{
			LOGD("Call Remote dlerror Func Failed");
			ptrace_detach(pid);
			return iRet;
		}
		char *Error = (void *)ptrace_getret(&CurrentRegs);
		char LocalErrorInfo[1024] = {0};
		ptrace_readdata(pid, Error, LocalErrorInfo, 1024);
		ptrace_detach(pid);
		return iRet;
	}	
	
	// 将so库中需要调用的函数名称写入到远程进程内存空间中
	if (ptrace_writedata(pid, RemoteMapMemoryAddr + strlen(LibPath) + 2, FunctionName, strlen(FunctionName) + 1) == -1)
	{
		
		ptrace_detach(pid);
		return iRet;
	}
	
	// 设置dlsym的参数，返回值为远程进程内函数的地址
	// void *dlsym(void *handle, const char *symbol);
	parameters[0] = (long)RemoteModuleAddr;
	parameters[1] = (long)(RemoteMapMemoryAddr + strlen(LibPath) + 2);
	
	if (ptrace_call(pid, (long)dlsym_addr, parameters, 2, &CurrentRegs) == -1)
	{
		LOGD("Call Remote dlsym Func Failed");
		ptrace_detach(pid);
		return iRet;
	}	
	
	// RemoteModuleFuncAddr为远程进程空间内获取的函数地址
	RemoteModuleFuncAddr = (void *)ptrace_getret(&CurrentRegs);
	
	
	if (ptrace_call(pid, (long)RemoteModuleFuncAddr, FuncParameter, NumParameter, &CurrentRegs) == -1)
	{
		LOGD("Call Remote injected Func Failed");
		ptrace_detach(pid);
		return iRet;
	}	
	
	if (ptrace_setregs(pid, &OriginalRegs) == -1)
	{
		LOGD("Recover reges failed");
		ptrace_detach(pid);
		return iRet;		
	}
	
	ptrace_getregs(pid, &CurrentRegs);
	if (memcmp(&OriginalRegs, &CurrentRegs, sizeof(CurrentRegs)) != 0)
	{
		LOGD("Set Regs Error");
	}
	
	//剥离
	if (ptrace_detach(pid) == -1)
	{
		LOGD("ptrace detach failed");
		return iRet;
	}
	
	return 0;
}