ASP.NET Identity по умолчанию Password Hasher - Как это работает и безопасно ли?

Мне интересно, как Password Hasher, который по умолчанию реализован в UserManager, который поставляется с MVC 5 и ASP.NET Identity Framework, безопасен достаточно? И если так, если бы вы могли объяснить мне, как это работает?

Интерфейс IPasswordHasher выглядит следующим образом:

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

Как вы можете видеть, он не принимает соль, но в этой теме упоминается: "хэш-код ассемблера Asp.net" что он заставляет засовывать соль за кулисами. Поэтому мне интересно, как это делается? И откуда эта соль?

Моя забота о том, что соль является статической, что делает ее довольно небезопасной.

Ответ 1

Вот как работает реализация по умолчанию. Он использует функцию деривации ключей со случайной солью для создания хэша. Соль входит в состав продукции KDF. Таким образом, каждый раз, когда вы "хэш" тот же пароль, вы получите разные хэши. Чтобы проверить хэш, выходной сигнал отбрасывается на соль и остальное, а KDF снова запускается на пароле с указанной солью. Если результат совпадает с остальной частью исходного результата, хеш проверяется.

Хэш:

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

Проверка:

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

Ответ 2

Поскольку в наши дни ASP.NET является открытым исходным кодом, вы можете найти его на GitHub: AspNet.Identity 3.0 и AspNet.Identity 2.0.

Из комментариев:

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

Ответ 3

Я понимаю принятый ответ и проголосовал против него, но подумал, что дам свой ответ непрофессионалам здесь...

Создание хэша

Соль генерируется случайным образом с помощью функции Rfc2898DeriveBytes, который генерирует хеш и соль. Входные данные для Rfc2898DeriveBytes - это пароль, размер создаваемой соли и количество итераций хеширования. https://msdn.microsoft.com/en-us/library/h83s4e12(v=vs.110).aspx
Затем соль и хэш смешиваются (сначала следует соль хешем) и закодирован в виде строки (так что соль кодируется в хэш). Этот закодированный хеш (который содержит соль и хеш) затем хранится (как правило) в базе данных против пользователя.

Проверка пароля по хешу

Чтобы проверить пароль, который вводит пользователь.

Соль извлечена из сохраненного хешированного пароля.
Соль используется для хеширования введенного пользователем пароля с использованием перегрузки Rfc2898DeriveBytes, которая принимает соль вместо ее генерации. https://msdn.microsoft.com/en-us/library/yx129kfs(v=vs.110).aspx
Затем сохраненный хэш и тестовый хеш сравниваются.

Хеш

Под крышками хеш генерируется с использованием хеш-функции SHA1 (https://en.wikipedia.org/wiki/SHA-1). Эта функция итеративно вызывается 1000 раз (в стандартной реализации Identity)

Почему это безопасно

Случайные соли означают, что злоумышленник не может использовать предварительно сгенерированную таблицу хэшей, чтобы попытаться взломать пароли. Они должны были бы генерировать хэш-таблица для каждой соли. (Предполагая, что хакер также скомпрометировал вашу соль)
Если 2 пароля совпадают, они будут есть разные хеши. (имеется в виду, что злоумышленники не могут сделать вывод пароли)
Итеративный вызов SHA1 1000 раз означает, что Злоумышленник также должен сделать это. Идея в том, что если у них нет время на суперкомпьютере у них не будет достаточно ресурсов, чтобы перебрать заставить пароль из хеша. Это значительно замедлит время создания хеш-таблицы для данной соли.

Ответ 4

Для таких, как я, которые являются совершенно новыми для этого, вот код с константой и фактический способ сравнения байта []. Я получил весь этот код из stackoverflow, но определил константы, чтобы значения могли быть изменены, а также

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

В вашем пользовательском ApplicationUserManager вы устанавливаете свойство PasswordHasher именем класса, который содержит указанный выше код.

Ответ 5

Вы можете получить источник хеш-пароля по умолчанию для ASP.NET Core здесь:

PasswordHasher.cs