package util.Encrypt;

import java.io.IOException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.util.Calendar;

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

import util.HexString;

public class EncryptUtil {
	
 public static final String PBKDF2_ALGORITHM = "PBKDF2WithHmacSHA1";
 
 // The following constants may be changed without breaking existing hashes.
 public static final int SALT_BYTE_SIZE = 24;
 public static final int HASH_BYTE_SIZE = 24;
 public static final int PBKDF2_ITERATIONS = 1000;
 
 public static final int ITERATION_INDEX = 0;
 public static final int SALT_INDEX = 1;
 public static final int PBKDF2_INDEX = 2;
 
 /**
 * Returns a salted PBKDF2 hash of the password.
 *
 * @param password the password to hash
 * @return a salted PBKDF2 hash of the password
 */
 public static String createPassword(String password)
 throws NoSuchAlgorithmException, InvalidKeySpecException
 {
 return createPassword(password.toCharArray());
 }
 
 /**
 * Returns a salted PBKDF2 hash of the password.
 *
 * @param password the password to hash
 * @return a salted PBKDF2 hash of the password
 */
 public static String createPassword(char[] password)
 throws NoSuchAlgorithmException, InvalidKeySpecException
 {
 // Generate a random salt
 SecureRandom random = new SecureRandom();
 byte[] salt = new byte[SALT_BYTE_SIZE];
 random.nextBytes(salt);
 
 // Hash the password
 byte[] hash = pbkdf2(password, salt, PBKDF2_ITERATIONS, HASH_BYTE_SIZE);
 // format iterations:salt:hash
 return PBKDF2_ITERATIONS + "@" + HexString.toHex(salt) + "@" + HexString.toHex(hash);
 }
 
 /**
 * Validates a password using a hash.
 *
 * @param password the password to check
 * @param correctHash the hash of the valid password
 * @return true if the password is correct, false if not
 */
 public static boolean validatePassword(String password, String correctHash)
 throws NoSuchAlgorithmException, InvalidKeySpecException
 {
 	System.out.println("password" + password + " correctHash" + correctHash);
 return validatePassword(password.toCharArray(), correctHash);
 }
 
 /**
 * Validates a password using a hash.
 *
 * @param password the password to check
 * @param correctHash the hash of the valid password
 * @return true if the password is correct, false if not
 */
 public static boolean validatePassword(char[] password, String correctHash)
 throws NoSuchAlgorithmException, InvalidKeySpecException
 {
 // Decode the hash into its parameters
 String[] params = correctHash.split("@");
 int iterations = Integer.parseInt(params[ITERATION_INDEX]);
 byte[] salt = HexString.fromHex(params[SALT_INDEX]);
 byte[] hash = HexString.fromHex(params[PBKDF2_INDEX]);
 // Compute the hash of the provided password, using the same salt,
 // iteration count, and hash length
 byte[] testHash = pbkdf2(password, salt, iterations, hash.length);
 // Compare the hashes in constant time. The password is correct if
 // both hashes match.
 return slowEquals(hash, testHash);
 }
 
 public static String createToken(int Expires, String device, String key) throws Exception {
 	Calendar cal = Calendar.getInstance();
 	cal.add(Calendar.DATE, Expires);
 	return DES.encrypt( getRandom() + "@" + device + "@" + cal.getTimeInMillis(),key);
	}
 
 public static boolean validateToken(Calendar Expires, String device,String token ,String key) throws IOException, Exception {
 	String content = DES.decrypt(token,key);
 	String[] pieces = content.split("@");
 	if( 3 == pieces.length )
 	{
 	String forDevice = pieces[1];
 		long preExpires = Long.parseLong(pieces[2]);
 	return (forDevice.equals(device) && preExpires > Expires.getTimeInMillis());
 	}
 	return false;
 }
 
 /**
 * Compares two byte arrays in length-constant time. This comparison method
 * is used so that password hashes cannot be extracted from an on-line
 * system using a timing attack and then attacked off-line.
 *
 * @param a the first byte array
 * @param b the second byte array
 * @return true if both byte arrays are the same, false if not
 */
 private static boolean slowEquals(byte[] a, byte[] b)
 {
 int diff = a.length ^ b.length;
 for(int i = 0; i < a.length && i < b.length; i++)
 diff |= a[i] ^ b[i];
 return diff == 0;
 }
 
 /**
 * Computes the PBKDF2 hash of a password.
 *
 * @param password the password to hash.
 * @param salt the salt
 * @param iterations the iteration count (slowness factor)
 * @param bytes the length of the hash to compute in bytes
 * @return the PBDKF2 hash of the password
 */
 private static byte[] pbkdf2(char[] password, byte[] salt, int iterations, int bytes)
 throws NoSuchAlgorithmException, InvalidKeySpecException
 {
 PBEKeySpec spec = new PBEKeySpec(password, salt, iterations, bytes * 8);
 SecretKeyFactory skf = SecretKeyFactory.getInstance(PBKDF2_ALGORITHM);
 return skf.generateSecret(spec).getEncoded();
 }
 
	/**
	 * 随机数的盐值
	 * @return
	 */
 private static String getRandom()
	{
	 //Always use a SecureRandom generator
	 SecureRandom sr;
		try {
			sr = SecureRandom.getInstance("SHA1PRNG");
		 //Create array for salt
		 byte[] salt = new byte[16];
		 //Get a random salt
		 sr.nextBytes(salt);
		 //return salt
		 return HexString.toHex(salt);
		 
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return null;
	}
 

}