.NET Framework Créer une clé à partir d'un mot de passe / SALT aléatoire (en C #)


Exemple

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

public class PasswordDerivedBytesExample
{
    public static void Main(String[] args)
    {
        // Get a password from the user.
        Console.WriteLine("Enter a password to produce a key:");

        byte[] pwd = Encoding.Unicode.GetBytes(Console.ReadLine());

        byte[] salt = CreateRandomSalt(7);

        // Create a TripleDESCryptoServiceProvider object.
        TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();

        try
        {
            Console.WriteLine("Creating a key with PasswordDeriveBytes...");

            // Create a PasswordDeriveBytes object and then create
            // a TripleDES key from the password and salt.
            PasswordDeriveBytes pdb = new PasswordDeriveBytes(pwd, salt);

            // Create the key and set it to the Key property
            // of the TripleDESCryptoServiceProvider object.
            tdes.Key = pdb.CryptDeriveKey("TripleDES", "SHA1", 192, tdes.IV);

            Console.WriteLine("Operation complete.");
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            // Clear the buffers
            ClearBytes(pwd);
            ClearBytes(salt);

            // Clear the key.
            tdes.Clear();
        }

        Console.ReadLine();
    }

    #region Helper methods

    /// <summary>
    /// Generates a random salt value of the specified length.
    /// </summary>
    public static byte[] CreateRandomSalt(int length)
    {
        // Create a buffer
        byte[] randBytes;

        if (length >= 1)
        {
            randBytes = new byte[length];
        }
        else
        {
            randBytes = new byte[1];
        }

        // Create a new RNGCryptoServiceProvider.
        RNGCryptoServiceProvider rand = new RNGCryptoServiceProvider();

        // Fill the buffer with random bytes.
        rand.GetBytes(randBytes);

        // return the bytes.
        return randBytes;
    }

    /// <summary>
    /// Clear the bytes in a buffer so they can't later be read from memory.
    /// </summary>
    public static void ClearBytes(byte[] buffer)
    {
        // Check arguments.
        if (buffer == null)
        {
            throw new ArgumentNullException("buffer");
        }

        // Set each byte in the buffer to 0.
        for (int x = 0; x < buffer.Length; x++)
        {
            buffer[x] = 0;
        }
    }

    #endregion
}

Cet exemple provient de MSDN.

Il s'agit d'une démonstration de console qui montre comment créer une clé sécurisée basée sur un mot de passe défini par l'utilisateur et comment créer un SALT aléatoire basé sur le générateur aléatoire cryptographique.

Remarques:

  • La fonction intégrée PasswordDeriveBytes utilise l'algorithme standard PBKDF1 pour générer une clé à partir du mot de passe. Par défaut, il utilise 100 itérations pour générer la clé permettant de ralentir les attaques par force brute. Le SALT généré aléatoirement renforce la clé.

  • La fonction CryptDeriveKey convertit la clé générée par PasswordDeriveBytes en une clé compatible avec l'algorithme de chiffrement spécifié (ici "TripleDES") en utilisant l'algorithme de hachage spécifié (ici "SHA1"). La clé dans cet exemple est 192 octets, et le vecteur d'initialisation IV provient du fournisseur de cryptage triple-DES.

  • Généralement, ce mécanisme est utilisé pour protéger une clé générée aléatoirement par un mot de passe, qui crypte une grande quantité de données. Vous pouvez également l'utiliser pour fournir plusieurs mots de passe d'utilisateurs différents pour donner accès aux mêmes données (protégées par une autre clé aléatoire).

  • Malheureusement, CryptDeriveKey ne prend actuellement pas en charge AES. Voir ici
    REMARQUE: pour résoudre ce problème, vous pouvez créer une clé AES aléatoire pour le chiffrement des données à protéger avec AES et stocker la clé AES dans un conteneur TripleDES qui utilise la clé générée par CryptDeriveKey . Mais cela limite la sécurité à TripleDES, ne profite pas des plus grandes tailles de clés d'AES et crée une dépendance à TripleDES.

Utilisation: Voir la méthode Main ().