/

CVE-2025-70045

Severity:

HIGH RISK

(7.4)

Improper Certificate Validation in jxcore jxm HTTPS Requests

CVE-2025-70045

Analyzed

Vulnerability type

Category:

Improper Certificate Validation

CWE:

CWE-295

Impact:

Man-in-the-Middle and Confidentiality Compromise

Severity:

HIGH RISK

(7.4)

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

jxcore jxm contains an improper TLS/SSL certificate validation issue where HTTPS requests disable certificate checks by setting rejectUnauthorized: false when jx_obj.IsSecure is true.

This behavior allows attackers capable of performing network-level interception to impersonate trusted endpoints, enabling man-in-the-middle attacks and sensitive data exposure over supposedly secure connections.

Affected context

The vulnerability occurs in jxcore jxm when establishing outbound HTTPS connections.

When the application considers a context "secure" (jx_obj.IsSecure is true), it explicitly disables TLS certificate verification using rejectUnauthorized: false in the HTTPS request options.

In environments where clients assume HTTPS implies authenticity and integrity (e.g., calling APIs, authentication endpoints, or data services), this behavior undermines the trust model of TLS and exposes traffic to interception by on-path attackers.

Exploit preconditions

  • Attack surface: Outbound HTTPS requests made by jxcore jxm to remote servers.
  • Required access: Ability to observe or influence network traffic between the jxcore instance and the intended HTTPS endpoint (e.g., same network segment, compromised router, malicious Wi‑Fi access point, or corporate proxy).
  • Trigger point: Any code path that issues HTTPS requests while jx_obj.IsSecure evaluates to true, causing rejectUnauthorized to be set to false.
  • Why exploitation is possible: With certificate validation disabled, the client accepts any presented certificate, including self-signed or attacker-controlled certificates, so an attacker can impersonate the target host without needing a valid certificate chain.

Why this happens

This issue stems from programmatically disabling core TLS security checks based on application state.

By setting the HTTPS option rejectUnauthorized: false, the code bypasses server certificate verification, which is the primary control ensuring that the remote endpoint is authentic and trusted.

This maps directly to CWE-295: Improper Certificate Validation, where the implementation either omits or weakens verification of TLS/SSL certificates, often under the misconception that doing so simplifies development or avoids configuration issues.

In abstract terms, the insecure pattern is: "conditionally trust any TLS certificate when a connection is labeled secure," which reverses the normal trust boundary and breaks the TLS guarantee of server authenticity.

Potential impact

  • Attackers on the network path may intercept and read sensitive data (credentials, tokens, personal or business data) sent over HTTPS.
  • Network attackers could modify API responses or inject malicious data, leading to data integrity issues or application misbehavior.
  • Session hijacking could occur if authentication cookies or tokens are exposed via a spoofed HTTPS endpoint.
  • Downstream systems may be compromised if the application trusts tampered responses to make security-sensitive decisions or configuration changes.
  • Users and operators may be misled into believing communications are secure due to the use of HTTPS schemes and ports, despite the lack of actual certificate validation.

General mitigation guidance

Effective mitigation focuses on enforcing strict TLS certificate validation and avoiding any patterns that weaken it:

  • Remove or avoid code paths that set rejectUnauthorized: false; rely on default HTTPS behavior that validates certificates against trusted roots.
  • Use well-maintained trust stores and avoid hard-coding overrides that treat all certificates as trusted.
  • Where self-signed or private CA certificates are required, add only those specific CAs or certificates to a dedicated trust store instead of disabling verification globally.
  • Implement configuration-driven security: expose options for specifying trusted CAs or certificate pinning rather than toggling validation off in code.
  • Apply least-privilege principles to outgoing connections, limiting which endpoints can be contacted and monitoring for unexpected destinations.
  • Encourage development practices that treat validation failures as errors to be fixed (misconfiguration, expired certs), not as reasons to disable security checks.

How teams detect issues like this

Organizations can identify this class of issue using a combination of code analysis and runtime inspection:

  • Static analysis: Search for HTTPS or TLS client calls where options include rejectUnauthorized: false or equivalent flags that bypass certificate validation.
  • Code review signals: Flag any helper functions or configuration toggles that disable SSL verification for "debug", "development", or "secure" modes; require justification and alternative secure patterns.
  • Policy enforcement: Add linting rules or security gates in CI/CD pipelines that reject changes introducing disabled TLS verification or unbounded trust of certificates.
  • Runtime monitoring: Inspect outbound TLS connections using proxies or security tooling to verify that certificate chains are validated and that clients reject invalid certificates.
  • Inventory & configuration checks: Regularly audit application configuration and environment variables to ensure no global settings disable SSL verification at the platform or library level.

Sources

SourceLink
gist.github.comgist.github.com/zcxlighthouse/bd5852a409c97438016f2c476f8461d9
github.comgithub.com/jxcore
github.comgithub.com/jxcore/jxm

Frequently asked

questions

Yes, but it typically requires the attacker to be on the network path between the jxcore jxm instance and its HTTPS targets (for example, on the same local network, controlling a gateway, or operating a malicious access point). From there, the attacker can impersonate trusted servers because the client does not validate certificates.

No. Because certificate validation is disabled by rejectUnauthorized: false, the client will accept any certificate the attacker presents, including self-signed or invalid certificates, making impersonation significantly easier.

The safest approach is to remove any code that disables certificate verification and rely on strict, default TLS verification, optionally combined with explicit trust stores or certificate pinning for known endpoints instead of globally bypassing checks.

Establish a security guideline that forbids disabling TLS certificate validation in production code, enforce this via code review and automated checks, provide secure patterns for handling custom CAs or pinned certificates, and treat certificate errors as configuration issues to be resolved rather than suppressed.

Find out what's already
exploitable in your codebase.