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

CVE-2026-102827: Command and Argument Injection Bypass in simple-git via Option Abbreviation

Alon Barad
Alon Barad
Software Engineer

Oct 6, 2026·7 min read·33 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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.

Exploitation

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.

Impact Assessment

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.

Remediation

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.

Official Patches

steveukxCommit fixing abbreviation handling in simple-git
steveukxPull request addressing security plugin bypass

Fix Analysis (1)

Technical Appendix

CVSS Score
8.1/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
EPSS Probability
0.36%
Top 72% most exploited

Affected Systems

Node.js environments deploying applications that integrate simple-git versions prior to 4.0.0Systems executing server-side simple-git commands where parameters are derived from user-controlled inputs

Affected Versions Detail

Product
Affected Versions
Fixed Version
simple-git
steveukx
< 4.0.04.0.0
AttributeDetail
CWE IDCWE-88, CWE-77
Attack VectorNetwork
CVSS Base Score8.1
Exploit MaturityPoC
Affected ComponentblockUnsafeOperationsPlugin
Remediation StrategyGIT_TEST_DISALLOW_ABBREVIATED_OPTIONS

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
CWE-88
Improper Neutralization of Argument Delimiters in a Command ('Argument Injection')

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.

References & Sources

  • [1]GHSA-858h-whjf-mvg5 Security Advisory
  • [2]NVD CVE-2026-102827 Entry
  • [3]CVE.org 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-77378
6.5

CVE-2026-77378: Authenticated SQL Injection in Bolt CMS ListFormatHelper

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.

Alon Barad
Alon Barad
3 views•11 min read
•about 2 hours ago•CVE-2026-77382
5.9

CVE-2026-77382: Cryptographic Precision Loss in falcon-rust Discrete-Gaussian Sampler

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.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 3 hours ago•CVE-2026-62955
7.2

CVE-2026-62955: Authenticated Path Traversal and Remote Code Execution via realpath() Bypass in baserCMS BcThemeFileService

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.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 4 hours ago•CVE-2026-63012
6.5

CVE-2026-63012: Authorization Bypass and Information Disclosure in baserCMS Administrative API

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.

Alon Barad
Alon Barad
2 views•9 min read
•about 5 hours ago•CVE-2026-102945
4.9

CVE-2026-102945: Unrecovered Goroutine Panic via Malformed NGAP PathSwitchRequest in Aether Project AMF

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.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 6 hours ago•CVE-2026-103025
8.7

CVE-2026-103025: Unbounded Memory Allocation and Decompression Bomb in bep/imagemeta PNG Parser

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.

Amit Schendel
Amit Schendel
2 views•1 min read