Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(acm): enhance email validation to report approval mailboxes and omit DNS records (#3290)

Matheus André8180d4b3b839
diff --git a/docs/services/acm.md b/docs/services/acm.md
index 091447ce5b..0d92f7ca89 100644
--- a/docs/services/acm.md
+++ b/docs/services/acm.md
@@ -28,7 +28,8 @@
## Emulation Behavior
-- **Auto-Issuance:** All requested certificates are immediately issued with status `ISSUED`, and every entry in `DomainValidationOptions` reports `ValidationStatus: SUCCESS` (no DNS/email validation required). With a validation wait configured, both stay pending until the wait has passed.
+- **Auto-Issuance:** All requested certificates are immediately issued with status `ISSUED`, and every entry in `DomainValidationOptions` reports `ValidationStatus: SUCCESS` (no DNS/email validation required). With a validation wait configured, both stay pending until the wait has passed, for `DNS` and `EMAIL` validation alike: there is no approval mail to confirm, so the wait stands in for the approval, and a certificate never times out.
+- **Validation Artefacts:** `DomainValidationOptions` follows the validation method as on AWS. `DNS` validation carries the `ResourceRecord` CNAME to publish; `EMAIL` validation carries no record but `ValidationEmails`, the five conventional mailboxes (`admin@`, `administrator@`, `hostmaster@`, `postmaster@`, `webmaster@`) of the `ValidationDomain`, which is the domain itself (wildcard stripped) or the one given in the request's `DomainValidationOptions`. An option naming a domain that is not on the certificate, or a `ValidationDomain` that is not the domain or one of its parents, is rejected with `InvalidDomainValidationOptionsException`. Real ACM also mails the WHOIS contacts, which Floci cannot know.
- **Real Cryptography:** Certificates are generated with real RSA/EC keys and valid X.509 structure
- **One Local CA:** Every issued certificate (`AMAZON_ISSUED` and `PRIVATE`) is signed by Floci's local root CA, and `GetCertificate` returns that CA as `CertificateChain`. Trust it once (`GET /_floci/ca.pem`, see [TLS](../configuration/tls.md)) and both Floci's HTTPS endpoint and every ACM certificate validate. `DescribeCertificate` reports `Issuer` as the CA's name, `CN=Floci Local CA`, where AWS reports `Amazon`. `ImportCertificate` keeps the chain you upload.
- **CA on First Use:** The CA is created under `{persistent-path}/tls/` the first time a certificate is issued, also with TLS off and in `memory` storage mode, so that directory must be writable. A certificate keeps the chain it was issued with; after a CA regeneration, delete and re-request it.
diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/AcmJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/acm/AcmJsonHandler.java
index ea158b99d5..d46986bc4a 100644
--- a/src/main/java/io/github/hectorvent/floci/services/acm/AcmJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/acm/AcmJsonHandler.java
@@ -399,6 +399,11 @@ public class AcmJsonHandler {
rrNode.put("Value", dv.resourceRecord().value());
dvNode.set("ResourceRecord", rrNode);
}
+ if (dv.validationEmails() != null && !dv.validationEmails().isEmpty()) {
+ ArrayNode emails = objectMapper.createArrayNode();
+ dv.validationEmails().forEach(emails::add);
+ dvNode.set("ValidationEmails", emails);
+ }
validations.add(dvNode);
}
node.set("DomainValidationOptions", validations);
diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java b/src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java
index cde7cbb587..f157d26211 100644
--- a/src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java
@@ -156,6 +156,8 @@ public class AcmService implements ResourceProvider {
status = validationWaitSeconds > 0 ? CertificateStatus.PENDING_VALIDATION : CertificateStatus.ISSUED;
}
+ ValidationMethod method = validationMethod != null ? validationMethod : ValidationMethod.DNS;
+
// A server leaf signed by the local CA, so Certificate plus CertificateChain from
// GetCertificate validate the way an ACM certificate and its chain do on AWS.
CertificateGenerator.GeneratedCertificate generated = certificateAuthority.issueServerCertificate(
@@ -177,7 +179,7 @@ public class AcmService implements ResourceProvider {
cert.setStatus(status);
cert.setType(type);
- cert.setValidationMethod(validationMethod != null ? validationMethod : ValidationMethod.DNS);
+ cert.setValidationMethod(method);
cert.setCreatedAt(now);
cert.setIssuedAt(status == CertificateStatus.ISSUED ? now : null);
cert.setNotBefore(generated.notBefore());
@@ -198,7 +200,7 @@ public class AcmService implements ResourceProvider {
List<DomainValidation> validations = new ArrayList<>();
for (String san : allSans) {
validations.add(generateDomainValidation(san, requestedValidationDomains.get(san.toLowerCase(Locale.ROOT)),
- validationMethod, status));
+ method, status));
}
cert.setDomainValidationOptions(validations);
@@ -777,11 +779,25 @@ public class AcmService implements ResourceProvider {
* Generates a domain validation entry whose status follows the certificate: an ISSUED
* certificate has validated every domain, a PENDING_VALIDATION one has not yet.
*
+ * <p>The artefacts follow the validation method, as on AWS: DNS validation carries the CNAME
+ * record to publish under {@code _<token>.<domain>}, EMAIL validation carries instead the
+ * addresses the approval mail went to, the five conventional mailboxes of the validation
+ * domain. Real ACM also mails the WHOIS contacts, which the emulator cannot know.</p>
+ *
* @param requestedValidationDomain the {@code ValidationDomain} the caller asked for, or {@code null}
- * to validate the domain against itself
+ * to validate the domain against itself (a wildcard against its base
+ * domain for EMAIL, since there is no mailbox at {@code *.})
*/
private DomainValidation generateDomainValidation(String domain, String requestedValidationDomain,
ValidationMethod method, CertificateStatus status) {
+ String validationStatus = status == CertificateStatus.ISSUED ? "SUCCESS" : "PENDING_VALIDATION";
+
+ if (method == ValidationMethod.EMAIL) {
+ String validationDomain = requestedValidationDomain != null ? requestedValidationDomain : baseDomain(domain);
+ return new DomainValidation(domain, validationDomain, validationStatus, method.name(), null,
+ validationEmails(validationDomain));
+ }
+
String validationToken = generateValidationToken(domain);
String recordBase = baseDomain(domain);
ResourceRecord resourceRecord = new ResourceRecord(
@@ -789,19 +805,23 @@ public class AcmService implements ResourceProvider {
"CNAME",
"_" + validationToken.substring(32) + ".acm-validations.aws."
);
-
- String validationStatus = status == CertificateStatus.ISSUED ? "SUCCESS" : "PENDING_VALIDATION";
-
return new DomainValidation(
domain,
requestedValidationDomain != null ? requestedValidationDomain : domain,
validationStatus,
- method != null ? method.name() : "DNS",
+ method.name(),
resourceRecord,
null
);
}
+ /** The mailboxes ACM always sends the approval mail to, in the order the console lists them. */
+ static List<String> validationEmails(String validationDomain) {
+ String domain = validationDomain.toLowerCase(Locale.ROOT);
+ return List.of("admin@" + domain, "administrator@" + domain, "hostmaster@" + domain,
+ "postmaster@" + domain, "webmaster@" + domain);
+ }
+
private String generateValidationToken(String domain) {
String tokenInput = regionResolver.getAccountId() + ":" + baseDomain(domain);
try {
diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmEdgeCaseTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmEdgeCaseTest.java
index 07fe8cdb82..a763690301 100644
--- a/src/test/java/io/github/hectorvent/floci/services/acm/AcmEdgeCaseTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmEdgeCaseTest.java
@@ -320,6 +320,49 @@ class AcmEdgeCaseTest {
.body("__type", equalTo("ValidationException"));
}
+ @Test
+ void emailValidationReportsValidationEmailsInsteadOfAResourceRecord() {
+ // Issue #3252
+ String certificateArn = given()
+ .header("X-Amz-Target", "CertificateManager.RequestCertificate")
+ .contentType(ACM_CONTENT_TYPE)
+ .body("""
+ {
+ "DomainName": "probe.email.example.com",
+ "ValidationMethod": "EMAIL",
+ "DomainValidationOptions": [
+ {"DomainName": "probe.email.example.com", "ValidationDomain": "email.example.com"}
+ ]
+ }
+ """)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().jsonPath().getString("CertificateArn");
+
+ given()
+ .header("X-Amz-Target", "CertificateManager.DescribeCertificate")
+ .contentType(ACM_CONTENT_TYPE)
+ .body("""
+ {
+ "CertificateArn": "%s"
+ }
+ """.formatted(certificateArn))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("Certificate.DomainValidationOptions", hasSize(1))
+ .body("Certificate.DomainValidationOptions[0].DomainName", equalTo("probe.email.example.com"))
+ .body("Certificate.DomainValidationOptions[0].ValidationDomain", equalTo("email.example.com"))
+ .body("Certificate.DomainValidationOptions[0].ValidationMethod", equalTo("EMAIL"))
+ .body("Certificate.DomainValidationOptions[0].ValidationEmails", contains(
+ .body("Certificate.DomainValidationOptions[0]", not(hasKey("ResourceRecord")));
+ }
+
// ==================== Domain Name Validation Tests ====================
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmServiceTest.java
index c7f2f74fff..640e876bfb 100644
--- a/src/test/java/io/github/hectorvent/floci/services/acm/AcmServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmServiceTest.java
@@ -123,6 +123,77 @@ class AcmServiceTest {
assertChainsToTheCa(cert);
}
+ @Test
+ void emailValidationReportsTheApprovalMailboxesAndNoDnsRecord() {
+ // Issue #3252: the CNAME under _<token>.<domain> belongs to DNS validation only; an EMAIL
+ // certificate reports instead where the approval mail went.
+ Certificate cert = newService(30).requestCertificate("probe.example.test", List.of("*.probe.example.test"),
+ ValidationMethod.EMAIL, null, KeyAlgorithm.RSA_2048, null, null, null, REGION);
+
+ assertEquals(CertificateStatus.PENDING_VALIDATION, cert.getStatus());
+ assertNull(cert.getIssuedAt());
+ assertEquals(2, cert.getDomainValidationOptions().size());
+ for (DomainValidation validation : cert.getDomainValidationOptions()) {
+ assertEquals("EMAIL", validation.validationMethod());
+ assertEquals("PENDING_VALIDATION", validation.validationStatus());
+ assertNull(validation.resourceRecord(), "no DNS record for " + validation.domainName());
+ assertEquals("probe.example.test", validation.validationDomain(),
+ "the wildcard is validated through its base domain");
+ assertEquals(List.of("[email protected]", "[email protected]",
+ validation.validationEmails());
+ }
+ }
+
+ @Test
+ void emailValidationFollowsTheConfiguredWaitLikeDnsValidation() {
+ Certificate cert = service.requestCertificate("issued.example.test", List.of(),
+ ValidationMethod.EMAIL, null, KeyAlgorithm.RSA_2048, null, null, null, REGION);
+
+ assertEquals(CertificateStatus.ISSUED, cert.getStatus());
+ DomainValidation validation = cert.getDomainValidationOptions().get(0);
+ assertEquals("SUCCESS", validation.validationStatus());
+ assertNull(validation.resourceRecord());
+ assertEquals(5, validation.validationEmails().size());
+ }
+
+ @Test
+ void dnsValidationCarriesNoValidationEmails() {
+ Certificate cert = service.requestCertificate("dns.example.test", List.of(), ValidationMethod.DNS,
+ null, KeyAlgorithm.RSA_2048, null, null, null, REGION);
+
+ DomainValidation validation = cert.getDomainValidationOptions().get(0);
+ assertEquals("CNAME", validation.resourceRecord().type());
+ assertNull(validation.validationEmails());
+ }
+
+ @Test
+ void domainValidationOptionsChooseTheValidationDomain() {
+ Certificate cert = service.requestCertificate("site.sub.example.test", List.of("api.sub.example.test"),
+ ValidationMethod.EMAIL, null, KeyAlgorithm.RSA_2048, null, null, null,
+ Map.of("site.sub.example.test", "example.test"), REGION);
+
+ DomainValidation site = cert.getDomainValidationOptions().get(0);
+ assertEquals("site.sub.example.test", site.domainName());
+ assertEquals("example.test", site.validationDomain());
+ assertTrue(site.validationEmails().contains("[email protected]"));
+ DomainValidation api = cert.getDomainValidationOptions().get(1);
+ assertEquals("api.sub.example.test", api.validationDomain(), "no option given: the domain itself");
+ }
+
+ @Test
+ void domainValidationOptionsMustNameACertificateDomainAndASuperdomain() {
+ AwsException unrelated = assertThrows(AwsException.class, () -> service.requestCertificate(
+ "site.example.test", List.of(), ValidationMethod.EMAIL, null, KeyAlgorithm.RSA_2048, null, null, null,
+ Map.of("other.example.test", "example.test"), REGION));
+ assertEquals("InvalidDomainValidationOptionsException", unrelated.getErrorCode());
+
+ AwsException notASuperdomain = assertThrows(AwsException.class, () -> service.requestCertificate(
+ "site.example.test", List.of(), ValidationMethod.EMAIL, null, KeyAlgorithm.RSA_2048, null, null, null,
+ Map.of("site.example.test", "example.net"), REGION));
+ assertEquals("InvalidDomainValidationOptionsException", notASuperdomain.getErrorCode());
+ }
+
@Test
void anIdempotentReplayReturnsTheSameCertificateInsteadOfIssuingAnother() {
Certificate first = service.requestCertificate("same.example.test", List.of(), ValidationMethod.DNS,