Initial MFPlus draft

applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus.c

@@ -0,0 +1,116 @@
+#include "mf_plus.h"
+#include "mf_plus_render.h"
+
+#include <nfc/protocols/mf_plus/mf_plus_poller.h>
+
+#include "nfc/nfc_app_i.h"
+
+#include "../nfc_protocol_support_common.h"
+#include "../nfc_protocol_support_gui_common.h"
+#include "../iso14443_4a/iso14443_4a_i.h"
+
+static void nfc_scene_info_on_enter_mf_plus(NfcApp* instance) {
+    const NfcDevice* device = instance->nfc_device;
+    const MfPlusData* data = nfc_device_get_data(device, NfcProtocolMfPlus);
+
+    FuriString* temp_str = furi_string_alloc();
+    nfc_append_filename_string_when_present(instance, temp_str);
+    furi_string_cat_printf(
+        temp_str, "\e#%s\n", nfc_device_get_name(device, NfcDeviceNameTypeFull));
+    furi_string_replace(temp_str, "Mifare", "MIFARE");
+    nfc_render_mf_plus_info(data, NfcProtocolFormatTypeFull, temp_str);
+
+    widget_add_text_scroll_element(
+        instance->widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
+
+    furi_string_free(temp_str);
+}
+static NfcCommand nfc_scene_read_poller_callback_mf_plus(NfcGenericEvent event, void* context) {
+    furi_assert(event.protocol == NfcProtocolMfPlus);
+
+    NfcApp* instance = context;
+    const MfPlusPollerEvent* mf_plus_event = event.event_data;
+
+    if(mf_plus_event->type == MfPlusPollerEventTypeReadSuccess) {
+        nfc_device_set_data(
+            instance->nfc_device, NfcProtocolMfPlus, nfc_poller_get_data(instance->poller));
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventPollerSuccess);
+        return NfcCommandStop;
+    }
+
+    return NfcCommandContinue;
+}
+
+static void nfc_scene_read_on_enter_mf_plus(NfcApp* instance) {
+    nfc_poller_start(instance->poller, nfc_scene_read_poller_callback_mf_plus, instance);
+}
+
+static void nfc_scene_read_success_on_enter_mf_plus(NfcApp* instance) {
+    const NfcDevice* device = instance->nfc_device;
+    const MfPlusData* data = nfc_device_get_data(device, NfcProtocolMfPlus);
+
+    FuriString* temp_str = furi_string_alloc();
+    furi_string_cat_printf(
+        temp_str, "\e#%s\n", nfc_device_get_name(device, NfcDeviceNameTypeFull));
+    nfc_render_mf_plus_info(data, NfcProtocolFormatTypeFull, temp_str);
+
+    widget_add_text_scroll_element(
+        instance->widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
+
+    furi_string_free(temp_str);
+}
+
+static void nfc_scene_emulate_on_enter_mf_plus(NfcApp* instance) {
+    const Iso14443_4aData* iso14443_4a_data =
+        nfc_device_get_data(instance->nfc_device, NfcProtocolIso14443_4a);
+
+    instance->listener =
+        nfc_listener_alloc(instance->nfc, NfcProtocolIso14443_4a, iso14443_4a_data);
+    nfc_listener_start(
+        instance->listener, nfc_scene_emulate_listener_callback_iso14443_4a, instance);
+}
+
+const NfcProtocolSupportBase nfc_protocol_support_mf_plus = {
+    .features = NfcProtocolFeatureMoreInfo,
+
+    .scene_info =
+        {
+            .on_enter = nfc_scene_info_on_enter_mf_plus,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_more_info =
+        {
+            .on_enter = nfc_protocol_support_common_on_enter_empty,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_read =
+        {
+            .on_enter = nfc_scene_read_on_enter_mf_plus,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_read_menu =
+        {
+            .on_enter = nfc_protocol_support_common_on_enter_empty,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_read_success =
+        {
+            .on_enter = nfc_scene_read_success_on_enter_mf_plus,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_saved_menu =
+        {
+            .on_enter = nfc_protocol_support_common_on_enter_empty,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_save_name =
+        {
+            .on_enter = nfc_protocol_support_common_on_enter_empty,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_emulate =
+        {
+            .on_enter = nfc_scene_emulate_on_enter_mf_plus,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+};

applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "../nfc_protocol_support_base.h"
+
+extern const NfcProtocolSupportBase nfc_protocol_support_mf_plus;

applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus_render.c

@@ -0,0 +1,67 @@
+#include "mf_plus_render.h"
+
+#include "../iso14443_4a/iso14443_4a_render.h"
+
+void nfc_render_mf_plus_info(
+    const MfPlusData* data,
+    NfcProtocolFormatType format_type,
+    FuriString* str) {
+    nfc_render_iso14443_4a_brief(mf_plus_get_base_data(data), str);
+
+    if(format_type != NfcProtocolFormatTypeFull) return;
+
+    furi_string_cat(str, "\n\e#ISO14443-4 data");
+    nfc_render_iso14443_4a_extra(mf_plus_get_base_data(data), str);
+}
+
+void nfc_render_mf_plus_data(const MfPlusData* data, FuriString* str) {
+    nfc_render_mf_plus_version(&data->version, str);
+}
+
+void nfc_render_mf_plus_version(const MfPlusVersion* data, FuriString* str) {
+    furi_string_cat_printf(
+        str,
+        "%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
+        data->uid[0],
+        data->uid[1],
+        data->uid[2],
+        data->uid[3],
+        data->uid[4],
+        data->uid[5],
+        data->uid[6]);
+    furi_string_cat_printf(
+        str,
+        "hw %02x type %02x sub %02x\n"
+        " maj %02x min %02x\n"
+        " size %02x proto %02x\n",
+        data->hw_vendor,
+        data->hw_type,
+        data->hw_subtype,
+        data->hw_major,
+        data->hw_minor,
+        data->hw_storage,
+        data->hw_proto);
+    furi_string_cat_printf(
+        str,
+        "sw %02x type %02x sub %02x\n"
+        " maj %02x min %02x\n"
+        " size %02x proto %02x\n",
+        data->sw_vendor,
+        data->sw_type,
+        data->sw_subtype,
+        data->sw_major,
+        data->sw_minor,
+        data->sw_storage,
+        data->sw_proto);
+    furi_string_cat_printf(
+        str,
+        "batch %02x:%02x:%02x:%02x:%02x\n"
+        "week %d year %d\n",
+        data->batch[0],
+        data->batch[1],
+        data->batch[2],
+        data->batch[3],
+        data->batch[4],
+        data->prod_week,
+        data->prod_year);
+}

applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus_render.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <nfc/protocols/mf_plus/mf_plus.h>
+
+#include "../nfc_protocol_support_render_common.h"
+
+void nfc_render_mf_plus_info(
+    const MfPlusData* data,
+    NfcProtocolFormatType format_type,
+    FuriString* str);
+
+void nfc_render_mf_plus_data(const MfPlusData* data, FuriString* str);
+
+void nfc_render_mf_plus_version(const MfPlusVersion* data, FuriString* str);

applications/main/nfc/helpers/protocol_support/nfc_protocol_support_defs.c

@@ -17,6 +17,7 @@
 #include "felica/felica.h"
 #include "mf_ultralight/mf_ultralight.h"
 #include "mf_classic/mf_classic.h"
+#include "mf_plus/mf_plus.h"
 #include "mf_desfire/mf_desfire.h"
 #include "slix/slix.h"
 #include "st25tb/st25tb.h"
@@ -38,6 +39,7 @@ const NfcProtocolSupportBase* nfc_protocol_support[NfcProtocolNum] = {
     [NfcProtocolFelica] = &nfc_protocol_support_felica,
     [NfcProtocolMfUltralight] = &nfc_protocol_support_mf_ultralight,
     [NfcProtocolMfClassic] = &nfc_protocol_support_mf_classic,
+    [NfcProtocolMfPlus] = &nfc_protocol_support_mf_plus,
     [NfcProtocolMfDesfire] = &nfc_protocol_support_mf_desfire,
     [NfcProtocolSlix] = &nfc_protocol_support_slix,
     [NfcProtocolSt25tb] = &nfc_protocol_support_st25tb,

lib/nfc/SConscript

@@ -21,6 +21,7 @@ env.Append(
         File("protocols/iso14443_4b/iso14443_4b.h"),
         File("protocols/mf_ultralight/mf_ultralight.h"),
         File("protocols/mf_classic/mf_classic.h"),
+        File("protocols/mf_plus/mf_plus.h"),
         File("protocols/mf_desfire/mf_desfire.h"),
         File("protocols/slix/slix.h"),
         File("protocols/st25tb/st25tb.h"),
@@ -31,6 +32,7 @@ env.Append(
         File("protocols/iso14443_4b/iso14443_4b_poller.h"),
         File("protocols/mf_ultralight/mf_ultralight_poller.h"),
         File("protocols/mf_classic/mf_classic_poller.h"),
+        File("protocols/mf_plus/mf_plus_poller.h"),
         File("protocols/mf_desfire/mf_desfire_poller.h"),
         File("protocols/st25tb/st25tb_poller.h"),
         # Listeners

lib/nfc/protocols/mf_plus/mf_plus.c

@@ -0,0 +1,114 @@
+#include "mf_plus.h"
+
+#include <bit_lib/bit_lib.h>
+#include <furi.h>
+
+#define MF_PLUS_PROTOCOL_NAME "Mifare Plus"
+
+const NfcDeviceBase nfc_device_mf_plus = {
+    .protocol_name = MF_PLUS_PROTOCOL_NAME,
+    .alloc = (NfcDeviceAlloc)mf_plus_alloc,
+    .free = (NfcDeviceFree)mf_plus_free,
+    .reset = (NfcDeviceReset)mf_plus_reset,
+    .copy = (NfcDeviceCopy)mf_plus_copy,
+    .verify = (NfcDeviceVerify)mf_plus_verify,
+    .load = (NfcDeviceLoad)mf_plus_load,
+    .save = (NfcDeviceSave)mf_plus_save,
+    .is_equal = (NfcDeviceEqual)mf_plus_is_equal,
+    .get_name = (NfcDeviceGetName)mf_plus_get_device_name,
+    .get_uid = (NfcDeviceGetUid)mf_plus_get_uid,
+    .set_uid = (NfcDeviceSetUid)mf_plus_set_uid,
+    .get_base_data = (NfcDeviceGetBaseData)mf_plus_get_base_data,
+};
+
+MfPlusData* mf_plus_alloc() {
+    MfPlusData* data = malloc(sizeof(MfPlusData));
+    data->iso14443_4a_data = iso14443_4a_alloc();
+    return data;
+}
+
+void mf_plus_free(MfPlusData* data) {
+    furi_check(data);
+    iso14443_4a_free(data->iso14443_4a_data);
+    free(data);
+}
+
+void mf_plus_reset(MfPlusData* data) {
+    furi_check(data);
+    iso14443_4a_reset(data->iso14443_4a_data);
+}
+
+void mf_plus_copy(MfPlusData* data, const MfPlusData* other) {
+    furi_check(data);
+    furi_check(other);
+    iso14443_4a_copy(data->iso14443_4a_data, other->iso14443_4a_data);
+}
+
+bool mf_plus_verify(MfPlusData* data, const FuriString* device_type) {
+    UNUSED(data);
+    return furi_string_equal_str(device_type, MF_PLUS_PROTOCOL_NAME);
+}
+
+bool mf_plus_load(MfPlusData* data, FlipperFormat* ff, uint32_t version) {
+    // TODO
+    UNUSED(data);
+    UNUSED(ff);
+    UNUSED(version);
+    return true;
+}
+
+bool mf_plus_save(const MfPlusData* data, FlipperFormat* ff) {
+    // TODO
+    UNUSED(data);
+    UNUSED(ff);
+    return true;
+}
+
+bool mf_plus_is_equal(const MfPlusData* data, const MfPlusData* other) {
+    furi_check(data);
+    furi_check(other);
+
+    bool equal = false;
+
+    do {
+        if(!iso14443_4a_is_equal(data->iso14443_4a_data, other->iso14443_4a_data)) break;
+
+        equal = true;
+    } while(false);
+
+    return equal;
+}
+
+const char* mf_plus_get_device_name(const MfPlusData* data, NfcDeviceNameType name_type) {
+    furi_check(data);
+
+    const char* name = NULL;
+
+    do {
+        if(name_type == NfcDeviceNameTypeFull) {
+            name = "Mifare Plus";
+        } else if(name_type == NfcDeviceNameTypeShort) {
+            name = "Mifare Plus";
+        } else {
+            break;
+        }
+    } while(false);
+
+    return name;
+}
+
+const uint8_t* mf_plus_get_uid(const MfPlusData* data, size_t* uid_len) {
+    furi_assert(data);
+
+    return iso14443_4a_get_uid(data->iso14443_4a_data, uid_len);
+}
+
+bool mf_plus_set_uid(MfPlusData* data, const uint8_t* uid, size_t uid_len) {
+    furi_assert(data);
+
+    return iso14443_4a_set_uid(data->iso14443_4a_data, uid, uid_len);
+}
+Iso14443_4aData* mf_plus_get_base_data(const MfPlusData* data) {
+    furi_check(data);
+    return data->iso14443_4a_data;
+}

lib/nfc/protocols/mf_plus/mf_plus.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a.h>
+
+#include <lib/toolbox/simple_array.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MF_PLUS_UID_SIZE (7)
+#define MF_PLUS_BATCH_SIZE (5)
+
+#define MF_PLUS_CMD_GET_VERSION (0x60)
+
+typedef enum {
+    MfPlusErrorNone,
+    MfPlusErrorUnknown,
+    MfPlusErrorNotPresent,
+    MfPlusErrorProtocol,
+    MfPlusErrorAuth,
+    MfPlusErrorPartialRead,
+    MfPlusErrorTimeout,
+} MfPlusError;
+
+typedef enum {
+    MfPlusTypePlus,
+    MfPlusTypeEV1,
+    MfPlusTypeEV2,
+    MfPlusTypeS,
+    MfPlusTypeSE,
+    MfPlusTypeX,
+
+    MfPlusTypeUnknown,
+    MfPlusTypeNum,
+} MfPlusType;
+
+typedef enum {
+    MfPlusSize1K,
+    MfPlusSize2K,
+    MfPlusSize4K,
+
+    MfPlusSizeUnknown,
+    MfPlusSizeNum,
+} MfPlusSize;
+
+typedef enum {
+    MfPlusSecurityLevel0,
+    MfPlusSecurityLevel1,
+    MfPlusSecurityLevel2,
+    MfPlusSecurityLevel3,
+
+    MfPlusSecurityLevelUnknown,
+    MfPlusSecurityLevelNum,
+} MfPlusSecurityLevel;
+
+typedef struct {
+    uint8_t hw_vendor;
+    uint8_t hw_type;
+    uint8_t hw_subtype;
+    uint8_t hw_major;
+    uint8_t hw_minor;
+    uint8_t hw_storage;
+    uint8_t hw_proto;
+
+    uint8_t sw_vendor;
+    uint8_t sw_type;
+    uint8_t sw_subtype;
+    uint8_t sw_major;
+    uint8_t sw_minor;
+    uint8_t sw_storage;
+    uint8_t sw_proto;
+
+    uint8_t uid[MF_PLUS_UID_SIZE];
+    uint8_t batch[MF_PLUS_BATCH_SIZE];
+    uint8_t prod_week;
+    uint8_t prod_year;
+} MfPlusVersion;
+
+typedef struct {
+    Iso14443_4aData* iso14443_4a_data;
+    MfPlusVersion version;
+    MfPlusType type;
+    MfPlusSize size;
+    MfPlusSecurityLevel security_level;
+} MfPlusData;
+
+MfPlusData* mf_plus_alloc();
+
+void mf_plus_free(MfPlusData* data);
+
+void mf_plus_reset(MfPlusData* data);
+
+void mf_plus_copy(MfPlusData* data, const MfPlusData* other);
+
+bool mf_plus_verify(MfPlusData* data, const FuriString* device_type);
+
+bool mf_plus_load(MfPlusData* data, FlipperFormat* ff, uint32_t version);
+
+bool mf_plus_save(const MfPlusData* data, FlipperFormat* ff);
+
+bool mf_plus_is_equal(const MfPlusData* data, const MfPlusData* other);
+
+const char* mf_plus_get_device_name(const MfPlusData* data, NfcDeviceNameType name_type);
+
+const uint8_t* mf_plus_get_uid(const MfPlusData* data, size_t* uid_len);
+
+bool mf_plus_set_uid(MfPlusData* data, const uint8_t* uid, size_t uid_len);
+
+Iso14443_4aData* mf_plus_get_base_data(const MfPlusData* data);
+
+#ifdef __cplusplus
+}
+#endif

lib/nfc/protocols/mf_plus/mf_plus_i.c

@@ -0,0 +1,11 @@
+#include "mf_plus_i.h"
+
+bool mf_plus_version_parse(MfPlusVersion* data, const BitBuffer* buf) {
+    const bool can_parse = bit_buffer_get_size_bytes(buf) == sizeof(MfPlusVersion);
+
+    if(can_parse) {
+        bit_buffer_write_bytes(buf, data, sizeof(MfPlusVersion));
+    }
+
+    return can_parse;
+}

lib/nfc/protocols/mf_plus/mf_plus_i.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "mf_plus.h"
+
+bool mf_plus_version_parse(MfPlusVersion* data, const BitBuffer* buf);

lib/nfc/protocols/mf_plus/mf_plus_poller.c

@@ -0,0 +1,160 @@
+#include "mf_plus_poller_i.h"
+
+#include <nfc/protocols/nfc_poller_base.h>
+
+#include <furi.h>
+
+#define TAG "MfPlusPoller"
+
+#define MF_PLUS_BUF_SIZE (64U)
+#define MF_PLUS_RESULT_BUF_SIZE (512U)
+
+typedef NfcCommand (*MfPlusPollerReadHandler)(MfPlusPoller* instance);
+
+const MfPlusData* mf_plus_poller_get_data(MfPlusPoller* instance) {
+    furi_assert(instance);
+
+    return instance->data;
+}
+
+MfPlusPoller* mf_plus_poller_alloc(Iso14443_4aPoller* iso14443_4a_poller) {
+    furi_assert(iso14443_4a_poller);
+
+    MfPlusPoller* instance = malloc(sizeof(MfPlusPoller));
+    furi_assert(instance);
+
+    instance->iso14443_4a_poller = iso14443_4a_poller;
+
+    instance->data = mf_plus_alloc();
+
+    instance->general_event.protocol = NfcProtocolMfPlus;
+    instance->general_event.event_data = &instance->mfp_event;
+    instance->general_event.instance = instance;
+
+    instance->mfp_event.data = &instance->mfp_event_data;
+
+    return instance;
+}
+
+static NfcCommand mf_plus_poller_handler_idle(MfPlusPoller* instance) {
+    furi_assert(instance);
+
+    bit_buffer_reset(instance->input_buffer);
+    bit_buffer_reset(instance->result_buffer);
+    bit_buffer_reset(instance->tx_buffer);
+    bit_buffer_reset(instance->rx_buffer);
+
+    iso14443_4a_copy(
+        instance->data->iso14443_4a_data,
+        iso14443_4a_poller_get_data(instance->iso14443_4a_poller));
+
+    instance->state = MfPlusPollerStateReadVersion;
+    return NfcCommandContinue;
+}
+
+static NfcCommand mf_plus_poller_handler_read_version(MfPlusPoller* instance) {
+    instance->error = mf_plus_poller_read_version(instance, &instance->data->version);
+    if(instance->error == MfPlusErrorNone) {
+        instance->state = MfPlusPollerStateReadSuccess;
+    } else {
+        instance->state = MfPlusPollerStateReadFailed;
+    }
+
+    return NfcCommandContinue;
+}
+
+static NfcCommand mf_plus_poller_handler_read_failed(MfPlusPoller* instance) {
+    furi_assert(instance);
+    FURI_LOG_D(TAG, "Read failed");
+    iso14443_4a_poller_halt(instance->iso14443_4a_poller);
+    instance->mfp_event.data->error = instance->error;
+    NfcCommand command = instance->callback(instance->general_event, instance->context);
+    instance->state = MfPlusPollerStateIdle;
+    return command;
+}
+
+static NfcCommand mf_plus_poller_handler_read_success(MfPlusPoller* instance) {
+    furi_assert(instance);
+    FURI_LOG_D(TAG, "Read success");
+    iso14443_4a_poller_halt(instance->iso14443_4a_poller);
+    instance->mfp_event.type = MfPlusPollerEventTypeReadSuccess;
+    NfcCommand command = instance->callback(instance->general_event, instance->context);
+    instance->state = MfPlusPollerStateIdle;
+    return command;
+}
+
+static const MfPlusPollerReadHandler mf_plus_poller_read_handler[MfPlusPollerStateNum] = {
+    [MfPlusPollerStateIdle] = mf_plus_poller_handler_idle,
+    [MfPlusPollerStateReadVersion] = mf_plus_poller_handler_read_version,
+    [MfPlusPollerStateReadFailed] = mf_plus_poller_handler_read_failed,
+    [MfPlusPollerStateReadSuccess] = mf_plus_poller_handler_read_success,
+};
+
+static void mf_plus_poller_set_callback(
+    MfPlusPoller* instance,
+    NfcGenericCallback callback,
+    void* context) {
+    furi_assert(instance);
+    furi_assert(callback);
+
+    instance->callback = callback;
+    instance->context = context;
+}
+
+static NfcCommand mf_plus_poller_run(NfcGenericEvent event, void* context) {
+    furi_assert(event.protocol = NfcProtocolIso14443_4a);
+
+    MfPlusPoller* instance = context;
+    furi_assert(instance);
+
+    const Iso14443_4aPollerEvent* iso14443_4a_event = event.event_data;
+    furi_assert(iso14443_4a_event);
+
+    NfcCommand command = NfcCommandContinue;
+
+    if(iso14443_4a_event->type == Iso14443_4aPollerEventTypeReady) {
+        command = mf_plus_poller_read_handler[instance->state](instance);
+    } else if(iso14443_4a_event->type == Iso14443_4aPollerEventTypeError) {
+        instance->mfp_event.type = MfPlusPollerEventTypeReadFailed;
+        command = instance->callback(instance->general_event, instance->context);
+    }
+
+    return command;
+}
+
+void mf_plus_poller_free(MfPlusPoller* instance) {
+    furi_assert(instance);
+    furi_assert(instance->data);
+
+    mf_plus_free(instance->data);
+    free(instance);
+}
+
+bool mf_plus_poller_detect(NfcGenericEvent event, void* context) {
+    furi_assert(event.event_data);
+    furi_assert(event.protocol = NfcProtocolIso14443_4a);
+    furi_assert(context);
+
+    MfPlusPoller* instance = context;
+    furi_assert(instance);
+
+    Iso14443_4aPollerEvent* iso14443_4a_event = event.event_data;
+    bool detected = false;
+
+    if(iso14443_4a_event->type == Iso14443_4aPollerEventTypeReady) {
+        MfPlusVersion version = {};
+        const MfPlusError error = mf_plus_poller_read_version(instance, &version);
+        detected = (error == MfPlusErrorNone);
+    }
+
+    return detected;
+}
+
+const NfcPollerBase mf_plus_poller = {
+    .alloc = (NfcPollerAlloc)mf_plus_poller_alloc,
+    .free = (NfcPollerFree)mf_plus_poller_free,
+    .set_callback = (NfcPollerSetCallback)mf_plus_poller_set_callback,
+    .run = (NfcPollerRun)mf_plus_poller_run,
+    .detect = (NfcPollerDetect)mf_plus_poller_detect,
+    .get_data = (NfcPollerGetData)mf_plus_poller_get_data,
+};

lib/nfc/protocols/mf_plus/mf_plus_poller.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "mf_plus.h"
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MIFARE Plus poller opaque type definition.
+ */
+typedef struct MfPlusPoller MfPlusPoller;
+
+/**
+ * @brief Enumeration of possible MfPlus poller event types.
+ */
+
+typedef enum {
+    MfPlusPollerEventTypeReadSuccess, /**< Card was read successfully. */
+    MfPlusPollerEventTypeReadFailed, /**< Poller failed to read the card. */
+} MfPlusPollerEventType;
+
+/**
+ * @brief MIFARE Plus poller event data.
+ */
+typedef union {
+    MfPlusError error; /**< Error code indicating card reading fail reason. */
+} MfPlusPollerEventData;
+
+/**
+ * @brief MIFARE Plus poller event structure.
+ *
+ * Upon emission of an event, an instance of this struct will be passed to the callback.
+ */
+typedef struct {
+    MfPlusPollerEventType type; /**< Type of emitted event. */
+    MfPlusPollerEventData* data; /**< Pointer to event specific data. */
+} MfPlusPollerEvent;
+
+/**
+ * @brief Read MfPlus card version.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the MfPlusVersion structure to be filled with version data.
+ * @return MfPlusErrorNone on success, an error code on failure.
+ */
+MfPlusError mf_plus_poller_read_version(MfPlusPoller* instance, MfPlusVersion* data);
+
+#ifdef __cplusplus
+}
+#endif

lib/nfc/protocols/mf_plus/mf_plus_poller_i.c

@@ -0,0 +1,73 @@
+#include "mf_plus_poller_i.h"
+
+#include <furi.h>
+
+#include "mf_plus_i.h"
+
+#define TAG "MfPlusPoller"
+
+MfPlusError mf_plus_process_error(Iso14443_4aError error) {
+    switch(error) {
+    case Iso14443_4aErrorNone:
+        return MfPlusErrorNone;
+    case Iso14443_4aErrorNotPresent:
+        return MfPlusErrorNotPresent;
+    case Iso14443_4aErrorTimeout:
+        return MfPlusErrorTimeout;
+    default:
+        return MfPlusErrorProtocol;
+    }
+}
+
+MfPlusError
+    mf_plus_send_chunk(MfPlusPoller* instance, const BitBuffer* tx_buffer, BitBuffer* rx_buffer) {
+    furi_assert(instance);
+    furi_assert(instance->iso14443_4a_poller);
+    furi_assert(instance->tx_buffer);
+    furi_assert(instance->rx_buffer);
+    furi_assert(tx_buffer);
+    furi_assert(rx_buffer);
+
+    MfPlusError error = MfPlusErrorNone;
+
+    do {
+        Iso14443_4aError iso14443_4a_error = iso14443_4a_poller_send_block(
+            instance->iso14443_4a_poller, tx_buffer, instance->rx_buffer);
+
+        if(iso14443_4a_error != Iso14443_4aErrorNone) {
+            error = mf_plus_process_error(iso14443_4a_error);
+            break;
+        }
+
+        bit_buffer_reset(instance->tx_buffer);
+
+        if(bit_buffer_get_size_bytes(instance->rx_buffer) > sizeof(uint8_t)) {
+            bit_buffer_copy_right(rx_buffer, instance->rx_buffer, sizeof(uint8_t));
+        } else {
+            bit_buffer_reset(rx_buffer);
+        }
+    } while(false);
+
+    return error;
+}
+
+MfPlusError mf_plus_poller_read_version(MfPlusPoller* instance, MfPlusVersion* data) {
+    furi_assert(instance);
+
+    bit_buffer_reset(instance->input_buffer);
+    bit_buffer_append_byte(instance->input_buffer, MF_PLUS_CMD_GET_VERSION);
+
+    MfPlusError error;
+
+    do {
+        error = mf_plus_send_chunk(instance, instance->input_buffer, instance->result_buffer);
+
+        if(error != MfPlusErrorNone) break;
+
+        if(!mf_plus_version_parse(data, instance->result_buffer)) {
+            error = MfPlusErrorProtocol;
+        }
+    } while(false);
+
+    return error;
+}

lib/nfc/protocols/mf_plus/mf_plus_poller_i.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "mf_plus_poller.h"
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a_poller_i.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MF_PLUS_FWT_FC (60000)
+
+typedef enum {
+    MfPlusCardStateDetected,
+    MfPlusCardStateLost,
+} MfPlusCardState;
+
+typedef enum {
+    MfPlusPollerStateIdle,
+    MfPlusPollerStateReadVersion,
+    MfPlusPollerStateReadFailed,
+    MfPlusPollerStateReadSuccess,
+
+    MfPlusPollerStateNum,
+} MfPlusPollerState;
+
+struct MfPlusPoller {
+    Iso14443_4aPoller* iso14443_4a_poller;
+
+    MfPlusData* data;
+    MfPlusCardState card_state;
+    MfPlusPollerState state;
+
+    BitBuffer* tx_buffer;
+    BitBuffer* rx_buffer;
+    BitBuffer* input_buffer;
+    BitBuffer* result_buffer;
+
+    MfPlusError error;
+    NfcGenericEvent general_event;
+    MfPlusPollerEvent mfp_event;
+    MfPlusPollerEventData mfp_event_data;
+    NfcGenericCallback callback;
+    void* context;
+};
+
+MfPlusError mf_plus_process_error(Iso14443_4aError error);
+
+MfPlusPoller* mf_plus_poller_alloc(Iso14443_4aPoller* iso14443_4a_poller);
+
+void mf_plus_poller_free(MfPlusPoller* instance);
+
+#ifdef __cplusplus
+}
+#endif

lib/nfc/protocols/nfc_protocol.h

@@ -184,6 +184,7 @@ typedef enum {
     NfcProtocolFelica,
     NfcProtocolMfUltralight,
     NfcProtocolMfClassic,
+    NfcProtocolMfPlus,
     NfcProtocolMfDesfire,
     NfcProtocolSlix,
     NfcProtocolSt25tb,

targets/f7/api_symbols.csv

@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,58.0,,
+Version,+,58.2,,
 Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
@@ -149,6 +149,8 @@ Header,+,lib/nfc/protocols/mf_classic/mf_classic_poller.h,,
 Header,+,lib/nfc/protocols/mf_classic/mf_classic_poller_sync.h,,
 Header,+,lib/nfc/protocols/mf_desfire/mf_desfire.h,,
 Header,+,lib/nfc/protocols/mf_desfire/mf_desfire_poller.h,,
+Header,+,lib/nfc/protocols/mf_plus/mf_plus.h,,
+Header,+,lib/nfc/protocols/mf_plus/mf_plus_poller.h,,
 Header,+,lib/nfc/protocols/mf_ultralight/mf_ultralight.h,,
 Header,+,lib/nfc/protocols/mf_ultralight/mf_ultralight_listener.h,,
 Header,+,lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.h,,
@@ -2452,6 +2454,19 @@ Function,+,mf_desfire_save,_Bool,"const MfDesfireData*, FlipperFormat*"
 Function,+,mf_desfire_send_chunks,MfDesfireError,"MfDesfirePoller*, const BitBuffer*, BitBuffer*"
 Function,+,mf_desfire_set_uid,_Bool,"MfDesfireData*, const uint8_t*, size_t"
 Function,+,mf_desfire_verify,_Bool,"MfDesfireData*, const FuriString*"
+Function,+,mf_plus_alloc,MfPlusData*,
+Function,+,mf_plus_copy,void,"MfPlusData*, const MfPlusData*"
+Function,+,mf_plus_free,void,MfPlusData*
+Function,+,mf_plus_get_base_data,Iso14443_4aData*,const MfPlusData*
+Function,+,mf_plus_get_device_name,const char*,"const MfPlusData*, NfcDeviceNameType"
+Function,+,mf_plus_get_uid,const uint8_t*,"const MfPlusData*, size_t*"
+Function,+,mf_plus_is_equal,_Bool,"const MfPlusData*, const MfPlusData*"
+Function,+,mf_plus_load,_Bool,"MfPlusData*, FlipperFormat*, uint32_t"
+Function,+,mf_plus_poller_read_version,MfPlusError,"MfPlusPoller*, MfPlusVersion*"
+Function,+,mf_plus_reset,void,MfPlusData*
+Function,+,mf_plus_save,_Bool,"const MfPlusData*, FlipperFormat*"
+Function,+,mf_plus_set_uid,_Bool,"MfPlusData*, const uint8_t*, size_t"
+Function,+,mf_plus_verify,_Bool,"MfPlusData*, const FuriString*"
 Function,+,mf_ultralight_alloc,MfUltralightData*,
 Function,+,mf_ultralight_copy,void,"MfUltralightData*, const MfUltralightData*"
 Function,+,mf_ultralight_detect_protocol,_Bool,const Iso14443_3aData*