94% 到 6%:Rust 内存缺陷的可利用性断层

一、引言

1.1 一个不该出现的数字

Rust 的核心承诺只有一句话:在编译期消除内存安全问题。所有权、借用检查、生命周期,这套机制的设计目标就是让 use-after-free、缓冲区溢出、数据竞争这类缺陷在编译阶段被拒绝,而不是等到运行时被利用。

这个承诺兑现得相当成功。但把 Rust 官方生态的漏洞公告库 RustSec advisory-db 整个拉下来数一遍,会得到一个不太舒服的数字:

全库 1246 条公告中,有 346 条(27.8%)带有内存类标签(memory-corruption 或 memory-exposure);其中 memory-corruption 这个标签单独出现了 281 次。也就是说,平均每一百条 Rust 安全公告里,就有二十八条属于「Rust 本应防住的那一类」。

如果只看到这里,结论会是「Rust 的承诺是空话」。但继续往下拆,会发现真实情况比这个数字复杂得多 —— 也更有意思。

1.2 Rust 的安全承诺,边界到底在哪

Rust 的安全性并不是「编译器保证所有代码都安全」,而是一个更精确的表述:

只要你不写 unsafe,编译器保证你的代码不会出现内存安全问题。

这句承诺有三重限定,每一重都是理解本文数据的钥匙:

限定一:只对安全代码成立。 unsafe 块内的代码由写它的人负责。而标准库、异步运行时、容器库、加密库——整个生态的基础设施,恰恰大量使用 unsafe,因为要实现所有权模型无法表达的数据结构(自引用、侵入式链表、无锁结构、自定义分配器)。

限定二:只保证「内存安全」,不保证「逻辑安全」。 认证绕过、注入、拒绝服务、加密误用,这些与内存无关的缺陷,所有权模型完全管不到。

限定三:保证的是「不出现 UB」,不是「不被利用」。 反过来说,不出现 UB 也不等于不被利用 —— 一个纯粹的权限校验逻辑错误,可以毫无 UB 地泄露全部数据。

本文要回答的就是:这三重限定在真实数据里各自占多大分量。

1.3 研究问题与贡献

围绕这个目标,本文提出四个研究问题:

  • RQ1:Rust 生态的安全公告中,缺陷类型的分布是什么样的?内存类占多大比例?
  • RQ2:内存类缺陷里,「可被利用的漏洞」与「soundness 缺陷」的比例随时间如何变化?
  • RQ3:这些缺陷的失效机理可以归为几类?其中哪些是 C 语言里也存在的老问题,哪些是 Rust 特有的新问题?
  • RQ4:RustSec 的 memory-corruption 标签是否还能有效传达风险等级?内存类缺陷的严重度是否显著高于非内存类?

主要贡献:

  1. 首次对 RustSec 全库(1246 条公告,2016–2026)做双口径分离统计 —— 把「带 CVE 编号」与「自称 unsound」当作两个独立判据,分别统计,不合并为单一结论。据我们对公开资料的检索,此前没有针对该库的分类字段做过程度这样的口径分离。
  2. 发现一个明确的结构性转折:内存类公告中带 CVE 的比例从 2020 年的 94% 降至 2025–2026 年的 6–10%,同期 soundness 占比从 57% 升至 66%。并对「CVE 分配延迟」这一替代解释做了排除性检验(4.5 节)。
  3. 归纳出四类失效机理,并指出其中三类(类型表达不足、auto trait 约束遗漏、Drop 语义脱节)在 C 语言中没有对应物 —— 它们是 Rust 安全模型自身引入的新失效形态。
  4. 用 CVSS 严重度分布 + Mann-Whitney U 检验证明内存类缺陷显著更严重(严重级占比 27.9% vs 6.9%,p = 2.46×10⁻⁶),并据此指出:标签内部「被评分的危险缺陷」与「未被评分的 soundness 债务」各占一半 —— 给出 memory-corruption 标签风险沟通失效的定量依据,而非仅凭观察印象。
  5. 对其中一个「无 CVE 的 unsound」做了现场复现验证(6.3 节):用 Miri 在 anyhow 1.0.102 上检出 Undefined Behavior,在 1.0.104 上确认修复生效。触发代码不含任何 unsafe,却能在编译期毫无警告地通过 —— 这为「编译器保证的边界之外还有一层手工维护的契约」提供了可独立验证的证据,而不只是引用公告。

1.4 与作者前作的关系

本文不与作者此前的公开工作重叠:题材、数据源与分析方法均为新的,共用的只是量化审计这一方法习惯。

二、背景与相关工作

2.1 借用检查器管什么、不管什么

要理解后面四类失效机理,先要明确 Rust 编译器到底检查了什么。

它检查的: 引用的生命周期是否越界;可变引用与共享引用是否共存;移动之后是否还被使用;跨线程传递的值是否实现了 Send / Sync。

它不检查的:

不检查的东西

后果示例

unsafe 块内的内存操作

手写加法溢出、指针别名、双重释放

类型签名是否表达了全部真实约束

迭代器生命周期跑出分配器范围

一个泛型参数上的 trait bound 是否足够

漏掉 Sync 导致并发调用 !Sync 类型

整数运算的溢出语义

release 构建下静默回绕,绕过边界检查

值在哪个线程被析构

LocalSet 任务的 future 在错误线程 drop

安全 API 内部构造引用的合法性

借用链里混入共享引用

表格右侧六项,构成了本文第五节全部四类机理。 换句话说:Rust 的安全性建立在一组「编译器看不见的前提」上,而这些前提由写代码的人手工维护。

2.2 unsound 是什么,为什么它不算「漏洞」却仍是 UB

soundness(健全性)是类型系统领域的概念:一个类型系统是 sound 的,意味着「所有类型检查通过的程序的运行时行为,都不会超出语言规范所定义的范围」。对 Rust 而言,规范范围之外就是未定义行为(UB)。

unsound 的 API 指的是:一个用安全签名暴露、内部含 unsafe 的 API,允许只使用安全代码的调用者触发 UB。典型形式包括:

  • 返回的生命周期比实际可信的长度更长
  • 要求调用者遵守某个约定,但没在类型上表达这个要求
  • unsafe impl 了 Send / Sync 但实际不满足条件
  • 泛型约束写漏,导致实例化出非法组合

为什么它和「漏洞」是两回事: 漏洞(vulnerability)强调外部可利用性 —— 攻击者能否用它达成越权、泄露、执行。unsound 强调内部一致性 —— 这个 API 违反了它自己声明的契约。一个 unsound 的 API 可能因为触发条件过于苛刻而完全无法被攻击者利用(例如要求调用方传入一个特定的 !Unpin 类型,且做大量精确的内存布局对齐)。

但两者共享同一个后果:UB。 而 UB 的可怕之处在于它给编译器留下自由 —— 一段包含 UB 的代码,其行为不受任何保证,包括「不泄露内存」这一条。

这就是本文后续讨论的核心张力:风险等级不同,但后果类型相同,而它们在 RustSec 里叫同一个名字。

2.3 RustSec 的分类体系

RustSec advisory-db 是 Rust 安全工作组维护的官方漏洞公告库,同时是 cargo-audit 与 cargo-deny 的数据源 —— 也就是说,它是 Rust 生态事实上的安全通告标准。

每条 advisory 的 categories 字段取值为下列之一(可多选):

category

含义

是否与内存安全相关

memory-corruption

内存破坏

是

memory-exposure

内存暴露(信息泄露)

是

code-execution

代码执行

否

crypto-failure

加密失败

否

denial-of-service

拒绝服务

否

file-disclosure

文件泄露

否

format-injection

格式串注入

否

privilege-escalation

权限提升

否

thread-safety

线程安全

否(注:部分与内存序相关)

malicious

恶意包

否

unmaintained

停止维护

否

vulnerability

一般漏洞

否

注意 memory-corruption 的覆盖面:它既装「攻击者可控的越界写」,也装「需要特定调用模式才触发的 UB」。这个标签没有区分「可利用性」维度。 本文的 Q4 就是针对这一点。

2.4 已有研究与本文的增量

Rust 的内存安全模型有大量学术讨论(如 RustBelt 对 Rust 类型系统核心的形式化验证),但这些工作关注的是语言本身是否 sound,而本文关注的是生态里的实现是否遵守了语言的契约。

关于 unsafe 代码的经验研究多集中在「unsafe 用了多少、用在哪里」(如 cargo-geiger 类工具),关注的是数量;本文关注的是失效形态的分类与演化。

近期另有工作着力于用新的检测技术发现 Rust 的健全性缺陷:静态分析方向的 TYPEPULSE(arXiv:2502.03271)与 UnsafeChecker(arXiv:2609.09641),模糊测试方向的 deepSURF(arXiv:2506.15648)与 RustGo(arXiv:2608.05870)。这条线关注的是「找出尚未披露的缺陷」;本文不引入任何检测手段,关注的是已披露缺陷的记录方式——公告库的分类字段能否承载风险等级信息。

关于漏洞标签体系的研究(如对 CWE、CVSS 的批评性分析)指出过「单一标签掩盖风险差异」的问题,但据检索,此前没有工作把这一批评应用到 RustSec 的 memory-corruption 上。

本文的增量是三件事:全库规模的双口径统计、四类失效机理的归纳、以及对标签体系风险沟通能力的质疑。

三、方法

3.1 数据来源与快照

数据来自 RustSec advisory-db 仓库的完整快照,取得方式为拉取仓库归档(codeload tar.gz,约 0.46 MB),本地解压解析,不经任何第三方统计服务。

需要说明格式细节(这一条对复现者很关键):新版 advisory-db 的公告文件已从纯 .toml 改为带 TOML 代码块 frontmatter 的 .md,结构如下:

crates/<crate-name>/RUSTSEC-YYYY-NNNN.md

```toml
[advisory]
id = "RUSTSEC-2020-0105"
package = "abi_stable"
categories = ["memory-corruption"]
cvss = "CVSS:3.1/..."
date = "2020-12-21"

[versions]
patched = [">= 0.9.1"]
```

解析时只接受路径形如 crates/<name>/<id>.md 的成员,取第一个 ```toml 到下一个 ``` 之间的内容作为 frontmatter,用标准库 tomllib 解析。首次按旧格式(纯 .toml)解析会得到 0 条,这是格式变更导致的,不是数据缺失。

最终样本:1246 条 advisory,时间跨度 2016-01 至 2026-09。

3.2 三个独立判据

本文刻意不为「是否内存漏洞」给出单一判定,而是用三个互相独立的判据,各自单独统计:

判据

定义

说明

A:带 CVE

aliases 字段中存在 CVE- 前缀编号

进入通用漏洞披露体系,可作为「实际漏洞」的保守代理指标

B:自称 unsound

正文正则匹配 unsound / soundness / undefined behavior / undefined behaviour / UB

由作者/报告者自己定性为健全性问题

C:有 CVSS

cvss 字段非空

被评定过威胁等级

三个判据不合并,因为它们的含义不同:判据 A 反映「是否被外部体系承认」,判据 B 反映「报告者的自我定性」,判据 C 反映「是否有严重度评分」。任何单一判据都不足以单独定义「可利用性」,因此本文在需要下判断的地方,都会同时给出多个判据下的数字,让读者自行权衡。

为什么用 CVE 而不是 CVSS 作为主判据: 以全库 1246 条为分母,CVSS 的覆盖率仅 29.3%(365 条可解析向量),缺失太多;判据 A 的覆盖率则是 42.7%(532 条)。这一差距在内存类公告内部更明显:该子集里判据 A 的覆盖率升至 54.3%(188/346)。而 CVE 的分配本身就是「这个缺陷值得独立编号」的外部裁决。

关于判据 C(CVSS)的用途:它的覆盖率不足以支撑「是否有 CVE」这类判断,但在 4.4 节做了另一件更重要的事 —— 比较内存类与非内存类的严重度分布。这里 CVSS 覆盖率的偏低本身就是一个发现:CVSS 主要出现在有 CVE 的公告上,soundness 类缺陷几乎不会被评 CVSS,因此这个分组比较实际上揭示了标签内部的真实结构(见 4.4 节)。

3.3 编码表

对每条 advisory 提取以下字段:

字段

来源

用途

id

frontmatter

主键,用于复核

package

frontmatter

涉及的 crate

date

frontmatter

年度趋势

categories

frontmatter

RQ1

aliases

frontmatter

判据 A

cvss

frontmatter

判据 C

informational

frontmatter

区分「漏洞」与「信息性通告」(490 条被标记)

正文全文

md body

判据 B;失效机理归纳

关于 informational:全库有 490 条被标记为 informational,主要包括「该 crate 已停止维护」这类通告。本文在做机理归纳时只使用带 memory-corruption / memory-exposure 标签的公告,其中 informational 类占比很低,未单独剔除,但在此声明其存在,以免读者误认为 1246 条全部是可利用漏洞。

3.4 统计口径

口径一:一条 advisory 可以属于多个 category。 因此各分类计数之和(370)大于「至少含一个内存类标签的公告数」(346),差额 24 条为同时带两个内存标签的公告。

口径二:43.9%(547 条)的公告没有 categories 字段。 这部分既不参与内存类统计,也不参与逻辑类统计。本文所有占比均以全库 1246 条为分母,与图表口径一致,任何一个比例都可以直接用「条数 ÷ 1246」复核。

3.5 案例选取

机理归纳需要读正文,而 346 条逐条精读不现实。案例选取标准:

  1. 知名度优先 —— 优先选取被广泛依赖的 crate(tokio、anyhow、bytes、openssl、serde_json 等),因为它们的缺陷影响面最大,也最能说明「这不是冷门项目的边缘问题」
  2. 机理代表性 —— 同类机理中选取描述最清晰、含可复现代码的
  3. 有 CVE 与无 CVE 并重 —— 刻意同时选取两类,以支撑 Q4

最终精读并收入本文的案例来自 22 条知名 crate 的内存类公告,完整正文已提取存档,可按 RUSTSEC-ID 复核。

3.6 伦理与合规

本文只使用公开的漏洞公告数据,不涉及任何未披露漏洞。所有引用的案例均来自已公开的 advisory,相关 crate 的维护者已完成修复。本文的批评对象是标签体系的风险沟通效率,不是任何具体的维护者或项目 —— 事实上,这些 advisory 能够被公开记录,恰恰说明该生态的披露机制是健康的。

四、结果

4.1 全库缺陷类型分布(RQ1)

图 1 RustSec 公告的缺陷类型分布。一条公告可属多个类别,故各类计数之和大于公告总数;占比以全库 1246 条公告为分母。数据来源:RustSec advisory-db 的 categories 字段。

按出现次数排序:

category

出现次数

占全库比例

memory-corruption

281

22.6%

denial-of-service

127

10.2%

memory-exposure

89

7.1%

crypto-failure

84

6.7%

malicious

75

6.0%

thread-safety

64

5.1%

code-execution

38

3.0%

format-injection

21

1.7%

file-disclosure

19

1.5%

privilege-escalation

19

1.5%

两个内存类标签的出现次数合计 370 次,对应 346 条 公告。内存类占比 27.8%,是单一类型中最高的一项。

malicious 的 75 条(6.0%)值得单独留意:这是 Rust 生态里的恶意包公告,说明供应链攻击已经进入这个一度被认为「包少、质量高、审查严」的生态。这一项在所有非内存类标签中排第三(仅次于 denial-of-service 127 与 crypto-failure 84),高于 code-execution(38)——发布恶意包的收益已经超过了直接写漏洞利用。

4.2 内存类缺陷的双口径演化(RQ2,核心发现)

memory-corruption 这一个标签,实际上装着两种性质完全不同的东西:

  • 实际可利用的漏洞 —— 攻击者能直接触发,通常被分配 CVE 编号
  • soundness 缺陷 —— 安全代码就能触发 UB,但需要特定调用模式配合,未必可利用

把它们按年拆开(判据 A 与判据 B),得到图 2:

图 2 内存类安全公告的两种口径逐年对比。浅灰线为内存类公告总数;红线为其中带 CVE 编号者;蓝线为其中正文自称 unsound / soundness / UB 者。2018–2019 年样本量分别为 5 与 7 条,比例不宜单独解读。数据来源:RustSec advisory-db 的 categories 与 aliases 字段。

年份

内存类总数

其中带 CVE(A)

其中自称 unsound(B)

A 占比

2018

5

4

2

80%

2019

7

7

2

100%

2020

82

77

47

94%

2021

72

67

32

93%

2022

27

9

15

33%

2023

22

10

13

45%

2024

19

5

7

26%

2025

51

3

35

6%

2026

61

6

40

10%

2020 年,内存类公告的 94%(77/82)带 CVE —— 那一年暴露出来的几乎全是真能利用的漏洞。

2026 年,这个比例是 10%(6/61)。同期自称 unsound 的达到 40 条。

同一个标签,六年之间含义完全变了。

还要注意灰色基线(内存类总量):2024 年降到 19 条的低点后,2025 年回升到 51、2026 年到 61 —— 内存类公告并没有消失,而是在换性质。回升的部分几乎全是 soundness,不是漏洞。

4.3 soundness 占比的抬升(RQ2 续)

图 3 内存类公告中「自称 unsound」所占比例。比例 = 正文含 unsound / soundness / undefined behaviour / UB 措辞的条数 ÷ 当年内存类公告总数。2018–2019 年分母仅 5 与 7 条,百分比波动大,不作为趋势依据。数据来源:RustSec advisory-db 全库正文检索。

按「自称 unsound 条数 ÷ 当年内存类总数」计算:

2020 年 57% → 2021 年 44% → 2022 年 56% → 2023 年 59% → 2024 年 37% → 2025 年 69% → 2026 年 66%。

这不是单调演进。 2024 年曾降到 37%,随后两年冲上 66–69%。结合 4.2 的总量数据可以解释:2025 年起内存类公告总量从 19 条骤增到 51、61 条 —— 这一轮增量由新审计驱动,而新审计发现的主要是历史上遗留的 soundness 债务。

4.4 内存类缺陷是否真的更严重(RQ4,统计检验)

4.2 和 4.3 说明了内存类缺陷性质在变,但没有回答一个更基本的问题:内存类缺陷是不是真的更危险? 如果内存类与非内存类的严重度分布没有差异,那「按类型分级告警」的建议就无从谈起。

RustSec 中有 365 条公告带有可解析的 CVSS 3.x 向量(占全库 29.3%);另有 63 条使用 CVSS 4.0 向量。本节的分组检验基于自行实现的 CVSS 3.x 基础分公式,4.0 分数与之不同量纲、不可混算,因此未纳入。相应地,内存类公告中 cvss 字段非空的共 131 条,其中 2 条为 CVSS 4.0(rssn RUSTSEC-2026-0038、lz4_flex RUSTSEC-2026-0041),故参与分组的内存类样本为 129 条。

按 CVSS 3.x 基础分公式逐条算分后,按「是否内存类」分组对比:

分组

n

均值

中位数

P90

严重级(≥9.0)

内存类

129

7.84

8.1

9.8

36(27.9%)

非内存类

130

7.01

7.5

8.6

9(6.9%)

图 4 CVSS 基础分的严重度分级分布:内存类(n = 129)与非内存类(n = 130)。条形为组内占比,右侧标出「严重级(CVSS ≥ 9.0)」占比:内存类 27.9%(Wilson 95% 置信区间 [20.9%, 36.2%])对非内存类 6.9%([3.7%, 12.6%]),两区间不重叠。Mann-Whitney U 单侧检验 p = 2.46×10⁻⁶,效应量 r = 0.324。数据来源:RustSec advisory-db 中 365 条含可解析 CVSS 向量的公告,基础分按 CVSS 3.x 标准公式自行计算。

Mann-Whitney U 单侧检验(内存类 > 非内存类):p = 2.456×10⁻⁶,效应量 r = 0.324。

两个「严重级」占比的 Wilson 95% 置信区间 完全不重叠(内存类 [20.9%, 36.2%] vs 非内存类 [3.7%, 12.6%])。

内存类缺陷不仅性质不同,严重程度也显著更高 —— 差异不是采样波动。

但这个结果还引出一个比「更严重」更要紧的推论:

那 129 条有 CVSS 的内存类缺陷,几乎全部来自有 CVE 的那一部分 —— 因为 CVSS 评分通常只对已编号的漏洞评定,soundness 类缺陷基本不会被评 CVSS。

于是 memory-corruption 标签内部的真实结构是这样的:

  • 被评分的那一半(有 CVE、有 CVSS):27.9% 是严重级,是生态中最危险的缺陷集中的地方
  • 没被评分的那一半(soundness):没有任何威胁等级评定,没人系统评估过它们的可利用性

同一个标签下,一半是生态中最危险的缺陷,另一半是无人评估利用性的技术债。

这正是「标签混装」的实际代价 —— 它不是学术上的分类洁癖问题,而是导致 cargo-audit 的告警无法分级、CI 门禁无法设置差异化阈值的直接原因。

4.5 排除「CVE 未分配」这一替代解释

4.2 的结论面临一个必须正面回应的质疑:2025–2026 的公告太新,CVE 编号可能还没走完分配流程,导致 CVE 数量被系统性低估。

检验方法:看已有足够时间完成 CVE 分配的年份。

年份

距今

内存类

带 CVE

A 占比

是否可能受分配延迟影响

2020

6 年

82

77

94%

否

2021

5 年

72

67

93%

否

2023

3 年

22

10

45%

基本不可能

2024

2 年

19

5

26%

基本不可能

2025

1 年

51

3

6%

可能有轻微影响

2026

半年

61

6

10%

可能有影响

2023 与 2024 年分别已过去 3 年和 2 年,CVE 分配流程早已完成,A 占比分别是 45% 和 26% —— 处在 2025–2026(6%、10%)与 2020–2021(93%、94%)之间,并且明显更靠近前者。

结论:A 占比的下降是真实的结构性变化,不是统计假象。 真正的转折点发生在 2022 年(该年内存类 27 条中仅 9 条带 CVE,占比 33%),此后一直维持在低位。

需要承认的残余不确定性:2025–2026 两列可能仍有轻微的 CVE 分配延迟影响,因此 6% 和 10% 这两个数字应理解为下界性质的估计 —— 真实值可能略高,但不会高到改变趋势判断。

五、四类失效机理(RQ3)

数据只回答「有多少」,回答不了「为什么」。而「为什么」才是 Rust 安全边界到底在哪里的答案。

把带内存标签的公告正文逐条阅读后,失效机理可归为四类。关键区分:只有第一类是 C 语言里也有的老问题,后三类是 Rust 引入的新问题。

5.1 第一类:手写内存管理重演 C 的老问题

unsafe 块里手写的内存操作如果算错,出的错和 C 里一模一样。这一类没有新意,但数量最多、后果最直接:

bytes RUSTSEC-2026-0007(CVE-2026-25541,2026-02)—— 整数溢出

// BytesMut::reserve 的唯一回收路径
if v_capacity >= new_cap + offset

new_cap + offset 是一次未检查的加法。在 release 构建下,usize 溢出会静默回绕(debug 构建才 panic),于是这个条件可能错误地通过,self.cap 被设成一个超过实际分配容量的值。后续 spare_capacity_mut() 等 API 信任这个被污染的值,进而构造出越界的切片。

两个关键点:bytes 是网络编程最底层的库之一,tokio、hyper 等核心框架都依赖它;缺陷根源是 Rust 为性能做的取舍 —— release 下整数溢出不检查。借用检查器对此完全无能为力,它检查的是所有权与生命周期,管不了整数语义。

smallvec RUSTSEC-2021-0003(CVE-2021-25900)—— 堆缓冲区溢出

insert_many 分配了比所需更小的缓冲区,然后越界写。触发条件是传入的迭代器产出元素数多于其 size_hint() 给出的下界 —— 也就是说,只要一个迭代器对自身规模的估计不准确,就能触发堆溢出。修复版同时把实现改成使用更少的 unsafe,官方说明是「更容易验证其正确性」——这句话本身就是对 unsafe 可验证性的注解。

同类还有:smallvec::grow() 在已溢出的 SmallVec 上用更小容量值,破坏分配器元数据(CVE-2019-15554);bitvec 在 BitVec → BitBox 转换时未考虑分配移动,导致双重释放(CVE-2020-35862);bumpalo::realloc 复制了 new_size 而非 old_size 字节,越界读取未知内存(CVE-2020-35861)。

5.2 第二类:类型系统没能表达真实约束

这类更有意思:代码通过了借用检查,因为借用检查看到的东西是「合法」的 —— 但真实的约束根本没被类型表达出来。

bumpalo RUSTSEC-2022-0078 —— 迭代器生命周期跑出了分配器范围

Vec::into_iter() 产生的迭代器,其生命周期没有被约束到分配它的 Bump 上。官方 advisory 给出的触发代码如下:

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);                 // 分配器先被释放
    for _ in 0..100 {
        let reuse_bump = Bump::new();              // 新分配器大概率复用同一块内存
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }
    for x in into_iter {               // ↓ 此处访问原内存 —— 已经是别人的了
        print!("0x{:02x} ", x);
    }
    println!();
}

这段代码没有任何 unsafe 关键字。 它全部由安全 API 写成,借用检查器全程放行 —— 因为迭代器类型没有携带「我依赖哪个 bump」这个信息,编译器无从知道这两个值有先后关系。

这是 Rust 特有的失效形态:问题不在 unsafe 写错,而在安全抽象的类型签名漏表达了一个真实存在的依赖。

openssl RUSTSEC-2025-0004(CVE-2025-24898,2025-02)—— 生命周期绑错了对象

ssl::select_next_proto 返回的切片指向 server 参数的缓冲区,但生命周期被绑定到了 client 参数上。当 server 缓冲区的存活期短于 client 时产生 use-after-free,可能把任意内存内容返回给客户端。修复方式是修改函数签名,将输出的生命周期正确约束到两个输入缓冲区。

注意这个案例的含义:缺陷存在于签名里,而签名是安全的、编译器检查过的。编译器验证了签名内部的自洽性,但无法验证签名是否忠实描述了实现的真实依赖。

anyhow RUSTSEC-2026-0190(2026-06)—— 借用链里混进共享引用(详见第六节)

5.3 第三类:auto trait 约束遗漏 —— C 里根本不存在的问题

这一类是本文认为最值得注意的,因为它在 C 里没有对应物:C 没有 Send/Sync 这类编译期线程安全抽象,也就不存在「抽象自身的约束写漏了」这种缺陷。

tokio RUSTSEC-2025-0023 —— broadcast channel 漏了 Sync

tokio::sync::broadcast 在接收时会并行对存的值调用 clone。但它只要求 T: Send,没有要求 T: Sync。这意味着可以传入一个 Send 但 !Sync 的类型 —— 如果它的 clone 实现依赖「不会被并发调用」这个性质(这正是 !Sync 所保证的),那么并行 clone 就会让它被并发访问,产生 UB。

本质是:这个 API 的 trait bound 少写了一个。 编译通过、类型检查通过、借用检查通过 —— 因为约束本身不完整,编译器的所有检查都建立在错误的前提上。

同类还有:

  • crossbeam-deque RUSTSEC-2021-0093(CVE-2021-32810):数据竞争导致任务被 pop 两次,而其他任务被遗忘。任务在堆上分配时触发双重释放。
  • tokio::sync::oneshot RUSTSEC-2021-0124(CVE-2021-45710):channel 关闭后并发调用 send 与 try_recv,两半通道并发访问同一内存位置,产生数据竞争并导致内存破坏。
  • borsh RUSTSEC-2023-0033:反序列化未实现 Copy/Clone 的零大小类型(ZST)时产生 UB —— 反序列化 1000 个实例后访问即段错误。

5.4 第四类:Drop 与线程语义脱节

类型系统管住了值,管不住「这个值在哪个线程上被析构」。

tokio RUSTSEC-2021-0072(CVE-2021-38191)—— 错线程析构

用 JoinHandle::abort 中止任务时,如果任务当时未在执行,future 会在调用 abort 的那个线程上被 drop。对于 LocalSet 上生成的任务,这是错误的线程 —— 而大量项目在 tokio 任务里使用 Rc / RefCell(它们天然不是 Send),跨线程 drop 直接破坏其内部不变量。问题在于 abort 是一个看起来完全无害的安全 API。

time RUSTSEC-2020-0071(CVE-2020-26235)/ chrono RUSTSEC-2020-0159 —— 多线程环境变量竞争

相关函数在多线程程序中不加同步地设置环境变量。当环境变量在与受影响函数不同的线程被读取时,可能因解引用悬垂指针而段错误。麻烦之处在于用户完全不知情 —— 触发点可能在标准库或第三方库里,且需要「先设置再读取」的时序配合。

5.5 四类机理的小结

类别

典型案例

是否 C 里也有

借用检查器为何失守

手写内存管理

bytes 整数溢出、smallvec 堆溢出

有

unsafe 块不在检查范围内

类型表达不足

bumpalo 迭代器、openssl 生命周期

无

签名自洽,但未忠实描述真实依赖

auto trait 约束遗漏

tokio broadcast 漏 Sync、crossbeam-deque

无

约束不完整,检查建立在错误前提上

Drop/线程语义

tokio 错误线程 drop、time 环境变量

无

类型系统不追踪运行时线程归属

后三类合计占据了相当比重,而它们都不可能出现在 C 语言中 —— 因为 C 没有 Send/Sync、没有生命周期、没有 Drop。Rust 在消除旧问题的同时,开辟了新的失效空间。

六、典型案例与现场验证

这两个案例放在一起,构成本文对 Q4 最直接的证据。

6.1 bytes RUSTSEC-2026-0007(CVE-2026-25541,2026-02)

  • 性质:整数溢出 → 越界切片
  • 是否有 CVE:有
  • 统计归类:漏洞
  • 库的地位:网络编程基础库(tokio、hyper 的依赖)
  • 成因:release 构建下整数静默回绕,绕过边界检查

6.2 anyhow RUSTSEC-2026-0190(2026-06)

anyhow 是 Rust 生态中使用最广泛的错误处理库。公告全文如下:

当用户先通过 Error::context() 给错误添加上下文,之后再调用 Error::downcast_mut() 时,构造可变引用的过程会把一个共享引用带进借用链,违反借用规则,产生未定义行为。修复方式(commit 6e8c000)是重构可变引用的构造方式,避免共享引用进入结果借用链。

  • 性质:借用规则违反 → UB
  • 是否有 CVE:无
  • 统计归类:soundness
  • 库的地位:最广泛使用的错误处理库
  • 成因:安全 API 内部构造引用时违规

为什么必须单独说它:

  1. 时间是 2026 年 6 月 —— 不是 Rust 早期的历史遗留
  2. 出事的不是冷门 crate —— anyhow 的月下载量在数亿量级
  3. 缺陷不在 unsafe —— 而是安全 API 的内部实现违反了借用规则。这类问题借用检查器在设计上就抓不到:它检查的是调用点的借用关系,不是库内部构造引用时的合法性
  4. 它没有 CVE —— 按本文口径属于「unsound」而非「可利用漏洞」。但它是 UB,且有明确触发路径。

上面四条都还是「公告说它是 UB」这一层面。它到底能不能被触发、触发时是什么样子 —— 下一节直接跑给你看。

6.3 现场验证:两个案例,两条修复路线

前面几节的分析都建立在「读取 RustSec 公告」之上。但本文的核心论断 —— 安全 API 内部可以违反借用规则,且编译器会全程放行 —— 值得独立验证,而不是停留在引用层面。

更值得做的是:同样属于「类型表达不足」这一类失效,不同的修复方式效果差别极大。anyhow 与 bumpalo 恰好处在两条不同的修复路线上,把它们放在一起跑,能直接看出差别。

实验设计:对每个 crate,各取「受影响的最后一个版本」与「修复版本」,跑同一段代码,用 Miri(Rust 官方 MIR 解释器,内置 Stacked Borrows 别名规则检查器)检测未定义行为。

下面这张是实验现场的真实终端截图(Windows PowerShell,非示意图;本机用户名路径已做马赛克处理)——本节后续所有输出都来自同一条命令 cargo +nightly-x86_64-pc-windows-gnu miri run:

图 5 实验现场的真实终端截图(上下两张为同一窗口先后两次运行)。上:anyhow 1.0.102,Miri 在 anyhow-1.0.102/src/ptr.rs:170 处检出别名规则违规,栈回溯指向 downcast_mut,退出码 1。下:切到 1.0.104 后运行同一段代码,new context 正常输出、无任何 Miri 告警、退出码 0(窗口内 Updating anyhow v1.0.102 -> v1.0.104 一行即版本切换的现场记录)。复现环境:rustc 1.100.0-nightly、target x86_64-pc-windows-gnu;工程与日志见 repro/。

6.3.1 案例 A:anyhow——改实现

被测代码(全文如下,没有任何 unsafe):

use anyhow::Error;
use std::fmt;

#[derive(Debug)]
struct ErrorContext(&'static str);

impl fmt::Display for ErrorContext {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, f)
    }
}

fn main() {
    let mut error = Error::msg("inner error").context(ErrorContext("old context"));

    // ↓ 这一行触发 UB:downcast_mut 返回的可变引用,
    //   与 context() 内部持有的共享引用共存于同一借用链
    let context: &mut ErrorContext = error.downcast_mut().unwrap();
    context.0 = "new context";

    println!("{:?}", error);
}

anyhow 版本

Miri 退出码

结果

1.0.102(受影响)

1

检出 Undefined Behavior

1.0.104(含修复)

0

无告警,正常输出

图 6 anyhow 对照实验:同一份代码在受影响版本与修复版本上的运行结果。上半为 1.0.102,Miri 检出「以只读标签构造可变引用」的别名规则违规;下半为 1.0.104,同一份代码无任何 Miri 告警。被测代码不含任何 unsafe。复现环境:rustc 1.100.0-nightly、Miri(Stacked Borrows)、target x86_64-pc-windows-gnu;原始日志见 repro/miri_1.0.102.txt 与 repro/miri_1.0.104.txt。

1.0.102 的报错原文(节选):

error: Undefined Behavior: trying to retag from <7316> for Unique permission
       at alloc2471[0x38], but that tag only grants SharedReadOnly permission
       for this location
   --> anyhow-1.0.102/src/ptr.rs:170:18
    |
170 |         unsafe { &mut *self.ptr.as_ptr() }
help: <7316> was created by a SharedReadOnly retag at offsets [0x38..0x48]
   --> src/main.rs:33:38
    |
 33 |     let context: &mut ErrorContext = error.downcast_mut().unwrap();
    = note: stack backtrace:
            0: anyhow::ptr::Mut::<'_, ErrorContext>::deref_mut
                at anyhow-1.0.102/src/ptr.rs:170:18
            1: anyhow::error::<impl anyhow::Error>::downcast_mut::<ErrorContext>
                at anyhow-1.0.102/src/error.rs:560:18
            2: main
                at src/main.rs:33:38

修复方式是重写内部实现(commit 6e8c000:重构可变引用的构造方式,避免共享引用进入借用链)。类型签名没有变 —— 所以同一段代码在 1.0.104 上照常编译通过,只是 Miri 不再报 UB。

6.3.2 案例 B:bumpalo——改类型签名

被测代码(同样没有 unsafe):

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();   // 迭代器没携带「依赖哪个 bump」的信息
    drop(bump);                        // 分配器先被释放

    for _ in 0..100 {                  // 反复申请新 Bump,让分配器复用同一块内存
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {               // ↓ use-after-free
        print!("0x{:02x} ", x);
    }
    println!();
}

bumpalo 版本

结果

3.11.0(受影响)

Miri 检出 Undefined Behavior

3.11.1(含修复)

编译失败(E0505:不能在借用存续期间移出 bump)

图 7 bumpalo 对照实验:受影响版本检出 use-after-free,修复版本在编译期拒绝同一段代码。上半为 3.11.0,Miri 同时给出分配点(src/main.rs:21)、释放点(src/main.rs:25)与 UB 发生点(bumpalo/src/collections/vec.rs:2300);下半为 3.11.1,同一份代码报 E0505 —— drop(bump) 与迭代器的借用冲突。被测代码同样不含任何 unsafe。原始日志见 repro/miri_bumpalo_3.11.0.txt 与 repro/miri_bumpalo_3.11.1.txt。

3.11.0 上 Miri 的输出 —— 这次的诊断信息完整到可以直接当 UAF 教材,它同时给出了分配点、释放点和 UB 发生点:

error: Undefined Behavior: in-bounds pointer arithmetic failed:
       alloc858 has been freed, so this pointer is dangling
    --> bumpalo-3.11.0/src/collections/vec.rs:2300:28
     |
2300 |                 self.ptr = self.ptr.offset(1);
     |                            ^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
     |
help: alloc858 was allocated here:
    --> src/main.rs:21:5
     |
  21 |     vec.extend([0x01u8; 32]);
     |     ^^^^^^^^^^^^^^^^^^^^^^^^
help: alloc858 was deallocated here:
    --> src/main.rs:25:5
     |
  25 |     drop(bump);
     |     ^^^^^^^^^^
     = note: stack backtrace:
             0: <bumpalo::collections::vec::IntoIter<u8> as std::iter::Iterator>::next
                 at bumpalo-3.11.0/src/collections/vec.rs:2300:28
             1: main
                 at src/main.rs:34:14

而 3.11.1 上,同一段代码根本编译不过 —— 修复方式是给 IntoIter 增加生命周期参数,把这个信息补进类型里:

error[E0505]: cannot move out of `bump` because it is borrowed
   --> src/main.rs:25:10
    |
 19 |     let bump = Bump::new();
    |         ---- binding `bump` declared here
 20 |     let mut vec = Vec::new_in(&bump);
    |                               ----- borrow of `bump` occurs here
 25 |     drop(bump);
    |          ^^^^ move out of `bump` occurs here
 34 |     for x in into_iter {
    |              --------- borrow later used here

编译器这段报错本身就是对本文论点的注解:它明确指出了「借用在这里产生 → 借用在这里还被使用 → 所以你不能在中间移出 bump」。而这正是 3.11.1 之前类型里缺失的那条信息 —— 信息一旦补进去,编译器就能自己拦住所有同类用法。

6.3.3 两条修复路线的差别


anyhow(1.0.104)

bumpalo(3.11.1)

改的是什么

内部实现

类型签名

类型是否变强

否

是(IntoIter 增加生命周期参数)

同一段触发代码在修复版

能编译,只是不再触发 UB

编译失败(E0505)

同类用法能否再出现

可能 —— 类型没变,下次实现再写错依然无人拦

不能 —— 编译器从此拒绝

检测依赖

只能靠 Miri / sanitizer

编译器本身

这个对比给出了本文关于「类型表达不足」这一类失效的一个结论:

改实现只是修掉了这一个 bug;改类型签名才是把「编译器看不见的约束」变成「编译器能检查的约束」。 前者留下的是「同一类错误可能再犯」,后者留下的是编译错误 —— 代价是可能破坏下游兼容(bumpalo 的这个修复确实改变了 into_iter() 的签名)。

三条观察,逐条都有上面的输出支撑:

  1. 缺陷是真实存在且当前可触发的 —— 不是「理论上可能」。Miri 在两个不同的 crate 上分别抓到了别名规则违规与悬垂指针。
  2. 两段触发代码都不含 unsafe —— 使用者不需要打开任何不安全开关,只需要正常的调用顺序(先 context() 再 downcast_mut();先取迭代器再 drop 分配器)。
  3. 编译器在受影响版本上全程放行 —— 两段代码都毫无警告地编译通过。借用检查器检查的是调用点的借用关系,而缺陷发生在库内部构造引用时 —— 那已经在它的视野之外。

这就完成了 4.2 节「悲观解释」的闭环。 两个都在使用最广泛的库之列、都在 2022–2026 年之间披露、后果都是 UB 级、都能稳定复现且触发代码零 unsafe —— 而它们在 RustSec 里都没有 CVE、都没有 CVSS 评分,标签是 memory-corruption。

如果这样的缺陷都被统计归入「不是漏洞」的那一类,那「2026 年 CVE 比例只有 10%」这个数字就不能被读作「Rust 的内存问题基本解决了」。

6.4 bytes 与 anyhow 的对照


bytes(2026-02)

anyhow(2026-06)

缺陷性质

整数溢出 → 越界切片

借用规则违反 → UB

是否有 CVE

有

无

统计归类

漏洞

soundness

库地位

网络编程基础库

最广泛使用的错误处理库

成因层

unsafe 块内的算术

安全 API 内部的引用构造

后果

攻击者可控的越界读

未定义行为

这两个缺陷的后果类型相同(都不满足内存安全),但在统计上被分到了两类。 这不是 bytes 或 anyhow 的问题,而是标签体系的问题。

这正是 4.2 节「悲观解释」的实证:一个使用极广的库、2026 年、UB 级缺陷,在统计上被归入「不是漏洞」的那一类。也就是说,「CVE 比例降到 6%」这个数字,不能直接读作「Rust 的内存问题减少了 94%」。

七、讨论

7.1 memory-corruption 标签的风险沟通能力已失效

这是本文最想指出的结论。

该标签同时装着:

  • bytes 那种攻击者可直接利用的越界读(有 CVE,CVSS 可评)
  • anyhow 那种需要特定调用模式才触发的 UB(无 CVE,但同属内存安全范畴)
  • bumpalo 那种官方 advisory 里附了一段能直接跑的触发代码的 unsound

三者的风险差一个数量级,但对外的标签完全一样。

由此产生两个方向的误判:

  • 看空的人:数出 281 条 memory-corruption,得出「Rust 也有大量内存漏洞」—— 夸大
  • 看多的人:看到 CVE 比例降到 6%,得出「Rust 的内存问题解决了」—— 漏掉 anyhow 这类通过安全 API 触发的 UB

正确的读法是按口径分开看:346 条内存类公告中,188 条带 CVE(判据 A)属于需要关注的外部风险;158 条不带 CVE 属于生态内部技术债 —— 但其中一部分(如 anyhow)具备 UB 级后果,只是触发条件苛刻。

7.2 Rust 的安全边界在哪里

把四类机理和演化数据合起来看,Rust 的安全边界可以这样描述:

编译器保证的那部分,是真实有效的。 内存类公告里带 CVE 的比例从 94% 降到 6–10%,这个下降是真实的(已排除 CVE 分配延迟的解释),且发生在 unsafe 代码量与生态规模同时增长的背景下。

编译器没保证的那部分,构成了剩余的全部风险,并且分为两个性质不同的子集:

  • unsafe 块内的手写内存管理(第一类)—— 这是 Rust 主动接受的代价,是「明知的风险」
  • 安全抽象自身的缺陷(第二、三、四类)—— 类型签名漏表达约束、trait bound 写漏、Drop 语义脱节。这类风险的特点是:使用者在写完全安全的代码时就已经暴露,且编译器的所有检查都会为它放行

第二类的下半句才是关键:一个使用者可能从来不写 unsafe,完全信任编译器,却仍然因为一个依赖库的签名缺陷而获得 UB。

7.3 对使用者的实务含义

从本文数据可以得出三条可操作的建议:

  1. cargo audit 的告警不能只看数量。 当前它同时报告两类性质不同的内存问题。使用者需要进一步查看 advisory 正文判断性质 —— 有 CVE 的优先处理,unsound 类按触发条件评估。
  2. 依赖的「安全性」需要区分层次。 一个 crate 声明的 unsafe 代码量是透明的(可查),但它安全抽象的正确性是不透明的。本文的案例表明,后者可能出更大问题(bumpalo 的 UAF 触发代码没有任何 unsafe)。
  3. 对新版本的关注度应高于对旧版本的容忍度。 2025–2026 的内存类公告中有相当部分是历史遗留的 soundness 债务被新审计发现,而非新引入的缺陷。这意味着升级会带来大量「原来就有问题」的告警 —— 这些告警值得看,但不必恐慌。

八、限制与偏差

本文的方法学局限,逐项列出:

1. 数据源单一。 本文只使用 RustSec advisory-db。它虽然同时是 cargo-audit 的数据源(因此是事实标准),但不代表 Rust 生态全部的安全缺陷 —— 未上报、未记录的缺陷不在样本内。因此本文所有比例应理解为本库内的分布,而非生态的真实缺陷率。

2. 判据 A(CVE)是「可利用性」的代理指标,不是等价物。 一个缺陷可以被分配 CVE 却难以利用,也可以不被分配 CVE 却可被利用。本文使用它是因为分配行为本身反映了外部裁决,但这个代理关系不是完美的。

3. 判据 B(自称 unsound)依赖措辞。 正文是否出现 unsound / UB 等词,受报告者的写作习惯影响。有些 soundness 缺陷可能用其他措辞描述(如 violates、incorrect),会被判据 B 漏掉,导致 B 类数量被低估。

4. 43.9% 的公告无 categories。 这部分未参与类型统计。如果它们的类型分布与有分类的部分显著不同,本文 RQ1 的结论会有偏差。无法检验这一点,因为无分类就是没有信息。

5. 2025–2026 存在残余的 CVE 分配延迟。 如 4.5 节所述,这两年仍有轻微延迟影响,因此 6% 与 10% 应视为下界估计。

6. 案例选取非随机。 第 3.5 节的选取标准倾向于知名度高的 crate,因此第五、六节呈现的失效机理偏向于影响力大、披露质量高的案例,不能代表长尾 crate 的分布。

7. 单一时点快照。 数据为一次抓取的仓库快照,未做时间序列追踪。公告库会持续修订(例如补充分类字段、更正日期),本文数字对应抓取时刻。

8. CVSS 4.0 向量未纳入。 全库另有 63 条公告使用 CVSS 4.0 向量,因与 3.x 不同量纲而未参与 4.4 节的分组检验(见 4.4 节)。其中属于内存类的只有 2 条,因此内存类一侧的样本几乎完整(129/131);缺口主要在非内存类一侧,而这批样本缺失对结论的影响方向未经检验,这是 4.4 节统计结果的一处已知缺口。

九、缓解建议

9.1 对 crate 维护者

  1. 把「这个 API 在什么条件下是 sound」写成文档。 本文第二类机理的根源是「约束没被类型表达」,退一步的做法是用文档显式写出前提 —— bumpalo 的 advisory 之所以清晰,正是因为触发条件被讲清楚了。
  2. unsafe 块的规模是可控变量。 smallvec 在修复 CVE-2021-25900 时,官方说明提到修复版「使用了更少的 unsafe,因此更容易验证其正确性」——这是一个值得推广的实践:把可验证性当作与性能并列的设计目标。
  3. 注意 trait bound 的完备性。 tokio broadcast 漏 Sync 的教训是:并发 API 的 bound 需要按「实现实际做了什么」来写,而不是按「看起来需要什么」来写。

9.2 对下游使用者

  1. 区分对待两类告警(见 7.3 节)。
  2. 对少数关键依赖做「抽象正确性」评估 —— 尤其是提供容器、分配器、并发原语的 crate。它们的 unsafe 是必要的,但其安全抽象的正确性无法由编译器验证。
  3. 不要把「无 CVE」等同于「无风险」 —— anyhow 是活生生的反例。

9.3 对审计与披露方

这是本文认为最值得推进的一条:建议 RustSec 在 memory-corruption 下增设可利用性分层,例如:

  • memory-corruption + exploitable:攻击者可直接触发(对应判据 A)
  • memory-corruption + soundness-only:需要特定调用模式,无已知外部触发路径

如果这一分层存在,本文 4.2 节的那张表就不再需要人工推断,而可以直接从数据读出。当前状态是:这个区分只存在于每条 advisory 的正文里,而不在结构化字段中 —— 这意味着任何自动化工具(cargo-audit、CI 门禁)都无法据此分级,只能一视同仁地报警。

十、结论

第一,Rust 的承诺兑现了,但兑现的方式和宣传的不一样。 内存类公告里带 CVE 的比例从 2020 年的 94% 降至 2025–2026 年的 6–10%,且这一下降已排除「CVE 分配延迟」的解释。但它主要不是通过「消除内存安全问题」实现的,而是通过把问题压缩到「需要特定调用模式才触发」:类型签名漏了约束、trait bound 少写一个、迭代器生命周期跑出分配器范围、unsafe 块里算错一个加法。

第二,Rust 引入了 C 里不存在的失效类别。 第三类(auto trait 约束遗漏)是典型:Send/Sync 是 Rust 安全模型自己的抽象,它们的约束可以被写漏。tokio broadcast channel 只要求 T: Send 而不要求 T: Sync —— 编译器放行,因为所有检查都建立在「约束是完整的」这个前提上。

第三,memory-corruption 这个标签的风险沟通能力已经失效。

这不是分类洁癖,有定量支撑。对 365 条带 CVSS 的公告做分组检验后发现:内存类缺陷的严重度显著高于非内存类(均值 7.84 vs 7.01,严重级占比 27.9% vs 6.9%,两个 Wilson 区间不重叠,Mann-Whitney U 单侧 p = 2.46×10⁻⁶)。

而这恰恰暴露了问题:那 129 条带 CVSS 的内存类缺陷几乎全是有 CVE 的部分 —— soundness 类不会被评 CVSS。所以标签内部的真实结构是:

  • 被评分的那一半:27.9% 达到严重级,是生态中最危险的缺陷集中的地方
  • 没被评分的那一半:没有任何威胁等级评定,没人系统评估过可利用性

它同时装着 bytes 那种攻击者可直接利用的越界读(有 CVE),和 anyhow 那种最流行库里的 UB(无 CVE、无评分)。两者后果类型相同,风险等级差一个数量级,对外却叫同一个名字 —— 一半是生态里最危险的,另一半是没人评估的。

这直接导致 cargo-audit 的告警无法分级,CI 门禁无法设置差异化阈值。 也因此,「CVE 比例降到 6%」这个数字不能被直接读作「Rust 的内存问题减少了 94%」。

最后,回到标题里的那个断层。

答案是:比 C 安全得多,但这个「安全」有明确的形状。 它被压缩在「编译器能看见的那部分」里。编译器看不见的部分 —— unsafe 块、类型签名的忠实性、trait bound 的完备性、值的线程归属 —— 仍然由写代码的人手工维护。

而 2025–2026 的数据说明,这部分的手工维护正在成为主要的风险来源。 94% 到 6% 这个数字,描述的不是「问题消失了」,而是「问题从一个可被外部利用的形式,迁移到了一个需要特定条件才暴露的形式」—— 而后者恰恰不出现在 CVE 里,也不出现在 CVSS 评分里。

参考文献

  1. RustSec Working Group. RustSec Advisory Database(开源仓库,含 advisory 格式说明与分类定义). https://github.com/RustSec/advisory-db
  2. RustSec Working Group. advisory-db README(仓库主文档,说明目录结构、advisory 文件格式与 categories 取值). https://github.com/RustSec/advisory-db/blob/main/README.md
  3. RustSec Working Group. EXAMPLE_ADVISORY.md(advisory 文件格式样例,本文 3.1 节据此解析). https://github.com/RustSec/advisory-db/blob/main/EXAMPLE_ADVISORY.md
  4. RustBelt Project. RustBelt: Logical Foundations for the Future of Safe Systems Programming(项目主页). https://plv.mpi-sws.org/rustbelt/
  5. The Rust Reference. Behavior considered undefined. https://doc.rust-lang.org/reference/behavior-considered-undefined.html
  6. The Rustonomicon. The Dark Arts of Advanced and Unsafe Rust Programming. https://doc.rust-lang.org/nomicon/
  7. 各案例对应的 RustSec Advisory 原文(RUSTSEC-2026-0007、RUSTSEC-2026-0190、RUSTSEC-2025-0023、RUSTSEC-2025-0004、RUSTSEC-2022-0078、RUSTSEC-2021-0003、RUSTSEC-2021-0072、RUSTSEC-2021-0093、RUSTSEC-2020-0071、RUSTSEC-2020-0159 等),可按 ID 在数据源中检索。
  8. dtolnay/anyhow, UB in Error::downcast_mut(Issue #451,RUSTSEC-2026-0190 对应的上游问题单,修复见 commit 6e8c000). https://github.com/dtolnay/anyhow/issues/451
  9. Rust 内存安全检测方向的近期工作(本文 2.4 节引用):TYPEPULSE: Detecting Type Confusion Bugs in Rust Programs(arXiv:2502.03271,USENIX Security 2025);UnsafeChecker: Finding Soundness Bugs in Rust Safe Abstractions(arXiv:2609.09641);deepSURF: Detecting Memory Safety Vulnerabilities in Rust Through Fuzzing LLM-Augmented Harnesses(arXiv:2506.15648);RustGo: Fairly Directed Greybox Fuzzing for Enforcing Rust Memory Safety(arXiv:2608.05870)。

附录:复现

A. 获取数据

curl -L -o advisory-db.tar.gz \
  https://codeload.github.com/RustSec/advisory-db/tar.gz/refs/heads/main

B. 解析要点(复现者必读)

公告文件路径为 crates/<crate>/RUSTSEC-YYYY-NNNN.md,frontmatter 是代码块形式而非 +++:

```toml
[advisory]
id = "..."
categories = [...]
```

取第一个 ```toml 至下一个 ``` 之间的内容,用 tomllib.loads() 解析。若按旧格式(纯 .toml)解析会得到 0 条 —— 这是格式变更,不是数据缺失(本次踩坑记录)。

C. 三个判据统计

  • 判据 A:any(x.startswith("CVE-") for x in advisory.get("aliases") or [])
  • 判据 B:re.search(r"\b(unsound|soundness|undefined behavior|undefined behaviour|ub\b)", full_text, re.I)
  • 判据 C:bool(advisory.get("cvss"))

D. 本次解析的关键结果(供复核)

指标

数值

解析出的 advisory 总数

1246

含内存类标签(去重)

346

内存类标签出现次数

370(corruption 281 + exposure 89)

无 categories 字段

547(43.9%)

内存类中带 CVE(判据 A)

188

内存类中自称 unsound(判据 B)

193

内存类中有 CVSS(判据 C)

131

同时满足 A 与 B

87

仅满足 B

106

仅满足 A

101

A、B 均不满足

52

全库带 CVE(任一类)

532(42.7%)

含可解析 CVSS 3.x 向量

365(29.3%)

含 CVSS 4.0 向量(未纳入分组)

63

其中内存类 / 非内存类

129 / 130

内存类严重级(≥9.0)占比

27.9%(Wilson95% [20.9%, 36.2%])

非内存类严重级占比

6.9%(Wilson95% [3.7%, 12.6%])

Mann-Whitney U(内存类>非内存类)

U=11098.0,p=2.456×10⁻⁶,r=0.324

E. 目录结构

本文实际用到的文件如下(不列选题阶段试错留下的探针脚本):

rustsec_audit/
├── scripts/
│   ├── rustsec_audit.py            # 全库类型分布与年度统计(附录取数的主要来源)
│   ├── rustsec_mem_breakdown.py    # 内存类双口径细分(判据 A / B / C)
│   ├── rustsec_cases.py            # 知名 crate 的 advisory 正文提取
│   ├── cvss_analysis.py            # 自实现 CVSS 3.x 基础分 + Mann-Whitney U 检验
│   ├── figures_rustsec.py          # 图 1–图 4(SVG)
│   ├── fig_miri.py                 # 图 6 anyhow 对照
│   ├── fig_miri_bumpalo.py         # 图 7 bumpalo 对照
│   ├── make_fig7_pair.py           # 图 5(把两张真截图拼成上下对照)
│   ├── make_cover.py               # 投稿封面(SVG)
│   ├── make_cover_png.py           # 投稿封面(SVG → PNG)
│   ├── svg2png.py                  # SVG → PNG(Edge 无头模式)
│   ├── rebuild_all.py              # 一键:出图 → 转 PNG → 跑三项校验
│   └── final_check.py              # 数字自洽与标题一致性校验
├── data/
│   ├── rustsec.json                # 全库解析结果(1246 条)
│   ├── rustsec_mem.json            # 内存类双口径细分结果
│   ├── rustsec_cases.txt           # 22 条案例正文存档
│   └── rustsec_cvss.json           # CVSS 计算与分组结果
├── repro/                          # ★ 复现材料,编辑索要 PoC 时给这个目录
│   ├── anyhow_ub/                  # cargo 工程:RUSTSEC-2026-0190
│   ├── bumpalo_uaf/                # cargo 工程:RUSTSEC-2022-0078
│   ├── run_contrast.py             # anyhow 对照实验驱动
│   ├── run_contrast_bumpalo.py     # bumpalo 对照实验驱动
│   ├── miri_1.0.102.txt            # anyhow 受影响版本:Miri 检出 UB
│   ├── miri_1.0.104.txt            # anyhow 修复版本:无告警
│   ├── miri_bumpalo_3.11.0.txt     # bumpalo 受影响版本:检出 use-after-free
│   ├── miri_bumpalo_3.11.1.txt     # bumpalo 修复版本:编译失败
│   ├── shot_anyhow102.png          # 图 5 上半(真机截图)
│   └── shot_terminal2.png          # 图 5 下半(真机截图)
├── svg_src/                        # 全部图的 SVG 源(8 个:7 张正文图 + 封面)
├── images/                         # 正文配图 PNG(7 张;文件名编号 ≠ 正文图号)
└── final/
    ├── 01_正文.md                  # 本文
    ├── 02_导读.txt                 # 标题 / 摘要 / 配图清单 / 分类建议
    ├── 03_投稿步骤.md              # 先知投稿页字段逐项对照
    └── cover_1200x900.png          # 投稿封面(先知必填,4:3)

复现任一案例的最短路径:装好 Rust nightly + Miri 后,进入 repro/anyhow_ub(或 bumpalo_uaf)执行 cargo +nightly miri run,即可看到与图 6、图 7 一致的输出。