/

CVE-2026-27826

Severity:

HIGH RISK

(8.2)

SSRF in MCP Atlassian HTTP Middleware

CVE-2026-27826

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized outbound requests and potential credential theft via SSRF

Severity:

HIGH RISK

(8.2)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

MCP Atlassian's HTTP middleware contains a server-side request forgery (SSRF) flaw that allows an unauthenticated attacker to coerce the server into making outbound HTTP requests to arbitrary URLs.

If an attacker can reach the mcp-atlassian HTTP endpoint, they can abuse custom headers to pivot the server into calling internal or external services, potentially exposing cloud metadata credentials, internal services, or polluting LLM tool outputs.

Affected context

This vulnerability affects deployments of MCP Atlassian (for Confluence and Jira) where:

  • The mcp-atlassian HTTP endpoint is reachable over a network (internet, VPN, or internal LAN), and
  • The process is permitted to make outbound HTTP requests (e.g., to Atlassian APIs, cloud services, or internal microservices).

The bug resides in the HTTP middleware and dependency injection layer, so it appears even when individual MCP tools look secure in isolation.

Exploit preconditions

  • Attack surface: The mcp-atlassian HTTP endpoint (typically exposed as an HTTP/HTTPS service).
  • Required access: Network-level reachability to the endpoint; no valid credentials or Authorization header are needed.
  • Trigger point: Supplying two specific custom HTTP headers in a request that omits the Authorization header, causing the server to initiate outbound HTTP requests.
  • Why exploitation is possible: The middleware layer trusts header-controlled parameters to construct outbound HTTP requests without authenticating the caller or validating/limiting the target URL, enabling classic SSRF behavior.

Why this happens

The underlying defect is an SSRF design flaw in the HTTP middleware/dependency injection pipeline.

Middleware logic accepts attacker-controlled header values and uses them to drive outbound HTTP requests, without enforcing authentication, whitelisting, or network boundary checks.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server that can reach internal or privileged network resources is tricked into issuing HTTP calls on behalf of an unauthenticated client.

Because the issue lives outside individual tool handlers, typical tool-level code review or scanning may miss it, as the unsafe pattern is in shared plumbing rather than application logic.

Potential impact

  • Theft of cloud instance metadata or IAM role credentials via calls to 169.254.169.254 or similar metadata endpoints.
  • Internal network reconnaissance (probing internal hosts, ports, and HTTP services that are not directly exposed).
  • Access to internal-only APIs, dashboards, or management endpoints reachable from the MCP server.
  • Injection of attacker-controlled content into LLM tool results, potentially influencing downstream decisions or leaking sensitive data.
  • Use of the MCP server as a stepping stone for further attacks within the hosting environment.

General mitigation guidance

Effective mitigation focuses on narrowing trust boundaries around outbound requests and eliminating header-driven request targets.

Recommended patterns include:

  • Enforce authentication early: Ensure that any middleware capable of issuing outbound requests verifies the caller's identity before processing request-driven configuration.
  • Constrain outbound destinations: Implement strict allowlists for URLs, hostnames, and IP ranges that outbound HTTP clients may contact; reject or normalize user-controlled URLs.
  • Block access to sensitive network zones: Deny requests to link-local metadata addresses (e.g., 169.254.169.254), RFC1918 private ranges, and other internal segments from generic HTTP clients.
  • Separate configuration from user input: Treat headers and other request parameters as untrusted; do not feed them directly into HTTP client configuration or dependency injection without validation.
  • Apply least privilege at the infrastructure level: Limit the server's network egress with firewall rules, security groups, or service meshes, and avoid granting broad cloud instance roles when not required.
  • Defense-in-depth validation: Introduce centralized URL/host validation utilities used by all outbound HTTP call sites to reduce the chance of reintroducing similar flaws.

How teams detect issues like this

Organizations can identify and monitor this class of issue using a combination of static and runtime techniques:

  • Static analysis patterns:
  • Scan middleware and dependency injection code for HTTP client initialization that derives URLs or hosts from headers, query parameters, or other request-controlled input.
  • Flag usages of generic HTTP clients where the target URL is not constrained by configuration or allowlists.
  • Search for code paths where authentication checks happen after outbound request construction.
  • Code review signals:
  • Outbound calls in framework middleware, decorators, or DI factories that run for unauthenticated requests.
  • Logic that reads custom headers or query parameters and passes them to HTTP client builders without validation.
  • Shared HTTP helpers that lack clear URL validation or network boundary enforcement.
  • Policy and automated tooling:
  • Apply linters or SAST tools with SSRF-focused rulesets to CI pipelines, tuned to your HTTP client libraries and framework.
  • Instrument application logging to capture outbound request targets and correlate them with incoming requests, alerting on unexpected internal or metadata endpoints.
  • Use network telemetry and egress filtering solutions to detect anomalous traffic from MCP Atlassian hosts to internal or link-local IPs.

Sources

SourceLink
github.comgithub.com/sooperset/mcp-atlassian/commit/5cd697dfce9116ef330b8dc7a91291640e0528d9
github.comgithub.com/sooperset/mcp-atlassian/security/advisories/GHSA-7r34-79r5-rcc9

Frequently asked

questions

Yes, if the mcp-atlassian HTTP endpoint is exposed to the internet (directly or via a proxy) and reachable by an attacker, they can exploit the SSRF without authentication. If the service is only on an internal network, exploitation is limited to actors with that network access.

No. The vulnerable behavior is specifically reachable when requests omit the Authorization header and include certain custom headers, so no valid credentials are required.

The robust fix pattern is to ensure authentication occurs before any middleware triggers outbound calls, and to restrict outbound destinations to a tightly controlled allowlist. Additionally, remove or heavily validate any logic that derives outbound request targets from user-controlled headers or parameters.

Architecturally, avoid tying outbound HTTP targets to request-derived data, centralize URL validation and allowlisting, and enforce strict egress controls at the network layer. During development, include SSRF-specific checks in code review and static analysis, focusing on middleware, DI layers, and shared HTTP helpers rather than only tool- or handler-level code.

Find out what's already
exploitable in your codebase.