# 什么是奇异值分解

奇异值分解（英语：Singular value decomposition，缩写：SVD）是线性代数中一种重要的矩阵分解，在信号处理、统计学等领域有重要应用。奇异值分解在某些方面与对称矩阵或埃尔米特矩阵基于特征向量的对角化类似，这两种矩阵分解尽管有其相关性，但还是有明显的不同。对称阵特征向量分解的基础是谱分析，而奇异值分解则是谱分析理论在任意矩阵上的推广。

:::info{title="摘自"}
[维基百科-奇异值分解](https://zh.wikipedia.org/wiki/%E5%A5%87%E5%BC%82%E5%80%BC%E5%88%86%E8%A7%A3)
:::





# 奇异值分解的表示形式

假设一个 $ m * n $ 的矩阵 $ A $,其奇异值分解的表示形式为:

$$
    A_{m \times n} = U_{m \times m} \Sigma_{m \times n}  V_{n \times n}^T
$$

其中,$V^T$和$U$都是正交矩阵。


:::info{title="正交矩阵"}
* **数学定义**：满足 $M^T M = M M^T = I$ 的方阵，其逆矩阵等于转置矩阵（$M^{-1} = M^T$）。
* **代数特性**：行/列向量两两垂直（正交）且长度均为 1，构成了空间中的一组标准正交基。
* **几何意义**：在矩阵变换中仅负责**空间旋转**或**镜像翻转**，不改变向量的长度和夹角（保持刚体形态）。
:::
# 奇异值分解的具体含义

假设有一个维度为 $n$ 的向量 $x$

对于$V^T$来说,$V^T x$ 等同于计算在$V$这个坐标系下，原先的向量$x$对应的位置。

我们记 $x_1 = V^T x$

对于$\Sigma$来说,$\Sigma x_1$ 等同于计算在$V$这个坐标系下，沿各个方向的伸缩程度。

我们记 $x_2 = \Sigma x_1 = \Sigma V^T x $

对于$U$来说,$U x_2$ 等同于向量$x_2$映射到$U$这个坐标系。

我们记 $x_3 = U x_2 = U \Sigma x_1 = U \Sigma V^T x $


![image.png](/static/img/2fa8b7f137b7a68a3077a2bf05843614.image.webp)


:::info{title="摘自"}
[【【无痛线代】彻底搞懂SVD！矩阵究竟怎么就奇异了？】](https://www.bilibili.com/video/BV1XcfiBeEwQ?vd_source=3a5368e56c6fbf38ec2032bd6430901b)
:::

# 奇异值的如何计算

对于任意对称矩阵 $M$（如 $A^TA$），其特征值分解形式为 $M = W \Lambda W^T$（其中 $W$ 为正交矩阵，$\Lambda$ 为对角矩阵）。

由此可得：

$$
\begin{aligned}
A^T A &= M_{n \times n} \\
&= W_{n \times n} \Lambda_{n \times n} W_{n \times n}^T
\end{aligned}
$$

另一方面，将 $A$ 的奇异值分解 $A = U \Sigma V^T$ 代入上式展开：

$$
\begin{aligned}
A^T A &= (U_{m \times m} \Sigma_{m \times n} V_{n \times n}^T)^T (U_{m \times m} \Sigma_{m \times n} V_{n \times n}^T) \\
&= V_{n \times n} \Sigma_{n \times m}^T U_{m \times m}^T U_{m \times m} \Sigma_{m \times n} V_{n \times n}^T \\
&= V_{n \times n} (\Sigma_{n \times m}^T \Sigma_{m \times n}) V_{n \times n}^T \\
&= V_{n \times n} \Lambda_{n \times n} V_{n \times n}^T
\end{aligned}
$$

通过对比上述两种矩阵对角化的形式，我们可以确定：**$A^TA$ 的特征向量矩阵 $W$ 可以作为右奇异矩阵 $V$ 的一个解。**

同理，对于左奇异矩阵 $U$，我们可以通过构建对称矩阵 $A A^T$ 来进行推导。

假设我们对矩阵 $A A^T$ 进行特征值分解（EVD）：

$$
\begin{aligned}
A A^T &= N_{m \times m}\\
&= P_{m \times m} \Lambda_{m \times m} P_{m \times m}^T 
\end{aligned}
$$
其中，$P$ 是由 $A A^T$ 的特征向量正交单位化后组成的矩阵，$\Lambda$ 是对应的特征值对角矩阵。

而根据 SVD 的定义 $A = U \Sigma V^T$，代入可得：

$$
\begin{aligned}
A A^T &= (U_{m \times m} \Sigma_{m \times n} V_{n \times n}^T) (U_{m \times m} \Sigma_{m \times n} V_{n \times n}^T)^T \\
&= U_{m \times m} \Sigma_{m \times n} V_{n \times n}^T V_{n \times n} \Sigma_{n \times m}^T U_{m \times m}^T
\end{aligned}
$$

因为 $V$ 是正交矩阵，满足 $V^T V = I_{n \times n}$，所以上式可以化简为：
$$
\begin{aligned}
A A^T &= U_{m \times m} (\Sigma_{m \times n} \Sigma_{n \times m}^T) U_{m \times m}^T \\
&= U_{m \times m} \Lambda_{m \times m} U_{m \times m}^T
\end{aligned}
$$

因此，通过对比两组对角化形式，我们可以确定：$P$ 可以是 $U$ 的一个解。

通过对比特征值分解与奇异值分解的展开式，我们同样可以推导得到中间奇异值矩阵 $\Sigma$ 的求解方式。

由前述推导可知，特征值对角矩阵 $\Lambda$ 与奇异值矩阵 $\Sigma$ 满足如下关系：

$$
\begin{aligned}
\Lambda_{n \times n} &= \Sigma_{n \times m}^T \Sigma_{m \times n} \\
\Lambda_{m \times m} &= \Sigma_{m \times n} \Sigma_{n \times m}^T
\end{aligned}
$$

展开对角矩阵的乘法映射，对于对角线上的每一个元素，有如下对应关系：

$$
\begin{aligned}
\lambda_i &= \sigma_i^2 \\
\sigma_i &= \sqrt{\lambda_i}
\end{aligned}
$$


:::note{title="注意"}
这里的每一个$\lambda$都是大于等于0的，因为$A^T A$是**半正定**的,即:
$$x^T (A^T A) x \ge 0$$
:::

通过对比上述矩阵对角线的映射关系，我们可以确定：**中间奇异值矩阵 $\Sigma$ 的非零对角元素 $\sigma_i$ 即为矩阵 $A^TA$（或 $AA^T$）特征值 $\lambda_i$ 的算术平方根。在结构上，只需将 $\sigma_i$ 构造在与原矩阵 $A$ 维度完全相同的 $m \times n$ 对角矩阵中即可。**

# 如何计算奇异值分解？

## 对于方阵

```python
import torch

def compute_svd(A: torch.Tensor):
    # 1. 算 A.T @ A 的特征值和特征向量，用 clamp 防御浮点负数误差
    s_eig, V = torch.linalg.eigh(A.T @ A)
    
    # 2. 强制翻转对齐（从升序变降序）
    s_eig = torch.flip(s_eig, dims=[0])
    V = torch.flip(V, dims=[1])
    
    # 3. 开根号求出奇异值
    S_val = torch.sqrt(torch.clamp(s_eig, min=0.0) + 1e-12)
    
    # 4. 联动推导 U，彻底避免独立求解导致的符号错位
    U_reduced = (A @ V) / S_val.unsqueeze(0)
    
    return U_reduced, torch.diag(S_val), V.T

```

## 1. 计算右奇异矩阵 $V$ 和奇异值 $\Sigma$

对矩阵 $A^T A$ 进行实对称特征值分解（即调用 `torch.linalg.eigh`）。

* **特征值处理**：将解出的特征值由大到小降序排列，直接开根号（即对元素执行 `torch.sqrt`）得到奇异值。构造出对角矩阵 $\Sigma$。
* **向量对齐**：将特征向量矩阵的列按照对应的特征值降序同步翻转，得到最终的右奇异矩阵 $V$。

## 2. 联动计算左奇异矩阵 $U$ 的有效列

不独立求解 $A A^T$，而是直接通过 $A$ 和已求出的 $V$、$\Sigma$ 进行反向逆推，求出紧凑版的左奇异矩阵 $U_{\text{部分}}$：


$$U_{\text{部分}} = A V \Sigma^{-1}$$


在代码中，这等价于计算矩阵乘法 $A \times V$，然后将结果的每一列分别除以对应的非零奇异值 $\sigma_i$。此时 $U$ 与 $V$ 的空间正负号完全绑定对齐。

## 3. 正交化补全维度（仅在需要 Full SVD 时）

如果需要将 $U$ 补全为 $m \times m$ 的完备方阵（如 `full_matrices=True`）：

* 算法会在内核中利用**施密特正交化（Gram-Schmidt）**，人为产生与已有列向量全部严格垂直、且模长为 1 的新向量，直接拼接塞入矩阵剩余的空位中。



# 奇异值分解的另一种表达形式

外积展开形式 (Outer Product Expansion)矩阵形式的 $A = U \Sigma V^T$ 

实际上可以转译为数个低秩矩阵相加的线性组合。这种形式能最直观地体现“奇异值大小决定信息量大小”的本质。

假设 $A$ 的秩为 $r$ ，$u_i$ 为 $U$ 的第 $i$ 个列向量，$v_i$ 为 $V$ 的第 $i$ 个列向量（则 $v_i^T$ 为 $V^T$ 的第 $i$ 个行向量）：
$$A = \sum_{i=1}^{r} \sigma_i u_i v_i^T = \sigma_1 u_1 v_1^T + \sigma_2 u_2 v_2^T + \dots + \sigma_r u_r v_r^T$$

:::info{title="结构拆解"}
每一个 $u_i v_i^T$ 都是一个大小为 $m \times n$、但秩严格等于 1 的基础矩阵。

物理意义：原矩阵 $A$ 被拆解成了 $r$ 个秩为 1 的“子图层/子矩阵”的叠加，而每个图层所分配的权重（清晰度/能量），正好就是对应的奇异值 $\sigma_i$。
:::

SVD-奇异值分解

Problem: 1411. 给 N x 3 网格图涂色的方案数

# 1. 有向图路径数量
在这个问题中，我们可以将网格图的每一行都可以抽象成一个顶点(vertex),我们可以将这个问题抽象成:

有向图G（V,E)

* V代表顶点集，
* E代表边集，其中的每个元素代表{from_state,to_state},from_state的下一行可以是to_state
如下图所示:

![numOfWays-base.png](/static/img/74617e971eeb3ea1ea1479cf1e1e2821.numOfWays-base.webp)

我们要求的就是: 从这个图中的每个点出发，能够走出多少条长度为n - 1的路径




## Code
```cpp

#include <vector>
#include <ranges>
#include <algorithm>
#include <print>
using namespace std;


class Solution {
private:
    static bool check_state(int state){
        int left = (state / 9) % 3;
        int mid = (state / 3) % 3;
        int right = (state) % 3;
        if((left == mid) or (right == mid)){
            return false;
        }
        return true;
    }
    static bool check_edge(int first_state,int second_state){
        int first_color[3] = {(first_state / 9) % 3,(first_state/ 3) % 3,(first_state) % 3 };
        int second_color[3] = {(second_state / 9) % 3,(second_state/ 3) % 3,(second_state) % 3 };
        for(int i = 0;i < 3;i++){
            if(first_color[i] == second_color[i]){
                return false;
            }
        }
        return true;
    }

public:
    using ll = long long;
    static constexpr ll mod = 1'000'000'007;
    int numOfWays(int n) {

        vector<vector<int>> state_transition_table(27);
        int cnt = 0;
        for(int first_state = 0; first_state < 27;first_state++){
            if(check_state(first_state) == false){
                continue;
            }
            for(int second_state = 0;second_state < 27;second_state++){
                if(check_state(second_state) == false){
                    continue;
                }
                if(check_edge(first_state,second_state)){
                    state_transition_table[first_state].emplace_back(second_state);
                }
            }
            
        }
        vector<int> state_sum = state_transition_table | 
                            views::transform([](vector<int>& v){ return int{!v.empty()};})|
                            ranges::to<vector<int>>();
        for(int step = 0;step < n - 1;step++){
            vector<int> pre_state_sum = state_sum;
            for(int from_state = 0;from_state < 27;from_state++){
                state_sum[from_state] = 0;
                for(int to_state : state_transition_table[from_state]){
                    state_sum[from_state] = (state_sum[from_state] + pre_state_sum[to_state] * 1LL) % mod;
                }
            }
        }
        return ranges::fold_left(state_sum,0,[&](int lhs,int rhs){ return (lhs + rhs) % mod;});
    }
};
```
## 复杂度
* 时间复杂度: O(n∗27)
* 空间复杂度: O(n∗5)

# 2. 顶点聚合
实际上，我们不需要这么多顶点，具体来说，我们可以看到顶点一共有两种模式,即ABA模式和ABC模式。


![numOfWays-advance.png](/static/img/304602e42ed087b8572ae07c3f1c0e09.numOfWays-advance.webp)

进一步，我们对图进行收缩，有:


![numOfWays-aggregate.png](/static/img/863b3b2aab96b8142f2b595fcfc5a55d.numOfWays-aggregate.webp)


:::info{title="公式"}

原先需要对12个点进行求值，现在只需要对2个pattern进行求值。

公式为:

* state[n][ABA] = 3 * state[n - 1][ABA] + 2 * state[n - 1][ABC]
* state[n][ABC] = 2 * state[n - 1][ABA] + 2 * state[n - 1][ABC]

其中
state[1][ABC] = 6
state[1][ABA] = 6
:::




## 模板元优化
由于本题n的数量较小，且相同的输入，永远会产生相同的结果，所以，可以在编译期就计算完成

## Code
```C++
#include <vector>
#include <ranges>
#include <algorithm>
#include <print>
using namespace std;

using ll = long long;
inline static constexpr ll mod = 1'000'000'007;
struct TableData {
    int status[5002];
};

inline static consteval TableData init_tables() {
    TableData data = {}; 
    
    data.status[1] = 12;
    data.status[2] = 54;

    for (int i = 3; i <= 5000; ++i) {
        data.status[i] = (7 * mod + 5LL * data.status[i - 1] - 2LL * data.status[i - 2]) % mod;
    }
    
    return data;
}


class Solution {
public:
    static constexpr TableData cache = init_tables();
    int numOfWays(int n) {
        // state[n][ABA] = 3 * state[n - 1][ABA] + 2 * state[n - 1][ABC]
        // state[n][ABC] = 2 * state[n - 1][ABA] + 2 * state[n - 1][ABC]
        return cache.status[n];
    } 
};
```

## 复杂度
* 时间复杂度: O(1)
* 空间复杂度: O(1)


链接：https://leetcode.cn/problems/number-of-ways-to-paint-n-3-grid/solutions/3871848/cong-tu-lun-jian-mo-dao-ding-dian-shou-s-papq/

给 N x 3 网格图涂色的方案数 - 从图论建模到顶点收缩：利用 C++20 consteval 实现 O(1) 

# EmTaint 的工作价值

1. **解决固件后端间接调用难以解析的问题**
  Linux-based 固件后端大量存在间接调用（indirect calls），传统方法无法解析，导致大量潜在漏洞路径无法被发现。
  EmTaint 针对这一核心难点提出改进，使得更多真实的可疑路径能够被揭示。

2. **提升变量别名（variable alias）场景下的数据流分析能力**
  变量别名频繁出现会导致数据流追踪断裂，隐含漏洞路径无法识别。
  EmTaint 通过改进分析机制，使得在别名复杂的情况下仍能保持可靠的数据流追踪。

3. **减少传统方法带来的误识别问题**
  之前的研究依赖启发式方式识别“中介污点源（mediate taint source）”，可能误识别，从而产生大量误报（false positives）。
  EmTaint 通过更精确的分析方式避免此类启发式错误，使结果更准确。

3. **揭示传统方法遗漏的大量潜在漏洞路径**
  由于未处理间接调用和别名问题，现有方法会遗漏许多真实路径（false negatives）。
  EmTaint 提供更完整的路径覆盖，使漏洞挖掘更全面。




# EmTaint的工作原理

![image.png](/static/img/7a17458b664dd4e4a350432ee7d8f863.image.webp)

下面是 EmTaint **如何进行漏洞分析的完整流程**，使用 Markdown 列表结构清晰呈现，并用中文表达技术要点。

## 1. 固件预处理（Firmware Preprocessing）

* 对固件进行解压与文件提取，定位并抽取其中的二进制可执行文件。
* 将提取出的二进制代码转换为中间表示（IR）。
* 在 IR 基础上构建控制流图（CFG）与部分调用图（CG），为后续分析（别名、间接调用、污点传播）提供结构信息。

---

## 2. 基于 SSE 的按需别名分析（SSE-Based On-Demand Alias Analysis）

* 引入一种新的 **结构化符号表达式（Structured Symbolic Expression, SSE）**，用来精确表达变量及内存块之间的别名关系。
* 设计别名更新机制，用于在整个二进制执行范围内持续追踪变量别名变化。
* **按需分析**：只计算与“关注变量”相关的别名关系，而不是对全局所有变量进行计算。

  * 避免无关变量带来的巨大开销。
  * 使得别名分析可以在复杂固件中高效运行。


## 3. 间接调用解析（Indirect Call Resolution）

* 使用别名分析提供的数据依赖信息，解析间接调用的真实目标。
* 通过检查：**间接调用点（indirect callsite）** 与**被引用的函数指针**之间的数据依赖关系来判断可能的调用目标。
* 该机制允许污点分析跨越更多函数边界，提高对真实漏洞路径的覆盖能力。


## 4. 污点初始化与传播（Taint Initialization and Propagation）

### 4.1 识别污点源（Taint Sources）

* 对攻击者可控制的输入点进行标记，例如：

  * `recv()`
  * 文件读取
  * 用户输入缓冲区
* 这些源头的变量被初始化为“污点”。

### 4.2 污点传播（Taint Propagation）

* 在程序的指令执行路径上持续跟踪污点流动，依据：

  * 传播规则（赋值、算术、指针操作等）
  * 按需别名分析返回的别名关系
* 污点可通过直接赋值、指针、结构体、数组等复杂路径向前传播。

## 5. 漏洞检测模块（Taint-Style Vulnerability Check）

### 5.1 找到污点到达的危险点（Security-Sensitive Sinks）

典型危险操作包括：

* `system()`
* `exec*()`
* 内存拷贝、缓冲区写入（如 `strcpy`）
* 关键权限操作函数

### 5.2 判断是否构成潜在漏洞

在危险点，如果：

* 对应变量 **受到污点影响**（被攻击者控制）
* 且该变量 **未经过约束/校验**
  则标记为潜在漏洞（Potential Vulnerability）。

这一检测逻辑与传统污点分析一致，但借助 EmTaint 的别名分析与间接调用解析，使得更多真实漏洞路径可以被发现，减少 false negatives。

EmTaint论文工作

# OctopusTaint 的工作价值

1. 采用静态污点分析的方法，同时融合数据流的分析

2. 解决间接调用问题

3. 可追踪 NVRAM 的变形 taint，识别用户自定义 taint source

4. 强化 Sanitization 检测 



# 静态污点分析中的挑战

## 1. **栈变量与全局变量识别**

**挑战：**
精确识别用于创建、更新或获取栈内存定义所需的栈变量偏移量存在较大难度，尤其在出现间接内存寻址或复制传播的情况下。

**原因：**
基于 VEX-IR 的到达定义分析（RDA）有时会将用于计算内存引用地址的寄存器操作误判为数学运算，导致所需内存定义更新失败。


## 2. **间接调用处理**

**挑战：**
被分析的固件中间接函数调用非常普遍，且常与潜在漏洞路径相关。

**angr RDA 的问题：**
在存在间接调用的情况下，angr RDA 无法判断应探索的具体函数，缺乏指导信息。


## 3. **函数参数恢复**

**挑战：**
在分析过程中，angr 框架经常无法完整恢复函数的所有预期参数。

**原因：**

* 调用约定恢复不足
* 栈帧重建不完整
* 参数识别启发式有限


## 4. **清洗（Sanitization）检查**

**挑战：**
识别污点路径中的安全检查和长度约束（如边界检查、格式验证）十分困难。

**原因：**
在回溯阶段，需要遍历数据依赖图（DDG）以定位对最终污点汇有贡献的定义，但：

* 清洗操作节点可能无法被识别
* 某些定义在图中表示不一致
* 安全检查可能以非标准形式实现

# OctopusTaint的工作原理

![image.png](/static/img/2ba6cc30b5ae8d36d6f36c9ea4ab5f42.image.webp)

## 固件解包（Firmware Unpacking）

:::info{title="核心目标"}
固件内部组件可访问和分析
:::
- 使用 **binwalk** 解包固件
- 提取前端网页文件（HTML, XML, Ajax, ASP）
- 提取二进制文件供后续分析


## 后端文件选择（Back-end Files Selection）

:::info{title="筛选潜在漏洞区域"}
利用关键字匹配挑选与漏洞相关的二进制文件
:::

- 提取网页文件中的关键字符串（参考 SaTC 方法）
- 选择关键字匹配或相似的二进制文件
- 针对使用共享内存库（如 `libnvram.so`）的二进制文件标记
- 追踪跨文件数据交互


## 二进制函数选择（Binary Functions Selection）

:::info{title="关注高风险函数"}
确保分析聚焦可能存在漏洞的关键位置
:::

- 优先分析以下函数  
  - 接收用户输入（如 `get_cgi`）  
  - 执行系统命令（如 `system`）  
  - NVRAM 操作函数（如 `nvram_set`, `nvram_get`）
- 记录新的用户自定义输入函数
- 在后续分析中追踪调用这些函数的二进制函数


## 静态污点引擎与回溯（Static Taint-Engine and Backtracking）

:::info{title="OctopusTaint 核心模块"}
精确生成污点传播定义和路径
:::

- 核心采用 **Reaching Definition Analysis（RDA）**  
  - 支持函数内部和跨函数分析
- 构建 **数据依赖图（DDG）**  
  - 基于 use-def 链和 def-use 链
- 集成 **AIL 中间语言** 和 clinic 模块  
  - 精确恢复调用约定、栈变量和全局变量
- 对关键函数执行污点分析  
  - 遇到系统调用或危险函数（如 `strcpy`, `sprintf`）时检查参数定义  
  - 使用自底向上的深度优先回溯追踪污点源到污点汇  
  - 记录路径到 File_get_2_Sink  
  - 对 NVRAM 操作（如 `nvram_set`）同样记录到 File_get_2_Set


## 清洗检查（Sanitization Inspection）


- 分析回溯得到的候选路径  
- 提取关键安全检查（条件判断、输入长度限制等）  
- 特别关注字符串操作及长度参数  
- 已清洗或受限的路径会被过滤



## 执行路径连接与过滤（Connect Execution Paths and Filtering）

- 固件可能由多个二进制文件组成  
- 函数之间通过共享内存、套接字或文件通信  
- OctopusTaint 追踪跨文件通信路径，尤其是 NVRAM  
- 汇总每个二进制文件的 File_get_2_Set 和 File_get_2_Sink  
- 连接成完整执行路径  
- 对路径进行过滤，挑选出最关键漏洞进行报告


# OctopusTaint可取之处

1. 采用RDA到达定义分析,有较好的分析价值
2. 采取Sink2Source方法
3. 面向多系统，而不是局限于linux系统
4. 对于系统内部的清洗函数，进行过滤，提高运行效率

可以参考的图:

![image.png](/static/img/8bb41c218f569418a258f9f92fd582ce.image.webp)

# OctopusTaint参考工作

## 多二进制路径追踪
- **Karonte**
  - 跟踪用户可控输入（HTTP headers、环境变量）跨多个二进制文件
  - 构建 **多二进制图（multi-binary graph）**
  - 使用 **DSE** 判断 tainted 输入是否到达关键 sink
  - **借鉴点**：多二进制交互追踪和 DSE 方法

https://github.com/ucsb-seclab/karonte


## Web 接口静态分析与符号执行
- **SaTC**
  - 解包固件，提取 HTML、XML、Ajax 等 Web 文件
  - 提取关键字对应后端 API
  - 使用无限制符号执行（unconstrained symbolic execution）探索用户输入到系统函数路径
  - 输出完整 taint 路径报告
  - **借鉴点**：Web 前端输入到后端 API 的追踪方法

https://github.com/NSSL-SJTU/SaTC


## SSE 与别名分析
- **EmTaint**
  - 使用 **SSE** 进行别名分析，解决间接调用问题
  - 探索更深的 taint 路径，弥补 SaTC 和 Karonte 的遗漏
  - **借鉴点**：间接调用处理与别名分析

https://github.com/kuc001/EmTaint

## 定义-使用链与数据依赖图（DDG）
- **HermeScan**
  - 基于 def-use 构建 top DDG
  - 前向 taint 跟踪
  - 采用 path-merging 缓解路径爆炸
  - **借鉴点**：前向 taint 跟踪与路径优化


- **MangoDFA**
  - 采用反向遍历（sink → source）
  - 缓解路径爆炸，加速大规模分析
  - **借鉴点**：反向 taint 路径分析

github.com/sefcom/operation-mango-public

OctopusTaint论文工作

# LLMSecConfig的工作价值

1. 继承了LLM的静态分析工具，用于容器编排{Container Orchestrators[CO]}

2. 通过现实的配置展示其有效性 （使用了**1000**个docker配置）

3. 公开了数据集和实现方法 (source:[https://figshare.com/s/2a9be8ccfbec9d8ba199](url))



# LLMSecConfig的工作原理


![image.png](/static/img/9d46e5a393498bb7e21f2b50c4365cb4.image.webp)

1. 使用静态分析工具分析配置文件
2. 通过RAG进行上下文检索
3. 构造提示词，试图生成正确的配置文件
4. 对于生成后的文件进行检测，对于不正确的配置，重回step 1

# LLMSecConfig的可取之处

1. 使用了ArtifactHub作为数据来源，在相关领域研究，可以在其中获取需要的配置文件
2. 采取两种精度(metric)作为量化评测结果

:::info{title="PSR 解析正确比率"}
用于量化LLM生成语法正确的YAML配置文件的比率
:::


:::info{title="PR 通过率"}
用于量化LLM修复的YAML配置文件，通过所有安全检测的比例
:::

# 方案的不足之处

1. LLM方法仍然具有不确定性，论文中使用的评估方案并不能完全覆盖所有的情况，仍然会有边缘情况的出现

2. 涉及不同安全参数之间的复杂相互依赖，对LLM生成安全策略有更深的要求