KEDA CVE-2025-68476
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain RBAC to modify TriggerAuthentication
-
DeliveryCraft resource with arbitrary serviceAccount file path
-
ExploitPoint Vault address to attacker server
-
ExecutionKEDA reads file and sends contents to attacker
-
ImpactExfiltrate node secrets/keys/system files
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires Kubernetes RBAC permission to create or modify a TriggerAuthentication resource in the cluster, and the target KEDA resource must use TriggerAuthentication configured for HashiCorp Vault authentication (spec.hashiCorpVault.credential.serviceAccount). The attacker also needs to direct the Vault authentication request to a server they control to receive the exfiltrated file contents. The primary limiting factor is the PR:H prerequisite: only users with create/update rights on TriggerAuthentication can exploit it - the advisory's sole effective workaround is strictly restricting those RBAC permissions to trusted users. Affected versions are KEDA <2.17.3 and 2.18.0-2.18.3 (fixed in 2.17.3, 2.18.3, and >=2.19.0). |
| Impact | This is a genuine but access-gated confidentiality issue rather than a critical broadly-exploitable flaw. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:H/UI:N/VC:H/SC:H, score 8.2) is internally consistent with the description: exploitation requires PR:H - specifically Kubernetes RBAC permission to create or modify a TriggerAuthentication custom resource - and the SC:H (subsequent system High) correctly reflects that the read escapes the KEDA pod to reach the underlying node's filesystem. This is not a PR:N remote-unauth bug; the 'AV:N' reflects that TriggerAuthentication objects are submitted via the Kubernetes API, but the privilege prerequisite is the real gate. Supporting signals are muted: EPSS is 0.55% (44th percentile), there is no CISA KEV listing (no public exploit identified at time of analysis), and no public POC. The signals are consistent - moderate CVSS, low EPSS, no active exploitation - indicating a real-but-targeted risk requiring an existing foothold with meaningful cluster RBAC, not a mass-exploitation candidate. The source-code diff independently confirms the root cause (an unvalidated os.ReadFile on the user-supplied ServiceAccount path, replaced by a JWT-validating reader), raising confidence that the fix and description are accurate. |
| Exploit ScenarioDerived | An attacker who has already obtained Kubernetes RBAC rights to create or modify TriggerAuthentication resources (e.g., a low-trust tenant, compromised CI service account, or malicious insider) crafts a TriggerAuthentication pointing spec.hashiCorpVault.credential.serviceAccount at an arbitrary node path such as /etc/passwd or a mounted secret, and sets the Vault address to a server they control. When KEDA authenticates, it reads that file and sends its contents to the attacker's server, exfiltrating node secrets and system files. No public POC or exploit code is currently identified. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 25, 2026
Arbitrary file read in KEDA (Kubernetes Event Driven Autoscaling) affects operator versions prior to 2.17.3 and 2.18.0 through 2.18.2 (fixed in 2.17.3, 2.18.3 and 2.19.0+), allowing an authenticated attacker who holds Kubernetes RBAC permission to create or modify a TriggerAuthentication resource to direct the content of any file on the KEDA pod's node - such as service account tokens, secrets, or /etc/passwd - to an attacker-controlled HashiCorp Vault endpoint during the Vault authentication handshake. This is an access-gated confidentiality issue rather than a broadly exploitable flaw: the PR:H prerequisite (write access to TriggerAuthentication) is the main limiting factor, and the advisory's only effective workaround is strict RBAC restriction on that resource. No public exploit code has been identified at time of analysis, and EPSS is low at 0.55% (44th percentile), with no CISA KEV listing.
RemediationAI
Upgrade the KEDA operator to a patched release: vendor-released patch: 2.17.3, 2.18.3, or 2.19.0 and later (the fix commit is 15c5677f65f809b9b6b59a52f4cf793db0a510fd, and full details are in advisory GHSA-c4p6-qg4m-9jmr). If immediate upgrade is not possible, apply the advisory's stated workaround by strictly restricting Kubernetes RBAC so that only trusted, authorized identities hold create or update permissions on TriggerAuthentication resources - this removes the attacker's ability to supply a malicious serviceAccount path, at the cost of centralizing change control for that resource. As additional compensating controls, limit network egress from the KEDA operator namespace so it can only reach the legitimate Vault endpoint, since exfiltration depends on sending the captured file content to an attacker-controlled server; and where Vault authentication is not required, avoid TriggerAuthentication configurations that use spec.hashiCorpVault.credential.serviceAccount entirely. After patching, verify the operator image reports 2.17.3, 2.18.3 or >= 2.19.0 and audit existing TriggerAuthentication objects for unexpected serviceAccount paths. Note that no vendor-released patch is available for unsupported branches, and the only mitigations there are the RBAC and network-egress restrictions above, which trade convenience for reduced exposure.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in go
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerability is a path traversal (CWE-22) in the HashiCorp Vault integration of the KEDA operator. In pkg/scaling/resolver/hashicorpvault_handler.go, the Vault handler read the file specified by spec.hashiCorpVault.credential.serviceAccount directly via os.ReadFile and used its contents as the JWT sent in the Vault login request, without validating that the path actually pointed at the Kubernetes projected service account token (default /var/run/secrets/kubernetes.io/serviceaccount/token). Because the file content is transmitted to whatever Vault address is configured, an attacker who can set that path can read arbitrary files readable by the KEDA operator process and exfiltrate them over the outbound Vault request. The upstream fix introduces pkg/scaling/resolver/k8s_validator.go with readKubernetesServiceAccountProjectedToken(), which parses the file as a JWT and rejects it unless the subject claim begins with 'system:serviceaccount:', and it also replaces the hard-coded token path with a named constant. The change turns the read into a validated, token-shaped-only operation, closing the arbitrary-file-read primitive while preserving legitimate Vault JWT authentication via TriggerAuthentication.
Know when Kubernetes gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:H/UI:N/VC:H/VI:N/VA:N/SC:H/SI:N/SA:N
Attacker submits a malicious TriggerAuthentication via the K8s API (AV:N) needing high RBAC privileges (PR:H); reading node files beyond the pod boundary is a scope change (S:C) with confidentiality-only impact (C:H, I/A:N).
Primary rating from Vendor (github).
CVSS VectorVendor: github
DescriptionCVE.org
KEDA is a Kubernetes-based Event Driven Autoscaling component. Prior to versions 2.17.3 and 2.18.3, an Arbitrary File Read vulnerability has been identified in KEDA, potentially affecting any KEDA resource that uses TriggerAuthentication to configure HashiCorp Vault authentication. The vulnerability stems from an incorrect or insufficient path validation when loading the Service Account Token specified in spec.hashiCorpVault.credential.serviceAccount. An attacker with permissions to create or modify a TriggerAuthentication resource can exfiltrate the content of any file from the node's filesystem (where the KEDA pod resides) by directing the file's content to a server under their control, as part of the Vault authentication request. The potential impact includes the exfiltration of sensitive system information, such as secrets, keys, or the content of files like /etc/passwd. This issue has been patched in versions 2.17.3 and 2.18.3.
Executive ViewAI
KEDA, the event-driven autoscaling component used across many Kubernetes clusters, contains a high-severity flaw that allows a user who already holds rights to manage TriggerAuthentication resources to read arbitrary files from the node hosting the KEDA operator, including service account tokens and secrets. The exposure is narrow by design - it requires an attacker to have already been granted that specific write access - so the practical risk concentrates on platform and DevOps teams with broad cluster permissions rather than the general user base. Leadership should care because captured tokens and credentials from those files could enable lateral movement and privilege escalation into production workloads, and the advisory's only effective workaround is tightening RBAC on that resource.
Apply vendor patch (fixed in KEDA 2.17.3, 2.18.3, and 2.19.0+). Where upgrading cannot be completed immediately, enforce strict RBAC restriction limiting who may create or modify TriggerAuthentication resources, per the vendor advisory's stated workaround, and monitor for unauthorized changes to those resources.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
More in Kubernetes
View allA critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access
Credential-harvesting malware compromised 84 versions of 42 TanStack npm packages on 2026-05-11 via chained GitHub Actio
Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c
Kubernetes API server in all versions allow an attacker who is able to create a ClusterIP service and set the spec.exter
A security issue was discovered in Kubernetes where a user that can create pods on Windows nodes may be able to escalate
Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. Rated critical severity (CVSS 9.9), this vulne
Unauthenticated remote attackers can trigger complete database overwrites, server-side file reads, and SSRF attacks agai
The Kubernetes integration in GitLab Enterprise Edition 11.x before 11.2.8, 11.3.x before 11.3.9, and 11.4.x before 11.4
Fluentd configuration injection in the kube-logging Logging operator before 6.6.0 allows a namespace-scoped user who can
Authenticated Typebot users can abuse the webhook block (HTTP Request component) in versions prior to 3.13.1 to issue ar
Same weakness CWE-22 – Path Traversal
View allSame technique Path Traversal
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| SUSE Linux Enterprise Server 16.1 | Affected |
| SUSE Linux Enterprise Server for SAP applications 16.1 | Affected |
NVD
CVE.org
EPSS
GitHub
Exploit-DB