webauthn-slim 3.4.3

data/lib/webauthn/attestation_statement/none.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "webauthn/attestation_statement/base"
+
+module WebAuthn
+  module AttestationStatement
+    class None < Base
+      def valid?(*_args)
+        if statement == {} && trustworthy?
+          [WebAuthn::AttestationStatement::ATTESTATION_TYPE_NONE, nil]
+        else
+          false
+        end
+      end
+
+      private
+
+      def attestation_type
+        WebAuthn::AttestationStatement::ATTESTATION_TYPE_NONE
+      end
+    end
+  end
+end

data/lib/webauthn/attestation_statement/packed.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "webauthn/attestation_statement/base"
+
+module WebAuthn
+  # Implements https://www.w3.org/TR/2018/CR-webauthn-20180807/#packed-attestation
+  module AttestationStatement
+    class Packed < Base
+      # Follows "Verification procedure"
+      def valid?(authenticator_data, client_data_hash)
+        valid_format? &&
+          valid_algorithm?(authenticator_data.credential) &&
+          valid_ec_public_keys?(authenticator_data.credential) &&
+          meet_certificate_requirement? &&
+          matching_aaguid?(authenticator_data.attested_credential_data.raw_aaguid) &&
+          valid_signature?(authenticator_data, client_data_hash) &&
+          trustworthy?(aaguid: authenticator_data.aaguid) &&
+          [attestation_type, attestation_trust_path]
+      end
+
+      private
+
+      def valid_algorithm?(credential)
+        !self_attestation? || algorithm == COSE::Key.deserialize(credential.public_key).alg
+      end
+
+      def self_attestation?
+        !raw_certificates
+      end
+
+      def valid_format?
+        algorithm && signature
+      end
+
+      def valid_ec_public_keys?(credential)
+        (certificates&.map(&:public_key) || [credential.public_key_object])
+          .select { |pkey| pkey.is_a?(OpenSSL::PKey::EC) }
+          .all? { |pkey| pkey.check_key }
+      end
+
+      # Check https://www.w3.org/TR/2018/CR-webauthn-20180807/#packed-attestation-cert-requirements
+      def meet_certificate_requirement?
+        if attestation_certificate
+          subject = attestation_certificate.subject.to_a
+
+          attestation_certificate.version == 2 &&
+            subject.assoc('OU')&.at(1) == "Authenticator Attestation" &&
+            attestation_certificate.find_extension('basicConstraints')&.value == 'CA:FALSE'
+        else
+          true
+        end
+      end
+
+      def attestation_type
+        if attestation_trust_path
+          WebAuthn::AttestationStatement::ATTESTATION_TYPE_BASIC_OR_ATTCA # FIXME: use metadata if available
+        else
+          WebAuthn::AttestationStatement::ATTESTATION_TYPE_SELF
+        end
+      end
+
+      def valid_signature?(authenticator_data, client_data_hash)
+        super(
+          authenticator_data,
+          client_data_hash,
+          attestation_certificate&.public_key || authenticator_data.credential.public_key_object
+        )
+      end
+    end
+  end
+end

data/lib/webauthn/attestation_statement.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "webauthn/attestation_statement/apple"
+require "webauthn/attestation_statement/fido_u2f"
+require "webauthn/attestation_statement/none"
+require "webauthn/attestation_statement/packed"
+require "webauthn/error"
+
+module WebAuthn
+  module AttestationStatement
+    class FormatNotSupportedError < Error; end
+
+    ATTESTATION_FORMAT_NONE = "none"
+    ATTESTATION_FORMAT_FIDO_U2F = "fido-u2f"
+    ATTESTATION_FORMAT_PACKED = 'packed'
+    ATTESTATION_FORMAT_APPLE = "apple"
+
+    FORMAT_TO_CLASS = {
+      ATTESTATION_FORMAT_NONE => WebAuthn::AttestationStatement::None,
+      ATTESTATION_FORMAT_FIDO_U2F => WebAuthn::AttestationStatement::FidoU2f,
+      ATTESTATION_FORMAT_PACKED => WebAuthn::AttestationStatement::Packed,
+      ATTESTATION_FORMAT_APPLE => WebAuthn::AttestationStatement::Apple
+    }.freeze
+
+    def self.from(format, statement, relying_party: WebAuthn.configuration.relying_party)
+      klass = FORMAT_TO_CLASS[format]
+
+      if klass
+        klass.new(statement, relying_party)
+      else
+        raise(FormatNotSupportedError, "Unsupported attestation format '#{format}'")
+      end
+    end
+  end
+end

data/lib/webauthn/authenticator_assertion_response.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "webauthn/authenticator_data"
+require "webauthn/authenticator_response"
+require "webauthn/encoder"
+require "webauthn/public_key"
+
+module WebAuthn
+  class SignatureVerificationError < VerificationError; end
+  class SignCountVerificationError < VerificationError; end
+
+  class AuthenticatorAssertionResponse < AuthenticatorResponse
+    def self.from_client(response, relying_party: WebAuthn.configuration.relying_party)
+      encoder = relying_party.encoder
+
+      user_handle =
+        if response["userHandle"]
+          encoder.decode(response["userHandle"])
+        end
+
+      new(
+        authenticator_data: encoder.decode(response["authenticatorData"]),
+        client_data_json: encoder.decode(response["clientDataJSON"]),
+        signature: encoder.decode(response["signature"]),
+        user_handle: user_handle,
+        relying_party: relying_party
+      )
+    end
+
+    attr_reader :user_handle
+
+    def initialize(authenticator_data:, signature:, user_handle: nil, **options)
+      super(**options)
+
+      @authenticator_data_bytes = authenticator_data
+      @signature = signature
+      @user_handle = user_handle
+    end
+
+    def verify(
+      expected_challenge,
+      expected_origin = nil,
+      public_key:,
+      sign_count:,
+      user_presence: nil,
+      user_verification: nil,
+      rp_id: nil
+    )
+      super(
+        expected_challenge,
+        expected_origin,
+        user_presence: user_presence,
+        user_verification: user_verification,
+        rp_id: rp_id
+      )
+      verify_item(:signature, WebAuthn::PublicKey.deserialize(public_key))
+      verify_item(:sign_count, sign_count)
+
+      true
+    end
+
+    def authenticator_data
+      @authenticator_data ||= WebAuthn::AuthenticatorData.deserialize(authenticator_data_bytes)
+    end
+
+    private
+
+    attr_reader :authenticator_data_bytes, :signature
+
+    def valid_signature?(webauthn_public_key)
+      webauthn_public_key.verify(signature, authenticator_data_bytes + client_data.hash)
+    end
+
+    def valid_sign_count?(stored_sign_count)
+      normalized_sign_count = stored_sign_count || 0
+      if authenticator_data.sign_count.nonzero? || normalized_sign_count.nonzero?
+        authenticator_data.sign_count > normalized_sign_count
+      else
+        true
+      end
+    end
+
+    def type
+      WebAuthn::TYPES[:get]
+    end
+  end
+end

data/lib/webauthn/authenticator_attestation_response.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "webauthn/cbor"
+require "forwardable"
+require "uri"
+require "openssl"
+
+require "webauthn/attestation_object"
+require "webauthn/authenticator_response"
+require "webauthn/client_data"
+require "webauthn/encoder"
+
+module WebAuthn
+  class AttestationStatementVerificationError < VerificationError; end
+  class AttestedCredentialVerificationError < VerificationError; end
+
+  class AuthenticatorAttestationResponse < AuthenticatorResponse
+    extend Forwardable
+
+    def self.from_client(response, relying_party: WebAuthn.configuration.relying_party)
+      encoder = relying_party.encoder
+
+      new(
+        attestation_object: encoder.decode(response["attestationObject"]),
+        transports: response["transports"],
+        client_data_json: encoder.decode(response["clientDataJSON"]),
+        relying_party: relying_party
+      )
+    end
+
+    attr_reader :attestation_type, :attestation_trust_path, :transports
+
+    def initialize(attestation_object:, transports: [], **options)
+      super(**options)
+
+      @attestation_object_bytes = attestation_object
+      @transports = transports
+      @relying_party = relying_party
+    end
+
+    def verify(expected_challenge, expected_origin = nil, user_presence: nil, user_verification: nil, rp_id: nil)
+      super
+
+      verify_item(:attested_credential)
+      if relying_party.verify_attestation_statement
+        verify_item(:attestation_statement)
+      end
+
+      true
+    end
+
+    def attestation_object
+      @attestation_object ||= WebAuthn::AttestationObject.deserialize(attestation_object_bytes, relying_party)
+    end
+
+    def_delegators(
+      :attestation_object,
+      :aaguid,
+      :attestation_statement,
+      :attestation_certificate_key_id,
+      :authenticator_data,
+      :credential
+    )
+
+    alias_method :attestation_certificate_key, :attestation_certificate_key_id
+
+    private
+
+    attr_reader :attestation_object_bytes, :relying_party
+
+    def type
+      WebAuthn::TYPES[:create]
+    end
+
+    def valid_attested_credential?
+      attestation_object.valid_attested_credential? &&
+        relying_party.algorithms.include?(authenticator_data.credential.algorithm)
+    end
+
+    def valid_attestation_statement?
+      @attestation_type, @attestation_trust_path = attestation_object.valid_attestation_statement?(client_data.hash)
+    end
+  end
+end

data/lib/webauthn/authenticator_data/attested_credential_data.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "webauthn/cbor"
+require "webauthn/cose"
+require "webauthn/error"
+
+module WebAuthn
+  class AttestedCredentialDataFormatError < WebAuthn::Error; end
+
+  class AuthenticatorData
+    class AttestedCredentialData
+      AAGUID_LENGTH = 16
+      ZEROED_AAGUID = 0.chr * AAGUID_LENGTH
+
+      ID_LENGTH_LENGTH = 2
+
+      attr_reader :raw_aaguid, :id_length, :id, :trailing_bytes
+
+      Credential =
+        Struct.new(:id, :public_key, :algorithm, keyword_init: true) do
+          def public_key_object
+            COSE::Key.deserialize(public_key).to_pkey
+          end
+        end
+
+      def self.deserialize(data)
+        new(data)
+      end
+
+      def initialize(data)
+        header_length = AAGUID_LENGTH + ID_LENGTH_LENGTH
+        unless data.is_a?(String) && data.bytesize >= header_length
+          raise AttestedCredentialDataFormatError
+        end
+
+        data = data.b
+        @raw_aaguid = data.byteslice(0, AAGUID_LENGTH)
+        @id_length = data.byteslice(AAGUID_LENGTH, ID_LENGTH_LENGTH).unpack1("n")
+        if data.bytesize < header_length + id_length
+          raise AttestedCredentialDataFormatError
+        end
+
+        @id = data.byteslice(header_length, id_length)
+        @trailing_bytes = data.byteslice(header_length + id_length..-1)
+      end
+
+      def valid?
+        valid_credential_public_key?
+      end
+
+      def aaguid
+        raw_aaguid.unpack("H8H4H4H4H12").join("-")
+      end
+
+      def credential
+        @credential ||=
+          if valid?
+            Credential.new(id: id, public_key: public_key, algorithm: algorithm)
+          end
+      end
+
+      def length
+        if valid?
+          AAGUID_LENGTH + ID_LENGTH_LENGTH + id_length + public_key_length
+        end
+      end
+
+      private
+
+      def algorithm
+        COSE::Algorithm.find(cose_key.alg)&.name
+      end
+
+      def valid_credential_public_key?
+        !!cose_key.alg
+      end
+
+      def cose_key
+        @cose_key ||= COSE::Key.deserialize(public_key)
+      end
+
+      def public_key
+        trailing_bytes[0..public_key_length - 1]
+      end
+
+      def public_key_length
+        @public_key_length ||=
+          CBOR.decode_first(trailing_bytes).last
+      rescue CBOR::MalformedData
+        raise AttestedCredentialDataFormatError
+      end
+    end
+  end
+end

data/lib/webauthn/authenticator_data.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "webauthn/cbor"
+require "webauthn/authenticator_data/attested_credential_data"
+require "webauthn/error"
+
+module WebAuthn
+  class AuthenticatorDataFormatError < WebAuthn::Error; end
+
+  class AuthenticatorData
+    RP_ID_HASH_LENGTH = 32
+    FLAGS_LENGTH = 1
+    SIGN_COUNT_LENGTH = 4
+
+    attr_reader :data, :rp_id_hash, :flags, :sign_count, :trailing_bytes
+
+    def self.deserialize(data)
+      new(data)
+    end
+
+    def initialize(data)
+      unless data.is_a?(String) && data.bytesize >= base_length
+        raise AuthenticatorDataFormatError
+      end
+
+      @data = data.b.freeze
+      @rp_id_hash = @data.byteslice(0, RP_ID_HASH_LENGTH)
+      @flags = @data.getbyte(RP_ID_HASH_LENGTH)
+      @sign_count = @data.byteslice(RP_ID_HASH_LENGTH + FLAGS_LENGTH, SIGN_COUNT_LENGTH).unpack1("N")
+      @trailing_bytes = @data.byteslice(base_length..-1)
+    end
+
+    def valid?
+      (!attested_credential_data_included? || attested_credential_data.valid?) &&
+        (!extension_data_included? || extension_data) &&
+        valid_length?
+    end
+
+    def user_flagged?
+      user_present? || user_verified?
+    end
+
+    def user_present?
+      (flags & 0x1) != 0
+    end
+
+    def user_verified?
+      (flags & 0x4) != 0
+    end
+
+    def credential_backup_eligible?
+      (flags & 0x8) != 0
+    end
+
+    def credential_backed_up?
+      (flags & 0x10) != 0
+    end
+
+    def attested_credential_data_included?
+      (flags & 0x40) != 0
+    end
+
+    def extension_data_included?
+      (flags & 0x80) != 0
+    end
+
+    def credential
+      if attested_credential_data_included?
+        attested_credential_data.credential
+      end
+    end
+
+    def attested_credential_data
+      @attested_credential_data ||=
+        AttestedCredentialData.deserialize(trailing_bytes)
+    rescue AttestedCredentialDataFormatError
+      raise AuthenticatorDataFormatError
+    end
+
+    def extension_data
+      @extension_data ||= CBOR.decode(raw_extension_data)
+    rescue CBOR::MalformedData
+      raise AuthenticatorDataFormatError
+    end
+
+    def aaguid
+      raw_aaguid = attested_credential_data.raw_aaguid
+
+      unless raw_aaguid == WebAuthn::AuthenticatorData::AttestedCredentialData::ZEROED_AAGUID
+        attested_credential_data.aaguid
+      end
+    end
+
+    private
+
+    def valid_length?
+      data.bytesize == base_length + attested_credential_data_length + extension_data_length
+    end
+
+    def raw_extension_data
+      if extension_data_included?
+        if attested_credential_data_included?
+          trailing_bytes[attested_credential_data.length..-1]
+        else
+          trailing_bytes
+        end
+      end
+    end
+
+    def attested_credential_data_length
+      if attested_credential_data_included?
+        attested_credential_data.length
+      else
+        0
+      end
+    end
+
+    def extension_data_length
+      if extension_data_included?
+        raw_extension_data.length
+      else
+        0
+      end
+    end
+
+    def base_length
+      RP_ID_HASH_LENGTH + FLAGS_LENGTH + SIGN_COUNT_LENGTH
+    end
+  end
+end

data/lib/webauthn/authenticator_response.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "webauthn/authenticator_data"
+require "webauthn/client_data"
+require "webauthn/error"
+
+module WebAuthn
+  TYPES = { create: "webauthn.create", get: "webauthn.get" }.freeze
+
+  class VerificationError < Error; end
+
+  class AuthenticatorDataVerificationError < VerificationError; end
+  class ChallengeVerificationError < VerificationError; end
+  class OriginVerificationError < VerificationError; end
+  class RpIdVerificationError < VerificationError; end
+  class TokenBindingVerificationError < VerificationError; end
+  class TopOriginVerificationError < VerificationError; end
+  class TypeVerificationError < VerificationError; end
+  class UserPresenceVerificationError < VerificationError; end
+  class UserVerifiedVerificationError < VerificationError; end
+
+  class AuthenticatorResponse
+    def initialize(client_data_json:, relying_party: WebAuthn.configuration.relying_party)
+      @client_data_json = client_data_json
+      @relying_party = relying_party
+    end
+
+    def verify(expected_challenge, expected_origin = nil, user_presence: nil, user_verification: nil, rp_id: nil)
+      expected_origin ||= relying_party.allowed_origins || raise("Unspecified expected origin")
+
+      rp_id ||= relying_party.id
+
+      verify_item(:type)
+      verify_item(:token_binding)
+      verify_item(:challenge, expected_challenge)
+      verify_item(:origin, expected_origin)
+      verify_item(:top_origin) if needs_top_origin_verification?
+      verify_item(:authenticator_data)
+
+      verify_item(
+        :rp_id,
+        rp_id || rp_id_from_origin(expected_origin)
+      )
+
+      # Fallback to RP configuration unless user_presence is passed in explicitely
+      if user_presence.nil? && !relying_party.silent_authentication || user_presence
+        verify_item(:user_presence)
+      end
+
+      if user_verification
+        verify_item(:user_verified)
+      end
+
+      true
+    end
+
+    def valid?(*args, **keyword_arguments)
+      verify(*args, **keyword_arguments)
+    rescue WebAuthn::VerificationError
+      false
+    end
+
+    def client_data
+      @client_data ||= WebAuthn::ClientData.new(client_data_json)
+    end
+
+    private
+
+    attr_reader :client_data_json, :relying_party
+
+    def verify_item(item, *args)
+      if send("valid_#{item}?", *args)
+        true
+      else
+        camelized_item = item.to_s.split('_').map { |w| w.capitalize }.join
+        error_const_name = "WebAuthn::#{camelized_item}VerificationError"
+        raise Object.const_get(error_const_name)
+      end
+    end
+
+    def valid_type?
+      client_data.type == type
+    end
+
+    def valid_token_binding?
+      client_data.valid_token_binding_format?
+    end
+
+    def valid_top_origin?
+      return false unless client_data.cross_origin
+
+      relying_party.allowed_top_origins&.include?(client_data.top_origin)
+    end
+
+    def valid_challenge?(expected_challenge)
+      OpenSSL.secure_compare(client_data.challenge, expected_challenge)
+    end
+
+    def valid_origin?(expected_origin)
+      return false unless expected_origin
+
+      expected_origin.include?(client_data.origin)
+    end
+
+    def valid_rp_id?(rp_id)
+      return false unless rp_id
+
+      OpenSSL::Digest::SHA256.digest(rp_id) == authenticator_data.rp_id_hash
+    end
+
+    def valid_authenticator_data?
+      authenticator_data.valid?
+    rescue WebAuthn::AuthenticatorDataFormatError
+      false
+    end
+
+    def valid_user_presence?
+      authenticator_data.user_flagged?
+    end
+
+    def valid_user_verified?
+      authenticator_data.user_verified?
+    end
+
+    def rp_id_from_origin(expected_origin)
+      URI.parse(expected_origin.first).host if expected_origin.size == 1
+    end
+
+    def type
+      raise NotImplementedError, "Please define #type method in subclass"
+    end
+
+    def needs_top_origin_verification?
+      relying_party.verify_cross_origin && (client_data.cross_origin || client_data.top_origin)
+    end
+  end
+end