Why I'm making Faraday
Over the past several months, we've seen what I would personally characterize as a pretty major shift in Bitcoiners' attitudes toward hardware wallets. Over the summer, we all witnessed the heartbreaking Coldcard firmware fiasco unfold. The other major incident that comes to mind as I write this post (although it feels like the number of "incidents" is countless at this point) is the Ledger SIM implant attack. Again my heart goes out to the victims.
So now we come to the heart of the issue, and the reason for Faraday. The people who came through these events not only untouched, but who did so without a worry, were mostly the ones who had rolled their own dice, and run their own "setups" the entire time. These are the people who somehow had the tenacity to believe that they could have a better handle on things by doing it their own way. Rather than following a setup guide that was written by someone else, these people had decided from the get-go that they would feel best if they took care of things themselves.
There are as many keystore setups as there are people, and there is no fully right and no fully wrong way to do it. But there are certain practices and behaviors that can instill confidence in the safety of one's keys, both in how they are generated and how they are stored. I do not propose to offer any personal solutions to this surely difficult problem. Rather, my idea is simply to empower people to use their own verifiable entropy and design their own backup solutions.
Verifying and storing your own entropy is harder than it sounds
Confidence in generating and keeping keys requires careful thought and planning. It also requires flexibility on all fronts: from how the entropy is generated, to how checksums are calculated, to how backups are crafted. Everyone has a different view of how these things should go.
In my own experience, most keygen tools do one or a couple of parts of this process well, but many are lacking in others. Some take dice rolls but hide the conversion. Some show the math but run on an "offline computer" with no clear guide to achieving confidence in being truly "offline." Some are actually excellent for seeds and signing, but assume you already know exactly what you're doing.
What I could not find was an easy interface for the whole thing, end-to-end: verifiable entropy, maximally customizable backup plans, a safe offline digital environment, no vendor risk, and no tiny screens! Having found nothing that I felt to be "comprehensive," I set out to build one.
First attempt: an offline HTML file on Tails
Following in the footsteps of the great Ian Coleman, my first attempt was a simple HTML file. It's easy enough to carry a file to an offline computer and open it in a browser. Plenty of good projects work this way, and for good reasons. A single file is easy to read, easy to audit and easy to carry.
This first solution worked, more or less. But the further I took it, the more I ran into the same question: offline where? An HTML file is only as offline as the computer you open it on. A browser is one of the largest programs on any machine, and the operating system under it was built to be online.
Tails is a common go-to solution for an "offline" computer, given its amnesiac nature. Internal drives cannot be mounted without setting an admin password, and networking cannot be accessed if disabled before login. It sounds pretty good. Tails in its own right is a remarkable project, and I don't want to take anything from it. But I came away uneasy about using it as a home for a Bitcoin keystore project.
Tails is built to go online, privately, through Tor. That is its purpose, and it does it well. But keeping it offline is something you choose each time you start it, not something the system is built around. Underneath is a full desktop: a window system, a browser, and drivers for every network card and every disk it might meet. Every one of those is code that runs next to your keys. Tor Browser running on Tails sits atop well over a thousand software packages, each of which is a possible attack vector. If you are using an operating system that is fundamentally designed to be online, you're running on an attack surface that's simply far larger than necessary.
In short, HTML files can make the math visible and give you greater choice than a single hardware wallet's firmware, but they do not make the computer trustworthy, and they are not actually that easy to work with if you care about a sanitary data flow.
Why the stick stays in
Furthermore, Tails is also meant to run with its USB stick inserted the whole time. That is a deliberate part of its design: pull the stick and Tails shuts the computer down and wipes its memory. If someone snatches your laptop while you are using it, as happened to Ross Ulbricht in a San Francisco library, the machine is meant to turn itself off before they can read anything from it. For the people Tails protects, that is exactly the right feature.
Faraday deals with a different threat. I wanted the system to load into memory and then run with no stick attached at all, so that while your keys are loaded, there is no storage plugged in for anything to be written to or read from. For signing, I wanted the opposite of a full desktop as well. I wanted a system that could not reach a network or a disk, because the code to do so was never there.
Second attempt: a stripped-down Arch
So I tried to build that myself. I started from Arch Linux and began taking things out: no network stack, no drivers for Ethernet or Wi-Fi or Bluetooth. Internal storage went: no drivers for the computer's own disks, so nothing could be read from them or written to them. Option after option in the kernel's configuration went the same way, until what was left was much closer to an offline machine than anything I could get from a general-purpose distribution.
It worked. It was also still very complex. A Linux distribution is hundreds of packages, each with its own dependencies and its own idea of what it needs. I still had a desktop to run the wallet software on, and a desktop is a large amount of software to trust. I had made a smaller haystack, but it was still a haystack. I even went so far as designing an admittedly user-unfriendly "export broker," a protected environment that was unable to access the normal desktop environment, for writing to a USB stick. To be honest, the whole system contained more friction than even I could handle. No one would ever use such a system.
The approach that stuck
The answer came from a friend's private project, one that was never meant for public release. It was designed to run on a Raspberry Pi, and its approach was strikingly simple: one Rust program, running directly on a Linux kernel, drawing straight to the screen. No desktop. No window system. No browser. Just the kernel, and one program that does everything needed to be a Bitcoin keystore and signer.
As soon as I saw it, I saw what it could be beyond the Pi. Take that approach to an ordinary PC, and with careful controls, you get something that neither a hardware wallet nor a Linux distribution gives you.
That is Faraday.
What Faraday is
Faraday boots from a USB stick on an ordinary computer and runs entirely from memory. Its kernel has no network stack and no driver for the computer's own disks, so once the boot stick is out, it has no network and no drive of any kind. Those things are not "turned off," they are simply not there.
There is no X11, no Wayland, no window manager, no toolkit and no browser engine, and on a PC no GPU driver either. The computer's firmware sets up a framebuffer, the kernel hands it over, and Faraday, one Rust program, lays out every screen, draws its own fonts and writes every pixel itself. Keys, clicks and touches arrive as raw input events from the kernel. Less software between you and your keys is less to attack. And Faraday has FAR less. On a PC, the whole boot file, the kernel and Faraday together, is about 15 MB. And Faraday's cryptography is checked against published test vectors where a standard has them and, wherever one exists, against an implementation Faraday did not write (please note that Faraday uses established Rust implementations wherever possible, and only introduces its own implementations or specifications according to strict standards).
It is stateless by design. Nothing is written to the computer, and everything in memory fades away soon after power off. Your keys load only while no stick is attached, and only what you choose to write down on paper or steel, or to a stick, is kept.
And the thing I set out to build in the first place is at its center: You can roll every bit of a seed yourself and watch the words appear from bits that anyone can follow. The full word lists are included, so you can check each word by hand as well. I am trying to make it as beautiful and user-friendly as I can.
Why a big screen changes everything
Running on a PC instead of a small device turned out to matter more than I expected.
Hardware wallets and Pi-based signers have small screens, and the small screen shapes everything. You see one word at a time, one field at a time, one step at a time, and you have to hold the rest in your head. Checking your entropy on a screen that size is possible, but it is hard to see.
A laptop's screen is a different world. Faraday can show your dice rolls, the bits they made and the words those bits became, all at once. It can lay out a whole backup plan on one page: which seed goes where and what each backup location holds. It can walk a first-time spender from an envelope left for them to a sent transaction without hiding the parts that matter.
There is a quieter benefit too. A hardware wallet is made for one job, so it is worth tampering with in the factory, in the post, or in the shop, because an attacker knows what it will hold. Buying one also puts your name and address on a customer list. Faraday runs on an ordinary laptop, one among hundreds of millions, bought anywhere or already yours. Nothing you bought says you hold keys. And in a multisig setup, it turns a device you already own into a signer. Faraday has a natural place in any multi-vendor multisig setup.
Open to every platform
Nothing in Faraday's approach ties it to one kind of hardware. If a machine can boot a Linux kernel and hand it a screen, Faraday can be at home there. I hope that Faraday can be particularly useful to people who do not otherwise have access to vendor hardware wallets or "specialized" hardware such as Raspberry Pis. Any laptop CAN function as a keystore and signer — Faraday is unlocking that potential for everyone.
Where it stands
Faraday is a pre-release. It has not yet been thoroughly reviewed. That review is part of the plan: the Audits page explains how anyone can examine it and report what they find, and every audit will be published there. As I said in my previous post, only time and community acceptance will prove its worth.
In the meantime, I invite you to try it out! The tour walks through the app in brief, and you can try the full app in Faraday Demo, which comes with the Starter and opens in Practice mode. A strip along the bottom of the window stands in for USB sticks and easily loads the various elements that you'd have handy if you were using Faraday for real. I would also encourage testing on real hardware, and would love to hear about your experiences, both good and bad!
It all started with one question after the Coldcard news: how do I know my seed is really random? Faraday is my answer. Roll the dice yourself, and watch.