Configurable password hashing algorithm/cost

server/src/main/java/org/elasticsearch/common/settings/Setting.java

@@ -1023,7 +1023,7 @@ public static Setting<String> simpleString(String key, Validator<String> validat
      * @param key          the settings key for this setting.
      * @param defaultValue the default String value.
      * @param properties   properties for this setting like scope, filtering...
-     * @return
+     * @return the Setting Object
      */
     public static Setting<String> simpleString(String key, String defaultValue, Property... properties) {
         return new Setting<>(key, s -> defaultValue, Function.identity(), properties);

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/XPackSettings.java

@@ -8,6 +8,7 @@
 import org.elasticsearch.common.settings.Setting;
 import org.elasticsearch.common.settings.Setting.Property;
 import org.elasticsearch.xpack.core.security.SecurityField;
+import org.elasticsearch.xpack.core.security.authc.support.Hasher;
 import org.elasticsearch.xpack.core.ssl.SSLClientAuth;
 import org.elasticsearch.xpack.core.ssl.SSLConfigurationSettings;
 import org.elasticsearch.xpack.core.ssl.VerificationMode;
@@ -19,6 +20,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Function;
 
 import static org.elasticsearch.xpack.core.security.SecurityField.USER_SETTING;
 
@@ -110,8 +112,16 @@ private XPackSettings() {
         DEFAULT_CIPHERS = ciphers;
     }
 
-    public static final Setting<String> PASSWORD_HASHING_ALGORITHM = Setting.simpleString(
-        "xpack.security.authc.password_hashing.algorithm", "bcrypt", Setting.Property.NodeScope);
+    /*
+     * Do not allow insecure hashing algorithms to be used for password hashing
+     */
+    public static final Setting<String> PASSWORD_HASHING_ALGORITHM = new Setting<>(
+        "xpack.security.authc.password_hashing.algorithm", "bcrypt", Function.identity(), (v, s) -> {
+        if (Hasher.getAvailableAlgoStoredHash().contains(v) == false) {
+            throw new IllegalArgumentException("Invalid algorithm: " + v + ". Only pbkdf2 or bcrypt family algorithms can be used for " +
+                "password hashing.");
+        }
+    }, Setting.Property.NodeScope);
 
     public static final List<String> DEFAULT_SUPPORTED_PROTOCOLS = Arrays.asList("TLSv1.2", "TLSv1.1", "TLSv1");
     public static final SSLClientAuth CLIENT_AUTH_DEFAULT = SSLClientAuth.REQUIRED;

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/security/authc/support/Hasher.java

@@ -20,7 +20,6 @@
 import java.util.Base64;
 import java.util.List;
 import java.util.Locale;
-import java.util.Random;
 import java.util.stream.Collectors;
 
 public enum Hasher {
@@ -370,8 +369,18 @@ public boolean verify(SecureString text, char[] hash) {
     private static final String SSHA256_PREFIX = "{SSHA256}";
     private static final String PBKDF2_PREFIX = "{PBKDF2}";
     private static final int PBKDF2_DEFAULT_COST = 10000;
-    private static final int PBKDF2_KEY_LENGTH = 256;
+    private static final int BCRYPT_DEFAULT_COST = 10;
+    private static final SecureRandom SECURE_RANDOM = new SecureRandom();
 
+    /**
+     * Returns a {@link Hasher} instance of the appropriate algorithm and associated cost as
+     * indicated by the {@code name}. Name identifiers for the default costs for
+     * BCRYPT and PBKDF2 return the he default BCRYPT and PBKDF2 Hasher instead of the specific
+     * instances for the associated cost.
+     *
+     * @param name The name of the algorithm and cost combination identifier
+     * @return the hasher associated with the identifier
+     */
     public static Hasher resolve(String name) {
         switch (name.toLowerCase(Locale.ROOT)) {
             case "bcrypt":
@@ -389,7 +398,7 @@ public static Hasher resolve(String name) {
             case "bcrypt9":
                 return BCRYPT9;
             case "bcrypt10":
-                return BCRYPT10;
+                return BCRYPT;
             case "bcrypt11":
                 return BCRYPT11;
             case "bcrypt12":
@@ -403,7 +412,7 @@ public static Hasher resolve(String name) {
             case "pbkdf2_1000":
                 return PBKDF2_1000;
             case "pbkdf2_10000":
-                return PBKDF2_10000;
+                return PBKDF2;
             case "pbkdf2_50000":
                 return PBKDF2_50000;
             case "pbkdf2_100000":
@@ -429,28 +438,25 @@ public static Hasher resolve(String name) {
     /**
      * Returns a {@link Hasher} instance that can be used to verify the {@code hash} by inspecting the
      * hash prefix and determining the algorithm used for its generation.
-     * The default BCRYPT and PBKDF2 Hashers are used for verifying all the hashes of these algorithm
-     * families, instead of the specific instances for the given cost factor, as the cost factor is
-     * deduced from the hash and all {@link Hasher} share the same {@link #verifyPbkdf2Hash(SecureString, char[]) verifyPbkdf2Hash}
-     * and {@link #verifyBcryptHash(SecureString, char[]) verifyBcryptHash} methods respectively.
      *
      * @param hash the char array from which the hashing algorithm is to be deduced
      * @return the hasher that can be used for validation
      */
     public static Hasher resolveFromHash(char[] hash) {
-        String hashString = new String(hash);
-        if (hashString.startsWith(BCRYPT_PREFIX)) {
-            return Hasher.BCRYPT;
-        } else if (hashString.startsWith(PBKDF2_PREFIX)) {
-            return Hasher.PBKDF2;
-        } else if (hashString.startsWith(SHA1_PREFIX)) {
+        if (CharArrays.charsBeginsWith(BCRYPT_PREFIX, hash)) {
+            int cost = Integer.parseInt(new String(Arrays.copyOfRange(hash, BCRYPT_PREFIX.length(), hash.length - 54)));
+            return cost == BCRYPT_DEFAULT_COST ? Hasher.BCRYPT : resolve("bcrypt" + cost);
+        } else if (CharArrays.charsBeginsWith(PBKDF2_PREFIX, hash)) {
+            int cost = Integer.parseInt(new String(Arrays.copyOfRange(hash, PBKDF2_PREFIX.length(), hash.length - 90)));
+            return cost == PBKDF2_DEFAULT_COST ? Hasher.PBKDF2 : resolve("pbkdf2_" + cost);
+        } else if (CharArrays.charsBeginsWith(SHA1_PREFIX, hash)) {
             return Hasher.SHA1;
-        } else if (hashString.startsWith(MD5_PREFIX)) {
+        } else if (CharArrays.charsBeginsWith(MD5_PREFIX, hash)) {
             return Hasher.MD5;
-        } else if (hashString.startsWith(SSHA256_PREFIX)) {
+        } else if (CharArrays.charsBeginsWith(SSHA256_PREFIX, hash)) {
             return Hasher.SSHA256;
         } else {
-            throw new IllegalArgumentException("unknown hash format for hash [" + hashString + "]");
+            throw new IllegalArgumentException("unknown hash format for hash [" + new String(hash) + "]");
         }
     }
 
@@ -495,8 +501,8 @@ private static char[] getPbkdf2Hash(SecureString data, int cost) {
     private static boolean verifyPbkdf2Hash(SecureString data, char[] hash) {
         // Base64 string length : (4*(n/3)) rounded up to the next multiple of 4 because of padding,  i.e. 44 for 32 bytes
         final int tokenLength = 44;
-        char[] hashChars = new char[tokenLength];
-        char[] saltChars = new char[tokenLength];
+        char[] hashChars = null;
+        char[] saltChars = null;
         try {
             if (CharArrays.charsBeginsWith(PBKDF2_PREFIX, hash) == false) {
                 return false;
@@ -506,17 +512,21 @@ private static boolean verifyPbkdf2Hash(SecureString data, char[] hash) {
             int cost = Integer.parseInt(new String(Arrays.copyOfRange(hash, PBKDF2_PREFIX.length(), hash.length - (2 * tokenLength + 2))));
             SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("PBKDF2withHMACSHA512");
             PBEKeySpec keySpec = new PBEKeySpec(data.getChars(), Base64.getDecoder().decode(CharArrays.toUtf8Bytes(saltChars)),
-                cost, PBKDF2_KEY_LENGTH);
+                cost, 256);
             char[] computedPwdHash = CharArrays.utf8BytesToChars(Base64.getEncoder()
                 .encode(secretKeyFactory.generateSecret(keySpec).getEncoded()));
-            boolean result = CharArrays.constantTimeEquals(computedPwdHash, hashChars);
+            final boolean result = CharArrays.constantTimeEquals(computedPwdHash, hashChars);
             Arrays.fill(computedPwdHash, '\u0000');
             return result;
         } catch (InvalidKeySpecException | NoSuchAlgorithmException e) {
             throw new ElasticsearchException("Can't use PBKDF2 for password hashing", e);
         } finally {
-            Arrays.fill(hashChars, '\u0000');
-            Arrays.fill(saltChars, '\u0000');
+            if (null != hashChars) {
+                Arrays.fill(hashChars, '\u0000');
+            }
+            if (null != saltChars) {
+                Arrays.fill(saltChars, '\u0000');
+            }
         }
     }
 
@@ -547,9 +557,8 @@ public static List<String> getAvailableAlgoStoredHash() {
      * Generates an array of {@code length} random bytes using {@link java.security.SecureRandom}
      */
     private static byte[] generateSalt(int length) {
-        Random random = new SecureRandom();
         byte[] salt = new byte[length];
-        random.nextBytes(salt);
+        SECURE_RANDOM.nextBytes(salt);
         return salt;
     }
 

x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/PasswordHashingAlgorithmBootstrapCheck.java

@@ -8,7 +8,6 @@
 import org.elasticsearch.bootstrap.BootstrapCheck;
 import org.elasticsearch.bootstrap.BootstrapContext;
 import org.elasticsearch.xpack.core.XPackSettings;
-import org.elasticsearch.xpack.core.security.authc.support.Hasher;
 
 import javax.crypto.SecretKeyFactory;
 import java.security.NoSuchAlgorithmException;
@@ -22,11 +21,6 @@ public class PasswordHashingAlgorithmBootstrapCheck implements BootstrapCheck {
     @Override
     public BootstrapCheckResult check(BootstrapContext context) {
         final String selectedAlgorithm = XPackSettings.PASSWORD_HASHING_ALGORITHM.get(context.settings);
-        if (Hasher.getAvailableAlgoStoredHash().contains(selectedAlgorithm.toLowerCase(Locale.ROOT)) == false) {
-            final String errorMessage = String.format(Locale.ROOT, "Only the following values [%s] are permitted for the [%s] setting. ",
-                Hasher.getAvailableAlgoStoredHash(), XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey());
-            return BootstrapCheckResult.failure(errorMessage);
-        }
         if (selectedAlgorithm.toLowerCase(Locale.ROOT).startsWith("pbkdf2")) {
             try {
                 SecretKeyFactory.getInstance("PBKDF2withHMACSHA512");

x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/Security.java

@@ -283,8 +283,8 @@ public Security(Settings settings, final Path configPath) {
             // fetched
             final List<BootstrapCheck> checks = new ArrayList<>();
             checks.addAll(Arrays.asList(
-                    new TokenSSLBootstrapCheck(),
-                    new PkiRealmBootstrapCheck(settings, getSslService()),
+                new TokenSSLBootstrapCheck(),
+                new PkiRealmBootstrapCheck(settings, getSslService()),
                 new TLSLicenseBootstrapCheck(),
                 new PasswordHashingAlgorithmBootstrapCheck()));
             checks.addAll(InternalRealms.getBootstrapChecks(settings, env));

x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/action/user/TransportChangePasswordAction.java

@@ -12,9 +12,11 @@
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.tasks.Task;
 import org.elasticsearch.transport.TransportService;
+import org.elasticsearch.xpack.core.XPackSettings;
 import org.elasticsearch.xpack.core.security.action.user.ChangePasswordAction;
 import org.elasticsearch.xpack.core.security.action.user.ChangePasswordRequest;
 import org.elasticsearch.xpack.core.security.action.user.ChangePasswordResponse;
+import org.elasticsearch.xpack.core.security.authc.support.Hasher;
 import org.elasticsearch.xpack.core.security.user.AnonymousUser;
 import org.elasticsearch.xpack.core.security.user.SystemUser;
 import org.elasticsearch.xpack.core.security.user.XPackUser;
@@ -41,6 +43,13 @@ protected void doExecute(Task task, ChangePasswordRequest request, ActionListene
             listener.onFailure(new IllegalArgumentException("user [" + username + "] is internal"));
             return;
         }
+        final String requestPwdHashAlgo = Hasher.resolveFromHash(request.passwordHash()).name();
+        final String configPwdHashAlgo = Hasher.resolve(XPackSettings.PASSWORD_HASHING_ALGORITHM.get(settings)).name();
+        if (requestPwdHashAlgo.equalsIgnoreCase(configPwdHashAlgo) == false) {
+            listener.onFailure(new IllegalArgumentException("incorrect password hashing algorithm [" + requestPwdHashAlgo + "] used while" +
+                " [" + configPwdHashAlgo + "] is configured."));
+            return;
+        }
         nativeUsersStore.changePassword(request, new ActionListener<Void>() {
             @Override
             public void onResponse(Void v) {

x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/PasswordHashingAlgorithmBootstrapCheckTests.java

@@ -17,7 +17,7 @@ public class PasswordHashingAlgorithmBootstrapCheckTests extends ESTestCase {
     public void testPasswordHashingAlgorithmBootstrapCheck() {
         Settings settings = Settings.EMPTY;
         assertFalse(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).isFailure());
-
+        // The following two will always pass because for now we only test in environments where PBKDF2WithHMACSHA512 is supported
         settings = Settings.builder().put(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey(), "PBKDF2_10000").build();
         assertFalse(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).isFailure());
 
@@ -29,26 +29,5 @@ public void testPasswordHashingAlgorithmBootstrapCheck() {
 
         settings = Settings.builder().put(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey(), "BCRYPT11").build();
         assertFalse(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).isFailure());
-
-        settings = Settings.builder().put(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey(), "SHA1").build();
-        assertTrue(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).isFailure());
-        assertThat(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).getMessage(),
-            containsString(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey()));
-
-        settings = Settings.builder().put(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey(), "MD5").build();
-        assertTrue(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).isFailure());
-        assertThat(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).getMessage(),
-            containsString(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey()));
-
-        settings = Settings.builder().put(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey(), "SSHA256").build();
-        assertTrue(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).isFailure());
-        assertThat(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).getMessage(),
-            containsString(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey()));
-
-        settings = Settings.builder().put(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey(), "Argon").build();
-        assertTrue(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).isFailure());
-        assertThat(new PasswordHashingAlgorithmBootstrapCheck().check(new BootstrapContext(settings, null)).getMessage(),
-            containsString(XPackSettings.PASSWORD_HASHING_ALGORITHM.getKey()));
-
     }
 }