Investigating issues with ECDSA_SECP256k1

src/main/kotlin/org/onflow/flow/sdk/crypto/Crypto.kt

@@ -220,13 +220,17 @@ internal class SignerImpl(
         if (hashAlgo == HashAlgorithm.KECCAK256 || hashAlgo == HashAlgorithm.KMAC128) {
             // Handle Keccak-256 and KMAC128 separately
             val hash = hasher.hash(bytes)
-            val ecdsaSign = Signature.getInstance("NONEwithECDSA")
-            ecdsaSign.initSign(privateKey.key)
-            ecdsaSign.update(hash)
-            signature = ecdsaSign.sign()
+            val noneEcdsaSign = Signature.getInstance("NONEwithECDSA", "BC")
+            noneEcdsaSign.initSign(privateKey.key)
+            noneEcdsaSign.update(hash)
+            signature = noneEcdsaSign.sign()
         } else {
             // Handle other algorithms with valid IDs
-            val ecdsaSign = Signature.getInstance(hashAlgo.id)
+            val ecdsaSign = if (privateKey.key.algorithm == "EC" && privateKey.key is ECPrivateKey) {
+                Signature.getInstance("ECDSA", "BC")
+            } else {
+                Signature.getInstance(hashAlgo.id)
+            }
             ecdsaSign.initSign(privateKey.key)
             ecdsaSign.update(bytes)
             signature = ecdsaSign.sign()

src/main/kotlin/org/onflow/flow/sdk/models.kt

@@ -48,7 +48,6 @@ enum class FlowChainId(
             ?: UNKNOWN
     }
 }
-
 enum class SignatureAlgorithm(
     val algorithm: String,
     val curve: String,
@@ -58,7 +57,7 @@ enum class SignatureAlgorithm(
 ) {
     UNKNOWN("unknown", "unknown", "unknown", -1, 0),
     ECDSA_P256("ECDSA", "P-256", "ECDSA_P256", 2, 1),
-    ECDSA_SECP256k1("ECDSA", "secp256k1", "ECDSA_secp256k1", 3, 2);
+    ECDSA_SECP256k1("ECDSA", "secp256k1", "ECDSA_SECP256k1", 3, 2);
 
     companion object {
         @JvmStatic

src/test/kotlin/org/onflow/flow/sdk/crypto/CryptoTest.kt

@@ -1,9 +1,12 @@
 package org.onflow.flow.sdk.crypto
 
+import org.bouncycastle.jce.provider.BouncyCastleProvider
 import org.onflow.flow.sdk.HashAlgorithm
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
+import org.onflow.flow.sdk.SignatureAlgorithm
 import java.math.BigInteger
+import java.security.Security
 import java.security.Signature
 
 internal class CryptoTest {
@@ -60,6 +63,13 @@ internal class CryptoTest {
         assertNotNull(signer)
     }
 
+    @Test
+    fun `Get signer for ECDSA_SECP256k1`() {
+        val keyPair = Crypto.generateKeyPair(SignatureAlgorithm.ECDSA_SECP256k1)
+        val signer = Crypto.getSigner(keyPair.private, HashAlgorithm.SHA3_256)
+        assertNotNull(signer)
+    }
+
     @Test
     fun `Get hasher`() {
         val hasher = Crypto.getHasher()
@@ -82,6 +92,23 @@ internal class CryptoTest {
         assertEquals(expectedLength, normalizedSignature.size)
     }
 
+    @Test
+    fun `Test normalizeSignature for ECDSA_SECP256k1`() {
+        Security.addProvider(BouncyCastleProvider())
+        val keyPair = Crypto.generateKeyPair(SignatureAlgorithm.ECDSA_SECP256k1)
+
+        val ecdsaSign = Signature.getInstance(HashAlgorithm.SHA3_256.id, "BC")
+        ecdsaSign.initSign(keyPair.private.key)
+        ecdsaSign.update("test".toByteArray())
+
+        val signature = ecdsaSign.sign()
+
+        val normalizedSignature = Crypto.normalizeSignature(signature, keyPair.private.ecCoupleComponentSize)
+
+        val expectedLength = 2 * keyPair.private.ecCoupleComponentSize
+        assertEquals(expectedLength, normalizedSignature.size)
+    }
+
     @Test
     fun `Test extractRS`() {
         val keyPair = Crypto.generateKeyPair()
@@ -99,6 +126,24 @@ internal class CryptoTest {
         assertTrue(s > BigInteger.ZERO)
     }
 
+    @Test
+    fun `Test extractRS for ECDSA_SECP256k1`() {
+        Security.addProvider(BouncyCastleProvider())
+        val keyPair = Crypto.generateKeyPair(SignatureAlgorithm.ECDSA_SECP256k1)
+
+        val ecdsaSign = Signature.getInstance(HashAlgorithm.SHA3_256.id, "BC")
+        ecdsaSign.initSign(keyPair.private.key)
+
+        ecdsaSign.update("test".toByteArray())
+
+        val signature = ecdsaSign.sign()
+
+        val (r, s) = Crypto.extractRS(signature)
+
+        assertTrue(r > BigInteger.ZERO)
+        assertTrue(s > BigInteger.ZERO)
+    }
+
     @Test
     fun `Hasher implementation`() {
         val hasher = HasherImpl(HashAlgorithm.SHA3_256)
@@ -239,4 +284,22 @@ internal class CryptoTest {
         val signature = signer.sign("test".toByteArray())
         assertNotNull(signature)
     }
+
+    @Test
+    fun `Signer implementation for ECDSA_SECP256k1`() {
+        val keyPair = Crypto.generateKeyPair(SignatureAlgorithm.ECDSA_SECP256k1)
+        val signer = SignerImpl(keyPair.private, HashAlgorithm.SHA3_256)
+        val signature = signer.sign("test".toByteArray())
+        assertNotNull(signature)
+    }
+
+    @Test
+    fun `Signer implementation for ECDSA_SECP256k1 and non-standard hasher`() {
+        val keyPair = Crypto.generateKeyPair(SignatureAlgorithm.ECDSA_SECP256k1)
+        val key = "thisKeyIsAtLeast16Bytes".toByteArray()
+        val hasher = HasherImpl(HashAlgorithm.KMAC128, key)
+        val signer = SignerImpl(keyPair.private, HashAlgorithm.KMAC128, hasher)
+        val signature = signer.sign("test".toByteArray())
+        assertNotNull(signature)
+    }
 }