如何在Java中散列密码？

我需要在数据库中存储哈希密码。如何在Java中执行此操作？

我希望采用纯文本密码，添加一个随机盐，然后将盐和哈希密码存储在数据库中。

然后，当用户想要登录时，我可以获取他们提交的密码，从他们的帐户信息中添加随机盐，对其进行哈希处理，并查看它是否等同于存储的哈希密码及其帐户信息。

191399 次浏览
小开

bcrypt是一个非常好的库，其中有一个Java端口。

小开

您可以使用MessageDigest来计算哈希，但这在安全性方面是错误的。哈希不能用于存储密码，因为它们很容易被破解。

您应该使用其他算法（如bcrypt、pbkdf2和scrypt）来存储您的密码。看这里。

小开

这里有两个关于MD5哈希和其他哈希方法的链接：

Javadoc API：https://docs.oracle.com/javase/1.5.0/docs/api/java/security/MessageDigest.html

教程：http://www.twmacinta.com/myjava/fast_md5.php

小开

在所有标准的散列方案中，LDAPSSHA是最安全的散列方案。

http：//www.openldap.org/faq/data/cache/347.html.

我只会遵循这里指定的算法，并使用MessageDigest来执行哈希。

您需要按照建议将SALT存储在数据库中。

小开
最佳答案

实际上，您可以使用Java运行时内置的工具来实现这一点。Java 6中的SUNJCE支持PBKDF2，这是一种用于密码哈希的好算法。

byte[] salt = new byte[16];
random.nextBytes(salt);
KeySpec spec = new PBEKeySpec("password".toCharArray(), salt, 65536, 128);
SecretKeyFactory f = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
byte[] hash = f.generateSecret(spec).getEncoded();
Base64.Encoder enc = Base64.getEncoder();
System.out.printf("salt: %s%n", enc.encodeToString(salt));
System.out.printf("hash: %s%n", enc.encodeToString(hash));

下面是可用于PBKDF2密码身份验证的实用程序类：

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Arrays;
import java.util.Base64;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


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


/**
* Hash passwords for storage, and test passwords against password tokens.
*
* Instances of this class can be used concurrently by multiple threads.
*
* @author erickson
* @see <a href="http://stackoverflow.com/a/2861125/3474">StackOverflow</a>
*/
public final class PasswordAuthentication
{


/**
* Each token produced by this class uses this identifier as a prefix.
*/
public static final String ID = "$31$";


/**
* The minimum recommended cost, used by default
*/
public static final int DEFAULT_COST = 16;


private static final String ALGORITHM = "PBKDF2WithHmacSHA1";


private static final int SIZE = 128;


private static final Pattern layout = Pattern.compile("\\$31\\$(\\d\\d?)\\$(.{43})");


private final SecureRandom random;


private final int cost;


public PasswordAuthentication()
{
this(DEFAULT_COST);
}


/**
* Create a password manager with a specified cost
*
* @param cost the exponential computational cost of hashing a password, 0 to 30
*/
public PasswordAuthentication(int cost)
{
iterations(cost); /* Validate cost */
this.cost = cost;
this.random = new SecureRandom();
}


private static int iterations(int cost)
{
if ((cost < 0) || (cost > 30))
throw new IllegalArgumentException("cost: " + cost);
return 1 << cost;
}


/**
* Hash a password for storage.
*
* @return a secure authentication token to be stored for later authentication
*/
public String hash(char[] password)
{
byte[] salt = new byte[SIZE / 8];
random.nextBytes(salt);
byte[] dk = pbkdf2(password, salt, 1 << cost);
byte[] hash = new byte[salt.length + dk.length];
System.arraycopy(salt, 0, hash, 0, salt.length);
System.arraycopy(dk, 0, hash, salt.length, dk.length);
Base64.Encoder enc = Base64.getUrlEncoder().withoutPadding();
return ID + cost + '$' + enc.encodeToString(hash);
}


/**
* Authenticate with a password and a stored password token.
*
* @return true if the password and token match
*/
public boolean authenticate(char[] password, String token)
{
Matcher m = layout.matcher(token);
if (!m.matches())
throw new IllegalArgumentException("Invalid token format");
int iterations = iterations(Integer.parseInt(m.group(1)));
byte[] hash = Base64.getUrlDecoder().decode(m.group(2));
byte[] salt = Arrays.copyOfRange(hash, 0, SIZE / 8);
byte[] check = pbkdf2(password, salt, iterations);
int zero = 0;
for (int idx = 0; idx < check.length; ++idx)
zero |= hash[salt.length + idx] ^ check[idx];
return zero == 0;
}


private static byte[] pbkdf2(char[] password, byte[] salt, int iterations)
{
KeySpec spec = new PBEKeySpec(password, salt, iterations, SIZE);
try {
SecretKeyFactory f = SecretKeyFactory.getInstance(ALGORITHM);
return f.generateSecret(spec).getEncoded();
}
catch (NoSuchAlgorithmException ex) {
throw new IllegalStateException("Missing algorithm: " + ALGORITHM, ex);
}
catch (InvalidKeySpecException ex) {
throw new IllegalStateException("Invalid SecretKeyFactory", ex);
}
}


/**
* Hash a password in an immutable {@code String}.
*
* <p>Passwords should be stored in a {@code char[]} so that it can be filled
* with zeros after use instead of lingering on the heap and elsewhere.
*
* @deprecated Use {@link #hash(char[])} instead
*/
@Deprecated
public String hash(String password)
{
return hash(password.toCharArray());
}


/**
* Authenticate with a password in an immutable {@code String} and a stored
* password token.
*
* @deprecated Use {@link #authenticate(char[],String)} instead.
* @see #hash(String)
*/
@Deprecated
public boolean authenticate(String password, String token)
{
return authenticate(password.toCharArray(), token);
}


}
小开

您可以使用四郎库（以前的J安全）的实施来描述奥瓦斯普所描述的内容。

看起来Jasypt库也有一个_ABC，_0。

小开

我完全同意埃里克森的观点，即答案是PBKDF2。

如果您没有该选项，或者只需要使用散列，那么Apache Commons DigestUtils比获取正确的JCE代码要容易得多： https://commons.apache.org/proper/commons-codec/apidocs/org/apache/commons/codec/digest/DigestUtils.html

如果使用哈希，请使用SHA256或SHA512。本页对密码处理和哈希有很好的建议（请注意，它不建议对密码处理使用哈希）： http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html

小开

除了在其他回答中提到的bcrypt和pbkdf2之外，我建议查看斯克里普特

不建议使用MD5和Sha-1，因为它们相对较快，因此使用“每小时租金”分布式计算（例如EC2）或现代高端GPU，可以在相对较低的成本和合理的时间内使用暴力/字典攻击“破解”密码。

如果您必须使用它们，那么至少将算法迭代预定义的大量次数（1000+）。

小开

虽然已经提到了NIST建议PBKDF2，但我想指出的是，从2013年到2015年，有一个公共密码哈希竞争。最终，阿尔贡2被选为推荐的密码哈希函数。

对于您可以使用的原始（本机C）库，有一个广泛采用的Java绑定。

在一般的使用案例中，我认为从安全的角度来看，选择PBKDF2而不是Argon2并不重要，反之亦然。如果您有严格的安全要求，我建议您在评估时考虑Argon2。

有关密码哈希函数安全性的详细信息，请参阅Security.se。

小开

您可以使用春天的安全密码（只有2个可选的编译依赖项），它支持PBKDF2、bcrypt、斯克里普特和阿尔贡2密码加密。

Argon2PasswordEncoder argon2PasswordEncoder = new Argon2PasswordEncoder();
String aCryptedPassword = argon2PasswordEncoder.encode("password");
boolean passwordIsValid = argon2PasswordEncoder.matches("password", aCryptedPassword);

SCryptPasswordEncoder sCryptPasswordEncoder = new SCryptPasswordEncoder();
String sCryptedPassword = sCryptPasswordEncoder.encode("password");
boolean passwordIsValid = sCryptPasswordEncoder.matches("password", sCryptedPassword);

BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
String bCryptedPassword = bCryptPasswordEncoder.encode("password");
boolean passwordIsValid = bCryptPasswordEncoder.matches("password", bCryptedPassword);

Pbkdf2PasswordEncoder pbkdf2PasswordEncoder = new Pbkdf2PasswordEncoder();
String pbkdf2CryptedPassword = pbkdf2PasswordEncoder.encode("password");
boolean passwordIsValid = pbkdf2PasswordEncoder.matches("password", pbkdf2CryptedPassword);
小开

我从Udemy上的一段视频中学到了这一点，并将其编辑为更强的随机密码。

}


private String pass() {
String passswet="1234567890zxcvbbnmasdfghjklop[iuytrtewq@#$%^&*" ;


char icon1;
char[] t=new char[20];


int rand1=(int)(Math.random()*6)+38;//to make a random within the range of special characters


icon1=passswet.charAt(rand1);//will produce char with a special character


int i=0;
while( i <11) {


int rand=(int)(Math.random()*passswet.length());
//notice (int) as the original value of Math>random() is double


t[i] =passswet.charAt(rand);


i++;
t[10]=icon1;
//to replace the specified item with icon1
}
return new String(t);
}












}
小开

截至2020年，最可靠的密码哈希算法是Argon2Id或阿尔贡2I，而不是其Spring实现，该算法最有可能在任何硬件上优化其强度。

PBKDF2标准包括分组密码BCRYPT算法的CPU贪婪/计算昂贵的特征，并且增加了其流密码的能力。PBKDF2被内存指数贪婪的Scrypt压倒，然后被抗侧信道攻击的Argon2压倒

Argon2提供必要的校准工具，以在给定目标散列时间和所使用的硬件的情况下找到优化的强度参数。

  • 阿尔贡2I专门用于内存贪婪哈希
  • Argon2d专门用于CPU贪婪哈希
  • Argon2Id使用两种方法。

内存贪婪哈希将有助于防止GPU用于破解。

Spring Security/Bouncy Castle的实现没有经过优化，考虑到攻击者可能使用的内容，它相对较弱。 CF：Spring文档阿尔贡2和斯克里普特

当前

的实现使用了Bouncy Castle，它没有利用 密码破解者将进行并行/优化，因此有一个 攻击者和防御者之间不必要的不对称。

Java使用中最可靠的实现是姆卡默勒的实现，

用C编写的正式的本地实现的包装JAR/库。

它写得很好，使用起来很简单。

嵌入式版本为Linux、Windows和OSX提供本地构建。

例如，摩根大通（JPMorganChase）在其泰塞拉安全项目中使用了它，该项目用于保护法定人数（其以太坊加密货币实施）。

这里有一个例子：

    final char[] password = "a4e9y2tr0ngAnd7on6P১M°RD".toCharArray();
byte[] salt = new byte[128];
new SecureRandom().nextBytes(salt);
final Argon2Advanced argon2 = Argon2Factory.createAdvanced(Argon2Factory.Argon2Types.ARGON2id);
byte[] hash = argon2.rawHash(10, 1048576, 4, password, salt);

（参见泰塞拉）

在POM中声明lib：

<dependency>
<groupId>de.mkammerer</groupId>
<artifactId>argon2-jvm</artifactId>
<version>2.7</version>
</dependency>

或使用Gradle：

compile 'de.mkammerer:argon2-jvm:2.7'

校准可以使用de.mkammerer.argon2.argon2helper#finditerations来执行

SCRYPT和PBKDF2算法也可以通过编写一些简单的基准来校准，但当前的最小安全迭代值将需要更高的哈希时间。

小开

下面是我创建的简单PasswordHasher类：

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Arrays;


public class PasswordHasher {
private static final String ALGO = "PBKDF2WithHmacSHA1";
private static final byte[] SALT = {
8, 8, 8, 8, 2,
8, 7, 7, 7, 2,
1, 1, 1, 1, 2,
11
};
private static final int ITERATION_COUNT = 1000;
private static final int KEY_LENGTH = 128;


private SecretKeyFactory mFactory;


byte[] hashPassword(String password) {
SecretKeyFactory factory = getFactory();


if (factory != null) {
try {
KeySpec spec = new PBEKeySpec(password.toCharArray(), SALT, ITERATION_COUNT, KEY_LENGTH);
return factory.generateSecret(spec).getEncoded();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
}
}
return null;
}


boolean verifyPassword(String password, byte[] expectedHashResult) {
byte[] hashedPassword = hashPassword(password);
if (hashedPassword == null) {
// Log fail result
return false;
}
return Arrays.equals(hashedPassword, expectedHashResult);
}


private SecretKeyFactory getFactory() {
if (mFactory == null) {
try {
mFactory = SecretKeyFactory.getInstance(ALGO);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
return mFactory;
}
}

提交答案