Squashed 'mifare_fuzzer/' changes from ffdb210a8..ce7435fee

ce7435fee fix catalog versions
b585248c3 categories part 1
c9b3fcbca format
67d33e4a3 more manifestos, xbox controller and videopoker ufbt fixes
b179bf26e Add Screenshots
8cf25925c API 31 / unzip sources
REVERT: ffdb210a8 First commit
REVERT: fe5d6d30b Initial commit

git-subtree-dir: mifare_fuzzer
git-subtree-split: ce7435fee5c66cfee7a230fc38b901895181c3c3

application.fam

@@ -9,7 +9,11 @@ App(
     ],
     stack_size=4 * 1024,
     order=30,
-    fap_icon="./images/mifare_fuzzer_10px.png",
-    fap_category="Tools",
+    fap_icon="images/mifare_fuzzer_10px.png",
+    fap_category="NFC",
     fap_icon_assets="images",
+    fap_author="@spheeere98",
+    fap_weburl="https://github.com/spheeere98/mifare_fuzzer",
+    fap_version="1.1",
+    fap_description="App emulates Mifare Classic cards with various UIDs to check how reader reacts on them",
 )

mifare_fuzzer.c

@@ -1,9 +1,9 @@
 #include "mifare_fuzzer_i.h"
 
 /// @brief mifare_fuzzer_custom_event_callback()
-/// @param context 
-/// @param event 
-/// @return 
+/// @param context
+/// @param event
+/// @return
 static bool mifare_fuzzer_custom_event_callback(void* context, uint32_t event) {
     furi_assert(context);
     MifareFuzzerApp* app = context;
@@ -11,8 +11,8 @@ static bool mifare_fuzzer_custom_event_callback(void* context, uint32_t event) {
 }
 
 /// @brief mifare_fuzzer_back_event_callback()
-/// @param context 
-/// @return 
+/// @param context
+/// @return
 static bool mifare_fuzzer_back_event_callback(void* context) {
     furi_assert(context);
     MifareFuzzerApp* app = context;
@@ -20,15 +20,15 @@ static bool mifare_fuzzer_back_event_callback(void* context) {
 }
 
 /// @brief mifare_fuzzer_tick_event_callback()
-/// @param context 
-static void mifare_fuzzer_tick_event_callback(void* context){
+/// @param context
+static void mifare_fuzzer_tick_event_callback(void* context) {
     furi_assert(context);
     MifareFuzzerApp* app = context;
     scene_manager_handle_tick_event(app->scene_manager);
 }
 
 /// @brief mifare_fuzzer_alloc()
-/// @return 
+/// @return
 MifareFuzzerApp* mifare_fuzzer_alloc() {
     MifareFuzzerApp* app = malloc(sizeof(MifareFuzzerApp));
 
@@ -36,43 +36,35 @@ MifareFuzzerApp* mifare_fuzzer_alloc() {
     app->scene_manager = scene_manager_alloc(&mifare_fuzzer_scene_handlers, app);
     view_dispatcher_enable_queue(app->view_dispatcher);
     view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
-    view_dispatcher_set_custom_event_callback(app->view_dispatcher, mifare_fuzzer_custom_event_callback);
-    view_dispatcher_set_navigation_event_callback(app->view_dispatcher, mifare_fuzzer_back_event_callback);
+    view_dispatcher_set_custom_event_callback(
+        app->view_dispatcher, mifare_fuzzer_custom_event_callback);
+    view_dispatcher_set_navigation_event_callback(
+        app->view_dispatcher, mifare_fuzzer_back_event_callback);
 
     // 1000 ticks are about 1 sec
-    view_dispatcher_set_tick_event_callback(app->view_dispatcher, mifare_fuzzer_tick_event_callback, MIFARE_FUZZER_TICK_PERIOD);
+    view_dispatcher_set_tick_event_callback(
+        app->view_dispatcher, mifare_fuzzer_tick_event_callback, MIFARE_FUZZER_TICK_PERIOD);
 
     // Open GUI record
     app->gui = furi_record_open(RECORD_GUI);
-    view_dispatcher_attach_to_gui(
-        app->view_dispatcher,
-        app->gui,
-        ViewDispatcherTypeFullscreen
-    );
+    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
 
     // view: select card type
     app->submenu_card = submenu_alloc();
     view_dispatcher_add_view(
-        app->view_dispatcher,
-        MifareFuzzerViewSelectCard,
-        submenu_get_view(app->submenu_card)
-    );
+        app->view_dispatcher, MifareFuzzerViewSelectCard, submenu_get_view(app->submenu_card));
 
     // view: select attack type
     app->submenu_attack = submenu_alloc();
     view_dispatcher_add_view(
-        app->view_dispatcher,
-        MifareFuzzerViewSelectAttack,
-        submenu_get_view(app->submenu_attack)
-    );
+        app->view_dispatcher, MifareFuzzerViewSelectAttack, submenu_get_view(app->submenu_attack));
 
     // view: emulator
     app->emulator_view = mifare_fuzzer_emulator_alloc();
     view_dispatcher_add_view(
         app->view_dispatcher,
         MifareFuzzerViewEmulator,
-        mifare_fuzzer_emulator_get_view(app->emulator_view)
-    );
+        mifare_fuzzer_emulator_get_view(app->emulator_view));
 
     // worker
     app->worker = mifare_fuzzer_worker_alloc();
@@ -95,7 +87,7 @@ MifareFuzzerApp* mifare_fuzzer_alloc() {
 }
 
 /// @brief mifare_fuzzer_free()
-/// @param app 
+/// @param app
 void mifare_fuzzer_free(MifareFuzzerApp* app) {
     furi_assert(app);
 
@@ -103,6 +95,7 @@ void mifare_fuzzer_free(MifareFuzzerApp* app) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_free() :: Views");
     view_dispatcher_remove_view(app->view_dispatcher, MifareFuzzerViewSelectCard);
     view_dispatcher_remove_view(app->view_dispatcher, MifareFuzzerViewSelectAttack);
+    view_dispatcher_remove_view(app->view_dispatcher, MifareFuzzerViewEmulator);
 
     // Submenus
     //FURI_LOG_D(TAG, "mifare_fuzzer_free() :: Submenus");
@@ -145,8 +138,8 @@ void mifare_fuzzer_free(MifareFuzzerApp* app) {
 }
 
 /// @brief mifare_fuzzer_app (ENTRYPOINT)
-/// @param p 
-/// @return 
+/// @param p
+/// @return
 int32_t mifare_fuzzer_app(void* p) {
     UNUSED(p);
     //FURI_LOG_D(TAG, "mifare_fuzzer_app()");

mifare_fuzzer_i.h

@@ -48,7 +48,6 @@ typedef enum {
 } MifareFuzzerView;
 
 struct MifareFuzzerApp {
-
     Gui* gui;
 
     ViewDispatcher* view_dispatcher;
@@ -74,5 +73,4 @@ struct MifareFuzzerApp {
     FuriString* file_path;
     FuriString* uid_str;
     Stream* uids_stream;
-
 };

mifare_fuzzer_worker.c

@@ -2,17 +2,18 @@
 #include "mifare_fuzzer_worker.h"
 
 /// @brief mifare_fuzzer_worker_alloc()
-/// @return 
+/// @return
 MifareFuzzerWorker* mifare_fuzzer_worker_alloc() {
     MifareFuzzerWorker* mifare_fuzzer_worker = malloc(sizeof(MifareFuzzerWorker));
     // Worker thread attributes
-    mifare_fuzzer_worker->thread = furi_thread_alloc_ex("MifareFuzzerWorker", 8192, mifare_fuzzer_worker_task, mifare_fuzzer_worker);
+    mifare_fuzzer_worker->thread = furi_thread_alloc_ex(
+        "MifareFuzzerWorker", 8192, mifare_fuzzer_worker_task, mifare_fuzzer_worker);
     mifare_fuzzer_worker->state = MifareFuzzerWorkerStateStop;
     return mifare_fuzzer_worker;
 }
 
 /// @brief mifare_fuzzer_worker_free()
-/// @param mifare_fuzzer_worker 
+/// @param mifare_fuzzer_worker
 void mifare_fuzzer_worker_free(MifareFuzzerWorker* mifare_fuzzer_worker) {
     furi_assert(mifare_fuzzer_worker);
     furi_thread_free(mifare_fuzzer_worker->thread);
@@ -20,17 +21,17 @@ void mifare_fuzzer_worker_free(MifareFuzzerWorker* mifare_fuzzer_worker) {
 }
 
 /// @brief mifare_fuzzer_worker_stop()
-/// @param mifare_fuzzer_worker 
+/// @param mifare_fuzzer_worker
 void mifare_fuzzer_worker_stop(MifareFuzzerWorker* mifare_fuzzer_worker) {
     furi_assert(mifare_fuzzer_worker);
-    if (mifare_fuzzer_worker->state != MifareFuzzerWorkerStateStop) {
+    if(mifare_fuzzer_worker->state != MifareFuzzerWorkerStateStop) {
         mifare_fuzzer_worker->state = MifareFuzzerWorkerStateStop;
         furi_thread_join(mifare_fuzzer_worker->thread);
     }
 }
 
 /// @brief mifare_fuzzer_worker_start()
-/// @param mifare_fuzzer_worker 
+/// @param mifare_fuzzer_worker
 void mifare_fuzzer_worker_start(MifareFuzzerWorker* mifare_fuzzer_worker) {
     furi_assert(mifare_fuzzer_worker);
     mifare_fuzzer_worker->state = MifareFuzzerWorkerStateEmulate;
@@ -38,27 +39,20 @@ void mifare_fuzzer_worker_start(MifareFuzzerWorker* mifare_fuzzer_worker) {
 }
 
 /// @brief mifare_fuzzer_worker_task()
-/// @param context 
-/// @return 
+/// @param context
+/// @return
 int32_t mifare_fuzzer_worker_task(void* context) {
     MifareFuzzerWorker* mifare_fuzzer_worker = context;
 
     if(mifare_fuzzer_worker->state == MifareFuzzerWorkerStateEmulate) {
-
         FuriHalNfcDevData params = mifare_fuzzer_worker->nfc_dev_data;
 
         furi_hal_nfc_exit_sleep();
         while(mifare_fuzzer_worker->state == MifareFuzzerWorkerStateEmulate) {
-            furi_hal_nfc_listen(
-                params.uid,
-                params.uid_len,
-                params.atqa,
-                params.sak, false, 500
-            );
+            furi_hal_nfc_listen(params.uid, params.uid_len, params.atqa, params.sak, false, 500);
             furi_delay_ms(50);
         }
         furi_hal_nfc_sleep();
-
     }
 
     mifare_fuzzer_worker->state = MifareFuzzerWorkerStateStop;
@@ -67,25 +61,27 @@ int32_t mifare_fuzzer_worker_task(void* context) {
 }
 
 /// @brief mifare_fuzzer_worker_is_emulating()
-/// @param mifare_fuzzer_worker 
-/// @return 
+/// @param mifare_fuzzer_worker
+/// @return
 bool mifare_fuzzer_worker_is_emulating(MifareFuzzerWorker* mifare_fuzzer_worker) {
-    if (mifare_fuzzer_worker->state == MifareFuzzerWorkerStateEmulate) {
+    if(mifare_fuzzer_worker->state == MifareFuzzerWorkerStateEmulate) {
         return true;
     }
     return false;
 }
 
 /// @brief mifare_fuzzer_worker_set_nfc_dev_data()
-/// @param mifare_fuzzer_worker 
-/// @param nfc_dev_data 
-void mifare_fuzzer_worker_set_nfc_dev_data(MifareFuzzerWorker* mifare_fuzzer_worker, FuriHalNfcDevData nfc_dev_data) {
+/// @param mifare_fuzzer_worker
+/// @param nfc_dev_data
+void mifare_fuzzer_worker_set_nfc_dev_data(
+    MifareFuzzerWorker* mifare_fuzzer_worker,
+    FuriHalNfcDevData nfc_dev_data) {
     mifare_fuzzer_worker->nfc_dev_data = nfc_dev_data;
 }
 
 /// @brief mifare_fuzzer_worker_get_nfc_dev_data()
-/// @param mifare_fuzzer_worker 
-/// @return 
+/// @param mifare_fuzzer_worker
+/// @return
 FuriHalNfcDevData mifare_fuzzer_worker_get_nfc_dev_data(MifareFuzzerWorker* mifare_fuzzer_worker) {
     return mifare_fuzzer_worker->nfc_dev_data;
 }

mifare_fuzzer_worker.h

@@ -23,7 +23,9 @@ void mifare_fuzzer_worker_stop(MifareFuzzerWorker* mifare_fuzzer_worker);
 void mifare_fuzzer_worker_start(MifareFuzzerWorker* mifare_fuzzer_worker);
 // task
 int32_t mifare_fuzzer_worker_task(void* context);
-// 
+//
 bool mifare_fuzzer_worker_is_emulating(MifareFuzzerWorker* mifare_fuzzer_worker);
-void mifare_fuzzer_worker_set_nfc_dev_data(MifareFuzzerWorker* mifare_fuzzer_worker, FuriHalNfcDevData nfc_dev_data);
+void mifare_fuzzer_worker_set_nfc_dev_data(
+    MifareFuzzerWorker* mifare_fuzzer_worker,
+    FuriHalNfcDevData nfc_dev_data);
 FuriHalNfcDevData mifare_fuzzer_worker_get_nfc_dev_data(MifareFuzzerWorker* mifare_fuzzer_worker);

scenes/mifare_fuzzer_scene_attack.c

@@ -8,13 +8,13 @@ enum SubmenuIndex {
 };
 
 /// @brief mifare_fuzzer_scene_attack_submenu_callback()
-/// @param context 
-/// @param index 
+/// @param context
+/// @param index
 void mifare_fuzzer_scene_attack_submenu_callback(void* context, uint32_t index) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_attack_submenu_callback() :: index = %ld", index);
     MifareFuzzerApp* app = context;
     uint8_t custom_event = 255;
-    switch(index){
+    switch(index) {
     case SubmenuIndexTestValue:
         custom_event = MifareFuzzerEventTestValueAttack;
         break;
@@ -32,7 +32,7 @@ void mifare_fuzzer_scene_attack_submenu_callback(void* context, uint32_t index)
 }
 
 /// @brief mifare_fuzzer_scene_attack_on_enter()
-/// @param context 
+/// @param context
 void mifare_fuzzer_scene_attack_on_enter(void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_attack_on_enter()");
     MifareFuzzerApp* app = context;
@@ -44,41 +44,32 @@ void mifare_fuzzer_scene_attack_on_enter(void* context) {
         "Test Values",
         SubmenuIndexTestValue,
         mifare_fuzzer_scene_attack_submenu_callback,
-        app
-    );
+        app);
     submenu_add_item(
         submenu_attack,
         "Random Values",
         SubmenuIndexRandomValuesAttack,
         mifare_fuzzer_scene_attack_submenu_callback,
-        app
-    );
+        app);
     submenu_add_item(
         submenu_attack,
         "Load UIDs from file",
         SubmenuIndexLoadUIDsFromFile,
         mifare_fuzzer_scene_attack_submenu_callback,
-        app
-    );
+        app);
 
     // set selected menu
-    submenu_set_selected_item(submenu_attack,
-        scene_manager_get_scene_state(
-            app->scene_manager,
-            MifareFuzzerSceneAttack
-        )
-    );
+    submenu_set_selected_item(
+        submenu_attack,
+        scene_manager_get_scene_state(app->scene_manager, MifareFuzzerSceneAttack));
 
-    view_dispatcher_switch_to_view(
-        app->view_dispatcher,
-        MifareFuzzerViewSelectAttack
-    );
+    view_dispatcher_switch_to_view(app->view_dispatcher, MifareFuzzerViewSelectAttack);
 }
 
 /// @brief mifare_fuzzer_scene_attack_on_event()
-/// @param context 
-/// @param event 
-/// @return 
+/// @param context
+/// @param event
+/// @return
 bool mifare_fuzzer_scene_attack_on_event(void* context, SceneManagerEvent event) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_attack_on_event()");
     MifareFuzzerApp* app = context;
@@ -88,7 +79,8 @@ bool mifare_fuzzer_scene_attack_on_event(void* context, SceneManagerEvent event)
         //FURI_LOG_D(TAG, "mifare_fuzzer_scene_attack_on_event() :: event.event = %ld", event.event);
         if(event.event == MifareFuzzerEventTestValueAttack) {
             // save selected item
-            scene_manager_set_scene_state(app->scene_manager, MifareFuzzerSceneAttack, SubmenuIndexTestValue);
+            scene_manager_set_scene_state(
+                app->scene_manager, MifareFuzzerSceneAttack, SubmenuIndexTestValue);
             // set emulator attack
             app->attack = MifareFuzzerAttackTestValues;
             mifare_fuzzer_emulator_set_attack(app->emulator_view, app->attack);
@@ -97,7 +89,8 @@ bool mifare_fuzzer_scene_attack_on_event(void* context, SceneManagerEvent event)
             consumed = true;
         } else if(event.event == MifareFuzzerEventRandomValuesAttack) {
             // save selected item
-            scene_manager_set_scene_state(app->scene_manager, MifareFuzzerSceneAttack, SubmenuIndexRandomValuesAttack);
+            scene_manager_set_scene_state(
+                app->scene_manager, MifareFuzzerSceneAttack, SubmenuIndexRandomValuesAttack);
             // set emulator attack
             app->attack = MifareFuzzerAttackRandomValues;
             mifare_fuzzer_emulator_set_attack(app->emulator_view, app->attack);
@@ -106,7 +99,8 @@ bool mifare_fuzzer_scene_attack_on_event(void* context, SceneManagerEvent event)
             consumed = true;
         } else if(event.event == MifareFuzzerEventLoadUIDsFromFileAttack) {
             // save selected item
-            scene_manager_set_scene_state(app->scene_manager, MifareFuzzerSceneAttack, SubmenuIndexLoadUIDsFromFile);
+            scene_manager_set_scene_state(
+                app->scene_manager, MifareFuzzerSceneAttack, SubmenuIndexLoadUIDsFromFile);
             // set emulator attack
             app->attack = MifareFuzzerAttackLoadUidsFromFile;
             mifare_fuzzer_emulator_set_attack(app->emulator_view, app->attack);
@@ -115,14 +109,14 @@ bool mifare_fuzzer_scene_attack_on_event(void* context, SceneManagerEvent event)
             dialog_file_browser_set_basic_options(&browser_options, MIFARE_FUZZER_FILE_EXT, NULL);
             browser_options.hide_ext = false;
             bool res = dialog_file_browser_show(
-                app->dialogs,
-                app->file_path,
-                app->app_folder, &browser_options);
+                app->dialogs, app->file_path, app->app_folder, &browser_options);
             if(res) {
                 app->uids_stream = buffered_file_stream_alloc(app->storage);
-                    res = buffered_file_stream_open(
-                        app->uids_stream,
-                        furi_string_get_cstr(app->file_path), FSAM_READ, FSOM_OPEN_EXISTING);
+                res = buffered_file_stream_open(
+                    app->uids_stream,
+                    furi_string_get_cstr(app->file_path),
+                    FSAM_READ,
+                    FSOM_OPEN_EXISTING);
                 if(res) {
                     // open next scene
                     scene_manager_next_scene(app->scene_manager, MifareFuzzerSceneEmulator);
@@ -132,7 +126,7 @@ bool mifare_fuzzer_scene_attack_on_event(void* context, SceneManagerEvent event)
             }
             consumed = true;
         }
-    } else if (event.type == SceneManagerEventTypeTick) {
+    } else if(event.type == SceneManagerEventTypeTick) {
         //FURI_LOG_D(TAG, "mifare_fuzzer_scene_attack_on_event() :: SceneManagerEventTypeTick");
         //consumed = true;
     }
@@ -141,7 +135,7 @@ bool mifare_fuzzer_scene_attack_on_event(void* context, SceneManagerEvent event)
 }
 
 /// @brief mifare_fuzzer_scene_attack_on_exit()
-/// @param context 
+/// @param context
 void mifare_fuzzer_scene_attack_on_exit(void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_attack_on_exit()");
     MifareFuzzerApp* app = context;

scenes/mifare_fuzzer_scene_emulator.c

@@ -16,8 +16,8 @@ uint8_t id_uid_test[9][7] = {
 };
 
 /// @brief mifare_fuzzer_scene_emulator_callback()
-/// @param event 
-/// @param context 
+/// @param event
+/// @param context
 static void mifare_fuzzer_scene_emulator_callback(MifareFuzzerEvent event, void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_emulator_callback()");
     furi_assert(context);
@@ -26,7 +26,7 @@ static void mifare_fuzzer_scene_emulator_callback(MifareFuzzerEvent event, void*
 }
 
 /// @brief mifare_fuzzer_scene_emulator_on_enter()
-/// @param context 
+/// @param context
 void mifare_fuzzer_scene_emulator_on_enter(void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_emulator_on_enter()");
     MifareFuzzerApp* app = context;
@@ -38,13 +38,14 @@ void mifare_fuzzer_scene_emulator_on_enter(void* context) {
     tick_counter = 0;
     mifare_fuzzer_emulator_set_tick_num(app->emulator_view, tick_counter);
     emulator->ticks_between_cards = MIFARE_FUZZER_DEFAULT_TICKS_BETWEEN_CARDS;
-    mifare_fuzzer_emulator_set_ticks_between_cards(app->emulator_view, emulator->ticks_between_cards);
+    mifare_fuzzer_emulator_set_ticks_between_cards(
+        app->emulator_view, emulator->ticks_between_cards);
     // init default card data
     FuriHalNfcDevData nfc_dev_data;
     nfc_dev_data.atqa[0] = 0x00;
     nfc_dev_data.atqa[1] = 0x00;
     nfc_dev_data.sak = 0x00;
-    if (app->card == MifareCardUltralight) {
+    if(app->card == MifareCardUltralight) {
         nfc_dev_data.uid_len = 0x07;
     } else {
         nfc_dev_data.uid_len = 0x04;
@@ -57,16 +58,13 @@ void mifare_fuzzer_scene_emulator_on_enter(void* context) {
     attack_step = 0;
 
     // switch to view
-    view_dispatcher_switch_to_view(
-        app->view_dispatcher,
-        MifareFuzzerViewEmulator
-    );
+    view_dispatcher_switch_to_view(app->view_dispatcher, MifareFuzzerViewEmulator);
 }
 
 /// @brief mifare_fuzzer_scene_emulator_on_event()
-/// @param context 
-/// @param event 
-/// @return 
+/// @param context
+/// @param event
+/// @return
 bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent event) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_emulator_on_event()");
     FuriHalNfcDevData nfc_dev_data;
@@ -76,8 +74,8 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
 
     bool consumed = false;
 
-    if (event.type == SceneManagerEventTypeCustom) {
-        if (event.event == MifareFuzzerEventStartAttack) {
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == MifareFuzzerEventStartAttack) {
             //FURI_LOG_D(TAG, "mifare_fuzzer_scene_emulator_on_event() :: MifareFuzzerEventStartAttack");
 
             // Stop worker
@@ -85,17 +83,17 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
 
             // Set card type
             // TODO: Move somewhere else, I do not like this to be there
-            if (app->card == MifareCardClassic1k) {
+            if(app->card == MifareCardClassic1k) {
                 nfc_dev_data.atqa[0] = 0x04;
                 nfc_dev_data.atqa[1] = 0x00;
                 nfc_dev_data.sak = 0x08;
                 nfc_dev_data.uid_len = 0x04;
-            } else if (app->card == MifareCardClassic4k) {
+            } else if(app->card == MifareCardClassic4k) {
                 nfc_dev_data.atqa[0] = 0x02;
                 nfc_dev_data.atqa[1] = 0x00;
                 nfc_dev_data.sak = 0x18;
                 nfc_dev_data.uid_len = 0x04;
-            } else if (app->card == MifareCardUltralight) {
+            } else if(app->card == MifareCardUltralight) {
                 nfc_dev_data.atqa[0] = 0x44;
                 nfc_dev_data.atqa[1] = 0x00;
                 nfc_dev_data.sak = 0x00;
@@ -103,19 +101,19 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
             }
 
             // Set UIDs
-            if (app->attack == MifareFuzzerAttackTestValues) {
+            if(app->attack == MifareFuzzerAttackTestValues) {
                 // Load test UIDs
                 for(uint8_t i = 0; i < nfc_dev_data.uid_len; i++) {
                     nfc_dev_data.uid[i] = id_uid_test[attack_step][i];
                 }
                 // Next UIDs on next loop
-                if (attack_step >= 8) {
+                if(attack_step >= 8) {
                     attack_step = 0;
                 } else {
                     attack_step++;
                 }
-            } else if (app->attack == MifareFuzzerAttackRandomValues) {
-                if (app->card == MifareCardUltralight) {
+            } else if(app->attack == MifareFuzzerAttackRandomValues) {
+                if(app->card == MifareCardUltralight) {
                     // First byte of a 7 byte UID is the manufacturer-code
                     // https://github.com/Proxmark/proxmark3/blob/master/client/taginfo.c
                     // https://stackoverflow.com/questions/37837730/mifare-cards-distinguish-between-4-byte-and-7-byte-uids
@@ -132,10 +130,10 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
                         nfc_dev_data.uid[i] = (furi_hal_random_get() & 0xFF);
                     }
                 }
-            } else if (app->attack == MifareFuzzerAttackLoadUidsFromFile) {
+            } else if(app->attack == MifareFuzzerAttackLoadUidsFromFile) {
                 //bool end_of_list = false;
                 // read stream
-                while(true){
+                while(true) {
                     furi_string_reset(app->uid_str);
                     if(!stream_read_line(app->uids_stream, app->uid_str)) {
                         // restart from beginning on empty line
@@ -146,7 +144,9 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
                     // Skip comments
                     if(furi_string_get_char(app->uid_str, 0) == '#') continue;
                     // Skip lines with invalid length
-                    if((furi_string_size(app->uid_str) != 9) && (furi_string_size(app->uid_str) != 15)) continue;
+                    if((furi_string_size(app->uid_str) != 9) &&
+                       (furi_string_size(app->uid_str) != 15))
+                        continue;
                     break;
                 }
 
@@ -156,7 +156,7 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
                 // parse string to UID
                 // TODO: a better validation on input?
                 for(uint8_t i = 0; i < nfc_dev_data.uid_len; i++) {
-                    if (i <= ((furi_string_size(app->uid_str) - 1) / 2)) {
+                    if(i <= ((furi_string_size(app->uid_str) - 1) / 2)) {
                         char temp_str[3];
                         temp_str[0] = furi_string_get_cstr(app->uid_str)[i * 2];
                         temp_str[1] = furi_string_get_cstr(app->uid_str)[i * 2 + 1];
@@ -166,7 +166,6 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
                         nfc_dev_data.uid[i] = 0x00;
                     }
                 }
-
             }
 
             mifare_fuzzer_worker_set_nfc_dev_data(app->worker, nfc_dev_data);
@@ -179,27 +178,29 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
             // Start worker
             mifare_fuzzer_worker_start(app->worker);
 
-        } else if (event.event == MifareFuzzerEventStopAttack) {
+        } else if(event.event == MifareFuzzerEventStopAttack) {
             //FURI_LOG_D(TAG, "mifare_fuzzer_scene_emulator_on_event() :: MifareFuzzerEventStopAttack");
             // Stop worker
             mifare_fuzzer_worker_stop(app->worker);
-        } else if (event.event == MifareFuzzerEventIncrementTicks) {
-            if (!emulator->is_attacking) {
-                if (emulator->ticks_between_cards < MIFARE_FUZZER_MAX_TICKS_BETWEEN_CARDS) {
+        } else if(event.event == MifareFuzzerEventIncrementTicks) {
+            if(!emulator->is_attacking) {
+                if(emulator->ticks_between_cards < MIFARE_FUZZER_MAX_TICKS_BETWEEN_CARDS) {
                     emulator->ticks_between_cards++;
-                    mifare_fuzzer_emulator_set_ticks_between_cards(app->emulator_view, emulator->ticks_between_cards);
+                    mifare_fuzzer_emulator_set_ticks_between_cards(
+                        app->emulator_view, emulator->ticks_between_cards);
                 };
             };
-        } else if (event.event == MifareFuzzerEventDecrementTicks) {
-            if (!emulator->is_attacking) {
-                if (emulator->ticks_between_cards > MIFARE_FUZZER_MIN_TICKS_BETWEEN_CARDS) {
+        } else if(event.event == MifareFuzzerEventDecrementTicks) {
+            if(!emulator->is_attacking) {
+                if(emulator->ticks_between_cards > MIFARE_FUZZER_MIN_TICKS_BETWEEN_CARDS) {
                     emulator->ticks_between_cards--;
-                    mifare_fuzzer_emulator_set_ticks_between_cards(app->emulator_view, emulator->ticks_between_cards);
+                    mifare_fuzzer_emulator_set_ticks_between_cards(
+                        app->emulator_view, emulator->ticks_between_cards);
                 };
             };
         }
         consumed = true;
-    } else if (event.type == SceneManagerEventTypeTick) {
+    } else if(event.type == SceneManagerEventTypeTick) {
         //FURI_LOG_D(TAG, "mifare_fuzzer_scene_emulator_on_event() :: SceneManagerEventTypeTick");
 
         // Used to check tick length (not perfect but enough)
@@ -208,14 +209,15 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
         //FURI_LOG_D(TAG, "Time is: %.2d:%.2d:%.2d", curr_dt.hour, curr_dt.minute, curr_dt.second);
 
         // If emulator is attacking
-        if (emulator->is_attacking) {
+        if(emulator->is_attacking) {
             // increment tick_counter
             tick_counter++;
             mifare_fuzzer_emulator_set_tick_num(app->emulator_view, tick_counter);
             //FURI_LOG_D(TAG, "tick_counter is: %.2d", tick_counter);
-            if (tick_counter >= emulator->ticks_between_cards) {
+            if(tick_counter >= emulator->ticks_between_cards) {
                 // Queue event for changing UID
-                view_dispatcher_send_custom_event(app->view_dispatcher, MifareFuzzerEventStartAttack);
+                view_dispatcher_send_custom_event(
+                    app->view_dispatcher, MifareFuzzerEventStartAttack);
             }
         }
 
@@ -226,7 +228,7 @@ bool mifare_fuzzer_scene_emulator_on_event(void* context, SceneManagerEvent even
 }
 
 /// @brief mifare_fuzzer_scene_emulator_on_exit()
-/// @param context 
+/// @param context
 void mifare_fuzzer_scene_emulator_on_exit(void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_emulator_on_exit()");
     MifareFuzzerApp* app = context;
@@ -237,5 +239,4 @@ void mifare_fuzzer_scene_emulator_on_exit(void* context) {
         stream_rewind(app->uids_stream);
         buffered_file_stream_close(app->uids_stream);
     }
-
 }

scenes/mifare_fuzzer_scene_start.c

@@ -8,13 +8,13 @@ enum SubmenuIndex {
 };
 
 /// @brief mifare_fuzzer_scene_start_submenu_callback()
-/// @param context 
-/// @param index 
+/// @param context
+/// @param index
 void mifare_fuzzer_scene_start_submenu_callback(void* context, uint32_t index) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_start_submenu_callback() :: index = %ld", index);
     MifareFuzzerApp* app = context;
     uint8_t custom_event = 255;
-    switch(index){
+    switch(index) {
     case SubmenuIndexClassic1k:
         custom_event = MifareFuzzerEventClassic1k;
         break;
@@ -32,7 +32,7 @@ void mifare_fuzzer_scene_start_submenu_callback(void* context, uint32_t index) {
 }
 
 /// @brief mifare_fuzzer_scene_start_on_enter()
-/// @param context 
+/// @param context
 void mifare_fuzzer_scene_start_on_enter(void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_start_on_enter()");
     MifareFuzzerApp* app = context;
@@ -44,41 +44,31 @@ void mifare_fuzzer_scene_start_on_enter(void* context) {
         "Classic 1k",
         SubmenuIndexClassic1k,
         mifare_fuzzer_scene_start_submenu_callback,
-        app
-    );
+        app);
     submenu_add_item(
         submenu_card,
         "Classic 4k",
         SubmenuIndexClassic4k,
         mifare_fuzzer_scene_start_submenu_callback,
-        app
-    );
+        app);
     submenu_add_item(
         submenu_card,
         "Ultralight",
         SubmenuIndexUltralight,
         mifare_fuzzer_scene_start_submenu_callback,
-        app
-    );
+        app);
 
     // set selected menu
-    submenu_set_selected_item(submenu_card,
-        scene_manager_get_scene_state(
-            app->scene_manager,
-            MifareFuzzerSceneStart
-        )
-    );
+    submenu_set_selected_item(
+        submenu_card, scene_manager_get_scene_state(app->scene_manager, MifareFuzzerSceneStart));
 
-    view_dispatcher_switch_to_view(
-        app->view_dispatcher,
-        MifareFuzzerViewSelectCard
-    );
+    view_dispatcher_switch_to_view(app->view_dispatcher, MifareFuzzerViewSelectCard);
 }
 
 /// @brief mifare_fuzzer_scene_start_on_event()
-/// @param context 
-/// @param event 
-/// @return 
+/// @param context
+/// @param event
+/// @return
 bool mifare_fuzzer_scene_start_on_event(void* context, SceneManagerEvent event) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_start_on_event()");
     MifareFuzzerApp* app = context;
@@ -88,7 +78,8 @@ bool mifare_fuzzer_scene_start_on_event(void* context, SceneManagerEvent event)
         //FURI_LOG_D(TAG, "mifare_fuzzer_scene_start_on_event() :: event.event = %ld", event.event);
         if(event.event == MifareFuzzerEventClassic1k) {
             // save selected item
-            scene_manager_set_scene_state(app->scene_manager, MifareFuzzerSceneStart, SubmenuIndexClassic1k);
+            scene_manager_set_scene_state(
+                app->scene_manager, MifareFuzzerSceneStart, SubmenuIndexClassic1k);
             // set emulator card
             app->card = MifareCardClassic1k;
             mifare_fuzzer_emulator_set_card(app->emulator_view, app->card);
@@ -97,7 +88,8 @@ bool mifare_fuzzer_scene_start_on_event(void* context, SceneManagerEvent event)
             consumed = true;
         } else if(event.event == MifareFuzzerEventClassic4k) {
             // save selected item
-            scene_manager_set_scene_state(app->scene_manager, MifareFuzzerSceneStart, SubmenuIndexClassic4k);
+            scene_manager_set_scene_state(
+                app->scene_manager, MifareFuzzerSceneStart, SubmenuIndexClassic4k);
             // set emulator card
             app->card = MifareCardClassic4k;
             mifare_fuzzer_emulator_set_card(app->emulator_view, app->card);
@@ -106,7 +98,8 @@ bool mifare_fuzzer_scene_start_on_event(void* context, SceneManagerEvent event)
             consumed = true;
         } else if(event.event == MifareFuzzerEventUltralight) {
             // save selected item
-            scene_manager_set_scene_state(app->scene_manager, MifareFuzzerSceneStart, SubmenuIndexUltralight);
+            scene_manager_set_scene_state(
+                app->scene_manager, MifareFuzzerSceneStart, SubmenuIndexUltralight);
             // set emulator card
             app->card = MifareCardUltralight;
             mifare_fuzzer_emulator_set_card(app->emulator_view, app->card);
@@ -114,7 +107,7 @@ bool mifare_fuzzer_scene_start_on_event(void* context, SceneManagerEvent event)
             scene_manager_next_scene(app->scene_manager, MifareFuzzerSceneAttack);
             consumed = true;
         }
-    } else if (event.type == SceneManagerEventTypeTick) {
+    } else if(event.type == SceneManagerEventTypeTick) {
         //FURI_LOG_D(TAG, "mifare_fuzzer_scene_start_on_event() :: SceneManagerEventTypeTick");
         //consumed = true;
     }
@@ -123,7 +116,7 @@ bool mifare_fuzzer_scene_start_on_event(void* context, SceneManagerEvent event)
 }
 
 /// @brief mifare_fuzzer_scene_start_on_exit()
-/// @param context 
+/// @param context
 void mifare_fuzzer_scene_start_on_exit(void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_scene_start_on_exit()");
     MifareFuzzerApp* app = context;

views/mifare_fuzzer_emulator.c

@@ -5,9 +5,9 @@
 // Screen is 128 × 64 pixels
 
 /// @brief mifare_fuzzer_emulator_set_callback
-/// @param mifare_fuzzer_emulator 
-/// @param callback 
-/// @param context 
+/// @param mifare_fuzzer_emulator
+/// @param callback
+/// @param context
 void mifare_fuzzer_emulator_set_callback(
     MifareFuzzerEmulator* mifare_fuzzer_emulator,
     MifareFuzzerEmulatorCallback callback,
@@ -20,8 +20,8 @@ void mifare_fuzzer_emulator_set_callback(
 }
 
 /// @brief mifare_fuzzer_emulator_draw_callback
-/// @param canvas 
-/// @param _model 
+/// @param canvas
+/// @param _model
 static void mifare_fuzzer_emulator_draw_callback(Canvas* canvas, void* _model) {
     MifareFuzzerEmulatorModel* model = _model;
     FuriString* furi_string = furi_string_alloc();
@@ -40,7 +40,7 @@ static void mifare_fuzzer_emulator_draw_callback(Canvas* canvas, void* _model) {
     char uid_char[3];
     cpos = 0;
     for(uint8_t i = 0; i < model->nfc_dev_data.uid_len; i++) {
-        if (i > 0) {
+        if(i > 0) {
             uid[cpos] = ':';
             cpos++;
         }
@@ -56,17 +56,17 @@ static void mifare_fuzzer_emulator_draw_callback(Canvas* canvas, void* _model) {
     // Secondary font
     canvas_set_font(canvas, FontSecondary);
     // Card
-    canvas_draw_str(canvas,   4, 22, "c:");
-    canvas_draw_str(canvas,  15, 22, model->mifare_card_dsc);
+    canvas_draw_str(canvas, 4, 22, "c:");
+    canvas_draw_str(canvas, 15, 22, model->mifare_card_dsc);
     // Timing
     furi_string_printf(furi_string, "%d", model->ticks_between_cards);
-    canvas_draw_str(canvas,  90, 22, "t:");
+    canvas_draw_str(canvas, 90, 22, "t:");
     canvas_draw_str(canvas, 100, 22, furi_string_get_cstr(furi_string));
     // Attack
-    canvas_draw_str(canvas,   4, 33, "a:");
-    canvas_draw_str(canvas,  15, 33, model->attack_dsc);
+    canvas_draw_str(canvas, 4, 33, "a:");
+    canvas_draw_str(canvas, 15, 33, model->attack_dsc);
 
-    if (!model->is_attacking) {
+    if(!model->is_attacking) {
         elements_button_left(canvas, "t-1");
         elements_button_center(canvas, "Start");
         elements_button_right(canvas, "t+1");
@@ -80,9 +80,9 @@ static void mifare_fuzzer_emulator_draw_callback(Canvas* canvas, void* _model) {
 }
 
 /// @brief mifare_fuzzer_emulator_input_callback
-/// @param event 
-/// @param context 
-/// @return 
+/// @param event
+/// @param context
+/// @return
 static bool mifare_fuzzer_emulator_input_callback(InputEvent* event, void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_emulator_input_callback()");
     furi_assert(context);
@@ -91,13 +91,15 @@ static bool mifare_fuzzer_emulator_input_callback(InputEvent* event, void* conte
 
     if(event->type == InputTypeShort) {
         if(event->key == InputKeyRight) {
-            if (!mifare_fuzzer_emulator->is_attacking) {
-                mifare_fuzzer_emulator->callback(MifareFuzzerEventIncrementTicks, mifare_fuzzer_emulator->context);
+            if(!mifare_fuzzer_emulator->is_attacking) {
+                mifare_fuzzer_emulator->callback(
+                    MifareFuzzerEventIncrementTicks, mifare_fuzzer_emulator->context);
             };
             consumed = true;
         } else if(event->key == InputKeyLeft) {
-            if (!mifare_fuzzer_emulator->is_attacking) {
-                mifare_fuzzer_emulator->callback(MifareFuzzerEventDecrementTicks, mifare_fuzzer_emulator->context);
+            if(!mifare_fuzzer_emulator->is_attacking) {
+                mifare_fuzzer_emulator->callback(
+                    MifareFuzzerEventDecrementTicks, mifare_fuzzer_emulator->context);
             };
             consumed = true;
         } else if(event->key == InputKeyUp) {
@@ -105,23 +107,22 @@ static bool mifare_fuzzer_emulator_input_callback(InputEvent* event, void* conte
         } else if(event->key == InputKeyDown) {
             consumed = true;
         } else if(event->key == InputKeyOk) {
-
             // Toggle attack
-            if (mifare_fuzzer_emulator->is_attacking) {
+            if(mifare_fuzzer_emulator->is_attacking) {
                 mifare_fuzzer_emulator->is_attacking = false;
-                mifare_fuzzer_emulator->callback(MifareFuzzerEventStopAttack, mifare_fuzzer_emulator->context);
+                mifare_fuzzer_emulator->callback(
+                    MifareFuzzerEventStopAttack, mifare_fuzzer_emulator->context);
             } else {
                 mifare_fuzzer_emulator->is_attacking = true;
-                mifare_fuzzer_emulator->callback(MifareFuzzerEventStartAttack, mifare_fuzzer_emulator->context);
+                mifare_fuzzer_emulator->callback(
+                    MifareFuzzerEventStartAttack, mifare_fuzzer_emulator->context);
             }
 
             with_view_model(
                 mifare_fuzzer_emulator->view,
-                MifareFuzzerEmulatorModel* model,
-                {
-                    model->is_attacking = mifare_fuzzer_emulator->is_attacking;
-                }, true
-            );
+                MifareFuzzerEmulatorModel * model,
+                { model->is_attacking = mifare_fuzzer_emulator->is_attacking; },
+                true);
 
             consumed = true;
         }
@@ -131,7 +132,7 @@ static bool mifare_fuzzer_emulator_input_callback(InputEvent* event, void* conte
 }
 
 /// @brief mifare_fuzzer_emulator_enter_callback
-/// @param context 
+/// @param context
 static void mifare_fuzzer_emulator_enter_callback(void* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_emulator_enter_callback()");
     furi_assert(context);
@@ -141,40 +142,34 @@ static void mifare_fuzzer_emulator_enter_callback(void* context) {
     mifare_fuzzer_emulator->is_attacking = false;
     with_view_model(
         mifare_fuzzer_emulator->view,
-        MifareFuzzerEmulatorModel* model,
-        {
-            model->is_attacking = false;
-        },
-        true
-    );
-
+        MifareFuzzerEmulatorModel * model,
+        { model->is_attacking = false; },
+        true);
 }
 
 /// @brief mifare_fuzzer_emulator_alloc
-/// @return 
+/// @return
 MifareFuzzerEmulator* mifare_fuzzer_emulator_alloc() {
     MifareFuzzerEmulator* mifare_fuzzer_emulator = malloc(sizeof(MifareFuzzerEmulator));
     mifare_fuzzer_emulator->view = view_alloc();
     view_set_context(mifare_fuzzer_emulator->view, mifare_fuzzer_emulator);
-    view_allocate_model(mifare_fuzzer_emulator->view, ViewModelTypeLocking, sizeof(MifareFuzzerEmulatorModel));
+    view_allocate_model(
+        mifare_fuzzer_emulator->view, ViewModelTypeLocking, sizeof(MifareFuzzerEmulatorModel));
     view_set_draw_callback(mifare_fuzzer_emulator->view, mifare_fuzzer_emulator_draw_callback);
     view_set_input_callback(mifare_fuzzer_emulator->view, mifare_fuzzer_emulator_input_callback);
     view_set_enter_callback(mifare_fuzzer_emulator->view, mifare_fuzzer_emulator_enter_callback);
 
     with_view_model(
         mifare_fuzzer_emulator->view,
-        MifareFuzzerEmulatorModel* model,
-        {
-            model->title = "Mifare Fuzzer (emulator)";
-        },
-        true
-    );
+        MifareFuzzerEmulatorModel * model,
+        { model->title = "Mifare Fuzzer (emulator)"; },
+        true);
 
     return mifare_fuzzer_emulator;
 }
 
 /// @brief mifare_fuzzer_emulator_free
-/// @param context 
+/// @param context
 void mifare_fuzzer_emulator_free(MifareFuzzerEmulator* context) {
     //FURI_LOG_D(TAG, "mifare_fuzzer_emulator_free()");
     furi_assert(context);
@@ -195,23 +190,25 @@ void mifare_fuzzer_emulator_free(MifareFuzzerEmulator* context) {
 }
 
 /// @brief mifare_fuzzer_emulator_get_view
-/// @param mifare_fuzzer_emulator 
-/// @return 
+/// @param mifare_fuzzer_emulator
+/// @return
 View* mifare_fuzzer_emulator_get_view(MifareFuzzerEmulator* mifare_fuzzer_emulator) {
     furi_assert(mifare_fuzzer_emulator);
     return mifare_fuzzer_emulator->view;
 }
 
 /// @brief Set card type
-/// @param mifare_fuzzer_emulator 
-/// @param mifare_card 
-void mifare_fuzzer_emulator_set_card(MifareFuzzerEmulator* mifare_fuzzer_emulator, MifareCard mifare_card) {
+/// @param mifare_fuzzer_emulator
+/// @param mifare_card
+void mifare_fuzzer_emulator_set_card(
+    MifareFuzzerEmulator* mifare_fuzzer_emulator,
+    MifareCard mifare_card) {
     furi_assert(mifare_fuzzer_emulator);
     furi_assert(mifare_card);
 
     with_view_model(
         mifare_fuzzer_emulator->view,
-        MifareFuzzerEmulatorModel* model,
+        MifareFuzzerEmulatorModel * model,
         {
             model->mifare_card = mifare_card;
             switch(mifare_card) {
@@ -226,21 +223,21 @@ void mifare_fuzzer_emulator_set_card(MifareFuzzerEmulator* mifare_fuzzer_emulato
                 break;
             }
         },
-        true
-    );
-
+        true);
 }
 
 /// @brief Set attack type
-/// @param mifare_fuzzer_emulator 
-/// @param mifare_attack 
-void mifare_fuzzer_emulator_set_attack(MifareFuzzerEmulator* mifare_fuzzer_emulator, MifareFuzzerAttack mifare_attack) {
+/// @param mifare_fuzzer_emulator
+/// @param mifare_attack
+void mifare_fuzzer_emulator_set_attack(
+    MifareFuzzerEmulator* mifare_fuzzer_emulator,
+    MifareFuzzerAttack mifare_attack) {
     furi_assert(mifare_fuzzer_emulator);
     furi_assert(mifare_attack);
 
     with_view_model(
         mifare_fuzzer_emulator->view,
-        MifareFuzzerEmulatorModel* model,
+        MifareFuzzerEmulatorModel * model,
         {
             model->attack = mifare_attack;
             switch(mifare_attack) {
@@ -255,53 +252,50 @@ void mifare_fuzzer_emulator_set_attack(MifareFuzzerEmulator* mifare_fuzzer_emula
                 break;
             }
         },
-        true
-    );
-
+        true);
 }
 
 /// @brief mifare_fuzzer_emulator_set_nfc_dev_data
-/// @param mifare_fuzzer_emulator 
-/// @param nfc_dev_data 
-void mifare_fuzzer_emulator_set_nfc_dev_data(MifareFuzzerEmulator* mifare_fuzzer_emulator, FuriHalNfcDevData nfc_dev_data) {
+/// @param mifare_fuzzer_emulator
+/// @param nfc_dev_data
+void mifare_fuzzer_emulator_set_nfc_dev_data(
+    MifareFuzzerEmulator* mifare_fuzzer_emulator,
+    FuriHalNfcDevData nfc_dev_data) {
     furi_assert(mifare_fuzzer_emulator);
 
     with_view_model(
         mifare_fuzzer_emulator->view,
-        MifareFuzzerEmulatorModel* model,
-        {
-            model->nfc_dev_data = nfc_dev_data;
-        }, true
-    );
+        MifareFuzzerEmulatorModel * model,
+        { model->nfc_dev_data = nfc_dev_data; },
+        true);
 }
 
-
 /// @brief mifare_fuzzer_emulator_set_ticks_between_cards
-/// @param mifare_fuzzer_emulator 
-/// @param ticks 
-void mifare_fuzzer_emulator_set_ticks_between_cards(MifareFuzzerEmulator* mifare_fuzzer_emulator, uint8_t ticks) {
+/// @param mifare_fuzzer_emulator
+/// @param ticks
+void mifare_fuzzer_emulator_set_ticks_between_cards(
+    MifareFuzzerEmulator* mifare_fuzzer_emulator,
+    uint8_t ticks) {
     furi_assert(mifare_fuzzer_emulator);
 
     with_view_model(
         mifare_fuzzer_emulator->view,
-        MifareFuzzerEmulatorModel* model,
-        {
-            model->ticks_between_cards = ticks;
-        }, true
-    );
+        MifareFuzzerEmulatorModel * model,
+        { model->ticks_between_cards = ticks; },
+        true);
 }
 
 /// @brief mifare_fuzzer_emulator_set_tick_num
-/// @param mifare_fuzzer_emulator 
-/// @param tick_num 
-void mifare_fuzzer_emulator_set_tick_num(MifareFuzzerEmulator* mifare_fuzzer_emulator, uint8_t tick_num) {
+/// @param mifare_fuzzer_emulator
+/// @param tick_num
+void mifare_fuzzer_emulator_set_tick_num(
+    MifareFuzzerEmulator* mifare_fuzzer_emulator,
+    uint8_t tick_num) {
     furi_assert(mifare_fuzzer_emulator);
 
     with_view_model(
         mifare_fuzzer_emulator->view,
-        MifareFuzzerEmulatorModel* model,
-        {
-            model->tick_num = tick_num;
-        }, true
-    );
+        MifareFuzzerEmulatorModel * model,
+        { model->tick_num = tick_num; },
+        true);
 }

views/mifare_fuzzer_emulator.h

@@ -45,26 +45,26 @@ void mifare_fuzzer_emulator_free(MifareFuzzerEmulator* context);
 
 View* mifare_fuzzer_emulator_get_view(MifareFuzzerEmulator* context);
 
-void mifare_fuzzer_emulator_set_card(MifareFuzzerEmulator* mifare_fuzzer_emulator, MifareCard mifare_card);
-void mifare_fuzzer_emulator_set_attack(MifareFuzzerEmulator* mifare_fuzzer_emulator, MifareFuzzerAttack mifare_attack);
+void mifare_fuzzer_emulator_set_card(
+    MifareFuzzerEmulator* mifare_fuzzer_emulator,
+    MifareCard mifare_card);
+void mifare_fuzzer_emulator_set_attack(
+    MifareFuzzerEmulator* mifare_fuzzer_emulator,
+    MifareFuzzerAttack mifare_attack);
 
 void mifare_fuzzer_emulator_set_callback(
     MifareFuzzerEmulator* mifare_fuzzer_emulator,
     MifareFuzzerEmulatorCallback callback,
-    void* context
-);
+    void* context);
 
 void mifare_fuzzer_emulator_set_nfc_dev_data(
     MifareFuzzerEmulator* mifare_fuzzer_emulator,
-    FuriHalNfcDevData nfc_dev_data
-);
+    FuriHalNfcDevData nfc_dev_data);
 
 void mifare_fuzzer_emulator_set_ticks_between_cards(
     MifareFuzzerEmulator* mifare_fuzzer_emulator,
-    uint8_t ticks
-);
+    uint8_t ticks);
 
 void mifare_fuzzer_emulator_set_tick_num(
     MifareFuzzerEmulator* mifare_fuzzer_emulator,
-    uint8_t tick_num
-);
+    uint8_t tick_num);