Specifications

What Bitcoin Witness supports, what it checks, what it produces as of September 2026, and where its boundaries are. We will be updating this page as the development continues.

An air-gapped verification layer for your self-custody setup.

Bitcoin Witness independently checks the work the other layers produce (seeds, addresses, extended public keys, multisig setups, backup formats, descriptors, signatures, etc.) and turns those checks into secret-free documents your heirs, cosigners, counterparties and auditors can use. It can sign transactions offline too, but it is a verifier first. See who it’s for.

Layer, function, tools at that layer, and what the verification layer does there, with examples.
Self-custody layerFunctionTools at this layerWhat the witness does in this layer
BuyAcquisitionExchanges, P2Pnot this layer
GenerateEntropy, the seed itselfDice, coins, a wallet's RNGWarns about patterns in your own dice or coin throws and estimates their entropy (no hardware RNG in our seed code). See examples
StoreHot / cold custodyHardware wallets, multisigRe-derives the wallet definition, descriptor, checksums and cosigner keys. See examples
BackupSeed preservationSteel plates, paper, sharesProves the backup rebuilds the expected wallet across standards. See examples
AccessSpending, signingWallets, PSBT toolingAudits PSBT files and signatures for privacy and exfiltration. Confirms a key controls an address today. See examples
InheritEstate transferAttorneys, estate firmsAssembles a secret-free, optionally GPG-signed folder an heir, attorneys or a multisig group can act on. See examples
RecoverDisaster recoverySeed restoreRehearses the restore in advance, singlesig or multisig. See examples

What it is not: not a daily-driver spending wallet · not a multisig coordinator · not networked · not a custody service · not tamper-evident hardware (it runs on a general-purpose Raspberry Pi, its defenses are the air gap, encryption, and a pinned, verified supply chain).

Code: no compiled binaries or firmware are produced by the project itself. The whole trust-relevant codebase is a number of Bash and Python scripts. Bundled third-party tools (Electrum, Sparrow, KeePassXC, Ian Coleman's BIP39 tool) are open source and independently verified during installation (which itself is a script, not a binary).

As of September 2026 we support the following modern and legacy standards.

StandardWhat it is
BIP32Hierarchical deterministic key derivation, the tree every modern wallet derives addresses from.
BIP39The 12/15/18/21/24-word seed phrase, verified in all 10 official languages.
Electrum seedElectrum's native seed format, distinct from BIP39. Verified through the same seed workflow, with its own derivation and salt.
BIP44 / 49 / 84 / 86The four address types: Legacy (1…), nested SegWit (3…), native SegWit (bc1q…, Bech32), and Taproot (bc1p…, Bech32m per BIP350). All derived and confirmed.
BIP143 / BIP341The SegWit v0 and Taproot sighash algorithms: the exact transaction pre-image a signature commits to, and the value the Dark Skippy nonce audit recomputes against.
BIP48Multisig account structure (2-of-3 and similar). Verified and signed (P2WSH / P2SH-P2WSH).
BIP67Lexicographic ordering of public keys inside a multisig script: the sortedmulti rule that makes a 2-of-3 derive the same addresses on every wallet regardless of the order cosigners were added. Applied on both derive and sign.
BIP85Deterministic child seeds: one master seed derives many independent BIP39 mnemonics by index. Generated in all 10 BIP39 languages.
BIP352 / BIP392Silent Payments. Derives and confirms your reusable sp1… address and verifies a sp(…) descriptor checksum. Verify-only: no chain scanning.
BIP380 / BIP388Output descriptors and wallet policies, the compact "recipe" that rebuilds a wallet's addresses. Checksums verified. Imports supported (Bitcoin Core, Ledger / BlueWallet interop).
SLIP-132Extended-key version bytes: the prefix that labels an xpub with its address type. Decoded and derived for single-sig (ypub/zpub) and multisig (capital Ypub/Zpub).
BIP389Multipath descriptors: the /<0;1>/* shorthand that packs a receive and a change branch into one string. Accepted. The reversed /<1;0>/* is refused rather than silently show change addresses under the "receive" heading.
BIP-129 (BSMS)The standard multisig setup file cosigners exchange. Verified.
BIP-93 (Codex32)A paper-and-pencil-checkable way to split a backup into shares. Bitcoin Witness verifies Codex32 shares as part of its backup-format breadth.
BIP322 / BIP137Prove control of an address by signing a message. No coins move. Format auto-detected on verify. Signing covers 1…, 3… and bc1q…, a Taproot bc1p… key-path signature made elsewhere is verified, but Bitcoin Witness does not message-sign Taproot itself.
SLIP-39Shamir M-of-N share backup (Trezor-style). Recover and generate, validated against all 45 official test vectors.
Seed XORN-of-N XOR shares (Coldcard-style): combine/recover the original seed from all parts, or split a seed into parts, with an optional decoy mode.

Our code only ever checks.

Every fund-spending signature comes from Electrum or Sparrow, both mature, widely-audited signers. Bitcoin Witness ships no production Schnorr signer, and its own ECDSA is used only where a signature can never authorise a spend.

Bitcoin Witness's own BIP340 / RFC6979 code is used in exactly two places, neither of which can ever authorise a spend: message sign and verify (BIP322 / BIP137, whose signatures spend an impossible outpoint or sign the "Bitcoin Signed Message" magic, so they can never move coins), and the independent nonce audit on every signature it produces. The signing itself is delegated to the trusted third-party signer. Our math checks that signer's output, it does not replace it.

A leak-proofing check on every signature we make.

Dark Skippy (disclosed August 2024, darkskippy.com) is a real attack where a malicious signer hides fragments of your seed inside its signatures and leaks the whole thing across a couple of transactions.

Each signature produced on the station is checked against an independently recomputed deterministic nonce. A mismatch blocks export. The defense works because a second device redoes a deterministic signer's arithmetic on every signature. For ECDSA the recomputation follows RFC 6979 and is grind-aware, replaying the low-R grind. For Taproot it follows BIP 340 with a deterministic aux_rand = 0. We have searched for another consumer signer that performs this recomputation and would welcome a counterexample. A confirmed leak is quarantined: the signature file is renamed, refused for export, and never broadcast. Nothing is deleted. Implemented in sign-psbt.sh + psbt_handler.py.

The scope is important: a nonce can only be recomputed by the party that generated it. A signature that arrives already made (from a hardware wallet, from a cosigner) is only checked against the key it claims to come from. Dark Skippy is an attack on the device that signs. We defend the signing that happens on our device. We do not audit a nonce we did not generate.

Five boundaries. Named honestly.

BoundaryWhat it defends
1. Air gapNetwork exposure. WiFi/Bluetooth disabled at four independent layers (firmware, kernel modules, firmware-file removal, service masking + rfkill). The live air-gap state is re-checked when the menu starts, on every return to the menu, and again before each workflow.
2. LUKS at restDevice theft. /home is a LUKS2 / AES-XTS volume unlocked by passphrase at boot. Workflow secrets never page to disk. Confidentiality at rest, not integrity. Optional (INCLUDE_LUKS=0 leaves /home in plaintext).
3. Pinned supply chainTampered downloads. Upstream tarballs are GPG-verified against hand-pinned 40-char fingerprints. The Debian packages ride a digest-pinned base image and a SHA-256 manifest. Verification runs host-side as the bundle is prepared, and the manifest is anchored by a composition hash you carry across on paper.
4. Input validation + nonce auditMalicious wallet software. PSBT size caps + the RFC6979 / BIP340 Dark Skippy nonce check on every signature produced.
5. Trust-base integrityA tampered trust base (evil-maid, swapped SD card). The appliance prints a hash of its own code to compare out-of-band, catching an altered card. It detects persistent tamper, not tamper-evident hardware and not remote attestation.

The reasoning and the disclosure contact are on the Security page.

A supported Raspberry Pi on Raspberry Pi OS Bookworm 64-bit.

TierHardware
FullPi 4B (2–8 GB), Pi 5 (4–8 GB)
SupportedPi Zero 2W (512 MB): Electrum-first, Sparrow not recommended

All models are aarch64 (ARM64). Host-side assembly scripts run on macOS, Linux, or Windows via WSL2 (Docker required).

Every version is pinned.

Wallet versions are pinned exactly; the JDK to the Temurin 25 LTS line, and Debian packages to a digest-pinned Bookworm snapshot.

ComponentPinned version
Electrum4.6.2
Sparrow Wallet2.2.3
Eclipse Temurin JDK25
BIP39 standalone tool (Ian Coleman)0.5.6
Python3.11
Debian basebookworm

Accept · sign-our-leg · relay.

ClassWallets & how they interoperate
Air-gap signersColdcard, Foundation Passport, Sparrow and Jade were bench-tested over microSD; SeedSigner and Krux share the embit engine we test against. Descriptor or Coldcard .txt import covers multisig.
CoordinatorsBitcoin Core, Specter, Nunchuk. These interoperate at the PSBT / descriptor layer. Bitcoin Witness verifies and relays coordinator-produced PSBTs and signs its own leg of a sortedmulti multisig. Wallets generated in Bitcoin Core are supported: import the descriptor and the station derives its addresses independently.
USB-only caveatTrezor and BitBox02 sign over a live cable. Bitcoin Witness has no USB-host signing role, so it cannot drive those devices directly. It can still verify and relay a coordinator-produced PSBT from a Trezor / BitBox02 multisig.

Standard PSBTs (BIP-174 v0 + BIP-370 v2) are read and relayed. Single-sig and sortedmulti multisig are signed. Emitted formats are validated by a recurring differential wallet-compatibility audit against independent engines (Bitcoin Core, Electrum, Sparrow/drongo, BDK, embit, btclib).

What's in the build.

Verification and signing

  • Guided, step-by-step verification of a seed phrase or an extended public key, generation of a new seed phrase from dice / coin entropy, offline PSBT signing, document encryption and decryption, and a health check of the station itself
  • Multisig verification across BIP48 P2WSH, P2SH-P2WSH and legacy P2SH. Multisig signing on P2WSH, P2SH-P2WSH and legacy P2SH
  • Taproot (BIP86) derivation, and key-path signing with the Sparrow module
  • Message sign / verify (BIP322 + BIP137)
  • SLIP-39 and Seed XOR backups. Codex32 verification (verification only: the station does not generate Codex32 shares)
  • The Dark Skippy nonce audit on every signature produced
  • Timestamped Confidence Reports
  • See full walkthrough demo and report types here

Packages and supporting checks

  • The Inheritance Package, the complete secret-free estate folder
  • Verification / Attestation Certificate package
  • Proof-of-Control package (self-sovereign proof of address control)
  • Multisig Onboarding package
  • Supporting checks: a descriptor diff that tells you two descriptors describe different wallets, never that coins moved or that an address is safe to fund. A PSBT privacy pre-check that flags round amounts, change fingerprinting, address reuse within the one file and consolidation: heuristics, advisory only, and a clean report does not mean a transaction is private
  • Heir rehearsal mode
  • A descriptor privacy audit that flags structural privacy leaks in a wallet descriptor (address reuse, script-type mixing, a derivation path that reveals which software made it, Taproot/legacy inconsistency), as advisory notes only, never a refusal. The descriptor still verifies and a clean report does not prove a wallet is private
  • Saveable, optionally GPG-signed audit records: an entropy-quality record for a dice / coin seed, and a signature / nonce-audit record from a signing session, each secret-free by construction, so it can leave the box and be re-checked later

Read it before you trust it.

The free xpubverify.py tool is published separately under the MIT license. Clone it, read the source (pure Python stdlib, one sitting) and run the test suite, which prints its own totals. No dependencies, no network.

audit xpubverify Shell
# 1. Clone the public repo
git clone https://github.com/BitcoinWitness/xpubverify
cd xpubverify

# 2. Read the source (pure Python stdlib, wc -l it yourself)
less xpubverify.py

# 3. Run the test suite (no dependencies needed)
python3 test_xpubverify.py
# Expected: 405/406 passed, 1 SKIPPED, 0 FAILED
# the SKIP needs an optional reference lib: pip install embit
Read the source on GitHub →

Keep reading

See it work, screen by screen.

Every workflow on this page is captured in the walk-through: the menus, the refusals, the report at the end.