/

CVE-2026-44932

Severity:

HIGH RISK

(8.8)

OS Command Injection (CWE-78) in wicked DHCP Client

CVE-2026-44932

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution on client via network-local DHCP

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

The wicked DHCP client before version 0.6.79 passes unsanitized strings from DHCP replies directly into command execution paths.

A malicious DHCP server on the same network can leverage this to execute arbitrary code on the victim machine when it processes crafted DHCP responses.

Affected context

This vulnerability occurs in environments where the wicked DHCP client is used to obtain network configuration from DHCP servers.

It is relevant on systems that automatically trust DHCP responses on connected interfaces, such as laptops or servers joining untrusted or semi-trusted networks (e.g., public Wi-Fi, shared VLANs).

The issue is most impactful when the DHCP client runs with elevated privileges and when there are no additional network admission controls limiting who can operate a DHCP server on the segment.

Exploit preconditions

  • Attack surface: Network-local, limited to the Layer 2 segment where DHCP traffic is visible.
  • Required access: Ability to run or spoof a DHCP server or otherwise inject DHCP responses seen by the wicked client.
  • Trigger point: Processing of DHCP replies by the wicked client during lease acquisition or renewal.
  • Why exploitation is possible: Untrusted string fields from DHCP replies are passed into command execution contexts without proper sanitization, enabling attacker-controlled shell metacharacters or command fragments to be interpreted.

Why this happens

The root cause aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

The wicked DHCP client incorporates data from DHCP response fields (such as options or hostnames) into commands or scripts without robust escaping, validation, or separation between data and control.

Because the code treats network-supplied strings as safe and directly embeds them in shell or system calls, an attacker controlling those strings can break out of the intended command structure and inject additional commands.

Potential impact

  • Execution of arbitrary OS commands with the privileges of the DHCP client process.
  • Local system compromise, including installation of malware or backdoors.
  • Exfiltration or tampering with sensitive configuration and data on the affected host.
  • Use of the compromised machine as a pivot point for lateral movement within the network.
  • Disruption of network connectivity or configuration for the target system.

General mitigation guidance

Effective mitigation centers on treating DHCP input as untrusted data and separating it from command execution:

  • Use APIs that do not invoke a shell (e.g., exec-style calls with argument arrays) instead of constructing shell command strings.
  • Rigorously validate and normalize all DHCP-derived strings, allowing only expected characters and formats (e.g., strict hostname or IP address patterns).
  • Avoid embedding DHCP values directly into scripts; instead, pass them as data parameters, environment variables, or through controlled configuration interfaces.
  • Run the DHCP client with least privilege and apply OS-level sandboxing, MAC policies, or containers to limit the blast radius of a compromise.
  • Restrict which interfaces accept DHCP and avoid using DHCP on highly sensitive management networks where feasible.

How teams detect issues like this

Organizations can look for this vulnerability class through both code-centric and runtime approaches:

  • Static analysis: Define rules to flag string concatenation into system(), popen(), shell scripts, or similar OS command APIs where input ultimately traces back to network packets or DHCP options.
  • Code review: Pay attention to paths where DHCP option values, hostnames, or other network-derived strings are passed into shells, interpreted scripts, or configuration generators without whitelist validation.
  • Configuration and policy checks: Enforce development guidelines that prohibit shell command construction from network inputs and require safe wrappers or libraries.
  • Runtime monitoring: Use host intrusion detection to flag unusual child processes spawned by the DHCP client, especially commands containing network-derived values.

Sources

SourceLink
bugzilla.suse.combugzilla.suse.com/show_bug.cgi?id=1265221
github.comgithub.com/openSUSE/wicked/releases/tag/version-0.6.79
lists.suse.comlists.suse.com/pipermail/sle-security-updates/2026-June/026688.html
lists.suse.comlists.suse.com/pipermail/sle-security-updates/2026-June/026689.html
lists.suse.comlists.suse.com/pipermail/sle-security-updates/2026-June/026690.html
lists.suse.comlists.suse.com/pipermail/sle-security-updates/2026-June/026691.html

Frequently asked

questions

Not directly over arbitrary internet paths. Exploitation typically requires being on the same Layer 2 network segment as the victim or otherwise able to present DHCP replies to the wicked client, such as by operating a rogue DHCP server on a shared network.

No traditional authentication is needed, but the attacker must control or interfere with DHCP on the network. This usually means physical or logical access to the same LAN, Wi-Fi network, or virtual network segment where the target device requests DHCP configuration.

The safest pattern is to eliminate shell-based command construction from DHCP-derived values entirely, using non-shell APIs to apply configuration, combined with strict validation and canonicalization of all DHCP fields before use.

Treat all network input as untrusted, enforce strong input validation and allow-lists, avoid building shell commands from external data, and adopt secure coding guidelines plus static analysis checks that specifically flag command injection patterns during development and code review.

Find out what's already
exploitable in your codebase.