/

CVE-2026-36765

Severity:

HIGH RISK

(8.8)

XML External Entity (XXE) in SpringBlade loadReport Endpoint

CVE-2026-36765

Deferred

Vulnerability type

Category:

XML External Entity (XXE)

CWE:

CWE-611

Impact:

Remote Code Execution via XML External Entity Processing

Severity:

HIGH RISK

(8.8)

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

SpringBlade v4.8.0 contains an XML External Entity (XXE) vulnerability in the /designer/loadReport endpoint, where XML input is parsed without properly restricting external entity resolution.

An authenticated attacker who can reach this endpoint and submit crafted XML can leverage XXE to execute arbitrary code on the underlying server in some deployment configurations.

Affected context

The vulnerability appears in SpringBlade v4.8.0 within the /designer/loadReport functionality, which processes XML-based report definitions or similar structured content.

It manifests when the XML parser used by this endpoint allows external entity expansion or custom entity resolution and is invoked on attacker-controlled XML.

The issue becomes relevant in environments where authenticated users can upload or submit XML payloads to this endpoint and where the application's XML parser is not hardened against XXE.

Exploit preconditions

  • Attack surface: HTTP(S) endpoint /designer/loadReport exposed by a SpringBlade v4.8.0 deployment.
  • Required access: Valid authenticated user account (at least with access to the report designer / loader functionality).
  • Input control: Ability to supply or influence the XML content processed by /designer/loadReport.
  • Trigger point: Server-side XML parsing of the attacker-supplied document with external entity resolution enabled or insufficiently restricted.
  • Why exploitation is possible: The XML parser configuration does not fully disable DTDs and external entities, allowing crafted entities to be resolved in ways that can lead to file access, SSRF, or in some environments code execution via underlying XML processing features or integrations.

Why this happens

This vulnerability stems from insecure XML parsing configuration, mapping directly to CWE-611: Improper Restriction of XML External Entity Reference.

The /designer/loadReport endpoint consumes XML data but relies on a parser that permits external entity definitions or external DTDs, trusting the structure and references within the document.

When user-controllable XML is processed with these features enabled, attackers can define entities that reference local files, network resources, or other interpreter features.

In certain setups—especially where XML processing is tied into template engines, transformation pipelines, or system-level utilities—these entities can be abused to pivot from data exfiltration and SSRF to arbitrary code execution.

The abstract pattern is: untrusted XML input + entity resolution enabled + powerful XML processing backend = externally controllable behavior beyond mere data parsing.

Potential impact

  • Arbitrary code execution on the application server in environments where XML processors or downstream integrations allow execution primitives.
  • Reading sensitive local files that the application process can access via file-based external entities.
  • Server-Side Request Forgery (SSRF), enabling connections to internal services, metadata endpoints, or restricted network segments.
  • Disclosure of configuration data, credentials, API keys, or other secrets stored on the host.
  • Expansion into broader system compromise if the application runs with elevated privileges or has access to critical infrastructure.

General mitigation guidance

Effective mitigation focuses on hardening XML parsing and reducing trust in user-supplied XML:

  • Configure all XML parsers used by /designer/loadReport (and similar endpoints) to:
  • Disable DTD declarations entirely.
  • Disable external general entities and external parameter entities.
  • Disable external schema and stylesheet loading, if applicable.
  • Prefer XML processing libraries or APIs that are secure-by-default regarding XXE and do not expose entity resolution without explicit opt-in.
  • Treat all XML input originating from clients as untrusted, even when behind authentication, and process it through a restricted, whitelisted schema or a safe data model rather than raw XML constructs.
  • Apply the principle of least privilege to the application runtime:
  • Run with minimal OS permissions and restricted network egress where possible.
  • Limit access to sensitive file paths that are not needed by the application.
  • Where XML is not strictly necessary, consider alternative payload formats (e.g., JSON) that lack legacy entity expansion features.

How teams detect issues like this

Detection typically combines code-level inspections with runtime monitoring:

  • Static analysis and code scanning:
  • Search for XML parser instantiations (e.g., DOM/SAX/StAX/JAXB) used in /designer/loadReport and verify that DTDs and external entities are explicitly disabled.
  • Use SAST rules targeting CWE-611 to flag XML parsing where secure features (e.g., FEATURE_SECURE_PROCESSING, DTD disable flags) are not set.
  • Code review practices:
  • Require explicit documentation in code reviews whenever XML is used, stating how XXE is mitigated.
  • Flag any XML-based endpoints that accept data from authenticated users without schema validation or hardened parser configuration.
  • Runtime and log analysis:
  • Monitor for unusual outbound requests from the application (possible SSRF) or error logs that reference DTD resolution, entity expansion, or unexpected XML parsing failures.
  • Security testing:
  • Incorporate XXE-specific tests into routine application security testing (DAST), using safe proofs-of-concept that detect entity resolution behaviors without causing harm.
  • Automated security tools and CI pipelines can be configured to fail builds when insecure XML patterns are detected.

Sources

SourceLink
github.comgithub.com/chillzhuang/SpringBlade
github.comgithub.com/chillzhuang/SpringBlade/issues/37

Frequently asked

questions

The vulnerability is reachable wherever the /designer/loadReport endpoint is exposed. Because it requires authentication, exploitation normally depends on attackers obtaining or abusing valid credentials, but it can be exploited remotely if the application is internet-facing and an attacker can log in.

An attacker must be an authenticated user with access to the XML-based report loading functionality. They need the ability to submit or influence the XML payload processed by /designer/loadReport.

The most robust fix is to harden all XML parsing by disabling DTDs and external entities across the application and, where feasible, constrain XML to a validated schema or a safer data representation. Ensuring that the XML parser used for /designer/loadReport cannot resolve external entities eliminates the XXE attack vector.

Establish a secure-by-default XML handling guideline: forbid DTDs and external entities for untrusted input, prefer modern libraries that enforce secure processing, and discourage the introduction of new XML endpoints unless necessary. Integrate SAST rules and security review checklists that specifically call out XXE risks anytime XML parsing code is added or modified.

Find out what's already
exploitable in your codebase.