RIPEMD160 Clase

Referencia

Definición

Espacio de nombres:: System.Security.Cryptography

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Representa la clase abstracta desde la que se heredan todas las implementaciones del algoritmo hash MD160.

public ref class RIPEMD160 abstract : System::Security::Cryptography::HashAlgorithm

[System.Runtime.InteropServices.ComVisible(true)]
public abstract class RIPEMD160 : System.Security.Cryptography.HashAlgorithm

[<System.Runtime.InteropServices.ComVisible(true)>]
type RIPEMD160 = class
    inherit HashAlgorithm

Public MustInherit Class RIPEMD160
Inherits HashAlgorithm

Herencia: Object

HashAlgorithm
RIPEMD160

Derivado: System.Security.Cryptography.RIPEMD160Managed

Atributos: ComVisibleAttribute

Ejemplos

En el ejemplo de código siguiente se calcula el RIPEMD160 hash de todos los archivos de un directorio.

using namespace System;
using namespace System::IO;
using namespace System::Security::Cryptography;

// Print the byte array in a readable format.
void PrintByteArray( array<Byte>^array )
{
   int i;
   for ( i = 0; i < array->Length; i++ )
   {
      Console::Write( String::Format( "{0:X2}", array[ i ] ) );
      if ( (i % 4) == 3 )
            Console::Write( " " );

   }
   Console::WriteLine();
}

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   if ( args->Length < 2 )
   {
      Console::WriteLine( "Usage: hashdir <directory>" );
      return 0;
   }

   try
   {
      
      // Create a DirectoryInfo object representing the specified directory.
      DirectoryInfo^ dir = gcnew DirectoryInfo( args[ 1 ] );
      
      // Get the FileInfo objects for every file in the directory.
      array<FileInfo^>^files = dir->GetFiles();
      
      // Initialize a RIPE160 hash object.
      RIPEMD160 ^ myRIPEMD160 = RIPEMD160Managed::Create();
      array<Byte>^hashValue;
      
      // Compute and print the hash values for each file in directory.
      System::Collections::IEnumerator^ myEnum = files->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         FileInfo^ fInfo = safe_cast<FileInfo^>(myEnum->Current);
         
         // Create a fileStream for the file.
         FileStream^ fileStream = fInfo->Open( FileMode::Open );
         
         // Compute the hash of the fileStream.
         hashValue = myRIPEMD160->ComputeHash( fileStream );
         
         // Write the name of the file to the Console.
         Console::Write( "{0}: ", fInfo->Name );
         
         // Write the hash value to the Console.
         PrintByteArray( hashValue );
         
         // Close the file.
         fileStream->Close();
      }
      return 0;
   }
   catch ( DirectoryNotFoundException^ ) 
   {
      Console::WriteLine( "Error: The directory specified could not be found." );
   }
   catch ( IOException^ ) 
   {
      Console::WriteLine( "Error: A file in the directory could not be accessed." );
   }

}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Windows.Forms;

public class HashDirectory
{

    [STAThreadAttribute]
    public static void Main(String[] args)
    {
        string directory = "";
        if (args.Length < 1)
        {
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            DialogResult dr = fbd.ShowDialog();
            if (dr == DialogResult.OK)
            {
                directory = fbd.SelectedPath;
            }
            else
            {
                Console.WriteLine("No directory selected.");
                return;
            }
        }
        else
        {
            directory = args[0];
        }

        try
        {
            // Create a DirectoryInfo object representing the specified directory.
            DirectoryInfo dir = new DirectoryInfo(directory);
            // Get the FileInfo objects for every file in the directory.
            FileInfo[] files = dir.GetFiles();
            // Initialize a RIPE160 hash object.
            RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create();
            byte[] hashValue;
            // Compute and print the hash values for each file in directory.
            foreach (FileInfo fInfo in files)
            {
                // Create a fileStream for the file.
                FileStream fileStream = fInfo.Open(FileMode.Open);
                // Be sure it's positioned to the beginning of the stream.
                fileStream.Position = 0;
                // Compute the hash of the fileStream.
                hashValue = myRIPEMD160.ComputeHash(fileStream);
                // Write the name of the file to the Console.
                Console.Write(fInfo.Name + ": ");
                // Write the hash value to the Console.
                PrintByteArray(hashValue);
                // Close the file.
                fileStream.Close();
            }
            return;
        }
        catch (DirectoryNotFoundException)
        {
            Console.WriteLine("Error: The directory specified could not be found.");
        }
        catch (IOException)
        {
            Console.WriteLine("Error: A file in the directory could not be accessed.");
        }
    }
    // Print the byte array in a readable format.
    public static void PrintByteArray(byte[] array)
    {
        int i;
        for (i = 0; i < array.Length; i++)
        {
            Console.Write(String.Format("{0:X2}", array[i]));
            if ((i % 4) == 3) Console.Write(" ");
        }
        Console.WriteLine();
    }
}

Imports System.IO
Imports System.Security.Cryptography
Imports System.Windows.Forms

Public Class HashDirectory

    Public Shared Sub Main(ByVal args() As String)
        Dim directory As String
        If args.Length < 1 Then
            Dim fdb As New FolderBrowserDialog
            Dim dr As DialogResult = fdb.ShowDialog()
            If (dr = DialogResult.OK) Then
                directory = fdb.SelectedPath
            Else
                Console.WriteLine("No directory selected")
                Return
            End If
        Else
            directory = args(0)
        End If
        Try
            ' Create a DirectoryInfo object representing the specified directory.
            Dim dir As New DirectoryInfo(directory)
            ' Get the FileInfo objects for every file in the directory.
            Dim files As FileInfo() = dir.GetFiles()
            ' Initialize a RIPE160 hash object.
            Dim myRIPEMD160 As RIPEMD160 = RIPEMD160Managed.Create()
            Dim hashValue() As Byte
            ' Compute and print the hash values for each file in directory.
            Dim fInfo As FileInfo
            For Each fInfo In files
                ' Create a fileStream for the file.
                Dim fileStream As FileStream = fInfo.Open(FileMode.Open)
                ' Be sure it's positioned to the beginning of the stream.
                fileStream.Position = 0
                ' Compute the hash of the fileStream.
                hashValue = myRIPEMD160.ComputeHash(fileStream)
                ' Write the name of the file to the Console.
                Console.Write(fInfo.Name + ": ")
                ' Write the hash value to the Console.
                PrintByteArray(hashValue)
                ' Close the file.
                fileStream.Close()
            Next fInfo
            Return
        Catch DExc As DirectoryNotFoundException
            Console.WriteLine("Error: The directory specified could not be found.")
        Catch IOExc As IOException
            Console.WriteLine("Error: A file in the directory could not be accessed.")
        End Try

    End Sub

    ' Print the byte array in a readable format.
    Public Shared Sub PrintByteArray(ByVal array() As Byte)
        Dim i As Integer
        For i = 0 To array.Length - 1
            Console.Write(String.Format("{0:X2}", array(i)))
            If i Mod 4 = 3 Then
                Console.Write(" ")
            End If
        Next i
        Console.WriteLine()

    End Sub
End Class

Comentarios

Las funciones hash asignan cadenas binarias de una longitud arbitraria a cadenas binarias pequeñas de una longitud fija. Una función hash criptográfica tiene la propiedad que es computacionalmente inviable encontrar dos entradas distintas que hashen el mismo valor; es decir, los valores hash de dos conjuntos de datos deben coincidir si los datos correspondientes también coinciden. Los pequeños cambios en los datos dan lugar a cambios impredecibles grandes en el hash.

RIPEMD-160 es una función hash criptográfica de 160 bits. Está pensado para su uso como sustituto de las funciones hash de 128 bits MD4, MD5 y RIPEMD. RIPEMD se desarrolló en el marco del proyecto de la UE RIPE (Race Integrity Primitives Evaluation, 1988-1992).

Nota

RIPEMD160 se ha reemplazado por los algoritmos hash seguros SHA-256 y SHA-512 y sus clases derivadas. SHA256 y SHA512 ofrecen una mejor seguridad y rendimiento que RIPEMD160. Use RIPEMD160 solo para la compatibilidad con los datos y las aplicaciones heredadas.

Constructores

RIPEMD160()

Inicializa una nueva instancia de la clase RIPEMD160.

Campos

HashSizeValue	Representa el tamaño en bits del código hash calculado. (Heredado de HashAlgorithm)
HashValue	Representa el valor del código hash calculado. (Heredado de HashAlgorithm)
State	Representa el estado del cálculo del valor hash. (Heredado de HashAlgorithm)

Propiedades

CanReuseTransform	Obtiene un valor que indica si la transformación actual puede volver a usarse. (Heredado de HashAlgorithm)
CanTransformMultipleBlocks	Cuando se invalida en una clase derivada, obtiene un valor que indica si se pueden transformar varios bloques. (Heredado de HashAlgorithm)
Hash	Obtiene el valor del código hash calculado. (Heredado de HashAlgorithm)
HashSize	Obtiene el tamaño en bits del código hash calculado. (Heredado de HashAlgorithm)
InputBlockSize	Cuando se invalida en una clase derivada, obtiene el tamaño del bloque de entrada. (Heredado de HashAlgorithm)
OutputBlockSize	Cuando se invalida en una clase derivada, obtiene el tamaño del bloque de salida. (Heredado de HashAlgorithm)

Métodos

Clear()	Libera todos los recursos que utiliza la clase HashAlgorithm. (Heredado de HashAlgorithm)
ComputeHash(Byte[])	Calcula el valor hash para la matriz de bytes especificada. (Heredado de HashAlgorithm)
ComputeHash(Byte[], Int32, Int32)	Calcula el valor hash para la región especificada de la matriz de bytes indicada. (Heredado de HashAlgorithm)
ComputeHash(Stream)	Calcula el valor hash del objeto Stream especificado. (Heredado de HashAlgorithm)
ComputeHashAsync(Stream, CancellationToken)	Calcula de manera asincrónica el valor hash del objeto Stream especificado. (Heredado de HashAlgorithm)
Create()	Crea una instancia de la implementación predeterminada del algoritmo hash RIPEMD160.
Create(String)	Crea una instancia de la implementación especificada del algoritmo hash RIPEMD160.
Dispose()	Libera todos los recursos usados por la instancia actual de la clase HashAlgorithm. (Heredado de HashAlgorithm)
Dispose(Boolean)	Libera los recursos no administrados que usa HashAlgorithm y, de forma opcional, libera los recursos administrados. (Heredado de HashAlgorithm)
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
HashCore(Byte[], Int32, Int32)	Cuando se invalida en una clase derivada, enruta los datos escritos en el objeto al algoritmo hash para el cálculo del valor hash. (Heredado de HashAlgorithm)
HashCore(ReadOnlySpan<Byte>)	Envía los datos escritos en el objeto al algoritmo hash para el cálculo del valor hash. (Heredado de HashAlgorithm)
HashFinal()	Cuando se invalida en una clase derivada, finaliza el cálculo de hash una vez que el algoritmo hash criptográfico termina de procesar los últimos datos. (Heredado de HashAlgorithm)
Initialize()	Restablece el algoritmo hash a su estado inicial. (Heredado de HashAlgorithm)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
TransformBlock(Byte[], Int32, Int32, Byte[], Int32)	Calcula el valor hash para la región especificada de la matriz de bytes de entrada y copia la región especificada de la matriz de bytes de entrada resultante en la región indicada de la matriz de bytes de salida. (Heredado de HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32)	Calcula el valor hash para la región especificada de la matriz de bytes indicada. (Heredado de HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)	Intenta calcular el valor de hash para la matriz de bytes especificada. (Heredado de HashAlgorithm)
TryHashFinal(Span<Byte>, Int32)	Intenta finalizar el cálculo de hash una vez que el algoritmo hash procesa los últimos datos. (Heredado de HashAlgorithm)

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Libera los recursos no administrados que usa HashAlgorithm y, de forma opcional, libera los recursos administrados.

(Heredado de HashAlgorithm)

Se aplica a

Consulte también

servicios criptográficos