Wie man ein Passwort hasht

Ich möchte den Hash eines Passworts auf dem Telefon speichern, bin mir aber nicht sicher, wie ich das machen soll. Ich kann nur scheinbar Verschlüsselungsmethoden finden. Wie soll das Passwort richtig gehasht werden?

UPDATE : Diese Antwort ist ernsthaft veraltet . Bitte verwenden Sie stattdessen die Empfehlungen unter https://stackoverflow.com/a/10402129/251311 .

Sie können entweder verwenden

var md5 = new MD5CryptoServiceProvider();
var md5data = md5.ComputeHash(data);

oder

var sha1 = new SHA1CryptoServiceProvider();
var sha1data = sha1.ComputeHash(data);

Um dataals Byte-Array zu erhalten, könnten Sie verwenden

var data = Encoding.ASCII.GetBytes(password);

und um String von md5dataoder zurück zu bekommensha1data

var hashedPassword = ASCIIEncoding.GetString(md5data);

Die meisten anderen Antworten hier sind mit den heutigen Best Practices etwas veraltet. Als solches ist hier die Anwendung der Verwendung von PBKDF2 / Rfc2898DeriveByteszum Speichern und Überprüfen von Passwörtern. Der folgende Code befindet sich in diesem Beitrag in einer eigenständigen Klasse: Ein weiteres Beispiel für das Speichern eines gesalzenen Kennwort-Hash . Die Grundlagen sind wirklich einfach, daher ist es hier aufgeschlüsselt:

SCHRITT 1 Erstellen Sie den Salzwert mit einem kryptografischen PRNG:

byte[] salt;
new RNGCryptoServiceProvider().GetBytes(salt = new byte[16]);

SCHRITT 2 Erstellen Sie die Rfc2898DeriveBytes und erhalten Sie den Hashwert:

var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 100000);
byte[] hash = pbkdf2.GetBytes(20);

SCHRITT 3 Kombinieren Sie die Salt- und Passwortbytes für die spätere Verwendung:

byte[] hashBytes = new byte[36];
Array.Copy(salt, 0, hashBytes, 0, 16);
Array.Copy(hash, 0, hashBytes, 16, 20);

SCHRITT 4 Verwandeln Sie das kombinierte Salz + Hasch in eine Zeichenfolge zur Lagerung

string savedPasswordHash = Convert.ToBase64String(hashBytes);
DBContext.AddUser(new User { ..., Password = savedPasswordHash });

SCHRITT 5 Überprüfen Sie das vom Benutzer eingegebene Passwort anhand eines gespeicherten Passworts

/* Fetch the stored value */
string savedPasswordHash = DBContext.GetUser(u => u.UserName == user).Password;
/* Extract the bytes */
byte[] hashBytes = Convert.FromBase64String(savedPasswordHash);
/* Get the salt */
byte[] salt = new byte[16];
Array.Copy(hashBytes, 0, salt, 0, 16);
/* Compute the hash on the password the user entered */
var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 100000);
byte[] hash = pbkdf2.GetBytes(20);
/* Compare the results */
for (int i=0; i < 20; i++)
    if (hashBytes[i+16] != hash[i])
        throw new UnauthorizedAccessException();

Hinweis: Abhängig von den Leistungsanforderungen Ihrer spezifischen Anwendung kann der Wert 100000reduziert werden. Ein Mindestwert sollte vorhanden sein 10000.

Basierend auf der großartigen Antwort von csharptest.net habe ich eine Klasse dafür geschrieben:

public static class SecurePasswordHasher
{
    /// <summary>
    /// Size of salt.
    /// </summary>
    private const int SaltSize = 16;

    /// <summary>
    /// Size of hash.
    /// </summary>
    private const int HashSize = 20;

    /// <summary>
    /// Creates a hash from a password.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="iterations">Number of iterations.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password, int iterations)
    {
        // Create salt
        byte[] salt;
        new RNGCryptoServiceProvider().GetBytes(salt = new byte[SaltSize]);

        // Create hash
        var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations);
        var hash = pbkdf2.GetBytes(HashSize);

        // Combine salt and hash
        var hashBytes = new byte[SaltSize + HashSize];
        Array.Copy(salt, 0, hashBytes, 0, SaltSize);
        Array.Copy(hash, 0, hashBytes, SaltSize, HashSize);

        // Convert to base64
        var base64Hash = Convert.ToBase64String(hashBytes);

        // Format hash with extra information
        return string.Format("$MYHASH$V1${0}${1}", iterations, base64Hash);
    }

    /// <summary>
    /// Creates a hash from a password with 10000 iterations
    /// </summary>
    /// <param name="password">The password.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password)
    {
        return Hash(password, 10000);
    }

    /// <summary>
    /// Checks if hash is supported.
    /// </summary>
    /// <param name="hashString">The hash.</param>
    /// <returns>Is supported?</returns>
    public static bool IsHashSupported(string hashString)
    {
        return hashString.Contains("$MYHASH$V1$");
    }

    /// <summary>
    /// Verifies a password against a hash.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="hashedPassword">The hash.</param>
    /// <returns>Could be verified?</returns>
    public static bool Verify(string password, string hashedPassword)
    {
        // Check hash
        if (!IsHashSupported(hashedPassword))
        {
            throw new NotSupportedException("The hashtype is not supported");
        }

        // Extract iteration and Base64 string
        var splittedHashString = hashedPassword.Replace("$MYHASH$V1$", "").Split('$');
        var iterations = int.Parse(splittedHashString[0]);
        var base64Hash = splittedHashString[1];

        // Get hash bytes
        var hashBytes = Convert.FromBase64String(base64Hash);

        // Get salt
        var salt = new byte[SaltSize];
        Array.Copy(hashBytes, 0, salt, 0, SaltSize);

        // Create hash with given salt
        var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations);
        byte[] hash = pbkdf2.GetBytes(HashSize);

        // Get result
        for (var i = 0; i < HashSize; i++)
        {
            if (hashBytes[i + SaltSize] != hash[i])
            {
                return false;
            }
        }
        return true;
    }
}

Verwendung:

// Hash
var hash = SecurePasswordHasher.Hash("mypassword");

// Verify
var result = SecurePasswordHasher.Verify("mypassword", hash);

Ein Beispiel-Hash könnte sein:

$MYHASH$V1$10000$Qhxzi6GNu/Lpy3iUqkeqR/J1hh8y/h5KPDjrv89KzfCVrubn

Wie Sie sehen können, habe ich auch die Iterationen in den Hash aufgenommen, um die Verwendung zu vereinfachen und die Möglichkeit zu bieten, diese zu aktualisieren, falls ein Upgrade erforderlich ist.

Wenn Sie sich für .net Core interessieren, habe ich auch eine .net Core-Version für Code Review .

Ich verwende einen Hash und ein Salt für meine Passwortverschlüsselung (es ist der gleiche Hash, den die Asp.Net-Mitgliedschaft verwendet):

private string PasswordSalt
{
   get
   {
      var rng = new RNGCryptoServiceProvider();
      var buff = new byte[32];
      rng.GetBytes(buff);
      return Convert.ToBase64String(buff);
   }
}

private string EncodePassword(string password, string salt)
{
   byte[] bytes = Encoding.Unicode.GetBytes(password);
   byte[] src = Encoding.Unicode.GetBytes(salt);
   byte[] dst = new byte[src.Length + bytes.Length];
   Buffer.BlockCopy(src, 0, dst, 0, src.Length);
   Buffer.BlockCopy(bytes, 0, dst, src.Length, bytes.Length);
   HashAlgorithm algorithm = HashAlgorithm.Create("SHA1");
   byte[] inarray = algorithm.ComputeHash(dst);
   return Convert.ToBase64String(inarray);
}

1. Erstelle ein Salz,
2. Erstellen Sie ein Hash-Passwort mit Salt
3. Speichern Sie sowohl Haschisch als auch Salz
4. Mit Passwort und Salt entschlüsseln ... damit Entwickler das Passwort nicht entschlüsseln können

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); 
      }
 }

Die Antworten von @ csharptest.net und Christian Gollhardt sind großartig, vielen Dank. Nachdem ich diesen Code in der Produktion mit Millionen von Datensätzen ausgeführt hatte, stellte ich fest, dass ein Speicherverlust vorliegt. Die Klassen RNGCryptoServiceProvider und Rfc2898DeriveBytes werden von IDisposable abgeleitet, aber wir verfügen nicht über sie. Ich werde meine Lösung als Antwort schreiben, wenn jemand eine entsorgte Version benötigt.

public static class SecurePasswordHasher
{
    /// <summary>
    /// Size of salt.
    /// </summary>
    private const int SaltSize = 16;

    /// <summary>
    /// Size of hash.
    /// </summary>
    private const int HashSize = 20;

    /// <summary>
    /// Creates a hash from a password.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="iterations">Number of iterations.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password, int iterations)
    {
        // Create salt
        using (var rng = new RNGCryptoServiceProvider())
        {
            byte[] salt;
            rng.GetBytes(salt = new byte[SaltSize]);
            using (var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations))
            {
                var hash = pbkdf2.GetBytes(HashSize);
                // Combine salt and hash
                var hashBytes = new byte[SaltSize + HashSize];
                Array.Copy(salt, 0, hashBytes, 0, SaltSize);
                Array.Copy(hash, 0, hashBytes, SaltSize, HashSize);
                // Convert to base64
                var base64Hash = Convert.ToBase64String(hashBytes);

                // Format hash with extra information
                return $"$HASH|V1${iterations}${base64Hash}";
            }
        }

    }

    /// <summary>
    /// Creates a hash from a password with 10000 iterations
    /// </summary>
    /// <param name="password">The password.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password)
    {
        return Hash(password, 10000);
    }

    /// <summary>
    /// Checks if hash is supported.
    /// </summary>
    /// <param name="hashString">The hash.</param>
    /// <returns>Is supported?</returns>
    public static bool IsHashSupported(string hashString)
    {
        return hashString.Contains("HASH|V1$");
    }

    /// <summary>
    /// Verifies a password against a hash.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="hashedPassword">The hash.</param>
    /// <returns>Could be verified?</returns>
    public static bool Verify(string password, string hashedPassword)
    {
        // Check hash
        if (!IsHashSupported(hashedPassword))
        {
            throw new NotSupportedException("The hashtype is not supported");
        }

        // Extract iteration and Base64 string
        var splittedHashString = hashedPassword.Replace("$HASH|V1$", "").Split('$');
        var iterations = int.Parse(splittedHashString[0]);
        var base64Hash = splittedHashString[1];

        // Get hash bytes
        var hashBytes = Convert.FromBase64String(base64Hash);

        // Get salt
        var salt = new byte[SaltSize];
        Array.Copy(hashBytes, 0, salt, 0, SaltSize);

        // Create hash with given salt
        using (var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations))
        {
            byte[] hash = pbkdf2.GetBytes(HashSize);

            // Get result
            for (var i = 0; i < HashSize; i++)
            {
                if (hashBytes[i + SaltSize] != hash[i])
                {
                    return false;
                }
            }

            return true;
        }

    }
}

Verwendung:

// Hash
var hash = SecurePasswordHasher.Hash("mypassword");

// Verify
var result = SecurePasswordHasher.Verify("mypassword", hash);

Ich denke, KeyDerivation.Pbkdf2 ist besser als Rfc2898DeriveBytes.

Beispiel und Erklärung: Hash-Passwörter in 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=
 */

Dies ist ein Beispielcode aus dem Artikel. Und es ist eine Mindestsicherheitsstufe. Um es zu erhöhen, würde ich anstelle des Parameters KeyDerivationPrf.HMACSHA1 verwenden

KeyDerivationPrf.HMACSHA256 oder KeyDerivationPrf.HMACSHA512.

Gehen Sie beim Passwort-Hashing keine Kompromisse ein. Es gibt viele mathematisch fundierte Methoden, um das Hacken von Passwort-Hashs zu optimieren. Folgen könnten katastrophal sein. Sobald ein Übeltäter die Passwort-Hash-Tabelle Ihrer Benutzer in die Hände bekommen kann, ist es für ihn relativ einfach, Passwörter zu knacken, wenn der Algorithmus schwach oder die Implementierung falsch ist. Er hat viel Zeit (Zeit x Computerleistung), um Passwörter zu knacken. Das Passwort-Hashing sollte kryptografisch stark sein, um "viel Zeit" in " unangemessen viel Zeit " umzuwandeln .

Noch ein Punkt zum Hinzufügen

Die Hash-Überprüfung braucht Zeit (und es ist gut). Wenn der Benutzer einen falschen Benutzernamen eingibt, dauert es keine Zeit, um zu überprüfen, ob der Benutzername falsch ist. Wenn der Benutzername korrekt ist, starten wir die Passwortüberprüfung - es ist ein relativ langer Prozess.

Für einen Hacker wäre es sehr leicht zu verstehen, ob ein Benutzer existiert oder nicht.

Stellen Sie sicher, dass Sie keine sofortige Antwort zurückgeben, wenn der Benutzername falsch ist.

Unnötig zu sagen: Geben Sie niemals eine Antwort, was falsch ist. Nur allgemeine "Anmeldeinformationen sind falsch".