第一章：C语言与GO语言混合编程的底层原理与架构范式
C语言与Go语言混合编程并非语法层面的简单拼接，而是建立在运行时互操作能力之上的系统级协同范式。其核心依赖于Go的cgo工具链与C ABI（Application Binary Interface）的严格对齐，以及两者在内存管理、调用约定和符号可见性上的显式契约。
调用机制的本质对齐
Go通过cgo生成符合C ABI的函数桩（stub），将Go函数导出为C可链接符号时，需显式添加//export注释，并确保函数签名仅含C兼容类型（如*C.int、*C.char）。反之，C调用Go函数前必须在import "C"前声明#include头文件，并启用-buildmode=c-shared或-buildmode=c-archive构建模式。
内存生命周期的协同边界
Go的GC不管理C分配的内存，C也不应直接释放Go分配的[]byte或string底层数据。典型实践如下：
// C侧：malloc分配，由C侧free
char* new_buffer(int size) {
return (char*)malloc(size);
}// Go侧：显式转换并手动管理C内存
buf := C.new_buffer(1024)
defer C.free(unsafe.Pointer(buf)) // 必须显式释放两种主流集成架构模式
| 架构模式 | 适用场景 | 关键约束 |
|---|---|---|
| Go主控+C扩展 | 高性能IO/加密/硬件驱动模块 | C代码不可阻塞Go调度器（避免CGO_NO_THREADS=1） |
| C主控+Go嵌入库 | 传统C应用渐进式引入Go逻辑 | 需静态链接Go运行时，且初始化runtime.GOMAXPROCS |
错误处理的跨语言映射
C函数返回错误码时，应在Go封装层统一转换为Go error：
func ReadConfig(path string) (string, error) {
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
ret := C.c_read_config(cpath)
if ret == nil {
return "", fmt.Errorf("failed to read config: %s", C.GoString(C.strerror(errno)))
}
return C.GoString(ret), nil
}该模式强制要求所有跨语言边界的数据流经过类型安全转换与所有权显式移交，构成混合编程的稳定基石。
第二章：单元测试在C/GO混合项目中的协同验证体系
2.1 Cgo接口层的双向调用单元测试设计与实践
Cgo双向调用测试需覆盖 Go → C 和 C → Go 两条路径，核心挑战在于内存生命周期协同与错误传播一致性。
测试架构分层
- 桩函数注入：通过
#cgo LDFLAGS: -ldl动态加载 mock C 库 - goroutine 安全断言：确保 C 回调在主线程或指定 Go 协程中执行
- 资源自动清理：利用
t.Cleanup()释放 C 分配内存
关键验证点表格
| 验证项 | 方法 | 失败示例 |
|---|---|---|
| Go 调用 C 返回值 | assert.Equal(t, 42, C.add(20, 22)) |
C 函数未导出符号 |
| C 回调 Go 函数 | C.register_go_callback(goCallback) |
Go 函数未用 //export 标记 |
//export goCallback
func goCallback(val *C.int) {
*val = 100 // 修改 C 传入指针所指值
}此导出函数被 C 侧调用，*val = 100 直接写入 C 分配内存；必须确保 val 非 nil 且生命周期由 C 管理，Go 侧不负责释放。
graph TD
A[Go test] --> B[调用 C.add]
B --> C[C 返回 int]
A --> D[注册 goCallback]
D --> E[C 触发回调]
E --> F[Go 修改 *C.int]2.2 跨语言内存生命周期一致性测试（malloc/free vs. CGO Go pointer safety）
内存所有权边界陷阱
Go 的 GC 不管理 C.malloc 分配的内存，而 C.free 释放后若 Go 代码仍持有对应 *C.char 指针，将触发悬垂引用。
典型误用示例
// C code (inlined via CGO)
#include <stdlib.h>
char* new_c_string() {
char* s = malloc(16);
strcpy(s, "hello");
return s; // Ownership transferred to Go — but Go doesn't track it!
}// Go code
/*
#cgo LDFLAGS: -lm
#include <string.h>
#include <stdlib.h>
char* new_c_string();
*/
import "C"
import "unsafe"
func badExample() {
cstr := C.new_c_string()
go func() {
// ⚠️ Race: C.free may run while this goroutine reads cstr
_ = C.GoString(cstr) // unsafe if freed concurrently
}()
C.free(unsafe.Pointer(cstr)) // Go has no knowledge of this release
}逻辑分析：C.free 立即释放底层内存，但 Go 运行时无法感知该操作；C.GoString 内部复制内容前未做存活检查，导致竞态读取已释放页。参数 cstr 是裸 C 指针，无 Go runtime 生命周期钩子。
安全实践对照表
| 方案 | 是否受 Go GC 管理 | 跨 goroutine 安全 | 需显式 free？ |
|---|---|---|---|
C.CString() + C.free() |
❌ | ❌（需同步） | ✅ |
C.CBytes() + C.free() |
❌ | ❌ | ✅ |
make([]byte, n) + C.GoBytes() |
✅ | ✅ | ❌ |
正确生命周期绑定流程
graph TD
A[Go 分配 []byte] --> B[C.GoBytes → C char*]
B --> C[传入 C 函数处理]
C --> D[C 函数完成 → 返回控制权给 Go]
D --> E[Go 自动 GC 回收切片]2.3 基于Ginkgo+Catch2的混合测试框架集成与断言对齐
在跨语言C++/Go混合服务中，需统一断言语义。Ginkgo（Go）与Catch2（C++）原生断言不兼容，需桥接层对齐。
断言语义映射表
| Ginkgo 断言 | Catch2 等效表达 | 语义强度 |
|---|---|---|
Expect(err).NotTo(HaveOccurred()) |
REQUIRE(!err) |
强制失败 |
Expect(val).To(Equal(42)) |
CHECK(val == 42) |
软失败 |
C++侧适配器封装
// catch2_ginkgo_bridge.hpp：提供Ginkgo风格宏
#define GINKGO_REQUIRE_NOT_NULL(ptr) REQUIRE((ptr) != nullptr)
#define GINKGO_EXPECT_EQ(actual, expected) CHECK((actual) == (expected))该头文件屏蔽Catch2原生宏差异，使C++测试用例可被Go侧CI流水线统一解析。
流程协同机制
graph TD
A[Go测试启动] --> B[调用C++ FFI接口]
B --> C[Catch2执行并序列化断言结果]
C --> D[Ginkgo解析JSON断言日志]
D --> E[聚合生成统一JUnit报告]2.4 共享数据结构（struct/union）的ABI兼容性自动化校验
跨模块/进程共享 struct 或 union 时，字段偏移、对齐、大小的微小差异将导致静默内存越界。自动化校验成为关键防线。
核心校验维度
- 字段顺序与类型一致性
offsetof()偏移值匹配sizeof()与alignof()对齐约束- 位域（bit-field）布局可移植性
示例：ABI快照比对代码
// abi_snapshot.c —— 生成结构体元信息
#include <stddef.h>
#include <stdio.h>
#define SNAP(name, type) \
printf("%s: size=%zu, align=%zu, field_a=%zu\n", \
#name, sizeof(type), _Alignof(type), offsetof(type, a));
typedef struct { int a; char b; } test_t;
SNAP(test, test_t); // 输出：test: size=8, align=4, field_a=0逻辑说明：
offsetof精确捕获字段起始偏移；_Alignof验证对齐要求；输出格式化为机器可解析的快照。参数#name为宏字符串化结构名，确保标识可追溯。
工具链集成流程
graph TD
A[源码编译] --> B[Clang AST提取]
B --> C[生成JSON ABI描述]
C --> D[与基准快照diff]
D --> E[CI失败/告警]| 字段 | v1.0 快照 | v1.1 快照 | 兼容？ |
|---|---|---|---|
header.len |
offset=4 | offset=8 | ❌ |
payload[0] |
offset=16 | offset=16 | ✅ |
2.5 测试覆盖率穿透：从Go test -cover到gcov+lcov的全链路映射
Go 原生 go test -cover 提供快速函数级覆盖率，但缺乏行级高亮与跨语言兼容能力。当项目引入 CGO 或需与 C/C++ 混合构建时，必须升级至 gcov + lcov 工具链。
Go 中启用 CGO 覆盖采集
CGO_ENABLED=1 go test -covermode=count -coverprofile=coverage.cov ./...
# -covermode=count → 记录每行执行次数（非布尔）
# -coverprofile → 生成可被 gocov 转换的文本格式 该命令输出的 .cov 文件不兼容 lcov，需借助 gocov 转为 JSON 再导出 lcov 格式。
全链路映射关键步骤
- 编译阶段注入
-fprofile-arcs -ftest-coverage（C 部分） - 运行时生成
.gcda文件 lcov --capture合并 Go（经转换）与 C 的覆盖率数据genhtml渲染带跳转的 HTML 报告
| 工具 | 输入格式 | 输出能力 |
|---|---|---|
go test -cover |
内存统计 | 终端摘要，无源码映射 |
lcov |
.info（多源） |
行级高亮、分支覆盖、合并视图 |
graph TD
A[go test -cover] --> B[gocov convert]
B --> C[coverage.json]
C --> D[lcov --add-tracefile]
D --> E[merged.info]
E --> F[genhtml]第三章：面向不确定性的模糊测试深度攻坚
3.1 针对Cgo导出函数的AFL++与go-fuzz协同模糊策略
协同设计动机
Cgo导出函数（//export）是Go与C交互的关键入口，但其内存模型和调用约定易引入UAF、栈溢出等漏洞。单一fuzzer难以兼顾Go运行时约束与C层原始内存操作。
混合模糊流程
graph TD
A[Go测试桩] -->|构造C兼容输入| B(Cgo导出函数)
B -->|返回错误码/panic| C[AFL++反馈驱动]
A -->|序列化输入| D[go-fuzz corpus]
D -->|变异后注入| A输入桥接代码示例
// export MyCFunc
// #include <stdint.h>
import "C"
import "unsafe"
//export MyCFunc
func MyCFunc(buf *C.uint8_t, len C.size_t) C.int {
// 将C指针安全转为Go slice，避免cgo检查失败
b := (*[1 << 20]byte)(unsafe.Pointer(buf))[:int(len):int(len)]
return C.int(processBytes(b)) // 实际业务逻辑
}
(*[1<<20]byte)是固定长度数组强制转换，规避Go 1.21+对unsafe.Slice在cgo边界使用的限制；[:int(len):int(len)]精确切片防止越界读，确保AFL++触发崩溃时能准确定位C层偏移。
协同优势对比
| 维度 | AFL++ | go-fuzz | 协同增益 |
|---|---|---|---|
| 输入结构感知 | 弱（字节级） | 强（Go类型推导） | 联合生成结构化+原始内存输入 |
| 运行时覆盖 | 无GC干扰 | 受GC停顿影响 | AFL++主导高频C路径，go-fuzz探查GC敏感边界 |
3.2 混合边界：C端输入解析器与Go端序列化逻辑的联合变异注入
数据同步机制
当移动端（iOS/Android）提交含特殊字符的 JSON 输入（如 {"name":"Alice\u0000test"}），C 端解析器若未严格校验 Unicode 控制字符，会保留 \u0000 并透传至 Go 后端。
序列化协同漏洞
Go 的 json.Unmarshal 默认容忍部分非法 Unicode，但经 encoding/gob 或自定义 BinaryMarshaler 序列化后，\u0000 可能被误解释为字符串截断符，导致内存越界读取。
// 示例：危险的联合序列化路径
type User struct {
Name string `json:"name"`
}
var u User
json.Unmarshal([]byte(`{"name":"A\u0000B"}`), &u) // 成功解码，u.Name == "A\x00B"
gob.NewEncoder(buf).Encode(u) // 在二进制流中保留 \x00，触发下游 C 接口解析异常逻辑分析：
json.Unmarshal仅验证 UTF-8 结构，不剔除控制字符；gob编码直接序列化string内部字节，无 sanitization。参数u.Name的底层[]byte含\x00，在与 C FFI 交互时引发空终止截断。
| 风险环节 | C端行为 | Go端行为 |
|---|---|---|
| 输入接收 | memcpy 原始字节流 | json.Unmarshal 接收 |
| 边界校验 | 依赖 strlen → 截断 | 无默认控制字符过滤 |
| 序列化输出 | cgo 调用传入 C.CString |
gob 输出含 \x00 字节 |
graph TD
A[C客户端输入] -->|含\\u0000的JSON| B(C端解析器)
B -->|透传原始bytes| C(Go HTTP Handler)
C -->|json.Unmarshal| D[User struct]
D -->|gob.Encode| E[二进制流]
E -->|C.CString| F[C FFI接口]
F --> G[缓冲区截断/越界]3.3 内存安全漏洞（UAF、Buffer Overflow）的跨语言崩溃归因与符号执行复现
跨语言崩溃信号捕获
在混合栈（如 Rust FFI 调用 C 库）中，SIGSEGV 的 si_addr 与 si_code 需结合 DWARF 与 .eh_frame 联合解析，区分 UAF（si_code == SEGV_ACCERR）与溢出（si_code == SEGV_MAPERR）。
符号执行驱动复现
使用 angr 对跨语言边界函数建模时，需显式声明调用约定与内存布局：
# 声明 C 函数原型：void process(char* buf, int len)
proj = angr.Project("libmixed.so", auto_load_libs=False)
process = proj.factory.callable(
proj.loader.find_symbol("process").rebased_addr,
cc=angr.calling_conventions.SimCCAMD64(), # 关键：匹配 ABI
concrete_only=False
)
process.set_state( # 注入符号化输入
buf=claripy.BVS("input_buf", 256 * 8),
len=claripy.BVV(256, 32)
)逻辑分析：
SimCCAMD64()确保寄存器参数传递（rdi,rsi）与真实调用一致；BVS创建 256 字节符号缓冲区，BVV固定长度以触发越界读写路径。concrete_only=False启用路径约束求解。
漏洞模式映射表
| 漏洞类型 | 触发条件 | 符号执行关键约束 | 典型语言组合 |
|---|---|---|---|
| UAF | free(p); use(p) |
p == malloc_addr ∧ p ≠ NULL |
C/Rust（裸指针） |
| Buffer Overflow | write(buf+size, 1) |
size > buf_len ∧ size < 0x1000 |
C/Go（Cgo 调用） |
graph TD
A[Crash Signal] --> B{si_code == SEGV_ACCERR?}
B -->|Yes| C[UAF: 检查堆分配/释放历史]
B -->|No| D[Overflow: 分析栈帧偏移与符号化长度]
C --> E[生成 PoC：malloc→free→use]
D --> E第四章：混沌工程驱动的C/GO混合系统韧性验证
4.1 在CGO调用链中注入系统级扰动（syscall fault injection + goroutine panic chaos）
核心原理
通过拦截 libc 系统调用入口（如 open, read, write），在 CGO 调用栈关键路径上动态注入错误码（如 EIO, ENOSYS）或触发 runtime.GoPanic()，实现可控的系统级混沌。
注入点选择策略
- ✅
LD_PRELOADhook libc 符号（需cgo构建时保留符号可见性） - ✅
runtime.SetFinalizer关联 CGO 分配内存，延迟触发 panic - ❌ 直接 patch
syscall.Syscall— Go 运行时内联优化使其不可靠
示例：故障注入器（C 侧）
// inject_fault.c — 编译为 libinject.so
#include <errno.h>
#include <dlfcn.h>
#include <stdio.h>
static int (*real_open)(const char*, int, ...) = NULL;
int open(const char *pathname, int flags, ...) {
if (!real_open) real_open = dlsym(RTLD_NEXT, "open");
// 每第3次调用返回 EIO
static int cnt = 0;
if (++cnt % 3 == 0) {
errno = EIO;
return -1;
}
return real_open(pathname, flags);
}逻辑分析：利用
dlsym(RTLD_NEXT)获取原始open地址，通过静态计数器实现概率性故障。errno = EIO使 Go 层os.Open返回*os.PathError，触发上层错误处理分支，验证容错逻辑健壮性。
故障传播效果对比
| 扰动类型 | Go 层表现 | 是否中断 goroutine |
|---|---|---|
EIO（syscall） |
os.Open 返回 error |
否（可恢复） |
panic("cgofault") |
runtime: cgo callback panicked |
是（非阻塞式终止） |
graph TD
A[Go main goroutine] -->|CGO call| B[libinject.so open]
B -->|EIO| C[os.Open returns error]
B -->|panic| D[runtime panics in cgo frame]
D --> E[goroutine exits with stack trace]4.2 共享资源竞争场景建模：C线程池与Go runtime调度器的死锁/活锁混沌实验
数据同步机制
C线程池中，pthread_mutex_t 与条件变量组合常引发隐式依赖链；Go 中 sync.Mutex 配合 runtime.Gosched() 可能诱发调度器感知不到的自旋等待。
混沌触发代码示例
// C线程池：两个worker循环争抢同一mutex+cond，无超时退出
pthread_mutex_lock(&mu);
while (shared_state == BUSY)
pthread_cond_wait(&cv, &mu); // 若signal丢失且无唤醒者→死锁
pthread_mutex_unlock(&mu);逻辑分析：pthread_cond_wait 原子性释放锁并挂起，但若信号在lock前发出，则永久丢失；BUSY状态无原子更新机制，竞态窗口达微秒级。
Go runtime活锁模拟
func liveLockWorker(mu *sync.Mutex, ch chan struct{}) {
for {
mu.Lock()
select {
case <-ch:
mu.Unlock()
return
default:
mu.Unlock()
runtime.Gosched() // 主动让出P，但所有goroutine同步执行此路径→活锁
}
}
}参数说明：ch为控制退出通道；runtime.Gosched() 不保证调度公平性，在高负载下易导致P空转。
| 维度 | C线程池 | Go runtime |
|---|---|---|
| 调度主体 | OS内核线程 | M:N用户态goroutine |
| 死锁检测 | 无内置机制 | 无（需pprof+trace人工推断） |
| 活锁敏感度 | 低（线程数固定） | 极高（goroutine数量弹性） |
graph TD
A[共享资源访问请求] --> B{C线程池}
A --> C{Go runtime}
B --> D[OS调度器介入<br>mutex阻塞→线程休眠]
C --> E[Go scheduler拦截<br>尝试唤醒G或迁移P]
D --> F[死锁：无超时+信号丢失]
E --> G[活锁：G频繁Gosched但无进展]4.3 动态链接库热替换下的运行时行为漂移观测与熔断机制验证
行为漂移观测点注入
在 dlopen/dlsym 调用链中插入钩子，捕获符号解析前后函数地址变化：
// 拦截 dlsym 并记录地址漂移
void* tracked_dlsym(void* handle, const char* symbol) {
void* addr = dlsym(handle, symbol); // 原始符号解析
static uint64_t last_hash = 0;
uint64_t curr_hash = hash_function(addr); // 地址哈希化防误报
if (curr_hash != last_hash && last_hash != 0) {
log_drift(symbol, last_hash, curr_hash); // 触发漂移日志
trigger_safety_check(); // 启动熔断预检
}
last_hash = curr_hash;
return addr;
}逻辑分析：通过哈希比对避免指针微小偏移（如 ASLR 微调）误判；trigger_safety_check() 启动轻量级运行时一致性校验。
熔断决策矩阵
| 漂移频次 | 连续调用异常率 | 熔断动作 |
|---|---|---|
| ≥3次/秒 | >15% | 阻断后续 dlopen |
| ≥1次/秒 | >40% | 切换至降级 stub |
熔断状态流转
graph TD
A[热替换触发] --> B{地址哈希变更？}
B -->|是| C[启动漂移计数器]
C --> D[超阈值？]
D -->|是| E[激活熔断：禁用新句柄+回滚符号表]
D -->|否| F[允许执行，更新基线]4.4 基于eBPF的混合调用栈实时追踪与异常传播路径可视化
传统用户态/内核态调用栈割裂，导致异常（如 panic、SIGSEGV）传播路径难以端到端还原。eBPF 提供安全、可编程的内核观测能力，结合 bpf_get_stack() 与 bpf_probe_read_user() 可跨上下文采集混合栈帧。
核心数据结构设计
struct stack_event {
__u32 pid;
__u32 tid;
__u64 timestamp;
__u32 kernel_depth;
__u32 user_depth;
__u64 kstack[64]; // 内核符号地址（需vmlinux映射）
__u64 ustack[64]; // 用户态地址（需/proc/pid/maps+debuginfo）
};此结构支持双栈对齐：
kstack[]由bpf_get_stack(ctx, buf, size, BPF_F_REUSE_STACKID | BPF_F_USER_STACK)获取；ustack[]需配合uprobe在libc关键函数（如raise,abort）处触发，避免用户栈遍历失败。
异常传播链构建逻辑
- 捕获
tracepoint:exceptions:exception_entry触发初始事件 - 关联
sched:sched_process_exit和syscalls:sys_enter_kill构建因果边 - 服务端使用 FlameGraph + Mermaid 渲染传播拓扑：
graph TD
A[app: malloc_fail] --> B[kernel: do_page_fault]
B --> C[app: signal_handler]
C --> D[libpthread: __libc_siglongjmp]关键参数说明
| 参数 | 含义 | 推荐值 |
|---|---|---|
BPF_F_USER_STACK |
强制采集用户栈 | 必选（异常上下文必需） |
BPF_F_REUSE_STACKID |
复用栈ID减少map压力 | 启用 |
max_entries in BPF_MAP_TYPE_STACK_TRACE |
栈哈希表容量 | ≥8192（高并发场景） |
第五章：形式化验证在C/GO混合契约中的可信落地边界
混合契约的典型架构约束
在区块链跨链桥项目 ChainFusion 中，核心共识校验模块采用 C 语言实现（编译为 WASM），而状态同步与事件分发层由 Go 编写（通过 CGO 调用 C 接口）。二者通过结构体指针传递和内存共享完成数据交换，但未引入任何运行时边界检查。该设计在性能上提升约 37%，却导致三类高危漏洞：C 层越界读取 Go 分配的 slice 头部、Go GC 提前回收被 C 持有引用的内存、以及 C 函数返回空指针后 Go 层未做 nil 检查即解引用。
形式化建模的关键抽象点
我们使用 Frama-C（C 侧）与 Why3（Go 侧接口契约）构建联合验证模型。对 verify_signature() 这一关键函数，其 C 实现需满足以下 ACSL 规约：
/*@ requires \valid_read(msg + (0..len-1));
requires len > 0 && len <= MAX_MSG_SIZE;
ensures \result == 0 || \result == 1;
assigns \nothing;
*/
int verify_signature(const uint8_t* msg, size_t len, const uint8_t* sig);对应 Go 侧调用需声明 //go:cgo_import_static verify_signature 并在 .h 文件中绑定 //export verify_signature，确保 Why3 可解析其内存契约。
验证失败的真实案例回溯
2023 年 Q3 的一次审计中，Frama-C 的 Value Analysis 发现：当 len == 0 时，C 函数因未显式检查 len > 0 而触发未定义行为（UB），而 Go 层传入 len=0 的测试用例恰好绕过单元测试覆盖。Why3 验证器则指出 Go 侧 C.verify_signature(nil, 0, ...) 调用违反了 requires \valid_read(...) 前置条件，形成契约断裂点。
可信边界的量化界定
| 验证维度 | 已覆盖场景 | 当前不可达边界 |
|---|---|---|
| 内存安全性 | 栈变量访问、静态数组越界 | 动态分配内存的生命周期交叉证明 |
| 并发正确性 | 单线程 CGO 调用序列 | Go runtime 与 C 线程池的竞态建模 |
| 数值溢出 | 所有算术运算（含 size_t 转换） | 浮点精度误差传播（仅限 C 数学库） |
工具链协同瓶颈分析
Mermaid 流程图揭示实际验证流中的断点：
flowchart LR
A[Go 源码] --> B[CGO 构建生成 .h/.c]
B --> C[Frama-C 解析 C ABI]
C --> D{是否含指针别名？}
D -->|是| E[需人工注入 \separated 契约]
D -->|否| F[自动生成 ACSL]
E --> G[Why3 合并 Go 接口约束]
G --> H[Z3/SMTCoq 求解器验证]
H --> I[失败：缺少 C 运行时模型]该流程在 malloc/free 与 Go runtime·sysAlloc 交互处失效——Frama-C 无法建模 Go 内存管理器的页级分配策略，导致所有涉及跨语言堆内存共享的路径均标记为“不可判定”。
生产环境部署的妥协策略
在 ChainFusion v2.4 中，团队将验证边界收缩至“确定性纯计算子集”：禁用所有 C.malloc 调用，改用预分配环形缓冲区；Go 层通过 unsafe.Slice 显式构造只读视图，并在每次 CGO 调用前插入 runtime.KeepAlive 防止 GC 提前回收。此方案使可验证代码占比从 41% 提升至 89%，但牺牲了动态负载适配能力。
边界之外的遗留风险
当合约处理包含嵌套 TLV 结构的跨链交易时，C 层递归解析深度超过 7 层后，栈空间消耗超出 WASM 线性内存限制，而 Frama-C 默认不建模栈溢出——该缺陷在压力测试中触发 wasm trap: out of bounds memory access，但所有形式化验证报告均未预警。
