Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): resolve server certificate references in ELB and CloudFront (#5075)
Matheus Oliveiraa84a8a04354a
diff --git a/docs/services/cloudfront.md b/docs/services/cloudfront.mdindex beda278cf7..26947ae74f 100644--- a/docs/services/cloudfront.md+++ b/docs/services/cloudfront.md@@ -231,6 +231,9 @@ PUT, PATCH and DELETE).headers, allowed header removals, and sampled `Server-Timing` metrics. `Pragma: server-timing`forces those metrics for enabled policies. Distribution writes reject unknown policy IDs, andpolicies attached to a cache behavior cannot be deleted.+- `ViewerCertificate.IAMCertificateId` must be the `ServerCertificateId` of an uploaded IAM server+ certificate: distribution create and update reject an unknown one with `InvalidViewerCertificate`,+ and `DeleteServerCertificate` returns `DeleteConflict` while a distribution references it.- Up to 20 custom response headers policies can be created, and one policy can be associated withup to 100 distributions.- The five AWS managed response headers policy IDs are available and can be selected withdiff --git a/docs/services/elb-classic.md b/docs/services/elb-classic.mdindex 9e39e0e945..8fb8d05e6d 100644--- a/docs/services/elb-classic.md+++ b/docs/services/elb-classic.md@@ -77,6 +77,10 @@ opened and no traffic is forwarded. Only the control plane and health checking a- An Auto Scaling group that names Classic load balancers in `LoadBalancerNames` has its instancesregistered and deregistered automatically, so a Terraform `min_elb_capacity` wait can besatisfied.+- A listener's `SSLCertificateId` must name an existing certificate: an IAM server certificate ARN+ or an ACM certificate ARN. `CreateLoadBalancer` and `CreateLoadBalancerListeners` reject a+ missing one with `CertificateNotFound`. An IAM server certificate a listener references cannot+ be deleted: `DeleteServerCertificate` returns `DeleteConflict` until the listener is removed.## Configurationdiff --git a/docs/services/elb.md b/docs/services/elb.mdindex e9334660e6..b5e204a49a 100644--- a/docs/services/elb.md+++ b/docs/services/elb.md@@ -93,6 +93,7 @@ Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB)- Each `CreateListener` automatically creates an immutable default rule (`priority=default`, `isDefault=true`). This rule cannot be deleted; use `ModifyListener` to change its action.- Rule priorities are unique per listener: `CreateRule` and `SetRulePriorities` only reject a priority held by another rule on the same listener. `SetRulePriorities` is atomic: all priority assignments are validated before any change is committed.- `DeleteTargetGroup` is rejected with `ResourceInUse` while the target group is referenced by any listener or rule.+- `DeleteServerCertificate` is rejected with `DeleteConflict` while an IAM server certificate is named by a listener. Listener certificate ARNs are not validated when they are added.- `DeleteRule` is rejected with `OperationNotPermitted` for the default rule.- `DescribeSSLPolicies` returns a pre-seeded list of standard AWS SSL policies (`ELBSecurityPolicy-*`).- `DescribeAccountLimits` returns standard default limits (e.g., 50 load balancers per region, 100 target groups, etc.).diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 862ee577aa..fbca2e8780 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -572,11 +572,12 @@ certificate body, certificate chain, or private key".`ServerCertificateId` uses AWS's `ASCA` prefix for certificates. `GetAccountSummary`'s`ServerCertificates` count is backed by this store rather than reporting zero.-One modeled error is not raised: AWS returns `DeleteConflict` from `DeleteServerCertificate` when a-load balancer still references the certificate. Floci cannot determine that yet, because ELB-Classic and CloudFront store certificate identifiers without resolving them against IAM. Tracked in-[#4875](https://github.com/floci-io/floci/issues/4875), which covers both directions: rejecting a-reference to a certificate that does not exist, and refusing to delete one that is in use.+`DeleteServerCertificate` returns `DeleteConflict` while the certificate is in use, as AWS does.+Services that reference a certificate (ELB Classic listeners, ELBv2 listeners, CloudFront+distributions) report it through `ServerCertificateReferenceProvider`, which IAM consults without+depending on them. In the other direction, ELB Classic rejects a listener whose `SSLCertificateId`+names no certificate with `CertificateNotFound`, and CloudFront rejects an unknown+`ViewerCertificate.IAMCertificateId` with `InvalidViewerCertificate`.### SSH Public Keysdiff --git a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontService.java b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontService.javaindex 545d5f3bdc..55262ed638 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontService.java@@ -27,6 +27,8 @@ import io.github.hectorvent.floci.services.cloudfront.model.PublicKey;import io.github.hectorvent.floci.services.cloudfront.model.RealtimeLogConfig;import io.github.hectorvent.floci.services.cloudfront.model.ResponseHeadersPolicy;import io.github.hectorvent.floci.services.cloudfront.model.StreamingDistribution;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.ServerCertificateReferenceProvider;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -49,7 +51,7 @@ import java.util.function.Function;import java.util.regex.Pattern;@ApplicationScoped-public class CloudFrontService {+public class CloudFrontService implements ServerCertificateReferenceProvider {private static final String CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";private static final int MAX_CUSTOM_RESPONSE_HEADERS_POLICIES = 20;@@ -121,6 +123,7 @@ public class CloudFrontService {private final StorageBackend<String, MonitoringSubscription> monitoringStore;private final String accountId;private final RegionResolver regionResolver;+ private final IamService iamService;private final String domainSuffix;/*** Host suffixes under which every distribution is served as {@code <id><suffix>}, whatever@@ -133,8 +136,14 @@ public class CloudFrontService {*/private final List<String> localDeliverySuffixes;- @Injectpublic CloudFrontService(StorageFactory factory, EmulatorConfig config, RegionResolver regionResolver) {+ this(factory, config, regionResolver, null);+ }++ @Inject+ public CloudFrontService(StorageFactory factory, EmulatorConfig config, RegionResolver regionResolver,+ IamService iamService) {+ this.iamService = iamService;this.distStore = factory.create("cloudfront", "cloudfront-distributions.json",new TypeReference<Map<String, Distribution>>() {});this.invalidationStore = factory.create("cloudfront", "cloudfront-invalidations.json",@@ -182,6 +191,7 @@ public class CloudFrontService {validateOriginCustomHeaders(dist.getConfig());validateResponseHeadersPolicyReferences(dist.getConfig(), null);validateTrustedKeyGroups(dist.getConfig());+ validateViewerCertificate(dist.getConfig());String id = generateDistributionId();dist.setId(id);dist.setArn(arn("distribution/" + id));@@ -212,6 +222,7 @@ public class CloudFrontService {validateOriginCustomHeaders(updated.getConfig());validateResponseHeadersPolicyReferences(updated.getConfig(), id);validateTrustedKeyGroups(updated.getConfig());+ validateViewerCertificate(updated.getConfig());updated.setId(id);updated.setArn(existing.getArn());updated.setDomainName(existing.getDomainName());@@ -223,6 +234,36 @@ public class CloudFrontService {return updated;}+ @Override+ public List<Reference> serverCertificateReferences() {+ List<Reference> references = new ArrayList<>();+ for (Distribution distribution : distStore.scan(k -> true)) {+ String certificateId = iamCertificateId(distribution.getConfig());+ if (certificateId != null) {+ references.add(new Reference(certificateId, "distribution " + distribution.getId()));+ }+ }+ return references;+ }++ private static String iamCertificateId(DistributionConfig config) {+ if (config == null || config.getViewerCertificate() == null) {+ return null;+ }+ String certificateId = config.getViewerCertificate().get("IAMCertificateId");+ return certificateId == null || certificateId.isBlank() ? null : certificateId;+ }++ private void validateViewerCertificate(DistributionConfig config) {+ String certificateId = iamCertificateId(config);+ if (certificateId != null && iamService != null+ && iamService.findServerCertificateById(certificateId).isEmpty()) {+ throw new AwsException("InvalidViewerCertificate",+ "The specified SSL certificate doesn't exist, isn't valid, "+ + "or doesn't include a valid certificate chain.", 400);+ }+ }+private static void validateOriginCustomHeaders(DistributionConfig config) {if (config == null || config.getOrigins() == null) {return;diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicService.java b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicService.javaindex d95356eec4..241fc6e8c7 100644--- a/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicService.java+++ b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicService.java@@ -2,21 +2,27 @@ package io.github.hectorvent.floci.services.elb;import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsRegionFacts;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.dns.EmbeddedDnsServer;import io.github.hectorvent.floci.core.storage.StorageBackedMap;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.acm.AcmService;import io.github.hectorvent.floci.services.ec2.Ec2Service;import io.github.hectorvent.floci.services.ec2.model.SecurityGroup;import io.github.hectorvent.floci.services.ec2.model.Subnet;import io.github.hectorvent.floci.services.elb.model.ClassicHealthCheck;import io.github.hectorvent.floci.services.elb.model.ClassicListener;import io.github.hectorvent.floci.services.elb.model.ClassicLoadBalancer;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.ServerCertificateReferenceProvider;+import io.github.hectorvent.floci.services.iam.model.ServerCertificate;import jakarta.annotation.PostConstruct;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;+import org.jboss.logging.Logger;import java.security.SecureRandom;import java.time.Instant;@@ -26,6 +32,7 @@ import java.util.LinkedHashMap;import java.util.LinkedHashSet;import java.util.List;import java.util.Map;+import java.util.Optional;import java.util.Set;import java.util.concurrent.ConcurrentHashMap;import java.util.stream.Collectors;@@ -45,8 +52,9 @@ import java.util.stream.Collectors;* inventing a result.*/@ApplicationScoped-public class ElbClassicService {+public class ElbClassicService implements ServerCertificateReferenceProvider {+ private static final Logger LOG = Logger.getLogger(ElbClassicService.class);private static final SecureRandom RANDOM = new SecureRandom();private final Ec2Service ec2Service;@@ -54,6 +62,8 @@ public class ElbClassicService {private final StorageFactory storageFactory;private final EmulatorConfig config;private final RegionResolver regionResolver;+ private final IamService iamService;+ private final AcmService acmService;// region → load balancer name → recordprivate Map<String, Map<String, ClassicLoadBalancer>> loadBalancers = new ConcurrentHashMap<>();@@ -62,20 +72,32 @@ public class ElbClassicService {ElbClassicHealthChecker healthChecker,StorageFactory storageFactory,EmulatorConfig config) {- this(ec2Service, healthChecker, storageFactory, config, null);+ this(ec2Service, healthChecker, storageFactory, config, null, null, null);}- @Injectpublic ElbClassicService(Ec2Service ec2Service,ElbClassicHealthChecker healthChecker,StorageFactory storageFactory,EmulatorConfig config,RegionResolver regionResolver) {+ this(ec2Service, healthChecker, storageFactory, config, regionResolver, null, null);+ }++ @Inject+ public ElbClassicService(Ec2Service ec2Service,+ ElbClassicHealthChecker healthChecker,+ StorageFactory storageFactory,+ EmulatorConfig config,+ RegionResolver regionResolver,+ IamService iamService,+ AcmService acmService) {this.ec2Service = ec2Service;this.healthChecker = healthChecker;this.storageFactory = storageFactory;this.config = config;this.regionResolver = regionResolver;+ this.iamService = iamService;+ this.acmService = acmService;}@PostConstruct@@ -138,6 +160,7 @@ public class ElbClassicService {for (ClassicListener listener : listeners) {validateListener(listener);}+ requireCertificates(region, listeners);Map<String, ClassicLoadBalancer> regionLbs =loadBalancers.computeIfAbsent(region, k -> new ConcurrentHashMap<>());@@ -258,6 +281,7 @@ public class ElbClassicService {for (ClassicListener listener : listeners) {validateListener(listener);}+ requireCertificates(region, listeners);for (ClassicListener listener : listeners) {ClassicListener existing = lb.getListeners().stream().filter(l -> l.getLoadBalancerPort().equals(listener.getLoadBalancerPort()))@@ -534,6 +558,63 @@ public class ElbClassicService {}}+ @Override+ public List<Reference> serverCertificateReferences() {+ List<Reference> references = new ArrayList<>();+ for (Map<String, ClassicLoadBalancer> regionLbs : loadBalancers.values()) {+ for (ClassicLoadBalancer lb : regionLbs.values()) {+ for (ClassicListener listener : lb.getListeners()) {+ String certificate = listener.getSslCertificateId();+ if (certificate != null && !certificate.isBlank()) {+ references.add(new Reference(certificate,+ "load balancer " + lb.getLoadBalancerName()));+ }+ }+ }+ }+ return references;+ }++ private void requireCertificates(String region, List<ClassicListener> listeners) {+ for (ClassicListener listener : listeners) {+ String certificateId = listener.getSslCertificateId();+ if (certificateId != null && !certificateId.isBlank() && !certificateExists(region, certificateId)) {+ throw new AwsException("CertificateNotFound",+ "Server Certificate not found for the key: " + certificateId, 400);+ }+ }+ }++ private boolean certificateExists(String region, String certificateArn) {+ if (!AwsArnUtils.isArn(certificateArn)) {+ return false;+ }+ AwsArnUtils.Arn arn = AwsArnUtils.parse(certificateArn);+ return switch (arn.service()) {+ case "iam" -> iamService == null || iamServerCertificate(arn, certificateArn).isPresent();+ case "acm" -> acmService == null || acmCertificateExists(region, certificateArn);+ default -> false;+ };+ }++ private Optional<ServerCertificate> iamServerCertificate(AwsArnUtils.Arn arn, String certificateArn) {+ if (!arn.resource().startsWith("server-certificate/")) {+ return Optional.empty();+ }+ String name = arn.resource().substring(arn.resource().lastIndexOf('/') + 1);+ return iamService.findServerCertificate(name)+ .filter(certificate -> certificateArn.equals(certificate.getArn()));+ }++ private boolean acmCertificateExists(String region, String certificateArn) {+ try {+ return certificateArn.equals(acmService.describeCertificate(certificateArn, region).getArn());+ } catch (AwsException e) {+ LOG.debugv("ACM certificate {0} not usable in {1}: {2}", certificateArn, region, e.getMessage());+ return false;+ }+ }+private static void validateListener(ClassicListener listener) {if (listener.getProtocol() == null || listener.getLoadBalancerPort() == null|| listener.getInstancePort() == null) {diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.javaindex 41c28906de..7c5ab43243 100644--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java@@ -13,6 +13,7 @@ import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.ec2.Ec2Service;import io.github.hectorvent.floci.services.ec2.model.Subnet;import io.github.hectorvent.floci.services.elbv2.model.*;+import io.github.hectorvent.floci.services.iam.ServerCertificateReferenceProvider;import jakarta.annotation.PostConstruct;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -32,7 +33,7 @@ import java.util.Map;import java.util.Set;@ApplicationScoped-public class ElbV2Service implements ResourceProvider {+public class ElbV2Service implements ResourceProvider, ServerCertificateReferenceProvider {@InjectElbV2DataPlane dataPlane;@@ -893,6 +894,19 @@ public class ElbV2Service implements ResourceProvider {// ── Listener Certificates ─────────────────────────────────────────────────+ @Override+ public List<Reference> serverCertificateReferences() {+ List<Reference> references = new ArrayList<>();+ for (Map<String, Listener> regionListeners : listeners.values()) {+ for (Listener listener : regionListeners.values()) {+ for (String certificate : listener.getCertificates()) {+ references.add(new Reference(certificate, "listener " + listener.getListenerArn()));+ }+ }+ }+ return references;+ }+public void addListenerCertificates(String region, String listenerArn, List<String> certArns) {Listener listener = requireListener(region, listenerArn);for (String certArn : certArns) {diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.javaindex 8565b718c0..9f4b3a8a03 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java@@ -21,6 +21,7 @@ import io.github.hectorvent.floci.services.iam.model.SigningCertificate;import io.github.hectorvent.floci.services.iam.model.SshPublicKey;import io.github.hectorvent.floci.services.iam.model.VirtualMfaDevice;import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.inject.Instance;import jakarta.inject.Inject;import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;@@ -68,18 +69,21 @@ public class IamQueryHandler {private final SAMLProviderService samlProviderService;private final ServiceLastAccessedService serviceLastAccessedService;private final RegionResolver regionResolver;+ private final Instance<ServerCertificateReferenceProvider> serverCertificateReferenceProviders;@Injectpublic IamQueryHandler(IamService iamService, IamPolicyEvaluator policyEvaluator,AccountResolver accountResolver, SAMLProviderService samlProviderService,ServiceLastAccessedService serviceLastAccessedService,- RegionResolver regionResolver) {+ RegionResolver regionResolver,+ Instance<ServerCertificateReferenceProvider> serverCertificateReferenceProviders) {this.iamService = iamService;this.policyEvaluator = policyEvaluator;this.accountResolver = accountResolver;this.samlProviderService = samlProviderService;this.serviceLastAccessedService = serviceLastAccessedService;this.regionResolver = regionResolver;+ this.serverCertificateReferenceProviders = serverCertificateReferenceProviders;}public Response handle(String action, MultivaluedMap<String, String> params, String authorization) {@@ -740,7 +744,8 @@ public class IamQueryHandler {}private Response handleDeleteServerCertificate(MultivaluedMap<String, String> params) {- iamService.deleteServerCertificate(getParam(params, "ServerCertificateName"));+ iamService.deleteServerCertificate(getParam(params, "ServerCertificateName"),+ serverCertificateReferenceProviders.stream().toList());return Response.ok(AwsQueryResponse.envelopeNoResult("DeleteServerCertificate", AwsNamespaces.IAM)).build();}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.javaindex 5cc89e4532..34367cf258 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java@@ -56,7 +56,9 @@ import java.time.Instant;import java.time.format.DateTimeFormatter;import java.util.Arrays;import java.util.Base64;+import java.util.Collection;import java.util.Comparator;+import java.util.HashSet;import java.util.Optional;import java.util.Set;import java.util.concurrent.ConcurrentHashMap;@@ -2316,8 +2318,12 @@ public class IamService implements SessionAccountLookup, ResourceProvider {existing.setPath(normalizePath(newPath));}existing.setServerCertificateName(targetName);- existing.setArn(iamArnBeside(existing.getArn(), "server-certificate",+ String previousArn = existing.getArn();+ existing.setArn(iamArnBeside(previousArn, "server-certificate",existing.getPath(), targetName));+ if (!previousArn.equals(existing.getArn()) && !existing.getFormerArns().contains(previousArn)) {+ existing.getFormerArns().add(previousArn);+ }if (!targetName.equals(name)) {serverCertificates.delete(name);}@@ -2326,10 +2332,47 @@ public class IamService implements SessionAccountLookup, ResourceProvider {}}+ /** The certificate carrying that ServerCertificateId, for callers that reference it by id. */+ public Optional<ServerCertificate> findServerCertificateById(String serverCertificateId) {+ if (serverCertificateId == null) {+ return Optional.empty();+ }+ return serverCertificates.scan(k -> true).stream()+ .filter(c -> serverCertificateId.equals(c.getServerCertificateId()))+ .findFirst();+ }+public void deleteServerCertificate(String name) {+ deleteServerCertificate(name, List.of());+ }++ /**+ * Deletes a server certificate unless one of the providers reports it in use, in which case+ * AWS answers {@code DeleteConflict} and the certificate stays.+ */+ public void deleteServerCertificate(String name, Collection<ServerCertificateReferenceProvider> providers) {validateIamResourceName(name, "ServerCertificateName");synchronized (serverCertificateLock) {- getServerCertificate(name);+ ServerCertificate certificate = getServerCertificate(name);+ Set<String> arnsCarriedByOthers = new HashSet<>();+ for (ServerCertificate other : serverCertificates.scan(k -> true)) {+ if (!other.getServerCertificateId().equals(certificate.getServerCertificateId())) {+ arnsCarriedByOthers.add(other.getArn());+ }+ }+ for (ServerCertificateReferenceProvider provider : providers) {+ for (ServerCertificateReferenceProvider.Reference reference : provider.serverCertificateReferences()) {+ String referenced = reference.certificate();+ if (certificate.getArn().equals(referenced)+ || certificate.getServerCertificateId().equals(referenced)+ || (certificate.getFormerArns().contains(referenced)+ && !arnsCarriedByOthers.contains(referenced))) {+ throw new AwsException("DeleteConflict",+ "Cannot delete entity, must remove referencing " + reference.referrer()+ + " first.", 409);+ }+ }+ }serverCertificates.delete(name);}LOG.infov("Deleted IAM server certificate: {0}", name);diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ServerCertificateReferenceProvider.java b/src/main/java/io/github/hectorvent/floci/services/iam/ServerCertificateReferenceProvider.javanew file mode 100644index 0000000000..5e18af0f87--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iam/ServerCertificateReferenceProvider.java@@ -0,0 +1,27 @@+package io.github.hectorvent.floci.services.iam;++import java.util.List;++/**+ * Reports which IAM server certificates a service currently references.+ *+ * <p>Implemented by services that accept a server certificate on a resource (ELB listeners,+ * CloudFront distributions); consumed by {@code IamQueryHandler} via+ * {@code Instance<ServerCertificateReferenceProvider>} so {@code DeleteServerCertificate} can+ * refuse a certificate that is in use without IAM depending on those services.</p>+ */+public interface ServerCertificateReferenceProvider {++ /**+ * One use of a server certificate.+ *+ * @param certificate the certificate as the referrer stores it: its ARN or its ServerCertificateId+ * @param referrer a description of what holds the reference, for the DeleteConflict message+ */+ record Reference(String certificate, String referrer) {}++ /**+ * @return every server certificate reference this service currently holds, or an empty list+ */+ List<Reference> serverCertificateReferences();+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/model/ServerCertificate.java b/src/main/java/io/github/hectorvent/floci/services/iam/model/ServerCertificate.javaindex 4770d847de..b72153c210 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/model/ServerCertificate.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/model/ServerCertificate.java@@ -4,6 +4,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import io.quarkus.runtime.annotations.RegisterForReflection;import java.time.Instant;+import java.util.ArrayList;+import java.util.List;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;@@ -21,6 +23,8 @@ public class ServerCertificate {private String serverCertificateId;private String path = "/";private String arn;+ /** ARNs the certificate carried before a rename or move, which a referrer may still hold. */+ private List<String> formerArns = new ArrayList<>();private String certificateBody;/** PEM private key. Never echoed back: no AWS reader returns it once uploaded. */private String privateKey;@@ -45,6 +49,10 @@ public class ServerCertificate {public void setPath(String path) { this.path = path; }public String getArn() { return arn; }public void setArn(String arn) { this.arn = arn; }+ public List<String> getFormerArns() { return formerArns; }+ public void setFormerArns(List<String> formerArns) {+ this.formerArns = formerArns == null ? new ArrayList<>() : new ArrayList<>(formerArns);+ }public String getCertificateBody() { return certificateBody; }public void setCertificateBody(String certificateBody) { this.certificateBody = certificateBody; }public String getPrivateKey() { return privateKey; }diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontViewerCertificateTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontViewerCertificateTest.javanew file mode 100644index 0000000000..0f6c5eb978--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontViewerCertificateTest.java@@ -0,0 +1,119 @@+package io.github.hectorvent.floci.services.cloudfront;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.acm.CertificateGenerator;+import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import io.github.hectorvent.floci.services.cloudfront.model.DefaultCacheBehavior;+import io.github.hectorvent.floci.services.cloudfront.model.Distribution;+import io.github.hectorvent.floci.services.cloudfront.model.DistributionConfig;+import io.github.hectorvent.floci.services.cloudfront.model.Origin;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.model.ServerCertificate;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.http.ContentType;+import org.junit.jupiter.api.Test;++import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;++/**+ * A distribution's {@code ViewerCertificate.IAMCertificateId} is resolved against IAM, and the+ * certificate it names cannot be deleted while a distribution still holds it.+ */+@QuarkusTest+class CloudFrontViewerCertificateTest {++ private static final String IAM_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260227/us-east-1/iam/aws4_request";+ private static final CertificateGenerator GENERATOR = new CertificateGenerator();++ private final CloudFrontService cloudFrontService;+ private final IamService iamService;++ CloudFrontViewerCertificateTest(CloudFrontService cloudFrontService, IamService iamService) {+ this.cloudFrontService = cloudFrontService;+ this.iamService = iamService;+ }++ private static String suffix() {+ return Long.toString(System.nanoTime(), 36);+ }++ private ServerCertificate uploadCertificate(String name) {+ CertificateGenerator.GeneratedCertificate pair = GENERATOR.generateSelfSignedCertificate(+ "cf.certs.test.local", List.of(), KeyAlgorithm.EC_prime256v1);+ return iamService.uploadServerCertificate(name, "/cloudfront/", pair.certificatePem(),+ pair.privateKeyPem(), null, Map.of());+ }++ private Distribution distributionWithCertificate(String certificateId) {+ Origin origin = new Origin();+ origin.setId("cert-origin");+ origin.setDomainName("example.com");+ Map<String, Object> customOriginConfig = new LinkedHashMap<>();+ customOriginConfig.put("HTTPPort", "80");+ customOriginConfig.put("HTTPSPort", "443");+ customOriginConfig.put("OriginProtocolPolicy", "http-only");+ origin.setCustomOriginConfig(customOriginConfig);++ DefaultCacheBehavior behavior = new DefaultCacheBehavior();+ behavior.setTargetOriginId("cert-origin");+ behavior.setViewerProtocolPolicy("allow-all");++ DistributionConfig config = new DistributionConfig();+ config.setEnabled(false);+ config.setComment("viewer-certificate-test");+ config.setOrigins(List.of(origin));+ config.setDefaultCacheBehavior(behavior);+ Map<String, String> viewerCertificate = new LinkedHashMap<>();+ viewerCertificate.put("IAMCertificateId", certificateId);+ viewerCertificate.put("SSLSupportMethod", "sni-only");+ config.setViewerCertificate(viewerCertificate);++ Distribution distribution = new Distribution();+ distribution.setConfig(config);+ return distribution;+ }++ @Test+ void createDistributionRejectsAnIamCertificateIdThatDoesNotExist() {+ AwsException rejected = assertThrows(AwsException.class,+ () -> cloudFrontService.createDistribution(distributionWithCertificate("ASCAMISSING"), Map.of()));++ assertEquals("InvalidViewerCertificate", rejected.getErrorCode());+ assertEquals(400, rejected.getHttpStatus());+ }++ @Test+ void createDistributionAcceptsAnUploadedCertificateAndHoldsItUntilTheDistributionIsGone() {+ String name = "cf-cert-" + suffix();+ ServerCertificate certificate = uploadCertificate(name);++ Distribution created = cloudFrontService.createDistribution(+ distributionWithCertificate(certificate.getServerCertificateId()), Map.of());++ given().header("Authorization", IAM_AUTH)+ .contentType(ContentType.URLENC)+ .formParam("Action", "DeleteServerCertificate")+ .formParam("ServerCertificateName", name)+ .when().post("/").then()+ .statusCode(409)+ .body("ErrorResponse.Error.Code", equalTo("DeleteConflict"))+ .body("ErrorResponse.Error.Message", containsString(created.getId()));++ cloudFrontService.removeDistribution(created.getId());++ given().header("Authorization", IAM_AUTH)+ .contentType(ContentType.URLENC)+ .formParam("Action", "DeleteServerCertificate")+ .formParam("ServerCertificateName", name)+ .when().post("/").then().statusCode(200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicServerCertificateIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicServerCertificateIntegrationTest.javanew file mode 100644index 0000000000..cf7a07ef85--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicServerCertificateIntegrationTest.java@@ -0,0 +1,190 @@+package io.github.hectorvent.floci.services.elb;++import io.github.hectorvent.floci.services.acm.CertificateGenerator;+import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import io.restassured.config.EncoderConfig;+import io.restassured.http.ContentType;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;++/**+ * A Classic listener's {@code SSLCertificateId} is resolved against IAM on the way in, and the+ * certificate it names cannot be deleted while a listener still holds it.+ */+@QuarkusTest+class ElbClassicServerCertificateIntegrationTest {++ private static final String ELB_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260427/us-east-1/elasticloadbalancing/aws4_request";+ private static final String IAM_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260227/us-east-1/iam/aws4_request";+ private static final String ACM_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260227/us-east-1/acm/aws4_request";+ private static final String CLASSIC_VERSION = "2012-06-01";+ private static final CertificateGenerator GENERATOR = new CertificateGenerator();++ private static String suffix() {+ return Long.toString(System.nanoTime(), 36);+ }++ private static String uploadCertificate(String name) {+ CertificateGenerator.GeneratedCertificate pair = GENERATOR.generateSelfSignedCertificate(+ "elb.certs.test.local", List.of(), KeyAlgorithm.EC_prime256v1);+ return given().header("Authorization", IAM_AUTH)+ .formParam("Action", "UploadServerCertificate")+ .formParam("ServerCertificateName", name)+ .formParam("CertificateBody", pair.certificatePem())+ .formParam("PrivateKey", pair.privateKeyPem())+ .when().post("/").then().statusCode(200)+ .extract().path("UploadServerCertificateResponse.UploadServerCertificateResult"+ + ".ServerCertificateMetadata.Arn");+ }++ private static String requestAcmCertificate() {+ return given().header("Authorization", ACM_AUTH)+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")+ .contentType("application/x-amz-json-1.1").config(RestAssured.config().encoderConfig(EncoderConfig.encoderConfig().encodeContentTypeAs("application/x-amz-json-1.1", ContentType.TEXT)))+ .body("{\"DomainName\": \"elb-" + suffix() + ".example.com\", \"ValidationMethod\": \"DNS\"}")+ .when().post("/").then().statusCode(200)+ .extract().path("CertificateArn");+ }++ private static ValidatableResponse deleteCertificate(String name) {+ return given().header("Authorization", IAM_AUTH)+ .formParam("Action", "DeleteServerCertificate")+ .formParam("ServerCertificateName", name)+ .when().post("/").then();+ }++ private static ValidatableResponse createLoadBalancer(String lbName, String certificateId) {+ return given().header("Authorization", ELB_AUTH)+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Version", CLASSIC_VERSION)+ .formParam("LoadBalancerName", lbName)+ .formParam("Subnets.member.1", Ec2Service.defaultSubnetId("us-east-1", "a"))+ .formParam("Listeners.member.1.Protocol", "HTTPS")+ .formParam("Listeners.member.1.LoadBalancerPort", "443")+ .formParam("Listeners.member.1.InstanceProtocol", "HTTP")+ .formParam("Listeners.member.1.InstancePort", "8080")+ .formParam("Listeners.member.1.SSLCertificateId", certificateId)+ .when().post("/").then();+ }++ @Test+ void createLoadBalancerRejectsAnIamCertificateThatDoesNotExist() {+ createLoadBalancer("elb-cert-missing-" + suffix(),+ "arn:aws:iam::000000000000:server-certificate/never-uploaded")+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("CertificateNotFound"));+ }++ @Test+ void createLoadBalancerRejectsAnAcmCertificateThatDoesNotExist() {+ createLoadBalancer("elb-acm-missing-" + suffix(),+ "arn:aws:acm:us-east-1:000000000000:certificate/00000000-0000-0000-0000-000000000000")+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("CertificateNotFound"));+ }++ @Test+ void createLoadBalancerListenersRejectsAMissingCertificate() {+ String lb = "elb-cert-listeners-" + suffix();+ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Version", CLASSIC_VERSION)+ .formParam("LoadBalancerName", lb)+ .formParam("Subnets.member.1", Ec2Service.defaultSubnetId("us-east-1", "a"))+ .formParam("Listeners.member.1.Protocol", "HTTP")+ .formParam("Listeners.member.1.LoadBalancerPort", "80")+ .formParam("Listeners.member.1.InstancePort", "8080")+ .when().post("/").then().statusCode(200);++ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "CreateLoadBalancerListeners")+ .formParam("Version", CLASSIC_VERSION)+ .formParam("LoadBalancerName", lb)+ .formParam("Listeners.member.1.Protocol", "HTTPS")+ .formParam("Listeners.member.1.LoadBalancerPort", "443")+ .formParam("Listeners.member.1.InstancePort", "8080")+ .formParam("Listeners.member.1.SSLCertificateId",+ "arn:aws:iam::000000000000:server-certificate/never-uploaded")+ .when().post("/").then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("CertificateNotFound"));+ }++ @Test+ void certificateInUseCannotBeDeletedUntilTheListenerIsGone() {+ String certName = "elb-cert-" + suffix();+ String lb = "elb-cert-in-use-" + suffix();+ String arn = uploadCertificate(certName);++ createLoadBalancer(lb, arn).statusCode(200);++ deleteCertificate(certName)+ .statusCode(409)+ .body("ErrorResponse.Error.Code", equalTo("DeleteConflict"))+ .body("ErrorResponse.Error.Message", containsString(lb));++ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "DeleteLoadBalancerListeners")+ .formParam("Version", CLASSIC_VERSION)+ .formParam("LoadBalancerName", lb)+ .formParam("LoadBalancerPorts.member.1", "443")+ .when().post("/").then().statusCode(200);++ deleteCertificate(certName).statusCode(200);+ }++ @Test+ void createLoadBalancerAcceptsAnAcmCertificateOfItsOwnRegionAndAccount() {+ createLoadBalancer("elb-acm-ok-" + suffix(), requestAcmCertificate()).statusCode(200);+ }++ @Test+ void createLoadBalancerRejectsAnAcmCertificateFromAnotherRegion() {+ String otherRegion = requestAcmCertificate().replace(":us-east-1:", ":eu-west-1:");+ createLoadBalancer("elb-acm-region-" + suffix(), otherRegion)+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("CertificateNotFound"));+ }++ @Test+ void createLoadBalancerRejectsAnAcmCertificateArnOfAnotherAccountOrPartition() {+ String arn = requestAcmCertificate();+ createLoadBalancer("elb-acm-acct-" + suffix(), arn.replace(":000000000000:", ":111111111111:"))+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("CertificateNotFound"));+ createLoadBalancer("elb-acm-part-" + suffix(), arn.replace("arn:aws:", "arn:aws-cn:"))+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("CertificateNotFound"));+ }++ @Test+ void renamedCertificateStillBlocksDeleteWhileAListenerHoldsItsFormerArn() {+ String certName = "elb-cert-old-" + suffix();+ String renamed = certName + "-new";+ String lb = "elb-cert-renamed-" + suffix();+ createLoadBalancer(lb, uploadCertificate(certName)).statusCode(200);++ given().header("Authorization", IAM_AUTH)+ .formParam("Action", "UpdateServerCertificate")+ .formParam("ServerCertificateName", certName)+ .formParam("NewServerCertificateName", renamed)+ .when().post("/").then().statusCode(200);++ deleteCertificate(renamed)+ .statusCode(409)+ .body("ErrorResponse.Error.Code", equalTo("DeleteConflict"))+ .body("ErrorResponse.Error.Message", containsString(lb));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.javaindex e9207fa03d..b051685e16 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.java@@ -28,6 +28,7 @@ import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicReference;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.Mockito.mock;@@ -144,6 +145,80 @@ class ServerCertificateStateTest {"account A's key was replaced by account B's upload");}+ @Test+ void deleteIsRefusedWhileAProviderReferencesTheCertificateByArnOrById() {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ CertificateGenerator.GeneratedCertificate pair = cheapMaterial();+ ServerCertificate created = service.uploadServerCertificate("in-use", "/", pair.certificatePem(),+ pair.privateKeyPem(), null, Map.of());++ for (String reference : List.of(created.getArn(), created.getServerCertificateId())) {+ ServerCertificateReferenceProvider provider = () -> List.of(+ new ServerCertificateReferenceProvider.Reference(reference, "load balancer web"));+ AwsException conflict = assertThrows(AwsException.class,+ () -> service.deleteServerCertificate("in-use", List.of(provider)));+ assertEquals("DeleteConflict", conflict.getErrorCode());+ assertEquals(409, conflict.getHttpStatus());+ assertTrue(conflict.getMessage().contains("load balancer web"));+ assertTrue(service.findServerCertificate("in-use").isPresent());+ }+ }++ @Test+ void deleteIsRefusedWhenAProviderStillHoldsTheArnFromBeforeARename() {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ CertificateGenerator.GeneratedCertificate pair = cheapMaterial();+ ServerCertificate created = service.uploadServerCertificate("before", "/", pair.certificatePem(),+ pair.privateKeyPem(), null, Map.of());+ String formerArn = created.getArn();+ ServerCertificate renamed = service.updateServerCertificate("before", "after", null);+ assertNotEquals(formerArn, renamed.getArn());+ ServerCertificateReferenceProvider provider = () -> List.of(+ new ServerCertificateReferenceProvider.Reference(formerArn, "load balancer web"));++ AwsException conflict = assertThrows(AwsException.class,+ () -> service.deleteServerCertificate("after", List.of(provider)));++ assertEquals("DeleteConflict", conflict.getErrorCode());+ assertTrue(service.findServerCertificate("after").isPresent());+ }++ @Test+ void aFormerArnReusedByANewCertificateNoLongerBlocksTheRenamedOne() {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ CertificateGenerator.GeneratedCertificate pair = cheapMaterial();+ String formerArn = service.uploadServerCertificate("shared", "/", pair.certificatePem(),+ pair.privateKeyPem(), null, Map.of()).getArn();+ service.updateServerCertificate("shared", "moved", null);+ ServerCertificate reused = service.uploadServerCertificate("shared", "/", pair.certificatePem(),+ pair.privateKeyPem(), null, Map.of());+ assertEquals(formerArn, reused.getArn());+ ServerCertificateReferenceProvider provider = () -> List.of(+ new ServerCertificateReferenceProvider.Reference(formerArn, "load balancer web"));++ service.deleteServerCertificate("moved", List.of(provider));++ assertTrue(service.findServerCertificate("moved").isEmpty());+ AwsException conflict = assertThrows(AwsException.class,+ () -> service.deleteServerCertificate("shared", List.of(provider)));+ assertEquals("DeleteConflict", conflict.getErrorCode());+ }++ @Test+ void deleteSucceedsWhenProvidersReferenceOnlyOtherCertificates() {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ CertificateGenerator.GeneratedCertificate pair = cheapMaterial();+ service.uploadServerCertificate("free", "/", pair.certificatePem(), pair.privateKeyPem(),+ null, Map.of());+ ServerCertificateReferenceProvider provider = () -> List.of(+ new ServerCertificateReferenceProvider.Reference(+ "arn:aws:iam::000000000000:server-certificate/other", "load balancer web"));++ service.deleteServerCertificate("free", List.of(provider));++ assertTrue(service.findServerCertificate("free").isEmpty());+ }+private static int raceTogether(Runnable... actions) throws InterruptedException {AtomicInteger succeeded = new AtomicInteger();CountDownLatch start = new CountDownLatch(1);