Comment utiliser la fonction hash_update_stream pour implémenter le hachage de téléchargement Chunked (hachage de téléchargement)

Lors de la gestion des téléchargements de fichiers importants, le téléchargement de morceaux est une technique courante qui permet de diviser les fichiers en morceaux plus petits pour télécharger un par un sans attendre que le fichier entier soit complètement téléchargé. Dans le même temps, afin de s'assurer que le fichier téléchargé n'est pas falsifié pendant le processus de transmission, un algorithme de hachage est généralement utilisé pour vérifier l'intégrité du fichier. PHP fournit la fonction hash_update_stream , qui peut nous aider à implémenter le téléchargement de hachage segmenté. Cet article présentera en détail comment utiliser la fonction hash_update_stream pour implémenter cette fonction.

1. Introduction à la fonction hash_update_stream

La fonction hash_update_stream est une fonction de hachage dans PHP, qui est utilisée pour hacher un flux (comme un fichier, un flux de données, etc.). Dans un scénario de téléchargement segmenté, chaque fois qu'un bloc de fichiers est téléchargé, cette fonction peut être appelée pour mettre à jour la valeur de hachage, garantissant que chaque bloc de fichiers peut calculer correctement le hachage et effectuer une vérification d'intégrité.

Prototype de fonction:

 bool hash_update_stream ( resource $context , resource $handle [, int $length = 8192 ] )

• $ Context : Spécifie un contexte de hachage, généralement créé via la fonction hash_init .

• $ Handle : une ressource qui pointe vers un fichier ou un flux de données ouvert.

• $ Longueur : le nombre d'octets lus, la valeur par défaut est 8192 octets.

2. Comment implémenter le téléchargement de hachage segmenté

Supposons que nous ayons un fichier plus grand qui doit être téléchargé dans des segments, et chaque bloc de fichiers téléchargé nécessite une vérification de hachage. Nous pouvons implémenter le téléchargement de hachage segmenté comme suit:

2.1 Création d'un contexte de hachage

Tout d'abord, créez un contexte de hachage et sélectionnez un algorithme de hachage (tel que Sha256 ) pour le calcul.

 $hashContext = hash_init('sha256');

2.2 Ouvrez le fichier et téléchargez-le en segments

Ensuite, nous ouvrons le flux de fichiers et téléchargeons le contenu du fichier en segments. Chaque fois qu'un bloc de fichiers est téléchargé, nous appelons la fonction hash_update_stream pour mettre à jour la valeur de hachage.

 $filePath = 'path/to/largefile.zip'; // Chemin de fichier
$chunkSize = 8192; // Taille de bloc par lecture

$fileHandle = fopen($filePath, 'rb'); // Ouvrez le flux de fichiers
if (!$fileHandle) {
    die('Impossible d'ouvrir le fichier');
}

while (!feof($fileHandle)) {
    // Lire un bloc d'un flux de fichiers
    $chunk = fread($fileHandle, $chunkSize);
    
    // Mettre à jour la valeur de hachage
    hash_update_stream($hashContext, $chunk);
    
    // Télécharger les blocs de fichiers ici
    // Supposons que vous ayez une fonction de téléchargement pour télécharger chaque bloc
    // upload_chunk($chunk);
}

// Fermez le flux de fichiers
fclose($fileHandle);

2.3 Calculez et renvoyez la valeur de hachage finale

Une fois que tous les blocs du fichier sont téléchargés et traités, nous pouvons utiliser la fonction HASH_FINAL pour obtenir la valeur de hachage finale.

 $finalHash = hash_final($hashContext);
echo "La valeur de hachage du fichier est：$finalHash";

De cette façon, nous pouvons nous assurer que chaque bloc de fichiers est correctement haché et enfin obtenir la valeur de hachage de l'ensemble du fichier.

3. Vérifiez la valeur de hachage dans les segments avec le serveur

Pendant le processus de téléchargement segmenté, chaque fois que le client télécharge un bloc de fichiers, il peut envoyer la valeur de hachage correspondante (ou la valeur de hachage du fichier entier) au serveur et le serveur vérifie l'intégrité du fichier via la valeur de hachage reçue.

Le processus de vérification côté serveur est le suivant:

3.1 Recevoir et vérifier le hachage

 // Supposons que la valeur de hachage téléchargée par le client est reçue
$receivedHash = $_POST['file_hash'];

// Recalculer le hachage du côté serveur
$serverHashContext = hash_init('sha256');
$fileHandle = fopen('path/to/uploaded_chunk', 'rb'); // Ouvrez le bloc de fichiers téléchargé

while (!feof($fileHandle)) {
    $chunk = fread($fileHandle, 8192);
    hash_update_stream($serverHashContext, $chunk);
}

$calculatedHash = hash_final($serverHashContext);

// Vérifier la valeur de hachage
if ($calculatedHash === $receivedHash) {
    echo 'Vérification du hachage du bloc de fichiers passé';
} else {
    echo 'La vérification du hachage du bloc de fichiers a échoué';
}

fclose($fileHandle);

4. Résumé

L'utilisation de la fonction hash_update_stream pour implémenter le téléchargement de hachage segmenté est un moyen simple et efficace, ce qui peut assurer l'intégrité de chaque bloc de fichiers pendant le processus de téléchargement. Grâce aux étapes ci-dessus, nous pouvons télécharger le fichier dans des segments et utiliser la vérification de la valeur de hachage pour nous assurer que les données téléchargées n'ont pas été falsifiées. Il convient de noter que pendant le processus de téléchargement, pour s'assurer que chaque bloc du fichier peut être téléchargé dans le bon ordre, le serveur doit également effectuer une vérification de hachage correspondante.

Ce qui précède est la méthode de base de l'utilisation de la fonction hash_update_stream pour implémenter les téléchargements de hachage segmentés. J'espère que cet article vous sera utile!