Calcul du Hash des fichiers chez Secure Exchanges

Calcul du Hash des fichiers chez Secure Exchanges

Chez Secure Exchanges, nous utilisons une méthode robuste et efficace pour calculer le hash SHA-512 de fichiers de toutes tailles. Notre approche assure la sécurité et l'intégrité des données tout en optimisant les performances pour les fichiers volumineux.

Méthode de Calcul du Hash

  1. Fichiers de 1 Go ou moins :

    • Pour les fichiers de taille égale ou inférieure à 1 Go, nous utilisons une méthode standard de calcul du hash SHA-512 en une seule passe sur l'ensemble du fichier.

  2. Fichiers de plus de 1 Go :

    • Pour les fichiers de taille supérieure à 1 Go, nous divisons le fichier en blocs de 100 MB.
    • Nous calculons le hash SHA-512 de chaque bloc individuellement.
    • Nous combinons les hashes de chaque bloc en une seule chaîne.
    • Nous calculons le hash final de cette chaîne combinée.

Consultation en Ligne

Pour offrir à nos utilisateurs une flexibilité maximale, quiconque détient un fichier peut également consulter notre page dédiée pour calculer le hash de leur fichier : Calculateur de Hash. Ce service est conçu pour fournir un calcul rapide et fiable du hash, quel que soit la taille du fichier.

À partir du 24 juin 2024, nous avons mis en œuvre cette nouvelle méthode de calcul du hash pour améliorer les performances et la gestion des fichiers volumineux. Avant cette date, le hash était calculé de manière traditionnelle. Cette mise à jour reflète notre engagement continu à optimiser nos services pour répondre aux besoins de nos utilisateurs.

Chez Secure Exchanges, nous nous engageons à fournir des solutions sécurisées et performantes pour tous vos besoins de gestion de fichiers.

Exemple de Code

Voici des exemples de code en C#, JavaScript pour calculer le hash SHA-512 d'un fichier en utilisant notre approche.

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

  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. }

    • Related Articles

    • Installation du nouveau certificat SSL de Secure Exchanges - Administrateur

      Si vous avez une autre procédure, vous pouvez bien sûr l'utiliser. Le script que nous proposons est simplement une aide pour simplifier le processus. L'important, c'est de vous s'assurer que notre nouveau certificat soit bien ajouté dans ...

    • L'Analyse de Vulnérabilité de Secure Exchanges

      Secure Exchanges offre une fonctionnalité d'analyse de vulnérabilité pour aider à détecter des échanges contenant des informations potentiellement vulnérables et à risque d'être compromises. Voici un guide étape par étape pour utiliser cette fonction ...

    • Quels sont les paramètres de configuration de Secure Exchanges sur Gmail?

      Pour configurer les paramètres de Secure Exchanges sur Gmail, vous devez cliquer sur l'extension Secure Exchanges puis sur Paramètres. Vous verrez donc apparaître la fenêtre suivante incluant diverses options: Vous pouvez ainsi définir les options ...

    • Comment conserver les fichiers cryptés ?

      Pour que SESAR conserve vos fichiers chiffrés sur disque, vous devez générer une nouvelle clé publique/privée. Conservez la clé privée en lieu sûr et partagez avec l’équipe de Secure Exchanges votre clé publique. (pour utiliser SESAR restore vous ...

    • Quels sont les paramètres de configuration de Secure Exchanges sur Outlook?

      Divers paramètres Secure Exchanges peuvent être configurés sur Outlook : 1. Paramètres de message : Sur ce volet, vous pouvez définir les options d'envoi et de réception de vos courriels sécurisés, la langue de votre connecteur et de communication, ...