openid4vp 0.1.0

data/lib/openid4vp/verifier/request_builder.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../util/random"
+require_relative "../util/uri"
+require_relative "../response_mode"
+require_relative "../authorization_request"
+require_relative "../dc_api"
+require_relative "session"
+require_relative "created_request"
+
+module OpenID4VP
+  class Verifier
+    # Builds and stores the Verifier::Session + Authorization Request (or
+    # DC API request) for `Verifier#create_request` (OpenID4VP §5, §13.3
+    # steps 2-4; design doc §4.20).
+    class RequestBuilder
+      DEFAULT_RESPONSE_MODE = "direct_post"
+
+      def initialize(verifier)
+        @verifier = verifier
+      end
+
+      # rubocop:disable-next Metrics/MethodLength
+      def build(dcql_query:, response_mode: DEFAULT_RESPONSE_MODE, by_reference: nil, request_uri_method: nil,
+                signed: nil, transaction_data: [], verifier_info: [], scope: nil, expected_origins: nil,
+                origin: nil, client_metadata: {}, state: nil, dc_api_protocol: nil)
+        config = @verifier.config
+        is_dc_api = OpenID4VP::ResponseMode.dc_api?(response_mode)
+
+        request_id = OpenID4VP::Util::Random.id
+        nonce = OpenID4VP::Util::Random.nonce
+        session_id = OpenID4VP::Util::Random.id
+        state_value = resolve_state!(is_dc_api, state, request_id)
+
+        signed = resolve_signed!(config, signed)
+        by_reference = resolve_by_reference!(config, by_reference, signed)
+        validate_expected_origins!(is_dc_api, signed, expected_origins)
+
+        metadata_additions, encryption_jwk = config.encryption_metadata(response_mode, request_id)
+        metadata = build_client_metadata(config, client_metadata, metadata_additions)
+
+        params = build_params(
+          config: config, nonce: nonce, state: state_value, response_mode: response_mode, dcql_query: dcql_query,
+          client_metadata: metadata, transaction_data: transaction_data, verifier_info: verifier_info,
+          scope: scope, expected_origins: expected_origins, is_dc_api: is_dc_api
+        )
+
+        request = OpenID4VP::AuthorizationRequest.new(params)
+        request.validate!(scope_resolver: config.scope_resolver, signed: signed, dc_api: is_dc_api)
+
+        outcome = build_outcome(
+          config, request, is_dc_api: is_dc_api, by_reference: by_reference, signed: signed,
+                           request_id: request_id, request_uri_method: request_uri_method, client_metadata: metadata,
+                           dc_api_protocol: dc_api_protocol
+        )
+
+        session = build_session(
+          id: session_id, request_id: request_id, nonce: nonce, state: state_value, response_mode: response_mode,
+          request: request, request_object: outcome[:request_object], encryption_jwk: encryption_jwk,
+          origin: origin, config: config
+        )
+        config.session_store.create(session)
+
+        OpenID4VP::Verifier::CreatedRequest.new(
+          session: session, url: outcome[:url], request_object: outcome[:request_object],
+          dc_api_request: outcome[:dc_api_request], authorization_request: request
+        )
+      end
+
+      private
+
+      def build_session(id:, request_id:, nonce:, state:, response_mode:, request:, request_object:,
+                        encryption_jwk:, origin:, config:)
+        OpenID4VP::Verifier::Session.new(
+          id: id, request_id: request_id, nonce: nonce, state: state, response_mode: response_mode,
+          request: request, request_object: request_object, encryption_jwk: encryption_jwk, origin: origin,
+          created_at: config.now, expires_at: config.now + config.session_ttl
+        )
+      end
+
+      # `state` is always the request_id for non-DC-API flows: the session
+      # store only indexes sessions by request_id, so any other state value
+      # could never be resolved back to a session by the response endpoint
+      # (§13.3 step 6). The `state:` kwarg is kept for API compatibility but
+      # a caller-supplied value is rejected rather than silently ignored.
+      def resolve_state!(is_dc_api, state, request_id)
+        return nil if is_dc_api
+        raise OpenID4VP::ConfigurationError, "state is derived from the request id and cannot be overridden" if state
+
+        request_id
+      end
+
+      def resolve_signed!(config, signed)
+        signed = config.client_id.signed_request_required? if signed.nil?
+
+        if signed && !config.client_id.signed_request_allowed?
+          raise OpenID4VP::ConfigurationError, "#{config.client_id.prefix} client_id cannot sign requests"
+        end
+        if !signed && config.client_id.signed_request_required?
+          raise OpenID4VP::ConfigurationError, "#{config.client_id.prefix} requires a signed request"
+        end
+
+        signed
+      end
+
+      def resolve_by_reference!(config, by_reference, signed)
+        by_reference = !config.request_uri_base.nil? if by_reference.nil?
+
+        if by_reference && config.request_uri_base.nil?
+          raise OpenID4VP::ConfigurationError, "by_reference requires a request_uri_base"
+        end
+        raise OpenID4VP::ConfigurationError, "request_uri requires a signed request object" if by_reference && !signed
+
+        by_reference
+      end
+
+      def validate_expected_origins!(is_dc_api, signed, expected_origins)
+        return unless is_dc_api && signed && expected_origins.nil?
+
+        raise OpenID4VP::ConfigurationError, "expected_origins required for signed DC API requests"
+      end
+
+      def build_client_metadata(config, overrides, additions)
+        metadata = config.client_metadata.merge(overrides || {})
+        metadata["vp_formats_supported"] = config.vp_formats_supported if config.vp_formats_supported
+        metadata.merge(additions)
+      end
+
+      def build_params(config:, nonce:, state:, response_mode:, dcql_query:, client_metadata:, transaction_data:,
+                       verifier_info:, scope:, expected_origins:, is_dc_api:)
+        params = {
+          "response_type" => "vp_token", "client_id" => config.client_id.to_s, "nonce" => nonce,
+          "response_mode" => response_mode
+        }
+        # OpenID4VP §5.9.2: a pre-registered client_id's metadata (formats,
+        # jwks, ...) is already registered out-of-band, so the request MUST
+        # NOT carry a client_metadata parameter -- RequestVerification::
+        # PreRegistered rejects one on the Wallet side (InvalidClient) even
+        # when it is the `{}` this builder would otherwise always send.
+        params["client_metadata"] = client_metadata unless config.client_id.pre_registered?
+        params["state"] = state if state
+        params["dcql_query"] = dcql_query if dcql_query
+        params["scope"] = scope if scope
+        params["transaction_data"] = transaction_data unless transaction_data.nil? || transaction_data.empty?
+        params["verifier_info"] = verifier_info unless verifier_info.nil? || verifier_info.empty?
+        params["expected_origins"] = expected_origins if expected_origins
+        add_return_uri!(params, config, response_mode, is_dc_api)
+        params
+      end
+
+      def add_return_uri!(params, config, response_mode, is_dc_api)
+        if OpenID4VP::ResponseMode.direct_post?(response_mode)
+          raise OpenID4VP::ConfigurationError, "response_uri is not configured" if config.response_uri.nil?
+
+          params["response_uri"] = config.response_uri
+        elsif !is_dc_api
+          if config.redirect_uri.nil?
+            raise OpenID4VP::ConfigurationError, "redirect_uri is required for response_mode #{response_mode}"
+          end
+
+          params["redirect_uri"] = config.redirect_uri
+        end
+      end
+
+      def build_outcome(config, request, is_dc_api:, by_reference:, signed:, request_id:, request_uri_method:,
+                        client_metadata:, dc_api_protocol:)
+        if is_dc_api
+          build_dc_api(request, signed: signed, _dc_api_protocol: dc_api_protocol)
+        elsif by_reference
+          build_by_reference(config, request, request_id: request_id, request_uri_method: request_uri_method,
+                                              client_metadata: client_metadata)
+        else
+          build_by_value(config, request, signed: signed)
+        end
+      end
+
+      # `_dc_api_protocol` is accepted for forward-compatibility with
+      # multisigned DC API requests (not built by this task); unsigned and
+      # signed requests always use their respective DcApi::PROTOCOLS entry.
+      def build_dc_api(request, signed:, _dc_api_protocol: nil)
+        return { url: nil, request_object: nil, dc_api_request: OpenID4VP::DcApi.unsigned_request(request) } unless
+          signed
+
+        jws = nil
+        dc_api_request = OpenID4VP::DcApi.signed_request(request, signer: lambda { |r|
+          jws = @verifier.request_signer.sign(r)
+        })
+        { url: nil, request_object: jws, dc_api_request: dc_api_request }
+      end
+
+      def build_by_reference(config, request, request_id:, request_uri_method:, client_metadata:)
+        request_uri = "#{config.request_uri_base}/#{request_id}"
+        url_params = { "client_id" => config.client_id.to_s, "request_uri" => request_uri }
+        url_params["request_uri_method"] = request_uri_method if request_uri_method
+        url_params["client_metadata"] = ::JSON.generate(client_metadata) if request_uri_method == "post"
+        url = OpenID4VP::Util::URI.with_query(config.authorization_endpoint, url_params)
+
+        request_object = request_uri_method == "post" ? nil : @verifier.request_signer.sign(request)
+        { url: url, request_object: request_object, dc_api_request: nil }
+      end
+
+      def build_by_value(config, request, signed:)
+        if signed
+          jws = @verifier.request_signer.sign(request)
+          url = OpenID4VP::Util::URI.with_query(
+            config.authorization_endpoint, { "client_id" => config.client_id.to_s, "request" => jws }
+          )
+          { url: url, request_object: jws, dc_api_request: nil }
+        else
+          { url: request.to_url(config.authorization_endpoint), request_object: nil, dc_api_request: nil }
+        end
+      end
+    end
+  end
+end

data/lib/openid4vp/verifier/request_signer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../request_object"
+require_relative "../jose/algorithms"
+
+module OpenID4VP
+  class Verifier
+    # Signs Authorization Requests / Request Objects (OpenID4VP §5, §5.10)
+    # on behalf of a `Verifier`, picking the header material required by
+    # the Verifier's Client Identifier Prefix (design doc §4.20).
+    class RequestSigner
+      def initialize(config)
+        @config = config
+      end
+
+      attr_reader :config
+
+      def signing_key
+        config.signing_key
+      end
+
+      def alg
+        return nil if config.signing.nil?
+
+        config.signing[:alg] || OpenID4VP::JOSE::Algorithms.for_key(signing_key)
+      end
+
+      # Signs `request` (an AuthorizationRequest) as a Request Object,
+      # returning the compact JWS. Raises ConfigurationError for the
+      # `redirect_uri` Client Identifier Prefix, which forbids signed
+      # Request Objects (OpenID4VP §5.9).
+      def sign(request, wallet_nonce: nil, aud: OpenID4VP::RequestObject::DEFAULT_AUD)
+        if config.client_id.prefix == "redirect_uri"
+          raise OpenID4VP::ConfigurationError, "redirect_uri requests cannot be signed"
+        end
+
+        OpenID4VP::RequestObject.sign(
+          request, key: signing_key, alg: alg, wallet_nonce: wallet_nonce, aud: aud, **header_options
+        )
+      end
+
+      private
+
+      def header_options
+        case config.client_id.prefix
+        when "x509_san_dns", "x509_hash"
+          { x5c: config.signing[:x5c] }
+        when "decentralized_identifier"
+          { kid: signing_key.kid }
+        when "verifier_attestation"
+          { attestation_jwt: config.attestation_jwt, kid: signing_key.kid }
+        else
+          signing_key.kid ? { kid: signing_key.kid } : {}
+        end
+      end
+    end
+  end
+end

data/lib/openid4vp/verifier/request_uri_endpoint.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../metadata/wallet_metadata"
+require_relative "../metadata/verifier_metadata"
+require_relative "../metadata/vp_formats"
+require_relative "../response_encryption"
+require_relative "../response_mode"
+require_relative "http_result"
+
+module OpenID4VP
+  class Verifier
+    # OpenID4VP §5.10-5.10.2: the Request URI endpoint. Serves the
+    # Verifier's signed Request Object by value, either as-is (GET, or a
+    # cached POST-tailored object) or tailored to the Wallet's `wallet_nonce`
+    # and `wallet_metadata` (POST, per §5.10).
+    class RequestUriEndpoint
+      MAX_WALLET_NONCE_LENGTH = 512
+
+      def initialize(verifier)
+        @verifier = verifier
+      end
+
+      def call(request_id, method:, params: {}, headers: {}) # rubocop:disable Lint/UnusedMethodArgument
+        session = @verifier.session_store.find_by_request_id(request_id)
+        return HttpResult.error(404, "invalid_request", "unknown request") if session.nil?
+        return HttpResult.error(400, "invalid_request", "request already used") unless retrievable?(session)
+
+        dispatch(session, method, params)
+      end
+
+      private
+
+      def retrievable?(session)
+        %i[created request_retrieved].include?(session.status)
+      end
+
+      def dispatch(session, method, params)
+        case method.to_s.upcase
+        when "GET" then handle_get(session)
+        when "POST" then handle_post(session, params)
+        else HttpResult.new(status: 405, headers: HttpResult::NO_STORE, body: "")
+        end
+      end
+
+      def handle_get(session)
+        jws = session.request_object || @verifier.request_signer.sign(session.request)
+        session.request_object = jws
+        persist!(session)
+        HttpResult.jwt(jws)
+      end
+
+      def handle_post(session, params)
+        wallet_metadata = parse_wallet_metadata(params["wallet_metadata"])
+        wallet_nonce = parse_wallet_nonce(params["wallet_nonce"])
+        request = tailor(session, wallet_metadata)
+        validate_signing_alg!(wallet_metadata)
+
+        session.wallet_metadata = wallet_metadata&.to_h
+        session.wallet_nonce = wallet_nonce
+        session.request_object = @verifier.request_signer.sign(request, wallet_nonce: wallet_nonce)
+        persist!(session)
+        HttpResult.jwt(session.request_object)
+      rescue OpenID4VP::Error => e
+        HttpResult.error(400, e.code || "invalid_request", e.description)
+      end
+
+      def persist!(session)
+        session.transition!(:request_retrieved) if session.status == :created
+        @verifier.session_store.update(session)
+      end
+
+      def tailor(session, wallet_metadata)
+        request = session.request
+        return request if wallet_metadata.nil?
+
+        request = tailor_encryption(session, request, wallet_metadata)
+        tailor_formats(request, wallet_metadata)
+      end
+
+      def tailor_encryption(session, request, wallet_metadata)
+        return request unless OpenID4VP::ResponseMode.encrypted?(session.response_mode)
+
+        algs = wallet_metadata.authorization_encryption_alg_values_supported
+        encs = wallet_metadata.authorization_encryption_enc_values_supported
+        return request if algs.nil? && encs.nil?
+
+        verifier_metadata = request.client_metadata || OpenID4VP::Metadata::VerifierMetadata.new({})
+        enc = recompute_enc(verifier_metadata, algs, encs)
+        request.with(client_metadata: verifier_metadata.with(encrypted_response_enc_values_supported: [enc]).to_h)
+      end
+
+      def recompute_enc(verifier_metadata, algs, encs)
+        encryption = OpenID4VP::ResponseEncryption.new(
+          verifier_metadata: verifier_metadata, wallet_supported_algs: algs, wallet_supported_encs: encs
+        )
+        encryption.key
+        encryption.enc
+      rescue OpenID4VP::InvalidRequest
+        raise OpenID4VP::InvalidRequest, "no common encryption algorithm"
+      end
+
+      def tailor_formats(request, wallet_metadata)
+        config_formats = @verifier.config.vp_formats_supported
+        return request if config_formats.nil?
+
+        raw_wallet_formats = wallet_metadata.to_h["vp_formats_supported"]
+        return request if raw_wallet_formats.nil?
+
+        wallet_formats = OpenID4VP::Metadata::VpFormats.from_h(raw_wallet_formats)
+        intersection = OpenID4VP::Metadata::VpFormats.from_h(config_formats).intersect(wallet_formats)
+        raise OpenID4VP::VpFormatsNotSupported, "no common vp_formats_supported" if intersection.empty?
+
+        verifier_metadata = request.client_metadata || OpenID4VP::Metadata::VerifierMetadata.new({})
+        request.with(client_metadata: verifier_metadata.with(vp_formats_supported: intersection.to_h).to_h)
+      end
+
+      def validate_signing_alg!(wallet_metadata)
+        return if wallet_metadata.nil?
+
+        algs = wallet_metadata.request_object_signing_alg_values_supported
+        return if algs.nil? || algs.include?(@verifier.request_signer.alg)
+
+        raise OpenID4VP::InvalidRequest, "wallet does not support this Verifier's request object signing algorithm"
+      end
+
+      def parse_wallet_metadata(raw)
+        return nil if raw.nil?
+
+        hash = raw.is_a?(::String) ? parse_json_string(raw) : raw
+        OpenID4VP::Metadata::WalletMetadata.new(hash)
+      end
+
+      def parse_json_string(str)
+        ::JSON.parse(str)
+      rescue ::JSON::ParserError
+        raise OpenID4VP::InvalidRequest, "wallet_metadata is not valid JSON"
+      end
+
+      def parse_wallet_nonce(raw)
+        return nil if raw.nil?
+        unless raw.is_a?(::String) && raw.length <= MAX_WALLET_NONCE_LENGTH
+          raise OpenID4VP::InvalidRequest,
+                "wallet_nonce must be a string of at most #{MAX_WALLET_NONCE_LENGTH} characters"
+        end
+
+        raw
+      end
+    end
+  end
+end

data/lib/openid4vp/verifier/response_endpoint.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../authorization_response"
+require_relative "../error_response"
+require_relative "../response_endpoint_result"
+require_relative "../jose/jwe"
+require_relative "../response_mode"
+require_relative "../util/random"
+require_relative "../util/uri"
+require_relative "http_result"
+require_relative "response_validator"
+
+module OpenID4VP
+  class Verifier
+    # OpenID4VP §8.2/§8.3.1/§13.3: the Response endpoint, receiving the
+    # Wallet's Authorization Response (or Authorization Error Response) for
+    # a direct_post[.jwt] session, or (via the `session_id:` kwarg) a DC API
+    # session for which there is no request/state parameter to look it up by.
+    class ResponseEndpoint
+      def initialize(verifier)
+        @verifier = verifier
+      end
+
+      def call(params, headers: {}, session_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+        session, error, decoded = locate_session(params, session_id)
+        return error if error
+        return HttpResult.error(400, "invalid_request", "response already received") unless awaiting_response?(session)
+
+        process(session, params, decoded)
+      rescue OpenID4VP::InvalidRequest, OpenID4VP::InvalidResponse => e
+        HttpResult.error(400, e.code || "invalid_request", e.description)
+      end
+
+      private
+
+      def awaiting_response?(session)
+        %i[created request_retrieved].include?(session.status)
+      end
+
+      # DC API sessions have no request/state parameter for a Wallet to send
+      # back over HTTP, so their caller passes `session_id` directly;
+      # otherwise the session is located from `params` (§13.3/§14.3.2). Each
+      # `locate_by_*` returns `[session, error, decoded]`: `decoded` is only
+      # ever non-nil when locating the session already required decrypting
+      # the response (the static-key path below), so `#process` can reuse it
+      # instead of decrypting twice.
+      def locate_session(params, session_id)
+        return locate_by_session_id(session_id) if session_id
+
+        locate_by_params(params)
+      end
+
+      def locate_by_session_id(session_id)
+        session = @verifier.session(session_id)
+        session ? [session, nil, nil] : [nil, HttpResult.error(404, "invalid_request", "unknown session"), nil]
+      end
+
+      def locate_by_params(params)
+        return locate_by_response(params["response"]) if params["response"]
+
+        locate_by_state(params["state"])
+      end
+
+      # §8.3: an encrypted direct_post.jwt/dc_api.jwt response is located by
+      # the `kid` of its JWE header. For ephemeral encryption that `kid` is
+      # the session's request_id (Task 25); for static encryption keys it
+      # instead identifies one of `config.encryption[:keys]`, so the
+      # response must be decrypted with those *before* a session can be
+      # found -- by the decrypted payload's `state` (§13.3).
+      def locate_by_response(compact_jwe)
+        header = OpenID4VP::JOSE::JWE.peek(compact_jwe)
+        kid = header["kid"]
+        ephemeral_session = kid && @verifier.session_store.find_by_request_id(kid)
+        return [ephemeral_session, nil, nil] if ephemeral_session
+
+        locate_by_static_response(compact_jwe, kid)
+      end
+
+      def locate_by_static_response(compact_jwe, kid)
+        keys = static_encryption_keys
+        unless static_key_candidate?(keys, kid)
+          return [nil, HttpResult.error(400, "invalid_request", "unknown key id"), nil]
+        end
+
+        decoded = OpenID4VP::AuthorizationResponse.decode(
+          OpenID4VP::ResponseMode::DIRECT_POST_JWT, { "response" => compact_jwe }, decryption_keys: keys
+        )
+        session, error, = locate_by_state(decoded.response.state)
+        error ? [nil, error, nil] : [session, nil, decoded]
+      end
+
+      def static_encryption_keys
+        encryption = @verifier.config.encryption
+        encryption && encryption[:keys]
+      end
+
+      def static_key_candidate?(keys, kid)
+        return false if keys.nil? || keys.empty?
+
+        kid.nil? || keys.any? { |key| key.kid == kid }
+      end
+
+      # Also used for the unencrypted error-response fallback of an
+      # otherwise-encrypted response_mode (§8.3.1: error responses are never
+      # encrypted).
+      def locate_by_state(state)
+        session = state && @verifier.session_store.find_by_request_id(state)
+        session ? [session, nil, nil] : [nil, HttpResult.error(400, "invalid_request", "unknown state"), nil]
+      end
+
+      def process(session, params, decoded)
+        decoded ||= OpenID4VP::AuthorizationResponse.decode(
+          session.response_mode, params, decryption_keys: decryption_keys(session)
+        )
+        verify_state!(session, decoded)
+        store!(session, decoded)
+        finish(session)
+      end
+
+      def decryption_keys(session)
+        return [session.encryption_jwk] if session.encryption_jwk
+
+        static_encryption_keys || []
+      end
+
+      # §14.3.2: an encrypted response's state (unlike an unencrypted one) was
+      # not itself used to locate the session, so it is checked here instead.
+      # DC API responses have no state to check (§13.3/RequestBuilder never
+      # sets one for them); every other encrypted mode MUST carry one that
+      # matches the session's, or the response is rejected (§8.2/§14.3.2).
+      def verify_state!(session, decoded)
+        return unless decoded.encrypted
+        return if OpenID4VP::ResponseMode.dc_api?(session.response_mode)
+        return if decoded.response.state == session.state
+
+        raise OpenID4VP::InvalidResponse, "state mismatch"
+      end
+
+      def store!(session, decoded)
+        response = decoded.response
+        if response.is_a?(OpenID4VP::ErrorResponse)
+          store_error!(session, response)
+        else
+          store_success!(session, decoded, response)
+        end
+      end
+
+      def store_error!(session, response)
+        session.error = { "code" => response.error, "description" => response.error_description }
+        session.transition!(:response_received)
+        session.transition!(:failed)
+      end
+
+      def store_success!(session, decoded, response)
+        session.response_params = response.to_payload
+        session.response_encryption = encryption_summary(decoded) if decoded.encrypted
+        session.transition!(:response_received)
+        verify_on_receipt!(session)
+      end
+
+      def encryption_summary(decoded)
+        header = decoded.encryption_header
+        { "kid" => header["kid"], "alg" => header["alg"], "enc" => header["enc"] }
+      end
+
+      # OpenID4VP §8.6/§14.1: a Verifier configured with
+      # `verify_on_receipt: true` validates the response immediately
+      # (storing its result/error and transitioning the session to
+      # `:verified`/`:failed`) rather than waiting for `fetch_response`. The
+      # outcome is only ever observable via `fetch_response`/`result`: a
+      # validation failure here is swallowed (the session is already left
+      # `:failed` with the error stored by `ResponseValidator#verify`) so the
+      # Wallet still gets the normal 200 `{redirect_uri}` response and learns
+      # nothing about why verification failed (OpenID4VP §8.2: the Response
+      # endpoint's HTTP response is not the channel for reporting that).
+      def verify_on_receipt!(session)
+        return unless @verifier.config.verify_on_receipt
+
+        @verifier.response_validator.verify(session)
+      rescue OpenID4VP::InvalidResponse
+        nil
+      end
+
+      def finish(session)
+        config = @verifier.config
+        session.response_code = OpenID4VP::Util::Random.response_code if config.redirect_uri_base
+        @verifier.session_store.update(session)
+
+        redirect_uri = config.redirect_uri_base && OpenID4VP::Util::URI.with_fragment(
+          config.redirect_uri_base, "response_code" => session.response_code
+        )
+        HttpResult.json(200, OpenID4VP::ResponseEndpointResult.new(redirect_uri: redirect_uri).to_h)
+      end
+    end
+  end
+end