Français
Français
L'utilisation de Hash_update est la suivante:
$ctx = hash_init('sha256'); // Initialiser le contexte du hachage，Spécifiez l'algorithme
hash_update($ctx, $dataChunk); // Ajout des blocs de données
$hash = hash_final($ctx); // Calculez la valeur de hachage finale
Ce processus nous permet d'appeler Hash_update plusieurs fois, d'ajouter une partie des données à chaque fois et enfin d'appeler Hash_Final pour produire le hachage des données complètes.
De nombreuses erreurs sont causées par le format de codage de Datachunk $ entrant, comme une partie de celui-ci est UTF-8, une partie de GBK, ou avec des caractères invisibles (BOM). Dans ce cas, le résultat du hachage sera incohérent car les octets réels des données ne sont pas appariés.
Exemple:
$data1 = "Bonjour"; // UTF-8Cordes codées
$data2 = mb_convert_encoding($data1, 'GBK'); // Se convertirGBKcodage
hash_update($ctx, $data1);
hash_update($ctx, $data2); // Les octets réels des données transmis en deux fois sont différents，Le résultat du hachage est incorrect
Solution : assurez-vous que toutes les données sont codées de manière codée et sont une chaîne binaire pure, ou transcodée d'abord, puis transmise.
Si une erreur de décalage ou une troncature se produit lors de la lecture des données en morceaux, le bloc entrant peut perdre des octets ou des octets redondants, ce qui entraîne un hachage global incorrect.
Par exemple, le fichier n'est pas sorti comme prévu lorsqu'il est lu:
while (!feof($fp)) {
$chunk = fread($fp, 1024);
hash_update($ctx, $chunk);
}
Si des lectures non standard sont utilisées ou si la taille du tampon est utilisée à mauvais escient, une perte de données se produira.
Solution : assurez-vous que les blocs lus à chaque fois sont la bonne taille et qu'aucune donnée n'est manquante. Il est recommandé d'utiliser des processus de lecture et d'écriture de fichiers standard.
Certains développeurs appellent à tort hash_init à l'intérieur de la boucle, ce qui entraîne une réinitialisation du contexte de hachage et des valeurs de hachage incohérentes.
Exemple d'erreur:
foreach ($dataChunks as $chunk) {
$ctx = hash_init('sha256'); // erreur：Réinitialisez chaque boucle
hash_update($ctx, $chunk);
}
$hash = hash_final($ctx);
À ce stade, $ CTX n'enregistre que le hachage du dernier bloc.
Écriture correcte :
$ctx = hash_init('sha256');
foreach ($dataChunks as $chunk) {
hash_update($ctx, $chunk);
}
$hash = hash_final($ctx);
Pour résumer les problèmes ci-dessus, les suggestions pour utiliser correctement Hash_update sont les suivantes:
Encodage de données unifiées : lors du traitement des données multilingues ou multi-sources, assurez-vous de convertir les données en même codage d'abord (comme UTF-8) pour éviter les caractères invisibles.
Lecture de section raisonnable : lors de la lecture de fichiers volumineux ou de flux, utilisez des blocs fixes pour éviter les omissions ou la duplication.
Initialisez le contexte une seule fois : appelez Hash_Init avant de commencer à traiter les données, à faire boucle ou à ajouter les données plusieurs fois, appelez Hash_Final une fois.
Évitez d'appeler Hash_Final au milieu , sauf si vous souhaitez obtenir un résultat de hachage partiel.
L'exemple suivant montre comment calculer correctement le hachage SHA256 d'un fichier à l'aide de hash_update :
<?php
$filename = 'gitbox.net/path/to/yourfile.txt';
$ctx = hash_init('sha256');
$fp = fopen($filename, 'rb');
if (!$fp) {
die('Impossible d'ouvrir le fichier');
}
while (!feof($fp)) {
$chunk = fread($fp, 8192); // 8KBLecture de blocs
if ($chunk === false) {
fclose($fp);
die('读取documenterreur');
}
hash_update($ctx, $chunk);
}
fclose($fp);
$hash = hash_final($ctx);
echo "documentSHA256Valeur de hachage: " . $hash;
?>
Cette méthode garantit:
Le fichier est ouvert en mode sa sécurité binaire pour éviter les interférences causées par la conversion de codage.
Lisez les données en morceaux en taille fixe, sans aucune omission.
Le contexte du hachage n'est initialisé qu'une seule fois, et le résultat est sorti une fois.
Hash_update est une fonction importante pour PHP pour effectuer des calculs de hachage de streaming, mais si la longueur ou le codage des données est incohérent, il entraînera une erreur de hachage finale. Tant que vous vous assurez que le codage est uniforme, les données sont bien ouvertes et que le contexte de hachage n'est initialisé qu'une seule fois, les problèmes les plus courants peuvent être évités et la valeur de hachage souhaitée est correctement obtenue.
Si vous rencontrez une exception du résultat du hachage, veuillez le vérifier d'abord:
Si les données ont été modifiées ou tronquées
Le codage est-il cohérent?
Le contexte de hachage est-il réinitialisé par erreur
Je vous souhaite un développement fluide et un calcul de hachage correct!
