File hash calculation at Secure Exchanges

How is the file hash calculated at Secure Exchanges?

At Secure Exchanges, we use a robust and efficient method to calculate the SHA-512 hash of files of all sizes. Our approach ensures data security and integrity while optimizing performance for large files.

Hash Calculation Method

  1. Files of 1 GB or less :

    • For files of size equal to or less than 1 GB, we use a standard method of calculating the SHA-512 hash in a single pass on the entire file.

  2. Files larger than 1 GB :

    • For files larger than 1 GB, we divide the file into 100 MB blocks.
    • We calculate the SHA-512 hash of each block individually.
    • We combine the hashes of each block into a single string.
    • We calculate the final hash of this combined string.

Online Consultation

To offer our users maximum flexibility, anyone with a file can also consult our dedicated page to calculate its hash: Hash Calculator . This service is designed to provide a fast and reliable hash calculation, regardless of file size.

Info
Starting June 24, 2024, we implemented this new hash calculation method to improve performance and the handling of large files. Prior to this date, hashing was calculated using the traditional method. This update reflects our ongoing commitment to optimizing our services to meet the needs of our users.

At Secure Exchanges, we are committed to providing secure and efficient solutions for all your file management needs.

Example Code

Here are some code examples in C#, JavaScript to calculate the SHA-512 hash of a file using our approach.

c#
  2. using System;
  3. using System.Collections.Generic;
  4. using System.IO;
  5. using System.Security.Cryptography;
  6. using System.Text;

  9. public static class Hashing
  10. {
  11. public static string GetSHA512OfFile(string filePath)
  12. {
  13. if (File.Exists(filePath))
  14. {
  15. const int chunkSize = 100 * 1024 * 1024; // 100 MB
  16. const long largeFileTrigger = 1000 * 1024 * 1024; // 1 GB
  17. FileInfo fileInfo = new FileInfo(filePath);
  18. long fileSize = fileInfo.Length;

  20. if (fileSize <= largeFileTrigger)
  21. {
  22. // For files smaller than or equal to 1 GB, calculate hash directly
  23. using (var stream = new BufferedStream(File.OpenRead(filePath), chunkSize))
  24. {
  25. return GetSHA512OfStream(stream);
  26. }
  27. }
  28. else
  29. {
  30. // For files larger than 1 GB, use chunked approach
  31. List<string> blockHashes = new List<string>();
  32. using (var stream = new BufferedStream(File.OpenRead(filePath), chunkSize))
  33. {
  34. byte[] buffer = new byte[chunkSize];
  35. int bytesRead;
  36. while ((bytesRead = stream.Read(buffer, 0, chunkSize)) > 0)
  37. {
  38. using (SHA512 sha512 = SHA512.Create())
  39. {
  40. byte[] chunkHash = sha512.ComputeHash(buffer, 0, bytesRead);
  41. blockHashes.Add(BitConverter.ToString(chunkHash).Replace("-", "").ToLower());
  42. }
  43. }
  44. }
  45. // Combine block hashes and calculate final hash
  46. string combinedHashString = string.Join("", blockHashes);
  47. using (SHA512 sha512 = SHA512.Create())
  48. {
  49. byte[] finalHash = sha512.ComputeHash(Encoding.UTF8.GetBytes(combinedHashString));
  50. return BitConverter.ToString(finalHash).Replace("-", "").ToUpper();
  51. }
  52. }
  53. }
  54. else
  55. {
  56. return null;
  57. }
  58. }

  60. public static string GetSHA512OfStream(Stream stream)
  61. {
  62. using (var sha = SHA512.Create())
  63. {
  64. return GetHexaString(sha.ComputeHash(stream));
  65. }
  66. }

  68. private static string GetHexaString(byte[] hash)
  69. {
  70. if (hash != null)
  71. {
  72. StringBuilder sb = new StringBuilder();
  73. for (int i = 0; i < hash.Length; i++)
  74. {
  75. sb.Append(hash[i].ToString("X2"));
  76. }
  77. return sb.ToString();
  78. }
  79. return string.Empty;
     }
    }

Javascript

Quote
  2. var window = self;
  3. var document = {};

  5. onmessage = async function (args) {
  6. var obj = args.data;
  7. let reader = new FileReader();
  8. var hash = {};
  9. var chunkSize = 100 * 1024 * 1024; // 100MB chunk size for large files
  10. var largeFileTrigger = 1000 * 1024 * 1024; // 1GB file will use block approach
  11. var isLargeFile = obj.File.size > largeFileTrigger;

  13. const chunksQuantity = Math.ceil(obj.File.size / chunkSize);
  14. const chunksQueue = new Array(chunksQuantity).fill().map((_, index) => index).reverse();

  16. let blockHashes = [];

  18. reader.onload = async function (evt) {
  19. if (isLargeFile) {
  20. let blockHash = await digestMessage(evt.currentTarget.result);
  21. blockHashes.push(blockHash);
  22. } else {
  23. blockHashes.push(evt.currentTarget.result);
  24. }
  25. readNext();
  26. }

  28. let readNext = async function () {
  29. if (chunksQueue.length > 0) {
  30. const chunkId = chunksQueue.pop();
  31. const sentSize = chunkId * chunkSize;
  32. const chunk = obj.File.slice(sentSize, sentSize + chunkSize);
  33. reader.readAsArrayBuffer(chunk);
  34. } else {
  35. reader.abort();
  36. var hexHash = null;
  37. if (isLargeFile) {
  38. let combinedHashBuffer = new TextEncoder().encode(blockHashes.join(''));
  39. hexHash = await digestMessage(combinedHashBuffer);
  40. } else {
  41. hexHash = await digestMessage(blockHashes[0]);
  42. }

  44. hash.SHA512 = hexHash.toUpperCase();
  45. postMessage({ Hash: hash, File: obj.File, ID: obj.ID, ReturnObject: obj.ReturnObject });
  46. }
  47. }

  49. readNext();
  50. }

  52. // Function to digest message and return hex string
  53. async function digestMessage(buffer) {
  54. const hashBuffer = await crypto.subtle.digest('SHA-512', buffer);
  55. const hashArray = Array.from(new Uint8Array(hashBuffer));
  56. const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
  57. return hashHex;
  58. }