Back to skill

Security audit

Auto Prodcution

Security checks for vulnerabilities and agentic risk

Overview

This skill has a coherent project-improvement purpose, but it tells the agent to modify code and automatically commit broad repository changes without explicit user approval.

Review this skill carefully before installing. It is not shown to exfiltrate data or install malware, but it can autonomously edit a project, run broad checks, and commit all visible Git changes. Use only in a clean branch or disposable copy, inspect `git status` first, and do not allow automatic commits or load tests against real services without explicit confirmation.

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 (1)

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:72
Finding
Unscoped Git Staging and Autonomous Repository Commits## Vulnerability Details **File Location**: `SKILL.md`, lines 67–83 and line 130 **Vulnerability Type**: Unsafe repository modification and unscoped Git staging **Risk Level**: Medium ### Vulnerable Code Lines 72 and 83 require staging every change in the repository before committing: ```bash git add -A && git commit -m "vibe: [dimension] fix [subproblem] — summary" ``` ```bash git add -A && git commit -m "vibe: [dimension] improve from X to Y — summary" ``` Line 130 additionally instructs the agent to execute the workflow directly without asking whether it should continue, except when it encounters an ambiguity that it cannot resolve. ### Technical Analysis The `git add -A` command stages all non-ignored changes visible to Git across the working tree. Its scope is not restricted to files modified by the Skill. Consequently, unrelated tracked-file modifications, deletions, and non-ignored untracked files already present in the repository can be included in the mandatory commits. The workflow does not require inspection of `git status`, review of the staged diff, secret scanning of staged content, or user approval before committing. The instruction to continue autonomously compounds this issue because the user may not receive an opportunity to detect or exclude unrelated content before it becomes part of Git history. This is an insecure coding practice rather than a privilege-escalation flaw. The Skill operates with the agent's existing repository and Git permissions; it does not obtain additional system privileges. ### Attack Path 1. A repository contains an unrelated modified file or a non-ignored untracked file. This could include local configuration, credentials, API tokens, private notes, or unfinished user work. 2. The user invokes the Skill to assess and improve the project. 3. The Skill modifies files while following its scorecard workflow. 4. The mandated `git add -A` command stages bot ...[truncated 1124 chars]
Remediation
## Remediation Suggestions 1. Replace `git add -A` with explicit staging of only the files intentionally modified by the current remediation task: ```bash git add -- path/to/modified-file path/to/test-file ``` 2. Capture the initial repository state with `git status --short` before making changes. Treat all pre-existing modifications and untracked files as out of scope. 3. Before each commit, require these checks: ```bash git status --short git diff --cached --stat git diff --cached ``` 4. Unstage any file not explicitly associated with the current subproblem: ```bash git restore --staged -- path/to/unrelated-file ``` 5. Run secret detection against the staged diff before committing, and block commits containing credentials, private keys, tokens, or sensitive configuration. 6. Do not automatically commit when the working tree was already dirty. Either preserve and exclude pre-existing changes reliably or request user confirmation. 7. Revise the autonomous-execution instruction so that repository commits require explicit approval, especially when staged files include content not created or modified by the Skill. 8. Document every file included in a commit and verify that the commit contains changes for only one intended subproblem.
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (5)

Missing User Warnings

High
Confidence
98% confidence
Finding
This section requires automatic git commits after each subproblem and again after scorecard updates, without warning the user that repository history will be altered. Automatic history mutation is more dangerous than ordinary file writes because it creates durable state changes, can trigger hooks or CI, and may be hard to cleanly undo in shared or protected repositories.

Natural-Language Policy Violations

Medium
Confidence
84% confidence
Finding
The skill description is written to operate in Chinese and does not indicate that the user may choose another language. This can violate language/locale policy when a skill implicitly enforces a specific language without opt-in.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill instructs the agent to create `VIBE_SCORECARD.md` if absent and to continue iteratively modifying project files as part of its workflow, but it does not warn the user that running the skill will perform automatic writes. In autonomous agent environments, silent file creation and repeated modification can overwrite intent, pollute repositories, or alter sensitive projects unexpectedly.

Context-Inappropriate Capability

Medium
Confidence
96% confidence
Finding
The skill explicitly instructs the agent to run `git add -A && git commit ...` automatically after each sub-fix, which changes repository history without a separate user confirmation step. In an agent context, automatic commits can persist incorrect or unsafe modifications, create noisy history, and make rollback or review harder, especially when the skill is designed to iterate autonomously.

Context-Inappropriate Capability

Medium
Confidence
87% confidence
Finding
The skill directs the agent to execute a wide set of scanning, testing, and performance commands (`semgrep`, `trivy`, `npm audit`, `k6`, `artillery`, etc.) against whatever project it is run in. These commands can be expensive, environment-dependent, invoke external tooling, leak metadata through networked package/security services, or cause unintended load and side effects when launched automatically without scope limits or approval.

Static analysis

No suspicious patterns detected.