Light, fluffy, and always free - The AWS Local Emulator alternative
fix(kinesis): reject non-string tag members instead of coercing them (#3099)
soreavisfcb5bd02c02e
diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.javaindex 4acd87af21..ec0b8f056f 100644--- a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java@@ -118,13 +118,15 @@ public class KinesisJsonHandler {streamMode = mode;}}- service.createStream(streamName, shardCount, streamMode,- optionalMaxRecordSize(request), region);// CreateStream's optional Tags member was being dropped. That is invisible to a// hand-written script but not to Terraform: aws_kinesis_stream sets tags at create// time and then reads them back with ListTagsForStream, so an empty read produces a// permanent "tags will be updated in-place" diff on an unchanged configuration.+ // Parsed before the stream exists so a malformed Tags member rejects the whole+ // request instead of leaving an untagged stream behind.Map<String, String> tags = parseTags(request);+ service.createStream(streamName, shardCount, streamMode,+ optionalMaxRecordSize(request), region);if (!tags.isEmpty()) {service.addTagsToStream(streamName, tags, region);}@@ -406,8 +408,19 @@ public class KinesisJsonHandler {private Response handleRemoveTagsFromStream(JsonNode request, String region) {String streamName = resolveStreamName(request);- java.util.List<String> tagKeys = new java.util.ArrayList<>();- request.path("TagKeys").forEach(node -> tagKeys.add(node.asText()));+ JsonNode tagKeysNode = request.path("TagKeys");+ List<String> tagKeys = new ArrayList<>();+ if (!tagKeysNode.isMissingNode() && !tagKeysNode.isNull()) {+ if (!tagKeysNode.isArray()) {+ throw new AwsException("SerializationException", "TagKeys must be a list of strings.", 400);+ }+ for (JsonNode node : tagKeysNode) {+ if (!node.isTextual()) {+ throw new AwsException("SerializationException", "TagKeys must be a list of strings.", 400);+ }+ tagKeys.add(node.textValue());+ }+ }service.removeTagsFromStream(streamName, tagKeys, region);return Response.ok(objectMapper.createObjectNode()).build();}@@ -428,12 +441,24 @@ public class KinesisJsonHandler {// Shared by CreateStream and AddTagsToStream so the two paths cannot drift: the same// request shape has to produce the same stored tags whichever operation carries it.- // A missing or non-object Tags member yields an empty map rather than an error, which- // is what AddTagsToStream already did before CreateStream started calling this.+ // A missing or null Tags member yields an empty map; anything else that is not a map+ // of strings is a wire deserialization error rather than a value to coerce, so a+ // number or boolean is rejected instead of being stored as its text.private Map<String, String> parseTags(JsonNode request) {Map<String, String> tags = new HashMap<>();- request.path("Tags").fields()- .forEachRemaining(entry -> tags.put(entry.getKey(), entry.getValue().asText()));+ JsonNode tagsNode = request.path("Tags");+ if (tagsNode.isMissingNode() || tagsNode.isNull()) {+ return tags;+ }+ if (!tagsNode.isObject()) {+ throw new AwsException("SerializationException", "Tags must be a map of string values.", 400);+ }+ tagsNode.fields().forEachRemaining(entry -> {+ if (!entry.getValue().isTextual()) {+ throw new AwsException("SerializationException", "Tags must be a map of string values.", 400);+ }+ tags.put(entry.getKey(), entry.getValue().textValue());+ });return tags;}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisIntegrationTest.javaindex 751963c878..df4aa5c7d6 100644--- a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisIntegrationTest.java@@ -1319,4 +1319,35 @@ class KinesisIntegrationTest {buf.get(payload);return new ObjectMapper().readTree(payload);}++ @Test+ @Order(67)+ void createStreamRejectsANonStringTagValueWithSerializationException() {+ // A non-string tag value is a wire deserialization error, not a value to coerce:+ // it used to be stored as its text ("5"), and the stream was created before the+ // tags were parsed. Now the whole request is rejected and nothing is created.+ given()+ .header("X-Amz-Target", "Kinesis_20131202.CreateStream")+ .contentType(KINESIS_CONTENT_TYPE)+ .body("""+ {"StreamName": "create-with-bad-tags", "ShardCount": 1, "Tags": {"Foo": 5}}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("SerializationException"));++ given()+ .header("X-Amz-Target", "Kinesis_20131202.DescribeStream")+ .contentType(KINESIS_CONTENT_TYPE)+ .body("""+ {"StreamName": "create-with-bad-tags"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ResourceNotFoundException"));+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.javaindex 8b267385e7..4beef11368 100644--- a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.kinesis;+import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.BinaryNode;@@ -1220,4 +1221,148 @@ class KinesisJsonHandlerTest {assertEquals(Map.of("Foo", "Bar", "gw:example", "kinesis"),service.listTagsForStream("test-stream", REGION));}++ @Test+ void createStreamRejectsANonStringTagValueBeforeCreatingTheStream() {+ for (ObjectNode tags : nonStringTagValues()) {+ ObjectNode create = MAPPER.createObjectNode();+ create.put("StreamName", "rejected-tags-stream");+ create.put("ShardCount", 1);+ create.set("Tags", tags);+ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("CreateStream", create, REGION));+ assertEquals("SerializationException", ex.getErrorCode());+ assertEquals("Tags must be a map of string values.", ex.getMessage());+ assertEquals(400, ex.getHttpStatus());+ }++ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("StreamName", "rejected-tags-stream");+ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("DescribeStream", describe, REGION));+ assertEquals("ResourceNotFoundException", ex.getErrorCode());+ }++ @Test+ void createStreamRejectsANonObjectTagsMember() {+ for (JsonNode tags : List.of(MAPPER.getNodeFactory().textNode("Foo=Bar"),+ MAPPER.getNodeFactory().numberNode(5), MAPPER.createArrayNode().add("Foo"))) {+ ObjectNode create = MAPPER.createObjectNode();+ create.put("StreamName", "rejected-tags-stream");+ create.put("ShardCount", 1);+ create.set("Tags", tags);+ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("CreateStream", create, REGION));+ assertEquals("SerializationException", ex.getErrorCode());+ }+ }++ @Test+ void createStreamWithANullTagsMemberLeavesTheStreamUntagged() {+ ObjectNode create = MAPPER.createObjectNode();+ create.put("StreamName", "null-tags-stream");+ create.put("ShardCount", 1);+ create.putNull("Tags");+ assertThat(handler.handle("CreateStream", create, REGION).getStatus(), is(200));++ assertTrue(service.listTagsForStream("null-tags-stream", REGION).isEmpty());+ }++ @Test+ void addTagsToStreamRejectsANonStringTagValueWithoutTouchingExistingTags() {+ createStream("test-stream");+ ObjectNode add = MAPPER.createObjectNode();+ add.put("StreamName", "test-stream");+ add.putObject("Tags").put("Foo", "Bar");+ assertThat(handler.handle("AddTagsToStream", add, REGION).getStatus(), is(200));++ for (ObjectNode tags : nonStringTagValues()) {+ ObjectNode bad = MAPPER.createObjectNode();+ bad.put("StreamName", "test-stream");+ bad.set("Tags", tags);+ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("AddTagsToStream", bad, REGION));+ assertEquals("SerializationException", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ }++ assertEquals(Map.of("Foo", "Bar"), service.listTagsForStream("test-stream", REGION));+ }++ @Test+ void removeTagsFromStreamRejectsANonStringTagKey() {+ createStream("test-stream");+ ObjectNode add = MAPPER.createObjectNode();+ add.put("StreamName", "test-stream");+ add.putObject("Tags").put("Foo", "Bar");+ assertThat(handler.handle("AddTagsToStream", add, REGION).getStatus(), is(200));++ for (JsonNode tagKeys : List.of(MAPPER.createArrayNode().add(5), MAPPER.createArrayNode().add(true),+ MAPPER.createArrayNode().addNull(), MAPPER.createArrayNode().add("Foo").add(5),+ MAPPER.getNodeFactory().textNode("Foo"), MAPPER.createObjectNode().put("a", "Foo"))) {+ ObjectNode remove = MAPPER.createObjectNode();+ remove.put("StreamName", "test-stream");+ remove.set("TagKeys", tagKeys);+ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("RemoveTagsFromStream", remove, REGION));+ assertEquals("SerializationException", ex.getErrorCode());+ assertEquals("TagKeys must be a list of strings.", ex.getMessage());+ assertEquals(400, ex.getHttpStatus());+ }++ assertEquals(Map.of("Foo", "Bar"), service.listTagsForStream("test-stream", REGION));+ }++ @Test+ void removeTagsFromStreamStillRemovesStringTagKeys() {+ createStream("test-stream");+ ObjectNode add = MAPPER.createObjectNode();+ add.put("StreamName", "test-stream");+ add.putObject("Tags").put("Foo", "Bar").put("Baz", "Qux");+ assertThat(handler.handle("AddTagsToStream", add, REGION).getStatus(), is(200));++ ObjectNode remove = MAPPER.createObjectNode();+ remove.put("StreamName", "test-stream");+ remove.putArray("TagKeys").add("Foo");+ assertThat(handler.handle("RemoveTagsFromStream", remove, REGION).getStatus(), is(200));++ assertEquals(Map.of("Baz", "Qux"), service.listTagsForStream("test-stream", REGION));+ }++ @Test+ void removeTagsFromStreamWithANullOrMissingTagKeysLeavesTagsUntouched() {+ createStream("test-stream");+ ObjectNode add = MAPPER.createObjectNode();+ add.put("StreamName", "test-stream");+ add.putObject("Tags").put("Foo", "Bar");+ assertThat(handler.handle("AddTagsToStream", add, REGION).getStatus(), is(200));++ ObjectNode nullKeys = MAPPER.createObjectNode();+ nullKeys.put("StreamName", "test-stream");+ nullKeys.putNull("TagKeys");+ assertThat(handler.handle("RemoveTagsFromStream", nullKeys, REGION).getStatus(), is(200));+ ObjectNode missingKeys = MAPPER.createObjectNode();+ missingKeys.put("StreamName", "test-stream");+ assertThat(handler.handle("RemoveTagsFromStream", missingKeys, REGION).getStatus(), is(200));++ assertEquals(Map.of("Foo", "Bar"), service.listTagsForStream("test-stream", REGION));+ }++ /** Every non-string tag value shape — number, boolean, null, object, array — plus a map mixing a valid and an invalid value. */+ private static List<ObjectNode> nonStringTagValues() {+ ObjectNode number = MAPPER.createObjectNode();+ number.put("Foo", 5);+ ObjectNode bool = MAPPER.createObjectNode();+ bool.put("Foo", true);+ ObjectNode nul = MAPPER.createObjectNode();+ nul.putNull("Foo");+ ObjectNode object = MAPPER.createObjectNode();+ object.putObject("Foo");+ ObjectNode array = MAPPER.createObjectNode();+ array.putArray("Foo");+ ObjectNode mixed = MAPPER.createObjectNode();+ mixed.put("Foo", "Bar");+ mixed.put("Baz", 5);+ return List.of(number, bool, nul, object, array, mixed);+ }}