Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ses): add DKIM actions with domain-inherited email DKIM (#1904)
Kenshin Okinakaff0201a13a76
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesIdentityAttributesTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesIdentityAttributesTest.javaindex 122c137522..9132e183f2 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesIdentityAttributesTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesIdentityAttributesTest.java@@ -11,25 +11,37 @@ import org.junit.jupiter.api.TestMethodOrder;import software.amazon.awssdk.awscore.exception.AwsServiceException;import software.amazon.awssdk.services.ses.SesClient;import software.amazon.awssdk.services.ses.model.DeleteIdentityRequest;+import software.amazon.awssdk.services.ses.model.GetIdentityDkimAttributesRequest;import software.amazon.awssdk.services.ses.model.GetIdentityMailFromDomainAttributesRequest;import software.amazon.awssdk.services.ses.model.GetIdentityMailFromDomainAttributesResponse;import software.amazon.awssdk.services.ses.model.GetIdentityNotificationAttributesRequest;import software.amazon.awssdk.services.ses.model.GetIdentityNotificationAttributesResponse;+import software.amazon.awssdk.services.ses.model.IdentityDkimAttributes;import software.amazon.awssdk.services.ses.model.IdentityMailFromDomainAttributes;import software.amazon.awssdk.services.ses.model.IdentityNotificationAttributes;+import software.amazon.awssdk.services.ses.model.SetIdentityDkimEnabledRequest;import software.amazon.awssdk.services.ses.model.SetIdentityFeedbackForwardingEnabledRequest;import software.amazon.awssdk.services.ses.model.SetIdentityHeadersInNotificationsEnabledRequest;import software.amazon.awssdk.services.ses.model.SetIdentityMailFromDomainRequest;+import software.amazon.awssdk.services.ses.model.VerifyDomainDkimRequest;import software.amazon.awssdk.services.ses.model.VerifyDomainIdentityRequest;import software.amazon.awssdk.services.sesv2.SesV2Client;import software.amazon.awssdk.services.sesv2.model.BadRequestException;import software.amazon.awssdk.services.sesv2.model.CreateEmailIdentityRequest;import software.amazon.awssdk.services.sesv2.model.DeleteEmailIdentityRequest;+import software.amazon.awssdk.services.sesv2.model.DkimAttributes;+import software.amazon.awssdk.services.sesv2.model.DkimSigningAttributes;+import software.amazon.awssdk.services.sesv2.model.DkimStatus;+import software.amazon.awssdk.services.sesv2.model.DkimSigningAttributesOrigin;+import software.amazon.awssdk.services.sesv2.model.DkimSigningKeyLength;import software.amazon.awssdk.services.sesv2.model.GetEmailIdentityRequest;import software.amazon.awssdk.services.sesv2.model.GetEmailIdentityResponse;import software.amazon.awssdk.services.sesv2.model.IdentityInfo;import software.amazon.awssdk.services.sesv2.model.ListEmailIdentitiesRequest;+import software.amazon.awssdk.services.sesv2.model.NotFoundException;+import software.amazon.awssdk.services.sesv2.model.PutEmailIdentityDkimSigningAttributesRequest;+import software.amazon.awssdk.services.sesv2.model.PutEmailIdentityDkimSigningAttributesResponse;import software.amazon.awssdk.services.sesv2.model.PutEmailIdentityMailFromAttributesRequest;import software.amazon.awssdk.services.sesv2.model.VerificationStatus;@@ -46,6 +58,13 @@ class SesIdentityAttributesTest {private static SesV2Client sesV2;private static String v1Domain;private static String v2Domain;+ // DKIM tests use their own identities so their token regeneration / status resets don't interfere+ // with the ordered MAIL FROM / notification tests above.+ private static String dkimDomain;+ // A separate domain that is DKIM-verified (Success) via Route53, plus an email under it, to check+ // that an email inherits its parent domain's *verified* DKIM.+ private static String verifiedDkimDomain;+ private static String verifiedDkimEmail;@BeforeAllstatic void setup() {@@ -54,6 +73,9 @@ class SesIdentityAttributesTest {String suffix = TestFixtures.uniqueName();v1Domain = suffix + ".v1-attrs.example.com";v2Domain = suffix + ".v2-attrs.example.com";+ dkimDomain = suffix + ".dkim-attrs.example.com";+ verifiedDkimDomain = suffix + ".dkim-verified.example.com";+ verifiedDkimEmail = "user@" + verifiedDkimDomain;}@AfterAll@@ -62,13 +84,17 @@ class SesIdentityAttributesTest {try {sesV1.deleteIdentity(DeleteIdentityRequest.builder().identity(v1Domain).build());} catch (Exception ignored) {}+ try {+ sesV1.deleteIdentity(DeleteIdentityRequest.builder().identity(dkimDomain).build());+ } catch (Exception ignored) {}sesV1.close();}if (sesV2 != null) {- try {- sesV2.deleteEmailIdentity(DeleteEmailIdentityRequest.builder()- .emailIdentity(v2Domain).build());- } catch (Exception ignored) {}+ for (String id : new String[] {v2Domain, verifiedDkimEmail, verifiedDkimDomain}) {+ try {+ sesV2.deleteEmailIdentity(DeleteEmailIdentityRequest.builder().emailIdentity(id).build());+ } catch (Exception ignored) {}+ }sesV2.close();}}@@ -198,4 +224,91 @@ class SesIdentityAttributesTest {sesV2.deleteEmailIdentity(DeleteEmailIdentityRequest.builder().emailIdentity(domain).build());}}++ // ───────────────────────── DKIM ─────────────────────────++ @Test+ @Order(20)+ void verifyDomainDkim_returnsStableTokens() {+ sesV1.verifyDomainIdentity(VerifyDomainIdentityRequest.builder().domain(dkimDomain).build());++ List<String> first = sesV1.verifyDomainDkim(+ VerifyDomainDkimRequest.builder().domain(dkimDomain).build()).dkimTokens();+ assertThat(first).hasSize(3);++ List<String> second = sesV1.verifyDomainDkim(+ VerifyDomainDkimRequest.builder().domain(dkimDomain).build()).dkimTokens();+ assertThat(second).isEqualTo(first);+ }++ @Test+ @Order(21)+ void setIdentityDkimEnabled_togglesFlag() {+ sesV1.setIdentityDkimEnabled(SetIdentityDkimEnabledRequest.builder()+ .identity(dkimDomain).dkimEnabled(false).build());++ IdentityDkimAttributes attrs = sesV1.getIdentityDkimAttributes(+ GetIdentityDkimAttributesRequest.builder().identities(dkimDomain).build())+ .dkimAttributes().get(dkimDomain);+ assertThat(attrs.dkimEnabled()).isFalse();++ sesV1.setIdentityDkimEnabled(SetIdentityDkimEnabledRequest.builder()+ .identity(dkimDomain).dkimEnabled(true).build());+ }++ @Test+ @Order(22)+ void setIdentityDkimEnabled_unknownIdentity_throws() {+ assertThatThrownBy(() -> sesV1.setIdentityDkimEnabled(SetIdentityDkimEnabledRequest.builder()+ .identity("unknown." + dkimDomain).dkimEnabled(true).build()))+ .isInstanceOf(AwsServiceException.class);+ }++ @Test+ @Order(23)+ void putEmailIdentityDkimSigningAttributes_regeneratesTokensOnKeyLengthChange() {+ List<String> before = sesV2.getEmailIdentity(GetEmailIdentityRequest.builder()+ .emailIdentity(dkimDomain).build()).dkimAttributes().tokens();++ PutEmailIdentityDkimSigningAttributesResponse resp = sesV2.putEmailIdentityDkimSigningAttributes(+ PutEmailIdentityDkimSigningAttributesRequest.builder()+ .emailIdentity(dkimDomain)+ .signingAttributesOrigin(DkimSigningAttributesOrigin.AWS_SES)+ .signingAttributes(DkimSigningAttributes.builder()+ .nextSigningKeyLength(DkimSigningKeyLength.RSA_1024_BIT).build())+ .build());+ assertThat(resp.dkimTokens()).hasSize(3);+ assertThat(resp.dkimTokens()).isNotEqualTo(before);+ }++ @Test+ @Order(24)+ void putEmailIdentityDkimSigningAttributes_unknownIdentity_throwsNotFound() {+ assertThatThrownBy(() -> sesV2.putEmailIdentityDkimSigningAttributes(+ PutEmailIdentityDkimSigningAttributesRequest.builder()+ .emailIdentity("ghost." + dkimDomain)+ .signingAttributesOrigin(DkimSigningAttributesOrigin.AWS_SES)+ .build()))+ .isInstanceOf(NotFoundException.class);+ }++ @Test+ @Order(25)+ void emailIdentity_inheritsVerifiedParentDomainDkim() {+ // Bring the parent domain to DKIM Success via Route53 so the email inherits SUCCESS (not Pending).+ TestFixtures.verifySesDomainIdentityViaRoute53(sesV2, verifiedDkimDomain);+ DkimAttributes domainDkim = sesV2.getEmailIdentity(GetEmailIdentityRequest.builder()+ .emailIdentity(verifiedDkimDomain).build()).dkimAttributes();+ assertThat(domainDkim.status()).isEqualTo(DkimStatus.SUCCESS);++ sesV2.createEmailIdentity(CreateEmailIdentityRequest.builder()+ .emailIdentity(verifiedDkimEmail).build());+ DkimAttributes emailDkim = sesV2.getEmailIdentity(GetEmailIdentityRequest.builder()+ .emailIdentity(verifiedDkimEmail).build()).dkimAttributes();++ // The email carries no DKIM of its own; it mirrors the verified domain's status and tokens.+ assertThat(emailDkim.signingEnabled()).isTrue();+ assertThat(emailDkim.status()).isEqualTo(DkimStatus.SUCCESS);+ assertThat(emailDkim.tokens()).isEqualTo(domainDkim.tokens());+ }}diff --git a/docs/services/ses.md b/docs/services/ses.mdindex b573d5fad3..772b48883f 100644--- a/docs/services/ses.md+++ b/docs/services/ses.md@@ -43,7 +43,9 @@ Floci exposes the classic Amazon SES Query API used by `aws ses ...` commands an| `SetIdentityHeadersInNotificationsEnabled` | Toggle headers-in-notifications per notification type || `SetIdentityMailFromDomain` | Set or clear the MAIL FROM domain for an identity || `GetIdentityMailFromDomainAttributes` | Read MAIL FROM domain settings |-| `GetIdentityDkimAttributes` | Return DKIM status for identities |+| `GetIdentityDkimAttributes` | Return DKIM status for identities (an email inherits its domain's DKIM) |+| `SetIdentityDkimEnabled` | Enable or disable DKIM signing for an identity |+| `VerifyDomainDkim` | Return a domain's (stable) DKIM CNAME tokens || `PutIdentityPolicy` | Create or replace a sending-authorization policy on an identity || `GetIdentityPolicies` | Return the requested policies for an identity || `ListIdentityPolicies` | List an identity's policy names |@@ -193,6 +195,7 @@ Alongside the classic Query API, Floci implements a subset of the SES v2 REST JS| `GET` | `/v2/email/identities/{emailIdentity}` | `GetEmailIdentity` || `DELETE` | `/v2/email/identities/{emailIdentity}` | `DeleteEmailIdentity` || `PUT` | `/v2/email/identities/{emailIdentity}/dkim` | `PutEmailIdentityDkimAttributes` |+| `PUT` | `/v2/email/identities/{emailIdentity}/dkim/signing` | `PutEmailIdentityDkimSigningAttributes` (Easy DKIM / BYODKIM) || `PUT` | `/v2/email/identities/{emailIdentity}/feedback` | `PutEmailIdentityFeedbackAttributes` || `PUT` | `/v2/email/identities/{emailIdentity}/mail-from` | `PutEmailIdentityMailFromAttributes` || `PUT` | `/v2/email/identities/{emailIdentity}/configuration-set` | `PutEmailIdentityConfigurationSetAttributes` |@@ -283,3 +286,5 @@ For a **single-recipient** list-managed send, Floci injects a functional unsubscTag operations support these ARN forms: `arn:aws:ses:<region>:<account>:configuration-set/<name>`, `arn:aws:ses:<region>:<account>:template/<name>`, and `arn:aws:ses:<region>:<account>:identity/<email-or-domain>`. Tags supplied to `CreateConfigurationSet`, `CreateEmailTemplate`, and `CreateEmailIdentity` are reachable through `ListTagsForResource`; `UpdateEmailTemplate` does not modify tags. Other resource types return `NotFoundException`.Identity, identity-policy, template, custom-verification-template, configuration-set, and sent-message state is shared between the v1 Query API and the v2 REST JSON API, so a template created with `CreateTemplate` resolves through `SendEmail` on v2 (and vice versa), a policy written with `PutIdentityPolicy` (v1) is returned by `GetEmailIdentityPolicies` (v2), a custom verification email template created with `CreateCustomVerificationEmailTemplate` (v1) is returned by `GetCustomVerificationEmailTemplate` (v2), a configuration set created with `CreateConfigurationSet` is visible to both `DescribeConfigurationSet` (v1) and `GetConfigurationSet` (v2), and every send appears in the same `GET /_aws/ses` inspection mailbox.++DKIM follows AWS's domain-centric model. A **domain** identity carries DKIM tokens (generated at verification, stable across `VerifyDomainDkim` calls); its `DkimVerificationStatus` tracks **DNS record detection** — it transitions to `Success` when the expected `<token>._domainkey.<domain>` CNAMEs are present in the Route53 emulation, not when DKIM is enabled. An **email** identity has no DKIM of its own: its `DkimAttributes` (`SigningEnabled`, `Status`, `Tokens`) are inherited from its parent domain identity when one is registered. The parent is the exact domain after the `@` (verified against AWS): a verified `example.com` covers `[email protected]` but not `[email protected]` unless `mail.example.com` is itself a registered identity. `SetIdentityDkimEnabled` / `PutEmailIdentityDkimAttributes` only toggle the signing flag (they no longer force the verification status); `PutEmailIdentityDkimSigningAttributes` sets the signing origin (`AWS_SES` Easy DKIM — regenerating tokens when the key length changes — or `EXTERNAL` BYODKIM).diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex 92170cfd25..a0ce0adedd 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -392,6 +392,8 @@ public class AwsQueryController {"GetAccountSendingEnabled", "ListVerifiedEmailAddresses", "DeleteVerifiedEmailAddress","SetIdentityNotificationTopic", "GetIdentityNotificationAttributes","SetIdentityFeedbackForwardingEnabled",+ "SetIdentityDkimEnabled",+ "VerifyDomainDkim","SetIdentityHeadersInNotificationsEnabled","SetIdentityMailFromDomain", "GetIdentityMailFromDomainAttributes","GetIdentityDkimAttributes",diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesController.javaindex 42185d3b49..8c5d0d457b 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java@@ -150,7 +150,7 @@ public class SesController {result.put("IdentityType", toV2IdentityType(identity.getIdentityType()));result.put("VerifiedForSendingStatus","Success".equals(identity.getVerificationStatus()));- result.set("DkimAttributes", buildDkimAttributes(identity));+ result.set("DkimAttributes", buildDkimAttributes(identity, region));LOG.infov("SES V2 CreateEmailIdentity: {0}", emailIdentity);return Response.ok(result).build();@@ -199,7 +199,7 @@ public class SesController {throw new AwsException("NotFoundException","Identity " + emailIdentity + " does not exist.", 404);}- return Response.ok(buildFullIdentityResponse(identity)).build();+ return Response.ok(buildFullIdentityResponse(identity, region)).build();}@DELETE@@ -320,6 +320,50 @@ public class SesController {}}+ @PUT+ @Path("/identities/{emailIdentity}/dkim/signing")+ public Response putEmailIdentityDkimSigningAttributes(@Context HttpHeaders headers,+ @PathParam("emailIdentity") String emailIdentity,+ String body) {+ String region = regionResolver.resolveRegion(headers);+ try {+ JsonNode request = (body == null || body.isBlank())+ ? objectMapper.createObjectNode() : objectMapper.readTree(body);+ requireJsonObject(request);+ String origin = request.path("SigningAttributesOrigin").asText(null);+ if (!"AWS_SES".equals(origin) && !"EXTERNAL".equals(origin)) {+ throw new AwsException("BadRequestException",+ "SigningAttributesOrigin must be AWS_SES or EXTERNAL.", 400);+ }+ JsonNode attrs = requireObjectOrAbsent(request, "SigningAttributes");+ String selector = attrs.path("DomainSigningSelector").asText(null);+ String nextKeyLength = attrs.path("NextSigningKeyLength").asText(null);+ if (nextKeyLength != null+ && !"RSA_1024_BIT".equals(nextKeyLength) && !"RSA_2048_BIT".equals(nextKeyLength)) {+ throw new AwsException("BadRequestException",+ "NextSigningKeyLength must be RSA_1024_BIT or RSA_2048_BIT.", 400);+ }+ String privateKey = attrs.path("DomainSigningPrivateKey").asText(null);+ if ("EXTERNAL".equals(origin)+ && (selector == null || selector.isBlank()+ || privateKey == null || privateKey.isBlank())) {+ throw new AwsException("BadRequestException",+ "EXTERNAL origin requires DomainSigningSelector and DomainSigningPrivateKey.", 400);+ }+ SesService.DkimSigningResult result = sesService.putDkimSigningAttributes(+ emailIdentity, origin, selector, nextKeyLength, region);+ ObjectNode out = objectMapper.createObjectNode();+ out.put("DkimStatus", toV2Status(result.dkimStatus()));+ ArrayNode tokens = out.putArray("DkimTokens");+ result.dkimTokens().forEach(tokens::add);+ return Response.ok(out).build();+ } catch (AwsException e) {+ throw remapV1Exception(e);+ } catch (Exception e) {+ throw new AwsException("BadRequestException", e.getMessage(), 400);+ }+ }+// ────────────────── Identity MAIL FROM ──────────────────────────@PUT@@ -2105,7 +2149,7 @@ public class SesController {// ──────────────────────────── Helpers ────────────────────────────- private ObjectNode buildFullIdentityResponse(Identity identity) {+ private ObjectNode buildFullIdentityResponse(Identity identity, String region) {ObjectNode result = objectMapper.createObjectNode();result.put("IdentityType", toV2IdentityType(identity.getIdentityType()));result.put("VerifiedForSendingStatus",@@ -2113,7 +2157,7 @@ public class SesController {result.put("VerificationStatus", toV2Status(identity.getVerificationStatus()));result.put("FeedbackForwardingStatus", identity.isFeedbackForwardingEnabled());- result.set("DkimAttributes", buildDkimAttributes(identity));+ result.set("DkimAttributes", buildDkimAttributes(identity, region));ObjectNode mailFromAttributes = result.putObject("MailFromAttributes");mailFromAttributes.put("BehaviorOnMxFailure", v1BehaviorToV2(identity.getBehaviorOnMxFailure()));@@ -2161,16 +2205,28 @@ public class SesController {+ "constraint: Member must satisfy enum value set: [REJECT_MESSAGE, USE_DEFAULT_VALUE]", 400);}- private ObjectNode buildDkimAttributes(Identity identity) {+ private ObjectNode buildDkimAttributes(Identity identity, String region) {+ // An email identity reports its parent domain's DKIM (SigningEnabled / Status / Tokens all+ // inherit from the domain), matching AWS; a domain reports its own.+ Identity src = sesService.effectiveDkimSource(identity, region);ObjectNode dkim = objectMapper.createObjectNode();- dkim.put("SigningEnabled", identity.isDkimEnabled());- dkim.put("Status", toV2Status(identity.getDkimVerificationStatus()));+ dkim.put("SigningEnabled", src.isDkimEnabled());+ dkim.put("Status", toV2Status(src.getDkimVerificationStatus()));ArrayNode tokens = dkim.putArray("Tokens");- if (identity.getDkimTokens() != null) {- for (String token : identity.getDkimTokens()) {+ if (src.getDkimTokens() != null) {+ for (String token : src.getDkimTokens()) {tokens.add(token);}}+ dkim.put("SigningAttributesOrigin", src.getDkimSigningAttributesOrigin());+ dkim.put("NextSigningKeyLength", src.getDkimNextSigningKeyLength());+ dkim.put("CurrentSigningKeyLength", src.getDkimCurrentSigningKeyLength());+ if (src.getDkimLastKeyGenerationTimestamp() != null) {+ // SES v2 (restJson1) serializes this timestamp as epoch seconds (a number); emitting an+ // ISO string breaks the SDK's unixTimestamp unmarshaller.+ dkim.put("LastKeyGenerationTimestamp",+ src.getDkimLastKeyGenerationTimestamp().toEpochMilli() / 1000.0);+ }return dkim;}diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.javaindex 5566af60c7..e5bb966474 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.java@@ -71,6 +71,8 @@ public class SesQueryHandler {case "SetIdentityNotificationTopic" -> handleSetIdentityNotificationTopic(params, region);case "GetIdentityNotificationAttributes" -> handleGetIdentityNotificationAttributes(params, region);case "SetIdentityFeedbackForwardingEnabled" -> handleSetIdentityFeedbackForwardingEnabled(params, region);+ case "SetIdentityDkimEnabled" -> handleSetIdentityDkimEnabled(params, region);+ case "VerifyDomainDkim" -> handleVerifyDomainDkim(params, region);case "SetIdentityHeadersInNotificationsEnabled" -> handleSetIdentityHeadersInNotificationsEnabled(params, region);case "SetIdentityMailFromDomain" -> handleSetIdentityMailFromDomain(params, region);case "GetIdentityMailFromDomainAttributes" -> handleGetIdentityMailFromDomainAttributes(params, region);@@ -334,14 +336,16 @@ public class SesQueryHandler {var xml = new XmlBuilder().start("DkimAttributes");for (String identityValue : identities) {Identity identity = sesService.getIdentityVerificationAttributes(identityValue, region);+ // An email identity reports its parent domain's DKIM state (matching AWS).+ Identity src = sesService.effectiveDkimSource(identity, region);xml.start("entry");xml.elem("key", identityValue);xml.start("value");- xml.elem("DkimEnabled", identity != null ? String.valueOf(identity.isDkimEnabled()) : "false");- xml.elem("DkimVerificationStatus", identity != null ? identity.getDkimVerificationStatus() : "NotStarted");+ xml.elem("DkimEnabled", src != null ? String.valueOf(src.isDkimEnabled()) : "false");+ xml.elem("DkimVerificationStatus", src != null ? src.getDkimVerificationStatus() : "NotStarted");xml.start("DkimTokens");- if (identity != null && identity.getDkimTokens() != null) {- for (String token : identity.getDkimTokens()) {+ if (src != null && src.getDkimTokens() != null) {+ for (String token : src.getDkimTokens()) {xml.elem("member", token);}}@@ -360,6 +364,24 @@ public class SesQueryHandler {return Response.ok(AwsQueryResponse.envelopeEmptyResult("SetIdentityFeedbackForwardingEnabled", AwsNamespaces.SES)).build();}+ private Response handleSetIdentityDkimEnabled(MultivaluedMap<String, String> params, String region) {+ String identityValue = getParam(params, "Identity");+ boolean enabled = parseRequiredBoolean(params, "DkimEnabled");+ sesService.setDkimAttributes(identityValue, enabled, region);+ return Response.ok(AwsQueryResponse.envelopeEmptyResult("SetIdentityDkimEnabled", AwsNamespaces.SES)).build();+ }++ private Response handleVerifyDomainDkim(MultivaluedMap<String, String> params, String region) {+ String domain = getParam(params, "Domain");+ List<String> tokens = sesService.verifyDomainDkim(domain, region);+ var xml = new XmlBuilder().start("DkimTokens");+ for (String token : tokens) {+ xml.elem("member", token);+ }+ xml.end("DkimTokens");+ return Response.ok(AwsQueryResponse.envelope("VerifyDomainDkim", AwsNamespaces.SES, xml.build())).build();+ }+private Response handleSetIdentityHeadersInNotificationsEnabled(MultivaluedMap<String, String> params, String region) {String identityValue = getParam(params, "Identity");String notificationType = getParam(params, "NotificationType");diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesService.javaindex a55d615802..5229e61ec5 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java@@ -255,10 +255,13 @@ public class SesService {if (existing != null) return existing;Identity identity = new Identity(domain, "Domain");- identity.setDkimTokens(generateDkimTokens());+ regenerateDkimTokens(identity);identity.setVerificationStatus("Pending");identity.setDkimEnabled(true);- identity.setDkimVerificationStatus("Pending");+ // The create response reports DKIM verification as NotStarted (SES hasn't begun tracking the+ // CNAMEs yet); the first Get/List refresh transitions it to Pending. Matches AWS, where+ // CreateEmailIdentity returns NOT_STARTED but a subsequent GetEmailIdentity returns PENDING.+ identity.setDkimVerificationStatus("NotStarted");identityStore.put(key, identity);LOG.infov("Verified domain identity: {0} in region {1}", domain, region);return identity;@@ -677,27 +680,33 @@ public class SesService {}public void setDkimAttributes(String identityValue, boolean signingEnabled, String region) {+ if (identityValue == null || identityValue.isBlank()) {+ throw new AwsException("InvalidParameterValue", "Identity is required.", 400);+ }+ // DKIM is a domain concept and an email reports its parent domain's DKIM (via effectiveDkimSource),+ // so toggling DKIM on an email whose parent domain is a registered identity is a no-op that leaves+ // the domain untouched — matching real AWS, regardless of whether the email identity itself exists.+ if (identityValue.contains("@")) {+ String domain = identityValue.substring(identityValue.indexOf('@') + 1);+ if (identityStore.get(identityKey(region, domain)).isPresent()) {+ return;+ }+ }String key = identityKey(region, identityValue);Identity identity = identityStore.get(key).orElse(null);-if (identity == null) {- String domain = identityValue != null && identityValue.contains("@")+ String domain = identityValue.contains("@")? identityValue.substring(identityValue.indexOf('@') + 1): identityValue;- if (identityValue != null && identityValue.contains("@")- && identityStore.get(identityKey(region, domain)).isPresent()) {- return;- }- throw new AwsException("BadRequestException",+ // v1-native code; the v2 controller remaps InvalidParameterValue -> BadRequestException.+ throw new AwsException("InvalidParameterValue","Domain " + domain + " is not verified for DKIM signing.", 400);}+ // Only toggle the signing flag. DkimVerificationStatus tracks DNS record detection (via the+ // Route53 lookup in refreshIdentityState), not the enabled flag — matching real AWS, where+ // SetIdentityDkimEnabled / PutEmailIdentityDkimAttributes leave the verification status alone.identity.setDkimEnabled(signingEnabled);- if (signingEnabled) {- identity.setDkimVerificationStatus("Success");- } else {- identity.setDkimVerificationStatus("NotStarted");- }identityStore.put(key, identity);LOG.infov("Updated DKIM attributes for {0}: signingEnabled={1}", identityValue, signingEnabled);}@@ -710,6 +719,128 @@ public class SesService {return tokens;}+ /**+ * Generates a fresh Easy DKIM token set and records the key length / generation timestamp. New+ * tokens mean the previously published CNAMEs no longer match, so the verification status resets+ * to Pending (re-detected via the Route53 lookup) and the origin returns to AWS_SES. Only meaningful+ * for domain identities; refreshIdentityState re-upgrades to Success once the new records exist.+ */+ private void regenerateDkimTokens(Identity identity) {+ identity.setDkimTokens(generateDkimTokens());+ identity.setDkimCurrentSigningKeyLength(identity.getDkimNextSigningKeyLength());+ identity.setDkimLastKeyGenerationTimestamp(Instant.now(clock));+ identity.setDkimSigningAttributesOrigin("AWS_SES");+ // The new tokens' CNAMEs aren't detected yet, so DKIM verification resets to Pending. The+ // identity's own verification is NOT revoked by a key rotation (matching AWS) — keep Success+ // when already verified; a not-yet-verified identity stays Pending.+ identity.setDkimVerificationStatus("Pending");+ if (!"Success".equals(identity.getVerificationStatus())) {+ identity.setVerificationStatus("Pending");+ }+ }++ /**+ * v1 VerifyDomainDkim: returns the domain identity's DKIM tokens (3), generating them if needed.+ * Tokens are stable across calls (AWS does not regenerate them). The domain is registered as a+ * pending identity if it does not exist yet, matching AWS's lenient behavior (VerifyDomainDkim+ * starts DKIM setup for any domain).+ */+ public List<String> verifyDomainDkim(String domain, String region) {+ validateIdentityWhitespace(domain, "Domain");+ if (domain == null || domain.isBlank()) {+ throw new AwsException("InvalidParameterValue", "Domain is required.", 400);+ }+ if (domain.contains("@")) {+ // Domain-only action: an email-shaped value must not create an email-valued "Domain".+ throw new AwsException("InvalidParameterValue", "Domain " + domain + " is invalid.", 400);+ }+ String key = identityKey(region, domain);+ Identity identity = identityStore.get(key).orElse(null);+ if (identity == null) {+ identity = new Identity(domain, "Domain");+ identity.setVerificationStatus("Pending");+ identity.setDkimEnabled(true);+ identity.setDkimVerificationStatus("Pending");+ }+ if (!hasDkimTokens(identity)) {+ regenerateDkimTokens(identity);+ }+ identityStore.put(key, identity);+ LOG.infov("VerifyDomainDkim: {0} (region {1})", domain, region);+ return identity.getDkimTokens();+ }++ /**+ * v2 PutEmailIdentityDkimSigningAttributes. AWS_SES (Easy DKIM): sets the next signing key length+ * and regenerates tokens when the length changes. EXTERNAL (BYODKIM): switches the origin and+ * clears the Easy DKIM tokens (the caller publishes its own selector, which Floci does not use for+ * signing). Returns the resulting DKIM status and tokens.+ */+ public DkimSigningResult putDkimSigningAttributes(String identityValue, String origin,+ String signingSelector, String nextKeyLength,+ String region) {+ // DKIM signing attributes are domain-level; AWS rejects a missing/blank value or an+ // email-address identity here (verified: all return the same 400 "must be a valid domain")+ // rather than mutating state that the email would just inherit back from its parent domain.+ if (identityValue == null || identityValue.isBlank() || identityValue.contains("@")) {+ throw new AwsException("BadRequestException",+ "The EmailIdentity value must be a valid domain.", 400);+ }+ String key = identityKey(region, identityValue);+ Identity identity = identityStore.get(key)+ .orElseThrow(() -> new AwsException("NotFoundException",+ "Email identity " + identityValue + " does not exist.", 404));+ if ("EXTERNAL".equals(origin)) {+ identity.setDkimSigningAttributesOrigin("EXTERNAL");+ // Clear the Easy DKIM tokens and reset the status: Floci can't verify a BYODKIM selector,+ // so leaving a prior Success/Pending with no tokens (and no Route53 detection path) would+ // be inconsistent.+ identity.setDkimTokens(new ArrayList<>());+ identity.setDkimVerificationStatus("Pending");+ LOG.infov("PutEmailIdentityDkimSigningAttributes(EXTERNAL): {0} selector={1}",+ identityValue, signingSelector);+ } else {+ identity.setDkimSigningAttributesOrigin("AWS_SES");+ // DKIM tokens are a domain concept; only (re)generate them for a domain identity.+ if ("Domain".equals(identity.getIdentityType())) {+ if (nextKeyLength != null && !nextKeyLength.equals(identity.getDkimCurrentSigningKeyLength())) {+ identity.setDkimNextSigningKeyLength(nextKeyLength);+ regenerateDkimTokens(identity);+ } else if (!hasDkimTokens(identity)) {+ regenerateDkimTokens(identity);+ }+ }+ LOG.infov("PutEmailIdentityDkimSigningAttributes(AWS_SES): {0} keyLength={1}",+ identityValue, nextKeyLength);+ }+ identityStore.put(key, refreshIdentityState(identity, region));+ Identity src = effectiveDkimSource(identity, region);+ return new DkimSigningResult(src.getDkimVerificationStatus(),+ src.getDkimTokens() == null ? List.of() : src.getDkimTokens());+ }++ /** Carrier for the PutEmailIdentityDkimSigningAttributes response ({@code dkimStatus} is v1-native). */+ public record DkimSigningResult(String dkimStatus, List<String> dkimTokens) {}++ /**+ * Resolves which identity's DKIM state should be reported for {@code identity}. A domain reports+ * its own DKIM; an email address reports its parent domain's DKIM (SigningEnabled / Status /+ * Tokens all inherit from the domain), matching AWS. Falls back to the identity itself when the+ * parent domain is not a registered identity.+ */+ public Identity effectiveDkimSource(Identity identity, String region) {+ if (identity == null || !"EmailAddress".equals(identity.getIdentityType())) {+ return identity;+ }+ String addr = identity.getIdentity();+ int at = addr == null ? -1 : addr.indexOf('@');+ if (at < 0 || at == addr.length() - 1) {+ return identity;+ }+ Identity domainIdentity = identityStore.get(identityKey(region, addr.substring(at + 1))).orElse(null);+ return domainIdentity == null ? identity : refreshIdentityState(domainIdentity, region);+ }+private Identity refreshIdentityState(Identity identity, String region) {if (identity == null) {return null;@@ -717,19 +848,30 @@ public class SesService {boolean changed = false;if ("Domain".equals(identity.getIdentityType()) && identity.getDkimTokens() == null) {- identity.setDkimTokens(generateDkimTokens());+ regenerateDkimTokens(identity);changed = true;}if ("Domain".equals(identity.getIdentityType()) && hasDkimTokens(identity)) {changed |= normalizePendingDomainState(identity);- if (!"Success".equals(identity.getVerificationStatus())- && hasAllExpectedDkimRecords(identity, region)) {- identity.setVerificationStatus("Success");- if (identity.isDkimEnabled()) {+ // Upgrade identity- and DKIM-verification independently so that, e.g., after a key rotation+ // (which resets only DkimVerificationStatus while the identity stays verified), the DKIM+ // status can still return to Success once the new records are detected.+ // Only look up DNS when a status can still be upgraded — skip the (cached) Route53 check+ // once both identity- and DKIM-verification are already Success. DKIM verification tracks+ // DNS detection independently of the signing-enabled flag, so it can reach Success even+ // when DKIM signing is disabled, and can re-pend/re-upgrade after a key rotation.+ boolean needsUpgrade = !"Success".equals(identity.getVerificationStatus())+ || !"Success".equals(identity.getDkimVerificationStatus());+ if (needsUpgrade && hasAllExpectedDkimRecords(identity, region)) {+ if (!"Success".equals(identity.getVerificationStatus())) {+ identity.setVerificationStatus("Success");+ changed = true;+ }+ if (!"Success".equals(identity.getDkimVerificationStatus())) {identity.setDkimVerificationStatus("Success");+ changed = true;}- changed = true;}}@@ -754,8 +896,9 @@ public class SesService {identity.setVerificationStatus("Pending");changed = true;}- if (identity.isDkimEnabled()- && !"Success".equals(identity.getDkimVerificationStatus())+ // DKIM verification tracks DNS detection, not the signing-enabled flag, so a domain that has+ // begun tracking (NotStarted -> Pending) reports Pending on Get even while signing is disabled.+ if (!"Success".equals(identity.getDkimVerificationStatus())&& !"Pending".equals(identity.getDkimVerificationStatus())) {identity.setDkimVerificationStatus("Pending");changed = true;diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/model/Identity.java b/src/main/java/io/github/hectorvent/floci/services/ses/model/Identity.javaindex 1214ebfbbe..f2bdc73648 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/model/Identity.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/model/Identity.java@@ -35,6 +35,18 @@ public class Identity {@JsonProperty("DkimTokens")private List<String> dkimTokens;+ @JsonProperty("DkimSigningAttributesOrigin")+ private String dkimSigningAttributesOrigin = "AWS_SES"; // "AWS_SES" (Easy DKIM) or "EXTERNAL" (BYODKIM)++ @JsonProperty("DkimNextSigningKeyLength")+ private String dkimNextSigningKeyLength = "RSA_2048_BIT";++ @JsonProperty("DkimCurrentSigningKeyLength")+ private String dkimCurrentSigningKeyLength = "RSA_2048_BIT";++ @JsonProperty("DkimLastKeyGenerationTimestamp")+ private Instant dkimLastKeyGenerationTimestamp;+@JsonProperty("NotificationAttributes")private Map<String, String> notificationAttributes = new HashMap<>();@@ -95,6 +107,18 @@ public class Identity {public List<String> getDkimTokens() { return dkimTokens; }public void setDkimTokens(List<String> dkimTokens) { this.dkimTokens = dkimTokens; }+ public String getDkimSigningAttributesOrigin() { return dkimSigningAttributesOrigin; }+ public void setDkimSigningAttributesOrigin(String origin) { this.dkimSigningAttributesOrigin = origin; }++ public String getDkimNextSigningKeyLength() { return dkimNextSigningKeyLength; }+ public void setDkimNextSigningKeyLength(String len) { this.dkimNextSigningKeyLength = len; }++ public String getDkimCurrentSigningKeyLength() { return dkimCurrentSigningKeyLength; }+ public void setDkimCurrentSigningKeyLength(String len) { this.dkimCurrentSigningKeyLength = len; }++ public Instant getDkimLastKeyGenerationTimestamp() { return dkimLastKeyGenerationTimestamp; }+ public void setDkimLastKeyGenerationTimestamp(Instant ts) { this.dkimLastKeyGenerationTimestamp = ts; }+public Map<String, String> getNotificationAttributes() { return notificationAttributes; }public void setNotificationAttributes(Map<String, String> notificationAttributes) { this.notificationAttributes = notificationAttributes; }diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesDkimSigningActionsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesDkimSigningActionsIntegrationTest.javanew file mode 100644index 0000000000..dcbe1cd488--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesDkimSigningActionsIntegrationTest.java@@ -0,0 +1,254 @@+package io.github.hectorvent.floci.services.ses;++import io.github.hectorvent.floci.core.common.XmlParser;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotEquals;++/**+ * Integration tests for the DKIM actions: v1 {@code VerifyDomainDkim} / {@code SetIdentityDkimEnabled}+ * and v2 {@code PutEmailIdentityDkimSigningAttributes}, plus the email-inherits-parent-domain DKIM+ * behavior. Verified against real AWS (tokens stable on VerifyDomainDkim; email DKIM mirrors the+ * parent domain; DKIM status tracks DNS detection, not the enabled flag).+ */+@QuarkusTest+class SesDkimSigningActionsIntegrationTest {++ private static final String V1_AUTH =+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/email/aws4_request";+ private static final String V2_AUTH =+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/ses/aws4_request";++ private io.restassured.specification.RequestSpecification v1(String action) {+ return given().contentType("application/x-www-form-urlencoded")+ .header("Authorization", V1_AUTH).formParam("Action", action);+ }++ @Test+ void verifyDomainDkim_returnsThreeStableTokens_andRegistersDomain() {+ String domain = "dkim-verify.floci.test";+ List<String> first = XmlParser.extractAll(v1("VerifyDomainDkim").formParam("Domain", domain)+ .when().post("/").then().statusCode(200).extract().asString(), "member");+ assertEquals(3, first.size());++ // Stable across calls (AWS does not regenerate).+ List<String> second = XmlParser.extractAll(v1("VerifyDomainDkim").formParam("Domain", domain)+ .when().post("/").then().statusCode(200).extract().asString(), "member");+ assertEquals(first, second);++ // The domain is now a DKIM identity, visible via GetIdentityDkimAttributes.+ v1("GetIdentityDkimAttributes").formParam("Identities.member.1", domain)+ .when().post("/").then().statusCode(200)+ .body(containsString("<key>" + domain + "</key>"))+ .body(containsString("<DkimEnabled>true</DkimEnabled>"));+ }++ @Test+ void setIdentityDkimEnabled_togglesFlag_andUnknownIdentityErrors() {+ String domain = "dkim-toggle.floci.test";+ v1("VerifyDomainIdentity").formParam("Domain", domain).when().post("/").then().statusCode(200);++ v1("SetIdentityDkimEnabled").formParam("Identity", domain).formParam("DkimEnabled", "false")+ .when().post("/").then().statusCode(200)+ .body(containsString("SetIdentityDkimEnabledResponse"));++ v1("GetIdentityDkimAttributes").formParam("Identities.member.1", domain)+ .when().post("/").then().statusCode(200)+ .body(containsString("<DkimEnabled>false</DkimEnabled>"));++ // Unknown identity -> v1-native InvalidParameterValue.+ v1("SetIdentityDkimEnabled").formParam("Identity", "unknown-dkim.floci.test")+ .formParam("DkimEnabled", "true")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"))+ .body(containsString("is not verified for DKIM signing."));+ }++ @Test+ void putDkimSigningAttributes_awsSes_regeneratesTokensOnKeyLengthChange() {+ String domain = "dkim-signing.floci.test";+ List<String> before = given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200)+ .extract().path("DkimAttributes.Tokens");++ // Change the key length (default is RSA_2048_BIT) -> tokens regenerate.+ Response resp = given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningAttributesOrigin\":\"AWS_SES\","+ + "\"SigningAttributes\":{\"NextSigningKeyLength\":\"RSA_1024_BIT\"}}")+ .when().put("/v2/email/identities/" + domain + "/dkim/signing").then().statusCode(200)+ .body("DkimTokens", hasSize(3))+ // Regenerated tokens reset the status: the new CNAMEs are not yet detected in DNS.+ .body("DkimStatus", equalTo("PENDING")).extract().response();+ List<String> after = resp.path("DkimTokens");+ assertNotEquals(before, after, "changing the key length must regenerate the tokens");++ given().header("Authorization", V2_AUTH)+ .when().get("/v2/email/identities/" + domain).then().statusCode(200)+ .body("DkimAttributes.CurrentSigningKeyLength", equalTo("RSA_1024_BIT"))+ .body("DkimAttributes.Tokens", equalTo(after));+ }++ @Test+ void putDkimSigningAttributes_emailIdentity_returns400() {+ // DKIM signing attributes are domain-level; an email-shaped identity is rejected.+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningAttributesOrigin\":\"AWS_SES\"}")+ .when().put("/v2/email/identities/[email protected]/dkim/signing")+ .then().statusCode(400).body("__type", equalTo("BadRequestException"))+ .body("message", equalTo("The EmailIdentity value must be a valid domain."));+ }++ @Test+ void putDkimSigningAttributes_blankIdentity_returns400() {+ // A blank/whitespace identity is rejected with the same 400 "must be a valid domain" as an+ // email-shaped one (verified against AWS), rather than falling through to a 404.+ given().urlEncodingEnabled(false).contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningAttributesOrigin\":\"AWS_SES\"}")+ .when().put("/v2/email/identities/%20/dkim/signing")+ .then().statusCode(400).body("__type", equalTo("BadRequestException"))+ .body("message", equalTo("The EmailIdentity value must be a valid domain."));+ }++ @Test+ void putDkimSigningAttributes_unknownIdentity_returns404() {+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningAttributesOrigin\":\"AWS_SES\"}")+ .when().put("/v2/email/identities/ghost-signing.floci.test/dkim/signing")+ .then().statusCode(404).body("__type", equalTo("NotFoundException"));+ }++ @Test+ void putDkimSigningAttributes_externalWithBlankPrivateKey_returns400() {+ String domain = "dkim-external.floci.test";+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);++ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningAttributesOrigin\":\"EXTERNAL\",\"SigningAttributes\":"+ + "{\"DomainSigningSelector\":\"sel\",\"DomainSigningPrivateKey\":\"\"}}")+ .when().put("/v2/email/identities/" + domain + "/dkim/signing")+ .then().statusCode(400).body("__type", equalTo("BadRequestException"));+ }++ @Test+ void setIdentityDkimEnabled_missingIdentity_returns400() {+ v1("SetIdentityDkimEnabled").formParam("DkimEnabled", "true")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"))+ .body(containsString("Identity is required."));+ }++ @Test+ void verifyDomainDkim_whitespaceDomain_returns400() {+ v1("VerifyDomainDkim").formParam("Domain", " dkim-ws.floci.test")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"))+ .body(containsString("whitespace"));+ }++ @Test+ void verifyDomainDkim_emailShapedInput_returns400() {+ v1("VerifyDomainDkim").formParam("Domain", "[email protected]")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ }++ @Test+ void putDkimSigningAttributes_invalidKeyLength_returns400() {+ String domain = "dkim-badkeylen.floci.test";+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);++ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningAttributesOrigin\":\"AWS_SES\","+ + "\"SigningAttributes\":{\"NextSigningKeyLength\":\"RSA_4096_BIT\"}}")+ .when().put("/v2/email/identities/" + domain + "/dkim/signing")+ .then().statusCode(400).body("__type", equalTo("BadRequestException"));+ }++ @Test+ void putDkimSigningAttributes_external_clearsTokensAndResetsStatusToPending() {+ String domain = "dkim-byodkim.floci.test";+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);++ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningAttributesOrigin\":\"EXTERNAL\",\"SigningAttributes\":"+ + "{\"DomainSigningSelector\":\"sel\",\"DomainSigningPrivateKey\":\"key\"}}")+ .when().put("/v2/email/identities/" + domain + "/dkim/signing").then().statusCode(200)+ .body("DkimStatus", equalTo("PENDING"))+ .body("DkimTokens", hasSize(0));++ given().header("Authorization", V2_AUTH)+ .when().get("/v2/email/identities/" + domain).then().statusCode(200)+ .body("DkimAttributes.Status", equalTo("PENDING"))+ .body("DkimAttributes.SigningAttributesOrigin", equalTo("EXTERNAL"))+ .body("DkimAttributes.Tokens", hasSize(0));+ }++ @Test+ void putDkimSigningAttributes_nonObjectBody_returns400() {+ given().contentType("application/json").header("Authorization", V2_AUTH).body("[]")+ .when().put("/v2/email/identities/dkim-nonobj.floci.test/dkim/signing")+ .then().statusCode(400).body("__type", equalTo("BadRequestException"));+ }++ @Test+ void putEmailIdentityDkimAttributes_existingEmailWithRegisteredDomain_isNoOp() {+ String domain = "dkim-emailtoggle.floci.test";+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"bob@" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);++ // Toggling DKIM on the email is a no-op (DKIM is domain-controlled) — 200, nothing changes.+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"SigningEnabled\": false}")+ .when().put("/v2/email/identities/bob@" + domain + "/dkim").then().statusCode(200);++ // The email still reports the domain's DKIM (enabled), and the domain is untouched.+ given().header("Authorization", V2_AUTH)+ .when().get("/v2/email/identities/bob@" + domain).then().statusCode(200)+ .body("DkimAttributes.SigningEnabled", equalTo(true));+ given().header("Authorization", V2_AUTH)+ .when().get("/v2/email/identities/" + domain).then().statusCode(200)+ .body("DkimAttributes.SigningEnabled", equalTo(true));+ }++ @Test+ void emailIdentity_inheritsParentDomainDkim() {+ String domain = "dkim-inherit.floci.test";+ List<String> domainTokens = given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200)+ .extract().path("DkimAttributes.Tokens");++ // An email under that domain inherits the domain's DKIM (tokens, enabled, pending status).+ given().contentType("application/json").header("Authorization", V2_AUTH)+ .body("{\"EmailIdentity\":\"bob@" + domain + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);++ given().header("Authorization", V2_AUTH)+ .when().get("/v2/email/identities/bob@" + domain).then().statusCode(200)+ .body("DkimAttributes.SigningEnabled", equalTo(true))+ .body("DkimAttributes.Status", equalTo("PENDING"))+ .body("DkimAttributes.Tokens", equalTo(domainTokens))+ .body("DkimAttributes.Tokens", not(hasSize(0)));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.javaindex bc8ff05c0b..a79707eb53 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.java@@ -78,7 +78,9 @@ class SesServiceLegacyDkimTokensTest {assertTrue(refreshed.getDkimTokens().stream().allMatch(token -> token != null && !token.isBlank()));assertEquals("Pending", refreshed.getVerificationStatus());assertFalse(refreshed.isDkimEnabled());- assertEquals("NotStarted", refreshed.getDkimVerificationStatus());+ // Once tokens are backfilled the domain is pending DNS detection (status tracks detection, not+ // the signing flag), rather than staying NotStarted.+ assertEquals("Pending", refreshed.getDkimVerificationStatus());List<String> persistedTokens = identityStore.get(key).orElseThrow().getDkimTokens();assertNotNull(persistedTokens);diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.javaindex ffcca1bb04..56bc8f0ff5 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.java@@ -54,8 +54,19 @@ class SesV2IntegrationTest {.body("IdentityType", equalTo("DOMAIN")).body("VerifiedForSendingStatus", equalTo(false)).body("DkimAttributes.SigningEnabled", equalTo(true))- .body("DkimAttributes.Status", equalTo("PENDING"))+ // CreateEmailIdentity reports NOT_STARTED (SES hasn't begun tracking the CNAMEs yet).+ .body("DkimAttributes.Status", equalTo("NOT_STARTED")).body("DkimAttributes.Tokens", not(empty()));++ // A subsequent GetEmailIdentity transitions the DKIM status to PENDING, matching AWS.+ given()+ .contentType("application/json")+ .header("Authorization", AUTH_HEADER)+ .when()+ .get("/v2/email/identities/v2example.com")+ .then()+ .statusCode(200)+ .body("DkimAttributes.Status", equalTo("PENDING"));}@Test@@ -199,6 +210,64 @@ class SesV2IntegrationTest {.body("DkimAttributes.SigningEnabled", equalTo(true)).body("DkimAttributes.Status", equalTo("SUCCESS")).body("DkimAttributes.Tokens", not(empty()));++ // DKIM verification status tracks DNS detection independently of the signing flag: disabling+ // DKIM keeps Status=SUCCESS while the CNAMEs remain published.+ given()+ .contentType("application/json")+ .header("Authorization", AUTH_HEADER)+ .body("""+ {"SigningEnabled": false}+ """)+ .when()+ .put("/v2/email/identities/v2dkim-success.floci.test/dkim")+ .then()+ .statusCode(200);++ given()+ .contentType("application/json")+ .header("Authorization", AUTH_HEADER)+ .when()+ .get("/v2/email/identities/v2dkim-success.floci.test")+ .then()+ .statusCode(200)+ .body("DkimAttributes.SigningEnabled", equalTo(false))+ .body("DkimAttributes.Status", equalTo("SUCCESS"));++ // Re-enable so the key-rotation assertion below starts from the signing-enabled state.+ given()+ .contentType("application/json")+ .header("Authorization", AUTH_HEADER)+ .body("""+ {"SigningEnabled": true}+ """)+ .when()+ .put("/v2/email/identities/v2dkim-success.floci.test/dkim")+ .then()+ .statusCode(200);++ // Rotating the DKIM key must not revoke the identity's sending verification (matching AWS):+ // VerificationStatus stays SUCCESS, but DKIM re-pends until the new tokens' records are detected.+ given()+ .contentType("application/json")+ .header("Authorization", AUTH_HEADER)+ .body("""+ {"SigningAttributesOrigin":"AWS_SES","SigningAttributes":{"NextSigningKeyLength":"RSA_1024_BIT"}}+ """)+ .when()+ .put("/v2/email/identities/v2dkim-success.floci.test/dkim/signing")+ .then()+ .statusCode(200);++ given()+ .contentType("application/json")+ .header("Authorization", AUTH_HEADER)+ .when()+ .get("/v2/email/identities/v2dkim-success.floci.test")+ .then()+ .statusCode(200)+ .body("VerificationStatus", equalTo("SUCCESS"))+ .body("DkimAttributes.Status", equalTo("PENDING"));}@Test@@ -519,7 +588,9 @@ class SesV2IntegrationTest {.then().statusCode(200).body("DkimAttributes.SigningEnabled", equalTo(true))- .body("DkimAttributes.Status", equalTo("SUCCESS"));+ // example.com is not a DKIM-verified domain identity, so the enabled flag is set but the+ // DKIM verification status stays NOT_STARTED (status tracks DNS detection, not the flag).+ .body("DkimAttributes.Status", equalTo("NOT_STARTED"));}@Test