fix u2f counter for real

Merge pull request #155 from solokeys/pin_lockout_ga
Pin lockout ga
2019-03-31 23:29:00 -04:00 · 2019-03-29 17:11:48 -04:00 · 2019-03-26 19:00:42 -04:00 · 2019-03-26 19:00:12 -04:00 · 2019-03-26 18:33:03 -04:00 · 2019-03-26 16:36:08 -04:00
40 changed files with 2608 additions and 2996 deletions
--- a/1
+++ b/1
@ -0,0 +1 @@
+2.0.0
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -15,3 +15,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Extension interface to U2F and FIDO2
    - Read firmware version
    - Read RNG bytes
+
+## [1.1.1] - 2019-03-01
+
+- This version fixes an incorrect error code returned in U2F.  
+
+## [2.0.0] - 2019-03-01
+
+- Merge of NFC functionality branch
+- Bug fix with compiled USB name being too long causing buffer overrun
+- Change upper byte of counter from `0xff` to `0x7f` to fix issues with some websites.
--- a/1
+++ b/1
@ -0,0 +1 @@
+Apache-2.0 OR MIT
--- a/21
+++ b/21
@ -9,7 +9,9 @@

 ecc_platform=2

-src = $(wildcard pc/*.c) $(wildcard fido2/*.c) $(wildcard crypto/sha256/*.c) crypto/tiny-AES-c/aes.c
+src = $(wildcard pc/*.c) $(wildcard fido2/*.c) $(wildcard fido2/extensions/*.c) \
+	$(wildcard crypto/sha256/*.c) crypto/tiny-AES-c/aes.c
+
 obj = $(src:.c=.o) crypto/micro-ecc/uECC.o

 LIBCBOR = tinycbor/lib/libtinycbor.a
@ -20,7 +22,17 @@ else
  export LDFLAGS = -Wl,--gc-sections
 endif
 LDFLAGS += $(LIBCBOR)
-CFLAGS = -O2 -fdata-sections -ffunction-sections
+
+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])')
+
+VERSION_FLAGS= -DSOLO_VERSION_MAJ=$(VERSION_MAJ) -DSOLO_VERSION_MIN=$(VERSION_MIN) \
+	-DSOLO_VERSION_PATCH=$(VERSION_PAT) -DSOLO_VERSION=\"$(VERSION_FULL)\"
+
+CFLAGS = -O2 -fdata-sections -ffunction-sections $(VERSION_FLAGS)

 INCLUDES = -I./tinycbor/src -I./crypto/sha256 -I./crypto/micro-ecc/ -Icrypto/tiny-AES-c/ -I./fido2/ -I./pc -I./fido2/extensions
 INCLUDES += -I./crypto/cifra/src
@ -83,6 +95,11 @@ docker-build:
 	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)
+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

--- a/README.md
+++ b/README.md
@ -4,6 +4,12 @@
 [![Keybase Chat](https://img.shields.io/badge/chat-on%20keybase-brightgreen.svg)](https://keybase.io/team/solokeys.public)
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fsolokeys%2Fsolo.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fsolokeys%2Fsolo?ref=badge_shield)

+[![latest release](https://img.shields.io/github/release/solokeys/solo.svg)](https://github.com/solokeys/solo/releases)
+[![commits since last release](https://img.shields.io/github/commits-since/solokeys/solo/latest.svg)](https://github.com/solokeys/solo/commits/master)
+[![last commit](https://img.shields.io/github/last-commit/solokeys/solo.svg)](https://github.com/solokeys/solo/commits/master)
+[![commit activity](https://img.shields.io/github/commit-activity/m/solokeys/solo.svg)](https://github.com/solokeys/solo/commits/master)
+[![contributors](https://img.shields.io/github/contributors/solokeys/solo.svg)](https://github.com/solokeys/solo/graphs/contributors)
+

 # Solo

@ -13,7 +19,7 @@ Solo supports FIDO2 and U2F standards for strong two-factor authentication and p

 <img src="https://solokeys.com/images/photos/hero-on-white-cropped.png" width="600">

-This repo contains the Solo firmware, including implementations of FIDO2 and U2F (CTAP2 and CTAP) over USB and NFC. The main implementation is for STM32L432, and it's ported to NRF52840 and EFM32J.
+This repo contains the Solo firmware, including implementations of FIDO2 and U2F (CTAP2 and CTAP) over USB and NFC. The main implementation is for STM32L432, but it is easily portable.

 For development no hardware is needed, Solo also runs as a standalone application for Windows, Linux, and Mac OSX. If you like (or want to learn) hardware instead, you can run Solo on the NUCLEO-L432KC development board, or we make Solo for Hacker, an unlocked version of Solo that lets you customize its firmware.

@ -33,7 +39,7 @@ Solo is based on the STM32L432 microcontroller. It offers the following security

 Solo for Hacker is a special version of Solo that let you customize its firmware, for example you can change the LED color, and even build advanced applications.

-You can only buy Solo for Hacker at [solokeys.com](https://solokeys.com), as we don't sell it on Amazon and other places to avoid confusing customers. If you buy a Hacker, you can permanently lock it into a regular Solo, but viceversa you can NOT take a regular Solo and turn it a Hacker.
+Check out [solokeys.com](https://solokeys.com), for options on where to buy Solo.  Solo Hacker can be converted to a secure version, but normal Solo cannot be converted to a Hacker version.

 If you have a Solo for Hacker, here's how you can load your own code on it. You can find more details, including how to permanently lock it, in our [documentation](https://docs.solokeys.io/solo/building/). We only support Python3.

@ -56,17 +62,14 @@ 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/led.c#L15) and force:
-```
-uint32_t b = 0;
-```
+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 blue-light-free version of Solo.
+Then recompile, load your new firmware, and enjoy a different LED color Solo.

-In the Hacker version, hardware is the same and firmware is unlocked, in the sense that 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.
-
-A frequently asked question is whether Solo for Hacker is less secure than regular Solo. The answer is certainly yes, and therefore we only recommend to use Solo for Hacker for development, experimentation, and fun. 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.
+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)

@ -83,7 +86,7 @@ This builds Solo as a standalone application. Solo application is set up to send
 Testing can be done using our fork of Yubico's client software, python-fido2. Our fork of python-fido2 has small changes to make it send USB HID over UDP to the authenticator application. You can install our fork by running the following:

 ```bash
-cd python-fido2 && python setup.py install
+pip install -r tools/requirements.txt
 ```

 Run the Solo application:
@ -93,12 +96,7 @@ Run the Solo application:

 In another shell, you can run client software, for example our tests:
 ```bash
-python tools/ctap_test.py
-```
-
-Or any client example such as:
-```bash
-python python-fido2/examples/credential.py
+python tools/ctap_test.py sim fido2
 ```

 You can find more details in our [documentation](https://docs.solokeys.io/solo/), including how to build on the the NUCLEO-L432KC development board.
--- a/2
+++ b/2
@ -1 +1 @@
-1.1.1
+2.0.0
--- a/docs/solo/udev.md
+++ b/docs/solo/udev.md
@ -1,24 +1,31 @@
-# tl;dr
+# Summary

-Create a file like [`/etc/udev/rules.d/99-solo.rules`](https://github.com/solokeys/solo/blob/master/99-solo.rules), for instance the following rules should cover access in all cases:
+On Linux, by default USB dongles can't be accessed by users, for security reasons. To allow user access, so-called "udev rules" must be installed. (Under Fedora, your key may work without such a rule.)
+
+Create a file like [`70-solokeys-access.rules`](https://github.com/solokeys/solo/blob/master/udev/70-solokeys-access.rules) in your `/etc/udev/rules.d` directory, for instance the following rule should cover normal access (it has to be on one line):

 ```
-# Solo bootloader + firmware
-ATTRS{idVendor}=="0483", ATTRS{idProduct}=="a2ca", TAG+="uaccess", GROUP="plugdev"
-
-# ST DFU bootloader
-ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", TAG+="uaccess", GROUP="plugdev"
-
-# U2F Zero
-ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="8acf", TAG+="uaccess", GROUP="plugdev"
+SUBSYSTEM=="hidraw", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="a2ca", TAG+="uaccess", MODE="0660", GROUP="plugdev"
 ```

-Then run
+Additionally, run the following command after you create this file (it is not necessary to do this again in the future):

 ```
 sudo udevadm control --reload-rules && sudo udevadm trigger
 ```

+A simple way to setup both the udev rule and the udevadm reload is:
+
+```
+git clone git@github.com:solokeys/solo.git
+cd solo/udev
+make setup
+```
+
+We are working on getting user access to Solo keys enabled automatically in common Linux distributions: <https://github.com/solokeys/solo/issues/144>.
+
+
+
 # How do udev rules work and why are they needed

 In Linux, `udev` (part of `systemd`, read `man 7 udev`) handles "hot-pluggable" devices, of which Solo and U2F Zero are examples. In particular, it creates nodes in the `/dev` filesystem (in Linux, everything is a file), which allow accessing the device.
--- a/fido2/ctap.c
+++ b/fido2/ctap.c
@ -33,7 +33,6 @@ static int8_t PIN_BOOT_ATTEMPTS_LEFT = PIN_BOOT_ATTEMPTS;

 AuthenticatorState STATE;

-
 static void ctap_reset_key_agreement();

 static struct {
@ -69,6 +68,8 @@ uint8_t verify_pin_auth(uint8_t * pinAuth, uint8_t * clientDataHash)

 }

+
+
 uint8_t ctap_get_info(CborEncoder * encoder)
 {
    int ret;
@ -77,16 +78,14 @@ uint8_t ctap_get_info(CborEncoder * encoder)
    CborEncoder options;
    CborEncoder pins;

-    const int number_of_versions = 2;
-
-    ret = cbor_encoder_create_map(encoder, &map, 5);
+    ret = cbor_encoder_create_map(encoder, &map, 6);
    check_ret(ret);
    {

        ret = cbor_encode_uint(&map, RESP_versions);     //  versions key
        check_ret(ret);
        {
-            ret = cbor_encoder_create_array(&map, &array, number_of_versions);
+            ret = cbor_encoder_create_array(&map, &array, 2);
            check_ret(ret);
            {
                ret = cbor_encode_text_stringz(&array, "U2F_V2");
@ -98,6 +97,19 @@ uint8_t ctap_get_info(CborEncoder * encoder)
            check_ret(ret);
        }

+        ret = cbor_encode_uint(&map, RESP_extensions);
+        check_ret(ret);
+        {
+            ret = cbor_encoder_create_array(&map, &array, 1);
+            check_ret(ret);
+            {
+                ret = cbor_encode_text_stringz(&array, "hmac-secret");
+                check_ret(ret);
+            }
+            ret = cbor_encoder_close_container(&map, &array);
+            check_ret(ret);
+        }
+
        ret = cbor_encode_uint(&map, RESP_aaguid);
        check_ret(ret);
        {
@ -311,18 +323,123 @@ static int is_matching_rk(CTAP_residentKey * rk, CTAP_residentKey * rk2)
           (rk->user.id_size == rk2->user.id_size);
 }

+static int ctap_make_extensions(CTAP_extensions * ext, uint8_t * ext_encoder_buf, unsigned int * ext_encoder_buf_size)
+{
+    CborEncoder extensions;
+    int ret;
+    uint8_t output[64];
+    uint8_t shared_secret[32];
+    uint8_t hmac[32];
+    uint8_t credRandom[32];

-static int ctap_make_auth_data(struct rpId * rp, CborEncoder * map, uint8_t * auth_data_buf, unsigned int len, CTAP_userEntity * user, uint8_t credtype, int32_t algtype, int32_t * sz, int store)
+    if (ext->hmac_secret_present == EXT_HMAC_SECRET_PARSED)
+    {
+        printf1(TAG_CTAP, "Processing hmac-secret..\r\n");
+
+        crypto_ecc256_shared_secret((uint8_t*) &ext->hmac_secret.keyAgreement.pubkey,
+                                    KEY_AGREEMENT_PRIV,
+                                    shared_secret);
+        crypto_sha256_init();
+        crypto_sha256_update(shared_secret, 32);
+        crypto_sha256_final(shared_secret);
+
+        crypto_sha256_hmac_init(shared_secret, 32, hmac);
+        crypto_sha256_update(ext->hmac_secret.saltEnc, ext->hmac_secret.saltLen);
+        crypto_sha256_hmac_final(shared_secret, 32, hmac);
+
+        if (memcmp(ext->hmac_secret.saltAuth, hmac, 16) == 0)
+        {
+            printf1(TAG_CTAP, "saltAuth is valid\r\n");
+        }
+        else
+        {
+            printf1(TAG_CTAP, "saltAuth is invalid\r\n");
+            return CTAP2_ERR_EXTENSION_FIRST;
+        }
+
+        // Generate credRandom
+        crypto_sha256_hmac_init(CRYPTO_TRANSPORT_KEY, 0, credRandom);
+        crypto_sha256_update((uint8_t*)&ext->hmac_secret.credential->id, sizeof(CredentialId));
+        crypto_sha256_hmac_final(CRYPTO_TRANSPORT_KEY, 0, credRandom);
+
+        // Decrypt saltEnc
+        crypto_aes256_init(shared_secret, NULL);
+        crypto_aes256_decrypt(ext->hmac_secret.saltEnc, ext->hmac_secret.saltLen);
+
+        // Generate outputs
+        crypto_sha256_hmac_init(credRandom, 32, output);
+        crypto_sha256_update(ext->hmac_secret.saltEnc, 32);
+        crypto_sha256_hmac_final(credRandom, 32, output);
+
+        if (ext->hmac_secret.saltLen == 64)
+        {
+            crypto_sha256_hmac_init(credRandom, 32, output + 32);
+            crypto_sha256_update(ext->hmac_secret.saltEnc + 32, 32);
+            crypto_sha256_hmac_final(credRandom, 32, output + 32);
+        }
+
+        // Encrypt for final output
+        crypto_aes256_init(shared_secret, NULL);
+        crypto_aes256_encrypt(output, ext->hmac_secret.saltLen);
+
+        // output
+        printf1(TAG_GREEN, "have %d bytes for Extenstions encoder\r\n",*ext_encoder_buf_size);
+        cbor_encoder_init(&extensions, ext_encoder_buf, *ext_encoder_buf_size, 0);
+        {
+            CborEncoder hmac_secret_map;
+            ret = cbor_encoder_create_map(&extensions, &hmac_secret_map, 1);
+            check_ret(ret);
+            {
+                ret = cbor_encode_text_stringz(&hmac_secret_map, "hmac-secret");
+                check_ret(ret);
+
+                ret = cbor_encode_byte_string(&hmac_secret_map, output, ext->hmac_secret.saltLen);
+                check_ret(ret);
+            }
+            ret = cbor_encoder_close_container(&extensions, &hmac_secret_map);
+            check_ret(ret);
+        }
+        *ext_encoder_buf_size = cbor_encoder_get_buffer_size(&extensions, ext_encoder_buf);
+    }
+    else if (ext->hmac_secret_present == EXT_HMAC_SECRET_REQUESTED)
+    {
+        cbor_encoder_init(&extensions, ext_encoder_buf, *ext_encoder_buf_size, 0);
+        {
+            CborEncoder hmac_secret_map;
+            ret = cbor_encoder_create_map(&extensions, &hmac_secret_map, 1);
+            check_ret(ret);
+            {
+                ret = cbor_encode_text_stringz(&hmac_secret_map, "hmac-secret");
+                check_ret(ret);
+
+                ret = cbor_encode_boolean(&hmac_secret_map, 1);
+                check_ret(ret);
+            }
+            ret = cbor_encoder_close_container(&extensions, &hmac_secret_map);
+            check_ret(ret);
+        }
+        *ext_encoder_buf_size = cbor_encoder_get_buffer_size(&extensions, ext_encoder_buf);
+    }
+    else
+    {
+        *ext_encoder_buf_size = 0;
+    }
+    return 0;
+}
+
+
+static int ctap_make_auth_data(struct rpId * rp, CborEncoder * map, uint8_t * auth_data_buf, uint32_t * len, CTAP_credInfo * credInfo)
 {
    CborEncoder cose_key;
-    int auth_data_sz, ret;
+
+    unsigned int auth_data_sz = sizeof(CTAP_authDataHeader);
    uint32_t count;
    CTAP_residentKey rk, rk2;
    CTAP_authData * authData = (CTAP_authData *)auth_data_buf;

    uint8_t * cose_key_buf = auth_data_buf + sizeof(CTAP_authData);

-    if((sizeof(CTAP_authDataHeader)) > len)
+    if((sizeof(CTAP_authDataHeader)) > *len)
    {
        printf1(TAG_ERR,"assertion fail, auth_data_buf must be at least %d bytes\n", sizeof(CTAP_authData) - sizeof(CTAP_attestHeader));
        exit(1);
@ -359,13 +476,12 @@ static int ctap_make_auth_data(struct rpId * rp, CborEncoder * map, uint8_t * au
    authData->head.flags |= (ctap_is_pin_set() << 2);


-
-    if (credtype != 0)
+    if (credInfo != NULL)
    {
        // add attestedCredentialData
        authData->head.flags |= (1 << 6);//include attestation data

-        cbor_encoder_init(&cose_key, cose_key_buf, len - sizeof(CTAP_authData), 0);
+        cbor_encoder_init(&cose_key, cose_key_buf, *len - sizeof(CTAP_authData), 0);

        memmove(authData->attest.aaguid, CTAP_AAGUID, 16);
        authData->attest.credLenL =  sizeof(CredentialId) & 0x00FF;
@ -383,10 +499,10 @@ static int ctap_make_auth_data(struct rpId * rp, CborEncoder * map, uint8_t * au
        make_auth_tag(authData->head.rpIdHash, authData->attest.id.nonce, count, authData->attest.id.tag);

        // resident key
-        if (store)
+        if (credInfo->rk)
        {
            memmove(&rk.id, &authData->attest.id, sizeof(CredentialId));
-            memmove(&rk.user, user, sizeof(CTAP_userEntity));
+            memmove(&rk.user, &credInfo->user, sizeof(CTAP_userEntity));

            unsigned int index = STATE.rk_stored;
            unsigned int i;
@ -410,29 +526,19 @@ static int ctap_make_auth_data(struct rpId * rp, CborEncoder * map, uint8_t * au
        }
 done_rk:

-        // DELETE
-        //crypto_aes256_init(CRYPTO_TRANSPORT_KEY, NULL);
-        //crypto_aes256_encrypt((uint8_t*)&authData->attest.credential.user, CREDENTIAL_ENC_SIZE);
        printf1(TAG_GREEN, "MADE credId: "); dump_hex1(TAG_GREEN, (uint8_t*) &authData->attest.id, sizeof(CredentialId));

-        ctap_generate_cose_key(&cose_key, (uint8_t*)&authData->attest.id, sizeof(CredentialId), credtype, algtype);
+        ctap_generate_cose_key(&cose_key, (uint8_t*)&authData->attest.id, sizeof(CredentialId), credInfo->publicKeyCredentialType, credInfo->COSEAlgorithmIdentifier);

        auth_data_sz = sizeof(CTAP_authData) + cbor_encoder_get_buffer_size(&cose_key, cose_key_buf);

    }
-    else
-    {
-        auth_data_sz = sizeof(CTAP_authDataHeader);
-    }

-    {
-        ret = cbor_encode_int(map,RESP_authData);
-        check_ret(ret);
-        ret = cbor_encode_byte_string(map, auth_data_buf, auth_data_sz);
-        check_ret(ret);
-    }

-    if (sz) *sz = auth_data_sz;
+
+
+
+    *len = auth_data_sz;
    return 0;
 }

@ -559,7 +665,7 @@ uint8_t ctap_make_credential(CborEncoder * encoder, uint8_t * request, int lengt
    CTAP_makeCredential MC;
    int ret;
    unsigned int i;
-    uint8_t auth_data_buf[300];
+    uint8_t auth_data_buf[310];
    CTAP_credentialDescriptor * excl_cred = (CTAP_credentialDescriptor *) auth_data_buf;
    uint8_t * sigbuf = auth_data_buf + 32;
    uint8_t * sigder = auth_data_buf + 32 + 64;
@ -624,13 +730,32 @@ uint8_t ctap_make_credential(CborEncoder * encoder, uint8_t * request, int lengt
    CborEncoder map;
    ret = cbor_encoder_create_map(encoder, &map, 3);
    check_ret(ret);
-    int32_t auth_data_sz;
-
-    ret = ctap_make_auth_data(&MC.rp, &map, auth_data_buf, sizeof(auth_data_buf),
-            &MC.user, MC.publicKeyCredentialType, MC.COSEAlgorithmIdentifier, &auth_data_sz, MC.rk);
+    uint32_t auth_data_sz = sizeof(auth_data_buf);

+    ret = ctap_make_auth_data(&MC.rp, &map, auth_data_buf, &auth_data_sz,
+            &MC.credInfo);
    check_retr(ret);

+    {
+        unsigned int ext_encoder_buf_size = sizeof(auth_data_buf) - auth_data_sz;
+        uint8_t * ext_encoder_buf = auth_data_buf + auth_data_sz;
+
+        ret = ctap_make_extensions(&MC.extensions, ext_encoder_buf, &ext_encoder_buf_size);
+        check_retr(ret);
+        if (ext_encoder_buf_size)
+        {
+            ((CTAP_authData *)auth_data_buf)->head.flags |= (1 << 7);
+            auth_data_sz += ext_encoder_buf_size;
+        }
+    }
+
+    {
+        ret = cbor_encode_int(&map,RESP_authData);
+        check_ret(ret);
+        ret = cbor_encode_byte_string(&map, auth_data_buf, auth_data_sz);
+        check_ret(ret);
+    }
+
    crypto_ecc256_load_attestation_key();
    int sigder_sz = ctap_calculate_signature(auth_data_buf, auth_data_sz, MC.clientDataHash, auth_data_buf, sigbuf, sigder);
    printf1(TAG_MC,"der sig [%d]: ", sigder_sz); dump_hex1(TAG_MC, sigder, sigder_sz);
@ -852,6 +977,7 @@ static void save_credential_list(CTAP_authDataHeader * head, uint8_t * clientDat
        memmove(getAssertionState.clientDataHash, clientDataHash, CLIENT_DATA_HASH_SIZE);
        memmove(&getAssertionState.authData, head, sizeof(CTAP_authDataHeader));
        memmove(getAssertionState.creds, creds, sizeof(CTAP_credentialDescriptor) * (count));
+
    }
    getAssertionState.count = count;
    printf1(TAG_GA,"saved %d credentials\n",count);
@ -916,7 +1042,6 @@ uint8_t ctap_get_next_assertion(CborEncoder * encoder)
    CborEncoder map;
    CTAP_authDataHeader authData;
    memmove(&authData, &getAssertionState.authData, sizeof(CTAP_authDataHeader));
-    // CTAP_authDataHeader * authData = &getAssertionState.authData;

    CTAP_credentialDescriptor * cred = pop_credential();

@ -939,6 +1064,7 @@ uint8_t ctap_get_next_assertion(CborEncoder * encoder)
        ret = cbor_encoder_create_map(encoder, &map, 3);
    }

+
    check_ret(ret);
    printf1(TAG_RED, "RPID hash: "); dump_hex1(TAG_RED, authData.rpIdHash, 32);

@ -949,6 +1075,7 @@ uint8_t ctap_get_next_assertion(CborEncoder * encoder)
        check_ret(ret);
    }

+
    // if only one account for this RP, null out the user details
    if (!getAssertionState.user_verified)
    {
@ -969,7 +1096,7 @@ uint8_t ctap_get_next_assertion(CborEncoder * encoder)
 uint8_t ctap_get_assertion(CborEncoder * encoder, uint8_t * request, int length)
 {
    CTAP_getAssertion GA;
-    uint8_t auth_data_buf[sizeof(CTAP_authDataHeader)];
+    uint8_t auth_data_buf[sizeof(CTAP_authDataHeader) + 80];
    int ret = ctap_parse_get_assertion(&GA,request,length);

    if (ret != 0)
@ -978,19 +1105,15 @@ uint8_t ctap_get_assertion(CborEncoder * encoder, uint8_t * request, int length)
        return ret;
    }

-    if (ctap_is_pin_set() && GA.pinAuthPresent == 0)
-    {
-        printf2(TAG_ERR,"pinAuth is required\n");
-        return CTAP2_ERR_PIN_REQUIRED;
-    }
-    else
-    {
-        if (ctap_is_pin_set() || (GA.pinAuthPresent))
+    if (GA.pinAuthPresent)
    {
        ret = verify_pin_auth(GA.pinAuth, GA.clientDataHash);
        check_retr(ret);
        getAssertionState.user_verified = 1;
    }
+    else
+    {
+        getAssertionState.user_verified = 0;
    }

    if (!GA.rp.size || !GA.clientDataHashPresent)
@ -1015,47 +1138,15 @@ uint8_t ctap_get_assertion(CborEncoder * encoder, uint8_t * request, int length)
        map_size += 1;
    }

+    if (GA.extensions.hmac_secret_present == EXT_HMAC_SECRET_PARSED)
+    {
+        printf1(TAG_GA, "hmac-secret is present\r\n");
+    }
+
    ret = cbor_encoder_create_map(encoder, &map, map_size);
    check_ret(ret);

-#ifdef ENABLE_U2F_EXTENSIONS
-    if ( is_extension_request((uint8_t*)&GA.creds[validCredCount - 1].credential.id, sizeof(CredentialId)) )
-    {
-        ret = cbor_encode_int(&map,RESP_authData);
-        check_ret(ret);
-        memset(auth_data_buf,0,sizeof(auth_data_buf));
-        ret = cbor_encode_byte_string(&map, auth_data_buf, sizeof(auth_data_buf));
-        check_ret(ret);
-    }
-    else
-#endif
-    {
-        ret = ctap_make_auth_data(&GA.rp, &map, auth_data_buf, sizeof(auth_data_buf), NULL, 0,0,NULL, 0);
-        check_retr(ret);
-    }
-
-    /*for (int j = 0; j < GA.credLen; j++)*/
-    /*{*/
-        /*printf1(TAG_GA,"CRED ID (# %d): ", GA.creds[j].credential.enc.count);*/
-        /*dump_hex1(TAG_GA, (uint8_t*)&GA.creds[j].credential, sizeof(struct Credential));*/
-        /*if (ctap_authenticate_credential(&GA.rp, &GA.creds[j]))   // warning encryption will break this*/
-        /*{*/
-            /*printf1(TAG_GA,"  Authenticated.\n");*/
-        /*}*/
-        /*else*/
-        /*{*/
-            /*printf1(TAG_GA,"  NOT authentic.\n");*/
-        /*}*/
-    /*}*/
-
-    // Decrypt here
-
-    //
-    if (validCredCount > 0)
-    {
-        save_credential_list((CTAP_authDataHeader*)auth_data_buf, GA.clientDataHash, GA.creds, validCredCount-1);   // skip last one
-    }
-    else
+    if (validCredCount == 0)
    {
        printf2(TAG_ERR,"Error, no authentic credential\n");
        return CTAP2_ERR_NO_CREDENTIALS;
@ -1085,6 +1176,50 @@ uint8_t ctap_get_assertion(CborEncoder * encoder, uint8_t * request, int length)

    CTAP_credentialDescriptor * cred = &GA.creds[validCredCount - 1];

+    GA.extensions.hmac_secret.credential = &cred->credential;
+
+#ifdef ENABLE_U2F_EXTENSIONS
+    if ( is_extension_request((uint8_t*)&GA.creds[validCredCount - 1].credential.id, sizeof(CredentialId)) )
+    {
+        ret = cbor_encode_int(&map,RESP_authData);
+        check_ret(ret);
+        memset(auth_data_buf,0,sizeof(CTAP_authDataHeader));
+        ret = cbor_encode_byte_string(&map, auth_data_buf, sizeof(CTAP_authDataHeader));
+        check_ret(ret);
+    }
+    else
+#endif
+    {
+        uint32_t len = sizeof(auth_data_buf);
+        ret = ctap_make_auth_data(&GA.rp, &map, auth_data_buf, &len, NULL);
+        check_retr(ret);
+
+        ((CTAP_authData *)auth_data_buf)->head.flags &= ~(1 << 2);
+        ((CTAP_authData *)auth_data_buf)->head.flags |= (getAssertionState.user_verified << 2);
+        
+        {
+            unsigned int ext_encoder_buf_size = sizeof(auth_data_buf) - len;
+            uint8_t * ext_encoder_buf = auth_data_buf + len;
+
+            ret = ctap_make_extensions(&GA.extensions, ext_encoder_buf, &ext_encoder_buf_size);
+            check_retr(ret);
+            if (ext_encoder_buf_size)
+            {
+                ((CTAP_authData *)auth_data_buf)->head.flags |= (1 << 7);
+                len += ext_encoder_buf_size;
+            }
+        }
+
+        {
+            ret = cbor_encode_int(&map,RESP_authData);
+            check_ret(ret);
+            ret = cbor_encode_byte_string(&map, auth_data_buf, len);
+            check_ret(ret);
+        }
+    }
+
+    save_credential_list((CTAP_authDataHeader*)auth_data_buf, GA.clientDataHash, GA.creds, validCredCount-1);   // skip last one
+
    ret = ctap_end_get_assertion(&map, cred, auth_data_buf, GA.clientDataHash, add_user_info);
    check_retr(ret);

@ -1406,7 +1541,6 @@ uint8_t ctap_request(uint8_t * pkt_raw, int length, CTAP_RESPONSE * resp)
    pkt_raw++;
    length--;

-
    uint8_t * buf = resp->data;

    cbor_encoder_init(&encoder, buf, resp->data_size, 0);
--- a/fido2/ctap.h
+++ b/fido2/ctap.h
@ -54,6 +54,13 @@
 #define CP_getKeyAgreement        0x07
 #define CP_getRetries             0x08

+#define EXT_HMAC_SECRET_COSE_KEY    0x01
+#define EXT_HMAC_SECRET_SALT_ENC    0x02
+#define EXT_HMAC_SECRET_SALT_AUTH   0x03
+
+#define EXT_HMAC_SECRET_REQUESTED   0x01
+#define EXT_HMAC_SECRET_PARSED      0x02
+
 #define RESP_versions               0x1
 #define RESP_extensions             0x2
 #define RESP_aaguid                 0x3
@ -142,9 +149,13 @@ struct Credential {
    CredentialId id;
    CTAP_userEntity user;
 };
-
 typedef struct Credential CTAP_residentKey;

+typedef struct
+{
+    uint8_t type;
+    struct Credential credential;
+} CTAP_credentialDescriptor;

 typedef struct
 {
@ -181,34 +192,62 @@ struct rpId
    uint8_t name[RP_NAME_LIMIT];
 };

+typedef struct
+{
+    struct{
+        uint8_t x[32];
+        uint8_t y[32];
+    } pubkey;
+
+    int kty;
+    int crv;
+} COSE_key;
+
+typedef struct
+{
+    uint8_t saltLen;
+    uint8_t saltEnc[64];
+    uint8_t saltAuth[32];
+    COSE_key keyAgreement;
+    struct Credential * credential;
+} CTAP_hmac_secret;
+
+typedef struct
+{
+    uint8_t hmac_secret_present;
+    CTAP_hmac_secret hmac_secret;
+} CTAP_extensions;
+
+typedef struct
+{
+    CTAP_userEntity user;
+    uint8_t publicKeyCredentialType;
+    int32_t COSEAlgorithmIdentifier;
+    uint8_t rk;
+} CTAP_credInfo;
+
 typedef struct
 {
    uint32_t paramsParsed;
    uint8_t clientDataHash[CLIENT_DATA_HASH_SIZE];
    struct rpId rp;
-    CTAP_userEntity user;

-    uint8_t publicKeyCredentialType;
-    int32_t COSEAlgorithmIdentifier;
+    CTAP_credInfo credInfo;

    CborValue excludeList;
    size_t excludeListSize;

-    uint8_t rk;
    uint8_t uv;
    uint8_t up;

    uint8_t pinAuth[16];
    uint8_t pinAuthPresent;
    int pinProtocol;
+    CTAP_extensions extensions;

 } CTAP_makeCredential;

-typedef struct
-{
-    uint8_t type;
-    struct Credential credential;
-} CTAP_credentialDescriptor;
+

 typedef struct
 {
@ -230,22 +269,16 @@ typedef struct

    CTAP_credentialDescriptor creds[ALLOW_LIST_MAX_SIZE];
    uint8_t allowListPresent;
+
+    CTAP_extensions extensions;
+
 } CTAP_getAssertion;

 typedef struct
 {
    int pinProtocol;
    int subCommand;
-    struct
-    {
-        struct{
-            uint8_t x[32];
-            uint8_t y[32];
-        } pubkey;
-
-        int kty;
-        int crv;
-    } keyAgreement;
+    COSE_key keyAgreement;
    uint8_t keyAgreementPresent;
    uint8_t pinAuth[16];
    uint8_t pinAuthPresent;
--- a/fido2/ctap_parse.c
+++ b/fido2/ctap_parse.c
@ -128,14 +128,14 @@ uint8_t parse_user(CTAP_makeCredential * MC, CborValue * val)
            }

            sz = USER_ID_MAX_SIZE;
-            ret = cbor_value_copy_byte_string(&map, MC->user.id, &sz, NULL);
+            ret = cbor_value_copy_byte_string(&map, MC->credInfo.user.id, &sz, NULL);
            if (ret == CborErrorOutOfMemory)
            {
                printf2(TAG_ERR,"Error, USER_ID is too large\n");
                return CTAP2_ERR_LIMIT_EXCEEDED;
            }
-            MC->user.id_size = sz;
-            printf1(TAG_GREEN,"parsed id_size: %d\r\n", MC->user.id_size);
+            MC->credInfo.user.id_size = sz;
+            printf1(TAG_GREEN,"parsed id_size: %d\r\n", MC->credInfo.user.id_size);
            check_ret(ret);
        }
        else if (strcmp((const char *)key, "name") == 0)
@ -146,12 +146,12 @@ uint8_t parse_user(CTAP_makeCredential * MC, CborValue * val)
                return CTAP2_ERR_INVALID_CBOR_TYPE;
            }
            sz = USER_NAME_LIMIT;
-            ret = cbor_value_copy_text_string(&map, (char *)MC->user.name, &sz, NULL);
+            ret = cbor_value_copy_text_string(&map, (char *)MC->credInfo.user.name, &sz, NULL);
            if (ret != CborErrorOutOfMemory)
            {   // Just truncate the name it's okay
                check_ret(ret);
            }
-            MC->user.name[USER_NAME_LIMIT - 1] = 0;
+            MC->credInfo.user.name[USER_NAME_LIMIT - 1] = 0;
        }
        else if (strcmp((const char *)key, "displayName") == 0)
        {
@ -161,12 +161,12 @@ uint8_t parse_user(CTAP_makeCredential * MC, CborValue * val)
                return CTAP2_ERR_INVALID_CBOR_TYPE;
            }
            sz = DISPLAY_NAME_LIMIT;
-            ret = cbor_value_copy_text_string(&map, (char *)MC->user.displayName, &sz, NULL);
+            ret = cbor_value_copy_text_string(&map, (char *)MC->credInfo.user.displayName, &sz, NULL);
            if (ret != CborErrorOutOfMemory)
            {   // Just truncate the name it's okay
                check_ret(ret);
            }
-            MC->user.displayName[DISPLAY_NAME_LIMIT - 1] = 0;
+            MC->credInfo.user.displayName[DISPLAY_NAME_LIMIT - 1] = 0;
        }
        else if (strcmp((const char *)key, "icon") == 0)
        {
@ -176,12 +176,12 @@ uint8_t parse_user(CTAP_makeCredential * MC, CborValue * val)
                return CTAP2_ERR_INVALID_CBOR_TYPE;
            }
            sz = ICON_LIMIT;
-            ret = cbor_value_copy_text_string(&map, (char *)MC->user.icon, &sz, NULL);
+            ret = cbor_value_copy_text_string(&map, (char *)MC->credInfo.user.icon, &sz, NULL);
            if (ret != CborErrorOutOfMemory)
            {   // Just truncate the name it's okay
                check_ret(ret);
            }
-            MC->user.icon[ICON_LIMIT - 1] = 0;
+            MC->credInfo.user.icon[ICON_LIMIT - 1] = 0;

        }
        else
@ -305,8 +305,8 @@ uint8_t parse_pub_key_cred_params(CTAP_makeCredential * MC, CborValue * val)
        {
            if (pub_key_cred_param_supported(cred_type, alg_type) == CREDENTIAL_IS_SUPPORTED)
            {
-                MC->publicKeyCredentialType = cred_type;
-                MC->COSEAlgorithmIdentifier = alg_type;
+                MC->credInfo.publicKeyCredentialType = cred_type;
+                MC->credInfo.COSEAlgorithmIdentifier = alg_type;
                MC->paramsParsed |= PARAM_pubKeyCredParams;
                return 0;
            }
@ -556,6 +556,154 @@ uint8_t parse_options(CborValue * val, uint8_t * rk, uint8_t * uv, uint8_t * up)
    return 0;
 }

+uint8_t ctap_parse_hmac_secret(CborValue * val, CTAP_hmac_secret * hs)
+{
+    size_t map_length;
+    size_t salt_len;
+    uint8_t parsed_count = 0;
+    int key;
+    int ret;
+    unsigned int i;
+    CborValue map;
+
+    if (cbor_value_get_type(val) != CborMapType)
+    {
+        printf2(TAG_ERR,"error, wrong type\n");
+        return CTAP2_ERR_INVALID_CBOR_TYPE;
+    }
+
+    ret = cbor_value_enter_container(val,&map);
+    check_ret(ret);
+
+    ret = cbor_value_get_map_length(val, &map_length);
+    check_ret(ret);
+
+    for (i = 0; i < map_length; i++)
+    {
+        if (cbor_value_get_type(&map) != CborIntegerType)
+        {
+            printf2(TAG_ERR,"Error, expecting CborIntegerTypefor hmac-secret map key, got %s\n", cbor_value_get_type_string(&map));
+            return CTAP2_ERR_INVALID_CBOR_TYPE;
+        }
+        ret = cbor_value_get_int(&map, &key);
+        check_ret(ret);
+
+        ret = cbor_value_advance(&map);
+        check_ret(ret);
+
+        switch(key)
+        {
+            case EXT_HMAC_SECRET_COSE_KEY:
+                ret = parse_cose_key(&map, &hs->keyAgreement);
+                check_retr(ret);
+                parsed_count++;
+            break;
+            case EXT_HMAC_SECRET_SALT_ENC:
+                salt_len = 64;
+                ret = cbor_value_copy_byte_string(&map, hs->saltEnc, &salt_len, NULL);
+                if ((salt_len != 32 && salt_len != 64) || ret == CborErrorOutOfMemory)
+                {
+                    return CTAP1_ERR_INVALID_LENGTH;
+                }
+                check_ret(ret);
+                hs->saltLen = salt_len;
+                parsed_count++;
+            break;
+            case EXT_HMAC_SECRET_SALT_AUTH:
+                salt_len = 32;
+                ret = cbor_value_copy_byte_string(&map, hs->saltAuth, &salt_len, NULL);
+                check_ret(ret);
+                parsed_count++;
+            break;
+        }
+
+        ret = cbor_value_advance(&map);
+        check_ret(ret);
+    }
+
+    if (parsed_count != 3)
+    {
+        printf2(TAG_ERR, "ctap_parse_hmac_secret missing parameter.  Got %d.\r\n", parsed_count);
+        return CTAP2_ERR_MISSING_PARAMETER;
+    }
+
+    return 0;
+}
+
+
+uint8_t ctap_parse_extensions(CborValue * val, CTAP_extensions * ext)
+{
+    CborValue map;
+    size_t sz, map_length;
+    char key[16];
+    int ret;
+    unsigned int i;
+    bool b;
+
+    if (cbor_value_get_type(val) != CborMapType)
+    {
+        printf2(TAG_ERR,"error, wrong type\n");
+        return CTAP2_ERR_INVALID_CBOR_TYPE;
+    }
+
+    ret = cbor_value_enter_container(val, &map);
+    check_ret(ret);
+
+    ret = cbor_value_get_map_length(val, &map_length);
+    check_ret(ret);
+
+    for (i = 0; i < map_length; i++)
+    {
+        if (cbor_value_get_type(&map) != CborTextStringType)
+        {
+            printf2(TAG_ERR,"Error, expecting text string type for options map key, got %s\n", cbor_value_get_type_string(&map));
+            return CTAP2_ERR_INVALID_CBOR_TYPE;
+        }
+        sz = sizeof(key);
+        ret = cbor_value_copy_text_string(&map, key, &sz, NULL);
+
+        if (ret == CborErrorOutOfMemory)
+        {
+            printf2(TAG_ERR,"Error, rp map key is too large. Ignoring.\n");
+            cbor_value_advance(&map);
+            cbor_value_advance(&map);
+            continue;
+        }
+        check_ret(ret);
+        key[sizeof(key) - 1] = 0;
+
+        ret = cbor_value_advance(&map);
+        check_ret(ret);
+
+
+        if (strncmp(key, "hmac-secret",11) == 0)
+        {
+            if (cbor_value_get_type(&map) == CborBooleanType)
+            {
+                ret = cbor_value_get_boolean(&map, &b);
+                check_ret(ret);
+                if (b) ext->hmac_secret_present = EXT_HMAC_SECRET_REQUESTED;
+                printf1(TAG_CTAP, "set hmac_secret_present to %d\r\n", b);
+            }
+            else if (cbor_value_get_type(&map) == CborMapType)
+            {
+                ret = ctap_parse_hmac_secret(&map, &ext->hmac_secret);
+                check_retr(ret);
+                ext->hmac_secret_present = EXT_HMAC_SECRET_PARSED;
+                printf1(TAG_CTAP, "parsed hmac_secret request\r\n");
+            }
+            else
+            {
+                printf1(TAG_RED, "warning: hmac_secret request ignored for being wrong type\r\n");
+            }
+        }
+
+        ret = cbor_value_advance(&map);
+        check_ret(ret);
+    }
+    return 0;
+}
+
 uint8_t ctap_parse_make_credential(CTAP_makeCredential * MC, CborEncoder * encoder, uint8_t * request, int length)
 {
    int ret;
@ -631,8 +779,8 @@ uint8_t ctap_parse_make_credential(CTAP_makeCredential * MC, CborEncoder * encod

                ret = parse_user(MC, &map);

-                printf1(TAG_MC,"  ID: "); dump_hex1(TAG_MC, MC->user.id, MC->user.id_size);
-                printf1(TAG_MC,"  name: %s\n", MC->user.name);
+                printf1(TAG_MC,"  ID: "); dump_hex1(TAG_MC, MC->credInfo.user.id, MC->credInfo.user.id_size);
+                printf1(TAG_MC,"  name: %s\n", MC->credInfo.user.name);

                break;
            case MC_pubKeyCredParams:
@ -640,8 +788,8 @@ uint8_t ctap_parse_make_credential(CTAP_makeCredential * MC, CborEncoder * encod

                ret = parse_pub_key_cred_params(MC, &map);

-                printf1(TAG_MC,"  cred_type: 0x%02x\n", MC->publicKeyCredentialType);
-                printf1(TAG_MC,"  alg_type: %d\n", MC->COSEAlgorithmIdentifier);
+                printf1(TAG_MC,"  cred_type: 0x%02x\n", MC->credInfo.publicKeyCredentialType);
+                printf1(TAG_MC,"  alg_type: %d\n", MC->credInfo.COSEAlgorithmIdentifier);

                break;
            case MC_excludeList:
@ -665,11 +813,13 @@ uint8_t ctap_parse_make_credential(CTAP_makeCredential * MC, CborEncoder * encod
                {
                    return CTAP2_ERR_INVALID_CBOR_TYPE;
                }
+                ret = ctap_parse_extensions(&map, &MC->extensions);
+                check_retr(ret);
                break;

            case MC_options:
                printf1(TAG_MC,"CTAP_options\n");
-                ret = parse_options(&map, &MC->rk, &MC->uv, &MC->up);
+                ret = parse_options(&map, &MC->credInfo.rk, &MC->uv, &MC->up);
                check_retr(ret);
                break;
            case MC_pinAuth:
@ -886,6 +1036,8 @@ uint8_t ctap_parse_get_assertion(CTAP_getAssertion * GA, uint8_t * request, int
                break;
            case GA_extensions:
                printf1(TAG_GA,"GA_extensions\n");
+                ret = ctap_parse_extensions(&map, &GA->extensions);
+                check_retr(ret);
                break;

            case GA_options:
@ -940,15 +1092,15 @@ uint8_t ctap_parse_get_assertion(CTAP_getAssertion * GA, uint8_t * request, int
    return 0;
 }

-uint8_t parse_cose_key(CborValue * it, uint8_t * x, uint8_t * y, int * kty, int * crv)
+uint8_t parse_cose_key(CborValue * it, COSE_key * cose)
 {
    CborValue map;
    size_t map_length;
    int ret,key;
    unsigned int i;
    int xkey = 0,ykey = 0;
-    *kty = 0;
-    *crv = 0;
+    cose->kty = 0;
+    cose->crv = 0;


    CborType type = cbor_value_get_type(it);
@ -986,7 +1138,7 @@ uint8_t parse_cose_key(CborValue * it, uint8_t * x, uint8_t * y, int * kty, int
                printf1(TAG_PARSE,"COSE_KEY_LABEL_KTY\n");
                if (cbor_value_get_type(&map) == CborIntegerType)
                {
-                    ret = cbor_value_get_int_checked(&map, kty);
+                    ret = cbor_value_get_int_checked(&map, &cose->kty);
                    check_ret(ret);
                }
                else
@ -1001,7 +1153,7 @@ uint8_t parse_cose_key(CborValue * it, uint8_t * x, uint8_t * y, int * kty, int
                printf1(TAG_PARSE,"COSE_KEY_LABEL_CRV\n");
                if (cbor_value_get_type(&map) == CborIntegerType)
                {
-                    ret = cbor_value_get_int_checked(&map, crv);
+                    ret = cbor_value_get_int_checked(&map, &cose->crv);
                    check_ret(ret);
                }
                else
@ -1011,14 +1163,14 @@ uint8_t parse_cose_key(CborValue * it, uint8_t * x, uint8_t * y, int * kty, int
                break;
            case COSE_KEY_LABEL_X:
                printf1(TAG_PARSE,"COSE_KEY_LABEL_X\n");
-                ret = parse_fixed_byte_string(&map, x, 32);
+                ret = parse_fixed_byte_string(&map, cose->pubkey.x, 32);
                check_retr(ret);
                xkey = 1;

                break;
            case COSE_KEY_LABEL_Y:
                printf1(TAG_PARSE,"COSE_KEY_LABEL_Y\n");
-                ret = parse_fixed_byte_string(&map, y, 32);
+                ret = parse_fixed_byte_string(&map, cose->pubkey.y, 32);
                check_retr(ret);
                ykey = 1;

@ -1030,7 +1182,7 @@ uint8_t parse_cose_key(CborValue * it, uint8_t * x, uint8_t * y, int * kty, int
        ret = cbor_value_advance(&map);
        check_ret(ret);
    }
-    if (xkey == 0 || ykey == 0 || *kty == 0 || *crv == 0)
+    if (xkey == 0 || ykey == 0 || cose->kty == 0 || cose->crv == 0)
    {
        return CTAP2_ERR_MISSING_PARAMETER;
    }
@ -1110,7 +1262,7 @@ uint8_t ctap_parse_client_pin(CTAP_clientPin * CP, uint8_t * request, int length
                break;
            case CP_keyAgreement:
                printf1(TAG_CP,"CP_keyAgreement\n");
-                ret = parse_cose_key(&map, CP->keyAgreement.pubkey.x, CP->keyAgreement.pubkey.y, &CP->keyAgreement.kty, &CP->keyAgreement.crv);
+                ret = parse_cose_key(&map, &CP->keyAgreement);
                check_retr(ret);
                CP->keyAgreementPresent = 1;
                break;
--- a/fido2/ctap_parse.h
+++ b/fido2/ctap_parse.h
@ -30,7 +30,7 @@ uint8_t parse_rp(struct rpId * rp, CborValue * val);
 uint8_t parse_options(CborValue * val, uint8_t * rk, uint8_t * uv, uint8_t * up);

 uint8_t parse_allow_list(CTAP_getAssertion * GA, CborValue * it);
-uint8_t parse_cose_key(CborValue * it, uint8_t * x, uint8_t * y, int * kty, int * crv);
+uint8_t parse_cose_key(CborValue * it, COSE_key * cose);


 uint8_t ctap_parse_make_credential(CTAP_makeCredential * MC, CborEncoder * encoder, uint8_t * request, int length);
--- a/fido2/u2f.c
+++ b/fido2/u2f.c
@ -247,7 +247,7 @@ static int16_t u2f_authenticate(struct u2f_authenticate_request * req, uint8_t c
 	}

    count = ctap_atomic_count(0);
-    hash[0] = 0x7f;
+    hash[0] = (count >> 24) & 0xff;
    hash[1] = (count >> 16) & 0xff;
    hash[2] = (count >> 8) & 0xff;
    hash[3] = (count >> 0) & 0xff;
@ -264,7 +264,7 @@ static int16_t u2f_authenticate(struct u2f_authenticate_request * req, uint8_t c
    crypto_ecc256_sign(hash, 32, sig);

    u2f_response_writeback(&up,1);
-    hash[0] = 0x7f;
+    hash[0] = (count >> 24) & 0xff;
    hash[1] = (count >> 16) & 0xff;
    hash[2] = (count >> 8) & 0xff;
    hash[3] = (count >> 0) & 0xff;
--- a/targets/stm32l432/src/version.h
+++ b/targets/stm32l432/src/version.h
--- a/in-docker-build.sh
+++ b/in-docker-build.sh
@ -7,6 +7,7 @@ export PREFIX=/opt/gcc-arm-none-eabi-8-2018-q4-major/bin/
 cd /solo/targets/stm32l432
 git fetch --tags
 git checkout ${version}
+git submodule update --init --recursive
 version=$(git describe)

 make cbor
@ -34,6 +35,8 @@ function build() {
 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

 pip install -U pip
@ -42,3 +45,7 @@ cd ${out_dir}
 bundle="bundle-hacker-${version}"
 /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-hacker-debug-1-${version}.hex ${bundle}.hex
+bundle="bundle-hacker-debug-2-${version}"
+/opt/conda/bin/solo mergehex bootloader-nonverifying-${version}.hex firmware-hacker-debug-2-${version}.hex ${bundle}.hex
--- a/pc/app.h
+++ b/pc/app.h
@ -15,7 +15,7 @@
 #define DEBUG_LEVEL 1

 #define ENABLE_U2F
-
+#define ENABLE_U2F_EXTENSIONS
 //#define BRIDGE_TO_WALLET

 void printing_init();
--- a/targets/stm32l432/Makefile
+++ b/targets/stm32l432/Makefile
@ -93,6 +93,11 @@ flashboot: solo.hex bootloader.hex
 	STM32_Programmer_CLI -c port=SWD -halt -e all --readunprotect
 	STM32_Programmer_CLI -c port=SWD -halt  -d bootloader.hex -rst

+flash-firmware:
+	arm-none-eabi-size -A solo.elf
+	solo program aux enter-bootloader
+	solo program bootloader solo.hex
+
 # tell ST DFU to enter application
 detach:
 	STM32_Programmer_CLI -c port=usb1 -ob nBOOT0=1
--- a/targets/stm32l432/Makefile.test.mk
+++ b/targets/stm32l432/Makefile.test.mk
@ -1,73 +0,0 @@
-CC=arm-none-eabi-gcc
-CP=arm-none-eabi-objcopy
-SZ=arm-none-eabi-size
-AR=arm-none-eabi-ar
-
-# ST related
-SRC = src/main.c src/init.c src/flash.c src/led.c
-SRC += src/startup_stm32l432xx.s src/system_stm32l4xx.c
-SRC += lib/stm32l4xx_ll_gpio.c lib/stm32l4xx_ll_pwr.c lib/stm32l4xx_ll_rcc.c lib/stm32l4xx_ll_tim.c lib/stm32l4xx_ll_utils.c
-
-OBJ1=$(SRC:.c=.o)
-OBJ=$(OBJ1:.s=.o)
-
-INC = -Isrc/ -Isrc/cmsis/ -Ilib/ -Ilib/usbd/ -I../../fido2/ -I../../fido2/extensions
-INC += -I../../tinycbor/src -I../../crypto/sha256 -I../../crypto/micro-ecc
-INC += -I../../crypto/tiny-AES-c
-
-SEARCH=-L../../tinycbor/lib
-
-LDSCRIPT=stm32l432xx.ld
-
-CFLAGS= $(INC)
-
-TARGET=solo
-HW=-mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb
-
-# Solo or Nucleo board
-CHIP=STM32L432xx
-
-DEFINES = -D$(CHIP) -DAES256=1  -DUSE_FULL_LL_DRIVER
-DEFINES += -DTEST_SOLO_STM32 -DTEST
-
-CFLAGS=$(INC) -c $(DEFINES)   -Wall -fdata-sections -ffunction-sections $(HW)
-LDFLAGS_LIB=$(HW) $(SEARCH) -specs=nano.specs  -specs=nosys.specs  -Wl,--gc-sections  -lnosys
-LDFLAGS=$(HW) $(LDFLAGS_LIB) -T$(LDSCRIPT) -Wl,-Map=$(TARGET).map,--cref
-
-
-.PRECIOUS: %.o
-
-all: $(TARGET).elf
-	$(SZ) $^
-
-%.o: %.c
-	$(CC) $^ $(HW)  -Os $(CFLAGS) -o $@
-
-../../crypto/micro-ecc/uECC.o: ../../crypto/micro-ecc/uECC.c
-	$(CC) $^ $(HW)  -O3 $(CFLAGS) -o $@
-
-%.o: %.s
-	$(CC) $^ $(HW)  -Os $(CFLAGS) -o $@
-
-%.elf: $(OBJ)
-	$(CC) $^ $(HW) $(LDFLAGS) -o $@
-
-%.hex: %.elf
-	$(CP) -O ihex $^ $(TARGET).hex
-	$(CP) -O binary $^ $(TARGET).bin
-
-clean:
-	rm -f *.o src/*.o src/*.elf *.elf *.hex $(OBJ)
-
-flash: $(TARGET).hex
-	STM32_Programmer_CLI -c port=SWD -halt -e all --readunprotect
-	STM32_Programmer_CLI -c port=SWD -halt  -d $(TARGET).hex -rst
-
-detach:
-	STM32_Programmer_CLI -c port=usb1 -ob nBOOT0=1
-
-cbor:
-	cd ../../tinycbor/ && make clean
-	cd ../../tinycbor/ && make CC="$(CC)" AR=$(AR) \
-LDFLAGS="$(LDFLAGS_LIB)" \
-CFLAGS="$(CFLAGS)"
--- a/targets/stm32l432/bootloader/main.c
+++ b/targets/stm32l432/bootloader/main.c
@ -26,6 +26,7 @@

 uint8_t REBOOT_FLAG = 0;

+void SystemClock_Config(void);

 void BOOT_boot(void)
 {
--- a/targets/stm32l432/build/application.mk
+++ b/targets/stm32l432/build/application.mk
@ -46,7 +46,7 @@ DEFINES = -DDEBUG_LEVEL=$(DEBUG) -D$(CHIP) -DAES256=1  -DUSE_FULL_LL_DRIVER -DAP

 CFLAGS=$(INC) -c $(DEFINES)   -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -fdata-sections -ffunction-sections \
 	-fomit-frame-pointer $(HW) -g $(VERSION_FLAGS)
-LDFLAGS_LIB=$(HW) $(SEARCH) -specs=nano.specs  -specs=nosys.specs  -Wl,--gc-sections -u _printf_float -lnosys
+LDFLAGS_LIB=$(HW) $(SEARCH) -specs=nano.specs  -specs=nosys.specs  -Wl,--gc-sections -lnosys
 LDFLAGS=$(HW) $(LDFLAGS_LIB) -T$(LDSCRIPT) -Wl,-Map=$(TARGET).map,--cref -Wl,-Bstatic -ltinycbor

 ECC_CFLAGS = $(CFLAGS) -DuECC_PLATFORM=5 -DuECC_OPTIMIZATION_LEVEL=4 -DuECC_SQUARE_FUNC=1 -DuECC_SUPPORT_COMPRESSED_POINT=0
--- a/targets/stm32l432/lib/usbd/usbd_composite.c
+++ b/targets/stm32l432/lib/usbd/usbd_composite.c
@ -110,7 +110,7 @@ __ALIGN_BEGIN uint8_t COMPOSITE_CDC_HID_DESCRIPTOR[COMPOSITE_CDC_HID_DESCRIPTOR_
  0x03,   /* bNumEndpoints: 3 endpoints used */
  0x02,   /* bInterfaceClass: Communication Interface Class */
  0x02,   /* bInterfaceSubClass: Abstract Control Model */
-  0x01,   /* bInterfaceProtocol: Common AT commands */
+  0x00,   /* bInterfaceProtocol: Common AT commands */
  0x00,   /* iInterface: */

  /*Header Functional Descriptor*/
--- a/targets/stm32l432/linker/bootloader_stm32l4xx.ld
+++ b/targets/stm32l432/linker/bootloader_stm32l4xx.ld
@ -1,201 +1,74 @@
-/*
-*****************************************************************************
-**
+/* Copyright 2019 SoloKeys Developers */
+/* */
+/* Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or */
+/* http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or */
+/* http://opensource.org/licenses/MIT>, at your option. This file may not be */
+/* copied, modified, or distributed except according to those terms. */

-**  File        : LinkerScript.ld
-**
-**  Abstract    : Linker script for STM32L432KCUx Device with
-**                256KByte FLASH, 64KByte RAM
-**
-**                Set heap size, stack size and stack location according
-**                to application requirements.
-**
-**                Set memory bank area and size if external memory is used.
-**
-**  Target      : STMicroelectronics STM32
-**
-**
-**  Distribution: The file is distributed as is, without any warranty
-**                of any kind.
-**
-**  (c)Copyright Ac6.
-**  You may use this file as-is or modify it according to the needs of your
-**  project. Distribution of this file (unmodified or modified) is not
-**  permitted. Ac6 permit registered System Workbench for MCU users the
-**  rights to distribute the assembled, compiled & linked contents of this
-**  file as part of an application binary file, provided that it is built
-**  using the System Workbench for MCU toolchain.
-**
-*****************************************************************************
-*/
-
-/* Entry Point */
 ENTRY(Reset_Handler)

-/* Highest address of the user mode stack */
-_estack = 0x2000c000;    /* end of RAM */
-/* Generate a link error if heap and stack don't fit into RAM */
-_Min_Heap_Size = 0x200;      /* required amount of heap  */
-_Min_Stack_Size = 0x400; /* required amount of stack */
+/* End of RAM */
+_estack = 0x2000c000;
+
+_MIN_STACK_SIZE = 0x400;

-/* Specify the memory areas */
 MEMORY
 {
-FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 20K
-RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 48K
-SRAM2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
+    flash (rx)      : ORIGIN = 0x08000000, LENGTH = 20K
+    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
+    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }

-/* Define output sections */
 SECTIONS
 {
-  /* The startup code goes first into FLASH */
    .isr_vector :
    {
        . = ALIGN(8);
-    KEEP(*(.isr_vector)) /* Startup code */
+        KEEP(*(.isr_vector))
        . = ALIGN(8);
-  } >FLASH
+    } >flash

-  /* The program code and other data goes into FLASH */
    .text :
    {
        . = ALIGN(8);
-    *(.text)           /* .text sections (code) */
-    *(.text*)          /* .text* sections (code) */
-    *(.glue_7)         /* glue arm to thumb code */
-    *(.glue_7t)        /* glue thumb to arm code */
-    *(.eh_frame)
-
+        *(.text*)
+        *(.rodata*)
        KEEP(*(.init))
-    KEEP (*(.fini))
+        KEEP(*(.finit))
+        . = ALIGN(8);
+        _etext = .;
+    } >flash

-    . = ALIGN(8);
-    _etext = .;        /* define a global symbols at end of code */
-  } >FLASH
-
-  /* Constant data goes into FLASH */
-  .rodata :
-  {
-    . = ALIGN(8);
-    *(.rodata)         /* .rodata sections (constants, strings, etc.) */
-    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
-    . = ALIGN(8);
-  } >FLASH
-
-  .ARM.extab   :
-  {
-  . = ALIGN(8);
-  *(.ARM.extab* .gnu.linkonce.armextab.*)
-  . = ALIGN(8);
-  } >FLASH
-  .ARM : {
-	. = ALIGN(8);
-    __exidx_start = .;
-    *(.ARM.exidx*)
-    __exidx_end = .;
-	. = ALIGN(8);
-  } >FLASH
-
-  .preinit_array     :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__preinit_array_start = .);
-    KEEP (*(.preinit_array*))
-    PROVIDE_HIDDEN (__preinit_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  .init_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__init_array_start = .);
-    KEEP (*(SORT(.init_array.*)))
-    KEEP (*(.init_array*))
-    PROVIDE_HIDDEN (__init_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-  .fini_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__fini_array_start = .);
-    KEEP (*(SORT(.fini_array.*)))
-    KEEP (*(.fini_array*))
-    PROVIDE_HIDDEN (__fini_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  /* used by the startup to initialize data */
    _sidata = LOADADDR(.data);

-  /* Initialized data sections goes into RAM, load LMA copy after code */
    .data :
    {
        . = ALIGN(8);
-    _sdata = .;        /* create a global symbol at data start */
-    *(.data)           /* .data sections */
-    *(.data*)          /* .data* sections */
-
+        _sdata = .;
+        *(.data*)
        . = ALIGN(8);
-    _edata = .;        /* define a global symbol at data end */
-  } >RAM AT> FLASH
+        _edata = .;
+    } >ram AT> flash

-  _sisram2 = LOADADDR(.sram2);
-
-  /* CCM-RAM section
-  *
-  * IMPORTANT NOTE!
-  * If initialized variables will be placed in this section,
-  * the startup code needs to be modified to copy the init-values.
-  */
-  .sram2 :
-  {
-    . = ALIGN(8);
-    _ssram2 = .;       /* create a global symbol at sram2 start */
-    *(.sram2)
-    *(.sram2*)
-
-    . = ALIGN(8);
-    _esram2 = .;       /* create a global symbol at sram2 end */
-  } >SRAM2 AT> FLASH
-
-
-  /* Uninitialized data section */
-  . = ALIGN(4);
    .bss :
    {
-    /* This is used by the startup in order to initialize the .bss secion */
-    _sbss = .;         /* define a global symbol at bss start */
+        . = ALIGN(4);
+        _sbss = .;
        __bss_start__ = _sbss;
-    *(.bss)
        *(.bss*)
        *(COMMON)
-
        . = ALIGN(4);
-    _ebss = .;         /* define a global symbol at bss end */
+        _ebss = .;
        __bss_end__ = _ebss;
-  } >RAM
+    } > ram

-  /* User_heap_stack section, used to check that there is enough RAM left */
-  ._user_heap_stack :
+    ._stack :
    {
        . = ALIGN(8);
-    PROVIDE ( end = . );
-    PROVIDE ( _end = . );
-    . = . + _Min_Heap_Size;
-    . = . + _Min_Stack_Size;
+        end = .;
+        _end = .;
+        . = . + _MIN_STACK_SIZE;
        . = ALIGN(8);
-  } >RAM
+    } > ram

-
-
-  /* Remove information from the standard libraries */
-  /DISCARD/ :
-  {
-    libc.a ( * )
-    libm.a ( * )
-    libgcc.a ( * )
-  }
-
-  .ARM.attributes 0 : { *(.ARM.attributes) }
 }
--- a/targets/stm32l432/linker/bootloader_stm32l4xx_extra.ld
+++ b/targets/stm32l432/linker/bootloader_stm32l4xx_extra.ld
@ -1,201 +1,74 @@
-/*
-*****************************************************************************
-**
+/* Copyright 2019 SoloKeys Developers */
+/* */
+/* Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or */
+/* http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or */
+/* http://opensource.org/licenses/MIT>, at your option. This file may not be */
+/* copied, modified, or distributed except according to those terms. */

-**  File        : LinkerScript.ld
-**
-**  Abstract    : Linker script for STM32L432KCUx Device with
-**                256KByte FLASH, 64KByte RAM
-**
-**                Set heap size, stack size and stack location according
-**                to application requirements.
-**
-**                Set memory bank area and size if external memory is used.
-**
-**  Target      : STMicroelectronics STM32
-**
-**
-**  Distribution: The file is distributed as is, without any warranty
-**                of any kind.
-**
-**  (c)Copyright Ac6.
-**  You may use this file as-is or modify it according to the needs of your
-**  project. Distribution of this file (unmodified or modified) is not
-**  permitted. Ac6 permit registered System Workbench for MCU users the
-**  rights to distribute the assembled, compiled & linked contents of this
-**  file as part of an application binary file, provided that it is built
-**  using the System Workbench for MCU toolchain.
-**
-*****************************************************************************
-*/
-
-/* Entry Point */
 ENTRY(Reset_Handler)

-/* Highest address of the user mode stack */
-_estack = 0x2000c000;    /* end of RAM */
-/* Generate a link error if heap and stack don't fit into RAM */
-_Min_Heap_Size = 0x200;      /* required amount of heap  */
-_Min_Stack_Size = 0x400; /* required amount of stack */
+/* End of RAM */
+_estack = 0x2000c000;
+
+_MIN_STACK_SIZE = 0x400;

-/* Specify the memory areas */
 MEMORY
 {
-FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 32K
-RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 48K
-SRAM2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
+    flash (rx)      : ORIGIN = 0x08000000, LENGTH = 32K
+    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
+    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }

-/* Define output sections */
 SECTIONS
 {
-  /* The startup code goes first into FLASH */
    .isr_vector :
    {
        . = ALIGN(8);
-    KEEP(*(.isr_vector)) /* Startup code */
+        KEEP(*(.isr_vector))
        . = ALIGN(8);
-  } >FLASH
+    } >flash

-  /* The program code and other data goes into FLASH */
    .text :
    {
        . = ALIGN(8);
-    *(.text)           /* .text sections (code) */
-    *(.text*)          /* .text* sections (code) */
-    *(.glue_7)         /* glue arm to thumb code */
-    *(.glue_7t)        /* glue thumb to arm code */
-    *(.eh_frame)
-
+        *(.text*)
+        *(.rodata*)
        KEEP(*(.init))
-    KEEP (*(.fini))
+        KEEP(*(.finit))
+        . = ALIGN(8);
+        _etext = .;
+    } >flash

-    . = ALIGN(8);
-    _etext = .;        /* define a global symbols at end of code */
-  } >FLASH
-
-  /* Constant data goes into FLASH */
-  .rodata :
-  {
-    . = ALIGN(8);
-    *(.rodata)         /* .rodata sections (constants, strings, etc.) */
-    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
-    . = ALIGN(8);
-  } >FLASH
-
-  .ARM.extab   :
-  {
-  . = ALIGN(8);
-  *(.ARM.extab* .gnu.linkonce.armextab.*)
-  . = ALIGN(8);
-  } >FLASH
-  .ARM : {
-	. = ALIGN(8);
-    __exidx_start = .;
-    *(.ARM.exidx*)
-    __exidx_end = .;
-	. = ALIGN(8);
-  } >FLASH
-
-  .preinit_array     :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__preinit_array_start = .);
-    KEEP (*(.preinit_array*))
-    PROVIDE_HIDDEN (__preinit_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  .init_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__init_array_start = .);
-    KEEP (*(SORT(.init_array.*)))
-    KEEP (*(.init_array*))
-    PROVIDE_HIDDEN (__init_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-  .fini_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__fini_array_start = .);
-    KEEP (*(SORT(.fini_array.*)))
-    KEEP (*(.fini_array*))
-    PROVIDE_HIDDEN (__fini_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  /* used by the startup to initialize data */
    _sidata = LOADADDR(.data);

-  /* Initialized data sections goes into RAM, load LMA copy after code */
    .data :
    {
        . = ALIGN(8);
-    _sdata = .;        /* create a global symbol at data start */
-    *(.data)           /* .data sections */
-    *(.data*)          /* .data* sections */
-
+        _sdata = .;
+        *(.data*)
        . = ALIGN(8);
-    _edata = .;        /* define a global symbol at data end */
-  } >RAM AT> FLASH
+        _edata = .;
+    } >ram AT> flash

-  _sisram2 = LOADADDR(.sram2);
-
-  /* CCM-RAM section
-  *
-  * IMPORTANT NOTE!
-  * If initialized variables will be placed in this section,
-  * the startup code needs to be modified to copy the init-values.
-  */
-  .sram2 :
-  {
-    . = ALIGN(8);
-    _ssram2 = .;       /* create a global symbol at sram2 start */
-    *(.sram2)
-    *(.sram2*)
-
-    . = ALIGN(8);
-    _esram2 = .;       /* create a global symbol at sram2 end */
-  } >SRAM2 AT> FLASH
-
-
-  /* Uninitialized data section */
-  . = ALIGN(4);
    .bss :
    {
-    /* This is used by the startup in order to initialize the .bss secion */
-    _sbss = .;         /* define a global symbol at bss start */
+        . = ALIGN(4);
+        _sbss = .;
        __bss_start__ = _sbss;
-    *(.bss)
        *(.bss*)
        *(COMMON)
-
        . = ALIGN(4);
-    _ebss = .;         /* define a global symbol at bss end */
+        _ebss = .;
        __bss_end__ = _ebss;
-  } >RAM
+    } > ram

-  /* User_heap_stack section, used to check that there is enough RAM left */
-  ._user_heap_stack :
+    ._stack :
    {
        . = ALIGN(8);
-    PROVIDE ( end = . );
-    PROVIDE ( _end = . );
-    . = . + _Min_Heap_Size;
-    . = . + _Min_Stack_Size;
+        end = .;
+        _end = .;
+        . = . + _MIN_STACK_SIZE;
        . = ALIGN(8);
-  } >RAM
+    } > ram

-
-
-  /* Remove information from the standard libraries */
-  /DISCARD/ :
-  {
-    libc.a ( * )
-    libm.a ( * )
-    libgcc.a ( * )
-  }
-
-  .ARM.attributes 0 : { *(.ARM.attributes) }
 }
--- a/targets/stm32l432/linker/stm32l4xx.ld
+++ b/targets/stm32l432/linker/stm32l4xx.ld
@ -1,202 +1,80 @@
-/*
-*****************************************************************************
-**
+/* Copyright 2019 SoloKeys Developers */
+/* */
+/* Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or */
+/* http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or */
+/* http://opensource.org/licenses/MIT>, at your option. This file may not be */
+/* copied, modified, or distributed except according to those terms. */

-**  File        : LinkerScript.ld
-**
-**  Abstract    : Linker script for STM32L432KCUx Device with
-**                256KByte FLASH, 64KByte RAM
-**
-**                Set heap size, stack size and stack location according
-**                to application requirements.
-**
-**                Set memory bank area and size if external memory is used.
-**
-**  Target      : STMicroelectronics STM32
-**
-**
-**  Distribution: The file is distributed as is, without any warranty
-**                of any kind.
-**
-**  (c)Copyright Ac6.
-**  You may use this file as-is or modify it according to the needs of your
-**  project. Distribution of this file (unmodified or modified) is not
-**  permitted. Ac6 permit registered System Workbench for MCU users the
-**  rights to distribute the assembled, compiled & linked contents of this
-**  file as part of an application binary file, provided that it is built
-**  using the System Workbench for MCU toolchain.
-**
-*****************************************************************************
-*/
-
-/* Entry Point */
 ENTRY(Reset_Handler)

-/* Highest address of the user mode stack */
-_estack = 0x2000c000;    /* end of RAM */
-/* Generate a link error if heap and stack don't fit into RAM */
-_Min_Heap_Size = 0x200;      /* required amount of heap  */
-_Min_Stack_Size = 0x400; /* required amount of stack */
+/* End of RAM */
+_estack = 0x2000c000;
+
+_MIN_STACK_SIZE = 0x400;
+
+/*
+    Memory layout of device:
+        20 KB            198KB-8            38 KB
+    | bootloader |    application     |  secrets/data |
+ */

-/* Specify the memory areas */
 MEMORY
 {
-/* First 20 KB is bootloader */
-FLASH (rx)      : ORIGIN = 0x08005000, LENGTH = 198K-8 /* Leave out 38 Kb at end for data */
-RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 48K
-SRAM2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
+    flash (rx)      : ORIGIN = 0x08005000, LENGTH = 198K - 8
+    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
+    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }

-/* Define output sections */
 SECTIONS
 {
-  /* The startup code goes first into FLASH */
    .isr_vector :
    {
        . = ALIGN(8);
-    KEEP(*(.isr_vector)) /* Startup code */
+        KEEP(*(.isr_vector))
        . = ALIGN(8);
-  } >FLASH
+    } >flash

-  /* The program code and other data goes into FLASH */
    .text :
    {
        . = ALIGN(8);
-    *(.text)           /* .text sections (code) */
-    *(.text*)          /* .text* sections (code) */
-    *(.glue_7)         /* glue arm to thumb code */
-    *(.glue_7t)        /* glue thumb to arm code */
-    *(.eh_frame)
-
+        *(.text*)
+        *(.rodata*)
        KEEP(*(.init))
-    KEEP (*(.fini))
+        KEEP(*(.finit))
+        . = ALIGN(8);
+        _etext = .;
+    } >flash

-    . = ALIGN(8);
-    _etext = .;        /* define a global symbols at end of code */
-  } >FLASH
-
-  /* Constant data goes into FLASH */
-  .rodata :
-  {
-    . = ALIGN(8);
-    *(.rodata)         /* .rodata sections (constants, strings, etc.) */
-    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
-    . = ALIGN(8);
-  } >FLASH
-
-  .ARM.extab   :
-  {
-  . = ALIGN(8);
-  *(.ARM.extab* .gnu.linkonce.armextab.*)
-  . = ALIGN(8);
-  } >FLASH
-  .ARM : {
-	. = ALIGN(8);
-    __exidx_start = .;
-    *(.ARM.exidx*)
-    __exidx_end = .;
-	. = ALIGN(8);
-  } >FLASH
-
-  .preinit_array     :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__preinit_array_start = .);
-    KEEP (*(.preinit_array*))
-    PROVIDE_HIDDEN (__preinit_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  .init_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__init_array_start = .);
-    KEEP (*(SORT(.init_array.*)))
-    KEEP (*(.init_array*))
-    PROVIDE_HIDDEN (__init_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-  .fini_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__fini_array_start = .);
-    KEEP (*(SORT(.fini_array.*)))
-    KEEP (*(.fini_array*))
-    PROVIDE_HIDDEN (__fini_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  /* used by the startup to initialize data */
    _sidata = LOADADDR(.data);

-  /* Initialized data sections goes into RAM, load LMA copy after code */
    .data :
    {
        . = ALIGN(8);
-    _sdata = .;        /* create a global symbol at data start */
-    *(.data)           /* .data sections */
-    *(.data*)          /* .data* sections */
-
+        _sdata = .;
+        *(.data*)
        . = ALIGN(8);
-    _edata = .;        /* define a global symbol at data end */
-  } >RAM AT> FLASH
+        _edata = .;
+    } >ram AT> flash

-  _sisram2 = LOADADDR(.sram2);
-
-  /* CCM-RAM section
-  *
-  * IMPORTANT NOTE!
-  * If initialized variables will be placed in this section,
-  * the startup code needs to be modified to copy the init-values.
-  */
-  .sram2 :
-  {
-    . = ALIGN(8);
-    _ssram2 = .;       /* create a global symbol at sram2 start */
-    *(.sram2)
-    *(.sram2*)
-
-    . = ALIGN(8);
-    _esram2 = .;       /* create a global symbol at sram2 end */
-  } >SRAM2 AT> FLASH
-
-
-  /* Uninitialized data section */
-  . = ALIGN(4);
    .bss :
    {
-    /* This is used by the startup in order to initialize the .bss secion */
-    _sbss = .;         /* define a global symbol at bss start */
+        . = ALIGN(4);
+        _sbss = .;
        __bss_start__ = _sbss;
-    *(.bss)
        *(.bss*)
        *(COMMON)
-
        . = ALIGN(4);
-    _ebss = .;         /* define a global symbol at bss end */
+        _ebss = .;
        __bss_end__ = _ebss;
-  } >RAM
+    } > ram

-  /* User_heap_stack section, used to check that there is enough RAM left */
-  ._user_heap_stack :
+    ._stack :
    {
        . = ALIGN(8);
-    PROVIDE ( end = . );
-    PROVIDE ( _end = . );
-    . = . + _Min_Heap_Size;
-    . = . + _Min_Stack_Size;
+        end = .;
+        _end = .;
+        . = . + _MIN_STACK_SIZE;
        . = ALIGN(8);
-  } >RAM
+    } > ram

-
-
-  /* Remove information from the standard libraries */
-  /DISCARD/ :
-  {
-    libc.a ( * )
-    libm.a ( * )
-    libgcc.a ( * )
-  }
-
-  .ARM.attributes 0 : { *(.ARM.attributes) }
 }
--- a/targets/stm32l432/linker/stm32l4xx_extra.ld
+++ b/targets/stm32l432/linker/stm32l4xx_extra.ld
@ -1,203 +1,74 @@
-/*
-*****************************************************************************
-**
+/* Copyright 2019 SoloKeys Developers */
+/* */
+/* Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or */
+/* http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or */
+/* http://opensource.org/licenses/MIT>, at your option. This file may not be */
+/* copied, modified, or distributed except according to those terms. */

-**  File        : LinkerScript.ld
-**
-**  Abstract    : Linker script for STM32L432KCUx Device with
-**                256KByte FLASH, 64KByte RAM
-**
-**                Set heap size, stack size and stack location according
-**                to application requirements.
-**
-**                Set memory bank area and size if external memory is used.
-**
-**  Target      : STMicroelectronics STM32
-**
-**
-**  Distribution: The file is distributed as is, without any warranty
-**                of any kind.
-**
-**  (c)Copyright Ac6.
-**  You may use this file as-is or modify it according to the needs of your
-**  project. Distribution of this file (unmodified or modified) is not
-**  permitted. Ac6 permit registered System Workbench for MCU users the
-**  rights to distribute the assembled, compiled & linked contents of this
-**  file as part of an application binary file, provided that it is built
-**  using the System Workbench for MCU toolchain.
-**
-*****************************************************************************
-*/
-
-/* Entry Point */
 ENTRY(Reset_Handler)

-/* Highest address of the user mode stack */
-_estack = 0x2000c000;    /* end of RAM */
-/* Generate a link error if heap and stack don't fit into RAM */
-_Min_Heap_Size = 0x200;      /* required amount of heap  */
-_Min_Stack_Size = 0x400; /* required amount of stack */
+/* End of RAM */
+_estack = 0x2000c000;
+
+_MIN_STACK_SIZE = 0x400;

-/* Specify the memory areas */
 MEMORY
 {
-/* First 32 KB is bootloader */ 
-/*FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 238K-8 [> Leave out 38 Kb at end for data <]*/
-FLASH (rx)      : ORIGIN = 0x08008000, LENGTH = 186K-8 /* Leave out 38 Kb at end for data */
-RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 48K
-SRAM2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
+    flash (rx)      : ORIGIN = 0x08008000, LENGTH = 186K - 8
+    ram (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
+    sram2 (rw)      : ORIGIN = 0x10000000, LENGTH = 16K
 }

-/* Define output sections */
 SECTIONS
 {
-  /* The startup code goes first into FLASH */
    .isr_vector :
    {
        . = ALIGN(8);
-    KEEP(*(.isr_vector)) /* Startup code */
+        KEEP(*(.isr_vector))
        . = ALIGN(8);
-  } >FLASH
+    } >flash

-  /* The program code and other data goes into FLASH */
    .text :
    {
        . = ALIGN(8);
-    *(.text)           /* .text sections (code) */
-    *(.text*)          /* .text* sections (code) */
-    *(.glue_7)         /* glue arm to thumb code */
-    *(.glue_7t)        /* glue thumb to arm code */
-    *(.eh_frame)
-
+        *(.text*)
+        *(.rodata*)
        KEEP(*(.init))
-    KEEP (*(.fini))
+        KEEP(*(.finit))
+        . = ALIGN(8);
+        _etext = .;
+    } >flash

-    . = ALIGN(8);
-    _etext = .;        /* define a global symbols at end of code */
-  } >FLASH
-
-  /* Constant data goes into FLASH */
-  .rodata :
-  {
-    . = ALIGN(8);
-    *(.rodata)         /* .rodata sections (constants, strings, etc.) */
-    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
-    . = ALIGN(8);
-  } >FLASH
-
-  .ARM.extab   :
-  {
-  . = ALIGN(8);
-  *(.ARM.extab* .gnu.linkonce.armextab.*)
-  . = ALIGN(8);
-  } >FLASH
-  .ARM : {
-	. = ALIGN(8);
-    __exidx_start = .;
-    *(.ARM.exidx*)
-    __exidx_end = .;
-	. = ALIGN(8);
-  } >FLASH
-
-  .preinit_array     :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__preinit_array_start = .);
-    KEEP (*(.preinit_array*))
-    PROVIDE_HIDDEN (__preinit_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  .init_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__init_array_start = .);
-    KEEP (*(SORT(.init_array.*)))
-    KEEP (*(.init_array*))
-    PROVIDE_HIDDEN (__init_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-  .fini_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__fini_array_start = .);
-    KEEP (*(SORT(.fini_array.*)))
-    KEEP (*(.fini_array*))
-    PROVIDE_HIDDEN (__fini_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  /* used by the startup to initialize data */
    _sidata = LOADADDR(.data);

-  /* Initialized data sections goes into RAM, load LMA copy after code */
    .data :
    {
        . = ALIGN(8);
-    _sdata = .;        /* create a global symbol at data start */
-    *(.data)           /* .data sections */
-    *(.data*)          /* .data* sections */
-
+        _sdata = .;
+        *(.data*)
        . = ALIGN(8);
-    _edata = .;        /* define a global symbol at data end */
-  } >RAM AT> FLASH
+        _edata = .;
+    } >ram AT> flash

-  _sisram2 = LOADADDR(.sram2);
-
-  /* CCM-RAM section
-  *
-  * IMPORTANT NOTE!
-  * If initialized variables will be placed in this section,
-  * the startup code needs to be modified to copy the init-values.
-  */
-  .sram2 :
-  {
-    . = ALIGN(8);
-    _ssram2 = .;       /* create a global symbol at sram2 start */
-    *(.sram2)
-    *(.sram2*)
-
-    . = ALIGN(8);
-    _esram2 = .;       /* create a global symbol at sram2 end */
-  } >SRAM2 AT> FLASH
-
-
-  /* Uninitialized data section */
-  . = ALIGN(4);
    .bss :
    {
-    /* This is used by the startup in order to initialize the .bss secion */
-    _sbss = .;         /* define a global symbol at bss start */
+        . = ALIGN(4);
+        _sbss = .;
        __bss_start__ = _sbss;
-    *(.bss)
        *(.bss*)
        *(COMMON)
-
        . = ALIGN(4);
-    _ebss = .;         /* define a global symbol at bss end */
+        _ebss = .;
        __bss_end__ = _ebss;
-  } >RAM
+    } > ram

-  /* User_heap_stack section, used to check that there is enough RAM left */
-  ._user_heap_stack :
+    ._stack :
    {
        . = ALIGN(8);
-    PROVIDE ( end = . );
-    PROVIDE ( _end = . );
-    . = . + _Min_Heap_Size;
-    . = . + _Min_Stack_Size;
+        end = .;
+        _end = .;
+        . = . + _MIN_STACK_SIZE;
        . = ALIGN(8);
-  } >RAM
+    } > ram

-
-
-  /* Remove information from the standard libraries */
-  /DISCARD/ :
-  {
-    libc.a ( * )
-    libm.a ( * )
-    libgcc.a ( * )
-  }
-
-  .ARM.attributes 0 : { *(.ARM.attributes) }
 }
--- a/targets/stm32l432/src/redirect.c
+++ b/targets/stm32l432/src/redirect.c
@ -39,7 +39,7 @@ int _write (int fd, const void *buf, unsigned long int len)
 	// logbuflen += len;

 	// Send out USB serial
-	CDC_Transmit_FS(buf, len);
+	CDC_Transmit_FS(data, len);
 	// if (res == USBD_OK)
 	// 	logbuflen = 0;
 #endif
--- a/targets/stm32l432/src/rng.c
+++ b/targets/stm32l432/src/rng.c
@ -17,7 +17,7 @@ int __errno = 0;

 void rng_get_bytes(uint8_t * dst, size_t sz)
 {
-    uint8_t r[8];
+    uint8_t r[4];
    unsigned int i,j;
    for (i = 0; i < sz; i += 4)
    {
@ -33,7 +33,7 @@ void rng_get_bytes(uint8_t * dst, size_t sz)

        for (j = 0; j < 4; j++)
        {
-            if ((i + j) > sz)
+            if ((i + j) >= sz)
            {
                return;
            }
--- a/targets/stm32l432/src/script.ld
+++ b/targets/stm32l432/src/script.ld
@ -1,183 +0,0 @@
-/*
-*****************************************************************************
-**
-
-**  File        : LinkerScript.ld
-**
-**  Abstract    : Linker script for STM32L432KCUx Device with
-**                256KByte FLASH, 64KByte RAM
-**
-**                Set heap size, stack size and stack location according
-**                to application requirements.
-**
-**                Set memory bank area and size if external memory is used.
-**
-**  Target      : STMicroelectronics STM32
-**
-**
-**  Distribution: The file is distributed as is, without any warranty
-**                of any kind.
-**
-**  (c)Copyright Ac6.
-**  You may use this file as-is or modify it according to the needs of your
-**  project. Distribution of this file (unmodified or modified) is not
-**  permitted. Ac6 permit registered System Workbench for MCU users the
-**  rights to distribute the assembled, compiled & linked contents of this
-**  file as part of an application binary file, provided that it is built
-**  using the System Workbench for MCU toolchain.
-**
-*****************************************************************************
-*/
-
-/* Entry Point */
-ENTRY(Reset_Handler)
-
-/* Highest address of the user mode stack */
-_estack = 0x20010000;    /* end of RAM */
-/* Generate a link error if heap and stack don't fit into RAM */
-_Min_Heap_Size = 0x200;      /* required amount of heap  */
-_Min_Stack_Size = 0x400; /* required amount of stack */
-
-/* Specify the memory areas */
-MEMORY
-{
-RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 64K
-FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 256K
-}
-
-/* Define output sections */
-SECTIONS
-{
-  /* The startup code goes first into FLASH */
-  .isr_vector :
-  {
-    . = ALIGN(8);
-    KEEP(*(.isr_vector)) /* Startup code */
-    . = ALIGN(8);
-  } >FLASH
-
-  /* The program code and other data goes into FLASH */
-  .text :
-  {
-    . = ALIGN(8);
-    *(.text)           /* .text sections (code) */
-    *(.text*)          /* .text* sections (code) */
-    *(.glue_7)         /* glue arm to thumb code */
-    *(.glue_7t)        /* glue thumb to arm code */
-    *(.eh_frame)
-
-    KEEP (*(.init))
-    KEEP (*(.fini))
-
-    . = ALIGN(8);
-    _etext = .;        /* define a global symbols at end of code */
-  } >FLASH
-
-  /* Constant data goes into FLASH */
-  .rodata :
-  {
-    . = ALIGN(8);
-    *(.rodata)         /* .rodata sections (constants, strings, etc.) */
-    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
-    . = ALIGN(8);
-  } >FLASH
-
-  .ARM.extab   : 
-  { 
-  . = ALIGN(8);
-  *(.ARM.extab* .gnu.linkonce.armextab.*)
-  . = ALIGN(8);
-  } >FLASH
-  .ARM : {
-	. = ALIGN(8);
-    __exidx_start = .;
-    *(.ARM.exidx*)
-    __exidx_end = .;
-	. = ALIGN(8);
-  } >FLASH
-
-  .preinit_array     :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__preinit_array_start = .);
-    KEEP (*(.preinit_array*))
-    PROVIDE_HIDDEN (__preinit_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-  
-  .init_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__init_array_start = .);
-    KEEP (*(SORT(.init_array.*)))
-    KEEP (*(.init_array*))
-    PROVIDE_HIDDEN (__init_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-  .fini_array :
-  {
-	. = ALIGN(8);
-    PROVIDE_HIDDEN (__fini_array_start = .);
-    KEEP (*(SORT(.fini_array.*)))
-    KEEP (*(.fini_array*))
-    PROVIDE_HIDDEN (__fini_array_end = .);
-	. = ALIGN(8);
-  } >FLASH
-
-  /* used by the startup to initialize data */
-  _sidata = LOADADDR(.data);
-
-  /* Initialized data sections goes into RAM, load LMA copy after code */
-  .data : 
-  {
-    . = ALIGN(8);
-    _sdata = .;        /* create a global symbol at data start */
-    *(.data)           /* .data sections */
-    *(.data*)          /* .data* sections */
-
-    . = ALIGN(8);
-    _edata = .;        /* define a global symbol at data end */
-  } >RAM AT> FLASH
-
-  
-  /* Uninitialized data section */
-  . = ALIGN(4);
-  .bss :
-  {
-    /* This is used by the startup in order to initialize the .bss secion */
-    _sbss = .;         /* define a global symbol at bss start */
-    __bss_start__ = _sbss;
-    *(.bss)
-    *(.bss*)
-    *(COMMON)
-
-    . = ALIGN(4);
-    _ebss = .;         /* define a global symbol at bss end */
-    __bss_end__ = _ebss;
-  } >RAM
-
-  /* User_heap_stack section, used to check that there is enough RAM left */
-  ._user_heap_stack :
-  {
-    . = ALIGN(8);
-    PROVIDE ( end = . );
-    PROVIDE ( _end = . );
-    . = . + _Min_Heap_Size;
-    . = . + _Min_Stack_Size;
-    . = ALIGN(8);
-  } >RAM
-
-  
-
-  /* Remove information from the standard libraries */
-  /DISCARD/ :
-  {
-    libc.a ( * )
-    libm.a ( * )
-    libgcc.a ( * )
-  }
-
-  .ARM.attributes 0 : { *(.ARM.attributes) }
-}
-
-
--- a/tools/ctap_test.py
+++ b/tools/ctap_test.py
--- a/tools/testing/main.py
+++ b/tools/testing/main.py
@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2019 SoloKeys Developers
+#
+# Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+# http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+# http://opensource.org/licenses/MIT>, at your option. This file may not be
+# copied, modified, or distributed except according to those terms.
+#
+
+# Script for testing correctness of CTAP2/CTAP1 security token
+
+import sys
+
+from solo.fido2 import force_udp_backend
+from tests import Tester, FIDO2Tests, U2FTests, HIDTests, SoloTests
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: %s [sim] <[u2f]|[fido2]|[rk]|[hid]|[ping]>")
+        sys.exit(0)
+
+    t = Tester()
+    t.set_user_count(3)
+
+    if "sim" in sys.argv:
+        print("Using UDP backend.")
+        force_udp_backend()
+        t.set_sim(True)
+        t.set_user_count(10)
+
+    t.find_device()
+
+    if "solo" in sys.argv:
+        SoloTests(t).run()
+
+    if "u2f" in sys.argv:
+        U2FTests(t).run()
+
+    if "fido2" in sys.argv:
+        # t.test_fido2()
+        FIDO2Tests(t).run()
+
+    # hid tests are a bit invasive and should be done last
+    if "hid" in sys.argv:
+        HIDTests(t).run()
+
+    if "bootloader" in sys.argv:
+        if t.is_sim:
+            raise RuntimeError("Cannot test bootloader in simulation yet.")
+        # print("Put device in bootloader mode and then hit enter")
+        # input()
+        # t.test_bootloader()
+
+    # t.test_responses()
+    # t.test_fido2_brute_force()
--- a/tools/testing/tests/init.py
+++ b/tools/testing/tests/init.py
@ -0,0 +1,11 @@
+from . import fido2
+from . import hid
+from . import solo
+from . import u2f
+from . import tester
+
+FIDO2Tests = fido2.FIDO2Tests
+HIDTests = hid.HIDTests
+U2FTests = u2f.U2FTests
+SoloTests = solo.SoloTests
+Tester = tester.Tester
--- a/tools/testing/tests/fido2.py
+++ b/tools/testing/tests/fido2.py
--- a/tools/testing/tests/hid.py
+++ b/tools/testing/tests/hid.py
@ -0,0 +1,252 @@
+import sys, os, time
+from binascii import hexlify
+
+from fido2.hid import CTAPHID
+from fido2.ctap import CtapError
+
+from .tester import Tester, Test
+
+
+class HIDTests(Tester):
+    def __init__(self, tester=None):
+        super().__init__(tester)
+        self.check_timeouts = False
+
+    def set_check_timeouts(self, en):
+        self.check_timeouts = en
+
+    def run(self,):
+        self.test_long_ping()
+        self.test_hid(self.check_timeouts)
+
+    def test_long_ping(self):
+        amt = 1000
+        pingdata = os.urandom(amt)
+        with Test("Send %d byte ping" % amt):
+            try:
+                t1 = time.time() * 1000
+                r = self.send_data(CTAPHID.PING, pingdata)
+                t2 = time.time() * 1000
+                delt = t2 - t1
+                # if (delt < 140 ):
+                # raise RuntimeError('Fob is too fast (%d ms)' % delt)
+                if delt > 555 * (amt / 1000):
+                    raise RuntimeError("Fob is too slow (%d ms)" % delt)
+                if r != pingdata:
+                    raise ValueError("Ping data not echo'd")
+            except CtapError:
+                raise RuntimeError("ping failed")
+
+        sys.stdout.flush()
+
+    def test_hid(self, check_timeouts=False):
+        if check_timeouts:
+            with Test("idle"):
+                try:
+                    cmd, resp = self.recv_raw()
+                except socket.timeout:
+                    pass
+
+        with Test("init"):
+            r = self.send_data(CTAPHID.INIT, "\x11\x11\x11\x11\x11\x11\x11\x11")
+
+        with Test("100 byte ping"):
+            pingdata = os.urandom(100)
+            try:
+                r = self.send_data(CTAPHID.PING, pingdata)
+                if r != pingdata:
+                    raise ValueError("Ping data not echo'd")
+            except CtapError as e:
+                print("100 byte Ping failed:", e)
+                raise RuntimeError("ping failed")
+
+        self.test_long_ping()
+
+        with Test("Wink"):
+            r = self.send_data(CTAPHID.WINK, "")
+
+        with Test("CBOR msg with no data"):
+            try:
+                r = self.send_data(CTAPHID.CBOR, "")
+                if len(r) > 1 or r[0] == 0:
+                    raise RuntimeError("Cbor is supposed to have payload")
+            except CtapError as e:
+                assert e.code == CtapError.ERR.INVALID_LENGTH
+
+        with Test("No data in U2F msg"):
+            try:
+                r = self.send_data(CTAPHID.MSG, "")
+                print(hexlify(r))
+                if len(r) > 2:
+                    raise RuntimeError("MSG is supposed to have payload")
+            except CtapError as e:
+                assert e.code == CtapError.ERR.INVALID_LENGTH
+
+        with Test("Use init command to resync"):
+            r = self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+
+        with Test("Invalid HID command"):
+            try:
+                r = self.send_data(0x66, "")
+                raise RuntimeError("Invalid command did not return error")
+            except CtapError as e:
+                assert e.code == CtapError.ERR.INVALID_COMMAND
+
+        with Test("Sending packet with too large of a length."):
+            self.send_raw("\x81\x1d\xba\x00")
+            cmd, resp = self.recv_raw()
+            Tester.check_error(resp, CtapError.ERR.INVALID_LENGTH)
+
+        r = self.send_data(CTAPHID.PING, "\x44" * 200)
+        with Test("Sending packets that skip a sequence number."):
+            self.send_raw("\x81\x04\x90")
+            self.send_raw("\x00")
+            self.send_raw("\x01")
+            # skip 2
+            self.send_raw("\x03")
+            cmd, resp = self.recv_raw()
+            Tester.check_error(resp, CtapError.ERR.INVALID_SEQ)
+
+        with Test("Resync and send ping"):
+            try:
+                r = self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+                pingdata = os.urandom(100)
+                r = self.send_data(CTAPHID.PING, pingdata)
+                if r != pingdata:
+                    raise ValueError("Ping data not echo'd")
+            except CtapError as e:
+                raise RuntimeError("resync fail: ", e)
+
+        with Test("Send ping and abort it"):
+            self.send_raw("\x81\x04\x00")
+            self.send_raw("\x00")
+            self.send_raw("\x01")
+            try:
+                r = self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+            except CtapError as e:
+                raise RuntimeError("resync fail: ", e)
+
+        with Test("Send ping and abort it with different cid, expect timeout"):
+            oldcid = self.cid()
+            newcid = "\x11\x22\x33\x44"
+            self.send_raw("\x81\x10\x00")
+            self.send_raw("\x00")
+            self.send_raw("\x01")
+            self.set_cid(newcid)
+            self.send_raw(
+                "\x86\x00\x08\x11\x22\x33\x44\x55\x66\x77\x88"
+            )  # init from different cid
+            print("wait for init response")
+            cmd, r = self.recv_raw()  # init response
+            assert cmd == 0x86
+            self.set_cid(oldcid)
+            if check_timeouts:
+                # print('wait for timeout')
+                cmd, r = self.recv_raw()  # timeout response
+                assert cmd == 0xBF
+
+        with Test("Test timeout"):
+            self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+            t1 = time.time() * 1000
+            self.send_raw("\x81\x04\x00")
+            self.send_raw("\x00")
+            self.send_raw("\x01")
+            cmd, r = self.recv_raw()  # timeout response
+            t2 = time.time() * 1000
+            delt = t2 - t1
+            assert cmd == 0xBF
+            assert r[0] == CtapError.ERR.TIMEOUT
+            assert delt < 1000 and delt > 400
+
+        with Test("Test not cont"):
+            self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+            self.send_raw("\x81\x04\x00")
+            self.send_raw("\x00")
+            self.send_raw("\x01")
+            self.send_raw("\x81\x10\x00")  # init packet
+            cmd, r = self.recv_raw()  # timeout response
+            assert cmd == 0xBF
+            assert r[0] == CtapError.ERR.INVALID_SEQ
+
+        if check_timeouts:
+            with Test("Check random cont ignored"):
+                self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+                self.send_raw("\x01\x10\x00")
+                try:
+                    cmd, r = self.recv_raw()  # timeout response
+                except socket.timeout:
+                    pass
+
+        with Test("Check busy"):
+            t1 = time.time() * 1000
+            self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+            oldcid = self.cid()
+            newcid = "\x11\x22\x33\x44"
+            self.send_raw("\x81\x04\x00")
+            self.set_cid(newcid)
+            self.send_raw("\x81\x04\x00")
+            cmd, r = self.recv_raw()  # busy response
+            t2 = time.time() * 1000
+            assert t2 - t1 < 100
+            assert cmd == 0xBF
+            assert r[0] == CtapError.ERR.CHANNEL_BUSY
+
+            self.set_cid(oldcid)
+            cmd, r = self.recv_raw()  # timeout response
+            assert cmd == 0xBF
+            assert r[0] == CtapError.ERR.TIMEOUT
+
+        with Test("Check busy interleaved"):
+            cid1 = "\x11\x22\x33\x44"
+            cid2 = "\x01\x22\x33\x44"
+            self.set_cid(cid2)
+            self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+            self.set_cid(cid1)
+            self.send_data(CTAPHID.INIT, "\x11\x22\x33\x44\x55\x66\x77\x88")
+            self.send_raw("\x81\x00\x63")  # echo 99 bytes first channel
+
+            self.set_cid(cid2)  # send ping on 2nd channel
+            self.send_raw("\x81\x00\x63")
+            Tester.delay(0.1)
+            self.send_raw("\x00")
+
+            cmd, r = self.recv_raw()  # busy response
+
+            self.set_cid(cid1)  # finish 1st channel ping
+            self.send_raw("\x00")
+
+            self.set_cid(cid2)
+
+            assert cmd == 0xBF
+            assert r[0] == CtapError.ERR.CHANNEL_BUSY
+
+            self.set_cid(cid1)
+            cmd, r = self.recv_raw()  # ping response
+            assert cmd == 0x81
+            assert len(r) == 0x63
+
+        if check_timeouts:
+            with Test("Test idle, wait for timeout"):
+                sys.stdout.flush()
+                try:
+                    cmd, resp = self.recv_raw()
+                except socket.timeout:
+                    pass
+
+        with Test("Test cid 0 is invalid"):
+            self.set_cid("\x00\x00\x00\x00")
+            self.send_raw(
+                "\x86\x00\x08\x11\x22\x33\x44\x55\x66\x77\x88", cid="\x00\x00\x00\x00"
+            )
+            cmd, r = self.recv_raw()  # timeout
+            assert cmd == 0xBF
+            assert r[0] == CtapError.ERR.INVALID_CHANNEL
+
+        with Test("Test invalid broadcast cid use"):
+            self.set_cid("\xff\xff\xff\xff")
+            self.send_raw(
+                "\x81\x00\x08\x11\x22\x33\x44\x55\x66\x77\x88", cid="\xff\xff\xff\xff"
+            )
+            cmd, r = self.recv_raw()  # timeout
+            assert cmd == 0xBF
+            assert r[0] == CtapError.ERR.INVALID_CHANNEL
--- a/tools/testing/tests/solo.py
+++ b/tools/testing/tests/solo.py
@ -0,0 +1,70 @@
+from solo.client import SoloClient
+
+from fido2.ctap1 import ApduError
+
+from .util import shannon_entropy
+from .tester import Tester, Test
+
+
+class SoloTests(Tester):
+    def __init__(self, tester=None):
+        super().__init__(tester)
+
+    def run(self,):
+        self.test_solo()
+
+    def test_solo(self,):
+        """
+        Solo specific tests
+        """
+        # RNG command
+        sc = SoloClient()
+        sc.find_device(self.dev)
+        sc.use_u2f()
+        memmap = (0x08005000, 0x08005000 + 198 * 1024 - 8)
+
+        total = 1024 * 16
+        with Test("Gathering %d random bytes..." % total):
+            entropy = b""
+            while len(entropy) < total:
+                entropy += sc.get_rng()
+
+        with Test("Test entropy is close to perfect"):
+            s = shannon_entropy(entropy)
+            assert s > 7.98
+        print("Entropy is %.5f bits per byte." % s)
+
+        with Test("Test Solo version command"):
+            assert len(sc.solo_version()) == 3
+
+        with Test("Test bootloader is not active"):
+            try:
+                sc.write_flash(memmap[0], b"1234")
+            except ApduError:
+                pass
+
+        sc.exchange = sc.exchange_fido2
+        with Test("Test Solo version and random commands with fido2 layer"):
+            assert len(sc.solo_version()) == 3
+            sc.get_rng()
+
+    def test_bootloader(self,):
+        sc = SoloClient()
+        sc.find_device(self.dev)
+        sc.use_u2f()
+
+        memmap = (0x08005000, 0x08005000 + 198 * 1024 - 8)
+        data = b"A" * 64
+
+        with Test("Test version command"):
+            assert len(sc.bootloader_version()) == 3
+
+        with Test("Test write command"):
+            sc.write_flash(memmap[0], data)
+
+        for addr in (memmap[0] - 8, memmap[0] - 4, memmap[1], memmap[1] - 8):
+            with Test("Test out of bounds write command at 0x%04x" % addr):
+                try:
+                    sc.write_flash(addr, data)
+                except CtapError as e:
+                    assert e.code == CtapError.ERR.NOT_ALLOWED
--- a/tools/testing/tests/tester.py
+++ b/tools/testing/tests/tester.py
@ -0,0 +1,197 @@
+import time, struct
+
+from fido2.hid import CtapHidDevice
+from fido2.client import Fido2Client
+from fido2.ctap1 import CTAP1
+from fido2.utils import Timeout
+
+from fido2.ctap import CtapError
+
+
+def ForceU2F(client, device):
+    client.ctap = CTAP1(device)
+    client.pin_protocol = None
+    client._do_make_credential = client._ctap1_make_credential
+    client._do_get_assertion = client._ctap1_get_assertion
+
+
+class Packet(object):
+    def __init__(self, data):
+        self.data = data
+
+    def ToWireFormat(self,):
+        return self.data
+
+    @staticmethod
+    def FromWireFormat(pkt_size, data):
+        return Packet(data)
+
+
+class Test:
+    def __init__(self, msg):
+        self.msg = msg
+
+    def __enter__(self,):
+        print(self.msg)
+
+    def __exit__(self, a, b, c):
+        print("Pass")
+
+
+class Tester:
+    def __init__(self, tester=None):
+        self.origin = "https://examplo.org"
+        self.host = "examplo.org"
+        self.user_count = 10
+        self.is_sim = False
+        if tester:
+            self.initFromTester(tester)
+
+    def initFromTester(self, tester):
+        self.user_count = tester.user_count
+        self.is_sim = tester.is_sim
+        self.dev = tester.dev
+        self.ctap = tester.ctap
+        self.ctap1 = tester.ctap1
+        self.client = tester.client
+
+    def find_device(self,):
+        print(list(CtapHidDevice.list_devices()))
+        dev = next(CtapHidDevice.list_devices(), None)
+        if not dev:
+            raise RuntimeError("No FIDO device found")
+        self.dev = dev
+        self.client = Fido2Client(dev, self.origin)
+        self.ctap = self.client.ctap2
+        self.ctap1 = CTAP1(dev)
+
+        # consume timeout error
+        # cmd,resp = self.recv_raw()
+
+    def set_user_count(self, count):
+        self.user_count = count
+
+    def set_sim(self, b):
+        self.is_sim = b
+
+    def reboot(self,):
+        if self.is_sim:
+            print("Sending restart command...")
+            self.send_magic_reboot()
+            Tester.delay(0.25)
+        else:
+            print("Please reboot authentictor and hit enter")
+            input()
+            self.find_device()
+
+    def send_data(self, cmd, data):
+        if not isinstance(data, bytes):
+            data = struct.pack("%dB" % len(data), *[ord(x) for x in data])
+        with Timeout(1.0) as event:
+            return self.dev.call(cmd, data, event)
+
+    def send_raw(self, data, cid=None):
+        if cid is None:
+            cid = self.dev._dev.cid
+        elif not isinstance(cid, bytes):
+            cid = struct.pack("%dB" % len(cid), *[ord(x) for x in cid])
+        if not isinstance(data, bytes):
+            data = struct.pack("%dB" % len(data), *[ord(x) for x in data])
+        data = cid + data
+        l = len(data)
+        if l != 64:
+            pad = "\x00" * (64 - l)
+            pad = struct.pack("%dB" % len(pad), *[ord(x) for x in pad])
+            data = data + pad
+        data = list(data)
+        assert len(data) == 64
+        self.dev._dev.InternalSendPacket(Packet(data))
+
+    def send_magic_reboot(self,):
+        """
+        For use in simulation and testing.  Random bytes that authentictor should detect
+        and then restart itself.
+        """
+        magic_cmd = (
+            b"\xac\x10\x52\xca\x95\xe5\x69\xde\x69\xe0\x2e\xbf"
+            + b"\xf3\x33\x48\x5f\x13\xf9\xb2\xda\x34\xc5\xa8\xa3"
+            + b"\x40\x52\x66\x97\xa9\xab\x2e\x0b\x39\x4d\x8d\x04"
+            + b"\x97\x3c\x13\x40\x05\xbe\x1a\x01\x40\xbf\xf6\x04"
+            + b"\x5b\xb2\x6e\xb7\x7a\x73\xea\xa4\x78\x13\xf6\xb4"
+            + b"\x9a\x72\x50\xdc"
+        )
+        self.dev._dev.InternalSendPacket(Packet(magic_cmd))
+
+    def cid(self,):
+        return self.dev._dev.cid
+
+    def set_cid(self, cid):
+        if not isinstance(cid, (bytes, bytearray)):
+            cid = struct.pack("%dB" % len(cid), *[ord(x) for x in cid])
+        self.dev._dev.cid = cid
+
+    def recv_raw(self,):
+        with Timeout(1.0):
+            cmd, payload = self.dev._dev.InternalRecv()
+        return cmd, payload
+
+    def check_error(data, err=None):
+        assert len(data) == 1
+        if err is None:
+            if data[0] != 0:
+                raise CtapError(data[0])
+        elif data[0] != err:
+            raise ValueError("Unexpected error: %02x" % data[0])
+
+    def testFunc(self, func, test, *args, **kwargs):
+        with Test(test):
+            res = None
+            expectedError = kwargs.get("expectedError", None)
+            otherArgs = kwargs.get("other", {})
+            try:
+                res = func(*args, **otherArgs)
+                if expectedError != CtapError.ERR.SUCCESS:
+                    raise RuntimeError("Expected error to occur for test: %s" % test)
+            except CtapError as e:
+                if expectedError is not None:
+                    cond = e.code != expectedError
+                    if isinstance(expectedError, list):
+                        cond = e.code not in expectedError
+                    else:
+                        expectedError = [expectedError]
+                    if cond:
+                        raise RuntimeError(
+                            f"Got error code {hex(e.code)}, expected {[hex(x) for x in expectedError]}"
+                        )
+                else:
+                    print(e)
+        return res
+
+    def testReset(self,):
+        print("Resetting Authenticator...")
+        try:
+            self.ctap.reset()
+        except CtapError:
+            # Some authenticators need a power cycle
+            print("You must power cycle authentictor.  Hit enter when done.")
+            input()
+            time.sleep(0.2)
+            self.find_device()
+            self.ctap.reset()
+
+    def testMC(self, test, *args, **kwargs):
+        return self.testFunc(self.ctap.make_credential, test, *args, **kwargs)
+
+    def testGA(self, test, *args, **kwargs):
+        return self.testFunc(self.ctap.get_assertion, test, *args, **kwargs)
+
+    def testCP(self, test, *args, **kwargs):
+        return self.testFunc(self.ctap.client_pin, test, *args, **kwargs)
+
+    def testPP(self, test, *args, **kwargs):
+        return self.testFunc(
+            self.client.pin_protocol.get_pin_token, test, *args, **kwargs
+        )
+
+    def delay(secs):
+        time.sleep(secs)
--- a/tools/testing/tests/u2f.py
+++ b/tools/testing/tests/u2f.py
@ -0,0 +1,121 @@
+from fido2.ctap1 import CTAP1, ApduError, APDU
+from fido2.utils import sha256
+from fido2.client import _call_polling
+
+from .tester import Tester, Test
+
+
+class U2FTests(Tester):
+    def __init__(self, tester=None):
+        super().__init__(tester)
+
+    def run(self,):
+        self.test_u2f()
+
+    def register(self, chal, appid):
+        reg_data = _call_polling(0.25, None, None, self.ctap1.register, chal, appid)
+        return reg_data
+
+    def authenticate(self, chal, appid, key_handle, check_only=False):
+        auth_data = _call_polling(
+            0.25,
+            None,
+            None,
+            self.ctap1.authenticate,
+            chal,
+            appid,
+            key_handle,
+            check_only=check_only,
+        )
+        return auth_data
+
+    def test_u2f(self,):
+        chal = sha256(b"AAA")
+        appid = sha256(b"BBB")
+        lastc = 0
+
+        regs = []
+
+        with Test("Check version"):
+            assert self.ctap1.get_version() == "U2F_V2"
+
+        with Test("Check bad INS"):
+            try:
+                self.ctap1.send_apdu(0, 0, 0, 0, b"")
+            except ApduError as e:
+                assert e.code == 0x6D00
+
+        with Test("Check bad CLA"):
+            try:
+                self.ctap1.send_apdu(1, CTAP1.INS.VERSION, 0, 0, b"abc")
+            except ApduError as e:
+                assert e.code == 0x6E00
+
+        for i in range(0, self.user_count):
+            with Test(
+                "U2F reg + auth %d/%d (count: %02x)" % (i + 1, self.user_count, lastc)
+            ):
+                reg = self.register(chal, appid)
+                reg.verify(appid, chal)
+                auth = self.authenticate(chal, appid, reg.key_handle)
+                auth.verify(appid, chal, reg.public_key)
+
+                regs.append(reg)
+                # check endianness
+                if lastc:
+                    assert (auth.counter - lastc) < 10
+                lastc = auth.counter
+                if lastc > 0x80000000:
+                    print("WARNING: counter is unusually high: %04x" % lastc)
+                    assert 0
+
+        for i in range(0, self.user_count):
+            with Test(
+                "Checking previous registration %d/%d" % (i + 1, self.user_count)
+            ):
+                auth = self.authenticate(chal, appid, regs[i].key_handle)
+                auth.verify(appid, chal, regs[i].public_key)
+
+        print("Check that all previous credentials are registered...")
+        for i in range(0, self.user_count):
+            with Test("Check that previous credential %d is registered" % i):
+                try:
+                    auth = self.ctap1.authenticate(
+                        chal, appid, regs[i].key_handle, check_only=True
+                    )
+                except ApduError as e:
+                    # Indicates that key handle is registered
+                    assert e.code == APDU.USE_NOT_SATISFIED
+
+        with Test("Check an incorrect key handle is not registered"):
+            kh = bytearray(regs[0].key_handle)
+            kh[0] = kh[0] ^ (0x40)
+            try:
+                self.ctap1.authenticate(chal, appid, kh, check_only=True)
+                assert 0
+            except ApduError as e:
+                assert e.code == APDU.WRONG_DATA
+
+        with Test("Try to sign with incorrect key handle"):
+            try:
+                self.ctap1.authenticate(chal, appid, kh)
+                assert 0
+            except ApduError as e:
+                assert e.code == APDU.WRONG_DATA
+
+        with Test("Try to sign using an incorrect keyhandle length"):
+            try:
+                kh = regs[0].key_handle
+                self.ctap1.authenticate(chal, appid, kh[: len(kh) // 2])
+                assert 0
+            except ApduError as e:
+                assert e.code == APDU.WRONG_DATA
+
+        with Test("Try to sign using an incorrect appid"):
+            badid = bytearray(appid)
+            badid[0] = badid[0] ^ (0x40)
+            try:
+                auth = self.ctap1.authenticate(chal, badid, regs[0].key_handle)
+                assert 0
+            except ApduError as e:
+                assert e.code == APDU.WRONG_DATA
--- a/tools/testing/tests/util.py
+++ b/tools/testing/tests/util.py
@ -0,0 +1,12 @@
+import math
+
+
+def shannon_entropy(data):
+    s = 0.0
+    total = len(data)
+    for x in range(0, 256):
+        freq = data.count(x)
+        p = freq / total
+        if p > 0:
+            s -= p * math.log2(p)
+    return s
--- a/udev/70-solokeys-access.rules
+++ b/udev/70-solokeys-access.rules
@ -13,7 +13,7 @@ SUBSYSTEM=="hidraw", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="a2ca", TAG+="ua
 SUBSYSTEM=="tty", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="a2ca", TAG+="uaccess"

 # ST DFU access
-SUBSYSTEM=="hidraw", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", TAG+="uaccess"
+SUBSYSTEM=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", TAG+="uaccess"

 # U2F Zero
 SUBSYSTEM=="hidraw", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="8acf", TAG+="uaccess"
--- a/udev/70-solokeys-legacy-access.rules
+++ b/udev/70-solokeys-legacy-access.rules
@ -13,7 +13,7 @@ SUBSYSTEM=="hidraw", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="a2ca", MODE="06
 SUBSYSTEM=="tty", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="a2ca", MODE="0660", GROUP="plugdev"

 # ST DFU access
-SUBSYSTEM=="hidraw", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE="0660", GROUP="plugdev"
+SUBSYSTEM=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE="0660", GROUP="plugdev"

 # U2F Zero
 SUBSYSTEM=="hidraw", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="8acf", MODE="0660", GROUP="plugdev"
--- a/udev/Makefile
+++ b/udev/Makefile
@ -10,6 +10,8 @@

 setup: install activate
 legacy-setup: install-legacy activate
+
+# Symlinks can be setup, we don't officially supply any
 # symlinks: install-symlinks activate

 RULES_PATH=/etc/udev/rules.d
@ -19,10 +21,10 @@ activate:
 	sudo udevadm trigger

 install:
-	sudo ln -sf $(PWD)/70-solokeys-access.rules ${RULES_PATH}/70-solokeys-access.rules
+	sudo cp $(PWD)/70-solokeys-access.rules ${RULES_PATH}/70-solokeys-access.rules

 install-legacy:
-	sudo ln -sf $(PWD)/70-solokeys-legacy-access.rules ${RULES_PATH}/70-solokeys-access.rules
+	sudo cp $(PWD)/70-solokeys-legacy-access.rules ${RULES_PATH}/70-solokeys-access.rules

 # install-symlinks:
 # 	sudo cp $(PWD)/71-solokeys-symlinks.rules ${RULES_PATH}/71-solokeys-symlinks.rules
--- a/udev/README.md
+++ b/udev/README.md
@ -0,0 +1,14 @@
+This is for Linux systems only.
+
+To install the official SoloKeys udev rules, allowing access to your key, run
+
+```
+make install
+```
+
+This should work assuming your system is reasonably up-to-date. If not, try
+
+```
+make install-legacy
+```
+
Author	SHA1	Message	Date
Conor Patrick	89769ecc18	fix u2f counter for real	2019-03-31 23:29:00 -04:00
Conor Patrick	3b3f47bfcf	Merge pull request #155 from solokeys/pin_lockout_ga Pin lockout ga	2019-03-29 17:11:48 -04:00
Conor Patrick	6fa443b0bc	tests for GA without pin	2019-03-26 19:00:42 -04:00
Conor Patrick	893d4131b2	change how pin is enforced for GA	2019-03-26 19:00:12 -04:00
Conor Patrick	4e21c0bd8f	Merge pull request #152 from solokeys/testing_yubikey Testing yubikey	2019-03-26 18:33:03 -04:00
Conor Patrick	251eb6bf64	Merge branch 'master' into testing_yubikey	2019-03-26 16:36:08 -04:00
Conor Patrick	08e236df69	fix code quality issues x/2	2019-03-26 16:14:28 -04:00
Conor Patrick	d2091563ab	fix code quality issues	2019-03-26 16:09:30 -04:00
Conor Patrick	54a6a82ca0	Merge pull request #153 from solokeys/rng-fix Fix buffer overrun and use correct size for random u32	2019-03-26 15:37:51 -04:00
Nicolas Stalder	40b9dae38a	Fix buffer overrun and use correct size for random u32	2019-03-26 01:55:42 +01:00
Nicolas Stalder	98a209e330	make target to flash firmware via bootloader	2019-03-23 13:54:04 +01:00
Nicolas Stalder	d3b5fb68ee	Build debug 1/2 versions of hacker firmware and bundle	2019-03-23 13:52:47 +01:00
Conor Patrick	74a1f0e21b	Merge pull request #143 from solokeys/paranoid-modemmanager Do not signal "AT modem" for ACM-CDC serial	2019-03-23 01:48:18 -04:00
Nicolas Stalder	e21172fff8	Merge pull request #149 from solokeys/hmac-secret Hmac-secret	2019-03-22 22:05:41 +01:00
Nicolas Stalder	9d3144e9b1	oops. black	2019-03-22 21:56:18 +01:00
Nicolas Stalder	a2a774125f	Fix usage and display fido2-ext in it	2019-03-22 21:40:55 +01:00
Nicolas Stalder	349ea5343a	Remove paranoid MM stuff, not signaling AT modem is enough + better	2019-03-22 20:01:31 +01:00
Nicolas Stalder	c851807376	Do not advertise AT modem capabilities	2019-03-22 20:00:02 +01:00
Nicolas Stalder	84d1629aa3	Allow toggling between strict and paranoid ModemManager filter-policy	2019-03-22 20:00:02 +01:00
Nicolas Stalder	8f6ae29163	Fix ModemManager udev rule for some distros	2019-03-22 20:00:02 +01:00
Conor Patrick	a0d27c2c56	add memory layout commment, undo -8 simplification	2019-03-22 19:55:25 +01:00
Conor Patrick	3a10427bd9	remove unused files	2019-03-22 19:55:25 +01:00
Nicolas Stalder	f3b591e570	Apply suggestions from code review Co-Authored-By: conorpp <conorpp94@gmail.com>	2019-03-22 19:55:25 +01:00
Conor Patrick	175f59d206	paste into other linker scripts	2019-03-22 19:55:25 +01:00
Conor Patrick	f5ff6a11f0	rewrite base linker script	2019-03-22 19:55:25 +01:00
Conor Patrick	d979420324	u2f work with yubikey5	2019-03-22 01:59:19 -04:00
Conor Patrick	5076af1be4	works with yubikey5	2019-03-22 01:22:55 -04:00
Conor Patrick	0a7845459c	breakup test_fido2	2019-03-22 00:45:28 -04:00
Conor Patrick	c4262b0f5b	rename	2019-03-22 00:20:48 -04:00
Conor Patrick	53fb0059a7	break into separate files	2019-03-22 00:20:20 -04:00
Conor Patrick	a1a75e4ab5	check errors	2019-03-21 12:47:15 -04:00
Conor Patrick	d68011ef04	remove warnings	2019-03-21 00:01:37 -04:00
Conor Patrick	02e83073e0	add hmac-secret to reg response	2019-03-20 23:58:42 -04:00
Conor Patrick	3a48756f96	remove extra layer of map	2019-03-20 23:40:58 -04:00
Conor Patrick	946e932b1e	refactor to use less ram	2019-03-20 23:28:45 -04:00
Conor Patrick	142d4002e5	remove warning, reduce memory	2019-03-20 23:14:17 -04:00
Conor Patrick	dbe5283e1f	test solo commands on fido2 layer	2019-03-20 21:06:18 -04:00
Conor Patrick	2d233f164e	small bug fixes	2019-03-20 21:03:03 -04:00
Conor Patrick	b62e9906c7	make new function	2019-03-20 20:13:16 -04:00
Conor Patrick	e22e636475	hmac-secret tested	2019-03-20 20:03:25 -04:00
Conor Patrick	074225d87a	hmac-secret fully functional	2019-03-20 20:03:12 -04:00
Conor Patrick	bb9b2ea9d4	validate saltAuth	2019-03-20 18:10:52 -04:00
Conor Patrick	e8d5bc5829	refactor ctap_make_auth_data arguments	2019-03-20 17:43:50 -04:00
Conor Patrick	850381a633	test parsing	2019-03-20 16:52:10 -04:00
Conor Patrick	ce3ad0e56f	bugfix	2019-03-20 16:51:58 -04:00
Conor Patrick	00d86379e5	parse full hmac-secret	2019-03-20 16:21:21 -04:00
Conor Patrick	6098810167	start to test hmac-secret	2019-03-20 15:45:35 -04:00
Conor Patrick	821880a8d6	parse extension info in MC	2019-03-20 15:45:10 -04:00
Conor Patrick	44f96f5843	Merge pull request #148 from solokeys/testing_refactor Testing refactor	2019-03-20 15:06:12 -04:00
Conor Patrick	6ec9fb962a	delay send_raw in test	2019-03-20 14:59:31 -04:00
Conor Patrick	c9bfe001ee	refactored version, previously lost	2019-03-20 14:56:52 -04:00
Nicolas Stalder	5e46fd96ac	Create LICENSE	2019-03-19 16:29:39 +01:00
Nicolas Stalder	103cc3cfb0	Some fun with shields	2019-03-19 16:28:47 +01:00
Conor Patrick	9544330dc3	delay send_raw in test	2019-03-18 04:36:02 +01:00
Conor Patrick	0964ff69b7	refactor a bit	2019-03-18 04:36:02 +01:00
Nicolas Stalder	e4a2b9e1ca	Get udev instructions up to date	2019-03-18 02:52:34 +01:00
Conor Patrick	d29fa34da1	Update README.md	2019-03-15 22:08:07 -04:00
Conor Patrick	6ed2610a5c	Merge pull request #145 from solokeys/stable-v2.0.0 Set STABLE_VERSION to 2.0.0	2019-03-14 19:39:43 -04:00
Nicolas Stalder	3b9d4e5023	Set STABLE_VERSION to 2.0.0	2019-03-15 00:35:50 +01:00
Conor Patrick	2da083c18a	Merge pull request #138 from solokeys/fix-warning I think this does it	2019-03-11 14:33:02 -04:00
Nicolas Stalder	50bfbc1eff	I think this does it	2019-03-10 15:26:45 +01:00
Nicolas Stalder	86739df7a1	Improvements to Docker build	2019-03-10 15:19:16 +01:00
Nicolas Stalder	c7f0d050d7	Fix udev rule for STM bootloader	2019-03-08 14:25:29 +01:00
Conor Patrick	b79670a447	Merge pull request #133 from solokeys/more_testing More testing	2019-03-07 21:25:53 -05:00
Conor Patrick	169ba59ed4	use alpha	2019-03-07 21:19:10 -05:00
Conor Patrick	f3003c58c9	new release 2.0.0	2019-03-07 20:33:20 -05:00
Conor Patrick	084e518018	refactor	2019-03-06 17:43:28 -05:00
Conor Patrick	6674f0a8ff	add more tests	2019-03-06 16:17:12 -05:00
Conor Patrick	f704851419	add bootloader tests	2019-03-06 14:23:56 -05:00
Conor Patrick	0d5e1ee872	Test solo specific commands	2019-03-06 14:06:07 -05:00
Conor Patrick	5cb81c753d	Add version/extensions to PC build	2019-03-06 14:05:44 -05:00
Conor Patrick	b0b0564df9	fix imports	2019-03-06 13:13:43 -05:00
 @ -1 +1 @@
 .1.1
 .0.0