← MCP server and skill grades

kubernetes-mcp-server

containers/kubernetes-mcp-server

C
Type
MCP server
Scanned
Nov 13, 2026
Version
2bb8c6a8034e
Files read
1020

This server lets AI assistants inspect and manage your Kubernetes and OpenShift clusters, including changing workloads, installing Helm charts, checking monitoring tools, and running commands inside containers. The biggest risk is that a tricked AI can read your raw cluster tokens and private keys or run commands and alter live workloads by default, and HTTP or container mode opens cluster control to anyone on your network unless you turn on authentication.

What it can reach

Files
Reads and watches local kubeconfig files (such as ~/.kube/config), server settings, TLS certificates, and local Helm charts, writes optional log files, and caches downloaded binaries in ~/.kubernetes-mcp-server/bin when using the Python wrapper.
Secrets
Reads cluster tokens, client certificates, and private keys from local kubeconfig files or in-cluster service accounts, OAuth credentials, and Kubernetes Secret objects in connected clusters.
Network
Connects to Kubernetes and OpenShift APIs, Helm registries, login providers, telemetry endpoints, and monitoring backends (Prometheus, Alertmanager, Loki, Tempo, Kiali, NetObserv), and can listen on an HTTP or HTTPS port across all network interfaces.
Shell commands
Runs arbitrary commands inside cluster pod containers by default and executes a downloaded server binary when launched through the Python wrapper.
Other
Creates, updates, scales, and deletes Kubernetes and OpenShift cluster resources, container workloads, Helm releases, KubeVirt virtual machines, and Tekton pipelines.

Findings

1 high19 medium33 low
  1. Highconfiguration_view exposes unredacted kubeconfig tokens and private keys

    pkg/kubernetes/configuration.go:78

    The configuration_view tool is enabled by default in stdio mode and remains active even when read_only = true or denied_resources is configured. Unlike kubectl config view, which redacts secrets by default, ConfigurationView calls clientcmdapi.FlattenConfig without redacting sensitive fields, reading external client-key and tokenFile paths from disk and returning raw bearer tokens, passwords, TLS private keys, and OIDC refresh tokens in YAML (for every cluster in kubeconfig when minified is false). Prompt injection in pod logs, events, or issues can trick the agent into calling configuration_view and exposing all kubeconfig credentials into the model context.

    Fix: Redact sensitive kubeconfig fields (for example with clientcmdapi.RedactSecrets or ShortenConfig rather than FlattenConfig) before serializing, or disable configuration_view by default in stdio mode just as it is disabled over HTTP.

  2. MediumHTTP mode binds to 0.0.0.0 without authentication by default

    pkg/config/config.go:433

    When HTTP mode is used—either by setting port in config.toml or out of the box in the container image, server.json Docker configuration, and Helm chart—bind_address defaults to 0.0.0.0 and require_oauth defaults to false. In addition, the MCP Go SDK DNS-rebinding check only guards connections accepted on a loopback IP, so connections arriving on a LAN interface or through Docker bridge NAT (-p 8080:8080) bypass localhost Host header protection. Anyone on the local network, or a website reaching a locally published Docker container, can invoke /mcp without credentials to run commands in pods and read or modify cluster resources.

    Fix: Default bind_address to 127.0.0.1, require require_oauth = true (or an explicit insecure override) before binding to non-loopback interfaces, and bind container port mappings in server.json to 127.0.0.1:8080:8080.

  3. MediumDocker registry package exposes unauthenticated MCP HTTP port on all network interfaces

    server.json:57

    In server.json, the OCI (Docker) package mounts the user's kubeconfig into the container and sets the default Docker port mapping (-p) to 8080:8080 without a 127.0.0.1 host prefix. In Docker, -p 8080:8080 binds port 8080 on 0.0.0.0 across all host network interfaces rather than localhost only, while the default container setup uses plain HTTP with no authentication. Anyone on the same Wi-Fi or local network can connect directly to port 8080 on the user's machine and call MCP tools to view kubeconfig data, read secrets, or run commands and workloads in the user's Kubernetes clusters.

    Fix: Change the default -p argument in server.json from 8080:8080 to 127.0.0.1:8080:8080 so Docker only binds the MCP HTTP endpoint to localhost.

  4. MediumDocker MCP registry config binds unauthenticated HTTP port to all network interfaces

    server.json:57

    The OCI container package entry in server.json mounts the user's kubeconfig into the container and sets the default Docker -p port mapping to 8080:8080 while connecting over plain HTTP (http://localhost:8080/mcp) without authentication. In Docker, -p 8080:8080 without a loopback IP prefix binds 0.0.0.0:8080 on the host (and can bypass host firewall rules on Linux), allowing anyone on the same network to call MCP tools and run commands or modify resources in the user's Kubernetes cluster.

    Fix: Change the default port mapping in server.json from 8080:8080 to 127.0.0.1:8080:8080 so the container port is only reachable from localhost.

  5. MediumOCI package manifest publishes HTTP MCP port on all network interfaces

    server.json:57

    The OCI container package definition sets the Docker port mapping argument (-p) to 8080:8080 without a 127.0.0.1 host bind address, while mounting the user's kubeconfig into the container. In Docker, -p 8080:8080 binds port 8080 on 0.0.0.0 (every network interface on the host) rather than just localhost, allowing anyone on the same local network to connect directly to the unauthenticated /mcp HTTP endpoint and control the user's Kubernetes clusters with no AI involvement.

    Fix: Change the default port mapping to 127.0.0.1:8080:8080 so the container HTTP endpoint is only reachable from the local machine.

  6. MediumDocker registry configuration publishes MCP HTTP port on all network interfaces

    server.json:57

    In server.json, the OCI (Docker) package defines a required -p runtime argument whose default is 8080:8080 while mounting the user's kubeconfig and using plain HTTP (http://localhost:8080/mcp) with no authentication flags. In Docker, -p 8080:8080 binds port 8080 on all host network interfaces (0.0.0.0) rather than loopback, allowing other devices on the same local network to connect directly to the MCP endpoint and invoke Kubernetes tools using the mounted credentials. Standard npx, uvx, and binary installs use stdio and are not affected.

    Fix: Change the default port mapping in server.json to 127.0.0.1:8080:8080 so Docker only exposes the port on localhost.

  7. MediumDocker package manifest publishes HTTP MCP port on all network interfaces by default

    server.json:57

    The OCI Docker package definition in server.json sets the default -p port mapping to 8080:8080 while mounting the user's kubeconfig into the container with no authentication configured, even though the transport URL is http://localhost:8080/mcp. In Docker, -p 8080:8080 binds port 8080 on 0.0.0.0 (every network interface on the host), allowing anyone on the same local network to connect to the MCP endpoint and view kubeconfig data, read or delete cluster resources, or execute commands in pods.

    Fix: Restrict the default Docker port mapping in server.json to loopback by changing "8080:8080" to "127.0.0.1:8080:8080".

  8. MediumOCI registry manifest binds unauthenticated MCP HTTP port to all network interfaces

    server.json:57

    The OCI Docker package definition sets the default '-p' port mapping to '8080:8080' while mounting the user's kubeconfig and configuring no authentication. In Docker, '-p 8080:8080' binds port 8080 on 0.0.0.0 across all host network interfaces rather than localhost, allowing anyone on the same local network to connect to '/mcp' and read cluster secrets, view kubeconfig details, or run and modify workloads in the user's cluster.

    Fix: Change the default '-p' runtime argument in server.json to '127.0.0.1:8080:8080' so Docker only exposes the port on localhost.

  9. MediumDocker package manifest exposes MCP HTTP port on all network interfaces

    server.json:57

    In the MCP Registry manifest (server.json), the OCI/Docker package mounts the user's kubeconfig file and publishes port 8080 using -p with a default of 8080:8080 instead of 127.0.0.1:8080:8080, with no authentication configured. Although the MCP client connects locally via http://localhost:8080/mcp, Docker binds 8080:8080 to 0.0.0.0, allowing anyone on the same local network to connect directly to port 8080 and invoke Kubernetes tools (such as pods_exec, resources_create_or_update, and configuration_view) using the user's cluster credentials.

    Fix: Change the default -p runtime argument in server.json from 8080:8080 to 127.0.0.1:8080:8080 so Docker binds the HTTP endpoint only to localhost.

  10. MediumDocker MCP registry manifest exposes HTTP server on all network interfaces

    server.json:57

    The OCI container package in server.json mounts the user's kubeconfig and maps port -p with a default of 8080:8080 while using plain HTTP (http://localhost:8080/mcp) and no authentication flags. In Docker, -p 8080:8080 without a loopback IP binds to 0.0.0.0 on the host, allowing anyone on the same local network to connect to port 8080 and run Kubernetes tools (including pod command execution and viewing configuration) using the user's cluster credentials.

    Fix: Bind the published container port to loopback by changing the default value in server.json to 127.0.0.1:8080:8080.

  11. MediumDocker registry package binds HTTP server to all network interfaces (0.0.0.0:8080) by default

    server.json:57

    In server.json, the OCI Docker package sets the default -p runtime argument to 8080:8080 while mounting the user's kubeconfig file and serving plain HTTP on /mcp without authentication configured. In Docker, -p 8080:8080 without a 127.0.0.1 prefix publishes the port on 0.0.0.0 across all host network interfaces, allowing anyone on the same local network to connect directly to the MCP server and read kubeconfig details or run commands and modify resources in the user's Kubernetes clusters.

    Fix: Change the default -p value in server.json to 127.0.0.1:8080:8080 so Docker binds the HTTP port only to the local loopback interface.

  12. MediumDocker MCP registry manifest exposes unauthenticated HTTP endpoint on all network interfaces

    server.json:57

    The OCI container package in server.json sets the default Docker port mapping to 8080:8080 without restricting it to 127.0.0.1, even though the configured transport URL only connects to localhost. When launched with these defaults, Docker binds port 8080 on 0.0.0.0, allowing anyone on the same network to reach the unauthenticated MCP server and use the mounted kubeconfig to read Secrets, modify cluster resources, or run commands in pods.

    Fix: Change the default -p runtime argument in server.json to 127.0.0.1:8080:8080 so the HTTP endpoint is only accessible on the loopback interface.

  13. MediumOCI container manifest binds unauthenticated MCP HTTP port to 0.0.0.0 by default

    server.json:57

    In the OCI (Docker) package entry of server.json, the required -p runtime argument defaults to 8080:8080 while mounting the user's kubeconfig into the container and configuring plain HTTP transport without authentication. In Docker, -p 8080:8080 binds port 8080 on all host network interfaces (0.0.0.0) rather than localhost only, often bypassing host firewall rules. Anyone on the same local network could connect to port 8080/mcp to read credentials from the mounted kubeconfig or run commands and modify workloads in the user's Kubernetes clusters.

    Fix: Change the default port mapping in server.json from 8080:8080 to 127.0.0.1:8080:8080 so the container port is only reachable from the local machine.

  14. MediumOCI registry manifest publishes unauthenticated MCP HTTP port on all network interfaces

    server.json:57

    The OCI (Docker) package entry in server.json mounts the user's kubeconfig into the container and maps the HTTP MCP endpoint with -p 8080:8080 by default while configuring no authentication. In Docker, 8080:8080 binds port 8080 to 0.0.0.0 across all host network interfaces rather than 127.0.0.1, allowing anyone on the same network to connect directly to /mcp, view kubeconfig details or cluster Secrets, modify workloads, and execute commands inside pods.

    Fix: Restrict the published container port to loopback by changing the default -p value to 127.0.0.1:8080:8080.

  15. MediumDocker MCP registry config exposes unauthenticated server on all network interfaces

    server.json:57

    In the OCI (Docker) package entry of server.json, the default port mapping argument (-p) is set to 8080:8080 while mounting the user's kubeconfig into the container and connecting over plain HTTP (http://localhost:8080/mcp) without authentication. In Docker, -p 8080:8080 binds port 8080 on 0.0.0.0 (all host network interfaces) rather than loopback, and on Linux it can also bypass host firewall input rules. When installed via this OCI registry configuration, anyone on the same local network can connect to port 8080 and invoke Kubernetes management tools (such as pods_exec, pods_run, or resources_create_or_update) using the user's cluster credentials.

    Fix: Change the default -p value in server.json from 8080:8080 to 127.0.0.1:8080:8080 so Docker binds the host port to localhost only.

  16. MediumOCI registry manifest binds the HTTP MCP server port to all network interfaces (0.0.0.0) by default

    server.json:57

    The OCI Docker package definition in server.json mounts the user's kubeconfig into the container and sets the required -p port mapping default to 8080:8080 even though the transport URL targets http://localhost:8080/mcp without authentication arguments. In Docker, -p 8080:8080 binds port 8080 on 0.0.0.0 across all host network interfaces, allowing other devices on the local network (or cross-origin local requests if Origin checks are absent) to reach the MCP server and control the user's Kubernetes clusters.

    Fix: Change the default Docker port mapping in server.json from 8080:8080 to 127.0.0.1:8080:8080 so the container port is only reachable from localhost by default.

  17. MediumDocker registry configuration exposes HTTP MCP port on all network interfaces

    server.json:57

    The OCI container entry in server.json mounts the user's kubeconfig and sets the default Docker -p port mapping to 8080:8080 without a 127.0.0.1 prefix, even though the configured transport URL is http://localhost:8080/mcp and no authentication is enabled by default. In Docker, -p 8080:8080 binds to 0.0.0.0 on the host, allowing anyone on the same local network to connect to port 8080 and invoke MCP tools to read cluster secrets, execute commands inside pods, or modify cluster workloads.

    Fix: Bind the container port exclusively to loopback by changing the default value to 127.0.0.1:8080:8080.

  18. MediumOCI container package exposes unauthenticated MCP HTTP server on all network interfaces

    server.json:57

    The MCP Registry OCI container definition mounts the user's kubeconfig and publishes port 8080 on all host interfaces (-p 8080:8080) while the container image starts the HTTP server with authentication disabled by default. Anyone on the same local network can connect to port 8080 and run Kubernetes tools or read cluster secrets using the mounted kubeconfig. In addition, because Docker forwards traffic to the container's non-loopback bridge IP, the MCP SDK's loopback-only Host header check does not trigger inside the container, leaving local users exposed to browser DNS-rebinding attacks from untrusted websites.

    Fix: Change the default port mapping in server.json to bind only to localhost (127.0.0.1:8080:8080) and require OAuth authentication or explicit Host/Origin validation in container HTTP mode.

  19. MediumHelm chart exposes unauthenticated MCP server and metrics via Ingress by default

    charts/kubernetes-mcp-server/templates/ingress.yaml:1

    The Helm chart enables an external Ingress on path / by default (with TLS unset on standard Kubernetes) while leaving require_oauth disabled and serviceAccount.automountToken enabled. Deploying the chart with the documented install commands exposes /mcp, /metrics, and /stats to the network without authentication, allowing anyone who can reach the Ingress hostname to run MCP tools using the pod ServiceAccount's cluster permissions.

    Fix: Disable ingress.enabled by default, require OAuth or an authenticating proxy and TLS before exposing /mcp externally, and isolate /metrics and /stats on a separate internal metrics_port.

  20. MediumDocker MCP registry package publishes unauthenticated HTTP server on 0.0.0.0

    server.json:57

    The OCI container package definition in server.json mounts the user's kubeconfig and defaults the Docker -p flag to 8080:8080 without a 127.0.0.1 host bind address, even though the transport URL is http://localhost:8080/mcp and OAuth is not enabled. Docker binds -p 8080:8080 on all host network interfaces (0.0.0.0), allowing anyone on the same network to connect to port 8080 and run Kubernetes tools using the mounted credentials.

    Fix: Change the default -p runtime argument in server.json to 127.0.0.1:8080:8080 so Docker only binds the port on the host loopback interface.

  21. LowOAuth JWT validation skips audience check when oauth_audience is unset

    pkg/http/authorization.go:212

    When require_oauth = true and authorization_url are configured without setting oauth_audience, startup validation succeeds without warning and ValidateWithProvider sets SkipClientIDCheck = true. Any valid JWT issued by that OIDC provider for any other application or client in the same realm or tenant is accepted by /mcp, and if [token_exchange] is enabled, the server will exchange that foreign-audience token using its own client credentials for a Kubernetes token.

    Fix: Require oauth_audience to be set whenever require_oauth = true (especially when token_exchange is configured) instead of enabling SkipClientIDCheck when audience is empty.

  22. LowPython wrapper downloads and executes binary at runtime without checksum verification

    python/kubernetes_mcp_server/kubernetes_mcp_server.py:60

    When installed from PyPI (for example via uvx kubernetes-mcp-server), the Python wrapper downloads the platform Go binary from GitHub Releases on first launch, marks it executable (0o755), and runs it without checking a cryptographic hash or signature. Because pip and uv only verify the Python wrapper package and not the runtime GitHub download, a compromised release asset or TLS-intercepting proxy can execute arbitrary native code on the user's computer.

    Fix: Embed per-platform SHA-256 checksums in each released Python package (or publish platform-specific wheels containing the binary) and verify the digest before setting executable permissions.

  23. LowKiali auto-discovery trusts namespaced CRs across all namespaces and forwards Bearer tokens over HTTP

    pkg/kiali/discover.go:114

    When the kiali toolset and experimental_enable_target_compatibility_tool_filters are enabled without an explicit URL, HasKiali lists namespaced Kiali custom resources across all namespaces, constructs https:// and http:// Service URLs from fields in those CRs, and probes /api/status with Authorization: Bearer <token>. In a multi-tenant cluster, a user who can create a Kiali CR in their own namespace can capture the server's Bearer token over cleartext HTTP during automatic discovery and hijack the process-wide discoveredURL so subsequent kiali tool calls send user Bearer tokens to the attacker's service.

    Fix: Restrict Kiali CR discovery to trusted namespaces (such as istio-system or an explicitly configured namespace), scope discovered URLs per target rather than globally, and refuse to send cluster Bearer tokens over cleartext HTTP.

  24. LowObservability HTTP clients forward Bearer tokens across redirects and to untrusted Route or tenant endpoints

    pkg/obs/auth/auth.go:96

    BuildRoundTripper injects the user's or server's Kubernetes Bearer token inside an http.RoundTripper (NewAuthorizationCredentialsRoundTripper), while the Loki, Tempo, Prometheus, and Alertmanager HTTP clients do not disable redirects. Because RoundTripper executes below net/http redirect handling, any 3xx redirect to an external host re-attaches the Authorization: Bearer header, bypassing Go's cross-origin credential stripping. Furthermore, Loki and Tempo discovery resolves namespaced LokiStack/TempoStack Services (over cleartext HTTP by default) and unvalidated OpenShift Route spec.host values across all namespaces while trusting public CAs, allowing prompt injection to leak cluster Bearer tokens to attacker-controlled endpoints.

    Fix: Disable redirects on observability HTTP clients (as NetObserv already does), restrict LokiStack and TempoStack discovery to trusted namespaces, and do not send Kubernetes Bearer tokens over cleartext HTTP or to unverified external Route hosts.

  25. Lowhelm_install chart validation can be bypassed via local paths and HTTPS-to-HTTP redirects

    pkg/helm/helm.go:164

    validateChartReference blocks file:// and http:// schemes, but when allowed_registries is unset (the default), any reference without a URL scheme passes validation and is handed to install.LocateChart, which checks os.Stat and loads local directories or archives from the MCP server's filesystem. LocateChart also uses Helm's default HTTP client without redirect validation or TLSEnforcingTransport, allowing an https:// chart URL (or an open redirect on an allowed registry) to redirect to http:// internal endpoints or cleartext charts.

    Fix: Reject local filesystem paths and path traversal segments in validateChartReference when local charts are not intended, and pass a custom HTTP getter to Helm that enforces require_tls and validates redirect targets against scheme and allowed_registries rules.

  26. Lowvm_create renders unescaped arguments with text/template and applies multi-document YAML

    pkg/toolsets/kubevirt/vm/create/tool.go:209

    vm_create interpolates string arguments (such as name, namespace, workload, instancetype, preference, storage, and networks) into vm.yaml.tmpl using text/template without escaping YAML syntax or newlines, then passes the rendered string to ResourcesCreateOrUpdate, which splits on --- and applies every YAML document. Prompt-injected arguments can inject arbitrary VirtualMachine fields (such as hostDisk volumes) or extra Kubernetes manifests (such as Pods, Secrets, or ClusterRoleBindings) in any namespace, bypassing tool allowlists and vm_create's bounded RBAC metadata.

    Fix: Build the VirtualMachine object as a structured Go map or typed struct marshaled with sigs.k8s.io/yaml instead of text/template, and apply only that single VirtualMachine object.

  27. LowConfirmation rules default to fail-open and miss Server-Side Apply create/update operations

    pkg/config/config.go:475

    Operators who configure confirmation_rules for human approval face two bypasses: confirmation_fallback defaults to allow, meaning any MCP client that does not advertise elicitation support (including HTTP clients that omit the capability during initialization) silently executes matched actions without approval; additionally, resources_create_or_update, pods_run, and vm_create use Server-Side Apply (HTTP PATCH, mapped to verb = patch), so kube-level confirmation rules written for verb = create or verb = update never fire on those tools.

    Fix: Default confirmation_fallback to deny so confirmation rules fail closed when elicitation is unsupported, and match Server-Side Apply PATCH requests against create/update kube-level confirmation rules.

  28. LowOne-click IDE install links and config examples run unpinned @latest package at startup

    README.md:86

    The one-click install deeplinks for VS Code and Cursor, as well as the configuration examples for Claude Desktop and Goose, run npx -y kubernetes-mcp-server@latest. Because -y skips confirmation and @latest is unpinned, the coding agent can automatically download and run newly published npm versions at startup with access to the user's kubeconfig if the upstream npm package were ever compromised.

    Fix: Pin a specific release version in IDE install deeplinks and configuration snippets instead of using @latest.

  29. LowDockerfile uses unpinned :latest base images

    Dockerfile:15

    Both the Go builder stage (golang:latest) and the runtime container stage (ubi-minimal:latest) pull mutable :latest image tags instead of pinned versions and SHA256 digests, reducing build reproducibility and exposing manual image builds to unexpected upstream changes.

    Fix: Pin both FROM instructions in Dockerfile to explicit version tags and immutable @sha256 digests.

  30. LowRecommended MCP client configs auto-install unpinned @latest npm package

    README.md:86

    The setup examples for Claude Desktop, VS Code, Cursor, and Goose CLI configure npx with -y and kubernetes-mcp-server@latest. Running an unpinned @latest tag with automatic installation downloads and executes new npm releases at startup without confirmation, increasing supply-chain risk for a process given access to ~/.kube/config.

    Fix: Pin explicit release versions in the MCP configuration examples instead of using @latest.

  31. LowContainer build uses unpinned :latest base image tags

    Dockerfile:15

    Both the builder stage (golang:latest) and runtime stage (registry.access.redhat.com/ubi9/ubi-minimal:latest) use floating :latest tags without version or SHA-256 digest pinning, reducing build reproducibility and exposing builds to unexpected upstream image changes.

    Fix: Pin both FROM instructions in Dockerfile to specific version tags and immutable @sha256 digests.

  32. LowInstall snippets and one-click links execute unpinned @latest npm package

    README.md:86

    The Getting Started configuration examples and one-click VS Code and Cursor install links configure MCP clients to run npx -y kubernetes-mcp-server@latest. Because the version is unpinned and -y skips confirmation, MCP clients can automatically download and run newly published npm releases at startup, exposing the host machine and kubeconfig if the upstream npm package is ever compromised.

    Fix: Pin a specific release version in configuration examples and IDE install links instead of using @latest.

  33. LowDockerfile uses mutable latest tags for build and runtime base images

    Dockerfile:1

    Both the Go builder stage and the UBI9 minimal runtime stage pull unpinned :latest container tags instead of fixed version tags and SHA-256 digests. Building the image locally or in CI pulls whatever upstream image is currently tagged latest, weakening build reproducibility and supply-chain verification.

    Fix: Pin both FROM instructions in Dockerfile to explicit version tags and immutable SHA-256 digests.

  34. LowOne-click install links and sample configs execute unpinned @latest npm package

    README.md:86

    The Getting Started configurations and one-click VS Code and Cursor install links configure MCP clients to run npx -y kubernetes-mcp-server@latest on startup. Because the package version is not pinned and -y skips confirmation prompts, the client can automatically download and execute newly published versions from npm with access to the user's kubeconfig.

    Fix: Pin a specific release version in recommended MCP client configurations and one-click install links instead of using @latest.

  35. LowDockerfile uses unpinned :latest tags for build and runtime base images

    Dockerfile:1

    Both stages of the Dockerfile pull mutable :latest tags (golang:latest and registry.access.redhat.com/ubi9/ubi-minimal:latest) without version or SHA256 digest pinning. Building the container image at different times can pull unexpected upstream compiler or OS changes without digest verification.

    Fix: Pin both golang and ubi9/ubi-minimal base images in Dockerfile to explicit version tags and SHA256 digests.

  36. LowOne-click IDE install links run unpinned '@latest' npm package automatically

    README.md:112

    The one-click install links for Cursor and VS Code, along with the sample client configurations, run 'npx -y kubernetes-mcp-server@latest' on every startup. Combining '-y' with the mutable '@latest' tag silently downloads and executes new npm releases at runtime without version pinning, exposing users to host compromise if the upstream npm package is ever hijacked.

    Fix: Pin a specific release version in IDE install deeplinks and recommended configuration snippets instead of '@latest'.

  37. LowDockerfile uses unpinned ':latest' base image tags

    Dockerfile:15

    Both the Go builder image ('golang:latest') and the runtime base image ('registry.access.redhat.com/ubi9/ubi-minimal:latest') reference mutable ':latest' tags without version or SHA256 digest pinning, reducing build reproducibility and supply-chain safety when building the container.

    Fix: Pin both FROM instructions in Dockerfile to explicit version tags and SHA256 digests.

  38. LowDockerfile uses unpinned :latest base images

    Dockerfile:1

    Both the Go builder stage (golang:latest) and the Red Hat UBI minimal runtime stage (ubi9/ubi-minimal:latest) in the Dockerfile reference mutable :latest tags rather than pinned versions and SHA-256 digests. Building the container image from source could pull an unexpected or modified upstream image.

    Fix: Pin both FROM instructions in Dockerfile to specific version tags and immutable @sha256 digests.

  39. LowUnpinned latest base images in Dockerfile

    Dockerfile:1

    Both the Go builder stage (golang:latest) and the minimal runtime stage (ubi9/ubi-minimal:latest) pull floating latest tags without a specific version or SHA-256 digest. Building the image at different times pulls changing upstream images, reducing build reproducibility and supply-chain assurance.

    Fix: Pin both FROM instructions in Dockerfile to explicit version tags and SHA-256 image digests.

  40. LowRecommended install configurations auto-download unpinned latest package at startup

    README.md:86

    The Getting Started configurations and one-click install links for VS Code and Cursor run npx -y kubernetes-mcp-server@latest (or uvx with @latest). This causes the package runner to automatically download and execute the newest published version without confirmation whenever the coding agent starts, exposing existing users if a future registry release is compromised.

    Fix: Recommend pinning a specific release version (for example kubernetes-mcp-server@0.x.y) in client configurations and one-click install links.

  41. LowOne-click install links and client examples run unpinned @latest package at startup

    README.md:86

    The Getting Started configuration snippets and one-click install links for VS Code and Cursor run npx -y kubernetes-mcp-server@latest. Every time the coding agent starts the MCP server, npx automatically downloads and executes whatever version is currently tagged latest on npm without confirmation, giving any compromised future package release immediate access to the user's local machine and kubeconfig.

    Fix: Pin a specific release version instead of @latest in one-click install links and example MCP client configurations.

  42. LowUnpinned :latest base images in Dockerfile

    Dockerfile:1

    Both stages of the Dockerfile reference mutable :latest image tags (golang:latest and registry.access.redhat.com/ubi9/ubi-minimal:latest) instead of pinned versions or digests, which means local or CI image builds can silently pull different or compromised upstream base layers over time.

    Fix: Pin both FROM instructions in Dockerfile to explicit version tags and SHA-256 image digests.

  43. LowDockerfile uses unpinned latest tags for builder and runtime base images

    Dockerfile:1

    Both the Go builder stage (golang:latest) and the Red Hat UBI minimal runtime stage (ubi-minimal:latest) reference mutable :latest tags without version or SHA-256 digest pinning, so rebuilding the container image can silently pull modified or compromised upstream layers.

    Fix: Pin both FROM instructions in Dockerfile to specific version tags and SHA-256 digests.

  44. LowInstall guides and one-click links run unpinned @latest packages at runtime

    README.md:86

    The setup snippets and one-click install links for Claude Desktop, VS Code, Cursor, and Goose configure the agent to run npx -y kubernetes-mcp-server@latest (or uvx with @latest). Because -y skips confirmation and @latest is unpinned, the agent automatically downloads and runs whatever version is newest on npm or PyPI at startup, which would expose users' Kubernetes credentials if a future package release were ever compromised.

    Fix: Pin a specific release version in configuration snippets and install deeplinks instead of @latest, or recommend installing a checksum-verified release binary.

  45. LowDockerfile uses unpinned :latest tags for builder and runtime base images

    Dockerfile:1

    Both stages of the Dockerfile reference mutable :latest tags (golang:latest and registry.access.redhat.com/ubi9/ubi-minimal:latest) instead of pinned versions and SHA-256 digests. Building the container image pulls whatever compiler and base OS image were most recently pushed upstream, reducing build reproducibility and supply-chain assurance.

    Fix: Pin both FROM instructions in Dockerfile to explicit version tags and immutable @sha256 digests.

  46. LowOne-click install links and setup snippets run unpinned @latest npm package

    README.md:86

    The recommended client configurations and the one-click install links for VS Code and Cursor configure the agent to run npx -y kubernetes-mcp-server@latest on every startup. Because @latest is unpinned and -y skips confirmation prompts, a compromised future npm release would be automatically downloaded and executed with access to the user's kubeconfig.

    Fix: Pin a specific release version in installation snippets and one-click install deep links instead of using @latest.

  47. LowContainer build uses unpinned latest base image tags

    Dockerfile:1

    Both the Go builder stage (golang:latest) and the runtime stage (registry.access.redhat.com/ubi9/ubi-minimal:latest) use mutable :latest tags without version or SHA-256 digest pinning. Building the image at different times pulls unverified upstream changes, reducing build reproducibility and supply-chain assurance.

    Fix: Pin both the golang builder image and the ubi9/ubi-minimal runtime image to explicit version tags and SHA-256 digests.

  48. LowRecommended client configs and one-click install badges execute unpinned @latest packages via npx

    README.md:86

    The installation examples and one-click install links for Claude Desktop, VS Code, Cursor, and Goose configure the client to run npx -y kubernetes-mcp-server@latest. This silently downloads and executes whatever version was most recently published to npm each time the coding agent starts, exposing users with cluster credentials to immediate impact if the npm package is ever compromised.

    Fix: Pin a specific release version in install examples and one-click install links instead of using @latest, or recommend installing a verified release binary.

  49. LowDockerfile uses unpinned floating :latest tags for builder and runtime base images

    Dockerfile:1

    Both the Go builder stage (golang:latest) and the Red Hat UBI minimal runtime stage (registry.access.redhat.com/ubi9/ubi-minimal:latest) pull floating :latest tags without pinning specific versions or SHA-256 digests, which prevents reproducible builds and silently pulls unreviewed upstream image updates.

    Fix: Pin both FROM instructions in the Dockerfile to explicit version tags and immutable @sha256 digests.

  50. LowHelm chart stores server configuration in a ConfigMap rather than a Secret

    charts/kubernetes-mcp-server/templates/configmap.yaml:2

    Although the configuration reference warns that config.toml can hold inline credentials such as token_exchange.client_auth.client_secret and advises mounting it from a Secret, the Helm chart renders .Values.config into a plaintext ConfigMap. Built-in read-only roles such as view allow reading ConfigMaps even when Secret access is denied, exposing any inline credentials placed in .Values.config to namespace viewers.

    Fix: Render config.toml into a Kubernetes Secret (or support a Secret-backed drop-in directory via --config-dir) and warn in the chart README against placing credentials in .Values.config.

  51. LowOne-click install links and config snippets execute unpinned @latest package

    README.md:86

    The VS Code and Cursor one-click install links and sample MCP client configurations invoke npx -y kubernetes-mcp-server@latest. Combining -y with the mutable @latest tag automatically downloads and runs new npm publications at agent startup without version pinning, increasing supply-chain exposure for the user's kubeconfig.

    Fix: Pin editor deeplinks and example MCP configurations to a specific release version or recommend installing a verified release binary.

  52. LowExample OpenShift NetObserv Helm values expose cluster read access without authentication

    charts/kubernetes-mcp-server/examples/values-openshift-netobserv.yaml:40

    This example Helm values file enables external Ingress while setting cluster_auth_mode to kubeconfig (sharing the pod's cluster-wide view ServiceAccount with every caller) and leaving require_oauth disabled with no authentication proxy sidecar. An operator who copies this example as shown in the chart README exposes unauthenticated read access to cluster resources and network flow logs on the Ingress hostname.

    Fix: Set ingress.enabled to false by default in the example values file, or include OAuth configuration before exposing the server externally.

  53. LowDockerfile uses unpinned latest base image tags

    Dockerfile:1

    Both the Go builder image (golang:latest) and the UBI9 minimal runtime image (registry.access.redhat.com/ubi9/ubi-minimal:latest) use mutable latest tags instead of pinned versions and SHA-256 digests, so container builds automatically pull upstream image changes without digest verification.

    Fix: Pin both FROM instructions in Dockerfile to explicit version tags and SHA-256 image digests.