【信息科学与工程学】【安全领域】【信息科学与工程学】【安全领域】安全基础——第十六篇云安全 10 云计算安全领域的核心算法和模型01-171主机测评

云计算安全领域的核心算法和模型

编号

类别

领域

模型配方

定理/算法/模型/方法名称

定理/算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式和参数选择/参数优化

精度/密度/误差/强度

底层规律/理论定理

典型应用场景和各类特征

变量/常量/参数列表及说明

数学特征

时序和交互流程的所有细节/分步骤时序情况及数学方程式

流动模型和流向方法的数学描述

硬件设计/软件设计及资源

Safety-D1-0001

硬件安全

芯片设计/物理不可克隆函数

基于环形振荡器频率的PUF

环形振荡器物理不可克隆函数

1. 电路构造：在芯片上制造大量（N对）完全相同的环形振荡器（RO）。每个RO由奇数个反相器首尾相接构成，振荡频率 f=1/(2⋅n⋅td)，其中 n为反相器级数， td为每级延迟。 2. 激励-响应：挑战（C）选择一对RO（RO_i， RO_j）。响应（R）为比较两者频率： R=Sign(fi−fj)。若 fi>fj，则 R=1，否则 R=0。 3. 参数选择：反相器级数 n通常为3, 5, 7等奇数。延迟 td由工艺偏差（阈值电压Vth，沟道长度L的微观差异）决定，具有随机性。选择RO对的数量N决定了PUF的挑战-响应对空间（2^N量级）。 4. 优化：通过增加仲裁器或多次采样取平均来抗环境噪声（电压、温度）。使用纠错码（如BCH码）对原始响应进行模糊提取，提升稳定性。

唯一性：汉明距离（HD_inter）期望为0.5。可靠性：汉明距离（HD_intra）应尽可能低（<5%）。随机性：通过NIST统计测试套件。

半导体制造过程中的微观物理差异具有不可克隆的随机性。利用这些差异产生芯片的“数字指纹”。

场景：设备身份认证、安全密钥生成、硬件防伪。特征：不可克隆、不可预测、对物理攻击敏感（可作为入侵检测）。

C：挑战向量，选择RO对的索引。 R：响应比特。 f_i, f_j：第i， j个环形振荡器的频率。 N： RO对总数。 t_d：单元门延迟，是工艺、电压、温度（PVT）的函数。 Sign( )：符号函数。

集合与逻辑：挑战-响应对的映射。概率与统计：频率分布，汉明距离统计。随机性：制造过程的随机物理偏差。稳定性：对抗环境噪声的稳定性分析。

1. 注册阶段：在受控环境下，施加一系列挑战 {C_k}，测得并存储其对应的可靠响应 {R_k} 的哈希值 H(R_k)。 2. 认证阶段：施加相同挑战 C_k，测得当前响应 R'k。计算 R'k 与存储的哈希值是否匹配（或经纠错后匹配）。方程式： Auth=[H(Rk′⊕ECC(Rk′,Syndrome))==Stored_Hash]

信息流：挑战C -> RO阵列 -> 频率计数器 -> 比较器/仲裁器 -> 原始响应R -> （可选）纠错编码器 -> 最终响应。数学描述： R=FPUF(C;Θphysical)，其中 Θphysical代表芯片的物理随机参数集合，函数 F由电路拓扑决定。

硬件：需集成大量（数千个）RO单元、多路选择器、计数器和比较器。占用硅片面积，功耗与激活的RO数量成正比。软件：驱动电路、控制挑战-响应协议、实现模糊提取和纠错算法。

Safety-D1-0002

硬件安全

内存加密

基于Tweakable分组密码的模式

内存加密引擎（XTS-AES模式）

1. 问题建模：内存数据以固定大小的块（如Cache Line， 64字节）存储，地址已知。需确保相同明文在不同地址加密成不同密文。 2. 算法步骤： a. 将明文 P分为 m 个 128-bit 块： P=P1∥P2∥…∥Pm。 b. 生成Tweak值 T=Address（或地址的某种编码）。计算调整值： α=EK(T)，其中 E是AES加密， K是加密密钥。 c. 对第 j 块明文加密： Cj=EK2(Pj⊕(α⊗GF(2128)j))⊕(α⊗GF(2128)j)。其中 ⊗表示伽罗华域乘法， j是块序号。 d. 组合密文块得到最终密文 C。 3. 参数选择：块大小128-bit与AES一致。Tweak通常使用内存地址的高位（排除块内偏移）。使用两个独立密钥K1， K2（可从主密钥派生）。伽罗华域多项式通常取 x128+x7+x2+x+1。

强度：与底层AES算法强度相同（128， 192， 256位）。误差传播：一个密文块错误仅影响对应明文块。

可调分组密码理论。Tweak像一个“第二地址”，确保相同明文在不同位置（或不同Tweak下）密文独立。

场景：保护DRAM、持久性内存中的数据，防止物理探测、冷启动攻击。特征：确定性加密、并行化友好、与地址强绑定。

P, C：明文和密文数据块。 K1, K2： AES加密密钥。 T： Tweak值（通常为内存地址）。 α：由Tweak生成的掩码。 j：数据块在段内的序号。 E( )： AES加密函数。 ⊕：按位异或。 ⊗：伽罗华域乘法。

代数：伽罗华域算术。对称性：加密解密结构对称。计算与算法：分组密码模式。

写入流程： CPU给出地址Addr和数据P -> 内存控制器计算Tweak=Addr -> 计算α -> 逐块计算 Cj-> 将C写入内存。读取流程：从Addr读出C -> 计算相同α -> 逐块解密 Pj=DK2(Cj⊕(α⊗j))⊕(α⊗j)-> 返回P给CPU。方程式：如上加密/解密步骤。

数据流： CPU数据总线 <-> 加密/解密引擎 <-> 内存总线 <-> DRAM。控制流：内存访问地址触发Tweak生成和加解密操作。数学描述： C=XTS-Encrypt(K1,K2,T,P), P=XTS-Decrypt(K1,K2,T,C)。

硬件：集成在内存控制器或SoC中，包含AES核心、伽罗华域乘法器、密钥存储。对内存访问引入固定延迟（几个时钟周期）。软件：操作系统分配和管理加密密钥，确保进程间隔离。

Safety-D1-0003

网络安全

网络协议/形式化验证

模型检验与状态空间可达性分析

协议安全属性的模型检验（以TLA+为例）

1. 形式化规约：用形式化语言（如TLA+）定义协议模型M。包括： – 状态变量集合 V={v1,v2,…}。 – 初始状态谓词 Init(V)。 – 状态转移关系 Next(V,V‘)，定义在状态V下，下一个状态V‘的可能取值。 2. 定义安全属性：用时序逻辑公式 ϕ表达属性（如“秘密永远不会泄露”）。常用线性时序逻辑（LTL）或计算树逻辑（CTL）。例如，安全属性 G(secret_is_safe)表示“在所有可达状态下，秘密始终安全”。 3. 模型检验：算法（如状态空间搜索）系统性地遍历从 Init出发，通过 Next关系可达的所有状态集合 SR。检查 SR中每个状态（或路径）是否都满足 ϕ。 4. 参数优化：为应对状态爆炸，使用抽象解释（合并相似状态）、对称规约、界限模型检测（限制运行步数k）。

精度：对给定模型M，验证结果是精确的（是/否）。若属性不满足，检验器会提供反例路径。误差：抽象和界限可能引入误差（假阳性/假阴性），需人工复核。

图论（状态空间为有向图），逻辑学（一阶逻辑，时序逻辑），自动机理论。

场景：验证TLS， TCP， 5G等复杂协议的设计安全性，发现逻辑漏洞（如竞争条件、死锁）。特征：穷尽性、自动化、在模型边界内保证正确性。

M：形式化模型。 V：状态变量向量。 Init：初始状态谓词。 Next：状态转移关系。 φ：要验证的时序逻辑公式。 S_R：从Init出发，通过Next可达的所有状态集合。

逻辑：谓词逻辑，时序逻辑。集合：状态集合。图论：状态空间图的可达性分析。离散：状态是离散的。

1. 初始化：状态队列 Q = {s0

Init(s0)=True}。已验证状态集合 S_v = ∅。 2. 搜索循环： while Q 非空: 取出状态 s; if s 不满足 φ: 返回“假”及反例路径; 将 s 加入 S_v; 对所有满足 Next(s, s‘) 的 s‘，若 s‘ 不在 S_v 中，则将 s‘ 加入 Q。 3. 结束：若循环结束，则返回“真”，属性成立。方程式：算法核心是计算不动点： (S_R = \\mu S. (Init \\cup {s‘

\\exists s \\in S: Next(s, s‘)}) )。

Safety-D1-0004

密码学应用

云数据安全/同态加密

近似算术的同态加密方案

CKKS (Cheon-Kim-Kim-Song) 方案

1. 基础框架：基于环LWE问题。在多项式环 Rq=Zq[X]/(XN+1)上操作，其中 N 是2的幂， q是大模数。 2. 密钥生成：私钥 sk=s∈Rq，公钥 pk=(−a⋅s+e,a)，其中 a 均匀随机取自 R_q， e 是小误差多项式。 3. 加密：明文 m是复数值向量，先编码为环 R上的多项式 π(m)。加密时，选择小随机多项式 u,e0,e1，计算密文 ct=(c0,c1)=(pk0⋅u+e0+Δ⋅π(m),pk1⋅u+e1)modq，其中 Δ是缩放因子。 4. 同态运算： – 加法：对应分量模q相加。 – 乘法：计算张量积然后重线性化，并伴随缩放因子的调整和模切换以控制噪声增长。近似计算： Dec(ctA⊙ctB)≈π(mA)⋅π(mB)+small error。 5. 参数选择： N (环维度，如2^15) 决定安全级别和槽数。模数链 {q0,q1,…,qL}用于支持深度为L的乘法。误差分布方差 σ 影响安全性。缩放因子 Δ 控制精度。

精度：计算结果是近似的，均方误差与初始噪声、乘法深度和参数选择有关。强度：基于环LWE问题的困难性，参数 (N, q, σ) 对应具体安全级别（如128位）。

格密码学，环LWE困难问题，多项式算术。

场景：隐私保护的云计算、数据分析、机器学习（在加密数据上训练/预测）。特征：支持定点数的加法和乘法，允许一定误差，效率优于完全同态加密（FHE）。

N：环维度， 2的幂。 q：模数，一个大整数。 R_q：多项式商环。 s, a, e, u：多项式，其中e， u为小系数多项式。 m：复数向量明文。 π( )：编码函数，将向量映射为多项式。 Δ：缩放因子（2^p）。 ct：密文，通常为多项式对。

代数：多项式环运算，模运算。概率与统计：误差分布（离散高斯分布）。计算与算法：快速傅里叶变换（NTT）用于加速多项式乘法。优化：参数优化以平衡安全、精度和效率。

1. 参数生成 (N, q_L, σ, Δ) -> 2. 密钥生成 (sk, pk, evk) -> 3. 客户端加密 (m -> π(m) -> ct) -> 4. 云端计算 (对ct执行加、乘、旋转等操作，使用evk并管理模数链) -> 5. 客户端解密 (ct‘ -> π(m‘) ≈ f(m) ) -> 6. 解码 (π(m‘) -> m‘)。核心运算方程：同态乘法后的重线性化： ctmult=(c0,c1,c2)通过evk转换为标准的两元素密文形式。

数据流：明文向量 -> 编码 -> 加密 -> 密文流 -> 同态运算（加/乘/旋转） -> 结果密文 -> 解密 -> 解码 -> 近似结果向量。噪声流：初始噪声 -> 加法运算线性增长 -> 乘法运算近似平方增长 -> 模切换降低噪声和模数。

硬件：需要高性能的大数模乘法和NTT加速器（ASIC/FPGA）。内存带宽要求高，用于传输大密文。软件：实现CKKS方案的库（如SEAL， HElib）。资源消耗大，密文膨胀严重（明文膨胀千倍以上），计算开销比明文高数个数量级。

Safety-D1-0005

系统安全

虚拟化/侧信道防御

时间噪声注入

确定性延迟与随机调度

1. 威胁建模：假设攻击者能高精度测量操作时间（如缓存命中/未命中，分支预测）来推断敏感数据。 2. 防御原理：向系统的时间行为注入噪声，使侧信道与敏感数据的相关性降低或消失。 3. 方法步骤： a. 识别关键操作：找到其执行时间依赖敏感数据d的操作O(d)。设其理想时间为 tbase(d)。 b. 注入噪声：在执行O(d)前后，引入一个随机延迟 Δ，使得观测时间 tobs=tbase(d)+Δ。 c. 噪声分布选择： Δ可以从均匀分布、高斯分布或拉普拉斯分布中采样。差分隐私理论中，拉普拉斯机制可提供严格隐私保证： (Pr[\\Delta = x] = \\frac{1}{2b} \\exp(-\\frac{

}{b}) )，其中尺度参数b与时间函数的全局敏感度 (GS = \\max_{d, d‘}

t{base}(d) – t{base}(d‘)

)相关， b=GS/ϵ， ε 为隐私预算。 d. 调度优化：除了加性噪声，还可以对共享资源（如CPU核心、缓存）的访问进行随机调度，增加攻击者观测的不确定性。

强度/误差： – 安全强度：用互信息 I(D;Tobs)衡量，目标使其趋近于0。在差分隐私框架下，强度由ε控制。 – 性能开销：平均引入的延迟 E[Δ]和尾部延迟。

信息论（降低互信息），差分隐私，排队论（随机调度）。

场景：保护云环境中跨VM的缓存侧信道、时序侧信道攻击。特征：是一种掩盖（Masking）技术而非消除（Elimination）技术，在安全和性能间权衡。

d：敏感数据。 O(d)：依赖于d的操作。 t_{base}(d)：无噪声下的操作时间。 Δ：注入的随机延迟。 b：拉普拉斯分布尺度参数。 ε：差分隐私预算。 GS：时间函数的全局敏感度。

编号

类别

领域

模型配方

定理/算法/模型/方法名称

定理/算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式和参数选择/参数优化

精度/密度/误差/强度

底层规律/理论定理

典型应用场景和各类特征

变量/常量/参数列表及说明

数学特征

时序和交互流程的所有细节/分步骤时序情况及数学方程式

流动模型和流向方法的数学描述

硬件设计/软件设计及资源

Safety-D1-0006

网络安全

密钥交换/后量子密码

基于格的密钥交换

FrodoKEM (简化模型)

1. 基础问题：基于学习有误问题。给定矩阵 A∈Zqn×n，和 B=AS+E，其中 S,E为小元素矩阵，从 (A, B) 恢复 S 是困难的。 2. 密钥生成： Alice 生成随机矩阵 A，私钥 (S, E)，计算公钥 B=AS+Emodq。 3. 封装： Bob 生成临时私钥 (S‘, E‘)，计算共享秘密 V=S‘TB+E‘’，并从 V 中提取密钥 K 和密文 C1=ATS‘+E‘’‘， C2为 K 的编码。发送 (C1, C2)。 4. 解封装： Alice 计算 W=C1TS，并从 W 和 C2 中恢复相同的 K。噪声 E 的设计使得 Alice 和 Bob 计算出的共享值相近，可通过纠错码对齐。

强度：参数集 (n, q, 误差分布χ) 对应 NIST 后量子密码标准的安全级别 (如 FrodoKEM-640 对应 L1: 128-bit 经典安全)。失败概率：因噪声导致双方恢复的密钥不一致的概率，需极低 (如 2^{-128})。

格理论，带误差学习问题。

场景： TLS 1.3 等协议中的后量子密钥交换，抵御量子计算机攻击。特征：保守安全假设、相对较大的公钥和密文尺寸。

A, B, C1: 在环 Zq上的矩阵。 S, E, S‘, E‘, …: 从小分布 χ (如离散高斯) 中采样的矩阵。 n: 矩阵维度 (如 640)。 q: 模数 (如 2^15)。 χ: 误差分布。

代数：矩阵运算 (模 q)。概率与统计：误差分布，失败概率计算。优化：参数 (n, q, χ) 的权衡 (安全、尺寸、效率)。

1. Alice 生成 (A, B) 作为公钥，保留 S。 2. Bob 选择临时私钥 (S‘, E‘)，计算 (C1, C2, K)。发送 (C1, C2)，保留 K。 3. Alice 接收 (C1, C2)，计算 W 并恢复出 K‘。如果成功， K‘ = K。核心方程： K≈Rec(S‘T(AS+E),C2)=Rec((ATS‘)TS+noise,C2)。

信息流：公钥参数 (A, B) -> Bob 临时密钥生成 -> 密文 (C1, C2) -> Alice 解密。双向流动的核心是噪声匹配，使得双方能计算出近似相等的共享值。

硬件：需要大矩阵乘法和模运算加速器。内存占用大 (公钥可达数十KB)。软件：实现矩阵运算、采样、编解码。计算密集型，但可并行化。

Safety-D1-0007

密码学应用

数据完整性/认证

消息认证码构造

HMAC (基于哈希的MAC)

1. 目标：使用密码散列函数 H (如 SHA-256) 和密钥 K 为消息 M 生成一个认证标签 T。 2. 填充与派生：将密钥 K 填充/哈希至散列函数的块大小 B 字节。定义内填充 ipad = 0x36 重复 B 次，外填充 opad = 0x5C 重复 B 次。 3. 计算步骤： a. Si=K⊕ipad b. H1=H(Si∥M) c. So=K⊕opad d. T=H(So∥H1) 4. 输出： T 即为消息认证码。

强度：与底层哈希函数 H 的抗碰撞性和抗第二原像能力相关。理想情况下，伪造成功概率为 1/2n(n 为输出长度)。长度：输出长度与哈希函数输出相同 (如 256-bit)。

Merkle–Damgård 结构或海绵结构的嵌套密钥哈希。安全性可规约到哈希函数的抗碰撞性。

场景：网络协议 (IPsec, TLS)、 API 请求签名、数据完整性校验。特征：计算高效、标准化的、与现有哈希函数库兼容。

K: 密钥 (建议长度 >= H 的输出长度)。 M: 输入消息。 H: 密码散列函数 (如 SHA-256)。 B: H 的输入块大小 (字节)。 ipad, opad: 固定的字节常量。 T: 消息认证码 (标签)。

逻辑与构造：确定性算法，基于逻辑步骤构造。计算特征：调用了两次哈希压缩函数。

1. 准备密钥：对 K 进行适当填充或哈希，使其长度为 B。 2. 计算内部哈希： inner=H((K⊕ipad)∥M)。 3. 计算外部哈希： T=HMAC(K,M)=H((K⊕opad)∥inner)。方程式：如上所示。

数据流向：密钥 K 与 ipad 异或后，拼接消息 M，进行第一次哈希；结果再与用 opad 处理后的密钥拼接，进行第二次哈希。是两层哈希的串联结构。

硬件：可使用已有的哈希函数 (如 SHA256) 硬件加速器。软件：实现简单，资源消耗与哈希两次消息类似。

Safety-D1-0008

系统安全

访问控制/可信计算

远程证明与属性声明

DAA (直接匿名证明)

1. 参与者：平台 (TPM)、发行方 (Issuer)、验证方 (Verifier)。 2. 加入协议：平台向发行方证明其拥有有效的 TPM 背书密钥 (EK) 和可信配置，并获得一个由发行方签名的凭证 (Credential)，该凭证关联于一个伪名 (假名) 密钥 f。 3. 签名/证明协议：平台使用其私钥和凭证，对某个消息 m (或验证方挑战) 生成签名 σ。该签名可被验证方用发行方公钥验证，且： a. 匿名性：来自同一平台的多次签名不可关联。 b. 可追溯性：如果平台私钥被泄露用于作恶，发行方可打开签名揭露平台身份。 4. 数学模型：基于群签名和零知识证明。使用双线性对 e:G1×G2→GT。证明方生成一个承诺和知识签名 (SPK)，证明其拥有满足特定关系的私钥和凭证，而不泄露它们。

强度：依赖于离散对数/双线性对问题的困难性。提供计算安全的匿名性和可追溯性。匿名性：在计算不可区分性下，签名对验证方是匿名的。

群签名理论、零知识证明、双线性对密码学。

场景：远程平台完整性证明 (如 TPM)、匿名认证 (如车辆网)、隐私保护的会员服务。特征：强隐私保护 (对验证方匿名)、可控的追溯机制。

EK, AK: 平台背书密钥和证明密钥。 f: 平台的私密假名。 Cred: 发行方颁发的凭证 (对 f 的盲签名)。 σ: 对消息 m 的 DAA 签名。 e: 双线性映射。 SPK: 知识的签名证明。

代数：群运算、双线性对。逻辑：零知识证明的逻辑表述。概率：随机化确保不可关联性。

1. 平台加入：平台与发行方运行一个交互式协议，平台证明其持有有效 EK，并获得一个盲化的凭证 Cred = Sign_Issuer(f)。 2. 平台签名：对消息 m，平台生成： σ = (SPK{(f, Cred): Verify(Cred, f)=1 ∧ Sign(f, m)})(m)。 3. 验证：验证方用发行方公钥验证 SPK 的有效性，并可选择性地检查平台是否在黑名单中 (基于 f 的衍生值)。

信息流包含两条主路径： 1. 平台 -> 发行方 (获取凭证)。 2. 平台 -> 验证方 (匿名证明)。凭证的颁发和签名的生成是分离的，验证方只需与平台交互。

硬件：需要 TPM 或安全芯片保护私钥 f 和 EK。软件：实现复杂的零知识证明协议和双线性对运算，计算和通信开销较高。

Safety-D1-0009

网络安全

入侵检测/异常检测

基于信息论的检测

连接熵检测 (Destination Port Entropy)

1. 模型基础：在时间窗口 t 内，观测到网络流向目标端口 p_i 的流量计数为 c_i。目标端口分布的变化可以反映扫描或攻击行为。 2. 计算熵值：首先计算目标端口分布的概率质量函数： P(pi)=ci/∑jcj。然后计算香农熵： Ht(P)=−∑iP(pi)log2P(pi)。 3. 检测逻辑：正常服务流量 (如 Web) 通常集中在少数端口 (如 80, 443)，熵值较低。端口扫描或蠕虫传播会连接大量随机端口，导致熵值显著升高。设置阈值 Hth，当 Ht>Hth时触发警报。 4. 参数选择：时间窗口 t (如 5 分钟)。阈值 Hth需通过基线学习或经验设定。可使用滑动窗口计算熵的时间序列。

精度/误差：用检测率 (TPR) 和误报率 (FPR) 衡量。阈值 Hth调节二者平衡。密度：对高频度扫描敏感，对慢速扫描可能漏报。

信息论，香农熵。熵反映了随机变量的不确定性。

场景：检测网络内部的水平扫描、蠕虫爆发、异常外联。特征：无监督、计算轻量、对已知和未知扫描都有效，但需确定合适阈值。

t: 时间窗口长度。 c_i: 在窗口 t 内流向目标端口 i 的连接数/报文数。 P: 目标端口的经验概率分布。 H_t: 在窗口 t 内计算得到的端口熵值。 H_{th}: 告警阈值。

概率与统计：经验概率分布计算。信息论：香农熵。时序分析：滑动窗口下的时间序列。

1. 数据收集：在时间窗口 t 内，统计所有流的目的端口计数 {c_i}。 2. 分布计算：对每个端口 i，计算 pi=ci/∑cj。 3. 熵计算： H=−∑ipilog2(pi)(定义 0 log 0 = 0)。 4. 决策： if H>Hth: raise_alert(“可能的端口扫描”)。时序方程： H[t]=f({ci(t−Δ,t]})。

数据流：网络报文 -> 按目的端口聚合计数 -> 计算概率分布 -> 计算熵值 -> 与阈值比较 -> 告警事件流。熵值是一个随时间变化的标量信号。

硬件：可在网络处理器或 FPGA 上实现高速流统计。软件：轻量级算法，适合在 IDS 传感器或 SDN 控制器中实时运行。需要存储一个端口计数表。

Safety-D1-0010

系统安全

软件安全/模糊测试

覆盖率引导的进化算法

美国模糊 lop (AFL) 遗传算法

1. 种子输入：初始输入语料库 (seed corpus)。 2. 遗传变异：对输入队列中的每个输入文件，进行确定性变异 (位翻转、算术加减、块插入等) 和随机性变异。 3. 执行与反馈：将变异后的输入喂给目标程序，并监控其执行路径。使用轻量级插桩记录分支 (edge) 的覆盖情况。定义“新路径”为发现了新的分支转移对 (src->dst)。 4. 进化选择：如果一次变异产生了新的路径，则该变异输入被保留，加入输入队列，作为后续变异的“父本”。这引导搜索向未覆盖的代码区域探索。 5. 能量调度：为每个种子分配“能量”，即对其进行的变异次数。能量分配策略可以是均匀的，或基于种子发现新路径的速度、输入大小等启发式调整。

密度/强度：用代码覆盖率 (分支覆盖率) 衡量。目标是最大化覆盖。误差：可能存在路径爆炸，无法在有限时间内覆盖所有路径。可能产生误报 (崩溃不一定是安全漏洞)。

遗传算法、进化计算。将程序输入视为“个体”，代码覆盖率作为“适应度”，通过变异和选择进行进化搜索。

场景：自动化的漏洞挖掘，特别是内存破坏类漏洞 (栈溢出、释放后重用等)。特征：黑盒/灰盒、无需源代码 (可二进制插桩)、定向进化、高效。

I: 输入字节序列。 Q: 输入队列 (语料库)。 E: 分配给一个种子的变异能量。 C: 覆盖位图，记录已见的分支对。 f(I): 目标程序。 crash: 程序是否异常崩溃。

集合：输入队列、覆盖集合。随机性：变异操作的随机性。优化：在输入空间中进行启发式搜索以最大化覆盖。

while (时间未用完且未达到覆盖目标): 1. 从队列 Q 中选出一个种子 S。 2. 根据能量调度算法决定对 S 的变异次数 E。 3. for i in 1 to E: a. 对 S 应用随机变异操作，生成 S‘。 b. 执行 f(S‘)，记录覆盖位图 C‘ 和是否崩溃。 c. if C‘ 包含 Q 中未见的新分支: 将 S‘ 加入 Q。 d. if f(S‘) 崩溃: 记录 S‘ 到崩溃列表。

控制流是一个进化循环。数据流：种子 -> 变异器 -> 目标程序 -> 覆盖率反馈 -> 选择器 -> 新种子加入队列。流向由覆盖率引导，向能产生新覆盖的方向流动。

硬件：对 CPU 性能要求高，需要并行运行多个模糊测试实例 (并行化)。软件： AFL 及其衍生工具。需要对目标程序进行插桩以获得覆盖率反馈。资源消耗与目标程序复杂度和运行速度正相关。

Safety-D1-0011

密码学应用

量子安全/密钥分发

量子力学原理的密钥交换

BB84 量子密钥分发协议

1. 编码： Alice 随机生成两个长度为 n 的二进制序列：比特串 (表示 0 或 1) 和基串 (表示测量基，如 “+” 基对应 {

0>,

1>}， “×” 基对应 {

+>,

->})。她根据比特和基，制备相应的量子态 (单光子偏振态) 发送给 Bob。 2. 测量： Bob 随机选择测量基对每个光子进行测量，得到自己的比特串和基串。 3. 基比对：通过经典信道公开比较基串 (不透露比特值)。双方丢弃那些测量基不一致的比特位。剩下约 n/2 位构成原始密钥。 4. 错误估计与纠错：双方公开比较一部分原始密钥的比特值，估算误码率 e。如果 e 低于阈值 (如 11%)，则进行信息协商 (如 Cascade 协议) 纠错，得到一致密钥。 5. 隐私放大：利用公开的随机哈希函数，从纠错后的密钥中提取更短的最终密钥，以消除窃听者 Eve 可能获得的部分信息。最终密钥长度 ≈ n * (1 – 2h(e))，其中 h(e) 是二进制熵函数。

安全性：基于量子不可克隆定理和海森堡测不准原理，任何窃听行为都会引入可检测的错误。误码率阈值：对光子数分离攻击，阈值约为 12.4% (BB84)。密钥率：单位时间生成的最终密钥比特数，受距离、光子源、探测器效率限制。

量子力学基本原理、信息论。

场景：高安全等级通信的密钥分发，如政务、金融骨干网。特征：信息论安全 (而非计算安全)、对未来的量子计算机免疫、距离受限 (数百公里)。

n: 初始发送的量子态数量。 a_i, b_i: Alice 和 Bob 的比特值。 α_i, β_i: Alice 和 Bob 选择的基。 e: 量子信道的误码率。 h(e): 二进制香农熵， h(e)=−elog2(e)−(1−e)log2(1−e)。 K: 最终的安全密钥。

Safety-D1-0012

网络安全

流量分析/匿名通信

低延迟匿名网络模型

洋葱路由 (Tor) 电路建立

1. 目录与共识：客户端从目录服务器获取 Tor 中继列表和共识，包含各中继的公钥、地址、带宽权重等。 2. 电路建立 (Telescoping)：客户端为建立一条 3-hop 电路： a. 选择守卫节点 G，用其公钥 PK_G 加密一个“创建”单元，建立到 G 的 TLS 连接，并协商一个临时密钥 K1。 b. 通过 G 的加密链路，选择中间节点 M，发送用 PK_M 加密的“扩展”单元，其中包含用 K1 加密的临时信息，与 M 协商出密钥 K2。 c. 通过 G 和 M 的加密链路，选择出口节点 E，同理协商出密钥 K3。 d. 此时，客户端与每个中继共享一个对称密钥 (K1, K2, K3)。 3. 分层加解密：发送数据时，客户端用 K3, K2, K1 依次加密数据，像包洋葱。数据经过 E 时解密最外层 (用 K3)，经过 M 时解密中间层 (用 K2)，经过 G 时解密最内层 (用 K1) 得到原始数据转发到目标服务器。每个中继只知道其前驱和后继。

匿名性强度：在部分敌手模型下 (非全球被动敌手)，提供不可关联性 (发送者与接收者不可关联)。延迟：引入 3 跳的额外路由延迟，通常数百毫秒。

混合网络、分层加密、电路交换。

场景：互联网匿名访问、规避审查、保护通信元数据。特征：低延迟 (相对于 Mixnet)、分布式、流量特征可能被主动攻击分析。

G, M, E: 守卫、中间、出口中继。 PK_i: 中继 i 的长期公钥。 K_i: 客户端与中继 i 协商的临时会话密钥。 Cell: Tor 网络传输的基本单元 (512 字节)。 DATA: 应用层数据。

图论：网络拓扑，路径选择算法。密码学：非对称加密 (建立连接)、对称加密 (数据传输)。概率：中继的随机选择 (带宽加权)。

1. 客户端 -> G: Send(Enc_PK_G(“CREATE”, g^x))。 Receive(Enc_PK_client(g^y, hash(K1)))。计算 K1 = g^{xy}。 2. 客户端 (通过G) -> M: Send(Enc_K1(Relay) “EXTEND”， Enc_PK_M(g^x‘))。 Receive(Enc_K1(Relay) “EXTENDED”， Enc_PK_client(g^y‘))。计算 K2。 3. 客户端 (通过G, M) -> E: 类似步骤 2，计算 K3。 4. 数据传输: C 发送: Enc_K1( Enc_K2( Enc_K3(DATA) ) )。 G 解密外层后转发给 M: Enc_K2( Enc_K3(DATA) )。依此类推。

数据流是单向的洋葱式管道。控制流 (电路建立) 是嵌套的、顺序的协商过程。密钥协商流嵌套在已建立的加密链路中。数据包流动时，在每个中继被剥去一层加密。

硬件：中继需要足够的网络带宽和 CPU 进行加解密。软件： Tor 守护进程，实现协议栈 (TLS, 电路管理, 流管理)。客户端资源消耗低，中继资源消耗高 (带宽和连接数)。

Safety-D1-0013

系统安全

可信执行环境

内存隔离与证明模型

Intel SGX 飞地认证与数据密封

1. 飞地创建：应用程序创建一块受保护的飞地，其初始代码和数据在加载时被度量，度量值 (MRENCLAVE) 是代码/数据的密码学哈希承诺。 2. 本地证明：飞地可生成一个报告 (REPORT)，包含 MRENCLAVE、飞地内数据 (如公钥) 和由处理器密钥派生的消息认证码 (MAC)。另一个本地飞地 (Quoting Enclave) 可验证此 REPORT 并转换为可验证的引证 (QUOTE)。 3. 远程证明： QUOTE 被发送到远程验证方。验证方通过 Intel 的证明服务 (IAS) 验证 QUOTE 的签名 (使用 Intel 的根密钥)，从而确信飞地在真正的 SGX 处理器上以特定代码 (MRENCLAVE) 运行。 4. 数据密封：飞地可以使用一个与平台和飞地身份绑定的密钥密封数据。密封密钥从处理器内置的密钥和飞地的度量值 (MRSIGNER 或 MRENCLAVE) 派生。数据只能在相同的飞地 (或同一开发者签名的飞地) 在相同平台上解封。

完整性：飞地内存受到内存加密引擎 (MEE) 和完整性树保护，防止物理和软件攻击。认证强度：依赖于 Intel 的根证书和处理器密钥的安全。

硬件强制隔离、密码学度量、基于身份的加密。

场景：云中隐私计算 (在不可信 OS 上运行敏感代码)、数字版权管理、密钥保护。特征：硬件级隔离、远程可验证、依赖硬件厂商 (Intel) 作为根信任点。

MRENCLAVE: 飞地初始内容的 SHA-256 哈希度量值。 MRSIGNER: 飞地开发者的公钥哈希。 REPORT: 包含 MRENCLAVE 和用户数据的结构，用本地对称密钥认证。 QUOTE: 由 Quoting Enclave 签名的 REPORT，证明其来源。 Seal Key: 从 CPU 秘密和飞地身份派生的密钥。

密码学：哈希函数、消息认证码、数字签名、密钥派生。逻辑：证明的逻辑链条 (飞地 -> CPU -> Intel -> 验证方)。

1. 飞地启动：加载代码/数据 -> 计算 MRENCLAVE -> 初始化飞地。 2. 生成报告：飞地调用 EREPORT 指令，生成针对目标飞地 (如 QE) 的 REPORT。 3. 生成引证：本地 QE 验证 REPORT MAC，并用自己的私钥 (由 Intel 背书) 签发 QUOTE。 4. 远程验证：验证方接收 QUOTE -> 向 IAS 请求验证 -> IAS 验证 Intel 签名并返回证明结果。 5. 安全会话：验证成功后，验证方与飞地建立安全信道交换数据。

信任流从硬件根开始，经过多级证明，传递到远程验证方。数据流：飞地敏感数据 <-(密封/解封)-> 非易失存储。密钥派生的流向是确定性的，从 CPU 固植密钥和飞地身份流向密封密钥。

硬件： CPU 必须支持 SGX，包含内存加密引擎、完整性树、受保护的密钥存储和密码学指令。软件： SGX SDK，飞地开发框架。开发者需将敏感代码分区到飞地中，存在内存限制 (Enclave Page Cache)。

Safety-D1-0014

应用安全

Web安全/浏览器模型

同源策略与跨域安全

同源策略 (SOP) 和 CORS 检查

1. 同源定义：两个 URL 的协议、主机、端口完全相同，则同源。源定义为三元组 (scheme, host, port)。 2. SOP 默认行为：浏览器禁止来自源 A 的脚本访问源 B 的 DOM、 Cookie、 LocalStorage 或发起跨域 XMLHttpRequest (AJAX) 请求。 3. CORS 机制：允许服务器声明哪些其他源可以访问其资源。对于“非简单请求”，浏览器会先发送一个预检请求 (OPTIONS 方法)。 a. 预检请求：浏览器发送带有 Origin, Access-Control-Request-Method, Access-Control-Request-Headers的 OPTIONS 请求。 b. 服务器响应：服务器响应头中应包含 Access-Control-Allow-Origin(允许的源，或 ‘’)， Access-Control-Allow-Methods, Access-Control-Allow-Headers。 c. 实际请求：如果预检通过，浏览器发送实际请求，并检查响应头中的 Access-Control-Allow-Origin是否匹配当前源。 4. 凭证请求：若要携带 Cookie 等凭证，客户端需设置 withCredentials: true，服务器需响应 Access-Control-Allow-Credentials: true且 Access-Control-Allow-Origin不能为 ‘‘，必须是具体源。

安全性：是 Web 安全的基石，防止恶意网站窃取用户在其他站点的数据。配置错误会导致 SOP 绕过。粒度：以源为最小隔离单位。

访问控制模型，基于来源的隔离原则。

场景：所有现代 Web 浏览器，保护用户会话和数据不被恶意网站窃取。特征：浏览器强制执行、透明对用户、服务器可控的放松策略 (CORS)。

Origin: 请求来源，字符串，格式为 scheme://host:port。 A_O, A_M, A_H: 服务器在响应头中声明的允许的源、方法、头部。 Request_Method: 实际请求的方法 (如 POST)。 Request_Headers: 实际请求的自定义头部列表。

集合与逻辑：源的定义和比较。条件判断逻辑 (包含、匹配)。规则系统：一系列条件判断规则。

简单请求： 1. 浏览器发送实际请求，头中包含 Origin: https://a.com。 2. 服务器响应，头中包含 Access-Control-Allow-Origin: https://a.com(或 )。 3. 浏览器检查响应头中的值是否包含当前源。是则放行，否则阻止。非简单请求 (预检)*： 1. 浏览器发送 OPTIONS 预检请求。 2. 服务器响应预检，声明允许的 A_O, A_M, A_H。 3. 浏览器检查：如果当前 Origin 在 A_O 中，且 Request_Method 在 A_M 中，且 Request_Headers 是 A_H 的子集，则继续；否则阻断。 4. 预检通过后，发送实际请求，再次检查 A_O。

信息流是双向的请求-响应。控制流：在浏览器发起跨域请求时，插入 SOP 检查逻辑。如果请求是“非简单”的，控制流会分支，先发送一个预检请求，根据其响应决定是否继续发送实际请求。

硬件：无特殊要求。软件：在浏览器内核 (如 Blink, Gecko) 的网络栈和 JavaScript 引擎中实现。对开发者透明，但需要后端服务器正确配置 CORS 头。

Safety-D1-0015

网络安全

防火墙/策略验证

策略冲突检测与优化

防火墙策略分析与最小化

1. 策略表示：将防火墙规则表建模为有序列表 R=[r1,r2,…,rn]。每条规则 ri=(predicatei,decisioni)，其中谓词 predicatei是定义在报文头字段 (如 src_ip, dst_ip, src_port, dst_port, protocol) 上的匹配条件，通常表示为区间或集合。 decision_i 是动作 (允许/拒绝)。 2. 冲突检测：规则 ri和 rj(i < j) 存在冲突，如果： a. 它们的谓词交集非空： Pi∩Pj=∅。 b. 它们的动作不同： decisioni=decisionj。则对于匹配 Pi∩Pj的报文，会命中 ri而被 rj遮蔽。 3. 策略最小化：目标是在保持语义不变的情况下，减少规则数量。算法 (如 FDD – 防火墙决策图)： a. 将规则列表转换为等价的无冲突决策图 (FDD)，这是一个二叉树，节点是字段测试，边是区间，叶节点是动作。 b. 对 FDD 进行合并和化简 (如合并相同子树的节点)。 c. 将化简后的 FDD 转换回最优的规则列表。

精度：分析结果是精确的，基于规则语义。优化目标：最小化规则数量，提高匹配效率。

集合论 (规则谓词是字段空间的子集)、区间代数、决策树优化。

场景：企业网络防火墙、云安全组策略的管理和优化。特征：静态分析、可发现规则冗余、阴影、泛化等异常，并优化策略性能。

R: 有序规则列表。 r_i: 第 i 条规则。 P_i: 规则 r_i 的谓词，定义为报文头空间 D 的一个子集。 decision_i: 动作， ∈ {允许，拒绝}。 FDD: 防火墙决策图，一个有向无环图。

集合：规则匹配域的并、交、差、包含关系。逻辑：规则顺序的逻辑蕴含。图论：决策图的构造和遍历。优化：图结构的化简。

1. 冲突检测算法： for i in 1 to n: for j in i+1 to n: if Pi∩Pj=∅and decision_i != decision_j: report conflict(r_i, r_j, Pi∩Pj)。 2. FDD 构建与最小化： a. 创建根节点，对应第一个字段 (如 src_ip)。 b. 根据规则集中该字段的区间，划分子节点。 c. 递归地对每个子节点，用剩余字段和过滤后的规则集构建子树。 d. 合并所有具有相同结构的子树。 e. 深度优先遍历 FDD，将每条从根到叶子的路径转换为一条规则。

分析是静态的，无运行时序。数据流是规则列表 -> 内部表示 (如区间集) -> 分析结果 (冲突报告) 或优化表示 (FDD) -> 最小化规则列表。是一个转换和化简的流程。

硬件：通常在管理服务器上离线运行。软件：策略分析工具。计算复杂度与规则数量和字段维度有关，最坏情况是指数级，但对实际策略通常可管理。

Safety-D1-0016

密码学应用

区块链/共识安全

中本聪共识与最长链规则

比特币工作量证明 (PoW) 与孤儿块率

1. 区块生成：矿工收集交易，构建区块头，包含前一个区块的哈希 (prev_hash)、默克尔根 (merkle_root)、时间戳、难度目标 (bits) 和一个随机数 (nonce)。目标是找到一个 nonce，使得区块头的双 SHA-256 哈希值小于目标阈值 T： SHA256(SHA256(BlockHeader))<T。 2. 难度调整：每产生 2016 个区块 (约两周)，根据实际产生时间与期望时间 (2016 * 10 分钟) 的比值调整难度目标 T，以维持平均 10 分钟出块时间。 3. 分叉与共识：当两个矿工几乎同时找到有效区块时，会产生临时分叉。节点总是选择在其所见的最长链 (累计工作量最大的链) 后继续挖矿。设主链高度为 H，计算量为 C。一个竞争分支要成为主链，需要其计算量 C‘ > C。在泊松过程中，一个落后 k 个区块的分支追上主链的概率随 k 指数下降。通常 6 次确认后认为交易不可逆。 4. 孤儿块率：区块在网络中传播需要时间 Δ。在时间 Δ 内，其他矿工找到新区块的概率约为 p=1−e−λΔ，其中 λ 是全网出块速率 (1/600 秒)。这导致了孤儿块 (在分叉中被抛弃的块) 的产生。降低 Δ (如通过中继网络) 可减少孤儿率。

安全性 (抗双花)：假设诚实节点控制大部分算力，攻击者要改写历史需要拥有超过 50% 的全网算力 (51% 攻击)。最终性：是概率最终性。 k 个确认后，回滚概率约为 (pq)k(攻击者算力占比 q，诚实者 p)。

概率论 (泊松过程)、博弈论 (纳什均衡)、密码学哈希函数。

场景：比特币、以太坊 (当前) 等公有链的共识机制。特征：去中心化、高能耗、概率最终性、吞吐量低。

T: 难度目标，一个 256-bit 数。 H: 区块头。 nonce: 32-bit 随机数。 λ: 全网平均出块速率 (0.1 个/分钟)。 Δ: 区块全网传播时间。 p, q: 诚实和恶意节点的算力占比 (p+q=1)。 k: 确认数。

概率与统计：泊松过程、指数分布。优化：矿工在期望收益最大化下的策略选择。博弈论：矿工间的竞争与合作博弈。

1. 挖矿循环：矿工不断变更 nonce (或 extraNonce) -> 计算 H‘ = SHA256(SHA256(Header)) -> 与 T 比较 -> 若 H‘ >= T，重复。 2. 出块与广播：若找到 H‘ < T，立即广播新区块给邻居节点。 3. 链选择：节点收到新区块后，验证其有效性，并更新本地链为累计工作量最大的链。 4. 难度调整周期：每 2016 块，计算新难度 Tnew=Told∗ExpectedTimeActualTime。

信息流是区块和交易的洪泛广播。工作量 (算力) 的流动决定了链的增长率。共识的形成是一个随时间推移，所有节点对“最长链”视图逐渐收敛的随机过程。孤儿块是网络延迟导致的短暂“支流”，最终被主链“淹没”。

硬件：矿工使用 ASIC 进行高速哈希运算，耗能巨大。全节点需要存储整个区块链。软件：比特币核心客户端，实现 P2P 网络、共识逻辑、交易验证等。

Safety-D1-0017

系统安全

漏洞利用/内存安全

堆内存元数据攻击

The House of Force 堆溢出利用技术

1. 目标：通过堆溢出覆盖 top chunk 的 size 字段，从而控制后续 malloc 的分配位置，实现任意地址写。 2. 堆布局： glibc malloc 管理堆块，其中“wilderness”或“top chunk”是堆顶的剩余空间。 top chunk 的头部有一个 size 字段。 3. 攻击步骤： a. 通过溢出漏洞，覆盖 top chunk 的 size 字段为一个非常大的值 (如 0xffffffff)。 b. 然后申请一块巨大的内存 (size_attack)。 malloc 在分割 top chunk 时，计算新的 top chunk 地址为： new_top = old_top + size_attack。 c. 精心计算 size_attack，使得 new_top 正好指向目标地址 (如 GOT 表、 hook 函数指针) 减去 chunk 头大小。 d. 下次 malloc 返回的指针将指向目标地址附近，随后写入的数据将覆盖目标地址处的内存 (如函数指针)，劫持控制流。 4. 数学计算：设目标地址为 target_addr， chunk 头大小为 hdr_sz (如 8 字节)。则需要： new_top = target_addr – hdr_sz。而 new_top = old_top + aligned_size_attack，其中 aligned_size_attack 是请求大小加上对齐开销。因此， size_attack = (target_addr – hdr_sz – old_top) & ~(对齐-1)。需要使 size_attack 为正值且小于被覆盖的巨大 size。

强度/约束：需要能够溢出到 top chunk 并覆盖其 size。目标地址需要高于堆的当前地址 (即 target_addr > old_top)。现代 glibc 对 top chunk size 增加了完整性检查，此技术已基本失效。

堆管理器的内部实现逻辑 (如 glibc ptmalloc)。利用算术操作和指针计算中的不检查溢出漏洞。

场景：针对旧版本 glibc (缺乏完整性检查) 的堆溢出漏洞利用。特征：一种“通杀”型利用原语，可导致任意地址写，但条件较苛刻。

old_top: 当前 top chunk 的地址。 top_size: 被覆盖后的 top chunk 的 size 字段值。 size_attack: 攻击者请求分配的大小。 aligned_size: 经过对齐调整后实际从 top chunk 分割的大小。 target_addr: 攻击者希望控制的最终目标地址。 hdr_sz: malloc chunk 头部大小。

算术：指针算术，整数溢出/回绕。构造：精确计算请求大小以达到目标地址。

1. 触发溢出：修改紧邻 top chunk 的堆块数据，溢出覆盖 top_size 为极大值 (如 -1)。 2. 请求巨大分配：调用 malloc(size_attack)，其中 size_attack 根据公式计算得出。 3. 堆管理器计算： malloc 内部计算: chunk_ptr = old_top; new_top = chunk_ptr + aligned_size_attack; 由于 top_size 极大，检查通过。 4. 返回恶意指针： malloc 返回 ptr = chunk_ptr + hdr_sz，其指向 target_addr。 5. 写目标地址：通过 ptr 写入数据，覆盖 target_addr 处的关键数据。

攻击流是线性的：溢出修改元数据 -> 触发分配计算 -> 返回指向目标地址的指针 -> 写入 -> 控制流劫持。数据流从攻击者控制的缓冲区流向 top chunk 元数据，再通过堆管理器的内部指针计算逻辑，流向任意目标地址。

硬件：无特殊需求。软件：依赖特定的 glibc 版本 (旧版) 和堆布局。利用代码需精确计算 offsets。现代 mitigations (如 top chunk 完整性检查) 可防御。

Safety-D1-0018

应用安全

Web安全/输入过滤

服务器端模板注入攻击与沙箱逃逸

模板引擎代码执行 (以 Jinja2 为例)

1. 漏洞产生：当用户输入被直接拼接到模板字符串中，然后被模板引擎渲染时，如果输入包含模板语法，则会被执行。例如，服务端代码: template = “Hello ” + username + “!“; render(template)。如果 username 为 {{7 * 7}}，渲染结果将为 “Hello 49!”。 2. 攻击载荷：在 SSTI 中，攻击者目标是执行任意代码。在 Jinja2 中，可通过访问内置对象和类层次结构实现： a. 寻找基类对象： {{‘‘.__class__}}返回字符串类。 b. 遍历继承链： {{‘‘.__class__.__base__}}或 {{‘‘.__class__.__mro__}}找到 object 类。 c. 获取子类列表： {{‘‘.__class__.__base__.__subclasses__()}}返回所有子类。 d. 定位危险类：在子类列表中寻找可被利用的类，如 subprocess.Popen、 os._wrap_close等。 e. 调用危险方法： {{‘‘.__class__.__base__.__subclasses__()[N].__init__.__globals__[‘os‘].popen(‘id‘).read()}}，其中 N 是目标子类的索引。 3. 沙箱逃逸：模板引擎的沙箱试图限制访问危险函数和属性，但通过对象图遍历 (如 __class__, __globals__) 可能绕过。

严重性：可导致远程代码执行，危害等同于代码注入。探测：通过注入简单表达式如 {{7*‘7‘}}观察输出是否为 “7777777” 来判断。

编程语言反射、对象模型、沙箱隔离原理。

场景：使用模板引擎 (Jinja2, Twig, Freemarker) 的 Web 应用，如 Flask, Django。特征：漏洞源于不安全的用户输入拼接，而非模板引擎自身漏洞。利用依赖于模板语言的功能和沙箱强度。

payload: 攻击者控制的输入字符串，包含模板语法。 {{ … }}: 模板引擎的表达式分隔符。 class 等: Python 的魔术属性，用于内省。 N: 目标子类在列表中的索引。

构造：通过有限的初始对象 (如空字符串) 构造出访问任意函数的能力。图论：对象之间的引用关系构成一个有向图，攻击者寻找从已知对象到危险函数的路径。

1. 探测：发送包含 {{7 * 7}}的输入，观察输出是否为 “49”。 2. 信息收集：注入 {{‘‘.__class__}}等获取对象信息。 3. 寻找利用链：通过遍历 __subclasses__()列表，找到可利用的类 (如 Popen)。可能需要多次尝试索引 N。 4. 执行命令：构造最终的 payload，调用 popen(‘whoami‘).read()并读取输出。 5. 结果提取：命令执行结果会被嵌入到渲染后的模板输出中。

数据流：攻击者输入 -> 被拼接到模板字符串 -> 模板引擎解析字符串 -> 识别模板语法 -> 执行表达式 -> 表达式访问 Python 对象 -> 触发危险函数调用 -> 结果返回并嵌入输出 -> 返回给攻击者。是一个从数据到代码执行的流。

硬件：无。软件：漏洞存在于 Web 应用代码中。防御需严格将用户输入与模板代码分离，如使用上下文变量传递而非拼接。模板引擎可配置沙箱模式，但可能被绕过。

Safety-D1-0019

密码学应用

安全多方计算

隐私保护集合交集

PSI-Cardinality (基于 Diffie-Hellman)

1. 目标：两方 Alice 和 Bob 各自拥有一个集合，希望计算交集的大小，而不泄露集合的具体元素。 2. 基于 DH 的协议： a. 双方协商一个循环群 G 和生成元 g。 b. Alice 有集合 A={a1,…,am}， Bob 有集合 B={b1,…,bn}。 c. Alice 生成私钥 x←Zp∗，为每个元素计算 hi=H(ai)x，其中 H 是哈希到 G 的函数。将集合 HA={h1,…,hm}发送给 Bob。 d. Bob 生成私钥 y←Zp∗，为每个元素计算：对收到的每个 hi，计算 ki=hiy=H(ai)xy。对他自己的每个元素 bj，计算 tj=H(bj)y。他将集合 TB={t1,…,tn}发送给 Alice。 e. Alice 收到 TB后，对每个 tj计算 sj=tjx=H(bj)xy。 f. 现在， Alice 拥有集合 SA={H(ai)xy}， Bob 拥有集合 KB={H(ai)xy}(来自 Alice 集的转换) 和 TB={H(bj)y}。注意，当且仅当 ai=bj时， H(ai)xy=H(bj)xy。 g. 为了计算交集大小， Bob 可以计算 (

K_B \\cap {H(b_j)^{xy}}

)，但这需要 Alice 发送 SA给他。为了不泄露更多信息，他们可以使用不经意伪随机函数进一步处理。一种简化是： Bob 将 KB发送给 Alice， Alice 计算 (

S_A \\cap K_B

)即为交集大小。但这会泄露交集元素的哈希值给 Alice。更复杂的协议可以避免此问题。

安全性：在半诚实模型下安全，基于 DDH 假设。双方只得知交集大小，不知具体元素。通信复杂度： O(m+n)。

Diffie-Hellman 密钥交换、哈希函数、不经意伪随机函数。

场景：隐私匹配 (如发现共同联系人而不泄露通讯录)、联合数据分析的初步阶段。特征：保护集合隐私，但可能泄露集合大小。计算和通信开销高于明文计算。

G, g, p: 循环群参数。 A, B: 参与方的私有集合。 H: 哈希函数，映射到群 G。 x, y: Alice 和 Bob 的临时私钥。 h_i, t_j: 盲化后的集合元素。

Safety-D1-0020

网络安全

威胁检测/机器学习

异常检测模型

一类支持向量机 (One-Class SVM)

1. 问题定义：给定一组正常样本 {xi}⊂X，学习一个函数 f，使得对正常数据 f(x) >= 0，对异常数据 f(x) < 0。 2. 核心思想：在特征空间中找到一个小球，包含尽可能多的正常数据点。这转化为优化问题：最小化 R2+νn1∑iξi 约束： ∥Φ(xi)−a∥2≤R2+ξi,ξi≥0 其中 a 是球心， R 是半径， Φ是将数据映射到高维特征空间的核函数， ξi是松弛变量， ν∈(0,1]控制异常点比例上限和支持向量的比例。 3. 对偶问题：引入拉格朗日乘子，得到对偶问题，其解只依赖于样本间的内积 K(xi,xj)=⟨Φ(xi),Φ(xj)⟩(核函数)。决策函数为： f(x)=R2−∑i,jαiαjK(xi,xj)+2∑iαiK(xi,x)−K(x,x)，其中 αi是拉格朗日乘子。如果 f(x) >= 0，则 x 被接受为正常。 4. 参数选择：核函数通常选择高斯核 K(xi,xj)=exp(−γ∥xi−xj∥2)。参数 γ 控制核的宽度， ν 控制对异常值的容忍度。通过交叉验证或经验选择。

精度指标：在测试集上用 F1-score, AUC 等衡量。由于无标签，常用重构误差或人工验证。误差：支持向量决定了模型边界，异常点可能被误分为正常 (假阴性)。

统计学习理论、核方法、凸优化。在特征空间中寻找最小超球体。

场景：入侵检测 (仅用正常流量训练)、工业设备故障检测、欺诈检测 (初期只有正常交易)。特征：无监督/半监督，只需正常样本训练，对新型未知异常有一定检测能力。

x_i: 训练样本， d 维特征向量。 Φ: 映射到高维特征空间的函数。 a, R: 超球体的球心和半径。 ξ_i: 松弛变量，允许一些样本在球外。 ν: 控制支持向量比例和异常值上限的参数。 α_i: 拉格朗日乘子，对应支持向量。 K: 核函数，如高斯核。

优化：带有不等式约束的凸优化问题。几何：在特征空间中寻找最小包围球。统计：基于样本估计数据的密集区域。

1. 训练阶段：输入正常数据集 {x_i}，选择核函数 K 和参数 ν, γ。求解优化问题得到拉格朗日乘子 {α_i} 和半径 R。支持向量是那些 α_i > 0 的样本。 2. 决策阶段：对于新样本 x，计算决策值 f(x)。 if f(x) >= 0: 预测为正常; else: 预测为异常。核心优化方程：见上述对偶问题和决策函数。

数据流：训练样本 -> 特征提取 -> 核矩阵计算 -> 求解优化问题 -> 得到模型 ({α_i}, R)。在线检测时，新样本 x -> 计算与所有支持向量的核函数值 -> 代入决策函数 f(x) -> 输出标签。模型“流动”的是支持向量及其权重。

硬件：训练时需计算和存储核矩阵 (O(n^2) 内存)，对大样本集有挑战。预测时需计算新点与所有支持向量的核函数，开销与支持向量数量成正比。软件：使用 libsvm 等库。需特征工程，参数调优。

Safety-D1-0021

密码学应用

零知识证明

非交互式零知识证明

zk-SNARKs (简洁非交互式知识论证)

1. 将计算转化为电路：将待证明的语句转化为算术电路或 R1CS。例如，证明知道一个哈希的原像，就是将哈希函数表示为电路。 2. 二次算术程序：将电路转化为 QAP，即寻找多项式，使得电路可满足性等价于这些多项式在特定点取值为零。 3. 可信设置：为特定电路生成公共参考串 (CRS)。这涉及随机采样一些毒药知识 (toxic waste) τ，并计算其幂的椭圆曲线点 {gτi}，然后销毁 τ。 CRS 分为证明密钥 pk 和验证密钥 vk。 4. 生成证明：证明者利用 pk、公开输入 x 和私有见证 w，通过 CRS 中的值计算几个椭圆曲线点作为证明 π。这个过程不需要交互。 5. 验证证明：验证者利用 vk、公开输入 x 和证明 π，进行几次双线性对计算。如果配对等式成立，则接受证明。 6. 核心配对检查：验证者检查如 e(A,B)=e(C,D)∗e(E,F)这样的等式，其中 A, B, C, D, E, F 是证明和验证密钥中的椭圆曲线点。

简洁性：证明大小恒定 (约 288 字节)，验证时间极快 (毫秒级)，与电路复杂度无关。知识可靠性：在计算性双线性群假设下，如果能生成有效证明，则证明者“知道”见证 w (知识提取)。零知识性：证明 π 不泄露任何关于 w 的信息。

椭圆曲线密码学、双线性对、知识承诺、多项式承诺。将 NP 语句的证明转化为代数方程组的可满足性，再通过密码学隐藏。

场景：区块链隐私交易 (Zcash)、可验证计算、身份认证而不泄露身份信息。特征：证明极小、验证极快、但需要可信设置，且电路固定后无法更改。

C: 算术电路。 x: 公开输入。 w: 私有见证。 τ: 有毒废料，在可信设置后必须销毁。 pk, vk: 证明密钥和验证密钥。 π: 证明，包含几个椭圆曲线点。 e: 双线性映射。

代数：多项式插值、拉格朗日基、椭圆曲线群运算。逻辑： NP 关系的算术化。密码学：双线性对的性质。

1. 可信设置 (一次性)：根据电路 C 生成随机 τ，计算 pk = {g^{τ^i}, g^{α * τ^i}, …}， vk = {g^α, g^{γ}, g^{βγ}, …}，销毁 τ。 2. 证明生成：证明者使用 pk，根据 x 和 w 计算多项式 h(x)，并生成承诺 π = (g^{A(τ)}, g^{B(τ)}, g^{C(τ)}, g^{H(τ)}, …)，其中 A, B, C, H 是与电路约束相关的多项式。 3. 验证：验证者使用 vk 和 π，检查双线性配对等式，例如： e(gA,gB)=?e(gC,g)∗e(gH,gZ(τ))，其中 Z(τ) 是 QAP 的目标多项式在 τ 处的值 (包含在 vk 中)。

信息流是单向的：可信设置生成 pk/vk 后，证明者可以随时生成证明 π 并发送给任何验证者。验证者只需 vk, x, π 即可验证，无需与证明者交互。信任流依赖于初始的可信设置。

硬件：证明生成需要大量的椭圆曲线运算和快速傅里叶变换 (用于多项式计算)，计算密集，内存需求大。软件：复杂的密码学库 (如 libsnark)。可信设置需要多方安全计算仪式以降低中心化信任风险。

Safety-D1-0022

硬件安全

侧信道防御/密码工程

掩码防护技术

一阶布尔掩码 (在 AES S-Box 上)

1. 目标：将密码算法的中间值 v 用随机掩码 r 隐藏，使得能量消耗等侧信道与 v 不相关。使用共享表示： v=s⊕r，其中 s 是秘密共享值。 2. 对线性操作：如 AES 的 ShiftRows 和 MixColumns，掩码可以简单地传递。例如， MixColumns 是线性变换 L，则 L(v⊕r)=L(v)⊕L(r)。因此，只需用同样的方式处理掩码份额即可。 3. 对非线性操作 (S-Box)：需要特殊设计。对于 AES 的 8-bit S-Box S(x)，要实现掩码版本 S‘(s, r) = (S(s \\oplus r) \\oplus r‘, r‘)，其中 r‘ 是一个新的随机掩码。这可以通过预计算的查找表实现，但表大小为 2^{2n} (n=8 时为 64KB)。更高效的方法是使用塔域分解和乘法掩码方案，但复杂度高。 4. 一阶安全性：攻击者需要同时获取 s 和 r 的信息才能恢复 v，理论上任何一阶统计矩 (如均值、方差) 都与 v 无关。但需确保在计算过程中没有出现 s 和 r 的未掩码组合 (如 (s⊕r) & s)。

安全性阶数：一阶掩码理论上抵抗一阶差分能量分析。高阶掩码可抵抗更高阶攻击。开销：引入随机数生成开销和计算复杂度增加 (约 2-4 倍面积/功耗)。

秘密共享、布尔代数。将单个敏感变量分割成多个随机份额，使得单个份额不泄露信息。

场景：保护智能卡、安全芯片中的 AES、 DES 等对称密码实现，抵御差分能量分析和电磁分析。特征：在算法层进行防护，不依赖物理层，但增加功耗、面积和时序开销。

v: 敏感中间值 (如 AES 状态字节)。 s, r: 共享值，满足 v = s ⊕ r。 r‘: 新的随机掩码，用于刷新输出。 S(x): 原始的 S-Box 函数。 S‘(s, r): 掩码后的 S-Box 函数。

布尔代数：异或运算、与运算。概率：掩码是均匀随机的。组合逻辑：电路设计需满足无故障传播条件。

1. 输入：接收掩码输入 (s, r)，其中 s = v ⊕ r。 2. 刷新掩码 (可选但推荐)：生成新随机数 r‘，计算 s‘ = s ⊕ r‘， r‘’ = r ⊕ r‘。现在 (s‘, r‘’) 是 v 的新共享，且与旧共享独立。 3. 计算非线性函数：计算 t = S‘(s‘, r‘’) = (S(s‘ ⊕ r‘’) ⊕ r‘‘‘, r‘‘‘) = (S(v) ⊕ r‘‘‘, r‘‘‘)。这里 S‘ 是掩码 S-Box 实现。 4. 输出：输出共享 (S(v) ⊕ r‘‘‘, r‘‘‘)。关键：在整个计算过程中，原始值 v 从未以明文形式出现。

数据流中，敏感值 v 始终以两个份额 (s, r) 的形式流动。每次非线性操作前，份额可能被刷新。随机数 r 像一条“护城河”包裹着秘密数据流，所有操作都在“护城河”内进行，结果再用新的随机数重新包裹。

硬件：需要真随机数发生器。电路面积和功耗显著增加，时序可能延长 (关键路径增加)。需确保无 glitch 和早期传播。软件：在微控制器上软件实现效率低，因需要处理份额和大量

编号 Safety-D1-0023

围绕云计算图形图像、音频/文本显示领域，并纵深覆盖从底层硬件到上层SaaS软件的漏洞与防御算法模型，突出软硬件融合设计的安全考量。

编号

类别

领域

模型配方

定理/算法/模型/方法名称

定理/算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式和参数选择/参数优化

精度/密度/误差/强度

底层规律/理论定理

典型应用场景和各类特征

变量/常量/参数列表及说明

数学特征

时序和交互流程的所有细节/分步骤时序情况及数学方程式

流动模型和流向方法的数学描述

硬件设计/软件设计及资源

Safety-D1-0023

系统安全

图形渲染/虚拟化

基于GPU虚拟化的侧信道攻击

GPU内存驱逐计时攻击 (GPU-based Eviction Timing Attack)

1. 威胁模型：攻击者与受害者VM共享同一物理GPU（如通过GPU虚拟化或SR-IOV）。 GPU的L2缓存等共享资源未在VM间充分隔离。 2. 攻击原理： a. 监视器：攻击者分配GPU缓冲区并反复访问，使其数据驻留L2缓存，同时高精度计时。 b. 驱逐：受害者VM的正常图形渲染或计算任务会访问其自己的GPU内存，若与攻击者缓冲区映射到同一缓存集，则会驱逐攻击者的缓存行。 c. 探测：攻击者立即再次访问自己的缓冲区。若访问时间长（缓存未命中），表明受害者访问了冲突集；若访问时间短（缓存命中），表明受害者未访问。通过此差异推断受害者内存访问模式。 3. 数学建模：设攻击者缓冲区大小为B， GPU L2缓存大小为C，关联度为A。攻击者需将缓冲区划分为C/A个不相关的“探测集”。访问时间T_acc服从混合分布： T_acc ~ P_miss * T_memory + (1-P_miss) * T_cache，其中P_miss是缓存未命中概率，受受害者活动影响。通过统计假设检验（如似然比检验）从T_acc的时间序列中推断受害者的活动。

精度：可探测到受害者是否访问了特定内存区域，但难以直接恢复精确数据值。信噪比：受GPU缓存替换策略、共享程度、系统噪声影响。

计算机体系结构（缓存层次结构）、概率论与统计推断、计时分析。

场景：在公有云GPU实例（如NVIDIA vGPU， AWS Inferentia）上，跨VM推断邻户的机器学习模型架构、输入特征或渲染内容。特征：无需特权、跨VM攻击、对细粒度活动敏感。

B: 攻击者分配的GPU缓冲区大小。 C: GPU共享缓存总容量。 A: 缓存关联度。 T_acc: 单次内存访问测量时间。 T_cache, T_memory: 缓存命中/未命中的基准访问时间。 P_miss: 缓存未命中概率。

概率与统计：假设检验，信号检测理论。计算与算法：缓存地址映射计算（index = (addr >> b) & (s-1)）。优化：缓冲区布局优化以最大化冲突。

1. 攻击者初始化：分配和初始化大小为B的缓冲区，确保其均匀覆盖所有缓存集。执行“预热”访问使其填满缓存。 2. 计时循环： for i in 0 to N-1: a. 访问自己的缓冲区，记录时间t_start。 b. 等待一个极短的时间间隔Δt（允许受害者执行）。 c. 再次访问自己的缓冲区，记录时间t_end。 d. 计算Δt_access = t_end – t_start，存入时间序列。 3. 后处理：对时间序列应用滑动平均滤波，检测Δt_access显著大于基线（T_memory）的峰值，峰值出现对应于受害者缓存访问活动期。

信息流：受害者GPU内存访问 -> 引起物理缓存状态变化 -> 影响攻击者缓存命中率 -> 体现为攻击者测量到的访问时间波动 -> 攻击者从时间信号中反推受害者活动。是一个隐蔽的侧信道信息流动。

硬件： GPU缓存需在vGPU间共享。防御需硬件支持缓存分区（如Cache Allocation Technology）或完全虚拟化。软件：攻击者为普通用户进程。防御需hypervisor或GPU驱动实施严格的缓存隔离或添加噪声。

Safety-D1-0024

应用安全

图形渲染/Web

WebGL着色器定时侧信道与指纹收集

WebGL 着色器性能指纹识别

1. 原理：不同GPU硬件（型号、驱动版本）执行同一段WebGL着色器代码的性能特征（执行时间）存在细微差异。这些差异构成硬件指纹。 2. 基准测试着色器设计：编写片段着色器，包含： a. 算术强度测试：循环执行大量浮点运算（如正弦、对数、乘加）。 for(int i=0; i<LOOP_CNT; i++){ result = sin(cos(result) * inputVal); } b. 纹理采样测试：执行随机或特定模式的纹理采样，测试纹理缓存和内存带宽。 c. 分支性能测试：包含条件分支的循环，测试GPU的分支预测和SIMD效率。 3. 计时：使用JavaScript的WebGLQuery对象（EXT_disjoint_timer_query）或requestAnimationFrame回调解码时间，精确测量着色器执行GPU时间。 4. 指纹生成：对多个测试项的执行时间进行向量化V = [t1, t2, …, tn]。可进一步通过PCA降维或直接作为高维特征向量。通过聚类或相似度计算（如余弦相似度）识别或追踪设备。

唯一性：在高性能桌面GPU中区分度好，在移动端同质化硬件中区分度较低。稳定性：受系统负载、温度、驱动版本影响，但短期内相对稳定。

性能基准测试、计量学、模式识别。利用硬件微架构差异导致的计算时延差异。

场景：网页浏览器中无需Cookie的跨会话用户追踪、反欺诈（识别虚拟机或常用设备）。特征：隐蔽、难以重置、受WebGL标准支持，但可被用户禁用。

LOOP_CNT: 循环迭代次数，需足够大以产生可测量时延。 inputVal: 变化的输入值，防止编译器过度优化。 t_i: 第i个测试项目的GPU执行时间。 V: 指纹特征向量。

计量学：时间测量与误差分析。统计：特征向量的相似性度量。优化：着色器代码设计以最大化硬件差异。

1. 初始化WebGL上下文。 2. 编译和链接基准测试着色器程序。 3. 创建查询对象 query = gl.createQuery()。 4. 对于每个测试项： a. gl.beginQuery(gl.TIME_ELAPSED_EXT, query)。 b. 执行绘制调用（触发着色器运行）。 c. gl.endQuery(gl.TIME_ELAPSED_EXT)。 d. 轮询查询结果，获取gl.getQueryParameter(query, gl.QUERY_RESULT)，即纳秒级时间t_i。 5. 聚合结果，形成指纹向量V。

控制流： JS -> 发起WebGL调用 -> GPU驱动 -> GPU执行着色器 -> 返回时间查询结果 -> JS。数据流：定制的着色器代码作为测试向量输入GPU， GPU返回其执行时间这个“响应”，形成挑战-响应对。

硬件：依赖GPU本身的计算能力和微架构细节。无法在软件层面完全模拟。软件：几行JavaScript即可实现。防御手段包括：用户禁用WebGL、浏览器对计时器进行模糊化（如添加随机噪声、降低精度）、标准化GPU驱动行为。

Safety-D1-0025

软件安全

操作系统/字体渲染

字体解析器内存损坏漏洞模型

字形轮廓点数组越界写入（以FreeType为例）

1. 漏洞点：字体文件（如TTF）中的glyf表包含每个字形的轮廓描述。轮廓由一系列点（points[]）组成，每个点有x, y坐标和on-curve标志。渲染前需将轮廓点转换为位图，此过程涉及扫描转换。 2. 触发条件：恶意字体文件可以构造一个畸形的轮廓： a. 定义轮廓包含N个点，但实际在文件中提供的点坐标数量M小于N。 b. 或在轮廓指令序列中，通过CALL子程序等操作，使渲染器内部状态机的“点索引”超出为当前轮廓分配的点数组边界。 3. 内存破坏：当解析器使用这个越界的索引i（i >= array_size）去读写points[i]时，会发生堆或栈缓冲区溢出。例如： points[i].x = interpolate(p[j].x, p[k].x, t);其中i被恶意数据控制。 4. 利用：精心控制i的值，可以覆盖点数组之后的关键内存结构，如函数指针、返回地址，从而劫持控制流。

强度：可导致远程代码执行（当字体被浏览器、文档查看器自动渲染时）。利用复杂度：需绕过ASLR、 DEP等现代缓解措施，但字体解析器常以高权限运行。

文件格式解析、自动机状态验证、边界检查缺失。本质是输入验证不充分。

场景：恶意文档、网页（通过@font-face）、操作系统字体预览功能均可触发。特征：文件是攻击载体，解析是受害组件，攻击可绕过许多基于网络的传统防御。

N: 字形轮廓声明的点数。 M: 字体文件中实际提供的点数。 points[]: 存储点坐标的数组。 i, j, k: 数组索引，由字体指令流控制。 array_size: points数组的实际分配大小。

离散数学：数组索引、边界。自动机：字体指令解释器的状态。构造：恶意输入构造以实现特定内存布局。

1. 字体加载：应用打开字体文件， FreeType解析glyf表。 2. 轮廓加载：为字形轮廓分配点数组 points = malloc(sizeof(Point) * N)。 3. 指令解释：逐条解释轮廓指令（如MOVETO， LINETO， CURVETO）。某些指令会向points追加点，并更新当前点索引cp。 4. 漏洞触发：当解释到恶意构造的指令（如引用一个不存在的点P[cp]，其中cp >= N），执行points[cp].x = value，发生越界写。 5. 控制流劫持：覆盖的关键数据被后续使用，导致程序计数器被控制。

数据流：恶意字体文件 -> 文件I/O -> 解析器内存缓冲区 -> 点数组 -> 越界写入相邻内存。控制流被畸形数据引导至错误的索引计算路径。

硬件：无特殊要求。防御可借助内存保护单元（MPU）。软件：漏洞在FreeType等库中。修复需在解析指令时严格验证所有索引均在[0, N)范围内。使用模糊测试（如oss-fuzz）可发现此类漏洞。

Safety-D1-0026

系统安全

虚拟化/图形透传

虚拟GPU (vGPU) 资源耗尽攻击

基于图形API调用的vGPU DoS

1. 目标：在GPU虚拟化环境中，单个恶意VM通过发起大量、复杂的图形或计算请求，耗尽宿主机GPU物理资源（计算单元、显存、命令队列空间），导致同宿主机其他VM的vGPU性能急剧下降或服务不可用。 2. 攻击向量： a. 显存分配：持续分配大量GPU显存直至达到vGPU限额或宿主机上限。 b. 计算任务：提交永无止境的计算着色器（无限循环或极大迭代次数），长时间独占GPU计算单元。内核形如： while(true) { do_expensive_math(); } c. 命令缓冲区洪水：以最高速率提交海量小型绘图或计算命令，塞满GPU命令处理器队列。 3. 资源模型：设宿主机GPU总资源为R_total，划分为k个vGPU，每个vGPU配额为R_i。攻击者VM资源使用R_attack(t)。攻击成功条件： R_attack(t) -> R_i（用满自身配额，通过垃圾数据）或通过共享资源（如GPU引擎、电源/ thermal budget）间接影响他人，即f(R_attack(t))导致R_available_for_others(t) << ΣR_j。

强度：可导致同主机其他VM图形性能降级>90%，或引发VM/宿主机驱动程序崩溃。检测难度：在配额内活动看似合法，难以与高强度合法应用区分。

资源管理、排队论、公平调度。本质是资源共享与隔离不彻底。

场景：公有云vGPU实例（如NVIDIA GRID， Intel GVT-g），容器内GPU使用（如NVIDIA Docker）。特征：内部拒绝服务、资源隔离缺陷、可能绕过基于配额的限制。

R_total: GPU物理资源总量（如显存字节数、计算单元数）。 R_i: 分配给第i个VM的vGPU资源配额。 R_attack(t): 攻击者VM在时间t的资源占用。 C_queue: GPU命令队列容量。 λ_submit: 攻击者提交命令的速率。

优化：在约束R_attack <= R_i下，最大化对共享资源的干扰。排队论：命令队列的到达与服务模型，可能使队列饱和。控制理论：资源使用的反馈与控制。

1. 攻击者VM启动，获取vGPU上下文。 2. 资源耗尽阶段：并行执行： a. 线程A：循环分配最大尺寸的显存缓冲区，填充数据，保持引用防止释放。 b. 线程B：编译并提交包含无限循环的计算着色器内核。 c. 线程C：在每一帧（或最高频率）提交包含大量无效绘图调用的命令缓冲区。 3. 持续运行，直到被系统干预或目标达成。

资源流： GPU物理资源（计算单元、显存、带宽、命令槽位）被攻击者VM发起的海量请求形成的“洪流”所占据。正常VM的请求流被阻塞或严重延迟。这是一种“资源吸附”型流动。

硬件：依赖GPU硬件提供资源监控和强制限制能力（如NVIDIA Ampere架构的MIG）。软件： Hypervisor和vGPU驱动需实现工作保留和服务质量调度。防御包括：每个vGPU硬性资源上限、检测并终止长时间运行的内核、命令提交速率限制。

Safety-D1-0027

应用安全

音频处理/语音识别

对抗性音频样本生成

基于优化的音频对抗样本（白盒）

1. 目标：给定原始音频信号x（波形），其被自动语音识别系统识别为T(x) = “原始文本”。寻找一个扰动δ，使得`

_p ≤ ε（扰动人类不可闻），但T(x+δ) = “目标文本”。 **2. 优化问题**：min_δ L(T(x+δ), y_target) + λ *

p，其中L是ASR系统的损失函数（连接时序分类损失），y_target是目标转录文本。 **3. 迭代攻击（以FGSM变种为例）**： a. 前向传播计算损失梯度：g = ∇x L(T(x), y_target)。 b. 计算扰动方向：符号梯度方向通常有效，δ = ε * sign(g)。 c. 为提升可迁移性和鲁棒性，可使用迭代方法如PGD：δ{t+1} = Clip_ε(δ_t + α * sign(∇{x+δ_t} L))。 **4. 不可感知约束**：使用L_∞范数约束幅值。更精细的约束可考虑心理声学模型，将扰动隐藏在听觉掩蔽阈值之下：

Safety-D1-0028

软件安全

云操作系统/容器

容器逃逸漏洞模型（用户命名空间与挂载）

利用user namespace与FUSE的容器逃逸

1. 前提：容器以特权模式运行（–privileged）或具有SYS_ADMIN能力，并允许访问/dev/fuse。攻击者在容器内已获root权限。 2. 创建用户命名空间：在容器内，攻击者调用unshare(CLONE_NEWUSER)创建一个新的用户命名空间。在新user ns中，攻击者拥有完整root映射（0->0），从而获得在该ns内的所有能力。 3. 挂载FUSE文件系统：利用SYS_ADMIN能力，攻击者可以在宿主机挂载命名空间内挂载一个恶意的FUSE文件系统。这个FUSE文件系统的read/write操作由攻击者控制的用户空间程序处理。 4. 写入逃逸：攻击者编写FUSE处理程序，当接收到特定写入请求时，该程序直接读写宿主机文件系统（如/）。因为FUSE守护进程在宿主机的上下文中运行（尽管由容器内触发），它可以访问宿主机的文件描述符。通过向挂载的FUSE文件写入特定载荷，攻击者能在宿主机上创建或覆盖文件（如/etc/crontab， .ssh/authorized_keys），实现逃逸和权限提升。

严重性：容器内root -> 宿主机root，完全逃逸。利用条件：需要–privileged或SYS_ADMIN+ /dev/fuse访问权，常见于某些CI/CD或自建平台错误配置。

Linux命名空间、能力模型、 FUSE文件系统。利用命名空间和能力交叉点的权限升级。

场景：错误配置的Docker容器、 Kubernetes Pod（特别是允许特权或hostIPC/hostPID但不完全隔离）。特征：本地权限提升、利用合法功能组合达成非法目的。

CLONE_NEWUSER: 创建新用户命名空间的标志。 SYS_ADMIN: Linux能力，允许挂载操作。 /dev/fuse: FUSE设备文件。 fuse_operations: 包含read， write等回调函数的结构体。

集合与映射：用户/命名空间ID映射。逻辑：权限与能力的组合逻辑。构造：利用多个子系统的交互达成逃逸。

1. 容器内获取root（通过漏洞）。 2. 执行unshare(CLONE_NEWUSER)，在新user ns中成为root。 3. 编译恶意FUSE程序，其write回调包含： if (buf contains “ESCAPE_PAYLOAD”) { open(“/host/etc/crontab”, O_WRONLY); … }。 4. 挂载FUSE文件系统： ./malicious_fuse /mnt/evil。 5. 写入逃逸： echo “ESCAPE_PAYLOAD” > /mnt/evil/file。触发FUSE程序在宿主机上下文执行代码。 6. 清理（可选）。

控制流从容器内的进程 -> 通过unsharesyscall进入新user ns -> 通过mountsyscall触发FUSE内核模块 -> FUSE内核模块唤醒宿主机上的用户态守护进程 -> 守护进程执行恶意代码操作宿主机文件系统。这是一个从隔离的命名空间“渗透”到外层命名空间的流。

硬件：无特殊需求。软件：漏洞源于Linux内核命名空间和安全模型的复杂交互。防御：禁止容器使用–privileged，降低能力（drop SYS_ADMIN），使用Seccomp过滤unshare， mount等系统调用，使用只读根文件系统。

Safety-D1-0029

密码学应用

云存储/图像隐写

基于深度学习的自适应图像隐写分析

富模型特征下的空间域隐写检测

1. 特征提取：使用富模型（如SRM， Spatial Rich Model）从图像中提取高阶噪声残差特征。对图像I进行线性高通滤波，得到残差R = I * h，其中h是一组方向性高通滤波器核。然后计算残差邻域内像素值的联合概率分布（通过量化、截断和三元化），形成高维特征向量F（维数可达数万）。 2. 分类模型：使用集成分类器（如集成分类器FLD）或深度学习（如CNN）对特征F进行分类。训练集包含纯净图像C和用隐写算法S以负载率α嵌入秘密信息后的隐写图像S。 3. 检测过程：给定待测图像I_test，提取其特征F_test，输入训练好的分类器G，得到判决分数score = G(F_test)。与阈值τ比较决定是否为隐写图像。 4. 对抗：隐写方试图设计算法使嵌入更改的统计特征Φ(S(I, m))尽量接近Φ(I)，其中Φ是特征提取函数。这导致一个极小极大博弈： min_S max_D [Pr(D(Φ(S(I,m))) = 隐写) – Pr(D(Φ(I)) = 隐写)]。

检测准确率：在已知隐写算法和固定负载率下， AUC可超过0.99。对未知算法或低负载（<0.1 bpp）准确率下降。虚警率：需控制在极低水平（如<0.001）以实用。

统计模式识别、假设检验（Neyman-Pearson引理）、博弈论。本质是区分两个统计分布（自然图像vs.隐写图像）。

场景：云相册/网盘内容安全审查、数字取证、防止利用图片传输恶意载荷。特征：被动检测、计算密集型、与具体隐写算法相关。

I: 图像像素矩阵。 h: 高通滤波器核集合。 R: 滤波后的残差图像。 F: 从残差计算出的高维特征向量。 α: 隐写嵌入率（比特每像素）。 G: 训练好的分类器（如SVM， CNN）。 τ: 检测阈值。

统计：高阶统计矩、概率分布建模。信号处理：线性滤波。机器学习：特征工程与分类。

1. 训练阶段：对大量自然图像{I_nat}和其隐写版本{I_stego}提取SRM特征，训练一个二分类器G。 2. 检测阶段： a. 输入待测图像I_test。 b. 用一组高通滤波器卷积图像，得到多个残差通道。 c. 对每个残差通道，计算其量化、截断、三元化后的共生矩阵，展平为子特征。 d. 拼接所有子特征，形成最终特征向量F_test。 e. 将F_test输入分类器G，得到判决分数score。 f. 如果score > τ，判定为隐写；否则为自然图像。

信息流：图像像素 -> 线性滤波（去相关）-> 残差统计 -> 高维特征向量 -> 分类器 -> 判决分数。隐写信息的存在会微弱地改变残差的统计分布，这个微小信号被特征提取放大并被分类器捕获。

硬件：特征提取和分类（尤其是深度学习模型）需要GPU加速。软件：实现SRM特征提取和分类器训练/推理。隐写方则需设计抗检测的嵌入算法（如基于对抗训练的深度隐写）。

Safety-D1-0030

系统安全

BIOS/UEFI固件

SPI闪存重放攻击与固件回滚

SPI闪存编程周期旁路与回滚防御

1. 威胁：攻击者物理接触设备，将BIOS/UEFI固件芯片（SPI Flash）拆下，用编程器读取内容F_old，修改后写回，或直接用旧版本但含漏洞的固件F_vuln替换当前已修补的固件F_patched，实现回滚攻击。 2. 传统防御：启动时校验固件密码学摘要。但若旧版本固件F_vuln的签名仍然有效，回滚仍可通过。 3. 增强模型（基于单调计数器）： a. 在SoC或TPM中内置一个抗回滚单调计数器 C。每次更新到新固件F_i时，将计数器的当前值c_i嵌入固件头，并将计数器递增： C = c_i + 1。 b. 启动时，引导ROM不仅验证固件签名，还验证固件头中的计数器值c是否等于芯片内存储的计数器值C。即必须满足： VerifySig(F_i) AND (c_i == C)。 c. 回滚攻击试图刷入旧固件F_j（j < i），其包含计数器值c_j < c_i。由于c_j != C，验证失败，系统拒绝启动。 4. 物理攻击：攻击者可能试图对存储计数器C的易失性存储器（如电池备份RAM）或一次性可编程熔丝进行物理操作（如冷冻、探针）。防御需硬件安全设计。

强度：在密码学签名和防篡改计数器完好的情况下，可完全防止固件回滚。局限性：依赖硬件安全，计数器一旦耗尽或损坏可能导致设备变砖。

密码学（数字签名）、单调递增序列、硬件安全（防篡改存储）。

场景：服务器、笔记本、 IoT设备的物理安全防护，确保即使物理接触也无法降级固件以利用旧漏洞。特征：防御物理攻击、依赖硬件信任根、必须与安全启动结合。

F_i: 第i版固件镜像。 C: 存储在安全硬件中的当前单调计数器值。 c_i: 嵌入在固件F_i头中的计数器值。 VerifySig(): 固件签名验证函数。 SK_fw: 固件签名私钥（由厂商安全保管）。

逻辑：条件验证（签名AND计数器匹配）。序列：单调递增的计数器序列。密码学：数字签名算法（如RSA-PSS）。

1. 制造时：初始化安全硬件中的计数器C = 0。 2. 固件更新（安全过程）： a. 进入恢复模式，验证新固件F_new签名。 b. 从安全硬件读取当前计数器值C，将其写入F_new头部的c_new字段。 c. 将F_new写入SPI闪存。 d. 关键步骤：递增安全硬件中的计数器： C = C + 1。 3. 每次启动： a. 引导ROM从SPI闪存加载固件头，读取c_stored。 b. 从安全硬件读取C。 c. 如果VerifySig(FW) == PASS AND c_stored == C，继续启动；否则，进入恢复模式。

信任流：从不可变的安全硬件计数器C开始，在更新时“消耗”一个计数器值并将其“绑定”到特定固件版本F_i。启动时，从闪存中读取的c_i必须与硬件中当前的C匹配，形成一个时间箭头验证，阻止向“过去”回滚。

硬件： SoC必须集成防篡改的单调计数器存储（如eFuse，电池备份RAM+加密）。引导ROM必须硬化。软件：固件更新工具必须原子化地执行“写闪存-递增计数器”操作。恢复模式需能处理验证失败。

Safety-D1-0031

应用安全

文本显示/富文本编辑器

跨站脚本（XSS）富文本过滤模型

基于语法分析与白名单的HTML净化

1. 问题：用户提交的富文本（HTML）需在显示前净化，移除危险标签和属性，同时保留安全格式。 2. 模型设计： a. 解析：使用健壮的HTML解析器（如HTML5规范）将输入字符串解析为文档对象模型（DOM）树。正确处理畸形HTML和编码。 b. 遍历与过滤：深度优先遍历DOM树。对每个节点（元素、属性）： i. 元素白名单：如果元素标签名不在白名单L = {p, b, i, em, strong, a, …}中，则删除该节点（但可能保留其子节点）。 ii. 属性白名单：对保留元素，检查其每个属性。如果属性名不在该元素允许的属性列表A(tag)中，则删除。对关键属性（如href， src）的值进行额外验证： – 协议白名单： href和src的协议必须为http， https， mailto或相对协议。使用正则匹配： `href.matches(‘^(https?://

mailto:

#)’)。 – **编码防御**：对属性值进行HTML实体编码。 iii. **事件处理器移除**：所有以on开头的属性（如onclick，onmouseover`）无条件移除。 c. 序列化：将净化后的DOM树重新序列化为安全的HTML字符串。

安全性：理论上可完全防御由富文本输入导致的XSS，前提是白名单设置正确且解析器无误。功能性：在安全和功能间权衡，过严的白名单可能破坏用户格式。

形式语言（HTML语法）、树遍历算法、白名单访问控制。

场景：论坛发帖、博客评论、在线文档编辑器的内容安全过滤。特征：输入净化、针对存储型和反射型XSS、是Web应用安全的基础设施。

HTML_in: 用户输入的原始HTML字符串。 DOM: 解析后的文档树。 L: 安全的HTML元素标签名白名单集合。 A(tag): 针对特定标签tag的安全属性名集合。 regex_protocol: 用于验证URL协议的正则表达式。

树结构： DOM树的遍历与操作。集合：白名单集合的成员判断。形式语言： HTML/XML语法解析。

Safety-D1-0032

硬件安全

显示接口/物理侧信道

通过电磁辐射重建显示内容

基于电磁辐射的Tempest攻击

1. 物理原理：显示设备（尤其是传统VGA接口）的模拟信号在电缆和电路中会产生电磁辐射。这些辐射的强度和频率与正在显示的像素内容（RGB值、同步信号）相关。 2. 信号建模：对于逐行扫描显示器，视频信号V(t)是时间函数。一行像素的显示可建模为： V(t) = Σ_{i} (R_i * δ(t – i*t_pixel))的平滑版本，其中R_i是第i个像素的红色分量强度， t_pixel是每个像素的显示时间。这个时域信号会在特定频带（取决于行频f_h和像素时钟f_pixel）产生特征性的电磁辐射E(t)。 3. 重建过程： a. 信号捕获：使用定向天线和软件定义无线电接收特定频段的辐射信号S(t)，采样数字化。 b. 同步提取：从S(t)中提取行同步和场同步的周期信息（对应f_h和f_v）。这通常表现为信号的周期性尖峰。 c. 像素时钟恢复：通过锁相环等技术，从行信号中恢复像素时钟频率f_pixel。 d. 采样与对齐：利用恢复的时钟，对每一行的信号进行采样，得到一串幅度值序列A[n]。 e. 图像重建：将幅度序列A[n]按行排列，并进行对比度/亮度调整，重建出单色图像。对RGB三通道需分别处理不同频段或通过颜色编码推断。

分辨率：可重建文本内容（如字母），但细节有限。受信噪比、距离、设备屏蔽影响。距离：在无屏蔽情况下，攻击有效距离可达数十米。

电磁学、信号处理、通信理论。显示信号无意调制了电磁辐射。

场景：针对物理隔离网络（空气间隙）的窃密，从高安全区域外的显示器电磁泄漏中获取信息。特征：被动、非侵入、需要专业设备、对数字接口（DVI， HDMI）效果减弱但仍有风险。

V(t): 模拟视频信号。 E(t): 辐射出的电磁场信号。 S(t): 接收到的信号。 f_h, f_v: 行频和场频。 f_pixel: 像素时钟频率。 A[n]: 采样后的幅度序列。

信号处理：滤波、同步恢复、采样。傅里叶分析：从时域信号到频域特征的变换。图像重建：从一维序列到二维图像的映射。

1. 侦察：扫描电磁频谱，寻找来自目标显示器的特征辐射频段。 2. 捕获：在目标频段进行长时间采样，得到S(t)。 3. 预处理：对S(t)进行带通滤波，增强信噪比。 4. 同步恢复：计算S(t)的自相关或应用锁相环，提取f_h和f_v。 5. 时钟恢复：在行同步内，通过过零检测或频谱分析估计f_pixel。 6. 采样：对每一行，以f_pixel为采样率进行采样，得到一行像素的幅度值。 7. 帧组装：将所有行按场同步信号组装成图像矩阵I[x][y]。 8. 后处理：对I进行去噪、锐化、二值化，提高可读性。

信息流：计算机内存中的显示数据 -> GPU -> 视频接口电路 -> 产生携带视频信息的模拟电信号 -> 信号在电缆/PCB上传播产生电磁辐射 -> 空间传播 -> 被天线接收 -> 解调/采样 -> 重建为图像数据。这是一个从数字信息到模拟物理场，再被逆向还原的泄露流。

硬件：攻击端需要SDR（如USRP）、定向天线、可能需低噪声放大器。防御端需使用屏蔽良好的显示器和电缆（如STP），或采用低辐射设备（Tempest认证），或在物理上隔离安全区域。

Safety-D1-0033

软件安全

云管理系统/API

云API滥用与资源枯竭攻击

云管理API速率限制绕过与资源创建攻击

1. 攻击模式：攻击者通过窃取的API密钥或令牌，调用云服务商（如AWS， Azure）的管理API，快速创建大量高成本资源（如大规格虚拟机、 GPU实例、海量存储），导致受害者账单激增（经济DoS）或达到账户资源上限（技术DoS）。 2. 绕过速率限制：云API通常有全局（每账户/每区域）和局部（每用户/每IP）速率限制。攻击策略： a. 分布式调用：使用僵尸网络从多个IP发起请求。 b. API端点遍历：如果限制是基于单个端点（如ec2:RunInstances），攻击者可能混合调用不同服务的API以分散请求。 c. 慢速攻击：以略低于限制阈值的速率持续发起请求，长期占用资源配额。 3. 资源创建模型：设攻击者拥有创建资源R的权限，每个资源单位时间成本为$c。攻击者在时间T内创建N(t)个资源。总成本 C_total = ∫_0^T c * N(t) dt。攻击者目标是快速最大化C_total或N(t)直至达到账户限额L。

经济影响：可在几分钟内产生数万至数十万美元的未经授权费用。检测延迟：从资源创建到账单周期结束可能有时延，给攻击者窗口期。

速率限制算法（令牌桶、漏桶）、经济模型、异常检测。

场景：云账户劫持（通过钓鱼、泄露的凭据）、恶意内部人员、供应链攻击（滥用第三方服务的云令牌）。特征：经济驱动、利用云按需付费模型、自动化脚本可大规模实施。

API_Key/Token: 用于认证的凭证。 R: 资源类型（如m5.24xlarge实例）。 c: 资源单位时间成本（美元/小时）。 N(t): 在时间t存活的资源数量。 L: 账户资源数量或成本的软/硬限制。 RateLimit: API速率限制（请求数/秒）。

优化：在约束dN/dt ≤ RateLimit下，最大化C_total或使N(t) -> L最快。控制：对资源创建速率的开环控制。时序：攻击的时间序列分析。

1. 凭证获取：通过钓鱼、泄露等方式获得有效的云API密钥。 2. 侦察：使用密钥调用API（如iam:GetUser， ec2:DescribeAccountAttributes）了解账户限额和现有资源。 3. 攻击执行：编写脚本，循环调用资源创建API（如ec2:RunInstances），并可能配合其他API（如ec2:CreateVolume， s3:CreateBucket）制造更多成本。脚本可能使用多线程和分布式代理绕过IP限制。 4. 维持：防止资源被自动关停（如避开监控时间窗口）。

控制流：攻击者脚本 -> 通过API网关认证 -> 云控制平面 -> 资源编排服务 -> 底层基础设施创建资源。资源流被恶意脚本大量、快速地“泵入”云环境。资金流随之从受害者账户流向云服务商。

硬件：攻击者需要控制僵尸网络或使用云函数（如AWS Lambda）自身发起攻击，形成“用自己的资源攻击自己”的悖论。软件：云服务商需部署行为异常检测：分析API调用模式（时间、序列、资源类型）、设置预算告警、强制使用MFA和权限最小化原则、对高风险操作（创建昂贵资源）要求二次确认或延迟生效。

Safety-D1-0034

系统安全

操作系统/内存管理

页表污染攻击与特权提升

利用写入时复制（CoW）的页表项污染

1. 背景：现代操作系统使用写时复制（CoW）优化fork()。父进程和子进程初始共享所有只读页，包括页表页。当一方尝试写入时，会触发缺页异常，内核分配新物理页并复制内容。 2. 攻击思路：在Linux内核中，页表（PTE）本身也存储在被映射的物理页中。攻击者试图在子进程中触发对共享页表页的写操作，导致内核复制该页表页。攻击者可控制写入的内容，从而在复制的页表页中植入一个恶意页表项（PTE）。这个恶意PTE可能将内核代码或数据页面映射到用户空间，从而实现EoP。 3. 步骤： a. 内存布局：攻击者进程通过大量分配，使其页表页恰好位于一个已知的虚拟地址V_pt，且该地址在用户空间可访问（某些架构/配置下可能）。 b. fork：攻击者调用fork()创建子进程。此时父子共享包含V_pt对应的页表页。 c. 触发CoW：在子进程中，向地址V_pt写入一个精心构造的值（一个恶意的PTE）。这触发缺页。内核会分配一个新的物理页P_new作为页表页，将旧页表页内容复制过来，但此时子进程的写入请求已经发生，复制的数据中包含了攻击者写入的恶意PTE。 d. 利用：这个恶意PTE可能将一个内核可执行页映射到用户空间，之后攻击者即可向该页写入shellcode并执行。

严重性：可从无特权的用户空间获得内核代码执行能力，完全颠覆系统安全。利用条件：需要深入了解内核内存管理细节，成功率受内核版本和缓解措施影响。

操作系统内存管理、页表结构、写时复制语义。利用共享内存语义的副作用。

场景： Linux本地权限提升，尤其在允许用户空间访问页表的内存配置下（如某些嵌入式系统）。特征：利用内核自身机制（CoW）攻击内核、条件较为苛刻但极具威胁。

V_pt: 用户空间可访问的、存放页表项的虚拟地址。 PTE_orig: 原始的页表项。 PTE_mal: 攻击者构造的恶意页表项（如设置U/S位为用户，指向内核代码页）。 P_old, P_new: 旧的共享页表物理页和新的CoW复制页。

位操作： PTE标志位的操作（U/S, R/W, P）。虚拟内存：虚拟到物理地址的转换。并发：父子进程的并发内存访问。

1. 准备：喷射内存，使自己的一个页表页位于用户映射区V_pt。 2. Fork： pid = fork()。 3. 在子进程中： a. 向V_pt写入PTE_mal。这立即触发缺页异常（因为页是只读的CoW页）。 b. 内核的缺页处理程序分配新页P_new，从P_old复制数据。关键：复制的是P_old的原始内容加上刚刚子进程写入的PTE_mal（因为写入可能已在缓存中，内存一致性模型复杂）。 c. 内核更新子进程的页表，使V_pt指向P_new，并标记为可写。 4. 缺页返回后，子进程的页表页P_new中已包含恶意PTE。 5. 利用恶意映射访问内核内存。

信息流：攻击者数据（恶意PTE） -> 通过用户空间写入 -> 触发内核CoW机制 -> 内核在复制页表页时，无意中将攻击者数据作为页表内容固化到新的物理页 -> 新的页表生效 -> 建立非法的虚拟内存映射 -> 攻击者通过该映射访问内核。数据“污染”了页表复制过程。

硬件：依赖CPU的内存管理单元（MMU）和缓存一致性协议。某些ARM/ARM64配置允许用户访问页表。软件： Linux内核漏洞（CVE-2019-9213等）。防御：确保用户空间永远无法直接访问页表页（清除_PAGE_USER位），或在复制页表页时进行安全性验证。

Safety-D1-0035

密码学应用

多媒体/数字水印

鲁棒视频水印的抗重编码攻击模型

基于奇异值分解（SVD）的时空域水印

1. 嵌入：将视频视为帧序列{F_t}。对选定的帧，分块处理。对于每一块B（例如8×8），进行SVD分解： B = U * S * V^T，其中S是对角矩阵，对角线元素为奇异值σ_i（σ_1 ≥ σ_2 ≥ … ≥ 0）。 2. 水印嵌入规则：修改最大奇异值σ_1来编码水印比特w ∈ {0, 1}。使用量化索引调制：将σ_1量化到两个不同的集合之一。 – 如果w=1： σ_1‘ = Q_1(σ_1)，其中Q_1是步长为Δ的量化器，中心在…， -Δ， 0， Δ， 2Δ， …。 – 如果w=0： σ_1‘ = Q_0(σ_1)，其中Q_0是偏移了Δ/2的量化器，中心在…， -Δ/2， Δ/2， 3Δ/2， …。然后重构水印块： B‘ = U * S‘ * V^T，其中S‘是σ_1替换为σ_1‘后的对角阵。 3. 提取：对可能受攻击的视频帧块B_att，计算其SVD得到σ_1_att。计算到两个量化网格的距离： `d1 =

σ_1_att – Q_1(σ_1_att)

，d0 =

σ_1_att – Q_0(σ_1_att)

。如果d1 < d0，则判决w=1；否则w=0`。 4. 抗攻击性：奇异值对常规信号处理（如压缩、滤波、亮度调整）具有较好稳定性，因此水印鲁棒。

鲁棒性：可抵抗H.264/AVC重编码（中高码率）、高斯滤波、尺度缩放等常见攻击。比特错误率（BER）可低于5%。不可见性：调整Δ以平衡鲁棒性和视觉质量（PSNR > 40dB）。

线性代数（矩阵分解）、信号处理、量化理论。利用奇异值的代数不变量特性。

场景：视频版权保护、盗版溯源、广播监控。特征：盲水印（提取不需原视频）、对几何攻击（旋转、裁剪）较脆弱，常需与其它技术结合。

B: 视频帧块（矩阵）。 U, S, V: B的SVD分解结果。 σ_i: 奇异值，特别是σ_1。 w: 待嵌入的水印比特。 Δ: 量化步长，控制嵌入强度。 Q_0, Q_1: 量化函数。

Safety-D1-0036

软件安全

PaaS/无服务器计算

无服务器函数持久化攻击与数据泄露

利用冷启动延迟的临时存储残留攻击

1. 无服务器模型：函数实例在执行后被冻结或销毁，其本地临时存储（/tmp）理论上被清空。但为优化性能（冷启动），平台可能复用实例，其内存和磁盘状态可能被保留一段时间。 2. 攻击模型： a. 侦察：攻击者部署一个函数，写入敏感数据到/tmp（如窃取的数据库凭证、私钥）。函数执行结束，实例进入“冷冻”状态。 b. 利用：攻击者通过某种方式（如触发自己的另一个函数，并期望分配到同一个物理实例）尝试访问残留的/tmp。如果平台未彻底清理，攻击者可能读取到前一个函数留下的数据。 3. 概率模型：设平台有M个物理工作者实例。攻击者第一次函数运行在实例W_i上。攻击者第二次调用函数，被调度到同一个实例W_i的概率是1/M。通过高频、短时间间隔内连续调用，可增加命中概率。更高级的攻击可能利用资源定位（如通过侧信道推测实例位置）。

严重性：可能导致跨租户数据泄露，违反多租户隔离的核心安全承诺。成功概率：取决于平台实现、实例复用策略和时间窗口，可能很低但非零。

概率论、资源调度、多租户隔离。利用资源回收与分配之间的时间窗口和状态残留。

场景： AWS Lambda， Azure Functions， Google Cloud Functions 等FaaS平台。特征：攻击无服务器隔离模型、依赖平台实现细节、难以被应用层感知。

M: 可用的工作者实例总数。 W_i: 第i个工作者实例。 P_reuse: 攻击者函数被调度到同一个实例的概率。 T_cleanup: 平台清理实例状态的超时时间。 Data_prev: 前一次执行留在/tmp的数据。

概率：调度命中概率计算。时序：攻击调用与清理的时间竞争。

1. 攻击者函数A：在/tmp写入敏感文件secret.txt，然后正常结束。 2. 实例冻结：平台冻结该实例W_i，可能未擦除/tmp。 3. 短时间后，攻击者立即再次调用函数B（可能与A相同或不同）。 4. 平台调度：可能将函数B调度到刚冻结的实例W_i上以快速启动（暖启动）。 5. 函数B执行：尝试读取/tmp/secret.txt。如果文件存在且内容可读，攻击成功，数据泄露。

信息流：敏感数据（来自函数A的运行时） -> 写入实例W_i的临时存储 -> 实例冻结，数据残留 -> 实例被解冻用于服务函数B -> 函数B从临时存储读取残留数据 -> 数据泄露给攻击者。数据通过被复用的实例“载体”在时间上传递给了不应有权限的后续函数。

硬件：无特殊要求，但平台需依赖CPU和内存的强隔离（如AMD SEV-SNP）。软件：平台防御是绝对的。必须在每次函数执行结束后，或在新函数执行开始前，强制清空实例的所有临时存储和内存。使用加密的短暂卷，并在实例终止时安全擦除密钥。

Safety-D1-0037

硬件安全

半导体物理/芯片安全

激光故障注入攻击模型

通过激光脉冲扰动晶体管状态

1. 物理原理：聚焦的激光脉冲照射到CMOS晶体管上，会在硅中产生电子-空穴对，从而在pn结处产生光电流I_photo。这可以： a. 翻转逻辑值：对存储单元（如SRAM，锁存器），光电流可能足以克服反馈，将‘0’变为‘1’或反之。 b. 跳过指令：对组合逻辑，瞬时电流可能导致时序违规，使门电路输出错误值，例如让条件跳转指令JZ（为零跳转）在执行时被跳过，从而改变程序流。 2. 攻击模型：攻击者需要去封装芯片，用微探针台定位目标区域。激光参数：波长λ（决定穿透深度，如1064nm用于硅）、脉冲能量E_pulse、脉冲宽度τ（皮秒到纳秒）、聚焦点直径d。 3. 扰动方程：产生的光生载流子密度Δn与激光通量Φ和吸收系数α(λ)相关： Δn ≈ α(λ) * Φ / (hν)，其中hν是光子能量。光电流I_photo = q * A * Δn / τ_r， q为电子电荷， A为结面积， τ_r为载流子寿命。需I_photo超过电路的噪声容限。

空间精度：现代攻击可达1μm量级，可针对单个晶体管或门。时间精度：需与目标电路时钟同步，精度在纳秒级。

半导体物理学（光电效应）、电路理论、激光与物质相互作用。

场景：攻击智能卡、安全芯片、汽车ECU，用于绕过密码学验证、提取固件、权限提升。特征：物理侵入式、高成本、高技能、可绕过许多逻辑防护。

λ: 激光波长。 E_pulse: 单脉冲能量。 τ: 脉冲宽度。 d: 光斑直径。 α(λ): 硅在波长λ下的吸收系数。 Φ: 激光能量通量（J/cm²）。 I_photo: induced photocurrent.

物理方程：光电转换方程。三维几何：激光聚焦与芯片布局对齐。时序：激光脉冲与时钟沿的精确同步。

1. 逆向工程：对目标芯片去封装，使用显微镜和染色技术定位感兴趣的区域（如加密协处理器）。 2. 参数标定：在不关键区域测试，确定引发故障所需的激光能量和时序。 3. 同步：将激光脉冲与芯片时钟同步，使脉冲在目标指令执行的精确时刻到达目标晶体管。 4. 攻击执行：触发芯片执行安全敏感操作（如PIN验证），同时发射同步的激光脉冲。 5. 观察结果：如果故障注入成功，芯片可能表现出异常行为（如接受错误PIN），攻击者记录此条件。

能量流：激光器 -> 聚焦光学系统 -> 芯片表面 -> 穿透钝化层 -> 在硅衬底产生电子-空穴对 -> 形成光电流 -> 干扰晶体管正常开关行为 -> 导致逻辑状态错误。这是一个从外部物理能量到内部逻辑错误的因果链。

硬件：防御：使用顶层金属网格、传感器检测异常光/电压/电流、随机延迟、双轨预充电逻辑、在安全关键路径上增加冗余和校验。攻击端需要昂贵的激光故障注入设备。软件：在固件中加入完整性检查、冗余计算与比较。

Safety-D1-0038

应用安全

文本处理/Office文档

Office公式编辑器内存损坏漏洞利用

等式编辑器栈缓冲区溢出（CVE-2017-11882）

1. 漏洞点：旧版Microsoft Office的EQNEDT32.EXE（等式编辑器）在解析字体名称Font Name记录时，使用固定大小的栈缓冲区char buffer[64]，但使用strcpy将字体名从文件复制到缓冲区，无长度检查。 2. 漏洞触发：恶意.rtf或.doc文件包含一个畸形公式对象（OLE）。在公式的字体记录中， Font Name字段被构造为超过64字节的长字符串。 3. 溢出利用： strcpy(buffer, long_font_name)导致栈缓冲区溢出，覆盖函数返回地址。攻击者将Shellcode编码在long_font_name字符串中，并精确计算偏移，使返回地址被覆盖为指向Shellcode的地址（可能是缓冲区本身地址或跳转指令地址）。 4. 绕过DEP/ASLR：该编辑器未启用DEP/ASLR，因此Shellcode在栈上可执行，且地址可预测，利用简单。

影响：在打开恶意文档时自动执行代码，无需用户交互（除打开文档外）。利用可靠性：在未打补丁的系统上接近100%。

软件工程（不安全的C函数）、栈帧布局、控制流劫持。

场景：鱼叉式钓鱼邮件附件、恶意网站上的文档下载。经典“漏洞利用套件”组成部分。特征：文件类型攻击、针对旧版但广泛部署的软件、利用简单。

buffer[64]: 栈上的目标缓冲区。 long_font_name: 攻击者控制的超长字符串（>64字节）。 ret_addr: 被覆盖的返回地址。 shellcode: 嵌入在字体名中的机器码。

连续内存模型：栈布局的线性覆盖。构造：精确计算填充长度和地址偏移。

1. 文档解析： Word加载RTF，发现嵌入的公式OLE对象，启动EQNEDT32.EXE进程。 2. 字体解析：在EQNEDT32.EXE中，解析到字体记录，读取字体名字符串指针和长度。 3. 脆弱调用：调用strcpy(buffer, src)，其中src指向恶意字体名。 4. 栈溢出： src内容复制到buffer并越过边界，覆盖栈上的保存的EBP和返回地址。 5. 函数返回：脆弱的函数返回时，从被覆盖的返回地址处取出EIP，跳转到攻击者控制的地址（如指向buffer中部的jmp esp指令）。 6. 执行Shellcode：执行buffer中的Shellcode，通常下载并执行第二阶段恶意软件。

数据流：恶意文档文件 -> 文件解析器 -> 字体名字符串 -> strcpy-> 栈缓冲区 -> 溢出覆盖返回地址 -> 控制流跳转至Shellcode -> 执行恶意操作。攻击载荷像“特洛伊木马”一样隐藏在文档内容中，在解析时被释放并触发。

硬件：无特殊需求。 DEP（数据执行保护）可防御，但该程序未启用。软件：补丁是修复strcpy为strncpy或检查长度。缓解措施：启用DEP和ASLR，禁用旧版、不安全的组件（如等式编辑器），使用Office查看器或沙箱打开不受信任文档。

Safety-D1-0039

系统安全

虚拟化/IOMMU

DMA攻击与IOMMU防护配置模型

直接内存访问重映射与防护

1. DMA攻击：具有总线主控能力的恶意或受控外设（如网卡、 GPU）可以直接读写系统内存（DMA），可能绕过CPU访问控制

编号

类别

领域

模型配方

定理/算法/模型/方法名称

定理/算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式和参数选择/参数优化

精度/密度/误差/强度

底层规律/理论定理

典型应用场景和各类特征

变量/常量/参数列表及说明

数学特征

时序和交互流程的所有细节/分步骤时序情况及数学方程式

流动模型和流向方法的数学描述

硬件设计/软件设计及资源

Safety-D1-0040

系统安全

图形渲染/虚拟化

GPU内存驱逐计时侧信道攻击

基于GPU L2缓存组冲突的跨VM信息泄露

1. 威胁模型：攻击者与受害者VM共享物理GPU（如vGPU, SR-IOV）。 GPU的末级缓存（L2）是VM间共享资源，缺乏硬件分区。 2. 攻击原理： a. 地址映射： GPU内存地址addr映射到缓存组set： set = (addr >> b) & (S-1)，其中b是块偏移位数， S是缓存组数。 b. 监视器：攻击者分配缓冲区A，其地址经过精心设计，使其均匀覆盖所有缓存组。攻击者反复读取A，使数据驻留L2，并测量访问时间t_access。 c. 驱逐与探测：受害者VM执行图形渲染，其内存访问若与A的某些行映射到同一缓存组，会驱逐攻击者的缓存行。攻击者立即再次测量A的访问时间。若t_access显著变长（缓存未命中），则推断受害者访问了冲突的缓存组。 3. 信号处理：对时间序列{t_i}应用滑动窗口平均和阈值检测。设基线缓存命中时间为T_hit，未命中时间为T_miss。定义判决变量D_i = 1 if t_i > T_hit + k*σ, 否则0。 D_i=1表示冲突发生。通过分析D_i的模式，可推断受害者内存访问模式（如哪些纹理被采样）。

空间分辨率：可区分不同缓存组（即不同的内存地址范围）的访问。时间分辨率：受GPU内存访问延迟和计时精度限制，通常在纳秒级。信噪比：受GPU工作负载、缓存替换策略、系统噪声影响。

计算机体系结构（缓存层次、地址映射）、统计信号检测、假设检验。

场景：公有云GPU实例（如NVIDIA A100 vGPU）上，跨VM推断邻户的机器学习模型激活、渲染场景特征或商业敏感数据。特征：无特权、跨VM、对细粒度内存访问敏感、防御困难。

addr: GPU虚拟/物理地址。 S: GPU L2缓存组数量。 b: 缓存行大小对数（如6对应64字节）。 t_access: 单次内存访问计时测量值。 T_hit, T_miss: 缓存命中/未命中基准时间。 σ: 计时噪声的标准差。 k: 检测阈值倍数（如3）。 D_i: 二值检测结果。

集合与映射：地址到缓存组的映射函数。概率与统计：计时值的分布，假设检验（如Z检验）。信号处理：时间序列滤波与峰值检测。优化：缓冲区布局优化以最大化缓存组覆盖。

1. 攻击者初始化：分配和“预热”缓冲区A，使其填满所有L2缓存组。测量基线时间T_hit。 2. 监测循环： for i in 0 to N-1: a. 同步点（可选，通过共享内存或网络与受害者协调时序）。 b. 快速连续测量缓冲区A中所有行的访问时间，得到向量t_vec。 c. 计算每个缓存组的平均访问时间t_avg[set]。 d. 标记t_avg[set] > threshold的缓存组为“被驱逐”。 3. 后处理：将“被驱逐”的缓存组序列与受害者潜在操作（如纹理读取、矩阵乘法）的已知内存访问模式进行相关性分析，推断受害者活动。

信息流：受害者GPU内核内存访问 -> 引起特定L2缓存组的状态变化（驱逐）-> 影响攻击者对应缓存组的命中率 -> 体现为攻击者测量到的访问时间延迟 -> 攻击者从时间延迟模式反推受害者的内存访问地址模式。这是一个通过共享缓存状态传递信息的隐蔽信道。

硬件：防御： GPU硬件需支持缓存分配技术（如GPU Cache Partitioning）或完全虚拟化缓存。攻击端需要能进行高精度计时（如GPU时钟计数器）。软件： Hypervisor或GPU驱动需实现缓存隔离或添加噪声（随机延迟）。对用户透明，但可能影响性能。

Safety-D1-0041

应用安全

图形渲染/Web

WebGL 2.0 计算着色器资源探测

基于计算着色器最大工作组数量的硬件指纹

1. 原理： WebGL 2.0 引入了计算着色器，其最大工作组数量（gl.MAX_COMPUTE_WORK_GROUP_SIZE）和最大工作组调用数量（gl.MAX_COMPUTE_WORK_GROUP_INVOCATIONS）是硬件和驱动相关的限制。这些值构成稳定的指纹。 2. 特征提取： a. 查询上述WebGL常量。 b. 执行基准测试计算着色器，测量在不同工作组配置下的执行时间。例如，运行一个简单的并行归约内核，改变工作组大小[x, y, z]，测量GPU时间。 c. 性能特征向量P = [t_1, t_2, …, t_m]，其中t_i是第i种配置下的执行时间。 3. 指纹生成：将查询的常量与性能特征向量拼接，形成一个综合特征向量F = [C; P]。可进一步哈希（如SHA-256）得到一个紧凑的指纹H(F)。

唯一性：在桌面GPU中区分度高，移动GPU同质化较高。稳定性：驱动程序更新可能改变性能特征，但常量值通常稳定。

性能基准测试、硬件特性探测、哈希函数。利用硬件规格和微架构性能差异。

场景：网页端跨浏览器会话的用户追踪、反机器人（识别真实GPU而非模拟器）。特征：利用现代WebGL特性、比传统Canvas指纹更持久、可与其他指纹结合。

gl.MAX_…: WebGL常量，三维整数向量或标量。 t_i: 在特定工作组配置下的计算着色器执行时间（纳秒）。 F: 原始特征向量。 H: 哈希函数（如SHA-256）。 fingerprint: 最终指纹，哈希值。

向量：特征向量的构成。计量学：时间测量精度。哈希：将高维特征映射为固定长度摘要。

1. 初始化WebGL 2上下文。 2. 查询常量： size = gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_SIZE); invoc = gl.getParameter(gl.MAX_COMPUTE_WORK_GROUP_INVOCATIONS)。 3. 编译基准计算着色器。 4. 性能测试循环：对一组预定义的工作组配置configs，执行： a. 绑定着色器，设置统一变量。 b. 使用gl.beginQuery/gl.endQuery测量时间。 c. 分发计算调用：gl.dispatchCompute(numGroupsX, numGroupsY, numGroupsZ)。 d. 获取查询结果，记录时间t。 5. 构建特征向量 F = [size[0],size[1],size[2], invoc, t1, t2, …]。 6. 哈希： fingerprint = SHA256(F)。

控制流： JS -> WebGL API调用 -> GPU驱动 -> GPU执行计算着色器 -> 返回查询结果和时间。数据流：硬件限制常量和性能测量值作为“响应”，构成指纹。这是一种主动探测式的信息收集流。

硬件：依赖GPU硬件对计算着色器的支持和具体性能特性。软件模拟（如SwiftShader）会暴露不同特征。软件：几行JavaScript即可实现。防御手段有限：用户可禁用WebGL；浏览器可考虑对常量查询返回模糊化或标准化的值，并对计时器进行降精度处理。

Safety-D1-0042

软件安全

字体渲染/操作系统

字形轮廓指令解释器整数溢出

TrueType指令MIAP（移动并执行指令）中的算术溢出

1. 漏洞点： TrueType解释器执行MIAP指令时，用于计算控制点坐标的中间值可能发生整数溢出。具体地，在将缩放后的距离（FUnits）转换为像素时，计算公式涉及大整数乘法和除法。 2. 触发条件：恶意字体文件包含一个特别设计的字形轮廓。在MIAP指令中，操作数rP（参考点）和cvt（控制值表索引）被精心构造，使得计算出的distance = cvt[arg] * scale / ppem时发生32位有符号整数溢出。其中scale是缩放因子， ppem是每em像素数。 3. 内存破坏：溢出的distance值被用于计算目标点坐标： point[p].x = point[rP].x + distance(或y坐标)。这个溢出后的错误坐标值可能极大或为负，导致后续内存访问越界，例如在访问点数组points[]时使用该坐标作为索引，或导致后续图形指令在异常大的画布上操作，引发堆损坏。

严重性：可导致远程代码执行，当字体被自动渲染时（如文档预览、网页字体）。利用复杂度：需绕过现代操作系统的缓解措施（ASLR, DEP），但字体渲染器常以高权限运行。

整数算术、溢出语义、自动机状态（字体指令解释）。本质是算术运算未检查边界。

场景：恶意文档、网页字体（@font-face）、系统字体目录下的恶意字体文件可触发。特征：文件格式攻击、针对复杂的状态机解释器、影响广泛（Windows/macOS/Linux）。

rP: 参考点索引。 cvt[]: 控制值表。 scale: 当前变换的缩放因子（26.6固定点数）。 ppem: 像素每em（整数）。 distance: 计算出的距离，可能溢出。 point[]: 轮廓点坐标数组。

算术：有符号整数运算与溢出（a * b / c可能溢出 a*b）。离散：数组索引计算。构造：构造输入使中间乘积超过INT_MAX。

1. 字体加载与解析。 2. 解释MIAP指令： a. 从cvt表中加载值val = cvt[arg]。 b. 计算distance = (val * scale) / ppem。漏洞点： val * scale可能超过32位有符号整数范围。 c. 取参考点(x_rP, y_rP)。 d. 计算目标点坐标： x_target = x_rP + distance。 e. 将目标点移动到计算出的坐标。 3. 后续操作：使用这个错误（极大/极小）的坐标值进行后续绘图或点操作，可能导致越界内存访问，破坏堆结构，最终可能允许代码执行。

数据流：恶意字体数据 -> 解释器加载cvt值和参数 -> 执行脆弱算术运算 -> 产生溢出的distance-> 用于计算坐标 -> 异常坐标导致越界内存访问。控制流被畸形数据引导至错误的计算路径，产生毒害的中间结果。

硬件：无特殊需求。防御可借助整数溢出检查指令（如果CPU支持）。软件：漏洞存在于FreeType等库中。修复：在乘法前检查是否溢出，或使用64位中间值进行计算。使用模糊测试（如oss-fuzz）是发现此类漏洞的关键。

Safety-D1-0043

系统安全

虚拟化/图形

vGPU 媒体引擎共享攻击

通过视频编解码引擎的跨VM干扰

1. 威胁模型：现代GPU包含专用的视频编解码硬件单元（如NVIDIA NVENC/NVDEC）。在虚拟化环境中，这些单元可能在vGPU间共享。 2. 攻击原理： a. 资源耗尽：攻击者VM发起大量视频编码/解码请求，占用所有可用的编解码会话槽位或硬件队列，导致受害者VM无法使用该功能，造成服务降级。 b. 计时侧信道：视频编解码任务执行时间与输入内容（复杂度）相关。攻击者可以测量自己编解码任务的完成时间。如果编解码单元被共享，受害者VM的编解码任务会与攻击者任务竞争硬件资源，导致攻击者任务执行时间延长。通过分析时间变化，可能推断受害者任务的某些特征（如视频复杂度）。 3. 数学模型：设编解码单元有C个并发通道。攻击者发起N_a个任务，受害者有N_v个任务。任务服务时间S。总负载ρ = (N_a + N_v) * E[S] / C。当ρ > 1时，队列形成，平均等待时间W = ρ * E[S] / (C*(1-ρ))（M/M/C排队模型近似）。攻击者测量到的任务总时间T = S + W会受N_v影响。

影响：可导致视频转码、流媒体服务性能下降。侧信道信息有限。检测难度：资源耗尽在配额内可能被视为合法高负载。

排队论、资源共享、性能干扰。利用固定功能硬件的共享和有限并发性。

场景：云游戏、云视频编辑、实时流媒体处理等依赖GPU编解码的vGPU实例。特征：针对专用硬件单元、可能影响服务质量、侧信道带宽较低。

C: 编解码硬件单元的最大并发通道数。 N_a, N_v: 攻击者和受害者VM的活动任务数。 S: 单个编解码任务的服务时间（随机变量）。 ρ: 系统总负载。 W: 任务在队列中的平均等待时间。 T: 测量到的任务端到端延迟。

排队论： M/M/C模型，利特尔定律。概率：服务时间的分布。优化：在资源限制下最大化干扰。

1. 攻击者VM：启动一个循环，不断提交视频编码任务（如将小帧编码为H.264），并高精度测量每个任务的完成时间T_i。 2. 监测阶段：在受害者VM不活跃时，建立T_i的基线分布。 3. 攻击阶段：当推测受害者VM开始使用编解码器时（如通过其他侧信道或定时触发），继续测量T_i。 4. 分析：比较攻击阶段与基线阶段的T_i分布（如比较均值、尾部延迟）。如果T_i显著增加且方差变大，表明存在资源竞争，即受害者正在使用编解码器。更精细的分析可能推断受害者负载的强度。

资源流：编解码硬件单元的处理能力被攻击者和受害者的任务流共享。攻击者通过测量自己任务流的延迟变化来探测共享资源上的“流量”变化，从而感知受害者的活动。这是一种基于竞争的性能干扰侧信道。

硬件：防御： GPU硬件应为每个vGPU提供独立的编解码引擎或严格的硬件分区。攻击端需要能提交编解码任务并高精度计时。软件： Hypervisor或驱动需监控编解码资源使用，实施公平调度和配额。对用户透明，但分区可能增加硬件成本。

Safety-D1-0044

应用安全

音频处理/语音合成

针对文本到语音系统的对抗攻击

生成对抗性文本输入使TTS输出错误语音

1. 目标：给定一个文本到语音系统TTS(text) -> audio，寻找一个对抗文本text_adv，使得： a. 语义保留： text_adv对人类阅读者与原始目标文本text_target含义相同或相似。 b. 语音错误： TTS(text_adv)生成的音频，被自动语音识别系统ASR转录时，结果ASR(TTS(text_adv))不等于（或包含）预期的text_target，而是攻击者希望的text_malicious。 2. 攻击方法（基于梯度）：如果TTS和ASR可微分（白盒），可将它们拼接，构建管道F(text) = ASR(TTS(text))。攻击目标是最大化F(text)输出text_malicious的概率，同时最小化text与text_target的编辑距离。这是一个离散优化问题，可使用梯度估计（如Gumbel-Softmax）或基于搜索的方法（如遗传算法）求解。 3. 人类不可感知约束：对抗文本text_adv应看起来自然，可通过同义词替换、插入不可见字符（零宽字符）、或利用TTS系统的分词/发音规则中的歧义来实现。

攻击成功率：对先进的神经TTS+ASR管道，在控制修改程度下，可实现>50%的误识别率。隐蔽性：对抗文本看起来基本正常，但可能包含不寻常的字符或拼写。

自然语言处理、对抗性机器学习、离散优化。利用TTS系统的文本规范化、分词和发音模型的脆弱性。

场景：攻击语音助手（如通过短信触发TTS读出来执行命令）、篡改自动播报系统（如公共交通、 IVR）、生成误导性音频内容。特征：数字攻击、需要模型访问（白盒/黑盒）、跨模态（文本->语音->文本）。

text_target: 人类期望听到的文本。 text_malicious: 希望ASR识别出的恶意文本。 text_adv: 对抗性文本输入。 TTS: 文本到语音模型（可微分）。 ASR: 自动语音识别模型（可微分）。 F: 串联模型。 edit_distance: 文本编辑距离（如Levenshtein距离）。

优化：在离散空间（文本）中寻找对抗样本。自然语言：语义相似性度量。概率：使用Gumbel-Softmax近似离散分布的梯度。

1. 模型准备：获取或训练可微分的TTS和ASR模型。 2. 初始化： text_adv = text_target。 3. 迭代优化： for step in 1 to N: a. 将text_adv转换为词嵌入序列E。 b. 前向传播计算损失： L = L_asr( F(E) , text_malicious ) + λ * L_sim( E, embed(text_target) )。 c. 计算梯度∇_E L。 d. 使用Gumbel-Softmax或投影梯度下降更新E，并将其映射回词汇表，得到新的text_adv（可能包含[UNK]占位符）。 e. 对text_adv进行后处理，用词典中的合理词汇替换[UNK]，确保文本通顺。 4. 验证：将text_adv输入实际TTS系统，用ASR测试，确认攻击成功。

信息流：对抗文本text_adv-> TTS系统（文本规范化、声学模型、声码器）-> 合成语音波形 -> ASR系统（声学模型、语言模型）-> 识别文本text_out。攻击者通过逆向传播梯度，从目标text_malicious反向调整text_adv的表示，使得在通过复杂管道后，输出发生偏离。

硬件：生成对抗文本需要GPU进行梯度计算。执行攻击只需播放文本（如短信）。软件：需要白盒访问TTS和ASR模型。防御：对输入文本进行严格的规范化、过滤异常字符、使用对抗训练增强TTS模型的鲁棒性、在TTS和ASR之间加入一致性校验（如文本重新合成并比较）。

Safety-D1-0045

系统安全

容器/虚拟化

利用cgroupsrelease_agent的容器逃逸

cgroup notify_on_release 机制滥用

1. 背景： Linux cgroup的release_agent特性允许在cgroup中所有进程退出时，执行一个用户指定的脚本。该脚本路径由cgroup.procs文件的上层目录的release_agent文件指定。 2. 攻击前提：容器内具有挂载cgroup文件系统的能力（通常需要SYS_ADMIN），且能以root身份写入release_agent文件。 3. 攻击步骤： a. 在容器内挂载cgroup文件系统： mount -t cgroup -o rdma cgroup /mnt/cgrp。 b. 在挂载点下创建子cgroup： mkdir /mnt/cgrp/x。 c. 启用release_agent：向/mnt/cgrp/release_agent写入一个脚本路径，该脚本将在宿主机上执行。例如，写入/cmd。注意，这个路径是宿主机根文件系统下的路径。 d. 通知cgroup在退出时执行agent：向/mnt/cgrp/x/notify_on_release写入1。 e. 将容器内sh进程的PID写入/mnt/cgrp/x/cgroup.procs。这使得sh进程加入这个新cgroup。 f. 退出容器内的sh进程（如执行exit）。由于cgroup x中所有进程退出，触发release_agent机制。内核将在宿主机的上下文中执行/cmd脚本。 g. 攻击者可提前在容器内通过某种方式（如写文件到挂载的卷）在宿主机的/cmd路径放置恶意脚本。

严重性：容器内root -> 宿主机root命令执行，完全逃逸。利用条件：需要容器以–privileged运行或具有SYS_ADMIN能力，并允许挂载cgroup。

Linux cgroup机制、内核事件通知。滥用cgroup的管理功能在宿主机执行代码。

场景：错误配置的Docker容器（特别是允许特权模式）、某些CI/CD环境。特征：本地权限提升、利用合法但危险的内核特性。

/mnt/cgrp: 容器内挂载的cgroup文件系统路径。 /mnt/cgrp/release_agent: 指定触发时执行的脚本路径（宿主机路径）。 /mnt/cgrp/x/notify_on_release: 控制是否触发release_agent的标志文件。 /mnt/cgrp/x/cgroup.procs: 将进程PID加入该cgroup的文件。 PID_sh: 容器内shell进程的PID。

系统编程：文件系统操作、进程管理。逻辑：条件触发（进程退出 -> 执行脚本）。构造：通过文件系统操作设置触发链。

1. 容器内获取root。 2. 挂载cgroup fs： mount -t cgroup -o rdma cgroup /mnt/cgrp。 3. 创建子cgroup： mkdir /mnt/cgrp/x。 4. 设置release_agent： echo ‘/cmd‘ > /mnt/cgrp/release_agent。 5. 启用通知： echo 1 > /mnt/cgrp/x/notify_on_release。 6. 将shell加入cgroup：找出当前shell的PID， echo $PID > /mnt/cgrp/x/cgroup.procs。 7. 准备Payload：确保宿主机/cmd文件存在且包含恶意命令（如反弹shell）。这可能需要通过绑定挂载等方式提前植入。 8. 触发：退出当前shell进程（exit）。内核检测到cgroup x为空，执行宿主机上的/cmd脚本。

控制流：容器内进程（shell）退出 -> 内核cgroup子系统检测到cgroup变空 -> 检查notify_on_release-> 读取release_agent路径 -> 在宿主机上下文中执行该路径指定的脚本。这是一个从容器内事件到宿主机动作的逃逸流。

硬件：无特殊需求。软件：漏洞源于cgroup特性的危险默认设置或过度授权。防御：禁止容器使用–privileged，降低能力（drop SYS_ADMIN），使用Seccomp过滤mount系统调用，或使用容器运行时（如containerd）的默认安全配置，其通常禁用该特性。

Safety-D1-0046

密码学应用

多媒体/视频水印

抗几何攻击的视频水印

基于尺度不变特征变换（SIFT）特征点的水印

1. 挑战：视频在遭受旋转、缩放、平移（RST）等几何攻击后，基于固定位置（如空间域、DCT块）的水印会失效。 2. 原理：利用SIFT在视频帧中提取稳定的关键点。这些关键点对RST变换具有部分不变性。以关键点为中心的局部区域（如圆形邻域）作为水印嵌入域。 3. 嵌入： a. 对原始视频帧I，检测SIFT关键点{kp_i}。选择一部分稳定且分布均匀的关键点作为宿主。 b. 对每个选定的关键点kp，提取其周围的圆形区域R，变换到对数极坐标L。这种变换将旋转和缩放转换为平移，便于处理。 c. 在L的幅度谱（通过DFT）的中间频带嵌入水印比特，使用扩频或QIM技术。 d. 逆变换回空间域，将修改后的区域插值回原帧。 4. 检测：对可能受攻击的视频帧I_att，同样检测SIFT关键点。通过关键点描述子匹配，找到与原始帧对应的关键点对。对每个匹配的关键点区域，进行同样的对数极坐标变换和DFT，从中检测水印比特。通过多数表决从多个关键点恢复完整水印。

鲁棒性：可抵抗一定程度的旋转（±15°）、缩放（0.5-2倍）、平移、裁剪以及压缩。容量：水印容量与关键点数量正相关，但过多会影响不可见性。

计算机视觉（特征检测、匹配）、信号处理（傅里叶变换、对数极坐标映射）、扩频通信。

场景：需要抵抗编辑、格式转换的版权保护视频水印。特征：对几何攻击鲁棒、计算复杂、检测需要原始视频特征点信息（非盲）。

I: 原始视频帧。 kp_i: SIFT关键点，包含位置(x,y)，尺度σ，方向θ。 R: 以关键点为中心的圆形区域。 L: 对数极坐标表示。 F: L的傅里叶变换幅度谱。 w: 待嵌入的水印序列。

几何变换：旋转、缩放、平移的数学表示。图像处理： SIFT算法，对数极坐标变换， DFT。检测理论：多数表决解码。

嵌入： 1. 对关键帧提取SIFT关键点，筛选出稳定的点集K。 2. 对每个kp in K： a. 提取圆形区域R。 b. 将R映射到对数极坐标L。 c. 计算L的2D-DFT得到F。 d. 在F的选定频带系数C上使用QIM嵌入水印比特： C‘ = Q_w(C)。 e. 2D-IDFT逆变换回L‘。 f. 逆对数极坐标映射回R‘。 g. 将R‘插值回原帧位置。检测： 1. 对待测帧提取SIFT关键点。 2. 与原始关键点描述子数据库进行匹配，得到匹配对。 3. 对每个匹配对，在待测帧上提取对应区域，经相同变换得到F_att。 4. 从F_att的相应频带解调水印比特。 5. 对所有匹配对解调的比特进行投票，得到最终水印序列。

信息流：水印比特 -> 被调制到多个稳定关键点区域的频域 -> 经受攻击（RST等） -> 在检测端，通过特征点匹配重新定位这些区域 -> 从频域解调比特 -> 聚合投票恢复水印。水印信息“锚定”在视频内容的视觉特征上，随特征一起经历几何变换。

硬件： SIFT计算和DFT/IDFT计算密集，需要CPU/GPU加速。实时嵌入/检测有挑战。软件：实现SIFT（如OpenCV），对数极坐标变换，频域水印嵌入/检测算法。需处理视频编解码。

Safety-D1-0047

软件安全

BIOS/固件更新

固件更新映像回滚漏洞

利用版本号比较逻辑缺陷的降级攻击

1. 安全策略：固件更新程序应检查新映像的版本号V_new是否大于当前版本V_current，即V_new > V_current，否则拒绝降级，防止回滚到有漏洞的旧版本。 2. 漏洞模式：版本号比较逻辑存在缺陷。例如： a. 字符串比较误用：将版本号当作字符串进行字典序比较，如“10.0” < “2.0”，因为‘1‘ < ‘2‘。 b. 整数溢出/回绕：版本号以整数存储，如16位无符号整数。当前版本V_current = 65535，攻击者提交V_new = 0（或1）。由于0 < 65535，本应拒绝。但如果比较逻辑是(int16_t)(V_new – V_current) > 0，则0 – 65535在16位有符号整数下等于1（因为回绕），错误地认为V_new > V_current。 c. 多部分版本解析错误：对A.B.C.D格式，解析时可能错误地只比较了主版本号A，忽略了次要版本。 3. 利用：攻击者构造一个版本号V_mal，其数值在漏洞逻辑下被认为大于V_current，但实际上代表一个更旧的、有已知漏洞的固件版本。更新程序接受并刷入V_mal，系统被回滚。

严重性：允许攻击者将设备固件降级到易受攻击的版本，从而利用旧漏洞获得控制权。普遍性：在嵌入式设备、 IoT设备中常见，由于开发人员安全意识不足。

软件工程（版本比较语义）、整数运算、字符串处理。比较逻辑的完备性与正确性。

场景：路由器、摄像头、智能设备等IoT设备的固件更新机制。特征：逻辑漏洞、可远程触发（如果更新可远程发起）、危害持久。

V_current: 当前固件版本号（字符串或整数）。 V_new: 新固件映像声称的版本号。 V_mal: 攻击者构造的恶意版本号。 compare(): 有漏洞的版本比较函数。

字符串比较：字典序与数值序的差异。整数运算：有符号/无符号，溢出语义。逻辑：比较谓词的正确性。

1. 攻击者准备：获取一个包含已知漏洞的旧固件映像，并修改其文件头中的版本号字段为V_mal，该值利用漏洞可被比较函数判断为“更新”。 2. 发起更新：通过Web界面、本地工具或网络协议向目标设备提交伪造的更新包。 3. 更新程序验证：验证数字签名（通常通过）。然后调用if (compare(V_mal, V_current) <= 0) { abort(); }。由于漏洞，此检查通过。 4. 刷写：更新程序将旧固件写入闪存。 5. 重启：设备重启，运行有漏洞的旧固件，攻击者随后可利用该漏洞。

控制流：更新请求 -> 验证签名 -> 版本检查（有漏洞）-> 检查通过 -> 擦写闪存 -> 重启运行旧固件。攻击者通过提供畸形的版本号数据，绕过了本应坚固的“版本递增”策略检查点。

硬件：无特殊需求。防御需在引导加载程序中实现正确的版本比较。软件：修复：使用安全的版本比较库，将版本号解析为定长的整数元组（如(major, minor, patch, build)）并进行逐分量比较。实现抗回滚的单调计数器是更根本的解决方案（见D1-0030）。

Safety-D1-0048

应用安全

文本显示/PDF渲染

PDF嵌入式JavaScript代码执行

利用PDF阅读器JavaScript引擎的漏洞

1. 攻击面： PDF标准支持嵌入JavaScript，用于表单交互等。阅读器（如Adobe Acrobat, Foxit）内置JavaScript引擎（如SpiderMonkey的旧版本）。 2. 漏洞模式： a. JavaScript引擎漏洞：引擎本身存在内存损坏漏洞（如UAF，类型混淆）。恶意PDF中的JavaScript代码可以触发这些漏洞。 b. 不安全的API暴露： PDF JavaScript API提供了访问文件和系统的危险方法（如File.saveAs, Doc.mailDoc）。结合社会工程，可诱骗用户执行操作。 c. 逻辑漏洞：通过JavaScript禁用阅读器的安全警告，或自动执行恶意动作。 3. 利用链示例：恶意PDF包含一段JavaScript，其中： i. 创建一个大的ArrayBuffer。 ii. 通过精心操作，导致对该ArrayBuffer的引用被释放后仍被使用（UAF）。 iii. 重用释放的内存，植入Shellcode。 iv. 通过漏洞获得代码执行，可能加载第二阶段恶意软件。

严重性：打开恶意PDF即可自动执行代码，无需用户交互（除打开文件外）。影响范围：影响广泛使用的PDF阅读器，是常见的攻击向量。

浏览器安全（JavaScript引擎安全）、内存安全、文件格式解析。

场景：鱼叉式钓鱼邮件附件、恶意网站上的PDF下载。特征：文件类型攻击、利用阅读器丰富的功能、常与漏洞利用套件结合。

PDF: 恶意PDF文件，包含嵌入式JavaScript。 JS_Engine: PDF阅读器内的JavaScript引擎（如SpiderMonkey）。 ArrayBuffer: JavaScript中的二进制数据缓冲区对象。 UAF: 释放后使用漏洞原语。

内存模型：堆布局，释放后使用。编程语言： JavaScript语法与引擎内部表示。构造：利用脚本操作触发底层漏洞。

1. 文档打开：用户使用易受攻击的阅读器打开恶意PDF。 2. JavaScript执行：阅读器解析PDF，发现嵌入式JavaScript动作，并在文档打开时自动执行（或由页面事件触发）。 3. 触发漏洞： JavaScript代码执行一系列堆操作（分配、释放、重用），精确触发引擎中的内存损坏漏洞（如UAF）。 4. 控制流劫持：漏洞导致程序计数器被攻击者控制，跳转到攻击者植入的Shellcode（可能通过ROP链）。 5. 权限提升与持久化： Shellcode执行，可能以用户权限下载并运行恶意软件，或尝试提权。

信息流：恶意PDF文件 -> 阅读器解析并加载 -> JavaScript引擎解释执行恶意脚本 -> 脚本操作触发底层引擎漏洞 -> 内存损坏导致控制流劫持 -> 执行攻击者代码。恶意逻辑隐藏在文档的合法功能（JavaScript）中，在解释执行时释放。

硬件：无特殊需求。 DEP/ASLR可增加利用难度。软件：防御：禁用PDF中的JavaScript（在阅读器设置中）、保持阅读器更新至最新版本、使用沙箱运行阅读器（如Chrome内置PDF阅读器）、在虚拟机或受限环境中打开不受信任PDF。

Safety-D1-0049

系统安全

虚拟化/IOMMU

DMA重映射保护配置错误

缺失或错误的IOMMU映射导致DMA攻击

1. DMA攻击：具有总线主控能力的外设（如网卡、 NVMe SSD、 GPU）可以直接读写系统内存，此过程称为DMA。恶意或受控的外设可通过DMA写入或读取任意物理内存，绕过CPU的页表保护。 2. IOMMU防御：输入输出内存管理单元在设备和内存之间，将设备发起的DMA请求中的设备地址DVA转换为主机物理地址HPA，并检查权限。需要为每个设备创建独立的地址转换表（IOMMU页表）。 3. 配置错误模型： a. IOMMU未启用：系统BIOS/操作系统未启用IOMMU（VT-d/AMD-Vi），设备可直接访问所有物理内存。 b. 映射过宽：设备被映射到过大的地址范围，包含了不应访问的内存（如内核代码）。例如，映射了整个[0, 4GB)区域，而不是仅为设备驱动分配的缓冲区。 c. 缺少映射：关键设备（如内置GPU）未被IOMMU管理，成为攻击入口。 d. 权限错误：为设备映射设置了错误的权限，如允许写入只读区域。 4. 利用：攻击者通过已控制或有漏洞的设备，发起指向敏感内存区域的DMA读写请求。由于IOMMU配置错误，请求被放行，导致内核数据泄露、篡改或控制流劫持。

严重性：可导致从普通用户权限或通过外设直接获得内核代码执行能力。普遍性：在服务器和桌面系统中， IOMMU配置错误或驱动未正确使用IOMMU的情况并不罕见。

内存管理、硬件虚拟化、访问控制。 IOMMU应为每个设备提供最小权限映射。

场景：云服务器中，恶意租户通过分配给其的PCIe设备（如直通GPU）攻击宿主机或邻户。本地攻击者通过有漏洞的驱动程序或恶意USB设备发起攻击。特征：利用硬件特性、需要设备访问权、可绕过软件安全机制。

DVA: 设备虚拟地址（设备视角的地址）。 HPA: 主机物理地址。 IOMMU_PT: IOMMU页表，存储DVA->HPA映射及权限位（R/W）。 Device_BDF: 设备的总线-设备-功能号，用于标识。

映射：地址转换映射关系。集合：允许访问的物理地址集合。权限：读、写权限位。

1. 侦察：攻击者（在VM内或本地）枚举PCI设备，检查IOMMU状态（如通过dmesg， /sys/class/iommu）。 2. 设备控制：通过驱动漏洞或恶意固件获得对目标PCIe设备的控制权。 3. 构造恶意DMA请求：编程设备DMA引擎，使其发起对特定DVA的读写操作。攻击者推测或探测到该DVA可能映射到敏感HPA（如内核代码段）。 4. 触发DMA：启动设备DMA传输。 5. IOMMU处理： IOMMU接收请求，查找Device_BDF对应的页表，翻译DVA。由于配置错误（如映射缺失或过宽），翻译成功并获得对敏感HPA的访问权限。 6. 内存访问： DMA操作直接读/写目标物理内存，攻击完成。

数据流：恶意设备 -> 发起DMA请求（DVA, R/W）-> IOMMU -> （检查页表）-> 访问主机物理内存HPA。控制流被设备硬件驱动，绕过CPU的软件执行流。配置错误使得本应被拦截的非法数据流得以通过。

硬件：必须启用IOMMU（在BIOS中）。硬件需支持中断重映射和ACS以隔离设备。软件：操作系统内核和设备驱动必须正确使用IOMMU API（如Linux的dma_map_*函数），为每个DMA缓冲区创建精确的映射，并在使用后解除映射。虚拟化中，需为直通设备正确配置IOMMU。

Safety-D1-0050

密码学应用

机器学习/云AI服务

针对图像分类模型的模型提取攻击

通过黑盒查询重建替代模型

1. 目标：云AI服务（如AWS Rekognition, Google Vision）提供付费的图像分类API。攻击者希望复制（窃取）其模型F，而无需训练成本或访问模型内部。 2. 攻击方法： a. 查询：攻击者向黑盒API提交大量输入图像x_i，获得预测结果（如top-5标签及置信度）y_i = F(x_i)。 b. 合成数据集：构建一个合成数据集D = {(x_i, y_i)}。 c. 训练替代模型：使用D训练一个本地模型G_θ，目标是使G_θ的行为与F尽可能相似，即最小化损失L(θ) = Σ_i l(G_θ(x_i), y_i)，其中l可以是交叉熵损失（利用置信度）或仅标签的0-1损失。 d. 主动学习：为了高效，攻击者可以使用主动学习策略选择信息量大的x_i进行查询，例如选择G_θ预测不确定性高的图像，或使用对抗样本生成技术创建“困难”样本。 3. 提取评估：评估替代模型G_θ与原始模型F在保留测试集上预测的一致性（如准确率匹配度）。高一致性表明提取成功。

提取质量：替代模型G_θ在功能和精度上可接近原始模型F（如>90%的一致性）。查询成本：需要数千至数百万次查询，取决于模型复杂度和攻击算法效率。

机器学习、优化、查询复杂性。将模型视为可通过输入-输出对近似的函数。

场景：窃取商业AI模型知识产权、规避API查询费用、为后续对抗攻击做准备。特征：黑盒攻击、需要大量查询、可能违反服务条款。

F: 目标黑盒模型（云API）。 x_i: 查询输入（图像）。 y_i: API返回的预测（标签+置信度）。 G_θ: 替代模型（如ResNet），参数θ。 L: 训练损失函数。 N: 查询预算。

优化：最小化预测差异损失。主动学习：基于不确定性的采样策略。近似理论：用有限样本近似函数。

1. 初始化：准备一个初始图像集（如ImageNet子集）。初始化一个替代模型架构G_θ。 2. 查询与收集： for i in 1 to N: 选择图像x（从初始集或由主动学习策略生成）；查询y = F(x)；将(x, y)加入数据集D。 3. 训练：每隔一定数量的新数据点，在累积的数据集D上训练（或微调）G_θ。 4. 主动选择：使用当前的G_θ，计算未查询图像的不确定性（如预测熵`H(y‘

x)），选择熵最高的图像作为下一批查询候选。 **5. 迭代**：重复步骤2-4，直到查询预算N用尽或G_θ的性能在验证集上收敛。 **6. 输出**：最终替代模型G_θ`。

信息流：攻击者生成或选择输入x_i-> 发送至云API -> 云API返回预测y_i-> 攻击者收集(x_i, y_i)对 -> 用于训练本地模型G_θ-> G_θ逐渐逼近F的行为。这是一个通过有限输入-输出观测来逆向工程目标函数的过程。

Safety-D1-0051

软件安全

云存储/数据去重

跨用户数据去重侧信道攻击

利用存储去重推断文件存在性

1. 背景：云存储服务（如Dropbox, Google Drive）使用数据去重技术，当多个用户上传相同文件时，只在后端存储一份副本。上传时，客户端计算文件哈希H(file)，如果服务器已存在该哈希，则只需增加一个引用，上传快速完成；否则需实际上传文件内容。 2. 攻击原理：攻击者可以推断目标用户是否存储了某个特定文件F_target。 a. 攻击者计算h = H(F_target)。 b. 攻击者尝试上传一个与F_target内容完全相同的文件（或具有相同哈希的文件）。 c. 测量上传时间T_upload。如果T_upload非常短（秒级），表明服务器已存在该哈希，即可能有其他用户（包括目标）已存储该文件。如果T_upload较长（需传输数据），则表明服务器上没有该文件。 d. 为了区分目标用户和其他用户，攻击者可能需要结合其他信息（如知道目标用户对某些敏感文件的兴趣）。 3. 概率模型：设目标用户拥有文件F_target的先验概率为P。观察到快速上传（去重命中）事件E。则后验概率`P(拥有

E) = (P * 1) / (P * 1 + (1-P) * q)，其中q是其他用户拥有该文件的概率。如果文件很稀有（q`很小），一次命中就能显著提高后验概率。

准确性：对于稀有文件，推断准确性高。对于常见文件（如Windows系统文件），推断无意义。误报：可能因其他用户拥有相同文件而导致误报。

信息论、概率论、性能侧信道。利用去重优化引入的时序差异。

场景：推断云存储用户是否拥有某些敏感文件（如泄露的文档、特定软件、媒体文件），用于侦察、勒索或验证数据泄露。特征：无特权攻击、远程、非侵入、但需要知道目标文件的确切内容。

F_target: 目标文件内容。 H: 加密哈希函数（如SHA-256）。 h: 文件哈希值。 T_upload: 文件上传耗时测量值。 T_fast, T_slow: 去重命中/未命中的典型上传时间阈值。 P, q: 概率参数。

概率：贝叶斯推断。计量学：时间测量与阈值比较。哈希函数：抗碰撞性。

1. 攻击者准备：获取或生成与目标文件F_target完全相同的副本F_copy。 2. 基线测量：上传一个已知服务器没有的文件，测量T_slow；上传一个已知服务器已有的常见文件，测量T_fast。确定阈值τ。 3. 探测：在适当的时机（如目标用户可能已上传后），攻击者发起对F_copy的上传请求，并精确测量从请求开始到收到成功响应的时间T。 4. 决策：如果T < τ，推断“文件存在”（去重命中）；否则推断“文件不存在”。 5. 重复：可对多个目标文件进行探测，绘制目标用户的存储画像。

信息流：攻击者发起上传请求（包含哈希h）-> 服务器检查哈希索引 -> 如果存在，快速返回成功（添加引用）；如果不存在，要求上传数据块 -> 攻击者从响应时间差异推断索引查找结果。文件的存在性信息通过优化路径（快速路径 vs 慢速路径）泄露。

Safety-D1-0052

系统安全

操作系统/系统调用

syscall序列异常检测

基于系统调用n-gram的入侵检测

1. 数据收集：在训练阶段，收集正常进程（如sshd, nginx）执行时产生的系统调用序列。每个进程生成一个序列S = [s1, s2, …, sn]，其中s_i是系统调用号（如open=2, read=0）。 2. 特征提取：将序列分割为重叠的长度为k的n-gram。例如，对于k=3，序列[2,0,1,3]产生n-gram： [2,0,1], [0,1,3]。统计所有正常进程中各n-gram的出现频率，形成一个概率模型或简单地将出现过的n-gram加入“正常集”N。 3. 检测：在线监控时，对目标进程的系统调用流进行滑动窗口（长度k）分析。对于窗口中的每个n-gram g，检查g是否在正常集N中。定义异常分数A = (在窗口中出现的不在N中的唯一n-gram数量) / (窗口中总唯一n-gram数量)。如果A超过阈值θ，则触发警报。 4. 参数选择： k通常为5-11。过小则缺乏上下文，过大则过于严格导致高误报。阈值θ通过验证集调整，平衡检测率和误报率。

检测率 (TPR)：对已知攻击（如缓冲区溢出导致shellcode执行）检测率高。误报率 (FPR)：受程序行为正常变异影响，需仔细调参以降低FPR。

自然语言处理（n-gram模型）、异常检测、序列分析。假设攻击会导致异常的系统调用模式。

场景：主机入侵检测系统（HIDS），保护关键服务器进程（如Web服务器， SSH）。特征：基于行为、可检测未知攻击（零日）、对性能有影响（需内核模块）。

S: 系统调用序列。 k: n-gram的长度。 g: 一个k-gram。 N: 训练得到的正常k-gram集合。 A: 异常分数（0到1）。 θ: 告警阈值。

序列分析：滑动窗口， n-gram生成。集合：正常集合的成员判断。统计：频率统计，阈值设定。

1. 训练阶段：对多个正常进程实例，通过内核模块或strace收集其系统调用轨迹，构建正常n-gram集合N。 2. 监控阶段：对目标进程PID，实时捕获其系统调用。 a. 维护一个长度为k的队列Q，存放最近的k个系统调用号。 b. 每当有新系统调用s_new进入：将s_new加入Q，如果Q已满（长度为k），则从Q中取出一个k-gram g。 c. 检查g是否在N中。如果不在，将其加入当前窗口的“异常gram列表”。 d. 每隔W个系统调用（或固定时间间隔），计算当前窗口的异常分数A。 e. 如果A > θ，生成告警，并可选择终止进程或进一步调查。

数据流：进程执行 -> 产生系统调用序列 -> 被监控组件捕获 -> 分割为n-gram -> 与正常模式库比对 -> 计算异常分数 -> 与阈值比较 -> 产生告警事件。正常行为形成“预期”的序列流，攻击行为导致“异常”的子序列出现。

硬件：对硬件无特殊需求，但内核模块监控会引入少量CPU开销。软件：需实现内核模块（如Linux Audit, eBPF）来捕获系统调用。需要收集和标注大量正常轨迹进行训练。模型需要针对每个守护进程单独训练。

Safety-D1-0053

硬件安全

显示接口/视频线缆

通过HDMI线缆的电磁辐射窃听

HDMI连接器的无意调制辐射

1. 物理原理： HDMI传输的是数字信号，但其高速差分对（TMDS通道）在切换时会产生高频电磁辐射。辐射的频谱特性与传输的像素数据相关。特别是，视频内容中的重复模式（如固定颜色的条纹、文本）会在特定频点产生较强的线谱。 2. 信号特征：对于1920×1080@60Hz的视频，像素时钟约148.5 MHz。辐射频谱可能包含此频率的谐波。图像内容对信号进行幅度调制。从辐射信号S(t)中，可以提取出与行同步、场同步对应的周期性成分。 3. 重建挑战：与模拟VGA不同， HDMI是数字编码，直接重建原始像素

编号

类别

领域

模型配方

定理/算法/模型/方法名称

定理/算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式和参数选择/参数优化

精度/密度/误差/强度

底层规律/理论定理

典型应用场景和各类特征

变量/常量/参数列表及说明

数学特征

时序和交互流程的所有细节/分步骤时序情况及数学方程式

流动模型和流向方法的数学描述

硬件设计/软件设计及资源

Safety-D1-0054

硬件安全

芯片设计/硬件木马检测

基于侧信道指纹的硬件木马检测

功耗/电磁旁路分析木马检测

1. 黄金模型建立：使用可信的芯片（“黄金样本”）在受控环境下，测量其执行特定密码操作（如AES加密）时的功耗轨迹 Pgold(t)或电磁辐射 EMgold(t,f)。收集大量轨迹，建立统计特征模型（如均值轨迹 μgold(t)，协方差矩阵 Σgold）。 2. 待测芯片测量：在相同条件下，测量待测芯片执行相同操作的功耗/电磁轨迹 Ptest(t)。 3. 特征提取与比对：常用方法： a. 模板攻击：计算待测轨迹与黄金模板的似然比。假设轨迹服从多元高斯分布，对数似然比 (\\Lambda = -\\frac{1}{2}[(P{test}-\\mu{gold})^T \\Sigma{gold}^{-1}(P{test}-\\mu_{gold}) + \\ln

\\Sigma_{gold}

] )。异常低的似然比表明存在木马。 b. 瞬时功耗差异：计算差分轨迹 ΔP(t)=Ptest(t)−μgold(t)。在无木马时， ΔP(t)应为零均值噪声。存在木马电路活动时，会在特定时间点 tk产生显著峰值。使用假设检验（如t检验）判断峰值是否显著： t-score=σ/NΔPtkˉ，其中 ΔPtkˉ是多次测量在 tk处的平均差分， σ是标准差， N是测量次数。 4. 参数优化：测量点数、对齐精度、滤波带宽、显著性水平 α（如0.01）。

检测率：对激活后功耗显著（如>5%额外功耗）的木马检测率高。误报率：受工艺偏差、环境噪声影响，需通过足够样本和统计方法控制。分辨率：可定位到时钟周期级的时间精度。

统计模式识别、信号处理、假设检验。硬件木马的额外电路活动会引入可测量的物理信号偏差。

场景：集成电路供应链安全，检测在第三方工厂或设计环节中被植入的硬件木马。特征：非侵入式、可现场检测、对小型或仅在特定条件下触发的木马不敏感。

P(t): 时间域的功耗轨迹向量。 EM(t,f): 时频域的电磁辐射信号。 μ, Σ: 黄金样本轨迹的均值向量和协方差矩阵。 Λ: 对数似然比。 ΔP(t): 差分功耗轨迹。 t-score: t检验统计量。 α: 显著性水平。

统计：多元高斯分布，假设检验，主成分分析（用于降维）。信号处理：轨迹对齐，滤波，特征提取。优化：检测阈值优化以平衡TPR和FPR。

1. 训练阶段：用黄金芯片，在固定输入和时钟下，采集N条功耗轨迹，计算 μgold和 Σgold。 2. 测试阶段：对待测芯片，采集M条轨迹，对齐到黄金模板。 3. 计算差异：对每条测试轨迹，计算 ΔPi(t)=Ptest,i(t)−μgold(t)。 4. 统计检验：对每个时间点t，计算M条差分轨迹在该点的均值 ΔPˉ(t)和标准差 s(t)，计算 t-stat(t)=s(t)/MΔPˉ(t)。 5. 决策：如果存在 t使得 (

Safety-D1-0055

应用安全

云文档协作/实时编辑

操作转换 (OT) 的一致性攻击

利用OT变换函数缺陷产生编辑冲突

1. OT背景：在实时协作编辑中，多个用户并发编辑文档。每个操作O（如“在位置p插入字符c”）在发送到服务器前被标记一个状态向量SV。服务器使用变换函数T处理并发操作，使得所有副本最终一致。 2. 攻击模型：攻击者作为一个恶意用户加入会话。目标是利用变换函数T的实现漏洞，使不同用户看到不同的最终文档状态，破坏一致性。例如，假设有两个并发操作： Oa=Insert(p,“X”)， Ob=Insert(p,“Y”)。正确的T应定义两者最终顺序（如按用户ID排序），结果应为“XY”或“YX”。有漏洞的T可能导致用户A看到“XY”，用户B看到“YX”。 3. 攻击步骤： a. 监听或预测其他用户的操作。 b. 精心构造一个并发操作 Omal，使其与目标用户的操作 Ovictim在变换时产生歧义。例如，利用涉及“删除”和“插入”位置计算的边界条件错误。 c. 快速连续提交 Omal，使得服务器和客户端在不同时间收到操作序列，触发不一致的变换路径。 4. 形式化：设文档状态为S，操作序列为 O1,O2,…,On。 OT要求对于任意并发操作 Oi,Oj，有 T(T(Oi,Oj),T(Oj,Oi))使得两者最终状态相同。攻击者寻找违反此等式的操作对。

影响：破坏协作文档的最终一致性，导致数据丢失、错乱，破坏服务可用性。条件：需要能够加入协作会话并提交编辑操作。

分布式系统理论、操作变换、一致性模型（如CRDT的挑战）。攻击变换函数的数学定义完备性。

场景： Google Docs, Office 365 在线协作等实时编辑服务。特征：逻辑攻击、针对核心算法、可能造成持久性数据损坏。

O: 编辑操作，可表示为元组 (type, pos, char, sv)。 T(Oa, Ob): 变换函数，返回在Ob之后应用的Oa的转换版本。 SV: 状态向量，表示操作所基于的文档版本。 S: 文档状态。

代数：操作变换的代数性质（交换律、结合律）。形式化验证：使用定理证明器验证变换函数属性。并发控制：操作序列的偏序关系。

1. 攻击者加入会话，获取当前文档状态和状态向量。 2. 预测受害者操作：通过界面观察或网络监听，推测受害者即将在位置p插入文本。 3. 构造恶意操作：攻击者快速在位置p（或p±ε）插入一个特殊字符，并确保其操作与受害者操作在服务器处被判定为并发（即基于相同的SV）。 4. 提交：几乎同时提交恶意操作和（或触发）受害者操作。 5. 服务器处理：服务器以某种顺序收到操作，应用变换函数T。由于漏洞， T对这两个操作的不同处理顺序产生了不同的结果。 6. 分发：服务器将变换后的操作分发给各客户端。由于变换结果不一致，不同客户端应用了不同的操作序列，导致状态分叉。

数据流：用户操作 -> 客户端OT引擎 -> 发送到服务器 -> 服务器OT引擎进行变换和广播 -> 各客户端接收并应用。攻击者注入恶意操作流，在服务器OT引擎的变换节点引发歧义，导致流出不同版本的操作流到不同客户端，破坏汇合的一致性。

硬件：无特殊需求。软件： OT算法实现（如ShareJS, ot.js）必须经过严格的形式化验证。防御：使用无冲突复制数据类型 (CRDT) 替代OT，或对OT变换函数进行形式化证明。实施操作验证和历史一致性检查。

Safety-D1-0056

系统安全

操作系统/内存管理

页表项 (PTE) 的滥用：页帧重用攻击

利用未初始化的页帧数据泄露内核信息

1. 背景：当物理页帧被释放后，其内容通常不会被清零，直到被重新分配和写入。内核的.text, .data段页面被释放后（如模块卸载），可能被重新分配给用户空间进程。 2. 攻击原理： a. 攻击者进程大量申请内存（如通过mmap），希望分配到刚被释放的、曾包含敏感内核数据的物理页帧。 b. 如果分配成功，攻击者可以读取该页面的原始内容，可能包含内核指针、栈数据、密码密钥等。 c. 为提高成功率，攻击者可以：先释放一个已知的内核对象（如可卸载模块），然后立即大量分配用户内存，增加“碰撞”概率。 3. 概率模型：设系统有M个物理页帧，攻击者一次分配N个页面。目标敏感页帧被释放后仍在空闲列表中的概率为1。攻击者至少分配到一页目标帧的概率约为 1−(1−M1)N。当N与M可比时，概率显著。

信息泄露：可泄露内核地址（破坏KASLR）、敏感数据结构内容、甚至密码学密钥。可靠性：成功率受内存分配器行为、系统负载影响，但通过大量分配可提高。

概率论、操作系统内存管理。利用内存隔离生命周期中的“释放-重用”窗口。

场景： Linux/Windows本地信息泄露，用于绕过KASLR或获取进一步利用所需的原语。特征：本地攻击、无特权、利用内存分配器的非确定性。

M: 系统物理页帧总数。 N: 攻击者一次性分配的用户页面数。 P_success: 至少分配到一个目标页帧的概率。 page_content: 分配到页面的原始字节数据。

概率：组合概率计算。内存管理：页帧分配算法（如伙伴系统）。逆向：从原始数据中解析有价值的信息。

1. 触发释放：通过某种方式（如卸载一个内核模块）导致包含敏感数据的物理页帧被释放回空闲列表。 2. 抢占分配：立即调用mmap(NULL, N*PAGE_SIZE, …)分配大量用户空间内存。内存分配器可能从空闲列表中分配出刚释放的页帧。 3. 扫描内容：遍历分配的内存区域，搜索特征模式（如内核指针值通常在高地址、具有特定对齐）。 4. 信息提取：提取找到的指针或数据，用于后续攻击（如计算内核基址）。

信息流：内核敏感数据驻留在物理页帧 -> 页帧被释放但未清零 -> 页帧被重新分配给用户进程 -> 用户进程读取页帧残留数据 -> 信息泄露。敏感数据通过物理页帧这个共享“载体”，从内核空间“流动”到了用户空间。

硬件：无特殊需求。软件：防御：在内核释放包含敏感数据的页帧时主动清零（memset_explicit）。或使用init_on_alloc/init_on_free内核特性强制清零所有空闲内存。这会带来性能开销。

Safety-D1-0057

密码学应用

云存储/可搜索加密

可搜索对称加密 (SSE) 的规模泄露

针对SSE的查询恢复攻击

1. SSE模型：客户端将加密文档集合C和加密索引I外包到云服务器。索引允许客户端提交加密查询q（对应关键词w），服务器返回包含w的文档ID，而不泄露w和文档内容。 2. 泄露概况：实际SSE方案会泄露一些元数据，如： a. 访问模式：对于查询q，服务器看到被访问的索引条目和返回的文档ID。 b. 搜索模式：相同查询q会产生相同的服务器访问模式，泄露哪些查询是相同的。 c. 规模模式：每个关键词w对应的文档数量（响应规模）`

DB(w)

。 **3. 攻击方法**：攻击者（云服务器）拥有对公开数据集（如英文维基百科）的统计知识：每个词w的文档频率df(w)`。攻击者观察一系列查询的响应规模序列 R=(r1,r2,…,rt)，其中 (r_i =

DB(w_i)

)。目标是找到映射π，将关键词w与观测到的响应规模r匹配，使得观测数据的似然性最大。这可以形式化为优化问题： (\\max{\\pi} \\prod{i} P(df(\\pi^{-1}(r_i))

r_i) )或使用图匹配算法，将查询规模与公开数据集的词频进行匹配。

恢复准确率：对具有独特频率的关键词恢复准确率高。对常见词（the, a）难以区分。总体可恢复~60%以上的查询。数据要求：需要公开的、与目标数据集相关的统计信息。

统计推断、图论（二分图匹配）、信息论。利用元数据泄露与公开统计的相关性。

场景：攻击基于SSE的加密邮件、加密云盘搜索功能，推断用户的搜索兴趣或文档内容。特征：被动攻击、仅利用方案固有泄露、对静态数据集有效。

Safety-D1-0058

应用安全

音频处理/声纹识别

针对声纹识别系统的欺骗攻击

录音重放与合成语音攻击

1. 攻击类型： a. 重放攻击：直接播放目标说话人的录音。 b. 语音合成：使用TTS合成目标说话人的语音，说出任意内容。 c. 语音转换：将攻击者语音转换为目标说话人的音色。 2. 检测挑战：声纹识别系统V提取语音特征F(x)（如MFCC, Spectrogram）并分类。欺骗攻击试图生成语音x_adv，使得F(x_adv)与目标说话人的特征分布P_target匹配，即最小化 d(F(xadv),Ptarget)，其中d是距离度量（如余弦相似度）。 3. 对抗样本生成：在白盒设置下，若V可微，可通过梯度下降生成对抗样本： xadv=x+ϵ⋅sign(∇xJ(V(x),ytarget))，其中J是损失函数， y_target是目标说话人标签。这需要在音频波形上添加人耳难以察觉的扰动。 4. 活体检测防御：防御系统D需要检测语音是否来自活人。特征包括： a. 频谱特征：录音设备与麦克风的频率响应差异，录音可能缺少某些高频成分或具有特定的频响曲线。 b. 相位特征：自然语音的相位信息与重放语音不同。 c. 调制特征：自然语音的幅度/频率调制特性。

欺骗成功率：对未经防御的系统，重放和高质量合成攻击成功率可>80%。防御性能：现代活体检测可将攻击接受率降至<5%。

信号处理、模式识别、对抗性机器学习。区分真实生物特征与伪造特征。

场景：声纹锁、电话银行身份验证、智能设备声控。特征：非接触式攻击、可自动化、需要获取目标语音样本。

x: 语音信号（波形）。 F(x): 声纹特征提取函数。 P_target: 目标说话人的声纹特征分布。 d: 特征距离函数。 J: 分类损失（如交叉熵）。 D(x): 活体检测器，输出真假概率。

信号处理：梅尔频率倒谱系数，相位谱分析。机器学习：分类器，特征学习。优化：生成对抗扰动。

1. 重放攻击：获取目标语音录音 -> 在认证时播放录音 -> 系统采集音频 -> 特征提取 -> 与目标声纹比对 -> 接受。 2. 合成攻击：使用目标语音训练TTS模型 -> 合成任意内容的语音 -> 播放 -> 系统认证。 3. 活体检测（防御）流程： a. 系统录制认证语音。 b. 提取用于活体检测的特征（如CQCC，相位差）。 c. 将特征输入训练好的二元分类器D（真/假）。 d. 如果D判定为“真”，再进行声纹匹配；否则直接拒绝。

信息流：攻击者准备伪造语音 -> 通过空气/电话线传播 -> 系统麦克风采集 -> 特征提取 -> （活体检测） -> 声纹匹配 -> 认证决策。攻击者试图在源头注入伪造的语音信号流，欺骗后续的处理管道。防御方在管道中增加一个“活体检测”过滤器。

硬件：攻击可能需要高质量录音/播放设备。防御方可使用特定麦克风阵列或传感器（如检测嘴唇运动）进行多模态活体检测。软件：声纹识别引擎（如Kaldi），活体检测模型（如ASVspoof挑战赛中的模型）。需持续更新以应对新的欺骗手段。

Safety-D1-0059

系统安全

虚拟化/嵌套虚拟化

VM Escape via Hypervisor 嵌套漏洞

利用二级地址转换 (SLAT) 的缺陷

1. 嵌套虚拟化： L1 Hypervisor运行在物理机上， L2 VM运行在L1上。 L1使用扩展页表 (EPT) 将L2的“客户物理地址” (GPA) 映射到“主机物理地址” (HPA)。 2. 漏洞模型： L1 Hypervisor的EPT管理代码存在缺陷。例如： a. 在映射L2 VM内存时，错误地将L1 Hypervisor自身代码或数据区域的HPA映射到L2的EPT中，并且权限设置为可写。 b. 在EPT项更新时，存在竞争条件，导致临时出现一个过宽的映射。 3. 攻击步骤： a. L2 VM中的攻击者探测EPT映射。通过尝试访问特定的GPA并测量延迟或观察是否触发缺页异常，可以推断该GPA是否被映射以及大致位置。 b. 一旦发现疑似映射到L1 Hypervisor内存的区域，尝试写入特定数据（如函数指针）。 c. 如果写入成功，当L1 Hypervisor后续执行到被覆盖的代码或使用被修改的数据时，控制流可能被劫持，导致从L2 VM逃逸到L1 Hypervisor，进而控制宿主机。

严重性： L2 VM（可能是不可信租户）完全攻破L1 Hypervisor，危害整个物理服务器及其上所有其他VM。利用条件：需要L1 Hypervisor的漏洞，但嵌套虚拟化增加了攻击面。

计算机体系结构（二级地址转换）、虚拟化原理、内存安全。

场景：云服务商提供的嵌套虚拟化服务（如AWS EC2 bare metal实例上运行自定义Hypervisor），或虚拟机自检/调试环境。特征：利用Hypervisor层漏洞、危害性极大、漏洞发现困难。

GPA: 客户物理地址（L2 VM视角）。 HPA: 主机物理地址（物理机视角）。 EPT: 扩展页表，存储GPA->HPA映射。 EPT Entry: EPT表项，包含HPA帧号及权限位。

内存映射：二级地址转换的数学函数 HPA = EPT(GPA)。位操作： EPT项权限位修改。竞争条件：并发修改EPT的时序分析。

1. 信息收集： L2 VM内攻击者通过侧信道或超时探测，绘制部分EPT映射图，寻找“可疑”的GPA区域（如访问时无异常且延迟与访问L1内存一致）。 2. 尝试写：向可疑GPA区域写入一个已知模式（如0xdeadbeef）。 3. 验证：通过其他手段（如触发L1中特定功能并观察行为变化）或再次读取，确认写入是否成功。 4. 利用：如果确认可写，精心构造写入内容，覆盖L1 Hypervisor的关键数据（如虚拟设备MMIO操作的处理函数指针）。 5. 触发：从L2 VM执行操作（如访问虚拟设备），触发L1 Hypervisor使用被覆盖的函数指针，跳转到攻击者控制的代码（可能已通过写入植入在L2 VM内存中，但需确保该内存也被EPT映射为可执行）。

控制流： L2 VM执行 -> 触发EPT缺页或访问 -> L1 Hypervisor的EPT处理代码运行（存在漏洞）-> 错误配置EPT映射 -> L2 VM获得写入L1内存的能力 -> L2 VM写L1内存 -> 后续L1代码执行流被劫持。漏洞使得L2 VM的数据写入流突破了隔离边界，流入了L1 Hypervisor的控制流。

硬件：依赖CPU的SLAT（EPT/NPT）硬件支持。硬件本身应无漏洞。软件：防御： L1 Hypervisor必须极其小心地管理EPT，确保绝不将自身内存映射给L2 VM。使用形式化验证或静态分析检查EPT管理代码。禁用嵌套虚拟化除非必要。

Safety-D1-0060

密码学应用

区块链/智能合约

重入攻击 (Reentrancy Attack) 模型

基于EVM调用栈的递归利用

1. 漏洞合约模式： solidity function withdraw(uint amount) public { require(balances[msg.sender] >= amount); msg.sender.call.value(amount)(); // 外部调用，转移以太币 balances[msg.sender] -= amount; // 状态更新在转账之后 } 2. 攻击原理： EVM在执行外部调用（如call.value()()）时，会将控制权转移到被调用合约。如果被调用合约是攻击者合约，其fallback函数可以再次调用withdraw函数。此时，由于攻击者的balances尚未被减少（因为balances[msg.sender] -= amount还未执行）， require检查再次通过，导致第二次转账。这个过程可以递归进行，直到gas耗尽或合约余额不足。 3. 数学表示：设合约初始余额为B，攻击者初始余额记录为b。每次withdraw调用转移amount = b。在重入n次后，合约总计被转出n * b，而攻击者余额记录只在第一次调用后的第n+1次更新时才被减去（但为时已晚）。只要n * b ≤ B且gas足够，攻击可继续。

影响：可耗尽合约中的所有以太币。典型：著名的The DAO攻击即利用此漏洞。

智能合约语义、状态机、递归。违反“检查-生效-交互”模式，状态更新落后于外部交互。

场景：以太坊及其他EVM兼容链上的去中心化金融 (DeFi) 合约、众筹合约。特征：逻辑漏洞、自动化利用、造成直接资金损失。

balances[mapping]: 记录地址余额的状态变量。 msg.sender: 调用者地址。 amount: 提取金额。 call.value()(): 低级以太币转账调用，会触发接收者的fallback函数。 B: 合约总余额。 n: 重入次数。

状态机：合约状态转换，不变量破坏（余额总和守恒）。递归：函数递归调用。时序：操作顺序的依赖性。

1. 攻击者部署恶意合约，其fallback函数中包含对漏洞合约withdraw的再次调用。 2. 攻击者调用漏洞合约的withdraw函数。 3. 漏洞合约检查通过，执行call.value向攻击者合约转账。 4. EVM转账触发攻击者合约的fallback函数执行。 5. 在fallback函数中，攻击者合约再次调用漏洞合约的withdraw函数（递归）。 6. 步骤3-5循环，直到gas将尽或合约余额不足。 **7. 递归返回，最终执行balances[msg.sender] -= amount，但只减一次（对应最后一次递归返回）。

控制流：攻击者调用withdraw-> 合约检查 -> 外部call-> 跳转到攻击者合约fallback-> fallback中再次调用withdraw-> … 形成循环。资金流在第一次call时就从合约流向攻击者，并在循环中不断重复。状态更新流被推迟，无法阻止循环。

硬件：无特殊需求。软件：防御：使用“检查-生效-交互”模式，先更新状态再执行外部调用。或使用重入锁（如OpenZeppelin的ReentrancyGuard）。静态分析工具（如Slither）可检测此模式。

Safety-D1-0061

应用安全

Web安全/浏览器缓存

跨站搜索劫持 (XS-Search)

利用浏览器缓存推断搜索结果

1. 攻击原理：许多搜索引擎（如Google，内网搜索引擎）对搜索结果的HTTP响应使用缓存控制头，使得相同的搜索请求响应可被浏览器缓存。攻击者可以检测特定搜索结果的缓存状态，从而推断用户是否进行过该搜索。 2. 攻击步骤： a. 攻击者构造一个恶意页面，其中包含对目标搜索URL的“探测”资源请求（如图片， iframe）。例如， <img src="https://search.com?q=secret">。 b. 如果受害者之前搜索过“secret”，则该URL的响应可能已在其浏览器缓存中。当浏览器加载恶意页面时，对于缓存的资源，会直接从磁盘加载，速度极快（~0ms）；对于未缓存的资源，需要网络请求，速度慢（>50ms）。 c. 攻击者通过JavaScript的performanceAPI测量img元素的加载时间t_load。如果t_load < threshold（如20ms），则推断该搜索存在缓存，即受害者搜索过该关键词。 3. 优化：攻击者可以并行探测多个关键词，或使用更精确的计时源（如performance.now()）。为绕过缓存分区，攻击者可能需要将探测资源托管在与目标搜索引擎相同的站点（或利用跨站点脚本）。

准确性：在低噪声环境下，区分缓存命中/未命中的准确率高。受网络抖动、浏览器实现、缓存策略影响。带宽：可探测大量关键词，但每个关键词需一个请求。

网络性能测量、缓存机制、统计检测。利用缓存访问的时序侧信道。

场景：推断用户搜索历史（可能泄露健康、财务等敏感信息）、内网信息侦察。特征：远程Web攻击、无需用户交互（除访问恶意页面）、受缓存分区等缓解措施制约。

URL_q: 包含搜索词q的搜索URL。 t_load: 测量到的资源加载时间。 τ: 时间阈值，用于区分缓存命中/未命中。 P_cache: 资源在缓存中的先验概率。

计量学：高分辨率计时，噪声下的信号检测。概率：基于计时的假设检验。优化：阈值选择以最小化错误。

1. 攻击者引诱受害者访问恶意网页。 2. 页面加载时， JavaScript动态创建多个隐藏的Image对象，其src属性指向不同的目标搜索URL。 3. 为每个Image对象绑定onload和onerror事件处理器，并在设置src前记录t_start = performance.now()。 4. 在onload事件中，计算t_load = performance.now() – t_start。 5. 判断：如果t_load < τ，则推测该搜索词q存在于受害者缓存中，即受害者曾搜索过q。 6. 将结果（推测的搜索词）回传到攻击者服务器。

信息流：受害者的历史搜索行为 -> 使特定URL的响应存入浏览器缓存 -> 受害者访问恶意页面 -> 页面发起对目标URL的资源请求 -> 浏览器检查缓存 -> 快速（缓存命中）或慢速（未命中）返回 -> 攻击者脚本通过计时推断缓存状态 -> 反推搜索历史。历史行为通过缓存状态这个中间变量泄露给攻击者。

硬件：无特殊需求。高精度计时器有利于攻击。软件：攻击者为几行JavaScript。防御：搜索引擎对包含敏感查询的响应设置Cache-Control: private或no-store。浏览器实施缓存分区（已广泛部署），使跨站攻击者无法读取受害者对搜索站的缓存。禁用performance.now的高精度或添加噪声。

Safety-D1-0062

系统安全

操作系统/文件系统

利用文件系统链接的权限绕过

符号链接与硬链接竞争条件

1. 漏洞模式：特权进程（如setuid程序）以root身份运行，但在访问用户可控的文件路径时，存在“检查-使用”竞争条件 (TOCTOU)。 2. 攻击步骤： a. 特权进程P需要打开文件/tmp/userfile，并在打开前用lstat()检查其属性（如确保不是符号链接）。 b. 在lstat()（检查）和open()（使用）之间，攻击者快速将/tmp/userfile从普通文件替换为一个指向敏感文件（如/etc/shadow）的符号链接。 c. 如果替换成功，特权进程P将遵循符号链接，打开并可能写入敏感文件，导致权限提升或信息泄露。 3. 竞争窗口：竞争窗口Δt是lstat和open系统调用之间的时间。攻击者通过持续快速切换（使用rename系统调用）/tmp/userfile指向的目标文件，增加命中竞争窗口的概率。成功率与Δt和攻击者切换频率正相关。

严重性：本地权限提升，从普通用户到root。可靠性：成功率取决于竞争窗口大小，通过多核并行攻击可显著提高。

操作系统并发、文件系统语义、竞争条件。利用安全检查与实际操作之间的时间差。

场景： Linux/Unix系统中的setuid程序、计划任务（cron）脚本、备份程序等。特征：本地攻击、需要高频率文件操作、现代内核已增加许多防御。

path: 用户可控的文件路径字符串（如/tmp/userfile）。 Δt: 检查与使用之间的时间间隔。 f_attacker: 攻击者控制的文件/链接。 f_target: 攻击者希望访问的敏感目标文件。

时序：竞争窗口，并发操作的交错。概率：在Δt内成功替换的概率。系统编程：文件系统操作的系统调用序列。

1. 攻击者准备：创建普通文件A和指向目标的符号链接B。 2. 启动特权进程 P，其代码路径包含对path的lstat后接open。 3. 并行攻击循环：在另一个进程/线程中，循环执行： rename(“A”, “path”); rename(“B”, “path”);。 4. 竞争：期望在P的lstat检查path时，它指向A（通过检查）；而在随后的open时，由于攻击者的rename，它已指向B（符号链接）。 5. 利用：如果竞争成功， P将打开敏感目标文件f_target，攻击者可能通过P的逻辑写入或读取该文件。

控制流：特权进程执行检查(lstat) -> （攻击者快速切换文件链接） -> 特权进程执行使用(open)。攻击者通过注入并发的文件系统操作流，在检查和使用两个操作之间“ splicing ”入一个恶意的文件链接，改变了open操作的实际对象。

硬件：多核CPU有利于并行攻击，缩短有效竞争窗口。软件：防御：使用openat系统调用结合O_NOFOLLOW和O_PATH标志，或使用fstat在打开文件描述符后检查文件属性。内核文件系统加固（如protected_symlinks）。

Safety-D1-0063

密码学应用

多方计算/隐私集合求交

基于不经意传输的PSI

KKRT16 PSI协议

1. 基础工具：不经意传输扩展，允许接收方以c个基础OT交换为代价，执行m次OT，其中m >> c。 2. 协议概览（两方， Alice有集合A， Bob有集合B）： a. 布谷鸟哈希：双方将各自集合的元素放入布谷鸟哈希表H中。每个桶包含多个元素，空位用伪随机元素填充。目标是每个元素在表中有d个可能位置（如d=3）。 b. 不经意PRF编码：对于哈希表的每个位置j（共B个桶）， Alice和Bob运行一个不经意PRF (OPRF)。 Bob作为发送方，输入为其落在位置j的所有元素的密钥k_j。 Alice作为接收方，输入为其落在位置j的元素x，获得输出F(k_j, x)。如果Bob也有相同元素y=x落在同位置，则F(k_j, x) = F(k_j, y)。 c. 比较： Alice计算其所有元素的OPRF值集合S_A， Bob计算其所有元素的OPRF值集合S_B。双方交换（或通过其他方式比较）这两个集合，交集即为S_A ∩ S_B，其原像对应A ∩ B。 3. 安全性：对于不在交集中的元素， Alice学到的OPRF值看起来是随机的，无法反推Bob的元素。

通信复杂度：接近线性O(m)，其中m为集合大小，效率很高。安全：在半诚实模型下安全，基于OT和PRF的假设。

哈希表（布谷鸟哈希）、不经意传输、伪随机函数。将集合成员测试转化为OPRF值相等性测试。

场景：大规模隐私联系人匹配、广告转化测量、联合分析。特征：目前最高效的PSI协议之一、需多轮交互、可扩展至大集合。

A, B: 参与方的私有集合。 H: 布谷鸟哈希函数，映射元素到d个桶索引。 B: 哈希表桶的数量。 k_j: Bob为第j个桶生成的OPRF密钥。 F(k, x): 伪随机函数。 S_A, S_B: 双方元素的OPRF值集合。

哈希：布谷鸟哈希的构造与分析。概率：哈希冲突与表填充的成功率。密码学： OPRF构造， OT扩展。

1. 初始化：双方约定布谷鸟哈希参数（表大小B, 哈希函数d个）。 2. 插入：双方将各自集合元素插入本地布谷鸟哈希表，空位用伪随机元素填充。 3. OPRF阶段：对每个桶j=1 to B： a. Bob为其在该桶中的每个元素y生成一个OPRF密钥k_{j,y}。 b. Alice和Bob为桶j执行一个OPRF子协议，使得Alice能为其在该桶中的每个元素x获得F(k_{j,y}, x)，而Bob获得F(k_{j,y}, y)。具体地，通过OT扩展实现， Alice输入x， Bob输入k_{j,y}。 4. 集合构建： Alice收集所有F(k, x)值形成S_A。 Bob收集所有F(k, y)值形成S_B。 5. 求交：双方比较S_A和S_B（可通过不经意传输或哈希后比较）。相等的值对应交集元素。

信息流：双方私有集合 -> 本地布谷鸟哈希 -> 按桶进行OPRF交互 -> 生成伪随机标签集合 -> 比较标签集合求交。元素通过哈希被分散到不同的桶中并行处理。 OPRF将元素“盲化”为随机标签，只有相同的元素能产生相同的标签。

硬件：需要大量计算进行OT扩展和OPRF评估，可使用硬件加速。软件：实现复杂，有开源库（如PSI）。内存消耗与哈希表大小成正比。

Safety-D1-0064

应用安全

云视频会议/虚拟背景

利用虚拟背景的深度信息泄露

从背景分割模型中推断室内布局

1. 背景：视频会议软件（如Zoom, Teams）使用神经网络实时分割人像与背景，以实现虚拟背景。模型M输入为视频帧I，输出为每个像素属于前景（人）的概率掩码P = M(I)。 2. 攻击假设：模型M的预测可能无意中编码了背景的深度或场景信息。例如，对于相似的背景物体（如书架、窗户），模型可能因为训练数据偏差而赋予不同的分割置信度，这细微差异可能被利用。 3. 攻击方法： a. 模型逆向：如果攻击者能以白盒或黑盒方式查询M（例如通过自己加入会议或利用测试API），他可以提交大量精心设计的探针图像I_probe，这些图像包含不同的背景布局或物体。 b. 观察输出：攻击者记录模型输出的掩码P，或更具体地，模型中间层的特征激活F = φ(I)。这些特征可能对背景内容敏感。 c. 推断：通过分析P或F与I_probe背景的关系，攻击者可以学习一个逆向映射R，使得R(P) ≈ background_info。在攻击时，攻击者获取受害者视频流的分割掩码P_victim（可通过截屏或网络分析），应用R推断受害者背景的大致布局或存在的物体。

泄露程度：可能推断出背景是否存在特定物体类型（如电视、书架）、大致房间大小（通过分割边缘的模糊程度），但难以获得精确细节。可行性：高度依赖具体模型，且需要大量探针和数据。

机器学习逆向工程、特征反演、模型窃取。利用分割模型对背景的残留依赖性。

场景：针对远程办公人员的隐私侦察，推断其家庭办公室环境、公司内部环境等。特征：被动观测、利用AI功能副作用、隐私泄露风险。

I: 输入视频帧（RGB图像）。 M: 背景分割神经网络。 P: 输出概率掩码（单通道，值0-1）。 φ(I): 模型中间层特征图。 R: 逆向映射函数（攻击者学习）。 background_info: 要推断的背景信息（如物体类别标签）。

机器学习：特征提取，模型解释。逆向工程：从输出反推输入敏感部分。统计：相关性分析。

1. 攻击者数据收集：在可控环境下，使用不同背景布局拍摄大量图片，并获取模型M对它们的输出掩码P，形成数据集{(I_i, P_i)}。 2. 训练逆向模型：训练一个神经网络R，输入为P_i（或其特征），输出为背景信息的编码（如场景分类标签）。损失函数为背景信息预测误差。 3. 实施攻击：在目标会议中，攻击者（作为参与者）截取受害者视频帧，提取其分割掩码P_victim（可通过观察虚拟背景边缘的瑕疵，或直接获取流媒体数据如果未加密）。 4. 推断：将P_victim输入训练好的R，得到对受害者背景的推断。

信息流：受害者真实背景 -> 被摄像头捕获为视频帧I-> 分割模型M处理 -> 输出前景掩码P（主要包含前景信息，但残留背景线索）-> 攻击者获取P-> 应用逆向模型R-> 推断背景信息。背景信息通过分割模型的“不完美”或“偏见”被部分编码到输出掩码中泄露。

硬件：无特殊需求，攻击者需要能运行模型M和R。软件：攻击者需要访问分割模型（可能是公开的或可逆向的）。防御：在客户端进行分割计算，仅将前景人像和虚拟背景的合成帧传输到云端，确保原始背景帧绝不离开本地设备。对模型进行对抗训练，使其对背景变化更加鲁棒（即背景不变性）。

Safety-D1-0065

系统安全

虚拟化/设备直通

利用PCIe ACS绕过进行DMA攻击

PCIe访问控制服务 (ACS) 配置错误

1. 背景：在SR-IOV或GPU直通场景中，多个VM共享或独占一个物理PCIe设备。 PCIe ACS是一种硬件特性，允许在PCIe交换层面对设备发起的请求（如DMA, Interrupt）进行路由和访问控制，防止一个VM的设备攻击另一个VM或宿主机。 2. 漏洞模型：如果ACS在硬件上不支持，或在软件（Hypervisor/BIOS）上未正确启用配置，恶意VM控制下的直通设备可以： a. 发起指向其他VM内存或宿主机内存的DMA请求。 b. 伪造中断消息，干扰其他设备或VM。 c. 窥探其他设备的内存访问。 3. 攻击步骤：假设两个VM， VM_A（攻击者）和VM_B（受害者），共享一个支持SR-IOV的网卡。每个VM获得一个虚拟功能(VF)。如果ACS未启用， VM_A可以编程其VF，发起一次DMA写操作，目标地址设置为VM_B内存的物理地址（可能通过信息泄露获得）。 PCIe交换机由于缺乏ACS控制，可能会将此请求路由到VM_B的内存，造成数据破坏或泄露。

严重性：跨VM内存访问，完全破坏隔离性。普遍性：依赖硬件支持和正确配置，在旧系统或错误配置的云平台中可能存在。

PCIe总线协议、输入输出内存管理、硬件强制隔离。 ACS是确保多租户下PCIe隔离的关键。

场景：公有云中提供GPU直通、高性能网卡（如AWS ENA, NVIDIA Mellanox）的实例。特征：硬件级攻击、需要直通设备控制权、配置错误导致。

VF: 虚拟功能，一个PCIe SR-IOV虚拟设备实例。 ACS: 访问控制服务， PCIe能力结构，包含源验证、重定向阻止等功能位。 DMA Request: 包含目标地址、数据、请求者ID (BDF)的数据包。 BDF: 总线-设备-功能号，唯一标识一个PCIe功能。

硬件协议： PCIe事务层包格式， ACS策略规则。访问控制：基于BDF的访问控制列表。配置： PCIe配置空间的读写。

1. 侦察：攻击者VM读取其VF的PCIe配置空间，检查ACS能力位是否启用。或尝试探测其他VM的内存。 2. 准备：通过其他漏洞或侧信道，获取受害者VM或宿主机的某个敏感物理地址PA_target。 3. 构造恶意DMA：编程VF的DMA引擎，设置目标地址为PA_target，数据为攻击载荷。 4. 触发DMA：启动VF的DMA传输。 5. PCIe路由： DMA请求包离开VF，经过PCIe交换机。如果ACS未正确实施，交换机不检查或无法阻止跨边界请求，将请求路由到PA_target所在的内存控制器。 6. 内存访问：内存控制器对PA_target执行写操作，攻击完成。

数据流：恶意VF -> 生成恶意DMA请求包 -> PCIe交换机（缺乏ACS过滤）-> 内存控制器 -> 受害者物理内存。 ACS本应是一个“防火墙”，检查每个请求的源BDF和目标地址范围。配置错误使得防火墙规则缺失，恶意数据流得以跨隔离域流动。

硬件：必须要求PCIe交换机和根端口支持ACS，并在BIOS中启用。硬件是防御的基础。软件： Hypervisor（如Linux vfio-pci驱动）在将VF分配给VM前，必须验证ACS已启用并正确配置。如果硬件不支持ACS，应避免将设备共享给不受信任的VM。

Safety-D1-0066

密码学应用

数字水印/深度伪造检测

基于生物信号一致性的深度伪造检测

利用光电容积描记 (PPG) 信号

1. 原理：真实人脸的皮肤在视频中会因心跳引起的血流变化而产生细微的颜色亮度周期性变化，可通过人脸区域的平均RGB值序列提取出光电容积描记信号。深度伪造视频通常无法准确生成或保持这种生理信号的一致性。 2. 信号提取：对视频帧序列{I_t}，在检测到的人脸区域R内，计算每个颜色通道的平均值： (C_t = \\frac{1}{

} \\sum_{p \\in R} I_t(p) )，其中C可以是R, G, B。得到三个时间序列R(t), G(t), B(t)。由于血液对绿光吸收最强， G通道的PPG信号最明显。 3. 特征分析： a. 频谱分析：计算G(t)的功率谱密度PSD(f)。真实人脸的PSD在典型心率范围（如0.8-3 Hz，对应48-180 BPM）应有一个明显的峰值。深度伪造视频的PSD可能在此频段没有峰值，或峰值位置不合理。 b. 信号质量：计算信噪比SNR = P_{signal} / P_{noise}，其中P_signal是心率频段的功率， P_noise是其他频段的功率。真实视频的SNR通常更高。 c. 多区域一致性：提取人脸多个区域（如前额、脸颊）的PPG信号，计算它们之间的相关性。真实视频中，这些信号应高度相关（同源于心跳），而深度伪造可能不一致。

检测准确率：对高质量深度伪造（如“换脸”）检测有效，报告AUC>0.9。对重放攻击无效。局限性：需要视频长度足够（>10秒），光照稳定，人脸清晰。

生物信号处理、频谱分析、生理学。利用真实生物体特有的生命体征信号作为“活体”证据。

场景：社交媒体内容审核、视频证据鉴真、远程身份验证（活体检测）。特征：被动检测、利用生物特征、对计算机生成内容有效。

I_t: 第t帧图像。 R: 人脸区域像素集合。 C(t): 颜色通道平均值时间序列。 PSD(f): 功率谱密度。 f_hr: 心率频率（Hz）。 SNR: 信噪比。 ρ: 不同区域PPG信号的相关系数。

信号处理：时间序列分析，快速傅里叶变换。统计：相关性分析，假设检验。生理学：心率范围先验知识。

1. 输入视频，进行人脸检测与跟踪，稳定区域R。 2. 信号提取：对每一帧，计算区域R内G通道（或去相关后的颜色信号）的平均值，形成原始信号x(t)。 3. 预处理：对x(t)进行带通滤波（如0.8-3 Hz）以保留心率频段，得到x_f(t)。 4. 频谱分析：计算x_f(t)的PSD，找到峰值频率f_peak。检查f_peak是否在合理心率范围，并计算该峰值功率与背景噪声功率的比率（SNR）。 5. 决策：如果f_peak在合理范围且 SNR > 阈值T1，则判定为真实视频的可能性高；否则判定为可疑/伪造。可增加多区域一致性检查以提高鲁棒性。

Safety-D1-0067

软件安全

操作系统/系统服务

利用Windows COM服务器提权

COM对象劫持与模拟级别滥用

1. COM背景：组件对象模型允许进程间通信。高权限进程（如系统服务）可能实例化一个注册在HKEY_CURRENT_USER下的COM对象，该注册表键可由普通用户控制。 2. 攻击模式： a. 普通用户找到一个以SYSTEM或高权限运行的服务或进程，它会加载一个用户可控制的CLSID。 b. 用户在HKCU\\Classes\\CLSID\\{CLSID}\\InprocServer32下注册一个恶意的DLL路径，指向攻击者编写的DLL。 c. 当高权限进程调用CoCreateInstance或类似函数实例化该CLSID时，由于COM的加载顺序（HKCU优先于HKLM），它会加载攻击者的DLL。 d. 攻击者的DLL在高权限进程中加载执行，实现权限提升。 3. 模拟级别：如果高权限进程在实例化COM对象时设置了错误的模拟级别（如RPC_C_IMP_LEVEL_IMPERSONATE），攻击者的DLL甚至可能模拟调用者身份执行更多操作。

严重性：普通用户到SYSTEM权限提升。条件：需要找到这样一个有漏洞的高权限COM使用者，并且它加载的CLSID用户可写。

Windows组件对象模型、注册表权限、进程安全上下文。利用权限进程对用户可控资源的信任。

场景： Windows本地权限提升，特别是存在配置错误或第三方软件漏洞时。特征：利用合法机制、需要特定条件、是常见的EoP技术。

CLSID: 全局唯一标识符，标识一个COM类。 HKCU, HKLM: 注册表配置单元，当前用户和本地机器。 InprocServer32: 注册表值，指定进程内服务器的DLL路径。模拟级别: 指定服务器可以多大程度上扮演客户端。

注册表：键值查找优先级（HKCU over HKLM）。进程安全：令牌模拟级别。系统编程： COM API调用。

1. 信息收集：攻击者枚举以高权限运行的进程，并监控其COM加载活动（如使用ProcMon），寻找加载HKCU下CLSID的实例。 2. 劫持准备：对于目标CLSID，在HKCU\\Classes\\CLSID\\{CLSID}\\InprocServer32下创建注册表项，将(Default)值设置为恶意DLL的路径。 3. 触发加载：通过重启服务、重启系统或触发特定功能，使高权限进程再次实例化该CLSID。 4. DLL执行：高权限进程加载并执行恶意DLL的DllMain函数。 5. 权限利用：在DLL中，以高权限执行代码，如添加用户到管理员组。

控制流：高权限进程 -> 调用CoCreateInstance(CLSID)-> COM运行时查询注册表 -> 首先在HKCU下找到恶意DLL路径 -> 加载该DLL到高权限进程空间 -> 执行DLL入口点。攻击者通过污染用户注册表这个“配置流”，将高权限进程的控制流引入恶意代码。

硬件：无特殊需求。软件：防御：高权限进程应避免加载用户可控的COM服务器。使用CLSCTX_ENABLE_CLOAKING标志或指定REGCLS_SUSPENDED并检查调用者身份。启用UAC并遵循最小特权原则。微软已通过修补程序和C:\\Program Files目录的写保护缓解了许多此类攻击。

Safety-D1-0068

应用安全

云数据库/SQL注入

二阶SQL注入攻击模型

利用数据存储与后续使用的分离

1. 与一阶注入区别：攻击者输入包含SQL特殊字符的载荷，在首次插入/存储到数据库时，由于使用了参数化查询或转义，被安全地存储为数据。然而，当应用程序后续在另一个不同的上下文中（如报告生成、数据导出）从数据库读取该数据并动态构建SQL查询时，未进行适当的处理，导致注入发生。 2. 攻击步骤： a. 攻击者在应用的“用户注册”或“评论”功能中，提交用户名admin'–。应用使用参数化查询安全插入： INSERT INTO users (name) VALUES (@name)，因此字符串admin'–被原样存入数据库。 b. 后台存在一个管理员功能，用于搜索用户并展示其活动日志。该功能构造查询时，直接从数据库读取用户名并拼接： SELECT * FROM logs WHERE username='“ + usernameFromDB + ”'。 c. 当管理员查看攻击者账户admin'–的日志时，从数据库读取的用户名admin'–被拼接到查询中，形成： SELECT * FROM logs WHERE username='admin'–'。注释符–使查询提前结束，可能返回所有用户的日志，造成信息泄露。 3. 数学表示：设存储函数S(x)安全（如参数化），使用函数U(y)不安全（拼接）。攻击者输入m使得U(S(m))产生恶意SQL语句，而S(m)本身是安全的。

影响：可导致数据泄露、篡改，甚至权限提升，取决于第二个使用点的上下文。隐蔽性：比一阶注入更隐蔽，因为首次输入看似无害。

字符串处理、代码注入、上下文相关解析。安全依赖于所有使用路径的一致性。

场景：任何具有数据存储和后续动态查询功能的Web应用（如CRM， ERP，内容管理系统）。特征：时间延迟攻击、需要两个处理阶段、易被传统扫描器忽略。

m: 攻击者输入的恶意字符串。 S(): 存储阶段的数据处理函数（安全）。 U(): 后续使用阶段的数据处理函数（不安全，拼接）。 Q: 最终生成的SQL查询字符串。

字符串：拼接，转义，上下文区分。逻辑：数据流跟踪（污点分析）。构造：设计载荷使其在第二个上下文中生效。

1. 攻击者发现一个数据入口点A（如个人资料更新），其输入经安全处理存入DB。 2. 攻击者提交载荷：在A处提交包含SQL片段的载荷PAYLOAD。 3. 存储： PAYLOAD被安全地存储在数据库字段F中。 4. 触发：攻击者等待或主动触发另一个功能点B（如生成报告），该功能会读取字段F的数据并用于动态构建SQL查询。 5. 注入发生：在B点，从数据库读出的PAYLOAD被直接拼接到查询字符串中，注入成功。 6. 利用：攻击者通过B点的功能获取注入结果。

数据流：攻击者输入 -> 入口点A（安全处理）-> 数据库存储 -> 出口点B（不安全处理）-> 动态查询构建 -> SQL执行。恶意载荷像“定时炸弹”，在A点被安全包装后存入仓库，在B点被拆封并错误使用，导致爆炸。

硬件：无特殊需求。软件：防御：对所有数据库输入使用参数化查询，无论来源是用户输入还是数据库自身。实施严格的输出编码。使用静态/动态应用程序安全测试 (SAST/DAST) 工具进行数据流污点分析，以发现此类问题。

Safety-D1-0069

系统安全

内存安全/控制流完整性

细粒度控制流完整性 (CFI)

基于前向边验证的CFI

1. 目标：确保程序执行遵循预先计算的控制流图 (CFG)。主要防御间接调用（通过函数指针、虚函数）被劫持。 2. 原理：在编译时分析程序源码/二进制，生成每个间接控制转移指令（如call eax, jmp [edx+8]）的合法目标集合Targets(I)。在运行时，在执行间接跳转前，插入检查代码验证目标地址addr是否在Targets(I)中。 3. 数学表示：设CFG为有向图G=(V, E)，其中V是基本块， E是允许的转移边。对于每个间接跳转点v_i，其合法目标集合是`{v_j

(v_i, v_j) ∈ E}。运行时检查：if (target_addr ∉ Targets(v_i)) then abort()。 **4. 实现**： a. **粗粒度CFI**：将目标集合放宽，例如所有函数入口点作为一个集合。安全性较弱但开销低。 b. **细粒度CFI**：精确计算每个调用点的可能目标（如基于类型）。安全性高但分析复杂，可能有精度损失（由于动态加载、函数指针转换）。 c. **硬件支持**： Intel CET（控制流强制技术）使用ENDBRANCH`指令标记合法间接跳转目标， CPU硬件检查。

安全性：可有效防御面向返回编程等代码复用攻击。细粒度CFI理论上是强大的控制流劫持缓解措施。性能开销：通常<10%，取决于检查粒度和实现。

图论（控制流图）、程序分析、运行时验证。将程序控制流限制为静态分析确定的合法路径。

场景：操作系统内核、浏览器、服务器进程等关键软件的漏洞利用缓解。特征：编译时/链接时技术、需要源代码或高级二进制分析、是现代安全开发生命周期的一部分。

G=(V,E): 控制流图。 v_i: 一个基本块（或间接跳转指令位置）。 Targets(v_i): v_i的合法目标基本块集合。 addr: 运行时计算出的跳转目标地址。 ID: 合法目标的标识符（如标签，哈希）。

图论：有向图的遍历，可达性分析。集合：集合成员判断。程序分析：指针分析，别名分析。

1. 编译/链接时：分析程序，构建CFG，为每个间接调用/跳转指令分配一个唯一ID，并计算其合法目标ID集合。 2. 插桩：在每条间接跳转指令前，插入检查代码。检查代码计算目标地址对应的ID（例如通过一个从地址到ID的映射表），并验证该ID是否在当前跳转点的合法目标ID集合中。 3. 运行时：程序执行到插桩点： a. 计算间接跳转的目标地址addr。 b. 查找addr对应的目标ID id_t。 c. 获取当前跳转点的合法目标ID集合 S_i。 d. 如果 id_t ∉ S_i，触发安全违规处理（如终止进程）。 e. 否则，允许跳转执行。

控制流：程序正常执行 -> 到达间接跳

编号

类别

领域

模型配方

定理/算法/模型/方法名称

定理/算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式和参数选择/参数优化

精度/密度/误差/强度

底层规律/理论定理

典型应用场景和各类特征

变量/常量/参数列表及说明

数学特征

时序和交互流程的所有细节/分步骤时序情况及数学方程式

流动模型和流向方法的数学描述

硬件设计/软件设计及资源

Safety-D1-0074

硬件安全

图形处理器/内存压缩

GPU帧缓冲压缩 (FBC) 数据残留攻击

利用无损压缩算法的侧信道

1. 背景： GPU为节省带宽，对写入帧缓冲/显存的数据进行实时无损压缩（如块压缩）。压缩率取决于数据模式（空间局部性、颜色相似性）。 2. 攻击原理：攻击者与受害者共享GPU。攻击者分配一个缓冲区，与受害者敏感数据（如渲染的文本、界面元素）可能映射到同一物理内存块。攻击者写入特定的探测模式到自己的缓冲区，并测量写入时间t_write。 GPU在写入前会先读取该内存块（包含受害者残留数据）进行解压缩-修改-再压缩。如果攻击者的探测模式与受害者残留数据组合后具有更高的可压缩性，则t_write会变短，因为压缩后的数据量小，写入带宽需求低。通过分析t_write与不同探测模式的关系，可以推断出受害者残留数据的部分信息。 3. 数学模型：设内存块大小为B字节。原始数据（受害者残留D_v+ 攻击者写入D_a）的压缩后大小为C(D_v, D_a)。写入时间t_write ≈ α + β * C(D_v, D_a)，其中α是固定开销， β是每字节写入时间。攻击者通过改变D_a，测量t_write，试图求解或逼近D_v。这类似于选择明文攻击。

分辨率：可探测内存块级别的数据模式，难以恢复精确字节。成功率：依赖于压缩算法对数据模式的敏感度，以及攻击者能进行多少次测量。

信息论（数据压缩）、旁路分析（时序分析）。压缩率是数据和算法的函数，泄露了数据的信息熵。

场景：云游戏、虚拟桌面架构中，跨用户推断邻户的屏幕内容（如输入的字符、显示的图片）。特征：跨租户攻击、利用内存子系统优化、需要高精度计时。

D_v: 受害者残留在目标内存块中的数据（未知）。 D_a: 攻击者写入的探测数据（可控）。 B: 内存块大小（如64字节）。 C(D): 压缩函数，返回压缩后数据长度。 t_write: 测量到的写入时间。 α, β: 与硬件相关的时序参数。

信息论：条件熵，互信息。优化：选择D_a以最大化t_write关于D_v的信息。信号处理：从噪声时间测量中提取信号。

1. 地址布局：攻击者通过大量分配，使自己的缓冲区与受害者可能使用的显存区域在物理上相邻或共享内存控制器。 2. 基准测量：在受害者不活跃时，测量写入各种已知模式D_a的时间，建立基线t_base(D_a)。 3. 主动探测：在受害者执行敏感操作后，立即测量写入相同模式D_a的时间t_probe(D_a)。 4. 差异分析：计算Δt(D_a) = t_probe(D_a) – t_base(D_a)。如果Δt(D_a)显著为负，表明D_a与受害者残留数据D_v组合后压缩率提高，暗示两者存在某种相关性（如颜色相近、模式相似）。 5. 模式推断：通过分析多个D_a对应的Δt，可以部分重建D_v的特征（如主要颜色、是否存在边缘）。

信息流：受害者渲染操作 -> 数据写入GPU显存（被压缩） -> 内存块残留压缩数据 -> 攻击者写入探测数据 -> GPU执行读-解压-修改-再压缩操作 -> 压缩率受残留数据影响 -> 体现为写入时间差异 -> 攻击者从时间差异推断残留数据。残留数据通过改变压缩算法内部的“上下文”，影响了攻击者操作的性能，信息由此泄露。

硬件： GPU内存控制器和压缩硬件是攻击面。防御需在上下文切换时清空压缩上下文或对压缩元数据也进行隔离。软件：攻击者需能分配GPU缓冲区和进行纳秒级计时。驱动或Hypervisor需管理压缩元数据的安全。

Safety-D1-0075

应用安全

浏览器/WebAssembly

WebAssembly 内存时序侧信道

利用Wasm线性内存的边界检查旁路

1. 背景： WebAssembly (Wasm) 运行在沙箱中，对线性内存的访问会在运行时进行边界检查（确保偏移在[0, memory.buffer.byteLength)内）。检查通过后才会访问实际的JavaScript ArrayBuffer。 2. 攻击模型：攻击者Wasm模块可以测量自身内存访问的时间。由于边界检查是在访问前进行的，攻击者试图访问一个“带外”地址（越界）时，会立即抛出异常，这比成功访问并获取数据可能更快或更慢，具体取决于引擎实现和硬件。 3. 攻击步骤： a. 攻击者拥有一个Wasm模块，其线性内存后紧邻着另一个敏感数据（如同源其他Wasm模块的数据，或JavaScript对象）。 b. 攻击者尝试以不同偏移i读取自己的内存，并测量时间t(i)。当i在合法范围内时， t(i)是正常的内存访问时间。当i超出边界但落在相邻敏感数据的地址空间时，边界检查会失败，但某些引擎的检查实现可能存在时序差异。例如，检查可能分两步：先检查是否小于长度，再检查是否大于等于0。攻击者可以构造i为一个非常大的值，使第一个比较就失败，可能比落在合法范围内但需要计算地址并访问内存更快。 c. 通过分析t(i)的分布，攻击者可以探测相邻内存区域的布局，甚至推断其内容（如果访问非法地址但未立即抛出异常，而是触发了垃圾回收或其它慢路径）。

精度：可探测相邻内存的大致范围，难以读取具体数据。影响：可能绕过Wasm沙箱，进行有限的地址空间布局随机化 (ASLR) 绕过。

程序分析、微架构计时、沙箱逃逸。利用安全检查路径与正常路径的时序差异。

场景：恶意Wasm模块在浏览器中试图探测其他Wasm模块或JavaScript对象的内存布局，为后续攻击做准备。特征：浏览器内部攻击、利用引擎实现细节、受Spectre等硬件漏洞影响更大。

i: 尝试访问的内存偏移（索引）。 len: 当前Wasm模块线性内存的字节长度。 t(i): 测量到的访问偏移i所需时间。 threshold: 用于区分“界内”和“界外”访问的时间阈值。

计时分析：高分辨率时间测量，统计分布分析。边界检查：比较操作的时序。侧信道：通过时间差异推断条件判断结果。

1. 攻击者Wasm模块初始化，获取其线性内存的ArrayBufferab。 2. 计时循环： for i in 0 to MAX_PROBE: a. t0 = performance.now() b. 尝试读取ab[i]（在Wasm中对应i32.load指令）。 c. 捕获可能抛出的RangeError异常。 d. t1 = performance.now(); t(i) = t1 – t0。 3. 分析：绘制t(i)随i变化的曲线。期望在i >= len附近观察到t(i)的突变（或出现两种明显不同的时间聚类）。突变点揭示了内存边界，其后的模式可能反映相邻内存区域的性质（如是否可读、是否触发异常）。

控制流： Wasm指令i32.load-> 运行时边界检查 -> 检查通过则访问ArrayBuffer数据；检查失败则抛出异常。两条路径的执行时间可能存在差异。攻击者通过提供不同的i，观察控制流进入哪条路径（通过时间），从而反向推断检查条件（i < len）的真假，进而推测len的值或相邻区域属性。

硬件：受CPU缓存、分支预测影响。防御需要常数时间的边界检查。软件：防御： Wasm引擎必须实现常数时间的边界检查，无论索引是否越界，检查路径的执行时间都应相同。或将线性内存放置在有保护页的独立区域，使越界访问立即触发段错误而非引擎检查。

Safety-D1-0076

系统安全

虚拟化/中断虚拟化

利用虚拟中断注入的VM拒绝服务

虚拟中断风暴攻击

1. 背景： Hypervisor将物理中断转化为虚拟中断注入到VM中。对每个虚拟中断， Hypervisor需要模拟一个写入VM的虚拟中断控制器（如APIC）的操作。 2. 攻击模型：恶意VM可以编程其直通的PCI设备，或利用漏洞，以极高的速率产生中断请求。由于中断是虚拟化的， Hypervisor需要为每个中断进行上下文切换和状态更新，产生开销。如果恶意VM能产生足够高的中断频率，可以： a. 耗尽Hypervisor的CPU时间，影响其他VM的性能。 b. 导致目标VM（如果中断是定向的）的虚拟CPU被频繁抢占，无法执行有效工作。 c. 塞满虚拟中断控制器的队列，导致合法中断丢失。 3. 数学模型：设Hypervisor处理一个虚拟中断的平均时间为t_vint。攻击者VM产生中断的速率为λ_attack（中断/秒）。则Hypervisor用于处理该VM中断的CPU占用率为ρ = λ_attack * t_vint。要使系统饱和，需ρ >= 1。对于多核，攻击者需针对每个vCPU。现代Hypervisor有中断速率限制，但攻击者可能试图绕过。

影响：可导致目标VM或整个宿主机的性能严重下降，甚至不可用。检测：相对容易检测，因为中断速率异常高。

排队论、性能干扰、资源耗尽。利用虚拟化开销作为攻击载体。

场景：云平台中，恶意租户利用有缺陷或恶意的设备驱动，发起对同主机其他VM的拒绝服务攻击。特征：内部DoS、利用虚拟化层、可能被误认为硬件故障。

λ_attack: 攻击者VM产生虚拟中断的速率。 t_vint: Hypervisor处理单个虚拟中断的平均时间（包括VM exit/entry）。 ρ: Hypervisor CPU占用率。 Q_size: 虚拟中断控制器的队列长度。

排队论： M/M/1 或 M/D/1 队列模型，利特尔定律。优化：在约束下最大化λ_attack。性能分析：上下文切换开销。

1. 攻击者VM控制一个可产生中断的设备（如网卡、定时器）。 2. 编程设备，使其以最大可能速率产生中断（例如，将网络接收环的缓冲区设为最小，并发送大量小包触发接收中断）。 3. 持续攻击，产生中断风暴。 4. Hypervisor影响： a. 频繁的VM exit，处理中断注入。 b. 目标VM的vCPU频繁被中断抢占，执行效率骤降。 c. 可能产生中断丢失或延迟。

中断流：物理设备产生中断 -> Hypervisor截获 -> 翻译为虚拟中断 -> 注入目标VM -> VM处理中断 -> VM恢复执行。攻击者通过恶意设备产生极高频率的物理中断流，经虚拟化层放大为对Hypervisor和目标VM的“洪流”攻击。

硬件：依赖设备的中断产生能力。某些设备支持中断合并 (interrupt coalescing) 可缓解。软件：防御： Hypervisor必须实现虚拟中断速率限制，对来自单个VM或设备的中断进行整形或节流。监测异常中断频率并告警/隔离。使用轮询模式代替中断驱动，但可能增加延迟。

Safety-D1-0077

密码学应用

多媒体/图像隐写

基于生成对抗网络的隐写术

对抗性隐写 (SteganoGAN)

1. 目标：训练一个编码器E和解码器D，使得对于秘密消息m和封面图像c，生成的载密图像s = E(c, m)与c在视觉上难以区分，且D(s) = m。同时，希望s能抵抗隐写分析器H的检测。 2. 对抗训练框架： a. 生成器 (G)：即编码器E，输入(c, m)，输出载密图像s。 b. 判别器 (D_steg)：隐写分析器，输入图像，输出是真实封面(c)或载密图像(s)的概率。 c. 解码器 (D)：从s中恢复m。 3. 损失函数： – 对抗损失： L_adv = E[log D_steg(c)] + E[log(1 – D_steg(s))]，鼓励s欺骗D_steg。 – 重建损失： `L_rec =

D(s) – m

_1，确保消息准确恢复。 – **感知损失**：L_per =

VGG(s) – VGG(c)

_2，确保s与c在特征空间相似。 – **总损失**：L_G = λ_adv * L_adv + λ_rec * L_rec + λ_per * L_per。 **4. 训练**：交替训练生成器G（编码器E和解码器D）和判别器D_steg`，形成极小极大博弈。

Safety-D1-0078

系统安全

操作系统/进程间通信

Unix域套接字 (UDS) 权限绕过

利用UDS文件描述符传递的权限混淆

1. 背景： Unix域套接字允许进程间传递文件描述符 (fd)。接收进程获得一个指向相同内核文件对象的新fd，通常继承发送进程对该文件的访问权限（如读、写）。 2. 漏洞模式：特权进程P_priv打开一个敏感文件/etc/shadow（只读），获得fd fd_shadow。非特权进程P_unpriv创建一个UDS并与P_priv连接。 P_priv通过UDS将fd_shadow发送给P_unpriv。在接收端，内核会为P_unpriv创建一个新的fd fd_new，它指向同一个/etc/shadow内核文件对象。关键问题： fd_new的权限应该是什么？如果内核错误地赋予了fd_new与P_priv原始打开时相同的权限（读），那么P_unpriv就获得了读取/etc/shadow的能力，实现了权限提升。 3. 正确行为：接收进程获得的fd，其权限不应超过接收进程本身对该文件的访问权限（基于文件系统权限位和进程凭证）。在传递前，内核应进行权限检查。

严重性：本地权限提升，从普通用户读取root文件。条件：需要找到一个有漏洞的特权进程，愿意通过UDS传递敏感fd。

操作系统安全、权能模型、文件描述符语义。文件描述符传递不应扩大接收者的权限。

场景： Linux/Unix系统中，存在将文件描述符用于进程协作的服务（如某些数据库、监控代理）。特征：本地攻击、利用进程间协作机制、逻辑漏洞。

fd_shadow: 特权进程打开敏感文件获得的文件描述符。 UDS: Unix域套接字，用于进程间通信。 fd_new: 接收进程获得的新文件描述符。 cred_send, cred_recv: 发送和接收进程的凭证（UID, GID等）。 file_perms: 文件本身的权限位（如rw-r—–）。

权限检查：访问控制矩阵，基于凭证的检查。进程间通信：文件描述符传递的语义。系统调用： sendmsg/recvmsgwith SCM_RIGHTS。

1. 攻击者准备：作为非特权用户，创建UDS并监听。 2. 诱导特权进程：通过某种方式（如利用特权进程的其他功能）使其连接到攻击者的UDS，并诱使其发送一个已打开的敏感文件描述符fd_sensitive。 3. 接收fd：攻击者进程调用recvmsg接收控制消息SCM_RIGHTS，获得新的文件描述符fd_new。 4. 尝试访问：攻击者通过fd_new尝试读取或写入。如果内核存在漏洞，未对接收者进行权限检查，则访问成功，权限绕过达成。 5. 利用：读取敏感文件内容。

数据流：敏感文件 <-(通过fd_sensitive)- 特权进程 <-(通过UDS传递fd_sensitive)- 攻击者进程。攻击者通过UDS这个“管道”获取了指向敏感文件的句柄。漏洞在于，内核在创建这个新句柄时，没有验证攻击者是否原本就有权限访问该文件，相当于将访问权“泄漏”了出去。

硬件：无特殊需求。软件：防御：内核必须在recvmsg处理SCM_RIGHTS时，对接收进程进行文件访问权限检查，检查应基于接收进程的凭证和文件模式，而不是发送进程的打开模式。此漏洞在Linux内核历史中已修复。

Safety-D1-0079

密码学应用

云数据审计/可证明数据持有

概率性可证明数据持有 (PDP)

基于BLS签名的PDP方案

1. 目标：客户端将文件F外包到云服务器，之后可以随机挑战服务器以证明其仍完整持有F，而无需下载整个文件。 2. 预处理：客户端将文件分为n个块m_i。生成公私钥对(sk, pk)。为每个块计算一个认证标签σ_i = (H(i) * u^{m_i})^{sk}，其中H是哈希到椭圆曲线群G1的函数， u是G1的一个生成元。客户端存储(pk, {σ_i})，将({m_i}, {σ_i})发送到服务器，删除本地文件。 3. 挑战：客户端随机选择c个块索引的集合Q，并为每个i ∈ Q选择一个随机系数v_i ∈ Z_p。发送挑战chal = (Q, {v_i})给服务器。 4. 证明：服务器计算聚合值μ = Σ_{i∈Q} v_i * m_i mod p和 σ = Π_{i∈Q} σ_i^{v_i}。发送证明(μ, σ)给客户端。 5. 验证：客户端检查等式： e(σ, g) == e( Π_{i∈Q} H(i)^{v_i} * u^{μ}, pk )，其中e是双线性对， g是G2的生成元。如果相等，则通过验证。 6. 安全：基于计算Diffie-Hellman假设。服务器若丢失或篡改任何块，无法通过验证，除非能以不可忽略概率伪造BLS签名。

检测概率：假设文件有n块，挑战c块。如果服务器丢失了t块，则单次挑战检测到丢失的概率为 1 – C(n-t, c) / C(n, c)。通过多次挑战可无限接近1。通信开销：证明大小恒定（一个群元素和一个域元素），与c无关。

双线性对密码学、概率论、可证明安全。利用同态标签聚合实现高效验证。

场景：云存储完整性审计，归档数据验证。特征：公开可验证（有公钥即可）、概率性检查、高效（亚线性通信）。

F: 原始文件。 m_i: 第i个文件块。 (sk, pk): BLS签名密钥对。 σ_i: 第i块的认证标签。 Q, v_i: 挑战集合和随机系数。 μ, σ: 服务器的聚合证明。 e: 双线性映射G1 x G2 -> Gt。

代数：群指数运算，双线性对性质。概率：抽样检测的概率计算。密码学： BLS签名，同态性。

1. 密钥生成：客户端生成(sk, pk)。 2. 标签生成：对每个块i=1 to n，计算σ_i = (H(i) * u^{m_i})^{sk}。 3. 外包：发送( {m_i}, {σ_i} )给服务器，本地保留(pk, 文件摘要)。 4. 挑战阶段：客户端随机选择c个索引Q和系数{v_i}，发送chal。 5. 证明生成：服务器计算μ = Σ v_i m_i mod p， σ = Π σ_i^{v_i}，返回(μ, σ)。 6. 验证：客户端计算左边LHS = e(σ, g)，右边RHS = e( Π H(i)^{v_i} * u^{μ}, pk )，检查LHS == RHS。

信息流：客户端生成标签（绑定数据块）-> 与数据一并存储于云 -> 客户端发起随机挑战（指定部分块）-> 服务器聚合被挑战块的数据和标签生成简洁证明 -> 客户端用双线性对快速验证。数据完整性证据通过挑战-响应的交互流来提供，证据本身是聚合的、可验证的密码学承诺。

硬件：需要支持双线性对运算（计算较慢），可使用硬件加速。软件：实现椭圆曲线和双线性对运算库。客户端和服务器都需要进行计算，但客户端验证开销远小于下载文件。

Safety-D1-0080

应用安全

云桌面/远程显示协议

利用视频编码的屏幕内容窃取

针对H.264/AVC帧内预测的信息泄露

1. 背景：远程桌面协议（如RDP, VNC）使用视频编解码器（如H.264）压缩屏幕变化区域。帧内预测利用当前块相邻已编码像素预测当前块，以消除空间冗余。 2. 攻击模型：攻击者作为中间人（或恶意服务器）可以观察到编码后的视频流。由于帧内预测模式的选择强烈依赖于原始像素内容，分析这些模式可以泄露原始屏幕的部分信息。例如，文本区域通常具有尖锐的边缘，会倾向于选择方向性预测模式（如水平、垂直）。而平滑区域会选择DC预测模式。 3. 攻击方法： a. 从码流中解析出每个4×4或8×8亮度块的帧内预测模式mode(i, j)。 b. 将预测模式映射为视觉特征。例如，将水平预测模式mode=1的块渲染为水平条纹，垂直预测模式mode=0渲染为垂直条纹， DC模式渲染为灰色。 c. 将这些模式图案按块位置拼接，可以生成一个低分辨率但可识别的“预测模式图像”，该图像近似反映了原始屏幕的边缘和纹理信息，可能泄露文本、图标轮廓等。

可读性：对于包含文本的屏幕区域，重建的“模式图像”可能足以识别单词或数字，特别是当字体较大时。分辨率：块级（4×4或8×8像素），细节有限。

视频压缩原理、信息论、图像重建。预测模式是原始图像内容的函数，构成一个侧信道。

场景：窃听加密的远程桌面会话（如通过VPN），在不破解加密的情况下，从元数据（预测模式）中推断屏幕内容。特征：被动攻击、仅需访问码流、对高压缩率设置更有效（因为模式选择更关键）。

mode(i, j): 位于(i,j)的图像块的帧内预测模式（0-8或更多）。 B: 块大小（如4或8）。 I_recon: 从预测模式重建的低分辨率图像（每个块一个“像素”代表模式）。映射函数 M(mode): 将模式值映射为颜色或纹理。

图像处理：块处理，模式到纹理的映射。信息论：预测模式与原始内容之间的互信息。压缩：帧内预测算法。

1. 捕获码流：攻击者嗅探网络流量，提取H.264/AVC的NAL单元，特别是包含帧内编码片（I-slice）的单元。 2. 解析：解码码流的头部信息，提取每个亮度块的帧内预测模式，得到模式矩阵Modes。 3. 可视化：对Modes中的每个元素mode，根据预定义的映射M(mode)生成一个BxB的图案块（例如，水平模式画水平线）。将所有块拼接成一幅图像I_recon。 4. 后处理：对I_recon进行平滑、锐化或超分辨率处理，提高可读性。 5. 解读：攻击者尝试从I_recon中识别文本、界面元素等。

信息流：原始屏幕像素 -> 编码器进行帧内预测，选择最优模式 -> 模式信息被写入码流 -> 攻击者截获码流 -> 解析提取模式矩阵 -> 将模式矩阵反渲染为近似图像。原始屏幕的几何结构信息（边缘方向）通过预测模式这个压缩过程的“副产品”泄露出来。

硬件：无特殊需求，攻击者需要能解析H.264码流。软件：攻击者需实现部分H.264解析器。防御：在编码器端，可以随机化或强制使用特定的预测模式（如总是用DC模式），但这会降低压缩效率。或对码流进行加密，包括头部信息（但可能影响网络适应性）。使用更安全的远程显示协议，其对屏幕内容进行语义感知的编码而非单纯视频压缩。

Safety-D1-0081

系统安全

虚拟化/热迁移

虚拟机热迁移过程中的内存泄露

利用迭代预拷贝的边迁移边访问

1. 热迁移过程：为减少停机时间，常使用预拷贝。源Hypervisor迭代地将VM的内存页拷贝到目标主机。每次迭代拷贝上一轮传输过程中被VM写脏的页（脏页）。 2. 攻击模型：假设攻击者控制源主机上的一个VM，该VM即将被迁移。攻击者希望在迁移过程中，将其内存中的敏感信息泄露给目标主机的（潜在）恶意管理员。 3. 攻击方法：攻击者VM内的进程可以精确控制对特定内存页的写入时机。 a. 攻击者将敏感数据放在一个内存页P中。 b. 在迁移开始前的最后一刻，攻击者写入P，将其标记为脏页。 c. 在第一次迭代预拷贝中， P可能不会被传输（因为不是初始传输集）。 d. 在第一次迭代后、第二次迭代前的短暂间隔，攻击者再次写入P，确保它在第二轮脏页列表中。 e. 如此反复，攻击者可以确保P在整个迁移过程中始终是脏页，从而在每次迭代时都被传输。这样，敏感数据P的内容会在网络中传输多次。 f. 目标主机的恶意管理员可能通过监控网络流量或内存快照，有机会多次捕获P的内容，提高成功窃取的概率。

泄露风险：增加了敏感数据在网络上暴露的次数和时间窗口。隐蔽性：表现为正常的迁移流量，难以检测。

迭代算法、边信道、信息泄露。利用迁移算法对脏页的重复传输特性。

场景：跨安全域（如从私有云到公有云）的虚拟机迁移，担心目标环境不可信。特征：主动攻击、需要控制被迁移的VM、利用迁移协议特性。

P: 包含敏感数据的内存页。 D_i: 第i轮迭代传输的脏页集合。 t_iter: 迭代周期。 t_write: 攻击者对页P执行写入操作的时间点。 n_transmits: 页P被传输的次数。

时序控制：精确控制写入操作在迭代周期的相位。算法分析：预拷贝算法的迭代过程。信息论：增加传输次数以提高窃取概率。

1. 迁移启动：源Hypervisor开始预拷贝，传输所有内存页（第一轮）。 2. 攻击者行动：在每轮传输完成后、下一轮开始前，攻击者进程对敏感页P执行一次写入（如*((volatile char*)ptr) = 1;）。 3. 标记脏页：由于写入， P被CPU的脏位标记。 4. 下一轮传输： Hypervisor收集脏页，包含P，将其再次传输。 5. 重复：步骤2-4持续进行，直到迁移进入停机检查点阶段。 6. 结果：页P的内容在网络上被传输了多次（可能数十次），而非一次。

数据流：敏感数据驻留在VM内存页P-> 攻击者写入使P变脏 -> 被Hypervisor内存追踪机制记录 -> 在下一轮预拷贝中被传输到网络 -> 攻击者再次写入使其保持脏状态 -> 再次被传输。攻击者通过注入“写入”操作，将敏感数据“泵入”迁移数据流中，并使其循环流动，增加被截获的机会。

硬件：依赖CPU的脏页标记机制。无特殊防御硬件。软件：防御：在迁移敏感VM时，使用后拷贝（post-copy）或在预拷贝中引入页传输次数的限制。对迁移流量进行端到端加密。源Hypervisor可检测异常脏页模式（如单个页在多轮中持续变脏）。

Safety-D1-0082

密码学应用

机器学习/模型提取

功能等效模型提取 via 决策边界

基于边界搜索的黑盒模型提取

1. 目标：对于一个黑盒分类模型F: X -> Y，提取一个功能等效的模型G，使得对于（几乎）所有x， G(x) = F(x)。 2. 攻击方法：不依赖置信度分数，仅使用预测标签。核心思想是探索决策边界。 a. 起点：选择两个输入x_a, x_b，使得F(x_a) != F(x_b)。 b. 二分搜索：在x_a和x_b的连线上进行二分搜索，寻找决策边界点x_*，使得F(x_*)在两类之间变化。具体地，定义x(t) = (1-t)*x_a + t*x_b, t ∈ [0,1]。通过二分法找到t*，使得F(x(t*))与F(x(t*+ε))不同，则x(t*)近似在边界上。 c. 收集边界点：重复以上过程，获得大量决策边界点{x_*^i}及其预测标签（在边界两侧）。 d. 训练替代模型：使用这些边界点作为训练数据。对于每个边界点x_*，构造两个非常接近的点x_*+δ和x_*-δ，并分配它们在边界两侧的标签（来自F）。用这些数据训练一个模型G，其决策边界将被迫逼近收集到的边界点。 3. 有效性：对于线性或低复杂度边界的模型，此方法高效。对于高复杂度边界，需要更多查询。

查询效率：需要O(d * log(1/ε))量级的查询来定位一个d维边界点，效率低于基于梯度的攻击，但仅需标签。提取质量：在模型F决策边界光滑的情况下，可提取出高保真度的替代模型。

优化（二分搜索）、计算几何（决策边界）、主动学习。通过探测输入空间的决策边界来逆向工程模型。

场景：攻击仅提供最终分类标签（无置信度）的在线AI服务，用于模型窃取或为后续对抗攻击做准备。特征：仅需标签、适用于更广泛的API、查询开销大。

F: 目标黑盒模型（仅提供argmax标签）。 x_a, x_b: 初始点，预测不同。 t: 插值参数。 x_^i: 第i个找到的决策边界点。 δ: 一个小扰动向量。 G*: 替代模型（如SVM, 神经网络）。

优化：在一维线段上寻找根（决策变化点）。几何：输入空间的线性插值，决策边界的几何形状。搜索：二分搜索算法。

1. 初始化：随机选择一对点x_a, x_b，查询F得到y_a, y_b。如果y_a == y_b，则重新选择，直到y_a != y_b。 2. 边界搜索：在连接x_a和x_b的线段上进行二分搜索： low=0, high=1。 while high – low > ε: mid = (low+high)/2 x_mid = (1-mid)*x_a + mid*x_b y_mid = F(x_mid) if y_mid == y_a: low = midelse: high = mid。得到边界参数t* ≈ mid，对应点x_*。 3. 收集：记录x_*，以及F(x_* – δ‘)和F(x_* + δ‘)的标签（δ‘是一个极小随机向量）。 4. 重复：从新的随机点对开始，收集大量边界点。 5. 训练：用所有收集到的(x, y)对训练替代模型G。

信息流：攻击者生成候选点x(t)-> 查询黑盒模型F得到标签y-> 根据标签变化调整搜索区间 -> 定位决策边界点x_*-> 记录边界点及其邻域标签 -> 用这些点“描绘”出决策边界的形状 -> 训练模型G拟合这个形状。攻击者像“雷达”一样扫描输入空间，用F的标签响应作为回声来绘制决策边界的轮廓图。

硬件：无特殊需求，但大量查询需要网络和计算资源。软件：攻击者实现二分搜索和模型训练代码。防御：对查询进行速率限制、检测异常查询模式（如大量沿直线的查询）、在决策边界附近引入随机性（如随机分类），但会降低模型可用性。

Safety-D1-0083

系统安全

操作系统/内核模块

利用eBPF程序的内核提权

eBPF验证器绕过与内存任意读写

1. eBPF背景：扩展伯克利包过滤器允许用户空间将受限的字节码程序加载到内核执行。程序通过验证器确保安全：无循环（除非有边界）、内存访问在边界内、不包含危险指令。 2. 漏洞模式：验证器可能存在逻辑漏洞，允许恶意eBPF程序： a. 类型混淆：利用验证器对指针和标量的跟踪不准确，将一个指针类型当作标量进行算术运算，然后转换回指针，从而生成一个指向内核任意地址的指针。 b. 边界检查绕过：验证器对数组访问的边界检查基于变量可能的值范围。攻击者可以构造复杂的算术运算，使验证器推导出的边界是安全的，但实际运行时，通过溢出或符号错误，索引会越界。 c. 未初始化寄存器：使用未正确初始化的寄存器，其值可能包含之前的内核指针残留。 3. 利用：一旦获得任意内核内存读/写原语，可以修改凭证结构体（task_struct->cred）提升权限，或修改函数指针劫持控制流。

严重性：普通用户到root内核权限提升。利用条件：需要CAP_BPF能力（通常需要root），但若系统配置不当（如启用unprivileged_bpf_disabled=0），普通用户也可加载某些类型的eBPF程序。

程序验证、静态分析、符号执行。验证器的形式化证明与实际实现之间的差距。

场景： Linux本地提权，利用eBPF验证器漏洞（如CVE-2021-31440）。特征：内核漏洞、利用新兴的、复杂的内核子系统。

eBPF prog: 攻击者编写的恶意eBPF字节码。 verifier: eBPF验证器，对程序进行静态分析。 reg: eBPF虚拟机寄存器。 map: eBPF映射，用于与用户空间通信。 kernel_addr: 攻击者希望读写的内核地址。

程序分析：值范围分析，指针分析。符号执行：验证器使用的分析技术。构造：精心设计字节码以欺骗验证器。

1. 攻击者编写恶意eBPF程序，利用验证器漏洞（如类型混淆）构造出可进行越界内存访问的代码路径。 2. 加载程序：通过bpf()系统调用加载程序。验证器进行静态分析，由于漏洞，错误地认为程序安全，允许加载。 3. 程序附加：将程序附加到某个事件（如kprobe， tracepoint）。 4. 触发执行：触发事件（如执行特定系统调用），内核执行eBPF程序。 5. 恶意操作：在运行时，程序利用验证漏洞产生的错误状态，对内核内存进行任意读写，例如： a. 读取current_task->cred地址。 b. 修改cred中的uid, gid为0。 6. 权限提升：攻击者进程现在具有root权限。

控制流：用户空间程序 -> bpf()系统调用 -> 验证器分析（被绕过）-> 程序JIT编译并加载 -> 内核事件触发程序执行 -> 程序执行恶意内存访问 -> 修改内核关键数据。攻击者通过注入“特制”的eBPF字节码流，流经有漏洞的验证器过滤器，进入内核执行流，最终污染内核数据流。

硬件：无特殊需求。 eBPF JIT编译器将字节码转为机器码，可能引入新漏洞。软件：防御：保持内核和验证器更新。默认禁用非特权eBPF (sysctl kernel.unprivileged_bpf_disabled=1)。使用Linux安全模块（如SELinux）限制bpf能力。形式化验证eBPF验证器。

Safety-D1-0084

应用安全

云存储/文件同步

利用文件版本历史恢复敏感数据

云盘“永久删除”绕过

1. 背景：许多云存储服务（如Dropbox, Google Drive）保留文件的版本历史，允许用户回滚到旧版本。当用户删除文件时，通常文件会被移动到“垃圾桶”，在一段时间后（如30天）自动清空，或用户可以手动“永久删除”。 2. 攻击模型：攻击者获得了受害者的云存储账户访问权限（通过钓鱼、密码泄露）。受害者曾上传过一份敏感文件F，后将其“永久删除”。攻击者试图恢复F。 3. 攻击方法： a. 检查文件活动日志或版本历史功能。如果服务在“永久删除”后仍然保留文件的版本历史，攻击者可能通过特定接口（如旧版API）访问到这些历史版本。 b. 尝试恢复已删除的文件。某些服务对“永久删除”的实现可能只是在用户界面隐藏文件，而实际数据在服务器后端可能保留更长时间（出于备份或法律合规）。攻击者可能通过未公开的API或管理功能访问这些“已删除”数据。 c. 利用“共享”功能残留。如果F曾被共享给其他用户，即使所有者删除了F，接收者的副本可能仍然存在。攻击者可以枚举受害者曾共享过的链接或用户，尝试访问这些残留副本。

恢复可能性：取决于服务提供商的具体实现和数据保留策略，并非总是成功，但存在风险。时间窗口：可能在“永久删除”后数月内仍可恢复。

数据生命周期管理、访问控制、元数据残留。云服务的数据删除语义可能与用户期望不符。

场景：云账户被盗后的数据泄露，或内部威胁（恶意管理员）恢复用户已删除的敏感文件。特征：账户级攻击、利用服务特性、隐私泄露。

F: 受害者希望永久删除的敏感文件。 v_i: 文件F的第i个历史版本。 t_delete: 文件被“永久删除”的时间点。 t_retention: 服务提供商实际的数据保留期限（通常未明确告知用户）。 API_undelete: 可能的未公开恢复API。

数据管理：版本控制，垃圾回收策略。访问控制：对“已删除”数据的权限检查。残留：元数据（如共享链接）的持久性。

1. 攻击者获得账户凭证。 2. 浏览常规界面：检查“我的文件”和“垃圾桶”，确认文件F不可见。 3. 探索版本历史：尝试访问文件F可能曾存在的目录的版本历史（如果服务支持目录级版本历史）。或通过搜索功能尝试搜索F的部分文件名或内容（如果索引未清除）。 4. 尝试API调用：使用云服务的官方API，调用如files/list_revisions或files/get_metadata，参数中包含include_deleted=true（如果API支持）。 5. 恢复尝试：如果找到F或其历史版本的引用，尝试调用files/download或files/restore。 6. 共享链探测：查询账户的共享链接列表或共享关系，寻找指向F的链接，并尝试访问。

信息流：文件F被用户“永久删除” -> 从前端界面移除 -> 但数据可能仍在后端存储，且元数据（版本、链接）未被完全清除 -> 攻击者通过非标准路径（API，历史视图）访问后端元数据 -> 通过元数据定位到残留数据 -> 恢复文件。用户期望的“删除”数据流（流向虚无）在服务后端被截断或分流到了隐藏的“存档”池中，攻击者从该池中打捞数据。

硬件：无特殊需求。软件：防御：服务提供商应在用户执行“永久删除”后，安全地擦除文件的所有副本和元数据，包括所有历史版本和备份。确保API不会暴露已删除的数据。对用户进行教育，了解云删除的实际含义。使用客户端加密，即使数据被恢复，没有密钥也无法解密。

Safety-D1-0085

密码学应用

后量子密码/数字签名

基于哈希的数字签名 (SPHINCS+)

少量次签名方案

1. 核心思想：使用哈希函数构造一次性签名 (OTS)，然后通过Merkle树将多个OTS公钥聚合成一个长期公钥。 2. 密钥生成：生成2^h个OTS密钥对(sk_i, pk_i)。构建一棵高度为h的Merkle树，其中叶子节点是pk_i的哈希。树根PK是长期公钥。 3. 签名：对消息m，计算d = H(m)。将d分为两部分：用于选择OTS索引i，和OTS本身的随机化值。使用选定的sk_i对m进行OTS签名σ_ots。签名还包括： σ_ots， pk_i，以及从pk_i到树根PK的Merkle认证路径Auth。所以签名σ = (i, σ_ots, pk_i, Auth)。 4. 验证：用pk_i和σ_ots验证OTS签名。然后验证pk_i的哈希在Merkle路径Auth下能否计算出根哈希PK‘，并检查PK‘ == PK。 5. 安全性：基于哈希函数的抗碰撞性和原像阻力。每个OTS密钥只能使用一次，否则安全性会降低。通过超大数量的OTS密钥（如2^60）来提供大量签名容量。

签名大小：较大（~8-41 KB），因为包含Merkle路径和OTS签名。安全强度：可配置为NIST安全级别1, 3, 5（对应128, 192, 256位经典安全）。量子安全：是，因为仅基于哈希。

哈希函数、 Merkle树、一次性签名。将许多弱签名（OTS）组合成一个强签名。

场景：需要长期量子安全的数字签名，如软件更新、证书颁发、区块链。特征：后量子安全、状态性（需跟踪已用索引）、签名大但验证快。

h: Merkle树高度，决定最大签名数量 2^h。 H: 抗碰撞哈希函数（如SHA-256, SHAKE-256）。 (sk_i, pk_i): 第i个一次性签名密钥对。 PK: Merkle树根，作为长期公钥。 Auth: Merkle认证路径，包含h个哈希值。 σ: 完整签名。

哈希：抗碰撞性，原像阻力。树结构： Merkle树构造与验证。组合：将多个密码学原语组合提升安全性。

1. 密钥生成：生成2^h个OTS密钥对，计算所有pk_i的哈希作为叶子，构建Merkle树，输出根PK为公钥，保存所有sk_i和树结构为私钥（实际通过种子派生）。 2. 签名消息m： a. 计算随机化哈希d = H(m)。 b. 从d解析出索引i（确定使用哪个OTS密钥）。 c. 使用sk_i对m生成OTS签名σ_ots。 d. 获取pk_i到树根的Merkle路径Auth。 e. 输出签名(i, σ_ots, pk_i, Auth)。 3. 验证： a. 用pk_i验证σ_ots对m的有效性。 b. 验证pk_i的哈希在路径Auth下计算出的根哈希PK‘是否等于公布的PK。 c. 如果两者都通过，则接受签名。

信息流：消息m-> 哈希和随机化 -> 选择索引i-> 用对应的OTS私钥sk_i签名 -> 附上公钥pk_i及其Merkle证明 -> 形成完整签名。验证时，分别验证OTS签名和Merkle证明，两者通过则意味着该签名来自持有整棵Merkle树对应私钥的实体。签名是“一次一密”的，但通过树结构获得了可多次验证的长期信任。

硬件：需要高效的哈希运算单元。签名生成需要大量哈希计算（构建OTS和路径）。软件：实现WOTS+等OTS方案和Merkle树逻辑。必须安全地管理状态（已用索引）以防重复使用。

Safety-D1-0086

系统安全

操作系统/内存漏洞

利用页表隔离不完整的侧信道

分支历史注入 (BHI) / 跨特权边界

1. 背景：现代CPU有分支预测器，在用户态和内核态之间可能共享部分分支历史（如全局历史缓冲区）。 2. 攻击原理：类似于Spectre-BTI，但攻击方向是从用户态毒化内核态的分支预测。 a. 训练：攻击者在用户态反复调用一个合法的系统调用，该调用在内核中有一条条件分支，其方向取决于用户提供的参数。攻击者通过控制参数，训练内核的分支预测器，使其在特定条件下总是预测“跳转”。 b. 毒化：攻击者随后触发一个不同的、但在分支预测器中索引相同的内核路径（例如，通过另一个系统调用或利用一个既有漏洞进入内核）。由于分支预测器被之前训练误导，它可能错误地预测跳转，导致内核短暂地执行一段本不该执行的代码（gadget），这段代码可能将部分内核内存加载到微架构状态（如缓存）。 c. 探测：攻击者回到用户态，通过缓存侧信道（如Flush+Reload）探测哪些地址被加载，从而泄露内核内存信息。 3. 关键：需要找到一个在用户态可训练、且与目标敏感内核gadget共享分支预测器历史记录的分支。

影响：从无特权的用户空间读取内核内存，绕过KASLR，可能泄露敏感信息。防御：需要硬件（如eIBRS）和软件（如retbleed缓解）结合。

微架构侧信道、分支预测、推测执行。利用跨特权级的预测器状态共享。

场景： Linux/Windows本地攻击，在拥有eIBRS等防御前，攻击者利用BHI读取内核内存。特征：无特权攻击、利用CPU微架构、需要已知或可触发内核代码路径。

BPU: 分支预测单元，包含全局历史寄存器 (GHR) 等。 PC: 程序计数器，用于索引分支预测器。 gadget: 一段内核代码片段，其执行会将敏感数据载入缓存。 cache side channel: 用于探测缓存状态的计时技术。

微架构：分支预测器算法（如TAGE, GShare）。侧信道：缓存攻击，时序分析。安全：跨特权边界隔离。

1. 定位gadget：通过逆向或已知信息，找到一个在内核中、可通过分支误预测触发的gadget，其地址addr_g。 2. 训练：反复调用一个合法的系统调用S_train，该调用在内核地址addr_train处有一个条件分支。通过精心选择参数，使该分支总是被采取，从而训练BPU在遇到addr_train时预测“跳转”。目标是使addr_train和addr_g在BPU的索引函数Index(PC, GHR)上产生冲突（即映射到同一预测器条目）。 3. 误预测触发：通过另一系统调用或漏洞进入内核，使执行流到达addr_g。由于BPU被毒化，它可能错误地预测addr_g处的分支为跳转，导致短暂执行gadget。 4. 泄露： Gadget执行将内核敏感数据加载到缓存中。 5. 探测：攻击者返回用户态，通过缓存侧信道探测哪些缓存线被加载，从而推断出敏感数据。

信息流：攻击者在用户态训练分支预测器 -> 预测器状态被污染 -> 内核执行时，被污染的分支预测导致短暂误执行gadget -> gadget访问内核敏感数据并载入缓存 -> 攻击者在用户态通过缓存侧信道探测到数据访问痕迹 -> 推断出敏感数据。信息通过被污染的微架构状态（分支预测器）作为桥梁，从内核推测执行流泄露到用户态可观测的缓存状态。

硬件：防御： CPU需实现更强的分支预测隔离，如Intel eIBRS (enhanced Indirect Branch Restricted Speculation) 在进入内核时清除分支历史。攻击端需要高精度计时器。软件：内核需启用相关缓解（如retbleed补丁）。编译器可使用lfence等指令阻止推测执行跨越关键边界。

Safety-D1-0087

应用安全

视频会议/虚拟背景

虚拟背景下的隐私泄露：反射与倒影

从眼镜/光滑物体的倒影中恢复信息

1. 威胁模型：用户使用虚拟背景功能，认为自己身后的真实背景已被隐藏。然而，如果用户佩戴眼镜，或身后有光滑物体（如相框、显示器），这些物体的表面可能会反射出用户身后的真实环境。 2. 攻击方法： a. 检测反射区域：使用计算机视觉算法检测视频帧中可能包含反射的区域R，如通过高光检测、偏振特征或基于深度学习的分割模型。 b. 反射分离：从区域R的混合图像I中分离出反射层L_r和背景（人脸）层L_b。这可以建模为： I = L_b + R * L_r，其中R是反射系数（与角度相关）。这是一个欠定问题，但可以利用多帧信息（用户轻微移动时反射内容变化）或物理先验（反射图像通常较模糊、对比度低）进行估计。 c. 增强与识别：对分离出的反射层L_r进行去模糊、超分辨率、对比度增强等处理，尝试恢复可读的图像，从而推断用户身后的环境信息（如白板上的字、窗户外的建筑、海报内容）。

可恢复性：对高质量的眼镜反射，在理想光照和静止背景下，可能恢复出可识别的文本或物体轮廓。通常分辨率很低，细节有限。条件：需要用户佩戴眼镜且身后有明亮、高对比度的物体。

计算机视觉（反射分离、盲去卷积）、图像处理、物理光学（反射模型）。虚拟背景无法消除物理世界中的光学反射。

场景：远程办公视频会议中，无意中泄露家庭或办公室环境的敏感细节（如白板上的设计草图、书架上的书籍标题）。特征：被动观测攻击、利用物理现象、需要一定的图像处理技术。

I: 观测到的视频帧（包含人脸和反射）。 R: 图像中反射区域掩码。 L_b, L_r: 待求的背景层和反射层。 R: 反射系数（空间变化）。 PSF: 点扩散函数，描述反射的模糊程度。

图像处理：盲源分离，图像分解。优化：在物理约束下求解L_b和L_r。物理：反射的光学模型。

1. 视频采集：攻击者（会议参与者）录制或截取用户的视频流。 2. 反射区域检测：对视频帧，检测眼镜片区域（基于椭圆拟合、深度学习）或其他高亮区域作为候选反射区R。 3. 多帧对齐：利用用户头部的微小运动，对多帧中反射区域的内容进行配准。 4. 反射分离：使用多帧信息求解L_r。例如，假设L_b（人脸）变化慢， L_r（反射）随头部运动而快速变化，可通过主成分分析或独立成分分析进行分离。 5. 图像增强：对L_r进行反卷积（估计PSF）、锐化、对比度拉伸，提高可读性。 6. 解读：人工或OCR识别增强后的图像内容。

信息流：用户身后真实场景的光线 -> 照射到眼镜等光滑表面 -> 发生反射 -> 被摄像头捕获，与人脸图像叠加 -> 视频流传输 -> 攻击者接收视频 -> 检测并分离反射成分 -> 增强恢复 -> 得到身后场景的近似图像。隐私信息通过“光学反射”这个物理信道，绕过了“虚拟背景”这个数字滤镜，泄露给攻击者。

硬件：攻击者需要能获取视频流（标准功能）。高质量摄像头和高分辨率视频有利于攻击。软件：攻击者需实现或使用现成的反射分离算法。防御：用户应避免在身后放置敏感物品。视频会议软件可集成反射检测与模糊功能，自动模糊检测到的眼镜区域。使用无镜片眼镜或调整光照减少反射。

Safety-D1-0088

系统安全

虚拟化/嵌套分页

利用嵌套分页的翻译缓存攻击

在AMD-V NPT 或 Intel EPT 的TLB侧信道

1. 背景：在虚拟化中，客户物理地址(GPA)到主机物理地址(HPA)的转换由嵌套页表（NPT/EPT）管理。 CPU会缓存这些转换在TLB中，包括特定于VM的标记。 2. 攻击模型：两个VM（攻击者A和受害者V）在同一物理CPU核心上运行。尽管它们的NPT不同，但底层硬件TLB可能在某些结构上共享（如L2 TLB），或VM切换时TLB条目可能不会被完全刷新（取决于invlpg或INVVPID操作）。 3. 攻击步骤： a. 探测：攻击者VM在切换出CPU前，用已知的GPAg_a填充一些TLB条目。 b. 等待： Hypervisor调度受害者VM运行。受害者VM执行其正常任务，可能会访问其自己的内存，从而分配TLB条目。 c. 再次调度：攻击者VM被再次调度到同一CPU核心。 d. 测量：攻击者立即测量访问g_a的时间。如果访问时间短（TLB命中），说明其TLB条目在受害者VM运行期间未被驱逐，暗示受害者VM的TLB活动不激烈。如果访问时间长（TLB未命中），则表明受害者VM可能进行了大量的内存访问，驱逐了共享TLB中的条目。 e. 通过分析TLB命中/未命中模式的时间序列，可以推断受害者VM的内存访问强度或模式。

信息泄露：可粗粒度推断受害者VM的活动级别（繁忙/空闲），或检测其是否在访问大块连续内存（可能驱逐更多TLB）。噪声：受其他VM和Hypervisor活动影响大。

计算机体系结构（TLB结构、替换策略）、性能侧信道。利用共享的CPU缓存资源作为通信媒介。

场景：跨VM的粗粒度活动监控，在云环境中推断邻户工作负载特征。特征：跨VM、无特权、带宽低、受调度影响大。

g_a: 攻击者VM内的一个客户虚拟地址（对应特定GPA）。 t_access: 测量到的访问g_a的时间。 T_hit, T_miss: TLB命中/未命中的基准访问时间。 TLB_ways: 共享TLB的相联度。 N_entries: 受害者VM可能访问的、与g_a竞争同一TLB组的不同页数。

缓存理论： TLB作为特殊缓存，其替换算法（LRU，随机）。计时分析：从时间差异推断缓存状态。并发：受CPU调度影响。

1. 攻击者VM准备：分配一个页面，获取其

编号

类别

领域

模型配方

定理/算法/模型/方法名称

定理/算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式和参数选择/参数优化

精度/密度/误差/强度

底层规律/理论定理

典型应用场景和各类特征

变量/常量/参数列表及说明

数学特征

时序和交互流程的所有细节/分步骤时序情况及数学方程式

流动模型和流向方法的数学描述

硬件设计/软件设计及资源

Safety-D1-0088

系统安全

虚拟化/嵌套分页

利用嵌套分页的翻译缓存攻击

AMD-V NPT / Intel EPT 的TLB侧信道

计算机体系结构（TLB结构、替换策略）、性能侧信道。利用共享的CPU缓存资源作为通信媒介。

场景：跨VM的粗粒度活动监控，在云环境中推断邻户工作负载特征。特征：跨VM、无特权、带宽低、受调度影响大。

缓存理论： TLB作为特殊缓存，其替换算法（LRU，随机）。计时分析：从时间差异推断缓存状态。并发：受CPU调度影响。

1. 攻击者VM准备：分配一个页面，获取其虚拟地址V_a，重复访问几次以填充TLB。 2. 主动让出CPU：调用sched_yield()或执行短时睡眠，触发VM exit，使Hypervisor调度受害者VM运行。 3. 等待/同步：攻击者VM等待一个预定时间或通过其他信道感知受害者VM任务结束。 4. 再次被调度： Hypervisor调度攻击者VM回到原CPU核心。 5. 立即测量：使用rdtsc等高精度计时器，测量访问V_a的时间t。 6. 分析：如果t ≈ T_hit，推断受害者活动弱；如果t ≈ T_miss，推断受害者活动强。 7. 重复：多次实验统计趋势。

控制流和数据流：攻击者VM执行(访问V_a填充TLB) -> VM exit -> 受害者VM运行(可能访问内存，驱逐TLB) -> VM exit -> 攻击者VM再次运行(测量访问V_a时间)。信息通过共享的TLB物理硬件状态传递，攻击者通过测量自身操作的延迟变化来感知受害者对共享资源的使用情况。

硬件：依赖TLB在不同VM上下文间的共享或残留。防御需硬件支持更激进的TLB刷新（如PCID, VPID）。软件：攻击者需用户级代码。 Hypervisor可通过在VM entry时刷新ASID或使用INVVPID减轻风险，但有性能开销。

Safety-D1-0089

应用安全

浏览器/Web图形

Canvas 指纹追踪与preserveDrawingBuffer滥用

基于Canvas图像数据哈希的持久追踪

1. 原理：使用HTML5 Canvas渲染相同文本或图形时，由于操作系统、字体渲染引擎、图形硬件、驱动程序及抗锯齿设置的细微差异，产生的像素数据会有微小不同。将这些像素数据哈希后可作为设备指纹。 2. 攻击步骤： a. 使用CanvasRenderingContext2D绘制复杂文本、贝塞尔曲线或带有渐变的形状。例如： ctx.fillText(“Hello, fingerprint!”, 10, 50); b. 调用canvas.toDataURL()获取图像的数据URL，或canvas.toBlob()后计算哈希。更隐蔽的方式是利用preserveDrawingBuffer: true创建WebGL上下文，在后续帧中读取渲染结果，绕过某些浏览器的指纹保护。 c. 计算像素数据的哈希（如MD5, SHA-1）。即使差异仅几个像素，哈希值也会截然不同。 3. 对抗preserveDrawingBuffer：默认情况下，浏览器为性能会清除WebGL缓冲区。设置preserveDrawingBuffer: true可保留绘制结果，允许通过readPixels读取，为指纹提供了更稳定、可重复的渲染输出。

唯一性：在桌面环境中区分度高，移动端稍弱。与WebGL指纹结合可增强唯一性。持久性：重装浏览器或清除Cookie后通常不变。浏览器隐私模式可能降低其有效性。

计算机图形学（字体栅格化、抗锯齿）、哈希函数、设备识别。利用软件栈和硬件组合的熵源。

场景：跨网站用户追踪、广告欺诈检测、账号安全（识别常用设备）。特征：脚本可执行、无需用户许可、难以完全阻止。

canvas: HTMLCanvasElement对象。 ctx: Canvas 2D渲染上下文或WebGL上下文。 preserveDrawingBuffer: WebGL上下文属性，布尔值。 pixelData: 从canvas获取的图像像素数据（Uint8Array）。 hash: 对pixelData计算的哈希值（字符串）。

哈希函数：将高维像素数据映射为固定长度摘要。图像处理：像素级数据比较。熵：计算指纹的熵值以衡量唯一性。

1. 创建Canvas元素，设置宽高（如200×50）。 2. 获取渲染上下文，对于WebGL需设置preserveDrawingBuffer: true。 3. 执行绘制操作：设置字体、绘制文本、路径、应用渐变等。 WebGL中执行更复杂的着色器渲染。 4. 读取像素数据： pixelData = ctx.getImageData(0, 0, width, height).data(2D) 或 gl.readPixels(…)(WebGL)。 5. 计算哈希： fingerprint = SHA256(pixelData)。 6. 使用：将哈希值作为标识符发送到服务器或存储在本地用于后续识别。

信息流：浏览器图形栈配置（字体、驱动、硬件）-> 影响Canvas绘图光栅化结果 -> 产生带有设备特征的像素数据 -> 被JavaScript读取并哈希 -> 生成唯一指纹。设备特征通过图形渲染管道“烙印”在像素数据中，被脚本提取。

硬件：依赖GPU和驱动。同一型号硬件指纹可能相似。软件：防御包括：浏览器返回标准化或模糊化的Canvas数据（如Tor Browser），限制preserveDrawingBuffer的使用，或提示用户是否允许Canvas数据访问。但可能破坏依赖Canvas的合法应用。

Safety-D1-0090

软件安全

操作系统/文件系统

利用fanotify事件监控的权限绕过

fanotify标记绕过与特权文件访问

1. 背景： fanotify是Linux内核的文件系统事件通知机制。可以监听文件访问事件，甚至阻塞(FAN_ENABLE_PERM)并决策是否允许访问。常用于防病毒、安全监控软件。 2. 漏洞模型：假设一个安全守护进程D使用fanotify监控/etc/passwd等敏感文件，并对所有访问请求进行审查。攻击者进程A尝试打开/etc/passwd，触发fanotify权限事件。 D收到事件，正在决策时，攻击者利用竞争条件： a. 在D决策前，快速将/etc/passwd移动（rename）到另一个位置，比如/tmp/xyz。 b. 立即创建一个指向/etc/shadow的符号链接，并将其命名为/etc/passwd。 c. 如果D的决策基于最初的文件路径(/etc/passwd)，并且批准了访问，则内核将重新进行路径解析，此时会跟踪新的符号链接，最终攻击者实际打开的是/etc/shadow，绕过了对/etc/shadow本身的监控。 3. 关键： fanotify事件与文件对象(inode)绑定，但决策后的访问会重新进行路径查找，这期间文件系统状态可能已改变。

严重性：可绕过安全软件对关键文件的保护，访问更敏感的文件。竞争窗口：存在于fanotify权限响应和内核重新打开文件之间。

文件系统语义、竞争条件(TOCTOU)、安全监控绕行。利用安全软件决策与内核执行之间的时间差。

场景：绕过主机入侵防御系统(HIPS)、防病毒软件的文件访问控制，实现本地权限提升或信息窃取。特征：本地攻击、需要高频率文件操作、针对特定安全软件。

path_orig: 被监控的原始路径（如/etc/passwd）。 path_target: 攻击者希望访问的真实目标路径（如/etc/shadow）。 fanotify mark: 对path_orig的监控标记。决策响应: 安全守护进程对权限事件的允许/拒绝答复。

时序：竞争窗口分析。文件系统：符号链接解析，重命名原子性。并发：多进程/多线程的快速文件操作。

1. 安全守护进程D：使用fanotify标记/etc/passwd，启用FAN_ENABLE_PERM。 2. 攻击者进程A：调用open(“/etc/passwd”, O_RDONLY)。这被内核阻塞，并生成权限事件给D。 3. 竞争开始：在D处理事件时， A启动另一个线程（或利用信号处理程序）执行： a. rename(“/etc/passwd”, “/tmp/xyz”) b. symlink(“/etc/shadow”, “/etc/passwd”) 4. 安全决策： D（可能基于过时的路径信息）决定允许访问/etc/passwd，发送允许响应给内核。 5. 内核继续：内核收到允许响应，重新为A的open调用解析路径/etc/passwd。由于步骤3，它现在解析到指向/etc/shadow的符号链接。 6. 结果： A成功打开/etc/shadow，绕过了对/etc/shadow的直接监控。

控制流：攻击者open-> 内核触发fanotify事件 -> 安全进程D处理事件 -> (同时)攻击者快速重命名和创建链接 -> D返回允许决策 -> 内核重新解析路径 -> 跟踪符号链接 -> 打开目标文件。攻击者通过注入并发的文件系统操作流，在安全决策生效前“调换”了文件系统中的对象，导致决策应用于错误的对象。

硬件：多核CPU有利于并行攻击。软件：防御：安全软件应使用文件描述符(fanotify_event_info_fid)而非路径来识别文件对象，并在决策时使用该fd，避免路径重解析。或在内核中，在fanotify权限检查期间锁定父目录的rename操作。更新内核（如5.1+）提供了更安全的FID模式。

Safety-D1-0091

密码学应用

云数据审计/动态数据

动态可证明数据持有 (DPDP)

基于默克尔哈希树与BLS的DPDP方案

1. 挑战：支持数据块的插入、删除、修改等动态操作，同时能高效证明完整性。 2. 数据结构：将文件划分为块，并为每个块m_i计算认证标签σ_i（如BLS签名）。然后构建一棵默克尔哈希树，其中叶子节点是`H(m_i

σ_i)或其变体。树根R由客户端签名后公开发布，或与认证标签一起存储于服务器。 **3. 静态验证**：与PDP类似，客户端挑战服务器提供特定块的证明，包括该块的数据m_i、标签σ_i以及从叶子到根R的默克尔路径Π_i。客户端验证σ_i的有效性，并用Π_i验证H(m_i

σ_i)能否计算出正确的根R。 **4. 动态更新**： a. **修改块i为m_i‘**：客户端生成新标签σ_i‘，计算新叶子节点值L_i‘ = H(m_i‘

σ_i‘)。将(m_i‘, σ_i‘)发送给服务器，并提供L_i‘和更新的默克尔路径节点。服务器更新存储和树。 b. **插入/删除**：需要更新树结构。使用排名默克尔树或可扩展的向量承诺，但复杂度增加。一种方法是使用“桶”策略或维护多棵树。 **5. 效率**：验证需要O(log n)哈希运算，更新需要服务器O(log n)`哈希重新计算。

安全性：基于哈希函数的抗碰撞性和签名安全性。动态操作下保持完整性。开销：服务器需维护哈希树，更新操作有对数级开销。

默克尔哈希树、向量承诺、动态数据结构。将动态数据映射到静态的树根承诺。

Safety-D1-0092

应用安全

云视频会议/音频处理

利用音频包丢失隐藏(PLC)的数据隐匿

在音频流中嵌入隐蔽信息的网络编码

1. 背景：实时音频传输（如VoIP）使用编解码器，当检测到网络丢包时，会启动包丢失隐藏算法，根据之前接收到的音频信号预测并生成填充信号，以保持听觉连续性。 2. 攻击模型：攻击者作为会议参与者，可以控制其发送的音频流。他希望在音频流中隐蔽地传输数据（如窃取的文件内容）给另一个接收者（同谋），而不被其他参与者或服务器检测到异常。 3. 方法：攻击者利用PLC机制对特定序列的丢包不敏感的特性。例如，在某些静音或平稳音频段， PLC生成的填充信号听起来与真实信号几乎没有区别。攻击者可以： a. 在音频编码前，将秘密数据调制到某些音频帧的细微特征上（如相位、高频分量），这些特征在通过PLC恢复时会被保留或产生可预测的变化。 b. 攻击者与接收者共谋，约定在特定时间“丢弃”某些数据包。接收端应用PLC算法后，从恢复的音频中解调出秘密信息。对于其他正常参与者，由于PLC的作用，他们听到的音频基本正常，难以察觉。 4. 数学模型：设原始音频信号s(t)，秘密比特b ∈ {0,1}。发送端生成含密信号s‘(t) = s(t) + α * m(b, t)，其中m是调制信号（能量低，位于PLC不敏感频带）， α很小。丢包后，接收端PLC产生估计信号ŝ(t) ≈ s(t) + β * m(b, t)，其中β是PLC对调制信号的传递函数。接收者从ŝ(t)中解调出b。

隐蔽性：在适度丢包率下，听觉质量影响极小。需要分析音频内容以选择最佳嵌入位置。带宽：隐匿带宽很低，每秒可能只有几比特到几十比特。

信号处理（音频编码、 PLC）、信息隐藏、数字通信。利用有损传输信道中的误差恢复机制作为通信信道。

场景：在加密的VoIP/ViIP会议中建立隐蔽信道，泄露信息；或用于网络隐蔽通信。特征：数字隐写、利用实时传输协议、需要共谋接收方。

s(t): 原始音频信号。 m(b,t): 秘密信息的调制信号（如扩频序列）。 α: 嵌入强度（水印强度）。 PLC(): 包丢失隐藏算法函数。 ŝ(t): 接收端PLC处理后的音频信号。 p_loss: 模拟的丢包率。

信号处理：音频分析，感知掩蔽，调制解调。信息论：隐蔽信道容量计算。通信：在有噪信道中传输信息。

1. 发送端（攻击者）： a. 获取秘密数据，进行纠错编码。 b. 在音频采集时或编码后，将编码后的比特流调制到音频帧的特定频带或相位上，生成含密音频流。 c. 正常发送音频RTP包，但与接收者约定，某些包（携带关键调制信息）将被“故意”丢失（可通过真实丢包或共谋接收者假装丢包）。 2. 网络：发生丢包（自然的或被安排的）。 3. 接收端（共谋）： a. 收到音频流，识别出丢包事件。 b. 应用PLC算法，生成填充音频。 c. 从PLC生成的音频中（结合前后正确接收的包），解调出秘密比特流。 d. 进行纠错解码，恢复原始秘密数据。

信息流：秘密数据 -> 调制 -> 嵌入到音频信号 -> 编码为RTP包 -> 网络传输（部分丢包）-> PLC算法恢复连续音频 -> 从恢复的音频中解调 -> 解码得到秘密数据。秘密信息流“搭乘”音频流的“便车”，并利用丢包恢复过程作为“解码器”。正常参与者听到的只是略有失真的音频流。

硬件：无特殊需求。软件：攻击双方需实现调制解调和PLC算法。检测/防御：检测异常PLC模式（如特定序列的丢包总是发生在某发送者），或分析音频信号的统计特征是否与正常编码一致。使用更先进的、对篡改敏感的音频编码或完整性校验。

Safety-D1-0093

系统安全

虚拟化/内存超售

内存去重 (KSM) 侧信道与CoW攻击

基于内核同页合并的跨VM信息泄露

1. 背景：内核同页合并扫描所有VM的内存，寻找内容相同的页面，合并为一个只读副本，采用写时复制。用于内存超售。 2. 攻击模型：攻击者VM (A) 试图探测受害者VM (V) 是否拥有特定页面内容P_target。 3. 攻击步骤： a. A分配一个页面，并将其内容填充为P_target。 b. A触发KSM扫描（如通过madvise(MADV_MERGEABLE)）或等待定期扫描。 c. 如果V的内存中已存在相同内容的页面， KSM会将其与A的页面合并。合并后，两个VM的页面变为只读的CoW页面。 d. A尝试写入自己的页面。如果写入成功（触发缺页，获得新物理页），说明页面未被合并（V没有相同内容）。如果写入速度异常快（无缺页？实际上写入只读页会触发CoW，总是会有缺页，关键在于测量从写入到缺页处理完成的总时间），但可以通过另一种方法探测：在写入后，立即读取页面内容，检查是否仍然是P_target。如果仍然是P_target，说明A的写入没有生效，因为合并后的页面是只读的，写入会触发CoW，但新分配的页面初始内容是P_target吗？不，新页面是零页或原有内容被复制？这里需要更精确的探测：测量合并后页面的引用计数。攻击者无法直接读取，但可以通过侧信道：如果页面被合并，其物理地址可能被多个VM共享，访问该页可能由于共享而导致缓存状态不同，从而影响计时。但此方法复杂。 e. 更直接的攻击是利用合并后页面的CoW行为：如果A和V的页面被合并，当A写入时，会获得一个独立的新物理页，而V的页面仍然是只读的共享页。攻击者无法直接知道V的情况。但有一种变体：攻击者可以尝试通过内存压力迫使KSM取消合并，然后观察自己页面的变化，但这不可靠。

信息泄露：理论可行，但实际探测困难，噪声大。早期研究曾演示可行，现代内核已增加防御。影响：可能探测到受害者VM内存中的特定数据（如加密密钥、已知代码）。

内存管理、资源共享、侧信道。利用内存去重优化作为跨VM通信或探测通道。

场景：在启用了KSM的云环境中，跨VM探测敏感数据是否存在。特征：无特权、需要KSM启用、探测信号弱，防御已加强。

P_target: 攻击者想要探测的目标页面内容。 page_A: 攻击者VM中填充了P_target的页面。 KSM: 内核同页合并机制。 refcount: 共享页面的引用计数。 t_write: 测量到的写入页面时间。

内存管理：页面合并与拆分裂算法。侧信道：计时分析，缓存攻击。概率：合并发生的概率。

1. 攻击者准备：分配一个页面，用P_target填充。 2. 触发合并：调用madvise(addr, PAGE_SIZE, MADV_MERGEABLE)建议内核合并该页。或等待KSM守护进程扫描。 3. 探测合并状态（困难且不直接）： a. 方法1（旧）：测量写入该页的时间。被合并的页面是只读的，写入会触发CoW缺页，可能比写入可写页稍慢（因为涉及分配新页）。但差异小，易被噪声淹没。 b. 方法2（间接）：制造内存压力，观察页面内容是否“自发”变化（如果与V合并，且V写了该页，则A的页面会因为CoW而获得V写入的新值？不， CoW是独立的）。此方法不可行。 4. 结论：纯粹基于计时的KSM探测在现代系统上已非常困难。

信息流：攻击者准备页面P-> KSM扫描 -> 与受害者相同内容的页面P‘合并 -> 两者共享同一物理页（只读）。攻击者试图通过操作自己的页面P（写入）并观察副作用，来推断是否存在共享，从而知道受害者也有P‘。信息通过物理页共享这个隐蔽通道传递。

硬件：无特殊需求。软件：防御：在云环境中默认禁用KSM，或仅用于受信任的VM之间。 Linux内核可以限制KSM扫描范围，或对合并页面的访问添加噪声。虚拟机监控器可提供基于硬件的内存加密，使不同VM的相同明文加密成不同密文，从根本上防止KSM合并。

Safety-D1-0094

密码学应用

区块链/智能合约

时间戳依赖攻击

利用block.timestamp的可预测性

1. 漏洞模式：智能合约使用block.timestamp（或now）作为随机数源、条件判断或时间锁。矿工在一定程度上可以控制他们开采的区块的时间戳（通常允许有几百秒的偏差）。 2. 攻击：恶意矿工（或贿赂矿工的攻击者）可以为了自身利益操纵时间戳。 a. 时间锁绕过：如果合约有时间锁，要求block.timestamp > unlockTime才能提款。恶意矿工在打包自己的交易时，可以设置一个略大于unlockTime的时间戳，从而提前提款。 b. 伪随机数预测：如果合约用block.timestamp作为熵源生成“随机”数，例如： random = uint256(keccak256(abi.encodePacked(block.timestamp)))，攻击者（矿工）可以预先计算未来几个可能时间戳对应的随机数，并选择对自己有利的时间戳来打包交易，从而影响结果（如抽奖）。 3. 示例：一个简单的抽奖合约： solidity function win() public { require(block.timestamp % 10 == 0, “not yet“); // 发放奖金 } 矿工可以等到时间戳末位是0时，才打包win()交易，确保自己中奖。

影响：可导致资金被盗、抽奖被操纵、时间锁失效。利用条件：需要是矿工或能影响矿工。对时间戳的操纵有限度（需符合协议规则）。

区块链共识、时间戳语义、矿工权力。矿工对区块元数据有部分控制权。

场景：依赖时间戳的DeFi合约、抽奖游戏、时间锁合约。特征：矿工可提取价值(MEV)的一种、逻辑漏洞。

block.timestamp: 当前区块的时间戳（秒）。 unlockTime: 合约中设定的解锁时间戳。 random: 基于时间戳生成的伪随机数。 δ: 矿工允许调整时间戳的最大偏差（以太坊约±900秒）。

时间：时间戳的单调性与可控性。博弈论：矿工的激励与操纵收益。随机性：弱熵源导致的预测。

1. 攻击者（矿工）监视内存池，发现一笔目标合约的有利可图的交易T（如赢得奖金）。 2. 检查条件：交易T的执行依赖于block.timestamp满足某个条件C。 3. 挖矿时：当攻击者成功挖出一个区块时，他可以选择该区块的时间戳ts。只要ts在协议允许的范围内（前一个区块时间戳+1 到当前系统时间+允许偏差δ），并且满足条件C(ts) == true，他就可以将T包含进该区块，并设置block.timestamp = ts。 4. 执行：区块被网络接受，交易T在block.timestamp = ts下执行，条件通过，攻击者获利。 5. 如果攻击者不是矿工，他可以贿赂矿工执行步骤3-4。

控制流：合约代码包含require(block.timestamp …)-> 矿工挖到区块 -> 选择时间戳ts-> 打包交易 -> 交易执行时block.timestamp为ts-> 条件判断通过。攻击者（矿工）通过控制区块元数据（时间戳）这个“输入”，影响了合约内部的条件判断流，使其流向有利于自己的分支。

硬件：无特殊需求。软件：防御：避免使用block.timestamp作为随机源。对于时间锁，使用block.number代替，因为出块时间相对更可预测（但也不完全稳定）。或使用链下预言机提供更安全的时间戳。设计合约时，应假设矿工可以有限操纵时间戳。

Safety-D1-0095

应用安全

浏览器/Web音频

Web Audio API 指纹与AnalyserNode

基于音频渲染信号处理的设备指纹

1. 原理： Web Audio API的音频渲染管道涉及多个环节（采样率转换、混音、滤波），不同硬件和浏览器实现的细微差异会导致相同的音频源产生略有差异的输出信号。 2. 指纹生成： a. 创建音频上下文AudioContext，其采样率sampleRate是设备相关的，通常是硬件支持的几个固定值之一（如44.1kHz, 48kHz）。 b. 生成一个已知的测试音调（如440Hz正弦波），通过OscillatorNode播放。 c. 使用AnalyserNode连接到音频图，获取渲染后音频的时域或频域数据。 d. 对捕获的数据进行特征提取。例如，计算频域信号的特定谐波失真、信噪比、或与理想正弦波的差异。由于数模转换、音频驱动和浏览器的实现差异，这些特征会有微小变化。 e. 组合多个特征（采样率、失真度量、缓冲区大小支持等）形成指纹向量F，可哈希得到最终指纹。 3. 高级技巧：通过测量AudioContext的currentTime属性的漂移或精度，可以推断系统负载和性能特征，这也可能具有唯一性。

唯一性：采样率是强特征，但可能不是唯一的。结合失真特征可提高区分度。稳定性：采样率稳定，但失真特征可能受系统负载影响。

数字信号处理、音频渲染管道、计量学。利用音频硬件和软件栈的物理与实现差异。

场景：跨浏览器会话追踪，作为Canvas、WebGL指纹的补充。特征：脚本可执行、较新类型的指纹、用户感知弱。

audioCtx: AudioContext对象。 sampleRate: 音频上下文的采样率（Hz）。 oscillator: OscillatorNode，产生测试音调。 analyser: AnalyserNode，用于分析音频数据。 frequencyData: 从analyser获取的频域数据（Uint8Array）。 F: 特征向量。

信号处理：傅里叶变换，谐波分析，信噪比计算。计量学：测量采样率，时钟漂移。特征提取：从信号中提取稳定特征。

1. 创建音频上下文： `audioCtx = new (window.AudioContext

window.webkitAudioContext)()。 **2. 记录采样率**：sr = audioCtx.sampleRate。 **3. 创建音频图**：创建OscillatorNode，设置频率440Hz；创建AnalyserNode；连接oscillator -> analyser -> audioCtx.destination。 **4. 启动振荡器**，并等待短暂时间（如50ms）让信号稳定。 **5. 获取数据**：analyser.getByteFrequencyData(frequencyData)。 **6. 特征计算**： a. 在frequencyData中找到440Hz对应的bin的幅度A_fund。 b. 计算谐波（880Hz, 1320Hz等）的幅度A_harm。 c. 计算总谐波失真THD = sqrt(Σ A_harm^2) / A_fund。 d. 可选：测量audioCtx.currentTime的递增精度和抖动。 **7. 组合**：F = [sr, THD, …]，fingerprint = hash(F)`。

Safety-D1-0096

系统安全

操作系统/内存管理

利用mprotect和PROT_NONE的侧信道

通过页面保护位变化探测内存访问

1. 背景： mprotect()可以改变内存页的保护权限（读/写/执行）。将页面设置为PROT_NONE（不可访问）后，任何访问都会触发段错误(SIGSEGV)。 2. 攻击模型：攻击者与受害者进程共享内存（通过mmapMAP_SHARED），或攻击者能监控受害者进程的页表（如通过内核模块）。攻击者试图探测受害者何时访问特定共享页面P。 3. 攻击步骤： a. 攻击者将共享页面P的保护位设置为PROT_NONE。 b. 攻击者启动一个监控线程，等待SIGSEGV信号。为SIGSEGV安装处理程序，在处理程序中记录时间戳并可能将保护位改回可读。 c. 当受害者进程尝试访问页面P时，会触发页面错误，内核向受害者进程发送SIGSEGV（通常导致其崩溃）。但如果攻击者和受害者在同一线程组（通过clone创建）或通过ptrace附加，攻击者可能捕获到本应发给受害者的信号？这需要特殊设置。更通用的方法是，攻击者周期性地轮询：将P设为PROT_NONE，短暂睡眠，然后检查P是否被访问过。如何检查？如果受害者访问了P，页表项中可能会设置访问位（A bit）。攻击者可以读取/proc/self/pagemap或使用mincore()来检查页面的访问位。但A位是硬件管理的，且可能被内核定期清除。 4. 实际限制：现代Linux中，跨进程的信号传递是严格的。此攻击通常需要攻击者对目标进程有某种控制（如通过ptrace或作为父进程）。更可能用于分析自身进程的内存访问模式。

可行性：在特定设置下（如调试器与被调试进程）可能实现。作为跨进程攻击通用性低。精度：可精确定位到页面级别的访问事件。

内存保护、信号机制、页表属性。利用内存访问违规作为同步/通知机制。

场景：进程内自我分析、调试器监控被调试程序、或高级沙箱/蜜罐中监控恶意代码行为。特征：需要一定权限、可精确触发、性能开销大。

P: 目标内存页的起始地址。 prot: 保护标志（PROT_READ, PROT_NONE等）。 SIGSEGV: 段错误信号。 A bit: 页表项中的访问位。 t_access: 检测到的访问时间戳。

系统编程：内存管理调用，信号处理。硬件：页表项属性位。时序：信号/轮询的延迟。

1. 攻击者进程与受害者进程通过mmapMAP_SHARED共享内存，得到页面P。 2. 攻击者调用mprotect(P, PAGE_SIZE, PROT_NONE)，使页面不可访问。 3. 攻击者通过ptrace(PTRACE_SEIZE, victim_pid, …)附加到受害者进程（需要权限）。 4. 攻击者等待：使用waitpid()等待受害者进程状态变化。当受害者访问P时，会触发SIGSEGV并停止， ptrace会获得通知。 5. 攻击者记录事件，并可选择将保护位改回PROT_READ，然后让受害者继续执行。 6. 重复，监控多次访问。

控制流：受害者进程执行 -> 指令访问被保护页面P-> CPU触发缺页异常 -> 内核处理，发现权限违规 -> 内核向受害者进程发送SIGSEGV -> 由于被ptrace附加，信号被拦截，攻击者（跟踪者）被通知。攻击者通过mprotect设置了一个“陷阱”，受害者访问时触发陷阱，通过信号机制通知攻击者。

硬件：依赖MMU的页面保护机制。软件：攻击需要ptrace权限或父进程关系。防御：对敏感进程禁止ptrace（prctl(PR_SET_DUMPABLE, 0)或/proc/sys/kernel/yama/ptrace_scope）。使用seccomp过滤mprotect调用。

Safety-D1-0097

密码学应用

多方计算/隐私保护机器学习

安全多方神经网络推理

基于秘密分享的2PC神经网络推理

1. 场景：两方，一方持有神经网络模型M（权重W），另一方持有输入数据x。他们希望协作计算预测y = M(x)，而不向对方泄露自己的输入（W或x）。 2. 基础：使用算术秘密分享。将每个权重w和输入x的每个元素在环Z_L上分享为两个份额： [w] = (w_A, w_B)，满足w = w_A + w_B mod L。同理[x]。双方各持一份。 3. 线性层（如全连接、卷积）：线性变换y = Wx + b在秘密分享上是可加的。如果[W]和[x]被分享，则[y]可以通过本地计算和通信得到：每一方本地计算其份额的线性组合，然后通过一次通信（乘法三元组）处理W和x交叉项的乘法。具体地，使用Beaver三元组([a], [b], [c])，其中c = a*b。对于每个乘法门，双方： a. 本地计算[e] = [x] – [a], [f] = [W] – [b]，并公开e, f。 b. 本地计算[z] = f * [a] + e * [b] + [c] + e * f。可以验证z = W * x。 4. 非线性激活（如ReLU）：需要安全比较和选择。这比乘法昂贵得多。常用基于秘密分享的比较协议（如DGK, EdaBits）或通过多项式近似（如用低次多项式逼近ReLU）。 5. 整体流程：将神经网络表示为计算图，对每个线性操作使用Beaver乘法，对每个非线性激活使用安全比较或近似，层层计算，最终得到[y]，然后重建y给数据方。

安全性：在半诚实模型下安全，泄露仅为最终输出y。效率：线性层相对高效，非线性层（尤其是ReLU）是主要瓶颈。通信轮数与网络深度成正比。

安全多方计算、秘密分享、算术电路。将神经网络计算表示为一系列加法和乘法门，并在秘密分享上安全评估。

场景：隐私保护的图像分类、医疗诊断（医院有模型，患者有数据）、欺诈检测（银行有模型，商户有交易）。特征：保护模型和数据的隐私、计算和通信开销大、活跃研究领域。

W, x, y: 模型权重、输入数据、输出预测。 [v]: 值v的秘密分享（两方）。 L: 模数（足够大的整数，如2^64）。 (a, b, c): Beaver乘法三元组。 ReLU: 激活函数， max(0, x)。

算术：模加法和乘法。电路：将计算表示为算术电路。复杂度：通信和计算复杂度分析。

1. 离线阶段：预先生成所有需要的Beaver三元组([a], [b], [c])和安全比较所需的关联随机数。可通过不经意传输等实现。 2. 在线阶段： a. 数据方将输入x秘密分享为[x]，发送一份给模型方。 b. 模型方将其权重W秘密分享为[W]，发送一份给数据方。现在双方各有[W]和[x]的一份份额。 c. 对于网络每一层： i. 线性部分：对于每个线性操作，使用Beaver三元组进行安全乘法，得到该层输出的秘密分享[z]。 ii. 激活函数：对[z]应用安全ReLU协议，得到激活后输出的秘密分享[a]，作为下一层的输入[x]。 d. 最后一层输出[y]，双方交换份额重建y，由数据方获得结果。

信息流：原始输入x和权重W-> 被秘密分享为随机份额流 -> 份额在双方间流动，通过交互协议（乘法、比较）进行评估 -> 每层的输出仍是秘密分享 -> 最终输出的份额被合并重建为明文预测y。整个过程，明文数据仅在初始和最后出现，中间计算全在掩蔽的份额上进行。

硬件：需要大量计算（模运算）和通信。可使用硬件加速（如GPU，专用MPC芯片）。软件：实现复杂，有框架如SecureNN, ABY3。性能是主要挑战，尤其对于深度网络。

Safety-D1-0098

应用安全

云文档/格式解析

Microsoft Office 公式编辑器 OLE 对象混淆

利用嵌套OLE对象绕过静态检测

1. 背景： Office文档（.doc, .rtf）可以嵌入OLE对象，如公式编辑器(EQNEDT32.EXE)。恶意文档常利用其漏洞。安全产品会静态扫描文档中是否包含已知恶意的OLE对象或公式。 2. 混淆方法：将恶意公式OLE对象嵌套在另一个“容器”OLE对象内。例如，创建一个Excel OLE对象，在其内部再嵌入恶意公式对象。静态分析器可能只解析到第一层，看到的是Excel对象，因此可能不会深入分析其内容，从而漏过内嵌的恶意公式。 3. 技术细节： OLE对象在文件中以存储流形式存在。通过修改对象头或构造特殊的嵌套结构，使解析器在非递归模式下忽略内层对象。某些扫描引擎可能为了性能，默认只检查有限深度。 4. 利用：攻击者制作一个文档，其中包含一个看似无害的Excel OLE对象。在该Excel对象的流数据中，嵌入一个触发EQNEDT32.EXE漏洞的恶意公式对象。当用户打开文档时， Office会加载外层OLE对象（Excel），而在渲染或激活这个Excel对象时，内嵌的公式对象会被自动加载并解析，触发漏洞。

规避效果：可绕过一些基于静态特征匹配的杀毒软件或邮件网关。局限性：对执行动态分析或深度递归解析的检测引擎可能无效。

文件格式混淆、封装、递归解析。利用安全产品解析深度与完整性的权衡。

场景：制作更隐蔽的鱼叉式钓鱼邮件附件，规避企业安全扫描。特征：静态规避、增加分析复杂性、非零日漏洞利用的一部分。

OLE_outer: 外层OLE对象（如Excel图表）。 OLE_inner: 内层恶意OLE对象（如漏洞公式）。 storage stream: OLE结构化存储中的流，包含对象数据。 max_depth: 安全扫描器设定的最大递归解析深度。

数据结构：嵌套结构，树形解析。混淆：通过封装隐藏恶意载荷。检测：递归深度与检测率的权衡。

1. 攻击者准备恶意公式对象 F_mal，触发已知漏洞（如CVE-2017-11882）。 2. 创建外层容器对象：使用工具生成一个无害的Excel OLE对象 O_excel。 3. 嵌套：修改O_excel的OLE流，将F_mal作为其子对象嵌入。这可能需要手动编辑二进制流或使用脚本。 4. 构建最终文档：将嵌套后的O_excel对象插入到一个Word文档中。 5. 静态扫描绕过：扫描器解析文档，发现O_excel对象，识别为Excel类型，由于未检测到已知恶意特征且可能未深入解析其内部，标记为安全。 6. 执行：用户打开文档， Office加载O_excel，进而自动加载其内部的F_mal，触发漏洞。

信息流：恶意公式代码 -> 被封装进外层OLE对象流 -> 嵌入Office文档 -> 静态扫描器解析，可能止步于外层对象 -> 文档被放行 -> 用户打开， Office递归解析所有OLE对象 -> 内层恶意对象被提取并执行。恶意载荷流被“包裹”在合法的外层对象中，在检测点被“伪装”，在运行时被“解包”释放。

硬件：无特殊需求。软件：防御：安全产品应采用深度递归解析，解包所有嵌套的OLE对象。使用动态分析（沙箱）实际打开文档观察行为。禁用或更新有漏洞的旧版组件（如公式编辑器）。

Safety-D1-0099

系统安全

虚拟化/CPU 虚拟化

利用PAUSE指令的VM exit 侧信道

通过测量PAUSE循环时间推断Hypervisor调度

1. 背景： PAUSE指令提示CPU当前处于自旋等待循环，可以优化功耗和超线程性能。在虚拟化环境中，执行PAUSE不会导致VM exit。 2. 攻击模型：攻击者VM试图探测自己是否被Hypervisor调度出去（即其他VM或Hypervisor自身是否正在运行）。 3. 攻击原理：攻击者VM运行一个紧密循环，其中包含PAUSE指令并测量循环迭代的时间。当攻击者VM被调度在物理CPU上执行时，循环迭代很快。当Hypervisor调度其他实体（其他VM或自己）时，攻击者VM的vCPU被剥夺，此时即使它执行PAUSE循环，也不会进展。因此，测量一段时间内PAUSE循环的迭代次数，可以推断出攻击者VM的CPU占用份额，进而感知是否有其他负载在竞争CPU。 4. 公式：设物理时间间隔为Δt，攻击者VM测量到的循环迭代次数为N。则攻击者VM获得的实际CPU时间为t_cpu = N * t_iter，其中t_iter是单次迭代在独占CPU时的平均时间。 CPU占用率ρ = t_cpu / Δt。如果ρ显著低于1（或预期值），表明存在CPU竞争，即可能有其他VM活跃。

信息泄露：可推断同主机其他VM的CPU活动级别（繁忙/空闲）。噪声：受Hypervisor调度策略、系统其他中断影响。

性能计数器、调度侧信道、计时分析。利用CPU时间分配的可观测性。

场景：云环境中，跨VM推断邻户的工作负载强度，用于侦察或资源竞争攻击的准备工作。特征：无特权、低带宽、需要长时间测量。

Δt: 测量时间窗口（如100毫秒）。 N: 在Δt内完成的PAUSE循环迭代次数。 t_iter: 单次循环迭代在无竞争时的执行时间（通过校准获得）。 ρ: 测量到的CPU占用率。

计时：高精度循环计数（rdtsc）。调度： CPU时间片分配模型。统计：从时间序列估计占用率。

1. 校准：在系统空闲时，测量PAUSE循环单次迭代时间t_iter，或测量固定迭代次数（如1000万次）所需时间T_cal。 2. 监测循环： start_time = get_current_time() counter = 0 while (get_current_time() – start_time < Δt) { asm volatile(“pause”); counter++; } N = counter 3. 计算： t_cpu = N * t_iter; ρ = t_cpu / Δt。 4. 分析：连续监测ρ。如果ρ持续处于高位（如>0.9），推测主机相对空闲或自身独占。如果ρ周期性下降或处于低位，推测存在其他负载竞争CPU，即其他VM可能活跃。

信息流： Hypervisor调度决策（分配时间片给哪个VM）-> 影响攻击者VM获得的实际CPU时间 -> 体现为攻击者VM内PAUSE循环在固定墙上时间内能完成的迭代次数N-> 攻击者从N反推自身CPU占用率ρ-> 从ρ推断系统负载和邻户活动。调度信息通过CPU时间的“稀缺性”传递给了攻击者VM的可观测性能指标。

硬件：需要高精度计时器（如rdtsc）。 PAUSE指令本身不会引起VM exit，是其关键。软件：攻击者为用户级代码。防御： Hypervisor可添加噪声，如随机化调度时间片，或对rdtsc等计时指令进行虚拟化/降精度，但可能影响依赖精确计时的应用。

Safety-D1-0100

密码学应用

区块链/共识安全

权益证明 (PoS) 的长程攻击

无利害关系攻击与主观惩罚

1. 攻击模型：在PoS链中，验证者通过锁定代币（权益）获得出块权。长程攻击指攻击者在某个过去的区块高度H_old创建一个分叉，并从那时开始秘密生成一条更长的链，然后突然发布，试图重写历史。 2. 无利害关系问题：在纯PoS中，如果链选择规则是“最长链”，攻击者可以在过去某个点创建分叉，因为质押的代币在过去是有效的，并且生成区块不需要像PoW那样消耗现实资源。攻击者可以无成本地在多条分叉上同时签名（“在两条链上都投票”），因为过去的签名密钥可能已失效或代币已转移，没有惩罚。 3. 防御 – 主观惩罚：要求验证者签名时附带“时间段”或“纪元”信息。如果发现同一个验证者在同一高度对两个不同的区块签名，可以事后罚没其质押的代币，即使是在很久以后。这引入了“主观性”，因为新加入的节点需要知道历史中的欺诈证明才能判断哪条链是合法的。 4. 检查点：另一种防御是引入定期检查点（最终确定性）。例如，每100个区块，一旦被超过2/3的验证者签名，就成为最终确定的，不可回滚。这牺牲了“纯”最长链规则，但提供了强安全性。

成功条件：攻击者需要控制足够多的过去权益（如>1/3），且链协议存在无利害关系漏洞。防御有效性：通过罚没和最终确定性，现代PoS链（如以太坊2.0, Cosmos）已大幅缓解此攻击。

博弈论、密码经济学、共识安全性。在缺乏现实资源消耗时，需通过经济惩罚和社会共识来保证安全。

场景：针对早期或设计不当的PoS区块链，试图重写交易历史（双花）。特征：需要历史权益、攻击有延迟、防御机制已成熟。

H_old: 攻击开始的分叉点区块高度。 stake_old: 攻击者在H_old时刻控制的权益比例。 slashing condition: 罚没条件，如双重签名。 checkpoint: 最终确定的区块，不可逆。

博弈论：攻击者的收益成本分析。密码学：数字签名，默克尔证明。经济：质押与罚没的经济模型。

1. 攻击者准备：获取在历史高度H_old时控制的大量验证者私钥（可能通过购买旧币）。 2. 秘密挖矿：从H_old开始，私下创建一条分叉链C_alt，包含攻击者想要的交易（如双花）。 3. 发布：当C_alt的长度超过当前主链C_main从H_old开始的长度时，突然发布C_alt。 4. 网络分歧：根据最长链规则，诚实的节点可能会切换到C_alt，导致C_main上的交易被回滚。 5. 防御（罚没）生效：如果协议有罚没机制，诚实的节点可以检查到攻击者在H_old高度对两个不同区块都签了名，提交欺诈证明。攻击者质押的代币将被罚没，分叉C_alt被拒绝。新节点需要获取这些罚没信息才能做出正确选择。

信息流：攻击者从历史点H_old分叉 -> 私下生成更长的链（信息隐藏）-> 突然发布长链（信息释放）-> 网络根据规则可能切换 -> 防御机制检测到双重签名（信息验证）-> 提交罚没证据 -> 网络拒绝攻击链并惩罚。攻击依赖于制造一条“更优”的链信息流，但防御机制通过引入可验证的“作恶”信息流（双重签名证据）来抵消它。

硬件：无特殊需求。软件：区块链客户端需实现罚没证据的收集、传播和验证逻辑。需要安全的密钥管理，防止旧密钥泄露。轻客户端需要一种安全的方式获取检查点或欺诈证明。

【信息科学与工程学】【安全领域】【信息科学与工程学】【安全领域】安全基础——第十六篇云安全 10 云计算安全领域的核心算法和模型01

云计算安全领域的核心算法和模型

编号 Safety-D1-0023

相关推荐

评论抢沙发

热门标签

热门文章

最新文章

归档

分类

云计算安全领域的核心算法和模型

编号 Safety-D1-0023​

相关推荐

评论 抢沙发

热门标签

热门文章

最新文章

归档

分类

编号 Safety-D1-0023

评论抢沙发