Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify shared CKAN MCP Server instance
-
DeliveryCraft parameter value embedding delimiter characters to collide with victim query key
-
ExploitSubmit poisoned request to prime the shared cache
-
ExecutionVictim agent issues legitimate query
-
PersistServer returns attacker-controlled cached response
-
ImpactAI agent processes fabricated dataset content
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V15 - Secure Coding and Architecture Data authenticity verification
|
| Exploitation Conditions | Exploitation requires that the attacker and victim share the same running CKAN MCP Server process with a common in-process cache - for example, a multi-tenant or multi-agent deployment where multiple clients connect to one server instance. The attacker must be able to issue queries to the same server (authenticated or not at the application layer is not specified in the CVSS vector, which shows PR:N, meaning no privileges are required at the MCP server level). Successful exploitation also requires the attacker to issue the colliding-key request before the victim's legitimate request is served from cache (a timing dependency, reflected in AC:H). Exploitation is limited by: single-tenant or isolated-process deployments where no cache state is shared across users; the AC:H timing window requirement; and knowledge of the victim's query structure to construct a colliding parameter string. The flaw does not affect deployments where caching is disabled or where each user session has an isolated cache namespace. |
| Impact | The CVSS 3.1 vector AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N scores 6.5 (Medium), which is broadly consistent with independent assessment. AC:H accurately reflects that exploitation requires a race-condition style timing window: the attacker must prime the shared in-memory cache with a colliding key before a victim issues the legitimate query, and both parties must be routing through the same running CKAN MCP Server instance. This shared-cache requirement substantially limits the realistic attacker surface - it implies either a multi-tenant deployment where multiple external clients share one server process, or an internal attacker with access to the same deployment. The Integrity: High metric is well-justified: a successful collision lets the attacker substitute arbitrary cached content for the victim's query result, which could mean feeding fabricated dataset records or misleading metadata to an AI agent consuming the MCP output. Confidentiality: Low is plausible - a colliding key could also cause the server to return another user's prior query result to the attacker, leaking query content or result data. No EPSS data was supplied in the intelligence package, and the vulnerability has no CISA KEV listing and no publicly identified exploit code, suggesting it has not seen opportunistic mass exploitation. The attack is not trivially automatable due to the AC:H timing and shared-instance requirement, so real-world risk is most relevant to operators running CKAN MCP Server as a shared service for multiple users or agents simultaneously. |
| Exploit ScenarioDerived | An attacker with access to a shared CKAN MCP Server instance - for example, as one of several AI agent sessions routed through a common server - crafts a query whose parameter value embeds delimiter characters matching a known or guessable victim query pattern. The attacker sends this crafted query first, priming the cache with a collision key bound to attacker-controlled content. When the victim agent subsequently issues its legitimate query, the server returns the attacker's cached result rather than querying the real CKAN portal, causing the AI agent to process fabricated or misleading dataset records. No public proof-of-concept exploit has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 14, 2026
Cache key collision in CKAN MCP Server prior to version 0.4.112 allows an unauthenticated remote attacker to poison a shared in-process cache with a crafted response, causing legitimate victim queries to receive attacker-controlled data. The flaw lives in the canonicalizeParams function (src/utils/cache.ts), which joined query parameters with unescaped ampersand and equals-sign delimiters - the same delimiters used as structural separators - so a single parameter whose value embeds those characters produces an identical cache key to a distinct, legitimate multi-parameter query. No public exploit or CISA KEV listing has been identified at time of analysis, but the CVSS Integrity: High score reflects the full substitution of query results that a successful cache-poisoning achieves.
RemediationAI
Upgrade CKAN MCP Server to version 0.4.112 or later, which replaces the vulnerable k=v ampersand-join serialization in canonicalizeParams with canonical JSON serialization and wraps the full cache key in JSON array framing, eliminating the collision surface. The patch commit is available at https://github.com/ondata/ckan-mcp-server/commit/8e1522f9bbfa1f3b21550f17887f60f133e24151 and the tagged release at https://github.com/ondata/ckan-mcp-server/releases/tag/v0.4.112. If immediate upgrade is not possible, operators running CKAN MCP Server as a shared multi-user or multi-agent service should consider disabling the shared in-process cache entirely if the configuration exposes a cache-disable option, or restricting the server to single-tenant deployments (one isolated process per user or agent) as a compensating control - this eliminates the shared cache state that the collision depends on, at the cost of losing cache efficiency and potentially increasing upstream CKAN API load. Operators should verify the installed package version before assuming the fix is applied.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
CKAN MCP Server is a Model Context Protocol (MCP) server that wraps CKAN open data portal APIs, enabling AI agents and tools to query open datasets. The vulnerable component is the buildCacheKey pipeline in src/utils/cache.ts. Prior to the fix, canonicalizeParams serialized parameters as k=value pairs concatenated with literal '&', and buildCacheKey framed the result as 'serverUrl|action|params' using a literal '|' pipe. Because neither delimiter was escaped in parameter keys or values, an attacker supplying a parameter whose string value contains '&otherkey=othervalue' produces the exact same serialized key as two separate, legitimate parameters - a classic cache key injection / parameter confusion. CWE-345 (Insufficient Verification of Data Authenticity) captures the failure to ensure that a cache entry actually corresponds to the logical identity of the request that reads it. The commit fix replaces the k=v join scheme with canonical typed JSON serialization (recursive key-sort + JSON.stringify) and wraps the full key in JSON array framing, ensuring structural delimiters are always encoded.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N
Network-reachable with no privileges required; AC:H reflects shared-cache timing dependency; Integrity:High for full response substitution; Confidentiality:Low for potential cross-user cache leakage.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
1DescriptionCVE.org
CKAN MCP Server is a tool for querying CKAN open data portals. Prior to 0.4.112, canonicalizeParams in src/utils/cache.ts serializes request parameters with unescaped ampersand, equals-sign, and vertical-bar delimiters, allowing different logical parameter sets used by buildCacheKey to collide and an attacker to prime a shared cache with a response for a victim's distinct query. This issue is fixed in version 0.4.112.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-58728
GHSA-78x9-fhhx-v2g6
NVD
CVE.org
EPSS
VulDB
Exploit-DB