Solo hardware security key review

Sometime last year (I forget when), I backed a kickstarter that promised the first open-source hardware security key that supports FIDO2. Since the people doing the kickstarter have done this before for an older standard, I decided to back it.

Last week they finally arrived, and the wait was totally worth it! I got 1 with a USB type c connector (in yellow below), and 1 type a regular type a connector that also supports nfc (in red, for using with my phone).

Before I get into why they are so awesome, it's probably a good idea if we take small step back and look at what a hardware security key does and why it does it.

My Solos!

In short, a hardware security key has a unique secret key baked into it that you can't extract. If I understand it, this is sometimes known as a physically unclonable function (correct me in a comment if I'm wrong). It makes use of this secret key for authentication purposes by way of a chain of protocols, which are collectively known as FIDO2.

A diagram showing the different FIDO2 protocols. It's basically WebAuthn between browser and OS, and CTAP2 between OS and hardware security key

There are 2 important protocols here: WebAuthn that the browser provides to web pages to interact with hardware devices, and CTAP2 - which allows the browser to interface with the hardware security key through a channel that the operating system provides (be that over USB, NFC, Bluetooth, or some other means).

FIDO2 is new. Like very very new. To this end, browsers and websites don't yet have full support for it. Those that do aren't always enabled by default (in Firefox you've got to set security.webauth.u2f, security.webauth.webauthn, and security.webauth.webauthn_enable_usbtoken to true, but I think these will set by default in a coming update) or incorrectly 'detect' support by sniffing the user-agent string ( cough I'm looking at you, GitHub and Facebook cough ).

Despite this, when it is supported it works fabulously. Solo goes a long way to making the process as painless as possible - supporting both CTAP (for the older U2F protocol) and CTAP 2 (which is part of the FIDO 2 protcol suite). It's designed well (though the cases on the NFC-enabled version called the Solo Tap are a bit on the snug side), and since it's open source you can both inspect and contribute to the firmware to improve the Solo and add new features for everyone to enjoy.

Extra features like direct access to the onboard TRNG (true random number generator) are really nice to have - and the promise of more features to come makes it even better. I'm excited to see what new capabilities my Solo will gain with future updates!

In the future I want to take a deeper dive into Webauthn and implement support in applications I've written (e.g. Pepperminty Wiki). It looks like it might be quite complicated, but I'll post here when I've figured it out.

Comments

maya:

Nice answers in replace of Security Companies the question with real point of view and explaining about that.

My1:

to clarify a bit on the "physically unclonable function":

instead of a more or less normal storage chip like a flash chip or and EEPROM or whatever you instead get a cryptoprocessor, which unlike a plain storage chip can actually "think" and do stuff instead of just passively keeping track of the storage.

to explain it in easier terms.

Let's say to Sign stuff you need a very special Pen with very special Ink which cannot be easily be created except by actually having the fresh ink on hand (private key) but easily checked for being a counterfeit using the patterns it creates while signing stuff (public key) and instead of signing your name, the signature consists of a special kind of summary of the stuff you want to sign.

so with the ink patterns you can check that the signature was actually made with that pen and ink, and with the summary of the content you make sure nobody changed anything.

now you could store that special ink pen just in a boring box somewhere (like you could store your private key on a hard drive), BAD IDEA. anyone who finds your box can do whatever they want including creating a copy of said ink, which would kinda suck.

to increase security you could lock the box, which is better, but while you sign, you have to open the box which could be used by an attacker, or they could see you open it and open the box themselves by using your code.

now what can we do to protect the ink-pen?

simple.

we build a VERY sturdy cage which has only one entrance as well as hiring someone who wont get bribed and the only entrance to the cage is via an isolation chamber that makes sure that only that hired person goes in and that person has brain enough to verify that the key is authorised to be used by whatever method wanted, physical presence, PIN, etc.

and we put the pen in there and chain it so it cant be taken out.

with the verification they get the document or summary for signing, they go in, sign the document, and let the ink dry and give the sig out.

My1:

that way the pen cannot physically leave the cage and no one can retrieve the pen except by braking open the cage (aka the Secure chip) which would leave traces and you could tell everyone that your ink (private key) isnt safe anymore.

also some more elaborate secure chips can go a step further and do it like many money transport boxes. if opened any other way than planned, we make the contents unusable, which then obviously are the actually physically unclonable functions.

sorry for the wall of text, it's just kinda long winded coming up with a good metaphor.

Anonymous:

Nice write-up!

s/painless ass possible/painless as possible/g

Also, validation required me to enter an e-mail address, even though the field says optional.

Type this	To get this	Notes
`bold text`	bold text	-
`_italics text_`	italics text	-
`~~deleted text~~`	~~deleted~~	-
`code text`	`code text`	Inserts some monospaced code. It is preferred that large blocks of code are linked to using a service such as Pastebin, Github Gists or Ideone.
`> Quote`	Quote	-
`[display text](//google.com)`	display text	Inserts a hyperlink. Please use responsibly. `[rel=nofollow]` is in use and spam will be deleted.
`---`		Inserts a horizontal line. The previous line must be blank.

Stardust
Blog