CVE-2026-3194: 
NixOS vulnerability analysis and mitigation

CVE-2026-3194 is a missing authentication vulnerability in Chia Blockchain 2.1.0 affecting the send_transaction and get_private_key functions of the RPC Server Master Passphrase Handler component. The flaw allows a local attacker with low privileges to bypass authentication controls and access critical wallet operations without providing the configured master passphrase. It was disclosed on February 25, 2026, with the vendor having been notified in advance via email; a bug bounty report was rejected with the rationale "This is by design. The user is responsible for host security" (Red Hat CVE, VulDB). The vulnerability carries a CVSS v3.1 base score of 7.0 (High) (Feedly).

The root cause is classified under CWE-287 (Improper Authentication) and CWE-306 (Missing Authentication for Critical Function). In rpc_server_base.py, the _authenticate() method returns True for all requests when no RPC credentials are configured (the default state), effectively disabling authentication entirely (PoC Repo). Additionally, the RPC server lacks CORS headers and origin validation, enabling CSRF attacks from malicious web pages targeting the local wallet RPC port (default: localhost:9256). The Master Passphrase lock enforced by the Wallet GUI is completely ignored by the RPC server — any local process possessing the mTLS client certificates can call /get_private_key to extract the 24-word seed phrase in plaintext, or /send_transaction to initiate fund transfers, without any passphrase prompt (PoC Repo). Exploitation requires local access and possession of the mTLS certificates, contributing to the high attack complexity rating.

Successful exploitation allows an attacker to extract the wallet's 24-word mnemonic seed phrase in plaintext via the /get_private_key RPC endpoint, resulting in complete and irreversible compromise of all funds associated with the wallet (PoC Repo). An attacker can also call /send_transaction to transfer funds to an attacker-controlled address without any authentication or passphrase challenge. The CSRF attack vector further extends the threat surface: a malicious website visited by the victim can silently trigger fund transfers via the browser to the local RPC server, even without direct local access to the machine (PoC Repo). The confidentiality, integrity, and availability impacts are all rated High under CVSS v3.1.

A public proof-of-concept exploit is available on GitHub, published by researcher Danimlzg, demonstrating both the CSRF-based remote fund theft and the local master passphrase bypass with seed extraction (PoC Repo). The exploit was added to NVD on March 4, 2026 (Feedly). As of the latest available data, there is no evidence of active in-the-wild exploitation, and no threat actor attribution has been reported. The EPSS score is approximately 0.02% (0.000200), indicating a currently low probability of widespread exploitation (Feedly). This vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.

1. Reconnaissance: Identify a target system running Chia Blockchain 2.1.0 with the wallet daemon active. Confirm the RPC server is listening on localhost:9256 (wallet) or localhost:8555 (full node).
2. Obtain mTLS certificates (for local attack): Locate the client certificate and key at ~/.chia/mainnet/config/ssl/wallet/private_wallet.crt and private_wallet.key. These are accessible to any local user with read permissions on the Chia config directory.
3. Extract private key / seed phrase: Execute the following command to retrieve the 24-word seed without any passphrase prompt:

curl --insecure \
  --cert ~/.chia/mainnet/config/ssl/wallet/private_wallet.crt \
  --key ~/.chia/mainnet/config/ssl/wallet/private_wallet.key \
  -d '{"fingerprint": <wallet_fingerprint>}' \
  -H "Content-Type: application/json" \
  -X POST https://localhost:9256/get_private_key

The server returns the seed phrase, private key, and public keys in plaintext (PoC Repo). 4. Transfer funds (local): Call /send_transaction with the mTLS certificates to transfer XCH to an attacker-controlled address without passphrase verification. 5. CSRF-based remote attack: Host a malicious webpage containing a JavaScript fetch() call targeting http://127.0.0.1:9256/send_transaction with mode: 'no-cors'. When a Chia wallet user visits the page, the browser sends the POST request to the local RPC server, which executes the transaction. The CORS error in the browser is irrelevant — the wallet processes the command regardless (PoC Repo).

• Network: Unexpected outbound connections from the Chia wallet process to external addresses following RPC calls; unusual POST requests to localhost:9256/send_transaction or localhost:9256/get_private_key originating from non-Chia processes.
• Logs: Chia wallet RPC access logs showing calls to /get_private_key or /send_transaction from unexpected processes or at unusual times; transaction broadcast events not initiated by the user via the GUI.
• File System: Unauthorized access or reads of mTLS certificate files at ~/.chia/mainnet/config/ssl/wallet/private_wallet.crt and private_wallet.key by non-Chia processes.
• Process: Unexpected curl, python, or scripting processes making HTTPS connections to localhost:9256 or localhost:8555; browser processes initiating connections to local RPC ports.

No official patch from Chia has been released as of the available data; the vendor has characterized the behavior as by design, placing responsibility on the user for host security (Red Hat CVE). Recommended mitigations include: (1) restricting local system access to the Chia configuration directory and mTLS certificates to trusted users only; (2) implementing host-based firewall rules to block unauthorized local processes from connecting to RPC ports (9256, 8555); (3) monitoring RPC server access logs for unexpected calls to sensitive endpoints; (4) disabling the RPC server when not in active use; and (5) considering network-level controls to prevent browser-based CSRF attacks against local RPC endpoints (e.g., using browser extensions that block cross-origin requests to localhost). Users should evaluate whether the risk profile of running Chia Blockchain 2.1.0 is acceptable given the absence of a vendor patch (PoC Repo).

The vendor (Chia Network) rejected the bug bounty report with the statement "This is by design. The user is responsible for host security," a position that the researcher publicly disputed, characterizing the vulnerabilities as critical (PoC Repo). Red Hat has tracked the CVE in their security advisory database (Red Hat CVE). No significant broader media coverage or notable community debate beyond the initial disclosure has been identified in available sources.