added support for ISO15693 (NfcV) emulation, added support for reading SLIX tags

applications/main/nfc/scenes/nfc_scene_config.h

@@ -14,6 +14,11 @@ ADD_SCENE(nfc, file_select, FileSelect)
 ADD_SCENE(nfc, emulate_uid, EmulateUid)
 ADD_SCENE(nfc, nfca_read_success, NfcaReadSuccess)
 ADD_SCENE(nfc, nfca_menu, NfcaMenu)
+ADD_SCENE(nfc, nfcv_menu, NfcVMenu)
+ADD_SCENE(nfc, nfcv_unlock_menu, NfcVUnlockMenu)
+ADD_SCENE(nfc, nfcv_key_input, NfcVKeyInput)
+ADD_SCENE(nfc, nfcv_unlock, NfcVUnlock)
+ADD_SCENE(nfc, emulate_nfcv, EmulateNfcV)
 ADD_SCENE(nfc, mf_ultralight_read_success, MfUltralightReadSuccess)
 ADD_SCENE(nfc, mf_ultralight_data, MfUltralightData)
 ADD_SCENE(nfc, mf_ultralight_menu, MfUltralightMenu)

applications/main/nfc/scenes/nfc_scene_emulate_nfcv.c

@@ -0,0 +1,149 @@
+#include "../nfc_i.h"
+
+#define NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX (100)
+
+enum {
+    NfcSceneEmulateNfcVStateWidget,
+    NfcSceneEmulateNfcVStateTextBox,
+};
+
+bool nfc_emulate_nfcv_worker_callback(NfcWorkerEvent event, void* context) {
+    UNUSED(event);
+    furi_assert(context);
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventWorkerExit);
+    return true;
+}
+
+void nfc_scene_emulate_nfcv_widget_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    Nfc* nfc = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+    }
+}
+
+void nfc_emulate_nfcv_textbox_callback(void* context) {
+    furi_assert(context);
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+// Add widget with device name or inform that data received
+static void nfc_scene_emulate_nfcv_widget_config(Nfc* nfc, bool data_received) {
+    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
+    Widget* widget = nfc->widget;
+    widget_reset(widget);
+    FuriString* info_str;
+    info_str = furi_string_alloc();
+
+    widget_add_icon_element(widget, 0, 3, &I_RFIDDolphinSend_97x61);
+    widget_add_string_element(
+        widget, 89, 32, AlignCenter, AlignTop, FontPrimary, "Emulating NfcV");
+    if(strcmp(nfc->dev->dev_name, "")) {
+        furi_string_printf(info_str, "%s", nfc->dev->dev_name);
+    } else {
+        for(uint8_t i = 0; i < data->uid_len; i++) {
+            furi_string_cat_printf(info_str, "%02X ", data->uid[i]);
+        }
+    }
+    furi_string_trim(info_str);
+    widget_add_text_box_element(
+        widget, 56, 43, 70, 21, AlignCenter, AlignTop, furi_string_get_cstr(info_str), true);
+    furi_string_free(info_str);
+    if(data_received) {
+        widget_add_button_element(
+            widget, GuiButtonTypeCenter, "Log", nfc_scene_emulate_nfcv_widget_callback, nfc);
+    }
+}
+
+void nfc_scene_emulate_nfcv_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup Widget
+    nfc_scene_emulate_nfcv_widget_config(nfc, false);
+    // Setup TextBox
+    TextBox* text_box = nfc->text_box;
+    text_box_set_font(text_box, TextBoxFontHex);
+    text_box_set_focus(text_box, TextBoxFocusEnd);
+    furi_string_reset(nfc->text_box_store);
+
+    // Set Widget state and view
+    scene_manager_set_scene_state(
+        nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateWidget);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+    // Start worker
+    memset(&nfc->dev->dev_data.reader_data, 0, sizeof(NfcReaderRequestData));
+    nfc_worker_start(
+        nfc->worker,
+        NfcWorkerStateNfcVEmulate,
+        &nfc->dev->dev_data,
+        nfc_emulate_nfcv_worker_callback,
+        nfc);
+
+    nfc_blink_emulate_start(nfc);
+}
+
+bool nfc_scene_emulate_nfcv_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    NfcVData* nfcv_data = &nfc->dev->dev_data.nfcv_data;
+    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneEmulateNfcV);
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventWorkerExit) {
+            // Add data button to widget if data is received for the first time
+            if(!furi_string_size(nfc->text_box_store)) {
+                nfc_scene_emulate_nfcv_widget_config(nfc, true);
+            }
+            if(strlen(nfcv_data->last_command) > 0) {
+                /* use the last n bytes from the log so there's enough space for the new log entry */
+                size_t maxSize =
+                    NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX - (strlen(nfcv_data->last_command) + 1);
+                if(furi_string_size(nfc->text_box_store) >= maxSize) {
+                    furi_string_right(nfc->text_box_store, (strlen(nfcv_data->last_command) + 1));
+                }
+                furi_string_cat_printf(nfc->text_box_store, "%s", nfcv_data->last_command);
+                furi_string_push_back(nfc->text_box_store, '\n');
+                text_box_set_text(nfc->text_box, furi_string_get_cstr(nfc->text_box_store));
+
+                /* clear previously logged command */
+                strcpy(nfcv_data->last_command, "");
+            }
+            consumed = true;
+        } else if(event.event == GuiButtonTypeCenter && state == NfcSceneEmulateNfcVStateWidget) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateTextBox);
+            consumed = true;
+        } else if(event.event == NfcCustomEventViewExit && state == NfcSceneEmulateNfcVStateTextBox) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateWidget);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        if(state == NfcSceneEmulateNfcVStateTextBox) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateWidget);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_emulate_nfcv_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Stop worker
+    nfc_worker_stop(nfc->worker);
+
+    // Clear view
+    widget_reset(nfc->widget);
+    text_box_reset(nfc->text_box);
+    furi_string_reset(nfc->text_box_store);
+
+    nfc_blink_stop(nfc);
+}

applications/main/nfc/scenes/nfc_scene_extra_actions.c

@@ -4,6 +4,7 @@ enum SubmenuIndex {
     SubmenuIndexReadCardType,
     SubmenuIndexMfClassicKeys,
     SubmenuIndexMfUltralightUnlock,
+    SubmenuIndexNfcVUnlock,
 };
 
 void nfc_scene_extra_actions_submenu_callback(void* context, uint32_t index) {
@@ -34,6 +35,12 @@ void nfc_scene_extra_actions_on_enter(void* context) {
         SubmenuIndexMfUltralightUnlock,
         nfc_scene_extra_actions_submenu_callback,
         nfc);
+    submenu_add_item(
+        submenu,
+        "Unlock SLIX-L",
+        SubmenuIndexNfcVUnlock,
+        nfc_scene_extra_actions_submenu_callback,
+        nfc);
     view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
 }
 
@@ -56,6 +63,9 @@ bool nfc_scene_extra_actions_on_event(void* context, SceneManagerEvent event) {
             scene_manager_set_scene_state(nfc->scene_manager, NfcSceneReadCardType, 0);
             scene_manager_next_scene(nfc->scene_manager, NfcSceneReadCardType);
             consumed = true;
+        } else if(event.event == SubmenuIndexNfcVUnlock) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlockMenu);
+            consumed = true;
         }
         scene_manager_set_scene_state(nfc->scene_manager, NfcSceneExtraActions, event.event);
     }

applications/main/nfc/scenes/nfc_scene_nfc_data_info.c

@@ -7,6 +7,17 @@ void nfc_scene_nfc_data_info_widget_callback(GuiButtonType result, InputType typ
     }
 }
 
+uint32_t nfc_scene_nfc_data_info_get_key(uint8_t* data) {
+    uint32_t value = 0;
+
+    for(uint32_t pos = 0; pos < 4; pos++) {
+        value <<= 8;
+        value |= data[pos];
+    }
+
+    return value;
+}
+
 void nfc_scene_nfc_data_info_on_enter(void* context) {
     Nfc* nfc = context;
     Widget* widget = nfc->widget;
@@ -14,7 +25,8 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
     NfcDeviceData* dev_data = &nfc->dev->dev_data;
     NfcProtocol protocol = dev_data->protocol;
     uint8_t text_scroll_height = 0;
-    if((protocol == NfcDeviceProtocolMifareDesfire) || (protocol == NfcDeviceProtocolMifareUl)) {
+    if((protocol == NfcDeviceProtocolMifareDesfire) || (protocol == NfcDeviceProtocolMifareUl) ||
+       (protocol == NfcDeviceProtocolNfcV)) {
         widget_add_button_element(
             widget, GuiButtonTypeRight, "More", nfc_scene_nfc_data_info_widget_callback, nfc);
         text_scroll_height = 52;
@@ -40,19 +52,156 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
             temp_str, "\e#%s\n", nfc_mf_classic_type(dev_data->mf_classic_data.type));
     } else if(protocol == NfcDeviceProtocolMifareDesfire) {
         furi_string_cat_printf(temp_str, "\e#MIFARE DESfire\n");
+    } else if(protocol == NfcDeviceProtocolNfcV) {
+        switch(dev_data->nfcv_data.sub_type) {
+        case NfcVTypePlain:
+            furi_string_cat_printf(temp_str, "\e#ISO15693\n");
+            break;
+        case NfcVTypeSlix:
+            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX\n");
+            break;
+        case NfcVTypeSlixS:
+            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-S\n");
+            break;
+        case NfcVTypeSlixL:
+            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-L\n");
+            break;
+        case NfcVTypeSlix2:
+            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX2\n");
+            break;
+        default:
+            furi_string_cat_printf(temp_str, "\e#ISO15693 (unknown)\n");
+            break;
+        }
     } else {
         furi_string_cat_printf(temp_str, "\e#Unknown ISO tag\n");
     }
 
     // Set tag iso data
-    char iso_type = FURI_BIT(nfc_data->sak, 5) ? '4' : '3';
-    furi_string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
-    furi_string_cat_printf(temp_str, "UID:");
-    for(size_t i = 0; i < nfc_data->uid_len; i++) {
-        furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
+    if(protocol == NfcDeviceProtocolNfcV) {
+        NfcVData* nfcv_data = &nfc->dev->dev_data.nfcv_data;
+
+        furi_string_cat_printf(temp_str, "UID:\n");
+        for(size_t i = 0; i < nfc_data->uid_len; i++) {
+            furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
+        }
+        furi_string_cat_printf(temp_str, "\n");
+
+        furi_string_cat_printf(temp_str, "DSFID: %02X\n", nfcv_data->dsfid);
+        furi_string_cat_printf(temp_str, "AFI: %02X\n", nfcv_data->afi);
+        furi_string_cat_printf(temp_str, "IC Ref: %02X\n", nfcv_data->ic_ref);
+        furi_string_cat_printf(temp_str, "Blocks: %02X\n", nfcv_data->block_num);
+        furi_string_cat_printf(temp_str, "Blocksize: %02X\n", nfcv_data->block_size);
+
+        furi_string_cat_printf(
+            temp_str, "Data (%d byte)\n", nfcv_data->block_num * nfcv_data->block_size);
+
+        int maxBlocks = nfcv_data->block_num;
+        if(maxBlocks > 32) {
+            maxBlocks = 32;
+            furi_string_cat_printf(temp_str, "(truncated to %d blocks)\n", maxBlocks);
+        }
+
+        for(int block = 0; block < maxBlocks; block++) {
+            for(int pos = 0; pos < nfcv_data->block_size; pos++) {
+                furi_string_cat_printf(
+                    temp_str, " %02X", nfcv_data->data[block * nfcv_data->block_size + pos]);
+            }
+            furi_string_cat_printf(temp_str, "\n");
+        }
+        furi_string_cat_printf(temp_str, "\n");
+
+        switch(dev_data->nfcv_data.sub_type) {
+        case NfcVTypePlain:
+            furi_string_cat_printf(temp_str, "Type: Plain\n");
+            break;
+        case NfcVTypeSlix:
+            furi_string_cat_printf(temp_str, "Type: SLIX\n");
+            furi_string_cat_printf(temp_str, "Keys:\n");
+            furi_string_cat_printf(
+                temp_str,
+                " EAS      %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
+            break;
+        case NfcVTypeSlixS:
+            furi_string_cat_printf(temp_str, "Type: SLIX-S\n");
+            furi_string_cat_printf(temp_str, "Keys:\n");
+            furi_string_cat_printf(
+                temp_str,
+                " Read     %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_read));
+            furi_string_cat_printf(
+                temp_str,
+                " Write    %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_write));
+            furi_string_cat_printf(
+                temp_str,
+                " Privacy  %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_privacy));
+            furi_string_cat_printf(
+                temp_str,
+                " Destroy  %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_destroy));
+            furi_string_cat_printf(
+                temp_str,
+                " EAS      %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
+            break;
+        case NfcVTypeSlixL:
+            furi_string_cat_printf(temp_str, "Type: SLIX-L\n");
+            furi_string_cat_printf(temp_str, "Keys:\n");
+            furi_string_cat_printf(
+                temp_str,
+                " Privacy  %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_privacy));
+            furi_string_cat_printf(
+                temp_str,
+                " Destroy  %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_destroy));
+            furi_string_cat_printf(
+                temp_str,
+                " EAS      %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
+            break;
+        case NfcVTypeSlix2:
+            furi_string_cat_printf(temp_str, "Type: SLIX2\n");
+            furi_string_cat_printf(temp_str, "Keys:\n");
+            furi_string_cat_printf(
+                temp_str,
+                " Read     %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_read));
+            furi_string_cat_printf(
+                temp_str,
+                " Write    %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_write));
+            furi_string_cat_printf(
+                temp_str,
+                " Privacy  %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_privacy));
+            furi_string_cat_printf(
+                temp_str,
+                " Destroy  %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_destroy));
+            furi_string_cat_printf(
+                temp_str,
+                " EAS      %08lX\n",
+                nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
+            break;
+        default:
+            furi_string_cat_printf(temp_str, "\e#ISO15693 (unknown)\n");
+            break;
+        }
+    } else {
+        char iso_type = FURI_BIT(nfc_data->sak, 5) ? '4' : '3';
+        furi_string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
+        furi_string_cat_printf(temp_str, "UID:");
+        for(size_t i = 0; i < nfc_data->uid_len; i++) {
+            furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
+        }
+        furi_string_cat_printf(
+            temp_str, "\nATQA: %02X %02X ", nfc_data->atqa[1], nfc_data->atqa[0]);
+        furi_string_cat_printf(temp_str, " SAK: %02X", nfc_data->sak);
     }
-    furi_string_cat_printf(temp_str, "\nATQA: %02X %02X ", nfc_data->atqa[1], nfc_data->atqa[0]);
-    furi_string_cat_printf(temp_str, " SAK: %02X", nfc_data->sak);
 
     // Set application specific data
     if(protocol == NfcDeviceProtocolMifareDesfire) {
@@ -136,6 +285,9 @@ bool nfc_scene_nfc_data_info_on_event(void* context, SceneManagerEvent event) {
             } else if(protocol == NfcDeviceProtocolMifareUl) {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightData);
                 consumed = true;
+            } else if(protocol == NfcDeviceProtocolNfcV) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVMenu);
+                consumed = true;
             }
         }
     }

applications/main/nfc/scenes/nfc_scene_nfcv_key_input.c

@@ -0,0 +1,48 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_nfcv_key_input_byte_input_callback(void* context) {
+    Nfc* nfc = context;
+    NfcVSlixData* data = &nfc->dev->dev_data.nfcv_data.sub_data.slix;
+
+    memcpy(data->key_privacy, nfc->byte_input_store, 4);
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+}
+
+void nfc_scene_nfcv_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_nfcv_key_input_byte_input_callback,
+        NULL,
+        nfc,
+        nfc->byte_input_store,
+        4);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+}
+
+bool nfc_scene_nfcv_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, NfcSceneNfcVUnlock);
+            DOLPHIN_DEED(DolphinDeedNfcRead);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_nfcv_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/main/nfc/scenes/nfc_scene_nfcv_menu.c

@@ -0,0 +1,63 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+enum SubmenuIndex {
+    SubmenuIndexSave,
+    SubmenuIndexEmulate,
+};
+
+void nfc_scene_nfcv_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_nfcv_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(submenu, "Save", SubmenuIndexSave, nfc_scene_nfcv_menu_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Emulate", SubmenuIndexEmulate, nfc_scene_nfcv_menu_submenu_callback, nfc);
+
+    submenu_set_selected_item(
+        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVMenu));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_nfcv_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexSave) {
+            nfc->dev->format = NfcDeviceSaveFormatNfcV;
+            // 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_next_scene(nfc->scene_manager, NfcSceneEmulateNfcV);
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
+                DOLPHIN_DEED(DolphinDeedNfcAddEmulate);
+            } else {
+                DOLPHIN_DEED(DolphinDeedNfcEmulate);
+            }
+            consumed = true;
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVMenu, event.event);
+
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_previous_scene(nfc->scene_manager);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_nfcv_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_nfcv_unlock.c

@@ -0,0 +1,155 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+typedef enum {
+    NfcSceneNfcVUnlockStateIdle,
+    NfcSceneNfcVUnlockStateDetecting,
+    NfcSceneNfcVUnlockStateUnlocked,
+    NfcSceneNfcVUnlockStateAlreadyUnlocked,
+    NfcSceneNfcVUnlockStateNotSupportedCard,
+} NfcSceneNfcVUnlockState;
+
+static bool nfc_scene_nfcv_unlock_worker_callback(NfcWorkerEvent event, void* context) {
+    Nfc* nfc = context;
+    NfcVSlixData* data = &nfc->dev->dev_data.nfcv_data.sub_data.slix;
+
+    if(event == NfcWorkerEventNfcVPassKey) {
+        memcpy(data->key_privacy, nfc->byte_input_store, 4);
+    } else {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
+    }
+    return true;
+}
+
+void nfc_scene_nfcv_unlock_popup_callback(void* context) {
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_nfcv_unlock_set_state(Nfc* nfc, NfcSceneNfcVUnlockState state) {
+    FuriHalNfcDevData* nfc_data = &(nfc->dev->dev_data.nfc_data);
+    NfcVData* nfcv_data = &(nfc->dev->dev_data.nfcv_data);
+
+    uint32_t curr_state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVUnlock);
+    if(curr_state != state) {
+        Popup* popup = nfc->popup;
+        if(state == NfcSceneNfcVUnlockStateDetecting) {
+            popup_reset(popup);
+            popup_set_text(
+                popup, "Put figurine on\nFlipper's back", 97, 24, AlignCenter, AlignTop);
+            popup_set_icon(popup, 0, 8, &I_NFC_manual_60x50);
+        } else if(state == NfcSceneNfcVUnlockStateUnlocked) {
+            popup_reset(popup);
+
+            if(nfc_worker_get_state(nfc->worker) == NfcWorkerStateNfcVUnlockAndSave) {
+                nfc_text_store_set(
+                    nfc,
+                    "%s/SLIX_%02X%02X%02X%02X%02X%02X%02X%02X%s",
+                    NFC_APP_FOLDER,
+                    nfc_data->uid[0],
+                    nfc_data->uid[1],
+                    nfc_data->uid[2],
+                    nfc_data->uid[3],
+                    nfc_data->uid[4],
+                    nfc_data->uid[5],
+                    nfc_data->uid[6],
+                    nfc_data->uid[7],
+                    NFC_APP_EXTENSION);
+
+                nfc->dev->format = NfcDeviceSaveFormatNfcV;
+
+                if(nfc_device_save(nfc->dev, nfc->text_store)) {
+                    popup_set_header(popup, "Successfully\nsaved", 94, 3, AlignCenter, AlignTop);
+                } else {
+                    popup_set_header(
+                        popup, "Unlocked but\nsave failed!", 94, 3, AlignCenter, AlignTop);
+                }
+            } else {
+                popup_set_header(popup, "Successfully\nunlocked", 94, 3, AlignCenter, AlignTop);
+            }
+
+            notification_message(nfc->notifications, &sequence_single_vibro);
+            //notification_message(nfc->notifications, &sequence_success);
+
+            popup_set_icon(popup, 0, 6, &I_RFIDDolphinSuccess_108x57);
+            popup_set_context(popup, nfc);
+            popup_set_callback(popup, nfc_scene_nfcv_unlock_popup_callback);
+            popup_set_timeout(popup, 1500);
+
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+            DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+
+        } else if(state == NfcSceneNfcVUnlockStateAlreadyUnlocked) {
+            popup_reset(popup);
+
+            popup_set_header(popup, "Already\nUnlocked!", 94, 3, AlignCenter, AlignTop);
+            popup_set_icon(popup, 0, 6, &I_RFIDDolphinSuccess_108x57);
+            popup_set_context(popup, nfc);
+            popup_set_callback(popup, nfc_scene_nfcv_unlock_popup_callback);
+            popup_set_timeout(popup, 1500);
+
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+        } else if(state == NfcSceneNfcVUnlockStateNotSupportedCard) {
+            popup_reset(popup);
+            popup_set_header(popup, "Wrong Type Of Card!", 64, 3, AlignCenter, AlignTop);
+            popup_set_text(popup, nfcv_data->error, 4, 22, AlignLeft, AlignTop);
+            popup_set_icon(popup, 73, 20, &I_DolphinCommon_56x48);
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVUnlock, state);
+    }
+}
+
+void nfc_scene_nfcv_unlock_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    nfc_device_clear(nfc->dev);
+    // Setup view
+    nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateDetecting);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+
+    // Start worker
+    nfc_worker_start(
+        nfc->worker,
+        NfcWorkerStateNfcVUnlockAndSave,
+        &nfc->dev->dev_data,
+        nfc_scene_nfcv_unlock_worker_callback,
+        nfc);
+
+    nfc_blink_read_start(nfc);
+}
+
+bool nfc_scene_nfcv_unlock_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcWorkerEventCardDetected) {
+            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateUnlocked);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventAborted) {
+            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateAlreadyUnlocked);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventNoCardDetected) {
+            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateDetecting);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventWrongCardDetected) {
+            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateNotSupportedCard);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            nfc->scene_manager, NfcSceneNfcVUnlockMenu);
+    }
+    return consumed;
+}
+
+void nfc_scene_nfcv_unlock_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, NfcSceneNfcVUnlock, NfcSceneNfcVUnlockStateIdle);
+}

applications/main/nfc/scenes/nfc_scene_nfcv_unlock_menu.c

@@ -0,0 +1,60 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+enum SubmenuIndex {
+    SubmenuIndexNfcVUnlockMenuManual,
+    SubmenuIndexNfcVUnlockMenuTonieBox,
+};
+
+void nfc_scene_nfcv_unlock_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_nfcv_unlock_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVUnlockMenu);
+    submenu_add_item(
+        submenu,
+        "Enter PWD Manually",
+        SubmenuIndexNfcVUnlockMenuManual,
+        nfc_scene_nfcv_unlock_menu_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu,
+        "Auth As TonieBox",
+        SubmenuIndexNfcVUnlockMenuTonieBox,
+        nfc_scene_nfcv_unlock_menu_submenu_callback,
+        nfc);
+    submenu_set_selected_item(submenu, state);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_nfcv_unlock_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexNfcVUnlockMenuManual) {
+            nfc->dev->dev_data.nfcv_data.auth_method = NfcVAuthMethodManual;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVKeyInput);
+            consumed = true;
+        } else if(event.event == SubmenuIndexNfcVUnlockMenuTonieBox) {
+            nfc->dev->dev_data.nfcv_data.auth_method = NfcVAuthMethodTonieBox;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlock);
+            DOLPHIN_DEED(DolphinDeedNfcRead);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVUnlockMenu, event.event);
+    }
+    return consumed;
+}
+
+void nfc_scene_nfcv_unlock_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_read.c

@@ -68,6 +68,11 @@ bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcaReadSuccess);
             DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
             consumed = true;
+        } else if(event.event == NfcWorkerEventReadNfcV) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+            consumed = true;
         } else if(event.event == NfcWorkerEventReadMfUltralight) {
             notification_message(nfc->notifications, &sequence_success);
             // Set unlock password input to 0xFFFFFFFF only on fresh read

applications/main/nfc/scenes/nfc_scene_rpc.c

@@ -55,6 +55,13 @@ bool nfc_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                             &nfc->dev->dev_data,
                             nfc_scene_rpc_emulate_callback,
                             nfc);
+                    } else if(nfc->dev->format == NfcDeviceSaveFormatNfcV) {
+                        nfc_worker_start(
+                            nfc->worker,
+                            NfcWorkerStateNfcVEmulate,
+                            &nfc->dev->dev_data,
+                            nfc_scene_rpc_emulate_callback,
+                            nfc);
                     } else {
                         nfc_worker_start(
                             nfc->worker, NfcWorkerStateUidEmulate, &nfc->dev->dev_data, NULL, nfc);

applications/main/nfc/scenes/nfc_scene_saved_menu.c

@@ -116,6 +116,8 @@ bool nfc_scene_saved_menu_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
             } else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicEmulate);
+            } else if(nfc->dev->format == NfcDeviceSaveFormatNfcV) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateNfcV);
             } else {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
             }