Description

A flaw was found in libxml2 with Python bindings enabled. A remote attacker could exploit this vulnerability by providing a specially crafted XML document containing a Document Type Definition (DTD) with enumerated attribute values. This triggers a double-free error in the SAX attributeDecl callback handler, where a string is freed twice. This flaw can lead to a denial of service (DoS) due to a reproducible crash in Python applications using the libxml2 SAX bindings.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "8.5",
  "pubDate": "2026-09-08T12:16:58.083Z",
  "pubdate": "2026-09-08T12:16:58.083Z",
  "executiveSummary": "A critical memory management vulnerability exists in the libxml2 library, specifically when utilizing Python bindings. The flaw is categorized as a double-free memory corruption vulnerability.\nThe vulnerability occurs within the SAX (Simple API for XML) attributeDecl callback handler during the parsing of specially crafted XML documents. By embedding a Document Type Definition (DTD) featuring enumerated attribute values, a remote attacker can trigger the double-free condition.\nSuccessful exploitation of this flaw leads to a reproducible application crash, resulting in a Denial of Service (DoS) for any Python-based application leveraging these specific libxml2 SAX bindings.\nThis vulnerability is particularly concerning for network-exposed services that process untrusted XML input, as the exploit does not require authentication or elevated privileges. The memory corruption inherent in a double-free scenario also introduces potential vectors for further instability or arbitrary code execution, depending on the heap layout and the underlying memory allocator's resilience against such corruption. Organizations utilizing libxml2 should prioritize remediation through library updates or input validation to mitigate the risk of service disruption.",
  "technicalDetails": "The vulnerability resides in the SAX parsing logic of libxml2 when configured to interface with Python. The root cause is a double-free error triggered within the attributeDecl callback handler. This callback is responsible for processing attribute declarations found within a DTD of an XML document.\nWhen an XML parser encounters an attribute declaration with enumerated values, the SAX handler attempts to allocate and subsequently manage the memory associated with these attribute definitions. Due to improper state management in the Python wrapper layer, the memory pointer representing the attribute string is erroneously passed to the free() function twice.\nThe attack flow begins when an attacker transmits a maliciously crafted XML payload to a service utilizing the libxml2 Python bindings. This payload must include a DTD section that defines enumerated attributes in a manner that forces the parser to enter the vulnerable execution path in the attributeDecl handler. Upon reaching this point, the logic flaw triggers the deallocation of the memory block, followed by a second, redundant deallocation request for the same memory address.\nThe exploitation method relies on the deterministic nature of the parser's state machine. Once the second free() operation is executed, the heap manager's metadata becomes corrupted, as the free list or heap bin structures are updated inconsistently. In the context of Python applications, this results in an immediate segmentation fault or an abort signal, effectively terminating the process.\nThe component affected is the interface between the core C implementation of libxml2 and its Python language bindings. Because this occurs at the callback interface level, the vulnerability is exposed to any application that accepts XML input from external sources and processes it using the libxml2 SAX interface without sanitization. The requirement for exploitation is merely the ability to reach the XML parsing routine with a payload containing the specifically structured DTD attribute definitions. No authentication or specific user privileges are required to reach the vulnerable code path, making this a remote attack vector. The primary impact is a persistent Denial of Service; however, the corruption of heap metadata may, in certain environments, facilitate more sophisticated memory manipulation techniques if the allocator does not provide robust protection against double-free conditions."
}