Français
Français
Dans PHP, les fonctions sérialisées et non sérialisées sont généralement utilisées pour convertir les variables PHP en chaînes et stocker ou transférer. Les deux sont très utiles dans le processus de développement, mais peuvent également introduire des erreurs difficiles à trouver. Lors de la débogage de ces erreurs, nous avons besoin de quelques conseils pour aider à localiser le problème. Cet article présentera quelques erreurs courantes et leurs solutions et vous guidera sur la façon de déboguer efficacement ces fonctions.
La fonction Serialize convertit une variable PHP en une chaîne, qui peut être restaurée à la variable PHP d'origine via la fonction non sérialisée . Si les données après sérialisation sont incorrectes, une non-série ne récupérera pas correctement les données d'origine et peut même lancer un avertissement.
$myData = array('name' => 'John', 'age' => 30);
$serializedData = serialize($myData);
// Falaiter manuellement des données sérialisées
$serializedData = substr($serializedData, 0, 20);
$unserializedData = unserialize($serializedData);
Vérifiez l'intégrité des données : assurez-vous que les données sérialisées ne sont pas tronquées ou corrompues lors du stockage ou du transfert.
Imprimer et enregistrer des données sérialisées : utilisez var_dump ou écho pour sortir les données sérialisées pour voir si elle répond au format attendu.
var_dump($serializedData);
Si les données sérialisées sont modifiées de manière inattendue, l'intégrité des données peut être assurée en vérifiant et en vérifiant les données (comme l'utilisation de la somme de hachage ou de la somme de contrôle).
Lors de l'utilisation de non-série , des types de données inattendus peuvent apparaître. Par exemple, si l'objet sérialisé n'est pas chargé correctement lors de la non-série , une valeur de null ou un type incorrect peut être renvoyée.
class User {
public $name;
}
$serializedData = serialize(new User());
$unserializedData = unserialize($serializedData);
var_dump($unserializedData); // S'attendre à être User Objet，Mais peut revenir NULL
Vérifiez si la classe est chargée : si vous rencontrez des problèmes désérialisant un objet, vérifiez d'abord si la classe correspondante est chargée.
Utilisez class_exists () et method_exists () : assurez-vous que la classe désérialisée est définie en PHP et peut être correctement instanciée.
if (!class_exists('User')) {
echo "gentil User Indéfini";
} else {
$unserializedData = unserialize($serializedData);
var_dump($unserializedData);
}
Assurez-vous que la classe de l'objet désérialisé a été chargée correctement ou dynamiquement à l'aide de spl_autoload_register () .
Dans PHP 5.3 et supérieur, vous pouvez utiliser le deuxième paramètre de la fonction Unserialize () pour restreindre les classes désérialisées pour améliorer la sécurité.
$unserializedData = unserialize($serializedData, ["allowed_classes" => ["User"]]);
Les opérations de désérialisation présentent des risques de sécurité et les données de sérialisation malveillantes peuvent conduire à des vulnérabilités d'exécution de code, surtout si les données ne sont pas correctement vérifiées. Un attaquant peut essayer d'exécuter du code malveillant en altérant des données sérialisées.
$maliciousData = 'O:4:"User":1:{s:4:"name";s:4:"evil";}';
$unserializedData = unserialize($maliciousData);
Vérifiez les sources de données : vérifiez toujours la source des données avant de les désérialiser, en vous assurant que les données proviennent d'une source de confiance.
Utilisez le mécanisme de liste blanche : en définissant le paramètre ALLOGED_CLASSES , assurez-vous que seules les classes spécifiques sont autorisées à être désérialisées pendant la désérialisation.
Utilisez le paramètre autorisé_classes d' Unserialize () pour restreindre uniquement les classes spécifiques à désérialiser.
Envisagez d'utiliser le format JSON pour le transfert de données au lieu de sérialiser directement des objets PHP pour réduire le risque d'attaques de désérialisation.
$unserializedData = unserialize($maliciousData, ["allowed_classes" => ["User"]]);
Pendant le développement, il existe des outils et des astuces qui peuvent être utilisés pour aider à déboguer les problèmes pour sérialiser et non sériement les fonctions plus efficacement.
En enregistrant les données sérialisées dans un fichier journal, vous pouvez recommencer les données d'origine lorsque quelque chose ne va pas:
file_put_contents('serialize_log.txt', $serializedData . PHP_EOL, FILE_APPEND);
Écrivez des tests unitaires pour la sérialisation et le code lié à la désérialisation pour garantir que les données peuvent être correctement sérialisées et désérialisées et prendre toutes les exceptions.
public function testSerialization() {
$data = array('name' => 'John', 'age' => 30);
$serializedData = serialize($data);
$this->assertNotEmpty($serializedData);
$unserializedData = unserialize($serializedData);
$this->assertEquals($data, $unserializedData);
}
var_dump est un puissant outil de débogage qui peut afficher les types détaillés et le contenu des variables, nous aidant à identifier rapidement les problèmes.
var_dump($unserializedData);
Lors de la débogage des erreurs dans les fonctions de sérialisation et de non-série , nous devons considérer le problème sous plusieurs perspectives: si le format de données est complet, que la classe soit chargée correctement, que les données soient falsifiées, etc. avec des outils de débogage raisonnables, une vérification stricte et des mesures de sécurité appropriées, nous sommes en mesure de réduire efficacement et de réparer ces erreurs courantes.
J'espère que cet article vous aide à être plus utile lorsque vous traitez avec sérialiser et ne vous désérialiser en PHP.
