如何在Java中散列密码？

Question

我需要哈希密码才能存储在数据库中。我怎么能用Java做到这一点？

我希望获取纯文本密码，添加随机盐，然后将salt和哈希密码存储在数据库中。

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

Answer 1

您实际上可以使用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);
  }

}

Answer 2

这是一个完整的实现，其中两个方法完全符合您的要求：

String getSaltedHash(String password)
boolean checkPassword(String password, String stored)

关键是即使攻击者可以访问您的数据库和源代码，密码仍然是安全的。

import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.SecureRandom;
import org.apache.commons.codec.binary.Base64;

public class Password {
    // The higher the number of iterations the more 
    // expensive computing the hash is for us and
    // also for an attacker.
    private static final int iterations = 20*1000;
    private static final int saltLen = 32;
    private static final int desiredKeyLen = 256;

    /** Computes a salted PBKDF2 hash of given plaintext password
        suitable for storing in a database. 
        Empty passwords are not supported. */
    public static String getSaltedHash(String password) throws Exception {
        byte[] salt = SecureRandom.getInstance("SHA1PRNG").generateSeed(saltLen);
        // store the salt with the password
        return Base64.encodeBase64String(salt) + "$" + hash(password, salt);
    }

    /** Checks whether given plaintext password corresponds 
        to a stored salted hash of the password. */
    public static boolean check(String password, String stored) throws Exception{
        String[] saltAndHash = stored.split("\\$");
        if (saltAndHash.length != 2) {
            throw new IllegalStateException(
                "The stored password must have the form 'salt$hash'");
        }
        String hashOfInput = hash(password, Base64.decodeBase64(saltAndHash[0]));
        return hashOfInput.equals(saltAndHash[1]);
    }

    // using PBKDF2 from Sun, an alternative is https://github.com/wg/scrypt
    // cf. http://www.unlimitednovelty.com/2012/03/dont-use-bcrypt.html
    private static String hash(String password, byte[] salt) throws Exception {
        if (password == null || password.length() == 0)
            throw new IllegalArgumentException("Empty passwords are not supported.");
        SecretKeyFactory f = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
        SecretKey key = f.generateSecret(new PBEKeySpec(
            password.toCharArray(), salt, iterations, desiredKeyLen));
        return Base64.encodeBase64String(key.getEncoded());
    }
}

我们正在存储'salt$iterated_hash(password, salt)'。盐是32个随机字节，其目的是如果两个不同的人选择相同的密码，存储的密码仍然会有所不同。

iterated_hash，基本上是hash(hash(hash(... hash(password, salt) ...)))，对于有权访问您的数据库的潜在攻击者来说，猜测密码，哈希，查找数据库中的哈希值非常昂贵。每次用户登录时都必须计算此iterated_hash，但与花费近100％的时间计算哈希值的攻击者相比，它不会花费太多。

Answer 3

BCrypt是一个非常好的库，它有一个Java port。

Answer 4

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

您应该使用其他算法（如bcrypt，PBKDF2和scrypt）来存储密码。 See here

Answer 5

您可以使用Shiro描述的JSecurity库（以前的implementation）OWASP。

它看起来像JASYPT库有一个similar utility。

Answer 6

完全同意Erickson 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

Answer 7

除了其他答案中提到的bcrypt和PBKDF2之外，我建议您查看scrypt

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

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

• 有关详情，请参阅此处：https://security.stackexchange.com/questions/211/how-to-securely-hash-passwords

• 在这里：http://codahale.com/how-to-safely-store-a-password/（批评SHA家族，MD5等用于密码哈希目的）

• 在这里：http://www.unlimitednovelty.com/2012/03/dont-use-bcrypt.html（批评bcrypt并推荐scrypt和PBKDF2）

Answer 8

虽然已经提及NIST recommendation PBKDF2，但我想指出2013年至2015年期间有一个公开password hashing competition。最后， {{选择3}} 作为推荐的密码哈希函数。

您可以使用原始（本机C）库的相当好的Argon2。

在普通用例中，如果您选择PBKDF2而不是Argon2，反之亦然，从安全角度来看，我认为这无关紧要。如果您有强大的安全要求，我建议您在评估中考虑Argon2。

有关密码散列函数安全性的更多信息，请参阅Java binding。

Answer 9

这里有两个MD5散列和其他散列方法的链接：

Javadoc API：http://java.sun.com/j2se/1.4.2/docs/api/java/security/MessageDigest.html

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

Answer 10

在所有标准哈希方案中，LDAP ssha是最安全的哈希方案，

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

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

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

Answer 11

您可以使用Spring Security Crypto（只有2 optional compile dependencies），它支持PBKDF2，BCrypt和SCrypt密码加密。

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);

Answer 12

截至2020年，使用的最可靠的密码哈希算法最可能在给定任何硬件的情况下优化其强度，是 Argon2id 或 Argon2i ，但不是Spring实施。

PBKDF2标准包括块密码BCRYPT算法的CPU贪婪/计算昂贵的功能，并增加了其 stream cipher功能。 PBKDF2被内存指数贪婪的SCRYPT压倒，然后被抗侧通道攻击的Argon2压倒了。

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

• Argon2i 专用于内存贪婪散列
• Argon2d 专用于CPU贪婪散列
• Argon2id 使用这两种方法。

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

Spring安全性/ Bouncy Castle的实现未经过优化，并且鉴于攻击者可以使用的资源，因此相对而言要花上一周的时间。 cf：Spring文档Argon2和Scrypt

当前的实现使用未利用的Bouncy城​​堡 密码破解者会并行/优化，因此有一个 攻击者和防御者之间不必要的不​​对称性。

用于Java的最可靠的实现是mkammerer的实现，

用C语言编写的official native implementation的包装jar /库。

它写得很好并且易于使用。

嵌入式版本提供了适用于Linux，Windows和OSX的本机版本。

例如，jpmorganchase在其tessera安全项目中使用它来保护其以太坊加密货币实现Quorum。

这里是一个例子：

    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);

（请参见tessera）

在您的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算法也可以通过编写一些简单的基准进行校准，但是当前最小的安全迭代值将需要更长的哈希时间。

Answer 13

我从关于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);
}






}