Summary
JunoClaw's MCP write tools previously accepted a BIP‑39 mnemonic as a direct string parameter, embedding this highly sensitive seed phrase into LLM tool-call JSON.
As a result, the mnemonic could be exposed to any intermediate transport, logging, or telemetry system between the LLM provider and the MCP process, enabling full compromise of affected wallets and on-chain identities.
Affected context
This vulnerability affects JunoClaw deployments where:
- Agentic flows use MCP write tools such as
send_tokens,execute_contract,instantiate_contract,upload_wasm, andibc_transfer. - The BIP‑39 mnemonic is passed as a clear-text string parameter (
mnemonic: string) in LLM tool calls. - Tool-call payloads transit through external LLM providers, gateways, observability stacks, or logging systems that may record requests and responses.
- Operators rely on standard HTTP(S) transports, API gateways, or tracing/telemetry pipelines that are not explicitly designed to handle cryptographic secrets.
Exploit preconditions
- Attack surface:
- Any infrastructure component that can observe, capture, or replay LLM tool-call traffic, including:
- LLM provider backends and plugins
- Network intermediaries, proxies, and gateways
- Logging, tracing, and telemetry services
- MCP-side request handlers and their logs
- Required access:
- Read access to tool-call JSON payloads, logs, traces, or telemetry that include the
mnemonicparameter. - This could be held by cloud providers, observability vendors, internal operators, or an attacker who compromises those systems.
- Trigger point:
- Whenever an MCP write tool is invoked with
mnemonic: <seed phrase>as an argument during an LLM-agent workflow. - Why exploitation is possible:
- The BIP‑39 mnemonic is treated as ordinary data rather than a secret.
- It is serialized in JSON without redaction or special handling, making it visible in:
- Network captures
- Access logs
- Debug logs
- Distributed traces and telemetry streams
- Anyone with access to these data streams can extract the mnemonic and use it to derive private keys.
Why this happens
The core issue is a design-level information exposure (CWE-200) combined with improper storage and transmission of sensitive data (CWE-312, CWE-522, CWE-532).
Cryptographic seed phrases (BIP‑39 mnemonics) are treated as regular input parameters in MCP tool definitions. By allowing mnemonic: string to be supplied directly in tool-call JSON, the system:
- Fails to distinguish between low-sensitivity parameters and high-value secrets.
- Transmits and logs the mnemonic in clear text as part of normal request handling.
- Relies on generic logging and telemetry defaults that are not secret-aware.
Abstractly, this is an insecure pattern where:
- High-value secrets (keys, tokens, seed phrases) are passed through general RPC/LLM interfaces.
- There is no dedicated secret channel, key management, or redaction policy.
- Observability and transport layers are implicitly trusted to protect secrets they are not designed to handle.
Potential impact
- Full compromise of any wallet or account derived from the exposed mnemonic.
- Unauthorized token transfers, staking operations, and governance actions.
- Malicious smart contract execution or destructive contract interactions under the victim's identity.
- Long-term loss of control over identities and funds, as mnemonics can be reused indefinitely.
- Regulatory, legal, and reputational damage for organizations operating affected agents or infrastructure.
- Secondary compromise of additional systems that rely on the same mnemonic-derived keys.
General mitigation guidance
Mitigations should focus on eliminating direct mnemonic handling in LLM tool interfaces and treating mnemonics as high-sensitivity secrets:
- Remove secret parameters from tool interfaces:
- Avoid accepting
mnemonic(or equivalent seeds/keys) as explicit tool-call parameters. - Refactor tools to reference pre-configured wallet identities or key aliases managed server-side.
- Introduce dedicated key management:
- Store mnemonics and derived keys in a dedicated secrets or key management system under strict access control.
- Ensure that only the MCP process (or a signing service) sees raw key material, never the LLM layer.
- Minimize data exposure across layers:
- Design tool schemas so that LLM-facing interfaces only receive non-sensitive identifiers (e.g., account labels or IDs) rather than secrets.
- Enforce strict separation between "control-plane" metadata and "data-plane" secret material.
- Harden observability and logging practices:
- Implement systemic secret redaction for request/response logging and telemetry where possible.
- Apply least-logging principles: only record data necessary for debugging and compliance.
- Apply least privilege to execution flows:
- Limit which tools can perform high-value operations and consider multi-step confirmation or policy checks for large transfers or sensitive actions.
How teams detect issues like this
Detection should focus on identifying both historical exposure and ongoing risky patterns:
- Static analysis and schema review:
- Scan MCP tool definitions and API schemas for parameters like
mnemonic,seed,private_key, or other secret-like fields. - Flag any tool that accepts these fields directly via JSON, RPC, or LLM tool-call interfaces.
- Code review signals:
- Look for patterns where signing credentials are passed through LLM-facing code paths or general RPC handlers.
- Review implementation of logging, tracing, and error reporting around MCP tools for inclusion of sensitive parameters.
- Log and telemetry auditing:
- Perform targeted searches in historical logs, traces, and telemetry for mnemonic-like patterns (e.g., wordlists, known BIP‑39 dictionaries).
- Identify services that store or index LLM tool-call payloads without redaction.
- Policy and tooling enforcement:
- Introduce internal security policies that forbid direct handling of mnemonics or keys in LLM or front-facing APIs.
- Use automated review tools or CI checks to enforce secret-handling guidelines and prevent reintroduction of such parameters in future changes.

