1. /* 
    2.  * Password Hashing With PBKDF2 (http://crackstation.net/hashing-security.htm).
    3.  * Copyright (c) 2013, Taylor Hornby
    4.  * All rights reserved.
    5.  *
    6.  * Redistribution and use in source and binary forms, with or without 
    7.  * modification, are permitted provided that the following conditions are met:
    8.  *
    9.  * 1. Redistributions of source code must retain the above copyright notice, 
    10.  * this list of conditions and the following disclaimer.
    11.  *
    12.  * 2. Redistributions in binary form must reproduce the above copyright notice,
    13.  * this list of conditions and the following disclaimer in the documentation 
    14.  * and/or other materials provided with the distribution.
    15.  *
    16.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
    17.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
    18.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
    19.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
    20.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
    21.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
    22.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
    23.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
    24.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
    25.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
    26.  * POSSIBILITY OF SUCH DAMAGE.
    27.  */
    29. import java.security.SecureRandom;
    30. import javax.crypto.spec.PBEKeySpec;
    31. import javax.crypto.SecretKeyFactory;
    32. import java.math.BigInteger;
    33. import java.security.NoSuchAlgorithmException;
    34. import java.security.spec.InvalidKeySpecException;
    36. /*
    37.  * PBKDF2 salted password hashing.
    38.  * Author: havoc AT defuse.ca
    39.  * www: http://crackstation.net/hashing-security.htm
    40.  */
    41. public class PasswordHash {
    42.     public static final String PBKDF2_ALGORITHM = "PBKDF2WithHmacSHA1";
    44.     // The following constants may be changed without breaking existing hashes.
    45.     public static final int SALT_BYTE_SIZE = 24;
    46.     public static final int HASH_BYTE_SIZE = 24;
    47.     public static final int PBKDF2_ITERATIONS = 1000;
    49.     public static final int ITERATION_INDEX = 0;
    50.     public static final int SALT_INDEX = 1;
    51.     public static final int PBKDF2_INDEX = 2;
    53.     /**
    54.      * Returns a salted PBKDF2 hash of the password.
    55.      *
    56.      * @param   password    the password to hash
    57.      * @return              a salted PBKDF2 hash of the password
    58.      */
    59.     public static String createHash(String password)
    60.         throws NoSuchAlgorithmException, InvalidKeySpecException {
    61.         return createHash(password.toCharArray());
    62.     }
    64.     /**
    65.      * Returns a salted PBKDF2 hash of the password.
    66.      *
    67.      * @param   password    the password to hash
    68.      * @return              a salted PBKDF2 hash of the password
    69.      */
    70.     public static String createHash(char[] password)
    71.         throws NoSuchAlgorithmException, InvalidKeySpecException {
    72.         // Generate a random salt
    73.         SecureRandom random = new SecureRandom();
    74.         byte[] salt = new byte[SALT_BYTE_SIZE];
    75.         random.nextBytes(salt);
    77.         // Hash the password
    78.         byte[] hash = pbkdf2(password, salt, PBKDF2_ITERATIONS, HASH_BYTE_SIZE);
    79.         // format iterations:salt:hash
    80.         return PBKDF2_ITERATIONS + ":" + toHex(salt) + ":" +  toHex(hash);
    81.     }
    83.     /**
    84.      * Validates a password using a hash.
    85.      *
    86.      * @param   password        the password to check
    87.      * @param   correctHash     the hash of the valid password
    88.      * @return                  true if the password is correct, false if not
    89.      */
    90.     public static boolean validatePassword(String password, String correctHash)
    91.         throws NoSuchAlgorithmException, InvalidKeySpecException {
    92.         return validatePassword(password.toCharArray(), correctHash);
    93.     }
    95.     /**
    96.      * Validates a password using a hash.
    97.      *
    98.      * @param   password        the password to check
    99.      * @param   correctHash     the hash of the valid password
    100.      * @return                  true if the password is correct, false if not
    101.      */
    102.     public static boolean validatePassword(char[] password, String correctHash)
    103.         throws NoSuchAlgorithmException, InvalidKeySpecException {
    104.         // Decode the hash into its parameters
    105.         String[] params = correctHash.split(":");
    106.         int iterations = Integer.parseInt(params[ITERATION_INDEX]);
    107.         byte[] salt = fromHex(params[SALT_INDEX]);
    108.         byte[] hash = fromHex(params[PBKDF2_INDEX]);
    109.         // Compute the hash of the provided password, using the same salt, 
    110.         // iteration count, and hash length
    111.         byte[] testHash = pbkdf2(password, salt, iterations, hash.length);
    112.         // Compare the hashes in constant time. The password is correct if
    113.         // both hashes match.
    114.         return slowEquals(hash, testHash);
    115.     }
    117.     /**
    118.      * Compares two byte arrays in length-constant time. This comparison method
    119.      * is used so that password hashes cannot be extracted from an on-line 
    120.      * system using a timing attack and then attacked off-line.
    121.      * 
    122.      * @param   a       the first byte array
    123.      * @param   b       the second byte array 
    124.      * @return          true if both byte arrays are the same, false if not
    125.      */
    126.     private static boolean slowEquals(byte[] a, byte[] b) {
    127.         int diff = a.length ^ b.length;
    128.         for(int i = 0; i < a.length && i < b.length; i++)
    129.             diff |= a[i] ^ b[i];
    130.         return diff == 0;
    131.     }
    133.     /**
    134.      *  Computes the PBKDF2 hash of a password.
    135.      *
    136.      * @param   password    the password to hash.
    137.      * @param   salt        the salt
    138.      * @param   iterations  the iteration count (slowness factor)
    139.      * @param   bytes       the length of the hash to compute in bytes
    140.      * @return              the PBDKF2 hash of the password
    141.      */
    142.     private static byte[] pbkdf2(char[] password, byte[] salt, int iterations, int bytes)
    143.         throws NoSuchAlgorithmException, InvalidKeySpecException {
    144.         PBEKeySpec spec = new PBEKeySpec(password, salt, iterations, bytes * 8);
    145.         SecretKeyFactory skf = SecretKeyFactory.getInstance(PBKDF2_ALGORITHM);
    146.         return skf.generateSecret(spec).getEncoded();
    147.     }
    149.     /**
    150.      * Converts a string of hexadecimal characters into a byte array.
    151.      *
    152.      * @param   hex         the hex string
    153.      * @return              the hex string decoded into a byte array
    154.      */
    155.     private static byte[] fromHex(String hex) {
    156.         byte[] binary = new byte[hex.length() / 2];
    157.         for(int i = 0; i < binary.length; i++) {
    158.             binary[i] = (byte)Integer.parseInt(hex.substring(2*i, 2*i+2), 16);
    159.         }
    160.         return binary;
    161.     }
    163.     /**
    164.      * Converts a byte array into a hexadecimal string.
    165.      *
    166.      * @param   array       the byte array to convert
    167.      * @return              a length*2 character string encoding the byte array
    168.      */
    169.     private static String toHex(byte[] array) {
    170.         BigInteger bi = new BigInteger(1, array);
    171.         String hex = bi.toString(16);
    172.         int paddingLength = (array.length * 2) - hex.length();
    173.         if(paddingLength > 0) 
    174.             return String.format("%0" + paddingLength + "d", 0) + hex;
    175.         else
    176.             return hex;
    177.     }
    179.     /**
    180.      * Tests the basic functionality of the PasswordHash class
    181.      *
    182.      * @param   args        ignored
    183.      */
    184.     public static void main(String[] args) {
    185.         try {
    186.             // Print out 10 hashes
    187.             for(int i = 0; i < 10; i++)
    188.                 System.out.println(PasswordHash.createHash("p\r\nassw0Rd!"));
    190.             // Test password validation
    191.             boolean failure = false;
    192.             System.out.println("Running tests...");
    193.             for(int i = 0; i < 100; i++) {
    194.                 String password = ""+i;
    195.                 String hash = createHash(password);
    196.                 String secondHash = createHash(password);
    197.                 if(hash.equals(secondHash)) {
    198.                     System.out.println("FAILURE: TWO HASHES ARE EQUAL!");
    199.                     failure = true;
    200.                 }
    201.                 String wrongPassword = ""+(i+1);
    202.                 if(validatePassword(wrongPassword, hash)) {
    203.                     System.out.println("FAILURE: WRONG PASSWORD ACCEPTED!");
    204.                     failure = true;
    205.                 }
    206.                 if(!validatePassword(password, hash)) {
    207.                     System.out.println("FAILURE: GOOD PASSWORD NOT ACCEPTED!");
    208.                     failure = true;
    209.                 }
    210.             }
    211.             if(failure)
    212.                 System.out.println("TESTS FAILED!");
    213.             else
    214.                 System.out.println("TESTS PASSED!");
    215.         } catch(Exception ex) {
    216.             System.out.println("ERROR: " + ex);
    217.         }
    218.     }
    219. }