ASP.NET 成员资格使用的默认哈希算法是什么？

Question

ASP.NET 成员资格使用的默认哈希算法是什么？ 我该如何改变它？

Answer 1

编辑：不要按原样使用会员提供程序，因为它在保护用户密码方面严重不足，

因为谷歌搜索“会员提供商哈希算法” 将此答案作为第一个结果，并且将推断出福音，我有必要警告人们不要使用会员提供商，例如并使用 SHA-1、MD5 等哈希值来混淆数据库中的密码。

tl;dr

使用密钥派生函数，例如 bcrypt、scrypt 或（如果您需要 FIPS 合规性） ) PBKDF2 的工作因子足以使单个密码的哈希时间接近 1000 毫秒或更长。

如今，哈希很容易被暴力破解，最近历史上有大量数据泄露的例子。 为了防止您的用户密码在下一次黑客攻击中最终出现在 Pastebin 上，请确保使用需要足够长的时间来计算的函数对密码进行哈希处理！

而不是 Membership Provider，请尝试 IdentityReboot 或 特洛伊亨特至少谈到了微软的新实现。

同样有趣的是，在上面提到的相同谷歌结果中，我发现 教程向人们展示了使用 JtR 或 Hashcat 等流行工具来暴力破解这些密码哈希是多么容易。 在定制 GPU 装备上，SHA1 可以以每秒 48867 百万哈希值的惊人速度破解。 em>！ 拥有像 rockyou 之类的免费词典，一个积极主动的人，拥有您的数据库将很快获得您的大多数用户的密码。 作为开发人员，您有道德责任采取必要措施来保护用户密码的安全。

---

默认散列是 SHA1，但他们也加盐和对其进行 base64：

public string EncodePassword(string pass, string salt)
{
    byte[] bytes = Encoding.Unicode.GetBytes(pass);
    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);
}

如果您想了解更多有关如何更改它的信息，我仍然需要找出（除非使用自定义提供程序，请参见下文），但是 SHA-1 目前相当不错。 如果您想反转它或从中查找，这些人做了一些工作： http: //forums.asp.net/p/1336657/2899172.aspx

如果可能需要的话，这个问题将有助于逆转或复制此技术。 在 Ruby 中重新实现 ASP.NET 成员身份和用户密码哈希< /a>

如果您正在创建自定义提供程序，您可以创建您的散列和加密算法和方法。

private byte[] ConvertPasswordForStorage(string Password)
      {
         System.Text.UnicodeEncoding ue = 
      new System.Text.UnicodeEncoding();
         byte[] uePassword = ue.GetBytes(Password);
         byte[] RetVal = null;
         switch (_PasswordFormat)
         {
            case MembershipPasswordFormat.Clear:
               RetVal = uePassword;
               break;
            case MembershipPasswordFormat.Hashed:

               HMACSHA1 SHA1KeyedHasher = new HMACSHA1();
               SHA1KeyedHasher.Key = _ValidationKey;
               RetVal = SHA1KeyedHasher.ComputeHash(uePassword);
               break;
            case MembershipPasswordFormat.Encrypted:
               TripleDESCryptoServiceProvider tripleDes = new 
       TripleDESCryptoServiceProvider();
               tripleDes.Key = _DecryptionKey;
               tripleDes.IV = new byte[8];
               MemoryStream mStreamEnc = new MemoryStream();
               CryptoStream cryptoStream = new CryptoStream(mStreamEnc, 
        tripleDes.CreateEncryptor(), 
      CryptoStreamMode.Write);

               cryptoStream.Write(uePassword, 0, uePassword.Length);
               cryptoStream.FlushFinalBlock();
               RetVal = mStreamEnc.ToArray();
               cryptoStream.Close();
               break;

         }
         return RetVal;
      }

private string GetHumanReadablePassword(byte[] StoredPassword)
      {
         System.Text.UnicodeEncoding ue = new System.Text.UnicodeEncoding();
         string RetVal = null;
         switch (_PasswordFormat)
         {
            case MembershipPasswordFormat.Clear:
               RetVal = ue.GetString(StoredPassword);
               break;
            case MembershipPasswordFormat.Hashed:
               throw new ApplicationException(
        "Password cannot be recovered from a hashed format");

            case MembershipPasswordFormat.Encrypted:
               TripleDESCryptoServiceProvider tripleDes = 
        new TripleDESCryptoServiceProvider();
               tripleDes.Key = _DecryptionKey;
               tripleDes.IV = new byte[8];
               CryptoStream cryptoStream = 
        new CryptoStream(new MemoryStream(StoredPassword), 
      tripleDes.CreateDecryptor(), CryptoStreamMode.Read);
               MemoryStream msPasswordDec = new MemoryStream();
               int BytesRead = 0;
               byte[] Buffer = new byte[32];
               while ((BytesRead = cryptoStream.Read(Buffer, 0, 32)) > 0)
               {
                  msPasswordDec.Write(Buffer, 0, BytesRead);

               }
               cryptoStream.Close();

               RetVal = ue.GetString(msPasswordDec.ToArray());
               msPasswordDec.Close();
               break;
         }
         return RetVal;
      }

http://msdn.microsoft.com/en-us/library/aa479048.aspx

Answer 2

Ryan Christensen 的上述答案并不完整。 将盐转换为 byte[] 的部分不正确。

这是我在客户解决方案中实现的一个工作示例：

public string Hash(string value, string salt)
    {
        byte[] bytes = Encoding.Unicode.GetBytes(value);
        byte[] src = Convert.FromBase64String(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 3

默认哈希算法类型是 SHA1。 有两种方法可以改变这种情况。

1) 如果您使用的是 IIS 7，您可以使用“机器密钥”配置进行更新（如下所示）。 这允许您从可用选项列表中选择加密方法并指定密钥或密钥生成选项。

2) 如果您使用的是 IIS 6，您可以使用以下命令更改哈希算法类型web.config 文件中的成员资格元素：

<membership
    defaultProvider="provider name"
    userIsOnlineTimeWindow="number of minutes"
    hashAlgorithmType="SHA1">
    <providers>...</providers>
</membership>

根据文档 hashAlgorithmType 属性可以是任何提供的 .Net 哈希算法类型。 经过一番挖掘，发现 ASP.Net 2、3 和 3.5 的有效值为 MD5、RIPEMD160、SHA1、SHA256 、SHA384、SHA512。 这里重要的部分是所有这些类都继承自 HashAlgorithm。

hashAlgorithmType 属性的值也可以是machine.config 文件中 cryptoNameMapping 元素中的条目。 如果您需要第三方哈希算法，您可以使用它。 如果您使用的是 ASP.Net 2 或更高版本，则 machine.config 文件通常可以在 C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\CONFIG 中找到。 您可以在此处了解有关设置这些值的更多信息。

Answer 4

.NET 4.0 Framework 中的默认哈希算法更改为 HMACSHA256。

请注意，与 SHA-1 不同，HMAC SHA-256 是密钥哈希。 如果您的散列行为具有不确定性，则您可能没有设置密钥，从而强制它使用随机密钥。 类似于以下内容的内容将是罪魁祸首（这是我刚刚花了一个小时弄清楚的：p）。

HashAlgorithm.Create(Membership.HashAlgorithmType)

如果您希望让它与现有的提供程序一起使用，您可以使用 本指南。

Answer 5

哈希算法有一个更正，您必须使用：

byte[] src = Convert.FromBase64String(salt);

而不是

byte[] src = Encoding.Unicode.GetBytes(salt);

阅读文章 http://svakodnevnica.com.ba/index.php?option=com_kunena&func=view&catid=4&id=4&Itemid=5& ;lang=en#6

Answer 6

让我们讨论这个问题的安全且经过时间考验的答案：

1. Zetetic 只需两行代码即可完成！ 哈希算法 PBKDF2 比 SHA1 或 SHA256-SHA512 等要好得多PBKDF2、SCRYPT 或 ARGON2 等最新算法在哈希方面处于领先地位。 但在这种情况下使用 PBKDF2 很有用，因为它是由 .NET 在 Rfc2898DeriveBytes 类中实现的。 到目前为止，使用这个库非常棒，但有一些小问题，例如：

   a. Zetetic 默认使用 5000 次迭代。 如果您使用 Pbkdf2Hash256K

   ，则可自定义

   b. Zetetic 使用 Rfc2898DeriveBytes 和 Rfc2898DeriveBytes 由于某种原因基于 HMACSHA1，无法自定义。

2. 好消息！ 我已自定义 Rfc2898DeriveBytes 以使用 HMACSHA512 进行 128,000 次迭代，以便 SQLMembershipProvider 可以使用迄今为止尚不可用的 PBKDF2。 为了实现这一目标，我将 Zetetic 代码与我的 Rfc2898DeriveBytes 如下图：

using System.Security.Cryptography;

namespace custom.hashing.keyderivation
{
/// <summary>
/// This derived class of PBKDF2Hash provided necessary capabilities to SQLMembershipProvider in order to hash passwords in PBKDF2 way with 128,000 iterations.
/// </summary>
public class PBKDF2Hash : KeyedHashAlgorithm
{
    private const int kHashBytes = 64;

    private System.IO.MemoryStream _ms;

    public int WorkFactor { get; set; }

    public PBKDF2Hash()
        : base()
    {
        this.WorkFactor = 128000;
        this.Key = new byte[32]; // 32 Bytes will give us 256 bits.
        using (var rngCsp = new RNGCryptoServiceProvider())
        {
            // Fill the array with cryptographically secure random bytes.
            rngCsp.GetBytes(this.Key);
        }
    }

    /// <summary>
    /// Hash size in bits
    /// </summary>
    public override int HashSize
    {
        get
        {
            return kHashBytes * 8;
        }
    }

    protected override void HashCore(byte[] array, int ibStart, int cbSize)
    {
        (_ms = _ms ?? new System.IO.MemoryStream()).Write(array, ibStart, cbSize);
    }

    protected override byte[] HashFinal()
    {
        if (this.Key == null || this.Key.Length == 0)
        {
            throw new CryptographicException("Missing KeyedAlgorithm key");
        }

        _ms.Flush();

        var arr = _ms.ToArray();

        _ms = null;

        using (var hmac = new HMACSHA512())
        {
            return new MyRfc2898DeriveBytes(arr, this.Key, this.WorkFactor, hmac).GetBytes(kHashBytes);
        }
    }

    public override void Initialize()
    {
        _ms = null;
    }
}

// ==++==
// 
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// ==--==
// <OWNER>Microsoft</OWNER>
// 

//
// Rfc2898DeriveBytes.cs
//

// This implementation follows RFC 2898 recommendations. See http://www.ietf.org/rfc/Rfc2898.txt
/// <summary>
/// Microsoft has implemented PBKDF2 but with HMACSHA1. We are customizing this class to use HMACSHA512 in hashing process.
/// </summary>
public class MyRfc2898DeriveBytes : DeriveBytes
{
    private byte[] m_buffer;
    private byte[] m_salt;
    private HMAC m_hmac;  // The pseudo-random generator function used in PBKDF2

    private uint m_iterations;
    private uint m_block;
    private int m_startIndex;
    private int m_endIndex;

    private int m_blockSize;

    //
    // public constructors
    //

    // This method needs to be safe critical, because in debug builds the C# compiler will include null
    // initialization of the _safeProvHandle field in the method.  Since SafeProvHandle is critical, a
    // transparent reference triggers an error using PasswordDeriveBytes.
    [SecuritySafeCritical]
    public MyRfc2898DeriveBytes(byte[] password, byte[] salt, int iterations, HMAC hmac)
    {
        Salt = salt;
        IterationCount = iterations;
        hmac.Key = password;
        m_hmac = hmac;
        // m_blockSize is in bytes, HashSize is in bits. 
        m_blockSize = hmac.HashSize >> 3;

        Initialize();
    }

    //
    // public properties
    //

    public int IterationCount
    {
        get { return (int)m_iterations; }
        set
        {
            if (value <= 0)
                throw new ArgumentOutOfRangeException("value", "Error: Iteration count is zero or less");

            m_iterations = (uint)value;
            Initialize();
        }
    }

    public byte[] Salt
    {
        get { return (byte[])m_salt.Clone(); }
        set
        {
            if (value == null)
                throw new ArgumentNullException("value");
            if (value.Length < 8)
                throw new ArgumentException("Error: Salt size is less than 8");

            m_salt = (byte[])value.Clone();
            Initialize();
        }
    }

    //
    // public methods
    //

    public override byte[] GetBytes(int cb)
    {
        if (cb <= 0)
        {    throw new ArgumentOutOfRangeException("cb", "Error: Hash size is zero or less"); }

        Contract.Assert(m_blockSize > 0);

        byte[] password = new byte[cb];

        int offset = 0;
        int size = m_endIndex - m_startIndex;
        if (size > 0)
        {
            if (cb >= size)
            {
                Buffer.BlockCopy(m_buffer, m_startIndex, password, 0, size);
                m_startIndex = m_endIndex = 0;
                offset += size;
            }
            else
            {
                Buffer.BlockCopy(m_buffer, m_startIndex, password, 0, cb);
                m_startIndex += cb;
                return password;
            }
        }

        Contract.Assert(m_startIndex == 0 && m_endIndex == 0, "Invalid start or end index in the internal buffer.");

        while (offset < cb)
        {
            byte[] T_block = Func();
            int remainder = cb - offset;
            if (remainder > m_blockSize)
            {
                Buffer.BlockCopy(T_block, 0, password, offset, m_blockSize);
                offset += m_blockSize;
            }
            else
            {
                Buffer.BlockCopy(T_block, 0, password, offset, remainder);
                offset += remainder;
                Buffer.BlockCopy(T_block, remainder, m_buffer, m_startIndex, m_blockSize - remainder);
                m_endIndex += (m_blockSize - remainder);
                return password;
            }
        }
        return password;
    }

    public override void Reset()
    {
        Initialize();
    }

    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);

        if (disposing)
        {
            if (m_hmac != null)
            {
                ((IDisposable)m_hmac).Dispose();
            }

            if (m_buffer != null)
            {
                Array.Clear(m_buffer, 0, m_buffer.Length);
            }
            if (m_salt != null)
            {
                Array.Clear(m_salt, 0, m_salt.Length);
            }
        }
    }

    private void Initialize()
    {
        if (m_buffer != null)
            Array.Clear(m_buffer, 0, m_buffer.Length);
        m_buffer = new byte[m_blockSize];
        m_block = 1;
        m_startIndex = m_endIndex = 0;
    }

    internal static byte[] GetBytesFromInt(uint i)
    {
        return unchecked(new byte[] { (byte)(i >> 24), (byte)(i >> 16), (byte)(i >> 8), (byte)i });
    }

    // This function is defined as follow :
    // Func (S, i) = HMAC(S || i) | HMAC2(S || i) | ... | HMAC(iterations) (S || i) 
    // where i is the block number.
    private byte[] Func()
    {
        byte[] INT_block = GetBytesFromInt(m_block);

        m_hmac.TransformBlock(m_salt, 0, m_salt.Length, null, 0);
        m_hmac.TransformBlock(INT_block, 0, INT_block.Length, null, 0);
        m_hmac.TransformFinalBlock(new byte[0], 0, 0);
        byte[] temp = m_hmac.Hash;
        m_hmac.Initialize();

        byte[] ret = temp;
        for (int i = 2; i <= m_iterations; i++)
        {
            m_hmac.TransformBlock(temp, 0, temp.Length, null, 0);
            m_hmac.TransformFinalBlock(new byte[0], 0, 0);
            temp = m_hmac.Hash;
            for (int j = 0; j < m_blockSize; j++)
            {
                ret[j] ^= temp[j];
            }
            m_hmac.Initialize();
        }

        // increment the block count.
        if (m_block == uint.MaxValue)
        { throw new InvalidOperationException("Derived key too long."); }

        m_block++;
        return ret;
    }
}

创建此类后，执行

• 以下操作：

  将以下行添加到 Global.asax 或项目的相应启动文件的 Application_Start 事件中：

  System.Security.Cryptography.CryptoConfig.AddAlgorithm(typeof(custom.hashing.keyderivation.PBKDF2Hash), "PBKDF2Hash_HB");

• 并将 web.config 更改为：

构建此答案的参考资料取自：

• Zetetic 的 github 代码
• EVK 的答案
• Microsoft 参考代码

Answer 7

我附加了一个片段，显示了上面在 F# 中 Rawbert 的答案中的代码，

open System
open System.Security.Cryptography
open System.Text

module PasswordHelper =
    let EncodePassword(pass : string, salt : string) =
        let bytes = Encoding.Unicode.GetBytes(pass)
        let src = Convert.FromBase64String(salt)
        let dst : byte array = Array.zeroCreate (src.Length + bytes.Length)
        Buffer.BlockCopy(src, 0, dst, 0, src.Length)
        Buffer.BlockCopy(bytes, 0, dst, src.Length, bytes.Length)
        let algorithm = HashAlgorithm.Create("SHA1")
        let inArray = algorithm.ComputeHash(dst)
        Convert.ToBase64String(inArray)

这是来自活动应用程序的工作代码