How can I hash a password in Java?

ID : 20034

viewed : 22

Tags : javapasswordscryptographic-hash-functionjava

Top 5 Answer for How can I hash a password in Java?

vote vote

96

You can actually use a facility built in to the Java runtime to do this. The SunJCE in Java 6 supports PBKDF2, which is a good algorithm to use for password hashing.

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

Here's a utility class that you can use for PBKDF2 password authentication:

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

85

BCrypt is a very good library, and there is a Java port of it.

vote vote

70

You can comput hashes using MessageDigest, but this is wrong in terms of security. Hashes are not to be used for storing passwords, as they are easily breakable.

You should use another algorithm like bcrypt, PBKDF2 and scrypt to store you passwords. See here.

vote vote

63

You could use Spring Security Crypto (has only 2 optional compile dependencies), which supports PBKDF2, BCrypt, SCrypt and Argon2 password encryption.

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

55

You can use the Shiro library's (formerly JSecurity) implementation of what is described by OWASP.

It also looks like the JASYPT library has a similar utility.

Top 3 video Explaining How can I hash a password in Java?

Related QUESTION?