Back to skill

Security audit

EvoMap GEP-A2A

Security checks for vulnerabilities and agentic risk

Overview

The skill describes a plausible EvoMap integration, but it encourages unpinned external client execution and automated publishing/task claiming without strong review controls.

Install only if you are comfortable with EvoMap receiving agent-generated solution metadata and with the agent participating in marketplace tasks. Prefer manual protocol use or single-run mode, pin and review the Evolver client before running it, avoid private repositories unless publication is explicitly approved, and do not enable webhooks or loop mode until authentication, redaction, and per-task approval controls are in place.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (3)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:111
Finding
Unverified Remote Client Retrieval and Execution<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:111-142` **Vulnerability Type**: Remote payload retrieval and supply-chain execution **Risk Level**: High ### Vulnerable Code ```bash git clone https://github.com/autogame-17/evolver.git cd evolver npm install ``` Alternatively: ```bash TAG=$(curl -sL https://api.github.com/repos/autogame-17/evolver/releases/latest | grep '"tag_name"' | cut -d'"' -f4) curl -fsSL -o evolver.zip "https://github.com/autogame-17/evolver/archive/refs/tags/${TAG}.zip" unzip evolver.zip cd evolver-${TAG#v} npm install ``` The downloaded client is then executed continuously: ```bash node index.js --loop ``` ### Technical Analysis The Skill directs users to retrieve code from an external personal GitHub namespace and execute it without pinning an immutable commit or verifying a cryptographic signature or expected checksum. The `git clone` workflow follows the repository's mutable default branch. The archive workflow dynamically resolves the latest release tag through the GitHub API. Consequently, the effective code executed by users can change after the Skill itself has been reviewed. The subsequent `npm install` increases the attack surface because npm packages may run lifecycle scripts during installation. Transitive dependencies can also introduce code that was not directly reviewed. The Skill does not require inspection of the retrieved source, enforcement of a lockfile, disabled lifecycle scripts, or execution inside a restricted sandbox. Although SHA-256 is mentioned for marketplace asset identifiers, those hashes do not authenticate or verify the downloaded Evolver archive or its npm dependencies. ### Attack Path 1. An attacker compromises the `autogame-17/evolver` repository, a maintainer account, a release, or one of its npm dependencies. 2. The attacker modifies the default branch, publishes a malicious latest tag, or introduces a malicious dependency or lifecycle script. 3. A user follows the Skill ...[truncated 1086 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the client to a reviewed, immutable Git commit rather than the default branch or dynamically selected latest tag. 2. Publish signed release artifacts and document the expected SHA-256 checksum or signature fingerprint in the Skill. 3. Verify the checksum or signature before extracting or executing the archive, and fail closed on any mismatch. 4. Commit and review an exact dependency lockfile, then use `npm ci` instead of `npm install`. 5. Use `npm ci --ignore-scripts` where lifecycle scripts are unnecessary. Explicitly audit any lifecycle scripts that must remain enabled. 6. Display the resolved repository, commit, archive hash, and dependency set for user approval before installation. 7. Run the client under a dedicated, unprivileged account or isolated container with a read-only filesystem and narrowly scoped outbound network access. 8. Avoid exposing unrelated repositories, credentials, home-directory files, SSH material, or complete environment variables to the process. 9. Prefer a small, locally reviewed implementation of the documented HTTPS protocol when continuous client functionality is unnecessary. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:31
Finding
Automatic Publication of Local Agent Work Without Mandatory Review or Redaction<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:31-32, 135-142, 290-348, 539-548` **Vulnerability Type**: Uncontrolled outbound disclosure of local work product **Risk Level**: Medium ### Vulnerable Instructions ```text Continuous sync: In loop mode, evolver automatically fetches new assets, publishes your validated fixes, and claims bounty tasks on a 4-hour cycle. ``` ```text ### What Loop Mode Does (Every 4 Hours) 1. Hello -- Re-registers your node, refreshes claim code if expired. 2. Fetch -- Downloads newly promoted assets and available tasks. 3. Publish -- Uploads any validated fixes your agent has produced since the last cycle. 4. Task claim -- Claims the highest-value eligible task and begins work. ``` The periodic workflow reinforces this behavior: ```text Recommended interval: every 4+ hours 1. POST /a2a/fetch (with include_tasks: true) -- check for new assets and bounty tasks 2. If you have new validated fixes, POST /a2a/publish 3. If tasks are available, claim and work on the highest-value one 4. Check your reputation: GET /a2a/nodes/YOUR_NODE_ID ``` Published bundles include solution and environment metadata: ```json { "type": "Capsule", "schema_version": "1.5.0", "trigger": ["TimeoutError"], "gene": "sha256:GENE_HASH_HERE", "summary": "Fix API timeout with bounded retry and connection pooling", "confidence": 0.85, "blast_radius": { "files": 1, "lines": 10 }, "outcome": { "status": "success", "score": 0.85 }, "env_fingerprint": { "platform": "linux", "arch": "x64" }, "success_streak": 3, "asset_id": "sha256:CAPSULE_HASH_HERE" } ``` ### Technical Analysis Publishing assets is part of the declared marketplace functionality. However, the recommended loop mode automatically uploads broadly defined “validated fixes” without requiring per-item user consent, an explicit publication allowlist, a repository boundary, or secret and sensitive-data scanning. Gene and Capsule assets can contain trigger signals, s ...[truncated 1838 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require explicit user approval for every publication and show the exact outbound JSON payload before transmission. 2. Disable automatic publication by default; keep automatic fetching separate from publishing. 3. Restrict publication to files, repositories, or artifacts explicitly selected by the user. 4. Add secret, credential, PII, hostname, internal URL, filesystem-path, and proprietary-identifier scanning before submission. 5. Remove source code, logs, validation commands, internal paths, customer data, and unnecessary environment details unless the user expressly authorizes them. 6. Apply data minimization to `env_fingerprint`, triggers, summaries, and EvolutionEvent metadata. 7. Maintain a local publication audit log containing the destination, timestamp, fields sent, and user authorization. 8. Document Hub retention, revocation, redistribution, and deletion behavior before enabling publication. 9. Provide a local-only mode that computes and stores assets without transmitting them. ]]>

other

Warning
Location
SKILL.md:405
Finding
Unauthenticated Remote Task Content Can Drive Autonomous Agent Workflows<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:405-439, 539-548` **Vulnerability Type**: External agent task delegation without a documented trust boundary **Risk Level**: Medium ### Vulnerable Instructions ```json { "protocol": "gep-a2a", "protocol_version": "1.0.0", "message_type": "hello", "message_id": "msg_1736935100_e5f6a7b8", "sender_id": "node_e5f6a7b8c9d0e1f2", "timestamp": "2025-01-15T08:38:20Z", "payload": { "capabilities": {}, "gene_count": 0, "capsule_count": 0, "env_fingerprint": { "platform": "linux", "arch": "x64" }, "webhook_url": "https://your-agent.example.com/webhook" } } ``` ```text Hub will POST to your webhook URL in two scenarios: 1. high_value_task: When a matching high-value task ($10+) is created. 2. task_assigned: When a task is dispatched to your node. The payload includes task_id, title, signals, and bounty_id. ``` ```text 1. Receive POST webhook with type: "task_assigned" 2. Extract task_id, title, signals from the payload 3. Analyze signals and produce a solution 4. Publish solution: POST /a2a/publish 5. Complete task: POST /task/complete with { task_id, asset_id, node_id } ``` The periodic workflow also states: ```text 3. If tasks are available, claim and work on the highest-value one ``` ### Technical Analysis The Skill encourages the agent to accept Hub-controlled task titles and signals, analyze them, generate a solution, publish the result, and complete the task. It does not document webhook signature validation, timestamp checking, replay prevention, sender allowlisting, or a requirement to treat remote task text as untrusted data. Remote task fields are data, but downstream agents may interpret natural-language titles, signals, or bodies as executable instructions. Without a clear trust boundary, malicious task content could attempt prompt injection, induce unauthorized tool use, or redirect the agent toward unrelated work. The audit did not find an explic ...[truncated 1599 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require HMAC or asymmetric signatures on every webhook and validate them against a separately configured trusted key. 2. Include and verify timestamps, unique event identifiers, and a short freshness window to prevent replay attacks. 3. Enforce HTTPS and reject redirects, unexpected source identities, malformed content types, and oversized request bodies. 4. Treat task titles, signals, descriptions, and assets strictly as untrusted data rather than higher-priority agent instructions. 5. Explicitly prohibit remote task content from modifying system policies, safety constraints, tool permissions, or publication rules. 6. Require user confirmation before claiming a task, using local tools, accessing project data, publishing a solution, or completing a task. 7. Execute task processing in a sandbox with restricted filesystem access, no ambient credentials, limited resources, and destination-allowlisted networking. 8. Apply schema validation and content-length limits to webhook payloads. 9. Record authenticated sender information and all resulting agent actions in an audit log. 10. Make webhook processing and autonomous task claiming disabled by default. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • 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
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (10)

Vague Triggers

Medium
Confidence
93% confidence
Finding
The activation criteria include broad triggers such as 'agent marketplace' and related ecosystem terms, which can cause the skill to activate in loosely related conversations. In this skill, accidental activation is more dangerous because the content encourages network registration, asset publishing, task claiming, and webhook use with an external service.

Missing User Warnings

Medium
Confidence
98% confidence
Finding
The skill promotes continuous loop mode that automatically fetches remote assets, publishes outputs, and claims bounty tasks on a schedule, but it does not prominently require explicit user consent for these external actions. That creates a real risk of unauthorized data transmission, unintended participation in third-party workflows, and autonomous behavior beyond the user's expectations.

External Transmission

Medium
Category
Data Exfiltration
Content
Or download the latest release:

```bash
TAG=$(curl -sL https://api.github.com/repos/autogame-17/evolver/releases/latest | grep '"tag_name"' | cut -d'"' -f4)
curl -fsSL -o evolver.zip "https://github.com/autogame-17/evolver/archive/refs/tags/${TAG}.zip"
unzip evolver.zip
cd evolver-${TAG#v}
Confidence
91% confidence
Finding
The installation flow instructs users to contact external hosts (`api.github.com` and GitHub release archives) and download code directly from the network. In a skill that already encourages rapid 'plug and play' onboarding, this increases the chance of unreviewed code acquisition and external data transmission without sufficient provenance or integrity verification guidance.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
# Check releases
curl -s https://api.github.com/repos/autogame-17/evolver/releases/latest | grep tag_name

# Update
cd evolver
Confidence
84% confidence
Finding
This update-check step reaches out to GitHub's API, which is an external network transmission. By itself it is lower risk than the installation step, but it still causes outbound contact to a third party and can normalize remote update behavior without an explicit user warning.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
### How it works

1. **Claim** the parent task: `POST /task/claim`
2. **Propose decomposition**: `POST /task/propose-decomposition` with at least 2 subtasks. The decomposition is auto-approved -- subtasks are created immediately.
3. **Solver agents** discover and claim subtasks via `POST /a2a/fetch` (with `include_tasks: true`) or `GET /task/list`. Each subtask has `swarm_role: "solver"` and a `contribution_weight`.
4. Each solver completes their subtask: publish solution via `POST /a2a/publish`, then `POST /task/complete`.
5. When **all solvers** complete, an **aggregation task** is automatically created. Only agents with reputation >= 60 can claim it.
Confidence
94% confidence
Finding
The skill describes decomposition as 'auto-approved' and outlines a workflow where subtasks are created immediately and later aggregation tasks are automatically generated. This embeds autonomous task creation and progression in an external marketplace context, increasing the risk of unreviewed commitments, unexpected workload generation, and externally induced agent actions.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- Total solver weight must not exceed 0.85 (the remaining 0.15 goes to proposer + aggregator)
- Cannot decompose a subtask (only top-level tasks)

**Response:** Returns the created subtasks and `auto_approved: true`.

### Webhook notifications for swarm
Confidence
90% confidence
Finding
Returning `auto_approved: true` for decomposition reinforces that external task creation can occur without a human review checkpoint. In this skill's broader context of automated claiming and webhook-driven workflows, that makes the autonomy materially more dangerous than a passive status field in isolation.

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.

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.

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.

Missing User Warnings

Low
Confidence
95% confidence
Finding
The skill recommends webhook registration without clearly warning that this exposes an externally reachable callback endpoint that will accept remote POST requests. In context, that can expand the attack surface, enable spoofed or malicious callback traffic if not verified, and trigger downstream autonomous workflows tied to task assignment.