/

CVE-2026-13341

Severity:

HIGH RISK

(7.4)

Input Validation Flaw (CWE-20) in Konnect MCP APIs

CVE-2026-13341

Awaiting Analysis

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Unauthorized API Request Execution

Severity:

HIGH RISK

(7.4)

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

A server-side input validation weakness in the Kong Konnect Model Context Protocol (MCP) server before version 1.0.0 allows indirect prompt injection through crafted data or context.

Under certain conditions, a remote attacker can cause the server to issue unintended downstream API requests, potentially abusing trust in automated AI-assisted workflows.

Affected context

This vulnerability arises in deployments using the Kong Konnect MCP server as part of an AI- or automation-driven integration workflow.

The risk materializes when the MCP server consumes externally sourced data or context that can be influenced by remote parties, and then forwards or interprets this information for downstream API calls without robust validation or sanitization.

Environments where MCP output is treated as trusted instructions for backend services are particularly exposed.

Exploit preconditions

  • Attack surface: Remote, via interfaces that feed data, context, or instructions into the MCP server.
  • Required access: Ability to supply or influence MCP inputs (e.g., configuration, content, or messages processed by the MCP server).
  • Trigger point: Processing of attacker-controlled contextual inputs that are later interpreted as instructions, leading to unintended API calls.
  • Why exploitation is possible: The MCP server does not adequately distinguish between data and control instructions, allowing crafted content to alter the behavior of automated API workflows (indirect prompt injection).

Why this happens

The core issue is an improper input validation and interpretation pattern, aligning with CWE-20: Improper Input Validation.

The MCP server treats externally influenced contextual data as trustworthy, allowing it to affect control flow and trigger downstream API requests.

Instead of enforcing strict boundaries between user-supplied content and operational instructions, the design permits contextual inputs to be interpreted as actionable commands, enabling indirect prompt injection into AI- or automation-related components.

Potential impact

  • An attacker may cause the MCP server to perform unintended API requests against internal or external services.
  • The server could be coerced into modifying configuration, metadata, or resources managed by connected APIs.
  • Automated workflows might leak or expose sensitive information through unexpected API queries.
  • Downstream systems could be misused for pivoting, enumeration, or partial denial-of-service via excessive or malformed API requests.

General mitigation guidance

Effective mitigation focuses on tightening validation around all MCP inputs and strengthening separation between data and control instructions.

Common defensive patterns include:

  • Enforcing strict schemas and type checks for all external inputs processed by the MCP server, rejecting or normalizing unexpected fields and values.
  • Introducing explicit whitelists of permissible actions and endpoints that MCP-driven workflows are allowed to invoke.
  • Treating AI- or context-derived suggestions as untrusted until confirmed by additional logic or policy checks, rather than executing them directly.
  • Applying least-privilege to downstream API credentials so that even if unintended requests are issued, their scope and impact remain limited.
  • Implementing contextual escaping and sanitization layers where user content is embedded into prompt-like structures or instruction templates.

How teams detect issues like this

Detection can leverage both code-centric and runtime approaches:

  • Static analysis and code review focused on paths where MCP inputs influence routing, method selection, or API payload construction without sufficient validation.
  • Pattern-based checks for logic that directly binds user-controlled or context-derived strings into control fields (e.g., paths, methods, operation names).
  • Runtime logging and anomaly detection to identify unusual or unauthorized API calls initiated by the MCP server, especially those not aligned with expected workflows.
  • Policy enforcement via API gateways or service meshes that constrain MCP-originated traffic and surface deviations from defined request profiles.
  • Integration of automated security review tools into CI/CD pipelines to flag newly introduced routes or behaviors where contextual inputs can drive control decisions.

Sources

SourceLink
github.comgithub.com/Kong/mcp-konnect/security/advisories/GHSA-7767-3m3w-2p44

Frequently asked

questions

Exploitability depends on how exposed the MCP inputs are; if remote users or external systems can influence the context processed by the MCP server, they may be able to induce unintended API calls. Closed deployments with tightly controlled inputs are less exposed.

Not necessarily. The key requirement is the ability to supply or indirectly influence data consumed by the MCP server. In some deployments this may require authenticated access, while in others it could be reachable through public-facing integrations.

The safest approach is to enforce strict input validation and clear separation between data and control instructions. Treat contextual content as untrusted, validate it against schemas, and restrict which actions the MCP server is allowed to perform regardless of input content.

Future designs should adopt a default-deny stance for automated actions, ensure that AI- or context-derived suggestions are never executed blindly, and integrate security reviews into the design of MCP workflows. Applying least-privilege to downstream APIs and continuously monitoring MCP-driven traffic further reduces the risk of indirect prompt injection.

Find out what's already
exploitable in your codebase.