计算机系统篇之链接(15):共享库拦截技术之运行时库打桩(上)

计算机系统篇之链接(15):共享库拦截技术之运行时库打桩(上)

Author:stormQ

Saturday, 21. December 2019 11:58AM

  • 目录

    • 什么是运行时库打桩
    • 运行时库打桩的实现原理
    • 如何在加载程序时拦截标准库的 API

什么是运行时库打桩

库打桩(Library Interpositioning)是一种允许截获对共享库函数的调用,取而代之执行自己代码的技术。

运行时库打桩是库打桩技术中的一种,另外两种是编译时库打桩和链接时库打桩。它可以在程序加载时或程序运行过程中对共享库进行打桩。

运行时库打桩的强大之处在于只要能够访问可执行目标文件,就可以应用该技术。


运行时库打桩的实现原理

运行时库打桩的实现原理是基于动态链接器的LD_PRELOAD环境变量。如果LD_PRELOAD变量被设置为一个共享库路径名的列表(以空格或分号分隔),那么当你加载和运行一个程序,需要解析未定义的符号引用时,动态链接器会先搜索LD_PRELOAD中的共享库,然后才搜索任何其他的库。有了这个机制,当你加载和执行任意可执行文件时,可以对任何共享库中的任何函数打桩,包括libc.so


如何在加载程序时拦截标准库的 API

以“在加载程序时,拦截标准库的 malloc() 和 free() 函数”为例,具体过程如下。

step 1: 编写自定义的malloc()函数

1)由于要拦截标准库的malloc()函数,相当于要神不知鬼不觉地将程序中所有对标准库函数malloc()的调用换成调用我们自定义的malloc()函数。所以,我们自定义的malloc()的函数原型必须与标准库中的保持一致。

自定义的malloc()函数:

extern "C" {

void* malloc(size_t size)
{
}

}   // extern "C"

由于采用 C++ 编写,为了避免 C++ 默认对函数名重编(name mangling)所引起的副作用。我们将自定义的malloc()函数用extern "C"包裹起来。

2)从标准库中获取符号名称为malloc的符号定义的地址,即malloc()的函数地址

auto symbol_addr = dlsym(RTLD_NEXT, "malloc");

注:RTLD_NEXT表示下一个加载的共享库的句柄。这里,下一个加载的共享库默认就是libc.so。当然,这样做是有一定风险的。

注意: 为了让RTLD_NEXT可用,需要定义编译选项_GNU_SOURCE。我们可以在生成共享库时,将该选项传递给 g++,即-D_GNU_SOURCE

3)由于dlsym()函数的返回类型为void *,在使用前需要先进行类型转换

typedef void* (*__malloc)(size_t);
auto libc_malloc = reinterpret_cast<__malloc>(symbol_addr);
auto ptr = libc_malloc(size);

注:ptr指向所申请内存的首地址。

4)跟踪malloc()函数的调用情况

static thread_local bool called = false;
if (!called)
{
    called = true;
    LOG_INFO("malloc(%ld) = %p\n", size, ptr);
    called = false;
}

这里,需要注意两点: 1)引入静态局部变量called是为了防止死循环,因为printf()函数中会调用malloc()函数;2)修饰符thread_local表示变量called是线程局部对象,即每个线程都拥有一份私有的called变量,这样做是出于线程安全的考虑。

5)自定义malloc()函数的完整实现

extern "C" {

void* malloc(size_t size)
{
    auto symbol_addr = dlsym(RTLD_NEXT, "malloc");
    if (!symbol_addr)
    {
        throw std::runtime_error(dlerror());
    }
    typedef void* (*__malloc)(size_t);
    auto libc_malloc = reinterpret_cast<__malloc>(symbol_addr);
    auto ptr = libc_malloc(size);

    static thread_local bool called = false;
    if (!called)
    {
        called = true;
        LOG_INFO("malloc(%ld) = %p\n", size, ptr);
        called = false;
    }

    return ptr;
}

}   // extern "C"

step 2: 编写自定义的free()函数

自定义free()函数的完整实现:

extern "C" {

void free(void *ptr)
{
    auto symbol_addr = dlsym(RTLD_NEXT, "free");
    if (!symbol_addr)
    {
        throw std::runtime_error(dlerror());
    }
    typedef void (*__free)(void *);
    auto libc_free = reinterpret_cast<__free>(symbol_addr);
    libc_free(ptr);
    LOG_INFO("free() = %p\n", ptr);
}

}   // extern "C"

step 3: 编写测试程序 main.cpp

main.cpp:

#include 

int main()
{
    int *p1 = static_cast(malloc(16));
    int *p2 = static_cast(malloc(32));
    free(p2);
    free(p1);
    return 0;
}

step 4: 生成共享库 mymalloc.so

$ g++ -o mymalloc.so mymalloc.cpp -shared -fpic -ldl -D_GNU_SOURCE -g

注:由于dlsym()函数定义在libdl.so中。所以,需要指定链接选项-ldl

step 5: 生成并运行测试程序

1)生成可执行目标文件 main

$ g++ -o main main.cpp -g

2)运行可执行目标文件 main

方式1:

$ LD_PRELOAD="./mymalloc.so" ./main

注意: 一定要用引号将./mymalloc.so括起来。否则,两者将都被认为是环境变量LD_PRELOAD的值。

方式2:

$ export LD_PRELOAD=./mymalloc.so
$ ./main

错误的运行方式:

$ LD_PRELOAD=./mymalloc.so
$ ./main

3)运行结果

$ LD_PRELOAD="./mymalloc.so" ./main
malloc(72704) = 0x21d4010
malloc(16) = 0x21e6030
malloc(32) = 0x21e6050
free() = 0x21e6050
free() = 0x21e6030

输出结果中的malloc(72704) = 0x21d4010,是在main()函数执行前打印的。

4)调试可执行目标文件 main

$ gdb -q ./main
Reading symbols from ./main...done.
(gdb) set environment LD_PRELOAD=./mymalloc.so
(gdb) start
Temporary breakpoint 1 at 0x40056e: file main.cpp, line 8.
Starting program: /home/test/li_cpp/main 
malloc(72704) = 0x602010

Temporary breakpoint 1, main () at main.cpp:8
8	    int *p1 = static_cast(malloc(16));
(gdb) n
malloc(16) = 0x614030
9	    int *p2 = static_cast(malloc(32));
(gdb) 
malloc(32) = 0x614050
10	    free(p2);
(gdb) 
free() = 0x614050
11	    free(p1);
(gdb) c
Continuing.
free() = 0x614030
[Inferior 1 (process 28282) exited normally]
(gdb) 

注意: 设置可执行目标文件main的环境变量的操作必须在执行start前进行。

step 6: 完整程序

mymalloc.cpp:

// how to compile: g++ -o mymalloc.so mymalloc.cpp -shared -fpic -ldl -D_GNU_SOURCE -g

#include 
#include 
#include 

#define LOG_INFO std::printf

extern "C" {

void* malloc(size_t size)
{
    auto symbol_addr = dlsym(RTLD_NEXT, "malloc");
    if (!symbol_addr)
    {
        throw std::runtime_error(dlerror());
    }
    typedef void* (*__malloc)(size_t);
    auto libc_malloc = reinterpret_cast<__malloc>(symbol_addr);
    auto ptr = libc_malloc(size);

    static thread_local bool called = false;
    if (!called)
    {
        called = true;
        LOG_INFO("malloc(%ld) = %p\n", size, ptr);
        called = false;
    }

    return ptr;
}

void free(void *ptr)
{
    auto symbol_addr = dlsym(RTLD_NEXT, "free");
    if (!symbol_addr)
    {
        throw std::runtime_error(dlerror());
    }
    typedef void (*__free)(void *);
    auto libc_free = reinterpret_cast<__free>(symbol_addr);
    libc_free(ptr);
    LOG_INFO("free() = %p\n", ptr);
}

}   // extern "C"

main.cpp:

// how to compile: g++ -o main main.cpp -g
// how to run: LD_PRELOAD="./mymalloc.so" ./main

#include 

int main()
{
    int *p1 = static_cast(malloc(16));
    int *p2 = static_cast(malloc(32));
    free(p2);
    free(p1);
    return 0;
}

如果你觉得本文对你有所帮助,欢迎关注公众号,支持一下!

在这里插入图片描述

你可能感兴趣的:(#,链接)