GUIDE · MCP 11 min ·

The MCP advisories upgrades and scanners missOctober's 31 official advisories, sorted by action

A clean audit tells you little about MCP right now. On November 6, npm audit and pip-audit missed advisories I could read on GitHub, and a fully patched TypeScript server with an empty audit still accepted a token issued for another service. Read the repository advisories, then change the code they ask you to change.

TL;DR· the answer, in twenty seconds

What happened: The MCP organization published 31 advisories in October. On November 6, 23 of them, including two Inspector bugs rated 9.6, were absent from GitHub's advisory database, and npm audit and pip-audit did not report the ones I tested.

The minimum fix: List the repository advisories yourself, update Inspector and the reference servers by hand, then set the options the SDK fixes leave off: issuer, token audience and tool input limit.

The lesson: A scanner compares version ranges from a database. It says nothing about advisories the database lacks or settings your code never turned on.

The Model Context Protocol organization published 31 security advisories in October 2026, and when I checked on November 6, 23 of them were absent from the GitHub Advisory Database, including two MCP Inspector bugs rated 9.6.

I pulled every published advisory through the GitHub API from the organization's 44 non-archived repositories, 88 in all. October's 31 run from October 2 to October 28: 2 critical, 10 high, 14 medium and 5 low. I then ran scanners against affected versions and ran the new settings on the patched packages. I did not run any exploit, and I found no public report of these bugs being exploited in the wild. X1Y1's write-up found no such statement in the Python SDK advisories.

This batch fails you in two ways. Scanners cannot report an advisory that has not reached their database. Patched SDKs leave some of their fixes switched off, so a scanner reports the package clean while your server still has the bug.

What the scanners saw on November 6

This table counts October advisories whose GHSA ID resolved in the GitHub Advisory Database:

Repository October advisories In the database
inspector 9 0
servers 9 0
typescript-sdk 6 6
java-sdk 3 0
python-sdk 2 2
rust-sdk 2 0
Total 31 8

A missing ID could mean GitHub filed the same bug under a different ID, so I also queried by package and version:

Check Versions Result
npm audit Inspector 1.0.2, server-everything 2026.8.31, server-filesystem 2026.8.31 8 findings, all traced to zod, glob and minimatch. No October MCP advisory.
pip-audit mcp-server-fetch 2026.10.19, mcp-server-git 2026.1.14 0 findings
pip-audit mcp 2.1.1 4 findings. CVE-2026-115563 is not among them.
OSV query Inspector 1.0.2 and 2.11.0, mcp-core 2.0.0, rmcp 3.5.0 0 findings

A team that sees "high" next to Inspector, bumps zod and clears the report has not touched the OAuth callback bug, which lets a malicious server make Inspector spawn a process of the server's choosing after you connect and its OAuth flow redirects back.

The pip-audit miss is the one I would act on today. CVE-2026-115563 is the Python SDK's OAuth issuer bug, rated high and published September 28. An untrusted MCP server can collect your client_secret, authorization code, PKCE verifier or signed assertion by naming an authorization server it controls. Servers built with the SDK and stdio clients are out of scope. On November 6 its ID returned 404 from both GitHub's database API and OSV, 39 days after publication.

Some of the rest is lag, and the table above will age. Repository publication and database entry were 5 days apart for the TypeScript memory bug and 25 for the Python redirect bug. A Rust advisory, GHSA-c9xm-49cp-xcr9, took 95. The missing Inspector advisories were 16 days old when I checked, so they may appear next week. X1Y1 measured a longer gap on the Python side: fixes released September 7, database entry October 27.

I can't tell you why these 23 are absent. None of them has a CVE ID, while 7 of the 8 listed ones do, but the unlisted Python issuer bug has one, so a CVE alone does not get an advisory listed. GitHub's documentation says Dependabot alerts fire on GitHub-reviewed advisories. I did not run Dependabot, but on that description it would stay quiet about all 23 until they land.

Third-party servers add more. TestedMCP's October tracker counted 40 advisories across 12 listed servers when it last checked on November 2, with the reference servers among them.

List the advisories yourself

The repository advisory API needs no special access. This loop prints everything the seven repositories I care about published since a given date:

since=2026-10-01
for r in inspector servers typescript-sdk python-sdk java-sdk rust-sdk csharp-sdk; do
  gh api "repos/modelcontextprotocol/$r/security-advisories?per_page=100" --paginate \
    --jq ".[] | select(.published_at >= \"$since\")
         | [.published_at[:10], .severity, .ghsa_id, .summary[:60]] | @tsv"
done | sort

I ran it on November 6. Five more advisories had already appeared in November, including a C# session hijack rated high. Put the loop in a weekly job, or watch those repositories for security alerts. Add PrefectHQ/fastmcp if you use FastMCP, because it publishes outside this organization.

Read them in full. The SDK advisories have an "Am I affected?" section that rules out most stdio-only setups in a sentence, which will save you more time than any severity score.

Six fixes that need your code

Four October advisories and two from late September ship the fix turned off or break the old pattern. Each one says so in its fix section. Karl Mehta's post on X made the same point about the OAuth bugs and names TrustModel's trust scoring as a separate need. The advisory text is the better source.

Advisory Applies when Change after upgrading
Python OAuth issuer HTTP client with an OAuth provider, connecting to servers you do not fully trust Pass issuer; clear stored client info saved without one
TypeScript OAuth issuer Same, with a stored refresh token or bundled provider Pass expectedIssuer; add issuer to saved credentials or clear them
TypeScript bearer audience Your authorization server issues tokens for other services too Set expectedResource and return resource from the verifier
Python bearer audience Same Set validate_token_resource=True and return resource
TypeScript tool input memory Untrusted clients can reach your HTTP server Set maxToolInputElements and lower maxRequestBodySize
TypeScript shared transport @modelcontextprotocol/server 2.x sharing one server or transport across clients One server and transport per request or session

Bearer audience: a clean audit and the bug intact

I installed @modelcontextprotocol/sdk 1.32.2, the current 1.x release, and npm audit returned zero findings. Then I called requireBearerAuth with a verifier that returned a token issued for other.example.com:

Configuration Token Result
Default Other service 200
expectedResource set, verifier omits resource Any 401
expectedResource set Other service 401
expectedResource set This server 200

The first row is the advisory's bug, on the patched version. The second row is what breaks if you make half the change, and the advisory warns about it. Both edits go in together:

const auth = requireBearerAuth({
  verifier: {
    async verifyAccessToken(token) {
      const claims = await checkSignatureAndExpiry(token); // your code
      return {
        token,
        clientId: claims.client_id,
        scopes: claims.scope.split(" "),
        expiresAt: claims.exp,
        resource: new URL(claims.aud),
      };
    },
  },
  expectedResource: new URL("https://mcp.example.com/mcp"),
});

The Python equivalent behaved the same way when I ran BearerAuthBackend from mcp 2.3.0 through those four cases:

auth = AuthSettings(
    issuer_url="https://auth.example.com",
    resource_server_url="https://mcp.example.com/mcp",
    validate_token_resource=True,
)

# In your TokenVerifier.verify_token():
return AccessToken(
    token=token,
    client_id=claims["client_id"],
    scopes=claims["scope"].split(),
    resource=claims["aud"],  # must carry this server's URL
)

If aud can be a list in your tokens, pick the matching entry first, since resource holds one string. Both advisories offer a workaround on any version: reject tokens whose aud excludes your server inside your verifier. If your verifier already does that, you were never exposed to this bug. In Python, set validate_token_resource=False to silence the warning.

OAuth issuer: name the server that gets your secret

The Python fix arrived in mcp 1.30.0 and 2.2.0, the TypeScript one in sdk 1.31.0 and client 2.2.0. Without the new argument, the secret still goes wherever the MCP server points:

provider = ClientCredentialsOAuthProvider(
    server_url="https://mcp.example.com",
    storage=storage,
    client_id=client_id,
    client_secret=client_secret,
    issuer="https://auth.example.com",
)
const provider = new ClientCredentialsProvider({
  clientId,
  clientSecret,
  expectedIssuer: "https://auth.example.com",
});

I built the Python provider on mcp 2.3.0 with and without issuer. Both succeed, and the second prints an MCPDeprecationWarning. That class derives from UserWarning in 2.3.0, so it shows up in default output. The advisory says the 1.30.0 warning is a DeprecationWarning, which Python hides by default outside __main__, so 1.x users may never see it. Python requires issuer from 3.0. I confirmed the TypeScript option in the published type definitions and did not run either provider against a hostile server.

Three gaps remain after the upgrade. Registrations stored without an issuer stay unbound after the upgrade, so clear stored client information once or stamp the issuer on it. Python's RFC7523OAuthClientProvider has no issuer option and you have to migrate off it. The TypeScript advisory lists gaps its fix does not cover, including new interactive sign-ins, which still go to the authorization server the MCP server names. FastMCP users have the same bug: version 4.1.2 adds issuer, and its advisory calls upgrading alone insufficient.

Memory and transport: one option, one refactor

maxToolInputElements is off by default, which I confirmed on sdk 1.32.2 by calling a tool with 5,000 array elements through an in-memory transport:

new McpServer(info);                                  // accepted, 5000
new McpServer(info, { maxToolInputElements: 1_000 }); // isError: more than the maximum of 1000 elements

The advisory wants both limits. The element count covers tool arguments, and maxRequestBodySize covers everything else, down to whatever your tools need. If you parse bodies yourself with express.json() or Fastify, set the limit on that parser too.

The shared transport fix makes old code fail. The bug delivered one client's responses to another, because the SDK matched messages by JSON-RPC id and SDK clients all count from 0. The old README examples for Hono, Express, Fastify and Node showed the bad pattern. From 2.3.0, a second connect() rejects with ALREADY_CONNECTED, and a stateless transport rejects its second request, so any test that makes two requests will catch it. Pass a factory to createMcpHandler(), or build a new server and transport per request or per session.

Versions your updater will not move

The reference servers changed version scheme, and it strands anyone on the old one. server-everything and server-filesystem went from date versions to semantic versions, and semver ranks 2.0.1 below 2026.8.31. The server-everything advisory says package managers will not offer the fix and Dependabot will not open a pull request.

I checked with npm outdated on a project holding ^2026.8.31. The "wanted" column stays at 2026.8.31. npm does print a deprecation notice on install, so the signal exists if you read install logs. The server-everything advisory lists no patched version on the date-version line. Name the semantic line when you install:

npm install @modelcontextprotocol/server-everything@latest
npm install @modelcontextprotocol/server-filesystem@latest

That was 2.2.1 and 2.2.0 on November 6. The server-everything bug is the one to take personally if you keep keys in your shell. Affected versions from 2025.9.24 listened on 0.0.0.0 in HTTP mode with cors origin *, and the get-env tool returned process.env, so any page open in your browser could read it.

Inspector splits the same way. latest is 2.14.0, the v1-latest tag is 1.0.4, and npm's deprecation message says v1 receives security fixes only. Pinned 1.x installs need 1.0.4. Pinned 2.x installs need 2.14.0, which also picks up three advisories published this week.

Inspector deserves more attention than its dev-tool label suggests. GHSA-q978-78c7-phqw, rated 8.8, runs code on Windows and WSL through a server-chosen authorization_endpoint. Its authors write: "The model plays no part, no tool is invoked, nothing is approved, and no local configuration is under attacker control." Prompt-injection filters and tool approval prompts have nothing to inspect in that path.

What to rotate

An upgrade does nothing for credentials that already left. Rotate when an advisory's condition matches your history:

Advisory Condition Action
Python and TypeScript OAuth issuer The client connected to an untrusted server while holding credentials Rotate the client secret or signing key, revoke its tokens
Python and TypeScript redirects A redirect may have reached a host you do not control Rotate the credentials the client carried, revoke tokens
Inspector GHSA-8qgq-27v6-55w3 SSE proxy logs held Authorization or custom auth headers Rotate those credentials, purge the logs
Inspector GHSA-vcc9-3xgm-p9v4 A 2.x proxy ran while you browsed untrusted pages Reissue what the proxy stored
server-everything GHSA-mvf5-2qqv-rg3c HTTP mode ran with secrets in its environment Rotate what that environment held

The first two rows come from the advisories. The last three are my reading of the impact sections, since those advisories do not spell out a rotation step. On the redirect fix, cross-origin redirects now fail, so a client that reached its server through one needs its endpoint changed to the final URL. TypeScript's redirectPolicy: 'follow' restores the old behavior along with the exposure.

You may not be able to answer "did this client ever connect to an untrusted server?" from your logs. If you can't, decide based on what the credential can reach and how cheap rotation is.

What this means for your stack

Run the advisory loop above today and compare it to your lockfile. Update Inspector and the reference servers by hand, then grep your code for requireBearerAuth, AuthSettings, ClientCredentials and new McpServer and add the settings the fixes left off. Set issuer first, because that is the one where a server you connect to can walk off with a secret.

The pattern that outlasts this batch is explicit binding. A credential should name the one issuer it belongs to, and a token the one audience it was minted for. Defaults that follow whatever a remote server advertises keep producing this bug class. The Python advisories say as much: in 3.0, issuer becomes required and validate_token_resource defaults to True.

Secrets need the same treatment: a process should get only what its job needs. hasp is one working implementation of that part, and it does not fix issuer binding or token audience. hasp run --project-root . --env MCP_CLIENT_SECRET=@MCP_CLIENT_SECRET --grant-secret window --grant-window 15m -- python client.py hands the secret to that client run and keeps it out of your shell, so a get-env style leak in another process has less to return. The client itself still holds the secret and can still send it to the wrong server until you set issuer. Source-available (FCL-1.0), local-first, macOS and Linux, no account.

Whatever you run, treat a clean audit as one input with a date on it. It tells you what a database knew about your version ranges that morning, and the bearer test above returned 200 with an audit reporting zero.

Sources· cited above, in one place

NEXT STEP~90 seconds

Stop handing the agent your real keys.

hasp keeps secrets in one local encrypted vault, brokers them into the child process at exec, and never lets the agent read the value.

  • Local, encrypted vault — no account, no cloud, no telemetry by default.
  • Brokered run — agent gets a reference, the child process gets the value.
  • Pre-commit + pre-push hooks catch managed values before they ship.
  • Append-only HMAC audit log answers "did the agent touch the prod token?" in seconds.
→ okvault unlocked · binding ./api
→ okgrant once · pid 88421
→ okagent never read

macOS & Linux. Source-available (FCL-1.0, converts to Apache 2.0). No account.

Browse all clusters· eight threads, one index