English
English
The usage of hash_update is as follows:
$ctx = hash_init('sha256'); // Initialize hash context，Specify the algorithm
hash_update($ctx, $dataChunk); // Append data blocks
$hash = hash_final($ctx); // Calculate the final hash value
This process allows us to call hash_update multiple times, append part of the data each time, and finally call hash_final to output the hash of the complete data.
Many errors are caused by the incoming $dataChunk encoding format, such as part of it is UTF-8, part of it is GBK, or with invisible characters (BOM). In this case, the hash result will be inconsistent because the actual bytes of the data are not matched.
Example:
$data1 = "Hello"; // UTF-8Encoded strings
$data2 = mb_convert_encoding($data1, 'GBK'); // Convert toGBKcoding
hash_update($ctx, $data1);
hash_update($ctx, $data2); // The actual bytes of the data passed in two times are different，The hash result is incorrect
Solution : Make sure that all data is encoded consistently and is a pure binary string, or transcoded first and then passed in.
If an offset error or truncation occurs when reading data in chunks, the incoming block may lose some bytes or redundant bytes, resulting in an incorrect overall hash.
For example, the file is not chunked as expected when it is read:
while (!feof($fp)) {
$chunk = fread($fp, 1024);
hash_update($ctx, $chunk);
}
If non-standard reads are used or buffer size is misused, data loss will occur.
Solution : Make sure that the blocks read each time are the correct size and that no data is missing. It is recommended to use standard file reading and writing processes.
Some developers mistakenly call hash_init inside the loop, causing the hash context to be reset and hash values to be inconsistent.
Error example:
foreach ($dataChunks as $chunk) {
$ctx = hash_init('sha256'); // mistake：Reset every loop
hash_update($ctx, $chunk);
}
$hash = hash_final($ctx);
At this point, $ctx only saves the hash of the last block.
Correct writing :
$ctx = hash_init('sha256');
foreach ($dataChunks as $chunk) {
hash_update($ctx, $chunk);
}
$hash = hash_final($ctx);
To summarize the above issues, the suggestions for correctly using hash_update are as follows:
Unified data encoding : When processing multilingual or multi-source data, make sure to convert the data to the same encoding first (such as UTF-8) to avoid invisible characters.
Reasonable chunking reading : When reading large files or streams, use fixed blocks to avoid omissions or duplication.
Initialize the context only once : call hash_init before starting to process data, loop or append data multiple times, call hash_final once.
Avoid calling hash_final in the middle , unless you want to get a partial hash result.
The following example demonstrates how to correctly calculate the SHA256 hash of a file using hash_update :
<?php
$filename = 'gitbox.net/path/to/yourfile.txt';
$ctx = hash_init('sha256');
$fp = fopen($filename, 'rb');
if (!$fp) {
die('Unable to open the file');
}
while (!feof($fp)) {
$chunk = fread($fp, 8192); // 8KBBlock reading
if ($chunk === false) {
fclose($fp);
die('读取documentmistake');
}
hash_update($ctx, $chunk);
}
fclose($fp);
$hash = hash_final($ctx);
echo "documentSHA256Hash value: " . $hash;
?>
This method ensures:
The file is opened in binary safe mode to avoid interference caused by encoding conversion.
Read data in chunks in fixed size, without any omissions.
The hash context is initialized only once, and the result is output once.
hash_update is an important function for PHP to perform streaming hash calculations, but if the data length or encoding is inconsistent, it will cause a final hash error. As long as you ensure that the encoding is uniform, the data is chunked correctly, and the hash context is initialized only once, most common problems can be avoided and the desired hash value is correctly obtained.
If you encounter an exception of the hash result, please check it first:
Whether the data has been modified or truncated
Is the encoding consistent?
Is the hash context reset by error
I wish you a smooth development and a correct hash calculation!
