FDP-3254: Removal of KeyProvider interface, otherwise you have to create the SingingUtil for every public and private key (#93)

Author: JelleHoffman

oslp-message-signing/src/main/kotlin/com/gxf/utilities/oslp/message/signing/KeyProvider.kt

@@ -5,27 +5,29 @@ package com.gxf.utilities.oslp.message.signing
 
 import com.gxf.utilities.oslp.message.signing.configuration.SigningProperties
 import io.github.oshai.kotlinlogging.KotlinLogging
+import java.security.PrivateKey
+import java.security.PublicKey
 import java.security.SecureRandom
 import java.security.Signature
 
-open class SigningUtil(val signingConfiguration: SigningProperties, val keyProvider: KeyProvider) {
+open class SigningUtil(val signingConfiguration: SigningProperties) {
     private val logger = KotlinLogging.logger {}
 
-    fun createSignature(message: ByteArray): ByteArray {
+    fun createSignature(message: ByteArray, privateKey: PrivateKey): ByteArray {
         logger.debug { "Creating signature for message of length: ${message.size}" }
         return Signature.getInstance(signingConfiguration.securityAlgorithm, signingConfiguration.securityProvider)
             .apply {
-                initSign(keyProvider.getPrivateKey(), SecureRandom())
+                initSign(privateKey, SecureRandom())
                 update(message)
             }
             .sign()
     }
 
-    fun verifySignature(message: ByteArray, securityKey: ByteArray): Boolean {
+    fun verifySignature(message: ByteArray, securityKey: ByteArray, publicKey: PublicKey): Boolean {
         logger.debug { "Verifying signature for message of length: ${message.size}" }
         val builder =
             Signature.getInstance(signingConfiguration.securityAlgorithm, signingConfiguration.securityProvider).apply {
-                initVerify(keyProvider.getPublicKey())
+                initVerify(publicKey)
                 update(message)
             }
 

oslp-message-signing/src/main/kotlin/com/gxf/utilities/oslp/message/signing/SigningUtil.kt

@@ -6,64 +6,38 @@ package com.gxf.utilities.oslp.message.signing
 import com.gxf.utilities.oslp.message.signing.configuration.SigningProperties
 import java.security.KeyPair
 import java.security.KeyPairGenerator
-import java.security.PrivateKey
-import java.security.PublicKey
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 
 class SigningUtilTest {
 
+    val signingProperties: SigningProperties =
+        SigningProperties(securityProvider = "SunEC", securityAlgorithm = "SHA256withECDSA")
     val keyPairGenerator: KeyPairGenerator = KeyPairGenerator.getInstance("EC").apply { initialize(256) }
     val keyPair1: KeyPair = keyPairGenerator.generateKeyPair()
     val keyPair2: KeyPair = keyPairGenerator.generateKeyPair()
 
-    class TestKeyProvider(private val privateKey: PrivateKey, private val publicKey: PublicKey) : KeyProvider {
-        override fun getPrivateKey() = privateKey
-
-        override fun getPublicKey() = publicKey
-    }
-
-    val keyProvider1: TestKeyProvider = TestKeyProvider(privateKey = keyPair1.private, publicKey = keyPair1.public)
-
-    val keyProvider2: TestKeyProvider = TestKeyProvider(privateKey = keyPair2.private, publicKey = keyPair2.public)
-
-    private val signingUtil1: SigningUtil =
-        SigningUtil(
-            signingConfiguration = SigningProperties(securityProvider = "SunEC", securityAlgorithm = "SHA256withECDSA"),
-            keyProvider = keyProvider1,
-        )
-
-    private val signingUtil2: SigningUtil =
-        SigningUtil(
-            signingConfiguration = SigningProperties(securityProvider = "SunEC", securityAlgorithm = "SHA256withECDSA"),
-            keyProvider = keyProvider2,
-        )
-
-    private val signingUtil3: SigningUtil =
-        SigningUtil(
-            signingConfiguration = SigningProperties(securityProvider = "SunEC", securityAlgorithm = "SHA256withECDSA"),
-            keyProvider = keyProvider1,
-        )
+    private val signingUtil: SigningUtil = SigningUtil(signingProperties)
 
     @Test
     fun `should sign and verify message from different SigningUtils with same keys`() {
         val message = "test-message".toByteArray()
-        val signature = signingUtil1.createSignature(message)
-        assertThat(signingUtil3.verifySignature(message, signature)).isTrue()
+        val signature = signingUtil.createSignature(message, keyPair1.private)
+        assertThat(signingUtil.verifySignature(message, signature, keyPair1.public)).isTrue()
     }
 
     @Test
     fun `should not verify tampered message`() {
         var message = "test-message".toByteArray()
-        val signature = signingUtil1.createSignature(message)
+        val signature = signingUtil.createSignature(message, keyPair1.private)
         message = "tampered-message".toByteArray()
-        assertThat(signingUtil1.verifySignature(message, signature)).isFalse()
+        assertThat(signingUtil.verifySignature(message, signature, keyPair1.public)).isFalse()
     }
 
     @Test
     fun `should not verify tampered keys`() {
         val message = "test-message".toByteArray()
-        val signature = signingUtil1.createSignature(message)
-        assertThat(signingUtil2.verifySignature(message, signature)).isFalse()
+        val signature = signingUtil.createSignature(message, keyPair1.private)
+        assertThat(signingUtil.verifySignature(message, signature, keyPair2.public)).isFalse()
     }
 }