jwt 2.7.1 → 2.10.3

data/README.md

@@ -1,7 +1,7 @@
 # JWT
 
 [![Gem Version](https://badge.fury.io/rb/jwt.svg)](https://badge.fury.io/rb/jwt)
-[![Build Status](https://github.com/jwt/ruby-jwt/workflows/test/badge.svg?branch=main)](https://github.com/jwt/ruby-jwt/actions)
+[![Build Status](https://github.com/jwt/ruby-jwt/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/jwt/ruby-jwt/actions)
 [![Code Climate](https://codeclimate.com/github/jwt/ruby-jwt/badges/gpa.svg)](https://codeclimate.com/github/jwt/ruby-jwt)
 [![Test Coverage](https://codeclimate.com/github/jwt/ruby-jwt/badges/coverage.svg)](https://codeclimate.com/github/jwt/ruby-jwt/coverage)
 [![Issue Count](https://codeclimate.com/github/jwt/ruby-jwt/badges/issue_count.svg)](https://codeclimate.com/github/jwt/ruby-jwt)
@@ -10,13 +10,30 @@ A ruby implementation of the [RFC 7519 OAuth JSON Web Token (JWT)](https://tools
 
 If you have further questions related to development or usage, join us: [ruby-jwt google group](https://groups.google.com/forum/#!forum/ruby-jwt).
 
-## Announcements
-* Ruby 2.4 support was dropped in version 2.4.0
-* Ruby 1.9.3 support was dropped at December 31st, 2016.
-* Version 1.5.3 yanked. See: [#132](https://github.com/jwt/ruby-jwt/issues/132) and [#133](https://github.com/jwt/ruby-jwt/issues/133)
-
 See [CHANGELOG.md](CHANGELOG.md) for a complete set of changes.
 
+## Upcoming breaking changes
+
+Notable changes in the upcoming **version 3.0**:
+
+- The indirect dependency to [rbnacl](https://github.com/RubyCrypto/rbnacl) will be removed:
+  - Support for the non-standard SHA512256 algorithm will be removed.
+  - Support for Ed25519 will be moved to a [separate gem](https://github.com/anakinj/jwt-eddsa) for better dependency handling.
+
+- Base64 decoding will no longer fallback on the looser RFC 2045.
+
+- Claim verification has been [split into separate classes](https://github.com/jwt/ruby-jwt/pull/605) and has [a new api](https://github.com/jwt/ruby-jwt/pull/626) and lead to the following deprecations:
+  - The `::JWT::ClaimsValidator` class will be removed in favor of the functionality provided by `::JWT::Claims`.
+  - The `::JWT::Claims::verify!` method will be removed in favor of `::JWT::Claims::verify_payload!`.
+  - The `::JWT::JWA.create` method will be removed.
+  - The `::JWT::Verify` class will be removed in favor of the functionality provided by `::JWT::Claims`.
+  - Calling `::JWT::Claims::Numeric.new` with a payload will be removed in favor of `::JWT::Claims::verify_payload!(payload, :numeric)`.
+  - Calling `::JWT::Claims::Numeric.verify!` with a payload will be removed in favor of `::JWT::Claims::verify_payload!(payload, :numeric)`.
+
+- The internal algorithms were [restructured](https://github.com/jwt/ruby-jwt/pull/607) to support extensions from separate libraries. The changes lead to a few deprecations and new requirements:
+  - The `sign` and `verify` static methods on all the algorithms (`::JWT::JWA`) will be removed.
+  - Custom algorithms are expected to include the `JWT::JWA::SigningAlgorithm` module.
+
 ## Sponsors
 
 |Logo|Message|
@@ -26,40 +43,68 @@ See [CHANGELOG.md](CHANGELOG.md) for a complete set of changes.
 ## Installing
 
 ### Using Rubygems:
+
 ```bash
 gem install jwt
 ```
 
 ### Using Bundler:
+
 Add the following to your Gemfile
 ```
 gem 'jwt'
 ```
+
 And run `bundle install`
 
+Finally require the gem in your application
+```ruby
+require 'jwt'
+```
+
 ## Algorithms and Usage
 
-The JWT spec supports NONE, HMAC, RSASSA, ECDSA and RSASSA-PSS algorithms for cryptographic signing. Currently the jwt gem supports NONE, HMAC, RSASSA and ECDSA. If you are using cryptographic signing, you need to specify the algorithm in the options hash whenever you call JWT.decode to ensure that an attacker [cannot bypass the algorithm verification step](https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/). **It is strongly recommended that you hard code the algorithm, as you may leave yourself vulnerable by dynamically picking the algorithm**
+The jwt gem natively supports the NONE, HMAC, RSASSA, ECDSA and RSASSA-PSS algorithms via the openssl library. The gem can be extended with additional or alternative implementations of the algorithms via extensions.
+
+Additionally the EdDSA algorithm is supported via a [separate gem](https://rubygems.org/gems/jwt-eddsa).
+
+For safe cryptographic signing, you need to specify the algorithm in the options hash whenever you call `JWT.decode` to ensure that an attacker [cannot bypass the algorithm verification step](https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/). **It is strongly recommended that you hard code the algorithm, as you may leave yourself vulnerable by dynamically picking the algorithm**
 
 See: [ JSON Web Algorithms (JWA) 3.1. "alg" (Algorithm) Header Parameter Values for JWS](https://tools.ietf.org/html/rfc7518#section-3.1)
 
+### Deprecation warnings
+
+Deprecation warnings are logged once (`:once` option) by default to avoid spam in logs. Other options are `:silent` to completely silence warnings and `:warn` to log every time a deprecated path is executed.
+
+```ruby
+  JWT.configuration.deprecation_warnings = :warn # default is :once
+```
+
+### Base64 decoding
+
+In the past the gem has been supporting the Base64 decoding specified in [RFC2045](https://www.rfc-editor.org/rfc/rfc2045) allowing newlines and blanks in the base64 encoded payload. In future versions base64 decoding will be stricter and only comply to [RFC4648](https://www.rfc-editor.org/rfc/rfc4648).
+
+The stricter base64 decoding when processing tokens can be done via the `strict_base64_decoding` configuration accessor.
+```ruby
+  JWT.configuration.strict_base64_decoding = true # default is false
+```
+
 ### **NONE**
 
 * none - unsigned token
 
 ```ruby
-require 'jwt'
 
 payload = { data: 'test' }
 
 # IMPORTANT: set nil as password parameter
-token = JWT.encode payload, nil, 'none'
+token = JWT.encode(payload, nil, 'none')
 
 # eyJhbGciOiJub25lIn0.eyJkYXRhIjoidGVzdCJ9.
 puts token
 
 # Set password to nil and validation to false otherwise this won't work
-decoded_token = JWT.decode token, nil, false
+decoded_token = JWT.decode(token, nil, false)
 
 # Array
 # [
@@ -72,7 +117,6 @@ puts decoded_token
 ### **HMAC**
 
 * HS256 - HMAC using SHA-256 hash algorithm
-* HS512256 - HMAC using SHA-512-256 hash algorithm (only available with RbNaCl; see note below)
 * HS384 - HMAC using SHA-384 hash algorithm
 * HS512 - HMAC using SHA-512 hash algorithm
 
@@ -80,12 +124,12 @@ puts decoded_token
 # The secret must be a string. With OpenSSL 3.0/openssl gem `<3.0.1`, JWT::DecodeError will be raised if it isn't provided.
 hmac_secret = 'my$ecretK3y'
 
-token = JWT.encode payload, hmac_secret, 'HS256'
+token = JWT.encode(payload, hmac_secret, 'HS256')
 
 # eyJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoidGVzdCJ9.pNIWIL34Jo13LViZAJACzK6Yf0qnvT_BuwOxiMCPE-Y
 puts token
 
-decoded_token = JWT.decode token, hmac_secret, true, { algorithm: 'HS256' }
+decoded_token = JWT.decode(token, hmac_secret, true, { algorithm: 'HS256' })
 
 # Array
 # [
@@ -95,12 +139,6 @@ decoded_token = JWT.decode token, hmac_secret, true, { algorithm: 'HS256' }
 puts decoded_token
 ```
 
-Note: If [RbNaCl](https://github.com/RubyCrypto/rbnacl) is loadable, ruby-jwt will use it for HMAC-SHA256, HMAC-SHA512-256, and HMAC-SHA512. RbNaCl prior to 6.0.0 only support a maximum key size of 32 bytes for these algorithms.
-
-[RbNaCl](https://github.com/RubyCrypto/rbnacl) requires
-[libsodium](https://github.com/jedisct1/libsodium), it can be installed
-on MacOS with `brew install libsodium`.
-
 ### **RSA**
 
 * RS256 - RSA using SHA-256 hash algorithm
@@ -108,15 +146,15 @@ on MacOS with `brew install libsodium`.
 * RS512 - RSA using SHA-512 hash algorithm
 
 ```ruby
-rsa_private = OpenSSL::PKey::RSA.generate 2048
+rsa_private = OpenSSL::PKey::RSA.generate(2048)
 rsa_public = rsa_private.public_key
 
-token = JWT.encode payload, rsa_private, 'RS256'
+token = JWT.encode(payload, rsa_private, 'RS256')
 
 # eyJhbGciOiJSUzI1NiJ9.eyJkYXRhIjoidGVzdCJ9.GplO4w1spRgvEJQ3-FOtZr-uC8L45Jt7SN0J4woBnEXG_OZBSNcZjAJWpjadVYEe2ev3oUBFDYM1N_-0BTVeFGGYvMewu8E6aMjSZvOpf1cZBew-Vt4poSq7goG2YRI_zNPt3af2lkPqXD796IKC5URrEvcgF5xFQ-6h07XRDpSRx1ECrNsUOt7UM3l1IB4doY11GzwQA5sHDTmUZ0-kBT76ZMf12Srg_N3hZwphxBtudYtN5VGZn420sVrQMdPE_7Ni3EiWT88j7WCr1xrF60l8sZT3yKCVleG7D2BEXacTntB7GktBv4Xo8OKnpwpqTpIlC05dMowMkz3rEAAYbQ
 puts token
 
-decoded_token = JWT.decode token, rsa_public, true, { algorithm: 'RS256' }
+decoded_token = JWT.decode(token, rsa_public, true, { algorithm: 'RS256' })
 
 # Array
 # [
@@ -136,12 +174,12 @@ puts decoded_token
 ```ruby
 ecdsa_key = OpenSSL::PKey::EC.generate('prime256v1')
 
-token = JWT.encode payload, ecdsa_key, 'ES256'
+token = JWT.encode(payload, ecdsa_key, 'ES256')
 
 # eyJhbGciOiJFUzI1NiJ9.eyJkYXRhIjoidGVzdCJ9.AlLW--kaF7EX1NMX9WJRuIW8NeRJbn2BLXHns7Q5TZr7Hy3lF6MOpMlp7GoxBFRLISQ6KrD0CJOrR8aogEsPeg
 puts token
 
-decoded_token = JWT.decode token, ecdsa_key, true, { algorithm: 'ES256' }
+decoded_token = JWT.decode(token, ecdsa_key, true, { algorithm: 'ES256' })
 
 # Array
 # [
@@ -196,12 +234,12 @@ gem 'openssl', '~> 2.1'
 rsa_private = OpenSSL::PKey::RSA.generate 2048
 rsa_public = rsa_private.public_key
 
-token = JWT.encode payload, rsa_private, 'PS256'
+token = JWT.encode(payload, rsa_private, 'PS256')
 
 # eyJhbGciOiJQUzI1NiJ9.eyJkYXRhIjoidGVzdCJ9.KEmqagMUHM-NcmXo6818ZazVTIAkn9qU9KQFT1c5Iq91n0KRpAI84jj4ZCdkysDlWokFs3Dmn4MhcXP03oJKLFgnoPL40_Wgg9iFr0jnIVvnMUp1kp2RFUbL0jqExGTRA3LdAhuvw6ZByGD1bkcWjDXygjQw-hxILrT1bENjdr0JhFd-cB0-ps5SB0mwhFNcUw-OM3Uu30B1-mlFaelUY8jHJYKwLTZPNxHzndt8RGXF8iZLp7dGb06HSCKMcVzhASGMH4ZdFystRe2hh31cwcvnl-Eo_D4cdwmpN3Abhk_8rkxawQJR3duh8HNKc4AyFPo7SabEaSu2gLnLfN3yfg
 puts token
 
-decoded_token = JWT.decode token, rsa_public, true, { algorithm: 'PS256' }
+decoded_token = JWT.decode(token, rsa_public, true, { algorithm: 'PS256' })
 
 # Array
 # [
@@ -211,22 +249,57 @@ decoded_token = JWT.decode token, rsa_public, true, { algorithm: 'PS256' }
 puts decoded_token
 ```
 
+### Add custom header fields
+Ruby-jwt gem supports custom [header fields](https://tools.ietf.org/html/rfc7519#section-5)
+To add custom header fields you need to pass `header_fields` parameter
+
+```ruby
+token = JWT.encode(payload, key, algorithm='HS256', header_fields={})
+```
+
+**Example:**
+
+```ruby
+
+payload = { data: 'test' }
+
+# IMPORTANT: set nil as password parameter
+token = JWT.encode(payload, nil, 'none', { typ: 'JWT' })
+
+# eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJkYXRhIjoidGVzdCJ9.
+puts token
+
+# Set password to nil and validation to false otherwise this won't work
+decoded_token = JWT.decode(token, nil, false)
+
+# Array
+# [
+#   {"data"=>"test"}, # payload
+#   {"typ"=>"JWT", "alg"=>"none"} # header
+# ]
+puts decoded_token
+```
+
 ### **Custom algorithms**
 
-An object implementing custom signing or verification behaviour can be passed in the `algorithm` option when encoding and decoding. The given object needs to implement the method `valid_alg?` and `verify` and/or `alg` and `sign`, depending if object is used for encoding or decoding.
+When encoding or decoding a token, you can pass in a custom object through the `algorithm` option to handle signing or verification. This custom object must include or extend the `JWT::JWA::SigningAlgorithm` module and implement certain methods:
+
+- For decoding/verifying: The object must implement the methods `alg` and `verify`.
+- For encoding/signing: The object must implement the methods `alg` and `sign`.
+
+For customization options check the details from `JWT::JWA::SigningAlgorithm`.
+
 
 ```ruby
 module CustomHS512Algorithm
+  extend JWT::JWA::SigningAlgorithm
+
   def self.alg
     'HS512'
   end
 
-  def self.valid_alg?(alg_to_validate)
-    alg_to_validate == alg
-  end
-
   def self.sign(data:, signing_key:)
-    OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), data, signing_key)
+    OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha512'), signing_key, data)
   end
 
   def self.verify(data:, signature:, verification_key:)
@@ -238,49 +311,63 @@ token = ::JWT.encode({'pay' => 'load'}, 'secret', CustomHS512Algorithm)
 payload, header = ::JWT.decode(token, 'secret', true, algorithm: CustomHS512Algorithm)
 ```
 
-## Support for reserved claim names
-JSON Web Token defines some reserved claim names and defines how they should be
-used. JWT supports these reserved claim names:
+## `JWT::Token` and `JWT::EncodedToken`
 
- - 'exp' (Expiration Time) Claim
- - 'nbf' (Not Before Time) Claim
- - 'iss' (Issuer) Claim
- - 'aud' (Audience) Claim
- - 'jti' (JWT ID) Claim
- - 'iat' (Issued At) Claim
- - 'sub' (Subject) Claim
+The `JWT::Token` and `JWT::EncodedToken` classes can be used to manage your JWTs.
 
-## Add custom header fields
-Ruby-jwt gem supports custom [header fields](https://tools.ietf.org/html/rfc7519#section-5)
-To add custom header fields you need to pass `header_fields` parameter
+```ruby
+token = JWT::Token.new(payload: { exp: Time.now.to_i + 60, jti: '1234', sub: "my-subject" }, header: { kid: 'hmac' })
+token.sign!(algorithm: 'HS256', key: "secret")
 
+token.jwt # => "eyJhbGciOiJIUzI1N..."
+```
+
+The `JWT::EncodedToken` can be used to create a token object that allows verification of signatures and claims
 ```ruby
-token = JWT.encode payload, key, algorithm='HS256', header_fields={}
+encoded_token = JWT::EncodedToken.new(token.jwt)
+
+encoded_token.verify_signature!(algorithm: 'HS256', key: "secret")
+encoded_token.verify_signature!(algorithm: 'HS256', key: "wrong_secret") # raises JWT::VerificationError
+encoded_token.verify_claims!(:exp, :jti)
+encoded_token.verify_claims!(sub: ["not-my-subject"]) # raises JWT::InvalidSubError
+encoded_token.claim_errors(sub: ["not-my-subject"]).map(&:message) # => ["Invalid subject. Expected [\"not-my-subject\"], received my-subject"]
+encoded_token.payload # => { 'exp'=>1234, 'jti'=>'1234", 'sub'=>'my-subject' }
+encoded_token.header # {'kid'=>'hmac', 'alg'=>'HS256'}
 ```
 
-**Example:**
+### Detached payload
+
+The `::JWT::Token#detach_payload!` method can be use to detach the payload from the JWT.
 
 ```ruby
-require 'jwt'
+token = JWT::Token.new(payload: { pay: 'load' })
+token.sign!(algorithm: 'HS256', key: "secret")
+token.detach_payload!
+token.jwt # => "eyJhbGciOiJIUzI1NiJ9..UEhDY1Qlj29ammxuVRA_-gBah4qTy5FngIWg0yEAlC0"
+token.encoded_payload # => "eyJwYXkiOiJsb2FkIn0"
+```
 
-payload = { data: 'test' }
+The `JWT::EncodedToken` class can be used to decode a token with a detached payload by providing the payload to the token instance in separate.
 
-# IMPORTANT: set nil as password parameter
-token = JWT.encode payload, nil, 'none', { typ: 'JWT' }
+```ruby
+encoded_token = JWT::EncodedToken.new(token.jwt)
+encoded_token.encoded_payload = "eyJwYXkiOiJsb2FkIn0"
+encoded_token.verify_signature!(algorithm: 'HS256', key: "secret")
+encoded_token.payload # => {"pay"=>"load"}
+```
 
-# eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJkYXRhIjoidGVzdCJ9.
-puts token
+## Claims
 
-# Set password to nil and validation to false otherwise this won't work
-decoded_token = JWT.decode token, nil, false
+JSON Web Token defines some reserved claim names and defines how they should be
+used. JWT supports these reserved claim names:
 
-# Array
-# [
-#   {"data"=>"test"}, # payload
-#   {"typ"=>"JWT", "alg"=>"none"} # header
-# ]
-puts decoded_token
-```
+ - 'exp' (Expiration Time) Claim
+ - 'nbf' (Not Before Time) Claim
+ - 'iss' (Issuer) Claim
+ - 'aud' (Audience) Claim
+ - 'jti' (JWT ID) Claim
+ - 'iat' (Issued At) Claim
+ - 'sub' (Subject) Claim
 
 ### Expiration Time Claim
 
@@ -294,10 +381,10 @@ From [Oauth JSON Web Token 4.1.4. "exp" (Expiration Time) Claim](https://tools.i
 exp = Time.now.to_i + 4 * 3600
 exp_payload = { data: 'data', exp: exp }
 
-token = JWT.encode exp_payload, hmac_secret, 'HS256'
+token = JWT.encode(exp_payload, hmac_secret, 'HS256')
 
 begin
-  decoded_token = JWT.decode token, hmac_secret, true, { algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { algorithm: 'HS256' })
 rescue JWT::ExpiredSignature
   # Handle expired token, e.g. logout user or deny access
 end
@@ -306,7 +393,7 @@ end
 The Expiration Claim verification can be disabled.
 ```ruby
 # Decode token without raising JWT::ExpiredSignature error
-JWT.decode token, hmac_secret, true, { verify_expiration: false, algorithm: 'HS256' }
+JWT.decode(token, hmac_secret, true, { verify_expiration: false, algorithm: 'HS256' })
 ```
 
 **Adding Leeway**
@@ -318,11 +405,11 @@ leeway = 30 # seconds
 exp_payload = { data: 'data', exp: exp }
 
 # build expired token
-token = JWT.encode exp_payload, hmac_secret, 'HS256'
+token = JWT.encode(exp_payload, hmac_secret, 'HS256')
 
 begin
   # add leeway to ensure the token is still accepted
-  decoded_token = JWT.decode token, hmac_secret, true, { exp_leeway: leeway, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { exp_leeway: leeway, algorithm: 'HS256' })
 rescue JWT::ExpiredSignature
   # Handle expired token, e.g. logout user or deny access
 end
@@ -340,10 +427,10 @@ From [Oauth JSON Web Token 4.1.5. "nbf" (Not Before) Claim](https://tools.ietf.o
 nbf = Time.now.to_i - 3600
 nbf_payload = { data: 'data', nbf: nbf }
 
-token = JWT.encode nbf_payload, hmac_secret, 'HS256'
+token = JWT.encode(nbf_payload, hmac_secret, 'HS256')
 
 begin
-  decoded_token = JWT.decode token, hmac_secret, true, { algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { algorithm: 'HS256' })
 rescue JWT::ImmatureSignature
   # Handle invalid token, e.g. logout user or deny access
 end
@@ -352,7 +439,7 @@ end
 The Not Before Claim verification can be disabled.
 ```ruby
 # Decode token without raising JWT::ImmatureSignature error
-JWT.decode token, hmac_secret, true, { verify_not_before: false, algorithm: 'HS256' }
+JWT.decode(token, hmac_secret, true, { verify_not_before: false, algorithm: 'HS256' })
 ```
 
 **Adding Leeway**
@@ -364,11 +451,11 @@ leeway = 30
 nbf_payload = { data: 'data', nbf: nbf }
 
 # build expired token
-token = JWT.encode nbf_payload, hmac_secret, 'HS256'
+token = JWT.encode(nbf_payload, hmac_secret, 'HS256')
 
 begin
   # add leeway to ensure the token is valid
-  decoded_token = JWT.decode token, hmac_secret, true, { nbf_leeway: leeway, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { nbf_leeway: leeway, algorithm: 'HS256' })
 rescue JWT::ImmatureSignature
   # Handle invalid token, e.g. logout user or deny access
 end
@@ -386,11 +473,11 @@ You can pass multiple allowed issuers as an Array, verification will pass if one
 iss = 'My Awesome Company Inc. or https://my.awesome.website/'
 iss_payload = { data: 'data', iss: iss }
 
-token = JWT.encode iss_payload, hmac_secret, 'HS256'
+token = JWT.encode(iss_payload, hmac_secret, 'HS256')
 
 begin
   # Add iss to the validation to check if the token has been manipulated
-  decoded_token = JWT.decode token, hmac_secret, true, { iss: iss, verify_iss: true, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { iss: iss, verify_iss: true, algorithm: 'HS256' })
 rescue JWT::InvalidIssuerError
   # Handle invalid token, e.g. logout user or deny access
 end
@@ -401,24 +488,24 @@ On supported ruby versions (>= 2.5) you can also delegate to methods, on older v
 to convert them to proc (using `to_proc`)
 
 ```ruby
-JWT.decode token, hmac_secret, true,
+JWT.decode(token, hmac_secret, true,
            iss: %r'https://my.awesome.website/',
            verify_iss: true,
-           algorithm: 'HS256'
+           algorithm: 'HS256')
 ```
 
 ```ruby
-JWT.decode token, hmac_secret, true,
+JWT.decode(token, hmac_secret, true,
            iss: ->(issuer) { issuer.start_with?('My Awesome Company Inc') },
            verify_iss: true,
-           algorithm: 'HS256'
+           algorithm: 'HS256')
 ```
 
 ```ruby
-JWT.decode token, hmac_secret, true,
+JWT.decode(token, hmac_secret, true,
            iss: method(:valid_issuer?),
            verify_iss: true,
-           algorithm: 'HS256'
+           algorithm: 'HS256')
 
 # somewhere in the same class:
 def valid_issuer?(issuer)
@@ -436,11 +523,11 @@ From [Oauth JSON Web Token 4.1.3. "aud" (Audience) Claim](https://tools.ietf.org
 aud = ['Young', 'Old']
 aud_payload = { data: 'data', aud: aud }
 
-token = JWT.encode aud_payload, hmac_secret, 'HS256'
+token = JWT.encode(aud_payload, hmac_secret, 'HS256')
 
 begin
   # Add aud to the validation to check if the token has been manipulated
-  decoded_token = JWT.decode token, hmac_secret, true, { aud: aud, verify_aud: true, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { aud: aud, verify_aud: true, algorithm: 'HS256' })
 rescue JWT::InvalidAudError
   # Handle invalid token, e.g. logout user or deny access
   puts 'Audience Error'
@@ -459,15 +546,15 @@ jti_raw = [hmac_secret, iat].join(':').to_s
 jti = Digest::MD5.hexdigest(jti_raw)
 jti_payload = { data: 'data', iat: iat, jti: jti }
 
-token = JWT.encode jti_payload, hmac_secret, 'HS256'
+token = JWT.encode(jti_payload, hmac_secret, 'HS256')
 
 begin
   # If :verify_jti is true, validation will pass if a JTI is present
-  #decoded_token = JWT.decode token, hmac_secret, true, { verify_jti: true, algorithm: 'HS256' }
+  #decoded_token = JWT.decode(token, hmac_secret, true, { verify_jti: true, algorithm: 'HS256' })
   # Alternatively, pass a proc with your own code to check if the JTI has already been used
-  decoded_token = JWT.decode token, hmac_secret, true, { verify_jti: proc { |jti| my_validation_method(jti) }, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { verify_jti: proc { |jti| my_validation_method(jti) }, algorithm: 'HS256' })
   # or
-  decoded_token = JWT.decode token, hmac_secret, true, { verify_jti: proc { |jti, payload| my_validation_method(jti, payload) }, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { verify_jti: proc { |jti, payload| my_validation_method(jti, payload) }, algorithm: 'HS256' })
 rescue JWT::InvalidJtiError
   # Handle invalid token, e.g. logout user or deny access
   puts 'Error'
@@ -486,11 +573,11 @@ From [Oauth JSON Web Token 4.1.6. "iat" (Issued At) Claim](https://tools.ietf.or
 iat = Time.now.to_i
 iat_payload = { data: 'data', iat: iat }
 
-token = JWT.encode iat_payload, hmac_secret, 'HS256'
+token = JWT.encode(iat_payload, hmac_secret, 'HS256')
 
 begin
   # Add iat to the validation to check if the token has been manipulated
-  decoded_token = JWT.decode token, hmac_secret, true, { verify_iat: true, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { verify_iat: true, algorithm: 'HS256' })
 rescue JWT::InvalidIatError
   # Handle invalid token, e.g. logout user or deny access
 end
@@ -506,16 +593,32 @@ From [Oauth JSON Web Token 4.1.2. "sub" (Subject) Claim](https://tools.ietf.org/
 sub = 'Subject'
 sub_payload = { data: 'data', sub: sub }
 
-token = JWT.encode sub_payload, hmac_secret, 'HS256'
+token = JWT.encode(sub_payload, hmac_secret, 'HS256')
 
 begin
   # Add sub to the validation to check if the token has been manipulated
-  decoded_token = JWT.decode token, hmac_secret, true, { sub: sub, verify_sub: true, algorithm: 'HS256' }
+  decoded_token = JWT.decode(token, hmac_secret, true, { sub: sub, verify_sub: true, algorithm: 'HS256' })
 rescue JWT::InvalidSubError
   # Handle invalid token, e.g. logout user or deny access
 end
 ```
 
+### Standalone claim verification
+
+The JWT claim verifications can be used to verify any Hash to include expected keys and values.
+
+A few example on verifying the claims for a payload:
+```ruby
+JWT::Claims.verify_payload!({"exp" => Time.now.to_i + 10}, :numeric, :exp)
+JWT::Claims.valid_payload?({"exp" => Time.now.to_i + 10}, :exp)
+# => true
+JWT::Claims.payload_errors({"exp" => Time.now.to_i - 10}, :exp)
+# => [#<struct JWT::Claims::Error message="Signature has expired">]
+JWT::Claims.verify_payload!({"exp" => Time.now.to_i - 10}, exp: { leeway: 11})
+
+JWT::Claims.verify_payload!({"exp" => Time.now.to_i + 10, "sub" => "subject"}, :exp, sub: "subject")
+```
+
 ### Finding a Key
 
 To dynamically find the key for verifying the JWT signature, pass a block to the decode block. The block receives headers and the original payload as parameters. It should return with the key to verify the signature that was used to sign the JWT.
@@ -526,7 +629,7 @@ iss_payload = { data: 'data', iss: issuers.first }
 
 secrets = { issuers.first => hmac_secret, issuers.last => 'hmac_secret2' }
 
-token = JWT.encode iss_payload, hmac_secret, 'HS256'
+token = JWT.encode(iss_payload, hmac_secret, 'HS256')
 
 begin
   # Add iss to the validation to check if the token has been manipulated
@@ -543,7 +646,7 @@ end
 You can specify claims that must be present for decoding to be successful. JWT::MissingRequiredClaim will be raised if any are missing
 ```ruby
 # Will raise a JWT::MissingRequiredClaim error if the 'exp' claim is absent
-JWT.decode token, hmac_secret, true, { required_claims: ['exp'], algorithm: 'HS256' }
+JWT.decode(token, hmac_secret, true, { required_claims: ['exp'], algorithm: 'HS256' })
 ```
 
 ### X.509 certificates in x5c header
@@ -561,13 +664,13 @@ crls = crl_uris.map do |uri|
 end
 
 begin
-  JWT.decode(token, nil, true, { x5c: { root_certificates: root_certificates, crls: crls })
+  JWT.decode(token, nil, true, { x5c: { root_certificates: root_certificates, crls: crls } })
 rescue JWT::DecodeError
   # Handle error, e.g. x5c header certificate revoked or expired
 end
 ```
 
-### JSON Web Key (JWK)
+## JSON Web Key (JWK)
 
 JWK is a JSON structure representing a cryptographic key. This gem currently supports RSA, EC, OKP and HMAC keys. OKP support requires [RbNaCl](https://github.com/RubyCrypto/rbnacl) and currently only supports the Ed25519 curve.
 
@@ -594,7 +697,6 @@ algorithms = jwks.map { |key| key[:alg] }.compact.uniq
 JWT.decode(token, nil, true, algorithms: algorithms, jwks: jwks)
 ```
 
-
 The `jwks` option can also be given as a lambda that evaluates every time a kid is resolved.
 This can be used to implement caching of remotely fetched JWK Sets.
 
@@ -680,21 +782,25 @@ jwk_hash = jwk.export
 thumbprint_as_the_kid = jwk_hash[:kid]
 ```
 
-# Development and Tests
+# Development and testing
 
-We depend on [Bundler](http://rubygems.org/gems/bundler) for defining gemspec and performing releases to rubygems.org, which can be done with
+The tests are written with rspec. [Appraisal](https://github.com/thoughtbot/appraisal) is used to ensure compatibility with 3rd party dependencies providing cryptographic features.
 
 ```bash
-rake release
+bundle install
+bundle exec appraisal rake test
 ```
 
-The tests are written with rspec. [Appraisal](https://github.com/thoughtbot/appraisal) is used to ensure compatibility with 3rd party dependencies providing cryptographic features.
+# Releasing
+
+To cut a new release adjust the [version.rb](lib/jwt/version.rb) and [CHANGELOG](CHANGELOG.md) with desired version numbers and dates and commit the changes. Tag the release with the version number using the following command:
 
 ```bash
-bundle install
-bundle exec appraisal rake test
+rake release:source_control_push
 ```
 
+This will tag a new version an trigger a [GitHub action](.github/workflows/push_gem.yml) that eventually will push the gem to rubygems.org.
+
 ## How to contribute
 See [CONTRIBUTING](CONTRIBUTING.md).
 

data/lib/jwt/base64.rb

@@ -3,14 +3,31 @@
 require 'base64'
 
 module JWT
-  # Base64 helpers
+  # Base64 encoding and decoding
+  # @api private
   class Base64
     class << self
+      # Encode a string with URL-safe Base64 complying with RFC 4648 (not padded).
+      # @api private
       def url_encode(str)
-        ::Base64.encode64(str).tr('+/', '-_').gsub(/[\n=]/, '')
+        ::Base64.urlsafe_encode64(str, padding: false)
       end
 
+      # Decode a string with URL-safe Base64 complying with RFC 4648.
+      # Deprecated support for RFC 2045 remains for now. ("All line breaks or other characters not found in Table 1 must be ignored by decoding software")
+      # @api private
       def url_decode(str)
+        ::Base64.urlsafe_decode64(str)
+      rescue ArgumentError => e
+        raise unless e.message == 'invalid base64'
+        raise Base64DecodeError, 'Invalid base64 encoding' if JWT.configuration.strict_base64_decoding
+
+        loose_urlsafe_decode64(str).tap do
+          Deprecations.warning('Invalid base64 input detected, could be because of invalid padding, trailing whitespaces or newline chars. Graceful handling of invalid input will be dropped in the next major version of ruby-jwt', only_if_valid: true)
+        end
+      end
+
+      def loose_urlsafe_decode64(str)
         str += '=' * (4 - str.length.modulo(4))
         ::Base64.decode64(str.tr('-_', '+/'))
       end