¿Computing Hash al guardar un archivo?

Question

Tengo un inputStream que quiero usar para calcular un hash y guardar el archivo en el disco. Me gustaría saber cómo hacerlo de manera eficiente. ¿Debo usar alguna tarea para hacer eso al mismo tiempo, debería duplicar el pase de transmisión a dos flujos, uno para el método saveFile y otro para el método computeHash, o debería hacer algo más?

Answer 1

Tendrá que rellenar los bytes de la secuencia en un byte[] para picarlos.

Answer 2

¿Qué pasa con el uso de algoritmos hash que operan en un nivel de bloque? Puede agregar el bloque al hash (usando TransformBlock) y posteriormente escribir el bloque en el bloque foreach del archivo en la secuencia.

No comprobado tiro áspera:

using System.IO; 
using System.Security.Cryptography; 

... 

public byte[] HashedFileWrite(string filename, Stream input) 
{ 
    var hash_algorithm = MD5.Create(); 

    using(var file = File.OpenWrite(filename)) 
    { 
     byte[] buffer = new byte[4096]; 
     int read = 0; 

     while ((read = input.Read(buffer, 0, buffer.Length)) > 0) 
     { 
      hash_algorithm.TransformBlock(buffer, 0, read, null, 0); 
      file.Write(buffer, 0, read); 
     } 

     hash_algorithm.TransformFinalBlock(buffer, 0, read); 
    } 

    return hash_algorithm.Hash; 
} 

Answer 3

tal vez no sea la mejor opción, pero me gustaría optar por ir a Stream descendiente/envoltura, el que sería el paso a través de una realidad escribir el archivo en el disco.

Así:

• derivar de Stream
• tienen uno de los miembros, como Stream _inner; que será el flujo de destino para escribir
• implemento Write() y todas las cosas relacionadas con
• en Write() hash de los bloques de datos y llamada _inner.Write()

Ejemplo de uso

Stream s = File.Open("infile.dat"); 
Stream out = File.Create("outfile.dat"); 
HashWrapStream hasher = new HashWrapStream(out); 
byte[] buffer=new byte[1024]; 
int read = 0; 
while ((read=s.Read(buffer)!=0) 
{ 
    hasher.Write(buffer); 
} 
long hash=hasher.GetComputedHash(); // get actual hash 
hasher.Dispose(); 
s.Dispose(); 

Answer 4

Aquí está mi solución, escribe una serie de estructuras (la variable garrapatas) como un archivo CSV (utilizando el paquete Nuget CsvHelper) y luego crea un hash para fines de suma de control mediante el sufijo. sha256

Lo hago escribiendo el csv en un memoryStream, luego escribiendo el flujo de memoria en el disco, y pasando el flujo de memoria al hash algo.

Esta solución mantiene todo el archivo como un flujo de memoria. Está bien para todo excepto para archivos de varios gigabytes que te sacarían de ram. Si tuviera que hacer esto de nuevo, probablemente intente usar el enfoque CryptoStream, pero esto es lo suficientemente bueno para mis propósitos previsibles.

He verificado a través de una herramienta de terceros que los valores hash son válidos.

Aquí está el código:

//var ticks = **some_array_you_want_to_write_as_csv** 

using (var memoryStream = new System.IO.MemoryStream()) 
      { 
       using (var textWriter = new System.IO.StreamWriter(memoryStream)) 
       { 
        using (var csv = new CsvHelper.CsvWriter(textWriter)) 
        { 
         csv.Configuration.DetectColumnCountChanges = true; //error checking 
         csv.Configuration.RegisterClassMap<TickDataClassMap>(); 
         csv.WriteRecords(ticks); 

         textWriter.Flush(); 

         //write to disk 
         using (var fileStream = new System.IO.FileStream(targetFileName, System.IO.FileMode.Create)) 
         { 
          memoryStream.Position = 0; 
          memoryStream.CopyTo(fileStream); 

         } 

         //write sha256 hash, ensuring that the file was properly written 
         using (var sha256 = System.Security.Cryptography.SHA256.Create()) 
         { 
          memoryStream.Position = 0; 
          var hash = sha256.ComputeHash(memoryStream); 
          using (var reader = System.IO.File.OpenRead(targetFileName)) 
          { 
           System.IO.File.WriteAllText(targetFileName + ".sha256", hash.ConvertByteArrayToHexString()); 
          } 
         } 

        } 

       } 
      } 

Answer 5

Este método copiar y hash con corrientes encadenadas.

private static byte[] CopyAndHash(string source, string target, Action<double> progress, Func<bool> isCanceled) 
{ 
    using(var sha512 = SHA512.Create()) 
    using (var targetStream = File.OpenWrite(target)) 
    using (var cryptoStream = new CryptoStream(targetStream, sha512, CryptoStreamMode.Write)) 
    using (var sourceStream = File.OpenRead(source)) 
    { 
     byte[] buffer = new byte[81920]; 
     int read; 
     while ((read = sourceStream.Read(buffer, 0, buffer.Length)) > 0 && !isCanceled()) 
     { 
      cryptoStream.Write(buffer, 0, read); 

      progress?.Invoke((double) sourceStream.Length/sourceStream.Position * 100); 
     } 

    File.SetAttributes(target, File.GetAttributes(source)); 

    return sha512.Hash; 
    } 
} 

muestra completa ver https://gist.github.com/dhcgn/da1637277d9456db9523a96a0a34da78