PasswordEncryptionService.java

/*******************************************************************************
 * Copyright (c) 2015 MEDEVIT.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     MEDEVIT <office@medevit.at> - initial API and implementation
 ******************************************************************************/
package ch.rgw.tools;

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

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

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;

/**
 * @author Jeremiah Orr
 * @see http://java.dzone.com/articles/secure-password-storage-lots
 * @since 3.1
 */
public class PasswordEncryptionService {
	
	public boolean authenticate(String attemptedPassword, byte[] encryptedPassword, byte[] salt)
		throws NoSuchAlgorithmException, InvalidKeySpecException{
		// Encrypt the clear-text password using the same salt that was used to
		// encrypt the original password
		byte[] encryptedAttemptedPassword = getEncryptedPassword(attemptedPassword, salt);
		
		// Authentication succeeds if encrypted password that the user entered
		// is equal to the stored hash
		return Arrays.equals(encryptedPassword, encryptedAttemptedPassword);
	}
	
	public boolean authenticate(String attemptedPassword, String encryptedPassword, String salt)
		throws NoSuchAlgorithmException, InvalidKeySpecException, DecoderException{
		return authenticate(attemptedPassword, Hex.decodeHex(encryptedPassword.toCharArray()),
			Hex.decodeHex(salt.toCharArray()));
	}
	
	public byte[] getEncryptedPassword(String password, byte[] salt)
		throws NoSuchAlgorithmException, InvalidKeySpecException{
		// PBKDF2 with SHA-1 as the hashing algorithm. Note that the NIST
		// specifically names SHA-1 as an acceptable hashing algorithm for PBKDF2
		String algorithm = "PBKDF2WithHmacSHA1";
		// SHA-1 generates 160 bit hashes, so that's what makes sense here
		int derivedKeyLength = 160;
		// Pick an iteration count that works for you. The NIST recommends at
		// least 1,000 iterations:
		// http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf
		// iOS 4.x reportedly uses 10,000:
		// http://blog.crackpassword.com/2010/09/smartphone-forensics-cracking-blackberry-backup-passwords/
		int iterations = 20000;
		
		KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, iterations, derivedKeyLength);
		SecretKeyFactory f = SecretKeyFactory.getInstance(algorithm);
		
		return f.generateSecret(spec).getEncoded();
	}
	
	public String getEncryptedPasswordAsHexString(String password, String salt)
		throws NoSuchAlgorithmException, InvalidKeySpecException, DecoderException{
		byte[] encryptedPassword = getEncryptedPassword(password, Hex.decodeHex(salt.toCharArray()));
		return Hex.encodeHexString(encryptedPassword);
	}
	
	public byte[] generateSalt() throws NoSuchAlgorithmException{
		// VERY important to use SecureRandom instead of just Random
		SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
		
		// Generate a 8 byte (64 bit) salt as recommended by RSA PKCS5
		byte[] salt = new byte[8];
		random.nextBytes(salt);
		
		return salt;
	}
	
	public String generateSaltAsHexString() throws NoSuchAlgorithmException{
		return Hex.encodeHexString(generateSalt());
	}
}