Light, fluffy, and always free - The AWS Local Emulator alternative
refactor(acm): one issuer-signing primitive in CertificateGenerator (#3077)
Mario Toffia4e05fdf58208
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.javaindex 16eacb1952..cbd055b5fb 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@@ -404,11 +404,11 @@ public class AcmService implements ResourceProvider {cert.setIssuedAt(now);cert.setNotBefore(x509Cert.getNotBefore().toInstant());cert.setNotAfter(x509Cert.getNotAfter().toInstant());- cert.setSerial(x509Cert.getSerialNumber().toString());+ cert.setSerial(CertificateGenerator.colonHex(x509Cert.getSerialNumber()));cert.setSubject(x509Cert.getSubjectX500Principal().getName());cert.setIssuer(x509Cert.getIssuerX500Principal().getName());cert.setKeyAlgorithm(keyAlg);- cert.setSignatureAlgorithm(x509Cert.getSigAlgName());+ cert.setSignatureAlgorithm(x509Cert.getSigAlgName().toUpperCase(Locale.ROOT));cert.setCertificateBody(certificatePem);cert.setPrivateKey(privateKeyPem);cert.setCertificateChain(chainPem);diff --git a/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerator.java b/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerator.javaindex f75351a049..f43f1fbc38 100644--- a/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerator.java+++ b/src/main/java/io/github/hectorvent/floci/services/acm/CertificateGenerator.java@@ -7,10 +7,15 @@ import org.bouncycastle.asn1.pkcs.EncryptedPrivateKeyInfo;import org.bouncycastle.asn1.x500.X500Name;import org.bouncycastle.asn1.x509.AlgorithmIdentifier;import org.bouncycastle.asn1.x509.BasicConstraints;+import org.bouncycastle.asn1.x509.ExtendedKeyUsage;import org.bouncycastle.asn1.x509.Extension;import org.bouncycastle.asn1.x509.GeneralName;import org.bouncycastle.asn1.x509.GeneralNames;+import org.bouncycastle.asn1.x509.KeyPurposeId;import org.bouncycastle.asn1.x509.KeyUsage;+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;+import org.bouncycastle.asn1.x9.ECNamedCurveTable;+import org.bouncycastle.asn1.x9.X962Parameters;import org.bouncycastle.cert.X509CertificateHolder;import org.bouncycastle.cert.X509v3CertificateBuilder;import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;@@ -33,19 +38,23 @@ import java.io.StringReader;import java.io.StringWriter;import java.math.BigInteger;import java.net.InetAddress;+import java.nio.charset.StandardCharsets;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.PrivateKey;import java.security.PublicKey;import java.security.SecureRandom;import java.security.Security;+import java.security.Signature;import java.security.cert.X509Certificate;import java.security.spec.ECGenParameterSpec;import java.time.Instant;import java.time.temporal.ChronoUnit;import java.util.ArrayList;import java.util.Date;+import java.util.LinkedHashSet;import java.util.List;+import java.util.Locale;import java.util.regex.Pattern;@ApplicationScoped@@ -77,6 +86,16 @@ public class CertificateGenerator {String signatureAlgorithm) {}+ /**+ * What an issued leaf is for. Decides the Extended Key Usage. A CA passes {@code null}.+ * {@code SERVER} carries both serverAuth and clientAuth, as ACM-issued certificates do (and as+ * {@code DescribeCertificate} already advertises); {@code CLIENT} is clientAuth only.+ */+ public enum LeafUsage { SERVER, CLIENT }++ /** A signer: the issuer's certificate (for its DN) and its private key. */+ public record Issuer(X509Certificate certificate, PrivateKey key) {}+/*** Generates a certificate for local emulation that mimics an ACM-issued certificate:* the subject is {@code CN=<domainName>} but the issuer is a cosmetic Amazon CA DN, matching@@ -115,86 +134,187 @@ public class CertificateGenerator {return buildCertificate(domainName, sans, keyAlgorithm, "CN=" + domainName, true, keyPair);}+ /**+ * A root CA: self-signed, {@code cA=true}, {@code keyCertSign}, ten years. RSA 2048 because+ * every client in the emulator's reach accepts it and it keeps key generation under a second.+ */+ public GeneratedCertificate generateCaCertificate(String commonName) {+ try {+ KeyPair keyPair = generateKeyPair(KeyAlgorithm.RSA_2048);+ X500Name dn = new X500Name("CN=" + commonName);+ X509Certificate cert = signCertificate(dn, keyPair.getPublic(), dn, keyPair.getPrivate(),+ List.of(), true, null, 3650);+ return toGenerated(cert, keyPair.getPrivate(), dn.toString(), dn.toString());+ } catch (Exception e) {+ LOG.error("Failed to generate CA certificate", e);+ throw new CertificateGenerationException("CA generation failed: " + e.getMessage(), e);+ }+ }++ /**+ * A leaf signed by {@code issuer}. {@code subjectKeyPair} may be {@code null} to mint a new+ * one of {@code keyAlgorithm}; pass the previous pair to reissue with an updated SAN list and+ * an unchanged public key, in which case it must be of {@code keyAlgorithm}. The result is+ * checked before it is returned: the leaf must verify against the issuer's certificate, and a+ * supplied key pair must be a pair of the requested algorithm, so a caller can never get back+ * a certificate its own issuer rejects, a private key that does not fit it, or a key type it+ * did not ask for.+ */+ public GeneratedCertificate generateIssuedCertificate(String domainName, List<String> sans,+ KeyAlgorithm keyAlgorithm, KeyPair subjectKeyPair,+ Issuer issuer, LeafUsage usage) {+ try {+ if (subjectKeyPair != null && !isOfAlgorithm(subjectKeyPair.getPublic(), keyAlgorithm)) {+ throw new IllegalArgumentException("supplied key pair is not the requested " + keyAlgorithm);+ }+ if (subjectKeyPair != null && !isPair(subjectKeyPair.getPrivate(), subjectKeyPair.getPublic())) {+ throw new IllegalArgumentException("supplied private key does not match its public key");+ }+ KeyPair keyPair = subjectKeyPair != null ? subjectKeyPair : generateKeyPair(keyAlgorithm);+ X500Name subject = new X500Name("CN=" + domainName);+ X500Name issuerDn = X500Name.getInstance(issuer.certificate().getSubjectX500Principal().getEncoded());+ X509Certificate cert = signCertificate(subject, keyPair.getPublic(), issuerDn, issuer.key(),+ withDomainFirst(domainName, sans), false, usage, 365);+ cert.verify(issuer.certificate().getPublicKey());+ return toGenerated(cert, keyPair.getPrivate(), subject.toString(),+ issuer.certificate().getSubjectX500Principal().getName());+ } catch (Exception e) {+ LOG.error("Failed to generate issued certificate", e);+ throw new CertificateGenerationException("Certificate generation failed: " + e.getMessage(), e);+ }+ }++ /**+ * True when {@code key} is exactly what {@code keyAlgorithm} names: the RSA size, or for EC the+ * named curve read from the key's encoding, so a curve that only shares a field size+ * (secp256k1 for {@code EC_prime256v1}) does not pass.+ */+ boolean isOfAlgorithm(PublicKey key, KeyAlgorithm keyAlgorithm) {+ if ("EC".equals(keyAlgorithm.getAlgorithm())) {+ if (!"EC".equals(key.getAlgorithm())) {+ return false;+ }+ X962Parameters parameters = X962Parameters.getInstance(+ SubjectPublicKeyInfo.getInstance(key.getEncoded()).getAlgorithm().getParameters());+ return parameters.isNamedCurve()+ && ECNamedCurveTable.getOID(keyAlgorithm.getCurveName()).equals(parameters.getParameters());+ }+ return "RSA".equals(key.getAlgorithm()) && detectKeyAlgorithm(key) == keyAlgorithm;+ }++ /** True when {@code privateKey} signs what {@code publicKey} verifies. */+ public static boolean isPair(PrivateKey privateKey, PublicKey publicKey) throws Exception {+ String algorithm = "EC".equals(privateKey.getAlgorithm()) ? "SHA256withECDSA" : "SHA256withRSA";+ byte[] probe = "floci".getBytes(StandardCharsets.US_ASCII);+ Signature signer = Signature.getInstance(algorithm);+ signer.initSign(privateKey);+ signer.update(probe);+ byte[] signature = signer.sign();+ Signature verifier = Signature.getInstance(algorithm);+ verifier.initVerify(publicKey);+ verifier.update(probe);+ return verifier.verify(signature);+ }+private GeneratedCertificate buildCertificate(String domainName, List<String> sans, KeyAlgorithm keyAlgorithm,String issuerDn, boolean asCa, KeyPair suppliedKeyPair) {try {KeyPair keyPair = suppliedKeyPair != null ? suppliedKeyPair : generateKeyPair(keyAlgorithm);-- Instant now = Instant.now();- Instant notBefore = now;- Instant notAfter = now.plus(365, ChronoUnit.DAYS);-- BigInteger serial = new BigInteger(128, SECURE_RANDOM);String subjectDn = "CN=" + domainName;+ // Signed with the subject's own key, as before: generateCertificate keeps its cosmetic+ // Amazon issuer DN, generateSelfSignedCertificate keeps issuer == subject.+ X509Certificate cert = signCertificate(new X500Name(subjectDn), keyPair.getPublic(),+ new X500Name(issuerDn), keyPair.getPrivate(), withDomainFirst(domainName, sans), asCa, null, 365);+ return toGenerated(cert, keyPair.getPrivate(), subjectDn, issuerDn);+ } catch (Exception e) {+ LOG.error("Failed to generate certificate", e);+ throw new CertificateGenerationException("Certificate generation failed: " + e.getMessage(), e);+ }+ }- X500Name issuer = new X500Name(issuerDn);- X500Name subject = new X500Name(subjectDn);+ /**+ * The one place a certificate is signed. Everything else in this class, and+ * {@code CloudHsmV2Service}, goes through here.+ *+ * @param sans DNS names or IP addresses, written once each in order; empty for a CA+ * @param asCa sets {@code BasicConstraints(cA)}, {@code keyCertSign} and {@code cRLSign}+ * @param usage EKU for a leaf, {@code null} for a CA or a leaf without one+ */+ public X509Certificate signCertificate(X500Name subject, PublicKey subjectKey, X500Name issuerDn,+ PrivateKey issuerKey, List<String> sans, boolean asCa,+ LeafUsage usage, int validityDays) throws Exception {+ Instant now = Instant.now();+ BigInteger serial = new BigInteger(128, SECURE_RANDOM);+ X509v3CertificateBuilder certBuilder = new JcaX509v3CertificateBuilder(+ issuerDn, serial, Date.from(now), Date.from(now.plus(validityDays, ChronoUnit.DAYS)),+ subject, subjectKey);++ if (sans != null && !sans.isEmpty()) {+ List<GeneralName> sanList = new ArrayList<>();+ for (String san : new LinkedHashSet<>(sans)) {+ sanList.add(toGeneralName(san));+ }+ certBuilder.addExtension(Extension.subjectAlternativeName, false,+ new GeneralNames(sanList.toArray(new GeneralName[0])));+ }- String signatureAlgorithm = keyAlgorithm.getAlgorithm().equals("EC")- ? "SHA512withECDSA"- : "SHA512WithRSA";+ // keyEncipherment is an RSA key-transport bit; EC keys sign (and agree), they never encipher.+ int keyUsageBits = KeyUsage.digitalSignature;+ if ("RSA".equals(subjectKey.getAlgorithm())) {+ keyUsageBits |= KeyUsage.keyEncipherment;+ }+ if (asCa) {+ keyUsageBits |= KeyUsage.keyCertSign | KeyUsage.cRLSign;+ }+ certBuilder.addExtension(Extension.keyUsage, true, new KeyUsage(keyUsageBits));+ certBuilder.addExtension(Extension.basicConstraints, true, new BasicConstraints(asCa));+ if (usage == LeafUsage.SERVER) {+ certBuilder.addExtension(Extension.extendedKeyUsage, false, new ExtendedKeyUsage(+ new KeyPurposeId[] {KeyPurposeId.id_kp_serverAuth, KeyPurposeId.id_kp_clientAuth}));+ } else if (usage == LeafUsage.CLIENT) {+ certBuilder.addExtension(Extension.extendedKeyUsage, false,+ new ExtendedKeyUsage(KeyPurposeId.id_kp_clientAuth));+ }- X509v3CertificateBuilder certBuilder = new JcaX509v3CertificateBuilder(- issuer,- serial,- Date.from(notBefore),- Date.from(notAfter),- subject,- keyPair.getPublic()- );+ String signatureAlgorithm = "EC".equals(issuerKey.getAlgorithm()) ? "SHA512withECDSA" : "SHA512WithRSA";+ ContentSigner signer = new JcaContentSignerBuilder(signatureAlgorithm).build(issuerKey);+ X509CertificateHolder holder = certBuilder.build(signer);+ return new JcaX509CertificateConverter().getCertificate(holder);+ }- // Add Subject Alternative Names- List<GeneralName> sanList = new ArrayList<>();- sanList.add(toGeneralName(domainName));- if (sans != null) {- for (String san : sans) {- if (!san.equals(domainName)) {- sanList.add(toGeneralName(san));- }- }- }- GeneralNames generalNames = new GeneralNames(sanList.toArray(new GeneralName[0]));- certBuilder.addExtension(Extension.subjectAlternativeName, false, generalNames);-- // Add Key Usage — a trust-anchor self-signed cert also needs keyCertSign so it can- // act as its own issuer; an ACM-style leaf only needs digitalSignature/keyEncipherment.- int keyUsageBits = KeyUsage.digitalSignature | KeyUsage.keyEncipherment;- if (asCa) {- keyUsageBits |= KeyUsage.keyCertSign;- }- certBuilder.addExtension(Extension.keyUsage, true, new KeyUsage(keyUsageBits));-- // Add Basic Constraints — a trust anchor must be a CA so clients accept it as one.- certBuilder.addExtension(Extension.basicConstraints, true, new BasicConstraints(asCa));-- // Signed with the subject's own private key. For generateCertificate() the issuer DN is- // a cosmetic Amazon DN (mimicking ACM); for generateSelfSignedCertificate() issuer ==- // subject, so the cert is a valid self-signed trust anchor.- ContentSigner signer = new JcaContentSignerBuilder(signatureAlgorithm)- .build(keyPair.getPrivate());-- X509CertificateHolder certHolder = certBuilder.build(signer);- X509Certificate cert = new JcaX509CertificateConverter()- .getCertificate(certHolder);-- String certPem = toPem(cert);- String keyPem = toPem(keyPair.getPrivate());-- return new GeneratedCertificate(- certPem,- keyPem,- serial.toString(),- notBefore,- notAfter,+ private static List<String> withDomainFirst(String domainName, List<String> sans) {+ List<String> allSans = new ArrayList<>();+ allSans.add(domainName);+ if (sans != null) {+ allSans.addAll(sans);+ }+ return allSans;+ }++ /**+ * Metadata comes from the certificate, not from the arguments: the signature algorithm is the+ * issuer's (an RSA CA signing an EC leaf yields SHA512WITHRSA, spelled in upper case as ACM+ * does), and ACM shows the serial as colon-separated hex ({@code 07:71:71:f4:...}).+ */+ private GeneratedCertificate toGenerated(X509Certificate cert, PrivateKey key, String subjectDn,+ String issuerDn) throws Exception {+ return new GeneratedCertificate(+ toPem(cert),+ toPem(key),+ colonHex(cert.getSerialNumber()),+ cert.getNotBefore().toInstant(),+ cert.getNotAfter().toInstant(),subjectDn,issuerDn,- signatureAlgorithm- );+ cert.getSigAlgName().toUpperCase(Locale.ROOT));+ }- } catch (Exception e) {- LOG.error("Failed to generate certificate", e);- throw new CertificateGenerationException("Certificate generation failed: " + e.getMessage(), e);+ static String colonHex(BigInteger serial) {+ String hex = serial.toString(16);+ if (hex.length() % 2 == 1) {+ hex = "0" + hex;}+ return String.join(":", hex.split("(?<=\\G..)"));}private KeyPair generateKeyPair(KeyAlgorithm keyAlgorithm) throws Exception {@@ -244,7 +364,7 @@ public class CertificateGenerator {return IP_ADDRESS_PATTERN.matcher(value).matches();}- private String toPem(Object obj) throws Exception {+ public String toPem(Object obj) throws Exception {StringWriter sw = new StringWriter();try (JcaPEMWriter pemWriter = new JcaPEMWriter(sw)) {pemWriter.writeObject(obj);diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudhsmv2/CloudHsmV2Service.java b/src/main/java/io/github/hectorvent/floci/services/cloudhsmv2/CloudHsmV2Service.javaindex ca644c371c..83e6e38f07 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudhsmv2/CloudHsmV2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudhsmv2/CloudHsmV2Service.java@@ -4,6 +4,7 @@ import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.acm.CertificateGenerator;import io.github.hectorvent.floci.services.cloudhsmv2.model.Certificates;import io.github.hectorvent.floci.services.cloudhsmv2.model.Cluster;import io.github.hectorvent.floci.services.cloudhsmv2.model.ClusterState;@@ -11,9 +12,7 @@ import io.github.hectorvent.floci.services.cloudhsmv2.model.Hsm;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.bouncycastle.asn1.x500.X500Name;-import org.bouncycastle.cert.X509v3CertificateBuilder;import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;-import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;import org.bouncycastle.openssl.jcajce.JcaPEMWriter;import org.bouncycastle.operator.ContentSigner;@@ -27,15 +26,11 @@ import org.jboss.logging.Logger;import java.io.StringReader;import java.io.StringWriter;-import java.math.BigInteger;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.SecureRandom;-import java.security.cert.X509Certificate;import io.github.hectorvent.floci.services.cloudhsmv2.model.Backup;import io.github.hectorvent.floci.services.cloudhsmv2.model.BackupRetentionPolicy;-import java.security.PrivateKey;-import java.security.PublicKey;import java.time.temporal.ChronoUnit;import java.util.stream.Collectors;import java.time.Instant;@@ -64,20 +59,24 @@ public class CloudHsmV2Service {private final StorageBackend<String, Cluster> clusters;private final StorageBackend<String, Backup> backups;private final Ec2Service ec2Service;+ private final CertificateGenerator certificateGenerator;@Inject- public CloudHsmV2Service(StorageFactory storageFactory, Ec2Service ec2Service) {- this.clusters = storageFactory.create("cloudhsmv2", "cloudhsmv2-clusters.json",- new TypeReference<Map<String, Cluster>>() {});- this.backups = storageFactory.create("cloudhsmv2", "cloudhsmv2-backups.json",- new TypeReference<Map<String, Backup>>() {});- this.ec2Service = ec2Service;+ public CloudHsmV2Service(StorageFactory storageFactory, Ec2Service ec2Service,+ CertificateGenerator certificateGenerator) {+ this(storageFactory.create("cloudhsmv2", "cloudhsmv2-clusters.json",+ new TypeReference<Map<String, Cluster>>() {}),+ storageFactory.create("cloudhsmv2", "cloudhsmv2-backups.json",+ new TypeReference<Map<String, Backup>>() {}),+ ec2Service, certificateGenerator);}- CloudHsmV2Service(StorageBackend<String, Cluster> clusters, StorageBackend<String, Backup> backups, Ec2Service ec2Service) {+ CloudHsmV2Service(StorageBackend<String, Cluster> clusters, StorageBackend<String, Backup> backups,+ Ec2Service ec2Service, CertificateGenerator certificateGenerator) {this.clusters = clusters;this.backups = backups;this.ec2Service = ec2Service;+ this.certificateGenerator = certificateGenerator;}// ──────────────────────────── CreateCluster ────────────────────────────@@ -173,15 +172,18 @@ public class CloudHsmV2Service {try {KeyPair mfrKeyPair = generateKeyPair();X500Name mfrName = new X500Name("CN=HSM Manufacturer CA,O=AWS,C=US");- certs.setManufacturerHardwareCertificate(generateCert(mfrName, mfrName, mfrKeyPair.getPublic(), mfrKeyPair.getPrivate()));+ certs.setManufacturerHardwareCertificate(certificateGenerator.toPem(certificateGenerator.signCertificate(+ mfrName, mfrKeyPair.getPublic(), mfrName, mfrKeyPair.getPrivate(), List.of(), true, null, 365)));KeyPair awsKeyPair = generateKeyPair();X500Name awsName = new X500Name("CN=AWS CloudHSM Hardware CA,O=AWS,C=US");- certs.setAwsHardwareCertificate(generateCert(awsName, mfrName, awsKeyPair.getPublic(), mfrKeyPair.getPrivate()));+ certs.setAwsHardwareCertificate(certificateGenerator.toPem(certificateGenerator.signCertificate(+ awsName, awsKeyPair.getPublic(), mfrName, mfrKeyPair.getPrivate(), List.of(), true, null, 365)));KeyPair hsmKeyPair = generateKeyPair();X500Name hsmName = new X500Name("CN=HSM Instance " + clusterId + ",O=AWS,C=US");- certs.setHsmCertificate(generateCert(hsmName, awsName, hsmKeyPair.getPublic(), awsKeyPair.getPrivate()));+ certs.setHsmCertificate(certificateGenerator.toPem(certificateGenerator.signCertificate(+ hsmName, hsmKeyPair.getPublic(), awsName, awsKeyPair.getPrivate(), List.of(), false, null, 365)));} catch (Exception e) {LOG.warnv("Failed to generate emulated hardware certs: {0}", e.getMessage());}@@ -534,25 +536,6 @@ public class CloudHsmV2Service {return keyGen.generateKeyPair();}- private String generateCert(X500Name subject, X500Name issuer, PublicKey pubKey, PrivateKey signerKey) throws Exception {- BigInteger serial = new BigInteger(128, SECURE_RANDOM);- Instant now = Instant.now();- X509v3CertificateBuilder certBuilder = new JcaX509v3CertificateBuilder(- issuer, serial, Date.from(now), Date.from(now.plusSeconds(365L * 24 * 3600)), subject, pubKey);-- ContentSigner signer = new JcaContentSignerBuilder("SHA256WithRSA")- .build(signerKey);- X509CertificateHolder holder = certBuilder.build(signer);- X509Certificate cert = new JcaX509CertificateConverter()- .getCertificate(holder);-- StringWriter sw = new StringWriter();- try (JcaPEMWriter pemWriter = new JcaPEMWriter(sw)) {- pemWriter.writeObject(cert);- }- return sw.toString();- }-private void validatePemCertificate(String pem, String fieldName) {if (pem == null || pem.isBlank()) {throw new AwsException("CloudHsmInvalidRequestException",diff --git a/src/test/java/io/github/hectorvent/floci/services/acm/AcmImportExportTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/AcmImportExportTest.javaindex bb23ed1861..3456ad0708 100644--- a/src/test/java/io/github/hectorvent/floci/services/acm/AcmImportExportTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/acm/AcmImportExportTest.java@@ -95,7 +95,9 @@ class AcmImportExportTest {.body("Certificate.DomainName", equalTo("test-import.example.com")).body("Certificate.Status", equalTo("ISSUED")).body("Certificate.Type", equalTo("IMPORTED"))- .body("Certificate.KeyAlgorithm", equalTo("RSA-2048"));+ .body("Certificate.KeyAlgorithm", equalTo("RSA-2048"))+ .body("Certificate.Serial", matchesPattern("([0-9a-f]{2}:)+[0-9a-f]{2}"))+ .body("Certificate.SignatureAlgorithm", matchesPattern("SHA[0-9]+WITH[A-Z]+"));}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/acm/CertificateGeneratorIssuerTest.java b/src/test/java/io/github/hectorvent/floci/services/acm/CertificateGeneratorIssuerTest.javanew file mode 100644index 0000000000..6576fba7d6--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/acm/CertificateGeneratorIssuerTest.java@@ -0,0 +1,218 @@+package io.github.hectorvent.floci.services.acm;++import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import org.bouncycastle.jce.provider.BouncyCastleProvider;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.math.BigInteger;+import java.security.KeyPair;+import java.security.Security;+import java.security.cert.X509Certificate;+import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * The issuer-signing primitive: a CA that can sign, leaves that verify against it, and the+ * Extended Key Usage split between server and client leaves.+ */+class CertificateGeneratorIssuerTest {++ private static CertificateGenerator generator;++ @BeforeAll+ static void setup() {+ if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {+ Security.addProvider(new BouncyCastleProvider());+ }+ generator = new CertificateGenerator();+ }++ private static CertificateGenerator.Issuer newIssuer() {+ var ca = generator.generateCaCertificate("Floci Local CA");+ return new CertificateGenerator.Issuer(+ generator.parseCertificate(ca.certificatePem()), generator.parsePrivateKey(ca.privateKeyPem()));+ }++ @Test+ void caCertificateIsSelfSignedAndCanSign() throws Exception {+ var ca = generator.generateCaCertificate("Floci Local CA");+ X509Certificate cert = generator.parseCertificate(ca.certificatePem());++ assertEquals(cert.getSubjectX500Principal(), cert.getIssuerX500Principal());+ assertEquals("CN=Floci Local CA", cert.getSubjectX500Principal().getName());+ assertTrue(cert.getBasicConstraints() >= 0, "CA must carry cA=true");+ assertTrue(cert.getKeyUsage()[5], "CA must assert keyCertSign");+ assertTrue(cert.getKeyUsage()[6], "CA must assert cRLSign");+ assertNull(cert.getExtendedKeyUsage(), "a CA carries no EKU");+ assertNull(cert.getSubjectAlternativeNames(), "a CA carries no SAN");+ cert.verify(cert.getPublicKey());+ assertEquals(ca.subject(), ca.issuer());+ }++ @Test+ void issuedLeafVerifiesAgainstIssuerAndCarriesServerAuth() throws Exception {+ var issuer = newIssuer();++ var leaf = generator.generateIssuedCertificate("api.example.test", List.of("*.example.test"),+ KeyAlgorithm.RSA_2048, null, issuer, CertificateGenerator.LeafUsage.SERVER);+ X509Certificate cert = generator.parseCertificate(leaf.certificatePem());++ assertEquals(issuer.certificate().getSubjectX500Principal(), cert.getIssuerX500Principal());+ assertNotEquals(cert.getSubjectX500Principal(), cert.getIssuerX500Principal());+ assertEquals(-1, cert.getBasicConstraints(), "leaf must not be a CA");+ assertFalse(cert.getKeyUsage()[5], "leaf must not assert keyCertSign");+ assertTrue(cert.getKeyUsage()[0] && cert.getKeyUsage()[2], "RSA leaf: digitalSignature and keyEncipherment");+ assertEquals(List.of("1.3.6.1.5.5.7.3.1", "1.3.6.1.5.5.7.3.2"), cert.getExtendedKeyUsage(),+ "serverAuth and clientAuth, as ACM issues and DescribeCertificate advertises");+ assertEquals(List.of("api.example.test", "*.example.test"),+ cert.getSubjectAlternativeNames().stream().map(san -> san.get(1)).toList());+ assertEquals("SHA512WITHRSA", leaf.signatureAlgorithm(), "ACM spells the algorithm in upper case");+ assertTrue(cert.getSigAlgName().equalsIgnoreCase(leaf.signatureAlgorithm()),+ "metadata reports the real signature algorithm: " + cert.getSigAlgName());+ assertTrue(leaf.serial().matches("([0-9a-f]{2}:)+[0-9a-f]{2}"),+ "colon-separated hex serial: " + leaf.serial());+ assertEquals(cert.getSerialNumber(), new BigInteger(leaf.serial().replace(":", ""), 16));+ assertEquals(cert.getNotBefore().toInstant(), leaf.notBefore());+ assertEquals(cert.getNotAfter().toInstant(), leaf.notAfter());+ assertEquals("CN=api.example.test", leaf.subject());+ assertEquals(issuer.certificate().getSubjectX500Principal().getName(), leaf.issuer());+ cert.verify(issuer.certificate().getPublicKey());+ }++ @Test+ void issuedLeafReusesSuppliedKeyPairAndClientUsage() throws Exception {+ var issuer = newIssuer();+ var first = generator.generateIssuedCertificate("device-1", List.of(), KeyAlgorithm.RSA_2048, null, issuer,+ CertificateGenerator.LeafUsage.CLIENT);+ var keyPair = new KeyPair(+ generator.parseCertificate(first.certificatePem()).getPublicKey(),+ generator.parsePrivateKey(first.privateKeyPem()));++ var second = generator.generateIssuedCertificate("device-1", List.of(), KeyAlgorithm.RSA_2048, keyPair, issuer,+ CertificateGenerator.LeafUsage.CLIENT);+ X509Certificate cert = generator.parseCertificate(second.certificatePem());++ assertEquals(keyPair.getPublic(), cert.getPublicKey(), "supplied key pair must be reused");+ assertEquals(first.privateKeyPem(), second.privateKeyPem(), "the same private key is returned");+ assertNotEquals(first.serial(), second.serial(), "every issue gets a fresh serial");+ assertEquals(List.of("1.3.6.1.5.5.7.3.2"), cert.getExtendedKeyUsage(), "clientAuth only");+ cert.verify(issuer.certificate().getPublicKey());+ }++ @Test+ void ecLeafSignedByRsaCaReportsTheIssuerAlgorithmAndNoKeyEncipherment() throws Exception {+ var issuer = newIssuer();++ var leaf = generator.generateIssuedCertificate("ec.example.test", null, KeyAlgorithm.EC_prime256v1, null,+ issuer, CertificateGenerator.LeafUsage.SERVER);+ X509Certificate cert = generator.parseCertificate(leaf.certificatePem());++ assertEquals("EC", cert.getPublicKey().getAlgorithm());+ assertEquals("SHA512WITHRSA", leaf.signatureAlgorithm(), "the signature is the RSA issuer's");+ assertTrue(cert.getKeyUsage()[0], "digitalSignature");+ assertFalse(cert.getKeyUsage()[2], "an EC key never enciphers");+ assertEquals(List.of("ec.example.test"), cert.getSubjectAlternativeNames().stream().map(san -> san.get(1)).toList());+ cert.verify(issuer.certificate().getPublicKey());+ }++ @Test+ void anIssuerWhoseKeyDoesNotMatchItsCertificateIsRefused() {+ var one = generator.generateCaCertificate("One");+ var other = generator.generateCaCertificate("Other");+ var mismatched = new CertificateGenerator.Issuer(+ generator.parseCertificate(one.certificatePem()), generator.parsePrivateKey(other.privateKeyPem()));++ var refused = org.junit.jupiter.api.Assertions.assertThrows(CertificateGenerationException.class,+ () -> generator.generateIssuedCertificate("x.example.test", List.of(), KeyAlgorithm.RSA_2048, null,+ mismatched, CertificateGenerator.LeafUsage.SERVER));+ assertTrue(refused.getMessage().contains("Signature"), refused.getMessage());+ }++ @Test+ void aSuppliedKeyPairThatIsNotAPairIsRefused() {+ var issuer = newIssuer();+ var a = generator.generateIssuedCertificate("a", List.of(), KeyAlgorithm.RSA_2048, null, issuer,+ CertificateGenerator.LeafUsage.CLIENT);+ var b = generator.generateIssuedCertificate("b", List.of(), KeyAlgorithm.RSA_2048, null, issuer,+ CertificateGenerator.LeafUsage.CLIENT);+ var notAPair = new KeyPair(generator.parseCertificate(a.certificatePem()).getPublicKey(),+ generator.parsePrivateKey(b.privateKeyPem()));++ var refused = org.junit.jupiter.api.Assertions.assertThrows(CertificateGenerationException.class,+ () -> generator.generateIssuedCertificate("a", List.of(), KeyAlgorithm.RSA_2048, notAPair, issuer,+ CertificateGenerator.LeafUsage.CLIENT));+ assertTrue(refused.getMessage().contains("does not match"), refused.getMessage());+ }++ @Test+ void aSuppliedKeyPairOfAnotherAlgorithmIsRefused() {+ var issuer = newIssuer();+ var rsa = generator.generateIssuedCertificate("a", List.of(), KeyAlgorithm.RSA_2048, null, issuer,+ CertificateGenerator.LeafUsage.CLIENT);+ var rsaPair = new KeyPair(generator.parseCertificate(rsa.certificatePem()).getPublicKey(),+ generator.parsePrivateKey(rsa.privateKeyPem()));++ var refused = org.junit.jupiter.api.Assertions.assertThrows(CertificateGenerationException.class,+ () -> generator.generateIssuedCertificate("a", List.of(), KeyAlgorithm.EC_prime256v1, rsaPair, issuer,+ CertificateGenerator.LeafUsage.CLIENT));+ assertTrue(refused.getMessage().contains("not the requested EC_prime256v1"), refused.getMessage());+ }++ @Test+ void aSuppliedEcKeyPairOnACurveOfTheSameSizeIsRefused() throws Exception {+ var issuer = newIssuer();+ java.security.KeyPairGenerator kpg = java.security.KeyPairGenerator.getInstance("EC", "BC");+ kpg.initialize(new java.security.spec.ECGenParameterSpec("secp256k1"));+ KeyPair k1 = kpg.generateKeyPair();+ kpg.initialize(new java.security.spec.ECGenParameterSpec("secp256r1"));+ KeyPair p256 = kpg.generateKeyPair();++ var refused = org.junit.jupiter.api.Assertions.assertThrows(CertificateGenerationException.class,+ () -> generator.generateIssuedCertificate("a", List.of(), KeyAlgorithm.EC_prime256v1, k1, issuer,+ CertificateGenerator.LeafUsage.CLIENT));+ assertTrue(refused.getMessage().contains("not the requested EC_prime256v1"), refused.getMessage());+ var accepted = generator.generateIssuedCertificate("a", List.of(), KeyAlgorithm.EC_prime256v1, p256, issuer,+ CertificateGenerator.LeafUsage.CLIENT);+ assertEquals(p256.getPublic(), generator.parseCertificate(accepted.certificatePem()).getPublicKey());+ }++ @Test+ void duplicateSansAreWrittenOnce() throws Exception {+ var leaf = generator.generateIssuedCertificate("dup.example.test", List.of("dup.example.test", "other.example.test",+ "other.example.test"), KeyAlgorithm.RSA_2048, null, newIssuer(), CertificateGenerator.LeafUsage.SERVER);+ X509Certificate cert = generator.parseCertificate(leaf.certificatePem());++ assertEquals(List.of("dup.example.test", "other.example.test"),+ cert.getSubjectAlternativeNames().stream().map(san -> san.get(1)).toList());+ }++ @Test+ void existingSelfSignedAndAcmStylePathsAreUnchanged() throws Exception {+ var selfSigned = generator.generateSelfSignedCertificate("localhost", List.of("localhost"), KeyAlgorithm.RSA_2048);+ X509Certificate ss = generator.parseCertificate(selfSigned.certificatePem());+ assertEquals(ss.getSubjectX500Principal(), ss.getIssuerX500Principal());+ assertTrue(ss.getBasicConstraints() >= 0);+ assertNull(ss.getExtendedKeyUsage(), "the self-signed trust anchor carries no EKU, as before");+ ss.verify(ss.getPublicKey());++ var acmStyle = generator.generateCertificate("localhost", List.of("localhost"), KeyAlgorithm.RSA_2048);+ X509Certificate acm = generator.parseCertificate(acmStyle.certificatePem());+ assertTrue(acm.getIssuerX500Principal().getName().contains("Amazon"));+ assertEquals(-1, acm.getBasicConstraints());+ assertEquals("CN=Amazon,OU=Server CA 1B,O=Amazon,C=US", acmStyle.issuer());+ assertTrue(acmStyle.serial().matches("([0-9a-f]{2}:)+[0-9a-f]{2}"));+ }++ @Test+ void colonHexPadsOddLengthAndSplitsBytes() {+ assertEquals("0a", CertificateGenerator.colonHex(BigInteger.TEN));+ assertEquals("01:00", CertificateGenerator.colonHex(BigInteger.valueOf(256)));+ assertEquals("ff:ff:ff", CertificateGenerator.colonHex(new BigInteger("ffffff", 16)));+ }+}