Back to skill

Security audit

Project Bootstrap

Security checks for vulnerabilities and agentic risk

Overview

The skill is a mostly coherent project bootstrap workflow, but it asks agents to create repositories, change GitHub settings, post to Discord, and grant broad subagent tools without enough approval or scoping guidance.

Install only if you are comfortable with the agent making GitHub and Discord changes after your explicit review. Before using it, change generated agents to least-privilege tool allowlists, require confirmation before repo/ruleset/webhook/CI changes, use private Discord channels, minimize posted task and commit details, pin third-party GitHub Actions to reviewed commit SHAs, and require at least one human approval on protected branches.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
Findings (3)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:54
Finding
Generated agents receive an overprivileged full tool profile<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 54-64 **Vulnerability Type**: Excessive agent permissions and failure to enforce least privilege **Risk Level**: High ### Vulnerable Code ```json { "id": "agent-id", "name": "agent-id", "agentDir": "/path/to/workspace/agents/agent-id", "model": "model-alias", "tools": { "profile": "full", "deny": ["gateway"] } } ``` The accompanying instructions state that `gateway` should be denied for all agents except the main agent and that `message` should only be denied for pure code agents. They do not establish narrow, role-specific allowlists. ### Technical Analysis The Skill recommends assigning the `full` tool profile to every generated agent and then removing only selected capabilities. This denylist-based model grants specialized agents all capabilities included in the full profile unless each dangerous capability is explicitly identified and denied. A specialized development, research, or design agent generally does not require unrestricted access to shell execution, arbitrary filesystem locations, network services, secrets, messaging, or runtime configuration. Granting these capabilities exceeds the minimum privileges required for the declared multi-agent project-bootstrap workflow. This weakness becomes exploitable when an agent processes attacker-controlled task descriptions, repository content, issue comments, documentation, or other prompt-injection-bearing data. The injected instructions may induce the agent to invoke tools that are unrelated to its legitimate workstream. ### Attack Path 1. An attacker places malicious instructions in content consumed by a generated agent, such as a task description, GitHub issue, source file, or project document. 2. The specialized agent loads and interprets the attacker-controlled content. 3. Because the agent was assigned the `full` tool profile, it has capabilities beyond those necessary for its role. 4. The injected instr ...[truncated 1042 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Replace the `full` profile with explicit role-specific tool allowlists. 1. Start every generated agent with no tools enabled. 2. Add only the capabilities required by that agent's documented responsibilities. 3. Deny shell execution, arbitrary filesystem access, external networking, messaging, secret access, and configuration modification by default. 4. Restrict filesystem access to the agent's workspace and required project directories. 5. Permit outbound network access only to explicitly approved hosts and APIs. 6. Keep `gateway` unavailable to all non-administrative agents. 7. Give messaging capabilities only to agents with a documented communication requirement and restrict approved destinations. 8. Separate credentials by role and issue short-lived, narrowly scoped tokens. 9. Require human approval for privileged operations such as deployment, secret access, repository administration, or agent-configuration changes. 10. Document the required tool set for each role and test that denied tools cannot be invoked. ]]>

T08 · Insecure Dependencies

Error
Location
references/ci-cd-templates.md:83
Finding
CI templates reference third-party GitHub Actions through mutable version tags<![CDATA[ ## Vulnerability Details **File Location**: `references/ci-cd-templates.md`, lines 24 and 83 **Vulnerability Type**: Mutable third-party CI dependencies **Risk Level**: High ### Vulnerable Code The coverage workflow uses a mutable major-version reference: ```yaml - name: Upload coverage if: matrix.python-version == '3.12' uses: codecov/codecov-action@v4 ``` The notification workflow also uses a mutable major-version reference and provides the action with a secret Discord webhook: ```yaml notify: needs: [test] if: always() runs-on: ubuntu-latest steps: - name: Discord Notification uses: sarisia/actions-status-discord@v1 with: webhook: ${{ secrets.DISCORD_WEBHOOK }} status: ${{ needs.test.result }} title: "${{ github.repository }} CI" description: | Commit: ${{ github.event.head_commit.message }} Author: ${{ github.event.head_commit.author.name }} color: ${{ needs.test.result == 'success' && '0x00ff00' || '0xff0000' }} ``` ### Technical Analysis GitHub Action references such as `@v1` and `@v4` are mutable tags. Their maintainers, or an attacker who compromises the upstream repository, may move a tag to a different commit after the workflow has been reviewed. Actions execute code on the CI runner. The Discord notification action is additionally supplied with `secrets.DISCORD_WEBHOOK`, while other workflow credentials and repository access may be available depending on GitHub Actions permission settings. Pinning only to a major tag does not ensure that future runs execute the code that was originally audited. This is a supply-chain exposure rather than evidence that either named action is currently malicious. ### Attack Path 1. An upstream action maintainer account or repository is compromised, or a mutable release tag is maliciously reassigned. 2. The `v1` or `v4` tag begins resolving to attacker-controlled cod ...[truncated 1206 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every third-party Action to a reviewed, immutable full commit SHA, for example: ```yaml uses: sarisia/actions-status-discord@<reviewed-full-commit-sha> ``` 2. Add a comment recording the corresponding release version so maintainers can understand and update the pin. 3. Review upstream release notes and source changes before updating any pinned SHA. 4. Configure explicit top-level or job-level GitHub Actions permissions, starting with: ```yaml permissions: contents: read ``` 5. Set unused permissions to `none` and avoid granting write access to notification or coverage jobs. 6. Place secret-consuming steps in isolated jobs with no unnecessary repository permissions. 7. Do not expose repository secrets to workflows triggered by untrusted fork pull requests. 8. Use dependency-update automation that proposes SHA updates through reviewed pull requests. 9. Consider replacing the Discord action with a minimal, internally reviewed notification step or trusted internal action. 10. Rotate the Discord webhook immediately if action compromise or unexpected use is suspected. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
references/ci-cd-templates.md:135
Finding
Recommended branch protection permits merges without independent approval<![CDATA[ ## Vulnerability Details **File Location**: `references/ci-cd-templates.md`, lines 135-139 **Vulnerability Type**: Insufficient repository branch-protection controls **Risk Level**: Medium ### Vulnerable Code ```json { "type": "pull_request", "parameters": { "required_approving_review_count": 0, "dismiss_stale_reviews_on_push": true, "require_last_push_approval": false } } ``` ### Technical Analysis The proposed ruleset is described as protection for the main branch, but it explicitly requires zero approving reviews. It also does not require approval of the latest pushed revision. Required status checks provide useful automated validation, but they are not equivalent to independent review. Tests may have incomplete coverage, and changes to configuration, workflows, dependencies, generated files, or security-sensitive logic may pass available checks while remaining unsafe. The configuration therefore weakens the human authorization boundary for changes entering the protected branch. This is particularly risky in the declared multi-agent workflow because autonomous agents may generate and push changes without independent scrutiny. ### Attack Path 1. An attacker compromises a contributor or agent account, or causes an authorized agent to generate a malicious or unsafe change. 2. The account opens a pull request targeting `main`. 3. The change passes the configured status checks, bypasses gaps in test coverage, or modifies an area not meaningfully validated by those checks. 4. No approving review is required because `required_approving_review_count` is set to `0`. 5. The pull request is merged into `main`. 6. Subsequent CI, deployment, or user installation executes or distributes the unsafe change. Additionally, even if optional review practices are followed, `require_last_push_approval: false` allows new commits to be added after review without requiring approval of the final revision. ### Impact Assessment A contributor or comp ...[truncated 689 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Harden the recommended branch ruleset as follows: 1. Set `required_approving_review_count` to at least `1`; use `2` for security-sensitive or production repositories. 2. Set `require_last_push_approval` to `true`. 3. Require Code Owner approval for security-sensitive paths such as: - `.github/workflows/` - deployment configuration - dependency manifests and lock files - authentication and authorization code - infrastructure definitions 4. Restrict who may bypass branch protection and audit every bypass. 5. Prevent force pushes and branch deletion. 6. Require signed commits where operationally appropriate. 7. Require security scanning, dependency review, tests, linting, and policy checks before merge. 8. Ensure workflow and ruleset changes receive review from a maintainer other than the author. 9. Prevent autonomous agents from self-approving or merging their own changes. 10. Regularly audit repository rulesets to verify that organization-level exceptions have not weakened enforcement. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (6)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The description claims a broad project bootstrap skill covering new-project setup, agent-team design, GitHub repo setup, CI/CD pipeline creation, and Discord notifications. The supplied code does not perform those functions. Instead, it is a taskboard management CLI with pluggable backends: local JSON storage and GitHub Issues synchronization. Its GitHub use is limited to issue creation/updates/comments for tasks, not repository setup or pipeline provisioning. There is no code for creating repos, initializing source code structure, configuring CI/CD/TDD workflows, or sending Discord notifications. While task management is one component mentioned in the description, the overall declared purpose materially overstates and mischaracterizes the code’s actual primary behavior.

Lp3

Medium
Category
MCP Least Privilege
Confidence
90% confidence
Finding
The skill instructs actions that can affect files, environment-backed credentials, networked services, and external systems, but it does not declare an explicit tool scope or permission boundary. In a project-bootstrap context, that omission is risky because the workflow includes repo creation, ruleset changes, webhook setup, and file generation, increasing the chance of overbroad execution without clear user-visible constraints.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill provides concrete instructions for creating repositories, applying branch protection, and configuring webhooks, but does not prominently warn that these actions modify external services and project state. In this context, that can lead to unintended repo creation, policy changes, or secret-bearing webhook setup by an agent acting without an explicit user approval checkpoint.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The Discord notification template transmits commit messages and author names to an external Discord webhook, which can leak internal development metadata to a third party. In a project-bootstrap skill, this is more dangerous because users may copy the template directly into new repositories without realizing that commit content and contributor identity are being exfiltrated outside GitHub.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The document instructs agents to send taskboard summaries and notifications to Discord, which is an external communication channel, without any guidance on data minimization, channel access control, or avoiding sensitive project details. In a multi-agent project bootstrap skill, task titles, notes, blockers, PR references, and architecture status can easily contain confidential roadmap, security, or operational information, so normalizing automatic posting increases the risk of unintended data exposure.

External Transmission

Medium
Category
Data Exfiltration
Content
print(f"⚠️  {config.get('token_env', 'GITHUB_TOKEN')} not set, GitHub sync disabled")

    def _api(self, method: str, endpoint: str, data: dict = None) -> dict | list:
        url = f"https://api.github.com/repos/{self.repo}/{endpoint}"
        body = json.dumps(data).encode() if data else None
        req = Request(url, data=body, method=method)
        req.add_header("Authorization", f"token {self.token}")
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Static analysis

No suspicious patterns detected.