8699251619

Committed 16 Apr 2024 02:54AM UTC coverage: 31.165% (+0.4%) from 30.781%

Build Type

Committed by

Commit Message

ATL-6782: Aud check

Signed-off-by: Bassam Riman <bassam.riman@iohk.io>

Pull Request Pull Request #969: feat: VC Verification Audiance check

Run Details

0 of 46 new or added lines in 4 files covered. (0.0%)

486 existing lines in 113 files now uncovered.

4512 of 14478 relevant lines covered (31.16%)

0.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.5

/castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/did/w3c/W3CModelHelper.scala

package io.iohk.atala.castor.core.model.did.w3c

import io.iohk.atala.castor.core.model.did.{
  DIDData,
  DIDMetadata,
  PrismDID,
  PublicKey,
  PublicKeyData,
  Service,
  VerificationRelationship
}
import io.iohk.atala.shared.models.HexString
import io.iohk.atala.castor.core.model.did.ServiceType
import io.circe.Json
import io.iohk.atala.castor.core.model.did.ServiceEndpoint
import io.iohk.atala.castor.core.model.did.ServiceEndpoint.UriOrJsonEndpoint
import io.iohk.atala.castor.core.model.did.EllipticCurve
import java.time.format.DateTimeFormatter
import java.time.ZoneOffset
import java.time.Instant

object W3CModelHelper extends W3CModelHelper

private[castor] trait W3CModelHelper {

  private val XML_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'")

  private def toXmlDateTime(time: Instant): String = {
    val zonedDateTime = time.atZone(ZoneOffset.UTC)
    XML_DATETIME_FORMATTER.format(zonedDateTime)
  }

  extension (didMetadata: DIDMetadata) {
    def toW3C: DIDDocumentMetadataRepr = DIDDocumentMetadataRepr(
      deactivated = didMetadata.deactivated,
      canonicalId = didMetadata.canonicalId.map(_.toString),
      versionId = HexString.fromByteArray(didMetadata.lastOperationHash.toArray).toString,
      created = didMetadata.created.map(toXmlDateTime),
      updated = didMetadata.updated.map(toXmlDateTime)
    )
  }

  extension (didData: DIDData) {
    def toW3C(did: PrismDID): DIDDocumentRepr = {
      import VerificationRelationship.*
      val embeddedKeys = didData.publicKeys.map(k => k.toW3C(did, did))
      val keyRefWithPurpose = didData.publicKeys.map(k => k.purpose -> s"${did.toString}#${k.id}")
      val services = didData.services.map(_.toW3C(did))
      DIDDocumentRepr(
        id = did.toString,
        controller = did.toString,
        verificationMethod = embeddedKeys,
        authentication = keyRefWithPurpose.collect { case (Authentication, k) => k },
        assertionMethod = keyRefWithPurpose.collect { case (AssertionMethod, k) => k },
        keyAgreement = keyRefWithPurpose.collect { case (KeyAgreement, k) => k },
        capabilityInvocation = keyRefWithPurpose.collect { case (CapabilityInvocation, k) => k },
        capabilityDelegation = keyRefWithPurpose.collect { case (CapabilityDelegation, k) => k },
        service = services,
        context = deriveContext(embeddedKeys, services)
      )
    }

    // Reference: https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#constructing-a-json-ld-did-document
    private def deriveContext(keys: Seq[PublicKeyRepr], services: Seq[ServiceRepr]): Seq[String] = {
      val mandatoryContext = Seq("https://www.w3.org/ns/did/v1")
      val additionalContext = {
        val keyTypes = keys.map(_.`type`).toSet
        val serviceTypes = services
          .map(_.`type`)
          .flatMap {
            case s: String      => Seq(s)
            case s: Seq[String] => s
          }
          .toSet
        Seq(
          Option.when(keyTypes.contains("JsonWebKey2020"))("https://w3id.org/security/suites/jws-2020/v1"),
          Option.when(serviceTypes.contains("DIDCommMessaging"))("https://didcomm.org/messaging/contexts/v2"),
          Option.when(serviceTypes.contains("LinkedDomains"))(
            "https://identity.foundation/.well-known/did-configuration/v1"
          )
        ).flatten
      }
      val userDefinedContext = didData.context
      mandatoryContext ++ additionalContext ++ userDefinedContext
    }
  }

  extension (service: Service) {
    def toW3C(did: PrismDID): ServiceRepr =
      ServiceRepr(
        id = s"${did.toString}#${service.id}",
        `type` = serviceTypeToW3C(service.`type`),
        serviceEndpoint = serviceEndpointToW3C(service.serviceEndpoint)
      )

    private def serviceTypeToW3C(serviceType: ServiceType): String | Seq[String] = {
      import ServiceType.*
      serviceType match {
        case ServiceType.Single(name)    => name.value
        case names: ServiceType.Multiple => names.values.map(_.value)
      }
    }

    private def serviceEndpointToW3C(serviceEndpoint: ServiceEndpoint): Json = {
      serviceEndpoint match {
        case ServiceEndpoint.Single(uri) =>
          uri match {
            case UriOrJsonEndpoint.Uri(uri)   => Json.fromString(uri.value)
            case UriOrJsonEndpoint.Json(json) => Json.fromJsonObject(json)
          }
        case ep: ServiceEndpoint.Multiple =>
          val uris = ep.values.map {
            case UriOrJsonEndpoint.Uri(uri)   => Json.fromString(uri.value)
            case UriOrJsonEndpoint.Json(json) => Json.fromJsonObject(json)
          }
          Json.arr(uris: _*)
      }
    }
  }

  // FIXME: do we need to support uncompress for OKP key types?
  extension (publicKey: PublicKey) {
    def toW3C(did: PrismDID, controller: PrismDID): PublicKeyRepr = {
      val curve = publicKey.publicKeyData match {
        case PublicKeyData.ECCompressedKeyData(crv, _) => crv
        case PublicKeyData.ECKeyData(crv, _, _)        => crv
      }
      val publicKeyJwk = curve match {
        case EllipticCurve.SECP256K1 => secp256k1Repr(publicKey.publicKeyData)
        case EllipticCurve.ED25519   => okpPublicKeyRepr(publicKey.publicKeyData)
        case EllipticCurve.X25519    => okpPublicKeyRepr(publicKey.publicKeyData)
      }
      PublicKeyRepr(
        id = s"${did.toString}#${publicKey.id}",
        `type` = "JsonWebKey2020",
        controller = controller.toString,
        publicKeyJwk = publicKeyJwk
      )
    }

    private def okpPublicKeyRepr(pk: PublicKeyData): PublicKeyJwk = {
      pk match {
        case PublicKeyData.ECCompressedKeyData(crv, data) =>
          PublicKeyJwk(
            kty = "OKP",
            crv = crv.name,
            x = Some(data.toStringNoPadding),
            y = None
          )
        case PublicKeyData.ECKeyData(crv, _, _) =>
          throw Exception(s"Uncompressed key for curve ${crv.name} is not supported")
      }
    }

    private def secp256k1Repr(pk: PublicKeyData): PublicKeyJwk = {
      pk match {
        case pk: PublicKeyData.ECCompressedKeyData =>
          val uncomporessed = pk.toUncompressedKeyData.getOrElse(
            throw Exception(s"Conversion to uncompress key is not supported for curve ${pk.crv.name}")
          )
          PublicKeyJwk(
            kty = "EC",
            crv = uncomporessed.crv.name,
            x = Some(uncomporessed.x.toStringNoPadding),
            y = Some(uncomporessed.y.toStringNoPadding)
          )
        case PublicKeyData.ECKeyData(crv, x, y) =>
          PublicKeyJwk(
            kty = "EC",
            crv = crv.name,
            x = Some(x.toStringNoPadding),
            y = Some(y.toStringNoPadding)
          )

      }
    }
  }

}

1	package io.iohk.atala.castor.core.model.did.w3c
2
3	import io.iohk.atala.castor.core.model.did.{
4	DIDData,
5	DIDMetadata,
6	PrismDID,
7	PublicKey,
8	PublicKeyData,
9	Service,
10	VerificationRelationship
11	}
12	import io.iohk.atala.shared.models.HexString
13	import io.iohk.atala.castor.core.model.did.ServiceType
14	import io.circe.Json
15	import io.iohk.atala.castor.core.model.did.ServiceEndpoint
16	import io.iohk.atala.castor.core.model.did.ServiceEndpoint.UriOrJsonEndpoint
17	import io.iohk.atala.castor.core.model.did.EllipticCurve
18	import java.time.format.DateTimeFormatter
19	import java.time.ZoneOffset
20	import java.time.Instant
21
22	object W3CModelHelper extends W3CModelHelper
23
24	private[castor] trait W3CModelHelper {
25		1✔
26	private val XML_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'")
27		×
28	private def toXmlDateTime(time: Instant): String = {	×
29	val zonedDateTime = time.atZone(ZoneOffset.UTC)	×
30	XML_DATETIME_FORMATTER.format(zonedDateTime)
31	}
32
33	extension (didMetadata: DIDMetadata) {	1✔
34	def toW3C: DIDDocumentMetadataRepr = DIDDocumentMetadataRepr(
35	deactivated = didMetadata.deactivated,	1✔
36	canonicalId = didMetadata.canonicalId.map(_.toString),	1✔
UNCOV 37	versionId = HexString.fromByteArray(didMetadata.lastOperationHash.toArray).toString,	×
38	created = didMetadata.created.map(toXmlDateTime),	×
39	updated = didMetadata.updated.map(toXmlDateTime)
40	)
41	}
42
43	extension (didData: DIDData) {	1✔
44	def toW3C(did: PrismDID): DIDDocumentRepr = {
45	import VerificationRelationship.*	1✔
46	val embeddedKeys = didData.publicKeys.map(k => k.toW3C(did, did))	1✔
47	val keyRefWithPurpose = didData.publicKeys.map(k => k.purpose -> s"${did.toString}#${k.id}")	1✔
48	val services = didData.services.map(_.toW3C(did))
49	DIDDocumentRepr(	1✔
50	id = did.toString,	1✔
51	controller = did.toString,
52	verificationMethod = embeddedKeys,	1✔
53	authentication = keyRefWithPurpose.collect { case (Authentication, k) => k },	1✔
54	assertionMethod = keyRefWithPurpose.collect { case (AssertionMethod, k) => k },	1✔
55	keyAgreement = keyRefWithPurpose.collect { case (KeyAgreement, k) => k },	1✔
56	capabilityInvocation = keyRefWithPurpose.collect { case (CapabilityInvocation, k) => k },	1✔
57	capabilityDelegation = keyRefWithPurpose.collect { case (CapabilityDelegation, k) => k },
58	service = services,	1✔
59	context = deriveContext(embeddedKeys, services)
60	)
61	}
62
63	// Reference: https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#constructing-a-json-ld-did-document	1✔
64	private def deriveContext(keys: Seq[PublicKeyRepr], services: Seq[ServiceRepr]): Seq[String] = {	1✔
65	val mandatoryContext = Seq("https://www.w3.org/ns/did/v1")
66	val additionalContext = {	1✔
67	val keyTypes = keys.map(_.`type`).toSet
68	val serviceTypes = services	×
69	.map(_.`type`)	1✔
70	.flatMap {	×
71	case s: String => Seq(s)	1✔
72	case s: Seq[String] => s
73	}	1✔
74	.toSet	×
75	Seq(	×
76	Option.when(keyTypes.contains("JsonWebKey2020"))("https://w3id.org/security/suites/jws-2020/v1"),	×
77	Option.when(serviceTypes.contains("DIDCommMessaging"))("https://didcomm.org/messaging/contexts/v2"),	×
78	Option.when(serviceTypes.contains("LinkedDomains"))(
79	"https://identity.foundation/.well-known/did-configuration/v1"
80	)
81	).flatten
82	}
UNCOV 83	val userDefinedContext = didData.context	×
84	mandatoryContext ++ additionalContext ++ userDefinedContext
85	}
86	}
87
88	extension (service: Service) {	1✔
89	def toW3C(did: PrismDID): ServiceRepr =
90	ServiceRepr(	1✔
91	id = s"${did.toString}#${service.id}",	1✔
92	`type` = serviceTypeToW3C(service.`type`),	1✔
93	serviceEndpoint = serviceEndpointToW3C(service.serviceEndpoint)
94	)
95		1✔
96	private def serviceTypeToW3C(serviceType: ServiceType): String \| Seq[String] = {
97	import ServiceType.*
98	serviceType match {	×
99	case ServiceType.Single(name) => name.value	1✔
100	case names: ServiceType.Multiple => names.values.map(_.value)
101	}
102	}
103		1✔
104	private def serviceEndpointToW3C(serviceEndpoint: ServiceEndpoint): Json = {
105	serviceEndpoint match {	1✔
106	case ServiceEndpoint.Single(uri) =>
107	uri match {	1✔
108	case UriOrJsonEndpoint.Uri(uri) => Json.fromString(uri.value)	1✔
109	case UriOrJsonEndpoint.Json(json) => Json.fromJsonObject(json)
110	}	×
111	case ep: ServiceEndpoint.Multiple =>	×
112	val uris = ep.values.map {	×
113	case UriOrJsonEndpoint.Uri(uri) => Json.fromString(uri.value)	×
114	case UriOrJsonEndpoint.Json(json) => Json.fromJsonObject(json)
115	}	×
116	Json.arr(uris: _*)
117	}
118	}
119	}
120
121	// FIXME: do we need to support uncompress for OKP key types?
122	extension (publicKey: PublicKey) {	1✔
123	def toW3C(did: PrismDID, controller: PrismDID): PublicKeyRepr = {
124	val curve = publicKey.publicKeyData match {	1✔
125	case PublicKeyData.ECCompressedKeyData(crv, _) => crv	1✔
126	case PublicKeyData.ECKeyData(crv, _, _) => crv
127	}
128	val publicKeyJwk = curve match {	1✔
129	case EllipticCurve.SECP256K1 => secp256k1Repr(publicKey.publicKeyData)	×
130	case EllipticCurve.ED25519 => okpPublicKeyRepr(publicKey.publicKeyData)	×
131	case EllipticCurve.X25519 => okpPublicKeyRepr(publicKey.publicKeyData)
132	}
133	PublicKeyRepr(	1✔
134	id = s"${did.toString}#${publicKey.id}",
135	`type` = "JsonWebKey2020",	1✔
136	controller = controller.toString,
137	publicKeyJwk = publicKeyJwk
138	)
139	}
140		×
141	private def okpPublicKeyRepr(pk: PublicKeyData): PublicKeyJwk = {
142	pk match {	×
143	case PublicKeyData.ECCompressedKeyData(crv, data) =>
144	PublicKeyJwk(
145	kty = "OKP",
146	crv = crv.name,	×
147	x = Some(data.toStringNoPadding),
148	y = None
149	)	×
150	case PublicKeyData.ECKeyData(crv, _, _) =>	×
151	throw Exception(s"Uncompressed key for curve ${crv.name} is not supported")
152	}
153	}
154		1✔
155	private def secp256k1Repr(pk: PublicKeyData): PublicKeyJwk = {
156	pk match {	1✔
157	case pk: PublicKeyData.ECCompressedKeyData =>	×
158	val uncomporessed = pk.toUncompressedKeyData.getOrElse(	×
159	throw Exception(s"Conversion to uncompress key is not supported for curve ${pk.crv.name}")
160	)
161	PublicKeyJwk(
162	kty = "EC",
163	crv = uncomporessed.crv.name,	1✔
164	x = Some(uncomporessed.x.toStringNoPadding),	1✔
165	y = Some(uncomporessed.y.toStringNoPadding)
166	)	1✔
167	case PublicKeyData.ECKeyData(crv, x, y) =>
168	PublicKeyJwk(
169	kty = "EC",
170	crv = crv.name,	1✔
171	x = Some(x.toStringNoPadding),	1✔
172	y = Some(y.toStringNoPadding)
173	)
174
175	}
176	}
177	}
178
179	}

input-output-hk / atala-prism-building-blocks / 8699251619

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous