Light, fluffy, and always free - The AWS Local Emulator alternative
refactor(kms): split KmsService by key type (#3882)
TATSUNO “Taz” Yasuhiroec4943380b72
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 741a496226..0b640dc3a9 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@@ -10,6 +10,7 @@ import io.github.hectorvent.floci.core.resource.ResourceProvider;import io.github.hectorvent.floci.core.resource.SupportedResourceType;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.kms.keytype.KmsKeyTypes;import io.github.hectorvent.floci.services.kms.model.KmsAlias;import io.github.hectorvent.floci.services.kms.model.KmsGrant;import io.github.hectorvent.floci.services.kms.model.KmsImportParameters;@@ -19,67 +20,19 @@ import io.github.hectorvent.floci.services.kms.model.KmsKeyUsage;import io.github.hectorvent.floci.services.kms.model.KmsMessageType;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;-import org.bouncycastle.asn1.ASN1Integer;-import org.bouncycastle.asn1.ASN1ObjectIdentifier;-import org.bouncycastle.asn1.ASN1Primitive;-import org.bouncycastle.asn1.ASN1Sequence;-import org.bouncycastle.asn1.DERNull;-import org.bouncycastle.asn1.DERSequenceGenerator;-import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;-import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;-import org.bouncycastle.asn1.x509.AlgorithmIdentifier;-import org.bouncycastle.asn1.x509.DigestInfo;-import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;-import org.bouncycastle.crypto.Digest;-import org.bouncycastle.crypto.digests.SHA256Digest;-import org.bouncycastle.crypto.digests.SHA384Digest;-import org.bouncycastle.crypto.digests.SHA512Digest;-import org.bouncycastle.crypto.engines.RSABlindedEngine;-import org.bouncycastle.crypto.params.ECDomainParameters;-import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;-import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;-import org.bouncycastle.crypto.params.ECPrivateKeyParameters;-import org.bouncycastle.crypto.params.ECPublicKeyParameters;-import org.bouncycastle.crypto.params.ParametersWithRandom;-import org.bouncycastle.crypto.signers.ECDSASigner;-import org.bouncycastle.crypto.signers.Ed25519phSigner;-import org.bouncycastle.crypto.signers.PSSSigner;-import org.bouncycastle.crypto.signers.SM2Signer;-import org.bouncycastle.crypto.util.PrivateKeyFactory;-import org.bouncycastle.crypto.util.PublicKeyFactory;-import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;-import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;-import org.bouncycastle.jcajce.provider.asymmetric.ec.KeyFactorySpi;-import org.bouncycastle.jcajce.provider.asymmetric.ec.KeyPairGeneratorSpi;-import org.bouncycastle.jcajce.provider.util.AsymmetricKeyInfoConverter;-import org.bouncycastle.jce.ECNamedCurveTable;-import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;import org.jboss.logging.Logger;import javax.crypto.Cipher;-import javax.crypto.Mac;import javax.crypto.spec.GCMParameterSpec;-import javax.crypto.spec.OAEPParameterSpec;-import javax.crypto.spec.PSource;import javax.crypto.spec.SecretKeySpec;-import java.io.ByteArrayOutputStream;-import java.io.IOException;-import java.math.BigInteger;import java.nio.ByteBuffer;import java.nio.charset.StandardCharsets;import java.security.*;-import java.security.interfaces.EdECPrivateKey;-import java.security.spec.ECGenParameterSpec;-import java.security.spec.MGF1ParameterSpec;-import java.security.spec.PKCS8EncodedKeySpec;-import java.security.spec.PSSParameterSpec;-import java.security.spec.X509EncodedKeySpec;import java.time.Duration;import java.time.Instant;import java.util.*;import java.util.concurrent.ThreadLocalRandom;-import static io.github.hectorvent.floci.services.kms.model.KmsMessageType.DIGEST;import static io.github.hectorvent.floci.services.kms.model.KmsMessageType.RAW;@ApplicationScoped@@ -102,6 +55,7 @@ public class KmsService implements ResourceProvider {private final StorageBackend<String, KmsGrant> grantStore;private final RegionResolver regionResolver;private final SecureRandom secureRandom;+ private final KmsKeyTypes keyTypes;// Guards the check-generate-put sequence in ensureBackingKeyMaterial so two concurrent// first uses of the same legacy key cannot each mint a different backing key.private final Object backingKeyMaterialLock = new Object();@@ -134,6 +88,7 @@ public class KmsService implements ResourceProvider {this.grantStore = grantStore;this.regionResolver = regionResolver;this.secureRandom = secureRandom;+ this.keyTypes = new KmsKeyTypes(secureRandom);}public byte[] generateRandom(int numberOfBytes) {@@ -222,86 +177,13 @@ public class KmsService implements ResourceProvider {}private void generateKeyMaterial(KmsKey key, String region) {- KmsKeySpec spec = key.getKeySpec();try {- switch (spec.getKeyType()) {- case HMAC -> {- // HMAC keys are symmetric byte strings; generate outside the try block- // so ValidationException (400) isn't rewrapped as InternalFailure (500).- byte[] material = new byte[hmacKeyByteLength(spec)];- new SecureRandom().nextBytes(material);- key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(material));- }- case SYMMETRIC -> generateBackingKey(key);- case RSA -> {- KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");- int size = Integer.parseInt(spec.name().substring(4));- generator.initialize(size);- KeyPair pair = generator.generateKeyPair();- key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));- key.setPublicKeyEncoded(Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));- }- case ED25519 -> {- var pair = KeyPairGenerator.getInstance("Ed25519").generateKeyPair();- key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));- key.setPublicKeyEncoded(Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));- }- case ML_DSA -> {- String algorithm = spec.name().replace('_', '-');- var pair = KeyPairGenerator.getInstance(algorithm).generateKeyPair();- key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));- key.setPublicKeyEncoded(Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));- }- case ECC -> {- String curveName = spec.curveName();-- // For secp256k1 (ECC_SECG_P256K1), instantiate BC's SPI directly.- // JCA's ClassLoader.loadClass cannot find BC SPI classes in GraalVM native image- // unless they are allocated directly in code (GraalVM escape analysis eliminates- // unused allocations, keeping them out of the native image type registry).- KeyPairGenerator generator = isSecgP256k1(spec)- ? new KeyPairGeneratorSpi.EC()- : KeyPairGenerator.getInstance("EC");- generator.initialize(new ECGenParameterSpec(curveName));- KeyPair pair = generator.generateKeyPair();- key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));- key.setPublicKeyEncoded(Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));- }- case SM2 -> {- if (!region.equals("cn-north-1") && !region.equals("cn-northwest-1")) {- throw new AwsException("UnsupportedOperationException",- "KeySpec SM2 is not supported in this Region", 400);- }- KeyPairGenerator generator = new KeyPairGeneratorSpi.EC();- generator.initialize(new ECGenParameterSpec("sm2p256v1"));- KeyPair pair = generator.generateKeyPair();- key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));- key.setPublicKeyEncoded(Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));- }- default ->- throw new AwsException("InvalidCustomerMasterKeySpecException", "Unsupported key spec: " + spec, 400);- }- } catch (NoSuchAlgorithmException | InvalidAlgorithmParameterException e) {+ keyTypes.of(key.getKeySpec()).generateKeyMaterial(key, region);+ } catch (GeneralSecurityException e) {throw new AwsException("InternalFailure", "Failed to generate key material: " + e.getMessage(), 500);}}- /**- * Mints a new AES-256 backing key for the AES-GCM ciphertext envelope and makes it the- * current one, keeping any earlier backing keys in the map so ciphertext produced under- * them keeps decrypting (AWS KMS never discards prior backing keys either).- */- private void generateBackingKey(KmsKey key) {- byte[] material = new byte[AES_KEY_BYTES];- SECURE_RANDOM.nextBytes(material);- String backingKeyId = UUID.randomUUID().toString();- if (key.getBackingKeys() == null) {- key.setBackingKeys(new HashMap<>());- }- key.getBackingKeys().put(backingKeyId, Base64.getEncoder().encodeToString(material));- key.setCurrentBackingKeyId(backingKeyId);- }-/*** Self-healing for keys persisted before the AES-GCM envelope existed: their JSON has no* {@code backingKeys}/{@code currentBackingKeyId}, so the field defaults to an empty map on@@ -348,7 +230,7 @@ public class KmsService implements ResourceProvider {if (hasBackingKeyMaterial(current)) {return current;}- generateBackingKey(current);+ keyTypes.symmetric().addBackingKey(current);keyStore.put(region + "::" + current.getKeyId(), current);LOG.infov("Generated backing key material for legacy KMS key: {0} in {1}", current.getKeyId(), region);return current;@@ -393,14 +275,6 @@ public class KmsService implements ResourceProvider {}}- private static int hmacKeyByteLength(KmsKeySpec spec) {- if (!isHmac(spec)) {- throw new AwsException("InvalidCustomerMasterKeySpecException",- "Unsupported HMAC key spec: " + spec, 400);- }- return spec.materialByteLength();- }-public KmsKey describeKey(String keyId, String region) {return resolveKey(keyId, region);}@@ -846,8 +720,8 @@ public class KmsService implements ResourceProvider {}key.setOnDemandRotationCount(key.getOnDemandRotationCount() + 1);// AWS keeps prior backing keys after rotation so ciphertext encrypted under them keeps- // decrypting; generateBackingKey adds a new entry rather than replacing the map.- generateBackingKey(key);+ // decrypting.+ keyTypes.symmetric().addBackingKey(key);keyStore.put(region + "::" + key.getKeyId(), key);return key.getKeyId();}@@ -1261,10 +1135,9 @@ public class KmsService implements ResourceProvider {private static final String AES_GCM_TRANSFORMATION = "AES/GCM/NoPadding";private static final int GCM_IV_BYTES = 12;private static final int GCM_TAG_BITS = 128;- private static final int AES_KEY_BYTES = 32;+ private static final int AES_KEY_BYTES = KmsKeySpec.SYMMETRIC_DEFAULT.materialByteLength();private static final String BLOB_PREFIX_V2 = "kms:v2:";private static final String BLOB_PREFIX_V1 = "kms:";- private static final int SHA_512_DIGEST_BYTES = 64;private static final int MIN_MAC_MESSAGE_BYTES = 1;private static final int MAX_MAC_MESSAGE_BYTES = 4096;private static final int MIN_ENCRYPT_PLAINTEXT_BYTES = 1;@@ -1295,10 +1168,9 @@ public class KmsService implements ResourceProvider {validateKeyUsageForEncryptionOperation(kmsKey, operation);validateEncryptionAlgorithmForSpec(algorithm, kmsKey.getKeySpec());- if (kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.RSA) {+ if (algorithm != KmsKeySpec.Algorithm.SYMMETRIC_DEFAULT) {rejectEncryptionContextForAsymmetricKey(encryptionContext);- validateRsaPlaintextLength(plaintext, algorithm, kmsKey.getKeySpec());- byte[] ciphertext = rsaOaep(Cipher.ENCRYPT_MODE, kmsKey, algorithm, plaintext);+ byte[] ciphertext = keyTypes.of(kmsKey.getKeySpec()).encrypt(kmsKey, algorithm, plaintext);return new EncryptResult(ciphertext, kmsKey.getArn(), algorithm.getAlgName());}@@ -1363,7 +1235,7 @@ public class KmsService implements ResourceProvider {validateKeyUsageForEncryptionOperation(requestKey, "Decrypt");validateEncryptionAlgorithmForSpec(algorithm, requestKey.getKeySpec());rejectEncryptionContextForAsymmetricKey(encryptionContext);- byte[] plaintext = rsaOaep(Cipher.DECRYPT_MODE, requestKey, algorithm, ciphertext);+ byte[] plaintext = keyTypes.of(requestKey.getKeySpec()).decrypt(requestKey, algorithm, ciphertext);return new DecryptResult(plaintext, requestKey.getArn(), algorithm.getAlgName());}@@ -1705,105 +1577,14 @@ public class KmsService implements ResourceProvider {}}- /** RFC 8017 7.1.1: OAEP holds at most k - 2*hLen - 2 bytes, k being the modulus length. */- private static void validateRsaPlaintextLength(byte[] plaintext, KmsKeySpec.Algorithm algorithm, KmsKeySpec spec) {- int modulusBytes = switch (spec) {- case RSA_2048 -> 256;- case RSA_3072 -> 384;- case RSA_4096 -> 512;- default -> throw new AwsException("InvalidKeyUsageException",- "Algorithm " + algorithm.getAlgName() + " is incompatible with key spec " + spec.name() + ".", 400);- };- int digestBytes = algorithm == KmsKeySpec.Algorithm.RSAES_OAEP_SHA_1 ? 20 : 32;- int maxBytes = modulusBytes - 2 * digestBytes - 2;- if (plaintext.length > maxBytes) {- throw new AwsException("ValidationException",- "Algorithm " + algorithm.getAlgName() + " and key spec " + spec.name()- + " cannot encrypt data larger than " + maxBytes + " bytes.", 400);- }- }-- /**- * RSAES-OAEP with an explicit OAEPParameterSpec. The JDK's named OAEP transformations- * default MGF1 to SHA-1 whatever the main digest is, while KMS RSAES_OAEP_SHA_256 uses- * MGF1 over SHA-256, so the parameters are always spelled out.- */- private byte[] rsaOaep(int mode, KmsKey key, KmsKeySpec.Algorithm algorithm, byte[] input) {- try {- var digest = algorithm == KmsKeySpec.Algorithm.RSAES_OAEP_SHA_1 ? "SHA-1" : "SHA-256";- var cipher = Cipher.getInstance("RSA/ECB/OAEPPadding");- var params = new OAEPParameterSpec(digest, "MGF1", new MGF1ParameterSpec(digest),- PSource.PSpecified.DEFAULT);- if (mode == Cipher.ENCRYPT_MODE) {- cipher.init(mode, loadPublicKey(key.getPublicKeyEncoded(), key.getKeySpec()), params);- } else {- cipher.init(mode, loadPrivateKey(key.getPrivateKeyEncoded(), key.getKeySpec()), params);- }- return cipher.doFinal(input);- } catch (Exception e) {- if (mode == Cipher.DECRYPT_MODE) {- // Real KMS answers any OAEP failure the same way: the padding check hides- // whether the bytes were garbage, the wrong length, or made for another key.- // The log line keeps broken key material or a missing cipher diagnosable.- LOG.debugv(e, "RSA OAEP decrypt failed for key {0}", key.getKeyId());- throw new AwsException("InvalidCiphertextException", "The ciphertext is invalid.", 400);- }- LOG.warnv(e, "RSA OAEP encrypt failed for key {0}", key.getKeyId());- throw new AwsException("InternalFailure", "Failed to encrypt: " + e.getMessage(), 500);- }- }-public byte[] sign(String keyId, byte[] message, String algorithm, String region) {return sign(keyId, message, algorithm, RAW, region);}public byte[] sign(String keyId, byte[] message, String algorithm, KmsMessageType messageType, String region) {KmsKey kmsKey = resolveKey(keyId, region);- if (KmsKeySpec.SYMMETRIC_DEFAULT == kmsKey.getKeySpec()) {- throw new AwsException("UnsupportedOperationException", "Unsupported key spec for signing.", 400);- }-- var ed25519 = kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.ED25519;- var sm2 = kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.SM2;- if (ed25519) {- validateEd25519Request(kmsKey.getKeySpec(), algorithm, messageType, message);- }- if (kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.ML_DSA) {- validateMlDsaRequest(kmsKey.getKeySpec(), algorithm, messageType);- }- if (sm2) {- validateSm2Request(kmsKey.getKeySpec(), algorithm, messageType);- }-try {- PrivateKey privateKey = loadPrivateKey(kmsKey.getPrivateKeyEncoded(), kmsKey.getKeySpec());- if (ed25519) {- return signEd25519(privateKey, message, algorithm);- }- if (sm2) {- return signSm2(privateKey, message);- }- if (messageType == DIGEST && isRsaPssRequest(kmsKey.getKeySpec(), algorithm)) {- return signRsaPssDigest(privateKey, message, algorithm);- }- String jcaAlgo = switch (messageType) {- // If message is already a digest, we need a "NONEwith..." algorithm- case DIGEST -> "NONEwith" + (kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.RSA ? "RSA" : "ECDSA");- case RAW -> KmsKeySpec.getSignVerifyAlgorithm(algorithm).getJavaName();- };- if (messageType == DIGEST && isPKCS1v1_5(kmsKey.getKeySpec().getAlgorithm().getFirst())) {- // RFC 8017 9.2: PKCS#1 v1.5 signs DigestInfo{hashOID, digest}, not the- // bare digest, so the signature validates with external verifiers and- // real KMS (NONEwithRSA only pads the bytes it is given).- message = wrapInDigestInfo(message, algorithm);- }- if (isSecgP256k1(kmsKey.getKeySpec())) {- return signSecgP256k1(privateKey, message, jcaAlgo);- }- var sig = signatureFor(jcaAlgo);- sig.initSign(privateKey);- sig.update(message);- return sig.sign();+ return keyTypes.of(kmsKey.getKeySpec()).sign(kmsKey, message, algorithm, messageType);} catch (AwsException e) {throw e;} catch (Exception e) {@@ -1817,49 +1598,8 @@ public class KmsService implements ResourceProvider {public boolean verify(String keyId, byte[] message, byte[] signature, String algorithm, KmsMessageType messageType, String region) {KmsKey kmsKey = resolveKey(keyId, region);- if (KmsKeySpec.SYMMETRIC_DEFAULT == kmsKey.getKeySpec()) {- return false;- }-- var ed25519 = kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.ED25519;- var sm2 = kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.SM2;- if (ed25519) {- validateEd25519Request(kmsKey.getKeySpec(), algorithm, messageType, message);- }- if (kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.ML_DSA) {- validateMlDsaRequest(kmsKey.getKeySpec(), algorithm, messageType);- }- if (sm2) {- validateSm2Request(kmsKey.getKeySpec(), algorithm, messageType);- }-try {- PublicKey publicKey = loadPublicKey(kmsKey.getPublicKeyEncoded(), kmsKey.getKeySpec());- if (ed25519) {- return verifyEd25519(publicKey, message, signature, algorithm);- }- if (sm2) {- return verifySm2(publicKey, message, signature);- }- String jcaAlgo = KmsKeySpec.getSignVerifyAlgorithm(algorithm).getJavaName();-- if (DIGEST.equals(messageType)) {- if (isRsaPssRequest(kmsKey.getKeySpec(), algorithm)) {- return verifyRsaPssDigest(publicKey, message, signature, algorithm);- }- jcaAlgo = "NONEwith" + (kmsKey.getKeySpec().getKeyType() == KmsKeySpec.KeyType.RSA ? "RSA" : "ECDSA");- if (isPKCS1v1_5(kmsKey.getKeySpec().getAlgorithm().getFirst())) {- // Mirror sign(): verify against DigestInfo{hashOID, digest} (RFC 8017 9.2).- message = wrapInDigestInfo(message, algorithm);- }- }- if (isSecgP256k1(kmsKey.getKeySpec())) {- return verifySecgP256k1(publicKey, message, signature, jcaAlgo);- }- var sig = signatureFor(jcaAlgo);- sig.initVerify(publicKey);- sig.update(message);- return sig.verify(signature);+ return keyTypes.of(kmsKey.getKeySpec()).verify(kmsKey, message, signature, algorithm, messageType);} catch (AwsException e) {throw e;} catch (Exception e) {@@ -1882,12 +1622,7 @@ public class KmsService implements ResourceProvider {validateMacMessageLength(message);try {- byte[] keyBytes = Base64.getDecoder().decode(kmsKey.getPrivateKeyEncoded());- String jcaAlgorithm = mapMacAlgorithm(algorithm);- Mac mac = Mac.getInstance(jcaAlgorithm);- mac.init(new SecretKeySpec(keyBytes, jcaAlgorithm));- mac.update(message);- return mac.doFinal();+ return keyTypes.of(kmsKey.getKeySpec()).generateMac(kmsKey, message, algorithm);} catch (AwsException e) {throw e;} catch (Exception e) {@@ -1932,16 +1667,6 @@ public class KmsService implements ResourceProvider {return kmsKey;}- private String mapMacAlgorithm(String awsAlgo) {- return switch (awsAlgo) {- case "HMAC_SHA_224" -> "HmacSHA224";- case "HMAC_SHA_256" -> "HmacSHA256";- case "HMAC_SHA_384" -> "HmacSHA384";- case "HMAC_SHA_512" -> "HmacSHA512";- default -> throw new AwsException("InvalidMacAlgorithmException", "Unsupported MAC algorithm: " + awsAlgo, 400);- };- }-private static void validateMacMessageLength(byte[] message) {int length = message == null ? 0 : message.length;if (length < MIN_MAC_MESSAGE_BYTES || length > MAX_MAC_MESSAGE_BYTES) {@@ -1958,50 +1683,6 @@ public class KmsService implements ResourceProvider {}}- private PrivateKey loadPrivateKey(String encoded, KmsKeySpec spec) throws Exception {- byte[] decoded = Base64.getDecoder().decode(encoded);- if (isSecgP256k1(spec) || isSm2(spec)) {- // For secp256k1, use BC's KeyFactorySpi.EC directly as AsymmetricKeyInfoConverter.- // This bypasses JCA and ClassLoader.loadClass; the allocation is live (generatePrivate- // is called), so GraalVM's escape analysis keeps the class in the native image.- AsymmetricKeyInfoConverter converter = new KeyFactorySpi.EC();- return converter.generatePrivate(PrivateKeyInfo.getInstance(decoded));- }- return buildKeyFactory(spec).generatePrivate(new PKCS8EncodedKeySpec(decoded));- }-- private PublicKey loadPublicKey(String encoded, KmsKeySpec spec) throws Exception {- byte[] decoded = Base64.getDecoder().decode(encoded);- if (isSecgP256k1(spec) || isSm2(spec)) {- AsymmetricKeyInfoConverter converter = new KeyFactorySpi.EC();- return converter.generatePublic(SubjectPublicKeyInfo.getInstance(decoded));- }- return buildKeyFactory(spec).generatePublic(new X509EncodedKeySpec(decoded));- }-- /**- * Wraps a pre-computed digest in the ASN.1 {@code DigestInfo} structure that PKCS#1- * v1.5 signing prepends before padding (RFC 8017 9.2). Needed for {@code MessageType=DIGEST}- * RSA signatures because {@code NONEwithRSA} pads only the bytes it is given.- */- private byte[] wrapInDigestInfo(byte[] digest, String algorithm) {- ASN1ObjectIdentifier hashOid;- if (algorithm.endsWith("SHA_256")) {- hashOid = NISTObjectIdentifiers.id_sha256;- } else if (algorithm.endsWith("SHA_384")) {- hashOid = NISTObjectIdentifiers.id_sha384;- } else if (algorithm.endsWith("SHA_512")) {- hashOid = NISTObjectIdentifiers.id_sha512;- } else {- throw new AwsException("InvalidSigningAlgorithmException", "Unsupported algorithm: " + algorithm, 400);- }- try {- return new DigestInfo(new AlgorithmIdentifier(hashOid, DERNull.INSTANCE), digest).getEncoded();- } catch (IOException e) {- throw new AwsException("InternalFailure", "Failed to encode DigestInfo: " + e.getMessage(), 500);- }- }-public Map<String, Object> generateDataKey(String keyId, String keySpec, int numberOfBytes, String region) {return generateDataKey(keyId, keySpec, numberOfBytes, Map.of(), region);}@@ -2040,273 +1721,6 @@ public class KmsService implements ResourceProvider {// ──────────────────────────── Helpers ────────────────────────────- private static boolean isSecgP256k1(KmsKeySpec spec) {- return KmsKeySpec.ECC_SECG_P256K1 == spec;- }-- private static boolean isSm2(KmsKeySpec spec) {- return KmsKeySpec.SM2 == spec;- }-- private static void validateSm2Request(KmsKeySpec spec, String algorithm, KmsMessageType messageType) {- if (KmsKeySpec.getSignVerifyAlgorithm(algorithm) != KmsKeySpec.Algorithm.SM2DSA) {- throw new AwsException("InvalidKeyUsageException",- "Algorithm " + algorithm + " is incompatible with key spec " + spec.name() + ".", 400);- }- if (messageType != RAW) {- throw new AwsException("ValidationException",- "Message type " + messageType + " is incompatible with key spec " + spec.name() + ".", 400);- }- }-- private static byte[] signSm2(PrivateKey privateKey, byte[] message) throws Exception {- ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec("sm2p256v1");- ECDomainParameters domain = new ECDomainParameters(spec.getCurve(), spec.getG(), spec.getN(), spec.getH());- ECPrivateKeyParameters parameters = new ECPrivateKeyParameters(((BCECPrivateKey) privateKey).getD(), domain);-- var signer = new SM2Signer();- signer.init(true, new ParametersWithRandom(parameters, SECURE_RANDOM));- signer.update(message, 0, message.length);- return signer.generateSignature();- }-- private static boolean verifySm2(PublicKey publicKey, byte[] message, byte[] signature) {- ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec("sm2p256v1");- ECDomainParameters domain = new ECDomainParameters(spec.getCurve(), spec.getG(), spec.getN(), spec.getH());- ECPublicKeyParameters parameters = new ECPublicKeyParameters(((BCECPublicKey) publicKey).getQ(), domain);-- var verifier = new SM2Signer();- verifier.init(false, parameters);- verifier.update(message, 0, message.length);- return verifier.verifySignature(signature);- }-- /**- * Validates what an Ed25519 key accepts, matching the errors real KMS returns.- *- * <p>ED25519_SHA_512 only takes {@code MessageType=RAW} and ED25519_PH_SHA_512 only takes- * {@code MessageType=DIGEST}, whose value has to be exactly one SHA-512 digest. Real KMS- * rejects the other pairing and a wrong digest length with a ValidationException, and rejects- * any other signing algorithm with an InvalidKeyUsageException. Sign and Verify both enforce- * all three.- */- private static void validateEd25519Request(KmsKeySpec spec, String algorithm, KmsMessageType messageType,- byte[] message) {- var algo = KmsKeySpec.getSignVerifyAlgorithm(algorithm);- if (algo != KmsKeySpec.Algorithm.ED25519_SHA_512 && algo != KmsKeySpec.Algorithm.ED25519_PH_SHA_512) {- throw new AwsException("InvalidKeyUsageException",- "Algorithm " + algorithm + " is incompatible with key spec " + spec.name() + ".", 400);- }- var required = algo == KmsKeySpec.Algorithm.ED25519_SHA_512 ? KmsMessageType.RAW : KmsMessageType.DIGEST;- if (messageType != required) {- throw new AwsException("ValidationException",- "Message type " + messageType + " is incompatible with algorithm " + algorithm + ".", 400);- }- if (algo == KmsKeySpec.Algorithm.ED25519_PH_SHA_512 && message.length != SHA_512_DIGEST_BYTES) {- throw new AwsException("ValidationException",- "Digest is invalid length for algorithm " + algorithm + ".", 400);- }- }-- private static void validateMlDsaRequest(KmsKeySpec spec, String algorithm, KmsMessageType messageType) {- var signingAlgorithm = KmsKeySpec.getSignVerifyAlgorithm(algorithm);- if (signingAlgorithm != KmsKeySpec.Algorithm.ML_DSA_SHAKE_256) {- throw new AwsException("InvalidKeyUsageException",- "Algorithm " + algorithm + " is incompatible with key spec " + spec.name() + ".", 400);- }- if (messageType != RAW) {- throw new AwsException("ValidationException",- "Message type " + messageType + " is incompatible with key spec " + spec.name() + ".", 400);- }- }-- /**- * Signs with an Ed25519 key.- *- * <p>ED25519_SHA_512 is pure Ed25519 over the message. ED25519_PH_SHA_512 is RFC 8032- * Ed25519ph, and real KMS applies the SHA-512 pre-hash to the bytes the caller sends rather- * than treating them as an already computed digest. That is measurably different from- * MessageType=DIGEST on RSA and ECDSA keys, where the bytes are signed as they arrive.- *- * <p>The JDK has no Ed25519ph, so that branch uses BouncyCastle's lightweight signer,- * instantiated directly rather than resolved through a JCA provider, the same way the- * secp256k1 path does.- */- private static byte[] signEd25519(PrivateKey privateKey, byte[] message, String algorithm) throws Exception {- if (KmsKeySpec.Algorithm.ED25519_SHA_512.name().equals(algorithm)) {- var signature = Signature.getInstance("Ed25519");- signature.initSign(privateKey);- signature.update(message);- return signature.sign();- }- var signer = new Ed25519phSigner(new byte[0]);- signer.init(true, new Ed25519PrivateKeyParameters(ed25519Seed(privateKey), 0));- signer.update(message, 0, message.length);- return signer.generateSignature();- }-- private static boolean verifyEd25519(PublicKey publicKey, byte[] message, byte[] signature, String algorithm)- throws Exception {- if (KmsKeySpec.Algorithm.ED25519_SHA_512.name().equals(algorithm)) {- var verifier = Signature.getInstance("Ed25519");- verifier.initVerify(publicKey);- verifier.update(message);- return verifier.verify(signature);- }- var verifier = new Ed25519phSigner(new byte[0]);- verifier.init(false, new Ed25519PublicKeyParameters(ed25519Point(publicKey), 0));- verifier.update(message, 0, message.length);- return verifier.verifySignature(signature);- }-- private static byte[] ed25519Seed(PrivateKey privateKey) throws InvalidKeyException {- if (privateKey instanceof EdECPrivateKey edEC) {- return edEC.getBytes().orElseThrow(() -> new InvalidKeyException("Ed25519 private key is not extractable"));- }- throw new InvalidKeyException("Expected an Ed25519 private key but got " + privateKey.getAlgorithm());- }-- private static byte[] ed25519Point(PublicKey publicKey) {- return SubjectPublicKeyInfo.getInstance(publicKey.getEncoded()).getPublicKeyData().getBytes();- }-- /**- * Builds the {@link Signature} for a KMS signing algorithm.- *- * <p>BouncyCastle names PSS signatures {@code SHAnnnwithRSA/PSS}, and only its provider- * answers to that name. The JDK exposes one {@code RSASSA-PSS} Signature whose digest,- * mask generation function and salt length come from a parameter spec instead. AWS KMS- * RSASSA_PSS_SHA_nnn uses MGF1 over the same digest with a salt as long as that digest,- * which is what BouncyCastle's alias defaults to, so a signature made either way verifies- * against the other. Every other name Floci asks for is a standard JCA name.- */- private static Signature signatureFor(String jcaAlgorithm) throws GeneralSecurityException {- if (!jcaAlgorithm.endsWith("withRSA/PSS")) {- return Signature.getInstance(jcaAlgorithm);- }- var digest = "SHA-" + jcaAlgorithm.substring("SHA".length(), jcaAlgorithm.indexOf("with"));- var maskGeneration = switch (digest) {- case "SHA-256" -> MGF1ParameterSpec.SHA256;- case "SHA-384" -> MGF1ParameterSpec.SHA384;- case "SHA-512" -> MGF1ParameterSpec.SHA512;- default -> throw new NoSuchAlgorithmException("Unsupported PSS digest: " + digest);- };- var saltLength = MessageDigest.getInstance(digest).getDigestLength();- var signature = Signature.getInstance("RSASSA-PSS");- signature.setParameter(new PSSParameterSpec(digest, "MGF1", maskGeneration, saltLength, 1));- return signature;- }-- private static boolean isRsaPssRequest(KmsKeySpec spec, String algorithm) {- return spec.getKeyType() == KmsKeySpec.KeyType.RSA && algorithm.startsWith("RSASSA_PSS");- }-- /**- * Signs a pre-computed digest with RSASSA-PSS.- *- * <p>Real KMS applies the PSS encoding directly to the digest a {@code MessageType=DIGEST}- * caller sends. The JDK's {@code RSASSA-PSS} Signature always hashes its input first, so- * this uses BouncyCastle's lightweight raw PSS signer, instantiated directly like the- * secp256k1 and Ed25519ph paths. The raw signer defaults to MGF1 over the same digest with- * a salt as long as that digest, matching {@link #signatureFor(String)}, so RAW and DIGEST- * signatures verify against each other.- */- private static byte[] signRsaPssDigest(PrivateKey privateKey, byte[] digest, String algorithm) throws Exception {- var signer = rawPssSigner(algorithm);- signer.init(true, new ParametersWithRandom(PrivateKeyFactory.createKey(privateKey.getEncoded()), SECURE_RANDOM));- signer.update(digest, 0, digest.length);- return signer.generateSignature();- }-- private static boolean verifyRsaPssDigest(PublicKey publicKey, byte[] digest, byte[] signature, String algorithm) throws Exception {- var signer = rawPssSigner(algorithm);- signer.init(false, PublicKeyFactory.createKey(publicKey.getEncoded()));- signer.update(digest, 0, digest.length);- return signer.verifySignature(signature);- }-- private static PSSSigner rawPssSigner(String algorithm) {- Digest digest = switch (algorithm) {- case "RSASSA_PSS_SHA_256" -> new SHA256Digest();- case "RSASSA_PSS_SHA_384" -> new SHA384Digest();- case "RSASSA_PSS_SHA_512" -> new SHA512Digest();- default -> throw new AwsException("InvalidSigningAlgorithmException", "Unsupported algorithm: " + algorithm, 400);- };- return PSSSigner.createRawSigner(new RSABlindedEngine(), digest);- }-- private static boolean isPKCS1v1_5(KmsKeySpec.Algorithm spec) {- return spec == KmsKeySpec.Algorithm.RSASSA_PKCS1_V1_5_SHA_256- || spec == KmsKeySpec.Algorithm.RSASSA_PKCS1_V1_5_SHA_384- || spec == KmsKeySpec.Algorithm.RSASSA_PKCS1_V1_5_SHA_512;- }-- /**- * Signs {@code message} with secp256k1 using BC's lightweight {@link ECDSASigner}.- *- * <p>BC's {@code SignatureSpi} subclasses extend {@code java.security.SignatureSpi} (not- * {@code java.security.Signature}), so they cannot be used as a drop-in {@code Signature}.- * Using the lightweight API avoids JCA's {@code ClassLoader.loadClass} entirely — every- * class referenced here is directly allocated in reachable code and is always in GraalVM's- * native image type registry.</p>- */- private static byte[] signSecgP256k1(PrivateKey privateKey, byte[] message, String jcaAlgo) throws Exception {- ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec("secp256k1");- ECDomainParameters domain = new ECDomainParameters(spec.getCurve(), spec.getG(), spec.getN(), spec.getH());- ECPrivateKeyParameters privParams = new ECPrivateKeyParameters(((BCECPrivateKey) privateKey).getD(), domain);-- byte[] hash = "NONEwithECDSA".equals(jcaAlgo) ? message : hashForEcdsa(message, jcaAlgo);-- ECDSASigner signer = new ECDSASigner();- signer.init(true, new ParametersWithRandom(privParams, new SecureRandom()));- BigInteger[] rs = signer.generateSignature(hash);-- ByteArrayOutputStream bOut = new ByteArrayOutputStream();- DERSequenceGenerator seq = new DERSequenceGenerator(bOut);- seq.addObject(new ASN1Integer(rs[0]));- seq.addObject(new ASN1Integer(rs[1]));- seq.close();- return bOut.toByteArray();- }-- /**- * Verifies a DER-encoded ECDSA signature over secp256k1.- */- private static boolean verifySecgP256k1(PublicKey publicKey, byte[] message, byte[] signature, String jcaAlgo) throws Exception {- ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec("secp256k1");- ECDomainParameters domain = new ECDomainParameters(spec.getCurve(), spec.getG(), spec.getN(), spec.getH());- ECPublicKeyParameters pubParams = new ECPublicKeyParameters(((BCECPublicKey) publicKey).getQ(), domain);-- byte[] hash = "NONEwithECDSA".equals(jcaAlgo) ? message : hashForEcdsa(message, jcaAlgo);-- ASN1Sequence asn1 = ASN1Sequence.getInstance(ASN1Primitive.fromByteArray(signature));- BigInteger r = ASN1Integer.getInstance(asn1.getObjectAt(0)).getValue();- BigInteger s = ASN1Integer.getInstance(asn1.getObjectAt(1)).getValue();-- ECDSASigner verifier = new ECDSASigner();- verifier.init(false, pubParams);- return verifier.verifySignature(hash, r, s);- }-- private static byte[] hashForEcdsa(byte[] message, String jcaAlgo) throws Exception {- String mdAlgo = switch (jcaAlgo) {- case "SHA256withECDSA" -> "SHA-256";- case "SHA384withECDSA" -> "SHA-384";- case "SHA512withECDSA" -> "SHA-512";- default -> throw new AwsException("InvalidSigningAlgorithmException", "Unsupported EC algorithm: " + jcaAlgo, 400);- };- return MessageDigest.getInstance(mdAlgo).digest(message);- }-- private static KeyFactory buildKeyFactory(KmsKeySpec spec) throws Exception {- return KeyFactory.getInstance(switch (spec.getKeyType()) {- case RSA -> "RSA";- case ED25519 -> "Ed25519";- case ML_DSA -> "ML-DSA";- default -> "EC";- });- }-private KmsKey resolveKey(String keyIdOrArn, String region) {String id = keyIdOrArn;// Alias arndiff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/AsymmetricKeys.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/AsymmetricKeys.javanew file mode 100644index 0000000000..ebbfb16aff--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/AsymmetricKeys.java@@ -0,0 +1,90 @@+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 io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;++import java.security.GeneralSecurityException;+import java.security.KeyFactory;+import java.security.KeyPair;+import java.security.MessageDigest;+import java.security.NoSuchAlgorithmException;+import java.security.PrivateKey;+import java.security.PublicKey;+import java.security.Signature;+import java.security.spec.MGF1ParameterSpec;+import java.security.spec.PKCS8EncodedKeySpec;+import java.security.spec.PSSParameterSpec;+import java.security.spec.X509EncodedKeySpec;+import java.util.Base64;++final class AsymmetricKeys {++ private AsymmetricKeys() {+ }++ static KmsKeySpec.Algorithm requireSpecAlgorithm(KmsKeySpec spec, String algorithm) {+ KmsKeySpec.Algorithm signingAlgorithm = KmsKeySpec.getSignVerifyAlgorithm(algorithm);+ if (!spec.getAlgorithm().contains(signingAlgorithm)) {+ throw new AwsException("InvalidKeyUsageException",+ "Algorithm " + algorithm + " is incompatible with key spec " + spec.name() + ".", 400);+ }+ return signingAlgorithm;+ }++ static void requireRawMessage(KmsKeySpec spec, KmsMessageType messageType) {+ if (messageType != KmsMessageType.RAW) {+ throw new AwsException("ValidationException",+ "Message type " + messageType + " is incompatible with key spec " + spec.name() + ".", 400);+ }+ }++ static void store(KmsKey key, KeyPair pair) {+ key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));+ key.setPublicKeyEncoded(Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));+ }++ static PrivateKey privateKey(KmsKey key, String keyAlgorithm) throws GeneralSecurityException {+ byte[] decoded = Base64.getDecoder().decode(key.getPrivateKeyEncoded());+ return KeyFactory.getInstance(keyAlgorithm).generatePrivate(new PKCS8EncodedKeySpec(decoded));+ }++ static PublicKey publicKey(KmsKey key, String keyAlgorithm) throws GeneralSecurityException {+ byte[] decoded = Base64.getDecoder().decode(key.getPublicKeyEncoded());+ return KeyFactory.getInstance(keyAlgorithm).generatePublic(new X509EncodedKeySpec(decoded));+ }++ static byte[] sign(PrivateKey privateKey, String jcaAlgorithm, byte[] message) throws GeneralSecurityException {+ Signature signature = signatureFor(jcaAlgorithm);+ signature.initSign(privateKey);+ signature.update(message);+ return signature.sign();+ }++ static boolean verify(PublicKey publicKey, String jcaAlgorithm, byte[] message, byte[] signature)+ throws GeneralSecurityException {+ Signature verifier = signatureFor(jcaAlgorithm);+ verifier.initVerify(publicKey);+ verifier.update(message);+ return verifier.verify(signature);+ }++ // KMS RSASSA_PSS uses MGF1 over the same digest, with a salt as long as the digest.+ private static Signature signatureFor(String jcaAlgorithm) throws GeneralSecurityException {+ if (!jcaAlgorithm.endsWith("withRSA/PSS")) {+ return Signature.getInstance(jcaAlgorithm);+ }+ String digest = "SHA-" + jcaAlgorithm.substring("SHA".length(), jcaAlgorithm.indexOf("with"));+ MGF1ParameterSpec maskGeneration = switch (digest) {+ case "SHA-256" -> MGF1ParameterSpec.SHA256;+ case "SHA-384" -> MGF1ParameterSpec.SHA384;+ case "SHA-512" -> MGF1ParameterSpec.SHA512;+ default -> throw new NoSuchAlgorithmException("Unsupported PSS digest: " + digest);+ };+ int saltLength = MessageDigest.getInstance(digest).getDigestLength();+ Signature signature = Signature.getInstance("RSASSA-PSS");+ signature.setParameter(new PSSParameterSpec(digest, "MGF1", maskGeneration, saltLength, 1));+ return signature;+ }+}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.javanew file mode 100644index 0000000000..921ce56ca1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/BcEcKeys.java@@ -0,0 +1,54 @@+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.ECDomainParameters;+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.util.AsymmetricKeyInfoConverter;+import org.bouncycastle.jce.ECNamedCurveTable;+import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;++import java.io.IOException;+import java.security.InvalidAlgorithmParameterException;+import java.security.KeyPair;+import java.security.KeyPairGenerator;+import java.security.spec.ECGenParameterSpec;+import java.util.Base64;++// The BouncyCastle SPI classes are allocated directly. JCA lookup cannot find them in the native image.+final class BcEcKeys {++ private BcEcKeys() {+ }++ static KeyPair generateKeyPair(String curveName) throws InvalidAlgorithmParameterException {+ KeyPairGenerator generator = new KeyPairGeneratorSpi.EC();+ generator.initialize(new ECGenParameterSpec(curveName));+ return generator.generateKeyPair();+ }++ 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));+ }++ static ECPublicKeyParameters publicKeyParameters(KmsKey key, String curveName) throws IOException {+ AsymmetricKeyInfoConverter converter = new KeyFactorySpi.EC();+ byte[] decoded = Base64.getDecoder().decode(key.getPublicKeyEncoded());+ BCECPublicKey publicKey = (BCECPublicKey) converter.generatePublic(SubjectPublicKeyInfo.getInstance(decoded));+ return new ECPublicKeyParameters(publicKey.getQ(), domainParameters(curveName));+ }++ 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.javanew file mode 100644index 0000000000..5f96689cac--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccNistKeyType.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.services.kms.keytype;++import io.github.hectorvent.floci.services.kms.model.KmsKey;+import io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;++import java.security.GeneralSecurityException;+import java.security.KeyPairGenerator;+import java.security.PrivateKey;+import java.security.PublicKey;+import java.security.spec.ECGenParameterSpec;++final class EccNistKeyType implements KmsKeyType {++ @Override+ public void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {+ KeyPairGenerator generator = KeyPairGenerator.getInstance("EC");+ generator.initialize(new ECGenParameterSpec(key.getKeySpec().curveName()));+ AsymmetricKeys.store(key, generator.generateKeyPair());+ }++ @Override+ public byte[] sign(KmsKey key, byte[] message, String algorithm, KmsMessageType messageType)+ throws GeneralSecurityException {+ PrivateKey privateKey = AsymmetricKeys.privateKey(key, "EC");+ String jcaAlgorithm = switch (messageType) {+ case DIGEST -> "NONEwithECDSA";+ case RAW -> KmsKeySpec.getSignVerifyAlgorithm(algorithm).getJavaName();+ };+ return AsymmetricKeys.sign(privateKey, jcaAlgorithm, message);+ }++ @Override+ public boolean verify(KmsKey key, byte[] message, byte[] signature, String algorithm,+ KmsMessageType messageType) throws GeneralSecurityException {+ PublicKey publicKey = AsymmetricKeys.publicKey(key, "EC");+ // An unknown algorithm name fails even for DIGEST.+ KmsKeySpec.Algorithm signingAlgorithm = KmsKeySpec.getSignVerifyAlgorithm(algorithm);+ String jcaAlgorithm = switch (messageType) {+ case DIGEST -> "NONEwithECDSA";+ case RAW -> signingAlgorithm.getJavaName();+ };+ return AsymmetricKeys.verify(publicKey, jcaAlgorithm, message, signature);+ }+}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.javanew file mode 100644index 0000000000..212c192b3b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/EccSecgP256k1KeyType.java@@ -0,0 +1,90 @@+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 io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;+import org.bouncycastle.asn1.ASN1Integer;+import org.bouncycastle.asn1.ASN1Primitive;+import org.bouncycastle.asn1.ASN1Sequence;+import org.bouncycastle.asn1.DERSequenceGenerator;+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;+import org.bouncycastle.crypto.params.ECPublicKeyParameters;+import org.bouncycastle.crypto.params.ParametersWithRandom;+import org.bouncycastle.crypto.signers.ECDSASigner;++import java.io.ByteArrayOutputStream;+import java.io.IOException;+import java.math.BigInteger;+import java.security.GeneralSecurityException;+import java.security.MessageDigest;+import java.security.SecureRandom;++final class EccSecgP256k1KeyType implements KmsKeyType {++ private static final String CURVE = "secp256k1";++ private final SecureRandom random;++ EccSecgP256k1KeyType(SecureRandom random) {+ this.random = random;+ }++ @Override+ public void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {+ AsymmetricKeys.store(key, BcEcKeys.generateKeyPair(CURVE));+ }++ @Override+ public byte[] sign(KmsKey key, byte[] message, String algorithm, KmsMessageType messageType)+ throws GeneralSecurityException, IOException {+ ECPrivateKeyParameters privateKey = BcEcKeys.privateKeyParameters(key, CURVE);+ byte[] hash = switch (messageType) {+ case DIGEST -> message;+ case RAW -> hashForEcdsa(message, KmsKeySpec.getSignVerifyAlgorithm(algorithm));+ };++ ECDSASigner signer = new ECDSASigner();+ signer.init(true, new ParametersWithRandom(privateKey, random));+ BigInteger[] rs = signer.generateSignature(hash);++ ByteArrayOutputStream bOut = new ByteArrayOutputStream();+ DERSequenceGenerator seq = new DERSequenceGenerator(bOut);+ seq.addObject(new ASN1Integer(rs[0]));+ seq.addObject(new ASN1Integer(rs[1]));+ seq.close();+ return bOut.toByteArray();+ }++ @Override+ public boolean verify(KmsKey key, byte[] message, byte[] signature, String algorithm,+ KmsMessageType messageType) throws GeneralSecurityException, IOException {+ ECPublicKeyParameters publicKey = BcEcKeys.publicKeyParameters(key, CURVE);+ // An unknown algorithm name fails even for DIGEST.+ KmsKeySpec.Algorithm signingAlgorithm = KmsKeySpec.getSignVerifyAlgorithm(algorithm);+ byte[] hash = switch (messageType) {+ case DIGEST -> message;+ case RAW -> hashForEcdsa(message, signingAlgorithm);+ };++ ASN1Sequence asn1 = ASN1Sequence.getInstance(ASN1Primitive.fromByteArray(signature));+ BigInteger r = ASN1Integer.getInstance(asn1.getObjectAt(0)).getValue();+ BigInteger s = ASN1Integer.getInstance(asn1.getObjectAt(1)).getValue();++ ECDSASigner verifier = new ECDSASigner();+ verifier.init(false, publicKey);+ return verifier.verifySignature(hash, r, s);+ }++ private static byte[] hashForEcdsa(byte[] message, KmsKeySpec.Algorithm algorithm)+ throws GeneralSecurityException {+ String digest = switch (algorithm) {+ case ECDSA_SHA_256 -> "SHA-256";+ case ECDSA_SHA_384 -> "SHA-384";+ case ECDSA_SHA_512 -> "SHA-512";+ default -> throw new AwsException("InvalidSigningAlgorithmException",+ "Unsupported EC algorithm: " + algorithm.getJavaName(), 400);+ };+ return MessageDigest.getInstance(digest).digest(message);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Ed25519KeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Ed25519KeyType.javanew file mode 100644index 0000000000..19678d28bf--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Ed25519KeyType.java@@ -0,0 +1,83 @@+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 io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;+import org.bouncycastle.crypto.CryptoException;+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;+import org.bouncycastle.crypto.signers.Ed25519phSigner;++import java.security.GeneralSecurityException;+import java.security.InvalidKeyException;+import java.security.KeyPairGenerator;+import java.security.PrivateKey;+import java.security.PublicKey;+import java.security.interfaces.EdECPrivateKey;++final class Ed25519KeyType implements KmsKeyType {++ private static final int SHA_512_DIGEST_BYTES = 64;++ @Override+ public void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {+ AsymmetricKeys.store(key, KeyPairGenerator.getInstance("Ed25519").generateKeyPair());+ }++ // KMS runs Ed25519ph over the digest the caller sends, so the digest is hashed again.+ @Override+ public byte[] sign(KmsKey key, byte[] message, String algorithm, KmsMessageType messageType)+ throws GeneralSecurityException, CryptoException {+ KmsKeySpec.Algorithm signingAlgorithm = validateRequest(key.getKeySpec(), algorithm, messageType, message);+ PrivateKey privateKey = AsymmetricKeys.privateKey(key, "Ed25519");+ if (signingAlgorithm == KmsKeySpec.Algorithm.ED25519_SHA_512) {+ return AsymmetricKeys.sign(privateKey, "Ed25519", message);+ }+ Ed25519phSigner signer = new Ed25519phSigner(new byte[0]);+ signer.init(true, new Ed25519PrivateKeyParameters(seed(privateKey), 0));+ signer.update(message, 0, message.length);+ return signer.generateSignature();+ }++ @Override+ public boolean verify(KmsKey key, byte[] message, byte[] signature, String algorithm,+ KmsMessageType messageType) throws GeneralSecurityException {+ KmsKeySpec.Algorithm signingAlgorithm = validateRequest(key.getKeySpec(), algorithm, messageType, message);+ PublicKey publicKey = AsymmetricKeys.publicKey(key, "Ed25519");+ if (signingAlgorithm == KmsKeySpec.Algorithm.ED25519_SHA_512) {+ return AsymmetricKeys.verify(publicKey, "Ed25519", message, signature);+ }+ Ed25519phSigner verifier = new Ed25519phSigner(new byte[0]);+ verifier.init(false, new Ed25519PublicKeyParameters(point(publicKey), 0));+ verifier.update(message, 0, message.length);+ return verifier.verifySignature(signature);+ }++ private static KmsKeySpec.Algorithm validateRequest(KmsKeySpec spec, String algorithm,+ KmsMessageType messageType, byte[] message) {+ KmsKeySpec.Algorithm algo = AsymmetricKeys.requireSpecAlgorithm(spec, algorithm);+ KmsMessageType required = algo == KmsKeySpec.Algorithm.ED25519_SHA_512 ? KmsMessageType.RAW : KmsMessageType.DIGEST;+ if (messageType != required) {+ throw new AwsException("ValidationException",+ "Message type " + messageType + " is incompatible with algorithm " + algorithm + ".", 400);+ }+ if (algo == KmsKeySpec.Algorithm.ED25519_PH_SHA_512 && message.length != SHA_512_DIGEST_BYTES) {+ throw new AwsException("ValidationException",+ "Digest is invalid length for algorithm " + algorithm + ".", 400);+ }+ return algo;+ }++ private static byte[] seed(PrivateKey privateKey) throws InvalidKeyException {+ if (privateKey instanceof EdECPrivateKey edEC) {+ return edEC.getBytes().orElseThrow(() -> new InvalidKeyException("Ed25519 private key is not extractable"));+ }+ throw new InvalidKeyException("Expected an Ed25519 private key but got " + privateKey.getAlgorithm());+ }++ private static byte[] point(PublicKey publicKey) {+ return SubjectPublicKeyInfo.getInstance(publicKey.getEncoded()).getPublicKeyData().getBytes();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/HmacKeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/HmacKeyType.javanew file mode 100644index 0000000000..ca6029acf8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/HmacKeyType.java@@ -0,0 +1,46 @@+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 javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.security.GeneralSecurityException;+import java.security.SecureRandom;+import java.util.Base64;++final class HmacKeyType implements KmsKeyType {++ private final SecureRandom random;++ HmacKeyType(SecureRandom random) {+ this.random = random;+ }++ @Override+ public void generateKeyMaterial(KmsKey key, String region) {+ byte[] material = new byte[key.getKeySpec().materialByteLength()];+ random.nextBytes(material);+ key.setPrivateKeyEncoded(Base64.getEncoder().encodeToString(material));+ }++ @Override+ public byte[] generateMac(KmsKey key, byte[] message, String algorithm) throws GeneralSecurityException {+ byte[] keyBytes = Base64.getDecoder().decode(key.getPrivateKeyEncoded());+ String jcaAlgorithm = mapMacAlgorithm(algorithm);+ Mac mac = Mac.getInstance(jcaAlgorithm);+ mac.init(new SecretKeySpec(keyBytes, jcaAlgorithm));+ mac.update(message);+ return mac.doFinal();+ }++ private static String mapMacAlgorithm(String awsAlgo) {+ return switch (awsAlgo) {+ case "HMAC_SHA_224" -> "HmacSHA224";+ case "HMAC_SHA_256" -> "HmacSHA256";+ case "HMAC_SHA_384" -> "HmacSHA384";+ case "HMAC_SHA_512" -> "HmacSHA512";+ default -> throw new AwsException("InvalidMacAlgorithmException", "Unsupported MAC algorithm: " + awsAlgo, 400);+ };+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyType.javanew file mode 100644index 0000000000..bab9c85c7e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyType.java@@ -0,0 +1,35 @@+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 io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;++import java.security.GeneralSecurityException;++public interface KmsKeyType {++ void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException;++ default byte[] sign(KmsKey key, byte[] message, String algorithm, KmsMessageType messageType)+ throws Exception {+ throw new AwsException("UnsupportedOperationException", "Unsupported key spec for signing.", 400);+ }++ default boolean verify(KmsKey key, byte[] message, byte[] signature, String algorithm,+ KmsMessageType messageType) throws Exception {+ return false;+ }++ default byte[] encrypt(KmsKey key, KmsKeySpec.Algorithm algorithm, byte[] plaintext) {+ throw new IllegalStateException(key.getKeySpec() + " does not encrypt with " + algorithm);+ }++ default byte[] decrypt(KmsKey key, KmsKeySpec.Algorithm algorithm, byte[] ciphertext) {+ throw new IllegalStateException(key.getKeySpec() + " does not decrypt with " + algorithm);+ }++ default byte[] generateMac(KmsKey key, byte[] message, String algorithm) throws GeneralSecurityException {+ throw new IllegalStateException(key.getKeySpec() + " does not generate MACs");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyTypes.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyTypes.javanew file mode 100644index 0000000000..82b4261a72--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyTypes.java@@ -0,0 +1,44 @@+package io.github.hectorvent.floci.services.kms.keytype;++import io.github.hectorvent.floci.services.kms.model.KmsKeySpec;++import java.security.SecureRandom;++public final class KmsKeyTypes {++ private final SymmetricKeyType symmetric;+ private final KmsKeyType hmac;+ private final KmsKeyType rsa;+ private final KmsKeyType eccNist;+ private final KmsKeyType eccSecgP256k1;+ private final KmsKeyType ed25519;+ private final KmsKeyType mlDsa;+ private final KmsKeyType sm2;++ public KmsKeyTypes(SecureRandom random) {+ this.symmetric = new SymmetricKeyType(random);+ this.hmac = new HmacKeyType(random);+ this.rsa = new RsaKeyType(random);+ this.eccNist = new EccNistKeyType();+ this.eccSecgP256k1 = new EccSecgP256k1KeyType(random);+ this.ed25519 = new Ed25519KeyType();+ this.mlDsa = new MlDsaKeyType();+ this.sm2 = new Sm2KeyType(random);+ }++ public SymmetricKeyType symmetric() {+ return symmetric;+ }++ public KmsKeyType of(KmsKeySpec spec) {+ return switch (spec.getKeyType()) {+ case SYMMETRIC -> symmetric;+ case HMAC -> hmac;+ case RSA -> rsa;+ case ECC -> spec == KmsKeySpec.ECC_SECG_P256K1 ? eccSecgP256k1 : eccNist;+ case ED25519 -> ed25519;+ case ML_DSA -> mlDsa;+ case SM2 -> sm2;+ };+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/MlDsaKeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/MlDsaKeyType.javanew file mode 100644index 0000000000..a5c3da45fa--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/MlDsaKeyType.java@@ -0,0 +1,39 @@+package io.github.hectorvent.floci.services.kms.keytype;++import io.github.hectorvent.floci.services.kms.model.KmsKey;+import io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;++import java.security.GeneralSecurityException;+import java.security.KeyPairGenerator;+import java.security.PrivateKey;+import java.security.PublicKey;++final class MlDsaKeyType implements KmsKeyType {++ private static final String JCA_ALGORITHM = KmsKeySpec.Algorithm.ML_DSA_SHAKE_256.getJavaName();++ @Override+ public void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {+ String algorithm = key.getKeySpec().name().replace('_', '-');+ AsymmetricKeys.store(key, KeyPairGenerator.getInstance(algorithm).generateKeyPair());+ }++ @Override+ public byte[] sign(KmsKey key, byte[] message, String algorithm, KmsMessageType messageType)+ throws GeneralSecurityException {+ AsymmetricKeys.requireSpecAlgorithm(key.getKeySpec(), algorithm);+ AsymmetricKeys.requireRawMessage(key.getKeySpec(), messageType);+ PrivateKey privateKey = AsymmetricKeys.privateKey(key, "ML-DSA");+ return AsymmetricKeys.sign(privateKey, JCA_ALGORITHM, message);+ }++ @Override+ public boolean verify(KmsKey key, byte[] message, byte[] signature, String algorithm,+ KmsMessageType messageType) throws GeneralSecurityException {+ AsymmetricKeys.requireSpecAlgorithm(key.getKeySpec(), algorithm);+ AsymmetricKeys.requireRawMessage(key.getKeySpec(), messageType);+ PublicKey publicKey = AsymmetricKeys.publicKey(key, "ML-DSA");+ return AsymmetricKeys.verify(publicKey, JCA_ALGORITHM, message, signature);+ }+}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.javanew file mode 100644index 0000000000..938925ef6c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/RsaKeyType.java@@ -0,0 +1,182 @@+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 io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;+import org.bouncycastle.asn1.ASN1ObjectIdentifier;+import org.bouncycastle.asn1.DERNull;+import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;+import org.bouncycastle.asn1.x509.DigestInfo;+import org.bouncycastle.crypto.Digest;+import org.bouncycastle.crypto.digests.SHA256Digest;+import org.bouncycastle.crypto.digests.SHA384Digest;+import org.bouncycastle.crypto.digests.SHA512Digest;+import org.bouncycastle.crypto.engines.RSABlindedEngine;+import org.bouncycastle.crypto.params.ParametersWithRandom;+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;+import javax.crypto.spec.OAEPParameterSpec;+import javax.crypto.spec.PSource;+import java.io.IOException;+import java.security.GeneralSecurityException;+import java.security.KeyPairGenerator;+import java.security.PrivateKey;+import java.security.PublicKey;+import java.security.SecureRandom;+import java.security.spec.MGF1ParameterSpec;++import static io.github.hectorvent.floci.services.kms.model.KmsMessageType.DIGEST;++final class RsaKeyType implements KmsKeyType {++ private static final Logger LOG = Logger.getLogger(RsaKeyType.class);++ private final SecureRandom random;++ RsaKeyType(SecureRandom random) {+ this.random = random;+ }++ @Override+ public void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {+ KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");+ generator.initialize(keySize(key.getKeySpec()));+ AsymmetricKeys.store(key, generator.generateKeyPair());+ }++ @Override+ public byte[] sign(KmsKey key, byte[] message, String algorithm, KmsMessageType messageType) throws Exception {+ PrivateKey privateKey = AsymmetricKeys.privateKey(key, "RSA");+ if (messageType == DIGEST) {+ if (isPss(algorithm)) {+ return signPssDigest(privateKey, message, algorithm);+ }+ // RFC 8017 9.2: PKCS#1 v1.5 signs DigestInfo{hashOID, digest}, not the+ // bare digest, so the signature validates with external verifiers and+ // real KMS (NONEwithRSA only pads the bytes it is given).+ return AsymmetricKeys.sign(privateKey, "NONEwithRSA", wrapInDigestInfo(message, algorithm));+ }+ return AsymmetricKeys.sign(privateKey, KmsKeySpec.getSignVerifyAlgorithm(algorithm).getJavaName(), message);+ }++ @Override+ public boolean verify(KmsKey key, byte[] message, byte[] signature, String algorithm,+ KmsMessageType messageType) throws Exception {+ PublicKey publicKey = AsymmetricKeys.publicKey(key, "RSA");+ // An unknown algorithm name fails even for DIGEST.+ KmsKeySpec.Algorithm signingAlgorithm = KmsKeySpec.getSignVerifyAlgorithm(algorithm);+ if (messageType == DIGEST) {+ if (isPss(algorithm)) {+ return verifyPssDigest(publicKey, message, signature, algorithm);+ }+ // Mirror sign(): verify against DigestInfo{hashOID, digest} (RFC 8017 9.2).+ return AsymmetricKeys.verify(publicKey, "NONEwithRSA", wrapInDigestInfo(message, algorithm), signature);+ }+ return AsymmetricKeys.verify(publicKey, signingAlgorithm.getJavaName(), message, signature);+ }++ @Override+ public byte[] encrypt(KmsKey key, KmsKeySpec.Algorithm algorithm, byte[] plaintext) {+ validatePlaintextLength(plaintext, algorithm, key.getKeySpec());+ return oaep(Cipher.ENCRYPT_MODE, key, algorithm, plaintext);+ }++ @Override+ public byte[] decrypt(KmsKey key, KmsKeySpec.Algorithm algorithm, byte[] ciphertext) {+ return oaep(Cipher.DECRYPT_MODE, key, algorithm, ciphertext);+ }++ private static int keySize(KmsKeySpec spec) {+ return Integer.parseInt(spec.name().substring("RSA_".length()));+ }++ /** RFC 8017 7.1.1: OAEP holds at most k - 2*hLen - 2 bytes, k being the modulus length. */+ private static void validatePlaintextLength(byte[] plaintext, KmsKeySpec.Algorithm algorithm, KmsKeySpec spec) {+ int modulusBytes = keySize(spec) / 8;+ int digestBytes = algorithm == KmsKeySpec.Algorithm.RSAES_OAEP_SHA_1 ? 20 : 32;+ int maxBytes = modulusBytes - 2 * digestBytes - 2;+ if (plaintext.length > maxBytes) {+ throw new AwsException("ValidationException",+ "Algorithm " + algorithm.getAlgName() + " and key spec " + spec.name()+ + " cannot encrypt data larger than " + maxBytes + " bytes.", 400);+ }+ }++ // The JDK OAEP transformations default MGF1 to SHA-1. KMS RSAES_OAEP_SHA_256 uses MGF1 over SHA-256.+ private static byte[] oaep(int mode, KmsKey key, KmsKeySpec.Algorithm algorithm, byte[] input) {+ try {+ String digest = algorithm == KmsKeySpec.Algorithm.RSAES_OAEP_SHA_1 ? "SHA-1" : "SHA-256";+ Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPPadding");+ OAEPParameterSpec params = new OAEPParameterSpec(digest, "MGF1", new MGF1ParameterSpec(digest),+ PSource.PSpecified.DEFAULT);+ if (mode == Cipher.ENCRYPT_MODE) {+ cipher.init(mode, AsymmetricKeys.publicKey(key, "RSA"), params);+ } else {+ cipher.init(mode, AsymmetricKeys.privateKey(key, "RSA"), params);+ }+ return cipher.doFinal(input);+ } catch (Exception e) {+ if (mode == Cipher.DECRYPT_MODE) {+ LOG.debugv(e, "RSA OAEP decrypt failed for key {0}", key.getKeyId());+ throw new AwsException("InvalidCiphertextException", "The ciphertext is invalid.", 400);+ }+ LOG.warnv(e, "RSA OAEP encrypt failed for key {0}", key.getKeyId());+ throw new AwsException("InternalFailure", "Failed to encrypt: " + e.getMessage(), 500);+ }+ }++ private static boolean isPss(String algorithm) {+ return algorithm.startsWith("RSASSA_PSS");+ }++ // NONEwithRSA pads only the bytes it gets, so PKCS#1 v1.5 needs the DigestInfo wrapper (RFC 8017 9.2).+ private static byte[] wrapInDigestInfo(byte[] digest, String algorithm) {+ ASN1ObjectIdentifier hashOid;+ if (algorithm.endsWith("SHA_256")) {+ hashOid = NISTObjectIdentifiers.id_sha256;+ } else if (algorithm.endsWith("SHA_384")) {+ hashOid = NISTObjectIdentifiers.id_sha384;+ } else if (algorithm.endsWith("SHA_512")) {+ hashOid = NISTObjectIdentifiers.id_sha512;+ } else {+ throw new AwsException("InvalidSigningAlgorithmException", "Unsupported algorithm: " + algorithm, 400);+ }+ try {+ return new DigestInfo(new AlgorithmIdentifier(hashOid, DERNull.INSTANCE), digest).getEncoded();+ } catch (IOException e) {+ throw new AwsException("InternalFailure", "Failed to encode DigestInfo: " + e.getMessage(), 500);+ }+ }++ // 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, String algorithm) throws Exception {+ PSSSigner signer = rawPssSigner(algorithm);+ signer.init(true, new ParametersWithRandom(PrivateKeyFactory.createKey(privateKey.getEncoded()), random));+ signer.update(digest, 0, digest.length);+ return signer.generateSignature();+ }++ private static boolean verifyPssDigest(PublicKey publicKey, byte[] digest, byte[] signature, String algorithm)+ throws IOException {+ PSSSigner signer = rawPssSigner(algorithm);+ signer.init(false, PublicKeyFactory.createKey(publicKey.getEncoded()));+ signer.update(digest, 0, digest.length);+ return signer.verifySignature(signature);+ }++ private static PSSSigner rawPssSigner(String algorithm) {+ Digest digest = switch (algorithm) {+ case "RSASSA_PSS_SHA_256" -> new SHA256Digest();+ case "RSASSA_PSS_SHA_384" -> new SHA384Digest();+ case "RSASSA_PSS_SHA_512" -> new SHA512Digest();+ default -> throw new AwsException("InvalidSigningAlgorithmException", "Unsupported algorithm: " + algorithm, 400);+ };+ return PSSSigner.createRawSigner(new RSABlindedEngine(), digest);+ }+}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.javanew file mode 100644index 0000000000..e8185c33ef--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/Sm2KeyType.java@@ -0,0 +1,54 @@+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 io.github.hectorvent.floci.services.kms.model.KmsMessageType;+import org.bouncycastle.crypto.CryptoException;+import org.bouncycastle.crypto.params.ParametersWithRandom;+import org.bouncycastle.crypto.signers.SM2Signer;++import java.io.IOException;+import java.security.GeneralSecurityException;+import java.security.SecureRandom;++final class Sm2KeyType implements KmsKeyType {++ private static final String CURVE = "sm2p256v1";++ private final SecureRandom random;++ Sm2KeyType(SecureRandom random) {+ this.random = random;+ }++ @Override+ public void generateKeyMaterial(KmsKey key, String region) throws GeneralSecurityException {+ if (!region.equals("cn-north-1") && !region.equals("cn-northwest-1")) {+ throw new AwsException("UnsupportedOperationException",+ "KeySpec SM2 is not supported in this Region", 400);+ }+ AsymmetricKeys.store(key, BcEcKeys.generateKeyPair(CURVE));+ }++ @Override+ public byte[] sign(KmsKey key, byte[] message, String algorithm, KmsMessageType messageType)+ throws IOException, CryptoException {+ AsymmetricKeys.requireSpecAlgorithm(key.getKeySpec(), algorithm);+ AsymmetricKeys.requireRawMessage(key.getKeySpec(), messageType);+ SM2Signer signer = new SM2Signer();+ signer.init(true, new ParametersWithRandom(BcEcKeys.privateKeyParameters(key, CURVE), random));+ signer.update(message, 0, message.length);+ return signer.generateSignature();+ }++ @Override+ public boolean verify(KmsKey key, byte[] message, byte[] signature, String algorithm,+ KmsMessageType messageType) throws IOException {+ AsymmetricKeys.requireSpecAlgorithm(key.getKeySpec(), algorithm);+ AsymmetricKeys.requireRawMessage(key.getKeySpec(), messageType);+ SM2Signer verifier = new SM2Signer();+ verifier.init(false, BcEcKeys.publicKeyParameters(key, CURVE));+ verifier.update(message, 0, message.length);+ return verifier.verifySignature(signature);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/keytype/SymmetricKeyType.java b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/SymmetricKeyType.javanew file mode 100644index 0000000000..5938fb870f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kms/keytype/SymmetricKeyType.java@@ -0,0 +1,34 @@+package io.github.hectorvent.floci.services.kms.keytype;++import io.github.hectorvent.floci.services.kms.model.KmsKey;+import io.github.hectorvent.floci.services.kms.model.KmsKeySpec;++import java.security.SecureRandom;+import java.util.Base64;+import java.util.HashMap;+import java.util.UUID;++public final class SymmetricKeyType implements KmsKeyType {++ private final SecureRandom random;++ SymmetricKeyType(SecureRandom random) {+ this.random = random;+ }++ @Override+ public void generateKeyMaterial(KmsKey key, String region) {+ addBackingKey(key);+ }++ public void addBackingKey(KmsKey key) {+ byte[] material = new byte[KmsKeySpec.SYMMETRIC_DEFAULT.materialByteLength()];+ random.nextBytes(material);+ String backingKeyId = UUID.randomUUID().toString();+ if (key.getBackingKeys() == null) {+ key.setBackingKeys(new HashMap<>());+ }+ key.getBackingKeys().put(backingKeyId, Base64.getEncoder().encodeToString(material));+ key.setCurrentBackingKeyId(backingKeyId);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyTypesTest.java b/src/test/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyTypesTest.javanew file mode 100644index 0000000000..77af8a0ff7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kms/keytype/KmsKeyTypesTest.java@@ -0,0 +1,259 @@+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 io.github.hectorvent.floci.services.kms.model.KmsKeySpec;+import io.github.hectorvent.floci.services.kms.model.KmsMessageType;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.EnumSource;+import org.junit.jupiter.params.provider.ValueSource;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.nio.charset.StandardCharsets;+import java.security.GeneralSecurityException;+import java.security.MessageDigest;+import java.security.SecureRandom;+import java.util.Base64;+import java.util.EnumMap;+import java.util.HashMap;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.*;++class KmsKeyTypesTest {++ private static final String REGION = "us-east-1";+ private static final byte[] MESSAGE = "per key type".getBytes(StandardCharsets.UTF_8);++ private final KmsKeyTypes keyTypes = new KmsKeyTypes(new SecureRandom());++ @Test+ void everyKeySpecHasItsOwnKeyType() {+ Map<KmsKeySpec, Class<? extends KmsKeyType>> expected = new EnumMap<>(KmsKeySpec.class);+ expected.put(KmsKeySpec.SYMMETRIC_DEFAULT, SymmetricKeyType.class);+ expected.put(KmsKeySpec.RSA_2048, RsaKeyType.class);+ expected.put(KmsKeySpec.RSA_3072, RsaKeyType.class);+ expected.put(KmsKeySpec.RSA_4096, RsaKeyType.class);+ expected.put(KmsKeySpec.ECC_NIST_P256, EccNistKeyType.class);+ expected.put(KmsKeySpec.ECC_NIST_P384, EccNistKeyType.class);+ expected.put(KmsKeySpec.ECC_NIST_P521, EccNistKeyType.class);+ expected.put(KmsKeySpec.ECC_NIST_EDWARDS25519, Ed25519KeyType.class);+ expected.put(KmsKeySpec.ECC_SECG_P256K1, EccSecgP256k1KeyType.class);+ expected.put(KmsKeySpec.HMAC_224, HmacKeyType.class);+ expected.put(KmsKeySpec.HMAC_256, HmacKeyType.class);+ expected.put(KmsKeySpec.HMAC_384, HmacKeyType.class);+ expected.put(KmsKeySpec.HMAC_512, HmacKeyType.class);+ expected.put(KmsKeySpec.SM2, Sm2KeyType.class);+ expected.put(KmsKeySpec.ML_DSA_44, MlDsaKeyType.class);+ expected.put(KmsKeySpec.ML_DSA_65, MlDsaKeyType.class);+ expected.put(KmsKeySpec.ML_DSA_87, MlDsaKeyType.class);++ assertEquals(KmsKeySpec.values().length, expected.size());+ for (Map.Entry<KmsKeySpec, Class<? extends KmsKeyType>> entry : expected.entrySet()) {+ assertEquals(entry.getValue(), keyTypes.of(entry.getKey()).getClass(), entry.getKey().name());+ }+ }++ @Test+ void addingABackingKeyKeepsEarlierOnes() throws GeneralSecurityException {+ KmsKey key = generatedKey(KmsKeySpec.SYMMETRIC_DEFAULT, REGION);+ String first = key.getCurrentBackingKeyId();++ keyTypes.symmetric().addBackingKey(key);++ assertNotEquals(first, key.getCurrentBackingKeyId());+ assertEquals(2, key.getBackingKeys().size());+ assertTrue(key.getBackingKeys().containsKey(first));+ for (String material : key.getBackingKeys().values()) {+ assertEquals(32, Base64.getDecoder().decode(material).length);+ }+ }++ @Test+ void addingABackingKeyStartsAMissingMap() {+ KmsKey key = newKey(KmsKeySpec.SYMMETRIC_DEFAULT);+ key.setBackingKeys(null);++ keyTypes.symmetric().addBackingKey(key);++ assertEquals(1, key.getBackingKeys().size());+ assertTrue(key.getBackingKeys().containsKey(key.getCurrentBackingKeyId()));+ }++ @ParameterizedTest+ @CsvSource({+ "HMAC_224, HMAC_SHA_224, HmacSHA224",+ "HMAC_256, HMAC_SHA_256, HmacSHA256",+ "HMAC_384, HMAC_SHA_384, HmacSHA384",+ "HMAC_512, HMAC_SHA_512, HmacSHA512",+ })+ void hmacMatchesTheJdkMacOverTheGeneratedMaterial(KmsKeySpec spec, String algorithm, String jcaAlgorithm)+ throws GeneralSecurityException {+ KmsKey key = generatedKey(spec, REGION);+ byte[] material = Base64.getDecoder().decode(key.getPrivateKeyEncoded());+ Mac mac = Mac.getInstance(jcaAlgorithm);+ mac.init(new SecretKeySpec(material, jcaAlgorithm));++ assertEquals(spec.materialByteLength(), material.length);+ assertArrayEquals(mac.doFinal(MESSAGE), keyTypes.of(spec).generateMac(key, MESSAGE, algorithm));+ }++ @ParameterizedTest+ @CsvSource({+ "RSA_2048, RSASSA_PKCS1_V1_5_SHA_256",+ "RSA_2048, RSASSA_PKCS1_V1_5_SHA_384",+ "RSA_2048, RSASSA_PSS_SHA_256",+ "RSA_2048, RSASSA_PSS_SHA_512",+ "ECC_NIST_P256, ECDSA_SHA_256",+ "ECC_NIST_P384, ECDSA_SHA_384",+ "ECC_NIST_P521, ECDSA_SHA_512",+ "ECC_SECG_P256K1, ECDSA_SHA_256",+ "ECC_NIST_EDWARDS25519, ED25519_SHA_512",+ "ML_DSA_44, ML_DSA_SHAKE_256",+ })+ void rawSignatureVerifiesOnlyForTheSignedMessage(KmsKeySpec spec, String algorithm) throws Exception {+ KmsKey key = generatedKey(spec, REGION);+ KmsKeyType keyType = keyTypes.of(spec);++ byte[] signature = keyType.sign(key, MESSAGE, algorithm, KmsMessageType.RAW);++ assertTrue(keyType.verify(key, MESSAGE, signature, algorithm, KmsMessageType.RAW));+ assertFalse(keyType.verify(key, "another message".getBytes(StandardCharsets.UTF_8), signature,+ algorithm, KmsMessageType.RAW));+ }++ @ParameterizedTest+ @CsvSource({+ "RSA_2048, RSASSA_PKCS1_V1_5_SHA_256, SHA-256",+ "RSA_2048, RSASSA_PSS_SHA_384, SHA-384",+ "ECC_NIST_P256, ECDSA_SHA_256, SHA-256",+ "ECC_SECG_P256K1, ECDSA_SHA_256, SHA-256",+ })+ void digestSignatureVerifiesAsARawSignature(KmsKeySpec spec, String algorithm, String digestAlgorithm)+ throws Exception {+ KmsKey key = generatedKey(spec, REGION);+ KmsKeyType keyType = keyTypes.of(spec);+ byte[] digest = MessageDigest.getInstance(digestAlgorithm).digest(MESSAGE);++ byte[] signature = keyType.sign(key, digest, algorithm, KmsMessageType.DIGEST);++ assertTrue(keyType.verify(key, MESSAGE, signature, algorithm, KmsMessageType.RAW));+ assertTrue(keyType.verify(key, digest, signature, algorithm, KmsMessageType.DIGEST));+ }++ @Test+ void ed25519PreHashSignsTheSha512DigestOfTheMessage() throws Exception {+ KmsKey key = generatedKey(KmsKeySpec.ECC_NIST_EDWARDS25519, REGION);+ KmsKeyType keyType = keyTypes.of(KmsKeySpec.ECC_NIST_EDWARDS25519);+ byte[] digest = MessageDigest.getInstance("SHA-512").digest(MESSAGE);++ byte[] signature = keyType.sign(key, digest, "ED25519_PH_SHA_512", KmsMessageType.DIGEST);++ assertTrue(keyType.verify(key, digest, signature, "ED25519_PH_SHA_512", KmsMessageType.DIGEST));+ }++ @ParameterizedTest+ @EnumSource(value = KmsKeySpec.class, names = {"ECC_NIST_EDWARDS25519", "ML_DSA_65", "SM2"})+ void keyTypesWithOneSigningAlgorithmRejectAnyOther(KmsKeySpec spec) throws GeneralSecurityException {+ KmsKey key = generatedKey(spec, "cn-north-1");++ AwsException exception = assertThrows(AwsException.class,+ () -> keyTypes.of(spec).sign(key, MESSAGE, "ECDSA_SHA_256", KmsMessageType.RAW));++ assertEquals("InvalidKeyUsageException", exception.getErrorCode());+ assertEquals("Algorithm ECDSA_SHA_256 is incompatible with key spec " + spec.name() + ".",+ exception.getMessage());+ }++ @ParameterizedTest+ @ValueSource(strings = {"RSAES_OAEP_SHA_1", "RSAES_OAEP_SHA_256"})+ void rsaEncryptionRoundTrips(String algorithmName) throws GeneralSecurityException {+ KmsKeySpec.Algorithm algorithm = KmsKeySpec.Algorithm.valueOf(algorithmName);+ KmsKey key = generatedKey(KmsKeySpec.RSA_2048, REGION);+ KmsKeyType keyType = keyTypes.of(KmsKeySpec.RSA_2048);++ byte[] ciphertext = keyType.encrypt(key, algorithm, MESSAGE);++ assertEquals(256, ciphertext.length);+ assertArrayEquals(MESSAGE, keyType.decrypt(key, algorithm, ciphertext));+ }++ @Test+ void rsaEncryptionRejectsPlaintextOverTheOaepLimit() throws GeneralSecurityException {+ KmsKey key = generatedKey(KmsKeySpec.RSA_2048, REGION);+ KmsKeyType keyType = keyTypes.of(KmsKeySpec.RSA_2048);++ keyType.encrypt(key, KmsKeySpec.Algorithm.RSAES_OAEP_SHA_256, new byte[190]);+ AwsException exception = assertThrows(AwsException.class,+ () -> keyType.encrypt(key, KmsKeySpec.Algorithm.RSAES_OAEP_SHA_256, new byte[191]));++ assertEquals("ValidationException", exception.getErrorCode());+ assertEquals("Algorithm RSAES_OAEP_SHA_256 and key spec RSA_2048 cannot encrypt data larger than 190 bytes.",+ exception.getMessage());+ }++ @Test+ void rsaDecryptionOfForeignCiphertextIsInvalidCiphertext() throws GeneralSecurityException {+ KmsKey key = generatedKey(KmsKeySpec.RSA_2048, REGION);+ KmsKey other = generatedKey(KmsKeySpec.RSA_2048, REGION);+ KmsKeyType keyType = keyTypes.of(KmsKeySpec.RSA_2048);+ byte[] ciphertext = keyType.encrypt(other, KmsKeySpec.Algorithm.RSAES_OAEP_SHA_256, MESSAGE);++ AwsException exception = assertThrows(AwsException.class,+ () -> keyType.decrypt(key, KmsKeySpec.Algorithm.RSAES_OAEP_SHA_256, ciphertext));++ assertEquals("InvalidCiphertextException", exception.getErrorCode());+ }++ @ParameterizedTest+ @ValueSource(strings = {"cn-north-1", "cn-northwest-1"})+ void sm2SignsInChinaRegions(String region) throws Exception {+ KmsKey key = generatedKey(KmsKeySpec.SM2, region);+ KmsKeyType keyType = keyTypes.of(KmsKeySpec.SM2);++ byte[] signature = keyType.sign(key, MESSAGE, "SM2DSA", KmsMessageType.RAW);++ assertTrue(keyType.verify(key, MESSAGE, signature, "SM2DSA", KmsMessageType.RAW));+ }++ @Test+ void sm2KeyMaterialIsRefusedOutsideChinaRegions() {+ KmsKey key = newKey(KmsKeySpec.SM2);++ AwsException exception = assertThrows(AwsException.class,+ () -> keyTypes.of(KmsKeySpec.SM2).generateKeyMaterial(key, REGION));++ assertEquals("UnsupportedOperationException", exception.getErrorCode());+ assertNull(key.getPrivateKeyEncoded());+ }++ @ParameterizedTest+ @EnumSource(value = KmsKeySpec.class, names = {"SYMMETRIC_DEFAULT", "HMAC_256"})+ void keyTypesWithoutSigningRefuseToSignAndNeverVerify(KmsKeySpec spec) throws Exception {+ KmsKey key = generatedKey(spec, REGION);+ KmsKeyType keyType = keyTypes.of(spec);++ AwsException exception = assertThrows(AwsException.class,+ () -> keyType.sign(key, MESSAGE, "RSASSA_PSS_SHA_256", KmsMessageType.RAW));++ assertEquals("UnsupportedOperationException", exception.getErrorCode());+ assertFalse(keyType.verify(key, MESSAGE, new byte[64], "RSASSA_PSS_SHA_256", KmsMessageType.RAW));+ }++ private KmsKey generatedKey(KmsKeySpec spec, String region) throws GeneralSecurityException {+ KmsKey key = newKey(spec);+ keyTypes.of(spec).generateKeyMaterial(key, region);+ return key;+ }++ private static KmsKey newKey(KmsKeySpec spec) {+ KmsKey key = new KmsKey();+ key.setKeyId("key-" + spec.name());+ key.setKeySpec(spec);+ key.setBackingKeys(new HashMap<>());+ return key;+ }+}