假设我们有一个单线程程序，我们希望在发生预定义中断时捕获程序计数器（PC）的值（如定时器中断）。
看起来很容易，因为你知道我们只是使用一个特殊的关键字__asm__编写一个特定的汇编代码，并在转换4字节后弹出堆栈顶部的值。
多线程程序怎么样？
我们如何从同一进程中运行的另一个线程获取所有线程的值？ （从多线程处理器中的单独核心运行的线程获取值似乎非常不可思议）。 （在多线程程序中，每个线程都有它的堆栈和寄存器）。
我想实施一个破坏者线程。
为了在目标多线程程序中执行故障注入，故障模型是SEU（单个错误翻转），这意味着程序计数器寄存器中的任意位随机修改（位翻转）导致违反正确的程序序列。因此，出现控制流量误差（CFE）。
由于我们的目标程序是一个多线程程序，我们必须在所有线程的PC上执行故障注入。这是破坏者的任务。它应该能够获得线程的PC来执行故障注入。 假设我们有这个代码，
main ()
{
foo
}
void foo()
{
__asm__{
pop "%eax"
pop "%ebx" // now ebx holds porgram counter value (for main thread)
// her code injection like 00000111 XOR ebx for example
push ...
push ...
};
}
如果我们的程序是多线程程序。 是否意味着我们有多个堆栈？
当OS执行上下文切换时，这意味着正在运行的线程的堆栈和寄存器移动到内存中的某个位置。这是否意味着如果我们想要获取这些线程的程序计数器的值，我们会在内存中找到它们？哪里？是否可以在运行期间使用？
答案 0 :(得分：4)
在标志中使用带有SA_SIGINFO的{{3}}安装信号处理程序时，信号处理程序获取的第二个参数是指向siginfo_t的指针，第三个参数是指向ucontext_t。在Linux中，此结构包含内核中断线程时的寄存器值集，包括程序计数器。
#define _POSIX_C_SOURCE 200809L
#define _GNU_SOURCE
#include <signal.h>
#include <ucontext.h>
#if defined(__x86_64__)
#define PROGCOUNTER(ctx) (((ucontext *)ctx)->uc_mcontext.greg[REG_RIP])
#elif defined(__i386__)
#define PROGCOUNTER(ctx) (((ucontext *)ctx)->uc_mcontext.greg[REG_EIP])
#else
#error Unsupported architecture.
#endif
void signal_handler(int signum, siginfo_t *info, void *context)
{
const size_t program_counter = PROGCOUNTER(context);
/* Do something ... */
}
像往常一样，sigaction()等。不是 async-signal safe ，这意味着在信号处理程序中使用它们是不安全的。如果您希望将程序计数器输出到例如标准错误，您不应该使用任何标准I / O打印到stderr，而是构造要手动打印的字符串，并使用循环来printf()字符串的内容;例如，
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
static void wrerr(const char *p)
{
const int saved_errno = errno;
const char *q = p;
ssize_t n;
/* Nothing to print? */
if (!p || !*p)
return;
/* Find end of q. strlen() is not async-signal safe. */
while (*q) q++;
/* Write data from p to q. */
while (p < q) {
n = write(STDERR_FILENO, p, (size_t)(q - p));
if (n > 0)
p += n;
else
if (n != -1 || errno != EINTR)
break;
}
errno = saved_errno;
}
请注意，您希望在信号处理程序中保持errno的值不变，以便在库函数失败后中断，中断的线程仍会看到正确的errno值。 （这主要是一个调试问题，而且＃34;良好的形式＆＃34 ;;一些白痴呸呸as as＆＃it it it it it it it it it it）））））））））））））） / p>
您的程序可以检查/proc/self/maps伪文件（它不是真实文件，但是在读取文件时内核会动态生成的内容），以查看程序使用的内存区域，以确定是否当中断交付时，程序正在运行C库函数（非常常见）或其他东西。
如果您希望中断多线程程序中的特定线程，请使用write()。否则，信号会被传递给其中一个未阻塞信号的线程，或多或少随机。
这是一个示例程序，在使用-Wall -O2使用GCC-4.8.4编译时，在x86-64（AMD64）和x86中进行了测试：
#define _POSIX_C_SOURCE 200809L
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <ucontext.h>
#include <time.h>
#include <stdio.h>
#if defined(__x86_64__)
#define PROGRAM_COUNTER(mctx) ((mctx).gregs[REG_RIP])
#define STACK_POINTER(mctx) ((mctx).gregs[REG_RSP])
#elif defined(__i386__)
#define PROGRAM_COUNTER(mctx) ((mctx).gregs[REG_EIP])
#define STACK_POINTER(mctx) ((mctx).gregs[REG_ESP])
#else
#error Unsupported hardware architecture.
#endif
#define MAX_SIGNALS 64
#define MCTX(ctx) (((ucontext_t *)ctx)->uc_mcontext)
static void wrerr(const char *p, const char *q)
{
while (p < q) {
ssize_t n = write(STDERR_FILENO, p, (size_t)(q - p));
if (n > 0)
p += n;
else
if (n != -1 || errno != EINTR)
break;
}
}
static const char hexc[16] = "0123456789abcdef";
static inline char *prehex(char *before, size_t value)
{
do {
*(--before) = hexc[value & 15];
value /= (size_t)16;
} while (value);
*(--before) = 'x';
*(--before) = '0';
return before;
}
static volatile sig_atomic_t done = 0;
static void handle_done(int signum)
{
done = signum;
}
static int install_done(const int signum)
{
struct sigaction act;
memset(&act, 0, sizeof act);
sigemptyset(&act.sa_mask);
act.sa_handler = handle_done;
act.sa_flags = 0;
if (sigaction(signum, &act, NULL) == -1)
return errno;
return 0;
}
static size_t jump_target[MAX_SIGNALS] = { 0 };
static size_t jump_stack[MAX_SIGNALS] = { 0 };
static void handle_jump(int signum, siginfo_t *info, void *context)
{
const int saved_errno = errno;
char buffer[128];
char *p = buffer + sizeof buffer;
*(--p) = '\n';
p = prehex(p, STACK_POINTER(MCTX(context)));
*(--p) = ' ';
*(--p) = 'k';
*(--p) = 'c';
*(--p) = 'a';
*(--p) = 't';
*(--p) = 's';
*(--p) = ' ';
*(--p) = ',';
p = prehex(p, PROGRAM_COUNTER(MCTX(context)));
*(--p) = ' ';
*(--p) = '@';
wrerr(p, buffer + sizeof buffer);
if (signum >= 0 && signum < MAX_SIGNALS) {
if (jump_target[signum])
PROGRAM_COUNTER(MCTX(context)) = jump_target[signum];
if (jump_stack[signum])
STACK_POINTER(MCTX(context)) = jump_stack[signum];
}
errno = saved_errno;
}
static int install_jump(const int signum, void *target, size_t stack)
{
struct sigaction act;
if (signum < 0 || signum >= MAX_SIGNALS)
return errno = EINVAL;
jump_target[signum] = (size_t)target;
jump_stack[signum] = (size_t)stack;
memset(&act, 0, sizeof act);
sigemptyset(&act.sa_mask);
act.sa_sigaction = handle_jump;
act.sa_flags = SA_SIGINFO;
if (sigaction(signum, &act, NULL) == -1)
return errno;
return 0;
}
int main(int argc, char *argv[])
{
const struct timespec sec = { .tv_sec = 1, .tv_nsec = 0L };
const int pid = (int)getpid();
ucontext_t ctx;
printf("Run\n");
printf("\tkill -KILL %d\n", pid);
printf("\tkill -TERM %d\n", pid);
printf("\tkill -HUP %d\n", pid);
printf("\tkill -INT %d\n", pid);
printf("or press Ctrl+C to stop this process, or\n");
printf("\tkill -USR1 %d\n", pid);
printf("\tkill -USR2 %d\n", pid);
printf("to send the respective signal to this process.\n");
fflush(stdout);
if (install_done(SIGTERM) ||
install_done(SIGHUP) ||
install_done(SIGINT) ) {
printf("Cannot install signal handlers: %s.\n", strerror(errno));
return EXIT_FAILURE;
}
getcontext(&ctx);
if (install_jump(SIGUSR1, &&usr1_target, STACK_POINTER(MCTX(&ctx))) ||
install_jump(SIGUSR2, &&usr2_target, STACK_POINTER(MCTX(&ctx))) ) {
printf("Cannot install signal handlers: %s.\n", strerror(errno));
return EXIT_FAILURE;
}
/* These are expressions that should evaluate to false, but the compiler
* should not be able to optimize them away. */
if (argv[0][1] == 'A') {
usr1_target:
fputs("USR1\n", stdout);
fflush(stdout);
}
if (argv[0][1] == 'B') {
usr2_target:
fputs("USR2\n", stdout);
fflush(stdout);
}
while (!done) {
putchar('.');
fflush(stdout);
nanosleep(&sec, NULL);
}
fputs("\nAll done.\n", stdout);
fflush(stdout);
return EXIT_SUCCESS;
}
如果将上述内容保存为example.c，则可以使用
gcc -Wall -O2 example.c -o example
并运行它
./example
按 Ctrl + C 退出程序。复制命令（用于发送SIGUSR1和SIGUSR2信号），然后从另一个窗口运行它们，您将看到它们修改当前执行的位置。 （这些信号会导致程序计数器/指令指针跳回到if子句中，否则永远不会执行。）
有两组信号处理程序。 handle_done()只设置done标记。 handle_jump()向标准错误输出消息（使用低级I / O），如果指定，则更新程序计数器（指令指针）和堆栈指针。
在创建这样的示例程序时，堆栈指针是棘手的部分。如果我们对崩溃程序感到满意，那将是 easy 。但是，只有有效时，示例才有用。
当我们任意改变程序计数器/指令指针，并且在函数调用中传递中断时（大多数C库函数......），返回地址留在堆栈中。内核可以随时传递中断，所以我们甚至不能假设在函数调用时中断已经发送！因此，为了确保测试程序不会崩溃，我必须更新程序计数器/指令指针并将指针堆叠成一对。
当接收到跳转信号时，堆栈指针被重置为使用getcontext()获得的值I.这不能保证适合任何跳跃位置;它是我能做的最好的例子。我绝对认为跳转标签就在附近，而不是在编译器可能会弄乱堆栈的子范围内，请注意。
同样重要的是要记住，因为我们正在处理留给C编译器的细节，我们必须遵循编译器生成的任何二进制代码，而不是相反。为了可靠地处理进程及其线程，pthread_kill()是一个更好（并且诚实地，更容易）的接口。您只需设置父进程，并在目标跟踪子进程中明确允许跟踪。我已经展示了如何在目标流程中启动，停止和单步执行单个线程的ptrace()和examples here（都回答了同一个问题）。最难的部分是理解整体方案，概念;代码本身比这种信号处理程序上下文操作方式更容易 - 而且更强大。
对于自引入寄存器错误（编程计数器/指令指针或任何其他寄存器），假设大多数时间导致进程崩溃，此信号处理程序上下文操作应该足够。< / p>
答案 1 :(得分：2)
不，当线程正在执行时，它是不可能的。当一个线程正在执行时，其程序计数器（EIP）的当前值对于它正在运行的CPU核心是私有的。它在任何地方都没有内存。
架构有可能有特殊指令来发送有关执行状态的查询的处理器间请求，但x86没有这个。
但是，您可以使用ptrace system calls执行调试程序可以执行的任何操作;中断另一个线程并修改其任何状态（通用寄存器，标志，程序计数器等等）我不能给你一个例子，我只知道调试器用来修改另一个的保存状态的系统调用线程/进程。例如，this question要求使用ptrace修改另一个进程的RIP（用于测试代码注入）。
我不确定在同一进程中从另一个线程中删除一个线程是否可行;您的故障注入器可能更好地作为一个单独的进程干扰另一个进程的线程。
无论如何，当您进行ptrace系统调用以修改另一个线程中的某些内容时，将会发生的事情是运行系统调用的CPU将发送和处理器间消息发送到运行其他线程的CPU上的内核，这将打断你想要搞乱的那个线程。 Its state will be saved into memory by the kernel，任何CPU都可以修改它。
一旦另一个线程停止运行，它就不再与任何CPU强关联。在已经拥有热缓存的CPU上恢复它会更便宜，但这不能保证，因为一旦它不再忙于运行你导致停止的线程，CPU就可以开始运行任何其他线程。 / p>
用于修改EIP（foo()）的C函数非常难看，BTW：
首先，它是MSVC inline asm，所以没有Linux编译器会接受它（也许是icc？）。其次，它只适用于-fno-omit-frame-pointer，因为它假定它在一个推动%ebp的函数内部。
在asm中编写整个函数会容易得多。在64位非内联asm中，您只需编写：
global fault_inject_program_counter
fault_inject_program_counter:
xor qword [rsp], 0b00000111
ret
并使用NASM或YASM单独汇编该文件，并将.o与调用它的代码链接。 （我假设您更喜欢英特尔语法，因为您使用了MSVC-style asm {} instead GNU C asm("pop ; ... ; "::: ); inline asm.）
内联asm版本可能如下所示：
// this can't possibly work if inlined, or if compiled without `-fno-omit-frame-pointer
__attribute__((noinline)) void foo()
{
__asm__ volatile(
// "pop %eax\n\t"
// "pop %ebx\n\t" // now ebx holds the return address
// here code injection like 00000111 XOR ebx for example
// normal people would just write
"xorl $0b00000111, -4(%esp)\n\t"
// to modify the return value in-place, in a function with a frame pointer.
// push ...
// push ...
);
}