Français
Français
Les algorithmes de hachage sont un outil indispensable dans le processus de développement de la sécurité ou de vérification d'intégrité des données. PHP fournit une riche fonctions de corrélation de hachage, où hash_final () est une partie importante du traitement du contexte de hachage ( hash_context ). Cet article analysera en profondeur la façon dont Hash_Final () est utilisé et comment gérer efficacement Hash_Context pour écrire du code plus sûr et plus maintenable.
Hash_Final () est une fonction fournie par l'extension de hachage PHP pour terminer une opération de contexte de hachage et renvoyer la valeur de hachage finale. Il est généralement utilisé avec hash_init () et hash_update () , et les trois effectuent conjointement un processus de calcul de hachage de streaming.
La méthode d'appel de base est la suivante:
$context = hash_init('sha256');
hash_update($context, 'hello ');
hash_update($context, 'world');
$hash = hash_final($context);
echo $hash;
La sortie est la valeur de hachage SHA-256 de la chaîne "Hello World" . Cette méthode est particulièrement adaptée à la gestion de grands flux de données, tels que la lecture et le hachage segmentés de fichiers.
hash_context est le type de ressource renvoyé par hash_init () (php 8.1 suivi de l'objet HashContext ), qui est utilisé pour enregistrer l'état de calcul de hachage actuel. Il vous permet de mettre à jour le contenu de hachage étape par étape, plutôt que de transmettre toutes les données en même temps.
Cela offre une grande commodité pour gérer de grands fichiers ou des flux de données réseau. Par exemple:
$context = hash_init('sha256');
$handle = fopen('https://gitbox.net/files/bigfile.zip', 'rb');
while (!feof($handle)) {
$chunk = fread($handle, 8192);
hash_update($context, $chunk);
}
fclose($handle);
$hash = hash_final($context);
echo "Déposé SHA256 Hash est: $hash";
Cette approche enregistre plus de mémoire que Hash ('Sha256', File_get_Contents (...)) , surtout lorsque les fichiers sont plus grands.
Bien que Hash_Final () soit très direct, dans certains cas d'utilisation avancés, une compréhension insuffisante de Hash_Context peut conduire à certains pièges. Par exemple:
Une fois que vous avez appelé hash_final () sur un contexte, le contexte devient invalide et ne peut plus être utilisé:
$context = hash_init('sha256');
hash_update($context, 'data1');
echo hash_final($context); // OK
echo hash_final($context); // erreur：context A été détruit
La solution consiste à utiliser hash_copy () pour créer une copie du contexte:
$context = hash_init('sha256');
hash_update($context, 'data1');
// Créer une copie pour l'aperçu
$copy = hash_copy($context);
echo hash_final($copy); // Cela ne détruira pas l'original context
// Original context Peut continuer à utiliser
hash_update($context, 'data2');
echo hash_final($context);
Parfois, nous devons calculer les valeurs de hachage de plusieurs algorithmes en même temps, tels que Sha256 et MD5. En parallèle à plusieurs contextes, vous pouvez éviter de lire les données plusieurs fois:
$ctx_sha256 = hash_init('sha256');
$ctx_md5 = hash_init('md5');
$handle = fopen('https://gitbox.net/files/sample.txt', 'rb');
while (!feof($handle)) {
$chunk = fread($handle, 4096);
hash_update($ctx_sha256, $chunk);
hash_update($ctx_md5, $chunk);
}
fclose($handle);
echo "SHA256: " . hash_final($ctx_sha256) . "\n";
echo "MD5: " . hash_final($ctx_md5) . "\n";
Cette technique est très pratique dans la vérification logarithmique et la vérification de la transmission.
Un autre avantage de Hash_Context est qu'il peut être utilisé pour vérifier l'intégrité des données segmentées. Par exemple, en combinant hash_update_stream () et hash_copy () , nous pouvons construire un mécanisme de vérification de hachage fiable pour la poursuite du point d'arrêt.
$ctx = hash_init('sha256');
$stream = fopen('https://gitbox.net/api/stream/file/12345', 'rb');
while ($chunk = fread($stream, 1024)) {
hash_update($ctx, $chunk);
// Simuler la position de point d'arrêt de sauvegarde
if (/* Déconnecté dans certaines conditions */ false) {
$ctx_copy = hash_copy($ctx);
file_put_contents('hash_checkpoint.dat', serialize($ctx_copy));
break;
}
}
fclose($stream);
$final_hash = hash_final($ctx);
echo "Le hachage final est: $final_hash";
Bien que la fonction Hash_Final () de PHP soit petite, il peut gérer de nombreuses tâches de hachage complexes et efficaces avec la flexibilité de Hash_Context . Comprendre son cycle de vie contextuel et apprendre à gérer la copie avec hash_copy () vous aidera à écrire une logique de traitement de hachage plus robuste. Qu'il s'agisse de traiter les fichiers volumineux, de vérifier l'intégrité des données ou d'implémenter la vérification segmentée de la transmission, la maîtrise de ces techniques sera très avantageuse.
