jwt 1.5.6 → 2.2.3

data/lib/jwt/algos/unsupported.rb

@@ -0,0 +1,17 @@
+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/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,35 @@
+require_relative './error'
+
+module JWT
+  class ClaimsValidator
+    NUMERIC_CLAIMS = %i[
+      exp
+      iat
+      nbf
+    ].freeze
+
+    def initialize(payload)
+      @payload = payload.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    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/decode.rb

@@ -1,57 +1,109 @@
 # frozen_string_literal: true
-require 'jwt/json'
-require 'jwt/verify'
 
+require 'json'
+
+require 'jwt/signature'
+require 'jwt/verify'
 # JWT::Decode module
 module JWT
-  extend JWT::Json
-
   # Decoding logic for JWT
   class Decode
-    attr_reader :header, :payload, :signature
-
     def initialize(jwt, key, verify, options, &keyfinder)
+      raise(JWT::DecodeError, 'Nil JSON web token') unless jwt
       @jwt = jwt
       @key = key
-      @verify = verify
       @options = options
+      @segments = jwt.split('.')
+      @verify = verify
+      @signature = ''
       @keyfinder = keyfinder
     end
 
     def decode_segments
-      header_segment, payload_segment, crypto_segment = raw_segments(@jwt, @verify)
-      @header, @payload = decode_header_and_payload(header_segment, payload_segment)
-      @signature = Decode.base64url_decode(crypto_segment.to_s) if @verify
-      signing_input = [header_segment, payload_segment].join('.')
-      [@header, @payload, @signature, signing_input]
+      validate_segment_count!
+      if @verify
+        decode_crypto
+        verify_signature
+        verify_claims
+      end
+      raise(JWT::DecodeError, 'Not enough or too many segments') unless header && payload
+      [payload, header]
     end
 
-    def raw_segments(jwt, verify)
-      segments = jwt.split('.')
-      required_num_segments = verify ? [3] : [2, 3]
-      raise(JWT::DecodeError, 'Not enough or too many segments') unless required_num_segments.include? segments.length
-      segments
+    private
+
+    def verify_signature
+      raise(JWT::IncorrectAlgorithm, 'An algorithm must be specified') if allowed_algorithms.empty?
+      raise(JWT::IncorrectAlgorithm, 'Expected a different algorithm') unless options_includes_algo_in_header?
+
+      @key = find_key(&@keyfinder) if @keyfinder
+      @key = ::JWT::JWK::KeyFinder.new(jwks: @options[:jwks]).key_for(header['kid']) if @options[:jwks]
+
+      Signature.verify(header['alg'], @key, signing_input, @signature)
     end
-    private :raw_segments
 
-    def decode_header_and_payload(header_segment, payload_segment)
-      header = JWT.decode_json(Decode.base64url_decode(header_segment))
-      payload = JWT.decode_json(Decode.base64url_decode(payload_segment))
-      [header, payload]
+    def options_includes_algo_in_header?
+      allowed_algorithms.any? { |alg| alg.casecmp(header['alg']).zero? }
     end
-    private :decode_header_and_payload
 
-    def self.base64url_decode(str)
-      str += '=' * (4 - str.length.modulo(4))
-      Base64.decode64(str.tr('-_', '+/'))
+    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 verify
-      @options.each do |key, val|
-        next unless key.to_s =~ /verify/
+    def find_key(&keyfinder)
+      key = (keyfinder.arity == 2 ? yield(header, payload) : yield(header))
+      raise JWT::DecodeError, 'No verification key available' unless key
+      key
+    end
 
-        Verify.send(key, payload, @options) if val
-      end
+    def verify_claims
+      Verify.verify_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 && header['alg'] == 'none'
+
+      raise(JWT::DecodeError, 'Not enough or too many segments')
+    end
+
+    def segment_length
+      @segments.count
+    end
+
+    def decode_crypto
+      @signature = JWT::Base64.url_decode(@segments[2] || '')
+    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/default_options.rb

@@ -0,0 +1,15 @@
+module JWT
+  module DefaultOptions
+    DEFAULT_OPTIONS = {
+      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']
+    }.freeze
+  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'.freeze
+    ALG_KEY  = 'alg'.freeze
+
+    def initialize(options)
+      @payload = options[:payload]
+      @key = options[:key]
+      _, @algorithm = Algos.find(options[:algorithm])
+      @headers = options[:headers].each_with_object({}) { |(key, value), headers| headers[key.to_s] = value }
+    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 && @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

@@ -1,6 +1,10 @@
 # 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
@@ -11,4 +15,6 @@ module JWT
   class InvalidSubError < DecodeError; end
   class InvalidJtiError < DecodeError; end
   class InvalidPayload < DecodeError; end
+
+  class JWKError < DecodeError; end
 end

data/lib/jwt/json.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
+
 require 'json'
 
 module JWT
-  # JSON fallback implementation or ruby 1.8.x
-  module Json
-    def decode_json(encoded)
-      JSON.parse(encoded)
-    rescue JSON::ParserError
-      raise JWT::DecodeError, 'Invalid segment encoding'
-    end
+  # JSON wrapper
+  class JSON
+    class << self
+      def generate(data)
+        ::JSON.generate(data)
+      end
 
-    def encode_json(raw)
-      JSON.generate(raw)
+      def parse(data)
+        ::JSON.parse(data)
+      end
     end
   end
 end

data/lib/jwt/jwk.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'jwk/key_finder'
+
+module JWT
+  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(keypair)
+        mappings.fetch(keypair.class) do |klass|
+          raise JWT::JWKError, "Cannot create JWK from a #{klass.name}"
+        end.new(keypair)
+      end
+
+      def classes
+        @mappings = nil # reset the cached mappings
+        @classes ||= []
+      end
+
+      alias new create_from
+
+      private
+
+      def mappings
+        @mappings ||= generate_mappings
+      end
+
+      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
+        end
+      end
+    end
+  end
+end
+
+require_relative 'jwk/key_base'
+require_relative 'jwk/ec'
+require_relative 'jwk/rsa'
+require_relative 'jwk/hmac'

data/lib/jwt/jwk/ec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module JWT
+  module JWK
+    class EC < KeyBase
+      extend Forwardable
+      def_delegators :@keypair, :public_key
+
+      KTY    = 'EC'.freeze
+      KTYS   = [KTY, OpenSSL::PKey::EC].freeze
+      BINARY = 2
+
+      def initialize(keypair, kid = nil)
+        raise ArgumentError, 'keypair must be of type OpenSSL::PKey::EC' unless keypair.is_a?(OpenSSL::PKey::EC)
+
+        kid ||= generate_kid(keypair)
+        super(keypair, kid)
+      end
+
+      def private?
+        @keypair.private_key?
+      end
+
+      def export(options = {})
+        crv, x_octets, y_octets = keypair_components(keypair)
+        exported_hash = {
+          kty: KTY,
+          crv: crv,
+          x: encode_octets(x_octets),
+          y: encode_octets(y_octets),
+          kid: kid
+        }
+        return exported_hash unless private? && options[:include_private] == true
+
+        append_private_parts(exported_hash)
+      end
+
+      private
+
+      def append_private_parts(the_hash)
+        octets = keypair.private_key.to_bn.to_s(BINARY)
+        the_hash.merge(
+          d: encode_octets(octets)
+        )
+      end
+
+      def generate_kid(ec_keypair)
+        _crv, x_octets, y_octets = keypair_components(ec_keypair)
+        sequence = OpenSSL::ASN1::Sequence([OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(x_octets, BINARY)),
+                                            OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(y_octets, BINARY))])
+        OpenSSL::Digest::SHA256.hexdigest(sequence.to_der)
+      end
+
+      def keypair_components(ec_keypair)
+        encoded_point = ec_keypair.public_key.to_bn.to_s(BINARY)
+        case ec_keypair.group.curve_name
+        when 'prime256v1'
+          crv = 'P-256'
+          x_octets, y_octets = encoded_point.unpack('xa32a32')
+        when 'secp384r1'
+          crv = 'P-384'
+          x_octets, y_octets = encoded_point.unpack('xa48a48')
+        when 'secp521r1'
+          crv = 'P-521'
+          x_octets, y_octets = encoded_point.unpack('xa66a66')
+        else
+          raise Jwt::JWKError, "Unsupported curve '#{ec_keypair.group.curve_name}'"
+        end
+        [crv, x_octets, y_octets]
+      end
+
+      def encode_octets(octets)
+        ::JWT::Base64.url_encode(octets)
+      end
+
+      def encode_open_ssl_bn(key_part)
+        ::JWT::Base64.url_encode(key_part.to_s(BINARY))
+      end
+
+      class << self
+        def import(jwk_data)
+          # See https://tools.ietf.org/html/rfc7518#section-6.2.1 for an
+          # explanation of the relevant parameters.
+
+          jwk_crv, jwk_x, jwk_y, jwk_d, jwk_kid = jwk_attrs(jwk_data, %i[crv x y d kid])
+          raise Jwt::JWKError, 'Key format is invalid for EC' unless jwk_crv && jwk_x && jwk_y
+
+          new(ec_pkey(jwk_crv, jwk_x, jwk_y, jwk_d), jwk_kid)
+        end
+
+        def to_openssl_curve(crv)
+          # The JWK specs and OpenSSL use different names for the same curves.
+          # See https://tools.ietf.org/html/rfc5480#section-2.1.1.1 for some
+          # pointers on different names for common curves.
+          case crv
+          when 'P-256' then 'prime256v1'
+          when 'P-384' then 'secp384r1'
+          when 'P-521' then 'secp521r1'
+          else raise JWT::JWKError, 'Invalid curve provided'
+          end
+        end
+
+        private
+
+        def jwk_attrs(jwk_data, attrs)
+          attrs.map do |attr|
+            jwk_data[attr] || jwk_data[attr.to_s]
+          end
+        end
+
+        def ec_pkey(jwk_crv, jwk_x, jwk_y, jwk_d)
+          curve = to_openssl_curve(jwk_crv)
+
+          x_octets = decode_octets(jwk_x)
+          y_octets = decode_octets(jwk_y)
+
+          key = OpenSSL::PKey::EC.new(curve)
+
+          # The details of the `Point` instantiation are covered in:
+          # - https://docs.ruby-lang.org/en/2.4.0/OpenSSL/PKey/EC.html
+          # - https://www.openssl.org/docs/manmaster/man3/EC_POINT_new.html
+          # - https://tools.ietf.org/html/rfc5480#section-2.2
+          # - https://www.secg.org/SEC1-Ver-1.0.pdf
+          # Section 2.3.3 of the last of these references specifies that the
+          # encoding of an uncompressed point consists of the byte `0x04` followed
+          # by the x value then the y value.
+          point = OpenSSL::PKey::EC::Point.new(
+            OpenSSL::PKey::EC::Group.new(curve),
+            OpenSSL::BN.new([0x04, x_octets, y_octets].pack('Ca*a*'), 2)
+          )
+
+          key.public_key = point
+          key.private_key = OpenSSL::BN.new(decode_octets(jwk_d), 2) if jwk_d
+
+          key
+        end
+
+        def decode_octets(jwk_data)
+          ::JWT::Base64.url_decode(jwk_data)
+        end
+
+        def decode_open_ssl_bn(jwk_data)
+          OpenSSL::BN.new(::JWT::Base64.url_decode(jwk_data), BINARY)
+        end
+      end
+    end
+  end
+end