[原创]ptrace注入代码在不同平台的区别（ARM64、x86-64、MIPS64）-编程技术-看雪安全社区

[原创]ptrace注入代码在不同平台的区别（ARM64、x86-64、MIPS64）

发表于: 2026-4-5 00:19 10712

[原创]ptrace注入代码在不同平台的区别（ARM64、x86-64、MIPS64）

plight

2026-4-5 00:19

10712

> **⚠️ 免责声明**：本文仅供学习和研究目的，介绍 ptrace 在 Linux 系统编程中的技术细节。ptrace 是 Linux 提供的标准系统调用，广泛用于调试器（如 gdb）开发。使用 ptrace 需要 root 权限，且应遵守相关法律法规。请勿将本文技术用于非法目的。

之前学过 ARM64(aarch64) 的 ptrace 注入，最近尝试使用 ptrace 在 x86-64 上注入时，发现两者实现上有些区别，在ARM64上能成功注入的代码，修改相关寄存器和调用约定之后在x86-64上却一直注入失败 (dlopen返回一个很小的值，比如0x8e，正常情况下dlopen应该返回一个堆地址）。本文用来说明两个平台之间的ptrace注入代码区别，方便后面参考。**2026.4.20 补充MIPS64的ptrace注入**

-----

# ptrace

ptrace 是 Linux 提供的一个系统调用，允许一个进程（tracer）观察和控制另一个进程（tracee）的执行。它是调试器（如 gdb）和进程注入技术的基础。**如果想要操作其它进程，需要有root权限。**

ptrace 的核心能力包括：

- **读写目标进程内存**：通过 `PTRACE_PEEKDATA` / `PTRACE_POKEDATA` 读写目标进程的内存内容。
- **读写目标进程寄存器**：通过 `PTRACE_GETREGS` / `PTRACE_SETREGS` 获取和修改目标进程的寄存器状态。
- **控制目标进程执行**：通过 `PTRACE_CONT`、`PTRACE_SINGLESTEP` 等控制目标进程的继续执行或单步执行。
- **附加/分离目标进程**：通过 `PTRACE_ATTACH` / `PTRACE_DETACH` 附加到目标进程或从目标进程分离。

基本的函数原型：

```c
long ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data);
```

# 注入流程

ptrace 注入的核心思路是：附加到目标进程，让目标进程调用 `dlopen` 来加载我们指定的 so 库，从而在目标进程中执行我们的代码。

通用的注入流程如下：

1. **附加目标进程**：调用 `ptrace(PTRACE_ATTACH, pid, ...)` 附加到目标进程，目标进程会收到 `SIGSTOP` 信号暂停执行。
2. **保存寄存器现场**：调用 `ptrace(PTRACE_GETREGS, pid, ...)` 保存目标进程当前的寄存器状态，以便注入完成后恢复。
3. **获取目标进程中的关键函数地址**：在目标进程的内存空间中找到 `dlopen`、`dlsym`、`dlclose` 等函数的地址。由于 ASLR 的存在，同一个库在不同进程中的加载地址是不同的，但**同一个库内部函数的偏移是固定的**。因此可以通过以下公式计算：

```
   远程函数地址 = 本进程函数地址 - 本进程模块基址 + 目标进程模块基址
   ```

具体步骤：
   - 在注入工具（本进程）中，通过 `dlsym` 获取 `dlopen` 的地址，记为 `local_dlopen_addr`
   - 解析 `/proc/self/maps`，找到 `dlopen` 所在模块（如 `libc.so`）的基地址，记为 `local_base`
   - 解析 `/proc/<pid>/maps`，找到目标进程中同一模块的基地址，记为 `remote_base`
   - 计算偏移：`offset = local_dlopen_addr - local_base`
   - 得到目标进程中的地址：`remote_dlopen_addr = remote_base + offset`

这个方法的前提是**注入工具和目标进程加载了同一版本的库**，这在同一台机器上通常是成立的。
4. **向目标进程内存写入参数**：将 so 库路径字符串等参数写入目标进程的内存中（通常写入栈上或 mmap 的内存区域）。
5. **设置寄存器，调用 dlopen**：按照目标平台的调用约定设置寄存器和栈，使目标进程执行 `dlopen` 调用。
6. **触发执行并等待返回**：让目标进程继续执行，等待调用完成。
7. **获取返回值**：读取寄存器获取 `dlopen` 的返回值（so 库的句柄/基址）。
8. **恢复寄存器现场并分离**：将之前保存的寄存器状态恢复，调用 `ptrace(PTRACE_DETACH, pid, ...)` 分离目标进程，目标进程继续正常执行。

虽然整体流程在两个平台上是一致的，但第 5 步和第 6 步的具体实现因平台差异而有所不同，这也是本文的重点。

# ARM64下的注入

## 寄存器与调用约定

ARM64 调用约定：

- **参数传递**：前 8 个参数通过 `x0` - `x7` 寄存器传递。
- **返回值**：通过 `x0` 寄存器返回。
- **程序计数器**：`pc` 寄存器，指向将要执行的指令。
- **栈顶指针**：`sp` 寄存器。
- **链接寄存器**：`lr`（即 `x30`），保存函数返回地址。

## 寄存器结构体

ARM64 使用 `struct user_pt_regs` 或通过 `iovec` 配合 `PTRACE_GETREGSET` 来获取寄存器：

```c
struct user_pt_regs {
    __u64 regs[31];  // x0 - x30
    __u64 sp;
    __u64 pc;
    __u64 pstate;
};

// 获取寄存器
struct iovec iov;
struct user_pt_regs regs;
iov.iov_base = &regs;
iov.iov_len = sizeof(regs);
ptrace(PTRACE_GETREGSET, pid, (void*)NT_PRSTATUS, &iov);
```

## 调用dlopen

在 ARM64 上调用 `dlopen` 的设置比较直观：

```c
// 设置参数
regs.regs[0] = so_path_addr;   // x0 = 第一个参数：so库路径地址
regs.regs[1] = RTLD_NOW;       // x1 = 第二个参数：dlopen flags
regs.pc = dlopen_addr;          // pc = dlopen 函数地址
regs.regs[30] = 0;              // lr = 0，使 dlopen 返回后触发 SIGSEGV

ptrace(PTRACE_SETREGSET, pid, (void*)NT_PRSTATUS, &iov);
ptrace(PTRACE_CONT, pid, NULL, NULL);
// 等待目标进程触发 SIGSEGV（因为 lr = 0，dlopen 返回后会跳转到地址 0）
waitpid(pid, &status, 0);
```

ARM64 的关键点：
- 将 `lr`（x30）设置为 0。当 `dlopen` 执行完毕后，会尝试返回到 `lr` 指向的地址（即地址 0），这会触发 `SIGSEGV` 信号。
- 通过 `waitpid` 捕获这个 `SIGSEGV` 信号，就知道 `dlopen` 已经执行完毕。
- 此时读取 `x0` 寄存器即可获得 `dlopen` 的返回值。

## 注入工具
下面是完整的 ARM64 (Android) 上的 ptrace 注入代码（**如果要注入Android APP，需要将so放在app对应的lib目录下，因为有selinux的限制**）。
```c
// injector_arm64.c - ARM64 ptrace 注入工具
// 用法: ./injector_arm64 <pid> <so_absolute_path>
// 需要 root 权限

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/uio.h>
#include <sys/mman.h>
#include <linux/elf.h>
#include <dlfcn.h>
#include <asm/ptrace.h>

// 获取寄存器（ARM64 使用 PTRACE_GETREGSET + iovec）
static int get_regs(pid_t pid, struct user_pt_regs *regs) {
    struct iovec iov;
    iov.iov_base = regs;
    iov.iov_len = sizeof(*regs);
    if (ptrace(PTRACE_GETREGSET, pid, (void *)NT_PRSTATUS, &iov) < 0) {
        perror("PTRACE_GETREGSET");
        return -1;
    }
    return 0;
}

// 设置寄存器
static int set_regs(pid_t pid, struct user_pt_regs *regs) {
    struct iovec iov;
    iov.iov_base = regs;
    iov.iov_len = sizeof(*regs);
    if (ptrace(PTRACE_SETREGSET, pid, (void *)NT_PRSTATUS, &iov) < 0) {
        perror("PTRACE_SETREGSET");
        return -1;
    }
    return 0;
}

// 从 /proc/pid/maps 中查找指定库的基地址
static long get_module_base(pid_t pid, const char *module_name) {
    char path[256];
    char line[512];
    long base = 0;

if (pid == 0)
        snprintf(path, sizeof(path), "/proc/self/maps");
    else
        snprintf(path, sizeof(path), "/proc/%d/maps", pid);

FILE *fp = fopen(path, "r");
    if (!fp) { perror("fopen maps"); return 0; }

while (fgets(line, sizeof(line), fp)) {
        if (strstr(line, module_name)) {
            base = strtol(line, NULL, 16);
            break;
        }
    }
    fclose(fp);
    return base;
}

// 通过地址查找其所在的模块名和模块基址
static int find_module_by_addr(void *addr, char *module_name, size_t name_len, long *base) {
    char line[512];
    FILE *fp = fopen("/proc/self/maps", "r");
    if (!fp) return -1;

unsigned long target = (unsigned long)addr;
    char found_module[256] = {0};

while (fgets(line, sizeof(line), fp)) {
        unsigned long start, end;
        if (sscanf(line, "%lx-%lx", &start, &end) != 2) continue;
        if (target >= start && target < end) {
            char *path = strrchr(line, '/');
            if (path) {
                char *nl = strchr(path, '\n');
                if (nl) *nl = '\0';
                strncpy(found_module, path, sizeof(found_module) - 1);
            }
            break;
        }
    }
    fclose(fp);
    if (found_module[0] == '\0') return -1;

*base = get_module_base(0, found_module);
    strncpy(module_name, found_module, name_len - 1);
    module_name[name_len - 1] = '\0';
    return 0;
}

// 计算目标进程中某函数的地址（自动检测所在模块）
static long get_remote_func_addr(pid_t pid, void *local_func) {
    char module_name[256];
    long local_base;

if (find_module_by_addr(local_func, module_name, sizeof(module_name), &local_base) < 0) {
        fprintf(stderr, "Failed to find module for addr %p\n", local_func);
        return 0;
    }

long remote_base = get_module_base(pid, module_name);
    if (!local_base || !remote_base) {
        fprintf(stderr, "Failed to get module base for %s\n", module_name);
        return 0;
    }

return remote_base + ((long)local_func - local_base);
}

// 在远程进程中调用一个函数，最多支持 6 个参数
// 原理: 设置 x0-x5 为参数, pc 为函数地址, lr = 0
//       PTRACE_CONT 后等待 SIGSEGV (因为 lr=0, ret 跳转到地址 0)
//       读取 x0 获取返回值
static long call_remote_func(pid_t pid, struct user_pt_regs *orig_regs,
                             long func_addr,
                             long arg0, long arg1, long arg2,
                             long arg3, long arg4, long arg5) {
    // 基于原始寄存器来设置，保证 sp 等关键寄存器正确
    struct user_pt_regs regs;
    memcpy(&regs, orig_regs, sizeof(regs));

regs.regs[0] = arg0;       // x0 - x5: 参数
    regs.regs[1] = arg1;
    regs.regs[2] = arg2;
    regs.regs[3] = arg3;
    regs.regs[4] = arg4;
    regs.regs[5] = arg5;
    regs.pc = func_addr;        // pc = 目标函数地址
    regs.regs[30] = 0;          // lr = 0，函数返回时触发 SIGSEGV

if (set_regs(pid, &regs) < 0) return -1;

if (ptrace(PTRACE_CONT, pid, NULL, NULL) < 0) {
        perror("PTRACE_CONT");
        return -1;
    }

int status;
    waitpid(pid, &status, WUNTRACED);

// 读取返回值 (ARM64 返回值在 x0)
    if (get_regs(pid, &regs) < 0) return -1;
    return (long)regs.regs[0];
}

// 向目标进程写入数据（以 long 为单位，按需补齐）
static int ptrace_write_data(pid_t pid, unsigned long addr, const void *data, size_t len) {
    const unsigned char *src = (const unsigned char *)data;
    size_t i = 0;

for (i = 0; i + sizeof(long) <= len; i += sizeof(long)) {
        long val;
        memcpy(&val, src + i, sizeof(long));
        if (ptrace(PTRACE_POKEDATA, pid, (void *)(addr + i), (void *)val) < 0) {
            perror("PTRACE_POKEDATA");
            return -1;
        }
    }
    if (i < len) {
        long val = ptrace(PTRACE_PEEKDATA, pid, (void *)(addr + i), NULL);
        memcpy(&val, src + i, len - i);
        if (ptrace(PTRACE_POKEDATA, pid, (void *)(addr + i), (void *)val) < 0) {
            perror("PTRACE_POKEDATA tail");
            return -1;
        }
    }
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "用法: %s <pid> <so_absolute_path>\n", argv[0]);
        return 1;
    }

pid_t pid = atoi(argv[1]);
    const char *so_path = argv[2];
    int status;

// 1. 附加目标进程
    if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) {
        perror("PTRACE_ATTACH");
        return 1;
    }
    waitpid(pid, &status, WUNTRACED);

// 2. 保存原始寄存器
    struct user_pt_regs orig_regs;
    if (get_regs(pid, &orig_regs) < 0) {
        ptrace(PTRACE_DETACH, pid, NULL, NULL);
        return 1;
    }

// 3. 在远程进程中调用 mmap 分配内存
    long remote_mmap = get_remote_func_addr(pid, (void *)mmap);
    long mmap_result = call_remote_func(pid, &orig_regs, remote_mmap,
        0, 0x1000, PROT_READ | PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

if (mmap_result == -1 || mmap_result == 0) {
        fprintf(stderr, "[-] 远程 mmap 失败\n");
        set_regs(pid, &orig_regs);
        ptrace(PTRACE_DETACH, pid, NULL, NULL);
        return 1;
    }
    printf("[+] 远程 mmap 成功, 地址: 0x%lx\n", mmap_result);

// 4. 将 so 路径写入 mmap 分配的内存
    ptrace_write_data(pid, (unsigned long)mmap_result, so_path, strlen(so_path) + 1);

// 5. 获取远程 dlopen 地址并调用
    void *local_dlopen = dlsym(RTLD_DEFAULT, "dlopen");
    long remote_dlopen = get_remote_func_addr(pid, local_dlopen);
    long dlopen_ret = call_remote_func(pid, &orig_regs, remote_dlopen,
        mmap_result, RTLD_NOW, 0, 0, 0, 0);

printf("[+] dlopen 返回值: 0x%lx\n", dlopen_ret);
    if (dlopen_ret == 0)
        printf("[-] dlopen 失败！\n");
    else
        printf("[+] 注入成功！handle = 0x%lx\n", dlopen_ret);

// 6. 恢复寄存器现场并分离
    set_regs(pid, &orig_regs);
    ptrace(PTRACE_DETACH, pid, NULL, NULL);
    return 0;
}
```

## ARM64 (Android) 注入踩坑：SO 路径不能直接写到栈上

上面的调用约定和寄存器设置看起来很简单，但在 Android 手机上实际测试时发现，不能直接把 SO 路径写入目标进程的栈空间。

最初的实现：

```c
// ❌ 错误做法：直接写到栈上
unsigned long path_addr = (regs.sp - path_len) & ~0xF;
regs.sp = path_addr - 128;
ptrace_write_data(pid, path_addr, so_path, path_len);

regs.regs[0] = path_addr;   // x0 = so 路径
regs.regs[1] = RTLD_NOW;    // x1 = flags
regs.pc = dlopen_addr;
regs.regs[30] = 0;          // lr = 0
```

运行结果：`dlopen` 的返回值恰好等于我们传入的 `path_addr`，说明 `x0` 根本没有被修改——`dlopen` 没有真正执行。

**原因**：在 Android 上，`dlopen` 内部的 linker 实现对内存区域有要求。直接写在栈上的路径字符串，可能因为 linker 内部的内存访问检查等原因导致执行异常。

**解决方法**：先在目标进程中调用 `mmap` 分配一块独立的内存，再将 SO 路径写入这块内存：

```c
// ✅ 正确做法：先 mmap 分配内存，再写入路径
// 1. 远程调用 mmap
long mmap_result = call_remote_func(pid, &orig_regs, remote_mmap,
    0, 0x1000, PROT_READ | PROT_WRITE,
    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

// 2. 将路径写入 mmap 分配的内存
ptrace_write_data(pid, mmap_result, so_path, path_len);

// 3. 用 mmap 的地址作为 dlopen 的参数
long dlopen_ret = call_remote_func(pid, &orig_regs, remote_dlopen,
    mmap_result, RTLD_NOW, 0, 0, 0, 0);
```

# x86-64下的注入

x86-64 的 ptrace 注入流程和 ARM64 基本一致，但在调用约定和返回地址处理上有重要差异。下面按照相同的结构介绍，并说明两个平台的关键区别。

## 寄存器与调用约定

x86-64 调用约定：

- **参数传递**：前 6 个整数参数依次通过 `rdi`、`rsi`、`rdx`、`rcx`、`r8`、`r9` 传递
- **返回值**：通过 `rax` 寄存器返回
- **程序计数器**：`rip` 寄存器
- **栈指针**：`rsp` 寄存器
- **没有链接寄存器**：x86-64 使用栈来保存返回地址，`call` 指令自动压栈，`ret` 指令自动弹栈

## 寄存器结构体

x86-64 使用 `struct user_regs_struct`，通过 `PTRACE_GETREGS` 获取：

```c
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, NULL, &regs);
```

## 调用 dlopen（错误的方式）

按照 ARM64 的思路，直接设置寄存器调用 dlopen：

```c
// 设置参数
regs.rdi = path_addr;       // rdi = so 路径
regs.rsi = RTLD_NOW;        // rsi = flags
regs.rip = dlopen_addr;     // rip = dlopen 函数地址

// 模拟 call 指令：将返回地址压栈
regs.rsp -= 8;
ptrace(PTRACE_POKEDATA, pid, (void *)regs.rsp, (void *)0);  // 返回地址设为 0

ptrace(PTRACE_SETREGS, pid, NULL, &regs);
ptrace(PTRACE_CONT, pid, NULL, NULL);
// 等待 SIGSEGV（因为返回地址为 0）
waitpid(pid, &status, 0);
```

完整代码如下：
```c
// x86-64 ptrace 注入工具
// 用法: ./injector_x86_64 <pid> <so_absolute_path>
// 需要 root 权限
// 参考 ARM64 实现：先 mmap 分配内存，再写入 SO 路径，最后调用 dlopen

// 获取寄存器
static int get_regs(pid_t pid, struct user_regs_struct *regs) {
    if (ptrace(PTRACE_GETREGS, pid, NULL, regs) < 0) {
        perror("PTRACE_GETREGS");
        return -1;
    }
    return 0;
}

// 设置寄存器
static int set_regs(pid_t pid, struct user_regs_struct *regs) {
    if (ptrace(PTRACE_SETREGS, pid, NULL, regs) < 0) {
        perror("PTRACE_SETREGS");
        return -1;
    }
    return 0;
}