Mifare Ultralight authentication (#1365)

* mifare ultralight auth prototype
* it works!
* Reference source
* use countof
* rework everything
* oops forgot scenes
* build: revert changes in manifest, stack size
* build: fix buid, format sources
* nfc: update unlock ultralight GUI
* nfc: fix byte input header
* nfc: add new scenes for locked ultralight
* nfc: add data read to ultralights
* nfc: add unlock option in mf ultralight menu
* nfc: add data read init in ultralight generation
* nfc: lin sources, fix unlocked save
* nfc: format python sources
* nfc: clean up

Co-authored-by: gornekich <n.gorbadey@gmail.com>

applications/nfc/scenes/nfc_scene_config.h

@@ -15,6 +15,11 @@ ADD_SCENE(nfc, emulate_uid, EmulateUid)
 ADD_SCENE(nfc, mf_ultralight_read_success, MfUltralightReadSuccess)
 ADD_SCENE(nfc, mf_ultralight_menu, MfUltralightMenu)
 ADD_SCENE(nfc, mf_ultralight_emulate, MfUltralightEmulate)
+ADD_SCENE(nfc, mf_ultralight_read_auth, MfUltralightReadAuth)
+ADD_SCENE(nfc, mf_ultralight_read_auth_result, MfUltralightReadAuthResult)
+ADD_SCENE(nfc, mf_ultralight_key_input, MfUltralightKeyInput)
+ADD_SCENE(nfc, mf_ultralight_unlock_menu, MfUltralightUnlockMenu)
+ADD_SCENE(nfc, mf_ultralight_unlock_warn, MfUltralightUnlockWarn)
 ADD_SCENE(nfc, mf_desfire_read_success, MfDesfireReadSuccess)
 ADD_SCENE(nfc, mf_desfire_menu, MfDesfireMenu)
 ADD_SCENE(nfc, mf_desfire_data, MfDesfireData)

applications/nfc/scenes/nfc_scene_extra_actions.c

@@ -2,6 +2,7 @@
 
 enum SubmenuIndex {
     SubmenuIndexMfClassicKeys,
+    SubmenuIndexMfUltralightUnlock,
 };
 
 void nfc_scene_extra_actions_submenu_callback(void* context, uint32_t index) {
@@ -20,6 +21,12 @@ void nfc_scene_extra_actions_on_enter(void* context) {
         SubmenuIndexMfClassicKeys,
         nfc_scene_extra_actions_submenu_callback,
         nfc);
+    submenu_add_item(
+        submenu,
+        "Unlock NTAG/Ultralight",
+        SubmenuIndexMfUltralightUnlock,
+        nfc_scene_extra_actions_submenu_callback,
+        nfc);
     view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
 }
 
@@ -35,6 +42,8 @@ bool nfc_scene_extra_actions_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
             }
             consumed = true;
+        } else if(event.event == SubmenuIndexMfUltralightUnlock) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
         }
         scene_manager_set_scene_state(nfc->scene_manager, NfcSceneExtraActions, event.event);
     }

applications/nfc/scenes/nfc_scene_mf_ultralight_key_input.c

@@ -0,0 +1,44 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mf_ultralight_key_input_byte_input_callback(void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+}
+
+void nfc_scene_mf_ultralight_key_input_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    ByteInput* byte_input = nfc->byte_input;
+    byte_input_set_header_text(byte_input, "Enter the password in hex");
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_scene_mf_ultralight_key_input_byte_input_callback,
+        NULL,
+        nfc,
+        nfc->byte_input_store,
+        4);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+}
+
+bool nfc_scene_mf_ultralight_key_input_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventByteInputDone) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockWarn);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_key_input_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(nfc->byte_input, "");
+}

applications/nfc/scenes/nfc_scene_mf_ultralight_menu.c

@@ -1,6 +1,7 @@
 #include "../nfc_i.h"
 
 enum SubmenuIndex {
+    SubmenuIndexUnlock,
     SubmenuIndexSave,
     SubmenuIndexEmulate,
 };
@@ -14,7 +15,16 @@ void nfc_scene_mf_ultralight_menu_submenu_callback(void* context, uint32_t index
 void nfc_scene_mf_ultralight_menu_on_enter(void* context) {
     Nfc* nfc = context;
     Submenu* submenu = nfc->submenu;
+    MfUltralightData* data = &nfc->dev->dev_data.mf_ul_data;
 
+    if(data->data_read != data->data_size) {
+        submenu_add_item(
+            submenu,
+            "Unlock With Password",
+            SubmenuIndexUnlock,
+            nfc_scene_mf_ultralight_menu_submenu_callback,
+            nfc);
+    }
     submenu_add_item(
         submenu, "Save", SubmenuIndexSave, nfc_scene_mf_ultralight_menu_submenu_callback, nfc);
     submenu_add_item(
@@ -35,19 +45,20 @@ bool nfc_scene_mf_ultralight_menu_on_event(void* context, SceneManagerEvent even
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexSave) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfUltralightMenu, SubmenuIndexSave);
             nfc->dev->format = NfcDeviceSaveFormatMifareUl;
             // Clear device name
             nfc_device_set_name(nfc->dev, "");
             scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
             consumed = true;
         } else if(event.event == SubmenuIndexEmulate) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfUltralightMenu, SubmenuIndexEmulate);
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
             consumed = true;
+        } else if(event.event == SubmenuIndexUnlock) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
+            consumed = true;
         }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfUltralightMenu, event.event);
+
     } else if(event.type == SceneManagerEventTypeBack) {
         consumed = scene_manager_previous_scene(nfc->scene_manager);
     }

applications/nfc/scenes/nfc_scene_mf_ultralight_read_auth.c

@@ -0,0 +1,107 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+typedef enum {
+    NfcSceneMfUlReadStateIdle,
+    NfcSceneMfUlReadStateDetecting,
+    NfcSceneMfUlReadStateReading,
+    NfcSceneMfUlReadStateNotSupportedCard,
+} NfcSceneMfUlReadState;
+
+bool nfc_scene_mf_ultralight_read_auth_worker_callback(NfcWorkerEvent event, void* context) {
+    Nfc* nfc = context;
+
+    if(event == NfcWorkerEventMfUltralightPassKey) {
+        memcpy(nfc->dev->dev_data.mf_ul_data.auth_key, nfc->byte_input_store, 4);
+    } else {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
+    }
+    return true;
+}
+
+void nfc_scene_mf_ultralight_read_auth_set_state(Nfc* nfc, NfcSceneMfUlReadState state) {
+    uint32_t curr_state =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightReadAuth);
+    if(curr_state != state) {
+        if(state == NfcSceneMfUlReadStateDetecting) {
+            popup_reset(nfc->popup);
+            popup_set_text(
+                nfc->popup, "Apply card to\nFlipper's back", 97, 24, AlignCenter, AlignTop);
+            popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual);
+        } else if(state == NfcSceneMfUlReadStateReading) {
+            popup_reset(nfc->popup);
+            popup_set_header(
+                nfc->popup, "Reading card\nDon't move...", 85, 24, AlignCenter, AlignTop);
+            popup_set_icon(nfc->popup, 12, 23, &A_Loading_24);
+        } else if(state == NfcSceneMfUlReadStateNotSupportedCard) {
+            popup_reset(nfc->popup);
+            popup_set_header(nfc->popup, "Wrong type of card!", 64, 3, AlignCenter, AlignTop);
+            popup_set_text(
+                nfc->popup,
+                "Only MIFARE\nUltralight & NTAG\n are supported",
+                4,
+                22,
+                AlignLeft,
+                AlignTop);
+            popup_set_icon(nfc->popup, 73, 17, &I_DolphinFirstStart8_56x51);
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfUltralightReadAuth, state);
+    }
+}
+
+void nfc_scene_mf_ultralight_read_auth_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcRead);
+
+    nfc_device_clear(nfc->dev);
+    // Setup view
+    nfc_scene_mf_ultralight_read_auth_set_state(nfc, NfcSceneMfUlReadStateDetecting);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    // Start worker
+    nfc_worker_start(
+        nfc->worker,
+        NfcWorkerStateReadMfUltralightReadAuth,
+        &nfc->dev->dev_data,
+        nfc_scene_mf_ultralight_read_auth_worker_callback,
+        nfc);
+
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_mf_ultralight_read_auth_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if((event.event == NfcWorkerEventSuccess) || (event.event == NfcWorkerEventFail)) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadAuthResult);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventCardDetected) {
+            nfc_scene_mf_ultralight_read_auth_set_state(nfc, NfcSceneMfUlReadStateReading);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventNoCardDetected) {
+            nfc_scene_mf_ultralight_read_auth_set_state(nfc, NfcSceneMfUlReadStateDetecting);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventWrongCardDetected) {
+            nfc_scene_mf_ultralight_read_auth_set_state(
+                nfc, NfcSceneMfUlReadStateNotSupportedCard);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_read_auth_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Stop worker
+    nfc_worker_stop(nfc->worker);
+    // Clear view
+    popup_reset(nfc->popup);
+    nfc_blink_stop(nfc);
+    scene_manager_set_scene_state(
+        nfc->scene_manager, NfcSceneMfUltralightReadAuth, NfcSceneMfUlReadStateIdle);
+}

applications/nfc/scenes/nfc_scene_mf_ultralight_read_auth_result.c

@@ -0,0 +1,98 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_mf_ultralight_read_auth_result_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    Nfc* nfc = context;
+
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_ultralight_read_auth_result_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+
+    // Setup dialog view
+    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
+    MfUltralightData* mf_ul_data = &nfc->dev->dev_data.mf_ul_data;
+    MfUltralightConfigPages* config_pages = mf_ultralight_get_config_pages(mf_ul_data);
+    Widget* widget = nfc->widget;
+    string_t temp_str;
+    string_init(temp_str);
+
+    if((mf_ul_data->data_read == mf_ul_data->data_size) && (mf_ul_data->data_read > 0)) {
+        widget_add_string_element(
+            widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "All pages are unlocked!");
+    } else {
+        widget_add_string_element(
+            widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Not all pages unlocked!");
+    }
+    string_set_str(temp_str, "UID:");
+    for(size_t i = 0; i < nfc_data->uid_len; i++) {
+        string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
+    }
+    widget_add_string_element(
+        widget, 0, 17, AlignLeft, AlignTop, FontSecondary, string_get_cstr(temp_str));
+    if(mf_ul_data->auth_success) {
+        string_printf(
+            temp_str,
+            "Password: %02X %02X %02X %02X",
+            config_pages->auth_data.pwd.raw[0],
+            config_pages->auth_data.pwd.raw[1],
+            config_pages->auth_data.pwd.raw[2],
+            config_pages->auth_data.pwd.raw[3]);
+        widget_add_string_element(
+            widget, 0, 28, AlignLeft, AlignTop, FontSecondary, string_get_cstr(temp_str));
+        string_printf(
+            temp_str,
+            "PACK: %02X %02X",
+            config_pages->auth_data.pack.raw[0],
+            config_pages->auth_data.pack.raw[1]);
+        widget_add_string_element(
+            widget, 0, 39, AlignLeft, AlignTop, FontSecondary, string_get_cstr(temp_str));
+    }
+    string_printf(
+        temp_str, "Pages Read: %d/%d", mf_ul_data->data_read / 4, mf_ul_data->data_size / 4);
+    widget_add_string_element(
+        widget, 0, 50, AlignLeft, AlignTop, FontSecondary, string_get_cstr(temp_str));
+    widget_add_button_element(
+        widget,
+        GuiButtonTypeRight,
+        "Save",
+        nfc_scene_mf_ultralight_read_auth_result_widget_callback,
+        nfc);
+
+    string_clear(temp_str);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_ultralight_read_auth_result_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeRight) {
+            nfc->dev->format = NfcDeviceSaveFormatMifareUl;
+            // Clear device name
+            nfc_device_set_name(nfc->dev, "");
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_read_auth_result_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean views
+    widget_reset(nfc->widget);
+}

applications/nfc/scenes/nfc_scene_mf_ultralight_read_success.c

@@ -1,51 +1,67 @@
 #include "../nfc_i.h"
 #include <dolphin/dolphin.h>
 
-#define NFC_SCENE_READ_SUCCESS_SHIFT "              "
-
 enum {
-    ReadMifareUlStateShowUID,
+    ReadMifareUlStateShowInfo,
     ReadMifareUlStateShowData,
 };
 
-void nfc_scene_mf_ultralight_read_success_dialog_callback(DialogExResult result, void* context) {
+void nfc_scene_mf_ultralight_read_success_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
     Nfc* nfc = context;
 
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+    }
 }
 
 void nfc_scene_mf_ultralight_read_success_on_enter(void* context) {
     Nfc* nfc = context;
     DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
 
-    // Setup dialog view
+    // Setup widget view
     FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
     MfUltralightData* mf_ul_data = &nfc->dev->dev_data.mf_ul_data;
-    DialogEx* dialog_ex = nfc->dialog_ex;
-    dialog_ex_set_left_button_text(dialog_ex, "Retry");
-    dialog_ex_set_right_button_text(dialog_ex, "More");
-    dialog_ex_set_center_button_text(dialog_ex, "Data");
-    dialog_ex_set_header(
-        dialog_ex, nfc_mf_ul_type(mf_ul_data->type, true), 64, 8, AlignCenter, AlignCenter);
-    dialog_ex_set_icon(dialog_ex, 8, 13, &I_Medium_chip_22x21);
-    // Display UID
-    nfc_text_store_set(
-        nfc,
-        NFC_SCENE_READ_SUCCESS_SHIFT "ATQA: %02X%02X\n" NFC_SCENE_READ_SUCCESS_SHIFT
-                                     "SAK: %02X\nUID: %02X %02X %02X %02X %02X %02X %02X",
-        data->atqa[0],
-        data->atqa[1],
-        data->sak,
-        data->uid[0],
-        data->uid[1],
-        data->uid[2],
-        data->uid[3],
-        data->uid[4],
-        data->uid[5],
-        data->uid[6]);
-    dialog_ex_set_text(dialog_ex, nfc->text_store, 8, 16, AlignLeft, AlignTop);
-    dialog_ex_set_context(dialog_ex, nfc);
-    dialog_ex_set_result_callback(dialog_ex, nfc_scene_mf_ultralight_read_success_dialog_callback);
+    Widget* widget = nfc->widget;
+    widget_add_button_element(
+        widget,
+        GuiButtonTypeLeft,
+        "Retry",
+        nfc_scene_mf_ultralight_read_success_widget_callback,
+        nfc);
+    widget_add_button_element(
+        widget,
+        GuiButtonTypeCenter,
+        "Data",
+        nfc_scene_mf_ultralight_read_success_widget_callback,
+        nfc);
+    widget_add_button_element(
+        widget,
+        GuiButtonTypeRight,
+        "More",
+        nfc_scene_mf_ultralight_read_success_widget_callback,
+        nfc);
+
+    widget_add_string_element(
+        widget, 0, 0, AlignLeft, AlignTop, FontSecondary, nfc_mf_ul_type(mf_ul_data->type, true));
+    string_t data_str;
+    string_init_printf(data_str, "UID:");
+    for(size_t i = 0; i < data->uid_len; i++) {
+        string_cat_printf(data_str, " %02X", data->uid[i]);
+    }
+    widget_add_string_element(
+        widget, 0, 13, AlignLeft, AlignTop, FontSecondary, string_get_cstr(data_str));
+    string_printf(
+        data_str, "Pages Read: %d/%d", mf_ul_data->data_read / 4, mf_ul_data->data_size / 4);
+    widget_add_string_element(
+        widget, 0, 24, AlignLeft, AlignTop, FontSecondary, string_get_cstr(data_str));
+    if(mf_ul_data->data_read != mf_ul_data->data_size) {
+        widget_add_string_element(
+            widget, 0, 35, AlignLeft, AlignTop, FontSecondary, "Password-protected pages!");
+    }
+    string_clear(data_str);
 
     // Setup TextBox view
     TextBox* text_box = nfc->text_box;
@@ -60,8 +76,8 @@ void nfc_scene_mf_ultralight_read_success_on_enter(void* context) {
     text_box_set_text(text_box, string_get_cstr(nfc->text_box_store));
 
     scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfUltralightReadSuccess, ReadMifareUlStateShowUID);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+        nfc->scene_manager, NfcSceneMfUltralightReadSuccess, ReadMifareUlStateShowInfo);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
 }
 
 bool nfc_scene_mf_ultralight_read_success_on_event(void* context, SceneManagerEvent event) {
@@ -71,13 +87,13 @@ bool nfc_scene_mf_ultralight_read_success_on_event(void* context, SceneManagerEv
         scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightReadSuccess);
 
     if(event.type == SceneManagerEventTypeCustom) {
-        if(state == ReadMifareUlStateShowUID && event.event == DialogExResultLeft) {
+        if(state == ReadMifareUlStateShowInfo && event.event == GuiButtonTypeLeft) {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
             consumed = true;
-        } else if(state == ReadMifareUlStateShowUID && event.event == DialogExResultRight) {
+        } else if(state == ReadMifareUlStateShowInfo && event.event == GuiButtonTypeRight) {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightMenu);
             consumed = true;
-        } else if(state == ReadMifareUlStateShowUID && event.event == DialogExResultCenter) {
+        } else if(state == ReadMifareUlStateShowInfo && event.event == GuiButtonTypeCenter) {
             view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
             scene_manager_set_scene_state(
                 nfc->scene_manager, NfcSceneMfUltralightReadSuccess, ReadMifareUlStateShowData);
@@ -85,9 +101,9 @@ bool nfc_scene_mf_ultralight_read_success_on_event(void* context, SceneManagerEv
         }
     } else if(event.type == SceneManagerEventTypeBack) {
         if(state == ReadMifareUlStateShowData) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
             scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfUltralightReadSuccess, ReadMifareUlStateShowUID);
+                nfc->scene_manager, NfcSceneMfUltralightReadSuccess, ReadMifareUlStateShowInfo);
             consumed = true;
         } else {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
@@ -102,7 +118,7 @@ void nfc_scene_mf_ultralight_read_success_on_exit(void* context) {
     Nfc* nfc = context;
 
     // Clean views
-    dialog_ex_reset(nfc->dialog_ex);
+    widget_reset(nfc->widget);
     text_box_reset(nfc->text_box);
     string_reset(nfc->text_box_store);
 }

applications/nfc/scenes/nfc_scene_mf_ultralight_unlock_menu.c

@@ -0,0 +1,70 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexMfUlUnlockMenuManual,
+    SubmenuIndexMfUlUnlockMenuAmeebo,
+    SubmenuIndexMfUlUnlockMenuXiaomi,
+};
+
+void nfc_scene_mf_ultralight_unlock_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_mf_ultralight_unlock_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    uint32_t state =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
+    submenu_add_item(
+        submenu,
+        "Enter Password Manually",
+        SubmenuIndexMfUlUnlockMenuManual,
+        nfc_scene_mf_ultralight_unlock_menu_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu,
+        "Auth As Ameebo",
+        SubmenuIndexMfUlUnlockMenuAmeebo,
+        nfc_scene_mf_ultralight_unlock_menu_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu,
+        "Auth As Xiaomi",
+        SubmenuIndexMfUlUnlockMenuXiaomi,
+        nfc_scene_mf_ultralight_unlock_menu_submenu_callback,
+        nfc);
+    submenu_set_selected_item(submenu, state);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_ultralight_unlock_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexMfUlUnlockMenuManual) {
+            nfc->dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodManual;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightKeyInput);
+            consumed = true;
+        } else if(event.event == SubmenuIndexMfUlUnlockMenuAmeebo) {
+            nfc->dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodAmeebo;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockWarn);
+            consumed = true;
+        } else if(event.event == SubmenuIndexMfUlUnlockMenuXiaomi) {
+            nfc->dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodXiaomi;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockWarn);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneExtraActions, event.event);
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_unlock_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/nfc/scenes/nfc_scene_mf_ultralight_unlock_warn.c

@@ -0,0 +1,45 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mf_ultralight_unlock_warn_dialog_callback(DialogExResult result, void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+}
+
+void nfc_scene_mf_ultralight_unlock_warn_on_enter(void* context) {
+    Nfc* nfc = context;
+    DialogEx* dialog_ex = nfc->dialog_ex;
+
+    dialog_ex_set_context(dialog_ex, nfc);
+    dialog_ex_set_result_callback(dialog_ex, nfc_scene_mf_ultralight_unlock_warn_dialog_callback);
+
+    dialog_ex_set_header(dialog_ex, "Risky function!", 64, 4, AlignCenter, AlignTop);
+    dialog_ex_set_text(
+        dialog_ex, "Wrong password\ncan block your\ncard.", 4, 18, AlignLeft, AlignTop);
+    dialog_ex_set_icon(dialog_ex, 73, 17, &I_DolphinFirstStart8_56x51);
+    dialog_ex_set_center_button_text(dialog_ex, "OK");
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+}
+
+bool nfc_scene_mf_ultralight_unlock_warn_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == DialogExResultCenter) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadAuth);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_unlock_warn_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    dialog_ex_reset(nfc->dialog_ex);
+    submenu_reset(nfc->submenu);
+}