Files hash Calculation 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 the security and integrity of the data while optimizing performance for large files.

Hash Calculation Method

1. Files of 1 GB or less:

   • For files of 1 GB or less, we use a standard method to calculate the SHA-512 hash in a single pass over the entire file.

2. Files larger than 1 GB:

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

Online Consultation

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

As of June 24, 2024, we have implemented this new hash calculation method to improve performance and manage large files more efficiently. Before this date, the hash was calculated in the traditional way. 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 high-performance solutions for all your file management needs.

Code sample

Here are examples of code in C# and 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;
   
8. 
   
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;
19. 
    
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.     }
59. 
    
60.     public static string GetSHA512OfStream(Stream stream)
61.     {
62.         using (var sha = SHA512.Create())
63.         {
64.             return GetHexaString(sha.ComputeHash(stream));
65.         }
66.     }
67. 
    
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;
        }
    }
80. 
    

Javascript

2. var window = self;
3. var document = {};
4. 
   
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;
12. 
    
13.     const chunksQuantity = Math.ceil(obj.File.size / chunkSize);
14.     const chunksQueue = new Array(chunksQuantity).fill().map((_, index) => index).reverse();
15. 
    
16.     let blockHashes = [];
17. 
    
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.     }
27. 
    
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.             }
43. 
    
44.             hash.SHA512 = hexHash.toUpperCase();
45.             postMessage({ Hash: hash, File: obj.File, ID: obj.ID, ReturnObject: obj.ReturnObject });
46.         }
47.     }
48. 
    
49.     readNext();
50. }
51. 
    
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. }

• Related Articles

• My Secure Exchanges tab is no longer present in my Outlook ribbon.

  If your Secure Exchanges tab is no longer present in your Outlook ribbon but was previously : Please follow these steps : 1. Go to Outlook, under File / Account Information / Manage COM Add-ins. 2. If the OSecureExchanges files is there, check if the ...

• What are the configuration settings for Secure Exchanges on Gmail?

  To configure the Secure Exchanges settings on Gmail, you need to click on the Secure Exchanges extension and then on Settings. You will therefore see the following window appear with various options: You can thus define the options of the emails by ...

• What are the Secure Exchanges configuration settings on Outlook?

  Various Secure Exchanges settings can be configured on Outlook: 1. Messages Settings : On this pane, you can define the options for sending and receiving your secure emails, the language of your connector and communication, the security and opening ...

• Installing the new Secure Exchanges SSL certificate - Administrator

  If you have another procedure, you can certainly use it. The script we provide is simply a tool to help streamline the process. The important thing is to ensure that our new certificate is properly added to TrustedPublisher for each Secure Exchanges ...

• How to keep encrypted files?

  In order for SESAR to keep your encrypted files on disk, you must generate a new public/private key. Keep the private key in a safe place and share your public key with the Secure Exchanges team. (to use SESAR restore you must enter your private key ...