RIPEMD160 Classe

Definizione

Rappresenta la classe astratta dalla quale ereditano tutte le implementazioni dell'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
Ereditarietà
RIPEMD160
Derivato
Attributi

Esempio

Nell'esempio di codice seguente viene calcolato l'hash RIPEMD160 per tutti i file in una directory.

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

Commenti

Le funzioni hash eseguono il mapping di stringhe binarie di lunghezza arbitraria a piccole stringhe binarie di lunghezza fissa. Una funzione hash crittografica ha la proprietà che è infeasible a livello di calcolo per trovare due input distinti che eseguino l'hash allo stesso valore; ovvero gli hash di due set di dati devono corrispondere se anche i dati corrispondenti corrispondono. Le piccole modifiche apportate ai dati comportano modifiche imprevedibili di grandi dimensioni nell'hash.

RIPEMD-160 è una funzione hash crittografica a 160 bit. È destinato all'uso come sostituzione per le funzioni hash a 128 bit MD4, MD5 e RIPEMD. RIPEMD è stato sviluppato nel quadro del progetto UE RIPE (RACE Integrity Primitives Evaluation, 1988-1992).

Nota

RIPEMD160 è stato sostituito dagli algoritmi hash sicuri SHA-256 e SHA-512 e dalle relative classi derivate. SHA256 e SHA512 offrono sicurezza e prestazioni migliori rispetto a RIPEMD160. Usare RIPEMD160 solo per la compatibilità con applicazioni e dati legacy.

Costruttori

RIPEMD160()

Inizializza una nuova istanza della classe RIPEMD160.

Campi

HashSizeValue

Rappresenta la dimensione in bit del codice hash calcolato.

(Ereditato da HashAlgorithm)
HashValue

Rappresenta il valore del codice hash calcolato.

(Ereditato da HashAlgorithm)
State

Rappresenta lo stato del calcolo hash.

(Ereditato da HashAlgorithm)

Proprietà

CanReuseTransform

Ottiene un valore che indica se è possibile riutilizzare la trasformazione corrente.

(Ereditato da HashAlgorithm)
CanTransformMultipleBlocks

Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se è possibile trasformare più blocchi.

(Ereditato da HashAlgorithm)
Hash

Ottiene il valore del codice hash calcolato.

(Ereditato da HashAlgorithm)
HashSize

Ottiene la dimensione in bit del codice hash calcolato.

(Ereditato da HashAlgorithm)
InputBlockSize

Quando ne viene eseguito l'override in una classe derivata, ottiene la dimensione del blocco di input.

(Ereditato da HashAlgorithm)
OutputBlockSize

Quando ne viene eseguito l'override in una classe derivata, ottiene la dimensione del blocco di output.

(Ereditato da HashAlgorithm)

Metodi

Clear()

Rilascia tutte le risorse usate dalla classe HashAlgorithm.

(Ereditato da HashAlgorithm)
ComputeHash(Byte[])

Consente di calcolare il valore hash della matrice di byte specificata.

(Ereditato da HashAlgorithm)
ComputeHash(Byte[], Int32, Int32)

Calcola il valore hash dell'area specifica della matrice di byte specificata.

(Ereditato da HashAlgorithm)
ComputeHash(Stream)

Calcola il valore hash per l'oggetto Stream specificato.

(Ereditato da HashAlgorithm)
ComputeHashAsync(Stream, CancellationToken)

Calcola in modo asincrono il valore hash per l'oggetto Stream specificato.

(Ereditato da HashAlgorithm)
Create()

Consente di creare un'istanza dell'implementazione predefinita dell'algoritmo hash RIPEMD160.

Create(String)

Consente di creare un'istanza dell'implementazione specificata dell'algoritmo hash RIPEMD160.

Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe HashAlgorithm.

(Ereditato da HashAlgorithm)
Dispose(Boolean)

Rilascia le risorse non gestite usate da HashAlgorithm e, facoltativamente, le risorse gestite.

(Ereditato da HashAlgorithm)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
HashCore(Byte[], Int32, Int32)

Quando ne viene eseguito l'override in una classe derivata, indirizza i dati scritti nell'oggetto verso l'algoritmo hash per il calcolo dell'hash.

(Ereditato da HashAlgorithm)
HashCore(ReadOnlySpan<Byte>)

Consente di indirizzare i dati scritti nell'oggetto nell'algoritmo hash per il calcolo dell'hash.

(Ereditato da HashAlgorithm)
HashFinal()

Quando ne viene eseguito l'override in una classe derivata, finalizza il calcolo hash una volta che gli ultimi dati sono stati elaborati dall'algoritmo hash crittografico.

(Ereditato da HashAlgorithm)
Initialize()

Reimposta lo stato iniziale dell'algoritmo hash.

(Ereditato da HashAlgorithm)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
TransformBlock(Byte[], Int32, Int32, Byte[], Int32)

Consente di calcolare il valore hash dell'area specifica della matrice di byte di input e di copiare una determinata area della matrice di byte di input nell'area specifica della matrice di byte di output.

(Ereditato da HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32)

Calcola il valore hash dell'area specifica della matrice di byte specificata.

(Ereditato da HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)

Tenta di calcolare il valore hash per la matrice di byte specificata.

(Ereditato da HashAlgorithm)
TryHashFinal(Span<Byte>, Int32)

Tenta di finalizzare il calcolo hash dopo l'elaborazione degli ultimi dati da parte dell'algoritmo hash.

(Ereditato da HashAlgorithm)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia le risorse non gestite usate da HashAlgorithm e, facoltativamente, le risorse gestite.

(Ereditato da HashAlgorithm)

Si applica a

Vedi anche