Feature/oidf 15

modules/admin-server/src/main/kotlin/com/sphereon/oid/fed/server/admin/Application.kt

@@ -2,8 +2,10 @@ package com.sphereon.oid.fed.server.admin
 
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
+import org.springframework.context.annotation.ComponentScan
 
 @SpringBootApplication
+@ComponentScan(basePackages = ["com.sphereon.oid.fed.services"])
 class Application
 
 fun main(args: Array<String>) {

modules/openid-federation-common/src/commonMain/kotlin/com/sphereon/oid/fed/common/httpclient/OidFederationClient.kt

@@ -1,5 +1,6 @@
 package com.sphereon.oid.fed.common.httpclient
 
+import com.sphereon.oid.fed.openapi.models.JWTHeader
 import io.ktor.client.*
 import io.ktor.client.call.*
 import io.ktor.client.engine.*
@@ -10,20 +11,28 @@ import io.ktor.client.plugins.logging.*
 import io.ktor.client.request.*
 import io.ktor.client.request.forms.*
 import io.ktor.http.*
+import io.ktor.http.HttpMethod.Companion.Delete
 import io.ktor.http.HttpMethod.Companion.Get
 import io.ktor.http.HttpMethod.Companion.Post
 import io.ktor.utils.io.core.*
+import kotlinx.serialization.json.JsonObject
 
 class OidFederationClient(
     engine: HttpClientEngine,
+    // TODO need KMS implementation
+    //private val kmsInterface: KMSInterface,
     private val isRequestAuthenticated: Boolean = false,
     private val isRequestCached: Boolean = false
 ) {
     private val client: HttpClient = HttpClient(engine) {
         install(HttpCache)
         install(Logging) {
-            logger = Logger.DEFAULT
-            level = LogLevel.INFO
+            logger = object : Logger {
+                override fun log(message: String) {
+                    com.sphereon.oid.fed.common.logging.Logger.info("API", message)
+                }
+            }
+            level = LogLevel.ALL
         }
         if (isRequestAuthenticated) {
             install(Auth) {
@@ -41,13 +50,12 @@ class OidFederationClient(
     }
 
     suspend fun fetchEntityStatement(
-        url: String,
-        httpMethod: HttpMethod = Get,
-        parameters: Parameters = Parameters.Empty
+        url: String, httpMethod: HttpMethod = Get, postParameters: PostEntityParameters? = null
     ): String {
+
         return when (httpMethod) {
             Get -> getEntityStatement(url)
-            Post -> postEntityStatement(url, parameters)
+            Post -> postEntityStatement(url, postParameters)
             else -> throw IllegalArgumentException("Unsupported HTTP method: $httpMethod")
         }
     }
@@ -56,11 +64,50 @@ class OidFederationClient(
         return client.use { it.get(url).body() }
     }
 
-    private suspend fun postEntityStatement(url: String, parameters: Parameters): String {
+    private suspend fun postEntityStatement(url: String, postParameters: PostEntityParameters?): String {
+        val body = postParameters?.let { params ->
+            // TODO need KMS implementation
+            //kmsInterface.createJWT(header = params.header, payload = params.payload)
+            params.payload.toString()
+        }
+
+        return client.use {
+            it.post(url) {
+                setBody(body)
+            }.body()
+        }
+    }
+
+    suspend fun fetchAccount(
+        url: String, httpMethod: HttpMethod = Get, parameters: Parameters = Parameters.Empty
+    ): String {
+        return when (httpMethod) {
+            Get -> getAccount(url)
+            Post -> postAccount(url, parameters)
+            Delete -> deleteAccount(url)
+            else -> throw IllegalArgumentException("Unsupported HTTP method: $httpMethod")
+        }
+    }
+
+    private suspend fun getAccount(url: String): String {
+        return client.use { it.get(url).body() }
+    }
+
+    private suspend fun postAccount(url: String, parameters: Parameters): String {
         return client.use {
             it.post(url) {
                 setBody(FormDataContent(parameters))
             }.body()
         }
     }
+
+    private suspend fun deleteAccount(url: String): String {
+        return client.use { it.delete(url).body() }
+    }
+
+
+    // Data class for POST parameters
+    data class PostEntityParameters(
+        val payload: JsonObject, val header: JWTHeader
+    )
 }

modules/openid-federation-common/src/commonMain/kotlin/com/sphereon/oid/fed/common/jwt/JoseJwt.kt

@@ -1,7 +1,7 @@
 package com.sphereon.oid.fed.common.jwt
 
-expect class JwtHeader
-expect class JwtPayload
+import com.sphereon.oid.fed.openapi.models.JWTHeader
+import kotlinx.serialization.json.JsonObject
 
-expect fun sign(payload: JwtPayload, header: JwtHeader, opts: Map<String, Any>): String
+expect fun sign(payload: JsonObject, header: JWTHeader, opts: Map<String, Any>): String
 expect fun verify(jwt: String, key: Any, opts: Map<String, Any>): Boolean

modules/openid-federation-common/src/commonMain/kotlin/com/sphereon/oid/fed/common/jwt/KMSInterface.kt

@@ -0,0 +1,10 @@
+package com.sphereon.oid.fed.common.jwt
+
+import com.sphereon.oid.fed.openapi.models.JWTHeader
+import kotlinx.serialization.json.JsonObject
+
+interface KMSInterface {
+
+    fun createJWT(header: JWTHeader, payload: JsonObject): String
+
+}

modules/openid-federation-common/src/commonMain/kotlin/com/sphereon/oid/fed/common/jwt/KMSInterfaceImpl.kt

@@ -0,0 +1,14 @@
+package com.sphereon.oid.fed.common.jwt
+
+import com.sphereon.oid.fed.openapi.models.JWTHeader
+import kotlinx.serialization.json.JsonObject
+
+class KMSInterfaceImpl: KMSInterface {
+
+    override fun createJWT(header: JWTHeader, payload: JsonObject):String {
+
+        // TODO get key and pass it
+        val jwt = sign(payload = payload, header = header, opts = mapOf())
+        return jwt
+    }
+}

modules/openid-federation-common/src/commonMain/kotlin/com/sphereon/oid/fed/common/mapper/JsonMapper.kt

@@ -15,7 +15,7 @@ class JsonMapper {
      * Used for mapping JWT token to EntityStatement object
      */
     fun mapEntityStatement(jwtToken: String): EntityConfigurationStatement? =
-        decodeJWTComponents(jwtToken)?.payload?.let { Json.decodeFromJsonElement(it) }
+        decodeJWTComponents(jwtToken).payload.let { Json.decodeFromJsonElement(it) }
 
     /*
      * Used for mapping trust chain

modules/openid-federation-common/src/jsMain/kotlin/com/sphereon/oid/fed/common/jwt/JoseJwt.js.kt

@@ -1,9 +1,9 @@
 package com.sphereon.oid.fed.common.jwt
 
-import com.sphereon.oid.fed.openapi.models.EntityConfigurationStatement
 import com.sphereon.oid.fed.openapi.models.JWTHeader
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
 
 @JsModule("jose")
 @JsNonModule
@@ -26,15 +26,10 @@ external object Jose {
     fun jwtVerify(jwt: String, key: Any, options: dynamic = definedExternally): dynamic
 }
 
-actual typealias JwtPayload = EntityConfigurationStatement
-actual typealias JwtHeader = JWTHeader
-
 @ExperimentalJsExport
 @JsExport
 actual fun sign(
-    payload: JwtPayload,
-    header: JwtHeader,
-    opts: Map<String, Any>
+    payload: JsonObject, header: JWTHeader, opts: Map<String, Any>
 ): String {
     val privateKey = opts["privateKey"] ?: throw IllegalArgumentException("JWK private key is required")
 
@@ -46,9 +41,7 @@ actual fun sign(
 @ExperimentalJsExport
 @JsExport
 actual fun verify(
-    jwt: String,
-    key: Any,
-    opts: Map<String, Any>
+    jwt: String, key: Any, opts: Map<String, Any>
 ): Boolean {
     return Jose.jwtVerify(jwt, key, opts)
 }

modules/openid-federation-common/src/jsTest/kotlin/com/sphereon/oid/fed/common/jwt/JoseJwtTest.js.kt

@@ -1,10 +1,15 @@
 package com.sphereon.oid.fed.common.jwt
 
 import com.sphereon.oid.fed.common.jwt.Jose.generateKeyPair
+import com.sphereon.oid.fed.openapi.models.EntityConfigurationStatement
 import com.sphereon.oid.fed.openapi.models.JWKS
+import com.sphereon.oid.fed.openapi.models.JWTHeader
 import kotlinx.coroutines.async
 import kotlinx.coroutines.await
 import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.encodeToJsonElement
 import kotlin.js.Promise
 import kotlin.test.Test
 import kotlin.test.assertTrue
@@ -14,10 +19,13 @@ class JoseJwtTest {
     @Test
     fun signTest() = runTest {
         val keyPair = (generateKeyPair("RS256") as Promise<dynamic>).await()
+        val entityStatement =
+            EntityConfigurationStatement(iss = "test", sub = "test", exp = 111111, iat = 111111, jwks = JWKS())
+        val payload: JsonObject = Json.encodeToJsonElement(entityStatement) as JsonObject
         val result = async {
             sign(
-                JwtPayload(iss = "test", sub = "test", exp = 111111, iat = 111111, jwks = JWKS()),
-                JwtHeader(typ = "JWT", alg = "RS256", kid = "test"),
+                payload,
+                JWTHeader(typ = "JWT", alg = "RS256", kid = "test"),
                 mutableMapOf("privateKey" to keyPair.privateKey)
             )
         }
@@ -28,9 +36,12 @@ class JoseJwtTest {
     @Test
     fun verifyTest() = runTest {
         val keyPair = (generateKeyPair("RS256") as Promise<dynamic>).await()
+        val entityStatement =
+            EntityConfigurationStatement(iss = "test", sub = "test", exp = 111111, iat = 111111, jwks = JWKS())
+        val payload: JsonObject = Json.encodeToJsonElement(entityStatement) as JsonObject
         val signed = (sign(
-            JwtPayload(iss = "test", sub = "test", exp = 111111, iat = 111111, jwks = JWKS()),
-            JwtHeader(typ = "JWT", alg = "RS256", kid = "test"),
+            payload,
+            JWTHeader(typ = "JWT", alg = "RS256", kid = "test"),
             mutableMapOf("privateKey" to keyPair.privateKey)
         ) as Promise<dynamic>).await()
         val result = async { verify(signed, keyPair.publicKey, emptyMap()) }

modules/openid-federation-common/src/jvmMain/kotlin/com/sphereon/oid/fed/common/jwt/JoseJwt.jvm.kt

@@ -1,29 +1,27 @@
 package com.sphereon.oid.fed.common.jwt
 
-import com.nimbusds.jose.JWSHeader
-import com.nimbusds.jose.JWSSigner
-import com.nimbusds.jose.JWSVerifier
+import com.nimbusds.jose.*
 import com.nimbusds.jose.crypto.RSASSASigner
 import com.nimbusds.jose.crypto.RSASSAVerifier
 import com.nimbusds.jose.jwk.RSAKey
 import com.nimbusds.jwt.JWTClaimsSet
 import com.nimbusds.jwt.SignedJWT
+import com.sphereon.oid.fed.openapi.models.JWTHeader
+import kotlinx.serialization.json.JsonObject
 
-actual typealias JwtPayload = JWTClaimsSet
-actual typealias JwtHeader = JWSHeader
 
 actual fun sign(
-    payload: JwtPayload,
-    header: JwtHeader,
+    payload: JsonObject,
+    header: JWTHeader,
     opts: Map<String, Any>
 ): String {
     val rsaJWK = opts["key"] as RSAKey? ?: throw IllegalArgumentException("The RSA key pair is required")
 
     val signer: JWSSigner = RSASSASigner(rsaJWK)
 
     val signedJWT = SignedJWT(
-        header,
-        payload
+        header.toJWSHeader(),
+        JWTClaimsSet.parse(payload.toString())
     )
 
     signedJWT.sign(signer)
@@ -44,4 +42,12 @@ actual fun verify(
     } catch (e: Exception) {
         throw Exception("Couldn't verify the JWT Signature: ${e.message}", e)
     }
-}
+}
+
+fun JWTHeader.toJWSHeader(): JWSHeader {
+    val type = typ
+    return JWSHeader.Builder(JWSAlgorithm.parse(alg)).apply {
+        type(JOSEObjectType(type))
+        keyID(kid)
+    }.build()
+}

modules/openid-federation-common/src/jvmTest/kotlin/com/sphereon/oid/fed/common/httpclient/OidFederationClientTest.kt

@@ -1,11 +1,15 @@
 package com.sphereon.oid.fed.common.httpclient
 
-import com.sphereon.oid.fed.openapi.models.*
+import com.nimbusds.jose.jwk.gen.RSAKeyGenerator
+import com.sphereon.oid.fed.openapi.models.EntityConfigurationStatement
+import com.sphereon.oid.fed.openapi.models.JWKS
+import com.sphereon.oid.fed.openapi.models.JWTHeader
 import io.ktor.client.engine.mock.*
 import io.ktor.http.*
 import kotlinx.coroutines.runBlocking
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.encodeToJsonElement
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -38,7 +42,9 @@ class OidFederationClientTest {
     fun testGetEntityStatement() {
         runBlocking {
             val client = OidFederationClient(mockEngine)
-            val response = client.fetchEntityStatement("https://www.example.com?iss=https://edugain.org/federation&sub=https://openid.sunet.se", HttpMethod.Get)
+            val response = client.fetchEntityStatement(
+                "https://www.example.com?iss=https://edugain.org/federation&sub=https://openid.sunet.se", HttpMethod.Get
+            )
             assertEquals(jwt, response)
         }
     }
@@ -47,11 +53,20 @@ class OidFederationClientTest {
     fun testPostEntityStatement() {
         runBlocking {
             val client = OidFederationClient(mockEngine)
-            val response = client.fetchEntityStatement("https://www.example.com", HttpMethod.Post,
-                Parameters.build {
-                    append("iss","https://edugain.org/federation")
-                    append("sub","https://openid.sunet.se")
-                })
+            val key = RSAKeyGenerator(2048).keyID("key1").generate()
+            val entityStatement = EntityConfigurationStatement(
+                iss = "https://edugain.org/federation",
+                sub = "https://openid.sunet.se",
+                exp = 111111,
+                iat = 111111,
+                jwks = JWKS()
+            )
+            val payload: JsonObject = Json.encodeToJsonElement(entityStatement) as JsonObject
+            val response = client.fetchEntityStatement(
+                "https://www.example.com", HttpMethod.Post, OidFederationClient.PostEntityParameters(
+                    payload = payload, header = JWTHeader(typ = "JWT", alg = "RS256", kid = key.keyID)
+                )
+            )
             assertEquals(jwt, response)
         }
     }