CVE-2026-73846: CKAN MCP Server Cache-key Canonicalization Collision Enables Cache Vulnerability

MODERATE
Advisory Identifier: GHSA-78x9-fhhx-v2g6
CVSS 6.5
CWE-436 CWE-345
Published
Advisory Summary

CVE-2026-73846 is a MODERATE (CVSS 6.5) cache-key canonicalization collision enables cache vulnerability (CWE-436: Interpretation Conflict) affecting CKAN MCP Server libraries in the npm ecosystem. The issue involves cache-key canonicalization collision enables cache confusion / poisoning. Remediation is available by upgrading affected packages to version 0.4.112.

CVE-2026-73846 at a Glance

CVE Identifier CVE-2026-73846
GHSA Identifier GHSA-78x9-fhhx-v2g6
Severity MODERATE
CVSS v3.1 Base Score 6.5
CWE Classification CWE-436: Interpretation Conflict
Affected Product CKAN MCP Server
Package Ecosystem npm
Published Date
Last Updated

Security Impact

CVSS: 6.5

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N).

Attack Vector Network (AV:N)
Attack Complexity High (AC:H)
Privileges Required None (PR:N)
User Interaction None (UI:N)
Scope Unchanged (S:U)
Confidentiality Low (C:L)
Integrity High (I:H)
Availability None (A:N)

How to Fix CVE-2026-73846

To remediate this vulnerability, upgrade all affected CKAN MCP Server dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

@aborruso/ckan-mcp-server fixed: 0.4.112
npm install @aborruso/ckan-mcp-server@0.4.112
Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release:

npm ls @aborruso/ckan-mcp-server

How to Check if You Are Affected

To determine whether your Node.js application is affected by CVE-2026-73846, inspect your project dependencies using npm:

npm ls @aborruso/ckan-mcp-server

Analyze the terminal output to locate any version of CKAN MCP Server in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 0.4.112), your application is affected.

Note: The npm ls @aborruso/ckan-mcp-server command inspects dependencies declared in your package.json and lockfile; it does not perform automated runtime dynamic scanning.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under CWE-436: Interpretation Conflict, where product a handles inputs or steps differently than product b, which causes a to perform incorrect actions based on its perception of b's state. In CKAN MCP Server, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

## Summary The response cache derives its key from an ambiguous string serialization of the request parameters. `canonicalizeParams` joins sorted `${key}=${value}` pairs with `&` and does not escape `&`, `=`, or the `|` field separators used in `buildCacheKey`. Two **different** logical parameter sets can therefore serialize to the **same** key and share one cache entry. Because the cached value is whatever the upstream returned for whichever request populated the entry first, an attacker can prime a colliding key so a victim's distinct query (same `server_url`) is served the attacker's cached response. ## Affected code ```js // src/utils/cache.ts export function canonicalizeParams(params) { const keys = Object.keys(params).sort(); const pairs = []; for (const key of keys) { const value = params[key]; if (value === undefined || value === null) continue; const serialized = typeof value === "object" ? JSON.stringify(value) : String(value); pairs.push(`${key}=${serialized}`); // value not escaped } return pairs.join("&"); // '&' delimiter, injectable } export async function buildCacheKey(serverUrl, action, params) { const raw = `${serverUrl}|${action}|${canonicalizeParams(params)}`; // '|' also unescaped return sha1Hex(raw); } ``` Confirmed collisions (identical key): - `{ q: "budget", rows: 10 }` ≡ `{ q: "budget&rows=10" }` → both canonicalize to `q=budget&rows=10` - `{ filters: { a: "b" } }` ≡ `{ filters: '{"a":"b"}' }` → both canonicalize to `filters={"a":"b"}` (object-vs-string ambiguity) An attacker can reproduce **any** target canonical string by injecting it into the alphabetically-first parameter, so the collision is general, not incidental. ## Impact - **Cache poisoning / confusion.** On a shared cache (caching is enabled by default; the Cloudflare Workers deployment uses the shared `caches.default`, and a Node HTTP instance shares one in-process LRU across all clients), an attacker primes a colliding entry so that another client's genuinely different query receives the attacker-chosen response for the same portal. - **Integrity of results.** Victims receive data for a query they did not make (wrong dataset list, wrong record set), undermining trust in tool output. - **Chains with indirect prompt injection (advisory #07).** The attacker's colliding request can be one whose upstream response surfaces an attacker-controlled dataset (with malicious `notes`/`title`); the victim's benign query then serves that poisoned content to the model — delivering prompt injection via the cache, without the victim ever querying the malicious dataset. Confidentiality impact is low (same-portal public data); the primary damage is integrity. `AC:H` reflects the need for caching to be enabled and a shared instance plus priming before the victim's request populates the entry. ## Proof of concept `poc/cache-collision-poc.mjs` primes a single-param request and shows a victim's distinct two-param request being served the attacker-primed entry: ``` attacker canonical : q=budget&rows=10 victim canonical : q=budget&rows=10 same cache key : true victim served from cache: true victim RECEIVED : RESULT_FOR({"q":"budget&rows=10"}) victim EXPECTED : RESULT_FOR({"q":"budget","rows":10}) ``` ## Remediation - Build the cache key from an unambiguous, injection-proof encoding: hash a structured, canonical JSON (with typed values) or percent-encode/escape each key and value before joining, and use a separator that cannot appear in the encoded fields. Include a type tag so `{a:{...}}` (object) and `{a:"..."}` (string) never coincide. - Consider partitioning the cache per client/tenant on shared deployments so one client cannot influence another's entries.

CVE-2026-73846 Affected CKAN MCP Server Versions

1 component(s)
Fixed Versions:
0.4.112
Product / Package Ecosystem Affected Versions Fixed Version
@aborruso/ckan-mcp-server
npm
< 0.4.112
0.4.112

References

Frequently Asked Questions

What is CVE-2026-73846?
CVE-2026-73846 is a security vulnerability in CKAN MCP Server involving Cache-key canonicalization collision enables cache confusion / poisoning under CWE-436: Interpretation Conflict.
Which CKAN MCP Server versions are affected?
Affected versions include releases prior to 0.4.112 across affected packages: @aborruso/ckan-mcp-server.
What version fixes CVE-2026-73846?
Upgrading to 0.4.112 (or the latest patched release for your respective branch) resolves the vulnerability.
Is @aborruso/ckan-mcp-server affected?
Yes, @aborruso/ckan-mcp-server is affected in releases prior to 0.4.112. Upgrade your dependency to 0.4.112 or later.
What is the CVSS score of CVE-2026-73846?
CVE-2026-73846 has a CVSS v3.1 base score of 6.5 (MODERATE) with vector string CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N.
What CWE is associated with CVE-2026-73846?
CVE-2026-73846 is classified under CWE-436: Interpretation Conflict (Product A handles inputs or steps differently than Product B, which causes A to perform incorrect actions based on its perception of B's state.).
How can I check npm dependencies for CVE-2026-73846?
Run the dependency tree command: 'npm ls @aborruso/ckan-mcp-server'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-78x9-fhhx-v2g6",
  "modified" : "2026-09-03T14:49:22Z",
  "published" : "2026-09-03T14:49:22Z",
  "aliases" : [ "CVE-2026-73846" ],
  "summary" : "CKAN MCP Server: Cache-key canonicalization collision enables cache confusion / poisoning",
  "details" : "## Summary\n\nThe response cache derives its key from an ambiguous string serialization of the request parameters. `canonicalizeParams` joins sorted `${key}=${value}` pairs with `&` and does not escape `&`, `=`, or the `|` field separators used in `buildCacheKey`. Two **different** logical parameter sets can therefore serialize to the **same** key and share one cache entry. Because the cached value is whatever the upstream returned for whichever request populated the entry first, an attacker can prime a colliding key so a victim's distinct query (same `server_url`) is served the attacker's cached response.\n\n## Affected code\n\n```js\n// src/utils/cache.ts\nexport function canonicalizeParams(params) {\n  const keys = Object.keys(params).sort();\n  const pairs = [];\n  for (const key of keys) {\n    const value = params[key];\n    if (value === undefined || value === null) continue;\n    const serialized = typeof value === \"object\" ? JSON.stringify(value) : String(value);\n    pairs.push(`${key}=${serialized}`);        // value not escaped\n  }\n  return pairs.join(\"&\");                        // '&' delimiter, injectable\n}\n\nexport async function buildCacheKey(serverUrl, action, params) {\n  const raw = `${serverUrl}|${action}|${canonicalizeParams(params)}`;  // '|' also unescaped\n  return sha1Hex(raw);\n}\n```\n\nConfirmed collisions (identical key):\n\n- `{ q: \"budget\", rows: 10 }`  ≡  `{ q: \"budget&rows=10\" }`  → both canonicalize to `q=budget&rows=10`\n- `{ filters: { a: \"b\" } }`  ≡  `{ filters: '{\"a\":\"b\"}' }`  → both canonicalize to `filters={\"a\":\"b\"}` (object-vs-string ambiguity)\n\nAn attacker can reproduce **any** target canonical string by injecting it into the alphabetically-first parameter, so the collision is general, not incidental.\n\n## Impact\n\n- **Cache poisoning / confusion.** On a shared cache (caching is enabled by\n  default; the Cloudflare Workers deployment uses the shared `caches.default`, and\n  a Node HTTP instance shares one in-process LRU across all clients), an attacker\n  primes a colliding entry so that another client's genuinely different query\n  receives the attacker-chosen response for the same portal.\n- **Integrity of results.** Victims receive data for a query they did not make\n  (wrong dataset list, wrong record set), undermining trust in tool output.\n- **Chains with indirect prompt injection (advisory #07).** The attacker's\n  colliding request can be one whose upstream response surfaces an\n  attacker-controlled dataset (with malicious `notes`/`title`); the victim's\n  benign query then serves that poisoned content to the model — delivering prompt\n  injection via the cache, without the victim ever querying the malicious dataset.\n\nConfidentiality impact is low (same-portal public data); the primary damage is\nintegrity. `AC:H` reflects the need for caching to be enabled and a shared\ninstance plus priming before the victim's request populates the entry.\n\n## Proof of concept\n\n`poc/cache-collision-poc.mjs` primes a single-param request and shows a victim's\ndistinct two-param request being served the attacker-primed entry:\n\n```\nattacker canonical : q=budget&rows=10\nvictim   canonical : q=budget&rows=10\nsame cache key      : true\nvictim served from cache: true\nvictim RECEIVED    : RESULT_FOR({\"q\":\"budget&rows=10\"})\nvictim EXPECTED    : RESULT_FOR({\"q\":\"budget\",\"rows\":10})\n```\n\n## Remediation\n\n- Build the cache key from an unambiguous, injection-proof encoding: hash a\n  structured, canonical JSON (with typed values) or percent-encode/escape each key\n  and value before joining, and use a separator that cannot appear in the encoded\n  fields. Include a type tag so `{a:{...}}` (object) and `{a:\"...\"}` (string)\n  never coincide.\n- Consider partitioning the cache per client/tenant on shared deployments so one\n  client cannot influence another's entries.",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N"
  } ],
  "affected" : [ {
    "package" : {
      "ecosystem" : "npm",
      "name" : "@aborruso/ckan-mcp-server"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "0"
      }, {
        "fixed" : "0.4.112"
      } ]
    } ]
  } ],
  "references" : [ {
    "type" : "WEB",
    "url" : "https://github.com/ondata/ckan-mcp-server/security/advisories/GHSA-78x9-fhhx-v2g6"
  }, {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-73846"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/ondata/ckan-mcp-server/commit/8e1522f9bbfa1f3b21550f17887f60f133e24151"
  }, {
    "type" : "PACKAGE",
    "url" : "https://github.com/ondata/ckan-mcp-server"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/ondata/ckan-mcp-server/releases/tag/v0.4.112"
  } ],
  "database_specific" : {
    "cwe_ids" : [ "CWE-345", "CWE-436" ],
    "severity" : "MODERATE",
    "github_reviewed" : true,
    "github_reviewed_at" : "2026-09-03T14:49:22Z",
    "nvd_published_at" : "2026-08-14T17:20:36Z"
  }
}