/

CVE-2026-50782

Severity:

HIGH RISK

(7.5)

XML External Entity (CWE-611) in Jinher OA C6 Endpoint

CVE-2026-50782

Deferred

Vulnerability type

Category:

XML External Entity (XXE) Injection

CWE:

CWE-611

Impact:

Sensitive File Disclosure and Server Data Exposure

Severity:

HIGH RISK

(7.5)

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

Jinher OA C6 exposes an XML External Entity (XXE) injection flaw in the GetXmlHttp endpoint that processes attacker-controlled XML.

An unauthenticated remote attacker can exploit this to read arbitrary files from the server, including via out-of-band channels, when XML input is parsed without proper entity restrictions.

Jinher OA C6 exposes an XML External Entity (XXE) injection flaw in the GetXmlHttp endpoint that processes attacker-controlled XML.

An unauthenticated remote attacker can exploit this to read arbitrary files from the server, including via out-of-band channels, when XML input is parsed without proper entity restrictions.

Affected context

The vulnerability occurs in Jinher OA C6 when the /c6/JHSoft.Web.HrmAttendance/sp_manager_getUserlist.aspx/GetXmlHttp endpoint accepts XML input and parses it using a configuration that allows external entities.

It typically manifests in deployments where XML parsers are left in their default, permissive state, and where the endpoint is exposed to unauthenticated network clients.

The issue is more pronounced if the application has access to sensitive filesystem paths or internal network resources that can be referenced by XML entities.

The vulnerability occurs in Jinher OA C6 when the /c6/JHSoft.Web.HrmAttendance/sp_manager_getUserlist.aspx/GetXmlHttp endpoint accepts XML input and parses it using a configuration that allows external entities.

It typically manifests in deployments where XML parsers are left in their default, permissive state, and where the endpoint is exposed to unauthenticated network clients.

The issue is more pronounced if the application has access to sensitive filesystem paths or internal network resources that can be referenced by XML entities.

Exploit preconditions

  • Attack surface: Publicly reachable HTTP endpoint at /c6/JHSoft.Web.HrmAttendance/sp_manager_getUserlist.aspx/GetXmlHttp.
  • Required access: No authentication is required; the attacker only needs network access to the vulnerable server.
  • Trigger point: Submission of a crafted XML payload that defines external entities and causes the parser to resolve them during request handling.
  • Why exploitation is possible: The XML parser is configured to process external entities and DTDs, allowing attacker-controlled XML to reference local files or remote resources, enabling in-band or out-of-band data exfiltration.
  • Attack surface: Publicly reachable HTTP endpoint at /c6/JHSoft.Web.HrmAttendance/sp_manager_getUserlist.aspx/GetXmlHttp.
  • Required access: No authentication is required; the attacker only needs network access to the vulnerable server.
  • Trigger point: Submission of a crafted XML payload that defines external entities and causes the parser to resolve them during request handling.
  • Why exploitation is possible: The XML parser is configured to process external entities and DTDs, allowing attacker-controlled XML to reference local files or remote resources, enabling in-band or out-of-band data exfiltration.

Why this happens

This vulnerability stems from using XML parsers that are not hardened against external entity resolution, mapping directly to CWE-611: Improper Restriction of XML External Entity Reference.

The application treats client-supplied XML as trusted, enabling the parser to process <!ENTITY> declarations and fetch resources via file://, http://, or related schemes.

Abstractly, the insecure pattern is: accepting untrusted XML input, leaving entity expansion enabled, and allowing the parser to access resources beyond the intended application data model.

This vulnerability stems from using XML parsers that are not hardened against external entity resolution, mapping directly to CWE-611: Improper Restriction of XML External Entity Reference.

The application treats client-supplied XML as trusted, enabling the parser to process <!ENTITY> declarations and fetch resources via file://, http://, or related schemes.

Abstractly, the insecure pattern is: accepting untrusted XML input, leaving entity expansion enabled, and allowing the parser to access resources beyond the intended application data model.

Potential impact

  • An attacker may read arbitrary files from the server's filesystem, including configuration or credential stores.
  • Attackers could access application logs that contain sensitive operational or user information.
  • XML entities can be used to probe internal network services, potentially revealing internal IPs or service banners.
  • Sensitive secrets, such as database connection strings or API keys, could be exposed if they reside in accessible files.
  • An attacker may read arbitrary files from the server's filesystem, including configuration or credential stores.
  • Attackers could access application logs that contain sensitive operational or user information.
  • XML entities can be used to probe internal network services, potentially revealing internal IPs or service banners.
  • Sensitive secrets, such as database connection strings or API keys, could be exposed if they reside in accessible files.

General mitigation guidance

Effective mitigation focuses on hardening XML parsing and reducing trust in external entities.

Common defensive patterns include:

  • Configuring XML parsers to disable external entities, DTD processing, and related features by default.
  • Using high-level APIs or libraries that offer secure-by-default XML handling and do not expose raw parser settings unnecessarily.
  • Validating incoming XML against strict schemas and rejecting documents containing DTDs, entity declarations, or unexpected structures.
  • Applying least-privilege principles to the application process so that even if XML parsing is abused, filesystem and network access are minimized.
  • Segmenting sensitive configuration and secrets into stores that are not readable by the web application's runtime account.

Effective mitigation focuses on hardening XML parsing and reducing trust in external entities.

Common defensive patterns include:

  • Configuring XML parsers to disable external entities, DTD processing, and related features by default.
  • Using high-level APIs or libraries that offer secure-by-default XML handling and do not expose raw parser settings unnecessarily.
  • Validating incoming XML against strict schemas and rejecting documents containing DTDs, entity declarations, or unexpected structures.
  • Applying least-privilege principles to the application process so that even if XML parsing is abused, filesystem and network access are minimized.
  • Segmenting sensitive configuration and secrets into stores that are not readable by the web application's runtime account.

How teams detect issues like this

Organizations can detect XXE risks by:

  • Applying static analysis rules that flag calls to XML parsers where external entities or DTD processing are enabled.
  • Reviewing code for direct use of low-level XML APIs without explicit secure configuration, especially in request-handling endpoints.
  • Implementing security-focused code review checklists that require verification of parser settings for all XML-consuming components.
  • Monitoring for unusual outbound requests or file access patterns correlated with XML-handling endpoints, using logging and intrusion detection systems.
  • Leveraging automated SAST/DAST tools that include specific checks for XXE, such as sending crafted XML payloads to identify unsafe parser behavior.

Organizations can detect XXE risks by:

  • Applying static analysis rules that flag calls to XML parsers where external entities or DTD processing are enabled.
  • Reviewing code for direct use of low-level XML APIs without explicit secure configuration, especially in request-handling endpoints.
  • Implementing security-focused code review checklists that require verification of parser settings for all XML-consuming components.
  • Monitoring for unusual outbound requests or file access patterns correlated with XML-handling endpoints, using logging and intrusion detection systems.
  • Leveraging automated SAST/DAST tools that include specific checks for XXE, such as sending crafted XML payloads to identify unsafe parser behavior.

Sources

SourceLink
github.comgithub.com/dihe123/CNVD-Jinher-OA-XXE/blob/main/README.md
github.comgithub.com/dihe123/CNVD-Jinher-OA-XXE/tree/main

Frequently asked

questions

Yes. The XXE flaw is exposed over HTTP, and an attacker with network access to the Jinher OA C6 server can send crafted XML without needing local access.

No authentication is required. The vulnerable GetXmlHttp endpoint can be reached by unauthenticated remote users, making exploitation possible with minimal privileges.

The safest pattern is to configure all XML parsers to disable external entities and DTD processing, use secure-by-default XML libraries, and enforce strict schema validation on incoming XML.

Developers can prevent XXE by adopting security-hardening guidelines for XML handling, encapsulating parsing behind well-reviewed utility components, ensuring default parser configurations are locked down, and integrating static and dynamic security testing into the CI/CD pipeline to catch unsafe parser usage early.

Yes. The XXE flaw is exposed over HTTP, and an attacker with network access to the Jinher OA C6 server can send crafted XML without needing local access.

No authentication is required. The vulnerable GetXmlHttp endpoint can be reached by unauthenticated remote users, making exploitation possible with minimal privileges.

The safest pattern is to configure all XML parsers to disable external entities and DTD processing, use secure-by-default XML libraries, and enforce strict schema validation on incoming XML.

Developers can prevent XXE by adopting security-hardening guidelines for XML handling, encapsulating parsing behind well-reviewed utility components, ensuring default parser configurations are locked down, and integrating static and dynamic security testing into the CI/CD pipeline to catch unsafe parser usage early.

Find out what's already
exploitable in your codebase.