/

CVE-2023-42344

Severity:

HIGH RISK

(7.3)

XML External Entity (XXE) in Alkacon OpenCms CMIS Chemistry

CVE-2023-42344

Deferred

Vulnerability type

Category:

XML External Entity (XXE)

CWE:

CWE-611

Impact:

Information Disclosure via XML External Entity Resolution

Severity:

HIGH RISK

(7.3)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Alkacon OpenCms before version 10.5.1 contains an XML External Entity (XXE) vulnerability in the CMIS Chemistry servlet's cmis-online/query endpoint.

A remote, unauthenticated attacker can submit crafted XML payloads to this endpoint to exfiltrate sensitive information from the server via external entity resolution.

Affected context

The vulnerability exists in deployments of Alkacon OpenCms using the CMIS Chemistry servlet, specifically the cmis-online/query functionality that processes XML-based requests.

It manifests when the XML parser handling incoming CMIS query requests is configured to allow external entities or DTD processing without restriction.

Installations that expose the CMIS endpoint to untrusted networks or the public internet, and that rely on default or permissive XML parser settings, are most exposed to risk.

Exploit preconditions

  • Attack surface: Network-accessible CMIS Chemistry servlet, typically at a path exposing cmis-online/query.
  • Required access: None; exploitation can be performed by unauthenticated remote attackers who can send XML requests to the endpoint.
  • Trigger point: Submission of a crafted XML document as part of a CMIS query that defines malicious external entities or DTDs.
  • Why exploitation is possible: The XML parser used by the Chemistry servlet is configured to process external entities, allowing attacker-controlled XML to reference local or remote resources and have the server resolve and return their contents.

Why this happens

This issue stems from unsafe XML parsing behavior in the CMIS Chemistry servlet. The component responsible for handling cmis-online/query requests accepts XML input and passes it to an XML parser without disabling external entity expansion or DTD processing.

This aligns with CWE-611: Improper Restriction of XML External Entity Reference, where untrusted XML documents can declare entities that point to local files, internal services, or remote resources.

Because the parser treats these declarations as trusted, it may fetch and incorporate the referenced content into its processing flow, inadvertently exposing sensitive data or internal system details.

Potential impact

  • Disclosure of sensitive local files readable by the application process (e.g., configuration files, credentials, or logs)
  • Exposure of internal network information by making the server perform unintended HTTP or TCP requests (SSRF-like behavior)
  • Leakage of application-specific secrets, database connection strings, or API keys referenced in configuration
  • Insight into server filesystem structure and environment, aiding further attacks
  • Potential partial bypass of network segmentation through server-initiated connections to internal hosts

General mitigation guidance

Effective mitigation centers on hardening XML parsing behavior and reducing trust in external entities:

  • Configure all XML parsers used by the CMIS Chemistry servlet to disable external entity resolution and DTD processing by default.
  • Use XML parsing libraries or factory methods that are explicitly designed for secure-by-default behavior, avoiding legacy or permissive settings.
  • Isolate and minimize the use of XML where possible; consider alternative data formats (e.g., JSON) for new integrations that do not require XML features.
  • Apply the principle of least privilege to the application runtime, ensuring the process has minimal filesystem and network access so that, even if XML resolution is misconfigured, reachable data and services are limited.
  • Harden server-side configuration by restricting access to especially sensitive files and segregating configuration secrets into locations not directly accessible to the application user.

How teams detect issues like this

Organizations can detect and monitor for XXE-style issues using a combination of code and runtime analysis:

  • Static analysis: Configure SAST tools to flag XML parser configurations that allow external entities, DTDs, or remote resource resolution in servlet and CMIS-related code paths.
  • Code review: During manual review, look for XML parsing logic that does not explicitly disable external entities or that uses generic, unconfigured parser factories.
  • Security testing: Incorporate XXE test cases into dynamic application security testing (DAST) and integration tests for XML endpoints such as cmis-online/query.
  • Runtime monitoring: Log and monitor outbound network requests originating from the CMS server that are triggered by XML processing, and watch for unexpected access to local files or unusual error responses related to entity resolution.
  • Policy enforcement: Establish internal guidelines that require secure XML parser settings for any new or modified XML-processing code, with automated checks in CI/CD pipelines.

Sources

SourceLink
labs.watchtowr.comlabs.watchtowr.com/xxe-you-can-depend-on-me-opencms/
github.comgithub.com/projectdiscovery/nuclei-templates/issues/8864

Frequently asked

questions

Yes. The vulnerable CMIS Chemistry servlet endpoint can be exploited remotely by sending crafted XML requests over the network, and no prior authentication is required if the endpoint is publicly exposed.

An attacker only needs network access to the CMIS cmis-online/query endpoint. There is no requirement for valid user credentials, but practical exploitability depends on whether this endpoint is reachable from the attacker's location.

The safest pattern is to treat all incoming XML as untrusted and configure XML parsers to disable external entity resolution and DTD processing completely, using secure parser factories or hardened configuration wrappers.

Prevention involves adopting secure-by-default XML parsing practices, standardizing parser configuration across the codebase, enforcing these settings via code review and static analysis, and considering non-XML data formats for new features where possible to minimize exposure to XXE risks.

Find out what's already
exploitable in your codebase.