Skip to main content

xml_builder EUVDEUVD-2026-63879

| CVE-2026-48590 LOW
XML Injection (aka Blind XPath Injection) (CWE-91)
2026-08-21 EEF
2.1
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Attacker supplies crafted string containing structural XML characters as form field name or JSON key
  2. Delivery
    Host application passes input verbatim to XmlBuilder.element as name argument
  3. Exploit
    Library interpolates unsanitized name into XML byte stream
  4. Execution
    Structural characters break tag boundary in serialized output
  5. Persist
    Downstream XML consumer parses attacker-controlled structure
  6. Impact
    Injected markup causes content spoofing or unexpected document structure

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization XPath query parameterization
Exploitation Conditions

Exploitation requires the host application to pass user-controlled data - such as HTTP form field names, JSON object keys, or similar external string inputs - directly as the name argument to XmlBuilder.element or related functions without prior sanitization. This is the essential gate: applications that only pass static, developer-defined strings as element or attribute names are not exploitable regardless of what users supply as element content or attribute values. The CVSS 4.0 AT:P metric correctly reflects this specific attack-target condition. Authentication requirements for reaching the vulnerable code path depend entirely on the host application's access controls and cannot be determined from the library-level CVE data alone. Exploitation is further limited in impact to scenarios where the resulting XML document is consumed by a parser or system that treats the output as structured markup; applications that treat the XML as opaque bytes or re-validate it downstream may experience no meaningful impact.

Impact

The vendor-assigned CVSS 4.0 score of 2.1 (AV:L/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:N/SI:L/SA:N) reflects a narrow impact: subsequent-system low integrity only, with no confidentiality or availability component. The AV:L (local) assignment deserves scrutiny - the CVE description explicitly cites HTTP form field names and JSON object keys as realistic attack sources, meaning real-world exploitation in web applications is network-triggered even though the library itself is assessed locally; this tension should be verified against the host application's attack surface rather than accepted at face value. AT:P correctly captures the specific precondition: the host application must pass user-controlled strings as XML element names, which is not the default or recommended usage pattern. No EPSS data was supplied, KEV status is absent, and no standalone public exploit code has been identified - all low-urgency signals. Combined with the library's narrow Elixir ecosystem footprint and the integrity-only downstream impact, this is low priority for most organizations unless they operate an application known to route untrusted input directly into XmlBuilder name arguments. The risk assessment is constrained by the absence of EPSS scoring in the provided intelligence.

Exploit ScenarioDerived

An attacker submits a crafted HTTP form field name such as x><!--injected--><evil attr="bad" to a web application that uses xml_builder to serialize request parameters into an XML document. The application passes the field name verbatim to XmlBuilder.element/3, causing the library to interpolate the structural characters into the output, breaking tag boundaries and embedding the attacker's markup. A downstream XML parser or API consumer then processes the corrupted document, potentially accepting spoofed data or triggering unexpected application logic. The GitHub advisory's test suite demonstrates this exact pattern, though no standalone exploit tool has been identified.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 21, 2026

XML injection in joshnuss xml_builder (Elixir) allows an attacker who can influence element names, attribute names, or doctype identifiers to inject arbitrary XML markup - including extra elements, comments, and event-handler attributes - into the serialized document output. All library releases from 0.0.1 through 2.4.0 are affected; the vulnerability resides in the core XmlBuilder.element and XmlBuilder.generate API surface. No active exploitation has been confirmed (CVE is not in CISA KEV), and no standalone public exploit code has been identified, though the GitHub security advisory includes demonstrative test cases.

RemediationAI

Upgrade xml_builder to version 2.4.1, which introduces the sanitize! validation function across all name-interpolation sites; the patch is available at https://github.com/joshnuss/xml_builder/commit/d5c0aec32a8eecbb440fb9bbb0f59d4d188d5859 and the advisory is at https://github.com/joshnuss/xml_builder/security/advisories/GHSA-r82p-3q2p-728w. If upgrade is temporarily blocked, the primary compensating control is to allowlist or validate any user-controlled string before passing it as a name argument to any XmlBuilder function - specifically, reject strings containing <, >, ", ', &, /, =, or whitespace characters at the application layer. This shifts the sanitization burden to every call site in the application, which carries meaningful regression risk if new XmlBuilder call sites are introduced without equivalent guards; upgrade is strongly preferred over relying on this workaround.

Affected VersionsENISA

xml_builder 0.0.1 <2.4.1
xml_builder 9fb49131ad3ee146a4c9db9bc175bdffe32e30a0 <d5c0aec32a8eecbb440fb9bbb0f59d4d188d5859

Affected Packages

euvd xml_builder fix: 2.4.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

xml_builder is an Elixir library for programmatically constructing and serializing XML documents (CPE: cpe:2.3:a:joshnuss:xml_builder:*:*:*:*:*:*:*:*). The root cause (CWE-91, XML Injection) is that lib/xml_builder.ex passed element names, attribute names, and doctype identifiers through Elixir's to_string/1 and interpolated the result verbatim into the serialized XML byte stream with no validation against the XML Name production grammar. Structural characters - <, >, ", ', &, /, = - were not rejected or escaped, allowing a name argument containing those characters to break tag boundaries and introduce arbitrary markup. The patch commit (d5c0aec32a8eecbb440fb9bbb0f59d4d188d5859) introduces a private sanitize! function guarded by a Unicode-aware regex (~r/^[\p{L}_:][\p{L}\p{N}_.-:]*$/u) that raises XmlBuilder.SanitizationError on any non-conforming name, applied consistently across all element and attribute serialization paths.

Know when Xml Builder 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 (EEF) PRIMARY 2.1 LOW
CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:N/SI:L/SA:N
vuln.today AI 4.0 MEDIUM

Network-sourced input triggers exploitation (AV:N) but requires the host app to pass untrusted data as XML names (AC:H); downstream document integrity impact with scope change (S:C/I:L); no confidentiality or availability impact.

3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:L/A:N
4.0 AV:N/AC:H/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:N/SI:L/SA:N

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
Low
Subsequent system: Availability
None

DescriptionCVE.org

XML Injection vulnerability in joshnuss xml_builder (XmlBuilder module) allows Content Spoofing, XML Injection.

This vulnerability is associated with program files lib/xml_builder.ex and program routines XmlBuilder.generate/1, XmlBuilder.generate/2, XmlBuilder.element/1, XmlBuilder.element/2, XmlBuilder.element/3.

Element names, attribute names, and doctype identifiers are interpolated verbatim into the serialized XML output without validation or escaping of structural characters (<, >, ", ', &). An attacker who can influence a name argument (for example, an element name derived from a JSON object key or an HTTP form field name) can inject arbitrary XML markup including extra elements, comments, and event-handler attributes into the output document.

This issue affects xml_builder: from 0.0.1 before 2.4.1.

Threat Intelligence Overview

EPSS Score
0.2%
Top 87% exploitable
Prevalence
Low
niche Elixir ecosystem library, limited enterprise production footprint
Data Quality
6 sources
Confidence: High

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 LOW
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

10
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

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