NfcDict Refactoring (#3271)

* toolbox(keys_dict): generalize nfc_dict * nfc: rework nfc app and tests * toolbox(keys_dict): improve code readability
flipperdevices · Dec 18, 2023 · 7642d67 · 7642d67
1 parent 8c4716f
commit 7642d67
Show file tree

Hide file tree

Showing 14 changed files with 524 additions and 448 deletions.
diff --git a/applications/debug/unit_tests/nfc/nfc_test.c b/applications/debug/unit_tests/nfc/nfc_test.c
@@ -12,7 +12,7 @@
 #include <nfc/protocols/mf_ultralight/mf_ultralight_poller_sync.h>
 #include <nfc/protocols/mf_classic/mf_classic_poller_sync.h>
 
-#include <nfc/helpers/nfc_dict.h>
+#include <toolbox/keys_dict.h>
 #include <nfc/nfc.h>
 
 #include "../minunit.h"
@@ -443,36 +443,36 @@ MU_TEST(mf_classic_dict_test) {
             "Remove test dict failed");
     }
 
-    NfcDict* dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_UNIT_TEST_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
-    mu_assert(dict != NULL, "nfc_dict_alloc() failed");
+    KeysDict* dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_UNIT_TEST_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
+    mu_assert(dict != NULL, "keys_dict_alloc() failed");
 
-    size_t dict_keys_total = nfc_dict_get_total_keys(dict);
-    mu_assert(dict_keys_total == 0, "nfc_dict_keys_total() failed");
+    size_t dict_keys_total = keys_dict_get_total_keys(dict);
+    mu_assert(dict_keys_total == 0, "keys_dict_keys_total() failed");
 
     const uint32_t test_key_num = 30;
     MfClassicKey* key_arr_ref = malloc(test_key_num * sizeof(MfClassicKey));
     for(size_t i = 0; i < test_key_num; i++) {
         furi_hal_random_fill_buf(key_arr_ref[i].data, sizeof(MfClassicKey));
         mu_assert(
-            nfc_dict_add_key(dict, key_arr_ref[i].data, sizeof(MfClassicKey)), "add key failed");
+            keys_dict_add_key(dict, key_arr_ref[i].data, sizeof(MfClassicKey)), "add key failed");
 
-        size_t dict_keys_total = nfc_dict_get_total_keys(dict);
-        mu_assert(dict_keys_total == (i + 1), "nfc_dict_keys_total() failed");
+        size_t dict_keys_total = keys_dict_get_total_keys(dict);
+        mu_assert(dict_keys_total == (i + 1), "keys_dict_keys_total() failed");
     }
 
-    nfc_dict_free(dict);
+    keys_dict_free(dict);
 
-    dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_UNIT_TEST_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
-    mu_assert(dict != NULL, "nfc_dict_alloc() failed");
+    dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_UNIT_TEST_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
+    mu_assert(dict != NULL, "keys_dict_alloc() failed");
 
-    dict_keys_total = nfc_dict_get_total_keys(dict);
-    mu_assert(dict_keys_total == test_key_num, "nfc_dict_keys_total() failed");
+    dict_keys_total = keys_dict_get_total_keys(dict);
+    mu_assert(dict_keys_total == test_key_num, "keys_dict_keys_total() failed");
 
     MfClassicKey key_dut = {};
     size_t key_idx = 0;
-    while(nfc_dict_get_next_key(dict, key_dut.data, sizeof(MfClassicKey))) {
+    while(keys_dict_get_next_key(dict, key_dut.data, sizeof(MfClassicKey))) {
         mu_assert(
             memcmp(key_arr_ref[key_idx].data, key_dut.data, sizeof(MfClassicKey)) == 0,
             "Loaded key data mismatch");
@@ -484,19 +484,19 @@ MU_TEST(mf_classic_dict_test) {
     for(size_t i = 0; i < COUNT_OF(delete_keys_idx); i++) {
         MfClassicKey* key = &key_arr_ref[delete_keys_idx[i]];
         mu_assert(
-            nfc_dict_is_key_present(dict, key->data, sizeof(MfClassicKey)),
-            "nfc_dict_is_key_present() failed");
+            keys_dict_is_key_present(dict, key->data, sizeof(MfClassicKey)),
+            "keys_dict_is_key_present() failed");
         mu_assert(
-            nfc_dict_delete_key(dict, key->data, sizeof(MfClassicKey)),
-            "nfc_dict_delete_key() failed");
+            keys_dict_delete_key(dict, key->data, sizeof(MfClassicKey)),
+            "keys_dict_delete_key() failed");
     }
 
-    dict_keys_total = nfc_dict_get_total_keys(dict);
+    dict_keys_total = keys_dict_get_total_keys(dict);
     mu_assert(
         dict_keys_total == test_key_num - COUNT_OF(delete_keys_idx),
-        "nfc_dict_keys_total() failed");
+        "keys_dict_keys_total() failed");
 
-    nfc_dict_free(dict);
+    keys_dict_free(dict);
     free(key_arr_ref);
 
     mu_assert(

diff --git a/applications/main/nfc/helpers/mf_user_dict.c b/applications/main/nfc/helpers/mf_user_dict.c
@@ -1,6 +1,6 @@
 #include "mf_user_dict.h"
 
-#include <nfc/helpers/nfc_dict.h>
+#include <toolbox/keys_dict.h>
 #include <nfc/protocols/mf_classic/mf_classic.h>
 #include <furi/furi.h>
 
@@ -15,22 +15,22 @@ struct MfUserDict {
 MfUserDict* mf_user_dict_alloc(size_t max_keys_to_load) {
     MfUserDict* instance = malloc(sizeof(MfUserDict));
 
-    NfcDict* dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+    KeysDict* dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_USER_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
     furi_assert(dict);
 
-    size_t dict_keys_num = nfc_dict_get_total_keys(dict);
+    size_t dict_keys_num = keys_dict_get_total_keys(dict);
     instance->keys_num = MIN(max_keys_to_load, dict_keys_num);
 
     if(instance->keys_num > 0) {
         instance->keys_arr = malloc(instance->keys_num * sizeof(MfClassicKey));
         for(size_t i = 0; i < instance->keys_num; i++) {
             bool key_loaded =
-                nfc_dict_get_next_key(dict, instance->keys_arr[i].data, sizeof(MfClassicKey));
+                keys_dict_get_next_key(dict, instance->keys_arr[i].data, sizeof(MfClassicKey));
             furi_assert(key_loaded);
         }
     }
-    nfc_dict_free(dict);
+    keys_dict_free(dict);
 
     return instance;
 }
@@ -67,13 +67,13 @@ bool mf_user_dict_delete_key(MfUserDict* instance, uint32_t index) {
     furi_assert(index < instance->keys_num);
     furi_assert(instance->keys_arr);
 
-    NfcDict* dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+    KeysDict* dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_USER_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
     furi_assert(dict);
 
     bool key_delete_success =
-        nfc_dict_delete_key(dict, instance->keys_arr[index].data, sizeof(MfClassicKey));
-    nfc_dict_free(dict);
+        keys_dict_delete_key(dict, instance->keys_arr[index].data, sizeof(MfClassicKey));
+    keys_dict_free(dict);
 
     if(key_delete_success) {
         instance->keys_num--;

diff --git a/applications/main/nfc/nfc_app_i.h b/applications/main/nfc/nfc_app_i.h
@@ -52,7 +52,7 @@
 
 #include <nfc/nfc_device.h>
 #include <nfc/helpers/nfc_data_generator.h>
-#include <nfc/helpers/nfc_dict.h>
+#include <toolbox/keys_dict.h>
 
 #include <gui/modules/validators.h>
 #include <toolbox/path.h>
@@ -80,7 +80,7 @@ typedef enum {
 } NfcRpcState;
 
 typedef struct {
-    NfcDict* dict;
+    KeysDict* dict;
     uint8_t sectors_total;
     uint8_t sectors_read;
     uint8_t current_sector;

diff --git a/applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c b/applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c
@@ -41,7 +41,8 @@ NfcCommand nfc_dict_attack_worker_callback(NfcGenericEvent event, void* context)
             instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
     } else if(mfc_event->type == MfClassicPollerEventTypeRequestKey) {
         MfClassicKey key = {};
-        if(nfc_dict_get_next_key(instance->nfc_dict_context.dict, key.data, sizeof(MfClassicKey))) {
+        if(keys_dict_get_next_key(
+               instance->nfc_dict_context.dict, key.data, sizeof(MfClassicKey))) {
             mfc_event->data->key_request_data.key = key;
             mfc_event->data->key_request_data.key_provided = true;
             instance->nfc_dict_context.dict_keys_current++;
@@ -60,7 +61,7 @@ NfcCommand nfc_dict_attack_worker_callback(NfcGenericEvent event, void* context)
         view_dispatcher_send_custom_event(
             instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
     } else if(mfc_event->type == MfClassicPollerEventTypeNextSector) {
-        nfc_dict_rewind(instance->nfc_dict_context.dict);
+        keys_dict_rewind(instance->nfc_dict_context.dict);
         instance->nfc_dict_context.dict_keys_current = 0;
         instance->nfc_dict_context.current_sector =
             mfc_event->data->next_sector_data.current_sector;
@@ -79,7 +80,7 @@ NfcCommand nfc_dict_attack_worker_callback(NfcGenericEvent event, void* context)
         view_dispatcher_send_custom_event(
             instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
     } else if(mfc_event->type == MfClassicPollerEventTypeKeyAttackStop) {
-        nfc_dict_rewind(instance->nfc_dict_context.dict);
+        keys_dict_rewind(instance->nfc_dict_context.dict);
         instance->nfc_dict_context.is_key_attack = false;
         instance->nfc_dict_context.dict_keys_current = 0;
         view_dispatcher_send_custom_event(
@@ -124,15 +125,15 @@ static void nfc_scene_mf_classic_dict_attack_prepare_view(NfcApp* instance) {
         scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfClassicDictAttack);
     if(state == DictAttackStateUserDictInProgress) {
         do {
-            if(!nfc_dict_check_presence(NFC_APP_MF_CLASSIC_DICT_USER_PATH)) {
+            if(!keys_dict_check_presence(NFC_APP_MF_CLASSIC_DICT_USER_PATH)) {
                 state = DictAttackStateSystemDictInProgress;
                 break;
             }
 
-            instance->nfc_dict_context.dict = nfc_dict_alloc(
-                NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
-            if(nfc_dict_get_total_keys(instance->nfc_dict_context.dict) == 0) {
-                nfc_dict_free(instance->nfc_dict_context.dict);
+            instance->nfc_dict_context.dict = keys_dict_alloc(
+                NFC_APP_MF_CLASSIC_DICT_USER_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
+            if(keys_dict_get_total_keys(instance->nfc_dict_context.dict) == 0) {
+                keys_dict_free(instance->nfc_dict_context.dict);
                 state = DictAttackStateSystemDictInProgress;
                 break;
             }
@@ -141,13 +142,13 @@ static void nfc_scene_mf_classic_dict_attack_prepare_view(NfcApp* instance) {
         } while(false);
     }
     if(state == DictAttackStateSystemDictInProgress) {
-        instance->nfc_dict_context.dict = nfc_dict_alloc(
-            NFC_APP_MF_CLASSIC_DICT_SYSTEM_PATH, NfcDictModeOpenExisting, sizeof(MfClassicKey));
+        instance->nfc_dict_context.dict = keys_dict_alloc(
+            NFC_APP_MF_CLASSIC_DICT_SYSTEM_PATH, KeysDictModeOpenExisting, sizeof(MfClassicKey));
         dict_attack_set_header(instance->dict_attack, "MF Classic System Dictionary");
     }
 
     instance->nfc_dict_context.dict_keys_total =
-        nfc_dict_get_total_keys(instance->nfc_dict_context.dict);
+        keys_dict_get_total_keys(instance->nfc_dict_context.dict);
     dict_attack_set_total_dict_keys(
         instance->dict_attack, instance->nfc_dict_context.dict_keys_total);
     instance->nfc_dict_context.dict_keys_current = 0;
@@ -185,7 +186,7 @@ bool nfc_scene_mf_classic_dict_attack_on_event(void* context, SceneManagerEvent
             if(state == DictAttackStateUserDictInProgress) {
                 nfc_poller_stop(instance->poller);
                 nfc_poller_free(instance->poller);
-                nfc_dict_free(instance->nfc_dict_context.dict);
+                keys_dict_free(instance->nfc_dict_context.dict);
                 scene_manager_set_scene_state(
                     instance->scene_manager,
                     NfcSceneMfClassicDictAttack,
@@ -215,7 +216,7 @@ bool nfc_scene_mf_classic_dict_attack_on_event(void* context, SceneManagerEvent
                 if(instance->nfc_dict_context.is_card_present) {
                     nfc_poller_stop(instance->poller);
                     nfc_poller_free(instance->poller);
-                    nfc_dict_free(instance->nfc_dict_context.dict);
+                    keys_dict_free(instance->nfc_dict_context.dict);
                     scene_manager_set_scene_state(
                         instance->scene_manager,
                         NfcSceneMfClassicDictAttack,
@@ -253,7 +254,7 @@ void nfc_scene_mf_classic_dict_attack_on_exit(void* context) {
     scene_manager_set_scene_state(
         instance->scene_manager, NfcSceneMfClassicDictAttack, DictAttackStateUserDictInProgress);
 
-    nfc_dict_free(instance->nfc_dict_context.dict);
+    keys_dict_free(instance->nfc_dict_context.dict);
 
     instance->nfc_dict_context.current_sector = 0;
     instance->nfc_dict_context.sectors_total = 0;

diff --git a/applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c b/applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c
@@ -14,20 +14,20 @@ void nfc_scene_mf_classic_keys_on_enter(void* context) {
 
     // Load flipper dict keys total
     uint32_t flipper_dict_keys_total = 0;
-    NfcDict* dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_SYSTEM_PATH, NfcDictModeOpenExisting, sizeof(MfClassicKey));
+    KeysDict* dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_SYSTEM_PATH, KeysDictModeOpenExisting, sizeof(MfClassicKey));
     if(dict) {
-        flipper_dict_keys_total = nfc_dict_get_total_keys(dict);
-        nfc_dict_free(dict);
+        flipper_dict_keys_total = keys_dict_get_total_keys(dict);
+        keys_dict_free(dict);
     }
 
     // Load user dict keys total
     uint32_t user_dict_keys_total = 0;
-    dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+    dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_USER_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
     if(dict) {
-        user_dict_keys_total = nfc_dict_get_total_keys(dict);
-        nfc_dict_free(dict);
+        user_dict_keys_total = keys_dict_get_total_keys(dict);
+        keys_dict_free(dict);
     }
 
     FuriString* temp_str = furi_string_alloc();

diff --git a/applications/main/nfc/scenes/nfc_scene_mf_classic_keys_add.c b/applications/main/nfc/scenes/nfc_scene_mf_classic_keys_add.c
@@ -29,23 +29,23 @@ bool nfc_scene_mf_classic_keys_add_on_event(void* context, SceneManagerEvent eve
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventByteInputDone) {
             // Add key to dict
-            NfcDict* dict = nfc_dict_alloc(
-                NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+            KeysDict* dict = keys_dict_alloc(
+                NFC_APP_MF_CLASSIC_DICT_USER_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
             furi_assert(dict);
 
             MfClassicKey key = {};
             memcpy(key.data, instance->byte_input_store, sizeof(MfClassicKey));
-            if(nfc_dict_is_key_present(dict, key.data, sizeof(MfClassicKey))) {
+            if(keys_dict_is_key_present(dict, key.data, sizeof(MfClassicKey))) {
                 scene_manager_next_scene(
                     instance->scene_manager, NfcSceneMfClassicKeysWarnDuplicate);
-            } else if(nfc_dict_add_key(dict, key.data, sizeof(MfClassicKey))) {
+            } else if(keys_dict_add_key(dict, key.data, sizeof(MfClassicKey))) {
                 scene_manager_next_scene(instance->scene_manager, NfcSceneSaveSuccess);
                 dolphin_deed(DolphinDeedNfcMfcAdd);
             } else {
                 scene_manager_previous_scene(instance->scene_manager);
             }
 
-            nfc_dict_free(dict);
+            keys_dict_free(dict);
             consumed = true;
         }
     }

diff --git a/lib/nfc/SConscript b/lib/nfc/SConscript
@@ -48,7 +48,6 @@ env.Append(
         File("helpers/iso14443_crc.h"),
         File("helpers/iso13239_crc.h"),
         File("helpers/nfc_data_generator.h"),
-        File("helpers/nfc_dict.h"),
     ],
 )