NFC: Add support for Gen4 "ultimate card" in Magic app (#2238)

* NFC: gen4 gtu detect in magic app
* NFC: more support for GTU card
* NFC: Fix Gen1 in Magic
* Allow double UIDs for MFClassic on GTU cards
* NFC: Small magic app tweaks
* nfc magic: notify card event on wiping
* nfc magic: fix power consumption
* nfc magic: disable i2c writing and fix wipe loop
* NfcMagic: correct formatting in printf
* NfcMagic: correct formatting in printf, proper version
* nfc_magic: rework card found notification and gen4 wiping

Co-authored-by: あく <alleteam@gmail.com>

applications/external/nfc_magic/scenes/nfc_magic_scene_actions.c

@@ -0,0 +1,50 @@
+#include "../nfc_magic_i.h"
+enum SubmenuIndex {
+    SubmenuIndexWrite,
+    SubmenuIndexWipe,
+};
+
+void nfc_magic_scene_actions_submenu_callback(void* context, uint32_t index) {
+    NfcMagic* nfc_magic = context;
+    view_dispatcher_send_custom_event(nfc_magic->view_dispatcher, index);
+}
+
+void nfc_magic_scene_actions_on_enter(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    Submenu* submenu = nfc_magic->submenu;
+    submenu_add_item(
+        submenu, "Write", SubmenuIndexWrite, nfc_magic_scene_actions_submenu_callback, nfc_magic);
+    submenu_add_item(
+        submenu, "Wipe", SubmenuIndexWipe, nfc_magic_scene_actions_submenu_callback, nfc_magic);
+
+    submenu_set_selected_item(
+        submenu, scene_manager_get_scene_state(nfc_magic->scene_manager, NfcMagicSceneActions));
+    view_dispatcher_switch_to_view(nfc_magic->view_dispatcher, NfcMagicViewMenu);
+}
+
+bool nfc_magic_scene_actions_on_event(void* context, SceneManagerEvent event) {
+    NfcMagic* nfc_magic = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexWrite) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneFileSelect);
+            consumed = true;
+        } else if(event.event == SubmenuIndexWipe) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneWipe);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(nfc_magic->scene_manager, NfcMagicSceneActions, event.event);
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            nfc_magic->scene_manager, NfcMagicSceneStart);
+    }
+
+    return consumed;
+}
+
+void nfc_magic_scene_actions_on_exit(void* context) {
+    NfcMagic* nfc_magic = context;
+    submenu_reset(nfc_magic->submenu);
+}

applications/external/nfc_magic/scenes/nfc_magic_scene_check.c

@@ -42,7 +42,9 @@ void nfc_magic_scene_check_on_enter(void* context) {
     nfc_magic_worker_start(
         nfc_magic->worker,
         NfcMagicWorkerStateCheck,
-        &nfc_magic->nfc_dev->dev_data,
+        nfc_magic->dev,
+        &nfc_magic->source_dev->dev_data,
+        nfc_magic->new_password,
         nfc_magic_check_worker_callback,
         nfc_magic);
     nfc_magic_blink_start(nfc_magic);

applications/external/nfc_magic/scenes/nfc_magic_scene_config.h

@@ -1,4 +1,8 @@
 ADD_SCENE(nfc_magic, start, Start)
+ADD_SCENE(nfc_magic, key_input, KeyInput)
+ADD_SCENE(nfc_magic, actions, Actions)
+ADD_SCENE(nfc_magic, gen4_actions, Gen4Actions)
+ADD_SCENE(nfc_magic, new_key_input, NewKeyInput)
 ADD_SCENE(nfc_magic, file_select, FileSelect)
 ADD_SCENE(nfc_magic, write_confirm, WriteConfirm)
 ADD_SCENE(nfc_magic, wrong_card, WrongCard)
@@ -8,5 +12,7 @@ ADD_SCENE(nfc_magic, success, Success)
 ADD_SCENE(nfc_magic, check, Check)
 ADD_SCENE(nfc_magic, not_magic, NotMagic)
 ADD_SCENE(nfc_magic, magic_info, MagicInfo)
+ADD_SCENE(nfc_magic, rekey, Rekey)
+ADD_SCENE(nfc_magic, rekey_fail, RekeyFail)
 ADD_SCENE(nfc_magic, wipe, Wipe)
 ADD_SCENE(nfc_magic, wipe_fail, WipeFail)

applications/external/nfc_magic/scenes/nfc_magic_scene_file_select.c

@@ -1,22 +1,60 @@
 #include "../nfc_magic_i.h"
 
-static bool nfc_magic_scene_file_select_is_file_suitable(NfcDevice* nfc_dev) {
-    return (nfc_dev->format == NfcDeviceSaveFormatMifareClassic) &&
-           (nfc_dev->dev_data.mf_classic_data.type == MfClassicType1k) &&
-           (nfc_dev->dev_data.nfc_data.uid_len == 4);
+static bool nfc_magic_scene_file_select_is_file_suitable(NfcMagic* nfc_magic) {
+    NfcDevice* nfc_dev = nfc_magic->source_dev;
+    if(nfc_dev->format == NfcDeviceSaveFormatMifareClassic) {
+        switch(nfc_magic->dev->type) {
+        case MagicTypeClassicGen1:
+        case MagicTypeClassicDirectWrite:
+        case MagicTypeClassicAPDU:
+            if((nfc_dev->dev_data.mf_classic_data.type != MfClassicType1k) ||
+               (nfc_dev->dev_data.nfc_data.uid_len != 4)) {
+                return false;
+            }
+            return true;
+
+        case MagicTypeGen4:
+            return true;
+        default:
+            return false;
+        }
+    } else if(
+        (nfc_dev->format == NfcDeviceSaveFormatMifareUl) &&
+        (nfc_dev->dev_data.nfc_data.uid_len == 7)) {
+        switch(nfc_magic->dev->type) {
+        case MagicTypeUltralightGen1:
+        case MagicTypeUltralightDirectWrite:
+        case MagicTypeUltralightC_Gen1:
+        case MagicTypeUltralightC_DirectWrite:
+        case MagicTypeGen4:
+            switch(nfc_dev->dev_data.mf_ul_data.type) {
+            case MfUltralightTypeNTAGI2C1K:
+            case MfUltralightTypeNTAGI2C2K:
+            case MfUltralightTypeNTAGI2CPlus1K:
+            case MfUltralightTypeNTAGI2CPlus2K:
+                return false;
+            default:
+                return true;
+            }
+        default:
+            return false;
+        }
+    }
+
+    return false;
 }
 
 void nfc_magic_scene_file_select_on_enter(void* context) {
     NfcMagic* nfc_magic = context;
     // Process file_select return
-    nfc_device_set_loading_callback(nfc_magic->nfc_dev, nfc_magic_show_loading_popup, nfc_magic);
+    nfc_device_set_loading_callback(
+        nfc_magic->source_dev, nfc_magic_show_loading_popup, nfc_magic);
 
-    if(!furi_string_size(nfc_magic->nfc_dev->load_path)) {
-        furi_string_set_str(nfc_magic->nfc_dev->load_path, NFC_APP_FOLDER);
+    if(!furi_string_size(nfc_magic->source_dev->load_path)) {
+        furi_string_set_str(nfc_magic->source_dev->load_path, NFC_APP_FOLDER);
     }
-
-    if(nfc_file_select(nfc_magic->nfc_dev)) {
-        if(nfc_magic_scene_file_select_is_file_suitable(nfc_magic->nfc_dev)) {
+    if(nfc_file_select(nfc_magic->source_dev)) {
+        if(nfc_magic_scene_file_select_is_file_suitable(nfc_magic)) {
             scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneWriteConfirm);
         } else {
             scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneWrongCard);
@@ -34,5 +72,5 @@ bool nfc_magic_scene_file_select_on_event(void* context, SceneManagerEvent event
 
 void nfc_magic_scene_file_select_on_exit(void* context) {
     NfcMagic* nfc_magic = context;
-    nfc_device_set_loading_callback(nfc_magic->nfc_dev, NULL, nfc_magic);
+    nfc_device_set_loading_callback(nfc_magic->source_dev, NULL, nfc_magic);
 }

applications/external/nfc_magic/scenes/nfc_magic_scene_gen4_actions.c

@@ -0,0 +1,70 @@
+#include "../nfc_magic_i.h"
+enum SubmenuIndex {
+    SubmenuIndexWrite,
+    SubmenuIndexChangePassword,
+    SubmenuIndexWipe,
+};
+
+void nfc_magic_scene_gen4_actions_submenu_callback(void* context, uint32_t index) {
+    NfcMagic* nfc_magic = context;
+    view_dispatcher_send_custom_event(nfc_magic->view_dispatcher, index);
+}
+
+void nfc_magic_scene_gen4_actions_on_enter(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    Submenu* submenu = nfc_magic->submenu;
+    submenu_add_item(
+        submenu,
+        "Write",
+        SubmenuIndexWrite,
+        nfc_magic_scene_gen4_actions_submenu_callback,
+        nfc_magic);
+    submenu_add_item(
+        submenu,
+        "Change password",
+        SubmenuIndexChangePassword,
+        nfc_magic_scene_gen4_actions_submenu_callback,
+        nfc_magic);
+    submenu_add_item(
+        submenu,
+        "Wipe",
+        SubmenuIndexWipe,
+        nfc_magic_scene_gen4_actions_submenu_callback,
+        nfc_magic);
+
+    submenu_set_selected_item(
+        submenu,
+        scene_manager_get_scene_state(nfc_magic->scene_manager, NfcMagicSceneGen4Actions));
+    view_dispatcher_switch_to_view(nfc_magic->view_dispatcher, NfcMagicViewMenu);
+}
+
+bool nfc_magic_scene_gen4_actions_on_event(void* context, SceneManagerEvent event) {
+    NfcMagic* nfc_magic = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexWrite) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneFileSelect);
+            consumed = true;
+        } else if(event.event == SubmenuIndexChangePassword) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneNewKeyInput);
+            consumed = true;
+        } else if(event.event == SubmenuIndexWipe) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneWipe);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(
+            nfc_magic->scene_manager, NfcMagicSceneGen4Actions, event.event);
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            nfc_magic->scene_manager, NfcMagicSceneStart);
+    }
+
+    return consumed;
+}
+
+void nfc_magic_scene_gen4_actions_on_exit(void* context) {
+    NfcMagic* nfc_magic = context;
+    submenu_reset(nfc_magic->submenu);
+}

applications/external/nfc_magic/scenes/nfc_magic_scene_key_input.c

@@ -0,0 +1,45 @@
+#include "../nfc_magic_i.h"
+
+void nfc_magic_scene_key_input_byte_input_callback(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    view_dispatcher_send_custom_event(
+        nfc_magic->view_dispatcher, NfcMagicCustomEventByteInputDone);
+}
+
+void nfc_magic_scene_key_input_on_enter(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    // Setup view
+    ByteInput* byte_input = nfc_magic->byte_input;
+    byte_input_set_header_text(byte_input, "Enter the password in hex");
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_magic_scene_key_input_byte_input_callback,
+        NULL,
+        nfc_magic,
+        (uint8_t*)&nfc_magic->dev->password,
+        4);
+    view_dispatcher_switch_to_view(nfc_magic->view_dispatcher, NfcMagicViewByteInput);
+}
+
+bool nfc_magic_scene_key_input_on_event(void* context, SceneManagerEvent event) {
+    NfcMagic* nfc_magic = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcMagicCustomEventByteInputDone) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneCheck);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_magic_scene_key_input_on_exit(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    // Clear view
+    byte_input_set_result_callback(nfc_magic->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(nfc_magic->byte_input, "");
+}

applications/external/nfc_magic/scenes/nfc_magic_scene_magic_info.c

@@ -1,4 +1,5 @@
 #include "../nfc_magic_i.h"
+#include "../lib/magic/types.h"
 
 void nfc_magic_scene_magic_info_widget_callback(
     GuiButtonType result,
@@ -13,14 +14,18 @@ void nfc_magic_scene_magic_info_widget_callback(
 void nfc_magic_scene_magic_info_on_enter(void* context) {
     NfcMagic* nfc_magic = context;
     Widget* widget = nfc_magic->widget;
+    const char* card_type = nfc_magic_type(nfc_magic->dev->type);
 
     notification_message(nfc_magic->notifications, &sequence_success);
 
     widget_add_icon_element(widget, 73, 17, &I_DolphinCommon_56x48);
     widget_add_string_element(
         widget, 3, 4, AlignLeft, AlignTop, FontPrimary, "Magic card detected");
+    widget_add_string_element(widget, 3, 17, AlignLeft, AlignTop, FontSecondary, card_type);
     widget_add_button_element(
         widget, GuiButtonTypeLeft, "Retry", nfc_magic_scene_magic_info_widget_callback, nfc_magic);
+    widget_add_button_element(
+        widget, GuiButtonTypeRight, "More", nfc_magic_scene_magic_info_widget_callback, nfc_magic);
 
     // Setup and start worker
     view_dispatcher_switch_to_view(nfc_magic->view_dispatcher, NfcMagicViewWidget);
@@ -33,6 +38,15 @@ bool nfc_magic_scene_magic_info_on_event(void* context, SceneManagerEvent event)
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == GuiButtonTypeLeft) {
             consumed = scene_manager_previous_scene(nfc_magic->scene_manager);
+        } else if(event.event == GuiButtonTypeRight) {
+            MagicType type = nfc_magic->dev->type;
+            if(type == MagicTypeGen4) {
+                scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneGen4Actions);
+                consumed = true;
+            } else {
+                scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneActions);
+                consumed = true;
+            }
         }
     }
     return consumed;

applications/external/nfc_magic/scenes/nfc_magic_scene_new_key_input.c

@@ -0,0 +1,45 @@
+#include "../nfc_magic_i.h"
+
+void nfc_magic_scene_new_key_input_byte_input_callback(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    view_dispatcher_send_custom_event(
+        nfc_magic->view_dispatcher, NfcMagicCustomEventByteInputDone);
+}
+
+void nfc_magic_scene_new_key_input_on_enter(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    // Setup view
+    ByteInput* byte_input = nfc_magic->byte_input;
+    byte_input_set_header_text(byte_input, "Enter the password in hex");
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_magic_scene_new_key_input_byte_input_callback,
+        NULL,
+        nfc_magic,
+        (uint8_t*)&nfc_magic->new_password,
+        4);
+    view_dispatcher_switch_to_view(nfc_magic->view_dispatcher, NfcMagicViewByteInput);
+}
+
+bool nfc_magic_scene_new_key_input_on_event(void* context, SceneManagerEvent event) {
+    NfcMagic* nfc_magic = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcMagicCustomEventByteInputDone) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneRekey);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_magic_scene_new_key_input_on_exit(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    // Clear view
+    byte_input_set_result_callback(nfc_magic->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(nfc_magic->byte_input, "");
+}

applications/external/nfc_magic/scenes/nfc_magic_scene_rekey.c

@@ -0,0 +1,95 @@
+#include "../nfc_magic_i.h"
+
+enum {
+    NfcMagicSceneRekeyStateCardSearch,
+    NfcMagicSceneRekeyStateCardFound,
+};
+
+bool nfc_magic_rekey_worker_callback(NfcMagicWorkerEvent event, void* context) {
+    furi_assert(context);
+
+    NfcMagic* nfc_magic = context;
+    view_dispatcher_send_custom_event(nfc_magic->view_dispatcher, event);
+
+    return true;
+}
+
+static void nfc_magic_scene_rekey_setup_view(NfcMagic* nfc_magic) {
+    Popup* popup = nfc_magic->popup;
+    popup_reset(popup);
+    uint32_t state = scene_manager_get_scene_state(nfc_magic->scene_manager, NfcMagicSceneRekey);
+
+    if(state == NfcMagicSceneRekeyStateCardSearch) {
+        popup_set_text(
+            nfc_magic->popup,
+            "Apply the\nsame card\nto the back",
+            128,
+            32,
+            AlignRight,
+            AlignCenter);
+        popup_set_icon(nfc_magic->popup, 0, 8, &I_NFC_manual_60x50);
+    } else {
+        popup_set_icon(popup, 12, 23, &I_Loading_24);
+        popup_set_header(popup, "Writing\nDon't move...", 52, 32, AlignLeft, AlignCenter);
+    }
+
+    view_dispatcher_switch_to_view(nfc_magic->view_dispatcher, NfcMagicViewPopup);
+}
+
+void nfc_magic_scene_rekey_on_enter(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    scene_manager_set_scene_state(
+        nfc_magic->scene_manager, NfcMagicSceneRekey, NfcMagicSceneRekeyStateCardSearch);
+    nfc_magic_scene_rekey_setup_view(nfc_magic);
+
+    // Setup and start worker
+    nfc_magic_worker_start(
+        nfc_magic->worker,
+        NfcMagicWorkerStateRekey,
+        nfc_magic->dev,
+        &nfc_magic->source_dev->dev_data,
+        nfc_magic->new_password,
+        nfc_magic_rekey_worker_callback,
+        nfc_magic);
+    nfc_magic_blink_start(nfc_magic);
+}
+
+bool nfc_magic_scene_rekey_on_event(void* context, SceneManagerEvent event) {
+    NfcMagic* nfc_magic = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcMagicWorkerEventSuccess) {
+            nfc_magic->dev->password = nfc_magic->new_password;
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneSuccess);
+            consumed = true;
+        } else if(event.event == NfcMagicWorkerEventFail) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneRekeyFail);
+            consumed = true;
+        } else if(event.event == NfcMagicWorkerEventCardDetected) {
+            scene_manager_set_scene_state(
+                nfc_magic->scene_manager, NfcMagicSceneRekey, NfcMagicSceneRekeyStateCardFound);
+            nfc_magic_scene_rekey_setup_view(nfc_magic);
+            consumed = true;
+        } else if(event.event == NfcMagicWorkerEventNoCardDetected) {
+            scene_manager_set_scene_state(
+                nfc_magic->scene_manager, NfcMagicSceneRekey, NfcMagicSceneRekeyStateCardSearch);
+            nfc_magic_scene_rekey_setup_view(nfc_magic);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_magic_scene_rekey_on_exit(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    nfc_magic_worker_stop(nfc_magic->worker);
+    scene_manager_set_scene_state(
+        nfc_magic->scene_manager, NfcMagicSceneRekey, NfcMagicSceneRekeyStateCardSearch);
+    // Clear view
+    popup_reset(nfc_magic->popup);
+
+    nfc_magic_blink_stop(nfc_magic);
+}

applications/external/nfc_magic/scenes/nfc_magic_scene_rekey_fail.c

@@ -0,0 +1,50 @@
+#include "../nfc_magic_i.h"
+
+void nfc_magic_scene_rekey_fail_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcMagic* nfc_magic = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(nfc_magic->view_dispatcher, result);
+    }
+}
+
+void nfc_magic_scene_rekey_fail_on_enter(void* context) {
+    NfcMagic* nfc_magic = context;
+    Widget* widget = nfc_magic->widget;
+
+    notification_message(nfc_magic->notifications, &sequence_error);
+
+    widget_add_icon_element(widget, 72, 17, &I_DolphinCommon_56x48);
+    widget_add_string_element(
+        widget, 7, 4, AlignLeft, AlignTop, FontPrimary, "Can't change password!");
+
+    widget_add_button_element(
+        widget, GuiButtonTypeLeft, "Finish", nfc_magic_scene_rekey_fail_widget_callback, nfc_magic);
+
+    // Setup and start worker
+    view_dispatcher_switch_to_view(nfc_magic->view_dispatcher, NfcMagicViewWidget);
+}
+
+bool nfc_magic_scene_rekey_fail_on_event(void* context, SceneManagerEvent event) {
+    NfcMagic* nfc_magic = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                nfc_magic->scene_manager, NfcMagicSceneStart);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            nfc_magic->scene_manager, NfcMagicSceneStart);
+    }
+    return consumed;
+}
+
+void nfc_magic_scene_rekey_fail_on_exit(void* context) {
+    NfcMagic* nfc_magic = context;
+
+    widget_reset(nfc_magic->widget);
+}

applications/external/nfc_magic/scenes/nfc_magic_scene_start.c

@@ -1,8 +1,7 @@
 #include "../nfc_magic_i.h"
 enum SubmenuIndex {
     SubmenuIndexCheck,
-    SubmenuIndexWriteGen1A,
-    SubmenuIndexWipe,
+    SubmenuIndexAuthenticateGen4,
 };
 
 void nfc_magic_scene_start_submenu_callback(void* context, uint32_t index) {
@@ -22,12 +21,10 @@ void nfc_magic_scene_start_on_enter(void* context) {
         nfc_magic);
     submenu_add_item(
         submenu,
-        "Write Gen1A",
-        SubmenuIndexWriteGen1A,
+        "Authenticate Gen4",
+        SubmenuIndexAuthenticateGen4,
         nfc_magic_scene_start_submenu_callback,
         nfc_magic);
-    submenu_add_item(
-        submenu, "Wipe", SubmenuIndexWipe, nfc_magic_scene_start_submenu_callback, nfc_magic);
 
     submenu_set_selected_item(
         submenu, scene_manager_get_scene_state(nfc_magic->scene_manager, NfcMagicSceneStart));
@@ -40,23 +37,13 @@ bool nfc_magic_scene_start_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexCheck) {
+            nfc_magic->dev->password = MAGIC_GEN4_DEFAULT_PWD;
             scene_manager_set_scene_state(
                 nfc_magic->scene_manager, NfcMagicSceneStart, SubmenuIndexCheck);
             scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneCheck);
             consumed = true;
-        } else if(event.event == SubmenuIndexWriteGen1A) {
-            // Explicitly save state in each branch so that the
-            // correct option is reselected if the user cancels
-            // loading a file.
-            scene_manager_set_scene_state(
-                nfc_magic->scene_manager, NfcMagicSceneStart, SubmenuIndexWriteGen1A);
-            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneFileSelect);
-            consumed = true;
-        } else if(event.event == SubmenuIndexWipe) {
-            scene_manager_set_scene_state(
-                nfc_magic->scene_manager, NfcMagicSceneStart, SubmenuIndexWipe);
-            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneWipe);
-            consumed = true;
+        } else if(event.event == SubmenuIndexAuthenticateGen4) {
+            scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneKeyInput);
         }
     }
 

applications/external/nfc_magic/scenes/nfc_magic_scene_wipe.c

@@ -22,7 +22,12 @@ static void nfc_magic_scene_wipe_setup_view(NfcMagic* nfc_magic) {
     if(state == NfcMagicSceneWipeStateCardSearch) {
         popup_set_icon(nfc_magic->popup, 0, 8, &I_NFC_manual_60x50);
         popup_set_text(
-            nfc_magic->popup, "Apply card to\nthe back", 128, 32, AlignRight, AlignCenter);
+            nfc_magic->popup,
+            "Apply the\nsame card\nto the back",
+            128,
+            32,
+            AlignRight,
+            AlignCenter);
     } else {
         popup_set_icon(popup, 12, 23, &I_Loading_24);
         popup_set_header(popup, "Wiping\nDon't move...", 52, 32, AlignLeft, AlignCenter);
@@ -42,7 +47,9 @@ void nfc_magic_scene_wipe_on_enter(void* context) {
     nfc_magic_worker_start(
         nfc_magic->worker,
         NfcMagicWorkerStateWipe,
-        &nfc_magic->nfc_dev->dev_data,
+        nfc_magic->dev,
+        &nfc_magic->source_dev->dev_data,
+        nfc_magic->new_password,
         nfc_magic_wipe_worker_callback,
         nfc_magic);
     nfc_magic_blink_start(nfc_magic);

applications/external/nfc_magic/scenes/nfc_magic_scene_write.c

@@ -21,7 +21,12 @@ static void nfc_magic_scene_write_setup_view(NfcMagic* nfc_magic) {
 
     if(state == NfcMagicSceneWriteStateCardSearch) {
         popup_set_text(
-            nfc_magic->popup, "Apply card to\nthe back", 128, 32, AlignRight, AlignCenter);
+            nfc_magic->popup,
+            "Apply the\nsame card\nto the back",
+            128,
+            32,
+            AlignRight,
+            AlignCenter);
         popup_set_icon(nfc_magic->popup, 0, 8, &I_NFC_manual_60x50);
     } else {
         popup_set_icon(popup, 12, 23, &I_Loading_24);
@@ -42,7 +47,9 @@ void nfc_magic_scene_write_on_enter(void* context) {
     nfc_magic_worker_start(
         nfc_magic->worker,
         NfcMagicWorkerStateWrite,
-        &nfc_magic->nfc_dev->dev_data,
+        nfc_magic->dev,
+        &nfc_magic->source_dev->dev_data,
+        nfc_magic->new_password,
         nfc_magic_write_worker_callback,
         nfc_magic);
     nfc_magic_blink_start(nfc_magic);

applications/external/nfc_magic/scenes/nfc_magic_scene_wrong_card.c

@@ -26,7 +26,7 @@ void nfc_magic_scene_wrong_card_on_enter(void* context) {
         AlignLeft,
         AlignTop,
         FontSecondary,
-        "Writing is supported\nonly for 4 bytes UID\nMifare Classic 1k");
+        "Writing this file is\nnot supported for\nthis magic card.");
     widget_add_button_element(
         widget, GuiButtonTypeLeft, "Retry", nfc_magic_scene_wrong_card_widget_callback, nfc_magic);