[FL-2627] Flipper applications: SDK, build and debug system (#1387)

* Added support for running applications from SD card (FAPs - Flipper Application Packages)
* Added plugin_dist target for fbt to build FAPs
* All apps of type FlipperAppType.EXTERNAL and FlipperAppType.PLUGIN are built as FAPs by default
* Updated VSCode configuration for new fbt features - re-deploy stock configuration to use them
* Added debugging support for FAPs with fbt debug & VSCode
* Added public firmware API with automated versioning

Co-authored-by: hedger <hedger@users.noreply.github.com>
Co-authored-by: SG <who.just.the.doctor@gmail.com>
Co-authored-by: あく <alleteam@gmail.com>

applications/main/nfc/application.fam

@@ -0,0 +1,23 @@
+App(
+    appid="nfc",
+    name="NFC",
+    apptype=FlipperAppType.APP,
+    entry_point="nfc_app",
+    cdefines=["APP_NFC"],
+    requires=[
+        "gui",
+        "dialogs",
+    ],
+    provides=["nfc_start"],
+    icon="A_NFC_14",
+    stack_size=5 * 1024,
+    order=30,
+)
+
+App(
+    appid="nfc_start",
+    apptype=FlipperAppType.STARTUP,
+    entry_point="nfc_on_system_start",
+    requires=["nfc"],
+    order=30,
+)

applications/main/nfc/helpers/nfc_custom_event.h

@@ -0,0 +1,15 @@
+#pragma once
+
+enum NfcCustomEvent {
+    // Reserve first 100 events for button types and indexes, starting from 0
+    NfcCustomEventReserved = 100,
+
+    NfcCustomEventViewExit,
+    NfcCustomEventWorkerExit,
+    NfcCustomEventByteInputDone,
+    NfcCustomEventTextInputDone,
+    NfcCustomEventDictAttackDone,
+    NfcCustomEventDictAttackSkip,
+    NfcCustomEventRpcLoad,
+    NfcCustomEventRpcSessionClose,
+};

applications/main/nfc/helpers/nfc_emv_parser.c

@@ -0,0 +1,82 @@
+#include "nfc_emv_parser.h"
+#include <flipper_format/flipper_format.h>
+
+static const char* nfc_resources_header = "Flipper EMV resources";
+static const uint32_t nfc_resources_file_version = 1;
+
+static bool nfc_emv_parser_search_data(
+    Storage* storage,
+    const char* file_name,
+    string_t key,
+    string_t data) {
+    bool parsed = false;
+    FlipperFormat* file = flipper_format_file_alloc(storage);
+    string_t temp_str;
+    string_init(temp_str);
+
+    do {
+        // Open file
+        if(!flipper_format_file_open_existing(file, file_name)) break;
+        // Read file header and version
+        uint32_t version = 0;
+        if(!flipper_format_read_header(file, temp_str, &version)) break;
+        if(string_cmp_str(temp_str, nfc_resources_header) ||
+           (version != nfc_resources_file_version))
+            break;
+        if(!flipper_format_read_string(file, string_get_cstr(key), data)) break;
+        parsed = true;
+    } while(false);
+
+    string_clear(temp_str);
+    flipper_format_free(file);
+    return parsed;
+}
+
+bool nfc_emv_parser_get_aid_name(
+    Storage* storage,
+    uint8_t* aid,
+    uint8_t aid_len,
+    string_t aid_name) {
+    furi_assert(storage);
+    bool parsed = false;
+    string_t key;
+    string_init(key);
+    for(uint8_t i = 0; i < aid_len; i++) {
+        string_cat_printf(key, "%02X", aid[i]);
+    }
+    if(nfc_emv_parser_search_data(storage, EXT_PATH("nfc/assets/aid.nfc"), key, aid_name)) {
+        parsed = true;
+    }
+    string_clear(key);
+    return parsed;
+}
+
+bool nfc_emv_parser_get_country_name(
+    Storage* storage,
+    uint16_t country_code,
+    string_t country_name) {
+    bool parsed = false;
+    string_t key;
+    string_init_printf(key, "%04X", country_code);
+    if(nfc_emv_parser_search_data(
+           storage, EXT_PATH("nfc/assets/country_code.nfc"), key, country_name)) {
+        parsed = true;
+    }
+    string_clear(key);
+    return parsed;
+}
+
+bool nfc_emv_parser_get_currency_name(
+    Storage* storage,
+    uint16_t currency_code,
+    string_t currency_name) {
+    bool parsed = false;
+    string_t key;
+    string_init_printf(key, "%04X", currency_code);
+    if(nfc_emv_parser_search_data(
+           storage, EXT_PATH("nfc/assets/currency_code.nfc"), key, currency_name)) {
+        parsed = true;
+    }
+    string_clear(key);
+    return parsed;
+}

applications/main/nfc/helpers/nfc_emv_parser.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <m-string.h>
+#include <storage/storage.h>
+
+/** Get EMV application name by number
+ * @param storage Storage instance
+ * @param aid - AID number array
+ * @param aid_len - AID length
+ * @param aid_name - string to keep AID name
+ * @return - true if AID found, false otherwies
+ */
+bool nfc_emv_parser_get_aid_name(
+    Storage* storage,
+    uint8_t* aid,
+    uint8_t aid_len,
+    string_t aid_name);
+
+/** Get country name by country code
+ * @param storage Storage instance
+ * @param country_code - ISO 3166 country code
+ * @param country_name - string to keep country name
+ * @return - true if country found, false otherwies
+ */
+bool nfc_emv_parser_get_country_name(
+    Storage* storage,
+    uint16_t country_code,
+    string_t country_name);
+
+/** Get currency name by currency code
+ * @param storage Storage instance
+ * @param currency_code - ISO 3166 currency code
+ * @param currency_name - string to keep currency name
+ * @return - true if currency found, false otherwies
+ */
+bool nfc_emv_parser_get_currency_name(
+    Storage* storage,
+    uint16_t currency_code,
+    string_t currency_name);

applications/main/nfc/helpers/nfc_generators.c

@@ -0,0 +1,492 @@
+#include <furi_hal_random.h>
+#include "nfc_generators.h"
+
+#define NXP_MANUFACTURER_ID (0x04)
+
+static const uint8_t version_bytes_mf0ulx1[] = {0x00, 0x04, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03};
+static const uint8_t version_bytes_ntag21x[] = {0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x03};
+static const uint8_t version_bytes_ntag_i2c[] = {0x00, 0x04, 0x04, 0x05, 0x02, 0x00, 0x00, 0x03};
+static const uint8_t default_data_ntag203[] =
+    {0xE1, 0x10, 0x12, 0x00, 0x01, 0x03, 0xA0, 0x10, 0x44, 0x03, 0x00, 0xFE};
+static const uint8_t default_data_ntag213[] = {0x01, 0x03, 0xA0, 0x0C, 0x34, 0x03, 0x00, 0xFE};
+static const uint8_t default_data_ntag215_216[] = {0x03, 0x00, 0xFE};
+static const uint8_t default_data_ntag_i2c[] = {0xE1, 0x10, 0x00, 0x00, 0x03, 0x00, 0xFE};
+static const uint8_t default_config_ntag_i2c[] = {0x01, 0x00, 0xF8, 0x48, 0x08, 0x01, 0x00, 0x00};
+
+static void nfc_generate_common_start(NfcDeviceData* data) {
+    nfc_device_data_clear(data);
+}
+
+static void nfc_generate_mf_ul_uid(uint8_t* uid) {
+    uid[0] = NXP_MANUFACTURER_ID;
+    furi_hal_random_fill_buf(&uid[1], 6);
+    // I'm not sure how this is generated, but the upper nybble always seems to be 8
+    uid[6] &= 0x0F;
+    uid[6] |= 0x80;
+}
+
+static void nfc_generate_mf_classic_uid(uint8_t* uid, uint8_t length) {
+    uid[0] = NXP_MANUFACTURER_ID;
+    furi_hal_random_fill_buf(&uid[1], length - 1);
+}
+
+static void nfc_generate_mf_classic_block_0(uint8_t* block, uint8_t uid_len) {
+    // Block length is always 16 bytes, and the UID can be either 4 or 7 bytes
+    furi_assert(uid_len == 4 || uid_len == 7);
+    furi_assert(block);
+    nfc_generate_mf_classic_uid(block, uid_len);
+    for(int i = uid_len; i < 16; i++) {
+        block[i] = 0xFF;
+    }
+}
+
+static void nfc_generate_mf_classic_sector_trailer(MfClassicData* data, uint8_t block) {
+    // All keys are set to FFFF FFFF FFFFh at chip delivery and the bytes 6, 7 and 8 are set to FF0780h.
+    MfClassicSectorTrailer* sec_tr = (MfClassicSectorTrailer*)data->block[block].value;
+    sec_tr->access_bits[0] = 0xFF;
+    sec_tr->access_bits[1] = 0x07;
+    sec_tr->access_bits[2] = 0x80;
+    sec_tr->access_bits[3] = 0x69; // Nice
+
+    memset(sec_tr->key_a, 0xff, sizeof(sec_tr->key_a));
+    memset(sec_tr->key_b, 0xff, sizeof(sec_tr->key_b));
+
+    mf_classic_set_block_read(data, block, &data->block[block]);
+    mf_classic_set_key_found(
+        data, mf_classic_get_sector_by_block(block), MfClassicKeyA, 0xFFFFFFFFFFFF);
+    mf_classic_set_key_found(
+        data, mf_classic_get_sector_by_block(block), MfClassicKeyB, 0xFFFFFFFFFFFF);
+}
+
+static void nfc_generate_mf_ul_common(NfcDeviceData* data) {
+    data->nfc_data.type = FuriHalNfcTypeA;
+    data->nfc_data.interface = FuriHalNfcInterfaceRf;
+    data->nfc_data.uid_len = 7;
+    nfc_generate_mf_ul_uid(data->nfc_data.uid);
+    data->nfc_data.atqa[0] = 0x44;
+    data->nfc_data.atqa[1] = 0x00;
+    data->nfc_data.sak = 0x00;
+    data->protocol = NfcDeviceProtocolMifareUl;
+}
+
+static void
+    nfc_generate_mf_classic_common(NfcDeviceData* data, uint8_t uid_len, MfClassicType type) {
+    data->nfc_data.type = FuriHalNfcTypeA;
+    data->nfc_data.interface = FuriHalNfcInterfaceRf;
+    data->nfc_data.uid_len = uid_len;
+    nfc_generate_mf_classic_block_0(data->mf_classic_data.block[0].value, uid_len);
+    data->nfc_data.atqa[0] = 0x44;
+    data->nfc_data.atqa[1] = 0x00;
+    data->nfc_data.sak = 0x08;
+    data->protocol = NfcDeviceProtocolMifareClassic;
+    data->mf_classic_data.type = type;
+}
+
+static void nfc_generate_calc_bcc(uint8_t* uid, uint8_t* bcc0, uint8_t* bcc1) {
+    *bcc0 = 0x88 ^ uid[0] ^ uid[1] ^ uid[2];
+    *bcc1 = uid[3] ^ uid[4] ^ uid[5] ^ uid[6];
+}
+
+static void nfc_generate_mf_ul_copy_uid_with_bcc(NfcDeviceData* data) {
+    MfUltralightData* mful = &data->mf_ul_data;
+    memcpy(mful->data, data->nfc_data.uid, 3);
+    memcpy(&mful->data[4], &data->nfc_data.uid[3], 4);
+    nfc_generate_calc_bcc(data->nfc_data.uid, &mful->data[3], &mful->data[8]);
+}
+
+static void nfc_generate_mf_ul_orig(NfcDeviceData* data) {
+    nfc_generate_common_start(data);
+    nfc_generate_mf_ul_common(data);
+
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeUnknown;
+    mful->data_size = 16 * 4;
+    mful->data_read = mful->data_size;
+    nfc_generate_mf_ul_copy_uid_with_bcc(data);
+    // TODO: what's internal byte on page 2?
+    memset(&mful->data[4 * 4], 0xFF, 4);
+}
+
+static void nfc_generate_mf_ul_ntag203(NfcDeviceData* data) {
+    nfc_generate_common_start(data);
+    nfc_generate_mf_ul_common(data);
+
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeNTAG203;
+    mful->data_size = 42 * 4;
+    mful->data_read = mful->data_size;
+    nfc_generate_mf_ul_copy_uid_with_bcc(data);
+    mful->data[9] = 0x48; // Internal byte
+    memcpy(&mful->data[3 * 4], default_data_ntag203, sizeof(default_data_ntag203));
+}
+
+static void nfc_generate_mf_ul_with_config_common(NfcDeviceData* data, uint8_t num_pages) {
+    nfc_generate_common_start(data);
+    nfc_generate_mf_ul_common(data);
+
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->data_size = num_pages * 4;
+    mful->data_read = mful->data_size;
+    nfc_generate_mf_ul_copy_uid_with_bcc(data);
+    uint16_t config_index = (num_pages - 4) * 4;
+    mful->data[config_index] = 0x04; // STRG_MOD_EN
+    mful->data[config_index + 3] = 0xFF; // AUTH0
+    mful->data[config_index + 5] = 0x05; // VCTID
+    memset(&mful->data[config_index + 8], 0xFF, 4); // Default PWD
+    if(num_pages > 20) mful->data[config_index - 1] = MF_UL_TEARING_FLAG_DEFAULT;
+}
+
+static void nfc_generate_mf_ul_ev1_common(NfcDeviceData* data, uint8_t num_pages) {
+    nfc_generate_mf_ul_with_config_common(data, num_pages);
+    MfUltralightData* mful = &data->mf_ul_data;
+    memcpy(&mful->version, version_bytes_mf0ulx1, sizeof(version_bytes_mf0ulx1));
+    for(size_t i = 0; i < 3; ++i) {
+        mful->tearing[i] = MF_UL_TEARING_FLAG_DEFAULT;
+    }
+    // TODO: what's internal byte on page 2?
+}
+
+static void nfc_generate_mf_ul_11(NfcDeviceData* data) {
+    nfc_generate_mf_ul_ev1_common(data, 20);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeUL11;
+    mful->version.prod_subtype = 0x01;
+    mful->version.storage_size = 0x0B;
+    mful->data[16 * 4] = 0x00; // Low capacitance version does not have STRG_MOD_EN
+}
+
+static void nfc_generate_mf_ul_h11(NfcDeviceData* data) {
+    nfc_generate_mf_ul_ev1_common(data, 20);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeUL11;
+    mful->version.prod_subtype = 0x02;
+    mful->version.storage_size = 0x0B;
+}
+
+static void nfc_generate_mf_ul_21(NfcDeviceData* data) {
+    nfc_generate_mf_ul_ev1_common(data, 41);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeUL21;
+    mful->version.prod_subtype = 0x01;
+    mful->version.storage_size = 0x0E;
+    mful->data[37 * 4] = 0x00; // Low capacitance version does not have STRG_MOD_EN
+}
+
+static void nfc_generate_mf_ul_h21(NfcDeviceData* data) {
+    nfc_generate_mf_ul_ev1_common(data, 41);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeUL21;
+    mful->version.prod_subtype = 0x02;
+    mful->version.storage_size = 0x0E;
+}
+
+static void nfc_generate_ntag21x_common(NfcDeviceData* data, uint8_t num_pages) {
+    nfc_generate_mf_ul_with_config_common(data, num_pages);
+    MfUltralightData* mful = &data->mf_ul_data;
+    memcpy(&mful->version, version_bytes_ntag21x, sizeof(version_bytes_mf0ulx1));
+    mful->data[9] = 0x48; // Internal byte
+    // Capability container
+    mful->data[12] = 0xE1;
+    mful->data[13] = 0x10;
+}
+
+static void nfc_generate_ntag213(NfcDeviceData* data) {
+    nfc_generate_ntag21x_common(data, 45);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeNTAG213;
+    mful->version.storage_size = 0x0F;
+    mful->data[14] = 0x12;
+    // Default contents
+    memcpy(&mful->data[16], default_data_ntag213, sizeof(default_data_ntag213));
+}
+
+static void nfc_generate_ntag215(NfcDeviceData* data) {
+    nfc_generate_ntag21x_common(data, 135);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeNTAG215;
+    mful->version.storage_size = 0x11;
+    mful->data[14] = 0x3E;
+    // Default contents
+    memcpy(&mful->data[16], default_data_ntag215_216, sizeof(default_data_ntag215_216));
+}
+
+static void nfc_generate_ntag216(NfcDeviceData* data) {
+    nfc_generate_ntag21x_common(data, 231);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = MfUltralightTypeNTAG216;
+    mful->version.storage_size = 0x13;
+    mful->data[14] = 0x6D;
+    // Default contents
+    memcpy(&mful->data[16], default_data_ntag215_216, sizeof(default_data_ntag215_216));
+}
+
+static void
+    nfc_generate_ntag_i2c_common(NfcDeviceData* data, MfUltralightType type, uint16_t num_pages) {
+    nfc_generate_common_start(data);
+    nfc_generate_mf_ul_common(data);
+
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->type = type;
+    memcpy(&mful->version, version_bytes_ntag_i2c, sizeof(version_bytes_ntag_i2c));
+    mful->data_size = num_pages * 4;
+    mful->data_read = mful->data_size;
+    memcpy(mful->data, data->nfc_data.uid, data->nfc_data.uid_len);
+    mful->data[7] = data->nfc_data.sak;
+    mful->data[8] = data->nfc_data.atqa[0];
+    mful->data[9] = data->nfc_data.atqa[1];
+
+    uint16_t config_register_page;
+    uint16_t session_register_page;
+
+    // Sync with mifare_ultralight.c
+    switch(type) {
+    case MfUltralightTypeNTAGI2C1K:
+        config_register_page = 227;
+        session_register_page = 229;
+        break;
+    case MfUltralightTypeNTAGI2C2K:
+        config_register_page = 481;
+        session_register_page = 483;
+        break;
+    case MfUltralightTypeNTAGI2CPlus1K:
+    case MfUltralightTypeNTAGI2CPlus2K:
+        config_register_page = 232;
+        session_register_page = 234;
+        break;
+    default:
+        furi_crash("Unknown MFUL");
+        break;
+    }
+
+    memcpy(
+        &mful->data[config_register_page * 4],
+        default_config_ntag_i2c,
+        sizeof(default_config_ntag_i2c));
+    memcpy(
+        &mful->data[session_register_page * 4],
+        default_config_ntag_i2c,
+        sizeof(default_config_ntag_i2c));
+}
+
+static void nfc_generate_ntag_i2c_1k(NfcDeviceData* data) {
+    nfc_generate_ntag_i2c_common(data, MfUltralightTypeNTAGI2C1K, 231);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->version.prod_ver_minor = 0x01;
+    mful->version.storage_size = 0x13;
+
+    memcpy(&mful->data[12], default_data_ntag_i2c, sizeof(default_data_ntag_i2c));
+    mful->data[14] = 0x6D; // Size of tag in CC
+}
+
+static void nfc_generate_ntag_i2c_2k(NfcDeviceData* data) {
+    nfc_generate_ntag_i2c_common(data, MfUltralightTypeNTAGI2C2K, 485);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->version.prod_ver_minor = 0x01;
+    mful->version.storage_size = 0x15;
+
+    memcpy(&mful->data[12], default_data_ntag_i2c, sizeof(default_data_ntag_i2c));
+    mful->data[14] = 0xEA; // Size of tag in CC
+}
+
+static void nfc_generate_ntag_i2c_plus_common(
+    NfcDeviceData* data,
+    MfUltralightType type,
+    uint16_t num_pages) {
+    nfc_generate_ntag_i2c_common(data, type, num_pages);
+
+    MfUltralightData* mful = &data->mf_ul_data;
+    uint16_t config_index = 227 * 4;
+    mful->data[config_index + 3] = 0xFF; // AUTH0
+    memset(&mful->data[config_index + 8], 0xFF, 4); // Default PWD
+}
+
+static void nfc_generate_ntag_i2c_plus_1k(NfcDeviceData* data) {
+    nfc_generate_ntag_i2c_plus_common(data, MfUltralightTypeNTAGI2CPlus1K, 236);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->version.prod_ver_minor = 0x02;
+    mful->version.storage_size = 0x13;
+}
+
+static void nfc_generate_ntag_i2c_plus_2k(NfcDeviceData* data) {
+    nfc_generate_ntag_i2c_plus_common(data, MfUltralightTypeNTAGI2CPlus2K, 492);
+    MfUltralightData* mful = &data->mf_ul_data;
+    mful->version.prod_ver_minor = 0x02;
+    mful->version.storage_size = 0x15;
+}
+
+static void nfc_generate_mf_classic(NfcDeviceData* data, uint8_t uid_len, MfClassicType type) {
+    nfc_generate_common_start(data);
+    nfc_generate_mf_classic_common(data, uid_len, type);
+
+    // Set the UID
+    data->nfc_data.uid[0] = NXP_MANUFACTURER_ID;
+    for(int i = 1; i < uid_len; i++) {
+        data->nfc_data.uid[i] = data->mf_classic_data.block[0].value[i];
+    }
+
+    MfClassicData* mfc = &data->mf_classic_data;
+    mf_classic_set_block_read(mfc, 0, &mfc->block[0]);
+
+    if(type == MfClassicType4k) {
+        // Set every block to 0xFF
+        for(uint16_t i = 1; i < 256; i += 1) {
+            if(mf_classic_is_sector_trailer(i)) {
+                nfc_generate_mf_classic_sector_trailer(mfc, i);
+            } else {
+                memset(&mfc->block[i].value, 0xFF, 16);
+            }
+            mf_classic_set_block_read(mfc, i, &mfc->block[i]);
+        }
+    } else if(type == MfClassicType1k) {
+        // Set every block to 0xFF
+        for(uint16_t i = 1; i < MF_CLASSIC_1K_TOTAL_SECTORS_NUM * 4; i += 1) {
+            if(mf_classic_is_sector_trailer(i)) {
+                nfc_generate_mf_classic_sector_trailer(mfc, i);
+            } else {
+                memset(&mfc->block[i].value, 0xFF, 16);
+            }
+            mf_classic_set_block_read(mfc, i, &mfc->block[i]);
+        }
+    }
+
+    mfc->type = type;
+}
+
+static void nfc_generate_mf_classic_1k_4b_uid(NfcDeviceData* data) {
+    nfc_generate_mf_classic(data, 4, MfClassicType1k);
+}
+
+static void nfc_generate_mf_classic_1k_7b_uid(NfcDeviceData* data) {
+    nfc_generate_mf_classic(data, 7, MfClassicType1k);
+}
+
+static void nfc_generate_mf_classic_4k_4b_uid(NfcDeviceData* data) {
+    nfc_generate_mf_classic(data, 4, MfClassicType4k);
+}
+
+static void nfc_generate_mf_classic_4k_7b_uid(NfcDeviceData* data) {
+    nfc_generate_mf_classic(data, 7, MfClassicType4k);
+}
+
+static const NfcGenerator mf_ul_generator = {
+    .name = "Mifare Ultralight",
+    .generator_func = nfc_generate_mf_ul_orig,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator mf_ul_11_generator = {
+    .name = "Mifare Ultralight EV1 11",
+    .generator_func = nfc_generate_mf_ul_11,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator mf_ul_h11_generator = {
+    .name = "Mifare Ultralight EV1 H11",
+    .generator_func = nfc_generate_mf_ul_h11,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator mf_ul_21_generator = {
+    .name = "Mifare Ultralight EV1 21",
+    .generator_func = nfc_generate_mf_ul_21,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator mf_ul_h21_generator = {
+    .name = "Mifare Ultralight EV1 H21",
+    .generator_func = nfc_generate_mf_ul_h21,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag203_generator = {
+    .name = "NTAG203",
+    .generator_func = nfc_generate_mf_ul_ntag203,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag213_generator = {
+    .name = "NTAG213",
+    .generator_func = nfc_generate_ntag213,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag215_generator = {
+    .name = "NTAG215",
+    .generator_func = nfc_generate_ntag215,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag216_generator = {
+    .name = "NTAG216",
+    .generator_func = nfc_generate_ntag216,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag_i2c_1k_generator = {
+    .name = "NTAG I2C 1k",
+    .generator_func = nfc_generate_ntag_i2c_1k,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag_i2c_2k_generator = {
+    .name = "NTAG I2C 2k",
+    .generator_func = nfc_generate_ntag_i2c_2k,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag_i2c_plus_1k_generator = {
+    .name = "NTAG I2C Plus 1k",
+    .generator_func = nfc_generate_ntag_i2c_plus_1k,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator ntag_i2c_plus_2k_generator = {
+    .name = "NTAG I2C Plus 2k",
+    .generator_func = nfc_generate_ntag_i2c_plus_2k,
+    .next_scene = NfcSceneMfUltralightMenu,
+};
+
+static const NfcGenerator mifare_classic_1k_4b_uid_generator = {
+    .name = "Mifare Classic 1k 4byte UID",
+    .generator_func = nfc_generate_mf_classic_1k_4b_uid,
+    .next_scene = NfcSceneMfClassicMenu,
+};
+
+static const NfcGenerator mifare_classic_1k_7b_uid_generator = {
+    .name = "Mifare Classic 1k 7byte UID",
+    .generator_func = nfc_generate_mf_classic_1k_7b_uid,
+    .next_scene = NfcSceneMfClassicMenu,
+};
+
+static const NfcGenerator mifare_classic_4k_4b_uid_generator = {
+    .name = "Mifare Classic 4k 4byte UID",
+    .generator_func = nfc_generate_mf_classic_4k_4b_uid,
+    .next_scene = NfcSceneMfClassicMenu,
+};
+
+static const NfcGenerator mifare_classic_4k_7b_uid_generator = {
+    .name = "Mifare Classic 4k 7byte UID",
+    .generator_func = nfc_generate_mf_classic_4k_7b_uid,
+    .next_scene = NfcSceneMfClassicMenu,
+};
+
+const NfcGenerator* const nfc_generators[] = {
+    &mf_ul_generator,
+    &mf_ul_11_generator,
+    &mf_ul_h11_generator,
+    &mf_ul_21_generator,
+    &mf_ul_h21_generator,
+    &ntag203_generator,
+    &ntag213_generator,
+    &ntag215_generator,
+    &ntag216_generator,
+    &ntag_i2c_1k_generator,
+    &ntag_i2c_2k_generator,
+    &ntag_i2c_plus_1k_generator,
+    &ntag_i2c_plus_2k_generator,
+    &mifare_classic_1k_4b_uid_generator,
+    &mifare_classic_1k_7b_uid_generator,
+    &mifare_classic_4k_4b_uid_generator,
+    &mifare_classic_4k_7b_uid_generator,
+    NULL,
+};

applications/main/nfc/helpers/nfc_generators.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../nfc_i.h"
+
+typedef void (*NfcGeneratorFunc)(NfcDeviceData* data);
+
+struct NfcGenerator {
+    const char* name;
+    NfcGeneratorFunc generator_func;
+    NfcScene next_scene;
+};
+
+extern const NfcGenerator* const nfc_generators[];

applications/main/nfc/nfc.c

@@ -0,0 +1,269 @@
+#include "nfc_i.h"
+#include "furi_hal_nfc.h"
+
+bool nfc_custom_event_callback(void* context, uint32_t event) {
+    furi_assert(context);
+    Nfc* nfc = context;
+    return scene_manager_handle_custom_event(nfc->scene_manager, event);
+}
+
+bool nfc_back_event_callback(void* context) {
+    furi_assert(context);
+    Nfc* nfc = context;
+    return scene_manager_handle_back_event(nfc->scene_manager);
+}
+
+static void nfc_rpc_command_callback(RpcAppSystemEvent event, void* context) {
+    furi_assert(context);
+    Nfc* nfc = context;
+
+    furi_assert(nfc->rpc_ctx);
+
+    if(event == RpcAppEventSessionClose) {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventRpcSessionClose);
+        rpc_system_app_set_callback(nfc->rpc_ctx, NULL, NULL);
+        nfc->rpc_ctx = NULL;
+    } else if(event == RpcAppEventAppExit) {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+    } else if(event == RpcAppEventLoadFile) {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventRpcLoad);
+    } else {
+        rpc_system_app_confirm(nfc->rpc_ctx, event, false);
+    }
+}
+
+Nfc* nfc_alloc() {
+    Nfc* nfc = malloc(sizeof(Nfc));
+
+    nfc->worker = nfc_worker_alloc();
+    nfc->view_dispatcher = view_dispatcher_alloc();
+    nfc->scene_manager = scene_manager_alloc(&nfc_scene_handlers, nfc);
+    view_dispatcher_enable_queue(nfc->view_dispatcher);
+    view_dispatcher_set_event_callback_context(nfc->view_dispatcher, nfc);
+    view_dispatcher_set_custom_event_callback(nfc->view_dispatcher, nfc_custom_event_callback);
+    view_dispatcher_set_navigation_event_callback(nfc->view_dispatcher, nfc_back_event_callback);
+
+    // Nfc device
+    nfc->dev = nfc_device_alloc();
+
+    // Open GUI record
+    nfc->gui = furi_record_open(RECORD_GUI);
+
+    // Open Notification record
+    nfc->notifications = furi_record_open(RECORD_NOTIFICATION);
+
+    // Submenu
+    nfc->submenu = submenu_alloc();
+    view_dispatcher_add_view(nfc->view_dispatcher, NfcViewMenu, submenu_get_view(nfc->submenu));
+
+    // Dialog
+    nfc->dialog_ex = dialog_ex_alloc();
+    view_dispatcher_add_view(
+        nfc->view_dispatcher, NfcViewDialogEx, dialog_ex_get_view(nfc->dialog_ex));
+
+    // Popup
+    nfc->popup = popup_alloc();
+    view_dispatcher_add_view(nfc->view_dispatcher, NfcViewPopup, popup_get_view(nfc->popup));
+
+    // Loading
+    nfc->loading = loading_alloc();
+    view_dispatcher_add_view(nfc->view_dispatcher, NfcViewLoading, loading_get_view(nfc->loading));
+
+    // Text Input
+    nfc->text_input = text_input_alloc();
+    view_dispatcher_add_view(
+        nfc->view_dispatcher, NfcViewTextInput, text_input_get_view(nfc->text_input));
+
+    // Byte Input
+    nfc->byte_input = byte_input_alloc();
+    view_dispatcher_add_view(
+        nfc->view_dispatcher, NfcViewByteInput, byte_input_get_view(nfc->byte_input));
+
+    // TextBox
+    nfc->text_box = text_box_alloc();
+    view_dispatcher_add_view(
+        nfc->view_dispatcher, NfcViewTextBox, text_box_get_view(nfc->text_box));
+    string_init(nfc->text_box_store);
+
+    // Custom Widget
+    nfc->widget = widget_alloc();
+    view_dispatcher_add_view(nfc->view_dispatcher, NfcViewWidget, widget_get_view(nfc->widget));
+
+    // Mifare Classic Dict Attack
+    nfc->dict_attack = dict_attack_alloc();
+    view_dispatcher_add_view(
+        nfc->view_dispatcher, NfcViewDictAttack, dict_attack_get_view(nfc->dict_attack));
+
+    // Detect Reader
+    nfc->detect_reader = detect_reader_alloc();
+    view_dispatcher_add_view(
+        nfc->view_dispatcher, NfcViewDetectReader, detect_reader_get_view(nfc->detect_reader));
+
+    // Generator
+    nfc->generator = NULL;
+
+    return nfc;
+}
+
+void nfc_free(Nfc* nfc) {
+    furi_assert(nfc);
+
+    if(nfc->rpc_state == NfcRpcStateEmulating) {
+        // Stop worker
+        nfc_worker_stop(nfc->worker);
+    } else if(nfc->rpc_state == NfcRpcStateEmulated) {
+        // Stop worker
+        nfc_worker_stop(nfc->worker);
+        // Save data in shadow file
+        nfc_device_save_shadow(nfc->dev, nfc->dev->dev_name);
+    }
+    if(nfc->rpc_ctx) {
+        rpc_system_app_send_exited(nfc->rpc_ctx);
+        rpc_system_app_set_callback(nfc->rpc_ctx, NULL, NULL);
+        nfc->rpc_ctx = NULL;
+    }
+
+    // Nfc device
+    nfc_device_free(nfc->dev);
+
+    // Submenu
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewMenu);
+    submenu_free(nfc->submenu);
+
+    // DialogEx
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewDialogEx);
+    dialog_ex_free(nfc->dialog_ex);
+
+    // Popup
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewPopup);
+    popup_free(nfc->popup);
+
+    // Loading
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewLoading);
+    loading_free(nfc->loading);
+
+    // TextInput
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewTextInput);
+    text_input_free(nfc->text_input);
+
+    // ByteInput
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewByteInput);
+    byte_input_free(nfc->byte_input);
+
+    // TextBox
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewTextBox);
+    text_box_free(nfc->text_box);
+    string_clear(nfc->text_box_store);
+
+    // Custom Widget
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewWidget);
+    widget_free(nfc->widget);
+
+    // Mifare Classic Dict Attack
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewDictAttack);
+    dict_attack_free(nfc->dict_attack);
+
+    // Detect Reader
+    view_dispatcher_remove_view(nfc->view_dispatcher, NfcViewDetectReader);
+    detect_reader_free(nfc->detect_reader);
+
+    // Worker
+    nfc_worker_stop(nfc->worker);
+    nfc_worker_free(nfc->worker);
+
+    // View Dispatcher
+    view_dispatcher_free(nfc->view_dispatcher);
+
+    // Scene Manager
+    scene_manager_free(nfc->scene_manager);
+
+    // GUI
+    furi_record_close(RECORD_GUI);
+    nfc->gui = NULL;
+
+    // Notifications
+    furi_record_close(RECORD_NOTIFICATION);
+    nfc->notifications = NULL;
+
+    free(nfc);
+}
+
+void nfc_text_store_set(Nfc* nfc, const char* text, ...) {
+    va_list args;
+    va_start(args, text);
+
+    vsnprintf(nfc->text_store, sizeof(nfc->text_store), text, args);
+
+    va_end(args);
+}
+
+void nfc_text_store_clear(Nfc* nfc) {
+    memset(nfc->text_store, 0, sizeof(nfc->text_store));
+}
+
+void nfc_blink_start(Nfc* nfc) {
+    notification_message(nfc->notifications, &sequence_blink_start_blue);
+}
+
+void nfc_blink_stop(Nfc* nfc) {
+    notification_message(nfc->notifications, &sequence_blink_stop);
+}
+
+void nfc_show_loading_popup(void* context, bool show) {
+    Nfc* nfc = context;
+    TaskHandle_t timer_task = xTaskGetHandle(configTIMER_SERVICE_TASK_NAME);
+
+    if(show) {
+        // Raise timer priority so that animations can play
+        vTaskPrioritySet(timer_task, configMAX_PRIORITIES - 1);
+        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewLoading);
+    } else {
+        // Restore default timer priority
+        vTaskPrioritySet(timer_task, configTIMER_TASK_PRIORITY);
+    }
+}
+
+int32_t nfc_app(void* p) {
+    Nfc* nfc = nfc_alloc();
+    char* args = p;
+
+    // Check argument and run corresponding scene
+    if(args && strlen(args)) {
+        nfc_device_set_loading_callback(nfc->dev, nfc_show_loading_popup, nfc);
+        uint32_t rpc_ctx = 0;
+        if(sscanf(p, "RPC %lX", &rpc_ctx) == 1) {
+            nfc->rpc_ctx = (void*)rpc_ctx;
+            rpc_system_app_set_callback(nfc->rpc_ctx, nfc_rpc_command_callback, nfc);
+            rpc_system_app_send_started(nfc->rpc_ctx);
+            view_dispatcher_attach_to_gui(
+                nfc->view_dispatcher, nfc->gui, ViewDispatcherTypeDesktop);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRpc);
+        } else {
+            view_dispatcher_attach_to_gui(
+                nfc->view_dispatcher, nfc->gui, ViewDispatcherTypeFullscreen);
+            if(nfc_device_load(nfc->dev, p, true)) {
+                if(nfc->dev->format == NfcDeviceSaveFormatMifareUl) {
+                    scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
+                } else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
+                    scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicEmulate);
+                } else {
+                    scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
+                }
+            } else {
+                // Exit app
+                view_dispatcher_stop(nfc->view_dispatcher);
+            }
+        }
+        nfc_device_set_loading_callback(nfc->dev, NULL, nfc);
+    } else {
+        view_dispatcher_attach_to_gui(
+            nfc->view_dispatcher, nfc->gui, ViewDispatcherTypeFullscreen);
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneStart);
+    }
+
+    view_dispatcher_run(nfc->view_dispatcher);
+
+    nfc_free(nfc);
+
+    return 0;
+}

applications/main/nfc/nfc.h

@@ -0,0 +1,3 @@
+#pragma once
+
+typedef struct Nfc Nfc;

applications/main/nfc/nfc_cli.c

@@ -0,0 +1,141 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <cli/cli.h>
+#include <lib/toolbox/args.h>
+
+#include <lib/nfc/nfc_types.h>
+#include <lib/nfc/nfc_device.h>
+
+static void nfc_cli_print_usage() {
+    printf("Usage:\r\n");
+    printf("nfc <cmd>\r\n");
+    printf("Cmd list:\r\n");
+    printf("\tdetect\t - detect nfc device\r\n");
+    printf("\temulate\t - emulate predefined nfca card\r\n");
+    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
+        printf("\tfield\t - turn field on\r\n");
+    }
+}
+
+static void nfc_cli_detect(Cli* cli, string_t args) {
+    UNUSED(args);
+    // Check if nfc worker is not busy
+    if(furi_hal_nfc_is_busy()) {
+        printf("Nfc is busy\r\n");
+        return;
+    }
+
+    FuriHalNfcDevData dev_data = {};
+    bool cmd_exit = false;
+    furi_hal_nfc_exit_sleep();
+    printf("Detecting nfc...\r\nPress Ctrl+C to abort\r\n");
+    while(!cmd_exit) {
+        cmd_exit |= cli_cmd_interrupt_received(cli);
+        if(furi_hal_nfc_detect(&dev_data, 400)) {
+            printf("found: %s ", nfc_get_dev_type(dev_data.type));
+            printf("UID length: %d, UID:", dev_data.uid_len);
+            for(size_t i = 0; i < dev_data.uid_len; i++) {
+                printf("%02X", dev_data.uid[i]);
+            }
+            printf("\r\n");
+            break;
+        }
+        furi_hal_nfc_sleep();
+        furi_delay_ms(50);
+    }
+    furi_hal_nfc_sleep();
+}
+
+static void nfc_cli_emulate(Cli* cli, string_t args) {
+    UNUSED(args);
+    // Check if nfc worker is not busy
+    if(furi_hal_nfc_is_busy()) {
+        printf("Nfc is busy\r\n");
+        return;
+    }
+
+    furi_hal_nfc_exit_sleep();
+    printf("Emulating NFC-A Type: T2T UID: 36 9C E7 B1 0A C1 34 SAK: 00 ATQA: 00/44\r\n");
+    printf("Press Ctrl+C to abort\r\n");
+
+    FuriHalNfcDevData params = {
+        .uid = {0x36, 0x9C, 0xe7, 0xb1, 0x0A, 0xC1, 0x34},
+        .uid_len = 7,
+        .atqa = {0x44, 0x00},
+        .sak = 0x00,
+        .type = FuriHalNfcTypeA,
+    };
+
+    while(!cli_cmd_interrupt_received(cli)) {
+        if(furi_hal_nfc_listen(params.uid, params.uid_len, params.atqa, params.sak, false, 100)) {
+            printf("Reader detected\r\n");
+            furi_hal_nfc_sleep();
+        }
+        furi_delay_ms(50);
+    }
+    furi_hal_nfc_sleep();
+}
+
+static void nfc_cli_field(Cli* cli, string_t args) {
+    UNUSED(args);
+    // Check if nfc worker is not busy
+    if(furi_hal_nfc_is_busy()) {
+        printf("Nfc is busy\r\n");
+        return;
+    }
+
+    furi_hal_nfc_exit_sleep();
+    furi_hal_nfc_field_on();
+
+    printf("Field is on. Don't leave device in this mode for too long.\r\n");
+    printf("Press Ctrl+C to abort\r\n");
+
+    while(!cli_cmd_interrupt_received(cli)) {
+        furi_delay_ms(50);
+    }
+
+    furi_hal_nfc_field_off();
+    furi_hal_nfc_sleep();
+}
+
+static void nfc_cli(Cli* cli, string_t args, void* context) {
+    UNUSED(context);
+    string_t cmd;
+    string_init(cmd);
+
+    do {
+        if(!args_read_string_and_trim(args, cmd)) {
+            nfc_cli_print_usage();
+            break;
+        }
+        if(string_cmp_str(cmd, "detect") == 0) {
+            nfc_cli_detect(cli, args);
+            break;
+        }
+        if(string_cmp_str(cmd, "emulate") == 0) {
+            nfc_cli_emulate(cli, args);
+            break;
+        }
+
+        if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
+            if(string_cmp_str(cmd, "field") == 0) {
+                nfc_cli_field(cli, args);
+                break;
+            }
+        }
+
+        nfc_cli_print_usage();
+    } while(false);
+
+    string_clear(cmd);
+}
+
+void nfc_on_system_start() {
+#ifdef SRV_CLI
+    Cli* cli = furi_record_open(RECORD_CLI);
+    cli_add_command(cli, "nfc", CliCommandFlagDefault, nfc_cli, NULL);
+    furi_record_close(RECORD_CLI);
+#else
+    UNUSED(nfc_cli);
+#endif
+}

applications/main/nfc/nfc_i.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include "nfc.h"
+
+#include <furi.h>
+#include <furi_hal.h>
+
+#include <gui/gui.h>
+#include <gui/view.h>
+#include <gui/view_dispatcher.h>
+#include <gui/scene_manager.h>
+#include <cli/cli.h>
+#include <notification/notification_messages.h>
+
+#include <gui/modules/submenu.h>
+#include <gui/modules/dialog_ex.h>
+#include <gui/modules/popup.h>
+#include <gui/modules/loading.h>
+#include <gui/modules/text_input.h>
+#include <gui/modules/byte_input.h>
+#include <gui/modules/text_box.h>
+#include <gui/modules/widget.h>
+
+#include <lib/nfc/nfc_types.h>
+#include <lib/nfc/nfc_worker.h>
+#include <lib/nfc/nfc_device.h>
+#include <lib/nfc/helpers/mf_classic_dict.h>
+#include <lib/nfc/parsers/nfc_supported_card.h>
+
+#include "views/dict_attack.h"
+#include "views/detect_reader.h"
+
+#include <nfc/scenes/nfc_scene.h>
+#include <nfc/helpers/nfc_custom_event.h>
+
+#include "rpc/rpc_app.h"
+
+#define NFC_TEXT_STORE_SIZE 128
+
+typedef enum {
+    NfcRpcStateIdle,
+    NfcRpcStateEmulating,
+    NfcRpcStateEmulated,
+} NfcRpcState;
+
+// Forward declaration due to circular dependency
+typedef struct NfcGenerator NfcGenerator;
+
+struct Nfc {
+    NfcWorker* worker;
+    ViewDispatcher* view_dispatcher;
+    Gui* gui;
+    NotificationApp* notifications;
+    SceneManager* scene_manager;
+    NfcDevice* dev;
+    FuriHalNfcDevData dev_edit_data;
+
+    char text_store[NFC_TEXT_STORE_SIZE + 1];
+    string_t text_box_store;
+    uint8_t byte_input_store[6];
+
+    void* rpc_ctx;
+    NfcRpcState rpc_state;
+
+    // Common Views
+    Submenu* submenu;
+    DialogEx* dialog_ex;
+    Popup* popup;
+    Loading* loading;
+    TextInput* text_input;
+    ByteInput* byte_input;
+    TextBox* text_box;
+    Widget* widget;
+    DictAttack* dict_attack;
+    DetectReader* detect_reader;
+
+    const NfcGenerator* generator;
+};
+
+typedef enum {
+    NfcViewMenu,
+    NfcViewDialogEx,
+    NfcViewPopup,
+    NfcViewLoading,
+    NfcViewTextInput,
+    NfcViewByteInput,
+    NfcViewTextBox,
+    NfcViewWidget,
+    NfcViewDictAttack,
+    NfcViewDetectReader,
+} NfcView;
+
+Nfc* nfc_alloc();
+
+int32_t nfc_task(void* p);
+
+void nfc_text_store_set(Nfc* nfc, const char* text, ...);
+
+void nfc_text_store_clear(Nfc* nfc);
+
+void nfc_blink_start(Nfc* nfc);
+
+void nfc_blink_stop(Nfc* nfc);
+
+void nfc_show_loading_popup(void* context, bool show);

applications/main/nfc/scenes/nfc_scene.c

@@ -0,0 +1,30 @@
+#include "nfc_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const nfc_on_enter_handlers[])(void*) = {
+#include "nfc_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const nfc_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "nfc_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const nfc_on_exit_handlers[])(void* context) = {
+#include "nfc_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers nfc_scene_handlers = {
+    .on_enter_handlers = nfc_on_enter_handlers,
+    .on_event_handlers = nfc_on_event_handlers,
+    .on_exit_handlers = nfc_on_exit_handlers,
+    .scene_num = NfcSceneNum,
+};

applications/main/nfc/scenes/nfc_scene.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) NfcScene##id,
+typedef enum {
+#include "nfc_scene_config.h"
+    NfcSceneNum,
+} NfcScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers nfc_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "nfc_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
+#include "nfc_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
+#include "nfc_scene_config.h"
+#undef ADD_SCENE

applications/main/nfc/scenes/nfc_scene_config.h

@@ -0,0 +1,53 @@
+ADD_SCENE(nfc, start, Start)
+ADD_SCENE(nfc, read, Read)
+ADD_SCENE(nfc, saved_menu, SavedMenu)
+ADD_SCENE(nfc, extra_actions, ExtraActions)
+ADD_SCENE(nfc, set_type, SetType)
+ADD_SCENE(nfc, set_sak, SetSak)
+ADD_SCENE(nfc, set_atqa, SetAtqua)
+ADD_SCENE(nfc, set_uid, SetUid)
+ADD_SCENE(nfc, generate_info, GenerateInfo)
+ADD_SCENE(nfc, read_card_success, ReadCardSuccess)
+ADD_SCENE(nfc, save_name, SaveName)
+ADD_SCENE(nfc, save_success, SaveSuccess)
+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, mf_ultralight_read_success, MfUltralightReadSuccess)
+ADD_SCENE(nfc, mf_ultralight_data, MfUltralightData)
+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)
+ADD_SCENE(nfc, mf_desfire_app, MfDesfireApp)
+ADD_SCENE(nfc, mf_classic_read_success, MfClassicReadSuccess)
+ADD_SCENE(nfc, mf_classic_menu, MfClassicMenu)
+ADD_SCENE(nfc, mf_classic_emulate, MfClassicEmulate)
+ADD_SCENE(nfc, mf_classic_keys, MfClassicKeys)
+ADD_SCENE(nfc, mf_classic_keys_add, MfClassicKeysAdd)
+ADD_SCENE(nfc, mf_classic_dict_attack, MfClassicDictAttack)
+ADD_SCENE(nfc, emv_read_success, EmvReadSuccess)
+ADD_SCENE(nfc, emv_menu, EmvMenu)
+ADD_SCENE(nfc, emulate_apdu_sequence, EmulateApduSequence)
+ADD_SCENE(nfc, device_info, DeviceInfo)
+ADD_SCENE(nfc, delete, Delete)
+ADD_SCENE(nfc, delete_success, DeleteSuccess)
+ADD_SCENE(nfc, restore_original_confirm, RestoreOriginalConfirm)
+ADD_SCENE(nfc, restore_original, RestoreOriginal)
+ADD_SCENE(nfc, debug, Debug)
+ADD_SCENE(nfc, field, Field)
+ADD_SCENE(nfc, dict_not_found, DictNotFound)
+ADD_SCENE(nfc, rpc, Rpc)
+ADD_SCENE(nfc, exit_confirm, ExitConfirm)
+ADD_SCENE(nfc, retry_confirm, RetryConfirm)
+ADD_SCENE(nfc, detect_reader, DetectReader)
+ADD_SCENE(nfc, mfkey_nonces_info, MfkeyNoncesInfo)
+ADD_SCENE(nfc, mfkey_complete, MfkeyComplete)
+ADD_SCENE(nfc, nfc_data_info, NfcDataInfo)

applications/main/nfc/scenes/nfc_scene_debug.c

@@ -0,0 +1,54 @@
+#include "../nfc_i.h"
+
+enum SubmenuDebugIndex {
+    SubmenuDebugIndexField,
+    SubmenuDebugIndexApdu,
+};
+
+void nfc_scene_debug_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_debug_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(
+        submenu, "Field", SubmenuDebugIndexField, nfc_scene_debug_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Apdu", SubmenuDebugIndexApdu, nfc_scene_debug_submenu_callback, nfc);
+
+    submenu_set_selected_item(
+        submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneDebug));
+
+    nfc_device_clear(nfc->dev);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_debug_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuDebugIndexField) {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneDebug, SubmenuDebugIndexField);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneField);
+            consumed = true;
+        } else if(event.event == SubmenuDebugIndexApdu) {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneDebug, SubmenuDebugIndexApdu);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateApduSequence);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_debug_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_delete.c

@@ -0,0 +1,77 @@
+#include "../nfc_i.h"
+
+void nfc_scene_delete_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_delete_on_enter(void* context) {
+    Nfc* nfc = context;
+    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
+
+    // Setup Custom Widget view
+    string_t temp_str;
+    string_init(temp_str);
+
+    string_printf(temp_str, "\e#Delete %s?\e#", nfc->dev->dev_name);
+    widget_add_text_box_element(
+        nfc->widget, 0, 0, 128, 23, AlignCenter, AlignCenter, string_get_cstr(temp_str), false);
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeLeft, "Cancel", nfc_scene_delete_widget_callback, nfc);
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeRight, "Delete", nfc_scene_delete_widget_callback, nfc);
+
+    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(
+        nfc->widget, 64, 24, AlignCenter, AlignTop, FontSecondary, string_get_cstr(temp_str));
+
+    NfcProtocol protocol = nfc->dev->dev_data.protocol;
+    if(protocol == NfcDeviceProtocolEMV) {
+        string_set_str(temp_str, "EMV bank card");
+    } else if(protocol == NfcDeviceProtocolMifareUl) {
+        string_set_str(temp_str, nfc_mf_ul_type(nfc->dev->dev_data.mf_ul_data.type, true));
+    } else if(protocol == NfcDeviceProtocolMifareClassic) {
+        string_set_str(temp_str, nfc_mf_classic_type(nfc->dev->dev_data.mf_classic_data.type));
+    } else if(protocol == NfcDeviceProtocolMifareDesfire) {
+        string_set_str(temp_str, "MIFARE DESFire");
+    } else {
+        string_set_str(temp_str, "Unknown ISO tag");
+    }
+    widget_add_string_element(
+        nfc->widget, 64, 34, AlignCenter, AlignTop, FontSecondary, string_get_cstr(temp_str));
+    widget_add_string_element(nfc->widget, 64, 44, AlignCenter, AlignTop, FontSecondary, "NFC-A");
+    string_clear(temp_str);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_delete_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = scene_manager_previous_scene(nfc->scene_manager);
+        } else if(event.event == GuiButtonTypeRight) {
+            if(nfc_device_delete(nfc->dev, true)) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneDeleteSuccess);
+            } else {
+                scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneStart);
+            }
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_delete_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_delete_success.c

@@ -0,0 +1,40 @@
+#include "../nfc_i.h"
+
+void nfc_scene_delete_success_popup_callback(void* context) {
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_delete_success_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    popup_set_icon(popup, 0, 2, &I_DolphinMafia_115x62);
+    popup_set_header(popup, "Deleted", 83, 19, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, nfc);
+    popup_set_callback(popup, nfc_scene_delete_success_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_delete_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                nfc->scene_manager, NfcSceneFileSelect);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_delete_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    popup_reset(nfc->popup);
+}

applications/main/nfc/scenes/nfc_scene_detect_reader.c

@@ -0,0 +1,63 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+bool nfc_detect_reader_worker_callback(NfcWorkerEvent event, void* context) {
+    UNUSED(event);
+    furi_assert(context);
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
+    return true;
+}
+
+void nfc_scene_detect_reader_callback(void* context) {
+    furi_assert(context);
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_detect_reader_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcEmulate);
+
+    detect_reader_set_callback(nfc->detect_reader, nfc_scene_detect_reader_callback, nfc);
+    nfc_worker_start(
+        nfc->worker,
+        NfcWorkerStateAnalyzeReader,
+        &nfc->dev->dev_data,
+        nfc_detect_reader_worker_callback,
+        nfc);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDetectReader);
+
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_detect_reader_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            nfc_worker_stop(nfc->worker);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfkeyNoncesInfo);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventDetectReaderMfkeyCollected) {
+            detect_reader_inc_nonce_cnt(nfc->detect_reader);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_detect_reader_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Stop worker
+    nfc_worker_stop(nfc->worker);
+
+    // Clear view
+    detect_reader_reset(nfc->detect_reader);
+
+    nfc_blink_stop(nfc);
+}

applications/main/nfc/scenes/nfc_scene_device_info.c

@@ -0,0 +1,81 @@
+#include "../nfc_i.h"
+#include "../helpers/nfc_emv_parser.h"
+
+void nfc_scene_device_info_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_device_info_on_enter(void* context) {
+    Nfc* nfc = context;
+    NfcDeviceData* dev_data = &nfc->dev->dev_data;
+
+    string_t temp_str;
+    string_init(temp_str);
+
+    if(dev_data->protocol == NfcDeviceProtocolEMV) {
+        EmvData* emv_data = &dev_data->emv_data;
+        string_printf(temp_str, "\e#%s\n", emv_data->name);
+        for(uint8_t i = 0; i < emv_data->number_len; i += 2) {
+            string_cat_printf(temp_str, "%02X%02X ", emv_data->number[i], emv_data->number[i + 1]);
+        }
+        string_strim(temp_str);
+
+        // Add expiration date
+        if(emv_data->exp_mon) {
+            string_cat_printf(temp_str, "\nExp: %02X/%02X", emv_data->exp_mon, emv_data->exp_year);
+        }
+        // Parse currency code
+        if((emv_data->currency_code)) {
+            string_t currency_name;
+            string_init(currency_name);
+            if(nfc_emv_parser_get_currency_name(
+                   nfc->dev->storage, emv_data->currency_code, currency_name)) {
+                string_cat_printf(temp_str, "\nCur: %s  ", string_get_cstr(currency_name));
+            }
+            string_clear(currency_name);
+        }
+        // Parse country code
+        if((emv_data->country_code)) {
+            string_t country_name;
+            string_init(country_name);
+            if(nfc_emv_parser_get_country_name(
+                   nfc->dev->storage, emv_data->country_code, country_name)) {
+                string_cat_printf(temp_str, "Reg: %s", string_get_cstr(country_name));
+            }
+            string_clear(country_name);
+        }
+    } else if(dev_data->protocol == NfcDeviceProtocolMifareClassic) {
+        string_set(temp_str, nfc->dev->dev_data.parsed_data);
+    }
+
+    widget_add_text_scroll_element(nfc->widget, 0, 0, 128, 52, string_get_cstr(temp_str));
+    string_clear(temp_str);
+
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeRight, "More", nfc_scene_device_info_widget_callback, nfc);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_device_info_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_device_info_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear views
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_dict_not_found.c

@@ -0,0 +1,49 @@
+#include "../nfc_i.h"
+
+void nfc_scene_dict_not_found_popup_callback(void* context) {
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_dict_not_found_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    popup_set_text(
+        popup,
+        "Function requires\nan SD card with\nfresh databases.",
+        82,
+        24,
+        AlignCenter,
+        AlignCenter);
+    popup_set_icon(popup, 6, 10, &I_SDQuestion_35x43);
+    popup_set_timeout(popup, 2500);
+    popup_set_context(popup, nfc);
+    popup_set_callback(popup, nfc_scene_dict_not_found_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_dict_not_found_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneExtraActions)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneExtraActions);
+            } else {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneStart);
+            }
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_dict_not_found_on_exit(void* context) {
+    Nfc* nfc = context;
+    popup_reset(nfc->popup);
+}

applications/main/nfc/scenes/nfc_scene_emulate_apdu_sequence.c

@@ -0,0 +1,34 @@
+#include "../nfc_i.h"
+#include <core/common_defines.h>
+
+void nfc_scene_emulate_apdu_sequence_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    popup_set_header(popup, "Run APDU reader", 64, 31, AlignCenter, AlignTop);
+
+    // Setup and start worker
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    nfc_worker_start(nfc->worker, NfcWorkerStateEmulateApdu, &nfc->dev->dev_data, NULL, nfc);
+
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_emulate_apdu_sequence_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    bool consumed = false;
+    return consumed;
+}
+
+void nfc_scene_emulate_apdu_sequence_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Stop worker
+    nfc_worker_stop(nfc->worker);
+    // Clear view
+    popup_reset(nfc->popup);
+
+    nfc_blink_stop(nfc);
+}

applications/main/nfc/scenes/nfc_scene_emulate_uid.c

@@ -0,0 +1,146 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+#define NFC_SCENE_EMULATE_UID_LOG_SIZE_MAX (200)
+
+enum {
+    NfcSceneEmulateUidStateWidget,
+    NfcSceneEmulateUidStateTextBox,
+};
+
+bool nfc_emulate_uid_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_uid_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_uid_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_uid_widget_config(Nfc* nfc, bool data_received) {
+    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
+    Widget* widget = nfc->widget;
+    widget_reset(widget);
+    string_t info_str;
+    string_init(info_str);
+
+    widget_add_icon_element(widget, 0, 3, &I_RFIDDolphinSend_97x61);
+    widget_add_string_element(widget, 89, 32, AlignCenter, AlignTop, FontPrimary, "Emulating UID");
+    if(strcmp(nfc->dev->dev_name, "")) {
+        string_printf(info_str, "%s", nfc->dev->dev_name);
+    } else {
+        for(uint8_t i = 0; i < data->uid_len; i++) {
+            string_cat_printf(info_str, "%02X ", data->uid[i]);
+        }
+    }
+    string_strim(info_str);
+    widget_add_text_box_element(
+        widget, 56, 43, 70, 21, AlignCenter, AlignTop, string_get_cstr(info_str), true);
+    string_clear(info_str);
+    if(data_received) {
+        widget_add_button_element(
+            widget, GuiButtonTypeCenter, "Log", nfc_scene_emulate_uid_widget_callback, nfc);
+    }
+}
+
+void nfc_scene_emulate_uid_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcEmulate);
+
+    // Setup Widget
+    nfc_scene_emulate_uid_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);
+    string_reset(nfc->text_box_store);
+
+    // Set Widget state and view
+    scene_manager_set_scene_state(
+        nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateWidget);
+    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,
+        NfcWorkerStateUidEmulate,
+        &nfc->dev->dev_data,
+        nfc_emulate_uid_worker_callback,
+        nfc);
+
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_emulate_uid_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    NfcReaderRequestData* reader_data = &nfc->dev->dev_data.reader_data;
+    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneEmulateUid);
+    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(!string_size(nfc->text_box_store)) {
+                nfc_scene_emulate_uid_widget_config(nfc, true);
+            }
+            // Update TextBox data
+            if(string_size(nfc->text_box_store) < NFC_SCENE_EMULATE_UID_LOG_SIZE_MAX) {
+                string_cat_printf(nfc->text_box_store, "R:");
+                for(uint16_t i = 0; i < reader_data->size; i++) {
+                    string_cat_printf(nfc->text_box_store, " %02X", reader_data->data[i]);
+                }
+                string_push_back(nfc->text_box_store, '\n');
+                text_box_set_text(nfc->text_box, string_get_cstr(nfc->text_box_store));
+            }
+            memset(reader_data, 0, sizeof(NfcReaderRequestData));
+            consumed = true;
+        } else if(event.event == GuiButtonTypeCenter && state == NfcSceneEmulateUidStateWidget) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateTextBox);
+            consumed = true;
+        } else if(event.event == NfcCustomEventViewExit && state == NfcSceneEmulateUidStateTextBox) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateWidget);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        if(state == NfcSceneEmulateUidStateTextBox) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateWidget);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_emulate_uid_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);
+    string_reset(nfc->text_box_store);
+
+    nfc_blink_stop(nfc);
+}

applications/main/nfc/scenes/nfc_scene_emv_menu.c

@@ -0,0 +1,54 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexSave,
+    SubmenuIndexInfo,
+};
+
+void nfc_scene_emv_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_emv_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(submenu, "Save", SubmenuIndexSave, nfc_scene_emv_menu_submenu_callback, nfc);
+    submenu_add_item(submenu, "Info", SubmenuIndexInfo, nfc_scene_emv_menu_submenu_callback, nfc);
+    submenu_set_selected_item(
+        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneEmvMenu));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_emv_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexSave) {
+            nfc->dev->format = NfcDeviceSaveFormatBankCard;
+            // Clear device name
+            nfc_device_set_name(nfc->dev, "");
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
+            consumed = true;
+        } else if(event.event == SubmenuIndexInfo) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneEmvMenu, event.event);
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_previous_scene(nfc->scene_manager);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_emv_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_emv_read_success.c

@@ -0,0 +1,88 @@
+#include "../nfc_i.h"
+#include "../helpers/nfc_emv_parser.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_emv_read_success_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_emv_read_success_on_enter(void* context) {
+    Nfc* nfc = context;
+    EmvData* emv_data = &nfc->dev->dev_data.emv_data;
+    DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+
+    // Setup Custom Widget view
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeLeft, "Retry", nfc_scene_emv_read_success_widget_callback, nfc);
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeRight, "More", nfc_scene_emv_read_success_widget_callback, nfc);
+
+    string_t temp_str;
+    string_init_printf(temp_str, "\e#%s\n", emv_data->name);
+    for(uint8_t i = 0; i < emv_data->number_len; i += 2) {
+        string_cat_printf(temp_str, "%02X%02X ", emv_data->number[i], emv_data->number[i + 1]);
+    }
+    string_strim(temp_str);
+
+    // Add expiration date
+    if(emv_data->exp_mon) {
+        string_cat_printf(temp_str, "\nExp: %02X/%02X", emv_data->exp_mon, emv_data->exp_year);
+    }
+    // Parse currency code
+    if((emv_data->currency_code)) {
+        string_t currency_name;
+        string_init(currency_name);
+        if(nfc_emv_parser_get_currency_name(
+               nfc->dev->storage, emv_data->currency_code, currency_name)) {
+            string_cat_printf(temp_str, "\nCur: %s  ", string_get_cstr(currency_name));
+        }
+        string_clear(currency_name);
+    }
+    // Parse country code
+    if((emv_data->country_code)) {
+        string_t country_name;
+        string_init(country_name);
+        if(nfc_emv_parser_get_country_name(
+               nfc->dev->storage, emv_data->country_code, country_name)) {
+            string_cat_printf(temp_str, "Reg: %s", string_get_cstr(country_name));
+        }
+        string_clear(country_name);
+    }
+
+    widget_add_text_scroll_element(nfc->widget, 0, 0, 128, 52, string_get_cstr(temp_str));
+    string_clear(temp_str);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_emv_read_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmvMenu);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
+        consumed = true;
+    }
+    return consumed;
+}
+
+void nfc_scene_emv_read_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_exit_confirm.c

@@ -0,0 +1,47 @@
+#include "../nfc_i.h"
+
+void nfc_scene_exit_confirm_dialog_callback(DialogExResult result, void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+}
+
+void nfc_scene_exit_confirm_on_enter(void* context) {
+    Nfc* nfc = context;
+    DialogEx* dialog_ex = nfc->dialog_ex;
+
+    dialog_ex_set_left_button_text(dialog_ex, "Exit");
+    dialog_ex_set_right_button_text(dialog_ex, "Stay");
+    dialog_ex_set_header(dialog_ex, "Exit to NFC Menu?", 64, 11, AlignCenter, AlignTop);
+    dialog_ex_set_text(
+        dialog_ex, "All unsaved data\nwill be lost!", 64, 25, AlignCenter, AlignTop);
+    dialog_ex_set_context(dialog_ex, nfc);
+    dialog_ex_set_result_callback(dialog_ex, nfc_scene_exit_confirm_dialog_callback);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+}
+
+bool nfc_scene_exit_confirm_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == DialogExResultRight) {
+            consumed = scene_manager_previous_scene(nfc->scene_manager);
+        } else if(event.event == DialogExResultLeft) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                nfc->scene_manager, NfcSceneStart);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_exit_confirm_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean view
+    dialog_ex_reset(nfc->dialog_ex);
+}

applications/main/nfc/scenes/nfc_scene_extra_actions.c

@@ -0,0 +1,57 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexMfClassicKeys,
+    SubmenuIndexMfUltralightUnlock,
+};
+
+void nfc_scene_extra_actions_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_extra_actions_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(
+        submenu,
+        "Mf Classic Keys",
+        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);
+}
+
+bool nfc_scene_extra_actions_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexMfClassicKeys) {
+            if(mf_classic_dict_check_presence(MfClassicDictTypeFlipper)) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeys);
+            } else {
+                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);
+    }
+    return consumed;
+}
+
+void nfc_scene_extra_actions_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_field.c

@@ -0,0 +1,33 @@
+#include "../nfc_i.h"
+
+void nfc_scene_field_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    furi_hal_nfc_field_on();
+
+    Popup* popup = nfc->popup;
+    popup_set_header(
+        popup,
+        "Field is on\nDon't leave device\nin this mode for too long.",
+        64,
+        11,
+        AlignCenter,
+        AlignTop);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+
+    notification_internal_message(nfc->notifications, &sequence_set_blue_255);
+}
+
+bool nfc_scene_field_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+void nfc_scene_field_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    furi_hal_nfc_field_off();
+    notification_internal_message(nfc->notifications, &sequence_reset_blue);
+    popup_reset(nfc->popup);
+}

applications/main/nfc/scenes/nfc_scene_file_select.c

@@ -0,0 +1,25 @@
+#include "../nfc_i.h"
+#include "nfc/nfc_device.h"
+
+void nfc_scene_file_select_on_enter(void* context) {
+    Nfc* nfc = context;
+    // Process file_select return
+    nfc_device_set_loading_callback(nfc->dev, nfc_show_loading_popup, nfc);
+    if(nfc_file_select(nfc->dev)) {
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneSavedMenu, 0);
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneSavedMenu);
+    } else {
+        scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneStart);
+    }
+    nfc_device_set_loading_callback(nfc->dev, NULL, nfc);
+}
+
+bool nfc_scene_file_select_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+void nfc_scene_file_select_on_exit(void* context) {
+    UNUSED(context);
+}

applications/main/nfc/scenes/nfc_scene_generate_info.c

@@ -0,0 +1,55 @@
+#include "../nfc_i.h"
+#include "../helpers/nfc_generators.h"
+
+void nfc_scene_generate_info_dialog_callback(DialogExResult result, void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+}
+
+void nfc_scene_generate_info_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup dialog view
+    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
+    DialogEx* dialog_ex = nfc->dialog_ex;
+    dialog_ex_set_right_button_text(dialog_ex, "More");
+
+    // Create info text
+    string_t info_str;
+    string_init_printf(
+        info_str, "%s\n%s\nUID:", nfc->generator->name, nfc_get_dev_type(data->type));
+    // Append UID
+    for(int i = 0; i < data->uid_len; ++i) {
+        string_cat_printf(info_str, " %02X", data->uid[i]);
+    }
+    nfc_text_store_set(nfc, string_get_cstr(info_str));
+    string_clear(info_str);
+
+    dialog_ex_set_text(dialog_ex, nfc->text_store, 0, 0, AlignLeft, AlignTop);
+    dialog_ex_set_context(dialog_ex, nfc);
+    dialog_ex_set_result_callback(dialog_ex, nfc_scene_generate_info_dialog_callback);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+}
+
+bool nfc_scene_generate_info_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == DialogExResultRight) {
+            scene_manager_next_scene(nfc->scene_manager, nfc->generator->next_scene);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_generate_info_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean views
+    dialog_ex_reset(nfc->dialog_ex);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c

@@ -0,0 +1,170 @@
+#include "../nfc_i.h"
+
+#define TAG "NfcMfClassicDictAttack"
+
+typedef enum {
+    DictAttackStateIdle,
+    DictAttackStateUserDictInProgress,
+    DictAttackStateFlipperDictInProgress,
+} DictAttackState;
+
+bool nfc_dict_attack_worker_callback(NfcWorkerEvent event, void* context) {
+    furi_assert(context);
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
+    return true;
+}
+
+void nfc_dict_attack_dict_attack_result_callback(void* context) {
+    furi_assert(context);
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventDictAttackSkip);
+}
+
+static void nfc_scene_mf_classic_dict_attack_update_view(Nfc* nfc) {
+    MfClassicData* data = &nfc->dev->dev_data.mf_classic_data;
+    uint8_t sectors_read = 0;
+    uint8_t keys_found = 0;
+
+    // Calculate found keys and read sectors
+    mf_classic_get_read_sectors_and_keys(data, &sectors_read, &keys_found);
+    dict_attack_set_keys_found(nfc->dict_attack, keys_found);
+    dict_attack_set_sector_read(nfc->dict_attack, sectors_read);
+}
+
+static void nfc_scene_mf_classic_dict_attack_prepare_view(Nfc* nfc, DictAttackState state) {
+    MfClassicData* data = &nfc->dev->dev_data.mf_classic_data;
+    NfcMfClassicDictAttackData* dict_attack_data = &nfc->dev->dev_data.mf_classic_dict_attack_data;
+    NfcWorkerState worker_state = NfcWorkerStateReady;
+    MfClassicDict* dict = NULL;
+
+    // Identify scene state
+    if(state == DictAttackStateIdle) {
+        if(mf_classic_dict_check_presence(MfClassicDictTypeUser)) {
+            state = DictAttackStateUserDictInProgress;
+        } else {
+            state = DictAttackStateFlipperDictInProgress;
+        }
+    } else if(state == DictAttackStateUserDictInProgress) {
+        state = DictAttackStateFlipperDictInProgress;
+    }
+
+    // Setup view
+    if(state == DictAttackStateUserDictInProgress) {
+        worker_state = NfcWorkerStateMfClassicDictAttack;
+        dict_attack_set_header(nfc->dict_attack, "Mf Classic User Dict.");
+        dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+
+        // If failed to load user dictionary - try flipper dictionary
+        if(!dict) {
+            FURI_LOG_E(TAG, "User dictionary not found");
+            state = DictAttackStateFlipperDictInProgress;
+        }
+    }
+    if(state == DictAttackStateFlipperDictInProgress) {
+        worker_state = NfcWorkerStateMfClassicDictAttack;
+        dict_attack_set_header(nfc->dict_attack, "Mf Classic Flipper Dict.");
+        dict = mf_classic_dict_alloc(MfClassicDictTypeFlipper);
+        if(!dict) {
+            FURI_LOG_E(TAG, "Flipper dictionary not found");
+            // Pass through to let worker handle the failure
+        }
+    }
+    // Free previous dictionary
+    if(dict_attack_data->dict) {
+        mf_classic_dict_free(dict_attack_data->dict);
+    }
+    dict_attack_data->dict = dict;
+    scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfClassicDictAttack, state);
+    dict_attack_set_callback(nfc->dict_attack, nfc_dict_attack_dict_attack_result_callback, nfc);
+    dict_attack_set_current_sector(nfc->dict_attack, 0);
+    dict_attack_set_card_detected(nfc->dict_attack, data->type);
+    dict_attack_set_total_dict_keys(
+        nfc->dict_attack, dict ? mf_classic_dict_get_total_keys(dict) : 0);
+    nfc_scene_mf_classic_dict_attack_update_view(nfc);
+    nfc_worker_start(
+        nfc->worker, worker_state, &nfc->dev->dev_data, nfc_dict_attack_worker_callback, nfc);
+}
+
+void nfc_scene_mf_classic_dict_attack_on_enter(void* context) {
+    Nfc* nfc = context;
+    nfc_scene_mf_classic_dict_attack_prepare_view(nfc, DictAttackStateIdle);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDictAttack);
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_mf_classic_dict_attack_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    MfClassicData* data = &nfc->dev->dev_data.mf_classic_data;
+    bool consumed = false;
+
+    uint32_t state =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicDictAttack);
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcWorkerEventSuccess) {
+            if(state == DictAttackStateUserDictInProgress) {
+                nfc_worker_stop(nfc->worker);
+                nfc_scene_mf_classic_dict_attack_prepare_view(nfc, state);
+                consumed = true;
+            } else {
+                notification_message(nfc->notifications, &sequence_success);
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicReadSuccess);
+                consumed = true;
+            }
+        } else if(event.event == NfcWorkerEventAborted) {
+            if(state == DictAttackStateUserDictInProgress) {
+                nfc_scene_mf_classic_dict_attack_prepare_view(nfc, state);
+                consumed = true;
+            } else {
+                notification_message(nfc->notifications, &sequence_success);
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicReadSuccess);
+                consumed = true;
+            }
+        } else if(event.event == NfcWorkerEventCardDetected) {
+            dict_attack_set_card_detected(nfc->dict_attack, data->type);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventNoCardDetected) {
+            dict_attack_set_card_removed(nfc->dict_attack);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventFoundKeyA) {
+            dict_attack_inc_keys_found(nfc->dict_attack);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventFoundKeyB) {
+            dict_attack_inc_keys_found(nfc->dict_attack);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventNewSector) {
+            nfc_scene_mf_classic_dict_attack_update_view(nfc);
+            dict_attack_inc_current_sector(nfc->dict_attack);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventNewDictKeyBatch) {
+            nfc_scene_mf_classic_dict_attack_update_view(nfc);
+            dict_attack_inc_current_dict_key(nfc->dict_attack, NFC_DICT_KEY_BATCH_SIZE);
+            consumed = true;
+        } else if(event.event == NfcCustomEventDictAttackSkip) {
+            if(state == DictAttackStateUserDictInProgress) {
+                nfc_worker_stop(nfc->worker);
+                consumed = true;
+            } else if(state == DictAttackStateFlipperDictInProgress) {
+                nfc_worker_stop(nfc->worker);
+                consumed = true;
+            }
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
+        consumed = true;
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_dict_attack_on_exit(void* context) {
+    Nfc* nfc = context;
+    NfcMfClassicDictAttackData* dict_attack_data = &nfc->dev->dev_data.mf_classic_dict_attack_data;
+    // Stop worker
+    nfc_worker_stop(nfc->worker);
+    if(dict_attack_data->dict) {
+        mf_classic_dict_free(dict_attack_data->dict);
+        dict_attack_data->dict = NULL;
+    }
+    dict_attack_reset(nfc->dict_attack);
+    nfc_blink_stop(nfc);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_emulate.c

@@ -0,0 +1,67 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+#define NFC_MF_CLASSIC_DATA_NOT_CHANGED (0UL)
+#define NFC_MF_CLASSIC_DATA_CHANGED (1UL)
+
+bool nfc_mf_classic_emulate_worker_callback(NfcWorkerEvent event, void* context) {
+    UNUSED(event);
+    Nfc* nfc = context;
+
+    scene_manager_set_scene_state(
+        nfc->scene_manager, NfcSceneMfClassicEmulate, NFC_MF_CLASSIC_DATA_CHANGED);
+    return true;
+}
+
+void nfc_scene_mf_classic_emulate_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcEmulate);
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    if(strcmp(nfc->dev->dev_name, "")) {
+        nfc_text_store_set(nfc, "Emulating\n%s", nfc->dev->dev_name);
+    } else {
+        nfc_text_store_set(nfc, "Emulating\nMf Classic", nfc->dev->dev_name);
+    }
+    popup_set_icon(popup, 0, 3, &I_RFIDDolphinSend_97x61);
+    popup_set_header(popup, nfc->text_store, 56, 31, AlignLeft, AlignTop);
+
+    // Setup and start worker
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    nfc_worker_start(
+        nfc->worker,
+        NfcWorkerStateMfClassicEmulate,
+        &nfc->dev->dev_data,
+        nfc_mf_classic_emulate_worker_callback,
+        nfc);
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_mf_classic_emulate_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeBack) {
+        // Stop worker
+        nfc_worker_stop(nfc->worker);
+        // Check if data changed and save in shadow file
+        if(scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicEmulate) ==
+           NFC_MF_CLASSIC_DATA_CHANGED) {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfClassicEmulate, NFC_MF_CLASSIC_DATA_NOT_CHANGED);
+            nfc_device_save_shadow(nfc->dev, nfc->dev->dev_name);
+        }
+        consumed = false;
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_emulate_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    popup_reset(nfc->popup);
+
+    nfc_blink_stop(nfc);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c

@@ -0,0 +1,60 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mf_classic_keys_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_classic_keys_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Load flipper dict keys total
+    uint32_t flipper_dict_keys_total = 0;
+    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeFlipper);
+    if(dict) {
+        flipper_dict_keys_total = mf_classic_dict_get_total_keys(dict);
+        mf_classic_dict_free(dict);
+    }
+    // Load user dict keys total
+    uint32_t user_dict_keys_total = 0;
+    dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+    if(dict) {
+        user_dict_keys_total = mf_classic_dict_get_total_keys(dict);
+        mf_classic_dict_free(dict);
+    }
+
+    widget_add_string_element(
+        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "MF Classic Keys");
+    char temp_str[32];
+    snprintf(temp_str, sizeof(temp_str), "Flipper dict: %ld", flipper_dict_keys_total);
+    widget_add_string_element(nfc->widget, 0, 20, AlignLeft, AlignTop, FontSecondary, temp_str);
+    snprintf(temp_str, sizeof(temp_str), "User dict: %ld", user_dict_keys_total);
+    widget_add_string_element(nfc->widget, 0, 32, AlignLeft, AlignTop, FontSecondary, temp_str);
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeCenter, "Add", nfc_scene_mf_classic_keys_widget_callback, nfc);
+    widget_add_icon_element(nfc->widget, 90, 12, &I_Keychain);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_classic_keys_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeCenter) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeysAdd);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_keys_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_add.c

@@ -0,0 +1,57 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mf_classic_keys_add_byte_input_callback(void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+}
+
+void nfc_scene_mf_classic_keys_add_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    ByteInput* byte_input = nfc->byte_input;
+    byte_input_set_header_text(byte_input, "Enter the key in hex");
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_scene_mf_classic_keys_add_byte_input_callback,
+        NULL,
+        nfc,
+        nfc->byte_input_store,
+        6);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+}
+
+bool nfc_scene_mf_classic_keys_add_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventByteInputDone) {
+            // Add key to dict
+            bool key_added = false;
+            MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+            if(dict) {
+                if(mf_classic_dict_add_key(dict, nfc->byte_input_store)) {
+                    key_added = true;
+                }
+            }
+            if(key_added) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
+            } else {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
+            }
+            mf_classic_dict_free(dict);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_keys_add_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_mf_classic_menu.c

@@ -0,0 +1,68 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexSave,
+    SubmenuIndexEmulate,
+    SubmenuIndexInfo,
+};
+
+void nfc_scene_mf_classic_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_mf_classic_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(
+        submenu, "Save", SubmenuIndexSave, nfc_scene_mf_classic_menu_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Emulate", SubmenuIndexEmulate, nfc_scene_mf_classic_menu_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Info", SubmenuIndexInfo, nfc_scene_mf_classic_menu_submenu_callback, nfc);
+
+    submenu_set_selected_item(
+        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicMenu));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_classic_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexSave) {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfClassicMenu, SubmenuIndexSave);
+            nfc->dev->format = NfcDeviceSaveFormatMifareClassic;
+            // 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, NfcSceneMfClassicMenu, SubmenuIndexEmulate);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicEmulate);
+            consumed = true;
+        } else if(event.event == SubmenuIndexInfo) {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfClassicMenu, SubmenuIndexInfo);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_previous_scene(nfc->scene_manager);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_read_success.c

@@ -0,0 +1,81 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_mf_classic_read_success_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_scene_mf_classic_read_success_on_enter(void* context) {
+    Nfc* nfc = context;
+    NfcDeviceData* dev_data = &nfc->dev->dev_data;
+    MfClassicData* mf_data = &dev_data->mf_classic_data;
+
+    DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+
+    // Setup view
+    Widget* widget = nfc->widget;
+    widget_add_button_element(
+        widget, GuiButtonTypeLeft, "Retry", nfc_scene_mf_classic_read_success_widget_callback, nfc);
+    widget_add_button_element(
+        widget, GuiButtonTypeRight, "More", nfc_scene_mf_classic_read_success_widget_callback, nfc);
+
+    string_t temp_str;
+    if(string_size(nfc->dev->dev_data.parsed_data)) {
+        string_init_set(temp_str, nfc->dev->dev_data.parsed_data);
+    } else {
+        string_init_printf(temp_str, "\e#%s\n", nfc_mf_classic_type(mf_data->type));
+        string_cat_printf(temp_str, "UID:");
+        for(size_t i = 0; i < dev_data->nfc_data.uid_len; i++) {
+            string_cat_printf(temp_str, " %02X", dev_data->nfc_data.uid[i]);
+        }
+        uint8_t sectors_total = mf_classic_get_total_sectors_num(mf_data->type);
+        uint8_t keys_total = sectors_total * 2;
+        uint8_t keys_found = 0;
+        uint8_t sectors_read = 0;
+        mf_classic_get_read_sectors_and_keys(mf_data, &sectors_read, &keys_found);
+        string_cat_printf(temp_str, "\nKeys Found: %d/%d", keys_found, keys_total);
+        string_cat_printf(temp_str, "\nSectors Read: %d/%d", sectors_read, sectors_total);
+    }
+
+    widget_add_text_scroll_element(widget, 0, 0, 128, 52, string_get_cstr(temp_str));
+    string_clear(temp_str);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_classic_read_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeRight) {
+            // Clear device name
+            nfc_device_set_name(nfc->dev, "");
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicMenu);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_read_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c

@@ -0,0 +1,114 @@
+#include "../nfc_i.h"
+
+#define TAG "NfcSceneMfDesfireApp"
+
+enum SubmenuIndex {
+    SubmenuIndexAppInfo,
+    SubmenuIndexDynamic, // dynamic indexes start here
+};
+
+MifareDesfireApplication* nfc_scene_mf_desfire_app_get_app(Nfc* nfc) {
+    uint32_t app_idx = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp) >>
+                       1;
+    MifareDesfireApplication* app = nfc->dev->dev_data.mf_df_data.app_head;
+    for(uint32_t i = 0; i < app_idx && app; i++) {
+        app = app->next;
+    }
+    return app;
+}
+
+void nfc_scene_mf_desfire_app_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_mf_desfire_app_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+    MifareDesfireApplication* app = nfc_scene_mf_desfire_app_get_app(nfc);
+    if(!app) {
+        popup_set_icon(nfc->popup, 5, 5, &I_WarningDolphin_45x42);
+        popup_set_header(nfc->popup, "Internal Error!", 55, 12, AlignLeft, AlignBottom);
+        popup_set_text(
+            nfc->popup,
+            "No app selected.\nThis should\nnever happen,\nplease file a bug.",
+            55,
+            15,
+            AlignLeft,
+            AlignTop);
+        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+        FURI_LOG_E(TAG, "Bad state. No app selected?");
+        return;
+    }
+
+    text_box_set_font(nfc->text_box, TextBoxFontHex);
+
+    submenu_add_item(
+        submenu, "App info", SubmenuIndexAppInfo, nfc_scene_mf_desfire_app_submenu_callback, nfc);
+
+    uint16_t cap = NFC_TEXT_STORE_SIZE;
+    char* buf = nfc->text_store;
+    int idx = SubmenuIndexDynamic;
+    for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
+        int size = snprintf(buf, cap, "File %d", file->id);
+        if(size < 0 || size >= cap) {
+            FURI_LOG_W(
+                TAG,
+                "Exceeded NFC_TEXT_STORE_SIZE when preparing file id strings; menu truncated");
+            break;
+        }
+        char* label = buf;
+        cap -= size + 1;
+        buf += size + 1;
+        submenu_add_item(submenu, label, idx++, nfc_scene_mf_desfire_app_submenu_callback, nfc);
+    }
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_desfire_app_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp);
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        MifareDesfireApplication* app = nfc_scene_mf_desfire_app_get_app(nfc);
+        TextBox* text_box = nfc->text_box;
+        string_reset(nfc->text_box_store);
+        if(event.event == SubmenuIndexAppInfo) {
+            mf_df_cat_application_info(app, nfc->text_box_store);
+        } else {
+            uint16_t index = event.event - SubmenuIndexDynamic;
+            MifareDesfireFile* file = app->file_head;
+            for(int i = 0; file && i < index; i++) {
+                file = file->next;
+            }
+            if(!file) {
+                return false;
+            }
+            mf_df_cat_file(file, nfc->text_box_store);
+        }
+        text_box_set_text(text_box, string_get_cstr(nfc->text_box_store));
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, state | 1);
+        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
+        consumed = true;
+    } else if(event.type == SceneManagerEventTypeBack) {
+        if(state & 1) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+            scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, state & ~1);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_desfire_app_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear views
+    text_box_reset(nfc->text_box);
+    string_reset(nfc->text_box_store);
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_mf_desfire_data.c

@@ -0,0 +1,107 @@
+#include "../nfc_i.h"
+
+#define TAG "NfcSceneMfDesfireData"
+
+enum {
+    MifareDesfireDataStateMenu,
+    MifareDesfireDataStateItem, // MUST be last, states >= this correspond with submenu index
+};
+
+enum SubmenuIndex {
+    SubmenuIndexCardInfo,
+    SubmenuIndexDynamic, // dynamic indexes start here
+};
+
+void nfc_scene_mf_desfire_data_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = (Nfc*)context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_mf_desfire_data_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireData);
+    MifareDesfireData* data = &nfc->dev->dev_data.mf_df_data;
+
+    text_box_set_font(nfc->text_box, TextBoxFontHex);
+
+    submenu_add_item(
+        submenu,
+        "Card info",
+        SubmenuIndexCardInfo,
+        nfc_scene_mf_desfire_data_submenu_callback,
+        nfc);
+
+    uint16_t cap = NFC_TEXT_STORE_SIZE;
+    char* buf = nfc->text_store;
+    int idx = SubmenuIndexDynamic;
+    for(MifareDesfireApplication* app = data->app_head; app; app = app->next) {
+        int size = snprintf(buf, cap, "App %02x%02x%02x", app->id[0], app->id[1], app->id[2]);
+        if(size < 0 || size >= cap) {
+            FURI_LOG_W(
+                TAG, "Exceeded NFC_TEXT_STORE_SIZE when preparing app id strings; menu truncated");
+            break;
+        }
+        char* label = buf;
+        cap -= size + 1;
+        buf += size + 1;
+        submenu_add_item(submenu, label, idx++, nfc_scene_mf_desfire_data_submenu_callback, nfc);
+    }
+
+    if(state >= MifareDesfireDataStateItem) {
+        submenu_set_selected_item(
+            nfc->submenu, state - MifareDesfireDataStateItem + SubmenuIndexDynamic);
+        scene_manager_set_scene_state(
+            nfc->scene_manager, NfcSceneMfDesfireData, MifareDesfireDataStateMenu);
+    }
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_desfire_data_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireData);
+    MifareDesfireData* data = &nfc->dev->dev_data.mf_df_data;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        TextBox* text_box = nfc->text_box;
+        string_reset(nfc->text_box_store);
+        if(event.event == SubmenuIndexCardInfo) {
+            mf_df_cat_card_info(data, nfc->text_box_store);
+            text_box_set_text(text_box, string_get_cstr(nfc->text_box_store));
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
+            scene_manager_set_scene_state(
+                nfc->scene_manager,
+                NfcSceneMfDesfireData,
+                MifareDesfireDataStateItem + SubmenuIndexCardInfo);
+            consumed = true;
+        } else {
+            uint16_t index = event.event - SubmenuIndexDynamic;
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfDesfireData, MifareDesfireDataStateItem + index);
+            scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, index << 1);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireApp);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        if(state >= MifareDesfireDataStateItem) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfDesfireData, MifareDesfireDataStateMenu);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_desfire_data_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear views
+    text_box_reset(nfc->text_box);
+    string_reset(nfc->text_box_store);
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_mf_desfire_menu.c

@@ -0,0 +1,66 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexSave,
+    SubmenuIndexEmulateUid,
+    SubmenuIndexInfo,
+};
+
+void nfc_scene_mf_desfire_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_mf_desfire_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(
+        submenu, "Save", SubmenuIndexSave, nfc_scene_mf_desfire_menu_submenu_callback, nfc);
+    submenu_add_item(
+        submenu,
+        "Emulate UID",
+        SubmenuIndexEmulateUid,
+        nfc_scene_mf_desfire_menu_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu, "Info", SubmenuIndexInfo, nfc_scene_mf_desfire_menu_submenu_callback, nfc);
+
+    submenu_set_selected_item(
+        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireMenu));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_desfire_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexSave) {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfDesfireMenu, SubmenuIndexSave);
+            nfc->dev->format = NfcDeviceSaveFormatMifareDesfire;
+            // Clear device name
+            nfc_device_set_name(nfc->dev, "");
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
+            consumed = true;
+        } else if(event.event == SubmenuIndexEmulateUid) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
+            consumed = true;
+        } else if(event.event == SubmenuIndexInfo) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_desfire_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c

@@ -0,0 +1,93 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_mf_desfire_read_success_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_desfire_read_success_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
+    MifareDesfireData* data = &nfc->dev->dev_data.mf_df_data;
+    Widget* widget = nfc->widget;
+
+    // Prepare string for data display
+    string_t temp_str;
+    string_init_printf(temp_str, "\e#MIFARE DESfire\n");
+    string_cat_printf(temp_str, "UID:");
+    for(size_t i = 0; i < nfc_data->uid_len; i++) {
+        string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
+    }
+
+    uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
+    uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
+    string_cat_printf(temp_str, "\n%d", bytes_total);
+    if(data->version.sw_storage & 1) {
+        string_push_back(temp_str, '+');
+    }
+    string_cat_printf(temp_str, " bytes, %d bytes free\n", bytes_free);
+
+    uint16_t n_apps = 0;
+    uint16_t n_files = 0;
+    for(MifareDesfireApplication* app = data->app_head; app; app = app->next) {
+        n_apps++;
+        for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
+            n_files++;
+        }
+    }
+    string_cat_printf(temp_str, "%d Application", n_apps);
+    if(n_apps != 1) {
+        string_push_back(temp_str, 's');
+    }
+    string_cat_printf(temp_str, ", %d file", n_files);
+    if(n_files != 1) {
+        string_push_back(temp_str, 's');
+    }
+
+    // Add text scroll element
+    widget_add_text_scroll_element(widget, 0, 0, 128, 52, string_get_cstr(temp_str));
+    string_clear(temp_str);
+
+    // Add button elements
+    widget_add_button_element(
+        widget, GuiButtonTypeLeft, "Retry", nfc_scene_mf_desfire_read_success_widget_callback, nfc);
+    widget_add_button_element(
+        widget, GuiButtonTypeRight, "More", nfc_scene_mf_desfire_read_success_widget_callback, nfc);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_desfire_read_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireMenu);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_desfire_read_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean dialog
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_data.c

@@ -0,0 +1,32 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mf_ultralight_data_on_enter(void* context) {
+    Nfc* nfc = context;
+    MfUltralightData* data = &nfc->dev->dev_data.mf_ul_data;
+    TextBox* text_box = nfc->text_box;
+
+    text_box_set_font(text_box, TextBoxFontHex);
+    for(uint16_t i = 0; i < data->data_size; i += 2) {
+        if(!(i % 8) && i) {
+            string_push_back(nfc->text_box_store, '\n');
+        }
+        string_cat_printf(nfc->text_box_store, "%02X%02X ", data->data[i], data->data[i + 1]);
+    }
+    text_box_set_text(text_box, string_get_cstr(nfc->text_box_store));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
+}
+
+bool nfc_scene_mf_ultralight_data_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+void nfc_scene_mf_ultralight_data_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean view
+    text_box_reset(nfc->text_box);
+    string_reset(nfc->text_box_store);
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_emulate.c

@@ -0,0 +1,67 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+#define NFC_MF_UL_DATA_NOT_CHANGED (0UL)
+#define NFC_MF_UL_DATA_CHANGED (1UL)
+
+bool nfc_mf_ultralight_emulate_worker_callback(NfcWorkerEvent event, void* context) {
+    UNUSED(event);
+    Nfc* nfc = context;
+
+    scene_manager_set_scene_state(
+        nfc->scene_manager, NfcSceneMfUltralightEmulate, NFC_MF_UL_DATA_CHANGED);
+    return true;
+}
+
+void nfc_scene_mf_ultralight_emulate_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcEmulate);
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    if(strcmp(nfc->dev->dev_name, "")) {
+        nfc_text_store_set(nfc, "Emulating\n%s", nfc->dev->dev_name);
+    } else {
+        nfc_text_store_set(nfc, "Emulating\nMf Ultralight", nfc->dev->dev_name);
+    }
+    popup_set_icon(popup, 0, 3, &I_RFIDDolphinSend_97x61);
+    popup_set_header(popup, nfc->text_store, 56, 31, AlignLeft, AlignTop);
+
+    // Setup and start worker
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    nfc_worker_start(
+        nfc->worker,
+        NfcWorkerStateMfUltralightEmulate,
+        &nfc->dev->dev_data,
+        nfc_mf_ultralight_emulate_worker_callback,
+        nfc);
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_mf_ultralight_emulate_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeBack) {
+        // Stop worker
+        nfc_worker_stop(nfc->worker);
+        // Check if data changed and save in shadow file
+        if(scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate) ==
+           NFC_MF_UL_DATA_CHANGED) {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfUltralightEmulate, NFC_MF_UL_DATA_NOT_CHANGED);
+            nfc_device_save_shadow(nfc->dev, nfc->dev->dev_name);
+        }
+        consumed = false;
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_emulate_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    popup_reset(nfc->popup);
+
+    nfc_blink_stop(nfc);
+}

applications/main/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/main/nfc/scenes/nfc_scene_mf_ultralight_menu.c

@@ -0,0 +1,81 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexUnlock,
+    SubmenuIndexSave,
+    SubmenuIndexEmulate,
+    SubmenuIndexInfo,
+};
+
+void nfc_scene_mf_ultralight_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_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(
+        submenu,
+        "Emulate",
+        SubmenuIndexEmulate,
+        nfc_scene_mf_ultralight_menu_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu, "Info", SubmenuIndexInfo, nfc_scene_mf_ultralight_menu_submenu_callback, nfc);
+
+    submenu_set_selected_item(
+        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightMenu));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_ultralight_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == 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_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
+            consumed = true;
+        } else if(event.event == SubmenuIndexUnlock) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
+            consumed = true;
+        } else if(event.event == SubmenuIndexInfo) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            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);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    submenu_reset(nfc->submenu);
+}

applications/main/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, 20, &I_DolphinCommon_56x48);
+        }
+        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/main/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/main/nfc/scenes/nfc_scene_mf_ultralight_read_success.c

@@ -0,0 +1,78 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_mf_ultralight_read_success_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_success_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+
+    // Setup widget view
+    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
+    MfUltralightData* mf_ul_data = &nfc->dev->dev_data.mf_ul_data;
+    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,
+        GuiButtonTypeRight,
+        "More",
+        nfc_scene_mf_ultralight_read_success_widget_callback,
+        nfc);
+
+    string_t temp_str;
+    string_init_printf(temp_str, "\e#%s\n", nfc_mf_ul_type(mf_ul_data->type, true));
+    string_cat_printf(temp_str, "UID:");
+    for(size_t i = 0; i < data->uid_len; i++) {
+        string_cat_printf(temp_str, " %02X", data->uid[i]);
+    }
+    string_cat_printf(
+        temp_str, "\nPages Read: %d/%d", mf_ul_data->data_read / 4, mf_ul_data->data_size / 4);
+    if(mf_ul_data->data_read != mf_ul_data->data_size) {
+        string_cat_printf(temp_str, "\nPassword-protected pages!");
+    }
+    widget_add_text_scroll_element(widget, 0, 0, 128, 52, string_get_cstr(temp_str));
+    string_clear(temp_str);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_ultralight_read_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightMenu);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_read_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean view
+    widget_reset(nfc->widget);
+}

applications/main/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/main/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, 20, &I_DolphinCommon_56x48);
+    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);
+}

applications/main/nfc/scenes/nfc_scene_mfkey_complete.c

@@ -0,0 +1,49 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mfkey_complete_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_mfkey_complete_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    widget_add_string_element(nfc->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Complete!");
+    widget_add_string_multiline_element(
+        nfc->widget,
+        64,
+        32,
+        AlignCenter,
+        AlignCenter,
+        FontSecondary,
+        "Now use mfkey32v2\nto extract keys");
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeCenter, "OK", nfc_scene_mfkey_complete_callback, nfc);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mfkey_complete_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeCenter) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                nfc->scene_manager, NfcSceneStart);
+        }
+    } else if(event.event == SceneManagerEventTypeBack) {
+        consumed =
+            scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneStart);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mfkey_complete_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_mfkey_nonces_info.c

@@ -0,0 +1,55 @@
+#include "../nfc_i.h"
+#include <lib/nfc/helpers/mfkey32.h>
+
+void nfc_scene_mfkey_nonces_info_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_mfkey_nonces_info_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    string_t temp_str;
+    string_init(temp_str);
+
+    uint16_t nonces_saved = mfkey32_get_auth_sectors(temp_str);
+    widget_add_text_scroll_element(nfc->widget, 0, 22, 128, 42, string_get_cstr(temp_str));
+    string_printf(temp_str, "Nonces saved %d", nonces_saved);
+    widget_add_string_element(
+        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, string_get_cstr(temp_str));
+    widget_add_string_element(
+        nfc->widget, 0, 12, AlignLeft, AlignTop, FontSecondary, "Authenticated sectors:");
+
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeRight, "Next", nfc_scene_mfkey_nonces_info_callback, nfc);
+
+    string_clear(temp_str);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mfkey_nonces_info_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfkeyComplete);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed =
+            scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneStart);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mfkey_nonces_info_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_nfc_data_info.c

@@ -0,0 +1,133 @@
+#include "../nfc_i.h"
+
+void nfc_scene_nfc_data_info_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_nfc_data_info_on_enter(void* context) {
+    Nfc* nfc = context;
+    Widget* widget = nfc->widget;
+    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
+    NfcDeviceData* dev_data = &nfc->dev->dev_data;
+    NfcProtocol protocol = dev_data->protocol;
+    uint8_t text_scroll_height = 0;
+    if((protocol == NfcDeviceProtocolMifareDesfire) || (protocol == NfcDeviceProtocolMifareUl)) {
+        widget_add_button_element(
+            widget, GuiButtonTypeRight, "More", nfc_scene_nfc_data_info_widget_callback, nfc);
+        text_scroll_height = 52;
+    } else {
+        text_scroll_height = 64;
+    }
+
+    string_t temp_str;
+    string_init(temp_str);
+    // Set name if present
+    if(nfc->dev->dev_name[0] != '\0') {
+        string_printf(temp_str, "\ec%s\n", nfc->dev->dev_name);
+    }
+
+    // Set tag type
+    if(protocol == NfcDeviceProtocolEMV) {
+        string_cat_printf(temp_str, "\e#EMV Bank Card\n");
+    } else if(protocol == NfcDeviceProtocolMifareUl) {
+        string_cat_printf(temp_str, "\e#%s\n", nfc_mf_ul_type(dev_data->mf_ul_data.type, true));
+    } else if(protocol == NfcDeviceProtocolMifareClassic) {
+        string_cat_printf(
+            temp_str, "\e#%s\n", nfc_mf_classic_type(dev_data->mf_classic_data.type));
+    } else if(protocol == NfcDeviceProtocolMifareDesfire) {
+        string_cat_printf(temp_str, "\e#MIFARE DESfire\n");
+    } else {
+        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';
+    string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
+    string_cat_printf(temp_str, "UID:");
+    for(size_t i = 0; i < nfc_data->uid_len; i++) {
+        string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
+    }
+    string_cat_printf(temp_str, "\nATQA: %02X %02X ", nfc_data->atqa[1], nfc_data->atqa[0]);
+    string_cat_printf(temp_str, " SAK: %02X", nfc_data->sak);
+
+    // Set application specific data
+    if(protocol == NfcDeviceProtocolMifareDesfire) {
+        MifareDesfireData* data = &dev_data->mf_df_data;
+        uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
+        uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
+        string_cat_printf(temp_str, "\n%d", bytes_total);
+        if(data->version.sw_storage & 1) {
+            string_push_back(temp_str, '+');
+        }
+        string_cat_printf(temp_str, " bytes, %d bytes free\n", bytes_free);
+
+        uint16_t n_apps = 0;
+        uint16_t n_files = 0;
+        for(MifareDesfireApplication* app = data->app_head; app; app = app->next) {
+            n_apps++;
+            for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
+                n_files++;
+            }
+        }
+        string_cat_printf(temp_str, "%d Application", n_apps);
+        if(n_apps != 1) {
+            string_push_back(temp_str, 's');
+        }
+        string_cat_printf(temp_str, ", %d file", n_files);
+        if(n_files != 1) {
+            string_push_back(temp_str, 's');
+        }
+    } else if(protocol == NfcDeviceProtocolMifareUl) {
+        MfUltralightData* data = &dev_data->mf_ul_data;
+        string_cat_printf(
+            temp_str, "\nPages Read %d/%d", data->data_read / 4, data->data_size / 4);
+        if(data->data_size > data->data_read) {
+            string_cat_printf(temp_str, "\nPassword-protected");
+        }
+    } else if(protocol == NfcDeviceProtocolMifareClassic) {
+        MfClassicData* data = &dev_data->mf_classic_data;
+        uint8_t sectors_total = mf_classic_get_total_sectors_num(data->type);
+        uint8_t keys_total = sectors_total * 2;
+        uint8_t keys_found = 0;
+        uint8_t sectors_read = 0;
+        mf_classic_get_read_sectors_and_keys(data, &sectors_read, &keys_found);
+        string_cat_printf(temp_str, "\nKeys Found %d/%d", keys_found, keys_total);
+        string_cat_printf(temp_str, "\nSectors Read %d/%d", sectors_read, sectors_total);
+    }
+
+    // Add text scroll widget
+    widget_add_text_scroll_element(
+        widget, 0, 0, 128, text_scroll_height, string_get_cstr(temp_str));
+    string_clear(temp_str);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_nfc_data_info_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    NfcProtocol protocol = nfc->dev->dev_data.protocol;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeRight) {
+            if(protocol == NfcDeviceProtocolMifareDesfire) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireApp);
+                consumed = true;
+            } else if(protocol == NfcDeviceProtocolMifareUl) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightData);
+                consumed = true;
+            }
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_nfc_data_info_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_nfca_menu.c

@@ -0,0 +1,62 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexSaveUid,
+    SubmenuIndexEmulateUid,
+    SubmenuIndexInfo,
+};
+
+void nfc_scene_nfca_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_nfca_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(
+        submenu, "Save UID", SubmenuIndexSaveUid, nfc_scene_nfca_menu_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Emulate UID", SubmenuIndexEmulateUid, nfc_scene_nfca_menu_submenu_callback, nfc);
+    submenu_add_item(submenu, "Info", SubmenuIndexInfo, nfc_scene_nfca_menu_submenu_callback, nfc);
+
+    submenu_set_selected_item(
+        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcaMenu));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_nfca_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexSaveUid) {
+            nfc->dev->format = NfcDeviceSaveFormatUid;
+            // Clear device name
+            nfc_device_set_name(nfc->dev, "");
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
+            consumed = true;
+        } else if(event.event == SubmenuIndexEmulateUid) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
+            consumed = true;
+        } else if(event.event == SubmenuIndexInfo) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcaMenu, event.event);
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_previous_scene(nfc->scene_manager);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_nfca_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_nfca_read_success.c

@@ -0,0 +1,72 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_nfca_read_success_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_scene_nfca_read_success_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+
+    // Setup view
+    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
+    Widget* widget = nfc->widget;
+
+    string_t temp_str;
+    string_init_set_str(temp_str, "\e#Unknown ISO tag\n");
+
+    char iso_type = FURI_BIT(data->sak, 5) ? '4' : '3';
+    string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
+    string_cat_printf(temp_str, "UID:");
+    for(size_t i = 0; i < data->uid_len; i++) {
+        string_cat_printf(temp_str, " %02X", data->uid[i]);
+    }
+    string_cat_printf(temp_str, "\nATQA: %02X %02X ", data->atqa[1], data->atqa[0]);
+    string_cat_printf(temp_str, " SAK: %02X", data->sak);
+
+    widget_add_text_scroll_element(widget, 0, 0, 128, 52, string_get_cstr(temp_str));
+    string_clear(temp_str);
+
+    widget_add_button_element(
+        widget, GuiButtonTypeLeft, "Retry", nfc_scene_nfca_read_success_widget_callback, nfc);
+    widget_add_button_element(
+        widget, GuiButtonTypeRight, "More", nfc_scene_nfca_read_success_widget_callback, nfc);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_nfca_read_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcaMenu);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
+        consumed = true;
+    }
+    return consumed;
+}
+
+void nfc_scene_nfca_read_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_read.c

@@ -0,0 +1,114 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+typedef enum {
+    NfcSceneReadStateIdle,
+    NfcSceneReadStateDetecting,
+    NfcSceneReadStateReading,
+} NfcSceneReadState;
+
+bool nfc_scene_read_worker_callback(NfcWorkerEvent event, void* context) {
+    Nfc* nfc = context;
+    bool consumed = false;
+    if(event == NfcWorkerEventReadMfClassicLoadKeyCache) {
+        consumed = nfc_device_load_key_cache(nfc->dev);
+    } else {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
+        consumed = true;
+    }
+    return consumed;
+}
+
+void nfc_scene_read_set_state(Nfc* nfc, NfcSceneReadState state) {
+    uint32_t curr_state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneRead);
+    if(curr_state != state) {
+        if(state == NfcSceneReadStateDetecting) {
+            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 == NfcSceneReadStateReading) {
+            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);
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneRead, state);
+    }
+}
+
+void nfc_scene_read_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcRead);
+
+    nfc_device_clear(nfc->dev);
+    // Setup view
+    nfc_scene_read_set_state(nfc, NfcSceneReadStateDetecting);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    // Start worker
+    nfc_worker_start(
+        nfc->worker, NfcWorkerStateRead, &nfc->dev->dev_data, nfc_scene_read_worker_callback, nfc);
+
+    nfc_blink_start(nfc);
+}
+
+bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if((event.event == NfcWorkerEventReadUidNfcB) ||
+           (event.event == NfcWorkerEventReadUidNfcF) ||
+           (event.event == NfcWorkerEventReadUidNfcV)) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneReadCardSuccess);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventReadUidNfcA) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcaReadSuccess);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventReadMfUltralight) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadSuccess);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventReadMfClassicDone) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicReadSuccess);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventReadMfDesfire) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireReadSuccess);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventReadBankCard) {
+            notification_message(nfc->notifications, &sequence_success);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmvReadSuccess);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventReadMfClassicDictAttackRequired) {
+            if(mf_classic_dict_check_presence(MfClassicDictTypeFlipper)) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicDictAttack);
+            } else {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
+            }
+            consumed = true;
+        } else if(event.event == NfcWorkerEventCardDetected) {
+            nfc_scene_read_set_state(nfc, NfcSceneReadStateReading);
+            consumed = true;
+        } else if(event.event == NfcWorkerEventNoCardDetected) {
+            nfc_scene_read_set_state(nfc, NfcSceneReadStateDetecting);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_read_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Stop worker
+    nfc_worker_stop(nfc->worker);
+    // Clear view
+    popup_reset(nfc->popup);
+    scene_manager_set_scene_state(nfc->scene_manager, NfcSceneRead, NfcSceneReadStateIdle);
+
+    nfc_blink_stop(nfc);
+}

applications/main/nfc/scenes/nfc_scene_read_card_success.c

@@ -0,0 +1,60 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_read_card_success_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_scene_read_card_success_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    string_t temp_str;
+    string_init(temp_str);
+    DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
+
+    // Setup view
+    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
+    Widget* widget = nfc->widget;
+    string_set_str(temp_str, nfc_get_dev_type(data->type));
+    widget_add_string_element(
+        widget, 64, 12, AlignCenter, AlignBottom, FontPrimary, string_get_cstr(temp_str));
+    string_set_str(temp_str, "UID:");
+    for(uint8_t i = 0; i < data->uid_len; i++) {
+        string_cat_printf(temp_str, " %02X", data->uid[i]);
+    }
+    widget_add_string_element(
+        widget, 64, 32, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(temp_str));
+    widget_add_button_element(
+        widget, GuiButtonTypeLeft, "Retry", nfc_scene_read_card_success_widget_callback, nfc);
+
+    string_clear(temp_str);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_read_card_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = scene_manager_previous_scene(nfc->scene_manager);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_read_card_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_restore_original.c

@@ -0,0 +1,45 @@
+#include "../nfc_i.h"
+
+void nfc_scene_restore_original_popup_callback(void* context) {
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_restore_original_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
+    popup_set_header(popup, "Original file\nrestored", 13, 22, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, nfc);
+    popup_set_callback(popup, nfc_scene_restore_original_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_restore_original_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneSavedMenu);
+            } else {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneStart);
+            }
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_restore_original_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    popup_reset(nfc->popup);
+}

applications/main/nfc/scenes/nfc_scene_restore_original_confirm.c

@@ -0,0 +1,53 @@
+#include "../nfc_i.h"
+
+void nfc_scene_restore_original_confirm_dialog_callback(DialogExResult result, void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+}
+
+void nfc_scene_restore_original_confirm_on_enter(void* context) {
+    Nfc* nfc = context;
+    DialogEx* dialog_ex = nfc->dialog_ex;
+
+    dialog_ex_set_header(dialog_ex, "Restore Card Data?", 64, 0, AlignCenter, AlignTop);
+    dialog_ex_set_icon(dialog_ex, 5, 15, &I_Restoring);
+    dialog_ex_set_text(
+        dialog_ex, "It will be returned\nto its original state.", 47, 21, AlignLeft, AlignTop);
+    dialog_ex_set_left_button_text(dialog_ex, "Cancel");
+    dialog_ex_set_right_button_text(dialog_ex, "Restore");
+    dialog_ex_set_context(dialog_ex, nfc);
+    dialog_ex_set_result_callback(dialog_ex, nfc_scene_restore_original_confirm_dialog_callback);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+}
+
+bool nfc_scene_restore_original_confirm_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == DialogExResultRight) {
+            if(!nfc_device_restore(nfc->dev, true)) {
+                scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneStart);
+            } else {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneRestoreOriginal);
+            }
+            consumed = true;
+        } else if(event.event == DialogExResultLeft) {
+            consumed = scene_manager_previous_scene(nfc->scene_manager);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_restore_original_confirm_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean view
+    dialog_ex_reset(nfc->dialog_ex);
+}

applications/main/nfc/scenes/nfc_scene_retry_confirm.c

@@ -0,0 +1,47 @@
+#include "../nfc_i.h"
+
+void nfc_scene_retry_confirm_dialog_callback(DialogExResult result, void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+}
+
+void nfc_scene_retry_confirm_on_enter(void* context) {
+    Nfc* nfc = context;
+    DialogEx* dialog_ex = nfc->dialog_ex;
+
+    dialog_ex_set_left_button_text(dialog_ex, "Retry");
+    dialog_ex_set_right_button_text(dialog_ex, "Stay");
+    dialog_ex_set_header(dialog_ex, "Retry Reading?", 64, 11, AlignCenter, AlignTop);
+    dialog_ex_set_text(
+        dialog_ex, "All unsaved data will be\nlost!", 64, 25, AlignCenter, AlignTop);
+    dialog_ex_set_context(dialog_ex, nfc);
+    dialog_ex_set_result_callback(dialog_ex, nfc_scene_retry_confirm_dialog_callback);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+}
+
+bool nfc_scene_retry_confirm_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == DialogExResultRight) {
+            consumed = scene_manager_previous_scene(nfc->scene_manager);
+        } else if(event.event == DialogExResultLeft) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                nfc->scene_manager, NfcSceneRead);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_retry_confirm_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clean view
+    dialog_ex_reset(nfc->dialog_ex);
+}

applications/main/nfc/scenes/nfc_scene_rpc.c

@@ -0,0 +1,86 @@
+#include "../nfc_i.h"
+
+void nfc_scene_rpc_on_enter(void* context) {
+    Nfc* nfc = context;
+    Popup* popup = nfc->popup;
+
+    popup_set_header(popup, "NFC", 89, 42, AlignCenter, AlignBottom);
+    popup_set_text(popup, "RPC mode", 89, 44, AlignCenter, AlignTop);
+
+    popup_set_icon(popup, 0, 12, &I_RFIDDolphinSend_97x61);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+
+    notification_message(nfc->notifications, &sequence_display_backlight_on);
+}
+
+static bool nfc_scene_rpc_emulate_callback(NfcWorkerEvent event, void* context) {
+    UNUSED(event);
+    Nfc* nfc = context;
+
+    nfc->rpc_state = NfcRpcStateEmulated;
+    return true;
+}
+
+bool nfc_scene_rpc_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    Popup* popup = nfc->popup;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        consumed = true;
+        if(event.event == NfcCustomEventViewExit) {
+            rpc_system_app_confirm(nfc->rpc_ctx, RpcAppEventAppExit, true);
+            scene_manager_stop(nfc->scene_manager);
+            view_dispatcher_stop(nfc->view_dispatcher);
+        } else if(event.event == NfcCustomEventRpcSessionClose) {
+            scene_manager_stop(nfc->scene_manager);
+            view_dispatcher_stop(nfc->view_dispatcher);
+        } else if(event.event == NfcCustomEventRpcLoad) {
+            bool result = false;
+            const char* arg = rpc_system_app_get_data(nfc->rpc_ctx);
+            if((arg) && (nfc->rpc_state == NfcRpcStateIdle)) {
+                if(nfc_device_load(nfc->dev, arg, false)) {
+                    if(nfc->dev->format == NfcDeviceSaveFormatMifareUl) {
+                        nfc_worker_start(
+                            nfc->worker,
+                            NfcWorkerStateMfUltralightEmulate,
+                            &nfc->dev->dev_data,
+                            nfc_scene_rpc_emulate_callback,
+                            nfc);
+                    } else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
+                        nfc_worker_start(
+                            nfc->worker,
+                            NfcWorkerStateMfClassicEmulate,
+                            &nfc->dev->dev_data,
+                            nfc_scene_rpc_emulate_callback,
+                            nfc);
+                    } else {
+                        nfc_worker_start(
+                            nfc->worker, NfcWorkerStateUidEmulate, &nfc->dev->dev_data, NULL, nfc);
+                    }
+                    nfc->rpc_state = NfcRpcStateEmulating;
+                    result = true;
+
+                    nfc_blink_start(nfc);
+                    nfc_text_store_set(nfc, "emulating\n%s", nfc->dev->dev_name);
+                    popup_set_text(popup, nfc->text_store, 89, 44, AlignCenter, AlignTop);
+                }
+            }
+
+            rpc_system_app_confirm(nfc->rpc_ctx, RpcAppEventLoadFile, result);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_rpc_on_exit(void* context) {
+    Nfc* nfc = context;
+    Popup* popup = nfc->popup;
+
+    nfc_blink_stop(nfc);
+
+    popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
+    popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
+    popup_set_icon(popup, 0, 0, NULL);
+}

applications/main/nfc/scenes/nfc_scene_save_name.c

@@ -0,0 +1,86 @@
+#include "../nfc_i.h"
+#include "m-string.h"
+#include <lib/toolbox/random_name.h>
+#include <gui/modules/validators.h>
+#include <toolbox/path.h>
+
+void nfc_scene_save_name_text_input_callback(void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventTextInputDone);
+}
+
+void nfc_scene_save_name_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    TextInput* text_input = nfc->text_input;
+    bool dev_name_empty = false;
+    if(!strcmp(nfc->dev->dev_name, "")) {
+        set_random_name(nfc->text_store, sizeof(nfc->text_store));
+        dev_name_empty = true;
+    } else {
+        nfc_text_store_set(nfc, nfc->dev->dev_name);
+    }
+    text_input_set_header_text(text_input, "Name the card");
+    text_input_set_result_callback(
+        text_input,
+        nfc_scene_save_name_text_input_callback,
+        nfc,
+        nfc->text_store,
+        NFC_DEV_NAME_MAX_LEN,
+        dev_name_empty);
+
+    string_t folder_path;
+    string_init(folder_path);
+
+    if(string_end_with_str_p(nfc->dev->load_path, NFC_APP_EXTENSION)) {
+        path_extract_dirname(string_get_cstr(nfc->dev->load_path), folder_path);
+    } else {
+        string_set_str(folder_path, NFC_APP_FOLDER);
+    }
+
+    ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(
+        string_get_cstr(folder_path), NFC_APP_EXTENSION, nfc->dev->dev_name);
+    text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextInput);
+
+    string_clear(folder_path);
+}
+
+bool nfc_scene_save_name_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventTextInputDone) {
+            if(strcmp(nfc->dev->dev_name, "")) {
+                nfc_device_delete(nfc->dev, true);
+            }
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetUid)) {
+                nfc->dev->dev_data.nfc_data = nfc->dev_edit_data;
+            }
+            strlcpy(nfc->dev->dev_name, nfc->text_store, strlen(nfc->text_store) + 1);
+            if(nfc_device_save(nfc->dev, nfc->text_store)) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
+                consumed = true;
+            } else {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneStart);
+            }
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_save_name_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    void* validator_context = text_input_get_validator_callback_context(nfc->text_input);
+    text_input_set_validator(nfc->text_input, NULL, NULL);
+    validator_is_file_free(validator_context);
+
+    text_input_reset(nfc->text_input);
+}

applications/main/nfc/scenes/nfc_scene_save_success.c

@@ -0,0 +1,47 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_save_success_popup_callback(void* context) {
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_save_success_on_enter(void* context) {
+    Nfc* nfc = context;
+    DOLPHIN_DEED(DolphinDeedNfcSave);
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
+    popup_set_header(popup, "Saved!", 13, 22, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, nfc);
+    popup_set_callback(popup, nfc_scene_save_success_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneSavedMenu);
+            } else {
+                consumed = scene_manager_search_and_switch_to_another_scene(
+                    nfc->scene_manager, NfcSceneFileSelect);
+            }
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_save_success_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    // Clear view
+    popup_reset(nfc->popup);
+}

applications/main/nfc/scenes/nfc_scene_saved_menu.c

@@ -0,0 +1,117 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexEmulate,
+    SubmenuIndexEditUid,
+    SubmenuIndexRename,
+    SubmenuIndexDelete,
+    SubmenuIndexInfo,
+    SubmenuIndexRestoreOriginal,
+};
+
+void nfc_scene_saved_menu_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_saved_menu_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    if(nfc->dev->format == NfcDeviceSaveFormatUid ||
+       nfc->dev->format == NfcDeviceSaveFormatMifareDesfire ||
+       nfc->dev->format == NfcDeviceSaveFormatBankCard) {
+        submenu_add_item(
+            submenu,
+            "Emulate UID",
+            SubmenuIndexEmulate,
+            nfc_scene_saved_menu_submenu_callback,
+            nfc);
+        if(nfc->dev->dev_data.protocol == NfcDeviceProtocolUnknown) {
+            submenu_add_item(
+                submenu,
+                "Edit UID",
+                SubmenuIndexEditUid,
+                nfc_scene_saved_menu_submenu_callback,
+                nfc);
+        }
+    } else if(
+        nfc->dev->format == NfcDeviceSaveFormatMifareUl ||
+        nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
+        submenu_add_item(
+            submenu, "Emulate", SubmenuIndexEmulate, nfc_scene_saved_menu_submenu_callback, nfc);
+    }
+    submenu_add_item(
+        submenu, "Info", SubmenuIndexInfo, nfc_scene_saved_menu_submenu_callback, nfc);
+    if(nfc->dev->shadow_file_exist) {
+        submenu_add_item(
+            submenu,
+            "Restore to original",
+            SubmenuIndexRestoreOriginal,
+            nfc_scene_saved_menu_submenu_callback,
+            nfc);
+    }
+    submenu_add_item(
+        submenu, "Rename", SubmenuIndexRename, nfc_scene_saved_menu_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Delete", SubmenuIndexDelete, nfc_scene_saved_menu_submenu_callback, nfc);
+    submenu_set_selected_item(
+        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneSavedMenu));
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_saved_menu_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    NfcDeviceData* dev_data = &nfc->dev->dev_data;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneSavedMenu, event.event);
+        if(event.event == SubmenuIndexEmulate) {
+            if(nfc->dev->format == NfcDeviceSaveFormatMifareUl) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
+            } else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicEmulate);
+            } else {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
+            }
+            consumed = true;
+        } else if(event.event == SubmenuIndexRename) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
+            consumed = true;
+        } else if(event.event == SubmenuIndexEditUid) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetUid);
+            consumed = true;
+        } else if(event.event == SubmenuIndexDelete) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneDelete);
+            consumed = true;
+        } else if(event.event == SubmenuIndexInfo) {
+            bool application_info_present = false;
+            if(dev_data->protocol == NfcDeviceProtocolEMV) {
+                application_info_present = true;
+            } else if(dev_data->protocol == NfcDeviceProtocolMifareClassic) {
+                application_info_present = nfc_supported_card_verify_and_parse(dev_data);
+            }
+
+            if(application_info_present) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneDeviceInfo);
+            } else {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
+            }
+            consumed = true;
+        } else if(event.event == SubmenuIndexRestoreOriginal) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRestoreOriginalConfirm);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_saved_menu_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_set_atqa.c

@@ -0,0 +1,44 @@
+#include "../nfc_i.h"
+
+void nfc_scene_set_atqa_byte_input_callback(void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+}
+
+void nfc_scene_set_atqa_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    ByteInput* byte_input = nfc->byte_input;
+    byte_input_set_header_text(byte_input, "Enter atqa in hex");
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_scene_set_atqa_byte_input_callback,
+        NULL,
+        nfc,
+        nfc->dev->dev_data.nfc_data.atqa,
+        2);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+}
+
+bool nfc_scene_set_atqa_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, NfcSceneSetUid);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_set_atqa_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_set_sak.c

@@ -0,0 +1,44 @@
+#include "../nfc_i.h"
+
+void nfc_scene_set_sak_byte_input_callback(void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+}
+
+void nfc_scene_set_sak_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    ByteInput* byte_input = nfc->byte_input;
+    byte_input_set_header_text(byte_input, "Enter SAK in hex");
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_scene_set_sak_byte_input_callback,
+        NULL,
+        nfc,
+        &nfc->dev->dev_data.nfc_data.sak,
+        1);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+}
+
+bool nfc_scene_set_sak_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, NfcSceneSetAtqua);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_set_sak_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_set_type.c

@@ -0,0 +1,69 @@
+#include "../nfc_i.h"
+#include "m-string.h"
+#include "../helpers/nfc_generators.h"
+
+enum SubmenuIndex {
+    SubmenuIndexNFCA4,
+    SubmenuIndexNFCA7,
+    SubmenuIndexGeneratorsStart,
+};
+
+void nfc_scene_set_type_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_set_type_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+    // Clear device name
+    nfc_device_set_name(nfc->dev, "");
+    string_set_str(nfc->dev->load_path, "");
+    submenu_add_item(
+        submenu, "NFC-A 7-bytes UID", SubmenuIndexNFCA7, nfc_scene_set_type_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "NFC-A 4-bytes UID", SubmenuIndexNFCA4, nfc_scene_set_type_submenu_callback, nfc);
+
+    // Generators
+    int i = SubmenuIndexGeneratorsStart;
+    for(const NfcGenerator* const* generator = nfc_generators; *generator != NULL;
+        ++generator, ++i) {
+        submenu_add_item(submenu, (*generator)->name, i, nfc_scene_set_type_submenu_callback, nfc);
+    }
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_set_type_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexNFCA7) {
+            nfc->dev->dev_data.nfc_data.uid_len = 7;
+            nfc->dev->format = NfcDeviceSaveFormatUid;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetSak);
+            consumed = true;
+        } else if(event.event == SubmenuIndexNFCA4) {
+            nfc->dev->dev_data.nfc_data.uid_len = 4;
+            nfc->dev->format = NfcDeviceSaveFormatUid;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetSak);
+            consumed = true;
+        } else {
+            nfc_device_clear(nfc->dev);
+            nfc->generator = nfc_generators[event.event - SubmenuIndexGeneratorsStart];
+            nfc->generator->generator_func(&nfc->dev->dev_data);
+
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneGenerateInfo);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_set_type_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_set_uid.c

@@ -0,0 +1,55 @@
+#include "../nfc_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_set_uid_byte_input_callback(void* context) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+}
+
+void nfc_scene_set_uid_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    ByteInput* byte_input = nfc->byte_input;
+    byte_input_set_header_text(byte_input, "Enter uid in hex");
+    nfc->dev_edit_data = nfc->dev->dev_data.nfc_data;
+    byte_input_set_result_callback(
+        byte_input,
+        nfc_scene_set_uid_byte_input_callback,
+        NULL,
+        nfc,
+        nfc->dev_edit_data.uid,
+        nfc->dev_edit_data.uid_len);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+}
+
+bool nfc_scene_set_uid_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = (Nfc*)context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventByteInputDone) {
+            DOLPHIN_DEED(DolphinDeedNfcAdd);
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
+                nfc->dev->dev_data.nfc_data = nfc->dev_edit_data;
+                if(nfc_device_save(nfc->dev, nfc->dev->dev_name)) {
+                    scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
+                    consumed = true;
+                }
+            } else {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
+                consumed = true;
+            }
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_set_uid_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_start.c

@@ -0,0 +1,81 @@
+#include "../nfc_i.h"
+
+enum SubmenuIndex {
+    SubmenuIndexRead,
+    SubmenuIndexDetectReader,
+    SubmenuIndexSaved,
+    SubmenuIndexExtraAction,
+    SubmenuIndexAddManualy,
+    SubmenuIndexDebug,
+};
+
+void nfc_scene_start_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_start_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(submenu, "Read", SubmenuIndexRead, nfc_scene_start_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Detect Reader", SubmenuIndexDetectReader, nfc_scene_start_submenu_callback, nfc);
+    submenu_add_item(submenu, "Saved", SubmenuIndexSaved, nfc_scene_start_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Extra Actions", SubmenuIndexExtraAction, nfc_scene_start_submenu_callback, nfc);
+    submenu_add_item(
+        submenu, "Add Manually", SubmenuIndexAddManualy, nfc_scene_start_submenu_callback, nfc);
+
+    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
+        submenu_add_item(
+            submenu, "Debug", SubmenuIndexDebug, nfc_scene_start_submenu_callback, nfc);
+    }
+
+    submenu_set_selected_item(
+        submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneStart));
+
+    nfc_device_clear(nfc->dev);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_start_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexRead) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
+            consumed = true;
+        } else if(event.event == SubmenuIndexDetectReader) {
+            bool sd_exist = storage_sd_status(nfc->dev->storage) == FSE_OK;
+            if(sd_exist) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneDetectReader);
+            } else {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
+            }
+            consumed = true;
+        } else if(event.event == SubmenuIndexSaved) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneFileSelect);
+            consumed = true;
+        } else if(event.event == SubmenuIndexExtraAction) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneExtraActions);
+            consumed = true;
+        } else if(event.event == SubmenuIndexAddManualy) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetType);
+            consumed = true;
+        } else if(event.event == SubmenuIndexDebug) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneDebug);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneStart, event.event);
+    }
+    return consumed;
+}
+
+void nfc_scene_start_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/views/detect_reader.c

@@ -0,0 +1,115 @@
+#include "detect_reader.h"
+
+#include <gui/elements.h>
+
+struct DetectReader {
+    View* view;
+    DetectReaderDoneCallback callback;
+    void* context;
+};
+
+typedef struct {
+    uint16_t nonces;
+} DetectReaderViewModel;
+
+static void detect_reader_draw_callback(Canvas* canvas, void* model) {
+    DetectReaderViewModel* m = model;
+    char text[32] = {};
+
+    snprintf(text, sizeof(text), "Tap the reader several times");
+    canvas_draw_str_aligned(canvas, 64, 0, AlignCenter, AlignTop, "Tap the reader several times");
+
+    if(m->nonces == 0) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 52, 22, AlignLeft, AlignTop, "Emulating...");
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(canvas, 52, 35, AlignLeft, AlignTop, "MIFARE Classic");
+        canvas_draw_icon(canvas, 0, 13, &I_Tap_reader_36x38);
+    } else {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 54, 22, AlignLeft, AlignTop, "Collecting...");
+        canvas_set_font(canvas, FontSecondary);
+        snprintf(text, sizeof(text), "Nonces: %d", m->nonces);
+        canvas_draw_str_aligned(canvas, 54, 35, AlignLeft, AlignTop, text);
+        elements_button_right(canvas, "Next");
+        canvas_draw_icon(canvas, 6, 15, &I_ArrowC_1_36x36);
+    }
+}
+
+static bool detect_reader_input_callback(InputEvent* event, void* context) {
+    DetectReader* detect_reader = context;
+    furi_assert(detect_reader->callback);
+    bool consumed = false;
+
+    uint8_t nonces = 0;
+    with_view_model(
+        detect_reader->view, (DetectReaderViewModel * model) {
+            nonces = model->nonces;
+            return false;
+        });
+
+    if(event->type == InputTypeShort) {
+        if(event->key == InputKeyRight) {
+            if(nonces > 0) {
+                detect_reader->callback(detect_reader->context);
+                consumed = true;
+            }
+        }
+    }
+
+    return consumed;
+}
+
+DetectReader* detect_reader_alloc() {
+    DetectReader* detect_reader = malloc(sizeof(DetectReader));
+    detect_reader->view = view_alloc();
+    view_allocate_model(detect_reader->view, ViewModelTypeLocking, sizeof(DetectReaderViewModel));
+    view_set_draw_callback(detect_reader->view, detect_reader_draw_callback);
+    view_set_input_callback(detect_reader->view, detect_reader_input_callback);
+    view_set_context(detect_reader->view, detect_reader);
+
+    return detect_reader;
+}
+
+void detect_reader_free(DetectReader* detect_reader) {
+    furi_assert(detect_reader);
+
+    view_free(detect_reader->view);
+    free(detect_reader);
+}
+
+void detect_reader_reset(DetectReader* detect_reader) {
+    furi_assert(detect_reader);
+
+    with_view_model(
+        detect_reader->view, (DetectReaderViewModel * model) {
+            model->nonces = 0;
+            return false;
+        });
+}
+
+View* detect_reader_get_view(DetectReader* detect_reader) {
+    furi_assert(detect_reader);
+
+    return detect_reader->view;
+}
+
+void detect_reader_set_callback(
+    DetectReader* detect_reader,
+    DetectReaderDoneCallback callback,
+    void* context) {
+    furi_assert(detect_reader);
+    furi_assert(callback);
+
+    detect_reader->callback = callback;
+    detect_reader->context = context;
+}
+
+void detect_reader_inc_nonce_cnt(DetectReader* detect_reader) {
+    furi_assert(detect_reader);
+    with_view_model(
+        detect_reader->view, (DetectReaderViewModel * model) {
+            model->nonces++;
+            return false;
+        });
+}

applications/main/nfc/views/detect_reader.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <stdint.h>
+#include <gui/view.h>
+#include <gui/modules/widget.h>
+
+typedef struct DetectReader DetectReader;
+
+typedef void (*DetectReaderDoneCallback)(void* context);
+
+DetectReader* detect_reader_alloc();
+
+void detect_reader_free(DetectReader* detect_reader);
+
+void detect_reader_reset(DetectReader* detect_reader);
+
+View* detect_reader_get_view(DetectReader* detect_reader);
+
+void detect_reader_set_callback(
+    DetectReader* detect_reader,
+    DetectReaderDoneCallback callback,
+    void* context);
+
+void detect_reader_inc_nonce_cnt(DetectReader* detect_reader);

applications/main/nfc/views/dict_attack.c

@@ -0,0 +1,231 @@
+#include "dict_attack.h"
+
+#include <m-string.h>
+#include <gui/elements.h>
+
+typedef enum {
+    DictAttackStateRead,
+    DictAttackStateCardRemoved,
+} DictAttackState;
+
+struct DictAttack {
+    View* view;
+    DictAttackCallback callback;
+    void* context;
+};
+
+typedef struct {
+    DictAttackState state;
+    MfClassicType type;
+    string_t header;
+    uint8_t sectors_total;
+    uint8_t sectors_read;
+    uint8_t sector_current;
+    uint8_t keys_total;
+    uint8_t keys_found;
+    uint16_t dict_keys_total;
+    uint16_t dict_keys_current;
+} DictAttackViewModel;
+
+static void dict_attack_draw_callback(Canvas* canvas, void* model) {
+    DictAttackViewModel* m = model;
+    if(m->state == DictAttackStateCardRemoved) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 64, 4, AlignCenter, AlignTop, "Lost the tag!");
+        canvas_set_font(canvas, FontSecondary);
+        elements_multiline_text_aligned(
+            canvas, 64, 23, AlignCenter, AlignTop, "Make sure the tag is\npositioned correctly.");
+    } else if(m->state == DictAttackStateRead) {
+        char draw_str[32] = {};
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 64, 2, AlignCenter, AlignTop, string_get_cstr(m->header));
+        canvas_set_font(canvas, FontSecondary);
+        float dict_progress = m->dict_keys_total == 0 ?
+                                  0 :
+                                  (float)(m->dict_keys_current) / (float)(m->dict_keys_total);
+        float progress = m->sectors_total == 0 ? 0 :
+                                                 ((float)(m->sector_current) + dict_progress) /
+                                                     (float)(m->sectors_total);
+        if(progress > 1.0) {
+            progress = 1.0;
+        }
+        elements_progress_bar(canvas, 5, 15, 120, progress);
+        canvas_set_font(canvas, FontSecondary);
+        snprintf(draw_str, sizeof(draw_str), "Keys found: %d/%d", m->keys_found, m->keys_total);
+        canvas_draw_str_aligned(canvas, 1, 28, AlignLeft, AlignTop, draw_str);
+        snprintf(
+            draw_str, sizeof(draw_str), "Sectors Read: %d/%d", m->sectors_read, m->sectors_total);
+        canvas_draw_str_aligned(canvas, 1, 40, AlignLeft, AlignTop, draw_str);
+    }
+    elements_button_center(canvas, "Skip");
+}
+
+static bool dict_attack_input_callback(InputEvent* event, void* context) {
+    DictAttack* dict_attack = context;
+    bool consumed = false;
+    if(event->type == InputTypeShort && event->key == InputKeyOk) {
+        if(dict_attack->callback) {
+            dict_attack->callback(dict_attack->context);
+        }
+        consumed = true;
+    }
+    return consumed;
+}
+
+DictAttack* dict_attack_alloc() {
+    DictAttack* dict_attack = malloc(sizeof(DictAttack));
+    dict_attack->view = view_alloc();
+    view_allocate_model(dict_attack->view, ViewModelTypeLocking, sizeof(DictAttackViewModel));
+    view_set_draw_callback(dict_attack->view, dict_attack_draw_callback);
+    view_set_input_callback(dict_attack->view, dict_attack_input_callback);
+    view_set_context(dict_attack->view, dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            string_init(model->header);
+            return false;
+        });
+    return dict_attack;
+}
+
+void dict_attack_free(DictAttack* dict_attack) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            string_clear(model->header);
+            return false;
+        });
+    view_free(dict_attack->view);
+    free(dict_attack);
+}
+
+void dict_attack_reset(DictAttack* dict_attack) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            model->state = DictAttackStateRead;
+            model->type = MfClassicType1k;
+            model->sectors_total = 0;
+            model->sectors_read = 0;
+            model->sector_current = 0;
+            model->keys_total = 0;
+            model->keys_found = 0;
+            model->dict_keys_total = 0;
+            model->dict_keys_current = 0;
+            string_reset(model->header);
+            return false;
+        });
+}
+
+View* dict_attack_get_view(DictAttack* dict_attack) {
+    furi_assert(dict_attack);
+    return dict_attack->view;
+}
+
+void dict_attack_set_callback(DictAttack* dict_attack, DictAttackCallback callback, void* context) {
+    furi_assert(dict_attack);
+    furi_assert(callback);
+    dict_attack->callback = callback;
+    dict_attack->context = context;
+}
+
+void dict_attack_set_header(DictAttack* dict_attack, const char* header) {
+    furi_assert(dict_attack);
+    furi_assert(header);
+
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            string_set_str(model->header, header);
+            return true;
+        });
+}
+
+void dict_attack_set_card_detected(DictAttack* dict_attack, MfClassicType type) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            model->state = DictAttackStateRead;
+            model->sectors_total = mf_classic_get_total_sectors_num(type);
+            model->keys_total = model->sectors_total * 2;
+            return true;
+        });
+}
+
+void dict_attack_set_card_removed(DictAttack* dict_attack) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            model->state = DictAttackStateCardRemoved;
+            return true;
+        });
+}
+
+void dict_attack_set_sector_read(DictAttack* dict_attack, uint8_t sec_read) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            model->sectors_read = sec_read;
+            return true;
+        });
+}
+
+void dict_attack_set_keys_found(DictAttack* dict_attack, uint8_t keys_found) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            model->keys_found = keys_found;
+            return true;
+        });
+}
+
+void dict_attack_set_current_sector(DictAttack* dict_attack, uint8_t curr_sec) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            model->sector_current = curr_sec;
+            model->dict_keys_current = 0;
+            return true;
+        });
+}
+
+void dict_attack_inc_current_sector(DictAttack* dict_attack) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            if(model->sector_current < model->sectors_total) {
+                model->sector_current++;
+                model->dict_keys_current = 0;
+            }
+            return true;
+        });
+}
+
+void dict_attack_inc_keys_found(DictAttack* dict_attack) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            if(model->keys_found < model->keys_total) {
+                model->keys_found++;
+            }
+            return true;
+        });
+}
+
+void dict_attack_set_total_dict_keys(DictAttack* dict_attack, uint16_t dict_keys_total) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            model->dict_keys_total = dict_keys_total;
+            return true;
+        });
+}
+
+void dict_attack_inc_current_dict_key(DictAttack* dict_attack, uint16_t keys_tried) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view, (DictAttackViewModel * model) {
+            if(model->dict_keys_current + keys_tried < model->dict_keys_total) {
+                model->dict_keys_current += keys_tried;
+            }
+            return true;
+        });
+}

applications/main/nfc/views/dict_attack.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <stdint.h>
+#include <gui/view.h>
+#include <gui/modules/widget.h>
+
+#include <lib/nfc/protocols/mifare_classic.h>
+
+typedef struct DictAttack DictAttack;
+
+typedef void (*DictAttackCallback)(void* context);
+
+DictAttack* dict_attack_alloc();
+
+void dict_attack_free(DictAttack* dict_attack);
+
+void dict_attack_reset(DictAttack* dict_attack);
+
+View* dict_attack_get_view(DictAttack* dict_attack);
+
+void dict_attack_set_callback(DictAttack* dict_attack, DictAttackCallback callback, void* context);
+
+void dict_attack_set_header(DictAttack* dict_attack, const char* header);
+
+void dict_attack_set_card_detected(DictAttack* dict_attack, MfClassicType type);
+
+void dict_attack_set_card_removed(DictAttack* dict_attack);
+
+void dict_attack_set_sector_read(DictAttack* dict_attack, uint8_t sec_read);
+
+void dict_attack_set_keys_found(DictAttack* dict_attack, uint8_t keys_found);
+
+void dict_attack_set_current_sector(DictAttack* dict_attack, uint8_t curr_sec);
+
+void dict_attack_inc_current_sector(DictAttack* dict_attack);
+
+void dict_attack_inc_keys_found(DictAttack* dict_attack);
+
+void dict_attack_set_total_dict_keys(DictAttack* dict_attack, uint16_t dict_keys_total);
+
+void dict_attack_inc_current_dict_key(DictAttack* dict_attack, uint16_t keys_tried);