/

CVE-2025-66413

Severity:

HIGH RISK

(7.4)

Information Exposure in Git for Windows Clone Operation

CVE-2025-66413

Analyzed

Vulnerability type

Category:

Information Exposure

CWE:

CWE-200, CWE-307

Impact:

Credential Exposure and Account 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

Git for Windows prior to 2.53.0(2) can expose a user's NTLM hash when they are tricked into cloning from a malicious server.

An attacker who captures this hash can attempt offline brute-force attacks to recover the associated Windows account name and password, potentially leading to account compromise.

Affected context

This vulnerability affects Git for Windows clients performing clone operations against untrusted or attacker-controlled Git servers.

It is relevant in environments where:

  • NTLM authentication is in use for network access or single sign-on
  • Users regularly clone repositories over network protocols that may trigger NTLM negotiation
  • Developers interact with external or unfamiliar Git hosting endpoints (e.g., URLs received via email, chat, or tickets)

The risk materializes when a user initiates a clone from a malicious endpoint that can provoke and capture NTLM-based authentication data.

Exploit preconditions

  • Attack surface: Git for Windows client during network-based Git operations (e.g., git clone).
  • Required access: Ability for the attacker to operate or control a Git server or network endpoint and convince a victim to clone from it (social engineering, phishing, or URL spoofing).
  • Trigger point: The victim runs a Git command (typically git clone) against the attacker-controlled server, causing NTLM authentication to occur and the hash to be transmitted.
  • Why exploitation is possible: The client exposes NTLM authentication material to the remote endpoint in a way that allows the attacker to capture the NTLM hash, which can then be subjected to offline brute-force attacks due to the weakness of NTLM hashing.

Why this happens

The core issue is an information exposure pattern where authentication material (NTLM hashes) is made available to a potentially untrusted remote party during routine client-server interaction.

This aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, as the Git for Windows client does not sufficiently restrict when and to whom NTLM-derived credentials are sent.

Abstractly, the insecure pattern is:

  • Treating any remote Git endpoint as trusted for integrated authentication, without strong origin validation or user-awareness.
  • Allowing protocol negotiation to proceed such that a passive or malicious remote endpoint can receive sensitive hash values.

The problem is not that NTLM exists, but that its derived secrets are exposed to parties that should not receive them, enabling offline credential recovery.

Potential impact

  • Attacker may obtain the victim's NTLM hash during a clone to a malicious Git server.
  • Attacker could perform offline brute-force or dictionary attacks against the NTLM hash to derive the victim's account password.
  • Compromise of the victim's Windows user account if the password is recovered.
  • Potential lateral movement within the organization's network if the same credentials are reused for other services.
  • Increased risk of unauthorized access to source code repositories, development infrastructure, and corporate systems tied to the compromised account.

General mitigation guidance

Effective mitigation focuses on reducing when and how sensitive authentication material is exposed, and limiting trust in remote endpoints:

  • Prefer protocols and authentication mechanisms that do not expose reusable password hashes to remote servers (e.g., using access tokens, SSH keys, or modern credential schemes instead of NTLM where possible).
  • Restrict or disable automatic integrated authentication to untrusted or unknown Git servers; require explicit configuration or user consent before sending system credentials.
  • Segment and harden developer environments so that domain credentials are not broadly reused for external development services.
  • Apply least-privilege principles to user accounts whose credentials may be exposed, reducing the blast radius if a password is guessed.
  • Provide user training and internal guidelines about cloning only from trusted, verified repository URLs and being cautious with links received via email or messaging platforms.
  • Centralize Git access via secured, vetted internal proxies or mirrors, so users rarely need to connect directly to arbitrary external Git endpoints.

How teams detect issues like this

Detection tends to focus on identifying risky authentication flows and unusual Git server interactions:

  • Review client and network logs to identify Git-for-Windows traffic that negotiates NTLM authentication with non-corporate or unapproved endpoints.
  • Use network monitoring or intrusion detection systems to flag outbound NTLM authentication attempts to unknown or external addresses.
  • Apply static or configuration analysis to development workstation images and Git configuration files to detect settings that allow or encourage integrated NTLM authentication to arbitrary hosts.
  • Incorporate security review steps into DevSecOps practices, checking that developers rely on SSH keys or access tokens for external Git services instead of domain credentials.
  • Periodically audit password reuse and password strength policies to reduce the likelihood that an exposed hash can be brute-forced into a widely useful credential.

Sources

SourceLink
github.comgithub.com/git-for-windows/git/releases/tag/v2.53.0.windows.2
github.comgithub.com/git-for-windows/git/security/advisories/GHSA-hv9c-4jm9-jh3x

Frequently asked

questions

Yes. An attacker can exploit it remotely by operating a malicious Git server or endpoint and convincing a victim to perform a clone operation against it, which can cause the client to send NTLM hashes.

The attacker needs control over a Git server or network endpoint and the ability to persuade the victim to connect to it (for example, by sending a crafted repository URL). No prior access to the victim's machine is required beyond their normal Git usage.

Use authentication schemes that do not expose reusable password hashes (such as SSH keys or access tokens), restrict NTLM or integrated authentication to trusted domains and hosts, and configure Git clients so that system credentials are not automatically sent to arbitrary servers.

Apply a default-deny stance for credential sharing with network services, enforce strong separation between internal identity systems and external development services, routinely audit authentication flows for information exposure, and incorporate secure configuration baselines for developer tooling into workstation provisioning and CI policies.

Find out what's already
exploitable in your codebase.