Light, fluffy, and always free - The AWS Local Emulator alternative
test(auth): add SigV4 validator unit tests for RDS and ElastiCache proxies (#361)
TiMc227c3cd4afa
diff --git a/pom.xml b/pom.xmlindex 6a1a7fb9ca..0a0769568d 100644--- a/pom.xml+++ b/pom.xml@@ -27,6 +27,13 @@<type>pom</type><scope>import</scope></dependency>+ <dependency>+ <groupId>software.amazon.awssdk</groupId>+ <artifactId>bom</artifactId>+ <version>2.42.24</version>+ <type>pom</type>+ <scope>import</scope>+ </dependency></dependencies></dependencyManagement>@@ -143,6 +150,12 @@<artifactId>rest-assured</artifactId><scope>test</scope></dependency>+ <!-- AWS SDK for independent SigV4 oracle in validator tests -->+ <dependency>+ <groupId>software.amazon.awssdk</groupId>+ <artifactId>rds</artifactId>+ <scope>test</scope>+ </dependency></dependencies><build>diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/proxy/SigV4ValidatorTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/proxy/SigV4ValidatorTest.javanew file mode 100644index 0000000000..7d5ee96269--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/proxy/SigV4ValidatorTest.java@@ -0,0 +1,173 @@+package io.github.hectorvent.floci.services.elasticache.proxy;++import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.testutil.IamServiceTestHelper;+import io.github.hectorvent.floci.testutil.SigV4TokenTestHelper;+import org.junit.jupiter.api.Test;++import java.time.Instant;++import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++class SigV4ValidatorTest {++ @Test+ void validateAcceptsTokenForMatchingReplicationGroup() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(60),+ 900+ );++ assertTrue(validator.validate(token, "cache-cluster-01"));+ assertTrue(validator.validate(token, "CACHE-CLUSTER-01"));+ }++ @Test+ void validateRejectsTokenForDifferentReplicationGroup() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(60),+ 900+ );++ assertFalse(validator.validate(token, "other-cluster"));+ }++ @Test+ void validateRejectsTamperedSignature() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String validToken = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(60),+ 900+ );+ String tamperedToken = validToken.replace("User=default", "User=other");++ assertFalse(validator.validate(tamperedToken, "cache-cluster-01"));+ }++ @Test+ void validateAcceptsTokenWhenExpectedGroupIsNull() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(60),+ 900+ );++ assertTrue(validator.validate(token, null));+ }++ @Test+ void validateRejectsExpiredToken() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(1200),+ 900+ );++ assertFalse(validator.validate(token, "cache-cluster-01"));+ }++ @Test+ void validateRejectsTokenWithUnknownAccessKey() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDUNKNOWN",+ "wrong-secret",+ Instant.now().minusSeconds(60),+ 900+ );++ assertFalse(validator.validate(token, "cache-cluster-01"));+ }++ @Test+ void validateAcceptsTokenWithUrlEncodedUser() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ // Username with characters that require URL encoding exercises the+ // encoding path independently of the validator's decode logic+ String token = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "[email protected]",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(60),+ 900+ );++ assertTrue(validator.validate(token, "cache-cluster-01"));+ }++ @Test+ void validateRejectsTokenMissingActionParameter() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String validToken = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(60),+ 900+ );+ String withoutAction = validToken.replaceFirst("Action=connect&", "");++ assertFalse(validator.validate(withoutAction, "cache-cluster-01"));+ }++ @Test+ void validateRejectsTokenMissingSignatureParameter() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDCACHE", "secret-cache");++ SigV4Validator validator = new SigV4Validator(iamService);+ String validToken = SigV4TokenTestHelper.createElastiCacheToken(+ "cache-cluster-01",+ "default",+ "AKIDCACHE",+ "secret-cache",+ Instant.now().minusSeconds(60),+ 900+ );+ String withoutSignature = validToken.replaceFirst("&X-Amz-Signature=[0-9a-f]+", "");++ assertFalse(validator.validate(withoutSignature, "cache-cluster-01"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsSigV4ValidatorTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsSigV4ValidatorTest.javanew file mode 100644index 0000000000..16c6da4aa8--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsSigV4ValidatorTest.java@@ -0,0 +1,219 @@+package io.github.hectorvent.floci.services.rds.proxy;++import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.testutil.IamServiceTestHelper;+import io.github.hectorvent.floci.testutil.SigV4TokenTestHelper;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.rds.RdsUtilities;+import software.amazon.awssdk.services.rds.model.GenerateAuthenticationTokenRequest;++import java.time.Instant;++import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++class RdsSigV4ValidatorTest {++ /**+ * Uses the real AWS SDK RDS presigner as an independent SigV4 oracle.+ * If this test passes, the validator is compatible with tokens generated+ * by actual AWS SDK clients, not just our hand-rolled test helper.+ */+ @Test+ void validateAcceptsTokenFromAwsSdkPresigner() throws Exception {+ String accessKeyId = "AKIAORACLETEST";+ String secretAccessKey = "oracle-secret-key-value";+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey(accessKeyId, secretAccessKey);++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);++ RdsUtilities utilities = RdsUtilities.builder()+ .credentialsProvider(StaticCredentialsProvider.create(+ AwsBasicCredentials.create(accessKeyId, secretAccessKey)))+ .region(Region.US_EAST_1)+ .build();++ String sdkToken = utilities.generateAuthenticationToken(+ GenerateAuthenticationTokenRequest.builder()+ .hostname("db.oracle-test.local")+ .port(5432)+ .username("testuser")+ .build());++ assertTrue(validator.validate(sdkToken),+ "Validator must accept tokens generated by the official AWS SDK RDS presigner");+ }++ @Test+ void validateAcceptsTokenSignedWithHostAndPort() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(60),+ 900+ );++ assertTrue(validator.validate(token));+ }++ @Test+ void validateRejectsTokenWhenSignedForHostWithoutPort() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String validToken = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(60),+ 900+ );+ String brokenToken = validToken.replace("db.example.local:5432/?", "db.example.local/?");++ assertFalse(validator.validate(brokenToken));+ }++ @Test+ void validateRejectsExpiredToken() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(1200),+ 900+ );++ assertFalse(validator.validate(token));+ }++ @Test+ void validateRejectsTamperedSignature() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String validToken = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(60),+ 900+ );+ String tamperedToken = validToken.replace("DBUser=admin", "DBUser=attacker");++ assertFalse(validator.validate(tamperedToken));+ }++ @Test+ void validateRejectsTokenWithUnknownAccessKey() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDUNKNOWN",+ "wrong-secret",+ Instant.now().minusSeconds(60),+ 900+ );++ assertFalse(validator.validate(token));+ }++ @Test+ void validateRejectsTokenMissingDbUser() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String validToken = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(60),+ 900+ );+ String withoutDbUser = validToken.replaceFirst("DBUser=admin&", "");++ assertFalse(validator.validate(withoutDbUser));+ }++ @Test+ void validateAcceptsTokenWithUrlEncodedDbUser() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ // Username with characters that require URL encoding exercises the+ // encoding path independently of the validator's decode logic+ String token = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "[email protected]",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(60),+ 900+ );++ assertTrue(validator.validate(token));+ }++ @Test+ void validateRejectsTokenWithWrongRegion() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String token = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(60),+ 900+ );+ // Tampering with the region in the credential scope invalidates the signature+ String tamperedToken = token.replace("us-east-1", "eu-west-1");++ assertFalse(validator.validate(tamperedToken));+ }++ @Test+ void validateRejectsTokenMissingSignatureParameter() throws Exception {+ IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey("AKIDRDS", "secret-rds");++ RdsSigV4Validator validator = new RdsSigV4Validator(iamService);+ String validToken = SigV4TokenTestHelper.createRdsToken(+ "db.example.local",+ 5432,+ "admin",+ "AKIDRDS",+ "secret-rds",+ Instant.now().minusSeconds(60),+ 900+ );+ String withoutSignature = validToken.replaceFirst("&X-Amz-Signature=[0-9a-f]+", "");++ assertFalse(validator.validate(withoutSignature));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/testutil/IamServiceTestHelper.java b/src/test/java/io/github/hectorvent/floci/testutil/IamServiceTestHelper.javanew file mode 100644index 0000000000..edf845b39d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testutil/IamServiceTestHelper.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.testutil;++import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.model.AccessKey;++import java.lang.reflect.Constructor;++public final class IamServiceTestHelper {++ private IamServiceTestHelper() {+ }++ @SuppressWarnings("unchecked")+ public static IamService iamServiceWithAccessKey(String accessKeyId, String secretAccessKey) {+ try {+ Constructor<IamService> constructor = IamService.class.getDeclaredConstructor(+ StorageBackend.class,+ StorageBackend.class,+ StorageBackend.class,+ StorageBackend.class,+ StorageBackend.class,+ StorageBackend.class,+ String.class+ );+ constructor.setAccessible(true);++ InMemoryStorage<String, AccessKey> accessKeys = new InMemoryStorage<>();+ accessKeys.put(accessKeyId, new AccessKey(accessKeyId, secretAccessKey, "test-user"));++ return constructor.newInstance(+ null,+ null,+ null,+ null,+ accessKeys,+ null,+ "123456789012"+ );+ } catch (ReflectiveOperationException e) {+ throw new IllegalStateException("Failed to construct IamService test fixture", e);+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/testutil/SigV4TokenTestHelper.java b/src/test/java/io/github/hectorvent/floci/testutil/SigV4TokenTestHelper.javanew file mode 100644index 0000000000..add6dcbf97--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testutil/SigV4TokenTestHelper.java@@ -0,0 +1,142 @@+package io.github.hectorvent.floci.testutil;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.net.URLEncoder;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.util.ArrayList;+import java.util.Comparator;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++public final class SigV4TokenTestHelper {++ private static final DateTimeFormatter DATETIME_FMT =+ DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'").withZone(ZoneOffset.UTC);++ private SigV4TokenTestHelper() {+ }++ public static String createElastiCacheToken(+ String clusterId,+ String user,+ String accessKeyId,+ String secretKey,+ Instant timestamp,+ int expiresSeconds+ ) throws Exception {+ Map<String, String> params = new LinkedHashMap<>();+ params.put("Action", "connect");+ params.put("User", user);+ return signToken(clusterId, null, clusterId, accessKeyId, secretKey, "us-east-1",+ "elasticache", timestamp, expiresSeconds, params);+ }++ public static String createRdsToken(+ String host,+ int port,+ String dbUser,+ String accessKeyId,+ String secretKey,+ Instant timestamp,+ int expiresSeconds+ ) throws Exception {+ Map<String, String> params = new LinkedHashMap<>();+ params.put("Action", "connect");+ params.put("DBUser", dbUser);+ return signToken(host, port, host + ":" + port, accessKeyId, secretKey, "us-east-1",+ "rds-db", timestamp, expiresSeconds, params);+ }++ private static String signToken(+ String host,+ Integer port,+ String canonicalHostHeader,+ String accessKeyId,+ String secretKey,+ String region,+ String service,+ Instant timestamp,+ int expiresSeconds,+ Map<String, String> params+ ) throws Exception {+ String date = DateTimeFormatter.BASIC_ISO_DATE.withZone(ZoneOffset.UTC).format(timestamp);+ String dateTime = DATETIME_FMT.format(timestamp);+ String credentialScope = date + "/" + region + "/" + service + "/aws4_request";++ Map<String, String> queryParams = new LinkedHashMap<>(params);+ queryParams.put("X-Amz-Credential", accessKeyId + "/" + credentialScope);+ queryParams.put("X-Amz-Date", dateTime);+ queryParams.put("X-Amz-Expires", Integer.toString(expiresSeconds));+ queryParams.put("X-Amz-SignedHeaders", "host");++ List<String> encodedPairs = new ArrayList<>();+ for (Map.Entry<String, String> entry : queryParams.entrySet()) {+ encodedPairs.add(entry.getKey() + "=" + urlEncode(entry.getValue()));+ }++ String canonicalQuery = encodedPairs.stream()+ .sorted(Comparator.comparing(SigV4TokenTestHelper::rawParamName))+ .reduce((a, b) -> a + "&" + b)+ .orElse("");++ String canonicalRequest = "GET\n/\n"+ + canonicalQuery + "\n"+ + "host:" + canonicalHostHeader + "\n\n"+ + "host\n"+ + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";++ String stringToSign = "AWS4-HMAC-SHA256\n"+ + dateTime + "\n"+ + credentialScope + "\n"+ + sha256Hex(canonicalRequest);++ byte[] signingKey = deriveSigningKey(secretKey, date, region, service);+ String signature = hexEncode(hmacSha256(signingKey, stringToSign));++ String authority = port == null ? host : host + ":" + port;+ return authority + "/?" + canonicalQuery + "&X-Amz-Signature=" + signature;+ }++ private static String rawParamName(String rawPair) {+ int eq = rawPair.indexOf('=');+ return eq >= 0 ? rawPair.substring(0, eq) : rawPair;+ }++ private static String urlEncode(String value) {+ return URLEncoder.encode(value, StandardCharsets.UTF_8);+ }++ private static byte[] deriveSigningKey(String secretKey, String date, String region,+ String service) throws Exception {+ byte[] kSecret = ("AWS4" + secretKey).getBytes(StandardCharsets.UTF_8);+ byte[] kDate = hmacSha256(kSecret, date);+ byte[] kRegion = hmacSha256(kDate, region);+ byte[] kService = hmacSha256(kRegion, service);+ return hmacSha256(kService, "aws4_request");+ }++ private static byte[] hmacSha256(byte[] key, String data) throws Exception {+ Mac mac = Mac.getInstance("HmacSHA256");+ mac.init(new SecretKeySpec(key, "HmacSHA256"));+ return mac.doFinal(data.getBytes(StandardCharsets.UTF_8));+ }++ private static String sha256Hex(String input) throws Exception {+ MessageDigest digest = MessageDigest.getInstance("SHA-256");+ return hexEncode(digest.digest(input.getBytes(StandardCharsets.UTF_8)));+ }++ private static String hexEncode(byte[] bytes) {+ StringBuilder sb = new StringBuilder(bytes.length * 2);+ for (byte b : bytes) {+ sb.append(String.format("%02x", b));+ }+ return sb.toString();+ }+}