webauthn-slim 3.4.3

data/lib/webauthn/cbor.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "webauthn/error"
+
+module WebAuthn
+  # The WebAuthn subset of RFC 8949, without a native extension. Inspired by
+  # the bounded decoder in https://github.com/rails/rails/pull/57100.
+  module CBOR
+    class MalformedData < WebAuthn::Error; end
+
+    MAX_SIZE = 10 * 1024 * 1024
+    MAX_DEPTH = 16
+
+    def self.decode(data)
+      decoder = Decoder.new(data)
+      value = decoder.decode
+      raise MalformedData, "Trailing CBOR data" unless decoder.position == data.bytesize
+
+      value
+    end
+
+    # Returns both the first item and its exact encoded length. Credential keys
+    # can be followed by extensions, and need not use the shortest encoding.
+    def self.decode_first(data)
+      decoder = Decoder.new(data)
+      [decoder.decode, decoder.position]
+    end
+
+    def self.encode(value)
+      case value
+      when Integer
+        value >= 0 ? header(0, value) : header(1, -1 - value)
+      when String
+        header(value.encoding == Encoding::BINARY ? 2 : 3, value.bytesize) + value.b
+      when Array
+        header(4, value.length) + value.map { |item| encode(item) }.join
+      when Hash
+        header(5, value.length) + value.map { |key, item| encode(key) + encode(item) }.join
+      when false then "\xf4".b
+      when true then "\xf5".b
+      when nil then "\xf6".b
+      when Float then "\xfb".b + [value].pack("G")
+      else raise ArgumentError, "Unsupported CBOR value #{value.class}"
+      end
+    end
+
+    def self.header(type, value)
+      prefix = type << 5
+      case value
+      when 0..23 then [prefix | value].pack("C")
+      when 24..255 then [prefix | 24, value].pack("CC")
+      when 256..65535 then [prefix | 25, value].pack("Cn")
+      when 65536..0xffffffff then [prefix | 26, value].pack("CN")
+      when 0x100000000..0xffffffffffffffff then [prefix | 27, value].pack("CQ>")
+      else raise ArgumentError, "CBOR integer out of range"
+      end
+    end
+    private_class_method :header
+
+    class Decoder
+      attr_reader :position
+
+      def initialize(data)
+        raise MalformedData, "Expected CBOR bytes" unless data.is_a?(String)
+        raise MalformedData, "Input exceeds maximum size" if data.bytesize > MAX_SIZE
+
+        @data = data.b
+        @position = 0
+      end
+
+      def decode(depth = 0)
+        raise MalformedData, "Maximum nesting depth exceeded" if depth >= MAX_DEPTH
+
+        byte = read(1).getbyte(0)
+        type = byte >> 5
+        info = byte & 31
+        return simple(info) if type == 7
+
+        if info == 31
+          return indefinite(type, depth)
+        end
+
+        size = argument(info)
+        case type
+        when 0 then size
+        when 1 then -1 - size
+        when 2, 3 then string(type, read(size))
+        when 4
+          raise MalformedData, "Truncated CBOR array" if size > remaining
+
+          Array.new(size) { decode(depth + 1) }
+        when 5
+          raise MalformedData, "Truncated CBOR map" if size > remaining / 2
+
+          {}.tap { |map| size.times { read_pair(map, depth) } }
+        else raise MalformedData, "Unsupported CBOR tag #{size}"
+        end
+      end
+
+      private
+
+      def read(size)
+        raise MalformedData, "Unexpected end of input" if size > remaining
+
+        bytes = @data.byteslice(@position, size)
+        @position += size
+        bytes
+      end
+
+      def remaining
+        @data.bytesize - position
+      end
+
+      def argument(info)
+        case info
+        when 0..23 then info
+        when 24 then read(1).unpack1("C")
+        when 25 then read(2).unpack1("n")
+        when 26 then read(4).unpack1("N")
+        when 27 then read(8).unpack1("Q>")
+        else raise MalformedData, "Invalid CBOR additional information"
+        end
+      end
+
+      def string(type, bytes)
+        return bytes if type == 2
+
+        bytes.force_encoding(Encoding::UTF_8)
+        raise MalformedData, "Invalid CBOR UTF-8 string" unless bytes.valid_encoding?
+
+        bytes
+      end
+
+      def read_pair(map, depth)
+        key = decode(depth + 1)
+        raise MalformedData, "Duplicate CBOR map key" if map.key?(key)
+
+        map[key] = decode(depth + 1)
+      end
+
+      def indefinite(type, depth)
+        raise MalformedData, "Invalid indefinite CBOR item" unless (2..5).include?(type)
+
+        value = type == 5 ? {} : (type == 4 ? [] : "".b)
+        until @data.getbyte(position) == 255
+          if type == 5
+            read_pair(value, depth)
+          elsif type == 4
+            value << decode(depth + 1)
+          else
+            byte = @data.getbyte(position)
+            unless byte && byte >> 5 == type && byte & 31 != 31
+              raise MalformedData, "Invalid indefinite string chunk"
+            end
+
+            value << decode(depth + 1)
+          end
+        end
+        read(1)
+        type == 3 ? string(type, value) : value
+      end
+
+      def simple(info)
+        case info
+        when 20 then false
+        when 21 then true
+        when 22, 23 then nil
+        when 25
+          half = read(2).unpack1("n")
+          exponent = (half >> 10) & 31
+          mantissa = half & 1023
+          value =
+            if exponent == 0
+              Math.ldexp(mantissa, -24)
+            elsif exponent == 31
+              mantissa == 0 ? Float::INFINITY : Float::NAN
+            else
+              Math.ldexp(mantissa + 1024, exponent - 25)
+            end
+          half & 0x8000 == 0 ? value : -value
+        when 26 then read(4).unpack1("g")
+        when 27 then read(8).unpack1("G")
+        else raise MalformedData, "Unsupported CBOR simple value"
+        end
+      end
+    end
+    private_constant :Decoder
+  end
+end

data/lib/webauthn/client_data.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+require "webauthn/encoder"
+require "webauthn/error"
+
+module WebAuthn
+  class ClientDataMissingError < Error; end
+
+  class ClientData
+    VALID_TOKEN_BINDING_STATUSES = ["present", "supported", "not-supported"].freeze
+
+    def initialize(client_data_json)
+      @client_data_json = client_data_json
+    end
+
+    def type
+      data["type"]
+    end
+
+    def challenge
+      WebAuthn.standard_encoder.decode(data["challenge"])
+    end
+
+    def origin
+      data["origin"]
+    end
+
+    def token_binding
+      data["tokenBinding"]
+    end
+
+    def cross_origin
+      data["crossOrigin"]
+    end
+
+    def top_origin
+      data["topOrigin"]
+    end
+
+    def valid_token_binding_format?
+      if token_binding
+        token_binding.is_a?(Hash) && VALID_TOKEN_BINDING_STATUSES.include?(token_binding["status"])
+      else
+        true
+      end
+    end
+
+    def hash
+      OpenSSL::Digest::SHA256.digest(client_data_json)
+    end
+
+    private
+
+    attr_reader :client_data_json
+
+    def data
+      @data ||=
+        if client_data_json
+          JSON.parse(client_data_json)
+        else
+          raise ClientDataMissingError, "Client Data JSON is missing"
+        end
+    end
+  end
+end

data/lib/webauthn/configuration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'webauthn/relying_party'
+
+module WebAuthn
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  class Configuration
+    extend Forwardable
+
+    def_delegators :@relying_party,
+                   :algorithms,
+                   :algorithms=,
+                   :encoding,
+                   :encoding=,
+                   :origin,
+                   :origin=,
+                   :allowed_origins,
+                   :allowed_origins=,
+                   :allowed_top_origins,
+                   :allowed_top_origins=,
+                   :verify_attestation_statement,
+                   :verify_attestation_statement=,
+                   :verify_cross_origin,
+                   :verify_cross_origin=,
+                   :credential_options_timeout,
+                   :credential_options_timeout=,
+                   :silent_authentication,
+                   :silent_authentication=,
+                   :acceptable_attestation_types,
+                   :acceptable_attestation_types=,
+                   :attestation_root_certificates_finders,
+                   :attestation_root_certificates_finders=,
+                   :encoder,
+                   :encoder=,
+                   :legacy_u2f_appid,
+                   :legacy_u2f_appid=
+
+    attr_reader :relying_party
+
+    def initialize
+      @relying_party = RelyingParty.new
+    end
+
+    def rp_name
+      relying_party.name
+    end
+
+    def rp_name=(name)
+      relying_party.name = name
+    end
+
+    def rp_id
+      relying_party.id
+    end
+
+    def rp_id=(id)
+      relying_party.id = id
+    end
+  end
+end

data/lib/webauthn/cose.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "webauthn/cbor"
+
+module WebAuthn
+  # Public COSE keys and signature algorithms used by WebAuthn (RFC 9053).
+  # SubjectPublicKeyInfo construction follows the approach in Rails PR #57100.
+  module COSE
+    class Error < WebAuthn::Error; end
+    class MalformedKeyError < Error; end
+    class UnknownKeyType < Error; end
+
+    module Key
+      Curve =
+        Struct.new(:id, :name, :pkey_name, :coordinate_length) do
+          def self.find(id)
+            CURVES.find { |curve| curve.id == id }
+          end
+
+          def self.by_name(name)
+            CURVES.find { |curve| curve.name == name }
+          end
+
+          def self.by_pkey_name(name)
+            CURVES.find { |curve| curve.pkey_name == name }
+          end
+        end
+
+      CURVES = [
+        Curve.new(1, "P-256", "prime256v1", 32),
+        Curve.new(2, "P-384", "secp384r1", 48),
+        Curve.new(3, "P-521", "secp521r1", 66),
+        Curve.new(6, "Ed25519", "ED25519", 32),
+        Curve.new(7, "Ed448", "ED448", 57),
+        Curve.new(8, "secp256k1", "secp256k1", 32)
+      ].each(&:freeze).freeze
+
+      def self.deserialize(bytes)
+        map = CBOR.decode(bytes)
+        type = map.is_a?(Hash) && map[1]
+        case type
+        when 1 then OKP.new(alg: map[3], crv: map[-1], x: map[-2])
+        when 2 then EC2.new(alg: map[3], crv: map[-1], x: map[-2], y: map[-3])
+        when 3 then RSA.new(alg: map[3], n: map[-1], e: map[-2])
+        else raise UnknownKeyType, "Unsupported COSE key type #{type}"
+        end
+      rescue CBOR::MalformedData, ArgumentError => e
+        raise MalformedKeyError, e.message
+      end
+
+      class Base
+        attr_accessor :alg
+
+        def self.deserialize(bytes)
+          key = Key.deserialize(bytes)
+          raise MalformedKeyError, "Unexpected COSE key type" unless key.is_a?(self)
+
+          key
+        end
+
+        def initialize(alg: nil)
+          raise ArgumentError, "Invalid COSE algorithm" unless alg.nil? || alg.is_a?(Integer)
+
+          @alg = alg
+        end
+
+        def serialize
+          CBOR.encode(map)
+        end
+
+        private
+
+        def bytes?(value, length = nil)
+          value.is_a?(String) && value.encoding == Encoding::BINARY &&
+            (length ? value.bytesize == length : !value.empty?)
+        end
+
+        def subject_public_key(identifiers, bytes)
+          OpenSSL::PKey.read(
+            OpenSSL::ASN1::Sequence(
+              [
+                OpenSSL::ASN1::Sequence(identifiers.map { |name| OpenSSL::ASN1::ObjectId(name) }),
+                OpenSSL::ASN1::BitString(bytes)
+              ]
+            ).to_der
+          )
+        end
+      end
+
+      class EC2 < Base
+        attr_reader :crv, :x, :y
+
+        def self.from_pkey(key)
+          curve = Curve.by_pkey_name(key.group.curve_name)
+          raise ArgumentError, "Unsupported EC curve" unless curve
+
+          point = key.is_a?(OpenSSL::PKey::EC) ? key.public_key : key
+          bytes = point.to_octet_string(:uncompressed)
+          size = curve.coordinate_length
+          new(crv: curve.id, x: bytes.byteslice(1, size), y: bytes.byteslice(1 + size, size))
+        end
+
+        def initialize(crv:, x:, y:, **options) # rubocop:disable Naming/MethodParameterName
+          super(**options)
+          @crv, @x, @y = crv, x, y
+          curve = Curve.find(crv)
+          unless [1, 2, 3, 8].include?(crv) && bytes?(x, curve.coordinate_length) && bytes?(y, curve.coordinate_length)
+            raise ArgumentError, "Invalid EC2 curve or coordinates"
+          end
+        end
+
+        def map
+          { 1 => 2, 3 => alg, -1 => crv, -2 => x, -3 => y }.compact
+        end
+
+        def to_pkey
+          subject_public_key(["id-ecPublicKey", Curve.find(crv).pkey_name], "\x04".b + x + y)
+        end
+      end
+
+      class OKP < Base
+        attr_reader :crv, :x
+
+        def self.from_pkey(key)
+          curve = Curve.by_pkey_name(key.oid)
+          raise ArgumentError, "Unsupported OKP curve" unless curve
+
+          new(crv: curve.id, x: OpenSSL::ASN1.decode(key.public_to_der).value.last.value)
+        end
+
+        def initialize(crv:, x:, **options) # rubocop:disable Naming/MethodParameterName
+          super(**options)
+          @crv, @x = crv, x
+          unless [6, 7].include?(crv) && bytes?(x, Curve.find(crv).coordinate_length)
+            raise ArgumentError, "Invalid OKP curve or public key"
+          end
+        end
+
+        def map
+          { 1 => 1, 3 => alg, -1 => crv, -2 => x }.compact
+        end
+
+        def to_pkey
+          subject_public_key([Curve.find(crv).pkey_name], x)
+        end
+      end
+
+      class RSA < Base
+        attr_reader :n, :e
+
+        def self.from_pkey(key)
+          new(n: key.n.to_s(2), e: key.e.to_s(2))
+        end
+
+        def initialize(n:, e:, **options) # rubocop:disable Naming/MethodParameterName
+          super(**options)
+          raise ArgumentError, "Invalid RSA modulus or exponent" unless bytes?(n) && bytes?(e)
+
+          @n, @e = n, e
+        end
+
+        def map
+          { 1 => 3, 3 => alg, -1 => n, -2 => e }.compact
+        end
+
+        def to_pkey
+          OpenSSL::PKey::RSA.new(
+            OpenSSL::ASN1::Sequence([n, e].map { |bytes| OpenSSL::ASN1::Integer(OpenSSL::BN.new(bytes, 2)) }).to_der
+          )
+        end
+      end
+    end
+
+    Algorithm =
+      Struct.new(:id, :name, :hash_function, :key_type, :curve_name) do
+        def self.find(id_or_name)
+          ALGORITHMS.find { |algorithm| algorithm.id == id_or_name || algorithm.name == id_or_name }
+        end
+
+        def self.by_name(name)
+          find(name)
+        end
+
+        def compatible_key?(key)
+          case key_type
+          when :ec
+            key.is_a?(OpenSSL::PKey::EC) && key.group.curve_name == curve_name
+          when :rsa
+            key.is_a?(OpenSSL::PKey::RSA)
+          when :eddsa
+            key.respond_to?(:oid) && ["ED25519", "ED448"].include?(key.oid)
+          end
+        end
+
+        def verify(key, signature, data)
+          return false unless compatible_key?(key)
+
+          if name.start_with?("PS")
+            key.verify_pss(hash_function, signature, data, salt_length: :digest, mgf1_hash: hash_function)
+          else
+            if key_type == :ec
+              size = (key.group.degree + 7) / 8
+              if signature.bytesize == size * 2
+                signature = OpenSSL::ASN1::Sequence(
+                  [signature.byteslice(0, size), signature.byteslice(size, size)].map do |bytes|
+                    OpenSSL::ASN1::Integer(OpenSSL::BN.new(bytes, 2))
+                  end
+                ).to_der
+              end
+            end
+
+            key.verify(hash_function, signature, data)
+          end
+        rescue OpenSSL::PKey::PKeyError
+          raise unless key_type == :eddsa
+
+          false
+        end
+      end
+
+    ALGORITHMS = [
+      Algorithm.new(-7, "ES256", "SHA256", :ec, "prime256v1"),
+      Algorithm.new(-35, "ES384", "SHA384", :ec, "secp384r1"),
+      Algorithm.new(-36, "ES512", "SHA512", :ec, "secp521r1"),
+      Algorithm.new(-47, "ES256K", "SHA256", :ec, "secp256k1"),
+      Algorithm.new(-8, "EdDSA", nil, :eddsa),
+      Algorithm.new(-37, "PS256", "SHA256", :rsa),
+      Algorithm.new(-38, "PS384", "SHA384", :rsa),
+      Algorithm.new(-39, "PS512", "SHA512", :rsa),
+      Algorithm.new(-257, "RS256", "SHA256", :rsa),
+      Algorithm.new(-258, "RS384", "SHA384", :rsa),
+      Algorithm.new(-259, "RS512", "SHA512", :rsa),
+      Algorithm.new(-65535, "RS1", "SHA1", :rsa)
+    ].each(&:freeze).freeze
+  end
+end

data/lib/webauthn/credential.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "webauthn/public_key_credential/creation_options"
+require "webauthn/public_key_credential/request_options"
+require "webauthn/public_key_credential_with_assertion"
+require "webauthn/public_key_credential_with_attestation"
+
+module WebAuthn
+  module Credential
+    def self.options_for_create(**keyword_arguments)
+      WebAuthn::PublicKeyCredential::CreationOptions.new(**keyword_arguments)
+    end
+
+    def self.options_for_get(**keyword_arguments)
+      WebAuthn::PublicKeyCredential::RequestOptions.new(**keyword_arguments)
+    end
+
+    def self.from_create(credential, relying_party: WebAuthn.configuration.relying_party)
+      WebAuthn::PublicKeyCredentialWithAttestation.from_client(credential, relying_party: relying_party)
+    end
+
+    def self.from_get(credential, relying_party: WebAuthn.configuration.relying_party)
+      WebAuthn::PublicKeyCredentialWithAssertion.from_client(credential, relying_party: relying_party)
+    end
+  end
+end

data/lib/webauthn/credential_creation_options.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "webauthn/cose"
+require "webauthn/credential_options"
+require "webauthn/credential_rp_entity"
+require "webauthn/credential_user_entity"
+
+module WebAuthn
+  def self.credential_creation_options(rp_name: nil, user_name: "web-user", display_name: "web-user", user_id: "1")
+    warn(
+      "DEPRECATION WARNING: `WebAuthn.credential_creation_options` is deprecated."\
+      " Please use `WebAuthn::Credential.options_for_create` instead."
+    )
+
+    CredentialCreationOptions.new(
+      rp_name: rp_name, user_id: user_id, user_name: user_name, user_display_name: display_name
+    ).to_h
+  end
+
+  class CredentialCreationOptions < CredentialOptions
+    DEFAULT_RP_NAME = "web-server"
+
+    attr_accessor :attestation, :authenticator_selection, :exclude_credentials, :extensions
+
+    def initialize(
+      attestation: nil,
+      authenticator_selection: nil,
+      exclude_credentials: nil,
+      extensions: nil,
+      user_id:,
+      user_name:,
+      user_display_name: nil,
+      rp_name: nil
+    )
+      super()
+
+      @attestation = attestation
+      @authenticator_selection = authenticator_selection
+      @exclude_credentials = exclude_credentials
+      @extensions = extensions
+      @user_id = user_id
+      @user_name = user_name
+      @user_display_name = user_display_name
+      @rp_name = rp_name
+    end
+
+    def to_h
+      options = {
+        challenge: challenge,
+        pubKeyCredParams: pub_key_cred_params,
+        timeout: timeout,
+        user: { id: user.id, name: user.name, displayName: user.display_name },
+        rp: { name: rp.name }
+      }
+
+      if attestation
+        options[:attestation] = attestation
+      end
+
+      if authenticator_selection
+        options[:authenticatorSelection] = authenticator_selection
+      end
+
+      if exclude_credentials
+        options[:excludeCredentials] = exclude_credentials
+      end
+
+      if extensions
+        options[:extensions] = extensions
+      end
+
+      options
+    end
+
+    def pub_key_cred_params
+      configuration.algorithms.map do |alg_name|
+        { type: "public-key", alg: COSE::Algorithm.by_name(alg_name).id }
+      end
+    end
+
+    def rp
+      @rp ||= CredentialRPEntity.new(name: rp_name || configuration.rp_name || DEFAULT_RP_NAME)
+    end
+
+    def user
+      @user ||= CredentialUserEntity.new(id: user_id, name: user_name, display_name: user_display_name)
+    end
+
+    private
+
+    attr_reader :user_id, :user_name, :user_display_name, :rp_name
+
+    def configuration
+      WebAuthn.configuration
+    end
+  end
+end

data/lib/webauthn/credential_entity.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module WebAuthn
+  class CredentialEntity
+    attr_reader :name
+
+    def initialize(name:)
+      @name = name
+    end
+  end
+end