/

CVE-2026-26190

Severity:

CRITICAL RISK

(9.8)

Missing Authentication in Milvus Management Port

CVE-2026-26190

Analyzed

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthenticated Remote Access to Administrative and Data Operations

Severity:

CRITICAL RISK

(9.8)

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

Milvus, an open-source vector database for generative AI, exposes its management TCP port (9091) with missing or weak authentication on critical REST and debug endpoints in affected versions.

When reachable, unauthenticated clients can access the full REST API and a debug expression endpoint, enabling arbitrary data operations, credential manipulation, and expression evaluation without proper access control.

Affected context

The vulnerability affects Milvus deployments that:

  • Run versions prior to 2.5.27 or 2.6.10, and
  • Expose TCP port 9091 (metrics/management port) to networks where untrusted users can connect, and
  • Rely on the default configuration for authentication on management/debug endpoints.

In this context, the /expr debug endpoint uses a predictable default authentication token derived from etcd.rootPath, and the full REST API (/api/v1/*) is available on the management port without any authentication.

Exploit preconditions

  • Attack surface: Network-accessible Milvus instance with port 9091 exposed (e.g., within a cluster, VPC, or public internet).
  • Required access: Network-level ability to open TCP connections to the Milvus management/metrics port; no valid application credentials are required in vulnerable configurations.
  • Trigger point (debug endpoint): Sending requests to /expr with the default or derivable token that depends on etcd.rootPath (default by-dev), allowing arbitrary expression evaluation.
  • Trigger point (REST API): Sending unauthenticated HTTP requests to /api/v1/* on port 9091 to invoke business operations such as data insertion, deletion, index management, and credential operations.
  • Why exploitation is possible: Authentication and authorization checks are missing or effectively bypassed:
  • The debug endpoint uses a weak, predictable shared token.
  • The REST API is registered on a port intended for metrics/management but lacks any authentication layer, so the server trusts any client that can connect.

Why this happens

This issue stems from missing and insufficient authentication controls on sensitive HTTP endpoints exposed via the management port.

The /api/v1/* REST API, designed for core business operations, is bound to port 9091 without enforcing authentication, meaning access control is delegated entirely to network reachability.

Additionally, the /expr debug endpoint relies on a default, predictable token derived from configuration (etcd.rootPath with a default of by-dev), which does not provide robust authentication.

Conceptually, this maps to CWE-306: Missing Authentication for Critical Function, where security-sensitive operations (data manipulation, credential management, internal expression evaluation) are accessible without strong proof of identity, often due to design assumptions about trusted networks or internal-only access.

Potential impact

  • Unauthenticated manipulation of collections, vectors, and indexes (creation, modification, deletion) on the Milvus instance.
  • Unauthorized insertion, alteration, or deletion of data, potentially undermining AI model behavior and search relevance.
  • Unauthorized management of credentials or security-related configuration exposed through the REST API.
  • Data exfiltration by reading sensitive vectors and metadata, including embeddings derived from proprietary or personal data.
  • Service disruption or denial of service by issuing expensive queries, dropping critical indexes, or misconfiguring collections.
  • Facilitation of broader environment compromise if Milvus is integrated into larger workflows or pipelines that trust its data and APIs.

General mitigation guidance

Mitigation typically focuses on enforcing robust authentication on management and business APIs, hardening network exposure, and avoiding weak shared secrets:

  • Introduce mandatory authentication and authorization for all REST and debug endpoints, including those bound to management or metrics ports.
  • Replace predictable, configuration-derived tokens with strong, randomly generated credentials or standards-based authentication mechanisms (e.g., mTLS, OAuth2/JWT, or similar).
  • Segregate metrics/management functionality from business APIs, exposing them on different ports or paths with distinct security policies.
  • Apply least-privilege networking: restrict management ports to dedicated administration networks, internal control planes, or specific service accounts.
  • Provide secure-by-default configurations that never bind powerful APIs unauthenticated on interfaces reachable by non-administrative users.
  • Document and encourage configuration patterns that minimize reliance on "trusted internal network" assumptions.

How teams detect issues like this

Effective detection often combines configuration inspection, network analysis, and application-level review:

  • Configuration review: Automatically scan Milvus configuration files, deployment manifests, and Helm charts to detect when port 9091 is bound on non-loopback interfaces or exposed via ingress/load balancers.
  • Network exposure checks: Use network scanning and service discovery tools to identify Milvus management ports reachable from untrusted segments, then verify whether they require authentication for /api/v1/* and /expr.
  • Static analysis & code review: Look for routes/controllers registering business APIs or debug handlers on management or metrics ports without explicit authentication middleware.
  • Runtime monitoring: Inspect HTTP access logs on port 9091 to identify unauthenticated access patterns or sensitive operations originating from unexpected clients or networks.
  • Policy enforcement: Implement infrastructure-as-code (IaC) policies (e.g., in Terraform, Kubernetes admission controllers, or GitOps pipelines) that block deployments exposing sensitive management ports without proper authentication or network ACLs.

Sources

SourceLink
github.comgithub.com/milvus-io/milvus/commit/92b74dd2e286006a83b4a5f07951027b32e718a9
github.comgithub.com/milvus-io/milvus/releases/tag/v2.5.27
github.comgithub.com/milvus-io/milvus/releases/tag/v2.6.10
github.comgithub.com/milvus-io/milvus/security/advisories/GHSA-7ppg-37fh-vcr6

Frequently asked

questions

Yes, if port 9091 is reachable from an attacker's network location. In vulnerable versions, an attacker does not need valid Milvus credentials to interact with the REST API or the /expr debug endpoint on that port.

No valid application-level accounts are required in the affected configuration. Network-level access to port 9091 is sufficient, because the critical endpoints either lack authentication entirely or rely on a predictable default token.

Enforce strong, mandatory authentication and authorization for all REST and debug endpoints, segregate management/debug functions from public-facing APIs, and ensure that configuration defaults do not expose powerful operations on unauthenticated ports.

Adopt a "secure by default" design: require authentication on all state-changing APIs, avoid predictable or configuration-derived tokens, restrict management ports with network controls, and integrate security reviews (code, configuration, and IaC policies) into the development and deployment lifecycle.

Find out what's already
exploitable in your codebase.