Oct 6, 2026·7 min read·33 visits
A validation mismatch allows command execution bypasses in simple-git by using abbreviated Git options such as --receive-p and --exe, which bypass blocklist filters but are fully executed by the underlying Git binary.
CVE-2026-102827 is an argument injection bypass vulnerability in the node.js simple-git package where the default blockUnsafeOperationsPlugin fails to detect abbreviated Git command options. Attackers can bypass validations using prefixes like --receive-p or --exe, which native Git subsequently expands to dangerous options, leading to remote command execution.
This section outlines the architectural role of simple-git and the mechanics of the identified argument injection vulnerability. The simple-git library serves as a lightweight interface running Git commands within Node.js applications by wrapping process spawns. While it simplifies repository operations, exposing argument vectors to untrusted input introduces an attack surface where malicious parameters can modify execution logic.
To control this risk, the library employs security plugins designed to filter out destructive parameters. However, differences in how the Node.js wrapper parses options compared to the native C-based Git binary create a discrepancy. This mismatch allows command execution via argument injection, specifically bypassing prefix checks within the blockUnsafeOperationsPlugin.
This vulnerability is tracked as CVE-2026-102827 and GHSA-858h-whjf-mvg5. It is classified as improper neutralization of argument delimiters (CWE-88) and command injection (CWE-77). The flaw permits unauthenticated remote command execution under the context of the running application, specifically targeting the unprotected push path.
The root cause of this vulnerability lies in a parsing discrepancy between the JavaScript-based argument validation logic in simple-git and the native command-line option parser implemented in the git binary. The simple-git library uses a blocklist pattern via its blockUnsafeOperationsPlugin to inspect command arguments before executing them. This plugin attempts to prevent abuse by comparing input strings against known dangerous option patterns, such as --receive-pack and --exec.
The native Git CLI parser utilizes an option processing engine that automatically resolves unambiguous long-form parameter prefixes to their full counterparts. If a developer runs git push --receive-p=CMD, the parser recognizes that --receive-p matches only one valid option prefix, which is --receive-pack. It automatically expands the abbreviation internally and executes the argument accordingly. The same mechanism applies to --exe resolving to --exec.
Because simple-git's blockUnsafeOperationsPlugin historically performed exact string matches or restrictive regular expression checks, it did not account for these abbreviation permutations. An attacker could supply --receive-p or --exe instead of the fully written option names. The validation filter evaluated these strings, determined they did not match the blocked literals, and passed them to the child process spawning layer.
Upon receiving the command line, the native Git process parsed the abbreviated options and executed the specified binary payloads. Although previous fixes, such as those addressing CVE-2026-28291, introduced mitigation steps for specific operations like cloning, they failed to cover the push path. Consequently, the push path remained fully exposed to this parsing bypass mechanism.
The vulnerable implementation of simple-git relied on matching literal string patterns within its input validation checks. The following conceptual representation shows the vulnerable validation path where options were checked against exact strings:
// Vulnerable validation logic (conceptual)
function detectVulnerableFlags(args) {
const dangerousFlags = ['--receive-pack', '--exec', '--upload-pack'];
for (const arg of args) {
if (dangerousFlags.includes(arg.split('=')[0])) {
throw new Error('Unsafe operation blocked');
}
}
}The patched implementation in version 4.0.0 leverages an internal Git configuration variable rather than maintaining a complex local JavaScript parser. It sets the GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS environment variable to "true" inside the child process execution context. This prevents the native Git binary from resolving abbreviated arguments, forcing it to reject any incomplete long-form options.
The patch introduces the environment plugin to enforce this constraint globally:
// simple-git/src/lib/plugins/allow-environment.plugin.ts
export function allowEnvironmentPlugin(
allowEnvironment: readonly string[],
allowAbbreviatedOptions = false
): SimpleGitPlugin<'spawn.options'> {
return {
type: 'spawn.options',
action(spawnOptions, context) {
const env = { ...spawnOptions.env };
return {
...spawnOptions,
env: {
...env,
GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS: String(!allowAbbreviatedOptions),
},
};
},
};
}If an abbreviated parameter is supplied when GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS is set to "true", Git immediately halts execution and exits with status code 128. The wrapper captures this error and handles it gracefully via a specialized exception handler.
// simple-git/src/lib/errors/git-configuration-error.ts
const REASONS = {
DISALLOWED_ABBREVIATED: {
text: 'disallowed abbreviated or ambiguous option',
solution:
'Unambiguous abbreviated options blocked with unsafe.allowAbbreviatedOptions setting: {message}',
},
UNKNOWN: { text: '~ unknown ~', solution: undefined },
} as const;This structural change shifts the responsibility of validating command-line options back to the Git binary itself, ensuring full completeness of the fix across all present and future CLI options.
To exploit this vulnerability, an attacker must identify a consumer application that accepts user-supplied arguments and passes them directly to simple-git methods, specifically the push operation. The application must permit untrusted string inputs to populate the options or arguments arrays of the library wrapper.
An attacker constructs a payload targeting the push operation by leveraging the --receive-p or --exe option abbreviations. The payload is designed to point to an arbitrary local command execution string, formatted as an option assignment.
# Example command executed via child process spawn
git push origin main --receive-p="touch /tmp/pwned"When this command runs, the Node.js process spawns the native Git binary. The Git command-line parser maps --receive-p to the native --receive-pack handler. Since --receive-pack directs Git to use a specific helper executable to receive objects on the remote side, Git executes the specified payload string as an operating system command under the privileges of the Node.js application process.
The impact of successful exploitation is remote command execution (RCE) on the host operating system. Because the payload runs as a child process of the Node.js application, the injected commands execute with the same operating system privileges as the parent Node.js runtime process. If the application runs as a privileged user or root, the attacker gains full administrative control over the host container or server.
The CVSS 3.1 base score is 8.1, reflecting high confidentiality, integrity, and availability impacts. The attack complexity is rated as high because the exploit requires a specific application configuration where user-controlled inputs are passed directly into the command options arrays of simple-git methods.
While the Exploit Prediction Scoring System (EPSS) score remains low at approximately 0.36%, the simplicity of abusing prefix abbreviations makes this a highly reliable exploitation vector once the prerequisite input exposure is met. There are no active reports of this vulnerability being used in ransomware or listed in the CISA KEV catalog, but the availability of public technical details increases the risk of targeted scanning.
The primary mitigation is upgrading the simple-git dependency to version 4.0.0 or higher. This version activates the native blocking of abbreviated options by default across all spawned Git sub-processes. Applications using legacy versions must be audited to ensure that user input is never used to construct option flags.
If upgrading is not immediately possible due to breaking changes in major version releases, developers must implement manual input sanitization. A strict validation filter must be applied to all user-controlled strings, blocking any parameter that starts with a hyphen character (-) unless it explicitly matches a predefined safe allowlist of non-option values.
Additionally, applying container-level security controls reduces the potential blast radius. Applications should execute within minimal, unprivileged service accounts, and system-call filtering such as seccomp or AppArmor should be configured to restrict the creation of unauthorized child processes.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
simple-git steveukx | < 4.0.0 | 4.0.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-88, CWE-77 |
| Attack Vector | Network |
| CVSS Base Score | 8.1 |
| Exploit Maturity | PoC |
| Affected Component | blockUnsafeOperationsPlugin |
| Remediation Strategy | GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS |
The product takes string input from an external source, constructs a command string with arguments from it, and executes the command. However, it does not properly neutralize command or argument delimiters.
CVE-2026-77378 (GHSA-r7h9-qx4h-77j5) is an authenticated SQL injection vulnerability affecting the bolt/core package of Bolt CMS in versions prior to 6.1.4. The flaw resides in the ListFormatHelper utility class, where content-type slugs are dynamically interpolated into raw SQL query strings via sprintf rather than bound as parameterized inputs. When the general/caching/list_format configuration directive is enabled, an authenticated user with upload privileges can exploit the /async/select-options endpoint to inject arbitrary SQL commands and query the underlying database.
A cryptographic soundness defect in the discrete-Gaussian sampler of falcon-rust prior to version 0.2.0 degrades acceptance-probability precision to approximately 2^-33. By evaluating exponential approximations using 32-bit fractional fixed-point arithmetic (FixedPoint64) and left-shifting polynomial inputs by 31 bits, the implementation violates Falcon's required precision bound of 2^-40 to 2^-46, invalidating the theoretical security reduction against statistical private key leakage.
CVE-2026-62955 is an authenticated path traversal vulnerability in baserCMS affecting versions 5.2.3 up to, but not including, 5.3.0. The flaw resides in the BcThemeFileService::getFullpath() method within the bc-theme-file plugin and represents an incomplete remediation of CVE-2026-30940. Because the path containment check relies on PHP's realpath() returning a non-false value, supplying a nonexistent theme subdirectory causes the verification guard to be skipped entirely. An authenticated administrator can exploit this flaw to read, write, overwrite, or delete arbitrary files within the permissions of the PHP process, leading to remote code execution when executable PHP files are written to the webroot.
CVE-2026-63012 is an authorization bypass and information disclosure vulnerability in baserCMS versions prior to 5.3.0. An architectural flaw in the authentication service configuration combined with overly permissive API access control rules allows low-privileged operator accounts to query restricted administrative API endpoints by supplying a matching HTTP Referer header.
CVE-2026-102945 is a denial-of-service vulnerability affecting the Access and Mobility Management Function (AMF) of the Aether Project (omec-project/amf) prior to version 3.1.6. When processing an NGAP PathSwitchRequest message over the 3GPP N2 interface, the HandlePathSwitchRequest function fails to verify the byte slice lengths of extensible APER bit strings inside the UESecurityCapabilities Information Element before accessing index zero. Because the NGAP receive goroutine lacks a panic recovery handler, supplying a zero-length bit string triggers an out-of-bounds slice read panic that terminates the entire AMF daemon.
CVE-2026-103025 (GHSA-7hvw-3c2q-45qg) is a high-severity denial-of-service (DoS) vulnerability in github.com/bep/imagemeta prior to version 0.17.3. The PNG metadata parser fails to validate declared chunk lengths prior to heap buffer allocation (CWE-789) and inflates zlib-compressed zTXt IPTC chunks without an output size limit (CWE-409). Additionally, out-of-bounds slice indexing in the PNG zTXt handler and IPTC character set resolver allows remote attackers to trigger runtime panics.