webauthn 2.1.0 → 2.4.1

data/lib/webauthn/attestation_statement/fido_u2f.rb

@@ -4,7 +4,6 @@ require "cose"
 require "openssl"
 require "webauthn/attestation_statement/base"
 require "webauthn/attestation_statement/fido_u2f/public_key"
-require "webauthn/signature_verifier"
 
 module WebAuthn
   module AttestationStatement
@@ -19,7 +18,8 @@ module WebAuthn
           valid_credential_public_key?(authenticator_data.credential.public_key) &&
           valid_aaguid?(authenticator_data.attested_credential_data.raw_aaguid) &&
           valid_signature?(authenticator_data, client_data_hash) &&
-          [WebAuthn::AttestationStatement::ATTESTATION_TYPE_BASIC_OR_ATTCA, attestation_trust_path]
+          trustworthy?(attestation_certificate_key_id: attestation_certificate_key_id) &&
+          [attestation_type, attestation_trust_path]
       end
 
       private
@@ -47,10 +47,8 @@ module WebAuthn
         attested_credential_data_aaguid == WebAuthn::AuthenticatorData::AttestedCredentialData::ZEROED_AAGUID
       end
 
-      def valid_signature?(authenticator_data, client_data_hash)
-        WebAuthn::SignatureVerifier
-          .new(VALID_ATTESTATION_CERTIFICATE_ALGORITHM, certificate_public_key)
-          .verify(signature, verification_data(authenticator_data, client_data_hash))
+      def algorithm
+        VALID_ATTESTATION_CERTIFICATE_ALGORITHM.id
       end
 
       def verification_data(authenticator_data, client_data_hash)
@@ -64,6 +62,10 @@ module WebAuthn
       def public_key_u2f(cose_key_data)
         PublicKey.new(cose_key_data)
       end
+
+      def attestation_type
+        WebAuthn::AttestationStatement::ATTESTATION_TYPE_BASIC_OR_ATTCA
+      end
     end
   end
 end

data/lib/webauthn/attestation_statement/none.rb

@@ -6,12 +6,18 @@ module WebAuthn
   module AttestationStatement
     class None < Base
       def valid?(*_args)
-        if statement == {}
+        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

@@ -2,25 +2,21 @@
 
 require "openssl"
 require "webauthn/attestation_statement/base"
-require "webauthn/signature_verifier"
 
 module WebAuthn
   # Implements https://www.w3.org/TR/2018/CR-webauthn-20180807/#packed-attestation
-  # ECDAA attestation is unsupported.
   module AttestationStatement
     class Packed < Base
       # Follows "Verification procedure"
       def valid?(authenticator_data, client_data_hash)
-        check_unsupported_feature
-
         valid_format? &&
           valid_algorithm?(authenticator_data.credential) &&
-          valid_certificate_chain? &&
           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) &&
-          attestation_type_and_trust_path
+          trustworthy?(aaguid: authenticator_data.aaguid) &&
+          [attestation_type, attestation_trust_path]
       end
 
       private
@@ -30,27 +26,11 @@ module WebAuthn
       end
 
       def self_attestation?
-        !raw_certificates && !raw_ecdaa_key_id
+        !raw_certificates
       end
 
       def valid_format?
-        algorithm && signature && (
-          [raw_certificates, raw_ecdaa_key_id].compact.size < 2
-        )
-      end
-
-      def check_unsupported_feature
-        if raw_ecdaa_key_id
-          raise NotSupportedError, "ecdaaKeyId of the packed attestation format is not implemented yet"
-        end
-      end
-
-      def valid_certificate_chain?
-        if certificate_chain
-          certificate_chain.all? { |c| certificate_in_use?(c) }
-        else
-          true
-        end
+        algorithm && signature
       end
 
       def valid_ec_public_keys?(credential)
@@ -65,7 +45,6 @@ module WebAuthn
           subject = attestation_certificate.subject.to_a
 
           attestation_certificate.version == 2 &&
-            certificate_in_use?(attestation_certificate) &&
             subject.assoc('OU')&.at(1) == "Authenticator Attestation" &&
             attestation_certificate.extensions.find { |ext| ext.oid == 'basicConstraints' }&.value == 'CA:FALSE'
         else
@@ -73,27 +52,20 @@ module WebAuthn
         end
       end
 
-      def certificate_in_use?(certificate)
-        now = Time.now
-
-        certificate.not_before < now && now < certificate.not_after
+      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)
-        signature_verifier = WebAuthn::SignatureVerifier.new(
-          algorithm,
+        super(
+          authenticator_data,
+          client_data_hash,
           attestation_certificate&.public_key || authenticator_data.credential.public_key_object
         )
-
-        signature_verifier.verify(signature, authenticator_data.data + client_data_hash)
-      end
-
-      def attestation_type_and_trust_path
-        if attestation_trust_path
-          [WebAuthn::AttestationStatement::ATTESTATION_TYPE_BASIC_OR_ATTCA, attestation_trust_path]
-        else
-          [WebAuthn::AttestationStatement::ATTESTATION_TYPE_SELF, nil]
-        end
       end
     end
   end

data/lib/webauthn/attestation_statement/tpm.rb

@@ -2,98 +2,63 @@
 
 require "cose/algorithm"
 require "openssl"
-require "tpm/constants"
+require "tpm/key_attestation"
 require "webauthn/attestation_statement/base"
-require "webauthn/attestation_statement/tpm/cert_info"
-require "webauthn/attestation_statement/tpm/pub_area"
-require "webauthn/signature_verifier"
 
 module WebAuthn
   module AttestationStatement
     class TPM < Base
-      CERTIFICATE_V3 = 2
-      CERTIFICATE_EMPTY_NAME = OpenSSL::X509::Name.new([]).freeze
-      CERTIFICATE_SAN_DIRECTORY_NAME = 4
-      OID_TCG_AT_TPM_MANUFACTURER = "2.23.133.2.1"
-      OID_TCG_AT_TPM_MODEL = "2.23.133.2.2"
-      OID_TCG_AT_TPM_VERSION = "2.23.133.2.3"
-      OID_TCG_KP_AIK_CERTIFICATE = "2.23.133.8.3"
       TPM_V2 = "2.0"
 
-      def valid?(authenticator_data, client_data_hash)
-        case attestation_type
-        when ATTESTATION_TYPE_ATTCA
-          att_to_be_signed = authenticator_data.data + client_data_hash
+      COSE_ALG_TO_TPM = {
+        "RS1" => { signature: ::TPM::ALG_RSASSA, hash: ::TPM::ALG_SHA1 },
+        "RS256" => { signature: ::TPM::ALG_RSASSA, hash: ::TPM::ALG_SHA256 },
+        "PS256" => { signature: ::TPM::ALG_RSAPSS, hash: ::TPM::ALG_SHA256 },
+        "ES256" => { signature: ::TPM::ALG_ECDSA, hash: ::TPM::ALG_SHA256 },
+      }.freeze
 
+      def valid?(authenticator_data, client_data_hash)
+        attestation_type == ATTESTATION_TYPE_ATTCA &&
           ver == TPM_V2 &&
-            valid_signature? &&
-            valid_attestation_certificate? &&
-            pub_area.valid?(authenticator_data.credential.public_key) &&
-            cert_info.valid?(statement["pubArea"],
-                             OpenSSL::Digest.digest(cose_algorithm.hash_function, att_to_be_signed)) &&
-            matching_aaguid?(authenticator_data.attested_credential_data.raw_aaguid) &&
-            [attestation_type, attestation_trust_path]
-        when ATTESTATION_TYPE_ECDAA
-          raise(
-            WebAuthn::AttestationStatement::Base::NotSupportedError,
-            "Attestation type ECDAA is not supported"
-          )
-        end
+          valid_key_attestation?(
+            authenticator_data.data + client_data_hash,
+            authenticator_data.credential.public_key_object,
+            authenticator_data.aaguid
+          ) &&
+          matching_aaguid?(authenticator_data.attested_credential_data.raw_aaguid) &&
+          trustworthy?(aaguid: authenticator_data.aaguid) &&
+          [attestation_type, attestation_trust_path]
       end
 
       private
 
-      def valid_signature?
-        WebAuthn::SignatureVerifier
-          .new(algorithm, attestation_certificate.public_key)
-          .verify(signature, verification_data, rsa_pss_salt_length: :auto)
-      end
-
-      def valid_attestation_certificate?
-        extensions = attestation_certificate.extensions
-
-        attestation_certificate.version == CERTIFICATE_V3 &&
-          attestation_certificate.subject.eql?(CERTIFICATE_EMPTY_NAME) &&
-          valid_subject_alternative_name? &&
-          certificate_in_use?(attestation_certificate) &&
-          extensions.find { |ext| ext.oid == 'basicConstraints' }&.value == "CA:FALSE" &&
-          extensions.find { |ext| ext.oid == "extendedKeyUsage" }&.value == OID_TCG_KP_AIK_CERTIFICATE
-      end
-
-      def valid_subject_alternative_name?
-        extension = attestation_certificate.extensions.detect { |ext| ext.oid == "subjectAltName" }
-        return unless extension&.critical?
-
-        san_asn1 = OpenSSL::ASN1.decode(extension).find do |val|
-          val.tag_class == :UNIVERSAL && val.tag == OpenSSL::ASN1::OCTET_STRING
-        end
-        directory_name = OpenSSL::ASN1.decode(san_asn1.value).find do |val|
-          val.tag_class == :CONTEXT_SPECIFIC && val.tag == CERTIFICATE_SAN_DIRECTORY_NAME
-        end
-        name = OpenSSL::X509::Name.new(directory_name.value.first).to_a
-        manufacturer = name.assoc(OID_TCG_AT_TPM_MANUFACTURER).at(1)
-        model = name.assoc(OID_TCG_AT_TPM_MODEL).at(1)
-        version = name.assoc(OID_TCG_AT_TPM_VERSION).at(1)
-
-        ::TPM::VENDOR_IDS[manufacturer] && !model.empty? && !version.empty?
-      end
-
-      def certificate_in_use?(certificate)
-        now = Time.now
+      def valid_key_attestation?(certified_extra_data, key, aaguid)
+        key_attestation =
+          ::TPM::KeyAttestation.new(
+            statement["certInfo"],
+            signature,
+            statement["pubArea"],
+            certificates,
+            OpenSSL::Digest.digest(cose_algorithm.hash_function, certified_extra_data),
+            signature_algorithm: tpm_algorithm[:signature],
+            hash_algorithm: tpm_algorithm[:hash],
+            root_certificates: root_certificates(aaguid: aaguid)
+          )
 
-        certificate.not_before < now && now < certificate.not_after
+        key_attestation.valid? && key_attestation.key && key_attestation.key.to_pem == key.to_pem
       end
 
-      def verification_data
-        statement["certInfo"]
+      def valid_certificate_chain?(**_)
+        # Already performed as part of #valid_key_attestation?
+        true
       end
 
-      def cert_info
-        @cert_info ||= CertInfo.new(statement["certInfo"])
+      def default_root_certificates
+        ::TPM::KeyAttestation::ROOT_CERTIFICATES
       end
 
-      def pub_area
-        @pub_area ||= PubArea.new(statement["pubArea"])
+      def tpm_algorithm
+        COSE_ALG_TO_TPM[cose_algorithm.name] || raise("Unsupported algorithm #{cose_algorithm.name}")
       end
 
       def ver
@@ -105,10 +70,8 @@ module WebAuthn
       end
 
       def attestation_type
-        if raw_certificates && !raw_ecdaa_key_id
+        if raw_certificates
           ATTESTATION_TYPE_ATTCA
-        elsif raw_ecdaa_key_id && !raw_certificates
-          ATTESTATION_TYPE_ECDAA
         else
           raise "Attestation type invalid"
         end

data/lib/webauthn/authenticator_assertion_response.rb

@@ -3,7 +3,6 @@
 require "webauthn/authenticator_data"
 require "webauthn/authenticator_response"
 require "webauthn/encoder"
-require "webauthn/signature_verifier"
 require "webauthn/public_key"
 
 module WebAuthn
@@ -37,8 +36,7 @@ module WebAuthn
       @user_handle = user_handle
     end
 
-    def verify(expected_challenge, expected_origin = nil, public_key:, sign_count:, user_verification: nil,
-               rp_id: nil)
+    def verify(expected_challenge, expected_origin = nil, public_key:, sign_count:, user_verification: nil, rp_id: nil)
       super(expected_challenge, expected_origin, user_verification: user_verification, rp_id: rp_id)
       verify_item(:signature, WebAuthn::PublicKey.deserialize(public_key))
       verify_item(:sign_count, sign_count)
@@ -47,7 +45,7 @@ module WebAuthn
     end
 
     def authenticator_data
-      @authenticator_data ||= WebAuthn::AuthenticatorData.new(authenticator_data_bytes)
+      @authenticator_data ||= WebAuthn::AuthenticatorData.deserialize(authenticator_data_bytes)
     end
 
     private
@@ -55,9 +53,7 @@ module WebAuthn
     attr_reader :authenticator_data_bytes, :signature
 
     def valid_signature?(webauthn_public_key)
-      WebAuthn::SignatureVerifier
-        .new(webauthn_public_key.alg, webauthn_public_key.pkey)
-        .verify(signature, authenticator_data_bytes + client_data.hash)
+      webauthn_public_key.verify(signature, authenticator_data_bytes + client_data.hash)
     end
 
     def valid_sign_count?(stored_sign_count)

data/lib/webauthn/authenticator_attestation_response.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require "cbor"
+require "forwardable"
 require "uri"
 require "openssl"
 
-require "webauthn/authenticator_data"
+require "webauthn/attestation_object"
 require "webauthn/authenticator_response"
-require "webauthn/attestation_statement"
 require "webauthn/client_data"
 require "webauthn/encoder"
 
@@ -16,6 +16,8 @@ module WebAuthn
   class AttestedCredentialVerificationError < VerificationError; end
 
   class AuthenticatorAttestationResponse < AuthenticatorResponse
+    extend Forwardable
+
     def self.from_client(response)
       encoder = WebAuthn.configuration.encoder
 
@@ -30,7 +32,7 @@ module WebAuthn
     def initialize(attestation_object:, **options)
       super(**options)
 
-      @attestation_object = attestation_object
+      @attestation_object_bytes = attestation_object
     end
 
     def verify(expected_challenge, expected_origin = nil, user_verification: nil, rp_id: nil)
@@ -39,107 +41,40 @@ module WebAuthn
       verify_item(:attested_credential)
       if WebAuthn.configuration.verify_attestation_statement
         verify_item(:attestation_statement)
-        verify_item(:attestation_trustworthiness) if WebAuthn.configuration.attestation_root_certificates_finders.any?
       end
 
       true
     end
 
-    def credential
-      authenticator_data.credential
-    end
-
-    def attestation_statement
-      @attestation_statement ||=
-        WebAuthn::AttestationStatement.from(attestation["fmt"], attestation["attStmt"])
+    def attestation_object
+      @attestation_object ||= WebAuthn::AttestationObject.deserialize(attestation_object_bytes)
     end
 
-    def authenticator_data
-      @authenticator_data ||= WebAuthn::AuthenticatorData.new(attestation["authData"])
-    end
+    def_delegators(
+      :attestation_object,
+      :aaguid,
+      :attestation_statement,
+      :attestation_certificate_key_id,
+      :authenticator_data,
+      :credential
+    )
 
-    def attestation_format
-      attestation["fmt"]
-    end
-
-    def attestation
-      @attestation ||= CBOR.decode(attestation_object)
-    end
-
-    def aaguid
-      raw_aaguid = authenticator_data.attested_credential_data.raw_aaguid
-      unless raw_aaguid == WebAuthn::AuthenticatorData::AttestedCredentialData::ZEROED_AAGUID
-        authenticator_data.attested_credential_data.aaguid
-      end
-    end
-
-    def attestation_certificate_key
-      raw_subject_key_identifier(attestation_statement.attestation_certificate)&.unpack("H*")&.[](0)
-    end
+    alias_method :attestation_certificate_key, :attestation_certificate_key_id
 
     private
 
-    attr_reader :attestation_object
+    attr_reader :attestation_object_bytes
 
     def type
       WebAuthn::TYPES[:create]
     end
 
     def valid_attested_credential?
-      authenticator_data.attested_credential_data_included? &&
-        authenticator_data.attested_credential_data.valid?
+      attestation_object.valid_attested_credential?
     end
 
     def valid_attestation_statement?
-      @attestation_type, @attestation_trust_path = attestation_statement.valid?(authenticator_data, client_data.hash)
-    end
-
-    def valid_attestation_trustworthiness?
-      case @attestation_type
-      when WebAuthn::AttestationStatement::ATTESTATION_TYPE_NONE
-        WebAuthn.configuration.acceptable_attestation_types.include?('None')
-      when WebAuthn::AttestationStatement::ATTESTATION_TYPE_SELF
-        WebAuthn.configuration.acceptable_attestation_types.include?('Self')
-      else
-        WebAuthn.configuration.acceptable_attestation_types.include?(@attestation_type) &&
-          attestation_root_certificates_store.verify(leaf_certificate, signing_certificates)
-      end
-    end
-
-    def raw_subject_key_identifier(certificate)
-      extension = certificate.extensions.detect { |ext| ext.oid == "subjectKeyIdentifier" }
-      return unless extension
-
-      ext_asn1 = OpenSSL::ASN1.decode(extension.to_der)
-      ext_value = ext_asn1.value.last
-      OpenSSL::ASN1.decode(ext_value.value).value
-    end
-
-    def attestation_root_certificates_store
-      certificates =
-        WebAuthn.configuration.attestation_root_certificates_finders.reduce([]) do |certs, finder|
-          if certs.empty?
-            finder.find(attestation_format: attestation_format,
-                        aaguid: aaguid,
-                        attestation_certificate_key_id: attestation_certificate_key) || []
-          else
-            certs
-          end
-        end
-
-      OpenSSL::X509::Store.new.tap do |store|
-        certificates.each do |cert|
-          store.add_cert(cert)
-        end
-      end
-    end
-
-    def signing_certificates
-      @attestation_trust_path[1..-1]
-    end
-
-    def leaf_certificate
-      @attestation_trust_path.first
+      @attestation_type, @attestation_trust_path = attestation_object.valid_attestation_statement?(client_data.hash)
     end
   end
 end