· via dev.to (home feed)
Static scanner missed both mcp-atlassian CVEs; manual trace and AST rewrite caught one
A static scanner for MCP servers reported seven findings on mcp-atlassian v0.16.0 and none matched its two CVEs. A hand trace found the flaws, and a rewrite of one rule now catches the critical file-write bug.

The author of mcpscan, a static analyzer for Model Context Protocol servers, has published an unusually frank postmortem: when pointed at a widely used MCP server carrying two published vulnerabilities, the tool detected neither of them.
According to the post on dev.to, the target was sooperset/mcp-atlassian, a Jira and Confluence MCP server with roughly 6,100 GitHub stars. Version 0.16.0 has two published CVEs, one of them critical. mcpscan 0.21.0 reported seven findings against that release after scanning 94 files in about six seconds — and not one was a real bug. Scanning the patched v0.17.0 returned the same seven findings, on the same lines.
Two vulnerabilities, neither detected
CVE-2026-27825, rated critical with a CVSS score of 9.1, allows an arbitrary file write that can lead to code execution, reached through the download path used by confluence_download_attachment, which placed no limit on where downloaded files could land. CVE-2026-27826 is a high-severity server-side request forgery issue exposed through the X-Atlassian-Jira-Url and X-Atlassian-Confluence-Url headers. Both were fixed in v0.17.0.
Seven findings, zero true positives
Per the author, the report broke down like this: two "hardcoded secret" alerts pointed at an OAuth endpoint URL and a path constant in utils/oauth.py, both already suppressed by the project's own linter; two "path traversal" alerts in utils/oauth_setup.py fired because the rule's pattern saw the text open( — inside JavaScript window.open calls embedded in HTML that the Python code generates; and three "TLS verification disabled" alerts landed on code that only runs when an operator deliberately sets ssl_verify to false.
Since the patched release produced identical output, the report was plainly not measuring the security of the download path.
A manual trace found all four sites
The method that worked was narrow, the author writes: for every function that writes a file, work out where the path originates and whether anything confines it to a base directory before the write happens. In confluence/attachments.py, download_attachment accepts target_path as a parameter, converts it to an absolute path (which constrains nothing), creates any missing directories with makedirs, and writes the downloaded bytes there. jira/attachments.py repeats the same shape. Two higher-level functions that hand a target directory down to those writers bring the count to four — the same four sites upstream patched.
The upstream fix is a single call to validate_safe_path, which resolves symlinks and raises an error unless the resolved path stays inside a base directory, which defaults to the working directory.
Why the rule missed it, and the rewrite
The September version of the path-traversal rule only triggered when a path was built inline on the same line as the write — it can catch open(f"{base}/{name}", "w"). The vulnerable line, open(target_path, "wb"), gives a regex nothing to object to; the danger lives in the unchecked parameter arriving from the caller.
mcpscan 0.22.0, released alongside the post, adds a per-function AST pass beside the regex: taint is seeded from parameters, propagated through plain assignments, Path() and os.path.abspath, and any write sink receiving a tainted name is flagged HIGH unless a boundary check exists — realpath or resolve paired with startswith, is_relative_to or commonpath, or a call to anything named like safe_path or validate_path. window.open no longer matches.
On v0.16.0 the new rule flags confluence/attachments.py:198 and jira/attachments.py:50 as HIGH; on v0.17.0 it reports nothing, and total findings drop to five. The release adds eight tests, the full suite passes 266 of 266, and the tool's self-scan is clean after one suppression — its own baseline writer has exactly the flagged shape. That illustrates the trade-off: an unchecked write to a tool-supplied path is a bug in an MCP server but ordinary behaviour in a CLI that writes where its own user told it to. The update is on PyPI as mcpscan-cli.
What it still cannot do
The pass examines one function at a time, so paths flowing through several functions go untracked, and validation performed by a caller is not recognised. The SSRF remains invisible, leaving the score at one of two CVEs. The author also concedes that an earlier "14 of 14, zero false positives" benchmark was measured against self-written synthetic fixtures and therefore said nothing about detection on real code.
Why it matters
MCP servers hand model-controlled input to filesystem, network and shell operations, which makes popular ones like mcp-atlassian a live attack surface. This case is a concrete demonstration that line-based static scanning can be confidently wrong against real code, that a focused human trace — follow every tool-controlled input to its sink and look for what stops it — remains the primary review technique, and that a scanner is best positioned as the second pass, for code the reviewer never reached and for regressions. It is also a useful reminder that benchmarks built from fixtures you wrote yourself measure your assumptions, not your detection rate.
- #mcp
- #security
- #static-analysis
- #cve
- #python