ELF .note.gnu.property 段篡改劫持 IFUNC 解析顺序分析
在 ELF 加载早期,.note.gnu.property 这样的“非代码段”元数据已经足以影响 IFUNC resolver 的执行路径;一次不改 .text 的 note 篡改,可能让同一个符号在运行时落到完全不同的实现上。
0 加载器先读 note、再进入 IFUNC resolver
glibc 动态加载器在装载 ELF 对象时会读取 PT_NOTE 中的 NT_GNU_PROPERTY_TYPE_0。在 x86_64 上,.note.gnu.property 常见属性包括:
GNU_PROPERTY_X86_FEATURE_1_ANDGNU_PROPERTY_X86_FEATURE_1_IBTGNU_PROPERTY_X86_FEATURE_1_SHSTKGNU_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 5x86_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,shstkreadelf -n 可观察到如下属性:
Properties: x86 feature: IBT, SHSTKIFUNC 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 解析结果需要同时满足以下条件:
- ELF 携带
PT_NOTE,且.note.gnu.property被映射到进程地址空间。 - 二进制中存在 IFUNC 符号或
R_X86_64_IRELATIVE重定位。 - resolver 直接读取 note,或间接依赖加载器基于 note 形成的状态。
- note 数据位于文件可修改区域,且缺少签名、哈希、包管理校验等保护。
- 修改后的 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=0x000000030x3 同时包含:
IBT = 0x1
SHSTK = 0x2resolver 读取到两个 bit 均存在,返回 cet_marked_impl:
probe_value(1)=21修改后:
GNU_PROPERTY_X86_FEATURE_1_AND=0x00000000resolver 读取不到 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 = 101python3 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 使用情况。