Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
new file mode 100644
index 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.java
index 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.java
index 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 {
@Override
public void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {
- AsymmetricKeys.store(key, BcEcKeys.generateKeyPair(CURVE));
+ BcEcKeys.generateKeyPair(key, CURVE, random);
}
@Override
diff --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.java
index 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.java
index 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);
}
@Override
diff --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.java
new file mode 100644
index 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());
+ }
+}