Solo is an open source security key, and you can get one at solokeys.com.
Solo supports FIDO2 and U2F standards for strong two-factor authentication and password-less login, and it will protect you against phishing and other online attacks. With colored cases and multilingual guides we want to make secure login more personable and accessible to everyone around the globe.
This repo contains the Solo firmware, including implementations of FIDO2 and U2F (CTAP2 and CTAP) over USB and NFC. The main implementation is for STM32L432, but it is easily portable.
For development no hardware is needed, Solo also runs as a standalone application for Windows, Linux, and Mac OSX. If you like (or want to learn) hardware instead, you can run Solo on the NUCLEO-L432KC development board, or we make Solo for Hacker, an unlocked version of Solo that lets you customize its firmware.
Solo is based on the STM32L432 microcontroller. It offers the following security features.
- True random number generation to guarantee random keys.
- Security isolation so only simple & secure parts of code can handle keys.
- Flash protection from both external use and untrusted code segments.
- 256 KB of memory to support hardened crypto implementations and, later, additional features such as OpenPGP or SSH.
- No NDA needed to develop for.
Solo for Hacker is a special version of Solo that let you customize its firmware, for example you can change the LED color, and even build advanced applications.
Check out solokeys.com, for options on where to buy Solo. Solo Hacker can be converted to a secure version, but normal Solo cannot be converted to a Hacker version.
If you have a Solo for Hacker, here's how you can load your own code on it. You can find more details, including how to permanently lock it, in our documentation. We support Python3.
For example, if you want to turn off any blue light emission, you can edit led_rgb() and change LED_INIT_VALUE
to be a different hex color.
Then recompile, load your new firmware, and enjoy a different LED color Solo.
In the Hacker version, hardware is the same but the firmware is unlocked, so you can 1) load an unsigned application, or 2) entirely reflash the key. By contrast, in a regular Solo you can only upgrade to a firmware signed by SoloKeys, and flash is locked and debug disabled permanently.
Hacker Solo isn't really secure so you should only use it for development. An attacker with physical access to a Solo for Hacker can reflash it following the steps above, and even a malware on your computer could possibly reflash it.
git clone --recurse-submodules https://github.com/solokeys/solo
cd soloIf you forgot the --recurse-submodules while cloning, simply run git submodule update --init --recursive.
make update will also checkout the latest code on master and submodules.
You can checkout the code to build a specific version of the firmware with:
VERSION_TO_BUILD=2.5.3
git fetch --tags
git checkout ${VERSION_TO_BUILD}
git submodule update --init --recursive
In order to compile ARM code, you need the ARM compiler and other things like bundling bootloader and firmware require the solo-python python package. Check our documentation for details.
You can update your solokey after running pip3 install solo-python with solo key update for the latest version. To apply a custom image use solo program bootloader <file>(.json|.hex).
Alternatively, you can use Docker to create a container with the toolchain. You can run:
# Build the toolchain container
make docker-build-toolchain
# Build all versions of the firmware in the "builds" folder
make docker-build-allThe builds folder will contain all the variation on the firmware in .hex files.
If you have the toolchain installed on your machine you can build the firmware with:
cd targets/stm32l432
make cbor
make build-hacker
cd ../..
make venv
source venv/bin/activate
solo program aux enter-bootloader
solo program bootloader targets/stm32l432/solo.hexClone Solo and build it
git clone --recurse-submodules https://github.com/solokeys/solo
cd solo
make allThis builds Solo as a standalone application. Solo application is set up to send and recv USB HID messages over UDP to ease development and reduce need for hardware.
Testing can be done using our fork of Yubico's client software, python-fido2. Our fork of python-fido2 has small changes to make it send USB HID over UDP to the authenticator application. You can install our fork by running the following:
pip install -r tools/requirements.txtRun the Solo application:
./mainIn another shell, you can run our test suite.
You can find more details in our documentation, including how to build on the the NUCLEO-L432KC development board.
Check out our official documentation.
Solo is an upgrade to U2F Zero. It was born from Conor's passion for making secure hardware, and from our shared belief that security should be open to be trustworthy, in hardware like in software.
This project follows the all-contributors specification. Contributions of any kind welcome! The ultimate goal is to have a FIDO2 security key supporting USB, NFC, and BLE interfaces, that can run on a variety of MCUs. Look at the issues to see what is currently being worked on. Feel free to add issues as well.
Thanks goes to these wonderful people (emoji key):
Solo is fully open source.
All software, unless otherwise noted, is dual licensed under Apache 2.0 and MIT. You may use Solo software under the terms of either the Apache 2.0 license or MIT license.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
All hardware, unless otherwise noted, is dual licensed under CERN and CC-BY-SA. You may use Solo hardware under the terms of either the CERN 1.2 license or CC-BY-SA 4.0 license.
All documentation, unless otherwise noted, is licensed under CC-BY-SA. You may use Solo documentation under the terms of the CC-BY-SA 4.0 license
You can buy Solo, Solo Tap, and Solo for Hackers at solokeys.com.
