English
English
When handling large file uploads, chunked upload is a commonly used technique that allows a file to be divided into smaller chunks for sequential uploading without waiting for the entire file to be fully uploaded. Meanwhile, to ensure the file has not been tampered with during transmission, hash algorithms are typically used to verify the integrity of the file. PHP provides the hash_update_stream function, which helps us achieve chunked upload hashing. This article will explain in detail how to use the hash_update_stream function for this purpose.
hash_update_stream is a hashing function in PHP that performs hashing operations on a stream (such as a file or data stream). In the context of chunked uploads, this function can be called each time a file chunk is uploaded to update the hash value, ensuring that the hash of each chunk is correctly calculated and verified for integrity.
Function prototype:
bool hash_update_stream ( resource $context , resource $handle [, int $length = 8192 ] )
$context: Specifies a hash context, typically created with the hash_init function.
$handle: A resource pointing to the opened file or data stream.
$length: The number of bytes to read at a time, defaulting to 8192 bytes.
Suppose we have a large file that needs to be uploaded in chunks, and each chunk must undergo a hash verification. The following steps can be used to implement chunked upload hashing:
First, create a hash context and select a hashing algorithm (e.g., sha256) for the computation.
$hashContext = hash_init('sha256');
Next, we open the file stream and upload the content in chunks. Each time a chunk is uploaded, we call the hash_update_stream function to update the hash value.
$filePath = 'path/to/largefile.zip'; // File path
$chunkSize = 8192; // Chunk size per read
<p>$fileHandle = fopen($filePath, 'rb'); // Open the file stream<br>
if (!$fileHandle) {<br>
die('Unable to open file');<br>
}</p>
<p>while (!feof($fileHandle)) {<br>
// Read a chunk from the file stream<br>
$chunk = fread($fileHandle, $chunkSize);</p>
hash_update_stream($hashContext, $chunk);
// Upload the chunk here
// Assume you have an upload function to upload each chunk
// upload_chunk($chunk);
}
// Close the file stream
fclose($fileHandle);
Once all file chunks have been uploaded and processed, we can use the hash_final function to get the final hash value.
$finalHash = hash_final($hashContext);
echo "The file's hash value is: $finalHash";
This ensures that the hash of each file chunk has been correctly calculated, and the overall hash value for the entire file is obtained.
During the chunked upload process, each time a chunk is uploaded, the client can send the corresponding hash value (or the final hash for the entire file) to the server. The server can then use the received hash to verify the file's integrity.
The server-side verification process is as follows:
// Assume the server receives the hash value uploaded by the client
$receivedHash = $_POST['file_hash'];
<p>// Recalculate the hash on the server<br>
$serverHashContext = hash_init('sha256');<br>
$fileHandle = fopen('path/to/uploaded_chunk', 'rb'); // Open the uploaded file chunk</p>
<p>while (!feof($fileHandle)) {<br>
$chunk = fread($fileHandle, 8192);<br>
hash_update_stream($serverHashContext, $chunk);<br>
}</p>
<p>$calculatedHash = hash_final($serverHashContext);</p>
<p>// Verify the hash value<br>
if ($calculatedHash === $receivedHash) {<br>
echo 'File chunk hash verification passed';<br>
} else {<br>
echo 'File chunk hash verification failed';<br>
}</p>
<p>fclose($fileHandle);<br>
Using the hash_update_stream function for chunked upload hashing is a simple and effective method that ensures the integrity of each file chunk during the upload process. By following the steps outlined above, we can upload files in chunks and verify their integrity with hash values, ensuring that the uploaded data has not been tampered with. It is important to ensure that each chunk is uploaded in the correct order, and the server should also perform the corresponding hash verification.
That concludes the basic method for using the hash_update_stream function for chunked upload hashing. We hope this article is helpful to you!
