[FL-1958] U2F prototype (#879)

* U2F implementation prototype
* U2F data encryption and store, user confirmation request
* remove debug prints
* fix notification bug in chrome
* split u2f_alloc into u2f_init and u2f_alloc
* typo fix, furi-hal-trng -> furi-hal-random
* rand/srand redefinition
* SubGhz: a little bit of Dante.
* u2f_data naming fix

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

14 files changed, 1026 insertions, 115 deletions

diff --git a/firmware/targets/f6/furi-hal/furi-hal-crypto.c b/firmware/targets/f6/furi-hal/furi-hal-crypto.c
index 91875d23..f5398421 100644
--- a/firmware/targets/f6/furi-hal/furi-hal-crypto.c
+++ b/firmware/targets/f6/furi-hal/furi-hal-crypto.c
@@ -1,5 +1,6 @@
 #include <furi-hal-crypto.h>
 #include <furi-hal-bt.h>
+#include <furi-hal-random.h>
 #include <furi.h>
 #include <shci.h>
 
@@ -7,10 +8,119 @@
 
 CRYP_HandleTypeDef crypt;
 
+#define ENCLAVE_FACTORY_KEY_SLOTS 10
+#define ENCLAVE_SIGNATURE_SIZE 16
+
+static const uint8_t enclave_signature_iv[ENCLAVE_FACTORY_KEY_SLOTS][16] = {
+    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
+    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
+    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
+    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
+    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
+    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
+    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
+    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
+    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
+    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
+};
+
+static const uint8_t enclave_signature_input[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
+    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
+    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
+    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
+    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
+    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
+    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
+    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
+    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
+    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
+};
+
+static const uint8_t enclave_signature_expected[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
+    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
+    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
+    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
+    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
+    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
+    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
+    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
+    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
+    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
+};
+
 void furi_hal_crypto_init() {
     FURI_LOG_I(TAG, "Init OK");
 }
 
+static bool furi_hal_crypto_generate_unique_keys(uint8_t start_slot, uint8_t end_slot) {
+    FuriHalCryptoKey key;
+    uint8_t key_data[32];
+    FURI_LOG_I(TAG, "Generating keys %u..%u", start_slot, end_slot);
+    for (uint8_t slot = start_slot; slot <= end_slot; slot++) {
+        key.type = FuriHalCryptoKeyTypeSimple;
+        key.size = FuriHalCryptoKeySize256;
+        key.data = key_data;
+        furi_hal_random_fill_buf(key_data, 32);
+        if (!furi_hal_crypto_store_add_key(&key, &slot)) {
+            FURI_LOG_E(TAG, "Error writing key to slot %u", slot);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_key(uint8_t key_slot) {
+    uint8_t keys_nb = 0;
+    uint8_t valid_keys_nb = 0;
+    uint8_t last_valid_slot = ENCLAVE_FACTORY_KEY_SLOTS;
+    uint8_t empty_iv[16];
+    furi_hal_crypto_verify_enclave(&keys_nb, &valid_keys_nb);
+    if (key_slot <= ENCLAVE_FACTORY_KEY_SLOTS) { // It's a factory key
+        if (key_slot > keys_nb)
+            return false;
+    } else { // Unique key
+        if (keys_nb < ENCLAVE_FACTORY_KEY_SLOTS) // Some factory keys are missing
+            return false;
+        for (uint8_t i = key_slot; i > ENCLAVE_FACTORY_KEY_SLOTS; i--) {
+            if(furi_hal_crypto_store_load_key(i, empty_iv)) {
+                last_valid_slot = i;
+                furi_hal_crypto_store_unload_key(i);
+                break;
+            }
+        }
+        if (last_valid_slot == key_slot)
+            return true;
+        else // Generate missing unique keys
+            return furi_hal_crypto_generate_unique_keys(last_valid_slot+1, key_slot);
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_enclave(uint8_t* keys_nb, uint8_t* valid_keys_nb) {
+    furi_assert(keys_nb);
+    furi_assert(valid_keys_nb);
+    uint8_t keys = 0;
+    uint8_t keys_valid = 0;
+    uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
+    for(size_t key_slot = 0; key_slot < ENCLAVE_FACTORY_KEY_SLOTS; key_slot++) {
+        if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
+            keys++;
+            if(furi_hal_crypto_encrypt(enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
+                keys_valid += memcmp(buffer, enclave_signature_expected[key_slot], ENCLAVE_SIGNATURE_SIZE) == 0;
+            }
+            furi_hal_crypto_store_unload_key(key_slot + 1);
+        }
+    }
+    *keys_nb = keys;
+    *valid_keys_nb = keys_valid;
+    if (*valid_keys_nb == ENCLAVE_FACTORY_KEY_SLOTS)
+        return true;
+    else
+        return false;
+}
+
 bool furi_hal_crypto_store_add_key(FuriHalCryptoKey* key, uint8_t* slot) {
     furi_assert(key);
     furi_assert(slot);
diff --git a/firmware/targets/f6/furi-hal/furi-hal-info.c b/firmware/targets/f6/furi-hal/furi-hal-info.c
index 783a5113..c1225ac9 100644
--- a/firmware/targets/f6/furi-hal/furi-hal-info.c
+++ b/firmware/targets/f6/furi-hal/furi-hal-info.c
@@ -2,48 +2,6 @@
 #include <furi-hal.h>
 #include <shci.h>
 
-#define ENCLAVE_SIGNATURE_KEY_SLOTS 10
-#define ENCLAVE_SIGNATURE_SIZE 16
-
-static const uint8_t enclave_signature_iv[ENCLAVE_SIGNATURE_KEY_SLOTS][16] = {
-    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
-    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
-    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
-    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
-    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
-    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
-    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
-    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
-    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
-    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
-};
-
-static const uint8_t enclave_signature_input[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
-    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
-    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
-    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
-    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
-    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
-    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
-    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
-    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
-    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
-};
-
-static const uint8_t enclave_signature_expected[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
-    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
-    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
-    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
-    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
-    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
-    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
-    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
-    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
-    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
-};
-
 void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
     string_t value;
     string_init(value);
@@ -164,23 +122,12 @@ void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
         out("radio_ble_mac", string_get_cstr(value), false, context);
 
         // Signature verification
-        uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
-        size_t enclave_valid_keys = 0;
-        for(size_t key_slot = 0; key_slot < ENCLAVE_SIGNATURE_KEY_SLOTS; key_slot++) {
-            if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
-                if(furi_hal_crypto_encrypt(
-                       enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
-                    enclave_valid_keys += memcmp(
-                                              buffer,
-                                              enclave_signature_expected[key_slot],
-                                              ENCLAVE_SIGNATURE_SIZE) == 0;
-                }
-                furi_hal_crypto_store_unload_key(key_slot + 1);
-            }
-        }
+        uint8_t enclave_keys = 0;
+        uint8_t enclave_valid_keys = 0;
+        bool enclave_valid = furi_hal_crypto_verify_enclave(&enclave_keys, &enclave_valid_keys);
         string_printf(value, "%d", enclave_valid_keys);
         out("enclave_valid_keys", string_get_cstr(value), false, context);
-        out("enclave_valid", (enclave_valid_keys == ENCLAVE_SIGNATURE_KEY_SLOTS) ? "true" : "false", true, context);
+        out("enclave_valid", enclave_valid ? "true" : "false", true, context);
     } else {
         out("radio_alive", "false", true, context);
     }
diff --git a/firmware/targets/f6/furi-hal/furi-hal-random.c b/firmware/targets/f6/furi-hal/furi-hal-random.c
new file mode 100644
index 00000000..a7bc3a31
--- /dev/null
+++ b/firmware/targets/f6/furi-hal/furi-hal-random.c
@@ -0,0 +1,56 @@
+#include "furi-hal-random.h"
+#include <furi.h>
+#include <furi-hal.h>
+
+#include <stm32wbxx_ll_rng.h>
+#include <stm32wbxx_ll_hsem.h>
+
+#include <hw_conf.h>
+
+uint32_t furi_hal_random_get() {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+    if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+        furi_crash("TRNG error");
+    }
+
+    uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+
+    return random_val;
+}
+
+void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len) {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    for (uint32_t i = 0; i < len; i+= 4) {
+        while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+        if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+            furi_crash("TRNG error");
+        }
+
+        uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+        uint8_t len_cur = ((i+4) < len) ? (4) : (len-i);
+        memcpy(&buf[i], &random_val, len_cur);
+    }
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+}
+
+void srand(unsigned seed) {
+}
+
+int rand() {
+    return (furi_hal_random_get() & RAND_MAX);
+}
diff --git a/firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c b/firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c
new file mode 100644
index 00000000..a7426c82
--- /dev/null
+++ b/firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c
@@ -0,0 +1,309 @@
+#include "furi-hal-version.h"
+#include "furi-hal-usb_i.h"
+#include "furi-hal-usb-hid-u2f.h"
+#include "furi-hal-usb.h"
+#include <furi.h>
+#include "usb.h"
+#include "usb_hid.h"
+
+#define HID_PAGE_FIDO 0xF1D0
+#define HID_FIDO_U2F 0x01
+#define HID_FIDO_INPUT 0x20
+#define HID_FIDO_OUTPUT 0x21
+
+#define HID_EP_IN 0x81
+#define HID_EP_OUT 0x01
+
+struct HidIadDescriptor {
+    struct usb_iad_descriptor hid_iad;
+    struct usb_interface_descriptor hid;
+    struct usb_hid_descriptor hid_desc;
+    struct usb_endpoint_descriptor hid_ep_in;
+    struct usb_endpoint_descriptor hid_ep_out;
+};
+
+struct HidConfigDescriptor {
+    struct usb_config_descriptor config;
+    struct HidIadDescriptor iad_0;
+} __attribute__((packed));
+
+/* HID report: FIDO U2F */
+static const uint8_t hid_u2f_report_desc[] = {
+    HID_RI_USAGE_PAGE(16, HID_PAGE_FIDO),
+    HID_USAGE(HID_FIDO_U2F),
+    HID_COLLECTION(HID_APPLICATION_COLLECTION),
+    HID_USAGE(HID_FIDO_INPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_USAGE(HID_FIDO_OUTPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_OUTPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_END_COLLECTION,
+};
+
+static const struct usb_string_descriptor dev_manuf_desc = USB_STRING_DESC("Flipper Devices Inc.");
+static const struct usb_string_descriptor dev_prod_desc = USB_STRING_DESC("U2F Token test");
+static const struct usb_string_descriptor dev_serial_desc = USB_STRING_DESC("TODO: serial");
+
+/* Device descriptor */
+static const struct usb_device_descriptor hid_u2f_device_desc = {
+    .bLength = sizeof(struct usb_device_descriptor),
+    .bDescriptorType = USB_DTYPE_DEVICE,
+    .bcdUSB = VERSION_BCD(2, 0, 0),
+    .bDeviceClass = USB_CLASS_IAD,
+    .bDeviceSubClass = USB_SUBCLASS_IAD,
+    .bDeviceProtocol = USB_PROTO_IAD,
+    .bMaxPacketSize0 = USB_EP0_SIZE,
+    .idVendor = 0x0483,
+    .idProduct = 0x5741,
+    .bcdDevice = VERSION_BCD(1, 0, 0),
+    .iManufacturer = UsbDevManuf,
+    .iProduct = UsbDevProduct,
+    .iSerialNumber = UsbDevSerial,
+    .bNumConfigurations = 1,
+};
+
+/* Device configuration descriptor */
+static const struct HidConfigDescriptor hid_u2f_cfg_desc = {
+    .config =
+        {
+            .bLength = sizeof(struct usb_config_descriptor),
+            .bDescriptorType = USB_DTYPE_CONFIGURATION,
+            .wTotalLength = sizeof(struct HidConfigDescriptor),
+            .bNumInterfaces = 1,
+            .bConfigurationValue = 1,
+            .iConfiguration = NO_DESCRIPTOR,
+            .bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
+            .bMaxPower = USB_CFG_POWER_MA(100),
+        },
+    .iad_0 =
+        {
+            .hid_iad =
+                {
+                    .bLength = sizeof(struct usb_iad_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFASEASSOC,
+                    .bFirstInterface = 0,
+                    .bInterfaceCount = 1,
+                    .bFunctionClass = USB_CLASS_PER_INTERFACE,
+                    .bFunctionSubClass = USB_SUBCLASS_NONE,
+                    .bFunctionProtocol = USB_PROTO_NONE,
+                    .iFunction = NO_DESCRIPTOR,
+                },
+            .hid =
+                {
+                    .bLength = sizeof(struct usb_interface_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFACE,
+                    .bInterfaceNumber = 0,
+                    .bAlternateSetting = 0,
+                    .bNumEndpoints = 2,
+                    .bInterfaceClass = USB_CLASS_HID,
+                    .bInterfaceSubClass = USB_HID_SUBCLASS_NONBOOT,
+                    .bInterfaceProtocol = USB_HID_PROTO_NONBOOT,
+                    .iInterface = NO_DESCRIPTOR,
+                },
+            .hid_desc =
+                {
+                    .bLength = sizeof(struct usb_hid_descriptor),
+                    .bDescriptorType = USB_DTYPE_HID,
+                    .bcdHID = VERSION_BCD(1, 0, 0),
+                    .bCountryCode = USB_HID_COUNTRY_NONE,
+                    .bNumDescriptors = 1,
+                    .bDescriptorType0 = USB_DTYPE_HID_REPORT,
+                    .wDescriptorLength0 = sizeof(hid_u2f_report_desc),
+                },
+            .hid_ep_in =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_IN,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+            .hid_ep_out =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_OUT,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+        },
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf);
+static void hid_u2f_deinit(usbd_device* dev);
+static void hid_u2f_on_wakeup(usbd_device* dev);
+static void hid_u2f_on_suspend(usbd_device* dev);
+
+//static bool hid_u2f_send_report(uint8_t report_id);
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg);
+static usbd_respond
+    hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
+static usbd_device* usb_dev;
+static osSemaphoreId_t hid_u2f_semaphore = NULL;
+static bool hid_u2f_connected = false;
+
+static HidU2fCallback callback;
+static void* cb_ctx;
+
+bool furi_hal_hid_u2f_is_connected() {
+    return hid_u2f_connected;
+}
+
+void furi_hal_hid_u2f_set_callback(HidU2fCallback cb, void* ctx) {
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+
+    callback = cb;
+    cb_ctx = ctx;
+
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fConnected, cb_ctx);
+    }
+}
+
+UsbInterface usb_hid_u2f = {
+    .init = hid_u2f_init,
+    .deinit = hid_u2f_deinit,
+    .wakeup = hid_u2f_on_wakeup,
+    .suspend = hid_u2f_on_suspend,
+
+    .dev_descr = (struct usb_device_descriptor*)&hid_u2f_device_desc,
+
+    .str_manuf_descr = (void*)&dev_manuf_desc,
+    .str_prod_descr = (void*)&dev_prod_desc,
+    .str_serial_descr = (void*)&dev_serial_desc,
+
+    .cfg_descr = (void*)&hid_u2f_cfg_desc,
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf) {
+    if(hid_u2f_semaphore == NULL) hid_u2f_semaphore = osSemaphoreNew(1, 1, NULL);
+    usb_dev = dev;
+
+    usbd_reg_config(dev, hid_u2f_ep_config);
+    usbd_reg_control(dev, hid_u2f_control);
+
+    usbd_connect(dev, true);
+}
+
+static void hid_u2f_deinit(usbd_device* dev) {
+    usbd_reg_config(dev, NULL);
+    usbd_reg_control(dev, NULL);
+}
+
+static void hid_u2f_on_wakeup(usbd_device* dev) {
+    hid_u2f_connected = true;
+    if (callback != NULL)
+        callback(HidU2fConnected, cb_ctx);
+}
+
+static void hid_u2f_on_suspend(usbd_device* dev) {
+    if(hid_u2f_connected == true) {
+        hid_u2f_connected = false;
+        osSemaphoreRelease(hid_u2f_semaphore);
+        if (callback != NULL)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+}
+
+void furi_hal_hid_u2f_send_response(uint8_t* data, uint8_t len) {
+    if ((hid_u2f_semaphore == NULL) || (hid_u2f_connected == false))
+        return;
+    furi_check(osSemaphoreAcquire(hid_u2f_semaphore, osWaitForever) == osOK);
+    if (hid_u2f_connected == true) {
+        usbd_ep_write(usb_dev, HID_EP_OUT, data, len);
+    }
+}
+
+uint32_t furi_hal_hid_u2f_get_request(uint8_t* data) {
+    int32_t len = usbd_ep_read(usb_dev, HID_EP_IN, data, HID_U2F_PACKET_LEN);
+    return ((len < 0) ? 0 : len);
+}
+
+static void hid_u2f_rx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (callback != NULL)
+        callback(HidU2fRequest, cb_ctx);
+}
+
+static void hid_u2f_tx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    osSemaphoreRelease(hid_u2f_semaphore);
+}
+
+static void hid_u2f_txrx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (event == usbd_evt_eptx) {
+        hid_u2f_tx_ep_callback(dev, event, ep);
+    } else {
+        hid_u2f_rx_ep_callback(dev, event, ep);
+    }
+}
+
+/* Configure endpoints */
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg) {
+    switch(cfg) {
+    case 0:
+        /* deconfiguring device */
+        usbd_ep_deconfig(dev, HID_EP_IN);
+        usbd_ep_deconfig(dev, HID_EP_OUT);
+        usbd_reg_endpoint(dev, HID_EP_IN, 0);
+        usbd_reg_endpoint(dev, HID_EP_OUT, 0);
+        return usbd_ack;
+    case 1:
+        /* configuring device */
+        usbd_ep_config(dev, HID_EP_IN, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_ep_config(dev, HID_EP_OUT, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_reg_endpoint(dev, HID_EP_IN, hid_u2f_txrx_ep_callback);
+        usbd_reg_endpoint(dev, HID_EP_OUT, hid_u2f_txrx_ep_callback);
+        usbd_ep_write(dev, HID_U2F_PACKET_LEN, 0, 0);
+        return usbd_ack;
+    default:
+        return usbd_fail;
+    }
+}
+
+/* Control requests handler */
+static usbd_respond hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
+    /* HID control requests */
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_CLASS) &&
+       req->wIndex == 0) {
+        switch(req->bRequest) {
+        case USB_HID_SETIDLE:
+            return usbd_ack;
+        case USB_HID_GETREPORT:
+            // dev->status.data_ptr = &hid_u2f_report;
+            // dev->status.data_count = sizeof(hid_u2f_report);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_STANDARD) &&
+       req->wIndex == 0 && req->bRequest == USB_STD_GET_DESCRIPTOR) {
+        switch(req->wValue >> 8) {
+        case USB_DTYPE_HID:
+            dev->status.data_ptr = (uint8_t*)&(hid_u2f_cfg_desc.iad_0.hid_desc);
+            dev->status.data_count = sizeof(hid_u2f_cfg_desc.iad_0.hid_desc);
+            return usbd_ack;
+        case USB_DTYPE_HID_REPORT:
+            dev->status.data_ptr = (uint8_t*)hid_u2f_report_desc;
+            dev->status.data_count = sizeof(hid_u2f_report_desc);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    return usbd_fail;
+}
diff --git a/firmware/targets/f6/target.mk b/firmware/targets/f6/target.mk
index 3b9ada6c..e60e375e 100644
--- a/firmware/targets/f6/target.mk
+++ b/firmware/targets/f6/target.mk
@@ -71,7 +71,8 @@ C_SOURCES += \
 	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_tim.c \
 	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_usart.c \
 	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_lpuart.c \
-	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_utils.c
+	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_utils.c \
+	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_rng.c
 
 # FreeRTOS
 CFLAGS += \
diff --git a/firmware/targets/f7/furi-hal/furi-hal-crypto.c b/firmware/targets/f7/furi-hal/furi-hal-crypto.c
index 91875d23..f5398421 100644
--- a/firmware/targets/f7/furi-hal/furi-hal-crypto.c
+++ b/firmware/targets/f7/furi-hal/furi-hal-crypto.c
@@ -1,5 +1,6 @@
 #include <furi-hal-crypto.h>
 #include <furi-hal-bt.h>
+#include <furi-hal-random.h>
 #include <furi.h>
 #include <shci.h>
 
@@ -7,10 +8,119 @@
 
 CRYP_HandleTypeDef crypt;
 
+#define ENCLAVE_FACTORY_KEY_SLOTS 10
+#define ENCLAVE_SIGNATURE_SIZE 16
+
+static const uint8_t enclave_signature_iv[ENCLAVE_FACTORY_KEY_SLOTS][16] = {
+    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
+    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
+    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
+    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
+    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
+    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
+    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
+    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
+    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
+    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
+};
+
+static const uint8_t enclave_signature_input[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
+    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
+    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
+    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
+    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
+    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
+    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
+    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
+    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
+    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
+};
+
+static const uint8_t enclave_signature_expected[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
+    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
+    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
+    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
+    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
+    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
+    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
+    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
+    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
+    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
+};
+
 void furi_hal_crypto_init() {
     FURI_LOG_I(TAG, "Init OK");
 }
 
+static bool furi_hal_crypto_generate_unique_keys(uint8_t start_slot, uint8_t end_slot) {
+    FuriHalCryptoKey key;
+    uint8_t key_data[32];
+    FURI_LOG_I(TAG, "Generating keys %u..%u", start_slot, end_slot);
+    for (uint8_t slot = start_slot; slot <= end_slot; slot++) {
+        key.type = FuriHalCryptoKeyTypeSimple;
+        key.size = FuriHalCryptoKeySize256;
+        key.data = key_data;
+        furi_hal_random_fill_buf(key_data, 32);
+        if (!furi_hal_crypto_store_add_key(&key, &slot)) {
+            FURI_LOG_E(TAG, "Error writing key to slot %u", slot);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_key(uint8_t key_slot) {
+    uint8_t keys_nb = 0;
+    uint8_t valid_keys_nb = 0;
+    uint8_t last_valid_slot = ENCLAVE_FACTORY_KEY_SLOTS;
+    uint8_t empty_iv[16];
+    furi_hal_crypto_verify_enclave(&keys_nb, &valid_keys_nb);
+    if (key_slot <= ENCLAVE_FACTORY_KEY_SLOTS) { // It's a factory key
+        if (key_slot > keys_nb)
+            return false;
+    } else { // Unique key
+        if (keys_nb < ENCLAVE_FACTORY_KEY_SLOTS) // Some factory keys are missing
+            return false;
+        for (uint8_t i = key_slot; i > ENCLAVE_FACTORY_KEY_SLOTS; i--) {
+            if(furi_hal_crypto_store_load_key(i, empty_iv)) {
+                last_valid_slot = i;
+                furi_hal_crypto_store_unload_key(i);
+                break;
+            }
+        }
+        if (last_valid_slot == key_slot)
+            return true;
+        else // Generate missing unique keys
+            return furi_hal_crypto_generate_unique_keys(last_valid_slot+1, key_slot);
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_enclave(uint8_t* keys_nb, uint8_t* valid_keys_nb) {
+    furi_assert(keys_nb);
+    furi_assert(valid_keys_nb);
+    uint8_t keys = 0;
+    uint8_t keys_valid = 0;
+    uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
+    for(size_t key_slot = 0; key_slot < ENCLAVE_FACTORY_KEY_SLOTS; key_slot++) {
+        if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
+            keys++;
+            if(furi_hal_crypto_encrypt(enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
+                keys_valid += memcmp(buffer, enclave_signature_expected[key_slot], ENCLAVE_SIGNATURE_SIZE) == 0;
+            }
+            furi_hal_crypto_store_unload_key(key_slot + 1);
+        }
+    }
+    *keys_nb = keys;
+    *valid_keys_nb = keys_valid;
+    if (*valid_keys_nb == ENCLAVE_FACTORY_KEY_SLOTS)
+        return true;
+    else
+        return false;
+}
+
 bool furi_hal_crypto_store_add_key(FuriHalCryptoKey* key, uint8_t* slot) {
     furi_assert(key);
     furi_assert(slot);
diff --git a/firmware/targets/f7/furi-hal/furi-hal-info.c b/firmware/targets/f7/furi-hal/furi-hal-info.c
index 783a5113..c1225ac9 100644
--- a/firmware/targets/f7/furi-hal/furi-hal-info.c
+++ b/firmware/targets/f7/furi-hal/furi-hal-info.c
@@ -2,48 +2,6 @@
 #include <furi-hal.h>
 #include <shci.h>
 
-#define ENCLAVE_SIGNATURE_KEY_SLOTS 10
-#define ENCLAVE_SIGNATURE_SIZE 16
-
-static const uint8_t enclave_signature_iv[ENCLAVE_SIGNATURE_KEY_SLOTS][16] = {
-    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
-    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
-    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
-    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
-    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
-    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
-    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
-    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
-    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
-    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
-};
-
-static const uint8_t enclave_signature_input[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
-    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
-    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
-    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
-    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
-    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
-    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
-    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
-    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
-    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
-};
-
-static const uint8_t enclave_signature_expected[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
-    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
-    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
-    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
-    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
-    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
-    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
-    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
-    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
-    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
-};
-
 void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
     string_t value;
     string_init(value);
@@ -164,23 +122,12 @@ void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
         out("radio_ble_mac", string_get_cstr(value), false, context);
 
         // Signature verification
-        uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
-        size_t enclave_valid_keys = 0;
-        for(size_t key_slot = 0; key_slot < ENCLAVE_SIGNATURE_KEY_SLOTS; key_slot++) {
-            if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
-                if(furi_hal_crypto_encrypt(
-                       enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
-                    enclave_valid_keys += memcmp(
-                                              buffer,
-                                              enclave_signature_expected[key_slot],
-                                              ENCLAVE_SIGNATURE_SIZE) == 0;
-                }
-                furi_hal_crypto_store_unload_key(key_slot + 1);
-            }
-        }
+        uint8_t enclave_keys = 0;
+        uint8_t enclave_valid_keys = 0;
+        bool enclave_valid = furi_hal_crypto_verify_enclave(&enclave_keys, &enclave_valid_keys);
         string_printf(value, "%d", enclave_valid_keys);
         out("enclave_valid_keys", string_get_cstr(value), false, context);
-        out("enclave_valid", (enclave_valid_keys == ENCLAVE_SIGNATURE_KEY_SLOTS) ? "true" : "false", true, context);
+        out("enclave_valid", enclave_valid ? "true" : "false", true, context);
     } else {
         out("radio_alive", "false", true, context);
     }
diff --git a/firmware/targets/f7/furi-hal/furi-hal-random.c b/firmware/targets/f7/furi-hal/furi-hal-random.c
new file mode 100644
index 00000000..a7bc3a31
--- /dev/null
+++ b/firmware/targets/f7/furi-hal/furi-hal-random.c
@@ -0,0 +1,56 @@
+#include "furi-hal-random.h"
+#include <furi.h>
+#include <furi-hal.h>
+
+#include <stm32wbxx_ll_rng.h>
+#include <stm32wbxx_ll_hsem.h>
+
+#include <hw_conf.h>
+
+uint32_t furi_hal_random_get() {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+    if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+        furi_crash("TRNG error");
+    }
+
+    uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+
+    return random_val;
+}
+
+void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len) {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    for (uint32_t i = 0; i < len; i+= 4) {
+        while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+        if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+            furi_crash("TRNG error");
+        }
+
+        uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+        uint8_t len_cur = ((i+4) < len) ? (4) : (len-i);
+        memcpy(&buf[i], &random_val, len_cur);
+    }
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+}
+
+void srand(unsigned seed) {
+}
+
+int rand() {
+    return (furi_hal_random_get() & RAND_MAX);
+}
diff --git a/firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c b/firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c
new file mode 100644
index 00000000..a7426c82
--- /dev/null
+++ b/firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c
@@ -0,0 +1,309 @@
+#include "furi-hal-version.h"
+#include "furi-hal-usb_i.h"
+#include "furi-hal-usb-hid-u2f.h"
+#include "furi-hal-usb.h"
+#include <furi.h>
+#include "usb.h"
+#include "usb_hid.h"
+
+#define HID_PAGE_FIDO 0xF1D0
+#define HID_FIDO_U2F 0x01
+#define HID_FIDO_INPUT 0x20
+#define HID_FIDO_OUTPUT 0x21
+
+#define HID_EP_IN 0x81
+#define HID_EP_OUT 0x01
+
+struct HidIadDescriptor {
+    struct usb_iad_descriptor hid_iad;
+    struct usb_interface_descriptor hid;
+    struct usb_hid_descriptor hid_desc;
+    struct usb_endpoint_descriptor hid_ep_in;
+    struct usb_endpoint_descriptor hid_ep_out;
+};
+
+struct HidConfigDescriptor {
+    struct usb_config_descriptor config;
+    struct HidIadDescriptor iad_0;
+} __attribute__((packed));
+
+/* HID report: FIDO U2F */
+static const uint8_t hid_u2f_report_desc[] = {
+    HID_RI_USAGE_PAGE(16, HID_PAGE_FIDO),
+    HID_USAGE(HID_FIDO_U2F),
+    HID_COLLECTION(HID_APPLICATION_COLLECTION),
+    HID_USAGE(HID_FIDO_INPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_USAGE(HID_FIDO_OUTPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_OUTPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_END_COLLECTION,
+};
+
+static const struct usb_string_descriptor dev_manuf_desc = USB_STRING_DESC("Flipper Devices Inc.");
+static const struct usb_string_descriptor dev_prod_desc = USB_STRING_DESC("U2F Token test");
+static const struct usb_string_descriptor dev_serial_desc = USB_STRING_DESC("TODO: serial");
+
+/* Device descriptor */
+static const struct usb_device_descriptor hid_u2f_device_desc = {
+    .bLength = sizeof(struct usb_device_descriptor),
+    .bDescriptorType = USB_DTYPE_DEVICE,
+    .bcdUSB = VERSION_BCD(2, 0, 0),
+    .bDeviceClass = USB_CLASS_IAD,
+    .bDeviceSubClass = USB_SUBCLASS_IAD,
+    .bDeviceProtocol = USB_PROTO_IAD,
+    .bMaxPacketSize0 = USB_EP0_SIZE,
+    .idVendor = 0x0483,
+    .idProduct = 0x5741,
+    .bcdDevice = VERSION_BCD(1, 0, 0),
+    .iManufacturer = UsbDevManuf,
+    .iProduct = UsbDevProduct,
+    .iSerialNumber = UsbDevSerial,
+    .bNumConfigurations = 1,
+};
+
+/* Device configuration descriptor */
+static const struct HidConfigDescriptor hid_u2f_cfg_desc = {
+    .config =
+        {
+            .bLength = sizeof(struct usb_config_descriptor),
+            .bDescriptorType = USB_DTYPE_CONFIGURATION,
+            .wTotalLength = sizeof(struct HidConfigDescriptor),
+            .bNumInterfaces = 1,
+            .bConfigurationValue = 1,
+            .iConfiguration = NO_DESCRIPTOR,
+            .bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
+            .bMaxPower = USB_CFG_POWER_MA(100),
+        },
+    .iad_0 =
+        {
+            .hid_iad =
+                {
+                    .bLength = sizeof(struct usb_iad_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFASEASSOC,
+                    .bFirstInterface = 0,
+                    .bInterfaceCount = 1,
+                    .bFunctionClass = USB_CLASS_PER_INTERFACE,
+                    .bFunctionSubClass = USB_SUBCLASS_NONE,
+                    .bFunctionProtocol = USB_PROTO_NONE,
+                    .iFunction = NO_DESCRIPTOR,
+                },
+            .hid =
+                {
+                    .bLength = sizeof(struct usb_interface_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFACE,
+                    .bInterfaceNumber = 0,
+                    .bAlternateSetting = 0,
+                    .bNumEndpoints = 2,
+                    .bInterfaceClass = USB_CLASS_HID,
+                    .bInterfaceSubClass = USB_HID_SUBCLASS_NONBOOT,
+                    .bInterfaceProtocol = USB_HID_PROTO_NONBOOT,
+                    .iInterface = NO_DESCRIPTOR,
+                },
+            .hid_desc =
+                {
+                    .bLength = sizeof(struct usb_hid_descriptor),
+                    .bDescriptorType = USB_DTYPE_HID,
+                    .bcdHID = VERSION_BCD(1, 0, 0),
+                    .bCountryCode = USB_HID_COUNTRY_NONE,
+                    .bNumDescriptors = 1,
+                    .bDescriptorType0 = USB_DTYPE_HID_REPORT,
+                    .wDescriptorLength0 = sizeof(hid_u2f_report_desc),
+                },
+            .hid_ep_in =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_IN,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+            .hid_ep_out =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_OUT,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+        },
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf);
+static void hid_u2f_deinit(usbd_device* dev);
+static void hid_u2f_on_wakeup(usbd_device* dev);
+static void hid_u2f_on_suspend(usbd_device* dev);
+
+//static bool hid_u2f_send_report(uint8_t report_id);
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg);
+static usbd_respond
+    hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
+static usbd_device* usb_dev;
+static osSemaphoreId_t hid_u2f_semaphore = NULL;
+static bool hid_u2f_connected = false;
+
+static HidU2fCallback callback;
+static void* cb_ctx;
+
+bool furi_hal_hid_u2f_is_connected() {
+    return hid_u2f_connected;
+}
+
+void furi_hal_hid_u2f_set_callback(HidU2fCallback cb, void* ctx) {
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+
+    callback = cb;
+    cb_ctx = ctx;
+
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fConnected, cb_ctx);
+    }
+}
+
+UsbInterface usb_hid_u2f = {
+    .init = hid_u2f_init,
+    .deinit = hid_u2f_deinit,
+    .wakeup = hid_u2f_on_wakeup,
+    .suspend = hid_u2f_on_suspend,
+
+    .dev_descr = (struct usb_device_descriptor*)&hid_u2f_device_desc,
+
+    .str_manuf_descr = (void*)&dev_manuf_desc,
+    .str_prod_descr = (void*)&dev_prod_desc,
+    .str_serial_descr = (void*)&dev_serial_desc,
+
+    .cfg_descr = (void*)&hid_u2f_cfg_desc,
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf) {
+    if(hid_u2f_semaphore == NULL) hid_u2f_semaphore = osSemaphoreNew(1, 1, NULL);
+    usb_dev = dev;
+
+    usbd_reg_config(dev, hid_u2f_ep_config);
+    usbd_reg_control(dev, hid_u2f_control);
+
+    usbd_connect(dev, true);
+}
+
+static void hid_u2f_deinit(usbd_device* dev) {
+    usbd_reg_config(dev, NULL);
+    usbd_reg_control(dev, NULL);
+}
+
+static void hid_u2f_on_wakeup(usbd_device* dev) {
+    hid_u2f_connected = true;
+    if (callback != NULL)
+        callback(HidU2fConnected, cb_ctx);
+}
+
+static void hid_u2f_on_suspend(usbd_device* dev) {
+    if(hid_u2f_connected == true) {
+        hid_u2f_connected = false;
+        osSemaphoreRelease(hid_u2f_semaphore);
+        if (callback != NULL)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+}
+
+void furi_hal_hid_u2f_send_response(uint8_t* data, uint8_t len) {
+    if ((hid_u2f_semaphore == NULL) || (hid_u2f_connected == false))
+        return;
+    furi_check(osSemaphoreAcquire(hid_u2f_semaphore, osWaitForever) == osOK);
+    if (hid_u2f_connected == true) {
+        usbd_ep_write(usb_dev, HID_EP_OUT, data, len);
+    }
+}
+
+uint32_t furi_hal_hid_u2f_get_request(uint8_t* data) {
+    int32_t len = usbd_ep_read(usb_dev, HID_EP_IN, data, HID_U2F_PACKET_LEN);
+    return ((len < 0) ? 0 : len);
+}
+
+static void hid_u2f_rx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (callback != NULL)
+        callback(HidU2fRequest, cb_ctx);
+}
+
+static void hid_u2f_tx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    osSemaphoreRelease(hid_u2f_semaphore);
+}
+
+static void hid_u2f_txrx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (event == usbd_evt_eptx) {
+        hid_u2f_tx_ep_callback(dev, event, ep);
+    } else {
+        hid_u2f_rx_ep_callback(dev, event, ep);
+    }
+}
+
+/* Configure endpoints */
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg) {
+    switch(cfg) {
+    case 0:
+        /* deconfiguring device */
+        usbd_ep_deconfig(dev, HID_EP_IN);
+        usbd_ep_deconfig(dev, HID_EP_OUT);
+        usbd_reg_endpoint(dev, HID_EP_IN, 0);
+        usbd_reg_endpoint(dev, HID_EP_OUT, 0);
+        return usbd_ack;
+    case 1:
+        /* configuring device */
+        usbd_ep_config(dev, HID_EP_IN, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_ep_config(dev, HID_EP_OUT, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_reg_endpoint(dev, HID_EP_IN, hid_u2f_txrx_ep_callback);
+        usbd_reg_endpoint(dev, HID_EP_OUT, hid_u2f_txrx_ep_callback);
+        usbd_ep_write(dev, HID_U2F_PACKET_LEN, 0, 0);
+        return usbd_ack;
+    default:
+        return usbd_fail;
+    }
+}
+
+/* Control requests handler */
+static usbd_respond hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
+    /* HID control requests */
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_CLASS) &&
+       req->wIndex == 0) {
+        switch(req->bRequest) {
+        case USB_HID_SETIDLE:
+            return usbd_ack;
+        case USB_HID_GETREPORT:
+            // dev->status.data_ptr = &hid_u2f_report;
+            // dev->status.data_count = sizeof(hid_u2f_report);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_STANDARD) &&
+       req->wIndex == 0 && req->bRequest == USB_STD_GET_DESCRIPTOR) {
+        switch(req->wValue >> 8) {
+        case USB_DTYPE_HID:
+            dev->status.data_ptr = (uint8_t*)&(hid_u2f_cfg_desc.iad_0.hid_desc);
+            dev->status.data_count = sizeof(hid_u2f_cfg_desc.iad_0.hid_desc);
+            return usbd_ack;
+        case USB_DTYPE_HID_REPORT:
+            dev->status.data_ptr = (uint8_t*)hid_u2f_report_desc;
+            dev->status.data_count = sizeof(hid_u2f_report_desc);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    return usbd_fail;
+}
diff --git a/firmware/targets/furi-hal-include/furi-hal-crypto.h b/firmware/targets/furi-hal-include/furi-hal-crypto.h
index 482b3d7a..3aba2ede 100644
--- a/firmware/targets/furi-hal-include/furi-hal-crypto.h
+++ b/firmware/targets/furi-hal-include/furi-hal-crypto.h
@@ -32,6 +32,10 @@ typedef struct {
  */
 void furi_hal_crypto_init();
 
+bool furi_hal_crypto_verify_enclave(uint8_t* keys_nb, uint8_t* valid_keys_nb);
+
+bool furi_hal_crypto_verify_key(uint8_t key_slot);
+
 /** Store key in crypto storage
  *
  * @param      key   FuriHalCryptoKey to store. Only Master, Simple or
diff --git a/firmware/targets/furi-hal-include/furi-hal-random.h b/firmware/targets/furi-hal-include/furi-hal-random.h
new file mode 100644
index 00000000..fa549d23
--- /dev/null
+++ b/firmware/targets/furi-hal-include/furi-hal-random.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Get random value
+ *
+ * @return     random value
+ */
+uint32_t furi_hal_random_get();
+
+/** Fill buffer with random data
+ *
+ * @param      buf  buffer pointer
+ * @param      data buffer len
+ */
+void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/firmware/targets/furi-hal-include/furi-hal-usb-hid-u2f.h b/firmware/targets/furi-hal-include/furi-hal-usb-hid-u2f.h
new file mode 100644
index 00000000..e9bf5765
--- /dev/null
+++ b/firmware/targets/furi-hal-include/furi-hal-usb-hid-u2f.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#define HID_U2F_PACKET_LEN 64
+
+typedef enum {
+    HidU2fDisconnected,
+    HidU2fConnected,
+    HidU2fRequest,
+} HidU2fEvent;
+
+typedef void (*HidU2fCallback)(HidU2fEvent ev, void* context);
+
+/** Get HID U2F connection state
+ *
+ * @return      true / false
+ */
+bool furi_hal_hid_u2f_is_connected();
+
+/** Set HID U2F event callback
+ *
+ * @param      cb  callback
+ * @param      ctx  callback context
+ */
+void furi_hal_hid_u2f_set_callback(HidU2fCallback cb, void* ctx);
+
+/** Get received U2F HID packet
+ *
+ */
+uint32_t furi_hal_hid_u2f_get_request(uint8_t* data);
+
+/** Send U2F HID response packet
+ *
+ * @param      data  response data
+ * @param      len  packet length
+ */
+void furi_hal_hid_u2f_send_response(uint8_t* data, uint8_t len);
diff --git a/firmware/targets/furi-hal-include/furi-hal-usb.h b/firmware/targets/furi-hal-include/furi-hal-usb.h
index b11ddcf1..a384236b 100644
--- a/firmware/targets/furi-hal-include/furi-hal-usb.h
+++ b/firmware/targets/furi-hal-include/furi-hal-usb.h
@@ -23,6 +23,7 @@ struct UsbInterface {
 extern UsbInterface usb_cdc_single;
 extern UsbInterface usb_cdc_dual;
 extern UsbInterface usb_hid;
+extern UsbInterface usb_hid_u2f;
 
 /** USB device low-level initialization
  */
diff --git a/firmware/targets/furi-hal-include/furi-hal.h b/firmware/targets/furi-hal-include/furi-hal.h
index f7613625..e0885598 100644
--- a/firmware/targets/furi-hal-include/furi-hal.h
+++ b/firmware/targets/furi-hal-include/furi-hal.h
@@ -40,6 +40,7 @@ template <unsigned int N> struct STOP_EXTERNING_ME {};
 #include "furi-hal-compress.h"
 #include "furi-hal-uart.h"
 #include "furi-hal-info.h"
+#include "furi-hal-random.h"
 
 /** Init furi-hal */
 void furi_hal_init();