Skip to content

armgit / floci

Public Imported from GitHub
0

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

fix(ssm): resolve Secrets Manager references in GetParameter (#4581)

Mario Toffia86c4904bcc26
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SsmSecretsManagerReferenceTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SsmSecretsManagerReferenceTest.java
new file mode 100644
index 0000000000..ef4ce6a1c6
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SsmSecretsManagerReferenceTest.java
@@ -0,0 +1,118 @@
+package com.floci.test;
+
+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 software.amazon.awssdk.services.cloudformation.CloudFormationClient;
+import software.amazon.awssdk.services.cloudformation.model.CreateStackRequest;
+import software.amazon.awssdk.services.cloudformation.model.DeleteStackRequest;
+import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
+import software.amazon.awssdk.services.secretsmanager.model.CreateSecretResponse;
+import software.amazon.awssdk.services.secretsmanager.model.DeleteSecretRequest;
+import software.amazon.awssdk.services.ssm.SsmClient;
+import software.amazon.awssdk.services.ssm.model.GetParametersResponse;
+import software.amazon.awssdk.services.ssm.model.Parameter;
+import software.amazon.awssdk.services.ssm.model.ParameterNotFoundException;
+import software.amazon.awssdk.services.ssm.model.ParameterType;
+import software.amazon.awssdk.services.ssm.model.SsmException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("SSM references to Secrets Manager secrets")
+class SsmSecretsManagerReferenceTest {
+
+ private static final String PREFIX = "/aws/reference/secretsmanager/";
+
+ private static SsmClient ssm;
+ private static SecretsManagerClient secretsManager;
+ private static CloudFormationClient cloudFormation;
+ private static final List<String> secrets = new ArrayList<>();
+ private static final List<String> stacks = new ArrayList<>();
+
+ @BeforeAll
+ static void setup() {
+ ssm = TestFixtures.ssmClient();
+ secretsManager = TestFixtures.secretsManagerClient();
+ cloudFormation = TestFixtures.cloudFormationClient();
+ }
+
+ @AfterAll
+ static void cleanup() {
+ for (String stack : stacks) {
+ cloudFormation.deleteStack(DeleteStackRequest.builder().stackName(stack).build());
+ }
+ for (String secret : secrets) {
+ secretsManager.deleteSecret(DeleteSecretRequest.builder()
+ .secretId(secret).forceDeleteWithoutRecovery(true).build());
+ }
+ ssm.close();
+ secretsManager.close();
+ cloudFormation.close();
+ }
+
+ @Test
+ @DisplayName("reads a secret created through Secrets Manager")
+ void readsASecretCreatedThroughSecretsManager() {
+ String name = TestFixtures.uniqueName("ssm-ref-sm");
+ CreateSecretResponse created = secretsManager.createSecret(r -> r.name(name).secretString("s3cr3t"));
+ secrets.add(name);
+
+ Parameter parameter = ssm.getParameter(r -> r.name(PREFIX + name).withDecryption(true)).parameter();
+
+ assertThat(parameter.name()).isEqualTo(PREFIX + name);
+ assertThat(parameter.value()).isEqualTo("s3cr3t");
+ assertThat(parameter.type()).isEqualTo(ParameterType.SECURE_STRING);
+ assertThat(parameter.arn()).isEqualTo(created.arn());
+ assertThat(parameter.sourceResult()).startsWith("{\"ARN\":\"" + created.arn() + "\"")
+ .contains("\"secretString\":\"s3cr3t\"");
+ assertRefusedWithoutDecryption(name);
+ }
+
+ @Test
+ @DisplayName("reads a secret created through CloudFormation")
+ void readsASecretCreatedThroughCloudFormation() {
+ String name = TestFixtures.uniqueName("ssm-ref-cfn");
+ String stack = TestFixtures.uniqueName("ssm-ref-cfn-stack");
+ cloudFormation.createStack(CreateStackRequest.builder().stackName(stack).templateBody("""
+ {"Resources": {"Key": {"Type": "AWS::SecretsManager::Secret", "Properties": {
+ "Name": "%s", "GenerateSecretString": {"PasswordLength": 40, "ExcludePunctuation": true}}}}}
+ """.formatted(name)).build());
+ stacks.add(stack);
+ cloudFormation.waiter().waitUntilStackCreateComplete(r -> r.stackName(stack));
+
+ String generated = secretsManager.getSecretValue(r -> r.secretId(name)).secretString();
+ Parameter parameter = ssm.getParameter(r -> r.name(PREFIX + name).withDecryption(true)).parameter();
+
+ assertThat(parameter.value()).hasSize(40).isEqualTo(generated);
+ assertRefusedWithoutDecryption(name);
+ }
+
+ @Test
+ @DisplayName("a missing secret is ParameterNotFound")
+ void missingSecretIsParameterNotFound() {
+ String name = TestFixtures.uniqueName("ssm-ref-missing");
+
+ assertThatThrownBy(() -> ssm.getParameter(r -> r.name(PREFIX + name).withDecryption(true)))
+ .isInstanceOf(ParameterNotFoundException.class);
+
+ GetParametersResponse batch = ssm.getParameters(r -> r.names(PREFIX + name).withDecryption(true));
+ assertThat(batch.parameters()).isEmpty();
+ assertThat(batch.invalidParameters()).containsExactly(PREFIX + name);
+ }
+
+ private static void assertRefusedWithoutDecryption(String name) {
+ assertThatThrownBy(() -> ssm.getParameter(r -> r.name(PREFIX + name).withDecryption(false)))
+ .isInstanceOf(SsmException.class)
+ .hasMessageContaining("WithDecryption flag must be True")
+ .extracting(e -> ((SsmException) e).awsErrorDetails().errorCode())
+ .isEqualTo("ValidationException");
+ assertThatThrownBy(() -> ssm.getParameter(r -> r.name(PREFIX + name)))
+ .isInstanceOf(SsmException.class)
+ .hasMessageContaining("WithDecryption flag must be True");
+ }
+}
diff --git a/docs/services/ssm.md b/docs/services/ssm.md
index 1410110507..146e1281ad 100644
--- a/docs/services/ssm.md
+++ b/docs/services/ssm.md
@@ -111,6 +111,24 @@ aws ssm get-parameter --name /aws/service/ami-amazon-linux-latest/al2023-ami-ker
aws ssm get-parameter --name /aws/service/eks/optimized-ami/1.31/amazon-linux-2023/x86_64/standard/recommended/image_id
```
+## Secrets Manager References
+
+`GetParameter` and `GetParameters` answer `/aws/reference/secretsmanager/<secret-id>` from
+Secrets Manager, so an application, an ECS task secret or a CodeBuild `parameter-store`
+variable can read a secret through Parameter Store.
+The answer is a `SecureString` with the secret's value and ARN and `Version` 0, and
+`SourceResult` carries the Secrets Manager `GetSecretValue` result as a JSON string, without
+`secretBinary` for a binary secret. A
+`:<version-id>` or `:<staging-label>` suffix, such as `:AWSPREVIOUS`, selects a version and is
+echoed as `Selector`. As on AWS, `WithDecryption` must be true, and a missing secret is
+`ParameterNotFound`; `GetParameters` lists a reference it cannot answer in `InvalidParameters`.
+With IAM enforcement on, the caller also needs `secretsmanager:GetSecretValue` on the secret,
+and a refusal fails the whole call with a `ValidationException`, as it does on AWS.
+
+```bash
+aws ssm get-parameter --name /aws/reference/secretsmanager/my-app/api-key --with-decryption
+```
+
## Parameter Types
All AWS parameter types are accepted: `String`, `StringList`, `SecureString`.
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java
index e3ae133b78..0653a7c81a 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java
@@ -305,7 +305,8 @@ public class AwsJson11Controller {
String region = regionResolver.resolveRegion(httpHeaders);
Response delegated = switch (serviceKey) {
- case "ssm" -> ssmJsonHandler.handle(action, request, region);
+ case "ssm" -> ssmJsonHandler.handle(
+ action, request, region, httpHeaders.getHeaderString("Authorization"));
case "events" -> eventBridgeHandler.handle(action, request, region);
case "servicediscovery" -> cloudMapHandler.handle(action, request, region);
case "elasticmapreduce" -> emrHandler.handle(action, request, region);
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java
index a70da7f159..7dd2ba57e4 100644
--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java
+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java
@@ -151,7 +151,7 @@ public class AwsServiceRouter {
case "sqs" -> sqsHandler.handle(action, requestBody, region);
case "sns" -> snsHandler.handle(action, requestBody, region);
case "events" -> eventBridgeHandler.handle(action, requestBody, region);
- case "ssm" -> ssmHandler.handle(action, requestBody, region);
+ case "ssm" -> ssmHandler.handle(action, requestBody, region, null);
case "kinesis" -> kinesisHandler.handle(action, requestBody, region);
case "logs" -> logsHandler.handle(action, requestBody, region);
case "monitoring" -> metricsHandler.handle(action, requestBody, region);
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
index 19b02fddf1..c8d969a10b 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
@@ -1221,7 +1221,8 @@ public class CloudFormationService implements ResourceProvider {
return;
}
try {
- resolved.put(e.getKey(), ssmService.getParameter(parameterName, region).getValue());
+ // A plaintext type: a Secrets Manager reference needs decryption, so it is refused.
+ resolved.put(e.getKey(), ssmService.getParameter(parameterName, false, region).getValue());
} catch (AwsException ex) {
missing.add(parameterName);
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java
index 8f2720b661..f7a98c2bab 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java
@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.ssm;
import io.github.hectorvent.floci.core.common.AwsErrorResponse;
import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.IamEnforcementFilter;
import io.github.hectorvent.floci.core.common.PaginatedResult;
import io.github.hectorvent.floci.core.common.Pagination;
import io.github.hectorvent.floci.services.ssm.model.Command;
@@ -40,20 +41,23 @@ public class SsmJsonHandler {
private final SsmService ssmService;
private final SsmCommandService commandService;
private final ObjectMapper objectMapper;
+ private final IamEnforcementFilter iamEnforcementFilter;
@Inject
- public SsmJsonHandler(SsmService ssmService, SsmCommandService commandService, ObjectMapper objectMapper) {
+ public SsmJsonHandler(SsmService ssmService, SsmCommandService commandService, ObjectMapper objectMapper,
+ IamEnforcementFilter iamEnforcementFilter) {
this.ssmService = ssmService;
this.commandService = commandService;
this.objectMapper = objectMapper;
+ this.iamEnforcementFilter = iamEnforcementFilter;
}
- public Response handle(String action, JsonNode request, String region) {
+ public Response handle(String action, JsonNode request, String region, String authorization) {
return switch (action) {
// Parameter Store
case "PutParameter" -> handlePutParameter(request, region);
- case "GetParameter" -> handleGetParameter(request, region);
- case "GetParameters" -> handleGetParameters(request, region);
+ case "GetParameter" -> handleGetParameter(request, region, authorization);
+ case "GetParameters" -> handleGetParameters(request, region, authorization);
case "GetParametersByPath" -> handleGetParametersByPath(request, region);
case "DeleteParameter" -> handleDeleteParameter(request, region);
case "DeleteParameters" -> handleDeleteParameters(request, region);
@@ -127,20 +131,26 @@ public class SsmJsonHandler {
return Response.ok(new PutParameterResponse(version)).build();
}
- private Response handleGetParameter(JsonNode request, String region) {
+ private Response handleGetParameter(JsonNode request, String region, String authorization) {
String name = request.path("Name").asText();
- Parameter param = ssmService.getParameter(name, region);
+ boolean withDecryption = request.path("WithDecryption").asBoolean(false);
+ authorizeSecretReads(List.of(name), withDecryption, region, authorization);
+ Parameter param = ssmService.getParameter(name, withDecryption, region);
+ authorizeSecretValues(List.of(param), authorization);
ObjectNode response = objectMapper.createObjectNode();
response.set("Parameter", parameterToNode(param));
return Response.ok(response).build();
}
- private Response handleGetParameters(JsonNode request, String region) {
+ private Response handleGetParameters(JsonNode request, String region, String authorization) {
List<String> names = new ArrayList<>();
request.path("Names").forEach(n -> names.add(n.asText()));
+ boolean withDecryption = request.path("WithDecryption").asBoolean(false);
+ authorizeSecretReads(names, withDecryption, region, authorization);
- List<Parameter> params = ssmService.getParameters(names, region);
+ List<Parameter> params = ssmService.getParameters(names, withDecryption, region);
+ authorizeSecretValues(params, authorization);
ObjectNode response = objectMapper.createObjectNode();
ArrayNode parametersArray = objectMapper.createArrayNode();
@@ -153,6 +163,46 @@ public class SsmJsonHandler {
return Response.ok(response).build();
}
+ /**
+ * AWS reads a reference with the caller's own {@code secretsmanager:GetSecretValue}, checked
+ * before the secret is looked up, and reports a refusal as a failed dependency call that fails
+ * the whole request.
+ */
+ private void authorizeSecretReads(List<String> names, boolean withDecryption, String region,
+ String authorization) {
+ if (!withDecryption) {
+ return;
+ }
+ for (String name : names) {
+ String secretArn = name.startsWith(SsmService.SECRET_REFERENCE_PREFIX)
+ ? ssmService.secretReferenceArn(name, region) : null;
+ if (secretArn != null) {
+ authorizeSecretRead(authorization, secretArn);
+ }
+ }
+ }
+
+ /**
+ * Checks the secret each value came from, which differs from the one checked before the read
+ * when the secret was replaced in between.
+ */
+ private void authorizeSecretValues(List<Parameter> params, String authorization) {
+ for (Parameter param : params) {
+ if (param.getName().startsWith(SsmService.SECRET_REFERENCE_PREFIX)) {
+ authorizeSecretRead(authorization, param.getArn());
+ }
+ }
+ }
+
+ private void authorizeSecretRead(String authorization, String secretArn) {
+ try {
+ iamEnforcementFilter.authorizeAdditionalResource(authorization, "secretsmanager:GetSecretValue", secretArn);
+ } catch (AwsException denied) {
+ throw new AwsException("ValidationException",
+ "An error occurred while calling one AWS dependency service.", 400);
+ }
+ }
+
private Response handleGetParametersByPath(JsonNode request, String region) {
String path = request.path("Path").asText();
boolean recursive = request.path("Recursive").asBoolean(false);
@@ -1025,15 +1075,22 @@ public class SsmJsonHandler {
private ObjectNode parameterToNode(Parameter p) {
ObjectNode node = objectMapper.createObjectNode();
node.put("Name", p.getName());
- node.put("Value", p.getValue());
+ if (p.getValue() != null) {
+ node.put("Value", p.getValue());
+ }
node.put("Type", p.getType());
node.put("Version", p.getVersion());
node.put("LastModifiedDate", p.getLastModifiedDate().toEpochMilli() / 1000.0);
node.put("ARN", p.getArn());
- node.put("DataType", p.getDataType());
+ if (p.getDataType() != null) {
+ node.put("DataType", p.getDataType());
+ }
if (p.getSelector() != null) {
node.put("Selector", p.getSelector());
}
+ if (p.getSourceResult() != null) {
+ node.put("SourceResult", p.getSourceResult());
+ }
return node;
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java
index 66d284cb77..db9ba91f35 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java
@@ -1,12 +1,23 @@
package io.github.hectorvent.floci.services.ssm;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.AwsArnUtils;
import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.resource.ExplorerResource;
+import io.github.hectorvent.floci.core.resource.ResourceProvider;
+import io.github.hectorvent.floci.core.resource.SupportedResourceType;
import io.github.hectorvent.floci.core.storage.InMemoryStorage;
import io.github.hectorvent.floci.core.storage.StorageBackend;
import io.github.hectorvent.floci.core.storage.StorageFactory;
import io.github.hectorvent.floci.services.ec2.Ec2ImageCatalog;
+import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;
+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;
+import io.github.hectorvent.floci.services.secretsmanager.model.SecretVersion;
import io.github.hectorvent.floci.services.ssm.model.Parameter;
import io.github.hectorvent.floci.services.ssm.model.ParameterHistory;
import io.github.hectorvent.floci.services.ssm.model.ParameterStringFilter;
@@ -14,17 +25,14 @@ import io.github.hectorvent.floci.services.ssm.model.PatchBaselineIdentity;
import io.github.hectorvent.floci.services.ssm.model.ServiceSetting;
import io.github.hectorvent.floci.services.ssm.model.SsmAssociation;
import io.github.hectorvent.floci.services.ssm.model.SsmDocument;
-import com.fasterxml.jackson.core.type.TypeReference;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.jboss.logging.Logger;
import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
import java.util.*;
-import io.github.hectorvent.floci.core.resource.ExplorerResource;
-import io.github.hectorvent.floci.core.resource.ResourceProvider;
-import io.github.hectorvent.floci.core.resource.SupportedResourceType;
-import io.github.hectorvent.floci.core.common.AwsArnUtils;
import java.util.ArrayList;
import java.util.Set;
@@ -34,6 +42,9 @@ public class SsmService implements ResourceProvider {
private static final Logger LOG = Logger.getLogger(SsmService.class);
private static final String PUBLIC_PARAMETER_PREFIX = "/aws/service/";
+ private static final DateTimeFormatter SOURCE_RESULT_DATE =
+ DateTimeFormatter.ofPattern("MMM d, yyyy, h:mm:ss a", Locale.US).withZone(ZoneOffset.UTC);
+ static final String SECRET_REFERENCE_PREFIX = "/aws/reference/secretsmanager/";
// Label is a ParameterStringFilter key too, but only GetParametersByPath accepts it.
private static final Set<String> DESCRIBE_PARAMETERS_FILTER_KEYS =
Set.of("Name", "Type", "KeyId", "Path", "Tier", "DataType");
@@ -59,10 +70,11 @@ public class SsmService implements ResourceProvider {
private final int maxParameterHistory;
private final RegionResolver regionResolver;
private final Ec2ImageCatalog imageCatalog;
+ private final SecretsManagerService secretsManager;
@Inject
public SsmService(StorageFactory storageFactory, EmulatorConfig config, RegionResolver regionResolver,
- Ec2ImageCatalog imageCatalog) {
+ Ec2ImageCatalog imageCatalog, SecretsManagerService secretsManager) {
this(
storageFactory.create("ssm", "ssm-parameters.json",
new TypeReference<>() {
@@ -84,7 +96,8 @@ public class SsmService implements ResourceProvider {
}),
config.services().ssm().maxParameterHistory(),
regionResolver,
- imageCatalog
+ imageCatalog,
+ secretsManager
);
}
@@ -129,7 +142,7 @@ public class SsmService implements ResourceProvider {
StorageBackend<String, SsmAssociation> associationStore,
int maxParameterHistory, RegionResolver regionResolver) {
this(parameterStore, historyStore, documentPermissionStore, documentStore,
- serviceSettingStore, associationStore, maxParameterHistory, regionResolver, null);
+ serviceSettingStore, associationStore, maxParameterHistory, regionResolver, null, null);
}
/**
@@ -143,7 +156,7 @@ public class SsmService implements ResourceProvider {
StorageBackend<String, ServiceSetting> serviceSettingStore,
StorageBackend<String, SsmAssociation> associationStore,
int maxParameterHistory, RegionResolver regionResolver,
- Ec2ImageCatalog imageCatalog) {
+ Ec2ImageCatalog imageCatalog, SecretsManagerService secretsManager) {
this.parameterStore = parameterStore;
this.historyStore = historyStore;
this.documentPermissionStore = documentPermissionStore;
@@ -153,6 +166,7 @@ public class SsmService implements ResourceProvider {
this.maxParameterHistory = maxParameterHistory;
this.regionResolver = regionResolver;
this.imageCatalog = imageCatalog;
+ this.secretsManager = secretsManager;
}
/**
@@ -204,7 +218,15 @@ public class SsmService implements ResourceProvider {
return version;
}
+ /** Reads on behalf of ECS task secrets, CodeBuild and CloudFormation ssm-secure, which decrypt. */
public Parameter getParameter(String name, String region) {
+ return getParameter(name, true, region);
+ }
+
+ public Parameter getParameter(String name, boolean withDecryption, String region) {
+ if (name != null && name.startsWith(SECRET_REFERENCE_PREFIX)) {
+ return secretReference(name, withDecryption, region);
+ }
return findParameter(name, region).orElseThrow(() -> {
int separator = name == null ? -1 : name.lastIndexOf(':');
if (separator > 0 && separator < name.length() - 1
@@ -217,14 +239,118 @@ public class SsmService implements ResourceProvider {
});
}
- public List<Parameter> getParameters(List<String> names, String region) {
+ /** A name AWS cannot answer, whatever the reason, is left out rather than failing the call. */
+ public List<Parameter> getParameters(List<String> names, boolean withDecryption, String region) {
List<Parameter> result = new ArrayList<>();
for (String name : names) {
- findParameter(name, region).ifPresent(result::add);
+ try {
+ result.add(getParameter(name, withDecryption, region));
+ } catch (AwsException e) {
+ LOG.debugv("GetParameters lists {0} as invalid: {1}", name, e.getMessage());
+ }
}
return result;
}
+ /**
+ * The resource IAM checks a reference read on: the secret's ARN, or for a secret that does not
+ * exist, the ARN a GetSecretValue by that name is checked on, so a missing secret is refused too.
+ * Null for a malformed name, which AWS rejects before it calls Secrets Manager.
+ */
+ String secretReferenceArn(String name, String region) {
+ SecretReferenceName reference = SecretReferenceName.of(name);
+ if (reference.malformed()) {
+ return null;
+ }
+ String secretId = reference.secretId();
+ try {
+ return secretsManager.describeSecret(secretId, region).getArn();
+ } catch (AwsException expected) {
+ // No such secret: check the name instead, so the caller is refused either way.
+ return regionResolver.buildArn("secretsmanager", region, "secret:" + secretId);
+ }
+ }
+
+ /**
+ * AWS answers {@code /aws/reference/secretsmanager/<secret-id>[:<version-id-or-label>]} with the
+ * secret's value. The order of the checks and the error texts are what AWS sends, including the
+ * missing slash and the "null" it prints for a name without a selector.
+ */
+ private Parameter secretReference(String name, boolean withDecryption, String region) {
+ SecretReferenceName reference = SecretReferenceName.of(name);
+ String secretId = reference.secretId();
+ String selector = reference.selector();
+ if (reference.malformed()) {
+ throw new AwsException("ValidationException", "Invalid parameter name. Please use correct syntax "
+ + "for referencing a version/label <name>:<version/label>", 400);
+ }
+ if (!withDecryption) {
+ throw new AwsException("ValidationException",
+ "WithDecryption flag must be True for retrieving a Secret Manager secret.", 400);
+ }
+ Secret secret;
+ SecretVersion version;
+ try {
+ secret = secretsManager.describeSecret(secretId, region);
+ boolean byId = selector != null && secret.getVersions().containsKey(selector);
+ // By the ARN just described, so a secret replaced in between is not found rather than read.
+ // A miss still falls back to a secret named like the ARN's last part ("app-AbCdEf"), a
+ // name AWS warns against, so that fallback is deliberately not guarded here.
+ version = secretsManager.getSecretValue(secret.getArn(), byId ? selector : null,
+ byId ? null : selector, region);
+ } catch (AwsException e) {
+ if ("ResourceNotFoundException".equals(e.getErrorCode())) {
+ throw new AwsException("ParameterNotFound", "An error occurred (ParameterNotFound) when referencing "
+ + "Secrets Manager: Secret " + name.substring(1) + (selector == null ? "null" : "")
+ + " not found.", 400);
+ }
+ throw new AwsException("ValidationException", "Invalid Request to Secrets Manager", 400);
+ }
+ Parameter parameter = new Parameter(SECRET_REFERENCE_PREFIX + secretId, version.getSecretString(), "SecureString");
+ parameter.setVersion(0);
+ parameter.setArn(secret.getArn());
+ parameter.setLastModifiedDate(version.getCreatedDate());
+ parameter.setDataType(null);
+ parameter.setSelector(selector == null ? null : ":" + selector);
+ parameter.setSourceResult(sourceResult(secret, version));
+ return parameter;
+ }
+
+ /** The secret id and the version id or staging label after the first colon, if any. */
+ private record SecretReferenceName(String secretId, String selector) {
+ static SecretReferenceName of(String name) {
+ String reference = name.substring(SECRET_REFERENCE_PREFIX.length());
+ int colon = reference.indexOf(':');
+ return colon < 0 ? new SecretReferenceName(reference, null)
+ : new SecretReferenceName(reference.substring(0, colon), reference.substring(colon + 1));
+ }
+
+ /** A trailing colon or a second one, which AWS rejects before anything else. */
+ boolean malformed() {
+ return selector != null && (selector.isEmpty() || selector.contains(":"));
+ }
+ }
+
+ /**
+ * AWS's GetSecretValue result the way SSM serializes it: Gson's field names, order and default
+ * US date format in UTC, with null fields left out.
+ */
+ private static String sourceResult(Secret secret, SecretVersion version) {
+ ObjectNode result = JsonNodeFactory.instance.objectNode()
+ .put("ARN", secret.getArn())
+ .put("name", secret.getName())
+ .put("versionId", version.getVersionId());
+ if (version.getSecretString() != null) {
+ result.put("secretString", version.getSecretString());
+ }
+ // AWS dumps a binary secret's ByteBuffer internals here; left out until a caller reads them.
+ if (version.getVersionStages() != null) {
+ ArrayNode stages = result.putArray("versionStages");
+ version.getVersionStages().forEach(stages::add);
+ }
+ return result.put("createdDate", SOURCE_RESULT_DATE.format(version.getCreatedDate())).toString();
+ }
+
/**
* AWS reserves the {@code aws} and {@code ssm} namespaces, with or without a leading slash
* and regardless of case, so an account can never write over a public parameter. The rule
diff --git a/src/main/java/io/github/hectorvent/floci/services/ssm/model/Parameter.java b/src/main/java/io/github/hectorvent/floci/services/ssm/model/Parameter.java
index 37159d6da2..b100097abd 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ssm/model/Parameter.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ssm/model/Parameter.java
@@ -46,6 +46,10 @@ public class Parameter {
@JsonIgnore
private String selector;
+ // Only set on a Secrets Manager reference: AWS's GetSecretValue result as a JSON string.
+ @JsonIgnore
+ private String sourceResult;
+
public Parameter() {}
public Parameter(String name, String value, String type) {
@@ -85,4 +89,7 @@ public class Parameter {
public String getSelector() { return selector; }
public void setSelector(String selector) { this.selector = selector; }
+
+ public String getSourceResult() { return sourceResult; }
+ public void setSourceResult(String sourceResult) { this.sourceResult = sourceResult; }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationSsmParameterIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationSsmParameterIntegrationTest.java
index 99b0afe022..19a574a68a 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationSsmParameterIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationSsmParameterIntegrationTest.java
@@ -136,4 +136,55 @@ class CloudFormationSsmParameterIntegrationTest {
.body(containsString(
"Unable to fetch parameters [/cfn/test/does-not-exist] from parameter store for this account"));
}
+
+ @Test
+ void createStack_secretsManagerReferenceIsNotAPlaintextParameter() {
+ given()
+ .header("X-Amz-Target", "secretsmanager.CreateSecret")
+ .contentType(SSM_CONTENT_TYPE)
+ .body("{\"Name\": \"cfn-ssm-ref-secret\", \"SecretString\": \"s3cr3t\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ String template = """
+ {
+ "Parameters": {
+ "Secret": {
+ "Type": "AWS::SSM::Parameter::Value<String>",
+ "Default": "/aws/reference/secretsmanager/cfn-ssm-ref-secret"
+ }
+ },
+ "Resources": {
+ "Q": {
+ "Type": "AWS::SQS::Queue",
+ "Properties": {
+ "QueueName": { "Fn::Sub": "cfn-ssm-ref-${Secret}" }
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "ssm-secret-ref-param-stack")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", "ssm-secret-ref-param-stack")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>CREATE_FAILED</StackStatus>"))
+ .body(containsString("Unable to fetch parameters [/aws/reference/secretsmanager/cfn-ssm-ref-secret]"));
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmCommandServiceDirectExecutionTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmCommandServiceDirectExecutionTest.java
index 7628658061..a2938cc0fd 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmCommandServiceDirectExecutionTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmCommandServiceDirectExecutionTest.java
@@ -356,7 +356,7 @@ class SsmCommandServiceDirectExecutionTest {
SsmCommandService commandService = new SsmCommandService(
new SingleCommandStoreFactory(commandStore), objectMapper, regionResolver, executor);
- SsmJsonHandler jsonHandler = new SsmJsonHandler(mock(SsmService.class), commandService, objectMapper);
+ SsmJsonHandler jsonHandler = new SsmJsonHandler(mock(SsmService.class), commandService, objectMapper, null);
Command command = commandService.sendCommand(objectMapper.readTree("""
{
@@ -374,7 +374,7 @@ class SsmCommandServiceDirectExecutionTest {
ObjectNode listRequest = objectMapper.createObjectNode().put("CommandId", command.getCommandId());
AtomicBoolean listReturned = new AtomicBoolean(false);
Thread listThread = new Thread(() -> {
- jsonHandler.handle("ListCommands", listRequest, "us-west-2");
+ jsonHandler.handle("ListCommands", listRequest, "us-west-2", null);
listReturned.set(true);
});
listThread.start();
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandlerSecretReferenceTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandlerSecretReferenceTest.java
new file mode 100644
index 0000000000..fed7fb625e
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandlerSecretReferenceTest.java
@@ -0,0 +1,49 @@
+package io.github.hectorvent.floci.services.ssm;
+
+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.IamEnforcementFilter;
+import io.github.hectorvent.floci.services.ssm.model.Parameter;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class SsmJsonHandlerSecretReferenceTest {
+
+ private static final String REGION = "us-east-1";
+ private static final String NAME = "/aws/reference/secretsmanager/app";
+ private static final String CHECKED_ARN = "arn:aws:secretsmanager:us-east-1:000000000000:secret:app-AAAAAA";
+ private static final String REPLACEMENT_ARN = "arn:aws:secretsmanager:us-east-1:000000000000:secret:app-BBBBBB";
+
+ private final ObjectMapper objectMapper = new ObjectMapper();
+
+ @Test
+ void aSecretReplacedBetweenTheCheckAndTheReadIsCheckedOnItsOwnArn() {
+ SsmService ssmService = mock(SsmService.class);
+ IamEnforcementFilter iamEnforcementFilter = mock(IamEnforcementFilter.class);
+ Parameter replacement = new Parameter(NAME, "replacement-value", "SecureString");
+ replacement.setArn(REPLACEMENT_ARN);
+ when(ssmService.secretReferenceArn(NAME, REGION)).thenReturn(CHECKED_ARN);
+ when(ssmService.getParameter(NAME, true, REGION)).thenReturn(replacement);
+ when(ssmService.getParameters(List.of(NAME), true, REGION)).thenReturn(List.of(replacement));
+ doThrow(new AwsException("AccessDenied", "denied", 403)).when(iamEnforcementFilter)
+ .authorizeAdditionalResource("auth", "secretsmanager:GetSecretValue", REPLACEMENT_ARN);
+ SsmJsonHandler handler = new SsmJsonHandler(ssmService, null, objectMapper, iamEnforcementFilter);
+
+ ObjectNode getParameter = objectMapper.createObjectNode().put("Name", NAME).put("WithDecryption", true);
+ ObjectNode getParameters = objectMapper.createObjectNode().put("WithDecryption", true);
+ getParameters.putArray("Names").add(NAME);
+
+ assertEquals("An error occurred while calling one AWS dependency service.", assertThrows(AwsException.class,
+ () -> handler.handle("GetParameter", getParameter, REGION, "auth")).getMessage());
+ assertEquals("An error occurred while calling one AWS dependency service.", assertThrows(AwsException.class,
+ () -> handler.handle("GetParameters", getParameters, REGION, "auth")).getMessage());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmSecretsManagerReferenceIamEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmSecretsManagerReferenceIamEnforcementIntegrationTest.java
new file mode 100644
index 0000000000..c43b9b5642
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmSecretsManagerReferenceIamEnforcementIntegrationTest.java
@@ -0,0 +1,146 @@
+package io.github.hectorvent.floci.services.ssm;
+
+import io.github.hectorvent.floci.testing.IamEnforcementProfile;
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.TestProfile;
+import io.restassured.response.ValidatableResponse;
+import io.restassured.specification.RequestSpecification;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+import java.util.UUID;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+
+/**
+ * Parameter Store reads a reference with the caller's own {@code secretsmanager:GetSecretValue}
+ * permission, checked before the secret is looked up. Measured against AWS in eu-west-1 on
+ * 2026-09-28 with a role allowed only {@code ssm:GetParameter} and {@code ssm:GetParameters}.
+ */
+@QuarkusTest
+@TestProfile(IamEnforcementProfile.class)
+class SsmSecretsManagerReferenceIamEnforcementIntegrationTest {
+
+ private static final String ACCOUNT_ID = "000000000000";
+ private static final String REGION = "us-east-1";
+ private static final String PREFIX = "/aws/reference/secretsmanager/";
+ private static final String DEPENDENCY_FAILED = "An error occurred while calling one AWS dependency service.";
+ private static final String SSM_ONLY = """
+ {"Version":"2012-10-17","Statement":[
+ {"Effect":"Allow","Action":["ssm:GetParameter","ssm:GetParameters"],"Resource":"*"}
+ ]}""";
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ void getParameterIsRefusedWithoutGetSecretValueWhetherOrNotTheSecretExists() {
+ String secret = createSecret("ref-denied");
+ String caller = createUserWithPolicy("ssm-only", SSM_ONLY);
+
+ ssm(caller, "GetParameter", "{\"Name\": \"" + PREFIX + secret + "\", \"WithDecryption\": true}")
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo(DEPENDENCY_FAILED));
+ ssm(caller, "GetParameter", "{\"Name\": \"" + PREFIX + secret + "-missing\", \"WithDecryption\": true}")
+ .statusCode(400)
+ .body("message", equalTo(DEPENDENCY_FAILED));
+ ssm(caller, "GetParameter", "{\"Name\": \"" + PREFIX + secret + "\"}")
+ .statusCode(400)
+ .body("message", equalTo("WithDecryption flag must be True for retrieving a Secret Manager secret."));
+ }
+
+ @Test
+ void aMalformedReferenceGetsTheSyntaxErrorBeforeTheCallerIsChecked() {
+ String caller = createUserWithPolicy("ssm-only-syntax", SSM_ONLY);
+
+ ssm(caller, "GetParameter", "{\"Name\": \"" + PREFIX + "app:a:b\", \"WithDecryption\": true}")
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo("Invalid parameter name. Please use correct syntax "
+ + "for referencing a version/label <name>:<version/label>"));
+ }
+
+ @Test
+ void getParametersFailsAsAWholeWhenOneReferenceIsRefused() {
+ String secret = createSecret("refs-denied");
+ String caller = createUserWithPolicy("ssm-only-batch", SSM_ONLY);
+
+ ssm(caller, "GetParameters", "{\"Names\": [\"" + PREFIX + secret + "\", \"" + PREFIX + secret + "-missing\"], "
+ + "\"WithDecryption\": true}")
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo(DEPENDENCY_FAILED));
+ }
+
+ @Test
+ void aCallerAllowedGetSecretValueOnTheSecretArnReadsTheReference() {
+ String secret = createSecret("ref-allowed");
+ String arn = json(ACCOUNT_ID, "secretsmanager", "secretsmanager.DescribeSecret",
+ "{\"SecretId\": \"" + secret + "\"}")
+ .statusCode(200)
+ .extract().path("ARN");
+ String caller = createUserWithPolicy("ssm-and-secret", """
+ {"Version":"2012-10-17","Statement":[
+ {"Effect":"Allow","Action":["ssm:GetParameter","ssm:GetParameters"],"Resource":"*"},
+ {"Effect":"Allow","Action":"secretsmanager:GetSecretValue","Resource":"%s"}
+ ]}""".formatted(arn));
+
+ ssm(caller, "GetParameter", "{\"Name\": \"" + PREFIX + secret + "\", \"WithDecryption\": true}")
+ .statusCode(200)
+ .body("Parameter.Value", equalTo("secret-value"));
+ ssm(caller, "GetParameters", "{\"Names\": [\"" + PREFIX + secret + "\"], \"WithDecryption\": true}")
+ .statusCode(200)
+ .body("Parameters[0].Value", equalTo("secret-value"));
+ }
+
+ private static String createSecret(String prefix) {
+ String name = prefix + "-" + UUID.randomUUID().toString().substring(0, 8);
+ json(ACCOUNT_ID, "secretsmanager", "secretsmanager.CreateSecret",
+ "{\"Name\": \"" + name + "\", \"SecretString\": \"secret-value\"}")
+ .statusCode(200);
+ return name;
+ }
+
+ private static String createUserWithPolicy(String prefix, String policyDocument) {
+ String userName = prefix + "-" + UUID.randomUUID().toString().substring(0, 8);
+ adminIam(Map.of("Action", "CreateUser", "UserName", userName)).statusCode(200);
+ adminIam(Map.of("Action", "PutUserPolicy", "UserName", userName, "PolicyName", "inline",
+ "PolicyDocument", policyDocument)).statusCode(200);
+ return adminIam(Map.of("Action", "CreateAccessKey", "UserName", userName))
+ .statusCode(200)
+ .extract().path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey.AccessKeyId");
+ }
+
+ private static ValidatableResponse adminIam(Map<String, String> params) {
+ RequestSpecification spec = given()
+ .header("Authorization", authorization(ACCOUNT_ID, "iam"))
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Version", "2010-05-08");
+ params.forEach(spec::formParam);
+ return spec.when().post("/").then();
+ }
+
+ private static ValidatableResponse ssm(String accessKeyId, String action, String body) {
+ return json(accessKeyId, "ssm", "AmazonSSM." + action, body);
+ }
+
+ private static ValidatableResponse json(String accessKeyId, String scope, String target, String body) {
+ return given()
+ .header("Authorization", authorization(accessKeyId, scope))
+ .header("X-Amz-Target", target)
+ .contentType("application/x-amz-json-1.1")
+ .body(body)
+ .when().post("/").then();
+ }
+
+ private static String authorization(String accessKeyId, String service) {
+ return "AWS4-HMAC-SHA256 Credential=" + accessKeyId + "/20260928/" + REGION + "/" + service
+ + "/aws4_request, SignedHeaders=host, Signature=abc";
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmSecretsManagerReferenceIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmSecretsManagerReferenceIntegrationTest.java
new file mode 100644
index 0000000000..c3b3f9d328
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmSecretsManagerReferenceIntegrationTest.java
@@ -0,0 +1,238 @@
+package io.github.hectorvent.floci.services.ssm;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.ValidatableResponse;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasKey;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.startsWith;
+
+/**
+ * Parameter Store answers {@code /aws/reference/secretsmanager/<secret-id>} from Secrets Manager.
+ * The expected responses and error texts were measured against AWS in eu-west-1 on 2026-09-28.
+ */
+@QuarkusTest
+class SsmSecretsManagerReferenceIntegrationTest {
+
+ private static final String JSON = "application/x-amz-json-1.1";
+ private static final String PREFIX = "/aws/reference/secretsmanager/";
+ private static final String NEEDS_DECRYPTION =
+ "WithDecryption flag must be True for retrieving a Secret Manager secret.";
+ private static final String BAD_SELECTOR =
+ "Invalid parameter name. Please use correct syntax for referencing a version/label <name>:<version/label>";
+
+ @Inject
+ SsmService ssmService;
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ void resolvesTheCurrentValueOfASecretCreatedThroughSecretsManager() {
+ String name = unique("ref-sm") + "/nested/path";
+ String arn = createSecret(name, "first-value");
+ putSecretValue(name, "second-value");
+ float created = given()
+ .header("X-Amz-Target", "secretsmanager.GetSecretValue")
+ .contentType(JSON)
+ .body("{\"SecretId\": \"" + name + "\"}")
+ .when().post("/").then().statusCode(200).extract().path("CreatedDate");
+
+ getParameter(PREFIX + name, true)
+ .statusCode(200)
+ .body("Parameter.Name", equalTo(PREFIX + name))
+ .body("Parameter.Type", equalTo("SecureString"))
+ .body("Parameter.Value", equalTo("second-value"))
+ .body("Parameter.Version", equalTo(0))
+ .body("Parameter.ARN", equalTo(arn))
+ .body("Parameter.LastModifiedDate", equalTo(created))
+ .body("Parameter", not(hasKey("DataType")))
+ .body("Parameter", not(hasKey("Selector")))
+ .body("Parameter.SourceResult", startsWith("{\"ARN\":\"" + arn + "\",\"name\":\"" + name + "\",\"versionId\":\""))
+ .body("Parameter.SourceResult", containsString(
+ "\"secretString\":\"second-value\",\"versionStages\":[\"AWSCURRENT\"],\"createdDate\":\""));
+ }
+
+ @Test
+ void ecsAndCodeBuildReadAReferenceWithDecryption() {
+ String name = unique("ref-internal");
+ createSecret(name, "internal-value");
+
+ assertEquals("internal-value", ssmService.getParameter(PREFIX + name, "us-east-1").getValue());
+ }
+
+ @Test
+ void refusesAReferenceWithoutDecryptionBeforeLookingItUp() {
+ String name = unique("ref-plain");
+ createSecret(name, "value");
+
+ getParameter(PREFIX + name, false).statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo(NEEDS_DECRYPTION));
+ given()
+ .header("X-Amz-Target", "AmazonSSM.GetParameter")
+ .contentType(JSON)
+ .body("{\"Name\": \"" + PREFIX + name + "\"}")
+ .when().post("/").then().statusCode(400)
+ .body("message", equalTo(NEEDS_DECRYPTION));
+ getParameter(PREFIX + unique("ref-absent"), false).statusCode(400)
+ .body("message", equalTo(NEEDS_DECRYPTION));
+ }
+
+ @Test
+ void missingSecretIsParameterNotFoundWithTheTextAwsSends() {
+ String name = unique("ref-missing");
+
+ getParameter(PREFIX + name, true).statusCode(400)
+ .body("__type", equalTo("ParameterNotFound"))
+ .body("message", equalTo("An error occurred (ParameterNotFound) when referencing Secrets Manager: "
+ + "Secret aws/reference/secretsmanager/" + name + "null not found."));
+ }
+
+ @Test
+ void selectsAVersionByStagingLabelOrVersionId() {
+ String name = unique("ref-select");
+ createSecret(name, "first-value");
+ String firstVersion = given()
+ .header("X-Amz-Target", "secretsmanager.DescribeSecret")
+ .contentType(JSON)
+ .body("{\"SecretId\": \"" + name + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getMap("VersionIdsToStages").keySet().iterator().next().toString();
+ putSecretValue(name, "second-value");
+
+ getParameter(PREFIX + name + ":AWSPREVIOUS", true).statusCode(200)
+ .body("Parameter.Name", equalTo(PREFIX + name))
+ .body("Parameter.Selector", equalTo(":AWSPREVIOUS"))
+ .body("Parameter.Value", equalTo("first-value"))
+ .body("Parameter.SourceResult", containsString("\"versionStages\":[\"AWSPREVIOUS\"]"));
+ getParameter(PREFIX + name + ":" + firstVersion, true).statusCode(200)
+ .body("Parameter.Selector", equalTo(":" + firstVersion))
+ .body("Parameter.Value", equalTo("first-value"));
+ getParameter(PREFIX + name + ":AWSCURRENT", true).statusCode(200)
+ .body("Parameter.Value", equalTo("second-value"));
+ getParameter(PREFIX + name + ":NOSUCHSTAGE", true).statusCode(400)
+ .body("__type", equalTo("ParameterNotFound"))
+ .body("message", equalTo("An error occurred (ParameterNotFound) when referencing Secrets Manager: "
+ + "Secret aws/reference/secretsmanager/" + name + ":NOSUCHSTAGE not found."));
+ }
+
+ @Test
+ void malformedSelectorIsRefusedBeforeTheDecryptionCheck() {
+ String name = unique("ref-malformed");
+ createSecret(name, "value");
+
+ for (String reference : new String[] {name + ":AWSCURRENT:extra", name + ":",
+ "arn:aws:secretsmanager:us-east-1:000000000000:secret:" + name}) {
+ getParameter(PREFIX + reference, false).statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo(BAD_SELECTOR));
+ }
+ }
+
+ @Test
+ void secretScheduledForDeletionIsAnInvalidRequest() {
+ String name = unique("ref-deleted");
+ createSecret(name, "value");
+ given()
+ .header("X-Amz-Target", "secretsmanager.DeleteSecret")
+ .contentType(JSON)
+ .body("{\"SecretId\": \"" + name + "\", \"RecoveryWindowInDays\": 7}")
+ .when().post("/").then().statusCode(200);
+
+ getParameter(PREFIX + name, true).statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo("Invalid Request to Secrets Manager"));
+ }
+
+ @Test
+ void binarySecretHasNoValue() {
+ String name = unique("ref-binary");
+ given()
+ .header("X-Amz-Target", "secretsmanager.CreateSecret")
+ .contentType(JSON)
+ .body("{\"Name\": \"" + name + "\", \"SecretBinary\": \"YWJj\"}")
+ .when().post("/").then().statusCode(200);
+
+ getParameter(PREFIX + name, true).statusCode(200)
+ .body("Parameter.Type", equalTo("SecureString"))
+ .body("Parameter", not(hasKey("Value")));
+ }
+
+ @Test
+ void getParametersListsEveryReferenceItCannotAnswerAsInvalid() {
+ String name = unique("ref-batch");
+ String plain = "/" + unique("ref-batch-plain");
+ createSecret(name, "first-value");
+ putSecretValue(name, "second-value");
+ given()
+ .header("X-Amz-Target", "AmazonSSM.PutParameter")
+ .contentType(JSON)
+ .body("{\"Name\": \"" + plain + "\", \"Value\": \"plain\", \"Type\": \"String\"}")
+ .when().post("/").then().statusCode(200);
+ String missing = PREFIX + unique("ref-batch-missing");
+ String unknownStage = PREFIX + name + ":NOSUCH";
+ String malformed = PREFIX + name + ":a:b";
+
+ getParameters(true, PREFIX + name, PREFIX + name + ":AWSPREVIOUS", missing, unknownStage, malformed, plain)
+ .statusCode(200)
+ .body("Parameters.Value", containsInAnyOrder("second-value", "first-value", "plain"))
+ .body("InvalidParameters", containsInAnyOrder(missing, unknownStage, malformed));
+
+ getParameters(false, PREFIX + name, plain)
+ .statusCode(200)
+ .body("Parameters.Value", containsInAnyOrder("plain"))
+ .body("InvalidParameters", containsInAnyOrder(PREFIX + name));
+ }
+
+ private static ValidatableResponse getParameter(String name, boolean withDecryption) {
+ return given()
+ .header("X-Amz-Target", "AmazonSSM.GetParameter")
+ .contentType(JSON)
+ .body("{\"Name\": \"" + name + "\", \"WithDecryption\": " + withDecryption + "}")
+ .when().post("/").then();
+ }
+
+ private static ValidatableResponse getParameters(boolean withDecryption, String... names) {
+ StringBuilder list = new StringBuilder();
+ for (String name : names) {
+ list.append(list.isEmpty() ? "" : ",").append('"').append(name).append('"');
+ }
+ return given()
+ .header("X-Amz-Target", "AmazonSSM.GetParameters")
+ .contentType(JSON)
+ .body("{\"Names\": [" + list + "], \"WithDecryption\": " + withDecryption + "}")
+ .when().post("/").then();
+ }
+
+ private static String createSecret(String name, String value) {
+ return given()
+ .header("X-Amz-Target", "secretsmanager.CreateSecret")
+ .contentType(JSON)
+ .body("{\"Name\": \"" + name + "\", \"SecretString\": \"" + value + "\"}")
+ .when().post("/").then().statusCode(200).extract().path("ARN");
+ }
+
+ private static void putSecretValue(String name, String value) {
+ given()
+ .header("X-Amz-Target", "secretsmanager.PutSecretValue")
+ .contentType(JSON)
+ .body("{\"SecretId\": \"" + name + "\", \"SecretString\": \"" + value + "\"}")
+ .when().post("/").then().statusCode(200);
+ }
+
+ private static String unique(String prefix) {
+ return prefix + "-" + Long.toString(System.nanoTime(), 36);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java
index 158d2b63a3..2fbef90b51 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java
@@ -41,7 +41,7 @@ class SsmServicePublicAmiParameterTest {
ssmService = new SsmService(
new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
- 5, new RegionResolver(REGION, "000000000000"), new Ec2ImageCatalog());
+ 5, new RegionResolver(REGION, "000000000000"), new Ec2ImageCatalog(), null);
}
@Test
@@ -84,7 +84,7 @@ class SsmServicePublicAmiParameterTest {
ssmService.putParameter("/app/ami", "ami-custom", "String", null, false, REGION);
List<Parameter> params = ssmService.getParameters(
- List.of("/app/ami", AL2023_DEFAULT, "/app/missing"), REGION);
+ List.of("/app/ami", AL2023_DEFAULT, "/app/missing"), false, REGION);
assertEquals(List.of("/app/ami", AL2023_DEFAULT), params.stream().map(Parameter::getName).toList());
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java
index 19c2310f2e..91973f09df 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java
@@ -4,6 +4,9 @@ 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.core.storage.StorageBackend;
+import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;
+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;
+import io.github.hectorvent.floci.services.secretsmanager.model.SecretVersion;
import io.github.hectorvent.floci.services.ssm.model.Parameter;
import io.github.hectorvent.floci.services.ssm.model.ParameterHistory;
import io.github.hectorvent.floci.services.ssm.model.ParameterStringFilter;
@@ -13,6 +16,7 @@ import io.github.hectorvent.floci.services.ssm.model.SsmDocument;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import java.time.Instant;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -26,6 +30,8 @@ import java.util.concurrent.TimeoutException;
import java.util.function.Predicate;
import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
class SsmServiceTest {
@@ -137,7 +143,7 @@ class SsmServiceTest {
ssmService.putParameter("/b", "2", "String", null, false, region);
ssmService.putParameter("/c", "3", "String", null, false, region);
- List<Parameter> params = ssmService.getParameters(List.of("/a", "/c", "/missing"), region);
+ List<Parameter> params = ssmService.getParameters(List.of("/a", "/c", "/missing"), false, region);
assertEquals(2, params.size());
}
@@ -434,7 +440,7 @@ class SsmServiceTest {
ssmService.putParameter("/app/key", "v1", "String", null, false, region);
ssmService.putParameter("/app/key", "v2", "String", null, true, region);
- List<Parameter> found = ssmService.getParameters(List.of("/app/key:1", "/app/key:9"), region);
+ List<Parameter> found = ssmService.getParameters(List.of("/app/key:1", "/app/key:9"), false, region);
assertEquals(1, found.size());
assertEquals("v1", found.getFirst().getValue());
}
@@ -1212,6 +1218,51 @@ class SsmServiceTest {
assertFilterError("InvalidFilterValue", new ParameterStringFilter("Type", null, List.of()));
}
+ @Test
+ void secretReferenceCarriesTheGetSecretValueResultAsAwsFormatsIt() {
+ String arn = "arn:aws:secretsmanager:us-east-1:000000000000:secret:app-AbCdEf";
+ Secret described = new Secret();
+ described.setArn(arn);
+ described.setName("app");
+ SecretVersion current = new SecretVersion();
+ current.setVersionId("4aa4a0d4-4321-4661-9288-c9e2aeffd37a");
+ current.setSecretString("{\"k\":\"v\"}");
+ current.setVersionStages(List.of("AWSCURRENT"));
+ current.setCreatedDate(Instant.parse("2026-09-28T16:47:31.824Z"));
+ SecretsManagerService secrets = mock(SecretsManagerService.class);
+ when(secrets.describeSecret("app", "us-east-1")).thenReturn(described);
+ when(secrets.getSecretValue(arn, null, null, "us-east-1")).thenReturn(current);
+ SsmService service = new SsmService(new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), 5, new RegionResolver("us-east-1", "000000000000"), null, secrets);
+
+ assertEquals("{\"ARN\":\"" + arn + "\",\"name\":\"app\",\"versionId\":\"4aa4a0d4-4321-4661-9288-c9e2aeffd37a\","
+ + "\"secretString\":\"{\\\"k\\\":\\\"v\\\"}\",\"versionStages\":[\"AWSCURRENT\"],"
+ + "\"createdDate\":\"Sep 28, 2026, 4:47:31 PM\"}",
+ service.getParameter("/aws/reference/secretsmanager/app", true, "us-east-1").getSourceResult());
+ }
+
+ @Test
+ void secretReplacedWhileReferenceIsReadIsNotReturnedUnderTheOldArn() {
+ String oldArn = "arn:aws:secretsmanager:us-east-1:000000000000:secret:app-AAAAAA";
+ Secret described = new Secret();
+ described.setArn(oldArn);
+ SecretVersion replacement = new SecretVersion();
+ replacement.setSecretString("replacement");
+ SecretsManagerService secrets = mock(SecretsManagerService.class);
+ when(secrets.describeSecret("app", "us-east-1")).thenReturn(described);
+ when(secrets.getSecretValue("app", null, null, "us-east-1")).thenReturn(replacement);
+ when(secrets.getSecretValue(oldArn, null, null, "us-east-1")).thenThrow(new AwsException(
+ "ResourceNotFoundException", "Secrets Manager can't find the specified secret.", 400));
+ SsmService service = new SsmService(new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), 5, new RegionResolver("us-east-1", "000000000000"), null, secrets);
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ service.getParameter("/aws/reference/secretsmanager/app", true, "us-east-1"));
+ assertEquals("ParameterNotFound", ex.getErrorCode());
+ }
+
private List<String> describedNames(List<ParameterStringFilter> filters, String region) {
return ssmService.describeParameters(filters, region).stream().map(Parameter::getName).toList();
}