Merge pull request #39 from a-sit-plus/release/2.2.0

* Dependency Updates
  * KmmResult 1.5.4
* Refactor `MultiBaseHelper` to only handle conversion
* Change `JwsHeader.publicKey` from JsonWebKey to CryptoPublicKey
* Remove `SignatureValueLength` parameters from JWS & COSE Algorithm Enum class
* Remove deprecated functions
* New `CryptoAlgorithm` class
* New `CryptoSignature` class for easy Asn1 - RawByteArray conversion
* Rename `Jws` classes
  * New `CryptoAlgorithm` class
  * New `CryptoSignature` class for easy Asn1 - RawByteArray conversion
* Rename function in file `JcaExtensions.kt` from `.toPublicKey` to `.toJcaPublicKey` to reflect connection to JVMname function in file `JcaExtensions.kt` from `.toPublicKey` to `.toJcaPublicKey` to reflect connection to JVM
* Remove VcLib-specific constants

Author: JesusMcCloud

CHANGELOG.md

@@ -32,3 +32,17 @@
   * Add `xxxSafe()` functions to encapsulate endocing/decoding in `KmmResult`
   * Return `KmmResult` for conversions between different key representations ( i.e. `CryptoPublicKey`, `CoseKey` and `JsonWebKey`) 
 
+### 2.2.0
+* Dependency Updates
+  * KmmResult 1.5.4
+* Refactor `MultiBaseHelper` to only handle conversion
+* Change `JwsHeader.publicKey` from JsonWebKey to CryptoPublicKey
+* Remove `SignatureValueLength` parameters from JWS & COSE Algorithm Enum class
+* Remove deprecated functions
+* New `CryptoAlgorithm` class
+* New `CryptoSignature` class for easy Asn1 - RawByteArray conversion
+* Rename `Jws` classes
+  * New `CryptoAlgorithm` class
+  * New `CryptoSignature` class for easy Asn1 - RawByteArray conversion
+* Rename function in file `JcaExtensions.kt` from `.toPublicKey` to `.toJcaPublicKey` to reflect connection to JVMname function in file `JcaExtensions.kt` from `.toPublicKey` to `.toJcaPublicKey` to reflect connection to JVM
+* Remove VcLib-specific constants

build.gradle.kts

@@ -1,7 +1,7 @@
 import org.jetbrains.dokka.gradle.DokkaMultiModuleTask
 
 plugins {
-    id("at.asitplus.gradle.conventions") version "1.9.20+20231107" //version can be omitted for composite build
+    id("at.asitplus.gradle.conventions") version "1.9.20+20231114" //version can be omitted for composite build
 }
 group = "at.asitplus.crypto"
 

buildSrc/src/main/kotlin/DatatypeVersions.kt

@@ -1,5 +1,4 @@
 object DatatypeVersions{
     const val encoding= "1.2.3"
-    const val kmmresult="1.5.3"
     const val okio = "3.5.0"
 }

datatypes-cose/build.gradle.kts

@@ -1,5 +1,4 @@
 import DatatypeVersions.encoding
-import DatatypeVersions.kmmresult
 import at.asitplus.gradle.*
 
 plugins {
@@ -9,7 +8,7 @@ plugins {
     id("at.asitplus.gradle.conventions")
 }
 
-version = "2.1.0"
+version = "2.2.0"
 
 kotlin {
     jvm()
@@ -39,7 +38,7 @@ exportIosFramework(
     "KmpCryptoCose",
     serialization("cbor"),
     datetime(),
-    "at.asitplus:kmmresult:${kmmresult}",
+    kmmresult(),
     project(":datatypes")
 )
 

datatypes-cose/src/commonMain/kotlin/at/asitplus/crypto/datatypes/cose/CoseAlgorithm.kt

@@ -1,6 +1,6 @@
 package at.asitplus.crypto.datatypes.cose
 
-import at.asitplus.crypto.datatypes.JwsAlgorithm
+import at.asitplus.crypto.datatypes.CryptoAlgorithm
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.descriptors.PrimitiveKind
@@ -10,12 +10,12 @@ import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 
 @Serializable(with = CoseAlgorithmSerializer::class)
-enum class CoseAlgorithm(val value: Int) {
+enum class CoseAlgorithm(val value: Int, val isEC: Boolean = false) {
 
     // ECDSA with SHA-size
-    ES256(-7),
-    ES384(-35),
-    ES512(-36),
+    ES256(-7, true),
+    ES384(-35, true),
+    ES512(-36, true),
 
     // HMAC-size with SHA-size
     HS256(5),
@@ -30,38 +30,32 @@ enum class CoseAlgorithm(val value: Int) {
     // RSASSA-PKCS1-v1_5 with SHA-size
     RS256(-257),
     RS384(-258),
-    RS512(-259);
+    RS512(-259),
 
-    fun toJwsAlgorithm() = when(this) {
-        ES256 -> JwsAlgorithm.ES256
-        ES384 -> JwsAlgorithm.ES384
-        ES512 -> JwsAlgorithm.ES512
+    // RSASSA-PKCS1-v1_5 using SHA-1
+    RS1(-65535);
 
-        HS256 -> JwsAlgorithm.HS256
-        HS384 -> JwsAlgorithm.HS384
-        HS512 -> JwsAlgorithm.HS512
 
-        PS256 -> JwsAlgorithm.PS256
-        PS384 -> JwsAlgorithm.PS384
-        PS512 -> JwsAlgorithm.PS512
+    fun toCryptoAlgorithm() = when(this) {
+        ES256 -> CryptoAlgorithm.ES256
+        ES384 -> CryptoAlgorithm.ES384
+        ES512 -> CryptoAlgorithm.ES512
 
-        RS256 -> JwsAlgorithm.RS256
-        RS384 -> JwsAlgorithm.RS384
-        RS512 -> JwsAlgorithm.RS512
-    }
+        HS256 -> CryptoAlgorithm.HS256
+        HS384 -> CryptoAlgorithm.HS384
+        HS512 -> CryptoAlgorithm.HS512
 
-    val signatureValueLength
-        get() = when (this) {
-            ES256 -> 256 / 8 * 2
-            ES384 -> 384 / 8 * 2
-            ES512 -> 512 / 8 * 2
-            HS256 -> 256 / 8
-            HS384 -> 384 / 8
-            HS512 -> 512 / 8
-            else -> -1 // RSA signatures do not have a fixed size
-        }
-}
+        PS256 -> CryptoAlgorithm.PS256
+        PS384 -> CryptoAlgorithm.PS384
+        PS512 -> CryptoAlgorithm.PS512
+
+        RS256 -> CryptoAlgorithm.RS256
+        RS384 -> CryptoAlgorithm.RS384
+        RS512 -> CryptoAlgorithm.RS512
 
+        RS1 -> CryptoAlgorithm.RS1
+    }
+}
 
 object CoseAlgorithmSerializer : KSerializer<CoseAlgorithm> {
 
@@ -74,7 +68,27 @@ object CoseAlgorithmSerializer : KSerializer<CoseAlgorithm> {
 
     override fun deserialize(decoder: Decoder): CoseAlgorithm {
         val decoded = decoder.decodeInt()
-        return CoseAlgorithm.values().first { it.value == decoded }
+        return CoseAlgorithm.entries.first { it.value == decoded }
     }
 
+}
+
+fun CryptoAlgorithm.toCoseAlgorithm() = when(this) {
+    CryptoAlgorithm.ES256 -> CoseAlgorithm.ES256
+    CryptoAlgorithm.ES384 -> CoseAlgorithm.ES384
+    CryptoAlgorithm.ES512 -> CoseAlgorithm.ES512
+
+    CryptoAlgorithm.HS256 -> CoseAlgorithm.HS256
+    CryptoAlgorithm.HS384 -> CoseAlgorithm.HS384
+    CryptoAlgorithm.HS512 -> CoseAlgorithm.HS512
+
+    CryptoAlgorithm.PS256 -> CoseAlgorithm.PS256
+    CryptoAlgorithm.PS384 -> CoseAlgorithm.PS384
+    CryptoAlgorithm.PS512 -> CoseAlgorithm.PS512
+
+    CryptoAlgorithm.RS256 -> CoseAlgorithm.RS256
+    CryptoAlgorithm.RS384 -> CoseAlgorithm.RS384
+    CryptoAlgorithm.RS512 -> CoseAlgorithm.RS512
+
+    CryptoAlgorithm.RS1 -> CoseAlgorithm.RS1
 }

datatypes-cose/src/commonMain/kotlin/at/asitplus/crypto/datatypes/cose/CoseHeader.kt

@@ -4,13 +4,9 @@ import at.asitplus.crypto.datatypes.cose.io.cborSerializer
 import io.github.aakira.napier.Napier
 import io.matthewnelson.encoding.base16.Base16
 import io.matthewnelson.encoding.core.Encoder.Companion.encodeToString
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 import kotlinx.serialization.cbor.ByteString
 import kotlinx.serialization.cbor.SerialLabel
-import kotlinx.serialization.decodeFromByteArray
-import kotlinx.serialization.encodeToByteArray
 
 /**
  * Protected header of a [CoseSigned].

datatypes-cose/src/commonMain/kotlin/at/asitplus/crypto/datatypes/cose/CoseKey.kt

@@ -82,7 +82,7 @@ data class CoseKey(
      * or the first error. More details in either [CoseKeyParams.RsaParams.toCryptoPublicKey] or [CoseKeyParams.EcYByteArrayParams.toCryptoPublicKey]
      */
     fun toCryptoPublicKey(): KmmResult<CryptoPublicKey> =
-        keyParams?.toCryptoPublicKey() ?: KmmResult.failure(IllegalArgumentException("No public key parameters!"))
+        keyParams?.toCryptoPublicKey() ?: failure(IllegalArgumentException("No public key parameters!"))
 
     fun serialize() = cborSerializer.encodeToByteArray(this)
 
@@ -218,7 +218,11 @@ object CoseKeySerializer : KSerializer<CoseKey> {
         @SerialLabel(-4)
         @SerialName("d")
         @ByteString
-        val d: ByteArray? = null
+        val d: ByteArray? = null,
+        @SerialLabel(-1)
+        @SerialName("k")
+        @ByteString
+        val k: ByteArray? = null
     ) {
         constructor(src: CoseKey) : this(
             src.type,
@@ -237,6 +241,10 @@ object CoseKeySerializer : KSerializer<CoseKey> {
                 is CoseKeyParams.RsaParams -> params.e
                 else -> null
             },
+            when (val params = src.keyParams) {
+                is CoseKeyParams.SymmKeyParams -> params.k
+                else -> null
+            },
             when (val params = src.keyParams) {
                 is CoseKeyParams.RsaParams -> params.d
                 is CoseKeyParams.EcYByteArrayParams -> params.d
@@ -334,6 +342,39 @@ object CoseKeySerializer : KSerializer<CoseKey> {
         override fun toCoseKey() = CoseKey(type, keyId, algorithm, operations, baseIv, CoseKeyParams.RsaParams(n, e, d))
     }
 
+    @Serializable
+    private class CoseSymmKeySerialContainer(
+        @SerialLabel(1)
+        @SerialName("kty")
+        val type: CoseKeyType,
+        @SerialLabel(2)
+        @SerialName("kid")
+        @ByteString
+        val keyId: ByteArray? = null,
+        @SerialLabel(3)
+        @SerialName("alg")
+        val algorithm: CoseAlgorithm? = null,
+        @SerialLabel(4)
+        @SerialName("key_ops")
+        val operations: Array<CoseKeyOperation>? = null,
+        @SerialLabel(5)
+        @SerialName("Base IV")
+        @ByteString
+        val baseIv: ByteArray? = null,
+        @SerialLabel(-1)
+        @SerialName("k")
+        val k: ByteArray? = null,
+    ) : SerialContainer {
+        init {
+            if (type != CoseKeyType.SYMMETRIC) throw IllegalArgumentException("Not a symmetric key!")
+            if (k == null) throw IllegalArgumentException("Parameter k not optional for symmetric keys")
+        }
+
+        override fun toCoseKey() =
+            CoseKey(type, keyId, algorithm, operations, baseIv, CoseKeyParams.SymmKeyParams(k!!))
+
+    }
+
     override val descriptor: SerialDescriptor
         get() = CoseKeySerialContainer.serializer().descriptor
 
@@ -344,7 +385,7 @@ object CoseKeySerializer : KSerializer<CoseKey> {
             "alg" to 3,
             "key_ops" to 4,
             "Base IV" to 5,
-            "n/crv" to -1,
+            "k/n/crv" to -1,
             "x/e" to -2,
             "y" to -3,
             "d" to 4
@@ -360,6 +401,7 @@ object CoseKeySerializer : KSerializer<CoseKey> {
         var xOrE: ByteArray? = null
         var y: ByteArray? = null
         var d: ByteArray? = null
+        var k: ByteArray? = null
 
         decoder.decodeStructure(descriptor) {
             while (true) {
@@ -391,7 +433,7 @@ object CoseKeySerializer : KSerializer<CoseKey> {
                             ArraySerializer(CoseKeyOperationSerializer)
                         )
 
-                    labels["n/crv"] -> {
+                    labels["k/n/crv"] -> {
                         when (type) {
                             CoseKeyType.EC2 -> {
                                 val deser = CoseEllipticCurveSerializer
@@ -403,7 +445,10 @@ object CoseKeySerializer : KSerializer<CoseKey> {
                                 n = decodeNullableSerializableElement(deser.descriptor, index, deser)
                             }
 
-                            CoseKeyType.SYMMETRIC -> {}
+                            CoseKeyType.SYMMETRIC -> {
+                                val deser = ByteArraySerializer()
+                                k = decodeNullableSerializableElement(deser.descriptor, index, deser)
+                            }
                         }
 
                     }
@@ -444,7 +489,9 @@ object CoseKeySerializer : KSerializer<CoseKey> {
                 CoseRsaKeySerialContainer(type, keyId, alg, keyOps, baseIv, n, xOrE, d).toCoseKey()
             }
 
-            CoseKeyType.SYMMETRIC -> CoseKey(type, keyId, alg, keyOps, keyParams = null)
+            CoseKeyType.SYMMETRIC -> {
+                CoseSymmKeySerialContainer(type,keyId,alg,keyOps,baseIv, k).toCoseKey()
+            }
         }
     }
 

datatypes-cose/src/commonMain/kotlin/at/asitplus/crypto/datatypes/cose/CoseKeyParams.kt

@@ -1,6 +1,7 @@
 package at.asitplus.crypto.datatypes.cose
 
 import at.asitplus.KmmResult
+import at.asitplus.KmmResult.Companion.failure
 import at.asitplus.KmmResult.Companion.wrap
 import at.asitplus.crypto.datatypes.CryptoPublicKey
 import at.asitplus.crypto.datatypes.asn1.decodeFromDer
@@ -153,4 +154,10 @@ sealed class CoseKeyParams {
             }.wrap()
         }
     }
+
+    data class SymmKeyParams(
+        val k: ByteArray
+    ): CoseKeyParams() {
+        override fun toCryptoPublicKey(): KmmResult<CryptoPublicKey> = failure(IllegalArgumentException("Symmetric keys do not have public component"))
+    }
 }

datatypes-cose/src/commonMain/kotlin/at/asitplus/crypto/datatypes/cose/CoseKeyType.kt

@@ -26,7 +26,7 @@ object CoseKeyTypeSerializer : KSerializer<CoseKeyType> {
 
     override fun deserialize(decoder: Decoder): CoseKeyType {
         val decoded = decoder.decodeInt()
-        return CoseKeyType.values().firstOrNull { it.value == decoded }
+        return CoseKeyType.entries.firstOrNull { it.value == decoded }
             ?: throw IllegalArgumentException("Not known: $decoded")
     }
 }