PBKDF2WithHmacSHA1算法

主要用于明文密码加密字符串存入数据库。由棱镜门思考。目前大部分企业中都是明文密码。一旦被攻破。危害非常大。现在主流加密技术是MD5加密。不过MD5的存在小概率碰撞(根据密码学的定义，如果内容不同的明文，通过散列算法得出的结果（密码学称为信息摘要）相同，就称为发生了“碰撞”。).如何生成md5碰撞的算法论文http://www.infosec.sdu.edu.cn/paper/md5-attack.pdf。一些黑客破获密码的方法是一种被称为“跑字典”的方法。有两种方法得到字典，一种是日常搜集的用做密码的字符串表，另一种是用排列组合方法生成的，先用MD5程序计算出这些字典项的MD5值，然后再用目标的MD5值在这个字典中检索。即使假设密码的最大长度为8，同时密码只能是字母和数字，共26+26+10=62个字符，排列组合出的字典的项数则是P(62,1)+P (62,2)….+P(62,8)，那也已经是一个很天文的数字了，存储这个字典就需要TB级的磁盘组，而且这种方法还有一个前提，就是能获得目标账户的 密码MD5值的情况下才可以。当如果用户的密码是弱密码的就很危险了。

　　PBKDF2WithHmacSHA1算法比MD5算法更安全。它可以同样密码在不同时间生成不同加密Hash。跑字典将无效。下面是算法Demo。

 package hashpassword;
 import java.security.SecureRandom;
 import javax.crypto.spec.PBEKeySpec;
 import javax.crypto.SecretKeyFactory;
 import java.math.BigInteger;
 import java.security.NoSuchAlgorithmException;
 import java.security.spec.InvalidKeySpecException;

 /*
  * PBKDF2 salted password hashing.
  * Author: havoc AT defuse.ca
  * www: http://crackstation.net/hashing-security.htm
  */
 public class PasswordHash
 {
     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 = 10;

     public static final int ITERATION_INDEX = 0;
     public static final int SALT_INDEX = 1;
     public static final int PBKDF2_INDEX = 2;

     public static String createHash(String password)
         throws NoSuchAlgorithmException, InvalidKeySpecException
     {
         return createHash(password.toCharArray());
     }

     /**
      * Returns a salted PBKDF2 hash of the password.
      * 返回一个加盐后的PBKDF2哈希密码
      * @param   password    the password to hash
      * @return              a salted PBKDF2 hash of the password
      */
     public static String createHash(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 + ":" + toHex(salt) + ":" +  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
     {
         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 = fromHex(params[SALT_INDEX]);
         byte[] hash = 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);
     }

     /**
      * 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.
      *  计算PBKDF2哈希密码
      * @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();
     }

     /**
      * Converts a string of hexadecimal characters into a byte array.
      *
      * @param   hex         the hex string
      * @return              the hex string decoded into a byte array
      */
     private static byte[] fromHex(String hex)
     {
         byte[] binary = new byte[hex.length() / 2];
         for(int i = 0; i < binary.length; i++)
         {
             binary[i] = (byte)Integer.parseInt(hex.substring(2*i, 2*i+2), 16);
         }
         return binary;
     }

     /**
      * Converts a byte array into a hexadecimal string.
      *
      * @param   array       the byte array to convert
      * @return              a length*2 character string encoding the byte array
      */
     private static String toHex(byte[] array)
     {
         BigInteger bi = new BigInteger(1, array);
         String hex = bi.toString(16);
         int paddingLength = (array.length * 2) - hex.length();
         if(paddingLength > 0)
             return String.format("%0" + paddingLength + "d", 0) + hex;
         else
             return hex;
     }

     /**
      * Tests the basic functionality of the PasswordHash class
      *
      * @param   args        ignored
      */
     public static void main(String[] args)
     {
         try
         {
             // Print out 10 hashes
             for(int i = 0; i < 10; i++)
                 System.out.println(PasswordHash.createHash("p\r\nassw0Rd!"));

             // Test password validation
             boolean failure = false;
             System.out.println("Running tests...");
             for(int i = 0; i < 100; i++)
             {
                 String password = ""+i;
                 String hash = createHash(password);
                 String secondHash = createHash(password);
                 if(hash.equals(secondHash)) {
                     System.out.println("FAILURE: TWO HASHES ARE EQUAL!");
                     failure = true;
                 }
                 String wrongPassword = ""+(i+1);
                 if(validatePassword(wrongPassword, hash)) {
                     System.out.println("FAILURE: WRONG PASSWORD ACCEPTED!");
                     failure = true;
                 }
                 if(!validatePassword(password, hash)) {
                     System.out.println("FAILURE: GOOD PASSWORD NOT ACCEPTED!");
                     failure = true;
                 }
             }
             if(failure)
                 System.out.println("TESTS FAILED!");
             else
                 System.out.println("TESTS PASSED!");
         }
         catch(Exception ex)
         {
             System.out.println("ERROR: " + ex);
         }
     }

 }

https://crackstation.net/hashing-security.htm