jwt 1.5.6 → 2.0.0

data/lib/jwt/security_utils.rb

@@ -0,0 +1,52 @@
+module JWT
+  # Collection of security methods
+  #
+  # @see: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/security_utils.rb
+  module SecurityUtils
+
+    module_function
+
+    def secure_compare(left, right)
+      left_bytesize = left.bytesize
+
+      return false unless left_bytesize == right.bytesize
+
+      unpacked_left = left.unpack "C#{left_bytesize}"
+      result = 0
+      right.each_byte { |byte| result |= byte ^ unpacked_left.shift }
+      result.zero?
+    end
+
+    def verify_rsa(algorithm, public_key, signing_input, signature)
+      public_key.verify(OpenSSL::Digest.new(algorithm.sub('RS', 'sha')), signature, signing_input)
+    end
+
+    def asn1_to_raw(signature, public_key)
+      byte_size = (public_key.group.degree + 7) / 8
+      OpenSSL::ASN1.decode(signature).value.map { |value| value.value.to_s(2).rjust(byte_size, "\x00") }.join
+    end
+
+    def raw_to_asn1(signature, private_key)
+      byte_size = (private_key.group.degree + 7) / 8
+      sig_bytes = signature[0..(byte_size - 1)]
+      sig_char = signature[byte_size..-1] || ''
+      OpenSSL::ASN1::Sequence.new([sig_bytes, sig_char].map { |int| OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(int, 2)) }).to_der
+    end
+
+    def rbnacl_fixup(algorithm, key)
+      algorithm = algorithm.sub('HS', 'SHA').to_sym
+
+      return [] unless defined?(RbNaCl) && RbNaCl::HMAC.constants(false).include?(algorithm)
+
+      authenticator = RbNaCl::HMAC.const_get(algorithm)
+
+      # Fall back to OpenSSL for keys larger than 32 bytes.
+      return [] if key.bytesize > authenticator.key_bytes
+
+      [
+        authenticator,
+        key.bytes.fill(0, key.bytesize...authenticator.key_bytes).pack('C*')
+      ]
+    end
+  end
+end

data/lib/jwt/signature.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'jwt/security_utils'
+require 'openssl'
+begin
+  require 'rbnacl'
+rescue LoadError => e
+  abort(e.message) if defined?(RbNaCl)
+end
+
+# JWT::Signature module
+module JWT
+  # Signature logic for JWT
+  module Signature
+    extend self
+
+    HMAC_ALGORITHMS = %w[HS256 HS512256 HS384 HS512].freeze
+    RSA_ALGORITHMS = %w[RS256 RS384 RS512].freeze
+    ECDSA_ALGORITHMS = %w[ES256 ES384 ES512].freeze
+
+    NAMED_CURVES = {
+      'prime256v1' => 'ES256',
+      'secp384r1' => 'ES384',
+      'secp521r1' => 'ES512'
+    }.freeze
+
+    def sign(algorithm, msg, key)
+      if HMAC_ALGORITHMS.include?(algorithm)
+        sign_hmac(algorithm, msg, key)
+      elsif RSA_ALGORITHMS.include?(algorithm)
+        sign_rsa(algorithm, msg, key)
+      elsif ECDSA_ALGORITHMS.include?(algorithm)
+        sign_ecdsa(algorithm, msg, key)
+      else
+        raise NotImplementedError, 'Unsupported signing method'
+      end
+    end
+
+    def verify(algo, key, signing_input, signature)
+      verified = if HMAC_ALGORITHMS.include?(algo)
+        verify_hmac(algo, key, signing_input, signature)
+      elsif RSA_ALGORITHMS.include?(algo)
+        SecurityUtils.verify_rsa(algo, key, signing_input, signature)
+      elsif ECDSA_ALGORITHMS.include?(algo)
+        verify_ecdsa(algo, key, signing_input, signature)
+      else
+        raise JWT::VerificationError, 'Algorithm not supported'
+      end
+
+      raise(JWT::VerificationError, 'Signature verification raised') unless verified
+    rescue OpenSSL::PKey::PKeyError
+      raise JWT::VerificationError, 'Signature verification raised'
+    ensure
+      OpenSSL.errors.clear
+    end
+
+    private
+
+    def sign_rsa(algorithm, msg, private_key)
+      raise EncodeError, "The given key is a #{private_key.class}. It has to be an OpenSSL::PKey::RSA instance." if private_key.class == String
+      private_key.sign(OpenSSL::Digest.new(algorithm.sub('RS', 'sha')), msg)
+    end
+
+    def sign_ecdsa(algorithm, msg, private_key)
+      key_algorithm = NAMED_CURVES[private_key.group.curve_name]
+      if algorithm != key_algorithm
+        raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} signing key was provided"
+      end
+
+      digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha'))
+      SecurityUtils.asn1_to_raw(private_key.dsa_sign_asn1(digest.digest(msg)), private_key)
+    end
+
+    def sign_hmac(algorithm, msg, 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_ecdsa(algorithm, public_key, signing_input, signature)
+      key_algorithm = NAMED_CURVES[public_key.group.curve_name]
+      if algorithm != key_algorithm
+        raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} verification key was provided"
+      end
+
+      digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha'))
+      public_key.dsa_verify_asn1(digest.digest(signing_input), SecurityUtils.raw_to_asn1(signature, public_key))
+    end
+
+    def verify_hmac(algorithm, public_key, signing_input, signature)
+      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_hmac(algorithm, signing_input, public_key))
+      end
+    end
+  end
+end

data/lib/jwt/verify.rb

@@ -1,106 +1,101 @@
 # frozen_string_literal: true
+
 require 'jwt/error'
 
 module JWT
   # JWT verify methods
   class Verify
+    DEFAULTS = {
+      leeway: 0
+    }.freeze
+
     class << self
-      %w(verify_aud verify_expiration verify_iat verify_iss verify_jti verify_not_before verify_sub).each do |method_name|
+      %w[verify_aud verify_expiration verify_iat verify_iss verify_jti verify_not_before verify_sub].each do |method_name|
         define_method method_name do |payload, options|
           new(payload, options).send(method_name)
         end
       end
+
+      def verify_claims(payload, options)
+        options.each do |key, val|
+          next unless key.to_s =~ /verify/
+          Verify.send(key, payload, options) if val
+        end
+      end
     end
 
     def initialize(payload, options)
       @payload = payload
-      @options = options
+      @options = DEFAULTS.merge(options)
     end
 
     def verify_aud
-      return unless (options_aud = extract_option(:aud))
-
-      if @payload['aud'].is_a?(Array)
-        verify_aud_array(@payload['aud'], options_aud)
-      else
-        raise(
-          JWT::InvalidAudError,
-          "Invalid audience. Expected #{options_aud}, received #{@payload['aud'] || '<none>'}"
-        ) unless @payload['aud'].to_s == options_aud.to_s
-      end
-    end
+      return unless (options_aud = @options[:aud])
 
-    def verify_aud_array(audience, options_aud)
-      if options_aud.is_a?(Array)
-        options_aud.each do |aud|
-          raise(JWT::InvalidAudError, 'Invalid audience') unless audience.include?(aud.to_s)
-        end
-      else
-        raise(JWT::InvalidAudError, 'Invalid audience') unless audience.include?(options_aud.to_s)
-      end
+      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')
-
-      if @payload['exp'].to_i <= (Time.now.to_i - leeway)
-        raise(JWT::ExpiredSignature, 'Signature has expired')
-      end
+      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')
 
-      if !@payload['iat'].is_a?(Numeric) || @payload['iat'].to_f > (Time.now.to_f + leeway)
-        raise(JWT::InvalidIatError, 'Invalid iat')
-      end
+      iat = @payload['iat']
+      raise(JWT::InvalidIatError, 'Invalid iat') if !iat.is_a?(Numeric) || iat.to_f > (Time.now.to_f + iat_leeway)
     end
 
     def verify_iss
-      return unless (options_iss = extract_option(:iss))
+      return unless (options_iss = @options[:iss])
 
-      if @payload['iss'].to_s != options_iss.to_s
-        raise(
-          JWT::InvalidIssuerError,
-          "Invalid issuer. Expected #{options_iss}, received #{@payload['iss'] || '<none>'}"
-        )
-      end
+      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 = extract_option(:verify_jti)
+      options_verify_jti = @options[:verify_jti]
+      jti = @payload['jti']
+
       if options_verify_jti.respond_to?(:call)
-        raise(JWT::InvalidJtiError, 'Invalid jti') unless options_verify_jti.call(@payload['jti'])
-      else
-        raise(JWT::InvalidJtiError, 'Missing jti') if @payload['jti'].to_s.strip.empty?
+        raise(JWT::InvalidJtiError, 'Invalid jti') unless options_verify_jti.call(jti)
+      elsif jti.to_s.strip.empty?
+        raise(JWT::InvalidJtiError, 'Missing jti')
       end
     end
 
     def verify_not_before
       return unless @payload.include?('nbf')
-
-      if @payload['nbf'].to_i > (Time.now.to_i + leeway)
-        raise(JWT::ImmatureSignature, 'Signature nbf has not been reached')
-      end
+      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 = extract_option(:sub))
-
-      raise(
-        JWT::InvalidSubError,
-        "Invalid subject. Expected #{options_sub}, received #{@payload['sub'] || '<none>'}"
-      ) unless @payload['sub'].to_s == options_sub.to_s
+      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
 
     private
 
-    def extract_option(key)
-      @options.values_at(key.to_sym, key.to_s).compact.first
+    def global_leeway
+      @options[:leeway]
+    end
+
+    def exp_leeway
+      @options[:exp_leeway] || global_leeway
+    end
+
+    def iat_leeway
+      @options[:iat_leeway] || global_leeway
     end
 
-    def leeway
-      extract_option :leeway
+    def nbf_leeway
+      @options[:nbf_leeway] || global_leeway
     end
   end
 end

data/lib/jwt/version.rb

@@ -10,11 +10,11 @@ module JWT
   # Moments version builder module
   module VERSION
     # major version
-    MAJOR = 1
+    MAJOR = 2
     # minor version
-    MINOR = 5
+    MINOR = 0
     # tiny version
-    TINY  = 6
+    TINY  = 0
     # alpha, beta, etc. tag
     PRE   = nil
 

data/lib/jwt.rb

@@ -1,192 +1,61 @@
 # frozen_string_literal: true
+
 require 'base64'
-require 'openssl'
 require 'jwt/decode'
+require 'jwt/default_options'
+require 'jwt/encode'
 require 'jwt/error'
-require 'jwt/json'
+require 'jwt/signature'
+require 'jwt/verify'
 
 # JSON Web Token implementation
 #
 # Should be up to date with the latest spec:
-# https://tools.ietf.org/html/rfc7519#section-4.1.5
+# https://tools.ietf.org/html/rfc7519
 module JWT
-  extend JWT::Json
-
-  NAMED_CURVES = {
-    'prime256v1' => 'ES256',
-    'secp384r1' => 'ES384',
-    'secp521r1' => 'ES512'
-  }.freeze
-
-  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
-  }.freeze
+  include JWT::DefaultOptions
 
   module_function
 
-  def sign(algorithm, msg, key)
-    if %w(HS256 HS384 HS512).include?(algorithm)
-      sign_hmac(algorithm, msg, key)
-    elsif %w(RS256 RS384 RS512).include?(algorithm)
-      sign_rsa(algorithm, msg, key)
-    elsif %w(ES256 ES384 ES512).include?(algorithm)
-      sign_ecdsa(algorithm, msg, key)
-    else
-      raise NotImplementedError, 'Unsupported signing method'
-    end
-  end
-
-  def sign_rsa(algorithm, msg, private_key)
-    private_key.sign(OpenSSL::Digest.new(algorithm.sub('RS', 'sha')), msg)
-  end
-
-  def sign_ecdsa(algorithm, msg, private_key)
-    key_algorithm = NAMED_CURVES[private_key.group.curve_name]
-    if algorithm != key_algorithm
-      raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} signing key was provided"
-    end
-
-    digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha'))
-    asn1_to_raw(private_key.dsa_sign_asn1(digest.digest(msg)), private_key)
-  end
-
-  def verify_rsa(algorithm, public_key, signing_input, signature)
-    public_key.verify(OpenSSL::Digest.new(algorithm.sub('RS', 'sha')), signature, signing_input)
-  end
-
-  def verify_ecdsa(algorithm, public_key, signing_input, signature)
-    key_algorithm = NAMED_CURVES[public_key.group.curve_name]
-    if algorithm != key_algorithm
-      raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} verification key was provided"
-    end
-
-    digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha'))
-    public_key.dsa_verify_asn1(digest.digest(signing_input), raw_to_asn1(signature, public_key))
-  end
-
-  def sign_hmac(algorithm, msg, key)
-    OpenSSL::HMAC.digest(OpenSSL::Digest.new(algorithm.sub('HS', 'sha')), key, msg)
-  end
-
-  def base64url_encode(str)
-    Base64.encode64(str).tr('+/', '-_').gsub(/[\n=]/, '')
-  end
-
-  def encoded_header(algorithm = 'HS256', header_fields = {})
-    header = { 'typ' => 'JWT', 'alg' => algorithm }.merge(header_fields)
-    base64url_encode(encode_json(header))
-  end
-
-  def encoded_payload(payload)
-    raise InvalidPayload, 'exp claim must be an integer' if payload['exp'] && payload['exp'].is_a?(Time)
-    base64url_encode(encode_json(payload))
-  end
-
-  def encoded_signature(signing_input, key, algorithm)
-    if algorithm == 'none'
-      ''
-    else
-      signature = sign(algorithm, signing_input, key)
-      base64url_encode(signature)
-    end
-  end
-
   def encode(payload, key, algorithm = 'HS256', header_fields = {})
-    algorithm ||= 'none'
-    segments = []
-    segments << encoded_header(algorithm, header_fields)
-    segments << encoded_payload(payload)
-    segments << encoded_signature(segments.join('.'), key, algorithm)
-    segments.join('.')
-  end
-
-  def decoded_segments(jwt, key = nil, verify = true, custom_options = {}, &keyfinder)
-    raise(JWT::DecodeError, 'Nil JSON web token') unless jwt
-
-    merged_options = DEFAULT_OPTIONS.merge(custom_options)
-
-    decoder = Decode.new jwt, key, verify, merged_options, &keyfinder
-    decoder.decode_segments
+    encoder = Encode.new payload, key, algorithm, header_fields
+    encoder.segments
   end
 
   def decode(jwt, key = nil, verify = true, custom_options = {}, &keyfinder)
     raise(JWT::DecodeError, 'Nil JSON web token') unless jwt
 
     merged_options = DEFAULT_OPTIONS.merge(custom_options)
-    decoder = Decode.new jwt, key, verify, merged_options, &keyfinder
+
+    decoder = Decode.new jwt, verify
     header, payload, signature, signing_input = decoder.decode_segments
-    decode_verify_signature(key, header, signature, signing_input, merged_options, &keyfinder) if verify
-    decoder.verify
+    decode_verify_signature(key, header, payload, signature, signing_input, merged_options, &keyfinder) if verify
+
+    Verify.verify_claims(payload, merged_options) if verify
 
     raise(JWT::DecodeError, 'Not enough or too many segments') unless header && payload
 
     [payload, header]
   end
 
-  def decode_verify_signature(key, header, signature, signing_input, options, &keyfinder)
-    algo, key = signature_algorithm_and_key(header, key, &keyfinder)
-    if options[:algorithm] && algo != options[:algorithm]
-      raise JWT::IncorrectAlgorithm, 'Expected a different algorithm'
-    end
-    verify_signature(algo, key, signing_input, signature)
-  end
+  def decode_verify_signature(key, header, payload, signature, signing_input, options, &keyfinder)
+    algo, key = signature_algorithm_and_key(header, payload, key, &keyfinder)
 
-  def signature_algorithm_and_key(header, key, &keyfinder)
-    key = yield(header) if keyfinder
-    [header['alg'], key]
-  end
+    raise(JWT::IncorrectAlgorithm, 'An algorithm must be specified') unless options[:algorithm]
+    raise(JWT::IncorrectAlgorithm, 'Expected a different algorithm') unless algo == options[:algorithm]
 
-  def verify_signature(algo, key, signing_input, signature)
-    verify_signature_algo(algo, key, signing_input, signature)
-  rescue OpenSSL::PKey::PKeyError
-    raise JWT::VerificationError, 'Signature verification raised'
-  ensure
-    OpenSSL.errors.clear
+    Signature.verify(algo, key, signing_input, signature)
   end
 
-  def verify_signature_algo(algo, key, signing_input, signature)
-    if %w(HS256 HS384 HS512).include?(algo)
-      raise(JWT::VerificationError, 'Signature verification raised') unless secure_compare(signature, sign_hmac(algo, signing_input, key))
-    elsif %w(RS256 RS384 RS512).include?(algo)
-      raise(JWT::VerificationError, 'Signature verification raised') unless verify_rsa(algo, key, signing_input, signature)
-    elsif %w(ES256 ES384 ES512).include?(algo)
-      raise(JWT::VerificationError, 'Signature verification raised') unless verify_ecdsa(algo, key, signing_input, signature)
-    else
-      raise JWT::VerificationError, 'Algorithm not supported'
+  def signature_algorithm_and_key(header, payload, key, &keyfinder)
+    if keyfinder
+      key = if keyfinder.arity == 2
+        yield(header, payload)
+      else
+        yield(header)
+      end
+      raise JWT::DecodeError, 'No verification key available' unless key
     end
-  end
-
-  # From devise
-  # constant-time comparison algorithm to prevent timing attacks
-  def secure_compare(a, b)
-    return false if a.nil? || b.nil? || a.empty? || b.empty? || a.bytesize != b.bytesize
-    l = a.unpack "C#{a.bytesize}"
-
-    res = 0
-    b.each_byte { |byte| res |= byte ^ l.shift }
-    res.zero?
-  end
-
-  def raw_to_asn1(signature, private_key)
-    byte_size = (private_key.group.degree + 7) / 8
-    r = signature[0..(byte_size - 1)]
-    s = signature[byte_size..-1]
-    OpenSSL::ASN1::Sequence.new([r, s].map { |int| OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(int, 2)) }).to_der
-  end
-
-  def asn1_to_raw(signature, public_key)
-    byte_size = (public_key.group.degree + 7) / 8
-    OpenSSL::ASN1.decode(signature).value.map { |value| value.value.to_s(2).rjust(byte_size, "\x00") }.join
-  end
-
-  def base64url_decode(str)
-    Decode.base64url_decode(str)
+    [header['alg'], key]
   end
 end

data/ruby-jwt.gemspec

@@ -6,7 +6,6 @@ Gem::Specification.new do |spec|
   spec.name = 'jwt'
   spec.version = JWT.gem_version
   spec.authors = [
-    'Jeff Lindsay',
     'Tim Rudat'
   ]
   spec.email = 'timrudat@gmail.com'
@@ -14,17 +13,19 @@ Gem::Specification.new do |spec|
   spec.description = 'A pure ruby implementation of the RFC 7519 OAuth JSON Web Token (JWT) standard.'
   spec.homepage = 'http://github.com/jwt/ruby-jwt'
   spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.1'
 
   spec.files = `git ls-files -z`.split("\x0")
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = %w(lib)
+  spec.require_paths = %w[lib]
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'json', '< 2.0'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'simplecov-json'
   spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'codacy-coverage'
+  spec.add_development_dependency 'rbnacl'
 end

data/spec/integration/readme_examples_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../spec_helper'
 require 'jwt'
 
@@ -10,10 +11,10 @@ describe 'README.md code test' do
       token = JWT.encode payload, nil, 'none'
       decoded_token = JWT.decode token, nil, false
 
-      expect(token).to eq 'eyJ0eXAiOiJKV1QiLCJhbGciOiJub25lIn0.eyJkYXRhIjoidGVzdCJ9.'
+      expect(token).to eq 'eyJhbGciOiJub25lIn0.eyJkYXRhIjoidGVzdCJ9.'
       expect(decoded_token).to eq [
         { 'data' => 'test' },
-        { 'typ' => 'JWT', 'alg' => 'none' }
+        { 'alg' => 'none' }
       ]
     end
 
@@ -21,10 +22,10 @@ describe 'README.md code test' do
       token = JWT.encode payload, 'my$ecretK3y', 'HS256'
       decoded_token = JWT.decode token, 'my$ecretK3y', false
 
-      expect(token).to eq 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoidGVzdCJ9.ZxW8go9hz3ETCSfxFxpwSkYg_602gOPKearsf6DsxgY'
+      expect(token).to eq 'eyJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoidGVzdCJ9.pNIWIL34Jo13LViZAJACzK6Yf0qnvT_BuwOxiMCPE-Y'
       expect(decoded_token).to eq [
         { 'data' => 'test' },
-        { 'typ' => 'JWT', 'alg' => 'HS256' }
+        { 'alg' => 'HS256' }
       ]
     end
 
@@ -37,7 +38,7 @@ describe 'README.md code test' do
 
       expect(decoded_token).to eq [
         { 'data' => 'test' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' }
+        { 'alg' => 'RS256' }
       ]
     end
 
@@ -52,7 +53,7 @@ describe 'README.md code test' do
 
       expect(decoded_token).to eq [
         { 'data' => 'test' },
-        { 'typ' => 'JWT', 'alg' => 'ES256' }
+        { 'alg' => 'ES256' }
       ]
     end
   end
@@ -122,13 +123,13 @@ describe 'README.md code test' do
 
     context 'aud' do
       it 'array' do
-        aud = %w(Young Old)
+        aud = %w[Young Old]
         aud_payload = { data: 'data', aud: aud }
 
         token = JWT.encode aud_payload, hmac_secret, 'HS256'
 
         expect do
-          JWT.decode token, hmac_secret, true, aud: %w(Old Young), verify_aud: true, algorithm: 'HS256'
+          JWT.decode token, hmac_secret, true, aud: %w[Old Young], verify_aud: true, algorithm: 'HS256'
         end.not_to raise_error
       end
 
@@ -176,6 +177,17 @@ describe 'README.md code test' do
       end
     end
 
+    context 'custom header fields' do
+      it 'with custom field' do
+        payload = { data: 'test' }
+
+        token = JWT.encode payload, nil, 'none', typ: 'JWT'
+        _, header = JWT.decode token, nil, false
+
+        expect(header['typ']).to eq 'JWT'
+      end
+    end
+
     it 'sub' do
       sub = 'Subject'
       sub_payload = { data: 'data', sub: sub }