1. 引言：漏洞利用缓解技术与现代防御机制概述
软件安全领域一直上演着漏洞利用与防御对策之间持续的攻防博弈。没有任何一种防御措施是绝对完美的，攻击者总在不断寻找新的方法来绕过现有的缓解技术。这突显了纵深防御策略的必要性。本报告将深入探讨几种核心的现代漏洞利用缓解机制：RELRO、栈 Canary、ASLR 和 PIE。这些技术旨在增加漏洞利用的难度，但并非无法攻破。报告将阐述它们的实现原理、常见的绕过方法，以及在特定场景下（如利用格式化字符串漏洞和 ROP 攻击）如何被攻克。
这些防御机制的演进反映了攻击技术的变迁。早期的攻击可能依赖简单的栈溢出直接注入并执行 shellcode。诸如 NX/DEP 等防御技术的出现，迫使攻击者转向代码重用技术（如 ROP）。随后，ASLR/PIE 的引入使得寻找可用代码段变得更加困难，而 Canary 机制则旨在检测溢出本身。这种攻防的相互作用催生了日益复杂的攻防技术。最初，简单的缓冲区溢出允许攻击者直接在栈上注入并执行 shellcode。第一代防御演进是 NX/DEP（Non-Executable stack/Data Execution Prevention），它禁止了从栈等数据区域直接执行代码。攻击者随之调整策略，转向返回导向编程（Return-Oriented Programming, ROP），通过重用程序或链接库中已有的可执行代码片段（称为 gadgets）来达到攻击目的。第二代防御演进是地址空间布局随机化（ASLR）和位置无关可执行文件（PIE），它们随机化代码和数据在内存中的位置，增加了攻击者预测 ROP gadgets 和其他关键数据地址的难度。第三代防御演进是栈 Canary，它在发生栈缓冲区溢出并覆盖如返回地址等关键控制数据之前检测到溢出，从而阻止直接的 shellcode 执行和通过简单溢出构建 ROP 链。攻击者再次适应，发展出绕过这些新防御的技术，例如信息泄漏（用于攻破 ASLR/PIE 和发现 Canary 值）和暴力破解。格式化字符串漏洞因此成为一种强大的工具，可用于信息泄漏乃至直接的内存操纵。这种历史演进清晰地展示了防御措施催生新的攻击策略，反之亦然的因果关系，导致攻防双方的技术都日趋复杂。本报告所讨论的机制正是这场持续“猫鼠游戏”中的一些快照。
2. RELRO (Relocation Read-Only)：保护全局数据
在动态链接的 ELF（Executable and Linkable Format）二进制文件中，全局偏移表（Global Offset Table, GOT）和过程链接表（Procedure Linkage Table, PLT）扮演着至关重要的角色。GOT 用于在运行时解析共享库中函数的地址 。PLT 则作为这些函数调用的中间层 。
2.1. 基础：动态链接中的 GOT 与 PLT
动态链接的 ELF 二进制文件包含 GOT，以便动态解析位于共享库中的函数 。函数调用实际上指向 .plt 节中的 PLT 。PLT 指示 GOT 中的一个地址，GOT 实际位于 .plt.got 节（通常称为 .got.plt） 。GOT 包含指向 PLT 的指针，函数的最终地址存储在此。
“延迟绑定”（Lazy Binding）是动态链接的一个核心机制。当程序首次调用某个共享库函数时（例如 printf），执行流首先跳转到该函数在 PLT 中的对应条目（如 printf@plt）。PLT 代码随后会调用动态链接器（如 ld.so）来解析该函数的真实内存地址。解析完成后，动态链接器会将这个真实地址写入 GOT 中与该函数对应的条目。之后对该函数的调用，PLT 会直接跳转到 GOT 中存储的真实地址，从而提高效率 。GOT 条目在延迟绑定过程中的可写性，恰恰是攻击者关注的一个关键点。
2.2. RELRO 解析：目的与机制
RELRO（Relocation Read-Only）是一种漏洞利用缓解技术，旨在保护进程内存中的数据段，特别是 GOT，防止其在漏洞利用过程中被覆盖 。RELRO 通过在加载时处理重定位，并在之后将相关内存区域设置为只读，来增强安全性。
2.3. Partial RELRO
Partial RELRO 通过编译选项 gcc -Wl,-z,relro 启用 。在 Partial RELRO 模式下，.got 段（通常包含数据指针或在链接时已解析的函数指针）被标记为只读。然而，用于延迟绑定的 .got.plt 段（包含通过 PLT 解析的函数指针）仍然保持可写状态 。这意味着，尽管提供了一定的保护，但如果攻击者拥有任意地址写入的漏洞利用原语（例如某些格式化字符串漏洞），他们仍然可能通过覆盖 .got.plt 中的条目来劫持函数调用，将执行流重定向到恶意代码 。Partial RELRO 还会调整 ELF 内部数据段的顺序，将 GOT 等关键数据结构移动到程序的变量之上，以防止常见的缓冲区溢出直接覆盖它们，但这并不能阻止例如格式化字符串漏洞造成的 GOT 覆写 。
2.4. Full RELRO
Full RELRO 是一种更强的缓解措施，通过编译选项 gcc -Wl,-z,relro,-z,now 启用 。在 Full RELRO 模式下，动态链接器会在程序启动时（执行前）解析所有动态链接符号的地址，这个过程称为“即时绑定”（Eager Binding）。完成所有符号解析后，整个 GOT（包括原本属于 .got.plt 的部分）都会被设置为只读 。
Full RELRO 极大地增强了对 GOT 覆写攻击的防御能力，因为在程序运行时 GOT 是不可写的。其代价是程序启动时间可能会略有增加，因为所有符号都需要在启动时解析，而不是按需解析 。
2.5. 对 GOT 覆写攻击的影响
Full RELRO 通过使 GOT 在运行时只读，有效地缓解了 GOT 覆写攻击 。攻击者传统上利用可写的 GOT 条目，将其指向恶意代码，从而在程序调用某个库函数时劫持控制流。Partial RELRO 由于 .got.plt 段仍然可写，因此对这类攻击的防御能力有限。
2.6. 检查 RELRO 状态
可以使用如 checksec 之类的工具来检查二进制文件的 RELRO 状态（No RELRO, Partial RELRO, 或 Full RELRO）。这对于防御者评估二进制文件的安全性以及攻击者进行前期侦察都非常重要。
2.7. RELRO 配置比较
下表总结了 Partial RELRO 和 Full RELRO 的主要区别：
| 特性 | Partial RELRO | Full RELRO |
|---|---|---|
| 编译选项 | -Wl,-z,relro | -Wl,-z,relro,-z,now |
.got 段只读 | 是 | 是 |
.got.plt 段只读 | 否 (可写) | 是 |
| 绑定类型 | 延迟绑定 (Lazy Binding) | 即时绑定 (Eager Binding) |
| 启动性能影响 | 较小 | 可能略有增加 |
| 对 GOT 覆写攻击的防护 | 有限 (可覆写 .got.plt) | 强 (整个 GOT 只读) |
此表清晰地展示了两种 RELRO 配置在启用方式、保护范围、链接机制、性能和安全性方面的核心差异，有助于理解它们各自的权衡。Partial RELRO 安全性较低但启动开销小，而 Full RELRO 更安全但启动时有轻微性能成本。
2.8. RELRO 的意义与局限
Partial RELRO 虽然将 .got 段设为只读，提供了一定保护，但其 .got.plt 段的可写性使其成为一个“阿喀琉斯之踵”。拥有精确写入能力的攻击者（如利用格式化字符串漏洞）仍可针对 .got.plt。这是因为 .got.plt 存储了动态链接库函数的指针，覆写这些指针即可劫持控制流，从而绕过了 Partial RELRO 对这些特定条目的保护意图。
两种 RELRO 级别（Partial 和 Full）的存在，以及在旧系统中 Partial RELRO（甚至无 RELRO）的普遍性，突显了性能与安全之间的根本权衡。Full RELRO 的即时绑定虽然更安全，但会带来启动时间成本，对于性能敏感的应用，开发者可能会避免使用 。这种实际考量往往决定了所实施的安全级别。然而，像 Fedora 等较新的发行版默认启用 Full RELRO ，表明安全优先级正在超越这种微小的启动成本。
RELRO 专门防御 GOT 条目的覆写。它不能阻止其他形式的内存损坏或控制流劫持（例如，覆写存储在其他地方的函数指针，或栈溢出除非它们间接目标是 GOT）。RELRO 是一种针对特定攻击向量的定向防御，必须作为更广泛防御体系的一部分。
3. 栈 Canary：检测栈粉碎攻击
栈 Canary（也称栈 Cookie 或安全 Cookie）是一种用于检测栈缓冲区溢出的安全机制。其核心思想是在栈上放置一个“哨兵”值，如果该值被改变，则表明发生了溢出。
3.1. 核心原理：缓冲区溢出的“绊脚石”
栈 Canary 是一个秘密值，由编译器在编译时插入到栈帧中，位于局部变量（尤其是缓冲区）和控制数据（如保存的帧指针 EBP/RBP 和返回地址 RIP）之间 。由于栈上缓冲区溢出通常从低地址向高地址覆盖内存，因此在覆盖返回地址之前，必须先覆盖 Canary 值 。
在函数返回之前，程序会检查栈上的 Canary 值是否与其原始副本（通常存储在一个安全的位置，如线程本地存储或全局变量中）一致。如果 Canary 值发生了改变，表明发生了栈溢出，程序通常会调用一个特殊的处理函数（如 __stack_chk_fail），该函数会终止程序运行 。这样，潜在的代码执行漏洞就被转化为拒绝服务攻击。可以将 Canary 比作一个“秘密的盘子”，夹在可见的盘子之间，用于检测对栈的篡改尝试 。
3.2. 实现细节
3.2.1. 初始化
Canary 值通常是一个在程序启动时生成的随机或伪随机数 。它可以从一个全局变量（如 __stack_chk_guard）中初始化 。
在 Linux 系统中，Canary 值的随机性来源多样：
- 内核通过辅助向量（Auxiliary Vector）中的
AT_RANDOM项向用户空间程序传递一个随机数，glibc 和 musl libc 等 C 标准库会利用这个值来生成 Canary 。 /dev/urandom是另一个常用的随机数来源 。- 在某些特定情况下（例如，libssp 编译且系统无
/dev/urandom），可能存在回退机制，使用随机性较差甚至硬编码的值 。
为了增强对基于字符串的溢出（如 strcpy）的防御，Canary 的最低有效字节（LSB）通常被设置为 0（空字节），这利用了 Canary 的“终结者”特性，因为很多字符串操作函数遇到空字节会停止复制 。
3.2.2. 栈帧中的位置
编译器在函数的序言（prologue）部分将 Canary 值放置到栈帧上。在栈向下生长的架构中，典型的放置顺序是：首先存储 Canary，然后是可能发生溢出的缓冲区，最后是其他不易受溢出影响的局部小变量 。这种顺序的启发式思想是，修改数组通常比破坏持有标志、指针和函数指针的变量危险性小 。
3.2.3. 验证
在函数的尾声（epilogue）部分，即函数返回之前，栈上存储的 Canary 值会与参考值（如从 __stack_chk_guard 加载的值或存储在线程本地存储中的值）进行比较。如果不一致，则调用 __stack_chk_fail 函数，程序终止 。一个 GDB 回溯示例显示，当 __stack_chk_fail（通过 __GI_abort）被触发时，程序会收到 SIGABRT 信号 。
3.3. Canary 类型与编译器选项
- 终结者 Canary (Terminator Canaries): 包含空字节 (0x00)、回车 (0x0d)、换行 (0x0a)、文件结束符 (0xff) 等，旨在阻止基于字符串操作的溢出 。
- 随机 Canary (Random Canaries): 随机生成，使其值不可预测 。
- 异或 Canary (XOR Canaries): 将随机值与控制数据（如返回地址）进行异或操作，增加了破解的复杂性 。
编译器通过特定选项来启用栈保护，如 GCC 中的：
-fstack-protector: 为包含特定类型“易受攻击对象”（如大于 8 字节的缓冲区或调用alloca）的函数启用 Canary。-fstack-protector-strong: 类似于-fstack-protector，但覆盖范围更广，包括定义了局部数组或引用了局部栈帧地址的函数。这通常是现代编译器中较为常见的默认选项。-fstack-protector-all: 为所有函数启用 Canary，无论其是否包含易受攻击对象。这会带来更大的性能开销 。
3.4. 熵与强度
随机 Canary 的有效性取决于其熵（随机比特数）。一个 32 位的 Canary 有
种可能性，64 位 Canary 则有
种。如果 Canary 的某个字节是固定的（如空字节用作终结符），则其熵会降低。例如，一个 64 位 Canary 若有一个字节固定为 0x00，则其有效熵为 56 位 (
) 。
较低的熵（例如，在 32 位系统上，若 Canary 只有 3 个字节是随机的）会使得暴力破解在某些情况下变得可行，尤其是在攻击者可以多次尝试的场景下（如 forking 服务器）。
3.5. Canary 的意义与局限
尽管 Canary 能有效检测许多常见的栈溢出，但其强度（尤其是随机 Canary）是概率性的。如果攻击者能够猜到 Canary 值或通过信息泄漏手段获取它，那么这项保护就会失效 。这表明 Canary 并非完美的屏障。随机 Canary 依赖于其值的保密性 。如果该值被泄漏（例如，通过格式化字符串等信息泄漏漏洞），攻击者就能知道应该写回什么值以通过检查。如果 Canary 的熵较低，攻击者可能通过暴力破解猜出它，特别是在进程会重启的场景（如 forking 服务器）。因此，Canary 更像是一个高概率的检测器，而非绝对的预防方法，其有效性取决于其保密性和熵。
许多 Canary 实现中，其最低有效字节（LSB）包含一个空字节 。这具有双重作用：对于常见的字符串复制函数（如 strcpy），它充当“终结符”，可能在溢出到达 Canary 主体或返回地址之前就阻止溢出 。然而，这也略微降低了 Canary 随机部分的熵 。这种设计在针对特定字符串溢出的更好保护与随机部分略弱的抗暴力破解能力之间做出了权衡。
Canary 主要防御那些向高地址顺序破坏栈以达到返回地址的溢出。它们不能防御：
- 仅破坏局部变量而未触及 Canary 的溢出 。
- 能够直接针对返回地址或其他关键数据进行写操作的任意内存写漏洞（如某些格式化字符串利用），这些漏洞可以不覆盖 Canary 。
- 覆写存储在其他位置（如堆、数据段）的函数指针。 这意味着 Canary 对特定模式的栈溢出有效，但并非所有控制流劫持的通用解决方案。
4. ASLR (Address Space Layout Randomization)：模糊内存布局
地址空间布局随机化（ASLR）是一种安全特性，通过在程序每次运行时随机化其关键数据区域的基地址，来增加漏洞利用的难度。
4.1. 核心原理：使内存不可预测
ASLR 在进程每次启动时，会随机化其地址空间中关键数据区域的位置。这些区域包括可执行文件的基址（如果启用了 PIE）、栈、堆以及加载的共享库（如 libc）。其目的是使攻击者难以预测其目标的绝对地址（例如 ROP gadgets、shellcode、关键数据结构），从而阻止依赖硬编码地址的漏洞利用 。
4.2. Linux 中的随机化级别 (/proc/sys/kernel/randomize_va_space)
Linux 内核通过 /proc/sys/kernel/randomize_va_space 参数控制 ASLR 的行为。该参数可以设置为以下三个值之一，代表不同的随机化级别 ：
- 0: 禁用 ASLR。 不进行任何随机化。如果内核以
norandmaps参数启动，也会应用此设置 。 - 1: 保守随机化。 随机化栈、VDSO（Virtual Dynamic Shared Object）页和共享内存区域的位置。数据段的基址紧随可执行代码段之后 。
- 2: 完全随机化 (默认值)。 除了级别 1 随机化的区域外，还随机化数据段（包括堆）的位置 。
可以通过临时写入 /proc/sys/kernel/randomize_va_space 文件或修改 /etc/sysctl.conf 文件（并执行 sysctl -p）来永久更改此设置 。
下表总结了 Linux 中 ASLR randomize_va_space 的不同级别：
| 值 | 描述随机化的区域 | 默认设置 | | — | ---------------------------------------------------- | -------- | | 0 | 禁用 ASLR | 否 | | 1 | 随机化栈、VDSO、共享内存区域 | 否 | | 2 | 随机化栈、VDSO、共享内存区域、数据段（堆） | 是 |
此表清晰地概括了 Linux 中可用的不同 ASLR 强度级别，有助于理解每个级别随机化的范围以及为何级别 2 是更安全的默认设置。
4.3. 随机化熵
ASLR 的有效性取决于应用于每个地址的熵（随机比特数）。
-
在 32 位系统上，由于地址空间有限（最大 4GB），ASLR 的熵较低，使其相对较弱 。
-
在 64 位系统上，地址空间远大于 32 位系统，因此可以实现更高的熵。
-
对于 32 位 Linux 系统，栈的熵大约为 19 位（总共 32 位地址 - 12 位用于页对齐 - 1 位用于内存分区）。这意味着栈基址有
8×256
次尝试）。 其可行性取决于Canary的熵（例如，32位系统上3个随机字节的Canary更容易被暴力破解）。 #### 6.2.2. 暴力破解ASLR 在32位系统上，由于地址空间较小，熵较低，因此暴力破解ASLR更为可行 。如果一个地址只有少数几位是随机化的，或者攻击者可以多次尝试（例如，针对一个会重启的网络服务），那么暴力破解也是一种选择。堆喷射（Heap Spraying）可以被视为一种概率性的ASLR绕过方法，攻击者用其载荷填充大部分堆空间，以增加命中载荷的几率 。 ### 6.3. 部分覆写 (ASLR绕过) 核心思想是，如果攻击者只能覆写指针的一部分（例如，最低有效字节），他们仍有可能将控制流重定向到一个有用的位置，前提是未被覆写的高位字节仍然指向一个有效的（并且可能部分可预测的）内存区域 。例如，如果ASLR随机化了地址的高位，但攻击者可以覆写返回地址或函数指针的低1或2个字节，他们可能能够将目标更改到同一大致内存区域内的不同位置（例如，一个大的代码段内）。这种技术高度依赖于具体的ASLR实现细节和允许部分覆写的漏洞。 ### 6.4. 绕过技术的意义与影响 信息泄漏是攻破Canary和ASLR的最有效手段。一次成功的泄漏可以将这些概率性防御转变为对攻击者而言的确定性攻击。这突显了防止信息泄漏漏洞的至关重要性。Canary依赖保密性，ASLR依赖地址的不可预测性。信息泄漏可以揭示Canary的值 ，或者揭示随机化区域的基地址或指针，从而可以计算其他地址 。一旦秘密值（Canary）或随机偏移（ASLR）已知，防御在该特定实例或区域就 фактически被绕过。因此，泄漏内存的漏洞（如格式化字符串、未初始化读取、堆元数据暴露）对攻击者极具价值，因为它们可以中和这些广泛部署的缓解措施。 forking网络服务器的架构（例如旧版Apache）为Canary的暴力破解创造了“完美风暴”。克隆的地址空间（包括Canary值）以及崩溃的工作进程的自动重启，为攻击者提供了几乎无限次的尝试机会，且不易引起警报。这是一种特定的架构模式，显著削弱了Canary的保护作用 。暴力破解Canary通常需要多次尝试，每次失败的尝试（错误的Canary猜测）都会导致进程崩溃 。在独立应用程序中，反复崩溃是显而易见的，会中止攻击。forking服务器为新的连接/任务创建新的子进程，父进程通常在子进程崩溃时仅重启它 。关键是，派生的子进程通常从父进程继承相同的Canary值 。这允许攻击者每次连接/子进程进行一次猜测。崩溃仅限于子进程，父进程为下一次猜测提供了具有*相同Canary*的新目标。这将通常嘈杂且自败的暴力破解转变为一种安静而有效的攻击。 ASLR的有效性并非一成不变。它在32位系统（熵低）、针对非PIE可执行文件（代码基址固定）或与信息泄漏结合时，效果会大打折扣。这种可变性意味着“ASLR已启用”并不足以说明安全性；具体环境至关重要 。ASLR的强度由熵衡量——可能随机位置的数量。32位系统的地址空间远小于64位系统，固有地限制了ASLR的熵 ，使得暴力破解或猜测更可行。如果可执行文件不是PIE，其主要代码和数据段不会随机化，提供了固定的ROP gadget来源 ，ASLR仅保护库、栈、堆。如前所述，信息泄漏可以精确定位基地址，从而消除该泄漏段的随机化 。因此，简单地说“ASLR已开启”可能会产生误导。必须考虑架构（32/64位）、PIE状态以及信息泄漏的可能性，才能真正评估其在特定场景下的保护价值。 ## 7\. 格式化字符串漏洞：一种多功能的利用原语 格式化字符串漏洞是一种当用户提供的输入被直接用作格式化函数（如`printf`、`sprintf`、`snprintf`等）的格式字符串参数时产生的安全问题 。 ### 7.1. 核心原理：用户控制的格式字符串参数 C语言中的这类格式化函数是可变参数函数（variadic functions），它们根据格式字符串中存在的格式说明符（如`%d`, `%s`, `%x`, `%p`, `%n`）来确定从栈上期望多少个参数以及这些参数的类型。如果攻击者能够控制格式字符串，他们就可以提供特定的说明符，导致函数从栈上读取意料之外的数据，或向栈上甚至任意内存地址写入数据 。 ### 7.2. 触发漏洞 当应用程序将未经校验的用户输入（其中可能包含格式说明符）传递给格式化函数时，漏洞即被触发 。例如，`printf(user_input);` 如果`user_input`是`"%x %x %x"`，就会触发漏洞 。安全的做法是`printf("%s", user_input);` 。 ### 7.3. 利用技术：读取内存 - **`%x`, `%p` (读取栈值):** 这些说明符分别从栈中弹出一个值，并以十六进制整数或指针的形式打印。重复使用它们（如`%x%x%x`或`%p%p%p`）可以让攻击者转储栈上的连续值 。 - **`%s` (读取栈值所指向的数据):** 此说明符从栈中弹出一个值，将其视作地址（指针），并打印该地址处的空终止字符串。如果攻击者能将期望的地址放到栈上，就能用`%s`来解引用它并读取任意内存内容 。 - **直接访问参数 (`%N$x`, `%N$p`, `%N$s`):** 这些允许从栈上特定的参数位置读取数据（例如，`%7$x`读取第7个参数/栈值）。这对于精确定位栈上的特定数据非常有用，无需弹出所有前面的值 。 ### 7.4. 利用技术：写入任意内存 - **`%n` (写入已输出的字节数):** 此说明符从栈中取一个指针作为参数，并将`printf`到目前为止已成功写入的字节总数写入该指针所指向的内存位置 。 - **控制写入的值 (填充):** 攻击者通过控制在`%n`说明符之前打印的字符数量来控制由`%n`写入的值。这通常通过宽度说明符（如`%100x`打印至少100个字符）或简单地打印一定数量的虚拟字符来实现 。 - **`%hn` (短整型写入), `%hhn` (字节写入):** `%n`的这些变体分别允许写入2字节或1字节，从而对内存写入提供更细粒度的控制。这对于精确覆写至关重要，例如修改返回地址或Canary的一部分，而不过多干扰相邻字节 。 - **放置目标地址:** 要写入任意地址，攻击者必须首先将该地址放到栈上，以便`%n`可以将其用作参数。这可以通过将地址嵌入格式字符串本身（如果格式字符串的部分内容位于栈上），或使用直接访问参数使`%n`指向栈上已有的地址来实现。 ### 7.5. 常见利用的格式说明符 下表总结了在利用格式化字符串漏洞时最常用的格式说明符： | **说明符** | **利用目的** | **示例用法 (简要)** | | --- | --- | --- | | `%x` | 以十六进制读取栈值 | `AAAA%x%x` | | `%p` | 以指针形式读取栈值 | `AAAA%p%p` | | `%s` | 读取栈值所指向地址的字符串 | `[addr]%s` | | `%d` | 以十进制整数读取栈值 (可用于控制输出字节数) | `%100d` (填充) | | `%c` | 读取单个字节 (可用于精确控制输出字节数) | `%c` | | `%n` | 将已输出字节数写入栈值所指向的地址 (4字节) | `AAAA%10x%n` | | `%hn` | 将已输出字节数写入栈值所指向的地址 (2字节) | `AAAA%10x%hn` | | `%hhn` | 将已输出字节数写入栈值所指向的地址 (1字节) | `AAAA%10x%hhn` | | `%N$x` | 读取第N个参数/栈值 (十六进制) | `%7$x` | | `%N$s` | 读取第N个参数/栈值所指向的字符串 | `%7$s` | | `%N$n` | 将已输出字节数写入第N个参数/栈值指向的地址 | `[addr_payload]%7$n` | 此表可作为快速参考，帮助理解在利用格式化字符串漏洞时各种说明符在读取或写入内存中的具体作用。 ### 7.6. 格式化字符串漏洞的意义与影响 单一的格式化字符串漏洞可以赋予攻击者强大的原语：任意内存读取*和*任意内存写入。这种多功能性使其极为危险，因为它们可用于攻破多种其他保护机制（泄漏Canary、泄漏ASLR偏移、覆写返回地址/GOT条目）。格式化字符串漏洞不仅仅是一种特定类型的漏洞利用，它更是一个通往多种漏洞利用技术的大门，使其成为一种高度关键的漏洞。 直接访问参数（`%N$specifier`）显著增强了格式化字符串漏洞的可利用性 。没有它们，攻击者可能需要打印（并可能受限于缓冲区大小）许多中间栈值才能到达目标。直接访问允许精确定位栈偏移以进行读取和写入，使漏洞利用更可靠且噪音更小。传统的格式化字符串利用若无直接访问参数（例如`printf("AAAA%x%x%x%s")`），需要按顺序消耗栈参数。如果期望的数据/指针在栈的深处，格式字符串可能会变得非常长，或者输出量可能暴露行踪或引发问题。而像`%7$x`这样的直接访问参数允许`printf`直接跳转到栈上的第7个参数 。这意味着攻击者可以精确定位包含Canary、待泄漏指针或待写入地址的栈槽，而无需用其他说明符处理中间的栈槽。这使得漏洞利用更短、更精确，并且通常更容易构建。 `%n`说明符，结合对写入字节数的控制（通过填充）以及将目标地址放置在栈上的能力（通常在格式字符串本身之内），有效地为攻击者提供了“写任意值到任意地址”（write-what-where）的原语：他们可以将一个（几乎）任意的值写入一个（几乎）任意的内存位置。这是攻击者所能获得的最强大的能力之一。`%n`将到目前为止打印的字节数写入一个地址 。“到目前为止打印的字节数”（“what”）可以由攻击者使用格式字符串中的填充字符或宽度说明符来控制 。“地址”（“where”）作为`%n`的参数从栈中获取。攻击者通常可以通过将其期望的目标地址包含在格式字符串本身中（如果格式字符串缓冲区在栈上），然后使用直接访问参数或消耗先前的栈参数，使`%n`使用此地址。控制“what”被写入和“where”它被写入的组合构成了写任意值到任意地址的条件，这是漏洞利用中非常追求的原语。`%hn`和`%hhn`提供了对“what”大小的更精细控制 。 ## 8\. 案例研究：通过格式化字符串漏洞泄露栈Canary以实现ROP攻击 本节将通过一个典型的场景，阐述如何利用格式化字符串漏洞泄露栈Canary，并结合缓冲区溢出进行ROP攻击，从而绕过现代操作系统的多种安全防护。 ### 8.1. 场景概述 假设存在一个程序，它同时包含格式化字符串漏洞和栈缓冲区溢出漏洞。该程序编译时启用了栈Canary保护和ASLR（可能还包括PIE）。攻击目标是： 1. 利用格式化字符串漏洞泄露栈Canary的值。 2. 利用缓冲区溢出漏洞，结合已泄露的Canary值和精心构造的ROP链，覆写返回地址，最终劫持程序控制流以执行任意代码（例如，弹出一个shell）。 此场景在CTF竞赛和真实世界的漏洞利用中都较为常见 。 ### 8.2. 阶段一：泄露栈Canary #### 8.2.1. 确定Canary在栈上的偏移 要通过格式化字符串漏洞泄露Canary，首先需要确定Canary值在栈上相对于格式化函数（如`printf`）参数的位置。这通常需要借助调试器（如GDB）进行动态分析 。攻击者可以输入一连串的格式说明符，如`%lx-%lx-%lx...`（或在64位系统上更常用`%llx`或`%p`），来转储栈上的内容。通过观察输出，并与调试器中已知的栈值（或在`__stack_chk_fail`调用前断点处观察到的Canary值）进行比对，可以确定Canary是第几个被转储的值。例如，如果在的案例中，Canary是第41个被`%llx`转储的值，那么就可以使用格式字符串`%41$llx`（或`%41$lx`）来直接读取它。 #### 8.2.2. 构造泄露Canary的格式化字符串载荷 一旦确定了偏移量N，攻击者就可以构造如`"%N$lx"`这样的输入字符串。程序执行时，其输出将包含Canary的十六进制值。攻击脚本需要解析此输出来提取Canary。 ### 8.3. 阶段二：构造并执行ROP链 #### 8.3.1. 绕过ASLR 如果目标程序或其依赖的库（如libc）启用了ASLR（以及PIE对可执行文件本身），那么ROP gadgets和目标函数（如`system`）的地址在每次运行时都是随机的。 - **利用格式化字符串漏洞泄露模块基址：** 格式化字符串漏洞本身除了泄露Canary，也可能被用来泄露栈上保存的其他指针，例如指向libc或主可执行文件代码段的返回地址、GOT表中的条目等。一旦获得模块内的任一地址，就可以通过已知的相对偏移计算出该模块的基地址。 - **其他信息泄漏漏洞：** 如果仅靠格式化字符串漏洞不足以方便地泄露模块地址，可能需要结合其他类型的信息泄漏漏洞。 #### 8.3.2. 寻找ROP Gadgets 在确定了目标模块（如libc或主程序）的基地址后，可以使用ROPgadget、Ropper等工具在该模块中搜索有用的ROP gadgets 。典型的gadgets包括： - 控制参数寄存器的gadgets：例如，在x64系统上调用`system(command_string)`，需要将`command_string`的地址加载到`RDI`寄存器，因此`pop rdi; ret`这样的gadget非常关键。 - 目标函数的地址：通常是PLT表中的地址（如`system@plt`），或者直接是libc中`system`函数的地址（如果已解析）。 #### 8.3.3. 构造缓冲区溢出载荷 最终的缓冲区溢出载荷通常包含以下部分，按顺序排列： 1. **填充字节 (Junk)：** 一定数量的任意字节，用于填满缓冲区，直到Canary的位置。 2. **泄露的Canary值：** 将阶段一泄露的Canary值放置在此处，以确保通过`__stack_chk_fail`的检查。 3. **填充字节 (Junk)：** 可能需要更多填充字节以覆盖保存的帧指针(EBP/RBP)。 4. **ROP链的起始地址：** 这是覆写原返回地址的关键部分。 - 第一个gadget的地址（例如，`pop rdi; ret`的地址）。 - 为第一个gadget准备的参数（例如，`"/bin/sh"`字符串的地址）。这个字符串本身也需要被放置到内存中一个已知或可预测的位置。有时可以利用格式化字符串的写入能力（`%n`）来实现，或者如果程序的数据段中有可控的缓冲区，也可以利用。 - 第二个gadget的地址（例如，`system@plt`的地址）。 - （可选）后续gadgets，如`exit@plt`的地址，以实现程序在shell退出后能够干净地终止。 中的案例详细描述了载荷结构：首先是到达Canary的偏移，然后是到达RBP的偏移，最后是RIP（返回地址）。则解释了为调用`system`而构造ROP链的具体方法。 #### 8.3.4. 执行攻击 攻击脚本通常分两步执行： 1. 首先发送精心构造的格式化字符串输入，触发漏洞，从程序输出中解析出泄露的Canary值。 2. 然后，构造包含已泄露Canary值和ROP链的缓冲区溢出载荷，发送给程序，触发溢出，劫持控制流，执行ROP链。 ### 8.4. 案例分析的意义与影响 这个案例研究清晰地展示了攻击者如何将多个看似独立的漏洞串联起来以达到更具破坏性的效果。格式化字符串漏洞（提供信息泄漏/任意读能力）使得栈Canary保护被绕过，进而使得缓冲区溢出漏洞（提供内存破坏/控制流劫持能力）能够通过ROP成功利用。单独来看，这两个漏洞的威力可能都较为有限。这种漏洞链的利用方式突显了纵深防御的重要性，同时也揭示了单一防御机制可能存在的弱点。 漏洞利用的核心在于获取并组合利用原语。格式化字符串漏洞提供了关键的“读”原语（用于获取Canary和可能的ASLR相关地址），有时也提供“写”原语（如果需要写入`/bin/sh`字符串或ROP链的部分内容且方便的话）。一旦Canary被绕过，缓冲区溢出则提供了“控制流劫持”原语。成功的复杂漏洞利用通常就是识别并组合这些基本原语的过程。 确定Canary或其他泄露数据在栈上的精确偏移几乎总是需要动态分析（调试）。仅凭静态分析往往不足以应对编译器优化、变化的栈布局以及运行时因素带来的复杂性。这强调了漏洞利用开发过程中动手实践和迭代调试的本质 。栈的确切布局（局部变量、Canary、保存的寄存器的偏移）可能因编译器、编译标志甚至特定的函数调用路径而异。静态分析可以提供一个大致的了解，但格式化字符串利用所需的精确偏移（例如，哪个`%N$x`能命中Canary）最好通过在运行时观察程序状态来找到。像GDB这样的调试器允许攻击者在执行期间检查内存、寄存器和栈 。攻击者使用调试器发送测试输入，观察其输入在栈上的位置，以及目标数据（如Canary）的距离。这种测试、观察和改进的迭代过程是这类漏洞利用开发的基础。 ## 9\. 返回导向编程 (ROP) 原理 返回导向编程（Return-Oriented Programming, ROP）是一种先进的漏洞利用技术，攻击者通过控制程序的调用栈，来执行内存中已存在的、精心挑选的短指令序列（称为“gadgets”），从而实现任意代码执行的效果。 ### 9.1. 核心概念：重用现有代码 (“Gadgets”) ROP的核心思想是，攻击者并不注入新的恶意代码，而是利用程序自身代码段或其加载的共享库中已存在的指令片段 。每个gadget通常以一个`ret`（返回）指令结束。攻击者通过缓冲区溢出等漏洞控制栈内容，将栈上原本存储返回地址的区域覆写为一系列指向这些gadgets的地址。当一个gadget执行完毕并遇到其末尾的`ret`指令时，CPU会从栈顶弹出一个地址作为新的指令指针，从而跳转到下一个gadget执行。如此反复，形成一条gadget链，达到攻击者预期的复杂操作 。由于ROP执行的是内存中已标记为可执行的代码，它能够有效绕过NX/DEP（数据执行保护）等阻止在栈或堆上执行注入代码的防御机制 。 ### 9.2. ROP Gadgets - **定义：** ROP gadget是指以`ret`指令（或者在某些变体如JOP/COP中，以`jmp reg`或`call reg`指令）结尾的短指令序列 。 - **特性：** Gadgets通常执行一些简单的、有用的操作，例如： - 将栈上的值加载到寄存器 (如 `pop rdi; ret`) - 在寄存器之间移动数据 (如 `mov rax, rbx; ret`) - 执行算术或逻辑运算 (如 `add eax, ebx; ret`) - 从内存加载数据到寄存器 (如 `mov rax, [rdi]; ret`) - 将寄存器的值存储到内存 (如 `mov [rdi], rax; ret`) 。 - **发现：** Gadgets通常通过扫描目标二进制文件及其加载的库的可执行代码段来发现。具体方法是在代码中搜索`ret`指令的操作码，然后反汇编其前面的若干字节以识别出有用的指令序列。有多种自动化工具可以辅助这一过程，如ROPgadget、Ropper、`rp++`、`mona.py`等 。 ### 9.3. ROP链的构造与栈控制 攻击者通过漏洞（如栈溢出）覆写栈的一部分，精心构造一个虚假的调用栈帧。这个栈帧的内容大致如下（从低地址到高地址，即栈顶方向）： 1. 第一个gadget的地址。 2. （如果第一个gadget需要从栈上`pop`数据）为第一个gadget准备的数据。 3. 第二个gadget的地址。 4. （如果第二个gadget需要数据）为第二个gadget准备的数据。 5. 以此类推，直到ROP链结束 。 当存在漏洞的函数执行`ret`指令时，它会从栈顶弹出第一个gadget的地址，并跳转到该地址执行。第一个gadget完成其操作后，其末尾的`ret`指令又会从栈顶弹出第二个gadget的地址，并跳转执行。这个过程持续进行，直到整个ROP链执行完毕。 ### 9.4. ROP链中的参数传递 (例如为`system()`传递参数) 参数传递的方式因体系结构（如32位与64位）和调用约定（Calling Convention）的不同而异。 - **32位系统 (如cdecl调用约定)：** 参数通常直接通过栈传递。攻击者构造的ROP链会在栈上依次放置目标函数的地址（如`system@plt`）、一个伪造的返回地址（`system`函数返回后跳转的地址，通常不重要），然后是函数的参数（如`"/bin/sh"`字符串的地址）。 - **64位系统 (如System V AMD64 ABI)：** 前几个参数通常通过寄存器传递（通常是`RDI`, `RSI`, `RDX`, `RCX`, `R8`, `R9`）。因此，ROP链必须包含能够将参数值加载到这些寄存器的gadgets。例如，要调用`system(command_string)`，需要找到一个类似`pop rdi; ret`的gadget，先将`command_string`的地址压栈，然后通过这个gadget将其加载到`RDI`寄存器，之后再跳转到`system`函数的地址 。 ### 9.5. ROP的意义与演进 通过精心挑选和串联足够多样化的gadgets，攻击者理论上可以执行任意计算，使得ROP成为一种图灵完备的攻击方法 。这意味着攻击者不仅限于调用已有的函数，还可以构建出全新的行为逻辑。ROP gadgets执行基本操作：加载、存储、算术、条件跳转（如果存在这类gadgets）。这些基本操作是计算的构建块。如果攻击者能找到足够丰富的gadgets集合并有效地将它们链接起来，他们就能组合这些简单操作以实现复杂的逻辑，包括循环和分支 。图灵完备性意味着能够计算任何可计算函数。因此，ROP从一种简单的“调用函数”技术转变为一种使用受害者自身代码构建任意恶意逻辑的方法。 ROP攻击的可行性和复杂性在很大程度上取决于目标二进制文件及其加载库中可用gadgets的丰富程度。如果gadgets集合稀疏，某些操作可能无法实现或变得非常复杂。这就是为什么攻击者经常以大型库（如libc）为目标，因为这些库中通常包含大量多样的代码序列，更容易找到所需的gadgets。ROP链由gadgets构建而成 。每个gadget执行一个特定的小任务 。为了实现复杂目标（例如，设置多个寄存器、调用一个函数，然后再调用另一个函数），需要按特定顺序使用特定类型的gadgets。如果ROP所需的某个gadget（例如，需要控制RDX时，缺少`pop rdx; ret`）在程序可访问的内存空间中不可用，攻击者就无法轻易执行该部分操作。大型复杂的库（如libc）往往有大量的代码，增加了找到各种有用gadgets的概率 。因此，ROP的“攻击面”部分取决于目标进程地址空间中gadgets集的丰富程度。 ROP主要使用`ret`指令。其变种，如跳转导向编程（Jump-Oriented Programming, JOP）使用`jmp reg`类型的gadgets，调用导向编程（Call-Oriented Programming, COP）使用`call reg`类型的gadgets。这些变种的出现是为了绕过那些专门针对`ret`指令的防御措施（例如某些CFI实现或返回地址验证）。这显示了攻击技术的持续演化。ROP依赖`ret`指令来链接gadgets 。防御措施可能会专门监控或验证`ret`指令（例如，确保它们返回到`call`指令之后的位置）。为了绕过此类防御，攻击者寻找其他可用于链接的间接控制流指令。如果寄存器可以从栈中控制（例如，`pop rax; jmp rax;`），那么`jmp <register>`或`call <register>`指令可以起到与`ret`类似的作用。这导致了JOP和COP的发展，它们在概念上与ROP相似，但使用不同类型的gadgets进行链接，展示了代码重用攻击的适应性。 ## 10\. 安全编码实践与高级防御 尽管存在各种运行时缓解技术，但从源头上预防漏洞仍然是构建安全软件的基石。此外，随着攻击技术的发展，新的高级防御机制也在不断涌现。 ### 10.1. 预防格式化字符串漏洞 预防格式化字符串漏洞最有效的方法是遵循安全的编码实践： - **始终提供静态的、字面的格式字符串：** 这是最关键的一点。用户输入应始终作为格式字符串的参数传递，而不是作为格式字符串本身。例如，应使用`printf("%s", user_input);` 而不是 `printf(user_input);` 。 - **启用并关注编译器警告：** 现代编译器（如GCC）通常能够检测到格式化函数的不安全使用，并发出警告（例如`-Wformat-security`）。开发者应启用这些警告并修复所有相关问题 。 - **进行源代码审计：** 使用静态分析（SAST）和动态分析（DAST）工具来扫描代码库，以发现潜在的格式化字符串漏洞，尤其是在处理遗留代码时 。 - **使用安全的替代函数或方法：** 如果可用，应优先选择那些设计上更安全，或能限制危险格式说明符的函数库或API。 ### 10.2. 更广泛的视角：纵深防御与高级缓解技术 没有任何单一的防御机制是完美的。RELRO、Canary、ASLR、PIE和NX等机制协同工作时效果最佳，构成多层防御。面对ROP等高级利用技术，研究人员和业界也在开发更先进的防御手段： - **控制流完整性 (Control Flow Integrity, CFI)：** CFI旨在确保程序的间接分支（如通过函数指针或虚函数表的调用）只能跳转到预期的、合法的目标地址，从而阻止攻击者将控制流劫持到任意gadgets 。 - **指针认证码 (Pointer Authentication Codes, PAC)：** 主要在ARM架构中实现，PAC通过为指针（尤其是返回地址和函数指针）附加一个加密签名。在指针被解引用之前，硬件会验证这个签名。如果签名无效，表明指针已被篡改，从而阻止利用 。 - **内存标记扩展 (Memory Tagging Extension, MTE)：** 同样是ARM架构的一项特性，MTE为内存分配和指向这些分配的指针关联“标签”。在内存访问时，硬件检查指针标签与内存标签是否匹配，不匹配则表明可能存在内存安全违规（如缓冲区溢出、UAF），从而阻止非法访问 。 - **影子栈 (Shadow Stacks) / 受保护控制栈 (Guarded Control Stack, GCS)：** 这些机制在内存中维护一个受保护的、与主调用栈并行的“影子栈”，专门用于存储返回地址。在函数返回时，主栈上的返回地址会与影子栈中的副本进行比较，如果不一致则表明发生攻击 。 ### 10.3. 防御策略的深层思考 尽管运行时缓解技术至关重要，但预防格式化字符串漏洞（以及许多其他漏洞）的最有效方法是从一开始就采用安全的编码实践。在源头上修复漏洞总是优于仅仅依赖下游的缓解措施来捕获利用尝试 。格式化字符串漏洞源于一个特定的编码错误：将用户输入用作格式字符串 。安全的编码实践规定提供静态格式字符串并将用户数据作为参数传递 。如果遵循此实践，则该类漏洞将被消除。运行时缓解措施（ASLR、Canary等）旨在在漏洞*确实*存在时增加利用难度。因此，通过安全编码从一开始就防止漏洞是最根本和最有效的防御。 针对RELRO、Canary、ASLR、PIE等个体机制甚至ROP本身的绕过方法的存在，突显了分层安全方法的必要性。每一层都增加了攻击者的工作难度，一层防御的失败可能会被另一层捕获。本报告详细介绍了对RELRO（Partial RELRO）、Canary（泄漏、暴力破解）、ASLR（泄漏、暴力破解、部分覆写）和PIE（泄漏）的绕过方法。ROP绕过了NX/DEP。像CFI、PAC、MTE这样的高级防御旨在对抗ROP和其他高级攻击 。然而，即使是这些高级防御也可能有局限性或潜在的绕过方法（例如，粗粒度的CFI）。没有单一的防御是万能药。因此，强大的安全态势依赖于部署多种、多样化的安全机制。如果攻击者绕过一个，他们仍然面临其他机制，从而增加了利用的总体难度和成本。 `checksec` 、ROP gadget查找工具 和源代码审计工具 的提及，指向了自动化领域的军备竞赛。防御者使用工具来识别弱点并应用保护，而攻击者则使用工具来查找gadgets并自动化部分漏洞利用的生成。防御者使用`checksec`来验证二进制保护 。防御者使用静态/动态分析工具来查找像格式化字符串这样的漏洞 。攻击者使用像ROPgadget这样的工具来查找ROP gadgets 。像`pwntools`这样的漏洞利用框架有助于自动化漏洞利用的构建 。这表明攻防安全实践都越来越依赖自动化工具来管理复杂性和规模。新工具和技术的开发是双方持续进行的过程。 ## 11\. 结论 本报告深入探讨了RELRO、栈Canary、ASLR和PIE这四种关键的现代二进制安全机制的原理。分析表明，这些机制通过对内存布局、全局数据和栈完整性的保护，显著提高了漏洞利用的门槛。 然而，正如详细讨论的那样，这些防御并非坚不可摧。攻击者可以通过内存泄漏漏洞（尤其是利用格式化字符串漏洞）来获取Canary值或ASLR所需的地址信息，从而规避其保护。在特定环境下，如熵较低的32位系统或允许多次尝试的forking服务器模型，暴力破解也成为一种可行的绕过手段。部分覆写技术则针对ASLR的某些实现弱点。 通过案例研究，我们具体展示了如何将格式化字符串漏洞与缓冲区溢出漏洞相结合：首先利用格式化字符串泄露栈Canary，然后利用此信息绕过Canary检查，最终通过精心构造的ROP链在启用了ASLR和NX的环境下实现代码执行。这清晰地揭示了漏洞链的威力和多阶段攻击的复杂性。 总而言之，虽然单一的安全机制可能被绕过，但纵深防御的策略——即同时部署多种、多层次的缓解技术——能够极大地增加攻击的难度和成本。软件安全领域是一个持续演化的战场，安全专业人员必须不断学习和适应新的攻击与防御技术，才能有效地保护系统免受日益复杂的威胁。安全编码实践是构建可信软件的基石，应被置于首位，而运行时缓解技术则作为重要的补充防线。