Skip to content

Security: Hero-Gamer/entropylab

Security

SECURITY.md

Security Policy

Supported Versions

Only the most recent release receives security fixes. Users are encouraged to always use the latest version, available from the releases page and the official website.

Version Supported
1.0.0 ✅
< 1.0.0 ❌

Security Considerations

The offline AEXB verifier validates canonical message fields and slot-set constraints on supplied objects, including objects changed after decoding. Successful signature verification checks the supplied hashes and transcript; it does not derive transaction hashes from a PSBT or establish an honest host's randomness, secrecy, or live exchange ordering.

Host randomness (rho) remains sensitive after signing. A malicious signer using an operator-known base nonce can expose the signing key if its operator later obtains rho and the signature. With the corresponding account xpub and a non-hardened derivation path, compromise can extend to the account private key. Do not save, share or record real transcripts or paste them on a shared/recorded screen. Clipboard copies can persist outside this page.

In normal and preview builds, tab hide, idle timeout and print clear the pasted transcript and last-inspection cache and close its disclosure. Plain window blur preserves them so the opening or PSBT can be copied from another window; other revealed secrets and visible result panes are still concealed. End Session and pagehide clear field/cache. Clearing is best-effort; browser/OS copies are outside reliable erasure. A successful transcript check does not establish that host randomness stayed secret.

Who EntropyLab defends against, what it checks against each of them, and what it leaves to you: docs/Threat_Model.md.

EntropyLab handles Bitcoin private keys, seed phrases, and other secret wallet material. Its security posture rests on the following model:

  • The tool is self-contained and designed for offline, air-gapped use. It does not intentionally transmit sensitive data to any server.
  • The Security log below Important records initial browser-reported connectivity, connectivity changes, and detected browser translation. Its API accepts only fixed event codes, never arbitrary messages, errors, user input or wallet material. The last 100 events and local timestamps stay in page memory; pagehide (including End session) clears them. A back/forward-cache restore starts fresh and retains any latched translation warning. No status probe or log export is sent over the network or saved in browser storage. Browser connectivity does not establish internet reachability or a physical air gap, and the translation marker does not identify the translation service or prove what text it received.
  • The hosted site registers a service worker only on the exact HTTPS entropylab.online or www.entropylab.online origin. It stores only the self-contained application entry points in a content-versioned cache so an iPhone Home Screen web app can reopen without a network. Navigation is served only from that current named cache; the worker has no network fallback, background sync, push, or notification handling. When the app is opened while connected, the browser checks the hosted worker for an update and may replace the cached application. Cached availability and the browser's Offline label are not proof of a physical air gap.
  • The downloaded entropylab.html remains the recommended path for sensitive use. It is one self-contained file, does not register the hosted service worker from file:// or another host, and should be verified before transfer to a dedicated computer that is disconnected from every network.
  • EntropyLab's own secp256k1 curve operations (public-key derivation, ECDSA signing and verification in PSBT inspection, curve point math) and its cryptographic hashes (SHA-256/SHA-512/RIPEMD-160/HMAC/PBKDF2) run on bitcoin-core/libsecp256k1 (the library securing Bitcoin Core) and rust-bitcoin's bitcoin_hashes, compiled to WebAssembly from the pinned, lockfiled Rust crate in entropylab-wasm/ and executed entirely in-process — no network access, and the module never generates randomness (signing is RFC 6979 with caller-fixed extra entropy). BIP32 extended-key derivation, BIP39 mnemonics, Base58Check, bech32m, and address/script construction run on rust-bitcoin's crates in the same module, except that the PSBT editor uses src/js/script-builder.js and the pinned @scure/btc-signer package for address-to-output-script conversion. That JavaScript package and its bundled dependencies are part of the production audit surface. Script-to- address rendering in the editor and flow visualizer uses the WASM facade. CI rebuilds the WASM from the committed Rust sources and tests the fresh modules before building the site. Those same modules are bundled with the HTML candidate for downstream source and browser tests, deployment, and the post-merge artifact commit; publication does not compile a second WASM copy. CI compiles these modules inside the pinned dev image (one linux/amd64 rootfs, one Ubuntu snapshot, clang 18.1.3) and requires a second build in that image to match the bytes it publishes; the artifact commit and the Pages deploy wait for that check. Their digests are published in WASM-SHA256SUMS.txt. A host clang is a different compiler. The v1.0.0 entropylab-wasm and vanity-wasm modules are the bytes that three people rebuilt in that image at cb55bd9 on three machines outside GitHub: Windows with WSL2 and bare-metal Linux on x86_64, and macOS on ARM64 (the image under Rosetta). v1.0.0's psbt-wasm module, and every module rock has published since (qr-wasm included), have no recorded rebuild outside GitHub. A release page's footer names the source commit to rebuild it from. The page committed inside the v1.0.0 git tag is an earlier build with a different footer and is not the release. See the known issue. The v1.0.0 release page has been rebuilt from that commit only by its author so far, on Windows (on the computer later found to be compromised; see Release signing keys) and on Linux (in a separate hosted environment). No independent rebuild of it is recorded. docs/Reproductions.md records each rebuild by commit. Build-host paths are remapped out of the binary. The image is the boundary: the page and the modules are reproducible inside it. Its Dockerfile pins the base image, the package snapshot and the tool versions, but the compilers in it are prebuilt binaries, trusted as a seed, and the built image is not itself bit-for-bit reproducible. This is not a full-source bootstrap: EntropyLab's Rust, clang and WASM toolchain has not been built from source, and no one has checked that such a build would give the same modules. iOS/macOS Lockdown Mode disables WebAssembly. Exclude the site in Safari or use a host that can compile WASM. There is no JavaScript secp256k1 fallback; a host that cannot run the module is treated as broken.
  • Vanity wipes its retained final child and fixed parent nodes in place; matching a copy of a node and wiping that copy is not sufficient. Regression tests scan WASM memory for independently derived nodes, private keys, and chain codes after a grind. Passing these vectors does not guarantee erasure of every compiler or crypto-library temporary; terminate the worker to release its entire WASM instance.
  • Clearing a Key or Multisig station invalidates pending derivation work. Pagehide and persisted-page restoration also invalidate derivations and clear rendered seed-word grids, checksum choices, and brain-lab hex — and the secondary renderings of a typed transcript: the dealt-cards strip, the "show calculations" work-outs, the die-fairness panel, and the progress lines (which quote a rejected word or token in an error cue). The same boundary ends the whole PSBT/Nonce session (key bytes, paste fields, the parsed report and its rendered views), resets every Multisig tab, and the two body-level overlays — the expand editor (whose value can be an entire previous transaction) and the QR dialog — release their contents on close and on page hide because station wipes cannot reach them. Clearing the Journal empties the session's unsecured text: the snapshot (which can hold the whole session's recovery texts), the notepad, and the session log, including historical snapshots restored from a backup. Opening a complete journal file restores its saved sections; entry-only legacy files restore only entries. The Vanity source block drops the passphrase it displayed the moment the key pick is dropped. Journal teardown invalidates pending notebook and Key Manager imports at both file-read and decryption boundaries, and invalidates a pending complete-backup download. Changing the chosen journal file while it decrypts also discards that obsolete open. Obsolete completions cannot restore cleared state; this is not guaranteed erasure of immutable strings or browser-managed memory.
  • Secret byte buffers are overwritten after use, on a best-effort basis. The WASM bindings zero every linear-memory buffer before freeing it (el_free/psbt_free use volatile writes) and erase their own secret temporaries — private keys, seeds, chain codes, mnemonics, passphrases, signing nonces, and HMAC/PBKDF2 blocks. The crypto module's Rust allocator also overwrites the full allocation before freeing it, including unused capacity and dependency-owned descriptor strings and secret-key map nodes. Reallocation copies the live prefix into a new block, then erases and frees the old block; allocation failure preserves the original block. This adds wiping work and temporarily requires both blocks during a resize. It applies to the crypto module, not the separate PSBT or vanity allocators. The JavaScript layer zeroes the Uint8Arrays it is done with (.fill(0), HDKey.wipePrivateData()), including temporary BIP32 serialized key/chain-code views after master derivation, child derivation, and extended-key import (also on failure). Returned HDKey nodes keep independent copies; this cleanup does not wipe caller-owned seed buffers. With the fixes merged in PR #843, rejected HD derivation paths also wipe the last intermediate private child created before the error; the caller-owned root remains usable. A derived wallet, a BIP-85 child, and each station's copy of a key hold their secrets only as byte arrays and HDKey nodes; words, WIF, xprv and hex text are built only where a secret is shown, copied or exported, or where a tool takes it as text. The layer also clears intermediate BIP32 path nodes, per-address child keys, and the PSBT/BIP-85/Silent-Payments session roots when a session ends or the page unloads (when pagehide fires, which browsers do not guarantee). The limits are structural: JavaScript strings, BigInts and DOM values (revealed secrets, typed input) cannot be overwritten, only dereferenced — the "(best effort)" the UI already states. Live dependency objects and by-value stack copies are outside the allocator's release boundary. The separate PSBT module retains pair-level heap residues inside rust-bitcoin's parsed structures and serde_json's value trees (its exports do wipe the whole-document copies — the assembled inspection JSON and the rebuilt PSBT bytes — before returning, and the suite scans for that; the small per-pair copies inside the dependencies remain until heap reuse). What the page can and cannot erase lists each case in plain language. Stack copies are handled separately: Rust frames spill arguments and temporaries into the WASM shadow stack, which lives in linear memory and is not erased when a frame returns, so the loaders of both the crypto module and the PSBT module wrap every export to zero the whole stack region once per task after any export ran (the Node suite asserts BIP39 entropy, the PBKDF2 passphrase salt, HMAC and hash inputs, and WIF keys are absent from linear memory once the task settles, and for the PSBT module that its stack region is zeroed and that the two whole-document copies its exports assemble — the inspection JSON and the rebuilt PSBT bytes — are gone once the task settles). None of this protects against a compromised machine.
  • The on-screen result of any derivation can only be as trustworthy as the code that produced it. Review the source, build from src/, and test the tool with published vectors before relying on it.
  • Wallet security depends on the quality and secrecy of the entropy, seed phrase, passphrase, or private key supplied by the user, and on the integrity of the machine it runs on.
  • Silent Payment sender inputs use BIP-341 tweaked output-key scalars for P2TR key-path spends. Session-derived sender keys are handed over as byte buffers and wiped on success, construction failure, and partial resolution failure. The UI suppresses the vector API's private-key-sum diagnostic. Immutable BigInts and internal curve-library representations still depend on garbage collection; this is best-effort cleanup, not guaranteed erasure.
  • Silent Payments (BIP-352) support is a calculator: it derives reusable addresses, sender outputs, and spend tweaks from user-supplied keys and pasted transaction data. It does not connect to a node, Electrum server, or indexer, and cannot detect payments on its own. BIP-321 URIs and BIP-353 DNS TXT records are printed from the derived code so you can publish them on a domain you control; the page never resolves names, never fetches silentpayments.net, and ignores Lightning parameters in a URI. When a URI includes an ordinary Bitcoin fallback address alongside sp=, sender outputs use the selected Silent Payment instruction and the results show the unused fallback as escaped text. That fallback is not validated or used to construct an output.
  • Inscription envelope detection is a parser of witness/tap-leaf scripts. It does not render inscription media, assign sat numbers, or contact an indexer.
  • PSBT analysis is explicitly bounded. EntropyLab does not independently fetch or verify previous outputs, its output-ownership search covers only the displayed account/address range and supported script types, RFC 6979 replay needs a matching session key plus a supported SegWit v0 digest, and a signature on a script containing OP_CODESEPARATOR is reported as unverifiable rather than verified or replayed. The signer-audit verifier checks supported legacy and SegWit v0 ECDSA signatures with SIGHASH_ALL, plus Taproot key-path and tapscript signature records with SIGHASH_DEFAULT or SIGHASH_ALL. Other script shapes and sighash types, finalized Taproot script paths, and annex-carrying signatures stay unverified. Finalized-field checks also validate sibling scriptSig/witness fields already present in the sent PSBT, require matching sent/returned UTXO claims, and never report valid when the transaction cannot be serialized or the decoder caps verification. Their decoding, script resolution and signatures share bounded work, with sibling results reused rather than charging signatures twice. These checks follow consensus, not relay policy: uncompressed SegWit v0 keys and unused legacy stack items may be valid, while witness CLEANSTACK, NULLDUMMY and scriptSig size limits still apply. See the final follow-up regression cases in the verifier tests. Repeated BIP340 nonces are still checked, although those nonces cannot be replayed like RFC 6979 nonces. The report marks these cases incomplete; a completed individual check is not a security conclusion for the transaction.
  • With the fixes merged in PR #843, PSBT and raw-transaction nonce analysis refuses an inspection requiring more than 32,768 same-r candidate-pair comparisons across all nonce groups. This bounds collision-driven pair allocation; it is separate from the digest-reconstruction budget. Even benign repeated signatures can exceed this resource limit. Refusal clears the attempted report and surfaces an error, without recording a nonce verdict. Repeated-nonce warnings suppress the no-repeat assurance in both report formats.
  • The optional ECDSA nonce-history file is an explicit user download and never uses browser storage or the network. It contains check timestamps, master fingerprints when available, raw r values, domain-separated SHA-256 identity tags for exact signing keys and verified message digests or source contexts, plus verification flags; it does not contain raw PSBTs, transactions, signatures, public keys, or digests. This is correlation-sensitive metadata and should stay offline. The master fingerprint is descriptive; comparisons use the exact signing-key tag, since one wallet can have many child keys. A confirmed alert requires the same key/r pair with different verified message tags; otherwise the result is only a warning. The current implementation covers ECDSA, not Schnorr.
  • In auto mode the PSBT editor's output-script builder reads a whitespace-free token of 25 to 64 characters with at most two symbols, and no /, : or @, as an address and refuses it unless it decodes; a token starting with 1, 2, 3, m or n is read as an address from 21 characters. A mistyped address of that shape errors instead of becoming OP_RETURN text. Bare hex counts as a raw script only when it is even-length, contains an a-f digit and does not read as a Base58 address; a 0x prefix always marks raw script. Text that carries whitespace, a URL or e-mail separator, or three or more symbols is never read as an address, and neither is a token shorter than those floors, so a mistyped address outside the shape still becomes text; inspect the resulting output before use.
  • OP_RETURN detection is a parser of output scripts. It does not create data-carrier outputs, assign protocol meaning, or contact an indexer.
  • The published CID.txt is CIDv1 (raw, sha2-256) of the release entropylab.html — the same digest as SHA256SUMS.txt, written as an IPFS name. The calculator never speaks IPFS: no node, no gateway, no IPNS, no fetch. Retrieving the file by CID is an online-machine step; verify SHA256SUMS.txt before moving the HTML onto an air-gapped computer. Do not publish seeds, xprvs, or other private material to IPFS.
  • After each merge to rock, CI submits the tested entropylab.html digest to OpenTimestamps calendars and commits entropylab.html.ots. A pending proof is a calendar receipt, not a Bitcoin timestamp; a scheduled job upgrades it once a calendar has a block attestation. Verify upgraded proofs with ots verify against a local Bitcoin Core node. The calculator never stamps, upgrades, or fetches calendars.
  • The session Journal (notepad, session snapshot, debug log) lives only in this page's memory. It is never written to localStorage, IndexedDB, or the network. Closing or hiding the page discards it with the other secret fields. Notes, Keys, and Session share the Journal's password setting. Complete backups and recovery section exports reuse its encryption keys; there is no per-section switch to plaintext. Debug log exports use the same protection setting. If the Journal was created without a password, its encoded downloads have no access protection. New log events record tool names, timestamps, public fingerprints, and allowlisted settings. Freeform derivation paths record only that a change occurred, so a private value pasted into that field is not retained in the log. Seed phrases, xprvs, and other secret input fields are excluded. Historical events imported from a backup are unverified literal text and may contain secrets; this exclusion applies to newly recorded events. Displayed/copied/exported fields escape controls, backslashes, and invisible Unicode formatting or separators; stored backup fields remain literal. Opening a backup combines its events with this session's events without trusting timestamps or deduplicating records, then applies the retention bounds and combines discarded counts. Entry-only files preserve this session's existing log as well. The debug history is bounded by 10,000 events and 512 KiB of serialized UTF-8 JSON event data, with each event field limited to 300 characters. Runtime eviction removes the oldest events and increments a visible discarded-event count. Complete-backup parsing rejects invalid counts, oversized fields, or a log exceeding either bound; it never silently trims an imported log. Older backups without a discarded count default to zero. The whole-document and encrypted-file limits are unchanged. The displayed 400-event page does not limit Copy, Export, or complete backups.
  • Inserted multisig note references contain only a descriptive name, threshold, and ordered public co-signer fingerprints, with missing origins retained as unknowns. They never install wallets or identify keys for derivation. Import validates reference thresholds and fingerprint shapes; ordinary note text remains untrusted text, never HTML.
  • The Journal's Clear journal control requires an explicit discard choice. Its confirmation also offers a backup download and Cancel; both preserve the open Journal. Starting a download does not prove the browser saved the file, so it never automatically clears the Journal. Confirmed discard wipes the Journal's password, entries, notes, pending and archived key inputs, snapshots, and log on a best-effort basis. Keys still open in Key Station and its unfinished draft remain available. Pagehide cleanup remains unconditional and does not open this confirmation.
  • A complete Journal download seals entries, notepad pages, managed/ignored source inputs (including an unfinished Key Station form), saved historical snapshots, the current private recovery snapshot, and the log in one authenticated payload. The on-screen reveal controls independently govern current and historical display, copying, and separate snapshot exports; they do not omit recovery material from a complete backup. Unfinished inputs are captured verbatim and restore as unverified pending inputs with fresh IDs; they cannot overwrite an existing draft or install cached outputs. Empty forms are excluded. Journal creation, opening, and collection refuse an overflowing input inventory or an active key derivation before changing state. Standalone derivation has no Journal inventory limit. Revealing one report never reveals the other. Live snapshots mark private labels and values at their formatting sites; only those explicit ranges receive private field styling. Saved and opened snapshots recognize the app's report headings and field layout for display styling only. This does not validate keys, infer wallet state, or establish trust in the saved contents. Unknown report text remains plain, and all text is inserted as literal text nodes, never HTML. The entire saved report stays behind its own reveal control and private copy path, regardless of individual field colors. Formatting preserves the exact report text used by copy and export and adds no metadata to the backup or export format. It uses document version 3 inside the unchanged version 2 encrypted envelope; entry-only version 2 documents remain readable. Every component is parsed and bounded before installation. Complete backups allow up to 2,097,152 UTF-16 code units of combined plaintext, providing room for the new sections around legacy records. Legacy documents and individual fields keep their existing 1,048,576-unit limits. Downloaded JSON still cannot exceed 4 MiB; UTF-8 expansion and envelope overhead can exhaust that limit sooner. A larger backup is refused rather than silently truncated. Imported snapshots are untrusted historical text and remain concealed until revealed; they cannot install live wallets or session state. Backup-only snapshots omit recomputable HD address/WIF rows and multisig address rows while retaining root/seed/account recovery material, descriptors, and BIP-85 child secrets. Formatter failure refuses the backup. Existing historical text is never truncated. An optional validated offset identifies the most recent appended report for comparison only; a changed capture time alone or an empty restored session adds no duplicate. New derived reports preserve all earlier recovery text within the same limit. Historical snapshot text is retained by default. An explicit, confirmed removal drops it from this Journal's display and future backups without changing the current session, notes, or key inputs. A confirmation captured before Journal Clear or replacement cannot remove a newer snapshot; downloaded files are unaffected. The no-password acknowledgement applies to the entire backup. Restored key inputs still require fresh derivation, including when the backup was password protected. The whole backup always uses the Journal's password setting. Historical entry-only records remain readable and are preserved in complete backups; the interface no longer creates manual entries or duplicates derived keys into new entry records. Editing an existing record is explicit. Temporary fields are scrubbed when editing ends, and stale callbacks cannot change a replacement Journal. Changing recovery material removes its unverified historical wallet link. Complete backup refuses an open record editor so an unsaved draft cannot be mistaken for backed-up content. Section exports, including Debug log, follow the same Journal password setting. The read-only Session report viewer accepts only authenticated snapshot or debug log exports using the open Journal's keys, bounded by the same 4 MiB file limit. Report contents are untrusted literal text and start concealed, regardless of export kind. Revealed text uses the shared private copy path. Close, automatic concealment, Journal Clear, and pagehide drop the viewer's text and invalidate pending reads; it never installs wallets or appends imported report text to the log. Clear debug log offers Export first, Clear, and Cancel. Export first leaves the data intact and requires a separate explicit Clear after download handoff; dismissing the dialog invalidates its pending export. It rejects stale confirmations after Journal replacement or teardown. It scrubs the old events on a best-effort basis and starts a fresh log with one clear event. Pending exports cannot hand off the old log after Clear, and pending copy/export outcomes cannot repopulate it. A pending native clipboard rejection cannot start a fallback copy of the cleared log. Clearing cannot retract text already sent to the clipboard or files already downloaded. Copy and export capture all retained events before recording their own outcome. A download-started event confirms only browser handoff, not a saved file. Exports retain the session-log envelope kind for compatibility.
  • Keys lives behind the same unlocked Journal gate. Its .elkeys exports reuse the Journal's deterministic export encryption and optional password; the Key Manager does not generate a salt, nonce, password, or key material. Key exports include all available and archived source inputs; there is no inclusion selection that silently changes export scope. Version 2 vaults store source inputs/settings, not cached wallet results. Both version 1 and 2 imports discard cached results, claimed identities, file-local IDs, and any claimed verification state. A present portable passphrase must be a string; malformed passphrases reject the complete file before preview or mutation, including when they occur in archived inputs. The import preview names the inputs and counts archived entries. Confirming installs them and derives active inputs; archive-only files stay archived. Canceling the preview installs nothing. Imported and restored inputs, including archived entries, cannot supply wallet outputs before fresh derivation. A complete backup restores active inputs as pending and keeps archived inputs archived; Derive all pending starts derivation of the pending inputs. Restore and derive uses that same fresh-derivation path for one archived input set, preserving the restored inputs if derivation fails or stops. Derivation uses each input's saved chain and rejects unknown chains or a chain incompatible with the input's network family. Import matching uses the freshly derived full-root identity or a single key's compressed public key, never a four-byte fingerprint or a file's claimed identity. Ordinary manual single-key derivation is unchanged. Exact setup reuse also requires matching network, scripts, derivation paths and ranges, purpose settings, and recovery capabilities. It preserves the existing station object and archives the imported source inputs. If a reviewed draft changed those inputs, reuse also preserves the corrected inputs as a distinct archive entry; archive capacity is checked before either source is consumed. A different setup requires a choice to keep the existing setup, add a separate one, or stop the remaining derivations. Keeping the existing setup leaves the imported inputs pending. Account-level imports without a comparable full-root identity are appended conservatively rather than used to replace a key. Failed, skipped, and unprocessed inputs remain pending; completed keys remain when a batch stops. Existing low-entropy and fingerprint-collision checks still apply. Re-derivation proves consistency with the supplied inputs, not that the sender lacks a copy of the key or that the inputs have adequate entropy. During a batch, the unfinished Key Station draft remains a live owner of its secret material while temporary inputs are derived. Completing or stopping the batch restores that draft and the previous station selection; it must not wipe material the draft still owns. Reviewing an input for manual editing asks before replacing a nonempty draft. A reviewed draft keeps its saved chain and setup checks after its original inputs are archived or cleared from Journal. Exact reuse after Journal Clear keeps the reviewed inputs in the draft and uses the existing key without creating another tab or reopening Journal. Import, archive, and restore refuse competing derivations; obsolete restore callbacks cannot revive removed inputs. Journal Clear cancels the batch and restores the draft before clearing Journal content. End Session and pagehide instead clear the retained draft along with the other session secrets. Pending decisions are dismissed and obsolete work cannot commit after teardown. Temporary input copies and dropped wallet buffers are cleared on a best-effort basis; the browser-memory limits below still apply. Archiving is limited to detached inputs and does not unload live Key Station keys; restoring them requires fresh derivation.
  • The Entropy Journal notebook holds entropy the user already produced, not a password manager and not a key generator. The AES-256-GCM key is PBKDF2-SHA-256 (600,000 rounds) of the optional password the user types, with the salt derived from the password itself; the IV is HMAC-SHA-256 of the plaintext under a second derived key. The file is therefore a deterministic function of the password and backup content — the journal never calls a CSPRNG. The trade-off is brute-force cost: anyone holding a password-protected file can test passwords at 600,000 SHA-256 rounds per guess, so a password should have real length. An empty password is allowed to preserve a frictionless local workflow and the same file format, but it provides no access protection: anyone with the file can open every saved section by leaving the password blank. The plaintext never goes to localStorage, IndexedDB, or the network.
  • Low-entropy dice and card transcripts are accepted intentionally so the calculator can be used for deterministic tests, demonstrations, and recovery experiments. EntropyLab does not claim that hashing a short input makes it secure. When the entered transcript is below the recommended entropy target, the result displays a prominent warning with the estimated supplied entropy and says to use it only for testing. Both hashed-dice methods recommend 100 rolls for a 24-word seed; 99 rolls still trigger the below-recommendation warning. Users who intend to secure funds must meet the displayed roll/card recommendation and verify their procedure independently.
  • Input bit counts are capacity estimates under source assumptions, not measurements of unpredictability. Dice estimates assume independent fair rolls; card estimates assume uniform shuffles and independent reshuffles. The Pearson χ² panel checks only face frequencies: even a predictable repeated sequence can receive no frequency warning. Its percentile is not a probability that the source is fair. Neither a favorable frequency result nor a valid BIP39 checksum certifies safe key material. Hashing does not increase the entropy supplied by the user.
  • Brain wallet — lab hashes the exact UTF-8 text with unsalted SHA-256 and treats the digest as BIP39 entropy. Guessable text is stolen coins. A valid 24-word mnemonic from that hash is not the same wallet as hashing the text as a Bitcoin Core private key, and it is not a backup of a Core hdseed or address key. The private-key brain-wallet mode remains a separate scalar path.
  • The vanity grinder (Vanity tab) is deterministic and works only on a Key Station key: a counter either extends that key's BIP39 passphrase (base-62 odometer characters) or selects its BIP32 account index, and every candidate is derived the standard way (PBKDF2 seed, BIP32 path), so it invents no entropy and every result is a setting of a wallet the user already holds. A found passphrase is still a BIP39 passphrase: the words alone no longer recover the wallet, and the tab says so before Update key writes it back to the key. The key's seed words (passphrase grind) or the parent node above the account (derivation grind) are handed to the page's own Web Workers and wiped with the run. Found passphrases live only in page memory, are masked until revealed, and are dropped by the same pagehide/bfcache clearing as every other secret.
  • BIP-85 children are a deterministic transformation of the parent BIP32 root, not newly generated entropy. A BIP-39 passphrase, when present, is part of that root (the same rule COLDCARD uses). Anyone who has the parent seed, the exact passphrase, the application, and the index can reproduce every child; protect the parent for the combined value of all derived wallets.
  • The Lightning tab deciphers LND aezeed cipher seeds and derives node identity keys in WebAssembly; it never creates seeds. The scrypt KDF runs at LND's parameters (N=2^15, r=8, p=1) and both scrypt exports bound the parameters — a 32 MiB working-buffer cap and p ≤ 16 on el_scrypt, only LND's two legitimate parameter sets on el_aezeed_decipher — because WASM linear memory never shrinks, so an unbounded call would grow the heap permanently (32 MiB after the first production decode) or trap on allocation failure and take every export down with it. The scrypt crate does not zeroize its working buffers, so the exports overwrite them after every call by re-allocating and wiping the same sizes; without that scrub, the buffer's first block retains one PBKDF2 iteration of the passphrase, which would let a later reader of page memory test passphrase guesses without paying the scrypt cost. The vendored AEZ v5 module (MIT-licensed, not public domain; see entropylab-wasm/src/aez/mod.rs) erases its expanded key schedule on drop and its key-expansion hasher after use, and a wide zeroing stack frame runs before the exports return to overwrite spilled frame temporaries. The Node suite asserts the derived key and the scrypt buffers are absent from linear memory after a decode; closing the tab remains the only guaranteed erasure.
  • The single-file design inlines all scripts (script-src 'unsafe-inline'), and the secp256k1 WebAssembly module adds wasm-unsafe-eval to the content security policy: Chromium and WebKit engines refuse to compile a WebAssembly module from JS without it. Application scripts are still all bundled at build time, so any inline script injected after packaging is outside the threat model this policy addresses.
  • Material involving loss of funds (incorrect derivations, exfiltration of secret data, injected script execution in the generated HTML, unexpected network egress) is treated as a security issue.

Released PSBT QR transport

The existing PSBT reader accepts static base64/hex, UR and PSBT-only BBQr (H, 2, Z). It reuses the existing QR pixel decoder and UR collector; there is no second camera stack or new runtime dependency. The bounded, synchronous raw-DEFLATE decoder for BBQr Z limits history to the format's 1024-byte window. Compressed input and decoded PSBTs are each capped at 1 MiB, with at most 1000 parts and a separate QR-text limit per frame. Wrong types, conflicting parts, malformed compression and over-budget input are refused. A valid static PSBT cannot replace a partial UR/BBQr transfer; that mismatch stays terminal until reset. Pasted transfers refuse every token after completion, even an identical duplicate.

QR transfer can avoid mounting shared removable media or connecting a USB data device to an offline machine. It still feeds untrusted data through the browser and decoders: it is not protection against a compromised host or parser vulnerabilities. Payloads are never evaluated as code or rendered as HTML, and transport completion is not transaction approval.

BBQr has neither an end-to-end checksum nor a transfer ID. Same-header, same-length fragments from different transfers cannot always be detected. PSBT magic and a successful parse do not authenticate the source. The receiving tool's PSBT-version and transaction checks still apply. Independent, hash-pinned SeedSigner and Coinkite corpora and their development-only regeneration commands are documented in test/fixtures/psbt-qr/README.md.

Preview-only QR observation

The local QR prototype accepts bounded, checksum-validated AEXT UR messages for one session; conflicts cannot replace captured stages and no full verdict is shown before stages 2, 3 and 4 are present. Camera frames and transcripts are kept in accessible memory only, with no automatic file, clipboard, Journal or browser-storage writes. Camera access is a separate permission probe whose tracks are stopped without scanning, including late/cancelled requests. Stop releases camera tracks; Clear capture, End session and leaving the page retire captured data. Completion automatically wipes captured buffers and clears the inspector transcript before showing either result; only non-secret verdict metadata remains. Clearing is best effort and cannot erase browser/OS copies. The decoded text is untrusted input and is never rendered as HTML or included in error messages. Transcript metadata is private, and complete signatures may permit broadcasting the authorized payment. Stage 3 also contains rho: it must remain confidential after completion. A malicious signer can use an operator-known base nonce; its operator can recover the signing key if they later obtain rho and the signature, even when transcript verification passes. Raw transcript export is therefore excluded from this prototype. Live capture adds the browser to the trusted environment holding rho; RAM-only operation reduces retention but does not guarantee erasure. This remains an observer, not an enforcement boundary against a compromised host. Camera pixels use the shared quircs WASM decoder and its preview worker. Camera stop/restart, disconnect, Clear Capture and completion retire the worker through its scrub/terminate lifecycle; stale replies cannot enter a capture. Accessible pixel and returned payload buffers are wiped. Retirement requests a scrub, but waits up to four seconds while busy, or 250 ms while idle, for an acknowledgement. The shared decoder returns a scrub result, which the observer does not currently surface; an unresponsive worker may be stopped before it scrubs transferred frames or WASM memory; termination does not prove zeroing. Immutable decoded strings and browser/OS copies cannot be reliably zeroed either. Camera cleanup continues even if decoder retirement throws. The shared UR collector handles fountain assembly and wipes retained fragments on completion, conflict, invalid assembly or reset. The observer preserves its narrower type, frame, fragment and message limits and canonical CBOR envelope checks. The checksum field additionally accepts the reference encoder's fixed-width uint32 form even for small values; other fields retain canonical checks and the assembled message must still match its CRC. Nonzero fountain padding is refused. Clear Capture and End Session reset the collector. Foundation Devices-derived UR notices remain under src/licenses/.

The QR observer's current preview also checks every supplied signature slot against a BIP143 SIGHASH_ALL digest independently reconstructed from the stage-3 PSBT. A transcript-only pass cannot bypass this check. This validates supplied slots under the PSBT's UTXO claims, not complete input coverage, wallet ownership, chain-state availability, destination/fee approval, coordinator policy, or the actual broadcast transaction. Both results require explicit acknowledgement via Clear Capture; Escape/backdrop cannot dismiss them. Acknowledgement resets the result but does not make a failed transaction safe. Optional post-capture transcript transfer was removed because completed transcripts are no longer retained.

The QR observer supports PSBT v0, SIGHASH_ALL, native P2WPKH, P2SH-P2WPKH, native P2WSH standard m-of-n multisig and P2SH-P2WSH standard m-of-n multisig. All input contexts are checked. Already-finalized inputs are refused with TRANSACTION_ALREADY_FINALIZED: a conservative observer scope limit, not a tamper finding. Existing partial signatures do not by themselves finalize an input.

The pasted transcript follows the confidentiality lifecycle described above: plain window blur preserves it; tab hide, idle timeout and print retire it. QR capture still pauses on every conceal trigger, including blur. Incomplete captured messages remain in memory until Clear Capture, End Session or page exit. Clearing remains best-effort. Coverage counts/indexes retained in the result are transaction metadata, not cryptographic secrets; Clear Capture retires that result too.

Released PSBT camera lifecycle

PSBT scanning opts into continuous acquisition on the existing camera controller. Other consumers retain its one-shot default. A capture owns one stream and one deadline across parts, with at most one decode in flight and one queued frame. Opening another PSBT scanner releases its predecessor. Stop, Close, conceal, tool/workspace teardown and completion invalidate the capture before external callbacks; late grants and decoded payloads cannot write a field. An existing field still requires explicit replacement.

A visible window blur while camera permission is pending preserves only that pending request. At activation the document must be visible and report hasFocus() === true; an unavailable or throwing focus API fails closed. Active blur, tab hide, print, idle and explicit cancellation still stop capture. The ordinary private-value conceal sweep is not bypassed by the permission-prompt exception. Supersession and destruction leave the capture stopped, and activation callbacks that stop it cannot allocate a stale timer. Browser/OS copies and camera buffers remain outside reliable erasure.

What the page can and cannot erase

EntropyLab overwrites the secrets it holds once you are done with them, on a best-effort basis, but a web page cannot erase everything it touches. This is where the line is.

What the page erases. While a key is loaded, the page holds its secrets as bytes it can overwrite: the seed's entropy and seed, private keys, HD key nodes, and a BIP39 passphrase or mini key you typed. Each station that uses the key holds a copy of its own, kept the same way. Clearing a key, clearing a station or ending its session overwrites those bytes with zeros; a key two tabs share is overwritten once neither uses it. Leaving or closing the page does the same when the browser runs the page's cleanup, which it does not always do: a mobile browser that ends a tab in the background, or a browser that crashes, skips it. That same cleanup ends the PSBT/Nonce session completely (its reports included), resets every Multisig form, and empties the panels that echo what you typed (dealt cards, the worked calculations, the fairness tally, the progress lines) and the two dialogs (the value editor and the QR view) — the dialogs also drop their contents the moment you close them. Clearing the Journal empties the session snapshot, the notepad, and the debug log, including imported historical snapshots; reopening restores only the data held in the saved journal file. The WebAssembly modules overwrite every buffer passed in or out and their working stacks after they run, and the PSBT module also wipes the whole-file copies its exports assemble. Vanity shuts its workers and their module down when a run ends. The browser can still make copies of its own while it manages memory, which the page cannot reach.

Private readouts disable browser text selection with user-select: none, including displayed seed words and per-address WIFs. Copying uses a deliberate clipboard icon beside the label or value's table row; clicking the value itself does not copy. The controls read the current shown value at activation and do not keep secrets in their attributes. Concealed values have no displayed copy control. Editable input fields still support normal selection and editing. Public derivation values remain selectable and copy when clicked; their labels offer a clipboard icon when no QR button is available. Public copy controls read the current value, and shortened public previews copy the complete value. This reduces accidental selection and copying; it does not hide revealed text from the browser, extensions, screenshots, or developer tools, and does not protect clipboard history or sync.

Copying can also leave copies in the browser's own processes after End session and tab closure. In the Windows 11 measurements described in #816, Edge 154.0.4258.53 retained copied seed words until Edge itself quit. Quit the browser completely after use; ending its processes releases their memory but does not prove that every copy was erased.

What the page cannot erase. Some copies stay in the browser's memory until the browser reuses that memory. The page can let go of them, but cannot overwrite them:

  • Text you type or paste. A field's value is text, and the browser's editor, undo history, spell checker and on-screen keyboard may keep copies of their own. Clear empties a field by assignment, which also drops that field's Undo history in Chrome, Edge and Firefox (measured 2026-10-27); earlier copies can still sit in browser memory until it is reused. The Key Station's BIP39 passphrase field is the exception: it shows one bullet per character and keeps the passphrase out of its value. The passphrase is kept in a form the page can wipe and reaches the seed as bytes. This reduces copies; it does not remove them. Each key still arrives as a one-character string, a paste or an input-method word arrives as its text once, and showing the passphrase builds it. In BIP39-word mode the field holds the text, as other fields do.
  • Text the page builds from a secret: revealed seed words, WIFs, xprvs and hex, SeedQR, the recovery sheet, downloads, and what a copy button puts on the clipboard. The few tools that take the words as text build them too: the Silent Payments key field, the Vanity passphrase grind, and the Journal.
  • The Journal and the Key Manager. The notepad and every entry are text, and so is a file once it is decrypted.
  • JavaScript numbers. The Silent Payments calculations turn a key into a BigInt, and briefly into hex text.
  • Live copies inside dependency objects, and the per-pair heap copies rust-bitcoin and serde_json make while the PSBT module parses or rebuilds a file. The crypto module erases freed Rust heap allocations even when a dependency exposes no erase API; it cannot erase an object still in use. End session overwrites both modules' whole memory with the patterns 0x55, 0xAA and 0xFF and then zeroes it, which removes these too.
  • A Vanity grind stopped mid-run. Its workers are terminated, not wiped: termination is a hard kill, so the worker never runs its own wipe and its memory — the seed words and passphrase it grinds on — is freed unzeroed. Only closing the tab reclaims it. (A grind that finishes or is stopped gracefully wipes itself first.)

Other copies are outside the browser, where the page cannot reach them at all. They can outlast the page and the browser, and some outlast a restart:

  • The clipboard. It belongs to the operating system. Clipboard history (Win+V), cloud clipboard sync, Apple's Universal Clipboard and clipboard managers keep their own copies, possibly on other devices, and EntropyLab cannot remove them.
  • Anything the operating system writes to disk. Swap, hibernation and crash dumps can hold a copy of the browser's memory, and no web page can prevent or erase that. Deleting the hibernation file afterwards does not reliably erase it on an SSD.

What the page keeps from other software. Some browser features and extensions copy what the page shows or a field holds, and send it off the computer or keep it where the page cannot erase it. The Content-Security-Policy cannot stop them, because the browser or the extension sends the text, not the page. Each offers an opt-out, and EntropyLab uses it:

  • Browser translation. Chrome's and Edge's built-in translators send the page's text to Google or Microsoft. Everything that shows a seed word, a key or a typed secret is marked translate="no", the preventive opt-out for browsers that honor it. EntropyLab warns when it detects Chrome/Google translation through translated-ltr / translated-rtl classes on the document root or Edge/Microsoft translation through _msthash, _msttexthash, or _mstmutation attributes anywhere in the document. It checks at initialization and observes relevant attribute changes and inserted subtrees. Detection opens Important, keeps the warning visible even if markers disappear, and records one security-log event through the detection callback. This is best-effort, browser-marker-based detection after the fact, not prevention or proof of which text was sent. The markers are not a security boundary or a guaranteed future browser API. Firefox translates on the device.
  • Writing aids. Edge's text prediction, which sends what you type to Microsoft, is off for the whole page. Every field opts out of Grammarly, which sends field text to its servers whatever the spell-check setting.
  • Password managers. Every field except the Journal's file password opts out of 1Password, LastPass, Bitwarden and Dashlane, so a BIP39 passphrase is never offered to a cloud-synced vault.
  • Session restore. Chrome saves field contents in its session-restore files on disk unless a field is marked autocomplete="off". Every field is.
  • The screen. Revealed private values are masked again when the window loses focus or is hidden, and after five minutes without input, so that Windows Recall, a screen share or a phone's app-switcher picture is less likely to catch them.

These opt-outs only work when the software honors them. They do not stop an extension that ignores them, or one written to steal.

What to do about it.

  • For real funds, use a dedicated computer that stays offline, with full-disk encryption on and hibernation off before you load a key. The computer hardening checklist gives the steps for Windows, macOS and Linux, and the browser settings that copy what is on the page.
  • Developers can inspect browser-memory residue with the residue audit harness (npm run test:residue), which drives Chrome/Edge with a public fixture, requires a clean baseline and positive controls, and scans process captures for actual derived secrets. The positive capture precedes output and clipboard verification; those checks return digests, never private-key text, through the debugging pipe. Missing captures invalidate the run; uncalibrated needles prove nothing. Its zero is not proof, and automation can add copies — see the doc.
  • Avoid the clipboard for secrets where you can. If you use it, turn off clipboard history and sync first.
  • When you are done, press End session in the header. It wipes the page, zeroes the WebAssembly modules' memory, empties the clipboard if EntropyLab copied something there (as far as the page can tell — it cannot read the clipboard to check), and asks the browser to close the tab. Closing the tab releases its resources, but the browser's main process can retain copied secrets as described above. A tab you opened straight to the file closes; if it stays open, close it yourself. Chrome and Edge keep running after the last window closes unless "Continue running background apps" is off in their System settings.
  • Then close the browser and restart the computer. That is a precaution, not a guarantee: a restart does not erase memory, and its contents can survive a short power-off.
  • None of this protects a computer that is already compromised: malware or a malicious browser extension can read a secret as you type it.

Release signing keys

Releases are verified with the detached signatures in SHA256SUMS.asc (instructions in that file's header). Each signer's public key is committed under keys/; the production deploy imports keys only from there, never from a release's KEYS file. The v1.0.0 signers and their keys:

Signer Key fingerprint Status
Portland.HODL 3428 CBB5 4C36 9D8A F14E F600 C801 EE1D 5285 101E
w-s-bitcoin 542E CCA3 B5CB 74CE C957 29B3 92C2 1496 202E 3774
timechainb 63EF 760E E641 A585 16D5 4930 F0B7 D606 C6FD 9D52
MrHodlX 6443 4EE4 8A96 C38E 78B7 875F 4E7E 416E E17D 237C revoked (announced 2026-10-30)

MrHodlX's key 64434EE4… is revoked. It was kept on a computer later found to be compromised. Treat any signature from it as untrusted, including its block on v1.0.0. v1.0.0 remains verifiable with the other three signatures. Import keys/MrHodlX-64434EE4-revoked.asc so GnuPG marks the key as revoked. Its revocation certificate was generated together with the key, so GnuPG shows the revocation dated 2026-09-29 with no reason given; it is a full revocation all the same, and GnuPG flags every signature made by the key.

MrHodlX signs with an interim key: DB19 EF73 4874 43AA EAC2 6687 17AB DC5F 9867 B54F (expires 2027-01-31; keys/MrHodlX-DB19EF73.asc). Before trusting any new key, confirm its fingerprint with the maintainers through more than one channel.

Reporting a Vulnerability

Please report suspected security issues privately through GitHub Security Advisories rather than opening a public issue. If private reporting is unavailable, reach the maintainers through the official website.

Include the version, the affected input type and derivation path if relevant, and a description of the impact. A maintainer will acknowledge the report and coordinate a fix; scope it as narrowly as needed to reproduce responsibly.

Disclaimer

This software is provided without warranty of any kind — no express, no implied, no promise it work or fit any purpose — under The Ooga Booga License, which dedicates it to the public domain. The caveman words mean what The Unlicense means. Keep verified backups, and use it at your own risk.

There aren't any published security advisories