Rfc2898DeriveBytes Classe

Définition

Espace de noms:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Source:

Rfc2898DeriveBytes.cs

Implémente une fonctionnalité de dérivation de clé basée sur mot de passe, PBKDF2, en utilisant un générateur de nombres pseudo-aléatoires basé sur HMACSHA1.

public ref class Rfc2898DeriveBytes : System::Security::Cryptography::DeriveBytes

public class Rfc2898DeriveBytes : System.Security.Cryptography.DeriveBytes

type Rfc2898DeriveBytes = class
    inherit DeriveBytes

Public Class Rfc2898DeriveBytes
Inherits DeriveBytes

Héritage

Object

DeriveBytes

Rfc2898DeriveBytes

Exemples

L’exemple de code suivant utilise la Rfc2898DeriveBytes classe pour créer deux clés identiques pour la Aes classe . Il chiffre et déchiffre ensuite certaines données à l’aide des clés.

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

// Generate a key k1 with password pwd1 and salt salt1.
// Generate a key k2 with password pwd1 and salt salt1.
// Encrypt data1 with key k1 using symmetric encryption, creating edata1.
// Decrypt edata1 with key k2 using symmetric decryption, creating data2.
// data2 should equal data1.

int main()
{
   array<String^>^passwordargs = Environment::GetCommandLineArgs();
   String^ usageText = "Usage: RFC2898 <password>\nYou must specify the password for encryption.\n";

   //If no file name is specified, write usage text.
   if ( passwordargs->Length == 1 )
   {
      Console::WriteLine( usageText );
   }
   else
   {
      String^ pwd1 = passwordargs[ 1 ];
      
      array<Byte>^salt1 = gcnew array<Byte>(8);
      RNGCryptoServiceProvider ^ rngCsp = gcnew RNGCryptoServiceProvider();
         rngCsp->GetBytes(salt1);
      //data1 can be a string or contents of a file.
      String^ data1 = "Some test data";

      //The default iteration count is 1000 so the two methods use the same iteration count.
      int myIterations = 1000;

      try
      {
         Rfc2898DeriveBytes ^ k1 = gcnew Rfc2898DeriveBytes( pwd1,salt1,myIterations );
         Rfc2898DeriveBytes ^ k2 = gcnew Rfc2898DeriveBytes( pwd1,salt1 );

         // Encrypt the data.
         Aes^ encAlg = Aes::Create();
         encAlg->Key = k1->GetBytes( 16 );
         MemoryStream^ encryptionStream = gcnew MemoryStream;
         CryptoStream^ encrypt = gcnew CryptoStream( encryptionStream,encAlg->CreateEncryptor(),CryptoStreamMode::Write );
         array<Byte>^utfD1 = (gcnew System::Text::UTF8Encoding( false ))->GetBytes( data1 );

         encrypt->Write( utfD1, 0, utfD1->Length );
         encrypt->FlushFinalBlock();
         encrypt->Close();
         array<Byte>^edata1 = encryptionStream->ToArray();
         k1->Reset();

         // Try to decrypt, thus showing it can be round-tripped.
         Aes^ decAlg = Aes::Create();
         decAlg->Key = k2->GetBytes( 16 );
         decAlg->IV = encAlg->IV;
         MemoryStream^ decryptionStreamBacking = gcnew MemoryStream;
         CryptoStream^ decrypt = gcnew CryptoStream( decryptionStreamBacking,decAlg->CreateDecryptor(),CryptoStreamMode::Write );

         decrypt->Write( edata1, 0, edata1->Length );
         decrypt->Flush();
         decrypt->Close();
         k2->Reset();

         String^ data2 = (gcnew UTF8Encoding( false ))->GetString( decryptionStreamBacking->ToArray() );
         if (  !data1->Equals( data2 ) )
         {
            Console::WriteLine( "Error: The two values are not equal." );
         }
         else
         {
            Console::WriteLine( "The two values are equal." );
            Console::WriteLine( "k1 iterations: {0}", k1->IterationCount );
            Console::WriteLine( "k2 iterations: {0}", k2->IterationCount );
         }
      }

      catch ( Exception^ e ) 
      {
         Console::WriteLine( "Error: ", e );
      }
   }
}

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

public class rfc2898test
{
    // Generate a key k1 with password pwd1 and salt salt1.
    // Generate a key k2 with password pwd1 and salt salt1.
    // Encrypt data1 with key k1 using symmetric encryption, creating edata1.
    // Decrypt edata1 with key k2 using symmetric decryption, creating data2.
    // data2 should equal data1.

    private const string usageText = "Usage: RFC2898 <password>\nYou must specify the password for encryption.\n";
    public static void Main(string[] passwordargs)
    {
        //If no file name is specified, write usage text.
        if (passwordargs.Length == 0)
        {
            Console.WriteLine(usageText);
        }
        else
        {
            string pwd1 = passwordargs[0];
            // Create a byte array to hold the random value.
            byte[] salt1 = new byte[8];
            using (RNGCryptoServiceProvider rngCsp = new
RNGCryptoServiceProvider())
            {
                // Fill the array with a random value.
                rngCsp.GetBytes(salt1);
            }

            //data1 can be a string or contents of a file.
            string data1 = "Some test data";
            //The default iteration count is 1000 so the two methods use the same iteration count.
            int myIterations = 1000;
            try
            {
                Rfc2898DeriveBytes k1 = new Rfc2898DeriveBytes(pwd1, salt1,
myIterations);
                Rfc2898DeriveBytes k2 = new Rfc2898DeriveBytes(pwd1, salt1);
                // Encrypt the data.
                Aes encAlg = Aes.Create();
                encAlg.Key = k1.GetBytes(16);
                MemoryStream encryptionStream = new MemoryStream();
                CryptoStream encrypt = new CryptoStream(encryptionStream,
encAlg.CreateEncryptor(), CryptoStreamMode.Write);
                byte[] utfD1 = new System.Text.UTF8Encoding(false).GetBytes(
data1);

                encrypt.Write(utfD1, 0, utfD1.Length);
                encrypt.FlushFinalBlock();
                encrypt.Close();
                byte[] edata1 = encryptionStream.ToArray();
                k1.Reset();

                // Try to decrypt, thus showing it can be round-tripped.
                Aes decAlg = Aes.Create();
                decAlg.Key = k2.GetBytes(16);
                decAlg.IV = encAlg.IV;
                MemoryStream decryptionStreamBacking = new MemoryStream();
                CryptoStream decrypt = new CryptoStream(
decryptionStreamBacking, decAlg.CreateDecryptor(), CryptoStreamMode.Write);
                decrypt.Write(edata1, 0, edata1.Length);
                decrypt.Flush();
                decrypt.Close();
                k2.Reset();
                string data2 = new UTF8Encoding(false).GetString(
decryptionStreamBacking.ToArray());

                if (!data1.Equals(data2))
                {
                    Console.WriteLine("Error: The two values are not equal.");
                }
                else
                {
                    Console.WriteLine("The two values are equal.");
                    Console.WriteLine("k1 iterations: {0}", k1.IterationCount);
                    Console.WriteLine("k2 iterations: {0}", k2.IterationCount);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e);
            }
        }
    }
}

Imports System.IO
Imports System.Text
Imports System.Security.Cryptography



Public Class rfc2898test
    ' Generate a key k1 with password pwd1 and salt salt1.
    ' Generate a key k2 with password pwd1 and salt salt1.
    ' Encrypt data1 with key k1 using symmetric encryption, creating edata1.
    ' Decrypt edata1 with key k2 using symmetric decryption, creating data2.
    ' data2 should equal data1.
    Private Const usageText As String = "Usage: RFC2898 <password>" + vbLf + "You must specify the password for encryption." + vbLf

    Public Shared Sub Main(ByVal passwordargs() As String)
        'If no file name is specified, write usage text.
        If passwordargs.Length = 0 Then
            Console.WriteLine(usageText)
        Else
            Dim pwd1 As String = passwordargs(0)

            Dim salt1(8) As Byte
            Using rngCsp As New RNGCryptoServiceProvider()
                rngCsp.GetBytes(salt1)
            End Using
            'data1 can be a string or contents of a file.
            Dim data1 As String = "Some test data"
            'The default iteration count is 1000 so the two methods use the same iteration count.
            Dim myIterations As Integer = 1000
            Try
                Dim k1 As New Rfc2898DeriveBytes(pwd1, salt1, myIterations)
                Dim k2 As New Rfc2898DeriveBytes(pwd1, salt1)
                ' Encrypt the data.
                Dim encAlg As Aes = Aes.Create()
                encAlg.Key = k1.GetBytes(16)
                Dim encryptionStream As New MemoryStream()
                Dim encrypt As New CryptoStream(encryptionStream, encAlg.CreateEncryptor(), CryptoStreamMode.Write)
                Dim utfD1 As Byte() = New System.Text.UTF8Encoding(False).GetBytes(data1)
                encrypt.Write(utfD1, 0, utfD1.Length)
                encrypt.FlushFinalBlock()
                encrypt.Close()
                Dim edata1 As Byte() = encryptionStream.ToArray()
                k1.Reset()

                ' Try to decrypt, thus showing it can be round-tripped.
                Dim decAlg As Aes = Aes.Create()
                decAlg.Key = k2.GetBytes(16)
                decAlg.IV = encAlg.IV
                Dim decryptionStreamBacking As New MemoryStream()
                Dim decrypt As New CryptoStream(decryptionStreamBacking, decAlg.CreateDecryptor(), CryptoStreamMode.Write)
                decrypt.Write(edata1, 0, edata1.Length)
                decrypt.Flush()
                decrypt.Close()
                k2.Reset()
                Dim data2 As String = New UTF8Encoding(False).GetString(decryptionStreamBacking.ToArray())

                If Not data1.Equals(data2) Then
                    Console.WriteLine("Error: The two values are not equal.")
                Else
                    Console.WriteLine("The two values are equal.")
                    Console.WriteLine("k1 iterations: {0}", k1.IterationCount)
                    Console.WriteLine("k2 iterations: {0}", k2.IterationCount)
                End If
            Catch e As Exception
                Console.WriteLine("Error: ", e)
            End Try
        End If

    End Sub
End Class

Remarques

Rfc2898DeriveBytes prend un mot de passe, un salt et un nombre d’itérations, puis génère des clés via des appels à la GetBytes méthode .

RFC 2898 inclut des méthodes permettant de créer une clé et un vecteur d’initialisation (IV) à partir d’un mot de passe et d’un sel. Vous pouvez utiliser PBKDF2, une fonction de dérivation de clé basée sur un mot de passe, pour dériver des clés à l’aide d’une fonction pseudo-aléatoire qui permet de générer des clés d’une longueur pratiquement illimitée. La Rfc2898DeriveBytes classe peut être utilisée pour produire une clé dérivée à partir d’une clé de base et d’autres paramètres. Dans une fonction de dérivation de clé basée sur un mot de passe, la clé de base est un mot de passe et les autres paramètres sont une valeur salt et un nombre d’itérations.

Pour plus d’informations sur PBKDF2, consultez RFC 2898, intitulée « PKCS #5 : Password-Based Cryptography Specification Version 2.0 ». Pour plus d’informations, consultez la section 5.2, « PBKDF2 ».

Important

Ne codez jamais en dur un mot de passe dans votre code source. Les mots de passe codés en dur peuvent être récupérés à partir d’un assembly à l’aide du Ildasm.exe (désassembleur IL), à l’aide d’un éditeur hexadécimal ou simplement en ouvrant l’assembly dans un éditeur de texte tel que Notepad.exe.

Constructeurs

Rfc2898DeriveBytes(Byte[], Byte[], Int32)	Obsolète. Initialise une nouvelle instance de la classe Rfc2898DeriveBytes à l'aide d'un mot de passe, d'un salt et d'un nombre d'itérations pour dériver la clé.
Rfc2898DeriveBytes(Byte[], Byte[], Int32, HashAlgorithmName)	Initialise une nouvelle instance de la classe Rfc2898DeriveBytes en utilisant le mot de passe, le salt, le nombre d’itérations et le nom de l’algorithme de hachage spécifiés pour dériver la clé.
Rfc2898DeriveBytes(String, Byte[])	Obsolète. Initialise une nouvelle instance de la classe Rfc2898DeriveBytes à l'aide d'un mot de passe et d'un salt pour dériver la clé.
Rfc2898DeriveBytes(String, Byte[], Int32)	Obsolète. Initialise une nouvelle instance de la classe Rfc2898DeriveBytes à l'aide d'un mot de passe, d'un salt et d'un nombre d'itérations pour dériver la clé.
Rfc2898DeriveBytes(String, Byte[], Int32, HashAlgorithmName)	Initialise une nouvelle instance de la classe Rfc2898DeriveBytes en utilisant le mot de passe, le salt, le nombre d’itérations et le nom de l’algorithme de hachage spécifiés pour dériver la clé.
Rfc2898DeriveBytes(String, Int32)	Obsolète. Initialise une nouvelle instance de la classe Rfc2898DeriveBytes à l'aide du mot de passe et de la taille de salt pour dériver la clé.
Rfc2898DeriveBytes(String, Int32, Int32)	Obsolète. Initialise une nouvelle instance de la classe Rfc2898DeriveBytes à l'aide d'un mot de passe, d'une taille de salt et d'un nombre d'itérations pour dériver la clé.
Rfc2898DeriveBytes(String, Int32, Int32, HashAlgorithmName)	Initialise une nouvelle instance de la classe Rfc2898DeriveBytes en utilisant le mot de passe, la taille de salt, le nombre d’itérations et le nom de l’algorithme de hachage spécifiés pour dériver la clé.

Propriétés

HashAlgorithm	Obtient l’algorithme de hachage utilisé pour la dérivation d’octets.
IterationCount	Obtient ou définit le nombre d'itérations pour l'opération.
Salt	Obtient ou définit la valeur salt de clé pour l'opération.

Méthodes

CryptDeriveKey(String, String, Int32, Byte[])	Obsolète. Dérive une clé de chiffrement de l'objet Rfc2898DeriveBytes.
Dispose()	En cas de substitution dans une classe dérivée, libère toutes les ressources utilisées par l’instance actuelle de la classe DeriveBytes. (Hérité de DeriveBytes)
Dispose(Boolean)	Libère les ressources non managées utilisées par la classe Rfc2898DeriveBytes 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)
GetBytes(Int32)	Retourne la clé pseudo-aléatoire de cet objet.
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)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Pbkdf2(Byte[], Byte[], Int32, HashAlgorithmName, Int32)	Crée une clé dérivée PBKDF2 à partir d’octets de mot de passe.
Pbkdf2(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32, HashAlgorithmName, Int32)	Crée une clé dérivée PBKDF2 à partir d’octets de mot de passe.
Pbkdf2(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, Int32, HashAlgorithmName)	Remplit une mémoire tampon avec une clé dérivée PBKDF2.
Pbkdf2(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32, HashAlgorithmName, Int32)	Crée une clé dérivée PBKDF2 à partir d’un mot de passe.
Pbkdf2(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Span<Byte>, Int32, HashAlgorithmName)	Remplit une mémoire tampon avec une clé dérivée PBKDF2.
Pbkdf2(String, Byte[], Int32, HashAlgorithmName, Int32)	Crée une clé dérivée PBKDF2 à partir d’un mot de passe.
Reset()	Rétablit l'état de l'opération.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Voir aussi

• services de chiffrement