jwt 1.5.0 → 2.5.0

data/lib/jwt/algos/ecdsa.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module JWT
+  module Algos
+    module Ecdsa
+      module_function
+
+      NAMED_CURVES = {
+        'prime256v1' => {
+          algorithm: 'ES256',
+          digest: 'sha256'
+        },
+        'secp256r1' => { # alias for prime256v1
+          algorithm: 'ES256',
+          digest: 'sha256'
+        },
+        'secp384r1' => {
+          algorithm: 'ES384',
+          digest: 'sha384'
+        },
+        'secp521r1' => {
+          algorithm: 'ES512',
+          digest: 'sha512'
+        },
+        'secp256k1' => {
+          algorithm: 'ES256K',
+          digest: 'sha256'
+        }
+      }.freeze
+
+      SUPPORTED = NAMED_CURVES.map { |_, c| c[:algorithm] }.uniq.freeze
+
+      def sign(to_sign)
+        algorithm, msg, key = to_sign.values
+        curve_definition = curve_by_name(key.group.curve_name)
+        key_algorithm = curve_definition[:algorithm]
+        if algorithm != key_algorithm
+          raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} signing key was provided"
+        end
+
+        digest = OpenSSL::Digest.new(curve_definition[:digest])
+        SecurityUtils.asn1_to_raw(key.dsa_sign_asn1(digest.digest(msg)), key)
+      end
+
+      def verify(to_verify)
+        algorithm, public_key, signing_input, signature = to_verify.values
+        curve_definition = curve_by_name(public_key.group.curve_name)
+        key_algorithm = curve_definition[:algorithm]
+        if algorithm != key_algorithm
+          raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} verification key was provided"
+        end
+
+        digest = OpenSSL::Digest.new(curve_definition[:digest])
+        public_key.dsa_verify_asn1(digest.digest(signing_input), SecurityUtils.raw_to_asn1(signature, public_key))
+      end
+
+      def curve_by_name(name)
+        NAMED_CURVES.fetch(name) do
+          raise UnsupportedEcdsaCurve, "The ECDSA curve '#{name}' is not supported"
+        end
+      end
+    end
+  end
+end

data/lib/jwt/algos/eddsa.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JWT
+  module Algos
+    module Eddsa
+      module_function
+
+      SUPPORTED = %w[ED25519 EdDSA].freeze
+
+      def sign(to_sign)
+        algorithm, msg, key = to_sign.values
+        if key.class != RbNaCl::Signatures::Ed25519::SigningKey
+          raise EncodeError, "Key given is a #{key.class} but has to be an RbNaCl::Signatures::Ed25519::SigningKey"
+        end
+        unless SUPPORTED.map(&:downcase).map(&:to_sym).include?(algorithm.downcase.to_sym)
+          raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key.primitive} signing key was provided"
+        end
+
+        key.sign(msg)
+      end
+
+      def verify(to_verify)
+        algorithm, public_key, signing_input, signature = to_verify.values
+        unless SUPPORTED.map(&:downcase).map(&:to_sym).include?(algorithm.downcase.to_sym)
+          raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key.primitive} signing key was provided"
+        end
+        raise DecodeError, "key given is a #{public_key.class} but has to be a RbNaCl::Signatures::Ed25519::VerifyKey" if public_key.class != RbNaCl::Signatures::Ed25519::VerifyKey
+
+        public_key.verify(signature, signing_input)
+      rescue RbNaCl::CryptoError
+        false
+      end
+    end
+  end
+end

data/lib/jwt/algos/hmac.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JWT
+  module Algos
+    module Hmac
+      module_function
+
+      SUPPORTED = %w[HS256 HS512256 HS384 HS512].freeze
+
+      def sign(to_sign)
+        algorithm, msg, key = to_sign.values
+        key ||= ''
+        authenticator, padded_key = SecurityUtils.rbnacl_fixup(algorithm, key)
+        if authenticator && padded_key
+          authenticator.auth(padded_key, msg.encode('binary'))
+        else
+          OpenSSL::HMAC.digest(OpenSSL::Digest.new(algorithm.sub('HS', 'sha')), key, msg)
+        end
+      end
+
+      def verify(to_verify)
+        algorithm, public_key, signing_input, signature = to_verify.values
+        authenticator, padded_key = SecurityUtils.rbnacl_fixup(algorithm, public_key)
+        if authenticator && padded_key
+          begin
+            authenticator.verify(padded_key, signature.encode('binary'), signing_input.encode('binary'))
+          rescue RbNaCl::BadAuthenticatorError
+            false
+          end
+        else
+          SecurityUtils.secure_compare(signature, sign(JWT::Signature::ToSign.new(algorithm, signing_input, public_key)))
+        end
+      end
+    end
+  end
+end

data/lib/jwt/algos/none.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JWT
+  module Algos
+    module None
+      module_function
+
+      SUPPORTED = %w[none].freeze
+
+      def sign(*); end
+
+      def verify(*)
+        true
+      end
+    end
+  end
+end

data/lib/jwt/algos/ps.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module JWT
+  module Algos
+    module Ps
+      # RSASSA-PSS signing algorithms
+
+      module_function
+
+      SUPPORTED = %w[PS256 PS384 PS512].freeze
+
+      def sign(to_sign)
+        require_openssl!
+
+        algorithm, msg, key = to_sign.values
+
+        key_class = key.class
+
+        raise EncodeError, "The given key is a #{key_class}. It has to be an OpenSSL::PKey::RSA instance." if key_class == String
+
+        translated_algorithm = algorithm.sub('PS', 'sha')
+
+        key.sign_pss(translated_algorithm, msg, salt_length: :digest, mgf1_hash: translated_algorithm)
+      end
+
+      def verify(to_verify)
+        require_openssl!
+
+        SecurityUtils.verify_ps(to_verify.algorithm, to_verify.public_key, to_verify.signing_input, to_verify.signature)
+      end
+
+      def require_openssl!
+        if Object.const_defined?('OpenSSL')
+          if ::Gem::Version.new(OpenSSL::VERSION) < ::Gem::Version.new('2.1')
+            raise JWT::RequiredDependencyError, "You currently have OpenSSL #{OpenSSL::VERSION}. PS support requires >= 2.1"
+          end
+        else
+          raise JWT::RequiredDependencyError, 'PS signing requires OpenSSL +2.1'
+        end
+      end
+    end
+  end
+end

data/lib/jwt/algos/rsa.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JWT
+  module Algos
+    module Rsa
+      module_function
+
+      SUPPORTED = %w[RS256 RS384 RS512].freeze
+
+      def sign(to_sign)
+        algorithm, msg, key = to_sign.values
+        raise EncodeError, "The given key is a #{key.class}. It has to be an OpenSSL::PKey::RSA instance." if key.instance_of?(String)
+
+        key.sign(OpenSSL::Digest.new(algorithm.sub('RS', 'sha')), msg)
+      end
+
+      def verify(to_verify)
+        SecurityUtils.verify_rsa(to_verify.algorithm, to_verify.public_key, to_verify.signing_input, to_verify.signature)
+      end
+    end
+  end
+end

data/lib/jwt/algos/unsupported.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JWT
+  module Algos
+    module Unsupported
+      module_function
+
+      SUPPORTED = [].freeze
+
+      def sign(*)
+        raise NotImplementedError, 'Unsupported signing method'
+      end
+
+      def verify(*)
+        raise JWT::VerificationError, 'Algorithm not supported'
+      end
+    end
+  end
+end

data/lib/jwt/algos.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'jwt/algos/hmac'
+require 'jwt/algos/eddsa'
+require 'jwt/algos/ecdsa'
+require 'jwt/algos/rsa'
+require 'jwt/algos/ps'
+require 'jwt/algos/none'
+require 'jwt/algos/unsupported'
+
+# JWT::Signature module
+module JWT
+  # Signature logic for JWT
+  module Algos
+    extend self
+
+    ALGOS = [
+      Algos::Hmac,
+      Algos::Ecdsa,
+      Algos::Rsa,
+      Algos::Eddsa,
+      Algos::Ps,
+      Algos::None,
+      Algos::Unsupported
+    ].freeze
+
+    def find(algorithm)
+      indexed[algorithm && algorithm.downcase]
+    end
+
+    private
+
+    def indexed
+      @indexed ||= begin
+        fallback = [Algos::Unsupported, nil]
+        ALGOS.each_with_object(Hash.new(fallback)) do |alg, hash|
+          alg.const_get(:SUPPORTED).each do |code|
+            hash[code.downcase] = [alg, code]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jwt/base64.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module JWT
+  # Base64 helpers
+  class Base64
+    class << self
+      def url_encode(str)
+        ::Base64.encode64(str).tr('+/', '-_').gsub(/[\n=]/, '')
+      end
+
+      def url_decode(str)
+        str += '=' * (4 - str.length.modulo(4))
+        ::Base64.decode64(str.tr('-_', '+/'))
+      end
+    end
+  end
+end

data/lib/jwt/claims_validator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative './error'
+
+module JWT
+  class ClaimsValidator
+    NUMERIC_CLAIMS = %i[
+      exp
+      iat
+      nbf
+    ].freeze
+
+    def initialize(payload)
+      @payload = payload.transform_keys(&:to_sym)
+    end
+
+    def validate!
+      validate_numeric_claims
+
+      true
+    end
+
+    private
+
+    def validate_numeric_claims
+      NUMERIC_CLAIMS.each do |claim|
+        validate_is_numeric(claim) if @payload.key?(claim)
+      end
+    end
+
+    def validate_is_numeric(claim)
+      return if @payload[claim].is_a?(Numeric)
+
+      raise InvalidPayload, "#{claim} claim must be a Numeric value but it is a #{@payload[claim].class}"
+    end
+  end
+end

data/lib/jwt/configuration/container.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'decode_configuration'
+require_relative 'jwk_configuration'
+
+module JWT
+  module Configuration
+    class Container
+      attr_accessor :decode, :jwk
+
+      def initialize
+        reset!
+      end
+
+      def reset!
+        @decode = DecodeConfiguration.new
+        @jwk    = JwkConfiguration.new
+      end
+    end
+  end
+end

data/lib/jwt/configuration/decode_configuration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module JWT
+  module Configuration
+    class DecodeConfiguration
+      attr_accessor :verify_expiration,
+                    :verify_not_before,
+                    :verify_iss,
+                    :verify_iat,
+                    :verify_jti,
+                    :verify_aud,
+                    :verify_sub,
+                    :leeway,
+                    :algorithms,
+                    :required_claims
+
+      def initialize
+        @verify_expiration = true
+        @verify_not_before = true
+        @verify_iss = false
+        @verify_iat = false
+        @verify_jti = false
+        @verify_aud = false
+        @verify_sub = false
+        @leeway = 0
+        @algorithms = ['HS256']
+        @required_claims = []
+      end
+
+      def to_h
+        {
+          verify_expiration: verify_expiration,
+          verify_not_before: verify_not_before,
+          verify_iss: verify_iss,
+          verify_iat: verify_iat,
+          verify_jti: verify_jti,
+          verify_aud: verify_aud,
+          verify_sub: verify_sub,
+          leeway: leeway,
+          algorithms: algorithms,
+          required_claims: required_claims
+        }
+      end
+    end
+  end
+end

data/lib/jwt/configuration/jwk_configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../jwk/kid_as_key_digest'
+require_relative '../jwk/thumbprint'
+
+module JWT
+  module Configuration
+    class JwkConfiguration
+      def initialize
+        self.kid_generator_type = :key_digest
+      end
+
+      def kid_generator_type=(value)
+        self.kid_generator = case value
+                             when :key_digest
+                               JWT::JWK::KidAsKeyDigest
+                             when :rfc7638_thumbprint
+                               JWT::JWK::Thumbprint
+                             else
+                               raise ArgumentError, "#{value} is not a valid kid generator type."
+        end
+      end
+
+      attr_accessor :kid_generator
+    end
+  end
+end

data/lib/jwt/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'configuration/container'
+
+module JWT
+  module Configuration
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= ::JWT::Configuration::Container.new
+    end
+  end
+end

data/lib/jwt/decode.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require 'jwt/signature'
+require 'jwt/verify'
+require 'jwt/x5c_key_finder'
+# JWT::Decode module
+module JWT
+  # Decoding logic for JWT
+  class Decode
+    def initialize(jwt, key, verify, options, &keyfinder)
+      raise(JWT::DecodeError, 'Nil JSON web token') unless jwt
+
+      @jwt = jwt
+      @key = key
+      @options = options
+      @segments = jwt.split('.')
+      @verify = verify
+      @signature = ''
+      @keyfinder = keyfinder
+    end
+
+    def decode_segments
+      validate_segment_count!
+      if @verify
+        decode_crypto
+        verify_algo
+        set_key
+        verify_signature
+        verify_claims
+      end
+      raise(JWT::DecodeError, 'Not enough or too many segments') unless header && payload
+
+      [payload, header]
+    end
+
+    private
+
+    def verify_signature
+      return unless @key || @verify
+
+      return if none_algorithm?
+
+      raise JWT::DecodeError, 'No verification key available' unless @key
+
+      return if Array(@key).any? { |key| verify_signature_for?(key) }
+
+      raise(JWT::VerificationError, 'Signature verification failed')
+    end
+
+    def verify_algo
+      raise(JWT::IncorrectAlgorithm, 'An algorithm must be specified') if allowed_algorithms.empty?
+      raise(JWT::IncorrectAlgorithm, 'Token is missing alg header') unless algorithm
+      raise(JWT::IncorrectAlgorithm, 'Expected a different algorithm') unless options_includes_algo_in_header?
+    end
+
+    def set_key
+      @key = find_key(&@keyfinder) if @keyfinder
+      @key = ::JWT::JWK::KeyFinder.new(jwks: @options[:jwks]).key_for(header['kid']) if @options[:jwks]
+      if (x5c_options = @options[:x5c])
+        @key = X5cKeyFinder.new(x5c_options[:root_certificates], x5c_options[:crls]).from(header['x5c'])
+      end
+    end
+
+    def verify_signature_for?(key)
+      Signature.verify(algorithm, key, signing_input, @signature)
+    end
+
+    def options_includes_algo_in_header?
+      allowed_algorithms.any? { |alg| alg.casecmp(algorithm).zero? }
+    end
+
+    def allowed_algorithms
+      # Order is very important - first check for string keys, next for symbols
+      algos = if @options.key?('algorithm')
+        @options['algorithm']
+      elsif @options.key?(:algorithm)
+        @options[:algorithm]
+      elsif @options.key?('algorithms')
+        @options['algorithms']
+      elsif @options.key?(:algorithms)
+        @options[:algorithms]
+      else
+        []
+      end
+      Array(algos)
+    end
+
+    def find_key(&keyfinder)
+      key = (keyfinder.arity == 2 ? yield(header, payload) : yield(header))
+      # key can be of type [string, nil, OpenSSL::PKey, Array]
+      return key if key && !Array(key).empty?
+
+      raise JWT::DecodeError, 'No verification key available'
+    end
+
+    def verify_claims
+      Verify.verify_claims(payload, @options)
+      Verify.verify_required_claims(payload, @options)
+    end
+
+    def validate_segment_count!
+      return if segment_length == 3
+      return if !@verify && segment_length == 2 # If no verifying required, the signature is not needed
+      return if segment_length == 2 && none_algorithm?
+
+      raise(JWT::DecodeError, 'Not enough or too many segments')
+    end
+
+    def segment_length
+      @segments.count
+    end
+
+    def none_algorithm?
+      algorithm == 'none'
+    end
+
+    def decode_crypto
+      @signature = ::JWT::Base64.url_decode(@segments[2] || '')
+    end
+
+    def algorithm
+      header['alg']
+    end
+
+    def header
+      @header ||= parse_and_decode @segments[0]
+    end
+
+    def payload
+      @payload ||= parse_and_decode @segments[1]
+    end
+
+    def signing_input
+      @segments.first(2).join('.')
+    end
+
+    def parse_and_decode(segment)
+      JWT::JSON.parse(::JWT::Base64.url_decode(segment))
+    rescue ::JSON::ParserError
+      raise JWT::DecodeError, 'Invalid segment encoding'
+    end
+  end
+end

data/lib/jwt/encode.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative './algos'
+require_relative './claims_validator'
+
+# JWT::Encode module
+module JWT
+  # Encoding logic for JWT
+  class Encode
+    ALG_NONE = 'none'
+    ALG_KEY  = 'alg'
+
+    def initialize(options)
+      @payload = options[:payload]
+      @key = options[:key]
+      _, @algorithm = Algos.find(options[:algorithm])
+      @headers = options[:headers].transform_keys(&:to_s)
+    end
+
+    def segments
+      @segments ||= combine(encoded_header_and_payload, encoded_signature)
+    end
+
+    private
+
+    def encoded_header
+      @encoded_header ||= encode_header
+    end
+
+    def encoded_payload
+      @encoded_payload ||= encode_payload
+    end
+
+    def encoded_signature
+      @encoded_signature ||= encode_signature
+    end
+
+    def encoded_header_and_payload
+      @encoded_header_and_payload ||= combine(encoded_header, encoded_payload)
+    end
+
+    def encode_header
+      @headers[ALG_KEY] = @algorithm
+      encode(@headers)
+    end
+
+    def encode_payload
+      if @payload.is_a?(Hash)
+        ClaimsValidator.new(@payload).validate!
+      end
+
+      encode(@payload)
+    end
+
+    def encode_signature
+      return '' if @algorithm == ALG_NONE
+
+      ::JWT::Base64.url_encode(JWT::Signature.sign(@algorithm, encoded_header_and_payload, @key))
+    end
+
+    def encode(data)
+      ::JWT::Base64.url_encode(JWT::JSON.generate(data))
+    end
+
+    def combine(*parts)
+      parts.join('.')
+    end
+  end
+end

data/lib/jwt/error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JWT
+  class EncodeError < StandardError; end
+  class DecodeError < StandardError; end
+  class RequiredDependencyError < StandardError; end
+
+  class VerificationError < DecodeError; end
+  class ExpiredSignature < DecodeError; end
+  class IncorrectAlgorithm < DecodeError; end
+  class ImmatureSignature < DecodeError; end
+  class InvalidIssuerError < DecodeError; end
+  class UnsupportedEcdsaCurve < IncorrectAlgorithm; end
+  class InvalidIatError < DecodeError; end
+  class InvalidAudError < DecodeError; end
+  class InvalidSubError < DecodeError; end
+  class InvalidJtiError < DecodeError; end
+  class InvalidPayload < DecodeError; end
+  class MissingRequiredClaim < DecodeError; end
+
+  class JWKError < DecodeError; end
+end