2

我最近阅读了一篇关于使用“salt”安全地散列用户密码的有趣文章。（这是原始文章，不幸的是，在发这篇文章时它似乎已经关闭，所以这里是缓存版本。）

我完全同意这个概念，除了我似乎无法找到一种将用户登录信息安全地存储在本地 cookie（或会话）中的方法，因为 salt + PBKDF2 哈希组合每次都是随机完成的。为了更好地理解我的意思，让我复制文章中的 C# 代码：

using System;
using System.Text;
using System.Security.Cryptography;

namespace PasswordHash
{
    /// <summary>
    /// Salted password hashing with PBKDF2-SHA1.
    /// Author: havoc AT defuse.ca
    /// www: http://crackstation.net/hashing-security.htm
    /// Compatibility: .NET 3.0 and later.
    /// </summary>
    class PasswordHash
    {
        // The following constants may be changed without breaking existing hashes.
        public const int SALT_BYTES = 24;
        public const int HASH_BYTES = 24;
        public const int PBKDF2_ITERATIONS = 1000;

        public const int ITERATION_INDEX = 0;
        public const int SALT_INDEX = 1;
        public const int PBKDF2_INDEX = 2;

        /// <summary>
        /// Creates a salted PBKDF2 hash of the password.
        /// </summary>
        /// <param name="password">The password to hash.</param>
        /// <returns>The hash of the password.</returns>
        public static string CreateHash(string password)
        {
            // Generate a random salt
            RNGCryptoServiceProvider csprng = new RNGCryptoServiceProvider();
            byte[] salt = new byte[SALT_BYTES];
            csprng.GetBytes(salt);

            // Hash the password and encode the parameters
            byte[] hash = PBKDF2(password, salt, PBKDF2_ITERATIONS, HASH_BYTES);
            return PBKDF2_ITERATIONS + ":" +
                Convert.ToBase64String(salt) + ":" +
                Convert.ToBase64String(hash);
        }

        /// <summary>
        /// Validates a password given a hash of the correct one.
        /// </summary>
        /// <param name="password">The password to check.</param>
        /// <param name="goodHash">A hash of the correct password.</param>
        /// <returns>True if the password is correct. False otherwise.</returns>
        public static bool ValidatePassword(string password, string goodHash)
        {
            // Extract the parameters from the hash
            char[] delimiter = { ':' };
            string[] split = goodHash.Split(delimiter);
            int iterations = Int32.Parse(split[ITERATION_INDEX]);
            byte[] salt = Convert.FromBase64String(split[SALT_INDEX]);
            byte[] hash = Convert.FromBase64String(split[PBKDF2_INDEX]);

            byte[] testHash = PBKDF2(password, salt, iterations, hash.Length);
            return SlowEquals(hash, testHash);
        }

        /// <summary>
        /// Compares two byte arrays in length-constant time. This comparison
        /// method is used so that password hashes cannot be extracted from
        /// on-line systems using a timing attack and then attacked off-line.
        /// </summary>
        /// <param name="a">The first byte array.</param>
        /// <param name="b">The second byte array.</param>
        /// <returns>True if both byte arrays are equal. False otherwise.</returns>
        private static bool SlowEquals(byte[] a, byte[] b)
        {
            uint diff = (uint)a.Length ^ (uint)b.Length;
            for (int i = 0; i < a.Length && i < b.Length; i++)
                diff |= (uint)(a[i] ^ b[i]);
            return diff == 0;
        }

        /// <summary>
        /// Computes the PBKDF2-SHA1 hash of a password.
        /// </summary>
        /// <param name="password">The password to hash.</param>
        /// <param name="salt">The salt.</param>
        /// <param name="iterations">The PBKDF2 iteration count.</param>
        /// <param name="outputBytes">The length of the hash to generate, in bytes.</param>
        /// <returns>A hash of the password.</returns>
        private static byte[] PBKDF2(string password, byte[] salt, int iterations, int outputBytes)
        {
            Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, salt);
            pbkdf2.IterationCount = iterations;
            return pbkdf2.GetBytes(outputBytes);
        }
    }
}

如您所见，验证密码的唯一方法是ValidatePassword使用纯文本密码进行调用。在我之前的普通 SHA1 实现中，为了在本地浏览器中存储用户登录信息，我将该 SHA1 值放入 cookie 中，并将其与存储在服务器上每个页面的数据库中的值进行比较。但是你如何用这种“安全”的方法做同样的事情呢？

有任何想法吗？

4

3 回答 3

3

您不想将散列密码存储在 cookie 中，因为这与将密码本身存储在 cookie 中是一样的。如果哈希是您登录所需的全部，那么它就是密码。您想用随机盐对用户密码进行哈希处理的原因不是为了保护登录过程，而是为了保护您的密码表。如果攻击者窃取了您的密码表，并且每个密码都没有使用唯一的盐进行哈希处理，那么他/她很容易找出许多密码。始终使用唯一的盐对您的用户密码进行哈希处理。用散列密码存储这个盐很好。如果您想要一种安全的方式来使用散列来根据 cookie 中的数据对用户进行身份验证，您将需要采用临时凭证或会话的方向。我能想到的最简单的方法如下：

  1. 当您的用户使用他的密码登录时，创建一个“会话”。分配一个值以唯一标识此会话，存储会话创建的时间（以毫秒为单位），并创建一个随机值作为盐。

  2. 用盐散列会话的 id。将此哈希和会话 ID 保存在用户的 cookie 中。

  3. 每次请求页面时，再次执行哈希并将其与存储在用户 cookie 中的值进行比较。如果值匹配并且自会话创建以来没有经过太多时间，您的用户可以查看该页面。否则，让他们使用密码再次登录。

于 2013-01-07T01:22:37.110 回答
1

哈希存储在服务器上，作为将明文密码发送到服务器时的用户身份验证的一部分，计算的盐（每个用户）存储在安全数据库中并添加到密码中，并根据密码 + 哈希计算加密结果。

Cookie 是错误的方法，因为它们会过期并且 Web 客户端没有理由需要 salt。

加盐密码：最佳实践？

于 2013-01-07T01:26:14.247 回答
0

一般来说，散列函数的盐是您根据规则计算的东西。例如，您使用用户标识符作为盐本身。您使用“用户名”值在数据库中查找用户，然后使用用户 ID 作为盐。这样，您不必将盐存储在任何地方，并且每个散列值的盐是不同的。

于 2013-01-07T00:33:40.527 回答