Nov 19, 2026·9 min read·2 visits
A path validation vulnerability (CWE-22) in the LLMKube Kubernetes operator allows low-privileged namespace users to read arbitrary files from the controller pod and worker nodes via unvalidated local paths in Model custom resources. Fixed in v0.9.0 by disabling local paths by default and introducing an explicit directory allowlist.
LLMKube prior to version 0.9.0 fails to restrict local filesystem paths and file:// URIs supplied in the Model.spec.source field of custom resources. A namespace-level user with permission to create or modify Model and InferenceService resources can traverse the filesystem of the operator controller pod or mount arbitrary host node files via a HostPathVolumeSource. This enables unauthorized disclosure of high-privilege Kubernetes ServiceAccount tokens and underlying host credentials.
LLMKube (github.com/defilantech/LLMKube) is a Kubernetes operator designed to manage and deploy self-hosted Large Language Model (LLM) inference workloads across heterogeneous hardware environments, including NVIDIA CUDA, AMD Vulkan, and Apple Silicon Metal. The operator provides two primary Custom Resource Definitions (CRDs): Model and InferenceService under the inference.llmkube.dev/v1alpha1 API group. These custom resources allow cluster users to declare model weights from various sources—such as remote HTTP repositories, Hugging Face hubs, PersistentVolumeClaims (PVCs), or local filesystems—and attach them to inference serving backends.
In versions prior to 0.9.0, the ModelReconciler and InferenceServiceReconciler controllers accept arbitrary absolute paths (/path/to/file) and file:// URIs in the Model.spec.source field without enforcing directory boundary restrictions. When a user specifies a local source, the operator treats the path as a trusted reference in two distinct execution contexts: the operator controller pod itself and the target Kubernetes worker node where the inference workload is scheduled.
Tracked as CVE-2026-68903 (and GHSA-jw3m-8q7m-f35r), this flaw is classified under CWE-22 (Improper Limitation of a Pathname to a Restricted Directory). In a multi-tenant Kubernetes cluster, namespace users granted standard RBAC permissions to manage Model and InferenceService resources are typically isolated within their assigned namespace. However, because the operator does not validate Model.spec.source against an approved base directory, a low-privileged user can cross tenant boundaries to read arbitrary files from the operator controller container or mount sensitive host node directories into an attacker-controlled pod.
The root cause of CVE-2026-68903 is the complete absence of path canonicalization and prefix allowlisting when processing local model sources across two separate reconciliation sinks. In internal/controller/source.go, the operator determines whether a model source resides on the local filesystem using the isLocalSource helper function. Prior to version 0.9.0, this function simply checked whether the input string began with file:// or /, and getLocalPath stripped the file:// scheme prefix if present.
The first vulnerable sink resides in the ModelReconciler inside internal/controller/model_controller.go. When reconciling a Model resource whose source satisfies isLocalSource, the controller calls copyLocalModel to stage the model artifact into the operator's cache storage. Because copyLocalModel passes the unvalidated result of getLocalPath(model.Spec.Source) directly to os.Open, the file operation executes within the filesystem namespace and security context of the llmkube-controller-manager pod. Any file readable by the controller process—most notably its mounted Kubernetes ServiceAccount bearer token at /var/run/secrets/kubernetes.io/serviceaccount/token—can be opened and copied into the shared model cache.
The second vulnerable sink occurs during workload generation in internal/controller/inferenceservice_controller.go and internal/controller/model_storage.go. When modelCache.enabled is active (the default configuration in pre-0.9.0 Helm charts) or when configuring local host storage for an InferenceService referencing a local Model, the operator constructs a Kubernetes Deployment for the inference server. In doing so, it appends a volume backed by corev1.HostPathVolumeSource whose Path parameter is populated directly from getLocalPath(model.Spec.Source).
Because Kubernetes hostPath volumes mount directories or files directly from the underlying worker node's root filesystem into the workload container, failing to restrict Model.spec.source allows any user capable of creating an InferenceService to mount arbitrary node files into their namespace pod. Neither the controller sink nor the HostPathVolumeSource sink verified whether the requested path resolved beneath a designated model storage directory.
Prior to commit ec2647fd4557962a971a1bc9435790b8e77ce961, source classification in internal/controller/source.go relied on case-sensitive prefix checks and provided no mechanism to validate local paths against an administrative policy:
// Vulnerable implementation prior to v0.9.0
func isLocalSource(source string) bool {
return strings.HasPrefix(source, "file://") || strings.HasPrefix(source, "/")
}
func getLocalPath(source string) string {
if strings.HasPrefix(source, "file://") {
return strings.TrimPrefix(source, "file://")
}
return source
}To remediate the vulnerability, commit ec2647fd4557962a971a1bc9435790b8e77ce961 (PR #981) introduced an opt-in --allowed-host-path-roots command-line flag (mapped to modelSource.allowedHostPathRoots in the Helm chart) and implemented validateLocalSourceAllowed in internal/controller/source.go:
// Patched implementation in internal/controller/source.go
func isLocalSource(source string) bool {
return hasSchemeFold(source, "file://") || strings.HasPrefix(source, "/")
}
func validateLocalSourceAllowed(source string, allowedRoots []string) error {
if !isLocalSource(source) {
return nil
}
p := getLocalPath(source)
if !filepath.IsAbs(p) {
return fmt.Errorf("local model source must be an absolute path: %q", source)
}
// Canonicalize the path to resolve '../' traversal sequences
clean := filepath.Clean(p)
allowed := false
for _, root := range allowedRoots {
if root == "" || !filepath.IsAbs(root) {
continue
}
r := filepath.Clean(root)
// Verify exact match or strict subdirectory prefix with path separator
if clean == r || strings.HasPrefix(clean, r+string(filepath.Separator)) {
allowed = true
break
}
}
if !allowed {
if hasNoUsableRoot(allowedRoots) {
return fmt.Errorf("local/hostPath model sources are disabled: no allowed roots configured "+
"(set modelSource.allowedHostPathRoots); refusing source %q (GHSA-jw3m-8q7m-f35r)", source)
}
return fmt.Errorf("local model source %q is not within any allowed root %v (GHSA-jw3m-8q7m-f35r)", source, allowedRoots)
}
return nil
}The patch enforces validation across three distinct layers in the controller architecture. First, ModelReconciler.Reconcile invokes rejectDisallowedLocalSource before dispatching any file operations. If validateLocalSourceAllowed returns an error, the reconciler transitions the Model resource to PhaseFailed with reason SourceNotAllowed and returns without requeuing. Second, InferenceServiceReconciler.Reconcile runs validateLocalSourceAllowed before building deployment specifications.
Third, as a defense-in-depth measure inside internal/controller/model_storage.go, buildModelStorageConfig verifies the source against allowedHostPathRoots before constructing volume definitions. If an unapproved local source reaches the storage builder, it substitutes disallowedLocalSourceStorageConfig, which replaces the HostPathVolumeSource with an isolated EmptyDirVolumeSource and injects an init container that terminates immediately with exit code 1.
> [!NOTE]
> Fix Completeness Assessment: The patch also introduces case-insensitive scheme matching (hasSchemeFold) so that mixed-case prefixes like FILE:// cannot bypass isLocalSource, and adds an SSRF guard (internal/controller/safehttp.go) blocking private, loopback, and link-local IP ranges for HTTP(S) model sources. One boundary limitation remains: filepath.Clean performs lexical path resolution and does not evaluate filesystem symlinks (filepath.EvalSymlinks). Consequently, if an administrator explicitly allowlists a directory where untrusted users have write access to create symlinks, a symlink pointing outside the allowlisted root could still be traversed. Administrators must ensure allowlisted host directories are only writable by trusted node administrators.
Exploiting CVE-2026-68903 requires authenticated access to a Kubernetes cluster running LLMKube < 0.9.0 with RBAC permissions to create Model and InferenceService resources within at least one namespace. No direct exec access to the controller namespace (llmkube-system) or privileged PodSecurityStandards admission permissions in the tenant namespace are required, because the operator controller itself creates the privileged hostPath deployment or performs the local file read.
To extract the operator controller's Kubernetes ServiceAccount token via the copyLocalModel sink, an attacker submits a Model manifest referencing the in-container token path:
apiVersion: inference.llmkube.dev/v1alpha1
kind: Model
metadata:
name: controller-token-leak
namespace: tenant-workloads
spec:
source: "file:///var/run/secrets/kubernetes.io/serviceaccount/token"
format: ggufWhen ModelReconciler processes controller-token-leak, isLocalSource evaluates to true and copyLocalModel opens /var/run/secrets/kubernetes.io/serviceaccount/token inside the llmkube-controller-manager pod. The controller copies the JWT into the shared model cache PVC under the deterministic cache key generated for the source path. The attacker can then deploy a workload mounting the shared cache or inspect the staged model file to retrieve the controller's cluster-scoped ServiceAccount token.
To read arbitrary files directly from a Kubernetes worker node, the attacker creates a Model pointing to a sensitive host path and pairs it with an InferenceService resource:
apiVersion: inference.llmkube.dev/v1alpha1
kind: Model
metadata:
name: node-file-target
namespace: tenant-workloads
spec:
source: "/etc/kubernetes/kubelet.conf"
format: gguf
---
apiVersion: inference.llmkube.dev/v1alpha1
kind: InferenceService
metadata:
name: node-file-reader
namespace: tenant-workloads
spec:
modelRef: node-file-target
replicas: 1Upon reconciling node-file-reader, InferenceServiceReconciler creates a Deployment in tenant-workloads containing a HostPathVolumeSource mapped to /etc/kubernetes/kubelet.conf and mounted into the inference container (typically at /models/model.gguf). The attacker can then run kubectl exec into the spawned pod in their namespace or inspect container startup logs to read the mounted host file.
CVE-2026-68903 carries a CVSS v3.1 base score of 7.7 (High) with the vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N. The Attack Vector is Network (AV:N) and Attack Complexity is Low (AC:L), as exploitation is performed through standard Kubernetes API requests without timing dependencies. Privileges Required is Low (PR:L), reflecting the need for namespace-scoped RBAC permissions to create Model and InferenceService objects. User Interaction is None (UI:N).
The Scope is Changed (S:C) and Confidentiality Impact is High (C:H). While the attacker initiates the action within a restricted tenant namespace, the vulnerable execution sinks operate within the security domain of the cluster-wide operator pod and the underlying Kubernetes worker node OS. Note that while the primary primitive is an arbitrary file read (I:N/A:N), disclosing the credentials protected by those files frequently leads to full cluster compromise.
Specifically, reading /var/run/secrets/kubernetes.io/serviceaccount/token from the controller pod grants the attacker all RBAC permissions assigned to the LLMKube operator ServiceAccount, which typically includes cluster-wide permissions to manage deployments, services, persistent volumes, and custom resources across all namespaces. Furthermore, mounting host node paths such as /var/lib/kubelet/pki/, /etc/kubernetes/, or container runtime state directories allows the attacker to extract node client certificates and pivot to the Kubernetes control plane.
Operators and cluster administrators running LLMKube must upgrade to version 0.9.0 or later (incorporating commit ec2647fd4557962a971a1bc9435790b8e77ce961). Version 0.9.0 introduces a breaking security enhancement: local and hostPath model sources (file:// and /...) are disabled by default because --allowed-host-path-roots (modelSource.allowedHostPathRoots in Helm) defaults to an empty list ([]).
If node-local model serving is not required in your environment, keep modelSource.allowedHostPathRoots empty. If bare-metal or node-local model directories must be used, explicitly configure a dedicated subdirectory in your Helm values.yaml:
modelSource:
allowedHostPathRoots:
- /srv/llmkube/modelsNever configure broad system directories such as /, /var, /etc, or /mnt in allowedHostPathRoots, and ensure that any allowlisted host directory is owned by root and not writable by untrusted workloads to prevent symlink traversal.
> [!WARNING]
> Upgrading the operator binary blocks new or reconciled resources from using disallowed local paths, but pre-existing InferenceService deployments created prior to the upgrade may retain active hostPath volumes until reconciled or recreated. After upgrading to 0.9.0, audit all existing Model resources across the cluster and delete any unauthorized workloads:
# Audit all Model resources for local paths or file:// schemes
kubectl get models.inference.llmkube.dev --all-namespaces \
-o jsonpath='{range .items[*]}{.metadata.namespace}{"/"}{.metadata.name}{": "}{.spec.source}{"\n"}{end}' \
| grep -iE '^(.*: )(file://|/)'
# Audit existing Pods for host-model hostPath volumes
kubectl get pods --all-namespaces \
-o jsonpath='{range .items[*]}{.metadata.namespace}{"/"}{.metadata.name}{": "}{.spec.volumes[*].hostPath.path}{"\n"}{end}' \
| grep -v ': $'In environments where an immediate upgrade to 0.9.0 is not possible, administrators should deploy a ValidatingAdmissionPolicy (or Kyverno/OPA Gatekeeper policy) that rejects any Model resource creation or update where spec.source matches (?i)^file:// or ^/.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
LLMKube defilantech | < 0.9.0 | 0.9.0 |
| Attribute | Detail |
|---|---|
| Vulnerability Class | CWE-22: Improper Limitation of a Pathname to a Restricted Directory |
| CVSS v3.1 Score | 7.7 High (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N) |
| Attack Vector | Network (Kubernetes API Custom Resource Manipulation) |
| Affected Component | LLMKube Operator (ModelReconciler & InferenceServiceReconciler) |
| Primary Impact | Arbitrary file read from controller pod and worker node filesystems |
| Patched Version | v0.9.0 |
| CISA KEV Status | Not Listed |
The software uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the software does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory.
CVE-2026-73864 is a CWE-494 (Download of Code Without Integrity Check) vulnerability in the Node.js package install-artifact-from-github prior to version 1.7.0. The tool downloads precompiled native Node.js C/C++ addons (.node binaries) from GitHub Releases or configurable mirrors and writes them directly to disk without verifying cryptographic checksums or signatures. Furthermore, its HTTP client follows cross-protocol redirects from HTTPS to plaintext HTTP. When the consuming application loads the downloaded addon via require(), the unverified native binary executes immediately within the Node.js process, permitting arbitrary native code execution if an attacker compromises a GitHub release asset, poisons a configured mirror, or intercepts downgraded network traffic.
CVE-2026-75521 is an unauthenticated remote authentication bypass vulnerability in Miren Runtime prior to version 0.11.1. The QUIC/HTTP3 RPC service configures its TLS listener with tls.RequestClientCert, which requests client certificates without validating them against the cluster Certificate Authority. Simultaneously, the RPC authenticators extract caller identities directly from PeerCertificates[0] without checking VerifiedChains, granting any caller presenting a self-signed certificate the AuthMethodCert identity and a complete Role-Based Access Control (RBAC) bypass.
CVE-2026-63129 is a high-severity SQL injection vulnerability (CWE-89) in the @connorbritain/mssql-mcp-core library and its downstream implementations (mssql-mcp-server, mssql-mcp-reader, and mssql-mcp-writer). The flaw results from the direct concatenation of unvalidated database identifiers, filter predicates, and enum parameters into T-SQL batches passed to the node-mssql Request.query() interface. Because pre-execution row count and preview queries execute before safety confirmation flags are checked, an attacker with access to invoke Model Context Protocol (MCP) tools can bypass confirmation controls and execute arbitrary stacked T-SQL statements.
CVE-2026-73504 (GHSA-jc42-994r-vvwp) is a credential exposure vulnerability in ING Bank's cassandra-jdbc-wrapper (com.ing.data:cassandra-jdbc-wrapper). Resulting from an incomplete remediation of AIKIDO-2024-10565, the log sanitization routines in DriverUtil redact the password property but fail to redact the token property. When DEBUG logging is enabled, connection properties and JDBC URLs containing DataStax Astra DB bearer tokens are written in plaintext to application logs, enabling local users or log aggregation readers to harvest active database credentials.
A denial-of-service vulnerability (CWE-400) exists in PGPainless versions prior to 1.7.8 and 2.0.x prior to 2.0.4 within the MessageInspector and InlineDetachImpl components. These components manually iterate over OpenPGP packet streams without enforcing the global 16-layer maximum nesting limit (MAX_LAYER_DEPTH). An unauthenticated remote attacker can supply a specially crafted OpenPGP message containing deeply nested PGPCompressedData packets to trigger unbounded recursive decompression, resulting in CPU starvation and Java Virtual Machine (JVM) heap exhaustion.
An authorization bypass and broken object-level access control vulnerability exists in djangocms-versioning prior to version 2.6.1. The check_discard and check_edit_redirect condition pipelines on the Version model omitted the user_can_change permission predicate. Because the corresponding administrative views retrieve target versions directly by their URL primary key and depend entirely on these condition pipelines for object-level access control, authenticated staff users without per-object change permissions can permanently delete draft versions or spawn new draft versions from published content.