A web client that peeks one byte past the end of the page it just downloaded
libsoup is GNOME's HTTP client/server library — it ships with GNOME (Epiphany, Evolution, GNOME Online Accounts), gets pulled in by anything linking libsoup-2.4 or libsoup-3, and lives on basically every desktop Linux box and many embedded appliances (Power HMC, IBM appliances, network gear). The flaw is in skip_insignificant_whitespace() inside the content sniffer, which is the routine libsoup uses to guess MIME types from response bodies. A crafted HTTP response from a server can cause the client to read one byte past the end of a heap buffer. Affected: libsoup < 3.6.5 for the 3.x line, plus the legacy 2.4 series that downstreams (Debian, Ubuntu, RHEL, SUSE, Azure Linux) backport into.
Red Hat / GHSA rated this HIGH (7.0) on the back of CVSS C:L/I:L/A:H, because in theory a one-byte over-read can leak adjacent heap metadata or crash the process. In practice it's the client that's vulnerable, the attack complexity is HIGH (the attacker needs to land specific heap layout and serve a malicious response that the client actually content-sniffs), and the realistic outcome is a process crash or at best a one-byte info leak — not RCE. The vendor score is generous; reality is closer to MEDIUM.
4 steps from start to impact.
Lure victim libsoup client to attacker HTTP endpoint
python -m http.server, nc, custom Go responder.- Victim host runs an application linked against libsoup < 3.6.5
- Victim issues an HTTP(S) request the attacker can answer
- Most servers don't run libsoup as an HTTP client; it's predominantly a desktop/Linux client-side library
- HTTPS + cert pinning blocks MITM variants
Serve crafted HTTP response that invokes content sniffing
SOUP_SESSION_USE_SNIFFER / a SoupContentSniffer feature, or for apps that defer to sniffer-based MIME detection. The attacker returns a response with controlled body bytes and a Content-Type that triggers the skip_insignificant_whitespace() codepath. Reference PoC: Red Hat reproducer in bugzilla #2358624.- The client application has the content sniffer feature attached to its SoupSession (default in some GNOME stacks, not in all libsoup consumers)
- Many libsoup consumers do NOT enable the content sniffer — server-side HTTP clients especially
- Hardened apps set explicit content-type handling and bypass the sniffer
Trigger one-byte heap over-read in skip_insignificant_whitespace()
- Heap layout places useful data immediately adjacent to the response body allocation
- glibc malloc, jemalloc, and tcmalloc all randomize/segregate; adjacent byte is usually padding or unrelated chunk metadata
- ASLR + heap randomization make repeatable info-leak hard
Convert over-read into impact
- Attacker has a second memory-corruption primitive to chain with the leak (not present here)
- A one-byte leak per session is wildly insufficient for practical ASLR bypass without repeated controlled triggers
- No public exploit, no in-the-wild use, EPSS 0.67%
The supporting signals.
| In-the-wild status | No known exploitation. Not in CISA KEV. No campaign attribution. |
|---|---|
| Public PoC | Reproducer attached to Red Hat Bugzilla #2358624; no weaponized exploit on GitHub or Exploit-DB. |
| EPSS | 0.67% — bottom-quartile likelihood of exploitation in next 30 days. |
| KEV status | Not listed. |
| CVSS vector | AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:H — network-reachable but AC:H (heap-grooming required) and impacts are partial confidentiality/integrity + high availability (crash). |
| Affected versions | libsoup < 3.6.5; libsoup2.4 legacy branch affected, backports issued for Debian, Ubuntu (USN-7432-1), RHEL, SUSE, Azure Linux 3.0, IBM Power HMC. |
| Fixed versions | libsoup 3.6.5; distro backports: Ubuntu libsoup2.4 2.74.x-*ubuntu*+esm, RHEL via RHSA, SUSE via openSUSE-SU, Azure Linux per Tenable plugin 235431. |
| Exposure data | libsoup is client-side; Shodan/Censys/GreyNoise have no meaningful server-side exposure signal. Installed base is essentially every GNOME desktop and many Linux appliances. |
| Disclosure date | 2025-04-02 (advisory), 2025-04-03 public. |
| Reporter | Reported via Red Hat Product Security; credit to GNOME libsoup maintainers for the fix in 3.6.5. |
noisgate verdict.
The decisive factor is chain ceiling: the entire primitive is a one-byte heap over-read on the client side with no public path to code execution, gated by attacker complexity (AC:H heap grooming) and victim opt-in to content sniffing. Vendor HIGH reflects the theoretical C:L/I:L/A:H triad, but the realistic worst case is a crash of a desktop app — not a fleet-impacting compromise.
Why this verdict
- Client-side only. libsoup is overwhelmingly an HTTP client library; the vulnerable code runs in the victim parsing an attacker-controlled response, not in a server attackers can scan for.
- AC:H is real here. A one-byte over-read requires the attacker to win a heap-layout lottery to leak anything useful; against modern glibc allocators, repeatable info leak is improbable.
- Chain ceiling is crash or 1-byte leak. No public research demonstrates RCE; without a second primitive, this does not escalate beyond DoS of a GNOME app or appliance daemon.
- Role multiplier — desktop / GNOME app role: chain succeeds, blast radius = single-user app crash. Not fleet-impacting.
- Role multiplier — Linux appliance (Power HMC, network gear) role: chain succeeds if the appliance's libsoup-using daemon content-sniffs attacker traffic; blast radius = daemon DoS, not RCE. No identity, hypervisor, CI, backup, or kernel-mode security role is canonically built on libsoup, so no CRITICAL floor is triggered.
- EPSS 0.67% and zero KEV signal corroborate that adversaries are not finding this worth weaponizing.
Why not higher?
HIGH would imply a chain ending in code execution or fleet-scale impact. The primitive is one byte of over-read with no published exploitation technique past crash, the affected role spectrum doesn't include canonically high-value-role components (DCs, IdPs, hypervisors, EDRs, CAs), and no role multiplier triggers the HIGH floor.
Why not lower?
LOW would require ignoring that libsoup ships on essentially every Linux desktop and many embedded appliances, and that the crash impact is real (A:H). The breadth of installation plus genuine availability impact keeps this firmly in MEDIUM rather than backlog hygiene.
What to do — in priority order.
- Patch libsoup to ≥ 3.6.5 (or apply distro backport) on workstations and appliances — Primary fix. For MEDIUM verdicts there is no noisgate mitigation SLA — go straight to the noisgate remediation window of ≤ 365 days, but in practice roll this with your normal monthly desktop / appliance patch cycle within 30–60 days since the fix is low-risk.
- Audit which libsoup consumers in your estate enable the content sniffer — Apps that don't attach
SoupContentSnifferto their session aren't reachable via this codepath. Useldd/lsofto enumerate processes linking libsoup and grep their source / config for sniffer feature use. Prioritize patching for the ones that do. - Block outbound HTTP from server-side libsoup consumers to untrusted destinations — If a server-side daemon (a Power HMC, an IoT controller, an automation runner) uses libsoup as a client, restrict its egress to known hosts via firewall / egress proxy so an attacker cannot serve it the malicious response.
- Enforce HTTPS with certificate validation for all libsoup-driven flows — Removes the MITM variant of step 1, leaving only direct attacker-controlled URLs reachable via phishing or SSRF.
- WAF / IDS signatures — the trigger is in a response body the client requested, not an inbound request your perimeter inspects.
- EDR memory protections like CFG/CET — they target control-flow hijack, not a one-byte read.
- Disabling JavaScript / browser hardening — libsoup is the HTTP transport, not the renderer; the bug fires before any script execution.
- Network IPS on the wire — the malicious response can be served over TLS and looks like any other HTTP body.
Crowdsourced verification payload.
Run on each Linux target as a privileged user (root or sudo). Example: sudo bash check-cve-2025-2784.sh. Detects installed libsoup version across Debian/Ubuntu (apt), RHEL/Rocky/Alma (rpm), and SUSE (zypper), and compares against the 3.6.5 fix or the distro-specific backport.
#!/usr/bin/env bash
# noisgate verifier — CVE-2025-2784 (libsoup heap over-read)
# Exit: 0 PATCHED, 1 VULNERABLE, 2 UNKNOWN
set -u
FIX_3X='3.6.5'
status='UNKNOWN'
details=''
ver_ge() { # ver_ge A B -> 0 if A >= B
[ "$1" = "$(printf '%s\n%s\n' "$1" "$2" | sort -V | tail -n1)" ]
}
check_pkg() {
local name="$1" ver="$2"
details+="$name=$ver "
case "$name" in
libsoup-3.0|libsoup3|libsoup-3.0-0)
if ver_ge "$ver" "$FIX_3X"; then echo PATCHED; else echo VULNERABLE; fi
;;
libsoup-2.4|libsoup2.4-1|libsoup-2_4-1)
# 2.4 branch only fixed via distro backport — defer to package manager metadata
echo UNKNOWN
;;
*) echo UNKNOWN ;;
esac
}
result='UNKNOWN'
if command -v dpkg-query >/dev/null 2>&1; then
while read -r n v; do
[ -z "$n" ] && continue
r=$(check_pkg "$n" "${v%%-*}")
[ "$r" = VULNERABLE ] && result=VULNERABLE
[ "$r" = PATCHED ] && [ "$result" != VULNERABLE ] && result=PATCHED
done < <(dpkg-query -W -f='${Package} ${Version}\n' 'libsoup*' 2>/dev/null)
fi
if command -v rpm >/dev/null 2>&1; then
while read -r line; do
n=$(echo "$line" | awk '{print $1}')
v=$(echo "$line" | awk '{print $2}')
[ -z "$n" ] && continue
r=$(check_pkg "$n" "${v%%-*}")
[ "$r" = VULNERABLE ] && result=VULNERABLE
[ "$r" = PATCHED ] && [ "$result" != VULNERABLE ] && result=PATCHED
done < <(rpm -qa --qf '%{NAME} %{VERSION}\n' 'libsoup*' 2>/dev/null)
fi
echo "$result $details"
case "$result" in
PATCHED) exit 0 ;;
VULNERABLE) exit 1 ;;
*) exit 2 ;;
esac
If you remember one thing.
libsoup-3.0 < 3.6.5 and libsoup-2.4 across all Linux hosts and appliances, add it to the next maintenance window, and skip the page-the-on-call routine. If you operate Power HMC or IBM appliances, prioritize those because they have fewer patching opportunities — apply IBM's HMC update when it lands.Sources
What defenders are saying.
Crowdsourced verification outputs.
Results submitted by users who ran the verification payload against their environment.