Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(kms): support SM2 signing in China regions (#3046)

Aniket Shukla5198cf29ec4d
diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
index e0093e701c..a74b9b0db9 100644
--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
@@ -646,9 +646,13 @@ public final class TestFixtures {
}
public static KmsClient kmsClient() {
+ return kmsClient(REGION);
+ }
+
+ public static KmsClient kmsClient(Region region) {
return KmsClient.builder()
.endpointOverride(ENDPOINT)
- .region(REGION)
+ .region(region)
.credentialsProvider(CREDENTIALS)
.build();
}
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KmsSm2Test.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KmsSm2Test.java
new file mode 100644
index 0000000000..99a781fce0
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KmsSm2Test.java
@@ -0,0 +1,93 @@
+package com.floci.test;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.awssdk.core.SdkBytes;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.kms.KmsClient;
+import software.amazon.awssdk.services.kms.model.KeySpec;
+import software.amazon.awssdk.services.kms.model.KeyUsageType;
+import software.amazon.awssdk.services.kms.model.KmsException;
+import software.amazon.awssdk.services.kms.model.MessageType;
+import software.amazon.awssdk.services.kms.model.SigningAlgorithmSpec;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class KmsSm2Test {
+
+ @ParameterizedTest
+ @ValueSource(strings = {"cn-north-1", "cn-northwest-1"})
+ void signAndVerifyUseSm2dsaWireAlgorithm(String region) {
+ try (KmsClient kms = TestFixtures.kmsClient(Region.of(region))) {
+ var key = kms.createKey(b -> b.keySpec(KeySpec.SM2).keyUsage(KeyUsageType.SIGN_VERIFY));
+ String keyId = key.keyMetadata().keyId();
+ try {
+ assertThat(key.keyMetadata().signingAlgorithms()).containsExactly(SigningAlgorithmSpec.SM2_DSA);
+ var publicKey = kms.getPublicKey(b -> b.keyId(keyId));
+ assertThat(publicKey.signingAlgorithms()).containsExactly(SigningAlgorithmSpec.SM2_DSA);
+ assertThat(publicKey.publicKey().asByteArray()).isNotEmpty();
+
+ var message = SdkBytes.fromUtf8String("SM2 SDK wire compatibility");
+ var signed = kms.sign(b -> b.keyId(keyId)
+ .message(message)
+ .messageType(MessageType.RAW)
+ .signingAlgorithm(SigningAlgorithmSpec.SM2_DSA));
+ assertThat(signed.signingAlgorithm()).isEqualTo(SigningAlgorithmSpec.SM2_DSA);
+ assertThat(signed.signingAlgorithmAsString()).isEqualTo("SM2DSA");
+ assertThat(signed.signature().asByteArray()).isNotEmpty();
+
+ var verified = kms.verify(b -> b.keyId(keyId)
+ .message(message)
+ .messageType(MessageType.RAW)
+ .signature(signed.signature())
+ .signingAlgorithm(SigningAlgorithmSpec.SM2_DSA));
+ assertThat(verified.signingAlgorithm()).isEqualTo(SigningAlgorithmSpec.SM2_DSA);
+ assertThat(verified.signingAlgorithmAsString()).isEqualTo("SM2DSA");
+ assertThat(verified.signatureValid()).isTrue();
+ } finally {
+ kms.scheduleKeyDeletion(b -> b.keyId(keyId).pendingWindowInDays(7));
+ }
+ }
+ }
+
+ @ParameterizedTest
+ @CsvSource({
+ "cn-north-1, ECDSA_SHA_256, RAW, InvalidKeyUsageException",
+ "cn-northwest-1, ECDSA_SHA_256, RAW, InvalidKeyUsageException",
+ "cn-north-1, SM2DSA, DIGEST, ValidationException",
+ "cn-northwest-1, SM2DSA, DIGEST, ValidationException"
+ })
+ void signAndVerifyRejectInvalidSm2Parameters(String region, String algorithm,
+ MessageType messageType, String errorCode) {
+ try (KmsClient kms = TestFixtures.kmsClient(Region.of(region))) {
+ var key = kms.createKey(b -> b.keySpec(KeySpec.SM2).keyUsage(KeyUsageType.SIGN_VERIFY));
+ String keyId = key.keyMetadata().keyId();
+ try {
+ var message = SdkBytes.fromByteArray(new byte[32]);
+ var signature = kms.sign(b -> b.keyId(keyId)
+ .message(message)
+ .messageType(MessageType.RAW)
+ .signingAlgorithm(SigningAlgorithmSpec.SM2_DSA)).signature();
+
+ var signError = assertThrows(KmsException.class, () -> kms.sign(b -> b.keyId(keyId)
+ .message(message)
+ .messageType(messageType)
+ .signingAlgorithm(algorithm)));
+ assertThat(signError.statusCode()).isEqualTo(400);
+ assertThat(signError.awsErrorDetails().errorCode()).isEqualTo(errorCode);
+
+ var verifyError = assertThrows(KmsException.class, () -> kms.verify(b -> b.keyId(keyId)
+ .message(message)
+ .messageType(messageType)
+ .signature(signature)
+ .signingAlgorithm(algorithm)));
+ assertThat(verifyError.statusCode()).isEqualTo(400);
+ assertThat(verifyError.awsErrorDetails().errorCode()).isEqualTo(errorCode);
+ } finally {
+ kms.scheduleKeyDeletion(b -> b.keyId(keyId).pendingWindowInDays(7));
+ }
+ }
+ }
+}
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.java
index 9195958dc8..1eeed08165 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
@@ -44,6 +44,7 @@ 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;
@@ -191,7 +192,7 @@ public class KmsService implements ResourceProvider {
key.setKeyState(PENDING_IMPORT);
key.setEnabled(false);
} else {
- generateKeyMaterial(key);
+ generateKeyMaterial(key, region);
}
keyStore.put(region + "::" + keyId, key);
@@ -216,7 +217,7 @@ public class KmsService implements ResourceProvider {
return normalized;
}
- private void generateKeyMaterial(KmsKey key) {
+ private void generateKeyMaterial(KmsKey key, String region) {
KmsKeySpec spec = key.getKeySpec();
try {
switch (spec.getKeyType()) {
@@ -262,6 +263,17 @@ public class KmsService implements ResourceProvider {
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);
}
@@ -1444,18 +1456,25 @@ public class KmsService implements ResourceProvider {
}
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);
}
@@ -1495,18 +1514,25 @@ public class KmsService implements ResourceProvider {
}
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)) {
@@ -1626,7 +1652,7 @@ public class KmsService implements ResourceProvider {
private PrivateKey loadPrivateKey(String encoded, KmsKeySpec spec) throws Exception {
byte[] decoded = Base64.getDecoder().decode(encoded);
- if (isSecgP256k1(spec)) {
+ 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.
@@ -1638,7 +1664,7 @@ public class KmsService implements ResourceProvider {
private PublicKey loadPublicKey(String encoded, KmsKeySpec spec) throws Exception {
byte[] decoded = Base64.getDecoder().decode(encoded);
- if (isSecgP256k1(spec)) {
+ if (isSecgP256k1(spec) || isSm2(spec)) {
AsymmetricKeyInfoConverter converter = new KeyFactorySpi.EC();
return converter.generatePublic(SubjectPublicKeyInfo.getInstance(decoded));
}
@@ -1710,6 +1736,43 @@ public class KmsService implements ResourceProvider {
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.
*
diff --git a/src/main/java/io/github/hectorvent/floci/services/kms/model/KmsKeySpec.java b/src/main/java/io/github/hectorvent/floci/services/kms/model/KmsKeySpec.java
index 10a812ae37..f9d54b261b 100644
--- a/src/main/java/io/github/hectorvent/floci/services/kms/model/KmsKeySpec.java
+++ b/src/main/java/io/github/hectorvent/floci/services/kms/model/KmsKeySpec.java
@@ -27,7 +27,7 @@ public enum KmsKeySpec {
HMAC_384(KeyType.HMAC, Algorithm.HMAC_SHA_384),
HMAC_512(KeyType.HMAC, Algorithm.HMAC_SHA_512),
- SM2(KeyType.SM2, Algorithm.SM2_DSA),
+ SM2(KeyType.SM2, Algorithm.SM2DSA),
ML_DSA_44(KeyType.ML_DSA, Algorithm.ML_DSA_SHAKE_256),
ML_DSA_65(KeyType.ML_DSA, Algorithm.ML_DSA_SHAKE_256),
@@ -152,7 +152,7 @@ public enum KmsKeySpec {
ECDSA_SHA_512("ECDSA_SHA_512", "SHA512withECDSA", KmsKeyUsage.SIGN_VERIFY),
ED25519_SHA_512("ED25519_SHA_512","Ed25519", KmsKeyUsage.SIGN_VERIFY),
ED25519_PH_SHA_512("ED25519_PH_SHA_512", "Ed25519", KmsKeyUsage.SIGN_VERIFY),
- SM2_DSA("SM2DSA","", KmsKeyUsage.SIGN_VERIFY),
+ SM2DSA("SM2DSA","", KmsKeyUsage.SIGN_VERIFY),
ML_DSA_SHAKE_256("ML_DSA_SHAKE_256", "ML-DSA", KmsKeyUsage.SIGN_VERIFY),
HMAC_SHA_224("HMAC_SHA_224",""),
HMAC_SHA_256("HMAC_SHA_256",""),
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.java
index cf4807e201..bd25f9cdfe 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
@@ -1195,6 +1195,19 @@ class KmsIntegrationTest {
.body("KeyMetadata.KeySpec", equalTo("ECC_NIST_P256"));
}
+ @Test
+ void createSm2KeyReportsRegionUnsupportedOperation() {
+ given()
+ .header("X-Amz-Target", "TrentService.CreateKey")
+ .contentType(KMS_CONTENT_TYPE)
+ .body("{\"KeyUsage\":\"SIGN_VERIFY\",\"KeySpec\":\"SM2\"}")
+ .when().post("/")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("UnsupportedOperationException"))
+ .body("message", equalTo("KeySpec SM2 is not supported in this Region"));
+ }
+
// ── Issue #1528 — ListKeyPolicies ────────────────────────────────────────
@Test
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.java
index 527af380d4..6639c08832 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
@@ -78,6 +78,31 @@ class KmsServiceTest {
assertEquals("Enabled", key.getKeyState());
}
+ @ParameterizedTest
+ @ValueSource(strings = {"us-east-1", "cn-fake-1"})
+ void createSm2KeyReportsRegionUnsupportedOperation(String region) {
+ AwsException exception = assertThrows(AwsException.class, () ->
+ kmsService.createKey(null, "SIGN_VERIFY", "SM2", null, Map.of(), region));
+
+ assertEquals("UnsupportedOperationException", exception.getErrorCode());
+ assertEquals("KeySpec SM2 is not supported in this Region", exception.getMessage());
+ assertEquals(400, exception.getHttpStatus());
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"cn-north-1", "cn-northwest-1"})
+ void createSm2KeySucceedsInChinaRegions(String region) {
+ KmsKey key = kmsService.createKey(null, "SIGN_VERIFY", "SM2", null, Map.of(), region);
+ byte[] message = "SM2 regional signing".getBytes(StandardCharsets.UTF_8);
+ byte[] signature = kmsService.sign(key.getKeyId(), message, "SM2DSA", region);
+
+ assertEquals(KmsKeySpec.SM2, key.getKeySpec());
+ assertEquals(KmsKeyUsage.SIGN_VERIFY, key.getKeyUsage());
+ assertNotNull(key.getPrivateKeyEncoded());
+ assertNotNull(key.getPublicKeyEncoded());
+ assertTrue(kmsService.verify(key.getKeyId(), message, signature, "SM2DSA", region));
+ }
+
@Test
void updateKeyDescriptionPersistsDescription() {
KmsKey key = kmsService.createKey("old description", REGION);