/

CVE-2026-30312

Severity:

CRITICAL RISK

(9.8)

OS Command Injection in DSAI-Cline Auto-Approval Module

CVE-2026-30312

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

DSAI-Cline's command auto-approval module contains an OS command injection flaw where newline characters are not treated as dangerous separators during validation.

An attacker can append malicious commands after a whitelisted command using a literal newline, causing PowerShell to execute both commands and enabling remote code execution without user interaction.

Affected context

This vulnerability occurs in environments where DSAI-Cline is configured to auto-approve or auto-execute commands based on a whitelist-style validation.

The module attempts to filter dangerous shell operators but only at the string level, allowing newline characters to slip through as implicit command separators.

When validated commands are later passed to PowerShell, the interpreter honors embedded newlines as separate commands, turning seemingly safe, whitelisted input into a multi-command sequence including attacker-controlled instructions.

Exploit preconditions

  • Attack surface: Interfaces where DSAI-Cline accepts or generates shell commands for auto-approval (e.g., automation workflows, integrations, or AI-generated commands).
  • Required access: Ability to influence or supply command strings that pass through the auto-approval module (e.g., via prompts, API requests, or upstream automation inputs).
  • Trigger point: Submission of a command that starts with a whitelisted base command and embeds a newline followed by arbitrary shell code.
  • Why exploitation is possible: The validator only blocks explicit operators like ;, &&, ||, |, and command substitution syntax, but does not treat newline characters as separators. PowerShell, however, interprets a newline as a command boundary and executes both the whitelisted and malicious segments sequentially.

Why this happens

The underlying issue is a classic OS command injection pattern where user-influenced input is concatenated into shell commands without robust, context-aware validation.

The DSAI-Cline module relies on brittle, string-based filtering to enforce a whitelist, focusing on a limited set of shell metacharacters while ignoring semantically equivalent separators such as newlines.

This maps directly to CWE-78: Improper Neutralization of Special Elements used in an OS Command, where the application attempts to sanitize or validate command text but fails to fully account for all ways the interpreter (PowerShell) can separate or structure commands.

By failing to treat newline characters as dangerous in the same way as ; or &&, the module creates an inconsistency between what the validator considers "safe" and what the shell actually executes.

Potential impact

  • Execution of arbitrary OS commands with the privileges of the DSAI-Cline process.
  • Unauthorized access to sensitive data on the host system.
  • Modification or destruction of local files and configuration.
  • Installation of backdoors, malware, or persistence mechanisms.
  • Lateral movement within the network using compromised host credentials or connectivity.
  • Abuse of DSAI-Cline's automation workflows for supply-chain or pipeline attacks.

General mitigation guidance

Effective mitigation focuses on eliminating direct shell composition paths and hardening any unavoidable command execution:

  • Prefer non-shell APIs (e.g., direct library calls, SDKs, or system APIs) instead of building shell command strings from user-controllable input.
  • If a shell must be used, construct commands using strict argument lists (e.g., PowerShell cmdlet invocation with parameter binding, not raw string concatenation) and avoid invoking a general-purpose command interpreter where possible.
  • Move from ad-hoc string filtering to positive, structured validation:
  • Define a strict schema of allowed commands and arguments.
  • Validate each argument by type and format, not just by searching for forbidden characters.
  • Treat all shell separators and control characters as potentially dangerous, including newlines, carriage returns, backticks, and other metacharacters that PowerShell interprets as command boundaries or modifiers.
  • Run the DSAI-Cline process and any child interpreters with least privilege, restricting filesystem and network access to the minimum required for operation.
  • Introduce defense-in-depth controls, such as restricting outbound command execution contexts, using application allow-lists at the OS level, and monitoring for abnormal command patterns.

How teams detect issues like this

Detection can combine code-level analysis with runtime monitoring:

  • Static analysis and code review:
  • Flag any code paths that assemble shell commands from variable input, especially concatenated strings passed to PowerShell or other shells.
  • Look for whitelist or blacklist style filters that check only a subset of metacharacters (;, &&, ||, |) and do not account for newlines or other separators.
  • Identify places where "safe command" labels are applied before execution, and confirm that validation matches the interpreter's parsing rules.
  • Policy and automated checks:
  • Enforce secure coding policies that discourage direct shell invocation for automation when library alternatives exist.
  • Use automated code scanning tools configured with rules for CWE-78 and patterns specific to PowerShell command concatenation and string-based whitelisting.
  • Runtime and log-based detection:
  • Monitor logs or telemetry for multi-line commands, suspicious PowerShell invocation patterns, or commands that combine benign tooling (e.g., git) with unexpected administrative or system operations.
  • Alert on sequences of commands triggered without direct user interaction or outside normal operational windows.

Sources

SourceLink
github.comgithub.com/Secsys-FDU/LLM-Tool-Calling-CVEs/issues/9
github.comgithub.com/necboy/cline-DSAI

Frequently asked

questions

It can be, depending on how DSAI-Cline is integrated. If remote users or external systems can influence the commands that pass through the auto-approval module—such as via APIs, chat interfaces, or automated workflows—then exploitation can be effectively remote.

The attacker needs the ability to control or meaningfully influence command strings processed by DSAI-Cline's auto-approval logic. Direct shell access is not required; controlling the upstream input to the auto-approval module is sufficient.

The most robust fix is to remove direct shell command construction and instead invoke operations through structured APIs or parameterized command interfaces. Where shells are unavoidable, use strict argument-based invocations and validated command schemas, not ad-hoc string filtering.

Avoid building shell commands from dynamic strings, adopt secure coding guidelines for automation components, and ensure validation logic is aligned with how the underlying interpreter parses input. Incorporate static analysis rules for command injection, peer review checklists focused on CWE-78 patterns, and continuous security testing of any feature that auto-executes or auto-approves commands.

Find out what's already
exploitable in your codebase.