Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat: support GenerateSecretString and Description for AWS::SecretsManager::Secret in CloudFormation (#176)

yoyof994b9545b02
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java
index e57954ed3c..e314815c52 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java
@@ -14,6 +14,7 @@ import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;
import io.github.hectorvent.floci.services.sns.SnsService;
import io.github.hectorvent.floci.services.sqs.SqsService;
import io.github.hectorvent.floci.services.ssm.SsmService;
+import io.github.hectorvent.floci.core.common.AwsException;
import com.fasterxml.jackson.databind.JsonNode;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
@@ -472,16 +473,79 @@ public class CloudFormationResourceProvisioner {
if (name == null || name.isBlank()) {
name = generatePhysicalName(stackName, r.getLogicalId(), 512, false);
}
- String value = resolveOptional(props, "SecretString", engine);
- if (value == null) {
- value = "{}";
- }
- var secret = secretsManagerService.createSecret(name, value, null, null, null, List.of(), region);
+ String description = resolveOptional(props, "Description", engine);
+ String value = resolveSecretValue(props, engine);
+ var secret = secretsManagerService.createSecret(name, value, null, description, null, List.of(), region);
r.setPhysicalId(secret.getArn());
r.getAttributes().put("Arn", secret.getArn());
r.getAttributes().put("Name", name);
}
+ /**
+ * Resolves the secret value from CloudFormation properties.
+ * SecretString and GenerateSecretString are mutually exclusive per AWS spec.
+ * If GenerateSecretString is present, a random password is generated.
+ * If SecretStringTemplate and GenerateStringKey are specified inside
+ * GenerateSecretString, the generated password is embedded in the template JSON.
+ */
+ private String resolveSecretValue(JsonNode props, CloudFormationTemplateEngine engine) {
+ if (props == null) {
+ return "{}";
+ }
+
+ // SecretString takes precedence when explicitly set
+ String secretString = resolveOptional(props, "SecretString", engine);
+ JsonNode genNode = props.get("GenerateSecretString");
+
+ if (secretString != null && genNode != null && !genNode.isNull()) {
+ throw new AwsException("ValidationError",
+ "You can't specify both SecretString and GenerateSecretString", 400);
+ }
+
+ if (secretString != null) {
+ return secretString;
+ }
+
+ if (genNode != null && !genNode.isNull()) {
+ return generateSecretString(genNode);
+ }
+
+ return "{}";
+ }
+
+ private String generateSecretString(JsonNode genNode) {
+ String password = io.github.hectorvent.floci.services.secretsmanager
+ .RandomPasswordGenerator.generate(genNode);
+
+ String template = null;
+ String key = null;
+ JsonNode templateNode = genNode.get("SecretStringTemplate");
+ JsonNode keyNode = genNode.get("GenerateStringKey");
+
+ if (templateNode != null && !templateNode.isNull()) {
+ template = templateNode.asText();
+ }
+ if (keyNode != null && !keyNode.isNull()) {
+ key = keyNode.asText();
+ }
+
+ if (template != null && key != null) {
+ // Insert the generated password into the template JSON
+ try {
+ var mapper = new com.fasterxml.jackson.databind.ObjectMapper();
+ var tree = (com.fasterxml.jackson.databind.node.ObjectNode) mapper.readTree(template);
+ tree.put(key, password);
+ return mapper.writeValueAsString(tree);
+ } catch (Exception e) {
+ // If the template is not valid JSON, fall back to raw password
+ LOG.warnv("Failed to parse SecretStringTemplate: {0}", e.getMessage());
+ return password;
+ }
+ }
+
+ return password;
+ }
+
// ── Nested Stack ──────────────────────────────────────────────────────────
private void provisionNestedStack(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,
diff --git a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/RandomPasswordGenerator.java b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/RandomPasswordGenerator.java
new file mode 100644
index 0000000000..3cff47ae52
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/RandomPasswordGenerator.java
@@ -0,0 +1,127 @@
+package io.github.hectorvent.floci.services.secretsmanager;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Generates random passwords following the same rules as the AWS Secrets Manager
+ * {@code GetRandomPassword} API. Reused by both the JSON handler and CloudFormation
+ * {@code GenerateSecretString} provisioning.
+ *
+ * @see <a href="https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetRandomPassword.html">
+ * AWS Secrets Manager – GetRandomPassword</a>
+ */
+public final class RandomPasswordGenerator {
+
+ private static final String LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+ private static final String UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ private static final String DIGITS = "0123456789";
+ private static final String PUNCTUATION = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+
+ private RandomPasswordGenerator() {
+ }
+
+ /**
+ * Generate a random password from a JSON node that may contain:
+ * {@code PasswordLength}, {@code ExcludeCharacters}, {@code ExcludeLowercase},
+ * {@code ExcludeUppercase}, {@code ExcludeNumbers}, {@code ExcludePunctuation},
+ * {@code IncludeSpace}, {@code RequireEachIncludedType}.
+ *
+ * @param node JSON object with optional password-generation fields
+ * @return the generated password
+ * @throws IllegalArgumentException if PasswordLength is out of range or the charset is empty
+ */
+ public static String generate(JsonNode node) {
+ boolean excludeLower = boolField(node, "ExcludeLowercase");
+ boolean excludeUpper = boolField(node, "ExcludeUppercase");
+ boolean excludeNumbers = boolField(node, "ExcludeNumbers");
+ boolean excludePunctuation = boolField(node, "ExcludePunctuation");
+ boolean includeSpace = boolField(node, "IncludeSpace");
+ String excludeChars = stringField(node, "ExcludeCharacters");
+
+ JsonNode passwordLengthNode = node == null ? null : node.get("PasswordLength");
+ int length = (passwordLengthNode != null && !passwordLengthNode.isNull())
+ ? passwordLengthNode.asInt(32) : 32;
+ if (length < 1 || length > 4096) {
+ throw new IllegalArgumentException("PasswordLength must be between 1 and 4096.");
+ }
+
+ JsonNode reqNode = node == null ? null : node.get("RequireEachIncludedType");
+ boolean requireEach = reqNode == null || reqNode.isNull() || reqNode.asBoolean();
+
+ // Build charset
+ StringBuilder charset = new StringBuilder();
+ if (!excludeLower) charset.append(LOWERCASE);
+ if (!excludeUpper) charset.append(UPPERCASE);
+ if (!excludeNumbers) charset.append(DIGITS);
+ if (!excludePunctuation) charset.append(PUNCTUATION);
+ if (includeSpace) charset.append(" ");
+
+ if (excludeChars != null) {
+ for (int i = charset.length() - 1; i >= 0; i--) {
+ if (excludeChars.indexOf(charset.charAt(i)) >= 0) {
+ charset.deleteCharAt(i);
+ }
+ }
+ }
+
+ if (charset.isEmpty()) {
+ throw new IllegalArgumentException("The password charset is empty after applying exclusions.");
+ }
+
+ SecureRandom random = new SecureRandom();
+ StringBuilder password = new StringBuilder(length);
+
+ if (requireEach) {
+ List<String> types = new ArrayList<>();
+ if (!excludeLower) types.add(LOWERCASE);
+ if (!excludeUpper) types.add(UPPERCASE);
+ if (!excludeNumbers) types.add(DIGITS);
+ if (!excludePunctuation) types.add(PUNCTUATION);
+ if (includeSpace) types.add(" ");
+
+ if (excludeChars != null) {
+ types = types.stream()
+ .map(t -> t.chars()
+ .filter(c -> excludeChars.indexOf(c) < 0)
+ .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+ .toString())
+ .filter(t -> !t.isEmpty())
+ .collect(Collectors.toList());
+ }
+ for (String type : types) {
+ password.append(type.charAt(random.nextInt(type.length())));
+ }
+ }
+
+ for (int i = password.length(); i < length; i++) {
+ password.append(charset.charAt(random.nextInt(charset.length())));
+ }
+
+ // Shuffle so required seed chars aren't always at the start
+ for (int i = length - 1; i > 0; i--) {
+ int j = random.nextInt(i + 1);
+ char tmp = password.charAt(i);
+ password.setCharAt(i, password.charAt(j));
+ password.setCharAt(j, tmp);
+ }
+
+ return password.toString();
+ }
+
+ private static boolean boolField(JsonNode node, String name) {
+ if (node == null) return false;
+ JsonNode f = node.get(name);
+ return f != null && !f.isNull() && f.asBoolean();
+ }
+
+ private static String stringField(JsonNode node, String name) {
+ if (node == null) return null;
+ JsonNode f = node.get(name);
+ return (f != null && !f.isNull()) ? f.asText() : null;
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.java
index 361aabb57e..c4e7e22283 100644
--- a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.java
@@ -325,98 +325,16 @@ public class SecretsManagerJsonHandler {
* @see <a href="https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetRandomPassword.html">AWS Secrets Manager – GetRandomPassword</a>
*/
private Response handleGetRandomPassword(JsonNode request, String region) {
-
- var excludeCharacters = request.get("ExcludeCharacters");
- var excludeLowerCase = request.get("ExcludeLowercase");
- var excludeNumbers = request.get("ExcludeNumbers");
- var excludePunctuation = request.get("ExcludePunctuation");
- var excludeUpperCase = request.get("ExcludeUppercase");
- var includeSpace = request.get("IncludeSpace");
- var passwordLength = request.get("PasswordLength");
- var requireEachIncludedType = request.get("RequireEachIncludedType");
-
- int length = (passwordLength != null && !passwordLength.isNull()) ? passwordLength.asInt(32) : 32;
- if (length < 1 || length > 4096) {
+ try {
+ String password = RandomPasswordGenerator.generate(request);
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("RandomPassword", password);
+ return Response.ok(response).build();
+ } catch (IllegalArgumentException e) {
return Response.status(400)
- .entity(new AwsErrorResponse("InvalidParameterException", "PasswordLength must be between 1 and 4096."))
+ .entity(new AwsErrorResponse("InvalidParameterException", e.getMessage()))
.build();
}
-
- StringBuilder charset = new StringBuilder();
- if (excludeLowerCase == null || excludeLowerCase.isNull() || !excludeLowerCase.asBoolean()) {
- charset.append("abcdefghijklmnopqrstuvwxyz");
- }
- if (excludeUpperCase == null || excludeUpperCase.isNull() || !excludeUpperCase.asBoolean()) {
- charset.append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
- }
- if (excludeNumbers == null || excludeNumbers.isNull() || !excludeNumbers.asBoolean()) {
- charset.append("0123456789");
- }
- if (excludePunctuation == null || excludePunctuation.isNull() || !excludePunctuation.asBoolean()) {
- charset.append("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~");
- }
- if (includeSpace != null && !includeSpace.isNull() && includeSpace.asBoolean()) {
- charset.append(" ");
- }
- if (excludeCharacters != null && !excludeCharacters.isNull()) {
- String excluded = excludeCharacters.asText();
- for (int i = charset.length() - 1; i >= 0; i--) {
- if (excluded.indexOf(charset.charAt(i)) >= 0) {
- charset.deleteCharAt(i);
- }
- }
- }
-
- SecureRandom random = new SecureRandom();
- StringBuilder password = new StringBuilder(length);
-
- boolean requireEach = requireEachIncludedType == null || requireEachIncludedType.isNull() || requireEachIncludedType.asBoolean();
- if (requireEach) {
- List<String> includedTypes = new ArrayList<>();
- if (excludeLowerCase == null || excludeLowerCase.isNull() || !excludeLowerCase.asBoolean()) {
- includedTypes.add("abcdefghijklmnopqrstuvwxyz");
- }
- if (excludeUpperCase == null || excludeUpperCase.isNull() || !excludeUpperCase.asBoolean()) {
- includedTypes.add("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
- }
- if (excludeNumbers == null || excludeNumbers.isNull() || !excludeNumbers.asBoolean()) {
- includedTypes.add("0123456789");
- }
- if (excludePunctuation == null || excludePunctuation.isNull() || !excludePunctuation.asBoolean()) {
- includedTypes.add("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~");
- }
- if (includeSpace != null && !includeSpace.isNull() && includeSpace.asBoolean()) {
- includedTypes.add(" ");
- }
- if (excludeCharacters != null && !excludeCharacters.isNull()) {
- String excluded = excludeCharacters.asText();
- includedTypes = includedTypes.stream()
- .map(t -> t.chars().filter(c -> excluded.indexOf(c) < 0)
- .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString())
- .filter(t -> !t.isEmpty())
- .collect(java.util.stream.Collectors.toList());
- }
- // Seed one char from each required type
- for (String type : includedTypes) {
- password.append(type.charAt(random.nextInt(type.length())));
- }
- }
-
- for (int i = password.length(); i < length; i++) {
- password.append(charset.charAt(random.nextInt(charset.length())));
- }
-
- // Shuffle so required chars aren't always at the start
- for (int i = length - 1; i > 0; i--) {
- int j = random.nextInt(i + 1);
- char tmp = password.charAt(i);
- password.setCharAt(i, password.charAt(j));
- password.setCharAt(j, tmp);
- }
-
- ObjectNode response = objectMapper.createObjectNode();
- response.put("RandomPassword", password.toString());
- return Response.ok(response).build();
}
private List<Secret.Tag> parseTags(JsonNode request) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
index 46577a8924..b0a82904fb 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
@@ -7,17 +7,22 @@ import io.restassured.http.ContentType;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
-
import static io.restassured.RestAssured.given;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.matchesRegex;
import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.startsWith;
@QuarkusTest
@@ -25,13 +30,16 @@ class CloudFormationIntegrationTest {
private static final String DYNAMODB_CONTENT_TYPE = "application/x-amz-json-1.0";
private static final String SSM_CONTENT_TYPE = "application/x-amz-json-1.1";
+ private static final String SM_CONTENT_TYPE = "application/x-amz-json-1.1";
+ private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
@BeforeAll
static void configureRestAssured() {
RestAssured.config = RestAssured.config().encoderConfig(
EncoderConfig.encoderConfig()
.encodeContentTypeAs(DYNAMODB_CONTENT_TYPE, ContentType.TEXT)
- .encodeContentTypeAs(SSM_CONTENT_TYPE, ContentType.TEXT));
+ .encodeContentTypeAs(SSM_CONTENT_TYPE, ContentType.TEXT)
+ .encodeContentTypeAs(SM_CONTENT_TYPE, ContentType.TEXT));
}
private static byte[] buildHandlerZip() {
@@ -1018,4 +1026,424 @@ class CloudFormationIntegrationTest {
.body(containsString("ecr-upper-stack-myrepo-"))
.body(not(containsString("ECR-Upper-Stack-MyRepo-")));
}
+
+ // ── Secrets Manager: GenerateSecretString + Description ──────────────────
+
+ @Test
+ void createStack_secretWithGenerateSecretString_defaultPassword() {
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-gen-default",
+ "GenerateSecretString": {}
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "gen-secret-default")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackId>"));
+
+ // Verify secret was created and has a generated value (default 32 chars)
+ String body = given()
+ .header("X-Amz-Target", "secretsmanager.GetSecretValue")
+ .contentType(SM_CONTENT_TYPE)
+ .body("{\"SecretId\": \"cfn-gen-default\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+
+ try {
+ JsonNode json = OBJECT_MAPPER.readTree(body);
+ String secretString = json.get("SecretString").asText();
+ assertThat(secretString, notNullValue());
+ assertThat(secretString.length(), equalTo(32));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ void createStack_secretWithGenerateSecretString_customLength() {
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-gen-len64",
+ "GenerateSecretString": {
+ "PasswordLength": 64,
+ "ExcludePunctuation": true
+ }
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "gen-secret-len64")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String body = given()
+ .header("X-Amz-Target", "secretsmanager.GetSecretValue")
+ .contentType(SM_CONTENT_TYPE)
+ .body("{\"SecretId\": \"cfn-gen-len64\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+
+ try {
+ JsonNode json = OBJECT_MAPPER.readTree(body);
+ String secretString = json.get("SecretString").asText();
+ assertThat(secretString.length(), equalTo(64));
+ // No punctuation
+ assertThat(secretString, not(matchesRegex(".*[!\"#$%&'()*+,\\-./:;<=>?@\\[\\\\\\]^_`{|}~].*")));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ void createStack_secretWithGenerateSecretString_templateAndKey() {
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-gen-template",
+ "GenerateSecretString": {
+ "SecretStringTemplate": "{\\"username\\": \\"admin\\"}",
+ "GenerateStringKey": "password",
+ "PasswordLength": 20,
+ "ExcludePunctuation": true
+ }
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "gen-secret-tpl")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String body = given()
+ .header("X-Amz-Target", "secretsmanager.GetSecretValue")
+ .contentType(SM_CONTENT_TYPE)
+ .body("{\"SecretId\": \"cfn-gen-template\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+
+ try {
+ JsonNode json = OBJECT_MAPPER.readTree(body);
+ String secretString = json.get("SecretString").asText();
+ assertThat(secretString, notNullValue());
+ // Parse the secret value as JSON
+ JsonNode secretJson = OBJECT_MAPPER.readTree(secretString);
+ assertThat(secretJson.get("username").asText(), equalTo("admin"));
+ assertThat(secretJson.has("password"), equalTo(true));
+ assertThat(secretJson.get("password").asText().length(), equalTo(20));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ void createStack_secretWithDescription() {
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-desc-secret",
+ "Description": "My test secret description",
+ "SecretString": "my-value"
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "desc-secret-stack")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ // Verify description via DescribeSecret
+ given()
+ .header("X-Amz-Target", "secretsmanager.DescribeSecret")
+ .contentType(SM_CONTENT_TYPE)
+ .body("{\"SecretId\": \"cfn-desc-secret\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("Description", equalTo("My test secret description"))
+ .body("Name", equalTo("cfn-desc-secret"));
+ }
+
+ @Test
+ void createStack_secretWithDescriptionAndGenerateSecretString() {
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-desc-gen-secret",
+ "Description": "Generated secret with desc",
+ "GenerateSecretString": {
+ "PasswordLength": 16,
+ "ExcludeNumbers": true
+ }
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "desc-gen-stack")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ // Verify description
+ given()
+ .header("X-Amz-Target", "secretsmanager.DescribeSecret")
+ .contentType(SM_CONTENT_TYPE)
+ .body("{\"SecretId\": \"cfn-desc-gen-secret\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("Description", equalTo("Generated secret with desc"));
+
+ // Verify generated value
+ String body = given()
+ .header("X-Amz-Target", "secretsmanager.GetSecretValue")
+ .contentType(SM_CONTENT_TYPE)
+ .body("{\"SecretId\": \"cfn-desc-gen-secret\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+
+ try {
+ JsonNode json = OBJECT_MAPPER.readTree(body);
+ String secretString = json.get("SecretString").asText();
+ assertThat(secretString.length(), equalTo(16));
+ assertThat(secretString, not(matchesRegex(".*[0-9].*")));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ void createStack_secretWithBothSecretStringAndGenerateSecretString_fails() {
+ // AWS rejects when both SecretString and GenerateSecretString are specified
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-both-secret",
+ "SecretString": "explicit-value",
+ "GenerateSecretString": {
+ "PasswordLength": 64
+ }
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "both-secret-stack")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ // The resource should have failed provisioning
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", "both-secret-stack")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("CREATE_FAILED"));
+ }
+
+ @Test
+ void createStack_secretWithNoSecretStringOrGenerate_defaultsEmptyJson() {
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-no-value-secret"
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "no-value-secret-stack")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "secretsmanager.GetSecretValue")
+ .contentType(SM_CONTENT_TYPE)
+ .body("{\"SecretId\": \"cfn-no-value-secret\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("SecretString", equalTo("{}"));
+ }
+
+ @Test
+ void createStack_secretAutoName_withGenerateSecretString() {
+ String template = """
+ {
+ "Resources": {
+ "AutoSecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "GenerateSecretString": {
+ "PasswordLength": 10,
+ "ExcludeLowercase": true,
+ "ExcludeUppercase": true,
+ "ExcludePunctuation": true
+ }
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "auto-gen-stack")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ // Verify resource was created with auto-generated name
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", "auto-gen-stack")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("auto-gen-stack-AutoSecret-"))
+ .body(containsString("CREATE_COMPLETE"));
+ }
+
+ @Test
+ void createStack_secretRefReturnsArn() {
+ String template = """
+ {
+ "Resources": {
+ "MySecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "Properties": {
+ "Name": "cfn-ref-secret",
+ "GenerateSecretString": {}
+ }
+ }
+ },
+ "Outputs": {
+ "SecretArn": {
+ "Value": {"Ref": "MySecret"}
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", "ref-secret-stack")
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", "ref-secret-stack")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("arn:aws:secretsmanager:"));
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/RandomPasswordGeneratorTest.java b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/RandomPasswordGeneratorTest.java
new file mode 100644
index 0000000000..76012918bb
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/RandomPasswordGeneratorTest.java
@@ -0,0 +1,174 @@
+package io.github.hectorvent.floci.services.secretsmanager;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class RandomPasswordGeneratorTest {
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ @Test
+ void defaultGenerates32Chars() {
+ String password = RandomPasswordGenerator.generate(MAPPER.createObjectNode());
+ assertThat(password, hasLength(32));
+ }
+
+ @Test
+ void nullNodeGenerates32Chars() {
+ String password = RandomPasswordGenerator.generate(null);
+ assertThat(password, hasLength(32));
+ }
+
+ @Test
+ void customLength() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", 64);
+ assertThat(RandomPasswordGenerator.generate(node), hasLength(64));
+ }
+
+ @Test
+ void lengthOfOne_withRequireEachDisabled() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", 1);
+ node.put("RequireEachIncludedType", false);
+ assertThat(RandomPasswordGenerator.generate(node), hasLength(1));
+ }
+
+ @Test
+ void lengthOfOne_withRequireEachEnabled_returnsMinimum4() {
+ // RequireEachIncludedType defaults to true, forcing minimum 4 (one per char type)
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", 1);
+ assertThat(RandomPasswordGenerator.generate(node), hasLength(4));
+ }
+
+ @Test
+ void lengthAbove4096Throws() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", 4097);
+ assertThrows(IllegalArgumentException.class, () -> RandomPasswordGenerator.generate(node));
+ }
+
+ @Test
+ void lengthZeroThrows() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", 0);
+ assertThrows(IllegalArgumentException.class, () -> RandomPasswordGenerator.generate(node));
+ }
+
+ @Test
+ void negativeLengthThrows() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", -5);
+ assertThrows(IllegalArgumentException.class, () -> RandomPasswordGenerator.generate(node));
+ }
+
+ @Test
+ void excludeLowercase() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludeLowercase", true);
+ node.put("PasswordLength", 100);
+ assertThat(RandomPasswordGenerator.generate(node), not(matchesPattern(".*[a-z].*")));
+ }
+
+ @Test
+ void excludeUppercase() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludeUppercase", true);
+ node.put("PasswordLength", 100);
+ assertThat(RandomPasswordGenerator.generate(node), not(matchesPattern(".*[A-Z].*")));
+ }
+
+ @Test
+ void excludeNumbers() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludeNumbers", true);
+ node.put("PasswordLength", 100);
+ assertThat(RandomPasswordGenerator.generate(node), not(matchesPattern(".*[0-9].*")));
+ }
+
+ @Test
+ void excludePunctuation() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludePunctuation", true);
+ node.put("PasswordLength", 100);
+ assertThat(RandomPasswordGenerator.generate(node),
+ not(matchesPattern(".*[!\"#$%&'()*+,\\-./:;<=>?@\\[\\\\\\]^_`{|}~].*")));
+ }
+
+ @Test
+ void includeSpace() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("IncludeSpace", true);
+ node.put("ExcludeLowercase", true);
+ node.put("ExcludeUppercase", true);
+ node.put("ExcludeNumbers", true);
+ node.put("ExcludePunctuation", true);
+ node.put("PasswordLength", 10);
+ assertThat(RandomPasswordGenerator.generate(node), is(" ")); // 10 spaces
+ }
+
+ @Test
+ void excludeCharacters() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludeCharacters", "abcABC123");
+ node.put("PasswordLength", 100);
+ String password = RandomPasswordGenerator.generate(node);
+ assertThat(password, not(matchesPattern(".*[abcABC123].*")));
+ }
+
+ @Test
+ void requireEachIncludedTypeDefaultTrue() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", 100);
+ String password = RandomPasswordGenerator.generate(node);
+ assertThat(password, matchesPattern(".*[a-z].*"));
+ assertThat(password, matchesPattern(".*[A-Z].*"));
+ assertThat(password, matchesPattern(".*[0-9].*"));
+ }
+
+ @Test
+ void requireEachIncludedTypeFalse() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludeLowercase", true);
+ node.put("ExcludeUppercase", true);
+ node.put("ExcludePunctuation", true);
+ node.put("RequireEachIncludedType", false);
+ node.put("PasswordLength", 32);
+ assertThat(RandomPasswordGenerator.generate(node), matchesPattern("[0-9]+"));
+ }
+
+ @Test
+ void emptyCharsetThrows() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludeLowercase", true);
+ node.put("ExcludeUppercase", true);
+ node.put("ExcludeNumbers", true);
+ node.put("ExcludePunctuation", true);
+ assertThrows(IllegalArgumentException.class, () -> RandomPasswordGenerator.generate(node));
+ }
+
+ @Test
+ void maxLength4096Works() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("PasswordLength", 4096);
+ assertThat(RandomPasswordGenerator.generate(node), hasLength(4096));
+ }
+
+ @Test
+ void excludeAllButDigitsWithExcludeCharacters() {
+ ObjectNode node = MAPPER.createObjectNode();
+ node.put("ExcludeLowercase", true);
+ node.put("ExcludeUppercase", true);
+ node.put("ExcludePunctuation", true);
+ node.put("ExcludeCharacters", "02468");
+ node.put("PasswordLength", 20);
+ // Only odd digits should remain: 1, 3, 5, 7, 9
+ assertThat(RandomPasswordGenerator.generate(node), matchesPattern("[13579]+"));
+ }
+}