Comment hacher un mot de passe

Question

J'aimerais stocker le hachage d'un mot de passe sur le téléphone, mais je ne sais pas comment faire. Je ne trouve que des méthodes de cryptage. Comment faire pour que le mot de passe soit correctement haché ?

Answer 1

Dans ASP.NET Core, utilisez PasswordHasher<TUser> .
 _{- Espace de nom : <code>Microsoft.AspNetCore.Identity</code><br> - Montage : <code>Microsoft.Extensions.Identity.Core.dll</code> ( <a href="https://www.nuget.org/packages/Microsoft.Extensions.Identity.Core" rel="noreferrer">NuGet </a>| <a href="https://github.com/dotnet/aspnetcore/blob/master/src/Identity/Extensions.Core/src/PasswordHasher.cs" rel="noreferrer">Source : </a>)}

---

Pour hacher un mot de passe, utilisez HashPassword() :

var hashedPassword = new PasswordHasher<object?>().HashPassword(null, password);

Pour vérifier un mot de passe, utilisez VerifyHashedPassword() :

var passwordVerificationResult = new PasswordHasher<object?>().VerifyHashedPassword(null, hashedPassword, password);
switch (passwordVerificationResult)
{
    case PasswordVerificationResult.Failed:
        Console.WriteLine("Password incorrect.");
        break;

    case PasswordVerificationResult.Success:
        Console.WriteLine("Password ok.");
        break;

    case PasswordVerificationResult.SuccessRehashNeeded:
        Console.WriteLine("Password ok but should be rehashed and updated.");
        break;

    default:
        throw new ArgumentOutOfRangeException();
}

---

Pour :

• Fait partie de la plateforme .NET. Bien plus sûr et plus fiable que de créer son propre algorithme de cryptographie.
• Nombre d'itérations configurable et compatibilité future (voir PasswordHasherOptions ).
• Pris Attaque en temps en considération lors de la vérification du mot de passe ( source ), tout comme ce que PHP y Allez sur a fait.

Cons :

• Format du mot de passe haché incompatibles avec ceux hachés par d'autres bibliothèques ou dans d'autres langages.

Answer 2

1. Créez un sel,
2. Créer un mot de passe haché avec un sel
3. Sauvegarder à la fois le hachage et le sel

4. décryptez avec un mot de passe et un sel... pour que les développeurs ne puissent pas décrypter le mot de passe.

   public class CryptographyProcessor { public string CreateSalt(int size) { //Generate a cryptographic random number. RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider(); byte[] buff = new byte[size]; rng.GetBytes(buff); return Convert.ToBase64String(buff); }

     public string GenerateHash(string input, string salt)
     { 
        byte[] bytes = Encoding.UTF8.GetBytes(input + salt);
        SHA256Managed sHA256ManagedString = new SHA256Managed();
        byte[] hash = sHA256ManagedString.ComputeHash(bytes);
        return Convert.ToBase64String(hash);
     }
   
     public bool AreEqual(string plainTextInput, string hashedInput, string salt)
     {
          string newHashedPin = GenerateHash(plainTextInput, salt);
          return newHashedPin.Equals(hashedInput); 
     }

   }

Answer 3

Je pense que l'utilisation de KeyDerivation.Pbkdf2 est meilleure que Rfc2898DeriveBytes.

Exemple et explication : Hacher les mots de passe en ASP.NET Core

using System;
using System.Security.Cryptography;
using Microsoft.AspNetCore.Cryptography.KeyDerivation;
 
public class Program
{
    public static void Main(string[] args)
    {
        Console.Write("Enter a password: ");
        string password = Console.ReadLine();
 
        // generate a 128-bit salt using a secure PRNG
        byte[] salt = new byte[128 / 8];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(salt);
        }
        Console.WriteLine($"Salt: {Convert.ToBase64String(salt)}");
 
        // derive a 256-bit subkey (use HMACSHA1 with 10,000 iterations)
        string hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(
            password: password,
            salt: salt,
            prf: KeyDerivationPrf.HMACSHA1,
            iterationCount: 10000,
            numBytesRequested: 256 / 8));
        Console.WriteLine($"Hashed: {hashed}");
    }
}
 
/*
 * SAMPLE OUTPUT
 *
 * Enter a password: Xtw9NMgx
 * Salt: NZsP6NnmfBuYeJrrAKNuVQ==
 * Hashed: /OOoOer10+tGwTRDTrQSoeCxVTFr6dtYly7d0cPxIak=
 */

Voici un exemple de code tiré de l'article. Il s'agit d'un niveau de sécurité minimum. Pour l'augmenter j'utiliserais à la place du paramètre KeyDerivationPrf.HMACSHA1

KeyDerivationPrf.HMACSHA256 ou KeyDerivationPrf.HMACSHA512.

Ne faites pas de compromis sur le hachage des mots de passe. Il existe de nombreuses méthodes mathématiquement valables pour optimiser le hachage des mots de passe. Les conséquences pourraient être désastreuses. Si un malfaiteur met la main sur la table de hachage des mots de passe de vos utilisateurs, il lui sera relativement facile de craquer les mots de passe si l'algorithme est faible ou si la mise en œuvre est incorrecte. facile pour lui de craquer les mots de passe si l'algorithme est faible ou si la mise en œuvre est incorrecte. Il dispose de beaucoup de temps (temps x puissance de l'ordinateur) pour craquer les mots de passe. Le hachage des mots de passe devrait être cryptographiquement fort pour transformer "beaucoup de temps" en "beaucoup de temps". en " un temps déraisonnable ".

Un point supplémentaire à ajouter

La vérification des hachages prend du temps (et c'est bien). Lorsque l'utilisateur saisit un nom d'utilisateur incorrect, il ne faut pas de temps pour vérifier que le nom d'utilisateur est incorrect. Lorsque le nom d'utilisateur est correct, nous commençons la vérification du mot de passe - c'est un processus relativement long.

Pour un pirate, il serait très facile de comprendre si l'utilisateur existe ou non.

Veillez à ne pas renvoyer une réponse immédiate lorsque le nom d'utilisateur est incorrect.

Inutile de dire qu'il ne donne jamais de réponse à ce qui ne va pas. Juste une réponse générale : "Les références sont fausses".

Answer 4

Utilisez la classe ci-dessous pour générer d'abord un Salt. Chaque utilisateur doit avoir un sel différent, nous pouvons le sauvegarder dans la base de données avec les autres propriétés de l'utilisateur. La valeur rounds décide du nombre de fois que le mot de passe sera haché.

Pour plus de détails : https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.rfc2898derivebytes.-ctor?view=netcore-3.1#System_Security_Cryptography_Rfc2898DeriveBytes__ctor_System_Byte___System_Byte___System_Int32 _

public class HashSaltWithRounds
{
    int saltLength = 32;
    public byte[] GenerateSalt()
    {
        using (var randomNumberGenerator = new RNGCryptoServiceProvider())
        {
            var randomNumber = new byte[saltLength];
            randomNumberGenerator.GetBytes(randomNumber);
            return randomNumber;
        }
    }

    public string HashDataWithRounds(byte[] password, byte[] salt, int rounds)
    {
        using(var rfc2898= new Rfc2898DeriveBytes(password, salt, rounds))
        {
            return Convert.ToBase64String(rfc2898.GetBytes(32));
        }
    }
}

Nous pouvons l'appeler depuis une application console comme suit. J'ai haché le mot de passe deux fois en utilisant la méthode même sel .

public class Program
{
    public static void Main(string[] args)
    {
        int numberOfIterations = 99;
        var hashFunction = new HashSaltWithRounds();

        string password = "Your Password Here";
        byte[] salt = hashFunction.GenerateSalt();

        var hashedPassword1 = hashFunction.HashDataWithRounds(Encoding.UTF8.GetBytes(password), salt, numberOfIterations);
        var hashedPassword2 = hashFunction.HashDataWithRounds(Encoding.UTF8.GetBytes(password), salt, numberOfIterations);

        Console.WriteLine($"hashedPassword1 :{hashedPassword1}");
        Console.WriteLine($"hashedPassword2 :{hashedPassword2}");
        Console.WriteLine(hashedPassword1.Equals(hashedPassword2));

        Console.ReadLine();

    }
}