CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-H4MF-4V27-HGGJ

GHSA-H4MF-4V27-HGGJ: WebDAV Credential Disclosure via Same-Host HTTPS-to-HTTP Redirect in rclone

Amit Schendel
Amit Schendel
Senior Security Researcher

Aug 6, 2026·7 min read·18 visits

Executive Summary (TL;DR)

rclone's WebDAV backend leaked sensitive credentials over cleartext HTTP during same-host HTTPS-to-HTTP redirects due to missing protocol scheme validation in its redirection handlers.

A protocol downgrade vulnerability in rclone's WebDAV backend allows sensitive credentials, cookies, and authentication headers to be transmitted in cleartext. This occurs when a remote server redirects an HTTPS request to a plaintext HTTP URL on the same host, which the Go HTTP client default behavior permits without checking the protocol transport layer. This report provides a detailed technical analysis of the root cause, exploit mechanics, patch diff, and remediation strategies.

Vulnerability Overview

A high-severity security vulnerability exists within the WebDAV backend of rclone, a popular command-line program used to manage files on cloud storage. The vulnerability allows sensitive credentials, cookies, and authentication headers to be transmitted in cleartext over the network when a target server initiates an HTTPS-to-HTTP protocol downgrade redirect. This exposure presents a substantial threat in environment topologies where network transactions cross untrusted segments or are subjected to local interception.

The attack surface resides within the application's HTTP redirection logic, specifically how the client handles transitions between secure transport layers (HTTPS) and plaintext transport layers (HTTP) on matching hostnames. Because the default behavior of Go's net/http package preserves authentication headers during same-host redirection, rclone failed to verify whether the target protocol scheme had been downgraded to unencrypted HTTP. Consequently, any credentials associated with the session are replayed over plaintext.

This vulnerability is classified under CWE-319 (Cleartext Transmission of Sensitive Information), CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor), and CWE-522 (Insufficiently Protected Credentials). Successful exploitation allows an on-path attacker or a compromised co-located service to intercept cleartext authentication tokens, such as Basic Authentication headers, session cookies, and custom secret keys. Security teams should prioritize patching this vulnerability to mitigate credential exposure risks during automated backup and synchronization routines.

Root Cause Analysis

To understand the root cause of this vulnerability, one must analyze the inner workings of Go's net/http client redirection handling. When an HTTP client processes a redirection status code (e.g., 301, 302, 307, 308), the default behavior of http.Client is to evaluate whether the target URL belongs to the same domain as the original request. If the host matches, the client preserves the original session headers, including highly sensitive fields like Authorization and Cookie, to maintain a seamless session.

However, Go's default implementation fails to validate transport scheme transitions during this host check. If an initial secure request is made to https://example.com/data and the server redirects the client to http://example.com/data, the standard library considers this the "same host." It does not prevent the transmission of credentials over the newly established unencrypted channel. The client continues the session, replaying the Authorization headers over plain text, which can be observed by any eavesdropper.

In rclone's WebDAV backend, this standard library behavior was exacerbated by custom redirect handlers defined in lib/rest/rest.go. The helper function PreserveMethodRedirectFn was designed to preserve the HTTP request verb (such as maintaining a PROPFIND request across temporary redirects instead of changing to a GET as the standard Go client does). Prior to the patch, neither the WebDAV client instantiation nor the custom redirection handlers verified if the target scheme transitioned from https to http. This left the backend exposed to protocol downgrade manipulations.

Code Analysis and Patch Verification

The vulnerability was remediated by introducing strict transport protocol validation within the custom redirection handlers located in lib/rest/rest.go and explicitly applying these handlers to the WebDAV backend client configuration.

In the patch, a new helper function isHTTPSDowngrade was introduced to examine the protocol scheme transition. It checks the history of the HTTP request execution path by analyzing the via slice, which holds previous requests in the redirection chain:

// isHTTPSDowngrade reports whether following the redirect to req would
// move from an https:// URL to a plaintext http:// URL.
func isHTTPSDowngrade(req *http.Request, via []*http.Request) bool {
	if len(via) == 0 {
		return false
	}
	prev := via[len(via)-1]
	return prev.URL.Scheme == "https" && req.URL.Scheme == "http"
}

The custom redirection handlers were updated to invoke this helper function and immediately abort the redirection process by returning a new error type, ErrHTTPSDowngrade, if a downgrade is detected. This prevents the request from being constructed and transmitted over cleartext:

// ErrHTTPSDowngrade is returned by the redirect handlers when a server tries to
// redirect an HTTPS request to a plaintext HTTP URL. Following such a redirect
// would replay any credentials over the network in cleartext, so rclone refuses.
var ErrHTTPSDowngrade = errors.New("refusing to follow HTTPS to HTTP redirect: would send credentials in cleartext")
 
func PreserveMethodRedirectFn(req *http.Request, via []*http.Request) error {
	if len(via) >= 10 {
		return errors.New("stopped after 10 redirects")
	}
	if isHTTPSDowngrade(req, via) {
		return ErrHTTPSDowngrade
	}
	if len(via) > 0 {
		req.Method = via[0].Method
	}
	return nil
}

To ensure all standard requests outside of method preservation routines are also protected, the patch introduced RefuseHTTPSDowngradeRedirectFn and assigned it to the standard WebDAV HTTP client's CheckRedirect property within backend/webdav/webdav.go:

	// Refuse redirects that downgrade HTTPS to plaintext HTTP.
	client.CheckRedirect = rest.RefuseHTTPSDowngradeRedirectFn
	f.srv = rest.NewClient(client).SetRoot(u.String())

This defensive engineering approach ensures that the application will throw a hard error and fail-closed rather than allowing the Go runtime to transmit credentials insecurely.

Exploitation & Threat Modeling

Exploitation of this vulnerability requires an Adversary-in-the-Middle (MitM) position, a compromised routing path, or control over DNS resolution for the target server's domain. In a real-world scenario, an attacker can exploit this behavior to harvest WebDAV credentials during automated cloud sync tasks.

An attacker begins by positioning themselves along the network path between the client running rclone and the WebDAV storage gateway. Alternatively, if the target network utilizes insecure DNS configurations, the attacker can execute a DNS hijacking attack to point the initial request to an attacker-controlled gateway. When the rclone client initiates its connection to https://webdav.internal.corp/, the attacker-controlled gateway intercepts the traffic.

While the attacker cannot easily forge a valid SSL/TLS certificate to decrypt the active HTTPS session, they can leverage co-located unsecured services or issue a direct redirection response. By sending a 302 Found response with a Location: http://webdav.internal.corp/ header, they instruct the client to follow the redirect on the same host but over plaintext HTTP.

Because the host name matches, the vulnerable version of rclone automatically packages the Authorization: Basic header into the new plaintext request. The client transmits this request to the unencrypted port, allowing the attacker to capture the unencrypted packets via standard packet-sniffing techniques and extract the base64-encoded credentials. This process requires zero interaction from the system administrator.

Impact Assessment

The security impact of credential exposure in rclone's WebDAV backend is high. Because WebDAV interfaces are frequently used for automated backups, system synchronization, and corporate shared drives, the credentials transmitted often possess read and write access to highly sensitive directories.

If an attacker successfully retrieves these credentials, they gain unauthorized access to the WebDAV server with the same permissions as the compromised client. This can result in unauthorized data exfiltration, deletion, or modification of critical backups. In enterprise settings, these credentials might also be linked to active directory accounts or single sign-on systems, allowing the attacker to move laterally across internal networks.

The CVSS v3.1 score is evaluated at 7.4 (High), with the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N. The complexity is high because the attacker must achieve an on-path position or control routing to intercept the downgrade path. However, because no authentication or user interaction is required to trigger the redirect response, the attack is highly reliable once the network position is established.

Remediation and Defensive Guidance

To fully remediate this vulnerability, security administrators must upgrade all installations of rclone to version v1.75.0 or higher. The upgraded versions contain the mandatory scheme checks that prevent the transmission of credentials during protocol downgrades.

If immediate software upgrades are not possible, administrators should review their WebDAV configurations. The auth_redirect advanced flag must be set to false. When auth_redirect is enabled, it acts as an explicit override that allows rclone to follow redirects that would otherwise be blocked. Ensuring this flag remains disabled is critical for maintaining transport layer security.

From a defensive development perspective, this vulnerability highlights the importance of implementing custom redirection verification rules in Go applications that handle sensitive authorization data. Developers should never rely solely on standard library hostname matching for authentication persistence without explicitly verifying that the transport protocol security has not been degraded.

Official Patches

rcloneFix patch commit for WebDAV credential leak on HTTPS-to-HTTP redirects.

Fix Analysis (1)

Technical Appendix

CVSS Score
7.4/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N

Affected Systems

rclone WebDAV Backend

Affected Versions Detail

Product
Affected Versions
Fixed Version
rclone
rclone
< 1.75.01.75.0
AttributeDetail
CWE IDCWE-319 / CWE-200
Attack VectorNetwork (Adversary-in-the-Middle)
CVSS v3.17.4 (High)
Exploit StatusProof of Concept (PoC) in regression tests
KEV StatusNot Listed
RemediationUpgrade to v1.75.0 or disable auth_redirect

MITRE ATT&CK Mapping

T1557Adversary-in-the-Middle
Credential Access
T1040Network Sniffing
Credential Access
CWE-319
Cleartext Transmission of Sensitive Information

The application transmits sensitive credential headers over unencrypted channels (plaintext HTTP) upon protocol downgrade.

Known Exploits & Detection

GitHub (Integration Tests)The official test suite includes a functional end-to-end regression proof-of-concept showing how standard Go HTTP configurations leak credentials during redirects in rest_test.go.

Vulnerability Timeline

Security patch committed to the official rclone repository.
2026-07-15
rclone version v1.75.0 released with the transport downgrade protection patch.
2026-07-15
GitHub Advisory Database publishes GHSA-H4MF-4V27-HGGJ.
2026-07-15

References & Sources

  • [1]GHSA-H4MF-4V27-HGGJ: rclone WebDAV Credentials Survive a Same-Host HTTPS-to-HTTP Redirect
  • [2]Fix Patch Commit
  • [3]rclone v1.75.0 Release Details

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•CVE-2026-109478
7.5

CVE-2026-109478: Algorithmic Complexity Denial of Service in ASP.NET Core Header Parsing

CVE-2026-109478 is a network-accessible Denial of Service (DoS) vulnerability in ASP.NET Core caused by inefficient algorithmic complexity (CWE-407) when parsing comma-separated HTTP request headers. Prior to the patch, the internal helper method ParsingHelpers.GetHeaderSplit repeatedly called StringValues.Concat inside a loop iterating over each comma-separated token. Because StringValues allocates a new array of size k + 1 and copies all existing elements upon each concatenation, processing N tokens incurs O(N^2) time and space complexity. An unauthenticated remote attacker can send HTTP requests with headers containing thousands of short, comma-separated values to exhaust CPU cycles and induce severe Garbage Collection (GC) pauses, rendering the web application unresponsive.

Alon Barad
Alon Barad
5 views•11 min read
•about 2 hours ago•CVE-2026-114147
7.5

CVE-2026-114147: Denial of Service via Memory Leak in ASP.NET Core SignalR Redis Backplane

CVE-2026-114147 is a high-severity Denial of Service (DoS) vulnerability affecting ASP.NET Core and specifically the Microsoft.AspNetCore.SignalR.StackExchangeRedis scale-out provider across .NET 8.0, 9.0, 10.0, and 11.0 preview releases. The vulnerability originates from a string comparison mismatch between internal per-connection group collections and the centralized Redis channel subscription registry, compounded by a race condition during connection teardown. Remote unauthenticated attackers can exploit this flaw to leave orphaned connection contexts and active Redis pub/sub listeners pinned in memory, leading to unbounded memory exhaustion and application process termination.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•CVE-2026-114156
6.5

CVE-2026-114156: Path Equivalence Security Feature Bypass in Microsoft ASP.NET Core

CVE-2026-114156 is an improper resolution of path equivalence vulnerability (CWE-41) in Microsoft ASP.NET Core affecting .NET 11.0 preview releases and Microsoft Visual Studio 2026. The vulnerability stems from a discrepancy between how path prefix validation helpers (such as PathString.StartsWithSegments) and downstream routing mechanisms handle alternate path separators and percent-encoded characters. An unauthenticated remote attacker can exploit this mismatch over the network to bypass path-based authorization middleware and access restricted endpoints.

Amit Schendel
Amit Schendel
5 views•8 min read
•about 4 hours ago•CVE-2026-114157
7.5

CVE-2026-114157: Local Privilege Escalation via Race Condition in ASP.NET Core Kestrel Named Pipes Transport

CVE-2026-114157 is a high-severity local privilege escalation and security feature bypass vulnerability affecting ASP.NET Core on Microsoft Windows. The flaw resides in the Kestrel web server's Named Pipes transport layer (Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes) and stems from a race condition (CWE-362) during broken pipe error recovery. When an active connection throws an IOException during handshake acceptance, the connection listener previously disposed of the broken NamedPipeServerStream instance before acquiring a replacement stream from its internal pool. This sequence created a momentary window where zero server instances of the named pipe existed in the Windows Named Pipe File System (NPFS). A local, low-privileged attacker can exploit this timing window to create a named pipe with the identical name and a permissive Discretionary Access Control List (DACL), hijacking subsequent inter-process communications and escalating privileges across security boundaries.

Amit Schendel
Amit Schendel
6 views•11 min read
•about 5 hours ago•CVE-2026-124194
6.5

CVE-2026-124194: Forced Authentication and NetNTLMv2 Credential Leakage in Microsoft Office Outlook

CVE-2026-124194 is a forced authentication and spoofing vulnerability in Microsoft Office Outlook caused by a missing user interface warning before dereferencing remote network paths (CWE-356). By embedding an attacker-controlled Universal Naming Convention (UNC) path within MAPI message properties such as PidLidReminderFileParameter, an unauthenticated remote attacker can force a victim's system to initiate an outbound SMB or WebDAV connection upon opening or previewing a crafted message. This automatic authentication handshake leaks the user's NetNTLMv2 hash, enabling offline password cracking or real-time NTLM relay attacks. The vulnerability was exploited in the wild as a zero-day prior to its remediation in Microsoft's November 2026 Patch Tuesday updates and is listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.

Alon Barad
Alon Barad
16 views•10 min read
•about 5 hours ago•CVE-2026-114154
7.5

CVE-2026-114154: Denial of Service in ASP.NET Core HttpSys Request Header Processing

CVE-2026-114154 is a high-severity Denial of Service (DoS) and uncontrolled resource consumption vulnerability in the Microsoft.AspNetCore.Server.HttpSys component of ASP.NET Core. When processing an HTTP request that simultaneously contains a chunked Transfer-Encoding header, a Content-Length header, and an explicit X-Content-Length header, the server throws an unhandled ArgumentException during header normalization. In certain versions, subsequent exception handling attempts to dereference a disposed native request context, aborting error response dispatch and leaking unmanaged HTTP.sys request structures.

Amit Schendel
Amit Schendel
4 views•9 min read