upd vb migrate app

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/helpers/nfc_debug_log.c

@@ -1,71 +0,0 @@
-#include "nfc_debug_log.h"
-
-#include <storage/storage.h>
-#include <stream/buffered_file_stream.h>
-
-#define TAG "NfcDebugLog"
-
-#define NFC_DEBUG_PCAP_FILENAME EXT_PATH("nfc/debug.txt")
-
-struct NfcDebugLog {
-    Stream* file_stream;
-    FuriString* data_str;
-};
-
-NfcDebugLog* nfc_debug_log_alloc() {
-    NfcDebugLog* instance = malloc(sizeof(NfcDebugLog));
-
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    instance->file_stream = buffered_file_stream_alloc(storage);
-
-    if(!buffered_file_stream_open(
-           instance->file_stream, NFC_DEBUG_PCAP_FILENAME, FSAM_WRITE, FSOM_OPEN_APPEND)) {
-        buffered_file_stream_close(instance->file_stream);
-        stream_free(instance->file_stream);
-        instance->file_stream = NULL;
-    }
-
-    if(!instance->file_stream) {
-        free(instance);
-        instance = NULL;
-    } else {
-        instance->data_str = furi_string_alloc();
-    }
-    furi_record_close(RECORD_STORAGE);
-
-    return instance;
-}
-
-void nfc_debug_log_free(NfcDebugLog* instance) {
-    furi_assert(instance);
-    furi_assert(instance->file_stream);
-    furi_assert(instance->data_str);
-
-    buffered_file_stream_close(instance->file_stream);
-    stream_free(instance->file_stream);
-    furi_string_free(instance->data_str);
-
-    free(instance);
-}
-
-void nfc_debug_log_process_data(
-    NfcDebugLog* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped) {
-    furi_assert(instance);
-    furi_assert(instance->file_stream);
-    furi_assert(instance->data_str);
-    furi_assert(data);
-    UNUSED(crc_dropped);
-
-    furi_string_printf(instance->data_str, "%lu %c:", furi_get_tick(), reader_to_tag ? 'R' : 'T');
-    uint16_t data_len = len;
-    for(size_t i = 0; i < data_len; i++) {
-        furi_string_cat_printf(instance->data_str, " %02x", data[i]);
-    }
-    furi_string_push_back(instance->data_str, '\n');
-
-    stream_write_string(instance->file_stream, instance->data_str);
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/helpers/nfc_debug_log.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-
-typedef struct NfcDebugLog NfcDebugLog;
-
-NfcDebugLog* nfc_debug_log_alloc();
-
-void nfc_debug_log_free(NfcDebugLog* instance);
-
-void nfc_debug_log_process_data(
-    NfcDebugLog* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped);

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/helpers/nfc_debug_pcap.c

@@ -1,130 +0,0 @@
-#include "nfc_debug_pcap.h"
-
-#include <storage/storage.h>
-#include <stream/buffered_file_stream.h>
-#include <furi_hal_nfc.h>
-#include <furi_hal_rtc.h>
-
-#define TAG "NfcDebugPcap"
-
-#define PCAP_MAGIC 0xa1b2c3d4
-#define PCAP_MAJOR 2
-#define PCAP_MINOR 4
-#define DLT_ISO_14443 264
-
-#define DATA_PICC_TO_PCD 0xFF
-#define DATA_PCD_TO_PICC 0xFE
-#define DATA_PICC_TO_PCD_CRC_DROPPED 0xFB
-#define DATA_PCD_TO_PICC_CRC_DROPPED 0xFA
-
-#define NFC_DEBUG_PCAP_FILENAME EXT_PATH("nfc/debug.pcap")
-
-struct NfcDebugPcap {
-    Stream* file_stream;
-};
-
-static Stream* nfc_debug_pcap_open(Storage* storage) {
-    Stream* stream = NULL;
-    stream = buffered_file_stream_alloc(storage);
-    if(!buffered_file_stream_open(stream, NFC_DEBUG_PCAP_FILENAME, FSAM_WRITE, FSOM_OPEN_APPEND)) {
-        buffered_file_stream_close(stream);
-        stream_free(stream);
-        stream = NULL;
-    } else {
-        if(!stream_tell(stream)) {
-            struct {
-                uint32_t magic;
-                uint16_t major, minor;
-                uint32_t reserved[2];
-                uint32_t snaplen;
-                uint32_t link_type;
-            } __attribute__((__packed__)) pcap_hdr = {
-                .magic = PCAP_MAGIC,
-                .major = PCAP_MAJOR,
-                .minor = PCAP_MINOR,
-                .snaplen = FURI_HAL_NFC_DATA_BUFF_SIZE,
-                .link_type = DLT_ISO_14443,
-            };
-            if(stream_write(stream, (uint8_t*)&pcap_hdr, sizeof(pcap_hdr)) != sizeof(pcap_hdr)) {
-                FURI_LOG_E(TAG, "Failed to write pcap header");
-                buffered_file_stream_close(stream);
-                stream_free(stream);
-                stream = NULL;
-            }
-        }
-    }
-    return stream;
-}
-
-NfcDebugPcap* nfc_debug_pcap_alloc() {
-    NfcDebugPcap* instance = malloc(sizeof(NfcDebugPcap));
-
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    instance->file_stream = nfc_debug_pcap_open(storage);
-    if(!instance->file_stream) {
-        free(instance);
-        instance = NULL;
-    }
-    furi_record_close(RECORD_STORAGE);
-
-    return instance;
-}
-
-void nfc_debug_pcap_free(NfcDebugPcap* instance) {
-    furi_assert(instance);
-    furi_assert(instance->file_stream);
-
-    buffered_file_stream_close(instance->file_stream);
-    stream_free(instance->file_stream);
-
-    free(instance);
-}
-
-void nfc_debug_pcap_process_data(
-    NfcDebugPcap* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped) {
-    furi_assert(instance);
-    furi_assert(data);
-    DateTime datetime;
-    furi_hal_rtc_get_datetime(&datetime);
-
-    uint8_t event = 0;
-    if(reader_to_tag) {
-        if(crc_dropped) {
-            event = DATA_PCD_TO_PICC_CRC_DROPPED;
-        } else {
-            event = DATA_PCD_TO_PICC;
-        }
-    } else {
-        if(crc_dropped) {
-            event = DATA_PICC_TO_PCD_CRC_DROPPED;
-        } else {
-            event = DATA_PICC_TO_PCD;
-        }
-    }
-
-    struct {
-        // https://wiki.wireshark.org/Development/LibpcapFileFormat#record-packet-header
-        uint32_t ts_sec;
-        uint32_t ts_usec;
-        uint32_t incl_len;
-        uint32_t orig_len;
-        // https://www.kaiser.cx/posts/pcap-iso14443/#_packet_data
-        uint8_t version;
-        uint8_t event;
-        uint16_t len;
-    } __attribute__((__packed__)) pkt_hdr = {
-        .ts_sec = datetime_datetime_to_timestamp(&datetime),
-        .ts_usec = 0,
-        .incl_len = len + 4,
-        .orig_len = len + 4,
-        .version = 0,
-        .event = event,
-        .len = len << 8 | len >> 8,
-    };
-    stream_write(instance->file_stream, (uint8_t*)&pkt_hdr, sizeof(pkt_hdr));
-    stream_write(instance->file_stream, data, len);
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/helpers/nfc_debug_pcap.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-
-typedef struct NfcDebugPcap NfcDebugPcap;
-
-NfcDebugPcap* nfc_debug_pcap_alloc();
-
-void nfc_debug_pcap_free(NfcDebugPcap* instance);
-
-void nfc_debug_pcap_process_data(
-    NfcDebugPcap* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped);

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/helpers/reader_analyzer.c

@@ -1,193 +0,0 @@
-#include "reader_analyzer.h"
-#include <lib/nfc/protocols/nfc_util.h>
-#include <lib/nfc/protocols/mifare_classic.h>
-#include <m-array.h>
-
-#include "nfc_debug_pcap.h"
-#include "nfc_debug_log.h"
-
-#define TAG "ReaderAnalyzer"
-
-#define READER_ANALYZER_MAX_BUFF_SIZE (1024)
-
-typedef struct {
-    bool reader_to_tag;
-    bool crc_dropped;
-    uint16_t len;
-} ReaderAnalyzerHeader;
-
-typedef enum {
-    ReaderAnalyzerNfcDataMfClassic,
-} ReaderAnalyzerNfcData;
-
-struct ReaderAnalyzer {
-    bool alive;
-    FuriStreamBuffer* stream;
-    FuriThread* thread;
-
-    ReaderAnalyzerParseDataCallback callback;
-    void* context;
-
-    ReaderAnalyzerMode mode;
-    NfcDebugLog* debug_log;
-    NfcDebugPcap* pcap;
-};
-
-void reader_analyzer_parse(ReaderAnalyzer* instance, uint8_t* buffer, size_t size) {
-    if(size < sizeof(ReaderAnalyzerHeader)) return;
-
-    size_t bytes_i = 0;
-    while(bytes_i < size) {
-        ReaderAnalyzerHeader* header = (ReaderAnalyzerHeader*)&buffer[bytes_i];
-        uint16_t len = header->len;
-        if(bytes_i + len > size) break;
-        bytes_i += sizeof(ReaderAnalyzerHeader);
-        if(instance->pcap) {
-            nfc_debug_pcap_process_data(
-                instance->pcap, &buffer[bytes_i], len, header->reader_to_tag, header->crc_dropped);
-        }
-        if(instance->debug_log) {
-            nfc_debug_log_process_data(
-                instance->debug_log,
-                &buffer[bytes_i],
-                len,
-                header->reader_to_tag,
-                header->crc_dropped);
-        }
-        bytes_i += len;
-    }
-}
-
-int32_t reader_analyzer_thread(void* context) {
-    ReaderAnalyzer* reader_analyzer = context;
-    uint8_t buffer[READER_ANALYZER_MAX_BUFF_SIZE] = {};
-
-    while(reader_analyzer->alive || !furi_stream_buffer_is_empty(reader_analyzer->stream)) {
-        size_t ret = furi_stream_buffer_receive(
-            reader_analyzer->stream, buffer, READER_ANALYZER_MAX_BUFF_SIZE, 50);
-        if(ret) {
-            reader_analyzer_parse(reader_analyzer, buffer, ret);
-        }
-    }
-
-    return 0;
-}
-
-ReaderAnalyzer* reader_analyzer_alloc() {
-    ReaderAnalyzer* instance = malloc(sizeof(ReaderAnalyzer));
-
-    instance->alive = false;
-    instance->stream =
-        furi_stream_buffer_alloc(READER_ANALYZER_MAX_BUFF_SIZE, sizeof(ReaderAnalyzerHeader));
-
-    instance->thread =
-        furi_thread_alloc_ex("ReaderAnalyzerWorker", 2048, reader_analyzer_thread, instance);
-    furi_thread_set_priority(instance->thread, FuriThreadPriorityLow);
-
-    return instance;
-}
-
-void reader_analyzer_start(ReaderAnalyzer* instance, ReaderAnalyzerMode mode) {
-    furi_assert(instance);
-
-    furi_stream_buffer_reset(instance->stream);
-    if(mode & ReaderAnalyzerModeDebugLog) {
-        instance->debug_log = nfc_debug_log_alloc();
-    }
-    if(mode & ReaderAnalyzerModeDebugPcap) {
-        instance->pcap = nfc_debug_pcap_alloc();
-    }
-
-    instance->alive = true;
-    furi_thread_start(instance->thread);
-}
-
-void reader_analyzer_stop(ReaderAnalyzer* instance) {
-    furi_assert(instance);
-
-    instance->alive = false;
-    furi_thread_join(instance->thread);
-
-    if(instance->debug_log) {
-        nfc_debug_log_free(instance->debug_log);
-        instance->debug_log = NULL;
-    }
-    if(instance->pcap) {
-        nfc_debug_pcap_free(instance->pcap);
-        instance->pcap = NULL;
-    }
-}
-
-void reader_analyzer_free(ReaderAnalyzer* instance) {
-    furi_assert(instance);
-
-    reader_analyzer_stop(instance);
-    furi_thread_free(instance->thread);
-    furi_stream_buffer_free(instance->stream);
-    free(instance);
-}
-
-void reader_analyzer_set_callback(
-    ReaderAnalyzer* instance,
-    ReaderAnalyzerParseDataCallback callback,
-    void* context) {
-    furi_assert(instance);
-    furi_assert(callback);
-
-    instance->callback = callback;
-    instance->context = context;
-}
-
-static void reader_analyzer_write(
-    ReaderAnalyzer* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped) {
-    ReaderAnalyzerHeader header = {
-        .reader_to_tag = reader_to_tag, .crc_dropped = crc_dropped, .len = len};
-    size_t data_sent = 0;
-    data_sent = furi_stream_buffer_send(
-        instance->stream, &header, sizeof(ReaderAnalyzerHeader), FuriWaitForever);
-    if(data_sent != sizeof(ReaderAnalyzerHeader)) {
-        FURI_LOG_W(TAG, "Sent %zu out of %zu bytes", data_sent, sizeof(ReaderAnalyzerHeader));
-    }
-    data_sent = furi_stream_buffer_send(instance->stream, data, len, FuriWaitForever);
-    if(data_sent != len) {
-        FURI_LOG_W(TAG, "Sent %zu out of %u bytes", data_sent, len);
-    }
-}
-
-static void
-    reader_analyzer_write_rx(uint8_t* data, uint16_t bits, bool crc_dropped, void* context) {
-    UNUSED(crc_dropped);
-    ReaderAnalyzer* reader_analyzer = context;
-    uint16_t bytes = bits < 8 ? 1 : bits / 8;
-    reader_analyzer_write(reader_analyzer, data, bytes, false, crc_dropped);
-}
-
-static void
-    reader_analyzer_write_tx(uint8_t* data, uint16_t bits, bool crc_dropped, void* context) {
-    UNUSED(crc_dropped);
-    ReaderAnalyzer* reader_analyzer = context;
-    uint16_t bytes = bits < 8 ? 1 : bits / 8;
-    reader_analyzer_write(reader_analyzer, data, bytes, true, crc_dropped);
-}
-
-void reader_analyzer_prepare_tx_rx(
-    ReaderAnalyzer* instance,
-    FuriHalNfcTxRxContext* tx_rx,
-    bool is_picc) {
-    furi_assert(instance);
-    furi_assert(tx_rx);
-
-    if(is_picc) {
-        tx_rx->sniff_tx = reader_analyzer_write_rx;
-        tx_rx->sniff_rx = reader_analyzer_write_tx;
-    } else {
-        tx_rx->sniff_rx = reader_analyzer_write_rx;
-        tx_rx->sniff_tx = reader_analyzer_write_tx;
-    }
-
-    tx_rx->sniff_context = instance;
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/helpers/reader_analyzer.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <lib/nfc/nfc_device.h>
-
-typedef enum {
-    ReaderAnalyzerModeDebugLog = 0x01,
-    ReaderAnalyzerModeDebugPcap = 0x04,
-} ReaderAnalyzerMode;
-
-typedef enum {
-    ReaderAnalyzerEventMfkeyCollected,
-} ReaderAnalyzerEvent;
-
-typedef struct ReaderAnalyzer ReaderAnalyzer;
-
-typedef void (*ReaderAnalyzerParseDataCallback)(ReaderAnalyzerEvent event, void* context);
-
-ReaderAnalyzer* reader_analyzer_alloc();
-
-void reader_analyzer_free(ReaderAnalyzer* instance);
-
-void reader_analyzer_set_callback(
-    ReaderAnalyzer* instance,
-    ReaderAnalyzerParseDataCallback callback,
-    void* context);
-
-void reader_analyzer_start(ReaderAnalyzer* instance, ReaderAnalyzerMode mode);
-
-void reader_analyzer_stop(ReaderAnalyzer* instance);
-
-void reader_analyzer_prepare_tx_rx(
-    ReaderAnalyzer* instance,
-    FuriHalNfcTxRxContext* tx_rx,
-    bool is_picc);

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/nfc_types.c

@@ -1,49 +0,0 @@
-#include "nfc_types.h"
-
-const char* nfc_get_dev_type(FuriHalNfcType type) {
-    if(type == FuriHalNfcTypeA) {
-        return "NFC-A";
-    } else if(type == FuriHalNfcTypeB) {
-        return "NFC-B";
-    } else if(type == FuriHalNfcTypeF) {
-        return "NFC-F";
-    } else if(type == FuriHalNfcTypeV) {
-        return "NFC-V";
-    } else {
-        return "Unknown";
-    }
-}
-
-const char* nfc_guess_protocol(NfcProtocol protocol) {
-    if(protocol == NfcDeviceProtocolMifareUl) {
-        return "Mifare Ultral/NTAG";
-    } else {
-        return "Unrecognized";
-    }
-}
-
-const char* nfc_mf_ul_type(MfUltralightType type, bool full_name) {
-    if(type == MfUltralightTypeNTAG213) {
-        return "NTAG213";
-    } else if(type == MfUltralightTypeNTAG215) {
-        return "NTAG215";
-    } else if(type == MfUltralightTypeNTAG216) {
-        return "NTAG216";
-    } else if(type == MfUltralightTypeNTAGI2C1K) {
-        return "NTAG I2C 1K";
-    } else if(type == MfUltralightTypeNTAGI2C2K) {
-        return "NTAG I2C 2K";
-    } else if(type == MfUltralightTypeNTAGI2CPlus1K) {
-        return "NTAG I2C Plus 1K";
-    } else if(type == MfUltralightTypeNTAGI2CPlus2K) {
-        return "NTAG I2C Plus 2K";
-    } else if(type == MfUltralightTypeNTAG203) {
-        return "NTAG203";
-    } else if(type == MfUltralightTypeUL11 && full_name) {
-        return "Mifare Ultralight 11";
-    } else if(type == MfUltralightTypeUL21 && full_name) {
-        return "Mifare Ultralight 21";
-    } else {
-        return "Mifare Ultralight";
-    }
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/nfc_types.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include "nfc_device.h"
-
-const char* nfc_get_dev_type(FuriHalNfcType type);
-
-const char* nfc_guess_protocol(NfcProtocol protocol);
-
-const char* nfc_mf_ul_type(MfUltralightType type, bool full_name);

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/nfc_worker.c

@@ -1,385 +0,0 @@
-#include "nfc_worker_i.h"
-#include <furi_hal.h>
-
-#include <platform.h>
-
-#define TAG "NfcWorker"
-
-/***************************** NFC Worker API *******************************/
-
-NfcWorker* nfc_worker_alloc() {
-    NfcWorker* nfc_worker = malloc(sizeof(NfcWorker));
-
-    // Worker thread attributes
-    nfc_worker->thread = furi_thread_alloc_ex("NfcWorker", 8192, nfc_worker_task, nfc_worker);
-
-    nfc_worker->callback = NULL;
-    nfc_worker->context = NULL;
-    nfc_worker->storage = furi_record_open(RECORD_STORAGE);
-
-    // Initialize rfal
-    while(furi_hal_nfc_is_busy()) {
-        furi_delay_ms(10);
-    }
-    nfc_worker_change_state(nfc_worker, NfcWorkerStateReady);
-
-    nfc_worker->reader_analyzer = reader_analyzer_alloc(nfc_worker->storage);
-
-    return nfc_worker;
-}
-
-void nfc_worker_free(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-
-    furi_thread_free(nfc_worker->thread);
-
-    furi_record_close(RECORD_STORAGE);
-
-    reader_analyzer_free(nfc_worker->reader_analyzer);
-
-    free(nfc_worker);
-}
-
-NfcWorkerState nfc_worker_get_state(NfcWorker* nfc_worker) {
-    return nfc_worker->state;
-}
-
-void nfc_worker_start(
-    NfcWorker* nfc_worker,
-    NfcWorkerState state,
-    NfcDeviceData* dev_data,
-    NfcWorkerCallback callback,
-    void* context) {
-    furi_assert(nfc_worker);
-    furi_assert(dev_data);
-    while(furi_hal_nfc_is_busy()) {
-        furi_delay_ms(10);
-    }
-    // XXX: These functions are not exported, and trying to link them separately causes
-    // catastrophic issues. They weren't here before, so we'll pretend they're not
-    // necessary.
-    // furi_hal_nfc_deinit();
-    // furi_hal_nfc_init();
-
-    nfc_worker->callback = callback;
-    nfc_worker->context = context;
-    nfc_worker->dev_data = dev_data;
-    nfc_worker_change_state(nfc_worker, state);
-    furi_thread_start(nfc_worker->thread);
-}
-
-void nfc_worker_stop(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->thread);
-    if(furi_thread_get_state(nfc_worker->thread) != FuriThreadStateStopped) {
-        furi_hal_nfc_stop();
-        nfc_worker_change_state(nfc_worker, NfcWorkerStateStop);
-        furi_thread_join(nfc_worker->thread);
-    }
-}
-
-void nfc_worker_change_state(NfcWorker* nfc_worker, NfcWorkerState state) {
-    nfc_worker->state = state;
-}
-
-/***************************** NFC Worker Thread *******************************/
-
-int32_t nfc_worker_task(void* context) {
-    NfcWorker* nfc_worker = context;
-
-    furi_hal_nfc_exit_sleep();
-
-    if(nfc_worker->state == NfcWorkerStateRead) {
-        if(nfc_worker->dev_data->read_mode == NfcReadModeAuto) {
-            nfc_worker_read(nfc_worker);
-        } else {
-            nfc_worker_read_type(nfc_worker);
-        }
-    } else if(nfc_worker->state == NfcWorkerStateUidEmulate) {
-        nfc_worker_emulate_uid(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateMfUltralightEmulate) {
-        nfc_worker_emulate_mf_ultralight(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateReadMfUltralightReadAuth) {
-        nfc_worker_mf_ultralight_read_auth(nfc_worker);
-    }
-    furi_hal_nfc_sleep();
-    nfc_worker_change_state(nfc_worker, NfcWorkerStateReady);
-
-    return 0;
-}
-
-static bool nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker, FuriHalNfcTxRxContext* tx_rx) {
-    bool read_success = false;
-    MfUltralightReader reader = {};
-    MfUltralightData data = {};
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_prepare_tx_rx(nfc_worker->reader_analyzer, tx_rx, false);
-        reader_analyzer_start(nfc_worker->reader_analyzer, ReaderAnalyzerModeDebugLog);
-    }
-
-    do {
-        // Otherwise, try to read as usual
-        if(!furi_hal_nfc_detect(&nfc_worker->dev_data->nfc_data, 200)) break;
-        if(!mf_ul_read_card(tx_rx, &reader, &data)) break;
-        // Copy data
-        nfc_worker->dev_data->mf_ul_data = data;
-        read_success = true;
-    } while(false);
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_stop(nfc_worker->reader_analyzer);
-    }
-
-    return read_success;
-}
-
-static bool nfc_worker_read_nfca(NfcWorker* nfc_worker, FuriHalNfcTxRxContext* tx_rx) {
-    FuriHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-
-    bool card_read = false;
-    furi_hal_nfc_sleep();
-    if(mf_ul_check_card_type(nfc_data->atqa[0], nfc_data->atqa[1], nfc_data->sak)) {
-        FURI_LOG_I(TAG, "Mifare Ultralight / NTAG detected");
-        nfc_worker->dev_data->protocol = NfcDeviceProtocolMifareUl;
-        card_read = nfc_worker_read_mf_ultralight(nfc_worker, tx_rx);
-    } else {
-        nfc_worker->dev_data->protocol = NfcDeviceProtocolUnknown;
-        card_read = true;
-    }
-
-    return card_read;
-}
-
-void nfc_worker_read(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    nfc_device_data_clear(nfc_worker->dev_data);
-    NfcDeviceData* dev_data = nfc_worker->dev_data;
-    FuriHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    FuriHalNfcTxRxContext tx_rx = {};
-    NfcWorkerEvent event = 0;
-    bool card_not_detected_notified = false;
-
-    while(nfc_worker->state == NfcWorkerStateRead) {
-        if(furi_hal_nfc_detect(nfc_data, 300)) {
-            // Process first found device
-            nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-            card_not_detected_notified = false;
-            if(nfc_data->type == FuriHalNfcTypeA) {
-                if(nfc_worker_read_nfca(nfc_worker, &tx_rx)) {
-                    if(dev_data->protocol == NfcDeviceProtocolMifareUl) {
-                        event = NfcWorkerEventReadMfUltralight;
-                        break;
-                    } else if(dev_data->protocol == NfcDeviceProtocolUnknown) {
-                        event = NfcWorkerEventReadUidNfcA;
-                        break;
-                    }
-                }
-            } else if(nfc_data->type == FuriHalNfcTypeB) {
-                event = NfcWorkerEventReadUidNfcB;
-                break;
-            } else if(nfc_data->type == FuriHalNfcTypeF) {
-                event = NfcWorkerEventReadUidNfcF;
-                break;
-            } else if(nfc_data->type == FuriHalNfcTypeV) {
-                event = NfcWorkerEventReadUidNfcV;
-                break;
-            }
-        } else {
-            if(!card_not_detected_notified) {
-                nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                card_not_detected_notified = true;
-            }
-        }
-        furi_hal_nfc_sleep();
-        furi_delay_ms(100);
-    }
-    // Notify caller and exit
-    if(event > NfcWorkerEventReserved) {
-        nfc_worker->callback(event, nfc_worker->context);
-    }
-}
-
-void nfc_worker_read_type(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    NfcReadMode read_mode = nfc_worker->dev_data->read_mode;
-    nfc_device_data_clear(nfc_worker->dev_data);
-    FuriHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    FuriHalNfcTxRxContext tx_rx = {};
-    NfcWorkerEvent event = 0;
-    bool card_not_detected_notified = false;
-
-    while(nfc_worker->state == NfcWorkerStateRead) {
-        if(furi_hal_nfc_detect(nfc_data, 300)) {
-            FURI_LOG_D(TAG, "Card detected");
-            furi_hal_nfc_sleep();
-            // Process first found device
-            nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-            card_not_detected_notified = false;
-            if(nfc_data->type == FuriHalNfcTypeA) {
-                if(read_mode == NfcReadModeMfUltralight) {
-                    FURI_LOG_I(TAG, "Mifare Ultralight / NTAG");
-                    nfc_worker->dev_data->protocol = NfcDeviceProtocolMifareUl;
-                    if(nfc_worker_read_mf_ultralight(nfc_worker, &tx_rx)) {
-                        event = NfcWorkerEventReadMfUltralight;
-                        break;
-                    }
-                } else if(read_mode == NfcReadModeNFCA) {
-                    nfc_worker->dev_data->protocol = NfcDeviceProtocolUnknown;
-                    event = NfcWorkerEventReadUidNfcA;
-                    break;
-                }
-            }
-        } else {
-            if(!card_not_detected_notified) {
-                nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                card_not_detected_notified = true;
-            }
-        }
-        furi_hal_nfc_sleep();
-        furi_delay_ms(100);
-    }
-    // Notify caller and exit
-    if(event > NfcWorkerEventReserved) {
-        nfc_worker->callback(event, nfc_worker->context);
-    }
-}
-
-void nfc_worker_emulate_uid(NfcWorker* nfc_worker) {
-    FuriHalNfcTxRxContext tx_rx = {};
-    FuriHalNfcDevData* data = &nfc_worker->dev_data->nfc_data;
-    NfcReaderRequestData* reader_data = &nfc_worker->dev_data->reader_data;
-
-    // TODO add support for RATS
-    // Need to save ATS to support ISO-14443A-4 emulation
-
-    while(nfc_worker->state == NfcWorkerStateUidEmulate) {
-        if(furi_hal_nfc_listen(data->uid, data->uid_len, data->atqa, data->sak, false, 100)) {
-            if(furi_hal_nfc_tx_rx(&tx_rx, 100)) {
-                reader_data->size = tx_rx.rx_bits / 8;
-                if(reader_data->size > 0) {
-                    memcpy(reader_data->data, tx_rx.rx_data, reader_data->size);
-                    if(nfc_worker->callback) {
-                        nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-                    }
-                }
-            } else {
-                FURI_LOG_E(TAG, "Failed to get reader commands");
-            }
-        }
-    }
-}
-
-void nfc_worker_mf_ultralight_auth_received_callback(MfUltralightAuth auth, void* context) {
-    furi_assert(context);
-
-    NfcWorker* nfc_worker = context;
-    nfc_worker->dev_data->mf_ul_auth = auth;
-    if(nfc_worker->callback) {
-        nfc_worker->callback(NfcWorkerEventMfUltralightPwdAuth, nfc_worker->context);
-    }
-}
-
-void nfc_worker_emulate_mf_ultralight(NfcWorker* nfc_worker) {
-    FuriHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    MfUltralightEmulator emulator = {};
-    mf_ul_prepare_emulation(&emulator, &nfc_worker->dev_data->mf_ul_data);
-
-    // TODO rework with reader analyzer
-    emulator.auth_received_callback = nfc_worker_mf_ultralight_auth_received_callback;
-    emulator.context = nfc_worker;
-
-    while(nfc_worker->state == NfcWorkerStateMfUltralightEmulate) {
-        mf_ul_reset_emulation(&emulator, true);
-        furi_hal_nfc_emulate_nfca(
-            nfc_data->uid,
-            nfc_data->uid_len,
-            nfc_data->atqa,
-            nfc_data->sak,
-            mf_ul_prepare_emulation_response,
-            &emulator,
-            5000);
-        // Check if data was modified
-        if(emulator.data_changed) {
-            nfc_worker->dev_data->mf_ul_data = emulator.data;
-            if(nfc_worker->callback) {
-                nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-            }
-            emulator.data_changed = false;
-        }
-    }
-}
-
-void nfc_worker_mf_ultralight_read_auth(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    MfUltralightData* data = &nfc_worker->dev_data->mf_ul_data;
-    FuriHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    FuriHalNfcTxRxContext tx_rx = {};
-    MfUltralightReader reader = {};
-    mf_ul_reset(data);
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_prepare_tx_rx(nfc_worker->reader_analyzer, &tx_rx, true);
-        reader_analyzer_start(nfc_worker->reader_analyzer, ReaderAnalyzerModeDebugLog);
-    }
-
-    uint32_t key = 0;
-    uint16_t pack = 0;
-    while(nfc_worker->state == NfcWorkerStateReadMfUltralightReadAuth) {
-        furi_hal_nfc_sleep();
-        if(furi_hal_nfc_detect(nfc_data, 300) && nfc_data->type == FuriHalNfcTypeA) {
-            if(mf_ul_check_card_type(nfc_data->atqa[0], nfc_data->atqa[1], nfc_data->sak)) {
-                nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-                if(data->auth_method == MfUltralightAuthMethodManual ||
-                   data->auth_method == MfUltralightAuthMethodAuto) {
-                    nfc_worker->callback(NfcWorkerEventMfUltralightPassKey, nfc_worker->context);
-                    key = nfc_util_bytes2num(data->auth_key, 4);
-                } else {
-                    FURI_LOG_E(TAG, "Incorrect auth method");
-                    break;
-                }
-
-                data->auth_success = mf_ultralight_authenticate(&tx_rx, key, &pack);
-
-                if(!data->auth_success) {
-                    // Reset card
-                    furi_hal_nfc_sleep();
-                    if(!furi_hal_nfc_activate_nfca(300, NULL)) {
-                        nfc_worker->callback(NfcWorkerEventFail, nfc_worker->context);
-                        break;
-                    }
-                }
-
-                mf_ul_read_card(&tx_rx, &reader, data);
-                if(data->auth_success) {
-                    MfUltralightConfigPages* config_pages = mf_ultralight_get_config_pages(data);
-                    if(config_pages != NULL) {
-                        config_pages->auth_data.pwd.value = REVERSE_BYTES_U32(key);
-                        config_pages->auth_data.pack.value = pack;
-                    }
-                    nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-                    break;
-                } else {
-                    nfc_worker->callback(NfcWorkerEventFail, nfc_worker->context);
-                    break;
-                }
-            } else {
-                nfc_worker->callback(NfcWorkerEventWrongCardDetected, nfc_worker->context);
-                furi_delay_ms(10);
-            }
-        } else {
-            nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-            furi_delay_ms(10);
-        }
-    }
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_stop(nfc_worker->reader_analyzer);
-    }
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/nfc_worker.h

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <lib/nfc/nfc_device.h>
-
-typedef struct NfcWorker NfcWorker;
-
-typedef enum {
-    // Init states
-    NfcWorkerStateNone,
-    NfcWorkerStateReady,
-    // Main worker states
-    NfcWorkerStateRead,
-    NfcWorkerStateUidEmulate,
-    NfcWorkerStateMfUltralightEmulate,
-    NfcWorkerStateReadMfUltralightReadAuth,
-    // Debug
-    NfcWorkerStateField,
-    // Transition
-    NfcWorkerStateStop,
-} NfcWorkerState;
-
-typedef enum {
-    // Reserve first 50 events for application events
-    NfcWorkerEventReserved = 50,
-
-    // Nfc read events
-    NfcWorkerEventReadUidNfcB,
-    NfcWorkerEventReadUidNfcV,
-    NfcWorkerEventReadUidNfcF,
-    NfcWorkerEventReadUidNfcA,
-    NfcWorkerEventReadMfUltralight,
-
-    // Nfc worker common events
-    NfcWorkerEventSuccess,
-    NfcWorkerEventFail,
-    NfcWorkerEventAborted,
-    NfcWorkerEventCardDetected,
-    NfcWorkerEventNoCardDetected,
-    NfcWorkerEventWrongCardDetected,
-
-    // Write Mifare Classic events
-    NfcWorkerEventWrongCard,
-
-    // Mifare Ultralight events
-    NfcWorkerEventMfUltralightPassKey, // NFC worker requesting manual key
-    NfcWorkerEventMfUltralightPwdAuth, // Reader sent auth command
-} NfcWorkerEvent;
-
-typedef bool (*NfcWorkerCallback)(NfcWorkerEvent event, void* context);
-
-NfcWorker* nfc_worker_alloc();
-
-NfcWorkerState nfc_worker_get_state(NfcWorker* nfc_worker);
-
-void nfc_worker_free(NfcWorker* nfc_worker);
-
-void nfc_worker_start(
-    NfcWorker* nfc_worker,
-    NfcWorkerState state,
-    NfcDeviceData* dev_data,
-    NfcWorkerCallback callback,
-    void* context);
-
-void nfc_worker_stop(NfcWorker* nfc_worker);

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/nfc_worker_i.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include "nfc_worker.h"
-
-#include <furi.h>
-#include <lib/toolbox/stream/file_stream.h>
-
-#include "protocols/nfc_util.h"
-#include "protocols/mifare_common.h"
-#include "protocols/nfca.h"
-#include "helpers/reader_analyzer.h"
-
-struct NfcWorker {
-    FuriThread* thread;
-    Storage* storage;
-    Stream* dict_stream;
-
-    NfcDeviceData* dev_data;
-
-    NfcWorkerCallback callback;
-    void* context;
-
-    NfcWorkerState state;
-
-    ReaderAnalyzer* reader_analyzer;
-};
-
-void nfc_worker_change_state(NfcWorker* nfc_worker, NfcWorkerState state);
-
-int32_t nfc_worker_task(void* context);
-
-void nfc_worker_read(NfcWorker* nfc_worker);
-
-void nfc_worker_read_type(NfcWorker* nfc_worker);
-
-void nfc_worker_emulate_uid(NfcWorker* nfc_worker);
-
-void nfc_worker_emulate_mf_ultralight(NfcWorker* nfc_worker);
-
-void nfc_worker_mf_ultralight_read_auth(NfcWorker* nfc_worker);
-
-void nfc_worker_mf_ul_auth_attack(NfcWorker* nfc_worker);

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/protocols/mifare_common.c

@@ -1,11 +0,0 @@
-#include "mifare_common.h"
-
-MifareType mifare_common_get_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    MifareType type = MifareTypeUnknown;
-
-    if((ATQA0 == 0x44) && (ATQA1 == 0x00) && (SAK == 0x00)) {
-        type = MifareTypeUltralight;
-    }
-
-    return type;
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/protocols/mifare_common.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-typedef enum {
-    MifareTypeUnknown,
-    MifareTypeUltralight,
-} MifareType;
-
-MifareType mifare_common_get_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK);

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/protocols/mifare_ultralight.c

@@ -1,1889 +0,0 @@
-#include <limits.h>
-#include <lib/nfc/protocols/mifare_ultralight.h>
-#include <lib/nfc/protocols/nfc_util.h>
-#include <furi.h>
-#include <furi_hal_nfc.h>
-
-#define TAG "MfUltralight"
-
-bool mf_ul_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    if((ATQA0 == 0x44) && (ATQA1 == 0x00) && (SAK == 0x00)) {
-        return true;
-    }
-    return false;
-}
-
-void mf_ul_reset(MfUltralightData* data) {
-    furi_assert(data);
-    data->type = MfUltralightTypeUnknown;
-    memset(&data->version, 0, sizeof(MfUltralightVersion));
-    memset(data->signature, 0, sizeof(data->signature));
-    memset(data->counter, 0, sizeof(data->counter));
-    memset(data->tearing, 0, sizeof(data->tearing));
-    memset(data->data, 0, sizeof(data->data));
-    data->data_size = 0;
-    data->data_read = 0;
-    data->curr_authlim = 0;
-    data->auth_success = false;
-}
-
-static MfUltralightFeatures mf_ul_get_features(MfUltralightType type) {
-    switch(type) {
-    case MfUltralightTypeUL11:
-    case MfUltralightTypeUL21:
-        return MfUltralightSupportFastRead | MfUltralightSupportCompatWrite |
-               MfUltralightSupportReadCounter | MfUltralightSupportIncrCounter |
-               MfUltralightSupportAuth | MfUltralightSupportSignature |
-               MfUltralightSupportTearingFlags | MfUltralightSupportVcsl;
-    case MfUltralightTypeNTAG213:
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-        return MfUltralightSupportFastRead | MfUltralightSupportCompatWrite |
-               MfUltralightSupportReadCounter | MfUltralightSupportAuth |
-               MfUltralightSupportSignature | MfUltralightSupportSingleCounter |
-               MfUltralightSupportAsciiMirror;
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2C2K:
-        return MfUltralightSupportFastRead | MfUltralightSupportSectorSelect;
-    case MfUltralightTypeNTAGI2CPlus1K:
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return MfUltralightSupportFastRead | MfUltralightSupportAuth |
-               MfUltralightSupportFastWrite | MfUltralightSupportSignature |
-               MfUltralightSupportSectorSelect;
-    case MfUltralightTypeNTAG203:
-        return MfUltralightSupportCompatWrite | MfUltralightSupportCounterInMemory;
-    default:
-        // Assumed original MFUL 512-bit
-        return MfUltralightSupportCompatWrite;
-    }
-}
-
-static void mf_ul_set_default_version(MfUltralightReader* reader, MfUltralightData* data) {
-    data->type = MfUltralightTypeUnknown;
-    reader->pages_to_read = 16;
-}
-
-static void mf_ul_set_version_ntag203(MfUltralightReader* reader, MfUltralightData* data) {
-    data->type = MfUltralightTypeNTAG203;
-    reader->pages_to_read = 42;
-}
-
-bool mf_ultralight_read_version(
-    FuriHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    bool version_read = false;
-
-    do {
-        FURI_LOG_D(TAG, "Reading version");
-        tx_rx->tx_data[0] = MF_UL_GET_VERSION_CMD;
-        tx_rx->tx_bits = 8;
-        tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-        if(!furi_hal_nfc_tx_rx(tx_rx, 50) || tx_rx->rx_bits != 64) {
-            FURI_LOG_D(TAG, "Failed reading version");
-            mf_ul_set_default_version(reader, data);
-            furi_hal_nfc_sleep();
-            furi_hal_nfc_activate_nfca(300, NULL);
-            break;
-        }
-        MfUltralightVersion* version = (MfUltralightVersion*)tx_rx->rx_data;
-        data->version = *version;
-        if(version->storage_size == 0x0B || version->storage_size == 0x00) {
-            data->type = MfUltralightTypeUL11;
-            reader->pages_to_read = 20;
-        } else if(version->storage_size == 0x0E) {
-            data->type = MfUltralightTypeUL21;
-            reader->pages_to_read = 41;
-        } else if(version->storage_size == 0x0F) {
-            data->type = MfUltralightTypeNTAG213;
-            reader->pages_to_read = 45;
-        } else if(version->storage_size == 0x11) {
-            data->type = MfUltralightTypeNTAG215;
-            reader->pages_to_read = 135;
-        } else if(version->prod_subtype == 5 && version->prod_ver_major == 2) {
-            // NTAG I2C
-            bool known = false;
-            if(version->prod_ver_minor == 1) {
-                if(version->storage_size == 0x13) {
-                    data->type = MfUltralightTypeNTAGI2C1K;
-                    reader->pages_to_read = 231;
-                    known = true;
-                } else if(version->storage_size == 0x15) {
-                    data->type = MfUltralightTypeNTAGI2C2K;
-                    reader->pages_to_read = 485;
-                    known = true;
-                }
-            } else if(version->prod_ver_minor == 2) {
-                if(version->storage_size == 0x13) {
-                    data->type = MfUltralightTypeNTAGI2CPlus1K;
-                    reader->pages_to_read = 236;
-                    known = true;
-                } else if(version->storage_size == 0x15) {
-                    data->type = MfUltralightTypeNTAGI2CPlus2K;
-                    reader->pages_to_read = 492;
-                    known = true;
-                }
-            }
-
-            if(!known) {
-                mf_ul_set_default_version(reader, data);
-            }
-        } else if(version->storage_size == 0x13) {
-            data->type = MfUltralightTypeNTAG216;
-            reader->pages_to_read = 231;
-        } else {
-            mf_ul_set_default_version(reader, data);
-            break;
-        }
-        version_read = true;
-    } while(false);
-
-    reader->supported_features = mf_ul_get_features(data->type);
-    return version_read;
-}
-
-bool mf_ultralight_authenticate(FuriHalNfcTxRxContext* tx_rx, uint32_t key, uint16_t* pack) {
-    furi_assert(pack);
-    bool authenticated = false;
-
-    do {
-        FURI_LOG_D(TAG, "Authenticating");
-        tx_rx->tx_data[0] = MF_UL_PWD_AUTH;
-        nfc_util_num2bytes(key, 4, &tx_rx->tx_data[1]);
-        tx_rx->tx_bits = 40;
-        tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-        if(!furi_hal_nfc_tx_rx(tx_rx, 50)) {
-            FURI_LOG_D(TAG, "Tag did not respond to authentication");
-            break;
-        }
-
-        // PACK
-        if(tx_rx->rx_bits < 2 * 8) {
-            FURI_LOG_D(TAG, "Authentication failed");
-            break;
-        }
-
-        *pack = (tx_rx->rx_data[1] << 8) | tx_rx->rx_data[0];
-
-        FURI_LOG_I(TAG, "Auth success. Password: %08lX. PACK: %04X", key, *pack);
-        authenticated = true;
-    } while(false);
-
-    return authenticated;
-}
-
-static int16_t mf_ultralight_page_addr_to_tag_addr(uint8_t sector, uint8_t page) {
-    return sector * 256 + page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_1k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 226: sector 0
-    // 227 - 228: config registers
-    // 229 - 230: session registers
-
-    if(linear_address > 230) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 229) {
-        *sector = 3;
-        *valid_pages = 2 - (linear_address - 229);
-        return linear_address - 229 + 248;
-    } else if(linear_address >= 227) {
-        *sector = 0;
-        *valid_pages = 2 - (linear_address - 227);
-        return linear_address - 227 + 232;
-    } else {
-        *sector = 0;
-        *valid_pages = 227 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_2k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 255: sector 0
-    // 256 - 480: sector 1
-    // 481 - 482: config registers
-    // 483 - 484: session registers
-
-    if(linear_address > 484) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 483) {
-        *sector = 3;
-        *valid_pages = 2 - (linear_address - 483);
-        return linear_address - 483 + 248;
-    } else if(linear_address >= 481) {
-        *sector = 1;
-        *valid_pages = 2 - (linear_address - 481);
-        return linear_address - 481 + 232;
-    } else if(linear_address >= 256) {
-        *sector = 1;
-        *valid_pages = 225 - (linear_address - 256);
-        return linear_address - 256;
-    } else {
-        *sector = 0;
-        *valid_pages = 256 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_1k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 233: sector 0 + registers
-    // 234 - 235: session registers
-
-    if(linear_address > 235) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 234) {
-        *sector = 0;
-        *valid_pages = 2 - (linear_address - 234);
-        return linear_address - 234 + 236;
-    } else {
-        *sector = 0;
-        *valid_pages = 234 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_2k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 233: sector 0 + registers
-    // 234 - 235: session registers
-    // 236 - 491: sector 1
-
-    if(linear_address > 491) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 236) {
-        *sector = 1;
-        *valid_pages = 256 - (linear_address - 236);
-        return linear_address - 236;
-    } else if(linear_address >= 234) {
-        *sector = 0;
-        *valid_pages = 2 - (linear_address - 234);
-        return linear_address - 234 + 236;
-    } else {
-        *sector = 0;
-        *valid_pages = 234 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag(
-    MfUltralightData* data,
-    MfUltralightReader* reader,
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    switch(data->type) {
-    case MfUltralightTypeNTAGI2C1K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_1k(linear_address, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2C2K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_2k(linear_address, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus1K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_1k(linear_address, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_2k(linear_address, sector, valid_pages);
-
-    default:
-        *sector = 0xff;
-        *valid_pages = reader->pages_to_read - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t
-    mf_ultralight_ntag_i2c_addr_tag_to_lin_1k(uint8_t page, uint8_t sector, uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        if(page <= 226) {
-            *valid_pages = 227 - page;
-            translated_page = page;
-            valid = true;
-        } else if(page >= 232 && page <= 233) {
-            *valid_pages = 2 - (page - 232);
-            translated_page = page - 232 + 227;
-            valid = true;
-        }
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 229;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t
-    mf_ultralight_ntag_i2c_addr_tag_to_lin_2k(uint8_t page, uint8_t sector, uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        *valid_pages = 256 - page;
-        translated_page = page;
-        valid = true;
-    } else if(sector == 1) {
-        if(page <= 224) {
-            *valid_pages = 225 - page;
-            translated_page = 256 + page;
-            valid = true;
-        } else if(page >= 232 && page <= 233) {
-            *valid_pages = 2 - (page - 232);
-            translated_page = page - 232 + 481;
-            valid = true;
-        }
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 483;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_1k(
-    uint8_t page,
-    uint8_t sector,
-    uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        if(page <= 233) {
-            *valid_pages = 234 - page;
-            translated_page = page;
-            valid = true;
-        } else if(page >= 236 && page <= 237) {
-            *valid_pages = 2 - (page - 236);
-            translated_page = page - 236 + 234;
-            valid = true;
-        }
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 234;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_2k(
-    uint8_t page,
-    uint8_t sector,
-    uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        if(page <= 233) {
-            *valid_pages = 234 - page;
-            translated_page = page;
-            valid = true;
-        } else if(page >= 236 && page <= 237) {
-            *valid_pages = 2 - (page - 236);
-            translated_page = page - 236 + 234;
-            valid = true;
-        }
-    } else if(sector == 1) {
-        *valid_pages = 256 - page;
-        translated_page = page + 236;
-        valid = true;
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 234;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_tag_to_lin(
-    MfUltralightData* data,
-    uint8_t page,
-    uint8_t sector,
-    uint16_t* valid_pages) {
-    switch(data->type) {
-    case MfUltralightTypeNTAGI2C1K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_1k(page, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2C2K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_2k(page, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus1K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_1k(page, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_2k(page, sector, valid_pages);
-
-    default:
-        *valid_pages = data->data_size / 4 - page;
-        return page;
-    }
-}
-
-MfUltralightConfigPages* mf_ultralight_get_config_pages(MfUltralightData* data) {
-    if(data->type >= MfUltralightTypeUL11 && data->type <= MfUltralightTypeNTAG216) {
-        return (MfUltralightConfigPages*)&data->data[data->data_size - 4 * 4];
-    } else if(
-        data->type >= MfUltralightTypeNTAGI2CPlus1K &&
-        data->type <= MfUltralightTypeNTAGI2CPlus2K) {
-        return (MfUltralightConfigPages*)&data->data[0xe3 * 4]; //-V641
-    } else {
-        return NULL;
-    }
-}
-
-static uint16_t mf_ultralight_calc_auth_count(MfUltralightData* data) {
-    if(mf_ul_get_features(data->type) & MfUltralightSupportAuth) {
-        MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-        uint16_t scaled_authlim = config->access.authlim;
-        // NTAG I2C Plus uses 2^AUTHLIM attempts rather than the direct number
-        if(scaled_authlim > 0 && data->type >= MfUltralightTypeNTAGI2CPlus1K &&
-           data->type <= MfUltralightTypeNTAGI2CPlus2K) {
-            scaled_authlim = 1 << scaled_authlim;
-        }
-        return scaled_authlim;
-    }
-
-    return 0;
-}
-
-// NTAG21x will NAK if NFC_CNT_EN unset, so preempt
-static bool mf_ultralight_should_read_counters(MfUltralightData* data) {
-    if(data->type < MfUltralightTypeNTAG213 || data->type > MfUltralightTypeNTAG216) return true;
-
-    MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-    return config->access.nfc_cnt_en;
-}
-
-static bool mf_ultralight_sector_select(FuriHalNfcTxRxContext* tx_rx, uint8_t sector) {
-    FURI_LOG_D(TAG, "Selecting sector %u", sector);
-    tx_rx->tx_data[0] = MF_UL_SECTOR_SELECT;
-    tx_rx->tx_data[1] = 0xff;
-    tx_rx->tx_bits = 16;
-    tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-    if(!furi_hal_nfc_tx_rx(tx_rx, 50)) {
-        FURI_LOG_D(TAG, "Failed to issue sector select command");
-        return false;
-    }
-
-    tx_rx->tx_data[0] = sector;
-    tx_rx->tx_data[1] = 0x00;
-    tx_rx->tx_data[2] = 0x00;
-    tx_rx->tx_data[3] = 0x00;
-    tx_rx->tx_bits = 32;
-    tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-    // This is NOT a typo! The tag ACKs by not sending a response within 1ms.
-    if(furi_hal_nfc_tx_rx(tx_rx, 20)) {
-        // TODO: what gets returned when an actual NAK is received?
-        FURI_LOG_D(TAG, "Sector %u select NAK'd", sector);
-        return false;
-    }
-
-    return true;
-}
-
-bool mf_ultralight_read_pages_direct(
-    FuriHalNfcTxRxContext* tx_rx,
-    uint8_t start_index,
-    uint8_t* data) {
-    FURI_LOG_D(TAG, "Reading pages %d - %d", start_index, start_index + 3);
-    tx_rx->tx_data[0] = MF_UL_READ_CMD;
-    tx_rx->tx_data[1] = start_index;
-    tx_rx->tx_bits = 16;
-    tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-    if(!furi_hal_nfc_tx_rx(tx_rx, 50) || tx_rx->rx_bits < 16 * 8) {
-        FURI_LOG_D(TAG, "Failed to read pages %d - %d", start_index, start_index + 3);
-        return false;
-    }
-    memcpy(data, tx_rx->rx_data, 16); //-V1086
-    return true;
-}
-
-bool mf_ultralight_read_pages(
-    FuriHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    uint8_t pages_read_cnt = 0;
-    uint8_t curr_sector_index = 0xff;
-    reader->pages_read = 0;
-    for(size_t i = 0; i < reader->pages_to_read; i += pages_read_cnt) {
-        uint8_t tag_sector;
-        int16_t valid_pages;
-        int16_t tag_page = mf_ultralight_ntag_i2c_addr_lin_to_tag(
-            data, reader, (int16_t)i, &tag_sector, &valid_pages);
-
-        furi_assert(tag_page != -1);
-        if(curr_sector_index != tag_sector) {
-            if(!mf_ultralight_sector_select(tx_rx, tag_sector)) return false;
-            curr_sector_index = tag_sector;
-        }
-
-        FURI_LOG_D(
-            TAG, "Reading pages %zu - %zu", i, i + (valid_pages > 4 ? 4 : valid_pages) - 1U);
-        tx_rx->tx_data[0] = MF_UL_READ_CMD;
-        tx_rx->tx_data[1] = tag_page;
-        tx_rx->tx_bits = 16;
-        tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-
-        if(!furi_hal_nfc_tx_rx(tx_rx, 50) || tx_rx->rx_bits < 16 * 8) {
-            FURI_LOG_D(
-                TAG,
-                "Failed to read pages %zu - %zu",
-                i,
-                i + (valid_pages > 4 ? 4 : valid_pages) - 1U);
-            break;
-        }
-
-        if(valid_pages > 4) {
-            pages_read_cnt = 4;
-        } else {
-            pages_read_cnt = valid_pages;
-        }
-        reader->pages_read += pages_read_cnt;
-        memcpy(&data->data[i * 4], tx_rx->rx_data, pages_read_cnt * 4);
-    }
-    data->data_size = reader->pages_to_read * 4;
-    data->data_read = reader->pages_read * 4;
-
-    return reader->pages_read > 0;
-}
-
-bool mf_ultralight_fast_read_pages(
-    FuriHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    uint8_t curr_sector_index = 0xff;
-    reader->pages_read = 0;
-    while(reader->pages_read < reader->pages_to_read) {
-        uint8_t tag_sector;
-        int16_t valid_pages;
-        int16_t tag_page = mf_ultralight_ntag_i2c_addr_lin_to_tag(
-            data, reader, reader->pages_read, &tag_sector, &valid_pages);
-
-        furi_assert(tag_page != -1);
-        if(curr_sector_index != tag_sector) {
-            if(!mf_ultralight_sector_select(tx_rx, tag_sector)) return false;
-            curr_sector_index = tag_sector;
-        }
-
-        FURI_LOG_D(
-            TAG, "Reading pages %d - %d", reader->pages_read, reader->pages_read + valid_pages - 1);
-        tx_rx->tx_data[0] = MF_UL_FAST_READ_CMD;
-        tx_rx->tx_data[1] = tag_page;
-        tx_rx->tx_data[2] = valid_pages - 1;
-        tx_rx->tx_bits = 24;
-        tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-        if(furi_hal_nfc_tx_rx(tx_rx, 50)) {
-            memcpy(&data->data[reader->pages_read * 4], tx_rx->rx_data, valid_pages * 4);
-            reader->pages_read += valid_pages;
-            data->data_size = reader->pages_read * 4;
-        } else {
-            FURI_LOG_D(
-                TAG,
-                "Failed to read pages %d - %d",
-                reader->pages_read,
-                reader->pages_read + valid_pages - 1);
-            break;
-        }
-    }
-
-    return reader->pages_read == reader->pages_to_read;
-}
-
-bool mf_ultralight_read_signature(FuriHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
-    bool signature_read = false;
-
-    FURI_LOG_D(TAG, "Reading signature");
-    tx_rx->tx_data[0] = MF_UL_READ_SIG;
-    tx_rx->tx_data[1] = 0;
-    tx_rx->tx_bits = 16;
-    tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-    if(furi_hal_nfc_tx_rx(tx_rx, 50)) {
-        memcpy(data->signature, tx_rx->rx_data, sizeof(data->signature));
-        signature_read = true;
-    } else {
-        FURI_LOG_D(TAG, "Failed redaing signature");
-    }
-
-    return signature_read;
-}
-
-bool mf_ultralight_read_counters(FuriHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
-    uint8_t counter_read = 0;
-
-    FURI_LOG_D(TAG, "Reading counters");
-    bool is_single_counter = (mf_ul_get_features(data->type) & MfUltralightSupportSingleCounter) !=
-                             0;
-    for(size_t i = is_single_counter ? 2 : 0; i < 3; i++) {
-        tx_rx->tx_data[0] = MF_UL_READ_CNT;
-        tx_rx->tx_data[1] = i;
-        tx_rx->tx_bits = 16;
-        tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-        if(!furi_hal_nfc_tx_rx(tx_rx, 50)) {
-            FURI_LOG_D(TAG, "Failed to read %d counter", i);
-            break;
-        }
-        data->counter[i] = (tx_rx->rx_data[2] << 16) | (tx_rx->rx_data[1] << 8) |
-                           tx_rx->rx_data[0];
-        counter_read++;
-    }
-
-    return counter_read == (is_single_counter ? 1 : 3);
-}
-
-bool mf_ultralight_read_tearing_flags(FuriHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
-    uint8_t flag_read = 0;
-
-    FURI_LOG_D(TAG, "Reading tearing flags");
-    for(size_t i = 0; i < 3; i++) {
-        tx_rx->tx_data[0] = MF_UL_CHECK_TEARING;
-        tx_rx->rx_data[1] = i;
-        tx_rx->tx_bits = 16;
-        tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
-        if(!furi_hal_nfc_tx_rx(tx_rx, 50)) {
-            FURI_LOG_D(TAG, "Failed to read %d tearing flag", i);
-            break;
-        }
-        data->tearing[i] = tx_rx->rx_data[0];
-        flag_read++;
-    }
-
-    return flag_read == 2;
-}
-
-bool mf_ul_read_card(
-    FuriHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    furi_assert(tx_rx);
-    furi_assert(reader);
-    furi_assert(data);
-
-    bool card_read = false;
-
-    // Read Mifare Ultralight version
-    if(mf_ultralight_read_version(tx_rx, reader, data)) {
-        if(reader->supported_features & MfUltralightSupportSignature) {
-            // Read Signature
-            mf_ultralight_read_signature(tx_rx, data);
-        }
-    } else {
-        // No GET_VERSION command, check for NTAG203 by reading last page (41)
-        uint8_t dummy[16];
-        if(mf_ultralight_read_pages_direct(tx_rx, 41, dummy)) {
-            mf_ul_set_version_ntag203(reader, data);
-            reader->supported_features = mf_ul_get_features(data->type);
-        } else {
-            // We're really an original Mifare Ultralight, reset tag for safety
-            furi_hal_nfc_sleep();
-            furi_hal_nfc_activate_nfca(300, NULL);
-        }
-    }
-
-    card_read = mf_ultralight_read_pages(tx_rx, reader, data);
-
-    if(card_read) {
-        if(reader->supported_features & MfUltralightSupportReadCounter &&
-           mf_ultralight_should_read_counters(data)) {
-            mf_ultralight_read_counters(tx_rx, data);
-        }
-        if(reader->supported_features & MfUltralightSupportTearingFlags) {
-            mf_ultralight_read_tearing_flags(tx_rx, data);
-        }
-        data->curr_authlim = 0;
-
-        if(reader->pages_read == reader->pages_to_read &&
-           reader->supported_features & MfUltralightSupportAuth && !data->auth_success) {
-            MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-            if(config->access.authlim == 0) {
-                // Attempt to auth with default PWD
-                uint16_t pack;
-                data->auth_success = mf_ultralight_authenticate(tx_rx, MF_UL_DEFAULT_PWD, &pack);
-                if(data->auth_success) {
-                    config->auth_data.pwd.value = MF_UL_DEFAULT_PWD;
-                    config->auth_data.pack.value = pack;
-                } else {
-                    furi_hal_nfc_sleep();
-                    furi_hal_nfc_activate_nfca(300, NULL);
-                }
-            }
-        }
-    }
-
-    if(reader->pages_read != reader->pages_to_read) {
-        if(reader->supported_features & MfUltralightSupportAuth) {
-            // Probably password protected, fix AUTH0 and PROT so before AUTH0
-            // can be written and since AUTH0 won't be readable, like on the
-            // original card
-            MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-            config->auth0 = reader->pages_read;
-            config->access.prot = true;
-        }
-    }
-
-    return card_read;
-}
-
-static void mf_ul_protect_auth_data_on_read_command_i2c(
-    uint8_t* tx_buff,
-    uint8_t start_page,
-    uint8_t end_page,
-    MfUltralightEmulator* emulator) {
-    if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K) {
-        // Blank out PWD and PACK
-        if(start_page <= 229 && end_page >= 229) {
-            uint16_t offset = (229 - start_page) * 4;
-            uint8_t count = 4;
-            if(end_page >= 230) count += 2;
-            memset(&tx_buff[offset], 0, count);
-        }
-
-        // Handle AUTH0 for sector 0
-        if(!emulator->auth_success) {
-            if(emulator->config_cache.access.prot) {
-                uint8_t auth0 = emulator->config_cache.auth0;
-                if(auth0 < end_page) {
-                    // start_page is always < auth0; otherwise is NAK'd already
-                    uint8_t page_offset = auth0 - start_page;
-                    uint8_t page_count = end_page - auth0;
-                    memset(&tx_buff[page_offset * 4], 0, page_count * 4);
-                }
-            }
-        }
-    }
-}
-
-static void mf_ul_ntag_i2c_fill_cross_area_read(
-    uint8_t* tx_buff,
-    uint8_t start_page,
-    uint8_t end_page,
-    MfUltralightEmulator* emulator) {
-    // For copying config or session registers in fast read
-    int16_t tx_page_offset;
-    int16_t data_page_offset;
-    uint8_t page_length;
-    bool apply = false;
-    MfUltralightType type = emulator->data.type;
-    if(emulator->curr_sector == 0) {
-        if(type == MfUltralightTypeNTAGI2C1K) {
-            if(start_page <= 233 && end_page >= 232) {
-                tx_page_offset = start_page - 232;
-                data_page_offset = 227;
-                page_length = 2;
-                apply = true;
-            }
-        } else if(type == MfUltralightTypeNTAGI2CPlus1K || type == MfUltralightTypeNTAGI2CPlus2K) {
-            if(start_page <= 237 && end_page >= 236) {
-                tx_page_offset = start_page - 236;
-                data_page_offset = 234;
-                page_length = 2;
-                apply = true;
-            }
-        }
-    } else if(emulator->curr_sector == 1) {
-        if(type == MfUltralightTypeNTAGI2C2K) {
-            if(start_page <= 233 && end_page >= 232) {
-                tx_page_offset = start_page - 232;
-                data_page_offset = 483;
-                page_length = 2;
-                apply = true;
-            }
-        }
-    }
-
-    if(apply) {
-        while(tx_page_offset < 0 && page_length > 0) { //-V614
-            ++tx_page_offset;
-            ++data_page_offset;
-            --page_length;
-        }
-        memcpy(
-            &tx_buff[tx_page_offset * 4],
-            &emulator->data.data[data_page_offset * 4],
-            page_length * 4);
-    }
-}
-
-static bool mf_ul_check_auth(MfUltralightEmulator* emulator, uint8_t start_page, bool is_write) {
-    if(!emulator->auth_success) {
-        if(start_page >= emulator->config_cache.auth0 &&
-           (emulator->config_cache.access.prot || is_write))
-            return false;
-    }
-
-    if(is_write && emulator->config_cache.access.cfglck) {
-        uint16_t config_start_page = emulator->page_num - 4;
-        if(start_page == config_start_page || start_page == config_start_page + 1) return false;
-    }
-
-    return true;
-}
-
-static bool mf_ul_ntag_i2c_plus_check_auth(
-    MfUltralightEmulator* emulator,
-    uint8_t start_page,
-    bool is_write) {
-    if(!emulator->auth_success) {
-        // Check NFC_PROT
-        if(emulator->curr_sector == 0 && (emulator->config_cache.access.prot || is_write)) {
-            if(start_page >= emulator->config_cache.auth0) return false;
-        } else if(emulator->curr_sector == 1) {
-            // We don't have to specifically check for type because this is done
-            // by address translator
-            uint8_t pt_i2c = emulator->data.data[231 * 4];
-            // Check 2K_PROT
-            if(pt_i2c & 0x08) return false;
-        }
-    }
-
-    if(emulator->curr_sector == 1) {
-        // Check NFC_DIS_SEC1
-        if(emulator->config_cache.access.nfc_dis_sec1) return false;
-    }
-
-    return true;
-}
-
-static int16_t mf_ul_get_dynamic_lock_page_addr(MfUltralightData* data) {
-    switch(data->type) {
-    case MfUltralightTypeNTAG203:
-        return 0x28;
-    case MfUltralightTypeUL21:
-    case MfUltralightTypeNTAG213:
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-        return data->data_size / 4 - 5;
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2CPlus1K:
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return 0xe2;
-    case MfUltralightTypeNTAGI2C2K:
-        return 0x1e0;
-    default:
-        return -1; // No dynamic lock bytes
-    }
-}
-
-// Returns true if page not locked
-// write_page is tag address
-static bool mf_ul_check_lock(MfUltralightEmulator* emulator, int16_t write_page) {
-    if(write_page < 2) return false; // Page 0-1 is always locked
-    if(write_page == 2) return true; // Page 2 does not have a lock flag
-
-    // Check static lock bytes
-    if(write_page <= 15) {
-        uint16_t static_lock_bytes = emulator->data.data[10] | (emulator->data.data[11] << 8);
-        return (static_lock_bytes & (1 << write_page)) == 0;
-    }
-
-    // Check dynamic lock bytes
-
-    // Check max page
-    switch(emulator->data.type) {
-    case MfUltralightTypeNTAG203:
-        // Counter page can be locked and is after dynamic locks
-        if(write_page == 40) return true;
-        break;
-    case MfUltralightTypeUL21:
-    case MfUltralightTypeNTAG213:
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-        if(write_page >= emulator->page_num - 5) return true;
-        break;
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2CPlus1K:
-        if(write_page > 225) return true;
-        break;
-    case MfUltralightTypeNTAGI2C2K:
-        if(write_page > 479) return true;
-        break;
-    case MfUltralightTypeNTAGI2CPlus2K:
-        if(write_page >= 226 && write_page <= 255) return true;
-        if(write_page >= 512) return true;
-        break;
-    default:
-        furi_crash("Unknown MFUL");
-        return true;
-    }
-
-    int16_t dynamic_lock_index = mf_ul_get_dynamic_lock_page_addr(&emulator->data);
-    if(dynamic_lock_index == -1) return true;
-    // Run address through converter because NTAG I2C 2K is special
-    uint16_t valid_pages; // unused
-    dynamic_lock_index =
-        mf_ultralight_ntag_i2c_addr_tag_to_lin(
-            &emulator->data, dynamic_lock_index & 0xff, dynamic_lock_index >> 8, &valid_pages) *
-        4;
-
-    uint16_t dynamic_lock_bytes = emulator->data.data[dynamic_lock_index] |
-                                  (emulator->data.data[dynamic_lock_index + 1] << 8);
-    uint8_t shift;
-
-    switch(emulator->data.type) {
-    // low byte LSB range, MSB range
-    case MfUltralightTypeNTAG203:
-        if(write_page >= 16 && write_page <= 27) //-V560
-            shift = (write_page - 16) / 4 + 1;
-        else if(write_page >= 28 && write_page <= 39) //-V560
-            shift = (write_page - 28) / 4 + 5;
-        else if(write_page == 41)
-            shift = 12;
-        else {
-            furi_crash("Unknown MFUL");
-        }
-
-        break;
-    case MfUltralightTypeUL21:
-    case MfUltralightTypeNTAG213:
-        // 16-17, 30-31
-        shift = (write_page - 16) / 2;
-        break;
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2CPlus1K:
-        // 16-31, 128-129
-        // 16-31, 128-143
-        shift = (write_page - 16) / 16;
-        break;
-    case MfUltralightTypeNTAGI2C2K:
-        // 16-47, 240-271
-        shift = (write_page - 16) / 32;
-        break;
-    case MfUltralightTypeNTAGI2CPlus2K:
-        // 16-47, 256-271
-        if(write_page >= 208 && write_page <= 225)
-            shift = 6;
-        else if(write_page >= 256 && write_page <= 271)
-            shift = 7;
-        else
-            shift = (write_page - 16) / 32;
-        break;
-    default:
-        furi_crash("Unknown MFUL");
-        break;
-    }
-
-    return (dynamic_lock_bytes & (1 << shift)) == 0;
-}
-
-static void mf_ul_make_ascii_mirror(MfUltralightEmulator* emulator, FuriString* str) {
-    // Locals to improve readability
-    uint8_t mirror_page = emulator->config->mirror_page;
-    uint8_t mirror_byte = emulator->config->mirror.mirror_byte;
-    MfUltralightMirrorConf mirror_conf = emulator->config_cache.mirror.mirror_conf;
-    uint16_t last_user_page_index = emulator->page_num - 6;
-    bool uid_printed = false;
-
-    if(mirror_conf == MfUltralightMirrorUid || mirror_conf == MfUltralightMirrorUidCounter) {
-        // UID range check
-        if(mirror_page < 4 || mirror_page > last_user_page_index - 3 ||
-           (mirror_page == last_user_page_index - 3 && mirror_byte > 2)) {
-            if(mirror_conf == MfUltralightMirrorUid) return;
-            // NTAG21x has the peculiar behavior when UID+counter selected, if UID does not fit but
-            // counter will fit, it will actually mirror the counter
-            furi_string_cat(str, "              ");
-        } else {
-            for(int i = 0; i < 3; ++i) {
-                furi_string_cat_printf(str, "%02X", emulator->data.data[i]);
-            }
-            // Skip BCC0
-            for(int i = 4; i < 8; ++i) {
-                furi_string_cat_printf(str, "%02X", emulator->data.data[i]);
-            }
-            uid_printed = true;
-        }
-
-        uint16_t next_byte_offset = mirror_page * 4 + mirror_byte + 14;
-        if(mirror_conf == MfUltralightMirrorUidCounter) ++next_byte_offset;
-        mirror_page = next_byte_offset / 4;
-        mirror_byte = next_byte_offset % 4;
-    }
-
-    if(mirror_conf == MfUltralightMirrorCounter || mirror_conf == MfUltralightMirrorUidCounter) {
-        // Counter is only printed if counter enabled
-        if(emulator->config_cache.access.nfc_cnt_en) {
-            // Counter protection check
-            if(emulator->config_cache.access.nfc_cnt_pwd_prot && !emulator->auth_success) return;
-            // Counter range check
-            if(mirror_page < 4) return;
-            if(mirror_page > last_user_page_index - 1) return;
-            if(mirror_page == last_user_page_index - 1 && mirror_byte > 2) return;
-
-            if(mirror_conf == MfUltralightMirrorUidCounter)
-                furi_string_cat(str, uid_printed ? "x" : " ");
-
-            furi_string_cat_printf(str, "%06lX", emulator->data.counter[2]);
-        }
-    }
-}
-
-static void mf_ul_increment_single_counter(MfUltralightEmulator* emulator) {
-    if(!emulator->read_counter_incremented && emulator->config_cache.access.nfc_cnt_en) {
-        if(emulator->data.counter[2] < 0xFFFFFF) {
-            ++emulator->data.counter[2];
-            emulator->data_changed = true;
-        }
-        emulator->read_counter_incremented = true;
-    }
-}
-
-static bool
-    mf_ul_emulate_ntag203_counter_write(MfUltralightEmulator* emulator, uint8_t* page_buff) {
-    // We'll reuse the existing counters for other NTAGs as staging
-    // Counter 0 stores original value, data is new value
-    uint32_t counter_value;
-    if(emulator->data.tearing[0] == MF_UL_TEARING_FLAG_DEFAULT) {
-        counter_value = emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] |
-                        (emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] << 8);
-    } else {
-        // We've had a reset here, so load from original value
-        counter_value = emulator->data.counter[0];
-    }
-    // Although the datasheet says increment by 0 is always possible, this is not the case on
-    // an actual tag. If the counter is at 0xFFFF, any writes are locked out.
-    if(counter_value == 0xFFFF) return false;
-    uint32_t increment = page_buff[0] | (page_buff[1] << 8);
-    if(counter_value == 0) {
-        counter_value = increment;
-    } else {
-        // Per datasheet specifying > 0x000F is supposed to NAK, but actual tag doesn't
-        increment &= 0x000F;
-        if(counter_value + increment > 0xFFFF) return false;
-        counter_value += increment;
-    }
-    // Commit to new value counter
-    emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] = (uint8_t)counter_value;
-    emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] = (uint8_t)(counter_value >> 8);
-    emulator->data.tearing[0] = MF_UL_TEARING_FLAG_DEFAULT;
-    if(counter_value == 0xFFFF) {
-        // Tag will lock out counter if final number is 0xFFFF, even if you try to roll it back
-        emulator->data.counter[1] = 0xFFFF;
-    }
-    emulator->data_changed = true;
-    return true;
-}
-
-static void mf_ul_emulate_write(
-    MfUltralightEmulator* emulator,
-    int16_t tag_addr,
-    int16_t write_page,
-    uint8_t* page_buff) {
-    // Assumption: all access checks have been completed
-
-    if(tag_addr == 2) {
-        // Handle static locks
-        uint16_t orig_static_locks = emulator->data.data[write_page * 4 + 2] |
-                                     (emulator->data.data[write_page * 4 + 3] << 8);
-        uint16_t new_static_locks = page_buff[2] | (page_buff[3] << 8);
-        if(orig_static_locks & 1) new_static_locks &= ~0x08;
-        if(orig_static_locks & 2) new_static_locks &= ~0xF0;
-        if(orig_static_locks & 4) new_static_locks &= 0xFF;
-        new_static_locks |= orig_static_locks;
-        page_buff[0] = emulator->data.data[write_page * 4];
-        page_buff[1] = emulator->data.data[write_page * 4 + 1];
-        page_buff[2] = new_static_locks & 0xff;
-        page_buff[3] = new_static_locks >> 8;
-    } else if(tag_addr == 3) {
-        // Handle OTP/capability container
-        *(uint32_t*)page_buff |= *(uint32_t*)&emulator->data.data[write_page * 4];
-    } else if(tag_addr == mf_ul_get_dynamic_lock_page_addr(&emulator->data)) {
-        // Handle dynamic locks
-        if(emulator->data.type == MfUltralightTypeNTAG203) {
-            // NTAG203 lock bytes are a bit different from the others
-            uint8_t orig_page_lock_byte = emulator->data.data[write_page * 4];
-            uint8_t orig_cnt_lock_byte = emulator->data.data[write_page * 4 + 1];
-            uint8_t new_page_lock_byte = page_buff[0];
-            uint8_t new_cnt_lock_byte = page_buff[1];
-
-            if(orig_page_lock_byte & 0x01) // Block lock bits 1-3
-                new_page_lock_byte &= ~0x0E;
-            if(orig_page_lock_byte & 0x10) // Block lock bits 5-7
-                new_page_lock_byte &= ~0xE0;
-            for(uint8_t i = 0; i < 4; ++i) {
-                if(orig_cnt_lock_byte & (1 << i)) // Block lock counter bit
-                    new_cnt_lock_byte &= ~(1 << (4 + i));
-            }
-
-            new_page_lock_byte |= orig_page_lock_byte;
-            new_cnt_lock_byte |= orig_cnt_lock_byte;
-            page_buff[0] = new_page_lock_byte;
-            page_buff[1] = new_cnt_lock_byte;
-        } else {
-            uint16_t orig_locks = emulator->data.data[write_page * 4] |
-                                  (emulator->data.data[write_page * 4 + 1] << 8);
-            uint8_t orig_block_locks = emulator->data.data[write_page * 4 + 2];
-            uint16_t new_locks = page_buff[0] | (page_buff[1] << 8);
-            uint8_t new_block_locks = page_buff[2];
-
-            int block_lock_count;
-            switch(emulator->data.type) {
-            case MfUltralightTypeUL21:
-                block_lock_count = 5;
-                break;
-            case MfUltralightTypeNTAG213:
-                block_lock_count = 6;
-                break;
-            case MfUltralightTypeNTAG215:
-                block_lock_count = 4;
-                break;
-            case MfUltralightTypeNTAG216:
-            case MfUltralightTypeNTAGI2C1K:
-            case MfUltralightTypeNTAGI2CPlus1K:
-                block_lock_count = 7;
-                break;
-            case MfUltralightTypeNTAGI2C2K:
-            case MfUltralightTypeNTAGI2CPlus2K:
-                block_lock_count = 8;
-                break;
-            default:
-                furi_crash("Unknown MFUL");
-                break;
-            }
-
-            for(int i = 0; i < block_lock_count; ++i) {
-                if(orig_block_locks & (1 << i)) new_locks &= ~(3 << (2 * i));
-            }
-
-            new_locks |= orig_locks;
-            new_block_locks |= orig_block_locks;
-
-            page_buff[0] = new_locks & 0xff;
-            page_buff[1] = new_locks >> 8;
-            page_buff[2] = new_block_locks;
-            if(emulator->data.type >= MfUltralightTypeUL21 && //-V1016
-               emulator->data.type <= MfUltralightTypeNTAG216)
-                page_buff[3] = MF_UL_TEARING_FLAG_DEFAULT;
-            else
-                page_buff[3] = 0;
-        }
-    }
-
-    memcpy(&emulator->data.data[write_page * 4], page_buff, 4);
-    emulator->data_changed = true;
-}
-
-void mf_ul_reset_emulation(MfUltralightEmulator* emulator, bool is_power_cycle) {
-    emulator->comp_write_cmd_started = false;
-    emulator->sector_select_cmd_started = false;
-    emulator->curr_sector = 0;
-    emulator->ntag_i2c_plus_sector3_lockout = false;
-    emulator->auth_success = false;
-    if(is_power_cycle) {
-        if(emulator->config != NULL) emulator->config_cache = *emulator->config;
-
-        if(emulator->supported_features & MfUltralightSupportSingleCounter) {
-            emulator->read_counter_incremented = false;
-        }
-
-        if(emulator->data.type == MfUltralightTypeNTAG203) {
-            // Apply lockout if counter ever reached 0xFFFF
-            if(emulator->data.counter[1] == 0xFFFF) {
-                emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] = 0xFF;
-                emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] = 0xFF;
-            }
-            // Copy original counter value from data
-            emulator->data.counter[0] =
-                emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] |
-                (emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] << 8);
-        }
-    } else {
-        if(emulator->config != NULL) {
-            // ACCESS (less CFGLCK) and AUTH0 are updated when reactivated
-            // MIRROR_CONF is not; don't know about STRG_MOD_EN, but we're not using that anyway
-            emulator->config_cache.access.value = (emulator->config->access.value & 0xBF) |
-                                                  (emulator->config_cache.access.value & 0x40);
-            emulator->config_cache.auth0 = emulator->config->auth0;
-        }
-    }
-    if(emulator->data.type == MfUltralightTypeNTAG203) {
-        // Mark counter as dirty
-        emulator->data.tearing[0] = 0;
-    }
-}
-
-void mf_ul_prepare_emulation(MfUltralightEmulator* emulator, MfUltralightData* data) {
-    FURI_LOG_D(TAG, "Prepare emulation");
-    emulator->data = *data;
-    emulator->supported_features = mf_ul_get_features(data->type);
-    emulator->config = mf_ultralight_get_config_pages(&emulator->data);
-    emulator->page_num = emulator->data.data_size / 4;
-    emulator->data_changed = false;
-    memset(&emulator->auth_attempt, 0, sizeof(MfUltralightAuth));
-    mf_ul_reset_emulation(emulator, true);
-}
-
-bool mf_ul_prepare_emulation_response(
-    uint8_t* buff_rx,
-    uint16_t buff_rx_len,
-    uint8_t* buff_tx,
-    uint16_t* buff_tx_len,
-    uint32_t* data_type,
-    void* context) {
-    furi_assert(context);
-    MfUltralightEmulator* emulator = context;
-    uint16_t tx_bytes = 0;
-    uint16_t tx_bits = 0;
-    bool command_parsed = false;
-    bool send_ack = false;
-    bool respond_nothing = false;
-    bool reset_idle = false;
-
-#ifdef FURI_DEBUG
-    FuriString* debug_buf;
-    debug_buf = furi_string_alloc();
-    for(int i = 0; i < (buff_rx_len + 7) / 8; ++i) {
-        furi_string_cat_printf(debug_buf, "%02x ", buff_rx[i]);
-    }
-    furi_string_trim(debug_buf);
-    FURI_LOG_T(TAG, "Emu RX (%d): %s", buff_rx_len, furi_string_get_cstr(debug_buf));
-    furi_string_reset(debug_buf);
-#endif
-
-    // Check composite commands
-    if(emulator->comp_write_cmd_started) {
-        if(buff_rx_len == 16 * 8) {
-            if(emulator->data.type == MfUltralightTypeNTAG203 &&
-               emulator->comp_write_page_addr == MF_UL_NTAG203_COUNTER_PAGE) {
-                send_ack = mf_ul_emulate_ntag203_counter_write(emulator, buff_rx);
-                command_parsed = send_ack;
-            } else {
-                mf_ul_emulate_write(
-                    emulator,
-                    emulator->comp_write_page_addr,
-                    emulator->comp_write_page_addr,
-                    buff_rx);
-                send_ack = true;
-                command_parsed = true;
-            }
-        }
-        emulator->comp_write_cmd_started = false;
-    } else if(emulator->sector_select_cmd_started) {
-        if(buff_rx_len == 4 * 8) {
-            if(buff_rx[0] <= 0xFE) {
-                emulator->curr_sector = buff_rx[0] > 3 ? 0 : buff_rx[0];
-                emulator->ntag_i2c_plus_sector3_lockout = false;
-                command_parsed = true;
-                respond_nothing = true;
-                FURI_LOG_D(TAG, "Changing sector to %d", emulator->curr_sector);
-            }
-        }
-        emulator->sector_select_cmd_started = false;
-    } else if(buff_rx_len >= 8) {
-        uint8_t cmd = buff_rx[0];
-        if(cmd == MF_UL_GET_VERSION_CMD) {
-            if(emulator->data.type >= MfUltralightTypeUL11) {
-                if(buff_rx_len == 1 * 8) {
-                    tx_bytes = sizeof(emulator->data.version);
-                    memcpy(buff_tx, &emulator->data.version, tx_bytes);
-                    *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                    command_parsed = true;
-                }
-            }
-        } else if(cmd == MF_UL_READ_CMD) {
-            if(buff_rx_len == (1 + 1) * 8) {
-                int16_t start_page = buff_rx[1];
-                tx_bytes = 16;
-                if(emulator->data.type < MfUltralightTypeNTAGI2C1K) {
-                    if(start_page < emulator->page_num) {
-                        do {
-                            uint8_t copied_pages = 0;
-                            uint8_t src_page = start_page;
-                            uint8_t last_page_plus_one = start_page + 4;
-                            uint8_t pwd_page = emulator->page_num - 2;
-                            FuriString* ascii_mirror = NULL;
-                            size_t ascii_mirror_len = 0;
-                            const char* ascii_mirror_cptr = NULL;
-                            uint8_t ascii_mirror_curr_page = 0;
-                            uint8_t ascii_mirror_curr_byte = 0;
-                            if(last_page_plus_one > emulator->page_num)
-                                last_page_plus_one = emulator->page_num;
-                            if(emulator->supported_features & MfUltralightSupportAuth) {
-                                if(!mf_ul_check_auth(emulator, start_page, false)) break;
-                                if(!emulator->auth_success && emulator->config_cache.access.prot &&
-                                   emulator->config_cache.auth0 < last_page_plus_one)
-                                    last_page_plus_one = emulator->config_cache.auth0;
-                            }
-                            if(emulator->supported_features & MfUltralightSupportSingleCounter)
-                                mf_ul_increment_single_counter(emulator);
-                            if(emulator->supported_features & MfUltralightSupportAsciiMirror &&
-                               emulator->config_cache.mirror.mirror_conf !=
-                                   MfUltralightMirrorNone) {
-                                ascii_mirror_curr_byte = emulator->config->mirror.mirror_byte;
-                                ascii_mirror_curr_page = emulator->config->mirror_page;
-                                // Try to avoid wasting time making mirror if we won't copy it
-                                // Conservatively check with UID+counter mirror size
-                                if(last_page_plus_one > ascii_mirror_curr_page &&
-                                   start_page + 3 >= ascii_mirror_curr_page &&
-                                   start_page <= ascii_mirror_curr_page + 6) {
-                                    ascii_mirror = furi_string_alloc();
-                                    mf_ul_make_ascii_mirror(emulator, ascii_mirror);
-                                    ascii_mirror_len = furi_string_utf8_length(ascii_mirror);
-                                    ascii_mirror_cptr = furi_string_get_cstr(ascii_mirror);
-                                    // Move pointer to where it should be to start copying
-                                    if(ascii_mirror_len > 0 &&
-                                       ascii_mirror_curr_page < start_page &&
-                                       ascii_mirror_curr_byte != 0) {
-                                        uint8_t diff = 4 - ascii_mirror_curr_byte;
-                                        ascii_mirror_len -= diff;
-                                        ascii_mirror_cptr += diff;
-                                        ascii_mirror_curr_byte = 0;
-                                        ++ascii_mirror_curr_page;
-                                    }
-                                    while(ascii_mirror_len > 0 &&
-                                          ascii_mirror_curr_page < start_page) {
-                                        uint8_t diff = ascii_mirror_len > 4 ? 4 : ascii_mirror_len;
-                                        ascii_mirror_len -= diff;
-                                        ascii_mirror_cptr += diff;
-                                        ++ascii_mirror_curr_page;
-                                    }
-                                }
-                            }
-
-                            uint8_t* dest_ptr = buff_tx;
-                            while(copied_pages < 4) {
-                                // Copy page
-                                memcpy(dest_ptr, &emulator->data.data[src_page * 4], 4);
-
-                                // Note: don't have to worry about roll-over with ASCII mirror because
-                                // lowest valid page for it is 4, while roll-over will at best read
-                                // pages 0-2
-                                if(ascii_mirror_len > 0 && src_page == ascii_mirror_curr_page) {
-                                    // Copy ASCII mirror
-                                    size_t copy_len = 4 - ascii_mirror_curr_byte;
-                                    if(copy_len > ascii_mirror_len) copy_len = ascii_mirror_len;
-                                    for(size_t i = 0; i < copy_len; ++i) {
-                                        if(*ascii_mirror_cptr != ' ')
-                                            dest_ptr[ascii_mirror_curr_byte] =
-                                                (uint8_t)*ascii_mirror_cptr;
-                                        ++ascii_mirror_curr_byte;
-                                        ++ascii_mirror_cptr;
-                                    }
-                                    ascii_mirror_len -= copy_len;
-                                    // Don't care if this is inaccurate after ascii_mirror_len = 0
-                                    ascii_mirror_curr_byte = 0;
-                                    ++ascii_mirror_curr_page;
-                                }
-
-                                if(emulator->supported_features & MfUltralightSupportAuth) {
-                                    if(src_page == pwd_page || src_page == pwd_page + 1) {
-                                        // Blank out PWD and PACK pages
-                                        memset(dest_ptr, 0, 4);
-                                    }
-                                }
-
-                                dest_ptr += 4;
-                                ++copied_pages;
-                                ++src_page;
-                                if(src_page >= last_page_plus_one) src_page = 0;
-                            }
-                            if(ascii_mirror != NULL) {
-                                furi_string_free(ascii_mirror);
-                            }
-                            *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                        } while(false);
-                    }
-                } else {
-                    uint16_t valid_pages;
-                    start_page = mf_ultralight_ntag_i2c_addr_tag_to_lin(
-                        &emulator->data, start_page, emulator->curr_sector, &valid_pages);
-                    if(start_page != -1) {
-                        if(emulator->data.type < MfUltralightTypeNTAGI2CPlus1K ||
-                           mf_ul_ntag_i2c_plus_check_auth(emulator, buff_rx[1], false)) {
-                            if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K &&
-                               emulator->curr_sector == 3 && valid_pages == 1) {
-                                // Rewind back a sector to match behavior on a real tag
-                                --start_page;
-                                ++valid_pages;
-                            }
-
-                            uint16_t copy_count = (valid_pages > 4 ? 4 : valid_pages) * 4;
-                            FURI_LOG_D(
-                                TAG,
-                                "NTAG I2C Emu: page valid, %02x:%02x -> %d, %d",
-                                emulator->curr_sector,
-                                buff_rx[1],
-                                start_page,
-                                valid_pages);
-                            memcpy(buff_tx, &emulator->data.data[start_page * 4], copy_count);
-                            // For NTAG I2C, there's no roll-over; remainder is filled by null bytes
-                            if(copy_count < tx_bytes)
-                                memset(&buff_tx[copy_count], 0, tx_bytes - copy_count);
-                            // Special case: NTAG I2C Plus sector 0 page 233 read crosses into page 236
-                            if(start_page == 233)
-                                memcpy(
-                                    &buff_tx[12], &emulator->data.data[(start_page + 1) * 4], 4);
-                            mf_ul_protect_auth_data_on_read_command_i2c(
-                                buff_tx, start_page, start_page + copy_count / 4 - 1, emulator);
-                            *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                        }
-                    } else {
-                        FURI_LOG_D(
-                            TAG,
-                            "NTAG I2C Emu: page invalid, %02x:%02x",
-                            emulator->curr_sector,
-                            buff_rx[1]);
-                        if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K &&
-                           emulator->curr_sector == 3 &&
-                           !emulator->ntag_i2c_plus_sector3_lockout) {
-                            // NTAG I2C Plus has a weird behavior where if you read sector 3
-                            // at an invalid address, it responds with zeroes then locks
-                            // the read out, while if you read the mirrored session registers,
-                            // it returns both session registers on either pages
-                            memset(buff_tx, 0, tx_bytes);
-                            *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                            emulator->ntag_i2c_plus_sector3_lockout = true;
-                        }
-                    }
-                }
-                if(!command_parsed) tx_bytes = 0;
-            }
-        } else if(cmd == MF_UL_FAST_READ_CMD) {
-            if(emulator->supported_features & MfUltralightSupportFastRead) {
-                if(buff_rx_len == (1 + 2) * 8) {
-                    int16_t start_page = buff_rx[1];
-                    uint8_t end_page = buff_rx[2];
-                    if(start_page <= end_page) {
-                        tx_bytes = ((end_page + 1) - start_page) * 4;
-                        if(emulator->data.type < MfUltralightTypeNTAGI2C1K) {
-                            if((start_page < emulator->page_num) &&
-                               (end_page < emulator->page_num)) {
-                                do {
-                                    if(emulator->supported_features & MfUltralightSupportAuth) {
-                                        // NAK if not authenticated and requested pages cross over AUTH0
-                                        if(!emulator->auth_success &&
-                                           emulator->config_cache.access.prot &&
-                                           (start_page >= emulator->config_cache.auth0 ||
-                                            end_page >= emulator->config_cache.auth0))
-                                            break;
-                                    }
-                                    if(emulator->supported_features &
-                                       MfUltralightSupportSingleCounter)
-                                        mf_ul_increment_single_counter(emulator);
-
-                                    // Copy requested pages
-                                    memcpy(
-                                        buff_tx, &emulator->data.data[start_page * 4], tx_bytes);
-
-                                    if(emulator->supported_features &
-                                           MfUltralightSupportAsciiMirror &&
-                                       emulator->config_cache.mirror.mirror_conf !=
-                                           MfUltralightMirrorNone) {
-                                        // Copy ASCII mirror
-                                        // Less stringent check here, because expecting FAST_READ to
-                                        // only be issued once rather than repeatedly
-                                        FuriString* ascii_mirror;
-                                        ascii_mirror = furi_string_alloc();
-                                        mf_ul_make_ascii_mirror(emulator, ascii_mirror);
-                                        size_t ascii_mirror_len =
-                                            furi_string_utf8_length(ascii_mirror);
-                                        const char* ascii_mirror_cptr =
-                                            furi_string_get_cstr(ascii_mirror);
-                                        int16_t mirror_start_offset =
-                                            (emulator->config->mirror_page - start_page) * 4 +
-                                            emulator->config->mirror.mirror_byte;
-                                        if(mirror_start_offset < 0) {
-                                            if(mirror_start_offset < -(int16_t)ascii_mirror_len) {
-                                                // Past ASCII mirror, don't copy
-                                                ascii_mirror_len = 0;
-                                            } else {
-                                                ascii_mirror_cptr += -mirror_start_offset;
-                                                ascii_mirror_len -= -mirror_start_offset;
-                                                mirror_start_offset = 0;
-                                            }
-                                        }
-                                        if(ascii_mirror_len > 0) {
-                                            int16_t mirror_end_offset =
-                                                mirror_start_offset + ascii_mirror_len;
-                                            if(mirror_end_offset > (end_page + 1) * 4) {
-                                                mirror_end_offset = (end_page + 1) * 4;
-                                                ascii_mirror_len =
-                                                    mirror_end_offset - mirror_start_offset;
-                                            }
-                                            for(size_t i = 0; i < ascii_mirror_len; ++i) {
-                                                if(*ascii_mirror_cptr != ' ')
-                                                    buff_tx[mirror_start_offset] =
-                                                        (uint8_t)*ascii_mirror_cptr;
-                                                ++mirror_start_offset;
-                                                ++ascii_mirror_cptr;
-                                            }
-                                        }
-                                        furi_string_free(ascii_mirror);
-                                    }
-
-                                    if(emulator->supported_features & MfUltralightSupportAuth) {
-                                        // Clear PWD and PACK pages
-                                        uint8_t pwd_page = emulator->page_num - 2;
-                                        int16_t pwd_page_offset = pwd_page - start_page;
-                                        // PWD page
-                                        if(pwd_page_offset >= 0 && pwd_page <= end_page) {
-                                            memset(&buff_tx[pwd_page_offset * 4], 0, 4);
-                                            // PACK page
-                                            if(pwd_page + 1 <= end_page)
-                                                memset(&buff_tx[(pwd_page_offset + 1) * 4], 0, 4);
-                                        }
-                                    }
-                                    *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                                    command_parsed = true;
-                                } while(false);
-                            }
-                        } else {
-                            uint16_t valid_pages;
-                            start_page = mf_ultralight_ntag_i2c_addr_tag_to_lin(
-                                &emulator->data, start_page, emulator->curr_sector, &valid_pages);
-                            if(start_page != -1) {
-                                if(emulator->data.type < MfUltralightTypeNTAGI2CPlus1K ||
-                                   mf_ul_ntag_i2c_plus_check_auth(emulator, buff_rx[1], false)) {
-                                    uint16_t copy_count = tx_bytes;
-                                    if(copy_count > valid_pages * 4) copy_count = valid_pages * 4;
-                                    memcpy(
-                                        buff_tx, &emulator->data.data[start_page * 4], copy_count);
-                                    if(copy_count < tx_bytes)
-                                        memset(&buff_tx[copy_count], 0, tx_bytes - copy_count);
-                                    mf_ul_ntag_i2c_fill_cross_area_read(
-                                        buff_tx, buff_rx[1], buff_rx[2], emulator);
-                                    mf_ul_protect_auth_data_on_read_command_i2c(
-                                        buff_tx,
-                                        start_page,
-                                        start_page + copy_count / 4 - 1,
-                                        emulator);
-                                    *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                                    command_parsed = true;
-                                }
-                            }
-                        }
-                        if(!command_parsed) tx_bytes = 0;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_WRITE) {
-            if(buff_rx_len == (1 + 5) * 8) {
-                do {
-                    uint8_t orig_write_page = buff_rx[1];
-                    int16_t write_page = orig_write_page;
-                    uint16_t valid_pages; // unused
-                    write_page = mf_ultralight_ntag_i2c_addr_tag_to_lin(
-                        &emulator->data, write_page, emulator->curr_sector, &valid_pages);
-                    if(write_page == -1) // NTAG I2C range check
-                        break;
-                    else if(write_page < 2 || write_page >= emulator->page_num) // Other MFUL/NTAG range check
-                        break;
-
-                    if(emulator->supported_features & MfUltralightSupportAuth) {
-                        if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K) {
-                            if(!mf_ul_ntag_i2c_plus_check_auth(emulator, orig_write_page, true))
-                                break;
-                        } else {
-                            if(!mf_ul_check_auth(emulator, orig_write_page, true)) break;
-                        }
-                    }
-                    int16_t tag_addr = mf_ultralight_page_addr_to_tag_addr(
-                        emulator->curr_sector, orig_write_page);
-                    if(!mf_ul_check_lock(emulator, tag_addr)) break;
-                    if(emulator->data.type == MfUltralightTypeNTAG203 &&
-                       orig_write_page == MF_UL_NTAG203_COUNTER_PAGE) {
-                        send_ack = mf_ul_emulate_ntag203_counter_write(emulator, &buff_rx[2]);
-                        command_parsed = send_ack;
-                    } else {
-                        mf_ul_emulate_write(emulator, tag_addr, write_page, &buff_rx[2]);
-                        send_ack = true;
-                        command_parsed = true;
-                    }
-                } while(false);
-            }
-        } else if(cmd == MF_UL_FAST_WRITE) {
-            if(emulator->supported_features & MfUltralightSupportFastWrite) {
-                if(buff_rx_len == (1 + 66) * 8) {
-                    if(buff_rx[1] == 0xF0 && buff_rx[2] == 0xFF) {
-                        // TODO: update when SRAM emulation implemented
-                        send_ack = true;
-                        command_parsed = true;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_COMP_WRITE) {
-            if(emulator->supported_features & MfUltralightSupportCompatWrite) {
-                if(buff_rx_len == (1 + 1) * 8) {
-                    uint8_t write_page = buff_rx[1];
-                    do {
-                        if(write_page < 2 || write_page >= emulator->page_num) break;
-                        if(emulator->supported_features & MfUltralightSupportAuth &&
-                           !mf_ul_check_auth(emulator, write_page, true))
-                            break;
-                        // Note we don't convert to tag addr here because there's only one sector
-                        if(!mf_ul_check_lock(emulator, write_page)) break;
-
-                        emulator->comp_write_cmd_started = true;
-                        emulator->comp_write_page_addr = write_page;
-                        send_ack = true;
-                        command_parsed = true;
-                    } while(false);
-                }
-            }
-        } else if(cmd == MF_UL_READ_CNT) {
-            if(emulator->supported_features & MfUltralightSupportReadCounter) {
-                if(buff_rx_len == (1 + 1) * 8) {
-                    do {
-                        uint8_t cnt_num = buff_rx[1];
-
-                        // NTAG21x checks
-                        if(emulator->supported_features & MfUltralightSupportSingleCounter) {
-                            if(cnt_num != 2) break; // Only counter 2 is available
-                            if(!emulator->config_cache.access.nfc_cnt_en)
-                                break; // NAK if counter not enabled
-                            if(emulator->config_cache.access.nfc_cnt_pwd_prot &&
-                               !emulator->auth_success)
-                                break;
-                        }
-
-                        if(cnt_num < 3) {
-                            buff_tx[0] = emulator->data.counter[cnt_num] & 0xFF;
-                            buff_tx[1] = (emulator->data.counter[cnt_num] >> 8) & 0xFF;
-                            buff_tx[2] = (emulator->data.counter[cnt_num] >> 16) & 0xFF;
-                            tx_bytes = 3;
-                            *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                        }
-                    } while(false);
-                }
-            }
-        } else if(cmd == MF_UL_INC_CNT) {
-            if(emulator->supported_features & MfUltralightSupportIncrCounter) {
-                if(buff_rx_len == (1 + 5) * 8) {
-                    uint8_t cnt_num = buff_rx[1];
-                    uint32_t inc = (buff_rx[2] | (buff_rx[3] << 8) | (buff_rx[4] << 16));
-                    // TODO: can you increment by 0 when counter is at 0xffffff?
-                    if((cnt_num < 3) && (emulator->data.counter[cnt_num] != 0x00FFFFFF) &&
-                       (emulator->data.counter[cnt_num] + inc <= 0x00FFFFFF)) {
-                        emulator->data.counter[cnt_num] += inc;
-                        // We're RAM-backed, so tearing never happens
-                        emulator->data.tearing[cnt_num] = MF_UL_TEARING_FLAG_DEFAULT;
-                        emulator->data_changed = true;
-                        send_ack = true;
-                        command_parsed = true;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_PWD_AUTH) {
-            if(emulator->supported_features & MfUltralightSupportAuth) {
-                if(buff_rx_len == (1 + 4) * 8) {
-                    // Record password sent by PCD
-                    memcpy(
-                        emulator->auth_attempt.pwd.raw,
-                        &buff_rx[1],
-                        sizeof(emulator->auth_attempt.pwd.raw));
-                    emulator->auth_attempted = true;
-                    if(emulator->auth_received_callback) {
-                        emulator->auth_received_callback(
-                            emulator->auth_attempt, emulator->context);
-                    }
-
-                    uint16_t scaled_authlim = mf_ultralight_calc_auth_count(&emulator->data);
-                    if(scaled_authlim != 0 && emulator->data.curr_authlim >= scaled_authlim) {
-                        if(emulator->data.curr_authlim != UINT16_MAX) {
-                            // Handle case where AUTHLIM has been lowered or changed from 0
-                            emulator->data.curr_authlim = UINT16_MAX;
-                            emulator->data_changed = true;
-                        }
-                        // AUTHLIM reached, always fail
-                        buff_tx[0] = MF_UL_NAK_AUTHLIM_REACHED;
-                        tx_bits = 4;
-                        *data_type = FURI_HAL_NFC_TX_RAW_RX_DEFAULT;
-                        mf_ul_reset_emulation(emulator, false);
-                        command_parsed = true;
-                    } else {
-                        if(memcmp(&buff_rx[1], emulator->config->auth_data.pwd.raw, 4) == 0) {
-                            // Correct password
-                            buff_tx[0] = emulator->config->auth_data.pack.raw[0];
-                            buff_tx[1] = emulator->config->auth_data.pack.raw[1];
-                            tx_bytes = 2;
-                            *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                            emulator->auth_success = true;
-                            command_parsed = true;
-                            if(emulator->data.curr_authlim != 0) {
-                                // Reset current AUTHLIM
-                                emulator->data.curr_authlim = 0;
-                                emulator->data_changed = true;
-                            }
-                        } else if(!emulator->config->auth_data.pwd.value) {
-                            // Unknown password, pretend to be an Amiibo
-                            buff_tx[0] = 0x80;
-                            buff_tx[1] = 0x80;
-                            tx_bytes = 2;
-                            *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                            emulator->auth_success = true;
-                            command_parsed = true;
-                        } else {
-                            // Wrong password, increase negative verification count
-                            if(emulator->data.curr_authlim < UINT16_MAX) {
-                                ++emulator->data.curr_authlim;
-                                emulator->data_changed = true;
-                            }
-                            if(scaled_authlim != 0 &&
-                               emulator->data.curr_authlim >= scaled_authlim) {
-                                emulator->data.curr_authlim = UINT16_MAX;
-                                buff_tx[0] = MF_UL_NAK_AUTHLIM_REACHED;
-                                tx_bits = 4;
-                                *data_type = FURI_HAL_NFC_TX_RAW_RX_DEFAULT;
-                                mf_ul_reset_emulation(emulator, false);
-                                command_parsed = true;
-                            } else {
-                                // Should delay here to slow brute forcing
-                            }
-                        }
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_READ_SIG) {
-            if(emulator->supported_features & MfUltralightSupportSignature) {
-                // Check 2nd byte = 0x00 - RFU
-                if(buff_rx_len == (1 + 1) * 8 && buff_rx[1] == 0x00) {
-                    tx_bytes = sizeof(emulator->data.signature);
-                    memcpy(buff_tx, emulator->data.signature, tx_bytes);
-                    *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                    command_parsed = true;
-                }
-            }
-        } else if(cmd == MF_UL_CHECK_TEARING) {
-            if(emulator->supported_features & MfUltralightSupportTearingFlags) {
-                if(buff_rx_len == (1 + 1) * 8) {
-                    uint8_t cnt_num = buff_rx[1];
-                    if(cnt_num < 3) {
-                        buff_tx[0] = emulator->data.tearing[cnt_num];
-                        tx_bytes = 1;
-                        *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                        command_parsed = true;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_HALT_START) {
-            reset_idle = true;
-            FURI_LOG_D(TAG, "Received HLTA");
-        } else if(cmd == MF_UL_SECTOR_SELECT) {
-            if(emulator->supported_features & MfUltralightSupportSectorSelect) {
-                if(buff_rx_len == (1 + 1) * 8 && buff_rx[1] == 0xFF) {
-                    // Send ACK
-                    emulator->sector_select_cmd_started = true;
-                    send_ack = true;
-                    command_parsed = true;
-                }
-            }
-        } else if(cmd == MF_UL_READ_VCSL) {
-            if(emulator->supported_features & MfUltralightSupportVcsl) {
-                if(buff_rx_len == (1 + 20) * 8) {
-                    buff_tx[0] = emulator->config_cache.vctid;
-                    tx_bytes = 1;
-                    *data_type = FURI_HAL_NFC_TXRX_DEFAULT;
-                    command_parsed = true;
-                }
-            }
-        } else {
-            // NTAG203 appears to NAK instead of just falling off on invalid commands
-            if(emulator->data.type != MfUltralightTypeNTAG203) reset_idle = true;
-            FURI_LOG_D(TAG, "Received invalid command");
-        }
-    } else {
-        reset_idle = true;
-        FURI_LOG_D(TAG, "Received invalid buffer less than 8 bits in length");
-    }
-
-    if(reset_idle) {
-        mf_ul_reset_emulation(emulator, false);
-        tx_bits = 0;
-        command_parsed = true;
-    }
-
-    if(!command_parsed) {
-        // Send NACK
-        buff_tx[0] = MF_UL_NAK_INVALID_ARGUMENT;
-        tx_bits = 4;
-        *data_type = FURI_HAL_NFC_TX_RAW_RX_DEFAULT;
-        // Every NAK should cause reset to IDLE
-        mf_ul_reset_emulation(emulator, false);
-    } else if(send_ack) {
-        buff_tx[0] = MF_UL_ACK;
-        tx_bits = 4;
-        *data_type = FURI_HAL_NFC_TX_RAW_RX_DEFAULT;
-    }
-
-    if(respond_nothing) {
-        *buff_tx_len = UINT16_MAX;
-        *data_type = FURI_HAL_NFC_TX_RAW_RX_DEFAULT;
-    } else {
-        // Return tx buffer size in bits
-        if(tx_bytes) {
-            tx_bits = tx_bytes * 8;
-        }
-        *buff_tx_len = tx_bits;
-    }
-
-#ifdef FURI_DEBUG
-    if(*buff_tx_len == UINT16_MAX) {
-        FURI_LOG_T(TAG, "Emu TX: no reply");
-    } else if(*buff_tx_len > 0) {
-        int count = (*buff_tx_len + 7) / 8;
-        for(int i = 0; i < count; ++i) {
-            furi_string_cat_printf(debug_buf, "%02x ", buff_tx[i]);
-        }
-        furi_string_trim(debug_buf);
-        FURI_LOG_T(TAG, "Emu TX (%d): %s", *buff_tx_len, furi_string_get_cstr(debug_buf));
-        furi_string_free(debug_buf);
-    } else {
-        FURI_LOG_T(TAG, "Emu TX: HALT");
-    }
-#endif
-
-    return tx_bits > 0;
-}
-
-bool mf_ul_is_full_capture(MfUltralightData* data) {
-    if(data->data_read != data->data_size) return false;
-
-    // Having read all the pages doesn't mean that we've got everything.
-    // By default PWD is 0xFFFFFFFF, but if read back it is always 0x00000000,
-    // so a default read on an auth-supported NTAG is never complete.
-    if(!(mf_ul_get_features(data->type) & MfUltralightSupportAuth)) return true;
-    MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-    return config->auth_data.pwd.value != 0 || config->auth_data.pack.value != 0;
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/protocols/nfc_util.c

@@ -1,70 +0,0 @@
-#include <lib/nfc/protocols/nfc_util.h>
-
-#include <furi.h>
-
-static const uint8_t nfc_util_odd_byte_parity[256] = {
-    1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
-    1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1,
-    1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1,
-    0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0,
-    1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,
-    0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0,
-    0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1,
-    0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
-    1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1};
-
-void nfc_util_num2bytes(uint64_t src, uint8_t len, uint8_t* dest) {
-    furi_assert(dest);
-    furi_assert(len <= 8);
-
-    while(len--) {
-        dest[len] = (uint8_t)src;
-        src >>= 8;
-    }
-}
-
-uint64_t nfc_util_bytes2num(const uint8_t* src, uint8_t len) {
-    furi_assert(src);
-    furi_assert(len <= 8);
-
-    uint64_t res = 0;
-    while(len--) {
-        res = (res << 8) | (*src);
-        src++;
-    }
-    return res;
-}
-
-uint8_t nfc_util_even_parity32(uint32_t data) {
-    // data ^= data >> 16;
-    // data ^= data >> 8;
-    // return !nfc_util_odd_byte_parity[data];
-    return (__builtin_parity(data) & 0xFF);
-}
-
-uint8_t nfc_util_odd_parity8(uint8_t data) {
-    return nfc_util_odd_byte_parity[data];
-}
-
-void nfc_util_odd_parity(const uint8_t* src, uint8_t* dst, uint8_t len) {
-    furi_assert(src);
-    furi_assert(dst);
-
-    uint8_t parity = 0;
-    uint8_t bit = 0;
-    while(len--) {
-        parity |= nfc_util_odd_parity8(*src) << (7 - bit); // parity is MSB first
-        bit++;
-        if(bit == 8) {
-            *dst = parity;
-            dst++;
-            parity = 0;
-            bit = 0;
-        }
-        src++;
-    }
-
-    if(bit) {
-        *dst = parity;
-    }
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/lib/nfc/protocols/nfca.c

@@ -1,142 +0,0 @@
-#include <lib/nfc/protocols/nfca.h>
-#include <string.h>
-#include <stdio.h>
-#include <furi.h>
-
-#define NFCA_CMD_RATS (0xE0U)
-
-#define NFCA_CRC_INIT (0x6363)
-
-#define NFCA_F_SIG (13560000.0)
-#define T_SIG 7374 //73.746ns*100
-#define T_SIG_x8 58992 //T_SIG*8
-#define T_SIG_x8_x8 471936 //T_SIG*8*8
-#define T_SIG_x8_x9 530928 //T_SIG*8*9
-
-#define NFCA_SIGNAL_MAX_EDGES (1350)
-
-typedef struct {
-    uint8_t cmd;
-    uint8_t param;
-} nfca_cmd_rats;
-
-static uint8_t nfca_default_ats[] = {0x05, 0x78, 0x80, 0x80, 0x00};
-
-static uint8_t nfca_sleep_req[] = {0x50, 0x00};
-
-uint16_t nfca_get_crc16(uint8_t* buff, uint16_t len) {
-    uint16_t crc = NFCA_CRC_INIT;
-    uint8_t byte = 0;
-
-    for(uint8_t i = 0; i < len; i++) {
-        byte = buff[i];
-        byte ^= (uint8_t)(crc & 0xff);
-        byte ^= byte << 4;
-        crc = (crc >> 8) ^ (((uint16_t)byte) << 8) ^ (((uint16_t)byte) << 3) ^
-              (((uint16_t)byte) >> 4);
-    }
-
-    return crc;
-}
-
-void nfca_append_crc16(uint8_t* buff, uint16_t len) {
-    uint16_t crc = nfca_get_crc16(buff, len);
-    buff[len] = (uint8_t)crc;
-    buff[len + 1] = (uint8_t)(crc >> 8);
-}
-
-bool nfca_emulation_handler(
-    uint8_t* buff_rx,
-    uint16_t buff_rx_len,
-    uint8_t* buff_tx,
-    uint16_t* buff_tx_len) {
-    bool sleep = false;
-    uint8_t rx_bytes = buff_rx_len / 8;
-
-    if(rx_bytes == sizeof(nfca_sleep_req) && !memcmp(buff_rx, nfca_sleep_req, rx_bytes)) {
-        sleep = true;
-    } else if(rx_bytes == sizeof(nfca_cmd_rats) && buff_rx[0] == NFCA_CMD_RATS) {
-        memcpy(buff_tx, nfca_default_ats, sizeof(nfca_default_ats));
-        *buff_tx_len = sizeof(nfca_default_ats) * 8;
-    }
-
-    return sleep;
-}
-
-static void nfca_add_bit(DigitalSignal* signal, bool bit) {
-    if(bit) {
-        signal->start_level = true;
-        for(size_t i = 0; i < 7; i++) {
-            signal->edge_timings[i] = T_SIG_x8;
-        }
-        signal->edge_timings[7] = T_SIG_x8_x9;
-        signal->edge_cnt = 8;
-    } else {
-        signal->start_level = false;
-        signal->edge_timings[0] = T_SIG_x8_x8;
-        for(size_t i = 1; i < 9; i++) {
-            signal->edge_timings[i] = T_SIG_x8;
-        }
-        signal->edge_cnt = 9;
-    }
-}
-
-static void nfca_add_byte(NfcaSignal* nfca_signal, uint8_t byte, bool parity) {
-    for(uint8_t i = 0; i < 8; i++) {
-        if(byte & (1 << i)) {
-            digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-        } else {
-            digital_signal_append(nfca_signal->tx_signal, nfca_signal->zero);
-        }
-    }
-    if(parity) {
-        digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-    } else {
-        digital_signal_append(nfca_signal->tx_signal, nfca_signal->zero);
-    }
-}
-
-NfcaSignal* nfca_signal_alloc() {
-    NfcaSignal* nfca_signal = malloc(sizeof(NfcaSignal));
-    nfca_signal->one = digital_signal_alloc(10);
-    nfca_signal->zero = digital_signal_alloc(10);
-    nfca_add_bit(nfca_signal->one, true);
-    nfca_add_bit(nfca_signal->zero, false);
-    nfca_signal->tx_signal = digital_signal_alloc(NFCA_SIGNAL_MAX_EDGES);
-
-    return nfca_signal;
-}
-
-void nfca_signal_free(NfcaSignal* nfca_signal) {
-    furi_assert(nfca_signal);
-
-    digital_signal_free(nfca_signal->one);
-    digital_signal_free(nfca_signal->zero);
-    digital_signal_free(nfca_signal->tx_signal);
-    free(nfca_signal);
-}
-
-void nfca_signal_encode(NfcaSignal* nfca_signal, uint8_t* data, uint16_t bits, uint8_t* parity) {
-    furi_assert(nfca_signal);
-    furi_assert(data);
-    furi_assert(parity);
-
-    nfca_signal->tx_signal->edge_cnt = 0;
-    nfca_signal->tx_signal->start_level = true;
-    // Start of frame
-    digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-
-    if(bits < 8) {
-        for(size_t i = 0; i < bits; i++) {
-            if(FURI_BIT(data[0], i)) {
-                digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-            } else {
-                digital_signal_append(nfca_signal->tx_signal, nfca_signal->zero);
-            }
-        }
-    } else {
-        for(size_t i = 0; i < bits / 8; i++) {
-            nfca_add_byte(nfca_signal, data[i], parity[i / 8] & (1 << (7 - (i & 0x07))));
-        }
-    }
-}

apps_broken_by_last_refactors/flipperzero_vb_migrate/scenes/vb_migrate_scene_from_app.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -54,20 +54,34 @@ static void
     }
 }
 
-static bool vb_migrate_scene_from_app_worker_callback(NfcWorkerEvent event, void* context) {
+static NfcCommand vb_migrate_scene_from_app_worker_callback(NfcGenericEvent event, void* context) {
     VbMigrate* inst = context;
-    bool result = false;
-
-    if(event == NfcWorkerEventSuccess) {
-        view_dispatcher_send_custom_event(inst->view_dispatcher, FromAppEventTypeTagWrite);
-        result = true;
+    NfcCommand result = NfcCommandContinue;
+
+    if(event.protocol == NfcProtocolInvalid) {
+        NfcEvent* nfc_event = event.event_data;
+        if(nfc_event->type == NfcEventTypeRxEnd) {
+            const MfUltralightData* data =
+                nfc_listener_get_data(inst->listener, NfcProtocolMfUltralight);
+            const BantBlock* bant = vb_tag_get_bant_block_const(data);
+            switch(vb_tag_get_operation(bant)) {
+            case VbTagOperationCheckDim:
+            case VbTagOperationReturnFromApp:
+                nfc_device_set_data(inst->nfc_dev, NfcProtocolMfUltralight, data);
+                view_dispatcher_send_custom_event(inst->view_dispatcher, FromAppEventTypeTagWrite);
+                break;
+            default:
+                break;
+            }
+        }
     }
 
     return result;
 }
 
 static void vb_migrate_scene_from_app_set_nfc_state(VbMigrate* inst, FromAppState state) {
-    BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+    nfc_device_copy_data(inst->nfc_dev, NfcProtocolMfUltralight, inst->data_work);
+    BantBlock* bant = vb_tag_get_bant_block(inst->data_work);
     if(state == FromAppStateEmulateReady) {
         vb_tag_set_random_nonce(bant);
         vb_tag_set_status(bant, VbTagStatusReady);
@@ -88,10 +102,12 @@ static void vb_migrate_scene_from_app_set_nfc_state(VbMigrate* inst, FromAppStat
     if(inst->clear_account_id) {
         vb_tag_set_app_flag(bant, false);
     }
+    nfc_device_set_data(inst->nfc_dev, NfcProtocolMfUltralight, inst->data_work);
 }
 
 static bool vb_migrate_scene_from_app_is_state_changed(VbMigrate* inst, FromAppState state) {
-    BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+    const MfUltralightData* data = nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+    const BantBlock* bant = vb_tag_get_bant_block_const(data);
     VbTagOperation operation = vb_tag_get_operation(bant);
 
     if(state == FromAppStateEmulateReady) {
@@ -184,12 +200,11 @@ static void vb_migrate_scene_from_app_set_state(VbMigrate* inst, FromAppState st
                 furi_string_free(temp_str);
 
                 vb_migrate_scene_from_app_set_nfc_state(inst, state);
-                nfc_worker_start(
-                    inst->worker,
-                    NfcWorkerStateMfUltralightEmulate,
-                    &inst->nfc_dev->dev_data,
-                    vb_migrate_scene_from_app_worker_callback,
-                    inst);
+                const NfcDeviceData* data =
+                    nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+                inst->listener = nfc_listener_alloc(inst->nfc, NfcProtocolMfUltralight, data);
+                nfc_listener_start(
+                    inst->listener, vb_migrate_scene_from_app_worker_callback, inst);
                 vb_migrate_blink_emulate(inst);
             } else {
                 view_dispatcher_send_custom_event(
@@ -212,12 +227,11 @@ static void vb_migrate_scene_from_app_set_state(VbMigrate* inst, FromAppState st
             view_dispatcher_switch_to_view(inst->view_dispatcher, VbMigrateViewWidget);
             notification_message(inst->notifications, &sequence_success);
             vb_migrate_scene_from_app_set_nfc_state(inst, state);
-            nfc_worker_start(
-                inst->worker,
-                NfcWorkerStateMfUltralightEmulate,
-                &inst->nfc_dev->dev_data,
-                vb_migrate_scene_from_app_worker_callback,
-                inst);
+            furi_assert(!inst->listener);
+            const NfcDeviceData* data =
+                nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+            inst->listener = nfc_listener_alloc(inst->nfc, NfcProtocolMfUltralight, data);
+            nfc_listener_start(inst->listener, vb_migrate_scene_from_app_worker_callback, inst);
             vb_migrate_blink_emulate(inst);
         } else if(state == FromAppStateEmulateTransferFromApp) {
             widget_reset(widget);
@@ -232,15 +246,19 @@ static void vb_migrate_scene_from_app_set_state(VbMigrate* inst, FromAppState st
                 inst);
 
             view_dispatcher_switch_to_view(inst->view_dispatcher, VbMigrateViewWidget);
-            nfc_worker_stop(inst->worker);
+            nfc_listener_stop(inst->listener);
+            nfc_listener_free(inst->listener);
+            inst->listener = NULL;
             vb_migrate_blink_stop(inst);
             vb_migrate_scene_from_app_set_nfc_state(inst, state);
             notification_message(inst->notifications, &sequence_success);
 
             // Restore original tag type if necessary
             if(inst->override_type != inst->orig_type && inst->override_type != VbTagTypeUnknown) {
-                BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+                nfc_device_copy_data(inst->nfc_dev, NfcProtocolMfUltralight, inst->data_work);
+                BantBlock* bant = vb_tag_get_bant_block(inst->data_work);
                 vb_tag_set_item_id_no(bant, inst->orig_product);
+                nfc_device_set_data(inst->nfc_dev, NfcProtocolMfUltralight, inst->data_work);
             }
 
             // Save the tag
@@ -319,16 +337,22 @@ bool vb_migrate_scene_from_app_on_event(void* context, SceneManagerEvent event)
                 scene_manager_get_scene_state(inst->scene_manager, VbMigrateSceneFromApp);
             if(vb_migrate_scene_from_app_is_state_changed(inst, state)) {
                 if(state == FromAppStateEmulateReady) {
-                    nfc_worker_stop(inst->worker);
+                    nfc_listener_stop(inst->listener);
+                    nfc_listener_free(inst->listener);
+                    inst->listener = NULL;
                     vb_migrate_blink_stop(inst);
                     vb_migrate_scene_from_app_set_state(inst, FromAppStateEmulateCheckDim);
                     consumed = true;
                 } else if(state == FromAppStateEmulateCheckDim) {
-                    BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+                    const MfUltralightData* data =
+                        nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+                    const BantBlock* bant = vb_tag_get_bant_block_const(data);
                     VbTagOperation operation = vb_tag_get_operation(bant);
 
                     if(operation == VbTagOperationReturnFromApp) {
-                        nfc_worker_stop(inst->worker);
+                        nfc_listener_stop(inst->listener);
+                        nfc_listener_free(inst->listener);
+                        inst->listener = NULL;
                         vb_migrate_blink_stop(inst);
                         vb_migrate_scene_from_app_set_state(
                             inst, FromAppStateEmulateTransferFromApp);
@@ -364,7 +388,11 @@ void vb_migrate_scene_from_app_on_exit(void* context) {
 
     // Perform your cleanup here
     widget_reset(inst->widget);
-    nfc_worker_stop(inst->worker);
+    if(inst->listener) {
+        nfc_listener_stop(inst->listener);
+        nfc_listener_free(inst->listener);
+        inst->listener = NULL;
+    }
     vb_migrate_blink_stop(inst);
     notification_message_block(inst->notifications, &sequence_reset_red);
 }

apps_broken_by_last_refactors/flipperzero_vb_migrate/scenes/vb_migrate_scene_load.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -36,7 +36,9 @@ bool vb_migrate_scene_load_on_event(void* context, SceneManagerEvent event) {
         if(vb_migrate_load_nfc(inst, inst->text_store, VB_MIGRATE_TEMPLATE_NAME)) {
             inst->num_captured = vb_migrate_count_captured_mons(inst, inst->text_store);
 
-            BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+            const MfUltralightData* data =
+                nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+            const BantBlock* bant = vb_tag_get_bant_block_const(data);
             const VbTagProduct* product = vb_tag_find_product(bant);
             inst->orig_product = product;
             if(product) {

apps_broken_by_last_refactors/flipperzero_vb_migrate/scenes/vb_migrate_scene_register.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -17,6 +17,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 #include <notification/notification_messages.h>
+#include <lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.h>
+#include <lib/nfc/protocols/mf_ultralight/mf_ultralight_listener.h>
 
 #include "../vb_tag.h"
 #include "../vb_migrate_i.h"
@@ -54,63 +56,81 @@ static void
     }
 }
 
-static bool
-    vb_migrate_scene_register_worker_read_initial_callback(NfcWorkerEvent event, void* context) {
+static NfcCommand
+    vb_migrate_scene_register_worker_read_initial_callback(NfcGenericEvent event, void* context) {
     VbMigrate* inst = context;
-    bool consumed = false;
+    const MfUltralightPollerEvent* mf_ultralight_event = event.event_data;
+    NfcCommand result = NfcCommandContinue;
 
-    if(event == NfcWorkerEventReadMfUltralight) {
+    if(mf_ultralight_event->type == MfUltralightPollerEventTypeReadSuccess) {
+        nfc_device_set_data(
+            inst->nfc_dev, NfcProtocolMfUltralight, nfc_poller_get_data(inst->poller));
         view_dispatcher_send_custom_event(inst->view_dispatcher, RegisterEventTypeVbReadInitial);
-        consumed = true;
+        result = NfcCommandStop;
     }
 
-    return consumed;
+    return result;
 }
 
-static bool vb_migrate_scene_register_worker_auth_callback(NfcWorkerEvent event, void* context) {
+static NfcCommand
+    vb_migrate_scene_register_worker_auth_callback(NfcGenericEvent event, void* context) {
     VbMigrate* inst = context;
-    bool consumed = false;
+    const MfUltralightListenerEvent* mf_ultralight_event = event.event_data;
+    NfcCommand result = NfcCommandContinue;
 
-    if(event == NfcWorkerEventMfUltralightPwdAuth) {
+    if(mf_ultralight_event->type == MfUltralightListenerEventTypeAuth) {
+        // Set up for auth
+        memcpy(
+            inst->captured_pwd,
+            mf_ultralight_event->data->password.data,
+            sizeof(inst->captured_pwd));
         view_dispatcher_send_custom_event(inst->view_dispatcher, RegisterEventTypeVbPwdAuth);
-        consumed = true;
+        result = NfcCommandStop;
     }
 
-    return consumed;
+    return result;
 }
 
-static bool
-    vb_migrate_scene_register_worker_full_capture_callback(NfcWorkerEvent event, void* context) {
+static NfcCommand
+    vb_migrate_scene_register_worker_full_capture_callback(NfcGenericEvent event, void* context) {
     VbMigrate* inst = context;
-    bool consumed = false;
+    const MfUltralightPollerEvent* mf_ultralight_event = event.event_data;
+    NfcCommand result = NfcCommandContinue;
 
-    if(event == NfcWorkerEventMfUltralightPassKey) {
+    if(mf_ultralight_event->type == MfUltralightPollerEventTypeAuthRequest) {
+        mf_ultralight_event->data->auth_context.skip_auth = false;
         memcpy(
-            inst->nfc_dev->dev_data.mf_ul_data.auth_key,
+            mf_ultralight_event->data->auth_context.password.data,
             inst->captured_pwd,
             sizeof(inst->captured_pwd));
-        consumed = true;
-    } else if(event == NfcWorkerEventSuccess) {
+    } else if(mf_ultralight_event->type == MfUltralightPollerEventTypeReadSuccess) {
+        nfc_device_set_data(
+            inst->nfc_dev, NfcProtocolMfUltralight, nfc_poller_get_data(inst->poller));
         view_dispatcher_send_custom_event(
             inst->view_dispatcher, RegisterEventTypeVbReadFullSuccess);
-        consumed = true;
-    } else if(event == NfcWorkerEventFail) {
+        result = NfcCommandStop;
+    } else if(mf_ultralight_event->type == MfUltralightPollerEventTypeAuthFailed) {
         view_dispatcher_send_custom_event(inst->view_dispatcher, RegisterEventTypeVbReadFullFail);
-        consumed = true;
+        result = NfcCommandStop;
     }
 
-    return consumed;
+    return result;
 }
 
 static void vb_migrate_scene_register_cleanup_state(VbMigrate* inst, RegisterState state) {
     if(state == RegisterStateCaptureInvalidTag || state == RegisterStateCaptureFailed ||
        state == RegisterStateCaptureIncorrectTag) {
         notification_message(inst->notifications, &sequence_reset_red);
-    } else if(
-        state == RegisterStateCaptureInitial || state == RegisterStateCapturePwd ||
-        state == RegisterStateCaptureFull) {
+    } else if(state == RegisterStateCaptureInitial || state == RegisterStateCaptureFull) {
+        vb_migrate_blink_stop(inst);
+        nfc_poller_stop(inst->poller);
+        nfc_poller_free(inst->poller);
+        inst->poller = NULL;
+    } else if(state == RegisterStateCapturePwd) {
         vb_migrate_blink_stop(inst);
-        nfc_worker_stop(inst->worker);
+        nfc_listener_stop(inst->listener);
+        nfc_listener_free(inst->listener);
+        inst->listener = NULL;
     }
 }
 
@@ -199,14 +219,9 @@ static void vb_migrate_scene_register_set_state(VbMigrate* inst, RegisterState s
                 inst);
 
             view_dispatcher_switch_to_view(inst->view_dispatcher, VbMigrateViewWidget);
-            nfc_device_clear(inst->nfc_dev);
-            inst->nfc_dev->dev_data.read_mode = NfcReadModeMfUltralight;
-            nfc_worker_start(
-                inst->worker,
-                NfcWorkerStateRead,
-                &inst->nfc_dev->dev_data,
-                vb_migrate_scene_register_worker_read_initial_callback,
-                inst);
+            inst->poller = nfc_poller_alloc(inst->nfc, NfcProtocolMfUltralight);
+            nfc_poller_start(
+                inst->poller, vb_migrate_scene_register_worker_read_initial_callback, inst);
             vb_migrate_blink_read(inst);
         } else if(state == RegisterStateCaptureInvalidTag) {
             widget_reset(widget);
@@ -238,15 +253,14 @@ static void vb_migrate_scene_register_set_state(VbMigrate* inst, RegisterState s
 
             view_dispatcher_switch_to_view(inst->view_dispatcher, VbMigrateViewWidget);
 
-            BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+            nfc_device_copy_data(inst->nfc_dev, NfcProtocolMfUltralight, inst->data_work);
+            BantBlock* bant = vb_tag_get_bant_block(inst->data_work);
             vb_tag_set_operation(bant, VbTagOperationReady);
             vb_tag_set_status(bant, VbTagStatusReady);
-            nfc_worker_start(
-                inst->worker,
-                NfcWorkerStateMfUltralightEmulate,
-                &inst->nfc_dev->dev_data,
-                vb_migrate_scene_register_worker_auth_callback,
-                inst);
+            inst->listener =
+                nfc_listener_alloc(inst->nfc, NfcProtocolMfUltralight, inst->data_work);
+            nfc_listener_start(
+                inst->listener, vb_migrate_scene_register_worker_auth_callback, inst);
             vb_migrate_blink_emulate(inst);
         } else if(state == RegisterStateCaptureFull) {
             widget_reset(widget);
@@ -264,13 +278,10 @@ static void vb_migrate_scene_register_set_state(VbMigrate* inst, RegisterState s
 
             view_dispatcher_switch_to_view(inst->view_dispatcher, VbMigrateViewWidget);
 
-            inst->nfc_dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodAuto;
-            nfc_worker_start(
-                inst->worker,
-                NfcWorkerStateReadMfUltralightReadAuth,
-                &inst->nfc_dev->dev_data,
-                vb_migrate_scene_register_worker_full_capture_callback,
-                inst);
+            // TODO: run detect before starting poller (need a worker thread)?
+            inst->poller = nfc_poller_alloc(inst->nfc, NfcProtocolMfUltralight);
+            nfc_poller_start(
+                inst->poller, vb_migrate_scene_register_worker_full_capture_callback, inst);
             vb_migrate_blink_read(inst);
         } else if(state == RegisterStateCaptureFailed) {
             widget_reset(widget);
@@ -364,11 +375,11 @@ bool vb_migrate_scene_register_on_event(void* context, SceneManagerEvent event)
         } else if(event.event == RegisterEventTypePrevButton) {
             consumed = vb_migrate_scene_register_prev_state(inst, state, false);
         } else if(event.event == RegisterEventTypeVbReadInitial) {
-            if(vb_tag_validate_product(&inst->nfc_dev->dev_data)) {
+            const MfUltralightData* data =
+                nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+            if(vb_tag_validate_product(data)) {
                 memcpy(
-                    inst->captured_uid,
-                    inst->nfc_dev->dev_data.nfc_data.uid,
-                    sizeof(inst->captured_uid));
+                    inst->captured_uid, data->iso14443_3a_data->uid, sizeof(inst->captured_uid));
                 notification_message(inst->notifications, &sequence_success);
                 vb_migrate_scene_register_set_state(inst, RegisterStateCapturePwd);
             } else {
@@ -377,19 +388,15 @@ bool vb_migrate_scene_register_on_event(void* context, SceneManagerEvent event)
             }
             consumed = true;
         } else if(event.event == RegisterEventTypeVbPwdAuth) {
-            // Set up for auth
-            memcpy(
-                inst->captured_pwd,
-                inst->nfc_dev->dev_data.mf_ul_auth.pwd.raw,
-                sizeof(inst->captured_pwd));
-
             notification_message(inst->notifications, &sequence_success);
             vb_migrate_scene_register_set_state(inst, RegisterStateCaptureFull);
             consumed = true;
         } else if(event.event == RegisterEventTypeVbReadFullSuccess) {
-            NfcDeviceData* dev_data = &inst->nfc_dev->dev_data;
-            if(memcmp(dev_data->nfc_data.uid, inst->captured_uid, sizeof(inst->captured_uid)) ||
-               dev_data->mf_ul_data.data_read != dev_data->mf_ul_data.data_size) {
+            const MfUltralightData* data =
+                nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+            if(memcmp(
+                   data->iso14443_3a_data->uid, inst->captured_uid, sizeof(inst->captured_uid)) ||
+               data->pages_read != data->pages_total) {
                 notification_message(inst->notifications, &sequence_error);
                 vb_migrate_scene_register_set_state(inst, RegisterStateCaptureIncorrectTag);
             } else {

apps_broken_by_last_refactors/flipperzero_vb_migrate/scenes/vb_migrate_scene_register_save.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -50,12 +50,12 @@ void vb_migrate_scene_register_save_on_enter(void* context) {
 
     // Set default name
     FuriString* temp_str;
-    NfcDeviceData* dev_data = &inst->nfc_dev->dev_data;
-    BantBlock* bant = vb_tag_get_bant_block(dev_data);
+    const MfUltralightData* data = nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+    const BantBlock* bant = vb_tag_get_bant_block_const(data);
     const VbTagProduct* prod = vb_tag_find_product(bant);
     temp_str = furi_string_alloc_printf("%s_", prod->short_name);
-    for(size_t i = 0; i < dev_data->nfc_data.uid_len; ++i) {
-        furi_string_cat_printf(temp_str, "%02x", dev_data->nfc_data.uid[i]);
+    for(size_t i = 0; i < data->iso14443_3a_data->uid_len; ++i) {
+        furi_string_cat_printf(temp_str, "%02x", data->iso14443_3a_data->uid[i]);
     }
     vb_migrate_text_store_set(inst, furi_string_get_cstr(temp_str));
     furi_string_free(temp_str);
@@ -80,7 +80,9 @@ bool vb_migrate_scene_register_save_on_event(void* context, SceneManagerEvent ev
                 if(vb_migrate_save_nfc(inst, inst->text_store, VB_MIGRATE_TEMPLATE_NAME)) {
                     inst->num_captured = 0;
 
-                    BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+                    const MfUltralightData* data =
+                        nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+                    const BantBlock* bant = vb_tag_get_bant_block_const(data);
                     const VbTagProduct* product = vb_tag_find_product(bant);
                     inst->orig_product = product;
                     if(product) {

apps_broken_by_last_refactors/flipperzero_vb_migrate/scenes/vb_migrate_scene_to_app.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -52,20 +52,29 @@ static void
     }
 }
 
-static bool vb_migrate_scene_to_app_worker_callback(NfcWorkerEvent event, void* context) {
+static NfcCommand vb_migrate_scene_to_app_worker_callback(NfcGenericEvent event, void* context) {
     VbMigrate* inst = context;
-    bool result = false;
-
-    if(event == NfcWorkerEventSuccess) {
-        view_dispatcher_send_custom_event(inst->view_dispatcher, ToAppEventTypeTagWrite);
-        result = true;
+    NfcCommand result = NfcCommandContinue;
+
+    if(event.protocol == NfcProtocolInvalid) {
+        NfcEvent* nfc_event = event.event_data;
+        if(nfc_event->type == NfcEventTypeRxEnd) {
+            const MfUltralightData* data =
+                nfc_listener_get_data(inst->listener, NfcProtocolMfUltralight);
+            const BantBlock* bant = vb_tag_get_bant_block_const(data);
+            if(vb_tag_get_operation(bant) == VbTagOperationTransferToApp) {
+                nfc_device_set_data(inst->nfc_dev, NfcProtocolMfUltralight, data);
+                view_dispatcher_send_custom_event(inst->view_dispatcher, ToAppEventTypeTagWrite);
+            }
+        }
     }
 
     return result;
 }
 
 static void vb_migrate_scene_to_app_set_nfc_state(VbMigrate* inst, ToAppState state) {
-    BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+    nfc_device_copy_data(inst->nfc_dev, NfcProtocolMfUltralight, inst->data_work);
+    BantBlock* bant = vb_tag_get_bant_block(inst->data_work);
     if(state == ToAppStateEmulateReady) {
         vb_tag_set_random_nonce(bant);
         vb_tag_set_status(bant, VbTagStatusReady);
@@ -80,10 +89,12 @@ static void vb_migrate_scene_to_app_set_nfc_state(VbMigrate* inst, ToAppState st
     if(inst->clear_account_id) {
         vb_tag_set_app_flag(bant, false);
     }
+    nfc_device_set_data(inst->nfc_dev, NfcProtocolMfUltralight, inst->data_work);
 }
 
 static bool vb_migrate_scene_to_app_is_state_changed(VbMigrate* inst, ToAppState state) {
-    BantBlock* bant = vb_tag_get_bant_block(&inst->nfc_dev->dev_data);
+    const MfUltralightData* data = nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+    const BantBlock* bant = vb_tag_get_bant_block_const(data);
     VbTagOperation operation = vb_tag_get_operation(bant);
 
     if(state == ToAppStateEmulateReady) {
@@ -183,7 +194,9 @@ static void vb_migrate_scene_to_app_set_state(VbMigrate* inst, ToAppState state)
 
 static void vb_migrate_scene_to_app_load_capture(VbMigrate* inst, bool go_next) {
     if(go_next) {
-        nfc_worker_stop(inst->worker);
+        nfc_listener_stop(inst->listener);
+        nfc_listener_free(inst->listener);
+        inst->listener = NULL;
         vb_migrate_blink_stop(inst);
         ++inst->next_id;
         ++inst->num_sent;
@@ -194,8 +207,8 @@ static void vb_migrate_scene_to_app_load_capture(VbMigrate* inst, bool go_next)
     } else {
         uint32_t state = scene_manager_get_scene_state(inst->scene_manager, VbMigrateSceneToApp);
         inst->next_id = vb_migrate_get_next_id(inst, inst->text_store, inst->next_id, true);
-        FuriString* temp_str = furi_string_alloc_printf(
-            VB_MIGRATE_CAPTURE_FORMAT, inst->next_id, NFC_APP_EXTENSION);
+        FuriString* temp_str =
+            furi_string_alloc_printf(VB_MIGRATE_CAPTURE_FORMAT, inst->next_id, NFC_APP_EXTENSION);
 
         vb_migrate_show_loading_popup(inst, true);
         if(vb_migrate_load_nfc(inst, inst->text_store, furi_string_get_cstr(temp_str))) {
@@ -222,12 +235,11 @@ static void vb_migrate_scene_to_app_load_capture(VbMigrate* inst, bool go_next)
             view_dispatcher_switch_to_view(inst->view_dispatcher, VbMigrateViewWidget);
 
             vb_migrate_scene_to_app_set_nfc_state(inst, state);
-            nfc_worker_start(
-                inst->worker,
-                NfcWorkerStateMfUltralightEmulate,
-                &inst->nfc_dev->dev_data,
-                vb_migrate_scene_to_app_worker_callback,
-                inst);
+
+            const NfcDeviceData* data =
+                nfc_device_get_data(inst->nfc_dev, NfcProtocolMfUltralight);
+            inst->listener = nfc_listener_alloc(inst->nfc, NfcProtocolMfUltralight, data);
+            nfc_listener_start(inst->listener, vb_migrate_scene_to_app_worker_callback, inst);
             vb_migrate_blink_emulate(inst);
         } else {
             view_dispatcher_send_custom_event(
@@ -291,7 +303,11 @@ void vb_migrate_scene_to_app_on_exit(void* context) {
 
     // Perform your cleanup here
     widget_reset(inst->widget);
-    nfc_worker_stop(inst->worker);
+    if(inst->listener) {
+        nfc_listener_stop(inst->listener);
+        nfc_listener_free(inst->listener);
+        inst->listener = NULL;
+    }
     vb_migrate_blink_stop(inst);
     notification_message_block(inst->notifications, &sequence_reset_red);
 }

apps_broken_by_last_refactors/flipperzero_vb_migrate/vb_migrate.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -70,7 +70,6 @@ bool vb_migrate_save_nfc(VbMigrate* inst, const char* dev_name, const char* file
             break;
         }
         furi_string_cat_printf(temp_str, "/%s", file_name);
-        inst->nfc_dev->format = NfcDeviceSaveFormatMifareUl;
         saved = nfc_device_save(inst->nfc_dev, furi_string_get_cstr(temp_str));
     } while(false);
 
@@ -79,13 +78,13 @@ bool vb_migrate_save_nfc(VbMigrate* inst, const char* dev_name, const char* file
 }
 
 bool vb_migrate_load_nfc(VbMigrate* inst, const char* dev_name, const char* file_name) {
-    bool saved = false;
+    bool loaded = false;
     FuriString* temp_str =
         furi_string_alloc_printf("%s/%s/%s", VB_MIGRATE_FOLDER, dev_name, file_name);
-    saved = nfc_device_load(inst->nfc_dev, furi_string_get_cstr(temp_str), true);
+    loaded = nfc_device_load(inst->nfc_dev, furi_string_get_cstr(temp_str));
 
     furi_string_free(temp_str);
-    return saved;
+    return loaded;
 }
 
 bool vb_migrate_delete(VbMigrate* inst, const char* dev_name, bool whole_vb) {
@@ -102,8 +101,7 @@ bool vb_migrate_delete(VbMigrate* inst, const char* dev_name, bool whole_vb) {
             FuriString* file_path = furi_string_alloc();
             while(storage_dir_read(dir_handle, &file_info, name, sizeof(name))) {
                 // Files that is .nfc, but is not template
-                if(!(file_info.flags & FSF_DIRECTORY) &&
-                   strstr(name, NFC_APP_EXTENSION) &&
+                if(!(file_info.flags & FSF_DIRECTORY) && strstr(name, NFC_APP_EXTENSION) &&
                    !strstr(name, VB_MIGRATE_TEMPLATE_NAME)) {
                     furi_string_printf(file_path, "%s/%s", furi_string_get_cstr(dir_path), name);
                     deleted =
@@ -169,7 +167,6 @@ int vb_migrate_get_next_id(VbMigrate* inst, const char* dev_name, int i, bool is
 }
 
 void vb_migrate_show_loading_popup(VbMigrate* inst, bool show) {
-
     if(show) {
         // Raise timer priority so that animations can play
         furi_timer_set_thread_priority(FuriTimerThreadPriorityElevated);
@@ -207,8 +204,9 @@ VbMigrate* vb_migrate_alloc() {
     inst->dialogs = furi_record_open(RECORD_DIALOGS);
 
     // NFC
+    inst->nfc = nfc_alloc();
     inst->nfc_dev = nfc_device_alloc();
-    inst->worker = nfc_worker_alloc();
+    inst->data_work = mf_ultralight_alloc();
 
     // Submenu
     inst->submenu = submenu_alloc();
@@ -289,8 +287,9 @@ void vb_migrate_free(VbMigrate* inst) {
     submenu_free(inst->submenu);
 
     // NFC
-    nfc_worker_free(inst->worker);
+    mf_ultralight_free(inst->data_work);
     nfc_device_free(inst->nfc_dev);
+    nfc_free(inst->nfc);
 
     furi_record_close(RECORD_DIALOGS);
     furi_record_close(RECORD_NOTIFICATION);

apps_broken_by_last_refactors/flipperzero_vb_migrate/vb_migrate_i.h

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -34,7 +34,10 @@
 #include <notification/notification.h>
 #include <dialogs/dialogs.h>
 
-#include <lib/nfc/nfc_worker.h>
+#include <lib/nfc/nfc.h>
+#include <lib/nfc/nfc_device.h>
+#include <lib/nfc/nfc_listener.h>
+#include <lib/nfc/nfc_poller.h>
 
 #include "vb_migrate.h"
 #include "scenes/vb_migrate_scene.h"
@@ -42,6 +45,7 @@
 
 #include "vb_migrate_icons.h"
 
+#define NFC_APP_EXTENSION ".nfc"
 #define VB_MIGRATE_TEMPLATE_NAME "template" NFC_APP_EXTENSION
 #define VB_MIGRATE_CAPTURE_FORMAT "%03d%s"
 
@@ -62,10 +66,13 @@ struct VbMigrate {
     TextInput* text_input;
     Loading* loading;
     VariableItemListEx* variable_list;
-    NfcWorker* worker;
+    Nfc* nfc;
+    NfcListener* listener;
+    NfcPoller* poller;
     NfcDevice* nfc_dev;
+    MfUltralightData* data_work;
     char text_store[128];
-    uint8_t captured_pwd[4];
+    uint8_t captured_pwd[MF_ULTRALIGHT_AUTH_PASSWORD_SIZE];
     uint8_t captured_uid[7];
     bool clear_account_id;
     int num_captured;

apps_broken_by_last_refactors/flipperzero_vb_migrate/vb_tag.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -114,8 +114,12 @@ static const char* vb_tag_type_names[] = {
     VB_NAME_VBBE_SHORT,
 };
 
-BantBlock* vb_tag_get_bant_block(NfcDeviceData* dev) {
-    return (BantBlock*)&dev->mf_ul_data.data[16];
+BantBlock* vb_tag_get_bant_block(MfUltralightData* data) {
+    return (BantBlock*)&data->page[4].data;
+}
+
+const BantBlock* vb_tag_get_bant_block_const(const MfUltralightData* data) {
+    return (BantBlock*)&data->page[4].data;
 }
 
 const VbTagProduct* vb_tag_find_product(const BantBlock* bant) {
@@ -128,12 +132,11 @@ const VbTagProduct* vb_tag_find_product(const BantBlock* bant) {
     return NULL;
 }
 
-bool vb_tag_validate_product(NfcDeviceData* dev) {
+bool vb_tag_validate_product(const MfUltralightData* data) {
     // Must be NTAG I2C Plus 1k
-    if(dev->protocol != NfcDeviceProtocolMifareUl) return false;
-    if(dev->mf_ul_data.type != MfUltralightTypeNTAGI2CPlus1K) return false;
+    if(data->type != MfUltralightTypeNTAGI2CPlus1K) return false;
     // Must match one of the known product IDs
-    BantBlock* bant = vb_tag_get_bant_block(dev);
+    const BantBlock* bant = vb_tag_get_bant_block_const(data);
     if(bant->common.magic != BANT_MAGIC) return false;
     return vb_tag_find_product(bant) != NULL;
 }

apps_broken_by_last_refactors/flipperzero_vb_migrate/vb_tag.h

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 // VB Lab Migration Assistant for Flipper Zero
-// Copyright (C) 2022  cyanic
+// Copyright (C) 2022-2024  cyanic
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -19,7 +19,7 @@
 #pragma once
 
 #include <furi.h>
-#include <lib/nfc/nfc_device.h>
+#include <lib/nfc/protocols/mf_ultralight/mf_ultralight.h>
 
 #define BANT_MAGIC (0x544E4142)
 
@@ -60,9 +60,10 @@ typedef enum {
     VbTagOperationSpotCommit,
 } VbTagOperation;
 
-BantBlock* vb_tag_get_bant_block(NfcDeviceData* dev);
+BantBlock* vb_tag_get_bant_block(MfUltralightData* data);
+const BantBlock* vb_tag_get_bant_block_const(const MfUltralightData* data);
 const VbTagProduct* vb_tag_find_product(const BantBlock* bant);
-bool vb_tag_validate_product(NfcDeviceData* dev);
+bool vb_tag_validate_product(const MfUltralightData* data);
 VbTagStatus vb_tag_get_status(const BantBlock* bant);
 void vb_tag_set_status(BantBlock* bant, VbTagStatus status);
 VbTagOperation vb_tag_get_operation(const BantBlock* bant);