Skip to content

armgit / floci

Public Imported from GitHub
0

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.md
index 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, and
policies 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 with
up to 100 distributions.
- The five AWS managed response headers policy IDs are available and can be selected with
diff --git a/docs/services/elb-classic.md b/docs/services/elb-classic.md
index 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 instances
registered and deregistered automatically, so a Terraform `min_elb_capacity` wait can be
satisfied.
+- 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.
## Configuration
diff --git a/docs/services/elb.md b/docs/services/elb.md
index 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.md
index 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 Keys
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontService.java b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontService.java
index 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;
- @Inject
public 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.java
index 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 → record
private 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);
}
- @Inject
public 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.java
index 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 {
@Inject
ElbV2DataPlane 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.java
index 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;
@Inject
public 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.java
index 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.java
new file mode 100644
index 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.java
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.java
index 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);