misc: merge from main

Author: aws-sdk-kotlin-ci

runtime/runtime-core/api/runtime-core.api

@@ -729,6 +729,10 @@ public final class aws/smithy/kotlin/runtime/hashing/EcdsaJVMKt {
 	public static final fun ecdsaSecp256r1 ([B[B)[B
 }
 
+public final class aws/smithy/kotlin/runtime/hashing/EcdsaKt {
+	public static final fun ecdsaSecp256r1Rs ([B[B)[B
+}
+
 public abstract interface class aws/smithy/kotlin/runtime/hashing/HashFunction {
 	public abstract fun digest ()[B
 	public abstract fun getBlockSizeBytes ()I

runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/hashing/Ecdsa.kt

@@ -5,6 +5,41 @@
 package aws.smithy.kotlin.runtime.hashing
 
 /**
- * ECDSA on the SECP256R1 curve.
+ * ECDSA on the SECP256R1 curve returning ASN.1 DER format.
  */
 public expect fun ecdsaSecp256r1(key: ByteArray, message: ByteArray): ByteArray
+
+/**
+ * ECDSA on the SECP256R1 curve returning raw r||s format.
+ */
+public fun ecdsaSecp256r1Rs(key: ByteArray, message: ByteArray): ByteArray {
+    val derSignature = ecdsaSecp256r1(key, message)
+    return parseDerSignature(derSignature)
+}
+
+/**
+ * Parses an ASN.1 DER encoded ECDSA signature and converts it to raw r||s format.
+ */
+private fun parseDerSignature(derSignature: ByteArray): ByteArray {
+    var index = 2 // Skip SEQUENCE tag and length
+
+    // Read r
+    index++ // Skip INTEGER tag
+    val rLength = derSignature[index++].toInt() and 0xFF
+    val r = derSignature.sliceArray(index until index + rLength)
+    index += rLength
+
+    // Read s
+    index++ // Skip INTEGER tag
+    val sLength = derSignature[index++].toInt() and 0xFF
+    val s = derSignature.sliceArray(index until index + sLength)
+
+    // Remove leading zero bytes and pad to 32 bytes
+    val rFixed = r.dropWhile { it == 0.toByte() }.toByteArray()
+    val sFixed = s.dropWhile { it == 0.toByte() }.toByteArray()
+
+    val rPadded = if (rFixed.size < 32) ByteArray(32 - rFixed.size) + rFixed else rFixed
+    val sPadded = if (sFixed.size < 32) ByteArray(32 - sFixed.size) + sFixed else sFixed
+
+    return rPadded + sPadded
+}

runtime/runtime-core/jvm/test/aws/smithy/kotlin/runtime/hashing/EcdsaJVMTest.kt

@@ -6,6 +6,8 @@ package aws.smithy.kotlin.runtime.hashing
 
 import org.junit.jupiter.api.Assertions.assertFalse
 import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.condition.EnabledForJreRange
+import org.junit.jupiter.api.condition.JRE
 import java.security.*
 import java.security.interfaces.*
 import java.security.spec.*
@@ -30,6 +32,10 @@ class EcdsaJVMTest {
 
         assertTrue(signature.isNotEmpty())
         assertTrue(signature.size >= 64) // ECDSA signatures are typically 70-72 bytes in DER format
+
+        val rawSignature = ecdsaSecp256r1Rs(privateKey, message)
+        assertTrue(signature.isNotEmpty())
+        assertTrue(rawSignature.size == 64)
     }
 
     @Test
@@ -44,6 +50,13 @@ class EcdsaJVMTest {
         assertTrue(signature1.isNotEmpty())
         assertTrue(signature2.isNotEmpty())
         assertFalse(signature1.contentEquals(signature2))
+
+        val rawSignature1 = ecdsaSecp256r1Rs(privateKey, message1)
+        val rawSignature2 = ecdsaSecp256r1Rs(privateKey, message2)
+
+        assertTrue(rawSignature1.isNotEmpty())
+        assertTrue(rawSignature2.isNotEmpty())
+        assertFalse(rawSignature1.contentEquals(rawSignature2))
     }
 
     @Test
@@ -53,6 +66,9 @@ class EcdsaJVMTest {
 
         val signature = ecdsaSecp256r1(privateKey, message)
         assertTrue(signature.isNotEmpty())
+
+        val rawSignature = ecdsaSecp256r1Rs(privateKey, message)
+        assertTrue(rawSignature.isNotEmpty())
     }
 
     @Test
@@ -62,6 +78,9 @@ class EcdsaJVMTest {
 
         val signature = ecdsaSecp256r1(privateKey, largeMessage)
         assertTrue(signature.isNotEmpty())
+
+        val rawSignature = ecdsaSecp256r1Rs(privateKey, largeMessage)
+        assertTrue(rawSignature.isNotEmpty())
     }
 
     @Test
@@ -81,4 +100,24 @@ class EcdsaJVMTest {
 
         assertTrue(verifier.verify(signature))
     }
+
+    @Test
+    // SHA256withECDSAinP1363Format algorithm was introduced in Java 11, skip on Java 8
+    @EnabledForJreRange(min = JRE.JAVA_11)
+    fun testVerifyRawSignature() {
+        val keyGen = KeyPairGenerator.getInstance("EC")
+        keyGen.initialize(ECGenParameterSpec("secp256r1"))
+        val keyPair = keyGen.generateKeyPair()
+        val privateKey = (keyPair.private as ECPrivateKey).s.toByteArray()
+        val publicKey = keyPair.public
+
+        val message = "Hello, World!".toByteArray()
+        val signature = ecdsaSecp256r1Rs(privateKey, message)
+
+        val verifier = Signature.getInstance("SHA256withECDSAinP1363Format")
+        verifier.initVerify(publicKey)
+        verifier.update(message)
+
+        assertTrue(verifier.verify(signature))
+    }
 }