Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(iot): enforce custom authorizer decisions on MQTT connections (#4835)

Mario Toffiaa33eea05cdc2
diff --git a/compatibility-tests/sdk-test-java/pom.xml b/compatibility-tests/sdk-test-java/pom.xml
index 7f84ea85d8..d85e44997b 100644
--- a/compatibility-tests/sdk-test-java/pom.xml
+++ b/compatibility-tests/sdk-test-java/pom.xml
@@ -666,6 +666,20 @@
<version>1.84</version>
<scope>test</scope>
</dependency>
+ <!-- MQTT 3.1.1 and MQTT 5 clients for the IoT custom-authorizer WebSocket tests,
+ the versions the emulator module itself tests with -->
+ <dependency>
+ <groupId>org.eclipse.paho</groupId>
+ <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
+ <version>1.2.5</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.paho</groupId>
+ <artifactId>org.eclipse.paho.mqttv5.client</artifactId>
+ <version>1.2.5</version>
+ <scope>test</scope>
+ </dependency>
<!-- Decodes the Snappy variants Firehose delivers to S3 (issue #2328).
Pinned because this module imports no BOM; keep it in step with the
version the Quarkus BOM manages for the emulator itself. -->
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IotCustomAuthorizerTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IotCustomAuthorizerTest.java
new file mode 100644
index 0000000000..5102da234b
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IotCustomAuthorizerTest.java
@@ -0,0 +1,1245 @@
+package com.floci.test;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.eclipse.paho.client.mqttv3.MqttClient;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
+import org.eclipse.paho.mqttv5.client.IMqttToken;
+import org.eclipse.paho.mqttv5.client.MqttAsyncClient;
+import org.eclipse.paho.mqttv5.client.MqttCallback;
+import org.eclipse.paho.mqttv5.client.MqttConnectionOptions;
+import org.eclipse.paho.mqttv5.client.MqttDisconnectResponse;
+import org.eclipse.paho.mqttv5.common.MqttMessage;
+import org.eclipse.paho.mqttv5.common.packet.MqttProperties;
+import org.jboss.logging.Logger;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.awscore.exception.AwsServiceException;
+import software.amazon.awssdk.core.SdkBytes;
+import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsClient;
+import software.amazon.awssdk.services.iam.IamClient;
+import software.amazon.awssdk.services.iot.IotClient;
+import software.amazon.awssdk.services.iot.model.AuthorizerStatus;
+import software.amazon.awssdk.services.iot.model.InvalidRequestException;
+import software.amazon.awssdk.services.iot.model.InvalidResponseException;
+import software.amazon.awssdk.services.iot.model.ResourceNotFoundException;
+import software.amazon.awssdk.services.iot.model.TestInvokeAuthorizerRequest;
+import software.amazon.awssdk.services.iot.model.TestInvokeAuthorizerResponse;
+import software.amazon.awssdk.services.lambda.LambdaClient;
+import software.amazon.awssdk.services.lambda.model.InvalidParameterValueException;
+import software.amazon.awssdk.services.lambda.model.Runtime;
+import software.amazon.awssdk.services.lambda.model.State;
+import software.amazon.awssdk.services.sts.StsClient;
+import software.amazon.awssdk.services.sts.model.GetCallerIdentityResponse;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.SecureRandom;
+import java.security.Signature;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.assertj.core.api.Assertions.fail;
+
+/**
+ * AWS IoT custom authorizers: {@code TestInvokeAuthorizer} and enforcement of a real MQTT CONNECT over
+ * WebSocket. Every expectation was measured against real AWS IoT Core (eu-west-1).
+ *
+ * <p>One Python Lambda serves every case. It decides by the decoded MQTT password, or by the token when
+ * there is no password, or by an {@code x-secret} header for an HTTP context. The {@code shape:<kind>}
+ * secrets make the Lambda check the received event against the AWS shape for that transport and answer
+ * with principal {@code shapeok} (allowed) or {@code shapebad} (denied), so the event shape is asserted
+ * through the authorizer response or the connection outcome.
+ *
+ * <p>Paho v3 and v5 share several class names ({@code MqttException}, {@code MemoryPersistence}); the v3
+ * ones are imported and the v5 ones are written fully qualified.
+ */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@DisplayName("IoT custom authorizer invocation and enforcement")
+class IotCustomAuthorizerTest {
+
+ private static final Logger LOG = Logger.getLogger(IotCustomAuthorizerTest.class);
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ private static final String PRINCIPAL = "measuredprincipal";
+ private static final String TOKEN_KEY_NAME = "tok";
+ private static final String SHAPE_SERVER_NAME = "shape.example.com";
+ private static final String NAME_PARAM = "x-amz-customauthorizer-name=";
+ private static final String SIGNATURE_PARAM = "x-amz-customauthorizer-signature=";
+ private static final String NAME_HEADER = "x-amz-customauthorizer-name";
+ private static final int TIMEOUT_SECONDS = 20;
+ /** AWS IoT allows one CONNECT per second per client id and answers a faster one with CONNACK 151. */
+ private static final long CONNECT_SPACING_NANOS = TimeUnit.MILLISECONDS.toNanos(1200);
+ /**
+ * MQTT 5 refusal: CONNACK reason 0x87. AWS also sends the reason string
+ * {@code CONNACK:Client is not authenticated/authorized to send the message:<id>}, which Paho 1.2.5 drops.
+ */
+ private static final int MQTT5_NOT_AUTHORIZED = 135;
+ /** MQTT 3.1.1 refusal: AWS sends no CONNACK and closes the WebSocket, which Paho reports as a lost connection. */
+ private static final int MQTT3_REFUSAL_REASON_CODE = MqttException.REASON_CODE_CONNECTION_LOST;
+
+ private static final String LAMBDA_SOURCE = """
+ import base64
+ import json
+ import os
+ import re
+
+ ALLOW_POLICY = os.environ["ALLOW_POLICY"]
+ ARN_PREFIX = os.environ["IOT_ARN_PREFIX"]
+ CLIENT_ID = os.environ["ALLOWED_CLIENT_ID"]
+ NAME_PREFIX = os.environ["NAME_PREFIX"]
+ SERVER_NAME = os.environ["SHAPE_SERVER_NAME"]
+ NAME_PARAM = "x-amz-customauthorizer-name="
+ SIGNATURE_PARAM = "x-amz-customauthorizer-signature="
+ ID_PATTERN = re.compile("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
+ SIGNED_KINDS = ("ti-token", "ti-signed-mqtt", "ws-signed")
+
+
+ def response(policies, principal="measuredprincipal", refresh=300, disconnect=3600):
+ out = {"isAuthenticated": True, "principalId": principal, "policyDocuments": policies}
+ if refresh is not None:
+ out["refreshAfterInSeconds"] = refresh
+ if disconnect is not None:
+ out["disconnectAfterInSeconds"] = disconnect
+ return out
+
+
+ def secret_of(event):
+ data = event.get("protocolData") or {}
+ mqtt = data.get("mqtt") or {}
+ if mqtt.get("password") is not None:
+ return base64.b64decode(mqtt["password"]).decode("utf-8")
+ if event.get("token") is not None:
+ return event["token"]
+ http = data.get("http") or {}
+ for key, value in (http.get("headers") or {}).items():
+ if key.lower() == "x-secret":
+ return value
+ for part in (http.get("queryString") or "").lstrip("?").split("&"):
+ if part.startswith("x-secret="):
+ return part.split("=", 1)[1]
+ return None
+
+
+ def expect(problems, condition, what):
+ if not condition:
+ problems.append(what)
+
+
+ def named_username(username, signed, secret):
+ prefix = CLIENT_ID + "?" + NAME_PARAM + NAME_PREFIX
+ if not isinstance(username, str) or not username.startswith(prefix):
+ return False
+ if signed:
+ return ("&" + SIGNATURE_PARAM) in username and username.endswith("&tok=" + secret)
+ return "&" not in username
+
+
+ def shape_problems(kind, event, secret):
+ problems = []
+ signed = kind in SIGNED_KINDS
+ expect(problems, event.get("signatureVerified") is signed, "signatureVerified %r" % event.get("signatureVerified"))
+ if signed:
+ expect(problems, event.get("token") == secret, "token %r" % event.get("token"))
+ else:
+ expect(problems, "token" not in event, "unexpected token")
+ meta = event.get("connectionMetadata")
+ expect(problems, isinstance(meta, dict) and set(meta) == {"id"} and ID_PATTERN.match(str(meta.get("id"))) is not None, "connectionMetadata %r" % meta)
+ if kind == "ti-token":
+ expect(problems, set(event) == {"token", "signatureVerified", "connectionMetadata"}, "keys %r" % sorted(event))
+ return problems
+ top = {"protocolData", "protocols", "signatureVerified", "connectionMetadata"}
+ if signed:
+ top.add("token")
+ expect(problems, set(event) == top, "keys %r" % sorted(event))
+ data = event.get("protocolData")
+ protocols = event.get("protocols")
+ if not isinstance(data, dict):
+ problems.append("protocolData %r" % data)
+ return problems
+ if kind == "ti-http":
+ expect(problems, protocols == ["http"], "protocols %r" % protocols)
+ expected = {"http": {"headers": {"X-Secret": secret, "X-Mixed-Case": "Value"}, "queryString": "?a=b&c=d"}}
+ expect(problems, data == expected, "protocolData %r" % data)
+ return problems
+ mqtt = data.get("mqtt") or {}
+ username = mqtt.get("username")
+ expect(problems, mqtt.get("clientId") == CLIENT_ID, "clientId %r" % mqtt.get("clientId"))
+ if signed:
+ expect(problems, set(mqtt) == {"username", "clientId"}, "mqtt keys %r" % sorted(mqtt))
+ else:
+ expect(problems, set(mqtt) == {"username", "password", "clientId"}, "mqtt keys %r" % sorted(mqtt))
+ expected_password = base64.b64encode(secret.encode("utf-8")).decode("ascii")
+ expect(problems, mqtt.get("password") == expected_password, "password %r" % mqtt.get("password"))
+ if kind in ("ti-mqtt", "ti-mqtt-tls", "ti-signed-mqtt"):
+ tls = kind == "ti-mqtt-tls"
+ expect(problems, protocols == (["tls", "mqtt"] if tls else ["mqtt"]), "protocols %r" % protocols)
+ expect(problems, set(data) == ({"tls", "mqtt"} if tls else {"mqtt"}), "protocolData keys %r" % sorted(data))
+ if tls:
+ expect(problems, data.get("tls") == {"serverName": SERVER_NAME}, "tls %r" % data.get("tls"))
+ expect(problems, named_username(username, signed, secret), "username %r" % username)
+ return problems
+ expect(problems, isinstance(protocols, list) and "http" in protocols and "mqtt" in protocols
+ and set(protocols) <= {"tls", "http", "mqtt"} and len(set(protocols)) == len(protocols), "protocols %r" % protocols)
+ expect(problems, isinstance(protocols, list) and set(data) == set(protocols), "protocolData keys %r" % sorted(data))
+ if "tls" in data:
+ tls = data["tls"]
+ expect(problems, isinstance(tls, dict) and set(tls) == {"serverName"} and bool(tls.get("serverName")), "tls %r" % tls)
+ http = data.get("http") or {}
+ expect(problems, set(http) == {"headers", "queryString"}, "http keys %r" % sorted(http))
+ headers = http.get("headers") or {}
+ expect(problems, all(key == key.lower() for key in headers), "header names %r" % sorted(headers))
+ expect(problems, "mqtt" in str(headers.get("sec-websocket-protocol")), "sec-websocket-protocol %r" % headers.get("sec-websocket-protocol"))
+ query = http.get("queryString")
+ if kind == "ws-query":
+ expect(problems, isinstance(query, str) and query.startswith(NAME_PARAM + NAME_PREFIX) and "&" not in query, "queryString %r" % query)
+ else:
+ expect(problems, query == "", "queryString %r" % query)
+ if kind == "ws-header":
+ expect(problems, str(headers.get("x-amz-customauthorizer-name")).startswith(NAME_PREFIX), "name header %r" % headers.get("x-amz-customauthorizer-name"))
+ if kind in ("ws-query", "ws-header"):
+ expect(problems, username == CLIENT_ID, "username %r" % username)
+ else:
+ expect(problems, named_username(username, signed, secret), "username %r" % username)
+ return problems
+
+
+ def handler(event, context):
+ print(json.dumps(event))
+ secret = secret_of(event)
+ print("secret=%r" % (secret,))
+ policy = ALLOW_POLICY
+ if secret is None:
+ return {"isAuthenticated": False}
+ if secret.startswith("shape:"):
+ problems = shape_problems(secret[len("shape:"):], event, secret)
+ print("shape problems: %r" % (problems,))
+ if problems:
+ return {"isAuthenticated": False, "principalId": "shapebad", "policyDocuments": []}
+ return response([policy], principal="shapeok")
+ if secret.startswith("ttl:"):
+ _, refresh, disconnect = secret.split(":")
+ return response([policy],
+ refresh=None if refresh == "-" else int(refresh),
+ disconnect=None if disconnect == "-" else int(disconnect))
+ if secret == "allow-me":
+ return response([policy])
+ if secret == "raise":
+ raise Exception("compat-raise")
+ if secret == "garbage":
+ return {"foo": 1}
+ if secret == "noauthflag":
+ return {"principalId": "measuredprincipal", "policyDocuments": [policy]}
+ if secret == "noprincipal":
+ return {"isAuthenticated": True, "policyDocuments": [policy]}
+ if secret == "badprincipal":
+ return response([policy], principal="bad-principal!")
+ if secret == "nopolicy":
+ return {"isAuthenticated": True, "principalId": "measuredprincipal"}
+ if secret == "denynopolicy":
+ return {"isAuthenticated": False, "principalId": "measuredprincipal"}
+ if secret == "denypol":
+ return {"isAuthenticated": False, "principalId": "measuredprincipal", "policyDocuments": [policy]}
+ if secret == "emptypol":
+ return response([])
+ if secret == "badjson":
+ return response(["this is not json"])
+ if secret == "manypol":
+ return response([policy] * 11)
+ if secret == "bigpol":
+ big = json.loads(policy)
+ big["Statement"][1]["Resource"] = [ARN_PREFIX + ":topic/big/%040d" % i for i in range(60)]
+ return response([json.dumps(big)])
+ if secret == "objpolicy":
+ return response([json.loads(policy)])
+ return {"isAuthenticated": False}
+ """;
+
+ private final String prefix = TestFixtures.uniqueName("compat-cauth");
+ private final String roleName = prefix + "-role";
+ private final String rolePolicyName = prefix + "-logs";
+ private final String functionName = prefix + "-fn";
+ private final String authorizer = prefix + "-a";
+ private final String signedAuthorizer = prefix + "-s";
+ private final String inactiveAuthorizer = prefix + "-i";
+ private final String unknownAuthorizer = prefix + "-nope";
+ private final String clientId = prefix + "-client";
+ private final String otherClientId = prefix + "-other";
+ private final List<String> createdAuthorizers = new ArrayList<>();
+ private final Map<String, Long> lastConnectNanos = new HashMap<>();
+
+ private IotClient iot;
+ private LambdaClient lambda;
+ private IamClient iam;
+ private CloudWatchLogsClient logs;
+ private boolean roleCreated;
+ private boolean functionCreated;
+ private boolean logGroupCreated;
+ private String allowPolicy;
+ private String mqttUri;
+ private KeyPair key1;
+ private KeyPair key2;
+ private KeyPair unregisteredKey;
+
+ enum Mqtt { V3_1_1, V5 }
+
+ @BeforeAll
+ void setUp() throws Exception {
+ iot = TestFixtures.iotClient();
+ lambda = TestFixtures.lambdaClient();
+ iam = TestFixtures.iamClient();
+ logs = TestFixtures.cloudWatchLogsClient();
+
+ String region;
+ try (StsClient sts = TestFixtures.stsClient()) {
+ region = sts.serviceClientConfiguration().region().id();
+ GetCallerIdentityResponse identity = sts.getCallerIdentity();
+ String partition = identity.arn().split(":")[1];
+ String arnPrefix = "arn:" + partition + ":iot:" + region + ":" + identity.account();
+ allowPolicy = "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", "
+ + "\"Action\": \"iot:Connect\", \"Resource\": \"" + arnPrefix + ":client/" + clientId + "\"}, "
+ + "{\"Effect\": \"Allow\", \"Action\": [\"iot:Publish\", \"iot:Subscribe\", \"iot:Receive\"], "
+ + "\"Resource\": \"*\"}]}";
+
+ KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
+ generator.initialize(2048);
+ key1 = generator.generateKeyPair();
+ key2 = generator.generateKeyPair();
+ unregisteredKey = generator.generateKeyPair();
+
+ String roleArn = createRole();
+ String functionArn = createFunction(roleArn, arnPrefix);
+ createAuthorizer(authorizer, functionArn, AuthorizerStatus.ACTIVE, false);
+ createAuthorizer(signedAuthorizer, functionArn, AuthorizerStatus.ACTIVE, true);
+ createAuthorizer(inactiveAuthorizer, functionArn, AuthorizerStatus.INACTIVE, false);
+ }
+ mqttUri = mqttBaseUri();
+ LOG.infov("custom authorizer fixtures ready: prefix={0} mqtt={1}", prefix, mqttUri);
+ awaitAuthorizerReady();
+ }
+
+ @AfterAll
+ void tearDown() {
+ for (String name : createdAuthorizers) {
+ quietly("deactivate authorizer " + name,
+ () -> iot.updateAuthorizer(r -> r.authorizerName(name).status(AuthorizerStatus.INACTIVE)));
+ quietly("delete authorizer " + name, () -> iot.deleteAuthorizer(r -> r.authorizerName(name)));
+ }
+ if (functionCreated) {
+ quietly("delete function", () -> lambda.deleteFunction(r -> r.functionName(functionName)));
+ }
+ if (roleCreated) {
+ quietly("delete role policy",
+ () -> iam.deleteRolePolicy(r -> r.roleName(roleName).policyName(rolePolicyName)));
+ quietly("delete role", () -> iam.deleteRole(r -> r.roleName(roleName)));
+ }
+ if (logGroupCreated) {
+ quietly("delete log group",
+ () -> logs.deleteLogGroup(r -> r.logGroupName("/aws/lambda/" + functionName)));
+ }
+ quietly("close clients", () -> {
+ iot.close();
+ lambda.close();
+ iam.close();
+ logs.close();
+ });
+ }
+
+ // ---------------------------------------------------------------------------------------------
+ // TestInvokeAuthorizer
+ // ---------------------------------------------------------------------------------------------
+
+ @Test
+ @DisplayName("test-invoke with an MQTT context returns the Lambda's verdict, policies verbatim and TTLs")
+ void testInvokeAllow() {
+ TestInvokeAuthorizerResponse response = invokeMqtt(authorizer, "allow-me");
+
+ assertThat(response.isAuthenticated()).isTrue();
+ assertThat(response.principalId()).isEqualTo(PRINCIPAL);
+ assertThat(response.policyDocuments()).containsExactly(allowPolicy);
+ assertThat(response.refreshAfterInSeconds()).isEqualTo(300);
+ assertThat(response.disconnectAfterInSeconds()).isEqualTo(3600);
+ }
+
+ @Test
+ @DisplayName("test-invoke with only an MQTT context sends protocols [mqtt] and the MQTT fields as given")
+ void testInvokeMqttContextEventShape() {
+ assertShapeOk(invokeMqtt(authorizer, "shape:ti-mqtt"));
+ }
+
+ @Test
+ @DisplayName("test-invoke with MQTT and TLS contexts sends protocols [tls, mqtt] and the server name")
+ void testInvokeMqttAndTlsContextEventShape() {
+ String secret = "shape:ti-mqtt-tls";
+ assertShapeOk(iot.testInvokeAuthorizer(r -> r.authorizerName(authorizer)
+ .mqttContext(m -> m.clientId(clientId)
+ .username(namedUsername(authorizer))
+ .password(SdkBytes.fromUtf8String(secret)))
+ .tlsContext(t -> t.serverName(SHAPE_SERVER_NAME))));
+ }
+
+ @Test
+ @DisplayName("test-invoke with only an HTTP context keeps header case and the query string with its '?'")
+ void testInvokeHttpContextEventShape() {
+ Map<String, String> headers = new LinkedHashMap<>();
+ headers.put("X-Secret", "shape:ti-http");
+ headers.put("X-Mixed-Case", "Value");
+ assertShapeOk(iot.testInvokeAuthorizer(r -> r.authorizerName(authorizer)
+ .httpContext(h -> h.headers(headers).queryString("?a=b&c=d"))));
+ }
+
+ @Test
+ @DisplayName("test-invoke fills omitted TTLs with 300 and 86400")
+ void testInvokeOmittedTtlsAreDefaulted() {
+ TestInvokeAuthorizerResponse response = invokeMqtt(authorizer, "ttl:-:-");
+
+ assertThat(response.isAuthenticated()).isTrue();
+ assertThat(response.policyDocuments()).containsExactly(allowPolicy);
+ assertThat(response.refreshAfterInSeconds()).isEqualTo(300);
+ assertThat(response.disconnectAfterInSeconds()).isEqualTo(86400);
+ }
+
+ @Test
+ @DisplayName("test-invoke accepts TTLs at the inclusive bounds 300 and 86400")
+ void testInvokeTtlBoundsAccepted() {
+ TestInvokeAuthorizerResponse response = invokeMqtt(authorizer, "ttl:300:86400");
+
+ assertThat(response.refreshAfterInSeconds()).isEqualTo(300);
+ assertThat(response.disconnectAfterInSeconds()).isEqualTo(86400);
+ }
+
+ @Test
+ @DisplayName("test-invoke returns a policy given as a JSON object as one compact string")
+ void testInvokeObjectPolicyIsCompacted() throws IOException {
+ TestInvokeAuthorizerResponse response = invokeMqtt(authorizer, "objpolicy");
+
+ assertThat(response.isAuthenticated()).isTrue();
+ assertThat(response.policyDocuments()).containsExactly(MAPPER.writeValueAsString(MAPPER.readTree(allowPolicy)));
+ }
+
+ static Stream<Arguments> invalidLambdaResponses() {
+ return Stream.of(
+ Arguments.of("garbage", "Lambda invocation result is in invalid format"),
+ Arguments.of("noauthflag", "Lambda invocation result is in invalid format"),
+ Arguments.of("deny",
+ "null at principalId failed to satisfy constraint: Member must satisfy ([a-zA-Z0-9]){1,128}"),
+ Arguments.of("noprincipal",
+ "null at principalId failed to satisfy constraint: Member must satisfy ([a-zA-Z0-9]){1,128}"),
+ Arguments.of("badprincipal", "bad-principal! at principalId failed to satisfy constraint: "
+ + "Member must satisfy ([a-zA-Z0-9]){1,128}"),
+ Arguments.of("nopolicy",
+ "policyDocuments failed to satisfy constraint: List of policies cannot be null."),
+ Arguments.of("denynopolicy",
+ "policyDocuments failed to satisfy constraint: List of policies cannot be null."),
+ Arguments.of("badjson", "policyDocuments failed to satisfy constraint: "
+ + "Policy document is Malformed: Invalid policy syntax."),
+ Arguments.of("manypol",
+ "policyDocuments failed to satisfy constraint: Number of policies allowed cannot exceed 10"),
+ Arguments.of("bigpol", "policyDocuments failed to satisfy constraint: "
+ + "Size of a policy document cannot exceeds hard limit of 2048"),
+ Arguments.of("ttl:299:3600", "299 at refreshAfterInSeconds failed to satisfy constraint: "
+ + "Member must be greater than 5 minutes and less than 24 hours."),
+ Arguments.of("ttl:86401:3600", "86401 at refreshAfterInSeconds failed to satisfy constraint: "
+ + "Member must be greater than 5 minutes and less than 24 hours."),
+ Arguments.of("ttl:300:299", "299 at disconnectAfterInSeconds failed to satisfy constraint: "
+ + "Member must be greater than 5 minutes and less than 24 hours."),
+ Arguments.of("ttl:300:86401", "86401 at disconnectAfterInSeconds failed to satisfy constraint: "
+ + "Member must be greater than 5 minutes and less than 24 hours."),
+ Arguments.of("ttl:10:10", "10 at refreshAfterInSeconds failed to satisfy constraint: "
+ + "Member must be greater than 5 minutes and less than 24 hours."),
+ Arguments.of("raise", "Lambda function encountered error in execution: compat-raise: Exception"));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("invalidLambdaResponses")
+ @DisplayName("test-invoke rejects an invalid Lambda response with InvalidResponseException")
+ void testInvokeRejectsInvalidLambdaResponse(String secret, String message) {
+ assertAwsError(() -> invokeMqtt(authorizer, secret), InvalidResponseException.class, 400, message);
+ }
+
+ @Test
+ @DisplayName("test-invoke returns isAuthenticated false when the Lambda denies with a principal and policies")
+ void testInvokeDenyWithPolicies() {
+ TestInvokeAuthorizerResponse response = invokeMqtt(authorizer, "denypol");
+
+ assertThat(response.isAuthenticated()).isFalse();
+ assertThat(response.principalId()).isEqualTo(PRINCIPAL);
+ assertThat(response.policyDocuments()).containsExactly(allowPolicy);
+ }
+
+ @Test
+ @DisplayName("test-invoke accepts an empty policyDocuments list")
+ void testInvokeEmptyPolicies() {
+ TestInvokeAuthorizerResponse response = invokeMqtt(authorizer, "emptypol");
+
+ assertThat(response.isAuthenticated()).isTrue();
+ assertThat(response.principalId()).isEqualTo(PRINCIPAL);
+ assertThat(response.policyDocuments()).isEmpty();
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects a token without its signature")
+ void testInvokeTokenWithoutSignature() {
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(authorizer).token("allow-me")),
+ InvalidRequestException.class, 400, "Request must provide both token and tokenSignature together.");
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects a token and signature on a signing-disabled authorizer")
+ void testInvokeTokenOnSigningDisabledAuthorizer() throws GeneralSecurityException {
+ String signature = sign(key1.getPrivate(), "allow-me");
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(authorizer)
+ .token("allow-me").tokenSignature(signature)),
+ InvalidRequestException.class, 400,
+ "Token and token signature provided but signing is disabled for the authorizer.");
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects a token combined with a context")
+ void testInvokeTokenWithContext() throws GeneralSecurityException {
+ String signature = sign(key1.getPrivate(), "allow-me");
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(signedAuthorizer)
+ .token("allow-me").tokenSignature(signature)
+ .mqttContext(m -> m.clientId(clientId).password(SdkBytes.fromUtf8String("allow-me")))),
+ InvalidRequestException.class, 400, "Request cannot have token and Http/Mqtt/Tls context.");
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects a request without token or context")
+ void testInvokeEmptyRequest() {
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(authorizer)),
+ InvalidRequestException.class, 400, "Request must have Http/Mqtt/Tls context.");
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects an HTTP query string without the leading '?'")
+ void testInvokeQueryStringWithoutQuestionMark() {
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(authorizer)
+ .httpContext(h -> h.headers(Map.of("X-Secret", "allow-me")).queryString("a=b"))),
+ InvalidRequestException.class, 400, "Invalid arguments in the call");
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects an empty HTTP query string")
+ void testInvokeEmptyQueryString() {
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(authorizer)
+ .httpContext(h -> h.headers(Map.of("X-Secret", "allow-me")).queryString(""))),
+ InvalidRequestException.class, 400,
+ "1 validation error detected: Value at 'httpContext.queryString' failed to satisfy constraint: "
+ + "Member must have length greater than or equal to 1");
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects a token signature that is not base64")
+ void testInvokeNonBase64Signature() {
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(signedAuthorizer)
+ .token("allow-me").tokenSignature("not base64!")),
+ InvalidRequestException.class, 400,
+ "1 validation error detected: Value at 'tokenSignature' failed to satisfy constraint: "
+ + "Member must satisfy regular expression pattern: [A-Za-z0-9+/]+={0,2}");
+ }
+
+ @Test
+ @DisplayName("test-invoke works on an INACTIVE authorizer")
+ void testInvokeInactiveAuthorizer() {
+ TestInvokeAuthorizerResponse response = invokeMqtt(inactiveAuthorizer, "allow-me");
+
+ assertThat(response.isAuthenticated()).isTrue();
+ assertThat(response.principalId()).isEqualTo(PRINCIPAL);
+ assertThat(response.policyDocuments()).containsExactly(allowPolicy);
+ }
+
+ @Test
+ @DisplayName("test-invoke on a nonexistent authorizer is 404")
+ void testInvokeUnknownAuthorizer() {
+ assertAwsError(() -> invokeMqtt(unknownAuthorizer, "allow-me"), ResourceNotFoundException.class, 404,
+ "Authorizer " + unknownAuthorizer + " not found");
+ }
+
+ @Test
+ @DisplayName("test-invoke in token mode verifies a signature by either registered key")
+ void testInvokeSignedTokenEitherKey() throws GeneralSecurityException {
+ for (KeyPair key : List.of(key1, key2)) {
+ String signature = sign(key.getPrivate(), "allow-me");
+ TestInvokeAuthorizerResponse response = iot.testInvokeAuthorizer(r -> r.authorizerName(signedAuthorizer)
+ .token("allow-me").tokenSignature(signature));
+
+ assertThat(response.isAuthenticated()).isTrue();
+ assertThat(response.principalId()).isEqualTo(PRINCIPAL);
+ assertThat(response.policyDocuments()).containsExactly(allowPolicy);
+ }
+ }
+
+ @Test
+ @DisplayName("test-invoke in token mode sends only token, signatureVerified true and connectionMetadata")
+ void testInvokeTokenModeEventShape() throws GeneralSecurityException {
+ String token = "shape:ti-token";
+ String signature = sign(key2.getPrivate(), token);
+ assertShapeOk(iot.testInvokeAuthorizer(r -> r.authorizerName(signedAuthorizer)
+ .token(token).tokenSignature(signature)));
+ }
+
+ @Test
+ @DisplayName("test-invoke rejects a signature over another token or by an unregistered key")
+ void testInvokeSignatureMismatch() throws GeneralSecurityException {
+ String message = "Token signature mismatch for authorizer " + signedAuthorizer;
+ String otherToken = sign(key1.getPrivate(), "other-token");
+ String unregistered = sign(unregisteredKey.getPrivate(), "allow-me");
+
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(signedAuthorizer)
+ .token("allow-me").tokenSignature(otherToken)), InvalidRequestException.class, 400, message);
+ assertAwsError(() -> iot.testInvokeAuthorizer(r -> r.authorizerName(signedAuthorizer)
+ .token("allow-me").tokenSignature(unregistered)), InvalidRequestException.class, 400, message);
+ }
+
+ @Test
+ @DisplayName("test-invoke with signature and token in the MQTT username verifies them and sends the token")
+ void testInvokeSignedMqttUsername() throws GeneralSecurityException {
+ String token = "shape:ti-signed-mqtt";
+ String username = signedUsername(sign(key1.getPrivate(), token), token);
+ assertShapeOk(iot.testInvokeAuthorizer(r -> r.authorizerName(signedAuthorizer)
+ .mqttContext(m -> m.clientId(clientId).username(username))));
+ }
+
+ // ---------------------------------------------------------------------------------------------
+ // MQTT CONNECT over WebSocket
+ // ---------------------------------------------------------------------------------------------
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("an allowed CONNECT succeeds and publish/subscribe round-trips")
+ void mqttAllowRoundTrip(Mqtt version) throws Exception {
+ String topic = prefix + "/rt/" + version.name().toLowerCase();
+ String payload = "hello-" + version.name();
+ try (Session session = open(version, target(namedUsername(authorizer), "allow-me"))) {
+ assertThat(session.roundTrip(topic, payload)).isEqualTo(payload);
+ }
+ }
+
+ enum Refusal {
+ DENY("deny", AuthorizerKind.ACTIVE, false),
+ CLIENT_ID_NOT_IN_POLICY("allow-me", AuthorizerKind.ACTIVE, true),
+ LAMBDA_RAISES("raise", AuthorizerKind.ACTIVE, false),
+ GARBAGE_RESPONSE("garbage", AuthorizerKind.ACTIVE, false),
+ EMPTY_POLICIES("emptypol", AuthorizerKind.ACTIVE, false),
+ REFRESH_BELOW_RANGE("ttl:299:3600", AuthorizerKind.ACTIVE, false),
+ DISCONNECT_ABOVE_RANGE("ttl:300:86401", AuthorizerKind.ACTIVE, false),
+ UNKNOWN_AUTHORIZER("allow-me", AuthorizerKind.UNKNOWN, false),
+ INACTIVE_AUTHORIZER("allow-me", AuthorizerKind.INACTIVE, false);
+
+ final String secret;
+ final AuthorizerKind authorizer;
+ final boolean otherClient;
+
+ Refusal(String secret, AuthorizerKind authorizer, boolean otherClient) {
+ this.secret = secret;
+ this.authorizer = authorizer;
+ this.otherClient = otherClient;
+ }
+ }
+
+ enum AuthorizerKind { ACTIVE, UNKNOWN, INACTIVE }
+
+ static Stream<Arguments> refusals() {
+ List<Arguments> cases = new ArrayList<>();
+ for (Mqtt version : Mqtt.values()) {
+ for (Refusal refusal : Refusal.values()) {
+ cases.add(Arguments.of(version, refusal));
+ }
+ }
+ return cases.stream();
+ }
+
+ @ParameterizedTest(name = "{0} {1}")
+ @MethodSource("refusals")
+ @DisplayName("a CONNECT the authorizer does not allow is refused")
+ void mqttRefused(Mqtt version, Refusal refusal) {
+ String name = switch (refusal.authorizer) {
+ case ACTIVE -> authorizer;
+ case UNKNOWN -> unknownAuthorizer;
+ case INACTIVE -> inactiveAuthorizer;
+ };
+ String client = refusal.otherClient ? otherClientId : clientId;
+ assertRefused(version, new Target(mqttUri, client, client + "?" + NAME_PARAM + name,
+ refusal.secret.getBytes(StandardCharsets.UTF_8), Map.of()));
+ }
+
+ static Stream<Arguments> acceptedForms() {
+ List<Arguments> cases = new ArrayList<>();
+ for (Mqtt version : Mqtt.values()) {
+ for (String secret : List.of("objpolicy", "ttl:-:-", "ttl:300:86400")) {
+ cases.add(Arguments.of(version, secret));
+ }
+ }
+ return cases.stream();
+ }
+
+ @ParameterizedTest(name = "{0} {1}")
+ @MethodSource("acceptedForms")
+ @DisplayName("an object-form policy, omitted TTLs and boundary TTLs are accepted on a real CONNECT")
+ void mqttAcceptedForms(Mqtt version, String secret) throws Exception {
+ assertConnects(version, target(namedUsername(authorizer), secret));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("the authorizer name is read from the WebSocket URL query")
+ void mqttNameInWebSocketQuery(Mqtt version) throws Exception {
+ assertConnects(version, new Target(mqttUri + "?" + NAME_PARAM + authorizer, clientId, clientId,
+ "allow-me".getBytes(StandardCharsets.UTF_8), Map.of()));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("the authorizer name is read from the WebSocket upgrade header")
+ void mqttNameInUpgradeHeader(Mqtt version) throws Exception {
+ assertConnects(version, new Target(mqttUri, clientId, clientId,
+ "allow-me".getBytes(StandardCharsets.UTF_8), Map.of(NAME_HEADER, authorizer)));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("WebSocket event: name in the username, empty query, lower-case headers")
+ void mqttEventShapeNameInUsername(Mqtt version) throws Exception {
+ assertConnects(version, target(namedUsername(authorizer), "shape:ws-user"));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("WebSocket event: name in the URL query, query string without '?', plain username")
+ void mqttEventShapeNameInQuery(Mqtt version) throws Exception {
+ assertConnects(version, new Target(mqttUri + "?" + NAME_PARAM + authorizer, clientId, clientId,
+ "shape:ws-query".getBytes(StandardCharsets.UTF_8), Map.of()));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("WebSocket event: name in the upgrade header, lower-cased among the headers")
+ void mqttEventShapeNameInHeader(Mqtt version) throws Exception {
+ assertConnects(version, new Target(mqttUri, clientId, clientId,
+ "shape:ws-header".getBytes(StandardCharsets.UTF_8), Map.of(NAME_HEADER, authorizer)));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("a signed authorizer accepts a valid signature and token in the username")
+ void mqttSignedAllow(Mqtt version) throws Exception {
+ String username = signedUsername(sign(key1.getPrivate(), "allow-me"), "allow-me");
+ assertConnects(version, new Target(mqttUri, clientId, username, null, Map.of()));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("a signed CONNECT sends the token with signatureVerified true")
+ void mqttSignedEventShape(Mqtt version) throws Exception {
+ String token = "shape:ws-signed";
+ String username = signedUsername(sign(key2.getPrivate(), token), token);
+ assertConnects(version, new Target(mqttUri, clientId, username, null, Map.of()));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @EnumSource(Mqtt.class)
+ @DisplayName("a signed authorizer refuses a signature over another token")
+ void mqttSignedWrongSignature(Mqtt version) throws GeneralSecurityException {
+ String username = signedUsername(sign(key1.getPrivate(), "other-token"), "allow-me");
+ assertRefused(version, new Target(mqttUri, clientId, username, null, Map.of()));
+ }
+
+ // ---------------------------------------------------------------------------------------------
+ // Fixtures
+ // ---------------------------------------------------------------------------------------------
+
+ private String createRole() {
+ String trust = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\","
+ + "\"Principal\":{\"Service\":\"lambda.amazonaws.com\"},\"Action\":\"sts:AssumeRole\"}]}";
+ String roleArn = iam.createRole(r -> r.roleName(roleName).assumeRolePolicyDocument(trust)
+ .description("floci compatibility test, IoT custom authorizer")).role().arn();
+ roleCreated = true;
+ String logsPolicy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":"
+ + "[\"logs:CreateLogStream\",\"logs:PutLogEvents\"],\"Resource\":\"*\"}]}";
+ iam.putRolePolicy(r -> r.roleName(roleName).policyName(rolePolicyName).policyDocument(logsPolicy));
+ return roleArn;
+ }
+
+ private String createFunction(String roleArn, String arnPrefix) throws InterruptedException {
+ Map<String, String> environment = new LinkedHashMap<>();
+ environment.put("ALLOW_POLICY", allowPolicy);
+ environment.put("IOT_ARN_PREFIX", arnPrefix);
+ environment.put("ALLOWED_CLIENT_ID", clientId);
+ environment.put("NAME_PREFIX", prefix);
+ environment.put("SHAPE_SERVER_NAME", SHAPE_SERVER_NAME);
+ SdkBytes zip = SdkBytes.fromByteArray(zip("lambda_function.py", LAMBDA_SOURCE));
+ // The role may write to this group but not create one, so a late log delivery after the
+ // tear-down cannot re-create it.
+ logs.createLogGroup(r -> r.logGroupName("/aws/lambda/" + functionName));
+ logGroupCreated = true;
+
+ String functionArn = null;
+ long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(90);
+ while (functionArn == null) {
+ try {
+ functionArn = lambda.createFunction(r -> r.functionName(functionName)
+ .runtime(Runtime.PYTHON3_12)
+ .role(roleArn)
+ .handler("lambda_function.handler")
+ .timeout(10)
+ .memorySize(128)
+ .environment(e -> e.variables(environment))
+ .code(c -> c.zipFile(zip))).functionArn();
+ } catch (InvalidParameterValueException e) {
+ if (System.nanoTime() > deadline || !e.getMessage().contains("cannot be assumed")) {
+ throw e;
+ }
+ LOG.infov("waiting for the IAM role to become assumable: {0}", e.awsErrorDetails().errorMessage());
+ Thread.sleep(3000);
+ }
+ }
+ functionCreated = true;
+
+ long activeDeadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(90);
+ while (lambda.getFunctionConfiguration(r -> r.functionName(functionName)).state() != State.ACTIVE) {
+ if (System.nanoTime() > activeDeadline) {
+ throw new IllegalStateException("function " + functionName + " did not become Active");
+ }
+ Thread.sleep(1000);
+ }
+ return functionArn;
+ }
+
+ private void createAuthorizer(String name, String functionArn, AuthorizerStatus status, boolean signed)
+ throws GeneralSecurityException {
+ Map<String, String> keys = new LinkedHashMap<>();
+ keys.put("k1", pem(key1.getPublic()));
+ keys.put("k2", pem(key2.getPublic()));
+ String authorizerArn = iot.createAuthorizer(r -> {
+ r.authorizerName(name).authorizerFunctionArn(functionArn).status(status);
+ if (signed) {
+ r.signingDisabled(false).tokenKeyName(TOKEN_KEY_NAME).tokenSigningPublicKeys(keys);
+ } else {
+ r.signingDisabled(true);
+ }
+ }).authorizerArn();
+ createdAuthorizers.add(name);
+ lambda.addPermission(r -> r.functionName(functionName)
+ .statementId(name + "-invoke")
+ .action("lambda:InvokeFunction")
+ .principal("iot.amazonaws.com")
+ .sourceArn(authorizerArn));
+ }
+
+ /**
+ * Right after creation AWS IoT sporadically refuses a valid CONNECT through a new authorizer without invoking
+ * the Lambda. Wait for three consecutive allowed CONNECTs through each ACTIVE authorizer before the tests
+ * start. Not getting there is left to the tests to report.
+ */
+ private void awaitAuthorizerReady() throws InterruptedException {
+ long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(90);
+ int consecutive = 0;
+ int attempt = 0;
+ while (consecutive < 3 && System.nanoTime() < deadline) {
+ attempt++;
+ boolean ok = connects(target(namedUsername(authorizer), "allow-me"))
+ && connects(new Target(mqttUri, clientId, signedUsername(signOrFail("allow-me"), "allow-me"),
+ null, Map.of()));
+ consecutive = ok ? consecutive + 1 : 0;
+ if (!ok) {
+ Thread.sleep(2000);
+ }
+ }
+ LOG.infov("authorizers ready={0} after {1} round(s)", consecutive >= 3, attempt);
+ }
+
+ private boolean connects(Target target) throws InterruptedException {
+ try (Session ignored = open(Mqtt.V3_1_1, target)) {
+ return true;
+ } catch (ConnectRefused | GeneralSecurityException e) {
+ LOG.infov("not ready: {0}", e.toString());
+ return false;
+ }
+ }
+
+ private String signOrFail(String token) {
+ try {
+ return sign(key1.getPrivate(), token);
+ } catch (GeneralSecurityException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private String mqttBaseUri() {
+ if (TestFixtures.isRealAws()) {
+ String host = iot.describeEndpoint(r -> r.endpointType("iot:Data-ATS")).endpointAddress();
+ return "wss://" + host + ":443/mqtt";
+ }
+ URI endpoint = TestFixtures.endpoint();
+ boolean secure = "https".equalsIgnoreCase(endpoint.getScheme());
+ int port = endpoint.getPort() != -1 ? endpoint.getPort() : secure ? 443 : 80;
+ return (secure ? "wss://" : "ws://") + endpoint.getHost() + ":" + port + "/mqtt";
+ }
+
+ // ---------------------------------------------------------------------------------------------
+ // Helpers
+ // ---------------------------------------------------------------------------------------------
+
+ private TestInvokeAuthorizerResponse invokeMqtt(String name, String secret) {
+ return iot.testInvokeAuthorizer(TestInvokeAuthorizerRequest.builder()
+ .authorizerName(name)
+ .mqttContext(m -> m.clientId(clientId)
+ .username(clientId + "?" + NAME_PARAM + name)
+ .password(SdkBytes.fromUtf8String(secret)))
+ .build());
+ }
+
+ private static void assertShapeOk(TestInvokeAuthorizerResponse response) {
+ assertThat(response.principalId())
+ .as("the Lambda reports shapebad when the event differs from the AWS shape (see its log)")
+ .isEqualTo("shapeok");
+ assertThat(response.isAuthenticated()).isTrue();
+ }
+
+ private static <T extends AwsServiceException> void assertAwsError(ThrowingCallable call, Class<T> type,
+ int status, String message) {
+ assertThatThrownBy(call).isInstanceOfSatisfying(type, e -> {
+ assertThat(e.statusCode()).isEqualTo(status);
+ assertThat(e.awsErrorDetails().errorMessage()).isEqualTo(message);
+ });
+ }
+
+ private String namedUsername(String name) {
+ return clientId + "?" + NAME_PARAM + name;
+ }
+
+ private String signedUsername(String signature, String token) {
+ return clientId + "?" + NAME_PARAM + signedAuthorizer
+ + "&" + SIGNATURE_PARAM + URLEncoder.encode(signature, StandardCharsets.UTF_8)
+ + "&" + TOKEN_KEY_NAME + "=" + token;
+ }
+
+ private Target target(String username, String secret) {
+ return new Target(mqttUri, clientId, username, secret.getBytes(StandardCharsets.UTF_8), Map.of());
+ }
+
+ private static String sign(PrivateKey key, String token) throws GeneralSecurityException {
+ Signature signature = Signature.getInstance("SHA256withRSA");
+ signature.initSign(key);
+ signature.update(token.getBytes(StandardCharsets.UTF_8));
+ return Base64.getEncoder().encodeToString(signature.sign());
+ }
+
+ private static String pem(PublicKey key) {
+ String body = Base64.getMimeEncoder(64, new byte[] {'\n'}).encodeToString(key.getEncoded());
+ return "-----BEGIN PUBLIC KEY-----\n" + body + "\n-----END PUBLIC KEY-----";
+ }
+
+ private static byte[] zip(String entryName, String content) {
+ try {
+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+ try (ZipOutputStream zip = new ZipOutputStream(bytes)) {
+ zip.putNextEntry(new ZipEntry(entryName));
+ zip.write(content.getBytes(StandardCharsets.UTF_8));
+ zip.closeEntry();
+ }
+ return bytes.toByteArray();
+ } catch (IOException e) {
+ throw new IllegalStateException("cannot build the Lambda deployment package", e);
+ }
+ }
+
+ private static void quietly(String what, Runnable action) {
+ try {
+ action.run();
+ } catch (RuntimeException e) {
+ LOG.warnv("cleanup step failed: {0}: {1}", what, e.toString());
+ }
+ }
+
+ // ---------------------------------------------------------------------------------------------
+ // MQTT clients
+ // ---------------------------------------------------------------------------------------------
+
+ private record Target(String uri, String clientId, String username, byte[] password,
+ Map<String, String> headers) {}
+
+ private interface Session extends AutoCloseable {
+ String roundTrip(String topic, String payload) throws Exception;
+
+ @Override
+ void close();
+ }
+
+ /** A refused CONNECT, carrying the client's own exception as the cause. */
+ private static final class ConnectRefused extends Exception {
+ ConnectRefused(Throwable cause) {
+ super("CONNECT failed: " + cause, cause);
+ }
+ }
+
+ private void assertConnects(Mqtt version, Target target) throws Exception {
+ try (Session ignored = open(version, target)) {
+ LOG.infov("{0} connected as {1}", version, target.username());
+ }
+ }
+
+ private void assertRefused(Mqtt version, Target target) {
+ Throwable thrown = catchThrowable(() -> open(version, target).close());
+ if (!(thrown instanceof ConnectRefused refused)) {
+ fail("expected the CONNECT to be refused, got " + thrown);
+ return;
+ }
+ Throwable cause = refused.getCause();
+ LOG.infov("{0} refused: {1} cause={2}", version, cause, cause.getCause());
+ if (version == Mqtt.V3_1_1) {
+ assertThat(cause).isInstanceOfSatisfying(MqttException.class,
+ e -> assertThat(e.getReasonCode()).isEqualTo(MQTT3_REFUSAL_REASON_CODE));
+ } else {
+ assertThat(cause).isInstanceOfSatisfying(org.eclipse.paho.mqttv5.common.MqttException.class,
+ e -> assertThat(e.getReasonCode()).isEqualTo(MQTT5_NOT_AUTHORIZED));
+ }
+ }
+
+ private Session open(Mqtt version, Target target)
+ throws ConnectRefused, GeneralSecurityException, InterruptedException {
+ Long last = lastConnectNanos.get(target.clientId());
+ if (last != null) {
+ long waitNanos = last + CONNECT_SPACING_NANOS - System.nanoTime();
+ if (waitNanos > 0) {
+ TimeUnit.NANOSECONDS.sleep(waitNanos);
+ }
+ }
+ lastConnectNanos.put(target.clientId(), System.nanoTime());
+ return version == Mqtt.V3_1_1 ? openV3(target) : openV5(target);
+ }
+
+ private Session openV3(Target target) throws ConnectRefused, GeneralSecurityException {
+ MqttClient client;
+ try {
+ client = new MqttClient(target.uri(), target.clientId(), new MemoryPersistence());
+ } catch (MqttException e) {
+ throw new IllegalStateException(e);
+ }
+ MqttConnectOptions options = new MqttConnectOptions();
+ options.setMqttVersion(MqttConnectOptions.MQTT_VERSION_3_1_1);
+ options.setCleanSession(true);
+ options.setAutomaticReconnect(false);
+ options.setConnectionTimeout(TIMEOUT_SECONDS);
+ options.setKeepAliveInterval(30);
+ if (target.username() != null) {
+ options.setUserName(target.username());
+ }
+ if (target.password() != null) {
+ options.setPassword(new String(target.password(), StandardCharsets.UTF_8).toCharArray());
+ }
+ if (!target.headers().isEmpty()) {
+ Properties headers = new Properties();
+ headers.putAll(target.headers());
+ options.setCustomWebSocketHeaders(headers);
+ }
+ if (needsEmulatorTls(target)) {
+ options.setSocketFactory(emulatorSocketFactory());
+ options.setHttpsHostnameVerificationEnabled(false);
+ }
+ try {
+ client.connect(options);
+ } catch (MqttException e) {
+ closeV3(client);
+ throw new ConnectRefused(e);
+ }
+ return new Session() {
+ @Override
+ public String roundTrip(String topic, String payload) throws Exception {
+ CompletableFuture<String> received = new CompletableFuture<>();
+ client.subscribe(topic, 1, (t, message) ->
+ received.complete(new String(message.getPayload(), StandardCharsets.UTF_8)));
+ client.publish(topic, payload.getBytes(StandardCharsets.UTF_8), 1, false);
+ return received.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
+ }
+
+ @Override
+ public void close() {
+ closeV3(client);
+ }
+ };
+ }
+
+ private static void closeV3(MqttClient client) {
+ try {
+ if (client.isConnected()) {
+ client.disconnect(5000);
+ }
+ } catch (MqttException e) {
+ LOG.debugv("MQTT 3.1.1 disconnect failed: {0}", e.toString());
+ }
+ try {
+ client.close();
+ } catch (MqttException e) {
+ LOG.debugv("MQTT 3.1.1 close failed: {0}", e.toString());
+ }
+ }
+
+ private Session openV5(Target target) throws ConnectRefused, GeneralSecurityException {
+ MqttAsyncClient client;
+ try {
+ client = new MqttAsyncClient(target.uri(), target.clientId(),
+ new org.eclipse.paho.mqttv5.client.persist.MemoryPersistence());
+ } catch (org.eclipse.paho.mqttv5.common.MqttException e) {
+ throw new IllegalStateException(e);
+ }
+ BlockingQueue<String> messages = new LinkedBlockingQueue<>();
+ client.setCallback(new MessageCallback(message -> messages.add(message)));
+ MqttConnectionOptions options = new MqttConnectionOptions();
+ options.setCleanStart(true);
+ options.setAutomaticReconnect(false);
+ options.setConnectionTimeout(TIMEOUT_SECONDS);
+ options.setKeepAliveInterval(30);
+ if (target.username() != null) {
+ options.setUserName(target.username());
+ }
+ if (target.password() != null) {
+ options.setPassword(target.password());
+ }
+ if (!target.headers().isEmpty()) {
+ options.setCustomWebSocketHeaders(target.headers());
+ }
+ if (needsEmulatorTls(target)) {
+ options.setSocketFactory(emulatorSocketFactory());
+ options.setHttpsHostnameVerificationEnabled(false);
+ }
+ try {
+ client.connect(options).waitForCompletion(TimeUnit.SECONDS.toMillis(TIMEOUT_SECONDS));
+ } catch (org.eclipse.paho.mqttv5.common.MqttException e) {
+ closeV5(client);
+ throw new ConnectRefused(e);
+ }
+ if (!client.isConnected()) {
+ closeV5(client);
+ throw new ConnectRefused(new IllegalStateException("CONNECT did not complete"));
+ }
+ return new Session() {
+ @Override
+ public String roundTrip(String topic, String payload) throws Exception {
+ client.subscribe(topic, 1).waitForCompletion(TimeUnit.SECONDS.toMillis(TIMEOUT_SECONDS));
+ client.publish(topic, payload.getBytes(StandardCharsets.UTF_8), 1, false)
+ .waitForCompletion(TimeUnit.SECONDS.toMillis(TIMEOUT_SECONDS));
+ return messages.poll(TIMEOUT_SECONDS, TimeUnit.SECONDS);
+ }
+
+ @Override
+ public void close() {
+ closeV5(client);
+ }
+ };
+ }
+
+ private static void closeV5(MqttAsyncClient client) {
+ try {
+ if (client.isConnected()) {
+ client.disconnect().waitForCompletion(5000);
+ }
+ } catch (org.eclipse.paho.mqttv5.common.MqttException e) {
+ LOG.debugv("MQTT 5 disconnect failed: {0}", e.toString());
+ }
+ try {
+ client.close();
+ } catch (org.eclipse.paho.mqttv5.common.MqttException e) {
+ LOG.debugv("MQTT 5 close failed: {0}", e.toString());
+ }
+ }
+
+ private static final class MessageCallback implements MqttCallback {
+ private final Consumer<String> sink;
+
+ MessageCallback(Consumer<String> sink) {
+ this.sink = sink;
+ }
+
+ @Override
+ public void disconnected(MqttDisconnectResponse response) {
+ LOG.debugv("MQTT 5 disconnected: {0}", response);
+ }
+
+ @Override
+ public void mqttErrorOccurred(org.eclipse.paho.mqttv5.common.MqttException exception) {
+ LOG.debugv("MQTT 5 error: {0}", exception.toString());
+ }
+
+ @Override
+ public void messageArrived(String topic, MqttMessage message) {
+ sink.accept(new String(message.getPayload(), StandardCharsets.UTF_8));
+ }
+
+ @Override
+ public void deliveryComplete(IMqttToken token) {
+ }
+
+ @Override
+ public void connectComplete(boolean reconnect, String serverUri) {
+ }
+
+ @Override
+ public void authPacketArrived(int reasonCode, MqttProperties properties) {
+ }
+ }
+
+ private static boolean needsEmulatorTls(Target target) {
+ return !TestFixtures.isRealAws() && target.uri().startsWith("wss://");
+ }
+
+ /** Floci's local TLS endpoint uses a test CA, so the emulator-only WebSocket trusts it like emulatorHttpClient. */
+ private static SSLSocketFactory emulatorSocketFactory() throws GeneralSecurityException {
+ X509TrustManager trustAll = new X509TrustManager() {
+ @Override
+ public void checkClientTrusted(X509Certificate[] chain, String authType) {
+ }
+
+ @Override
+ public void checkServerTrusted(X509Certificate[] chain, String authType) {
+ }
+
+ @Override
+ public X509Certificate[] getAcceptedIssuers() {
+ return new X509Certificate[0];
+ }
+ };
+ SSLContext context = SSLContext.getInstance("TLS");
+ context.init(null, new TrustManager[] {trustAll}, new SecureRandom());
+ return context.getSocketFactory();
+ }
+}
diff --git a/docs/services/index.md b/docs/services/index.md
index 9ddb0ed5f7..bbd98874c8 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -142,7 +142,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac
| [BCM Data Exports](bcm-data-exports.md) | `POST /` + `X-Amz-Target: AWSBillingAndCostManagementDataExports.*` | JSON 1.1 | 7 |
| [Transfer Family](transfer.md) | `POST /` + `X-Amz-Target: TransferService.*` | JSON 1.1 | 17 |
| [DataSync](datasync.md) | `POST /` + `X-Amz-Target: FmrsService.*` | JSON 1.1 | 48 |
-| [IoT Core](iot.md) | `/things/...`, `/endpoint`, rules/policies REST paths | REST JSON | 70 |
+| [IoT Core](iot.md) | `/things/...`, `/endpoint`, rules/policies REST paths | REST JSON | 71 |
| [IoT Data](iot.md) | `/things/{thingName}/shadow`, MQTT topics | REST JSON | 11 |
**Lambda, ElastiCache, RDS, MSK, MWAA, ECS, EKS, and OpenSearch** spin up real Docker containers and support IAM authentication and SigV4 request signing, the same auth flow as production AWS. **RDS Data API** executes SQL against the local RDS containers through AWS-compatible REST JSON routes.
diff --git a/docs/services/iot.md b/docs/services/iot.md
index c67973142f..2b1fe5c255 100644
--- a/docs/services/iot.md
+++ b/docs/services/iot.md
@@ -69,11 +69,11 @@ Current limitations:
## Authorizers
-Status: control plane only.
+Status: control plane, `TestInvokeAuthorizer` and MQTT `CONNECT` enforcement.
-`CreateAuthorizer`, `DescribeAuthorizer`, `UpdateAuthorizer`, `DeleteAuthorizer`, `ListAuthorizers`, `SetDefaultAuthorizer`, `DescribeDefaultAuthorizer` and `ClearDefaultAuthorizer` are served on the REST-JSON paths the AWS SDKs use, with the shapes, error codes and messages measured against AWS:
+`CreateAuthorizer`, `DescribeAuthorizer`, `UpdateAuthorizer`, `DeleteAuthorizer`, `ListAuthorizers`, `SetDefaultAuthorizer`, `DescribeDefaultAuthorizer`, `ClearDefaultAuthorizer` and `TestInvokeAuthorizer` are served on the REST-JSON paths the AWS SDKs use, with the shapes, error codes and messages measured against AWS:
-- A new authorizer is `INACTIVE` with HTTP caching off unless the request says otherwise. Unless `signingDisabled` is `true`, it needs a `tokenKeyName` and one or two RSA-2048 public keys in PEM form; a signing-disabled authorizer takes no keys. The function ARN is checked for ARN syntax only and is never resolved.
+- A new authorizer is `INACTIVE` with HTTP caching off unless the request says otherwise. Unless `signingDisabled` is `true`, it needs a `tokenKeyName` and one or two RSA-2048 public keys in PEM form; a signing-disabled authorizer takes no keys. The function ARN is checked for ARN syntax only; the function is resolved when it is invoked.
- `DescribeAuthorizer` returns every member; an unset token key name or key map is JSON `null`, and tags are not shown.
- `UpdateAuthorizer` changes only the members sent and merges signing keys by key name, refusing a third key. Any member sent moves `lastModifiedDate`; an empty body does not.
- `DeleteAuthorizer` refuses an `ACTIVE` authorizer (`InvalidRequestException`) and the default authorizer (`DeleteConflictException`).
@@ -82,9 +82,25 @@ Status: control plane only.
- Tags work through `TagResource`, `UntagResource` and `ListTagsForResource` on the authorizer ARN.
- CloudFormation provisions `AWS::IoT::Authorizer`: `Ref` is the name and `Fn::GetAtt Arn` the ARN.
+The function is invoked synchronously with the event AWS IoT sends (`protocolData`, `protocols`, `token` for a signed authorizer, `signatureVerified`, `connectionMetadata`), and its answer is checked as AWS checks it: `isAuthenticated`, a `principalId` of 1 to 128 letters and digits, at most 10 `policyDocuments` of at most 2048 characters each that parse as JSON objects, and TTLs from 300 to 86400 seconds. Omitted TTLs become 300 (`refreshAfterInSeconds`) and 86400 (`disconnectAfterInSeconds`), and a policy returned as a JSON object becomes one compact string. A signed authorizer verifies the token's SHA256withRSA signature against each of its keys before the function is invoked.
+
+- `TestInvokeAuthorizer` works on `ACTIVE` and `INACTIVE` authorizers. It returns the request errors (`InvalidRequestException`) and answer errors (`InvalidResponseException`) with AWS's messages, and passes the contexts on as given: header case is kept and `queryString` keeps its leading `?`.
+- An MQTT `CONNECT` on the plaintext listener or on [MQTT over WebSocket](#mqtt-over-websocket) that names an authorizer, in the username (`<clientId>?x-amz-customauthorizer-name=<name>`), the WebSocket URL query or the `x-amz-customauthorizer-name` upgrade header, is admitted only when the authorizer exists and is `ACTIVE`, the signature verifies for a signed authorizer, the answer is valid, `isAuthenticated` is `true`, and the returned policies allow `iot:Connect` on `arn:aws:iot:<region>:<account>:client/<clientId>`. The event carries the username with its query, the password in base64, and for WebSocket the lower-cased upgrade headers, the query string without `?` and, over TLS, the server name.
+- A refused MQTT 3.1.1 client is disconnected without a `CONNACK`; an MQTT 5 client gets `CONNACK` reason code `0x87` with the reason string AWS sends, then the connection closes. A `CONNECT` that names no authorizer is handled as before.
+
Current limitations:
-- Authorizers are not evaluated: no connection or HTTP publish invokes the function, and `TestInvokeAuthorizer` is not served (see [MQTT over WebSocket](#mqtt-over-websocket)).
+- The default authorizer is not used: a `CONNECT` that names no authorizer is not authenticated.
+- HTTPS publish does not invoke authorizers, and `enableCachingForHttp` has no effect.
+- `refreshAfterInSeconds` and `disconnectAfterInSeconds` are returned but do not schedule a re-invocation or a disconnect.
+- The returned policies decide `iot:Connect` only; publish, subscribe and receive are not checked against them.
+- The function's resource policy is not checked, so `AddPermission` for `iot.amazonaws.com` is not required.
+- A WebSocket upgrade without the `mqtt` subprotocol is not answered with AWS's 426.
+- A refused WebSocket client sees a close frame with status `1000`. AWS sends an empty close frame to an MQTT 3.1.1 client and closes the connection without a close frame after the MQTT 5 `CONNACK`.
+- An accepting MQTT 5 `CONNACK` carries no properties.
+- The MQTT over TLS listener (8883) authenticates by device certificate only.
+- On a connection, the authorizer is looked up in Floci's default account and region.
+- The MQTT password reaches the function as the broker decodes it, as UTF-8 text, so password bytes that are not valid UTF-8 arrive altered. The broker library, Vert.x MQTT, exposes the password only as a string.
## MQTT Broker
@@ -99,7 +115,7 @@ Broker scope:
- Support QoS 0 and QoS 1 publish/subscribe behavior for the local AWS IoT slice.
- Accept PUBLISH payloads up to 128 KB on 1883, 8883 and `/mqtt`, the AWS IoT Core quota (packets up to 146 KB including the variable header). A larger publish disconnects the client without acknowledgement, delivery or rule evaluation, as on AWS.
- Serve MQTT over TLS on 8883 next to plaintext 1883 when TLS is enabled, and verify the device certificate and its `iot:Connect` permission there.
-- Keep the plaintext listener permissive; topic-level authorization (`Publish`, `Subscribe`, `Receive`) is follow-up scope.
+- Keep the plaintext listener permissive except for a `CONNECT` that names a [custom authorizer](#authorizers); topic-level authorization (`Publish`, `Subscribe`, `Receive`) is follow-up scope.
- Keep MQTT broker logging minimal.
- Validate the relevant IoT compatibility tests against the native binary before considering the phase complete.
@@ -168,8 +184,10 @@ request to `/mqtt` gets the usual 404.
No client certificate is requested on this path. On AWS it authenticates by SigV4 (signed query
string on the upgrade URL) or by a custom authorizer (`<clientId>?x-amz-customauthorizer-name=<name>`
-as the MQTT username with a token as the password); Floci accepts such a CONNECT as is and does
-not evaluate the signature or the authorizer yet.
+as the MQTT username with a token as the password). Floci enforces a custom authorizer named in the
+username, the URL query or the `x-amz-customauthorizer-name` upgrade header, see
+[Authorizers](#authorizers); it does not verify a SigV4 signature, and a CONNECT that names no
+authorizer is accepted as is.
## Reserved Topics
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.java
index 930458b68b..d519745bed 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.java
@@ -1,8 +1,10 @@
package io.github.hectorvent.floci.services.iot;
import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectReader;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.hectorvent.floci.core.common.AwsException;
@@ -26,7 +28,8 @@ import jakarta.ws.rs.core.Response;
/**
* REST-JSON routes for AWS IoT custom authorizers: CreateAuthorizer, DescribeAuthorizer,
* UpdateAuthorizer, DeleteAuthorizer, ListAuthorizers, SetDefaultAuthorizer,
- * DescribeDefaultAuthorizer and ClearDefaultAuthorizer, on the paths and shapes the AWS SDKs use.
+ * DescribeDefaultAuthorizer, ClearDefaultAuthorizer and TestInvokeAuthorizer, on the paths and
+ * shapes the AWS SDKs use.
*/
@Path("/")
@Produces(MediaType.APPLICATION_JSON)
@@ -34,15 +37,19 @@ import jakarta.ws.rs.core.Response;
public class IotAuthorizerController {
private final IotAuthorizerService authorizerService;
+ private final IotCustomAuthorizer customAuthorizer;
private final RegionResolver regionResolver;
private final ObjectMapper objectMapper;
+ private final ObjectReader strictReader;
@Inject
- public IotAuthorizerController(IotAuthorizerService authorizerService, RegionResolver regionResolver,
- ObjectMapper objectMapper) {
+ public IotAuthorizerController(IotAuthorizerService authorizerService, IotCustomAuthorizer customAuthorizer,
+ RegionResolver regionResolver, ObjectMapper objectMapper) {
this.authorizerService = authorizerService;
+ this.customAuthorizer = customAuthorizer;
this.regionResolver = regionResolver;
this.objectMapper = objectMapper;
+ this.strictReader = objectMapper.reader().with(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);
}
@POST
@@ -75,6 +82,14 @@ public class IotAuthorizerController {
return Response.ok(objectMapper.createObjectNode()).build();
}
+ @POST
+ @Path("/authorizer/{authorizerName}/test")
+ public Response testInvokeAuthorizer(@Context HttpHeaders headers, @PathParam("authorizerName") String authorizerName,
+ String body) {
+ return Response.ok(customAuthorizer.testInvoke(authorizerName, readJson(body), regionResolver.resolveRegion(headers)))
+ .build();
+ }
+
@GET
@Path("/authorizers")
public Response listAuthorizers(@Context HttpHeaders headers,
@@ -138,7 +153,7 @@ public class IotAuthorizerController {
private JsonNode readJson(String body) {
try {
- return objectMapper.readTree(body == null || body.isBlank() ? "{}" : body);
+ return strictReader.readTree(body == null || body.isBlank() ? "{}" : body);
} catch (JsonProcessingException e) {
throw new AwsException("InvalidRequestException", e.getMessage(), 400);
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerService.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerService.java
index 50fd374997..295e90f02f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerService.java
@@ -31,8 +31,8 @@ import java.util.stream.Collectors;
/**
* AWS IoT Core custom authorizers: the records CreateAuthorizer and its peers manage, and the
- * account's default authorizer. The function ARN is checked for ARN syntax only, as on AWS; nothing
- * here invokes the function or gates a connection.
+ * account's default authorizer. The function ARN is checked for ARN syntax only, as on AWS;
+ * {@link IotCustomAuthorizer} invokes the function.
*/
@ApplicationScoped
public class IotAuthorizerService {
@@ -333,8 +333,7 @@ public class IotAuthorizerService {
}
RSAPublicKey key;
try {
- byte[] der = Base64.getDecoder().decode(String.join("", rest.subList(0, end)));
- key = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(der));
+ key = rsaPublicKey(pem);
} catch (GeneralSecurityException | IllegalArgumentException e) {
throw invalid("Authorizer " + name + " public key for key name " + keyName + " not a valid RSA key");
}
@@ -345,6 +344,14 @@ public class IotAuthorizerService {
}
}
+ /** The key of a PEM whose header and end lines {@link #requireRsa2048} has checked. */
+ static RSAPublicKey rsaPublicKey(String pem) throws GeneralSecurityException {
+ List<String> lines = pem.lines().toList();
+ List<String> body = lines.subList(lines.indexOf("-----BEGIN PUBLIC KEY-----") + 1, lines.size());
+ byte[] der = Base64.getDecoder().decode(String.join("", body.subList(0, body.indexOf("-----END PUBLIC KEY-----"))));
+ return (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(der));
+ }
+
private static void requireFunctionArn(String name, String functionArn) {
if (AwsArnUtils.resourceIfArnFor(functionArn, "lambda").filter(r -> r.startsWith("function:")).isEmpty()) {
throw invalid("Lambda function arn for authorizer " + name + " is not in proper ARN syntax");
@@ -380,7 +387,7 @@ public class IotAuthorizerService {
Map.of("resourceId", authorizer.getAuthorizerName(), "resourceArn", authorizer.getAuthorizerArn()));
}
- private static AwsException constraint(String field, String constraint) {
+ static AwsException constraint(String field, String constraint) {
return constraints(field, List.of(constraint));
}
@@ -391,7 +398,7 @@ public class IotAuthorizerService {
.collect(Collectors.joining("; ")));
}
- private static AwsException invalid(String message) {
+ static AwsException invalid(String message) {
return new AwsException("InvalidRequestException", message, 400);
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizer.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizer.java
new file mode 100644
index 0000000000..a6c2fb21b3
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizer.java
@@ -0,0 +1,330 @@
+package io.github.hectorvent.floci.services.iot;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectReader;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.MissingNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.services.iot.model.IotAuthorizer;
+import io.github.hectorvent.floci.services.lambda.LambdaService;
+import io.github.hectorvent.floci.services.lambda.model.InvocationType;
+import io.github.hectorvent.floci.services.lambda.model.InvokeResult;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.io.IOException;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.Signature;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.UUID;
+import java.util.regex.Pattern;
+
+/**
+ * AWS IoT custom authentication: the event AWS IoT sends an authorizer's function, the invocation,
+ * and the checks AWS makes on the function's answer, in AWS's order and wording. TestInvokeAuthorizer
+ * and the MQTT CONNECT on the broker's plaintext listener, which the WebSocket bridge lands on, share
+ * it.
+ */
+@ApplicationScoped
+public class IotCustomAuthorizer {
+
+ private static final Logger LOG = Logger.getLogger(IotCustomAuthorizer.class);
+ static final String NAME_PARAM = "x-amz-customauthorizer-name";
+ static final String SIGNATURE_PARAM = "x-amz-customauthorizer-signature";
+ private static final Pattern BASE64 = Pattern.compile("[A-Za-z0-9+/]+={0,2}");
+ private static final Pattern PRINCIPAL_ID = Pattern.compile("([a-zA-Z0-9]){1,128}");
+ private static final String POLICIES = "policyDocuments failed to satisfy constraint: ";
+ private static final String TTL_RANGE = " failed to satisfy constraint: Member must be greater than 5 minutes and less than 24 hours.";
+
+ private final IotAuthorizerService authorizers;
+ private final LambdaService lambdaService;
+ private final ObjectMapper objectMapper;
+ private final ObjectReader strictReader;
+ private final RegionResolver regionResolver;
+
+ /**
+ * What a WebSocket upgrade carried: the header names lower-cased, the raw query without its
+ * {@code ?} ({@code ""} when there was none), the server name, null unless it came over TLS, and
+ * the client's IP address, as the broker sees only the bridge's loopback socket.
+ */
+ record WebSocketUpgrade(Map<String, String> headers, String queryString, String serverName, String sourceIp) {
+ }
+
+ @Inject
+ public IotCustomAuthorizer(IotAuthorizerService authorizers, LambdaService lambdaService, ObjectMapper objectMapper,
+ RegionResolver regionResolver) {
+ this.authorizers = authorizers;
+ this.lambdaService = lambdaService;
+ this.objectMapper = objectMapper;
+ this.strictReader = objectMapper.reader().with(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);
+ this.regionResolver = regionResolver;
+ }
+
+ /** TestInvokeAuthorizer: the request checks AWS makes before invoking, then the function's checked answer. */
+ public ObjectNode testInvoke(String name, JsonNode request, String region) {
+ String token = request.path("token").asText(null);
+ String signature = request.path("tokenSignature").asText(null);
+ String queryString = request.path("httpContext").path("queryString").asText(null);
+ if ("".equals(token)) {
+ throw IotAuthorizerService.constraint("token", "Member must have length greater than or equal to 1");
+ }
+ if (token != null && token.length() > 6144) {
+ throw IotAuthorizerService.constraint("token", "Member must have length less than or equal to 6144");
+ }
+ if (signature != null && !BASE64.matcher(signature).matches()) {
+ throw IotAuthorizerService.constraint("tokenSignature", "Member must satisfy regular expression pattern: " + BASE64);
+ }
+ if (signature != null && signature.length() > 2560) {
+ throw IotAuthorizerService.constraint("tokenSignature", "Member must have length less than or equal to 2560");
+ }
+ if ("".equals(queryString)) {
+ throw IotAuthorizerService.constraint("httpContext.queryString", "Member must have length greater than or equal to 1");
+ }
+ IotAuthorizer authorizer = authorizers.describeAuthorizer(name, region);
+ ObjectNode protocolData = objectMapper.createObjectNode();
+ for (String protocol : List.of("tls", "mqtt", "http")) {
+ JsonNode context = request.path(protocol + "Context");
+ if (context.isObject()) {
+ // ponytail: a context goes to the function as sent, members in request order, which SDKs send in model order.
+ // Nested members are not checked against the model's length and type constraints, only those measured above.
+ protocolData.set(protocol, context);
+ }
+ }
+ if ((token == null) != (signature == null)) {
+ throw IotAuthorizerService.invalid("Request must provide both token and tokenSignature together.");
+ }
+ if (token != null) {
+ if (!protocolData.isEmpty()) {
+ throw IotAuthorizerService.invalid("Request cannot have token and Http/Mqtt/Tls context.");
+ }
+ if (authorizer.isSigningDisabled()) {
+ throw IotAuthorizerService.invalid("Token and token signature provided but signing is disabled for the authorizer.");
+ }
+ return invoke(authorizer, event(null, verifiedToken(authorizer, token, signature)));
+ }
+ if (protocolData.isEmpty()) {
+ throw IotAuthorizerService.invalid("Request must have Http/Mqtt/Tls context.");
+ }
+ if (queryString != null && !queryString.startsWith("?")) {
+ throw IotAuthorizerService.invalid("Invalid arguments in the call");
+ }
+ Map<String, String> headers = new LinkedHashMap<>();
+ protocolData.path("http").path("headers").properties().forEach(header -> headers.put(header.getKey(), header.getValue().asText()));
+ Map<String, String> params = params(protocolData.path("mqtt").path("username").asText(null), headers, queryString);
+ return invoke(authorizer, event(protocolData, signedToken(authorizer, params)));
+ }
+
+ /** The authorizer an MQTT CONNECT names in its username query, the WebSocket URL query or an upgrade header; null when none. */
+ static String authorizerName(String username, WebSocketUpgrade upgrade) {
+ return params(username, upgrade).get(NAME_PARAM);
+ }
+
+ /**
+ * The policies an MQTT CONNECT through the named authorizer is admitted with. None when the
+ * authorizer is not ACTIVE, which never invokes the function, or when the function denies or
+ * returns no policy; an {@link AwsException} when the authorizer does not exist, a signature
+ * does not verify (the function is not invoked) or the answer is one TestInvokeAuthorizer rejects.
+ */
+ List<String> connectPolicies(String name, String clientId, String username, String password, WebSocketUpgrade upgrade) {
+ // ponytail: the broker has no request context, so a connection finds authorizers in the default account and region.
+ IotAuthorizer authorizer = authorizers.describeAuthorizer(name, regionResolver.getDefaultRegion());
+ if (!"ACTIVE".equals(authorizer.getStatus())) {
+ return List.of();
+ }
+ ObjectNode protocolData = objectMapper.createObjectNode();
+ if (upgrade != null && upgrade.serverName() != null) {
+ protocolData.putObject("tls").put("serverName", upgrade.serverName());
+ }
+ ObjectNode mqtt = protocolData.putObject("mqtt");
+ if (username != null) {
+ mqtt.put("username", username);
+ }
+ if (password != null) {
+ // ponytail: Vert.x hands the password over as UTF-8 text, so bytes that are not UTF-8 reach the function altered.
+ mqtt.put("password", Base64.getEncoder().encodeToString(password.getBytes(StandardCharsets.UTF_8)));
+ }
+ mqtt.put("clientId", clientId);
+ if (upgrade != null) {
+ ObjectNode http = protocolData.putObject("http");
+ http.set("headers", objectMapper.valueToTree(upgrade.headers()));
+ http.put("queryString", upgrade.queryString());
+ }
+ ObjectNode answer = invoke(authorizer, event(protocolData, signedToken(authorizer, params(username, upgrade))));
+ if (!answer.path("isAuthenticated").booleanValue()) {
+ return List.of();
+ }
+ List<String> policies = new ArrayList<>();
+ answer.path("policyDocuments").forEach(policy -> policies.add(policy.asText()));
+ return policies;
+ }
+
+ private ObjectNode event(ObjectNode protocolData, String token) {
+ ObjectNode event = objectMapper.createObjectNode();
+ if (protocolData != null) {
+ event.set("protocolData", protocolData);
+ ArrayNode protocols = event.putArray("protocols");
+ for (String protocol : List.of("tls", "http", "mqtt")) {
+ if (protocolData.has(protocol)) {
+ protocols.add(protocol);
+ }
+ }
+ }
+ if (token != null) {
+ event.put("token", token);
+ }
+ event.put("signatureVerified", token != null);
+ event.putObject("connectionMetadata").put("id", UUID.randomUUID().toString());
+ return event;
+ }
+
+ /** Invokes the function and checks its answer as AWS does, returning the TestInvokeAuthorizer body. */
+ private ObjectNode invoke(IotAuthorizer authorizer, ObjectNode event) {
+ InvokeResult result = lambdaService.invokeArn(authorizer.getAuthorizerFunctionArn(),
+ event.toString().getBytes(StandardCharsets.UTF_8), InvocationType.RequestResponse);
+ JsonNode answer = readJson(result.getPayload());
+ if (result.getFunctionError() != null) {
+ throw invalidResponse("Lambda function encountered error in execution: " + answer.path("errorMessage").asText()
+ + ": " + answer.path("errorType").asText());
+ }
+ if (!answer.path("isAuthenticated").isBoolean()) {
+ throw invalidResponse("Lambda invocation result is in invalid format");
+ }
+ String principalId = answer.path("principalId").asText(null);
+ if (principalId == null || !PRINCIPAL_ID.matcher(principalId).matches()) {
+ throw invalidResponse(principalId + " at principalId failed to satisfy constraint: Member must satisfy " + PRINCIPAL_ID);
+ }
+ JsonNode policies = answer.path("policyDocuments");
+ if (!policies.isArray()) {
+ throw invalidResponse(POLICIES + "List of policies cannot be null.");
+ }
+ if (policies.size() > 10) {
+ throw invalidResponse(POLICIES + "Number of policies allowed cannot exceed 10");
+ }
+ ArrayNode documents = objectMapper.createArrayNode();
+ for (JsonNode policy : policies) {
+ String document = policy.isTextual() ? policy.asText() : policy.toString();
+ // ponytail: size counts characters and syntax means a JSON object; AWS's exact rules are unmeasured.
+ if (document.length() > 2048) {
+ throw invalidResponse(POLICIES + "Size of a policy document cannot exceeds hard limit of 2048");
+ }
+ if (!readJson(document.getBytes(StandardCharsets.UTF_8)).isObject()) {
+ throw invalidResponse(POLICIES + "Policy document is Malformed: Invalid policy syntax.");
+ }
+ documents.add(document);
+ }
+ int refresh = ttl(answer, "refreshAfterInSeconds", 300);
+ int disconnect = ttl(answer, "disconnectAfterInSeconds", 86400);
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("disconnectAfterInSeconds", disconnect);
+ response.put("isAuthenticated", answer.path("isAuthenticated").booleanValue());
+ response.set("policyDocuments", documents);
+ response.put("principalId", principalId);
+ response.put("refreshAfterInSeconds", refresh);
+ return response;
+ }
+
+ /** A TTL the function returned, or its default; AWS accepts 300 to 86400 inclusive whatever its message says. */
+ private static int ttl(JsonNode answer, String field, int fallback) {
+ JsonNode value = answer.path(field);
+ if (value.isMissingNode() || value.isNull()) {
+ return fallback;
+ }
+ if (!value.canConvertToInt() || value.asInt() < 300 || value.asInt() > 86400) {
+ throw invalidResponse(value.asText() + " at " + field + TTL_RANGE);
+ }
+ return value.asInt();
+ }
+
+ private JsonNode readJson(byte[] json) {
+ try {
+ JsonNode node = strictReader.readTree(json);
+ return node == null ? MissingNode.getInstance() : node;
+ } catch (IOException | IllegalArgumentException ignored) {
+ // Not JSON: the checks that follow report the answer the way AWS does.
+ return MissingNode.getInstance();
+ }
+ }
+
+ /** The verified token of a signed authorizer, or null for one with signing disabled. */
+ private static String signedToken(IotAuthorizer authorizer, Map<String, String> params) {
+ return authorizer.isSigningDisabled() ? null
+ : verifiedToken(authorizer, params.get(authorizer.getTokenKeyName()), params.get(SIGNATURE_PARAM));
+ }
+
+ /** The token, once an SHA256withRSA signature over it verifies against one of the authorizer's keys. */
+ private static String verifiedToken(IotAuthorizer authorizer, String token, String signature) {
+ if (token == null || signature == null) {
+ // AWS answers a signed authorizer without its token or signature with a null message.
+ throw new AwsException("InvalidRequestException", null, 400);
+ }
+ for (String pem : authorizer.getTokenSigningPublicKeys().values()) {
+ try {
+ Signature verifier = Signature.getInstance("SHA256withRSA");
+ verifier.initVerify(IotAuthorizerService.rsaPublicKey(pem));
+ verifier.update(token.getBytes(StandardCharsets.UTF_8));
+ if (verifier.verify(Base64.getDecoder().decode(signature))) {
+ return token;
+ }
+ } catch (GeneralSecurityException | IllegalArgumentException e) {
+ LOG.debugv("Token signature for authorizer {0} did not verify: {1}", authorizer.getAuthorizerName(), e.getMessage());
+ }
+ }
+ throw IotAuthorizerService.invalid("Token signature mismatch for authorizer " + authorizer.getAuthorizerName());
+ }
+
+ private static Map<String, String> params(String username, WebSocketUpgrade upgrade) {
+ return upgrade == null ? params(username, Map.of(), null) : params(username, upgrade.headers(), upgrade.queryString());
+ }
+
+ /**
+ * The parameters a request carries for custom authentication: the query on the MQTT username,
+ * then the query string, then the headers, the first one naming a parameter winning.
+ */
+ private static Map<String, String> params(String username, Map<String, String> headers, String queryString) {
+ // ponytail: names match case-insensitively in every source; precedence between sources is unmeasured on AWS.
+ Map<String, String> params = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+ int usernameQuery = username == null ? -1 : username.indexOf('?');
+ if (usernameQuery >= 0) {
+ addQuery(params, username.substring(usernameQuery + 1));
+ }
+ if (queryString != null) {
+ addQuery(params, queryString.startsWith("?") ? queryString.substring(1) : queryString);
+ }
+ headers.forEach(params::putIfAbsent);
+ return params;
+ }
+
+ private static void addQuery(Map<String, String> params, String query) {
+ for (String pair : query.split("&")) {
+ int equals = pair.indexOf('=');
+ if (equals > 0) {
+ params.putIfAbsent(urlDecoded(pair.substring(0, equals)), urlDecoded(pair.substring(equals + 1)));
+ }
+ }
+ }
+
+ private static String urlDecoded(String value) {
+ try {
+ return URLDecoder.decode(value, StandardCharsets.UTF_8);
+ } catch (IllegalArgumentException ignored) {
+ // A malformed escape is kept as sent: decoding it must not fail a CONNECT that names no authorizer.
+ return value;
+ }
+ }
+
+ private static AwsException invalidResponse(String message) {
+ return new AwsException("InvalidResponseException", message, 400);
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerService.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerService.java
index c6330539bc..4d37b702e0 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerService.java
@@ -4,6 +4,7 @@ import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.core.common.Resettable;
import io.github.hectorvent.floci.services.iot.model.IotRetainedMessage;
import io.netty.handler.codec.mqtt.MqttConnectReturnCode;
+import io.netty.handler.codec.mqtt.MqttProperties;
import io.netty.handler.codec.mqtt.MqttQoS;
import io.quarkus.runtime.ShutdownEvent;
import io.quarkus.runtime.StartupEvent;
@@ -49,6 +50,7 @@ import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
@@ -118,6 +120,7 @@ public class IotMqttBrokerService implements Resettable {
private final EmulatorConfig config;
private final Vertx vertx;
private final Instance<IotService> iotService;
+ private final IotCustomAuthorizer customAuthorizer;
private final TlsConfigurationRegistry tlsRegistry;
final WorkerExecutor ruleWorker;
private final Map<String, ClientSession> sessionsByClient = new ConcurrentHashMap<>();
@@ -130,16 +133,18 @@ public class IotMqttBrokerService implements Resettable {
* the one it was admitted under.
*/
private final AtomicLong ruleState = new AtomicLong();
+ private final Map<SocketAddress, IotCustomAuthorizer.WebSocketUpgrade> webSocketUpgrades = new ConcurrentHashMap<>();
private MqttServer server;
private MqttServer tlsServer;
private ReloadingKeyManager keyManager;
@Inject
public IotMqttBrokerService(EmulatorConfig config, Vertx vertx, Instance<IotService> iotService,
- TlsConfigurationRegistry tlsRegistry) {
+ IotCustomAuthorizer customAuthorizer, TlsConfigurationRegistry tlsRegistry) {
this.config = config;
this.vertx = vertx;
this.iotService = iotService;
+ this.customAuthorizer = customAuthorizer;
this.tlsRegistry = tlsRegistry;
this.ruleWorker = vertx.createSharedWorkerExecutor("floci-iot-mqtt-rules", 1);
}
@@ -325,6 +330,15 @@ public class IotMqttBrokerService implements Resettable {
ruleState.updateAndGet(state -> (state & reason) == 0 ? state : (state & ~reason) + RULE_STATE_STEP);
}
+ /**
+ * The WebSocket bridge's upgrades, keyed by the address its connection to the plaintext
+ * listener comes from: put before the first frame is piped, taken by that connection's CONNECT,
+ * dropped when the bridge session ends. A method, as the bridge holds a client proxy.
+ */
+ Map<SocketAddress, IotCustomAuthorizer.WebSocketUpgrade> webSocketUpgrades() {
+ return webSocketUpgrades;
+ }
+
public synchronized boolean isRunning() {
return server != null;
}
@@ -368,7 +382,7 @@ public class IotMqttBrokerService implements Resettable {
* anything else is answered with CONNACK not authorized (return code 5, reason code 0x87 on
* MQTT 5) and never becomes a session, so a client already holding that client id keeps its
* connection. The plaintext listener, which the WebSocket bridge also lands on, stays open to
- * every client.
+ * every client except one that names a custom authorizer, see {@link #authorizeCustom}.
*/
void handleEndpoint(MqttEndpoint endpoint, boolean verifyDevice) {
String clientId = endpoint.clientIdentifier();
@@ -383,7 +397,60 @@ public class IotMqttBrokerService implements Resettable {
: MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED);
return;
}
+ } else {
+ IotCustomAuthorizer.WebSocketUpgrade upgrade = remoteAddress == null ? null : webSocketUpgrades.remove(remoteAddress);
+ String username = endpoint.auth() == null ? null : endpoint.auth().getUsername();
+ String authorizerName = IotCustomAuthorizer.authorizerName(username, upgrade);
+ if (authorizerName != null) {
+ authorizeCustom(endpoint, authorizerName, upgrade, upgrade == null ? sourceIp : upgrade.sourceIp());
+ return;
+ }
}
+ admit(endpoint, principal);
+ }
+
+ /**
+ * A CONNECT naming a custom authorizer is admitted only when the authorizer's function allows
+ * it and the policies it returns allow {@code iot:Connect} for the client id. The function runs
+ * off the event loop. A refusal closes an MQTT 3.1.1 connection without a CONNACK and answers
+ * MQTT 5 with reason code 0x87, as AWS IoT does.
+ */
+ private void authorizeCustom(MqttEndpoint endpoint, String authorizerName, IotCustomAuthorizer.WebSocketUpgrade upgrade,
+ String sourceIp) {
+ String clientId = endpoint.clientIdentifier();
+ String username = endpoint.auth() == null ? null : endpoint.auth().getUsername();
+ String password = endpoint.auth() == null ? null : endpoint.auth().getPassword();
+ String serverName = upgrade == null ? null : upgrade.serverName();
+ AtomicBoolean closed = new AtomicBoolean();
+ endpoint.closeHandler(ignored -> closed.set(true));
+ vertx.executeBlocking(() -> {
+ List<String> policies = customAuthorizer.connectPolicies(authorizerName, clientId, username, password, upgrade);
+ return iotService.get().isConnectAllowedBy(policies, clientId, sourceIp, serverName);
+ }, false).onComplete(decision -> {
+ if (closed.get()) {
+ return;
+ }
+ if (decision.succeeded() && decision.result()) {
+ admit(endpoint, null);
+ return;
+ }
+ LOG.debugv("IoT MQTT client {0} refused by custom authorizer {1}: {2}", clientId, authorizerName,
+ decision.failed() ? decision.cause().getMessage() : "iot:Connect is not allowed");
+ if (endpoint.protocolVersion() != 5) {
+ endpoint.close();
+ return;
+ }
+ MqttProperties properties = new MqttProperties();
+ properties.add(new MqttProperties.StringProperty(MqttProperties.MqttPropertyType.REASON_STRING.value(),
+ "CONNACK:Client is not authenticated/authorized to send the message:" + UUID.randomUUID()));
+ endpoint.reject(MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED_5, properties);
+ });
+ }
+
+ private void admit(MqttEndpoint endpoint, String principal) {
+ String clientId = endpoint.clientIdentifier();
+ SocketAddress remoteAddress = endpoint.remoteAddress();
+ String sourceIp = remoteAddress == null ? null : remoteAddress.host();
ClientSession session = new ClientSession(
clientId,
endpoint,
@@ -425,7 +492,7 @@ public class IotMqttBrokerService implements Resettable {
return null;
}
String certificateArn = device.get().certificate().getCertificateArn();
- if (!iotService.get().isConnectAllowed(device.get(), clientId, sourceIp, requestedServerName(endpoint))) {
+ if (!iotService.get().isConnectAllowed(device.get(), clientId, sourceIp, requestedServerName(endpoint.sslSession()))) {
LOG.debugv("IoT MQTT TLS client {0} refused: iot:Connect is not allowed for {1}", clientId, certificateArn);
return null;
}
@@ -460,8 +527,8 @@ public class IotMqttBrokerService implements Resettable {
* {@code iot:DomainName}. An address literal is not a domain name: some clients send the
* host they dialled as SNI even when it is an IP.
*/
- private static String requestedServerName(MqttEndpoint endpoint) {
- if (!(endpoint.sslSession() instanceof ExtendedSSLSession session)) {
+ static String requestedServerName(SSLSession sslSession) {
+ if (!(sslSession instanceof ExtendedSSLSession session)) {
return null;
}
return session.getRequestedServerNames().stream()
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java
index 39af9d3d10..8e33a22b9b 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java
@@ -5,6 +5,7 @@ import io.vertx.core.Vertx;
import io.vertx.core.http.ServerWebSocket;
import io.vertx.core.net.NetClient;
import io.vertx.core.net.NetSocket;
+import io.vertx.core.net.SocketAddress;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import jakarta.enterprise.context.ApplicationScoped;
@@ -12,6 +13,9 @@ import jakarta.enterprise.event.Observes;
import jakarta.inject.Inject;
import org.jboss.logging.Logger;
+import java.util.LinkedHashMap;
+import java.util.Locale;
+import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
/**
@@ -19,8 +23,10 @@ import java.util.concurrent.atomic.AtomicBoolean;
* IoT uses for browser clients, the Device SDK's WebSocket transport and secure tunnelling. Frames
* are piped byte for byte to the broker's plaintext listener, so every broker feature and every
* authorization rule applies without a second code path. No client certificate is involved: on
- * AWS this path authenticates by SigV4 or a custom authorizer, and the broker stays permissive
- * for it.
+ * AWS this path authenticates by SigV4 or a custom authorizer. The broker enforces a custom
+ * authorizer named in the MQTT username, the URL query or an upgrade header, and stays permissive
+ * otherwise; the upgrade's headers, query, server name and client address reach it through
+ * {@link IotMqttBrokerService#webSocketUpgrades()}.
*
* <p>Everything for one session runs on the event loop of the WebSocket's connection, the
* broker socket included, so the handlers below never race each other.
@@ -92,7 +98,12 @@ public class IotMqttWebSocketBridge {
socket.close();
return;
}
- new BridgeSession(ws, socket).start();
+ // Registered before start() lets the first frame through, so it is there when the CONNECT
+ // reaches the broker; removed only if still this very instance, as the address can be reused.
+ SocketAddress bridgeAddress = socket.localAddress();
+ IotCustomAuthorizer.WebSocketUpgrade upgrade = upgradeOf(ws);
+ broker.webSocketUpgrades().put(bridgeAddress, upgrade);
+ new BridgeSession(ws, socket, forgetting(broker.webSocketUpgrades(), bridgeAddress, upgrade)).start();
})
.onFailure(error -> {
LOG.warnv("MQTT WebSocket bridge could not reach the broker on {0}:{1}: {2}",
@@ -101,15 +112,43 @@ public class IotMqttWebSocketBridge {
});
}
+ /** Drops the session's upgrade unless the address already carries a newer session's. */
+ static Runnable forgetting(Map<SocketAddress, IotCustomAuthorizer.WebSocketUpgrade> upgrades, SocketAddress address,
+ IotCustomAuthorizer.WebSocketUpgrade upgrade) {
+ return () -> upgrades.computeIfPresent(address, (key, current) -> current == upgrade ? null : current);
+ }
+
+ /**
+ * The upgrade as AWS hands it to a custom authorizer; the server name only over TLS, from SNI or
+ * else the Host header. The client's address rides along for the broker's policy evaluation.
+ */
+ private static IotCustomAuthorizer.WebSocketUpgrade upgradeOf(ServerWebSocket ws) {
+ Map<String, String> headers = new LinkedHashMap<>();
+ // ponytail: a repeated header keeps its last value.
+ ws.headers().forEach(header -> headers.put(header.getKey().toLowerCase(Locale.ROOT), header.getValue()));
+ String serverName = null;
+ if (ws.isSsl()) {
+ serverName = IotMqttBrokerService.requestedServerName(ws.sslSession());
+ if (serverName == null && ws.authority() != null && !IotMqttBrokerService.isAddressLiteral(ws.authority().host())) {
+ serverName = ws.authority().host();
+ }
+ }
+ SocketAddress client = ws.remoteAddress();
+ return new IotCustomAuthorizer.WebSocketUpgrade(headers, ws.query() == null ? "" : ws.query(), serverName,
+ client == null ? null : client.host());
+ }
+
static final class BridgeSession {
private final ServerWebSocket webSocket;
private final NetSocket socket;
+ private final Runnable onClose;
private final AtomicBoolean closed = new AtomicBoolean();
- BridgeSession(ServerWebSocket webSocket, NetSocket socket) {
+ BridgeSession(ServerWebSocket webSocket, NetSocket socket, Runnable onClose) {
this.webSocket = webSocket;
this.socket = socket;
+ this.onClose = onClose;
}
void start() {
@@ -162,7 +201,7 @@ public class IotMqttWebSocketBridge {
}
private void close(short code, String reason) {
- if (closed.compareAndSet(false, true)) {
+ if (markClosed()) {
socket.close();
if (!webSocket.isClosed()) {
webSocket.close(code, reason);
@@ -171,16 +210,25 @@ public class IotMqttWebSocketBridge {
}
private void closeSocket() {
- if (closed.compareAndSet(false, true)) {
+ if (markClosed()) {
socket.close();
}
}
private void closeWebSocket() {
- if (closed.compareAndSet(false, true) && !webSocket.isClosed()) {
+ if (markClosed() && !webSocket.isClosed()) {
+ // ponytail: on a custom-auth refusal AWS sends an empty close frame (MQTT 3.1.1) or no close frame (MQTT 5); Vert.x has no public API for either, so this sends status 1000.
webSocket.close();
}
}
+
+ private boolean markClosed() {
+ if (!closed.compareAndSet(false, true)) {
+ return false;
+ }
+ onClose.run();
+ return true;
+ }
}
/** The broker binds {@code 0.0.0.0} by default, which is not a connect target; loopback is. */
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java
index 5cdeb5f322..e42fadecf6 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java
@@ -495,14 +495,30 @@ public class IotService {
return false;
}
List<String> documents = attachedPolicyDocuments(certificate.getCertificateArn(), device.region(), device.accountId());
+ return isConnectAllowed(documents, connectionVariables(device, clientId, sourceIp, domainName),
+ device.region(), device.accountId(), clientId);
+ }
+
+ /**
+ * Decides {@code iot:Connect} for a client a custom authorizer admitted, from the policies its
+ * function returned, with the basic connection variables: there is no certificate, so the thing
+ * variables do not resolve.
+ */
+ public boolean isConnectAllowedBy(List<String> documents, String clientId, String sourceIp, String domainName) {
+ // ponytail: the broker has no request context, so a custom-auth client connects to the default account and region.
+ return isConnectAllowed(documents, basicConnectionVariables(clientId, sourceIp, domainName),
+ regionResolver.getDefaultRegion(), regionResolver.getDefaultAccountId(), clientId);
+ }
+
+ private boolean isConnectAllowed(List<String> documents, Map<String, String> variables, String region, String accountId,
+ String clientId) {
if (documents.isEmpty()) {
return false;
}
- Map<String, String> variables = connectionVariables(device, clientId, sourceIp, domainName);
List<String> resolved = documents.stream().map(document -> resolvePolicyVariables(document, variables)).toList();
Map<String, List<String>> conditionContext = new LinkedHashMap<>();
variables.forEach((key, value) -> conditionContext.put(key, List.of(value)));
- String clientArn = AwsArnUtils.Arn.of("iot", device.region(), device.accountId(), "client/" + clientId).toString();
+ String clientArn = AwsArnUtils.Arn.of("iot", region, accountId, "client/" + clientId).toString();
return policyEvaluator.evaluate(CallerContext.of(resolved), null, "iot:Connect", clientArn, conditionContext)
== IamPolicyEvaluator.Decision.ALLOW;
}
@@ -533,14 +549,7 @@ public class IotService {
* the client id names a thing attached to the certificate, as on AWS.
*/
private Map<String, String> connectionVariables(RegisteredDevice device, String clientId, String sourceIp, String domainName) {
- Map<String, String> variables = new LinkedHashMap<>();
- variables.put("iot:ClientId", clientId);
- if (sourceIp != null) {
- variables.put("aws:SourceIp", sourceIp);
- }
- if (domainName != null) {
- variables.put("iot:DomainName", domainName);
- }
+ Map<String, String> variables = basicConnectionVariables(clientId, sourceIp, domainName);
Optional<Thing> thing = getForAccount(thingStore, device.accountId(), thingKey(device.region(), clientId));
boolean attached = thing.isPresent()
&& getForAccount(thingPrincipalStore, device.accountId(), thingPrincipalKey(device.region(), clientId))
@@ -556,6 +565,18 @@ public class IotService {
return variables;
}
+ private static Map<String, String> basicConnectionVariables(String clientId, String sourceIp, String domainName) {
+ Map<String, String> variables = new LinkedHashMap<>();
+ variables.put("iot:ClientId", clientId);
+ if (sourceIp != null) {
+ variables.put("aws:SourceIp", sourceIp);
+ }
+ if (domainName != null) {
+ variables.put("iot:DomainName", domainName);
+ }
+ return variables;
+ }
+
/**
* Substitutes the connection's variables into every string of the document on the parsed tree,
* so a client id is never read as JSON. A statement still holding a variable Floci cannot
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerIntegrationTest.java
new file mode 100644
index 0000000000..3cc89bc079
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerIntegrationTest.java
@@ -0,0 +1,357 @@
+package io.github.hectorvent.floci.services.iot;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.services.lambda.LambdaService;
+import io.github.hectorvent.floci.services.lambda.model.InvocationType;
+import io.github.hectorvent.floci.services.lambda.model.InvokeResult;
+import io.quarkus.test.InjectMock;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.TestProfile;
+import org.eclipse.microprofile.config.inject.ConfigProperty;
+import org.eclipse.paho.client.mqttv3.MqttClient;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
+import org.eclipse.paho.mqttv5.client.MqttAsyncClient;
+import org.eclipse.paho.mqttv5.client.MqttConnectionOptions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+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;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Custom authorizers on the real routes and broker: {@code TestInvokeAuthorizer} on its REST-JSON
+ * path, and an MQTT CONNECT on the TCP listener or over WebSocket admitted or refused by the
+ * authorizer's answer the way AWS IoT does it (MQTT 3.1.1 closed without a CONNACK, MQTT 5
+ * answered with reason 135). The function is mocked and decides by the MQTT password; what it
+ * received is asserted as the event.
+ */
+@QuarkusTest
+@TestProfile(IotMqttWebSocketIntegrationTest.Profile.class)
+class IotCustomAuthorizerIntegrationTest {
+
+ private static final String FUNCTION_ARN = "arn:aws:lambda:us-east-1:000000000000:function:it-custom-auth";
+ private static final String NAME_PARAM = "x-amz-customauthorizer-name=";
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ @ConfigProperty(name = "quarkus.http.test-port", defaultValue = "0")
+ int testHttpPort;
+
+ @ConfigProperty(name = "quarkus.http.test-ssl-port", defaultValue = "0")
+ int testSslPort;
+
+ @InjectMock
+ LambdaService lambdaService;
+
+ private final BlockingQueue<JsonNode> events = new LinkedBlockingQueue<>();
+ private String authorizer;
+
+ @BeforeEach
+ void functionDecidesByThePassword() {
+ when(lambdaService.invokeArn(eq(FUNCTION_ARN), any(byte[].class), eq(InvocationType.RequestResponse)))
+ .thenAnswer(invocation -> {
+ JsonNode event = MAPPER.readTree((byte[]) invocation.getArgument(1));
+ events.add(event);
+ JsonNode mqtt = event.path("protocolData").path("mqtt");
+ String secret = new String(Base64.getDecoder().decode(mqtt.path("password").asText("")),
+ StandardCharsets.UTF_8);
+ String answer = switch (secret) {
+ case "allow" -> allow(mqtt.path("clientId").asText());
+ case "garbage" -> "{\"foo\": 1}";
+ default -> "{\"isAuthenticated\": false, \"principalId\": \"itprincipal\", \"policyDocuments\": []}";
+ };
+ return new InvokeResult(200, null, answer.getBytes(StandardCharsets.UTF_8), null, "request-id");
+ });
+ authorizer = "it-cauth-" + System.nanoTime();
+ given().contentType("application/json")
+ .body("{\"authorizerFunctionArn\": \"" + FUNCTION_ARN + "\", \"signingDisabled\": true, \"status\": \"ACTIVE\"}")
+ .when().post("/authorizer/" + authorizer)
+ .then().statusCode(200);
+ }
+
+ @Test
+ void testInvokeAuthorizerAnswersWithTheVerdictPoliciesAndDefaultedTtls() {
+ given().contentType("application/json")
+ .body("{\"mqttContext\": {\"username\": \"c1?" + NAME_PARAM + authorizer + "\", \"password\": \""
+ + base64("allow") + "\", \"clientId\": \"c1\"}}")
+ .when().post("/authorizer/" + authorizer + "/test")
+ .then()
+ .statusCode(200)
+ .body(equalTo("{\"disconnectAfterInSeconds\":86400,\"isAuthenticated\":true,\"policyDocuments\":["
+ + MAPPER.valueToTree(policy("c1")) + "],\"principalId\":\"itprincipal\",\"refreshAfterInSeconds\":300}"));
+ }
+
+ @Test
+ void testInvokeAuthorizerReportsAnInvalidAnswerAsInvalidResponseException() {
+ given().contentType("application/json")
+ .body("{\"mqttContext\": {\"clientId\": \"c1\", \"password\": \"" + base64("garbage") + "\"}}")
+ .when().post("/authorizer/" + authorizer + "/test")
+ .then()
+ .statusCode(400)
+ .header("X-Amzn-ErrorType", "InvalidResponseException")
+ .body("message", equalTo("Lambda invocation result is in invalid format"));
+ }
+
+ @Test
+ void testInvokeAuthorizerOnAMissingAuthorizerIsNotFound() {
+ given().contentType("application/json").body("{\"httpContext\": {}}")
+ .when().post("/authorizer/it-cauth-missing/test")
+ .then()
+ .statusCode(404)
+ .header("X-Amzn-ErrorType", "ResourceNotFoundException")
+ .body("message", equalTo("Authorizer it-cauth-missing not found"));
+ }
+
+ @Test
+ void aTestInvokeBodyWithTrailingContentIsAnInvalidRequest() {
+ given().contentType("application/json").body("{\"mqttContext\": {}} trailing")
+ .when().post("/authorizer/" + authorizer + "/test")
+ .then()
+ .statusCode(400)
+ .header("X-Amzn-ErrorType", "InvalidRequestException");
+ }
+
+ @Test
+ void mqtt3AllowedConnectSendsTheWebSocketEventWithTheUsernameVerbatim() throws Exception {
+ String clientId = "cauth-v3-" + System.nanoTime();
+ String username = clientId + "?" + NAME_PARAM + authorizer;
+
+ connectV3(ws(""), clientId, username, "allow", Map.of()).disconnect();
+
+ JsonNode event = takeEvent();
+ assertEquals(List.of("http", "mqtt"), protocols(event));
+ JsonNode headers = event.path("protocolData").path("http").path("headers");
+ headers.fieldNames().forEachRemaining(name -> assertEquals(name.toLowerCase(Locale.ROOT), name, "header names are lower-cased"));
+ assertTrue(headers.path("sec-websocket-protocol").asText().contains("mqtt"), headers.toString());
+ assertEquals("", event.path("protocolData").path("http").path("queryString").asText(null));
+ assertEquals(username, event.path("protocolData").path("mqtt").path("username").asText());
+ assertEquals(base64("allow"), event.path("protocolData").path("mqtt").path("password").asText());
+ assertEquals(clientId, event.path("protocolData").path("mqtt").path("clientId").asText());
+ assertFalse(event.path("signatureVerified").asBoolean(true));
+ }
+
+ @Test
+ void mqtt3RefusedConnectIsClosedWithoutAConnack() {
+ String clientId = "cauth-v3-deny-" + System.nanoTime();
+
+ MqttException refused = assertThrows(MqttException.class,
+ () -> connectV3(ws(""), clientId, clientId + "?" + NAME_PARAM + authorizer, "deny", Map.of()));
+
+ assertEquals(MqttException.REASON_CODE_CONNECTION_LOST, refused.getReasonCode());
+ }
+
+ @Test
+ void mqtt3ConnectForAClientIdThePolicyDoesNotCoverIsRefused() {
+ String clientId = "cauth-v3-other-" + System.nanoTime();
+ when(lambdaService.invokeArn(eq(FUNCTION_ARN), any(byte[].class), eq(InvocationType.RequestResponse)))
+ .thenReturn(new InvokeResult(200, null, allow("someone-else").getBytes(StandardCharsets.UTF_8), null, "id"));
+
+ MqttException refused = assertThrows(MqttException.class,
+ () -> connectV3(ws(""), clientId, clientId + "?" + NAME_PARAM + authorizer, "allow", Map.of()));
+
+ assertEquals(MqttException.REASON_CODE_CONNECTION_LOST, refused.getReasonCode());
+ }
+
+ @Test
+ void mqtt3ConnectNamingAnUnknownAuthorizerIsRefusedWithoutInvokingAnyFunction() {
+ String clientId = "cauth-v3-unknown-" + System.nanoTime();
+
+ MqttException refused = assertThrows(MqttException.class,
+ () -> connectV3(ws(""), clientId, clientId + "?" + NAME_PARAM + "it-cauth-nope", "allow", Map.of()));
+
+ assertEquals(MqttException.REASON_CODE_CONNECTION_LOST, refused.getReasonCode());
+ verify(lambdaService, never()).invokeArn(anyString(), any(byte[].class), any(InvocationType.class));
+ }
+
+ @Test
+ void mqtt5AllowedConnectWithTheNameInTheUrlQueryConnects() throws Exception {
+ String clientId = "cauth-v5-" + System.nanoTime();
+
+ MqttAsyncClient client = connectV5(ws("?" + NAME_PARAM + authorizer), clientId, clientId, "allow");
+ client.disconnect().waitForCompletion(5000);
+ client.close();
+
+ JsonNode event = takeEvent();
+ assertEquals(NAME_PARAM + authorizer, event.path("protocolData").path("http").path("queryString").asText());
+ assertEquals(clientId, event.path("protocolData").path("mqtt").path("username").asText());
+ }
+
+ @Test
+ void mqtt5RefusedConnectGetsReasonCode135() {
+ String clientId = "cauth-v5-deny-" + System.nanoTime();
+
+ org.eclipse.paho.mqttv5.common.MqttException refused = assertThrows(org.eclipse.paho.mqttv5.common.MqttException.class,
+ () -> connectV5(ws(""), clientId, clientId + "?" + NAME_PARAM + authorizer, "deny"));
+
+ assertEquals(135, refused.getReasonCode());
+ }
+
+ @Test
+ void theNameInTheUpgradeHeaderIsSentAmongTheLowerCasedHeaders() throws Exception {
+ String clientId = "cauth-header-" + System.nanoTime();
+
+ connectV3(ws(""), clientId, clientId, "allow", Map.of("X-Amz-CustomAuthorizer-Name", authorizer)).disconnect();
+
+ assertEquals(authorizer, takeEvent().path("protocolData").path("http").path("headers")
+ .path("x-amz-customauthorizer-name").asText());
+ }
+
+ @Test
+ void overWssTheEventCarriesTheServerName() throws Exception {
+ String clientId = "cauth-wss-" + System.nanoTime();
+
+ connectV3("wss://localhost:" + testSslPort + "/mqtt", clientId, clientId + "?" + NAME_PARAM + authorizer, "allow",
+ Map.of()).disconnect();
+
+ JsonNode event = takeEvent();
+ assertEquals(List.of("tls", "http", "mqtt"), protocols(event));
+ assertEquals("localhost", event.path("protocolData").path("tls").path("serverName").asText());
+ List<String> keys = new ArrayList<>();
+ event.path("protocolData").fieldNames().forEachRemaining(keys::add);
+ assertEquals(List.of("tls", "mqtt", "http"), keys);
+ }
+
+ @Test
+ void overWssToAnAddressLiteralTheEventCarriesNoServerName() throws Exception {
+ String clientId = "cauth-wss-ip-" + System.nanoTime();
+
+ connectV3("wss://127.0.0.1:" + testSslPort + "/mqtt", clientId, clientId + "?" + NAME_PARAM + authorizer, "allow",
+ Map.of()).disconnect();
+
+ JsonNode event = takeEvent();
+ assertEquals(List.of("http", "mqtt"), protocols(event));
+ assertFalse(event.path("protocolData").has("tls"), event.path("protocolData").toString());
+ }
+
+ @Test
+ void mqtt3AllowedConnectOnTheTcpListenerSendsAnMqttOnlyEvent() throws Exception {
+ String clientId = "cauth-tcp-v3-" + System.nanoTime();
+ String username = clientId + "?" + NAME_PARAM + authorizer;
+
+ connectV3(tcp(), clientId, username, "allow", Map.of()).disconnect();
+
+ JsonNode event = takeEvent();
+ assertEquals(List.of("mqtt"), protocols(event));
+ JsonNode protocolData = event.path("protocolData");
+ assertFalse(protocolData.has("http"), protocolData.toString());
+ assertFalse(protocolData.has("tls"), protocolData.toString());
+ assertEquals(username, protocolData.path("mqtt").path("username").asText());
+ assertEquals(base64("allow"), protocolData.path("mqtt").path("password").asText());
+ assertEquals(clientId, protocolData.path("mqtt").path("clientId").asText());
+ }
+
+ @Test
+ void mqtt5RefusedConnectOnTheTcpListenerGetsReasonCode135() throws Exception {
+ String clientId = "cauth-tcp-v5-deny-" + System.nanoTime();
+
+ org.eclipse.paho.mqttv5.common.MqttException refused = assertThrows(org.eclipse.paho.mqttv5.common.MqttException.class,
+ () -> connectV5(tcp(), clientId, clientId + "?" + NAME_PARAM + authorizer, "deny"));
+
+ assertEquals(135, refused.getReasonCode());
+ assertEquals(base64("deny"), takeEvent().path("protocolData").path("mqtt").path("password").asText());
+ }
+
+ // Helpers
+
+ private MqttClient connectV3(String url, String clientId, String username, String password, Map<String, String> headers)
+ throws Exception {
+ MqttClient client = new MqttClient(url, clientId, new MemoryPersistence());
+ client.setTimeToWait(10_000);
+ MqttConnectOptions options = new MqttConnectOptions();
+ options.setMqttVersion(MqttConnectOptions.MQTT_VERSION_3_1_1);
+ options.setCleanSession(true);
+ options.setConnectionTimeout(10);
+ options.setUserName(username);
+ options.setPassword(password.toCharArray());
+ if (!headers.isEmpty()) {
+ Properties custom = new Properties();
+ custom.putAll(headers);
+ options.setCustomWebSocketHeaders(custom);
+ }
+ if (url.startsWith("wss://")) {
+ options.setSocketFactory(IotMqttWebSocketIntegrationTest.trustOnlyFlociCa().getSocketFactory());
+ }
+ try {
+ client.connect(options);
+ } catch (MqttException e) {
+ client.close();
+ throw e;
+ }
+ return client;
+ }
+
+ private MqttAsyncClient connectV5(String url, String clientId, String username, String password)
+ throws org.eclipse.paho.mqttv5.common.MqttException {
+ MqttAsyncClient client = new MqttAsyncClient(url, clientId, new org.eclipse.paho.mqttv5.client.persist.MemoryPersistence());
+ MqttConnectionOptions options = new MqttConnectionOptions();
+ options.setCleanStart(true);
+ options.setConnectionTimeout(10);
+ options.setUserName(username);
+ options.setPassword(password.getBytes(StandardCharsets.UTF_8));
+ try {
+ client.connect(options).waitForCompletion(10_000);
+ } catch (org.eclipse.paho.mqttv5.common.MqttException e) {
+ client.close(true);
+ throw e;
+ }
+ return client;
+ }
+
+ private String ws(String query) {
+ return "ws://127.0.0.1:" + testHttpPort + "/mqtt" + query;
+ }
+
+ private static String tcp() {
+ return "tcp://127.0.0.1:" + IotMqttWebSocketIntegrationTest.PLAIN_PORT;
+ }
+
+ private JsonNode takeEvent() throws InterruptedException {
+ JsonNode event = events.poll(10, TimeUnit.SECONDS);
+ assertNotNull(event, "the authorizer function was not invoked");
+ return event;
+ }
+
+ private static List<String> protocols(JsonNode event) {
+ List<String> protocols = new ArrayList<>();
+ event.path("protocols").forEach(protocol -> protocols.add(protocol.asText()));
+ return protocols;
+ }
+
+ private static String allow(String clientId) {
+ return "{\"isAuthenticated\": true, \"principalId\": \"itprincipal\", \"policyDocuments\": ["
+ + MAPPER.valueToTree(policy(clientId)) + "]}";
+ }
+
+ private static String policy(String clientId) {
+ return "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\"iot:Connect\","
+ + "\"Resource\":\"arn:aws:iot:us-east-1:000000000000:client/" + clientId + "\"}]}";
+ }
+
+ private static String base64(String text) {
+ return Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerTest.java
new file mode 100644
index 0000000000..a126a95479
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerTest.java
@@ -0,0 +1,594 @@
+package io.github.hectorvent.floci.services.iot;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.iot.IotCustomAuthorizer.WebSocketUpgrade;
+import io.github.hectorvent.floci.services.lambda.LambdaService;
+import io.github.hectorvent.floci.services.lambda.model.InvocationType;
+import io.github.hectorvent.floci.services.lambda.model.InvokeResult;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
+import java.security.Signature;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The custom authorizer decision as AWS IoT makes it, with the function mocked: the event each
+ * request or connection produces, the checks on the function's answer in AWS's order and wording,
+ * and token signature verification.
+ */
+class IotCustomAuthorizerTest {
+
+ private static final String REGION = "us-east-1";
+ private static final String FUNCTION_ARN = "arn:aws:lambda:us-east-1:000000000000:function:auth";
+ private static final String POLICY = "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", "
+ + "\"Action\": \"iot:Connect\", \"Resource\": \"*\"}]}";
+ private static final String NAME_PARAM = "x-amz-customauthorizer-name=";
+ private static final String SIGNATURE_PARAM = "x-amz-customauthorizer-signature=";
+ private static final String PRINCIPAL_CONSTRAINT =
+ " at principalId failed to satisfy constraint: Member must satisfy ([a-zA-Z0-9]){1,128}";
+ private static final String TTL_CONSTRAINT =
+ " failed to satisfy constraint: Member must be greater than 5 minutes and less than 24 hours.";
+
+ private static KeyPair key1;
+ private static KeyPair key2;
+ private static KeyPair unregistered;
+
+ private final ObjectMapper mapper = new ObjectMapper();
+ private final RegionResolver regionResolver = new RegionResolver(REGION, "000000000000");
+ private final IotAuthorizerService authorizers = new IotAuthorizerService(new InMemoryStorage<>(), regionResolver);
+ private final LambdaService lambda = mock(LambdaService.class);
+ private final IotCustomAuthorizer customAuthorizer = new IotCustomAuthorizer(authorizers, lambda, mapper, regionResolver);
+ private final List<JsonNode> events = new ArrayList<>();
+ private String answer = response("[" + quoted(POLICY) + "]", "\"refreshAfterInSeconds\": 600, \"disconnectAfterInSeconds\": 3600");
+ private String functionError;
+
+ @BeforeAll
+ static void generateKeys() throws GeneralSecurityException {
+ KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
+ generator.initialize(2048);
+ key1 = generator.generateKeyPair();
+ key2 = generator.generateKeyPair();
+ unregistered = generator.generateKeyPair();
+ }
+
+ @BeforeEach
+ void setUp() {
+ when(lambda.invokeArn(eq(FUNCTION_ARN), any(byte[].class), eq(InvocationType.RequestResponse)))
+ .thenAnswer(invocation -> {
+ events.add(mapper.readTree((byte[]) invocation.getArgument(1)));
+ return new InvokeResult(200, functionError, answer.getBytes(StandardCharsets.UTF_8), null, "request-id");
+ });
+ create("a", "ACTIVE", false);
+ create("s", "ACTIVE", true);
+ create("off", "INACTIVE", false);
+ }
+
+ // TestInvokeAuthorizer
+
+ @Test
+ void testInvokeReturnsTheVerdictWithPoliciesVerbatimAndSendsTheMqttFieldsAsGiven() {
+ ObjectNode response = customAuthorizer.testInvoke("a", request("""
+ {"mqttContext": {"username": "c?x-amz-customauthorizer-name=a", "password": "c2VjcmV0", "clientId": "c"}}
+ """), REGION);
+
+ assertEquals("{\"disconnectAfterInSeconds\":3600,\"isAuthenticated\":true,\"policyDocuments\":["
+ + quoted(POLICY) + "],\"principalId\":\"p1\",\"refreshAfterInSeconds\":600}", response.toString());
+ assertEquals("{\"protocolData\":{\"mqtt\":{\"username\":\"c?x-amz-customauthorizer-name=a\",\"password\":\"c2VjcmV0\","
+ + "\"clientId\":\"c\"}},\"protocols\":[\"mqtt\"],\"signatureVerified\":false,"
+ + "\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void testInvokeOrdersProtocolDataTlsMqttHttpAndProtocolsTlsHttpMqtt() {
+ customAuthorizer.testInvoke("a", request("""
+ {"httpContext": {"headers": {"X-Secret": "s", "X-Mixed-Case": "Value"}, "queryString": "?a=b&c=d"},
+ "mqttContext": {"clientId": "c"}, "tlsContext": {"serverName": "iot.example.com"}}
+ """), REGION);
+
+ assertEquals("{\"protocolData\":{\"tls\":{\"serverName\":\"iot.example.com\"},\"mqtt\":{\"clientId\":\"c\"},"
+ + "\"http\":{\"headers\":{\"X-Secret\":\"s\",\"X-Mixed-Case\":\"Value\"},\"queryString\":\"?a=b&c=d\"}},"
+ + "\"protocols\":[\"tls\",\"http\",\"mqtt\"],\"signatureVerified\":false,"
+ + "\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void testInvokeWithAnEmptyHttpContextSendsAnEmptyHttpObject() {
+ customAuthorizer.testInvoke("a", request("{\"httpContext\": {}}"), REGION);
+
+ assertEquals("{\"protocolData\":{\"http\":{}},\"protocols\":[\"http\"],\"signatureVerified\":false,"
+ + "\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void connectionMetadataIdIsAFreshUuidForEveryInvocation() {
+ customAuthorizer.testInvoke("a", request("{\"httpContext\": {}}"), REGION);
+ customAuthorizer.testInvoke("a", request("{\"httpContext\": {}}"), REGION);
+
+ String first = events.get(0).path("connectionMetadata").path("id").asText();
+ String second = events.get(1).path("connectionMetadata").path("id").asText();
+ assertTrue(first.matches("[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}"), first);
+ assertNotEquals(first, second);
+ }
+
+ @Test
+ void testInvokeWorksOnAnInactiveAuthorizer() {
+ assertTrue(customAuthorizer.testInvoke("off", request("{\"httpContext\": {}}"), REGION)
+ .path("isAuthenticated").asBoolean());
+ }
+
+ @Test
+ void testInvokeOnAMissingAuthorizerIsNotFound() {
+ assertAwsError("ResourceNotFoundException", 404, "Authorizer nope not found",
+ () -> customAuthorizer.testInvoke("nope", request("{\"httpContext\": {}}"), REGION));
+ verifyNotInvoked();
+ }
+
+ @Test
+ void omittedTtlsAreDefaultedTo300And86400() {
+ answer = response("[" + quoted(POLICY) + "]", null);
+
+ ObjectNode response = testInvoke();
+
+ assertEquals(300, response.path("refreshAfterInSeconds").asInt());
+ assertEquals(86400, response.path("disconnectAfterInSeconds").asInt());
+ }
+
+ @Test
+ void ttlsAtTheInclusiveBoundsAreAccepted() {
+ answer = response("[" + quoted(POLICY) + "]", "\"refreshAfterInSeconds\": 300, \"disconnectAfterInSeconds\": 86400");
+
+ ObjectNode response = testInvoke();
+
+ assertEquals(300, response.path("refreshAfterInSeconds").asInt());
+ assertEquals(86400, response.path("disconnectAfterInSeconds").asInt());
+ }
+
+ @Test
+ void aPolicyGivenAsAnObjectIsReturnedAsOneCompactString() throws Exception {
+ answer = response("[" + POLICY + "]", null);
+
+ ObjectNode response = testInvoke();
+
+ assertEquals(mapper.writeValueAsString(mapper.readTree(POLICY)), response.path("policyDocuments").get(0).asText());
+ }
+
+ @Test
+ void aDenyWithPrincipalAndPoliciesIsReturnedAsIs() {
+ answer = "{\"isAuthenticated\": false, \"principalId\": \"p1\", \"policyDocuments\": [" + quoted(POLICY) + "]}";
+
+ ObjectNode response = testInvoke();
+
+ assertFalse(response.path("isAuthenticated").asBoolean());
+ assertEquals(POLICY, response.path("policyDocuments").get(0).asText());
+ }
+
+ @Test
+ void anEmptyPolicyListIsReturnedAsIs() {
+ answer = response("[]", null);
+
+ assertEquals(0, testInvoke().path("policyDocuments").size());
+ }
+
+ @ParameterizedTest
+ @CsvSource(delimiter = '|', value = {
+ "{\"foo\": 1}|Lambda invocation result is in invalid format",
+ "{\"principalId\": \"p1\", \"policyDocuments\": []}|Lambda invocation result is in invalid format",
+ "{\"isAuthenticated\": false}|null" + PRINCIPAL_CONSTRAINT,
+ "{\"isAuthenticated\": true, \"policyDocuments\": []}|null" + PRINCIPAL_CONSTRAINT,
+ "{\"isAuthenticated\": true, \"principalId\": \"bad-principal!\"}|bad-principal!" + PRINCIPAL_CONSTRAINT,
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\"}|policyDocuments failed to satisfy constraint: List of policies cannot be null.",
+ "{\"isAuthenticated\": false, \"principalId\": \"p1\"}|policyDocuments failed to satisfy constraint: List of policies cannot be null.",
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [\"this is not json\"]}"
+ + "|policyDocuments failed to satisfy constraint: Policy document is Malformed: Invalid policy syntax.",
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [\"{} {}\"]}"
+ + "|policyDocuments failed to satisfy constraint: Policy document is Malformed: Invalid policy syntax.",
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [\"{}\",\"{}\",\"{}\",\"{}\",\"{}\",\"{}\",\"{}\",\"{}\",\"{}\",\"{}\",\"{}\"]}"
+ + "|policyDocuments failed to satisfy constraint: Number of policies allowed cannot exceed 10",
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [{}], \"refreshAfterInSeconds\": 299}"
+ + "|299 at refreshAfterInSeconds" + TTL_CONSTRAINT,
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [{}], \"refreshAfterInSeconds\": 86401}"
+ + "|86401 at refreshAfterInSeconds" + TTL_CONSTRAINT,
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [{}], \"disconnectAfterInSeconds\": 299}"
+ + "|299 at disconnectAfterInSeconds" + TTL_CONSTRAINT,
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [{}], \"disconnectAfterInSeconds\": 86401}"
+ + "|86401 at disconnectAfterInSeconds" + TTL_CONSTRAINT,
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": [{}], \"refreshAfterInSeconds\": 10, \"disconnectAfterInSeconds\": 10}"
+ + "|10 at refreshAfterInSeconds" + TTL_CONSTRAINT,
+ "not json|Lambda invocation result is in invalid format",
+ "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": []} junk|Lambda invocation result is in invalid format"
+ })
+ void anInvalidAnswerIsAnInvalidResponseInAwsOrderAndWording(String invalidAnswer, String message) {
+ answer = invalidAnswer;
+
+ assertAwsError("InvalidResponseException", 400, message, this::testInvoke);
+ }
+
+ @Test
+ void aPolicyOverTheSizeLimitIsAnInvalidResponse() {
+ answer = response("[" + quoted("{\"Version\": \"2012-10-17\", \"Statement\": [], \"Id\": \"" + "x".repeat(2048) + "\"}")
+ + "]", null);
+
+ assertAwsError("InvalidResponseException", 400,
+ "policyDocuments failed to satisfy constraint: Size of a policy document cannot exceeds hard limit of 2048",
+ this::testInvoke);
+ }
+
+ @Test
+ void aFunctionErrorReportsItsMessageAndType() {
+ functionError = "Unhandled";
+ answer = "{\"errorMessage\": \"compat-raise\", \"errorType\": \"Exception\", \"stackTrace\": []}";
+
+ assertAwsError("InvalidResponseException", 400,
+ "Lambda function encountered error in execution: compat-raise: Exception", this::testInvoke);
+ }
+
+ @Test
+ void tokenWithoutSignatureIsRefused() {
+ assertInvalidRequest("Request must provide both token and tokenSignature together.",
+ () -> customAuthorizer.testInvoke("a", request("{\"token\": \"allow-me\"}"), REGION));
+ }
+
+ @Test
+ void tokenAndSignatureOnASigningDisabledAuthorizerAreRefused() throws GeneralSecurityException {
+ assertInvalidRequest("Token and token signature provided but signing is disabled for the authorizer.",
+ () -> customAuthorizer.testInvoke("a", tokenRequest("allow-me", sign(key1, "allow-me")), REGION));
+ }
+
+ @Test
+ void tokenWithAContextIsRefused() throws GeneralSecurityException {
+ ObjectNode request = tokenRequest("allow-me", sign(key1, "allow-me"));
+ request.putObject("mqttContext").put("clientId", "c");
+
+ assertInvalidRequest("Request cannot have token and Http/Mqtt/Tls context.",
+ () -> customAuthorizer.testInvoke("s", request, REGION));
+ }
+
+ @Test
+ void aRequestWithoutTokenOrContextIsRefused() {
+ assertInvalidRequest("Request must have Http/Mqtt/Tls context.",
+ () -> customAuthorizer.testInvoke("a", request("{}"), REGION));
+ }
+
+ @Test
+ void aSignatureThatIsNotBase64IsAValidationError() {
+ assertInvalidRequest("1 validation error detected: Value at 'tokenSignature' failed to satisfy constraint: "
+ + "Member must satisfy regular expression pattern: [A-Za-z0-9+/]+={0,2}",
+ () -> customAuthorizer.testInvoke("s", tokenRequest("allow-me", "not base64!"), REGION));
+ }
+
+ @Test
+ void aQueryStringWithoutTheQuestionMarkIsRefused() {
+ assertInvalidRequest("Invalid arguments in the call", () -> customAuthorizer.testInvoke("a",
+ request("{\"httpContext\": {\"headers\": {\"X-Secret\": \"s\"}, \"queryString\": \"a=b\"}}"), REGION));
+ }
+
+ @Test
+ void anEmptyQueryStringIsAValidationError() {
+ assertInvalidRequest("1 validation error detected: Value at 'httpContext.queryString' failed to satisfy "
+ + "constraint: Member must have length greater than or equal to 1",
+ () -> customAuthorizer.testInvoke("a", request("{\"httpContext\": {\"queryString\": \"\"}}"), REGION));
+ }
+
+ @Test
+ void anEmptyTokenIsAValidationError() throws GeneralSecurityException {
+ assertInvalidRequest("1 validation error detected: Value at 'token' failed to satisfy constraint: "
+ + "Member must have length greater than or equal to 1",
+ () -> customAuthorizer.testInvoke("s", tokenRequest("", sign(key1, "")), REGION));
+ }
+
+ @Test
+ void aTokenOverItsMaximumLengthIsAValidationError() throws GeneralSecurityException {
+ String token = "t".repeat(6145);
+
+ assertInvalidRequest("1 validation error detected: Value at 'token' failed to satisfy constraint: "
+ + "Member must have length less than or equal to 6144",
+ () -> customAuthorizer.testInvoke("s", tokenRequest(token, sign(key1, token)), REGION));
+ }
+
+ @Test
+ void aSignatureOverItsMaximumLengthIsAValidationError() {
+ assertInvalidRequest("1 validation error detected: Value at 'tokenSignature' failed to satisfy constraint: "
+ + "Member must have length less than or equal to 2560",
+ () -> customAuthorizer.testInvoke("s", tokenRequest("allow-me", "A".repeat(2561)), REGION));
+ }
+
+ @Test
+ void tokenModeVerifiesASignatureByEitherKeyAndSendsOnlyTheToken() throws GeneralSecurityException {
+ for (KeyPair key : List.of(key1, key2)) {
+ assertTrue(customAuthorizer.testInvoke("s", tokenRequest("allow-me", sign(key, "allow-me")), REGION)
+ .path("isAuthenticated").asBoolean());
+ assertEquals("{\"token\":\"allow-me\",\"signatureVerified\":true,\"connectionMetadata\":{\"id\":\"ID\"}}",
+ lastEvent());
+ }
+ }
+
+ @Test
+ void aSignatureOverAnotherTokenOrByAnUnregisteredKeyIsAMismatch() throws GeneralSecurityException {
+ assertInvalidRequest("Token signature mismatch for authorizer s",
+ () -> customAuthorizer.testInvoke("s", tokenRequest("allow-me", sign(key1, "other-token")), REGION));
+ assertInvalidRequest("Token signature mismatch for authorizer s",
+ () -> customAuthorizer.testInvoke("s", tokenRequest("allow-me", sign(unregistered, "allow-me")), REGION));
+ }
+
+ @Test
+ void aSignedMqttUsernameIsVerifiedAndItsTokenSent() throws GeneralSecurityException {
+ String username = signedUsername(sign(key1, "allow-me"), "allow-me");
+ ObjectNode request = mapper.createObjectNode();
+ request.putObject("mqttContext").put("username", username).put("clientId", "c");
+
+ customAuthorizer.testInvoke("s", request, REGION);
+
+ assertEquals("{\"protocolData\":{\"mqtt\":{\"username\":" + quoted(username) + ",\"clientId\":\"c\"}},"
+ + "\"protocols\":[\"mqtt\"],\"token\":\"allow-me\",\"signatureVerified\":true,"
+ + "\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void aSignatureInHttpHeadersOrQueryStringIsVerified() throws GeneralSecurityException {
+ String signature = sign(key2, "allow-me");
+ ObjectNode headers = mapper.createObjectNode();
+ headers.putObject("httpContext").putObject("headers").put("tok", "allow-me").put("x-amz-customauthorizer-signature", signature);
+ ObjectNode query = mapper.createObjectNode();
+ query.putObject("httpContext").put("queryString", "?tok=allow-me&" + SIGNATURE_PARAM + urlEncoded(signature));
+
+ customAuthorizer.testInvoke("s", headers, REGION);
+ assertEquals("allow-me", events.getLast().path("token").asText());
+ customAuthorizer.testInvoke("s", query, REGION);
+ assertEquals("allow-me", events.getLast().path("token").asText());
+ }
+
+ @Test
+ void aSignedAuthorizerWithoutATokenInTheContextIsRefusedWithoutAMessage() {
+ AwsException failure = assertThrows(AwsException.class, () -> customAuthorizer.testInvoke("s",
+ request("{\"mqttContext\": {\"clientId\": \"c\", \"password\": \"c2VjcmV0\"}}"), REGION));
+
+ assertEquals("InvalidRequestException", failure.getErrorCode());
+ assertNull(failure.getMessage());
+ verifyNotInvoked();
+ }
+
+ // MQTT CONNECT
+
+ @Test
+ void aWebSocketConnectSendsTlsMqttAndHttpWithTheUsernameVerbatim() {
+ Map<String, String> headers = new LinkedHashMap<>();
+ headers.put("host", "iot.example.com");
+ headers.put("sec-websocket-protocol", "mqtt");
+
+ List<String> policies = customAuthorizer.connectPolicies("a", "c", "c?" + NAME_PARAM + "a", "secret",
+ new WebSocketUpgrade(headers, "", "iot.example.com", null));
+
+ assertEquals(List.of(POLICY), policies);
+ assertEquals("{\"protocolData\":{\"tls\":{\"serverName\":\"iot.example.com\"},\"mqtt\":{\"username\":"
+ + "\"c?x-amz-customauthorizer-name=a\",\"password\":\"c2VjcmV0\",\"clientId\":\"c\"},\"http\":{\"headers\":"
+ + "{\"host\":\"iot.example.com\",\"sec-websocket-protocol\":\"mqtt\"},\"queryString\":\"\"}},"
+ + "\"protocols\":[\"tls\",\"http\",\"mqtt\"],\"signatureVerified\":false,"
+ + "\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void aConnectWithoutUsernamePasswordOrTlsLeavesThemOut() {
+ customAuthorizer.connectPolicies("a", "c", null, null, new WebSocketUpgrade(Map.of(), NAME_PARAM + "a", null, null));
+
+ assertEquals("{\"protocolData\":{\"mqtt\":{\"clientId\":\"c\"},\"http\":{\"headers\":{},"
+ + "\"queryString\":\"x-amz-customauthorizer-name=a\"}},\"protocols\":[\"http\",\"mqtt\"],"
+ + "\"signatureVerified\":false,\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void aPlainTcpConnectSendsOnlyMqtt() {
+ customAuthorizer.connectPolicies("a", "c", "c?" + NAME_PARAM + "a", null, null);
+
+ assertEquals("{\"protocolData\":{\"mqtt\":{\"username\":\"c?x-amz-customauthorizer-name=a\",\"clientId\":\"c\"}},"
+ + "\"protocols\":[\"mqtt\"],\"signatureVerified\":false,\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void aDenyOrAnEmptyPolicyListAdmitsNoPolicies() {
+ answer = "{\"isAuthenticated\": false, \"principalId\": \"p1\", \"policyDocuments\": [" + quoted(POLICY) + "]}";
+ assertEquals(List.of(), connect("a"));
+
+ answer = response("[]", null);
+ assertEquals(List.of(), connect("a"));
+ }
+
+ @Test
+ void anObjectPolicyReachesTheConnectAsACompactString() throws Exception {
+ answer = response("[" + POLICY + "]", null);
+
+ assertEquals(List.of(mapper.writeValueAsString(mapper.readTree(POLICY))), connect("a"));
+ }
+
+ @Test
+ void anInvalidAnswerFailsTheConnect() {
+ answer = "{\"isAuthenticated\": false}";
+
+ assertAwsError("InvalidResponseException", 400, "null" + PRINCIPAL_CONSTRAINT, () -> connect("a"));
+ }
+
+ @Test
+ void anInactiveAuthorizerAdmitsNothingWithoutInvokingTheFunction() {
+ assertEquals(List.of(), connect("off"));
+ verifyNotInvoked();
+ }
+
+ @Test
+ void anUnknownAuthorizerFailsTheConnectWithoutInvokingTheFunction() {
+ assertThrows(AwsException.class, () -> connect("nope"));
+ verifyNotInvoked();
+ }
+
+ @Test
+ void aSignedConnectSendsTheTokenAfterTheProtocols() throws GeneralSecurityException {
+ String username = signedUsername(sign(key2, "allow-me"), "allow-me");
+
+ customAuthorizer.connectPolicies("s", "c", username, null, null);
+
+ assertEquals("{\"protocolData\":{\"mqtt\":{\"username\":" + quoted(username) + ",\"clientId\":\"c\"}},"
+ + "\"protocols\":[\"mqtt\"],\"token\":\"allow-me\",\"signatureVerified\":true,"
+ + "\"connectionMetadata\":{\"id\":\"ID\"}}", lastEvent());
+ }
+
+ @Test
+ void aSignedConnectReadsTokenAndSignatureFromTheWebSocketQueryOrHeaders() throws GeneralSecurityException {
+ String signature = sign(key1, "allow-me");
+
+ customAuthorizer.connectPolicies("s", "c", "c", null, new WebSocketUpgrade(Map.of(),
+ NAME_PARAM + "s&" + SIGNATURE_PARAM + urlEncoded(signature) + "&tok=allow-me", null, null));
+ assertEquals("allow-me", events.getLast().path("token").asText());
+
+ customAuthorizer.connectPolicies("s", "c", "c", null, new WebSocketUpgrade(
+ Map.of("x-amz-customauthorizer-signature", signature, "tok", "allow-me"), "", null, null));
+ assertEquals("allow-me", events.getLast().path("token").asText());
+ }
+
+ @Test
+ void aSignedConnectWithABadOrMissingSignatureNeverInvokesTheFunction() throws GeneralSecurityException {
+ String overOtherToken = signedUsername(sign(key1, "other-token"), "allow-me");
+ String withoutToken = "c?" + NAME_PARAM + "s&" + SIGNATURE_PARAM + urlEncoded(sign(key1, "allow-me"));
+
+ for (String username : List.of(overOtherToken, withoutToken, "c?" + NAME_PARAM + "s&tok=allow-me")) {
+ assertThrows(AwsException.class, () -> customAuthorizer.connectPolicies("s", "c", username, null, null), username);
+ }
+ verifyNotInvoked();
+ }
+
+ @Test
+ void theAuthorizerNameComesFromTheUsernameTheWebSocketQueryOrTheUpgradeHeader() {
+ assertEquals("u", IotCustomAuthorizer.authorizerName("c?" + NAME_PARAM + "u&tok=t", null));
+ assertEquals("q", IotCustomAuthorizer.authorizerName("c", new WebSocketUpgrade(Map.of(), NAME_PARAM + "q", null, null)));
+ assertEquals("h", IotCustomAuthorizer.authorizerName(null,
+ new WebSocketUpgrade(Map.of("x-amz-customauthorizer-name", "h"), "", null, null)));
+ }
+
+ @Test
+ void aConnectNamingNoAuthorizerHasNoName() {
+ assertNull(IotCustomAuthorizer.authorizerName(null, null));
+ assertNull(IotCustomAuthorizer.authorizerName("plain-user", null));
+ assertNull(IotCustomAuthorizer.authorizerName("c?X-Amz-Algorithm=AWS4-HMAC-SHA256", new WebSocketUpgrade(
+ Map.of("sec-websocket-protocol", "mqtt"), "X-Amz-Signature=00", null, null)));
+ assertEquals("%zz", IotCustomAuthorizer.authorizerName("c?" + NAME_PARAM + "%zz", null),
+ "a malformed escape is kept as sent instead of failing the CONNECT");
+ }
+
+ // Helpers
+
+ private void create(String name, String status, boolean signed) {
+ ObjectNode body = mapper.createObjectNode().put("authorizerFunctionArn", FUNCTION_ARN).put("status", status);
+ if (signed) {
+ body.put("tokenKeyName", "tok");
+ body.putObject("tokenSigningPublicKeys").put("k1", pem(key1)).put("k2", pem(key2));
+ } else {
+ body.put("signingDisabled", true);
+ }
+ authorizers.createAuthorizer(name, body, REGION);
+ }
+
+ private ObjectNode testInvoke() {
+ return customAuthorizer.testInvoke("a", request("{\"mqttContext\": {\"clientId\": \"c\", \"password\": \"c2VjcmV0\"}}"),
+ REGION);
+ }
+
+ private List<String> connect(String name) {
+ return customAuthorizer.connectPolicies(name, "c", "c?" + NAME_PARAM + name, "secret", null);
+ }
+
+ private ObjectNode request(String json) {
+ try {
+ return (ObjectNode) mapper.readTree(json);
+ } catch (Exception e) {
+ throw new IllegalArgumentException(json, e);
+ }
+ }
+
+ private ObjectNode tokenRequest(String token, String signature) {
+ return mapper.createObjectNode().put("token", token).put("tokenSignature", signature);
+ }
+
+ /** The last event the function received, with its random connection id replaced by {@code ID}. */
+ private String lastEvent() {
+ ObjectNode event = (ObjectNode) events.getLast().deepCopy();
+ ((ObjectNode) event.get("connectionMetadata")).put("id", "ID");
+ return event.toString();
+ }
+
+ private void verifyNotInvoked() {
+ verify(lambda, never()).invokeArn(anyString(), any(byte[].class), any(InvocationType.class));
+ }
+
+ private static String response(String policies, String ttls) {
+ return "{\"isAuthenticated\": true, \"principalId\": \"p1\", \"policyDocuments\": " + policies
+ + (ttls == null ? "" : ", " + ttls) + "}";
+ }
+
+ private static String quoted(String text) {
+ return "\"" + text.replace("\\", "\\\\").replace("\"", "\\\"") + "\"";
+ }
+
+ private static String signedUsername(String signature, String token) {
+ return "c?" + NAME_PARAM + "s&" + SIGNATURE_PARAM + urlEncoded(signature) + "&tok=" + token;
+ }
+
+ private static String urlEncoded(String value) {
+ return URLEncoder.encode(value, StandardCharsets.UTF_8);
+ }
+
+ private static String sign(KeyPair key, String token) throws GeneralSecurityException {
+ PrivateKey privateKey = key.getPrivate();
+ Signature signature = Signature.getInstance("SHA256withRSA");
+ signature.initSign(privateKey);
+ signature.update(token.getBytes(StandardCharsets.UTF_8));
+ return Base64.getEncoder().encodeToString(signature.sign());
+ }
+
+ private static String pem(KeyPair key) {
+ return "-----BEGIN PUBLIC KEY-----\n"
+ + Base64.getMimeEncoder(64, "\n".getBytes(StandardCharsets.US_ASCII)).encodeToString(key.getPublic().getEncoded())
+ + "\n-----END PUBLIC KEY-----";
+ }
+
+ private void assertInvalidRequest(String message, Executable call) {
+ assertAwsError("InvalidRequestException", 400, message, call);
+ verifyNotInvoked();
+ }
+
+ private static void assertAwsError(String code, int status, String message, Executable call) {
+ AwsException failure = assertThrows(AwsException.class, call);
+ assertEquals(code, failure.getErrorCode());
+ assertEquals(status, failure.getHttpStatus());
+ assertEquals(message, failure.getMessage());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerDeviceVerificationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerDeviceVerificationTest.java
index 06176fbdc1..5eda9573fe 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerDeviceVerificationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerDeviceVerificationTest.java
@@ -108,7 +108,7 @@ class IotMqttBrokerDeviceVerificationTest {
.addCertValue(Buffer.buffer(serverLeaf.certificatePem()))
.addKeyValue(Buffer.buffer(serverLeaf.privateKeyPem())));
when(iotService.get()).thenReturn(service);
- broker = new IotMqttBrokerService(config, vertx, iotService, registry);
+ broker = new IotMqttBrokerService(config, vertx, iotService, mock(IotCustomAuthorizer.class), registry);
broker.startIfEnabled();
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerServiceTest.java
index 0394f01a05..616207b751 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttBrokerServiceTest.java
@@ -32,6 +32,7 @@ import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.net.KeyCertOptions;
import io.vertx.core.net.PemKeyCertOptions;
+import io.vertx.core.net.SocketAddress;
import io.vertx.mqtt.MqttEndpoint;
import io.vertx.mqtt.MqttTopicSubscription;
import io.vertx.mqtt.messages.MqttSubscribeMessage;
@@ -68,6 +69,7 @@ import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
@@ -93,6 +95,7 @@ import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
@@ -130,6 +133,7 @@ class IotMqttBrokerServiceTest {
private final TlsConfiguration tls = mock(TlsConfiguration.class);
@SuppressWarnings("unchecked")
private final Instance<IotService> iotService = mock(Instance.class);
+ private final IotCustomAuthorizer customAuthorizer = mock(IotCustomAuthorizer.class);
private int plainPort;
private int tlsPort;
private IotMqttBrokerService broker;
@@ -162,7 +166,7 @@ class IotMqttBrokerServiceTest {
when(config.tls().enabled()).thenReturn(true);
when(registry.getDefault()).thenReturn(Optional.of(tls));
when(tls.getKeyStoreOptions()).thenReturn(pem(bootLeaf));
- broker = new IotMqttBrokerService(config, vertx, iotService, registry);
+ broker = new IotMqttBrokerService(config, vertx, iotService, customAuthorizer, registry);
}
@AfterEach
@@ -481,6 +485,29 @@ class IotMqttBrokerServiceTest {
}
}
+ /**
+ * A WebSocket client's CONNECT reaches the broker from the bridge's loopback socket, so the
+ * policies its custom authorizer returns are evaluated against the address the bridge recorded
+ * for the WebSocket client.
+ */
+ @Test
+ void aWebSocketConnectThroughACustomAuthorizerIsEvaluatedAgainstTheWebSocketClientsAddress() {
+ IotService service = mock(IotService.class);
+ when(iotService.get()).thenReturn(service);
+ when(customAuthorizer.connectPolicies(eq("ws-auth"), eq("ws-client"), any(), any(), any()))
+ .thenReturn(List.of("{}"));
+ SocketAddress bridge = SocketAddress.inetSocketAddress(50123, "127.0.0.1");
+ broker.webSocketUpgrades().put(bridge, new IotCustomAuthorizer.WebSocketUpgrade(
+ Map.of(), IotCustomAuthorizer.NAME_PARAM + "=ws-auth", null, "203.0.113.7"));
+ MqttEndpoint endpoint = mock(MqttEndpoint.class);
+ when(endpoint.clientIdentifier()).thenReturn("ws-client");
+ when(endpoint.remoteAddress()).thenReturn(bridge);
+
+ broker.handleEndpoint(endpoint, false);
+
+ verify(service, timeout(10_000)).isConnectAllowedBy(List.of("{}"), "ws-client", "203.0.113.7", null);
+ }
+
/**
* Two publishes from two connections, the first one's rule action held on a latch: the second
* publish is fanned out, so its rules were handed over, yet they start only once the first
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridgeTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridgeTest.java
index 52d78c4009..037943dfe7 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridgeTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridgeTest.java
@@ -3,9 +3,17 @@ package io.github.hectorvent.floci.services.iot;
import io.vertx.core.Handler;
import io.vertx.core.http.ServerWebSocket;
import io.vertx.core.net.NetSocket;
+import io.vertx.core.net.SocketAddress;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyShort;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
@@ -22,7 +30,7 @@ class IotMqttWebSocketBridgeTest {
when(webSocket.isClosed()).thenReturn(false);
IotMqttWebSocketBridge.BridgeSession session =
- new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket, () -> { });
session.start();
ArgumentCaptor<Handler<Void>> closeCaptor = ArgumentCaptor.forClass(Handler.class);
@@ -44,7 +52,7 @@ class IotMqttWebSocketBridgeTest {
when(webSocket.isClosed()).thenReturn(false);
IotMqttWebSocketBridge.BridgeSession session =
- new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket, () -> { });
session.start();
ArgumentCaptor<Handler<Void>> closeCaptor = ArgumentCaptor.forClass(Handler.class);
@@ -66,7 +74,7 @@ class IotMqttWebSocketBridgeTest {
when(webSocket.isClosed()).thenReturn(false);
IotMqttWebSocketBridge.BridgeSession session =
- new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket, () -> { });
session.start();
ArgumentCaptor<Handler<Throwable>> exceptionCaptor = ArgumentCaptor.forClass(Handler.class);
@@ -89,7 +97,7 @@ class IotMqttWebSocketBridgeTest {
when(webSocket.isClosed()).thenReturn(false);
IotMqttWebSocketBridge.BridgeSession session =
- new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket, () -> { });
session.start();
ArgumentCaptor<Handler<Void>> closeCaptor = ArgumentCaptor.forClass(Handler.class);
@@ -104,4 +112,44 @@ class IotMqttWebSocketBridgeTest {
verify(webSocket, never()).close();
verify(webSocket, never()).close(anyShort(), anyString());
}
+
+ @Test
+ void everyWayTheSessionEndsRunsTheCloseHookOnce() {
+ for (int path = 0; path < 3; path++) {
+ ServerWebSocket webSocket = mock(ServerWebSocket.class);
+ NetSocket socket = mock(NetSocket.class);
+ AtomicInteger hooks = new AtomicInteger();
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket, hooks::incrementAndGet).start();
+ ArgumentCaptor<Handler<Void>> socketClose = ArgumentCaptor.forClass(Handler.class);
+ verify(socket).closeHandler(socketClose.capture());
+ ArgumentCaptor<Handler<Void>> webSocketClose = ArgumentCaptor.forClass(Handler.class);
+ verify(webSocket).closeHandler(webSocketClose.capture());
+ ArgumentCaptor<Handler<Throwable>> failure = ArgumentCaptor.forClass(Handler.class);
+ verify(socket).exceptionHandler(failure.capture());
+
+ switch (path) {
+ case 0 -> socketClose.getValue().handle(null);
+ case 1 -> webSocketClose.getValue().handle(null);
+ default -> failure.getValue().handle(new IllegalStateException("broker failed"));
+ }
+ socketClose.getValue().handle(null);
+ webSocketClose.getValue().handle(null);
+
+ assertEquals(1, hooks.get(), "path " + path);
+ }
+ }
+
+ @Test
+ void closingAnOlderSessionKeepsANewerSessionsEqualUpgradeOnTheSameAddress() {
+ SocketAddress address = SocketAddress.inetSocketAddress(50000, "127.0.0.1");
+ IotCustomAuthorizer.WebSocketUpgrade older = new IotCustomAuthorizer.WebSocketUpgrade(Map.of("host", "h"), "", null, null);
+ IotCustomAuthorizer.WebSocketUpgrade newer = new IotCustomAuthorizer.WebSocketUpgrade(Map.of("host", "h"), "", null, null);
+ Map<SocketAddress, IotCustomAuthorizer.WebSocketUpgrade> upgrades = new ConcurrentHashMap<>(Map.of(address, newer));
+
+ IotMqttWebSocketBridge.forgetting(upgrades, address, older).run();
+ assertSame(newer, upgrades.get(address));
+
+ IotMqttWebSocketBridge.forgetting(upgrades, address, newer).run();
+ assertTrue(upgrades.isEmpty());
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java
index 8d82c0c5f9..e262f86247 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java
@@ -128,12 +128,12 @@ public class IotMqttWebSocketIntegrationTest {
}
@Test
- void customAuthorizerStyleConnectIsAccepted() throws Exception {
+ void connectNamingAnUnknownCustomAuthorizerIsRefused() {
String clientId = "tunnel-" + System.nanoTime();
String username = clientId + "?x-amz-customauthorizer-name=my-authorizer";
- try (WsClient client = WsClient.connect(wss("/mqtt"), clientId, username, "token-" + System.nanoTime())) {
- assertTrue(client.isConnected());
- }
+ MqttException refused = assertThrows(MqttException.class,
+ () -> WsClient.connect(wss("/mqtt"), clientId, username, "token-" + System.nanoTime()));
+ assertEquals(MqttException.REASON_CODE_CONNECTION_LOST, refused.getReasonCode());
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceDeviceAuthTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceDeviceAuthTest.java
index 5d7b34fc58..3bc5c4967d 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceDeviceAuthTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceDeviceAuthTest.java
@@ -396,6 +396,27 @@ class IotServiceDeviceAuthTest {
assertFalse(connect(device, "sensor-1"));
}
+ @Test
+ void customAuthorizerPoliciesAllowTheClientArnOfTheDefaultAccountAndRegion() {
+ String onlySensor1 = statement("Allow", "arn:aws:iot:" + REGION + ":" + ACCOUNT + ":client/sensor-1", null);
+
+ assertTrue(service.isConnectAllowedBy(List.of(onlySensor1), "sensor-1", "127.0.0.1", null));
+ assertFalse(service.isConnectAllowedBy(List.of(onlySensor1), "sensor-2", "127.0.0.1", null));
+ assertFalse(service.isConnectAllowedBy(List.of(statement("Allow", "arn:aws:iot:eu-west-1:" + ACCOUNT + ":client/sensor-1",
+ null)), "sensor-1", "127.0.0.1", null), "a client ARN in another region");
+ assertFalse(service.isConnectAllowedBy(List.of(), "sensor-1", "127.0.0.1", null), "no policy means deny");
+ }
+
+ @Test
+ void customAuthorizerPoliciesResolveTheConnectionVariables() {
+ String policy = statement("Allow", "arn:aws:iot:*:*:client/${iot:ClientId}",
+ "{\"StringEquals\":{\"iot:DomainName\":\"iot.example.com\"},\"IpAddress\":{\"aws:SourceIp\":\"10.0.0.0/8\"}}");
+
+ assertTrue(service.isConnectAllowedBy(List.of(policy), "sensor-1", "10.1.2.3", "iot.example.com"));
+ assertFalse(service.isConnectAllowedBy(List.of(policy), "sensor-1", "127.0.0.1", "iot.example.com"));
+ assertFalse(service.isConnectAllowedBy(List.of(policy), "sensor-1", "10.1.2.3", null));
+ }
+
private RegisteredDevice registeredDevice(boolean active) {
IotCertificate created = service.createKeysAndCertificate(active, REGION);
return service.findRegisteredCertificate(parse(created)).orElseThrow();