Source code for pyeudiw.satosa.backends.openid4vp.vp_mdoc_cbor

import hashlib
from datetime import datetime, timezone

import cbor2
from cryptography.hazmat.primitives import serialization
from pymdoccbor.mdoc.verifier import MdocCbor

from pyeudiw.credential_presentation.base_vp_parser import BaseVPParser
from pyeudiw.satosa.backends.openid4vp.exceptions import (
    MdocCborValidationError,
    VPRevoked,
)
from pyeudiw.status_list.helper import StatusListTokenHelper
from pyeudiw.x509.verify import get_issuer_from_x5c

# ISO 18013-7 Annex B (OpenID4VP): SessionTranscript must have deviceEngagementBytes=null,
# eReaderKeyBytes=null, and handover with OpenID4VPHandover. CBOR map keys may be int or text.
_ST_KEY_DEVICE_ENGAGEMENT = ("deviceEngagementBytes", 0)
_ST_KEY_EREADER = ("eReaderKeyBytes", 1)
_ST_KEY_HANDOVER = ("handover", 2)


def _get_val(d: dict, keys: tuple) -> object:
    for k in keys:
        if k in d:
            return d[k]
    return None


[docs] def openid4vp_handover_info_hash( client_id: str, nonce: str, jwk_thumbprint: bytes, response_uri: str ) -> bytes: """SHA-256 of the CBOR OpenID4VPHandoverInfo array.""" encoded = cbor2.dumps([client_id, nonce, jwk_thumbprint, response_uri]) return hashlib.sha256(encoded).digest()
def _transcript_parts(st: object) -> tuple: if isinstance(st, (list, tuple)) and len(st) == 3: return st[0], st[1], st[2] if isinstance(st, dict): return ( _get_val(st, _ST_KEY_DEVICE_ENGAGEMENT), _get_val(st, _ST_KEY_EREADER), _get_val(st, _ST_KEY_HANDOVER), ) raise MdocCborValidationError("invalid SessionTranscript in deviceSigned") def _validate_session_transcript_openid4vp( st: object, expected_hash: bytes | None = None ) -> None: """Validate SessionTranscript conforms to OpenID4VP 1.0 appendix B.2.6.1.""" dev_eng, ereader, handover = _transcript_parts(st) if dev_eng is not None: raise MdocCborValidationError( "SessionTranscript must have deviceEngagementBytes=null for OpenID4VP" ) if ereader is not None: raise MdocCborValidationError( "SessionTranscript must have eReaderKeyBytes=null for OpenID4VP" ) if ( not isinstance(handover, (list, tuple)) or len(handover) != 2 or handover[0] != "OpenID4VPHandover" or not isinstance(handover[1], (bytes, bytearray)) ): raise MdocCborValidationError( "SessionTranscript must include OpenID4VPHandover for OpenID4VP" ) if expected_hash is not None and bytes(handover[1]) != expected_hash: raise MdocCborValidationError("OpenID4VPHandover does not match the request") def _check_session_transcripts_in_mdoc( mdoc: MdocCbor, expected_hash: bytes | None = None ) -> None: """When deviceSigned contains SessionTranscript, validate OpenID4VP profile.""" found = False cdict = mdoc.data_as_cbor_dict for doc in cdict.get("documents", []): inner = doc.value if hasattr(doc, "value") else doc if not isinstance(inner, dict): continue ds = inner.get("deviceSigned", inner.get(2)) if not ds: continue if isinstance(ds, bytes): try: ds = cbor2.loads(ds) except cbor2.CBORDecodeError: continue if not isinstance(ds, dict): continue st = ds.get("sessionTranscript", ds.get(0)) if st is None: continue if isinstance(st, bytes): try: st = cbor2.loads(st) except cbor2.CBORDecodeError: raise MdocCborValidationError( "invalid SessionTranscript in deviceSigned" ) if isinstance(st, (dict, list, tuple)): _validate_session_transcript_openid4vp(st, expected_hash) found = True if expected_hash is not None and not found: raise MdocCborValidationError( "SessionTranscript must include OpenID4VPHandover for OpenID4VP" )
[docs] class VpMDocCbor(BaseVPParser): def _is_expired(self, mdoc: MdocCbor) -> bool: for document in mdoc.documents: try: if document.issuersigned.issuer_auth.payload_as_dict["validityInfo"][ "validUntil" ] < datetime.now(timezone.utc): return True except KeyError: return True return False
[docs] def validate( self, token: str, verifier_id: str, verifier_nonce: str, response_uri: str | None = None, jwk_thumbprint: bytes | None = None, ) -> None: mdoc = MdocCbor() mdoc.loads(data=token) if mdoc.verify() is False: raise MdocCborValidationError("Signature is invalid") expected_hash = None if response_uri and jwk_thumbprint is not None: expected_hash = openid4vp_handover_info_hash( verifier_id, verifier_nonce, jwk_thumbprint, response_uri ) _check_session_transcripts_in_mdoc(mdoc, expected_hash) try: for document in mdoc.documents: x5c = [ cert.public_bytes(encoding=serialization.Encoding.PEM).decode() for cert in document.issuersigned.issuer_auth.x509_certificates ] self.trust_evaluator.get_public_keys( get_issuer_from_x5c(x5c), {"x5c": x5c} ) except Exception as e: raise MdocCborValidationError(f"Error validating keys: {e}") if self._is_expired(mdoc): raise MdocCborValidationError("Credential is expired") for document in mdoc.documents: status = document.issuersigned.issuer_auth.payload_as_dict.get("status") if not isinstance(status, dict) or "status_list" not in status: raise VPRevoked("credential status list is missing") status_list = StatusListTokenHelper.from_status(status) if ( status_list.is_expired() or status_list.get_status(status["status_list"]["idx"]) > 0 ): raise VPRevoked("Status list indicates that the token is revoked")
[docs] def parse(self, token: str) -> dict: mdoc = MdocCbor() mdoc.loads(data=token) mdoc.verify() return mdoc.disclosure_map