default up to enabled

allow in bootloader as well
add get_version command to hid
2019-09-17 00:06:45 +08:00 · 2019-09-16 17:12:09 +08:00 · 2019-09-16 17:00:30 +08:00 · 2019-09-16 17:00:13 +08:00 · 2019-09-16 16:25:58 +08:00 · 2019-09-16 15:33:38 +08:00
55 changed files with 405 additions and 1005 deletions
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@ -187,37 +187,6 @@
      "contributions": [
        "bug"
      ]
-    },
-    {
-      "login": "jolo1581",
-      "name": "Jan A.",
-      "avatar_url": "https://avatars1.githubusercontent.com/u/53423977?v=4",
-      "profile": "https://github.com/jolo1581",
-      "contributions": [
-        "code",
-        "doc"
-      ]
-    },
-    {
-      "login": "ccinelli",
-      "name": "ccinelli",
-      "avatar_url": "https://avatars0.githubusercontent.com/u/38021940?v=4",
-      "profile": "https://github.com/ccinelli",
-      "contributions": [
-        "infra",
-        "test"
-      ]
-    },
-    {
-      "login": "Nitrokey",
-      "name": "Nitrokey",
-      "avatar_url": "https://avatars1.githubusercontent.com/u/9438831?v=4",
-      "profile": "https://www.nitrokey.com",
-      "contributions": [
-        "code",
-        "test",
-        "ideas"
-      ]
    }
  ],
  "contributorsPerLine": 7,
--- a/.gitignore
+++ b/.gitignore
@ -34,8 +34,7 @@
 *.app
 *.i*86
 *.x86_64
-targets/*/*.hex
-targets/*/*.sha2
+*.hex

 # Debug files
 *.dSYM/
--- a/.travis.yml
+++ b/.travis.yml
@ -6,15 +6,14 @@ addons:
    sources:
      - ubuntu-toolchain-r-test
    packages:
-      - gcc-8
+      - gcc-7
      - cppcheck
-services:
-  - docker
 before_install:
    - sudo add-apt-repository -y ppa:team-gcc-arm-embedded/ppa
    - sudo apt-get update -q
-    - sudo apt-get install -y gcc-arm-embedded python3-venv
+    - sudo apt-get install -y gcc-arm-embedded
+    - sudo apt-get install -y python3-venv
 script:
-  - export CC=gcc-8
+  - export CC=gcc-7
  - pyenv shell 3.6.7
  - make travis
--- a/61
+++ b/61
@ -1,38 +1,33 @@
-FROM debian:9.11-slim
+FROM debian:stretch-slim
 MAINTAINER SoloKeys <hello@solokeys.com>

-# Install necessary packages
-RUN apt-get update  \
-  && apt-get install -y --no-install-recommends \
-    ca-certificates \
-    make \
-    wget \
-    bzip2 \
-    git \
-  && rm -rf /var/lib/apt/lists/*
+RUN apt-get update -qq
+RUN apt-get install -qq bzip2 git make wget >/dev/null

-# Install ARM compiler
-RUN set -eux; \
-	url="https://developer.arm.com/-/media/Files/downloads/gnu-rm/8-2019q3/RC1.1/gcc-arm-none-eabi-8-2019-q3-update-linux.tar.bz2?revision=c34d758a-be0c-476e-a2de-af8c6e16a8a2?product=GNU%20Arm%20Embedded%20Toolchain,64-bit,,Linux,8-2019-q3-update"; \
-	wget -O gcc.tar.bz2 "$url"; \
-  echo "6341f11972dac8de185646d0fbd73bfc gcc.tar.bz2" | md5sum -c -; \
-	echo "b50b02b0a16e5aad8620e9d7c31110ef285c1dde28980b1a9448b764d77d8f92 gcc.tar.bz2" | sha256sum -c -; \
-	tar -C /opt -xf gcc.tar.bz2; \
-	rm gcc.tar.bz2;
+# 1. ARM GCC: for compilation
+RUN wget -q -O gcc.tar.bz2 https://developer.arm.com/-/media/Files/downloads/gnu-rm/8-2018q4/gcc-arm-none-eabi-8-2018-q4-major-linux.tar.bz2?revision=d830f9dd-cd4f-406d-8672-cca9210dd220?product=GNU%20Arm%20Embedded%20Toolchain,64-bit,,Linux,8-2018-q4-major
+#   from website
+RUN echo "f55f90d483ddb3bcf4dae5882c2094cd  gcc.tar.bz2" > gcc.md5
+RUN md5sum -c gcc.md5
+#   self-generated
+RUN echo "fb31fbdfe08406ece43eef5df623c0b2deb8b53e405e2c878300f7a1f303ee52  gcc.tar.bz2" > gcc.sha256
+RUN sha256sum -c gcc.sha256
+RUN tar -C /opt -xf gcc.tar.bz2

-# Python3.7: for solo-python (merging etc.)
-RUN set -eux; \
-	url="https://repo.anaconda.com/miniconda/Miniconda3-4.5.12-Linux-x86_64.sh"; \
-	wget -O miniconda.sh "$url"; \
-  echo "866ae9dff53ad0874e1d1a60b1ad1ef8 miniconda.sh" | md5sum -c -; \
-	echo "e5e5b4cd2a918e0e96b395534222773f7241dc59d776db1b9f7fedfcb489157a miniconda.sh" | sha256sum -c -; \
-	bash ./miniconda.sh -b -p /opt/conda; \
-  ln -s /opt/conda/bin/python /usr/local/bin/python3; \
-  ln -s /opt/conda/bin/python /usr/local/bin/python; \
-  ln -s /opt/conda/bin/pip /usr/local/bin/pip3; \
-  ln -s /opt/conda/bin/pip /usr/local/bin/pip; \
-	rm miniconda.sh; \
-  pip install -U pip
+# 2. Python3.7: for solo-python (merging etc.)
+RUN wget -q -O miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-4.5.12-Linux-x86_64.sh
+#   from website
+RUN echo "866ae9dff53ad0874e1d1a60b1ad1ef8  miniconda.sh" > miniconda.md5
+RUN md5sum -c miniconda.md5
+#   self-generated
+RUN echo "e5e5b4cd2a918e0e96b395534222773f7241dc59d776db1b9f7fedfcb489157a  miniconda.sh" > miniconda.sha256
+RUN sha256sum -c miniconda.sha256

-# solo-python (Python3.7 script for merging etc.)
-RUN pip install -U solo-python
+RUN bash ./miniconda.sh -b -p /opt/conda
+RUN ln -s /opt/conda/bin/python /usr/local/bin/python3
+RUN ln -s /opt/conda/bin/python /usr/local/bin/python
+RUN ln -s /opt/conda/bin/pip /usr/local/bin/pip3
+RUN ln -s /opt/conda/bin/pip /usr/local/bin/pip
+
+# 3. Source code
+RUN git clone --recurse-submodules https://github.com/solokeys/solo /solo --config core.autocrlf=input
--- a/48
+++ b/48
@ -23,8 +23,8 @@ else
 endif
 LDFLAGS += $(LIBCBOR)

+VERSION:=$(shell git describe --abbrev=0 )
 VERSION_FULL:=$(shell git describe)
-VERSION:=$(shell python -c 'print("$(VERSION_FULL)".split("-")[0])')
 VERSION_MAJ:=$(shell python -c 'print("$(VERSION)".split(".")[0])')
 VERSION_MIN:=$(shell python -c 'print("$(VERSION)".split(".")[1])')
 VERSION_PAT:=$(shell python -c 'print("$(VERSION)".split(".")[2])')
@ -39,7 +39,7 @@ INCLUDES += -I./crypto/cifra/src

 CFLAGS += $(INCLUDES)
 # for crypto/tiny-AES-c
-CFLAGS += -DAES256=1 -DAPP_CONFIG=\"app.h\" -DSOLO_EXPERIMENTAL=1
+CFLAGS += -DAES256=1 -DAPP_CONFIG=\"app.h\"

 name = main

@ -62,7 +62,7 @@ test: venv
 	$(MAKE) clean
 	$(MAKE) -C . main
 	$(MAKE) clean
-	$(MAKE) -C ./targets/stm32l432 test PREFIX=$(PREFIX) "VENV=$(VENV)" VERSION_FULL=${VERSION_FULL}
+	$(MAKE) -C ./targets/stm32l432 test PREFIX=$(PREFIX) "VENV=$(VENV)"
 	$(MAKE) clean
 	$(MAKE) cppcheck

@ -88,30 +88,18 @@ wink: venv
 fido2-test: venv
 	venv/bin/python tools/ctap_test.py

-update:
-	git fetch --tags
-	git checkout master
-	git rebase origin/master
-	git submodule update --init --recursive
-
-DOCKER_TOOLCHAIN_IMAGE := "solokeys/solo-firmware-toolchain"
-
-docker-build-toolchain:
-	docker build -t $(DOCKER_TOOLCHAIN_IMAGE) .
-	docker tag $(DOCKER_TOOLCHAIN_IMAGE):latest $(DOCKER_TOOLCHAIN_IMAGE):${VERSION}
-	docker tag $(DOCKER_TOOLCHAIN_IMAGE):latest $(DOCKER_TOOLCHAIN_IMAGE):${VERSION_MAJ}
-	docker tag $(DOCKER_TOOLCHAIN_IMAGE):latest $(DOCKER_TOOLCHAIN_IMAGE):${VERSION_MAJ}.${VERSION_MIN}
-
-uncached-docker-build-toolchain:
-	docker build --no-cache -t $(DOCKER_TOOLCHAIN_IMAGE) .
-	docker tag $(DOCKER_TOOLCHAIN_IMAGE):latest $(DOCKER_TOOLCHAIN_IMAGE):${VERSION}
-	docker tag $(DOCKER_TOOLCHAIN_IMAGE):latest $(DOCKER_TOOLCHAIN_IMAGE):${VERSION_MAJ}
-	docker tag $(DOCKER_TOOLCHAIN_IMAGE):latest $(DOCKER_TOOLCHAIN_IMAGE):${VERSION_MAJ}.${VERSION_MIN}
-
-docker-build-all: 
+DOCKER_IMAGE := "solokeys/solo-firmware:local"
+SOLO_VERSIONISH := "master"
+docker-build:
+	docker build -t $(DOCKER_IMAGE) .
 	docker run --rm -v "$(CURDIR)/builds:/builds" \
-					-v "$(CURDIR):/solo" \
-				    $(DOCKER_TOOLCHAIN_IMAGE) "solo/in-docker-build.sh" ${VERSION_FULL}
+				    -v "$(CURDIR)/in-docker-build.sh:/in-docker-build.sh" \
+				    $(DOCKER_IMAGE) "./in-docker-build.sh" $(SOLO_VERSIONISH)
+uncached-docker-build:
+	docker build --no-cache -t $(DOCKER_IMAGE) .
+	docker run --rm -v "$(CURDIR)/builds:/builds" \
+				    -v "$(CURDIR)/in-docker-build.sh:/in-docker-build.sh" \
+				    $(DOCKER_IMAGE) "./in-docker-build.sh" $(SOLO_VERSIONISH)

 CPPCHECK_FLAGS=--quiet --error-exitcode=2

@ -132,14 +120,6 @@ clean:
 full-clean: clean
 	rm -rf venv

-test-docker:
-	rm -rf builds/*
-	$(MAKE) uncached-docker-build-toolchain
-	# Check if there are 4 docker images/tas named "solokeys/solo-firmware-toolchain"
-	NTAGS=$$(docker images | grep -c "solokeys/solo-firmware-toolchain") && [ $$NTAGS -eq 4 ]
-	$(MAKE) docker-build-all
-
 travis:
 	$(MAKE) test VENV=". ../../venv/bin/activate;"
-	$(MAKE) test-docker
 	$(MAKE) black
--- a/README.md
+++ b/README.md
@ -1,3 +1,9 @@
+**NEW!** We launched a new tiny security key called Somu, it's live on Crowd Supply and you can [pre-order it now](https://solokeys.com/somu)!
+
+[<img src="https://miro.medium.com/max/1400/1*PnzCPLqq_5nt1gjgSEY2LQ.png" width="600">](https://solokeys.com/somu)
+
+Somu is the micro version of Solo. We were inspired to make a secure Tomu, so we took its tiny form factor, we added the secure microcontroller and firmware of Solo, et voilà! Here we have Somu.
+
 [![latest release](https://img.shields.io/github/release/solokeys/solo.svg)](https://update.solokeys.com/)
 [![Keybase Chat](https://img.shields.io/badge/chat-on%20keybase-brightgreen.svg)](https://keybase.io/team/solokeys.public)
 [![Build Status](https://travis-ci.com/solokeys/solo.svg?style=flat-square&branch=master)](https://travis-ci.com/solokeys/solo)
@ -32,58 +38,10 @@ Check out [solokeys.com](https://solokeys.com), for options on where to buy Solo

 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](https://docs.solokeys.io/solo/building/). We support Python3.

-For example, if you want to turn off any blue light emission, you can edit [`led_rgb()`](https://github.com/solokeys/solo/blob/master/targets/stm32l432/src/app.h#L48) 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.
-
-## Checking out the code
 ```bash
 git clone --recurse-submodules https://github.com/solokeys/solo
 cd solo
-```

-If 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.
-
-## Checking out the code to build a specific version
-
-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
-```
-
-## Installing the toolchain
-
-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](https://docs.solokeys.io/solo/) for details
-
-## Installing the toolkit and compiling in Docker 
-Alternatively, you can use Docker to create a container with the toolchain.
-You can run:
-
-```bash
-# Build the toolchain container
-make docker-build-toolchain 
-
-# Build all versions of the firmware in the "builds" folder
-make docker-build-all
-```
-
-The `builds` folder will contain all the variation on the firmware in `.hex` files.
-
-## Build locally
-
-If you have the toolchain installed on your machine you can build the firmware with: 
-
-```bash
 cd targets/stm32l432
 make cbor
 make build-hacker
@ -95,6 +53,19 @@ solo program aux enter-bootloader
 solo program bootloader targets/stm32l432/solo.hex
 ```

+Alternatively, run `make docker-build` and use the firmware generated in `/tmp`.
+
+If you forgot the `--recurse-submodules` when cloning, simply `git submodule update --init --recursive`.
+
+For example, if you want to turn off any blue light emission, you can edit [`led_rgb()`](https://github.com/solokeys/solo/blob/master/targets/stm32l432/src/app.h#L48) 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.
+
 # Developing Solo (No Hardware Needed)

 Clone Solo and build it
@ -165,11 +136,6 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
    <td align="center"><a href="http://blogs.gnome.org/hughsie/"><img src="https://avatars0.githubusercontent.com/u/151380?v=4" width="100px;" alt="Richard Hughes"/><br /><sub><b>Richard Hughes</b></sub></a><br /><a href="#ideas-hughsie" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/solokeys/solo/commits?author=hughsie" title="Code">💻</a> <a href="#infra-hughsie" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#tool-hughsie" title="Tools">🔧</a></td>
    <td align="center"><a href="http://www.schulz.dk"><img src="https://avatars1.githubusercontent.com/u/1150049?v=4" width="100px;" alt="Kim Schulz"/><br /><sub><b>Kim Schulz</b></sub></a><br /><a href="#business-kimusan" title="Business development">💼</a> <a href="#ideas-kimusan" title="Ideas, Planning, & Feedback">🤔</a></td>
    <td align="center"><a href="https://github.com/oplik0"><img src="https://avatars2.githubusercontent.com/u/25460763?v=4" width="100px;" alt="Jakub"/><br /><sub><b>Jakub</b></sub></a><br /><a href="https://github.com/solokeys/solo/issues?q=author%3Aoplik0" title="Bug reports">🐛</a></td>
-    <td align="center"><a href="https://github.com/jolo1581"><img src="https://avatars1.githubusercontent.com/u/53423977?v=4" width="100px;" alt="Jan A."/><br /><sub><b>Jan A.</b></sub></a><br /><a href="https://github.com/solokeys/solo/commits?author=jolo1581" title="Code">💻</a> <a href="https://github.com/solokeys/solo/commits?author=jolo1581" title="Documentation">📖</a></td>
-    <td align="center"><a href="https://github.com/ccinelli"><img src="https://avatars0.githubusercontent.com/u/38021940?v=4" width="100px;" alt="ccinelli"/><br /><sub><b>ccinelli</b></sub></a><br /><a href="#infra-ccinelli" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/solokeys/solo/commits?author=ccinelli" title="Tests">⚠️</a></td>
-  </tr>
-  <tr>
-    <td align="center"><a href="https://www.nitrokey.com"><img src="https://avatars1.githubusercontent.com/u/9438831?v=4" width="100px;" alt="Nitrokey"/><br /><sub><b>Nitrokey</b></sub></a><br /><a href="https://github.com/solokeys/solo/commits?author=Nitrokey" title="Code">💻</a> <a href="https://github.com/solokeys/solo/commits?author=Nitrokey" title="Tests">⚠️</a> <a href="#ideas-Nitrokey" title="Ideas, Planning, & Feedback">🤔</a></td>
  </tr>
 </table>

@ -203,7 +169,7 @@ You can buy Solo, Solo Tap, and Solo for Hackers at [solokeys.com](https://solok
 <br/>

 [![License](https://img.shields.io/github/license/solokeys/solo.svg)](https://github.com/solokeys/solo/blob/master/LICENSE)
-[![All Contributors](https://img.shields.io/badge/all_contributors-22-orange.svg?style=flat-square)](#contributors)
+[![All Contributors](https://img.shields.io/badge/all_contributors-19-orange.svg?style=flat-square)](#contributors)
 [![Build Status](https://travis-ci.com/solokeys/solo.svg?branch=master)](https://travis-ci.com/solokeys/solo)
 [![Discourse Users](https://img.shields.io/discourse/https/discourse.solokeys.com/users.svg)](https://discourse.solokeys.com)
 [![Keybase Chat](https://img.shields.io/badge/chat-on%20keybase-brightgreen.svg)](https://keybase.io/team/solokeys.public)
--- a/2
+++ b/2
@ -1 +1 @@
-3.0.0
+2.5.2
--- a/docs/solo/application-ideas.md
+++ b/docs/solo/application-ideas.md
@ -1,99 +0,0 @@
-# Using Solo for passwordless or second factor login on Linux 
-
-## Setup on Ubuntu 18.04
-Before you can use Solo for passwordless or second factor login in your Linux system you have to install some packages.
-
-This was tested under **Linux Mint 19.2**.
-
-First you have to install PAM modules for u2f.
-
-```
-  sudo apt install libpam-u2f pamu2fcfg
-```
-
-## Setting up key
-To use Solo as passwordless or second factor login, you have to setup your system with your Solo.
-First create a new folder named **Yubico** in your **.config** folder in your **home** directory
-
-```
-  mkdir ~/.config/Yubico
-```
-
-Then create a new key for PAM U2F module. If it is your first key you want to register use following command:
-```
-  pamu2fcfg > ~/.config/Yubico/u2f_keys
-```
-If you want to register an additional key use this command instead:
-```
-  pamu2fcfg >> ~/.config/Yubico/u2f_keys
-```
-Now press the button on your Solo.
- 
-
-If you can't generate your key (error message), you may add Yubico Team from PPA and install latest libpam-u2f and pamu2fcfg and try again.
-```
-  sudo add-apt-repository ppa:yubico/stable
-  sudo apt-get update
-  sudo apt-get upgrade
-```
-
-
-## Login into Linux
-### Passwordless
-To login passwordless into your Linux system, you have to edit the file **lightdm** (or **gdm** or which display manager you prefered).
-In case of lightdm:
-
-```
-sudo vim /etc/pam.d/lightdm
-```
-Now search following entry:
-```
-@include common-auth
-```
-and add
-```
-auth    sufficient      pam_u2f.so
-```
-**before** @include common-auth.
-
-Save the file and test it.<br>
-Insert Solo in your USB port and logout.
-Now you should be able to login into Linux without password, only with pressing your button on Solo and press enter.
-
-Why **sufficient**? The difference between the keyword sufficient and required is, if you don't have your Solo available, you can also login, because the system falls back to password mode.
-
-
-The login mechanism can be also used for additional features like:
-
-:  - Login after screen timeout - edit /etc/pam.d/mate-screensaver (or kde-screensaver, ...)
-  - Passwordless sudo - edit /etc/pam.d/sudo
-
-Check out your folder **/etc/pam.d/** and do some experiments.
-
-**But remember:** <br>
-The login passwordless won't make your system more secure, but maybe more comfortable. If somebody have access to your Solo, this person will be also able to login into your system.
-
-
-### Solo as second factor
-To use Solo as second factor, for login into your Linux system, is nearly the same.
-
-```
-sudo vim /etc/pam.d/lightdm
-```
-Now search following entry:
-```
-@include common-auth
-```
-and add
-```
-auth    required      pam_u2f.so
-```
-**after** @include common-auth.
-
-Save the file and test it. <br>
-In case your Solo is not present, your password will be incrorrect. If Solo is plugged into your USB port, it will signal pressing the button and you will be able to login into Linux.
-
-Why **required**? If you choose the option **sufficent** your Solo is optional. You could also login without second factor if your Solo is not connected.
-
-**But remember:**<br>
-If you loose your Solo you won't be able to login into your system.
--- a/docs/solo/bootloader-mode.md
+++ b/docs/solo/bootloader-mode.md
@ -1,17 +1,16 @@
 # Booting into bootloader mode

-If you have a recent version of Solo, you can put it into bootloader mode by running this command.
+You can put Solo into bootloader mode by holding down the button, and plugging in Solo.  After 2 seconds, bootloader mode will activate.
+You'll see a yellowish flashing light and you can let go of the button.
+
+Now Solo is ready to [accept firmware updates](/solo/signed-updates).  If the Solo is a secured model, it can only accept signed updates, typically in the `firmware-*.json` format.
+
+If Solo is running a hacker build, it can be put into bootloader mode on command.  This makes it easier for development.

 ```bash
 solo program aux enter-bootloader
 ```

-If your Solo is a bit older (<=2.5.3) You can put Solo into bootloader mode by using the button method:  
-Hold down button while plugging in Solo.  After 2 seconds, bootloader mode will activate.
-You'll see a yellowish flashing light and you can let go of the button.
-
-Now Solo is ready to [accept firmware updates](/solo/signed-updates).  If the Solo is a secured model, it can only accept signed updates, typically in the `firmware-*.json` format.
-
 # The boot stages of Solo

 Solo has 3 boot stages.
@ -22,8 +21,7 @@ The first stage is the DFU (Device Firmware Update) which is in a ROM on Solo.
 This is what allows the entire firmware of Solo to be programmed.  **It's not recommended to develop for Solo using the DFU because 
 if you program broken firmware, you could brick your device**.

-On hacker/nonverifying-bootloader devices, you can boot into the DFU by holding down the button for 5 seconds, 
-when Solo is already in bootloader mode.
+On hacker devices, you can boot into the DFU by holding down the button for 5 seconds, when Solo is already in bootloader mode.

 You can also run this command when Solo is in bootloader mode to put it in DFU mode.

@ -31,7 +29,7 @@ You can also run this command when Solo is in bootloader mode to put it in DFU m
 solo program aux enter-dfu
 ```

-Note it will stay in DFU mode until you to tell it to boot again.  You can boot it again by running the following.
+Note it will stay in DFU mode until to tell it to boot again.  You can boot it again by running the following.

 ```bash
 solo program aux leave-dfu
--- a/docs/solo/building.md
+++ b/docs/solo/building.md
@ -36,21 +36,17 @@ Enter the `stm32l4xx` target directory.
 cd targets/stm32l432
 ```

-Now build the Solo application.
+Now build Solo.

 ```
-make firmware
+make build-hacker
 ```

-The `firmware` recipe builds the solo application, and outputs `solo.hex`.  You can use this
-to reprogram any unlocked/hacker Solo model.  Note that it does not include the Solo bootloader,
-so it is not a full reprogram.
-
-<!-- First it builds the bootloader, with
+The `build-hacker` recipe does a few things.  First it builds the bootloader, with
 signature checking disabled.  Then it builds the Solo application with "hacker" features
 enabled, like being able to jump to the bootloader on command.  It then merges bootloader
 and solo builds into the same binary.  I.e. it combines `bootloader.hex` and `solo.hex`
-into `all.hex`. -->
+into `all.hex`.

 If you're just planning to do development, **please don't try to reprogram the bootloader**,
 as this can be risky if done often.  Just use `solo.hex`.
@ -61,13 +57,13 @@ If you're developing, you probably want to see debug messages!  Solo has a USB
 Serial port that it will send debug messages through (from `printf`).  You can read them using
 a normal serial terminal like `picocom` or `putty`.

-Just add `-debug-1` or `-debug-2` to your build recipe, like this.
+Just add `DEBUG=1` or `DEBUG=2` to your build recipe, like this.

 ```
-make firmware-debug-1
+make build-hacker DEBUG=1
 ```

-If you use `debug-2`, that means Solo will not boot until something starts reading
+If you use `DEBUG=2`, that means Solo will not boot until something starts reading
 its debug messages.  So it basically waits to tether to a serial terminal so that you don't
 miss any debug messages.

@ -82,45 +78,27 @@ solo monitor <serial-port>

 [See issue 62](https://github.com/solokeys/solo/issues/62).

-### Building a complete Solo build (application + bootloader + certificate)
+### Building a Solo release

-To make a complete Solo build, you need to build the bootloader.  We provide
-two easy recipes:
+To build Solo

-* `bootloader-nonverifying`: bootloader with no signature checking on updates.  I.e. "unlocked".
-* `bootloader-verifying`: bootloader with signature checking enforced on updated.  I.e. "Locked".
+If you want to build a release of Solo, we recommend trying a Hacker build first
+just to make sure that it's working.  Otherwise it may not be as easy or possible to
+fix any mistakes.

-To be safe, let's use the `-nonverifying` build.
+If you're ready to program a full release, run this recipe to build.

 ```
-make bootloader-nonverifying
+make build-release-locked
 ```

-This outputs `bootloader.hex`.  We can then merge the bootloader and application.
+This outputs bootloader.hex, solo.hex, and the combined all.hex.

-```
-solo mergehex bootloader.hex solo.hex bundle.hex
-```
+Programming `all.hex` will cause the device to permanently lock itself.  This means debuggers cannot be used and signature checking
+will be enforced on all future updates.

-`bundle.hex` is our complete firmware build.  Note it is in this step that you can
-include a custom attestation certificate or lock the device from debugging/DFU.
-By default the "hacker" attestation certifcate and key is used.
-
-```
-solo mergehex  \
-    --attestation-key "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF" \
-    --attestation-cert attestation.der \
-    --lock \
-    solo.hex \
-    bootloader.hex \
-    bundle.hex
-```
-
-See [here for more information on custom attestation](/solo/customization/).
-
-If you use `--lock`, this will permanently lock the device to this new bootloader.  You
-won't be able to program the bootloader again or be able to connect a hardware debugger.
-The new bootloader may be able to accept (signed) updates still, depending on how you configured it.
-
-To learn more about normal updates or a "full" update, you should [read more on Solo's boot stages](/solo/bootloader-mode).
+Note if you program a secured `solo.hex` file onto a Solo Hacker, it will lock the flash, but the bootloader
+will still accept unsigned firmware updates.  So you can switch it back to being a hacker, but you will
+not be able to replace the unlocked bootloader anymore, since the permanently locked flash also disables the DFU.
+[Read more on Solo's boot stages](/solo/bootloader-mode).

--- a/docs/solo/customization.md
+++ b/docs/solo/customization.md
@ -114,27 +114,28 @@ If the checks succeed, you are ready to program the device attestation key and c

 ### Programming an attestation key and certificate

-First, [Build your solo application and bootloader](/solo/building).
+Convert the DER format of the device attestation certificate to "C" bytes using our utility script.  You may first need to
+first install prerequisite python modules (`pip install -r tools/requirements.txt`).

-Print your attestation key in a hex string format.  Using our utility script:
+```
+python tools/gencert/cbytes.py device_cert.der
+```
+
+Copy the byte string portion into the [`attestation.c` source file of Solo](https://github.com/solokeys/solo/blob/master/targets/stm32l432/src/attestation.c).  Overwrite the development or "default" certificate that is already there.
+
+Now [build the Solo firmware](/solo/building), either a secure or hacker build.  You will need to produce a `bootloader.hex` file and a `solo.hex` file.
+
+Print your attestation key in a hex string format.

 ```
 python tools/print_x_y.py device_key.pem
 ```

-Merge the `bootloader.hex`, `solo.hex`, attestion key, and certificate into one firmware file.
+Merge the `bootloader.hex`, `solo.hex`, and attestion key into one firmware file.

 ```
-solo mergehex  \
-    --attestation-key "(The 32-byte hex string extracted from device_key.pem)" \
-    --attestation-cert device_cert.der \
-    --lock \
-    solo.hex \
-    bootloader.hex \
-    bundle.hex
+solo mergehex --attestation-key <attestation-key-hex-string> bootloader.hex solo.hex all.hex
 ```

-Now you have a newly created `bundle.hex` file with a custom attestation key and cert.  You can [program this `bundle.hex` file
+Now you have a newly create `all.hex` file with a custom attestation key.  You can [program this `all.hex` file
 with Solo in DFU mode](/solo/programming#procedure).
-
-Are you interested in customizing in bulk?  Contact hello@solokeys.com and we can help.
--- a/docs/solo/programming.md
+++ b/docs/solo/programming.md
@ -22,11 +22,12 @@ solo key update <--secure | --hacker>
 You can manually install the [latest release](https://github.com/solokeys/solo/releases), or use a build that you made.

 ```bash
+# If it's a hacker, it will automatically boot into bootloader mode.
 solo program bootloader <firmware.hex | firmware.json>
 ```

 Note you won't be able to use `all.hex` or the `bundle-*.hex` builds, as these include the solo bootloader.  You shouldn't
-risk changing the Solo bootloader unless you want to make it a secure device, or [make other customizations](/solo/customization/).
+risk changing the Solo bootloader unless you want to make it a secure device, or [make other customizations]().

 ## Updating a Hacker to a Secure Solo

@ -37,14 +38,14 @@ You can use a firmware build from the [latest release](https://github.com/soloke
 a build that you made yourself.

 You need to use a firmware file that has the combined bootloader and application (or at the very least just the bootloader).
-This means using the `bundle-*.hex` file or the `bundle.hex` from your build.  If you overwrite the Solo flash with a missing bootloader,
+This means using the `bundle-*.hex` file or the `all.hex` from your build.  If you overwrite the Solo flash with a missing bootloader,
 it will be bricked.

 We provide two types of bundled builds.  The `bundle-hacker-*.hex` build is the hacker build.  If you update with this,
 you will update the bootloader and application, but nothing will be secured.  The `bundle-secure-non-solokeys.hex`
 is a secured build that will lock your device and it will behave just like a Secure Solo.  The main difference is that
 it uses a "default" attestation key in the device, rather than the SoloKeys attestation key.  There is no security
-concern with using our default attestation key, aside from a small privacy implication that services can distinguish it from Solo Secure.
+concern with using our default attestation key, aside from a privacy implication that services can distinguish it from Solo Secure.

 ### Procedure

@ -60,7 +61,7 @@ concern with using our default attestation key, aside from a small privacy impli

 2. Program the device

-        solo program dfu <bundle-secure-non-solokeys.hex | bundle.hex>
+        solo program dfu <bundle-secure-non-solokeys.hex | all.hex>

    Double check you programmed it with bootloader + application (or just bootloader).
    If you messed it up, simply don't do the next step and repeat this step correctly.
--- a/docs/solo/udev.md
+++ b/docs/solo/udev.md
@ -18,7 +18,7 @@ Further progress is tracked in: <https://github.com/solokeys/solo/issues/144>.
 If you still need to setup a rule, a simple way to do it is:

 ```
-git clone https://github.com/solokeys/solo.git
+git clone git@github.com:solokeys/solo.git
 cd solo/udev
 make setup
 ```
--- a/fido2/crypto.c
+++ b/fido2/crypto.c
@ -47,7 +47,7 @@ typedef enum
 #endif


-const uint8_t * attestation_cert_der;
+const uint8_t attestation_cert_der[];
 const uint16_t attestation_cert_der_size;
 const uint8_t attestation_key[];
 const uint16_t attestation_key_size;
@ -338,7 +338,7 @@ void crypto_aes256_encrypt(uint8_t * buf, int length)
 }


-const uint8_t _attestation_cert_der[] =
+const uint8_t attestation_cert_der[] =
 "\x30\x82\x01\xfb\x30\x82\x01\xa1\xa0\x03\x02\x01\x02\x02\x01\x00\x30\x0a\x06\x08"
 "\x2a\x86\x48\xce\x3d\x04\x03\x02\x30\x2c\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13"
 "\x02\x55\x53\x31\x0b\x30\x09\x06\x03\x55\x04\x08\x0c\x02\x4d\x44\x31\x10\x30\x0e"
@ -365,11 +365,9 @@ const uint8_t _attestation_cert_der[] =
 "\x7e\x74\x64\x1b\xa3\x7b\xf7\xe6\xd3\xaf\x79\x28\xdb\xdc\xa5\x88\x02\x21\x00\xcd"
 "\x06\xf1\xe3\xab\x16\x21\x8e\xd8\xc0\x14\xaf\x09\x4f\x5b\x73\xef\x5e\x9e\x4b\xe7"
 "\x35\xeb\xdd\x9b\x6d\x8f\x7d\xf3\xc4\x3a\xd7";
-const uint8_t * attestation_cert_der = (const uint8_t *)_attestation_cert_der;

-uint16_t attestation_cert_der_get_size(){
-    return sizeof(_attestation_cert_der)-1;
-}
+
+const uint16_t attestation_cert_der_size = sizeof(attestation_cert_der)-1;


 const uint8_t attestation_key[] = "\xcd\x67\xaa\x31\x0d\x09\x1e\xd1\x6e\x7e\x98\x92\xaa\x07\x0e\x19\x94\xfc\xd7\x14\xae\x7c\x40\x8f\xb9\x46\xb7\x2e\x5f\xe7\x5d\x30";
--- a/fido2/crypto.h
+++ b/fido2/crypto.h
@ -54,7 +54,10 @@ void crypto_reset_master_secret();
 void crypto_load_master_secret(uint8_t * key);


-extern const uint8_t * attestation_cert_der;
-uint16_t attestation_cert_der_get_size();
+extern const uint8_t attestation_cert_der[];
+extern const uint16_t attestation_cert_der_size;
+
+extern const uint8_t attestation_key[];
+extern const uint16_t attestation_key_size;

 #endif
--- a/fido2/ctap.c
+++ b/fido2/ctap.c
@ -661,7 +661,7 @@ uint8_t ctap_add_attest_statement(CborEncoder * map, uint8_t * sigder, int len)
        ret = cbor_encoder_create_array(&stmtmap, &x5carr, 1);
        check_ret(ret);
        {
-            ret = cbor_encode_byte_string(&x5carr, attestation_cert_der, attestation_cert_der_get_size());
+            ret = cbor_encode_byte_string(&x5carr, attestation_cert_der, attestation_cert_der_size);
            check_ret(ret);
            ret = cbor_encoder_close_container(&stmtmap, &x5carr);
            check_ret(ret);
@ -698,7 +698,7 @@ int ctap_authenticate_credential(struct rpId * rp, CTAP_credentialDescriptor * d
            crypto_sha256_init();
            crypto_sha256_update(rp->id, rp->size);
            crypto_sha256_final(rpIdHash);
-            return u2f_authenticate_credential((struct u2f_key_handle *)&desc->credential.id, U2F_KEY_HANDLE_SIZE,rpIdHash);
+            return u2f_authenticate_credential((struct u2f_key_handle *)&desc->credential.id, rpIdHash);
        break;
        case PUB_KEY_CRED_CUSTOM:
            return is_extension_request(getAssertionState.customCredId, getAssertionState.customCredIdSize);
@ -1761,28 +1761,11 @@ static void ctap_state_init()

    printf1(TAG_STOR, "Generated PIN SALT: ");
    dump_hex1(TAG_STOR, STATE.PIN_SALT, sizeof STATE.PIN_SALT);
+
 }

-/** Overwrite master secret from external source.
- * @param keybytes an array of KEY_SPACE_BYTES length.
- * 
- * This function should only be called from a privilege mode.
-*/
-void ctap_load_external_keys(uint8_t * keybytes){
-    memmove(STATE.key_space, keybytes, KEY_SPACE_BYTES);
-    authenticator_write_state(&STATE, 0);
-    authenticator_write_state(&STATE, 1);
-    crypto_load_master_secret(STATE.key_space);
-}
-
-#include "version.h"
 void ctap_init()
 {
-    printf1(TAG_ERR,"Current firmware version address: %p\r\n", &firmware_version);
-    printf1(TAG_ERR,"Current firmware version: %d.%d.%d.%d (%02x.%02x.%02x.%02x)\r\n",
-            firmware_version.major, firmware_version.minor, firmware_version.patch, firmware_version.reserved,
-            firmware_version.major, firmware_version.minor, firmware_version.patch, firmware_version.reserved
-            );
    crypto_ecc256_init();

    authenticator_read_state(&STATE);
--- a/fido2/ctap.h
+++ b/fido2/ctap.h
@ -361,6 +361,4 @@ extern uint8_t KEY_AGREEMENT_PUB[64];

 void lock_device_permanently();

-void ctap_load_external_keys(uint8_t * keybytes);
-
 #endif
--- a/fido2/ctaphid.c
+++ b/fido2/ctaphid.c
@ -539,14 +539,11 @@ extern void _check_ret(CborError ret, int line, const char * filename);
 #define check_hardcore(r)   _check_ret(r,__LINE__, __FILE__);\
                            if ((r) != CborNoError) exit(1);

-
-uint8_t ctaphid_custom_command(int len, CTAP_RESPONSE * ctap_resp, CTAPHID_WRITE_BUFFER * wb);
-
 uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
 {
-    uint8_t cmd = 0;
+    uint8_t cmd;
    uint32_t cid;
-    int len = 0;
+    int len;
 #ifndef DISABLE_CTAPHID_CBOR
    int status;
 #endif
@ -556,10 +553,6 @@ uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
    CTAP_RESPONSE ctap_resp;

    int bufstatus = ctaphid_buffer_packet(pkt_raw, &cmd, &cid, &len);
-    ctaphid_write_buffer_init(&wb);
-
-    wb.cid = cid;
-    wb.cmd = cmd;

    if (bufstatus == HID_IGNORE)
    {
@ -595,6 +588,9 @@ uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
        case CTAPHID_PING:
            printf1(TAG_HID,"CTAPHID_PING\n");

+            ctaphid_write_buffer_init(&wb);
+            wb.cid = cid;
+            wb.cmd = CTAPHID_PING;
            wb.bcnt = len;
            timestamp();
            ctaphid_write(&wb, ctap_buffer, len);
@ -607,9 +603,13 @@ uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
        case CTAPHID_WINK:
            printf1(TAG_HID,"CTAPHID_WINK\n");

+            ctaphid_write_buffer_init(&wb);

            device_wink();

+            wb.cid = cid;
+            wb.cmd = CTAPHID_WINK;
+
            ctaphid_write(&wb,NULL,0);

            break;
@ -634,6 +634,9 @@ uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
            ctap_response_init(&ctap_resp);
            status = ctap_request(ctap_buffer, len, &ctap_resp);

+            ctaphid_write_buffer_init(&wb);
+            wb.cid = cid;
+            wb.cmd = CTAPHID_CBOR;
            wb.bcnt = (ctap_resp.length+1);


@ -664,6 +667,9 @@ uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
            ctap_response_init(&ctap_resp);
            u2f_request((struct u2f_request_apdu*)ctap_buffer, &ctap_resp);

+            ctaphid_write_buffer_init(&wb);
+            wb.cid = cid;
+            wb.cmd = CTAPHID_MSG;
            wb.bcnt = (ctap_resp.length);

            ctaphid_write(&wb, ctap_resp.data, ctap_resp.length);
@ -674,14 +680,76 @@ uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
            printf1(TAG_HID,"CTAPHID_CANCEL\n");
            is_busy = 0;
            break;
+#if defined(IS_BOOTLOADER)
+        case CTAPHID_BOOT:
+            printf1(TAG_HID,"CTAPHID_BOOT\n");
+            ctap_response_init(&ctap_resp);
+            u2f_set_writeback_buffer(&ctap_resp);
+            is_busy = bootloader_bridge(len, ctap_buffer);
+
+            ctaphid_write_buffer_init(&wb);
+            wb.cid = cid;
+            wb.cmd = CTAPHID_BOOT;
+            wb.bcnt = (ctap_resp.length + 1);
+            ctaphid_write(&wb, &is_busy, 1);
+            ctaphid_write(&wb, ctap_resp.data, ctap_resp.length);
+            ctaphid_write(&wb, NULL, 0);
+            is_busy = 0;
+        break;
+#endif
+#if defined(SOLO_HACKER)
+        case CTAPHID_ENTERBOOT:
+            printf1(TAG_HID,"CTAPHID_ENTERBOOT\n");
+            boot_solo_bootloader();
+            ctaphid_write_buffer_init(&wb);
+            wb.cid = cid;
+            wb.cmd = CTAPHID_ENTERBOOT;
+            wb.bcnt = 0;
+            ctaphid_write(&wb, NULL, 0);
+            is_busy = 0;
+        break;
+        case CTAPHID_ENTERSTBOOT:
+            printf1(TAG_HID,"CTAPHID_ENTERBOOT\n");
+            boot_st_bootloader();
+        break;
+#endif
+#if !defined(IS_BOOTLOADER)
+        case CTAPHID_GETRNG:
+            printf1(TAG_HID,"CTAPHID_GETRNG\n");
+            ctap_response_init(&ctap_resp);
+            ctaphid_write_buffer_init(&wb);
+            wb.cid = cid;
+            wb.cmd = CTAPHID_GETRNG;
+            wb.bcnt = ctap_buffer[0];
+            if (!wb.bcnt)
+                wb.bcnt = 57;
+            memset(ctap_buffer,0,wb.bcnt);
+            ctap_generate_rng(ctap_buffer, wb.bcnt);
+            ctaphid_write(&wb, &ctap_buffer, wb.bcnt);
+            ctaphid_write(&wb, NULL, 0);
+            is_busy = 0;
+        break;
+#endif
+
+        case CTAPHID_GETVERSION:
+            printf1(TAG_HID,"CTAPHID_GETVERSION\n");
+            ctap_response_init(&ctap_resp);
+            ctaphid_write_buffer_init(&wb);
+            wb.cid = cid;
+            wb.cmd = CTAPHID_GETVERSION;
+            wb.bcnt = 3;
+            ctap_buffer[0] = SOLO_VERSION_MAJ;
+            ctap_buffer[1] = SOLO_VERSION_MIN;
+            ctap_buffer[2] = SOLO_VERSION_PATCH;
+            ctaphid_write(&wb, &ctap_buffer, 3);
+            ctaphid_write(&wb, NULL, 0);
+            is_busy = 0;
+        break;

        default:
-            if (ctaphid_custom_command(len, &ctap_resp, &wb) != 0){
-                is_busy = 0;
-            }else{
-                printf2(TAG_ERR, "error, unimplemented HID cmd: %02x\r\n", buffer_cmd());
+            printf2(TAG_ERR,"error, unimplemented HID cmd: %02x\r\n", buffer_cmd());
            ctaphid_send_error(cid, CTAP1_ERR_INVALID_COMMAND);
-            }
+            break;
    }
    cid_del(cid);
    buffer_reset();
@ -691,114 +759,3 @@ uint8_t ctaphid_handle_packet(uint8_t * pkt_raw)
    else return 0;

 }
-
-uint8_t ctaphid_custom_command(int len, CTAP_RESPONSE * ctap_resp, CTAPHID_WRITE_BUFFER * wb)
-{
-    ctap_response_init(ctap_resp);
-
-#if !defined(IS_BOOTLOADER) && (defined(SOLO_EXPERIMENTAL))
-    uint32_t param;
-#endif
-#if defined(IS_BOOTLOADER)
-    uint8_t is_busy;
-#endif
-
-    switch(wb->cmd)
-    {
-#if defined(IS_BOOTLOADER)
-        case CTAPHID_BOOT:
-            printf1(TAG_HID,"CTAPHID_BOOT\n");
-            u2f_set_writeback_buffer(ctap_resp);
-            is_busy = bootloader_bridge(len, ctap_buffer);
-            wb->bcnt = 1 + ctap_resp->length;
-
-            ctaphid_write(wb, &is_busy, 1);
-            ctaphid_write(wb, ctap_resp->data, ctap_resp->length);
-            ctaphid_write(wb, NULL, 0);
-            return 1;
-#endif
-#if defined(SOLO)
-        case CTAPHID_ENTERBOOT:
-            printf1(TAG_HID,"CTAPHID_ENTERBOOT\n");
-            boot_solo_bootloader();
-            wb->bcnt = 0;
-            ctaphid_write(wb, NULL, 0);
-            return 1;
-#endif
-
-#if !defined(IS_BOOTLOADER)
-        case CTAPHID_GETRNG:
-            printf1(TAG_HID,"CTAPHID_GETRNG\n");
-            wb->bcnt = ctap_buffer[0];
-            if (!wb->bcnt)
-                wb->bcnt = 57;
-            memset(ctap_buffer,0,wb->bcnt);
-            ctap_generate_rng(ctap_buffer, wb->bcnt);
-            ctaphid_write(wb, ctap_buffer, wb->bcnt);
-            ctaphid_write(wb, NULL, 0);
-            return 1;
-        break;
-#endif
-
-        case CTAPHID_GETVERSION:
-            printf1(TAG_HID,"CTAPHID_GETVERSION\n");
-            wb->bcnt = 4;
-            ctap_buffer[0] = SOLO_VERSION_MAJ;
-            ctap_buffer[1] = SOLO_VERSION_MIN;
-            ctap_buffer[2] = SOLO_VERSION_PATCH;
-#if defined(SOLO)
-            ctap_buffer[3] = solo_is_locked();
-#else
-            ctap_buffer[3] = 0;
-#endif
-            ctaphid_write(wb, ctap_buffer, 4);
-            ctaphid_write(wb, NULL, 0);
-            return 1;
-        break;
-
-#if !defined(IS_BOOTLOADER) && (defined(SOLO_EXPERIMENTAL))
-        case CTAPHID_LOADKEY:
-            /**
-             * Load external key.  Useful for enabling backups.
-             * bytes:            4                   96
-             * payload: | counter_increase (BE) | master_key |
-             * 
-             * Counter should be increased by a large amount, e.g. (0x10000000)
-             * to outdo any previously lost/broken keys.
-            */
-            printf1(TAG_HID,"CTAPHID_LOADKEY\n");
-            if (len != 100)
-            {
-                printf2(TAG_ERR,"Error, invalid length.\n");
-                ctaphid_send_error(wb->cid, CTAP1_ERR_INVALID_LENGTH);
-                return 1;
-            }
-
-            // Ask for THREE button presses
-            if (ctap_user_presence_test(8000) > 0)
-                if (ctap_user_presence_test(8000) > 0)
-                    if (ctap_user_presence_test(8000) > 0)
-                    {
-                        ctap_load_external_keys(ctap_buffer + 4);
-                        param = ctap_buffer[3];
-                        param |= ctap_buffer[2] << 8;
-                        param |= ctap_buffer[1] << 16;
-                        param |= ctap_buffer[0] << 24;
-                        ctap_atomic_count(param);
-
-                        wb->bcnt = 0;
-
-                        ctaphid_write(wb, NULL, 0);
-                        return 1;
-                    }
-
-            printf2(TAG_ERR, "Error, invalid length.\n");
-            ctaphid_send_error(wb->cid, CTAP2_ERR_OPERATION_DENIED);
-            return 1;
-#endif
-
-
-        }
-
-        return 0;
-}
--- a/fido2/ctaphid.h
+++ b/fido2/ctaphid.h
@ -29,7 +29,6 @@
 #define CTAPHID_ENTERSTBOOT     (TYPE_INIT | 0x52)
 #define CTAPHID_GETRNG          (TYPE_INIT | 0x60)
 #define CTAPHID_GETVERSION      (TYPE_INIT | 0x61)
-#define CTAPHID_LOADKEY         (TYPE_INIT | 0x62)
 // reserved for debug, not implemented except for HACKER and DEBUG_LEVEl > 0
 #define CTAPHID_PROBE           (TYPE_INIT | 0x70)

--- a/fido2/device.h
+++ b/fido2/device.h
@ -61,8 +61,8 @@ int ctap_user_presence_test(uint32_t delay);
 int ctap_generate_rng(uint8_t * dst, size_t num);

 // Increment atomic counter and return it.
-// @param amount the amount to increase the counter by.
-uint32_t ctap_atomic_count(uint32_t amount);
+// Must support two counters, @sel selects counter0 or counter1.
+uint32_t ctap_atomic_count(int sel);

 // Verify the user
 // return 1 if user is verified, 0 if not
--- a/fido2/u2f.c
+++ b/fido2/u2f.c
@ -26,7 +26,6 @@ static int16_t u2f_authenticate(struct u2f_authenticate_request * req, uint8_t c
 int8_t u2f_response_writeback(const uint8_t * buf, uint16_t len);
 void u2f_reset_response();

-void make_auth_tag(uint8_t * rpIdHash, uint8_t * nonce, uint32_t count, uint8_t * tag);

 static CTAP_RESPONSE * _u2f_resp = NULL;

@ -161,9 +160,9 @@ static void dump_signature_der(uint8_t * sig)
    len = ctap_encode_der_sig(sig, sigder);
    u2f_response_writeback(sigder, len);
 }
-static int8_t u2f_load_key(struct u2f_key_handle * kh, uint8_t khl, uint8_t * appid)
+static int8_t u2f_load_key(struct u2f_key_handle * kh, uint8_t * appid)
 {
-    crypto_ecc256_load_key((uint8_t*)kh, khl, NULL, 0);
+    crypto_ecc256_load_key((uint8_t*)kh, U2F_KEY_HANDLE_SIZE, NULL, 0);
    return 0;
 }

@ -188,41 +187,21 @@ int8_t u2f_new_keypair(struct u2f_key_handle * kh, uint8_t * appid, uint8_t * pu


 // Return 1 if authenticate, 0 if not.
-int8_t u2f_authenticate_credential(struct u2f_key_handle * kh, uint8_t key_handle_len, uint8_t * appid)
+int8_t u2f_authenticate_credential(struct u2f_key_handle * kh, uint8_t * appid)
 {
-    printf1(TAG_U2F, "checked CRED SIZE %d. (FIDO2: %d)\n", key_handle_len, sizeof(CredentialId));
    uint8_t tag[U2F_KEY_HANDLE_TAG_SIZE];
-
-    if (key_handle_len == sizeof(CredentialId))
-    {
-        printf1(TAG_U2F, "FIDO2 key handle detected.\n");
-        CredentialId * cred = (CredentialId *) kh;
-        // FIDO2 credential.
-
-        if (memcmp(cred->rpIdHash, appid, 32) != 0)
-        {
-            printf1(TAG_U2F, "APPID does not match rpIdHash.\n");
-            return 0;
-        }
-        make_auth_tag(appid, cred->nonce, cred->count, tag);
-
-        if (memcmp(cred->tag, tag, CREDENTIAL_TAG_SIZE) == 0){
-            return 1;
-        }
-
-    }else if (key_handle_len == U2F_KEY_HANDLE_SIZE)
-    {
    u2f_make_auth_tag(kh, appid, tag);
    if (memcmp(kh->tag, tag, U2F_KEY_HANDLE_TAG_SIZE) == 0)
    {
        return 1;
    }
-    }
-
+    else
+    {
        printf1(TAG_U2F, "key handle + appid not authentic\n");
        printf1(TAG_U2F, "calc tag: \n"); dump_hex1(TAG_U2F,tag, U2F_KEY_HANDLE_TAG_SIZE);
        printf1(TAG_U2F, "inp  tag: \n"); dump_hex1(TAG_U2F,kh->tag, U2F_KEY_HANDLE_TAG_SIZE);
        return 0;
+    }
 }


@ -237,7 +216,7 @@ static int16_t u2f_authenticate(struct u2f_authenticate_request * req, uint8_t c
    if (control == U2F_AUTHENTICATE_CHECK)
    {
        printf1(TAG_U2F, "CHECK-ONLY\r\n");
-        if (u2f_authenticate_credential(&req->kh, req->khl, req->app))
+        if (u2f_authenticate_credential(&req->kh, req->app))
        {
            return U2F_SW_CONDITIONS_NOT_SATISFIED;
        }
@ -248,8 +227,9 @@ static int16_t u2f_authenticate(struct u2f_authenticate_request * req, uint8_t c
    }
    if (
            (control != U2F_AUTHENTICATE_SIGN && control != U2F_AUTHENTICATE_SIGN_NO_USER) ||
-            (!u2f_authenticate_credential(&req->kh, req->khl, req->app)) ||     // Order of checks is important
-            u2f_load_key(&req->kh, req->khl, req->app) != 0
+            req->khl != U2F_KEY_HANDLE_SIZE ||
+            (!u2f_authenticate_credential(&req->kh, req->app)) ||     // Order of checks is important
+            u2f_load_key(&req->kh, req->app) != 0

        )
    {
@ -306,7 +286,7 @@ static int16_t u2f_register(struct u2f_register_request * req)
    uint8_t * sig = (uint8_t*)req;


-    const uint16_t attest_size = attestation_cert_der_get_size();
+    const uint16_t attest_size = attestation_cert_der_size;

 	if ( ! ctap_user_presence_test(750))
 	{
--- a/fido2/u2f.h
+++ b/fido2/u2f.h
@ -103,7 +103,7 @@ void u2f_request(struct u2f_request_apdu* req, CTAP_RESPONSE * resp);
 // @len data length
 void u2f_request_nfc(uint8_t * header, uint8_t * data, int datalen, CTAP_RESPONSE * resp);

-int8_t u2f_authenticate_credential(struct u2f_key_handle * kh, uint8_t key_handle_len, uint8_t * appid);
+int8_t u2f_authenticate_credential(struct u2f_key_handle * kh, uint8_t * appid);

 int8_t u2f_response_writeback(const uint8_t * buf, uint16_t len);
 void u2f_reset_response();
--- a/fido2/version.c
+++ b/fido2/version.c
@ -1,13 +0,0 @@
-#include "version.h"
-
-
-const version_t firmware_version __attribute__ ((section (".flag"))) __attribute__ ((__used__)) =  {
-  .major = SOLO_VERSION_MAJ,
-  .minor = SOLO_VERSION_MIN,
-  .patch = SOLO_VERSION_PATCH,
-  .reserved = 0
-};
-
-// from tinycbor, for a quick static_assert
-#include <compilersupport_p.h>
-cbor_static_assert(sizeof(version_t) == 4);
--- a/fido2/version.h
+++ b/fido2/version.h
@ -17,23 +17,5 @@
 #define SOLO_VERSION     __STR(SOLO_VERSION_MAJ) "." __STR(SOLO_VERSION_MIN) "." __STR(SOLO_VERSION_PATCH)
 #endif

-#include <stdint.h>
-#include <stdbool.h>
-
-typedef struct {
-  union{
-    uint32_t raw;
-    struct {
-      uint8_t major;
-      uint8_t minor;
-      uint8_t patch;
-      uint8_t reserved;
-    };
-  };
-} version_t;
-
-bool is_newer(const version_t* const newer, const version_t* const older);
-const version_t firmware_version ;
-

 #endif
--- a/in-docker-build.sh
+++ b/in-docker-build.sh
@ -1,10 +1,14 @@
 #!/bin/bash -xe
-version=$1

-export PREFIX=/opt/gcc-arm-none-eabi-8-2019-q3-update/bin/
+version=${1:-master}
+
+export PREFIX=/opt/gcc-arm-none-eabi-8-2018-q4-major/bin/

 cd /solo/targets/stm32l432
-ls
+git fetch --tags
+git checkout ${version}
+git submodule update --init --recursive
+version=$(git describe)

 make cbor

@ -12,12 +16,13 @@ out_dir="/builds"

 function build() {
    part=${1}
-    output=${2}
-    what="${part}"
+    variant=${2}
+    output=${3:-${part}}
+    what="${part}-${variant}"

    make full-clean

-    make ${what} VERSION_FULL=${version}
+    make ${what}

    out_hex="${what}-${version}.hex"
    out_sha2="${what}-${version}.sha2"
@ -27,27 +32,24 @@ function build() {
    cp ${out_hex} ${out_sha2} ${out_dir}
 }

-build bootloader-nonverifying bootloader
-build bootloader-verifying bootloader
-build firmware solo
-build firmware-debug-1 solo
-build firmware-debug-2 solo
-build firmware solo
+build bootloader nonverifying
+build bootloader verifying
+build firmware hacker solo
+build firmware hacker-debug-1 solo
+build firmware hacker-debug-2 solo
+build firmware secure solo
+build firmware secure-non-solokeys solo

+pip install -U pip
+pip install -U solo-python
 cd ${out_dir}
-
 bundle="bundle-hacker-${version}"
-/opt/conda/bin/solo mergehex bootloader-nonverifying-${version}.hex firmware-${version}.hex ${bundle}.hex
+/opt/conda/bin/solo mergehex bootloader-nonverifying-${version}.hex firmware-hacker-${version}.hex ${bundle}.hex
 sha256sum ${bundle}.hex > ${bundle}.sha2
-
 bundle="bundle-hacker-debug-1-${version}"
-/opt/conda/bin/solo mergehex bootloader-nonverifying-${version}.hex firmware-debug-1-${version}.hex ${bundle}.hex
-sha256sum ${bundle}.hex > ${bundle}.sha2
-
+/opt/conda/bin/solo mergehex bootloader-nonverifying-${version}.hex firmware-hacker-debug-1-${version}.hex ${bundle}.hex
 bundle="bundle-hacker-debug-2-${version}"
-/opt/conda/bin/solo mergehex bootloader-nonverifying-${version}.hex firmware-debug-2-${version}.hex ${bundle}.hex
-sha256sum ${bundle}.hex > ${bundle}.sha2
-
+/opt/conda/bin/solo mergehex bootloader-nonverifying-${version}.hex firmware-hacker-debug-2-${version}.hex ${bundle}.hex
 bundle="bundle-secure-non-solokeys-${version}"
-/opt/conda/bin/solo mergehex --lock bootloader-verifying-${version}.hex firmware-${version}.hex ${bundle}.hex
+/opt/conda/bin/solo mergehex bootloader-verifying-${version}.hex firmware-secure-non-solokeys-${version}.hex ${bundle}.hex
 sha256sum ${bundle}.hex > ${bundle}.sha2
--- a/mkdocs.yml
+++ b/mkdocs.yml
@ -15,7 +15,6 @@ nav:
    - Bootloader mode: solo/bootloader-mode.md
    - Customization: solo/customization.md
    - Solo Extras: solo/solo-extras.md
-    - Application Ideas: solo/application-ideas.md
    - Running on Nucleo32 board: solo/nucleo32-board.md
    - Signed update process: solo/signed-updates.md
    - Code documentation: solo/code-overview.md
--- a/pc/device.c
+++ b/pc/device.c
@ -108,7 +108,6 @@ int udp_recv(int fd, uint8_t * buf, int size)
        perror( "recvfrom failed" );
        exit(1);
    }
-    printf1(TAG_DUMP, ">>"); dump_hex1(TAG_DUMP, buf, length);
    return length;
 }

@ -125,8 +124,6 @@ void udp_send(int fd, uint8_t * buf, int size)
        perror( "sendto failed" );
        exit(1);
    }
-
-    printf1(TAG_DUMP, "<<"); dump_hex1(TAG_DUMP, buf, size);
 }


@ -316,11 +313,20 @@ int ctap_user_verification(uint8_t arg)
 }


-uint32_t ctap_atomic_count(uint32_t amount)
+uint32_t ctap_atomic_count(int sel)
 {
    static uint32_t counter1 = 25;
-    counter1 += (amount + 1);
-    return counter1;
+    /*return 713;*/
+    if (sel == 0)
+    {
+        printf1(TAG_RED,"counter1: %d\n", counter1);
+        return counter1++;
+    }
+    else
+    {
+        printf2(TAG_ERR,"counter2 not imple\n");
+        exit(1);
+    }
 }

 int ctap_generate_rng(uint8_t * dst, size_t num)
--- a/targets/stm32l432/Makefile
+++ b/targets/stm32l432/Makefile
@ -2,9 +2,8 @@ ifndef DEBUG
 DEBUG=0
 endif

-VERSION_FULL?=$(shell git describe)
-APPMAKE=build/application.mk VERSION_FULL=${VERSION_FULL} 
-BOOTMAKE=build/bootloader.mk VERSION_FULL=${VERSION_FULL} 
+APPMAKE=build/application.mk
+BOOTMAKE=build/bootloader.mk

 merge_hex=solo mergehex

@ -13,14 +12,20 @@ merge_hex=solo mergehex

 # The following are the main targets for reproducible builds.
 # TODO: better explanation
-firmware:
-	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=0 
+firmware-hacker:
+	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=0 EXTRA_DEFINES='-DSOLO_HACKER -DFLASH_ROP=0'

-firmware-debug-1:
-	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=1 
+firmware-hacker-debug-1:
+	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=1 EXTRA_DEFINES='-DSOLO_HACKER -DFLASH_ROP=0'

-firmware-debug-2:
-	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=2 
+firmware-hacker-debug-2:
+	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=2 EXTRA_DEFINES='-DSOLO_HACKER -DFLASH_ROP=0'
+
+firmware-secure-non-solokeys:
+	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=0 EXTRA_DEFINES='-DFLASH_ROP=2'
+
+firmware-secure:
+	$(MAKE) -f $(APPMAKE) -j8 solo.hex PREFIX=$(PREFIX) DEBUG=0 EXTRA_DEFINES='-DUSE_SOLOKEYS_CERT -DFLASH_ROP=2'

 bootloader-nonverifying:
 	$(MAKE) -f $(BOOTMAKE) -j8 bootloader.hex PREFIX=$(PREFIX) EXTRA_DEFINES='-DSOLO_HACKER' DEBUG=0
@ -85,12 +90,13 @@ flash_dfu: solo.hex bootloader.hex
 	# STM32_Programmer_CLI -c port=usb1 -halt -e all --readunprotect
 	STM32_Programmer_CLI -c port=usb1 -halt -rdu  -d all.hex

-flashboot: bootloader.hex
+flashboot: solo.hex bootloader.hex
+	$(VENV) $(merge_hex) solo.hex bootloader.hex all.hex
 	STM32_Programmer_CLI -c port=SWD -halt -e all --readunprotect
 	STM32_Programmer_CLI -c port=SWD -halt  -d bootloader.hex -rst

 flash-firmware:
-	$(SZ) -A solo.elf
+	arm-none-eabi-size -A solo.elf
 	solo program aux enter-bootloader
 	solo program bootloader solo.hex

--- a/targets/stm32l432/bootloader/bootloader.c
+++ b/targets/stm32l432/bootloader/bootloader.c
@ -19,12 +19,6 @@
 #include "ctap_errors.h"
 #include "log.h"

-volatile version_t current_firmware_version __attribute__ ((section (".flag2"))) __attribute__ ((__used__)) =  {
-  .major = SOLO_VERSION_MAJ,
-  .minor = SOLO_VERSION_MIN,
-  .patch = SOLO_VERSION_PATCH,
-  .reserved = 0
-};

 extern uint8_t REBOOT_FLAG;

@ -62,6 +56,8 @@ static void erase_application()
    }
 }

+#define LAST_ADDR       (APPLICATION_END_ADDR-2048 + 8)
+#define LAST_PAGE       (APPLICATION_END_PAGE-1)
 static void disable_bootloader()
 {
    // Clear last 4 bytes of the last application page-1, which is 108th
@ -106,38 +102,6 @@ int is_bootloader_disabled()
    uint32_t * auth = (uint32_t *)(AUTH_WORD_ADDR+4);
    return *auth == 0;
 }
-uint8_t * last_written_app_address;
-
-#include "version.h"
-bool is_firmware_version_newer_or_equal()
-{
-
-    printf1(TAG_BOOT,"Current firmware version: %u.%u.%u.%u (%02x.%02x.%02x.%02x)\r\n",
-          current_firmware_version.major, current_firmware_version.minor, current_firmware_version.patch, current_firmware_version.reserved,
-          current_firmware_version.major, current_firmware_version.minor, current_firmware_version.patch, current_firmware_version.reserved
-          );
-  volatile version_t * new_version = ((volatile version_t *) last_written_app_address);
-  printf1(TAG_BOOT,"Uploaded firmware version: %u.%u.%u.%u (%02x.%02x.%02x.%02x)\r\n",
-          new_version->major, new_version->minor, new_version->patch, new_version->reserved,
-          new_version->major, new_version->minor, new_version->patch, new_version->reserved
-          );
-
-  const bool allowed = is_newer((const version_t *)new_version, (const version_t *)&current_firmware_version) || current_firmware_version.raw == 0xFFFFFFFF;
-  if (allowed){
-    printf1(TAG_BOOT, "Update allowed, setting new firmware version as current.\r\n");
-//    current_firmware_version.raw = new_version.raw;
-    uint8_t page[PAGE_SIZE];
-    memmove(page, (uint8_t*)BOOT_VERSION_ADDR, PAGE_SIZE);
-    memmove(page, (version_t *)new_version, 4);
-    printf1(TAG_BOOT, "Writing\r\n");
-    flash_erase_page(BOOT_VERSION_PAGE);
-    flash_write(BOOT_VERSION_ADDR, page, PAGE_SIZE);
-    printf1(TAG_BOOT, "Finish\r\n");
-  } else {
-    printf1(TAG_BOOT, "Firmware older - update not allowed.\r\n");
-  }
-  return allowed;
-}

 /**
 * Execute bootloader commands
@ -161,7 +125,10 @@ int bootloader_bridge(int klen, uint8_t * keyh)
        return CTAP1_ERR_INVALID_LENGTH;
    }
 #ifndef SOLO_HACKER
-    extern uint8_t *pubkey_boot;
+    uint8_t * pubkey = (uint8_t*)"\xd2\xa4\x2f\x8f\xb2\x31\x1c\xc1\xf7\x0c\x7e\x64\x32\xfb\xbb\xb4\xa3\xdd\x32\x20"
+                                 "\x0f\x1b\x88\x9c\xda\x62\xc2\x83\x25\x93\xdd\xb8\x75\x9d\xf9\x86\xee\x03\x6c\xce"
+                                 "\x34\x47\x71\x36\xb3\xb2\xad\x6d\x12\xb7\xbe\x49\x3e\x20\xa4\x61\xac\xc7\x71\xc7"
+                                 "\x1f\xa8\x14\xf2";

    const struct uECC_Curve_t * curve = NULL;
 #endif
@ -198,11 +165,12 @@ int bootloader_bridge(int klen, uint8_t * keyh)
            }
            // Do the actual write
            flash_write((uint32_t)ptr,req->payload, len);
-            last_written_app_address = (uint8_t *)ptr + len - 8 + 4;
+
+
            break;
        case BootDone:
            // Writing to flash finished. Request code validation.
-            printf1(TAG_BOOT, "BootDone: \r\n");
+            printf1(TAG_BOOT, "BootDone: ");
 #ifndef SOLO_HACKER
            if (len != 64)
            {
@ -217,23 +185,17 @@ int bootloader_bridge(int klen, uint8_t * keyh)
            crypto_sha256_final(hash);
            curve = uECC_secp256r1();
            // Verify incoming signature made over the SHA256 hash
-            if (
-                    !uECC_verify(pubkey_boot, hash, 32, req->payload, curve)
-            )
+            if (! uECC_verify(pubkey,
+                        hash,
+                        32,
+                        req->payload,
+                        curve))
            {
-              printf1(TAG_BOOT, "Signature invalid\r\n");
-                return CTAP2_ERR_OPERATION_DENIED;
-            }
-            if (!is_firmware_version_newer_or_equal()){
-              printf1(TAG_BOOT, "Firmware older - update not allowed.\r\n");
-              printf1(TAG_BOOT, "Rebooting...\r\n");
-              REBOOT_FLAG = 1;
                return CTAP2_ERR_OPERATION_DENIED;
            }
 #endif
            // Set the application validated, and mark for reboot.
            authorize_application();
-
            REBOOT_FLAG = 1;
            break;
        case BootCheck:
@ -256,7 +218,6 @@ int bootloader_bridge(int klen, uint8_t * keyh)
            break;
        case BootReboot:
            printf1(TAG_BOOT, "BootReboot.\r\n");
-            printf1(TAG_BOOT, "Application authorized: %d.\r\n", is_authorized_to_boot());
            REBOOT_FLAG = 1;
            break;
        case BootDisable:
@ -316,10 +277,3 @@ void bootloader_heartbeat()

    led_rgb(((val * g)<<8) | ((val*r) << 16) | (val*b));
 }
-
-uint32_t ctap_atomic_count(uint32_t amount)
-{
-    static uint32_t count = 1000;
-    count += (amount + 1);
-    return count;
-}
--- a/targets/stm32l432/bootloader/bootloader.h
+++ b/targets/stm32l432/bootloader/bootloader.h
@ -9,6 +9,7 @@
 #define _APP_H_
 #include <stdint.h>
 #include "version.h"
+
 #define DEBUG_UART      USART1

 #ifndef DEBUG_LEVEL
@ -20,7 +21,6 @@
 #define BOOT_TO_DFU         0


-#define SOLO                1
 #define IS_BOOTLOADER       1

 #define ENABLE_U2F_EXTENSIONS
@ -64,9 +64,4 @@ int is_authorized_to_boot();
 int is_bootloader_disabled();
 void bootloader_heartbeat();

-// Return 1 if Solo is secure/locked.
-int solo_is_locked();
-
-
-
 #endif
--- a/targets/stm32l432/bootloader/main.c
+++ b/targets/stm32l432/bootloader/main.c
@ -46,7 +46,9 @@ int main()
 {
    uint8_t hidmsg[64];
    uint32_t t1 = 0;
+#ifdef SOLO_HACKER
    uint32_t stboot_time = 0;
+#endif
    uint32_t boot = 1;

    set_logging_mask(
@ -96,6 +98,7 @@ int main()
    }


+#ifdef SOLO_HACKER
    if (!is_bootloader_disabled())
    {
        stboot_time = millis();
@ -105,6 +108,7 @@ int main()
            goto start_bootloader;
        }
    }
+#endif

    if (is_authorized_to_boot() && (boot || is_bootloader_disabled()))
    {
@ -115,8 +119,9 @@ int main()

        printf1(TAG_RED,"Not authorized to boot (%08x == %08lx)\r\n", AUTH_WORD_ADDR, *(uint32_t*)AUTH_WORD_ADDR);
    }
+#ifdef SOLO_HACKER
    start_bootloader:
-
+#endif
    SystemClock_Config();
    init_gpio();
    init_millisecond_timer(0);
@ -133,14 +138,6 @@ int main()

    printf1(TAG_GEN,"recv'ing hid msg \n");

-    extern volatile version_t current_firmware_version;
-    printf1(TAG_BOOT,"Current firmware version address: %p\r\n", &current_firmware_version);
-    printf1(TAG_BOOT,"Current firmware version: %d.%d.%d.%d (%02x.%02x.%02x.%02x)\r\n",
-            current_firmware_version.major, current_firmware_version.minor, current_firmware_version.patch, current_firmware_version.reserved,
-            current_firmware_version.major, current_firmware_version.minor, current_firmware_version.patch, current_firmware_version.reserved
-    );
-    dump_hex1(TAG_BOOT, (uint8_t*)(&current_firmware_version) - 16, 32);
-

    while(1)
    {
--- a/targets/stm32l432/bootloader/pubkey_bootloader.c
+++ b/targets/stm32l432/bootloader/pubkey_bootloader.c
@ -1,6 +0,0 @@
-#include "stdint.h"
-
-uint8_t * pubkey_boot = (uint8_t*)"\xd2\xa4\x2f\x8f\xb2\x31\x1c\xc1\xf7\x0c\x7e\x64\x32\xfb\xbb\xb4\xa3\xdd\x32\x20"
-                        "\x0f\x1b\x88\x9c\xda\x62\xc2\x83\x25\x93\xdd\xb8\x75\x9d\xf9\x86\xee\x03\x6c\xce"
-                        "\x34\x47\x71\x36\xb3\xb2\xad\x6d\x12\xb7\xbe\x49\x3e\x20\xa4\x61\xac\xc7\x71\xc7"
-                        "\x1f\xa8\x14\xf2";
--- a/targets/stm32l432/bootloader/version_check.c
+++ b/targets/stm32l432/bootloader/version_check.c
@ -1,8 +0,0 @@
-#include "version.h"
-
-//  FIXME test version check function
-bool is_newer(const version_t* const newer, const version_t* const older){
-  return (newer->major > older->major) ||
-         (newer->major == older->major &&  newer->minor > older->minor) ||
-         (newer->major == older->major &&  newer->minor == older->minor &&  newer->patch >= older->patch);
-}
--- a/targets/stm32l432/build/application.mk
+++ b/targets/stm32l432/build/application.mk
@ -10,7 +10,6 @@ SRC += $(DRIVER_LIBS) $(USB_LIB)
 SRC += ../../fido2/apdu.c ../../fido2/util.c ../../fido2/u2f.c ../../fido2/test_power.c
 SRC += ../../fido2/stubs.c ../../fido2/log.c  ../../fido2/ctaphid.c  ../../fido2/ctap.c
 SRC += ../../fido2/ctap_parse.c ../../fido2/main.c
-SRC += ../../fido2/version.c
 SRC += ../../fido2/data_migration.c
 SRC += ../../fido2/extensions/extensions.c ../../fido2/extensions/solo.c
 SRC += ../../fido2/extensions/wallet.c
@ -71,7 +70,6 @@ all: $(TARGET).elf

 %.elf: $(OBJ)
 	$(CC) $^ $(HW) $(LDFLAGS) -o $@
-	@echo "Built version: $(VERSION_FLAGS)"

 %.hex: %.elf
 	$(SZ) $^
--- a/targets/stm32l432/build/bootloader.mk
+++ b/targets/stm32l432/build/bootloader.mk
@ -2,7 +2,6 @@ include build/common.mk

 # ST related
 SRC = bootloader/main.c bootloader/bootloader.c
-SRC += bootloader/pubkey_bootloader.c bootloader/version_check.c
 SRC += src/init.c src/redirect.c src/flash.c src/rng.c src/led.c src/device.c
 SRC += src/fifo.c src/crypto.c src/attestation.c src/sense.c
 SRC += src/startup_stm32l432xx.s src/system_stm32l4xx.c
@ -66,7 +65,6 @@ all: $(TARGET).elf

 %.elf: $(OBJ)
 	$(CC) $^ $(HW) $(LDFLAGS) -o $@
-	$(SZ) $@

 %.hex: %.elf
 	$(CP) -O ihex $^ $(TARGET).hex
--- a/targets/stm32l432/build/common.mk
+++ b/targets/stm32l432/build/common.mk
@ -13,8 +13,8 @@ USB_LIB := lib/usbd/usbd_cdc.c lib/usbd/usbd_cdc_if.c lib/usbd/usbd_composite.c
       lib/usbd/usbd_ctlreq.c lib/usbd/usbd_desc.c lib/usbd/usbd_hid.c \
 	   lib/usbd/usbd_ccid.c

-VERSION_FULL?=$(shell git describe)
-VERSION:=$(shell python -c 'print("$(VERSION_FULL)".split("-")[0])')
+VERSION:=$(shell git describe --abbrev=0 )
+VERSION_FULL:=$(shell git describe)
 VERSION_MAJ:=$(shell python -c 'print("$(VERSION)".split(".")[0])')
 VERSION_MIN:=$(shell python -c 'print("$(VERSION)".split(".")[1])')
 VERSION_PAT:=$(shell python -c 'print("$(VERSION)".split(".")[2])')
--- a/targets/stm32l432/linker/bootloader_stm32l4xx.ld
+++ b/targets/stm32l432/linker/bootloader_stm32l4xx.ld
@ -12,17 +12,9 @@ _estack = 0x2000c000;

 _MIN_STACK_SIZE = 0x400;

-/*
-flash_cfg is for storing bootloader data, like last used firmware version.
-bootloader_configuration should be equal to (APPLICATION_END_PAGE) page address, from targets/stm32l432/src/memory_layout.h:30; and equal to flash_cfg origin
-*/
-
-bootloader_configuration = 0x08000000 + 216*1024+8;
-
 MEMORY
 {
    flash (rx)      : ORIGIN = 0x08000000, LENGTH = 20K
-    flash_cfg (rx)  : ORIGIN = 0x08000000 + 216*1024+8, LENGTH = 2K-8
    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }
@ -47,11 +39,6 @@ SECTIONS
        _etext = .;
    } >flash

-    .flag2 bootloader_configuration :
-    {
-      KEEP(*(.flag2)) ;
-    } > flash_cfg
-
    _sidata = LOADADDR(.data);

    .data :
--- a/targets/stm32l432/linker/bootloader_stm32l4xx_extra.ld
+++ b/targets/stm32l432/linker/bootloader_stm32l4xx_extra.ld
@ -12,17 +12,9 @@ _estack = 0x2000c000;

 _MIN_STACK_SIZE = 0x400;

-/*
-flash_cfg is for storing bootloader data, like last used firmware version.
-bootloader_configuration should be equal to (APPLICATION_END_PAGE) page address, from targets/stm32l432/src/memory_layout.h:30; and equal to flash_cfg origin
-*/
-
-bootloader_configuration = 0x08000000 + 216*1024+8;
-
 MEMORY
 {
    flash (rx)      : ORIGIN = 0x08000000, LENGTH = 32K
-    flash_cfg (rx)  : ORIGIN = 0x08000000 + 216*1024+8, LENGTH = 2K-8
    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }
@ -47,11 +39,6 @@ SECTIONS
        _etext = .;
    } >flash

-    .flag2 bootloader_configuration :
-    {
-      KEEP(*(.flag2)) ;
-    } > flash_cfg
-
    _sidata = LOADADDR(.data);

    .data :
--- a/targets/stm32l432/linker/stm32l4xx.ld
+++ b/targets/stm32l432/linker/stm32l4xx.ld
@ -13,21 +13,14 @@ _estack = 0x2000c000;
 _MIN_STACK_SIZE = 0x400;

 /*
-len  |   20 KB/10p|      196KB-8-8/98p   |        2kB/1p         |      38 KB/19p  |
-pos  |   0->20 KB |     20->216KB-8-8    |   216kB -> 218 kB     |   218->256 KB   |
-posp |    0-10    |      10-113          |        113-114        |       113-128   |
-desc | bootloader |       application    | bootloader data       |  secrets/data   |
-
-    Last 8 bytes in application space are occupied by bootloader flags - app
-    authorization and bootloader activation flag.
+    Memory layout of device:
+        20 KB            198KB-8            38 KB
+    | bootloader |    application     |  secrets/data |
 */

-/* Current firmware version number is concatenated to the firmware code - see .flag marker */
-/* flash length is (APPLICATION_END_PAGE-20*1024), where 20K is bootloader */
-
 MEMORY
 {
-    flash (rx)      : ORIGIN = 0x08000000 + 20K, LENGTH = 216K - 20K - 8
+    flash (rx)      : ORIGIN = 0x08005000, LENGTH = 198K - 8
    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }
@ -63,12 +56,6 @@ SECTIONS
        _edata = .;
    } >ram AT> flash

-    .flag :
-    {
-        . = ALIGN(8);
-      KEEP(*(.flag)) ;
-    } > flash
-
    .bss :
    {
        . = ALIGN(4);
--- a/targets/stm32l432/linker/stm32l4xx_extra.ld
+++ b/targets/stm32l432/linker/stm32l4xx_extra.ld
@ -12,22 +12,9 @@ _estack = 0x2000c000;

 _MIN_STACK_SIZE = 0x400;

-/*
-len  |   32 KB/16p|      184KB-8-8/92p   |        2kB/1p         |      38 KB/19p  |
-pos  |   0->32 KB |     32->216KB-8-8    |   216kB -> 218 kB     |   218->256 KB   |
-posp |    0-16    |      16-113          |        113-114        |       113-128   |
-desc | bootloader |       application    | bootloader data       |  secrets/data   |
-
-    Last 8 bytes in application space are occupied by bootloader flags - app
-    authorization and bootloader activation flag.
- */
-
-/* Current firmware version number is concatenated to the firmware code - see .flag marker */
-/* flash length is (APPLICATION_END_PAGE-20*1024), where 20K is bootloader */
-
 MEMORY
 {
-    flash (rx)      : ORIGIN = 0x08000000 + 20K + 12K, LENGTH = 216K - 20K - 12K - 8
+    flash (rx)      : ORIGIN = 0x08008000, LENGTH = 186K - 8
    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }
@ -63,12 +50,6 @@ SECTIONS
        _edata = .;
    } >ram AT> flash

-    .flag :
-    {
-        . = ALIGN(8);
-      KEEP(*(.flag)) ;
-    } > flash
-
    .bss :
    {
        . = ALIGN(4);
--- a/targets/stm32l432/src/ams.c
+++ b/targets/stm32l432/src/ams.c
@ -8,25 +8,21 @@
 #include "device.h"
 #include "nfc.h"

-static void flush_rx(void)
+static void flush_rx()
 {
    while(LL_SPI_IsActiveFlag_RXNE(SPI1) != 0)
    {
        LL_SPI_ReceiveData8(SPI1);
    }
 }
-
-
-static void wait_for_tx(void)
+static void wait_for_tx()
 {
    // while (LL_SPI_IsActiveFlag_BSY(SPI1) == 1)
    //     ;
    while(LL_SPI_GetTxFIFOLevel(SPI1) != LL_SPI_TX_FIFO_EMPTY)
        ;
 }
-
-
-static void wait_for_rx(void)
+static void wait_for_rx()
 {
    while(LL_SPI_IsActiveFlag_RXNE(SPI1) == 0)
        ;
@ -274,7 +270,7 @@ void ams_print_int1(uint8_t int0)
 #endif
 }

-int ams_init(void)
+int ams_init()
 {
    LL_GPIO_SetPinMode(SOLO_AMS_CS_PORT,SOLO_AMS_CS_PIN,LL_GPIO_MODE_OUTPUT);
    LL_GPIO_SetOutputPin(SOLO_AMS_CS_PORT,SOLO_AMS_CS_PIN);
@ -296,7 +292,7 @@ int ams_init(void)
    return 0;
 }

-void ams_configure(void)
+void ams_configure()
 {
    // Should not be used during passive operation.
    uint8_t block[4];
--- a/targets/stm32l432/src/ams.h
+++ b/targets/stm32l432/src/ams.h
@ -39,8 +39,8 @@ typedef union
 #define SELECT() LL_GPIO_ResetOutputPin(SOLO_AMS_CS_PORT,SOLO_AMS_CS_PIN)
 #define UNSELECT() LL_GPIO_SetOutputPin(SOLO_AMS_CS_PORT,SOLO_AMS_CS_PIN)

-int ams_init(void);
-void ams_configure(void);
+int ams_init();
+void ams_configure();

 void ams_read_buffer(uint8_t * data, int len);
 void ams_write_buffer(uint8_t * data, int len);
--- a/targets/stm32l432/src/app.h
+++ b/targets/stm32l432/src/app.h
@ -9,8 +9,6 @@
 #include <stdint.h>
 #include "version.h"

-#define SOLO
-
 #define DEBUG_UART      USART1

 #ifndef DEBUG_LEVEL
@ -48,9 +46,6 @@
 void printing_init();
 void hw_init(int lf);

-// Return 1 if Solo is secure/locked.
-int solo_is_locked();
-
 //#define TEST
 //#define TEST_POWER

--- a/targets/stm32l432/src/attestation.c
+++ b/targets/stm32l432/src/attestation.c
@ -6,10 +6,10 @@
 // copied, modified, or distributed except according to those terms.
 #include <stdint.h>
 #include "crypto.h"
-#include "memory_layout.h"

+#ifdef USE_SOLOKEYS_CERT

-const uint8_t attestation_solo_cert_der[] =
+const uint8_t attestation_cert_der[] =
 "\x30\x82\x02\xe1\x30\x82\x02\x88\xa0\x03\x02\x01\x02\x02\x01\x01\x30\x0a\x06\x08"
 "\x2a\x86\x48\xce\x3d\x04\x03\x02\x30\x81\x80\x31\x0b\x30\x09\x06\x03\x55\x04\x06"
 "\x13\x02\x55\x53\x31\x11\x30\x0f\x06\x03\x55\x04\x08\x0c\x08\x4d\x61\x72\x79\x6c"
@ -49,8 +49,11 @@ const uint8_t attestation_solo_cert_der[] =
 "\xf8\x84\xc3\x78\x35\x93\x63\x81\x2e\xbe\xa6\x12\x32\x6e\x29\x90\xc8\x91\x4b\x71"
 "\x52"
 ;
+#else

-const uint8_t attestation_hacker_cert_der[] =
+// For testing/development only
+
+const uint8_t attestation_cert_der[] =
 "\x30\x82\x02\xe9\x30\x82\x02\x8e\xa0\x03\x02\x01\x02\x02\x01\x01\x30\x0a\x06\x08"
 "\x2a\x86\x48\xce\x3d\x04\x03\x02\x30\x81\x82\x31\x0b\x30\x09\x06\x03\x55\x04\x06"
 "\x13\x02\x55\x53\x31\x11\x30\x0f\x06\x03\x55\x04\x08\x0c\x08\x4d\x61\x72\x79\x6c"
@ -91,16 +94,8 @@ const uint8_t attestation_hacker_cert_der[] =
 "\xf3\x87\x61\x82\xd8\xcd\x48\xfc\x57"
 ;

+#endif

-const uint16_t attestation_solo_cert_der_size = sizeof(attestation_solo_cert_der)-1;
-const uint16_t attestation_hacker_cert_der_size = sizeof(attestation_hacker_cert_der)-1;
-
-// const uint16_t attestation_key_size = 32;
-const uint8_t * attestation_cert_der = ((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_cert;
-
-#include "log.h"
-uint16_t attestation_cert_der_get_size(){
-    uint16_t sz = (uint16_t)((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_cert_size;
-    return sz;
-}
+const uint16_t attestation_cert_der_size = sizeof(attestation_cert_der)-1;

+const uint16_t attestation_key_size = 32;
--- a/targets/stm32l432/src/crypto.c
+++ b/targets/stm32l432/src/crypto.c
@ -61,13 +61,12 @@ static uint8_t master_secret[64];
 static uint8_t transport_secret[32];


-void crypto_sha256_init(void)
+void crypto_sha256_init()
 {
    sha256_init(&sha256_ctx);
 }

-void crypto_sha512_init(void)
-{
+void crypto_sha512_init() {
    cf_sha512_init(&sha512_ctx);
 }

@ -80,7 +79,7 @@ void crypto_load_master_secret(uint8_t * key)
    memmove(transport_secret, key+64, 32);
 }

-void crypto_reset_master_secret(void)
+void crypto_reset_master_secret()
 {
    memset(master_secret, 0, 64);
    memset(transport_secret, 0, 32);
@ -108,8 +107,7 @@ void crypto_sha256_final(uint8_t * hash)
    sha256_final(&sha256_ctx, hash);
 }

-void crypto_sha512_final(uint8_t * hash)
-{
+void crypto_sha512_final(uint8_t * hash) {
    // NB: there is also cf_sha512_digest
    cf_sha512_digest_final(&sha512_ctx, hash);
 }
@ -185,19 +183,18 @@ void crypto_sha256_hmac_final(uint8_t * key, uint32_t klen, uint8_t * hmac)
 }


-void crypto_ecc256_init(void)
+void crypto_ecc256_init()
 {
    uECC_set_rng((uECC_RNG_Function)ctap_generate_rng);
    _es256_curve = uECC_secp256r1();
 }


-void crypto_ecc256_load_attestation_key(void)
+void crypto_ecc256_load_attestation_key()
 {
-    // static uint8_t _key [32];
-    flash_attestation_page * page =(flash_attestation_page *)ATTESTATION_PAGE_ADDR;
-    // memmove(_key, (uint8_t *)ATTESTATION_KEY_ADDR, 32);
-    _signing_key = page->attestation_key;
+    static uint8_t _key [32];
+    memmove(_key, (uint8_t*)ATTESTATION_KEY_ADDR, 32);
+    _signing_key = _key;
    _key_len = 32;
 }

--- a/targets/stm32l432/src/device.c
+++ b/targets/stm32l432/src/device.c
@ -34,9 +34,7 @@
 #define LOW_FREQUENCY        1
 #define HIGH_FREQUENCY       0

-#define SOLO_FLAG_LOCKED                    0x2
-
-void wait_for_usb_tether(void);
+void wait_for_usb_tether();


 uint32_t __90_ms = 0;
@ -50,12 +48,12 @@ static bool isLowFreq = 0;
 static bool _up_disabled = false;

 // #define IS_BUTTON_PRESSED()         (0  == (LL_GPIO_ReadInputPort(SOLO_BUTTON_PORT) & SOLO_BUTTON_PIN))
-static int is_physical_button_pressed(void)
+static int is_physical_button_pressed()
 {
    return (0  == (LL_GPIO_ReadInputPort(SOLO_BUTTON_PORT) & SOLO_BUTTON_PIN));
 }

-static int is_touch_button_pressed(void)
+static int is_touch_button_pressed()
 {
    int is_pressed = (tsc_read_button(0) || tsc_read_button(1));
 #ifndef IS_BOOTLOADER
@ -71,7 +69,7 @@ static int is_touch_button_pressed(void)

 int (*IS_BUTTON_PRESSED)() = is_physical_button_pressed;

-static void edge_detect_touch_button(void)
+static void edge_detect_touch_button()
 {
    static uint8_t last_touch = 0;
    uint8_t current_touch = 0;
@ -94,13 +92,12 @@ static void edge_detect_touch_button(void)

 }

-void device_disable_up(bool disable)
-{
+void device_disable_up(bool disable) {
    _up_disabled = disable;
 }

 // Timer6 overflow handler.  happens every ~90ms.
-void TIM6_DAC_IRQHandler(void)
+void TIM6_DAC_IRQHandler()
 {
    // timer is only 16 bits, so roll it over here
    TIM6->SR = 0;
@ -145,7 +142,7 @@ void USB_IRQHandler(void)
  HAL_PCD_IRQHandler(&hpcd);
 }

-uint32_t millis(void)
+uint32_t millis()
 {
    return (((uint32_t)TIM6->CNT) + (__90_ms * 90));
 }
@ -163,7 +160,7 @@ void device_set_status(uint32_t status)
    __device_status = status;
 }

-int device_is_button_pressed(void)
+int device_is_button_pressed()
 {
    return IS_BUTTON_PRESSED();
 }
@ -174,13 +171,12 @@ void delay(uint32_t ms)
    while ((millis() - time) < ms)
        ;
 }
-
-void device_reboot(void)
+void device_reboot()
 {
    NVIC_SystemReset();
 }

-void device_init_button(void)
+void device_init_button()
 {
    if (tsc_sensor_exists())
    {
@ -193,98 +189,6 @@ void device_init_button(void)
    }
 }

-int solo_is_locked(){
-    uint64_t device_settings = ((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->device_settings;
-    uint32_t tag = (uint32_t)(device_settings >> 32ull);
-    return tag == ATTESTATION_CONFIGURED_TAG && (device_settings & SOLO_FLAG_LOCKED) != 0;
-}
-
-/** device_migrate
- * Depending on version of device, migrates:
- * * Moves attestation certificate to data segment. 
- * * Creates locked variable and stores in data segment.
- * 
- * Once in place, this allows all devices to accept same firmware,
- * rather than using "hacker" and "secure" builds.
-*/
-static void device_migrate(){
-    extern const uint16_t attestation_solo_cert_der_size;
-    extern const uint16_t attestation_hacker_cert_der_size;
-
-    extern uint8_t attestation_solo_cert_der[];
-    extern uint8_t attestation_hacker_cert_der[];
-
-    uint64_t device_settings = ((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->device_settings;
-    uint32_t configure_tag = (uint32_t)(device_settings >> 32);
-
-    if (configure_tag != ATTESTATION_CONFIGURED_TAG)
-    {
-        printf1(TAG_RED,"Migrating certificate and lock information to data segment.\r\n");
-
-        device_settings = ATTESTATION_CONFIGURED_TAG;
-        device_settings <<= 32;
-
-        // Read current device lock level.
-        uint32_t optr = FLASH->OPTR;
-        if ((optr & 0xff) != 0xAA){
-            device_settings |= SOLO_FLAG_LOCKED;
-        }
-
-        uint8_t tmp_attestation_key[32];
-
-        memmove(tmp_attestation_key,
-            ((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_key,
-            32);
-
-        flash_erase_page(ATTESTATION_PAGE);
-        flash_write(
-            (uint32_t)((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_key,
-            tmp_attestation_key,
-            32
-        );
-
-        // Check if this is Solo Hacker attestation (not confidential)
-        // then write solo or hacker attestation cert to flash page.
-        uint8_t solo_hacker_attestation_key[32] = "\x1b\x26\x26\xec\xc8\xf6\x9b\x0f\x69\xe3\x4f"
-                                                  "\xb2\x36\xd7\x64\x66\xba\x12\xac\x16\xc3\xab"
-                                                  "\x57\x50\xba\x06\x4e\x8b\x90\xe0\x24\x48";
-
-        if (memcmp(solo_hacker_attestation_key,
-                   tmp_attestation_key,
-                   32) == 0)
-        {
-            printf1(TAG_GREEN,"Updating solo hacker cert\r\n");
-            flash_write_dword(
-             (uint32_t)&((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_cert_size,
-             (uint64_t)attestation_hacker_cert_der_size
-             );
-            flash_write(
-                (uint32_t)((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_cert,
-                attestation_hacker_cert_der,
-                attestation_hacker_cert_der_size
-            );
-        }
-        else
-        {
-            printf1(TAG_GREEN,"Updating solo secure cert\r\n");
-            flash_write_dword(
-             (uint32_t)&((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_cert_size,
-             (uint64_t)attestation_solo_cert_der_size
-             );
-            flash_write(
-                (uint32_t)((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->attestation_cert,
-                attestation_solo_cert_der,
-                attestation_solo_cert_der_size
-            );
-        }
-
-        // Save / done.
-        flash_write_dword(
-            (uint32_t) & ((flash_attestation_page *)ATTESTATION_PAGE_ADDR)->device_settings,
-            (uint64_t)device_settings);
-    }
-}
-
 void device_init(int argc, char *argv[])
 {

@ -313,8 +217,6 @@ void device_init(int argc, char *argv[])
    ctaphid_init();
    ctap_init();

-    device_migrate();
-
 #if BOOT_TO_DFU
    flash_option_bytes_init(1);
 #else
@ -324,12 +226,12 @@ void device_init(int argc, char *argv[])

 }

-int device_is_nfc(void)
+int device_is_nfc()
 {
    return _NFC_status;
 }

-void wait_for_usb_tether(void)
+void wait_for_usb_tether()
 {
    while (USBD_OK != CDC_Transmit_FS((uint8_t*)"tethered\r\n", 10) )
        ;
@ -340,7 +242,7 @@ void wait_for_usb_tether(void)
        ;
 }

-void usbhid_init(void)
+void usbhid_init()
 {
    if (!isLowFreq)
    {
@ -390,12 +292,12 @@ void ctaphid_write_block(uint8_t * data)
 }


-void usbhid_close(void)
+void usbhid_close()
 {

 }

-void main_loop_delay(void)
+void main_loop_delay()
 {

 }
@ -405,14 +307,13 @@ static uint32_t winkt1 = 0;
 #ifdef LED_WINK_VALUE
 static uint32_t winkt2 = 0;
 #endif
-
-void device_wink(void)
+void device_wink()
 {
    wink_time = 10;
    winkt1 = 0;
 }

-void heartbeat(void)
+void heartbeat()
 {
    static int state = 0;
    static uint32_t val = (LED_MAX_SCALER - LED_MIN_SCALER)/2;
@ -481,7 +382,7 @@ void authenticator_read_backup_state(AuthenticatorState * a)
 }

 // Return 1 yes backup is init'd, else 0
-int authenticator_is_backup_initialized(void)
+int authenticator_is_backup_initialized()
 {
    uint8_t header[16];
    uint32_t * ptr = (uint32_t *)flash_addr(STATE2_PAGE);
@ -506,8 +407,7 @@ void authenticator_write_state(AuthenticatorState * a, int backup)
    }
 }

-#if !defined(IS_BOOTLOADER)
-uint32_t ctap_atomic_count(uint32_t amount)
+uint32_t ctap_atomic_count(int sel)
 {
    int offset = 0;
    uint32_t * ptr = (uint32_t *)flash_addr(COUNTER1_PAGE);
@ -522,12 +422,10 @@ uint32_t ctap_atomic_count(uint32_t amount)

    uint32_t lastc = 0;

-    if (amount == 0)
+    if (sel != 0)
    {
-        // Use a random count [1-16].
-        uint8_t rng[1];
-        ctap_generate_rng(rng, 1);
-        amount = (rng[0] & 0x0f) + 1;
+        printf2(TAG_ERR,"counter2 not imple\n");
+        exit(1);
    }

    for (offset = 0; offset < PAGE_SIZE/4; offset += 2) // wear-level the flash
@ -560,7 +458,7 @@ uint32_t ctap_atomic_count(uint32_t amount)
        return lastc;
    }

-    lastc += amount;
+    lastc++;

    if (lastc/256 > erases)
    {
@ -598,10 +496,10 @@ uint32_t ctap_atomic_count(uint32_t amount)

    return lastc;
 }
-#endif


-void device_manage(void)
+
+void device_manage()
 {
 #if NON_BLOCK_PRINTING
    int i = 10;
@ -627,7 +525,7 @@ void device_manage(void)
 #endif
 }

-static int handle_packets(void)
+static int handle_packets()
 {
    static uint8_t hidmsg[HID_PACKET_SIZE];
    memset(hidmsg,0, sizeof(hidmsg));
@ -663,7 +561,6 @@ static int wait_for_button_activate(uint32_t wait)
    } while (!IS_BUTTON_PRESSED());
    return 0;
 }
-
 static int wait_for_button_release(uint32_t wait)
 {
    int ret;
@ -757,7 +654,7 @@ int ctap_user_verification(uint8_t arg)
    return 1;
 }

-void ctap_reset_rk(void)
+void ctap_reset_rk()
 {
    int i;
    printf1(TAG_GREEN, "resetting RK \r\n");
@ -767,7 +664,7 @@ void ctap_reset_rk(void)
    }
 }

-uint32_t ctap_rk_size(void)
+uint32_t ctap_rk_size()
 {
    return RK_NUM_PAGES * (PAGE_SIZE / sizeof(CTAP_residentKey));
 }
@ -829,7 +726,7 @@ void ctap_overwrite_rk(int index,CTAP_residentKey * rk)
    }
 }

-void boot_st_bootloader(void)
+void boot_st_bootloader()
 {
    __disable_irq();

@ -841,7 +738,7 @@ void boot_st_bootloader(void)
    ;
 }

-void boot_solo_bootloader(void)
+void boot_solo_bootloader()
 {
    LL_IWDG_Enable(IWDG);

--- a/targets/stm32l432/src/flash.c
+++ b/targets/stm32l432/src/flash.c
@ -14,12 +14,12 @@
 #include "log.h"
 #include "device.h"

-static void flash_lock(void)
+static void flash_lock()
 {
    FLASH->CR |= (1U<<31);
 }

-static void flash_unlock(void)
+static void flash_unlock()
 {
    if (FLASH->CR & FLASH_CR_LOCK)
    {
@ -31,18 +31,21 @@ static void flash_unlock(void)
 // Locks flash and turns off DFU
 void flash_option_bytes_init(int boot_from_dfu)
 {
+#ifndef FLASH_ROP
+#define FLASH_ROP 0
+#endif
+#if FLASH_ROP == 0
    uint32_t val = 0xfffff8aa;
+#elif FLASH_ROP == 2
+    uint32_t val = 0xfffff8cc;
+#else
+    uint32_t val = 0xfffff8b9;
+#endif

-    if (boot_from_dfu){
+    if (boot_from_dfu)
+    {
        val &= ~(1<<27); // nBOOT0 = 0  (boot from system rom)
    }
-    else {
-        if (solo_is_locked())
-        {
-            val = 0xfffff8cc;
-        }
-    }
-
    val &= ~(1<<26); // nSWBOOT0 = 0  (boot from nBoot0)
    val &= ~(1<<25); // SRAM2_RST = 1 (erase sram on reset)
    val &= ~(1<<24); // SRAM2_PE = 1 (parity check en)
--- a/targets/stm32l432/src/init.c
+++ b/targets/stm32l432/src/init.c
@ -699,7 +699,7 @@ void SystemClock_Config_LF20(void)
    SET_BIT(RCC->APB1ENR1, RCC_APB1ENR1_PWREN);
 }

-void init_usb(void)
+void init_usb()
 {
    // enable USB power
    SET_BIT(PWR->CR2, PWR_CR2_USV);
--- a/targets/stm32l432/src/init.h
+++ b/targets/stm32l432/src/init.h
@ -22,7 +22,7 @@
 #ifndef _INIT_H_
 #define _INIT_H_

-void init_usb(void);
+void init_usb();
 void init_gpio(void);
 void init_debug_uart(void);
 void init_pwm(void);
--- a/targets/stm32l432/src/main.c
+++ b/targets/stm32l432/src/main.c
@ -57,11 +57,10 @@ void TIM6_DAC_IRQHandler()
    __90_ms += 1;
 }

-uint32_t millis(void)
+uint32_t millis()
 {
    return (((uint32_t)TIM6->CNT) + (__90_ms * 90));
 }
-
 void _Error_Handler(char *file, int line)
 {
    while(1)
--- a/targets/stm32l432/src/memory_layout.h
+++ b/targets/stm32l432/src/memory_layout.h
@ -20,9 +20,6 @@
 #define	STATE2_PAGE		(PAGES - 2)
 #define	STATE1_PAGE		(PAGES - 1)

-#define	STATE1_PAGE_ADDR		(0x08000000 + ((STATE1_PAGE)*PAGE_SIZE)) 
-#define	STATE2_PAGE_ADDR		(0x08000000 + ((STATE2_PAGE)*PAGE_SIZE)) 
-
 // Storage of FIDO2 resident keys
 #define RK_NUM_PAGES    10
 #define RK_START_PAGE   (PAGES - 14)
@ -35,51 +32,15 @@
 #define APPLICATION_START_ADDR	(0x08000000 + ((APPLICATION_START_PAGE)*PAGE_SIZE))

 // where attestation key is located
-#define ATTESTATION_PAGE        (PAGES - 15)
-#define ATTESTATION_PAGE_ADDR   (0x08000000 + ATTESTATION_PAGE*PAGE_SIZE)
+#define ATTESTATION_KEY_PAGE    (PAGES - 15)
+#define ATTESTATION_KEY_ADDR    (0x08000000 + ATTESTATION_KEY_PAGE*PAGE_SIZE)

 // End of application code.  Leave some extra room for future data storage.
 // NOT included in application
-#define APPLICATION_END_PAGE	((PAGES - 20))
+#define APPLICATION_END_PAGE	((PAGES - 19))
 #define APPLICATION_END_ADDR	((0x08000000 + ((APPLICATION_END_PAGE)*PAGE_SIZE))-8)

 // Bootloader state.
 #define AUTH_WORD_ADDR          (APPLICATION_END_ADDR)

-#define LAST_ADDR       (APPLICATION_END_ADDR-2048 + 8)
-#define BOOT_VERSION_PAGE    (APPLICATION_END_PAGE)
-#define BOOT_VERSION_ADDR    (0x08000000 + BOOT_VERSION_PAGE*FLASH_PAGE_SIZE + 8)
-#define LAST_PAGE       (APPLICATION_END_PAGE-1)
-
-struct flash_memory_st{
-  uint8_t bootloader[APPLICATION_START_PAGE*2*1024];
-  uint8_t application[(APPLICATION_END_PAGE-APPLICATION_START_PAGE)*2*1024-8];
-  uint8_t auth_word[4];
-  uint8_t bootloader_disabled[4];
-  // place for more user data
-  uint8_t _reserved_application_end_mark[8];
-  uint8_t bootloader_data[2*1024-8];
-  uint8_t user_data[38*1024];
-} __attribute__((packed));
-
-typedef struct flash_memory_st flash_memory_st;
-
-#include <assert.h>
-static_assert(sizeof(flash_memory_st) == 256*1024, "Data structure doesn't match flash size");
-
-#define ATTESTATION_CONFIGURED_TAG      0xaa551e78
-
-struct flash_attestation_page{
-  uint8_t attestation_key[32];
-  // DWORD padded.
-  uint64_t device_settings;
-  uint64_t attestation_cert_size;
-  uint8_t attestation_cert[2048 - 32 - 8 - 8];
-} __attribute__((packed));
-
-typedef struct flash_attestation_page flash_attestation_page;
-
-static_assert(sizeof(flash_attestation_page) == 2048, "Data structure doesn't match flash size");
-
-
 #endif
--- a/targets/stm32l432/src/nfc.c
+++ b/targets/stm32l432/src/nfc.c
@ -359,7 +359,7 @@ static uint32_t WTX_timer;

 bool WTX_process(int read_timeout);

-void WTX_clear(void)
+void WTX_clear()
 {
 	WTX_sent = false;
 	WTX_fail = false;
@ -374,7 +374,7 @@ bool WTX_on(int WTX_time)
 	return true;
 }

-bool WTX_off(void)
+bool WTX_off()
 {
 	WTX_timer = 0;

@ -398,7 +398,7 @@ bool WTX_off(void)
 	return true;
 }

-void WTX_timer_exec(void)
+void WTX_timer_exec()
 {
 	// condition: (timer on) or (not expired[300ms])
 	if ((WTX_timer == 0) || WTX_timer + 300 > millis())
@ -856,7 +856,7 @@ void nfc_process_iblock(uint8_t * buf, int len)
 static uint8_t ibuf[1024];
 static int ibuflen = 0;

-void clear_ibuf(void)
+void clear_ibuf()
 {
 	ibuflen = 0;
 	memset(ibuf, 0, sizeof(ibuf));
@ -969,7 +969,7 @@ void nfc_process_block(uint8_t * buf, unsigned int len)
    }
 }

-int nfc_loop(void)
+int nfc_loop()
 {
    uint8_t buf[32];
    AMS_DEVICE ams;
--- a/targets/stm32l432/src/nfc.h
+++ b/targets/stm32l432/src/nfc.h
@ -6,9 +6,9 @@
 #include "apdu.h"

 // Return number of bytes read if any.
-int nfc_loop(void);
+int nfc_loop();

-int nfc_init(void);
+int nfc_init();

 typedef struct
 {
@ -61,6 +61,6 @@ typedef enum
 	APP_FIDO,
 } APPLETS;

-void WTX_timer_exec(void);
+void WTX_timer_exec();

 #endif
--- a/targets/stm32l432/src/sense.c
+++ b/targets/stm32l432/src/sense.c
@ -8,7 +8,7 @@
 #define ELECTRODE_0     TSC_GROUP2_IO1
 #define ELECTRODE_1     TSC_GROUP2_IO2

-void tsc_init(void)
+void tsc_init()
 {
    LL_GPIO_InitTypeDef GPIO_InitStruct;
    // Enable TSC clock
@ -74,7 +74,7 @@ void tsc_set_electrode(uint32_t channel_ids)
    TSC->IOCCR = (channel_ids);
 }

-void tsc_start_acq(void)
+void tsc_start_acq()
 {
    TSC->CR &= ~(TSC_CR_START);

@ -86,7 +86,7 @@ void tsc_start_acq(void)
    TSC->CR |= TSC_CR_START;
 }

-void tsc_wait_on_acq(void)
+void tsc_wait_on_acq()
 {
    while ( ! (TSC->ISR & TSC_FLAG_EOA) )
        ;
@ -117,7 +117,7 @@ uint32_t tsc_read_button(uint32_t index)
    return tsc_read(1) < 45;
 }

-int tsc_sensor_exists(void)
+int tsc_sensor_exists()
 {
    static uint8_t does = 0;
    if (does) return 1;
--- a/targets/stm32l432/src/sense.h
+++ b/targets/stm32l432/src/sense.h
@ -3,9 +3,9 @@

 #include <stdint.h>

-void tsc_init(void);
+void tsc_init();

-int tsc_sensor_exists(void);
+int tsc_sensor_exists();

 // Read button0 or button1
 // Returns 1 if pressed, 0 if not.
Author	SHA1	Message	Date
Conor Patrick	8955a1ccf4	default up to enabled	2019-09-17 00:06:45 +08:00
Conor Patrick	16f07bfc95	allow in bootloader as well	2019-09-16 17:12:09 +08:00
Conor Patrick	0945ad264c	add get_version command to hid	2019-09-16 17:00:30 +08:00
Conor Patrick	b20ca7c5f7	delete old code	2019-09-16 17:00:13 +08:00
Conor Patrick	bc73ce8d21	allow get_assertion with disabled UP	2019-09-16 16:25:58 +08:00
Conor Patrick	2051ddb180	properly check the rpId in request	2019-09-16 15:33:38 +08:00
 @ -1 +1 @@
 .0.0
 .5.2