HMACRIPEMD160 HMACRIPEMD160 HMACRIPEMD160 HMACRIPEMD160 Class

Définition

Calcule un code HMAC (Hash-based Message Authentication Code) à l'aide de la fonction de hachage RIPEMD160.Computes a Hash-based Message Authentication Code (HMAC) by using the RIPEMD160 hash function.

public ref class HMACRIPEMD160 : System::Security::Cryptography::HMAC
[System.Runtime.InteropServices.ComVisible(true)]
public class HMACRIPEMD160 : System.Security.Cryptography.HMAC
type HMACRIPEMD160 = class
    inherit HMAC
Public Class HMACRIPEMD160
Inherits HMAC
Héritage
Attributs

Exemples

L’exemple suivant montre comment signer un fichier à l’aide de HMACRIPEMD160 l’objet, puis comment vérifier le fichier.The following example shows how to sign a file by using the HMACRIPEMD160 object and then how to verify the file.

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

// Computes a keyed hash for a source file, creates a target file with the keyed hash
// prepended to the contents of the source file, then decrypts the file and compares
// the source and the decrypted files.
void EncodeFile( array<Byte>^key, String^ sourceFile, String^ destFile )
{
   
   // Initialize the keyed hash object.
   HMACRIPEMD160^ myhmacRIPEMD160 = gcnew HMACRIPEMD160( key );
   FileStream^ inStream = gcnew FileStream( sourceFile,FileMode::Open );
   FileStream^ outStream = gcnew FileStream( destFile,FileMode::Create );
   
   // Compute the hash of the input file.
   array<Byte>^hashValue = myhmacRIPEMD160->ComputeHash( inStream );
   
   // Reset inStream to the beginning of the file.
   inStream->Position = 0;
   
   // Write the computed hash value to the output file.
   outStream->Write( hashValue, 0, hashValue->Length );
   
   // Copy the contents of the sourceFile to the destFile.
   int bytesRead;
   
   // read 1K at a time
   array<Byte>^buffer = gcnew array<Byte>(1024);
   do
   {
      
      // Read from the wrapping CryptoStream.
      bytesRead = inStream->Read( buffer, 0, 1024 );
      outStream->Write( buffer, 0, bytesRead );
   }
   while ( bytesRead > 0 );

   myhmacRIPEMD160->Clear();
   
   // Close the streams
   inStream->Close();
   outStream->Close();
   return;
} // end EncodeFile



// Decrypt the encoded file and compare to original file.
bool DecodeFile( array<Byte>^key, String^ sourceFile )
{
   
   // Initialize the keyed hash object. 
   HMACRIPEMD160^ hmacRIPEMD160 = gcnew HMACRIPEMD160( key );
   
   // Create an array to hold the keyed hash value read from the file.
   array<Byte>^storedHash = gcnew array<Byte>(hmacRIPEMD160->HashSize / 8);
   
   // Create a FileStream for the source file.
   FileStream^ inStream = gcnew FileStream( sourceFile,FileMode::Open );
   
   // Read in the storedHash.
   inStream->Read( storedHash, 0, storedHash->Length );
   
   // Compute the hash of the remaining contents of the file.
   // The stream is properly positioned at the beginning of the content, 
   // immediately after the stored hash value.
   array<Byte>^computedHash = hmacRIPEMD160->ComputeHash( inStream );
   
   // compare the computed hash with the stored value
   bool err = false;
   for ( int i = 0; i < storedHash->Length; i++ )
   {
      if ( computedHash[ i ] != storedHash[ i ] )
      {
         err = true;
      }
   }
   if (err)
        {
            Console::WriteLine("Hash values differ! Encoded file has been tampered with!");
            return false;
        }
        else
        {
            Console::WriteLine("Hash values agree -- no tampering occurred.");
            return true;
        }

} //end DecodeFile


int main()
{
   array<String^>^Fileargs = Environment::GetCommandLineArgs();
   String^ usageText = "Usage: HMACRIPEMD160 inputfile.txt encryptedfile.hsh\nYou must specify the two file names. Only the first file must exist.\n";
   
   //If no file names are specified, write usage text.
   if ( Fileargs->Length < 3 )
   {
      Console::WriteLine( usageText );
   }
   else
   {
      try
      {
         
         // Create a random key using a random number generator. This would be the
         //  secret key shared by sender and receiver.
         array<Byte>^secretkey = gcnew array<Byte>(64);
         
         //RNGCryptoServiceProvider is an implementation of a random number generator.
         RNGCryptoServiceProvider^ rng = gcnew RNGCryptoServiceProvider;
         
         // The array is now filled with cryptographically strong random bytes.
         rng->GetBytes( secretkey );
         
         // Use the secret key to encode the message file.
         EncodeFile( secretkey, Fileargs[ 1 ], Fileargs[ 2 ] );
         
         // Take the encoded file and decode
         DecodeFile( secretkey, Fileargs[ 2 ] );
      }
      catch ( IOException^ e ) 
      {
         Console::WriteLine( "Error: File not found", e );
      }

   }
} //end main


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

public class HMACRIPEMD160example
{

    public static void Main(string[] Fileargs)
    {
        string dataFile;
        string signedFile;
        //If no file names are specified, create them.
        if (Fileargs.Length < 2)
        {
            dataFile = @"text.txt";
            signedFile = "signedFile.enc";

            if (!File.Exists(dataFile))
            {
                // Create a file to write to.
                using (StreamWriter sw = File.CreateText(dataFile))
                {
                    sw.WriteLine("Here is a message to sign");
                }
            }

        }
        else
        {
            dataFile = Fileargs[0];
            signedFile = Fileargs[1];
        }
        try
        {
            // Create a random key using a random number generator. This would be the
            //  secret key shared by sender and receiver.
            byte[] secretkey = new Byte[64];
            //RNGCryptoServiceProvider is an implementation of a random number generator.
            using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
            {
                // The array is now filled with cryptographically strong random bytes.
                rng.GetBytes(secretkey);

                // Use the secret key to sign the message file.
                SignFile(secretkey, dataFile, signedFile);

                // Verify the signed file
                VerifyFile(secretkey, signedFile);
            }
        }
        catch (IOException e)
        {
            Console.WriteLine("Error: File not found", e);
        }

    }  //end main
    // Computes a keyed hash for a source file and creates a target file with the keyed hash
    // prepended to the contents of the source file. 
    public static void SignFile(byte[] key, String sourceFile, String destFile)
    {
        // Initialize the keyed hash object.
        using (HMACRIPEMD160 hmac = new HMACRIPEMD160(key))
        {
            using (FileStream inStream = new FileStream(sourceFile, FileMode.Open))
            {
                using (FileStream outStream = new FileStream(destFile, FileMode.Create))
                {
                    // Compute the hash of the input file.
                    byte[] hashValue = hmac.ComputeHash(inStream);
                    // Reset inStream to the beginning of the file.
                    inStream.Position = 0;
                    // Write the computed hash value to the output file.
                    outStream.Write(hashValue, 0, hashValue.Length);
                    // Copy the contents of the sourceFile to the destFile.
                    int bytesRead;
                    // read 1K at a time
                    byte[] buffer = new byte[1024];
                    do
                    {
                        // Read from the wrapping CryptoStream.
                        bytesRead = inStream.Read(buffer, 0, 1024);
                        outStream.Write(buffer, 0, bytesRead);
                    } while (bytesRead > 0);
                }
            }
        }
        return;
    } // end SignFile


    // Compares the key in the source file with a new key created for the data portion of the file. If the keys 
    // compare the data has not been tampered with.
    public static bool VerifyFile(byte[] key, String sourceFile)
    {
        bool err = false;
        // Initialize the keyed hash object. 
        using (HMACRIPEMD160 hmac = new HMACRIPEMD160(key))
        {
            // Create an array to hold the keyed hash value read from the file.
            byte[] storedHash = new byte[hmac.HashSize / 8];
            // Create a FileStream for the source file.
            using (FileStream inStream = new FileStream(sourceFile, FileMode.Open))
            {
                // Read in the storedHash.
                inStream.Read(storedHash, 0, storedHash.Length);
                // Compute the hash of the remaining contents of the file.
                // The stream is properly positioned at the beginning of the content, 
                // immediately after the stored hash value.
                byte[] computedHash = hmac.ComputeHash(inStream);
                // compare the computed hash with the stored value

                for (int i = 0; i < storedHash.Length; i++)
                {
                    if (computedHash[i] != storedHash[i])
                    {
                        err = true;
                    }
                }
            }
        }
        if (err)
        {
            Console.WriteLine("Hash values differ! Signed file has been tampered with!");
            return false;
        }
        else
        {
            Console.WriteLine("Hash values agree -- no tampering occurred.");
            return true;
        }

    } //end VerifyFile

} //end class
Imports System.IO
Imports System.Security.Cryptography

Public Class HMACRIPEMD160example

    Public Shared Sub Main(ByVal Fileargs() As String)
        Dim dataFile As String
        Dim signedFile As String
        'If no file names are specified, create them.
        If Fileargs.Length < 2 Then
            dataFile = "text.txt"
            signedFile = "signedFile.enc"

            If Not File.Exists(dataFile) Then
                ' Create a file to write to.
                Using sw As StreamWriter = File.CreateText(dataFile)
                    sw.WriteLine("Here is a message to sign")
                End Using
            End If

        Else
            dataFile = Fileargs(0)
            signedFile = Fileargs(1)
        End If
        Try
            ' Create a random key using a random number generator. This would be the
            '  secret key shared by sender and receiver.
            Dim secretkey() As Byte = New [Byte](63) {}
            'RNGCryptoServiceProvider is an implementation of a random number generator.
            Using rng As New RNGCryptoServiceProvider()
                ' The array is now filled with cryptographically strong random bytes.
                rng.GetBytes(secretkey)

                ' Use the secret key to encode the message file.
                SignFile(secretkey, dataFile, signedFile)

                ' Take the encoded file and decode
                VerifyFile(secretkey, signedFile)
            End Using
        Catch e As IOException
            Console.WriteLine("Error: File not found", e)
        End Try

    End Sub

    ' Computes a keyed hash for a source file and creates a target file with the keyed hash
    ' prepended to the contents of the source file. 
    Public Shared Sub SignFile(ByVal key() As Byte, ByVal sourceFile As String, ByVal destFile As String)
        ' Initialize the keyed hash object.
        Using myhmac As New HMACRIPEMD160(key)
            Using inStream As New FileStream(sourceFile, FileMode.Open)
                Using outStream As New FileStream(destFile, FileMode.Create)
                    ' Compute the hash of the input file.
                    Dim hashValue As Byte() = myhmac.ComputeHash(inStream)
                    ' Reset inStream to the beginning of the file.
                    inStream.Position = 0
                    ' Write the computed hash value to the output file.
                    outStream.Write(hashValue, 0, hashValue.Length)
                    ' Copy the contents of the sourceFile to the destFile.
                    Dim bytesRead As Integer
                    ' read 1K at a time
                    Dim buffer(1023) As Byte
                    Do
                        ' Read from the wrapping CryptoStream.
                        bytesRead = inStream.Read(buffer, 0, 1024)
                        outStream.Write(buffer, 0, bytesRead)
                    Loop While bytesRead > 0
                End Using
            End Using
        End Using
        Return

    End Sub
    ' end SignFile

    ' Compares the key in the source file with a new key created for the data portion of the file. If the keys 
    ' compare the data has not been tampered with.
    Public Shared Function VerifyFile(ByVal key() As Byte, ByVal sourceFile As String) As Boolean
        Dim err As Boolean = False
        ' Initialize the keyed hash object. 
        Using hmac As New HMACRIPEMD160(key)
            ' Create an array to hold the keyed hash value read from the file.
            Dim storedHash(hmac.HashSize / 8 - 1) As Byte
            ' Create a FileStream for the source file.
            Using inStream As New FileStream(sourceFile, FileMode.Open)
                ' Read in the storedHash.
                inStream.Read(storedHash, 0, storedHash.Length - 1)
                ' Compute the hash of the remaining contents of the file.
                ' The stream is properly positioned at the beginning of the content, 
                ' immediately after the stored hash value.
                Dim computedHash As Byte() = hmac.ComputeHash(inStream)
                ' compare the computed hash with the stored value
                Dim i As Integer
                For i = 0 To storedHash.Length - 2
                    If computedHash(i) <> storedHash(i) Then
                        err = True
                    End If
                Next i
            End Using
        End Using
        If err Then
            Console.WriteLine("Hash values differ! Signed file has been tampered with!")
            Return False
        Else
            Console.WriteLine("Hash values agree -- no tampering occurred.")
            Return True
        End If

    End Function 'VerifyFile 
End Class
'end class

Remarques

HMACRIPEMD160est un type d’algorithme de hachage à clé qui est construit à partir de la fonction de hachage RIPEMD-160 et utilisé comme un code d’authentification de message basé sur le hachage (HMAC).HMACRIPEMD160 is a type of keyed hash algorithm that is constructed from the RIPEMD-160 hash function and used as a Hash-based Message Authentication Code (HMAC). Le processus HMAC mélange une clé secrète avec les données du message, hache le résultat avec la fonction de hachage, mélange cette valeur de hachage à la clé secrète, puis applique la fonction de hachage une deuxième fois.The HMAC process mixes a secret key with the message data, hashes the result with the hash function, mixes that hash value with the secret key again, and then applies the hash function a second time. Le hachage de sortie a une longueur de 160 bits.The output hash is 160 bits in length.

Un HMAC peut être utilisé pour déterminer si un message envoyé sur un canal non sécurisé a été falsifié, à condition que l’expéditeur et le destinataire partagent une clé secrète.An HMAC can be used to determine whether a message sent over an insecure channel has been tampered with, provided that the sender and receiver share a secret key. L’expéditeur calcule la valeur de hachage pour les données d’origine et envoie les données d’origine et la valeur de hachage sous la forme d’un message unique.The sender computes the hash value for the original data and sends both the original data and the hash value as a single message. Le destinataire recalcule la valeur de hachage sur le message reçu et vérifie que le HMAC calculé correspond au HMAC transmis.The receiver recalculates the hash value on the received message and checks that the computed HMAC matches the transmitted HMAC.

Toute modification apportée aux données ou à la valeur de hachage entraîne une incompatibilité, car la connaissance de la clé secrète est requise pour modifier le message et reproduire la valeur de hachage correcte.Any change to the data or the hash value results in a mismatch, because knowledge of the secret key is required to change the message and reproduce the correct hash value. Par conséquent, si les valeurs de hachage d’origine et calculées correspondent, le message est authentifié.Therefore, if the original and computed hash values match, the message is authenticated.

HMACRIPEMD160accepte des clés de toute taille et produit une séquence de hachage de 160 bits de long.HMACRIPEMD160 accepts keys of any size, and produces a hash sequence that is 160 bits long.

L’algorithme de hachage RIPEMD et ses successeurs ont été développés par le projet de maturité européenne.The RIPEMD hash algorithm and its successors were developed by the European RIPE project. L’algorithme RIPEMD d’origine a été conçu pour remplacer MD4 et MD5 et a ensuite été renforcé et renommé RIPEMD-160.The original RIPEMD algorithm was designed to replace MD4 and MD5 and was later strengthened and renamed RIPEMD-160. L’algorithme de hachage RIPEMD-160 produit une valeur de hachage de 160 bits.The RIPEMD-160 hash algorithm produces a 160-bit hash value. Les concepteurs de l’algorithme l’ont placé dans le domaine public.The algorithm's designers have placed it in the public domain.

En raison de problèmes de collision avec MD4 et MD5, Microsoft recommande SHA256 ou une meilleure solution.Due to collision problems with MD4 and MD5, Microsoft recommends SHA256 or better.

Constructeurs

HMACRIPEMD160() HMACRIPEMD160() HMACRIPEMD160() HMACRIPEMD160()

Initialise une nouvelle instance de la classe HMACRIPEMD160 avec une clé de 64 octets générée de manière aléatoire.Initializes a new instance of the HMACRIPEMD160 class with a randomly generated 64-byte key.

HMACRIPEMD160(Byte[]) HMACRIPEMD160(Byte[]) HMACRIPEMD160(Byte[]) HMACRIPEMD160(Byte[])

Initialise une nouvelle instance de la classe HMACRIPEMD160 avec les données de clé spécifiées.Initializes a new instance of the HMACRIPEMD160 class with the specified key data.

Méthodes

Clear() Clear() Clear() Clear()

Libère toutes les ressources utilisées par la classe HashAlgorithm.Releases all resources used by the HashAlgorithm class.

(Inherited from HashAlgorithm)
ComputeHash(Byte[]) ComputeHash(Byte[]) ComputeHash(Byte[]) ComputeHash(Byte[])

Calcule la valeur de hachage pour le tableau d'octets spécifié.Computes the hash value for the specified byte array.

(Inherited from HashAlgorithm)
ComputeHash(Byte[], Int32, Int32) ComputeHash(Byte[], Int32, Int32) ComputeHash(Byte[], Int32, Int32) ComputeHash(Byte[], Int32, Int32)

Calcule la valeur de hachage pour la région spécifiée du tableau d'octets spécifié.Computes the hash value for the specified region of the specified byte array.

(Inherited from HashAlgorithm)
ComputeHash(Stream) ComputeHash(Stream) ComputeHash(Stream) ComputeHash(Stream)

Calcule la valeur de hachage pour l'objet Stream spécifié.Computes the hash value for the specified Stream object.

(Inherited from HashAlgorithm)
Dispose() Dispose() Dispose() Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe HashAlgorithm.Releases all resources used by the current instance of the HashAlgorithm class.

(Inherited from HashAlgorithm)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Diffuse les ressources non managées utilisées par la classe HMAC lorsqu'un changement de clé est légitime et libère facultativement les ressources managées.Releases the unmanaged resources used by the HMAC class when a key change is legitimate and optionally releases the managed resources.

(Inherited from HMAC)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
HashCore(Byte[], Int32, Int32) HashCore(Byte[], Int32, Int32) HashCore(Byte[], Int32, Int32) HashCore(Byte[], Int32, Int32)

En cas de substitution dans une classe dérivée, achemine les données écrites dans l'objet vers l'algorithme de hachage HMAC par défaut pour calculer la valeur de hachage.When overridden in a derived class, routes data written to the object into the default HMAC hash algorithm for computing the hash value.

(Inherited from HMAC)
HashCore(ReadOnlySpan<Byte>) HashCore(ReadOnlySpan<Byte>) HashCore(ReadOnlySpan<Byte>) HashCore(ReadOnlySpan<Byte>) Inherited from HMAC
HashFinal() HashFinal() HashFinal() HashFinal()

En cas de substitution dans une classe dérivée, finalise le calcul de hachage une fois les dernières données traitées par l'objet de flux de chiffrement.When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.

(Inherited from HMAC)
Initialize() Initialize() Initialize() Initialize()

Initialise une instance de l'implémentation par défaut de HMAC.Initializes an instance of the default implementation of HMAC.

(Inherited from HMAC)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
TransformBlock(Byte[], Int32, Int32, Byte[], Int32) TransformBlock(Byte[], Int32, Int32, Byte[], Int32) TransformBlock(Byte[], Int32, Int32, Byte[], Int32) TransformBlock(Byte[], Int32, Int32, Byte[], Int32)

Calcule la valeur de hachage pour la région spécifiée du tableau d'octets d'entrée et copie la région spécifiée du tableau d'octets d'entrée dans la région spécifiée du tableau d'octets de sortie.Computes the hash value for the specified region of the input byte array and copies the specified region of the input byte array to the specified region of the output byte array.

(Inherited from HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32) TransformFinalBlock(Byte[], Int32, Int32) TransformFinalBlock(Byte[], Int32, Int32) TransformFinalBlock(Byte[], Int32, Int32)

Calcule la valeur de hachage pour la région spécifiée du tableau d'octets spécifié.Computes the hash value for the specified region of the specified byte array.

(Inherited from HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32) TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32) TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32) TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32) Inherited from HashAlgorithm
TryHashFinal(Span<Byte>, Int32) TryHashFinal(Span<Byte>, Int32) TryHashFinal(Span<Byte>, Int32) TryHashFinal(Span<Byte>, Int32) Inherited from HMAC

Propriétés

BlockSizeValue BlockSizeValue BlockSizeValue BlockSizeValue

Obtient ou définit la taille de bloc à utiliser dans la valeur de hachage.Gets or sets the block size to use in the hash value.

(Inherited from HMAC)
CanReuseTransform CanReuseTransform CanReuseTransform CanReuseTransform

Obtient une valeur indiquant si la transformation actuelle peut être réutilisée.Gets a value indicating whether the current transform can be reused.

(Inherited from HashAlgorithm)
CanTransformMultipleBlocks CanTransformMultipleBlocks CanTransformMultipleBlocks CanTransformMultipleBlocks

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si plusieurs blocs peuvent être transformés.When overridden in a derived class, gets a value indicating whether multiple blocks can be transformed.

(Inherited from HashAlgorithm)
Hash Hash Hash Hash

Obtient la valeur du code de hachage calculé.Gets the value of the computed hash code.

(Inherited from HashAlgorithm)
HashName HashName HashName HashName

Obtient ou définit le nom de l'algorithme de hachage à utiliser pour le hachage.Gets or sets the name of the hash algorithm to use for hashing.

(Inherited from HMAC)
HashSize HashSize HashSize HashSize

Obtient la taille, en bits, du code de hachage calculé.Gets the size, in bits, of the computed hash code.

(Inherited from HashAlgorithm)
InputBlockSize InputBlockSize InputBlockSize InputBlockSize

En cas de substitution dans une classe dérivée, obtient la taille du bloc d'entrée.When overridden in a derived class, gets the input block size.

(Inherited from HashAlgorithm)
Key Key Key Key

Obtient ou définit la clé à utiliser dans l'algorithme de hachage.Gets or sets the key to use in the hash algorithm.

(Inherited from HMAC)
OutputBlockSize OutputBlockSize OutputBlockSize OutputBlockSize

En cas de substitution dans une classe dérivée, obtient la taille du bloc de sortie.When overridden in a derived class, gets the output block size.

(Inherited from HashAlgorithm)

Champs

HashSizeValue HashSizeValue HashSizeValue HashSizeValue

Représente la taille, en bits, du code de hachage calculé.Represents the size, in bits, of the computed hash code.

(Inherited from HashAlgorithm)
HashValue HashValue HashValue HashValue

Représente la valeur du code de hachage calculé.Represents the value of the computed hash code.

(Inherited from HashAlgorithm)
KeyValue KeyValue KeyValue KeyValue

Clé à utiliser dans l'algorithme de hachage.The key to use in the hash algorithm.

(Inherited from KeyedHashAlgorithm)
State State State State

Représente l'état du calcul du hachage.Represents the state of the hash computation.

(Inherited from HashAlgorithm)

Implémentations d’interfaces explicites

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Libère les ressources non managées utilisées par HashAlgorithm et libère éventuellement les ressources managées.Releases the unmanaged resources used by the HashAlgorithm and optionally releases the managed resources.

(Inherited from HashAlgorithm)

S’applique à

Voir aussi