/

CVE-2026-25160

Severity:

CRITICAL RISK

(9.1)

Improper Certificate Validation in Alist Storage Drivers

CVE-2026-25160

Analyzed

Vulnerability type

Category:

Improper Certificate Validation

CWE:

CWE-295

Impact:

Confidentiality and Integrity Compromise via Man-in-the-Middle

Severity:

CRITICAL RISK

(9.1)

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

Alist disables TLS certificate verification by default for all outgoing storage driver connections, causing clients to trust any presented certificate.

In environments where network traffic can be intercepted or redirected, this behavior allows Man-in-the-Middle (MitM) attackers to decrypt, steal, and modify data transmitted during storage operations.

Affected context

This weakness appears in Alist deployments that:

  • Use HTTPS or TLS-secured endpoints for storage providers or remote backends
  • Rely on the default configuration where TLS certificate verification is disabled
  • Operate on networks where traffic between the Alist server and storage endpoints can be monitored, proxied, or rerouted (e.g., shared hosting, corporate networks, ISP-level inspection, or compromised infrastructure)

The vulnerability affects all outgoing storage driver communications that should be protected by TLS, not just a specific storage provider.

Exploit preconditions

  • Attack surface: Network path between the Alist instance and its configured storage backends (e.g., cloud storage, remote file services)
  • Required access: Ability to intercept, route, or impersonate network traffic (e.g., control of a gateway, router, Wi‑Fi access point, or upstream DNS)
  • Trigger point: Any TLS connection initiated by Alist's storage drivers where certificate verification is disabled
  • Why exploitation is possible: The client accepts any server certificate without verifying authenticity or trust, allowing an attacker-controlled endpoint to appear legitimate and terminate encrypted sessions.

Why this happens

The root cause is the decision to disable TLS certificate verification for outgoing connections in the storage driver layer.

This behavior maps to CWE-295: Improper Certificate Validation, where the client fails to validate the server's certificate chain, hostname, or trust anchor.

By treating all certificates as valid, the application removes the primary security property of TLS—authentication of the remote peer—thereby exposing encrypted channels to transparent interception and tampering.

Potential impact

  • Attackers could transparently decrypt all data sent between Alist and its storage backends.
  • Sensitive user files and metadata could be exfiltrated during upload, download, or synchronization.
  • Data in transit could be modified or replaced, leading to silent content tampering or corruption.
  • Credentials, access tokens, and session-related secrets used by storage drivers could be captured and reused.
  • Users and administrators could be misled into trusting forged content retrieved through compromised channels.

General mitigation guidance

Mitigation focuses on restoring strong TLS semantics and reducing implicit trust in the network path:

  • Ensure TLS certificate verification is enabled by default for all outgoing storage driver connections.
  • Validate server certificates against a trusted root CA store and perform hostname verification for each target endpoint.
  • Avoid configuration flags or environment variables that globally disable certificate checks; if such options must exist, document them as unsafe and restrict their use.
  • Prefer secure-by-default connection helpers or HTTP/TLS client libraries that make it harder to bypass verification.
  • Use least-privilege credentials for each storage backend so that any interception yields minimal reusable value.
  • Encourage deployments to use network segmentation and secure DNS to reduce the chances of traffic redirection.

How teams detect issues like this

Detection typically combines code-level and operational checks:

  • Static analysis and code review:
  • Search for TLS or HTTP client configurations that explicitly disable certificate verification (e.g., "InsecureSkipVerify"-style options or custom trust managers that accept all certs).
  • Flag wrapper functions that construct HTTP clients without hostname or certificate validation.
  • Use security linters and SAST tools configured with rules for improper TLS validation patterns.
  • Configuration and runtime inspection:
  • Audit service configuration for options that relax TLS verification, and treat them as policy violations.
  • Monitor outbound connections for use of plain HTTP where HTTPS is expected, and alert on endpoints that should be protected by TLS.
  • Policy enforcement:
  • Embed organization-wide policies in CI/CD to block changes that introduce disabled certificate verification or custom "trust all" logic.

Sources

SourceLink
github.comgithub.com/AlistGo/alist/commit/69629ca76a8f2c8c973ede3b616f93aa26ff23fb
github.comgithub.com/AlistGo/alist/security/advisories/GHSA-8jmm-3xwx-w974

Frequently asked

questions

Yes. Any attacker who can intercept or redirect network traffic between Alist and its storage backends—such as on shared Wi‑Fi, compromised routers, or hostile network segments—can exploit this flaw to perform MitM attacks.

No direct access to the Alist host is required. The attacker primarily needs influence over the network path (e.g., acting as a gateway, DNS manipulator, or access point) rather than valid application logins.

The safest pattern is to enable strict TLS certificate verification for all outgoing connections, using trusted root CAs and hostname checks, and to remove or tightly control any configuration that disables verification.

Design network clients to be secure by default, avoid "trust all certificates" shortcuts even in development, enforce TLS validation via shared libraries and coding standards, and incorporate automated checks in CI to block changes that weaken certificate validation.

Find out what's already
exploitable in your codebase.