Skip to main content
View

Attack ChainAIDerived

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

  1. Access
    Attacker controls guest/container on libslirp network
  2. Delivery
    Craft truncated malformed IPv4 packet
  3. Exploit
    Trigger ICMP error in icmp_forward_error()
  4. Execution
    Unclamped length causes heap over-read
  5. Persist
    Leaked host memory returned in ICMP reply
  6. Impact
    Harvest host memory from guest

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK

1 technique across 1 tactic: 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 that the target host uses libslirp as its network backend - e.g. QEMU user-mode ('slirp') networking or rootless Podman's default slirp4netns/libslirp networking - and that the attacker controls a guest VM or container attached to that emulated network, matching the AV:A adjacent position. The attacker must be able to emit raw/malformed IPv4 traffic that causes libslirp to generate an ICMP error (the icmp_forward_error() path). No host authentication or user interaction is needed (PR:N/UI:N). Limiting factors: deployments that do NOT use libslirp networking (e.g. bridged/macvlan/kernel-based VM networking, or CNI-based pod networking that does not route through libslirp) are not exposed via this path; and because the bug is a heap over-read, the attacker cannot choose which host memory is leaked, only that some adjacent host memory is disclosed.

Impact

This is a moderate-severity information-disclosure flaw whose risk is driven almost entirely by the virtualization boundary it crosses rather than by any evidence of exploitation. The CVSS 3.1 vector (AV:A/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N = 7.4) is internally consistent with the description: a guest or container (the 'adjacent' network position) can send a truncated/malformed packet with no host-side privileges or user interaction, and the scope change (S:C) reflects that leaked host-process memory crosses from the host's libslirp process into the guest/container. There is no KEV listing, no EPSS score, and no POC supplied in the input - the only third reference is the upstream libslirp FIX commit (21b33a6c) on freedesktop GitLab, not exploit code - so exploitation status is 'no public exploit identified at time of analysis.' The vuln.today decision label is 'this_week' (priority but not act_now/emergency), which aligns with a serious-but-not-actively-exploited info-leak: real priority for multi-tenant virtualization/container hosts, but not an emergency. One signal to note: impact is confined to confidentiality (C:H, I:N, A:N) and the leak is a heap over-read, so the data returned is unpredictable and not attacker-chosen - this is a memory-disclosure primitive, not code execution, which tempers the real-world severity relative to the 7.4 number.

Exploit ScenarioDerived

An attacker who controls a guest VM or container that uses libslirp user-mode networking (for example QEMU user networking or rootless Podman's default slirp networking) sends a crafted, truncated IPv4 packet that triggers an ICMP error response. Because icmp_forward_error() trusts the IP header's total-length field without clamping it to the actual buffer size, libslirp over-reads adjacent host heap memory and copies it into the quoted-packet portion of the ICMP error returned to the guest, leaking host process memory across the virtualization boundary. No public exploit was identified at time of analysis, only the upstream fix commit.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Nov 03, 2026

An out-of-bounds heap read in libslirp's icmp_forward_error() causes host memory to be copied into the ICMP error reply that libslirp sends back to a guest VM or container, disclosing adjacent heap contents across the virtualization boundary. Affected deployments are those using libslirp as their network backend - QEMU user-mode ('slirp') networking and rootless Podman's slirp4netns/slirp4netns-style networking - with packaged builds tracked for Red Hat Enterprise Linux 8, 9 and 10 and Red Hat OpenShift Container Platform 4 and 5. The flaw is scored 7.4 (CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N) with confidentiality-only impact; no public exploit identified at time of analysis, and exploitation requires an attacker who already controls a guest or container on the emulated network and can emit traffic that drives libslirp down the ICMP error path.

RemediationAI

Apply the libslirp update from your distribution once published: the upstream fix is commit 21b33a6c5588af9f58d15e528fdc1019452708e4 (https://gitlab.freedesktop.org/slirp/libslirp/-/commit/21b33a6c5588af9f58d15e528fdc1019452708e4), which clamps the quoted-packet length to the actual buffer, and Red Hat errata status per branch is tracked at https://access.redhat.com/security/cve/CVE-2026-120830 and https://bugzilla.redhat.com/show_bug.cgi?id=2565424 - note that the data provided lists the upstream commit but no tagged release or per-branch fixed version, so confirm the exact errata version for RHEL 8, 9, 10 and OpenShift Container Platform 4/5 there before recording a fix. Where an update cannot be applied immediately, the exposure is bounded by the network backend in use: deployments that do not route workload traffic through libslirp - bridged, macvlan or tap/kernel-based VM networking, and CNI-based pod networking - are not reachable through icmp_forward_error(), so switching affected guests or rootless containers to those backends removes the path, at the cost of losing the unprivileged, NAT-style connectivity that user-mode slirp and slirp4netns provide (bridged/macvlan setups typically need host network privileges and additional address management). As a lower-cost interim measure, restrict which guests or containers can emit arbitrary raw IPv4 traffic onto the slirp network so that malformed packets cannot reach the ICMP error generation path; this reduces but does not eliminate the attack surface, since any workload able to send crafted IP packets on that segment still triggers the over-read, and it does not remediate the underlying out-of-bounds read.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

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

Technical ContextAI · show details

libslirp is a small userspace TCP/IP stack that implements NAT-style networking for virtual machines and containers: QEMU links it for user-mode ('slirp') networking, and slirp4netns uses it to give rootless containers network access without host privileges. Because libslirp itself synthesises ICMP error responses on behalf of the emulated network, it builds a reply that quotes the beginning of the offending original IPv4 datagram. The code path icmp_forward_error() took the quoted-packet length from a field in the IPv4 header and used it to size a copy without clamping that value to the length of the buffer actually received (CWE-125, out-of-bounds read). A truncated or malformed packet therefore makes libslirp read past the end of its heap buffer and place the over-read bytes into the ICMP error message delivered back to the sender. The CVSS scope change (S:C) reflects that the boundary crossed is the guest/container-to-host one: an unprivileged participant on the emulated network gains a view of host process memory. The disclosure is opportunistic - the attacker can trigger the over-read but cannot select which adjacent heap bytes are returned - so in practice repeated malformed packets are needed to sample memory; the sources do not describe further details of how the length field must be crafted beyond a truncated or malformed packet. Note that the CPE entries identify the affected distribution channels (RHEL 8, 9, 10 and OpenShift Container Platform 4 and 5) rather than separate vulnerable codebases: the exposure follows from whichever of those products ship a libslirp build, and from whether workloads actually use libslirp networking.

Know when Libslirp 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 (redhat) PRIMARY 7.4 HIGH
AV:A/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N
vuln.today AI 7.4 HIGH

A guest/container on the libslirp network (AV:A) with no privileges or interaction triggers an OOB read that leaks host memory across the VM/container boundary (S:C, C:H); no integrity or availability impact is described.

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

Primary rating from Vendor (redhat).

CVSS VectorVendor: redhat

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

DescriptionCVE.org

A flaw was found in libslirp in icmp_forward_error(). When building an ICMP error response, the length of the quoted original IPv4 packet was taken from the IP header without clamping it to the actual buffer length. A truncated or malformed packet could cause an out-of-bounds heap read, leaking host memory into the ICMP error packet returned to a guest or container.

Executive ViewAI

Why It Matters

CVE-2026-120830, a high-severity heap out-of-bounds read in libslirp, exposes host memory contents to any attacker with control of a guest VM or container on an emulated network. The flaw affects QEMU user-mode networking and rootless Podman (slirp4netns) across Red Hat Enterprise Linux 8, 9, 10 and OpenShift 4 and 5. Leadership should prioritize patching because this cross-boundary data leak can undermine the isolation guarantees of virtualization and container platforms, potentially exposing sensitive host data to malicious tenants.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: restrict network access to/from guests and containers, disable ICMP error forwarding if supported, and switch to a different trusted network backend (e.g., macvtap or bridged networking) where feasible.

Threat Intelligence Overview

EPSS Score
0.2%
Top 87% exploitable
Prevalence
High
libslirp underlies QEMU user-mode and rootless container networking across RHEL and OpenShift fleets
Social Media
1
Sightings
Data Quality
4 sources
Confidence: Medium

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 No
EPSS 0.2%
Patch available No
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Controlled
Automatable· derived
No
Human Impact
High

Priority Score

37
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +37
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Affected Products (CPE)CVE.org

cpe:2.3:a:red_hat:red_hat_enterprise_linux_10:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_8:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_9:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_openshift_container_platform_4:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_openshift_container_platform_4:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_openshift_container_platform_4:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_openshift_container_platform_5:*:*:*:*:*:*:*:*

Related Vulnerabilities in libslirp Memory Safety Vulnerabilities

View all 2
CVE-2020-1983 MEDIUM POC
6.5 Apr 22

A use after free vulnerability in ip_reass() in ip_input.c of libslirp 4.2.0 and prior releases allows crafted packets t

CVE-2019-14378 HIGH POC
8.8 Jul 29

ip_reass in ip_input.c in libslirp 4.0.0 has a heap-based buffer overflow via a large packet because it mishandles a cas

CVE-2020-29130 MEDIUM POC
4.3 Nov 26

slirp.c in libslirp through 4.3.1 has a buffer over-read because it tries to read a certain amount of header data even i

CVE-2020-7211 HIGH
7.5 Jan 21

tftp.c in libslirp 4.1.0, as used in QEMU 4.2.0, does not prevent ..\ directory traversal on Windows. Rated high severit

CVE-2019-15890 HIGH
7.5 Sep 06

libslirp 4.0.0, as used in QEMU 4.1.0, has a use-after-free in ip_reass in ip_input.c. Rated high severity (CVSS 7.5), t

CVE-2026-9539 MEDIUM
6.5 Jun 24

Out-of-bounds heap read and integer underflow in libslirp's TCP urgent data handler (sosendoob) exposes gigabytes of hos

CVE-2020-10756 MEDIUM
6.5 Jul 09

An out-of-bounds read vulnerability was found in the SLiRP networking implementation of the QEMU emulator. Rated medium

CVE-2020-8608 MEDIUM
5.6 Feb 06

In libslirp 4.1.0, as used in QEMU 4.2.0, tcp_subr.c misuses snprintf return values, leading to a buffer overflow in lat

CVE-2020-7039 MEDIUM
5.6 Jan 16

tcp_emu in tcp_subr.c in libslirp 4.1.0, as used in QEMU 4.2.0, mismanages memory, as demonstrated by IRC DCC commands i

CVE-2020-29129 MEDIUM
4.3 Nov 26

ncsi.c in libslirp through 4.3.1 has a buffer over-read because it tries to read a certain amount of header data even if

CVE-2021-3595 LOW
3.8 Jun 15

An invalid pointer initialization issue was found in the SLiRP networking implementation of QEMU. Rated low severity (CV

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