Cálculo del hash de archivos en intercambios seguros

Cálculo del hash de archivos en intercambios seguros

En Secure Exchanges, utilizamos un método robusto y eficiente para calcular el hash SHA-512 de archivos de todos los tamaños. Nuestro enfoque garantiza la seguridad e integridad de los datos, a la vez que optimiza el rendimiento para archivos de gran tamaño.

Método de cálculo de hash

  1. Archivos de 1 GB o menos :

    • Para archivos de tamaño igual o menor a 1 GB, utilizamos un método estándar de cálculo del hash SHA-512 en una sola pasada en todo el archivo.

  2. Archivos de más de 1 GB :

    • Para archivos de más de 1 GB, dividimos el archivo en bloques de 100 MB.
    • Calculamos el hash SHA-512 de cada bloque individualmente.
    • Combinamos los hashes de cada bloque en una sola cadena.
    • Calculamos el hash final de esta cadena combinada.

Consulta en línea

Para ofrecer a nuestros usuarios la máxima flexibilidad, cualquier persona con un archivo también puede consultar nuestra página dedicada a calcular su hash: Calculadora de Hash . Este servicio está diseñado para proporcionar un cálculo de hash rápido y fiable, independientemente del tamaño del archivo.

Información
A partir del 24 de junio de 2024, implementamos este nuevo método de cálculo de hash para mejorar el rendimiento y la gestión de archivos grandes. Antes de esta fecha, el hash se calculaba mediante el método tradicional. Esta actualización refleja nuestro compromiso continuo con la optimización de nuestros servicios para satisfacer las necesidades de nuestros usuarios.

En Secure Exchanges, nos comprometemos a brindar soluciones seguras y eficientes para todas sus necesidades de gestión de archivos.

Código de ejemplo

Aquí hay algunos ejemplos de código en C#, JavaScript para calcular el hash SHA-512 de un archivo utilizando nuestro enfoque.

do#
  2. utilizando el sistema;
  3. utilizando System.Collections.Generic;
  4. utilizando System.IO;
  5. utilizando System.Security.Cryptography;
  6. utilizando System.Text;

  9. Hashing de clase estática pública
  10. {
  11. cadena estática pública GetSHA512OfFile(cadena filePath)
  12. {
  13. si (Archivo.Existe(rutaArchivo))
  14. {
  15. constante int tamaño del fragmento = 100 * 1024 * 1024; // 100 MB
  16. constante larga largeFileTrigger = 1000 * 1024 * 1024; // 1 GB
  17. FileInfo fileInfo = new FileInfo(rutaArchivo);
  18. tamaño de archivo largo = fileInfo.Length;

  20. si (tamaño del archivo <= largeFileTrigger)
  21. {
  22. // Para archivos menores o iguales a 1 GB, calcule el hash directamente
  23. usando (var stream = new BufferedStream(Archivo.OpenRead(filePath), chunkSize))
  24. {
  25. devolver GetSHA512OfStream(flujo);
  26. }
  27. }
  28. demás
  29. {
  30. // Para archivos de más de 1 GB, utilice el método fragmentado
  31. Lista<string> blockHashes = nueva Lista<string>();
  32. usando (var stream = new BufferedStream(Archivo.OpenRead(filePath), chunkSize))
  33. {
  34. byte[] buffer = nuevo byte[chunkSize];
  35. int bytesLeído;
  36. mientras ((bytesRead = stream.Read(buffer, 0, chunkSize)) > 0)
  37. {
  38. usando (SHA512 sha512 = SHA512.Create())
  39. {
  40. byte[] chunkHash = sha512.ComputeHash(búfer, 0, bytesRead);
  41. blockHashes.Add(BitConverter.ToString(chunkHash).Replace("-", "").ToLower());
  42. }
  43. }
  44. }
  45. // Combinar hashes de bloque y calcular el hash final
  46. cadena combinedHashString = cadena.Join("", blockHashes);
  47. usando (SHA512 sha512 = SHA512.Create())
  48. {
  49. byte[] finalHash = sha512.ComputeHash(Encoding.UTF8.GetBytes(combinedHashString));
  50. devuelve BitConverter.ToString(finalHash).Replace("-", "").ToUpper();
  51. }
  52. }
  53. }
  54. demás
  55. {
  56. devuelve nulo;
  57. }
  58. }

  60. cadena estática pública GetSHA512OfStream(Stream stream)
  61. {
  62. usando (var sha = SHA512.Create())
  63. {
  64. devuelve GetHexaString(sha.ComputeHash(stream));
  65. }
  66. }

  68. cadena estática privada GetHexaString(byte[] hash)
  69. {
  70. si (hash != nulo)
  71. {
  72. StringBuilder sb = nuevo StringBuilder();
  73. para (int i = 0; i < hash.Length; i++)
  74. {
  75. sb.Append(hash[i].ToString("X2"));
  76. }
  77. devolver sb.ToString();
  78. }
  79. devolver cadena.Vacío;
     }
    }

Javascript

Cita
  2. var ventana = self;
  3. var documento = {};

  5. onmessage = función asíncrona (argumentos) {
  6. var obj = args.data;
  7. deje que el lector = nuevo FileReader();
  8. var hash = {};
  9. var chunkSize = 100 * 1024 * 1024; // Tamaño de fragmento de 100 MB para archivos grandes
  10. var largeFileTrigger = 1000 * 1024 * 1024; // El archivo de 1 GB utilizará el enfoque de bloque
  11. var isLargeFile = obj.File.size > largeFileTrigger;

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

  16. deje que blockHashes = [];

  18. reader.onload = función asíncrona (evt) {
  19. si (esArchivoGrande) {
  20. deje que blockHash = espere digestMessage(evt.currentTarget.result);
  21. blockHashes.push(blockHash);
  22. } demás {
  23. blockHashes.push(evt.currentTarget.result);
  24. }
  25. leerSiguiente();
  26. }

  28. deje que readNext = función asíncrona () {
  29. si (chunksQueue.length > 0) {
  30. constante chunkId = chunksQueue.pop();
  31. constante tamañoEnviado = chunkId * tamañoDeChunk;
  32. const chunk = obj.File.slice(enviadoTamaño, enviadoTamaño + chunkSize);
  33. lector.readAsArrayBuffer(fragmento);
  34. } demás {
  35. lector.abort();
  36. var hexHash = nulo;
  37. si (esArchivoGrande) {
  38. deje que combinedHashBuffer = nuevo TextEncoder().encode(blockHashes.join(''));
  39. hexHash = esperar digestMessage(combinedHashBuffer);
  40. } demás {
  41. hexHash = esperar mensaje de digestión (blockHashes[0]);
  42. }

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

  49. leerSiguiente();
  50. }

  52. // Función para digerir el mensaje y devolver una cadena hexadecimal
  53. función asíncrona digestMessage(buffer) {
  54. constante hashBuffer = await crypto.subtle.digest('SHA-512', buffer);
  55. constante hashArray = Array.from(new Uint8Array(hashBuffer));
  56. constante hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
  57. devuelve hashHex;
  58. }