Every claim, traced
to the code.
This page states what Favilla KEY does. Every statement has been traced to a specific path in the firmware source and the manufacturing tooling. Where a protection has a limit, the limit is stated with the same weight as the protection. Where something is a production step, or is still on the bench, it is labelled as one. Last checked against the source on 18 November 2026.
One phrase.
Every key.
Your keys are generated on the device, during setup, and are never transmitted. Setup runs with the radio off. You choose where the randomness comes from.
Two chips draws one 16×16 grid from the SE051's certified true random number generator and another from the camera sensor, shows you both on the screen, and XORs them into the value it hashes, so neither chip vendor can determine your key alone, and you can repeat the mixing step by hand at Seed check. The secure element is a sealed box whose certificate you are trusting; the camera is a sensor whose output you can see. Together, a backdoor in either one has to also beat the other. Dice lets you roll a standard d6, 50 or 99 times; the seed is a published function of your rolls with no device secret in it, so you can recompute the same result on any offline machine and confirm the device used your rolls and nothing else.
Nothing else goes in. The firmware does not mix in the ESP32-S3's own generator: the radios are off during setup, the condition its vendor documents as degraded, and we would rather leave it out than count on it. There is no silent fallback either: a camera layer below its 128-bit pass line, or two layers that both come back flat, stops seed generation with an error rather than being quietly replaced. (A flat secure-element layer on its own does not: XOR with a constant changes nothing, so the camera simply carries the seed, and you would see the flat grid on the screen.)
We measured these sources on our own hardware and two of the results contradicted what we believed. The write-up is in Three questions about randomness.
From one standard BIP-39 recovery phrase (12 or 24 words) come three things: your Nostr identity, via NIP-06; your Bitcoin wallet, via BIP-84 for single-sig and BIP-48 as a multisig cosigner; and, with the Vault (in testing, see 06), the master secret behind your restorable passkeys and saved passwords. One phrase, written down once, restores everything: a replacement KEY restored from the same words is the same Nostr account, opens the same wallet, signs in to the same sites, and can open your encrypted password backup. An optional BIP-39 passphrase can be added at setup or at restore, typed on the buttons or scanned from a QR, either baked into the sealed seed, or asked for at each Bitcoin session so one set of words carries any number of wallets. Either way the device shows you the wallet fingerprint so you can confirm which wallet you are in. The passphrase changes the Bitcoin wallet only: your Nostr identity and your passkeys come from the words alone. You can also import an existing nsec; the device then operates as a Nostr-only signer, since an nsec alone carries no Bitcoin seed and no passkey master.
Never in plain form.
Anywhere.
Your Nostr key, your Bitcoin seed and your passkey master are stored as AES-256 ciphertext, wrapped twice. The outer key lives inside the SE051 secure element; the inner key lives inside the vault processor (see 03). Neither wrap key leaves its chip.
The Nostr key is kept inside the secure element. The secure element removes its layer only for the vault processor's own encrypted session, and only after your Nostr PIN has opened it; the vault processor removes the inner layer itself and uses the key there.
The Bitcoin seed is kept in a write-once page on the vault processor. Nothing on the main chip can replace it or swap in a seed of its choosing. The secure element removes the outer layer only when two things are true at once: a session that has verified your BTC PIN asks for it, and the door latch reads Bitcoin, a value only the vault processor can produce after a real power cycle (see 04). What comes back is still the inner layer, which only the vault processor can open.
The passkey master (the Vault, in testing) follows the same rule. The secure element removes its layer only for a session that has verified your Vault PIN, with the latch on the Vault door; the inner layer stays the vault processor's. Your saved passwords and 2FA codes are sealed records, each encrypted and authenticated by the vault processor under a key that comes from that master.
One door, one PIN. Each of these keys opens only with its own door's PIN, and that is checked by the secure element, not just by our firmware: the Nostr PIN cannot open the seed, the BTC PIN cannot open the passkeys, and so on. Even a full read of the vault processor's flash from a locked KEY gives none of them.
The main chip's flash holds settings, relays and pairings, and, with the Vault, the sealed password records. Nothing secret is stored there in plain form.
Your identity key
never touches the internet chip.
A Nostr identity key has to be live. It signs the moment something happens on a relay, so the chip that signs is, by design, connected to Wi-Fi. That is exactly what makes a software key fragile: when the key lives in the same processor that parses untrusted network traffic, any remote compromise of that processor can read the key straight out of memory. A stolen identity key is permanent. It cannot be revoked, only abandoned.
So we don't use it there. The Nostr key is used on a vault processor, an STM32G0: a second, deliberately simple chip with no radio and no network stack. The internet-facing processor never holds the key. When a signature is needed, it hands the vault processor a 32-byte hash in a fixed-length command and gets a finished signature back. Everything the main chip can write to the vault processor goes into a fixed-size slot that accepts one exact length; a write one byte short or one byte long is dropped, and there is no command that returns a key. Inside those fixed frames it still reads some structured data: Bitcoin signing requests, passkey and vault requests, the replies on its encrypted channel to the secure element, and, for Emberwill, block headers and proofs. Those readers are small and bounds-checked; the secure-element channel, the vault and passkey requests and the block headers are fuzzed, and the rest are tested against reference implementations. The one time the key exists on the main chip is setup: generated with the radio off, sealed into the vault, and wiped. There is no nsec export.
The Bitcoin seed gets the same treatment. It is opened only inside the vault processor, which derives the keys and signs each input itself. The main chip parses the transaction, hands the vault a fixed-size request per input, recomputes every hash independently, and refuses any signature whose hash or public key does not match. After setup, the seed never enters the main chip's memory.
With the Vault, the same chip does the work for your logins. It derives each site's passkey and signs the login itself, and it computes 2FA codes, so neither a site key nor a 2FA secret ever leaves it. Saved passwords are the one exception, because a password has to be typed: the vault processor opens that one record and hands it to the main chip to type (see 10).
The vault can't leak your key through its signatures either. A signature's nonce is tied to the key, so a dishonest or faulty signing chip could hide key bits in the nonces it picks, and nothing outside could tell. Every Nostr and Bitcoin signature now uses a nonce the vault processor cannot choose alone: the main chip commits to a random value, the vault commits to its part, and the main chip checks the result before any signature is released. A mismatch shows SIGNER FAULT and stops all signing until the next power cycle. We built a deliberately dishonest vault firmware and watched it get caught; the test report has the details.
The result is a property most signers cannot offer: a remote attacker who fully compromised the connected side still could not extract your Nostr key. The key stays on a chip that has no command to reveal it. The worst they could do is ask the signer to sign while they hold that access, bounded by your on-device policy. And that access is not permanent: a physical power cycle evicts an attacker living in memory; one that has written itself into flash is what Secure Boot (09) exists to stop. This holds while Wi-Fi is active, which is the whole point. It is not cold storage, it is a live key that stays isolated even in use.
Being honest about the bar: no connected device is unbreakable, but this one should be harder to compromise than the phone or computer you would otherwise sign on. Those run a full operating system, a browser, and thousands of lines of third-party code, with your key sitting in the same memory. This device runs a small, purpose-built firmware, and the signer that holds your key has no radios and no network stack, and takes only fixed-length commands. Less surface means fewer ways in, and even a way in does not reach the key.
Daily life, money and logins
are different doors.
The KEY has three doors, and you pick one each time it powers on. Each door has its own PIN, and each key opens only with its own door's PIN.
The Nostr door, opened with the Nostr PIN, is daily life: signing, messages, the app, remote signing. It connects over Wi-Fi; a Bluetooth mode, in testing, keeps Wi-Fi off entirely. It has no Bitcoin surface at all: no balance, no addresses, no Bitcoin API. Passkeys and passwords do not open in it either; the KEY tells you to restart into the Vault.
The Bitcoin door, opened with the BTC PIN on the KEY's own buttons, is signing only. Neither Wi-Fi nor Bluetooth is ever started in it, and firmware checks every two seconds that Wi-Fi hasn't been; any attempt halts the device. The BTC PIN never travels over any network, and there is no API that accepts it.
The Vault door, opened with the Vault PIN on the KEY's own buttons, holds passkeys, passwords and 2FA codes. Wi-Fi is never started in it; Bluetooth runs only if you turn it on, to reach a paired Favilla app or to type as a keyboard. It is in the firmware and being tested now (see 06).
One door per power cycle, and that's not a policy setting. Choosing a door closes the other two for that power-on life. The choice is latched inside the secure element and remembered by the vault processor, which only starts fresh on a real loss of power. The only way between doors is a physical power cycle: holding the two left buttons together cuts the battery to both processors in hardware (on USB power, unplug first). The secure element releases the seed's wrap key only against a latch value that the vault processor alone can produce, once it has seen that power cycle, and the value is burned again the moment each unwrap completes. The passkey master works the same way with the Vault's own value. So a remote spend is impossible by construction, and so is opening your logins from the Nostr door.
Wrong PINs. Each PIN has its own retry counter inside the secure element and its own budget. Delays between wrong tries grow from nothing to a full day. A paired phone gets three tries at the Nostr PIN, then remote unlock is refused until you unlock on the KEY; the BTC and Vault PINs are never accepted remotely. After nine wrong tries at a PIN the KEY stops sending it and offers a recovery wipe; your words restore everything. There is no duress PIN.
It refuses to sign what it
can't prove is yours.
Nostr events are signed as standard BIP-340 Schnorr signatures on the vault processor (see 03). The signing mode is set on the KEY and a client cannot override it. Manual, the default, asks for a button press on every event. Selective signs notes, reactions, reposts, zap requests, relay lists and message seals on its own and asks for everything else. Auto signs everything. Relay log-in challenges (NIP-42) are answered automatically in every mode.
Bitcoin signing is air-gapped only. There is no connected signing path at all. Bitcoin exists only in the Bitcoin door, where neither Wi-Fi nor Bluetooth is ever started; moving funds happens exclusively across the camera and screen. The device scans a ur:crypto-psbt QR, you confirm the destination, amount and fee on its own screen, enter the BTC PIN on its buttons, and it displays the signed transaction back as a QR. The transaction crosses the room as light, both ways.
Multisig is supported as a BIP-48 cosigner. Register the wallet descriptor on the device once; it derives and verifies addresses against that quorum, signs its own inputs, and hands anything it cannot prove is yours back unsigned. Single-sig and multisig transactions are kept separate; a mixed PSBT is refused. It is the posture we recommend: with a second signer in the quorum, the KEY never spends alone, and no single device, ours included, is the whole story. Supported: native SegWit single-sig (BIP-84) and P2WSH multisig (BIP-48), plus BIP-137 message signing. Not supported: Taproot, BBQr.
A Bitcoin session starts from a physical power cycle, not a soft reboot that compromised firmware could fake, so nothing from a previous session can be resident when the door opens. The seed is opened only inside the vault processor, which derives the keys and signs each input itself; the main chip hands it a fixed-size request per input, recomputes every hash independently, and refuses any signature that does not match. Each signature asks for the BTC PIN again, and the vault processor re-mints the latch value for it. When you are done the device sleeps; waking it returns to the Bitcoin session, and Nostr stays closed until the next power cycle. Before any of that, the device re-derives every input's key and every change output from your own keys, and anything it cannot prove is yours comes back unsigned.
Your logins,
now in testing.
Status: in the firmware, in testing. Everything in this section runs on our own KEYs today.
Plugged in over USB, or over Bluetooth, the KEY acts as a FIDO2 security key (CTAP2): websites can register a passkey on it and ask it to sign you in. Each sign-in shows the site's name on the KEY and waits for a button press, and your PIN is entered on the KEY, never on the computer. Discoverable passkeys, the kind that sign you in without typing a username, work too.
There are two kinds. A device-bound passkey is made inside the SE051 and can never leave it; lose the KEY and that passkey is gone, which is what some workplaces want. A restorable passkey comes from your recovery words, so a replacement KEY restored from the same words can sign in again. Its master secret is wrapped in the same two layers as your other keys (see 02), and each site's key is derived and used on the vault processor only: the secure element never sees it.
Logins live in the Vault door, with its own PIN, entered on the KEY (see 04). Wi-Fi is never started in it. Bluetooth runs only if you turn it on, and then only to reach a paired Favilla app or to act as a keyboard. In the Nostr door, passkeys and passwords do not open at all.
The Favilla Vault. The same door keeps ordinary usernames and passwords, and 2FA codes. Each record is sealed by the vault processor, and only a limited number can be opened per sitting. The KEY types a login in as a keyboard over USB or Bluetooth, or hands it to the Favilla iPhone app for AutoFill over a channel paired with a six-digit code. On a computer, the Favilla browser extension tells the KEY which site you are on, taken from the address bar rather than the page, and the KEY types the login after you press its button. A 2FA secret never leaves the vault processor: it computes the code and only the six digits come out. The KEY can also tell you which passwords are weak, reused or found in a known breach; the breach check sends only the first five characters of a hash, never the password.
Backups. Your saved logins can be backed up to a Nostr relay from the Nostr door. What is published is the records exactly as they are stored, still sealed, signed by a key that can sign nothing but backups; making and publishing the backup opens none of them. Because the sealing key comes from your words, a KEY restored from the same words can open the backup; without the words, it is unreadable.
Not done yet: the standard on-computer PIN and credential management, and FIDO certification.
Paired by light.
Confirmed by you.
Pairing takes two codes and one glance. Your phone first scans the KEY's own QR to reach it, on your home network or on the KEY's hotspot. Then the browser displays a QR code and the KEY scans it with its camera: the pairing secret crosses the room as light, not as network traffic. Then both sides independently compute a six-digit confirmation code from the freshly negotiated session key, and both screens show it. Pairing completes only when you confirm on the device that the codes match. If anyone interfered with the exchange, the two sides hold different keys and the codes cannot match. A scanned code alone enrols nothing: a browser that doesn't hold the matching private key can't complete the handshake at all.
After pairing, every sensitive request (unlock, signing, messages, status) is individually encrypted and authenticated under the session key, with a per-message counter that blocks replay and a binding to its exact endpoint that blocks reuse. The session key is derived independently on both ends from a secp256k1 handshake, is never transmitted, lives only in memory, and is forward-secret. Over the network, your unlock PIN is accepted only over this channel, never in the clear.
The browser's message cache is encrypted at rest under a key that only your unlocked KEY can produce, held in browser memory only, never written to disk. A phone that's lost or taken cannot decrypt its cached message history without a live connection to your unlocked KEY. This applies to the app served by the KEY; the remote app's cache is not protected this way.
Links that work exactly once.
Remote signing uses NIP-46 with one-time pairing tokens. Each bunker link works exactly once: presenting it enrols that app's key and destroys the token in the same operation. A link that has been used is worthless. It cannot pair anything, for anyone, ever again. The web form of the link carries its secret in the URL fragment, which browsers do not send to servers.
You can mint new app links and revoke any app at any time, including remotely, with one deliberate exception: the pairing that controls the others can be changed only on the device, so a compromised app can never lock you out of your own hardware. And whatever a remote app requests is bounded by the same on-device signing policy as everything else.
The network surface, in one sentence: nothing sensitive answers without a paired, sealed session; the only thing that session can unlock is the Nostr door, three attempts before remote unlock is disabled; and Bitcoin signing, PIN changes, seed display, and factory reset exist only on the device's physical buttons.
Signed firmware.
No remote updates.
Secure Boot V2 on the main processor. The KEYs we build have Secure Boot V2 burned into one-time eFuses, along with JTAG and ROM download locked down. The boot ROM checks the firmware signature from the first instruction, on every boot, for the life of the device. Only firmware signed with Favilla's RSA-3072 keys runs, and signing happens on our provisioning station, which is permanently offline. Plugging in a USB cable does not let anyone load their own firmware onto a factory-signed KEY.
No over-the-air updates. There is no code on the KEY that can fetch and install firmware from the internet. That is deliberate: we can never be made to push a quiet update to one person's device. Updates are signed images you choose to flash over USB. A simple flashing tool for owners is planned.
Flash encryption is not used, on purpose. The main processor's flash holds settings and pairings, and nothing secret in plain form (see 02), so encrypting it would protect little and add a one-way step that can brick a device. It may come later as an option for owners who want it.
The vault processor gets a readout lock. Once its firmware has passed the independent audit, the vault processor's debug and readout access is permanently disabled at the factory, sealing the inner wrap key inside it. Where that stands today: no unit has it yet, and until it is set, someone who opens a KEY and attaches a debugger to the vault processor could read its flash. That read still gives none of your keys: each one needs its own door's PIN at the secure element (see 02). A KEY whose vault processor is not locked says so in red on its boot screen.
Proving a KEY is genuine. Each KEY has an attestation key made inside its secure element at the factory. favillakey.io/verify sends it a fresh challenge by QR and checks the signed reply against our published list, with nothing sent to us.
The limits, stated with
the same weight.
Every security product has limits. Most vendors hope you won't ask. We'd rather you read ours here than discover them in someone else's teardown.
A health check cannot tell you a random source is good.
Our firmware refuses to generate a seed if the camera layer falls below its 128-bit pass line, or if both layers come back flat. It stops rather than falling back to something weaker, and we test that path deliberately. But we want to be precise about what that proves: it catches a source that is dead. It cannot catch a source that is alive and weak. This is not a gap in our implementation; it is a property of the problem. Any generator that produces uniform-looking output passes every statistical test ever written, including the one that just cost Coldcard users their coins. That limit is exactly why the camera is in the seed path, as a second chip the first would have to collude with, and why we ship a dice option: dice is the only path where you can check the result yourself instead of trusting our checks.
We have measured two of our sensors. It is not a budget.
We published raw min-entropy measurements for the accelerometer and the camera, including two results that were worse than we expected and one feature we decided not to ship because of them. Those numbers come from one unit, at one temperature, using estimators we wrote ourselves rather than NIST's reference tool. They are strong enough to have changed our design (the camera's result is why it sits in the seed path, as one half of an XOR with the secure element), and they are not strong enough to budget bits against on their own, so the design does not: if the camera layer were worthless, the secure element still carries the seed, and the reverse. The accelerometer does not contribute to your seed, and the part we measured has since been replaced.
A passphrase cannot be checked, only recognised.
A BIP-39 passphrase is supported, and you choose how it behaves when the wallet is created or restored. Bake it in: the passphrase is applied once, the derived seed is sealed, and the device never asks again; the words plus the passphrase are your backup. Ask each Bitcoin session: the words alone are sealed, and the Bitcoin door asks for a passphrase after the BTC PIN; the vault processor derives the wallet from it on the spot, at most five passphrases per power-on. Every passphrase is a valid wallet, so one set of words carries as many wallets as you have passphrases, and an answer of none, or a decoy, opens a different wallet from the real one. Your Nostr identity comes from the words alone in either mode. The limit to understand: the device cannot tell you a passphrase is wrong, because there is no wrong one. It shows you the wallet fingerprint instead. Check it against the one you wrote down before you fund anything or sign.
The Bitcoin signer is blind, by design.
The vault processor signs the transaction hashes it is handed and never sees the transaction. That is what keeps it parser-free. The consequence: compromised firmware on the main chip could, during a signing session you approved, hand it hashes for a different transaction than the one on the screen. Secure Boot (09) is what stops compromised firmware running at all; the main chip cross-checks every hash it sends; the PSBT parser on the main chip is the component we test and fuzz the hardest. And the practical defence is the one we recommend regardless: verify the outputs in your coordinator before broadcast, and use multisig, so the KEY never spends alone.
Physical access to a powered, unlocked device is a different threat.
The isolation described here defeats remote attacks: an attacker on the network cannot extract either key. It is not the same as defeating an attacker who opens the enclosure and probes the board with equipment. Keys reach the vault processor over an encrypted session the main chip cannot read, but PINs travel from the main chip to the secure element over the internal bus in the clear, and until the vault processor's readout lock is set (09) its flash can be read with a debugger. There is no tamper switch or mesh in the enclosure. A determined physical attacker who can probe the vault processor or the secure element is outside what this design claims to resist. The enclosure, the PINs, the optional motion lock and the air-gapped path raise the cost of physical attacks; they do not make them impossible.
The pairing check is yours to perform.
The six-digit code makes interference visible; it cannot make you look. Confirming without comparing the codes forfeits the protection. That is the inherent ceiling of every code-comparison scheme, ours included.
First contact is trust-on-first-use, in one direction.
Your browser learns the device's identity key on its very first connection and pins it thereafter. An active attacker present on your network at that exact first moment could impersonate the device to the browser; from the second connection on, the pinned key closes this.
An unlocked device trusts its paired client.
Within your chosen signing policy, a paired browser in an unlocked session can request signatures and read messages. That is what pairing means. The physical-button policy, the spend PIN, and revocation are the instruments that bound it.
Idle is handled by sleep, not by a lock.
Locking happens on sleep, on command, when a Bitcoin session ends, and on movement if you turn the motion lock on (it is off by default). By default the KEY sleeps after five minutes and drops its hotspot after two, and sleep wipes the working keys, so an idle KEY does lock, by going to sleep. A stationary, unlocked device with sleep disabled stays unlocked until told otherwise. Nostr signing does not lock the device; only a Bitcoin session closes its door.
In the Nostr door, the radio is up before you unlock.
The network stack comes up when the KEY boots into the Nostr door, before the Nostr PIN has been entered, so a locked device is already reachable on the network. Nothing can be unlocked from there without a paired session and the PIN, and the Bitcoin door is closed regardless. But it is surface, and we say so.
The access point password is not a security boundary.
The device's hotspot password is generated per device on first use and shown on its screen. It exists so your browser can reach the KEY, not as a security boundary. The boundary is the pairing and the encrypted channel, which is why joining the hotspot grants nothing.
Setup is the one time the main chip sees your words.
When you create or restore a wallet, the words and the keys derived from them pass through the main processor's memory before they are sealed into the vault. Setup runs with the radio off, and every buffer is wiped on every exit path, but for those minutes the main chip is trusted. After setup it never holds them again.
A compromised main chip could read your messages while it is in control.
For encrypted messages the vault processor does the key agreement and hands the main chip the shared secret for that conversation; the main chip does the encryption. So firmware that had taken over the main chip could read and forge messages while it ran, though it still could not take your identity key. A power cycle and Secure Boot are what remove it.
A saved password passes through the main chip when you use it.
Passkey logins and 2FA codes are computed inside the vault processor, but a password has to be typed, so the vault processor opens that one record and hands it to the main chip, which types it over USB or Bluetooth or sends it to the Favilla app. Firmware that had taken over the main chip in the Vault door could read the passwords you use while it ran. It could not empty the vault: the vault processor opens only a limited number of records per sitting, and a power cycle and Secure Boot are what remove such firmware. (The Vault, in testing.)
Some signatures are made over a hash the KEY cannot read.
A few large events, such as long follow lists, are too big for the KEY to read, so the app sends them as a finished hash. The KEY can't check what that hash covers, and says so: the request is marked "Hash only" on its screen rather than shown as an event it cannot verify. If you let an app sign some kinds of event without asking, the KEY has to take the app's word for which kind a hash-only request is, so a dishonest paired app could slip one through. Only a paired app can send these at all.
The EAL 6+ rating is the secure element's, and that is the part that guards your keys.
The SE051 is certified to Common Criteria EAL 6+, and it is the chip that protects your keys at rest: it checks your PIN, counts wrong tries, and opens its layer of a key only after the right PIN. That rating belongs to the chip. Certifying a whole device to Common Criteria is not required to sell it, and we do not claim it for the Favilla KEY. What does come before sale is an independent security audit of the device and firmware, which is under way.
Every statement on this page is written to be checked against the firmware source and the manufacturing tooling, which are to be published before the first sale. When the facts change, this page changes.