Back to skill

Security audit

acn

Security checks for vulnerabilities and agentic risk

Overview

This appears to be a real ACN integration skill, but it needs careful review because it can store sensitive keys and keep a remotely triggered listener running after setup.

Install only if you are comfortable giving this skill ACN account authority and, for optional flows, wallet or owner-token authority. Use testnet first, avoid storing valuable wallet keys in the generated .env file, pin and review CLI/package versions, confirm the exact ACN host before sending credentials, and require explicit approval before enabling any reboot-persistent listener, cron heartbeat, or wake-exec command.

Vulnerability Patterns
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • 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 (4)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/register_onchain.py:121
Finding
Configurable ACN API Origin Can Receive Long-Lived Bearer Credentials<![CDATA[ ## Vulnerability Details **File Location**: `scripts/register_onchain.py:121-157, 162-166, 262-266`; related configuration instructions in `SKILL.md:53, 101-102` **Vulnerability Type**: Unvalidated credential destination **Risk Level**: High ### Complete Code Snippet ```python async def _get_agent_id(acn_url: str, api_key: str) -> str: """Look up the ACN agent ID via /api/v1/agents/me using the API key.""" import httpx async with httpx.AsyncClient() as client: resp = await client.get( f"{acn_url}/api/v1/agents/me", headers={"Authorization": f"Bearer {api_key}"}, timeout=15, ) resp.raise_for_status() data = resp.json() agent_id: str = data.get("agent_id") or data.get("id") or "" if not agent_id: raise RuntimeError(f"Could not determine agent_id from /me response: {data}") return agent_id async def _bind_to_acn( acn_url: str, api_key: str, agent_id: str, token_id: int, chain: str, tx_hash: str, ) -> None: """POST /api/v1/onchain/agents/{agent_id}/bind to register the binding in ACN.""" import httpx async with httpx.AsyncClient() as client: resp = await client.post( f"{acn_url}/api/v1/onchain/agents/{agent_id}/bind", json={"token_id": token_id, "chain": chain, "tx_hash": tx_hash}, headers={"Authorization": f"Bearer {api_key}"}, timeout=30, ) resp.raise_for_status() ``` ```python acn_url = args.acn_url.rstrip("/") api_key = args.acn_api_key ``` ```python parser.add_argument( "--acn-url", default=os.getenv("ACN_API_URL", "https://api.acnlabs.dev"), help="ACN server base URL", ) ``` The broader Skill also permits arbitrary configured origins: ```text Precedence: --base-url → --region → ACN_BASE_URL → ~/.acn/config.json → global. ``` ```text acn join --base-url <origin> ``` ### Technical Analysis The script obtains ...[truncated 2288 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Parse the configured URL with a strict URL parser before any authenticated request. 2. Require `https` for all non-loopback destinations. 3. Allowlist the documented production hosts by default: - `api.acnlabs.dev` - `acn.acnlabs.cn` 4. Treat custom/self-hosted origins as an advanced mode requiring explicit user confirmation before transmitting a credential. 5. Reject embedded usernames/passwords, fragments, malformed hosts, and unexpected ports. 6. Instantiate the HTTP client with redirects disabled and reject any response that attempts to move the request to another origin. 7. Store credentials per origin so a credential issued by one ACN deployment cannot automatically be sent to another. 8. Display the normalized destination hostname before the first credential-bearing request, without displaying the credential. 9. Add tests covering HTTP downgrade attempts, deceptive subdomains, user-information URLs, custom ports, and poisoned environment variables. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/register_onchain.py:100
Finding
Ethereum Private Key Can Be Appended to a Permissive File or Followed Symlink<![CDATA[ ## Vulnerability Details **File Location**: `scripts/register_onchain.py:100-118, 182-188` **Vulnerability Type**: Unsafe plaintext secret-file creation **Risk Level**: High ### Complete Code Snippet ```python def _save_wallet(path: str, private_key: str, address: str) -> None: """Append wallet credentials to a .env file (skips existing keys). The file is created with mode 0o600 (owner read/write only) to prevent other users on the system from reading the private key. """ keys_to_add = {"WALLET_PRIVATE_KEY": private_key, "WALLET_ADDRESS": address} existing: set[str] = set() if os.path.exists(path): with open(path) as f: for line in f: if "=" in line: existing.add(line.split("=")[0].strip()) # Open with O_CREAT | O_WRONLY | O_APPEND and mode 0o600 fd = os.open(path, os.O_CREAT | os.O_WRONLY | os.O_APPEND, 0o600) with os.fdopen(fd, "a") as f: for key, value in keys_to_add.items(): if key not in existing: f.write(f"{key}={value}\n") ``` The function is invoked with a relative path after generating a wallet: ```python private_key: str = args.private_key or os.getenv("WALLET_PRIVATE_KEY", "") if not private_key: account = Account.create() private_key = account.key.hex() wallet_address = account.address _save_wallet(".env", private_key, wallet_address) print("\nWallet generated and saved to .env") ``` ### Technical Analysis The script claims that the generated `.env` is protected with mode `0600`, but the mode argument to `os.open()` only controls permissions when a new file is created. If `.env` already exists with broader permissions, opening it with `O_CREAT` does not tighten those permissions. The implementation also: - Uses a predictable relative path in the current working directory. - Follows symbolic links because `O_NOFOLLOW` is not used. - Separately checks and reads the path before opening ...[truncated 1976 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Prefer an operating-system keychain, hardware wallet, or dedicated secrets manager instead of a plaintext `.env` file. 2. If a file is necessary, store it in a dedicated user-owned configuration directory rather than the current working directory. 3. Create a new file atomically with restrictive flags, including the platform equivalents of: - `O_CREAT` - `O_EXCL` - `O_WRONLY` - `O_NOFOLLOW` 4. Set a restrictive process umask before creation. 5. Verify with `fstat()` that the opened descriptor is a regular file owned by the current user. 6. Apply `fchmod(fd, 0o600)` after opening any permitted existing file instead of assuming the creation mode changed it. 7. Do not append to an existing `.env` unless its type, owner, and permissions have been validated. 8. Avoid the separate `exists`/read/open sequence; perform operations through a securely opened file descriptor. 9. Write to a securely created temporary file, flush and `fsync()` it, then atomically rename it into place. 10. Warn the user that generated keys are plaintext secrets and require immediate backup and migration to protected storage. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:82
Finding
Unpinned Third-Party Packages Are Downloaded and Executed<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:82-84, 1153-1154`; `references/SDK.md:3-6, 81-83`; `references/INTERFAZE.md:19, 39-57` **Vulnerability Type**: Unpinned executable dependency and package-registry trust **Risk Level**: Medium ### Complete Code Snippet From `SKILL.md`: ```bash npx @acnlabs/acn-cli <command> # or: npm install -g @acnlabs/acn-cli ``` ```bash pip install web3 httpx ``` From `references/SDK.md`: ```bash pip install acn-client # WebSocket support: pip install acn-client[websockets] ``` ```bash npm install acn-client ``` From `references/INTERFAZE.md`: ```text | CLI | `npx @acnlabs/acn-cli <command>` · https://www.npmjs.com/package/@acnlabs/acn-cli | ``` ```bash npx @acnlabs/acn-cli config show npx @acnlabs/acn-cli agents me npx @acnlabs/acn-cli delivery get ``` ### Technical Analysis The instructions install or immediately execute packages without specifying reviewed versions, lockfiles, integrity hashes, signatures, or provenance requirements. `npx @acnlabs/acn-cli` is particularly sensitive because it may retrieve current registry content and execute it immediately. The effective code can therefore change after the Skill itself has been audited. The Python and npm installation commands likewise resolve whatever package versions and transitive dependencies the registries provide at execution time. These dependencies operate in a high-value context involving: - Long-lived ACN API keys. - Auth0 claim tokens. - Local agent configuration. - Remote message processing. - Optional Ethereum private keys. - Task and payment authority. No evidence shows that the currently named packages are malicious. The vulnerability is the mutable, unpinned trust path and the resulting supply-chain exposure. ### Attack Path 1. A package publisher account, registry, release process, or transitive dependency is compromised. 2. A malicious version is published under one of the instructed package names. 3. The agent runs an unvers ...[truncated 1233 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every direct dependency and CLI to an exact reviewed version. 2. Commit lockfiles that pin transitive dependencies. 3. For Python, use a requirements or lock file with cryptographic hashes and install with hash verification. 4. For npm, use a committed lockfile and reproducible installation such as `npm ci`. 5. Replace unqualified `npx @acnlabs/acn-cli` with an exact version and prevent unapproved automatic downloads. 6. Verify package provenance, publisher identity, signatures, and registry origin before installation. 7. Install dependencies in an isolated virtual environment or container with minimal filesystem and network access. 8. Do not expose wallet private keys or owner JWTs to package installation processes. 9. Review package lifecycle scripts and disable them where they are unnecessary. 10. Establish a dependency update process in which new versions are audited before changing the pinned version. ]]>

T06 · System Persistence

Error
Location
references/INTERFAZE.md:157
Finding
Skill Requests a Cross-Reboot Remote Wake and Command Channel<![CDATA[ ## Vulnerability Details **File Location**: `references/INTERFAZE.md:76-85, 157-160`; related listener instructions in `SKILL.md:313-327, 655-668` **Vulnerability Type**: Persistent remotely triggered runtime activation **Risk Level**: High ### Complete Code Snippet From `references/INTERFAZE.md`: ```bash npx @acnlabs/acn-cli listen --runtime command \ --chat-writeback \ --chat-api-base https://api.agentplanet.org \ --chat-complete-exec '<your complete command>' # or --chat-complete-url http://127.0.0.1:<port>/chat/complete ``` ```text ### 5. Persist and report - Persist `~/.acn/config.json`; ensure listen/complete restart after reboot. - Tell the human: `agent_id`, Mode A or B, and: open interfaze.io → log in → you should appear → green dot → send a test message. - List anything still needed (claim JWT only). ``` Related command-wake instructions in `SKILL.md`: ```bash acn listen --runtime http \ --wake-url http://127.0.0.1:10122/hooks/agent \ --wake-header 'Authorization: Bearer …' # or: acn listen --runtime command --wake-exec '/path/to/wake.sh' # or: acn listen --runtime log # debug ``` The Skill also recommends scheduled heartbeat persistence: ```bash # Idle-listener cron: */15 * * * * acn heartbeat # Busy agent: no cron needed — your normal API calls renew the TTL ``` ### Technical Analysis The Skill does not merely describe a temporary chat session. It directs the executing agent to: - Persist long-lived ACN configuration. - Keep a relay listener and completion process running. - Restart those processes after reboot. - Optionally invoke a local command through `--wake-exec`. - Maintain online status using a cron or scheduler. This creates a cross-session, remotely activated processing channel. Remote ACN messages arriving through the relay can wake a local runtime after the original Skill interaction has ended. Persistent availability is related to the declared Interfaze chat functionality, so the channel is ...[truncated 2213 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Default to a session-scoped listener that terminates when the current task ends. 2. Require explicit and informed user approval before creating any startup service, scheduled task, or reboot-persistent listener. 3. Clearly display: - What process will persist. - Which account will run it. - Which remote service can activate it. - Which local command or endpoint it invokes. 4. Prefer a narrowly defined HTTP wake API over a generic command execution hook. 5. If command mode is necessary, use a fixed executable and fixed arguments rather than a shell command string. 6. Run the listener under a dedicated low-privilege account with filesystem, process, and network sandboxing. 7. Default reception policy to `allowlist` or `manifest`, not unrestricted push. 8. Require explicit approval before allowing subnet membership to bypass sender restrictions. 9. Authenticate local wake requests with a separately scoped secret and bind the endpoint only to loopback. 10. Rate-limit and deduplicate remote events and require confirmation before financial or otherwise irreversible operations. 11. Provide documented commands to stop the listener, remove startup entries and cron jobs, delete stored credentials, and rotate the ACN API key. 12. Log remote activations without recording bearer credentials or sensitive message content. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (66)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The description presents a broad collaboration/networking skill centered on ACN operations and Interfaze chat integration. The code chunk instead implements a narrow local data-transformation utility for usage accounting: it loads JSON, extracts token/duration/model/provider fields from top-level or nested `usage`, normalizes aliases, adds a default `meter_source`, and outputs normalized JSON. There are no calls for network access, registration, discovery, messaging, task handling, or chat bridging. This is a materially different primary purpose, so the description does not accurately represent the code.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The description presents a multi-purpose ACN collaboration and chat integration skill, but this code chunk only implements one specific function: on-chain registration of an ACN agent and binding that registration to ACN. That is only loosely related to 'register your agent,' and materially differs from the broader declared behavior. The code also performs sensitive blockchain and wallet-management actions—creating or consuming an Ethereum private key, persisting it locally, and sending an on-chain transaction—which are not disclosed in the description. Conversely, most prominently declared capabilities (discovering agents, routing/broadcasting messages, managing orgs/subnets, handling work items, enabling Interfaze chat) are absent from the supplied code. This constitutes a description/behavior mismatch.

Credential Access

High
Category
Privilege Escalation
Content
name: acn
description: Agent Collaboration Network — Register your agent, discover other agents by skill, route messages, manage subnets/orgs, work on Org work items or Task Pool tasks, and connect yourself to Interfaze chat (Mode A direct or Mode B listen+writeback) when the user wants to talk on interfaze.io. Use when joining ACN, finding collaborators, sending or broadcasting messages, Org Harness (acn org), accepting and completing assignments, or enabling Interfaze / AgentPlanet chat.
license: MIT
compatibility: "Requires ACN_API_KEY env var (from POST /agents/join). Optional: ACN_BASE_URL or --region cn|global; AUTH0_JWT for owner-scoped endpoints (claim/transfer/release/delete); WALLET_PRIVATE_KEY for on-chain ERC-8004 registration (requires pip install web3 httpx, writes .env mode 0600). HTTPS access to the chosen regional ACN required."
metadata:
  author: acnlabs
  version: "1.0.2"
Confidence
88% confidence
Finding
The skill explicitly supports handling `WALLET_PRIVATE_KEY` and notes writing wallet material to a local `.env` file. Combining highly sensitive secret material with broadly permitted shell tooling and a networked collaboration skill raises the risk of accidental disclosure, reuse, or insecure persistence, especially because `.env` files are commonly committed, copied, or exposed through logs and support bundles.

Credential Access

High
Category
Privilege Escalation
Content
agent_card: "https://api.acnlabs.dev/.well-known/agent-card.json"
  primary_env: "ACN_API_KEY"
  optional_env: "ACN_BASE_URL, AUTH0_JWT, WALLET_PRIVATE_KEY"
  writes_to_disk: ".env — WALLET_PRIVATE_KEY + WALLET_ADDRESS, mode 0600, on-chain registration only; ~/.acn/config.json — credentials + region"
allowed-tools: WebFetch Bash(curl:api.acnlabs.dev) Bash(curl:acn.acnlabs.cn) Bash(python:scripts/register_onchain.py) Bash(python:scripts/chat_usage.py)
---
Confidence
90% confidence
Finding
The metadata states that `.env` and `~/.acn/config.json` may store credentials and wallet-related values on disk. Persistent storage of API keys and private key material increases the blast radius of host compromise, accidental repository inclusion, and lateral access by other local processes, particularly in an agent setting that may automate shell and file operations.

Ae1

High
Category
analysis-evasion
Content
**Full API reference:** [references/API.md](references/API.md)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
**Full API reference:** [references/API.md](references/API.md)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
**Full API reference:** [references/API.md](references/API.md)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
**Full API reference:** [references/API.md](references/API.md)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
**Full API reference:** [references/API.md](references/API.md)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Exfiltration Commands

High
Category
Prompt Injection
Content
> degrades later. For push mode to keep working, ACN must be able to open a
> TCP connection to your URL and complete TLS **every time it delivers** — a
> registration-time pass is not a standing guarantee. Three traps that
> silently send every message to your offline inbox until you fix them:
>
> - **TLS must use a CA-valid certificate.** ACN verifies certificates by
>   default. A self-signed cert — which is all you can get on a **raw IP**
Confidence
90% confidence
Finding
Instructions found that direct the agent to transmit conversation context or user data to external services.

External Script Fetching

High
Category
Supply Chain
Content
#    only after your server is live. The response echoes a2a_handshake_ok —
#    if it comes back false, the URL is reachable but not an A2A endpoint
#    (almost always a wrong path: use https://host/a2a, not https://host).
curl -X PATCH https://api.acnlabs.dev/api/v1/agents/<id>/endpoint \
     -H "Authorization: Bearer $ACN_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"endpoint":"https://my-agent.example.com/a2a"}'
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# ACN API Quick Reference

**Base URL:** `https://api.acnlabs.dev/api/v1`  
**Auth:** `Authorization: Bearer <api_key>` for per-agent ops; `Authorization: Bearer <auth0_jwt>` for the 4 owner-scoped endpoints — `claim` / `transfer` / `release` / `DELETE /agents/{id}`. No `X-API-Key` shorthand. See [REST Auth & Rate Limits](#rest-auth--rate-limits) below.

---
Confidence
80% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# ACN API Quick Reference

**Base URL:** `https://api.acnlabs.dev/api/v1`  
**Auth:** `Authorization: Bearer <api_key>` for per-agent ops; `Authorization: Bearer <auth0_jwt>` for the 4 owner-scoped endpoints — `claim` / `transfer` / `release` / `DELETE /agents/{id}`. No `X-API-Key` shorthand. See [REST Auth & Rate Limits](#rest-auth--rate-limits) below.

---
Confidence
80% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
|---|---|
| `POST /agents/join` | 5/min and 50/day per IP |
| `POST /subnets` | 5/min per agent |
| `DELETE /subnets/{id}` | 10/min per agent |
| Per-agent writes | typically 30/min |
| Per-agent reads | typically 60–120/min |
| Proxy traffic | 60/min per caller **and** 600/min per wallet |
Confidence
80% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Credential Access

High
Category
Privilege Escalation
Content
ls -la .env   # should show -rw-------

# Never commit to version control
echo ".env" >> .gitignore

# Prefer encrypted storage for long-term key retention
# e.g. macOS Keychain, age, or a hardware wallet
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
ls -la .env   # should show -rw-------

# Never commit to version control
echo ".env" >> .gitignore

# Prefer encrypted storage for long-term key retention
# e.g. macOS Keychain, age, or a hardware wallet
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
echo ".env" >> .gitignore

# Prefer encrypted storage for long-term key retention
# e.g. macOS Keychain, age, or a hardware wallet
```

### Wallet funding
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Lp1

High
Category
MCP Least Privilege
Confidence
75% confidence
Finding
The skill uses 'env' capability that is not listed in its permissions. This may indicate deceptive intent or missing permission declarations.

Lp1

High
Category
MCP Least Privilege
Confidence
75% confidence
Finding
The skill uses 'file_write' capability that is not listed in its permissions. This may indicate deceptive intent or missing permission declarations.

Lp1

High
Category
MCP Least Privilege
Confidence
75% confidence
Finding
The skill uses 'shell' capability that is not listed in its permissions. This may indicate deceptive intent or missing permission declarations.

Credential Access

High
Category
Privilege Escalation
Content
Security notes:
  - Never pass --private-key on the command line in shared or logged environments.
  - The generated .env file contains your private key in plaintext; restrict its
    permissions (chmod 600 .env) and never commit it to version control.
  - Verify the ACN API URL before running to avoid sending your key to a wrong server.
"""
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
Security notes:
  - Never pass --private-key on the command line in shared or logged environments.
  - The generated .env file contains your private key in plaintext; restrict its
    permissions (chmod 600 .env) and never commit it to version control.
  - Verify the ACN API URL before running to avoid sending your key to a wrong server.
"""
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
Security notes:
  - Never pass --private-key on the command line in shared or logged environments.
  - The generated .env file contains your private key in plaintext; restrict its
    permissions (chmod 600 .env) and never commit it to version control.
  - Verify the ACN API URL before running to avoid sending your key to a wrong server.
"""
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
def _save_wallet(path: str, private_key: str, address: str) -> None:
    """Append wallet credentials to a .env file (skips existing keys).

    The file is created with mode 0o600 (owner read/write only) to prevent
    other users on the system from reading the private key.
Confidence
97% confidence
Finding
The helper explicitly persists an Ethereum private key to a local .env file in plaintext. Even with mode 0600, plaintext key material on disk is highly sensitive and may be exposed through backups, accidental commits, malware, developer tooling, or later permission changes; in this skill context, compromise of that key enables wallet takeover and unauthorized on-chain actions.

Credential Access

High
Category
Privilege Escalation
Content
account = Account.create()
        private_key = account.key.hex()
        wallet_address = account.address
        _save_wallet(".env", private_key, wallet_address)
        print("\nWallet generated and saved to .env")
        print(f"  Address:     {wallet_address}")
        print("  ⚠  Back up your private key!\n")
Confidence
98% confidence
Finding
When no key is provided, the script auto-generates a wallet and immediately writes the private key to .env, creating sensitive credential material in plaintext by default. Because this skill is meant for agent registration and blockchain identity binding, theft of the generated key could let an attacker impersonate the agent’s on-chain identity or transfer control of the registered wallet.

Static analysis

Detected: suspicious.secret_argv_exposure

Instructions pass high-value credentials through process argv.

Critical
Code
suspicious.secret_argv_exposure
Location
references/SECURITY.md:29