/

CVE-2026-49257

Severity:

CRITICAL RISK

(10.0)

Missing Authentication (CWE-306) in mcp-pinot MCP Server

CVE-2026-49257

Deferred

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthorized Full Read/Write Access to Pinot Cluster

Severity:

CRITICAL RISK

(10.0)

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

mcp-pinot versions 3.0.1 and below start an HTTP MCP server on 0.0.0.0:8080 with no authentication, exposing powerful Pinot management tools to any network-adjacent caller.

Because the server forwards requests using server-side Pinot credentials, an attacker can issue SQL queries, create schemas, and mutate table configurations with full read/write access to the configured Pinot cluster.

Affected context

The vulnerability affects deployments using mcp-pinot versions 3.0.1 and below where the MCP server is launched with default settings.

In this configuration, the service:

  • Listens on all network interfaces (0.0.0.0) on port 8080
  • Exposes MCP tools over plain HTTP without access control
  • Uses its own trusted Pinot credentials to proxy backend operations

Risk is highest in environments where the service port is reachable from shared networks, container overlays, or cloud VPCs, even if not directly internet-facing.

Exploit preconditions

  • Attack surface: Network-accessible HTTP MCP endpoint at 0.0.0.0:8080 (or equivalent externally exposed binding)
  • Required access: Network adjacency sufficient to reach the mcp-pinot service port; no authentication or prior authorization required
  • Trigger point: Issuing HTTP requests invoking MCP tools for SQL execution, schema operations, or table configuration changes
  • Why exploitation is possible: The server does not enforce authentication or authorization and unconditionally forwards client requests using powerful server-side Pinot credentials, creating a confused-deputy condition.

Why this happens

The core issue is a design-level omission of authentication and authorization on a network-exposed management interface.

The MCP server trusts any incoming HTTP request as an authorized caller, then uses its own privileged Pinot credentials to perform backend operations.

This maps to CWE-306: Missing Authentication for Critical Function, where security-sensitive capabilities (query execution and administrative mutations) are exposed without verifying the identity or permissions of the requester.

The confused-deputy pattern arises because the server acts on behalf of untrusted clients while leveraging trusted backend credentials.

Potential impact

  • Remote execution of arbitrary SQL queries against the Pinot cluster, which can lead to data exfiltration
  • Creation, modification, or deletion of schemas and table configurations
  • Insertion, modification, or deletion of data, resulting in data loss or corruption
  • Disruption of analytics workloads and downstream consumers due to schema or configuration tampering
  • Abuse of the Pinot cluster as an internal pivot point for further reconnaissance or impact

General mitigation guidance

Mitigation focuses on enforcing strong access control and reducing default exposure of the MCP server:

  • Require authentication and authorization for all MCP endpoints that perform data or administrative operations.
  • Use least-privilege backend credentials so the MCP server cannot perform unnecessary administrative actions on Pinot.
  • Avoid binding management-style services to 0.0.0.0 by default; prefer localhost or explicitly configured interfaces.
  • Place the MCP server behind controlled network boundaries such as firewalls, service meshes, or API gateways with access policies.
  • Provide secure-by-default configuration templates that enable authentication and restricted bindings out of the box.

How teams detect issues like this

Detection can combine configuration review, network inspection, and behavioral monitoring:

  • Perform configuration audits to identify MCP servers bound to 0.0.0.0:8080 or similar ports without authentication settings.
  • Use network scans and service discovery to locate unauthenticated HTTP endpoints exposing MCP-like APIs in internal networks.
  • Monitor Pinot logs for unexpected or anomalous SQL queries, schema operations, and configuration changes originating from the MCP server.
  • Apply static analysis or configuration linting in CI to flag services that expose management interfaces without authentication.
  • Employ API gateways or service meshes that enforce authentication policies and can alert on unauthenticated access to sensitive routes.

Sources

SourceLink
github.comgithub.com/startreedata/mcp-pinot/commit/1c7d3f9cd384854bf72c127d230bdb32299475ad
github.comgithub.com/startreedata/mcp-pinot/issues/90
github.comgithub.com/startreedata/mcp-pinot/pull/95
github.comgithub.com/startreedata/mcp-pinot/security/advisories/GHSA-73cv-556c-w3g6

Frequently asked

questions

Yes, it is exploitable by any attacker who can reach the MCP server over the network. While it may not be internet-facing in all deployments, any network-adjacent host that can connect to the service port can exercise the exposed functionality.

The attacker only needs network access to the MCP server endpoint. No credentials or prior trust relationship with the Pinot cluster is required because the server uses its own backend credentials.

The safest pattern is to require strong authentication and authorization for all MCP operations, ensure the service does not bind broadly to 0.0.0.0 by default, and constrain the backend Pinot credentials so they have only the minimal privileges necessary for intended use.

Adopt secure-by-default design for all management and data-access services: require authentication on sensitive endpoints, avoid globally exposed bindings, review privilege levels of service credentials, and integrate security reviews and configuration linting into the development and deployment pipelines.

Find out what's already
exploitable in your codebase.