← Back to Feed CACHED · 2026-06-30 20:07:48 · CACHE_KEY CVE-2025-2784
CVE-2025-2784 · CWE-125 · Disclosed 2025-04-03

A flaw was found in libsoup

ASSESSED — NOISGATE V0.5
Vendor
Reassessed
Verdict:
Do you agree?
01 · The Real Story

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.

"One-byte heap over-read in libsoup's content sniffer. Client-side only, requires victim hitting attacker-controlled HTTP. Not a fire drill."
02 · The Attack Path

4 steps from start to impact.

STEP 01

Lure victim libsoup client to attacker HTTP endpoint

Attacker must get a libsoup-backed client (Epiphany, Evolution, a GNOME app, an embedded appliance making outbound HTTP, or a server-side process using libsoup as an HTTP client) to issue a request to a URL they control. This can be a phishing link, a malicious ad/CDN redirect, an MITM on cleartext HTTP, or an SSRF chained into a server-side libsoup consumer. Tooling: any HTTP server — python -m http.server, nc, custom Go responder.
Conditions required:
  • Victim host runs an application linked against libsoup < 3.6.5
  • Victim issues an HTTP(S) request the attacker can answer
Where this breaks in practice:
  • 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
Detection/coverage: Proxy / NDR logs of outbound HTTP, EDR process telemetry for GNOME apps
STEP 02

Serve crafted HTTP response that invokes content sniffing

libsoup performs MIME sniffing when the caller has enabled 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.
Conditions required:
  • The client application has the content sniffer feature attached to its SoupSession (default in some GNOME stacks, not in all libsoup consumers)
Where this breaks in practice:
  • 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
Detection/coverage: No widely-deployed signature for this specific payload; generic anomalous-response heuristics only
STEP 03

Trigger one-byte heap over-read in skip_insignificant_whitespace()

The function walks past a buffer boundary by one byte while skipping whitespace. The byte read is whatever lives immediately after the response body buffer on the heap. Tooling: any AddressSanitizer-built libsoup will flash on this; exploitation tooling is essentially a fuzzed HTTP responder.
Conditions required:
  • Heap layout places useful data immediately adjacent to the response body allocation
Where this breaks in practice:
  • 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
Detection/coverage: AddressSanitizer builds, glibc MALLOC_CHECK_=3, hardened_malloc
STEP 04

Convert over-read into impact

Realistic outcomes: (a) process crash → denial of service of the GNOME app or appliance daemon, (b) one-byte info leak that an attacker could theoretically chain with another bug to defeat ASLR. There is no public path from this single byte to RCE. Tooling: none weaponized.
Conditions required:
  • Attacker has a second memory-corruption primitive to chain with the leak (not present here)
Where this breaks in practice:
  • 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%
Detection/coverage: Crash telemetry (ABRT, systemd-coredump, Sentry) for libsoup-linked processes
03 · Intelligence Metadata

The supporting signals.

In-the-wild statusNo known exploitation. Not in CISA KEV. No campaign attribution.
Public PoCReproducer attached to Red Hat Bugzilla #2358624; no weaponized exploit on GitHub or Exploit-DB.
EPSS0.67% — bottom-quartile likelihood of exploitation in next 30 days.
KEV statusNot listed.
CVSS vectorAV: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 versionslibsoup < 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 versionslibsoup 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 datalibsoup 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 date2025-04-02 (advisory), 2025-04-03 public.
ReporterReported via Red Hat Product Security; credit to GNOME libsoup maintainers for the fix in 3.6.5.
04 · The Call

noisgate verdict.

Final Verdict
DOWNGRADED to MEDIUM (5.3/10)

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.

HIGH Affected version range and patched version (3.6.5)
HIGH Absence of in-the-wild exploitation and weaponized PoC
MEDIUM Blast radius — depends on which libsoup consumers in your estate enable the content sniffer

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.

05 · Compensating Control

What to do — in priority order.

  1. 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.
  2. Audit which libsoup consumers in your estate enable the content sniffer — Apps that don't attach SoupContentSniffer to their session aren't reachable via this codepath. Use ldd / lsof to enumerate processes linking libsoup and grep their source / config for sniffer feature use. Prioritize patching for the ones that do.
  3. 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.
  4. 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.
What doesn't work
  • 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.
06 · Verification

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.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/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
07 · Bottom Line

If you remember one thing.

TL;DR
This is a MEDIUM, not a HIGH. The vuln is real but the chain ceiling is a one-byte heap over-read on a client — practical worst case is a crash of a GNOME app or an embedded daemon. Per the noisgate mitigation SLA there is no mitigation deadline for MEDIUM — go straight to the noisgate remediation SLA of ≤ 365 days, which in practice means rolling libsoup ≥ 3.6.5 (or your distro backport) through your normal monthly desktop / appliance patching within 30–60 days. Monday morning: query your CMDB / SBOM for 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

  1. NVD — CVE-2025-2784
  2. GitHub Advisory GHSA-5qxx-2mqf-3v7g
  3. Red Hat Bugzilla #2358624
  4. Ubuntu USN-7432-1
  5. SUSE CVE record
  6. IBM Power HMC security bulletin
  7. Tenable plugin 235431 (Azure Linux 3.0)
  8. Snyk SNYK-DEBIAN11-LIBSOUP24-9652816
Peer Review

What defenders are saying.

Submit a review attribution: handle + country only
0 flags selected · stored anonymously
Validation Results

Crowdsourced verification outputs.

Results submitted by users who ran the verification payload against their environment.