Light, fluffy, and always free - The AWS Local Emulator alternative
perf(build): replace BouncyCastle with JDK crypto API as much as possible (#2988)
TATSUNO “Taz” Yasuhiroffe8a92635ce
diff --git a/compatibility-tests/sdk-test-python/tests/test_acm.py b/compatibility-tests/sdk-test-python/tests/test_acm.pyindex ea16775883..f974b60a4e 100644--- a/compatibility-tests/sdk-test-python/tests/test_acm.py+++ b/compatibility-tests/sdk-test-python/tests/test_acm.py@@ -7,7 +7,7 @@ import pytestfrom botocore.exceptions import ClientErrorfrom cryptography import x509from cryptography.hazmat.primitives import hashes, serialization-from cryptography.hazmat.primitives.asymmetric import rsa+from cryptography.hazmat.primitives.asymmetric import ec, padding, rsafrom cryptography.x509.oid import NameOIDFAKE_ARN = "arn:aws:acm:us-east-1:000000000000:certificate/00000000-0000-0000-0000-000000000000"@@ -27,6 +27,38 @@ class TestACMCertificateLifecycle:finally:acm_client.delete_certificate(CertificateArn=arn)+ @pytest.mark.parametrize(+ "key_algorithm,key_type",+ [("RSA_2048", rsa.RSAPublicKey), ("EC_prime256v1", ec.EllipticCurvePublicKey)],+ )+ def test_request_certificate_key_algorithms(+ self, acm_client, key_algorithm, key_type+ ):+ """Test RequestCertificate issues a parseable certificate for each key algorithm."""+ response = acm_client.request_certificate(+ DomainName=f"{key_algorithm.lower().replace('_', '-')}.example.com",+ KeyAlgorithm=key_algorithm,+ )+ arn = response["CertificateArn"]++ try:+ pem = acm_client.get_certificate(CertificateArn=arn)["Certificate"]+ certificate = x509.load_pem_x509_certificate(pem.encode())+ assert isinstance(certificate.public_key(), key_type)+ # A certificate whose signature does not match its own contents would+ # still parse, so check the self-signature rather than trusting the PEM.+ certificate.public_key().verify(+ certificate.signature,+ certificate.tbs_certificate_bytes,+ *(+ (ec.ECDSA(certificate.signature_hash_algorithm),)+ if isinstance(certificate.public_key(), ec.EllipticCurvePublicKey)+ else (padding.PKCS1v15(), certificate.signature_hash_algorithm)+ ),+ )+ finally:+ acm_client.delete_certificate(CertificateArn=arn)+def test_describe_certificate(self, acm_client):"""Test DescribeCertificate returns certificate details."""response = acm_client.request_certificate(DomainName="describe.example.com")@@ -164,8 +196,9 @@ class TestACMImportExport:acm_client.delete_certificate(CertificateArn=arn)def test_export_certificate(self, acm_client):- """Test ExportCertificate on imported cert returns cert and key."""+ """Test ExportCertificate returns the imported key, encrypted under the passphrase."""cert_pem, key_pem = self._generate_self_signed_cert()+ passphrase = b"test-passphrase"import_response = acm_client.import_certificate(Certificate=cert_pem, PrivateKey=key_pem@@ -174,10 +207,27 @@ class TestACMImportExport:try:response = acm_client.export_certificate(- CertificateArn=arn, Passphrase=b"test-passphrase"+ CertificateArn=arn, Passphrase=passphrase)assert response["Certificate"]assert response["PrivateKey"]++ # Asserting on the PEM header alone would pass for a key no client can+ # open. Decrypt it with the passphrase and check it is the key that was+ # imported, which is the whole point of the export.+ exported_key = serialization.load_pem_private_key(+ response["PrivateKey"].encode(), password=passphrase+ )+ imported_key = serialization.load_pem_private_key(key_pem, password=None)+ assert (+ exported_key.private_numbers() == imported_key.private_numbers()+ )++ # The passphrase has to actually be doing the work.+ with pytest.raises(ValueError):+ serialization.load_pem_private_key(+ response["PrivateKey"].encode(), password=b"wrong-passphrase"+ )finally:acm_client.delete_certificate(CertificateArn=arn)diff --git a/compatibility-tests/sdk-test-python/tests/test_kms.py b/compatibility-tests/sdk-test-python/tests/test_kms.pyindex 632136f12c..9ebc02f103 100644--- a/compatibility-tests/sdk-test-python/tests/test_kms.py+++ b/compatibility-tests/sdk-test-python/tests/test_kms.py@@ -2,9 +2,38 @@import hashlib+import boto3import pytestfrom botocore.exceptions import ClientError-from cryptography.hazmat.primitives import serialization+from cryptography.hazmat.primitives import hashes, serialization+from cryptography.hazmat.primitives.asymmetric import ec, padding+++# Every signing algorithm each key spec declares. RSA key generation is the only+# real cost here and the fixture below creates one key per spec, so covering the+# full matrix is cheaper than the per-case keys it replaced.+RSA_SIGNING_ALGORITHMS = [+ ("RSASSA_PSS_SHA_256", hashes.SHA256),+ ("RSASSA_PSS_SHA_384", hashes.SHA384),+ ("RSASSA_PSS_SHA_512", hashes.SHA512),+ ("RSASSA_PKCS1_V1_5_SHA_256", hashes.SHA256),+ ("RSASSA_PKCS1_V1_5_SHA_384", hashes.SHA384),+ ("RSASSA_PKCS1_V1_5_SHA_512", hashes.SHA512),+]++SIGNING_CASES = [+ (key_spec, algorithm, digest)+ for key_spec in ("RSA_2048", "RSA_3072", "RSA_4096")+ for algorithm, digest in RSA_SIGNING_ALGORITHMS+] + [+ ("ECC_NIST_P256", "ECDSA_SHA_256", hashes.SHA256),+ ("ECC_NIST_P384", "ECDSA_SHA_384", hashes.SHA384),+ ("ECC_NIST_P521", "ECDSA_SHA_512", hashes.SHA512),+ # secp256k1 is signed with BouncyCastle's lightweight signer, reached directly+ # rather than through a JCA provider, and the JDK dropped the curve. It is the+ # crypto path most likely to break in a native image.+ ("ECC_SECG_P256K1", "ECDSA_SHA_256", hashes.SHA256),+]class TestKMSKey:@@ -207,37 +236,73 @@ class TestKMSEncryption:class TestKMSSigning:"""Test KMS signing operations."""- def test_sign_and_verify(self, kms_client):- """Test Sign and Verify with RSA key."""- # Create an asymmetric signing key- response = kms_client.create_key(- Description="pytest-signing-key",- KeyUsage="SIGN_VERIFY",- KeySpec="RSA_2048",- )- key_id = response["KeyMetadata"]["KeyId"]+ @pytest.fixture(scope="class")+ @staticmethod+ def signing_key(aws_config, client_config):+ """Return one signing key per key spec, created on first use.++ RSA key generation dominates the runtime of this class, so the key is+ shared across every algorithm tested against it.+ """+ client = boto3.client("kms", config=client_config, **aws_config)+ created = {}++ def key_for(key_spec):+ if key_spec not in created:+ created[key_spec] = client.create_key(+ Description="pytest-signing-key",+ KeyUsage="SIGN_VERIFY",+ KeySpec=key_spec,+ )["KeyMetadata"]["KeyId"]+ return created[key_spec]++ yield key_for+ for key_id in created.values():+ client.schedule_key_deletion(KeyId=key_id, PendingWindowInDays=7)++ @pytest.mark.parametrize("key_spec,signing_algorithm,digest", SIGNING_CASES)+ def test_sign_and_verify(+ self, kms_client, signing_key, key_spec, signing_algorithm, digest+ ):+ """Test Sign and Verify, and check the signature against an outside library."""+ key_id = signing_key(key_spec)message = b"message to sign"- try:- # Sign the message- sign_response = kms_client.sign(- KeyId=key_id,- Message=message,- SigningAlgorithm="RSASSA_PSS_SHA_256",- )- signature = sign_response["Signature"]- assert signature-- # Verify the signature- verify_response = kms_client.verify(- KeyId=key_id,- Message=message,- Signature=signature,- SigningAlgorithm="RSASSA_PSS_SHA_256",- )- assert verify_response["SignatureValid"]- finally:- kms_client.schedule_key_deletion(KeyId=key_id, PendingWindowInDays=7)+ # Sign the message+ sign_response = kms_client.sign(+ KeyId=key_id,+ Message=message,+ SigningAlgorithm=signing_algorithm,+ )+ signature = sign_response["Signature"]+ assert signature++ # Verify the signature+ verify_response = kms_client.verify(+ KeyId=key_id,+ Message=message,+ Signature=signature,+ SigningAlgorithm=signing_algorithm,+ )+ assert verify_response["SignatureValid"]++ # Sign and Verify are both Floci, so agreeing with each other proves+ # nothing about the padding, the mask generation function or the salt+ # length. Check the signature against GetPublicKey with the parameters+ # AWS documents for this algorithm instead.+ public_key = serialization.load_der_public_key(+ kms_client.get_public_key(KeyId=key_id)["PublicKey"]+ )+ if signing_algorithm.startswith("ECDSA"):+ public_key.verify(signature, message, ec.ECDSA(digest()))+ else:+ if signing_algorithm.startswith("RSASSA_PSS"):+ scheme = padding.PSS(+ mgf=padding.MGF1(digest()), salt_length=digest.digest_size+ )+ else:+ scheme = padding.PKCS1v15()+ public_key.verify(signature, message, scheme, digest())def test_ed25519_sign_and_verify(self, kms_client):diff --git a/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.java b/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.javaindex 69de131696..f8dd8e6161 100644--- a/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.java+++ b/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.java@@ -3,7 +3,6 @@ package io.github.hectorvent.floci.config;import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.services.acm.CertificateGenerator;import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;-import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.eclipse.microprofile.config.spi.ConfigSource;import org.jboss.logging.Logger;@@ -19,7 +18,6 @@ import java.util.LinkedHashSet;import java.util.List;import java.util.Map;import java.util.Set;-import java.security.Security;/*** A MicroProfile {@link ConfigSource} that dynamically provides Quarkus TLS/SSL@@ -65,13 +63,6 @@ public class TlsConfigSource implements ConfigSource {return;}- // BouncyCastle may not be registered yet — this ConfigSource runs before CDI (@Startup beans)- // and before quarkus-security's runtime provider registration. Register it up front so BOTH- // certificate parsing (isSelfSigned/parseCertificate) and generation work; otherwise- // parseCertificate fails "no such provider: BC", isSelfSigned returns false, and the persisted- // self-signed certificate is needlessly regenerated on every restart.- ensureBouncyCastleRegistered();-String certPath = resolveProperty("floci.tls.cert-path", "");String keyPath = resolveProperty("floci.tls.key-path", "");String selfSigned = resolveProperty("floci.tls.self-signed", "true");@@ -171,16 +162,9 @@ public class TlsConfigSource implements ConfigSource {return defaultValue;}- private static void ensureBouncyCastleRegistered() {- if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {- Security.addProvider(new BouncyCastleProvider());- }- }-private void generateSelfSignedCert(Path tlsDir, Path certFile, Path keyFile) {try {Files.createDirectories(tlsDir);- ensureBouncyCastleRegistered();// Extract custom hostnames and combine with defaultsList<String> customHostnames = extractCustomHostnames();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/BouncyCastleInitializer.java b/src/main/java/io/github/hectorvent/floci/core/common/BouncyCastleInitializer.javadeleted file mode 100644index c0cc076c7c..0000000000--- a/src/main/java/io/github/hectorvent/floci/core/common/BouncyCastleInitializer.java+++ /dev/null@@ -1,32 +0,0 @@-package io.github.hectorvent.floci.core.common;--import io.quarkus.runtime.Startup;-import jakarta.enterprise.context.ApplicationScoped;-import org.bouncycastle.jce.provider.BouncyCastleProvider;-import org.jboss.logging.Logger;--import java.security.Security;--/**- * Ensures BouncyCastle security provider is registered.- * With quarkus-security extension and quarkus.security.security-providers=BC,- * this is handled by Quarkus.- */-@ApplicationScoped-@Startup-public class BouncyCastleInitializer {-- private static final Logger LOG = Logger.getLogger(BouncyCastleInitializer.class);-- static {- if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {- Security.addProvider(new BouncyCastleProvider());- LOG.debug("Registered BouncyCastle security provider (manual fallback)");- } else {- LOG.debug("BouncyCastle provider already registered by Quarkus");- }- }-- public BouncyCastleInitializer() {- }-}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 7fd314ddd2..f75351a049 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@@ -2,8 +2,10 @@ package io.github.hectorvent.floci.services.acm;import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;import jakarta.enterprise.context.ApplicationScoped;-import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;+import org.bouncycastle.asn1.ASN1Primitive;+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.Extension;import org.bouncycastle.asn1.x509.GeneralName;@@ -13,7 +15,6 @@ import org.bouncycastle.cert.X509CertificateHolder;import org.bouncycastle.cert.X509v3CertificateBuilder;import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;-import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.openssl.PEMParser;import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;import org.bouncycastle.openssl.jcajce.JcaPEMWriter;@@ -21,12 +22,13 @@ import org.bouncycastle.openssl.jcajce.JcePEMEncryptorBuilder;import org.bouncycastle.operator.ContentSigner;import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo;-import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfoBuilder;-import org.bouncycastle.pkcs.jcajce.JcaPKCS8EncryptedPrivateKeyInfoBuilder;-import org.bouncycastle.pkcs.jcajce.JcePKCSPBEOutputEncryptorBuilder;import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;import org.jboss.logging.Logger;+import javax.crypto.Cipher;+import javax.crypto.SecretKeyFactory;+import javax.crypto.spec.PBEKeySpec;+import javax.crypto.spec.PBEParameterSpec;import java.io.StringReader;import java.io.StringWriter;import java.math.BigInteger;@@ -52,6 +54,9 @@ public class CertificateGenerator {private static final Logger LOG = Logger.getLogger(CertificateGenerator.class);private static final String ISSUER_DN = "CN=Amazon,OU=Server CA 1B,O=Amazon,C=US";private static final SecureRandom SECURE_RANDOM = new SecureRandom();+ private static final String PBE_ALGORITHM = "PBEWithHmacSHA256AndAES_256";+ private static final int PBE_SALT_BYTES = 16;+ private static final int PBE_ITERATIONS = 4096;/*** Pattern matching IPv4 addresses (e.g. 192.168.1.100) and IPv6 addresses@@ -166,12 +171,10 @@ public class CertificateGenerator {// 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)- .setProvider(BouncyCastleProvider.PROVIDER_NAME).build(keyPair.getPrivate());X509CertificateHolder certHolder = certBuilder.build(signer);X509Certificate cert = new JcaX509CertificateConverter()- .setProvider(BouncyCastleProvider.PROVIDER_NAME).getCertificate(certHolder);String certPem = toPem(cert);@@ -197,10 +200,10 @@ public class CertificateGenerator {private KeyPair generateKeyPair(KeyAlgorithm keyAlgorithm) throws Exception {KeyPairGenerator keyGen;if ("EC".equals(keyAlgorithm.getAlgorithm())) {- keyGen = KeyPairGenerator.getInstance("EC", BouncyCastleProvider.PROVIDER_NAME);+ keyGen = KeyPairGenerator.getInstance("EC");keyGen.initialize(new ECGenParameterSpec(keyAlgorithm.getCurveName()), SECURE_RANDOM);} else {- keyGen = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME);+ keyGen = KeyPairGenerator.getInstance("RSA");keyGen.initialize(keyAlgorithm.getKeySize(), SECURE_RANDOM);}return keyGen.generateKeyPair();@@ -260,16 +263,24 @@ public class CertificateGenerator {try {PrivateKey privateKey = parsePrivateKey(privateKeyPem);- // Use AES-256-CBC instead of deprecated Triple-DES- JcePKCSPBEOutputEncryptorBuilder encryptorBuilder = new JcePKCSPBEOutputEncryptorBuilder(- NISTObjectIdentifiers.id_aes256_CBC- );- encryptorBuilder.setProvider(BouncyCastleProvider.PROVIDER_NAME);-- PKCS8EncryptedPrivateKeyInfoBuilder pkcs8Builder = new JcaPKCS8EncryptedPrivateKeyInfoBuilder(privateKey);- PKCS8EncryptedPrivateKeyInfo encryptedInfo = pkcs8Builder.build(- encryptorBuilder.build(passphrase.toCharArray())- );+ // PBES2 with AES-256-CBC, run through the JDK so no JCE provider has to be+ // registered. The algorithm name fixes the PBKDF2 PRF to HMAC-SHA256, and the+ // salt and iteration count are passed explicitly so the output does not depend+ // on provider defaults. The ASN.1 below only wraps the result, so it needs no+ // provider either.+ var secretKey = SecretKeyFactory.getInstance(PBE_ALGORITHM)+ .generateSecret(new PBEKeySpec(passphrase.toCharArray()));+ var salt = new byte[PBE_SALT_BYTES];+ SECURE_RANDOM.nextBytes(salt);+ var cipher = Cipher.getInstance(PBE_ALGORITHM);+ cipher.init(Cipher.ENCRYPT_MODE, secretKey, new PBEParameterSpec(salt, PBE_ITERATIONS));+ var ciphertext = cipher.doFinal(privateKey.getEncoded());++ var scheme = new AlgorithmIdentifier(+ PKCSObjectIdentifiers.id_PBES2,+ ASN1Primitive.fromByteArray(cipher.getParameters().getEncoded()));+ var encryptedInfo =+ new PKCS8EncryptedPrivateKeyInfo(new EncryptedPrivateKeyInfo(scheme, ciphertext));StringWriter sw = new StringWriter();try (JcaPEMWriter pemWriter = new JcaPEMWriter(sw)) {@@ -288,7 +299,6 @@ public class CertificateGenerator {Object obj = parser.readObject();if (obj instanceof X509CertificateHolder holder) {return new JcaX509CertificateConverter()- .setProvider(BouncyCastleProvider.PROVIDER_NAME).getCertificate(holder);}throw new IllegalArgumentException("Invalid certificate PEM format");@@ -301,8 +311,7 @@ public class CertificateGenerator {public PrivateKey parsePrivateKey(String keyPem) {try (PEMParser parser = new PEMParser(new StringReader(keyPem))) {Object obj = parser.readObject();- JcaPEMKeyConverter converter = new JcaPEMKeyConverter()- .setProvider(BouncyCastleProvider.PROVIDER_NAME);+ JcaPEMKeyConverter converter = new JcaPEMKeyConverter();if (obj instanceof org.bouncycastle.openssl.PEMKeyPair pemKeyPair) {return converter.getKeyPair(pemKeyPair).getPrivate();diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.java b/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.javaindex fd3e760ce0..28416443e1 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/KmsService.java@@ -29,6 +29,11 @@ import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;import org.bouncycastle.asn1.x509.AlgorithmIdentifier;import org.bouncycastle.asn1.x509.DigestInfo;import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;+import org.bouncycastle.crypto.Digest;+import org.bouncycastle.crypto.digests.SHA256Digest;+import org.bouncycastle.crypto.digests.SHA384Digest;+import org.bouncycastle.crypto.digests.SHA512Digest;+import org.bouncycastle.crypto.engines.RSABlindedEngine;import org.bouncycastle.crypto.params.ECDomainParameters;import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;@@ -37,6 +42,9 @@ import org.bouncycastle.crypto.params.ECPublicKeyParameters;import org.bouncycastle.crypto.params.ParametersWithRandom;import org.bouncycastle.crypto.signers.ECDSASigner;import org.bouncycastle.crypto.signers.Ed25519phSigner;+import org.bouncycastle.crypto.signers.PSSSigner;+import org.bouncycastle.crypto.util.PrivateKeyFactory;+import org.bouncycastle.crypto.util.PublicKeyFactory;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;import org.bouncycastle.jcajce.provider.asymmetric.ec.KeyFactorySpi;@@ -56,7 +64,9 @@ import java.nio.charset.StandardCharsets;import java.security.*;import java.security.interfaces.EdECPrivateKey;import java.security.spec.ECGenParameterSpec;+import java.security.spec.MGF1ParameterSpec;import java.security.spec.PKCS8EncodedKeySpec;+import java.security.spec.PSSParameterSpec;import java.security.spec.X509EncodedKeySpec;import java.time.Instant;import java.util.*;@@ -948,6 +958,9 @@ public class KmsService implements ResourceProvider {if (ed25519) {return signEd25519(privateKey, message, algorithm);}+ if (messageType == DIGEST && isRsaPssRequest(kmsKey.getKeySpec(), algorithm)) {+ return signRsaPssDigest(privateKey, message, algorithm);+ }String jcaAlgo = switch (messageType) {// If message is already a digest, we need a "NONEwith..." algorithmcase DIGEST -> "NONEwith" + (kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.RSA ? "RSA" : "ECDSA");@@ -962,10 +975,12 @@ public class KmsService implements ResourceProvider {if (isSecgP256k1(kmsKey.getKeySpec())) {return signSecgP256k1(privateKey, message, jcaAlgo);}- Signature sig = Signature.getInstance(jcaAlgo);+ var sig = signatureFor(jcaAlgo);sig.initSign(privateKey);sig.update(message);return sig.sign();+ } catch (AwsException e) {+ throw e;} catch (Exception e) {throw new AwsException("InternalFailure", "Failed to sign message: " + e.getMessage(), 500);}@@ -994,6 +1009,9 @@ public class KmsService implements ResourceProvider {String jcaAlgo = KmsKeySpec.getSignVerifyAlgorithm(algorithm).getJavaName();if (DIGEST.equals(messageType)) {+ if (isRsaPssRequest(kmsKey.getKeySpec(), algorithm)) {+ return verifyRsaPssDigest(publicKey, message, signature, algorithm);+ }jcaAlgo = "NONEwith" + (kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.RSA ? "RSA" : "ECDSA");if (isPKCS1v1_5(kmsKey.getKeySpec().getAlgorithm().getFirst())) {// Mirror sign(): verify against DigestInfo{hashOID, digest} (RFC 8017 9.2).@@ -1003,10 +1021,12 @@ public class KmsService implements ResourceProvider {if (isSecgP256k1(kmsKey.getKeySpec())) {return verifySecgP256k1(publicKey, message, signature, jcaAlgo);}- Signature sig = Signature.getInstance(jcaAlgo);+ var sig = signatureFor(jcaAlgo);sig.initVerify(publicKey);sig.update(message);return sig.verify(signature);+ } catch (AwsException e) {+ throw e;} catch (Exception e) {LOG.warnv("Verification failed for key {0}: {1}", keyId, e.getMessage());return false;@@ -1265,6 +1285,71 @@ public class KmsService implements ResourceProvider {return SubjectPublicKeyInfo.getInstance(publicKey.getEncoded()).getPublicKeyData().getBytes();}+ /**+ * Builds the {@link Signature} for a KMS signing algorithm.+ *+ * <p>BouncyCastle names PSS signatures {@code SHAnnnwithRSA/PSS}, and only its provider+ * answers to that name. The JDK exposes one {@code RSASSA-PSS} Signature whose digest,+ * mask generation function and salt length come from a parameter spec instead. AWS KMS+ * RSASSA_PSS_SHA_nnn uses MGF1 over the same digest with a salt as long as that digest,+ * which is what BouncyCastle's alias defaults to, so a signature made either way verifies+ * against the other. Every other name Floci asks for is a standard JCA name.+ */+ private static Signature signatureFor(String jcaAlgorithm) throws GeneralSecurityException {+ if (!jcaAlgorithm.endsWith("withRSA/PSS")) {+ return Signature.getInstance(jcaAlgorithm);+ }+ var digest = "SHA-" + jcaAlgorithm.substring("SHA".length(), jcaAlgorithm.indexOf("with"));+ var maskGeneration = switch (digest) {+ case "SHA-256" -> MGF1ParameterSpec.SHA256;+ case "SHA-384" -> MGF1ParameterSpec.SHA384;+ case "SHA-512" -> MGF1ParameterSpec.SHA512;+ default -> throw new NoSuchAlgorithmException("Unsupported PSS digest: " + digest);+ };+ var saltLength = MessageDigest.getInstance(digest).getDigestLength();+ var signature = Signature.getInstance("RSASSA-PSS");+ signature.setParameter(new PSSParameterSpec(digest, "MGF1", maskGeneration, saltLength, 1));+ return signature;+ }++ private static boolean isRsaPssRequest(KmsKeySpec spec, String algorithm) {+ return spec.getKeyType() == KmsKeySpec.KeyType.RSA && algorithm.startsWith("RSASSA_PSS");+ }++ /**+ * Signs a pre-computed digest with RSASSA-PSS.+ *+ * <p>Real KMS applies the PSS encoding directly to the digest a {@code MessageType=DIGEST}+ * caller sends. The JDK's {@code RSASSA-PSS} Signature always hashes its input first, so+ * this uses BouncyCastle's lightweight raw PSS signer, instantiated directly like the+ * secp256k1 and Ed25519ph paths. The raw signer defaults to MGF1 over the same digest with+ * a salt as long as that digest, matching {@link #signatureFor(String)}, so RAW and DIGEST+ * signatures verify against each other.+ */+ private static byte[] signRsaPssDigest(PrivateKey privateKey, byte[] digest, String algorithm) throws Exception {+ var signer = rawPssSigner(algorithm);+ signer.init(true, new ParametersWithRandom(PrivateKeyFactory.createKey(privateKey.getEncoded()), SECURE_RANDOM));+ signer.update(digest, 0, digest.length);+ return signer.generateSignature();+ }++ private static boolean verifyRsaPssDigest(PublicKey publicKey, byte[] digest, byte[] signature, String algorithm) throws Exception {+ var signer = rawPssSigner(algorithm);+ signer.init(false, PublicKeyFactory.createKey(publicKey.getEncoded()));+ signer.update(digest, 0, digest.length);+ return signer.verifySignature(signature);+ }++ private static PSSSigner rawPssSigner(String algorithm) {+ Digest digest = switch (algorithm) {+ case "RSASSA_PSS_SHA_256" -> new SHA256Digest();+ case "RSASSA_PSS_SHA_384" -> new SHA384Digest();+ case "RSASSA_PSS_SHA_512" -> new SHA512Digest();+ default -> throw new AwsException("InvalidSigningAlgorithmException", "Unsupported algorithm: " + algorithm, 400);+ };+ return PSSSigner.createRawSigner(new RSABlindedEngine(), digest);+ }+private static boolean isPKCS1v1_5(KmsKeySpec.Algorithm spec) {return spec == KmsKeySpec.Algorithm.RSASSA_PKCS1_V1_5_SHA_256|| spec == KmsKeySpec.Algorithm.RSASSA_PKCS1_V1_5_SHA_384diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyTlsCertificates.java b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyTlsCertificates.javaindex c6f0bfc0f9..e17e6dc3aa 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyTlsCertificates.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyTlsCertificates.java@@ -7,7 +7,6 @@ import io.github.hectorvent.floci.services.acm.CertificateGenerator;import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;-import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.jboss.logging.Logger;import javax.net.ssl.KeyManagerFactory;@@ -21,7 +20,6 @@ import java.security.KeyPair;import java.security.KeyStore;import java.security.PrivateKey;import java.security.SecureRandom;-import java.security.Security;import java.security.cert.X509Certificate;import java.util.ArrayList;import java.util.LinkedHashSet;@@ -108,7 +106,6 @@ public class RdsProxyTlsCertificates {if (sslContext != null) {return;}- ensureBouncyCastleRegistered();Path tlsDir = tlsDir();Path certFile = tlsDir.resolve(CERT_NAME);Path keyFile = tlsDir.resolve(KEY_NAME);@@ -195,12 +192,6 @@ public class RdsProxyTlsCertificates {return Path.of(config.storage().persistentPath(), TLS_DIR);}- private static void ensureBouncyCastleRegistered() {- if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {- Security.addProvider(new BouncyCastleProvider());- }- }-/*** Restricts {@code path} to owner-only access. This CA's private key is meant to be trusted by* a developer's client tooling (e.g. {@code sslmode=verify-full}), so unlike Floci's otherdiff --git a/src/main/resources/META-INF/native-image/reflect-config.json b/src/main/resources/META-INF/native-image/reflect-config.jsonindex 6f7df66adc..e7563033db 100644--- a/src/main/resources/META-INF/native-image/reflect-config.json+++ b/src/main/resources/META-INF/native-image/reflect-config.json@@ -2402,153 +2402,6 @@"allDeclaredMethods": true,"allDeclaredFields": true},- {- "name": "org.bouncycastle.jce.provider.BouncyCastleProvider",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.KeyFactorySpi",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.KeyFactorySpi$EC",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.KeyPairGeneratorSpi",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.KeyPairGeneratorSpi$EC",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.x509.CertificateFactory",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.digest.SHA256$Digest",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.digest.SHA384$Digest",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.DigestSignatureSpi$SHA256",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.SignatureSpi$ecDSA256",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.symmetric.AES$ECB",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.symmetric.PBEPBKDF2$PBKDF2withSHA256",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.digest.SHA512$Digest",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.DigestSignatureSpi$SHA512",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.SignatureSpi$ecDSA512",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.symmetric.AES$CBC",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.EC$Mappings",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.RSA$Mappings",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.asymmetric.X509$Mappings",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.digest.SHA512$Mappings",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },- {- "name": "org.bouncycastle.jcajce.provider.symmetric.AES$Mappings",- "allDeclaredConstructors": true,- "allPublicConstructors": true,- "allDeclaredMethods": true,- "allDeclaredFields": true- },{"name": "io.github.hectorvent.floci.services.appsync.graphql.AppSyncVtlEngine","allDeclaredConstructors": true,diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 0adb5c579a..678b649ba9 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -17,8 +17,6 @@ quarkus:max-body-size: ${floci.protocols.max-request-size}Mdatasource:active: false- security:- security-providers: BCshutdown:# Enables the pre-shutdown phase so stop hooks run before the HTTP server stops.# No 'delay' value is set - observers run synchronously, no artificial sleep is introduced.@@ -67,12 +65,6 @@ quarkus:- --enable-url-protocols=http,https- --initialize-at-run-time=io.vertx.ext.mail.impl.sasl.NTLMEngineImpl- --initialize-at-run-time=com.github.dockerjava.transport.NamedPipeSocket$Kernel32- - --initialize-at-run-time=org.bouncycastle.jcajce.provider.drbg.DRBG$Default- - --initialize-at-run-time=org.bouncycastle.jcajce.provider.drbg.DRBG$NonceAndIV- - --initialize-at-run-time=org.bouncycastle.crypto.prng.SP800SecureRandom- - --initialize-at-run-time=org.bouncycastle.jcajce.provider.asymmetric.rsa.KeyPairGeneratorSpi- - --initialize-at-run-time=org.bouncycastle.jcajce.provider.asymmetric.x509.CertificateFactory- - --initialize-at-run-time=io.github.hectorvent.floci.core.common.BouncyCastleInitializer- --initialize-at-run-time=io.github.hectorvent.floci.services.acm.AcmService- --initialize-at-run-time=io.github.hectorvent.floci.services.acm.CertificateGenerator- --initialize-at-run-time=io.github.hectorvent.floci.config.TlsConfigSourcediff --git a/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.javaindex 7c6244d60c..bb00b84195 100644--- a/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/kms/KmsServiceTest.java@@ -22,6 +22,8 @@ import java.security.KeyFactory;import java.security.MessageDigest;import java.security.PublicKey;import java.security.Signature;+import java.security.spec.MGF1ParameterSpec;+import java.security.spec.PSSParameterSpec;import java.security.spec.X509EncodedKeySpec;import java.util.Arrays;import java.util.Base64;@@ -1258,6 +1260,53 @@ class KmsServiceTest {assertArrayEquals(rawSig, digestSig);}+ @Test+ void signWithDigestMessageTypePssVerifiesWithExternalVerifier() throws Exception {+ KmsKey key = kmsService.createKey("rsa pss digest key", "SIGN_VERIFY", "RSA_2048", null, Map.of(), REGION);+ byte[] message = "floci kms pss round-trip".getBytes(StandardCharsets.UTF_8);+ byte[] digest = MessageDigest.getInstance("SHA-256").digest(message);++ byte[] sig = kmsService.sign(key.getKeyId(), digest,+ "RSASSA_PSS_SHA_256", KmsMessageType.DIGEST, REGION);++ // floci's own Verify round-trips, against the digest and against the raw message.+ assertTrue(kmsService.verify(key.getKeyId(), digest, sig,+ "RSASSA_PSS_SHA_256", KmsMessageType.DIGEST, REGION));+ assertTrue(kmsService.verify(key.getKeyId(), message, sig,+ "RSASSA_PSS_SHA_256", KmsMessageType.RAW, REGION));++ // External verifier with the PSS parameters AWS documents for RSASSA_PSS_SHA_256.+ byte[] der = Base64.getDecoder().decode(kmsService.getPublicKey(key.getKeyId(), REGION).getPublicKeyEncoded());+ PublicKey pub = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(der));+ Signature verifier = Signature.getInstance("RSASSA-PSS");+ verifier.setParameter(new PSSParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, 32, 1));+ verifier.initVerify(pub);+ verifier.update(message);+ assertTrue(verifier.verify(sig), "DIGEST PSS signature must verify as real RSASSA-PSS");+ }++ @Test+ void signWithInvalidAlgorithmThrowsInvalidSigningAlgorithm() {+ var key = kmsService.createKey("ecdsa key", "SIGN_VERIFY", "ECC_NIST_P256", null, Map.of(), REGION);++ var ex = assertThrows(AwsException.class, () ->+ kmsService.sign(key.getKeyId(), "sign me".getBytes(StandardCharsets.UTF_8), "NOT_AN_ALGORITHM", REGION));++ assertEquals("InvalidSigningAlgorithmException", ex.getErrorCode());+ }++ @Test+ void verifyWithInvalidAlgorithmThrowsInvalidSigningAlgorithm() {+ var key = kmsService.createKey("ecdsa key", "SIGN_VERIFY", "ECC_NIST_P256", null, Map.of(), REGION);+ var message = "sign me".getBytes(StandardCharsets.UTF_8);+ var sig = kmsService.sign(key.getKeyId(), message, "ECDSA_SHA_256", REGION);++ var ex = assertThrows(AwsException.class, () ->+ kmsService.verify(key.getKeyId(), message, sig, "NOT_AN_ALGORITHM", REGION));++ assertEquals("InvalidSigningAlgorithmException", ex.getErrorCode());+ }+@Testvoid verifyWithWrongSignatureReturnsFalse() {KmsKey key = kmsService.createKey("ecdsa key", "SIGN_VERIFY", "ECC_NIST_P256", null, Map.of(), REGION);