CVE-2026-3193: 
NixOS vulnerability analysis and mitigation

CVE-2026-3193 is a Cross-Site Request Forgery (CSRF) vulnerability in Chia Blockchain version 2.1.0, affecting the /send_transaction RPC endpoint. The flaw also involves missing authorization controls (CWE-862), allowing a remote attacker to execute unauthorized cryptocurrency transactions on behalf of a legitimate user. It was published on February 25, 2026, and assigned a CVSS v3.1 base score of 3.1 (Low) and a CVSS v4.0 base score of 1.3 (Low) (Feedly, VulDB). The vendor rejected a bug bounty report, stating the behavior is "by design" and that "the user is responsible for host security" (GitHub PoC).

The vulnerability stems from two root causes: CWE-352 (Cross-Site Request Forgery) and CWE-862 (Missing Authorization). The Chia RPC server (rpc_server_base.py) performs no CORS header enforcement and no origin validation, meaning any malicious website can issue POST requests to the locally bound wallet RPC port (default: localhost:9256). Additionally, if no RPC credentials are configured (the default state), the _authenticate() function returns True for all requests unconditionally. A third related issue is that the Master Passphrase lock enforced by the Wallet GUI is entirely ignored by the RPC server, allowing local processes with access to mTLS certificates to call /send_transaction or /get_private_key without any passphrase prompt (GitHub PoC).

Successful exploitation of the CSRF vector allows a remote attacker to initiate unauthorized cryptocurrency transactions from a victim's Chia wallet by tricking the user into visiting a malicious webpage — the browser executes the cross-origin POST request even though it cannot read the response due to CORS restrictions. The missing authorization and passphrase bypass issues compound the risk: a local attacker or malicious process with access to the mTLS certificate files can call /get_private_key to extract the full 24-word seed phrase in plaintext, enabling complete and irreversible theft of all wallet funds. There is no confidentiality impact from the CSRF vector alone, but the broader attack surface results in severe integrity compromise and potential total loss of cryptocurrency assets (GitHub PoC, Feedly).

A public proof-of-concept exploit is available on GitHub, demonstrating both the CSRF attack via a malicious HTML page and the local seed extraction via curl with mTLS certificates (GitHub PoC). The EPSS score is approximately 0.014%, indicating a low probability of widespread exploitation in the near term (Feedly). Exploitation requires user interaction (victim must visit a malicious page) and high attack complexity for the CSRF vector, while the local privilege escalation vector requires access to the host's mTLS certificate files. There is no evidence of in-the-wild exploitation at this time, and the vulnerability is not listed in the CISA KEV catalog (Feedly).

1. Reconnaissance: Identify a target running Chia Blockchain 2.1.0 with the wallet RPC server listening on localhost:9256 (default configuration with no RPC credentials set).
2. Craft CSRF payload: Create a malicious HTML page containing a JavaScript fetch() call targeting http://127.0.0.1:9256/send_transaction with mode: 'no-cors' and a JSON body specifying the attacker's wallet address, wallet ID, and desired transfer amount.
3. Deliver payload: Trick the victim into visiting the malicious page (e.g., via phishing email, malicious ad, or compromised website). The victim's browser executes the cross-origin POST request to the locally running Chia wallet RPC.
4. Transaction execution: The Chia RPC server, lacking CSRF token validation and origin checks, processes the request and broadcasts the transaction. The browser receives a CORS error but the transaction has already been signed and submitted.
5. Optional — Seed extraction (local): If the attacker has local access to the host, locate the mTLS certificate files at ~/.chia/mainnet/config/ssl/wallet/private_wallet.crt and .key, then call /get_private_key via curl --insecure with those certificates to retrieve the 24-word seed phrase in plaintext — no passphrase required (GitHub PoC).

• Network: Unexpected outbound POST requests from a browser process to http://127.0.0.1:9256/send_transaction or https://localhost:9256/send_transaction; unusual transaction broadcasts from the Chia node to the blockchain network.
• Logs: Chia wallet RPC access logs showing POST requests to /send_transaction or /get_private_key from unexpected origins or at unusual times; RPC log entries showing successful transaction submissions not initiated by the user.
• File System: Unexpected access or reads of mTLS certificate files located at ~/.chia/mainnet/config/ssl/wallet/private_wallet.crt and private_wallet.key by non-Chia processes.
• Process: curl or other HTTP client processes spawned with --insecure flags and certificate arguments targeting localhost:9256; browser processes making fetch requests to localhost RPC ports (GitHub PoC).

No official vendor patch has been released, as Chia Network rejected the bug bounty report as "by design." Until a patch is available, users should implement the following mitigations:

• Add CSRF token validation and strict origin checking to the RPC server.
• Implement SameSite=Strict cookie attributes and Content Security Policy (CSP) headers.
• Restrict the Chia RPC interface to trusted networks using firewall rules (block external access to ports 9256 and 8555).
• Set RPC credentials in the Chia configuration to prevent unauthenticated access.
• Restrict file system permissions on mTLS certificate files to prevent unauthorized local access.
• Consider running the Chia wallet on an isolated system or VM not used for general web browsing (Feedly, GitHub PoC).

The Chia Network vendor rejected the initial bug bounty report, characterizing the behavior as "by design" and placing responsibility for host security on the user — a response that the researcher publicly disputed, arguing the seed extraction and passphrase bypass constitute critical vulnerabilities (GitHub PoC). The vulnerability was picked up by several security aggregators including INCIBE-CERT and Offseq Radar shortly after disclosure (Feedly). Community reaction has been limited given the low CVSS score, though the researcher's framing of the issue as enabling "remote fund theft and seed extraction" has drawn attention to the broader design philosophy of the Chia RPC server.