RIPEMD160Managed Classe

Definizione

Consente di calcolare l'hash RIPEMD160 per i dati di input utilizzando la libreria gestita.

public ref class RIPEMD160Managed : System::Security::Cryptography::RIPEMD160
[System.Runtime.InteropServices.ComVisible(true)]
public class RIPEMD160Managed : System.Security.Cryptography.RIPEMD160
[<System.Runtime.InteropServices.ComVisible(true)>]
type RIPEMD160Managed = class
    inherit RIPEMD160
Public Class RIPEMD160Managed
Inherits RIPEMD160
Ereditarietà
RIPEMD160Managed
Attributi

Esempio

Nell'esempio di codice seguente viene illustrato come codificare un file usando la RIPEMD160Managed classe e quindi come decodificare il file.

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

RIPEMD-160 è una funzione hash crittografica a 160 bit. È destinato all'uso come sostituzione sicura 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

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

Costruttori

RIPEMD160Managed()

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)
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 è sottoposto a override in una classe derivata, indirizza i dati scritti all'oggetto nell'algoritmo hash RIPEMD160 per il calcolo dell'hash.

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'oggetto flusso crittografato.

Initialize()

Inizializza un'istanza della classe RIPEMD160Managed utilizzando la libreria gestita.

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