C++ Linux x64堆栈展开内部信号处理程序，用于修改返回地址

我正在尝试修改调用堆栈上的返回地址（向下一些级别）。当我在信号处理器中时，我需要这样做。因此，我正在做以下工作：

#include <csignal>
#include <cstdint>
#include <iostream>

// To print stacktrace
#include <execinfo.h>
#include <stdlib.h>

void printAround(uint64_t* p, int min=0, int max=3) {
    for(int i = min; i <= max; ++i) {
        std::cout << std::dec << ((i >= 0) ? " " : "") << i << ": "
                  << std::hex
                  << reinterpret_cast<uint64_t>(*(p + i))
                  << std::dec << std::endl;
    }
    std::cout << "================================================" << std::endl;
}

void sigHandler(int signum) {
    register uint64_t* EBP asm ("rbp");
    printAround(EBP);

    uint64_t *oldEBP = reinterpret_cast<uint64_t*>(*EBP);
    printAround(oldEBP);

    oldEBP = reinterpret_cast<uint64_t*>(*oldEBP);
    printAround(oldEBP);

    /* PRINT STACK TRACE!! POSSIBLY UNSAFE! */
    void *array[10];
    size_t size;
    char **strings;
    size_t i;
    size = backtrace(array, 10);
    strings = backtrace_symbols(array, size);
    std::cout << "\nObtained " << size << " stack frames.\n";
    for (i = 0; i < size; i++) {
        std::cout << strings[i] << "\n";
    }
    free(strings);
    /* END PRINT STACK TRACE !! */
}

int foo(void) {
    std::raise(SIGTRAP);
    return 5;
}

int baz(void) {
    return foo() + 10;
}

int bar(void) {
    return baz() + 15;
}

int main(int argc, char **argv) {
    // SIGTRAP is 0xCC
    std::signal(SIGTRAP, &sigHandler);
    return bar();
}

偏移量0处是上一个堆栈的基指针，偏移量1处是返回地址

从输出中可以看出，第一个返回地址是libc中的第一个函数，但下一个已经是

baz

，而不是

foo

，或者我所期望的另一个libc函数

当我移除信号处理器并将用于打印堆栈的逻辑放入

foo

时，我看到了我的所有函数：

foo

，

baz

，

bar

，

main

我错过了什么？我确实需要修改触发信号的函数的返回地址，即foo，但在堆栈展开逻辑中跳过了这个函数：（

另外，我知道在信号处理程序中使用回溯[2]是不安全的，因为它会导致未定义的行为！似乎我在这里很幸运，当我删除所有回溯逻辑时，问题仍然存在

另外，如果有人对如何解决这个问题有任何其他想法，我很高兴与大家分享。我曾尝试使用

\uuu builtin\u frame\u address（）

并使用参数>0，但这在信号处理程序[1]中崩溃。似乎有一些不同的想法，我找不到关于什么的任何信息

[1]

---

[2] 嗯，我从哪里开始

首先，我担心x64默认情况下没有帧指针，因此没有简单的方法通过遵循

rbp

s链来重建堆栈。此外，即使您重新编译了所有参与的代码（包括Glibc！）使用

-fno省略帧指针

信号处理程序的帧可能是由内核以一种非常特殊的方式设置的，因此不能保证您能够通过帧指针将其释放。顺便说一句，这可能是

内置帧地址

运行时失败的原因

接下来，您提到您希望通过更改编译器背后的返回地址来释放。没有什么比这更容易导致运行时崩溃。编译器在函数帧中保存了大量关键信息。这些信息通过调用函数和被调用函数之间的严格约定（所谓的“调用约定”）来保留。通过更改返回地址，您将丢弃所有这些信息，并且很可能返回到目标代码，其中寄存器中包含随机垃圾

---

实现堆栈展开的唯一合理方法是使用（或至少重新实现）现有的展开器（in，或最好是in）。

从信号处理程序中修改返回地址的解决方案首先需要一种不同的方法来注册信号处理程序

首先，代码：

#include <csignal>
#include <cstdint>
#include <iostream>

void signal_handler(int signal, siginfo_t *si, void *context)
{
    const int return_delta = 2;
    ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] += return_delta;
}


int foo(void)
{
    asm(".byte 0xcc\n");

    // "for(;;) ;" in a way that prevents the compiler from recognizing the
    // remainder of the function as dead code and optimizing it away...
    asm(".byte 0xEB\n");
    asm(".byte 0xFE\n");

    return 5;
}


int baz(void) {
    return foo() + 10;
}


int bar(void) {
    return baz() + 15;
}


int main(int argc, char **argv)
{
    struct sigaction sa = {0};
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction = signal_handler;
    sa.sa_flags = SA_SIGINFO;

    // Install signal handler
    sigaction(SIGTRAP, &sa, NULL);

    // So that we see some output
    size_t i{1000};
    while(i--) {
        std::cout << bar() << std::endl;
    }
    return 0;
}

#包括
#包括
#包括
无效信号处理程序（int信号、siginfo\u t*si、void*上下文）
{
const int return_delta=2；
（（ucontext\u t*）context）->uc\u mcontext.gregs[REG\u RIP]+=return\u delta；
}
int foo（无效）
{
asm（“.byte 0xcc\n”）；
//“for（；）；”以防止编译器识别
//函数的剩余部分作为死代码，并对其进行优化。。。
asm（“.byte 0xEB\n”）；
asm（“.byte 0xFE\n”）；
返回5；
}
内塔巴兹（空）{
返回foo（）+10；
}
内栏（空）{
返回baz（）+15；
}
int main（int argc，字符**argv）
{
结构sigaction sa={0}；
sigemptyset（和sa.sa_面具）；
sa.sa_sigaction=信号处理器；
sa.sa_flags=sa_SIGINFO；
//安装信号处理器
sigation（SIGTRAP，&sa，NULL）；
//所以我们看到了一些输出
大小{1000}；
而(我--){
STD:（代码1）<代码> STD:：CUT 1）抱歉删除了错误的标签，有两个和删除了C++ 2。我该怎么办？用一个空格输出的信号处理程序，写一些数据结构，我后来打印到STDUT了？这对我的问题有帮助吗？我是说打印和调用函数会导致这种“意外行为”吗？不是异步安全的。（基本上是因为它可以在内部调用malloc（），这不是异步安全的）。最好的方法可能是使用全局（静态）缓冲区。坏消息是：sprintf（）也不是异步安全的：-[我想你可能想使用
uintpttr\t
而不是
uint64\t
，以便更便于移植。。。
#include <csignal>
#include <cstdint>
#include <iostream>

void signal_handler(int signal, siginfo_t *si, void *context)
{
    const int return_delta = 2;
    ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] += return_delta;
}


int foo(void)
{
    asm(".byte 0xcc\n");

    // "for(;;) ;" in a way that prevents the compiler from recognizing the
    // remainder of the function as dead code and optimizing it away...
    asm(".byte 0xEB\n");
    asm(".byte 0xFE\n");

    return 5;
}


int baz(void) {
    return foo() + 10;
}


int bar(void) {
    return baz() + 15;
}


int main(int argc, char **argv)
{
    struct sigaction sa = {0};
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction = signal_handler;
    sa.sa_flags = SA_SIGINFO;

    // Install signal handler
    sigaction(SIGTRAP, &sa, NULL);

    // So that we see some output
    size_t i{1000};
    while(i--) {
        std::cout << bar() << std::endl;
    }
    return 0;
}