Merge branch 'dev' into porta/3925-js-views-finale

Author: hedger

applications/debug/bt_debug_app/views/bt_test.c

@@ -18,7 +18,7 @@ struct BtTestParam {
     void* context;
 };
 
-ARRAY_DEF(BtTestParamArray, BtTestParam, M_POD_OPLIST);
+ARRAY_DEF(BtTestParamArray, BtTestParam, M_POD_OPLIST); //-V658
 
 struct BtTest {
     View* view;

applications/debug/unit_tests/tests/bt/bt_test.c

@@ -4,10 +4,23 @@
 
 #include <bt/bt_service/bt_keys_storage.h>
 #include <storage/storage.h>
+#include <toolbox/saved_struct.h>
 
 #define BT_TEST_KEY_STORAGE_FILE_PATH EXT_PATH("unit_tests/bt_test.keys")
+#define BT_TEST_MIGRATION_FILE_PATH   EXT_PATH("unit_tests/bt_migration_test.keys")
 #define BT_TEST_NVM_RAM_BUFF_SIZE     (507 * 4) // The same as in ble NVM storage
 
+// Identity root key
+static const uint8_t gap_legacy_irk[16] =
+    {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};
+// Encryption root key
+static const uint8_t gap_legacy_erk[16] =
+    {0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21, 0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21};
+
+// Test constants for migration (matching bt_keys_storage.c)
+#define BT_KEYS_STORAGE_MAGIC_TEST     (0x18)
+#define BT_KEYS_STORAGE_VERSION_1_TEST (1)
+
 typedef struct {
     Storage* storage;
     BtKeysStorage* bt_keys_storage;
@@ -88,6 +101,134 @@ static void bt_test_keys_remove_test_file(void) {
         "Can't remove test file");
 }
 
+// Helper function to create a version 0 file manually
+static bool
+    bt_test_create_v0_file(const char* file_path, const uint8_t* nvm_data, size_t nvm_size) {
+    // Version 0 files use saved_struct format with magic 0x18, version 0, containing only BLE pairing data
+    return saved_struct_save(
+        file_path,
+        nvm_data,
+        nvm_size,
+        BT_KEYS_STORAGE_MAGIC_TEST,
+        0); // Version 0
+}
+
+// Helper function to verify file format version
+static bool bt_test_verify_file_version(const char* file_path, uint32_t expected_version) {
+    uint8_t magic, version;
+    size_t size;
+
+    if(!saved_struct_get_metadata(file_path, &magic, &version, &size)) {
+        return false;
+    }
+
+    return (magic == BT_KEYS_STORAGE_MAGIC_TEST && version == expected_version);
+}
+
+// Test migration from version 0 to version 1, including root key preservation
+static void bt_test_migration_v0_to_v1(void) {
+    // Create test NVM data
+    const size_t test_nvm_size = 100;
+    uint8_t test_nvm_data[test_nvm_size];
+    for(size_t i = 0; i < test_nvm_size; i++) {
+        test_nvm_data[i] = (uint8_t)(i & 0xFF);
+    }
+
+    // Create a version 0 file
+    mu_assert(
+        bt_test_create_v0_file(BT_TEST_MIGRATION_FILE_PATH, test_nvm_data, test_nvm_size),
+        "Failed to create version 0 test file");
+
+    // Create BT keys storage and load the v0 file (should trigger migration)
+    BtKeysStorage* migration_storage = bt_keys_storage_alloc(BT_TEST_MIGRATION_FILE_PATH);
+    uint8_t loaded_buffer[BT_TEST_NVM_RAM_BUFF_SIZE];
+    memset(loaded_buffer, 0, sizeof(loaded_buffer));
+    bt_keys_storage_set_ram_params(migration_storage, loaded_buffer, sizeof(loaded_buffer));
+
+    // Load should succeed and migrate v0 to v1
+    mu_assert(bt_keys_storage_load(migration_storage), "Failed to load and migrate v0 file");
+
+    // Verify the file is now version 1
+    mu_assert(
+        bt_test_verify_file_version(BT_TEST_MIGRATION_FILE_PATH, BT_KEYS_STORAGE_VERSION_1_TEST),
+        "File was not migrated to version 1");
+
+    // Verify the NVM data was preserved during migration
+    mu_assert(
+        memcmp(test_nvm_data, loaded_buffer, test_nvm_size) == 0,
+        "NVM data was corrupted during migration");
+
+    // Verify that legacy root keys are used after migration
+    const GapRootSecurityKeys* migrated_keys = bt_keys_storage_get_root_keys(migration_storage);
+    mu_assert(
+        memcmp(migrated_keys->irk, gap_legacy_irk, sizeof(gap_legacy_irk)) == 0,
+        "IRK not set to legacy after migration");
+    mu_assert(
+        memcmp(migrated_keys->erk, gap_legacy_erk, sizeof(gap_legacy_erk)) == 0,
+        "ERK not set to legacy after migration");
+
+    bt_keys_storage_free(migration_storage);
+    storage_simply_remove(bt_test->storage, BT_TEST_MIGRATION_FILE_PATH);
+}
+
+// Test that migration preserves existing pairing data and root keys are not changed on reload
+static void bt_test_migration_preserves_pairings_and_keys(void) {
+    const size_t pairing_data_size = 200;
+    uint8_t pairing_data[pairing_data_size];
+    for(size_t i = 0; i < pairing_data_size; i++) {
+        pairing_data[i] = (uint8_t)((i * 7 + 42) & 0xFF);
+    }
+    mu_assert(
+        bt_test_create_v0_file(BT_TEST_MIGRATION_FILE_PATH, pairing_data, pairing_data_size),
+        "Failed to create v0 file with pairing data");
+
+    GapRootSecurityKeys keys_after_first_load;
+    for(int iteration = 0; iteration < 2; iteration++) {
+        BtKeysStorage* storage = bt_keys_storage_alloc(BT_TEST_MIGRATION_FILE_PATH);
+        uint8_t buffer[BT_TEST_NVM_RAM_BUFF_SIZE];
+        memset(buffer, 0, sizeof(buffer));
+        bt_keys_storage_set_ram_params(storage, buffer, sizeof(buffer));
+        mu_assert(bt_keys_storage_load(storage), "Failed to load on iteration");
+        mu_assert(
+            memcmp(pairing_data, buffer, pairing_data_size) == 0,
+            "Pairing data corrupted on iteration");
+        const GapRootSecurityKeys* keys = bt_keys_storage_get_root_keys(storage);
+        if(iteration == 0)
+            memcpy(&keys_after_first_load, keys, sizeof(GapRootSecurityKeys));
+        else
+            mu_assert(
+                memcmp(&keys_after_first_load, keys, sizeof(GapRootSecurityKeys)) == 0,
+                "Root keys changed after reload");
+        bt_keys_storage_free(storage);
+    }
+    storage_simply_remove(bt_test->storage, BT_TEST_MIGRATION_FILE_PATH);
+}
+
+// Test that delete operation generates new secure keys in v1 and does not match legacy
+static void bt_test_delete_generates_new_keys_and_not_legacy(void) {
+    BtKeysStorage* storage = bt_keys_storage_alloc(BT_TEST_MIGRATION_FILE_PATH);
+    uint8_t buffer[BT_TEST_NVM_RAM_BUFF_SIZE];
+    memset(buffer, 0x55, sizeof(buffer));
+    bt_keys_storage_set_ram_params(storage, buffer, sizeof(buffer));
+    mu_assert(bt_keys_storage_update(storage, buffer, 100), "Failed to create initial v1 file");
+    const GapRootSecurityKeys* original_keys = bt_keys_storage_get_root_keys(storage);
+    uint8_t original_keys_copy[sizeof(GapRootSecurityKeys)];
+    memcpy(original_keys_copy, original_keys, sizeof(original_keys_copy));
+    bt_keys_storage_delete(storage);
+    const GapRootSecurityKeys* new_keys = bt_keys_storage_get_root_keys(storage);
+    mu_assert(
+        memcmp(original_keys_copy, new_keys, sizeof(original_keys_copy)) != 0,
+        "Root keys were not regenerated after delete");
+    mu_assert(
+        memcmp(new_keys->irk, gap_legacy_irk, sizeof(gap_legacy_irk)) != 0,
+        "IRK after delete should not match legacy");
+    mu_assert(
+        memcmp(new_keys->erk, gap_legacy_erk, sizeof(gap_legacy_erk)) != 0,
+        "ERK after delete should not match legacy");
+    bt_keys_storage_free(storage);
+    storage_simply_remove(bt_test->storage, BT_TEST_MIGRATION_FILE_PATH);
+}
+
 MU_TEST(bt_test_keys_storage_serial_profile) {
     furi_check(bt_test);
 
@@ -96,10 +237,28 @@ MU_TEST(bt_test_keys_storage_serial_profile) {
     bt_test_keys_remove_test_file();
 }
 
+MU_TEST(bt_test_migration_v0_to_v1_test) {
+    furi_check(bt_test);
+    bt_test_migration_v0_to_v1();
+}
+
+MU_TEST(bt_test_migration_preserves_pairings_and_keys_test) {
+    furi_check(bt_test);
+    bt_test_migration_preserves_pairings_and_keys();
+}
+
+MU_TEST(bt_test_delete_generates_new_keys_and_not_legacy_test) {
+    furi_check(bt_test);
+    bt_test_delete_generates_new_keys_and_not_legacy();
+}
+
 MU_TEST_SUITE(test_bt) {
     bt_test_alloc();
 
     MU_RUN_TEST(bt_test_keys_storage_serial_profile);
+    MU_RUN_TEST(bt_test_migration_v0_to_v1_test);
+    MU_RUN_TEST(bt_test_migration_preserves_pairings_and_keys_test);
+    MU_RUN_TEST(bt_test_delete_generates_new_keys_and_not_legacy_test);
 
     bt_test_free();
 }

applications/main/infrared/infrared_brute_force.c

@@ -7,7 +7,7 @@
 
 #include "infrared_signal.h"
 
-ARRAY_DEF(SignalPositionArray, size_t, M_DEFAULT_OPLIST);
+ARRAY_DEF(SignalPositionArray, size_t, M_DEFAULT_OPLIST); //-V658
 
 typedef struct {
     size_t index;

applications/main/nfc/helpers/mfkey32_logger.c

@@ -21,7 +21,7 @@ typedef struct {
     uint32_t ar1;
 } Mfkey32LoggerParams;
 
-ARRAY_DEF(Mfkey32LoggerParams, Mfkey32LoggerParams, M_POD_OPLIST);
+ARRAY_DEF(Mfkey32LoggerParams, Mfkey32LoggerParams, M_POD_OPLIST); //-V658
 
 struct Mfkey32Logger {
     uint32_t cuid;

applications/main/nfc/helpers/nfc_supported_cards.c

@@ -29,7 +29,7 @@ typedef struct {
     NfcSupportedCardsPluginFeature feature;
 } NfcSupportedCardsPluginCache;
 
-ARRAY_DEF(NfcSupportedCardsPluginCache, NfcSupportedCardsPluginCache, M_POD_OPLIST);
+ARRAY_DEF(NfcSupportedCardsPluginCache, NfcSupportedCardsPluginCache, M_POD_OPLIST); //-V658
 
 typedef enum {
     NfcSupportedCardsLoadStateIdle,

applications/main/onewire/onewire_cli.c

@@ -25,7 +25,7 @@ static void onewire_cli_search(PipeSide* pipe) {
     onewire_host_start(onewire);
     power_enable_otg(power, true);
 
-    while(!done) {
+    while(!done) { //-V1044
         if(onewire_host_search(onewire, address, OneWireHostSearchModeNormal) != 1) {
             printf("Search finished\r\n");
             onewire_host_reset_search(onewire);

applications/main/subghz/helpers/subghz_frequency_analyzer_log_item_array.h

@@ -35,7 +35,7 @@ TUPLE_DEF2( //-V1048
         M_DEFAULT_OPLIST)
 
 /* Define the array, register the oplist and define further algorithms on it */
-ARRAY_DEF(SubGhzFrequencyAnalyzerLogItemArray, SubGhzFrequencyAnalyzerLogItem_t) //-V779
+ARRAY_DEF(SubGhzFrequencyAnalyzerLogItemArray, SubGhzFrequencyAnalyzerLogItem_t) //-V779 //-V658
 #define M_OPL_SubGhzFrequencyAnalyzerLogItemArray_t() \
     ARRAY_OPLIST(SubGhzFrequencyAnalyzerLogItemArray, M_OPL_SubGhzFrequencyAnalyzerLogItem_t())
 ALGO_DEF(SubGhzFrequencyAnalyzerLogItemArray, SubGhzFrequencyAnalyzerLogItemArray_t)

applications/main/subghz/subghz_history.c

@@ -16,7 +16,7 @@ typedef struct {
     SubGhzRadioPreset* preset;
 } SubGhzHistoryItem;
 
-ARRAY_DEF(SubGhzHistoryItemArray, SubGhzHistoryItem, M_POD_OPLIST)
+ARRAY_DEF(SubGhzHistoryItemArray, SubGhzHistoryItem, M_POD_OPLIST) //-V658
 
 #define M_OPL_SubGhzHistoryItemArray_t() ARRAY_OPLIST(SubGhzHistoryItemArray, M_POD_OPLIST)
 

applications/main/subghz/views/receiver.c

@@ -18,7 +18,7 @@ typedef struct {
     uint8_t type;
 } SubGhzReceiverMenuItem;
 
-ARRAY_DEF(SubGhzReceiverMenuItemArray, SubGhzReceiverMenuItem, M_POD_OPLIST)
+ARRAY_DEF(SubGhzReceiverMenuItemArray, SubGhzReceiverMenuItem, M_POD_OPLIST) //-V658
 
 #define M_OPL_SubGhzReceiverMenuItemArray_t() \
     ARRAY_OPLIST(SubGhzReceiverMenuItemArray, M_POD_OPLIST)

applications/services/bt/bt_service/bt.c

@@ -403,6 +403,7 @@ static void bt_change_profile(Bt* bt, BtMessage* message) {
         bt->current_profile = furi_hal_bt_change_app(
             message->data.profile.template,
             message->data.profile.params,
+            bt_keys_storage_get_root_keys(bt->keys_storage),
             bt_on_gap_event_callback,
             bt);
         if(bt->current_profile) {
@@ -458,16 +459,19 @@ static void bt_load_keys(Bt* bt) {
         bt_keys_storage_load(bt->keys_storage);
 
         bt->current_profile = NULL;
-
     } else {
         FURI_LOG_I(TAG, "Keys unchanged");
     }
 }
 
 static void bt_start_application(Bt* bt) {
     if(!bt->current_profile) {
-        bt->current_profile =
-            furi_hal_bt_change_app(ble_profile_serial, NULL, bt_on_gap_event_callback, bt);
+        bt->current_profile = furi_hal_bt_change_app(
+            ble_profile_serial,
+            NULL,
+            bt_keys_storage_get_root_keys(bt->keys_storage),
+            bt_on_gap_event_callback,
+            bt);
 
         if(!bt->current_profile) {
             FURI_LOG_E(TAG, "BLE App start failed");