ASP.NET身份验证默认的密码哈希程序 - 它是如何工作的，是否安全？

Question

我想知道MVC 5和ASP.NET Identity Framework附带的UserManager默认实现的Password Hasher是否足够安全？如果是，你能否向我解释它是如何工作的？

IPasswordHasher接口如下：

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

正如您所看到的，它不需要盐，但在这个线程中提到了：“Asp.net Identity password hashing”，实际上在幕后确实加入了盐。所以我想知道它是如何做到的？盐来自哪里？

我的担忧是盐是静态的，这使得它相当不安全。

- André Snede

---

我不认为这直接回答了你的问题，但Brock Allen在这里谈到了一些你关心的问题=> http://brockallen.com/2013/10/20/the-good-the-bad-and-the-ugly-of-asp-net-identity/ ，他还编写了一个开源的用户身份管理和认证库，具有各种样板特性，如密码重置、哈希等等。https://github.com/brockallen/BrockAllen.MembershipReboot - Shiva

@Shiva 谢谢，我会查看该页面上的库和视频。但是如果可以避免的话，我宁愿不使用外部库。 - André Snede

请注意：安全领域的stackoverflow等价网站是http://security.stackexchange.com/。虽然您在这里通常可以得到好的/正确的答案，但专家们更多地在那里，尤其是针对“是否安全”的评论。我曾经问过类似的问题，那里的回答深入而且质量很高。 - phil soady

@philsoady 谢谢，当然很有道理。我已经在其他一些“子论坛”上了，如果我没有得到答案，我可以转到 securiry.stackexchange.com。感谢您的提示！ - André Snede

Answer 1

这里是默认实现的工作方式(ASP.NET Framework或ASP.NET Core)。它使用带有随机盐的密钥派生函数来生成哈希值。盐被包含在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);
}

- Andrew Savinykh

---

如果我理解正确的话，HashPassword函数会将盐值和哈希值一起返回在同一个字符串中？当你验证密码时，你再次将其拆分开来，使用拆分得到的盐值对输入的明文密码进行哈希运算，并将结果与原始哈希值进行比较？ - André Snede

@AndréSnedeHansen，没错。我也建议你在安全或密码学SE上提问。关于“是否安全”的部分可能会在这些相关上下文中得到更好的解答。 - Andrew Savinykh

@shajeerpuzhakkal如上面答案所述。 - Andrew Savinykh

我知道，这就是我问的原因-有什么意义呢？让代码看起来更聪明吗？;) 因为对我来说，使用十进制数字计数更加直观（毕竟我们有10个手指-至少大多数人都有），所以使用十六进制声明某些东西的数量似乎是不必要的代码混淆。 - Andrew Cyrul

@MihaiAlexandru-Ionut 你需要做的是 var hashedPassword = HashPassword(password); var result = VerifyHashedPassword(hashedPassword, password);。之后，result 将包含 true。 - Andrew Savinykh

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

- Knelis

---

是的，并值得注意的是，Zespri正在展示算法的添加部分。 - André Snede

GitHub上的源代码是Asp.Net.Identity 3.0，仍处于预发布阶段。2.0哈希函数的源代码位于CodePlex上。 - David

最新的实现现在可以在 https://github.com/dotnet/aspnetcore/blob/master/src/Identity/Extensions.Core/src/PasswordHasher.cs 找到。他们已经将其他存储库归档了 ;) - FranzHuber23

Answer 3

我理解了被接受的答案，并且已经点赞，但我想在这里放下我的通俗易懂的答案...

创建哈希值：

1. 使用函数 Rfc2898DeriveBytes 随机生成盐值，该函数生成一个哈希值和一个盐值。Rfc2898DeriveBytes 的输入是密码、要生成的盐值大小以及要执行的哈希迭代次数。 https://msdn.microsoft.com/zh-cn/library/h83s4e12(v=vs.110).aspx 2. 然后将盐值和哈希值混合在一起（先是盐值，然后是哈希值），并将其编码为字符串（所以盐值编码在哈希值中）。这个编码的哈希值（包含盐值和哈希值）通常会存储在数据库中，与用户相关联。

检查密码是否与哈希值匹配：

1. 从存储的哈希密码中提取盐值。

2. 使用重载的 Rfc2898DeriveBytes，它使用盐值而不是生成盐值，来对用户输入的密码进行哈希处理。 https://msdn.microsoft.com/zh-cn/library/yx129kfs(v=vs.110).aspx 3. 然后比较存储的哈希值和测试哈希值。

哈希值：

在内部，哈希是使用SHA1哈希函数生成的（https://en.wikipedia.org/wiki/SHA-1）。在默认的Identity实现中，该函数被迭代调用1000次。

为什么这是安全的

• 随机盐意味着攻击者不能使用预先生成的哈希表来尝试破解密码。他们需要为每个盐生成一个哈希表。（在此假设黑客也已经获取了您的盐）
• 如果两个密码相同，则它们将具有不同的哈希值。（这意味着攻击者无法推断出“常见”密码）
• 迭代调用SHA1 1000次意味着攻击者也需要这样做。其想法是，除非他们使用超级计算机，否则他们将没有足够的资源从哈希中暴力破解密码。这将大大减慢为给定盐生成哈希表的时间。

- Nattrass

---

谢谢您的解释。在“创建哈希 2。”中，您提到盐和哈希值被混合在一起，您知道这是否存储在AspNetUsers表中的PasswordHash中吗？盐存储在任何地方供我查看吗？ - unicorn2

@unicorn2 如果您查看Andrew Savinykh的答案...在哈希部分中，盐似乎存储在字节数组的前16个字节中，该数组进行Base64编码并写入数据库。您可以在PasswordHash表中看到此Base64编码字符串。您可以说关于Base64字符串的所有内容大约是其前三分之一是盐。有意义的盐是存储在PasswordHash表中完整字符串的Base64解码版本的前16个字节。 - Nattrass

@Nattrass，我对哈希和盐的理解还比较基础，但如果盐可以轻易地从哈希密码中提取出来，那么盐的作用是什么呢？我原以为盐是哈希算法的额外输入，不容易被猜测到的。 - NSouth

唯一的盐值使得对于给定密码的哈希是唯一的。因此，两个相同的密码会有不同的哈希值。即使攻击者拥有你的哈希值和盐值，也无法获得你的密码。哈希函数是不可逆的。他们仍然需要通过暴力破解每一个可能的密码。唯一的盐只是意味着如果攻击者成功获取了你整个用户表，他们不能通过对特定哈希值进行频率分析来推断常用密码。 - Nattrass

Answer 4

对于像我这样刚接触IT技术的人来说，以下是带有const关键字和比较byte[]实际方法的示例代码。我从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)
    {
        // https://dev59.com/CGIj5IYBdhLWcg3wuHXP

        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属性为包含上述代码的类的名称。

- kfrosty

---

对于这个.. _passwordHashBytes = bytes.GetBytes(SaltByteSize); 我猜你想说的是 _passwordHashBytes = bytes.GetBytes(HashByteSize);.. 在你的情况下没有关系，因为两者的大小相同，但一般情况下.. - Akshatha

Answer 5

我根据最新版本的.net6 PasswordHasher文档(V3)编写了我的PasswordHasher类。 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();
}

}

https://github.com/mammadkoma/WebApi/tree/master/WebApi

- M Komaei

Answer 6

在按照Andrew Savinykh的回答后，我做了以下更改。我正在使用已配置AspNet Identity的现有DB与Dapper。

请注意，如果您正在使用AspNet Identity，则PasswordHasherCompatibilityMode.IdentityV2非常适合使用。尚未针对AspNetCore Identity进行测试。

这是完整类的GitHub Gist。

- Sajeeb Chandan Saha