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



CVE-2026-105803

CVE-2026-105803: Arbitrary Command Execution via .lfsconfig Parsing in Git LFS

Alon Barad
Alon Barad
Software Engineer

Nov 20, 2026·10 min read·4 visits

Executive Summary (TL;DR)

Git LFS versions 1.3.0 through 3.8.0 fail to properly restrict configuration keys loaded from untrusted in-repository .lfsconfig files. Due to token-count validation flaws in config/git_fetcher.go and an unanchored regular expression in tq/custom.go, attackers can inject custom transfer adapter paths disguised as remote or access configuration keys. Cloning or fetching an affected repository executes attacker-controlled binaries on the client system. Upgrading to Git LFS v3.8.1 resolves the issue.

CVE-2026-105803 (GHSA-x72p-hmqp-46hw) is a high-severity arbitrary command execution vulnerability in Git Large File Storage (Git LFS) affecting versions from v1.3.0 prior to v3.8.1. The flaw stems from the combination of an unanchored regular expression in custom transfer adapter initialization (CWE-777) and insufficient syntactic validation during .lfsconfig key filtering (CWE-1286). An attacker can craft a repository containing a malicious .lfsconfig file that bypasses safe-key filtering restrictions and registers an arbitrary binary as a custom transfer adapter, leading to remote code execution when a victim clones or fetches from the repository.

Vulnerability Overview

Git Large File Storage (Git LFS) is an open-source Git extension written in Go that replaces large files such as audio samples, datasets, and graphics with text pointers inside Git while storing the file contents on a remote server. To facilitate repository-specific configurations, Git LFS allows repositories to include a tracked .lfsconfig file at the root of the working tree. This file typically defines non-sensitive parameters such as the remote LFS endpoint URL (lfs.url).

Because .lfsconfig travels with the repository and is controlled by anyone with commit access, Git LFS treats it as an untrusted configuration source. In its security model, directives capable of executing external programs—specifically custom transfer adapters (lfs.customtransfer.<name>.path) and extension filters—must only be loaded from trusted local sources such as /etc/gitconfig, ~/.gitconfig, or .git/config. To enforce this boundary, Git LFS sets a boolean flag (gc.OnlySafeKeys = true) when parsing .lfsconfig via readGitConfig() in config/git_fetcher.go.

CVE-2026-105803 represents a complete bypass of the .lfsconfig security boundary across all Git LFS releases from v1.3.0 up to v3.8.0. The vulnerability arises from the interaction of two distinct defects: improper syntactic validation of dot-delimited configuration keys (CWE-1286) during safe-key filtering, and an unanchored regular expression (CWE-777) used to identify custom transfer adapter paths in tq/custom.go.

By chaining these two weaknesses, an attacker can construct a composite configuration key in .lfsconfig that satisfies the safe-key whitelist while simultaneously matching the custom transfer adapter substring pattern. When a user or automated CI/CD pipeline clones or fetches objects from the repository, Git LFS registers and executes the attacker-specified command or binary in the context of the local user session.

Root Cause Analysis

The primary defense against malicious .lfsconfig directives resides in readGitConfig() within config/git_fetcher.go. As Git LFS iterates through configuration key-value pairs loaded from .lfsconfig, it splits each key into dot-separated tokens (parts := strings.Split(key, ".")) and evaluates whether the key is safe to admit into the active configuration environment (git.Env). Any key that does not satisfy the whitelist criteria is appended to an ignored slice and discarded.

The first flaw (CWE-1286) occurs in how readGitConfig() validates remote.* and *.access configuration keys. For keys beginning with remote, the parser executed the check if gc.OnlySafeKeys && (len(parts) == 3 && parts[2] != "lfsurl"). Because the rejection condition explicitly required len(parts) == 3, any key starting with remote. that contained four or more dot-separated segments caused the boolean expression to evaluate to false. Consequently, multi-segment keys under the remote namespace bypassed the continue statement and were marked as allowed = true. A similar flaw existed in the handling of access keys: the check else if len(parts) > 2 && parts[len(parts)-1] == "access" permitted any key containing three or more segments as long as its final token was access, without verifying that the key belonged to a valid lfs.<url>.access structure or restricting intermediate tokens.

The second flaw (CWE-777) resides in configureCustomAdapters() within tq/custom.go. When Git LFS prepares the transfer queue manifest, it scans all admitted configuration keys in git.All() using the regular expression lfs\.((?i)customtransfer\.([^.]+))\.path. In Go's regexp package, FindStringSubmatch() searches for the pattern anywhere within the target string unless explicit start-of-string (\A or ^) and end-of-string (\z or $) anchors are present.

Because the regular expression lacked both anchors, FindStringSubmatch() matched any configuration key containing lfs.customtransfer.<name>.path as an internal substring. When an attacker crafted a key such as lfs.customtransfer.testcustom.path.access or remote.lfs.customtransfer.testcustom.path.lfsurl, the key passed the readGitConfig() token filter due to its outer prefix or suffix, and subsequently triggered a positive match in configureCustomAdapters() due to its inner substring. Git LFS then extracted the captured adapter name (match[2]) and bound its executable path to the attacker-controlled value stored in .lfsconfig.

Code Analysis

The remediation for CVE-2026-105803 was implemented across three core commits in Git LFS v3.8.1, addressing both the regular expression matching in the transfer queue package and the key-filtering logic in the configuration parser.

In tq/custom.go (commit 62a727e7af1b0de0237c4d288ec0e977613df064), the unanchored regular expression in configureCustomAdapters() was updated to include strict string boundary anchors:

func configureCustomAdapters(git Env, m *concreteManifest) {
	configureDefaultCustomAdapters(git, m)
 
	// Vulnerable (prior to v3.8.1): lacked \A and \z anchors, matching substrings anywhere in the key
	// pathRegex := regexp.MustCompile(`lfs\.((?i)customtransfer\.([^.]+))\.path`)
 
	// Patched: enforces exact match from start of string (\A) to end of string (\z)
	pathRegex := regexp.MustCompile(`\Alfs\.((?i)customtransfer\.([^.]+))\.path\z`)
 
	for k, _ := range git.All() {
		match := pathRegex.FindStringSubmatch(k)
		if match == nil {
			continue
		}

In config/git_fetcher.go (commits 5182fdeccb834ed887746a557d0c736013704f39 and 1ecddd431e63c551ae11c153df0e07f37d2b44ef), the token validation logic inside readGitConfig() was tightened to prevent malformed multi-part keys from slipping past gc.OnlySafeKeys:

			} else if len(parts) > 1 && parts[0] == "remote" {
				// Vulnerable (prior to v3.8.1):
				// if gc.OnlySafeKeys && (len(parts) == 3 && parts[2] != "lfsurl") {
 
				// Patched: rejects keys with fewer than 3 tokens OR where the final token is not "lfsurl"
				if gc.OnlySafeKeys && (len(parts) < 3 || parts[len(parts)-1] != "lfsurl") {
					ignored = append(ignored, key)
					continue
				}
				allowed = true
				remote := strings.Join(parts[1:len(parts)-1], ".")
				uniqRemotes[remote] = remote == "origin"
			// Vulnerable (prior to v3.8.1):
			// } else if len(parts) > 2 && parts[len(parts)-1] == "access" {
 
			// Patched: requires the root namespace token parts[0] to be "lfs"
			} else if len(parts) > 2 && parts[0] == "lfs" && parts[len(parts)-1] == "access" {
				allowed = true
			}

Assessing fix completeness illustrates why defense-in-depth across both files was necessary. Fixing only the remote.* filter to require parts[len(parts)-1] == "lfsurl" and the access filter to require parts[0] == "lfs" would NOT have prevented exploitation on its own; keys such as remote.lfs.customtransfer.testcustom.path.lfsurl and lfs.customtransfer.testcustom.path.access still satisfy those structural token checks because Git permits dots inside subsection names (e.g., [remote "host.example.com"] or [lfs "https://example.com"]). The decisive security control that stops custom transfer injection is the \A...\z anchoring in tq/custom.go, which guarantees that any key ending in .lfsurl or .access or starting with remote. cannot match pathRegex. Meanwhile, tightening readGitConfig() closes the unintended filter gaps where arbitrary 4+ part remote.* keys or non-lfs .access keys were admitted into the configuration map.

Exploitation

Exploiting CVE-2026-105803 requires an attacker to create or modify a Git repository containing at least one Git LFS pointer file, a malicious .lfsconfig file, and either an in-repository payload binary or a reference to an executable already present on the target system. No authentication or elevated privileges on the victim host are required; the only prerequisite is that a victim user or automated build system clones or fetches the repository with Git LFS enabled.

The research context identifies three distinct exploitation vectors depending on how the configuration key and adapter name are structured. In Vector 1 (.access suffix injection) and Vector 2 (remote.*.lfsurl wrapper injection), the attacker defines a custom transfer adapter name (e.g., testcustom). If a standard adapter name is used, the LFS server selected by lfs.url negotiates that transfer adapter during the Batch API response. However, Vector 3 eliminates the need for a malicious LFS server altogether by hijacking Git LFS's built-in standalone file transfer adapter (lfs-standalone-file).

> [!NOTE] > When lfs-standalone-file is targeted, or when a file URL / standalone transfer path is triggered, Git LFS bypasses remote HTTP Batch API negotiation and immediately spawns the local process defined by the overridden adapter path.

The following commands, derived from the official regression test suite (t/t-custom-transfers-protect.sh), demonstrate how an affected repository is constructed:

# 1. Track a binary file pattern via Git LFS
git lfs track "*.bin"
printf "payload trigger" > test.bin
git add .gitattributes test.bin
 
# 2. Inject custom transfer adapter directives into .lfsconfig
# Vector A: Disguised as an access configuration key
git config --file .lfsconfig lfs.customtransfer.lfs-standalone-file.path.access "./adapter"
 
# Vector B: Disguised as a multi-part remote lfsurl configuration key
git config --file .lfsconfig remote.lfs.customtransfer.lfs-standalone-file.path.lfsurl "./adapter"
 
# 3. Commit the payload executable into the repository root
cp /path/to/compiled_payload ./adapter
chmod +x ./adapter
git add .lfsconfig adapter
git commit -m "Add repository assets"

When a victim executes git clone <repo_url>, Git first checks out the regular working tree files—placing .lfsconfig and ./adapter on disk in the repository root—and then invokes the git-lfs filter-process or git-lfs smudge hook to populate test.bin. At that point, Git LFS reads .lfsconfig, admits the poisoned key into git.All(), matches it in configureCustomAdapters(), and executes ./adapter as a child process.

Impact Assessment

Successful exploitation of CVE-2026-105803 grants the attacker arbitrary command execution on the client machine with the privileges of the user or service account running the Git operation. In developer workstations, this provides full access to local source code, SSH keys, cloud provider credentials, and internal network resources. In CI/CD runners and automated build pipelines that automatically clone repositories or check out pull requests from untrusted forks, exploitation leads to pipeline compromise, secret exfiltration, and potential supply-chain poisoning.

The authoritative CVSS v4.0 assessment by GitHub assigns a base score of 8.6 (High) with the vector CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N. The Attack Vector is Network (AV:N) because the malicious repository is delivered over remote Git protocols (HTTPS/SSH). Attack Complexity is Low (AC:L) and Attack Requirements are None (AT:N), as exploitation works reliably across default installations on Linux, macOS, and Windows (including Git for Windows, which bundles Git LFS by default). Privileges Required is None (PR:N), while User Interaction is Passive/Required (UI:P) because a user or automation agent must initiate a clone or fetch of the repository. Confidentiality (VC:H) and Integrity (VI:H) impacts on the vulnerable system are rated High due to arbitrary code execution.

Threat intelligence metrics indicate that while public proof-of-concept regression tests exist in the official Git LFS source repository, the vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. The Exploit Prediction Scoring System (EPSS) assigns CVE-2026-105803 a score of 0.00545 (0.55% probability of exploitation in the wild within 30 days), placing it in the 46.61st percentile.

Remediation

To remediate CVE-2026-105803, all deployments of Git LFS must be upgraded to version v3.8.1 or later. Users and administrators running Git for Windows, which bundles git-lfs.exe in its standard distribution, must upgrade to Git for Windows v2.56.0.windows.3 or a subsequent release containing the patched v3.8.1 binary.

In environments where an immediate upgrade is not possible, users can prevent automatic execution of Git LFS hooks during clone operations by disabling the smudge and process filters on the command line or in global configuration (~/.gitconfig). Running the clone command with the filter overrides shown below checks out the repository working tree without invoking Git LFS transfer adapters:

# Clone without executing Git LFS smudge or filter-process hooks
git clone -c filter.lfs.smudge= -c filter.lfs.process= -c filter.lfs.required=false <repository_url>

Once the repository is cloned with filters disabled, security teams or developers can inspect .lfsconfig prior to running git lfs pull or git lfs fetch. Security engineers can also audit existing repositories and CI/CD workspaces by scanning .lfsconfig files for strings matching customtransfer or .path, or by running Git LFS with trace logging enabled (GIT_TRACE=1) to observe whether warning: These unsafe '.lfsconfig' keys were ignored: or unexpected trace git-lfs: exec: events occur.

Official Patches

GitHub / Git LFSGit LFS v3.8.1 Official Release
GitHub Security AdvisoryGHSA-x72p-hmqp-46hw Official Security Advisory

Fix Analysis (6)

Technical Appendix

CVSS Score
8.6/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N
EPSS Probability
0.55%
Top 53% most exploited

Affected Systems

Git LFS (git-lfs/git-lfs)Git for Windows (bundled git-lfs.exe)

Affected Versions Detail

Product
Affected Versions
Fixed Version
Git LFS
GitHub / git-lfs
>= 1.3.0, <= 2.13.33.8.1
Git LFS
GitHub / git-lfs
>= 3.0.0, < 3.8.13.8.1
Git for Windows
Git for Windows
< 2.56.0.windows.32.56.0.windows.3
AttributeDetail
CVE / Advisory IDCVE-2026-105803 / GHSA-x72p-hmqp-46hw
Weakness ClassCWE-777 (Unanchored Regex) & CWE-1286 (Improper Syntactic Validation)
CVSS v4.0 Score8.6 High (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N)
EPSS Score0.00545 (46.61st Percentile)
Attack VectorNetwork (Cloning or fetching an untrusted Git repository with a crafted .lfsconfig)
ImpactArbitrary Command Execution / Remote Code Execution
Exploit StatusPoC available in official regression test suite (t/t-custom-transfers-protect.sh)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1189Drive-by Compromise
Initial Access
T1204.002User Execution: Malicious File
Execution
T1059Command and Scripting Interpreter
Execution
T1584.004Compromise Infrastructure: Server
Resource Development
CWE-777
Regular Expression without Anchors

The product uses a regular expression to perform security-critical validation or matching, but the regular expression does not use anchors to ensure that the match occurs at the beginning and/or end of the input string, allowing attackers to bypass checks via prefix or suffix injection.

Known Exploits & Detection

GitHub (Official Regression Tests in Fix Commit)Regression tests in t/t-custom-transfers-protect.sh demonstrating custom transfer adapter injection via .lfsconfig using .access and remote.*.lfsurl keys.

Vulnerability Timeline

CVE-2026-105803 and GitHub Security Advisory GHSA-x72p-hmqp-46hw published; Git LFS v3.8.1 released.
2026-11-19

References & Sources

  • [1]GitHub Security Advisory GHSA-x72p-hmqp-46hw
  • [2]Git LFS Release v3.8.1
  • [3]Official CVE Record (CVE.org)
  • [4]NVD Vulnerability Detail: CVE-2026-105803
  • [5]Fix Commit: Anchored Regex for Custom Adapters (62a727e)
  • [6]Fix Commit: Strict Remote Config Parsing (5182fde)
  • [7]Fix Commit: Strict Access Config Parsing (1ecddd4)
  • [8]Associated Fix Commit (45c0c51)
  • [9]Associated Fix Commit (c5b3bff)
  • [10]Associated Fix Commit (dcfb09f)
  • [11]CVE List v5 JSON Record

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-105802
8.6

CVE-2026-105802: Arbitrary Command Execution via Submodule Configuration Injection in Git LFS

A line delimiter injection vulnerability in Git Large File Storage (Git LFS) versions 0.6.0 through 3.8.0 allows remote attackers to execute arbitrary commands via crafted Git submodule URLs containing embedded line feed characters.

Alon Barad
Alon Barad
1 views•12 min read
•about 3 hours ago•CVE-2026-77367
9.4

CVE-2026-77367: Unauthenticated SQL Injection in Daptin Entity Listing Endpoints

An unauthenticated SQL injection vulnerability exists in Daptin prior to version 0.12.30. The generic entity listing handler fails to validate user-supplied sort parameters against the table schema before passing them to the goqu SQL query builder, enabling remote attackers to break out of SQL identifier quoting and execute arbitrary SQL subqueries.

Alon Barad
Alon Barad
5 views•9 min read
•about 4 hours ago•CVE-2026-77369
9.6

CVE-2026-77369: Broken Access Control in Daptin YJS Collaboration Endpoint

CVE-2026-77369 is a broken access control and Insecure Direct Object Reference (IDOR) vulnerability in Daptin, an open-source headless CMS. Affected versions from 0.11.4 through 0.12.29 expose a generic YJS real-time collaboration WebSocket endpoint (`GET /yjs/:documentName`) that verifies user authentication but fails to enforce row-level authorization when supplied with a canonical database room identifier (`{typename}.{referenceId}.{columnName}`). This allows any low-privileged authenticated user to read or modify restricted database columns of type `file.*` across all entities.

Alon Barad
Alon Barad
4 views•9 min read
•about 5 hours ago•CVE-2026-77376
6.1

CVE-2026-77376: Open Redirect in Bolt CMS LoginFormAuthenticator

CVE-2026-77376 is an open redirect vulnerability (CWE-601) in the core framework of Bolt CMS prior to version 6.1.4. The vulnerability resides within the LoginFormAuthenticator class, which processes post-authentication redirection for both successful and failed login attempts. Due to a lack of destination validation, the application accepts untrusted target paths from user sessions and directly reflects unvalidated HTTP Referer headers into HTTP Location response headers. Attackers can exploit this behavior to redirect users to arbitrary external domains after interacting with the Bolt login endpoint, facilitating credential harvesting and phishing attacks.

Amit Schendel
Amit Schendel
4 views•9 min read
•about 6 hours ago•CVE-2026-77377
5.2

CVE-2026-77377: Authenticated Server-Side Request Forgery in Bolt CMS Backend Asynchronous Endpoints

Bolt CMS (bolt/core) versions prior to 6.1.4 contain a Server-Side Request Forgery (SSRF) vulnerability in the authenticated URL-upload (/async/upload-url) and media embed (/async/embed) endpoints. Backend users with file upload or media embedding privileges can supply arbitrary URLs that the application fetches without destination IP validation. This allows authenticated attackers to force the server to initiate HTTP requests to loopback interfaces, RFC 1918 private networks, and cloud instance metadata services.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 7 hours ago•CVE-2026-77379
5.3

CVE-2026-77379: Information Disclosure in Bolt CMS Public Relation API

Bolt CMS prior to version 6.1.4 contains an information disclosure vulnerability in its public Relation API endpoints. The Doctrine ORM query extension (ContentExtension) fails to filter out unpublished, draft, or viewless content when querying the Relation entity. Because the Relation resource is configured with public read access (PUBLIC_ACCESS) via API Platform REST and GraphQL endpoints, unauthenticated remote attackers can enumerate relationship graphs, entity identifiers, and metadata associated with private content.

Alon Barad
Alon Barad
3 views•9 min read