Back to skill

Security audit

project-explorer-skill

Security checks for vulnerabilities and agentic risk

Overview

The skill is a project-exploration helper, but it tells agents to install and run arbitrary GitHub projects without clear approval, sandboxing, or safety limits.

Install only if you are comfortable with an agent potentially cloning, installing, and running untrusted project code. Use it in a disposable sandbox or container, keep secrets and private files out of reach, and require explicit approval before dependency installs, tests, examples, or app startup commands.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Findings (1)

T03 · Remote Payload Retrieval and Execution

Error
Location
skill.md:29
Finding

Unrestricted Retrieval and Execution of User-Supplied Remote Projects

Content
View full analysis

Vulnerability Details

File Location: skill.md, lines 29–38
Vulnerability Type: Remote payload retrieval and unsafe dependency execution
Risk Level: High

Vulnerable Code Snippet:

markdown
1. **Fetch the Repository** (if applicable)
   - Clone or download the project
   - Read the README, documentation, and key configuration files
   - Identify the tech stack, dependencies, and architecture

2. **Get It Running** 🏃
   - Install all necessary dependencies
   - Follow setup instructions (or figure them out if missing)
   - Run the project successfully
   - Test core functionality to verify it works

Technical Analysis

The Skill instructs the Agent to clone or download an arbitrary project, install its dependencies, run it, and test its functionality. These operations are performed without requiring prior source review, dependency verification, command approval, isolation, or permission restrictions.

This behavior exceeds the minimum privilege necessary for architecture analysis and documentation. Static inspection can support much of the declared project-exploration functionality without executing untrusted repository code. When execution is necessary, it should occur only after explicit authorization and inside a constrained environment.

A remote repository is a mutable payload source: its contents can change after the Skill itself has been audited. Installing dependencies may execute package lifecycle hooks, build scripts, setup modules, or native compilation steps. Running the application, examples, or tests directly executes repository-controlled code. Consequently, a malicious repository or compromised dependency can obtain code execution with the permissions and environmental access available to the Agent.

Although the pre-scan reported a possible sensitive-information network pattern, the audited file does not explicitly direct the Agent to collect or transmit credentials, environm ...[truncated 2244 chars]

Remediation
View remediation

Remediation Suggestions

  1. Make static analysis the default

    • Clone repositories without executing their contents.
    • Inspect manifests, lockfiles, setup scripts, build definitions, test configuration, and executable entry points before installation.
    • Generate architecture documentation from source inspection unless execution is explicitly necessary.
  2. Require informed user approval

    • Display every proposed installation and execution command before running it.
    • Explain that repository code and dependency hooks may execute arbitrary commands.
    • Obtain explicit approval separately for dependency installation, builds, tests, examples, and application startup.
  3. Use an ephemeral sandbox

    • Execute untrusted projects in a disposable container or virtual machine.
    • Run as an unprivileged user with no administrative or host-level capabilities.
    • Do not mount the user's home directory, SSH directory, cloud configuration, package-manager credentials, or unrelated workspaces.
    • Use a fresh temporary workspace that can be destroyed after analysis.
  4. Remove secrets and constrain access

    • Clear inherited environment variables and provide only variables strictly required for the test.
    • Do not expose API tokens, SSH agents, cloud metadata endpoints, credential stores, or host sockets.
    • Deny outbound network access by default and allowlist only destinations demonstrably required for setup or testing.
    • Prevent access to internal networks and local services unless explicitly approved.
  5. Harden dependency installation

    • Prefer committed lockfiles and pinned dependency versions.
    • Review package sources and reject unexpected registries, Git-based dependencies, local path escapes, and unpinned remote references.
    • Verify checksums or signatures where the ecosystem supports them.
    • Disable lifecycle and post-install scripts by default, enabling individual ...[truncated 888 chars]
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (2)

Missing User Warnings

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The skill explicitly directs the agent to clone, install dependencies for, and run unfamiliar GitHub projects, but provides no safety constraints, sandboxing requirements, trust checks, or warnings about executing untrusted code. This is dangerous because dependency installation and project startup scripts can execute attacker-controlled code, leading to host compromise, credential theft, data exfiltration, or persistence on the user's machine.

Content

No source excerpt is available for this finding.

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The trigger list is broad enough to match common, non-security-specific user requests such as 'analyze this project' or 'understand this project', which can cause the skill to activate unexpectedly. In this skill's context, unexpected activation is more dangerous because the workflow includes cloning, installing dependencies, and running unfamiliar code, potentially initiating risky actions without sufficiently explicit user intent.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.