ASP.NET Identity's Default Password Hasher - Nasıl çalışır ve güvenli mi?

MVC 5 ve ASP.NET Identity Framework ile birlikte gelen UserManager varsayılan uygulanan Parola Hasher yeterince güvenli olup olmadığını merak ediyorum ? Ve eğer öyleyse, bana nasıl çalıştığını açıklayabilirsen?

IPasswordHasher arayüzü şöyle görünür:

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

Gördüğünüz gibi, bir tuz almaz, ancak bu konuda bahsedilmiştir: " Asp.net Identity password hashing " perde arkasına tuz bulaşır. Bunu nasıl yaptığını merak ediyorum. Ve bu tuz nereden geliyor?

Benim endişem tuzun statik olması ve güvensiz olması.

Varsayılan uygulamanın ( ASP.NET Framework veya ASP.NET Core ) nasıl çalıştığı aşağıda açıklanmıştır. Karma üretmek için rastgele tuzlu bir Anahtar Türev Fonksiyonu kullanır . Tuz, KDF'nin çıktısının bir parçası olarak dahil edilir. Böylece, her zaman aynı şifreyi "hash" farklı karma alırsınız. Karmayı doğrulamak için çıktı tuz ve geri kalanına geri bölünür ve KDF şifre üzerinde belirtilen tuzla tekrar çalıştırılır. Sonuç ilk çıktının geri kalanıyla eşleşirse, karma doğrulanır.

Karma:

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

Doğrulanıyor:

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 bu günlerde açık kaynak olduğundan, GitHub'da bulabilirsiniz: AspNet.Identity 3.0 ve AspNet.Identity 2.0 .

Yorumlardan:

/* =======================
 * 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.)
 */

Kabul edilen cevabı anladım ve oy verdim ama yandaşlarımın cevabını buraya dökeceğimizi düşündüm ...

Karma oluşturma

1. Tuz, bir karma ve bir tuz üreten Rfc2898DeriveBytes fonksiyonu kullanılarak rastgele üretilir . Rfc2898DeriveBytes girişleri parola, üretilecek tuzun boyutu ve gerçekleştirilecek karma yineleme sayısıdır. https://msdn.microsoft.com/en-us/library/h83s4e12(v=vs.110).aspx
2. Tuz ve karma daha sonra birlikte ezilir (önce tuz ardından karma) ve bir ip olarak kodlanır (böylece tuz karma içinde kodlanır). Bu kodlanmış karma (tuz ve karma içeren) daha sonra (tipik olarak) kullanıcıya karşı veritabanında saklanır.

Bir karma için parola kontrol etme

Kullanıcının girdiği şifreyi kontrol etmek için.

1. Tuz, saklanan karma paroladan çıkarılır.
2. Tuz, kullanıcı giriş şifresini, Rfc2898DeriveBytes aşırı yüklemesi kullanarak bir tane üretmek yerine bir tuz alırken hash etmek için kullanılır . https://msdn.microsoft.com/en-us/library/yx129kfs(v=vs.110).aspx
3. Saklanan karma ve test karma karşılaştırılır.

Karma

Kapakların altında karma, SHA1 karma işlevi kullanılarak oluşturulur ( https://en.wikipedia.org/wiki/SHA-1 ). Bu işlev yinelenen şekilde 1000 kez çağrılır (Varsayılan Kimlik uygulamasında)

Bu neden güvenli

• Rastgele tuzlar, bir saldırganın şifreleri denemek ve kırmak için önceden oluşturulmuş bir karma tablo kullanamayacağı anlamına gelir. Her tuz için bir karma tablosu oluşturmaları gerekir. (Burada bilgisayar korsanının tuzunuzu tehlikeye attığını varsayarsak)
• 2 parola aynı ise farklı karma değerlere sahip olurlar. (yani saldırganlar 'ortak' şifreleri çıkaramazlar)
• SHA1'i 1000 kez yinelemek, saldırganın da bunu yapması gerektiği anlamına gelir. Fikir şu ki, bir süper bilgisayar üzerinde zamanları olmadıkça, şifreyi karma için zorlamak için yeterli kaynağa sahip olmayacaklardır. Belirli bir tuz için bir hash tablosu oluşturmak için zamanı büyük ölçüde yavaşlatacaktır.

Benim gibi bu konuda yepyeni olanlar için, burada const ile kod ve byte [] 'ları karşılaştırmanın gerçek bir yolu var. Stackoverflow tüm bu kodu aldım ama tanımlanmış consts böylece değerleri değiştirilebilir ve ayrıca

// 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://stackoverflow.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;
    }

Özel ApplicationUserManager'ınızda, PasswordHasher özelliğini yukarıdaki kodu içeren sınıfın adını ayarlarsınız.