编号​

Attack-A-0001

类别​

密码分析 / 代数密码分析

模型配方​

对于一个基于多变量二次方程组的密码系统（如Rainbow签名方案，或某些对称密码的S盒代数表示），将其加密/签名过程抽象为一组关于密钥/内部状态变量 {x1​,x2​,...,xn​}和公开信息（密文、签名、明文）{y1​,y2​,...,ym​}的代数方程（通常是非线性的）。攻击目标是求解此方程组以恢复密钥变量。配方为：找到一个算法 A，使得 A(F(x)=y)→x，其中 F:Fn→Fm为一组多项式映射。

算法/模型/方法名称​

线性化攻击 (Linearization Attack) 与扩展线性化 (XL) 算法

逐步思考推理过程及数学方程式​

目标：求解有限域 Fq​上的多变元二次方程组 fl​(x1​,...,xn​)=0,l=1,...,m。
步骤1：构造增广系统。将每个方程 fl​=0视为关于单项式（如 xi​,xi​xj​）的线性方程。设单项式集合为 (T = {x_1^{e_1}...x_n^{e_n}

精度/密度/误差/强度​

精度/强度：攻击的成功概率取决于扩展度 D的选择。当扩展后的线性系统 MXL​的秩比变量数 ∥TD​∥小至少1时，可求解。复杂度：主要取决于高斯消元，为 O(∥TD​∥ω)，其中 2<ω≤3为矩阵指数，∥TD​∥=∑i=0D​(in​)≈O(nD)对于固定 D。攻击的“强度”由其所需 D和对 n的渐近复杂度刻画。

底层规律/理论定理​

代数几何基本定理（希尔伯特零点定理）：在代数闭域上，多项式方程组的解集与其生成的理想对应。XL算法可视为在此定理指导下，通过构造理想 I=⟨f1​,...,fm​⟩的 D次齐次部分，并计算其在度 ≤ D的向量空间中的线性关系来逼近解。
线性代数理论：核心是将非线性问题转化为高维线性问题，依赖线性空间的基、秩-零化度定理。
组合数学：单项式的数量由组合数 (dn+d​)给出，决定了问题的规模。

典型应用场景​

1. 多变量公钥密码分析：如针对Rainbow, HFE (Hidden Field Equations) 签名方案的密钥恢复。
2. 流密码代数攻击：针对如Trivium, Grain 等，将其状态更新和输出函数建模为代数方程，求解初始状态。
3. 分组密码小型变体分析：对轮数简化或状态较小的AES、DES等，建立S盒和轮函数的代数方程并求解。
4. 哈希函数原像攻击：将压缩函数建模为多变量方程，求解满足哈希值的消息块。
5. 白盒密码实现破解：尝试从混淆后的查找表中提取出嵌入的密钥方程。

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

- n: 系统中原始变量的个数（密钥/状态变量）。
- m: 初始独立方程的数量。
- q: 有限域的阶，通常是2或一个素数。
- D: 扩展算法的目标次数（关键参数），决定了计算复杂度和成功率。
- TD​: 所有次数 ≤ D的单项式构成的向量。
- ND​:=∥TD​∥: 扩展后线性系统中“新变量”（线性化后变量）的个数。
- RD​: 扩展后得到的线性方程的数量。攻击成功需 RD​≥ND​−1（期望是 RD​≈ND​）。
- MXL​: 维度为 RD​×ND​的系数矩阵（在 Fq​上）。

数学特征​

- 集合：变量定义在有限域 Fq​上，单项式集合 TD​构成一个有限集。
- 代数：核心是多项式环 Fq​[x1​,...,xn​]及其齐次分量上的运算。
- 线性代数：算法最终归结为大型稀疏（或结构化稠密）矩阵的秩计算与高斯消元。
- 组合数学：复杂性由单项式数量的组合增长 (Dn+D​)主导。
- 概率与统计：在随机多项式模型下，可以分析 RD​达到 ND​所需的 D的概率，从而估计平均复杂度。
- 优化：选择最优的 D以最小化总计算成本 O(NDω​)是一个优化问题。
- 计算与算法特征：属于符号-数值混合计算，核心是线性系统求解，具有确定性的时间复杂度上界。

语言特征​

形式化、数学化描述。使用大量数学符号和公式（如 fl​,MXL​,(dn​)）。术语精确，如“线性化”、“单项式向量”、“系数矩阵”、“秩”、“高斯消元”。逻辑连接词明确，如“设...”、“将...转化为...”、“应用...”、“目标是...”。

时序和交互流程​

阶段1：准备 (Preparation)
1. 输入：目标密码系统代数方程 {fl​(x)=yl​}， 扩展度参数 D。
2. 动作：生成全体次数 ≤ D的单项式列表 TD​。
阶段2：扩展与构造 (Expansion & Construction)
3. 循环：对每个方程 fl​和每个次数 ≤ D−deg(fl​)的单项式 t，计算 t⋅fl​。
4. 动作：将结果多项式按单项式 TD​排序，提取系数，按行填入矩阵 MXL​。得到 MXL​⋅TD​=0。
阶段3：线性化与求解 (Linearization & Solving)
5. 动作：将 TD​中每个单项式替换为一个新变量 Xα​，得到线性系统 MXL​⋅X=0。
6. 动作：对 MXL​应用高斯消元法（或更高效的稀疏矩阵求解器），化为行最简形，求其零空间基向量 v。
阶段4：解恢复与验证 (Solution Recovery & Verification)
7. 判断：若零空间维数为1，则得到唯一（仿射）解 X∗。
8. 恢复：从 X∗中对应 xi​和 xi​xj​的分量，通过关系 xi​=Xi​,(xi​xj​)=Xij​的一致性，通常需要求解一个次级系统（如从 Xij​矩阵进行秩1分解）来得到 x∗。
9. 验证：将候选解 x∗代入原方程组 {fl​(x∗)=yl​}验证。若成功，输出 x∗；否则，返回阶段1，增加 D并重复。

编号​

Attack-A-0002

类别​

密码分析 / 对称密码分析

模型配方​

将分组密码（如AES）的第i轮和第i+1轮的输入输出差分对 (ΔI,ΔO)的关系建模为概率事件。目标是找到高概率的差分特征路径（一系列差分传递），使得当输入差分为 ΔP时，经过r轮加密后，输出差分为 ΔC的概率 p=Pr[ΔP→ΔC]显著高于随机概率 2−n。攻击利用此偏差恢复轮密钥。

逐步思考推理过程及数学方程式​

步骤1：选择差分特征。分析密码的非线性组件（如S盒）的差分分布表（DDT），找到高概率的输入-输出差分对 (δin​,δout​)，满足 Pr[S(x)⊕S(x⊕δin​)=δout​]=pS​最大。
步骤2：构造差分路径。连接多轮的高概率S盒差分，形成一条从明文差分 ΔP到密文差分 ΔC的完整r-1轮差分特征 Ω，其总概率 pΩ​=∏pSi​​。
步骤3：收集密文对。选择大量明文对 (P,P′)满足 P⊕P′=ΔP，获取对应的密文对 (C,C′)。预计需要约 c/pΩ​对，c为小常数。
步骤4：密钥恢复。针对最后一轮（或首尾两轮）的密钥 Kr​进行猜测。对每个候选密钥 k∗：
4.1 用 k∗对 C,C′进行部分解密，得到倒数第二轮输出 Y,Y′。
4.2 计算 Y⊕Y′，检查是否等于差分特征预测的倒数第二轮输出差分 ΔYr−1​。
4.3 统计满足条件的密文对数量，计为 T(k∗)。
步骤5：选择正确密钥。正确密钥对应的计数器 T(Kreal​)预计满足二项分布 B(N,pΩ​)，而错误密钥猜测的分布接近 B(N,2−n)。选择 T(k∗)值显著高于其他猜测的 k∗作为正确密钥。

精度/密度/误差/强度​

强度：由差分特征的概率 pΩ​决定。数据复杂度 O(1/pΩ​)，时间复杂度 (O(2^{

底层规律/理论定理​

差分均匀性：S盒的差分概率分布是衡量其抵御差分攻击能力的核心指标。
马尔可夫密码假设：假设密码各轮操作是独立的，则多轮差分概率等于各轮概率的乘积。
大数定律与假设检验：攻击本质是基于正确密钥和错误密钥假设下，计数器 T(k)分布的统计区分。

典型应用场景​

1. DES密码分析：经典应用，利用扩展置换和S盒的特性构造高效差分特征。
2. AES缩减轮变体分析：对轮数减少的AES进行攻击，评估其安全边际。
3. Feistel结构密码分析：如对Blowfish, Camellia等密码的评估。
4. 哈希函数的碰撞攻击：差分攻击思想是构建MD5、SHA-1碰撞攻击的核心。
5. 白盒实现的差分分析：即使代码被混淆，若差分特性不变，仍可能实施攻击。

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

- ΔP,ΔC: 明文、密文差分。
- Ω: 一条具体的差分特征路径。
- pΩ​: 该差分特征的概率。
- N: 收集的明文对数量。
- Kr​: 目标最后一轮的子密钥。
- T(k): 对应候选密钥 k满足差分条件的计数器。
- DDT: 差分分布表，记录S盒所有输入输出差分对对应的概率/计数。

数学特征​

- 概率与统计：核心是概率计算（乘法原理）和假设检验（区分两个二项分布）。
- 布尔代数/有限域算术：差分传播的计算基于XOR（特征2域上的加法）。
- 组合优化：搜索高概率差分特征是一个在密码组件图上寻找最优路径的组合优化问题。
- 随机过程：在马尔可夫假设下，差分传播可被视为一个随机过程。

语言特征​

术语：“差分特征”、“差分路径”、“概率”、“S盒”、“部分解密”、“密钥猜测”、“计数器”、“统计显著”。句式多为条件判断和步骤描述，如“如果...则满足”、“统计...的数量”。

时序和交互流程​

阶段1：离线分析
1. 分析目标密码的S盒DDT和线性层扩散性质。
2. 搜索高概率的（多轮）差分特征 Ω并计算其概率 pΩ​。
阶段2：在线数据采集
3. 生成或选择 N≈c/pΩ​个满足输入差分 ΔP的明文对 (Pi​,Pi′​)。
4. 访问加密预言机，获取对应的密文对 (Ci​,Ci′​)。
阶段3：密钥恢复攻击
5. 对所有可能的最后一轮密钥 k∈Kr​进行循环：
a. 初始化计数器 T[k]=0。
b. 对每个密文对 (Ci​,Ci′​)循环：
i. 用候选密钥 k对 Ci​,Ci′​进行部分逆变换，得 Yi​,Yi′​。
ii. 计算差分 δi​=Yi​⊕Yi′​。
iii. 如果​ δi​==ΔYr−1​(预测的差分)，则​ T[k]++。
6. 找出计数器 T[k]值明显高于其他密钥的候选 k∗。
7. 可选：用已知明文对验证 k∗，或对更多轮进行类似攻击。

Attack-A-0003​

密码分析 / 对称密码分析

线性密码分析

寻找密码算法中输入、输出和密钥比特间高度偏离1/2的线性近似关系，利用大量明文-密文对进行统计攻击以恢复密钥比特。

Attack-A-0004​

密码分析 / 对称密码分析

积分攻击 (Square Attack)

通过选择具有特定性质（如所有值均出现一次，即“平衡”性质）的明文集合，追踪该集合在加密过程中内部状态的性质（如和为零），从而恢复轮密钥。

Attack-A-0005​

密码分析 / 对称密码分析

中间相遇攻击

分别从加密和解密两个方向对部分密钥进行猜测，并在中间状态汇合处进行匹配，将时间复杂度从乘积项降为求和项。

Attack-A-0006​

密码分析 / 公钥密码分析

针对RSA的小私钥攻击 (Wiener攻击)

当RSA私钥 d过小时，其分数 k/d是 e/N的一个连分数逼近，通过计算 e/N的连分数展开可以恢复出 d。

Attack-A-0007​

密码分析 / 公钥密码分析

椭圆曲线离散对数问题的Pollard‘s Rho攻击

利用伪随机游走和Floyd判圈算法，在椭圆曲线点构成的群中寻找碰撞，将求解离散对数 d(满足 Q=dP) 的时间复杂度降至 O(n​)。

Attack-A-0008​

密码分析 / 代数

Buchberger算法求Gröbner基

将密码方程组系统的求解转化为计算其Gröbner基的问题。通过计算S-多项式并约简，最终得到易于求解的三角化方程组。

Attack-A-0009​

侧信道分析 / 能量分析

简单能量分析 (SPA)

直接观察密码设备运行时的能量迹波形，通过识别与密钥相关的操作模式（如平方-乘算法中的平方与乘法操作形状不同）来直接推断密钥。

Attack-A-0010​

侧信道分析 / 能量分析

差分能量分析 (DPA)

采集大量能量迹。根据密钥假设将能量迹分为两组，计算两组迹在每时间点上的平均差值。在密钥相关的操作点，差值会出现明显尖峰，从而验证密钥猜测。

Attack-A-0011​

侧信道分析 / 能量分析

相关能量分析 (CPA)

使用皮尔逊相关系数，将实测能量迹与基于功耗模型（如汉明重量模型）和密钥假设预测的功耗值进行相关性分析。相关系数最高的密钥猜测为正确密钥。

Attack-A-0012​

侧信道分析 / 故障分析

差分故障分析 (DFA)

向密码设备（如运行AES的芯片）注入故障（如时钟毛刺），诱导其产生一个或多个字节的错误输出。通过分析正确密文和错误密文的差分，结合算法扩散特性，反推轮密钥。

Attack-A-0013​

协议与网络攻击 / 中间人攻击

会话密钥协商中间人攻击 (MITM)

攻击者同时与通信双方（A和B）建立独立的、受其控制的会话，并分别协商密钥。攻击者可以解密、读取、修改并重新加密所有中转消息，而A和B无法察觉。

Attack-A-0014​

协议与网络攻击 / 重放攻击

认证协议重放攻击

攻击者窃听并记录合法的认证消息（如包含密码哈希或令牌），随后在另一个会话中将其原样重发给验证者。验证者因无法区分消息的新鲜性而误认为攻击者是合法用户。

Attack-A-0015​

机器学习对抗攻击 / 图像识别

快速梯度符号法 (FGSM) 攻击

在图像分类模型的输入梯度方向上添加一个小扰动：x′=x+ϵ⋅sign(∇x​J(θ,x,y))。这个精心构造的扰动能导致模型以高置信度错误分类，而人眼几乎无法察觉变化。

Attack-A-0016​

机器学习对抗攻击 / 物理世界攻击

对抗性补丁攻击

生成一个在物理世界中可打印、可粘贴的对抗性图案（补丁）。将其放置在场景中，能使目标检测或分类系统产生特定错误（如将“停止”标志识别为“限速”标志）。

Attack-A-0017​

计算与算法攻击 / 复杂度攻击

针对哈希表的碰撞拒绝服务攻击

利用哈希函数（如某些语言默认的哈希函数）的弱点，精心构造大量具有相同哈希值的不同键（Key）。当它们被插入哈希表时，所有键都进入同一个桶，使查询/插入操作从 O(1)退化为 O(n)，导致服务瘫痪。

Attack-A-0018​

计算与算法攻击 / 定时侧信道

针对RSA的Kocher定时攻击

通过精确测量RSA解密（或签名）操作的时间，由于平方-乘算法的分支条件与私钥比特相关，统计分析大量解密时间可以恢复出私钥 d的比特位。

Attack-A-0019​

网络拓扑与路由攻击

BGP前缀劫持攻击

恶意自治系统（AS）向其BGP对等体广播本不属于它的、更精确的IP前缀路由。由于BGP默认选择最具体路径，流量会被吸引到恶意AS，从而可被监听、丢弃或篡改。

Attack-A-0020​

分布式系统攻击 / 共识协议

比特币网络的51%算力攻击

单一实体或联盟控制了比特币网络超过50%的总哈希算力。这使其能够：1）双花交易；2）阻止部分或全部交易确认；3）阻止其他矿工挖出有效区块。攻击破坏了区块链的不可篡改性和去中心化信任。

Attack-A-0021​

后门与供应链攻击

模型后门攻击 (Neural Backdoor)

在训练深度神经网络时，向训练集中注入带有特定触发模式（如图像角落的特定像素块）且被错误标记的样本。模型学会在正常样本上表现良好，但对任何含有该触发模式的输入，都会以高置信度输出攻击者指定的错误标签。

编号​

Attack-B-0022

类别​

网络协议攻击 / 路由协议攻击

模型配方​

攻击者恶意配置或伪装成路由器，向相邻路由器发送伪造的路由信息协议（RIP）更新报文，宣称到达某个特定网络前缀具有异常优的度量（如跳数为1），从而诱使邻居路由器更新其路由表，将所有前往该前缀的流量重定向到攻击者控制的路由器。攻击者随后可对流量进行丢弃、监听或篡改。

逐步思考推理过程及数学方程式​

目标：非法劫持流向目标网络前缀 Pt​的流量。
步骤1：监听与学习。攻击者接入目标网络段，监听RIP更新报文（端口520/UDP），学习当前网络拓扑和路由表。记录到目标前缀 Pt​的现有下一跳 NHlegit​和度量 Metriclegit​。
步骤2：构造恶意更新。构造一个RIP响应报文，其中：
- 命令字段 = 2 (响应)。
- 地址族标识符 = 2 (IP)。
- IP地址 = 目标前缀 Pt​(如192.168.5.0)。
- 度量 = 1 (或任何小于 Metriclegit​的值，如0表示直连)。
步骤3：发送恶意更新。攻击者将构造的恶意RIP响应报文发送给相邻的一个或多个运行RIP的路由器。RIP没有内置的发送者身份验证，因此目标路由器会处理该报文。
步骤4：触发路由更新。目标路由器收到更新后，运行距离向量算法：
1. 比较到 Pt​的现有路径成本（来自 NHlegit​） Cold​=Metriclegit​+1(假设RIP跳数加1)。
2. 比较新通告的路径成本（来自攻击者） Cnew​=1+1=2。
3. 由于 Cnew​<Cold​，路由器将更新其路由表：下一跳指向攻击者，度量更新为2。
数学上，路由表更新规则为：NH(Pt​)=argminsrc​(Metricsrc​+Cost(src,self))。
步骤5：传播与生效。根据RIP的周期性（30秒）或触发更新机制，被污染的路由器会进一步向其邻居传播这条被污染的路由信息，导致攻击影响范围扩大。最终，发往 Pt​的流量被导向攻击者。

精度/密度/误差/强度​

精度：攻击在缺乏认证的RIPv1/v2网络中接近100%有效。在启用RIP认证或使用RIPng with IPSec的网络中无效。
强度/影响范围：攻击可劫持特定前缀的流量。影响范围受RIP管理距离和计时器影响，但可能通过触发更新快速传播。
误差/风险：攻击者可能因配置错误导致路由环路，引发网络不稳定。

底层规律/理论定理​

距离向量路由算法 (Bellman-Ford)：每个路由器基于邻居的通告，迭代计算到所有目的地的最短路径。算法假设所有参与者（路由器）是可信的。本攻击破坏了该信任假设。
毒性逆转与水平分割：某些RIP实现通过水平分割（不向来源接口回传路由）来防止简单的路由环路，但对来自新方向的欺骗更新防御有限。
网络收敛理论：恶意更新会破坏网络的收敛状态，引入不稳定路径。

典型应用场景​

1. 企业内部网络流量劫持：攻击接入企业内网的恶意主机，劫持内部服务器流量。
2. 隔离网络渗透：在物理隔离但运行RIP的网络中，作为横向移动手段。
3. 实验室环境测试：验证网络设备对路由欺骗的抵御能力。
4. 混合攻击链的一部分：作为中间人攻击的前置步骤，为后续数据窃取或篡改创造条件。
5. 拒绝服务：将大量流量引导至不存在的地址或低带宽链路，造成网络拥塞。

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

- Pt​： 要劫持的目标IP网络前缀。
- Metriclegit​： 到 Pt​的合法路由度量（跳数）。
- Metricmalicious​： 攻击者通告的恶意度量（通常设置为1或0）。
- NHlegit​： 到 Pt​的合法下一跳地址。
- RIP报文字段：命令、版本、地址族、IP地址、度量。
- 路由器接口：接收和发送更新的网络接口。

数学特征​

- 图论：网络被建模为图 G=(V,E)，路由器是顶点，链路是边。距离向量算法在图 G上计算最短路径。
- 优化：最短路径计算是一个分布式优化过程。
- 离散事件系统：路由更新是离散事件，系统状态（路由表）随时间变化。
- 博弈论：可视为恶意参与者破坏分布式共识过程的博弈。

语言特征​

术语：“距离向量”、“路由更新”、“下一跳”、“度量”、“毒性反转”、“水平分割”、“触发更新”。句式多为描述协议报文构造、状态机转换和路径比较，如“路由器收到更新后，比较度量…如果新度量更优，则更新路由表…”。

时序和交互流程​

阶段1：侦察
1. 攻击者监听网络，捕获RIP更新报文。
2. 分析报文，确定目标前缀 Pt​及其当前路径信息（下一跳、度量）。
阶段2：武器化
3. 构造恶意RIP响应报文：设置命令=2，填充目标前缀 Pt​，设置恶意度量 Metricmalicious​=1。
阶段3：投送
4. 攻击者将恶意报文发送到目标网络的广播地址（如255.255.255.255）或相邻路由器单播地址，目标端口520/UDP。
阶段4：利用
5. 相邻路由器R收到报文，验证基本格式（版本、校验和）。
6. R运行距离向量算法：对报文中的每个路由条目，计算新路径成本 = 通告度量 + 1。
7. 如果​ 新路径成本 < 路由表中现有路径成本，则：更新路由表，下一跳指向攻击者IP，度量更新为新成本；设置失效计时器；在下一个更新周期或立即（触发更新）向邻居通告此新路由。
8. 流量开始被重定向到攻击者。
阶段5：维持
9. 攻击者可能需要周期性（如每30秒内）发送恶意更新，以覆盖合法路由器的正常更新，防止路由因超时被清除。

Attack-B-0023​

网络协议攻击

DNS缓存投毒攻击

攻击者向DNS解析器发送大量伪造的DNS响应，试图猜中事务ID和端口号，使其缓存错误的域名-IP映射，从而将用户流量导向恶意服务器。

Attack-B-0024​

网络协议攻击

TCP序列号预测与连接劫持

攻击者通过嗅探或推测目标TCP连接的序列号(SEQ)和确认号(ACK)，伪造一个具有正确SEQ/ACK、源IP/端口的RST或数据包，插入会话以重置连接或注入恶意数据。

Attack-B-0025​

网络协议攻击

ICMP重定向攻击

攻击者发送伪造的ICMP重定向报文（类型5）给同一子网内的主机，声称到某IP有更优路由（通过攻击者），诱使主机更新其路由缓存，将流量发送给攻击者。

Attack-C-0026​

Web应用攻击

SQL注入攻击 (Union-based)

在Web应用输入点插入恶意SQL片段，如 ' UNION SELECT username, password FROM users--，使得后端数据库执行非常规查询，将敏感数据与正常结果一并返回。

Attack-C-0027​

Web应用攻击

跨站脚本攻击 (存储型XSS)

攻击者将恶意JavaScript代码（如 <script>alert(document.cookie)</script>）提交到Web应用的存储区（如评论、个人资料）。当其他用户浏览该内容时，脚本在其浏览器中执行，窃取其Cookie或进行其他操作。

Attack-C-0028​

Web应用攻击

跨站请求伪造攻击

诱使已登录目标网站的用户浏览器，向该网站发送一个伪造的HTTP请求（如图片标签 <img src="https://bank.com/transfer?to=attacker&amount=1000">），利用用户的登录状态执行非预期的操作（如转账）。

Attack-C-0029​

Web应用攻击

服务器端请求伪造攻击

攻击者利用Web应用的功能（如URL获取、图片处理）向其内网或本地环回地址发起请求，如 https://vuln.com/load?url=http://127.0.0.1/admin，从而探测或攻击内网服务。

Attack-C-0030​

Web应用攻击

不安全的反序列化攻击

攻击者向应用发送一个精心构造的序列化对象。当应用反序列化该对象时，会触发对象中嵌入的恶意代码（如 __destruct(), __wakeup()方法中的系统命令执行），导致远程代码执行。

Attack-D-0031​

系统软件攻击

栈缓冲区溢出攻击

向固定大小的栈缓冲区写入超长数据，覆盖相邻的函数返回地址，将其修改为指向内存中恶意Shellcode的地址。当函数返回时，程序跳转执行Shellcode，获得控制权。

Attack-D-0032​

系统软件攻击

返回导向编程攻击

在存在NX（不可执行内存）防护时，攻击者利用程序中已有的、以ret指令结尾的代码片段（gadget）链，通过控制栈指针，依次执行一系列gadget，最终达成任意代码执行效果，而无需注入代码。

Attack-D-0033​

系统软件攻击

格式化字符串漏洞攻击

当程序使用用户可控的字符串作为printf等格式化函数的格式参数时，攻击者可以输入如%x%x%n的字符串。%x用于泄漏栈内存，%n可将已输出字符数写入栈上地址所指向的内存，从而实现内存读写和程序控制流劫持。

Attack-D-0034​

系统软件攻击

整数溢出攻击

攻击者提供极大的输入值，使其在算术运算（如加法、乘法）后超出该整数类型的表示范围，发生回绕（如uint8_t的255+1=0），导致后续的内存分配或循环条件判断出现严重错误，可能引发堆溢出或逻辑漏洞。

Attack-D-0035​

系统软件攻击

Use-After-Free攻击

攻击者通过某种方式触发程序释放一个堆内存块，但未能清空指向该块的指针（悬垂指针）。随后，通过另一途径分配一个攻击者可控的数据到该内存块，并利用悬垂指针进行读写或虚函数调用，实现代码执行。

Attack-E-0036​

硬件安全攻击

缓存时序攻击 (Flush+Reload)

攻击者（在云环境等共享硬件中）与受害者共享内存。攻击者反复执行：1) Flush：使用clflush指令将目标共享内存地址（如GnuTLS的私钥处理函数地址）从缓存中驱逐。2) Wait：短暂等待。3) Reload：重新访问该地址并测量访问时间。极短的访问时间表明受害者在此期间访问了该地址，从而推断出受害者的执行路径和密钥信息。

Attack-E-0037​

硬件安全攻击

电磁侧信道分析

使用近场探头测量密码设备（如智能卡）运行时泄露的电磁辐射信号。信号强度与设备执行的指令和处理的汉明重量相关。通过分析电磁轨迹，结合DPA/CPA等统计方法，可恢复密钥。模型： S(t)=α⋅HW(data⊕key)+β⋅HW(data)+N(t)，其中 S(t)是t时刻的信号，α,β是系数，N(t)是噪声。

Attack-F-0038​

AI安全攻击

数据投毒攻击 (梯度上升)

在模型训练阶段，向训练集注入精心构造的毒化样本。目标是使模型在测试时在特定任务上失败，或对带有触发器的样本进行错误分类。优化目标：maxδ​L(θ∗(Dclean​∪(x+δ,ytarget​)),Dtest​)，其中 θ∗是在毒化数据集上训练得到的模型参数，L是攻击者的损失函数。

Attack-F-0039​

AI安全攻击

模型窃取攻击 (功能抽取)

攻击者没有模型 f的参数，但能通过API查询输入 x得到预测 f(x)（如类别概率）。攻击者构建一个替代模型 f′和一个查询数据集 Dq​，通过最小化 f′(x)和 f(x)的差异来训练 f′，使得 f′≈f。即 minf′​∑x∈Dq​​L(f′(x),f(x))。

Attack-F-0040​

AI安全攻击

成员推断攻击

给定一个数据点 x和目标模型 f，判断 x是否在 f的训练集 Dtrain​中。攻击基于过拟合现象：模型对训练样本的输出置信度通常高于非训练样本。可训练一个二元分类器 g，输入为 (f(x),y^​)或 f(x)的统计特征，输出是否为成员。

Attack-G-0041​

隐私攻击

去匿名化攻击 (链接攻击)

攻击者拥有一个匿名的数据集 A（如搜索记录，已移除姓名），和一个包含身份信息的公开数据集 P（如选民登记信息）。通过寻找两个数据集共有的准标识符（如邮编、性别、出生日期），将 A中的记录与 P中的个体关联起来，从而重新识别匿名记录背后的个人身份。

类别​

线性代数攻击 / 矩阵分解攻击

模型配方​

将密码系统的状态变换建模为线性变换矩阵 M与状态向量 s的乘法：s′=M⋅smodq。攻击目标是当 M的结构（如为稀疏、循环、或具有特定特征值）存在缺陷时，通过收集输入输出对 (s,s′)来求解 M，或利用 M的数学性质（如可逆性、特征分解）推导出密钥或内部状态。配方为：给定 n个线性无关的向量对 (si​,si′​)，构造矩阵方程 S′=M⋅S，其中 S,S′的列分别为 si​,si′​。则 M=S′⋅S−1。

算法/模型/方法名称​

矩阵求逆与线性方程组求解攻击

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：恢复线性状态转移矩阵 M。
步骤1：数据收集。获取或选择 n个线性无关的初始状态向量 s1​,s2​,...,sn​，并观察或计算其下一状态 si′​=Msi​。
步骤2：构造数据矩阵。令 (S = [s_1

精度/密度/误差/强度​

精度：在无噪声的精确算术下（如 mod q），精度为100%。
强度：攻击复杂度为 O(n3)（矩阵求逆）。当 n不大时高效。若 S病态或 M不可逆，攻击失败。
误差：在浮点运算或含噪声场景下，需最小二乘法，引入误差。

底层规律/理论定理​

线性代数基本定理：n个线性无关的n维向量构成一组基，任何线性变换可由其在基上的作用唯一确定。
矩阵表示定理：有限维向量空间上的线性变换可表示为矩阵。
可逆矩阵定理：方阵可逆当且仅当其列向量线性无关。

典型应用场景​

1. 线性反馈移位寄存器分析：给定LFSR输出序列，构建线性方程组求解反馈系数（抽头）。
2. 仿射密码破解：将仿射变换 y=Ax+b视为线性变换，通过已知明密文对求解 A,b。
3. 某些哈希函数的线性分析：若压缩函数有强线性分量，可构建线性模型进行碰撞或原像攻击。
4. 机器学习模型窃取：将线性模型视为 y=Wx，通过输入输出查询恢复权重矩阵 W。
5. 网络编码攻击：在随机线性网络编码中，通过捕获足够多的编码包恢复原始数据。

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

- n：状态向量维度。
- si​∈Fn：第i个初始状态向量。
- si′​∈Fn：第i个下一状态向量。
- S,S′∈Fn×n：数据矩阵。
- M∈Fn×n：待求的线性变换矩阵。
- F：数域，通常为 GF(2)或 GF(p)。

状态机​

S0​: 开始； S1​: 收集n个线性无关的 (si​,si′​)对； S2​: 构造矩阵 S,S′； S3​: 计算 S−1； S4​: 计算 M=S′S−1； S5​: 验证 M； S6​: 成功输出 M； S7​: 失败（如 S奇异）。

数学特征​

- 线性代数：核心是矩阵乘法、求逆、线性方程组求解。
- 抽象代数：在域 F上进行运算。
- 组合数学：矩阵稀疏性可能降低复杂度。
- 计算特征：高斯消元、LU分解、Strassen算法等。

语言特征​

术语：“线性变换”、“矩阵表示”、“基”、“可逆”、“高斯消元”。句式多为构造和求解描述。

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

阶段1：初始化
1. 设定维度 n和数域 F。
阶段2：数据采集
2. 循环直到收集到 n个线性无关的 si​：
a. 选择或观测一个状态 si​。
b. 观测其下一状态 si′​。
c. 检查 si​是否与已收集的向量线性无关（通过计算矩阵的秩）。
阶段3：矩阵构造
3. 构建矩阵 S=[s1​,...,sn​]， S′=[s1′​,...,sn′​]。
阶段4：求解
4. 计算 S的逆矩阵 S−1，通常通过高斯-约当消元法：构造增广矩阵 ([S

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：数据对需按顺序收集（si​→si′​）。求解过程（求逆、乘法）本质是顺序的，但可并行化。
并行序列：矩阵求逆和乘法可使用并行算法加速。

复杂度​

时间：O(n3)，来自矩阵求逆。
空间：O(n2)，存储矩阵 S,S′,M。
数据：需要 n个线性无关的向量对。

类别​

非线性代数攻击 / 多项式方程组求解 (Gröbner基)

模型配方​

将密码系统（如AES、哈希函数）的加密/验证过程表示为有限域 K上的多元多项式方程组 F={f1​(x1​,...,xn​)=0,...,fm​(x1​,...,xn​)=0}，其中变量包括密钥和内部状态。攻击目标是求解该方程组以恢复密钥。通过计算多项式理想 I=⟨f1​,...,fm​⟩的Gröbner基 G，得到一个易于求解的三角化系统，从而解出变量。

算法/模型/方法名称​

Buchberger算法 / F4/F5算法 求解Gröbner基

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：计算多项式理想 I⊂K[x1​,...,xn​]的Gröbner基 G。
步骤1：输入与初始化。输入多项式集合 F={f1​,...,fm​}，设定单项式序（如字典序 x1​>x2​>...>xn​或分级逆字典序）。令 G:=F， P:={(fi​,fj​)∥1≤i<j≤m}。
步骤2：循环处理S-多项式对。当​ P=∅时：
a. 从 P中选择一对 (f,g)并移除。
b. 计算S-多项式：
S(f,g)=LT(f)L​f−LT(g)L​g
其中 L=lcm(LT(f),LT(g))， LT(f)是 f的首项。
c. 计算 S(f,g)关于当前 G的余式 r=S(f,g)​G。这是通过多项式除法，反复用 G中多项式的首项消去 S(f,g)的首项，直到无法消去为止。
d. 如果​ r=0，则：
i. 将 r加入 G。
ii. 将 r与 G中所有其他多项式的配对加入 P： P:=P∪{(r,g′)∥∀g′∈G,g′=r}。
步骤3：输出。当 P为空时，算法终止，输出 G即为Gröbner基。
步骤4：回代求解。Gröbner基 G通常呈三角化形式。例如在字典序下，可依次求解单变量方程，并回代得到所有变量的值。

精度/密度/误差/强度​

精度：在精确算术下（如有理数、有限域），求解是精确的。
强度：最坏情况复杂度是双指数级，但对许多密码学方程组，由于结构特殊，实际复杂度可能较低。攻击强度取决于方程组的次数、变量数和稀疏性。
误差：无。

底层规律/理论定理​

希尔伯特基定理：多项式环上的每个理想都有有限生成集。
Buchberger定理：G是Gröbner基当且仅当对所有 f,g∈G，有 S(f,g)​G=0。
消元定理：在字典序下，Gröbner基具有三角结构，便于变量消元。

典型应用场景​

1. 代数密码分析：求解AES、DES等密码的代数方程组。
2. 多变量公钥密码：直接求解多变量方程以恢复密钥或伪造签名。
3. 密码协议分析：将协议安全性条件建模为多项式等式/不等式。
4. 组合优化：求解可满足性问题（转换为多项式方程组）。
5. 密码硬件代数故障分析：将故障传播建模为方程组并求解。

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

- K：系数域（如 GF(2), GF(p), Q)。
- x1​,...,xn​：多项式变量。
- f1​,...,fm​：生成多项式。
- I=⟨f1​,...,fm​⟩：由 F生成的理想。
- G：Gröbner基。
- P：待处理的S-多项式对集合。
- LT(f)：多项式 f的首项（在给定单项式序下）。

状态机​

S0​: 输入 F和单项式序； S1​: 初始化 G=F,P=Pairs(F)； S2​: 选择并移除一对 (f,g)从 P； S3​: 计算 S(f,g)和余式 r； S4​: 若 r=0，则转 S2​（若 P不空）；若 r=0，则更新 G和 P； S5​: 若 P=∅，输出 G；否则转 S2​。

数学特征​

- 交换代数：核心是多项式环、理想、模。
- 代数几何：理想 I的零点集对应于方程组的解集。
- 组合数学：单项式序是偏序集，算法涉及组合选择。
- 计算代数：算法复杂度分析。

语言特征​

术语：“Gröbner基”、“S-多项式”、“首项”、“单项式序”、“约简”、“理想”、“消元”。句式多为算法步骤描述和条件判断。

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

阶段1：准备
1. 输入多项式集合 F和单项式序 >。
2. 令 G:=F。
3. 令 P:={(f,g)∈G×G∥f=g}。
阶段2：主循环
4. While​ P=∅do：
a. 从 P中任取一对 (f,g)，并从 P中删除它。
b. 计算 L=lcm(LT(f),LT(g))。
c. 计算 S=(L/LT(f))⋅f−(L/LT(g))⋅g。
d. 计算 S除以 G的余式 r（即，重复：若存在 h∈G使得 LT(h)整除 LT(r)，则用 r−(LT(r)/LT(h))⋅h替换 r，直到无法进行）。
e. If​ r=0then：
i. 将 r加入 G。
ii. 对每个 g′∈G∖{r}，将 (r,g′)加入 P。
阶段3：输出与求解
5. 输出 G。
6. 对 G中的多项式，按变量顺序（如字典序）进行求解：先解只含 xn​的多项式，得到 xn​的值，回代到含 xn−1​,xn​的多项式中解 xn−1​，依此类推。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：Buchberger算法本质是顺序的，对的选择顺序影响效率但不影响结果。
并行序列：F4/F5算法将多个S-多项式同时约简，利用线性代数并行计算。

复杂度​

最坏时间：双指数 22O(n)。
平均时间：取决于问题结构，密码学问题常为单指数或亚指数。
空间：存储多项式和中间矩阵，可能很大。

类别​

拓扑代数攻击 / 同调代数攻击（应用于网络拓扑分析）

模型配方​

将网络拓扑结构抽象为单纯复形或图，利用同调群（如0维同调 H0​计算连通分支数，1维同调 H1​计算“环”数）的代数不变量来分析网络的冗余性、脆弱点和潜在攻击路径。模型配方：给定网络图 G=(V,E)，构造其链复形 C2​∂2​​C1​∂1​​C0​，计算同调群 Hk​=ker(∂k​)/im(∂k+1​)。其贝蒂数 βk​=rank(Hk​)是拓扑不变量，可用于指导攻击。

算法/模型/方法名称​

单纯同调计算与网络拓扑分析

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：计算网络拓扑的代数不变量（贝蒂数），以识别关键节点、冗余路径和脆弱结构。
步骤1：拓扑建模。将网络建模为图 G=(V,E)。可进一步将每个k-团（完全子图）视为k-单形，构建网络的单纯复形 K。
步骤2：构造链复形。定义k维链群 Ck​为以k-单形为基底的自由阿贝尔群（或向量空间）。定义边界算子 ∂k​:Ck​→Ck−1​，在基底上：对一个k-单形 [v0​,...,vk​]，
∂k​([v0​,...,vk​])=∑i=0k​(−1)i[v0​,...,vi​^​,...,vk​]
其中 vi​^​表示去掉顶点 vi​。扩展为线性映射。
步骤3：计算同调群。计算边界算子的矩阵表示 Dk​（在给定基底下）。然后：
- 计算 Zk​=ker(Dk​)（k维闭链群）。
- 计算 Bk​=im(Dk+1​)（k维边缘链群）。
- 同调群 Hk​=Zk​/Bk​。
步骤4：计算贝蒂数。贝蒂数 βk​=rank(Hk​)=rank(Zk​)−rank(Bk​)。对于图，常用的是：
- β0​= 连通分支数。
- β1​= 环数（独立环路数）= (

精度/密度/误差/强度​

精度：计算是精确的代数不变量。
强度：提供全局拓扑视角，而非局部属性。可识别用传统图论不易发现的脆弱性。
误差：模型简化（如忽略节点/边权重）可能引入与现实网络的误差。

底层规律/理论定理​

同调代数：链复形、同调群、贝蒂数、欧拉示性数定理（χ=∑(−1)kβk​）。
图论：平面图欧拉公式 V−E+F=2是同调的特殊情形。
代数拓扑：拓扑空间（此处为图）的同伦等价性保持同调群。

典型应用场景​

1. 网络渗透测试路径规划：利用 β1​识别冗余路径，寻找多条潜在攻击路径。
2. 关键基础设施网络脆弱性评估：通过 β0​变化分析节点/边移除对连通性的影响。
3. 网络拓扑匿名性分析（如Tor）：分析网络环路的同调特征，评估抗流量分析能力。
4. 传感器网络部署优化：通过同调指导部署以减少覆盖漏洞（高维类比）。
5. 社交网络社区检测与信息传播分析：0维同调可识别连通分支（社区）。

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

- G=(V,E)：网络图。
- K：由 G构造的单纯复形。
- Ck​：k维链群（自由阿贝尔群）。
- ∂k​：k维边界算子。
- Zk​=ker∂k​：k维闭链群。
- Bk​=im∂k+1​：k维边缘链群。
- Hk​=Zk​/Bk​：k维同调群。
- βk​=rank(Hk​)：第k贝蒂数。

状态机​

S0​: 输入图 G； S1​: 构建单纯复形 K（或直接使用图作为1维复形）； S2​: 构造链复形，计算边界算子矩阵 D0​,D1​,D2​； S3​: 计算 Z0​,Z1​,B0​,B1​； S4​: 计算 H0​,H1​和贝蒂数 β0​,β1​； S5​: 输出结果并解释。

数学特征​

- 代数拓扑：核心是同调论。
- 线性代数：边界算子的矩阵表示、核与像的计算。
- 图论：图是1维单纯复形。
- 组合数学：单纯复形的组合结构。
- 群论：链群是阿贝尔群。

语言特征​

术语：“单纯复形”、“链复形”、“边界算子”、“同调群”、“贝蒂数”、“闭链”、“边缘链”。句式多为定义和计算过程描述。

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

阶段1：建模
1. 输入无向图 G=(V,E)。设 (

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：矩阵构建和秩计算是顺序的。
并行序列：矩阵的秩和核计算可并行化。

复杂度​

时间：计算矩阵秩是 O(min(n,m)2⋅max(n,m))量级。
空间：存储边界矩阵 O(nm+mp)。
数据：需要完整的网络拓扑图。

类别​

几何代数攻击 / 共形几何代数网络流量异常检测

模型配方​

将网络流量数据点（如包大小、时间间隔、源/目的端口）映射到共形几何代数（CGA）空间 G4,1​中的点（或球面）。在CGA空间中，几何对象（点、球面、平面）和它们之间的变换（如反射、平移、旋转）可以用统一的代数形式表示。攻击模型：正常流量在CGA空间中形成某种几何流形或簇，异常流量（如DDoS、扫描）会偏离该流形。通过计算数据点与参考几何对象（如拟合的球面或平面）的距离（利用CGA内积）来检测异常。

算法/模型/方法名称​

基于共形几何代数的异常值检测

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：在高维网络流量数据中检测异常点。
步骤1：数据嵌入CGA空间。将每个d维数据点 x∈Rd嵌入到共形几何代数空间 G4,1​中，表示为 null vector（零向量）。标准嵌入：
X=x+21​x2e∞​+e0​
其中 e0​,e∞​是表示原点和无穷远点的基向量，满足 e02​=e∞2​=0,e0​⋅e∞​=−1。这里 x2是欧几里得范数平方。
步骤2：构建正常模型。使用一组正常流量数据点 {Xi​}，拟合一个几何对象，如d维球面。在CGA中，一个球面由向量 S=c−21​r2e∞​表示，其中 c是中心点（嵌入后的形式），r是半径。球面满足对任何在该球面上的点 X，有 X⋅S=0。拟合即寻找 S使得对大多数正常点，(

精度/密度/误差/强度​

精度：依赖于正常流量模型的准确拟合和阈值选择。可通过ROC曲线评估。
强度：CGA能统一处理平移、旋转、缩放，对某些变换下的异常更鲁棒。
误差：拟合误差、阈值选择误差、嵌入失真。

底层规律/理论定理​

共形几何代数：扩展了投影几何和反演几何，能在单一代数框架中表示欧氏、球面和投影几何的变换。
克利福德代数：CGA是特殊的克利福德代数 Cl4,1​。
几何计算：距离、角度、相交等几何关系可表示为代数运算。

典型应用场景​

1. DDoS攻击检测：攻击流量在（包大小，包速率）空间中形成不同簇。
2. 端口扫描检测：扫描流量在（目标IP分布，目标端口分布）空间中偏离正常。
3. 内部威胁检测：用户行为（登录时间、文件访问）在CGA空间中的异常。
4. 恶意软件C&C通信检测：周期性心跳包在时间序列上呈现几何规律，偏离即异常。
5. 网络入侵检测系统：作为特征提取和异常评分模块。

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

- x∈Rd：原始d维数据点。
- X∈G4,1​：嵌入CGA后的点（null vector）。
- e0​,e∞​：CGA的基向量，表示原点和无穷远点。
- S∈G4,1​：表示球面（或平面）的向量。
- d：点到几何对象的距离。
- τ：异常检测阈值。

状态机​

S0​: 收集正常流量数据； S1​: 将数据嵌入CGA空间； S2​: 拟合正常模型（几何对象 S）； S3​: 接收新数据点 Y； S4​: 嵌入 Y并计算距离 d； S5​: 比较 d2与 τ； S6​: 若大于 τ则报警（异常），否则标记正常； S7​: 可选地更新模型 S。

数学特征​

- 几何代数：核心是克利福德代数，双曲几何。
- 线性代数：向量空间运算，但具有几何积。
- 微分几何：流形、距离度量。
- 优化：拟合几何对象是最小二乘问题。
- 统计学：异常检测是假设检验。

语言特征​

术语：“共形几何代数”、“null vector”、“几何对象”、“内积”、“距离”。句式多为几何描述和计算过程。

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

离线训练阶段：
1. 收集历史正常流量数据点 {xi​}i=1N​⊂Rd。
2. 对每个点，计算嵌入： Xi​=xi​+21​xi2​e∞​+e0​。
3. 拟合球面模型 S：求解最优化问题 minS​∑i=1N​(Xi​⋅S)2，满足 S⋅e∞​=−1（归一化）。这导致一个特征值问题。
4. 计算正常距离的分布，确定阈值 τ（如95%分位数）。
在线检测阶段：
5. 对于新观测 y，计算 Y=y+21​y2e∞​+e0​。
6. 计算有符号距离平方： d2=(Y⋅e∞​)(S⋅e∞​)(Y⋅S)2​。注意 Y⋅e∞​=−1， S⋅e∞​=−1，所以 d2=(Y⋅S)2。
7. 如果​ d2>τ，则​ 发出异常警报。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：数据点按时间顺序到达，模型可在线更新。
分布式序列：不同网络节点的流量可分别建模，然后融合结果。

复杂度​

时间：嵌入 O(d)，距离计算 O(D)其中 D是CGA空间维度（32）。拟合模型 O(ND2)。
空间：存储模型 S和部分历史数据。

类别​

群论攻击 / 对称群密码分析（应用于S盒设计评估）

模型配方​

将分组密码的S盒视为一个有限集合 X={0,1}n上的置换 π:X→X。分析 π的群论性质，如其所在的对称群 S2n​中的阶、生成的子群结构、是否为偶置换、循环结构等。弱的群论性质（如阶过小、生成子群过小）可能导致密码算法存在弱点，如存在固定点、短周期，从而简化代数攻击或构造区分器。

算法/模型/方法名称​

置换的群论性质分析

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：分析S盒置换 π的群论性质，评估其强度。
步骤1：置换表示。给定S盒的查找表，将其视为集合 X={0,1,...,2n−1}上的置换 π。即对每个输入 x，有输出 π(x)。
步骤2：计算置换的阶。置换的阶是使得 πm=id的最小正整数 m。可通过计算置换的循环分解来求得：将 π分解为不相交循环的乘积：
π=(a11​a12​...a1l1​​)(a21​...a2l2​​)...(ak1​...aklk​​)
则阶 m=lcm(l1​,l2​,...,lk​)。
步骤3：分析循环结构。统计各长度循环的个数。例如，检查是否存在长度为1的循环（即固定点：π(x)=x），或长度为2的循环（对合）。记录循环类型（分区）。
步骤4：判断奇偶性。置换的奇偶性可由其循环分解计算：一个长度为 l的循环是偶置换当且仅当 l−1是偶数。所以，置换 π是偶置换当且仅当 ∑i=1k​(li​−1)=n−k是偶数。或者，计算置换的符号 sgn(π)=(−1)n−k。
步骤5：生成子群分析。计算由 π生成的循环子群 ⟨π⟩={π0,π1,...,πm−1}。其大小即为阶 m。如果 m很小，则S盒的代数次数可能较低，或者迭代使用S盒可能导致短周期。
步骤6：与其他变换的交互。考虑S盒与线性层的组合，分析其生成的子群是否可能过小（如AES的S盒与仿射层的组合是 S256​的一个子群，其阶已知很大）。

精度/密度/误差/强度​

精度：计算是精确的。
强度：这是一种结构性的弱点评估。单独群论性质弱不一定导致攻击，但可能与其他攻击结合。
误差：无。

底层规律/理论定理​

群论：对称群、置换的循环分解、置换的阶和奇偶性、凯莱定理。
代数组合：置换的循环类型与对称函数相关。

典型应用场景​

1. S盒设计评估：检测S盒是否存在短周期、固定点、对合等弱点。
2. 迭代密码分析：若轮函数作为置换阶很小，则全算法可能周期短。
3. 哈希函数分析：压缩函数中使用的置换的群论性质可能影响抗碰撞性。
4. 白盒密码：查找表实现的置换若阶小，可能通过自组合简化。
5. 流密码：基于置换的伪随机生成器的周期分析。

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

- n：S盒输入比特数。
- X={0,1}n：输入集合，大小 N=2n。
- π:X→X：S盒置换。
- 循环分解： π=C1​C2​...Ck​，其中 Ci​是循环。
- li​：循环 Ci​的长度。
- m=ord(π)：置换的阶。
- sgn(π)：置换的符号（±1）。

状态机​

S0​: 输入S盒表； S1​: 将S盒解释为置换 π； S2​: 计算循环分解； S3​: 计算阶 m=lcm(li​)； S4​: 分析循环结构（固定点、短循环等）； S5​: 计算奇偶性； S6​: 输出分析报告。

数学特征​

- 群论：对称群、子群、置换、循环指标。
- 组合数学：循环分解是组合结构。
- 数论：计算最小公倍数。
- 抽象代数：群作用。

语言特征​

术语：“置换”、“循环分解”、“阶”、“奇偶性”、“固定点”、“对合”、“生成子群”。句式多为性质描述和计算。

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

阶段1：数据输入
1. 读取S盒表，即长度为 2n的数组 S，其中 S[x]=π(x)。
阶段2：循环分解
2. 初始化标记数组 visited[0..N-1] = false。
3. 对​ x=0到​ N−1：
如果​ not visited[x]：
a. 开始一个新循环，记录 start = x。
b. 令 y = x，循环长度 len = 0。
c. 重复： visited[y] = true; y = S[y]; len++; 直到​ y == start。
d. 记录循环长度 len。
阶段3：计算阶
4. 收集所有循环长度 l1​,...,lk​。
5. 计算 m=lcm(l1​,...,lk​)。
阶段4：分析结构
6. 统计长度=1的循环数（固定点），长度=2的循环数（对合）等。
7. 计算奇偶性： sgn=(−1)N−k。
阶段5：输出
8. 输出阶 m，循环类型，奇偶性，以及是否存在弱点（如固定点）。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：循环分解算法是顺序遍历。
并行序列：标记和循环查找可并行化。

复杂度​

时间：O(N)，其中 N=2n。
空间：O(N)存储S盒和标记数组。

A0-0006​

线性代数

奇异值分解降维攻击

对高维网络流量或系统调用数据矩阵 A进行SVD：A=UΣVT。攻击者利用小的奇异值对应的分量（通常代表噪声或异常）来检测隐蔽信道或低频攻击。

A=∑i=1r​σi​ui​viT​， 选择 k<r， 用 Ak​=∑i=1k​σi​ui​viT​近似，残差 R=A−Ak​中可能包含攻击信号。

A0-0007​

线性代数

主成分分析异常检测

将正常行为数据投影到主成分上，攻击行为可能在少数主成分上有异常大的投影得分。

对数据中心化矩阵 X， 计算协方差矩阵 C=XTX/(n−1)， 特征分解得特征向量（主成分）vi​和特征值 λi​。 数据点 x的异常得分： s=∑i=1d​λi​(x⋅vi​)2​。

A0-0008​

线性代数

线性判别分析分类攻击

在入侵检测中，将连接特征投影到使类间散布最大、类内散布最小的方向上，以区分正常和攻击流量。

求解广义特征值问题： Sb​w=λSw​w， 其中 Sb​是类间散布矩阵， Sw​是类内散布矩阵。

A0-0009​

非线性代数

多项式插值密钥恢复

若密钥生成算法可表示为低次多项式 K=f(seed)， 则通过若干 (seed,K)对插值得到 f， 从而预测其他密钥。

拉格朗日插值： f(x)=∑i=1d+1​yi​∏j=i​xi​−xj​x−xj​​。

A0-0010​

非线性代数

结式消元法求解方程组

从两个二元多项式方程中消去一个变量，得到一元方程。用于简化方程组求解。

给定 f(x,y)=0,g(x,y)=0， 其结式 Resx​(f,g)是关于 y的一元多项式，其根为两曲线交点的y坐标。

A0-0011​

非线性代数

Wu-Ritt特征列方法

将多项式方程组化为三角列，类似于Gröbner基但使用不同的消元策略，适用于微分代数方程。

通过伪除和选取主变元，将方程组化为升列，从而依次求解。

A0-0012​

非线性代数

牛顿法求根攻击

用于求解非线性方程 f(x)=0， 在密码分析中可能用于求解近似解或优化问题。

迭代： xn+1​=xn​−f(xn​)/f′(xn​)。

A0-0013​

非线性代数

同伦延拓法

求解多项式方程组时，从一个易解的系统连续变形到目标系统，跟踪解路径。

构造同伦 H(x,t)=(1−t)G(x)+tF(x)， 当 t从0到1时，从 G(x)=0的解延拓到 F(x)=0的解。

A0-0014​

拓扑代数

持续同调分析时间序列

对时间序列数据（如网络流量）构建过滤复形，计算其持续同调（条形码），以捕获多尺度拓扑特征用于异常检测。

对每个尺度 ϵ， 构建复形 Kϵ​（如Rips复形）， 得到同调群的持续模结构， 生成条形码图。

A0-0015​

拓扑代数

映射类群作用于密码系统

考虑某些密码操作（如比特置换）构成的群，分析其拓扑性质（如亏格）对安全性的影响。

将密码变换视为曲面自同胚，研究其映射类群元素，可能揭示结构性弱点。

A0-0016​

拓扑代数

纤维丛理论模型隐蔽信道

将合法通信信道建模为底空间，隐蔽信道建模为纤维丛的截面，利用上同调检测非平凡丛的存在。

检查全局截面是否存在障碍类，若存在则表明有隐蔽信道。

A0-0017​

几何代数

共形几何代数恶意软件行为轨迹聚类

将系统调用序列映射为CGA空间中的轨迹，利用几何积计算轨迹间相似性进行聚类分析。

两条轨迹 P(t),Q(t)的相似性可通过比较其切向量在几何代数下的表示来定义。

A0-0018​

几何代数

几何代数表示神经网络对抗样本

用多重向量表示图像像素，对抗扰动在几何代数空间中具有特定方向，可更高效生成对抗样本。

图像 I表示为 X=∑i​Ii​ei​， 对抗扰动 δ满足 f(X+δ)=f(X)， 在几何积下约束 δ。

A0-0019​

几何代数

旋量表示与量子密码分析

将量子比特状态用几何代数中的旋量表示，分析量子密码协议的可能经典模拟攻击。

旋量 ψ满足 Iψ=ψ， 其中 I是伪标量，可用于简化计算。

A0-0020​

群论

置换群密码的轨道攻击

若密码算法在某个群作用下轨道较小，则可通过对代表元进行穷举来攻击。

设群 G作用在状态空间 X上， 若轨道 G⋅x大小小， 则可对每个轨道代表元测试。

A0-0021​

群论

线性反馈移位寄存器本原多项式检测

LFSR的周期最大当且仅当其反馈多项式是本原的。检测给定多项式是否本原，以评估强度。

多项式 f(x)阶为 n， 需检查 x2n−1≡1modf(x)且对所有 d∥(2n−1)的素因子， x(2n−1)/d≡1modf(x)。

A0-0022​

群论

椭圆曲线离散对数的Pollard Rho攻击

在椭圆曲线点群中利用随机游走寻找碰撞，将离散对数问题复杂度降至 O(n​)。

定义迭代函数 Ri+1​=f(Ri​)， 当碰撞 Ri​=Rj​时， 有 ai​P+bi​Q=aj​P+bj​Q， 得 d=(ai​−aj​)(bj​−bi​)−1modn。

A0-0023​

群论

陪集遍历中间相遇攻击

将密钥空间划分为群的陪集，分别从两侧搜索并在中间匹配，加速密钥恢复。

设 G是密钥空间群， H,K是子群， 搜索 g∈G满足 g=hk， 分别枚举 h∈H,k∈K并匹配中间状态。

A0-0024​

环论

多项式环上理想成员判定攻击

判断某个多项式（如表示密钥关系）是否属于由密码方程生成的理想，若是则可推导出密钥。

给定理想 I=⟨f1​,...,fm​⟩和多项式 g， 计算 g除以Gröbner基的余式，若为0则 g∈I。

A0-0025​

环论

中国剩余定理在RSA中的攻击

利用RSA加密在模 p和模 q下的性质，结合中国剩余定理加速计算或进行侧信道攻击。

解同余方程组： c≡memodp， c≡memodq， 得 mmodN。

A0-0026​

域论

有限域乘法逆元侧信道攻击

计算有限域逆元时，若采用扩展欧几里得算法，其运行时间可能与输入相关，从而泄露信息。

测时攻击： 测量计算 a−1modp的时间， 与 a的大小相关， 可恢复 a。

A0-0027​

域论

正规基表示下的代数攻击

在 GF(2n)中使用正规基表示，S盒的方程可能更稀疏，利于代数攻击。

设正规基为 {β,β2,...,β2n−1}， 元素 a=∑ai​β2i， 则平方是线性移位： a2=∑ai​β2i+1。

A0-0028​

格论

LLL格基约化攻击背包密码

将子集和问题转化为在格中寻找短向量问题，应用LLL算法求解。

构造格基 B， 其短向量对应子集和问题的解。

A0-0029​

格论

BKZ攻击LWE问题

将LWE问题嵌入格中，使用BKZ算法寻找包含误差向量的短向量，从而恢复密钥。

构建嵌入格： L={(x,y)∈Zm×Zn∥Ax=ymodq}， 其包含短向量 (s,e)。

A0-0030​

模论

模线性方程求解在RSA中的攻击

求解形如 ax≡bmodN的方程，当 a与 N不互素时，可能泄露因子。

计算 d=gcd(a,N)， 若 d>1则可能是 p或 q。

A0-0031​

表示论

群表示分析S盒的差分均匀性

将S盒视为群表示，研究其不可约表示如何影响差分性质。

计算S盒的Fourier变换（Walsh谱），与差分均匀性相关。

A0-0032​

表示论

特征标理论检测置换非线性度

利用置换群的特征标计算S盒的非线性度等密码学指标。

非线性度 (NL(f) = 2^{n-1} - \frac{1}{2} \max_{\alpha \neq 0}

A0-0033​

同调代数

Ext函子计算密码协议可复合性

用同调代数工具分析密码协议的安全性可复合性，检查是否存在隐藏的弱点。

将协议视为复形， 安全性条件对应上同调群的消失。

A0-0034​

同调代数

Tor函子分析密钥交换协议

用于分析在张量积下密钥的一致性，可能检测中间人攻击。

计算 Tor1Z​(A,B)等群。

A0-0035​

范畴论

范畴语义下协议安全性

用范畴论建模密码协议，态射表示攻击，检查安全性是否在函子下保持。

构造攻击范畴， 安全性对应某函子的忠实性。

A0-0036​

泛代数

克隆理论分析密码函数完备性

研究密码函数集是否在某种意义上完备，类似于逻辑门集的完备性。

检查函数集生成的克隆是否包含所有函数。

A0-0037​

数论

二次筛法因子分解

用于分解大整数，攻击RSA。核心是寻找 x2≡y2modN且 x≡±ymodN。

收集平滑数关系，构建线性方程组 mod 2， 解出平方同余式。

A0-0038​

数论

指数积分法计算离散对数

在有限域 GF(p)中计算离散对数的亚指数算法。

构造因子基， 寻找指数关系， 求解线性方程组。

A0-0039​

数论

椭圆曲线的MOV归约

将椭圆曲线离散对数归约到有限域离散对数，当嵌入度小时有效。

使用Weil配对将 E(Fq​)中的DLP归约到 Fqk∗​中的DLP， 其中 k是嵌入度。

A0-0040​

组合代数

超图划分攻击社交网络

将社交网络建模为超图，利用超图划分算法识别社区，用于针对性攻击。

最小化割边权重， 同时平衡分区大小。

A0-0041​

组合代数

拟阵理论在访问控制策略分析

将访问控制策略建模为拟阵，检查权限分配是否存在漏洞。

拟阵的独立集对应安全的权限集， 检查是否满足交换性等公理。

A0-0042​

微分代数

Risch算法检测代数关系

用于判断密码算法中出现的表达式是否存在代数关系，可能简化攻击。

给定表达式 f， 判断是否存在多项式 P使 P(f,f′,...)=0。

A0-0043​

微分代数

微分攻击对流密码

将密钥流生成器视为自动机，对其状态方程进行微分，可能降低复杂度。

计算布尔函数的导数 Da​f(x)=f(x)⊕f(x⊕a)。

A0-0044​

积分代数

代数攻击中的积分特性

类似于积分密码分析，但用代数语言描述，如证明某个中间状态的和为零。

构造多项式理想， 证明和为零是理想的成员。

A0-0045​

随机代数

多项式系统的概率求解

引入随机变量，以高概率求解方程组，如通过随机线性组合消元。

选择随机标量 αi​， 考虑 ∑αi​fi​=0， 可能得到更易解的方程。

A0-0046​

计算代数

快速多项式乘法在侧信道分析

使用FFT加速卷积，用于快速计算相关性或模板匹配。

计算 h=f∗g通过 H=F⋅G其中 F,G是DFT。

A0-0047​

计算代数

稀疏线性方程组求解攻击

密码方程组通常稀疏，使用专用算法（如Wiedemann算法）加速求解。

Wiedemann算法： 寻找序列的最小多项式， 适用于大型稀疏矩阵。

A0-0048​

符号代数

符号执行用于漏洞挖掘

将程序变量表示为符号，路径条件积累为多项式约束，求解可得触发漏洞的输入。

维护路径条件 PC， 当遇到分支时， 对两个方向分别添加约束， 并调用求解器检查可满足性。

A0-0049​

统计代数

代数侧信道分析

将能量迹建模为密钥的函数加上噪声，使用代数方法求解密钥，结合统计去噪。

模型： ti​=L(vi​(k))+ni​， 其中 L是泄漏函数， vi​是中间值， 构建方程组并求解。

A0-0050​

混合代数

代数与机器学习混合攻击

使用代数方法生成特征，用机器学习分类器检测攻击，或反之。

例如， 用Gröbner基简化特征， 再用SVM分类。

编号​

Attack-A0-0008

类别​

线性代数攻击 / 线性判别分析分类攻击

模型配方​

在入侵检测系统中，将网络连接的特征向量投影到使类间散布最大化、类内散布最小化的方向上，以区分正常和攻击流量。给定两类样本（正常类 C0​和攻击类 C1​），寻找投影方向 w，使得 Fisher 准则 J(w)=wTSW​wwTSB​w​最大，其中 SB​是类间散布矩阵，SW​是类内散布矩阵。投影后的数据在新的子空间中可以更容易地被线性分类器分离。

算法/模型/方法名称​

线性判别分析分类攻击模型

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：找到最佳投影方向 w，使得两类样本在投影后能最大程度地分离。
步骤1：计算类内散布矩阵。对每个类 Ci​，计算其均值向量 μi​=ni​1​∑x∈Ci​​x，其中 ni​是类 Ci​的样本数。类内散布矩阵定义为：
SW​=∑i=01​∑x∈Ci​​(x−μi​)(x−μi​)T
步骤2：计算类间散布矩阵。计算总体均值 μ=n1​∑x​x，类间散布矩阵为：
SB​=∑i=01​ni​(μi​−μ)(μi​−μ)T
步骤3：求解广义特征值问题。最大化 Fisher 准则等价于求解广义特征值问题：
SB​w=λSW​w
步骤4：选择投影方向。取最大特征值对应的特征向量作为投影方向 w∗。
步骤5：计算投影和阈值。将训练样本投影到 w∗上：y=w∗Tx。计算两类的投影均值：mi​=w∗Tμi​。通常选择分类阈值为 y0​=2m0​+m1​​或基于类先验概率调整。
步骤6：分类新样本。对新样本 xnew​，计算投影 ynew​=w∗Txnew​，若 ynew​>y0​则判为攻击，否则为正常。

精度/密度/误差/强度​

精度：在两类样本分布近似多元正态且协方差矩阵相等时，LDA 是最优分类器。精度受特征选择和样本质量影响。
强度：分类能力由 Fisher 比 J(w∗)衡量，值越大表示区分度越强。
误差：误报率和漏报率取决于类分布的重叠程度。

底层规律/理论定理​

Fisher 线性判别：最大化类间距离与类内距离的比值。
贝叶斯决策理论：在等协方差正态分布下，LDA 对应于最小化错误率的贝叶斯分类器。
广义瑞利商：优化问题转化为广义特征值问题。

典型应用场景​

1. 网络入侵检测系统：区分正常流量和已知攻击模式（如 DDoS、扫描）。
2. 垃圾邮件过滤：区分正常邮件和垃圾邮件。
3. 恶意软件检测：基于 API 调用序列的特征，区分恶意和良性软件。
4. 内部威胁检测：基于用户行为特征，区分正常行为和可疑行为。
5. 物联网设备异常检测：基于设备流量特征，区分正常操作和受控状态。

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

- x∈Rd：特征向量。
- C0​,C1​：正常类和攻击类的样本集合。
- n0​,n1​：两类样本数量。
- μ0​,μ1​：两类样本的均值向量。
- μ：总体均值向量。
- SW​：类内散布矩阵。
- SB​：类间散布矩阵。
- w：投影方向（特征向量）。
- y：投影后的标量值。
- y0​：分类阈值。

状态机​

S0​: 输入带标签的训练数据； S1​: 计算类均值 μ0​,μ1​和总体均值 μ； S2​: 计算 SW​和 SB​； S3​: 求解广义特征值问题 SB​w=λSW​w； S4​: 选取最大特征值对应的特征向量 w∗； S5​: 计算投影和分类阈值 y0​； S6​: 对新样本投影并分类。

数学特征​

- 线性代数：矩阵运算、特征值分解、二次型。
- 多元统计：均值向量、散布矩阵、协方差、多元正态分布。
- 优化：瑞利商最大化。
- 几何：投影、距离。

语言特征​

术语：“类内散布”、“类间散布”、“Fisher 准则”、“广义特征值”、“投影方向”、“分类阈值”。句式多为数学推导和比较。

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

训练阶段：
1. 准备训练集 {(xi​,li​)}，其中 li​∈{0,1}。
2. 按类别划分数据：C0​={xi​∥li​=0},C1​={xi​∥li​=1}。
3. 计算：μ0​=∥C0​∥1​∑x∈C0​​x， μ1​=∥C1​∥1​∑x∈C1​​x， μ=n1​∑i​xi​。
4. 计算：SW​=∑x∈C0​​(x−μ0​)(x−μ0​)T+∑x∈C1​​(x−μ1​)(x−μ1​)T。
5. 计算：SB​=n0​(μ0​−μ)(μ0​−μ)T+n1​(μ1​−μ)(μ1​−μ)T。
6. 求解 SB​w=λSW​w，可通过计算 SW−1​SB​的特征向量实现（若 SW​可逆）。
7. 选取最大特征值对应的特征向量 w∗。
8. 计算投影：m0​=w∗Tμ0​， m1​=w∗Tμ1​，设定阈值 y0​=2m0​+m1​​。
检测阶段：
9. 对新样本 xnew​，计算投影 y=w∗Txnew​。
10. 若 y>y0​，则分类为攻击（1），否则为正常（0）。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：训练过程是顺序的，但矩阵运算可并行化。
分布式序列：散布矩阵的计算可分布式进行。

复杂度​

时间：计算 SW​,SB​为 O(nd2)，求特征向量为 O(d3)，其中 d为特征维数。
空间：存储散布矩阵 O(d2)，特征向量 O(d)。

编号​

Attack-A0-0009

类别​

非线性代数攻击 / 多项式插值密钥恢复

模型配方​

若密钥生成算法可表示为关于种子（seed）的低次多项式 K=f(seed)，则通过获取若干对（seed, K），使用多项式插值（如拉格朗日插值）恢复多项式 f，从而可预测任意种子对应的密钥。模型配方：给定 t+1个点对 (xi​,yi​)，其中 yi​=f(xi​)，且 f是次数不超过 t的多项式，则存在唯一的插值多项式 L(x)满足 L(xi​)=yi​，且 L(x)=f(x)。

算法/模型/方法名称​

拉格朗日插值密钥恢复攻击

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：从 t+1个（种子，密钥）对恢复密钥生成多项式 f(x)。
步骤1：收集数据。通过侧信道、逆向工程或协议交互获取 t+1个不同的种子值 x1​,x2​,...,xt+1​及其对应的密钥 y1​,y2​,...,yt+1​，其中密钥可能为整数或域元素。
步骤2：构建拉格朗日基多项式。对每个 i=1,...,t+1，定义拉格朗日基多项式：
li​(x)=∏j=1j=i​t+1​xi​−xj​x−xj​​
步骤3：构造插值多项式。插值多项式为：
L(x)=∑i=1t+1​yi​⋅li​(x)
步骤4：验证与简化。验证 L(xi​)=yi​对所有 i成立。若 f定义在有限域上，将 L(x)的系数约化到该域。
步骤5：密钥预测。对于任意新种子 x′，计算预测密钥 K′=L(x′)。
步骤6：复杂度分析。若多项式次数 t很小，攻击高效。若 t很大，则需更多数据点，但可能通过其他结构简化。

精度/密度/误差/强度​

精度：在精确算术下，插值多项式精确等于 f(x)，预测精度为100%。
强度：攻击所需数据点数为 t+1，时间复杂度为 O(t2)（若直接计算）。
误差：在浮点数运算中可能产生舍入误差，但在有限域中无误差。

底层规律/理论定理​

多项式插值存在唯一性定理：给定 n+1个互异的点，存在唯一一个次数不超过 n的多项式通过所有这些点。
拉格朗日插值公式：显式构造插值多项式。
中国剩余定理：多项式插值可视为中国剩余定理在多项式环上的应用。

典型应用场景​

1. 弱伪随机数生成器攻击：若PRNG输出是种子的低次多项式，可插值预测后续输出。
2. 密码协议中的密钥派生攻击：若密钥派生函数（KDF）使用简单多项式，可能被插值。
3. 硬件安全模块（HSM）的密钥生成漏洞：某些HSM的密钥生成算法若设计不当，可能呈现低次多项式特性。
4. 白盒密码实现中的查表恢复：将查表内容建模为多项式并插值。
5. 数字版权管理（DRM）的密钥恢复：从多个设备提取的（设备ID, 内容密钥）对中插值出主密钥多项式。

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

- xi​：第 i个种子值（自变量）。
- yi​：第 i个密钥值（因变量）。
- t：多项式 f的次数上界。
- li​(x)：第 i个拉格朗日基多项式。
- L(x)：插值得到的多项式。
- 有限域 GF(q)：可选，系数和变量在该域中运算。

状态机​

S0​: 开始，目标为恢复密钥生成函数； S1​: 收集 t+1个不同的（种子，密钥）对； S2​: 构造拉格朗日基多项式 li​(x)； S3​: 计算插值多项式 L(x)=∑yi​li​(x)； S4​: 验证 L(xi​)=yi​； S5​: 输出 L(x)，可用于预测。

数学特征​

- 代数：多项式环、基函数、插值。
- 数论：有限域运算。
- 计算：多项式求值、乘法、加法。
- 组合：基函数的构造涉及乘积。

语言特征​

术语：“拉格朗日插值”、“基多项式”、“插值多项式”、“唯一性”。句式多为描述插值构造过程。

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

阶段1：数据收集
1. 通过观察、交互或窃听，获取至少 d+1个（种子，密钥）对，其中 d为猜测的多项式次数。若次数未知，可逐步增加点数直至插值稳定。
阶段2：插值计算
2. 设已收集点对为 (x1​,y1​),...,(xn​,yn​)， n≥d+1。
3. 对 i=1到 n，计算基多项式：
li​(x)=∏j=1,j=in​xi​−xj​x−xj​​
4. 计算插值多项式：
L(x)=∑i=1n​yi​⋅li​(x)
（注意：在有限域中，除法和乘法均为模运算。）
阶段3：验证
5. 检查 L(xi​)=yi​是否对所有 i成立。若成立，则 L(x)很可能为正确的密钥生成多项式。
阶段4：预测
6. 对于新种子 x′，计算预测密钥 K′=L(x′)。
7. 可选：用额外已知对验证预测准确性。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：收集数据点可按任意顺序，插值计算顺序无影响。
并行序列：基多项式的计算可并行。

复杂度​

时间：朴素计算每个基多项式需 O(n2)次乘除，总体 O(n3)，但可用优化方法（如重心插值）降至 O(n2)。
空间：存储点对和多项式系数，O(n)。

编号​

Attack-A0-0010

类别​

非线性代数攻击 / 结式消元法求解方程组

模型配方​

从两个多元多项式方程中消去一个变量，得到变量数减少的方程。给定两个多项式 f(x,y)=0和 g(x,y)=0，其结式 Resx​(f,g)是关于 y的一元多项式，其根包含两曲线所有交点的 y坐标。通过求解结式方程得到 y，再代回原方程求 x，从而将二元方程组求解化为一元方程求解。模型配方：将密码方程组视为多元多项式系统，通过反复计算结式消元，最终得到单变量方程。

算法/模型/方法名称​

结式消元法求解多项式方程组

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：求解二元多项式方程组 f(x,y)=0,g(x,y)=0。
步骤1：将多项式按变量排序。将 f和 g视为 x的多项式，系数为 y的多项式：
f(x,y)=am​(y)xm+am−1​(y)xm−1+...+a0​(y)
g(x,y)=bn​(y)xn+bn−1​(y)xn−1+...+b0​(y)
其中 ai​(y),bj​(y)是 y的多项式。
步骤2：构造 Sylvester 矩阵。结式的 Sylvester 矩阵是一个 (m+n)×(m+n)矩阵：
S=​<br>am​<br>0<br>⋮<br>0<br>bn​<br>0<br>⋮<br>0​am−1​am​⋱⋯bn−1​bn​⋱⋯​⋯am−1​⋱0⋯bn−1​⋱0​a0​⋯⋱am​b0​⋯⋱bn​​0a0​⋱am−1​0b0​⋱bn−1​​⋯⋯⋱⋯⋯⋯⋱⋯​00⋮a0​00⋮b0​<br>​​
前 n行由 f的系数构成，后 m行由 g的系数构成。
步骤3：计算结式。结式 Resx​(f,g)定义为 Sylvester 矩阵的行列式：
R(y)=det(S)
这是一个关于 y的多项式。
步骤4：求解结式方程。解方程 R(y)=0，得到 y的可能值集合 {y1​,y2​,...,yk​}。
步骤5：回代求解 x。对每个 yi​，代入原方程 f(x,yi​)=0和 g(x,yi​)=0，并求 x。通常取两个多项式的最大公因式（GCD）来求解 x。
步骤6：验证。将解 (xi​,yi​)代入原方程组验证。

精度/密度/误差/强度​

精度：在精确算术下，结式消元是精确的，但可能引入寄生解（即满足结式但不满足原方程的解）。
强度：将二元方程组化为一元方程，降低求解难度。但结式次数可能很高（最高 mn），求解一元高次方程本身可能困难。
误差：数值计算行列式可能带来误差。

底层规律/理论定理​

结式理论：两多项式有公共根当且仅当其结式为零。
Sylvester 矩阵：用于计算结式的矩阵构造。
消元理论：结式是消元理想的一种生成元。

典型应用场景​

1. 代数攻击中简化方程组：在密码代数方程组中消去部分变量。
2. 密码体制的代数分析：如求解多变量二次方程组的尝试。
3. 椭圆曲线密码的 MOV 攻击：在配对计算中涉及多项式求根。
4. 几何攻击：求解表示几何约束的多项式方程组。
5. 软件验证中的约束求解：用于程序路径条件中的多项式约束。

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

- f(x,y),g(x,y)：二元多项式。
- ai​(y),bj​(y)：f,g视为 x的多项式时的系数多项式。
- m,n：f,g关于 x的次数。
- S：Sylvester 矩阵。
- R(y)：结式多项式。
- (xi​,yi​)：方程组的解。

状态机​

S0​: 输入二元多项式方程组； S1​: 将多项式按消元变量重排； S2​: 构造 Sylvester 矩阵 S； S3​: 计算行列式得结式 R(y)； S4​: 求解 R(y)=0得 yi​； S5​: 对每个 yi​，回代求解 x； S6​: 验证解，输出。

数学特征​

- 代数：多项式环、结式、行列式。
- 线性代数：矩阵、行列式计算。
- 计算：符号计算、多项式求根。
- 几何：代数曲线交点。

语言特征​

术语：“结式”、“Sylvester 矩阵”、“消元”、“行列式”、“回代”。句式多为构造和计算过程描述。

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

阶段1：准备
1. 给定二元多项式方程组：f(x,y)=0,g(x,y)=0。确定消元变量，例如 x。
阶段2：构造 Sylvester 矩阵
2. 将 f,g按 x的降幂排列，系数为 y的多项式。
3. 设 f关于 x的次数为 m， g为 n。构造 (m+n)×(m+n)的 Sylvester 矩阵 S，如前述。
阶段3：计算结式
4. 计算行列式 R(y)=det(S)。这可以通过符号计算或数值计算完成。
阶段4：求解结式
5. 解一元方程 R(y)=0，得到 y的所有可能值 y1​,...,yk​（在复数域或指定域中）。
阶段5：回代
6. 对每个 yi​，代入 f(x,yi​)=0和 g(x,yi​)=0，得到两个关于 x的一元多项式。
7. 计算这两个多项式的最大公因式（GCD），其根即为可能的 x值。或者，直接解 f(x,yi​)=0得到 x，并检查是否满足 g(x,yi​)=0。
阶段6：验证
8. 将所有候选解 (xi​,yi​)代入原方程组验证，去除寄生解。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：消元和回代是顺序过程。
并行序列：对不同的 yi​回代求解可并行。

复杂度​

时间：计算行列式最坏为 O((m+n)3)，求解高次方程 R(y)=0的复杂度取决于次数和求解方法。
空间：存储 Sylvester 矩阵和结式多项式。

编号​

Attack-A0-0011

类别​

非线性代数攻击 / Wu-Ritt特征列方法

模型配方​

将多项式方程组化为三角列，类似于Gröbner基但使用不同的消元策略，尤其适用于微分代数方程。给定多项式方程组 PS={f1​,f2​,...,fm​}，通过伪除和选取主变元，将 PS化为特征列 CS，使得 Zero(PS)=Zero(CS)∪⋃i​Zero(PS∪{Ii​})，其中 Ii​是初式。特征列 CS呈三角化形式，便于依次求解。

算法/模型/方法名称​

Wu-Ritt特征列方法

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：将多项式方程组化为三角列，并求解。
步骤1：变量排序。确定变量的序 x1​<x2​<...<xn​。
步骤2：将多项式组化为升列。一个升列 AS是一组多项式 A1​,A2​,...,Ar​，其中每个 Ai​的主变元（最高序变量）大于其后面多项式的主变元，且 Ai​对其主变元的次数大于后面多项式中该变量的次数。通过伪除法进行约化，将多项式组化为升列。
步骤3：构造特征列。从初始多项式组 PS开始，反复选择序最低的多项式，用其约化其他多项式，并将非零余式加入多项式组，直到所有多项式对所选升列余式为零。最终得到的升列称为特征列 CS。
步骤4：分解零点集。特征列 CS的零点集 Zero(CS)包含原方程组的零点，但需考虑初式（多项式对其主变元的最高系数）不为零的条件。即：
Zero(PS)=Zero(CS/I)∪⋃i​Zero(PS∪{Ii​})
其中 I是所有初式的乘积，Ii​是单个初式。
步骤5：三角系统求解。特征列 CS呈三角形式：
⎩⎨⎧​f1​(x1​,...,xi1​​)=0f2​(x1​,...,xi2​​)=0⋯fr​(x1​,...,xir​​)=0​
其中 i1​<i2​<...<ir​。可以从第一个方程解出部分变量，代入后续方程逐步求解。
步骤6：处理分支。对每个分支（初式为零的情况）需单独处理，可能产生多个三角系统。

精度/密度/误差/强度​

精度：符号计算，精确。
强度：可处理多项式方程组，尤其适合微分多项式。效率通常优于 Gr"obner 基在某些情况。
误差：无数值误差，但计算可能因规模大而复杂。

底层规律/理论定理​

Ritt-Wu 原理：多项式组的零点集可分解为特征列的零点集和初式为零的零点集的并。
伪除算法：多项式约化的基础。
三角列理论：代数方程组的三角化。

典型应用场景​

1. 密码代数方程求解：求解对称密码的代数方程组。
2. 几何定理机器证明：将几何条件表示为多项式，用特征列法证明。
3. 机器人运动学求解：求解逆运动学方程。
4. 微分方程代数化求解：将微分方程视为微分多项式，用微分特征列法。
5. 程序验证中的约束求解。

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

- x1​,...,xn​：变量，具有序关系。
- PS={f1​,...,fm​}：多项式集合。
- CS={A1​,...,Ar​}：特征列（升列）。
- 主变元：多项式中序最高的变量。
- 初式：多项式对其主变元的最高系数。
- 伪余式：多项式对升列约化后的余式。

状态机​

S0​: 输入多项式组 PS和变量序； S1​: 初始化特征列为空； S2​: 在 PS中选择序最低的多项式作为基； S3​: 用基约化 PS中其他多项式，产生余式； S4​: 将非零余式加入 PS； S5​: 重复直到所有多项式对当前升列余式为零，得特征列 CS； S6​: 输出 CS并分解零点集。

数学特征​

- 代数：多项式环、序、约化。
- 计算代数：符号计算、三角化。
- 几何：代数簇分解。

语言特征​

术语：“特征列”、“升列”、“主变元”、“初式”、“伪余式”、“三角系统”。句式多为算法步骤描述。

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

阶段1：变量排序
1. 设定变量序，例如 x1​<x2​<...<xn​。
阶段2：初始化
2. 设 PS为初始多项式组， CS=∅。
阶段3：特征列计算循环
3. While​ PS非空 do：
a. 从 PS中选择序最低的多项式 f（主变元最小）。
b. 将 f从 PS中移除，加入 CS。
c. 用 CS中的多项式对 PS中每个多项式 g进行约化：计算 g对 CS的伪余式 r。
d. 若 r非零，则将 r加入 PS。
4. 得到特征列 CS。
阶段4：分解零点集
5. 计算 CS中每个多项式的初式 Ii​。
6. 原方程组的零点集分解为：
- Zero(CS/I)，其中 I=∏Ii​。
- 对每个 i，考虑 Ii​=0的情况，将 Ii​加入原方程组递归计算。
阶段5：求解三角系统
7. 对每个分支的特征列（三角系统），从最后一个方程开始求解，依次回代。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：算法是顺序迭代的。
分布式序列：不同分支可并行处理。

复杂度​

时间：最坏情况指数时间，但实际中常比 Gr"obner 基快。
空间：存储多项式中间表达式。

编号​

Attack-A0-0012

类别​

非线性代数攻击 / 牛顿法求根攻击

算法/模型/方法名称​

牛顿迭代法求根攻击

模型配方​

用于求解非线性方程 f(x)=0的数值方法。在密码分析中，可能用于求解近似解或优化问题。模型配方：从一个初始猜测 x0​开始，利用函数 f及其导数 f′构造迭代公式 xn+1​=xn​−f(xn​)/f′(xn​)，迭代直至 (

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：求方程 f(x)=0的根。
步骤1：选择初始点。根据对问题的了解，选择一个初始近似值 x0​。若对根的位置无先验知识，可能需要随机选择多个初始点。
步骤2：迭代更新。对于 n=0,1,2,...，计算：
xn+1​=xn​−f′(xn​)f(xn​)​
其中 f′(xn​)是 f在 xn​处的导数。在多元情况下，f:Rm→Rm，导数由雅可比矩阵 Jf​代替，更新公式为：
xn+1​=xn​−Jf​(xn​)−1f(xn​)
步骤3：检查收敛。设定容差 ϵ。当 ∥f(xn​)∥<ϵ或 ∥xn+1​−xn​∥<ϵ时，停止迭代，将 xn+1​作为近似根。
步骤4：处理不收敛。若迭代超过最大次数仍未收敛，或 f′(xn​)=0，则尝试其他初始点。
步骤5：验证。将得到的根代入原方程验证是否满足要求。

精度/密度/误差/强度​

精度：在单根附近，牛顿法具有二阶收敛速度，精度高。但在重根或导数接近零时收敛慢。
强度：高度依赖初始点选择，可能收敛到局部解而非全局解。
误差：迭代误差随步数减少，但浮点误差可能累积。

底层规律/理论定理​

泰勒展开：牛顿法源于函数在迭代点的一阶泰勒展开。
收敛定理：若初始点足够接近单根，且 f′连续且不为零，则牛顿法二次收敛。
牛顿-坎托罗维奇定理：给出牛顿法收敛的充分条件。

典型应用场景​

1. 密码方程数值求解：当代数方程难以符号求解时，尝试数值解。
2. 侧信道分析中的模板匹配：优化模板匹配的参数。
3. 机器学习对抗样本生成：用牛顿法优化对抗扰动。
4. 参数估计攻击：估计密码算法中的未知参数。
5. 密码协议中的数值分析：如求解离散对数问题的近似解。

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

- f(x)：目标函数，要求根或优化。
- f′(x)或 Jf​(x)：f的导数或雅可比矩阵。
- x0​：初始猜测。
- ϵ：容差，用于判断收敛。
- Nmax​：最大迭代次数。

状态机​

S0​: 选择初始点 x0​，设置 n=0； S1​: 计算 f(xn​)和 f′(xn​)； S2​: 若 f′(xn​)=0则失败；否则计算 xn+1​=xn​−f(xn​)/f′(xn​)； S3​: 检查收敛条件：若 (

数学特征​

- 微积分：导数、泰勒展开。
- 数值分析：迭代法、收敛性、误差分析。
- 优化：寻找函数零点。
- 线性代数：求解线性系统（多元情形）。

语言特征​

术语：“牛顿迭代”、“收敛”、“容差”、“导数”、“雅可比矩阵”。句式多为迭代更新和条件判断。

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

阶段1：初始化
1. 输入函数 f，导数 f′（或计算差商近似），初始点 x0​，容差 ϵ=10−6，最大迭代次数 N=100。
阶段2：迭代循环
2. For​ k=0to​ N−1：
a. 计算 y=f(xk​)。
b. 若 (

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：迭代是顺序的。
并行序列：多个初始点可并行尝试。

复杂度​

时间：每次迭代需计算函数值和导数，复杂度取决于 f的求值成本。通常迭代次数很少（二次收敛）。
空间：存储当前点和一些标量。

编号​

Attack-A0-0013

类别​

非线性代数攻击 / 同伦延拓法

模型配方​

求解多项式方程组时，构造一个同伦 H(x,t)=(1−t)G(x)+tF(x)，其中 G(x)=0是一个易于求解的系统（起始系统），F(x)=0是目标系统。当参数 t从0连续变化到1时，跟踪从 G(x)=0的解出发的解路径，最终得到 F(x)=0的解。模型配方：利用同伦连续性，将困难问题转化为简单问题的连续变形。

算法/模型/方法名称​

同伦延拓法求解多项式方程组

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：求解多项式方程组 F(x)=0，其中 F:Cn→Cn。
步骤1：构造起始系统。选择一个易于求解的多项式系统 G(x)=0，其解已知且数量等于目标系统的贝佐数（总解数，考虑重数）。常用起始系统如：Gi​(x)=xidi​​−1=0，其中 di​是 Fi​的总次数。
步骤2：构造同伦。定义同伦映射：
H(x,t)=(1−t)G(x)+γtF(x)
其中 γ∈C是一个随机复数，用于避免路径奇异性。当 t=0时，H(x,0)=G(x)；当 t=1时，H(x,1)=γF(x)，与 F(x)=0同解。
步骤3：路径跟踪。对起始系统的每个解 x(0)，从 t=0开始，将 t从0逐步增加到1，同时数值求解 H(x,t)=0。这通常通过预测-校正法实现：
- 预测步：用切向量方向预测下一步的值。对同伦方程微分：
∂x∂H​x˙+∂t∂H​t˙=0
给定步长 Δt，计算 x˙=−(∂x∂H​)−1∂t∂H​，然后预测 xpred​=x+x˙Δt。
- 校正步：以 xpred​为初值，用牛顿法求解 H(x,t+Δt)=0，得到校正后的解。
步骤4：收集终点。当 t=1时，路径跟踪结束，得到 F(x)=0的一个近似解。对所有起始解进行跟踪，收集所有终点。
步骤5：验证。将得到的解代入 F(x)=0验证，并可能用牛顿法精化。

精度/密度/误差/强度​

精度：数值方法，精度取决于路径跟踪的容差和浮点误差，但可通过精化达到高精度。
强度：可求得多项式系统的全部孤立解（在复数域中），适用于中等规模问题。
误差：路径跟踪可能失败（如路径发散、分叉），数值误差累积。

底层规律/理论定理​

同伦连续性：在适当条件下，解路径是 t的光滑曲线。
贝佐定理：多项式方程组在复射影空间中的解个数（重数计）等于各多项式次数的乘积。
路径跟踪的数值分析：预测-校正法、自适应步长控制。

典型应用场景​

1. 密码代数方程求解：求解多变量多项式方程组，用于密码分析。
2. 机器人运动学：求解逆运动学方程的所有解。
3. 计算机视觉：多视角几何中的多项式求解。
4. 化学平衡计算：求解反应方程组。
5. 经济学均衡计算：求解市场均衡方程。

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

- F(x)=0：目标多项式方程组。
- G(x)=0：起始方程组，易于求解。
- H(x,t)：同伦映射。
- γ：随机复数，用于扰动。
- x(0)：起始系统的解。
- 路径：参数曲线 (x(t),t)满足 H(x(t),t)=0。

状态机​

S0​: 构造起始系统 G和同伦 H； S1​: 求解 G(x)=0得所有起始解； S2​: 对每个起始解，初始化 t=0； S3​: 路径跟踪：预测步、校正步，更新 t和 x； S4​: 若 t=1，则记录终点解；否则继续跟踪； S5​: 收集所有终点解，验证。

数学特征​

- 代数拓扑：同伦、连续变形。
- 数值分析：常微分方程数值解、预测-校正、牛顿法。
- 复代数几何：贝佐数、射影空间。
- 线性代数：求解线性系统（雅可比矩阵）。

语言特征​

术语：“同伦延拓”、“起始系统”、“路径跟踪”、“预测-校正”、“贝佐数”。句式多为描述连续变形和数值跟踪过程。

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

阶段1：准备工作
1. 给定目标系统 F(x)=0, x∈Cn。
2. 构造起始系统 G(x)=0，例如 Gi​(x)=xidi​​−1，其中 di​=deg(Fi​)。
3. 随机选择复数 γ，构造同伦 H(x,t)=(1−t)G(x)+γtF(x)。
阶段2：求解起始系统
4. 求解 G(x)=0，得到所有 D=∏di​个解（易求，因已分解）。
阶段3：路径跟踪
5. 对每个起始解 x(0)：
a. 设置 t=0， x=x(0)。
b. While​ t<1：
i. 选择步长 Δt（自适应）。
ii. 计算预测方向：求解线性系统 JH​(x,t)⋅v=−∂t∂H​，其中 JH​=∂x∂H​是雅可比矩阵。得到 v=x˙。
iii. 预测： xpred​=x+vΔt， tnew​=t+Δt。
iv. 校正：以 xpred​为初值，用牛顿法求解 H(x,tnew​)=0，得到校正解 xcorr​。
v. 更新： x=xcorr​， t=tnew​。
c. 当 t=1时，记录 x作为目标系统的一个近似解。
阶段4：后处理
6. 对得到的近似解，可用牛顿法精化以提高精度。
7. 去除重复解（在容差内）。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：每个路径跟踪是顺序的。
并行序列：不同起始解的路径跟踪可完全并行。

复杂度​

时间：与解的数量和跟踪复杂度有关，最坏为解数量的多项式倍。路径跟踪每次迭代需解线性系统，O(n3)。
空间：存储所有解和路径跟踪的中间状态。

编号​

Attack-A0-0014

类别​

拓扑代数攻击 / 持续同调分析时间序列

模型配方​

对时间序列数据（如网络流量）构建过滤复形，计算其持续同调（条形码），以捕获多尺度拓扑特征用于异常检测。模型配方：给定时间序列 {pt​}t=1T​⊂Rd，构造其点云的 Rips 复形滤 {Kϵ​}ϵ≥0​，计算其同调群 Hk​(Kϵ​)的持续模结构，得到 k 维同调类的出生半径 ϵb​和死亡半径 ϵd​，表示拓扑特征（如连通分支、孔洞）的持续区间。异常行为可能导致持续区间的分布变化。

算法/模型/方法名称​

基于持续同调的时间序列异常检测

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：从时间序列的拓扑特征中检测异常。
步骤1：时间序列嵌入。将一维时间序列 yt​嵌入到高维空间，常用延迟嵌入：对每个 t，构造向量 pt​=(yt​,yt+1​,...,yt+m−1​)，其中 m是嵌入维数。得到点云 P={pt​}t=1T−m+1​⊂Rm。
步骤2：构建 Rips 复形滤。对每个尺度参数 ϵ≥0，构造 Rips 复形 Kϵ​：其 k-单形由 k+1 个两两距离不超过 ϵ的点构成。随着 ϵ增加，得到滤 Kϵ1​​⊂Kϵ2​​⊂...⊂KϵN​​。
步骤3：计算持续同调。对每个维度 k（通常 k=0,1），计算同调群 Hk​(Kϵ​)随着 ϵ变化的持续模。算法上，通过计算边界矩阵的 Smith 标准形或更高效的持久性算法，得到持续区间（条形码）集合 Bk​={(bi​,di​)}，其中 bi​是出生半径，di​是死亡半径。
步骤4：提取拓扑特征。从条形码中提取特征，如：
- 持续区间的长度 li​=di​−bi​。
- 每个维度的持续区间数量。
- 持续区间的统计量（均值、方差、中位数等）。
步骤5：异常检测。对正常时间序列，计算其条形码特征的分布。对新时间序列窗口，计算其特征，若偏离正常分布（如马哈拉诺比斯距离超过阈值），则判为异常。
步骤6：可视化。条形码图或持续图（persistence diagram）可用于直观分析。

精度/密度/误差/强度​

精度：依赖于嵌入参数和特征选择，能捕捉传统方法不易发现的拓扑异常。
强度：对数据的几何和拓扑结构敏感，尤其适合检测周期性和循环结构的变化。
误差：计算是精确的，但特征提取可能丢失信息。

底层规律/理论定理​

持续同调理论：将同调与滤结合，得到拓扑特征的持续性质。
拓扑数据分析：用拓扑方法研究数据形状。
Takens嵌入定理：在适当条件下，延迟嵌入可重构动力系统的相空间。

典型应用场景​

1. 网络流量异常检测：DDoS 攻击可能导致流量时间序列的拓扑特征变化。
2. 心电图（ECG）异常检测：心律失常会导致心电信号拓扑结构变化。
3. 传感器网络故障检测：传感器读数时间序列的拓扑变化指示故障。
4. 金融时间序列分析：市场震荡可能导致拓扑特征突变。
5. 语音信号处理：检测语音中的异常片段。

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

- yt​：原始时间序列，t=1,...,T。
- m：嵌入维数。
- τ：延迟步长（常取1）。
- P：嵌入后的点云。
- ϵ：Rips 复形的尺度参数。
- Kϵ​：尺度 ϵ下的 Rips 复形。
- Bk​：k 维持续区间（条形码）集合。
- 特征向量：从条形码提取的统计特征。

状态机​

S0​: 输入时间序列； S1​: 延迟嵌入得点云 P； S2​: 构建 Rips 滤； S3​: 计算持续同调，得条形码； S4​: 提取特征向量； S5​: 与正常特征分布比较，计算异常得分； S6​: 判定异常。

数学特征​

- 代数拓扑：单纯复形、同调群、持续同调。
- 动力系统：时间序列嵌入。
- 统计：特征提取、假设检验。
- 计算拓扑：持续同调算法。

语言特征​

术语：“持续同调”、“条形码”、“Rips 复形”、“滤”、“出生”、“死亡”、“拓扑特征”。句式多为描述拓扑构造和特征提取。

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

阶段1：数据预处理
1. 给定时间序列 y1​,y2​,...,yT​。
2. 选择嵌入维数 m和延迟 τ（通常 τ=1）。
3. 构造点云：对 t=1到 T−(m−1)τ，构造点 pt​=(yt​,yt+τ​,...,yt+(m−1)τ​)∈Rm。得到点云 P={pt​}t=1T′​，其中 T′=T−(m−1)τ。
阶段2：构建 Rips 复形滤
4. 选择一组增长的尺度参数 ϵ1​<ϵ2​<...<ϵL​，覆盖从0到点云直径的范围。
5. 对每个尺度 ϵk​，构建 Rips 复形 Kϵk​​：
- 顶点：点云中的每个点 pt​。
- 边：连接两点 pi​,pj​如果它们的欧氏距离 d(pi​,pj​)≤ϵk​。
- 高阶单形：如果所有边的距离条件满足，则添加三角形、四面体等。
6. 得到滤：Kϵ1​​⊂Kϵ2​​⊂...⊂KϵL​​。
阶段3：计算持续同调
7. 对每个维度 k（通常 k=0,1），计算持续同调。使用矩阵约简算法（如标准的 persistent homology 算法）：
a. 将滤中单形的出现顺序列出，得到过滤序。
b. 构造边界矩阵 D，行和列按过滤序排列。
c. 对 D进行列约简，得到简约矩阵 R。
d. 从 R中读取持续区间：如果列 j的 pivot 行为 i，且 i对应单形出现尺度为 b，j对应单形出现尺度为 d，则有一个持续区间 (b,d)，表示一个 k 维拓扑特征在尺度 b出生，在尺度 d死亡。
8. 收集所有 k 维持续区间，得到条形码 Bk​={(bi​,di​)}。
阶段4：特征提取
9. 从条形码中提取特征向量。例如，对于 k=0 和 k=1：
- 持续区间的个数。
- 持续长度的平均值、方差、最大值、最小值。
- 持续长度的直方图（分箱统计）。
- 出生尺度的统计量。
- 死亡尺度的统计量。
设提取的特征向量为 v∈Rf。
阶段5：异常检测
10. 训练阶段：使用历史正常时间序列数据，计算其特征向量，建立正常特征分布模型（例如，多元高斯分布，或使用一类SVM）。
11. 检测阶段：对新时间序列窗口，重复阶段1-4，得到其特征向量 vnew​。计算其与正常分布的偏离程度（如马哈拉诺比斯距离，或一类SVM的决策函数值）。若偏离超过阈值，则判为异常。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：时间序列数据本身是顺序的。Rips 复形的构建和持续同调计算通常按尺度顺序进行，但内部算法可并行化。
并行序列：对不同尺度或不同维度的同调计算可并行。特征提取的统计计算可并行。
随机序列：在构建 Rips 复形时，可以使用近似方法（如稀疏 Rips 复形）随机采样边，以降低计算复杂度。

复杂度​

时间：构建 Rips 复形需要计算所有点对距离，O((T′)2)。持续同调的计算最坏复杂度是单形数量的立方，但实际中由于稀疏性，可接受。特征提取复杂度较低。
空间：存储点云距离矩阵 O((T′)2)，但可通过稀疏表示减少。存储边界矩阵与单形列表，与复形大小成正比。
数据：需要足够长的时间序列以进行有效嵌入。

编号​

Attack-A0-0015

类别​

几何代数攻击 / 共形几何代数恶意软件行为轨迹聚类

模型配方​

将恶意软件在系统调用层面的行为序列（如API调用序列、文件操作序列）映射到共形几何代数（CGA）空间 G4,1​中的点序列，形成一条几何轨迹。在CGA空间中，利用几何积（Geometric Product）定义的旋转、平移和距离度量，计算不同恶意软件行为轨迹之间的相似性。通过聚类算法（如k-means、层次聚类）对轨迹进行分组，从而识别同一家族的恶意软件或新型变种。模型配方：将行为序列 {s1​,s2​,...,sL​}通过嵌入函数 Φ映射为CGA点序列 {Φ(s1​),...,Φ(sL​)}，然后通过CGA空间中的几何运算计算轨迹间距离，最后聚类。

算法/模型/方法名称​

基于CGA轨迹相似性的恶意软件聚类

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：计算两条行为轨迹 TA​和 TB​在CGA空间中的相似性度量，并用于聚类分析。
步骤1：行为序列向量化。将每个系统调用或行为事件 si​映射为一个特征向量 vi​∈Rd。例如，使用词嵌入（如Word2Vec）或手动定义的特征（如调用类别、目标对象、时间戳）。
步骤2：CGA空间嵌入。将每个特征向量 vi​嵌入到共形几何代数空间 G4,1​中，表示为 null vector（零向量）。标准嵌入公式为：
Xi​=vi​+21​vi2​e∞​+e0​
其中 e0​,e∞​是表示原点和无穷远点的基向量，满足 e02​=e∞2​=0,e0​⋅e∞​=−1。这里 vi2​是欧几里得范数平方。
步骤3：轨迹表示为多重向量。一条长度为 L的轨迹可以视为CGA空间中的点序列。我们可以用这些点拟合一个几何对象，如直线或平面，或者更一般地，用CGA中的k-向量（blade）来表示轨迹的整体方向或形状。一种简单方法是用序列中所有点的几何平均值（重心）和协方差结构来近似。另一种方法是使用CGA中的“刚体运动”来表示从一个点到下一个点的变换。
步骤4：计算轨迹相似性。定义两条轨迹 TA​={X1A​,...,XLA​A​}, TB​={X1B​,...,XLB​B​}的相似性。方法包括：
- 动态时间规整（DTW）距离：在CGA空间中计算点对之间的欧氏距离（通过CGA内积计算点间距离：dij​=(XiA​−XjB​)2​），然后应用DTW算法对齐轨迹并计算最小累积距离。
- 基于几何积的变换匹配：将每条轨迹视为由一系列CGA旋量（rotor）Rk​生成，这些旋量描述了点之间的刚体运动（Xk+1​=Rk​Xk​Rk​~​，其中 Rk​~​是逆）。比较两条轨迹的旋量序列的相似性（例如，通过比较旋量对应的旋转轴和角度）。
步骤5：聚类分析。使用步骤4计算的相似性矩阵，应用聚类算法（如层次聚类、谱聚类或k-means的变体）将恶意软件样本分组。

底层规律/理论定理​

共形几何代数：提供统一框架表示欧氏几何中的点、方向、平面、球体及刚体运动。旋量（Rotor）能优雅地表示旋转和平移的组合。
动态时间规整：一种时间序列对齐算法，允许序列在时间轴上的非线性伸缩，以找到最佳匹配。
表示学习：将离散行为事件映射到连续向量空间，捕捉语义相似性。

典型应用场景​

1. 恶意软件家族分类：对大量未知恶意软件样本进行自动化分类，归入已知家族或发现新家族。
2. 变种恶意软件检测：检测经过混淆、加壳或代码微小修改的恶意软件变种，其核心行为轨迹相似。
3. 入侵检测系统：对进程行为序列进行实时监控和聚类，发现偏离正常集群的异常进程（可能是新型攻击）。
4. 威胁狩猎：在大量端点数据中，通过行为轨迹聚类快速识别具有相似攻击模式的威胁活动组（Campaign）。
5. 沙箱分析结果增强：对沙箱生成的系统调用序列进行深度分析，补充基于静态签名的检测。

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

- si​： 第i个系统调用或行为事件。
- vi​∈Rd： 行为事件的特征向量表示。
- Xi​∈G4,1​： 嵌入CGA空间后的点（null vector）。
- e0​,e∞​： CGA的基向量，表示原点和无穷远点。
- TA​,TB​： 两条行为轨迹，为CGA点的序列。
- Rk​： 连接轨迹中相邻点的CGA旋量（Rotor），表示刚体运动。
- dij​： CGA空间中两点间的距离。
- D(TA​,TB​)： 两条轨迹间的最终相似性/距离度量。

状态机​

S0​: 输入恶意软件样本集合； S1​: 动态分析/沙箱执行，提取系统调用序列； S2​: 将每个系统调用转化为特征向量 vi​； S3​: 将每个特征向量嵌入CGA空间得 Xi​，形成轨迹； S4​: 计算所有轨迹两两之间的相似性/距离矩阵 M； S5​: 基于距离矩阵 M运行聚类算法； S6​: 输出聚类结果（家族标签或异常标志）。

数学特征​

- 几何代数：核心是克利福德代数 Cl4,1​，使用几何积、外积、内积。
- 线性代数：向量空间、特征值分解（用于旋量提取）。
- 微分几何：轨迹被视为流形上的曲线。
- 优化：动态时间规整是一个优化对齐问题。
- 组合数学：序列比对。
- 群论：旋量构成 Spin 群。

语言特征​

术语：“共形几何代数”、“null vector”、“旋量”、“刚体运动”、“几何积”、“轨迹对齐”、“动态时间规整”。句式多为描述几何表示和相似性计算过程。

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

阶段1：数据提取
1. 在受控环境（沙箱）中运行每个恶意软件样本，记录其产生的系统调用序列 S=[s1​,s2​,...,sL​]。
阶段2：特征化与嵌入
2. 对每个系统调用 si​，通过查找表或神经网络映射到特征向量 vi​。
3. 对每个 vi​，计算其CGA嵌入： Xi​=vi​+21​vi2​e∞​+e0​。得到轨迹 T=[X1​,X2​,...,XL​]。
阶段3：轨迹相似性计算（以DTW为例）
4. 对于两条轨迹 TA​和 TB​，构造距离矩阵 D，其中 Dij​=(XiA​−XjB​)2​。在CGA中，点差平方可通过内积计算：(X−Y)2=(X−Y)⋅(X−Y)。
5. 应用动态时间规整算法：
a. 初始化累积距离矩阵 C，大小为 (LA​+1)×(LB​+1)，其中 C0,0​=0， Ci,0​=C0,j​=∞。
b. 递归填充： Ci,j​=Dij​+min(Ci−1,j​,Ci,j−1​,Ci−1,j−1​)。
c. 最终轨迹间距离为 DDTW​(TA​,TB​)=CLA​,LB​​。
阶段4：聚类
6. 为所有N个样本计算成对的 DDTW​距离，形成距离矩阵 M。
7. 将 M输入给层次聚类（如平均链接）或谱聚类算法，得到K个簇。
阶段5：分析与标注
8. 检查每个簇中样本的其他属性（如可打印字符串、导入函数、网络行为），为簇赋予家族标签或标记为“未知新家族”。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：系统调用序列是时序的。DTW算法本质是顺序的。
并行序列：不同样本的轨迹相似性计算可完全并行。聚类算法的部分步骤也可并行。

复杂度​

时间：DTW计算复杂度为 O(LA​LB​)，对N个样本两两计算为 O(N2L2)，其中 L为平均序列长度。CGA嵌入和距离计算为 O(d)，其中 d是CGA空间维度（32）。
空间：存储所有轨迹的CGA点序列， O(NLd)。距离矩阵 O(N2)。

编号​

Attack-A0-0016

类别​

几何代数攻击 / 几何代数表示神经网络对抗样本

模型配方​

将神经网络的输入（如图像像素、特征向量）用几何代数（例如，基于 Cl3,0​或 Cl0,3​）中的多重向量（multivector）表示。对抗扰动被建模为施加在该多重向量上的微小几何变换（如旋转、缩放、剪切），这些变换在几何代数框架下可以统一表示。攻击目标是寻找一个几何扰动（表示为旋量Rotor或Versor），使得扰动后的多重向量被目标模型错误分类，同时扰动在某种几何范数下尽可能小。模型配方：设输入为多重向量 X，模型为 f，寻找扰动旋量 R（接近单位旋量），使得 f(RXR~)=f(X)，其中 R~是 R的逆（或反转）。

算法/模型/方法名称​

基于几何代数的对抗样本生成（GAAttack）

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：对给定的输入多重向量 X和目标模型 f，生成一个对抗性多重向量 X′，使得 f(X′)=f(X)且 (

底层规律/理论定理​

几何代数：旋量（Rotor）是描述旋转和缩放的优雅数学工具，满足 RR~=1。
李群与李代数：旋量群是李群，其生成元（2-向量）构成李代数。
对抗性机器学习：探索模型决策边界在输入空间的几何结构。

典型应用场景​

1. 图像分类模型的物理对抗攻击：生成在几何变换（如旋转、视角变化）下保持对抗性的扰动。
2. 点云分类攻击：点云数据天然适合用几何代数表示，攻击可针对3D物体识别模型。
3. 强化学习策略攻击：对智能体观察的状态（可表示为几何对象）施加几何扰动，诱导其做出错误决策。
4. 自动驾驶感知系统攻击：对摄像头输入的图像或激光雷达点云施加几何一致的对抗扰动，导致错误检测。
5. 生物特征识别攻击：对指纹或人脸特征模板施加几何扰动，绕过识别。

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

- X： 输入的多重向量表示。
- R： 单位旋量，表示几何扰动。
- R~： 旋量 R的逆（反转）。
- B： 单位2-向量，表示旋转平面（如 e1​e2​）。
- θ： 旋转角度（或缩放因子）。
- f： 目标神经网络模型。
- L： 损失函数（如交叉熵）。
- λ： 扰动大小惩罚系数。

状态机​

S0​: 输入干净样本 X和目标模型 f； S1​: 将 X转换为多重向量表示； S2​: 初始化旋量参数 B,θ（小随机值）； S3​: 构建旋量 R=exp(−θB/2)； S4​: 计算对抗样本 X′=RXR~； S5​: 计算损失 (L = \mathcal{L}(f(X'), y) + \lambda

数学特征​

- 几何代数：核心是旋量计算、几何积、指数映射。
- 微分几何：在流形（旋量群）上优化。
- 优化：带约束的梯度下降。
- 表示论：数据在几何代数下的表示。

语言特征​

术语：“多重向量”、“旋量”、“几何积”、“2-向量”、“旋转平面”、“指数映射”、“几何扰动”。句式多为描述几何变换和优化过程。

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

阶段1：表示转换
1. 输入：干净图像 I∈RH×W×3。
2. 对每个像素位置 (h,w)，构造向量 vhw​=re1​+ge2​+be3​∈R3。可以展平或将整个图像视为一个大向量（但计算量大）。更实际的做法是，将图像视为在空间维度上具有 Cl3,0​代数结构的场。
阶段2：初始化与迭代优化
3. 初始化扰动旋量参数：选择单位2-向量 B（如随机生成后归一化），设置初始小角度 θ0​，学习率 η，最大迭代次数 T。
4. For​ t=0to T−1：
a. 构造当前旋量： Rt​=exp(−θt​Bt​/2)。对于小角度，可以用一阶近似。
b. 对输入多重向量场的每个“像素” v施加扰动： v′=Rt​vRt​~​。这可以通过几何代数库并行计算。
c. 将扰动后的多重向量场 V′转换回标准张量格式 I′，输入模型得到预测和损失 Lcls​。
d. 计算总损失： (L = \mathcal{L}_{cls} + \lambda

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：优化迭代是顺序的。
并行序列：对输入场中每个元素（像素）的旋量变换可并行计算。

复杂度​

时间：每次迭代需要计算几何积和旋量指数，复杂度取决于输入大小和代数维度。对于 Cl3,0​，几何积是 O(1)常数操作，但需对每个输入元素进行。因此每次迭代复杂度约为 O(N)，其中 N是输入元素总数。
空间：需要存储中间的多重向量表示和旋量。

编号​

Attack-A0-0017

类别​

群论攻击 / 置换群密码的轨道攻击

模型配方​

若密码算法的状态空间在某个群 G的作用下具有非平凡的不动点集或轨道结构，则可能利用此结构简化攻击。具体地，设密码算法作用于状态空间 X，且存在一个群 G（如对称群、置换群、线性群）作用于 X，使得算法在某种意义上与 G作用“交换”或轨道易于分析。攻击者可以计算 G在 X上的轨道，然后对每个轨道的代表元进行穷举或简化分析，从而将整个攻击的复杂度从 (

算法/模型/方法名称​

基于群轨道的分治攻击

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：利用状态空间在群作用下的轨道分解，将全局搜索问题简化为在每个轨道上的局部搜索问题。
步骤1：识别对称群。分析密码算法，识别其状态空间 X上存在的一个对称群 G。例如，若算法的某些操作是位置无关的，或对输入字节的顺序置换具有不变性，则 G可能是置换群 Sn​。更形式化地，寻找一个群 G和同态 ϕ:G→Sym(X)，使得对于所有 g∈G和 x∈X，有 f(ϕ(g)(x))=ϕ(g′)(f(x))对某个 g′∈G成立（即 f与 G作用“交换”）。
步骤2：计算轨道。群 G作用在 X上，将 X划分为不相交的轨道：X=⋃i​Oi​，其中轨道 Oi​={g⋅xi​∣g∈G}，xi​是轨道的代表元。每个轨道的大小为 (

精度/密度/误差/强度​

精度：如果对称性识别正确，攻击是精确的。
强度：攻击复杂度从 (

底层规律/理论定理​

群作用与轨道分解：群作用将集合划分为轨道，轨道内的元素通过群元素相互关联。
轨道-稳定子定理：(

典型应用场景​

1. 对称密码的弱密钥分析：某些分组密码（如DES）存在弱密钥，其自加密或自解密性质与密钥的某种对称性相关。
2. 哈希函数的固定点攻击：寻找使 H(x)=x的 x，可以利用 H的某种对称性（如对输入分块的置换不变性）来缩小搜索空间。
3. 基于格的密码分析：格问题通常具有旋转对称性，可利用点群约化搜索。
4. 码本模式（ECB）的分析：当明文块存在大量重复时，密文块相同，这可以视为一种对称性，可用于数据压缩或模式识别攻击。
5. 侧信道分析中的模板分类：能量迹特征可能对时间的循环移位具有某种不变性，可利用循环群约化模板数量。

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

- X： 状态空间（如明文空间、密文空间、密钥空间）。
- G： 作用于 X的群（如置换群、循环群）。
- ϕ:G→Sym(X)： 群作用（同态）。
- Oi​： 第 i个轨道。
- xi​： 轨道 Oi​的代表元。
- StabG​(x)： 元素 x的稳定子群，即 {g∈G∣g⋅x=x}。
- f： 密码算法或目标函数。

状态机​

S0​: 分析算法，识别潜在的对称群 G； S1​: 计算群 G在状态空间 X上的轨道分解，得到代表元集合 {xi​}； S2​: 对每个轨道代表元 xi​执行核心攻击（例如，尝试密钥恢复）； S3​: 将代表元上的攻击结果，利用群作用推广到整个轨道 Oi​； S4​: 聚合所有轨道结果，输出最终攻击结果。

数学特征​

- 群论：群作用、轨道、稳定子、商空间。
- 抽象代数：同态、对称性。
- 组合数学：集合的划分。
- 表示论：群的线性表示可能相关。

语言特征​

术语：“群作用”、“轨道”、“代表元”、“稳定子群”、“对称性”、“轨道分解”。句式多为描述利用对称性进行约化的过程。

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

阶段1：对称性分析
1. 假设发现算法 E:K×X→X对输入的字节顺序置换具有不变性。即存在置换群 G=Sn​作用在 X={0,1}8n上（通过置换字节位置），使得对于任意 g∈G,k∈K,x∈X，有 Ek​(g⋅x)=g⋅Ek′​(x)，其中 k′是密钥 k经过相应置换后的结果。
阶段2：轨道分解
2. 计算 G在 X上的轨道。例如，如果 X是所有长度为 n的字节序列，则轨道由序列中字节值的多重集（直方图）决定。两个序列在同一轨道当且仅当它们是彼此的排列。因此，轨道代表元可以选择为按字节值排序的序列。
3. 设 R是所有按非递减顺序排列的字节序列的集合，它是每个轨道的一个代表元集。
阶段3：在代表元上执行攻击
4. 攻击目标：恢复密钥 k。攻击者选择一个代表元 x∈R。
5. 对 x执行攻击（例如，已知明文攻击），尝试恢复密钥。由于对称性，如果对 x恢复出的密钥是 kx​，那么对于同一轨道中的任何 g⋅x，对应的密钥将是 g⋅kx​（密钥编排也需相应置换）。
阶段4：结果验证与推广
6. 用另一对明密文验证恢复的密钥 kx​是否正确。如果正确，则攻击成功，且可以推导出对于任何在 g⋅x轨道中的明文，有效密钥为 g⋅kx​。
7. 如果攻击失败，尝试另一个轨道的代表元。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：轨道分解和代表元攻击可以是顺序的。
并行序列：对不同轨道代表元的攻击可完全并行。

复杂度​

时间：轨道分解的复杂度取决于群 G和集合 X的大小。攻击复杂度从 (O(

编号​

Attack-A0-0018

类别​

群论 / 线性反馈移位寄存器本原多项式检测

模型配方​

线性反馈移位寄存器（LFSR）生成的序列周期最大（2n−1）当且仅当其反馈多项式 f(x)是 n 次本原多项式。攻击模型旨在检测给定多项式 f(x)∈GF(2)[x]是否为本原多项式，以评估其用作密钥流生成器的强度。本原多项式的检测涉及数论和有限域理论：需要验证 f(x)是不可约的，并且 x在乘法群 GF(2n)∗≅GF(2)[x]/⟨f(x)⟩中的阶为 2n−1。

算法/模型/方法名称​

本原多项式检测算法

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：判定 n 次多项式 f(x)∈GF(2)[x]是否为本原多项式。
步骤1：检查不可约性。首先，f(x)必须是不可约的。可以使用 Rabin 不可约性测试：多项式 f(x)在 GF(2)上不可约当且仅当
gcd(f(x),x2i−x)=1for i=1,2,...,⌊n/2⌋
并且 f(x)整除 x2n−x。
步骤2：计算多项式阶。若 f(x)不可约，则它定义了一个有限域 GF(2n)≅GF(2)[x]/⟨f(x)⟩。多项式 f(x)的阶定义为使得 f(x)整除 xm−1的最小正整数 m。这等价于域中元素 x（即 xmodf(x)）的乘法阶。
步骤3：验证阶为 2n−1。由于 GF(2n)∗是阶为 2n−1的循环群，x的阶必须整除 2n−1。要验证其阶恰好为 2n−1，需要检查：
x(2n−1)/p≡1(modf(x))
对 2n−1的所有素因子 p都成立。这意味着 x的阶不被任何真因子除尽。
步骤4：结论。如果步骤1和3都通过，则 f(x)是本原多项式。否则，它不是。

精度/密度/误差/强度​

精度：算法是确定性的，精度100%。
强度：这是对LFSR序列周期性的直接评估。使用非本原多项式会缩短密钥流周期，从而降低安全性。
复杂度：需要分解 2n−1，这在 n 很大时是困难的。但攻击者通常针对已知或猜测的 n 进行。

底层规律/理论定理​

有限域理论：GF(2n)的乘法群是循环群，阶为 2n−1。本原多项式对应于本原元（生成元）的极小多项式。
数论：整数的素因子分解，欧拉定理。

典型应用场景​

1. 流密码评估：评估如 A5/1, E0 等流密码中使用的 LFSR 反馈多项式的强度。
2. 伪随机数生成器（PRNG）设计审计：检查自定义或开源 PRNG 中使用的 LFSR 多项式是否本原。
3. 硬件安全模块（HSM）测试：验证 HSM 中用于密钥生成的内部 LFSR 配置。
4. 通信系统：评估用于扰码或同步的 LFSR 的安全性。
5. 密码学教学与标准符合性测试：验证算法实现是否使用了标准推荐的本原多项式。

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

- f(x)： 待检测的多项式，次数为 n，系数在 GF(2)中。
- n： 多项式次数。
- GF(2n)： 包含 2n个元素的有限域。
- p： 整数 2n−1的素因子。
- 阶： 使得 xm≡1modf(x)的最小正整数 m。

状态机​

S0​: 输入多项式 f(x)和次数 n； S1​: 检查 f(x)是否不可约（Rabin测试）；如果可约，输出“非本原”并结束； S2​: 计算 M=2n−1，并找到其所有素因子 p1​,...,pk​； S3​: 对每个素因子 pi​，计算 ri​=xM/pi​modf(x)； S4​: 如果所有 ri​≡1modf(x)，则 f(x)本原；否则非本原。

数学特征​

- 抽象代数/有限域：核心是域扩张、本原元、极小多项式。
- 数论：整数分解、模幂运算。
- 多项式环：多项式运算、不可约性、同余。

语言特征​

术语：“本原多项式”、“不可约”、“阶”、“有限域”、“本原元”、“素因子”。句式多为条件检查和模幂计算。

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

阶段1：不可约性测试
1. 输入：f(x)=xn+an−1​xn−1+...+a0​，其中 ai​∈{0,1}。
2. 使用 Rabin 算法：
a. 计算 g1​(x)=gcd(f(x),x)。如果 g1​(x)=1，则 f可约（有因子 x）。
b. For​ i=1to ⌊n/2⌋：
i. 计算 hi​(x)=x2imodf(x)（通过快速模幂）。
ii. 计算 gi​(x)=gcd(f(x),hi​(x)−x)。
iii. 如果 gi​(x)=1，则 f可约，算法终止。
c. 计算 hn​(x)=x2nmodf(x)。
d. 如果 hn​(x)≡xmodf(x)，则 f不可约；否则可约。
阶段2：计算 2n−1的素因子分解
3. 对 M=2n−1进行整数分解，得到素因子列表 p1​,...,pk​。这是一个计算困难步骤，但对于中等 n（如 n<200）可行。
阶段3：验证阶
4. 在多项式环 GF(2)[x]中，计算 xMmodf(x)。结果应为 1（因为有限域乘法群阶为 M）。
5. 对每个素因子 pi​：
a. 计算 bi​=M/pi​。
b. 计算 ri​(x)=xbi​modf(x)。
c. 如果 ri​(x)≡1modf(x)，则 x的阶整除 bi​，因此小于 M，故 f非本原。算法终止。
阶段4：输出
6. 如果通过了所有 pi​的检查，则输出“f(x)是本原多项式”。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：Rabin测试的循环是顺序的。素因子检查可顺序或并行。
并行序列：对不同素因子 pi​的检查可并行。

复杂度​

时间：Rabin测试的复杂度约为 O(n3)（使用快速多项式乘法和取模）。计算 xMmodf(x)的复杂度为 O(n3logM)。整数分解 M的复杂度是瓶颈，对于大 n是指数级的。
空间：存储多项式中间结果，O(n2)。

编号​

Attack-A0-0019

类别​

群论攻击 / 椭圆曲线离散对数的Pollard Rho攻击

模型配方​

在椭圆曲线点构成的循环群 G=⟨P⟩中求解离散对数问题：给定点 Q∈G，求整数 d使得 Q=dP。Pollard Rho 算法通过定义伪随机游走 Ri+1​=f(Ri​)在群 G上，利用 Floyd 判圈算法寻找碰撞 Ri​=Rj​。由于游走是确定性的，碰撞意味着 ai​P+bi​Q=aj​P+bj​Q，从而可解出 d=(ai​−aj​)(bj​−bi​)−1modn，其中 (n =

算法/模型/方法名称​

Pollard's Rho Algorithm for ECDLP

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：在椭圆曲线群 G=⟨P⟩中，给定 Q，求解 d=logP​Q。
步骤1：定义划分与迭代函数。将群 G划分为三个大小近似相等的集合 S1​,S2​,S3​（例如，基于点的 x 坐标模 3）。定义迭代函数 f:G→G：
f(R)=⎩⎨⎧​R+P2RR+Q​if R∈S1​if R∈S2​if R∈S3​​
同时，我们需要跟踪系数 (a,b)使得 R=aP+bQ。因此，我们也更新系数：
(ai+1​,bi+1​)=⎩⎨⎧​(ai​+1,bi​)(2ai​,2bi​)modn(ai​,bi​+1)​if Ri​∈S1​if Ri​∈S2​if Ri​∈S3​​
步骤2：Floyd 判圈算法。初始化两个序列：(R0​,a0​,b0​)=(O,0,0)（但 O是无穷远点，不常用）或随机起点。更常用的是随机化起点。但 Floyd 算法通常从同一点开始两个指针：慢指针 (X,a,b)和快指针 (X′,a′,b′)，初始相同。然后迭代：慢指针走一步，快指针走两步，直到它们相等：
(X,a,b):=f(X,a,b)
(X′,a′,b′):=f(f(X′,a′,b′))
步骤3：检测碰撞。当 X=X′时发生碰撞。此时有：
aP+bQ=a′P+b′Q
即 (a−a′)P=(b′−b)Q=(b′−b)dP。
步骤4：求解离散对数。如果 b′≡b(modn)，则碰撞是平凡的（不提供信息），需要重新开始。否则，计算：
d=(a−a′)(b′−b)−1modn
步骤5：验证。检查是否 dP=Q。如果成立，则找到解。

底层规律/理论定理​

生日悖论：在大小为 n的集合中随机抽样，期望在约 πn/2​≈1.253n​次抽样后发生碰撞。
Floyd 判圈算法：检测函数迭代中循环的算法。
伪随机游走：通过确定性的函数模拟随机游走，以在低内存下寻找碰撞。

典型应用场景​

1. 椭圆曲线密码分析：攻击 ECDSA、ECDH 等协议的私钥，当曲线参数选择不当时（例如，群阶 n有小的因子，可用 Pohlig-Hellman 先降阶）。
2. 加密货币安全性评估：评估比特币、以太坊等使用的椭圆曲线（如 secp256k1）的安全性。
3. 密码标准符合性测试：验证实现的椭圆曲线群是否具有声明的阶数（无小子群）。
4. 侧信道攻击的辅助：当侧信道泄露了部分密钥信息时，可用 Pollard Rho 求解剩余部分。
5. 教学与研究工作：作为理解离散对数问题难度的经典案例。

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

- P： 椭圆曲线基点，阶为 n。
- Q： 目标点，满足 Q=dP。
- d： 要解的离散对数（私钥）。
- n： 基点 P的阶（群大小）。
- S1​,S2​,S3​： 群 G的划分。
- f： 迭代函数，映射 G→G。
- (ai​,bi​)： 系数，满足 Ri​=ai​P+bi​Q。
- (X,a,b),(X′,a′,b′)： Floyd 算法中的慢指针和快指针。

状态机​

S0​: 初始化指针 (X,a,b)=(X′,a′,b′)=(O,0,0)或随机起点； S1​: 慢指针走一步：(X,a,b)=f(X,a,b)； S2​: 快指针走两步：(X′,a′,b′)=f(f(X′,a′,b′))； S3​: 检查是否 X=X′； 如果不等，回到 S1​； 如果相等，进入 S4​； S4​: 检查是否 b≡b′(modn)，若是，则发生平凡碰撞，回到 S0​重新初始化；否则计算 d=(a−a′)(b′−b)−1modn并验证。

数学特征​

- 群论：循环群、离散对数。
- 数论：模逆运算、同余方程。
- 概率论：生日悖论、随机游走。
- 算法：循环检测、时空权衡。

语言特征​

术语：“Pollard Rho”、“离散对数”、“迭代函数”、“碰撞”、“Floyd 判圈”、“平凡碰撞”。句式多为描述游走、碰撞检测和方程求解。

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

阶段1：初始化
1. 选择随机整数 a0​,b0​∈[0,n−1]，计算初始点 R0​=a0​P+b0​Q。设慢指针 (X,a,b)=(R0​,a0​,b0​)，快指针 (X′,a′,b′)=(R0​,a0​,b0​)。
阶段2：主循环
2. 重复：
a. 慢指针前进一步：根据 X的划分，计算：
i. 如果 X∈S1​: (X,a,b)=(X+P,a+1modn,b)
ii. 如果 X∈S2​: (X,a,b)=(2X,2amodn,2bmodn)
iii. 如果 X∈S3​: (X,a,b)=(X+Q,a,b+1modn)
b. 快指针前进两步：对 (X′,a′,b′)执行两次上述操作。
c. 检查碰撞：如果 X=X′，则跳出循环。
阶段3：处理碰撞
3. 碰撞时，有 aP+bQ=a′P+b′Q。
4. 如果 b≡b′(modn)，则本次尝试失败，回到阶段1用新的随机起点重新开始。
5. 否则，计算 Δa=a−a′modn， Δb=b′−bmodn。计算 Δb的模逆 (Δb)−1modn。
6. 计算候选私钥 d=Δa⋅(Δb)−1modn。
阶段4：验证
7. 计算 dP，检查是否等于 Q。如果相等，则攻击成功，输出 d。否则，可能是由于迭代函数陷入非常短的循环导致错误碰撞，回到阶段1。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：Floyd 算法是顺序迭代的。
并行序列：可以使用并行化的 Pollard Rho 变体（如 distinguished points 方法），其中多个进程独立游走，并将达到特定特征的“标志点”存入公共表以检测碰撞。

复杂度​

时间：期望运行时间为 O(n​)次群运算。
空间：基本 Floyd 算法只需要常数存储空间。但如果使用并行标志点法，需要共享存储来保存标志点。

编号​

Attack-A0-0020

类别​

群论攻击 / 陪集遍历中间相遇攻击

模型配方​

当需要搜索的密钥空间 G可以分解为两个子群 H和 K的乘积（或陪集分解）时，即 G=HK={hk∣h∈H,k∈K}，则可以将中间相遇攻击推广到群论设置。攻击目标是从 G中找到一个满足特定条件的元素 g。通过分别枚举 H和 K中的元素，计算并存储与 g相关的中间值，然后进行匹配，从而将时间复杂度从 (

算法/模型/方法名称​

陪集分解中间相遇攻击（Coset Decomposition Meet-in-the-Middle）

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：在群 G中寻找一个元素 g，使得 g满足某个条件 C(g)=true。假设 G可以分解为子群（或子集）H和 K的乘积：G=H⋅K。
步骤1：分解密钥空间。识别合适的子群分解 G=H⋅K。这可能需要分析算法结构。例如，在密码算法中，加密函数 E可能由两部分组成：E=E2​∘E1​，其中 E1​的密钥来自 H， E2​的密钥来自 K。
步骤2：前向计算与存储。对 H中的所有元素 h，计算与攻击相关的某个中间值 F(h)，并将配对 (F(h),h)存储在表 T中。F(h)的选择应使得后续能与 K中的元素产生的值进行匹配。
步骤3：后向计算与匹配。对 K中的所有元素 k，计算一个值 G(k)，使得如果 g=hk是目标元素，则 F(h)=G(k)。对于每个 k，计算 G(k)并在表 T中查找匹配的 F(h)。
步骤4：验证候选。如果找到匹配 (h,k)，则候选 g=hk（或 g=kh，取决于分解）。用额外条件验证 g是否满足 C(g)。
步骤5：处理多解。可能找到多个候选，需要进一步筛选。

精度/密度/误差/强度​

精度：如果分解正确且匹配条件完备，正确解必然会被找到。可能产生错误候选，可通过验证滤除。
强度：将复杂度从乘积 (

底层规律/理论定理​

群论：子群、陪集分解、群直积（或半直积）。
中间相遇原理：用空间换取时间，分治策略。
生日悖论（在某些变体中）。

典型应用场景​

1. 多重加密攻击：对 2DES 的经典中间相遇攻击是特例，其中 G=H×K是密钥对的笛卡尔积。
2. 某些分组密码的密钥恢复：当算法轮结构允许将密钥分为独立的两部分时。
3. 基于格的密码分析：在求解最近向量问题（CVP）时，有时可以将格基分为两部分进行枚举匹配。
4. 哈希函数的原像攻击：在 Merkle-Damgård 结构中，从消息块的两端向中间攻击。
5. 乘积密码分析：分析由两个（或多个）较弱密码组合而成的密码系统。

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

- G： 要搜索的群（密钥空间）。
- H,K： 子群（或子集），满足 G=H⋅K。
- F:H→V： 前向计算函数，映射到某个值空间 V。
- G:K→V： 后向计算函数，映射到相同的值空间 V。
- T： 存储 (F(h),h)的查找表（通常基于哈希表）。
- C(g)： 目标元素 g需要满足的条件。

状态机​

S0​: 分析问题，得到陪集分解 G=H⋅K； S1​: 初始化空表 T； S2​: 对每个 h∈H，计算 v=F(h)，存储 (v,h)于 T； S3​: 对每个 k∈K，计算 w=G(k)，在 T中查找键为 w的条目； S4​: 如果找到 (w,h)，则形成候选 g=h⋅k（或按定义组合）； S5​: 验证 C(g)是否成立，若成立则输出 g。

数学特征​

- 群论：子群、陪集、群作用。
- 算法与数据结构：哈希表、时间-空间权衡。
- 组合数学：枚举与匹配。

语言特征​

术语：“陪集分解”、“中间相遇”、“前向计算”、“后向计算”、“匹配”、“查找表”。句式多为描述分边枚举和匹配的过程。

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

阶段1：问题建模
1. 设目标：找到 g∈G使得 E(g,x)=y，其中 E是加密函数，x,y已知。
2. 假设发现 E可以分解为：存在函数 ϕ和中间状态 z，使得 E1​(h,x)=z和 E2​(k,z)=y，且 E(g,x)=E2​(k,E1​(h,x))，其中 g=h⋅k（某种组合）。那么，条件为：E1​(h,x)=E2−1​(k,y)。
阶段2：前向计算
3. 对所有 h∈H，计算 zh​=E1​(h,x)。将 (zh​,h)存入哈希表 T，以 zh​为键。
阶段3：后向计算与匹配
4. 对所有 k∈K，计算 zk′​=E2−1​(k,y)。
5. 在表 T中查找键为 zk′​的条目。
6. 如果找到，则得到候选对 (h,k)，计算候选密钥 g=h⋅k。
阶段4：验证
7. 用额外的明文-密文对 (x′,y′)验证：检查是否 E(g,x′)=y′。如果成立，则攻击成功。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：枚举 H和 K可以是顺序的，但可并行化。
分布式序列：前向和后向计算可以分布到多台机器，但需要在某处合并匹配。

复杂度​

时间：(O(

编号​

Attack-A0-0021

类别​

环论攻击 / 多项式环上理想成员判定攻击

模型配方​

在密码分析中，许多安全性条件可以表述为某个多项式 g是否属于由密码方程组生成的多项式理想 I=⟨f1​,f2​,...,fm​⟩⊂R=K[x1​,...,xn​]。如果能够判定 g∈I，则意味着从密码方程中可以推导出关系 g=0，这可能泄露密钥信息或构造区分器。模型配方：给定多项式环 R和理想 I，判定目标多项式 g是否属于 I。这可以通过计算 g相对于理想 I的Gröbner基 G的余式来实现：g∈I当且仅当 g​G=0。

算法/模型/方法名称​

理想成员判定算法（通过Gröbner基）

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：判定多项式 g是否属于理想 I=⟨f1​,...,fm​⟩。
步骤1：计算Gröbner基。为理想 I计算一个Gröbner基 G={g1​,...,gt​}，相对于某个单项式序（如字典序、分级逆字典序）。这可以使用 Buchberger 算法或 F4/F5 算法。
步骤2：多项式约简。将目标多项式 g关于Gröbner基 G进行多变量多项式除法，得到余式 r。即，重复以下过程直到无法继续：如果存在 gi​∈G使得 LT(gi​)整除 LT(r)（当前余式的首项），则用 r−LT(gi​)LT(r)​gi​替换 r。最终得到的多项式 r是唯一的，称为 g模 G的规范形式。
步骤3：判定成员关系。根据多项式理想的定义和Gröbner基的性质，有：
g∈I当且仅当g​G=0
因此，如果步骤2得到的余式 r=0，则 g∈I；否则 g∈/I。
步骤4：解释结果。如果 g∈I，则意味着在密码系统变量所满足的方程（由 I定义）下，多项式 g必然为零。这可能对应一个密钥方程或一个统计偏差（如果 g被解释为概率）。

精度/密度/误差/强度​

精度：在精确计算下（如有理数系数），判定是精确的。
强度：判定本身是可靠的，但计算Gröbner基可能非常耗时，尤其是对于从密码系统生成的大型、高次理想。
误差：在数值计算或有限精度下可能产生误判。

底层规律/理论定理​

希尔伯特基定理：多项式环上的每个理想都有有限生成集。
Gröbner基的性质：Gröbner基是理想的一组特殊生成元，使得多项式除以Gröbner基的余式是唯一的，且为零当且仅当该多项式属于理想。
理想成员问题：是计算代数几何的基本问题。

典型应用场景​

1. 密码代数攻击中的关系推导：从已知的明文-密文-密钥方程中，推导出关于密钥的新的、更简单的方程（即，证明某个密钥多项式属于原始方程生成的理想）。
2. 哈希函数的碰撞分析：试图证明两个不同消息的哈希值相等的多项式条件属于某个理想，从而构造碰撞。
3. 零知识证明系统的安全性分析：验证攻击者能否从公开信息和关系推导出秘密信息（即，秘密多项式是否属于由公开信息生成的理想）。
4. 多变量签名方案的伪造攻击：尝试找到一个消息-签名对满足验证方程，即验证多项式属于由公钥方程生成的理想。
5. 侧信道分析中的代数建模：将能量迹或时序与密钥的关系建模为多项式，判断密钥是否满足特定关系（即，判断某个测试多项式是否属于模型理想）。

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

- R=K[x1​,...,xn​]： 多项式环，系数域为 K（如 GF(2), Q)。
- I=⟨f1​,...,fm​⟩： 由多项式集合 F生成的理想。
- G={g1​,...,gt​}： 理想 I的一个Gröbner基。
- g： 待判定的目标多项式。
- r=g​G： g除以 G的余式。
- LT(p)： 多项式 p的首项（在给定的单项式序下）。

状态机​

S0​: 输入理想生成元 F={fi​}和目标多项式 g； S1​: 计算理想 I=⟨F⟩的Gröbner基 G； S2​: 用 G对 g进行约简，得到余式 r； S3​: 检查 r是否为零多项式； 如果 r=0，则输出“g∈I”；否则输出“g∈/I”。

数学特征​

- 交换代数：多项式理想、Gröbner基、商环。
- 计算代数几何：理想成员判定是核心算法问题。
- 线性代数：多项式约简过程中的系数处理。

语言特征​

术语：“理想成员判定”、“Gröbner基”、“约简”、“余式”、“规范形式”。句式多为条件判断和计算过程描述。

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

阶段1：Gröbner基计算
1. 输入生成多项式的集合 F={f1​,...,fm​}⊂R。
2. 选择单项式序（例如 graded reverse lexicographic order）。
3. 运行 Buchberger 算法或 F4 算法计算 F的Gröbner基 G。这涉及生成S-多项式并反复约简，直到所有S-多项式对约简为零。
阶段2：约简目标多项式
4. 令 r:=g。
5. While​ 存在 gi​∈G使得 LT(gi​)整除 LT(r)do：
a. 选择第一个这样的 gi​（在给定排序下）。
b. 计算商项 t=LT(r)/LT(gi​)（单项式相除）。
c. 更新余式： r:=r−t⋅gi​。
6. 最终得到的 r即为余式。
阶段3：判定与输出
7. 如果 r是零多项式，则输出“目标多项式 g属于理想 I”。
8. 否则，输出“目标多项式 g不属于理想 I”，并可输出余式 r作为证据（因为 g≡r(modI)）。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：Gröbner基计算和约简是顺序算法，但内部有高度并行潜力。
并行序列：F4算法利用线性代数并行处理多个约简。

复杂度​

时间：计算Gröbner基在最坏情况下是双指数时间，但实际密码学问题中可能可行。约简一个多项式的复杂度通常较低。
空间：存储Gröbner基可能需要大量内存，尤其是多项式数量多、次数高时。

编号​

Attack-A0-0022

类别​

环论攻击 / 中国剩余定理在RSA中的攻击（共用模数攻击）

模型配方​

当两个或多个RSA公钥共享同一个模数 N，但使用不同的公钥指数 e1​和 e2​时，如果 gcd(e1​,e2​)=1，则攻击者可以利用扩展欧几里得算法和中国剩余定理（CRT）的思想，从用两个公钥加密的同一明文 m的密文 c1​≡me1​modN和 c2​≡me2​modN中恢复明文 m，而无需分解 N或获取私钥。模型配方：已知 c1​,c2​,e1​,e2​,N，且 gcd(e1​,e2​)=1，求 m。利用扩展欧几里得算法找到整数 s,t使得 se1​+te2​=1，然后计算 m≡c1s​⋅c2t​modN。注意，由于 s或 t可能为负数，计算中需使用模逆运算。

算法/模型/方法名称​

共用模数攻击（Common Modulus Attack）

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：从密文 c1​=me1​modN和 c2​=me2​modN中恢复明文 m，已知 e1​,e2​,N且 gcd(e1​,e2​)=1。
步骤1：检查指数互质。计算 g=gcd(e1​,e2​)。如果 g=1，则攻击可能不直接适用（但可能通过计算 mg简化问题）。假设 g=1。
步骤2：应用扩展欧几里得算法。寻找整数 s和 t，使得满足以下线性丢番图方程：
s⋅e1​+t⋅e2​=1
算法流程：设 r−1​=e1​,r0​=e2​， s−1​=1,s0​=0， t−1​=0,t0​=1。对于 i=1,2,...，计算：
qi​=⌊ri−2​/ri−1​⌋
ri​=ri−2​−qi​⋅ri−1​
si​=si−2​−qi​⋅si−1​
ti​=ti−2​−qi​⋅ti−1​
当 rk​=0时停止，此时 rk−1​=g=gcd(e1​,e2​)=1，且 s=sk−1​,t=tk−1​即为所求。注意 s和 t可能一正一负。
步骤3：处理负指数。由步骤2得到的关系式 se1​+te2​=1。则：
m=m1=mse1​+te2​=(me1​)s⋅(me2​)t≡c1s​⋅c2t​(modN)
如果 s或 t为负数，例如 s<0，则 c1s​在模 N下未定义。但我们可以将其转化为模逆运算：设 s′=−s>0，则 c1s​=(c1−1​)s′。计算 c1​在模 N下的逆元 c1−1​modN（这要求 gcd(c1​,N)=1，在RSA中通常成立，因为 m与 N互质）。因此，通用计算公式为：
m≡(c1s+​⋅c2t+​)⋅(c1−1​)s−⋅(c2−1​)t−modN
其中 s+=max(s,0)， s−=−min(s,0)， 对 t同理。
步骤4：计算模幂与模逆。根据步骤3的公式，依次计算所需的模逆和模幂，最终得到 mmodN。
步骤5：验证。得到的 m应具有可读的明文结构（如填充符合规范）。也可用公钥重新加密以验证。

精度/密度/误差/强度​

精度/强度：在 gcd(e1​,e2​)=1且 gcd(c1​,N)=1和 gcd(c2​,N)=1的条件下，攻击是确定性的，成功率为100%。
复杂度：时间复杂度为扩展欧几里得算法的 O(log(min(e1​,e2​)))加上模幂运算的 (O(\log

底层规律/理论定理​

扩展欧几里得算法：求解线性丢番图方程 ax+by=gcd(a,b)。
模运算的基本性质：ab⋅ac=ab+c， (ab)c=abc， 以及 a−1modN的定义和性质。
数论：若 gcd(a,n)=1，则 aϕ(n)≡1modn， 这保证了逆元的存在性。但本攻击并未直接使用欧拉定理，而是基于指数运算的结合律。

典型应用场景​

1. 错误配置的PKI系统：当多个用户或服务错误地使用了相同的RSA模数 N但不同 e时，攻击者可以截获发送给不同用户的同一消息的密文，从而恢复明文。
2. 网络协议中间人攻击：在协议中，如果同一消息需要用两个不同的公钥加密（例如，发给两个接收者），且公钥模数相同，中间人可以实施此攻击。
3. 某些加密库或硬件的实现缺陷：旧版或定制密码库在生成密钥对时可能重复使用模数。
4. 密码学作业或CTF挑战：作为经典教学案例，展示不当使用RSA的危害。
5. 对广播RSA的弱化攻击：广播RSA（Håstad’s Broadcast Attack）使用中国剩余定理，但需要多个密文。本攻击是其在两个接收者情况下的一个特例，但利用了指数互质。

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

- N： RSA公共模数，被两个密钥共享。
- e1​,e2​： 两个不同的公钥指数，满足 gcd(e1​,e2​)=1。
- c1​,c2​： 同一明文 m分别用公钥 (e1​,N)和 (e2​,N)加密得到的密文。
- m： 待恢复的明文，整数满足 0≤m<N。
- s,t： 扩展欧几里得算法找到的整数，满足 se1​+te2​=1。
- ci−1​modN： 密文 ci​在模 N下的乘法逆元。

状态机​

S0​: 输入 N,e1​,e2​,c1​,c2​； S1​: 计算 g=gcd(e1​,e2​)，如果 g=1则攻击失败，进入 Sfail​； S2​: 运行扩展欧几里得算法，得到 s,t满足 se1​+te2​=1； S3​: 根据 s,t的符号，计算所需的模逆元（如果指数为负）和模幂； S4​: 计算 m=c1s​⋅c2t​modN（处理负指数后）； S5​: 验证恢复的 m是否合理（如填充格式），若合理则进入 Ssuccess​，否则进入 Sfail​。

数学特征​

- 数论：核心是扩展欧几里得算法、模逆、模幂运算。
- 抽象代数：在环 ZN​中进行运算。
- 计算：算法复杂度是对数级别的，非常高效。
- 组合：指数的符号组合。

语言特征​

术语：“共用模数”、“扩展欧几里得算法”、“模逆”、“模幂”、“互质”、“负指数”。句式多为描述求解线性组合和模运算的过程。

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

阶段1：输入与检查
1. 攻击者获取：公共模数 N，两个公钥指数 e1​,e2​，以及对应同一明文 m的两个密文 c1​,c2​。
2. 验证 gcd(e1​,e2​)=1。如果不成立，攻击无法进行。
阶段2：求解线性组合
3. 运行扩展欧几里得算法求解 s和 t：
a. 设 (old_r,r)=(e1​,e2​), (old_s,s)=(1,0), (old_t,t)=(0,1)。
b. while​ r=0：
quotient = old_r // r
(old_r, r) = (r, old_r - quotient * r)
(old_s, s) = (s, old_s - quotient * s)
(old_t, t) = (t, old_t - quotient * t)
c. 循环结束后，有 gcd=old_r=1，且 s=old_s, t=old_t满足 se1​+te2​=1。
阶段3：处理负指数与计算
4. 根据 s,t的符号，计算中间量：
- 如果 s≥0， 计算 A=c1s​modN； 否则，计算 c1_inv=c1−1​modN，然后计算 A=(c1_inv)−smodN。
- 如果 t≥0， 计算 B=c2t​modN； 否则，计算 c2_inv=c2−1​modN，然后计算 B=(c2_inv)−tmodN。
5. 计算明文： m=A⋅BmodN。
阶段4：输出与验证
6. 输出 m。可选地，用公钥 (e1​,N)加密 m，验证是否等于 c1​。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：算法步骤顺序执行，但模逆和模幂计算可视为原子操作。
并行序列：A和 B的计算（包括可能的模逆计算）可以并行进行。

复杂度​

时间：扩展欧几里得算法：O(log(min(e1​,e2​)))。模逆计算：O(log3N)或更低（使用扩展欧几里得）。模幂运算：(O((\log

编号​

Attack-A0-0023

类别​

环论攻击 / 多项式环上的Coppersmith攻击（针对RSA with known high bits of p）

模型配方​

在RSA中，已知模数 N=pq。假设通过侧信道或部分信息泄露，攻击者知道了素数 p的高位部分，即已知一个近似值 p~​满足 p=p~​+x0​，其中 x0​是未知的小整数（相对于 p的大小）。该问题可以转化为在多项式环 ZN​[x]中求解模 N的小根问题。具体地，定义多项式 f(x)=p~​+x，则 x0​是满足 f(x0​)≡0modp的小根。由于 p整除 N，因此 f(x0​)≡0modp意味着 f(x0​)是 p的倍数。Coppersmith方法利用LLL算法来构造另一个多项式 h(x)，使得 h(x0​)=0在整数域上成立，从而可以在整数上直接求解 x0​。

算法/模型/方法名称​

Coppersmith's Method for Factoring with Known High Bits

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：已知 N=pq和 p的高位 p~​（即 (

精度/密度/误差/强度​

精度/强度：Coppersmith定理保证了如果已知的位数足够多（具体地，如果未知部分 X<N1/4在平衡素数情况下），则算法能在多项式时间内找到解。这是确定性的，前提是LLL找到的向量确实对应所需多项式。
复杂度：LLL运行时间取决于格的行列式和维度，对于参数 m,δ，格维度约为 mδ，因此是启发式的，但在实践中对中等大小的 N有效。

底层规律/理论定理​

Coppersmith定理：给定一个模数 N和次数为 δ的首一多项式 f(x)，可以在多项式时间内（关于 logN,δ）找到所有满足 f(x0​)≡0modp且 (

典型应用场景​

1. 侧信道攻击后的密钥恢复：当缓存计时攻击或故障攻击泄露了RSA素数 p的部分高位时。
2. 错误配置的密钥生成：某些劣质随机数生成器可能导致素数的高位具有低熵或可预测。
3. 网络协议中的部分信息泄露：某些协议可能意外泄露与密钥相关的信息。
4. 对基于CRT的RSA实现攻击：通过故障注入使签名计算错误，可能泄露 p的信息。
5. 密码学逆向工程与取证：从内存转储或损坏的存储中恢复不完整的密钥。

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

- N： RSA模数。
- p~​： 已知的 p的高位近似值。
- x0​： 未知的低位部分，满足 (

状态机​

S0​: 输入 N,p~​,X； S1​: 定义多项式 f(x)=p~​+x； S2​: 选择参数 m,δ，构造多项式集合 gi,k​(x)； S3​: 在 x=X处缩放，构建格基矩阵 B； S4​: 对 B运行LLL算法，得到约化基 B′； S5​: 从 B′的前几个短行恢复多项式 h1​(x),h2​(x),...； S6​: 计算 h1​(x)和 h2​(x)的GCD，或直接求 h1​(x)=0的整数根，得到候选 x0​； S7​: 计算 p=p~​+x0​，检查是否 p∣N；若成功，输出 p；否则调整参数或失败。

数学特征​

- 数论：模运算、因子分解。
- 抽象代数：多项式环。
- 格理论：LLL算法、格基构造。
- 计算代数：多项式GCD、求根。

语言特征​

术语：“Coppersmith方法”、“已知高位”、“小根”、“多项式格”、“LLL算法”、“Howgrave-Graham引理”。句式多为描述构造格和运行LLL的过程。

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

阶段1：参数设置
1. 输入：N(1024-bit), p~​(已知p的高512+ε位)，未知部分上界 X=2512−ϵ，其中 ε 是已知的位数超出一半的部分。
2. 设置参数：通常取 m=3,δ=1。构造多项式：
g0,0​=f(x)3， g0,1​=N⋅f(x)2， g0,2​=N2⋅f(x)， g0,3​=N3， 以及 g1,0​=x⋅f(x)3等（根据维度需要）。
阶段2：格基构造
3. 确定多项式集合的最大次数 d。例如，f(x)3的次数为3，乘以 xi后次数增加。设总次数为 d。
4. 对于每个多项式 g(x)，计算其系数向量 (a0​,a1​,...,ad​)。构造矩阵 B，其每一行对应一个 g，列为：[a0​,a1​X,a2​X2,...,ad​Xd]。
阶段3：LLL与多项式恢复
5. 对矩阵 B运行LLL算法，得到约化基 B′。
6. 取 B′的第一行（最短向量）v=(v0​,v1​,...,vd​)。构造多项式 h(x)=∑j=0d​(vj​/Xj)xj。由于 vj​是整数，vj​/Xj可能不是整数，但实际中常直接使用 v作为系数向量，即 h(x)=∑vj​xj，并认为 h(X⋅x)的系数是 vj​。
阶段4：求根与验证
7. 求解 h(x)=0的整数根。可以使用有理根定理或直接数值求解。得到候选 x0​。
8. 计算 p=p~​+x0​，检查 p是否整除 N。若整除，则成功分解 N。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：步骤顺序执行，LLL是核心顺序算法。
并行序列：LLL算法内部某些步骤可并行，但通常视为整体。

复杂度​

时间：主要开销在LLL，其复杂度关于格维度 w为 O(w5log3B)，其中 B是基向量范数的上界。维度 w与参数 m,δ相关，约为 mδ。对于中等参数，尚可处理。
空间：存储格基矩阵，O(w2)。

编号​

Attack-A0-0024

类别​

域论攻击 / 基于域迹的线性化攻击（针对基于LFSR的流密码）

模型配方​

许多流密码基于线性反馈移位寄存器（LFSR）和非线性滤波函数或组合函数。攻击目标是利用有限域 GF(2n)的迹函数（Trace function）的线性性质，将非线性关系转化为线性关系，从而建立线性方程来恢复初始状态或密钥。迹函数 Tr:GF(2n)→GF(2)定义为 Tr(x)=x+x2+x22+...+x2n−1，具有线性和满射性质。通过将非线性滤波函数表示为域元素的多项式，并对其应用迹函数，可能得到关于初始状态比特的线性方程。

算法/模型/方法名称​

线性化攻击（Linearization Attack） via Trace Function

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：对基于LFSR的流密码，给定一段密钥流 z0​,z1​,...,zm−1​，恢复LFSR的初始状态 s0​。
步骤1：建模非线性函数。设LFSR的状态在时刻 t对应域元素 st​∈GF(2n)，其更新是线性的：st+1​=L(st​)，其中 L是线性变换（对应于反馈多项式）。密钥流比特由非线性函数 f:GF(2n)→GF(2)生成：zt​=f(st​)。
步骤2：将函数表示为域多项式。将布尔函数 f表示为有限域 GF(2n)上的多项式函数。由于 GF(2n)上的任何函数都可以唯一表示为次数小于 2n的多项式：
f(x)=∑i=02n−1​ci​xi,ci​∈GF(2n)
但输出是 GF(2)中的比特，因此系数有约束。
步骤3：应用迹函数。利用迹函数的线性：Tr(a+b)=Tr(a)+Tr(b)，以及 Tr(cx2j)=Tr(c2−jx)（因为迹与Frobenius自同构交换）。目标是找到一组系数 αt​∈GF(2n)，使得线性组合 ∑t​αt​zt​可以表示为初始状态 s0​的迹的线性函数，即：
∑t=0m−1​αt​zt​=∑t​αt​f(st​)=Tr(β⋅s0​)
对于某个 β∈GF(2n)。这要求对 f的多项式表示进行代数操作，利用LFSR的线性性质 st​=Lt(s0​)。
步骤4：建立线性方程。如果步骤3成功，则对于每个选择的系数向量 α，我们得到一个形如 Tr(β⋅s0​)=known的方程，其中已知右边是 ∑αt​zt​。由于迹函数是到 GF(2)的线性映射，且 {β}可以张成整个对偶空间，我们可以收集足够多这样的方程来求解 s0​的各个线性函数。
步骤5：求解初始状态。设我们收集了 n个线性无关的方程 Tr(βi​⋅s0​)=bi​， i=1,...,n。这等价于一个线性方程组，可以解出 s0​（在某个基下的坐标）。具体地，选择 GF(2n)的一组基 {γ1​,...,γn​}，将 s0​表示为 s0​=∑j​xj​γj​， xj​∈GF(2)。则方程变为：
Tr(βi​∑j​xj​γj​)=∑j​xj​Tr(βi​γj​)=bi​
这是一个关于 xj​的 n×n线性方程组，在 GF(2)上求解。
步骤6：验证。用恢复的 s0​生成密钥流，与已知段比对。

精度/密度/误差/强度​

精度/强度：如果非线性函数 f的代数次数不高，且能成功线性化，攻击是确定性的。所需密钥流长度 m与 n和 f的复杂度有关。
复杂度：主要复杂度在于寻找合适的线性化系数 αt​，这可能需要解一个关于域元素的线性系统或利用预计算。求解最终方程组需要 O(n3)比特运算。
误差：如果 f的代数免疫性高，可能无法有效线性化。

底层规律/理论定理​

有限域理论：迹函数的定义和性质（线性、满射）。
Frobenius自同构：x↦x2是域自同构。
线性代数：求解线性方程组。
布尔函数代数：函数的多项式表示。

典型应用场景​

1. 针对Grain-like流密码的分析：Grain家族使用LFSR和NFSR，但早期版本可能受到线性化攻击变种的影响。
2. 对非线性滤波生成器的攻击：当滤波函数代数次数较低时。
3. 对组合生成器的相关攻击：如果组合函数与LFSR状态存在线性关系。
4. 密码标准评估：评估候选流密码对代数攻击的抵抗力。
5. 硬件实现攻击的辅助：结合侧信道信息简化方程。

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

- n： LFSR长度（域扩展次数）。
- st​∈GF(2n)： 时刻 t的LFSR状态（视为域元素）。
- L： 状态更新线性变换（对应于本原多项式）。
- f:GF(2n)→GF(2)： 非线性密钥流生成函数。
- zt​： 时刻 t的密钥流比特。
- Tr:GF(2n)→GF(2)： 迹函数。
- αt​∈GF(2n)： 线性组合系数。
- β∈GF(2n)： 与初始状态相关的域元素。
- γj​： GF(2n)在 GF(2)上的一组基。

状态机​

S0​: 输入密钥流段 z0​,...,zm−1​和密码结构（L, f）； S1​: 将 f表示为 GF(2n)上的多项式； S2​: 寻找一组系数 {αt​}，使得 ∑αt​f(Lt(s0​))可简化为 Tr(βs0​)形式； S3​: 对于每个找到的线性关系，计算右边值 ∑αt​zt​，得到方程 Tr(βs0​)=known； S4​: 收集至少 n个线性无关的方程； S5​: 在选定的基下，将方程转化为关于 s0​坐标的线性方程组并求解； S6​: 输出恢复的初始状态 s0​并验证。

数学特征​

- 抽象代数/有限域：核心是迹函数、Frobenius自同构、多项式表示。
- 线性代数：求解线性方程组。
- 布尔函数：代数次数、表示。

语言特征​

术语：“迹函数”、“线性化”、“Frobenius自同构”、“代数次数”、“有限域表示”。句式多为描述利用迹的线性性质进行化简的过程。

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

阶段1：分析与表示
1. 已知LFSR反馈多项式对应本原多项式 p(x)，定义域 GF(2n)≅GF(2)[x]/⟨p(x)⟩。状态 st​对应域元素。
2. 非线性函数 f通常以布尔函数形式给出。将其转换为在域 GF(2n)上运算的多项式。例如，如果 f取状态寄存器的某些位的非线性组合，可以表示为 f(s)=∑i∈I​Tr(λi​sdi​)的形式，其中 di​是2-权次（Fourier 谱表示）。
阶段2：构造线性关系
3. 目标是找到系数 αt​，使得 ∑t=0m−1​αt​f(Lt(s0​))是 Tr(βs0​)。由于 L是线性的，可以表示为域上的乘法：st​=αts0​，其中 α是 L对应的本原元（假设LFSR是最大周期的）。则 f(Lt(s0​))=f(αts0​)。
4. 将 f(x)展开为多项式 ∑ci​xi。则组合变为：
∑t​αt​f(αts0​)=∑t​αt​∑i​ci​(αts0​)i=∑i​ci​s0i​∑t​αt​αit
我们希望内和 ∑t​αt​αit对于大多数 i为零，只对某个特定的 i非零，且该 i对应的单项式 ci​s0i​可以写成 Tr(βs0​)。这需要精心选择 αt​。
阶段3：求解与验证
5. 通过解关于 αt​的线性方程组（在 GF(2n)中）来寻找系数。这可能需要 m足够大。
6. 一旦得到方程 Tr(βs0​)=b，通过变化 β（例如，取 β=αj）收集 n个方程。
7. 求解 s0​。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：步骤顺序执行，但寻找线性关系可能需要解线性系统。

复杂度​

时间：寻找线性化系数的复杂度取决于 f的表示和所需方程数量，可能是指数于 n或多项式的。求解最终方程组是 O(n3)。
空间：存储中间多项式系数和方程组。

编号​

Attack-A0-0025

类别​

格论攻击 / 利用格基约化求解背包问题（子集和问题）

模型配方​

背包密码（Merkle-Hellman）的安全性基于子集和问题的困难性：给定一个正整数集合（背包向量）a=(a1​,a2​,...,an​)和一个目标和 S，寻找一个二进制向量 x=(x1​,...,xn​)∈{0,1}n使得 a⋅x=∑i=1n​ai​xi​=S。攻击模型将求解子集和问题转化为在格中寻找短向量问题。具体地，构造一个格，使得其短向量对应方程 ∑ai​xi​−S=0的解。通过运行LLL或BKZ算法对格进行约化，有望找到这样的短向量，从而恢复明文 x。

算法/模型/方法名称​

Lattice-based Attack on Subset Sum Problem

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：给定 a=(a1​,...,an​)和 S，求 x∈{0,1}n使得 a⋅x=S。
步骤1：构造格。一个经典的构造是定义如下 (n+1)维格，其基矩阵为：
B=​10⋮00​01⋮00​⋯⋯⋱⋯⋯​00⋮10​−a1​−a2​⋮−an​S​​
即基向量为 bi​=ei​−ai​en+1​for i=1,...,n，和 bn+1​=Sen+1​，其中 ei​是标准基向量。考虑格点 v=∑i=1n​xi​bi​+bn+1​。计算：
v=(x1​,x2​,...,xn​,−∑ai​xi​+S)=(x1​,...,xn​,0)
因为 ∑ai​xi​=S。因此，解向量 x对应一个格点 v=(x1​,...,xn​,0)，其范数约为 ∑xi2​​≤n​，相对于随机格点较短。
步骤2：运行格基约化。对格 L的基矩阵 B运行LLL或BKZ算法，得到一组约化基向量 v1​,v2​,...。
步骤3：在短向量中寻找解。检查约化基中的短向量（特别是第一个向量）是否具有形式 (x1​,...,xn​,0)且 xi​∈{0,±1}（由于LLL可能产生负系数）。如果找到，则 x（或其绝对值）是候选解。
步骤4：验证。检查候选 x是否满足 a⋅x=S且 xi​∈{0,1}。
步骤5：处理噪声。如果LLL没有直接给出解，可能需要使用更大的块大小运行BKZ，或使用其他技术如枚举。

精度/密度/误差/强度​

精度/强度：对于低密度子集和问题（密度 d=n/log2​(maxai​)<0.9408...），攻击成功率很高。对于高密度问题，可能失败。算法是启发式的，不保证总是成功。
复杂度：LLL是多项式时间，但解高维或困难实例可能需要BKZ，其复杂度随块大小指数增长。

底层规律/理论定理​

格理论：LLL算法可以在多项式时间内找到近似最短向量。
子集和问题的密度：Lagarias和Odlyzko证明了当密度低于某个阈值时，子集和问题可以在多项式时间内用格方法解决。
几何级数原理：构造的格使得解对应一个异常短的向量。

典型应用场景​

1. 破解Merkle-Hellman背包密码：这是该攻击的经典应用。
2. 解决密码协议中的子集和实例：某些协议可能隐含子集和问题。
3. 作为更复杂格攻击的子程序：例如，在求解近似最大公因子问题（AGCD）或LWE问题时，可能转化为子集和形式。
4. 伪随机数生成器的分析：如果生成器基于子集和问题。
5. 密码学作业与CTF：常见挑战类型。

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

- a=(a1​,...,an​)： 公开的背包向量（正整数）。
- S： 目标和（正整数）。
- x=(x1​,...,xn​)： 未知的二进制向量，满足 a⋅x=S。
- B： 构造的格基矩阵，维度为 (n+1)×(n+1)。
- d： 子集和问题的密度，d=n/log2​(maxi​ai​)。

状态机​

S0​: 输入背包向量 a和目标和 S； S1​: 构造格基矩阵 B； S2​: 对 B运行LLL/BKZ算法，得到约化基 B′； S3​: 检查 B′中的短向量，寻找形式为 (x1​,...,xn​,0)且 xi​接近0/1的向量； S4​: 如果找到，提取候选 x′，验证是否满足 a⋅x′=S且 x′∈{0,1}n； S5​: 如果验证通过，输出解；否则尝试BKZ更高块大小或失败。

数学特征​

- 格理论：格基构造、LLL算法。
- 数论：整数向量、范数计算。
- 组合优化：子集和问题。

语言特征​

术语：“子集和问题”、“背包问题”、“格基约化”、“LLL算法”、“密度”、“短向量”。句式多为描述构造格和寻找短向量的过程。

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

阶段1：构造格
1. 给定 ai​和 S，构造矩阵 B如上述公式。注意，有时会使用缩放因子。另一种常见构造（CJLOSS格）是：
B=​10⋮00​01⋮00​⋯⋯⋱⋯⋯​00⋮10​Na1​Na2​⋮Nan​NS​​
其中 N是一个大整数（例如 2n/2），用于强制最后一个分量为0。解向量 v=(x1​,...,xn​,0)仍在格中，因为 ∑Nai​xi​−NS=0。
阶段2：运行LLL
2. 对矩阵 B应用LLL算法，δ参数通常取0.99。
阶段3：分析结果
3. LLL输出一组约化基向量。检查每个向量的最后一个分量是否接近0（例如，绝对值小于某个阈值）。对于这样的向量，看前 n个分量是否接近整数0或1（或-1）。
4. 如果向量 v=(v1​,...,vn​,vn+1​)满足 (

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：LLL/BKZ是顺序算法。
并行序列：BKZ的枚举步骤可并行。

复杂度​

时间：LLL复杂度为 O((n+1)5logmaxB)。对于中等 n（如100），可行。BKZ复杂度更高。
空间：存储格基 O((n+1)2)。

编号​

Attack-A0-0026

类别​

格论攻击 / 针对RSA小私钥指数d的Wiener攻击（基于连分数）

模型配方​

在RSA中，私钥 d满足 ed≡1modϕ(N)，即存在整数 k使得 ed−kϕ(N)=1。当私钥指数 d很小时（具体地，d<31​N1/4），Wiener攻击表明，dk​是 Ne​的一个连分数近似。由于 ϕ(N)=N−(p+q)+1≈N，因此 Ne​≈dk​。攻击通过计算 e/N的连分数展开，依次检查每个渐近分数是否给出一个有效的 d（即尝试用它解密）。如果 d足够小，它将在连分数展开的早期出现。

算法/模型/方法名称​

Wiener's Attack (Continued Fraction Attack on small d)

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：给定RSA公钥 (N,e)，其中私钥指数 d较小，恢复 d。
步骤1：计算连分数展开。计算有理数 e/N的连分数展开：
Ne​=a0​+a1​+a2​+⋱1​1​1​=[a0​;a1​,a2​,...]
使用欧几里得算法：设 r−2​=e, r−1​=N。对于 i≥0：
ai​=⌊ri−2​/ri−1​⌋
ri​=ri−2​−ai​ri−1​
直到 ri​=0。序列 a0​,a1​,...是连分数系数。
步骤2：计算渐近分数。从连分数系数构造渐近分数（收敛项）序列 di​ki​​：
设 k−2​=0,k−1​=1;d−2​=1,d−1​=0。
对于 i=0,1,2,...：
ki​=ai​ki−1​+ki−2​
di​=ai​di−1​+di−2​
则 di​ki​​是 e/N的第 i个渐近分数。
步骤3：检查候选。对每个渐近分数 di​ki​​，假设 k=ki​, d=di​。计算 ϕ(N)的候选值：
ϕ=ked−1​
检查 ϕ是否为整数。如果是，则进一步验证：在已知 N和 ϕ的情况下，可以解二次方程 x2−(N−ϕ+1)x+N=0来求 p和 q。即，计算：
b=N−ϕ+1
Δ=b2−4N
检查 Δ是否为完全平方数。如果是，则 p,q=(b±Δ​)/2为整数，且 pq=N。此时攻击成功，输出 d。
步骤4：迭代。如果对所有渐近分数检查完毕仍未成功，则可能 d不满足 Wiener 条件（即不够小），攻击失败。

精度/密度/误差/强度​

精度/强度：当 d<31​N1/4时，Wiener定理保证攻击成功。算法是确定性的。
复杂度：连分数展开的复杂度为 O(logN)，非常高效。
误差：如果 d大于阈值，攻击失败。

底层规律/理论定理​

连分数理论：实数的最佳有理逼近由它的连分数渐近分数给出。
Wiener定理：如果 d<31​N1/4，则 dk​是 Ne​的一个渐近分数。
RSA等式：ed=1+kϕ(N)。

典型应用场景​

1. 错误使用小d的RSA系统：为加快解密速度而使用小私钥指数，导致易受攻击。
2. 密码学教学与CTF挑战：经典案例。
3. 安全审计：检查密码库是否允许生成过小的私钥指数。
4. 对嵌入式设备或智能卡的攻击：这些设备可能因性能限制而使用小d。
5. 历史密码分析：分析旧协议或实现中的弱点。

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

- N： RSA模数。
- e： 公钥指数。
- d： 目标私钥指数（较小）。
- ϕ(N)： 欧拉函数值，ϕ(N)=(p−1)(q−1)。
- k： 满足 ed−kϕ(N)=1的整数。
- ai​： 连分数展开的第 i个系数。
- ki​,di​： 第 i个渐近分数的分子和分母。

状态机​

S0​: 输入 (N,e)； S1​: 计算 e/N的连分数展开，得到系数序列 {ai​}； S2​: 使用递推公式计算渐近分数序列 {(ki​,di​)}； S3​: 对每个 (ki​,di​)： 计算 ϕ=(e∗di​−1)/ki​； 如果 ϕ是整数，则计算 b=N−ϕ+1， Δ=b2−4N； 如果 Δ≥0且是完全平方数，则攻击成功，输出 d=di​并结束； S4​: 如果所有渐近分数检查完毕仍未成功，则攻击失败。

数学特征​

- 数论：连分数、欧几里得算法、二次方程求解。
- 计算：整数运算、平方检测。

语言特征​

术语：“Wiener攻击”、“连分数”、“渐近分数”、“小私钥指数”。句式多为描述计算连分数和验证候选的过程。

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

阶段1：连分数展开
1. 输入：大整数 e和 N。
2. 执行扩展欧几里得算法风格的步骤：
- 设 x=e, y=N。
- while​ y=0：
a=⌊x/y⌋(输出一个系数)
(x,y)=(y,x−a∗y)
记录所有商 a作为连分数系数。
阶段2：生成收敛项
3. 初始化：k−2​=0,k−1​=1;d−2​=1,d−1​=0。
4. for​ i=0,1,2,...(对应每个系数 ai​)：
ki​=ai​∗ki−1​+ki−2​
di​=ai​∗di−1​+di−2​
现在 (ki​,di​)是一对候选。
阶段3：验证候选
5. 对于每个 (ki​,di​)：
a. 检查 di​是否为奇数（因为通常 d是奇数），且 di​>1。
b. 计算 tmp=e∗di​−1。如果 tmpmodki​=0，跳过。
c. 计算 ϕ=tmp/ki​。
d. 解方程：p+q=N−ϕ+1， pq=N。即，计算 s=N−ϕ+1， 判别式 D=s2−4N。
e. 检查 D是否是非负完全平方数。如果是，则 p,q=(s±D​)/2为整数，且 p∗q==N。攻击成功，输出 di​。
阶段4：终止
6. 如果循环完所有系数仍未成功，则输出失败。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：连分数展开和渐近分数生成是顺序的。候选验证可顺序或提前终止。

复杂度​

时间：连分数展开需要 O(logN)步。每个候选的验证涉及常数次大数运算。总体非常快。
空间：常数空间。

编号​

Attack-A0-0026

类别​

格论攻击 / 针对RSA小私钥指数d的Wiener攻击（基于连分数）

模型配方​

在RSA中，私钥 d满足 ed≡1modϕ(N)，即存在整数 k使得 ed−kϕ(N)=1。当私钥指数 d很小时（具体地，d<31​N1/4），Wiener攻击表明，dk​是 Ne​的一个连分数近似。由于 ϕ(N)=N−(p+q)+1≈N，因此 Ne​≈dk​。攻击通过计算 e/N的连分数展开，依次检查每个渐近分数是否给出一个有效的 d（即尝试用它解密）。如果 d足够小，它将在连分数展开的早期出现。

算法/模型/方法名称​

Wiener's Attack (Continued Fraction Attack on small d)

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：给定RSA公钥 (N,e)，其中私钥指数 d较小，恢复 d。
步骤1：计算连分数展开。计算有理数 e/N的连分数展开：
Ne​=a0​+a1​+a2​+⋱1​1​1​=[a0​;a1​,a2​,...]
使用欧几里得算法：设 r−2​=e, r−1​=N。对于 i≥0：
ai​=⌊ri−2​/ri−1​⌋
ri​=ri−2​−ai​ri−1​
直到 ri​=0。序列 a0​,a1​,...是连分数系数。
步骤2：计算渐近分数。从连分数系数构造渐近分数（收敛项）序列 di​ki​​：
设 k−2​=0,k−1​=1;d−2​=1,d−1​=0。
对于 i=0,1,2,...：
ki​=ai​ki−1​+ki−2​
di​=ai​di−1​+di−2​
则 di​ki​​是 e/N的第 i个渐近分数。
步骤3：检查候选。对每个渐近分数 di​ki​​，假设 k=ki​, d=di​。计算 ϕ(N)的候选值：
ϕ=ked−1​
检查 ϕ是否为整数。如果是，则进一步验证：在已知 N和 ϕ的情况下，可以解二次方程 x2−(N−ϕ+1)x+N=0来求 p和 q。即，计算：
b=N−ϕ+1
Δ=b2−4N
检查 Δ是否为完全平方数。如果是，则 p,q=(b±Δ​)/2为整数，且 pq=N。此时攻击成功，输出 d。
步骤4：迭代。如果对所有渐近分数检查完毕仍未成功，则可能 d不满足 Wiener 条件（即不够小），攻击失败。

精度/密度/误差/强度​

精度/强度：当 d<31​N1/4时，Wiener定理保证攻击成功。算法是确定性的。
复杂度：连分数展开的复杂度为 O(logN)，非常高效。
误差：如果 d大于阈值，攻击失败。

底层规律/理论定理​

连分数理论：实数的最佳有理逼近由它的连分数渐近分数给出。
Wiener定理：如果 d<31​N1/4，则 dk​是 Ne​的一个渐近分数。
RSA等式：ed=1+kϕ(N)。

典型应用场景​

1. 错误使用小d的RSA系统：为加快解密速度而使用小私钥指数，导致易受攻击。
2. 密码学教学与CTF挑战：经典案例。
3. 安全审计：检查密码库是否允许生成过小的私钥指数。
4. 对嵌入式设备或智能卡的攻击：这些设备可能因性能限制而使用小d。
5. 历史密码分析：分析旧协议或实现中的弱点。

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

- N： RSA模数。
- e： 公钥指数。
- d： 目标私钥指数（较小）。
- ϕ(N)： 欧拉函数值，ϕ(N)=(p−1)(q−1)。
- k： 满足 ed−kϕ(N)=1的整数。
- ai​： 连分数展开的第 i个系数。
- ki​,di​： 第 i个渐近分数的分子和分母。

状态机​

S0​: 输入 (N,e)； S1​: 计算 e/N的连分数展开，得到系数序列 {ai​}； S2​: 使用递推公式计算渐近分数序列 {(ki​,di​)}； S3​: 对每个 (ki​,di​)： 计算 ϕ=(e∗di​−1)/ki​； 如果 ϕ是整数，则计算 b=N−ϕ+1， Δ=b2−4N； 如果 Δ≥0且是完全平方数，则攻击成功，输出 d=di​并结束； S4​: 如果所有渐近分数检查完毕仍未成功，则攻击失败。

数学特征​

- 数论：连分数、欧几里得算法、二次方程求解。
- 计算：整数运算、平方检测。

语言特征​

术语：“Wiener攻击”、“连分数”、“渐近分数”、“小私钥指数”。句式多为描述计算连分数和验证候选的过程。

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

阶段1：连分数展开
1. 输入：大整数 e和 N。
2. 执行扩展欧几里得算法风格的步骤：
- 设 x=e, y=N。
- while​ y=0：
a=⌊x/y⌋(输出一个系数)
(x,y)=(y,x−a∗y)
记录所有商 a作为连分数系数。
阶段2：生成收敛项
3. 初始化：k−2​=0,k−1​=1;d−2​=1,d−1​=0。
4. for​ i=0,1,2,...(对应每个系数 ai​)：
ki​=ai​∗ki−1​+ki−2​
di​=ai​∗di−1​+di−2​
现在 (ki​,di​)是一对候选。
阶段3：验证候选
5. 对于每个 (ki​,di​)：
a. 检查 di​是否为奇数（因为通常 d是奇数），且 di​>1。
b. 计算 tmp=e∗di​−1。如果 tmpmodki​=0，跳过。
c. 计算 ϕ=tmp/ki​。
d. 解方程：p+q=N−ϕ+1， pq=N。即，计算 s=N−ϕ+1， 判别式 D=s2−4N。
e. 检查 D是否是非负完全平方数。如果是，则 p,q=(s±D​)/2为整数，且 p∗q==N。攻击成功，输出 di​。
阶段4：终止
6. 如果循环完所有系数仍未成功，则输出失败。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：连分数展开和渐近分数生成是顺序的。候选验证可顺序或提前终止。

复杂度​

时间：连分数展开需要 O(logN)步。每个候选的验证涉及常数次大数运算。总体非常快。
空间：常数空间。

算法的伪代码（多种语言版本）​

Python版本：
python<br>import math<br>def wiener_attack(e, n):<br> def continued_fraction(e, n):<br> while n:<br> a = e // n<br> yield a<br> e, n = n, e - a * n<br> def convergents(cf):<br> hn, hd = 0, 1<br> kn, kd = 1, 0<br> for a in cf:<br> hn, hd = a * hn + hd, hn<br> kn, kd = a * kn + kd, kn<br> yield hn, kn<br> for k, d in convergents(continued_fraction(e, n)):<br> if k == 0 or d % 2 == 0:<br> continue<br> phi_candidate = (e * d - 1) // k<br> b = n - phi_candidate + 1<br> delta = b * b - 4 * n<br> if delta >= 0:<br> sqrt_delta = math.isqrt(delta)<br> if sqrt_delta * sqrt_delta == delta:<br> p = (b + sqrt_delta) // 2<br> q = (b - sqrt_delta) // 2<br> if p * q == n:<br> return d<br> return None<br>

Go版本：
```go
package main
import ("math/big")
func continuedFractions(e, n big.Int) (cf []big.Int) {
for n.Sign() != 0 {
a := new(big.Int).Div(e, n)
cf = append(cf, a)
e, n = n, new(big.Int).Sub(e, new(big.Int).Mul(a, n))
}
return
}
func convergents(cf []big.Int) ([]big.Int, []big.Int) {
var k, d []big.Int
hn, hd := big.NewInt(0), big.NewInt(1)
kn, kd := big.NewInt(1), big.NewInt(0)
for _, a := range cf {
hn, hd = new(big.Int).Add(new(big.Int).Mul(a, hn), hd), hn
kn, kd = new(big.Int).Add(new(big.Int).Mul(a, kn), kd), kn
k = append(k, new(big.Int).Set(hn))
d = append(d, new(big.Int).Set(kn))
}
return k, d
}
func wienerAttack(e, n *big.Int) *big.Int {
cf := continuedFractions(e, n)
kList, dList := convergents(cf)
for i := range kList {
k, d := kList[i], dList[i]
if k.Sign() == 0

编号​

Attack-A0-0027

类别​

格论攻击 / 针对带填充RSA的Coppersmith短填充攻击

模型配方​

假设同一明文 m在加密前被不同的、已知的、较短的随机填充串 r1​和 r2​填充，然后使用相同的RSA公钥 (N,e)加密，得到两个密文 c1​和 c2​。设填充函数为线性连接，即加密的消息为 m1​=2kr1​+m和 m2​=2kr2​+m，其中 k是填充长度（比特）。则我们有 c1​≡(2kr1​+m)emodN和 c2​≡(2kr2​+m)emodN。攻击目标是利用这两个多项式在模 N下有相同的根 m这一事实，通过计算两个多项式的最大公因式（GCD）来恢复 m。但由于 N很大，直接计算不可行。Coppersmith 方法通过构造一个多项式 g(x)=gcd(xe−c1​,(x+Δ)e−c2​)在整数环上（而不是模 N）有较小根 m，其中 Δ=2k(r1​−r2​)已知。通过将问题转化为寻找两个多项式的公共小根，并利用结式或格基约化，可以在 e较小且填充足够短时有效恢复 m。

算法/模型/方法名称​

Coppersmith's Short Pad Attack

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：给定两个密文 c1​,c2​，对应的填充 r1​,r2​，公钥 (N,e)，恢复明文 m。
步骤1：问题建模。设明文为 m，填充长度为 k比特，则加密的消息为：
M1​=2kr1​+m,M2​=2kr2​+m
满足：
c1​≡M1e​modN,c2​≡M2e​modN
设 Δ=2k(r1​−r2​)，则 M2​=M1​+Δ。因此，M1​是多项式 f1​(x)=xe−c1​和 f2​(x)=(x+Δ)e−c2​在模 N下的公共根。即：
f1​(M1​)≡0modN,f2​(M1​)≡0modN
步骤2：构造多项式。考虑多项式 g(x)=gcd(f1​(x),f2​(x))在多项式环 ZN​[x]中。由于 M1​是公共根，g(x)的次数至少为1。但直接计算模 N下的GCD困难，转而考虑在整数环上寻找公共小根。
步骤3：使用结式消元。计算结式 R=Resx​(f1​(x),f2​(x))。由于 f1​和 f2​在模 N下有公共根，所以 R≡0modN。即 R是 N的倍数。如果 R=0，则我们可以计算 gcd(R,N)，可能会得到 N的一个因子。但更常见的是，R本身就是 N的倍数，且可能等于 N的较小倍数，从而我们可以通过分解 R来得到 N的因子。
步骤4：通过格基约化直接求根。另一种更直接的方法是利用Coppersmith的多变量多项式求根技术。我们有两个多项式 f1​(x)和 f2​(x)，它们有公共小根 M1​。我们可以构造一个格，其基由多项式 xif1​(x)jf2​(x)m−j的系数向量组成（经过适当的缩放），然后应用LLL算法。最短向量对应一个新的多项式 h(x)，满足 h(M1​)=0在整数上成立，且 h的次数较低，从而可以求解 M1​。
步骤5：求解。从 h(x)=0的解中找出小整数根 M1​，然后恢复 m=M1​−2kr1​。
步骤6：验证。用公钥加密恢复的 m并与 c1​,c2​比较。

精度/密度/误差/强度​

精度/强度：当填充长度 k小于 N的大约 1/e2时，攻击可能成功。具体地，Coppersmith 证明了如果填充长度小于 N1/e2，则攻击可以在多项式时间内成功。
复杂度：依赖于 e的大小。对于小的 e（如 3 或 65537），攻击是有效的。主要复杂度在于运行 LLL 算法，格维度与 e有关。
误差：如果填充过长，攻击失败。

底层规律/理论定理​

Coppersmith 定理（多变量版本）：给定一个或多个模多项式，如果根足够小，则可以在多项式时间内找到这些根。
结式理论：两个多项式有公共根当且仅当其结式为零。
格基约化：LLL 算法可用于寻找具有小根的多项式。

典型应用场景​

1. 对使用随机填充的RSA加密的攻击：当相同的消息被随机填充并多次加密时。
2. 广播RSA的变种：如果相同的消息被发送给多个接收者，但使用了短随机填充。
3. 密码协议中的消息重放：如果协议允许同一消息在不同会话中加密，且填充随机但短。
4. 侧信道攻击的辅助：如果通过侧信道获得了填充的部分信息。
5. 密码学教学：作为Coppersmith方法的一个典型应用。

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

- N： RSA模数。
- e： 公钥指数。
- r1​,r2​： 两个不同的随机填充（已知，例如，在密文中传输）。
- k： 填充的比特长度。
- m： 待恢复的明文。
- c1​,c2​： 密文。
- Δ=2k(r1​−r2​)： 两个加密消息之间的已知差。
- f1​(x)=xe−c1​， f2​(x)=(x+Δ)e−c2​： 定义的多项式。

状态机​

S0​: 输入 N,e,c1​,c2​,r1​,r2​,k； S1​: 计算 Δ=2k(r1​−r2​)； S2​: 构造多项式 f1​(x)=xe−c1​和 f2​(x)=(x+Δ)e−c2​； S3​: 通过结式计算或格基约化方法寻找 f1​和 f2​的公共小根 M1​； S4​: 如果找到 M1​，则计算 m=M1​−2kr1​； S5​: 验证 m的正确性； S6​: 输出 m或失败。

数学特征​

- 数论：模运算、多项式。
- 抽象代数：多项式环、结式。
- 格理论：LLL算法、格基构造。
- 计算代数：多项式GCD、求根。

语言特征​

术语：“短填充攻击”、“Coppersmith方法”、“公共根”、“结式”、“格基约化”。句式多为描述构造多项式和寻找公共根的过程。

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

阶段1：准备工作
1. 已知：N,e,c1​,c2​,r1​,r2​,k。
2. 计算 Δ=2k(r1​−r2​)。注意，如果 r1​,r2​是比特串，则 2kr表示左移 k位。
阶段2：结式法
3. 计算结式 R=Resx​(f1​(x),f2​(x))。这可以通过计算两个多项式的Sylvester矩阵的行列式来实现。
4. 计算 d=gcd(R,N)。如果 d>1且 d<N，则 d是 N的一个因子，可以分解 N，然后正常解密。否则，如果 R=0或 R是 N的倍数，但无法直接分解，则尝试格方法。
阶段3：格方法
5. 构造格基。定义多项式集合：对于参数 m和 t，考虑所有多项式：
gi,j​(x)=xj⋅f1​(x)i⋅f2​(x)m−ifor 0≤i≤m,0≤j≤t−1
这些多项式在 x=M1​处模 Nm为零。在点 x=X处缩放，其中 X是 M1​的上界（例如，(X = 2^{

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：步骤顺序执行，LLL是核心顺序算法。
并行序列：结式计算和LLL内部可并行化。

复杂度​

时间：结式计算需要 O(e3)次大数运算。格方法的复杂度取决于维度，与 e和参数 m,t有关，但通常对于小 e是可行的。
空间：存储格基矩阵，维度大约为 mt。

A0-0028​

表示论攻击

利用特征标理论分析S盒的差分均匀性

将S盒视为有限域 GF(2n)到 GF(2m)的函数，计算其 Walsh 谱（Fourier 变换），其最大值与差分均匀性相关。用于评估S盒的密码学强度。

非线性度：(NL(f) = 2^{n-1} - \frac{1}{2} \max_{\alpha \neq 0, \beta}

A0-0029​

表示论攻击

群表示在密码侧信道分析中的应用（模板攻击）

将能量迹视为随机过程，利用主成分分析（PCA）或线性判别分析（LDA）进行降维，这些方法本质上是表示论（群在特征空间上的作用）的应用。

寻找投影方向，使得类间散布最大，类内散布最小：J(w)=wTSW​wwTSB​w​。

A0-0030​

同调代数攻击

使用同调群分析网络拓扑的冗余路径

计算网络图（单纯复形）的同调群，特别是1维同调群 H1​，其维度（贝蒂数）等于网络中独立环路的数量，可用于识别冗余路径和潜在攻击路径。

构建链复形 C2​∂2​​C1​∂1​​C0​，计算 H1​=ker∂1​/im∂2​，β1​=rankH1​。

A0-0031​

同调代数攻击

持久同调在时间序列异常检测中的应用

对时间序列数据构建点云（例如，通过延迟嵌入），然后计算其 Rips 复形的持久同调，得到条形码。异常行为会导致条形码的持续长度分布发生变化。

对每个尺度 ϵ，构建 Rips 复形 Kϵ​，计算持续同调，得到持续区间 (bi​,di​)，提取特征如平均长度、最长条等。

A0-0032​

范畴论攻击

用范畴论建模安全协议的可组合性

将密码协议视为范畴中的态射，安全性条件视为某种函子下的不变性。通过检查图表是否交换，来验证协议的安全性是否在复合下保持。

定义协议范畴 Prot，对象为状态，态射为协议步骤。安全属性由函子 F:Prot→Sec表达，验证 F(f∘g)=F(f)∘F(g)。

A0-0033​

范畴论攻击

利用范畴语义分析区块链智能合约的漏洞

将智能合约的状态和执行视为范畴中的对象和态射。不变量（如余额守恒）表示为函子。通过寻找不满足交换图的路径（即存在漏洞的执行序列）。

构造状态范畴，态射为交易。守恒律表示为自然变换。漏洞对应自然性条件的破坏。

A0-0034​

泛代数攻击

克隆理论分析密码函数的完备性

研究一组密码函数（如S盒、线性层）生成的克隆（关于复合封闭的函数集）是否包含所有函数，从而判断该组函数是否具有完备性（类似于逻辑门集的完备性）。

通过计算函数的 Sheffer 性质或 Post 类来判断克隆是否等于所有布尔函数的克隆。

A0-0035​

泛代数攻击

利用项代数求解密码方程

将密码方程组视为泛代数中的等式，使用项重写系统（Term Rewriting System）来化简方程，可能得到更易求解的形式。

建立重写规则，如 x⊕x→0， x⊕0→x，然后应用规则化简方程组。

A0-0036​

微分代数攻击

针对流密码的代数攻击（微分）

将流密码的密钥流生成视为代数函数，对其求导（在布尔函数情形为布尔导数），得到次数更低的方程，从而简化代数攻击。

布尔导数：Da​f(x)=f(x)⊕f(x⊕a)。如果 f的次数为 d，则 Da​f的次数最多为 d−1。迭代应用可得线性方程。

编号​

Attack-A0-0028

类别​

表示论攻击 / 利用特征标理论分析S盒的差分均匀性

模型配方​

将S盒视为有限域 GF(2n)到 GF(2m)的函数，计算其Walsh谱（Fourier变换），其最大值与差分均匀性相关。用于评估S盒的密码学强度。模型配方：给定S盒 S:GF(2n)→GF(2m)，其Walsh变换定义为：
S^(α,β)=∑x∈GF(2n)​(−1)Tr(β⋅S(x)+α⋅x)
其中 α∈GF(2n),β∈GF(2m)，且 Tr表示迹函数。S盒的非线性度定义为：
[NL(S) = 2^{n-1} - \frac{1}{2} \max_{\alpha \in GF(2^n), \beta \in GF(2^m), \beta \neq 0}

算法/模型/方法名称​

Walsh谱计算与S盒性质分析

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：计算S盒的Walsh谱，并由此推导其非线性度和差分均匀性等指标。
步骤1：定义S盒。将S盒表示为查找表或函数。设输入空间大小为 2n，输出空间大小为 2m。
步骤2：计算Walsh变换。对每一对 (α,β)，计算：
S^(α,β)=∑x=02n−1​(−1)Tr(β⋅S(x))⊕Tr(α⋅x)
其中 Tr是迹函数，在二进制域上通常定义为 Tr(x)=x+x2+x22+⋯+x2n−1。但实际计算中，常将 α,β视为整数索引（二进制表示），而点积为按位与后求奇偶（即二进制点积）。因此，常用公式为：
S^(α,β)=∑x=02n−1​(−1)β⋅S(x)⊕α⋅x
这里 β⋅S(x)表示二进制向量点积（模2和），α⋅x同理。
步骤3：计算非线性度。遍历所有非零 β和所有 α，找到 (

精度/密度/误差/强度​

精度：计算是精确的，因为遍历所有输入输出。
强度：Walsh谱和差分分布表是衡量S盒密码学强度的两个重要指标。非线性度越高，抗线性攻击能力越强；差分均匀性越低，抗差分攻击能力越强。
复杂度：计算Walsh谱需要 O(22n+m)次运算（如果直接计算），但可以通过快速Walsh变换（FWT）降低到 O(n2n)（当 m=n时）。计算DDT需要 O(22n)次运算。因此，对于较大的 n（如 n=8），计算可行；对于 n较大（如 n>12），计算变得困难。

底层规律/理论定理​

Walsh变换：是布尔函数频域分析的工具，与线性逼近的概率相关。
Parseval恒等式：∑α,β​S^(α,β)2=22n，用于检验计算正确性。
非线性度与差分均匀性的关系：存在一些下界和上界，例如：对于 n=m的S盒，有 NL≤2n−1−2n/2−1，且 δ≥2n−1−2n/2−1。

典型应用场景​

1. S盒设计评估：在新密码算法设计时，评估S盒的密码学强度。
2. 密码标准分析：分析AES、DES等标准算法的S盒性质。
3. 侧信道攻击的预处理：在模板攻击中，使用Walsh谱分析能量消耗与数据的相关性。
4. 布尔函数研究：研究具有高非线性度、低差分均匀性的函数。
5. 白盒密码分析：分析白盒实现中S盒的代数性质。

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

- n： S盒输入比特数。
- m： S盒输出比特数。
- S： S盒函数，表示为数组或函数。
- α： 输入掩码（0 到 2n−1）。
- β： 输出掩码（0 到 2m−1）。
- S^(α,β)： Walsh变换值。
- Wmax​： Walsh变换绝对值的最大值。
- NL： 非线性度。
- δ： 差分均匀性。

状态机​

S0​: 输入S盒表 S[0..2n−1]，每个元素为m比特； S1​: 计算Walsh谱：对每个 α,β计算 S^(α,β)； S2​: 找到 Wmax​，计算 NL； S3​: 计算差分分布表：对每个 α,β统计满足 S[x]⊕S[x⊕α]=β的x的数量； S4​: 找到DDT中的最大值，得到 δ； S5​: 输出 NL,δ和可能的其他指标。

数学特征​

- 表示论：Walsh变换是群 GF(2)n上的傅里叶变换。
- 组合数学：计数、排列。
- 代数：有限域、迹函数。
- 统计：分布。

语言特征​

术语：“Walsh谱”、“非线性度”、“差分均匀性”、“差分分布表”、“线性逼近”。句式多为描述计算过程和极值寻找。

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

阶段1：初始化
1. 读取S盒表，设输入大小为 2n，输出为m比特值（通常 m=n）。
阶段2：计算Walsh谱
2. 使用快速Walsh变换（FWT）算法：
a. 初始化数组 A大小为 2n×2m？实际上，通常我们固定输出掩码 β，然后对每个 β计算一个长度为 2n的序列 fβ​(x)=(−1)β⋅S(x)，然后对这个序列做快速Walsh变换（FWT）得到 S^(α,β)对于所有 α。但注意，通常我们计算的是二维Walsh变换，不过可以通过嵌套一维FWT实现。
b. 更直接的方法：对每个 α和 β，直接求和计算。复杂度 O(22n+m)，当 n=m=8时，计算量为 224=16M，可行。
c. 计算 S^(α,β)=∑x=02n−1​(−1)β⋅S(x)⊕α⋅x，其中点积是二进制点积（按位与的奇偶）。
阶段3：计算非线性度
3. 遍历所有 α和所有非零 β，记录 (

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：计算Walsh谱和DDT时，循环是顺序的，但内层可并行。
并行序列：每个 α或 β的计算独立，可并行化。

复杂度​

时间：直接计算Walsh谱：O(22n+m)；使用FWT可降至 O((n+m)2n+m)。计算DDT：O(22n)。
空间：存储Walsh谱需要 O(2n+m)，存储DDT需要 O(2n+m)。

算法的伪代码（多种语言版本）​

Python版本：
python<br>def walsh_transform(sbox, n, m):<br> size = 1 << n<br> walsh = [[0] * (1 << m) for _ in range(size)]<br> for alpha in range(size):<br> for beta in range(1 << m):<br> total = 0<br> for x in range(size):<br> # 计算点积的奇偶性<br> if (bin(beta & sbox[x]).count('1') ^ bin(alpha & x).count('1')) & 1:<br> total -= 1<br> else:<br> total += 1<br> walsh[alpha][beta] = total<br> return walsh<br><br>def nonlinearity(walsh, n, m):<br> max_val = 0<br> for alpha in range(1 << n):<br> for beta in range(1 << m):<br> if beta == 0: continue # 忽略beta=0<br> val = abs(walsh[alpha][beta])<br> if val > max_val:<br> max_val = val<br> return (1 << (n-1)) - max_val // 2<br><br>def differential_uniformity(sbox, n, m):<br> size = 1 << n<br> ddt = [[0] * (1 << m) for _ in range(size)]<br> for a in range(size):<br> for x in range(size):<br> b = sbox[x] ^ sbox[x ^ a]<br> ddt[a][b] += 1<br> # 忽略a=0<br> delta = max(ddt[a][b] for a in range(1, size) for b in range(size))<br> return delta<br>

Go版本：
go<br>func walshTransform(sbox []uint, n, m int) [][]int {<br> size := 1 << n<br> walsh := make([][]int, size)<br> for i := range walsh {<br> walsh[i] = make([]int, 1<<m)<br> }<br> for alpha := 0; alpha < size; alpha++ {<br> for beta := 0; beta < (1 << m); beta++ {<br> total := 0<br> for x := 0; x < size; x++ {<br> if bits.OnesCount(uint(beta&sbox[x]))^bits.OnesCount(uint(alpha&x))&1 == 1 {<br> total--<br> } else {<br> total++<br> }<br> }<br> walsh[alpha][beta] = total<br> }<br> }<br> return walsh<br>}<br><br>func nonlinearity(walsh [][]int, n, m int) int {<br> maxVal := 0<br> for alpha := 0; alpha < (1 << n); alpha++ {<br> for beta := 1; beta < (1 << m); beta++ { // 忽略beta=0<br> val := walsh[alpha][beta]<br> if val < 0 {<br> val = -val<br> }<br> if val > maxVal {<br> maxVal = val<br> }<br> }<br> }<br> return (1 << (n - 1)) - maxVal/2<br>}<br><br>func differentialUniformity(sbox []uint, n, m int) int {<br> size := 1 << n<br> ddt := make([][]int, size)<br> for i := range ddt {<br> ddt[i] = make([]int, 1<<m)<br> }<br> for a := 0; a < size; a++ {<br> for x := 0; x < size; x++ {<br> b := sbox[x] ^ sbox[x^a]<br> ddt[a][b]++<br> }<br> }<br> delta := 0<br> for a := 1; a < size; a++ {<br> for b := 0; b < (1 << m); b++ {<br> if ddt[a][b] > delta {<br> delta = ddt[a][b]<br> }<br> }<br> }<br> return delta<br>}<br>

Java版本：
java<br>public class SBoxAnalysis {<br> public static int[][] walshTransform(int[] sbox, int n, int m) {<br> int size = 1 << n;<br> int[][] walsh = new int[size][1 << m];<br> for (int alpha = 0; alpha < size; alpha++) {<br> for (int beta = 0; beta < (1 << m); beta++) {<br> int total = 0;<br> for (int x = 0; x < size; x++) {<br> if ((Integer.bitCount(beta & sbox[x]) ^ Integer.bitCount(alpha & x)) & 1) == 1) {<br> total--;<br> } else {<br> total++;<br> }<br> }<br> walsh[alpha][beta] = total;<br> }<br> }<br> return walsh;<br> }<br> public static int nonlinearity(int[][] walsh, int n, int m) {<br> int maxVal = 0;<br> for (int alpha = 0; alpha < (1 << n); alpha++) {<br> for (int beta = 1; beta < (1 << m); beta++) {<br> int val = Math.abs(walsh[alpha][beta]);<br> if (val > maxVal) maxVal = val;<br> }<br> }<br> return (1 << (n - 1)) - maxVal / 2;<br> }<br> public static int differentialUniformity(int[] sbox, int n, int m) {<br> int size = 1 << n;<br> int[][] ddt = new int[size][1 << m];<br> for (int a = 0; a < size; a++) {<br> for (int x = 0; x < size; x++) {<br> int b = sbox[x] ^ sbox[x ^ a];<br> ddt[a][b]++;<br> }<br> }<br> int delta = 0;<br> for (int a = 1; a < size; a++) {<br> for (int b = 0; b < (1 << m); b++) {<br> if (ddt[a][b] > delta) delta = ddt[a][b];<br> }<br> }<br> return delta;<br> }<br>}<br>

Kotlin版本：
kotlin<br>fun walshTransform(sbox: IntArray, n: Int, m: Int): Array<IntArray> {<br> val size = 1 shl n<br> val walsh = Array(size) { IntArray(1 shl m) }<br> for (alpha in 0 until size) {<br> for (beta in 0 until (1 shl m)) {<br> var total = 0<br> for (x in 0 until size) {<br> if ((Integer.bitCount(beta and sbox[x]) xor Integer.bitCount(alpha and x)) and 1 == 1) {<br> total--<br> } else {<br> total++<br> }<br> }<br> walsh[alpha][beta] = total<br> }<br> }<br> return walsh<br>}<br>fun nonlinearity(walsh: Array<IntArray>, n: Int, m: Int): Int {<br> var maxVal = 0<br> for (alpha in 0 until (1 shl n)) {<br> for (beta in 1 until (1 shl m)) {<br> val v = Math.abs(walsh[alpha][beta])<br> if (v > maxVal) maxVal = v<br> }<br> }<br> return (1 shl (n - 1)) - maxVal / 2<br>}<br>fun differentialUniformity(sbox: IntArray, n: Int, m: Int): Int {<br> val size = 1 shl n<br> val ddt = Array(size) { IntArray(1 shl m) }<br> for (a in 0 until size) {<br> for (x in 0 until size) {<br> val b = sbox[x] xor sbox[x xor a]<br> ddt[a][b]++<br> }<br> }<br> var delta = 0<br> for (a in 1 until size) {<br> for (b in 0 until (1 shl m)) {<br> if (ddt[a][b] > delta) delta = ddt[a][b]<br> }<br> }<br> return delta<br>}<br>

C++版本：
cpp<br>#include <vector><br>#include <cmath><br>#include <bitset><br>using namespace std;<br>vector<vector<int>> walsh_transform(const vector<int>& sbox, int n, int m) {<br> int size = 1 << n;<br> vector<vector<int>> walsh(size, vector<int>(1 << m, 0));<br> for (int alpha = 0; alpha < size; ++alpha) {<br> for (int beta = 0; beta < (1 << m); ++beta) {<br> int total = 0;<br> for (int x = 0; x < size; ++x) {<br> if ((bitset<32>(beta & sbox[x]).count() ^ bitset<32>(alpha & x).count()) & 1) {<br> total--;<br> } else {<br> total++;<br> }<br> }<br> walsh[alpha][beta] = total;<br> }<br> }<br> return walsh;<br>}<br>int nonlinearity(const vector<vector<int>>& walsh, int n, int m) {<br> int max_val = 0;<br> for (int alpha = 0; alpha < (1 << n); ++alpha) {<br> for (int beta = 1; beta < (1 << m); ++beta) {<br> int val = abs(walsh[alpha][beta]);<br> if (val > max_val) max_val = val;<br> }<br> }<br> return (1 << (n-1)) - max_val / 2;<br>}<br>int differential_uniformity(const vector<int>& sbox, int n, int m) {<br> int size = 1 << n;<br> vector<vector<int>> ddt(size, vector<int>(1 << m, 0));<br> for (int a = 0; a < size; ++a) {<br> for (int x = 0; x < size; ++x) {<br> int b = sbox[x] ^ sbox[x ^ a];<br> ddt[a][b]++;<br> }<br> }<br> int delta = 0;<br> for (int a = 1; a < size; ++a) {<br> for (int b = 0; b < (1 << m); ++b) {<br> if (ddt[a][b] > delta) delta = ddt[a][b];<br> }<br> }<br> return delta;<br>}<br>

A0-0029​

表示论攻击

群表示在密码侧信道分析中的应用（模板攻击）

将能量迹视为随机过程，利用主成分分析（PCA）或线性判别分析（LDA）进行降维，这些方法本质上是表示论（群在特征空间上的作用）的应用。

寻找投影方向，使得类间散布最大，类内散布最小：J(w)=wTSW​wwTSB​w​。

A0-0030​

同调代数攻击

使用同调群分析网络拓扑的冗余路径

计算网络图（单纯复形）的同调群，特别是1维同调群 H1​，其维度（贝蒂数）等于网络中独立环路的数量，可用于识别冗余路径和潜在攻击路径。

构建链复形 C2​∂2​​C1​∂1​​C0​，计算 H1​=ker∂1​/im∂2​，β1​=rankH1​。

A0-0031​

同调代数攻击

持久同调在时间序列异常检测中的应用

对时间序列数据构建点云（例如，通过延迟嵌入），然后计算其 Rips 复形的持久同调，得到条形码。异常行为会导致条形码的持续长度分布发生变化。

对每个尺度 ϵ，构建 Rips 复形 Kϵ​，计算持续同调，得到持续区间 (bi​,di​)，提取特征如平均长度、最长条等。

A0-0032​

范畴论攻击

用范畴论建模安全协议的可组合性

将密码协议视为范畴中的态射，安全性条件视为某种函子下的不变性。通过检查图表是否交换，来验证协议的安全性是否在复合下保持。

定义协议范畴 Prot，对象为状态，态射为协议步骤。安全属性由函子 F:Prot→Sec表达，验证 F(f∘g)=F(f)∘F(g)。

A0-0033​

范畴论攻击

利用范畴语义分析区块链智能合约的漏洞

将智能合约的状态和执行视为范畴中的对象和态射。不变量（如余额守恒）表示为函子。通过寻找不满足交换图的路径（即存在漏洞的执行序列）。

构造状态范畴，态射为交易。守恒律表示为自然变换。漏洞对应自然性条件的破坏。

A0-0034​

泛代数攻击

克隆理论分析密码函数的完备性

研究一组密码函数（如S盒、线性层）生成的克隆（关于复合封闭的函数集）是否包含所有函数，从而判断该组函数是否具有完备性（类似于逻辑门集的完备性）。

通过计算函数的 Sheffer 性质或 Post 类来判断克隆是否等于所有布尔函数的克隆。

A0-0035​

泛代数攻击

利用项代数求解密码方程

将密码方程组视为泛代数中的等式，使用项重写系统（Term Rewriting System）来化简方程，可能得到更易求解的形式。

建立重写规则，如 x⊕x→0， x⊕0→x，然后应用规则化简方程组。

A0-0036​

微分代数攻击

针对流密码的代数攻击（微分）

将流密码的密钥流生成视为代数函数，对其求导（在布尔函数情形为布尔导数），得到次数更低的方程，从而简化代数攻击。

布尔导数：Da​f(x)=f(x)⊕f(x⊕a)。如果 f的次数为 d，则 Da​f的次数最多为 d−1。迭代应用可得线性方程。

编号​

Attack-A0-0029

类别​

表示论攻击 / 群表示在密码侧信道分析中的应用（模板攻击）

模型配方​

将能量迹视为随机过程，利用主成分分析（PCA）或线性判别分析（LDA）进行降维。从表示论视角看，能量迹样本构成一个向量空间，不同密钥对应的迹集合在该空间上构成一个群表示。降维过程本质上是寻找该表示的不变子空间（主成分），使得在该子空间上不同密钥类的表示可区分。模板攻击通过构建每个密钥类的多元高斯分布模板，在降维后的子空间中进行贝叶斯分类。

算法/模型/方法名称​

基于主成分分析（PCA）的模板攻击

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：从能量迹中恢复密钥字节 k。

步骤1：数据采集。对每个可能的密钥值 k∈{0,1,…,255}，采集 N条能量迹 Ti(k)​∈RL，每条对应随机明文 Pi​。得到数据集 D={(Pi​,Ti​,k)}。

步骤2：特征选择。选择与密钥相关的中间值 v=S(P⊕k)（如AES S盒输出），计算其汉明重量 HW(v)作为标签。

步骤3：降维。将所有能量迹（不区分密钥）拼接成矩阵 X∈RM×L，其中 M=256×N。对 X进行中心化：Xˉ=X−μ，其中 μ是均值向量。计算协方差矩阵 C=M−11​XˉTXˉ。对 C进行特征值分解：C=VΛVT，选择前 d个最大特征值对应的特征向量 Vd​∈RL×d作为投影矩阵。投影后的数据：Y=XˉVd​∈RM×d。

步骤4：模板构建。对每个密钥 k，将其对应的投影迹集合 Y(k)建模为多元高斯分布 N(μk​,Σk​)，其中：
μk​=N1​∑i=1N​Yi(k)​,Σk​=N−11​∑i=1N​(Yi(k)​−μk​)(Yi(k)​−μk​)T

步骤5：分类。给定一条未知密钥的能量迹 t∈RL，先投影：y=(t−μ)Vd​。然后计算后验概率：
[P(k \mid y) \propto \frac{1}{\sqrt{(2\pi)^d

精度/密度/误差/强度​

精度：在信噪比高、训练数据充足时，成功率可达99%以上。
复杂度：离线模板构建复杂度 O(ML2+L3)，在线分类 O(d3)（因需计算逆协方差）。
误差来源：噪声、模型假设（高斯性）不成立、特征选择不当。

底层规律/理论定理​

表示论：对称群在迹向量空间上的作用，PCA寻找的是该表示的不可约子空间。
多元统计：多元高斯分布、贝叶斯决策理论。
香农信息论：互信息 I(K;T)量化密钥与能量迹之间的信息泄漏。

典型应用场景​

1. 智能卡密钥提取：从AES或DES实现中恢复密钥。
2. 物联网设备攻击：对资源受限设备进行模板攻击。
3. 白盒密码实现分析：构建针对白盒实现的模板。
4. 故障攻击增强：结合故障注入，构建更精确的模板。
5. 侧信道评估：作为评估抗侧信道攻击能力的基准测试。

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

- Ti(k)​∈RL：第 k类密钥的第 i条能量迹（长度 L）。
- X∈RM×L：所有能量迹构成的矩阵。
- Vd​∈RL×d：前 d个主成分（特征向量）。
- Y(k)∈RN×d：第 k类密钥的投影迹集合。
- μk​∈Rd,Σk​∈Rd×d：第 k类模板的均值和协方差。
- P(k)：密钥先验概率（通常均匀分布）。

状态机​

S0​: 采集训练能量迹； S1​: 数据预处理（对齐、去噪）； S2​: PCA降维； S3​: 对每个密钥类，估计高斯参数 (μk​,Σk​)； S4​: 采集测试迹，投影； S5​: 计算后验概率，选择最大者； S6​: 输出密钥猜测。

数学特征​

- 线性代数：特征值分解、协方差矩阵、投影。
- 概率统计：多元高斯分布、贝叶斯推断。
- 表示论：群在向量空间上的表示、不可约分解。
- 信息论：互信息、熵。

语言特征​

术语：“模板攻击”、“主成分分析”、“多元高斯”、“后验概率”、“协方差矩阵”。句式多为统计推断和线性代数操作描述。

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

阶段1：训练
1. 对每个密钥 k=0到 255，执行：
a. 随机生成明文 P，计算 v=S(P⊕k)。
b. 采集能量迹 t，存储 (P,t,k)。
2. 构建矩阵 X，每行是一条能量迹。
3. 中心化：Xˉij​=Xij​−M1​∑i​Xij​。
4. 计算协方差矩阵 C=M−11​XˉTXˉ。
5. 特征分解：[V,Λ]=eig(C)，按特征值降序排列。
6. 选择 d使得 ∑i=1d​λi​/∑λi​≥0.95（保留95%方差）。
7. 取 Vd​=V[:,1:d]。
8. 投影：Y=XˉVd​。
9. 对每个 k，从 Y中提取对应行，计算样本均值 μk​和协方差 Σk​。

阶段2：攻击
10. 采集一条未知密钥的能量迹 t。
11. 中心化：tˉ=t−μ（μ是训练集均值）。
12. 投影：y=tˉVd​。
13. 对每个候选密钥 k，计算马氏距离：dk​=(y−μk​)TΣk−1​(y−μk​)。
14. 选择使 dk​最小的 k作为输出。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：训练阶段顺序处理每条迹，PCA和模板构建是批量操作。
并行序列：不同密钥类的模板构建可并行；协方差矩阵计算可并行化。

复杂度​

时间：PCA O(L3)，模板构建 O(256Nd2)，分类 O(256d3)。
空间：存储所有训练迹 O(ML)，协方差矩阵 O(L2)，模板 O(256d2)。

算法的伪代码（golang/C/C++）​

C++ 版本（使用Eigen库）：
cpp<br>#include <Eigen/Dense><br>#include <vector><br>using Matrix = Eigen::MatrixXd;<br>using Vector = Eigen::VectorXd;<br>struct Template {<br> Vector mean;<br> Matrix cov;<br> Matrix cov_inv; // 预计算逆<br>};<br>std::vector<Template> train_templates(<br> const Matrix& traces, // M x L<br> const std::vector<int>& keys, // 每个迹对应的密钥<br> int d // PCA维数<br>) {<br> int M = traces.rows(), L = traces.cols();<br> // 中心化<br> Vector mean = traces.colwise().mean();<br> Matrix centered = traces.rowwise() - mean.transpose();<br> // PCA<br> Matrix cov = (centered.adjoint() * centered) / (M - 1);<br> Eigen::SelfAdjointEigenSolver<Matrix> solver(cov);<br> Vector eigenvalues = solver.eigenvalues().reverse();<br> Matrix eigenvectors = solver.eigenvectors().rowwise().reverse();<br> Matrix Vd = eigenvectors.leftCols(d);<br> Matrix projected = centered * Vd; // M x d<br> // 构建每个密钥的模板<br> std::vector<Template> tmpls(256);<br> for (int k = 0; k < 256; ++k) {<br> // 提取该类所有投影迹<br> std::vector<int> indices;<br> for (int i = 0; i < M; ++i) if (keys[i] == k) indices.push_back(i);<br> int nk = indices.size();<br> Matrix class_traces(nk, d);<br> for (int i = 0; i < nk; ++i) class_traces.row(i) = projected.row(indices[i]);<br> tmpls[k].mean = class_traces.colwise().mean();<br> Matrix centered_class = class_traces.rowwise() - tmpls[k].mean.transpose();<br> tmpls[k].cov = (centered_class.adjoint() * centered_class) / (nk - 1);<br> // 正则化防止奇异<br> tmpls[k].cov += 1e-6 * Matrix::Identity(d, d);<br> tmpls[k].cov_inv = tmpls[k].cov.inverse();<br> }<br> return tmpls;<br>}<br>int attack(const Vector& trace, const std::vector<Template>& tmpls,<br> const Vector& global_mean, const Matrix& Vd) {<br> Vector y = (trace - global_mean).transpose() * Vd; // 投影<br> double best_score = std::numeric_limits<double>::max();<br> int best_key = -1;<br> for (int k = 0; k < 256; ++k) {<br> Vector diff = y - tmpls[k].mean;<br> double score = diff.transpose() * tmpls[k].cov_inv * diff;<br> if (score < best_score) { best_score = score; best_key = k; }<br> }<br> return best_key;<br>}<br>

Go 版本（使用gonum库）：
go<br>package main<br>import ("gonum.org/v1/gonum/mat"; "gonum.org/v1/gonum/stat")<br>type Template struct {<br> mean *mat.VecDense; cov *mat.Dense; covInv *mat.Dense<br>}<br>func TrainTemplates(traces *mat.Dense, keys []int, d int) ([]Template, *mat.VecDense, *mat.Dense) {<br> m, l := traces.Dims()<br> // 中心化<br> mean := mat.NewVecDense(l, nil)<br> for i := 0; i < l; i++ { mean.SetVec(i, stat.Mean(traces.ColView(i).(*mat.VecDense), nil) }<br> centered := mat.NewDense(m, l, nil)<br> centered.Sub(traces, mat.NewVecDense(m, mat.Row(nil, 0, mean)).(*mat.VecDense).T())<br> // PCA (简化，实际应用SVD)<br> var cov mat.Dense; cov.Mul(centered.T(), centered); cov.Scale(1/float64(m-1), &cov)<br> var eig mat.Eigen; eig.Factorize(&cov, mat.EigenRight)<br> eigenvalues := eig.Values(nil); eigenvectors := mat.NewDense(l, l, nil)<br> // 排序并取前d个（此处略去排序代码）<br> Vd := eigenvectors.Slice(0, l, 0, d).(*mat.Dense)<br> var projected mat.Dense; projected.Mul(centered, Vd) // m x d<br> // 构建模板<br> tmpls := make([]Template, 256)<br> for k := 0; k < 256; k++ {<br> // 收集该类索引<br> var indices []int<br> for i := 0; i < m; i++ { if keys[i] == k { indices = append(indices, i) } }<br> nk := len(indices); classTraces := mat.NewDense(nk, d, nil)<br> for i, idx := range indices { classTraces.SetRow(i, mat.Row(nil, idx, &projected)) }<br> meanK := mat.NewVecDense(d, nil)<br> for j := 0; j < d; j++ { meanK.SetVec(j, stat.Mean(classTraces.ColView(j).(*mat.VecDense), nil)) }<br> centeredClass := mat.NewDense(nk, d, nil)<br> centeredClass.Sub(classTraces, mat.NewVecDense(nk, mat.Row(nil, 0, meanK)).(*mat.VecDense).T())<br> var covK mat.Dense; covK.Mul(centeredClass.T(), centeredClass); covK.Scale(1/float64(nk-1), &covK)<br> // 正则化<br> for j := 0; j < d; j++ { covK.Set(j, j, covK.At(j, j)+1e-6) }<br> var covInv mat.Dense; covInv.Inverse(&covK)<br> tmpls[k] = Template{meanK, &covK, &covInv}<br> }<br> return tmpls, mean, Vd<br>}<br>func Attack(trace *mat.VecDense, tmpls []Template, mean *mat.VecDense, Vd *mat.Dense) int {<br> var centered, y mat.VecDense; centered.SubVec(trace, mean)<br> y.MulVec(Vd.T(), &centered) // 投影<br> bestScore, bestKey := math.MaxFloat64, -1<br> for k := 0; k < 256; k++ {<br> var diff mat.VecDense; diff.SubVec(&y, tmpls[k].mean)<br> var tmp mat.VecDense; tmp.MulVec(tmpls[k].covInv, &diff)<br> score := mat.Dot(&diff, &tmp)<br> if score < bestScore { bestScore, bestKey = score, k }<br> }<br> return bestKey<br>}<br>

编号​

Attack-A0-0030

类别​

同调代数攻击 / 使用同调群分析网络拓扑的冗余路径

模型配方​

将网络拓扑建模为图 G=(V,E)，进而构造其单纯复形（如将每条边视为1-单形，每个三角形视为2-单形）。计算该复形的同调群，特别是一维同调群 H1​。H1​的秩（即贝蒂数 β1​）等于网络中独立环路（非边界循环）的数量，反映了网络的冗余性。攻击者可利用此信息识别关键链路（割边）或规划备用攻击路径。模型配方为：构建网络图的邻接矩阵，导出边界算子矩阵 D1​，计算 H1​=kerD1​/imD2​，其中 D2​是二维边界算子。

算法/模型/方法名称​

基于单纯同调的网络环路分析

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：计算网络拓扑的一维贝蒂数 β1​和一组基循环，以分析冗余路径。

步骤1：构造单纯复形。给定无向图 G=(V,E)，将其视为1维单纯复形 K，其中0-单形是顶点，1-单形是边。可选地，添加所有三角形（3-团）作为2-单形。

步骤2：构建链群。定义链群：
- C0​：以顶点为基的自由阿贝尔群（或向量空间，系数取 Z2​）。
- C1​：以边为基。
- C2​：以三角形为基（如果添加了2-单形）。

步骤3：计算边界算子。边界算子 ∂k​:Ck​→Ck−1​在基上的作用：
- 对边 e=[vi​,vj​]，∂1​(e)=vj​−vi​（在 Z2​中为 vi​+vj​）。
- 对三角形 t=[va​,vb​,vc​]，∂2​(t)=[vb​,vc​]−[va​,vc​]+[va​,vb​]（在 Z2​中为三边之和）。
将 ∂1​表示为矩阵 (D_1 \in \mathbb{Z}^{

精度/密度/误差/强度​

精度：基于线性代数，计算精确。
复杂度：矩阵秩和零空间计算，(O(\min(

底层规律/理论定理​

同调代数：链复形、同调群、贝蒂数。
图论：欧拉公式、环路空间维数公式。
线性代数：矩阵的秩、零空间、商空间。

典型应用场景​

1. 网络渗透测试路径规划：识别多个独立环路，提供多条潜在攻击路径。
2. 关键基础设施网络韧性分析：通过 β1​评估网络冗余度，β1​高表示韧性好。
3. 通信网络可靠性设计：确保有足够环路（高 β1​）以实现容错。
4. 社交网络结构分析：识别紧密团体（clique）形成的环路。
5. 网络协议分析：如检测路由环路。

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

- G=(V,E)：无向图，(

状态机​

S0​: 输入图 G； S1​: 构造边界算子矩阵 D1​； S2​: 计算秩 r=rank(D1​)，连通分支数 β0​=n−r； S3​: 计算 β1​=m−n+β0​； S4​: 计算 D1​的零空间基，得到独立环路； S5​: 输出 β1​和基循环。

数学特征​

- 代数拓扑：单纯同调、链复形。
- 线性代数：矩阵运算、秩、零空间。
- 图论：环路空间、连通性。

语言特征​

术语：“同调群”、“贝蒂数”、“边界算子”、“闭链”、“边缘链”、“单纯复形”。句式多为构造矩阵和计算秩、零空间。

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

阶段1：构造矩阵
1. 输入图 G，顶点集 V={v1​,…,vn​}，边集 E={e1​,…,em​}。
2. 构造矩阵 D1​∈Z2n×m​：对每条边 ek​=(vi​,vj​)，设置 D1​[i,k]=1,D1​[j,k]=1（模2加法，即1+1=0）。

阶段2：计算贝蒂数
3. 计算 D1​的秩 r（例如通过高斯消元法）。
4. 计算连通分支数：β0​=n−r。
5. 计算一维贝蒂数：β1​=m−n+β0​。

阶段3：计算环路基
6. 解线性方程组 D1​⋅x=0，求零空间基。具体：对 D1​进行行简化阶梯形（RREF）变换，得到自由变量对应的解向量，每个自由变量对应一个基循环。
7. 每个基向量 x∈Z2m​表示一个环路：非零分量对应的边构成一个闭合路径。

阶段4：输出
8. 输出 β1​和一组基循环（边的集合）。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：矩阵构造和消元是顺序的。
并行序列：矩阵秩和零空间计算可使用并行线性代数库。

复杂度​

时间：高斯消元 O(n2m)，但实际中 n,m是网络规模，通常可接受。
空间：存储矩阵 O(nm)。

算法的伪代码（golang/C/C++）​

C++ 版本（使用Eigen库，模2运算需自定义）：
cpp<br>#include <Eigen/Dense><br>#include <vector><br>#include <utility><br>// 模2矩阵类型<br>using MatrixZ2 = Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic>;<br>std::pair<int, std::vector<Eigen::VectorXi>> compute_homology(<br> const std::vector<std::pair<int, int>>& edges, int n) {<br> int m = edges.size();<br> MatrixZ2 D1(n, m);<br> D1.setZero();<br> for (int j = 0; j < m; ++j) {<br> int u = edges[j].first, v = edges[j].second;<br> D1(u, j) = 1; D1(v, j) = 1; // 模2加法<br> }<br> // 计算秩：高斯消元（模2）<br> MatrixZ2 R = D1; // 复制<br> int rank = 0;<br> for (int col = 0, row = 0; col < m && row < n; ++col) {<br> // 寻找主元<br> int pivot = row;<br> while (pivot < n && R(pivot, col) == 0) ++pivot;<br> if (pivot == n) continue; // 该列全零<br> // 交换行<br> R.row(row).swap(R.row(pivot));<br> // 消去该列其他行<br> for (int i = 0; i < n; ++i) {<br> if (i != row && R(i, col) == 1) R.row(i) += R.row(row); // 模2加法<br> }<br> ++row; ++rank;<br> }<br> int beta0 = n - rank;<br> int beta1 = m - n + beta0;<br> // 计算零空间基（简化，实际需从RREF读取）<br> // 此处省略，实际需解 D1 * x = 0<br> std::vector<Eigen::VectorXi> cycles; // 每个VectorXi长度为m<br> // ... 零空间计算代码 ...<br> return {beta1, cycles};<br>}<br>

Go 版本（使用gonum库，但需实现模2运算）：
go<br>package main<br>import "gonum.org/v1/gonum/mat"<br>func mod2Add(a, b float64) float64 { if a == b { return 0 } else { return 1 } }<br>func computeHomology(edges [][2]int, n int) (int, []mat.Vector) {<br> m := len(edges)<br> data := make([]float64, n*m)<br> for j, e := range edges {<br> u, v := e[0], e[1]<br> data[u*m+j] = 1<br> data[v*m+j] = 1 // 模2，但存储为浮点数<br> }<br> D1 := mat.NewDense(n, m, data)<br> // 计算秩（高斯消元，模2）<br> // 此处简化，假设有秩函数（实际需实现模2消元）<br> rank := naiveRankMod2(D1)<br> beta0 := n - rank<br> beta1 := m - n + beta0<br> // 计算零空间基（略）<br> var cycles []mat.Vector<br> return beta1, cycles<br>}<br>func naiveRankMod2(D *mat.Dense) int {<br> // 实现模2高斯消元求秩<br> n, m := D.Dims()<br> mat := mat.DenseCopyOf(D)<br> rank := 0<br> for col, row := 0, 0; col < m && row < n; col++ {<br> pivot := row<br> for pivot < n && mat.At(pivot, col) == 0 { pivot++ }<br> if pivot == n { continue }<br> // 交换行<br> if pivot != row {<br> mat.SwapRows(pivot, row)<br> }<br> // 消去<br> for i := 0; i < n; i++ {<br> if i != row && mat.At(i, col) == 1 {<br> for j := col; j < m; j++ {<br> val := mod2Add(mat.At(i, j), mat.At(row, j))<br> mat.Set(i, j, val)<br> }<br> }<br> }<br> row++<br> rank++<br> }<br> return rank<br>}<br>

编号​

Attack-A0-0031

类别​

同调代数攻击 / 持久同调在时间序列异常检测中的应用

模型配方​

对时间序列数据构建点云（例如，通过延迟嵌入），然后计算其 Rips 复形的持久同调，得到条形码。异常行为会导致条形码的持续长度分布发生变化。模型配方：给定时间序列 y1​,y2​,…,yT​，通过延迟嵌入将其转化为点云，然后对点云构建Rips滤，计算其持久同调，提取拓扑特征（如条码的持续长度、数量），用于检测异常。

算法/模型/方法名称​

基于持久同调的时间序列异常检测

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：从时间序列中提取拓扑特征，检测异常。

步骤1：时间序列嵌入。采用延迟嵌入法将一维时间序列嵌入到 d维空间。给定时间延迟 τ和嵌入维数 m，构造点云：
xt​=(yt​,yt+τ​,yt+2τ​,…,yt+(m−1)τ​)∈Rm
其中 t=1,2,…,T−(m−1)τ。

步骤2：构建Rips滤。对点云 {xi​}i=1N​，给定一个距离阈值 ϵ，构建一个单纯复形 Kϵ​，其中每个 k-单形由 k+1个两两距离不超过 ϵ的点构成。随着 ϵ从0增加到某个最大值，得到一组嵌套的复形 Kϵ0​​⊆Kϵ1​​⊆⋯⊆Kϵn​​，称为滤。

步骤3：计算持久同调。对每个维度 p（通常 p=0,1,2），计算滤的持久同调。这记录了拓扑特征（如连通分支、环、空洞）的“出生”和“死亡”阈值。算法上，通过计算边界矩阵的约化形式（如标准持久同调算法）得到持续区间 (bi​,di​)，其中 bi​是特征出生时的 ϵ，di​是死亡时的 ϵ。

步骤4：提取特征。从持续区间中提取特征向量，例如：
- 各维度的持续区间的个数。
- 持续长度的统计量（均值、方差、中位数、最大值等）。
- 持续区间的累积分布函数的分位数。

步骤5：异常检测。使用正常时间序列训练一个模型（如单类SVM、孤立森林）学习正常拓扑特征的分布。对新的时间序列，提取拓扑特征，若偏离正常分布则判为异常。

精度/密度/误差/强度​

精度：依赖于嵌入参数和特征选择，能捕捉传统方法难以发现的拓扑异常。
复杂度：计算Rips滤的持久同调最坏是指数复杂度，但对小点云和低维同调可行。
强度：对数据的整体形状变化敏感，适合检测周期性破坏、相位突变等。

底层规律/理论定理​

Takens嵌入定理：在适当条件下，延迟嵌入可以重建动力系统的相空间。
持久同调理论：提供了一种多尺度拓扑特征描述方法。
拓扑数据分析：将数据视为形状，用拓扑工具分析。

典型应用场景​

1. 网络流量异常检测：DDoS攻击可能导致流量时间序列的周期性模式破坏。
2. 传感器数据异常：工业传感器读数中的异常模式。
3. 心电图（ECG）分析：心律失常会导致心电信号拓扑结构变化。
4. 金融时间序列：市场震荡可能引起拓扑特征突变。
5. 语音信号处理：检测语音中的异常片段。

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

- yt​：时间序列，t=1,…,T。
- m：嵌入维数。
- τ：延迟步长。
- ϵ：Rips复形的距离阈值。
- Kϵ​：距离阈值为 ϵ时的单纯复形。
- (bi​,di​)：持续区间，表示一个拓扑特征的出生和死亡。
- 特征向量：从持续区间提取的统计特征。

状态机​

S0​: 输入时间序列； S1​: 延迟嵌入得到点云； S2​: 构建Rips滤； S3​: 计算持久同调，得到条码； S4​: 提取拓扑特征向量； S5​: 与正常模型比较，判断异常。

数学特征​

- 拓扑学：单纯复形、同调、持续同调。
- 动力系统：时间序列嵌入。
- 统计学：特征提取、假设检验。

语言特征​

术语：“持久同调”、“Rips滤”、“条码”、“出生”、“死亡”、“拓扑特征”。句式多为描述拓扑构造和特征提取。

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

阶段1：嵌入
1. 给定时间序列 y1​,…,yT​，选择参数 m和 τ。
2. 构造点云 X={xt​}，其中 xt​=(yt​,yt+τ​,…,yt+(m−1)τ​)，t=1,…,T−(m−1)τ。

阶段2：构建Rips滤
3. 计算点云中所有点对之间的欧氏距离矩阵 D，其中 Dij​=∥xi​−xj​∥。
4. 选择一组递增的阈值 ϵ0​=0,ϵ1​,…,ϵn​=maxDij​。
5. 对每个 ϵk​，构造Rips复形 Kϵk​​：当且仅当 Dij​≤ϵk​时，点 i和 j之间有边；当且仅当所有点对距离 ≤ϵk​时，更高维单形被添加。

阶段3：计算持久同调
6. 使用标准算法（如矩阵约简）计算滤的持久同调。对于每个维度 p，输出一组持续区间 {(bi​,di​)}。

阶段4：特征提取
7. 对每个维度 p，计算：
- 持续区间的个数 Np​。
- 持续长度 li​=di​−bi​的统计量：均值 μp​，方差 σp2​，最大值 Lpmax​。
- 持续长度的总和等。
8. 将所有特征拼接成特征向量 f。

阶段5：异常检测
9. 训练阶段：在正常时间序列上提取特征，训练一个单类分类器（如One-Class SVM）。
10. 测试阶段：对新时间序列提取特征，输入分类器，若分类器判定为异常则报警。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：嵌入和滤构造是顺序的，持久同调计算是顺序算法。
并行序列：点对距离计算可并行；不同维度的同调可并行计算。

复杂度​

时间：Rips复形构造 O(N3)（考虑所有单形），持久同调计算最坏 O(N3)，但实际中通过稀疏化加速。
空间：存储距离矩阵 O(N2)。

算法的伪代码（golang/C/C++）​

C++ 版本（使用GUDHI库）：
cpp<br>#include <gudhi/Simplex_tree.h><br>#include <gudhi/Rips_complex.h><br>#include <gudhi/Persistent_cohomology.h><br>#include <vector><br>#include <cmath><br>// 假设已有时间序列 data，长度 T<br>std::vector<std::vector<double>> delay_embedding(const std::vector<double>& data, int dim, int delay) {<br> std::vector<std::vector<double>> points;<br> for (int i = 0; i <= data.size() - dim * delay; ++i) {<br> std::vector<double> point;<br> for (int d = 0; d < dim; ++d)<br> point.push_back(data[i + d * delay]);<br> points.push_back(point);<br> }<br> return points;<br>}<br>void compute_persistence(const std::vector<std::vector<double>>& points, double max_edge) {<br> // 构建Rips复形<br> using Simplex_tree = Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_fast_persistence>;<br> using Rips_complex = Gudhi::rips_complex::Rips_complex<double>;<br> Rips_complex rips_complex(points, max_edge, Gudhi::Euclidean_distance());<br> Simplex_tree simplex_tree;<br> rips_complex.create_complex(simplex_tree, 2); // 2维<br> // 计算持久同调<br> using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Gudhi::persistent_cohomology::Field_Zp>;<br> Persistent_cohomology pcoh(simplex_tree);<br> pcoh.init_coefficients(2); // 系数域 Z/2Z<br> pcoh.compute_persistent_cohomology();<br> // 输出条码<br> pcoh.output_diagram();<br>}<br>int main() {<br> std::vector<double> time_series = {...}; // 时间序列数据<br> int embed_dim = 3, delay = 1;<br> double max_edge = 10.0;<br> auto points = delay_embedding(time_series, embed_dim, delay);<br> compute_persistence(points, max_edge);<br> return 0;<br>}<br>

Go 版本（无成熟库，示意算法）：
go<br>package main<br>import ("math"; "sort")<br>type Simplex struct { vertices []int; dim int }<br>type Filtration []Simplex<br>// 延迟嵌入<br>func DelayEmbedding(data []float64, m, tau int) [][]float64 {<br> var points [][]float64<br> for i := 0; i <= len(data)-m*tau; i++ {<br> pt := make([]float64, m)<br> for d := 0; d < m; d++ { pt[d] = data[i+d*tau] }<br> points = append(points, pt)<br> }<br> return points<br>}<br>// 计算点对距离矩阵<br>func DistanceMatrix(points [][]float64) [][]float64 {<br> n := len(points)<br> dist := make([][]float64, n)<br> for i := range dist { dist[i] = make([]float64, n) }<br> for i := 0; i < n; i++ {<br> for j := i+1; j < n; j++ {<br> d := 0.0<br> for k := range points[i] { d += math.Pow(points[i][k]-points[j][k], 2) }<br> dist[i][j] = math.Sqrt(d)<br> dist[j][i] = dist[i][j]<br> }<br> }<br> return dist<br>}<br>// 构建Rips滤（简化，只考虑0维和1维）<br>func BuildRipsFiltration(dist [][]float64, maxEpsilon float64) Filtration {<br> var filtration Filtration<br> n := len(dist)<br> // 添加0-单形（顶点）<br> for i := 0; i < n; i++ { filtration = append(filtration, Simplex{[]int{i}, 0}) }<br> // 添加1-单形（边）<br> for i := 0; i < n; i++ {<br> for j := i+1; j < n; j++ {<br> if dist[i][j] <= maxEpsilon {<br> filtration = append(filtration, Simplex{[]int{i, j}, 1})<br> }<br> }<br> }<br> // 按距离排序（此处简化）<br> return filtration<br>}<br>// 持久同调计算（0维）<br>func ZeroDimPersistence(filtration Filtration) []float64 {<br> // 使用并查集算法计算0维持续同调<br> // 返回持续长度（死亡时间-出生时间）<br> // 此处省略实现<br> return nil<br>}<br>

编号​

Attack-A0-0032

类别​

范畴论攻击 / 用范畴论建模安全协议的可组合性

模型配方​

将密码协议视为范畴中的态射，安全性条件视为某种函子下的不变性。通过检查图表是否交换，来验证协议的安全性是否在复合下保持。模型配方：定义范畴 Prot，其对象是协议参与方的状态，态射是协议步骤（如发送消息、密钥交换）。安全性属性通过函子 F:Prot→Sec映射到安全范畴，其中对象是安全级别，态射是安全变换。可组合性要求：对于两个协议 f:A→B和 g:B→C，复合协议 g∘f的安全性应满足 F(g∘f)=F(g)∘F(f)，即图表交换。

算法/模型/方法名称​

基于范畴论的安全协议组合验证

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：验证两个或多个安全协议组合后是否仍满足安全性属性。

步骤1：定义范畴。定义协议范畴 Prot：
- 对象：系统状态集合，通常包括参与方知识、随机数、密钥等。
- 态射：协议步骤，如消息传递、加密、解密等。态射的组合是协议的顺序执行。

步骤2：定义安全函子。定义函子 F:Prot→Sec，将协议映射到安全属性。例如，Sec​ 可以是部分序集范畴，对象是安全级别（如 IND-CPA, IND-CCA），态射是安全级别的提升（或降低）。函子将每个协议态射映射为一个安全性变换。

步骤3：形式化协议。将待验证的协议 P分解为基本态射的组合：P=fn​∘fn−1​∘⋯∘f1​。每个基本态射对应一个已分析过的子协议或原语。

步骤4：验证函子保持复合。需要证明：
F(P)=F(fn​∘⋯∘f1​)=F(fn​)∘⋯∘F(f1​)
右边是已知安全性的组合。如果等式成立，则组合协议的安全性可由子协议的安全性推导。

步骤5：图表交换。将协议组合表示为交换图。例如，两个协议 P1​:A→B和 P2​:B→C组合为 P2​∘P1​:A→C。安全性函子作用后，要求下图交换：
<br>\begin{CD}<br>F(A) @>F(P_1)>> F(B) \\<br>@V F(P_2 \circ P_1) VV @VV F(P_2) V \\<br>F(C) @= F(C)<br>\end{CD}<br>
即 F(P2​)∘F(P1​)=F(P2​∘P1​)。

步骤6：反例构造。如果图表不交换，则存在反例，表明组合可能不安全。可构造具体攻击场景。

精度/密度/误差/强度​

精度：形式化方法，可严格证明。
复杂度：依赖于协议的复杂性和安全属性的形式化程度。
强度：能揭示深层次的可组合性问题，但需要深厚的范畴论知识。

底层规律/理论定理​

范畴论：函子、自然变换、交换图。
密码协议形式化：如应用π演算、CryptoVerif等。
可组合性理论：普遍可组合（UC）框架是特例。

典型应用场景​

1. TLS协议套件组合：验证不同版本的握手协议和记录层协议组合的安全性。
2. 安全信道建立：验证密钥交换协议与后续加密协议组合的安全性。
3. 多方计算协议：验证子协议组合后的安全性。
4. 区块链协议层：验证共识层与交易层的安全组合。
5. 形式化验证工具：用于自动化协议验证。

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

- Prot：协议范畴，对象为状态，态射为协议步骤。
- Sec：安全范畴，对象为安全属性，态射为属性间的蕴含关系。
- F:Prot→Sec：安全函子。
- P,Q：协议（态射）。
- F(P)：协议 P的安全属性。

状态机​

S0​: 定义协议范畴和安全范畴； S1​: 定义安全函子 F； S2​: 将协议分解为态射组合； S3​: 计算 F在各态射上的作用； S4​: 检查图表是否交换； S5​: 若交换，则组合安全；否则，构造反例。

数学特征​

- 范畴论：函子、交换图、自然变换。
- 逻辑：形式化验证、模型检测。
- 代数：态射的组合、结构保持。

语言特征​

术语：“范畴”、“函子”、“交换图”、“可组合性”、“自然变换”。句式多为定义函子和检查图表交换。

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

阶段1：建立范畴模型
1. 识别协议中的状态：例如，Alice和Bob的初始知识、共享密钥、随机数等。这些作为对象。
2. 识别基本操作：如“发送消息m”、“用密钥k加密m”、“解密”等。这些作为基本态射。
3. 定义态射组合：顺序执行。

阶段2：定义安全函子
4. 定义安全范畴 Sec：对象可以是安全游戏（如IND-CPA游戏），态射是游戏之间的归约。
5. 定义函子 F：将每个协议态射映射到其安全性归约。例如，一次OTP加密映射为完美保密性。

阶段3：协议分解
6. 将待验证协议 P写为基本态射的组合：P=f1​∘f2​∘⋯∘fn​。

阶段4：验证交换性
7. 计算左边：F(P)，即整个协议的安全属性。
8. 计算右边：F(f1​)∘F(f2​)∘⋯∘F(fn​)，即子协议安全属性的组合。
9. 比较两边是否相等（或在安全范畴中等价）。

阶段5：结论
10. 如果相等，则协议组合安全；否则，存在可组合性漏洞。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：范畴定义和验证是顺序的。
并行序列：不同子协议的安全验证可并行。

复杂度​

时间：依赖于协议规模和安全性属性的复杂度。
空间：存储范畴和函子的定义。

算法的伪代码（golang/C/C++）​

C++ 版本（高度抽象，仅示意）：
cpp<br>#include <functional><br>#include <vector><br>// 定义状态类型（简化）<br>struct State { /* ... */ };<br>// 定义协议态射（函数对象）<br>using ProtocolMorphism = std::function<State(State)>;<br>// 定义安全属性类型<br>enum SecurityProperty { NONE, IND_CPA, IND_CCA, /* ... */ };<br>// 安全函子：将协议态射映射为安全属性（简化）<br>SecurityProperty security_functor(const ProtocolMorphism& f) {<br> // 实际中需要根据协议步骤分析安全性<br> if (is_encryption(f)) return IND_CPA;<br> // ...<br> return NONE;<br>}<br>// 协议组合<br>ProtocolMorphism compose(const std::vector<ProtocolMorphism>& fs) {<br> return [fs](State s) {<br> for (auto& f : fs) s = f(s);<br> return s;<br> };<br>}<br>// 验证可组合性<br>bool check_composition(const std::vector<ProtocolMorphism>& fs) {<br> SecurityProperty left = security_functor(compose(fs));<br> // 右侧：组合安全属性（这里用最小安全属性，简化）<br> SecurityProperty right = NONE;<br> for (auto& f : fs) {<br> SecurityProperty prop = security_functor(f);<br> right = std::min(right, prop); // 假设安全属性有偏序<br> }<br> return left == right;<br>}<br>

Go 版本：
go<br>package main<br>type State struct{}<br>type ProtocolMorphism func(State) State<br>type SecurityProperty int<br>const ( None SecurityProperty = iota; IND_CPA; IND_CCA )<br>func securityFunctor(f ProtocolMorphism) SecurityProperty {<br> // 分析f的安全性<br> return None<br>}<br>func compose(fs []ProtocolMorphism) ProtocolMorphism {<br> return func(s State) State {<br> for _, f := range fs { s = f(s) }<br> return s<br> }<br>}<br>func checkComposition(fs []ProtocolMorphism) bool {<br> left := securityFunctor(compose(fs))<br> right := None<br> for _, f := range fs {<br> prop := securityFunctor(f)<br> if prop < right { right = prop } // 假设安全属性有序<br> }<br> return left == right<br>}<br>

编号​

Attack-A0-0033

类别​

范畴论攻击 / 利用范畴语义分析区块链智能合约的漏洞

模型配方​

将智能合约的状态和执行视为范畴中的对象和态射。不变量（如余额守恒）表示为函子。通过寻找不满足交换图的路径（即存在漏洞的执行序列）。模型配方：定义范畴 Contract，对象是合约状态（包括余额、变量值等），态射是交易（函数调用）。安全不变量是函子 F:Contract→Invariant，将状态映射到不变量是否满足。漏洞对应于存在态射（交易序列）使得 F不保持，即 F(f(s))=F(s)，导致不变量被破坏。

算法/模型/方法名称​

基于范畴论的不变量漏洞检测

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：检测智能合约中违反不变量的交易序列。

步骤1：定义合约范畴。定义范畴 Contract：
- 对象：状态 S=(storage,balance,…)。
- 态射：交易 t:S→S′，表示执行合约函数后的状态转移。

步骤2：形式化不变量。不变量是状态上的谓词，如“总余额守恒”。将其表示为函子 F:Contract→Invariant，其中 Invariant​ 是只有两个对象（True, False）的范畴，态射是蕴含关系。函子将状态映射到不变量是否成立（True/False），并要求态射（交易）保持不变量：即如果 F(S)=True，则对任意可达态射 t:S→S′，应有 F(S′)=True。这对应于自然变换的条件。

步骤3：搜索违反路径。寻找状态 S和交易序列 t1​,t2​,…,tn​，使得 F(S)=True，但 F(tn​∘⋯∘t1​(S))=False。这可以通过符号执行或模型检测实现。

步骤4：交换图表示。不变量保持要求下图交换：
<br>\begin{CD}<br>S @>t>> S' \\<br>@V F VV @VV F V \\<br>True @>>id> True<br>\end{CD}<br>
如果存在 t使得 F(S′)=False，则图表不交换，发现漏洞。

步骤5：漏洞分类。根据不变量类型分类漏洞：重入、整数溢出、权限绕过等。

精度/密度/误差/强度​

精度：形式化方法，可精确检测违反不变量的路径。
复杂度：状态空间爆炸问题，需借助抽象解释、符号执行等优化。
强度：能发现深层的逻辑漏洞，但依赖于不变量的正确形式化。

底层规律/理论定理​

范畴论：函子、自然性条件、交换图。
形式化验证：霍尔逻辑、模型检测。
智能合约安全：常见漏洞模式。

典型应用场景​

1. 以太坊智能合约审计：检测重入、溢出等漏洞。
2. DeFi协议安全分析：验证资金池不变量的保持。
3. 跨链桥合约：验证锁定/铸造的守恒性。
4. 形式化验证工具：如K框架、Isabelle/HOL等。
5. 漏洞模式库构建：将常见漏洞抽象为不变量破坏模式。

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

- Contract：智能合约范畴，对象为状态，态射为交易。
- F:Contract→Invariant：不变量函子。
- S,S′：状态。
- t:S→S′：交易（态射）。
- 不变量谓词：如 inv(S)=(totalSupply==balanceOf[owner]+…)。

状态机​

S0​: 定义合约状态和交易； S1​: 形式化不变量谓词，定义函子 F； S2​: 从初始状态开始，探索状态空间； S3​: 对每个状态和交易，检查是否保持不变量； S4​: 若发现违反，则记录漏洞路径； S5​: 输出漏洞报告。

数学特征​

- 范畴论：函子、交换图。
- 逻辑：谓词逻辑、霍尔三元组。
- 计算机科学：形式化方法、程序语义。

语言特征​

术语：“不变量”、“函子”、“交换图”、“状态转移”、“漏洞路径”。句式多为定义函子和检查交换图。

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

阶段1：建模
1. 定义状态结构：包括所有存储变量、余额等。
2. 定义交易：每个合约函数对应一个态射，输入状态和参数，输出新状态。

阶段2：形式化不变量
3. 编写不变量谓词，例如：
inv(S)=S.totalSupply=∑addr​S.balance[addr]
4. 定义函子 F：F(S)=True如果 inv(S)成立，否则 False。

阶段3：探索状态空间
5. 从初始状态 S0​开始，生成所有可能的交易序列（深度受限）。
6. 对每个状态 S和每个可用交易 t，计算新状态 S′=t(S)。
7. 检查不变量：如果 inv(S)为真但 inv(S′)为假，则发现漏洞。

阶段4：漏洞验证
8. 对漏洞路径，生成具体测试用例（参数值）。
9. 在真实环境（如测试网）复现漏洞。

阶段5：修复
10. 修改合约，确保不变量保持。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：状态探索通常是顺序的，但可用并行或符号执行加速。
分布式序列：状态空间探索可分布式进行。

复杂度​

时间：最坏是指数级，但通过抽象和符号执行可改善。
空间：存储状态图，可能很大。

算法的伪代码（golang/C/C++）​

C++ 版本（简化，使用符号执行思想）：
cpp<br>#include <vector><br>#include <functional><br>struct State {<br> int totalSupply;<br> std::map<Address, int> balance;<br> // ... 其他变量<br>};<br>using Transaction = std::function<State(const State&, const std::vector<int>& args)>;<br>// 不变量谓词<br>bool invariant(const State& s) {<br> int sum = 0;<br> for (auto& [addr, bal] : s.balance) sum += bal;<br> return s.totalSupply == sum;<br>}<br>// 漏洞检测<br>struct Vulnerability { State from; Transaction t; std::vector<int> args; };<br>std::vector<Vulnerability> check_invariant(const State& init, const std::vector<Transaction>& txs) {<br> std::vector<Vulnerability> vulns;<br> // 状态空间探索（深度优先，有限深度）<br> std::function<void(State, int)> dfs = [&](State s, int depth) {<br> if (depth > 5) return; // 限制深度<br> for (auto& t : txs) {<br> // 生成随机参数（实际应用符号执行）<br> std::vector<int> args = generate_args(t);<br> State s2 = t(s, args);<br> if (invariant(s) && !invariant(s2)) {<br> vulns.push_back({s, t, args});<br> }<br> dfs(s2, depth+1);<br> }<br> };<br> dfs(init, 0);<br> return vulns;<br>}<br>

Go 版本：
go<br>package main<br>import "fmt"<br>type State struct {<br> totalSupply int<br> balance map[Address]int<br>}<br>type Transaction func(State, []int) State<br>func invariant(s State) bool {<br> sum := 0<br> for _, bal := range s.balance { sum += bal }<br> return s.totalSupply == sum<br>}<br>func checkInvariant(init State, txs []Transaction, maxDepth int) []Vulnerability {<br> var vulns []Vulnerability<br> var dfs func(State, int)<br> dfs = func(s State, depth int) {<br> if depth > maxDepth { return }<br> for _, t := range txs {<br> args := generateArgs()<br> s2 := t(s, args)<br> if invariant(s) && !invariant(s2) {<br> vulns = append(vulns, Vulnerability{s, t, args})<br> }<br> dfs(s2, depth+1)<br> }<br> }<br> dfs(init, 0)<br> return vulns<br>}<br>

编号​

Attack-A0-0037

类别​

数论攻击 / 二次筛法整数分解

模型配方​

二次筛法是一种用于分解大整数 N的算法，属于通用整数分解算法。其核心思想是寻找两个整数 x和 y，使得 x2≡y2(modN)但 x≡±y(modN)，从而通过计算 gcd(x−y,N)和 gcd(x+y,N)得到 N的非平凡因子。算法通过筛选满足 Q(x)=(x+⌈N​⌉)2−N平滑（即其所有素因子都在预先选定的因子基内）的 x值，构建线性方程组模 2 求解指数向量的线性组合，最终得到平方同余式。

算法/模型/方法名称​

二次筛法（Quadratic Sieve）

算法/模型/方法的逐步思考推理过程及每一个步骤的数学方程式​

目标：分解合数 N。
步骤1：选择因子基。选取一个素数集合 B={p1​,p2​,...,pk​}，其中每个素数 p满足 (pN​)=1（即 N是模 p的二次剩余）。这保证了对于每个 p∈B，方程 t2≡N(modp)有解，从而 p可能整除 Q(x)。
步骤2：筛选。定义多项式 Q(x)=(x+⌊N​⌋)2−N。对于 x在某个区间 [−M,M]内，计算 Q(x)并尝试用因子基中的素数分解它（即判断 Q(x)是否 B-平滑）。对于每个平滑的 Q(x)，记录其指数向量模 2：若 Q(x)=∏i=1k​piei​​，则向量 v=(e1​mod2,e2​mod2,...,ek​mod2)。
步骤3：构建线性方程组。收集足够多（略大于 k）的平滑关系，形成一个矩阵 A，其行是这些指数向量。我们需要找到 A的零空间向量，即线性组合（模 2）使得所有指数为偶数。这等价于求解 AT⋅z≡0(mod2)。
步骤4：求解线性方程组。通过高斯消元法（模 2）找到线性相关的行集合 S，使得 ∑i∈S​vi​≡0(mod2)。
步骤5：构造平方同余式。令 X=∏i∈S​(xi​+⌊N​⌋)modN， Y=∏i∈S​Q(xi​)​modN。由于每个 Q(xi​)的分解已知，其乘积为完全平方数，故 Y可计算为整数。则 X2≡Y2(modN)。
步骤6：因子分解。计算 d=gcd(X−Y,N)。如果 d=1且 d=N，则 d是 N的一个非平凡因子。否则，尝试其他线性相关集合。

精度/密度/误差/强度​

精度：算法是确定性的，只要找到足够的平滑关系，最终总能分解 N。
强度：二次筛法的复杂度为 LN​[1/2,1]=e(1+o(1))lnNlnlnN​，亚指数时间。
误差：可能找到平凡因子（1 或 N），此时需尝试其他线性组合。

底层规律/理论定理​

平方同余分解定理：若 x2≡y2(modN)且 x≡±y(modN)，则 gcd(x−y,N)和 gcd(x+y,N)是 N的非平凡因子。
二次剩余：因子基的选择依赖于 N是模 p的二次剩余。
平滑数分布：一个数在因子基 B上平滑的概率决定了算法效率。

典型应用场景​

1. 分解RSA模数：用于破解较小密钥长度的RSA（如512位）。
2. 密码学挑战：如RSA Factoring Challenge。
3. 密码协议安全性评估：评估基于整数分解难度的协议的安全性。
4. 数学研究：大整数分解。
5. 教学示范：理解现代整数分解算法。

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

- N： 待分解的合数。
- B： 因子基，由 k个素数组成。
- M： 筛选区间半长。
- Q(x)： 二次多项式，Q(x)=(x+⌊N​⌋)2−N。
- 平滑关系： 对每个 xi​，Q(xi​)=∏j=1k​pjeij​​。
- 指数向量： vi​=(ei1​mod2,...,eik​mod2)。
- 矩阵 A： 行由指数向量组成。
- 集合 S： 线性相关的行索引集合。

状态机​

S0​: 输入 N； S1​: 选择因子基 B和区间 M； S2​: 筛选得到平滑关系集合 R； S3​: 若 (

数学特征​

- 数论：二次剩余、平滑数、同余方程。
- 线性代数：模2矩阵、高斯消元、零空间。
- 概率统计：平滑数概率。
- 计算：大整数运算、筛法。

语言特征​

术语：“二次筛法”、“因子基”、“平滑数”、“平方同余”、“线性代数”、“高斯消元”。句式多为描述筛选和求解过程。

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

阶段1：初始化
1. 输入 N。
2. 计算 m=⌊N​⌋。
3. 选择因子基 B={p∣p 是素数,p≤Bmax​,(pN​)=1}，大小为 k。
4. 选择筛选区间长度 2M+1。
阶段2：筛选
5. 初始化数组 Q[x]对于 x∈[−M,M]存储 Q(x)=(x+m)2−N。
6. 对每个 p∈B：
a. 求解 t2≡N(modp)得到根 t1​,t2​（可能只有一个）。
b. 对于每个根 t，找到第一个 x∈[−M,M]使得 x≡t−m(modp)，然后以步长 p遍历，将 Q[x]除以 p直到不能整除，并记录指数。
7. 扫描数组，收集 Q[x]=±1或完全分解的 x值，得到平滑关系。
阶段3：线性代数
8. 为每个平滑关系构建指数向量模2，形成矩阵 Ar×k​（r为关系数）。
9. 对 A进行高斯消元（模2），得到零空间基向量（即线性相关集合）。
阶段4：构造平方同余
10. 对每个零空间向量（对应集合 S）：
a. 计算 X=∏i∈S​(xi​+m)modN。
b. 计算 Y=∏i∈S​Q(xi​)​modN，由于 Q(xi​)已分解，平方根易得。
c. 计算 d=gcd(X−Y,N)。
d. 如果 1<d<N，则成功分解。

顺序/乱序/差序列/倒序/并行序列/分布式序列/随机序列/其他​

顺序序列：筛选和线性代数是顺序的，但可并行化。
并行序列：筛选阶段可对不同的素数或区间并行；线性代数可并行。

复杂度​

时间：LN​[1/2,1]=e(1+o(1))lnNlnlnN​。
空间：存储平滑关系和矩阵，多项式级别。

算法的伪代码（golang/C/C++）​

C++ 版本（简化，使用GMP库）：
```cpp
#include <vector>
#include <cmath>
#include <gmpxx.h>
// 辅助函数：判断n是否B平滑，并返回指数向量
bool trial_divide(const mpz_class& n, const std::vector<int>& B, std::vector<int>& exp) {
mpz_class m = n;
exp.assign(B.size(), 0);
for (size_t i = 0; i < B.size(); ++i) {
int p = B[i];
while (m % p == 0) {
m /= p;
exp[i]++;
}
}
return m == 1

A0-0038​

数论攻击

指数积分法计算离散对数

在有限域 GF(p)中计算离散对数 gx=hmodp的亚指数算法。通过选择因子基，寻找形如 gc≡∏piei​​modp的关系，建立线性方程组求解离散对数。

关系：logg​(gc)=c≡∑ei​logg​pi​mod(p−1)。

A0-0039​

数论攻击

椭圆曲线的MOV归约

将椭圆曲线 E(Fq​)上的离散对数问题（ECDLP）通过Weil配对归约到有限域 Fqk​上的离散对数问题，其中 k是嵌入度。当 k较小时，可在亚指数时间内求解。

Weil配对：e(P,Q)=e(P,Q)m=1，其中 Q是 P的陪集，m是阶。

A0-0040​

组合代数攻击

超图划分攻击社交网络

将社交网络建模为超图，顶点表示用户，超边表示交互（如共同群组）。通过超图划分算法（如HMETIS）将图划分为两个部分，最小化割边权重，用于社区发现或针对性攻击。

最小化割边：min∑e∈cut​w(e)，满足分区平衡。

A0-0041​

组合代数攻击

拟阵理论在访问控制策略分析

将访问控制策略建模为拟阵，权限集合为基集，独立集对应安全的权限组合。通过检查拟阵公理（遗传性、交换性）是否满足，检测策略漏洞。

拟阵公理：1. 空集独立；2. 独立集的子集独立；3. 若 A,B独立且 (

A0-0042​

微分代数攻击

Risch算法检测代数关系

给定一个表达式（如密码算法中的中间值），判断是否存在多项式 P使得 P(f,f′,...)=0，从而发现代数关系简化攻击。

Risch算法：用于判断一个初等函数的积分是否初等，也可用于检测代数依赖性。

A0-0043​

微分代数攻击

布尔函数导数攻击流密码

对布尔函数 f求导 Da​f(x)=f(x)⊕f(x⊕a)，降低代数次数。迭代应用可得到线性方程，用于恢复密钥。

若 f次数为 d，则 Da​f次数 ≤ d−1。

A0-0044​

积分代数攻击

代数攻击中的积分特性

类似于积分密码分析，但用代数语言描述。证明某个中间状态的和为零是理想成员，从而无需计算具体值即可推断平衡性。

在理想 I中证明 ∑x∈S​F(x)=0。

A0-0045​

随机代数攻击

多项式系统的概率求解

引入随机变量，以高概率求解方程组。例如，通过随机线性组合消元，或使用概率Gröbner基算法。

选择随机标量 αi​，考虑 ∑αi​fi​=0，可能得到更易解的方程。

A0-0046​

计算代数攻击

快速多项式乘法在侧信道分析

使用FFT加速卷积，用于快速计算能量迹之间的相关性或模板匹配。

卷积：h=f∗g，通过FFT计算 H=F⋅G。

A0-0047​

计算代数攻击

稀疏线性方程组求解攻击

密码方程组通常稀疏，使用Wiedemann算法或Block Wiedemann算法加速求解。

Wiedemann算法：寻找序列的最小多项式，适用于大型稀疏矩阵。

A0-0048​

符号代数攻击

符号执行用于漏洞挖掘

将程序变量表示为符号，路径条件积累为多项式约束，通过求解器（如Z3）检查可满足性，生成触发漏洞的输入。

路径条件 PC的求解：SMT求解器。

A0-0049​

统计代数攻击

代数侧信道分析

将能量迹建模为 ti​=L(vi​(k))+ni​，其中 L是泄漏函数，vi​是中间值。构建方程组并求解，结合统计去噪。

方程组：ti​=L(f(xi​,k))+ni​，求解 k。

A0-0050​

混合代数攻击

代数与机器学习混合攻击

使用代数方法生成特征，用机器学习分类器检测攻击；或反之，用机器学习简化代数方程。

例如，用Gröbner基简化特征，再用SVM分类。

A0-0051​

线性代数攻击

张量分解攻击多维数据

将多维数据（如网络流量张量）分解为核心张量与因子矩阵的乘积，以发现潜在结构，用于异常检测。

Tucker分解：X=G×1​A×2​B×3​C。

A0-0052​

非线性代数攻击

神经网络代数攻击

将神经网络的前向传播表示为多项式方程组，通过求解方程组生成对抗样本或进行模型提取。

激活函数（如ReLU）可分段线性表示，整体为多项式系统。

A0-0053​

拓扑代数攻击

持续同调在点云异常检测

对点云数据（如网络连接端点）计算持续同调，提取拓扑特征（贝蒂数、持续长度），用于检测异常集群。

条形码的长短表示拓扑特征的持续性。

A0-0054​

几何代数攻击

共形几何代数在恶意软件检测

将API调用序列映射为CGA点，计算轨迹的几何特征（如曲率、挠率），用于分类。

曲率：κ=∥γ˙​∥3∥γ˙​×γ¨​∥​。

A0-0055​

群论攻击

置换群的轨道攻击

若密码算法在置换群作用下轨道小，则对每个轨道代表元进行穷举，降低复杂度。

轨道 Ox​={g⋅x∣g∈G}，大小 (

A0-0056​

环论攻击

多项式环上的理想分解攻击

将密码算法建模为多项式环，计算理想的准素分解，可能得到关于密钥的简单方程。

理想分解：I=Q1​∩Q2​∩...∩Qr​。

A0-0057​

域论攻击

正规基表示下的S盒分析

在 GF(2n)中使用正规基，S盒的方程可能更稀疏，利于代数攻击。

正规基：{β,β2,...,β2n−1}，平方运算对应于循环移位。

A0-0058​

格论攻击

针对NTRU的格攻击