HMACSHA256 Classe

Définition

Espace de noms:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Source:

HMACSHA256.cs

Calcule un code HMAC (Hash-based Message Authentication Code) à l'aide de la fonction de hachage SHA256.

public ref class HMACSHA256 : System::Security::Cryptography::HMAC

public class HMACSHA256 : System.Security.Cryptography.HMAC

type HMACSHA256 = class
    inherit HMAC

Public Class HMACSHA256
Inherits HMAC

Héritage

Object

HashAlgorithm

KeyedHashAlgorithm

HMAC

HMACSHA256

Exemples

L’exemple suivant montre comment signer un fichier à l’aide de l’objet HMACSHA256 , puis comment vérifier le fichier.

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 decodes the file and compares
// the source and the decoded files.
void EncodeFile( array<Byte>^key, String^ sourceFile, String^ destFile )
{
   
   // Initialize the keyed hash object.
   HMACSHA256^ myhmacsha256 = gcnew HMACSHA256( 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 = myhmacsha256->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 );

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



// Decode the encoded file and compare to original file.
bool DecodeFile( array<Byte>^key, String^ sourceFile )
{
   
   // Initialize the keyed hash object. 
   HMACSHA256^ hmacsha256 = gcnew HMACSHA256( key );
   
   // Create an array to hold the keyed hash value read from the file.
   array<Byte>^storedHash = gcnew array<Byte>(hmacsha256->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 = hmacsha256->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: HMACSHA256 inputfile.txt encodedfile.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 HMACSHA256example
{

    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 (HMACSHA256 hmac = new HMACSHA256(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 (HMACSHA256 hmac = new HMACSHA256(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 HMACSHA256example

    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 HMACSHA256(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 HMACSHA256(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

HMACSHA256 est un type d’algorithme de hachage à clé qui est construit à partir de la fonction de hachage SHA-256 et utilisé comme code d’authentification de message basé sur le hachage (HMAC). Le processus HMAC combine une clé secrète avec les données de message, hache le résultat avec la fonction de hachage, mélange à nouveau cette valeur de hachage avec la clé secrète, puis applique la fonction de hachage une deuxième fois. Le hachage de sortie est de 256 bits.

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. L’expéditeur calcule la valeur de hachage des données d’origine et envoie les données d’origine et la valeur de hachage en tant que message unique. Le récepteur recalcule la valeur de hachage sur le message reçu et vérifie que le HMAC calculé correspond au HMAC transmis.

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 nécessaire pour modifier le message et reproduire la valeur de hachage correcte. Par conséquent, si les valeurs de hachage d’origine et calculées correspondent, le message est authentifié.

HMACSHA256 accepte les clés de toute taille et produit une séquence de hachage de 256 bits de longueur.

Constructeurs

HMACSHA256()	Initialise une nouvelle instance de la classe HMACSHA256 avec une clé générée de manière aléatoire.
HMACSHA256(Byte[])	Initialise une nouvelle instance de la classe HMACSHA256 avec les données de clé spécifiées.

Champs

HashSizeInBits	Taille de hachage produite par l’algorithme HMAC SHA256, en bits.
HashSizeInBytes	Taille de hachage produite par l’algorithme HMAC SHA256, en octets.
HashSizeValue	Représente la taille, en bits, du code de hachage calculé. (Hérité de HashAlgorithm)
HashValue	Représente la valeur du code de hachage calculé. (Hérité de HashAlgorithm)
KeyValue	Clé à utiliser dans l'algorithme de hachage. (Hérité de KeyedHashAlgorithm)
State	Représente l'état du calcul du hachage. (Hérité de HashAlgorithm)

Propriétés

BlockSizeValue	Obtient ou définit la taille de bloc à utiliser dans la valeur de hachage. (Hérité de HMAC)
CanReuseTransform	Obtient une valeur indiquant si la transformation actuelle peut être réutilisée. (Hérité de HashAlgorithm)
CanTransformMultipleBlocks	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si plusieurs blocs peuvent être transformés. (Hérité de HashAlgorithm)
Hash	Obtient la valeur du code de hachage calculé. (Hérité de HashAlgorithm)
HashName	Obtient ou définit le nom de l'algorithme de hachage à utiliser pour le hachage. (Hérité de HMAC)
HashSize	Obtient la taille, en bits, du code de hachage calculé. (Hérité de HashAlgorithm)
InputBlockSize	En cas de substitution dans une classe dérivée, obtient la taille du bloc d'entrée. (Hérité de HashAlgorithm)
Key	Obtient ou définit la clé à utiliser dans le calcul de HMAC.
OutputBlockSize	En cas de substitution dans une classe dérivée, obtient la taille du bloc de sortie. (Hérité de HashAlgorithm)

Méthodes

Clear()	Libère toutes les ressources utilisées par la classe HashAlgorithm. (Hérité de HashAlgorithm)
ComputeHash(Byte[])	Calcule la valeur de hachage pour le tableau d'octets spécifié. (Hérité de HashAlgorithm)
ComputeHash(Byte[], Int32, Int32)	Calcule la valeur de hachage pour la région spécifiée du tableau d'octets spécifié. (Hérité de HashAlgorithm)
ComputeHash(Stream)	Calcule la valeur de hachage pour l'objet Stream spécifié. (Hérité de HashAlgorithm)
ComputeHashAsync(Stream, CancellationToken)	Calcule de manière asynchrone la valeur de hachage pour l'objet Stream spécifié. (Hérité de HashAlgorithm)
Dispose()	Libère toutes les ressources utilisées par l'instance actuelle de la classe HashAlgorithm. (Hérité de HashAlgorithm)
Dispose(Boolean)	Libère les ressources non managées utilisées par HMACSHA256 et libère éventuellement les ressources managées.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
HashCore(Byte[], Int32, Int32)	Route les données écrites dans l’objet vers l’algorithme HMAC pour le calcul de HMAC.
HashCore(ReadOnlySpan<Byte>)	Route les données écrites dans l’objet vers l’algorithme HMAC pour le calcul de HMAC.
HashData(Byte[], Byte[])	Calcule le HMAC des données à l’aide de l’algorithme SHA256.
HashData(Byte[], Stream)	Calcule le HMAC d’un flux à l’aide de l’algorithme SHA256.
HashData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>)	Calcule le HMAC des données à l’aide de l’algorithme SHA256.
HashData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>)	Calcule le HMAC des données à l’aide de l’algorithme SHA256.
HashData(ReadOnlySpan<Byte>, Stream)	Calcule le HMAC d’un flux à l’aide de l’algorithme SHA256.
HashData(ReadOnlySpan<Byte>, Stream, Span<Byte>)	Calcule le HMAC d’un flux à l’aide de l’algorithme SHA256.
HashDataAsync(Byte[], Stream, CancellationToken)	Calcule de façon asynchrone le HMAC d’un flux à l’aide de l’algorithme SHA256.
HashDataAsync(ReadOnlyMemory<Byte>, Stream, CancellationToken)	Calcule de façon asynchrone le HMAC d’un flux à l’aide de l’algorithme SHA256.
HashDataAsync(ReadOnlyMemory<Byte>, Stream, Memory<Byte>, CancellationToken)	Calcule de façon asynchrone le HMAC d’un flux à l’aide de l’algorithme SHA256.
HashFinal()	Finalise le calcul de HMAC après que les dernières données ont été traitées par l’algorithme.
Initialize()	Rétablit l’état initial de l’algorithme de hachage.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
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. (Hérité de HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32)	Calcule la valeur de hachage pour la région spécifiée du tableau d'octets spécifié. (Hérité de HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)	Tente de calculer la valeur de hachage pour le tableau d’octets spécifié. (Hérité de HashAlgorithm)
TryHashData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, Int32)	Tente de calculer le HMAC des données à l’aide de l’algorithme SHA256.
TryHashFinal(Span<Byte>, Int32)	Tente de finaliser le calcul de HMAC après que les dernières données ont été traitées par l’algorithme HMAC.

Voir aussi

• services de chiffrement