Пароль по умолчанию для ASP.NET Identity - как это работает и безопасно ли это?
Мне интересно, достаточно ли безопасен пароль хэшер, который по умолчанию реализован в UserManager, который поставляется с MVC 5 и ASP.NET Identity Framework? И если да, то не могли бы вы объяснить мне, как это работает?
Интерфейс IPasswordHasher выглядит так:
public interface IPasswordHasher
{
string HashPassword(string password);
PasswordVerificationResult VerifyHashedPassword(string hashedPassword,
string providedPassword);
}
Как вы можете видеть, это не требует соли, но упоминается в этой теме: " Хэширование идентификационного пароля Asp.net", что это действительно замаскирует его за кулисами. Так что мне интересно, как это сделать? И откуда эта соль?
Меня беспокоит то, что соль статична, что делает ее небезопасной.
6 ответов
Вот как работает реализация по умолчанию. Для получения хэша используется функция получения ключа со случайной солью. Соль включена в состав продукции 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);
}
Поскольку в наши дни 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.)
*/
Я понимаю принятый ответ и проголосовал за него, но подумал, что дам ответ моего мирянина здесь...
Создание хэша
- Соль генерируется случайным образом с помощью функции 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 раз означает, что злоумышленник также должен сделать это. Идея состоит в том, что, если у них нет времени на суперкомпьютер, у них не будет достаточно ресурсов для взлома пароля из хэша. Это значительно замедлит время создания хеш-таблицы для данной соли.
Для таких, как я, новичок в этом, вот код с const и реальный способ сравнить байты []. Я получил весь этот код из stackru, но определил константы, чтобы значения могли быть изменены, а также
// 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://stackru.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 имя класса, который содержит приведенный выше код.
Я пишу свой класс PasswordHasher на основе .net6 PasswordHasher docs последней версии (V3)https://github.com/dotnet/aspnetcore/blob/b56bb17db3ae73ce5a8664a2023a9b9af89499dd/src/Identity/Extensions.Core/src/PasswordHasher.cs
namespace Utilities;
public class PasswordHasher
{
public const int Pbkdf2Iterations = 1000;
public static string HashPasswordV3(string password)
{
return Convert.ToBase64String(HashPasswordV3(password, RandomNumberGenerator.Create()
, prf: KeyDerivationPrf.HMACSHA512, iterCount: Pbkdf2Iterations, saltSize: 128 / 8
, numBytesRequested: 256 / 8));
}
public static bool VerifyHashedPasswordV3(string hashedPasswordStr, string password)
{
byte[] hashedPassword = Convert.FromBase64String(hashedPasswordStr);
var iterCount = default(int);
var prf = default(KeyDerivationPrf);
try
{
// Read header information
prf = (KeyDerivationPrf)ReadNetworkByteOrder(hashedPassword, 1);
iterCount = (int)ReadNetworkByteOrder(hashedPassword, 5);
int saltLength = (int)ReadNetworkByteOrder(hashedPassword, 9);
// Read the salt: must be >= 128 bits
if (saltLength < 128 / 8)
{
return false;
}
byte[] salt = new byte[saltLength];
Buffer.BlockCopy(hashedPassword, 13, salt, 0, salt.Length);
// Read the subkey (the rest of the payload): must be >= 128 bits
int subkeyLength = hashedPassword.Length - 13 - salt.Length;
if (subkeyLength < 128 / 8)
{
return false;
}
byte[] expectedSubkey = new byte[subkeyLength];
Buffer.BlockCopy(hashedPassword, 13 + salt.Length, expectedSubkey, 0, expectedSubkey.Length);
// Hash the incoming password and verify it
byte[] actualSubkey = KeyDerivation.Pbkdf2(password, salt, prf, iterCount, subkeyLength);
#if NETSTANDARD2_0 || NETFRAMEWORK
return ByteArraysEqual(actualSubkey, expectedSubkey);
#elif NETCOREAPP
return CryptographicOperations.FixedTimeEquals(actualSubkey, expectedSubkey);
#else
#error Update target frameworks
#endif
}
catch
{
// This should never occur except in the case of a malformed payload, where
// we might go off the end of the array. Regardless, a malformed payload
// implies verification failed.
return false;
}
}
// privates
private static byte[] HashPasswordV3(string password, RandomNumberGenerator rng, KeyDerivationPrf prf, int iterCount, int saltSize, int numBytesRequested)
{
byte[] salt = new byte[saltSize];
rng.GetBytes(salt);
byte[] subkey = KeyDerivation.Pbkdf2(password, salt, prf, iterCount, numBytesRequested);
var outputBytes = new byte[13 + salt.Length + subkey.Length];
outputBytes[0] = 0x01; // format marker
WriteNetworkByteOrder(outputBytes, 1, (uint)prf);
WriteNetworkByteOrder(outputBytes, 5, (uint)iterCount);
WriteNetworkByteOrder(outputBytes, 9, (uint)saltSize);
Buffer.BlockCopy(salt, 0, outputBytes, 13, salt.Length);
Buffer.BlockCopy(subkey, 0, outputBytes, 13 + saltSize, subkey.Length);
return outputBytes;
}
private static void WriteNetworkByteOrder(byte[] buffer, int offset, uint value)
{
buffer[offset + 0] = (byte)(value >> 24);
buffer[offset + 1] = (byte)(value >> 16);
buffer[offset + 2] = (byte)(value >> 8);
buffer[offset + 3] = (byte)(value >> 0);
}
private static uint ReadNetworkByteOrder(byte[] buffer, int offset)
{
return ((uint)(buffer[offset + 0]) << 24)
| ((uint)(buffer[offset + 1]) << 16)
| ((uint)(buffer[offset + 2]) << 8)
| ((uint)(buffer[offset + 3]));
}
}
Использование в UserController:
namespace WebApi.Controllers.UserController;
[Route("api/[controller]/[action]")]
[ApiController]
public class UserController : ControllerBase
{
private readonly IUserService _userService;
public UserController(IUserService userService)
{
_userService = userService;
}
[HttpPost]
public async Task<IActionResult> Register(VmRegister model)
{
var user = new User
{
UserName = model.UserName,
PasswordHash = PasswordHasher.HashPasswordV3(model.Password),
FirstName = model.FirstName,
LastName = model.LastName,
Mobile = model.Mobile,
Email = model.Email,
};
await _userService.Add(user);
return StatusCode(201, user.Id);
}
[HttpPost]
public async Task<IActionResult> Login(VmLogin model)
{
var user = await _userService.GetByUserName(model.UserName);
if (user is null || !PasswordHasher.VerifyHashedPasswordV3(user.PasswordHash, model.Password))
throw new Exception("The UserName or Password is wrong.");
// generate token
return Ok();
}
}
Следуя ответу Андрея Савиных , я внес следующие изменения. Я использую Dapper с существующей БД, настроенной с помощью AspNet Identity.
Обратите внимание, что
PasswordHasherCompatibilityMode.IdentityV2отлично работает, если вы используете AspNet Identity. Еще не тестировался для AspNetCore Identity.
Вот GitHub Gist для полного класса.