Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(elbv2): preserve default listener certificates (#5692)

David Phillipsa55352bf9d61
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2DefaultCertificateTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2DefaultCertificateTest.java
new file mode 100644
index 0000000000..f8126eb60a
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2DefaultCertificateTest.java
@@ -0,0 +1,93 @@
+package com.floci.test;
+
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.acm.AcmClient;
+import software.amazon.awssdk.services.elasticloadbalancingv2.ElasticLoadBalancingV2Client;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.Certificate;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.OperationNotPermittedException;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("ELBv2 default listener certificates")
+class ElbV2DefaultCertificateTest {
+
+ @Test
+ @DisplayName("default removal is refused and ModifyListener can replace it")
+ void defaultRemovalIsRefusedAndModifyCanReplaceIt() {
+ Assumptions.assumeFalse(TestFixtures.isRealAws(), "Floci-only: requested ACM certificates are issued immediately");
+ try (AcmClient acm = TestFixtures.acmClient();
+ ElasticLoadBalancingV2Client elb = TestFixtures.elbV2Client()) {
+ String first = null;
+ String additional = null;
+ String loadBalancer = null;
+ try {
+ first = acm.requestCertificate(b -> b.domainName("default.example.test").validationMethod("DNS"))
+ .certificateArn();
+ additional = acm.requestCertificate(b -> b.domainName("additional.example.test").validationMethod("DNS"))
+ .certificateArn();
+ String firstArn = first;
+ String additionalArn = additional;
+ loadBalancer = elb.createLoadBalancer(b -> b.name(TestFixtures.uniqueName("sdk-default-cert"))
+ .type("application")).loadBalancers().get(0).loadBalancerArn();
+ String lbArn = loadBalancer;
+ String listener = elb.createListener(b -> b.loadBalancerArn(lbArn).port(443).protocol("HTTPS")
+ .certificates(Certificate.builder().certificateArn(firstArn).build())
+ .defaultActions(a -> a.type("fixed-response").fixedResponseConfig(f ->
+ f.statusCode("200").contentType("text/plain").messageBody("ok"))))
+ .listeners().get(0).listenerArn();
+ assertThat(certificates(elb, listener)).containsExactly(firstArn);
+ assertThatThrownBy(() -> elb.removeListenerCertificates(b -> b.listenerArn(listener)
+ .certificates(Certificate.builder().certificateArn(firstArn).build())))
+ .isInstanceOfSatisfying(OperationNotPermittedException.class,
+ error -> assertThat(error.statusCode()).isEqualTo(400));
+ assertThat(certificates(elb, listener)).containsExactly(firstArn);
+ elb.addListenerCertificates(b -> b.listenerArn(listener)
+ .certificates(Certificate.builder().certificateArn(additionalArn).build()));
+ assertThat(certificates(elb, listener)).containsExactly(firstArn, additionalArn);
+ assertThatThrownBy(() -> elb.removeListenerCertificates(b -> b.listenerArn(listener)
+ .certificates(Certificate.builder().certificateArn(firstArn).build())))
+ .isInstanceOf(OperationNotPermittedException.class);
+ assertThat(certificates(elb, listener)).containsExactly(firstArn, additionalArn);
+ elb.removeListenerCertificates(b -> b.listenerArn(listener)
+ .certificates(Certificate.builder().certificateArn(additionalArn).build()));
+ assertThat(certificates(elb, listener)).containsExactly(firstArn);
+ elb.modifyListener(b -> b.listenerArn(listener)
+ .certificates(Certificate.builder().certificateArn(additionalArn).build()));
+ assertThat(certificates(elb, listener)).containsExactly(additionalArn);
+ assertThatThrownBy(() -> elb.removeListenerCertificates(b -> b.listenerArn(listener)
+ .certificates(Certificate.builder().certificateArn(additionalArn).build())))
+ .isInstanceOf(OperationNotPermittedException.class);
+ assertThat(certificates(elb, listener)).containsExactly(additionalArn);
+ } finally {
+ try {
+ if (loadBalancer != null) {
+ String lbArn = loadBalancer;
+ elb.deleteLoadBalancer(b -> b.loadBalancerArn(lbArn));
+ }
+ } finally {
+ try {
+ if (first != null) {
+ String arn = first;
+ acm.deleteCertificate(b -> b.certificateArn(arn));
+ }
+ } finally {
+ if (additional != null) {
+ String arn = additional;
+ acm.deleteCertificate(b -> b.certificateArn(arn));
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private static List<String> certificates(ElasticLoadBalancingV2Client client, String listener) {
+ return client.describeListenerCertificates(b -> b.listenerArn(listener)).certificates().stream()
+ .map(Certificate::certificateArn).toList();
+ }
+}
diff --git a/docs/services/elb.md b/docs/services/elb.md
index 194c974204..e629d31e8d 100644
--- a/docs/services/elb.md
+++ b/docs/services/elb.md
@@ -94,6 +94,7 @@ Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB)
- 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.
- An HTTPS or TLS listener's certificates must name existing certificates: an IAM server certificate ARN or an ACM certificate ARN. `CreateListener`, `ModifyListener` and `AddListenerCertificates` reject a missing or empty one with `CertificateNotFound`, the three operations the API reference models it on, and a `ModifyListener` that turns a listener into an HTTPS or TLS one is held to the same check over the certificates it already carried. An IAM server certificate a listener references cannot be deleted: `DeleteServerCertificate` returns `DeleteConflict` until the certificate is removed from the listener. A write that records one runs while IAM holds its certificate lock, so a certificate cannot be deleted between the check and the write, and a `ModifyListener` refused by that check leaves the listener on the port, protocol, policy and certificates it already had.
+- `RemoveListenerCertificates` refuses removal of an HTTPS or TLS listener's default certificate with `OperationNotPermitted` (400) and preserves the certificate list. Use `ModifyListener` to replace the default certificate. Additional certificates can still be removed.
- `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/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java
index a2d8d2d270..72f25e7c96 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
@@ -978,7 +978,13 @@ public class ElbV2Service implements ResourceProvider, ServerCertificateReferenc
public void removeListenerCertificates(String region, String listenerArn, List<String> certArns) {
Listener listener = requireListener(region, listenerArn);
- listener.getCertificates().removeAll(certArns);
+ List<String> certificates = listener.getCertificates();
+ if (servesCertificates(listener.getProtocol()) && !certificates.isEmpty()
+ && certArns.contains(certificates.getFirst())) {
+ throw new AwsException("OperationNotPermitted",
+ "The default listener certificate cannot be removed.", 400);
+ }
+ certificates.removeAll(certArns);
persistRegion(listeners, region);
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.java
index 5894b74ac7..795e379fe9 100644
--- a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.java
@@ -345,4 +345,51 @@ class ElbV2ListenerCertificateIntegrationTest {
assertTrue(listenerCertificates(listenerArn).containsAll(List.of(first, second)),
"both certificates should be on the listener");
}
+ @Test
+ void removingTheOnlyDefaultCertificateReturnsOperationNotPermitted() {
+ String certificate = uploadCertificate();
+ String listener = listenerServing(certificate);
+ assertEquals(List.of(certificate), listenerCertificates(listener));
+ given().header("Authorization", ELB_AUTH)
+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)
+ .formParam("Certificates.member.1.CertificateArn", certificate)
+ .when().post("/").then().statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("OperationNotPermitted"));
+ assertEquals(List.of(certificate), listenerCertificates(listener));
+ }
+
+ @Test
+ void defaultRemovalKeepsAdditionalCertificatesAndModifyCanReplaceTheDefault() {
+ String first = uploadCertificate();
+ String additional = uploadCertificate();
+ String listener = listenerServing(first);
+ given().header("Authorization", ELB_AUTH)
+ .formParam("Action", "AddListenerCertificates").formParam("ListenerArn", listener)
+ .formParam("Certificates.member.1.CertificateArn", additional)
+ .when().post("/").then().statusCode(200);
+ assertEquals(List.of(first, additional), listenerCertificates(listener));
+ given().header("Authorization", ELB_AUTH)
+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)
+ .formParam("Certificates.member.1.CertificateArn", first)
+ .when().post("/").then().statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("OperationNotPermitted"));
+ assertEquals(List.of(first, additional), listenerCertificates(listener));
+ given().header("Authorization", ELB_AUTH)
+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)
+ .formParam("Certificates.member.1.CertificateArn", additional)
+ .when().post("/").then().statusCode(200);
+ assertEquals(List.of(first), listenerCertificates(listener));
+ given().header("Authorization", ELB_AUTH)
+ .formParam("Action", "ModifyListener").formParam("ListenerArn", listener)
+ .formParam("Certificates.member.1.CertificateArn", additional)
+ .when().post("/").then().statusCode(200);
+ assertEquals(List.of(additional), listenerCertificates(listener));
+ given().header("Authorization", ELB_AUTH)
+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)
+ .formParam("Certificates.member.1.CertificateArn", additional)
+ .when().post("/").then().statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("OperationNotPermitted"));
+ assertEquals(List.of(additional), listenerCertificates(listener));
+ }
+
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java
index d89e6b6df6..fda821154e 100644
--- a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java
@@ -22,14 +22,22 @@ import io.github.hectorvent.floci.services.elbv2.model.TargetHealth;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -82,6 +90,86 @@ class ElbV2ServiceTest {
stubAlbSubnets(ec2Service);
}
+ @ParameterizedTest
+ @ValueSource(strings = {"HTTPS", "TLS"})
+ void defaultCertificateRemovalIsRefusedBeforeChangingTheList(String protocol) {
+ String lbArn = service.createLoadBalancer(REGION, "default-cert-lb", "internal",
+ "TLS".equals(protocol) ? "network" : "application", "ipv4",
+ ALB_SUBNETS, List.of("sg-a"), Map.of()).getLoadBalancerArn();
+ String first = "arn:aws:iam::000000000000:server-certificate/first";
+ String additional = "arn:aws:iam::000000000000:server-certificate/additional";
+ String listenerArn = service.createListener(REGION, lbArn, protocol, 9443, null,
+ List.of(first, additional), List.of(), List.of(), Map.of()).getListenerArn();
+ clearInvocations(dataPlane);
+
+ AwsException rejected = assertThrows(AwsException.class,
+ () -> service.removeListenerCertificates(REGION, listenerArn, List.of(additional, first)));
+ assertEquals("OperationNotPermitted", rejected.getErrorCode());
+ assertEquals(List.of(first, additional), service.describeListenerCertificates(REGION, listenerArn));
+ verifyNoInteractions(dataPlane);
+
+ service.removeListenerCertificates(REGION, listenerArn, List.of(additional));
+ assertEquals(List.of(first), service.describeListenerCertificates(REGION, listenerArn));
+ assertThrows(AwsException.class,
+ () -> service.removeListenerCertificates(REGION, listenerArn, List.of(first)));
+ assertEquals(List.of(first), service.describeListenerCertificates(REGION, listenerArn));
+ }
+
+ @Test
+ void removalCannotDeleteADefaultPublishedByConcurrentModification() throws Exception {
+ String lbArn = service.createLoadBalancer(REGION, "default-replacement-lb", "internal", "application", "ipv4",
+ ALB_SUBNETS, List.of("sg-a"), Map.of()).getLoadBalancerArn();
+ String first = "arn:aws:iam::000000000000:server-certificate/first";
+ String additional = "arn:aws:iam::000000000000:server-certificate/additional";
+ String listener = service.createListener(REGION, lbArn, "HTTPS", 9443, null,
+ List.of(first, additional), List.of(), List.of(), Map.of()).getListenerArn();
+ CountDownLatch checkedOriginalDefault = new CountDownLatch(1);
+ CountDownLatch releaseRemoval = new CountDownLatch(1);
+ List<String> requested = new ArrayList<>(List.of(additional)) {
+ @Override
+ public boolean contains(Object value) {
+ boolean contains = super.contains(value);
+ checkedOriginalDefault.countDown();
+ try {
+ assertTrue(releaseRemoval.await(5, TimeUnit.SECONDS), "removal was not released");
+ } catch (InterruptedException failure) {
+ Thread.currentThread().interrupt();
+ throw new AssertionError("removal interrupted", failure);
+ }
+ return contains;
+ }
+ };
+ ExecutorService worker = Executors.newSingleThreadExecutor();
+ try {
+ Future<?> removal = worker.submit(() -> service.removeListenerCertificates(REGION, listener, requested));
+ assertTrue(checkedOriginalDefault.await(5, TimeUnit.SECONDS), "removal did not check the original default");
+ service.modifyListener(REGION, listener, null, null, null, List.of(additional), null, null);
+ assertEquals(List.of(additional), service.describeListenerCertificates(REGION, listener));
+ releaseRemoval.countDown();
+ removal.get(5, TimeUnit.SECONDS);
+ assertEquals(List.of(additional), service.describeListenerCertificates(REGION, listener));
+ AwsException rejected = assertThrows(AwsException.class,
+ () -> service.removeListenerCertificates(REGION, listener, List.of(additional)));
+ assertEquals("OperationNotPermitted", rejected.getErrorCode());
+ assertEquals(List.of(additional), service.describeListenerCertificates(REGION, listener));
+ } finally {
+ releaseRemoval.countDown();
+ worker.shutdownNow();
+ assertTrue(worker.awaitTermination(5, TimeUnit.SECONDS));
+ }
+ }
+
+ @Test
+ void certificateMetadataOnAnHttpListenerKeepsItsExistingRemovalBehavior() {
+ String lbArn = service.createLoadBalancer(REGION, "http-cert-lb", "internal", "application", "ipv4",
+ ALB_SUBNETS, List.of("sg-a"), Map.of()).getLoadBalancerArn();
+ String certificate = "arn:aws:iam::000000000000:server-certificate/metadata";
+ String listenerArn = service.createListener(REGION, lbArn, "HTTP", 8080, null,
+ List.of(certificate), List.of(), List.of(), Map.of()).getListenerArn();
+ service.removeListenerCertificates(REGION, listenerArn, List.of(certificate));
+ assertEquals(List.of(), service.describeListenerCertificates(REGION, listenerArn));
+ }
+
@Test
void modifyListenerDefaultActionsRecompilesRulesWithoutRestartingListener() {
String lbArn = service.createLoadBalancer(