C++ `LD_PRELOAD` 劫持函数：动态库注入与行为修改

哈喽，各位好！今天咱们来聊聊一个C++里挺有意思，但也可能有点危险的技术：LD_PRELOAD劫持函数。说它危险，是因为这玩意儿用好了能干大事，用不好可能让程序跑偏，甚至被恶意利用。所以，咱们要带着敬畏之心来学习。

一、LD_PRELOAD是个啥？

想象一下，你家门口有一条路，所有去你家的快递都要经过这条路。LD_PRELOAD就有点像在这条路上设了个“快递中转站”。当程序要调用某个函数的时候，系统会先看看这个“中转站”有没有这个函数的“替代品”。如果有，就先用“替代品”，而不是直接去系统库里找。

更专业一点说，LD_PRELOAD是一个环境变量，用于指定在程序启动时优先加载的动态链接库。这意味着，我们可以通过创建一个包含与程序所需函数同名函数的动态库，并设置LD_PRELOAD环境变量，来“劫持”程序对这些函数的调用。

二、为什么要劫持函数？

这问题问得好！劫持函数有很多用途，比如：

• 调试和测试： 我们可以用它来追踪函数的调用，记录参数和返回值，模拟错误情况等等。
• 性能分析： 我们可以测量函数的执行时间，分析程序的瓶颈。
• 功能增强： 我们可以给现有的函数添加新的功能，而无需修改程序的源代码。
• 安全加固： 我们可以替换一些不安全的函数，防止潜在的漏洞被利用。
• 行为修改： 偷偷摸摸地改变程序的行为，当然，要合法合规哦！

总之，只要你想对程序的行为进行一些干预，LD_PRELOAD就可能派上用场。

三、LD_PRELOAD的原理

简单来说，动态链接器（dynamic linker）在加载程序和它的依赖库时，会按照一定的顺序搜索函数符号。LD_PRELOAD指定的库会被优先加载，因此它的函数符号也会被优先解析。

具体步骤如下：

1. 程序启动，动态链接器开始工作。
2. 动态链接器检查LD_PRELOAD环境变量。
3. 如果LD_PRELOAD存在，动态链接器会优先加载其中指定的动态库。
4. 当程序调用一个函数时，动态链接器首先在LD_PRELOAD加载的库中查找该函数的符号。
5. 如果找到，就使用LD_PRELOAD中的函数实现；否则，继续在其他库中查找。

这个过程可以用下图简单描述：

程序 -> 动态链接器 -> LD_PRELOAD 库 -> 系统库

四、实战演练：劫持malloc函数

咱们通过一个简单的例子来演示如何使用LD_PRELOAD劫持malloc函数，并记录每次内存分配的大小。

1. 创建动态库 malloc_hook.c

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

// 定义函数指针类型，指向原始的 malloc 函数
typedef void* (*malloc_t)(size_t size);

// 保存原始的 malloc 函数地址
static malloc_t original_malloc = NULL;

// 构造函数，在动态库加载时执行
__attribute__((constructor)) void init() {
  // 获取原始的 malloc 函数地址
  original_malloc = (malloc_t)dlsym(RTLD_NEXT, "malloc");
  if (!original_malloc) {
    fprintf(stderr, "Failed to get original malloc function: %sn", dlerror());
    exit(EXIT_FAILURE);
  }
  fprintf(stdout, "malloc_hook.so: init() called, original malloc function address: %pn", (void*)original_malloc);
}

// 我们的劫持函数
void* malloc(size_t size) {
  // 在调用原始的 malloc 函数之前，记录分配大小
  fprintf(stdout, "malloc_hook.so: malloc(%zu) calledn", size);

  // 调用原始的 malloc 函数
  void* ptr = original_malloc(size);

  // 在调用原始的 malloc 函数之后，记录分配地址
  fprintf(stdout, "malloc_hook.so: malloc(%zu) returns %pn", size, ptr);
  return ptr;
}

代码解释：

• #define _GNU_SOURCE: 开启GNU扩展，以便使用dlsym的RTLD_NEXT选项。
• dlsym(RTLD_NEXT, "malloc"): 这个函数用于在动态链接库中查找符号。RTLD_NEXT表示查找下一个出现的malloc函数，也就是系统库中的malloc函数。
• __attribute__((constructor)): 这是一个GCC的扩展，用于指定一个函数在动态库加载时自动执行。这里我们用它来初始化original_malloc。
• 我们的malloc函数： 这个函数会拦截对malloc的调用，记录分配大小，然后调用原始的malloc函数，并返回结果。

2. 编译动态库

gcc -shared -fPIC malloc_hook.c -o malloc_hook.so -ldl

参数解释：

• -shared: 生成一个共享库（动态库）。
• -fPIC: 生成位置无关代码（Position Independent Code），这是动态库的必要条件。
• -ldl: 链接libdl库，这个库提供了dlsym等函数。

3. 创建测试程序 test.c

#include <stdio.h>
#include <stdlib.h>

int main() {
  int* ptr = (int*)malloc(sizeof(int) * 10);
  if (ptr == NULL) {
    perror("malloc failed");
    return 1;
  }
  printf("Allocated memory at %pn", ptr);
  free(ptr);
  return 0;
}

4. 编译测试程序

gcc test.c -o test

5. 运行测试程序，并设置LD_PRELOAD

LD_PRELOAD=./malloc_hook.so ./test

预期输出：

malloc_hook.so: init() called, original malloc function address: 0x7f... (实际地址)
malloc_hook.so: malloc(40) called
malloc_hook.so: malloc(40) returns 0x55... (实际地址)
Allocated memory at 0x55... (实际地址)

分析：

可以看到，在test程序调用malloc函数之前，我们的malloc_hook.so库中的malloc函数被优先调用了。它成功地记录了分配的大小，并调用了原始的malloc函数。

五、注意事项

• 命名冲突： 确保你的劫持函数和原始函数具有相同的函数签名（参数类型和返回值类型）。否则，程序可能会崩溃或者出现未定义的行为。
• 递归调用： 避免在劫持函数中直接或间接地调用自己。这可能会导致无限递归，最终导致栈溢出。
• 线程安全： 如果你的程序是多线程的，确保你的劫持函数是线程安全的。可以使用互斥锁等同步机制来保护共享资源。
• 性能影响： 劫持函数会增加额外的开销，可能会影响程序的性能。因此，应该谨慎使用，并进行性能测试。
• 安全性： LD_PRELOAD可能会被恶意利用，例如，通过劫持关键函数来窃取敏感信息。因此，应该限制LD_PRELOAD的使用，并进行安全审计。
• RTLD_NEXT 的使用: 必须小心处理，确保正确获取原始函数的地址。 如果获取失败，程序可能会崩溃。
• 构造函数和析构函数： 动态库中的构造函数（__attribute__((constructor))）和析构函数（__attribute__((destructor))）可能会影响程序的启动和退出行为。
• 符号可见性： 确保你的劫持函数在动态库中是可见的。可以使用__attribute__((visibility("default")))来显式地声明函数的可见性。

六、更复杂的例子：劫持open函数

咱们再来一个稍微复杂一点的例子，劫持open函数，并限制程序只能打开指定的文件。

1. 创建动态库 open_hook.c

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <string.h>
#include <unistd.h>

// 定义允许打开的文件列表
const char* allowed_files[] = {
  "/tmp/allowed.txt",
  NULL // 必须以 NULL 结尾
};

// 定义函数指针类型
typedef int (*open_t)(const char *pathname, int flags, ...);

// 保存原始的 open 函数地址
static open_t original_open = NULL;

// 构造函数
__attribute__((constructor)) void init() {
  original_open = (open_t)dlsym(RTLD_NEXT, "open");
  if (!original_open) {
    fprintf(stderr, "Failed to get original open function: %sn", dlerror());
    exit(EXIT_FAILURE);
  }
  fprintf(stdout, "open_hook.so: init() called, original open function address: %pn", (void*)original_open);
}

// 我们的劫持函数
int open(const char *pathname, int flags, ...) {
  // 检查是否允许打开该文件
  int allowed = 0;
  for (int i = 0; allowed_files[i] != NULL; i++) {
    if (strcmp(pathname, allowed_files[i]) == 0) {
      allowed = 1;
      break;
    }
  }

  if (!allowed) {
    fprintf(stderr, "open_hook.so: open(%s) blockedn", pathname);
    return -1; // 拒绝打开
  }

  // 调用原始的 open 函数
  va_list args;
  va_start(args, flags);
  mode_t mode = va_arg(args, mode_t);
  va_end(args);

  int fd = original_open(pathname, flags, mode);
  fprintf(stdout, "open_hook.so: open(%s) returns %dn", pathname, fd);
  return fd;
}

代码解释：

• allowed_files: 定义了一个允许打开的文件列表。
• va_list, va_start, va_arg, va_end: 这些是用于处理可变参数列表的宏。因为open函数可以接受不同数量的参数，所以我们需要使用这些宏来正确地获取参数。
• 我们的open函数： 首先检查要打开的文件是否在允许列表中。如果在，就调用原始的open函数；否则，拒绝打开。

2. 编译动态库

gcc -shared -fPIC open_hook.c -o open_hook.so -ldl

3. 创建测试程序 test_open.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
  int fd1 = open("/tmp/allowed.txt", O_RDONLY);
  if (fd1 == -1) {
    perror("open /tmp/allowed.txt failed");
  } else {
    printf("Opened /tmp/allowed.txt successfullyn");
    close(fd1);
  }

  int fd2 = open("/tmp/forbidden.txt", O_RDONLY);
  if (fd2 == -1) {
    perror("open /tmp/forbidden.txt failed");
  } else {
    printf("Opened /tmp/forbidden.txt successfullyn");
    close(fd2);
  }

  return 0;
}

4. 创建 /tmp/allowed.txt 文件 (因为测试程序要打开它)

touch /tmp/allowed.txt

5. 编译测试程序

gcc test_open.c -o test_open

6. 运行测试程序，并设置LD_PRELOAD

LD_PRELOAD=./open_hook.so ./test_open

预期输出：

open_hook.so: init() called, original open function address: 0x7f... (实际地址)
open_hook.so: open(/tmp/allowed.txt) returns 3
Opened /tmp/allowed.txt successfully
open_hook.so: open(/tmp/forbidden.txt) blocked
open /tmp/forbidden.txt failed: Permission denied

分析：

可以看到，程序成功地打开了/tmp/allowed.txt，但是被拒绝打开/tmp/forbidden.txt。

七、一些高级用法

• 配置文件： 可以从配置文件中读取允许打开的文件列表，而不是硬编码在代码中。
• 用户权限： 可以根据用户的权限来决定是否允许打开文件。
• 动态加载： 可以使用dlopen和dlsym函数动态地加载和卸载劫持库。
• 与ptrace结合： 可以与ptrace系统调用结合，实现更强大的调试和分析功能。

八、总结

LD_PRELOAD是一个强大的工具，可以用来劫持函数，修改程序的行为。但是，它也存在一些风险，需要谨慎使用。希望通过今天的讲解，大家对LD_PRELOAD有了更深入的了解。记住，能力越大，责任越大！要合法合规地使用这项技术。

九、常见问题解答

问题	解答
LD_PRELOAD 只能劫持 C 函数吗？	不，LD_PRELOAD 可以劫持 C++ 函数，只要函数符号在动态库中可见。对于 C++ 函数，需要注意名称修饰（name mangling）问题。可以使用 extern "C" 来避免名称修饰。
如何调试 LD_PRELOAD 劫持库？	可以使用 gdb 调试 LD_PRELOAD 劫持库。首先，使用 gdb ./test 启动调试器，然后在 gdb 中设置断点，例如 b malloc_hook.so:malloc。 运行程序时，gdb 会在 malloc_hook.so 库的 malloc 函数处中断。
为什么我的 LD_PRELOAD 劫持不起作用？	常见的原因包括： 1. LD_PRELOAD 环境变量没有正确设置。 2. 劫持函数的签名与原始函数不匹配。 3. 劫持库的路径不正确。 4. 程序使用了静态链接，而不是动态链接。 5. 符号可见性问题。
LD_PRELOAD 和 ptrace 的区别是什么？	LD_PRELOAD 是通过动态链接器来劫持函数，它是在程序启动时完成的。ptrace 是一种系统调用，允许一个进程控制另一个进程的执行。ptrace 可以动态地修改程序的内存和寄存器，因此比 LD_PRELOAD 更加灵活，但也更加复杂。LD_PRELOAD 更适合于修改程序的行为，而 ptrace 更适合于调试和分析程序。
如何保证 LD_PRELOAD 的安全性？	1. 限制 LD_PRELOAD 的使用，只允许信任的用户使用。 2. 对 LD_PRELOAD 劫持库进行安全审计，确保没有恶意代码。 3. 使用安全加固技术，例如地址空间布局随机化（ASLR）和数据执行保护（DEP），来降低 LD_PRELOAD 攻击的风险。 4. 避免在生产环境中使用 LD_PRELOAD，除非有充分的理由。
LD_PRELOAD 会影响 setuid 程序吗?	是的，LD_PRELOAD 会对 setuid 程序产生影响。为了安全起见，动态链接器在加载 setuid 程序时，通常会忽略 LD_PRELOAD 环境变量。这是为了防止恶意用户通过 LD_PRELOAD 劫持 setuid 程序的函数，从而获取 root 权限。但是，在某些情况下，可以通过设置 LD_LIBRARY_PATH 环境变量来影响 setuid 程序的动态链接过程，但这需要非常小心，以避免安全漏洞。
如何在 Docker 容器中使用 LD_PRELOAD?	在 Docker 容器中使用 LD_PRELOAD 与在普通 Linux 系统中使用类似。可以通过在 docker run 命令中使用 -e 选项来设置 LD_PRELOAD 环境变量。例如：docker run -e LD_PRELOAD=/path/to/your/hook.so your_image。 确保动态库在容器内部的路径是正确的。

希望这些问题解答能够帮助你更好地理解和使用 LD_PRELOAD。

好了，今天的分享就到这里。感谢大家的聆听！希望大家有所收获，也欢迎大家多多交流和讨论。 记住，技术是把双刃剑，用好它，造福社会；用不好，可能伤人伤己。 祝大家编程愉快！