# KeyedHashAlgorithm Classe

## Définition

Représente la classe abstraite dont toutes les implémentations des algorithmes de hachage à clé doivent dériver.Represents the abstract class from which all implementations of keyed hash algorithms must derive.

``public ref class KeyedHashAlgorithm abstract : System::Security::Cryptography::HashAlgorithm``
``````[System.Runtime.InteropServices.ComVisible(true)]
public abstract class KeyedHashAlgorithm : System.Security.Cryptography.HashAlgorithm``````
``````type KeyedHashAlgorithm = class
inherit HashAlgorithm``````
``````Public MustInherit Class KeyedHashAlgorithm
Inherits HashAlgorithm``````
Héritage
KeyedHashAlgorithm
Dérivé
Attributs

## Exemples

L’exemple de code suivant montre comment dériver de la classe KeyedHashAlgorithm.The following code example demonstrates how to derive from the KeyedHashAlgorithm class.

``````using System;
using System.Security.Cryptography;

public class TestHMACMD5
{
static private void PrintByteArray(Byte[] arr)
{
int i;
Console.WriteLine("Length: " + arr.Length);
for (i = 0; i < arr.Length; i++)
{
Console.Write("{0:X}", arr[i]);
Console.Write("    ");
if ((i + 9) % 8 == 0) Console.WriteLine();
}
if (i % 8 != 0) Console.WriteLine();
}
public static void Main()
{
// Create a key.
byte[] key1 = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
// Pass the key to the constructor of the HMACMD5 class.
HMACMD5 hmac1 = new HMACMD5(key1);

// Create another key.
byte[] key2 = System.Text.Encoding.ASCII.GetBytes("KeyString");
// Pass the key to the constructor of the HMACMD5 class.
HMACMD5 hmac2 = new HMACMD5(key2);

// Encode a string into a byte array, create a hash of the array,
// and print the hash to the screen.
byte[] data1 = System.Text.Encoding.ASCII.GetBytes("Hi There");
PrintByteArray(hmac1.ComputeHash(data1));

// Encode a string into a byte array, create a hash of the array,
// and print the hash to the screen.
byte[] data2 = System.Text.Encoding.ASCII.GetBytes("This data will be hashed.");
PrintByteArray(hmac2.ComputeHash(data2));
}
}
public class HMACMD5 : KeyedHashAlgorithm
{
private MD5 hash1;
private MD5 hash2;
private bool bHashing = false;

private byte[] rgbInner = new byte[64];
private byte[] rgbOuter = new byte[64];

public HMACMD5(byte[] rgbKey)
{
HashSizeValue = 128;
// Create the hash algorithms.
hash1 = MD5.Create();
hash2 = MD5.Create();
// Get the key.
if (rgbKey.Length > 64)
{
KeyValue = hash1.ComputeHash(rgbKey);
// No need to call Initialize; ComputeHash does it automatically.
}
else
{
KeyValue = (byte[])rgbKey.Clone();
}
// Compute rgbInner and rgbOuter.
int i = 0;
for (i = 0; i < 64; i++)
{
rgbInner[i] = 0x36;
rgbOuter[i] = 0x5C;
}
for (i = 0; i < KeyValue.Length; i++)
{
rgbInner[i] ^= KeyValue[i];
rgbOuter[i] ^= KeyValue[i];
}
}

public override byte[] Key
{
get { return (byte[])KeyValue.Clone(); }
set
{
if (bHashing)
{
throw new Exception("Cannot change key during hash operation");
}
if (value.Length > 64)
{
KeyValue = hash1.ComputeHash(value);
// No need to call Initialize; ComputeHash does it automatically.
}
else
{
KeyValue = (byte[])value.Clone();
}
// Compute rgbInner and rgbOuter.
int i = 0;
for (i = 0; i < 64; i++)
{
rgbInner[i] = 0x36;
rgbOuter[i] = 0x5C;
}
for (i = 0; i < KeyValue.Length; i++)
{
rgbInner[i] ^= KeyValue[i];
rgbOuter[i] ^= KeyValue[i];
}
}
}
public override void Initialize()
{
hash1.Initialize();
hash2.Initialize();
bHashing = false;
}
protected override void HashCore(byte[] rgb, int ib, int cb)
{
if (bHashing == false)
{
hash1.TransformBlock(rgbInner, 0, 64, rgbInner, 0);
bHashing = true;
}
hash1.TransformBlock(rgb, ib, cb, rgb, ib);
}

protected override byte[] HashFinal()
{
if (bHashing == false)
{
hash1.TransformBlock(rgbInner, 0, 64, rgbInner, 0);
bHashing = true;
}
// Finalize the original hash.
hash1.TransformFinalBlock(new byte[0], 0, 0);
// Write the outer array.
hash2.TransformBlock(rgbOuter, 0, 64, rgbOuter, 0);
// Write the inner hash and finalize the hash.
hash2.TransformFinalBlock(hash1.Hash, 0, hash1.Hash.Length);
bHashing = false;
return hash2.Hash;
}
}
``````
``````Imports System.Security.Cryptography
_

Public Class TestHMACMD5

Private Shared Sub PrintByteArray(ByVal arr() As [Byte])
Dim i As Integer
Console.WriteLine(("Length: " + arr.Length.ToString()))
For i = 0 To arr.Length - 1
Console.Write("{0:X}", arr(i))
Console.Write("    ")
If (i + 9) Mod 8 = 0 Then
Console.WriteLine()
End If
Next i
If i Mod 8 <> 0 Then
Console.WriteLine()
End If
End Sub

Public Shared Sub Main()
' Create a key.
Dim key1 As Byte() = {&HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB, &HB}
' Pass the key to the constructor of the HMACMD5 class.
Dim hmac1 As New HMACMD5(key1)

' Create another key.
Dim key2 As Byte() = System.Text.Encoding.ASCII.GetBytes("KeyString")
' Pass the key to the constructor of the HMACMD5 class.
Dim hmac2 As New HMACMD5(key2)

' Encode a string into a byte array, create a hash of the array,
' and print the hash to the screen.
Dim data1 As Byte() = System.Text.Encoding.ASCII.GetBytes("Hi There")
PrintByteArray(hmac1.ComputeHash(data1))

' Encode a string into a byte array, create a hash of the array,
' and print the hash to the screen.
Dim data2 As Byte() = System.Text.Encoding.ASCII.GetBytes("This data will be hashed.")
PrintByteArray(hmac2.ComputeHash(data2))
End Sub
End Class
_

Public Class HMACMD5
Inherits KeyedHashAlgorithm
Private hash1 As MD5
Private hash2 As MD5
Private bHashing As Boolean = False

Private rgbInner(64) As Byte
Private rgbOuter(64) As Byte

Public Sub New(ByVal rgbKey() As Byte)
HashSizeValue = 128
' Create the hash algorithms.
hash1 = MD5.Create()
hash2 = MD5.Create()
' Get the key.
If rgbKey.Length > 64 Then
KeyValue = hash1.ComputeHash(rgbKey)
' No need to call Initialize; ComputeHash does it automatically.
Else
KeyValue = CType(rgbKey.Clone(), Byte())
End If
' Compute rgbInner and rgbOuter.
Dim i As Integer = 0
For i = 0 To 63
rgbInner(i) = &H36
rgbOuter(i) = &H5C
Next i
i = 0
For i = 0 To KeyValue.Length - 1
rgbInner(i) = rgbInner(i) Xor KeyValue(i)
rgbOuter(i) = rgbOuter(i) Xor KeyValue(i)
Next i
End Sub

Public Overrides Property Key() As Byte()
Get
Return CType(KeyValue.Clone(), Byte())
End Get
Set(ByVal Value As Byte())
If bHashing Then
Throw New Exception("Cannot change key during hash operation")
End If
If value.Length > 64 Then
KeyValue = hash1.ComputeHash(value)
' No need to call Initialize; ComputeHash does it automatically.
Else
KeyValue = CType(value.Clone(), Byte())
End If
' Compute rgbInner and rgbOuter.
Dim i As Integer = 0
For i = 0 To 63
rgbInner(i) = &H36
rgbOuter(i) = &H5C
Next i
For i = 0 To KeyValue.Length - 1
rgbInner(i) ^= KeyValue(i)
rgbOuter(i) ^= KeyValue(i)
Next i
End Set
End Property

Public Overrides Sub Initialize()
hash1.Initialize()
hash2.Initialize()
bHashing = False
End Sub

Protected Overrides Sub HashCore(ByVal rgb() As Byte, ByVal ib As Integer, ByVal cb As Integer)
If bHashing = False Then
hash1.TransformBlock(rgbInner, 0, 64, rgbInner, 0)
bHashing = True
End If
hash1.TransformBlock(rgb, ib, cb, rgb, ib)
End Sub

Protected Overrides Function HashFinal() As Byte()
If bHashing = False Then
hash1.TransformBlock(rgbInner, 0, 64, rgbInner, 0)
bHashing = True
End If
' Finalize the original hash.
hash1.TransformFinalBlock(New Byte(0) {}, 0, 0)
' Write the outer array.
hash2.TransformBlock(rgbOuter, 0, 64, rgbOuter, 0)
' Write the inner hash and finalize the hash.
hash2.TransformFinalBlock(hash1.Hash, 0, hash1.Hash.Length)
bHashing = False
Return hash2.Hash
End Function
End Class
``````

## Remarques

Les fonctions de hachage mappent les chaînes binaires d’une longueur arbitraire aux petites chaînes binaires d’une longueur fixe.Hash functions map binary strings of an arbitrary length to small binary strings of a fixed length. Une fonction de hachage de chiffrement a la propriété qu’il est impossible de calculer deux entrées distinctes qui hachent la même valeur.A cryptographic hash function has the property that it is computationally infeasible to find two distinct inputs that hash to the same value. Les petites modifications apportées aux données entraînent des modifications importantes et imprévisibles dans le hachage.Small changes to the data result in large, unpredictable changes in the hash.

Un algorithme de hachage à clé est une fonction de hachage unidirectionnelle et dépendante de la clé utilisée comme code d’authentification de message.A keyed hash algorithm is a key-dependent, one-way hash function used as a message authentication code. Seule une personne connaissant la clé peut vérifier le hachage.Only someone who knows the key can verify the hash. Les algorithmes de hachage à clé fournissent l’authenticité sans secret.Keyed hash algorithms provide authenticity without secrecy.

Les fonctions de hachage sont couramment utilisées avec des signatures numériques et pour l'intégrité des données.Hash functions are commonly used with digital signatures and for data integrity. La classe HMACSHA1 est un exemple d’algorithme de hachage à clé.The HMACSHA1 class is an example of a keyed hash algorithm.

En raison de problèmes de collision avec SHA1, Microsoft recommande un modèle de sécurité basé sur SHA256 ou supérieur.Due to collision problems with SHA1, Microsoft recommends a security model based on SHA256 or better.

## Constructeurs

 Initialise une nouvelle instance de la classe KeyedHashAlgorithm.Initializes a new instance of the KeyedHashAlgorithm class.

## Champs

 Représente la taille, en bits, du code de hachage calculé.Represents the size, in bits, of the computed hash code. (Hérité de HashAlgorithm) Représente la valeur du code de hachage calculé.Represents the value of the computed hash code. (Hérité de HashAlgorithm) Clé à utiliser dans l'algorithme de hachage.The key to use in the hash algorithm. Représente l'état du calcul du hachage.Represents the state of the hash computation. (Hérité de HashAlgorithm)

## Propriétés

 Obtient une valeur indiquant si la transformation actuelle peut être réutilisée.Gets a value indicating whether the current transform can be reused. (Hérité de HashAlgorithm) 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. (Hérité de HashAlgorithm) Obtient la valeur du code de hachage calculé.Gets the value of the computed hash code. (Hérité de HashAlgorithm) Obtient la taille, en bits, du code de hachage calculé.Gets the size, in bits, of the computed hash code. (Hérité de HashAlgorithm) 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. (Hérité de HashAlgorithm) Obtient ou définit la clé à utiliser dans l'algorithme de hachage.Gets or sets the key to use in the hash algorithm. 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. (Hérité de HashAlgorithm)

## Méthodes

 Libère toutes les ressources utilisées par la classe HashAlgorithm.Releases all resources used by the HashAlgorithm class. (Hérité de HashAlgorithm) Calcule la valeur de hachage pour le tableau d'octets spécifié.Computes the hash value for the specified byte array. (Hérité de HashAlgorithm) 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. (Hérité de HashAlgorithm) Calcule la valeur de hachage pour l'objet Stream spécifié.Computes the hash value for the specified Stream object. (Hérité de HashAlgorithm) Crée une instance de l'implémentation par défaut d'un algorithme de hachage à clé.Creates an instance of the default implementation of a keyed hash algorithm. Crée une instance de l'implémentation spécifiée d'un algorithme de hachage à clé.Creates an instance of the specified implementation of a keyed hash algorithm. 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. (Hérité de HashAlgorithm) Libère les ressources non managées utilisées par KeyedHashAlgorithm et libère éventuellement les ressources managées.Releases the unmanaged resources used by the KeyedHashAlgorithm and optionally releases the managed resources. Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object. (Hérité de Object) Ce membre substitue Finalize(). Une documentation plus complète est peut-être disponible dans cette rubrique.This member overrides Finalize(), and more complete documentation might be available in that topic. Autorise Object à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant que Object soit récupéré par l'opération garbage collection.Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. Sert de fonction de hachage par défaut.Serves as the default hash function. (Hérité de Object) Obtient le Type de l'instance actuelle.Gets the Type of the current instance. (Hérité de Object) En cas de substitution dans une classe dérivée, achemine les données écrites dans l'objet vers l'algorithme de hachage pour calculer le hachage.When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash. (Hérité de HashAlgorithm) Route les données écrites dans l’objet vers l’algorithme de hachage pour le calcul du hachage.Routes data written to the object into the hash algorithm for computing the hash. (Hérité de HashAlgorithm) En cas de remplacement dans une classe dérivée, finalise le calcul du hachage une fois les dernières données traitées par l’algorithme de hachage du chiffrement.When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic hash algorithm. (Hérité de HashAlgorithm) Rétablit l’état initial de l’algorithme de hachage.Resets the hash algorithm to its initial state. (Hérité de HashAlgorithm) Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object. (Hérité de Object) Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object. (Hérité de Object) 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. (Hérité de HashAlgorithm) 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. (Hérité de HashAlgorithm) Tente de calculer la valeur de hachage pour le tableau d’octets spécifié.Attempts to compute the hash value for the specified byte array. (Hérité de HashAlgorithm) Tente de finaliser le calcul du hachage après que les dernières données ont été traitées par l’algorithme de hachage.Attempts to finalize the hash computation after the last data is processed by the hash algorithm. (Hérité de HashAlgorithm)

## Implémentations d’interfaces explicites

 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. (Hérité de HashAlgorithm)