Skip to main content

Kitodo.Production CVE-2026-54668

| EUVDEUVD-2026-109091 HIGH
Improper Restriction of XML External Entity Reference (CWE-611)
2026-10-23 security-advisories@github.com
8.7
CVSS 4.0 · Vendor: github
View

Attack ChainAIDerived

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

  1. Access
    Authenticate as import-capable user
  2. Exploit
    Upload crafted EAD/XML via Create-process dialog
  3. Execution
    Unhardened JAXP parser resolves external entity
  4. Impact
    Disclose local files or issue SSRF requests

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A02:2025 - Security Misconfiguration
ASVS 5.0
V13 - Configuration XML external entity prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires an authenticated account with permission to create a process / run catalog or EAD import - any role that can reach the 'Create process' file-upload dialog; no administrator privilege is needed, and the attacker fully controls the uploaded XML bytes. The trigger is the EAD-import path routing uploaded bytes to XMLUtils.parseXMLString, getNumberOfEADElements and checkIfXmlIsWellFormed, which build DocumentBuilderFactory/XMLInputFactory/SAXParserFactory via newInstance() with the default (insecure) JAXP configuration, leaving DOCTYPE declarations and external entity/DTD resolution enabled. No non-default configuration is required - the vulnerable methods ship insecure by default in versions <= 3.9.1. Limiting factors: authentication plus access to the import feature, and the bug being fixed in 3.9.2 (sibling parsers load()/newDocument() and the catalog-response handlers were already hardened, so only the upload path is affected).

Impact

This is a genuine but conditional priority rather than a mass-exploitation emergency. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N, VC:H/VI:H/VA:H, score 8.7 High) and CWE-611 are consistent with the confirmed mechanism: an authenticated user (PR:L) uploads attacker-controlled XML that an unhardened JAXP parser expands, yielding file disclosure and SSRF. The key limiting signal is PR:L - exploitation requires an account that can reach the 'Create process' import dialog, so this is not an anonymous internet-facing bug despite AV:N. No CISA KEV listing and no EPSS score are provided, so there is no evidence of active or widespread exploitation; the vuln.today Decision label is 'this_week' (not act_now/emergency), aligning with a patch-promptly posture rather than drop-everything. A public PoC exists in the GitHub advisory, but it demonstrates XXE against byte-for-byte copies of the vulnerable method bodies on OpenJDK 17, not against a live deployed Kitodo instance, so exploitability against the running product is strongly inferred but not independently verified end-to-end. Note the vendor CVSS claims VC:H/VI:H/VA:H (full triad); the documented impact is primarily confidentiality (local file read, SSRF) with secondary availability (billion-laughs DoS) and only indirect integrity via SSRF-triggered requests, so the integrity/availability 'High' ratings look aggressive relative to the described mechanism.

Exploit ScenarioDerived

An authenticated Kitodo user with permission to create a process uploads a crafted EAD/XML file through the 'Create process' file-upload dialog; the server parses it with a default-configured JAXP parser that resolves an embedded external entity, reading a local file (e.g. a config file containing DB credentials) or issuing an outbound request to an internal/cloud-metadata endpoint. A public PoC in the advisory reproduces both file disclosure and OOB-SSRF against verbatim copies of the vulnerable methods on OpenJDK 17. Low attack complexity means no special timing or grooming is needed once the attacker holds an import-capable account.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 23, 2026

XML external entity injection in Kitodo.Production 3.8.x and 3.9.x through 3.9.1 lets any authenticated user who can reach the 'Create process' file-upload dialog read server-side files and trigger outbound server requests by uploading a crafted EAD/XML document. The uploaded bytes are parsed by XMLUtils.parseXMLString, getNumberOfEADElements and checkIfXmlIsWellFormed, which build JAXP parser factories with default settings so DOCTYPE declarations and external entity resolution remain enabled (CWE-611); the upstream advisory documents a reproduction with a local-file canary, an out-of-band callback and a hardened-sibling negative control, though no confirmed weaponized exploit and no CISA KEV listing exist. A vendor patch ships in 3.9.2, and because the path requires only a low-privileged authenticated import user rather than anonymous access or admin rights, our assessment lands at CVSS:3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L - a genuine but conditional priority rather than a mass-exploitation emergency, scheduled for this week.

RemediationAI

Upgrade Kitodo.Production to 3.9.2 or later, which contains the XMLUtils hardening (disabling DOCTYPE declarations and external entity resolution across the DocumentBuilderFactory, XMLInputFactory and SAXParserFactory paths); the vendor states no database migration is required when updating from a previous 3.9 release, so the upgrade is a drop-in replacement. Advisory and release references are https://github.com/kitodo/kitodo-production/security/advisories/GHSA-mff2-fpqj-jg4q and https://github.com/kitodo/kitodo-production/releases/tag/kitodo-production-3.9.2. Where upgrading cannot be done immediately, the exposure is bounded by the prerequisite the advisory itself describes: the flaw is only reachable by an authenticated user holding permission to create a process or run the catalog/EAD import and thus reach the 'Create process' file-upload dialog, so restrict that permission to trusted operators and treat EAD/XML uploads from untrusted parties as hostile input; note that this narrows the attack surface but does not fix the underlying parser configuration for the users who still hold the permission. The upstream suggested fix, for anyone maintaining a fork, is to apply the same hardening already used in XMLUtils.load()/newDocument() and the catalog-response parsers to every parser factory in XMLUtils (SECURE_PROCESSING plus disallow-doctype-decl, external-general-entities and external-parameter-entities false, and SUPPORT_DTD / IS_SUPPORTING_EXTERNAL_ENTITIES false on the StAX factory).

Affected VersionsENISA

kitodo-production < 3.9.2

Affected Packages

euvd kitodo_production fix: 3.9.2

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

The affected code is Java XML parsing built on JAXP in Kitodo/src/main/java/org/kitodo/production/helper/XMLUtils.java. Three helpers each call a factory newInstance() and parse an attacker-supplied string with no secure configuration: parseXMLString uses a bare DocumentBuilderFactory (namespace-aware only), getNumberOfEADElements uses a bare XMLInputFactory (StAX), and checkIfXmlIsWellFormed uses a bare SAXParserFactory with validating=false and namespaceAware=true. On a standard JRE these defaults expand external general entities and fetch external DTDs, which is the CWE-611 condition; the advisory's reproduction on OpenJDK 17 shows both file:// entity expansion into parsed text and an http:// entity producing an outbound request to a sentinel listener. The vulnerability is a hardening gap, not a missing feature: the same file's load() and newDocument() already enable XMLConstants.FEATURE_SECURE_PROCESSING, and the external-data-management XmlResponseHandler and QueryURLImport catalog-response parsers additionally set http://apache.org/xml/features/disallow-doctype-decl - grep at tag kitodo-production-3.9.1 and main commit 55809fc4 shows those hardening calls exist only in the load/newDocument paths and never in the three upload parsers. Reachability is confirmed by code path: FileUploadDialog.handleFileUpload (PrimeFaces) reads the uploaded stream, CreateProcessForm sets the XML string, and ImportEadProcessesThread calls getNumberOfEADElements and parseXMLString, while ImportService and MetadataImportDialog also route uploaded XML into parseXMLString and checkIfXmlIsWellFormed. The advisory additionally notes entity-expansion denial of service (billion laughs / external DTD retrieval) as a secondary impact of the same unhardened parsers; local file disclosure and SSRF are the primary outcomes.

Know when the next one hits your stack

  • 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 (github) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.6 HIGH

Authenticated importer uploads XML over the network (PR:L, AV:N, UI:N); default-config parser resolves entities with no special trigger (AC:L); impact is mainly file/SSRF confidentiality (C:H), with limited SSRF-driven integrity and entity-expansion DoS (I:L/A:L).

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

Primary rating from Vendor (github).

CVSS VectorVendor: github

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

Lifecycle Timeline

2
Patch available
Oct 23, 2026 - 16:02 EUVD
CVE Published
Oct 23, 2026 - 15:17 cve.org
HIGH 8.7

DescriptionCVE.org

Kitodo.Production is a workflow management tool for mass digitization and is part of the Kitodo Digital Library Suite. Prior to version 3.9.2, org.kitodo.production.helper.XMLUtils exposes several XML parsing helpers that construct a JAXP parser with the default, non-secure configuration. The methods parseXMLString(String), getNumberOfEADElements(String, String) and checkIfXmlIsWellFormed(String) build a DocumentBuilderFactory / XMLInputFactory / SAXParserFactory via newInstance() and parse the attacker-supplied string without disabling DOCTYPE declarations or external entity resolution. These helpers sit directly on the EAD-import path: an authenticated user who uploads an EAD/XML file through the "Create process" file-upload dialog has the uploaded bytes parsed by these methods. A crafted document with an external entity therefore yields XML External Entity (XXE) injection: local file disclosure and outbound SSRF requests from the server. This issue has been patched in version 3.9.2.

Technical POC Analysis

CWE-611 (Improper Restriction of XML External Entity Reference).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

CVE-2026-54668 in Kitodo.Production 3.8.x and 3.9.x through 3.9.1 allows any authenticated user with access to the 'Create process' dialog to upload a crafted EAD/XML file and read server-side files or trigger outbound requests. This impacts library and archive workflows where low-privileged import users process metadata, potentially exposing sensitive server data and creating a data exfiltration or server-side request forgery risk.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 66% exploitable
Prevalence
Low
niche library/archive mass-digitization tool, limited to cultural-heritage institutions
Social Media
1
Sightings
Data Quality
4 sources
Confidence: Medium

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 HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
High

Priority Score

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

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

XML External Entity (XXE) attacks exploit XML parsers that process Document Type Definitions (DTDs) without proper restrictions.

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