Français
Français
Dans le développement de PHP, nous devons souvent comparer les chaînes, en particulier lors du traitement des données sensibles sécurisées telles que les mots de passe, les valeurs de hachage, les signatures, etc. En règle générale, les développeurs peuvent avoir tendance à utiliser "==" pour des comparaisons de chaînes simples. Cependant, lorsque nous discutons des chaînes de hachage, PHP fournit une fonction spéciale hash_equals () pour comparaison. Pourquoi PHP ne recommande-t-il pas d'utiliser "==" au lieu de hash_equals () , mais recommande ce dernier? Discutons des raisons derrière cela.
Dans PHP, == est un opérateur de comparaison lâche, ce qui signifie qu'il convertira automatiquement l'opérande pour comparer en fonction du type d'opérande. Ce comportement peut conduire à des résultats inattendus lorsqu'ils traitent des nombres et des chaînes. Par exemple:
<span><span><span class="hljs-variable">$hash1</span></span><span> = </span><span><span class="hljs-string">"abc"</span></span><span>;
</span><span><span class="hljs-variable">$hash2</span></span><span> = </span><span><span class="hljs-string">"a"</span></span><span> . </span><span><span class="hljs-string">"bc"</span></span><span>;
</span><span><span class="hljs-title function_ invoke__">var_dump</span></span><span>(</span><span><span class="hljs-variable">$hash1</span></span><span> == </span><span><span class="hljs-variable">$hash2</span></span><span>); </span><span><span class="hljs-comment">// Sortir: bool(true)</span></span><span>
</span></span>Dans l'exemple ci-dessus, $ hash1 et $ hash2 ne se ressemblent pas au début, mais comme PHP fait une conversion de type lorsque vous effectuez des comparaisons lâches, il supposera que les deux chaînes sont égales.
Plus important encore, PHP essaiera de comparer chaque caractère dans la chaîne jusqu'à ce qu'il soit constaté qu'un caractère dans les deux chaînes est différent. Cependant, de telles comparaisons lâches ne s'appliquent pas aux valeurs de hachage, car les valeurs de hachage sont des représentations de données binaires et ont des exigences de rigueur très élevées pour chaque caractère en termes de sécurité. Même avec de légères différences, la valeur de hachage doit être considérée comme différente. Par conséquent, == ne convient pas aux comparaisons de hachage.
Contrairement à == , hash_equals () est spécialement conçu pour la comparaison de la valeur de hachage. Il se comporte très strictement, n'effectue pas de conversions de type et n'est pas affectée par des comparaisons PHP lâches. hash_equals () vérifie le contenu de l'octet d'octets de deux cordes pour s'assurer qu'ils sont exactement les mêmes. S'il y a une différence, il renvoie faux immédiatement et il n'y a aucune erreur en raison du type de chaîne ou d'autres facteurs.
De plus, Hash_equals () a également le problème de prévenir les attaques de synchronisation. L'attaque de synchronisation est une méthode d'attaque qui utilise des différences de temps de fonctionnement pour deviner les données sensibles. Si vous utilisez == pour comparer directement les valeurs de hachage, PHP peut fuir certaines informations pendant le processus de comparaison, et l'attaquant peut déduire les différences entre les différentes valeurs de hachage par une observation minutieuse. hash_equals () donnera le résultat après que tous les caractères sont comparés, évitant ainsi cette vulnérabilité de sécurité.
Parce que == est une comparaison lâche, elle peut ressentir un comportement imprévisible lors du traitement des valeurs de hachage. Par exemple, si vous utilisez "==" lorsque vous faites des comparaisons de hachage et que la longueur de chaîne de hachage d'entrée est incohérente, PHP peut le remplir, ce qui entraîne des correspondances inutiles. Il n'y aura pas de tel problème avec hash_equals () , qui comparera avec précision chaque octet des deux chaînes pour s'assurer qu'ils sont exactement cohérents.
L'un des risques d'utilisation == pour comparer les valeurs de hachage est le potentiel de divulgation d'informations sur la longueur des chaînes. Si PHP utilise différents algorithmes de traitement de chaîne ou conversions de caractères dans la comparaison de deux chaînes de hachage, un attaquant peut être en mesure de faire deviner une information à travers le décalage horaire.
hash_equals () fournit une comparaison à temps constant, c'est-à-dire que le temps d'exécution de la chaîne d'entrée est le même, ce qui est très important pour empêcher les attaques de synchronisation.
Bien que la mise en œuvre de hash_equals () puisse être légèrement plus lente que == , ses avantages de sécurité dépassent de loin cette surcharge de performance. Surtout lorsque vous traitez avec des mots de passe ou des données sensibles, la sécurité doit toujours avoir la priorité sur les performances. Par conséquent, même si == exécute plus rapidement dans certains cas, il est plus recommandé d'utiliser hash_equals () pour les comparaisons de hachage.
De plus, PHP a effectué des optimisations de performances lors de la mise en œuvre de hash_equals () pour s'assurer qu'elle fonctionne efficacement dans la plupart des cas.
En PHP, bien que "==" soit un opérateur de comparaison courant, il ne convient pas aux comparaisons de hachage, en particulier dans les situations où les exigences de sécurité sont élevées. hash_equals () est spécialement conçu pour les comparaisons de hachage, qui peuvent fournir une vérification plus stricte et plus sûre et éviter les problèmes qui peuvent être causés par des comparaisons lâches. Pour garantir la sécurité du code, en particulier en ce qui concerne les données sensibles telles que les mots de passe, les clés API ou les signatures numériques, les développeurs doivent toujours utiliser hash_equals () au lieu de == pour les comparaisons de hachage.
