第五十九 软件漏洞

软件漏洞（Software Vulnerability）是程序中存在的安全缺陷，攻击者可利用这些缺陷执行非授权操作，如窃取数据、控制系统、拒绝服务等。从 Morris 蠕虫到 Heartbleed，从缓冲区溢出到 SQL 注入，软件漏洞造成的损失难以估量。理解漏洞的成因与防御，是每一位开发者的必修课。

一、漏洞概述

1.1 什么是软件漏洞

软件漏洞是指在软件设计、实现或配置中存在的弱点，使得攻击者能够违反系统的安全策略（机密性、完整性、可用性）。

1.2 漏洞生命周期

漏洞发现 → 漏洞验证 → 漏洞报告 → 补丁开发 → 补丁发布 → 漏洞公开 → 漏洞利用

1.3 CVE 与 CVSS

二、内存安全漏洞

2.1 缓冲区溢出（Buffer Overflow）

程序向缓冲区写入超过其容量的数据，导致相邻内存被覆盖。这是 C/C++ 程序最经典的漏洞类型。

// 漏洞代码：strcpy 不检查长度
void vulnerable(char* input) {
    char buffer[64];
    strcpy(buffer, input); // 若 input 超过 64 字节，溢出！
}

攻击原理： 溢出数据覆盖返回地址，使程序跳转到攻击者注入的 shellcode。

防御措施：

2.2 Rust 如何防止内存漏洞

Rust 的所有权系统在编译期保证内存安全，从根本上杜绝了缓冲区溢出、悬垂指针、双重释放等漏洞：

#![allow(unused)]
fn main() {
fn safe_example() {
    let mut buffer = [0u8; 64];
    let input = b"some data";
    
    // Rust 的切片操作会在运行时检查边界
    // 越界访问会 panic，而非静默溢出
    let len = input.len().min(buffer.len());
    buffer[..len].copy_from_slice(&input[..len]);
    
    // buffer[index] 也会进行边界检查
    // let val = buffer[100]; // panic: index out of bounds
}
}

2.3 释放后使用（Use-After-Free）

// C 漏洞代码
char* ptr = malloc(100);
free(ptr);
strcpy(ptr, "hacked"); // 使用已释放内存！

Rust 中所有权转移后原变量失效，编译器直接拒绝：

#![allow(unused)]
fn main() {
let s = String::from("hello");
let s2 = s;           // s 的所有权转移给 s2
// println!("{}", s); // 编译错误：s 已被移动
}

2.4 经典案例：Heartbleed（CVE-2014-0160）

OpenSSL 的 Heartbeat 扩展未验证请求长度，攻击者可读取服务器内存中最多 64KB 数据，包括私钥、用户会话等。

根本原因： C 语言缺少边界检查，memcpy 不验证长度。

三、注入漏洞

3.1 SQL 注入

攻击者通过输入恶意 SQL 片段，篡改数据库查询逻辑。

#![allow(unused)]
fn main() {
// 漏洞写法：字符串拼接
let query = format!("SELECT * FROM users WHERE name = '{}'", user_input);
// 若 user_input = "admin' OR '1'='1"，则查询所有用户
}

#![allow(unused)]
fn main() {
// 安全写法：参数化查询
let stmt = conn.prepare("SELECT * FROM users WHERE name = $1")?;
let rows = stmt.query(&[&user_input])?;
}

3.2 命令注入

攻击者通过输入恶意命令分隔符，在服务器上执行任意系统命令。

#![allow(unused)]
fn main() {
// 漏洞写法
let output = std::process::Command::new("sh")
    .arg("-c")
    .arg(format!("ping -c 1 {}", user_input)) // 输入 "8.8.8.8; rm -rf /"
    .output()?;
}

#![allow(unused)]
fn main() {
// 安全写法：不使用 shell，直接传参
let output = std::process::Command::new("ping")
    .arg("-c")
    .arg("1")
    .arg(&user_input) // 参数不会被解释为命令
    .output()?;
}

3.3 XSS（跨站脚本）

攻击者向网页注入恶意 JavaScript，在受害者浏览器中执行。

防御： 输出编码、CSP（内容安全策略）、HttpOnly Cookie。

3.4 注入漏洞防御总结

四、OWASP Top 10

OWASP（Open Web Application Security Project）定期发布 Web 应用十大安全风险：

五、其他常见漏洞

5.1 整数溢出

#![allow(unused)]
fn main() {
fn vulnerable_add(a: u32, b: u32) -> u32 {
    a + b // 若 a + b > u32::MAX，debug 模式 panic，release 模式回绕
}

fn safe_add(a: u32, b: u32) -> Option<u32> {
    a.checked_add(b) // 溢出返回 None
}
}

Rust 在 debug 模式下默认检测整数溢出（panic），release 模式下回绕（wrap-around），可使用 checked_*、saturating_*、wrapping_* 显式控制行为。

5.2 反序列化漏洞

不安全的反序列化可导致远程代码执行。防御： 使用安全格式（如 JSON）、白名单校验、避免反序列化任意类型。

5.3 竞态条件（TOCTOU）

Time-of-Check to Time-of-Use：检查和使用之间存在时间窗口，攻击者利用窗口篡改状态。

#![allow(unused)]
fn main() {
// 漏洞代码：检查与使用之间有间隙
if std::path::Path::new("/tmp/safe_file").exists() {
    // 攻击者可能在此间隙将文件替换为符号链接
    let data = std::fs::read("/tmp/safe_file")?;
}
}

5.4 路径遍历

攻击者使用 ../ 访问预期目录之外的文件。

#![allow(unused)]
fn main() {
// 安全写法：规范化路径并验证
use std::path::{Path, PathBuf};

fn safe_file_path(base: &Path, user_input: &str) -> Option<PathBuf> {
    let full = base.join(user_input);
    let canonical = full.canonicalize().ok()?;
    if canonical.starts_with(base.canonicalize().ok()?) {
        Some(canonical)
    } else {
        None // 路径遍历攻击被阻止
    }
}
}

六、漏洞检测与防御

6.1 静态分析（SAST）

不运行代码，通过分析源代码发现潜在漏洞。

6.2 动态分析（DAST）

运行时检测漏洞。

Rust 生态的模糊测试：

#![allow(unused)]
fn main() {
// 使用 cargo-fuzz 进行模糊测试
// 安装: cargo install cargo-fuzz
// 运行: cargo fuzz add parse_target
use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {
    if let Ok(s) = std::str::from_utf8(data) {
        let _ = parse_function(s); // 确保不 panic
    }
});
}

6.3 依赖漏洞扫描

# Rust 依赖漏洞扫描
cargo install cargo-audit
cargo audit

6.4 安全开发生命周期（SDL）

七、经典漏洞案例

八、总结与练习

本章小结

练习建议

1. 缓冲区溢出分析：阅读 Heartbleed 漏洞的技术细节，理解缺少边界检查如何导致信息泄露，思考 Rust 如何在编译期避免此类问题。
2. SQL 注入修复：编写一个含 SQL 注入漏洞的查询函数，然后用参数化查询修复它。
3. cargo audit 实践：在一个 Rust 项目中运行 cargo audit，检查依赖是否有已知 CVE，并尝试更新修复。
4. 模糊测试：使用 cargo-fuzz 对一个解析函数进行模糊测试，观察是否能触发 panic。
5. 威胁建模：选择一个 Web 应用功能（如用户登录），画出数据流图，识别可能的攻击面和威胁。
6. OWASP 对照：对照 OWASP Top 10，审查一个真实项目的代码，找出潜在的安全风险。