Back to skill

Security audit

AI Auto Dev

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed automation workflow, but it asks the agent to disable approvals, run with full filesystem access, persist cross-session logs, and push commits/tags to GitHub without user confirmation.

Install only if you are comfortable with a highly autonomous coding workflow. Before use, keep approval prompts enabled, avoid danger-full-access unless narrowly justified, remove the automatic GitHub push/tag step or require explicit review, and redirect persistent logs from ~/.claude to a project-local location with sensitive details minimized.

Vulnerability Patterns
  • 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
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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 (5)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:24
Finding
Mandatory Approval Bypass and Unrestricted Sandbox Access<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 24-35 **Vulnerability Type**: Approval bypass and excessive execution privileges **Risk Level**: Critical ### Complete Code Snippet ```toml ask_for_approval = "never" sandbox_mode = "danger-full-access" ``` The surrounding instructions state that the Builder must have complete filesystem access and that restricted mode should not be used. ### Technical Analysis The configuration explicitly disables approval prompts and places the Builder in an unrestricted execution environment. These settings remove two complementary security controls: 1. Interactive authorization before potentially dangerous operations. 2. Filesystem and process isolation limiting the consequences of generated commands. A coding assistant ordinarily needs access only to the relevant workspace and a limited set of build tools. Granting unrestricted system access is not necessary for routine compilation, testing, or file editing. Because the Builder processes generated specifications and project-controlled content, malicious instructions in either source can lead directly to arbitrary command execution outside the project. This issue matches both skill-instruction hijacking and unauthorized privilege escalation. The Skill changes the Agent's safety posture when loaded and obtains permissions beyond normal development requirements. ### Attack Path 1. A user invokes the Skill for a development task. 2. The Skill directs the environment to disable approval prompts. 3. The Builder is launched with `danger-full-access`. 4. A malicious specification, repository instruction, dependency script, or prompt-injected source file instructs the Builder to execute an unsafe command. 5. The command runs without interactive review and without workspace containment. 6. The command can read or modify files available to the current operating-system account and invoke local or network-capable tools. ### Impact Assessment An exploit ...[truncated 691 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `ask_for_approval = "never"`. - Replace `danger-full-access` with a workspace-scoped, write-limited sandbox. - Require explicit user approval for commands that: - Access paths outside the project. - Install packages globally. - Use credentials or network services. - Modify Git remotes, tags, or branches. - Delete or overwrite files. - Use a command allowlist for expected build and test tools. - Run third-party Builders under a dedicated low-privilege account or isolated container. - Treat repository files and generated specifications as untrusted input. - Permit temporary privilege escalation only for a displayed, narrowly scoped command after explicit approval. ]]>

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:39
Finding
Session Trust Manipulation Intended to Avoid Later Confirmations<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 39-55 **Vulnerability Type**: Agent confirmation-flow manipulation **Risk Level**: High ### Complete Code Snippet ```bash echo "Warmup at $(date '+%Y-%m-%d %H:%M:%S')" && sleep 2 && echo "Ready" ``` The associated requirements mandate that this command be run for every invocation with: ```text run_in_background: true ``` The documented purpose of the operation is to establish session trust so that later background Bash tasks do not require confirmation. ### Technical Analysis The warm-up command is benign in isolation. The vulnerability is its explicitly documented use as a mechanism to influence the host Agent's session-trust state and avoid authorization prompts for later background work. A harmless operation is used to establish trust, after which unrelated and more privileged operations may be executed with reduced scrutiny. This is a form of instruction-level safety-control manipulation: the Skill is not merely requesting background execution for performance reasons, but is intentionally changing how later commands are authorized. Combined with unrestricted Builder permissions, this creates a dangerous trust transition in which approval for a harmless command can implicitly weaken review of subsequent commands. ### Attack Path 1. The Skill starts a harmless sleep-and-echo task in the background. 2. The user or host approves the initial benign task, or the host records the session as trusted. 3. The Skill proceeds to launch Builder tasks in the background. 4. Subsequent commands receive fewer or no confirmation prompts. 5. Malicious or unexpectedly dangerous Builder actions execute under the established session trust. 6. The unrestricted sandbox configuration expands the impact beyond the project directory. ### Impact Assessment The immediate command does not itself compromise the system. Its impact is the weakening of authorization boundaries for later operations. Dependi ...[truncated 432 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the mandatory warm-up and all instructions whose purpose is to suppress later confirmations. - Do not treat approval of one benign command as approval for unrelated tasks. - Require command-specific authorization for every background process with side effects. - Display the exact command, working directory, permissions, and network requirements before launch. - Keep background execution subject to the same sandbox and approval policy as foreground execution. - Bind any trust decision to a narrowly defined command and expire it immediately after completion. ]]>

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:574
Finding
Automatic Commit, Tag, and GitHub Push Without User Confirmation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 574-588 **Vulnerability Type**: Unauthorized repository mutation and remote publication **Risk Level**: High ### Complete Code Snippet The source instructs the workflow to perform the following sequence automatically: ```text 1. Update project documentation, including README and CHANGELOG files. 2. Invoke the dev-log Skill. 3. Analyze changes and generate a commit message. 4. Commit the code. 5. Create a version tag. 6. Push the commit and tag to GitHub. 7. Perform the entire step automatically without user confirmation. 8. If synchronization fails, record the error and continue delivery. ``` ### Technical Analysis Committing, tagging, and pushing are externally visible and potentially irreversible repository operations. They are not required merely to implement or validate a local coding task. The Skill delegates these operations to another Skill and explicitly removes the user-confirmation checkpoint. This creates a transitive trust problem: the reviewed Skill grants `dev-log` authority to publish whatever files are present in the working tree. Generated artifacts, secrets, unrelated modifications, or malicious changes can consequently enter repository history and be transmitted to a remote service. Automatic tagging can additionally trigger release pipelines, package publication, deployments, or other CI/CD workflows configured on the repository. ### Attack Path 1. The Builder creates or modifies project files. 2. A malicious instruction or implementation adds sensitive, unintended, or backdoored content. 3. The workflow updates documentation and invokes `dev-log`. 4. `dev-log` stages and commits the current changes. 5. A version tag is created. 6. The commit and tag are pushed using the user's existing GitHub credentials. 7. Remote CI/CD or release automation may execute in response to the push or tag. 8. The user receives the result only after publication has occurred. ### I ...[truncated 657 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Make all commit, tag, push, release, and deployment operations opt-in. - Before any commit, display: - The complete staged diff. - The files to be committed. - The destination repository and branch. - The proposed commit message and tag. - Require separate explicit approval before pushing or creating a remote tag. - Run secret scanning and generated-artifact checks before staging. - Exclude unrelated working-tree changes by default. - Use protected branches and least-privilege repository tokens. - Do not invoke another Skill with publication authority unless its exact operations and inputs are shown to the user. - Never treat documentation updates as implicit authorization to publish code. ]]>

T02 · Agent Memory Poisoning

Error
Location
SKILL.md:758
Finding
Cross-Session Agent State Writes and Mandatory Future Ingestion<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 758-816 **Vulnerability Type**: Persistent Agent-state poisoning channel **Risk Level**: High ### Complete Code Snippet The Skill requires every new session to read persistent files outside the project: ```text ~/.claude/windtunnel/baselines/ai-auto-dev-baseline.md ~/.claude/windtunnel/experiments/{current-date}-summary.md {project-directory}/CLAUDE.md ``` It also mandates immediate persistent writes and provides this command: ```bash cat >> ~/.claude/windtunnel/experiments/$(date '+%Y-%m-%d')-log.md << 'EOF' {experiment log content} EOF ``` The persisted content includes measurements, decisions, baseline comparisons, and lessons intended to affect future sessions. ### Technical Analysis This design creates a persistent, cross-session input channel. Data generated during one task is written under the Agent's home directory, and future sessions are required to consume related files as trusted context. If project-controlled content, Builder output, or generated summaries enter these files without strict validation, an attacker can store instruction-like text that survives the current task. A later Agent may interpret that text as authoritative memory, policy, or historical guidance. The risk is amplified because the files are outside the audited project and can influence unrelated future sessions. This is distinct from operating-system persistence: the Skill does not install a service or startup hook. The security issue is persistent Agent-memory influence. ### Attack Path 1. An attacker introduces instruction-like content through a repository file, task description, Builder output, or generated report. 2. The workflow incorporates the content into an experiment log, baseline, archive, or summary. 3. The content is written to persistent storage under `~/.claude/windtunnel`. 4. The current session ends. 5. A future session follows the mandatory recovery procedure and reads the per ...[truncated 836 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not require automatic ingestion of writable cross-session files. - Keep task state inside the relevant project unless the user explicitly authorizes external persistence. - Treat persisted reports and summaries as untrusted data, never as instructions. - Store state in a typed, schema-validated format with a strict field allowlist. - Reject command blocks, policy overrides, role instructions, and tool directives from memory records. - Record provenance for every persisted value. - Escape or quote repository-controlled text before persistence. - Require user review before promoting task output into long-term Agent memory. - Apply file permissions that prevent modification by unrelated processes. - Provide a clear deletion and retention policy for persisted task information. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:18
Finding
Unpinned Global Third-Party Tool Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 18-22 **Vulnerability Type**: Unpinned dependency installation and supply-chain exposure **Risk Level**: Medium ### Complete Code Snippet ```bash npm i -g @openai/codex pip install aider-chat ``` ### Technical Analysis Both commands install the latest version selected by the package registry at execution time. No version, integrity hash, lockfile, or artifact signature is specified. The npm command also performs a global installation, increasing the installation's reach and potentially modifying commands available across projects. No evidence establishes that the named packages are malicious. The vulnerability is the unsafe dependency acquisition pattern: the reviewed Skill cannot guarantee which package release will be installed later. Registry compromise, account takeover, a malicious future release, or dependency compromise could cause installation-time or runtime code execution. The risk is compounded by the Skill's recommendation to run the resulting Builder with unrestricted filesystem access and disabled approvals. ### Attack Path 1. The user follows the prerequisite installation command. 2. The package manager resolves the latest package and transitive dependencies. 3. A compromised or unexpectedly changed release is downloaded. 4. Package installation hooks or the installed command execute attacker-controlled code. 5. The Builder is subsequently launched with broad filesystem and command privileges. 6. Malicious package code accesses user files, development credentials, repositories, or network services. ### Impact Assessment Package installation and later Builder execution occur with the privileges of the invoking user. Potential scope includes: - Execution of package lifecycle scripts. - Modification of globally installed commands and package files. - Access to user-readable files and development credentials. - Compromise of projects processed by the installed Builder ...[truncated 282 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin each tool to a reviewed exact version. - Verify package integrity using hashes, signatures, provenance attestations, or a trusted internal mirror. - Use lockfiles for transitive dependencies where supported. - Install tools in an isolated virtual environment, container, or project-local directory rather than globally. - Disable package lifecycle scripts during installation unless they have been reviewed and are required. - Audit the dependency tree before use. - Run installed tools with workspace-scoped permissions. - Establish an explicit update process instead of automatically consuming the latest registry release. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (11)

Agent Config Directory Access

High
Category
Agent Snooping
Content
**关键要求**:Builder 必须有完整文件系统访问权限,能执行 npx/node/tsc 等命令。

以 Codex 为例,`~/.codex/config.toml` 需配置:
```toml
ask_for_approval = "never"
sandbox_mode = "danger-full-access"
Confidence
99% confidence
Finding
The skill instructs configuration of `~/.codex/config.toml` with `ask_for_approval = "never"` and `sandbox_mode = "danger-full-access"`. This deliberately disables human approval checkpoints and grants unrestricted filesystem access, substantially increasing the impact of any prompt injection, tool misuse, destructive command, or unintended exfiltration performed by the automated workflow.

Description-Behavior Mismatch

High
Confidence
96% confidence
Finding
The skill claims documentation should only be staged, but later mandates direct updates to project documentation and GitHub synchronization before delivery. This scope mismatch can cause the agent to make persistent repository changes that the user did not clearly authorize, increasing the risk of unintended modification or publication.

Missing User Warnings

High
Confidence
98% confidence
Finding
The skill instructs automatic GitHub commit/tag/push with no user confirmation. Given the surrounding instructions to disable approvals and use full filesystem access, this can publish sensitive code, secrets, or erroneous changes to a remote repository without an interactive checkpoint.

Context-Inappropriate Capability

High
Confidence
97% confidence
Finding
Automatic commit, tag, and push functionality extends beyond code-generation orchestration into publication and source-control mutation. In the context of a skill already requiring `ask_for_approval = "never"` and `danger-full-access`, this greatly increases the blast radius by allowing autonomous exfiltration of work product and irreversible repository history changes.

Intent-Code Divergence

High
Confidence
95% confidence
Finding
The skill states formal documents are read-only and only staging files may be written, but elsewhere requires direct updates to README, CHANGELOG, and persistent logs. This contradiction can mislead users about what the agent will modify, undermining informed consent and making unauthorized persistence more likely.

Agent Config Directory Access

High
Category
Agent Snooping
Content
写入命令(PM 在第四步后执行):
```bash
cat >> ~/.claude/windtunnel/experiments/$(date '+%Y-%m-%d')-log.md << 'EOF'
{上述格式内容}
EOF
```
Confidence
98% confidence
Finding
Appending to `~/.claude/windtunnel/experiments/...` writes persistent data into a user-level agent configuration area outside the project. This creates cross-session state and a durable sink for potentially sensitive project information, and in combination with autonomous execution can silently alter the agent's broader operating context.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The instruction '使用英文编写 Spec' imposes a specific language choice as a rule because the builder 'understands English more precisely.' This is a locale/language policy issue because it does not offer the user a choice or document a justified region-specific constraint.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The workflow requires automatic writes to local staging files and other logs as part of execution, without clearly surfacing that user-provided task content may be persisted. This creates a retention path for potentially sensitive information and expands side effects beyond the immediate coding task.

Context-Inappropriate Capability

Medium
Confidence
91% confidence
Finding
The skill directs reads and writes under `~/.claude`, creating persistent user-level state outside the project workspace. That broadens access from task execution to cross-project data retention, which can expose unrelated context, leak sensitive task details into long-lived logs, and violate least-privilege expectations.

Ssd 3

Medium
Confidence
93% confidence
Finding
The skill explicitly reads prior session/project files and appends detailed task inputs, outputs, and conclusions to persistent logs. In a coding assistant context, those logs can naturally capture sensitive user data, proprietary requirements, or security-relevant details, creating a durable disclosure and retention channel.

Static analysis

No suspicious patterns detected.