fix: require jwt 3.3.0 for JWTVerifier

Author: atesgoral

Gemfile

@@ -27,7 +27,7 @@ gem "yard-sorbet", "~> 0.9" if RUBY_VERSION >= "3.1"
 group :test do
   gem "event_stream_parser", ">= 1.0"
   gem "faraday", ">= 2.0"
-  gem "jwt"
+  gem "jwt", ">= 3.3.0"
   gem "minitest", "~> 5.1", require: false
   gem "mocha"
   gem "webmock"

docs/installation.md

@@ -37,12 +37,12 @@ $ gem install mcp
 
 You may need to add additional dependencies depending on which features you wish to access.
 
-Verifying JWT access tokens on the server with `MCP::Server::OAuth::JWTVerifier` requires the `jwt` gem (and `jwt-eddsa` as well for EdDSA-signed tokens),
+Verifying JWT access tokens on the server with `MCP::Server::OAuth::JWTVerifier` requires version 3.3.0 or later of the `jwt` gem (and `jwt-eddsa` as well for EdDSA-signed tokens),
 which the verifier loads only when it is instantiated; `MCP::Server::OAuth::IntrospectionVerifier` needs nothing beyond the standard library.
 See [Authorization](/server/authorization/).
 
 ```ruby
-gem "jwt"
+gem "jwt", ">= 3.3.0"
 ```
 
 The HTTP client transport requires the `faraday` gem:

lib/mcp/server/oauth/jwt_verifier.rb

@@ -8,9 +8,10 @@
 
 # This file is autoloaded only when `JWTVerifier` is referenced, so the `jwt` dependency does not affect users of other verifiers.
 begin
+  gem "jwt", ">= 3.3.0"
   require "jwt"
 rescue LoadError
-  raise LoadError, "The 'jwt' gem is required to use MCP::Server::OAuth::JWTVerifier. Add it to your Gemfile: gem 'jwt'"
+  raise LoadError, "The 'jwt' gem (>= 3.3.0) is required to use MCP::Server::OAuth::JWTVerifier. Add it to your Gemfile: gem 'jwt', '>= 3.3.0'"
 end
 
 module MCP

test/mcp/server/oauth/jwt_verifier_loading_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "open3"
+
+module MCP
+  class Server
+    module OAuth
+      class JWTVerifierLoadingTest < Minitest::Test
+        def test_rejects_an_older_jwt_already_loaded
+          ["2.10.2", "3.2.0"].each do |version|
+            script = <<~RUBY
+              require "mcp"
+              require "jwt"
+              loaded = Gem.loaded_specs.fetch("jwt").dup
+              loaded.version = Gem::Version.new(#{version.inspect})
+              Gem.loaded_specs["jwt"] = loaded
+              MCP::Server::OAuth::JWTVerifier
+            RUBY
+            _stdout, stderr, status = run_ruby(script)
+
+            refute_predicate(status, :success?, version)
+            assert_includes(stderr, "LoadError")
+            assert_includes(stderr, "gem 'jwt', '>= 3.3.0'")
+          end
+        end
+
+        def test_loads_with_a_supported_jwt
+          _stdout, stderr, status = run_ruby('require "mcp"; MCP::Server::OAuth::JWTVerifier')
+
+          assert_predicate(status, :success?, stderr)
+        end
+
+        def test_other_verifiers_do_not_load_jwt
+          script = <<~RUBY
+            require "mcp"
+            MCP::Server::OAuth::IntrospectionVerifier
+            abort "jwt was loaded" if Gem.loaded_specs.key?("jwt")
+          RUBY
+          _stdout, stderr, status = run_ruby(script)
+
+          assert_predicate(status, :success?, stderr)
+        end
+
+        private
+
+        def run_ruby(script)
+          lib = File.expand_path("../../../../lib", __dir__)
+          # Keep bundled gems available without either Bundler startup hook.
+          env = { "RUBYOPT" => nil, "BUNDLER_SETUP" => nil, "GEM_PATH" => Gem.path.join(File::PATH_SEPARATOR) }
+          Open3.capture3(env, RbConfig.ruby, "-I", lib, "-e", script)
+        end
+      end
+    end
+  end
+end

test/mcp/server/oauth/jwt_verifier_middleware_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "jwt"
+require "openssl"
+require "base64"
+require "webmock/minitest"
+
+module MCP
+  class Server
+    module OAuth
+      class JWTVerifierMiddlewareTest < Minitest::Test
+        ISSUER = "https://as.example.com"
+        AUDIENCE = "https://mcp.example.com/mcp"
+        JWKS_URI = "https://as.example.com/.well-known/jwks.json"
+        METADATA = ProtectedResourceMetadata.new(resource: AUDIENCE, authorization_servers: [ISSUER])
+
+        def setup
+          @key = OpenSSL::PKey::EC.generate("prime256v1")
+          @public_key = OpenSSL::PKey.read(@key.public_to_pem)
+          @jwks = { keys: [JWT::JWK.new(@public_key, { kid: "ec-key", use: "sig", alg: "ES256" }).export] }
+          @claims = { "iss" => ISSUER, "aud" => AUDIENCE, "exp" => Time.now.to_i + 300 }
+        end
+
+        def test_ps256_token_with_an_ec_key_returns_401
+          assert_ps256_rejected(key: @public_key)
+        end
+
+        def test_ps256_token_with_a_static_ec_jwks_returns_401
+          assert_ps256_rejected(jwks: @jwks)
+        end
+
+        def test_ps256_token_with_a_fetched_ec_jwks_returns_401
+          stub_request(:get, JWKS_URI).to_return(body: JSON.generate(@jwks), headers: { "content-type" => "application/json" })
+
+          assert_ps256_rejected(jwks_uri: JWKS_URI)
+          assert_requested(:get, JWKS_URI, times: 1)
+        end
+
+        private
+
+        def assert_ps256_rejected(**key_source)
+          verifier = JWTVerifier.new(resource_metadata: METADATA, **key_source)
+          app = mock
+          app.expects(:call).once.returns([200, {}, ["authenticated"]])
+          middleware = Middleware.new(app, token_verifier: verifier, resource_metadata: METADATA)
+          reports = []
+          MCP.configuration.stubs(:exception_reporter).returns(->(error, _context) { reports << error })
+          valid_token = JWT.encode(@claims, @key, "ES256", { kid: "ec-key" })
+
+          status, = middleware.call({ "HTTP_AUTHORIZATION" => "Bearer #{valid_token}" })
+
+          assert_equal(200, status)
+
+          header = Base64.urlsafe_encode64(JSON.generate(alg: "PS256", kid: "ec-key"), padding: false)
+          payload = Base64.urlsafe_encode64(JSON.generate(@claims), padding: false)
+          token = "#{header}.#{payload}.AAAA"
+
+          status, headers, body = middleware.call({ "HTTP_AUTHORIZATION" => "Bearer #{token}" })
+
+          assert_equal(401, status)
+          assert_includes(headers.fetch("www-authenticate"), 'error="invalid_token"')
+          assert_equal("invalid_token", JSON.parse(body.join).fetch("error"))
+          assert_empty(reports)
+        end
+      end
+    end
+  end
+end