Light, fluffy, and always free - The AWS Local Emulator alternative
feat: add ACM support (#21)
Conor Heine8a8d55d9727c
diff --git a/README.md b/README.mdindex e54e481272..3c34604265 100644--- a/README.md+++ b/README.md@@ -47,7 +47,7 @@| KMS (sign, verify, re-encrypt) | ✅ | ⚠️ Partial || Native binary | ✅ ~40 MB | ❌ |-**20+ services. 408/408 SDK tests passing. Free forever.**+**21+ services. 408/408 SDK tests passing. Free forever.**## Quick Startdiff --git a/docs/services/acm.md b/docs/services/acm.mdnew file mode 100644index 0000000000..1158f0f60f--- /dev/null+++ b/docs/services/acm.md@@ -0,0 +1,117 @@+# ACM++**Protocol:** JSON 1.1 (`X-Amz-Target: CertificateManager.*`)+**Endpoint:** `POST http://localhost:4566/`++## Supported Actions++| Action | Description |+|---|---|+| `RequestCertificate` | Request a new certificate (auto-issued for emulation) |+| `DescribeCertificate` | Get certificate details and validation status |+| `GetCertificate` | Retrieve the certificate and chain in PEM format |+| `ListCertificates` | List all certificates with optional status filtering |+| `DeleteCertificate` | Delete a certificate |+| `AddTagsToCertificate` | Add tags to a certificate |+| `RemoveTagsFromCertificate` | Remove tags from a certificate |+| `ListTagsForCertificate` | List tags for a certificate |+| `ExportCertificate` | Export certificate with encrypted private key (PRIVATE type only) |+| `GetAccountConfiguration` | Get account-level ACM settings |+| `PutAccountConfiguration` | Update account-level ACM settings |+| `RenewCertificate` | Trigger certificate renewal |++## Emulation Behavior++- **Auto-Issuance:** All requested certificates are immediately issued with status `ISSUED` (no DNS/email validation required)+- **Real Cryptography:** Certificates are generated with real RSA/EC keys and valid X.509 structure+- **Key Algorithms:** Supports `RSA_2048`, `RSA_3072`, `RSA_4096`, `EC_prime256v1`, `EC_secp384r1`, `EC_secp521r1`+- **Certificate Types:** `AMAZON_ISSUED` (default) and `PRIVATE` (when `CertificateAuthorityArn` is provided)+- **Export:** Only `PRIVATE` type certificates can be exported with their private key++## Examples++```bash+export AWS_ENDPOINT=http://localhost:4566++# Request a certificate+CERT_ARN=$(aws acm request-certificate \+ --domain-name "example.com" \+ --subject-alternative-names "www.example.com" "*.example.com" \+ --validation-method DNS \+ --query CertificateArn --output text \+ --endpoint-url $AWS_ENDPOINT)++# Describe the certificate+aws acm describe-certificate \+ --certificate-arn $CERT_ARN \+ --endpoint-url $AWS_ENDPOINT++# Get certificate in PEM format+aws acm get-certificate \+ --certificate-arn $CERT_ARN \+ --endpoint-url $AWS_ENDPOINT++# List all certificates+aws acm list-certificates \+ --endpoint-url $AWS_ENDPOINT++# List only issued certificates+aws acm list-certificates \+ --certificate-statuses ISSUED \+ --endpoint-url $AWS_ENDPOINT++# Add tags+aws acm add-tags-to-certificate \+ --certificate-arn $CERT_ARN \+ --tags Key=Environment,Value=Production Key=Project,Value=Demo \+ --endpoint-url $AWS_ENDPOINT++# List tags+aws acm list-tags-for-certificate \+ --certificate-arn $CERT_ARN \+ --endpoint-url $AWS_ENDPOINT++# Request a private certificate (exportable)+PRIVATE_ARN=$(aws acm request-certificate \+ --domain-name "internal.example.com" \+ --certificate-authority-arn "arn:aws:acm-pca:us-east-1:123456789012:certificate-authority/12345678-1234-1234-1234-123456789012" \+ --query CertificateArn --output text \+ --endpoint-url $AWS_ENDPOINT)++# Export private certificate (passphrase must be base64-encoded, min 4 chars)+PASSPHRASE=$(echo -n "mypassphrase123" | base64)+aws acm export-certificate \+ --certificate-arn $PRIVATE_ARN \+ --passphrase $PASSPHRASE \+ --endpoint-url $AWS_ENDPOINT++# Delete a certificate+aws acm delete-certificate \+ --certificate-arn $CERT_ARN \+ --endpoint-url $AWS_ENDPOINT+```++## SDK Example (Java)++```java+AcmClient acm = AcmClient.builder()+ .endpointOverride(URI.create("http://localhost:4566"))+ .region(Region.US_EAST_1)+ .credentialsProvider(StaticCredentialsProvider.create(+ AwsBasicCredentials.create("test", "test")))+ .build();++// Request a certificate+RequestCertificateResponse response = acm.requestCertificate(req -> req+ .domainName("example.com")+ .subjectAlternativeNames("www.example.com", "*.example.com")+ .validationMethod(ValidationMethod.DNS));++String certArn = response.certificateArn();++// Describe the certificate+DescribeCertificateResponse desc = acm.describeCertificate(req -> req+ .certificateArn(certArn));++System.out.println("Status: " + desc.certificate().status());+```diff --git a/docs/services/index.md b/docs/services/index.mdindex 3fc6452156..abaa1f1147 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -1,6 +1,6 @@# Services Overview-Floci emulates 19+ AWS services on a single port (`4566`). All services use the real AWS wire protocol — your existing AWS CLI commands and SDK clients work without modification.+Floci emulates 21+ AWS services on a single port (`4566`). All services use the real AWS wire protocol — your existing AWS CLI commands and SDK clients work without modification.## Service Matrix@@ -28,6 +28,7 @@ Floci emulates 19+ AWS services on a single port (`4566`). All services use the| [EventBridge](eventbridge.md) | `POST /` + `X-Amz-Target: AmazonEventBridge.*` | JSON 1.1 | 14 || [CloudWatch Logs](cloudwatch.md) | `POST /` + `X-Amz-Target: Logs.*` | JSON 1.1 | 14 || [CloudWatch Metrics](cloudwatch.md#metrics) | `POST /` with `Action=` or JSON 1.1 | Query / JSON | 8 |+| [ACM](acm.md) | `POST /` + `X-Amz-Target: CertificateManager.*` | JSON 1.1 | 12 |## Common Setupdiff --git a/pom.xml b/pom.xmlindex 06cb11a990..792765b441 100644--- a/pom.xml+++ b/pom.xml@@ -83,6 +83,18 @@<version>3.4.0</version></dependency>+ <!-- BouncyCastle for X.509 certificate generation and PEM handling (ACM service) -->+ <dependency>+ <groupId>org.bouncycastle</groupId>+ <artifactId>bcprov-jdk18on</artifactId>+ <version>1.83</version>+ </dependency>+ <dependency>+ <groupId>org.bouncycastle</groupId>+ <artifactId>bcpkix-jdk18on</artifactId>+ <version>1.83</version>+ </dependency>+<!-- Testing --><dependency><groupId>io.quarkus</groupId>diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 31ca3a7bb9..517ecb0d6c 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -44,6 +44,7 @@ public interface EmulatorConfig {CloudWatchLogsStorageConfig cloudwatchlogs();CloudWatchMetricsStorageConfig cloudwatchmetrics();SecretsManagerStorageConfig secretsmanager();+ AcmStorageConfig acm();}interface SsmStorageConfig {@@ -112,6 +113,14 @@ public interface EmulatorConfig {long flushIntervalMs();}+ interface AcmStorageConfig {+ @WithDefault("memory")+ String mode();++ @WithDefault("5000")+ long flushIntervalMs();+ }+interface WalConfig {@WithDefault("30000")long compactionIntervalMs();@@ -150,6 +159,7 @@ public interface EmulatorConfig {CognitoServiceConfig cognito();StepFunctionsServiceConfig stepfunctions();CloudFormationServiceConfig cloudformation();+ AcmServiceConfig acm();}interface SsmServiceConfig {@@ -295,6 +305,15 @@ public interface EmulatorConfig {boolean enabled();}+ interface AcmServiceConfig {+ @WithDefault("true")+ boolean enabled();++ /** Seconds to wait before transitioning from PENDING_VALIDATION to ISSUED (0 = immediate) */+ @WithDefault("0")+ int validationWaitSeconds();+ }+interface LambdaServiceConfig {@WithDefault("true")boolean enabled();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.javaindex 1be4ebd328..9aeacb97d3 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.core.common;+import io.github.hectorvent.floci.services.acm.AcmJsonHandler;import io.github.hectorvent.floci.services.apigatewayv2.ApiGatewayV2JsonHandler;import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsHandler;import io.github.hectorvent.floci.services.cognito.CognitoJsonHandler;@@ -40,6 +41,7 @@ public class AwsJson11Controller {private static final String APIGW_V2_TARGET_PREFIX = "AmazonApiGatewayV2.";private static final String KMS_TARGET_PREFIX = "TrentService.";private static final String COGNITO_TARGET_PREFIX = "AWSCognitoIdentityProviderService.";+ private static final String ACM_TARGET_PREFIX = "CertificateManager.";private final ObjectMapper objectMapper;private final RegionResolver regionResolver;@@ -51,6 +53,7 @@ public class AwsJson11Controller {private final ApiGatewayV2JsonHandler apigwV2JsonHandler;private final KmsJsonHandler kmsJsonHandler;private final CognitoJsonHandler cognitoJsonHandler;+ private final AcmJsonHandler acmJsonHandler;@Injectpublic AwsJson11Controller(ObjectMapper objectMapper, RegionResolver regionResolver,@@ -59,7 +62,8 @@ public class AwsJson11Controller {SecretsManagerJsonHandler secretsManagerJsonHandler,KinesisJsonHandler kinesisJsonHandler,ApiGatewayV2JsonHandler apigwV2JsonHandler,- KmsJsonHandler kmsJsonHandler, CognitoJsonHandler cognitoJsonHandler) {+ KmsJsonHandler kmsJsonHandler, CognitoJsonHandler cognitoJsonHandler,+ AcmJsonHandler acmJsonHandler) {this.objectMapper = objectMapper;this.regionResolver = regionResolver;this.ssmJsonHandler = ssmJsonHandler;@@ -70,6 +74,7 @@ public class AwsJson11Controller {this.apigwV2JsonHandler = apigwV2JsonHandler;this.kmsJsonHandler = kmsJsonHandler;this.cognitoJsonHandler = cognitoJsonHandler;+ this.acmJsonHandler = acmJsonHandler;}@POST@@ -111,6 +116,9 @@ public class AwsJson11Controller {} else if (target.startsWith(COGNITO_TARGET_PREFIX)) {prefix = COGNITO_TARGET_PREFIX;serviceName = "Cognito";+ } else if (target.startsWith(ACM_TARGET_PREFIX)) {+ prefix = ACM_TARGET_PREFIX;+ serviceName = "ACM";} else {return Response.status(400).entity(new AwsErrorResponse("UnknownOperationException",@@ -134,6 +142,7 @@ public class AwsJson11Controller {case "ApiGatewayV2" -> apigwV2JsonHandler.handle(action, request, region);case "KMS" -> kmsJsonHandler.handle(action, request, region);case "Cognito" -> cognitoJsonHandler.handle(action, request, region);+ case "ACM" -> acmJsonHandler.handle(action, request, region);default -> null;};} catch (AwsException e) {diff --git a/src/main/java/io/github/hectorvent/floci/core/common/BouncyCastleInitializer.java b/src/main/java/io/github/hectorvent/floci/core/common/BouncyCastleInitializer.javanew file mode 100644index 0000000000..095cf5fcfa--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/BouncyCastleInitializer.java@@ -0,0 +1,43 @@+package io.github.hectorvent.floci.core.common;++import io.quarkus.runtime.Startup;+import jakarta.enterprise.context.ApplicationScoped;+import org.bouncycastle.jce.provider.BouncyCastleProvider;+import org.jboss.logging.Logger;++import java.security.Security;++/**+ * Ensures BouncyCastle security provider is registered before any CDI beans are injected.+ *+ * <p>This class uses a static initializer block to guarantee the provider is registered+ * during class loading, which happens before CDI injection. The {@code @Startup} annotation+ * ensures this class is loaded early in the application lifecycle.</p>+ *+ * <p>Design decision: Using static initializer + @Startup instead of @Observes StartupEvent+ * because StartupEvent observers run after CDI context is ready, which may be too late if+ * other beans depend on BouncyCastle during their construction.</p>+ *+ * @see <a href="https://quarkus.io/guides/cdi#startup-event">Quarkus CDI Startup</a>+ */+@ApplicationScoped+@Startup+public class BouncyCastleInitializer {++ private static final Logger LOG = Logger.getLogger(BouncyCastleInitializer.class);++ static {+ if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {+ Security.addProvider(new BouncyCastleProvider());+ LOG.info("Registered BouncyCastle security provider (static initializer)");+ }+ }++ /**+ * No-op constructor. The actual initialization happens in the static block above.+ * This bean exists solely to trigger class loading via {@code @Startup}.+ */+ public BouncyCastleInitializer() {+ // Static initializer has already run by the time this constructor is called+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.java b/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.javaindex 946804f6cb..178a5d1370 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.java@@ -45,6 +45,7 @@ public class ServiceRegistry {case "cognito-idp" -> config.services().cognito().enabled();case "states" -> config.services().stepfunctions().enabled();case "cloudformation" -> config.services().cloudformation().enabled();+ case "acm" -> config.services().acm().enabled();default -> true;};}@@ -71,6 +72,7 @@ public class ServiceRegistry {if (config.services().cognito().enabled()) enabled.add("cognito-idp");if (config.services().stepfunctions().enabled()) enabled.add("states");if (config.services().cloudformation().enabled()) enabled.add("cloudformation");+ if (config.services().acm().enabled()) enabled.add("acm");return enabled;}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/AcmJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/acm/AcmJsonHandler.javanew file mode 100644index 0000000000..71966cbca9--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/AcmJsonHandler.java@@ -0,0 +1,446 @@+package io.github.hectorvent.floci.services.acm;++import io.github.hectorvent.floci.core.common.AwsErrorResponse;+import io.github.hectorvent.floci.services.acm.model.*;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import jakarta.ws.rs.core.Response;+import org.jboss.logging.Logger;++import java.util.*;++/**+ * JSON handler for AWS Certificate Manager (ACM) API operations.+ *+ * <p>Implements the AWS JSON 1.1 protocol for ACM operations including+ * certificate request, import, export, listing, and lifecycle management.</p>+ *+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/Welcome.html">AWS ACM API Reference</a>+ */+@ApplicationScoped+public class AcmJsonHandler {++ private static final Logger LOG = Logger.getLogger(AcmJsonHandler.class);++ private final AcmService service;+ private final ObjectMapper objectMapper;++ @Inject+ public AcmJsonHandler(AcmService service, ObjectMapper objectMapper) {+ this.service = service;+ this.objectMapper = objectMapper;+ }++ public Response handle(String action, JsonNode request, String region) {+ return switch (action) {+ case "RequestCertificate" -> handleRequestCertificate(request, region);+ case "DescribeCertificate" -> handleDescribeCertificate(request, region);+ case "GetCertificate" -> handleGetCertificate(request, region);+ case "ListCertificates" -> handleListCertificates(request, region);+ case "DeleteCertificate" -> handleDeleteCertificate(request, region);+ case "ImportCertificate" -> handleImportCertificate(request, region);+ case "ExportCertificate" -> handleExportCertificate(request, region);+ case "AddTagsToCertificate" -> handleAddTagsToCertificate(request, region);+ case "ListTagsForCertificate" -> handleListTagsForCertificate(request, region);+ case "RemoveTagsFromCertificate" -> handleRemoveTagsFromCertificate(request, region);+ case "GetAccountConfiguration" -> handleGetAccountConfiguration(request, region);+ case "PutAccountConfiguration" -> handlePutAccountConfiguration(request, region);+ default -> Response.status(400)+ .entity(new AwsErrorResponse("UnsupportedOperation", "Operation " + action + " is not supported."))+ .build();+ };+ }++ private Response handleRequestCertificate(JsonNode request, String region) {+ String domainName = request.path("DomainName").asText(null);+ if (domainName == null || domainName.isBlank()) {+ return Response.status(400)+ .entity(new AwsErrorResponse("ValidationException",+ "Value null at 'domainName' failed to satisfy constraint: Member must not be null"))+ .build();+ }+ List<String> sans = parseStringList(request.path("SubjectAlternativeNames"));+ ValidationMethod validationMethod = parseValidationMethod(request.path("ValidationMethod").asText(null));+ String idempotencyToken = request.path("IdempotencyToken").asText(null);+ KeyAlgorithm keyAlgorithm = KeyAlgorithm.fromAwsName(request.path("KeyAlgorithm").asText(null));+ String certAuthorityArn = request.path("CertificateAuthorityArn").asText(null);+ CertificateOptions options = parseOptions(request.path("Options"));+ Map<String, String> tags = parseTags(request.path("Tags"));++ Certificate cert = service.requestCertificate(domainName, sans, validationMethod,+ idempotencyToken, keyAlgorithm, certAuthorityArn, options, tags, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.put("CertificateArn", cert.getArn());+ return Response.ok(response).build();+ }++ private Response handleDescribeCertificate(JsonNode request, String region) {+ String certificateArn = request.path("CertificateArn").asText();+ Certificate cert = service.describeCertificate(certificateArn, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.set("Certificate", buildCertificateDetail(cert));+ return Response.ok(response).build();+ }++ private Response handleGetCertificate(JsonNode request, String region) {+ String certificateArn = request.path("CertificateArn").asText();+ Certificate cert = service.getCertificate(certificateArn, region);++ // AWS returns RequestInProgressException for certificates still pending validation+ if (cert.getStatus() == CertificateStatus.PENDING_VALIDATION) {+ throw new io.github.hectorvent.floci.core.common.AwsException(+ "RequestInProgressException",+ "The certificate request is in progress. The certificate body is not yet available.",+ 400);+ }++ ObjectNode response = objectMapper.createObjectNode();+ response.put("Certificate", cert.getCertificateBody());+ if (cert.getCertificateChain() != null) {+ response.put("CertificateChain", cert.getCertificateChain());+ }+ return Response.ok(response).build();+ }++ private Response handleListCertificates(JsonNode request, String region) {+ List<CertificateStatus> statuses = parseCertificateStatuses(request.path("CertificateStatuses"));+ List<KeyAlgorithm> keyTypes = parseKeyTypes(request.path("Includes").path("keyTypes"));+ int maxItems = request.path("MaxItems").asInt(100);+ String nextToken = request.path("NextToken").asText(null);++ ListResult result = service.listCertificates(statuses, keyTypes, region, maxItems, nextToken);++ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode summaryList = objectMapper.createArrayNode();+ for (Certificate cert : result.certificates()) {+ summaryList.add(buildCertificateSummary(cert));+ }+ response.set("CertificateSummaryList", summaryList);+ if (result.nextToken() != null) {+ response.put("NextToken", result.nextToken());+ }+ return Response.ok(response).build();+ }++ private Response handleDeleteCertificate(JsonNode request, String region) {+ String certificateArn = request.path("CertificateArn").asText();+ service.deleteCertificate(certificateArn, region);+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleImportCertificate(JsonNode request, String region) {+ String certificate = request.path("Certificate").asText();+ String privateKey = request.path("PrivateKey").asText();+ String chain = request.path("CertificateChain").asText(null);+ String existingArn = request.path("CertificateArn").asText(null);+ Map<String, String> tags = parseTags(request.path("Tags"));++ Certificate cert = service.importCertificate(certificate, privateKey, chain, existingArn, tags, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.put("CertificateArn", cert.getArn());+ return Response.ok(response).build();+ }++ private Response handleExportCertificate(JsonNode request, String region) {+ String certificateArn = request.path("CertificateArn").asText();+ String passphrase = request.path("Passphrase").asText();++ Certificate cert = service.exportCertificate(certificateArn, passphrase, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.put("Certificate", cert.getCertificateBody());+ if (cert.getCertificateChain() != null) {+ response.put("CertificateChain", cert.getCertificateChain());+ }+ response.put("PrivateKey", cert.getPrivateKey());+ return Response.ok(response).build();+ }++ private Response handleAddTagsToCertificate(JsonNode request, String region) {+ String certificateArn = request.path("CertificateArn").asText();+ Map<String, String> tags = parseTags(request.path("Tags"));++ service.addTagsToCertificate(certificateArn, tags, region);+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleListTagsForCertificate(JsonNode request, String region) {+ String certificateArn = request.path("CertificateArn").asText();+ Map<String, String> tags = service.listTagsForCertificate(certificateArn, region);++ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode tagsArray = objectMapper.createArrayNode();+ for (Map.Entry<String, String> entry : tags.entrySet()) {+ ObjectNode tagNode = objectMapper.createObjectNode();+ tagNode.put("Key", entry.getKey());+ tagNode.put("Value", entry.getValue());+ tagsArray.add(tagNode);+ }+ response.set("Tags", tagsArray);+ return Response.ok(response).build();+ }++ private Response handleRemoveTagsFromCertificate(JsonNode request, String region) {+ String certificateArn = request.path("CertificateArn").asText();+ List<Map<String, String>> tagSpecs = new ArrayList<>();+ JsonNode tagsNode = request.path("Tags");+ if (tagsNode.isArray()) {+ for (JsonNode tagNode : tagsNode) {+ Map<String, String> spec = new HashMap<>();+ spec.put("Key", tagNode.path("Key").asText());+ if (tagNode.has("Value")) {+ spec.put("Value", tagNode.path("Value").asText());+ }+ tagSpecs.add(spec);+ }+ }++ service.removeTagsFromCertificate(certificateArn, tagSpecs, region);+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleGetAccountConfiguration(JsonNode request, String region) {+ int daysBeforeExpiry = service.getAccountDaysBeforeExpiry();++ ObjectNode response = objectMapper.createObjectNode();+ ObjectNode expiryEvents = objectMapper.createObjectNode();+ expiryEvents.put("DaysBeforeExpiry", daysBeforeExpiry);+ response.set("ExpiryEvents", expiryEvents);+ return Response.ok(response).build();+ }++ private Response handlePutAccountConfiguration(JsonNode request, String region) {+ String idempotencyToken = request.path("IdempotencyToken").asText(null);+ int daysBeforeExpiry = request.path("ExpiryEvents").path("DaysBeforeExpiry").asInt(45);++ service.putAccountConfiguration(daysBeforeExpiry, idempotencyToken);+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ // ============ Helper Methods ============++ private ObjectNode buildCertificateDetail(Certificate cert) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("CertificateArn", cert.getArn());+ node.put("DomainName", cert.getDomainName());++ ArrayNode sans = objectMapper.createArrayNode();+ if (cert.getSubjectAlternativeNames() != null) {+ cert.getSubjectAlternativeNames().forEach(sans::add);+ }+ node.set("SubjectAlternativeNames", sans);+ node.set("SubjectAlternativeNameSummaries", sans.deepCopy());+ node.put("HasAdditionalSubjectAlternativeNames", false);++ node.put("Status", cert.getStatus().name());+ node.put("Type", cert.getType().name());++ if (cert.getKeyAlgorithm() != null) {+ node.put("KeyAlgorithm", cert.getKeyAlgorithm().getAwsName());+ }+ if (cert.getSignatureAlgorithm() != null) {+ node.put("SignatureAlgorithm", cert.getSignatureAlgorithm());+ }+ if (cert.getSerial() != null) {+ node.put("Serial", cert.getSerial());+ }+ if (cert.getSubject() != null) {+ node.put("Subject", cert.getSubject());+ }+ if (cert.getIssuer() != null) {+ node.put("Issuer", cert.getIssuer());+ }++ if (cert.getCreatedAt() != null) {+ node.put("CreatedAt", cert.getCreatedAt().toEpochMilli() / 1000.0);+ }+ if (cert.getIssuedAt() != null) {+ node.put("IssuedAt", cert.getIssuedAt().toEpochMilli() / 1000.0);+ }+ if (cert.getImportedAt() != null) {+ node.put("ImportedAt", cert.getImportedAt().toEpochMilli() / 1000.0);+ }+ if (cert.getNotBefore() != null) {+ node.put("NotBefore", cert.getNotBefore().toEpochMilli() / 1000.0);+ }+ if (cert.getNotAfter() != null) {+ node.put("NotAfter", cert.getNotAfter().toEpochMilli() / 1000.0);+ }++ ArrayNode inUseBy = objectMapper.createArrayNode();+ if (cert.getInUseBy() != null) {+ cert.getInUseBy().forEach(inUseBy::add);+ }+ node.set("InUseBy", inUseBy);++ if (cert.getDomainValidationOptions() != null && !cert.getDomainValidationOptions().isEmpty()) {+ ArrayNode validations = objectMapper.createArrayNode();+ for (DomainValidation dv : cert.getDomainValidationOptions()) {+ ObjectNode dvNode = objectMapper.createObjectNode();+ dvNode.put("DomainName", dv.domainName());+ dvNode.put("ValidationDomain", dv.validationDomain());+ dvNode.put("ValidationStatus", dv.validationStatus());+ dvNode.put("ValidationMethod", dv.validationMethod());+ if (dv.resourceRecord() != null) {+ ObjectNode rrNode = objectMapper.createObjectNode();+ rrNode.put("Name", dv.resourceRecord().name());+ rrNode.put("Type", dv.resourceRecord().type());+ rrNode.put("Value", dv.resourceRecord().value());+ dvNode.set("ResourceRecord", rrNode);+ }+ validations.add(dvNode);+ }+ node.set("DomainValidationOptions", validations);+ }++ node.put("RenewalEligibility", "INELIGIBLE");++ ArrayNode keyUsages = objectMapper.createArrayNode();+ ObjectNode ku1 = objectMapper.createObjectNode();+ ku1.put("Name", "DIGITAL_SIGNATURE");+ keyUsages.add(ku1);+ ObjectNode ku2 = objectMapper.createObjectNode();+ ku2.put("Name", "KEY_ENCIPHERMENT");+ keyUsages.add(ku2);+ node.set("KeyUsages", keyUsages);++ ArrayNode extKeyUsages = objectMapper.createArrayNode();+ ObjectNode eku1 = objectMapper.createObjectNode();+ eku1.put("Name", "TLS_WEB_SERVER_AUTHENTICATION");+ eku1.put("OID", "1.3.6.1.5.5.7.3.1");+ extKeyUsages.add(eku1);+ ObjectNode eku2 = objectMapper.createObjectNode();+ eku2.put("Name", "TLS_WEB_CLIENT_AUTHENTICATION");+ eku2.put("OID", "1.3.6.1.5.5.7.3.2");+ extKeyUsages.add(eku2);+ node.set("ExtendedKeyUsages", extKeyUsages);++ if (cert.getCertOptions() != null) {+ ObjectNode opts = objectMapper.createObjectNode();+ opts.put("CertificateTransparencyLoggingPreference",+ cert.getCertOptions().certificateTransparencyLoggingPreference());+ node.set("Options", opts);+ }++ return node;+ }++ private ObjectNode buildCertificateSummary(Certificate cert) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("CertificateArn", cert.getArn());+ node.put("DomainName", cert.getDomainName());++ ArrayNode sans = objectMapper.createArrayNode();+ if (cert.getSubjectAlternativeNames() != null) {+ cert.getSubjectAlternativeNames().forEach(sans::add);+ }+ node.set("SubjectAlternativeNameSummaries", sans);+ node.put("HasAdditionalSubjectAlternativeNames", false);++ node.put("Status", cert.getStatus().name());+ node.put("Type", cert.getType().name());++ if (cert.getKeyAlgorithm() != null) {+ node.put("KeyAlgorithm", cert.getKeyAlgorithm().getAwsName());+ }++ ArrayNode keyUsages = objectMapper.createArrayNode();+ keyUsages.add("DIGITAL_SIGNATURE");+ keyUsages.add("KEY_ENCIPHERMENT");+ node.set("KeyUsages", keyUsages);++ ArrayNode extKeyUsages = objectMapper.createArrayNode();+ extKeyUsages.add("TLS_WEB_SERVER_AUTHENTICATION");+ extKeyUsages.add("TLS_WEB_CLIENT_AUTHENTICATION");+ node.set("ExtendedKeyUsages", extKeyUsages);++ if (cert.getCreatedAt() != null) {+ node.put("CreatedAt", cert.getCreatedAt().toEpochMilli() / 1000.0);+ }+ if (cert.getIssuedAt() != null) {+ node.put("IssuedAt", cert.getIssuedAt().toEpochMilli() / 1000.0);+ }+ if (cert.getImportedAt() != null) {+ node.put("ImportedAt", cert.getImportedAt().toEpochMilli() / 1000.0);+ }+ if (cert.getNotBefore() != null) {+ node.put("NotBefore", cert.getNotBefore().toEpochMilli() / 1000.0);+ }+ if (cert.getNotAfter() != null) {+ node.put("NotAfter", cert.getNotAfter().toEpochMilli() / 1000.0);+ }++ node.put("RenewalEligibility", "INELIGIBLE");+ node.put("InUse", cert.getInUseBy() != null && !cert.getInUseBy().isEmpty());++ return node;+ }++ private List<String> parseStringList(JsonNode node) {+ if (!node.isArray()) return null;+ List<String> list = new ArrayList<>();+ node.forEach(n -> list.add(n.asText()));+ return list;+ }++ private Map<String, String> parseTags(JsonNode tagsNode) {+ if (!tagsNode.isArray()) return null;+ Map<String, String> tags = new HashMap<>();+ for (JsonNode tagNode : tagsNode) {+ String key = tagNode.path("Key").asText();+ String value = tagNode.path("Value").asText(null);+ tags.put(key, value);+ }+ return tags;+ }++ private ValidationMethod parseValidationMethod(String method) {+ if (method == null) return ValidationMethod.DNS;+ try {+ return ValidationMethod.valueOf(method.toUpperCase());+ } catch (IllegalArgumentException e) {+ throw new io.github.hectorvent.floci.core.common.AwsException(+ "ValidationException",+ "Invalid validation method: " + method + ". Must be DNS or EMAIL.",+ 400);+ }+ }++ private CertificateOptions parseOptions(JsonNode optionsNode) {+ if (optionsNode.isMissingNode()) return null;+ String ctPref = optionsNode.path("CertificateTransparencyLoggingPreference").asText("ENABLED");+ return new CertificateOptions(ctPref, "DISABLED");+ }++ private List<CertificateStatus> parseCertificateStatuses(JsonNode node) {+ if (!node.isArray()) return null;+ List<CertificateStatus> list = new ArrayList<>();+ for (JsonNode n : node) {+ try {+ list.add(CertificateStatus.valueOf(n.asText()));+ } catch (IllegalArgumentException e) {+ LOG.debugv("Ignoring unknown certificate status: {0}", n.asText());+ }+ }+ return list.isEmpty() ? null : list;+ }++ private List<KeyAlgorithm> parseKeyTypes(JsonNode node) {+ if (!node.isArray()) return null;+ List<KeyAlgorithm> list = new ArrayList<>();+ for (JsonNode n : node) {+ KeyAlgorithm alg = KeyAlgorithm.fromAwsName(n.asText());+ if (alg != null) {+ list.add(alg);+ }+ }+ return list.isEmpty() ? null : list;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java b/src/main/java/io/github/hectorvent/floci/services/acm/AcmService.javanew file mode 100644index 0000000000..4e95d2d418--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java@@ -0,0 +1,657 @@+package io.github.hectorvent.floci.services.acm;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.acm.model.*;+import com.fasterxml.jackson.core.type.TypeReference;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.io.IOException;+import java.io.InputStream;+import java.nio.charset.StandardCharsets;+import java.security.SecureRandom;+import java.security.cert.X509Certificate;+import java.time.Instant;+import java.util.*;+import java.util.LinkedHashSet;+import java.util.HexFormat;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.atomic.AtomicBoolean;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.stream.Collectors;++/**+ * ACM (AWS Certificate Manager) service implementation for the local emulator.+ *+ * <p>Provides X.509 certificate management operations compatible with the AWS ACM API,+ * including certificate request, import, export, and lifecycle management.</p>+ *+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/Welcome.html">AWS ACM API Reference</a>+ */+@ApplicationScoped+public class AcmService {++ private static final Logger LOG = Logger.getLogger(AcmService.class);+ private static final int MAX_TAGS = 50;+ private static final int MAX_TAG_KEY_LENGTH = 128;+ private static final int MAX_TAG_VALUE_LENGTH = 256;+ private static final int MAX_SANS = 100;+ private static final int MAX_DOMAIN_LENGTH = 253;+ private static final SecureRandom SECURE_RANDOM = new SecureRandom();++ private final StorageBackend<String, Certificate> store;+ private final CertificateGenerator certificateGenerator;+ private final RegionResolver regionResolver;+ private final int validationWaitSeconds;+ private final AtomicInteger accountDaysBeforeExpiry = new AtomicInteger(45);+ private final AtomicBoolean securityWarningLogged = new AtomicBoolean(false);++ /**+ * Idempotency token cache using lazy expiration (1-hour TTL).+ *+ * <p>Design decision: Using ConcurrentHashMap with timestamp-based entries+ * instead of Caffeine or scheduled cleanup. This matches moto's approach+ * (see moto/acm/models.py:478-505) where expired entries are removed on+ * lookup. No background thread needed - acceptable for emulator workloads.</p>+ *+ * @see <a href="https://github.com/getmoto/moto/blob/main/moto/acm/models.py">moto ACM</a>+ */+ private final ConcurrentHashMap<String, IdempotencyTokenEntry> idempotencyTokenIndex = new ConcurrentHashMap<>();++ @Inject+ public AcmService(StorageFactory factory, CertificateGenerator certificateGenerator,+ EmulatorConfig config, RegionResolver regionResolver) {+ this(factory.create("acm", "acm-certificates.json",+ new TypeReference<Map<String, Certificate>>() {}),+ certificateGenerator,+ regionResolver,+ config.services().acm().validationWaitSeconds());+ }++ AcmService(StorageBackend<String, Certificate> store, CertificateGenerator certificateGenerator,+ RegionResolver regionResolver, int validationWaitSeconds) {+ this.store = store;+ this.certificateGenerator = certificateGenerator;+ this.regionResolver = regionResolver;+ this.validationWaitSeconds = validationWaitSeconds;++ // Validate Root CA resource availability+ validateRootCaResource();+ }++ /**+ * Log security warning once on first certificate creation/import.+ * Uses AtomicBoolean to ensure thread-safe single logging.+ */+ private void logSecurityWarningOnce() {+ if (securityWarningLogged.compareAndSet(false, true)) {+ LOG.warn("SECURITY WARNING: ACM emulator stores private keys in plaintext. " ++ "This is acceptable for local development but NOT for production use.");+ }+ }++ private void validateRootCaResource() {+ try (InputStream is = getClass().getResourceAsStream("/certs/amazon-root-ca.pem")) {+ if (is == null) {+ LOG.warn("Amazon Root CA certificate not found at /certs/amazon-root-ca.pem - " ++ "certificate chains will be empty");+ } else {+ LOG.info("Amazon Root CA certificate loaded successfully");+ }+ } catch (IOException e) {+ LOG.warnv("Failed to validate Root CA resource: {0}", e.getMessage());+ }+ }++ // ============ RequestCertificate ============++ public Certificate requestCertificate(String domainName, List<String> sans, ValidationMethod validationMethod,+ String idempotencyToken, KeyAlgorithm keyAlgorithm,+ String certAuthorityArn, CertificateOptions options,+ Map<String, String> tags, String region) {+ logSecurityWarningOnce();+ validateDomainName(domainName);+ validateSans(sans);+ if (tags != null) {+ validateTags(tags);+ }++ KeyAlgorithm alg = keyAlgorithm != null ? keyAlgorithm : KeyAlgorithm.RSA_2048;++ // Check idempotency with parameter validation+ if (idempotencyToken != null && !idempotencyToken.isEmpty()) {+ int requestHash = computeRequestHash(domainName, sans, alg);+ Optional<Certificate> existing = findByIdempotencyToken(idempotencyToken, region, requestHash);+ if (existing.isPresent()) {+ return existing.get();+ }+ }++ String certId = UUID.randomUUID().toString();+ String arn = buildCertificateArn(region, certId);++ // Determine certificate type and initial status+ CertificateType type;+ CertificateStatus status;+ if (certAuthorityArn != null && !certAuthorityArn.isEmpty()) {+ type = CertificateType.PRIVATE;+ status = CertificateStatus.ISSUED;+ } else {+ type = CertificateType.AMAZON_ISSUED;+ status = validationWaitSeconds > 0 ? CertificateStatus.PENDING_VALIDATION : CertificateStatus.ISSUED;+ }++ // Generate real X.509 certificate+ CertificateGenerator.GeneratedCertificate generated = certificateGenerator.generateCertificate(+ domainName, sans, alg+ );++ Instant now = Instant.now();++ Certificate cert = new Certificate();+ cert.setArn(arn);+ cert.setDomainName(domainName);++ // Use LinkedHashSet for O(1) deduplication while preserving insertion order+ LinkedHashSet<String> allSans = new LinkedHashSet<>();+ allSans.add(domainName);+ if (sans != null) {+ allSans.addAll(sans);+ }+ cert.setSubjectAlternativeNames(new ArrayList<>(allSans));++ cert.setStatus(status);+ cert.setType(type);+ cert.setValidationMethod(validationMethod != null ? validationMethod : ValidationMethod.DNS);+ cert.setCreatedAt(now);+ cert.setIssuedAt(status == CertificateStatus.ISSUED ? now : null);+ cert.setNotBefore(generated.notBefore());+ cert.setNotAfter(generated.notAfter());+ cert.setSerial(generated.serial());+ cert.setSubject(generated.subject());+ cert.setIssuer(generated.issuer());+ cert.setKeyAlgorithm(alg);+ cert.setSignatureAlgorithm(generated.signatureAlgorithm());+ cert.setCertificateBody(generated.certificatePem());+ cert.setPrivateKey(generated.privateKeyPem());+ cert.setCertificateChain(getAwsRootCa());+ cert.setCertOptions(options != null ? options : CertificateOptions.defaultOptions());+ cert.setCertAuthorityArn(certAuthorityArn);+ cert.setIdempotencyToken(idempotencyToken);+ cert.setTags(tags != null ? new HashMap<>(tags) : new HashMap<>());++ // Generate domain validation options with correct status based on type+ List<DomainValidation> validations = new ArrayList<>();+ for (String san : allSans) {+ validations.add(generateDomainValidation(san, validationMethod, type));+ }+ cert.setDomainValidationOptions(validations);++ String storageKey = regionKey(region, certId);+ store.put(storageKey, cert);++ // Index idempotency token for fast lookups with TTL+ if (idempotencyToken != null && !idempotencyToken.isEmpty()) {+ int requestHash = computeRequestHash(domainName, sans, alg);+ idempotencyTokenIndex.put(region + "::" + idempotencyToken,+ IdempotencyTokenEntry.create(arn, requestHash));+ }++ LOG.infov("Created certificate: {0} in region {1}", arn, region);+ return cert;+ }++ // ============ DescribeCertificate ============++ public Certificate describeCertificate(String certificateArn, String region) {+ Certificate cert = getCertificateByArn(certificateArn, region);++ // Check for expiration+ if (cert.isExpired() && cert.getStatus() != CertificateStatus.EXPIRED) {+ cert.setStatus(CertificateStatus.EXPIRED);+ store.put(regionKey(region, cert.extractCertificateId()), cert);+ }++ return cert;+ }++ // ============ GetCertificate ============++ public Certificate getCertificate(String certificateArn, String region) {+ return getCertificateByArn(certificateArn, region);+ }++ // ============ ListCertificates ============++ /**+ * Lists certificates with cursor-based pagination.+ *+ * @param statuses Filter by certificate status (null or empty for all)+ * @param keyTypes Filter by key algorithm (null or empty for all)+ * @param region AWS region+ * @param maxItems Maximum items per page (default 100)+ * @param nextToken Cursor for next page (null for first page)+ * @return ListResult containing certificates and optional nextToken+ */+ public ListResult listCertificates(List<CertificateStatus> statuses, List<KeyAlgorithm> keyTypes,+ String region, int maxItems, String nextToken) {+ int limit = maxItems > 0 ? Math.min(maxItems, 1000) : 100;+ String lastArn = decodeToken(nextToken);++ List<Certificate> allCerts = store.scan(k -> true).stream()+ .filter(c -> c.getArn().contains(":acm:" + region + ":"))+ .filter(c -> statuses == null || statuses.isEmpty() || statuses.contains(c.getStatus()))+ .filter(c -> keyTypes == null || keyTypes.isEmpty() || keyTypes.contains(c.getKeyAlgorithm()))+ .sorted(Comparator.comparing(Certificate::getArn))+ .collect(Collectors.toList());++ // Find starting position based on cursor+ int startIndex = 0;+ if (lastArn != null) {+ for (int i = 0; i < allCerts.size(); i++) {+ if (allCerts.get(i).getArn().compareTo(lastArn) > 0) {+ startIndex = i;+ break;+ }+ if (i == allCerts.size() - 1) {+ startIndex = allCerts.size(); // All items before cursor+ }+ }+ }++ // Get page+ List<Certificate> page = allCerts.stream()+ .skip(startIndex)+ .limit(limit)+ .collect(Collectors.toList());++ // Determine if there are more items+ String newNextToken = null;+ if (startIndex + limit < allCerts.size() && !page.isEmpty()) {+ newNextToken = encodeToken(page.get(page.size() - 1).getArn());+ }++ return new ListResult(page, newNextToken);+ }++ /**+ * Encodes a pagination cursor as Base64 JSON.+ */+ private String encodeToken(String lastArn) {+ if (lastArn == null) return null;+ String json = "{\"lastArn\":\"" + lastArn + "\"}";+ return Base64.getEncoder().encodeToString(json.getBytes(StandardCharsets.UTF_8));+ }++ /**+ * Decodes a pagination cursor from Base64 JSON.+ */+ private String decodeToken(String token) {+ if (token == null || token.isEmpty()) return null;+ try {+ String json = new String(Base64.getDecoder().decode(token), StandardCharsets.UTF_8);+ // Simple JSON parsing without Jackson dependency in this method+ int start = json.indexOf("\"lastArn\":\"") + 11;+ int end = json.indexOf("\"", start);+ return json.substring(start, end);+ } catch (Exception e) {+ throw new AwsException("InvalidNextTokenException", "Invalid pagination token", 400);+ }+ }++ // ============ DeleteCertificate ============++ public void deleteCertificate(String certificateArn, String region) {+ Certificate cert = getCertificateByArn(certificateArn, region);++ if (cert.getInUseBy() != null && !cert.getInUseBy().isEmpty()) {+ throw new AwsException("ResourceInUseException",+ "Certificate " + certificateArn + " is in use by: " + String.join(", ", cert.getInUseBy()), 409);+ }++ String storageKey = regionKey(region, cert.extractCertificateId());+ store.delete(storageKey);+ LOG.infov("Deleted certificate: {0}", certificateArn);+ }++ // ============ ImportCertificate ============++ public Certificate importCertificate(String certificatePem, String privateKeyPem, String chainPem,+ String existingArn, Map<String, String> tags, String region) {+ logSecurityWarningOnce();+ // Parse and validate certificate+ X509Certificate x509Cert;+ try {+ x509Cert = certificateGenerator.parseCertificate(certificatePem);+ certificateGenerator.validateCertificate(x509Cert);+ } catch (Exception e) {+ throw new AwsException("ValidationException", "Invalid certificate: " + e.getMessage(), 400);+ }++ // Parse and validate private key+ try {+ certificateGenerator.parsePrivateKey(privateKeyPem);+ } catch (Exception e) {+ throw new AwsException("ValidationException", "Invalid private key: " + e.getMessage(), 400);+ }++ if (tags != null) {+ validateTags(tags);+ }++ String certId;+ String arn;++ if (existingArn != null && !existingArn.isEmpty()) {+ // Re-import+ Certificate existing = getCertificateByArn(existingArn, region);+ certId = existing.extractCertificateId();+ arn = existingArn;+ } else {+ certId = UUID.randomUUID().toString();+ arn = buildCertificateArn(region, certId);+ }++ Instant now = Instant.now();+ KeyAlgorithm keyAlg = certificateGenerator.detectKeyAlgorithm(x509Cert.getPublicKey());++ Certificate cert = new Certificate();+ cert.setArn(arn);+ cert.setDomainName(extractCommonName(x509Cert));+ cert.setStatus(CertificateStatus.ISSUED);+ cert.setType(CertificateType.IMPORTED);+ cert.setCreatedAt(existingArn == null ? now : null);+ cert.setImportedAt(now);+ cert.setIssuedAt(now);+ cert.setNotBefore(x509Cert.getNotBefore().toInstant());+ cert.setNotAfter(x509Cert.getNotAfter().toInstant());+ cert.setSerial(x509Cert.getSerialNumber().toString());+ cert.setSubject(x509Cert.getSubjectX500Principal().getName());+ cert.setIssuer(x509Cert.getIssuerX500Principal().getName());+ cert.setKeyAlgorithm(keyAlg);+ cert.setSignatureAlgorithm(x509Cert.getSigAlgName());+ cert.setCertificateBody(certificatePem);+ cert.setPrivateKey(privateKeyPem);+ cert.setCertificateChain(chainPem);+ cert.setTags(tags != null ? new HashMap<>(tags) : new HashMap<>());++ String storageKey = regionKey(region, certId);+ store.put(storageKey, cert);++ LOG.infov("Imported certificate: {0}", arn);+ return cert;+ }++ // ============ ExportCertificate ============++ public Certificate exportCertificate(String certificateArn, String passphraseBase64, String region) {+ Certificate cert = getCertificateByArn(certificateArn, region);++ if (!cert.canExport()) {+ throw new AwsException("ValidationException",+ "Certificate is not PRIVATE type and Export is not ENABLED", 400);+ }++ String passphrase;+ try {+ passphrase = new String(Base64.getDecoder().decode(passphraseBase64));+ } catch (Exception e) {+ throw new AwsException("ValidationException", "Invalid passphrase encoding", 400);+ }++ if (passphrase.length() < 4) {+ throw new AwsException("ValidationException", "Passphrase must be at least 4 characters", 400);+ }++ // Encrypt the private key+ String encryptedKey = certificateGenerator.encryptPrivateKey(cert.getPrivateKey(), passphrase);++ // Return certificate with encrypted private key+ Certificate exportCert = new Certificate();+ exportCert.setCertificateBody(cert.getCertificateBody());+ exportCert.setCertificateChain(cert.getCertificateChain());+ exportCert.setPrivateKey(encryptedKey);+ return exportCert;+ }++ // ============ Tagging Operations ============++ public void addTagsToCertificate(String certificateArn, Map<String, String> tags, String region) {+ Certificate cert = getCertificateByArn(certificateArn, region);+ validateTags(tags);++ Map<String, String> currentTags = cert.getTags() != null ? new HashMap<>(cert.getTags()) : new HashMap<>();+ currentTags.putAll(tags);++ if (currentTags.size() > MAX_TAGS) {+ throw new AwsException("TooManyTagsException",+ "Certificate cannot have more than " + MAX_TAGS + " tags", 400);+ }++ cert.setTags(currentTags);+ store.put(regionKey(region, cert.extractCertificateId()), cert);+ }++ public Map<String, String> listTagsForCertificate(String certificateArn, String region) {+ Certificate cert = getCertificateByArn(certificateArn, region);+ return cert.getTags() != null ? new HashMap<>(cert.getTags()) : new HashMap<>();+ }++ public void removeTagsFromCertificate(String certificateArn, List<Map<String, String>> tagSpecs, String region) {+ Certificate cert = getCertificateByArn(certificateArn, region);+ Map<String, String> currentTags = cert.getTags() != null ? new HashMap<>(cert.getTags()) : new HashMap<>();++ for (Map<String, String> spec : tagSpecs) {+ String key = spec.get("Key");+ String value = spec.get("Value");+ if (key != null) {+ if (value == null) {+ // Remove by key only+ currentTags.remove(key);+ } else {+ // Remove only if value matches+ if (value.equals(currentTags.get(key))) {+ currentTags.remove(key);+ }+ }+ }+ }++ cert.setTags(currentTags);+ store.put(regionKey(region, cert.extractCertificateId()), cert);+ }++ // ============ Account Configuration ============++ public int getAccountDaysBeforeExpiry() {+ return accountDaysBeforeExpiry.get();+ }++ public void putAccountConfiguration(int daysBeforeExpiry, String idempotencyToken) {+ if (daysBeforeExpiry < 1 || daysBeforeExpiry > 90) {+ throw new AwsException("ValidationException",+ "DaysBeforeExpiry must be between 1 and 90", 400);+ }+ this.accountDaysBeforeExpiry.set(daysBeforeExpiry);+ }++ // ============ Helper Methods ============++ private Certificate getCertificateByArn(String arn, String region) {+ String certId = extractCertificateIdFromArn(arn);+ String storageKey = regionKey(region, certId);++ return store.get(storageKey).orElseThrow(() ->+ new AwsException("ResourceNotFoundException",+ "The certificate " + arn + " does not exist.", 404));+ }++ /**+ * Finds a certificate by idempotency token with lazy expiration.+ *+ * <p>Implementation follows moto's pattern (moto/acm/models.py:478-505):+ * expired entries are removed on lookup rather than using a background+ * cleanup thread.</p>+ *+ * @param token The idempotency token+ * @param region AWS region+ * @param requestHash Hash of current request parameters for validation+ * @return Optional containing the certificate if token is valid and not expired+ * @throws AwsException if token exists but parameters don't match (IdempotencyTokenException)+ */+ private Optional<Certificate> findByIdempotencyToken(String token, String region, int requestHash) {+ String indexKey = region + "::" + token;+ IdempotencyTokenEntry entry = idempotencyTokenIndex.get(indexKey);++ if (entry == null) {+ return Optional.empty();+ }++ // Lazy expiration: remove expired entries on lookup+ if (entry.isExpired()) {+ idempotencyTokenIndex.remove(indexKey);+ return Optional.empty();+ }++ // Validate request parameters match+ if (entry.requestHash() != requestHash) {+ throw new AwsException("IdempotencyException",+ "An idempotency token was used with a request that does not match a previous request " ++ "that used that token.", 400);+ }++ String certId = extractCertificateIdFromArn(entry.arn());+ return store.get(regionKey(region, certId));+ }++ /**+ * Computes a hash of request parameters for idempotency validation.+ * Parameters include: domainName, SANs (order-independent), keyAlgorithm.+ */+ private int computeRequestHash(String domainName, List<String> sans, KeyAlgorithm keyAlgorithm) {+ return Objects.hash(+ domainName,+ sans != null ? new HashSet<>(sans) : null,+ keyAlgorithm+ );+ }++ private void validateDomainName(String domainName) {+ if (domainName == null || domainName.isEmpty()) {+ throw new AwsException("ValidationException", "Domain name cannot be empty", 400);+ }+ if (domainName.length() > MAX_DOMAIN_LENGTH) {+ throw new AwsException("ValidationException",+ "Domain name cannot exceed " + MAX_DOMAIN_LENGTH + " characters", 400);+ }+ }++ private void validateSans(List<String> sans) {+ if (sans != null && sans.size() > MAX_SANS) {+ throw new AwsException("ValidationException",+ "Cannot have more than " + MAX_SANS + " subject alternative names", 400);+ }+ }++ private void validateTags(Map<String, String> tags) {+ if (tags == null) return;++ // Check total number of tags+ if (tags.size() > MAX_TAGS) {+ throw new AwsException("ValidationException",+ "Cannot have more than " + MAX_TAGS + " tags", 400);+ }++ for (Map.Entry<String, String> entry : tags.entrySet()) {+ String key = entry.getKey();+ String value = entry.getValue();++ if (key == null || key.isEmpty() || key.length() > MAX_TAG_KEY_LENGTH) {+ throw new AwsException("ValidationException",+ "Tag key must be 1-" + MAX_TAG_KEY_LENGTH + " characters", 400);+ }+ if (key.toLowerCase().startsWith("aws:")) {+ throw new AwsException("ValidationException",+ "Tag key cannot start with 'aws:'", 400);+ }+ if (value != null && value.length() > MAX_TAG_VALUE_LENGTH) {+ throw new AwsException("ValidationException",+ "Tag value cannot exceed " + MAX_TAG_VALUE_LENGTH + " characters", 400);+ }+ }+ }++ /**+ * Generates domain validation options with status based on certificate type.+ * Private certificates have SUCCESS status immediately; public certificates+ * start with PENDING_VALIDATION until DNS/email validation completes.+ */+ private DomainValidation generateDomainValidation(String domain, ValidationMethod method, CertificateType type) {+ String validationToken = generateValidationToken(domain);+ ResourceRecord resourceRecord = new ResourceRecord(+ "_" + validationToken.substring(0, 32) + "." + domain + ".",+ "CNAME",+ "_" + validationToken.substring(32) + ".acm-validations.aws."+ );++ // Private certificates don't need validation; public certificates do+ String validationStatus = (type == CertificateType.PRIVATE) ? "SUCCESS" : "PENDING_VALIDATION";++ return new DomainValidation(+ domain,+ domain,+ validationStatus,+ method != null ? method.name() : "DNS",+ resourceRecord,+ null+ );+ }++ private String generateValidationToken(String domain) {+ byte[] randomBytes = new byte[32];+ SECURE_RANDOM.nextBytes(randomBytes);+ return HexFormat.of().formatHex(randomBytes);+ }++ private String buildCertificateArn(String region, String certId) {+ String accountId = regionResolver.getAccountId();+ return "arn:aws:acm:" + region + ":" + accountId + ":certificate/" + certId;+ }++ private String extractCertificateIdFromArn(String arn) {+ int lastSlash = arn.lastIndexOf('/');+ return lastSlash >= 0 ? arn.substring(lastSlash + 1) : arn;+ }++ private String regionKey(String region, String certId) {+ return region + "::" + certId;+ }++ private String extractCommonName(X509Certificate cert) {+ String dn = cert.getSubjectX500Principal().getName();+ return Arrays.stream(dn.split(","))+ .map(String::trim)+ .filter(s -> s.startsWith("CN="))+ .findFirst()+ .map(s -> s.substring(3))+ .orElse(dn);+ }++ private String getAwsRootCa() {+ try (InputStream is = getClass().getResourceAsStream("/certs/amazon-root-ca.pem")) {+ if (is == null) {+ LOG.warn("Could not load Amazon Root CA from resources, using empty chain");+ return "";+ }+ return new String(is.readAllBytes(), StandardCharsets.UTF_8);+ } catch (IOException e) {+ LOG.warn("Failed to load Amazon Root CA: " + e.getMessage());+ return "";+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerationException.java b/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerationException.javanew file mode 100644index 0000000000..1324d092a7--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerationException.java@@ -0,0 +1,15 @@+package io.github.hectorvent.floci.services.acm;++/**+ * Exception thrown when certificate generation or parsing fails.+ */+public class CertificateGenerationException extends RuntimeException {++ public CertificateGenerationException(String message) {+ super(message);+ }++ public CertificateGenerationException(String message, Throwable cause) {+ super(message, cause);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerator.java b/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerator.javanew file mode 100644index 0000000000..6c5b000f67--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerator.java@@ -0,0 +1,282 @@+package io.github.hectorvent.floci.services.acm;++import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import jakarta.enterprise.context.ApplicationScoped;+import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;+import org.bouncycastle.asn1.x500.X500Name;+import org.bouncycastle.asn1.x509.BasicConstraints;+import org.bouncycastle.asn1.x509.Extension;+import org.bouncycastle.asn1.x509.GeneralName;+import org.bouncycastle.asn1.x509.GeneralNames;+import org.bouncycastle.asn1.x509.KeyUsage;+import org.bouncycastle.cert.X509CertificateHolder;+import org.bouncycastle.cert.X509v3CertificateBuilder;+import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;+import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;+import org.bouncycastle.jce.provider.BouncyCastleProvider;+import org.bouncycastle.openssl.PEMParser;+import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;+import org.bouncycastle.openssl.jcajce.JcaPEMWriter;+import org.bouncycastle.openssl.jcajce.JcePEMEncryptorBuilder;+import org.bouncycastle.operator.ContentSigner;+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;+import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo;+import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfoBuilder;+import org.bouncycastle.pkcs.jcajce.JcaPKCS8EncryptedPrivateKeyInfoBuilder;+import org.bouncycastle.pkcs.jcajce.JcePKCSPBEOutputEncryptorBuilder;+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;+import org.jboss.logging.Logger;++import java.io.StringReader;+import java.io.StringWriter;+import java.math.BigInteger;+import java.security.KeyPair;+import java.security.KeyPairGenerator;+import java.security.PrivateKey;+import java.security.PublicKey;+import java.security.SecureRandom;+import java.security.Security;+import java.security.cert.X509Certificate;+import java.security.spec.ECGenParameterSpec;+import java.time.Instant;+import java.time.temporal.ChronoUnit;+import java.util.ArrayList;+import java.util.Date;+import java.util.List;++@ApplicationScoped+public class CertificateGenerator {++ private static final Logger LOG = Logger.getLogger(CertificateGenerator.class);+ private static final String ISSUER_DN = "CN=Amazon,OU=Server CA 1B,O=Amazon,C=US";+ private static final SecureRandom SECURE_RANDOM = new SecureRandom();++ public record GeneratedCertificate(+ String certificatePem,+ String privateKeyPem,+ String serial,+ Instant notBefore,+ Instant notAfter,+ String subject,+ String issuer,+ String signatureAlgorithm+ ) {}++ /**+ * Generates a self-signed X.509 certificate for local emulation.+ *+ * <p>Note: RSA key generation (especially 4096-bit) can take 100-500ms.+ * In production emulator usage, consider moving this to a worker thread+ * or using virtual threads for concurrent certificate generation.</p>+ */+ public GeneratedCertificate generateCertificate(String domainName, List<String> sans, KeyAlgorithm keyAlgorithm) {+ try {+ KeyPair keyPair = generateKeyPair(keyAlgorithm);++ Instant now = Instant.now();+ Instant notBefore = now;+ Instant notAfter = now.plus(365, ChronoUnit.DAYS);++ BigInteger serial = new BigInteger(128, SECURE_RANDOM);+ String subjectDn = "CN=" + domainName;++ X500Name issuer = new X500Name(ISSUER_DN);+ X500Name subject = new X500Name(subjectDn);++ String signatureAlgorithm = keyAlgorithm.getAlgorithm().equals("EC")+ ? "SHA512withECDSA"+ : "SHA512WithRSA";++ X509v3CertificateBuilder certBuilder = new JcaX509v3CertificateBuilder(+ issuer,+ serial,+ Date.from(notBefore),+ Date.from(notAfter),+ subject,+ keyPair.getPublic()+ );++ // Add Subject Alternative Names+ List<GeneralName> sanList = new ArrayList<>();+ sanList.add(new GeneralName(GeneralName.dNSName, domainName));+ if (sans != null) {+ for (String san : sans) {+ if (!san.equals(domainName)) {+ sanList.add(new GeneralName(GeneralName.dNSName, san));+ }+ }+ }+ GeneralNames generalNames = new GeneralNames(sanList.toArray(new GeneralName[0]));+ certBuilder.addExtension(Extension.subjectAlternativeName, false, generalNames);++ // Add Key Usage+ certBuilder.addExtension(+ Extension.keyUsage,+ true,+ new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyEncipherment)+ );++ // Add Basic Constraints (not a CA)+ certBuilder.addExtension(+ Extension.basicConstraints,+ true,+ new BasicConstraints(false)+ );++ // Self-signed certificate for local emulation - signed with subject's own private key+ // Real AWS ACM certificates are signed by Amazon's CA hierarchy+ ContentSigner signer = new JcaContentSignerBuilder(signatureAlgorithm)+ .setProvider(BouncyCastleProvider.PROVIDER_NAME)+ .build(keyPair.getPrivate());++ X509CertificateHolder certHolder = certBuilder.build(signer);+ X509Certificate cert = new JcaX509CertificateConverter()+ .setProvider(BouncyCastleProvider.PROVIDER_NAME)+ .getCertificate(certHolder);++ String certPem = toPem(cert);+ String keyPem = toPem(keyPair.getPrivate());++ return new GeneratedCertificate(+ certPem,+ keyPem,+ serial.toString(),+ notBefore,+ notAfter,+ subjectDn,+ ISSUER_DN,+ signatureAlgorithm+ );++ } catch (Exception e) {+ LOG.error("Failed to generate certificate", e);+ throw new CertificateGenerationException("Certificate generation failed: " + e.getMessage(), e);+ }+ }++ private KeyPair generateKeyPair(KeyAlgorithm keyAlgorithm) throws Exception {+ KeyPairGenerator keyGen;+ if ("EC".equals(keyAlgorithm.getAlgorithm())) {+ keyGen = KeyPairGenerator.getInstance("EC", BouncyCastleProvider.PROVIDER_NAME);+ keyGen.initialize(new ECGenParameterSpec(keyAlgorithm.getCurveName()), SECURE_RANDOM);+ } else {+ keyGen = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME);+ keyGen.initialize(keyAlgorithm.getKeySize(), SECURE_RANDOM);+ }+ return keyGen.generateKeyPair();+ }++ private String toPem(Object obj) throws Exception {+ StringWriter sw = new StringWriter();+ try (JcaPEMWriter pemWriter = new JcaPEMWriter(sw)) {+ pemWriter.writeObject(obj);+ }+ return sw.toString();+ }++ /**+ * Encrypts a private key using AES-256-CBC (replacing deprecated Triple-DES).+ *+ * @param privateKeyPem The private key in PEM format+ * @param passphrase The passphrase for encryption+ * @return Encrypted private key in PEM format+ */+ public String encryptPrivateKey(String privateKeyPem, String passphrase) {+ try {+ PrivateKey privateKey = parsePrivateKey(privateKeyPem);++ // Use AES-256-CBC instead of deprecated Triple-DES+ JcePKCSPBEOutputEncryptorBuilder encryptorBuilder = new JcePKCSPBEOutputEncryptorBuilder(+ NISTObjectIdentifiers.id_aes256_CBC+ );+ encryptorBuilder.setProvider(BouncyCastleProvider.PROVIDER_NAME);++ PKCS8EncryptedPrivateKeyInfoBuilder pkcs8Builder = new JcaPKCS8EncryptedPrivateKeyInfoBuilder(privateKey);+ PKCS8EncryptedPrivateKeyInfo encryptedInfo = pkcs8Builder.build(+ encryptorBuilder.build(passphrase.toCharArray())+ );++ StringWriter sw = new StringWriter();+ try (JcaPEMWriter pemWriter = new JcaPEMWriter(sw)) {+ pemWriter.writeObject(encryptedInfo);+ }+ return sw.toString();++ } catch (Exception e) {+ LOG.error("Failed to encrypt private key", e);+ throw new CertificateGenerationException("Private key encryption failed: " + e.getMessage(), e);+ }+ }++ public X509Certificate parseCertificate(String certPem) {+ try (PEMParser parser = new PEMParser(new StringReader(certPem))) {+ Object obj = parser.readObject();+ if (obj instanceof X509CertificateHolder holder) {+ return new JcaX509CertificateConverter()+ .setProvider(BouncyCastleProvider.PROVIDER_NAME)+ .getCertificate(holder);+ }+ throw new IllegalArgumentException("Invalid certificate PEM format");+ } catch (Exception e) {+ LOG.error("Failed to parse certificate", e);+ throw new CertificateGenerationException("Certificate parsing failed: " + e.getMessage(), e);+ }+ }++ public PrivateKey parsePrivateKey(String keyPem) {+ try (PEMParser parser = new PEMParser(new StringReader(keyPem))) {+ Object obj = parser.readObject();+ JcaPEMKeyConverter converter = new JcaPEMKeyConverter()+ .setProvider(BouncyCastleProvider.PROVIDER_NAME);++ if (obj instanceof org.bouncycastle.openssl.PEMKeyPair pemKeyPair) {+ return converter.getKeyPair(pemKeyPair).getPrivate();+ } else if (obj instanceof org.bouncycastle.asn1.pkcs.PrivateKeyInfo pkInfo) {+ return converter.getPrivateKey(pkInfo);+ }+ throw new IllegalArgumentException("Invalid private key PEM format");+ } catch (Exception e) {+ LOG.error("Failed to parse private key", e);+ throw new CertificateGenerationException("Private key parsing failed: " + e.getMessage(), e);+ }+ }++ public void validateCertificate(X509Certificate cert) {+ try {+ cert.checkValidity();+ } catch (Exception e) {+ throw new IllegalArgumentException("Certificate validation failed: " + e.getMessage(), e);+ }+ }++ public KeyAlgorithm detectKeyAlgorithm(PublicKey publicKey) {+ String algorithm = publicKey.getAlgorithm();+ if ("RSA".equals(algorithm)) {+ try {+ java.security.interfaces.RSAPublicKey rsaKey = (java.security.interfaces.RSAPublicKey) publicKey;+ int keySize = rsaKey.getModulus().bitLength();+ return switch (keySize) {+ case 1024 -> KeyAlgorithm.RSA_1024;+ case 3072 -> KeyAlgorithm.RSA_3072;+ case 4096 -> KeyAlgorithm.RSA_4096;+ default -> KeyAlgorithm.RSA_2048;+ };+ } catch (Exception e) {+ return KeyAlgorithm.RSA_2048;+ }+ } else if ("EC".equals(algorithm)) {+ try {+ java.security.interfaces.ECPublicKey ecKey = (java.security.interfaces.ECPublicKey) publicKey;+ int fieldSize = ecKey.getParams().getCurve().getField().getFieldSize();+ return switch (fieldSize) {+ case 384 -> KeyAlgorithm.EC_secp384r1;+ case 521 -> KeyAlgorithm.EC_secp521r1;+ default -> KeyAlgorithm.EC_prime256v1;+ };+ } catch (Exception e) {+ return KeyAlgorithm.EC_prime256v1;+ }+ }+ return KeyAlgorithm.RSA_2048;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/Certificate.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/Certificate.javanew file mode 100644index 0000000000..cfb86113b8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/Certificate.java@@ -0,0 +1,267 @@+package io.github.hectorvent.floci.services.acm.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.HashMap;+import java.util.List;+import java.util.Map;++/**+ * Mutable certificate entity for Jackson serialization/deserialization.+ * Thread-safety is managed by the storage layer (ConcurrentHashMap).+ *+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/API_CertificateDetail.html">AWS ACM CertificateDetail</a>+ */+@RegisterForReflection+public class Certificate {+ private String arn;+ private String domainName;+ private List<String> subjectAlternativeNames;+ private CertificateStatus status;+ private CertificateType type;+ private ValidationMethod validationMethod;+ private Instant createdAt;+ private Instant issuedAt;+ private Instant importedAt;+ private Instant notBefore;+ private Instant notAfter;+ private String serial;+ private String subject;+ private String issuer;+ private KeyAlgorithm keyAlgorithm;+ private String signatureAlgorithm;+ private List<String> inUseBy;+ private Map<String, String> tags;+ private String certificateBody;+ private String privateKey;+ private String certificateChain;+ private CertificateOptions certOptions;+ private String certAuthorityArn;+ private List<DomainValidation> domainValidationOptions;+ private String idempotencyToken;++ public Certificate() {+ this.subjectAlternativeNames = new ArrayList<>();+ this.inUseBy = new ArrayList<>();+ this.tags = new HashMap<>();+ this.domainValidationOptions = new ArrayList<>();+ }++ // Getters and Setters+ public String getArn() {+ return arn;+ }++ public void setArn(String arn) {+ this.arn = arn;+ }++ public String getDomainName() {+ return domainName;+ }++ public void setDomainName(String domainName) {+ this.domainName = domainName;+ }++ public List<String> getSubjectAlternativeNames() {+ return subjectAlternativeNames;+ }++ public void setSubjectAlternativeNames(List<String> subjectAlternativeNames) {+ this.subjectAlternativeNames = subjectAlternativeNames != null ? new ArrayList<>(subjectAlternativeNames) : new ArrayList<>();+ }++ public CertificateStatus getStatus() {+ return status;+ }++ public void setStatus(CertificateStatus status) {+ this.status = status;+ }++ public CertificateType getType() {+ return type;+ }++ public void setType(CertificateType type) {+ this.type = type;+ }++ public ValidationMethod getValidationMethod() {+ return validationMethod;+ }++ public void setValidationMethod(ValidationMethod validationMethod) {+ this.validationMethod = validationMethod;+ }++ public Instant getCreatedAt() {+ return createdAt;+ }++ public void setCreatedAt(Instant createdAt) {+ this.createdAt = createdAt;+ }++ public Instant getIssuedAt() {+ return issuedAt;+ }++ public void setIssuedAt(Instant issuedAt) {+ this.issuedAt = issuedAt;+ }++ public Instant getImportedAt() {+ return importedAt;+ }++ public void setImportedAt(Instant importedAt) {+ this.importedAt = importedAt;+ }++ public Instant getNotBefore() {+ return notBefore;+ }++ public void setNotBefore(Instant notBefore) {+ this.notBefore = notBefore;+ }++ public Instant getNotAfter() {+ return notAfter;+ }++ public void setNotAfter(Instant notAfter) {+ this.notAfter = notAfter;+ }++ public String getSerial() {+ return serial;+ }++ public void setSerial(String serial) {+ this.serial = serial;+ }++ public String getSubject() {+ return subject;+ }++ public void setSubject(String subject) {+ this.subject = subject;+ }++ public String getIssuer() {+ return issuer;+ }++ public void setIssuer(String issuer) {+ this.issuer = issuer;+ }++ public KeyAlgorithm getKeyAlgorithm() {+ return keyAlgorithm;+ }++ public void setKeyAlgorithm(KeyAlgorithm keyAlgorithm) {+ this.keyAlgorithm = keyAlgorithm;+ }++ public String getSignatureAlgorithm() {+ return signatureAlgorithm;+ }++ public void setSignatureAlgorithm(String signatureAlgorithm) {+ this.signatureAlgorithm = signatureAlgorithm;+ }++ public List<String> getInUseBy() {+ return inUseBy;+ }++ public void setInUseBy(List<String> inUseBy) {+ this.inUseBy = inUseBy != null ? new ArrayList<>(inUseBy) : new ArrayList<>();+ }++ public Map<String, String> getTags() {+ return tags;+ }++ public void setTags(Map<String, String> tags) {+ this.tags = tags != null ? new HashMap<>(tags) : new HashMap<>();+ }++ public String getCertificateBody() {+ return certificateBody;+ }++ public void setCertificateBody(String certificateBody) {+ this.certificateBody = certificateBody;+ }++ public String getPrivateKey() {+ return privateKey;+ }++ public void setPrivateKey(String privateKey) {+ this.privateKey = privateKey;+ }++ public String getCertificateChain() {+ return certificateChain;+ }++ public void setCertificateChain(String certificateChain) {+ this.certificateChain = certificateChain;+ }++ public CertificateOptions getCertOptions() {+ return certOptions;+ }++ public void setCertOptions(CertificateOptions certOptions) {+ this.certOptions = certOptions;+ }++ public String getCertAuthorityArn() {+ return certAuthorityArn;+ }++ public void setCertAuthorityArn(String certAuthorityArn) {+ this.certAuthorityArn = certAuthorityArn;+ }++ public List<DomainValidation> getDomainValidationOptions() {+ return domainValidationOptions;+ }++ public void setDomainValidationOptions(List<DomainValidation> domainValidationOptions) {+ this.domainValidationOptions = domainValidationOptions != null ? new ArrayList<>(domainValidationOptions) : new ArrayList<>();+ }++ public String getIdempotencyToken() {+ return idempotencyToken;+ }++ public void setIdempotencyToken(String idempotencyToken) {+ this.idempotencyToken = idempotencyToken;+ }++ public boolean isExpired() {+ return notAfter != null && Instant.now().isAfter(notAfter);+ }++ public boolean canExport() {+ return type == CertificateType.PRIVATE ||+ (certOptions != null && "ENABLED".equals(certOptions.export()));+ }++ public String extractCertificateId() {+ if (arn == null) return null;+ int lastSlash = arn.lastIndexOf('/');+ return lastSlash >= 0 ? arn.substring(lastSlash + 1) : arn;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateOptions.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateOptions.javanew file mode 100644index 0000000000..b8804bb583--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateOptions.java@@ -0,0 +1,13 @@+package io.github.hectorvent.floci.services.acm.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+public record CertificateOptions(+ String certificateTransparencyLoggingPreference,+ String export+) {+ public static CertificateOptions defaultOptions() {+ return new CertificateOptions("ENABLED", "DISABLED");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateStatus.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateStatus.javanew file mode 100644index 0000000000..0821c8ee6a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateStatus.java@@ -0,0 +1,19 @@+package io.github.hectorvent.floci.services.acm.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * Certificate lifecycle status values matching AWS ACM.+ *+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/API_CertificateDetail.html">AWS ACM CertificateDetail</a>+ */+@RegisterForReflection+public enum CertificateStatus {+ PENDING_VALIDATION,+ ISSUED,+ INACTIVE,+ EXPIRED,+ VALIDATION_TIMED_OUT,+ REVOKED,+ FAILED+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateType.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateType.javanew file mode 100644index 0000000000..f632d418d3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/CertificateType.java@@ -0,0 +1,15 @@+package io.github.hectorvent.floci.services.acm.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * Certificate type indicating how the certificate was provisioned.+ *+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/API_CertificateDetail.html">AWS ACM CertificateDetail</a>+ */+@RegisterForReflection+public enum CertificateType {+ AMAZON_ISSUED,+ IMPORTED,+ PRIVATE+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/DomainValidation.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/DomainValidation.javanew file mode 100644index 0000000000..a3dbc9e13b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/DomainValidation.java@@ -0,0 +1,15 @@+package io.github.hectorvent.floci.services.acm.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+public record DomainValidation(+ String domainName,+ String validationDomain,+ String validationStatus,+ String validationMethod,+ ResourceRecord resourceRecord,+ List<String> validationEmails+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/IdempotencyTokenEntry.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/IdempotencyTokenEntry.javanew file mode 100644index 0000000000..634f70214b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/IdempotencyTokenEntry.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.services.acm.model;++import java.time.Duration;+import java.time.Instant;++/**+ * Entry for idempotency token cache with lazy expiration.+ *+ * <p>Design decision: Using ConcurrentHashMap with timestamp-based entries+ * instead of Caffeine or scheduled cleanup. This matches moto's approach+ * (see moto/acm/models.py:478-505) where expired entries are removed on+ * lookup. No background thread needed - acceptable for emulator workloads.</p>+ *+ * @param arn The certificate ARN associated with this token+ * @param expires Expiration instant (1 hour after creation)+ * @param requestHash Hash of original request parameters for validation+ * @see <a href="https://github.com/getmoto/moto/blob/main/moto/acm/models.py">moto ACM</a>+ */+public record IdempotencyTokenEntry(+ String arn,+ Instant expires,+ int requestHash+) {+ private static final Duration TTL = Duration.ofHours(1);++ /**+ * Creates a new idempotency token entry with 1-hour TTL from current time.+ *+ * @param arn The certificate ARN+ * @param requestHash Hash of the request parameters+ * @return New entry with expiration set to current time + 1 hour+ */+ public static IdempotencyTokenEntry create(String arn, int requestHash) {+ return new IdempotencyTokenEntry(arn, Instant.now().plus(TTL), requestHash);+ }++ /**+ * Checks if this token entry has expired.+ *+ * @return true if the current time is after the expiration instant+ */+ public boolean isExpired() {+ return Instant.now().isAfter(expires);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/KeyAlgorithm.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/KeyAlgorithm.javanew file mode 100644index 0000000000..9560caec12--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/KeyAlgorithm.java@@ -0,0 +1,74 @@+package io.github.hectorvent.floci.services.acm.model;++import com.fasterxml.jackson.annotation.JsonValue;+import io.quarkus.runtime.annotations.RegisterForReflection;+import org.jboss.logging.Logger;++/**+ * Key algorithm for certificate key pair generation.+ *+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/API_RequestCertificate.html">AWS ACM RequestCertificate</a>+ */+@RegisterForReflection+public enum KeyAlgorithm {+ RSA_1024("RSA-1024", "RSA", 1024),+ RSA_2048("RSA-2048", "RSA", 2048),+ RSA_3072("RSA-3072", "RSA", 3072),+ RSA_4096("RSA-4096", "RSA", 4096),+ EC_prime256v1("EC-prime256v1", "EC", 256),+ EC_secp384r1("EC-secp384r1", "EC", 384),+ EC_secp521r1("EC-secp521r1", "EC", 521);++ private static final Logger LOG = Logger.getLogger(KeyAlgorithm.class);++ private final String awsName;+ private final String algorithm;+ private final int keySize;++ KeyAlgorithm(String awsName, String algorithm, int keySize) {+ this.awsName = awsName;+ this.algorithm = algorithm;+ this.keySize = keySize;+ }++ @JsonValue+ public String getAwsName() {+ return awsName;+ }++ public String getAlgorithm() {+ return algorithm;+ }++ public int getKeySize() {+ return keySize;+ }++ public String getCurveName() {+ return switch (this) {+ case EC_prime256v1 -> "secp256r1";+ case EC_secp384r1 -> "secp384r1";+ case EC_secp521r1 -> "secp521r1";+ default -> null;+ };+ }++ public static KeyAlgorithm fromAwsName(String name) {+ if (name == null) return RSA_2048;+ // Normalize both directions: RSA_2048 ↔ RSA-2048+ String dashNormalized = name.replace("_", "-");+ String underscoreNormalized = name.replace("-", "_");+ for (KeyAlgorithm alg : values()) {+ // Match against awsName (dash format: "RSA-2048", "EC-prime256v1")+ if (alg.awsName.equalsIgnoreCase(name) || alg.awsName.equalsIgnoreCase(dashNormalized)) {+ return alg;+ }+ // Match against enum name (underscore format: "RSA_2048", "EC_prime256v1")+ if (alg.name().equalsIgnoreCase(name) || alg.name().equalsIgnoreCase(underscoreNormalized)) {+ return alg;+ }+ }+ LOG.warnv("Unknown key algorithm '{0}', defaulting to RSA_2048", name);+ return RSA_2048;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/ListResult.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/ListResult.javanew file mode 100644index 0000000000..55b586dbcb--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/ListResult.java@@ -0,0 +1,18 @@+package io.github.hectorvent.floci.services.acm.model;++import java.util.List;++/**+ * Result of paginated certificate listing.+ *+ * <p>Used by {@code ListCertificates} to return a page of certificates+ * along with a cursor token for fetching the next page.</p>+ *+ * @param certificates List of certificates for this page+ * @param nextToken Token for next page, or null if no more pages+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/API_ListCertificates.html">AWS ACM ListCertificates</a>+ */+public record ListResult(+ List<Certificate> certificates,+ String nextToken+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/ResourceRecord.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/ResourceRecord.javanew file mode 100644index 0000000000..5f6c8b3033--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/ResourceRecord.java@@ -0,0 +1,10 @@+package io.github.hectorvent.floci.services.acm.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+public record ResourceRecord(+ String name,+ String type,+ String value+) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/model/ValidationMethod.java b/src/main/java/io/github/hectorvent/floci/services/acm/model/ValidationMethod.javanew file mode 100644index 0000000000..61e89b7214--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/acm/model/ValidationMethod.java@@ -0,0 +1,14 @@+package io.github.hectorvent.floci.services.acm.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * Domain validation method for certificate issuance.+ *+ * @see <a href="https://docs.aws.amazon.com/acm/latest/APIReference/API_RequestCertificate.html">AWS ACM RequestCertificate</a>+ */+@RegisterForReflection+public enum ValidationMethod {+ DNS,+}diff --git a/src/main/resources/META-INF/native-image/reflect-config.json b/src/main/resources/META-INF/native-image/reflect-config.jsonindex d612e894a8..17fc5bf7fe 100644--- a/src/main/resources/META-INF/native-image/reflect-config.json+++ b/src/main/resources/META-INF/native-image/reflect-config.json@@ -2341,5 +2341,61 @@"allDeclaredConstructors": true,"allDeclaredMethods": true,"allDeclaredFields": true+ },+ {+ "name": "org.bouncycastle.jce.provider.BouncyCastleProvider",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true,+ "allDeclaredFields": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.KeyFactorySpi",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.KeyFactorySpi$EC",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.KeyPairGeneratorSpi",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.KeyPairGeneratorSpi$EC",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.digest.SHA256$Digest",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.digest.SHA384$Digest",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.DigestSignatureSpi$SHA256",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.SignatureSpi$ecDSA256",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.symmetric.AES$ECB",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true+ },+ {+ "name": "org.bouncycastle.jcajce.provider.symmetric.PBEPBKDF2$PBKDF2withSHA256",+ "allDeclaredConstructors": true,+ "allDeclaredMethods": true}]diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex a9c7e994c5..a45c4b8a71 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -3,7 +3,15 @@ quarkus:port: 4566host: 0.0.0.0native:- additional-build-args: "--initialize-at-run-time=org.apache.hc.client5.http.impl.auth.NTLMEngineImpl,--initialize-at-run-time=com.github.dockerjava.transport.NamedPipeSocket$Kernel32"+ additional-build-args: >-+ --initialize-at-run-time=org.apache.hc.client5.http.impl.auth.NTLMEngineImpl,+ --initialize-at-run-time=com.github.dockerjava.transport.NamedPipeSocket$Kernel32,+ --initialize-at-run-time=org.bouncycastle.jcajce.provider.drbg.DRBG$Default,+ --initialize-at-run-time=org.bouncycastle.jcajce.provider.drbg.DRBG$NonceAndIV,+ --initialize-at-run-time=org.bouncycastle.crypto.prng.SP800SecureRandom,+ --initialize-at-run-time=org.bouncycastle.jce.provider.BouncyCastleProvider,+ --initialize-at-run-time=io.github.hectorvent.floci.services.acm.AcmService,+ --initialize-at-run-time=io.github.hectorvent.floci.services.acm.CertificateGeneratorfloci:base-url: "http://localhost:4566"@@ -41,6 +49,9 @@ floci:secretsmanager:mode: memoryflush-interval-ms: 5000+ acm:+ mode: memory+ flush-interval-ms: 5000auth:validate-signatures: false@@ -108,3 +119,6 @@ floci:enabled: truecloudformation:enabled: true+ acm:+ enabled: true+ validation-wait-seconds: 0diff --git a/src/main/resources/certs/amazon-root-ca.pem b/src/main/resources/certs/amazon-root-ca.pemnew file mode 100644index 0000000000..7e2f844d8f--- /dev/null+++ b/src/main/resources/certs/amazon-root-ca.pem@@ -0,0 +1,25 @@+-----BEGIN CERTIFICATE-----+MIIESTCCAzGgAwIBAgITBntQXCplJ7wevi2i0ZmY7bibLDANBgkqhkiG9w0BAQsF+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6+b24gUm9vdCBDQSAxMB4XDTE1MTAyMTIyMjQzNFoXDTQwMTAyMTIyMjQzNFowRjEL+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEVMBMGA1UECxMMU2VydmVyIENB+IDFCMQ8wDQYDVQQDEwZBbWF6b24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK+AoIBAQDCThZn3c68asg3CZwaH2N2FfD7JfHr/RXfbLXEVhvwCMk9CeNAGKnX9EUH+2z9+RH3bQ7wBLM/FY/lBJH/O4Yl+XNM6sFPaLMJy9Ll4iqL7B/f6Mf5c5aFl3bG+m5z3bCMwdBZL2c5OJRFmVF9RhJh3lQbSs7nbVxN3bvVMVlNM5lXCBAB3FZPbEFYi+dB0wfPL9vY1dB7AJ5v4bMl9z5z9qWP2dW7m7v5vRVo+A9TFxn8B7EZVrTXFn3CyM+H9W8+K4iKbQ/7HZ7bVz3AYB5vOZjFU7Lz1h/0OG/m5v6cKGOiJAOmUjThVL3Cjb5+6nRIoTUdHHqP3L9rOi9a7VXnNdWRAgMBAAGjggE7MIIBNzASBgNVHRMBAf8ECDAG+AQH/AgEAMA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUWaRmBlKge5WSPKOUByeW+dFv5PdAwHwYDVR0jBBgwFoAUhBjMhTTsvAyUlC4IWZzHshBOCggwewYIKwYBBQUH+AQEEbzBtMC8GCCsGAQUFBzABhiNodHRwOi8vb2NzcC5yb290Y2ExLmFtYXpvbnRy+dXN0LmNvbTA6BggrBgEFBQcwAoYuaHR0cDovL2NydC5yb290Y2ExLmFtYXpvbnRy+dXN0LmNvbS9yb290Y2ExLmNlcjA/BgNVHR8EODA2MDSgMqAwhi5odHRwOi8vY3Js+LnJvb3RjYTEuYW1hem9udHJ1c3QuY29tL3Jvb3RjYTEuY3JsMBEGA1UdIAQKMAgw+BgYEVR0gADANBgkqhkiG9w0BAQsFAAOCAQEARP3m7HzM/VfnKaFC5rlI+TFkk5N4+rlCWElGh2v9s4k+1p5yTniV3n5/sR3DVHMa5TQ8m+4Z7PsKl/D8UFRl/5eEILxQ++7e5RLk4kcPfbc3VYl/lYgIhEY9CWA2t/FSXJJJu5f0EH0wEcN1A3F8mFbNNgN2N9+RvPWmGd4TCNy58bGmVQYO8+xJJbgTXTJ1HkIw/7VOp6ePm4CIk9MK2K8j9j3fB7b+vRmA1VwLB0K3Vw8jLDl1oLcz/nXPdfXhzzzXJy/TKgIUYJb3SB/k2bECiyM2xyIb+tTmFPau9YqHPBPK8xSpWJ9JfD/2pK1gORqVmBT8R88zcbAj6Qwk/pfKurw==+-----END CERTIFICATE-----diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmEdgeCaseTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmEdgeCaseTest.javanew file mode 100644index 0000000000..f601b0f6d7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmEdgeCaseTest.java@@ -0,0 +1,325 @@+package io.github.hectorvent.floci.services.acm;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import io.restassured.config.EncoderConfig;+import io.restassured.http.ContentType;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.UUID;+import java.util.stream.Collectors;+import java.util.stream.IntStream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++/**+ * Tests for edge cases: wildcard domains, max SANs (100), max tags (50).+ */+@QuarkusTest+class AcmEdgeCaseTest {++ private static final String ACM_CONTENT_TYPE = "application/x-amz-json-1.1";++ @BeforeAll+ static void configureRestAssured() {+ RestAssured.config = RestAssured.config().encoderConfig(+ EncoderConfig.encoderConfig()+ .encodeContentTypeAs(ACM_CONTENT_TYPE, ContentType.TEXT));+ }++ // ==================== Wildcard Domain Tests ====================++ @Test+ void wildcardDomainAsPrimary() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "*.example.com"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ void wildcardDomainAsSan() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "example.com",+ "SubjectAlternativeNames": ["*.example.com", "www.example.com"]+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ void nestedWildcardDomain() {+ // AWS allows wildcards only at the leftmost position+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "*.api.example.com"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ // ==================== Max SANs Tests ====================++ @Test+ void exactlyMaxSans() {+ // 100 SANs is the maximum+ List<String> sans = IntStream.range(0, 99)+ .mapToObj(i -> "san" + i + ".example.com")+ .collect(Collectors.toList());++ String sansJson = sans.stream()+ .map(s -> "\"" + s + "\"")+ .collect(Collectors.joining(", ", "[", "]"));++ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "max-sans.example.com",+ "SubjectAlternativeNames": %s+ }+ """.formatted(sansJson))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ void exceedMaxSans() {+ // 101 SANs should fail (primary domain + 100 SANs = 101 total)+ List<String> sans = IntStream.range(0, 101)+ .mapToObj(i -> "san" + i + ".example.com")+ .collect(Collectors.toList());++ String sansJson = sans.stream()+ .map(s -> "\"" + s + "\"")+ .collect(Collectors.joining(", ", "[", "]"));++ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "exceed-sans.example.com",+ "SubjectAlternativeNames": %s+ }+ """.formatted(sansJson))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ // ==================== Max Tags Tests ====================++ @Test+ void exactlyMaxTags() {+ // 50 tags is the maximum+ String tagsJson = IntStream.range(0, 50)+ .mapToObj(i -> "{\"Key\": \"Tag" + i + "\", \"Value\": \"Value" + i + "\"}")+ .collect(Collectors.joining(", ", "[", "]"));++ String arn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "max-tags-%s.example.com",+ "Tags": %s+ }+ """.formatted(UUID.randomUUID(), tagsJson))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // Verify tags were applied+ given()+ .header("X-Amz-Target", "CertificateManager.ListTagsForCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(arn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags.size()", equalTo(50));+ }++ @Test+ void exceedMaxTags() {+ // 51 tags should fail+ String tagsJson = IntStream.range(0, 51)+ .mapToObj(i -> "{\"Key\": \"Tag" + i + "\", \"Value\": \"Value" + i + "\"}")+ .collect(Collectors.joining(", ", "[", "]"));++ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "exceed-tags.example.com",+ "Tags": %s+ }+ """.formatted(tagsJson))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ // ==================== Validation Method Tests ====================++ @Test+ void invalidValidationMethodThrowsException() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "invalid-validation.example.com",+ "ValidationMethod": "INVALID_METHOD"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ // ==================== Domain Name Validation Tests ====================++ @Test+ void emptyDomainNameFails() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": ""+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ @Test+ void domainNameTooLong() {+ // Max domain length is 253 characters+ String longDomain = "a".repeat(254) + ".example.com";+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s"+ }+ """.formatted(longDomain))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ // ==================== Tag Validation Tests ====================++ @Test+ void awsPrefixedTagKeyFails() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "aws-tag.example.com",+ "Tags": [{"Key": "aws:reserved", "Value": "test"}]+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ @Test+ void emptyTagKeyFails() {+ given()+ .header("X-Amz-Target", "CertificateManager.AddTagsToCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "arn:aws:acm:us-east-1:123456789012:certificate/test",+ "Tags": [{"Key": "", "Value": "test"}]+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(anyOf(equalTo(400), equalTo(404)));+ }++ // ==================== Key Algorithm Tests ====================++ @Test+ void allKeyAlgorithmsSupported() {+ String[] algorithms = {"RSA_2048", "RSA_3072", "RSA_4096", "EC_prime256v1", "EC_secp384r1", "EC_secp521r1"};++ for (String algo : algorithms) {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s.example.com",+ "KeyAlgorithm": "%s"+ }+ """.formatted(algo.toLowerCase().replace("_", "-"), algo))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmIdempotencyTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmIdempotencyTest.javanew file mode 100644index 0000000000..c6e4ec0f64--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmIdempotencyTest.java@@ -0,0 +1,277 @@+package io.github.hectorvent.floci.services.acm;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import io.restassured.config.EncoderConfig;+import io.restassured.http.ContentType;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestInstance;+import org.junit.jupiter.api.TestMethodOrder;++import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++/**+ * Tests for idempotency token functionality with 1-hour TTL.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+@TestInstance(TestInstance.Lifecycle.PER_CLASS)+class AcmIdempotencyTest {++ private static final String ACM_CONTENT_TYPE = "application/x-amz-json-1.1";++ @BeforeAll+ static void configureRestAssured() {+ RestAssured.config = RestAssured.config().encoderConfig(+ EncoderConfig.encoderConfig()+ .encodeContentTypeAs(ACM_CONTENT_TYPE, ContentType.TEXT));+ }++ @Test+ @Order(1)+ void sameTokenReturnsExistingCertificate() {+ String token = "idempotency-test-" + UUID.randomUUID();+ String domain = "idempotent-" + UUID.randomUUID() + ".example.com";++ // First request+ String firstArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "IdempotencyToken": "%s"+ }+ """.formatted(domain, token))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // Second request with same token should return same ARN+ String secondArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "IdempotencyToken": "%s"+ }+ """.formatted(domain, token))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", equalTo(firstArn))+ .extract().jsonPath().getString("CertificateArn");++ // ARNs should match+ org.junit.jupiter.api.Assertions.assertEquals(firstArn, secondArn);+ }++ @Test+ @Order(2)+ void differentTokenCreatesNewCertificate() {+ String domain = "multi-token-" + UUID.randomUUID() + ".example.com";++ // First request+ String firstArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "IdempotencyToken": "token-1-%s"+ }+ """.formatted(domain, UUID.randomUUID()))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // Second request with different token should create new certificate+ String secondArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "IdempotencyToken": "token-2-%s"+ }+ """.formatted(domain, UUID.randomUUID()))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // ARNs should be different+ org.junit.jupiter.api.Assertions.assertNotEquals(firstArn, secondArn);+ }++ @Test+ @Order(3)+ void sameTokenDifferentParamsThrowsIdempotencyException() {+ String token = "param-mismatch-" + UUID.randomUUID();++ // First request with domain A+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "domain-a-%s.example.com",+ "IdempotencyToken": "%s"+ }+ """.formatted(UUID.randomUUID(), token))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ // Second request with same token but different domain - should fail+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "domain-b-%s.example.com",+ "IdempotencyToken": "%s"+ }+ """.formatted(UUID.randomUUID(), token))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("IdempotencyException"));+ }++ @Test+ @Order(4)+ void sameTokenDifferentKeyAlgorithmThrowsIdempotencyException() {+ String token = "key-algo-mismatch-" + UUID.randomUUID();+ String domain = "key-algo-" + UUID.randomUUID() + ".example.com";++ // First request with RSA-2048+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "KeyAlgorithm": "RSA_2048",+ "IdempotencyToken": "%s"+ }+ """.formatted(domain, token))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ // Second request with same token but different key algorithm - should fail+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "KeyAlgorithm": "EC_prime256v1",+ "IdempotencyToken": "%s"+ }+ """.formatted(domain, token))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("IdempotencyException"));+ }++ @Test+ @Order(5)+ void noTokenAlwaysCreatesNewCertificate() {+ String domain = "no-token-" + UUID.randomUUID() + ".example.com";++ // First request without token+ String firstArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s"+ }+ """.formatted(domain))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // Second request without token should create new certificate+ String secondArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s"+ }+ """.formatted(domain))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ org.junit.jupiter.api.Assertions.assertNotEquals(firstArn, secondArn);+ }++ @Test+ @Order(6)+ void sameTokenSameSansReturnsExistingCertificate() {+ String token = "sans-match-" + UUID.randomUUID();+ String domain = "sans-" + UUID.randomUUID() + ".example.com";++ // First request with SANs+ String firstArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "SubjectAlternativeNames": ["www.%s", "api.%s"],+ "IdempotencyToken": "%s"+ }+ """.formatted(domain, domain, domain, token))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // Same request should return same ARN+ String secondArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "%s",+ "SubjectAlternativeNames": ["www.%s", "api.%s"],+ "IdempotencyToken": "%s"+ }+ """.formatted(domain, domain, domain, token))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ org.junit.jupiter.api.Assertions.assertEquals(firstArn, secondArn);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmImportExportTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmImportExportTest.javanew file mode 100644index 0000000000..f5962dccb5--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmImportExportTest.java@@ -0,0 +1,312 @@+package io.github.hectorvent.floci.services.acm;++import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import io.restassured.config.EncoderConfig;+import io.restassured.http.ContentType;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestInstance;+import org.junit.jupiter.api.TestMethodOrder;++import java.util.Base64;+import java.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+@TestInstance(TestInstance.Lifecycle.PER_CLASS)+class AcmImportExportTest {++ private static final String ACM_CONTENT_TYPE = "application/x-amz-json-1.1";++ @Inject+ CertificateGenerator certificateGenerator;++ // Generated test certificate data+ private String validTestCertificate;+ private String validTestPrivateKey;++ private String importedCertificateArn;+ private String exportableCertificateArn;++ @BeforeAll+ void setupTestCertificates() {+ RestAssured.config = RestAssured.config().encoderConfig(+ EncoderConfig.encoderConfig()+ .encodeContentTypeAs(ACM_CONTENT_TYPE, ContentType.TEXT));++ // Generate a valid test certificate using CertificateGenerator+ CertificateGenerator.GeneratedCertificate generated = certificateGenerator.generateCertificate(+ "test-import.example.com",+ List.of("www.test-import.example.com"),+ KeyAlgorithm.RSA_2048+ );++ validTestCertificate = generated.certificatePem();+ validTestPrivateKey = generated.privateKeyPem();+ }++ // ==================== ImportCertificate Tests ====================++ @Test+ @Order(1)+ void importCertificateBasic() {+ // Escape newlines for JSON+ String certJson = validTestCertificate.replace("\n", "\\n");+ String keyJson = validTestPrivateKey.replace("\n", "\\n");++ importedCertificateArn = given()+ .header("X-Amz-Target", "CertificateManager.ImportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "Certificate": "%s",+ "PrivateKey": "%s"+ }+ """.formatted(certJson, keyJson))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"))+ .body("CertificateArn", containsString(":certificate/"))+ .extract().jsonPath().getString("CertificateArn");+ }++ @Test+ @Order(2)+ void verifyImportedCertificate() {+ given()+ .header("X-Amz-Target", "CertificateManager.DescribeCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(importedCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Certificate.CertificateArn", equalTo(importedCertificateArn))+ .body("Certificate.DomainName", equalTo("test-import.example.com"))+ .body("Certificate.Status", equalTo("ISSUED"))+ .body("Certificate.Type", equalTo("IMPORTED"))+ .body("Certificate.KeyAlgorithm", equalTo("RSA-2048"));+ }++ @Test+ @Order(3)+ void importCertificateWithTags() {+ String certJson = validTestCertificate.replace("\n", "\\n");+ String keyJson = validTestPrivateKey.replace("\n", "\\n");++ String taggedArn = given()+ .header("X-Amz-Target", "CertificateManager.ImportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "Certificate": "%s",+ "PrivateKey": "%s",+ "Tags": [+ {"Key": "Environment", "Value": "test"},+ {"Key": "ImportTest", "Value": "true"}+ ]+ }+ """.formatted(certJson, keyJson))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"))+ .extract().jsonPath().getString("CertificateArn");++ // Verify tags were applied+ given()+ .header("X-Amz-Target", "CertificateManager.ListTagsForCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(taggedArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags.size()", equalTo(2));+ }++ @Test+ @Order(4)+ void importCertificateReimport() {+ String certJson = validTestCertificate.replace("\n", "\\n");+ String keyJson = validTestPrivateKey.replace("\n", "\\n");++ // Re-import to the same ARN should succeed+ given()+ .header("X-Amz-Target", "CertificateManager.ImportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "Certificate": "%s",+ "PrivateKey": "%s",+ "CertificateArn": "%s"+ }+ """.formatted(certJson, keyJson, importedCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", equalTo(importedCertificateArn));+ }++ // ==================== ExportCertificate Tests ====================++ @Test+ @Order(10)+ void requestExportableCertificate() {+ // Create a PRIVATE type certificate that can be exported+ exportableCertificateArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "exportable.example.com",+ "CertificateAuthorityArn": "arn:aws:acm-pca:us-east-1:123456789012:certificate-authority/12345678-1234-1234-1234-123456789012"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"))+ .extract().jsonPath().getString("CertificateArn");+ }++ @Test+ @Order(11)+ void exportCertificate() {+ String passphrase = Base64.getEncoder().encodeToString("testpassphrase".getBytes());++ given()+ .header("X-Amz-Target", "CertificateManager.ExportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s",+ "Passphrase": "%s"+ }+ """.formatted(exportableCertificateArn, passphrase))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Certificate", startsWith("-----BEGIN CERTIFICATE-----"))+ .body("PrivateKey", startsWith("-----BEGIN ENCRYPTED PRIVATE KEY-----"));+ }++ @Test+ @Order(12)+ void exportCertificateShortPassphraseFails() {+ String shortPassphrase = Base64.getEncoder().encodeToString("abc".getBytes());++ given()+ .header("X-Amz-Target", "CertificateManager.ExportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s",+ "Passphrase": "%s"+ }+ """.formatted(exportableCertificateArn, shortPassphrase))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ @Test+ @Order(13)+ void exportNonExportableCertificateFails() {+ // Create a non-exportable certificate (AMAZON_ISSUED without Export option)+ String nonExportableArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "non-exportable.example.com"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ String passphrase = Base64.getEncoder().encodeToString("testpassphrase".getBytes());++ given()+ .header("X-Amz-Target", "CertificateManager.ExportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s",+ "Passphrase": "%s"+ }+ """.formatted(nonExportableArn, passphrase))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ @Test+ @Order(14)+ void exportCertificateNotFoundFails() {+ String passphrase = Base64.getEncoder().encodeToString("testpassphrase".getBytes());++ given()+ .header("X-Amz-Target", "CertificateManager.ExportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "arn:aws:acm:us-east-1:123456789012:certificate/nonexistent",+ "Passphrase": "%s"+ }+ """.formatted(passphrase))+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(15)+ void importInvalidCertificateFails() {+ given()+ .header("X-Amz-Target", "CertificateManager.ImportCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "Certificate": "not-a-valid-certificate",+ "PrivateKey": "not-a-valid-key"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmIntegrationTest.javanew file mode 100644index 0000000000..727ebe3940--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmIntegrationTest.java@@ -0,0 +1,558 @@+package io.github.hectorvent.floci.services.acm;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import io.restassured.config.EncoderConfig;+import io.restassured.http.ContentType;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestInstance;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+@TestInstance(TestInstance.Lifecycle.PER_CLASS)+class AcmIntegrationTest {++ private static final String ACM_CONTENT_TYPE = "application/x-amz-json-1.1";+ private static String createdCertificateArn;++ @BeforeAll+ static void configureRestAssured() {+ RestAssured.config = RestAssured.config().encoderConfig(+ EncoderConfig.encoderConfig()+ .encodeContentTypeAs(ACM_CONTENT_TYPE, ContentType.TEXT));+ }++ // ==================== User Story 1: RequestCertificate ====================++ @Test+ @Order(1)+ void requestCertificateBasic() {+ createdCertificateArn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "example.com"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"))+ .body("CertificateArn", containsString(":certificate/"))+ .extract().jsonPath().getString("CertificateArn");+ }++ @Test+ @Order(2)+ void requestCertificateWithSans() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "api.example.com",+ "SubjectAlternativeNames": ["www.example.com", "*.example.com"]+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ @Order(3)+ void requestCertificateWithDnsValidation() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "dns-validated.example.com",+ "ValidationMethod": "DNS"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ @Order(4)+ void requestCertificateWithEmailValidation() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "email-validated.example.com",+ "ValidationMethod": "EMAIL"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ @Order(5)+ void requestCertificateWithKeyAlgorithm() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "ec-cert.example.com",+ "KeyAlgorithm": "EC_prime256v1"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ @Order(6)+ void requestCertificateWithIdempotencyToken() {+ String token = "test-idempotency-token-123";++ // First request+ String arn1 = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "idempotent.example.com",+ "IdempotencyToken": "%s"+ }+ """.formatted(token))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // Second request with same token should return same ARN+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "idempotent.example.com",+ "IdempotencyToken": "%s"+ }+ """.formatted(token))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", equalTo(arn1));+ }++ @Test+ @Order(7)+ void requestCertificateWithTags() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "tagged.example.com",+ "Tags": [+ {"Key": "Environment", "Value": "test"},+ {"Key": "Project", "Value": "demo"}+ ]+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateArn", startsWith("arn:aws:acm:"));+ }++ @Test+ @Order(8)+ void requestCertificateEmptyDomainFails() {+ given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": ""+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ // ==================== User Story 2: DescribeCertificate ====================++ @Test+ @Order(10)+ void describeCertificate() {+ given()+ .header("X-Amz-Target", "CertificateManager.DescribeCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(createdCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Certificate.CertificateArn", equalTo(createdCertificateArn))+ .body("Certificate.DomainName", equalTo("example.com"))+ .body("Certificate.Status", equalTo("ISSUED"))+ .body("Certificate.Type", equalTo("AMAZON_ISSUED"))+ .body("Certificate.Serial", notNullValue())+ .body("Certificate.Subject", startsWith("CN="))+ .body("Certificate.Issuer", notNullValue())+ .body("Certificate.KeyAlgorithm", equalTo("RSA-2048"))+ .body("Certificate.NotBefore", notNullValue())+ .body("Certificate.NotAfter", notNullValue());+ }++ @Test+ @Order(11)+ void describeCertificateNotFound() {+ given()+ .header("X-Amz-Target", "CertificateManager.DescribeCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "arn:aws:acm:us-east-1:123456789012:certificate/nonexistent"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ // ==================== User Story 2: GetCertificate ====================++ @Test+ @Order(12)+ void getCertificate() {+ given()+ .header("X-Amz-Target", "CertificateManager.GetCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(createdCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Certificate", startsWith("-----BEGIN CERTIFICATE-----"))+ .body("CertificateChain", startsWith("-----BEGIN CERTIFICATE-----"));+ }++ // ==================== User Story 2: ListCertificates ====================++ @Test+ @Order(13)+ void listCertificates() {+ given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateSummaryList", notNullValue())+ .body("CertificateSummaryList.size()", greaterThanOrEqualTo(1));+ }++ @Test+ @Order(14)+ void listCertificatesWithStatusFilter() {+ given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateStatuses": ["ISSUED"]+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateSummaryList", notNullValue());+ }++ @Test+ @Order(15)+ void listCertificatesWithKeyTypeFilter() {+ given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "Includes": {+ "keyTypes": ["RSA_2048"]+ }+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateSummaryList", notNullValue());+ }++ // ==================== User Story 5: Tagging ====================++ @Test+ @Order(20)+ void addTagsToCertificate() {+ given()+ .header("X-Amz-Target", "CertificateManager.AddTagsToCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s",+ "Tags": [+ {"Key": "Team", "Value": "Engineering"},+ {"Key": "Cost-Center", "Value": "12345"}+ ]+ }+ """.formatted(createdCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(21)+ void listTagsForCertificate() {+ given()+ .header("X-Amz-Target", "CertificateManager.ListTagsForCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(createdCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags", notNullValue())+ .body("Tags.size()", greaterThanOrEqualTo(2));+ }++ @Test+ @Order(22)+ void removeTagsFromCertificate() {+ given()+ .header("X-Amz-Target", "CertificateManager.RemoveTagsFromCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s",+ "Tags": [+ {"Key": "Cost-Center"}+ ]+ }+ """.formatted(createdCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ // Verify tag was removed+ given()+ .header("X-Amz-Target", "CertificateManager.ListTagsForCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(createdCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags.find { it.Key == 'Cost-Center' }", nullValue());+ }++ @Test+ @Order(23)+ void addTagsInvalidKeyFails() {+ given()+ .header("X-Amz-Target", "CertificateManager.AddTagsToCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s",+ "Tags": [+ {"Key": "aws:reserved", "Value": "not-allowed"}+ ]+ }+ """.formatted(createdCertificateArn))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ // ==================== Account Configuration ====================++ @Test+ @Order(30)+ void getAccountConfiguration() {+ given()+ .header("X-Amz-Target", "CertificateManager.GetAccountConfiguration")+ .contentType(ACM_CONTENT_TYPE)+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ExpiryEvents.DaysBeforeExpiry", equalTo(45));+ }++ @Test+ @Order(31)+ void putAccountConfiguration() {+ given()+ .header("X-Amz-Target", "CertificateManager.PutAccountConfiguration")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "ExpiryEvents": {+ "DaysBeforeExpiry": 30+ },+ "IdempotencyToken": "config-token-123"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ // Verify configuration was updated+ given()+ .header("X-Amz-Target", "CertificateManager.GetAccountConfiguration")+ .contentType(ACM_CONTENT_TYPE)+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ExpiryEvents.DaysBeforeExpiry", equalTo(30));+ }++ // ==================== User Story 3: DeleteCertificate ====================++ @Test+ @Order(100)+ void deleteCertificate() {+ // Create a certificate to delete+ String arnToDelete = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "to-delete.example.com"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ // Delete it+ given()+ .header("X-Amz-Target", "CertificateManager.DeleteCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(arnToDelete))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ // Verify it's gone+ given()+ .header("X-Amz-Target", "CertificateManager.DescribeCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "%s"+ }+ """.formatted(arnToDelete))+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(101)+ void deleteCertificateNotFound() {+ given()+ .header("X-Amz-Target", "CertificateManager.DeleteCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateArn": "arn:aws:acm:us-east-1:123456789012:certificate/nonexistent"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ // ==================== Unsupported Operation ====================++ @Test+ void unsupportedOperation() {+ given()+ .header("X-Amz-Target", "CertificateManager.UnsupportedAction")+ .contentType(ACM_CONTENT_TYPE)+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("UnsupportedOperation"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmPaginationTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmPaginationTest.javanew file mode 100644index 0000000000..fc6ca9c089--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmPaginationTest.java@@ -0,0 +1,183 @@+package io.github.hectorvent.floci.services.acm;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import io.restassured.config.EncoderConfig;+import io.restassured.http.ContentType;+import io.restassured.response.Response;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestInstance;+import org.junit.jupiter.api.TestMethodOrder;++import java.util.ArrayList;+import java.util.HashSet;+import java.util.List;+import java.util.Set;++import static io.restassured.RestAssured.given;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.*;+import static org.junit.jupiter.api.Assertions.*;++/**+ * Tests for ListCertificates pagination functionality.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+@TestInstance(TestInstance.Lifecycle.PER_CLASS)+class AcmPaginationTest {++ private static final String ACM_CONTENT_TYPE = "application/x-amz-json-1.1";+ private static final int TOTAL_CERTS = 15;+ private final List<String> createdArns = new ArrayList<>();++ @BeforeAll+ static void configureRestAssured() {+ RestAssured.config = RestAssured.config().encoderConfig(+ EncoderConfig.encoderConfig()+ .encodeContentTypeAs(ACM_CONTENT_TYPE, ContentType.TEXT));+ }++ @Test+ @Order(1)+ void createMultipleCertificates() {+ // Create 15 certificates for pagination testing+ for (int i = 0; i < TOTAL_CERTS; i++) {+ String arn = given()+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "DomainName": "pagination-test-%d.example.com"+ }+ """.formatted(i))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath().getString("CertificateArn");++ createdArns.add(arn);+ }++ assertEquals(TOTAL_CERTS, createdArns.size());+ }++ @Test+ @Order(2)+ void listWithMaxItems() {+ // List with maxItems=5, expect nextToken+ Response response = given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "MaxItems": 5+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateSummaryList.size()", equalTo(5))+ .body("NextToken", notNullValue())+ .extract().response();++ String nextToken = response.jsonPath().getString("NextToken");+ assertNotNull(nextToken, "NextToken should be present when there are more pages");+ }++ @Test+ @Order(3)+ void paginateThroughAllCertificates() {+ Set<String> allArns = new HashSet<>();+ String nextToken = null;+ int pageCount = 0;+ int maxPages = 10; // Safety limit++ do {+ String body = nextToken == null+ ? "{\"MaxItems\": 5}"+ : "{\"MaxItems\": 5, \"NextToken\": \"" + nextToken + "\"}";++ Response response = given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body(body)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().response();++ List<String> pageArns = response.jsonPath().getList("CertificateSummaryList.CertificateArn");+ allArns.addAll(pageArns);+ nextToken = response.jsonPath().getString("NextToken");+ pageCount++;++ } while (nextToken != null && pageCount < maxPages);++ // Should have retrieved all created certificates (plus possibly others from other tests)+ assertTrue(allArns.containsAll(createdArns), "All created certificates should be retrievable via pagination");+ }++ @Test+ @Order(4)+ void invalidNextToken() {+ given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "NextToken": "invalid-token-not-base64"+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidNextTokenException"));+ }++ @Test+ @Order(5)+ void emptyListReturnsNoNextToken() {+ // List with a filter that matches nothing+ given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "CertificateStatuses": ["REVOKED"]+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateSummaryList", empty())+ .body("NextToken", nullValue());+ }++ @Test+ @Order(6)+ void maxItemsLimit() {+ // MaxItems should be capped at 1000+ given()+ .header("X-Amz-Target", "CertificateManager.ListCertificates")+ .contentType(ACM_CONTENT_TYPE)+ .body("""+ {+ "MaxItems": 2000+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CertificateSummaryList.size()", lessThanOrEqualTo(1000));+ }+}