/

CVE-2026-43992

Severity:

CRITICAL RISK

(9.8)

Information Exposure in JunoClaw MCP Write Tools

CVE-2026-43992

Deferred

Vulnerability type

Category:

Information Exposure

CWE:

CWE-200, CWE-312, CWE-522, CWE-532

Impact:

Compromise of Wallet Keys and On-Chain Identities

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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, and ibc_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 mnemonic parameter.
  • 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.

Sources

SourceLink
github.comgithub.com/Dragonmonk111/junoclaw/commit/339701e
github.comgithub.com/Dragonmonk111/junoclaw/releases/tag/v0.x.y-security-1
github.comgithub.com/Dragonmonk111/junoclaw/security/advisories/GHSA-j75q-8xvm-6c48

Frequently asked

questions

Yes. Any party with access to the LLM tool-call traffic or associated logs and telemetry can potentially extract the mnemonic. This includes remote service providers (e.g., LLM or observability vendors) and attackers who compromise those systems.

An attacker needs read access to any transport, logging, or telemetry surface that records the MCP write tool calls containing the mnemonic parameter. This could be network-level access, cloud provider access, or access to internal observability tools.

The safest pattern is to remove mnemonics and other secret material from all LLM-facing tool interfaces and instead use server-side key management. Tools should operate on identifiers or aliases, with signing handled inside a secure, non-logged component.

Establish a strict secret-handling model where mnemonics, keys, and tokens are never passed through general-purpose APIs, LLM tool calls, or logging systems. Use formal schemas that mark secret fields, enforce redaction and access control in CI and code review, and architect agent workflows so that sensitive operations are performed behind a dedicated signing or key-management boundary.

Find out what's already
exploitable in your codebase.