如何在Java中哈希密码?


176

我需要对密码进行哈希处理以存储在数据库中。如何用Java做到这一点?

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

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


11
@YGL如今,由于GPU攻击是如此便宜,这实际上已不是重组,即使加盐,SHA家族对于密码哈希(太快)实际上也是一个非常糟糕的选择。使用bcrypt,scrypt或PBKDF2
Eran Medan

11
为什么这个问题结束了?这是一个真正的工程问题,答案是无价的。OP并不需要图书馆,而是在问如何解决工程问题。
stackoverflowuser2010

12
太棒了。这个问题有52票赞成票,有人决定将其关闭为“ off-topic”。
stackoverflowuser2010

1
是的,我之前在Meta上发布过有关关闭的问题,但遭到了非常严重的殴打。
克里斯·杜特罗

8
这个问题应该重新讨论。这是一个有关如何编写程序来解决上述问题(密码验证)的简短代码解决方案的问题。看到触发词“库”并不能说明性地关闭一个问题。他不是在要求图书馆的建议,而是在问如何对密码进行哈希处理。编辑:在那里,修复它。
erickson

Answers:


155

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

}

11
您可能需要注意BigInteger:将前导零删除,将字节转换为十六进制。可以进行快速调试,但是由于这种影响,我已经看到了生产代码中的错误。
托马斯·波宁

24
@ thomas-pornin的要点强调了为什么我们需要一个,而不是一个几乎存在的代码块。令人害怕的是,被接受的答案无法回答如此重要的话题。
Nilzor

9
从Java 8开始使用算法PBKDF2WithHmacSHA512。它要强一些。
iwan.z 2014年

1
请注意,现有的Algs在更高版本中不会被删除:java_4:PBEWithMD5AndDES,DESede,DES java_5 / 6/7:PBKDF2WithHmacSHA1,PBE(仅在Java 5中),PBEWithSHA1AndRC2_40,PBEWithSHA1And,PBEWithMD5AndTriple java_8:PBEWithHMacshaSHAshaAndAnd,PBEWithMD1256,PBEWithHmacSHA512 ,PBEWithHmacSHA1AndAES_128,RC4_128,PBKDF2WithHmacSHA224,PBEWithHmacSHA256AndAES_256,RC2_128,PBEWithHmacSHA224AndAES_256,PBEWithHmacSHA384AndAES_256,PBEWithHmacSHA512AndAES_256,PBKDF2WithHmacSHA512,PBEWithHmacSHA256AndAES_128,PBKDF2WithHmacSHA384,PBEWithHmacSHA1AndAES_256
iwan.z

4
@TheTosters是的,错误密码的执行时间会更长;更具体地说,错误的密码将与正确的密码花费相同的时间。它可以防止定时攻击,尽管我承认我无法想到在这种情况下利用这种漏洞的实用方法。但是你不会偷工减料。仅仅因为我看不到它,并不意味着不会有更曲折的头脑。
埃里克森

97

这是一个完整的实现,其中有两种方法可以完全满足您的要求:

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%的时间计算哈希的攻击者相比,它并不需要花费那么多钱。


14
抱歉,我为什么要在现有库中选择它?图书馆可能有更高的机会受到全面审查。我怀疑这14个投票中的每一个都分析了代码是否存在问题。
约阿希姆·绍尔

2
@JoachimSauer这实际上只是使用一个库(javax.crypto),但是您是对的-不支持空密码。添加了一个异常使其明确。谢谢!
Martin Konicek 2013年

3
您可能应该将方法签名更改char[] passwordString password
assylias

2
尽管该参考文献似乎未获得一致同意。另请参阅:security.stackexchange.com/a/20369/12614
assylias 2013年

3
您确定字符串上的.equals()不会短路(即:当发现两个不相等的字节时停止循环)吗?如果这样做,则可能存在定时攻击泄漏有关密码哈希的信息的风险。
bobpoekert


7

您可以使用计算哈希 MessageDigest,但这在安全性方面是错误的。哈希值不可轻易用于存储密码。

您应该使用其他算法,例如bcrypt,PBKDF2和scrypt来存储密码。看这里


3
您如何在登录时哈希密码而不在数据库中存储盐?
ZZ编码器

9
使用用户名作为盐并不是致命的缺陷,但它远不及使用来自加密RNG的盐好。将盐存储在数据库中绝对没有问题。盐不是秘密。
艾里克森(Erickson),2010年

1
用户名和电子邮件也不会存储在数据库中吗?
克里斯·杜特罗

@ZZ Coder,@ erickson是正确的,我以某种方式假定这将是所有密码的盐,这将导致易于计算的彩虹表。
博佐

13
将用户名(或其他ID(例如电子邮件))用作盐的一个问题是,如果不让用户也设置新密码,就无法更改ID。
劳伦斯·多尔

6

您可以使用Shiro库的(以前称为JSecurity OWASP描述)实现

看起来JASYPT库也具有类似的实用程序


多数民众赞成在实际上我正在使用。但是由于我们决定不使用Shiro,因此对于仅包含一个软件包就包括整个Shiro库的效率低下感到有些担忧。
克里斯·杜特罗

我不知道仅由密码哈希实用程序组成的库。如果您担心依赖关系,最好还是自己动手制作。埃里克森的答案对我来说看起来不错。或者,如果您希望以安全的方式使用SHA,则只需从我引用的OWASP链接中复制代码即可。
laz 2010年

6

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

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

如果必须使用它们,则至少要对算法进行预定义的大量重复(1000+)。


6

完全同意Erickson的观点,PBKDF2是答案。

如果您没有该选项,或者只需要使用哈希,那么Apache Commons DigestUtils比正确设置JCE代码要容易得多: https /commons/codec/digest/DigestUtils.html

如果使用哈希,请使用sha256或sha512。此页面对密码处理和哈希提供了很好的建议(请注意,不建议对密码进行哈希处理):http : //www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html


值得注意的是,SHA512并不比SHA256更好,因为它的数量更大。
Azsgy

4

虽然已经提到了NIST建议PBKDF2,但我想指出的是,从2013年到2015年,有一个公共密码哈希竞赛。最后,Argon2被选为推荐的密码哈希函数。

您可以使用原始库(本机C)采用的Java绑定

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

有关密码哈希函数安全性的更多信息,请参见security.se


@zaph我将答案编辑得更加客观。请注意,NIST建议可能并不总是最佳选择(请参阅此处的示例)-当然,对于在其他地方建议的任何建议也是如此。因此,我确实认为该答案为该问题提供了价值。
Qw3ry

4

您可以使用Spring Security Crypto(只有2个可选的编译依赖项),它支持PBKDF2BCryptSCryptArgon2密码加密。

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

2

在这里,您有两个用于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


3
请记住,对于密码哈希,越慢越好。您应该将哈希函数的数千次迭代用作“关键加强”技术。另外,盐是必须的。
艾里克森(Erickson)2010年

我的印象是,质量哈希算法的多次迭代将产生与一次迭代大致相同的安全性,因为字节的长度仍然相同?
克里斯·杜特罗

@erickson最好放慢攻击者的速度。
迪蒙

6
关于关键的增强:存在盐会使预先计算的哈希值不可用。但是攻击者不必预先计算。攻击者可以“快速”对字符串+盐进行哈希处理,直到找到正确的字符串为止。但是,如果您对哈希进行了数千次迭代,则它们必须这样做。您的服务器不会受到1万次迭代的很大影响,因为它不会经常发生。攻击者将需要1万倍的计算能力。
zockman

2
今天,@ Simon @ MD5被认为对密码哈希无用,因为使用GPU暴力/字典攻击可以在数秒内破解它。看到这里:codahale.com/how-to-safely-store-a-password
Eran Medan

1

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

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

我只是遵循那里指定的算法,并使用MessageDigest进行哈希处理。

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


1
因为SSHA不会迭代哈希函数,所以它太快了。这使攻击者可以更快地尝试密码。更好的算法,例如Bcrypt,PBBKDF1和PBKDF2,使用“密钥加强”技术将攻击者放慢到密码应过期的地步,直到他们可以强行使用甚至8个字母的密码空间。
艾里克森(Erickson)2010年

所有这些机制的问题在于您无法获得客户支持。散列密码存在的问题是您无法支持使用其他算法散列的密码。使用ssha,至少所有LDAP客户端都支持它。
ZZ编码器2010年

它不是“最安全的”,而仅仅是“完全兼容的”。bcrypt / scrypt是资源密集型的方式。
eckes 2012年

1

截至2020年,正在使用的最可信,最灵活的算法,

在使用任何硬件的情况下最有可能优化其强度的设备,

Argon2idArgon2i

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

  • Argon2i专门研究内存贪婪哈希
  • Argon2d专门从事CPU贪婪哈希处理
  • Argon2id使用这两种方法。

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

Spring安全性/ Bouncy Castle的实现未经过优化,并且鉴于攻击者可以使用哪些资源,相对而言要花上一周的时间。cf:Spring文档

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

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

用Rust编写的官方本机实现的包装jar /库。

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

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

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

这里是tessera的示例代码。

可以使用de.mkammerer.argon2.Argon2Helper#findIterations进行校准

还可以通过编写一些简单的基准来对SCRYPT和Pbkdf2算法进行校准,但是当前最小的安全迭代值将需要更长的哈希时间。


0

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






}

我愿意接受更正,但是我认为您在哈希时不应该使用随机数。这样一来,您的哈希函数就可以保持确定性。也就是说,如果您对一个字符串进行多次哈希处理,则始终会为该字符串返回相同的哈希值。
杜尔迪
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.