Back to skill

Security audit

Cline Programming

Security checks for vulnerabilities and agentic risk

Overview

This skill is a Cline automation guide, but it repeatedly promotes auto-approved code execution and includes a test script that runs it without a human review gate.

Install only if you intend to use Cline with broad automation, and avoid running the provided `--yolo` examples or test script outside a disposable, least-privilege sandbox. Prefer manual approvals, review generated plans and diffs immediately before execution, and keep API credentials out of workspaces where autonomous tasks can read them.

Vulnerability Patterns
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:42
Finding
Autonomous code execution is enabled through unrestricted automatic approval## Vulnerability Details **File Location**: `SKILL.md:42-52`; `scripts/test_cline.sh:37-55` **Vulnerability Type**: Unsafe automatic approval of AI-generated operations **Risk Level**: High ### Complete Code Snippet From `SKILL.md`: ```bash # Execute code in automatic approval mode cline task "Create a simple web server" --act --yolo --verbose --json ``` The documentation states that `--yolo` automatically approves all operations and promotes it as the default approach. From `scripts/test_cline.sh`: ```bash # Test Cline planning mode echo "=== Testing Cline planning mode ===" if cline task "Create a simple Hello World program" --plan --yolo --verbose --json; then echo "Cline planning mode completed successfully" else echo "Cline planning mode failed" exit 1 fi echo "" # Test Cline execution mode echo "=== Testing Cline execution mode ===" if cline task "Create a simple Hello World program" --act --yolo --verbose --json; then echo "Cline execution mode completed successfully" else echo "Cline execution mode failed" exit 1 fi ``` ### Technical Analysis The skill invokes an AI programming tool in execution mode with the `--yolo` option. This option removes interactive approval boundaries and permits operations proposed by the model to proceed automatically. AI-generated operations may include shell commands, file creation or modification, package installation, network requests, and execution of generated programs. The effective operation is influenced not only by the explicit task but potentially by repository content, dependency output, external data, and model behavior. Automatically approving such operations therefore violates least-privilege and human-in-the-loop security principles. The test script also performs a live execution task rather than limiting itself to passive checks such as displaying the version or validating command syntax. Running the test can ...[truncated 1497 chars]
Remediation
## Remediation Suggestions 1. Remove `--yolo` from all default commands, examples, and test cases. 2. Require explicit approval for command execution, file writes, package installation, credential access, and network activity. 3. Replace the live execution test with passive checks such as `cline --version`, `cline help`, or a dry-run mode that cannot execute tools. 4. Run Cline in an isolated container or sandbox with: - A dedicated unprivileged account. - Read-only access to source files unless writes are specifically required. - A narrowly scoped writable workspace. - No access to home-directory credentials, SSH keys, cloud tokens, or system configuration. - Network access disabled by default or restricted through an allowlist. 5. If automation is essential, use a narrowly defined operation allowlist rather than approving every generated action. 6. Display the exact generated commands, file changes, and network targets before execution and require approval for any deviation. 7. Add a prominent warning that repository and task content must be treated as untrusted input.

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:56
Finding
The documented review stage does not constrain execution to the reviewed plan## Vulnerability Details **File Location**: `SKILL.md:56-69` **Vulnerability Type**: Plan-to-execution integrity failure **Risk Level**: High ### Complete Code Snippet ```bash # Generate a code plan in automatic approval mode cline task "Create a simple calculator program" --plan --yolo --verbose --json # View and inspect the code plan ls -la plan-*.md cat plan-*.md # Execute code in automatic approval mode cline task "Create a simple calculator program" --act --yolo --verbose --json ``` ### Technical Analysis The skill describes a `plan -> check -> act` security workflow, but the execution command does not reference, verify, or load the plan that the user reviewed. Instead, it starts a separate task using the original natural-language prompt. As a result, there is no integrity binding between the reviewed artifact and the operations performed during execution. Cline may regenerate a different implementation or select different commands during the act phase. The use of `--yolo` further removes the approval checkpoint that might otherwise expose this divergence. Merely displaying `plan-*.md` is not an enforceable security control. The wildcard can also display several plans, making it unclear which plan is associated with the subsequent execution. No plan identifier, content hash, signature, or change check is used. ### Attack Path 1. A user invokes plan mode and reviews a plan that appears safe. 2. Repository content, external context, model output, or the environment changes before act mode is invoked. 3. The act command starts a new generation process rather than executing the reviewed plan. 4. Cline produces operations that differ from the reviewed proposal. 5. Because `--yolo` is enabled, the new operations execute without another meaningful approval step. 6. The user may not detect the discrepancy because the documented workflow implies that the reviewed plan governs execution. ### Impact Assessme ...[truncated 561 chars]
Remediation
## Remediation Suggestions 1. Require act mode to consume the exact reviewed plan rather than regenerating behavior from the original prompt. 2. Use the supported plan-loading mechanism, such as `--load-plan`, if it guarantees execution from the supplied artifact. 3. Record a cryptographic hash of the reviewed plan and verify it immediately before execution. 4. Abort execution if the plan file changes, the selected plan is ambiguous, or Cline proposes operations absent from the reviewed plan. 5. Replace `plan-*.md` wildcards with an explicit plan path generated for the current task. 6. Present a final command and file-change diff before execution. 7. Require fresh user approval whenever execution diverges from the reviewed plan. 8. Remove `--yolo` so that the plan review is supplemented by operation-level confirmation and sandboxing.
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (7)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The skill claims a safe plan-check-act workflow, but the documented commands default to `--yolo` auto-approval for both planning and execution, with the 'check' step being only a manual suggestion rather than an enforced control. In the context of an AI coding/execution tool, this mismatch is dangerous because users may trust the description and run unreviewed generated actions with elevated autonomy, increasing the risk of unintended code execution or unsafe file/system changes.

Natural-Language Policy Violations

Medium
Confidence
94% confidence
Finding
The manifest description and main documentation are written entirely in Chinese, and the file does not indicate that the skill is China-specific or provide an option for another language. Under the stated policy, a language-specific constraint without user opt-in or justification is a natural-language policy violation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
"actModeApiProvider": "openai",
  "actModeOpenAiModelId": "doubao-seed-2.0-code",
  "autoApprovalSettings": {"version":30,"enabled":true,"favorites":[],"manualApprovals":[]},
  "autoApproveAllToggled": false,
  "autoApprovalTimeout": 300000
}
```
Confidence
91% confidence
Finding
The documented configuration includes enabled auto-approval settings for an AI system that can generate and execute code. In this skill's context, autonomous approval is especially risky because the same document repeatedly promotes `--yolo` execution, which can permit unsafe actions without meaningful human review and amplify prompt-induced or model-generated harmful behavior.

Description-Behavior Mismatch

Medium
Confidence
92% confidence
Finding
The script does more than test a planning workflow: it invokes `cline task ... --act --yolo`, which authorizes autonomous execution rather than requiring a human review step. In the context of an agent skill that advertises 'plan-check-act', this bypasses the safety boundary and can cause arbitrary file or environment changes if the underlying tool interprets the prompt broadly.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
Presenting `cline` in act mode with `--yolo` as a normal test path encourages unattended code execution without warning the operator about side effects. Because the task string is handed to an AI coding tool, execution may create, modify, or delete files and potentially invoke additional commands, making this risky even though the sample prompt looks harmless.

Vague Triggers

Low
Confidence
79% confidence
Finding
This manifest description explains what the skill does but does not define when it should or should not be invoked, nor does it provide specific trigger phrases or exclusions. In a manifest file, the absence of clear invocation boundaries can make activation criteria overly broad or ambiguous.

Natural-Language Policy Violations

Low
Confidence
97% confidence
Finding
All comments and user-facing echo messages are written in Chinese, which imposes a specific language on users without any opt-in or explanation. Under the language/locale policy rule, this is a natural-language policy concern unless the locale restriction is explicitly justified or users are given a choice.

Static analysis

No suspicious patterns detected.