From 9e62f08e4d6805e01a08f4def2bf4611d920046c Mon Sep 17 00:00:00 2001 From: Nikolay Minaylov Date: Wed, 22 Dec 2021 23:04:08 +0300 Subject: [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 --- firmware/targets/f6/furi-hal/furi-hal-crypto.c | 110 ++++++++ firmware/targets/f6/furi-hal/furi-hal-info.c | 61 +--- firmware/targets/f6/furi-hal/furi-hal-random.c | 56 ++++ firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c | 309 +++++++++++++++++++++ firmware/targets/f6/target.mk | 3 +- firmware/targets/f7/furi-hal/furi-hal-crypto.c | 110 ++++++++ firmware/targets/f7/furi-hal/furi-hal-info.c | 61 +--- firmware/targets/f7/furi-hal/furi-hal-random.c | 56 ++++ firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c | 309 +++++++++++++++++++++ .../targets/furi-hal-include/furi-hal-crypto.h | 4 + .../targets/furi-hal-include/furi-hal-random.h | 24 ++ .../furi-hal-include/furi-hal-usb-hid-u2f.h | 36 +++ firmware/targets/furi-hal-include/furi-hal-usb.h | 1 + firmware/targets/furi-hal-include/furi-hal.h | 1 + 14 files changed, 1026 insertions(+), 115 deletions(-) create mode 100644 firmware/targets/f6/furi-hal/furi-hal-random.c create mode 100644 firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c create mode 100644 firmware/targets/f7/furi-hal/furi-hal-random.c create mode 100644 firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c create mode 100644 firmware/targets/furi-hal-include/furi-hal-random.h create mode 100644 firmware/targets/furi-hal-include/furi-hal-usb-hid-u2f.h (limited to 'firmware') 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 #include +#include #include #include @@ -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 #include -#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 +#include + +#include +#include + +#include + +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 +#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 #include +#include #include #include @@ -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 #include -#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 +#include + +#include +#include + +#include + +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 +#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 + +#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 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(); -- cgit v1.2.3