CVE-2026-3192: 
NixOS vulnerability analysis and mitigation

CVE-2026-3192 is an improper authentication vulnerability in Chia Blockchain 2.1.0 affecting the _authenticate function within rpc_server_base.py of the RPC Credential Handler component. When no RPC credentials are configured (the default state), the function returns True for all incoming requests, effectively bypassing authentication entirely. The vulnerability was disclosed publicly on February 25, 2026, after the vendor rejected a bug bounty report, stating "This is by design. The user is responsible for host security." It carries a CVSS v3.1 base score of 8.1 (High) (VulDB, 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 checks whether an RPC username is configured; if none is set — which is the default — it unconditionally returns True, granting access to all RPC endpoints without any credential verification. Beyond the authentication bypass, the PoC also documents a CSRF attack vector where any malicious webpage can issue POST requests to the locally bound RPC ports (e.g., localhost:9256 for the wallet, localhost:8555 for the full node) without origin validation or CORS headers, and a Master Passphrase bypass where the RPC server ignores the wallet's locked state, allowing local processes with access to mTLS certificates to call sensitive endpoints. The exploit requires high attack complexity (e.g., network positioning or social engineering for CSRF), but no privileges or user interaction are needed (GitHub PoC, VulDB).

Successful exploitation allows an unauthenticated remote or local attacker to gain full control over the Chia RPC interface, with high impact to confidentiality, integrity, and availability. Critically, attackers can call /get_private_key to exfiltrate the wallet's 24-word seed phrase in plaintext and call /send_transaction to transfer funds to attacker-controlled addresses — all without triggering a Master Passphrase prompt, even when the wallet GUI is in a locked state. This effectively enables complete remote fund theft and private key extraction from affected Chia Blockchain 2.1.0 nodes (GitHub PoC, Feedly).

A public proof-of-concept exploit is available on GitHub, demonstrating authentication bypass, CSRF-based fund theft, and Master Passphrase bypass with seed extraction (GitHub PoC). The CVSS v4.0 exploit maturity is rated as PROOF_OF_CONCEPT, and the EPSS score is approximately 0.077% — indicating low but non-zero probability of widespread exploitation in the near term. There is no current evidence of in-the-wild exploitation or threat actor attribution, and the vulnerability is not listed in the CISA KEV catalog as of the time of this report (VulDB, Feedly).

1. Reconnaissance: Identify Chia Blockchain 2.1.0 nodes with RPC ports exposed — wallet RPC on localhost:9256 and full node RPC on localhost:8555. Determine whether the target has RPC credentials configured (default installations do not).
2. Authentication Bypass (No-Credential Default): Send any POST request to the RPC endpoint. Because _authenticate() returns True when no username is configured, the request is accepted without credentials.
3. CSRF Attack (Remote Browser-Based): Host a malicious webpage containing a JavaScript fetch() call targeting http://127.0.0.1:9256/send_transaction with mode: 'no-cors'. When a victim with a running Chia wallet visits the page, the browser executes the transaction. CORS errors are irrelevant as the wallet processes the command before the browser enforces the policy.
4. Master Passphrase Bypass (Local Access with mTLS Certs): If the attacker has local access or has obtained the mTLS certificate and key files from ~/.chia/mainnet/config/ssl/wallet/, use curl with --cert and --key flags to call /get_private_key and retrieve the 24-word seed phrase in plaintext, or call /send_transaction to transfer funds — bypassing the wallet's locked state entirely.
5. Fund Theft / Seed Extraction: Use the extracted seed phrase to import the wallet into an attacker-controlled environment, or directly broadcast transactions to drain funds to an attacker address (GitHub PoC).

• Network: Unexpected POST requests to localhost:9256 (wallet RPC) or localhost:8555 (full node RPC) from non-local or unexpected source IPs; outbound connections to unknown XCH wallet addresses following RPC activity.
• Logs: RPC server logs showing calls to /get_private_key or /send_transaction without corresponding user-initiated GUI actions; repeated unauthenticated RPC requests in rpc_server_base.py logs.
• File System: Unexpected access or modification timestamps on mTLS certificate files under ~/.chia/mainnet/config/ssl/wallet/; presence of scripts or tools (e.g., curl command history) referencing Chia RPC endpoints.
• Blockchain: Unauthorized outbound transactions from the wallet address to unknown recipient addresses, particularly with no corresponding user activity in the Chia GUI (GitHub PoC).

No official patch has been released by the Chia Network vendor as of the time of this report, and the vendor has characterized the behavior as by design. As immediate mitigations, operators should configure RPC credentials in the Chia config file to prevent the unauthenticated default path in _authenticate(). Network-level controls such as firewall rules should be applied to block external access to RPC ports (9256, 8555). Chia nodes should be isolated on restricted networks, and mTLS certificate files should have strict filesystem permissions. Monitoring RPC authentication logs for anomalous calls to sensitive endpoints like /get_private_key and /send_transaction is strongly recommended (Feedly, GitHub PoC).

The vendor (Chia Network) rejected the initial bug bounty report, stating the behavior is "by design" and that "the user is responsible for host security," a position that drew criticism from the security community given the severity of the potential impact (fund theft and seed extraction). The vulnerability was subsequently disclosed publicly by the researcher after vendor rejection, and the PoC was published on GitHub. The CVE was tracked by Red Hat, INCIBE-CERT, and multiple vulnerability aggregators, indicating moderate industry attention (VulDB, Feedly).