软件安全JSON解析器模糊测试案例

介绍

目标程序: json_parser.c

c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define MAX_KEY_LEN 64
#define MAX_VALUE_LEN 256
#define MAX_ARRAY_SIZE 1024

// JSON键值对结构
typedef struct {
    char *key;
    char *value;
    int type;  // 0=string, 1=number, 2=array
} json_pair_t;

// 全局数组缓冲区
int *global_array = NULL;
size_t global_array_size = 0;

// 漏洞1: 栈缓冲区溢出
void process_key(char *key) {
    char local_key[MAX_KEY_LEN];
    strcpy(local_key, key);  // 危险!无边界检查
    printf("Processing key: %s\n", local_key);
}

// 漏洞2: 格式字符串漏洞
void log_value(char *value) {
    fprintf(stderr, "Value: ");
    fprintf(stderr, value);  // 危险!直接使用用户输入作为格式字符串
    fprintf(stderr, "\n");
}

// 漏洞3: 整数溢出
size_t calculate_array_size(unsigned int count, unsigned int item_size) {
    // 危险!可能整数溢出
    size_t total = count * item_size;
    return total;
}

// 漏洞4: 堆缓冲区溢出
void process_array(int *data, size_t data_count) {
    if (!global_array) {
        fprintf(stderr, "Error: Array buffer not initialized\n");
        return;
    }

    // 危险!没有检查data_count是否超过global_array_size
    memcpy(global_array, data, data_count * sizeof(int));

    printf("Processed %zu array elements\n", data_count);
}

// 清理函数
void cleanup_array() {
    if (global_array) {
        free(global_array);
        global_array = NULL;
    }
}

// 漏洞5: Use-After-Free
void print_array_info() {
    // 危险!可能访问已释放的内存
    if (global_array_size > 0) {
        printf("Array size: %zu\n", global_array_size);
        if (global_array) {
            printf("First element: %d\n", global_array[0]);  // UAF!
        }
    }
}

// 简单的JSON解析器
char* skip_whitespace(char *json) {
    while (*json && isspace(*json)) json++;
    return json;
}

char* parse_string(char *json, char **result) {
    json = skip_whitespace(json);

    if (*json != '"') {
        return NULL;
    }

    json++; // skip opening "
    char *start = json;

    while (*json && *json != '"') json++;

    if (*json != '"') {
        return NULL;
    }

    size_t len = json - start;
    *result = malloc(len + 1);
    strncpy(*result, start, len);
    (*result)[len] = '\0';

    json++; // skip closing "
    return json;
}

char* parse_number(char *json, int *result) {
    json = skip_whitespace(json);

    *result = atoi(json);

    while (*json && (isdigit(*json) || *json == '-')) json++;

    return json;
}

char* parse_array(char *json, int **array, size_t *count) {
    json = skip_whitespace(json);

    if (*json != '[') {
        return NULL;
    }

    json++; // skip [

    // 解析数组长度
    unsigned int capacity = 10;
    *array = malloc(capacity * sizeof(int));
    *count = 0;

    json = skip_whitespace(json);

    while (*json && *json != ']') {
        int num;
        json = parse_number(json, &num);

        if (*count >= capacity) {
            capacity *= 2;
            *array = realloc(*array, capacity * sizeof(int));
        }

        (*array)[(*count)++] = num;

        json = skip_whitespace(json);
        if (*json == ',') {
            json++;
            json = skip_whitespace(json);
        }
    }

    if (*json != ']') {
        free(*array);
        return NULL;
    }

    json++; // skip ]
    return json;
}

int parse_json_pair(char *json) {
    char *key = NULL;
    char *value = NULL;
    int num_value;
    int *array_data = NULL;
    size_t array_count = 0;

    json = skip_whitespace(json);

    if (*json != '{') {
        fprintf(stderr, "Error: Expected '{'\n");
        return -1;
    }

    json++; // skip {

    while (1) {
        json = skip_whitespace(json);

        if (*json == '}') {
            break;
        }

        // 解析key
        json = parse_string(json, &key);
        if (!json) {
            fprintf(stderr, "Error: Failed to parse key\n");
            return -1;
        }

        // 触发栈溢出
        process_key(key);

        json = skip_whitespace(json);

        if (*json != ':') {
            fprintf(stderr, "Error: Expected ':'\n");
            free(key);
            return -1;
        }

        json++; // skip :
        json = skip_whitespace(json);

        // 根据类型解析value
        if (*json == '"') {
            // 字符串值
            json = parse_string(json, &value);
            if (!json) {
                free(key);
                return -1;
            }

            // 触发格式字符串漏洞
            log_value(value);

            free(value);
        }
        else if (*json == '[') {
            // 数组值
            json = parse_array(json, &array_data, &array_count);
            if (!json) {
                free(key);
                return -1;
            }

            // 触发整数溢出和堆溢出
            global_array_size = calculate_array_size(array_count, sizeof(int));

            if (global_array_size > 0) {
                global_array = malloc(global_array_size);
                if (global_array) {
                    process_array(array_data, array_count);
                }
            }

            free(array_data);
        }
        else if (isdigit(*json) || *json == '-') {
            // 数字值
            json = parse_number(json, &num_value);
            printf("Number: %d\n", num_value);
        }

        free(key);

        json = skip_whitespace(json);
        if (*json == ',') {
            json++;
        }
    }

    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s <json_file>\n", argv[0]);
        return 1;
    }

    FILE *fp = fopen(argv[1], "r");
    if (!fp) {
        fprintf(stderr, "Cannot open file: %s\n", argv[1]);
        return 1;
    }

    // 读取整个文件
    fseek(fp, 0, SEEK_END);
    long file_size = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    char *json_content = malloc(file_size + 1);
    fread(json_content, 1, file_size, fp);
    json_content[file_size] = '\0';
    fclose(fp);

    printf("Parsing JSON...\n");

    // 解析JSON
    int result = parse_json_pair(json_content);

    free(json_content);

    if (result == 0) {
        printf("JSON parsed successfully\n");

        // 清理资源
        cleanup_array();

        // 触发UAF
        print_array_info();
    }

    return result;
}

文件格式: JSON (JavaScript Object Notation)
测试工具: AFL++ (American Fuzzy Lop)
基础种子: seed.json

json
{
  "name": "test",
  "port": 8080,
  "array": [1, 2, 3]
}

漏洞点详解

漏洞1: 栈缓冲区溢出 (Critical)

c
// json_parser.c:20
void process_key(char *key) {
    char local_key[MAX_KEY_LEN];  // 64字节缓冲区
    strcpy(local_key, key);       // 无边界检查!
    printf("Processing key: %s\n", local_key);
}

触发条件: JSON中key超过64字节
测试用例:

json
{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": "value"}

漏洞2: 格式字符串漏洞 (High)

c
// json_parser.c:27
void log_value(char *value) {
    fprintf(stderr, "Value: ");
    fprintf(stderr, value);  // 危险!
    fprintf(stderr, "\n");
}

触发条件: JSON中value包含格式字符串
测试用例:

json
{"name": "%s%s%s"}
{"name": "%p%p%p"}
{"name": "%n"}

漏洞3: 整数溢出 (Medium)

c
// json_parser.c:34
size_t calculate_array_size(unsigned int count, unsigned int item_size) {
    size_t total = count * item_size;  // 可能溢出!
    return total;
}

触发条件: 极大的数组元素数量
测试用例:

json
{"array": [1,2,3,...]} // 包含0xFFFFFFFF个元素

漏洞4: 堆缓冲区溢出 (Critical)

c
// json_parser.c:40
void process_array(int *data, size_t data_count) {
    if (!global_array) {
        return;
    }

    // 没有检查data_count vs global_array_size!
    memcpy(global_array, data, data_count * sizeof(int));
}

触发条件: 数组数据超过分配的缓冲区
利用链: 整数溢出 → 小缓冲区 → 大数据 → 堆溢出

漏洞5: Use-After-Free (Medium)

c
// json_parser.c:279-280
cleanup_array();        // 释放global_array
print_array_info();     // 访问已释放内存!

void print_array_info() {
    if (global_array_size > 0) {
        if (global_array) {
            printf("First element: %d\n", global_array[0]);  // UAF!
        }
    }
}

触发条件: 正常解析包含数组的JSON

编译目标程序

bash

# 1. AFL++插桩版本 (用于fuzzing)
afl-clang-fast -o json_parser_fuzz json_parser.c

# 2. AddressSanitizer版本 (用于检测)
afl-clang-fast -fsanitize=address -fsanitize=undefined -g -O1 \
    -o json_parser_asan json_parser.c

# 3. 调试版本
gcc -g -fno-stack-protector -z execstack -no-pie \
    -o json_parser_debug json_parser.c

# 4. 标准版本
gcc -o json_parser_normal json_parser.c

测试基础种子

bash
root@softsec2:/opt/json_fuzzing_exercise# ./json_parser_normal seed.json
Parsing JSON...
Processing key: name
Value: test
Processing key: port
Number: 8080
Processing key: array
Processed 3 array elements
JSON parsed successfully
Array size: 12

种子设计

JSON格式简单,种子设计关键:

覆盖3种数据类型 (string/number/array)
边界值测试 (超长key/value,巨大数组)
格式错误 (缺失引号,括号不匹配)
攻击性payload (格式字符串,溢出数据)

接下来将会基于基础种子（种子1）的基础上生成一共10个变种种子

种子2: 超长key (栈溢出)

bash
cat > seeds/02_long_key.json << 'EOF'
{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": "value"}
EOF

目的: 触发process_key中的strcpy溢出

种子3: 格式字符串

bash
cat > seeds/03_format_string.json << 'EOF'
{"name": "%s%s%s%n"}
EOF

目的: 触发log_value格式字符串漏洞

种子4: 超长数组

bash
# 生成包含1000个元素的数组
echo -n '{"array": [' > seeds/04_large_array.json
for i in {1..1000}; do
    echo -n "$i"
    [ $i -lt 1000 ] && echo -n ","
done >> seeds/04_large_array.json
echo ']}' >> seeds/04_large_array.json

目的: 触发整数溢出和堆溢出

种子5: 缺失引号

bash
cat > seeds/05_invalid_quote.json << 'EOF'
{"name: "test"}
EOF

目的: 测试错误处理

种子6: 括号不匹配

bash
cat > seeds/06_unmatched_bracket.json << 'EOF'
{"name": "test"
EOF

目的: 测试解析器鲁棒性

种子7: 嵌套结构

bash
cat > seeds/07_nested.json << 'EOF'
{"obj": {"key": "value"}}
EOF

注意: 当前解析器不支持嵌套,会触发错误处理

种子8: 空JSON

bash
echo '{}' > seeds/08_empty.json

目的: 边界条件测试

种子9: 负数

bash
cat > seeds/09_negative.json << 'EOF'
{"port": -1}
EOF

种子10: 超长value

bash
printf '{"msg": "%0500d"}' 1 > seeds/10_long_value.json

AFL 模糊测试

bash
# 启动AFL++
afl-fuzz -i seeds -o output \
    -M fuzzer01 \
    -- ./json_parser_fuzz @@

参数说明:

-i seeds: 输入种子目录
-o output: 输出目录
-M fuzzer01: 主fuzzer
@@: AFL++插入测试文件路径的位置

种子设计的好的话，分分钟出结果

afl-1

bash

root@softsec2:/opt/json_fuzzing_exercise/output/fuzzer01/crashes# ls
id:000000,sig:11,src:000002,time:3113,execs:9537,op:havoc,rep:8           id:000003,sig:11,src:000006,time:52490,execs:37465,op:havoc,rep:8
id:000001,sig:11,src:000002,time:3815,execs:15601,op:havoc,rep:16         id:000004,sig:11,src:000006,time:103749,execs:40472,op:havoc,rep:16
id:000002,sig:11,src:000002+000008,time:6913,execs:33715,op:splice,rep:4  README.txt

先用正常编译版本，拿一个crash试一下

bash

root@softsec2:/opt/json_fuzzing_exercise/output/fuzzer01/crashes# ../../../json_parser_normal "id:000000,sig:11,src:000002,time:3113,execs:9537,op:havoc,rep:8" 
Parsing JSON...
Processing key: pa
Value: 0x561fbb39a8b0
Processing key: b
Value: bb39a8b0
Processing key: c
Value: 
JSON parsed successfully

可以用ASAN版本分析

bash
root@softsec2:/opt/json_fuzzing_exercise/output/fuzzer01/crashes# ../../../json_parser_asan "id:000000,sig:11,src:000002,time:3113,execs:9537,op:havoc,rep:8"
Parsing JSON...
Processing key: pa
Value: 0xffffffff
Processing key: b
Value: ffffffff
Processing key: c
Value: AddressSanitizer:DEADLYSIGNAL
=================================================================
==1749957==ERROR: AddressSanitizer: SEGV on unknown address 0x00009fff7fff (pc 0x0000004344a2 bp 0x7ffe31b6b460 sp 0x7ffe31b6abd8 T0)
==1749957==The signal is caused by a READ memory access.
    #0 0x4344a2 in __asan::QuickCheckForUnpoisonedRegion(unsigned long, unsigned long) asan_interceptors.cpp.o
    #1 0x43fc2e in printf_common(void*, char const*, __va_list_tag*) asan_interceptors.cpp.o
    #2 0x4414b9 in fprintf (/opt/json_fuzzing_exercise/json_parser_asan+0x4414b9)
    #3 0x4cf1bf in log_value /opt/json_fuzzing_exercise/json_parser.c:31:5
    #4 0x4d0f38 in parse_json_pair /opt/json_fuzzing_exercise/json_parser.c:212:13
    #5 0x4d1ab4 in main /opt/json_fuzzing_exercise/json_parser.c:278:18
    #6 0x7fcec770bd8f in __libc_start_call_main csu/../sysdeps/nptl/libc_start_call_main.h:58:16
    #7 0x7fcec770be3f in __libc_start_main csu/../csu/libc-start.c:392:3
    #8 0x420394 in _start (/opt/json_fuzzing_exercise/json_parser_asan+0x420394)

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV asan_interceptors.cpp.o in __asan::QuickCheckForUnpoisonedRegion(unsigned long, unsigned long)
==1749957==ABORTING

可以用hexdump查看一下crash的实际内容

bash
root@softsec2:/opt/json_fuzzing_exercise/output/fuzzer01/crashes# hexdump -C "id:000000,sig:11,src:000002,time:3113,execs:9537,op:havoc,rep:8"
00000000  7b 22 70 61 22 3a 20 22  25 70 22 2c 20 22 62 22  |{"pa": "%p", "b"|
00000010  3a 20 22 25 78 22 2c 20  22 63 22 3a 20 22 25 6e  |: "%x", "c": "%n|
00000020  22 7d 6f 3e 74 22 35 20  73 08                    |"}o>t"5 s.|
0000002a

%p - 指针泄露
%x - 十六进制值泄露
%n - 写入内存的格式字符串

触发位置: log_value() 函数 (json_parser.c:31)
漏洞类型: 格式字符串漏洞 (%n 试图写入内存,但地址无效导致崩溃)

导致的问题

信息泄露 - %p/%x 泄露内存地址 → 绕过ASLR
任意地址写入 - %n 可以写入内存 → 控制程序流
组合利用 - 泄露地址 + 精心构造的%n → RCE(远程代码执行)

短短几分钟就已经出来8个crash了

afl2

12分钟后

afl3

20分钟后
afl4

参考文献

AFLplusplus. (n.d.). AFL++ (American Fuzzy Lop plus plus). GitHub. https://github.com/AFLplusplus/AFLplusplus
OWASP Foundation. (n.d.-a). Format string attack. https://owasp.org/www-community/attacks/Format_string_attack
OWASP Foundation. (n.d.-b). Secure coding practices quick reference guide. https://owasp.org/www-project-secure-coding-practices-quick-reference-guide/
Software Engineering Institute. (n.d.). SEI CERT C coding standard. Carnegie Mellon University. https://wiki.sei.cmu.edu/confluence/display/c/SEI+CERT+C+Coding+Standard