/

CVE-2026-86185

Severity:

HIGH RISK

(8.0)

TLS Verification Bypass (CWE-295) in Bilibili Desktop

CVE-2026-86185

Deferred

Vulnerability type

Category:

Improper Certificate Validation

CWE:

CWE-295

Impact:

Remote Code Execution and Credential Theft

Severity:

HIGH RISK

(8.0)

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

Bilibili Desktop through version 1.18.0 disables TLS certificate verification across the application and executes remote JavaScript configuration without integrity validation. An on-path attacker may tamper with configuration responses, causing script execution in a privileged renderer and potentially enabling system command execution or credential theft.

Affected context

The vulnerability occurs in Bilibili Desktop deployments where TLS certificate verification is disabled process-wide and remote JavaScript configuration is accepted without a trusted integrity check. Risk is highest when the application retrieves configuration over a network that an attacker can observe or modify, and when the renderer exposes privileged IPC capabilities to remotely supplied script content.

Exploit preconditions

  • Attack surface: Network-fetched configuration and renderer-side JavaScript execution
  • Required access: An on-path position capable of intercepting or modifying configuration responses
  • Trigger point: Application startup or runtime retrieval and execution of remote configuration
  • Why exploitation is possible: Certificate validation is disabled, and the received JavaScript is not authenticated through an independent integrity mechanism
  • Additional condition: The renderer's privileged IPC bridge must expose capabilities that allow the injected script to reach sensitive application or operating-system functions

Why this happens

The underlying issue combines improper certificate validation with unsafe trust in remotely supplied executable content. Disabling TLS certificate verification removes server-authentication guarantees, while executing unsigned JavaScript without integrity validation allows modified network responses to become trusted application logic. This behavior maps primarily to CWE-295, Improper Certificate Validation, because the application fails to validate the peer certificate before relying on protected network content.

Potential impact

  • An attacker may execute arbitrary JavaScript in the application renderer.
  • Injected code could invoke privileged IPC functionality and may execute system commands.
  • User login credentials or other sensitive application data could be stolen.
  • The application may be used as a foothold for persistence or further compromise.
  • Configuration tampering could cause unauthorized behavior or service disruption.

General mitigation guidance

Mitigation generally focuses on restoring authenticated transport and reducing

the trust granted to remotely obtained code.

Common defensive patterns include:

  • Enforcing certificate and hostname verification for every TLS connection.
  • Avoiding process-wide settings that disable transport security.
  • Treating remote configuration as data rather than executable JavaScript.
  • Applying cryptographic integrity and authenticity checks to configuration when remote retrieval is necessary.
  • Using restrictive renderer isolation, context isolation, and narrowly scoped IPC interfaces.
  • Validating configuration against an allowlisted schema before use.
  • Applying least privilege to the desktop process and exposed operating-system capabilities.
  • Preventing sensitive credentials from being exposed to renderer-side scripts.

How teams detect issues like this

Organizations can identify similar weaknesses through:

  • Static analysis searches for disabled certificate verification, permissive TLS callbacks, and process-wide security overrides.
  • Code review checks for remote script evaluation, unsigned configuration, and renderer access to broad IPC methods.
  • Dependency and runtime policy checks that reject insecure TLS settings or untrusted executable content.
  • Network monitoring for configuration responses that are fetched without expected certificate validation or integrity metadata.
  • Automated security review tools and CI policies that flag dynamic code execution and unrestricted desktop IPC exposure.

Sources

SourceLink
app.bilibili.comapp.bilibili.com/
github.comgithub.com/LeoWSY-hashblue/bilibili-desktop-tls-disabled-rce
github.comgithub.com/LeoWSY-hashblue/bilibili-desktop-tls-disabled-rce/blob/main/advisory.md
vulncheck.comvulncheck.com/advisories/bilibili-desktop-through-1.18.0-remote-code-execution-via-tls-verification-bypass

Frequently asked

questions

Yes, within the stated threat model. An attacker generally needs an

on-path network position capable of altering configuration traffic; direct

internet-based exploitation without traffic interception is not implied.

The attacker needs to intercept or modify the application's configuration

fetches. No prior local account access is necessarily required, but the

resulting impact depends on the privileges exposed through the renderer's

IPC bridge.

Require strict TLS certificate and hostname validation, authenticate remote

configuration independently where appropriate, and avoid executing remote

JavaScript. Renderer processes should receive only narrowly scoped,

least-privilege IPC capabilities.

Enforce secure transport policies in code review and CI, prohibit disabling

certificate verification, validate configuration schemas and integrity, and

continuously test desktop application isolation and IPC boundaries.

Find out what's already
exploitable in your codebase.