0 加载器先读 note、再进入 IFUNC resolver

glibc 动态加载器在装载 ELF 对象时会读取 PT_NOTE 中的 NT_GNU_PROPERTY_TYPE_0。在 x86_64 上,.note.gnu.property 常见属性包括:

  • GNU_PROPERTY_X86_FEATURE_1_AND
  • GNU_PROPERTY_X86_FEATURE_1_IBT
  • GNU_PROPERTY_X86_FEATURE_1_SHSTK
  • GNU_PROPERTY_X86_ISA_1_NEEDED

这些属性用于描述对象文件与 CPU 特性、CET 相关机制之间的关系。IFUNC 使用 STT_GNU_IFUNC 或 R_X86_64_IRELATIVE 表达“运行期解析函数地址”的语义。加载器需要在普通业务代码执行前调用 resolver,拿到最终实现地址,再继续执行初始化函数和 main。

关键顺序如下:

.note.gnu.property 不是 .text,但它会被加载器消费。若 IFUNC resolver 或工程封装把该 note 当作可信运行期策略输入,攻击面不再局限于代码段篡改。仅修改 note 数据,即可在 .text 不变的情况下影响同一 IFUNC 符号下的实现选择。

1 GNU property note 的字段布局与 CET 标记

ELF note record 由一个固定长度头部和两个变长数据区组成。固定头部包含 3 个 32 位字段,后面依次跟随按 4 字节对齐的 name 与 desc:

Elf64_Nhdr / Elf32_Nhdr
  n_namesz  /* name 字节数 */
  n_descsz  /* desc 字节数 */
  n_type    /* note 类型 */

name         /* 例如 "GNU\0",长度由 n_namesz 指定,随后按 4 字节对齐 */
desc         /* 属性描述数据,长度由 n_descsz 指定,随后按 4 字节对齐 */

.note.gnu.property 的 desc 区域不是单个整数,而是一组连续的 property entry。每个 entry 包含属性类型、数据长度和属性数据:

pr_type      /* 例如 GNU_PROPERTY_X86_FEATURE_1_AND */
pr_datasz    /* 属性数据长度 */
pr_data      /* 例如 x86 feature bitmask,entry 按 8 字节对齐 */

.note.gnu.property 的 note 类型为:

#define NT_GNU_PROPERTY_TYPE_0 5

x86_64 CET 常见属性为:

#define GNU_PROPERTY_X86_FEATURE_1_AND 0xc0000002
#define GNU_PROPERTY_X86_FEATURE_1_IBT  0x1
#define GNU_PROPERTY_X86_FEATURE_1_SHSTK 0x2

使用以下链接参数时,ELF 会携带 IBT 与 SHSTK 标记:

-Wl,-z,ibt -Wl,-z,shstk

readelf -n 可观察到如下属性:

Properties: x86 feature: IBT, SHSTK

IFUNC resolver 的基本形式如下:

typedef int (*impl_t)(int);

static impl_t resolver(void) {
    return impl_a;
}

int target(int) __attribute__((ifunc("resolver")));

编译后可观察到 IFUNC 符号和 R_X86_64_IRELATIVE 重定位。加载器处理该重定位时调用 resolver,并把返回地址写入调用位置或 GOT/PLT 相关槽位。

2 用 constructor 和 IRELATIVE 验证解析顺序

ldd --version | head -n 1
gcc --version | head -n 1
uname -m

ifunc_order.c 用于证明 IFUNC resolver 早于 constructor 执行。resolver_seen 在 resolver 中置为 1,constructor 只读取该变量并打印。

ifunc_order.c

#include <stdio.h>

static volatile int resolver_seen = 0;

static int impl_generic(int x) { return x + 1; }
static int impl_sse2(int x) { return x + 2; }

typedef int (*math_impl_t)(int);

static math_impl_t select_impl(void) {
    resolver_seen = 1;
#if defined(__x86_64__)
    __builtin_cpu_init();
    if (__builtin_cpu_supports("sse2")) {
        return impl_sse2;
    }
#endif
    return impl_generic;
}

int probe_add(int) __attribute__((ifunc("select_impl")));

__attribute__((constructor))
static void before_main(void) {
    printf("constructor: resolver_seen=%d\n", resolver_seen);
}

int main(void) {
    printf("main: probe_add(40)=%d\n", probe_add(40));
    return 0;
}

编译、执行并观察重定位与符号类型:

gcc -O2 -Wall -Wextra -fPIE -pie -o ifunc_order ifunc_order.c
./ifunc_order

constructor: resolver_seen=1 说明 IFUNC resolver 已在 constructor 前执行。因为 resolver_seen 只在 IFUNC resolver 中被置为 1,而 constructor 只是读取并打印它。

readelf -rW ifunc_order | grep IRELATIVE

这表示二进制中存在 R_X86_64_IRELATIVE 重定位。加载器处理该重定位时,会调用:

base + 0x2520

处的 resolver,并把 resolver 返回的真实函数地址写入:

base + 0x5000

对应的位置。

readelf -Ws ifunc_order | grep -E 'IFUNC|probe_add|select_impl'

readelf 同时显示 probe_add 为 IFUNC 符号,并存在 R_X86_64_IRELATIVE 重定位,其 addend 0x2520 与 select_impl 地址一致,进一步 证明该地址就是加载器在重定位阶段调用的 resolver。

​

ifunc_note_demo.c :resolver 从当前 ELF 的 PT_NOTE 中解析 GNU_PROPERTY_X86_FEATURE_1_AND,当 IBT 与 SHSTK 两个 bit 同时存在时返回 cet_marked_impl,否则返回 legacy_impl。

ifunc_note_demo.c

#define _GNU_SOURCE
#include <elf.h>
#include <stdint.h>
#include <stdio.h>

#ifndef GNU_PROPERTY_X86_FEATURE_1_AND
#define GNU_PROPERTY_X86_FEATURE_1_AND 0xc0000002U
#endif
#ifndef GNU_PROPERTY_X86_FEATURE_1_IBT
#define GNU_PROPERTY_X86_FEATURE_1_IBT (1U << 0)
#endif
#ifndef GNU_PROPERTY_X86_FEATURE_1_SHSTK
#define GNU_PROPERTY_X86_FEATURE_1_SHSTK (1U << 1)
#endif

extern const Elf64_Ehdr __ehdr_start;

static uintptr_t align_up(uintptr_t n, uintptr_t a) {
    return (n + a - 1) & ~(a - 1);
}

static uint32_t read_feature_1_and_from_loaded_notes(void) {
    const unsigned char *base = (const unsigned char *)&__ehdr_start;
    const Elf64_Ehdr *eh = (const Elf64_Ehdr *)base;

    if (eh->e_ident[EI_MAG0] != ELFMAG0 ||
        eh->e_ident[EI_MAG1] != ELFMAG1 ||
        eh->e_ident[EI_MAG2] != ELFMAG2 ||
        eh->e_ident[EI_MAG3] != ELFMAG3 ||
        eh->e_ident[EI_CLASS] != ELFCLASS64) {
        return 0;
    }

    const Elf64_Phdr *ph = (const Elf64_Phdr *)(base + eh->e_phoff);
    for (uint16_t i = 0; i < eh->e_phnum; i++) {
        if (ph[i].p_type != PT_NOTE) {
            continue;
        }

        const unsigned char *p = base + ph[i].p_vaddr;
        const unsigned char *end = p + ph[i].p_memsz;

        while (p + 12 <= end) {
            uint32_t namesz = *(const uint32_t *)(const void *)(p + 0);
            uint32_t descsz = *(const uint32_t *)(const void *)(p + 4);
            uint32_t type = *(const uint32_t *)(const void *)(p + 8);
            p += 12;

            const unsigned char *name = p;
            const unsigned char *desc = (const unsigned char *)align_up((uintptr_t)(p + namesz), 4);
            const unsigned char *next = (const unsigned char *)align_up((uintptr_t)(desc + descsz), 4);
            if (next > end || desc > end) {
                return 0;
            }

            if (type == NT_GNU_PROPERTY_TYPE_0 && namesz == 4 &&
                name[0] == 'G' && name[1] == 'N' && name[2] == 'U' && name[3] == '\0') {
                const unsigned char *q = desc;
                const unsigned char *qend = desc + descsz;
                while (q + 8 <= qend) {
                    uint32_t pr_type = *(const uint32_t *)(const void *)(q + 0);
                    uint32_t pr_datasz = *(const uint32_t *)(const void *)(q + 4);
                    const unsigned char *data = q + 8;
                    if (data + pr_datasz > qend) {
                        break;
                    }
                    if (pr_type == GNU_PROPERTY_X86_FEATURE_1_AND && pr_datasz >= 4) {
                        return *(const uint32_t *)(const void *)data;
                    }
                    q = (const unsigned char *)align_up((uintptr_t)(data + pr_datasz), 8);
                }
            }
            p = next;
        }
    }
    return 0;
}

static int legacy_impl(int x) {
    return x + 10;
}

static int cet_marked_impl(int x) {
    return x + 20;
}

typedef int (*probe_impl_t)(int);

static probe_impl_t choose_probe_impl(void) {
    uint32_t f = read_feature_1_and_from_loaded_notes();
    if ((f & (GNU_PROPERTY_X86_FEATURE_1_IBT | GNU_PROPERTY_X86_FEATURE_1_SHSTK)) ==
        (GNU_PROPERTY_X86_FEATURE_1_IBT | GNU_PROPERTY_X86_FEATURE_1_SHSTK)) {
        return cet_marked_impl;
    }
    return legacy_impl;
}

int probe_value(int) __attribute__((ifunc("choose_probe_impl")));

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

编译时同时开启控制流保护指令生成和链接器 GNU property 标记:

gcc -O2 -Wall -Wextra -fPIE -pie \
  -fcf-protection=full \
  -Wl,-z,ibt -Wl,-z,shstk \
  -o ifunc_note_demo ifunc_note_demo.c

执行样本并检查 note、重定位与 IFUNC 符号:

./ifunc_note_demo

说明 IFUNC resolver 选择了 cet_marked_impl,也就是:

return x + 20;

因此:

1 + 20 = 21

这表明 resolver 读取到了 .note.gnu.property 中的 CET 标记。

ELF 确实携带 IBT / SHSTK 属性

readelf -n ifunc_note_demo | sed -n '/GNU_PROPERTY/,+6p'

说明编译参数:

-fcf-protection=full -Wl,-z,ibt -Wl,-z,shstk

成功让 ELF 写入了 GNU property note。

程序中确实存在 IFUNC 重定位

readelf -rW ifunc_note_demo | grep IRELATIVE

说明动态加载器在重定位阶段会调用地址 0x11c0 对应的 resolver,并把 resolver 返回的真实实现函数地址写入 GOT/相关槽位。

IRELATIVE addend 指向 resolver

readelf -Ws ifunc_note_demo | grep -E 'IFUNC|probe_value|choose_probe_impl'

R_X86_64_IRELATIVE 的 addend 是 0x11c0,刚好等于 choose_probe_impl 的地址。这证明加载器调用的 resolver 就是 choose_probe_impl。

在当前二进制中,IFUNC resolver 的分派结果依赖 .note.gnu.property 中的 GNU property 元数据。

3 修改 GNU_PROPERTY_X86_FEATURE_1_AND 的脚本

patch_gnu_property.py 只修改 .note.gnu.property 中的 GNU_PROPERTY_X86_FEATURE_1_AND 值。脚本不改 .text,不重写 ELF 结构,只在原有 property entry 的 4 字节 bitmask 位置进行覆盖。

patch_gnu_property.py

#!/usr/bin/env python3
import argparse
import shutil
import struct

NT_GNU_PROPERTY_TYPE_0 = 5
GNU_PROPERTY_X86_FEATURE_1_AND = 0xC0000002

def align(n, a):
    return (n + a - 1) & ~(a - 1)

def die(msg):
    raise SystemExit(msg)

def read_section(buf, wanted):
    if buf[:4] != b"\x7fELF":
        die("not an ELF file")
    if buf[4] != 2 or buf[5] != 1:
        die("only ELF64 little-endian is supported")

    e_shoff = struct.unpack_from("<Q", buf, 0x28)[0]
    e_shentsize = struct.unpack_from("<H", buf, 0x3A)[0]
    e_shnum = struct.unpack_from("<H", buf, 0x3C)[0]
    e_shstrndx = struct.unpack_from("<H", buf, 0x3E)[0]

    if e_shoff == 0 or e_shnum == 0 or e_shstrndx >= e_shnum:
        die("section table is missing")

    def sh(i):
        off = e_shoff + i * e_shentsize
        return struct.unpack_from("<IIQQQQIIQQ", buf, off)

    shstr = sh(e_shstrndx)
    shstr_off, shstr_size = shstr[4], shstr[5]
    shstr_data = buf[shstr_off:shstr_off + shstr_size]

    for i in range(e_shnum):
        item = sh(i)
        name_off = item[0]
        end = shstr_data.find(b"\0", name_off)
        if end < 0:
            continue
        name = shstr_data[name_off:end].decode("ascii", "replace")
        if name == wanted:
            return item[4], item[5]
    die(f"section {wanted} not found")

def parse_and_patch(buf, set_feature):
    sec_off, sec_size = read_section(buf, ".note.gnu.property")
    p = sec_off
    end = sec_off + sec_size
    changed = False

    while p + 12 <= end:
        namesz, descsz, note_type = struct.unpack_from("<III", buf, p)
        p += 12
        name_off = p
        desc_off = align(name_off + namesz, 4)
        next_note = align(desc_off + descsz, 4)
        if next_note > end:
            die("broken note size")

        name = bytes(buf[name_off:name_off + namesz])
        if note_type == NT_GNU_PROPERTY_TYPE_0 and name == b"GNU\0":
            q = desc_off
            qend = desc_off + descsz
            while q + 8 <= qend:
                pr_type, pr_datasz = struct.unpack_from("<II", buf, q)
                data_off = q + 8
                data_end = data_off + pr_datasz
                if data_end > qend:
                    die("broken property size")
                if pr_type == GNU_PROPERTY_X86_FEATURE_1_AND and pr_datasz >= 4:
                    old = struct.unpack_from("<I", buf, data_off)[0]
                    print(f"GNU_PROPERTY_X86_FEATURE_1_AND=0x{old:08x}")
                    if set_feature is not None:
                        struct.pack_into("<I", buf, data_off, set_feature)
                        print(f"patched GNU_PROPERTY_X86_FEATURE_1_AND=0x{set_feature:08x}")
                        changed = True
                q = align(data_end, 8)
        p = next_note

    if set_feature is not None and not changed:
        die("GNU_PROPERTY_X86_FEATURE_1_AND not found")

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("input")
    ap.add_argument("output")
    ap.add_argument("--set-feature", type=lambda x: int(x, 0), default=None)
    ns = ap.parse_args()

    shutil.copyfile(ns.input, ns.output)
    with open(ns.output, "rb") as f:
        data = bytearray(f.read())
    parse_and_patch(data, ns.set_feature)
    with open(ns.output, "wb") as f:
        f.write(data)

if __name__ == "__main__":
    main()

将 GNU_PROPERTY_X86_FEATURE_1_AND 清零后执行新文件:

python3 patch_gnu_property.py ifunc_note_demo ifunc_note_clear --set-feature 0

0x3 表示同时包含:

IBT   = 0x1
SHSTK = 0x2

所以 resolver 判断 IBT 和 SHSTK 都存在,选择:

cet_marked_impl

运行结果为:

chmod +x ifunc_note_clear
./ifunc_note_clear

修改后:

readelf -n ifunc_note_clear | sed -n '/GNU_PROPERTY/,+6p'

说明 .note.gnu.property 中的 CET feature bit 已被清零。

原始样本 probe_value(1)=21,修改后样本 probe_value(1)=11。由于 resolver 的逻辑是当 IBT 和 SHSTK 两个 bit 同时存在时 返回 cet_marked_impl,否则返回 legacy_impl,因此返回值变化说明 IFUNC resolver 的分派结果确实受 .note.gnu.property 控制。

4 note 影响 IFUNC 分派所需的条件

影响 IFUNC 解析结果需要同时满足以下条件:

  1. ELF 携带 PT_NOTE,且 .note.gnu.property 被映射到进程地址空间。
  2. 二进制中存在 IFUNC 符号或 R_X86_64_IRELATIVE 重定位。
  3. resolver 直接读取 note,或间接依赖加载器基于 note 形成的状态。
  4. note 数据位于文件可修改区域,且缺少签名、哈希、包管理校验等保护。
  5. 修改后的 note 仍保持 ELF note 格式合法,加载器不会因格式错误拒绝装载。

单纯修改 .note.gnu.property 不会自动改写任意 IFUNC resolver 的优先级。只有 resolver 的决策输入与该 note 存在依赖时,note 才能成为实现选择的控制面。

5 只改 note 后的返回值与哈希变化

.text 段哈希用于确认代码段没有被修改。objcopy --dump-section 分别导出原始文件与修改后文件的 .text。

objcopy --dump-section .text=base.text ifunc_note_demo
objcopy --dump-section .text=clear.text ifunc_note_clear
sha256sum base.text clear.text
cmp -s base.text clear.text
echo $?

两个 .text 段的 SHA-256 完全一致,cmp 返回值为 0,说明原始样本 ifunc_note_demo 与修改后样本 ifunc_note_clear 的代码段内容完全相同。

本次行为变化不是由 .text 代码段变化引起的,而是由 .note.gnu.property 中 GNU_PROPERTY_X86_FEATURE_1_AND bitmask 被修改导致的。

也就是说,在该样本设计中,无需修改代码段,只要修改 ELF note 元数据, 就可以改变依赖该 note 的 IFUNC resolver 分派结果。

这一结论成立的前提是 resolver 显式读取 .note.gnu.property并将其作为分派依据。普通 IFUNC resolver 如果不依赖该 note,单独修改 .note.gnu.property 不会自动改变其实现选择。

整个 ELF 文件哈希用于确认产物已经发生变化。

sha256sum ifunc_note_demo ifunc_note_clear

endbr64 指令用于确认编译器已经生成 IBT 相关落点指令。

objdump -d ifunc_note_demo | grep -m 5 endbr64

R_X86_64_IRELATIVE 的 addend 指向 resolver 地址。符号表中的 choose_probe_impl 地址与该 addend 对应。

readelf -rW ifunc_note_demo | grep IRELATIVE
readelf -Ws ifunc_note_demo | grep choose_probe_impl

R_X86_64_IRELATIVE 重定位的 addend 指向的就是 IFUNC resolver:choose_probe_impl。

其中 0x11c0 是该重定位的 addend。对于 R_X86_64_IRELATIVE, 动态加载器会在重定位阶段调用 base + addend,并把返回值写入 base + 0x4008 对应的位置。

choose_probe_impl 的地址正好是 0x11c0,因此可以确认该 IRELATIVE 重定位调用的 resolver 就是 choose_probe_impl。 这也解释了为什么 .note.gnu.property 被修改后,程序行为会发生变化: choose_probe_impl 在 resolver 阶段读取该 note,并根据其中的 feature bit 选择不同实现函数。

6 .text 未变但 resolver 决策输入已变

ifunc_note_demo 与 ifunc_note_clear 的 .text 哈希一致,说明代码段未被修改。两个文件的整体哈希不同,差异来自 .note.gnu.property。

原始样本中:

GNU_PROPERTY_X86_FEATURE_1_AND=0x00000003

0x3 同时包含:

IBT   = 0x1
SHSTK = 0x2

resolver 读取到两个 bit 均存在,返回 cet_marked_impl:

probe_value(1)=21

修改后:

GNU_PROPERTY_X86_FEATURE_1_AND=0x00000000

resolver 读取不到 IBT/SHSTK 标记,返回 legacy_impl:

probe_value(1)=11

该现象说明 .note.gnu.property 能在不改变 .text 的情况下影响特定 IFUNC resolver 的选择结果。风险点不在 IFUNC 机制本身,而在 resolver 把 ELF note 当成可信策略输入。

.note.gnu.property 是加载器消费的元数据,不是对 .text 的完整指令语义验证。清除或伪造属性会造成“文件实际代码形态”和“加载器看到的安全属性”不一致。

7 让 resolver 脱离 ELF note 的修复代码

resolver 不应读取 .note.gnu.property 作为运行期分支策略。CPU 能力判断应来自受控 API 或编译器内建逻辑。

fixed_ifunc.c 使用 __builtin_cpu_init 与 __builtin_cpu_supports 选择实现,不再读取 ELF note。

fixed_ifunc.c

#include <stdio.h>

static int generic_impl(int x) { return x + 10; }
static int sse2_impl(int x) { return x + 100; }

typedef int (*probe_impl_t)(int);

static probe_impl_t choose_probe_impl(void) {
#if defined(__x86_64__)
    __builtin_cpu_init();
    if (__builtin_cpu_supports("sse2")) {
        return sse2_impl;
    }
#endif
    return generic_impl;
}

int probe_value(int) __attribute__((ifunc("choose_probe_impl")));

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

编译、修改 note 并再次执行:

gcc -O2 -Wall -Wextra -fPIE -pie \
  -fcf-protection=full \
  -Wl,-z,ibt -Wl,-z,shstk \
  -o fixed_ifunc fixed_ifunc.c
./fixed_ifunc

说明 resolver 根据 CPU 能力选择了 sse2_impl:

1 + 100 = 101


python3 patch_gnu_property.py fixed_ifunc fixed_ifunc_clear --set-feature 0

修改 .note.gnu.property:

说明 IBT/SHSTK 标记已经被清零。

修改后再次运行:

chmod +x fixed_ifunc_clear
./fixed_ifunc_clear

返回值没有变化。

当 IFUNC resolver 不再读取 .note.gnu.property 时,修改 GNU property note 不再影响 IFUNC 分派结果。

8 元数据不应成为 IFUNC 策略输入

.note.gnu.property 在 IFUNC resolver 运行前已被加载器处理。该顺序使 ELF note 成为早期装载阶段的安全关键元数据。

实验结果显示,修改 GNU_PROPERTY_X86_FEATURE_1_AND 不需要改变 .text,即可改变依赖该 note 的 IFUNC resolver 返回值。原始样本返回 21,清除属性后返回 11,同时 .text 哈希保持一致。

普通 IFUNC resolver 若不读取 note,.note.gnu.property 篡改不会自动改变实现优先级。风险成因是把可篡改 ELF 元数据当成可信运行期策略输入,以及只验证代码段而忽略完整 ELF 文件。

修复重点是移除 resolver 对 note 的依赖、固定构建参数、验证完整文件哈希,并在 CI 中检查 CET 属性与 IFUNC 使用情况。