Résolution des pièges communs avec des octets nuls et une terminaison de chaîne en PHP

Les octets nuls (\ 0) peuvent provoquer un comportement inattendu dans PHP lors de l'interfaçage avec les extensions C ou des appels système car C traite \ 0 comme un terminateur de chaîne, même si les chaînes PHP sont en service binaire et préservent la pleine longueur. 2. Dans les opérations de fichiers, les noms de fichiers contenant des octets NULL comme "config.txt \ 0.php.bak" peuvent être tronqués à "config.txt", conduisant à un accès de fichiers ou à des risques de sécurité incorrects. 3. Pendant les téléchargements de fichiers, les attaquants peuvent exploiter les octets NULL dans $ _POST ['FileName'] pour contourner les vérifications d'extension, par exemple, "shell.php \ 0.jpg" étant enregistrée comme "shell.php". 4. Les comparaisons de chaînes en PHP pur (===, STRCMP) gèrent correctement les octets nuls, mais les extensions basées sur C ou les pilotes de base de données peuvent tronquer les chaînes, risquant l'intégrité des données. 5. Les expressions régulières peuvent correspondre partiellement aux chaînes avec des octets nuls, sauf si l'ancre a correctement ancré avec \ a et \ z, donc l'entrée doit être vérifiée pour \ 0 avant le traitement. 6. Les meilleures pratiques incluent le filtrage des octets nuls à l'aide de str_replace ("\ 0", '', $ entrée) ou de les rejeter, en utilisant Basename (), RealPath () et Filter_Input (), validant toutes les entrées utilisateur, évitant l'interpolation directe de la chaîne dans les appels système ou SQL, et en utilisant des instructions préparées pour les attentes de la base de données pour assurer la sécurité. Traitez toujours les octets nuls comme une entrée potentiellement dangereuse et les gérez explicitement pour éviter les vulnérabilités de troncature et de sécurité.

Travailler avec des chaînes en PHP semble généralement simple - jusqu'à ce que vous vous cachiez dans les cas de bord impliquant des octets nuls ( \0 ) et la terminaison de la chaîne , en particulier lorsque vous interfiez avec les extensions C, les opérations de fichiers ou la saisie utilisateur. Alors que PHP gère les chaînes de manière plus flexible que les langues de niveau inférieur, ces problèmes peuvent encore entraîner un comportement inattendu, des vulnérabilités de sécurité ou une troncature des données. Voici comment comprendre et éviter les pièges les plus courants.

Que sont les octets nuls et pourquoi sont-ils importants?

Un octet nul ( \0 ) est un caractère avec la valeur ASCII de 0. Dans les chaînes de style C, il marque l' extrémité d'une chaîne . Cependant, les chaînes de PHP sont à sa propriété binaire , ce qui signifie qu'elles peuvent contenir des octets nuls tout en préservant toute la longueur. Le problème se pose lorsque PHP passe des chaînes à C (comme celles des extensions ou des appels système) qui interprètent \0 comme un terminateur.

Par exemple:

 $ string = "Hello \ 0world";
echo strlen ($ string); // Sorties: 11

Même avec l'octet nul, PHP sait que la chaîne mesure 11 caractères. Mais si cette chaîne est transmise à une fonction C attendant une chaîne à terminaison nulle, elle ne verra que "hello" .

Pitre n ° 1: troncature inattendue dans les opérations de fichiers

L'un des problèmes les plus courants se produit lors de l'utilisation de fonctions comme file_get_contents() ou fopen() avec des noms de fichiers ou des chemins contenant des octets nuls.

 $ filename = "config.txt \ 0.php.bak";
file_get_contents ($ filename); // ne peut lire que "config.txt"

PHP peut permettre la réussite de la chaîne, mais l'appel du système sous-jacent (écrit en C) s'arrête à \0 , menant potentiellement à:

• Lire le mauvais fichier
• Contournement des extensions de fichiers (risque de sécurité dans les téléchargements de fichiers)

✅ Solution : toujours désinfecter et valider l'entrée:

 if (strPos ($ nom de fichier, "\ 0")! == false) {
    Jetez un nouveau InvalidArgumentException ("Les octets nuls ne sont pas autorisés dans les noms de fichiers");
}

Mieux encore, utilisez la liste blanche pour les opérations de fichiers et évitez les noms de fichiers dynamiques lorsque cela est possible.

Pitre n ° 2: risques de sécurité dans les téléchargements de fichiers

Les attaquants peuvent injecter des octets NULL dans $_GET , $_POST ou télécharger des noms de fichiers pour exploiter le comportement de terminaison de la chaîne.

Exemple d'un modèle dangereux:

 // ne fais pas ça
$ uploaddir = '/ uploads /';
MOVE_UPLOADED_FILE ($ _ fichiers ['file'] ['tmp_name'], $ uploaddir. $ _post ['filename']);

Si $_POST['filename'] est "shell.php\0.jpg" , certains systèmes peuvent l'enregistrer en tant que shell.php (car .jpg est ignoré après \0 ), en contournant les vérifications d'extension.

✅ Solution :

• Ne faites jamais confiance à la saisie des utilisateurs pour les chemins de fichier
• Utilisez basename() pour éliminer les informations de répertoire
• Valider les extensions sur le contenu du fichier réel, pas seulement le nom
• Filtre les octets nuls explicitement:

   if (preg_match ('/ [\ x00] /', $ nom de fichier)) {
    die ("nom de fichier non valide");
  }

Pitfall # 3: Problèmes avec strcmp et comparaison des cordes

Alors que la comparaison de chaînes native de PHP ( == , === , strcmp ) gère correctement les octets NULL, des problèmes peuvent survenir lors de l'utilisation d'extensions ou de pilotes de base de données qui reposent sur les chaînes C.

Par exemple, en comparant "admin\0" et "admin" en php:

 var_dump ("admin \ 0" === "admin"); // FAUX
var_dump (strcmp ("admin \ 0", "admin")); // non nul (pas égal)

Ceci est sûr en PHP pur, mais si ces chaînes sont utilisées dans les requêtes SQL via un pilote basé sur C, une troncature pourrait se produire.

✅ Meilleures pratiques : utilisez des déclarations préparées pour éviter l'injection et assurer l'intégrité des données:

 $ stmt = $ PDO-> Préparer ("SELECT * FROM Users Where Username =?");
$ stmt-> Execute ([$ username]); // PDO gère les données d'échappement et de données binaires

Pitre n ° 4: Médefrein dans les expressions régulières

Les fonctions de PCRE dans PHP sont généralement à sateinture binaire, mais les octets nuls peuvent toujours provoquer une confusion, en particulier lors du traitement de l'entrée des utilisateurs.

Exemple:

 preg_match ('/ ^ [\ w \.] $ /', "file.txt \ 0.php"); // peut retourner 1 (!)

Le regex correspond à l'octet nul, mais la chaîne complète est dangereuse.

✅ Correction : rejeter explicitement les octets nuls avant Regex:

 if (strPos ($ entrée, "\ 0")! == false) {
    // rejeter ou manipuler
}

Ou utilisez des motifs plus stricts avec \A et \z (début / fin absolu):

 preg_match ('/ \ a [\ w \.] \ z /', $ input); // assure une correspondance complète de cordes

Meilleures pratiques générales

Pour éviter les pièges d'octets nuls en php:

• ✅ Filtrez des octets nuls de l'entrée de l'utilisateur:

   $ Clean = str_replace ("\ 0", '', $ entrée); // ou rejeter entièrement

• ✅ Utilisez des fonctions intégrées comme basename() , realpath() et filter_input()
• ✅ Valider et désinfecter toutes les données externes - ne supposez jamais qu'elle est sûre
• ✅ Évitez l'interpolation directe des chaînes dans les appels système ou SQL
• ✅ Utilisez des fonctions de satection binaire lors de la gestion des données brutes

---

Les octets nuls ne sont pas intrinsèquement mauvais, mais ils exposent l'écart entre la manipulation de cordes de haut niveau de PHP et le monde de bas niveau de C. en validant les entrées tôt et en comprenant où vont vos cordes, vous pouvez éviter la troncature, les défauts de sécurité et les maux de tête.

Fondamentalement: traiter les octets nuls comme tout autre entrée dangereuse - les filtrer ou les gérer explicitement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!