Source code for pyeudiw.satosa.backends.openid4vp.endpoints.request_endpoint

import json
from copy import copy
from typing import Any, Callable

from satosa.attribute_mapping import AttributeMapper
from satosa.context import Context
from satosa.internal import InternalData
from satosa.response import Response

from pyeudiw.duckle_ql.utils import DUCKLE_PRESENTATION, DUCKLE_QUERY_KEY
from pyeudiw.jwk import JWK
from pyeudiw.jwt.exceptions import JWSSigningError
from pyeudiw.jwt.jws_helper import JWSHelper
from pyeudiw.satosa.backends.openid4vp.authorization_request import (
    build_authorization_request_claims,
    configured_response_mode,
    response_encryption_client_metadata,
    response_encryption_key_params,
)
from pyeudiw.satosa.backends.openid4vp.endpoints.vp_base_endpoint import VPBaseEndpoint
from pyeudiw.satosa.backends.openid4vp.schemas.wallet_metadata import (
    CLIENT_ID_SCHEMES_SUPPORTED_CTX,
    REQUEST_OBJ_SIG_ALG_VALUES_SUPPORTED,
    RESPONSE_MODES_SUPPORTED_CTX,
    VP_FORMATS_SUPPORTED_CTX,
    WalletPostRequest,
)
from pyeudiw.trust.dynamic import CombinedTrustEvaluator


[docs] class RequestHandler(VPBaseEndpoint): _REQUEST_OBJECT_TYP = "oauth-authz-req+jwt" _RESP_CONTENT_TYPE = f"application/{_REQUEST_OBJECT_TYP}" def __init__( self, config: dict, internal_attributes: dict[str, dict[str, str | list[str]]], base_url: str, name: str, auth_callback_func: Callable[[Context, InternalData], Response], converter: AttributeMapper, trust_evaluator: CombinedTrustEvaluator, db_engine=None, ) -> None: """ Initialize the AuthorizationHandler with the given configuration, internal attributes, base URL, and name. :param config: Configuration dictionary for the handler. :param internal_attributes: Internal attributes mapping. :param base_url: Base URL for the handler. :param name: Name of the handler. :raises ValueError: If storage or QR code settings are not configured. """ super().__init__( config, internal_attributes, base_url, name, auth_callback_func, converter, trust_evaluator, db_engine, ) self.absolute_response_url = self.attested_https_uri( "response_uris", "response", "/response-uri" ) self.metadata_jwks_by_kids = {i["kid"]: i for i in self.config["metadata_jwks"]} self.trust_evaluator = trust_evaluator self._credential_supported_formats = [ f["format"] for f in config["credential_presentation_handlers"]["formats"] ] client_id_schemes = [] for _, value in config["trust"].items(): client_id = value.get("config", {}).get("client_id") if client_id: prefix = client_id.split(":", 1)[0] client_id_schemes.append(prefix) self._client_id_schemes_supported = ( client_id_schemes if client_id_schemes else None )
[docs] def endpoint(self, context: Context) -> Response: self._log_function_debug("request_endpoint", context) if context.request_method == "GET": try: if not context.qs_params or "state" not in context.qs_params: raise ValueError("state is missing") state = context.qs_params["state"] if not state: raise ValueError("state is missing") except Exception as e400: return self._handle_400( context, "request error: missing or invalid parameter [id]", e400 ) try: document = self.db_engine.get_by_state(state) if not document: raise ValueError("session not found") except ValueError as e401: return self._handle_401( context, "session error: cannot find the session associated to the state", e401, ) except Exception as e500: return self._handle_500( context, "session error: cannot retrieve the session", e500, ) else: try: if not context.state or "SESSION_ID" not in context.state: raise ValueError("session_id is missing") session_id = context.state["SESSION_ID"] if not session_id: raise ValueError("session_id is missing") except Exception as e400: return self._handle_400( context, "request error: missing or invalid parameter [SESSION_ID]", e400, ) try: document = self.db_engine.get_latest_by_session_id(session_id) if not document: raise ValueError("session not found") except ValueError as e401: return self._handle_401( context, "session error: cannot find the session associated to the session_id", e401, ) except Exception as e500: return self._handle_500( context, "session error: cannot retrieve the session", e500, ) if document.get("request_object_issued"): return self._handle_400( context, "request error: request object already issued" ) key_params = response_encryption_key_params(self.config) encryption_key = JWK(key_type=key_params["kty"], ec_crv=key_params["crv"]) private_jwk = dict(encryption_key.jwk) private_jwk["use"] = key_params["use"] private_jwk["alg"] = key_params["alg"] public_jwk = { claim: private_jwk[claim] for claim in ("kty", "crv", "x", "y", "kid") if claim in private_jwk } metadata = self.config.get("metadata") or {} vp_formats = metadata.get("vp_formats_supported") or metadata.get("vp_formats") client_metadata = response_encryption_client_metadata( public_jwk, vp_formats, use=key_params["use"], alg=key_params["alg"] ) request = context.request or {} if context.request_method == "POST": try: wallet_post_request = WalletPostRequest.model_validate( request, context={ RESPONSE_MODES_SUPPORTED_CTX: configured_response_mode( self.config.get("authorization") ), VP_FORMATS_SUPPORTED_CTX: self._credential_supported_formats, CLIENT_ID_SCHEMES_SUPPORTED_CTX: self._client_id_schemes_supported, REQUEST_OBJ_SIG_ALG_VALUES_SUPPORTED: self.config["jwt"].get( "sig_alg_supported" ), }, ) except Exception as e: self._log_warning( context, f"wallet metadata not provided or invalid: {e}" ) wallet_post_request = WalletPostRequest( wallet_metadata=None, wallet_nonce=None, ) else: wallet_post_request = WalletPostRequest( wallet_metadata=None, wallet_nonce=None, ) data = build_authorization_request_claims( self.client_id, document["state"], self.absolute_response_url, self.config["authorization"], client_metadata=client_metadata, submission_data=self._build_submission_data(), wallet_nonce=wallet_post_request.wallet_nonce, ) if _aud := self.config["authorization"].get("aud"): data["aud"] = _aud # take the session created in the pre-request authz endpoint try: document_id = document["document_id"] data_copy = copy(data) if wallet_post_request.wallet_metadata: data_copy["wallet_metadata"] = ( wallet_post_request.wallet_metadata.model_dump() ) self.db_engine.update_request_object( document_id, data_copy, private_jwk ) except ValueError as e401: return self._handle_401( context, "session error: cannot find the session associated to the state", e401, ) except Exception as e500: return self._handle_500( context, "session error: cannot update the session", e500, ) _protected_jwt_headers = { "typ": RequestHandler._REQUEST_OBJECT_TYP, } # load all the trust handlers request jwt header parameters, if any trust_params = self.trust_evaluator.get_jwt_header_trust_parameters( issuer=self.client_id ) _protected_jwt_headers.update(trust_params) if ("x5c" in _protected_jwt_headers) or ("kid" in _protected_jwt_headers): # let helper decide which key best fit the given header, otherise use default hich is the first confgiured key helper = JWSHelper(self.config["metadata_jwks"]) else: helper = JWSHelper(self.default_metadata_private_jwk) alg_values_supported = ( wallet_post_request.wallet_metadata.alg_values_supported if wallet_post_request.wallet_metadata else [] ) or [] try: request_object_jwt = helper.sign( data, protected=_protected_jwt_headers, signing_algs=alg_values_supported, ) self.db_engine.mark_request_object_issued( document["document_id"], request_object_jwt ) self._log_debug(context, f"created request object {request_object_jwt}") return Response( message=request_object_jwt, status="200", content=RequestHandler._RESP_CONTENT_TYPE, ) except JWSSigningError as e400: return self._handle_400( context, "request error: cannot sign the request object, possibly due to a non supported algorithm", e400, ) except Exception as e500: return self._handle_500( context, "internal error: error while processing the request object", e500, )
@property def default_metadata_private_jwk(self) -> dict[str, Any]: """ Returns the default metadata private JWK :return: The first JWK from the metadata_jwks configuration. :rtype: dict[str, Any] """ return self.config["metadata_jwks"][0] def _build_submission_data(self) -> dict[str, Any] | None: raw = (self.config.get(DUCKLE_PRESENTATION) or {}).get(DUCKLE_QUERY_KEY) if raw is None: raw = self.config.get(DUCKLE_QUERY_KEY) if not raw: return None query = json.loads(raw) if isinstance(raw, str) else raw return {DUCKLE_QUERY_KEY: query, "typo": DUCKLE_PRESENTATION}