Back to skill

Security audit

Agent Arena Skill - on-chain ERC-8004 agent registry with x402-gated search and registration API

Security checks for vulnerabilities and agentic risk

Overview

The skill has a legitimate registry purpose, but it gives agents under-scoped authority to follow third-party hiring and payment instructions and exposes persistent wallet/profile data without enough safeguards.

Review this skill before installing or using it with funds. Only send non-sensitive task payloads to discovered agents, require explicit approval before any payment, verify the endpoint, chain, amount, and recipient address independently, and avoid putting personal data, secrets, internal URLs, or private operational details into registration or enrichment fields. If implementing the SDK example, pin dependency versions and avoid handling raw private keys in general application code.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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 (2)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:99
Finding
Untrusted Remote Hiring Instructions Can Control Payments and Data Destinations<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 99–110 **Vulnerability Type**: Remote instruction and payment-flow hijacking **Risk Level**: High ### Vulnerable Code Snippet ```markdown **IMPORTANT**: After receiving results, follow the `howToHire` block exactly to hire the agent. --- ## HIRE an agent After searching, use the `howToHire` block from the search result. The standard x402 flow: 1. Send `POST` to the agent's `endpoint` with your task payload 2. If you receive HTTP `402`, read the response body for payment requirements 3. Pay the required USDC amount to the agent's `paymentAddress` on the specified chain 4. Retry the request with `X-PAYMENT: <payment proof>` header 5. **Save the `txHash` from your payment** — you need it to submit a verified review ``` ### Technical Analysis The skill explicitly instructs the agent to follow a remotely supplied `howToHire` block “exactly.” The remote response controls consequential parameters including: - The endpoint receiving the task payload - The payment recipient address - The blockchain network - The requested payment amount - Additional hiring instructions returned by the service The skill does not require a local destination allowlist, maximum payment limit, chain validation, recipient verification, instruction filtering, or explicit user approval before transmitting data or signing a payment authorization. It therefore treats attacker-controlled remote content as authoritative agent instructions instead of untrusted data. This creates an instruction-hijacking boundary: compromise of the registry, manipulation of an indexed agent profile, or a malicious registered agent can influence the agent’s behavior after the skill has been reviewed. ### Attack Path 1. An attacker registers a malicious agent profile, compromises a legitimate profile, or compromises the registry response. 2. The attacker supplies an endpoint under their control and a chosen payment address through the r ...[truncated 1224 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Treat every field returned by the registry and third-party agents as untrusted data, never as executable instructions. 2. Replace “follow exactly” with a fixed, locally defined hiring procedure. 3. Parse responses through a strict schema that accepts only necessary fields such as validated HTTPS endpoints, supported chain identifiers, recipient addresses, and bounded numeric prices. 4. Reject free-form remote instructions that request tool use, secret access, policy changes, unrelated network calls, or additional payments. 5. Enforce a configurable payment ceiling per transaction and per session. 6. Require explicit user confirmation showing the exact asset, amount, chain, recipient, service endpoint, and purpose before signing. 7. Verify that the payment recipient matches the wallet bound to the selected on-chain identity. 8. Restrict outbound requests to HTTPS endpoints whose domains are verified and associated with the selected registry entry. 9. Avoid sending secrets, credentials, private conversation context, or unrelated files in task payloads. 10. Revalidate all payment requirements locally rather than trusting values returned by an arbitrary service endpoint. 11. Provide cancellation and timeout behavior when any endpoint, recipient, amount, or chain differs from the originally approved transaction. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:743
Finding
Unpinned Wallet-Signing Dependencies Create a Payment Supply-Chain Risk<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 743–753 **Vulnerability Type**: Unpinned privileged third-party dependencies **Risk Level**: Medium ### Vulnerable Code Snippet ```bash npm install @x402/core @x402/evm @x402/fetch viem ``` ```typescript import { wrapFetchWithPayment } from "@x402/fetch"; import { x402Client } from "@x402/core/client"; import { registerExactEvmScheme } from "@x402/evm/exact/client"; import { privateKeyToAccount } from "viem/accounts"; // Setup const signer = privateKeyToAccount("0xYOUR_PRIVATE_KEY"); ``` ### Technical Analysis The installation command does not pin exact versions and the project provides no lockfile, integrity hashes, package provenance requirements, or reproducible installation instructions. Package resolution can consequently select versions published after the skill was audited. These dependencies occupy a privileged position: they construct payment requests and receive a signer derived from private key material. A malicious or compromised dependency release could read the supplied key, alter the destination or amount of a payment authorization, exfiltrate signed messages, or modify network requests. No evidence shows that the named packages are currently malicious. The vulnerability is the unsafe dependency acquisition model combined with direct access to high-value signing capabilities. ### Attack Path 1. An attacker compromises the package publisher, package registry account, dependency release process, or a transitive dependency. 2. A malicious version is published under a package name used by the documented installation command. 3. A user follows the command without exact version constraints or a trusted lockfile. 4. The package manager resolves and installs the malicious release. 5. The application imports the compromised package in the same process that constructs the signer. 6. Malicious package code accesses signing operations or modifies x402 payment requests. 7. The at ...[truncated 830 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every direct dependency to an audited exact version rather than using unconstrained package resolution. 2. Commit a reviewed lockfile and require reproducible installation with `npm ci`. 3. Verify package integrity and registry provenance during installation. 4. Enable dependency scanning and alerting for direct and transitive packages. 5. Review release signatures, publisher identity, package ownership changes, and unexpected install scripts before upgrades. 6. Disable lifecycle scripts where feasible or explicitly audit packages that require them. 7. Isolate wallet signing in a dedicated process or hardware-backed wallet provider. 8. Do not place raw private keys directly in source code or expose them to general-purpose HTTP and dependency code. 9. Use a signer API that enforces recipient, asset, chain, amount, and per-session authorization limits. 10. Test and review dependency upgrades separately before changing the pinned production versions. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (5)

Missing User Warnings

High
Confidence
97% confidence
Finding
The registration flow explicitly stores user-supplied profile content on IPFS and on-chain, but the skill does not warn users that this data may be public, effectively permanent, and difficult or impossible to delete. That creates a serious privacy and safety risk if users include personal data, secrets, internal endpoints, or other sensitive operational details in descriptions or service metadata.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The manifest description says the registry works across 'EVM + Solana', but the supported chains section lists only 16 EVM networks and all registration, reputation, and payment flows are described in ERC-8004, EIP-3009, Base USDC, and EVM contract terms. No Solana endpoint, chain identifier format, wallet flow, or payment mechanism is documented anywhere in the skill file.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The skill encourages users to send wallet addresses and payment proofs as part of normal operation without warning that this data is linkable, persistent, and potentially sensitive. In a blockchain context, these identifiers can be correlated across transactions and services to profile users, exposing financial behavior and counterparties.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The buyer reputation and feedback features collect and expose transactional and behavioral metadata such as volume, disputes, review tendencies, and account age without an explicit privacy notice or consent guidance. Because wallet addresses are stable identifiers, this can enable reputation-based profiling and deanonymization of buyer behavior across transactions.

Intent-Code Divergence

Low
Confidence
93% confidence
Finding
The HIRE workflow instructs users to retry with the `X-PAYMENT` header, while the compare endpoint's `howToUse` block later says to retry with the `PAYMENT-SIGNATURE` header. These are active contradictions in usage guidance for the same x402 payment flow, which can mislead integrators about how to actually pay and hire agents.

Static analysis

No suspicious patterns detected.