merge ofw pr 4271

also thanks WillyJL
link to PR
https://github.com/flipperdevices/flipperzero-firmware/pull/4271/files

applications/main/nfc/scenes/nfc_scene_config.h

@@ -26,6 +26,7 @@ ADD_SCENE(nfc, retry_confirm, RetryConfirm)
 ADD_SCENE(nfc, exit_confirm, ExitConfirm)
 ADD_SCENE(nfc, save_confirm, SaveConfirm)
 
+ADD_SCENE(nfc, mf_ultralight_c_dict_attack, MfUltralightCDictAttack)
 ADD_SCENE(nfc, mf_ultralight_unlock_menu, MfUltralightUnlockMenu)
 ADD_SCENE(nfc, mf_ultralight_unlock_warn, MfUltralightUnlockWarn)
 ADD_SCENE(nfc, mf_ultralight_key_input, MfUltralightKeyInput)
@@ -52,6 +53,12 @@ ADD_SCENE(nfc, mf_classic_keys_delete, MfClassicKeysDelete)
 ADD_SCENE(nfc, mf_classic_keys_add, MfClassicKeysAdd)
 ADD_SCENE(nfc, mf_classic_keys_warn_duplicate, MfClassicKeysWarnDuplicate)
 
+ADD_SCENE(nfc, mf_ultralight_c_keys, MfUltralightCKeys)
+ADD_SCENE(nfc, mf_ultralight_c_keys_list, MfUltralightCKeysList)
+ADD_SCENE(nfc, mf_ultralight_c_keys_delete, MfUltralightCKeysDelete)
+ADD_SCENE(nfc, mf_ultralight_c_keys_add, MfUltralightCKeysAdd)
+ADD_SCENE(nfc, mf_ultralight_c_keys_warn_duplicate, MfUltralightCKeysWarnDuplicate)
+
 ADD_SCENE(nfc, set_type, SetType)
 ADD_SCENE(nfc, set_sak, SetSak)
 ADD_SCENE(nfc, set_atqa, SetAtqa)

applications/main/nfc/scenes/nfc_scene_delete_success.c

@@ -28,6 +28,10 @@ bool nfc_scene_delete_success_on_event(void* context, SceneManagerEvent event) {
             if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneMfClassicKeys)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneMfClassicKeys);
+            } else if(scene_manager_has_previous_scene(
+                          nfc->scene_manager, NfcSceneMfUltralightCKeys)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneMfUltralightCKeys);
             } else {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneFileSelect);

applications/main/nfc/scenes/nfc_scene_extra_actions.c

@@ -3,6 +3,7 @@
 enum SubmenuIndex {
     SubmenuIndexReadCardType,
     SubmenuIndexMfClassicKeys,
+    SubmenuIndexMfUltralightCKeys,
     SubmenuIndexMfUltralightUnlock,
     SubmenuIndexSlixUnlock,
 };
@@ -29,6 +30,12 @@ void nfc_scene_extra_actions_on_enter(void* context) {
         SubmenuIndexMfClassicKeys,
         nfc_scene_extra_actions_submenu_callback,
         instance);
+    submenu_add_item(
+        submenu,
+        "MIFARE Ultralight C Keys",
+        SubmenuIndexMfUltralightCKeys,
+        nfc_scene_extra_actions_submenu_callback,
+        instance);
     submenu_add_item(
         submenu,
         "Unlock NTAG/Ultralight",
@@ -54,6 +61,9 @@ bool nfc_scene_extra_actions_on_event(void* context, SceneManagerEvent event) {
         if(event.event == SubmenuIndexMfClassicKeys) {
             scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicKeys);
             consumed = true;
+        } else if(event.event == SubmenuIndexMfUltralightCKeys) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightCKeys);
+            consumed = true;
         } else if(event.event == SubmenuIndexMfUltralightUnlock) {
             mf_ultralight_auth_reset(instance->mf_ul_auth);
             scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightUnlockMenu);

applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c

@@ -1,7 +1,5 @@
 #include "../nfc_app_i.h"
 
-#define NFC_SCENE_MF_CLASSIC_KEYS_MAX (100)
-
 void nfc_scene_mf_classic_keys_widget_callback(GuiButtonType result, InputType type, void* context) {
     NfcApp* instance = context;
     if(type == InputTypeShort) {

applications/main/nfc/scenes/nfc_scene_mf_ultralight_c_dict_attack.c

@@ -0,0 +1,238 @@
+#include "../nfc_app_i.h"
+#include <dolphin/dolphin.h>
+
+#define TAG "NfcMfUlCDictAttack"
+
+// TODO: Support card_detected properly
+
+enum {
+    DictAttackStateUserDictInProgress,
+    DictAttackStateSystemDictInProgress,
+};
+
+NfcCommand nfc_mf_ultralight_c_dict_attack_worker_callback(NfcGenericEvent event, void* context) {
+    furi_assert(context);
+    furi_assert(event.event_data);
+    furi_assert(event.protocol == NfcProtocolMfUltralight);
+    NfcCommand command = NfcCommandContinue;
+    NfcApp* instance = context;
+    MfUltralightPollerEvent* poller_event = event.event_data;
+
+    if(poller_event->type == MfUltralightPollerEventTypeRequestMode) {
+        poller_event->data->poller_mode = MfUltralightPollerModeDictAttack;
+        command = NfcCommandContinue;
+    } else if(poller_event->type == MfUltralightPollerEventTypeRequestKey) {
+        MfUltralightC3DesAuthKey key = {};
+        if(keys_dict_get_next_key(
+               instance->mf_ultralight_c_dict_context.dict,
+               key.data,
+               sizeof(MfUltralightC3DesAuthKey))) {
+            poller_event->data->key_request_data.key = key;
+            poller_event->data->key_request_data.key_provided = true;
+            instance->mf_ultralight_c_dict_context.dict_keys_current++;
+
+            if(instance->mf_ultralight_c_dict_context.dict_keys_current % 10 == 0) {
+                view_dispatcher_send_custom_event(
+                    instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+            }
+        } else {
+            poller_event->data->key_request_data.key_provided = false;
+        }
+    } else if(poller_event->type == MfUltralightPollerEventTypeReadSuccess) {
+        nfc_device_set_data(
+            instance->nfc_device, NfcProtocolMfUltralight, nfc_poller_get_data(instance->poller));
+        // Check if this is a successful authentication by looking at the poller's auth context
+        const MfUltralightData* data = nfc_poller_get_data(instance->poller);
+
+        // Update page information
+        dict_attack_set_pages_read(instance->dict_attack, data->pages_read);
+        dict_attack_set_pages_total(instance->dict_attack, data->pages_total);
+
+        if(data->pages_read == data->pages_total) {
+            // Full read indicates successful authentication in dict attack mode
+            instance->mf_ultralight_c_dict_context.auth_success = true;
+            dict_attack_set_key_found(instance->dict_attack, true);
+        }
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackComplete);
+        command = NfcCommandStop;
+    }
+    return command;
+}
+
+void nfc_scene_mf_ultralight_c_dict_attack_dict_attack_result_callback(
+    DictAttackEvent event,
+    void* context) {
+    furi_assert(context);
+    NfcApp* instance = context;
+    if(event == DictAttackEventSkipPressed) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventDictAttackSkip);
+    }
+}
+
+void nfc_scene_mf_ultralight_c_dict_attack_prepare_view(NfcApp* instance) {
+    uint32_t state =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfUltralightCDictAttack);
+
+    // Set attack type to Ultralight C
+    dict_attack_set_type(instance->dict_attack, DictAttackTypeMfUltralightC);
+
+    if(state == DictAttackStateUserDictInProgress) {
+        do {
+            if(!keys_dict_check_presence(NFC_APP_MF_ULTRALIGHT_C_DICT_USER_PATH)) {
+                state = DictAttackStateSystemDictInProgress;
+                break;
+            }
+            instance->mf_ultralight_c_dict_context.dict = keys_dict_alloc(
+                NFC_APP_MF_ULTRALIGHT_C_DICT_USER_PATH,
+                KeysDictModeOpenAlways,
+                sizeof(MfUltralightC3DesAuthKey));
+            if(keys_dict_get_total_keys(instance->mf_ultralight_c_dict_context.dict) == 0) {
+                keys_dict_free(instance->mf_ultralight_c_dict_context.dict);
+                state = DictAttackStateSystemDictInProgress;
+                break;
+            }
+            dict_attack_set_header(instance->dict_attack, "MFUL C User Dictionary");
+        } while(false);
+    }
+    if(state == DictAttackStateSystemDictInProgress) {
+        instance->mf_ultralight_c_dict_context.dict = keys_dict_alloc(
+            NFC_APP_MF_ULTRALIGHT_C_DICT_SYSTEM_PATH,
+            KeysDictModeOpenExisting,
+            sizeof(MfUltralightC3DesAuthKey));
+        dict_attack_set_header(instance->dict_attack, "MFUL C System Dictionary");
+    }
+
+    instance->mf_ultralight_c_dict_context.dict_keys_total =
+        keys_dict_get_total_keys(instance->mf_ultralight_c_dict_context.dict);
+    dict_attack_set_total_dict_keys(
+        instance->dict_attack, instance->mf_ultralight_c_dict_context.dict_keys_total);
+    instance->mf_ultralight_c_dict_context.dict_keys_current = 0;
+    dict_attack_set_current_dict_key(
+        instance->dict_attack, instance->mf_ultralight_c_dict_context.dict_keys_current);
+
+    // Set initial Ultralight C specific values
+    dict_attack_set_key_found(instance->dict_attack, false);
+    dict_attack_set_pages_total(instance->dict_attack, 48); // Ultralight C page count
+    dict_attack_set_pages_read(instance->dict_attack, 0);
+
+    dict_attack_set_callback(
+        instance->dict_attack,
+        nfc_scene_mf_ultralight_c_dict_attack_dict_attack_result_callback,
+        instance);
+    scene_manager_set_scene_state(instance->scene_manager, NfcSceneMfUltralightCDictAttack, state);
+}
+
+void nfc_scene_mf_ultralight_c_dict_attack_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfUltralightCDictAttack,
+        DictAttackStateUserDictInProgress);
+    nfc_scene_mf_ultralight_c_dict_attack_prepare_view(instance);
+
+    // Setup and start worker
+    instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfUltralight);
+    nfc_poller_start(instance->poller, nfc_mf_ultralight_c_dict_attack_worker_callback, instance);
+
+    dict_attack_set_card_state(instance->dict_attack, true);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewDictAttack);
+    nfc_blink_read_start(instance);
+}
+
+void nfc_scene_mf_ul_c_dict_attack_update_view(NfcApp* instance) {
+    dict_attack_set_card_state(
+        instance->dict_attack, instance->mf_ultralight_c_dict_context.is_card_present);
+    dict_attack_set_current_dict_key(
+        instance->dict_attack, instance->mf_ultralight_c_dict_context.dict_keys_current);
+}
+
+bool nfc_scene_mf_ultralight_c_dict_attack_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    uint32_t state =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfUltralightCDictAttack);
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventDictAttackComplete) {
+            if(state == DictAttackStateUserDictInProgress) {
+                if(instance->mf_ultralight_c_dict_context.auth_success) {
+                    notification_message(instance->notifications, &sequence_success);
+                    scene_manager_next_scene(instance->scene_manager, NfcSceneReadSuccess);
+                    dolphin_deed(DolphinDeedNfcReadSuccess);
+                    consumed = true;
+                } else {
+                    nfc_poller_stop(instance->poller);
+                    nfc_poller_free(instance->poller);
+                    keys_dict_free(instance->mf_ultralight_c_dict_context.dict);
+                    scene_manager_set_scene_state(
+                        instance->scene_manager,
+                        NfcSceneMfUltralightCDictAttack,
+                        DictAttackStateSystemDictInProgress);
+                    nfc_scene_mf_ultralight_c_dict_attack_prepare_view(instance);
+                    instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfUltralight);
+                    nfc_poller_start(
+                        instance->poller,
+                        nfc_mf_ultralight_c_dict_attack_worker_callback,
+                        instance);
+                    consumed = true;
+                }
+            } else {
+                // Could check if card is fully read here like MFC dict attack, but found key means fully read
+                if(instance->mf_ultralight_c_dict_context.auth_success) {
+                    notification_message(instance->notifications, &sequence_success);
+                } else {
+                    notification_message(instance->notifications, &sequence_semi_success);
+                }
+                scene_manager_next_scene(instance->scene_manager, NfcSceneReadSuccess);
+                dolphin_deed(DolphinDeedNfcReadSuccess);
+                consumed = true;
+            }
+        } else if(event.event == NfcCustomEventDictAttackDataUpdate) {
+            dict_attack_set_current_dict_key(
+                instance->dict_attack, instance->mf_ultralight_c_dict_context.dict_keys_current);
+            consumed = true;
+        } else if(event.event == NfcCustomEventDictAttackSkip) {
+            if(state == DictAttackStateUserDictInProgress) {
+                nfc_poller_stop(instance->poller);
+                nfc_poller_free(instance->poller);
+                keys_dict_free(instance->mf_ultralight_c_dict_context.dict);
+                scene_manager_set_scene_state(
+                    instance->scene_manager,
+                    NfcSceneMfUltralightCDictAttack,
+                    DictAttackStateSystemDictInProgress);
+                nfc_scene_mf_ultralight_c_dict_attack_prepare_view(instance);
+                instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfUltralight);
+                nfc_poller_start(
+                    instance->poller, nfc_mf_ultralight_c_dict_attack_worker_callback, instance);
+            } else {
+                notification_message(instance->notifications, &sequence_semi_success);
+                scene_manager_next_scene(instance->scene_manager, NfcSceneReadSuccess);
+                dolphin_deed(DolphinDeedNfcReadSuccess);
+            }
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_next_scene(instance->scene_manager, NfcSceneExitConfirm);
+        consumed = true;
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_c_dict_attack_on_exit(void* context) {
+    NfcApp* instance = context;
+    nfc_poller_stop(instance->poller);
+    nfc_poller_free(instance->poller);
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfUltralightCDictAttack,
+        DictAttackStateUserDictInProgress);
+    keys_dict_free(instance->mf_ultralight_c_dict_context.dict);
+    instance->mf_ultralight_c_dict_context.dict_keys_total = 0;
+    instance->mf_ultralight_c_dict_context.dict_keys_current = 0;
+    instance->mf_ultralight_c_dict_context.auth_success = false;
+    instance->mf_ultralight_c_dict_context.is_card_present = false;
+    nfc_blink_stop(instance);
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_c_keys.c

@@ -0,0 +1,96 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_ultralight_c_keys_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcApp* instance = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_ultralight_c_keys_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    // Load flipper dict keys total
+    uint32_t flipper_dict_keys_total = 0;
+    KeysDict* dict = keys_dict_alloc(
+        NFC_APP_MF_ULTRALIGHT_C_DICT_SYSTEM_PATH,
+        KeysDictModeOpenExisting,
+        sizeof(MfUltralightC3DesAuthKey));
+    flipper_dict_keys_total = keys_dict_get_total_keys(dict);
+    keys_dict_free(dict);
+
+    // Load user dict keys total
+    uint32_t user_dict_keys_total = 0;
+    dict = keys_dict_alloc(
+        NFC_APP_MF_ULTRALIGHT_C_DICT_USER_PATH,
+        KeysDictModeOpenAlways,
+        sizeof(MfUltralightC3DesAuthKey));
+    user_dict_keys_total = keys_dict_get_total_keys(dict);
+    keys_dict_free(dict);
+
+    FuriString* temp_str = furi_string_alloc();
+    widget_add_string_element(
+        instance->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "MIFARE Ultralight C Keys");
+    furi_string_printf(temp_str, "System dict: %lu", flipper_dict_keys_total);
+    widget_add_string_element(
+        instance->widget,
+        0,
+        20,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        furi_string_get_cstr(temp_str));
+    furi_string_printf(temp_str, "User dict: %lu", user_dict_keys_total);
+    widget_add_string_element(
+        instance->widget,
+        0,
+        32,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        furi_string_get_cstr(temp_str));
+    widget_add_icon_element(instance->widget, 87, 13, &I_Keychain_39x36);
+    widget_add_button_element(
+        instance->widget,
+        GuiButtonTypeCenter,
+        "Add",
+        nfc_scene_mf_ultralight_c_keys_widget_callback,
+        instance);
+    if(user_dict_keys_total > 0) {
+        widget_add_button_element(
+            instance->widget,
+            GuiButtonTypeRight,
+            "List",
+            nfc_scene_mf_ultralight_c_keys_widget_callback,
+            instance);
+    }
+    furi_string_free(temp_str);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_ultralight_c_keys_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeCenter) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightCKeysAdd);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightCKeysList);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_c_keys_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    widget_reset(instance->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_c_keys_add.c

@@ -0,0 +1,63 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_ultralight_c_keys_add_byte_input_callback(void* context) {
+    NfcApp* instance = context;
+
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventByteInputDone);
+}
+
+void nfc_scene_mf_ultralight_c_keys_add_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    // Setup view
+    ByteInput* byte_input = instance->byte_input;
+    byte_input_set_header_text(byte_input, "Enter the key in hex");
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_scene_mf_ultralight_c_keys_add_byte_input_callback,
+        NULL,
+        instance,
+        instance->byte_input_store,
+        sizeof(MfUltralightC3DesAuthKey));
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewByteInput);
+}
+
+bool nfc_scene_mf_ultralight_c_keys_add_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventByteInputDone) {
+            // Add key to dict
+            KeysDict* dict = keys_dict_alloc(
+                NFC_APP_MF_ULTRALIGHT_C_DICT_USER_PATH,
+                KeysDictModeOpenAlways,
+                sizeof(MfUltralightC3DesAuthKey));
+
+            MfUltralightC3DesAuthKey key = {};
+            memcpy(key.data, instance->byte_input_store, sizeof(MfUltralightC3DesAuthKey));
+            if(keys_dict_is_key_present(dict, key.data, sizeof(MfUltralightC3DesAuthKey))) {
+                scene_manager_next_scene(
+                    instance->scene_manager, NfcSceneMfUltralightCKeysWarnDuplicate);
+            } else if(keys_dict_add_key(dict, key.data, sizeof(MfUltralightC3DesAuthKey))) {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneSaveSuccess);
+                dolphin_deed(DolphinDeedNfcMfcAdd);
+            } else {
+                scene_manager_previous_scene(instance->scene_manager);
+            }
+
+            keys_dict_free(dict);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_c_keys_add_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    // Clear view
+    byte_input_set_result_callback(instance->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(instance->byte_input, "");
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_c_keys_delete.c

@@ -0,0 +1,108 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_ultralight_c_keys_delete_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcApp* instance = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_ultralight_c_keys_delete_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    uint32_t key_index =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfUltralightCKeysDelete);
+    FuriString* key_str = furi_string_alloc();
+
+    widget_add_string_element(
+        instance->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Delete this key?");
+    widget_add_button_element(
+        instance->widget,
+        GuiButtonTypeLeft,
+        "Cancel",
+        nfc_scene_mf_ultralight_c_keys_delete_widget_callback,
+        instance);
+    widget_add_button_element(
+        instance->widget,
+        GuiButtonTypeRight,
+        "Delete",
+        nfc_scene_mf_ultralight_c_keys_delete_widget_callback,
+        instance);
+
+    KeysDict* mf_ultralight_c_user_dict = keys_dict_alloc(
+        NFC_APP_MF_ULTRALIGHT_C_DICT_USER_PATH,
+        KeysDictModeOpenAlways,
+        sizeof(MfUltralightC3DesAuthKey));
+    size_t dict_keys_num = keys_dict_get_total_keys(mf_ultralight_c_user_dict);
+    furi_assert(key_index < dict_keys_num);
+    MfUltralightC3DesAuthKey stack_key;
+    for(size_t i = 0; i < (key_index + 1); i++) {
+        bool key_loaded = keys_dict_get_next_key(
+            mf_ultralight_c_user_dict, stack_key.data, sizeof(MfUltralightC3DesAuthKey));
+        furi_assert(key_loaded);
+    }
+    furi_string_reset(key_str);
+    for(size_t i = 0; i < sizeof(MfUltralightC3DesAuthKey); i++) {
+        furi_string_cat_printf(key_str, "%02X", stack_key.data[i]);
+    }
+
+    widget_add_string_element(
+        instance->widget,
+        64,
+        32,
+        AlignCenter,
+        AlignCenter,
+        FontSecondary,
+        furi_string_get_cstr(key_str));
+
+    keys_dict_free(mf_ultralight_c_user_dict);
+    furi_string_free(key_str);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_ultralight_c_keys_delete_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeRight) {
+            uint32_t key_index = scene_manager_get_scene_state(
+                instance->scene_manager, NfcSceneMfUltralightCKeysDelete);
+            KeysDict* mf_ultralight_c_user_dict = keys_dict_alloc(
+                NFC_APP_MF_ULTRALIGHT_C_DICT_USER_PATH,
+                KeysDictModeOpenAlways,
+                sizeof(MfUltralightC3DesAuthKey));
+            size_t dict_keys_num = keys_dict_get_total_keys(mf_ultralight_c_user_dict);
+            furi_assert(key_index < dict_keys_num);
+            MfUltralightC3DesAuthKey stack_key;
+            for(size_t i = 0; i < (key_index + 1); i++) {
+                bool key_loaded = keys_dict_get_next_key(
+                    mf_ultralight_c_user_dict, stack_key.data, sizeof(MfUltralightC3DesAuthKey));
+                furi_assert(key_loaded);
+            }
+            bool key_delete_success = keys_dict_delete_key(
+                mf_ultralight_c_user_dict, stack_key.data, sizeof(MfUltralightC3DesAuthKey));
+            keys_dict_free(mf_ultralight_c_user_dict);
+            if(key_delete_success) {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneDeleteSuccess);
+            } else {
+                scene_manager_previous_scene(instance->scene_manager);
+            }
+        } else if(event.event == GuiButtonTypeLeft) {
+            scene_manager_previous_scene(instance->scene_manager);
+        }
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_c_keys_delete_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    widget_reset(instance->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_c_keys_list.c

@@ -0,0 +1,66 @@
+#include "../nfc_app_i.h"
+
+#define NFC_SCENE_MF_ULTRALIGHT_C_KEYS_LIST_MAX (100)
+
+void nfc_scene_mf_ultralight_c_keys_list_submenu_callback(void* context, uint32_t index) {
+    NfcApp* instance = context;
+
+    view_dispatcher_send_custom_event(instance->view_dispatcher, index);
+}
+
+void nfc_scene_mf_ultralight_c_keys_list_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    KeysDict* mf_ultralight_c_user_dict = keys_dict_alloc(
+        NFC_APP_MF_ULTRALIGHT_C_DICT_USER_PATH,
+        KeysDictModeOpenAlways,
+        sizeof(MfUltralightC3DesAuthKey));
+
+    submenu_set_header(instance->submenu, "Select key to delete:");
+    FuriString* temp_str = furi_string_alloc();
+
+    size_t dict_keys_num = keys_dict_get_total_keys(mf_ultralight_c_user_dict);
+    size_t keys_num = MIN((size_t)NFC_SCENE_MF_ULTRALIGHT_C_KEYS_LIST_MAX, dict_keys_num);
+    MfUltralightC3DesAuthKey stack_key;
+
+    if(keys_num > 0) {
+        for(size_t i = 0; i < keys_num; i++) {
+            bool key_loaded = keys_dict_get_next_key(
+                mf_ultralight_c_user_dict, stack_key.data, sizeof(MfUltralightC3DesAuthKey));
+            furi_assert(key_loaded);
+            furi_string_reset(temp_str);
+            for(size_t i = 0; i < sizeof(MfUltralightC3DesAuthKey); i++) {
+                furi_string_cat_printf(temp_str, "%02X", stack_key.data[i]);
+            }
+            submenu_add_item(
+                instance->submenu,
+                furi_string_get_cstr(temp_str),
+                i,
+                nfc_scene_mf_ultralight_c_keys_list_submenu_callback,
+                instance);
+        }
+    }
+    keys_dict_free(mf_ultralight_c_user_dict);
+    furi_string_free(temp_str);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_ultralight_c_keys_list_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        scene_manager_set_scene_state(
+            instance->scene_manager, NfcSceneMfUltralightCKeysDelete, event.event);
+        scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightCKeysDelete);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_c_keys_list_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    submenu_reset(instance->submenu);
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_c_keys_warn_duplicate.c

@@ -0,0 +1,49 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_ultralight_c_keys_warn_duplicate_popup_callback(void* context) {
+    NfcApp* instance = context;
+
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_mf_ultralight_c_keys_warn_duplicate_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    // Setup view
+    Popup* popup = instance->popup;
+    popup_set_icon(popup, 83, 22, &I_WarningDolphinFlip_45x42);
+    popup_set_header(popup, "Key Already Exists!", 64, 3, AlignCenter, AlignTop);
+    popup_set_text(
+        popup,
+        "Please enter a\n"
+        "different key.",
+        4,
+        24,
+        AlignLeft,
+        AlignTop);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, instance);
+    popup_set_callback(popup, nfc_scene_mf_ultralight_c_keys_warn_duplicate_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_mf_ultralight_c_keys_warn_duplicate_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                instance->scene_manager, NfcSceneMfUltralightCKeysAdd);
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_c_keys_warn_duplicate_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    popup_reset(instance->popup);
+}

applications/main/nfc/scenes/nfc_scene_save_success.c

@@ -28,6 +28,10 @@ bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
             if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneMfClassicKeys)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneMfClassicKeys);
+            } else if(scene_manager_has_previous_scene(
+                          nfc->scene_manager, NfcSceneMfUltralightCKeys)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneMfUltralightCKeys);
             } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSaveConfirm)) {
                 NfcSceneSaveConfirmState scene_state =
                     scene_manager_get_scene_state(nfc->scene_manager, NfcSceneSaveConfirm);