Light, fluffy, and always free - The AWS Local Emulator alternative
feat(kms): implement GenerateMac and VerifyMac (#927)
nblomquist6819bce49356
diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/KmsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/kms/KmsJsonHandler.javaindex 60e9d9ea0c..46dd02093a 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/KmsJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/KmsJsonHandler.java@@ -45,6 +45,8 @@ public class KmsJsonHandler {case "GenerateDataKeyWithoutPlaintext" -> handleGenerateDataKeyWithoutPlaintext(request, region);case "Sign" -> handleSign(request, region);case "Verify" -> handleVerify(request, region);+ case "GenerateMac" -> handleGenerateMac(request, region);+ case "VerifyMac" -> handleVerifyMac(request, region);case "CreateAlias" -> handleCreateAlias(request, region);case "DeleteAlias" -> handleDeleteAlias(request, region);case "ListAliases" -> handleListAliases(request, region);@@ -246,6 +248,35 @@ public class KmsJsonHandler {return Response.ok(response).build();}+ private Response handleGenerateMac(JsonNode request, String region) {+ String keyId = request.path("KeyId").asText();+ byte[] message = Base64.getDecoder().decode(request.path("Message").asText());+ String algorithm = request.path("MacAlgorithm").asText();++ KmsService.GenerateMacResult result = service.generateMacAndResolveKey(keyId, message, algorithm, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.put("KeyId", result.keyArn());+ response.put("Mac", Base64.getEncoder().encodeToString(result.mac()));+ response.put("MacAlgorithm", algorithm);+ return Response.ok(response).build();+ }++ private Response handleVerifyMac(JsonNode request, String region) {+ String keyId = request.path("KeyId").asText();+ byte[] message = Base64.getDecoder().decode(request.path("Message").asText());+ byte[] mac = Base64.getDecoder().decode(request.path("Mac").asText());+ String algorithm = request.path("MacAlgorithm").asText();++ KmsService.VerifyMacResult result = service.verifyMacAndResolveKey(keyId, message, mac, algorithm, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.put("KeyId", result.keyArn());+ response.put("MacAlgorithm", algorithm);+ response.put("MacValid", true);+ return Response.ok(response).build();+ }+private Response handleCreateAlias(JsonNode request, String region) {service.createAlias(request.path("AliasName").asText(), request.path("TargetKeyId").asText(), region);return Response.ok(objectMapper.createObjectNode()).build();diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.java b/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.javaindex 89cf89ec9a..2f55b5d23d 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.java@@ -30,6 +30,8 @@ import org.bouncycastle.jce.ECNamedCurveTable;import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;import org.jboss.logging.Logger;+import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;import java.io.ByteArrayOutputStream;import java.math.BigInteger;import java.nio.ByteBuffer;@@ -333,6 +335,10 @@ public class KmsService {private static final String BLOB_PREFIX_V2 = "kms:v2:";private static final String BLOB_PREFIX_V1 = "kms:";private static final int NONCE_BYTES = 8;+ private static final int MIN_MAC_MESSAGE_BYTES = 1;+ private static final int MAX_MAC_MESSAGE_BYTES = 4096;+ private static final int MIN_MAC_BYTES = 1;+ private static final int MAX_MAC_BYTES = 6144;private static final SecureRandom SECURE_RANDOM = new SecureRandom();public byte[] encrypt(String keyId, byte[] plaintext, String region) {@@ -395,6 +401,10 @@ public class KmsService {public record DecryptResult(byte[] plaintext, String keyArn) {}+ public record GenerateMacResult(byte[] mac, String keyArn) {}++ public record VerifyMacResult(String keyArn) {}+private record ParsedBlob(String keyId, String nonce, String contextFingerprint, String payload) {}private static ParsedBlob parseBlob(byte[] ciphertext) {@@ -506,6 +516,95 @@ public class KmsService {}}+ public byte[] generateMac(String keyId, byte[] message, String algorithm, String region) {+ KmsKey kmsKey = validateMacOperationKey(keyId, algorithm, region);+ return generateMac(kmsKey, message, algorithm);+ }++ public GenerateMacResult generateMacAndResolveKey(String keyId, byte[] message, String algorithm, String region) {+ KmsKey kmsKey = validateMacOperationKey(keyId, algorithm, region);+ return new GenerateMacResult(generateMac(kmsKey, message, algorithm), kmsKey.getArn());+ }++ private byte[] generateMac(KmsKey kmsKey, byte[] message, String algorithm) {+ validateMacMessageLength(message);++ try {+ byte[] keyBytes = Base64.getDecoder().decode(kmsKey.getPrivateKeyEncoded());+ String jcaAlgorithm = mapMacAlgorithm(algorithm);+ Mac mac = Mac.getInstance(jcaAlgorithm);+ mac.init(new SecretKeySpec(keyBytes, jcaAlgorithm));+ mac.update(message);+ return mac.doFinal();+ } catch (AwsException e) {+ throw e;+ } catch (Exception e) {+ throw new AwsException("InternalFailure", "Failed to generate MAC: " + e.getMessage(), 500);+ }+ }++ public void verifyMac(String keyId, byte[] message, byte[] mac, String algorithm, String region) {+ validateMacLength(mac);+ KmsKey kmsKey = validateMacOperationKey(keyId, algorithm, region);+ verifyMac(kmsKey, message, mac, algorithm);+ }++ public VerifyMacResult verifyMacAndResolveKey(String keyId, byte[] message, byte[] mac, String algorithm, String region) {+ validateMacLength(mac);+ KmsKey kmsKey = validateMacOperationKey(keyId, algorithm, region);+ verifyMac(kmsKey, message, mac, algorithm);+ return new VerifyMacResult(kmsKey.getArn());+ }++ private void verifyMac(KmsKey kmsKey, byte[] message, byte[] mac, String algorithm) {+ byte[] expected = generateMac(kmsKey, message, algorithm);+ if (!MessageDigest.isEqual(expected, mac)) {+ throw new AwsException("KMSInvalidMacException", "The MAC is not valid.", 400);+ }+ }++ private KmsKey validateMacOperationKey(String keyId, String algorithm, String region) {+ KmsKey kmsKey = resolveKey(keyId, region);+ String spec = kmsKey.getCustomerMasterKeySpec();+ if (!isHmac(spec) || !"GENERATE_VERIFY_MAC".equals(kmsKey.getKeyUsage())) {+ throw new AwsException("InvalidKeyUsageException",+ "MAC operations require an HMAC key with KeyUsage GENERATE_VERIFY_MAC.", 400);+ }++ String expectedAlgorithm = macAlgorithmFor(spec);+ if (!Objects.equals(expectedAlgorithm, algorithm)) {+ throw new AwsException("InvalidKeyUsageException",+ "MacAlgorithm " + algorithm + " is not valid for KeySpec " + spec + ".", 400);+ }+ return kmsKey;+ }++ private String mapMacAlgorithm(String awsAlgo) {+ return switch (awsAlgo) {+ case "HMAC_SHA_224" -> "HmacSHA224";+ case "HMAC_SHA_256" -> "HmacSHA256";+ case "HMAC_SHA_384" -> "HmacSHA384";+ case "HMAC_SHA_512" -> "HmacSHA512";+ default -> throw new AwsException("InvalidMacAlgorithmException", "Unsupported MAC algorithm: " + awsAlgo, 400);+ };+ }++ private static void validateMacMessageLength(byte[] message) {+ int length = message == null ? 0 : message.length;+ if (length < MIN_MAC_MESSAGE_BYTES || length > MAX_MAC_MESSAGE_BYTES) {+ throw new AwsException("ValidationException",+ "Message must be between 1 and 4096 bytes for MAC operations.", 400);+ }+ }++ private static void validateMacLength(byte[] mac) {+ int length = mac == null ? 0 : mac.length;+ if (length < MIN_MAC_BYTES || length > MAX_MAC_BYTES) {+ throw new AwsException("ValidationException",+ "Mac must be between 1 and 6144 bytes for VerifyMac.", 400);+ }+ }+private PrivateKey loadPrivateKey(String encoded, String spec) throws Exception {byte[] decoded = Base64.getDecoder().decode(encoded);if (isSecgP256k1(spec)) {diff --git a/src/test/java/io/github/hectorvent/floci/services/kms/KmsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/kms/KmsIntegrationTest.javanew file mode 100644index 0000000000..be19a94c17--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kms/KmsIntegrationTest.java@@ -0,0 +1,111 @@+package io.github.hectorvent.floci.services.kms;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.nio.charset.StandardCharsets;+import java.util.Base64;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.startsWith;+import static org.junit.jupiter.api.Assertions.assertEquals;++@QuarkusTest+class KmsIntegrationTest {++ private static final String KMS_CONTENT_TYPE = "application/x-amz-json-1.1";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void generateMacAndVerifyMacRoundTripThroughJsonHandler() {+ String keyId = given()+ .header("X-Amz-Target", "TrentService.CreateKey")+ .contentType(KMS_CONTENT_TYPE)+ .body("""+ {+ "Description": "integration-hmac",+ "KeyUsage": "GENERATE_VERIFY_MAC",+ "CustomerMasterKeySpec": "HMAC_256"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("KeyMetadata.KeyId", notNullValue())+ .body("KeyMetadata.Arn", startsWith("arn:aws:kms:"))+ .body("KeyMetadata.KeyUsage", equalTo("GENERATE_VERIFY_MAC"))+ .body("KeyMetadata.CustomerMasterKeySpec", equalTo("HMAC_256"))+ .extract().jsonPath().getString("KeyMetadata.KeyId");++ String message = Base64.getEncoder().encodeToString(+ "kms integration mac message".getBytes(StandardCharsets.UTF_8));+ String mac = given()+ .header("X-Amz-Target", "TrentService.GenerateMac")+ .contentType(KMS_CONTENT_TYPE)+ .body("""+ {+ "KeyId": "%s",+ "Message": "%s",+ "MacAlgorithm": "HMAC_SHA_256"+ }+ """.formatted(keyId, message))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("KeyId", startsWith("arn:aws:kms:"))+ .body("Mac", notNullValue())+ .body("MacAlgorithm", equalTo("HMAC_SHA_256"))+ .extract().jsonPath().getString("Mac");++ assertEquals(32, Base64.getDecoder().decode(mac).length);++ given()+ .header("X-Amz-Target", "TrentService.VerifyMac")+ .contentType(KMS_CONTENT_TYPE)+ .body("""+ {+ "KeyId": "%s",+ "Message": "%s",+ "Mac": "%s",+ "MacAlgorithm": "HMAC_SHA_256"+ }+ """.formatted(keyId, message, mac))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("KeyId", startsWith("arn:aws:kms:"))+ .body("MacAlgorithm", equalTo("HMAC_SHA_256"))+ .body("MacValid", equalTo(true));++ String differentMessage = Base64.getEncoder().encodeToString(+ "different message".getBytes(StandardCharsets.UTF_8));++ given()+ .header("X-Amz-Target", "TrentService.VerifyMac")+ .contentType(KMS_CONTENT_TYPE)+ .body("""+ {+ "KeyId": "%s",+ "Message": "%s",+ "Mac": "%s",+ "MacAlgorithm": "HMAC_SHA_256"+ }+ """.formatted(keyId, differentMessage, mac))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("KMSInvalidMacException"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.javaindex 30d88aacd5..4dcb08e56f 100644--- a/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.java@@ -657,6 +657,17 @@ class KmsServiceTest {assertEquals(spec, found.getCustomerMasterKeySpec());}+ @ParameterizedTest+ @ValueSource(strings = {"HMAC_224", "HMAC_256", "HMAC_384", "HMAC_512"})+ void generateMacSupportsAllAdvertisedHmacSpecs(String spec) {+ KmsKey key = kmsService.createKey("hmac key", "GENERATE_VERIFY_MAC", spec, null, Map.of(), REGION);+ byte[] message = "floci-mac-probe".getBytes(StandardCharsets.UTF_8);++ byte[] mac = kmsService.generateMac(key.getKeyId(), message, KmsService.macAlgorithmFor(spec), REGION);++ assertEquals(expectedMacByteLength(spec), mac.length);+ }+@Testvoid createHmacKey_requiresGenerateVerifyMacUsage() {AwsException ex = assertThrows(AwsException.class, () ->@@ -678,4 +689,95 @@ class KmsServiceTest {kmsService.getPublicKey(key.getKeyId(), REGION));assertEquals("UnsupportedOperationException", ex.getErrorCode());}++ @Test+ void generateMacWithHmacKeyReturnsDeterministicMac() {+ KmsKey key = kmsService.createKey("hmac key", "GENERATE_VERIFY_MAC", "HMAC_256", null, Map.of(), REGION);+ byte[] message = "floci-mac-probe".getBytes(StandardCharsets.UTF_8);++ byte[] first = kmsService.generateMac(key.getKeyId(), message, "HMAC_SHA_256", REGION);+ byte[] second = kmsService.generateMac(key.getKeyId(), message, "HMAC_SHA_256", REGION);++ assertEquals(32, first.length);+ assertArrayEquals(first, second);+ }++ @Test+ void generateMacRejectsAlgorithmThatDoesNotMatchKeySpec() {+ KmsKey key = kmsService.createKey("hmac key", "GENERATE_VERIFY_MAC", "HMAC_256", null, Map.of(), REGION);+ byte[] message = "floci-mac-probe".getBytes(StandardCharsets.UTF_8);++ AwsException ex = assertThrows(AwsException.class, () ->+ kmsService.generateMac(key.getKeyId(), message, "HMAC_SHA_512", REGION));++ assertEquals("InvalidKeyUsageException", ex.getErrorCode());+ }++ @Test+ void generateMacRejectsMessageOutsideAwsLengthBounds() {+ KmsKey key = kmsService.createKey("hmac key", "GENERATE_VERIFY_MAC", "HMAC_256", null, Map.of(), REGION);++ AwsException empty = assertThrows(AwsException.class, () ->+ kmsService.generateMac(key.getKeyId(), new byte[0], "HMAC_SHA_256", REGION));+ AwsException oversized = assertThrows(AwsException.class, () ->+ kmsService.generateMac(key.getKeyId(), new byte[4097], "HMAC_SHA_256", REGION));++ assertEquals("ValidationException", empty.getErrorCode());+ assertEquals("ValidationException", oversized.getErrorCode());+ }++ @Test+ void verifyMacAcceptsMatchingMacAndRejectsMismatch() {+ KmsKey key = kmsService.createKey("hmac key", "GENERATE_VERIFY_MAC", "HMAC_256", null, Map.of(), REGION);+ byte[] message = "floci-mac-probe".getBytes(StandardCharsets.UTF_8);+ byte[] mac = kmsService.generateMac(key.getKeyId(), message, "HMAC_SHA_256", REGION);++ assertDoesNotThrow(() -> kmsService.verifyMac(key.getKeyId(), message, mac, "HMAC_SHA_256", REGION));++ byte[] tamperedMac = mac.clone();+ tamperedMac[0] ^= 1;+ AwsException ex = assertThrows(AwsException.class, () ->+ kmsService.verifyMac(key.getKeyId(), message, tamperedMac, "HMAC_SHA_256", REGION));++ assertEquals("KMSInvalidMacException", ex.getErrorCode());+ }++ @Test+ void verifyMacRejectsMacOutsideAwsLengthBounds() {+ KmsKey key = kmsService.createKey("hmac key", "GENERATE_VERIFY_MAC", "HMAC_256", null, Map.of(), REGION);+ byte[] message = "floci-mac-probe".getBytes(StandardCharsets.UTF_8);++ AwsException empty = assertThrows(AwsException.class, () ->+ kmsService.verifyMac(key.getKeyId(), message, new byte[0], "HMAC_SHA_256", REGION));+ AwsException oversized = assertThrows(AwsException.class, () ->+ kmsService.verifyMac(key.getKeyId(), message, new byte[6145], "HMAC_SHA_256", REGION));++ assertEquals("ValidationException", empty.getErrorCode());+ assertEquals("ValidationException", oversized.getErrorCode());+ }++ @Test+ void verifyMacRejectsMessageOutsideAwsLengthBounds() {+ KmsKey key = kmsService.createKey("hmac key", "GENERATE_VERIFY_MAC", "HMAC_256", null, Map.of(), REGION);+ byte[] validMessage = "floci-mac-probe".getBytes(StandardCharsets.UTF_8);+ byte[] mac = kmsService.generateMac(key.getKeyId(), validMessage, "HMAC_SHA_256", REGION);++ AwsException empty = assertThrows(AwsException.class, () ->+ kmsService.verifyMac(key.getKeyId(), new byte[0], mac, "HMAC_SHA_256", REGION));+ AwsException oversized = assertThrows(AwsException.class, () ->+ kmsService.verifyMac(key.getKeyId(), new byte[4097], mac, "HMAC_SHA_256", REGION));++ assertEquals("ValidationException", empty.getErrorCode());+ assertEquals("ValidationException", oversized.getErrorCode());+ }++ private static int expectedMacByteLength(String spec) {+ return switch (spec) {+ case "HMAC_224" -> 28;+ case "HMAC_256" -> 32;+ case "HMAC_384" -> 48;+ case "HMAC_512" -> 64;+ default -> -1;+ };+ }}