didit-sdk 1.0.0

data/lib/didit/authentication/http.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module Didit
+  class Authentication
+    # Requests to the issuer over the SDK's transport ({Didit::Internal::Transport}):
+    # never retried, redirects never followed, the API key never sent.
+    # @api private
+    class Http
+      # One request to the issuer.
+      class Call
+        # @return [String] "GET", "POST" or "DELETE"
+        attr_reader :http_method
+        # @return [URI::Generic]
+        attr_reader :uri
+        # @return [String, nil] sent as +Authorization: Bearer+
+        attr_reader :bearer
+        # @return [Hash{String => String}, nil] form-encoded body
+        attr_reader :form
+        # @return [Hash{String => Object}, nil] JSON body
+        attr_reader :json
+        # @return [Array<String>] tokens, codes and verifiers redacted from errors
+        attr_reader :secrets
+
+        def initialize(http_method, uri, bearer: nil, form: nil, json: nil, secrets: [])
+          @http_method = http_method
+          @uri = uri
+          @bearer = bearer
+          @form = form
+          @json = json
+          @secrets = secrets
+          freeze
+        end
+
+        # The URL without query string or credentials, for errors.
+        def display_url
+          Internal::Util.display_url(uri)
+        end
+
+        # "GET /session/", for messages.
+        def describe
+          "#{http_method} #{uri.path}"
+        end
+      end
+
+      VERBS = { "GET" => :get, "POST" => :post, "DELETE" => :delete }.freeze
+
+      # @param timeout [Numeric] seconds for opening the connection, and for each read and write
+      # @param http_client [#call, nil] returns a configured, not yet started Net::HTTP for a URI
+      def initialize(timeout:, http_client:)
+        @timeout = timeout.to_f
+        @transport = Internal::Transport.new(http_client: http_client)
+        freeze
+      end
+
+      # Sends +call+ once and returns the response, whatever its status.
+      #
+      # @param call [Call]
+      # @return [Didit::Internal::Transport::Response]
+      # @raise [Didit::APIConnectionError, Didit::APITimeoutError] when no response arrives
+      def perform(call)
+        @transport.execute(VERBS.fetch(call.http_method), call.uri, headers_for(call), body_for(call), @timeout)
+      rescue Internal::Transport::Failure => e
+        error_class = e.timeout? ? APITimeoutError : APIConnectionError
+        raise error_class.new(http_method: call.http_method, url: call.display_url)
+      end
+
+      # Closes the idle connections.
+      #
+      # @return [nil]
+      def close
+        @transport.close
+      end
+
+      # The parsed JSON body of a 2xx response, nil when it has none.
+      #
+      # @return [Object, nil]
+      # @raise [Didit::APIStatusError] for any other status, with the call's secrets redacted
+      # @raise [Didit::APIResponseValidationError] when the body is not JSON
+      def read(call, response)
+        body = response.body.to_s
+        unless (200..299).cover?(response.status)
+          raise Internal::Errors.status_error(
+            status: response.status, headers: response.headers, raw_body: body, redact: call.secrets
+          )
+        end
+        return nil if response.status == 204 || body.empty?
+
+        begin
+          JSON.parse(text_of(body))
+        rescue JSON::ParserError
+          content_type = response.headers.fetch("content-type", "no content type")
+          raise validation_error(call, response, "Expected a JSON response from #{call.describe}, got #{content_type}.")
+        end
+      end
+
+      # The JSON object of a 2xx response.
+      #
+      # @return [Hash]
+      def read_object(call, response)
+        data = read(call, response)
+        raise validation_error(call, response, "Expected a JSON object from #{call.describe}.") unless data.is_a?(Hash)
+
+        data
+      end
+
+      # @return [Didit::APIResponseValidationError]
+      def validation_error(call, response, message)
+        body = response.body.to_s
+        APIResponseValidationError.new(
+          message, status: response.status, headers: response.headers,
+                   body: body.empty? ? nil : Internal::Util.redact(text_of(body), call.secrets),
+                   request_id: Internal::Util.request_id(response.headers)
+        )
+      end
+
+      private
+
+      def headers_for(call)
+        headers = {
+          "Accept" => "application/json",
+          "User-Agent" => Internal::Util.user_agent,
+          "X-Didit-Client" => Internal::Util.client_header
+        }
+        headers["Authorization"] = "Bearer #{call.bearer}" if call.bearer
+        if call.form
+          headers["Content-Type"] = "application/x-www-form-urlencoded"
+        elsif call.json
+          headers["Content-Type"] = "application/json"
+        end
+        headers
+      end
+
+      def body_for(call)
+        form = call.form
+        json = call.json
+        return URI.encode_www_form(form) if form
+
+        JSON.generate(json) if json
+      end
+
+      def text_of(body)
+        text = body.dup.force_encoding(Encoding::UTF_8)
+        text.valid_encoding? ? text : text.scrub
+      end
+    end
+  end
+end

data/lib/didit/authentication/issuer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Didit
+  class Authentication
+    # The issuer URL and the publishable key that carries it.
+    #
+    # An application's issuer is its canonical origin: +https://<slug>.auth.didit.me+
+    # (live), +https://<slug>.sandbox.auth.didit.me+ (sandbox) or its active custom
+    # domain, with no trailing slash. A publishable key is +pk_live_+ (live) or
+    # +pk_test_+ (sandbox) followed by the base64url encoding of the issuer, unpadded
+    # (correct "=" padding is accepted too).
+    # @api private
+    module Issuer
+      LOOPBACK_HOSTS = %w[localhost 127.0.0.1 ::1].freeze
+      # Prefix => whether the key may name a plain http loopback issuer.
+      PREFIXES = { "pk_live_" => false, "pk_test_" => true }.freeze
+      UNSAFE = /[\x00-\x20\x7f?#]/
+
+      module_function
+
+      # The issuer without trailing slashes.
+      #
+      # It must be an absolute https URL with no user name, password, query or
+      # fragment. Plain http is accepted only for localhost, *.localhost,
+      # 127.0.0.1 and ::1 (a local test stack) when +allow_loopback_http+ is true.
+      #
+      # @param issuer [String]
+      # @return [String]
+      # @raise [Didit::ConfigurationError]
+      def normalize(issuer, allow_loopback_http: true)
+        text = issuer.is_a?(String) ? issuer.strip : ""
+        if text.empty?
+          raise ConfigurationError,
+                "The issuer is empty: pass your application's issuer (https://<slug>.auth.didit.me or your " \
+                "custom domain) or use Didit::Authentication.from_publishable_key."
+        end
+        if PREFIXES.key?(text[0, 8])
+          raise ConfigurationError, "That is a publishable key, not an issuer: use Didit::Authentication.from_publishable_key."
+        end
+
+        uri = parse(text)
+        scheme = uri.scheme.to_s.downcase
+        secure = scheme == "https"
+        local = allow_loopback_http && scheme == "http" && loopback?(uri.hostname.to_s)
+        unless secure || local
+          raise ConfigurationError,
+                "The issuer must use https (http only for localhost while testing), got #{text.inspect}."
+        end
+
+        text.sub(%r{/+\z}, "")
+      end
+
+      # The issuer a +pk_live_+ or +pk_test_+ publishable key carries. A live key
+      # must name an https issuer; a test (sandbox) key may also name http on a
+      # loopback host, as the console allows for sandbox applications.
+      #
+      # @param publishable_key [String]
+      # @return [String]
+      # @raise [Didit::ConfigurationError]
+      def from_publishable_key(publishable_key)
+        key = publishable_key.is_a?(String) ? publishable_key.strip : ""
+        prefix = key[0, 8].to_s
+        unless PREFIXES.key?(prefix)
+          raise ConfigurationError,
+                "A publishable key starts with pk_live_ or pk_test_; copy it from the Developers section of " \
+                "Authentication in the Didit console."
+        end
+
+        normalize(decode_issuer(prefix, key[8..].to_s), allow_loopback_http: PREFIXES.fetch(prefix))
+      end
+
+      # Whether +host+ (without brackets) is a loopback name or address.
+      def loopback?(host)
+        host = host.downcase
+        LOOPBACK_HOSTS.include?(host) || host.end_with?(".localhost")
+      end
+
+      def decode_issuer(prefix, encoded)
+        raw = encoded.empty? ? nil : Base64Url.decode(unpad(encoded))
+        issuer = raw&.force_encoding(Encoding::UTF_8)
+        return issuer if issuer&.valid_encoding?
+
+        raise ConfigurationError,
+              "The publishable key is not valid: expected #{prefix} followed by the base64url-encoded issuer."
+      end
+
+      # +text+ without its "=" padding when that padding is exactly right (Python's
+      # urlsafe_b64encode pads), else unchanged, so that the strict decoder refuses it.
+      def unpad(text)
+        unpadded = text.sub(/={1,2}\z/, "")
+        exact = (text.length % 4).zero? && text.length - unpadded.length == -unpadded.length % 4
+        exact ? unpadded : text
+      end
+
+      def parse(text)
+        uri = text.match?(UNSAFE) ? nil : URI.parse(text)
+        if uri.is_a?(URI::HTTP) && uri.userinfo
+          raise ConfigurationError, "The issuer URL must not contain a user name or password."
+        end
+        return uri if uri.is_a?(URI::HTTP) && !uri.hostname.to_s.empty? && (1..65_535).cover?(uri.port)
+
+        invalid(text)
+      rescue URI::Error
+        invalid(text)
+      end
+
+      def invalid(text)
+        raise ConfigurationError,
+              "The issuer must be an absolute https URL with no query or fragment, got #{text.inspect}."
+      end
+    end
+  end
+end

data/lib/didit/authentication/jws.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "json"
+require "jwt"
+require "openssl"
+
+module Didit
+  class Authentication
+    # JWS parsing and claim checks for Didit Authentication tokens (no I/O here).
+    #
+    # Didit issuers sign with ES256 only: access tokens carry the header
+    # +typ: at+jwt+ and ID tokens +typ: JWT+. Every other algorithm, +none+
+    # included, is refused before any key is looked up.
+    # @api private
+    module Jws
+      ALGORITHM = "ES256"
+      MAX_TOKEN_LENGTH = 16_384
+      ACCESS_TYPES = %w[at+jwt application/at+jwt].freeze
+      ID_TYPES = %w[jwt application/jwt].freeze
+      ZERO = ("\x00" * 32).b.freeze
+      JSON_OPTIONS = { allow_nan: false, max_nesting: 64 }.merge(
+        # json 2.13 and newer can refuse duplicate member names; older versions keep the last one.
+        Gem::Version.new(JSON::VERSION) >= Gem::Version.new("2.13.0") ? { allow_duplicate_key: false } : {}
+      ).freeze
+      # Every claim is checked here; the jwt gem only checks the signature, whatever
+      # its global configuration says.
+      DECODE_OPTIONS = {
+        algorithm: ALGORITHM, verify_expiration: false, verify_not_before: false, verify_iat: false,
+        verify_iss: false, verify_aud: false, verify_jti: false, verify_sub: false, required_claims: nil
+      }.freeze
+
+      # A compact JWS whose header passed the algorithm, type and key id checks; not verified yet.
+      class Parsed
+        attr_reader :token, :header, :claims, :signature, :kid
+
+        def initialize(token:, header:, claims:, signature:, kid:)
+          @token = token
+          @header = header
+          @claims = claims
+          @signature = signature
+          @kid = kid
+          freeze
+        end
+      end
+
+      module_function
+
+      # Splits and decodes a compact JWS and checks its header (+alg+, +crit+,
+      # +typ+, +kid+). Nothing in it is trusted until the signature is checked.
+      #
+      # @param token [Object]
+      # @param kind [Symbol] +:access+ or +:id+
+      # @return [Parsed]
+      # @raise [Didit::TokenVerificationError]
+      def parse(token, kind)
+        fail!(:malformed, "The token is empty or not a string.") unless token.is_a?(String) && !token.empty?
+        if token.bytesize > MAX_TOKEN_LENGTH
+          fail!(:malformed, "The token is longer than #{MAX_TOKEN_LENGTH} characters.")
+        end
+
+        parts = token.b.split(".", -1)
+        fail!(:malformed, "The token is not a compact JWS (three dot-separated segments).") unless parts.length == 3
+
+        header_segment, payload_segment, signature_segment = parts
+        header = json_object(header_segment.to_s, "header")
+        check_header(header, kind)
+        claims = json_object(payload_segment.to_s, "payload")
+        signature = Base64Url.decode(signature_segment.to_s)
+        fail!(:malformed, "The token signature is not base64url.") if signature.nil?
+
+        Parsed.new(token: parts.join("."), header: header, claims: claims, signature: signature, kid: header["kid"])
+      end
+
+      # Checks the ES256 signature with +key+, through the jwt gem.
+      #
+      # @param parsed [Parsed]
+      # @param key [OpenSSL::PKey::EC]
+      # @raise [Didit::TokenVerificationError]
+      def verify_signature(parsed, key)
+        signature = parsed.signature
+        # The JWS form only: the 32-byte R then the 32-byte S, neither zero. A DER signature is refused.
+        unless signature.bytesize == 64 && signature.byteslice(0, 32) != ZERO && signature.byteslice(32, 32) != ZERO
+          fail!(:invalid_signature, "The token's signature is not a 64-byte ES256 signature (R || S).")
+        end
+
+        JWT.decode(parsed.token, key, true, DECODE_OPTIONS)
+        nil
+      rescue JWT::IncorrectAlgorithm
+        fail!(:unsupported_algorithm, "The token is not signed with ES256.")
+      rescue JWT::VerificationError, OpenSSL::PKey::PKeyError
+        fail!(:invalid_signature, "The token's signature does not verify with the issuer's key.")
+      rescue JWT::DecodeError, JSON::ParserError
+        fail!(:malformed, "The token could not be decoded.")
+      end
+
+      # Checks the registered claims of a token whose signature is verified.
+      #
+      # +iss+ must equal +issuer+; +sub+, +exp+ and +iat+ must be present; +exp+,
+      # +nbf+ and +iat+ are compared with +now+ allowing +leeway+ seconds of clock
+      # skew; +aud+ must contain one of +audience+ when it is given; an ID token's
+      # +nonce+ must equal +nonce+, or be absent when +nonce+ is nil.
+      #
+      # @param claims [Hash]
+      # @param kind [Symbol] +:access+ or +:id+
+      # @param issuer [String]
+      # @param audience [Array<String>, nil]
+      # @param nonce [String, nil]
+      # @param leeway [Float]
+      # @param now [Float]
+      # @raise [Didit::TokenVerificationError]
+      def check_claims(claims, kind:, issuer:, audience:, nonce:, leeway:, now:)
+        check_issuer(claims, issuer)
+        sub = claims["sub"]
+        fail!(:missing_claim, "The token has no sub claim.") unless sub.is_a?(String) && !sub.empty?
+
+        check_times(claims, leeway, now)
+        check_audience(claims, audience) if audience
+        check_nonce(claims, nonce) if kind == :id
+        nil
+      end
+
+      # A short, safe rendering of a header or claim value for an error message.
+      def shown(value)
+        text = value.inspect
+        text.length <= 64 ? text : "#{text[0, 61]}..."
+      end
+
+      def fail!(reason, message)
+        raise TokenVerificationError.new(reason, message)
+      end
+
+      def json_object(segment, part)
+        raw = Base64Url.decode(segment)
+        fail!(:malformed, "The token #{part} is not base64url.") if raw.nil?
+
+        text = raw.force_encoding(Encoding::UTF_8)
+        fail!(:malformed, "The token #{part} is not UTF-8.") unless text.valid_encoding?
+
+        value = JSON.parse(text, **JSON_OPTIONS)
+        fail!(:malformed, "The token #{part} is not a JSON object.") unless value.is_a?(Hash)
+
+        value
+      rescue JSON::ParserError, EncodingError
+        fail!(:malformed, "The token #{part} is not valid JSON.")
+      end
+
+      def check_header(header, kind)
+        alg = header["alg"]
+        if alg != ALGORITHM
+          fail!(:unsupported_algorithm, "The token is signed with #{shown(alg)}; only ES256 is accepted.")
+        end
+        if header.key?("crit")
+          fail!(:malformed, "The token header has critical extensions (crit), which are not supported.")
+        end
+        # RFC 7797 unencoded payloads: the jwt gem's versions disagree on b64 without crit.
+        fail!(:malformed, "The token header has b64, which is not supported.") if header.key?("b64")
+
+        check_type(header["typ"], kind)
+        kid = header["kid"]
+        fail!(:malformed, "The token header names no signing key (kid).") unless kid.is_a?(String) && !kid.empty?
+      end
+
+      def check_type(typ, kind)
+        if kind == :access
+          return if typ.is_a?(String) && ACCESS_TYPES.include?(typ.downcase)
+
+          fail!(:invalid_type, "The token is not an access token: its header typ is #{shown(typ)}, not \"at+jwt\".")
+        end
+        # ID tokens carry typ JWT; refusing at+jwt keeps an access token from passing as one.
+        return if typ.nil? || (typ.is_a?(String) && ID_TYPES.include?(typ.downcase))
+
+        fail!(:invalid_type, "The token is not an ID token: its header typ is #{shown(typ)}, not \"JWT\".")
+      end
+
+      def check_issuer(claims, issuer)
+        iss = claims["iss"]
+        fail!(:missing_claim, "The token has no iss claim.") if iss.nil?
+        fail!(:invalid_issuer, "The token was issued by #{shown(iss)}, not by #{issuer.inspect}.") if iss != issuer
+      end
+
+      def check_times(claims, leeway, now)
+        exp = numeric_date(claims, "exp")
+        iat = numeric_date(claims, "iat")
+        nbf = claims.key?("nbf") ? numeric_date(claims, "nbf") : nil
+        fail!(:expired, "The token has expired.") if now >= exp + leeway
+        fail!(:not_yet_valid, "The token is not valid yet (nbf is in the future).") if nbf && now + leeway < nbf
+        fail!(:invalid_issued_at, "The token was issued in the future (iat).") if now + leeway < iat
+      end
+
+      def numeric_date(claims, name)
+        fail!(:missing_claim, "The token has no #{name} claim.") unless claims.key?(name)
+
+        value = claims[name]
+        seconds = case value
+                  when Float then value
+                  # An integer beyond any Float is as unusable as NaN.
+                  when Integer then value.abs < Float::MAX ? value.to_f : Float::NAN
+                  else Float::NAN
+                  end
+        fail!(:malformed, "The token's #{name} claim is not a number of seconds.") unless seconds.finite?
+
+        seconds
+      end
+
+      def check_audience(claims, audience)
+        fail!(:missing_claim, "The token has no aud claim.") unless claims.key?("aud")
+
+        aud = claims["aud"]
+        # @type var values: Array[String]
+        values = case aud
+                 when String then [aud]
+                 when Array then aud.grep(String)
+                 else []
+                 end
+        fail!(:invalid_audience, "The token was not issued for this audience.") unless values.intersect?(audience)
+      end
+
+      def check_nonce(claims, nonce)
+        token_nonce = claims["nonce"]
+        if nonce.nil?
+          return if token_nonce.nil?
+
+          fail!(:invalid_nonce, "The ID token carries a nonce: pass the nonce this sign-in started with.")
+        end
+        return if token_nonce.is_a?(String) && OpenSSL.secure_compare(token_nonce, nonce)
+
+        fail!(:invalid_nonce, "The ID token's nonce does not match this sign-in.")
+      end
+    end
+  end
+end

data/lib/didit/authentication/key_set.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Didit
+  class Authentication
+    # The issuer's published ES256 keys by +kid+.
+    # @api private
+    class KeySet
+      # DER SubjectPublicKeyInfo header (id-ecPublicKey, prime256v1) of an uncompressed P-256 point.
+      SPKI_PREFIX = ["3059301306072a8648ce3d020106082a8648ce3d030107034200"].pack("H*").freeze
+      UNCOMPRESSED = "\x04".b.freeze
+
+      class << self
+        # The key set, or nil when +data+ is not a JWKS (+{"keys": [...]}+).
+        #
+        # Only EC P-256 keys with +use+ "sig" (or none) and +alg+ "ES256" (or none)
+        # and a non-empty string +kid+ are kept; the first usable key per kid wins.
+        #
+        # @param data [Object] the parsed JWKS
+        # @return [KeySet, nil]
+        def parse(data)
+          return nil unless data.is_a?(Hash) && data["keys"].is_a?(Array)
+
+          keys = {} # : Hash[String, OpenSSL::PKey::EC]
+          data["keys"].each do |jwk|
+            next unless jwk.is_a?(Hash)
+
+            kid = jwk["kid"]
+            next unless kid.is_a?(String) && !kid.empty? && !keys.key?(kid)
+
+            key = p256_key(jwk)
+            keys[kid] = key if key
+          end
+          new(keys, data)
+        end
+
+        # The public key of a P-256 signing JWK, or nil for any other or invalid key.
+        #
+        # @param jwk [Hash]
+        # @return [OpenSSL::PKey::EC, nil]
+        def p256_key(jwk)
+          return nil unless jwk["kty"] == "EC" && jwk["crv"] == "P-256"
+          return nil unless jwk.fetch("use", "sig") == "sig" && jwk.fetch("alg", Jws::ALGORITHM) == Jws::ALGORITHM
+
+          x = coordinate(jwk["x"])
+          y = coordinate(jwk["y"])
+          return nil unless x && y
+
+          # Reading the point as a SubjectPublicKeyInfo checks that it is on the curve.
+          key = OpenSSL::PKey.read(SPKI_PREFIX + UNCOMPRESSED + x + y)
+          key if key.is_a?(OpenSSL::PKey::EC) && key.group&.curve_name == "prime256v1"
+        rescue OpenSSL::PKey::PKeyError, ArgumentError
+          nil
+        end
+
+        private
+
+        # A P-256 coordinate: unpadded base64url of exactly 32 bytes (RFC 7518 section 6.2.1.2).
+        def coordinate(value)
+          raw = value.is_a?(String) ? Base64Url.decode(value) : nil
+          raw if raw && raw.bytesize == 32
+        end
+      end
+
+      # @return [Hash] the JWKS as the issuer sent it (frozen)
+      attr_reader :document
+
+      # @param keys [Hash{String => OpenSSL::PKey::EC}]
+      # @param document [Hash]
+      def initialize(keys, document)
+        @keys = keys.freeze
+        @document = IssuerCache.deep_freeze(document)
+        freeze
+      end
+
+      # @param kid [String]
+      # @return [OpenSSL::PKey::EC, nil]
+      def [](kid)
+        @keys[kid]
+      end
+
+      # @param kid [String]
+      def key?(kid)
+        @keys.key?(kid)
+      end
+    end
+  end
+end

data/lib/didit/authentication/pkce.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "digest"
+require "securerandom"
+
+module Didit
+  class Authentication
+    # A PKCE verifier and its S256 challenge (RFC 7636).
+    #
+    # Send {#code_challenge} and {#code_challenge_method} with the authorization
+    # request, keep {#code_verifier} on your server (it is left out of {#inspect})
+    # and pass it to {Authentication#exchange_code}.
+    class Pkce
+      METHOD = "S256"
+      VERIFIER = /\A[A-Za-z0-9\-._~]{43,128}\z/
+
+      # @return [String] keep it server-side; never send it to the browser
+      attr_reader :code_verifier
+      # @return [String] BASE64URL(SHA256(code_verifier))
+      attr_reader :code_challenge
+      # @return [String] always "S256"
+      attr_reader :code_challenge_method
+
+      # A new random verifier (32 random bytes, 43 characters) and its challenge.
+      #
+      # @return [Pkce]
+      def self.generate
+        new(SecureRandom.urlsafe_base64(32))
+      end
+
+      # +BASE64URL(SHA256(ASCII(verifier)))+ without padding (RFC 7636 section 4.2).
+      #
+      # @param verifier [String]
+      # @return [String]
+      def self.s256_challenge(verifier)
+        Base64Url.encode(Digest::SHA256.digest(verifier))
+      end
+
+      # @param code_verifier [String] 43 to 128 characters of A-Z, a-z, 0-9, "-", ".", "_" and "~"
+      # @raise [Didit::ConfigurationError] when the verifier does not fit RFC 7636 section 4.1
+      def initialize(code_verifier)
+        unless code_verifier.is_a?(String) && VERIFIER.match?(code_verifier)
+          raise ConfigurationError,
+                "A PKCE code_verifier is 43 to 128 characters of A-Z, a-z, 0-9, '-', '.', '_' and '~'."
+        end
+
+        @code_verifier = code_verifier.dup.freeze
+        @code_challenge = Pkce.s256_challenge(code_verifier).freeze
+        @code_challenge_method = METHOD
+        freeze
+      end
+
+      # @return [Hash{Symbol => String}]
+      def to_h
+        { code_verifier: code_verifier, code_challenge: code_challenge, code_challenge_method: code_challenge_method }
+      end
+
+      def inspect
+        "#<#{self.class.name} code_challenge=#{code_challenge.inspect} code_challenge_method=#{METHOD.inspect}>"
+      end
+      alias to_s inspect
+    end
+  end
+end