Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -2,8 +2,13 @@ package org.multipaz.documenttype

import kotlinx.io.bytestring.ByteString
import kotlinx.io.bytestring.decodeToString
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonArray
import kotlinx.serialization.json.jsonObject
import org.multipaz.cbor.Bstr
import org.multipaz.cbor.Cbor
import org.multipaz.cbor.DataItem
Expand Down Expand Up @@ -144,6 +149,18 @@ abstract class TransactionType<PayloadT: Any>(

/**
* Parses transaction data serialized for use in OpenID4VP protocol.
*
* The payload comes from [parseOpenId4VpRequest]. The hash algorithms the verifier accepts
* come from `transaction_data_hashes_alg`, so a type that does not override this function
* still hashes its transaction data with the algorithm the verifier asked for.
*
* If `transaction_data_hashes_alg` is absent or `null`, [TransactionData.hashAlgorithms] is
* left `null` and the default algorithm applies.
*
* @param serialized the base64url-encoded JSON transaction data item.
* @return transaction data wrapping the parsed payload.
* @throws IllegalArgumentException if `transaction_data_hashes_alg` is present but not an
* array of strings, or names no known hash algorithm.
*/
open fun parseJson(serialized: ByteString): TransactionData<PayloadT> {
val jsonString = serialized.decodeToString().fromBase64Url().decodeToString()
Expand All @@ -152,6 +169,22 @@ abstract class TransactionType<PayloadT: Any>(
payload = parseOpenId4VpRequest(jsonString),
protocol = TransactionProtocol.OPENID4VP,
rawBytes = serialized,
hashAlgorithms = parseJoseHashAlgorithms(
Comment thread
TheBlackBit marked this conversation as resolved.
Resolved
Comment thread
TheBlackBit marked this conversation as resolved.
Resolved
Json.parseToJsonElement(jsonString).jsonObject["transaction_data_hashes_alg"]
?.takeIf { it != JsonNull }
Comment thread
TheBlackBit marked this conversation as resolved.
Resolved
?.also {
require(it is JsonArray) {
"'transaction_data_hashes_alg' must be an array of strings: $it"
}
}
?.jsonArray
Comment thread
TheBlackBit marked this conversation as resolved.
Resolved
?.map { alg ->
require(alg is JsonPrimitive && alg.isString) {
"Hash algorithm in 'transaction_data_hashes_alg' must be a string: $alg"
}
alg.content
}
),
)
}

Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,108 @@
package org.multipaz.documenttype

import kotlinx.io.bytestring.encodeToByteString
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import kotlinx.serialization.json.put
import org.multipaz.crypto.Algorithm
import org.multipaz.presentment.TransactionData
import org.multipaz.presentment.TransactionProtocol
import org.multipaz.util.toBase64Url
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertNull
import kotlin.test.assertTrue

class TransactionTypeParseJsonTest {

// Relies on the base parseJson(), as a transaction type does unless it overrides it.
private object NoteTransaction : TransactionType<String>(
displayName = "Note",
identifier = "com.example.note",
) {
override fun serializeOpenId4VpRequest(
payload: String,
credentialIds: List<String>,
hashAlgorithms: List<Algorithm>?
): String = buildJsonObject {
put("type", identifier)
put("credential_ids", JsonArray(credentialIds.map { JsonPrimitive(it) }))
joseHashAlgorithms(hashAlgorithms)?.let {
put("transaction_data_hashes_alg", JsonArray(it.map { alg -> JsonPrimitive(alg) }))
}
put("note", payload)
}.toString()

override fun parseOpenId4VpRequest(jsonString: String): String =
Json.parseToJsonElement(jsonString).jsonObject.getValue("note").jsonPrimitive.content
}

private fun parse(json: String): TransactionData<String> =
NoteTransaction.parseJson(json.encodeToByteArray().toBase64Url().encodeToByteString())

private fun parseWithHashesAlg(hashesAlg: JsonElement): TransactionData<String> =
parse(buildJsonObject {
put("type", NoteTransaction.identifier)
put("credential_ids", JsonArray(listOf(JsonPrimitive("pid"))))
put("transaction_data_hashes_alg", hashesAlg)
put("note", "hello")
}.toString())

private fun algs(vararg names: String) = JsonArray(names.map { JsonPrimitive(it) })

@Test
fun requestedHashAlgorithmsSurviveTheRoundTrip() {
val data = parse(NoteTransaction.serializeOpenId4VpRequest(
payload = "hello",
credentialIds = listOf("pid"),
hashAlgorithms = listOf(Algorithm.SHA384, Algorithm.SHA256)
))
assertEquals("hello", data.payload)
assertEquals(TransactionProtocol.OPENID4VP, data.protocol)
assertEquals(listOf(Algorithm.SHA384, Algorithm.SHA256), data.hashAlgorithms)
}

@Test
fun noHashAlgorithmsLeavesTheDefault() {
val data = parse(NoteTransaction.serializeOpenId4VpRequest("hello", listOf("pid"), null))
assertNull(data.hashAlgorithms)
assertNull(parseWithHashesAlg(JsonNull).hashAlgorithms)
}

@Test
fun unknownHashAlgorithmsAreSkipped() {
assertEquals(listOf(Algorithm.SHA512), parseWithHashesAlg(algs("sha-3000", "sha-512")).hashAlgorithms)
}

@Test
fun noKnownHashAlgorithmIsRefused() {
assertFailsWith<IllegalArgumentException> { parseWithHashesAlg(algs("md5")) }
assertFailsWith<IllegalArgumentException> { parseWithHashesAlg(algs()) }
}

@Test
fun malformedHashAlgorithmsAreRefused() {
assertFailsWith<IllegalArgumentException> { parseWithHashesAlg(JsonPrimitive("sha-384")) }
assertFailsWith<IllegalArgumentException> { parseWithHashesAlg(JsonArray(listOf(JsonPrimitive(384)))) }
Comment thread
TheBlackBit marked this conversation as resolved.
Resolved
// A number next to a valid name: without the per-element check the number would become
// "384", be skipped as unknown, and the list would parse to [SHA256].
assertFailsWith<IllegalArgumentException> {
parseWithHashesAlg(JsonArray(listOf(JsonPrimitive(384), JsonPrimitive("sha-256"))))
}
}

@Test
fun nonArrayHashAlgorithmsErrorNamesTheField() {
val error = assertFailsWith<IllegalArgumentException> {
parseWithHashesAlg(JsonPrimitive("sha-384"))
}
assertTrue(error.message!!.contains("transaction_data_hashes_alg"))
}
}
Loading