java - 保护密码 SHA-1 Java

Question

我正在尝试保护我正在构建的 Web 应用程序的密码。我对密码学还很陌生。我使用 Java 和 Sha-1 哈希将密码存储在数据库中。

经过对此事的一些研究，使用盐似乎是散列密码的最佳方法，但是当然盐必须与密码一起存储。

就我而言，我在数据库中使用一个新列作为盐，我不知道这是否是正确的方法。如果有人窃取了我的数据库，用哈希值和盐就能读取密码吗？在哈希和盐之间放置一个分隔符并将它们存储在一起会更好吗？在这种情况下，要检查密码的有效性，我必须解析该字符串。 我只是想知道您的意见和可以应用于此处的最佳实践。

提前非常感谢您!

@Entity
@Table(name="USERS")
public class User implements BasePersistentEntity<Long> {

/**
 * 
 */
private static final long serialVersionUID = 1L;


@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="ID")
private Long id;

@Column(name="EMAIL",nullable=false,length=50,insertable=true,updatable=true)
private String email;

@Column(name="PASSWORD",nullable=false,length=40,insertable=true,updatable=true)
private String password;

@Column(name="SALT",nullable=false,length=40,insertable=true,updatable=true)
private String passwordSalt;


public Long getId() {
    return id;
}

public void setId(Long id) {
    this.id = id;
}

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email=email;
}

public String getPassword() {
    return password;
}

public void setPassword(String password) {
    if (password.equals(this.password))
    {
        return;
    }

    if (passwordSalt == null || passwordSalt.equals(""))
    {
        passwordSalt = RandomStringUtils.randomAscii(20);
    }

    this.password = DigestUtils.sha1Hex(password + passwordSalt);
}

/**
 * Check if a given password is correct.
 *
 * @param givenPassword
 * @return True is correct, else false.
 */
public boolean checkPassword(String givenPassword)
{
    return (password.equals(DigestUtils.sha1Hex(givenPassword + passwordSalt)));
}


public String getPasswordSalt() {
    return passwordSalt;
}

public void setPasswordSalt(String passwordSalt) {
    this.passwordSalt = passwordSalt;
}
}

Answer 1

盐的存储方式与方案的安全性无关紧要。 salt 和 hash 都可以以普通格式存储。

盐可用于防止彩虹表攻击以及为相同的密码创建不同的哈希值。

然而，您缺少的是某种工作因素或迭代计数。这是由密码 key 派生函数(例如 PBKDF2(包含在 Java 中)或 bcrypt)提供的。这将为防止暴力攻击提供一些额外的保护(尝试各种密码并查看它们是否匹配)。这会增加一些安全性，因为密码通常缺乏足够的熵。

可以存储可与服务器应用程序中的盐结合的静态“胡椒”。如果只有数据被盗，这可能会增加一些安全性。

<小时/>

不加胡椒的例子:

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;

import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public class PBKDF2ForPasswordHash {

    private static final String PBKDF_ALGORITHM = "PBKDF2WithHmacSHA1";
    private static final int ITERATION_COUNT = 10_000;
    // should be less than the size of the underlying hash
    private static final int PASSWORD_HASH_SIZE_BYTES = 16;
    private static final int SALT_SIZE_BYTES = 16;

    public static byte[] generateRandomSalt(final int saltSizeBytes) {
        final SecureRandom rng = new SecureRandom();
        final byte[] salt = new byte[saltSizeBytes];
        rng.nextBytes(salt);
        return salt;
    }

    public static byte[] generatePasswordHash(final char[] password,
            final byte[] salt) {
        SecretKeyFactory f;
        try {
            f = SecretKeyFactory.getInstance(PBKDF_ALGORITHM);
        } catch (final NoSuchAlgorithmException e) {
            throw new IllegalStateException("PBKDF algorithm "
                    + PBKDF_ALGORITHM + " not available", e);
        }
        final KeySpec ks = new PBEKeySpec(password, salt, ITERATION_COUNT,
                PASSWORD_HASH_SIZE_BYTES * Byte.SIZE);
        SecretKey s;
        try {
            s = f.generateSecret(ks);
        } catch (final InvalidKeySpecException e) {
            throw new IllegalArgumentException(
                    "PBEKeySpec should always be valid for " + PBKDF_ALGORITHM,
                    e);
        }
        return s.getEncoded();
    }

    public static final String toHex(final byte[] data) {
        final StringBuilder sb = new StringBuilder(data.length * 2);
        for (int i = 0; i < data.length; i++) {
            sb.append(String.format("%02x", data[i]));
        }
        return sb.toString();
    }

    public static void main(final String[] args) throws Exception {
        final char[] password = { 'o', 'w', 'l' };
        final byte[] salt = generateRandomSalt(SALT_SIZE_BYTES);
        System.out.println(toHex(salt));
        final byte[] hash = generatePasswordHash(password, salt);
        System.out.println(toHex(hash));
    }
}