如何对密码进行哈希处理

Question

我想在手机上存储密码的哈希值，但我不知道该怎么做。我似乎只能找到加密方法。应该如何正确地对密码进行哈希处理？

Answer 1

考虑到今天（2012 年）的最佳实践，这里的大多数其他答案都有些过时了。

.NET 中原生可用的最强大的密码哈希算法是 PBKDF2，由 Rfc2898DeriveBytes 类表示。
以下代码位于本文的独立类中： 如何存储加盐密码哈希的另一个示例。基础知识非常简单，因此这里进行了细分：

步骤 1 使用加密 PRNG 创建盐值：

byte[] salt;
new RNGCryptoServiceProvider().GetBytes(salt = new byte[16]);

步骤 2 创建 Rfc2898DeriveBytes 并获取哈希值：

var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 100000);
byte[] hash = pbkdf2.GetBytes(20);

< strong>STEP 3 将盐和密码字节组合起来供以后使用：

byte[] hashBytes = new byte[36];
Array.Copy(salt, 0, hashBytes, 0, 16);
Array.Copy(hash, 0, hashBytes, 16, 20);

STEP 4 将组合的 salt+hash 转换为字符串进行存储

string savedPasswordHash = Convert.ToBase64String(hashBytes);
DBContext.AddUser(new User { ..., Password = savedPasswordHash });

STEP 5 验证用户- 根据存储的密码输入密码

/* Fetch the stored value */
string savedPasswordHash = DBContext.GetUser(u => u.UserName == user).Password;
/* Extract the bytes */
byte[] hashBytes = Convert.FromBase64String(savedPasswordHash);
/* Get the salt */
byte[] salt = new byte[16];
Array.Copy(hashBytes, 0, salt, 0, 16);
/* Compute the hash on the password the user entered */
var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 100000);
byte[] hash = pbkdf2.GetBytes(20);
/* Compare the results */
for (int i=0; i < 20; i++)
    if (hashBytes[i+16] != hash[i])
        throw new UnauthorizedAccessException();

注意：根据特定应用程序的性能要求，可以减小值 100000。最小值应约为 10000。

Answer 2

基于 csharptest.net 的出色答案，我为此编写了一个类：

public static class SecurePasswordHasher
{
    /// <summary>
    /// Size of salt.
    /// </summary>
    private const int SaltSize = 16;

    /// <summary>
    /// Size of hash.
    /// </summary>
    private const int HashSize = 20;

    /// <summary>
    /// Creates a hash from a password.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="iterations">Number of iterations.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password, int iterations)
    {
        // Create salt
        byte[] salt;
        new RNGCryptoServiceProvider().GetBytes(salt = new byte[SaltSize]);

        // Create hash
        var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations);
        var hash = pbkdf2.GetBytes(HashSize);

        // Combine salt and hash
        var hashBytes = new byte[SaltSize + HashSize];
        Array.Copy(salt, 0, hashBytes, 0, SaltSize);
        Array.Copy(hash, 0, hashBytes, SaltSize, HashSize);

        // Convert to base64
        var base64Hash = Convert.ToBase64String(hashBytes);

        // Format hash with extra information
        return string.Format("$MYHASH$V1${0}${1}", iterations, base64Hash);
    }

    /// <summary>
    /// Creates a hash from a password with 10000 iterations
    /// </summary>
    /// <param name="password">The password.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password)
    {
        return Hash(password, 10000);
    }

    /// <summary>
    /// Checks if hash is supported.
    /// </summary>
    /// <param name="hashString">The hash.</param>
    /// <returns>Is supported?</returns>
    public static bool IsHashSupported(string hashString)
    {
        return hashString.Contains("$MYHASH$V1$");
    }

    /// <summary>
    /// Verifies a password against a hash.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="hashedPassword">The hash.</param>
    /// <returns>Could be verified?</returns>
    public static bool Verify(string password, string hashedPassword)
    {
        // Check hash
        if (!IsHashSupported(hashedPassword))
        {
            throw new NotSupportedException("The hashtype is not supported");
        }

        // Extract iteration and Base64 string
        var splittedHashString = hashedPassword.Replace("$MYHASH$V1$", "").Split('
用法：
// Hash
var hash = SecurePasswordHasher.Hash("mypassword");

// Verify
var result = SecurePasswordHasher.Verify("mypassword", hash);

示例哈希可能是这样的
$MYHASH$V1$10000$Qhxzi6GNu/Lpy3iUqkeqR/J1hh8y/h5KPDjrv89KzfCVrubn

：您可以看到，我还在哈希中包含了迭代，以便于使用，并且如果我们需要升级，也可以升级它。

如果您对 .net core 感兴趣，我在 代码审查。
);
        var iterations = int.Parse(splittedHashString[0]);
        var base64Hash = splittedHashString[1];

        // Get hash bytes
        var hashBytes = Convert.FromBase64String(base64Hash);

        // Get salt
        var salt = new byte[SaltSize];
        Array.Copy(hashBytes, 0, salt, 0, SaltSize);

        // Create hash with given salt
        var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations);
        byte[] hash = pbkdf2.GetBytes(HashSize);

        // Get result
        for (var i = 0; i < HashSize; i++)
        {
            if (hashBytes[i + SaltSize] != hash[i])
            {
                return false;
            }
        }
        return true;
    }
}

用法：

示例哈希可能是这样的

：您可以看到，我还在哈希中包含了迭代，以便于使用，并且如果我们需要升级，也可以升级它。

---

如果您对 .net core 感兴趣，我在 代码审查。

Answer 3

更新：这个答案已经严重过时了。请使用 https://stackoverflow.com/a/10402129 或 https://stackoverflow.com/a/73125177。

您可以使用

var md5 = new MD5CryptoServiceProvider();
var md5data = md5.ComputeHash(data);

或

var sha1 = new SHA1CryptoServiceProvider();
var sha1data = sha1.ComputeHash(data);

要获取 data 作为字节数组，您可以使用

var data = Encoding.ASCII.GetBytes(password);

并从 md5data 或 sha1data 获取字符串

var hashedPassword = ASCIIEncoding.GetString(md5data);

Answer 4

2022 (.NET 6+) 解决方案：

这里的大多数其他答案都是几年前写的，因此没有利用新版本 .NET 中引入的许多最新功能。现在可以更简单地实现同样的事情，并且样板文件和噪音也少得多。我提出的解决方案还提供了额外的稳健性，允许您将来修改设置（例如迭代计数等），而无需实际破坏旧的哈希值（如果您使用 接受答案提出的解决方案）。

优点：

• 使用新的静态 Rfc2898DeriveBytes.Pbkdf2() 方法，无需每次实例化和处置对象。

• 使用新的< code>RandomNumberGenerator 类及其静态 GetBytes 方法（在 .NET 6 中引入）用于生成盐。接受的答案中使用的 RNGCryptoServiceProvider 类 已过时。

• 使用CryptographicOperations.FixedTimeEquals 方法（在 .NET Core 2.1 中引入）用于比较 Verify 方法中的关键字节，而不是像已接受的答案那样手动进行比较。除了消除大量嘈杂的样板之外，这还可以消除定时攻击。

• 使用 SHA-256 而不是默认的 SHA-1 作为底层算法，只是为了安全起见，因为后者是一种更强大、更可靠的算法。

• Hash 方法返回的字符串具有以下结构：

  [键]:[盐]:[迭代]:[算法]

  这是该解决方案最重要的优点，这意味着我们基本上包含有关用于在最终字符串中创建哈希的配置的元数据。这允许我们将来更改哈希器类中的设置（例如迭代次数、salt/key 大小等），而不会破坏使用旧设置创建的先前哈希值。这是可接受的例如，答案不考虑在内，因为它依赖“当前”配置值来验证哈希值。

其他要点：

• 我在返回的哈希字符串中使用密钥和盐的十六进制表示形式。如果您愿意，也可以使用 base64，只需将每次出现的 Convert.ToHexString 和 Convert.FromHexString 更改为 Convert.ToBase64 和 Convert.FromBase64 分别。其余逻辑保持完全相同。
• 通常推荐的盐大小为 64 位或更高。我把它设置为128位。
• 密钥大小通常应与所选算法的自然输出大小相同 - 请参阅 此评论。在我们的例子中，正如我之前提到的，底层算法是 SHA-256，其输出大小为 256 位，这正是我们设置密钥大小的值。
• 如果您计划使用它来存储用户密码，通常建议使用至少 10,000 次迭代或更多。我已将默认值设置为 50,000，您当然可以根据需要进行更改。

代码：

public static class SecretHasher
{
    private const int _saltSize = 16; // 128 bits
    private const int _keySize = 32; // 256 bits
    private const int _iterations = 50000;
    private static readonly HashAlgorithmName _algorithm = HashAlgorithmName.SHA256;

    private const char segmentDelimiter = ':';

    public static string Hash(string input)
    {
        byte[] salt = RandomNumberGenerator.GetBytes(_saltSize);
        byte[] hash = Rfc2898DeriveBytes.Pbkdf2(
            input,
            salt,
            _iterations,
            _algorithm,
            _keySize
        );
        return string.Join(
            segmentDelimiter,
            Convert.ToHexString(hash),
            Convert.ToHexString(salt),
            _iterations,
            _algorithm
        );
    }

    public static bool Verify(string input, string hashString)
    {
        string[] segments = hashString.Split(segmentDelimiter);
        byte[] hash = Convert.FromHexString(segments[0]);
        byte[] salt = Convert.FromHexString(segments[1]);
        int iterations = int.Parse(segments[2]);
        HashAlgorithmName algorithm = new HashAlgorithmName(segments[3]);
        byte[] inputHash = Rfc2898DeriveBytes.Pbkdf2(
            input,
            salt,
            iterations,
            algorithm,
            hash.Length
        );
        return CryptographicOperations.FixedTimeEquals(inputHash, hash);
    }
}

用法：

// Hash:
string password = "...";
string hashed = SecretHasher.Hash(password);

// Verify:
string enteredPassword = "...";
bool isPasswordCorrect = SecretHasher.Verify(enteredPassword, hashed);

Answer 5

@csharptest.net 和 Christian Gollhardt 的回答非常好，非常感谢。但是在生产环境中运行此代码并包含数百万条记录后，我发现存在内存泄漏。 RNGCryptoServiceProvider 和 Rfc2898DeriveBytes 类派生自 IDisposable，但我们不会处置它们。如果有人需要处置版本，我将写下我的解决方案作为答案。

public static class SecurePasswordHasher
{
    /// <summary>
    /// Size of salt.
    /// </summary>
    private const int SaltSize = 16;

    /// <summary>
    /// Size of hash.
    /// </summary>
    private const int HashSize = 20;

    /// <summary>
    /// Creates a hash from a password.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="iterations">Number of iterations.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password, int iterations)
    {
        // Create salt
        using (var rng = new RNGCryptoServiceProvider())
        {
            byte[] salt;
            rng.GetBytes(salt = new byte[SaltSize]);
            using (var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations))
            {
                var hash = pbkdf2.GetBytes(HashSize);
                // Combine salt and hash
                var hashBytes = new byte[SaltSize + HashSize];
                Array.Copy(salt, 0, hashBytes, 0, SaltSize);
                Array.Copy(hash, 0, hashBytes, SaltSize, HashSize);
                // Convert to base64
                var base64Hash = Convert.ToBase64String(hashBytes);

                // Format hash with extra information
                return $"$HASH|V1${iterations}${base64Hash}";
            }
        }

    }

    /// <summary>
    /// Creates a hash from a password with 10000 iterations
    /// </summary>
    /// <param name="password">The password.</param>
    /// <returns>The hash.</returns>
    public static string Hash(string password)
    {
        return Hash(password, 10000);
    }

    /// <summary>
    /// Checks if hash is supported.
    /// </summary>
    /// <param name="hashString">The hash.</param>
    /// <returns>Is supported?</returns>
    public static bool IsHashSupported(string hashString)
    {
        return hashString.Contains("HASH|V1$");
    }

    /// <summary>
    /// Verifies a password against a hash.
    /// </summary>
    /// <param name="password">The password.</param>
    /// <param name="hashedPassword">The hash.</param>
    /// <returns>Could be verified?</returns>
    public static bool Verify(string password, string hashedPassword)
    {
        // Check hash
        if (!IsHashSupported(hashedPassword))
        {
            throw new NotSupportedException("The hashtype is not supported");
        }

        // Extract iteration and Base64 string
        var splittedHashString = hashedPassword.Replace("$HASH|V1$", "").Split('
用法：
// Hash
var hash = SecurePasswordHasher.Hash("mypassword");

// Verify
var result = SecurePasswordHasher.Verify("mypassword", hash);

);
        var iterations = int.Parse(splittedHashString[0]);
        var base64Hash = splittedHashString[1];

        // Get hash bytes
        var hashBytes = Convert.FromBase64String(base64Hash);

        // Get salt
        var salt = new byte[SaltSize];
        Array.Copy(hashBytes, 0, salt, 0, SaltSize);

        // Create hash with given salt
        using (var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations))
        {
            byte[] hash = pbkdf2.GetBytes(HashSize);

            // Get result
            for (var i = 0; i < HashSize; i++)
            {
                if (hashBytes[i + SaltSize] != hash[i])
                {
                    return false;
                }
            }

            return true;
        }

    }
}

用法：

Answer 6

在 ASP.NET Core 中，使用 PasswordHasher< ;TUser>.
<子>
 • 命名空间：Microsoft.AspNetCore.Identity
 • 程序集：Microsoft.Extensions.Identity.Core.dll（NuGet |

---

要对密码进行哈希处理，请使用 HashPassword()：

var hashedPassword = new PasswordHasher<object?>().HashPassword(null, password);

要验证密码，请使用 VerifyHashedPassword()：

var passwordVerificationResult = new PasswordHasher<object?>().VerifyHashedPassword(null, hashedPassword, password);
switch (passwordVerificationResult)
{
    case PasswordVerificationResult.Failed:
        Console.WriteLine("Password incorrect.");
        break;
    
    case PasswordVerificationResult.Success:
        Console.WriteLine("Password ok.");
        break;
    
    case PasswordVerificationResult.SuccessRehashNeeded:
        Console.WriteLine("Password ok but should be rehashed and updated.");
        break;
    
    default:
        throw new ArgumentOutOfRangeException();
}

---

优点：

• .NET 平台的一部分。比构建自己的加密算法更安全、更值得信赖。
• 可配置的迭代计数和未来兼容性（请参阅 PasswordHasherOptions< /代码>）。
• 验证密码时考虑了计时攻击 (源），就像PHP 和 Go 做到了。

缺点：

• 哈希密码格式 与其他库或其他语言的哈希值不兼容。

Answer 7

我使用哈希值和盐值进行密码加密（与 Asp.Net Membership 使用的哈希值相同）：

private string PasswordSalt
{
   get
   {
      var rng = new RNGCryptoServiceProvider();
      var buff = new byte[32];
      rng.GetBytes(buff);
      return Convert.ToBase64String(buff);
   }
}

private string EncodePassword(string password, string salt)
{
   byte[] bytes = Encoding.Unicode.GetBytes(password);
   byte[] src = Encoding.Unicode.GetBytes(salt);
   byte[] dst = new byte[src.Length + bytes.Length];
   Buffer.BlockCopy(src, 0, dst, 0, src.Length);
   Buffer.BlockCopy(bytes, 0, dst, src.Length, bytes.Length);
   HashAlgorithm algorithm = HashAlgorithm.Create("SHA1");
   byte[] inarray = algorithm.ComputeHash(dst);
   return Convert.ToBase64String(inarray);
}

Answer 8

1. 创建盐，
2. 用盐创建哈​​希密码
3. 保存哈希和盐
4. 用密码和盐解密...这样开发人员就无法解密密码

public class CryptographyProcessor
{
    public string CreateSalt(int size)
    {
        //Generate a cryptographic random number.
          RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
         byte[] buff = new byte[size];
         rng.GetBytes(buff);
         return Convert.ToBase64String(buff);
    }


      public string GenerateHash(string input, string salt)
      { 
         byte[] bytes = Encoding.UTF8.GetBytes(input + salt);
         SHA256Managed sHA256ManagedString = new SHA256Managed();
         byte[] hash = sHA256ManagedString.ComputeHash(bytes);
         return Convert.ToBase64String(hash);
      }

      public bool AreEqual(string plainTextInput, string hashedInput, string salt)
      {
           string newHashedPin = GenerateHash(plainTextInput, salt);
           return newHashedPin.Equals(hashedInput); 
      }
 }

Answer 9

我认为使用 KeyDerivation.Pbkdf2 比 Rfc2898DeriveBytes 更好。

示例及解释：
ASP.NET Core 中的哈希密码

using System;
using System.Security.Cryptography;
using Microsoft.AspNetCore.Cryptography.KeyDerivation;
 
public class Program
{
    public static void Main(string[] args)
    {
        Console.Write("Enter a password: ");
        string password = Console.ReadLine();
 
        // generate a 128-bit salt using a secure PRNG
        byte[] salt = new byte[128 / 8];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(salt);
        }
        Console.WriteLine($"Salt: {Convert.ToBase64String(salt)}");
 
        // derive a 256-bit subkey (use HMACSHA1 with 10,000 iterations)
        string hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(
            password: password,
            salt: salt,
            prf: KeyDerivationPrf.HMACSHA1,
            iterationCount: 10000,
            numBytesRequested: 256 / 8));
        Console.WriteLine($"Hashed: {hashed}");
    }
}
 
/*
 * SAMPLE OUTPUT
 *
 * Enter a password: Xtw9NMgx
 * Salt: NZsP6NnmfBuYeJrrAKNuVQ==
 * Hashed: /OOoOer10+tGwTRDTrQSoeCxVTFr6dtYly7d0cPxIak=
 */

这是本文中的示例代码。这是最低的安全级别。
要增加它，我将使用 KeyDerivationPrf.HMACSHA1 参数代替

KeyDerivationPrf.HMACSHA256 或 KeyDerivationPrf.HMACSHA512。

不要在密码哈希方面妥协。有许多数学上合理的方法可以优化密码哈希黑客攻击。后果可能是灾难性的。
一旦犯罪分子能够获得您用户的密码哈希表，这将是相对的
如果算法较弱或实现不正确，他很容易破解密码。
他有很多时间（时间x计算机能力）来破解密码。密码散列应该具有很强的加密强度，才能“花很多时间”
“不合理的时间”。

还有一点，添加

哈希验证需要时间（而且这是好事）。
当用户输入错误的用户名时，不需要时间来检查用户名是否正确。
当用户名正确时，我们开始密码验证 - 这是一个相对较长的过程。

对于黑客来说，很容易了解用户是否存在。

当用户名错误时，请确保不要立即返回答案。

不用说：永远不要回答哪里出了问题。只是一般“凭据错误”。

Answer 10

首先使用下面的类生成盐。每个用户都需要有不同的盐，我们可以将其与其他用户属性一起保存在数据库中。 rounds 值决定密码被哈希的次数。

有关更多详细信息： https://learn.microsoft.com/en-us/dotnet/api/system.security.cryptography.rfc2898derivebytes.-ctor?view=netcore-3.1#System_Security_Cryptography_Rfc2898DeriveBytes__ctor_System_Byte___System_Byte___System_Int32_

public class HashSaltWithRounds
{
    int saltLength = 32;
    public byte[] GenerateSalt()
    {
        using (var randomNumberGenerator = new RNGCryptoServiceProvider())
        {
            var randomNumber = new byte[saltLength];
            randomNumberGenerator.GetBytes(randomNumber);
            return randomNumber;
        }
    }

    public string HashDataWithRounds(byte[] password, byte[] salt, int rounds)
    {
        using(var rfc2898= new Rfc2898DeriveBytes(password, salt, rounds))
        {
            return Convert.ToBase64String(rfc2898.GetBytes(32));
        }
    }
}

我们可以从控制台应用程序如下。我使用相同的盐对密码进行了两次哈希处理。

public class Program
{
    public static void Main(string[] args)
    {
        int numberOfIterations = 99;
        var hashFunction = new HashSaltWithRounds();

        string password = "Your Password Here";
        byte[] salt = hashFunction.GenerateSalt();

        var hashedPassword1 = hashFunction.HashDataWithRounds(Encoding.UTF8.GetBytes(password), salt, numberOfIterations);
        var hashedPassword2 = hashFunction.HashDataWithRounds(Encoding.UTF8.GetBytes(password), salt, numberOfIterations);

        Console.WriteLine($"hashedPassword1 :{hashedPassword1}");
        Console.WriteLine($"hashedPassword2 :{hashedPassword2}");
        Console.WriteLine(hashedPassword1.Equals(hashedPassword2));

        Console.ReadLine();

    }
}

Answer 11

  var sha1 = SHA1.Create();      

  byte[] bytes = Encoding.UTF8.GetBytes("Your String Data");

  byte[] hash = sha1.ComputeHash(bytes);


    var sBuilder = new StringBuilder();

    for (int i = 0; i < hash.Length; i++)
    {
        sBuilder.Append(hash[i].ToString("X"));
    }

    Console.WriteLine(sBuilder.ToString());  //Hash value in Hex

Answer 12

这是使用 .NET 7.0 的示例

using Microsoft.AspNetCore.Cryptography.KeyDerivation;
using System.Security.Cryptography;

Console.Write("Enter a password: ");
string? password = Console.ReadLine();

// Generate a 128-bit salt using a sequence of
// cryptographically strong random bytes.
byte[] salt = RandomNumberGenerator.GetBytes(128 / 8); // divide by 8 to convert bits to bytes
Console.WriteLine($"Salt: {Convert.ToBase64String(salt)}");

// derive a 256-bit subkey (use HMACSHA256 with 100,000 iterations)
string hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(
    password: password!,
    salt: salt,
    prf: KeyDerivationPrf.HMACSHA256,
    iterationCount: 100000,
    numBytesRequested: 256 / 8));

Console.WriteLine($"Hashed: {hashed}");

/*
 * SAMPLE OUTPUT
 *
 * Enter a password: Xtw9NMgx
 * Salt: CGYzqeN4plZekNC88Umm1Q==
 * Hashed: Gt9Yc4AiIvmsC1QQbe2RZsCIqvoYlst2xbz0Fs8aHnw=
 */