Merge pull request #4857 from gchq/datafeed-keys-add-bcrypt

Add BCrupt hasher, change the way datafeed key auth works

Author: at055612

gradle/libs.versions.toml

@@ -36,7 +36,7 @@ aws-crt = { module = "software.amazon.awssdk.crt:aws-crt", version = "0.29.22" }
 aws-s3-transfer-manager = { module = "software.amazon.awssdk:s3-transfer-manager" } # version controlled by AWS BOM
 aws-sqs = { module = "software.amazon.awssdk:sqs" } # version controlled by AWS BOM
 aws-sts = { module = "software.amazon.awssdk:sts" } # version controlled by AWS BOM
-bcrypt = { module = "de.svenkubiak:jBCrypt", version = "0.4.1" }
+bcrypt = { module = "de.svenkubiak:jBCrypt", version = "0.4.3" }
 bouncy-castle = { module = "org.bouncycastle:bcprov-jdk18on", version = "1.78.1" }
 caffeine = { module = "com.github.ben-manes.caffeine:caffeine" } # version controlled by dropwizard-dependencies
 commons-beanutils = { module = "commons-beanutils:commons-beanutils", version = "1.9.4" }

stroom-receive/stroom-receive-common/src/main/java/stroom/receive/common/Argon2DataFeedKeyHasher.java

@@ -1,12 +1,14 @@
 package stroom.receive.common;
 
-import stroom.util.string.Base58;
+import stroom.util.string.StringUtil;
 
+import org.apache.commons.codec.binary.Hex;
 import org.bouncycastle.crypto.generators.Argon2BytesGenerator;
 import org.bouncycastle.crypto.params.Argon2Parameters;
 import org.bouncycastle.crypto.params.Argon2Parameters.Builder;
 
 import java.nio.charset.StandardCharsets;
+import java.security.SecureRandom;
 import java.util.Objects;
 
 class Argon2DataFeedKeyHasher implements DataFeedKeyHasher {
@@ -20,23 +22,33 @@ class Argon2DataFeedKeyHasher implements DataFeedKeyHasher {
     private static final int MEMORY_KB = 65_536;
     private static final int PARALLELISM = 1;
 
-    private final Argon2Parameters argon2Parameters;
+    private final SecureRandom secureRandom;
 
     public Argon2DataFeedKeyHasher() {
-        // No salt given the length of api keys being hashed
-        this.argon2Parameters = new Builder(Argon2Parameters.ARGON2_id)
+        this.secureRandom = new SecureRandom();
+    }
+
+    @Override
+    public HashOutput hash(final String dataFeedKey) {
+        final String randomSalt = StringUtil.createRandomCode(
+                secureRandom,
+                32,
+                StringUtil.ALLOWED_CHARS_BASE_58_STYLE);
+        return hash(dataFeedKey, randomSalt);
+    }
+
+    public HashOutput hash(final String dataFeedKey, final String salt) {
+        final Argon2Parameters params = new Builder(Argon2Parameters.ARGON2_id)
                 .withVersion(Argon2Parameters.ARGON2_VERSION_13)
                 .withIterations(ITERATIONS)
                 .withMemoryAsKB(MEMORY_KB)
                 .withParallelism(PARALLELISM)
+                .withSalt(salt.getBytes(StandardCharsets.UTF_8))
                 .build();
-    }
 
-    @Override
-    public String hash(final String dataFeedKey) {
         Objects.requireNonNull(dataFeedKey);
-        Argon2BytesGenerator generator = new Argon2BytesGenerator();
-        generator.init(argon2Parameters);
+        final Argon2BytesGenerator generator = new Argon2BytesGenerator();
+        generator.init(params);
         byte[] result = new byte[HASH_LENGTH];
         generator.generateBytes(
                 dataFeedKey.trim().getBytes(StandardCharsets.UTF_8),
@@ -46,7 +58,16 @@ public String hash(final String dataFeedKey) {
 
         // Base58 is a bit less nasty than base64 and widely supported in other languages
         // due to use in bitcoin.
-        return Base58.encode(result);
+        final String hash = Hex.encodeHexString(result);
+        return new HashOutput(hash, salt);
+    }
+
+    @Override
+    public boolean verify(final String dataFeedKey, final String hash, final String salt) {
+        Objects.requireNonNull(dataFeedKey);
+        Objects.requireNonNull(hash);
+        final HashOutput hashOutput = hash(dataFeedKey, salt);
+        return Objects.equals(hash, hashOutput.hash());
     }
 
     @Override

stroom-receive/stroom-receive-common/src/main/java/stroom/receive/common/BCryptDataFeedKeyHasher.java

@@ -0,0 +1,34 @@
+package stroom.receive.common;
+
+import stroom.util.shared.NullSafe;
+
+import org.mindrot.jbcrypt.BCrypt;
+
+import java.security.SecureRandom;
+import java.util.Objects;
+
+public class BCryptDataFeedKeyHasher implements DataFeedKeyHasher {
+
+    private final SecureRandom secureRandom = new SecureRandom();
+
+    @Override
+    public HashOutput hash(final String dataFeedKey) {
+        final String generatedSalt = BCrypt.gensalt(10, secureRandom);
+        final String hash = BCrypt.hashpw(Objects.requireNonNull(dataFeedKey), generatedSalt);
+        return new HashOutput(hash, generatedSalt);
+    }
+
+    @Override
+    public boolean verify(final String dataFeedKey, final String hash, final String salt) {
+        if (NullSafe.isEmptyString(dataFeedKey)) {
+            return false;
+        } else {
+            return BCrypt.checkpw(dataFeedKey, hash);
+        }
+    }
+
+    @Override
+    public DataFeedKeyHashAlgorithm getAlgorithm() {
+        return DataFeedKeyHashAlgorithm.BCRYPT_2A;
+    }
+}

stroom-receive/stroom-receive-common/src/main/java/stroom/receive/common/CachedHashedDataFeedKey.java

@@ -37,16 +37,23 @@ public Path getSourceFile() {
 
     /**
      * @return The hash of the data feed key. The hash algorithm used is defined by
-     * {@link CachedHashedDataFeedKey#getHashAlgorithmId()}
+     * {@link CachedHashedDataFeedKey#getHashAlgorithm()}
      */
     @NotBlank
     public String getHash() {
         return hashedDataFeedKey.getHash();
     }
 
+    /**
+     * @return May be null if the algorithm encodes the salt in the hash
+     */
+    public String getSalt() {
+        return hashedDataFeedKey.getSalt();
+    }
+
     @NotBlank
-    public String getHashAlgorithmId() {
-        return hashedDataFeedKey.getHashAlgorithmId();
+    public DataFeedKeyHashAlgorithm getHashAlgorithm() {
+        return hashedDataFeedKey.getHashAlgorithm();
     }
 
     /**

stroom-receive/stroom-receive-common/src/main/java/stroom/receive/common/DataFeedKeyHashAlgorithm.java

@@ -13,7 +13,7 @@
 public enum DataFeedKeyHashAlgorithm implements HasDisplayValue {
     // uniqueIds should be
     ARGON2("Argon2", 0),
-//        BCRYPT("BCrypt", 0),
+    BCRYPT_2A("BCrypt (2a)", 1),
     ;
 
     private static final DataFeedKeyHashAlgorithm[] SPARSE_ALGORITHM_ARRAY;

stroom-receive/stroom-receive-common/src/main/java/stroom/receive/common/DataFeedKeyHasher.java

@@ -1,13 +1,40 @@
 package stroom.receive.common;
 
+import java.util.Objects;
+
 interface DataFeedKeyHasher {
 
-    String hash(String dataFeedKey);
+    /**
+     * Generate the hash of a datafeed key.
+     *
+     * @param dataFeedKey The datafeed key to generate a hash for
+     * @return The hash and the salt used.
+     */
+    HashOutput hash(String dataFeedKey);
 
-//        default boolean verify(String apiKeyStr, String hash) {
-//            final String computedHash = hash(Objects.requireNonNull(apiKeyStr));
-//            return Objects.equals(Objects.requireNonNull(hash), computedHash);
-//        }
+    /**
+     * Verify a dataFeedKey against its hash, and if provided include its salt.
+     *
+     * @param dataFeedKey The datafeed key
+     * @param hash        The hash to verify against.
+     * @param salt        An optional salt to include in the verification
+     * @return True if verification is successful
+     */
+    default boolean verify(String dataFeedKey, String hash, String salt) {
+        final HashOutput hashOutput = hash(Objects.requireNonNull(dataFeedKey));
+        return Objects.equals(Objects.requireNonNull(hash), hashOutput.hash);
+    }
 
+    /**
+     * @return The enum representing this hash algorithm.
+     */
     DataFeedKeyHashAlgorithm getAlgorithm();
+
+
+    // --------------------------------------------------------------------------------
+
+
+    record HashOutput(String hash, String salt) {
+
+    }
 }