openid4vp 0.1.0

data/lib/openid4vp/wallet/request_processor.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../client_id"
+require_relative "../request_object"
+require_relative "../authorization_request"
+require_relative "../dc_api"
+require_relative "../response_mode"
+require_relative "../response_encryption"
+require_relative "../metadata/verifier_metadata"
+require_relative "../request_verification/resolver"
+require_relative "../request_verification/verified_request"
+require_relative "../util/uri"
+require_relative "../util/form"
+require_relative "../util/random"
+require_relative "processed_request"
+
+module OpenID4VP
+  class Wallet
+    # Wallet-side Authorization Request processing (design doc §4.21;
+    # OpenID4VP §5, §5.9-§5.10, Appendix A.2): parses `request`/`request_uri`,
+    # dispatches Client Identifier Prefix verification, runs
+    # `AuthorizationRequest#validate!`, and checks the Wallet-specific
+    # constraints (Client Identifier Prefix support, response_mode support,
+    # transaction_data types, vp_formats intersection, response encryption
+    # usability) before returning a `ProcessedRequest`.
+    class RequestProcessor
+      ACCEPT_HEADER = "application/oauth-authz-req+jwt"
+
+      def initialize(wallet)
+        @wallet = wallet
+      end
+
+      # OpenID4VP §5/§5.9-§5.10: processes an Authorization Request given as
+      # a URL String or an already-decoded params Hash.
+      def process(url_or_params)
+        params = normalize_params(url_or_params)
+        client_id = resolve_client_id(params)
+        parsed, wallet_nonce = resolve_request_source(params)
+        request = parsed.nil? ? OpenID4VP::AuthorizationRequest.from_params(params) : nil
+
+        verified = resolver.verify(client_id: client_id, request: request, parsed: parsed, wallet_nonce: wallet_nonce)
+        finalize(verified, wallet_nonce: wallet_nonce)
+      end
+
+      # Appendix A.2: processes a `{protocol, data}` DC API request.
+      def process_dc_api_request(protocol, data, origin:)
+        parsed_dc = OpenID4VP::DcApi.parse_request(protocol, data, origin: origin)
+        verified = parsed_dc.signed ? verify_dc_api_signed(parsed_dc) : verify_dc_api_unsigned(parsed_dc)
+        finalize(verified, dc_api: true, origin: origin)
+      end
+
+      private
+
+      attr_reader :wallet
+
+      def resolver
+        OpenID4VP::RequestVerification::Resolver.new(wallet.verification_config)
+      end
+
+      def normalize_params(url_or_params)
+        url_or_params.is_a?(::String) ? OpenID4VP::Util::URI.params_from(url_or_params) : url_or_params
+      end
+
+      def resolve_client_id(params)
+        raw = params["client_id"]
+        raise OpenID4VP::InvalidRequest, "client_id is required" if raw.nil?
+
+        raw.is_a?(OpenID4VP::ClientId) ? raw : OpenID4VP::ClientId.parse(raw)
+      end
+
+      # request vs request_uri (OpenID4VP §5): mutually exclusive. Returns
+      # `[parsed, wallet_nonce]`: `parsed` is nil for an unsigned request
+      # (built by the caller from `params` instead), `wallet_nonce` is only
+      # set for the request_uri POST method (§5.10).
+      def resolve_request_source(params)
+        has_request = !params["request"].nil?
+        has_request_uri = !params["request_uri"].nil?
+        if has_request && has_request_uri
+          raise OpenID4VP::InvalidRequest, "request and request_uri must not both be present"
+        end
+
+        return [OpenID4VP::RequestObject.parse(params["request"]), nil] if has_request
+        return fetch_by_reference(params) if has_request_uri
+
+        [nil, nil]
+      end
+
+      def fetch_by_reference(params)
+        method = resolve_request_uri_method(params["request_uri_method"])
+        method == "get" ? fetch_get(params["request_uri"]) : fetch_post(params["request_uri"])
+      end
+
+      def resolve_request_uri_method(raw)
+        return "get" if raw.nil?
+        return raw if %w[get post].include?(raw)
+
+        raise OpenID4VP::InvalidRequestUriMethod, "invalid request_uri_method: #{raw.inspect}"
+      end
+
+      def fetch_get(request_uri)
+        response = wallet.http.get(request_uri, headers: { "accept" => ACCEPT_HEADER })
+        check_http_status!(response)
+        [OpenID4VP::RequestObject.parse(response.body), nil]
+      end
+
+      # OpenID4VP §5.10: a POST carries a fresh wallet_nonce and the
+      # Wallet's metadata, and MUST get back a Request Object echoing that
+      # wallet_nonce (checked by Resolver#verify via `wallet_nonce:`).
+      def fetch_post(request_uri)
+        wallet_nonce = OpenID4VP::Util::Random.nonce
+        body = OpenID4VP::Util::Form.encode("wallet_metadata" => wallet.metadata.to_h, "wallet_nonce" => wallet_nonce)
+        headers = { "content-type" => "application/x-www-form-urlencoded", "accept" => ACCEPT_HEADER }
+        response = wallet.http.post(request_uri, body: body, headers: headers)
+        check_http_status!(response)
+        [OpenID4VP::RequestObject.parse(response.body), wallet_nonce]
+      end
+
+      def check_http_status!(response)
+        return if (200..299).cover?(response.status)
+
+        raise OpenID4VP::InvalidRequest, "request_uri fetch failed (#{response.status})"
+      end
+
+      # Appendix A.3.2.2: a multisigned DC API request carries one signature
+      # per Client Identifier (Trust Framework), each verifiable
+      # independently -- a Wallet supporting only some of the listed Client
+      # Identifier Prefixes verifies (only) the first one it supports,
+      # rather than requiring every signature (for prefixes it may not even
+      # have the means to verify) to succeed. A signed (non-multisigned)
+      # request has exactly one candidate, so this also covers §A.3.2.1.
+      def verify_dc_api_signed(parsed_dc)
+        supported = parsed_dc.requests.find { |parsed| wallet.metadata.supports_prefix?(parsed.request.client_id) }
+        raise OpenID4VP::InvalidRequest, "no supported client_id prefix in signed request" if supported.nil?
+
+        resolver.verify(
+          client_id: supported.request.client_id, request: supported.request, parsed: supported, dc_api: true
+        )
+      end
+
+      # Appendix A.2/A.3.1: an unsigned DC API request carries no client_id
+      # (any present value is ignored) and is not verified.
+      def verify_dc_api_unsigned(parsed_dc)
+        request = parsed_dc.request
+        OpenID4VP::RequestVerification::VerifiedRequest.new(
+          request: request, client_id: nil, verifier_metadata: request.client_metadata,
+          signed: false, signing_key: nil, parsed: nil, attestation: nil
+        )
+      end
+
+      def finalize(verified, wallet_nonce: nil, dc_api: false, origin: nil)
+        request = verified.request
+        request.validate!(scope_resolver: wallet.scope_resolver, signed: verified.signed, dc_api: dc_api)
+
+        check_prefix!(verified.client_id) if verified.client_id
+        check_response_mode!(request.response_mode)
+        validate_transaction_data!(request.transaction_data)
+
+        vp_formats = compute_vp_formats(verified.verifier_metadata)
+        check_formats!(request.effective_dcql_query, vp_formats)
+        encryption = build_encryption(request.response_mode, verified.verifier_metadata)
+
+        build_processed_request(verified, request, wallet_nonce, dc_api, origin, vp_formats, encryption)
+      end
+
+      def build_processed_request(verified, request, wallet_nonce, dc_api, origin, vp_formats, encryption)
+        audience = dc_api ? OpenID4VP::DcApi.audience(origin) : request.audience
+
+        OpenID4VP::Wallet::ProcessedRequest.new(
+          request: request, client_id: verified.client_id, verified: verified,
+          verifier_metadata: verified.verifier_metadata, audience: audience, response_mode: request.response_mode,
+          return_uri: request.return_uri, dc_api: dc_api, origin: origin, vp_formats: vp_formats,
+          dcql_query: request.effective_dcql_query, transaction_data: request.transaction_data || [],
+          encryption: encryption, wallet_nonce: wallet_nonce
+        )
+      end
+
+      # OpenID4VP §8.5: "The Wallet does not support the Client Identifier
+      # Prefix passed in the Authorization Request."
+      def check_prefix!(client_id)
+        return if wallet.metadata.supports_prefix?(client_id)
+
+        raise OpenID4VP::InvalidRequest, "unsupported client_id prefix"
+      end
+
+      def check_response_mode!(response_mode)
+        supported = wallet.metadata.response_modes_supported
+        return if supported.nil? || supported.include?(response_mode)
+
+        raise OpenID4VP::InvalidRequest, "unsupported response_mode"
+      end
+
+      # OpenID4VP §8.4/§8.5: unsupported transaction_data types raise
+      # invalid_transaction_data.
+      def validate_transaction_data!(entries)
+        (entries || []).each { |entry| wallet.transaction_data_types.validate!(entry) }
+      end
+
+      # OpenID4VP §10.1: the vp_formats in effect for this request -- the
+      # Wallet's own vp_formats_supported, narrowed to what the Verifier
+      # also supports when it declared vp_formats_supported.
+      def compute_vp_formats(verifier_metadata)
+        wallet_formats = wallet.metadata.vp_formats_supported
+        verifier_formats = verifier_metadata&.vp_formats_supported
+        verifier_formats ? wallet_formats.intersect(verifier_formats) : wallet_formats
+      end
+
+      # OpenID4VP §8.5: vp_formats_not_supported when the query requests a
+      # credential format outside the (possibly narrowed) vp_formats.
+      def check_formats!(dcql_query, vp_formats)
+        return if dcql_query.nil?
+
+        dcql_query.credentials.each do |credential_query|
+          next if vp_formats.formats.include?(credential_query.format)
+
+          raise OpenID4VP::VpFormatsNotSupported, "unsupported credential format: #{credential_query.format}"
+        end
+      end
+
+      # OpenID4VP §8.3: for an encrypted response_mode, resolves the
+      # Verifier's encryption key/alg/enc now so an unusable configuration
+      # is reported eagerly rather than at response-build time.
+      def build_encryption(response_mode, verifier_metadata)
+        return nil unless OpenID4VP::ResponseMode.encrypted?(response_mode)
+
+        encryption = OpenID4VP::ResponseEncryption.new(
+          verifier_metadata: verifier_metadata || OpenID4VP::Metadata::VerifierMetadata.new({}),
+          wallet_supported_algs: wallet.metadata.authorization_encryption_alg_values_supported,
+          wallet_supported_encs: wallet.metadata.authorization_encryption_enc_values_supported
+        )
+        encryption.key
+        encryption.enc
+        encryption
+      end
+    end
+  end
+end

data/lib/openid4vp/wallet/response_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../authorization_response"
+require_relative "presenter"
+
+module OpenID4VP
+  class Wallet
+    # OpenID4VP §8: builds the encoded Authorization Response for a
+    # (`ProcessedRequest`, `DCQL::Selection`) pair -- presenting every
+    # matched Credential (`Presenter`) and encoding the result for the
+    # request's Response Mode (`AuthorizationResponse#encode`).
+    class ResponseBuilder
+      # response: the `AuthorizationResponse`. encoded: its
+      # `AuthorizationResponse::Encoded`. vp_token: `response.vp_token` (a
+      # `VpToken`), exposed directly for convenience.
+      BuiltResponse = Struct.new(:response, :encoded, :vp_token, keyword_init: true)
+
+      def initialize(wallet)
+        @wallet = wallet
+      end
+
+      # Raises OpenID4VP::AccessDenied when `selection` does not satisfy the
+      # request's DCQL query (OpenID4VP §8.5: "The Wallet does not have a
+      # Credential that matches the requested parameters.").
+      def build(processed, selection)
+        raise OpenID4VP::AccessDenied, "no matching credentials" unless selection.satisfiable?
+
+        response = build_response(processed, selection)
+        encoded = response.encode(processed.response_mode, redirect_uri: processed.return_uri,
+                                                           encryption: processed.encryption)
+        BuiltResponse.new(response: response, encoded: encoded, vp_token: response.vp_token)
+      end
+
+      private
+
+      def build_response(processed, selection)
+        vp_token = Presenter.new(@wallet).present(processed, selection)
+        state = processed.dc_api ? nil : processed.request.state
+        OpenID4VP::AuthorizationResponse.new(vp_token: vp_token, state: state)
+      end
+    end
+  end
+end

data/lib/openid4vp/wallet/submission.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../response_mode"
+
+module OpenID4VP
+  class Wallet
+    # The result of `Wallet#submit`: `kind` says how the built response was
+    # delivered -- `:posted` (direct_post[.jwt]; the Verifier's HTTP
+    # response is consulted for `redirect_uri`/`status`), `:redirect` (a
+    # fragment/query URL for the caller's own HTTP layer to redirect the
+    # user agent to), or `:dc_api` (the `data` object for the caller's own
+    # Digital Credentials API bridge to return to the browser).
+    Submission = Struct.new(:kind, :redirect_uri, :data, :status, keyword_init: true)
+
+    # OpenID4VP §8.2/§8.3.1 (wallet side): delivers a
+    # `ResponseBuilder::BuiltResponse`'s encoded Authorization Response per
+    # the request's Response Mode, returning a `Submission`.
+    class Submitter
+      FORM_HEADERS = { "content-type" => "application/x-www-form-urlencoded" }.freeze
+
+      def initialize(wallet)
+        @wallet = wallet
+      end
+
+      def submit(processed, built)
+        return post(processed, built.encoded) if OpenID4VP::ResponseMode.direct_post?(processed.response_mode)
+        return Submission.new(kind: :dc_api, data: built.encoded.data) if
+          OpenID4VP::ResponseMode.dc_api?(processed.response_mode)
+
+        Submission.new(kind: :redirect, redirect_uri: built.encoded.url)
+      end
+
+      private
+
+      # OpenID4VP §8.2: POSTs the response, then reads the Verifier's JSON
+      # body for an OPTIONAL `redirect_uri` the caller's frontend should
+      # navigate to next (an empty body is valid and yields a nil
+      # redirect_uri).
+      def post(processed, encoded)
+        response = @wallet.http.post(processed.return_uri, body: encoded.form_body, headers: FORM_HEADERS)
+        check_status!(response)
+        Submission.new(kind: :posted, redirect_uri: redirect_uri_from(response.body), status: response.status)
+      end
+
+      def check_status!(response)
+        return if (200..299).cover?(response.status)
+
+        raise OpenID4VP::InvalidResponse, "response rejected (#{response.status})"
+      end
+
+      def redirect_uri_from(body)
+        return nil if body.nil? || body.strip.empty?
+
+        parsed = parse_json!(body)
+        raise OpenID4VP::InvalidResponse, "response body is not a JSON object" unless parsed.is_a?(::Hash)
+
+        parsed["redirect_uri"]
+      end
+
+      def parse_json!(body)
+        ::JSON.parse(body)
+      rescue ::JSON::ParserError
+        raise OpenID4VP::InvalidResponse, "response body is not valid JSON"
+      end
+    end
+  end
+end

data/lib/openid4vp/wallet.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "wallet/config"
+require_relative "wallet/request_processor"
+require_relative "wallet/response_builder"
+require_relative "wallet/submission"
+require_relative "dcql/evaluator"
+require_relative "error_response"
+require_relative "response_mode"
+
+module OpenID4VP
+  # OpenID4VP Wallet orchestration (design doc §4.21): processes
+  # Authorization Requests (by value, by reference, or over the W3C Digital
+  # Credentials API), verifying the Client Identifier Prefix (§5.9) and
+  # validating the request (§5, §5.10); evaluates a DCQL query against the
+  # Wallet's Credentials (`#evaluate`), presents and encodes the
+  # Authorization Response (`#build_response`), and submits it per the
+  # Response Mode (`#submit`) -- or does all of that in one call
+  # (`#respond`).
+  class Wallet
+    # The documented public name for `ResponseBuilder::BuiltResponse`
+    # (`#build_response`'s return type).
+    BuiltResponse = ResponseBuilder::BuiltResponse
+
+    def initialize(**)
+      @config = Config.new(**)
+      @request_processor = RequestProcessor.new(self)
+    end
+
+    attr_reader :config, :request_processor
+
+    def http
+      config.http
+    end
+
+    def metadata
+      config.metadata
+    end
+
+    def formats
+      config.formats
+    end
+
+    def verification_config
+      config.verification
+    end
+
+    def transaction_data_types
+      config.transaction_data_types
+    end
+
+    def scope_resolver
+      config.scope_resolver
+    end
+
+    def clock
+      config.clock
+    end
+
+    def now
+      config.now
+    end
+
+    def holder_keys
+      config.holder_keys
+    end
+
+    # OpenID4VP §5, §5.9-§5.10: parses and verifies `url_or_params` (a
+    # request URL/String, or an already-decoded params Hash), returning a
+    # `ProcessedRequest`.
+    def process_request(url_or_params)
+      request_processor.process(url_or_params)
+    end
+
+    # OpenID4VP Appendix A: parses and verifies a `{protocol, data}` DC API
+    # request, returning a `ProcessedRequest`.
+    def process_dc_api_request(protocol, data, origin:)
+      request_processor.process_dc_api_request(protocol, data, origin: origin)
+    end
+
+    # OpenID4VP §6.4: evaluates `processed.dcql_query` against `credentials`
+    # (an Array of `OpenID4VP::Credential`), returning a `DCQL::Selection`.
+    def evaluate(processed, credentials)
+      OpenID4VP::DCQL::Evaluator.new(processed.dcql_query, credentials, hooks: config.authority_hooks).evaluate
+    end
+
+    # OpenID4VP §8: builds and encodes the Authorization Response for
+    # `selection` (a `DCQL::Selection`, from `#evaluate`). Raises
+    # OpenID4VP::AccessDenied when `selection` is not `#satisfiable?`.
+    def build_response(processed, selection)
+      ResponseBuilder.new(self).build(processed, selection)
+    end
+
+    # OpenID4VP §8.5: builds and encodes an Authorization Error Response
+    # for `exception`. `processed`, when given, supplies the response_mode/
+    # return_uri/state; otherwise pass them via `response_mode:`/
+    # `return_uri:` directly (e.g. when `exception` was raised by
+    # `#process_request` itself, before a `ProcessedRequest` exists).
+    def build_error(processed, exception, response_mode: nil, return_uri: nil)
+      mode = processed ? processed.response_mode : response_mode
+      uri = processed ? processed.return_uri : return_uri
+      state = processed&.request&.state
+
+      OpenID4VP::ErrorResponse.from_exception(exception, state: state).encode(mode, redirect_uri: uri)
+    end
+
+    # OpenID4VP §8.2/§8.3.1: delivers `built` (a
+    # `ResponseBuilder::BuiltResponse`, from `#build_response`) per
+    # `processed.response_mode`, returning a `Submission`.
+    def submit(processed, built)
+      Submitter.new(self).submit(processed, built)
+    end
+
+    # Convenience: processes `url_or_params`, evaluates it against
+    # `credentials`, builds and submits the Authorization Response, and
+    # returns the resulting `Submission`. When an `OpenID4VP::Error` is
+    # raised after the request was successfully processed AND its
+    # response_mode is direct_post[.jwt], the corresponding Authorization
+    # Error Response is POSTed to `processed.return_uri` (its own outcome is
+    # not inspected) before the original exception is re-raised.
+    def respond(url_or_params, credentials)
+      processed = process_request(url_or_params)
+      selection = evaluate(processed, credentials)
+      built = build_response(processed, selection)
+      submit(processed, built)
+    rescue OpenID4VP::Error => e
+      post_error(processed, e) if processed
+      raise
+    end
+
+    private
+
+    def post_error(processed, exception)
+      return unless OpenID4VP::ResponseMode.direct_post?(processed.response_mode)
+
+      encoded = build_error(processed, exception)
+      http.post(processed.return_uri, body: encoded.form_body, headers: Submitter::FORM_HEADERS)
+    rescue OpenID4VP::Error
+      nil
+    end
+  end
+end

data/lib/openid4vp/x509/chain_validator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../x509"
+
+module OpenID4VP
+  module X509
+    # Validates an X.509 certificate chain (as presented e.g. via a JOSE/COSE
+    # `x5c` header) against a fixed set of trust anchors, using
+    # OpenSSL::X509::Store.
+    class ChainValidator
+      def initialize(trust_anchors:, time: nil)
+        @trust_anchors = trust_anchors.map { |c| OpenID4VP::X509.parse(c) }
+        @time = time
+      end
+
+      # chain: leaf certificate first, followed by zero or more untrusted
+      # intermediates (each an OpenSSL::X509::Certificate, DER or PEM
+      # string). Returns the parsed leaf certificate on success.
+      def validate!(chain)
+        certs = Array(chain).map { |c| OpenID4VP::X509.parse(c) }
+        leaf, *intermediates = certs
+        raise OpenID4VP::VerificationError, "empty certificate chain" if leaf.nil?
+
+        store = build_store
+        store_context = OpenSSL::X509::StoreContext.new(store, leaf, intermediates)
+        return leaf if store_context.verify
+
+        raise OpenID4VP::VerificationError, "certificate chain validation failed: #{store_context.error_string}"
+      end
+
+      private
+
+      def build_store
+        store = OpenSSL::X509::Store.new
+        store.time = @time if @time
+        @trust_anchors.each { |anchor| store.add_cert(anchor) }
+        store
+      end
+    end
+  end
+end

data/lib/openid4vp/x509.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "util"
+require_relative "util/base64url"
+
+module OpenID4VP
+  # Framework-agnostic X.509 helpers: parsing, subjectAltName dNSName
+  # extraction, key identifier extensions and x5c (RFC 7515 §4.1.6)
+  # conversions. See also `OpenID4VP::X509::ChainValidator`.
+  module X509
+    module_function
+
+    # Accepts an OpenSSL::X509::Certificate, a DER string or a PEM string.
+    def parse(input)
+      case input
+      when OpenSSL::X509::Certificate
+        input
+      when String
+        begin
+          OpenSSL::X509::Certificate.new(input)
+        rescue OpenSSL::X509::CertificateError
+          raise OpenID4VP::InvalidRequest, "invalid X.509 certificate"
+        end
+      else
+        raise OpenID4VP::InvalidRequest, "invalid X.509 certificate: #{input.class}"
+      end
+    end
+
+    # subjectAltName dNSName entries, in order.
+    def dns_sans(cert)
+      ext = extension(parse(cert), "subjectAltName")
+      return [] unless ext
+
+      ext.value.split(",").filter_map do |entry|
+        entry = entry.strip
+        entry.delete_prefix("DNS:") if entry.start_with?("DNS:")
+      end
+    end
+
+    # base64url(SHA-256(DER)) of the certificate, as used for the
+    # OID4VP `x509_hash` client identifier prefix.
+    def leaf_hash_b64(cert)
+      Util::Base64url.encode(Util.sha256(parse(cert).to_der))
+    end
+
+    # Raw keyIdentifier bytes from the authorityKeyIdentifier extension, or
+    # nil if the certificate has none / it carries no keyIdentifier.
+    def authority_key_identifier(cert)
+      ext = extension(parse(cert), "authorityKeyIdentifier")
+      return nil unless ext
+
+      # AuthorityKeyIdentifier ::= SEQUENCE { keyIdentifier [0] IMPLICIT
+      # OCTET STRING OPTIONAL, ... }. extnValue is the OCTET STRING wrapping
+      # that SEQUENCE's DER encoding.
+      seq = OpenSSL::ASN1.decode(extension_value_octets(ext))
+      key_id = seq.value.find { |v| v.tag.zero? && v.tag_class == :CONTEXT_SPECIFIC }
+      key_id&.value
+    end
+
+    # Raw keyIdentifier bytes from the subjectKeyIdentifier extension, or nil.
+    def subject_key_identifier(cert)
+      ext = extension(parse(cert), "subjectKeyIdentifier")
+      return nil unless ext
+
+      # SubjectKeyIdentifier ::= OCTET STRING, so extnValue wraps a single
+      # nested OCTET STRING whose value is the raw key identifier.
+      OpenSSL::ASN1.decode(extension_value_octets(ext)).value
+    end
+
+    # RFC 7515 x5c: standard (padded) base64 of each certificate's DER,
+    # leaf first.
+    def x5c_from(certs)
+      certs.map { |c| [parse(c).to_der].pack("m0") }
+    end
+
+    def certs_from_x5c(array)
+      array.map do |b64|
+        der =
+          begin
+            b64.unpack1("m0")
+          rescue ArgumentError
+            raise OpenID4VP::InvalidRequest, "invalid x5c entry"
+          end
+        parse(der)
+      end
+    end
+
+    # The extnValue OCTET STRING's raw contents (the DER encoding of the
+    # extension's actual value), decoded from the extension's own DER form
+    # since OpenSSL::X509::Extension does not expose it directly.
+    def extension_value_octets(ext)
+      asn1_extension = OpenSSL::ASN1.decode(ext.to_der)
+      asn1_extension.value.last.value
+    end
+    private_class_method :extension_value_octets
+
+    def extension(cert, oid)
+      cert.extensions.find { |e| e.oid == oid }
+    end
+    private_class_method :extension
+  end
+end

data/lib/openid4vp.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+require "securerandom"
+require "uri"
+require "cbor"
+
+require_relative "openid4vp/version"
+require_relative "openid4vp/errors"
+
+# Every file under lib/openid4vp declares its own load-time dependencies
+# (superclasses, mixins, constants used in class bodies) with require_relative,
+# so the load order of this glob does not matter.
+Dir[File.join(__dir__, "openid4vp", "**", "*.rb")].each { |file| require file }
+
+module OpenID4VP
+end