062_二进制安全进阶技术：格式字符串漏洞深度分析与利用指南——从漏洞原理到高级绕过技术的全面解析

void vulnerable_function(char *user_input) {
    printf(user_input);  // 危险！直接将用户输入用作格式字符串
}

void safe_function(char *user_input) {
    printf("%s", user_input);  // 安全，将用户输入作为%s的参数
}

// 危险模式1：直接使用用户输入作为格式字符串
printf(user_input);
fprintf(file, user_input);
sprintf(buffer, user_input);

// 危险模式2：格式化字符串拼接
char format[100];
snprintf(format, sizeof(format), "Error: %s", error_type);
fprintf(stderr, format, error_code);  // 注意：这里可能有额外的参数

// 危险模式3：不安全的可变参数传递
void log_message(char *format, ...) {
    va_list args;
    va_start(args, format);
    vprintf(format, args);  // 如果format来自不可信来源，则有风险
    va_end(args);
}

%x%x%x%x
%s%s%s%s
%n%n%n%n
%100x%x%x%x

void func(char *user_input) {
    char buffer[100];
    strcpy(buffer, user_input);
    printf(buffer);
}

./vuln $(python -c 'print("AAAA" + ".%p" * 20)')

// 错误的做法
printf(user_input);

// 正确的做法
printf("%s", user_input);

gcc -Wall -Wformat -Wformat-security -Werror=format-security source_file.c

gcc -Wall -fanalyzer source_file.c

clang --analyze -Xclang -analyzer-checker=security.insecureAPI.printf source_file.c

gcc -D_FORTIFY_SOURCE=2 -O2 source_file.c

# 示例GitHub Actions配置
name: Security Check
on: [push, pull_request]
jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run Flawfinder
        run: |
          pip install flawfinder
          flawfinder --minlevel=3 src/

威胁建模步骤：
1. 识别系统中的输入点
2. 确定数据流路径
3. 分析潜在的格式化函数调用
4. 评估风险级别
5. 制定防御计划

// 安全格式化函数示例
int safe_printf(const char *format, ...) {
    va_list args;
    va_start(args, format);
    
    // 安全检查
    if (!format || contains_dangerous_specifiers(format)) {
        va_end(args);
        return -1; // 拒绝不安全的格式化请求
    }
    
    int result = vprintf(format, args);
    va_end(args);
    return result;
}

# 使用OWASP dependency-check检查第三方库
./dependency-check --project "My Project" --scan /path/to/code

# 使用SonarQube进行静态代码分析
sonar-scanner -Dsonar.projectKey=my-project -Dsonar.sources=src

import fuzzing

def test_format_string(func):
    # 测试用例包括各种格式说明符和边界情况
    test_cases = [
        "%s", "%n", "%1000000d", "%*s", 
        "%x"*100, "%p%p%p", "\x00\x00\x00\x00%n"
    ]
    
    for test in test_cases:
        try:
            result = func(test)
            print(f"Test case: {test[:20]}... - {'PASSED' if result == 0 else 'FAILED'}")
        except Exception as e:
            print(f"Test case: {test[:20]}... - CRASHED: {str(e)}")

# 使用gcov进行代码覆盖分析
gcc -fprofile-arcs -ftest-coverage source_file.c -o test
./test
lcov --capture --directory . --output-file coverage.info
genhtml coverage.info --output-directory coverage_report

设计安全格式化接口的要点：
1. 将格式字符串与数据参数严格分离
2. 提供默认的安全格式（如"%s"）
3. 实现格式字符串白名单机制
4. 添加运行时检查

# 1. 创建隔离的Docker容器
mkdir -p /opt/security-lab/format-string
cd /opt/security-lab/format-string

# 2. 创建Dockerfile
cat > Dockerfile << 'EOF'
FROM ubuntu:20.04

# 安装必要工具
RUN apt-get update && apt-get install -y \
    gcc gdb git python3 python3-pip \
    build-essential libc6-dbg \
    && rm -rf /var/lib/apt/lists/*

# 安装pwntools用于教学（仅用于展示）
RUN pip3 install pwntools

# 禁用ASLR和其他保护，方便教学演示
RUN echo 0 > /proc/sys/kernel/randomize_va_space

# 创建工作目录
WORKDIR /lab

# 添加教学示例代码
EOF

# 3. 构建并运行容器
docker build -t format-string-lab .
docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -it format-string-lab

// example_vulnerable.c - 仅用于教学展示，实际开发中禁止使用
#include <stdio.h>

void vulnerable_function(const char *user_input) {
    printf("用户输入: ");
    printf(user_input);  // 危险：直接使用用户输入作为格式字符串
    printf("\n");
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        vulnerable_function(argv[1]);
    } else {
        printf("请提供输入参数\n");
    }
    return 0;
}

// example_safe.c - 安全的实现
#include <stdio.h>

void safe_function(const char *user_input) {
    printf("用户输入: %s\n", user_input);  // 安全：将用户输入作为数据参数
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        safe_function(argv[1]);
    } else {
        printf("请提供输入参数\n");
    }
    return 0;
}

printf(user_input);  // 漏洞！

sprintf(buffer, user_input, arg1, arg2);  // 漏洞！

char format[100];
strcpy(format, "Log: ");
strcat(format, user_input);
printf(format, arg1);  // 漏洞！

// 修复方法1：使用固定格式字符串
printf("%s", user_input);

// 修复方法2：使用安全的函数变体
snprintf(buffer, sizeof(buffer), "%s", user_input);

// 修复方法3：实现格式字符串验证函数
bool is_safe_format(const char *format) {
    // 检查是否包含危险的格式说明符
    // 例如：%n, %hhn, %hn, %lln
    const char *dangerous_specifiers[] = {"%n", "%hhn", "%hn", "%lln"};
    for (int i = 0; i < sizeof(dangerous_specifiers)/sizeof(dangerous_specifiers[0]); i++) {
        if (strstr(format, dangerous_specifiers[i]) != NULL) {
            return false;
        }
    }
    return true;
}

# 使用Flawfinder检测
flawfinder --minlevel=3 source_file.c

# 使用cppcheck检测
cppcheck --enable=warning,style,performance,portability,information,missingInclude --std=c99 source_file.c

# 使用SonarQube检测
sonar-scanner -Dsonar.projectKey=my-project -Dsonar.sources=. -Dsonar.host.url=http://localhost:9000 -Dsonar.login=your-token

# 使用Valgrind检测
valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes ./program

# 使用AddressSanitizer编译和运行
clang -fsanitize=address -g source_file.c -o program
./program

// 练习代码 - 包含格式字符串漏洞
#include <stdio.h>
#include <string.h>

void log_message(const char *message) {
    char log_buffer[256];
    snprintf(log_buffer, sizeof(log_buffer), message);  // 漏洞！
    printf("[%s]\n", log_buffer);
}

void process_request(const char *user_input) {
    char buffer[128];
    // 一些处理逻辑...
    log_message(user_input);  // 危险！
}

int main() {
    char input[128];
    printf("请输入消息: ");
    fgets(input, sizeof(input), stdin);
    process_request(input);
    return 0;
}

# 在Linux上启用所有安全选项
gcc -D_FORTIFY_SOURCE=2 -O2 -fstack-protector-all -Wformat -Wformat-security -Werror=format-security source_file.c

# 在Visual Studio中启用安全编译选项
cl /GS /sdl /guard:cf source_file.c

# 在macOS上编译安全的程序
clang -fstack-protector-all -Wformat -Wformat-security -Werror=format-security source_file.c

// 安全的跨平台格式化函数封装
#include <stdio.h>
#include <stdarg.h>
#include <stdbool.h>

// 检查格式字符串是否安全
static bool is_safe_format(const char *format) {
    if (!format) return false;
    
    // 检查是否包含危险的格式说明符
    const char *dangerous[] = {"%n", "%hhn", "%hn", "%lln", NULL};
    for (int i = 0; dangerous[i] != NULL; i++) {
        // 简单的字符串查找（实际实现应更健壮）
        const char *ptr = format;
        while ((ptr = strstr(ptr, dangerous[i])) != NULL) {
            // 确保这不是格式说明符的一部分
            if ((ptr == format || ptr[-1] != '%') && 
                (ptr[2] == '\0' || (ptr[2] != 'h' && ptr[2] != 'l'))) {
                return false;
            }
            ptr += 2;
        }
    }
    return true;
}

// 安全的printf封装
int safe_printf(const char *format, ...) {
    va_list args;
    va_start(args, format);
    
    // 安全检查
    if (!format || !is_safe_format(format)) {
        va_end(args);
        return -1;
    }
    
    int result = vprintf(format, args);
    va_end(args);
    return result;
}

# 完整的GCC安全编译选项
GCC_SECURITY_FLAGS = -D_FORTIFY_SOURCE=2 \
                     -O2 \
                     -fstack-protector-all \
                     -Wformat \
                     -Wformat-security \
                     -Werror=format-security \
                     -Wl,-z,relro,-z,now \
                     -pie

gcc $(GCC_SECURITY_FLAGS) source_file.c -o program

<!-- Visual Studio项目属性配置 -->
<PropertyGroup>
  <AdditionalOptions>/GS /sdl /guard:cf /DYNAMICBASE:NO</AdditionalOptions>
  <LinkIncremental>false</LinkIncremental>
  <BufferSecurityCheck>true</BufferSecurityCheck>
  <ControlFlowGuard>Guard</ControlFlowGuard>
  <EnhancedInstructionSet>AdvancedVectorExtensions2</EnhancedInstructionSet>
</PropertyGroup>

# 使用pytest进行跨平台安全测试
import pytest
import subprocess
import platform

def test_format_string_safety():
    # 根据平台选择编译命令
    if platform.system() == "Windows":
        compile_cmd = ["cl", "/GS", "/W4", "test_format_string.c"]
    else:  # Linux/macOS
        compile_cmd = ["gcc", "-Wall", "-Wformat", "-Werror=format-security", "test_format_string.c"]
    
    # 编译测试程序
    result = subprocess.run(compile_cmd, capture_output=True, text=True)
    
    # 检查编译是否成功
    assert result.returncode == 0, f"编译失败: {result.stderr}"
    
    # 运行测试程序
    if platform.system() == "Windows":
        run_cmd = ["test_format_string.exe"]
    else:
        run_cmd = ["./a.out"]
    
    test_result = subprocess.run(run_cmd, capture_output=True, text=True)
    
    # 验证程序行为
    assert "安全检查通过" in test_result.stdout

# Linux/macOS上的模糊测试
clang -fsanitize=fuzzer -g test_format_string.c -o test_fuzzer
./test_fuzzer -max_total_time=300

# Windows上的模糊测试
# 需要安装Visual Studio的Fuzzing工具集
cl /fsanitize=fuzzer test_format_string.c

# 跨平台格式字符串安全开发环境
FROM ubuntu:22.04

# 安装开发工具和安全工具
RUN apt-get update && apt-get install -y \
    gcc g++ clang make cmake \
    valgrind lcov cppcheck flawfinder \
    python3 python3-pip \
    git vim \
    && rm -rf /var/lib/apt/lists/*

# 安装安全检查工具
RUN pip3 install bandit safety semgrep

# 创建工作目录
WORKDIR /workspace

# 复制安全编码规则
COPY .semgrep_rules.yml /root/.semgrep_rules.yml

# 设置安全编译别名
RUN echo 'alias gcc="gcc -Wall -Wformat -Werror=format-security -D_FORTIFY_SOURCE=2 -O2 -fstack-protector-all"' >> /root/.bashrc
RUN echo 'alias clang="clang -Wall -Wformat -Werror=format-security -D_FORTIFY_SOURCE=2 -O2 -fstack-protector-all"' >> /root/.bashrc

CMD ["bash"]

# GitHub Actions工作流示例
name: Security Check

on: [push, pull_request]

jobs:
  security:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Setup dependencies
      run: |
        if [[ "${{ matrix.os }}" == "ubuntu-latest" ]]; then
          sudo apt-get update
          sudo apt-get install -y cppcheck flawfinder
        elif [[ "${{ matrix.os }}" == "macos-latest" ]]; then
          brew install cppcheck
        elif [[ "${{ matrix.os }}" == "windows-latest" ]]; then
          choco install cppcheck
        fi
        python -m pip install --upgrade pip
        pip install bandit semgrep
    
    - name: Run security checks
      run: |
        # 静态代码分析
        if [[ "${{ matrix.os }}" != "windows-latest" ]]; then
          semgrep --config=p/owasp-top-ten
        else
          semgrep --config=p/owasp-top-ten --no-color
        fi
        
        # 针对C/C++的检查
        if [[ "${{ matrix.os }}" != "windows-latest" ]]; then
          cppcheck --enable=warning,style,performance,portability,information,missingInclude,security src/
        else
          cppcheck --enable=warning,style,performance,portability,information,missingInclude,security src/ --quiet
        fi
    
    - name: Build with security flags
      run: |
        mkdir -p build && cd build
        if [[ "${{ matrix.os }}" == "windows-latest" ]]; then
          cmake -DCMAKE_CXX_FLAGS="/W4 /GS /sdl" ..
        else
          cmake -DCMAKE_CXX_FLAGS="-Wall -Wformat -Werror=format-security -D_FORTIFY_SOURCE=2" ..
        fi
        cmake --build .

防御层级结构：
├── 代码层：安全编码实践
├── 编译层：安全编译选项
├── 运行时层：运行时保护机制
├── 系统层：系统级安全控制
└── 网络层：网络安全防护

// 不安全的代码
bad_function(const char *user_input) {
    printf(user_input);  // 危险！用户输入直接作为格式字符串
}

// 安全的代码
good_function(const char *user_input) {
    printf("%s", user_input);  // 安全：格式字符串固定，用户输入作为参数
}

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

// 安全的printf封装
int secure_printf(const char *format, ...) {
    va_list args;
    va_start(args, format);
    
    // 检查格式字符串是否包含危险的格式说明符
    const char *dangerous_specifiers[] = {"%n", "%hhn", "%hn", "%lln", NULL};
    
    for (int i = 0; dangerous_specifiers[i] != NULL; i++) {
        if (strstr(format, dangerous_specifiers[i]) != NULL) {
            // 检测到危险的格式说明符
            va_end(args);
            fprintf(stderr, "安全警告：检测到危险的格式说明符\n");
            return -1;
        }
    }
    
    // 执行格式化输出
    int result = vprintf(format, args);
    va_end(args);
    return result;
}

#include <stdio.h>
#include <stdarg.h>

// 安全的日志函数
void safe_log(int level, const char *format, ...) {
    // 验证格式字符串参数
    if (!format) {
        fprintf(stderr, "错误：格式字符串不能为空\n");
        return;
    }
    
    va_list args;
    va_start(args, format);
    
    // 根据日志级别执行相应操作
    switch (level) {
        case 0: // 错误
            fprintf(stderr, "[ERROR] ");
            vfprintf(stderr, format, args);
            fprintf(stderr, "\n");
            break;
        case 1: // 警告
            fprintf(stderr, "[WARNING] ");
            vfprintf(stderr, format, args);
            fprintf(stderr, "\n");
            break;
        case 2: // 信息
            printf("[INFO] ");
            vprintf(format, args);
            printf("\n");
            break;
        default:
            fprintf(stderr, "错误：无效的日志级别\n");
            break;
    }
    
    va_end(args);
}

# GCC/Clang 编译选项
gcc -Wall -Wextra -Wformat -Wformat-security -Werror=format-security -D_FORTIFY_SOURCE=2 -O2 -fstack-protector-all source_file.c

# Visual Studio 编译选项
cl /W4 /GS /sdl /guard:cf /analyze source_file.c

# 使用Flawfinder检测格式字符串漏洞
flawfinder --minlevel=3 source_file.c

# 使用Semgrep检测格式字符串漏洞
semgrep --config=p/owasp-top-ten source_file.c

# 启用ASLR (Linux)
sudo sysctl -w kernel.randomize_va_space=2

# 检查ASLR状态
cat /proc/sys/kernel/randomize_va_space

# 检查程序是否启用了DEP (Linux)
readelf -l a.out | grep -i gnu_stack

# 使用GCC启用栈保护
gcc -fstack-protector-all source_file.c

# 检查程序是否启用了栈保护
readelf -s a.out | grep -i stack_chk

# 使用ASan编译
gcc -fsanitize=address -g source_file.c

# 使用Valgrind分析
valgrind --leak-check=full ./a.out

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 简单的异常行为检测
void log_and_monitor(const char *format, ...) {
    va_list args;
    va_start(args, format);
    
    // 记录日志
    FILE *log_file = fopen("security.log", "a");
    if (log_file) {
        time_t now = time(NULL);
        fprintf(log_file, "[%s] ", ctime(&now));
        vfprintf(log_file, format, args);
        fprintf(log_file, "\n");
        fclose(log_file);
    }
    
    // 执行输出
    vprintf(format, args);
    va_end(args);
    
    // 检测可疑模式
    if (strstr(format, "%n") != NULL) {
        fprintf(stderr, "安全警告：检测到可疑的格式说明符\n");
        // 可以在这里添加更多的安全措施，如终止程序
    }
}

// 不安全
printf(user_input);

// 安全
printf("%s", user_input);

#include <stdio.h>
#include <stdarg.h>

int safe_printf(const char *format, ...) {
    // 验证format不为NULL
    if (!format) {
        return 0;
    }
    
    va_list args;
    va_start(args, format);
    int result = vprintf(format, args);
    va_end(args);
    return result;
}

#include <string.h>

bool contains_format_specifiers(const char *input) {
    const char *dangerous[] = {"%n", "%hhn", "%hn", "%lln", NULL};
    for (int i = 0; dangerous[i] != NULL; i++) {
        if (strstr(input, dangerous[i]) != NULL) {
            return true;
        }
    }
    return false;
}

# GCC/Clang
gcc -Wall -Wextra -Wformat -Wformat-security -Werror=format-security source_file.c

# Visual Studio
cl /W4 /GS /sdl source_file.c

gcc -D_FORTIFY_SOURCE=2 -O2 source_file.c

// 包含格式字符串漏洞的代码
#include <stdio.h>
#include <string.h>

void process_data(const char *data) {
    char buffer[256];
    
    // 处理数据
    if (strlen(data) > 0) {
        sprintf(buffer, data); // 漏洞！直接使用用户输入作为格式字符串
        printf("处理结果: %s\n", buffer);
    }
}

void log_message(const char *level, const char *message) {
    char log_buffer[512];
    
    // 构建日志消息
    snprintf(log_buffer, sizeof(log_buffer), "[%s] " message, level); // 漏洞！间接使用用户输入
    printf("%s\n", log_buffer);
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        process_data(argv[1]);
        log_message("INFO", argv[1]);
    }
    return 0;
}

// 修复后的安全代码
#include <stdio.h>
#include <string.h>

void process_data(const char *data) {
    char buffer[256];
    
    // 处理数据 - 修复：使用固定格式字符串
    if (strlen(data) > 0) {
        snprintf(buffer, sizeof(buffer), "%s", data); // 安全：固定格式字符串
        printf("处理结果: %s\n", buffer);
    }
}

void log_message(const char *level, const char *message) {
    char log_buffer[512];
    
    // 构建日志消息 - 修复：使用正确的格式化
    snprintf(log_buffer, sizeof(log_buffer), "[%s] %s", level, message); // 安全：分离格式和数据
    printf("%s\n", log_buffer);
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        process_data(argv[1]);
        log_message("INFO", argv[1]);
    }
    return 0;
}

gcc -Wall -Wextra -Wformat -Wformat-security -Werror=format-security -D_FORTIFY_SOURCE=2 fix.c -o fix