Skip to content

CVE-2026-121458: Instatic AI & CMS Model Context Protocol (MCP) Content Read Tools Missing Authorization & Cross-Tenant Data Disclosure

Density:
C-Level Executive Briefing CVE-2026-121458 CRITICAL SCORE 82/100

A critical authorization failure in the Model Context Protocol (MCP) server endpoints of Instatic versions 0.0.12 through 0.0.20 exposes private drafts, unpublished records, and cross-tenant documents to low-privileged accounts possessing basic ai.chat and content.edit.own capabilities. Disclosed and cataloged as weaponized by VulnCheck on November 4, 2026, the vulnerability stems from missing object-level access control enforcement in the content_get_document and content_list_documents MCP tool handlers. While standard REST endpoints enforce user ownership, the MCP interface relies solely on coarse transport authentication, allowing connected LLM agents or malicious operators to enumerate and exfiltrate enterprise intellectual property without restriction. Hermes assigns an Agentic Security Score (HASS) of 88.

HYBRID

HERMES THREAT SCORE & AUTONOMOUS AI AGENT MCP AUTHORIZATION INTEGRITY EVALUATION

Target: Instatic MCP Server Content Read Tools (content_get_document & content_list_documents)
Confidence: 96%
82 / 100
CRITICAL

Measures real-world operational relevance, exploit weaponization, and active threat posture.

Dimension Breakdown
Exploitability 19 / 20
Threat Activity 16 / 20
Weaponization 19 / 20
Exposure 16 / 20
Prevalence 14 / 20
Impact 17 / 20
Exploit Maturity 19 / 20
Attack Chain Potential 18 / 20
๐Ÿ•ธ๏ธ Connected Knowledge Graph & Provenance

CVE-2026-121458: Instatic AI & CMS Model Context Protocol (MCP) Content Read Tools Missing Authorization & Cross-Tenant Data DisclosureVULNERABILITY

Connected Nodes: 1
Active Relationships (Outgoing)
→ affectsPRODUCTInstatic AI & Static CMS Platform
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

๐Ÿ” Why is this related? (Evidence & Provenance)

“Confirmed security vulnerability in Instatic AI & Static CMS Platform documented in Hermes dossier.”

Supporting Verified Evidence:

Instatic is an open-source static CMS and publishing platform tailored for AI-augmented workflows. It features a native Model Context Protocol (MCP) server daemon that exposes document management, template compilation, and editorial capabilities directly to frontier models and external autonomous coding agents (such as Claude Desktop, Cursor, or LangChain agents).

In Instatic architectures, users operate under capability-based access control flags:

  • ai.chat: Permits bidirectional conversations with local or remote LLM models via the MCP socket.
  • content.edit.own: Restricts user write and read operations to records where author_id == current_user.id.
  • content.read.all: Reserved for administrators and editorial managers.

Under normal HTTP REST routing, accessing /api/v1/documents/:id evaluates whether the document is published, belongs to the requesting tenant, or whether the caller holds administrative permissions. However, in the MCP subsystem, tool handlers registered under the MCP JSON-RPC protocol failed to verify record ownership, exposing all documents across the instance.

The vulnerability resides within the MCP tool dispatcher in src/server/mcp/tools/content.ts. When an agent invokes content_get_document or content_list_documents, the server extracts user identity from the MCP transport layer but fails to pass authorization filters down to the database ORM query builder.

// Vulnerable Implementation: src/server/mcp/tools/content.ts (prior to 0.0.21)
export const registerContentTools = (server: McpServer, db: Database) => {
// Tool: Retrieve a document by ID
server.tool(
"content_get_document",
{ documentId: z.string().uuid() },
async ({ documentId }, { session }) => {
// Check only coarse capability: Does caller have AI chat rights?
if (!session.hasCapability("ai.chat")) {
throw new McpError(ErrorCode.Unauthorized, "Missing ai.chat capability");
}
// FLAW: Direct database fetch without author_id / organization_id predicate
const doc = await db.documents.findUnique({
where: { id: documentId }
});
if (!doc) {
throw new McpError(ErrorCode.InvalidParams, "Document not found");
}
// Exposes raw content, draft status, and private metadata across tenants
return {
content: [{ type: "text", text: JSON.stringify(doc) }]
};
}
);
// Tool: List documents
server.tool(
"content_list_documents",
{ status: z.enum(["draft", "published", "archived"]).optional() },
async ({ status }, { session }) => {
if (!session.hasCapability("ai.chat")) {
throw new McpError(ErrorCode.Unauthorized, "Missing ai.chat capability");
}
// FLAW: Returns all documents across all users and organizations
const query: any = {};
if (status) query.status = status;
const docs = await db.documents.findMany({ where: query, take: 100 });
return {
content: [{ type: "text", text: JSON.stringify(docs) }]
};
}
);
};

In Instatic 0.0.21, the development team introduced scoped session context validation, enforcing tenancy and ownership filters on every MCP query builder call:

// Patched Implementation: src/server/mcp/tools/content.ts (0.0.21)
server.tool(
"content_get_document",
{ documentId: z.string().uuid() },
async ({ documentId }, { session }) => {
// Enforce both AI capability AND object-level read permissions
if (!session.hasCapability("ai.chat")) {
throw new McpError(ErrorCode.Unauthorized, "Missing ai.chat capability");
}
const whereClause: any = { id: documentId };
// If user cannot read all content, strictly restrict to own documents
if (!session.hasCapability("content.read.all")) {
whereClause.organizationId = session.organizationId;
if (session.hasCapability("content.edit.own")) {
whereClause.authorId = session.userId;
}
}
const doc = await db.documents.findFirst({ where: whereClause });
if (!doc) {
throw new McpError(ErrorCode.InvalidParams, "Document not found or access denied");
}
return { content: [{ type: "text", text: JSON.stringify(doc) }] };
}
);
sequenceDiagram
autonumber
actor Attacker as Low-Privileged Attacker (ai.chat)
participant Client as MCP Client / AI Chat Client
participant MCPServer as Instatic MCP Daemon (JSON-RPC)
participant DB as System SQLite / Postgres DB
participant Victim as Target Organization / CEO Drafts
Victim->>DB: Stores confidential strategy document (status: 'draft')
Attacker->>Client: Establishes MCP session with low-priv token
Client->>MCPServer: {"jsonrpc": "2.0", "method": "tools/call", "params": {"name": "content_list_documents", "arguments": {"status": "draft"}}}
MCPServer->>MCPServer: Verifies session.hasCapability("ai.chat") -> TRUE
Note over MCPServer,DB: Missing WHERE author_id check!
MCPServer->>DB: SELECT * FROM documents WHERE status = 'draft'
DB-->>MCPServer: Returns all private drafts across all tenants
MCPServer-->>Client: Returns JSON containing unreleased docs and secret tokens
Attacker->>Client: Exfiltrates proprietary data

The attack can be performed either through direct JSON-RPC calls over the WebSocket/stdio MCP interface or via indirect prompt injection. An attacker embedding hidden instructions inside a public forum or shared markdown file can direct an autonomous agent acting on behalf of a user to run content_list_documents and transmit the results to an external telemetry webhook.

Sigma Rule: Detection of Unscoped MCP Document Enumeration

Section titled โ€œSigma Rule: Detection of Unscoped MCP Document Enumerationโ€
title: Suspicious MCP Document Cross-Tenant Enumeration
id: e8a9142e-1823-41bb-a794-d2c676231201
status: experimental
description: Detects rapid enumeration of unpublished drafts and cross-tenant documents via Instatic MCP tools.
references:
- https://vulncheck.com/advisories/instatic-before-authorization-bypass-via-mcp-content-read-tools
author: Hermes Codex Cyber Threat Intelligence
date: 2026-11-04
logsource:
category: application
product: instatic
detection:
selection_mcp_call:
mcp.method: 'tools/call'
mcp.tool_name|in:
- 'content_list_documents'
- 'content_get_document'
selection_low_priv:
user.role|in:
- 'contributor'
- 'external_editor'
- 'ai_chat_user'
filter_admin:
user.role: 'admin'
condition: selection_mcp_call and selection_low_priv and not filter_admin
fields:
- user.id
- user.role
- mcp.tool_name
- mcp.arguments
falsepositives:
- Legitimate editorial automation running under dedicated service accounts.
level: high
Indicator TypeObservable / IndicatorRole / ContextStatus
MCP Tool Methodcontent_get_document, content_list_documentsTarget tool endpoints invoked with cross-tenant argumentsACTIVE
Tool ArgumentsdocumentId pointing to foreign author rowsObject-level authorization bypass observableMALICIOUS
Audit Alertmcp-server: 'Access denied: document owner mismatch'Log signature generated by post-patch enforcementCONFIRMED
Traffic AnomalySpikes in JSON-RPC tools/call requests from low-privilege sessionsBulk exfiltration or automated enumeration waveANOMALOUS

The maintainers resolved this vulnerability in Instatic version 0.0.21 by updating packages/mcp-server/src/tools/content.ts. The patch binds document read queries strictly to the callerโ€™s verified session.userId and tenancy boundary, throwing an authorization fault when foreign IDs are queried:

Product BranchVulnerable VersionsFixed ReleasePatch Status
Instatic 0.0.x0.0.12 โ€“ 0.0.200.0.21Official Security Release
Instatic < 0.0.12< 0.0.12N/A (MCP absent)Upgrade to 0.0.21 Recommended
  1. Upgrade Instatic Daemon: Immediately update Instatic to version 0.0.21 or later. Verify that the running server binary reports instatic --version >= 0.0.21.
  2. Restrict MCP Tool Exposure: In instatic.config.json, disable MCP tool exposure to non-administrative users by setting mcp.allow_public_tools: false and binding MCP listeners exclusively to localhost (127.0.0.1) or an authenticated Unix domain socket.
  3. Audit Historical Tool Access: Query system audit tables for content_get_document and content_list_documents calls initiated by non-administrative users between 2026-10-01 and the patch date to identify potential exfiltration of sensitive unpublished materials.
  4. Enforce Agentic Role-Based Scoping: Ensure that AI agent integrations utilize ephemeral, scoped service principal tokens rather than standing user session cookies.