jwt 2.3.0 → 2.10.1

data/lib/jwt/jwk/rsa.rb

@@ -2,95 +2,173 @@
 
 module JWT
   module JWK
-    class RSA < KeyBase
+    # JSON Web Key (JWK) representation of a RSA key
+    class RSA < KeyBase # rubocop:disable Metrics/ClassLength
       BINARY = 2
-      KTY    = 'RSA'.freeze
-      KTYS   = [KTY, OpenSSL::PKey::RSA].freeze
-      RSA_KEY_ELEMENTS = %i[n e d p q dp dq qi].freeze
+      KTY    = 'RSA'
+      KTYS   = [KTY, OpenSSL::PKey::RSA, JWT::JWK::RSA].freeze
+      RSA_PUBLIC_KEY_ELEMENTS  = %i[kty n e].freeze
+      RSA_PRIVATE_KEY_ELEMENTS = %i[d p q dp dq qi].freeze
+      RSA_KEY_ELEMENTS = (RSA_PRIVATE_KEY_ELEMENTS + RSA_PUBLIC_KEY_ELEMENTS).freeze
 
-      def initialize(keypair, kid = nil)
-        raise ArgumentError, 'keypair must be of type OpenSSL::PKey::RSA' unless keypair.is_a?(OpenSSL::PKey::RSA)
-        super(keypair, kid || generate_kid(keypair.public_key))
+      RSA_OPT_PARAMS    = %i[p q dp dq qi].freeze
+      RSA_ASN1_SEQUENCE = (%i[n e d] + RSA_OPT_PARAMS).freeze # https://www.rfc-editor.org/rfc/rfc3447#appendix-A.1.2
+
+      def initialize(key, params = nil, options = {})
+        params ||= {}
+
+        # For backwards compatibility when kid was a String
+        params = { kid: params } if params.is_a?(String)
+
+        key_params = extract_key_params(key)
+
+        params = params.transform_keys(&:to_sym)
+        check_jwk_params!(key_params, params)
+
+        super(options, key_params.merge(params))
+      end
+
+      def keypair
+        rsa_key
       end
 
       def private?
-        keypair.private?
+        rsa_key.private?
       end
 
       def public_key
-        keypair.public_key
+        rsa_key.public_key
       end
 
-      def export(options = {})
-        exported_hash = {
-          kty: KTY,
-          n: encode_open_ssl_bn(public_key.n),
-          e: encode_open_ssl_bn(public_key.e),
-          kid: kid
-        }
+      def signing_key
+        rsa_key if private?
+      end
 
-        return exported_hash unless private? && options[:include_private] == true
+      def verify_key
+        rsa_key.public_key
+      end
 
-        append_private_parts(exported_hash)
+      def export(options = {})
+        exported = parameters.clone
+        exported.reject! { |k, _| RSA_PRIVATE_KEY_ELEMENTS.include? k } unless private? && options[:include_private] == true
+        exported
       end
 
-      private
+      def members
+        RSA_PUBLIC_KEY_ELEMENTS.each_with_object({}) { |i, h| h[i] = self[i] }
+      end
 
-      def generate_kid(public_key)
+      def key_digest
         sequence = OpenSSL::ASN1::Sequence([OpenSSL::ASN1::Integer.new(public_key.n),
                                             OpenSSL::ASN1::Integer.new(public_key.e)])
         OpenSSL::Digest::SHA256.hexdigest(sequence.to_der)
       end
 
-      def append_private_parts(the_hash)
-        the_hash.merge(
-          d: encode_open_ssl_bn(keypair.d),
-          p: encode_open_ssl_bn(keypair.p),
-          q: encode_open_ssl_bn(keypair.q),
-          dp: encode_open_ssl_bn(keypair.dmp1),
-          dq: encode_open_ssl_bn(keypair.dmq1),
-          qi: encode_open_ssl_bn(keypair.iqmp)
-        )
+      def []=(key, value)
+        raise ArgumentError, 'cannot overwrite cryptographic key attributes' if RSA_KEY_ELEMENTS.include?(key.to_sym)
+
+        super(key, value)
+      end
+
+      private
+
+      def rsa_key
+        @rsa_key ||= self.class.create_rsa_key(jwk_attributes(*(RSA_KEY_ELEMENTS - [:kty])))
+      end
+
+      def extract_key_params(key)
+        case key
+        when JWT::JWK::RSA
+          key.export(include_private: true)
+        when OpenSSL::PKey::RSA # Accept OpenSSL key as input
+          @rsa_key = key # Preserve the object to avoid recreation
+          parse_rsa_key(key)
+        when Hash
+          key.transform_keys(&:to_sym)
+        else
+          raise ArgumentError, 'key must be of type OpenSSL::PKey::RSA or Hash with key parameters'
+        end
+      end
+
+      def check_jwk_params!(key_params, params)
+        raise ArgumentError, 'cannot overwrite cryptographic key attributes' unless (RSA_KEY_ELEMENTS & params.keys).empty?
+        raise JWT::JWKError, "Incorrect 'kty' value: #{key_params[:kty]}, expected #{KTY}" unless key_params[:kty] == KTY
+        raise JWT::JWKError, 'Key format is invalid for RSA' unless key_params[:n] && key_params[:e]
+      end
+
+      def parse_rsa_key(key)
+        {
+          kty: KTY,
+          n: encode_open_ssl_bn(key.n),
+          e: encode_open_ssl_bn(key.e),
+          d: encode_open_ssl_bn(key.d),
+          p: encode_open_ssl_bn(key.p),
+          q: encode_open_ssl_bn(key.q),
+          dp: encode_open_ssl_bn(key.dmp1),
+          dq: encode_open_ssl_bn(key.dmq1),
+          qi: encode_open_ssl_bn(key.iqmp)
+        }.compact
+      end
+
+      def jwk_attributes(*attributes)
+        attributes.each_with_object({}) do |attribute, hash|
+          hash[attribute] = decode_open_ssl_bn(self[attribute])
+        end
       end
 
       def encode_open_ssl_bn(key_part)
+        return unless key_part
+
         ::JWT::Base64.url_encode(key_part.to_s(BINARY))
       end
 
+      def decode_open_ssl_bn(jwk_data)
+        self.class.decode_open_ssl_bn(jwk_data)
+      end
+
       class << self
         def import(jwk_data)
-          pkey_params = jwk_attributes(jwk_data, *RSA_KEY_ELEMENTS) do |value|
-            decode_open_ssl_bn(value)
-          end
-          kid = jwk_attributes(jwk_data, :kid)[:kid]
-          self.new(rsa_pkey(pkey_params), kid)
+          new(jwk_data)
         end
 
-        private
+        def decode_open_ssl_bn(jwk_data)
+          return nil unless jwk_data
 
-        def jwk_attributes(jwk_data, *attributes)
-          attributes.each_with_object({}) do |attribute, hash|
-            value = jwk_data[attribute] || jwk_data[attribute.to_s]
-            value = yield(value) if block_given?
-            hash[attribute] = value
-          end
+          OpenSSL::BN.new(::JWT::Base64.url_decode(jwk_data), BINARY)
         end
 
-        def rsa_pkey(rsa_parameters)
-          raise JWT::JWKError, 'Key format is invalid for RSA' unless rsa_parameters[:n] && rsa_parameters[:e]
+        def create_rsa_key_using_der(rsa_parameters)
+          validate_rsa_parameters!(rsa_parameters)
 
-          populate_key(OpenSSL::PKey::RSA.new, rsa_parameters)
+          sequence = RSA_ASN1_SEQUENCE.each_with_object([]) do |key, arr|
+            next if rsa_parameters[key].nil?
+
+            arr << OpenSSL::ASN1::Integer.new(rsa_parameters[key])
+          end
+
+          if sequence.size > 2 # Append "two-prime" version for private key
+            sequence.unshift(OpenSSL::ASN1::Integer.new(0))
+
+            raise JWT::JWKError, 'Creating a RSA key with a private key requires the CRT parameters to be defined' if sequence.size < RSA_ASN1_SEQUENCE.size
+          end
+
+          OpenSSL::PKey::RSA.new(OpenSSL::ASN1::Sequence(sequence).to_der)
         end
 
-        if OpenSSL::PKey::RSA.new.respond_to?(:set_key)
-          def populate_key(rsa_key, rsa_parameters)
+        def create_rsa_key_using_sets(rsa_parameters)
+          validate_rsa_parameters!(rsa_parameters)
+
+          OpenSSL::PKey::RSA.new.tap do |rsa_key|
             rsa_key.set_key(rsa_parameters[:n], rsa_parameters[:e], rsa_parameters[:d])
             rsa_key.set_factors(rsa_parameters[:p], rsa_parameters[:q]) if rsa_parameters[:p] && rsa_parameters[:q]
             rsa_key.set_crt_params(rsa_parameters[:dp], rsa_parameters[:dq], rsa_parameters[:qi]) if rsa_parameters[:dp] && rsa_parameters[:dq] && rsa_parameters[:qi]
-            rsa_key
           end
-        else
-          def populate_key(rsa_key, rsa_parameters)
+        end
+
+        def create_rsa_key_using_accessors(rsa_parameters) # rubocop:disable Metrics/AbcSize
+          validate_rsa_parameters!(rsa_parameters)
+
+          OpenSSL::PKey::RSA.new.tap do |rsa_key|
             rsa_key.n = rsa_parameters[:n]
             rsa_key.e = rsa_parameters[:e]
             rsa_key.d = rsa_parameters[:d] if rsa_parameters[:d]
@@ -99,15 +177,24 @@ module JWT
             rsa_key.dmp1 = rsa_parameters[:dp] if rsa_parameters[:dp]
             rsa_key.dmq1 = rsa_parameters[:dq] if rsa_parameters[:dq]
             rsa_key.iqmp = rsa_parameters[:qi] if rsa_parameters[:qi]
-
-            rsa_key
           end
         end
 
-        def decode_open_ssl_bn(jwk_data)
-          return nil unless jwk_data
+        def validate_rsa_parameters!(rsa_parameters)
+          return unless rsa_parameters.key?(:d)
 
-          OpenSSL::BN.new(::JWT::Base64.url_decode(jwk_data), BINARY)
+          parameters = RSA_OPT_PARAMS - rsa_parameters.keys
+          return if parameters.empty? || parameters.size == RSA_OPT_PARAMS.size
+
+          raise JWT::JWKError, 'When one of p, q, dp, dq or qi is given all the other optimization parameters also needs to be defined' # https://www.rfc-editor.org/rfc/rfc7518.html#section-6.3.2
+        end
+
+        if ::JWT.openssl_3?
+          alias create_rsa_key create_rsa_key_using_der
+        elsif OpenSSL::PKey::RSA.new.respond_to?(:set_key)
+          alias create_rsa_key create_rsa_key_using_sets
+        else
+          alias create_rsa_key create_rsa_key_using_accessors
         end
       end
     end

data/lib/jwt/jwk/set.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module JWT
+  module JWK
+    # JSON Web Key Set (JWKS) representation
+    # https://tools.ietf.org/html/rfc7517
+    class Set
+      include Enumerable
+      extend Forwardable
+
+      attr_reader :keys
+
+      def initialize(jwks = nil, options = {}) # rubocop:disable Metrics/CyclomaticComplexity
+        jwks ||= {}
+
+        @keys = case jwks
+                when JWT::JWK::Set # Simple duplication
+                  jwks.keys
+                when JWT::JWK::KeyBase # Singleton
+                  [jwks]
+                when Hash
+                  jwks = jwks.transform_keys(&:to_sym)
+                  [*jwks[:keys]].map { |k| JWT::JWK.new(k, nil, options) }
+                when Array
+                  jwks.map { |k| JWT::JWK.new(k, nil, options) }
+                else
+                  raise ArgumentError, 'Can only create new JWKS from Hash, Array and JWK'
+                end
+      end
+
+      def export(options = {})
+        { keys: @keys.map { |k| k.export(options) } }
+      end
+
+      def_delegators :@keys, :each, :size, :delete, :dig
+
+      def select!(&block)
+        return @keys.select! unless block
+
+        self if @keys.select!(&block)
+      end
+
+      def reject!(&block)
+        return @keys.reject! unless block
+
+        self if @keys.reject!(&block)
+      end
+
+      def uniq!(&block)
+        self if @keys.uniq!(&block)
+      end
+
+      def merge(enum)
+        @keys += JWT::JWK::Set.new(enum.to_a).keys
+        self
+      end
+
+      def union(enum)
+        dup.merge(enum)
+      end
+
+      def add(key)
+        @keys << JWT::JWK.new(key)
+        self
+      end
+
+      def ==(other)
+        other.is_a?(JWT::JWK::Set) && keys.sort == other.keys.sort
+      end
+
+      alias eql? ==
+      alias filter! select!
+      alias length size
+      # For symbolic manipulation
+      alias | union
+      alias + union
+      alias << add
+    end
+  end
+end

data/lib/jwt/jwk/thumbprint.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JWT
+  module JWK
+    # https://tools.ietf.org/html/rfc7638
+    class Thumbprint
+      attr_reader :jwk
+
+      def initialize(jwk)
+        @jwk = jwk
+      end
+
+      def generate
+        ::Base64.urlsafe_encode64(
+          Digest::SHA256.digest(
+            JWT::JSON.generate(
+              jwk.members.sort.to_h
+            )
+          ), padding: false
+        )
+      end
+
+      alias to_s generate
+    end
+  end
+end

data/lib/jwt/jwk.rb

@@ -1,23 +1,25 @@
 # frozen_string_literal: true
 
 require_relative 'jwk/key_finder'
+require_relative 'jwk/set'
 
 module JWT
+  # JSON Web Key (JWK)
   module JWK
     class << self
-      def import(jwk_data)
-        jwk_kty = jwk_data[:kty] || jwk_data['kty']
-        raise JWT::JWKError, 'Key type (kty) not provided' unless jwk_kty
-
-        mappings.fetch(jwk_kty.to_s) do |kty|
-          raise JWT::JWKError, "Key type #{kty} not supported"
-        end.import(jwk_data)
-      end
+      def create_from(key, params = nil, options = {})
+        if key.is_a?(Hash)
+          jwk_kty = key[:kty] || key['kty']
+          raise JWT::JWKError, 'Key type (kty) not provided' unless jwk_kty
+
+          return mappings.fetch(jwk_kty.to_s) do |kty|
+            raise JWT::JWKError, "Key type #{kty} not supported"
+          end.new(key, params, options)
+        end
 
-      def create_from(keypair, kid = nil)
-        mappings.fetch(keypair.class) do |klass|
+        mappings.fetch(key.class) do |klass|
           raise JWT::JWKError, "Cannot create JWK from a #{klass.name}"
-        end.new(keypair, kid)
+        end.new(key, params, options)
       end
 
       def classes
@@ -26,6 +28,7 @@ module JWT
       end
 
       alias new create_from
+      alias import create_from
 
       private
 
@@ -36,6 +39,7 @@ module JWT
       def generate_mappings
         classes.each_with_object({}) do |klass, hash|
           next unless klass.const_defined?('KTYS')
+
           Array(klass::KTYS).each do |kty|
             hash[kty] = klass
           end
@@ -49,3 +53,4 @@ require_relative 'jwk/key_base'
 require_relative 'jwk/ec'
 require_relative 'jwk/rsa'
 require_relative 'jwk/hmac'
+require_relative 'jwk/okp_rbnacl' if JWT.rbnacl?

data/lib/jwt/token.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module JWT
+  # Represents a JWT token
+  #
+  # Basic token signed using the HS256 algorithm:
+  #
+  #   token = JWT::Token.new(payload: {pay: 'load'})
+  #   token.sign!(algorithm: 'HS256', key: 'secret')
+  #   token.jwt # => eyJhb....
+  #
+  # Custom headers will be combined with generated headers:
+  #   token = JWT::Token.new(payload: {pay: 'load'}, header: {custom: "value"})
+  #   token.sign!(algorithm: 'HS256', key: 'secret')
+  #   token.header # => {"custom"=>"value", "alg"=>"HS256"}
+  #
+  class Token
+    include Claims::VerificationMethods
+
+    # Initializes a new Token instance.
+    #
+    # @param header [Hash] the header of the JWT token.
+    # @param payload [Hash] the payload of the JWT token.
+    def initialize(payload:, header: {})
+      @header  = header&.transform_keys(&:to_s)
+      @payload = payload
+    end
+
+    # Returns the decoded signature of the JWT token.
+    #
+    # @return [String] the decoded signature of the JWT token.
+    def signature
+      @signature ||= ::JWT::Base64.url_decode(encoded_signature || '')
+    end
+
+    # Returns the encoded signature of the JWT token.
+    #
+    # @return [String] the encoded signature of the JWT token.
+    def encoded_signature
+      @encoded_signature ||= ::JWT::Base64.url_encode(signature)
+    end
+
+    # Returns the decoded header of the JWT token.
+    #
+    # @return [Hash] the header of the JWT token.
+    attr_reader :header
+
+    # Returns the encoded header of the JWT token.
+    #
+    # @return [String] the encoded header of the JWT token.
+    def encoded_header
+      @encoded_header ||= ::JWT::Base64.url_encode(JWT::JSON.generate(header))
+    end
+
+    # Returns the payload of the JWT token.
+    #
+    # @return [Hash] the payload of the JWT token.
+    attr_reader :payload
+
+    # Returns the encoded payload of the JWT token.
+    #
+    # @return [String] the encoded payload of the JWT token.
+    def encoded_payload
+      @encoded_payload ||= ::JWT::Base64.url_encode(JWT::JSON.generate(payload))
+    end
+
+    # Returns the signing input of the JWT token.
+    #
+    # @return [String] the signing input of the JWT token.
+    def signing_input
+      @signing_input ||= [encoded_header, encoded_payload].join('.')
+    end
+
+    # Returns the JWT token as a string.
+    #
+    # @return [String] the JWT token as a string.
+    # @raise [JWT::EncodeError] if the token is not signed or other encoding issues
+    def jwt
+      @jwt ||= (@signature && [encoded_header, @detached_payload ? '' : encoded_payload, encoded_signature].join('.')) || raise(::JWT::EncodeError, 'Token is not signed')
+    end
+
+    # Detaches the payload according to https://datatracker.ietf.org/doc/html/rfc7515#appendix-F
+    #
+    def detach_payload!
+      @detached_payload = true
+
+      nil
+    end
+
+    # Signs the JWT token.
+    #
+    # @param algorithm [String, Object] the algorithm to use for signing.
+    # @param key [String] the key to use for signing.
+    # @return [void]
+    # @raise [JWT::EncodeError] if the token is already signed or other problems when signing
+    def sign!(algorithm:, key:)
+      raise ::JWT::EncodeError, 'Token already signed' if @signature
+
+      JWA.resolve(algorithm).tap do |algo|
+        header.merge!(algo.header)
+        @signature = algo.sign(data: signing_input, signing_key: key)
+      end
+
+      nil
+    end
+
+    # Returns the JWT token as a string.
+    #
+    # @return [String] the JWT token as a string.
+    alias to_s jwt
+  end
+end

data/lib/jwt/verify.rb

@@ -1,105 +1,40 @@
 # frozen_string_literal: true
 
-require 'jwt/error'
+require_relative 'error'
 
 module JWT
-  # JWT verify methods
+  # @deprecated This class is deprecated and will be removed in the next major version of ruby-jwt.
   class Verify
-    DEFAULTS = {
-      leeway: 0
-    }.freeze
+    DEFAULTS = { leeway: 0 }.freeze
+    METHODS = %w[verify_aud verify_expiration verify_iat verify_iss verify_jti verify_not_before verify_sub verify_required_claims].freeze
 
+    private_constant(:DEFAULTS, :METHODS)
     class << self
-      %w[verify_aud verify_expiration verify_iat verify_iss verify_jti verify_not_before verify_sub verify_required_claims].each do |method_name|
-        define_method method_name do |payload, options|
+      METHODS.each do |method_name|
+        define_method(method_name) do |payload, options|
           new(payload, options).send(method_name)
         end
       end
 
+      # @deprecated This method is deprecated and will be removed in the next major version of ruby-jwt.
       def verify_claims(payload, options)
-        options.each do |key, val|
-          next unless key.to_s =~ /verify/
-          Verify.send(key, payload, options) if val
-        end
+        Deprecations.warning('The ::JWT::Verify.verify_claims method is deprecated and will be removed in the next major version of ruby-jwt')
+        ::JWT::Claims.verify!(payload, options)
+        true
       end
     end
 
+    # @deprecated This class is deprecated and will be removed in the next major version of ruby-jwt.
     def initialize(payload, options)
+      Deprecations.warning('The ::JWT::Verify class is deprecated and will be removed in the next major version of ruby-jwt')
       @payload = payload
       @options = DEFAULTS.merge(options)
     end
 
-    def verify_aud
-      return unless (options_aud = @options[:aud])
-
-      aud = @payload['aud']
-      raise(JWT::InvalidAudError, "Invalid audience. Expected #{options_aud}, received #{aud || '<none>'}") if ([*aud] & [*options_aud]).empty?
-    end
-
-    def verify_expiration
-      return unless @payload.include?('exp')
-      raise(JWT::ExpiredSignature, 'Signature has expired') if @payload['exp'].to_i <= (Time.now.to_i - exp_leeway)
-    end
-
-    def verify_iat
-      return unless @payload.include?('iat')
-
-      iat = @payload['iat']
-      raise(JWT::InvalidIatError, 'Invalid iat') if !iat.is_a?(Numeric) || iat.to_f > Time.now.to_f
-    end
-
-    def verify_iss
-      return unless (options_iss = @options[:iss])
-
-      iss = @payload['iss']
-
-      return if Array(options_iss).map(&:to_s).include?(iss.to_s)
-
-      raise(JWT::InvalidIssuerError, "Invalid issuer. Expected #{options_iss}, received #{iss || '<none>'}")
-    end
-
-    def verify_jti
-      options_verify_jti = @options[:verify_jti]
-      jti = @payload['jti']
-
-      if options_verify_jti.respond_to?(:call)
-        verified = options_verify_jti.arity == 2 ? options_verify_jti.call(jti, @payload) : options_verify_jti.call(jti)
-        raise(JWT::InvalidJtiError, 'Invalid jti') unless verified
-      elsif jti.to_s.strip.empty?
-        raise(JWT::InvalidJtiError, 'Missing jti')
+    METHODS.each do |method_name|
+      define_method(method_name) do
+        ::JWT::Claims.verify!(@payload, @options.merge(method_name => true))
       end
     end
-
-    def verify_not_before
-      return unless @payload.include?('nbf')
-      raise(JWT::ImmatureSignature, 'Signature nbf has not been reached') if @payload['nbf'].to_i > (Time.now.to_i + nbf_leeway)
-    end
-
-    def verify_sub
-      return unless (options_sub = @options[:sub])
-      sub = @payload['sub']
-      raise(JWT::InvalidSubError, "Invalid subject. Expected #{options_sub}, received #{sub || '<none>'}") unless sub.to_s == options_sub.to_s
-    end
-
-    def verify_required_claims
-      return unless (options_required_claims = @options[:required_claims])
-      options_required_claims.each do |required_claim|
-        raise(JWT::MissingRequiredClaim, "Missing required claim #{required_claim}") unless @payload.include?(required_claim)
-      end
-    end
-
-    private
-
-    def global_leeway
-      @options[:leeway]
-    end
-
-    def exp_leeway
-      @options[:exp_leeway] || global_leeway
-    end
-
-    def nbf_leeway
-      @options[:nbf_leeway] || global_leeway
-    end
   end
 end