c# - passwordhasher - rfc2898derivebytes




ASP.NET Identity Standard Password Hasher, wie funktioniert es und ist es sicher? (3)

Da ASP.NET heutzutage Open Source ist, können Sie es auf GitHub für AspNet.Identity 3.0 oder auf Codeplex für AspNet.Identity 2.0 finden .

Aus den Kommentaren:

/* =======================
 * HASHED PASSWORD FORMATS
 * =======================
 * 
 * Version 2:
 * PBKDF2 with HMAC-SHA1, 128-bit salt, 256-bit subkey, 1000 iterations.
 * (See also: SDL crypto guidelines v5.1, Part III)
 * Format: { 0x00, salt, subkey }
 *
 * Version 3:
 * PBKDF2 with HMAC-SHA256, 128-bit salt, 256-bit subkey, 10000 iterations.
 * Format: { 0x01, prf (UInt32), iter count (UInt32), salt length (UInt32), salt, subkey }
 * (All UInt32s are stored big-endian.)
 */

Ich frage mich, ob der Password Hasher, der standardmäßig im UserManager von MVC 5 und ASP.NET Identity Framework implementiert ist, sicher genug ist? Und wenn ja, wenn Sie mir erklären könnten, wie es funktioniert?

Die IPasswordHasher-Schnittstelle sieht folgendermaßen aus:

public interface IPasswordHasher
{
    string HashPassword(string password);
    PasswordVerificationResult VerifyHashedPassword(string hashedPassword, 
                                                       string providedPassword);
}

Wie Sie sehen können, braucht es kein Salz, aber es ist in diesem Thread erwähnt: " Asp.net Identity password hashing ", dass es tatsächlich hinter den Kulissen salzt. Ich frage mich, wie es das macht? Und woher kommt dieses Salz?

Meine Sorge ist, dass das Salz statisch ist, was es ziemlich unsicher macht.


Für diejenigen wie mich, die brandneu sind, hier ist Code mit const und eine tatsächliche Möglichkeit, die Byte [] zu vergleichen. Ich habe den ganzen Code von bekommen, aber defined costs, damit Werte geändert werden können und auch

// 24 = 192 bits
    private const int SaltByteSize = 24;
    private const int HashByteSize = 24;
    private const int HasingIterationsCount = 10101;


    public static string HashPassword(string password)
    {
        // http://.com/questions/19957176/asp-net-identity-password-hashing

        byte[] salt;
        byte[] buffer2;
        if (password == null)
        {
            throw new ArgumentNullException("password");
        }
        using (Rfc2898DeriveBytes bytes = new Rfc2898DeriveBytes(password, SaltByteSize, HasingIterationsCount))
        {
            salt = bytes.Salt;
            buffer2 = bytes.GetBytes(HashByteSize);
        }
        byte[] dst = new byte[(SaltByteSize + HashByteSize) + 1];
        Buffer.BlockCopy(salt, 0, dst, 1, SaltByteSize);
        Buffer.BlockCopy(buffer2, 0, dst, SaltByteSize + 1, HashByteSize);
        return Convert.ToBase64String(dst);
    }

    public static bool VerifyHashedPassword(string hashedPassword, string password)
    {
        byte[] _passwordHashBytes;

        int _arrayLen = (SaltByteSize + HashByteSize) + 1;

        if (hashedPassword == null)
        {
            return false;
        }

        if (password == null)
        {
            throw new ArgumentNullException("password");
        }

        byte[] src = Convert.FromBase64String(hashedPassword);

        if ((src.Length != _arrayLen) || (src[0] != 0))
        {
            return false;
        }

        byte[] _currentSaltBytes = new byte[SaltByteSize];
        Buffer.BlockCopy(src, 1, _currentSaltBytes, 0, SaltByteSize);

        byte[] _currentHashBytes = new byte[HashByteSize];
        Buffer.BlockCopy(src, SaltByteSize + 1, _currentHashBytes, 0, HashByteSize);

        using (Rfc2898DeriveBytes bytes = new Rfc2898DeriveBytes(password, _currentSaltBytes, HasingIterationsCount))
        {
            _passwordHashBytes = bytes.GetBytes(SaltByteSize);
        }

        return AreHashesEqual(_currentHashBytes, _passwordHashBytes);

    }

    private static bool AreHashesEqual(byte[] firstHash, byte[] secondHash)
    {
        int _minHashLength = firstHash.Length <= secondHash.Length ? firstHash.Length : secondHash.Length;
        var xor = firstHash.Length ^ secondHash.Length;
        for (int i = 0; i < _minHashLength; i++)
            xor |= firstHash[i] ^ secondHash[i];
        return 0 == xor;
    }

In Ihrem benutzerdefinierten ApplicationUserManager legen Sie die PasswordHasher-Eigenschaft den Name der Klasse fest, die den obigen Code enthält.


So funktioniert die Standardimplementierung . Es verwendet eine Schlüsselableitungsfunktion mit zufälligem Salz, um den Hash zu erzeugen. Das Salz ist als Teil der Ausgabe der KDF enthalten. Jedes Mal, wenn Sie dasselbe Passwort "hacken", erhalten Sie verschiedene Hashes. Um den Hash zu verifizieren, wird die Ausgabe wieder auf das Salz und den Rest aufgeteilt, und das KDF wird erneut auf dem Kennwort mit dem angegebenen Salz ausgeführt. Wenn das Ergebnis mit dem Rest der ursprünglichen Ausgabe übereinstimmt, wird der Hash verifiziert.

Hashing:

public static string HashPassword(string password)
{
    byte[] salt;
    byte[] buffer2;
    if (password == null)
    {
        throw new ArgumentNullException("password");
    }
    using (Rfc2898DeriveBytes bytes = new Rfc2898DeriveBytes(password, 0x10, 0x3e8))
    {
        salt = bytes.Salt;
        buffer2 = bytes.GetBytes(0x20);
    }
    byte[] dst = new byte[0x31];
    Buffer.BlockCopy(salt, 0, dst, 1, 0x10);
    Buffer.BlockCopy(buffer2, 0, dst, 0x11, 0x20);
    return Convert.ToBase64String(dst);
}

Überprüfung:

public static bool VerifyHashedPassword(string hashedPassword, string password)
{
    byte[] buffer4;
    if (hashedPassword == null)
    {
        return false;
    }
    if (password == null)
    {
        throw new ArgumentNullException("password");
    }
    byte[] src = Convert.FromBase64String(hashedPassword);
    if ((src.Length != 0x31) || (src[0] != 0))
    {
        return false;
    }
    byte[] dst = new byte[0x10];
    Buffer.BlockCopy(src, 1, dst, 0, 0x10);
    byte[] buffer3 = new byte[0x20];
    Buffer.BlockCopy(src, 0x11, buffer3, 0, 0x20);
    using (Rfc2898DeriveBytes bytes = new Rfc2898DeriveBytes(password, dst, 0x3e8))
    {
        buffer4 = bytes.GetBytes(0x20);
    }
    return ByteArraysEqual(buffer3, buffer4);
}




asp.net-identity