/

CVE-2026-30313

Severity:

CRITICAL RISK

(9.8)

OS Command Injection in DSAI-Cline Command Auto-Approval

CVE-2026-30313

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-94

Impact:

Remote Code Execution without user interaction

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 is vulnerable to OS command injection because its validation logic fails to treat embedded newline characters as dangerous separators.

An attacker can append malicious commands after a newline in what appears to be a whitelisted command, causing the PowerShell interpreter to execute both commands and enabling remote code execution without user interaction.

Affected context

This vulnerability affects environments where DSAI-Cline's command auto-approval feature is enabled and used to automatically run system commands through PowerShell.

The issue occurs in the parsing layer that attempts to enforce a whitelist by scanning for specific operators (such as ;, &&, ||, | and command substitution patterns) but does not treat raw newline characters as potential command separators.

Systems that trust auto-approved commands and execute them with elevated or inherited privileges are particularly exposed.

Exploit preconditions

  • Attack surface: The command input channel that feeds into DSAI-Cline's auto-approval module (e.g., chat-driven commands, automation workflows, or integrated tools that submit shell commands).
  • Required access: Ability to submit or influence a command that will be evaluated and auto-approved by DSAI-Cline; no local shell access is needed beyond this interface.
  • Trigger point: The moment DSAI-Cline scans the command string, applies its whitelist checks, and then forwards the "approved" command to the underlying PowerShell interpreter.
  • Why exploitation is possible: The validator implements string-based checks that only look for certain meta-characters and command substitution patterns, while PowerShell treats newline characters as command delimiters.

By inserting a literal newline between a benign, whitelisted command (e.g., git log) and a malicious command, the attacker causes the parser to see a single "safe" operation, whereas PowerShell executes multiple commands sequentially.

Why this happens

The core defect is an incomplete and context-insensitive validation strategy for shell commands, where the logic assumes that blocking a small set of dangerous tokens is sufficient.

This aligns with CWE-94: Improper Control of Generation of Code, since the application constructs and feeds code-like command strings into an interpreter without fully constraining what can be executed.

Instead of treating the command as untrusted code that must be either avoided or expressed through structured APIs, the module attempts to sanitize it using ad hoc string rules that do not model the interpreter's full syntax (in this case, that newlines act as separators).

As a result, the "whitelist" behaves more like a brittle blacklist, allowing attackers to generate arbitrary executable command sequences that bypass the intended restrictions.

Potential impact

  • Remote execution of arbitrary OS commands in the context of the DSAI-Cline runtime.
  • Exfiltration or destruction of sensitive data accessible to the service account.
  • Installation of backdoors, persistence mechanisms, or additional malware.
  • Lateral movement to other systems reachable from the compromised host.
  • Abuse of CI/CD or automation pipelines that rely on DSAI-Cline for command execution.

General mitigation guidance

Effective mitigation focuses on eliminating direct shell construction and dropping reliance on string-based whitelists:

  • Prefer structured, parameterized APIs instead of passing free-form command strings to PowerShell; use language or library calls that model each operation explicitly.
  • Where command invocation is unavoidable, use strict allowlisted subcommands and arguments modeled as structured data (e.g., fixed verb + enumerated options) rather than concatenated strings.
  • Treat the shell as an untrusted interpreter boundary: do not attempt to "sanitize" arbitrary input; instead, reject commands that deviate from narrowly defined patterns and avoid mixing user-controlled content into executable segments.
  • Normalize and canonicalize input before validation, including explicit handling of whitespace and newlines, and perform validation on the canonical form.
  • Run the execution context under least privilege, with constrained tokens and minimal filesystem/network access, so that any command execution is strongly limited in impact.
  • Log and gate auto-approved commands with optional policy-based approvals for high-risk operations, reducing the blast radius of any future parsing gaps.

How teams detect issues like this

Detection typically combines code-level analysis with runtime monitoring:

  • Static analysis / code review:
  • Flag any code that builds shell or PowerShell command strings from user-controlled or externally influenced input.
  • Identify validation routines that rely on blacklists of characters or operators instead of strict structural whitelists.
  • Look for logic that treats command text as opaque strings rather than decomposing into verbs, subcommands, and arguments.
  • Security testing:
  • Incorporate tests that inject newlines, alternate whitespace, and control characters into commands accepted by the auto-approval module.
  • Use dynamic analysis or fuzzing focused on the command parsing layer to surface inconsistencies between validation and interpreter behavior.
  • Operational monitoring:
  • Capture and review executed commands (or at least their normalized forms) in logs, with alerts on unusual patterns such as multi-line commands, unexpected utilities, or outbound network tools.
  • Deploy host-based intrusion detection to detect anomalous processes spawned by the DSAI-Cline runtime.

Automated SAST/DAST tools can help identify shell-command construction and suspicious validation patterns, but findings should be verified with threat-model–driven manual review.

Sources

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

Frequently asked

questions

Yes, if an attacker can supply commands to an interface that DSAI-Cline auto-approves and executes, they can achieve remote code execution without needing direct shell access.

The attacker must be able to influence or submit a command string to the auto-approval module. This could be via a chat interface, API, or integrated tool that feeds commands into DSAI-Cline, depending on how it is deployed.

Replace free-form shell execution with structured, parameterized operations that do not rely on constructing command strings. If shell execution is unavoidable, strictly model allowed commands and arguments as data, normalize input, and reject anything outside a narrowly defined, audited allowlist.

Treat any interaction with interpreters (shells, scripting engines, template engines) as code execution boundaries. Avoid string concatenation for commands, use safe APIs, enforce least privilege, and subject any validation logic that guards interpreter boundaries to dedicated security review and automated testing that includes edge cases like newlines and control characters.

Find out what's already
exploitable in your codebase.