Skip to content

armgit / floci

Public Imported from GitHub
0

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

fix(elbv2): round-trip the authenticate-oidc and authenticate-cognito configs (#3664)

lex00026abe487836
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java
index e0af962277..541c7d844b 100644
--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java
@@ -470,7 +470,10 @@ public class ElbV2QueryHandler {
Integer port = parseIntOrNull(p.getFirst("Port"));
String sslPolicy = p.getFirst("SslPolicy");
List<String> certs = parseCertificateList(p, "Certificates");
- List<Action> defaultActions = parseActions(p, "DefaultActions");
+ List<Action> defaultActions = parseActions(p, "DefaultActions", false);
+ applyExistingClientSecrets(defaultActions,
+ service.describeListeners(region, null, List.of(listenerArn)).stream()
+ .findFirst().map(Listener::getDefaultActions).orElse(null));
List<String> alpnPolicy = memberList(p, "AlpnPolicy");
Listener listener = service.modifyListener(region, listenerArn, protocol, port, sslPolicy,
@@ -585,7 +588,10 @@ public class ElbV2QueryHandler {
private Response handleModifyRule(MultivaluedMap<String, String> p, String region) {
String ruleArn = p.getFirst("RuleArn");
List<RuleCondition> conditions = parseConditions(p);
- List<Action> actions = parseActions(p, "Actions");
+ List<Action> actions = parseActions(p, "Actions", false);
+ applyExistingClientSecrets(actions,
+ service.describeRules(region, null, List.of(ruleArn)).stream()
+ .findFirst().map(Rule::getActions).orElse(null));
Rule rule = service.modifyRule(region, ruleArn,
conditions.isEmpty() ? null : conditions,
@@ -957,9 +963,58 @@ public class ElbV2QueryHandler {
if (a.getFixedResponseMessageBody() != null) xml.elem("MessageBody", a.getFixedResponseMessageBody());
xml.end("FixedResponseConfig");
}
+ if ("authenticate-oidc".equals(a.getType())) {
+ xml.start("AuthenticateOidcConfig");
+ xml.elem("Issuer", safe(a.getOidcIssuer()));
+ xml.elem("AuthorizationEndpoint", safe(a.getOidcAuthorizationEndpoint()));
+ xml.elem("TokenEndpoint", safe(a.getOidcTokenEndpoint()));
+ xml.elem("UserInfoEndpoint", safe(a.getOidcUserInfoEndpoint()));
+ xml.elem("ClientId", safe(a.getOidcClientId()));
+ // ClientSecret is deliberately absent. Real AWS never returns it, so a client that
+ // read it back here would compare it against a value AWS would not have sent.
+ if (a.getOidcSessionCookieName() != null) {
+ xml.elem("SessionCookieName", a.getOidcSessionCookieName());
+ }
+ if (a.getOidcScope() != null) xml.elem("Scope", a.getOidcScope());
+ if (a.getOidcSessionTimeout() != null) {
+ xml.elem("SessionTimeout", String.valueOf(a.getOidcSessionTimeout()));
+ }
+ if (a.getOidcOnUnauthenticatedRequest() != null) {
+ xml.elem("OnUnauthenticatedRequest", a.getOidcOnUnauthenticatedRequest());
+ }
+ xml.raw(authExtraParamsXml(a.getOidcAuthenticationRequestExtraParams()));
+ xml.end("AuthenticateOidcConfig");
+ }
+ if ("authenticate-cognito".equals(a.getType())) {
+ xml.start("AuthenticateCognitoConfig");
+ xml.elem("UserPoolArn", safe(a.getCognitoUserPoolArn()));
+ xml.elem("UserPoolClientId", safe(a.getCognitoUserPoolClientId()));
+ xml.elem("UserPoolDomain", safe(a.getCognitoUserPoolDomain()));
+ if (a.getCognitoSessionCookieName() != null) {
+ xml.elem("SessionCookieName", a.getCognitoSessionCookieName());
+ }
+ if (a.getCognitoScope() != null) xml.elem("Scope", a.getCognitoScope());
+ if (a.getCognitoSessionTimeout() != null) {
+ xml.elem("SessionTimeout", String.valueOf(a.getCognitoSessionTimeout()));
+ }
+ if (a.getCognitoOnUnauthenticatedRequest() != null) {
+ xml.elem("OnUnauthenticatedRequest", a.getCognitoOnUnauthenticatedRequest());
+ }
+ xml.raw(authExtraParamsXml(a.getCognitoAuthenticationRequestExtraParams()));
+ xml.end("AuthenticateCognitoConfig");
+ }
return xml.build();
}
+ private String authExtraParamsXml(Map<String, String> params) {
+ if (params == null || params.isEmpty()) {
+ return "";
+ }
+ XmlBuilder xml = new XmlBuilder().start("AuthenticationRequestExtraParams");
+ params.forEach((k, v) -> xml.start("entry").elem("key", k).elem("value", safe(v)).end("entry"));
+ return xml.end("AuthenticationRequestExtraParams").build();
+ }
+
private String conditionXml(RuleCondition c) {
XmlBuilder xml = new XmlBuilder();
xml.elem("Field", safe(c.getField()));
@@ -1059,6 +1114,16 @@ public class ElbV2QueryHandler {
}
private List<Action> parseActions(MultivaluedMap<String, String> p, String prefix) {
+ return parseActions(p, prefix, true);
+ }
+
+ /**
+ * @param creating true for CreateListener and CreateRule, false for the two modify operations.
+ * AuthenticateOidcActionConfig.ClientSecret is required on a create and may be omitted on a
+ * modify only when UseExistingClientSecret is true, so the two paths cannot share one rule.
+ */
+ private List<Action> parseActions(MultivaluedMap<String, String> p, String prefix,
+ boolean creating) {
List<Action> result = new ArrayList<>();
int i = 1;
while (true) {
@@ -1105,6 +1170,10 @@ public class ElbV2QueryHandler {
a.setFixedResponseContentType(p.getFirst(prefix + ".member." + i + ".FixedResponseConfig.ContentType"));
a.setFixedResponseMessageBody(p.getFirst(prefix + ".member." + i + ".FixedResponseConfig.MessageBody"));
}
+ case "authenticate-oidc" -> parseAuthenticateOidc(p,
+ prefix + ".member." + i + ".AuthenticateOidcConfig.", a, creating);
+ case "authenticate-cognito" -> parseAuthenticateCognito(p,
+ prefix + ".member." + i + ".AuthenticateCognitoConfig.", a);
}
result.add(a);
i++;
@@ -1112,6 +1181,111 @@ public class ElbV2QueryHandler {
return result;
}
+ // AuthenticateOidcActionConfig and AuthenticateCognitoActionConfig document these three
+ // defaults, and AWS reports the resolved values on Describe rather than the caller's gaps.
+ private static final String DEFAULT_AUTH_SESSION_COOKIE = "AWSELBAuthSessionCookie";
+ private static final String DEFAULT_AUTH_SCOPE = "openid";
+ private static final long DEFAULT_AUTH_SESSION_TIMEOUT = 604800L;
+
+ private void parseAuthenticateOidc(MultivaluedMap<String, String> p, String base, Action a,
+ boolean creating) {
+ a.setOidcIssuer(requiredAuthMember(p, base, "Issuer"));
+ a.setOidcAuthorizationEndpoint(requiredAuthMember(p, base, "AuthorizationEndpoint"));
+ a.setOidcTokenEndpoint(requiredAuthMember(p, base, "TokenEndpoint"));
+ a.setOidcUserInfoEndpoint(requiredAuthMember(p, base, "UserInfoEndpoint"));
+ a.setOidcClientId(requiredAuthMember(p, base, "ClientId"));
+ String clientSecret = p.getFirst(base + "ClientSecret");
+ boolean useExisting = Boolean.parseBoolean(p.getFirst(base + "UseExistingClientSecret"));
+ if (clientSecret == null || clientSecret.isBlank()) {
+ // Required on a create. On a modify it may be dropped only by asking for the stored
+ // one, and modifyExistingClientSecrets below is what puts that secret back.
+ if (creating || !useExisting) {
+ throw new AwsException("ValidationError", creating
+ ? "ClientSecret is required."
+ : "ClientSecret is required unless UseExistingClientSecret is true.", 400);
+ }
+ }
+ a.setOidcClientSecret(clientSecret);
+ a.setOidcUseExistingClientSecret(useExisting);
+ a.setOidcSessionCookieName(orDefault(p.getFirst(base + "SessionCookieName"),
+ DEFAULT_AUTH_SESSION_COOKIE));
+ a.setOidcScope(orDefault(p.getFirst(base + "Scope"), DEFAULT_AUTH_SCOPE));
+ a.setOidcSessionTimeout(parseSessionTimeout(p.getFirst(base + "SessionTimeout")));
+ a.setOidcOnUnauthenticatedRequest(p.getFirst(base + "OnUnauthenticatedRequest"));
+ a.setOidcAuthenticationRequestExtraParams(parseAuthExtraParams(p, base));
+ }
+
+ private void parseAuthenticateCognito(MultivaluedMap<String, String> p, String base, Action a) {
+ a.setCognitoUserPoolArn(requiredAuthMember(p, base, "UserPoolArn"));
+ a.setCognitoUserPoolClientId(requiredAuthMember(p, base, "UserPoolClientId"));
+ a.setCognitoUserPoolDomain(requiredAuthMember(p, base, "UserPoolDomain"));
+ a.setCognitoSessionCookieName(orDefault(p.getFirst(base + "SessionCookieName"),
+ DEFAULT_AUTH_SESSION_COOKIE));
+ a.setCognitoScope(orDefault(p.getFirst(base + "Scope"), DEFAULT_AUTH_SCOPE));
+ a.setCognitoSessionTimeout(parseSessionTimeout(p.getFirst(base + "SessionTimeout")));
+ a.setCognitoOnUnauthenticatedRequest(p.getFirst(base + "OnUnauthenticatedRequest"));
+ a.setCognitoAuthenticationRequestExtraParams(parseAuthExtraParams(p, base));
+ }
+
+ /**
+ * Puts the stored client secret back on any authenticate-oidc action that asked to keep it.
+ * Both modify operations replace the action list wholesale, so without this the documented
+ * UseExistingClientSecret flow would blank the secret it was written to preserve. A rule or a
+ * listener carries at most one authentication action, so the stored one is unambiguous.
+ */
+ private void applyExistingClientSecrets(List<Action> parsed, List<Action> existing) {
+ String stored = existing == null ? null : existing.stream()
+ .filter(a -> "authenticate-oidc".equals(a.getType()))
+ .map(Action::getOidcClientSecret)
+ .filter(Objects::nonNull)
+ .findFirst().orElse(null);
+ for (Action a : parsed) {
+ if ("authenticate-oidc".equals(a.getType()) && a.isOidcUseExistingClientSecret()
+ && (a.getOidcClientSecret() == null || a.getOidcClientSecret().isBlank())) {
+ if (stored == null) {
+ throw new AwsException("ValidationError",
+ "UseExistingClientSecret is true but no client secret is stored.", 400);
+ }
+ a.setOidcClientSecret(stored);
+ }
+ }
+ }
+
+ private String requiredAuthMember(MultivaluedMap<String, String> p, String base, String name) {
+ String value = p.getFirst(base + name);
+ if (value == null || value.isBlank()) {
+ throw new AwsException("ValidationError", name + " is required.", 400);
+ }
+ return value;
+ }
+
+ private static String orDefault(String value, String fallback) {
+ return value != null && !value.isBlank() ? value : fallback;
+ }
+
+ private static Long parseSessionTimeout(String raw) {
+ if (raw == null || raw.isBlank()) {
+ return DEFAULT_AUTH_SESSION_TIMEOUT;
+ }
+ return Long.parseLong(raw);
+ }
+
+ // AuthenticationRequestExtraParams is a map on the wire, so it arrives as
+ // <base>.AuthenticationRequestExtraParams.entry.N.key / .value.
+ private Map<String, String> parseAuthExtraParams(MultivaluedMap<String, String> p, String base) {
+ Map<String, String> params = new LinkedHashMap<>();
+ int n = 1;
+ while (true) {
+ String key = p.getFirst(base + "AuthenticationRequestExtraParams.entry." + n + ".key");
+ if (key == null) {
+ break;
+ }
+ params.put(key, safe(p.getFirst(base + "AuthenticationRequestExtraParams.entry." + n + ".value")));
+ n++;
+ }
+ return params;
+ }
+
private List<RuleCondition> parseConditions(MultivaluedMap<String, String> p) {
List<RuleCondition> result = new ArrayList<>();
int i = 1;
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Action.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Action.java
index 3f85746be1..2013f65f99 100644
--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Action.java
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Action.java
@@ -4,7 +4,9 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.quarkus.runtime.annotations.RegisterForReflection;
import java.util.ArrayList;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
@RegisterForReflection
@JsonIgnoreProperties(ignoreUnknown = true)
@@ -34,6 +36,36 @@ public class Action {
private String fixedResponseContentType;
private String fixedResponseMessageBody;
+ // authenticate-oidc
+ private String oidcIssuer;
+ private String oidcAuthorizationEndpoint;
+ private String oidcTokenEndpoint;
+ private String oidcUserInfoEndpoint;
+ private String oidcClientId;
+ /**
+ * Stored so a modify can keep it, never reported. Describe* on real AWS omits the secret,
+ * which is why Terraform's provider carries it forward from local state instead of reading
+ * it back.
+ */
+ private String oidcClientSecret;
+ /** Set by a modify that asked to keep the stored secret. Never reported. */
+ private boolean oidcUseExistingClientSecret;
+ private String oidcSessionCookieName;
+ private String oidcScope;
+ private Long oidcSessionTimeout;
+ private String oidcOnUnauthenticatedRequest;
+ private Map<String, String> oidcAuthenticationRequestExtraParams = new LinkedHashMap<>();
+
+ // authenticate-cognito
+ private String cognitoUserPoolArn;
+ private String cognitoUserPoolClientId;
+ private String cognitoUserPoolDomain;
+ private String cognitoSessionCookieName;
+ private String cognitoScope;
+ private Long cognitoSessionTimeout;
+ private String cognitoOnUnauthenticatedRequest;
+ private Map<String, String> cognitoAuthenticationRequestExtraParams = new LinkedHashMap<>();
+
public Action() {}
public String getType() { return type; }
@@ -81,6 +113,96 @@ public class Action {
public String getFixedResponseMessageBody() { return fixedResponseMessageBody; }
public void setFixedResponseMessageBody(String fixedResponseMessageBody) { this.fixedResponseMessageBody = fixedResponseMessageBody; }
+ public String getOidcIssuer() { return oidcIssuer; }
+ public void setOidcIssuer(String oidcIssuer) { this.oidcIssuer = oidcIssuer; }
+
+ public String getOidcAuthorizationEndpoint() { return oidcAuthorizationEndpoint; }
+ public void setOidcAuthorizationEndpoint(String oidcAuthorizationEndpoint) {
+ this.oidcAuthorizationEndpoint = oidcAuthorizationEndpoint;
+ }
+
+ public String getOidcTokenEndpoint() { return oidcTokenEndpoint; }
+ public void setOidcTokenEndpoint(String oidcTokenEndpoint) { this.oidcTokenEndpoint = oidcTokenEndpoint; }
+
+ public String getOidcUserInfoEndpoint() { return oidcUserInfoEndpoint; }
+ public void setOidcUserInfoEndpoint(String oidcUserInfoEndpoint) {
+ this.oidcUserInfoEndpoint = oidcUserInfoEndpoint;
+ }
+
+ public String getOidcClientId() { return oidcClientId; }
+ public void setOidcClientId(String oidcClientId) { this.oidcClientId = oidcClientId; }
+
+ public String getOidcClientSecret() { return oidcClientSecret; }
+ public void setOidcClientSecret(String oidcClientSecret) { this.oidcClientSecret = oidcClientSecret; }
+
+ public boolean isOidcUseExistingClientSecret() { return oidcUseExistingClientSecret; }
+ public void setOidcUseExistingClientSecret(boolean oidcUseExistingClientSecret) {
+ this.oidcUseExistingClientSecret = oidcUseExistingClientSecret;
+ }
+
+ public String getOidcSessionCookieName() { return oidcSessionCookieName; }
+ public void setOidcSessionCookieName(String oidcSessionCookieName) {
+ this.oidcSessionCookieName = oidcSessionCookieName;
+ }
+
+ public String getOidcScope() { return oidcScope; }
+ public void setOidcScope(String oidcScope) { this.oidcScope = oidcScope; }
+
+ public Long getOidcSessionTimeout() { return oidcSessionTimeout; }
+ public void setOidcSessionTimeout(Long oidcSessionTimeout) { this.oidcSessionTimeout = oidcSessionTimeout; }
+
+ public String getOidcOnUnauthenticatedRequest() { return oidcOnUnauthenticatedRequest; }
+ public void setOidcOnUnauthenticatedRequest(String oidcOnUnauthenticatedRequest) {
+ this.oidcOnUnauthenticatedRequest = oidcOnUnauthenticatedRequest;
+ }
+
+ public Map<String, String> getOidcAuthenticationRequestExtraParams() {
+ return oidcAuthenticationRequestExtraParams;
+ }
+
+ public void setOidcAuthenticationRequestExtraParams(Map<String, String> params) {
+ this.oidcAuthenticationRequestExtraParams = params;
+ }
+
+ public String getCognitoUserPoolArn() { return cognitoUserPoolArn; }
+ public void setCognitoUserPoolArn(String cognitoUserPoolArn) { this.cognitoUserPoolArn = cognitoUserPoolArn; }
+
+ public String getCognitoUserPoolClientId() { return cognitoUserPoolClientId; }
+ public void setCognitoUserPoolClientId(String cognitoUserPoolClientId) {
+ this.cognitoUserPoolClientId = cognitoUserPoolClientId;
+ }
+
+ public String getCognitoUserPoolDomain() { return cognitoUserPoolDomain; }
+ public void setCognitoUserPoolDomain(String cognitoUserPoolDomain) {
+ this.cognitoUserPoolDomain = cognitoUserPoolDomain;
+ }
+
+ public String getCognitoSessionCookieName() { return cognitoSessionCookieName; }
+ public void setCognitoSessionCookieName(String cognitoSessionCookieName) {
+ this.cognitoSessionCookieName = cognitoSessionCookieName;
+ }
+
+ public String getCognitoScope() { return cognitoScope; }
+ public void setCognitoScope(String cognitoScope) { this.cognitoScope = cognitoScope; }
+
+ public Long getCognitoSessionTimeout() { return cognitoSessionTimeout; }
+ public void setCognitoSessionTimeout(Long cognitoSessionTimeout) {
+ this.cognitoSessionTimeout = cognitoSessionTimeout;
+ }
+
+ public String getCognitoOnUnauthenticatedRequest() { return cognitoOnUnauthenticatedRequest; }
+ public void setCognitoOnUnauthenticatedRequest(String cognitoOnUnauthenticatedRequest) {
+ this.cognitoOnUnauthenticatedRequest = cognitoOnUnauthenticatedRequest;
+ }
+
+ public Map<String, String> getCognitoAuthenticationRequestExtraParams() {
+ return cognitoAuthenticationRequestExtraParams;
+ }
+
+ public void setCognitoAuthenticationRequestExtraParams(Map<String, String> params) {
+ this.cognitoAuthenticationRequestExtraParams = params;
+ }
+
@RegisterForReflection
@JsonIgnoreProperties(ignoreUnknown = true)
public static class TargetGroupTuple {
diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2AuthenticateActionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2AuthenticateActionIntegrationTest.java
new file mode 100644
index 0000000000..81f9ceac03
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2AuthenticateActionIntegrationTest.java
@@ -0,0 +1,264 @@
+package io.github.hectorvent.floci.services.elbv2;
+
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.path.xml.XmlPath;
+import io.restassured.specification.RequestSpecification;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+/**
+ * DescribeListeners and DescribeRules have to echo back the authenticate-oidc and
+ * authenticate-cognito configurations a listener or rule was created with. Without them a client
+ * that reads its own configuration back sees every sub-field missing and treats the listener as
+ * changed on every plan.
+ *
+ * <p>ClientSecret is the exception. Real AWS never returns it, so neither does floci.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class ElbV2AuthenticateActionIntegrationTest {
+
+ private static final String AUTH =
+ "AWS4-HMAC-SHA256 Credential=test/20260427/us-east-1/elasticloadbalancing/aws4_request";
+
+ private static String lbArn;
+ private static String tgArn;
+ private static String listenerArn;
+
+ private static String xml(RequestSpecification spec) {
+ return spec.header("Authorization", AUTH).when().post("/").then().statusCode(200)
+ .extract().asString();
+ }
+
+ @Test
+ @Order(1)
+ void seedLoadBalancerAndTargetGroup() {
+ lbArn = XmlPath.from(xml(given()
+ .formParam("Action", "CreateLoadBalancer")
+ .formParam("Name", "auth-action-lb")
+ .formParam("Type", "application")
+ .formParam("Subnets.member.1", Ec2Service.defaultSubnetId("us-east-1", "a"))
+ .formParam("Subnets.member.2", Ec2Service.defaultSubnetId("us-east-1", "b"))))
+ .getString("CreateLoadBalancerResponse.CreateLoadBalancerResult"
+ + ".LoadBalancers.member.LoadBalancerArn");
+
+ tgArn = XmlPath.from(xml(given()
+ .formParam("Action", "CreateTargetGroup")
+ .formParam("Name", "auth-action-tg")
+ .formParam("Protocol", "HTTP")
+ .formParam("Port", "80")
+ .formParam("VpcId", Ec2Service.defaultVpcId("us-east-1"))))
+ .getString("CreateTargetGroupResponse.CreateTargetGroupResult"
+ + ".TargetGroups.member.TargetGroupArn");
+ }
+
+ @Test
+ @Order(2)
+ void createListener_withAuthenticateOidc_roundTripsEverySubFieldExceptTheSecret() {
+ String base = "DefaultActions.member.1.AuthenticateOidcConfig.";
+ listenerArn = XmlPath.from(xml(given()
+ .formParam("Action", "CreateListener")
+ .formParam("LoadBalancerArn", lbArn)
+ .formParam("Protocol", "HTTPS")
+ .formParam("Port", "443")
+ .formParam("DefaultActions.member.1.Type", "authenticate-oidc")
+ .formParam("DefaultActions.member.1.Order", "1")
+ .formParam(base + "Issuer", "https://idp.example.com")
+ .formParam(base + "AuthorizationEndpoint", "https://idp.example.com/authorize")
+ .formParam(base + "TokenEndpoint", "https://idp.example.com/token")
+ .formParam(base + "UserInfoEndpoint", "https://idp.example.com/userinfo")
+ .formParam(base + "ClientId", "client-abc")
+ .formParam(base + "ClientSecret", "shhh")
+ .formParam(base + "OnUnauthenticatedRequest", "authenticate")
+ .formParam(base + "AuthenticationRequestExtraParams.entry.1.key", "prompt")
+ .formParam(base + "AuthenticationRequestExtraParams.entry.1.value", "login")
+ .formParam("DefaultActions.member.2.Type", "forward")
+ .formParam("DefaultActions.member.2.Order", "2")
+ .formParam("DefaultActions.member.2.TargetGroupArn", tgArn)))
+ .getString("CreateListenerResponse.CreateListenerResult"
+ + ".Listeners.member.ListenerArn");
+
+ String raw = xml(given()
+ .formParam("Action", "DescribeListeners")
+ .formParam("ListenerArns.member.1", listenerArn));
+ XmlPath described = XmlPath.from(raw);
+
+ String action = "DescribeListenersResponse.DescribeListenersResult.Listeners.member"
+ + ".DefaultActions.member[0].AuthenticateOidcConfig.";
+ assertEquals("https://idp.example.com", described.getString(action + "Issuer"));
+ assertEquals("https://idp.example.com/authorize",
+ described.getString(action + "AuthorizationEndpoint"));
+ assertEquals("https://idp.example.com/token", described.getString(action + "TokenEndpoint"));
+ assertEquals("https://idp.example.com/userinfo",
+ described.getString(action + "UserInfoEndpoint"));
+ assertEquals("client-abc", described.getString(action + "ClientId"));
+ assertEquals("authenticate", described.getString(action + "OnUnauthenticatedRequest"));
+ assertEquals("prompt",
+ described.getString(action + "AuthenticationRequestExtraParams.entry.key"));
+ assertEquals("login",
+ described.getString(action + "AuthenticationRequestExtraParams.entry.value"));
+
+ // The model documents all three defaults, and AWS reports the resolved value.
+ assertEquals("AWSELBAuthSessionCookie", described.getString(action + "SessionCookieName"));
+ assertEquals("openid", described.getString(action + "Scope"));
+ assertEquals("604800", described.getString(action + "SessionTimeout"));
+
+ assertFalse(raw.contains("ClientSecret"),
+ "real AWS never returns ClientSecret from a Describe call");
+ }
+
+ @Test
+ @Order(3)
+ void createRule_withAuthenticateCognito_roundTripsItsConfig() {
+ String base = "Actions.member.1.AuthenticateCognitoConfig.";
+ given()
+ .formParam("Action", "CreateRule")
+ .formParam("ListenerArn", listenerArn)
+ .formParam("Priority", "10")
+ .formParam("Conditions.member.1.Field", "path-pattern")
+ .formParam("Conditions.member.1.Values.member.1", "/private/*")
+ .formParam("Actions.member.1.Type", "authenticate-cognito")
+ .formParam("Actions.member.1.Order", "1")
+ .formParam(base + "UserPoolArn",
+ "arn:aws:cognito-idp:us-east-1:000000000000:userpool/us-east-1_abc")
+ .formParam(base + "UserPoolClientId", "pool-client")
+ .formParam(base + "UserPoolDomain", "auth.example.com")
+ .formParam(base + "Scope", "openid profile")
+ .formParam(base + "SessionTimeout", "3600")
+ .formParam("Actions.member.2.Type", "forward")
+ .formParam("Actions.member.2.Order", "2")
+ .formParam("Actions.member.2.TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when().post("/").then().statusCode(200);
+
+ XmlPath described = XmlPath.from(xml(given()
+ .formParam("Action", "DescribeRules")
+ .formParam("ListenerArn", listenerArn)));
+
+ String action = "DescribeRulesResponse.DescribeRulesResult.Rules.member"
+ + ".findAll { it.Priority.text() == '10' }.Actions.member[0]"
+ + ".AuthenticateCognitoConfig.";
+ assertEquals("arn:aws:cognito-idp:us-east-1:000000000000:userpool/us-east-1_abc",
+ described.getString(action + "UserPoolArn"));
+ assertEquals("pool-client", described.getString(action + "UserPoolClientId"));
+ assertEquals("auth.example.com", described.getString(action + "UserPoolDomain"));
+ assertEquals("openid profile", described.getString(action + "Scope"));
+ assertEquals("3600", described.getString(action + "SessionTimeout"));
+ assertEquals("AWSELBAuthSessionCookie", described.getString(action + "SessionCookieName"));
+ }
+
+ // ClientSecret is required on a create and may be omitted on a modify only by asking for the
+ // stored one. Both modify operations replace the action list wholesale, so without carrying the
+ // stored secret forward the documented keep-the-secret flow would blank it instead.
+ @Test
+ @Order(4)
+ void createListener_withoutClientSecret_isRejected() {
+ String base = "DefaultActions.member.1.AuthenticateOidcConfig.";
+ given()
+ .formParam("Action", "CreateListener")
+ .formParam("LoadBalancerArn", lbArn)
+ .formParam("Protocol", "HTTPS")
+ .formParam("Port", "9443")
+ .formParam("DefaultActions.member.1.Type", "authenticate-oidc")
+ .formParam(base + "Issuer", "https://idp.example.com")
+ .formParam(base + "AuthorizationEndpoint", "https://idp.example.com/authorize")
+ .formParam(base + "TokenEndpoint", "https://idp.example.com/token")
+ .formParam(base + "UserInfoEndpoint", "https://idp.example.com/userinfo")
+ .formParam(base + "ClientId", "client-abc")
+ .header("Authorization", AUTH)
+ .when().post("/")
+ .then().statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))
+ .body("ErrorResponse.Error.Message", equalTo("ClientSecret is required."));
+ }
+
+ @Test
+ @Order(5)
+ void modifyListener_withUseExistingClientSecret_keepsTheStoredSecret() {
+ String base = "DefaultActions.member.1.AuthenticateOidcConfig.";
+ xml(given()
+ .formParam("Action", "ModifyListener")
+ .formParam("ListenerArn", listenerArn)
+ .formParam("DefaultActions.member.1.Type", "authenticate-oidc")
+ .formParam("DefaultActions.member.1.Order", "1")
+ .formParam(base + "Issuer", "https://idp.example.com")
+ .formParam(base + "AuthorizationEndpoint", "https://idp.example.com/authorize")
+ .formParam(base + "TokenEndpoint", "https://idp.example.com/token")
+ .formParam(base + "UserInfoEndpoint", "https://idp.example.com/userinfo")
+ .formParam(base + "ClientId", "client-abc")
+ .formParam(base + "UseExistingClientSecret", "true")
+ .formParam(base + "Scope", "openid email")
+ .formParam("DefaultActions.member.2.Type", "forward")
+ .formParam("DefaultActions.member.2.Order", "2")
+ .formParam("DefaultActions.member.2.TargetGroupArn", tgArn));
+
+ // The modify took effect, and the secret the create supplied is still the stored one.
+ XmlPath described = XmlPath.from(xml(given()
+ .formParam("Action", "DescribeListeners")
+ .formParam("ListenerArns.member.1", listenerArn)));
+ String action = "DescribeListenersResponse.DescribeListenersResult.Listeners.member"
+ + ".DefaultActions.member[0].AuthenticateOidcConfig.";
+ assertEquals("openid email", described.getString(action + "Scope"));
+
+ // A later modify that keeps the secret again still works, which it cannot do once the
+ // stored secret has been blanked.
+ given()
+ .formParam("Action", "ModifyListener")
+ .formParam("ListenerArn", listenerArn)
+ .formParam("DefaultActions.member.1.Type", "authenticate-oidc")
+ .formParam(base + "Issuer", "https://idp.example.com")
+ .formParam(base + "AuthorizationEndpoint", "https://idp.example.com/authorize")
+ .formParam(base + "TokenEndpoint", "https://idp.example.com/token")
+ .formParam(base + "UserInfoEndpoint", "https://idp.example.com/userinfo")
+ .formParam(base + "ClientId", "client-abc")
+ .formParam(base + "UseExistingClientSecret", "true")
+ .header("Authorization", AUTH)
+ .when().post("/").then().statusCode(200);
+ }
+
+ @Test
+ @Order(6)
+ void modifyListener_withoutSecretAndWithoutTheFlag_isRejected() {
+ String base = "DefaultActions.member.1.AuthenticateOidcConfig.";
+ given()
+ .formParam("Action", "ModifyListener")
+ .formParam("ListenerArn", listenerArn)
+ .formParam("DefaultActions.member.1.Type", "authenticate-oidc")
+ .formParam(base + "Issuer", "https://idp.example.com")
+ .formParam(base + "AuthorizationEndpoint", "https://idp.example.com/authorize")
+ .formParam(base + "TokenEndpoint", "https://idp.example.com/token")
+ .formParam(base + "UserInfoEndpoint", "https://idp.example.com/userinfo")
+ .formParam(base + "ClientId", "client-abc")
+ .header("Authorization", AUTH)
+ .when().post("/")
+ .then().statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))
+ .body("ErrorResponse.Error.Message",
+ equalTo("ClientSecret is required unless UseExistingClientSecret is true."));
+ }
+
+ @Test
+ @Order(7)
+ void createListener_missingRequiredOidcMember_isRejected() {
+ given()
+ .formParam("Action", "CreateListener")
+ .formParam("LoadBalancerArn", lbArn)
+ .formParam("Protocol", "HTTPS")
+ .formParam("Port", "8443")
+ .formParam("DefaultActions.member.1.Type", "authenticate-oidc")
+ .formParam("DefaultActions.member.1.AuthenticateOidcConfig.Issuer",
+ "https://idp.example.com")
+ .header("Authorization", AUTH)
+ .when().post("/")
+ .then().statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));
+ }
+}