HashAlgorithm.ComputeHash Método

Definición

Espacio de nombres:

System.Security.Cryptography

Ensamblado:

System.Security.Cryptography.dll

Calcula el valor hash de los datos de entrada.

Sobrecargas

ComputeHash(Byte[])	Calcula el valor hash para la matriz de bytes especificada.
ComputeHash(Stream)	Calcula el valor hash del objeto Stream especificado.
ComputeHash(Byte[], Int32, Int32)	Calcula el valor hash para la región especificada de la matriz de bytes indicada.

ComputeHash(Byte[])

Source:

HashAlgorithm.cs

Calcula el valor hash para la matriz de bytes especificada.

C#

public byte[] ComputeHash (byte[] buffer);

Parámetros

buffer

Byte[]

La entrada para la cual se calcula el código hash.

Devoluciones

Byte[]

Código hash calculado.

Excepciones

ArgumentNullException

buffer es null.

ObjectDisposedException

El objeto ya se ha desechado.

Ejemplos

En el ejemplo siguiente se calcula el SHA256 valor hash de una cadena y se devuelve el hash como una cadena con formato hexadecimal de 64 caracteres. La cadena hash creada por este ejemplo de código es compatible con cualquier función hash SHA256 (en cualquier plataforma) que crea una cadena hash con formato hexadecimal de 64 caracteres.

C#

using System;
using System.Security.Cryptography;
using System.Text;

public class Program
{
    public static void Main()
    {
        string source = "Hello World!";
        using (SHA256 sha256Hash = SHA256.Create())
        {
            string hash = GetHash(sha256Hash, source);

            Console.WriteLine($"The SHA256 hash of {source} is: {hash}.");

            Console.WriteLine("Verifying the hash...");

            if (VerifyHash(sha256Hash, source, hash))
            {
                Console.WriteLine("The hashes are the same.");
            }
            else
            {
                Console.WriteLine("The hashes are not same.");
            }
        }
    }

    private static string GetHash(HashAlgorithm hashAlgorithm, string input)
    {

        // Convert the input string to a byte array and compute the hash.
        byte[] data = hashAlgorithm.ComputeHash(Encoding.UTF8.GetBytes(input));

        // Create a new Stringbuilder to collect the bytes
        // and create a string.
        var sBuilder = new StringBuilder();

        // Loop through each byte of the hashed data
        // and format each one as a hexadecimal string.
        for (int i = 0; i < data.Length; i++)
        {
            sBuilder.Append(data[i].ToString("x2"));
        }

        // Return the hexadecimal string.
        return sBuilder.ToString();
    }

    // Verify a hash against a string.
    private static bool VerifyHash(HashAlgorithm hashAlgorithm, string input, string hash)
    {
        // Hash the input.
        var hashOfInput = GetHash(hashAlgorithm, input);

        // Create a StringComparer an compare the hashes.
        StringComparer comparer = StringComparer.OrdinalIgnoreCase;

        return comparer.Compare(hashOfInput, hash) == 0;
    }
}
// The example displays the following output:
//    The SHA256 hash of Hello World! is: 7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069.
//    Verifying the hash...
//    The hashes are the same.

ComputeHash(Stream)

Source:

HashAlgorithm.cs

Calcula el valor hash del objeto Stream especificado.

C#

public byte[] ComputeHash (System.IO.Stream inputStream);

Parámetros

inputStream

Stream

La entrada para la cual se calcula el código hash.

Devoluciones

Byte[]

Código hash calculado.

Excepciones

ObjectDisposedException

El objeto ya se ha desechado.

Ejemplos

En el ejemplo siguiente se calcula el SHA256 hash de todos los archivos de un directorio.

C#

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

public class HashDirectory
{
    public static void Main(string[] args)
    {
        if (args.Length < 1)
        {
            Console.WriteLine("No directory selected.");
            return;
        }

        string directory = args[0];
        if (Directory.Exists(directory))
        {
            // Create a DirectoryInfo object representing the specified directory.
            var dir = new DirectoryInfo(directory);
            // Get the FileInfo objects for every file in the directory.
            FileInfo[] files = dir.GetFiles();
            // Initialize a SHA256 hash object.
            using (SHA256 mySHA256 = SHA256.Create())
            {
                // Compute and print the hash values for each file in directory.
                foreach (FileInfo fInfo in files)
                {
                    using (FileStream fileStream = fInfo.Open(FileMode.Open))
                    {
                        try
                        {
                            // Create a fileStream for the file.
                            // Be sure it's positioned to the beginning of the stream.
                            fileStream.Position = 0;
                            // Compute the hash of the fileStream.
                            byte[] hashValue = mySHA256.ComputeHash(fileStream);
                            // Write the name and hash value of the file to the console.
                            Console.Write($"{fInfo.Name}: ");
                            PrintByteArray(hashValue);
                        }
                        catch (IOException e)
                        {
                            Console.WriteLine($"I/O Exception: {e.Message}");
                        }
                        catch (UnauthorizedAccessException e)
                        {
                            Console.WriteLine($"Access Exception: {e.Message}");
                        }
                    }
                }
            }
        }
        else
        {
            Console.WriteLine("The directory specified could not be found.");
        }
    }

    // Display the byte array in a readable format.
    public static void PrintByteArray(byte[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            Console.Write($"{array[i]:X2}");
            if ((i % 4) == 3) Console.Write(" ");
        }
        Console.WriteLine();
    }
}

ComputeHash(Byte[], Int32, Int32)

Source:

HashAlgorithm.cs

Calcula el valor hash para la región especificada de la matriz de bytes indicada.

C#

public byte[] ComputeHash (byte[] buffer, int offset, int count);

Parámetros

buffer

Byte[]

La entrada para la cual se calcula el código hash.

offset

Int32

Desplazamiento en la matriz de bytes a partir del cual se empezarán a usar los datos.

count

Int32

Número de bytes de la matriz que se van a usar como datos.

Devoluciones

Byte[]

Código hash calculado.

Excepciones

ArgumentException

count es un valor no válido.

O bien

La longitud de buffer no es válida.

ArgumentNullException

buffer es null.

ArgumentOutOfRangeException

offset está fuera del intervalo. Este parámetro requiere un número no negativo.

ObjectDisposedException

El objeto ya se ha desechado.