如何使用 ptrace 找到 CALL 和 RET 号码？

Question

我正在尝试在 x86_64（英特尔语法）中动态查找程序在运行时调用和 returned 的函数数。

为此，我正在使用 ptrace（没有 PTRACE_SYSCALL），我正在检查 RIP 寄存器（包含下一个指令地址），我正在检查他的操作码。我知道如果 LSB 等于 0xE8（根据 Intel 文档，或 http://icube-avr.unistra.fr/fr/images/4/41/253666.pdf 第 105 页），可以找到函数 CALL。

我在http://ref.x86asm.net/coder64.html上找到了每条指令，所以在我的程序中，每次我找到0xE8、0x9A、0xF1等...我都找到了一个函数入口（CALL或INT指令），如果它是一个 0xC2、0XC3 等...这是一个函数 leave（RET 指令）。

目标是在运行时在每个程序上找到它，我无法访问测试程序的编译、检测或使用 gcc 的魔术工具。

我制作了一个小程序，可以用 gcc -Wall -Wextra your_file.c 编译并通过键入 ./a.out a_program 启动。

这是我的代码：

#include <sys/ptrace.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <sys/user.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

typedef struct user_regs_struct    reg_t;

static int8_t       increase(pid_t pid, int32_t *status)
{
        if (WIFEXITED(*status) || WIFSIGNALED(*status))
                return (-1);
        if (WIFSTOPPED(*status) && (WSTOPSIG(*status) == SIGINT))
                return (-1);
        if (ptrace(PTRACE_SINGLESTEP, pid, NULL, NULL) == -1)
                return (-1);
        return (0);
}

int                 main(int argc, char *argv[])
{
    size_t          pid = fork();
    long            address_rip;
    uint16_t        call = 0;
    uint16_t        ret = 0;
    int32_t         status;
    reg_t           regs;

    if (!pid) {
            if ((status = ptrace(PTRACE_TRACEME, 0, NULL, NULL)) == -1)
                    return (1);
            kill(getpid(), SIGSTOP);
            execvp(argv[1], argv + 1);
    } else {
            while (42) {
                    waitpid(pid, &status, 0);
                    ptrace(PTRACE_GETREGS, pid, NULL, &regs);
                    address_rip = ptrace(PTRACE_PEEKDATA, pid, regs.rip, NULL);
                    address_rip &= 0xFFFF;
                    if ((address_rip & 0x00FF) == 0xC2 || (address_rip & 0x00FF) == 0xC3 ||
                        (address_rip & 0x00FF) == 0xCA || (address_rip & 0x00FF) == 0xCB ||
                        (address_rip & 0x00FF) == 0xCF)
                            ret += 1;
                    else if ((address_rip & 0x00FF) == 0xE8 || (address_rip & 0x00FF) == 0xF1 ||
                             (address_rip & 0x00FF) == 0x9A || (address_rip & 0x00FF) == 0xCC ||
                             (address_rip & 0x00FF) == 0xCD || (address_rip & 0x00FF) == 0xCF)
                            call += 1;
                    if (increase(pid, &status) == -1) {
                            printf("call: %i\tret: %i\n", call, ret);
                            return (0);
                    }
            }
    }
    return (0);
}

当我运行它与 a_program （这是一个自定义程序，只需输入一些本地函数并执行一些写系统调用，目标只是跟踪输入/离开函数的数量这个程序），没有错误发生，它工作正常，但我没有相同数量的 CALL 和 RET。例子：

user> ./a.out basic_program

call: 636 ret: 651

(大量的call和ret是因为LibC在启动你的程序之前进入了很多函数，参见)

其实我的程序好像比函数调用多了return，但是我发现在(r/m64或r/m16/m32)中CALL或CALLF使用了0xFF指令，但也适用于其他指令，如 DEC、INC 或 JMP（非常常见的指令）。

那么，我该如何区分呢？根据 http://ref.x86asm.net/coder64.html 和“操作码字段”，但我如何找到它？

如果我将 0xFF 添加到我的条件中：

else if ((address_rip & 0x00FF) == 0xE8 || (address_rip & 0x00FF) == 0xF1 ||
         (address_rip & 0x00FF) == 0x9A || (address_rip & 0x00FF) == 0xCC ||
         (address_rip & 0x00FF) == 0xCD || (address_rip & 0x00FF) == 0xCF ||
         (address_rip & 0x00FF) == 0xFF)
                call += 1;

如果我启动它：

user> ./a.out basic_program

call: 1152 ret: 651

这对我来说似乎很正常，因为它会计算每个 JMP、DEC 或 INC，所以我需要区分每个 0xFF 指令。我试过这样做：

 else if ((address_rip & 0x00FF) == 0xE8 || (address_rip & 0x00FF) == 0xF1 ||
         (address_rip & 0x00FF) == 0x9A || (address_rip & 0x00FF) == 0xCC ||
         (address_rip & 0x00FF) == 0xCD || (address_rip & 0x00FF) == 0xCF ||
         ((address_rip & 0x00FF) == 0xFF && ((address_rip & 0x0F00) == 0X02 ||
         (address_rip & 0X0F00) == 0X03)))
                call += 1;

但它给了我同样的结果。我哪里错了吗？我怎样才能找到相同数量的调用和返回？

Answer 1

这是一个如何编程的例子。请注意，由于 x86 指令最长可达 16 个字节，因此必须查看 16 个字节以确保获得完整的指令。由于每次查看读取 8 个字节，这意味着您需要查看两次，一次在 regs.rip 处，一次在 8 个字节后：

peek1 = ptrace(PTRACE_PEEKDATA, pid, regs.rip, NULL);
peek2 = ptrace(PTRACE_PEEKDATA, pid, regs.rip + sizeof(long), NULL);

请注意，这段代码掩盖了很多关于如何处理前缀的细节，并将一堆无效指令检测为函数调用。进一步请注意，如果您想将其用于 32 位代码，则需要更改代码以包含更多 CALL 指令并删除对 REX 前缀的检测：

int iscall(long peek1, long peek2)
{
        union {
                long longs[2];
                unsigned char bytes[16];
        } data;

        int opcode, reg; 
        size_t offset;

        /* turn peeked longs into bytes */
        data.longs[0] = peek1;
        data.longs[1] = peek2;

        /* ignore relevant prefixes */
        for (offset = 0; offset < sizeof data.bytes &&
            ((data.bytes[offset] & 0xe7) == 0x26 /* cs, ds, ss, es override */
            || (data.bytes[offset] & 0xfc) == 0x64 /* fs, gs, addr32, data16 override */
            || (data.bytes[offset] & 0xf0) == 0x40); /* REX prefix */
            offset++)
                ;

        /* instruction is composed of all prefixes */
        if (offset > 15)
                return (0);

        opcode = data.bytes[offset];


        /* E8: CALL NEAR rel32? */
        if (opcode == 0xe8)
                return (1);

        /* sufficient space for modr/m byte? */
        if (offset > 14)
                return (0);

        reg = data.bytes[offset + 1] & 0070; /* modr/m byte, reg field */

        if (opcode == 0xff) {
                /* FF /2: CALL NEAR r/m64? */
                if (reg == 0020)
                        return (1);

                /* FF /3: CALL FAR r/m32 or r/m64? */
                if (reg == 0030)
                        return (1);
        }

        /* not a CALL instruction */
        return (0);
}

Answer 2

我个人会运行跟踪一条指令 "late"，保留上一步的 rip 和 rsp。为简单起见，假设 curr_rip 和 curr_rsp 是从最近的 PTRACE_GETREGS 获得的 rip 和 rsp 寄存器，而 prev_rip 和 prev_rsp 来自上一个。

如果(curr_rip < prev_rip || curr_rip > prev_rip + 16)，则指令指针要么向后移动，要么向前移动超过最长有效指令的长度。如果是这样，那么：

如果(curr_rsp > prev_rsp)，最后一条指令是某种ret，因为数据也从堆栈中弹出。
如果(curr_rsp < prev_rsp)，最后一条指令是某种call，因为数据也被压入堆栈。
如果(curr_rsp == prev_rsp)，指令是某种跳转；要么无条件跳转，要么分支。

换句话说，当(curr_rsp != prev_rsp && curr_rip > prev_rip && curr_rip <= prev_rip + 16时，您只需要检查从prev_rip开始的指令（curr_rip - prev_rip字节，介于1和16之间，包括）。为此，我会使用 Intel XED，但您当然可以自由实现自己的 call/ret 指令识别器。

如何使用 ptrace 找到 CALL 和 RET 号码？

How can I find CALL and RET number using ptrace?

c

assembly

ptrace

elf

opcode