Skip to main content

libwebsockets CVE-2025-11679

MEDIUM
Out-of-bounds Read (CWE-125)
2025-10-20 prodsec@nozominetworks.com
5.9
CVSS 4.0 · Vendor: nozominetworks
View

Attack ChainAIDerived

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

  1. Access
    Host crafted PNG on malicious website
  2. Delivery
    Victim libwebsockets client loads page
  3. Exploit
    Decode oversized PNG height in UPNG
  4. Execution
    Read past heap buffer in lws_upng_emit_next_line
  5. Impact
    Crash client application (DoS)

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 the target to have been compiled with the non-default LWS_WITH_UPNG flag AND to be actively using the HTML display stack - without both, the vulnerable lws_upng_emit_next_line path is not reachable. The trigger is a crafted PNG with an abnormally large height dimension served from an attacker-controlled website, and the victim must actively visit that site (UI:A). Limiting factors: the gating compile-time feature makes vulnerable builds uncommon, exploitation demands high attack complexity (AC:H) plus a specific attack requirement (AT:P), and the realistic outcome is a crash (availability loss) rather than code execution or data disclosure.

Impact

This is a genuinely low-to-moderate priority issue despite the OOB-read class. The vendor CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:N/UI:A) is internally consistent with the description: network-reachable but requiring high attack complexity, a specific attack requirement (AT:P - a crafted PNG that happens to trigger the condition), and active user interaction (the victim must browse to an attacker page). Crucially the vendor scores impact as VC:N/VI:N/VA:H - confidentiality and integrity are rated nil, and only availability (a crash) is affected, which is why the base score is a modest 5.9. EPSS reinforces this: 0.39% probability at the 31st percentile indicates no meaningful expectation of mass exploitation. There is no CISA KEV listing and no public exploit identified, so exploitation status is 'no public exploit identified at time of analysis.' The one signal worth flagging as internally tense is the 'Information Disclosure' tag combined with CWE-125 (out-of-bounds read) versus the vendor's VC:N rating and the description, which only claims a crash - an OOB read can in principle leak heap memory, but the authoritative vendor assessment treats this as a denial-of-service (crash) issue, not a data-disclosure one. Treat this as a crash/DoS bug, not a confidentiality breach, unless the Nozomi advisory states otherwise.

Exploit ScenarioDerived

An attacker hosts a web page embedding a crafted PNG whose declared height is abnormally large. A victim running a libwebsockets-based client built with LWS_WITH_UPNG and using the HTML display stack visits the page; decoding the malformed PNG drives lws_upng_emit_next_line to read past a heap-allocated buffer, likely crashing the client application. No public exploit code is identified at time of analysis, and the attack requires high complexity plus victim interaction.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 08, 2026

A heap out-of-bounds read in libwebsockets' lws_upng_emit_next_line() function can crash an application when the library is compiled with the non-default LWS_WITH_UPNG flag and the HTML display stack is in use. A remote, unauthenticated attacker can trigger the flaw by hosting a crafted PNG with an abnormally large height dimension on a site the victim visits, causing the affected process to read past a heap-allocated buffer and potentially terminate. Exploitation is constrained by the compile-time feature gate and the requirement that the HTML display path be reachable, so vulnerable builds are uncommon; EPSS is low (0.39%, 31st percentile) and no public exploit code or confirmed active exploitation has been identified at time of analysis.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed. The primary remediation is to apply the upstream libwebsockets commit 7df24cca7144d7bc9233b6b0a71108bd154ce101 (https://libwebsockets.org/git/libwebsockets/commit?id=7df24cca7144d7bc9233b6b0a71108bd154ce101), which corrects the boundary handling in lws_upng_emit_next_line(); teams should confirm with their distribution or embedded vendor whether a tagged release incorporating this commit has shipped, since no exact fixed version number is provided in the available data. Where patching is delayed, the most effective compensating control is to rebuild libwebsockets without the LWS_WITH_UPNG compile flag - because the vulnerable UPNG decoder path is only compiled in when that flag is set, removing it eliminates exposure entirely, at the trade-off of losing UPNG-based image decoding in the HTML display stack. A second option is to stop using the HTML display stack in affected deployments, since the flaw is unreachable when that path is not active; this likewise removes image-rendering functionality. Blocking or sanitizing attacker-controlled PNG content before it reaches the HTML display stack, or restricting which remote sites the HTML client may load, further reduces reachability of the crafted-image trigger, but these network-level measures are weaker than removing the vulnerable feature and depend on correct filtering of oversized image dimensions. Given the availability-only impact, patching can be prioritized relative to higher-impact issues, but any internet-facing or embedded build with LWS_WITH_UPNG enabled should be updated promptly.

Affected ProductsAI

The affected component is warmcat libwebsockets when compiled with the non-default LWS_WITH_UPNG flag and running the HTML display stack; builds without LWS_WITH_UPNG, or that never exercise the HTML display path, cannot reach the vulnerable lws_upng_emit_next_line() code and are not affected. The vulnerability is tracked as CVE-2025-11679 with the root-cause class CWE-125 (Out-of-bounds Read), and the upstream code change that addresses it is commit 7df24cca7144d7bc9233b6b0a71108bd154ce101 in the libwebsockets repository (https://libwebsockets.org/git/libwebsockets/commit?id=7df24cca7144d7bc9233b6b0a71108bd154ce101). Corroborating analysis is available from Nozomi Networks Labs at https://www.nozominetworks.com/labs/vulnerability-advisories-cve-2025-11679. No specific release-version range is enumerated in the provided data, so consumers should map the fixing commit to their libwebsockets version rather than assume any particular tag.

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

The issue is a classic out-of-bounds read (CWE-125) in libwebsockets, a lightweight C library for WebSocket and HTTP communication. The affected routine, lws_upng_emit_next_line(), belongs to the bundled UPNG (micro PNG) decoder that is only compiled in when LWS_WITH_UPNG is defined - a non-default build option. The decoder processes a PNG's declared dimensions, and when a crafted image advertises an abnormally large height value, index arithmetic in the line-emission path can step beyond the bounds of a heap-allocated buffer, producing an out-of-bounds read. The vulnerability is only reachable when the library's HTML display stack is actively rendering image content, which is the second prerequisite alongside the compile flag. Per CWE-125 semantics the impact class is availability and, at most, unintended memory disclosure rather than memory corruption enabling code execution; the authoritative assessment scores it CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:N/A:H, reflecting a remote, unauthenticated trigger with high attack complexity, user interaction, and availability-only impact (no confidentiality or integrity loss). The CPE-level product identity is warmcat libwebsockets built with LWS_WITH_UPNG.

Know when Libwebsockets 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 (nozominetworks) PRIMARY 5.9 MEDIUM
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:A/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 5.3 MEDIUM

Remote crafted-PNG trigger but needs a rare compile-time feature and victim browsing, so AC:H/UI:R; impact is a crash only, so C:N/I:N/A:H.

3.1 AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:N/A:H
4.0 AV:N/AC:H/AT:P/PR:N/UI:A/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE MEDIUM
Red Hat 3.1 LOW

Primary rating from Vendor (nozominetworks).

CVSS VectorVendor: nozominetworks

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
Active
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Out-of-bounds Read in lws_upng_emit_next_line in warmcat libwebsockets allows, when the LWS_WITH_UPNG flag is enabled during compilation and the HTML display stack is used, to read past a heap allocated buffer possibly causing a crash, when the user visits an attacker controlled website that contains a crafted PNG file with a big height dimension.

Threat Intelligence Overview

EPSS Score
0.4%
Top 69% exploitable
Prevalence
Medium
libwebsockets widely embedded, but UPNG/HTML-display feature rarely compiled in
Data Quality
3 sources
Confidence: Low

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
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.

Vendor StatusVendor

SUSE

Severity: Moderate

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