Linux运行中进程代码注入实战:新建线程托管自定义代码(PoC全解析)

平时我们写的程序都是自己启动、自己运行，但如果想让一个已经在跑的Linux进程“额外”执行一段我们的代码，还不影响它原本的工作，该怎么做？今天就拆解一个PoC（概念验证）项目——它能给运行中的Linux进程注入自定义代码，还会专门新建一个线程来跑这段代码，相当于给目标进程“插”了个新干活的线程，原进程该干啥还干啥。

先唠唠核心概念

先把几个关键概念讲明白，不然看代码容易懵：

• ptrace：Linux里的“调试神器”系统调用，简单说就是让一个进程（我们的inject程序）能“操控”另一个进程（目标进程），比如读/写它的内存、改它的寄存器、让它单步执行，gdb调试器就是靠它实现的。
• 进程代码注入：不是启动新进程，而是把我们的代码塞到已经在运行的进程内存里，让这个进程自己执行这段代码。
• clone系统调用：Linux里创建线程的底层调用（比我们常用的pthread_create更底层），这个PoC就是用它在目标进程里新建线程。
• mmap：给目标进程分配一块可读写/可执行的内存，用来放我们要注入的代码和新线程的栈——代码得有地方放，还得能跑起来。

这个PoC到底要干啥？

核心目标很明确：

1. 接收用户指定的“目标进程PID”和“要注入的代码文件”；
2. 用ptrace“接管”目标进程，获得操控权；
3. 在目标进程内存里分配三块专属内存（放注入代码、新线程栈、启动线程的引导代码）；
4. 把注入代码和引导代码写到目标进程内存里；
5. 触发clone创建新线程，让新线程执行我们的注入代码；
6. 恢复目标进程原本的运行状态，保证原进程不受影响；
7. 解除对目标进程的操控，完成注入。

实现流程（一张图看懂）

核心代码拆解（大白话版）

整个代码核心分为“参数解析、ptrace操控、内存分配、代码注入、线程创建”几块，挑关键的讲：

1. 参数解析（parse_args函数）

这部分就是“读用户输入”，处理-p（目标PID）和-f（注入代码文件路径）两个参数，存到settings结构体里。如果用户没输PID或代码文件，直接报错退出——总不能瞎注入吧？

voidparse_args(int argc, char **argv)
{
int opt;
// 解析-p和-f参数
while ((opt = getopt(argc, argv, "p:f:")) != -1) {
switch (opt) {
case'p': settings.pid = atoi(optarg); break; // 存PID
case'f': settings.payload = strdup(optarg); break; // 存代码文件路径
default:  fprintf(stderr, "用法：%s [-p 进程PID] [-f 注入代码文件]\n", argv[0]); exit(1);
        }
    }
// 校验参数合法性
if (settings.pid < 0 || !settings.payload) {
fprintf(stderr, "PID不合法或未指定注入代码文件\n");
exit(1);
    }
}

2. 核心：临时替换执行流（inject_code函数）

这是整个PoC最精髓的部分——让目标进程“临时”执行我们的代码，执行完还能恢复原样，相当于“借鸡下蛋”。

uint64_tinject_code(struct ptrace_info *info, uint8_t *code, size_t code_len)
{
structuser_regs_structregs, tmpregs;
uint8_t orig_code[code_len];

// 1. 读目标进程当前寄存器状态
    ptrace_getregs(info, &regs);
// 2. 保存目标进程当前要执行的代码（怕改乱了）
    ptrace_readmem(info, (void *)regs.rip, orig_code, sizeof(orig_code));
// 3. 把我们的代码写到目标进程当前指令位置
    ptrace_writemem(info, (void *)regs.rip, code, code_len);
// 4. 让目标进程继续执行，跑我们的代码
    ptrace_continue(info);
// 5. 恢复目标进程原来的代码
    ptrace_writemem(info, (void *)regs.rip, orig_code, sizeof(orig_code));
// 6. 读执行后的寄存器（RAX里是我们代码的返回值）
    ptrace_getregs(info, &tmpregs);
// 7. 恢复原寄存器状态，目标进程像没被改过一样
    ptrace_setregs(info, &regs);

// 返回我们代码的执行结果（比如mmap分配的内存地址）
return tmpregs.rax;
}

大白话解释：就像你趁同学写作业的间隙，偷偷拿他的笔写了一行字，写完把笔还给他，他完全没察觉——目标进程的执行流被我们临时改了，执行完我们的代码就恢复原样，只留下执行结果。

3. 给目标进程分配内存（inject_mmap函数）

我们没法直接给目标进程分配内存，所以用上面的inject_code，让目标进程自己调用mmap分配内存：

uint64_tinject_mmap(struct ptrace_info *info, int size, int prot)
{
uint8_t code[1024];
int code_len;

// 1. 构造mmap的汇编代码（让目标进程自己调mmap）
    code_len = asm_mmap(code, 0, size, prot, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    code_len += int3(code + code_len); // 加中断，方便控制

// 2. 让目标进程执行这段汇编，返回分配的内存地址
return inject_code(info, code, code_len);
}

4. 创建新线程（inject_clone函数）

这是注入的核心步骤，先读入要注入的代码，再分配内存，最后触发clone创建新线程：

voidinject_clone(struct ptrace_info *info)
{
    FILE *fp;
uint8_t code_to_exec[1024], clone_code[1024];
int stack_size = 2 * PAGE_SIZE, clone_code_size, codelen;
uint64_t stack_addr, text_addr, bootstrap;
structuser_regs_structorig_regs;

// 1. 读入要注入的代码文件
if (!(fp = fopen(settings.payload, "r"))) { perror("打开代码文件失败"); return; }
    codelen = fread(code_to_exec, 1, sizeof(code_to_exec), fp);
    fclose(fp);

// 2. 单步执行直到跳出SO（避免改共享库代码，更安全）
    step_until_no_longer_inside_SO(info, 1024);

// 3. 保存原寄存器状态（后续恢复）
    ptrace_getregs(info, &orig_regs);

// 4. 分配三块内存：存注入代码、线程栈、引导代码
    text_addr = inject_mmap(info, PAGE_SIZE, PROT_READ|PROT_EXEC); // 注入代码
    stack_addr = inject_mmap(info, stack_size, PROT_READ|PROT_WRITE); // 线程栈
    bootstrap = inject_mmap(info, PAGE_SIZE, PROT_READ|PROT_EXEC); // 引导代码

// 5. 把注入代码写到分配的内存里
    ptrace_writemem(info, (void *)text_addr, code_to_exec, codelen);

// 6. 构造clone汇编代码，写到引导内存里
    clone_code_size = asm_clone(clone_code, stack_addr + stack_size, text_addr);
    ptrace_writemem(info, (void *)bootstrap, clone_code, clone_code_size);

// 7. 改目标进程的指令指针（RIP），指向引导代码
structuser_regs_structregs = orig_regs;
    regs.rip = bootstrap;
    ptrace_setregs(info, &regs);
    ptrace_continue(info); // 执行clone，创建新线程

// 8. 恢复原寄存器状态，原线程正常运行
    ptrace_setregs(info, &orig_regs);
}

相关领域知识点（必懂）

这个PoC看着代码不多，但涉及Linux底层的核心知识点：

1. ptrace调试机制：Linux调试器的基础，需要root或相同UID权限，能实现进程暂停、内存读写、寄存器修改、单步执行——是整个注入的“操控杆”。
2. Linux线程模型：Linux里没有“线程”的专属概念，线程本质是“共享地址空间的进程”，由clone系统调用创建（带CLONE_VM等参数），这也是为什么用clone而不是fork（fork会创建独立进程）。
3. 内存保护机制：默认情况下，进程内存要么“可读可写”，要么“可读可执行”（NX保护），我们用mmap分配“可读可执行”的内存，是代码能运行的前提。
4. x86_64寄存器：RIP是“指令指针”（指向当前要执行的代码），改它就能让进程执行我们的代码；RAX是系统调用返回值寄存器，能拿到mmap/clone的执行结果。
5. 上下文恢复：修改目标进程后必须恢复寄存器和代码，否则目标进程会崩溃——这是“无痕注入”的关键。

实战验证（跟着做就行）

参考项目里的例子，几步就能验证：

1. 编译代码：cd src && make；
2. 启动目标进程：./dummy &（让它后台运行）；
3. 注入代码：./inject -p $(pidof dummy) -f ./count；
4. 验证线程：ps -eLF | head -1; ps -eLF | grep dummy——能看到dummy进程有多个线程，说明新线程创建成功。

If you need the complete source code, please add the WeChat number (c17865354792)

总结

1. 这个PoC的核心是利用ptrace操控目标进程，让其自行完成内存分配、线程创建，从而运行注入的代码，全程不破坏原进程的执行逻辑；
2. 关键技巧是“临时替换执行流+上下文恢复”，保证原进程正常运行，只新增线程执行自定义代码；
3. 整个实现依赖Linux的ptrace、mmap、clone三大系统调用，以及x86_64架构的寄存器操作。

这种技术本身是中性的：合法场景下可用于进程调试、热修复（不用重启进程更新代码）、性能分析；但被恶意使用时，就是木马注入、提权的工具。Linux也有ptrace_scope（限制ptrace使用）、ASLR（地址随机化）、NX保护等机制对抗这类注入，这也是系统安全的重要环节。

Welcome to follow WeChat official account【程序猿编码】