Light, fluffy, and always free - The AWS Local Emulator alternative
perf(kms): drop unused BouncyCastle curves from the native image (#4868)
TATSUNO “Taz” Yasuhirobdab4448d600
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KmsAsymmetricKeysTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KmsAsymmetricKeysTest.javanew file mode 100644index 0000000000..d7df2b5679--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KmsAsymmetricKeysTest.java@@ -0,0 +1,207 @@+package com.floci.test;++import org.bouncycastle.jce.provider.BouncyCastleProvider;+import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import software.amazon.awssdk.core.SdkBytes;+import software.amazon.awssdk.services.kms.KmsClient;+import software.amazon.awssdk.services.kms.model.AlgorithmSpec;+import software.amazon.awssdk.services.kms.model.CreateKeyResponse;+import software.amazon.awssdk.services.kms.model.ExpirationModelType;+import software.amazon.awssdk.services.kms.model.GetParametersForImportResponse;+import software.amazon.awssdk.services.kms.model.KeySpec;+import software.amazon.awssdk.services.kms.model.KeyUsageType;+import software.amazon.awssdk.services.kms.model.MessageType;+import software.amazon.awssdk.services.kms.model.OriginType;+import software.amazon.awssdk.services.kms.model.SigningAlgorithmSpec;+import software.amazon.awssdk.services.kms.model.WrappingKeySpec;++import javax.crypto.Cipher;+import javax.crypto.spec.OAEPParameterSpec;+import javax.crypto.spec.PSource;+import java.nio.charset.StandardCharsets;+import java.security.GeneralSecurityException;+import java.security.KeyFactory;+import java.security.KeyPair;+import java.security.KeyPairGenerator;+import java.security.MessageDigest;+import java.security.Provider;+import java.security.PublicKey;+import java.security.Signature;+import java.security.spec.ECGenParameterSpec;+import java.security.spec.MGF1ParameterSpec;+import java.security.spec.PSSParameterSpec;+import java.security.spec.X509EncodedKeySpec;++import static org.assertj.core.api.Assertions.assertThat;++/**+ * Signing and key import paths that build BouncyCastle key parameters by hand, so a class the+ * native image left out shows up here rather than only in JVM tests.+ */+class KmsAsymmetricKeysTest {++ // secp256k1 is not in the JDK.+ private static final Provider BC = new BouncyCastleProvider();+ private static final byte[] MESSAGE = "floci asymmetric keys".getBytes(StandardCharsets.UTF_8);++ private static KmsClient kms;+ // RSA key generation is the slow part of this class, so the PSS cases share one key.+ private static String rsaKeyId;++ @BeforeAll+ static void setUp() {+ kms = TestFixtures.kmsClient();+ rsaKeyId = createKey(KeySpec.RSA_2048);+ }++ @AfterAll+ static void tearDown() {+ if (kms != null) {+ if (rsaKeyId != null) {+ scheduleDeletion(rsaKeyId);+ }+ kms.close();+ }+ }++ @Test+ void secp256k1KeySignsRawAndDigestMessages() throws Exception {+ String keyId = createKey(KeySpec.ECC_SECG_P256_K1);+ try {+ PublicKey publicKey = publicKey(keyId, "EC");+ byte[] digest = MessageDigest.getInstance("SHA-256").digest(MESSAGE);++ byte[] rawSignature = sign(keyId, MESSAGE, MessageType.RAW, SigningAlgorithmSpec.ECDSA_SHA_256);+ byte[] digestSignature = sign(keyId, digest, MessageType.DIGEST, SigningAlgorithmSpec.ECDSA_SHA_256);++ assertThat(verifyLocally(publicKey, "SHA256withECDSA", rawSignature)).isTrue();+ assertThat(verifyLocally(publicKey, "SHA256withECDSA", digestSignature)).isTrue();+ assertThat(verify(keyId, MESSAGE, MessageType.RAW, SigningAlgorithmSpec.ECDSA_SHA_256, digestSignature))+ .isTrue();+ assertThat(verify(keyId, digest, MessageType.DIGEST, SigningAlgorithmSpec.ECDSA_SHA_256, rawSignature))+ .isTrue();+ } finally {+ scheduleDeletion(keyId);+ }+ }++ @ParameterizedTest+ @CsvSource({+ "ECC_NIST_P256, secp256r1, RSA_2048, ECDSA_SHA_256, SHA256withECDSA",+ "ECC_NIST_P384, secp384r1, RSA_2048, ECDSA_SHA_384, SHA384withECDSA",+ "ECC_NIST_P521, secp521r1, RSA_3072, ECDSA_SHA_512, SHA512withECDSA",+ "ECC_SECG_P256_K1, secp256k1, RSA_2048, ECDSA_SHA_256, SHA256withECDSA"+ })+ void importedEcKeyKeepsItsPublicKeyAndSigns(KeySpec keySpec, String curve, WrappingKeySpec wrappingKeySpec,+ SigningAlgorithmSpec algorithm, String jcaAlgorithm)+ throws Exception {+ // The JDK leaves the public key out of PKCS#8, which keeps the material under the OAEP size limit.+ KeyPairGenerator generator = "secp256k1".equals(curve) ? KeyPairGenerator.getInstance("EC", BC)+ : KeyPairGenerator.getInstance("EC");+ generator.initialize(new ECGenParameterSpec(curve));+ KeyPair keyPair = generator.generateKeyPair();++ CreateKeyResponse created = kms.createKey(b -> b+ .keySpec(keySpec)+ .keyUsage(KeyUsageType.SIGN_VERIFY)+ .origin(OriginType.EXTERNAL));+ String keyId = created.keyMetadata().keyId();+ try {+ GetParametersForImportResponse parameters = kms.getParametersForImport(b -> b+ .keyId(keyId)+ .wrappingAlgorithm(AlgorithmSpec.RSAES_OAEP_SHA_256)+ .wrappingKeySpec(wrappingKeySpec));+ byte[] wrapped = wrapWithRsaOaepSha256(parameters.publicKey().asByteArray(),+ keyPair.getPrivate().getEncoded());+ kms.importKeyMaterial(b -> b+ .keyId(keyId)+ .importToken(parameters.importToken())+ .encryptedKeyMaterial(SdkBytes.fromByteArray(wrapped))+ .expirationModel(ExpirationModelType.KEY_MATERIAL_DOES_NOT_EXPIRE));++ byte[] publicKey = kms.getPublicKey(b -> b.keyId(keyId)).publicKey().asByteArray();+ assertThat(publicKey).isEqualTo(keyPair.getPublic().getEncoded());++ byte[] signature = sign(keyId, MESSAGE, MessageType.RAW, algorithm);+ assertThat(verifyLocally(keyPair.getPublic(), jcaAlgorithm, signature)).isTrue();+ } finally {+ scheduleDeletion(keyId);+ }+ }++ @ParameterizedTest+ @CsvSource({+ "RSASSA_PSS_SHA_256, SHA-256",+ "RSASSA_PSS_SHA_384, SHA-384",+ "RSASSA_PSS_SHA_512, SHA-512"+ })+ void rsaPssSignsDigestMessages(SigningAlgorithmSpec algorithm, String digestName) throws Exception {+ byte[] digest = MessageDigest.getInstance(digestName).digest(MESSAGE);+ byte[] signature = sign(rsaKeyId, digest, MessageType.DIGEST, algorithm);++ assertThat(verify(rsaKeyId, digest, MessageType.DIGEST, algorithm, signature)).isTrue();+ assertThat(verify(rsaKeyId, MESSAGE, MessageType.RAW, algorithm, signature)).isTrue();++ Signature verifier = Signature.getInstance("RSASSA-PSS");+ int saltLength = MessageDigest.getInstance(digestName).getDigestLength();+ verifier.setParameter(new PSSParameterSpec(digestName, "MGF1", new MGF1ParameterSpec(digestName),+ saltLength, 1));+ verifier.initVerify(publicKey(rsaKeyId, "RSA"));+ verifier.update(MESSAGE);+ assertThat(verifier.verify(signature)).isTrue();+ }++ private static String createKey(KeySpec keySpec) {+ return kms.createKey(b -> b.keySpec(keySpec).keyUsage(KeyUsageType.SIGN_VERIFY)).keyMetadata().keyId();+ }++ private static PublicKey publicKey(String keyId, String algorithm) throws GeneralSecurityException {+ byte[] encoded = kms.getPublicKey(b -> b.keyId(keyId)).publicKey().asByteArray();+ KeyFactory factory = "EC".equals(algorithm) ? KeyFactory.getInstance(algorithm, BC)+ : KeyFactory.getInstance(algorithm);+ return factory.generatePublic(new X509EncodedKeySpec(encoded));+ }++ private static byte[] sign(String keyId, byte[] message, MessageType messageType,+ SigningAlgorithmSpec algorithm) {+ return kms.sign(b -> b+ .keyId(keyId)+ .message(SdkBytes.fromByteArray(message))+ .messageType(messageType)+ .signingAlgorithm(algorithm)).signature().asByteArray();+ }++ private static boolean verify(String keyId, byte[] message, MessageType messageType,+ SigningAlgorithmSpec algorithm, byte[] signature) {+ return kms.verify(b -> b+ .keyId(keyId)+ .message(SdkBytes.fromByteArray(message))+ .messageType(messageType)+ .signingAlgorithm(algorithm)+ .signature(SdkBytes.fromByteArray(signature))).signatureValid();+ }++ private static boolean verifyLocally(PublicKey publicKey, String jcaAlgorithm, byte[] signature)+ throws GeneralSecurityException {+ Signature verifier = Signature.getInstance(jcaAlgorithm, BC);+ verifier.initVerify(publicKey);+ verifier.update(MESSAGE);+ return verifier.verify(signature);+ }++ private static void scheduleDeletion(String keyId) {+ kms.scheduleKeyDeletion(b -> b.keyId(keyId).pendingWindowInDays(7));+ }++ private static byte[] wrapWithRsaOaepSha256(byte[] publicKeyDer, byte[] material) throws GeneralSecurityException {+ PublicKey wrappingKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(publicKeyDer));+ Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPPadding");+ cipher.init(Cipher.ENCRYPT_MODE, wrappingKey, new OAEPParameterSpec("SHA-256", "MGF1",+ MGF1ParameterSpec.SHA256, PSource.PSpecified.DEFAULT));+ return cipher.doFinal(material);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeys.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeys.javaindex 22db979da8..37022056c4 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeys.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeys.java@@ -6,57 +6,104 @@ import org.bouncycastle.asn1.ASN1BitString;import org.bouncycastle.asn1.ASN1Encoding;import org.bouncycastle.asn1.ASN1Object;import org.bouncycastle.asn1.ASN1ObjectIdentifier;+import org.bouncycastle.asn1.DERBitString;+import org.bouncycastle.asn1.gm.GMObjectIdentifiers;import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;import org.bouncycastle.asn1.sec.ECPrivateKey;+import org.bouncycastle.asn1.sec.SECObjectIdentifiers;import org.bouncycastle.asn1.x509.AlgorithmIdentifier;import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;+import org.bouncycastle.asn1.x9.X962Parameters;import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;+import org.bouncycastle.crypto.generators.ECKeyPairGenerator;import org.bouncycastle.crypto.params.ECDomainParameters;+import org.bouncycastle.crypto.params.ECKeyGenerationParameters;import org.bouncycastle.crypto.params.ECPrivateKeyParameters;import org.bouncycastle.crypto.params.ECPublicKeyParameters;-import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;-import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;-import org.bouncycastle.jcajce.provider.asymmetric.ec.KeyFactorySpi;-import org.bouncycastle.jcajce.provider.asymmetric.ec.KeyPairGeneratorSpi;-import org.bouncycastle.jcajce.provider.asymmetric.util.ECUtil;-import org.bouncycastle.jcajce.provider.util.AsymmetricKeyInfoConverter;-import org.bouncycastle.jce.ECNamedCurveTable;-import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;+import org.bouncycastle.math.ec.ECCurve;import org.bouncycastle.math.ec.ECPoint;+import org.bouncycastle.math.ec.WNafUtil;+import org.bouncycastle.math.ec.custom.gm.SM2P256V1Curve;+import org.bouncycastle.math.ec.custom.sec.SecP256K1Curve;+import org.bouncycastle.math.ec.custom.sec.SecP256R1Curve;+import org.bouncycastle.math.ec.custom.sec.SecP384R1Curve;+import org.bouncycastle.math.ec.custom.sec.SecP521R1Curve;+import org.bouncycastle.math.ec.endo.GLVTypeBEndomorphism;+import org.bouncycastle.math.ec.endo.GLVTypeBParameters;+import org.bouncycastle.math.ec.endo.ScalarSplitParameters;+import org.bouncycastle.util.encoders.Hex;import java.io.IOException;import java.math.BigInteger;-import java.security.InvalidAlgorithmParameterException;-import java.security.KeyPair;-import java.security.KeyPairGenerator;-import java.security.spec.ECGenParameterSpec;+import java.security.GeneralSecurityException;+import java.security.SecureRandom;import java.security.spec.InvalidKeySpecException;import java.util.Base64;+import java.util.Map;-// The BouncyCastle SPI classes are allocated directly. JCA lookup cannot find them in the native image.+// Each curve is built from its own BouncyCastle class. A lookup through BouncyCastle's named curve+// tables would keep every curve those tables know in the native image.final class BcEcKeys {+ private static final Map<String, NamedCurve> CURVES = Map.of(+ // G from SEC 2, the same point as NIST P-256+ "secp256r1", new NamedCurve(SECObjectIdentifiers.secp256r1, new SecP256R1Curve(),+ "046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296"+ + "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5"),+ // G from SEC 2, the same point as NIST P-384+ "secp384r1", new NamedCurve(SECObjectIdentifiers.secp384r1, new SecP384R1Curve(),+ "04AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7"+ + "3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F"),+ // G from SEC 2, the same point as NIST P-521+ "secp521r1", new NamedCurve(SECObjectIdentifiers.secp521r1, new SecP521R1Curve(),+ "0400C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE7"+ + "5928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66"+ + "011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF4"+ + "2640C550B9013FAD0761353C7086A272C24088BE94769FD16650"),+ // G from SEC 2+ "secp256k1", new NamedCurve(SECObjectIdentifiers.secp256k1, secp256k1Curve(),+ "0479BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"+ + "483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8"),+ // G from GB/T 32918.5+ "sm2p256v1", new NamedCurve(GMObjectIdentifiers.sm2p256v1, new SM2P256V1Curve(),+ "0432C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7"+ + "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"));+private BcEcKeys() {}- static KeyPair generateKeyPair(String curveName) throws InvalidAlgorithmParameterException {- KeyPairGenerator generator = new KeyPairGeneratorSpi.EC();- generator.initialize(new ECGenParameterSpec(curveName));- return generator.generateKeyPair();+ static void generateKeyPair(KmsKey key, String curveName, SecureRandom random)+ throws GeneralSecurityException {+ NamedCurve curve = curve(curveName);+ ECKeyPairGenerator generator = new ECKeyPairGenerator();+ generator.init(new ECKeyGenerationParameters(curve.domain(), random));+ AsymmetricCipherKeyPair pair = generator.generateKeyPair();+ BigInteger privateScalar = ((ECPrivateKeyParameters) pair.getPrivate()).getD();+ ECPoint publicPoint = ((ECPublicKeyParameters) pair.getPublic()).getQ();+ DERBitString publicKey = new DERBitString(publicPoint.getEncoded(false));+ ECPrivateKey privateKey = new ECPrivateKey(curve.domain().getN().bitLength(), privateScalar, publicKey,+ curve.parameters());+ try {+ store(key, new PrivateKeyInfo(curve.algorithm(), privateKey).getEncoded(ASN1Encoding.DER),+ new SubjectPublicKeyInfo(curve.algorithm(), publicKey).getEncoded(ASN1Encoding.DER));+ } catch (IOException e) {+ throw new GeneralSecurityException("Could not encode the " + curveName + " key pair", e);+ }}static ECPrivateKeyParameters privateKeyParameters(KmsKey key, String curveName) throws IOException {- AsymmetricKeyInfoConverter converter = new KeyFactorySpi.EC();byte[] decoded = Base64.getDecoder().decode(key.getPrivateKeyEncoded());- BCECPrivateKey privateKey = (BCECPrivateKey) converter.generatePrivate(PrivateKeyInfo.getInstance(decoded));- return new ECPrivateKeyParameters(privateKey.getD(), domainParameters(curveName));+ PrivateKeyInfo info = PrivateKeyInfo.getInstance(decoded);+ BigInteger privateScalar = ECPrivateKey.getInstance(info.parsePrivateKey()).getKey();+ return new ECPrivateKeyParameters(privateScalar, curve(curveName).domain());}- static ECPublicKeyParameters publicKeyParameters(KmsKey key, String curveName) throws IOException {- AsymmetricKeyInfoConverter converter = new KeyFactorySpi.EC();+ static ECPublicKeyParameters publicKeyParameters(KmsKey key, String curveName) {byte[] decoded = Base64.getDecoder().decode(key.getPublicKeyEncoded());- BCECPublicKey publicKey = (BCECPublicKey) converter.generatePublic(SubjectPublicKeyInfo.getInstance(decoded));- return new ECPublicKeyParameters(publicKey.getQ(), domainParameters(curveName));+ ECDomainParameters domain = curve(curveName).domain();+ byte[] point = SubjectPublicKeyInfo.getInstance(decoded).getPublicKeyData().getOctets();+ return new ECPublicKeyParameters(domain.getCurve().decodePoint(point), domain);}/**@@ -66,10 +113,8 @@ final class BcEcKeys {*/static void importPrivateKey(KmsKey key, byte[] material, String curveName) {try {- ImportedEcKey imported = parseImportedPrivateKey(material, curveName);- Base64.Encoder encoder = Base64.getEncoder();- key.setPrivateKeyEncoded(encoder.encodeToString(imported.privateKeyEncoded()));- key.setPublicKeyEncoded(encoder.encodeToString(imported.publicKeyEncoded()));+ ImportedEcKey imported = parseImportedPrivateKey(material, curve(curveName), curveName);+ store(key, imported.privateKeyEncoded(), imported.publicKeyEncoded());} catch (InvalidKeySpecException e) {throw new AwsException("IncorrectKeyMaterialException","Key material for key spec " + key.getKeySpec() + " must be a PKCS#8-encoded "@@ -77,7 +122,7 @@ final class BcEcKeys {}}- private static ImportedEcKey parseImportedPrivateKey(byte[] material, String curveName)+ private static ImportedEcKey parseImportedPrivateKey(byte[] material, NamedCurve curve, String curveName)throws InvalidKeySpecException {// BouncyCastle decodes the ECPrivateKey fields lazily, so a malformed field only fails when it// is read: read them all here, where a failure maps to IncorrectKeyMaterialException.@@ -99,25 +144,23 @@ final class BcEcKeys {if (!X9ObjectIdentifiers.id_ecPublicKey.equals(algorithm.getAlgorithm())) {throw new InvalidKeySpecException("the material is not an EC private key");}- ASN1ObjectIdentifier curveOid = ECUtil.getNamedCurveOid(curveName);- if (!curveOid.equals(algorithm.getParameters())) {+ if (!curve.oid().equals(algorithm.getParameters())) {throw new InvalidKeySpecException("the material must name the " + curveName + " curve");}- if (innerParameters != null && !curveOid.equals(innerParameters)) {+ if (innerParameters != null && !curve.oid().equals(innerParameters)) {throw new InvalidKeySpecException("the EC private key's own parameters must also name the "+ curveName + " curve");}- ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec(curveName);- if (privateScalar.signum() <= 0 || privateScalar.compareTo(spec.getN()) >= 0) {+ ECDomainParameters domain = curve.domain();+ if (privateScalar.signum() <= 0 || privateScalar.compareTo(domain.getN()) >= 0) {throw new InvalidKeySpecException("the private key is out of range for " + curveName);}- ECPoint publicPoint = spec.getG().multiply(privateScalar).normalize();- requireMatchingEmbeddedPublicKey(embeddedPublicKey, publicPoint, spec);+ ECPoint publicPoint = domain.getG().multiply(privateScalar).normalize();+ requireMatchingEmbeddedPublicKey(embeddedPublicKey, publicPoint, domain.getCurve());try {- SubjectPublicKeyInfo publicKeyInfo = new SubjectPublicKeyInfo(- new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, curveOid),+ SubjectPublicKeyInfo publicKeyInfo = new SubjectPublicKeyInfo(curve.algorithm(),publicPoint.getEncoded(false));return new ImportedEcKey(privateKeyInfo.getEncoded(ASN1Encoding.DER),publicKeyInfo.getEncoded(ASN1Encoding.DER));@@ -126,15 +169,14 @@ final class BcEcKeys {}}- private static void requireMatchingEmbeddedPublicKey(ASN1BitString embedded, ECPoint derived,- ECNamedCurveParameterSpec spec)+ private static void requireMatchingEmbeddedPublicKey(ASN1BitString embedded, ECPoint derived, ECCurve curve)throws InvalidKeySpecException {if (embedded == null) {return;}ECPoint embeddedPoint;try {- embeddedPoint = spec.getCurve().decodePoint(embedded.getOctets());+ embeddedPoint = curve.decodePoint(embedded.getOctets());} catch (RuntimeException e) {throw new InvalidKeySpecException("the embedded public key is not a point on the curve", e);}@@ -143,11 +185,60 @@ final class BcEcKeys {}}+ private static void store(KmsKey key, byte[] privateKeyEncoded, byte[] publicKeyEncoded) {+ Base64.Encoder encoder = Base64.getEncoder();+ key.setPrivateKeyEncoded(encoder.encodeToString(privateKeyEncoded));+ key.setPublicKeyEncoded(encoder.encodeToString(publicKeyEncoded));+ }++ private static NamedCurve curve(String curveName) {+ NamedCurve curve = CURVES.get(curveName);+ if (curve == null) {+ throw new IllegalArgumentException("Unsupported curve: " + curveName);+ }+ return curve;+ }++ // The GLV endomorphism BouncyCastle's CustomNamedCurves gives secp256k1. It speeds up verification.+ private static ECCurve secp256k1Curve() {+ GLVTypeBParameters glv = new GLVTypeBParameters(+ new BigInteger("7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee", 16),+ new BigInteger("5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72", 16),+ new ScalarSplitParameters(+ new BigInteger[]{+ new BigInteger("3086d221a7d46bcde86c90e49284eb15", 16),+ new BigInteger("-e4437ed6010e88286f547fa90abfe4c3", 16)},+ new BigInteger[]{+ new BigInteger("114ca50f7a8e2f3f657c1108d9d44cfd8", 16),+ new BigInteger("3086d221a7d46bcde86c90e49284eb15", 16)},+ new BigInteger("3086d221a7d46bcde86c90e49284eb153dab", 16),+ new BigInteger("e4437ed6010e88286f547fa90abfe4c42212", 16),+ 272));+ ECCurve curve = new SecP256K1Curve();+ return curve.configure().setEndomorphism(new GLVTypeBEndomorphism(curve, glv)).create();+ }+private record ImportedEcKey(byte[] privateKeyEncoded, byte[] publicKeyEncoded) {}- private static ECDomainParameters domainParameters(String curveName) {- ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec(curveName);- return new ECDomainParameters(spec.getCurve(), spec.getG(), spec.getN(), spec.getH());+ private record NamedCurve(ASN1ObjectIdentifier oid, ECDomainParameters domain) {++ NamedCurve(ASN1ObjectIdentifier oid, ECCurve curve, String generator) {+ this(oid, domain(curve, generator));+ }++ private static ECDomainParameters domain(ECCurve curve, String generator) {+ ECPoint g = curve.decodePoint(Hex.decodeStrict(generator));+ WNafUtil.configureBasepoint(g);+ return new ECDomainParameters(curve, g, curve.getOrder(), curve.getCofactor());+ }++ X962Parameters parameters() {+ return new X962Parameters(oid);+ }++ AlgorithmIdentifier algorithm() {+ return new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, parameters());+ }}}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccSecgP256k1KeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccSecgP256k1KeyType.javaindex 3da45a4c0d..2979215f10 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccSecgP256k1KeyType.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccSecgP256k1KeyType.java@@ -30,7 +30,7 @@ final class EccSecgP256k1KeyType implements KmsKeyType {@Overridepublic void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {- AsymmetricKeys.store(key, BcEcKeys.generateKeyPair(CURVE));+ BcEcKeys.generateKeyPair(key, CURVE, random);}@Overridediff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/RsaKeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/RsaKeyType.javaindex 28a081bbf5..8ce94144cc 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/RsaKeyType.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/RsaKeyType.java@@ -16,9 +16,9 @@ import org.bouncycastle.crypto.digests.SHA384Digest;import org.bouncycastle.crypto.digests.SHA512Digest;import org.bouncycastle.crypto.engines.RSABlindedEngine;import org.bouncycastle.crypto.params.ParametersWithRandom;+import org.bouncycastle.crypto.params.RSAKeyParameters;+import org.bouncycastle.crypto.params.RSAPrivateCrtKeyParameters;import org.bouncycastle.crypto.signers.PSSSigner;-import org.bouncycastle.crypto.util.PrivateKeyFactory;-import org.bouncycastle.crypto.util.PublicKeyFactory;import org.jboss.logging.Logger;import javax.crypto.Cipher;@@ -31,6 +31,7 @@ import java.security.PrivateKey;import java.security.PublicKey;import java.security.SecureRandom;import java.security.interfaces.RSAPrivateCrtKey;+import java.security.interfaces.RSAPublicKey;import java.security.spec.MGF1ParameterSpec;import java.util.Base64;@@ -61,7 +62,7 @@ final class RsaKeyType implements KmsKeyType {return AsymmetricKeys.sign(privateKey, algorithm.getJavaName(), message);}if (isPss(algorithm)) {- return signPssDigest(privateKey, message, algorithm);+ return signPssDigest((RSAPrivateCrtKey) privateKey, message, algorithm);}return AsymmetricKeys.sign(privateKey, "NONEwithRSA", wrapInDigestInfo(message, algorithm));}@@ -74,7 +75,7 @@ final class RsaKeyType implements KmsKeyType {return AsymmetricKeys.verify(publicKey, algorithm.getJavaName(), message, signature);}if (isPss(algorithm)) {- return verifyPssDigest(publicKey, message, signature, algorithm);+ return verifyPssDigest((RSAPublicKey) publicKey, message, signature, algorithm);}return AsymmetricKeys.verify(publicKey, "NONEwithRSA", wrapInDigestInfo(message, algorithm), signature);}@@ -197,18 +198,22 @@ final class RsaKeyType implements KmsKeyType {}// The JDK RSASSA-PSS Signature always hashes its input, so a DIGEST request needs BC's raw PSS signer.- private byte[] signPssDigest(PrivateKey privateKey, byte[] digest, KmsKeySpec.Algorithm algorithm)+ private byte[] signPssDigest(RSAPrivateCrtKey privateKey, byte[] digest, KmsKeySpec.Algorithm algorithm)throws Exception {+ RSAPrivateCrtKeyParameters parameters = new RSAPrivateCrtKeyParameters(privateKey.getModulus(),+ privateKey.getPublicExponent(), privateKey.getPrivateExponent(), privateKey.getPrimeP(),+ privateKey.getPrimeQ(), privateKey.getPrimeExponentP(), privateKey.getPrimeExponentQ(),+ privateKey.getCrtCoefficient());PSSSigner signer = rawPssSigner(algorithm);- signer.init(true, new ParametersWithRandom(PrivateKeyFactory.createKey(privateKey.getEncoded()), random));+ signer.init(true, new ParametersWithRandom(parameters, random));signer.update(digest, 0, digest.length);return signer.generateSignature();}- private static boolean verifyPssDigest(PublicKey publicKey, byte[] digest, byte[] signature,- KmsKeySpec.Algorithm algorithm) throws IOException {+ private static boolean verifyPssDigest(RSAPublicKey publicKey, byte[] digest, byte[] signature,+ KmsKeySpec.Algorithm algorithm) {PSSSigner signer = rawPssSigner(algorithm);- signer.init(false, PublicKeyFactory.createKey(publicKey.getEncoded()));+ signer.init(false, new RSAKeyParameters(false, publicKey.getModulus(), publicKey.getPublicExponent()));signer.update(digest, 0, digest.length);return signer.verifySignature(signature);}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Sm2KeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Sm2KeyType.javaindex 5c4c1951f1..5e9e753174 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Sm2KeyType.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Sm2KeyType.java@@ -28,7 +28,7 @@ final class Sm2KeyType implements KmsKeyType {throw new AwsException("UnsupportedOperationException","KeySpec SM2 is not supported in this Region", 400);}- AsymmetricKeys.store(key, BcEcKeys.generateKeyPair(CURVE));+ BcEcKeys.generateKeyPair(key, CURVE, random);}@Overridediff --git a/src/test/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeysTest.java b/src/test/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeysTest.javanew file mode 100644index 0000000000..88ca87abe6--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeysTest.java@@ -0,0 +1,48 @@+package io.github.hectorvent.floci.services.kms.keytype;++import io.github.hectorvent.floci.services.kms.model.KmsKey;+import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;+import org.bouncycastle.crypto.params.ECPublicKeyParameters;+import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;+import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;+import org.bouncycastle.jcajce.provider.asymmetric.ec.KeyFactorySpi;+import org.bouncycastle.jce.ECNamedCurveTable;+import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.security.SecureRandom;+import java.util.Base64;++import static org.junit.jupiter.api.Assertions.*;++class BcEcKeysTest {++ @ParameterizedTest+ @ValueSource(strings = {"secp256r1", "secp384r1", "secp521r1", "secp256k1", "sm2p256v1"})+ void generatedKeyMatchesBouncyCastleNamedCurve(String curveName) throws Exception {+ KmsKey key = new KmsKey();+ BcEcKeys.generateKeyPair(key, curveName, new SecureRandom());+ byte[] privateEncoded = Base64.getDecoder().decode(key.getPrivateKeyEncoded());+ byte[] publicEncoded = Base64.getDecoder().decode(key.getPublicKeyEncoded());++ KeyFactorySpi.EC factory = new KeyFactorySpi.EC();+ BCECPrivateKey privateKey = (BCECPrivateKey) factory.generatePrivate(PrivateKeyInfo.getInstance(privateEncoded));+ BCECPublicKey publicKey = (BCECPublicKey) factory.generatePublic(SubjectPublicKeyInfo.getInstance(publicEncoded));+ ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec(curveName);+ assertEquals(spec.getG().multiply(privateKey.getD()).normalize(), publicKey.getQ());+ assertArrayEquals(privateKey.getEncoded(), privateEncoded);+ assertArrayEquals(publicKey.getEncoded(), publicEncoded);++ ECPrivateKeyParameters privateParameters = BcEcKeys.privateKeyParameters(key, curveName);+ ECPublicKeyParameters publicParameters = BcEcKeys.publicKeyParameters(key, curveName);+ assertEquals(privateKey.getD(), privateParameters.getD());+ assertEquals(publicKey.getQ(), publicParameters.getQ());+ assertEquals(spec.getCurve(), privateParameters.getParameters().getCurve());+ assertEquals(spec.getG(), privateParameters.getParameters().getG());+ assertEquals(spec.getN(), privateParameters.getParameters().getN());+ assertEquals(spec.getH(), privateParameters.getParameters().getH());+ }+}