XML External Entity Injection

XML External Entity injection in Sparx Systems Enterprise Architect's XSLT Debugger lets an attacker who convinces a user to open a crafted XML/XSLT file cause the parser to resolve an external DTD and disclose arbitrary files readable by the victim's Enterprise Architect process. The issue was reported by CERT-PL and has been confirmed only in version 17.1, with all other releases unverified because vendor contact attempts were unsuccessful; the CPE entry covers the product across all versions. It is unauthenticated in the network sense but requires the victim to actively load attacker-controlled content into the debugger (UI:A in the CVSS v4.0 vector, UI:R in our CVSS v3.1 assessment), confidentiality-only impact with no write or code execution demonstrated from this flaw alone, and no public exploit identified at time of analysis.

Unauthenticated XML External Entity (XXE) injection in Ellucian WebAdvisor 3.2 lets remote attackers POST crafted XML to the /WebAdvisor/WebAdvisor endpoint and abuse an XML parser that has external entity and DTD resolution left enabled, yielding server-side request forgery, coerced NTLMv2 hash disclosure to an attacker-controlled SMB share, and arbitrary file read from the underlying Windows host through an out-of-band error-based channel. No authentication or user interaction is required (CVSS vector shows AV:N/PR:N/UI:N), and impact is confined to confidentiality with no integrity or availability effect; the vendor-published CVSS 4.0 score is 8.7 while our independent assessment rates the same vector as high confidentiality impact only. No public exploit code has been identified at time of analysis, and real-world exposure is limited to legacy higher-education deployments because WebAdvisor reached end-of-support in June 2022.

Arbitrary file system read in Adobe ColdFusion (2023 releases up to and including 2023.0.25 and 2025 releases up to and including 2025.0.13) is achievable through an XML External Entity (XXE) flaw that lets a remote attacker cause the server to resolve attacker-controlled external entities during XML processing. The CVSS vector is AV:N/AC:L/PR:N/UI:N/S:C (8.6), meaning the attack is unauthenticated, requires no user interaction, and crosses a security boundary so that disclosed data lies outside the vulnerable component's own scope; impact is confidentiality-only (high) with no integrity or availability effect. No public exploit code and no CISA KEV entry were identified at time of analysis, so risk derives from how many unpatched, network-reachable XML-processing endpoints exist rather than from confirmed active exploitation.

Privilege escalation in Adobe Experience Manager (AEM) allows an authenticated, low-privileged user - an author or contributor-level account - to abuse an Improper Restriction of XML External Entity Reference (XXE, CWE-611) in XML parsing and thereby read local files and reach internal resources well beyond their intended permissions, crossing a security boundary as reflected by the scope-changed CVSS 9.6 rating. The vector is network-reachable with no user interaction required (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N), so the only real precondition is obtaining valid low-tier credentials, which makes author instances and deployments with broadly provisioned low-privilege accounts the highest-risk exposure. No public exploit code has been identified at time of analysis, and builds updated past the affected ranges are not exploitable.

Unauthenticated remote attackers can exploit XML external entity (XXE) handling in Commvault's CVFS component to read files from the underlying host, resulting in high-confidentiality information disclosure (CVSS 4.0 8.7 HIGH; vendor vector AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N). Affected deployments are Commvault Cloud and Grid (HSX) CVFS instances, per the vendor's CPE data, that remain on a pre-fix maintenance release and expose an XML-accepting CVFS interface to the network. Integrity and availability are unaffected, and no public exploit has been identified at time of analysis; the primary practical barrier is whether the storage/backup management plane is network-reachable rather than confined to an internal segment.

IBM TRIRIGA Application Platform 5.0.0 through 5.0.8 contains an XML external entity (XXE) injection flaw that allows an authenticated attacker holding an elevated/privileged account to read sensitive information from the application server and, through the changed-scope condition in the CVSS vector, potentially from resources beyond the vulnerable component's own security boundary. Network access with low attack complexity and no user interaction is required, but the PR:H privilege requirement confines realistic exploitation to insiders or attackers who have already obtained privileged credentials, making this a moderate-priority issue rather than an emergency; no public exploit has been identified at time of analysis and the CVE is not listed in CISA KEV.

XML external entity (XXE) processing is enabled by default across multiple request paths in Progress MarkLogic Server 11.x before 11.3.7 and 12.x before 12.1.0, allowing an attacker who submits crafted XML to trigger server-side requests or read local files. The vulnerability is rated CVSS 7.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:L), meaning exploitation requires at least low-privileged credentials or an existing authenticated session - it is not an unauthenticated flaw - and the impact is limited to confidentiality loss and minor availability effects, with no integrity impact. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so exposure is currently a matter of unpatched, authenticated attack surface rather than active exploitation. Progress has published a security advisory and fixed releases that disable default external entity processing.

XML external entity (XXE) processing in Progress MarkLogic Server 11.x before 11.3.7 allows remote, unauthenticated attackers to disclose local files or trigger outbound network requests from the server through attacker-supplied SAML messages. Exploitation is conditional: the instance must be configured to use SAML single sign-on, since only the SAML parser's handling of external DTDs and entities is affected, and the impact is limited to confidentiality (C:H, no integrity or availability impact, CVSS 7.5). No public exploit code and no confirmed active exploitation have been identified at time of analysis, so this represents a genuine but conditional priority - patching matters most for deployments that have SAML SSO enabled and exposed to untrusted networks.

Out-of-band XML External Entity (XXE) injection in Eclipse JAXB RI (jaxb-ri) lets an unauthenticated remote attacker read local files when an application unmarshals attacker-influenced XML through the affected JAXB factory helpers (XmlFactory in the core and xsom modules). The pre-patch code relied solely on XMLConstants.FEATURE_SECURE_PROCESSING, so on JAXP/SAX/DocumentBuilder implementations where that single feature does not disable DOCTYPE declarations, external general entities, external parameter entities, or external DTD loading, external entity resolution remains possible and file content can be exfiltrated out-of-band. Exploitation requires both conditions to hold - untrusted XML reaching JAXB unmarshalling, plus a parser stack where secure processing alone is insufficient - which is why the vector carries AC:H and the score is 8.3 (High) on both the supplied CVSS 4.0 vector and the independently assessed CVSS 3.1 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:L). No confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis.

XML external entity injection in IBM DataPower Gateway 10.5.0.0-10.5.0.22, 10.6.0.0-10.6.0.10, 10.6.1-10.6.6, and 11.0.0.0-11.0.0.2 lets remote, unauthenticated attackers who can reach an XML-accepting endpoint read files or internal resources from the gateway host and, via entity expansion, exhaust memory. The CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:L, base 8.2) confirms no credentials or user interaction are required, with high confidentiality impact and low availability impact. There is no public exploit code and no indication of active exploitation, and IBM has published a patch through its support portal.

Authenticated users of the Arista Spectralight WiFi-server application can submit crafted XML requests that trigger external-entity resolution and disclose arbitrary local files from the server, with a secondary partial denial-of-service effect from entity processing. Exploitation requires valid credentials (CVSS 4.0 vector shows PR:L; the independent assessment concurs with PR:L) and network reach to an XML-accepting endpoint, so the realistic threat population is insiders or attackers who have already obtained an account rather than unauthenticated internet scanners. No public exploit code and no CISA KEV listing were identified at time of analysis, and the issue is rated CVSS 7.1 / CWE-611 - a moderate-severity, authentication-gated information-disclosure flaw rather than a top-tier emergency.

Improper restriction of XInclude resource resolution in Copernik XML Factory through 0.1.1 allows an attacker-controlled XML document to resolve xi:include hrefs when the stock JDK provider is in use, resulting in local file disclosure and server-side request forgery against internal HTTP endpoints. Only applications that obtain a factory from XmlFactories.newDocumentBuilderFactory() or XmlFactories.newSAXParserFactory() (or harden an externally supplied XMLReader via XmlFactories.harden()), run without Apache Xerces (xercesImpl) on the classpath, explicitly enable XInclude with setXIncludeAware(true) or the equivalent reader feature, and parse XML from an untrusted source are affected; the Xerces provider and the Android provider are not affected. No CVSS vector, EPSS score, or CISA KEV entry was provided, so no public exploit or active exploitation was identified at time of analysis, although the defect is confirmed and fixed by upstream commits and the 0.1.2 release.

Improper restriction of XML external entity resolution in the XSLT support extension of Apache Camel Quarkus (camel-quarkus-support-xalan) allows an attacker who supplies the XML document being transformed to read local files and to issue requests to internal network locations, because the bundled Xalan-J 2.7.x TransformerFactory predates JAXP 1.5 and cannot honour javax.xml.XMLConstants.ACCESS_EXTERNAL_DTD or ACCESS_EXTERNAL_STYLESHEET. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N, base 8.6) rates this as network-reachable and unauthenticated with scope change and high confidentiality impact, though exploitation is conditional: the application must pull camel-quarkus-xslt, camel-quarkus-xslt-saxon, camel-quarkus-tika or camel-quarkus-xmlsecurity onto the classpath, and on the xslt component path the attacker-controlled body must reach the transformer already as a javax.xml.transform.Source rather than a String, byte[], InputStream, DOMSource or StAXSource. Affected releases are 3.2.0 before 3.33.3 and 3.34.0 before 3.40.0; patches exist in 3.33.3 and 3.40.0, and no public exploit has been identified at time of analysis.

Unauthenticated XML External Entity (XXE) processing in Kiteworks Email Protection Gateway allows a remote sender to read files accessible to the gateway service account - including cryptographic key material and credentials - and have them sent to a destination the sender controls. The vulnerable parsing path is only reachable when the optional, non-default message-processing feature is enabled, which is the sole reason the assessed vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:L carries AC:H despite needing no authentication or user interaction; default installations are not exposed. Per the provided intelligence, no public exploit identified at time of analysis and no confirmed actively exploited (CISA KEV) status, and impact is bounded to files readable by the gateway service account plus the limited integrity/availability side effects typical of XXE.

XML external entity (XXE) injection in Apache Roller 6.1.5 lets an authenticated user who holds entry-editing rights on any weblog force the server to fetch and parse an attacker-influenced trackback response with an XML parser that resolves external entities, disclosing files readable by the Roller process account. The Trackback control is hidden in the standard UI, but its Struts2 action remains directly reachable over HTTP and no non-default server configuration is required, so the practical prerequisite is a valid low-privileged account plus a host the attacker controls to serve the malicious trackback XML (CVSS 3.1 7.7 High, AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N, scope change reflecting reads outside the application's own data). No public exploit code was identified at the time of analysis, and the vendor-released fix is Apache Roller 6.1.6, which eliminates the outbound trackback response parser.

XML external entity (XXE) processing in Apache Roller 6.1.5 allows an authenticated weblog administrator to read files accessible to the Roller process and to reach internal network addresses by importing a crafted OPML bookmark document, because the bookmark-import parser does not disable external entity resolution. The advisory confirms no non-default configuration is required - the administrator bookmark-import action is vulnerable out of the box on the affected release - which is consistent with the assessed CVSS 3.1 score of 7.7 High (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N, scope changed, confidentiality-only impact). No public exploit code and no confirmed active exploitation have been identified at time of analysis; the issue is remediated in Apache Roller 6.1.6, which uses a hardened parser that disables external entities and document type declarations.

XML External Entity (XXE) injection in http4s-scala-xml's EntityDecoder for scala.xml.Elem (all versions before 0.24.1 and 1.0.0-M39) allows unauthenticated remote attackers who can supply XML message bodies to disclose files readable by the service process, perform server-side request forgery (SSRF) against internal network resources, or trigger denial of service via entity expansion. The decoders obtain a javax.xml.parsers.SAXParserFactory through SAXParserFactory.newInstance without configuring secure-processing features, so JDK default behavior resolves DOCTYPE declarations, external general and parameter entities, and external DTDs. Vendor-released fixes are 0.24.1 and 1.0.0-M39; no public exploit code has been identified at time of analysis, and reachability depends on an application actually using these decoders against untrusted XML.

Information disclosure in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows a remote authenticated attacker to read files and reach resources outside the application's security scope by submitting crafted XML to an XML-processing function (CWE-611 XML external entity injection). The assessed vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N rates this 7.7 High: confidentiality impact is high with a scope change, but there is no integrity or availability effect, meaning the outcome is data exposure rather than code execution or service disruption. Exploitation requires a valid low-privilege DataStage account and network reachability to the affected XML handling surface; no user interaction is needed, and no public exploit identified at time of analysis. Patch available per vendor advisory (IBM support page node/7288649).

XML external entity (XXE) injection in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows an unauthenticated attacker positioned on an adjacent network segment to submit crafted XML that the product's parser resolves against external entities, resulting in disclosure of server-side files or server-side request forgery against internal services. The CVSS 3.1 vector (AV:A/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N, 7.4 High) requires no credentials and no user interaction, but the adjacent-network attack vector and the confidentiality-only impact mean exploitation depends heavily on whether an XML-accepting endpoint is reachable from an untrusted same-segment network and on what sensitive files or internal services are reachable from the server context. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (no CISA KEV listing), and IBM has published a patch advisory; despite the High score this is a moderate-priority issue that should not be over-prioritized relative to internet-reachable, integrity- or availability-impacting flaws.

Improper restriction of XML external entity references in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows an attacker positioned on an adjacent network segment - or elsewhere within the same cluster network - to read sensitive files and internal resources by submitting a crafted XML document to an FTM parsing endpoint. The assessed CVSS 3.1 vector (AV:A/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N, 7.4 High) confirms the exploitation requirements: no credentials and no user interaction are needed, but the adjacent-network prerequisite rather than an internet-facing vector meaningfully narrows the attacker population, and impact is confined strictly to confidentiality with no integrity or availability effect. There is no public exploit identified at time of analysis, no EPSS signal or CISA KEV listing is present in the provided data, and IBM has published a vendor advisory with a patch available for this CWE-611 flaw.

MPXJ's MerlinReader (versions 5.5.5 through 16.4.1) creates a default-configured DocumentBuilder when parsing XML taken from the ZTIMEINTERVALS column of a Merlin project SQLite database, leaving doctype declarations and external entities enabled, so a crafted database can coerce the parser into reading arbitrary local files when an application imports an untrusted Merlin file. The practical impact is bounded: per the vendor, MPXJ's downstream handling of the parsed XML means the file contents are unlikely to be exfiltrated, so this is effectively blind XXE (local file access, possible SSRF or parser DoS) rather than reliable data disclosure, which is why the independent assessment rates Confidentiality as Low despite the 7.5 HIGH base score, and the CVSS vector shows network reachability with PR:N/UI:N (unauthenticated, no user interaction beyond the file being processed by the host application). No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis; a vendor-released patch is available in MPXJ 16.4.1.

XML external entity injection in getID3 1.9.26 and earlier allows an attacker who can get a crafted media file parsed by the library's XML2array helper to read local files, potentially trigger server-side request forgery, and cause denial of service through entity expansion. The flaw only manifests on PHP versions earlier than 8.0, where libxml does not disable external entity loading by default and getID3's error-suppressed libxml_disable_entity_loader() call can fail silently; on PHP 8.0 and later the vulnerable code path does not trigger at all. No authentication or user interaction is required once those preconditions hold - the only requirement is that the application ingests attacker-influenced media metadata - and no public exploit identified at time of analysis, though the vendor has published a fix. Independent assessment rates the dominant impact as high-confidentiality local file disclosure (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:L), with integrity impact absent and availability impact limited.

IBM MQ message queueing middleware fails to properly restrict XML external entity resolution while processing MQRFH2 message headers, letting an authenticated queue user read server-side files or resources and drive the broker and its Java clients into a denial-of-service state. Affected releases span the 9.1.x, 9.2.x, 9.3.x and 9.4.x LTS/CD streams plus 10.0.0.0 Classes for Java, so any environment running the JMS/XMS or Java messaging client against a current broker is in scope. IBM has published a vendor fix and there is no public exploit code or CISA KEV entry identified at time of analysis, but the confidentiality and availability impact are both rated High (CVSS 8.1, AV:N/AC:L/PR:L/UI:N).

XML external entity (XXE) injection in the IBM MQ .NET client allows an authenticated attacker with queue-write access to read files from the host running that client and to cause a limited denial of service when the client parses the RFH2 folder of a crafted message. The flaw is client-side - the queue manager itself and the Java/C clients are not indicated as affected - and the attacker must already hold valid MQ credentials with authority to place messages on a queue the vulnerable client consumes. No public exploit has been identified at time of analysis, CISA's SSVC assessment records no exploitation activity and rates the issue not automatable with partial technical impact, and patch code is available from the vendor; the practical risk is genuine but moderate, well below what the 7.1 base score suggests at first glance.

IBM Business Automation Workflow, in both its container and traditional (on-premises) distributions, fails to restrict XML external entity resolution when parsing XML data, allowing an authenticated remote user to read server-side files or exhaust process memory. The flaw carries a CVSS base score of 7.1 (AV:N/AC:L/PR:L/UI:N, C:H/I:N/A:L), meaning a low-privileged but valid account is required — it is not exploitable unauthenticated. IBM has published a vendor fix via support document node 7285930; there is no CISA KEV listing and no public exploit code identified at time of analysis, and no EPSS score was supplied with the intelligence feed.

XML External Entity injection in Flowable flowable-engine through 8.0.0 allows authenticated users holding process deployment privileges to exfiltrate arbitrary local files or perform server-side request forgery against internal network endpoints. The vulnerability resides in ProcessDiagramLayoutFactory.parseXml(), which processes user-supplied BPMN XML without disabling external entity resolution, and is present in both the main flowable-engine module and the legacy flowable5-engine (Activiti-derived) module. No public exploit code has been identified at time of analysis, and no confirmed patched release version is available from the referenced data.

XML External Entity injection in IBM Business Automation Workflow allows authenticated remote attackers to read arbitrary server-side files or exhaust memory by submitting crafted XML payloads to processing endpoints. Both containerized (Kubernetes/OpenShift) and traditional on-premises deployments across versions 24.0.0 through 26.0.0 are confirmed affected. No public exploit code or CISA KEV listing exists at time of analysis; IBM has released interim fixes for all four affected version branches.

XML external entity (XXE) injection in IBM MQ 9.1.x, 9.2.x, 9.3.x, 9.4.x LTS/CD and 10.0.0.0 lets a remote attacker who holds low-privileged MQ access submit specially crafted XML that the product parses without disabling external entity resolution. Successful exploitation can disclose sensitive local files (confidentiality impact rated High) or exhaust memory and degrade availability (rated Low), yielding an overall CVSS base score of 7.1. There is no indication of confirmed active exploitation (no CISA KEV listing) and no public exploit code identified at time of analysis, though the vulnerability is trivially automatable once parser entry points are reachable.

XML external entity (XXE) injection in IBM MQ (9.1, 9.2, 9.3, 9.4 LTS/CD lines and 10.0.0.0) lets a remote attacker who can already authenticate to MQ and get XML content parsed by the product cause the parser to resolve attacker-supplied external entities. Successful exploitation exposes sensitive information readable by the MQ process (high confidentiality impact) and can consume memory resources, degrading availability. CVSS 3.1 scores this 7.1 (AV:N/AC:L/PR:L/UI:N), so exploitation requires low-privileged authenticated access rather than being fully unauthenticated; no public exploit code or CISA KEV entry was present in the supplied intelligence at time of analysis.

An XML external entity (XXE) injection flaw in IBM MQ's reply-message processing lets an authenticated attacker who can place messages on a queue cause the broker to resolve externally defined entities, resulting in arbitrary file disclosure from the MQ server and server-side request forgery against internal networks. The issue spans a wide swath of supported releases - MQ 9.1 LTS through 9.1.0.37, 9.2 LTS through 9.2.0.43, 9.3 LTS through 9.3.0.41 and 9.3 CD through 9.3.5.1, 9.4 LTS through 9.4.0.25 and 9.4 CD through 9.4.5.1, plus MQ 10.0.0.0 Managed File Transfer. IBM rates it CVSS 7.1 (AV:N/AC:L/PR:L/UI:N, high confidentiality, low integrity impact); no public exploit code and no CISA KEV entry were identified at time of analysis.

XML External Entity (XXE) injection in IBM Business Automation Workflow containers and traditional deployments allows an authenticated remote attacker to read arbitrary files from the server or perform server-side request forgery due to vulnerable XML processing enabled by default in programming model artifacts. Affected versions span the 24.0.0, 24.0.1, 25.0.0, and 26.0.0 release lines, all below their respective latest interim fixes. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV.

Unauthenticated XML external entity injection in MoguBlog through version 6.2 allows remote attackers to read arbitrary files from the server filesystem and trigger outbound SSRF requests via the public WeChat callback endpoint. The WechatRestApi.index() method passes raw POST body XML directly to SignUtil.xmlToMap(), which instantiates a dom4j SAXReader without any DTD or external-entity restrictions, enabling full XXE exploitation with entity resolution reflected in error responses. A publicly available Python proof-of-concept exploit exists; no vendor-released patch has been confirmed at time of analysis.

XML external entity (XXE) injection in Perforce's Akana API Platform allows remote unauthenticated attackers to abuse improperly restricted external references during XML-to-JSON processing. Affected builds are 2026.1, 2025.1.1, and every release before 2024.1.6 (including older unsupported versions); Perforce has shipped a security patch in the latest supported releases. No public exploit identified at time of analysis, but the CVSS 4.0 score of 9.2 and the unauthenticated network vector make this a high-priority patch for any exposed Akana gateway.

XXE injection in NextGen Mirth Connect allows unauthenticated remote attackers to exfiltrate arbitrary files from the server and trigger denial-of-service conditions when XML batch processing is enabled with the XPath option selected. The vulnerability stems from the absence of entity restrictions in the default XPath/JAXP XML parser configuration, permitting malicious external entity declarations to be resolved. A CISA ICS Medical advisory (ICSMA-26-253-01) and a researcher blog post confirm this affects healthcare integration infrastructure; no public exploit identified at time of analysis.

XXE injection via the XSLT Transformer Step in NextGen Mirth Connect (versions ≤4.7.1) allows unauthenticated network attackers to exfiltrate arbitrary server-local files through an out-of-band HTTP callback, and to deny service to the targeted processing channel. The root cause is a bare Java TransformerFactory instantiated without disabling external entity resolution (CWE-611). Full public proof-of-concept code exists at GitHub; CISA published ICS-Medical advisory ICSMA-26-253-01 on 2026-09-10, and the vendor-confirmed fix ships in version 4.7.2.

XML External Entity (XXE) injection in IBM webMethods Integration Server 11.1 allows an attacker with low-privileged access to submit malicious XML payloads that coerce the server's XML parser into disclosing sensitive filesystem contents or exhausting memory resources through recursive entity expansion. The vulnerability is confirmed by IBM with a patch available via advisory node/7286620. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.

XML External Entity (XXE) injection in Hitachi Cosminexus Component Container allows unauthenticated remote attackers to disclose sensitive local files or cause a denial of service through maliciously crafted XML input. The vulnerability spans an extensive range of versions across the 09-xx through 11-xx release trains, indicating a long-lived parser misconfiguration in the middleware's XML processing subsystem. No public exploit code or active exploitation has been confirmed; Hitachi has released patches for the actively maintained branches.

XML External Entity (XXE) injection in SAP Integration Suite allows low-privileged remote attackers to read arbitrary server-side files and trigger resource exhaustion via maliciously crafted XML payloads submitted to internal integration components. The vulnerability carries a scope-changed CVSS of 8.5 because the XML parser's external entity resolution crosses trust boundaries, exposing server filesystem contents through monitoring or logging channels. No public exploit code has been identified at time of analysis, but SAP has issued a Security Note (3792978) addressing the flaw.

XML External Entity injection in Distribution Management v1.0.0's level-rule module allows unauthenticated remote attackers to read arbitrary server-side files, conduct server-side request forgery to map internal networks, and potentially launch attacks against internal services by supplying a crafted XML payload. The CVSS vector confirms full confidentiality impact with no authentication barrier, though EPSS at 0.16% (6th percentile) indicates low observed exploitation activity. A public researcher writeup with a proof-of-concept payload has been published on GitHub, confirming practical exploitability.

SSRF, XXE and denial of service exposure arise in libxml2 before 2.15.4 because xmlXIncludeProcess and xmlXIncludeProcessTree fail to propagate the document's parseFlags down to the parser contexts they create for XInclude resolution. When parseFlags are dropped, protective options such as XML_PARSE_NONET stop being enforced, so an attacker-supplied document containing an external xi:include href can force outbound network fetches through the application's resource loader — enabling server-side request forgery, external entity injection, or a hang driven by an intentionally slow remote resource. Exploitation requires an application that enables XInclude and relies on XML_PARSE_NONET (typically with a custom resource loader); no public exploit code has been identified and EPSS is very low at 0.16% (6th percentile), with no CISA KEV listing.

XML external entity injection in the SAP Adapter component of IBM App Connect Enterprise and IBM Integration Bus for z/OS enables authenticated remote users to read arbitrary files from the server filesystem or conduct server-side request forgery against internal network resources. Affected releases span App Connect Enterprise 12.0.1.0-12.0.12.28 and 13.0.1.0-13.0.8.1, plus Integration Bus for z/OS 10.1.0.0-10.1.0.7. The CVSS scope-change flag (S:C) reflects that a successful XXE can pivot beyond the integration engine itself into adjacent internal infrastructure. No public exploit has been identified at time of analysis, and IBM has released a patch.

Unauthenticated remote file read in RESTEasy's SourceProvider component allows network attackers to exfiltrate arbitrary server-side files by exploiting an XML External Entity (XXE) flaw. The vulnerability exists because SourceProvider.writeTo() instantiates a SAXParser without disabling external entity resolution, so any endpoint that accepts application/xml and returns a Source or StreamSource type will parse attacker-controlled DOCTYPE declarations and leak file contents in the HTTP response. CVSS rates this 7.5 (High) with full confidentiality impact; no public exploit code or CISA KEV listing is identified at time of analysis, but the low-complexity unauthenticated network vector makes this a credible threat wherever RESTEasy-backed XML endpoints are exposed.

XML external entity injection across three document parsers in YaCy Search Server through version 1.941 enables unauthenticated network attackers to exfiltrate arbitrary local file contents via the search crawler. When the YaCy crawler fetches attacker-controlled SVG, FreeMind, or OpenSearch XML documents containing malicious DOCTYPE SYSTEM entity declarations, the unprotected SAX parsers resolve those entities and write the referenced file contents directly into the searchable index. No public exploit code or active exploitation has been confirmed at time of analysis, but a patch commit is available upstream and the XXE technique is trivially reproducible.

Unauthenticated XML External Entity (XXE) injection in MapFish Print's GML layer parser allows remote attackers to read arbitrary server-side files and conduct server-side request forgery (SSRF) via a single crafted HTTP POST to the /api/print3/print endpoint. All 3.x branches prior to 3.28.30, 3.30.32, 3.31.24, and 3.33.16, as well as 4.x prior to 4.0.5, are affected. A fully functional proof-of-concept exploit has been publicly disclosed in the GitHub Security Advisory GHSA-5v29-34h8-v68r, enabling exfiltration of Kubernetes service account tokens, OS credential files, and TLS certificates with no authentication required.

Unauthenticated remote file disclosure in Cisco BroadWorks stems from the OCI XML Parser permitting external entity resolution by default, allowing an attacker to read arbitrary filesystem files with the privileges of the BroadWorks process account. The affected component is the Open Client Interface - Provisioning (OCI-P) service, reachable over the network with no authentication or user interaction required, yielding a CVSS 7.5 score with C:H. No public exploit has been identified at time of analysis, and this vulnerability has not been confirmed as actively exploited by CISA KEV.

XXE injection in Datavane TIS v5.0.0 exposes authenticated attackers a path to SSRF and out-of-band file exfiltration against the server hosting the application. The `doEditWorkflow` endpoint accepts a `taskScript` parameter parsed by an unhardened Java `DocumentBuilderFactory` that resolves external entities and loads external DTDs, allowing a crafted XML payload to trigger outbound HTTP requests to attacker-controlled infrastructure and read local files accessible to the TIS process user, including configuration files and Derby database credentials. No public exploit has been identified at time of analysis, but VulnCheck has published a dedicated advisory and the upstream patch commit is publicly accessible, providing clear technical signal about the vulnerable code path.

XXE injection in Eclipse RDF4J exposes applications to local file disclosure and server-side request forgery when parsing untrusted XML-based RDF data or SPARQL query results. The root cause is an incomplete remediation of CVE-2018-1000644: while that earlier fix hardened some parser entry points, several XML parser interfaces remained unprotected against DOCTYPE declarations, external entity references, and external DTD loading. No public exploit has been identified at time of analysis, and no CISA KEV listing exists, but the unauthenticated network vector (CVSS 4.0: 8.7, PR:N) means any application exposing RDF ingestion endpoints is at risk without upgrading to RDF4J 5.3.2.

Unauthenticated XML External Entity (XXE) injection in TIBCO/Jaspersoft JasperReports Server (9.0.0 before HF-9 and 10.0.0 before HF-10) allows a remote attacker to submit crafted XML that the server's parser resolves, enabling local file disclosure and server-side request forgery against internal systems. The vendor rates it CVSS 4.0 9.3 (Critical) and no authentication is required. There is no public exploit identified at time of analysis and it is not in CISA KEV, but the unauthenticated network vector makes it a high-priority patch.

XML External Entity injection in Apache CXF's WSDL import processing allows attackers who can influence imported WSDL or XSD documents to bypass XXE protections applied to the top-level WSDL. CXF correctly hardens top-level WSDL parsing via StaxUtils, but delegates all <wsdl:import> and <xsd:import> resolution to WSDL4J, which lacks equivalent DOCTYPE and external entity restrictions - creating a security boundary mismatch that nullifies the top-level protections. No public exploit has been identified at time of analysis, but CWE-611 is a well-understood attack class with established tooling; successful exploitation against vulnerable deployments can yield arbitrary server-side file reads and SSRF. Vendor-released patches are available across three active release branches.

XML External Entity injection in IBM QRadar SIEM (versions 7.5.0 through 7.5.0 UP 15 IF005 and 7.6.0.0 through 7.6.0.1) lets remote unauthenticated attackers submit crafted XML-formatted syslog events to the parseXmlPayload() function in the event-processing pipeline. When any log source type uses XML-format property autodetection, events arriving on port 514 (UDP/TCP) are parsed without authentication, enabling file disclosure, SSRF, and denial of service. No public exploit identified at time of analysis, but EPSS is a low 0.32% (25th percentile) and IBM has published a fix.

Remote code execution, arbitrary file write, and privilege escalation vulnerabilities in Jenkins core (through 2.575 / LTS 2.568.1) and multiple plugins expose CI/CD infrastructure to full controller compromise. The most critical issue (CVE-2026-70426) allows agent processes and users with Agent/Connect permission to bypass the JEP-200 deserialization class filter via an unguarded fallback path in the Remoting library, enabling code execution on the Jenkins controller. Two independent arbitrary file write vectors (CVE-2026-70427 via malicious tar archives, CVE-2026-70428 via path traversal in file parameter names) can achieve equivalent controller-level code execution by writing Groovy scripts to JENKINS_HOME/init.groovy.d/ or deploying rogue plugins. No CISA KEV listing or public exploit has been identified at time of analysis, though the Jenkins security team coordinated a pre-announcement, suggesting no known active exploitation at disclosure.

Out-of-band file exfiltration in Gladinet CentreStack before 17.4 lets unauthenticated remote attackers read arbitrary server files by abusing an XML External Entity (XXE) flaw in the SharePoint StorageConfig handler. By pointing the storage configuration at a malicious URL, an attacker forces the server to parse attacker-controlled XML with external DTD references and leak sensitive files such as Web.config, exposing database credentials and cryptographic key material. Reported by VulnCheck; no public exploit identified at time of analysis, and the CVSS 4.0 base score is 8.7 (High).

Arbitrary file disclosure and Server-Side Request Forgery in veraPDF's validation-model module allow a remote attacker to read files off the validating host and force outbound requests by feeding it a crafted PDF. The flaw lives in DictionaryKeysHelper.getRichTextStringOrStreamEntryStringRepresentation(), which parses XHTML rich-text (/RC or /RV) annotation content with a default, unhardened DocumentBuilderFactory that resolves external entities and then reflects the expanded entity contents back into the validation report. All current releases of both the classic (org.verapdf:validation-model) and Jakarta (validation-model-jakarta) artifacts are affected; there is no public exploit identified at time of analysis and it is not listed in CISA KEV, though the vendor advisory (GHSA-3jh7-wm29-q568) describes exploitation as trivial.

Arbitrary file read and Server-Side Request Forgery in veraPDF-validation (and the validation-model-jakarta variant) let a remote attacker exfiltrate server files or reach internal services by submitting a crafted PDF whose XFA stream carries a malicious XML DOCTYPE. The insecure XML parser is reached automatically whenever a PDF is validated against the PDF/UA-1 profile, including via flavour auto-detection, so no operator action beyond normal validation is needed. There is no public exploit identified at time of analysis and it is not listed in CISA KEV, but the vendor advisory (GHSA-36mm-w85j-3q2j) and a fixing patch are confirmed.

Arbitrary file disclosure in Jinher OA C6 allows unauthenticated remote attackers to read sensitive server files through an XML External Entity flaw in the HrmAttendance sp_manager_getUserlist.aspx GetXmlHttp endpoint, which parses attacker-supplied XML without disabling external entity resolution. Because the attack is unauthenticated (PR:N) and network-reachable (AV:N), a crafted XML payload triggers an out-of-band request that exfiltrates file contents. A public proof-of-concept exists in a GitHub repository, though it is not listed in CISA KEV and EPSS remains low (0.25%), indicating publicly available exploit code but no confirmed active exploitation.

XML external entity exposure in the Netty network framework affects the optional XmlDecoder handler in versions 4.2.0.Final through 4.2.15.Final and 4.1.0.Final through 4.1.135.Final, where the underlying Aalto AsyncXMLInputFactory is instantiated without any security hardening. Any remote party able to push bytes into a channel pipeline that contains XmlDecoder can submit XML carrying a DOCTYPE/DTD declaration, and depending on Aalto async parser behavior DTD and entity processing remains active, creating a conditional path to reading local files or performing SSRF-style out-of-band requests. There is no public exploit identified at time of analysis, the issue is not on CISA KEV, and it is fixed in 4.1.136.Final and 4.2.16.Final.

Sensitive file and internal resource disclosure in Netcad Software NetGIS (versions 5.0.66 up to but not including 7.2.2) arises from an XML External Entity (XXE) flaw where the application resolves external entity references in serialized/XML data submitted by clients. Remote attackers can craft malicious XML payloads to read local files, exfiltrate data, or reach internal network resources on the server. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV; it was reported by Turkey's national CERT (TR-CERT/USOM).

XML External Entity injection in the libpve-storage-perl library (the storage-management Perl backend of Proxmox VE) affects builds identified as libpvestorage-perl v9.1.1 and libpve-storage-perl v8.3.7, per MITRE. An attacker able to submit crafted XML to an affected storage-handling code path can force the parser to resolve external entities, enabling arbitrary local file disclosure and potential SSRF or denial of service. There is no public exploit identified at time of analysis and the CVE is not listed in CISA KEV; EPSS was not provided.

Sensitive file disclosure and potential account takeover in Adobe Experience Manager (AEM as a Cloud Service, 6.5, and 6.5 LTS) arises from unsafe XML External Entity (XXE) processing that Adobe classifies as leading to arbitrary code execution in the current user's context. A low-privileged, authenticated attacker (PR:L) can trigger the flaw remotely over the network with no user interaction, reading protected files and pivoting to elevated access or session control. There is no public exploit identified at time of analysis and it is not listed in CISA KEV, but the 9.6 CVSS score and scope-change make it a high-priority patch.

Arbitrary file read in OpenRemote's KNXProtocol asset-import handler lets any authenticated user (PR:L, any realm) upload a malicious ETS project ZIP whose 0.xml is parsed via Saxon XSLT and XMLInputFactory without XXE hardening, resolving external entities to exfiltrate server files such as /etc/passwd, openmrs-runtime.properties, and cloud credential files, with SSRF against internal endpoints as a secondary impact. This is an incomplete-fix regression of CVE-2026-40882, which only hardened the parallel Velbus handler and left KNXProtocol's two XML parsing calls unprotected. A full working proof-of-concept reproducing both parsing stages is publicly available; the vulnerability is not listed in CISA KEV.

XML external entity (XXE) injection in IBM Business Automation Manager Open Editions 9.0.0 through 9.4.2 lets a remote, unauthenticated attacker submit crafted XML to the application's XML parser to read sensitive files or exhaust memory. The flaw carries a CVSS 9.1 (high confidentiality and availability impact) but has no public exploit identified at time of analysis, and EPSS is low at 0.39% (31st percentile). Reported by IBM PSIRT with a vendor advisory published (IBM support node 7278532).

Server-side request forgery and denial of service in Red Hat Build of Apicurio Registry 3 stem from unsafe XML parsing in the ContentTypeUtil.isParsableXml() method, which builds a SAXParserFactory without secure processing or external-entity restrictions (CWE-611, XXE). An attacker with artifact-write permission - or any unauthenticated client when the registry runs in its default configuration - can upload a crafted XML artifact whose external DTD/entity references force the server to fetch attacker-chosen URLs (blind SSRF into internal networks) or expand nested entities for resource-exhaustion DoS. CVSS is 8.5 (scope-changed, high availability impact); no public exploit identified at time of analysis.

XML external entity (XXE) injection in the Jenkins Assembla Plugin version 1.4 and earlier lets an attacker who can control the HTTP responses of the configured Assembla server read sensitive files and secrets from the Jenkins controller and pivot into internal services via server-side request forgery. Mapped to CWE-918 (SSRF) with a CVSS 3.1 base score of 7.1 (high), there is no public exploit identified at time of analysis and CISA SSVC rates exploitation as 'none' with only partial technical impact. Exploitation requires the attacker to influence what the Assembla endpoint returns, so it is a targeted rather than mass-exploitable condition.

Arbitrary file disclosure in Grav CMS versions prior to 2.0.0-beta.2 allows authenticated admin-panel users to read sensitive server files via XML External Entity (XXE) injection in SVG upload processing. The flaw stems from simplexml_load_string() being called without entity-loader protections, enabling exfiltration of credentials, configuration, and environment secrets. No public exploit identified at time of analysis, though the GHSA advisory includes a working proof-of-concept payload.

XML External Entity injection in the HAPI FHIR core library (Maven ca.uhn.hapi.fhir:org.hl7.fhir.utilities, versions <= 6.9.9) lets an attacker who controls or MITMs XML routed through XsltUtilities.saxonTransform(...) read local files and perform blind XXE/SSRF. The three saxonTransform overloads instantiate a bare net.sf.saxon.TransformerFactoryImpl that resolves external general and parameter entities, unlike the co-located transform() siblings that use the project's hardened XXE-protected factory. Publicly available exploit code exists (a full end-to-end PoC accompanies the GitHub advisory), though there is no public exploit identified as actively used in the wild.

XML External Entity (XXE) processing in Apache CXF versions prior to 4.1.7 and 4.2.0-4.2.1 allows remote attackers to trigger out-of-band external entity resolution via the EndpointReferenceUtils and W3CMultiSchemaFactory classes, which instantiate SAXParserFactory without JAXP hardening. While CVSS scores this 9.8 critical, EPSS reports only 0.02% exploitation probability, and there is no public exploit identified at time of analysis. Successful exploitation could enable data exfiltration, SSRF, or denial-of-service against applications that process attacker-controlled XML through CXF web services.

XML External Entity (XXE) exposure in Spring Web Services' Jaxp13XPathTemplate allows remote attackers to abuse XPath evaluation over StreamSource and SAXSource inputs because the underlying parser falls back to the JDK's default DocumentBuilderFactory rather than Spring's hardened configuration. Affected versions span the 3.1.x, 4.0.x, 4.1.x and 5.0.x release lines, and while no public exploit was identified at time of analysis, the CVSS 8.2 vector (AV:N/AC:L/PR:N/UI:N) indicates that any service that feeds untrusted XML through this template can be reached by unauthenticated remote attackers. The flaw was reported by VMware/Spring and is tracked in the official Spring security advisory.

Arbitrary file read in Adobe ColdFusion 2023.19, 2025.8 and earlier allows remote unauthenticated attackers to exfiltrate sensitive files from the host filesystem via a malicious XML document that a victim opens through the application. The scope-changed CVSS 7.4 reflects that exploitation can impact resources beyond ColdFusion's own security context, though success hinges on user interaction. No public exploit identified at time of analysis, and the issue is not listed in CISA KEV.

Server-side file disclosure in Schneider Electric EcoStruxure IT Data Center Expert v9.1.1 and prior allows authenticated users to read arbitrary files on the underlying host by submitting crafted XML payloads to SOAP service endpoints. The flaw stems from improper restriction of XML External Entity references (CWE-611) in the SOAP API. No public exploit identified at time of analysis, but CISA SSVC marks the issue as automatable with partial technical impact.

XML External Entity (XXE) injection in Docling's USPTO patent backend allows remote attackers to trigger denial of service, read arbitrary server files, or perform SSRF by submitting crafted patent XML to vulnerable versions (>=2.13.0, <2.74.0). The flaw stems from use of Python's unsafe xml.sax.parseString() across the ICE v4.x, Grant v2.5, and Application v1.x parsers. No public exploit identified at time of analysis, but the fix is publicly documented in the vendor advisory and a working patched release is available.

Local file disclosure and denial of service in the Docling document-conversion library (Python pip package, versions 2.45.0 up to 2.91.0) stem from its METS-GBS backend parsing XML and extracting archives without security controls. A maliciously crafted METS-GBS archive processed by Docling can trigger XML External Entity (XXE) resolution to read sensitive local files, or use decompression/zip bombs and unbounded tar extraction to exhaust memory and disk. EPSS is very low (0.01%, 3rd percentile) and there is no public exploit identified at time of analysis; exploitation requires a victim application to process attacker-supplied input.

XML External Entity (XXE) local file disclosure in Symfony's DomCrawler component allows remote attackers to read arbitrary server-side files when an application parses attacker-controlled XML via Crawler::addXmlContent(). The method explicitly set DOMDocument::$validateOnParse = true, which re-enabled libxml DTD subset processing and external entity resolution; because LIBXML_NONET only blocks network fetches and not file:// entities, an entity such as SYSTEM "file:///etc/passwd" is expanded and its contents exposed. EPSS is very low (0.05%, 17th percentile) and there is no public exploit identified at time of analysis, though the vendor commit ships a demonstrative test case.

External XML entity resolution in Hitachi Vantara Pentaho Data Integration & Analytics lets an authenticated, low-privileged attacker submit crafted XML that the application's parser resolves, disclosing sensitive local files and enabling server-side request forgery against internal systems. All releases before 10.2.0.7 are affected, as are 11.x branches before 11.0.0.0, explicitly including the 9.3.x and 8.3.x lines. There is no public exploit identified at time of analysis, and the EPSS exploitation probability is very low (0.03%, 8th percentile).

XML External Entity (XXE) injection in IBM Engineering Lifecycle Management (ELM) 7.0.3, 7.1.0, and 7.2.0 allows authenticated attackers to disclose sensitive information or exhaust memory resources by submitting crafted XML data to the application. The flaw carries a CVSS 7.1 (High) rating with low attack complexity over the network, but EPSS is only 0.02% (5th percentile) and there is no public exploit identified at time of analysis. SSVC classifies exploitation as 'none' with partial technical impact, indicating low immediate urgency despite the vendor-released patch.

Remote file disclosure in Cisco Catalyst SD-WAN Manager allows unauthenticated attackers to read arbitrary system files via XML External Entity (XXE) injection in the web UI. The vulnerability affects the management interface with network-accessible attack vector, low complexity, and no required privileges (CVSS 8.6). Attackers can extract sensitive configuration files, credentials, and operational data from the SD-WAN management platform. EPSS data not provided; exploitation status unknown but the unauthenticated remote vector and publicly disclosed Cisco advisory elevate real-world risk for internet-exposed instances.

Denial of service in Docling through version 2.61.0 lets remote attackers crash or exhaust resources on any system that parses a document via the JATS XML backend. The backend calls etree.parse() without disabling entity resolution, so a maliciously crafted JATS/XML file containing nested entity definitions (a 'billion laughs' XML bomb) triggers exponential entity expansion and consumes all available CPU/memory. No public exploit identified at time of analysis; EPSS is very low (0.02%) and SSVC records no observed exploitation, so this is a high-CVSS availability issue rather than an actively exploited threat.

Denial of service in Docling's METS GBS backend (through version 2.61.0) allows remote attackers to exhaust CPU and memory by submitting a malicious .tar.gz archive containing an XML bomb. The backend parses embedded XML with etree.fromstring() while entity resolution remains enabled, so recursively nested entity definitions expand exponentially during parsing and stall or crash the host processing the document. EPSS is very low (0.02%) and there is no public exploit code or KEV listing, but a vendor-published Notion write-up describes the flaw in detail.

XML external entity injection in Vvveb CMS versions before 1.0.8.2 allows authenticated site_admin users to read arbitrary server files and overwrite administrator password hashes via the admin Tools/Import feature. The vulnerability resides in system/import/xml.php where LIBXML_NOENT flag enabled external entity resolution, allowing injection of file:// and php://filter protocols. Attackers with low-privilege admin accounts can escalate to full administrator access by replacing password hashes in the database. Vendor-released patch version 1.0.8.2 removes LIBXML_NOENT flag. No active exploitation confirmed by CISA KEV at time of analysis.

XML External Entity injection in OpenCMS (versions through v20) allows remote unauthenticated attackers to achieve information disclosure, server-side request forgery, or arbitrary code execution via malicious .zip files uploaded to the Admin Import DB feature. The vulnerability stems from unsafe XML parsing of manifest.xml files within these archives. Despite a maximum CVSS 9.8 score, the real-world risk is limited by the administrative-only attack surface - exploitation requires access to privileged admin import functionality. No active exploitation confirmed (not in CISA KEV), and EPSS score of 0.03% (7th percentile) indicates minimal observed threat activity. Upstream fix available via GitHub commit e3e41e5a, though a tagged release version has not been independently verified.

XML External Entity (XXE) injection in changedetection.io version 0.54.9 and earlier allows local file disclosure when processing attacker-controlled XML or RSS feeds. The xpath_filter() function in html_tools.py creates an lxml parser without disabling external entity resolution, enabling attackers to embed DOCTYPE declarations that read sensitive files from the host system. Extracted content appears in watch output, diff history, and notification channels. No vendor-released patch identified at time of analysis. CVSS 8.2 reflects high confidentiality impact with attack complexity high due to specific runtime parser behavior requirements.

XML External Entity injection in Apache OpenNLP's DictionaryEntryPersistor allows remote unauthenticated attackers to disclose local files or perform server-side request forgery when processing untrusted dictionary files. The vulnerable SAX parser initialization omits critical security features (FEATURE_SECURE_PROCESSING, DTD disablement) present elsewhere in the codebase, creating an inconsistency exploitable via the public Dictionary(InputStream) API when loading stop-word lists or domain dictionaries. With EPSS at 0.03% (8th percentile) and no active exploitation reported, this represents a code-quality issue in a specific input path rather than an imminent widespread threat, though the CVSS 9.1 reflects maximum theoretical impact given the network-accessible, unauthenticated attack vector.

XML external entity injection in SpringBlade v4.8.0's /designer/loadReport endpoint enables authenticated attackers to execute arbitrary code remotely. The vulnerability requires low-privilege authentication (PR:L) but no other special conditions (AC:L, UI:N), allowing attackers with basic credentials to compromise confidentiality, integrity, and availability. EPSS probability is low (0.02%, 6th percentile) indicating minimal observed exploitation activity. No CISA KEV listing confirms this is not yet widely exploited in the wild, though a GitHub issue documents the flaw suggesting proof-of-concept details may exist.

XML injection in @xmldom/xmldom XMLSerializer allows remote attackers to inject arbitrary markup into serialized DOCTYPE declarations by crafting malicious DocumentType node properties (internalSubset, publicId, systemId). When applications programmatically create DocumentType nodes with attacker-controlled data via createDocumentType() and serialize the result, the serializer emits these fields verbatim without escaping or validation. Three distinct injection vectors exist: internalSubset containing ']>' terminates the DOCTYPE early; publicId containing quoted strings injects fake SYSTEM entities; systemId containing '>' breaks the declaration boundary. Downstream XML parsers re-parsing the serialized output may expand injected entities, enabling XXE attacks. No public exploit identified at time of analysis. EPSS data not provided. Vendor-released patch requires opt-in: applications must explicitly pass {requireWellFormed: true} to serializeToString() to enable validation guards; default behavior remains vulnerable to preserve backward compatibility with DOM Parsing spec.

Local file disclosure via XML External Entity (XXE) injection affects the lxml Python library (versions < 6.1.0) when applications parse untrusted XML using iterparse() or ETCompatXMLParser(), whose default configuration left resolve_entities=True. An unauthenticated remote attacker who can submit crafted XML to such an endpoint can read arbitrary local files readable by the process. There is no public exploit identified at time of analysis and EPSS risk is very low (0.03%), but exploitation is trivial (CVSS 7.5, AV:N/AC:L/PR:N/UI:N) wherever these two specific parsers are used.

Limited file disclosure and server-side request forgery in OpenRemote Manager through 1.21.0 allow authenticated low-privileged users to read local files under 1023 characters from the Manager host and initiate outbound connections. A publicly available proof-of-concept exists, but no active exploitation has been reported. The EPSS probability is very low at 0.06%.

XML External Entity (XXE) injection in Pachno 1.0.6's TextParser helper allows remote unauthenticated attackers to read arbitrary files from the server. The vulnerability is triggered through malicious XML entities embedded in wiki table syntax and inline tags within issue descriptions, comments, or wiki articles, exploiting unsafe simplexml_load_string() calls without LIBXML_NONET protections. With CVSS 9.3 and EPSS 0.04% (14th percentile), this represents a high-severity but low-probability threat. No active exploitation (CISA KEV) or public exploit code has been identified at time of analysis.

XML External Entity (XXE) injection in RTI Connext Professional routing and service components allows remote unauthenticated attackers to exfiltrate sensitive data and trigger denial of service conditions. Affects multiple product families (Routing Service, Observability Collector, Recording Service, Queueing Service, Cloud Discovery Service) across versions 5.3.0 through 7.6.x. CVSS 8.8 (High) with network vector and no authentication required. EPSS probability remains low (0.04%, 11th percentile) with no confirmed active exploitation per CISA. Vendor patch available via RTI advisory.

Grav CMS versions 1.7.x and earlier allow XML External Entity (XXE) injection through SVG file uploads in the administrative panel and File Manager plugin, potentially enabling remote code execution or information disclosure to authenticated administrators. No CVSS score, CVSS vector, or CWE classification has been assigned; exploitation status and patch availability cannot be confirmed from available data.

OpenEMR versions prior to 8.0.0.3 contain an XML External Entity (XXE) injection vulnerability in the Carecoordination module that allows authenticated users to read arbitrary files from the server. Attackers can exploit this by uploading a maliciously crafted CCDA document containing XXE payloads to access sensitive server files such as /etc/passwd. A patch is available in version 8.0.0.3, and this vulnerability has a CVSS score of 7.7 with high confidentiality impact.

An XML External Entity (XXE) vulnerability in the XMLUtils.java component of Slovensko.Digital Autogram allows remote unauthenticated attackers to conduct Server-Side Request Forgery (SSRF) attacks and read local files from the filesystem. The vulnerability affects Autogram software and can be exploited when a victim visits a specially crafted website that sends malicious XML to the application's local HTTP server /sign endpoint. A blog post detailing exploitation research is publicly available, increasing the likelihood of exploitation attempts.