Light, fluffy, and always free - The AWS Local Emulator alternative
feat(kms): support ECC imported key material (#4428)
MIdhun5cb973c5616f
diff --git a/docs/services/kms.md b/docs/services/kms.mdindex 293f38c4ef..f1e61c6a8d 100644--- a/docs/services/kms.md+++ b/docs/services/kms.md@@ -124,6 +124,11 @@ following combinations:| Symmetric encryption key (`SYMMETRIC_DEFAULT`) | **Wrapping algorithms:** `RSAES_OAEP_SHA_256`, `RSAES_OAEP_SHA_1`<br>**Wrapping key specs:** `RSA_2048`, `RSA_3072`, `RSA_4096` || HMAC key (`HMAC_*`) | **Wrapping algorithms:** `RSAES_OAEP_SHA_256`, `RSAES_OAEP_SHA_1`<br>**Wrapping key specs:** `RSA_2048`, `RSA_3072`, `RSA_4096` || Asymmetric RSA private key (`RSA_*`) | **Wrapping algorithms:** `RSA_AES_KEY_WRAP_SHA_256`, `RSA_AES_KEY_WRAP_SHA_1`<br>**Wrapping key specs:** `RSA_2048`, `RSA_3072`, `RSA_4096` |+| Asymmetric elliptic curve private key (`ECC_NIST_P256`, `ECC_NIST_P384`, `ECC_NIST_P521`, `ECC_SECG_P256K1`) | **Wrapping algorithms:** `RSA_AES_KEY_WRAP_SHA_256`, `RSA_AES_KEY_WRAP_SHA_1`, `RSAES_OAEP_SHA_256`, `RSAES_OAEP_SHA_1`<br>**Wrapping key specs:** `RSA_2048`, `RSA_3072`, `RSA_4096` |++As on AWS, `ECC_NIST_P521` material cannot use an `RSAES_OAEP_*` algorithm with the `RSA_2048`+wrapping key spec: `GetParametersForImport` rejects that combination with+`UnsupportedOperationException`. Use a larger wrapping key or an `RSA_AES_KEY_WRAP_*` algorithm.The hybrid `RSA_AES_KEY_WRAP_*` algorithms require a 256-bit AES key. `RSAES_PKCS1_V1_5` isrejected, matching AWS, which stopped supporting it on October 10, 2023.@@ -157,8 +162,12 @@ own the material and cannot rotate it.**Deviations:**-- `Origin=EXTERNAL` supports `SYMMETRIC_DEFAULT`, the `HMAC_*` key specs and the `RSA_*` key specs.-- Other asymmetric key specs are rejected at `CreateKey` with `UnsupportedOperationException`.+- `Origin=EXTERNAL` supports `SYMMETRIC_DEFAULT`, the `HMAC_*` key specs, the `RSA_*` key specs, and+ `ECC_NIST_P256`, `ECC_NIST_P384`, `ECC_NIST_P521` and `ECC_SECG_P256K1`. Imported elliptic curve+ material is a PKCS#8 private key on the key spec's named curve; as on AWS, the public key is+ derived from it, and an embedded public key must match.+- Other asymmetric key specs, including `ECC_NIST_EDWARDS25519`, which AWS can import, are rejected at+ `CreateKey` with `UnsupportedOperationException`.- Holding several imported key materials on one symmetric key, which real KMS uses for on-demandrotation of imported material, is not emulated. `ImportType=NEW_KEY_MATERIAL` on a key thatalready has key material is rejected with `UnsupportedOperationException`, anddiff --git a/src/main/java/io/github/hectorvent/floci/services/kms/KmsKeyImport.java b/src/main/java/io/github/hectorvent/floci/services/kms/KmsKeyImport.javaindex 76c902bea4..ecd763a954 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/KmsKeyImport.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/KmsKeyImport.java@@ -73,7 +73,7 @@ final class KmsKeyImport {* <p>RSAES_PKCS1_V1_5 stays in the modelled enum but AWS KMS stopped honouring it on* October 10, 2023.*/- static void validateWrappingAlgorithm(KmsKeySpec keySpec, String wrappingAlgorithm) {+ static void validateWrappingAlgorithm(KmsKeySpec keySpec, String wrappingAlgorithm, String wrappingKeySpec) {String algorithm = wrappingAlgorithm == null ? "" : wrappingAlgorithm;validateWrappingAlgorithmValue(algorithm, wrappingAlgorithm);@@ -92,6 +92,18 @@ final class KmsKeyImport {+ "Supported values are: RSA_AES_KEY_WRAP_SHA_1 and RSA_AES_KEY_WRAP_SHA_256.", 400);}}+ case ECC -> {+ // AWS accepts both RSAES_OAEP_* and RSA_AES_KEY_WRAP_* for ECC material, which is+ // everything validateWrappingAlgorithmValue lets through, except RSAES_OAEP_* under an+ // RSA_2048 wrapping key for ECC_NIST_P521, whose material is too long for that payload.+ boolean rsaesOaep = RSAES_OAEP_SHA_1.equals(algorithm) || RSAES_OAEP_SHA_256.equals(algorithm);+ if (keySpec == KmsKeySpec.ECC_NIST_P521 && rsaesOaep && "RSA_2048".equals(wrappingKeySpec)) {+ throw new AwsException("UnsupportedOperationException",+ "WrappingAlgorithm " + wrappingAlgorithm + " with WrappingKeySpec RSA_2048 is not "+ + "supported for " + keySpec + " key. Use a larger wrapping key spec or "+ + "RSA_AES_KEY_WRAP_SHA_1 or RSA_AES_KEY_WRAP_SHA_256.", 400);+ }+ }default -> throw new AwsException("UnsupportedOperationException","Importing key material for key spec " + keySpec + " is not supported.", 400);}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 233b1922fa..8103a170e4 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@@ -870,7 +870,7 @@ public class KmsService implements ResourceProvider {KmsKey key = resolveKey(keyId, region);requireExternalOrigin(key);requireNotPendingDeletion(key);- KmsKeyImport.validateWrappingAlgorithm(key.getKeySpec(), wrappingAlgorithm);+ KmsKeyImport.validateWrappingAlgorithm(key.getKeySpec(), wrappingAlgorithm, wrappingKeySpec);KmsKeyImport.WrappingKeyPair wrappingKeyPair = KmsKeyImport.generateWrappingKeyPair(wrappingKeySpec);KmsImportParameters parameters = new KmsImportParameters();@@ -1125,15 +1125,16 @@ public class KmsService implements ResourceProvider {}/**- * Allows imports for symmetric, HMAC and RSA key specs. Other key specs are not supported.+ * Allows imports for symmetric, HMAC, RSA and ECC key specs. Other key specs are not supported.*/private static String requireImportableSpec(KmsKeySpec spec) {if (spec != KmsKeySpec.SYMMETRIC_DEFAULT&& spec.getKeyType() != KmsKeySpec.KeyType.HMAC- && spec.getKeyType() != KmsKeySpec.KeyType.RSA) {+ && spec.getKeyType() != KmsKeySpec.KeyType.RSA+ && spec.getKeyType() != KmsKeySpec.KeyType.ECC) {throw new AwsException("UnsupportedOperationException",- "Origin EXTERNAL is only supported for SYMMETRIC_DEFAULT, HMAC and RSA key specs, not "+ "Origin EXTERNAL is only supported for SYMMETRIC_DEFAULT, HMAC, RSA and ECC key specs, not "+ spec + ".", 400);}return EXTERNAL_ORIGIN;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 921ce56ca1..22db979da8 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@@ -1,8 +1,16 @@package io.github.hectorvent.floci.services.kms.keytype;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.kms.model.KmsKey;+import org.bouncycastle.asn1.ASN1BitString;+import org.bouncycastle.asn1.ASN1Encoding;+import org.bouncycastle.asn1.ASN1Object;+import org.bouncycastle.asn1.ASN1ObjectIdentifier;import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;+import org.bouncycastle.asn1.sec.ECPrivateKey;+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;+import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;import org.bouncycastle.crypto.params.ECDomainParameters;import org.bouncycastle.crypto.params.ECPrivateKeyParameters;import org.bouncycastle.crypto.params.ECPublicKeyParameters;@@ -10,15 +18,19 @@ 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.ECPoint;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.spec.InvalidKeySpecException;import java.util.Base64;// The BouncyCastle SPI classes are allocated directly. JCA lookup cannot find them in the native image.@@ -47,6 +59,93 @@ final class BcEcKeys {return new ECPublicKeyParameters(publicKey.getQ(), domainParameters(curveName));}+ /**+ * Stores imported ECC key material: a PKCS#8 private key (RFC 5208) holding an RFC 5915+ * ECPrivateKey on the key spec's named curve. As on AWS, only the private key is taken from+ * the material and the public key is derived from it; an embedded public key must match.+ */+ 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()));+ } catch (InvalidKeySpecException e) {+ throw new AwsException("IncorrectKeyMaterialException",+ "Key material for key spec " + key.getKeySpec() + " must be a PKCS#8-encoded "+ + curveName + " private key: " + e.getMessage(), 400);+ }+ }++ private static ImportedEcKey parseImportedPrivateKey(byte[] material, 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.+ PrivateKeyInfo privateKeyInfo;+ BigInteger privateScalar;+ ASN1Object innerParameters;+ ASN1BitString embeddedPublicKey;+ try {+ privateKeyInfo = PrivateKeyInfo.getInstance(material);+ ECPrivateKey ecPrivateKey = ECPrivateKey.getInstance(privateKeyInfo.parsePrivateKey());+ privateScalar = ecPrivateKey.getKey();+ innerParameters = ecPrivateKey.getParametersObject();+ embeddedPublicKey = ecPrivateKey.getPublicKey();+ } catch (IOException | RuntimeException e) {+ throw new InvalidKeySpecException("the material is not a PKCS#8 EC private key", e);+ }++ AlgorithmIdentifier algorithm = privateKeyInfo.getPrivateKeyAlgorithm();+ 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())) {+ throw new InvalidKeySpecException("the material must name the " + curveName + " curve");+ }+ if (innerParameters != null && !curveOid.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) {+ throw new InvalidKeySpecException("the private key is out of range for " + curveName);+ }+ ECPoint publicPoint = spec.getG().multiply(privateScalar).normalize();+ requireMatchingEmbeddedPublicKey(embeddedPublicKey, publicPoint, spec);++ try {+ SubjectPublicKeyInfo publicKeyInfo = new SubjectPublicKeyInfo(+ new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, curveOid),+ publicPoint.getEncoded(false));+ return new ImportedEcKey(privateKeyInfo.getEncoded(ASN1Encoding.DER),+ publicKeyInfo.getEncoded(ASN1Encoding.DER));+ } catch (IOException e) {+ throw new InvalidKeySpecException("the key could not be re-encoded", e);+ }+ }++ private static void requireMatchingEmbeddedPublicKey(ASN1BitString embedded, ECPoint derived,+ ECNamedCurveParameterSpec spec)+ throws InvalidKeySpecException {+ if (embedded == null) {+ return;+ }+ ECPoint embeddedPoint;+ try {+ embeddedPoint = spec.getCurve().decodePoint(embedded.getOctets());+ } catch (RuntimeException e) {+ throw new InvalidKeySpecException("the embedded public key is not a point on the curve", e);+ }+ if (!embeddedPoint.equals(derived)) {+ throw new InvalidKeySpecException("the embedded public key does not match the private key");+ }+ }++ 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());diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccNistKeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccNistKeyType.javaindex 6fe9907ac2..41593650d4 100644--- a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccNistKeyType.java+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccNistKeyType.java@@ -19,6 +19,11 @@ final class EccNistKeyType implements KmsKeyType {AsymmetricKeys.store(key, generator.generateKeyPair());}+ @Override+ public void importKeyMaterial(KmsKey key, byte[] material) {+ BcEcKeys.importPrivateKey(key, material, key.getKeySpec().curveName());+ }+@Overridepublic byte[] sign(KmsKey key, byte[] message, KmsKeySpec.Algorithm algorithm, KmsMessageType messageType)throws GeneralSecurityException {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 d42fbaa1c8..3da45a4c0d 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@@ -33,6 +33,11 @@ final class EccSecgP256k1KeyType implements KmsKeyType {AsymmetricKeys.store(key, BcEcKeys.generateKeyPair(CURVE));}+ @Override+ public void importKeyMaterial(KmsKey key, byte[] material) {+ BcEcKeys.importPrivateKey(key, material, CURVE);+ }+@Overridepublic byte[] sign(KmsKey key, byte[] message, KmsKeySpec.Algorithm algorithm, KmsMessageType messageType)throws GeneralSecurityException, IOException {diff --git a/src/test/java/io/github/hectorvent/floci/services/kms/KmsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/kms/KmsIntegrationTest.javaindex d2bceab5ef..4de16dfb73 100644--- a/src/test/java/io/github/hectorvent/floci/services/kms/KmsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/kms/KmsIntegrationTest.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.kms;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.json.JsonPath;import io.restassured.response.Response;import jakarta.inject.Inject;import org.junit.jupiter.api.BeforeAll;@@ -18,6 +19,7 @@ import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.PublicKey;+import java.security.spec.ECGenParameterSpec;import java.security.spec.MGF1ParameterSpec;import java.security.spec.X509EncodedKeySpec;import java.util.Arrays;@@ -3124,6 +3126,62 @@ class KmsIntegrationTest {.body("KeyMetadata.Enabled", equalTo(true));}+ @Test+ void eccImportRoundTripDerivesThePublicKey() throws Exception {+ KeyPairGenerator generator = KeyPairGenerator.getInstance("EC");+ generator.initialize(new ECGenParameterSpec("secp256r1"));+ KeyPair importedKeyPair = generator.generateKeyPair();++ String keyId = given()+ .header("X-Amz-Target", "TrentService.CreateKey")+ .contentType(KMS_CONTENT_TYPE)+ .body("{\"Origin\":\"EXTERNAL\",\"KeyUsage\":\"SIGN_VERIFY\",\"KeySpec\":\"ECC_NIST_P256\"}")+ .when().post("/")+ .then()+ .statusCode(200)+ .body("KeyMetadata.KeyState", equalTo("PendingImport"))+ .extract().path("KeyMetadata.KeyId");++ JsonPath parameters = given()+ .header("X-Amz-Target", "TrentService.GetParametersForImport")+ .contentType(KMS_CONTENT_TYPE)+ .body(("{\"KeyId\":\"%s\",\"WrappingAlgorithm\":\"RSA_AES_KEY_WRAP_SHA_256\","+ + "\"WrappingKeySpec\":\"RSA_2048\"}").formatted(keyId))+ .when().post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath();++ String wrapped = Base64.getEncoder().encodeToString(wrapWithRsaAesSha256(+ parameters.getString("PublicKey"), importedKeyPair.getPrivate().getEncoded()));+ given()+ .header("X-Amz-Target", "TrentService.ImportKeyMaterial")+ .contentType(KMS_CONTENT_TYPE)+ .body(("{\"KeyId\":\"%s\",\"ImportToken\":\"%s\",\"EncryptedKeyMaterial\":\"%s\","+ + "\"ExpirationModel\":\"KEY_MATERIAL_DOES_NOT_EXPIRE\"}")+ .formatted(keyId, parameters.getString("ImportToken"), wrapped))+ .when().post("/")+ .then()+ .statusCode(200)+ .body("KeyMaterialId", matchesPattern("[a-f0-9]{64}"));++ String publicKey = given()+ .header("X-Amz-Target", "TrentService.GetPublicKey")+ .contentType(KMS_CONTENT_TYPE)+ .body("{\"KeyId\":\"%s\"}".formatted(keyId))+ .when().post("/")+ .then()+ .statusCode(200)+ .body("KeySpec", equalTo("ECC_NIST_P256"))+ .body("KeyUsage", equalTo("SIGN_VERIFY"))+ .extract().path("PublicKey");++ assertEquals(Base64.getEncoder().encodeToString(importedKeyPair.getPublic().getEncoded()), publicKey);+ describeKey(keyId)+ .body("KeyMetadata.KeyState", equalTo("Enabled"))+ .body("KeyMetadata.Enabled", equalTo(true));+ }+@Testvoid aDeprecatedWrappingAlgorithmIsRejected() {String keyId = createExternalSymmetricKey();diff --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 5f50f9cc83..ce83f88392 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@@ -14,6 +14,21 @@ import io.github.hectorvent.floci.services.kms.model.KmsKeySpec;import io.github.hectorvent.floci.services.kms.model.KmsKeyUsage;import io.github.hectorvent.floci.services.kms.model.KmsMessageType;import jakarta.ws.rs.core.Response;+import org.bouncycastle.asn1.ASN1Encodable;+import org.bouncycastle.asn1.ASN1EncodableVector;+import org.bouncycastle.asn1.ASN1Integer;+import org.bouncycastle.asn1.DERBitString;+import org.bouncycastle.asn1.DEROctetString;+import org.bouncycastle.asn1.DERSequence;+import org.bouncycastle.asn1.DERTaggedObject;+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.ECNamedCurveTable;+import org.bouncycastle.asn1.x9.X962Parameters;+import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.BeforeEach;@@ -26,6 +41,7 @@ import javax.crypto.spec.GCMParameterSpec;import javax.crypto.spec.OAEPParameterSpec;import javax.crypto.spec.PSource;import javax.crypto.spec.SecretKeySpec;+import java.math.BigInteger;import java.nio.charset.StandardCharsets;import java.security.KeyFactory;import java.security.KeyPair;@@ -34,6 +50,7 @@ import java.security.MessageDigest;import java.security.PublicKey;import java.security.Security;import java.security.Signature;+import java.security.spec.ECGenParameterSpec;import java.security.spec.MGF1ParameterSpec;import java.security.spec.PSSParameterSpec;import java.security.spec.X509EncodedKeySpec;@@ -2464,6 +2481,47 @@ class KmsServiceTest {return generator.generateKeyPair();}+ private KeyPair ecKeyPair(String keySpec) throws Exception {+ KeyPairGenerator generator = KeyPairGenerator.getInstance("EC", BouncyCastleProvider.PROVIDER_NAME);+ generator.initialize(new ECGenParameterSpec(KmsKeySpec.valueOf(keySpec).curveName()));+ return generator.generateKeyPair();+ }++ private byte[] ecPublicPoint(KeyPair keyPair) {+ return SubjectPublicKeyInfo.getInstance(keyPair.getPublic().getEncoded()).getPublicKeyData().getBytes();+ }++ /** Re-encodes an EC private key with the given algorithm identifier and embedded public point. */+ private byte[] ecPkcs8(KeyPair keyPair, String curveName, AlgorithmIdentifier algorithm,+ byte[] embeddedPublicPoint) throws Exception {+ return ecPkcs8(keyPair, curveName, algorithm, embeddedPublicPoint, null);+ }++ /** As above, also setting the RFC 5915 ECPrivateKey's own optional curve parameters. */+ private byte[] ecPkcs8(KeyPair keyPair, String curveName, AlgorithmIdentifier algorithm,+ byte[] embeddedPublicPoint, ASN1Encodable innerParameters) throws Exception {+ BigInteger privateScalar = ECPrivateKey.getInstance(+ PrivateKeyInfo.getInstance(keyPair.getPrivate().getEncoded()).parsePrivateKey()).getKey();+ int orderBits = ECNamedCurveTable.getByName(curveName).getN().bitLength();+ ECPrivateKey ecPrivateKey = new ECPrivateKey(orderBits, privateScalar,+ new DERBitString(embeddedPublicPoint), innerParameters);+ return new PrivateKeyInfo(algorithm, ecPrivateKey).getEncoded();+ }++ /** A P-256 PKCS#8 key whose RFC 5915 fields after the version are given as-is, malformed or not. */+ private byte[] ecPkcs8WithRawFields(ASN1Encodable... fieldsAfterVersion) throws Exception {+ ASN1EncodableVector fields = new ASN1EncodableVector();+ fields.add(new ASN1Integer(1));+ for (ASN1Encodable field : fieldsAfterVersion) {+ fields.add(field);+ }+ return new PrivateKeyInfo(p256NamedCurve(), new DERSequence(fields)).getEncoded();+ }++ private AlgorithmIdentifier p256NamedCurve() {+ return new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, X9ObjectIdentifiers.prime256v1);+ }+private KmsKey importInto(KmsKey key, byte[] rawMaterial, String wrappingAlgorithm) throws Exception {return importInto(key, rawMaterial, wrappingAlgorithm, "RSA_2048");}@@ -2943,10 +3001,315 @@ class KmsServiceTest {assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());}+ @ParameterizedTest+ @CsvSource({+ "ECC_NIST_P256, RSA_AES_KEY_WRAP_SHA_256, RSA_2048",+ "ECC_NIST_P384, RSA_AES_KEY_WRAP_SHA_1, RSA_3072",+ "ECC_NIST_P521, RSA_AES_KEY_WRAP_SHA_256, RSA_4096",+ "ECC_SECG_P256K1, RSA_AES_KEY_WRAP_SHA_256, RSA_2048",+ "ECC_NIST_P256, RSAES_OAEP_SHA_256, RSA_2048",+ "ECC_NIST_P521, RSAES_OAEP_SHA_1, RSA_4096",+ "ECC_NIST_P521, RSAES_OAEP_SHA_256, RSA_3072",+ "ECC_NIST_P521, RSA_AES_KEY_WRAP_SHA_256, RSA_2048",+ "ECC_SECG_P256K1, RSAES_OAEP_SHA_256, RSA_3072"+ })+ void supportedEccKeyAndWrappingSpecsImportUsablePrivateKeyMaterial(+ String keySpec, String wrappingAlgorithm, String wrappingKeySpec) throws Exception {+ KmsKey key = externalKey(keySpec, "SIGN_VERIFY");+ KeyPair importedKeyPair = ecKeyPair(keySpec);++ KmsKey imported = importInto(key, importedKeyPair.getPrivate().getEncoded(),+ wrappingAlgorithm, wrappingKeySpec);++ assertEquals("Enabled", imported.getKeyState());+ assertTrue(imported.isEnabled());+ assertArrayEquals(importedKeyPair.getPublic().getEncoded(),+ Base64.getDecoder().decode(imported.getPublicKeyEncoded()));++ KmsKeySpec.Algorithm algorithm = KmsKeySpec.valueOf(keySpec).getAlgorithm().getFirst();+ byte[] message = "imported ECC key".getBytes(StandardCharsets.UTF_8);+ byte[] signature = kmsService.sign(key.getKeyId(), message, algorithm.name(), REGION);+ Signature verifier = Signature.getInstance(algorithm.getJavaName(), BouncyCastleProvider.PROVIDER_NAME);+ verifier.initVerify(importedKeyPair.getPublic());+ verifier.update(message);+ assertTrue(verifier.verify(signature));+ }++ @Test+ void eccImportAcceptsACompressedEmbeddedPublicKey() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ KeyPair keyPair = ecKeyPair("ECC_NIST_P256");+ byte[] compressedPoint = ECNamedCurveTable.getByName("secp256r1").getCurve()+ .decodePoint(ecPublicPoint(keyPair)).getEncoded(true);++ KmsKey imported = importInto(key, ecPkcs8(keyPair, "secp256r1", p256NamedCurve(), compressedPoint),+ RSA_AES_SHA_256);++ assertEquals("Enabled", imported.getKeyState());+ assertArrayEquals(keyPair.getPublic().getEncoded(),+ Base64.getDecoder().decode(imported.getPublicKeyEncoded()));+ }++ @Test+ void eccImportRejectsKeyMaterialOnAnotherCurve() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ byte[] p384Material = ecKeyPair("ECC_NIST_P384").getPrivate().getEncoded();++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, p384Material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsExplicitCurveParameters() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ KeyPair keyPair = ecKeyPair("ECC_NIST_P256");+ AlgorithmIdentifier explicitCurve = new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey,+ new X962Parameters(ECNamedCurveTable.getByName("secp256r1")));+ byte[] material = ecPkcs8(keyPair, "secp256r1", explicitCurve, ecPublicPoint(keyPair));++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportAcceptsInnerParametersNamingTheSameCurve() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ KeyPair keyPair = ecKeyPair("ECC_NIST_P256");+ byte[] material = ecPkcs8(keyPair, "secp256r1", p256NamedCurve(), ecPublicPoint(keyPair),+ X9ObjectIdentifiers.prime256v1);++ KmsKey imported = importInto(key, material, RSA_AES_SHA_256);++ assertEquals("Enabled", imported.getKeyState());+ }++ @Test+ void eccImportRejectsInnerParametersNamingAnotherCurve() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ KeyPair keyPair = ecKeyPair("ECC_NIST_P256");+ byte[] material = ecPkcs8(keyPair, "secp256r1", p256NamedCurve(), ecPublicPoint(keyPair),+ SECObjectIdentifiers.secp384r1);++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsExplicitInnerCurveParameters() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ KeyPair keyPair = ecKeyPair("ECC_NIST_P256");+ byte[] material = ecPkcs8(keyPair, "secp256r1", p256NamedCurve(), ecPublicPoint(keyPair),+ new X962Parameters(ECNamedCurveTable.getByName("secp256r1")));++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsAMalformedPrivateKeyField() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ byte[] material = ecPkcs8WithRawFields(new ASN1Integer(7));++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsMalformedInnerParameters() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ byte[] material = ecPkcs8WithRawFields(new DEROctetString(new byte[] {1}),+ new DERTaggedObject(false, 0, new DERSequence(new ASN1Integer(3))));++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsAMalformedEmbeddedPublicKeyField() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ byte[] material = ecPkcs8WithRawFields(new DEROctetString(new byte[] {1}),+ new DERTaggedObject(true, 1, new ASN1Integer(5)));++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsAnEmbeddedPublicKeyThatDoesNotMatch() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ KeyPair keyPair = ecKeyPair("ECC_NIST_P256");+ byte[] otherPublicPoint = ecPublicPoint(ecKeyPair("ECC_NIST_P256"));+ byte[] material = ecPkcs8(keyPair, "secp256r1", p256NamedCurve(), otherPublicPoint);++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsAnRsaPrivateKey() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ byte[] rsaMaterial = rsaKeyPair("RSA_2048").getPrivate().getEncoded();++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, rsaMaterial, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void eccImportRejectsInvalidPkcs8Material() {+ KmsKey key = externalKey("ECC_SECG_P256K1", "SIGN_VERIFY");++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, material(32, (byte) 7), RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @ParameterizedTest+ @ValueSource(strings = {"ECC_NIST_P256", "ECC_NIST_P384", "ECC_NIST_P521", "ECC_SECG_P256K1"})+ void importedEccKeyVerifiesSignaturesAndSignsDigests(String keySpec) throws Exception {+ KmsKey key = externalKey(keySpec, "SIGN_VERIFY");+ KeyPair importedKeyPair = ecKeyPair(keySpec);+ importInto(key, importedKeyPair.getPrivate().getEncoded(), RSA_AES_SHA_256, "RSA_4096");+ KmsKeySpec.Algorithm algorithm = KmsKeySpec.valueOf(keySpec).getAlgorithm().getFirst();+ byte[] message = "imported ECC key".getBytes(StandardCharsets.UTF_8);++ Signature signer = Signature.getInstance(algorithm.getJavaName(), BouncyCastleProvider.PROVIDER_NAME);+ signer.initSign(importedKeyPair.getPrivate());+ signer.update(message);+ byte[] externalSignature = signer.sign();+ assertDoesNotThrow(() -> kmsService.verify(key.getKeyId(), message, externalSignature,+ algorithm.name(), REGION));+ byte[] tampered = "tampered message".getBytes(StandardCharsets.UTF_8);+ AwsException ex = assertThrows(AwsException.class, () -> kmsService.verify(key.getKeyId(), tampered,+ externalSignature, algorithm.name(), REGION));+ assertEquals("KMSInvalidSignatureException", ex.getErrorCode());++ byte[] digest = MessageDigest.getInstance(algorithm.getJavaName().substring(0, 6)).digest(message);+ byte[] digestSignature = kmsService.sign(key.getKeyId(), digest, algorithm.name(),+ KmsMessageType.DIGEST, REGION);+ Signature verifier = Signature.getInstance(algorithm.getJavaName(), BouncyCastleProvider.PROVIDER_NAME);+ verifier.initVerify(importedKeyPair.getPublic());+ verifier.update(message);+ assertTrue(verifier.verify(digestSignature));+ }++ @Test+ void reimportingTheSameEccKeyAfterDeletionRestoresIt() throws Exception {+ KmsKey key = externalKey("ECC_SECG_P256K1", "SIGN_VERIFY");+ KeyPair keyPair = ecKeyPair("ECC_SECG_P256K1");+ byte[] material = keyPair.getPrivate().getEncoded();+ importInto(key, material, RSA_AES_SHA_256);++ KmsKey deleted = kmsService.deleteImportedKeyMaterial(key.getKeyId(), REGION);+ assertEquals("PendingImport", deleted.getKeyState());+ assertNull(deleted.getPrivateKeyEncoded());++ KmsKey reimported = importInto(key, material, RSA_AES_SHA_256);+ assertEquals("Enabled", reimported.getKeyState());+ assertArrayEquals(keyPair.getPublic().getEncoded(),+ Base64.getDecoder().decode(reimported.getPublicKeyEncoded()));+ }++ @Test+ void reimportingADifferentEccKeyIsRejected() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P384", "SIGN_VERIFY");+ importInto(key, ecKeyPair("ECC_NIST_P384").getPrivate().getEncoded(), RSA_AES_SHA_256);+ kmsService.deleteImportedKeyMaterial(key.getKeyId(), REGION);+ byte[] otherKey = ecKeyPair("ECC_NIST_P384").getPrivate().getEncoded();++ AwsException ex = assertThrows(AwsException.class, () ->+ importInto(key, otherKey, RSA_AES_SHA_256));++ assertEquals("IncorrectKeyMaterialException", ex.getErrorCode());+ assertEquals("PendingImport", kmsService.describeKey(key.getKeyId(), REGION).getKeyState());+ }++ @Test+ void expiringEccMaterialReturnsTheKeyToPendingImport() throws Exception {+ KmsKey key = externalKey("ECC_NIST_P256", "SIGN_VERIFY");+ KmsService.ImportParameters parameters =+ kmsService.getParametersForImport(key.getKeyId(), RSA_AES_SHA_256, "RSA_2048", REGION);+ byte[] wrapped = wrapRsaAes(parameters.publicKeyEncoded(), RSA_AES_SHA_256,+ ecKeyPair("ECC_NIST_P256").getPrivate().getEncoded(), material(32, (byte) 91));+ kmsService.importKeyMaterial(key.getKeyId(), parameters.importToken(), wrapped,+ "KEY_MATERIAL_EXPIRES", Instant.now().getEpochSecond() + 3600, null, REGION);++ KmsKey stored = keyStore.get(REGION + "::" + key.getKeyId()).orElseThrow();+ stored.setValidTo(Instant.now().getEpochSecond() - 60);+ keyStore.put(REGION + "::" + key.getKeyId(), stored);++ KmsKey expired = kmsService.describeKey(key.getKeyId(), REGION);+ assertEquals("PendingImport", expired.getKeyState());+ assertFalse(expired.isEnabled());+ assertNull(expired.getPrivateKeyEncoded());+ }+@Test- void nonRsaAsymmetricKeySpecsCannotUseExternalOrigin() {+ void aReplicaOfAnImportedEccKeyAcceptsTheSameKey() throws Exception {+ String replicaRegion = "us-west-2";+ KmsKey primary = kmsService.createKey("external primary", "SIGN_VERIFY", "ECC_NIST_P256",+ null, Map.of(), "EXTERNAL", true, REGION);+ KeyPair keyPair = ecKeyPair("ECC_NIST_P256");+ importInto(primary, keyPair.getPrivate().getEncoded(), RSA_AES_SHA_256);+ KmsKey replica = kmsService.replicateKey(primary.getKeyId(), null, null, Map.of(), replicaRegion, REGION);+ assertEquals("PendingImport", replica.getKeyState());++ KmsService.ImportParameters parameters = kmsService.getParametersForImport(+ replica.getKeyId(), RSA_AES_SHA_256, "RSA_2048", replicaRegion);+ byte[] wrapped = wrapRsaAes(parameters.publicKeyEncoded(), RSA_AES_SHA_256,+ keyPair.getPrivate().getEncoded(), material(32, (byte) 91));+ KmsKey imported = kmsService.importKeyMaterial(replica.getKeyId(), parameters.importToken(), wrapped,+ "KEY_MATERIAL_DOES_NOT_EXPIRE", null, null, replicaRegion);++ assertEquals("Enabled", imported.getKeyState());+ assertArrayEquals(keyPair.getPublic().getEncoded(),+ Base64.getDecoder().decode(imported.getPublicKeyEncoded()));+ }++ @ParameterizedTest+ @ValueSource(strings = {"RSAES_OAEP_SHA_1", "RSAES_OAEP_SHA_256"})+ void p521MaterialRejectsRsaesOaepUnderAnRsa2048WrappingKey(String wrappingAlgorithm) {+ String keyId = externalKey("ECC_NIST_P521", "SIGN_VERIFY").getKeyId();++ AwsException ex = assertThrows(AwsException.class, () ->+ kmsService.getParametersForImport(keyId, wrappingAlgorithm, "RSA_2048", REGION));++ assertEquals("UnsupportedOperationException", ex.getErrorCode());+ }++ @ParameterizedTest+ @ValueSource(strings = {"ECC_NIST_EDWARDS25519", "ML_DSA_44"})+ void asymmetricKeySpecsWithoutImportSupportCannotUseExternalOrigin(String keySpec) {AwsException ex = assertThrows(AwsException.class, () ->- externalKey("ECC_NIST_P256", "SIGN_VERIFY"));+ externalKey(keySpec, "SIGN_VERIFY"));assertEquals("UnsupportedOperationException", ex.getErrorCode());}