From 0b42027973bac6e74e3ed55891c54f6f7676f7f3 Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:40:03 +0000
Subject: [PATCH 1/8] NFC: Refactor DESFire poller to NxpNativeCommand helper

---
 lib/nfc/helpers/nxp_native_command.c          | 115 ++++++++++++++++++
 lib/nfc/helpers/nxp_native_command.h          |  92 ++++++++++++++
 lib/nfc/helpers/nxp_native_command_mode.h     |  11 ++
 lib/nfc/protocols/mf_desfire/mf_desfire_i.h   |  48 +-------
 .../mf_desfire/mf_desfire_poller_i.c          |  68 +++--------
 5 files changed, 235 insertions(+), 99 deletions(-)
 create mode 100644 lib/nfc/helpers/nxp_native_command.c
 create mode 100644 lib/nfc/helpers/nxp_native_command.h
 create mode 100644 lib/nfc/helpers/nxp_native_command_mode.h

diff --git a/lib/nfc/helpers/nxp_native_command.c b/lib/nfc/helpers/nxp_native_command.c
new file mode 100644
index 000000000..d5d535891
--- /dev/null
+++ b/lib/nfc/helpers/nxp_native_command.c
@@ -0,0 +1,115 @@
+#include "nxp_native_command.h"
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a_poller_i.h>
+
+#define TAG "NxpNativeCommand"
+
+Iso14443_4aError nxp_native_command_iso14443_4a_poller(
+    Iso14443_4aPoller* iso14443_4a_poller,
+    NxpNativeCommandStatus* status_code,
+    const BitBuffer* input_buffer,
+    BitBuffer* result_buffer,
+    NxpNativeCommandMode command_mode,
+    BitBuffer* tx_buffer,
+    BitBuffer* rx_buffer) {
+    furi_check(iso14443_4a_poller);
+    furi_check(tx_buffer);
+    furi_check(rx_buffer);
+    furi_check(input_buffer);
+    furi_check(result_buffer);
+    furi_check(command_mode < NxpNativeCommandModeMAX);
+
+    Iso14443_4aError error = Iso14443_4aErrorNone;
+    *status_code = NXP_NATIVE_COMMAND_STATUS_OPERATION_OK;
+
+    do {
+        bit_buffer_reset(tx_buffer);
+        if(command_mode == NxpNativeCommandModePlain) {
+            bit_buffer_append(tx_buffer, input_buffer);
+        } else if(command_mode == NxpNativeCommandModeIsoWrapped) {
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_CLA);
+            bit_buffer_append_byte(tx_buffer, bit_buffer_get_byte(input_buffer, 0));
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_P1);
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_P2);
+            if(bit_buffer_get_size_bytes(input_buffer) > 1) {
+                bit_buffer_append_byte(tx_buffer, bit_buffer_get_size_bytes(input_buffer) - 1);
+                bit_buffer_append_right(tx_buffer, input_buffer, 1);
+            }
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_LE);
+        }
+
+        bit_buffer_reset(rx_buffer);
+        error = iso14443_4a_poller_send_block(iso14443_4a_poller, tx_buffer, rx_buffer);
+
+        if(error != Iso14443_4aErrorNone) {
+            break;
+        }
+
+        bit_buffer_reset(tx_buffer);
+        if(command_mode == NxpNativeCommandModePlain) {
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_STATUS_ADDITIONAL_FRAME);
+        } else if(command_mode == NxpNativeCommandModeIsoWrapped) {
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_CLA);
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_STATUS_ADDITIONAL_FRAME);
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_P1);
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_P2);
+            bit_buffer_append_byte(tx_buffer, NXP_NATIVE_COMMAND_ISO_LE);
+        }
+
+        size_t response_len = bit_buffer_get_size_bytes(rx_buffer);
+        *status_code = NXP_NATIVE_COMMAND_STATUS_LENGTH_ERROR;
+        bit_buffer_reset(result_buffer);
+        if(command_mode == NxpNativeCommandModePlain && response_len >= sizeof(uint8_t)) {
+            *status_code = bit_buffer_get_byte(rx_buffer, 0);
+            if(response_len > sizeof(uint8_t)) {
+                bit_buffer_copy_right(result_buffer, rx_buffer, sizeof(uint8_t));
+            }
+        } else if(
+            command_mode == NxpNativeCommandModeIsoWrapped &&
+            response_len >= 2 * sizeof(uint8_t) &&
+            bit_buffer_get_byte(rx_buffer, response_len - 2) == NXP_NATIVE_COMMAND_ISO_SW1) {
+            *status_code = bit_buffer_get_byte(rx_buffer, response_len - 1);
+            if(response_len > 2 * sizeof(uint8_t)) {
+                bit_buffer_copy_left(result_buffer, rx_buffer, response_len - 2 * sizeof(uint8_t));
+            }
+        }
+
+        while(*status_code == NXP_NATIVE_COMMAND_STATUS_ADDITIONAL_FRAME) {
+            bit_buffer_reset(rx_buffer);
+            error = iso14443_4a_poller_send_block(iso14443_4a_poller, tx_buffer, rx_buffer);
+
+            if(error != Iso14443_4aErrorNone) {
+                break;
+            }
+
+            const size_t rx_size = bit_buffer_get_size_bytes(rx_buffer);
+            const size_t rx_capacity_remaining = bit_buffer_get_capacity_bytes(result_buffer) -
+                                                 bit_buffer_get_size_bytes(result_buffer);
+
+            if(command_mode == NxpNativeCommandModePlain) {
+                *status_code = rx_size >= 1 ? bit_buffer_get_byte(rx_buffer, 0) :
+                                              NXP_NATIVE_COMMAND_STATUS_LENGTH_ERROR;
+                if(rx_size <= rx_capacity_remaining + 1) {
+                    bit_buffer_append_right(result_buffer, rx_buffer, sizeof(uint8_t));
+                } else {
+                    FURI_LOG_W(TAG, "RX buffer overflow: ignoring %zu bytes", rx_size - 1);
+                }
+            } else if(command_mode == NxpNativeCommandModeIsoWrapped) {
+                if(rx_size >= 2 &&
+                   bit_buffer_get_byte(rx_buffer, rx_size - 2) == NXP_NATIVE_COMMAND_ISO_SW1) {
+                    *status_code = bit_buffer_get_byte(rx_buffer, rx_size - 1);
+                } else {
+                    *status_code = NXP_NATIVE_COMMAND_STATUS_LENGTH_ERROR;
+                }
+                if(rx_size <= rx_capacity_remaining + 2) {
+                    bit_buffer_set_size_bytes(rx_buffer, rx_size - 2);
+                    bit_buffer_append(result_buffer, rx_buffer);
+                } else {
+                    FURI_LOG_W(TAG, "RX buffer overflow: ignoring %zu bytes", rx_size - 2);
+                }
+            }
+        }
+    } while(false);
+
+    return error;
+}
diff --git a/lib/nfc/helpers/nxp_native_command.h b/lib/nfc/helpers/nxp_native_command.h
new file mode 100644
index 000000000..61677a3f6
--- /dev/null
+++ b/lib/nfc/helpers/nxp_native_command.h
@@ -0,0 +1,92 @@
+#pragma once
+
+#include "nxp_native_command_mode.h"
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a_poller.h>
+
+// ISO 7816 command wrapping
+#define NXP_NATIVE_COMMAND_ISO_CLA (0x90)
+#define NXP_NATIVE_COMMAND_ISO_P1  (0x00)
+#define NXP_NATIVE_COMMAND_ISO_P2  (0x00)
+#define NXP_NATIVE_COMMAND_ISO_LE  (0x00)
+// ISO 7816 status wrapping
+#define NXP_NATIVE_COMMAND_ISO_SW1 (0x91)
+
+// Successful operation
+#define NXP_NATIVE_COMMAND_STATUS_OPERATION_OK                (0x00)
+// No changes done to backup files, CommitTransaction / AbortTransaction not necessary
+#define NXP_NATIVE_COMMAND_STATUS_NO_CHANGES                  (0x0C)
+// Insufficient NV-Memory to complete command
+#define NXP_NATIVE_COMMAND_STATUS_OUT_OF_EEPROM_ERROR         (0x0E)
+// Command code not supported
+#define NXP_NATIVE_COMMAND_STATUS_ILLEGAL_COMMAND_CODE        (0x1C)
+// CRC or MAC does not match data Padding bytes not valid
+#define NXP_NATIVE_COMMAND_STATUS_INTEGRITY_ERROR             (0x1E)
+// Invalid key number specified
+#define NXP_NATIVE_COMMAND_STATUS_NO_SUCH_KEY                 (0x40)
+// Length of command string invalid
+#define NXP_NATIVE_COMMAND_STATUS_LENGTH_ERROR                (0x7E)
+// Current configuration / status does not allow the requested command
+#define NXP_NATIVE_COMMAND_STATUS_PERMISSION_DENIED           (0x9D)
+// Value of the parameter(s) invalid
+#define NXP_NATIVE_COMMAND_STATUS_PARAMETER_ERROR             (0x9E)
+// Requested AID not present on PICC
+#define NXP_NATIVE_COMMAND_STATUS_APPLICATION_NOT_FOUND       (0xA0)
+// Unrecoverable error within application, application will be disabled
+#define NXP_NATIVE_COMMAND_STATUS_APPL_INTEGRITY_ERROR        (0xA1)
+// Currently not allowed to authenticate. Keep trying until full delay is spent
+#define NXP_NATIVE_COMMAND_STATUS_STATUS_AUTHENTICATION_DELAY (0xAD)
+// Current authentication status does not allow the requested command
+#define NXP_NATIVE_COMMAND_STATUS_AUTHENTICATION_ERROR        (0xAE)
+// Additional data frame is expected to be sent
+#define NXP_NATIVE_COMMAND_STATUS_ADDITIONAL_FRAME            (0xAF)
+// Attempt to read/write data from/to beyond the file's/record's limits
+// Attempt to exceed the limits of a value file.
+#define NXP_NATIVE_COMMAND_STATUS_BOUNDARY_ERROR              (0xBE)
+// Unrecoverable error within PICC, PICC will be disabled
+#define NXP_NATIVE_COMMAND_STATUS_PICC_INTEGRITY_ERROR        (0xC1)
+// Previous Command was not fully completed. Not all Frames were requested or provided by the PCD
+#define NXP_NATIVE_COMMAND_STATUS_COMMAND_ABORTED             (0xCA)
+// PICC was disabled by an unrecoverable error
+#define NXP_NATIVE_COMMAND_STATUS_PICC_DISABLED_ERROR         (0xCD)
+// Number of Applications limited to 28, no additional CreateApplication possible
+#define NXP_NATIVE_COMMAND_STATUS_COUNT_ERROR                 (0xCE)
+// Creation of file/application failed because file/application with same number already exists
+#define NXP_NATIVE_COMMAND_STATUS_DUBLICATE_ERROR             (0xDE)
+// Could not complete NV-write operation due to loss of power, internal backup/rollback mechanism activated
+#define NXP_NATIVE_COMMAND_STATUS_EEPROM_ERROR                (0xEE)
+// Specified file number does not exist
+#define NXP_NATIVE_COMMAND_STATUS_FILE_NOT_FOUND              (0xF0)
+// Unrecoverable error within file, file will be disabled
+#define NXP_NATIVE_COMMAND_STATUS_FILE_INTEGRITY_ERROR        (0xF1)
+
+typedef uint8_t NxpNativeCommandStatus;
+
+/**
+ * @brief Transmit and receive NXP Native Command chunks in poller mode.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * The result_buffer will be filled with any data received as a response to data
+ * sent from input_buffer, with a timeout defined by the fwt parameter.
+ *
+ * The tx_buffer and rx_buffer are used as working areas to handle individual
+ * command chunks and responses.
+ *
+ * @param[in, out] iso14443_4a_poller pointer to the instance to be used in the transaction.
+ * @param[out] status_code pointer to a status variable to hold the result of the operation.
+ * @param[in] input_buffer pointer to the buffer containing the data to be transmitted.
+ * @param[out] result_buffer pointer to the buffer to be filled with received data.
+ * @param[in] command_mode what command formatting mode to use for the transaction.
+ * @param[in, out] tx_buffer pointer to the buffer for command construction.
+ * @param[in, out] rx_buffer pointer to the buffer for response handling.
+ * @return Iso14443_4aErrorNone and STATUS_OPERATION_OK on success, an error code on failure.
+ */
+Iso14443_4aError nxp_native_command_iso14443_4a_poller(
+    Iso14443_4aPoller* iso14443_4a_poller,
+    NxpNativeCommandStatus* status_code,
+    const BitBuffer* input_buffer,
+    BitBuffer* result_buffer,
+    NxpNativeCommandMode command_mode,
+    BitBuffer* tx_buffer,
+    BitBuffer* rx_buffer);
diff --git a/lib/nfc/helpers/nxp_native_command_mode.h b/lib/nfc/helpers/nxp_native_command_mode.h
new file mode 100644
index 000000000..7684b4d48
--- /dev/null
+++ b/lib/nfc/helpers/nxp_native_command_mode.h
@@ -0,0 +1,11 @@
+#pragma once
+
+/**
+ * @brief Enumeration of possible command modes.
+ */
+typedef enum {
+    NxpNativeCommandModePlain, /**< Plain native commands. */
+    NxpNativeCommandModeIsoWrapped, /**< ISO 7816-wrapped commands. */
+
+    NxpNativeCommandModeMAX,
+} NxpNativeCommandMode;
diff --git a/lib/nfc/protocols/mf_desfire/mf_desfire_i.h b/lib/nfc/protocols/mf_desfire/mf_desfire_i.h
index 921bbb9de..9494120d2 100644
--- a/lib/nfc/protocols/mf_desfire/mf_desfire_i.h
+++ b/lib/nfc/protocols/mf_desfire/mf_desfire_i.h
@@ -2,55 +2,11 @@
 
 #include "mf_desfire.h"
 
+#include <nfc/helpers/nxp_native_command.h>
+
 #define MF_DESFIRE_FFF_PICC_PREFIX "PICC"
 #define MF_DESFIRE_FFF_APP_PREFIX  "Application"
 
-// Successful operation
-#define MF_DESFIRE_STATUS_OPERATION_OK          (0x00)
-// No changes done to backup files, CommitTransaction / AbortTransaction not necessary
-#define MF_DESFIRE_STATUS_NO_CHANGES            (0x0C)
-// Insufficient NV-Memory to complete command
-#define MF_DESFIRE_STATUS_OUT_OF_EEPROM_ERROR   (0x0E)
-// Command code not supported
-#define MF_DESFIRE_STATUS_ILLEGAL_COMMAND_CODE  (0x1C)
-// CRC or MAC does not match data Padding bytes not valid
-#define MF_DESFIRE_STATUS_INTEGRITY_ERROR       (0x1E)
-// Invalid key number specified
-#define MF_DESFIRE_STATUS_NO_SUCH_KEY           (0x40)
-// Length of command string invalid
-#define MF_DESFIRE_STATUS_LENGTH_ERROR          (0x7E)
-// Current configuration / status does not allow the requested command
-#define MF_DESFIRE_STATUS_PERMISSION_DENIED     (0x9D)
-// Value of the parameter(s) invalid
-#define MF_DESFIRE_STATUS_PARAMETER_ERROR       (0x9E)
-// Requested AID not present on PICC
-#define MF_DESFIRE_STATUS_APPLICATION_NOT_FOUND (0xA0)
-// Unrecoverable error within application, application will be disabled
-#define MF_DESFIRE_STATUS_APPL_INTEGRITY_ERROR  (0xA1)
-// Current authentication status does not allow the requested command
-#define MF_DESFIRE_STATUS_AUTHENTICATION_ERROR  (0xAE)
-// Additional data frame is expected to be sent
-#define MF_DESFIRE_STATUS_ADDITIONAL_FRAME      (0xAF)
-// Attempt to read/write data from/to beyond the file's/record's limits
-// Attempt to exceed the limits of a value file.
-#define MF_DESFIRE_STATUS_BOUNDARY_ERROR        (0xBE)
-// Unrecoverable error within PICC, PICC will be disabled
-#define MF_DESFIRE_STATUS_PICC_INTEGRITY_ERROR  (0xC1)
-// Previous Command was not fully completed. Not all Frames were requested or provided by the PCD
-#define MF_DESFIRE_STATUS_COMMAND_ABORTED       (0xCA)
-// PICC was disabled by an unrecoverable error
-#define MF_DESFIRE_STATUS_PICC_DISABLED_ERROR   (0xCD)
-// Number of Applications limited to 28, no additional CreateApplication possible
-#define MF_DESFIRE_STATUS_COUNT_ERROR           (0xCE)
-// Creation of file/application failed because file/application with same number already exists
-#define MF_DESFIRE_STATUS_DUBLICATE_ERROR       (0xDE)
-// Could not complete NV-write operation due to loss of power, internal backup/rollback mechanism activated
-#define MF_DESFIRE_STATUS_EEPROM_ERROR          (0xEE)
-// Specified file number does not exist
-#define MF_DESFIRE_STATUS_FILE_NOT_FOUND        (0xF0)
-// Unrecoverable error within file, file will be disabled
-#define MF_DESFIRE_STATUS_FILE_INTEGRITY_ERROR  (0xF1)
-
 // SimpleArray configurations
 
 extern const SimpleArrayConfig mf_desfire_key_version_array_config;
diff --git a/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c b/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c
index 6d8dfda16..f54133e3c 100644
--- a/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c
+++ b/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c
@@ -21,11 +21,11 @@ MfDesfireError mf_desfire_process_error(Iso14443_4aError error) {
 
 MfDesfireError mf_desfire_process_status_code(uint8_t status_code) {
     switch(status_code) {
-    case MF_DESFIRE_STATUS_OPERATION_OK:
+    case NXP_NATIVE_COMMAND_STATUS_OPERATION_OK:
         return MfDesfireErrorNone;
-    case MF_DESFIRE_STATUS_AUTHENTICATION_ERROR:
+    case NXP_NATIVE_COMMAND_STATUS_AUTHENTICATION_ERROR:
         return MfDesfireErrorAuthentication;
-    case MF_DESFIRE_STATUS_ILLEGAL_COMMAND_CODE:
+    case NXP_NATIVE_COMMAND_STATUS_ILLEGAL_COMMAND_CODE:
         return MfDesfireErrorCommandNotSupported;
     default:
         return MfDesfireErrorProtocol;
@@ -37,60 +37,22 @@ MfDesfireError mf_desfire_send_chunks(
     const BitBuffer* tx_buffer,
     BitBuffer* rx_buffer) {
     furi_check(instance);
-    furi_check(instance->iso14443_4a_poller);
-    furi_check(instance->tx_buffer);
-    furi_check(instance->rx_buffer);
-    furi_check(tx_buffer);
-    furi_check(rx_buffer);
 
-    MfDesfireError error = MfDesfireErrorNone;
+    NxpNativeCommandStatus status_code = NXP_NATIVE_COMMAND_STATUS_OPERATION_OK;
+    Iso14443_4aError iso14443_4a_error = nxp_native_command_iso14443_4a_poller(
+        instance->iso14443_4a_poller,
+        &status_code,
+        tx_buffer,
+        rx_buffer,
+        NxpNativeCommandModePlain,
+        instance->tx_buffer,
+        instance->rx_buffer);
 
-    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_desfire_process_error(iso14443_4a_error);
-            break;
-        }
-
-        bit_buffer_reset(instance->tx_buffer);
-        bit_buffer_append_byte(instance->tx_buffer, MF_DESFIRE_STATUS_ADDITIONAL_FRAME);
-
-        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(
-            bit_buffer_starts_with_byte(instance->rx_buffer, MF_DESFIRE_STATUS_ADDITIONAL_FRAME)) {
-            Iso14443_4aError iso14443_4a_error = iso14443_4a_poller_send_block(
-                instance->iso14443_4a_poller, instance->tx_buffer, instance->rx_buffer);
-
-            if(iso14443_4a_error != Iso14443_4aErrorNone) {
-                error = mf_desfire_process_error(iso14443_4a_error);
-                break;
-            }
-
-            const size_t rx_size = bit_buffer_get_size_bytes(instance->rx_buffer);
-            const size_t rx_capacity_remaining =
-                bit_buffer_get_capacity_bytes(rx_buffer) - bit_buffer_get_size_bytes(rx_buffer);
-
-            if(rx_size <= rx_capacity_remaining + 1) {
-                bit_buffer_append_right(rx_buffer, instance->rx_buffer, sizeof(uint8_t));
-            } else {
-                FURI_LOG_W(TAG, "RX buffer overflow: ignoring %zu bytes", rx_size - 1);
-            }
-        }
-    } while(false);
-
-    if(error == MfDesfireErrorNone) {
-        uint8_t err_code = bit_buffer_get_byte(instance->rx_buffer, 0);
-        error = mf_desfire_process_status_code(err_code);
+    if(iso14443_4a_error != Iso14443_4aErrorNone) {
+        return mf_desfire_process_error(iso14443_4a_error);
     }
 
-    return error;
+    return mf_desfire_process_status_code(status_code);
 }
 
 MfDesfireError mf_desfire_poller_read_version(MfDesfirePoller* instance, MfDesfireVersion* data) {

From 7525662f14ffdbf8a32999e81dd158eab12dcd7e Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:45:20 +0000
Subject: [PATCH 2/8] NFC: Sort protocol defs and add missing ones

---
 lib/nfc/SConscript                    | 12 ++++++++----
 lib/nfc/protocols/nfc_listener_defs.c |  5 +++--
 lib/nfc/protocols/nfc_poller_defs.c   |  2 +-
 lib/nfc/protocols/nfc_protocol.c      |  6 ++++--
 targets/f18/api_symbols.csv           |  2 +-
 targets/f7/api_symbols.csv            | 13 ++++++++++++-
 6 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/lib/nfc/SConscript b/lib/nfc/SConscript
index 82b87ea2a..f9f16c759 100644
--- a/lib/nfc/SConscript
+++ b/lib/nfc/SConscript
@@ -19,37 +19,41 @@ env.Append(
         File("protocols/iso14443_3b/iso14443_3b.h"),
         File("protocols/iso14443_4a/iso14443_4a.h"),
         File("protocols/iso14443_4b/iso14443_4b.h"),
+        File("protocols/iso15693_3/iso15693_3.h"),
+        File("protocols/felica/felica.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"),
-        File("protocols/felica/felica.h"),
         # Pollers
         File("protocols/iso14443_3a/iso14443_3a_poller.h"),
         File("protocols/iso14443_3b/iso14443_3b_poller.h"),
         File("protocols/iso14443_4a/iso14443_4a_poller.h"),
         File("protocols/iso14443_4b/iso14443_4b_poller.h"),
+        File("protocols/iso15693_3/iso15693_3_poller.h"),
+        File("protocols/felica/felica_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/slix/slix_poller.h"),
         File("protocols/st25tb/st25tb_poller.h"),
-        File("protocols/felica/felica_poller.h"),
         # Listeners
         File("protocols/iso14443_3a/iso14443_3a_listener.h"),
         File("protocols/iso14443_4a/iso14443_4a_listener.h"),
+        File("protocols/iso15693_3/iso15693_3_listener.h"),
+        File("protocols/felica/felica_listener.h"),
         File("protocols/mf_ultralight/mf_ultralight_listener.h"),
         File("protocols/mf_classic/mf_classic_listener.h"),
-        File("protocols/felica/felica_listener.h"),
+        File("protocols/slix/slix_listener.h"),
         # Sync API
         File("protocols/iso14443_3a/iso14443_3a_poller_sync.h"),
+        File("protocols/felica/felica_poller_sync.h"),
         File("protocols/mf_ultralight/mf_ultralight_poller_sync.h"),
         File("protocols/mf_classic/mf_classic_poller_sync.h"),
         File("protocols/st25tb/st25tb_poller_sync.h"),
-        File("protocols/felica/felica_poller_sync.h"),
         # Misc
         File("helpers/nfc_util.h"),
         File("helpers/iso14443_crc.h"),
diff --git a/lib/nfc/protocols/nfc_listener_defs.c b/lib/nfc/protocols/nfc_listener_defs.c
index 2a6167e9c..d0a23ba30 100644
--- a/lib/nfc/protocols/nfc_listener_defs.c
+++ b/lib/nfc/protocols/nfc_listener_defs.c
@@ -3,10 +3,10 @@
 #include <nfc/protocols/iso14443_3a/iso14443_3a_listener_defs.h>
 #include <nfc/protocols/iso14443_4a/iso14443_4a_listener_defs.h>
 #include <nfc/protocols/iso15693_3/iso15693_3_listener_defs.h>
+#include <nfc/protocols/felica/felica_listener_defs.h>
 #include <nfc/protocols/mf_ultralight/mf_ultralight_listener_defs.h>
 #include <nfc/protocols/mf_classic/mf_classic_listener_defs.h>
 #include <nfc/protocols/slix/slix_listener_defs.h>
-#include <nfc/protocols/felica/felica_listener_defs.h>
 
 const NfcListenerBase* nfc_listeners_api[NfcProtocolNum] = {
     [NfcProtocolIso14443_3a] = &nfc_listener_iso14443_3a,
@@ -14,10 +14,11 @@ const NfcListenerBase* nfc_listeners_api[NfcProtocolNum] = {
     [NfcProtocolIso14443_4a] = &nfc_listener_iso14443_4a,
     [NfcProtocolIso14443_4b] = NULL,
     [NfcProtocolIso15693_3] = &nfc_listener_iso15693_3,
+    [NfcProtocolFelica] = &nfc_listener_felica,
     [NfcProtocolMfUltralight] = &mf_ultralight_listener,
     [NfcProtocolMfClassic] = &mf_classic_listener,
+    [NfcProtocolMfPlus] = NULL,
     [NfcProtocolMfDesfire] = NULL,
     [NfcProtocolSlix] = &nfc_listener_slix,
     [NfcProtocolSt25tb] = NULL,
-    [NfcProtocolFelica] = &nfc_listener_felica,
 };
diff --git a/lib/nfc/protocols/nfc_poller_defs.c b/lib/nfc/protocols/nfc_poller_defs.c
index c007740b7..7581b4694 100644
--- a/lib/nfc/protocols/nfc_poller_defs.c
+++ b/lib/nfc/protocols/nfc_poller_defs.c
@@ -25,6 +25,6 @@ const NfcPollerBase* nfc_pollers_api[NfcProtocolNum] = {
     [NfcProtocolMfPlus] = &mf_plus_poller,
     [NfcProtocolMfDesfire] = &mf_desfire_poller,
     [NfcProtocolSlix] = &nfc_poller_slix,
-    /* Add new pollers here */
     [NfcProtocolSt25tb] = &nfc_poller_st25tb,
+    /* Add new pollers here */
 };
diff --git a/lib/nfc/protocols/nfc_protocol.c b/lib/nfc/protocols/nfc_protocol.c
index 40201843e..92d9d990b 100644
--- a/lib/nfc/protocols/nfc_protocol.c
+++ b/lib/nfc/protocols/nfc_protocol.c
@@ -22,7 +22,9 @@
  *            |               |             |
  *       ISO14443-4A   Mf Ultralight   Mf Classic
  *            |
- *       Mf Desfire
+ *      +-----+----+
+ *      |          |
+ *  Mf Desfire   Mf Plus
  * ```
  *
  * When implementing a new protocol, its place in the tree must be determined first.
@@ -60,8 +62,8 @@ static const NfcProtocol nfc_protocol_iso14443_3b_children_protocol[] = {
 
 /** List of ISO14443-4A child protocols. */
 static const NfcProtocol nfc_protocol_iso14443_4a_children_protocol[] = {
-    NfcProtocolMfDesfire,
     NfcProtocolMfPlus,
+    NfcProtocolMfDesfire,
 };
 
 /** List of ISO115693-3 child protocols. */
diff --git a/targets/f18/api_symbols.csv b/targets/f18/api_symbols.csv
index 2074fa131..ae056b56c 100644
--- a/targets/f18/api_symbols.csv
+++ b/targets/f18/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,82.1,,
+Version,+,82.2,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
 Header,+,applications/services/cli/cli.h,,
diff --git a/targets/f7/api_symbols.csv b/targets/f7/api_symbols.csv
index 1168a6eea..2696643d8 100644
--- a/targets/f7/api_symbols.csv
+++ b/targets/f7/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,82.1,,
+Version,+,82.2,,
 Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
@@ -152,6 +152,9 @@ Header,+,lib/nfc/protocols/iso14443_4a/iso14443_4a_listener.h,,
 Header,+,lib/nfc/protocols/iso14443_4a/iso14443_4a_poller.h,,
 Header,+,lib/nfc/protocols/iso14443_4b/iso14443_4b.h,,
 Header,+,lib/nfc/protocols/iso14443_4b/iso14443_4b_poller.h,,
+Header,+,lib/nfc/protocols/iso15693_3/iso15693_3.h,,
+Header,+,lib/nfc/protocols/iso15693_3/iso15693_3_listener.h,,
+Header,+,lib/nfc/protocols/iso15693_3/iso15693_3_poller.h,,
 Header,+,lib/nfc/protocols/mf_classic/mf_classic.h,,
 Header,+,lib/nfc/protocols/mf_classic/mf_classic_listener.h,,
 Header,+,lib/nfc/protocols/mf_classic/mf_classic_poller.h,,
@@ -165,6 +168,7 @@ Header,+,lib/nfc/protocols/mf_ultralight/mf_ultralight_listener.h,,
 Header,+,lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.h,,
 Header,+,lib/nfc/protocols/mf_ultralight/mf_ultralight_poller_sync.h,,
 Header,+,lib/nfc/protocols/slix/slix.h,,
+Header,+,lib/nfc/protocols/slix/slix_listener.h,,
 Header,+,lib/nfc/protocols/slix/slix_poller.h,,
 Header,+,lib/nfc/protocols/st25tb/st25tb.h,,
 Header,+,lib/nfc/protocols/st25tb/st25tb_poller.h,,
@@ -2196,6 +2200,13 @@ Function,+,iso15693_3_get_uid,const uint8_t*,"const Iso15693_3Data*, size_t*"
 Function,+,iso15693_3_is_block_locked,_Bool,"const Iso15693_3Data*, uint8_t"
 Function,+,iso15693_3_is_equal,_Bool,"const Iso15693_3Data*, const Iso15693_3Data*"
 Function,+,iso15693_3_load,_Bool,"Iso15693_3Data*, FlipperFormat*, uint32_t"
+Function,+,iso15693_3_poller_activate,Iso15693_3Error,"Iso15693_3Poller*, Iso15693_3Data*"
+Function,+,iso15693_3_poller_get_blocks_security,Iso15693_3Error,"Iso15693_3Poller*, uint8_t*, uint16_t"
+Function,+,iso15693_3_poller_get_system_info,Iso15693_3Error,"Iso15693_3Poller*, Iso15693_3SystemInfo*"
+Function,+,iso15693_3_poller_inventory,Iso15693_3Error,"Iso15693_3Poller*, uint8_t*"
+Function,+,iso15693_3_poller_read_block,Iso15693_3Error,"Iso15693_3Poller*, uint8_t*, uint8_t, uint8_t"
+Function,+,iso15693_3_poller_read_blocks,Iso15693_3Error,"Iso15693_3Poller*, uint8_t*, uint16_t, uint8_t"
+Function,+,iso15693_3_poller_send_frame,Iso15693_3Error,"Iso15693_3Poller*, const BitBuffer*, BitBuffer*, uint32_t"
 Function,+,iso15693_3_reset,void,Iso15693_3Data*
 Function,+,iso15693_3_save,_Bool,"const Iso15693_3Data*, FlipperFormat*"
 Function,+,iso15693_3_set_uid,_Bool,"Iso15693_3Data*, const uint8_t*, size_t"

From 6ebc4c7ad3da23b474b03106969f0b5c88e73af3 Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:48:19 +0000
Subject: [PATCH 3/8] NFC: Support NTAG4xx detection and basic info

---
 .../nfc_protocol_support_defs.c               |   2 +
 .../protocol_support/ntag4xx/ntag4xx.c        | 133 ++++++++++++
 .../protocol_support/ntag4xx/ntag4xx.h        |   5 +
 .../protocol_support/ntag4xx/ntag4xx_render.c | 110 ++++++++++
 .../protocol_support/ntag4xx/ntag4xx_render.h |  14 ++
 lib/nfc/SConscript                            |   2 +
 lib/nfc/protocols/nfc_device_defs.c           |   2 +
 lib/nfc/protocols/nfc_listener_defs.c         |   1 +
 lib/nfc/protocols/nfc_poller_defs.c           |   2 +
 lib/nfc/protocols/nfc_protocol.c              |  13 +-
 lib/nfc/protocols/nfc_protocol.h              |   1 +
 lib/nfc/protocols/ntag4xx/ntag4xx.c           | 192 ++++++++++++++++++
 lib/nfc/protocols/ntag4xx/ntag4xx.h           | 114 +++++++++++
 lib/nfc/protocols/ntag4xx/ntag4xx_i.c         |  54 +++++
 lib/nfc/protocols/ntag4xx/ntag4xx_i.h         |  25 +++
 lib/nfc/protocols/ntag4xx/ntag4xx_poller.c    | 165 +++++++++++++++
 lib/nfc/protocols/ntag4xx/ntag4xx_poller.h    |  43 ++++
 .../protocols/ntag4xx/ntag4xx_poller_defs.h   |   5 +
 lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.c  |  52 +++++
 lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.h  |  40 ++++
 targets/f18/api_symbols.csv                   |   2 +-
 targets/f7/api_symbols.csv                    |  18 +-
 22 files changed, 990 insertions(+), 5 deletions(-)
 create mode 100644 applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.c
 create mode 100644 applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.h
 create mode 100644 applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.c
 create mode 100644 applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.h
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx.c
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx.h
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx_i.c
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx_i.h
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx_poller.c
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx_poller.h
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx_poller_defs.h
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.c
 create mode 100644 lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.h

diff --git a/applications/main/nfc/helpers/protocol_support/nfc_protocol_support_defs.c b/applications/main/nfc/helpers/protocol_support/nfc_protocol_support_defs.c
index 66839aacc..fa6c3efec 100644
--- a/applications/main/nfc/helpers/protocol_support/nfc_protocol_support_defs.c
+++ b/applications/main/nfc/helpers/protocol_support/nfc_protocol_support_defs.c
@@ -21,6 +21,7 @@
 #include "mf_desfire/mf_desfire.h"
 #include "slix/slix.h"
 #include "st25tb/st25tb.h"
+#include "ntag4xx/ntag4xx.h"
 
 /**
  * @brief Array of pointers to concrete protocol support implementations.
@@ -43,5 +44,6 @@ const NfcProtocolSupportBase* nfc_protocol_support[NfcProtocolNum] = {
     [NfcProtocolMfDesfire] = &nfc_protocol_support_mf_desfire,
     [NfcProtocolSlix] = &nfc_protocol_support_slix,
     [NfcProtocolSt25tb] = &nfc_protocol_support_st25tb,
+    [NfcProtocolNtag4xx] = &nfc_protocol_support_ntag4xx,
     /* Add new protocol support implementations here */
 };
diff --git a/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.c b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.c
new file mode 100644
index 000000000..82a3d55b6
--- /dev/null
+++ b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.c
@@ -0,0 +1,133 @@
+#include "ntag4xx.h"
+#include "ntag4xx_render.h"
+
+#include <nfc/protocols/ntag4xx/ntag4xx_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_ntag4xx(NfcApp* instance) {
+    const NfcDevice* device = instance->nfc_device;
+    const Ntag4xxData* data = nfc_device_get_data(device, NfcProtocolNtag4xx);
+
+    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));
+    nfc_render_ntag4xx_info(data, NfcProtocolFormatTypeFull, temp_str);
+
+    widget_add_text_scroll_element(
+        instance->widget, 0, 0, 128, 64, furi_string_get_cstr(temp_str));
+
+    furi_string_free(temp_str);
+}
+
+static void nfc_scene_more_info_on_enter_ntag4xx(NfcApp* instance) {
+    const NfcDevice* device = instance->nfc_device;
+    const Ntag4xxData* data = nfc_device_get_data(device, NfcProtocolNtag4xx);
+
+    furi_string_reset(instance->text_box_store);
+    nfc_render_ntag4xx_data(data, instance->text_box_store);
+
+    text_box_set_font(instance->text_box, TextBoxFontHex);
+    text_box_set_text(instance->text_box, furi_string_get_cstr(instance->text_box_store));
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewTextBox);
+}
+
+static NfcCommand nfc_scene_read_poller_callback_ntag4xx(NfcGenericEvent event, void* context) {
+    furi_assert(event.protocol == NfcProtocolNtag4xx);
+
+    NfcCommand command = NfcCommandContinue;
+
+    NfcApp* instance = context;
+    const Ntag4xxPollerEvent* ntag4xx_event = event.event_data;
+
+    if(ntag4xx_event->type == Ntag4xxPollerEventTypeReadSuccess) {
+        nfc_device_set_data(
+            instance->nfc_device, NfcProtocolNtag4xx, nfc_poller_get_data(instance->poller));
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventPollerSuccess);
+        command = NfcCommandStop;
+    } else if(ntag4xx_event->type == Ntag4xxPollerEventTypeReadFailed) {
+        command = NfcCommandReset;
+    }
+
+    return command;
+}
+
+static void nfc_scene_read_on_enter_ntag4xx(NfcApp* instance) {
+    nfc_poller_start(instance->poller, nfc_scene_read_poller_callback_ntag4xx, instance);
+}
+
+static void nfc_scene_read_success_on_enter_ntag4xx(NfcApp* instance) {
+    const NfcDevice* device = instance->nfc_device;
+    const Ntag4xxData* data = nfc_device_get_data(device, NfcProtocolNtag4xx);
+
+    FuriString* temp_str = furi_string_alloc();
+    furi_string_cat_printf(
+        temp_str, "\e#%s\n", nfc_device_get_name(device, NfcDeviceNameTypeFull));
+    nfc_render_ntag4xx_info(data, NfcProtocolFormatTypeShort, 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_ntag4xx(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_ntag4xx = {
+    .features = NfcProtocolFeatureEmulateUid | NfcProtocolFeatureMoreInfo,
+
+    .scene_info =
+        {
+            .on_enter = nfc_scene_info_on_enter_ntag4xx,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_more_info =
+        {
+            .on_enter = nfc_scene_more_info_on_enter_ntag4xx,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+    .scene_read =
+        {
+            .on_enter = nfc_scene_read_on_enter_ntag4xx,
+            .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_ntag4xx,
+            .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_ntag4xx,
+            .on_event = nfc_protocol_support_common_on_event_empty,
+        },
+};
diff --git a/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.h b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.h
new file mode 100644
index 000000000..09a8388fa
--- /dev/null
+++ b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "../nfc_protocol_support_base.h"
+
+extern const NfcProtocolSupportBase nfc_protocol_support_ntag4xx;
diff --git a/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.c b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.c
new file mode 100644
index 000000000..0cb587726
--- /dev/null
+++ b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.c
@@ -0,0 +1,110 @@
+#include "ntag4xx_render.h"
+
+#include "../iso14443_4a/iso14443_4a_render.h"
+
+void nfc_render_ntag4xx_info(
+    const Ntag4xxData* data,
+    NfcProtocolFormatType format_type,
+    FuriString* str) {
+    nfc_render_iso14443_4a_brief(ntag4xx_get_base_data(data), str);
+
+    const Ntag4xxType type = ntag4xx_get_type_from_version(&data->version);
+    if(type >= Ntag4xxTypeUnknown) {
+        furi_string_cat(str, "Memory Size: unknown");
+    } else {
+        size_t size_cc = 32;
+        size_t size_ndef = 0;
+        size_t size_proprietary = 0;
+        bool has_tagtamper = false;
+        switch(type) {
+        case Ntag4xxType413DNA:
+            size_ndef = 128;
+            size_proprietary = 0;
+            break;
+        case Ntag4xxType424DNATT:
+            has_tagtamper = true;
+            /* fall-through */
+        case Ntag4xxType424DNA:
+            size_ndef = 256;
+            size_proprietary = 128;
+            break;
+        case Ntag4xxType426QDNATT:
+            has_tagtamper = true;
+            /* fall-through */
+        case Ntag4xxType426QDNA:
+            size_ndef = 768;
+            size_proprietary = 128;
+            break;
+        default:
+            break;
+        }
+        furi_string_cat_printf(
+            str, "\nMemory Size: %zu bytes\n", size_cc + size_ndef + size_proprietary);
+        furi_string_cat_printf(str, "Usable NDEF Size: %zu bytes\n", size_ndef - sizeof(uint16_t));
+        furi_string_cat_printf(str, "Capability Cont.: %zu bytes\n", size_cc);
+        if(size_proprietary) {
+            furi_string_cat_printf(str, "Proprietary File: %zu bytes\n", size_proprietary);
+        }
+        furi_string_cat_printf(str, "TagTamper: %ssupported", has_tagtamper ? "" : "not ");
+    }
+
+    if(format_type != NfcProtocolFormatTypeFull) return;
+
+    furi_string_cat(str, "\n\e#ISO14443-4 data");
+    nfc_render_iso14443_4a_extra(ntag4xx_get_base_data(data), str);
+}
+
+void nfc_render_ntag4xx_data(const Ntag4xxData* data, FuriString* str) {
+    nfc_render_ntag4xx_version(&data->version, str);
+}
+
+void nfc_render_ntag4xx_version(const Ntag4xxVersion* 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:%01x\n"
+        "week %d year %d\n"
+        "fab key %02x id %02x\n",
+        data->batch[0],
+        data->batch[1],
+        data->batch[2],
+        data->batch[3],
+        data->batch_extra,
+        data->prod_week,
+        data->prod_year,
+        (data->fab_key_4b << 1) | (data->fab_key_1b),
+        data->optional.fab_key_id);
+}
diff --git a/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.h b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.h
new file mode 100644
index 000000000..ca81cf4c4
--- /dev/null
+++ b/applications/main/nfc/helpers/protocol_support/ntag4xx/ntag4xx_render.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <nfc/protocols/ntag4xx/ntag4xx.h>
+
+#include "../nfc_protocol_support_render_common.h"
+
+void nfc_render_ntag4xx_info(
+    const Ntag4xxData* data,
+    NfcProtocolFormatType format_type,
+    FuriString* str);
+
+void nfc_render_ntag4xx_data(const Ntag4xxData* data, FuriString* str);
+
+void nfc_render_ntag4xx_version(const Ntag4xxVersion* data, FuriString* str);
diff --git a/lib/nfc/SConscript b/lib/nfc/SConscript
index f9f16c759..6d596c0e8 100644
--- a/lib/nfc/SConscript
+++ b/lib/nfc/SConscript
@@ -27,6 +27,7 @@ env.Append(
         File("protocols/mf_desfire/mf_desfire.h"),
         File("protocols/slix/slix.h"),
         File("protocols/st25tb/st25tb.h"),
+        File("protocols/ntag4xx/ntag4xx.h"),
         # Pollers
         File("protocols/iso14443_3a/iso14443_3a_poller.h"),
         File("protocols/iso14443_3b/iso14443_3b_poller.h"),
@@ -40,6 +41,7 @@ env.Append(
         File("protocols/mf_desfire/mf_desfire_poller.h"),
         File("protocols/slix/slix_poller.h"),
         File("protocols/st25tb/st25tb_poller.h"),
+        File("protocols/ntag4xx/ntag4xx_poller.h"),
         # Listeners
         File("protocols/iso14443_3a/iso14443_3a_listener.h"),
         File("protocols/iso14443_4a/iso14443_4a_listener.h"),
diff --git a/lib/nfc/protocols/nfc_device_defs.c b/lib/nfc/protocols/nfc_device_defs.c
index 6a145445c..4d337f377 100644
--- a/lib/nfc/protocols/nfc_device_defs.c
+++ b/lib/nfc/protocols/nfc_device_defs.c
@@ -24,6 +24,7 @@
 #include <nfc/protocols/mf_desfire/mf_desfire.h>
 #include <nfc/protocols/slix/slix_device_defs.h>
 #include <nfc/protocols/st25tb/st25tb.h>
+#include <nfc/protocols/ntag4xx/ntag4xx.h>
 
 /**
  * @brief List of registered NFC device implementations.
@@ -44,5 +45,6 @@ const NfcDeviceBase* nfc_devices[NfcProtocolNum] = {
     [NfcProtocolMfDesfire] = &nfc_device_mf_desfire,
     [NfcProtocolSlix] = &nfc_device_slix,
     [NfcProtocolSt25tb] = &nfc_device_st25tb,
+    [NfcProtocolNtag4xx] = &nfc_device_ntag4xx,
     /* Add new protocols here */
 };
diff --git a/lib/nfc/protocols/nfc_listener_defs.c b/lib/nfc/protocols/nfc_listener_defs.c
index d0a23ba30..43ffd716f 100644
--- a/lib/nfc/protocols/nfc_listener_defs.c
+++ b/lib/nfc/protocols/nfc_listener_defs.c
@@ -21,4 +21,5 @@ const NfcListenerBase* nfc_listeners_api[NfcProtocolNum] = {
     [NfcProtocolMfDesfire] = NULL,
     [NfcProtocolSlix] = &nfc_listener_slix,
     [NfcProtocolSt25tb] = NULL,
+    [NfcProtocolNtag4xx] = NULL,
 };
diff --git a/lib/nfc/protocols/nfc_poller_defs.c b/lib/nfc/protocols/nfc_poller_defs.c
index 7581b4694..9c3c88517 100644
--- a/lib/nfc/protocols/nfc_poller_defs.c
+++ b/lib/nfc/protocols/nfc_poller_defs.c
@@ -12,6 +12,7 @@
 #include <nfc/protocols/mf_desfire/mf_desfire_poller_defs.h>
 #include <nfc/protocols/slix/slix_poller_defs.h>
 #include <nfc/protocols/st25tb/st25tb_poller_defs.h>
+#include <nfc/protocols/ntag4xx/ntag4xx_poller_defs.h>
 
 const NfcPollerBase* nfc_pollers_api[NfcProtocolNum] = {
     [NfcProtocolIso14443_3a] = &nfc_poller_iso14443_3a,
@@ -26,5 +27,6 @@ const NfcPollerBase* nfc_pollers_api[NfcProtocolNum] = {
     [NfcProtocolMfDesfire] = &mf_desfire_poller,
     [NfcProtocolSlix] = &nfc_poller_slix,
     [NfcProtocolSt25tb] = &nfc_poller_st25tb,
+    [NfcProtocolNtag4xx] = &ntag4xx_poller,
     /* Add new pollers here */
 };
diff --git a/lib/nfc/protocols/nfc_protocol.c b/lib/nfc/protocols/nfc_protocol.c
index 92d9d990b..7d42520ef 100644
--- a/lib/nfc/protocols/nfc_protocol.c
+++ b/lib/nfc/protocols/nfc_protocol.c
@@ -22,9 +22,9 @@
  *            |               |             |
  *       ISO14443-4A   Mf Ultralight   Mf Classic
  *            |
- *      +-----+----+
- *      |          |
- *  Mf Desfire   Mf Plus
+ *      +-----+----+----------+
+ *      |          |          |
+ *  Mf Desfire   Mf Plus   NTAG4xx
  * ```
  *
  * When implementing a new protocol, its place in the tree must be determined first.
@@ -64,6 +64,7 @@ static const NfcProtocol nfc_protocol_iso14443_3b_children_protocol[] = {
 static const NfcProtocol nfc_protocol_iso14443_4a_children_protocol[] = {
     NfcProtocolMfPlus,
     NfcProtocolMfDesfire,
+    NfcProtocolNtag4xx,
 };
 
 /** List of ISO115693-3 child protocols. */
@@ -155,6 +156,12 @@ static const NfcProtocolTreeNode nfc_protocol_nodes[NfcProtocolNum] = {
             .children_num = 0,
             .children_protocol = NULL,
         },
+    [NfcProtocolNtag4xx] =
+        {
+            .parent_protocol = NfcProtocolIso14443_4a,
+            .children_num = 0,
+            .children_protocol = NULL,
+        },
     /* Add new protocols here */
 };
 
diff --git a/lib/nfc/protocols/nfc_protocol.h b/lib/nfc/protocols/nfc_protocol.h
index cf74972f7..17f31aba2 100644
--- a/lib/nfc/protocols/nfc_protocol.h
+++ b/lib/nfc/protocols/nfc_protocol.h
@@ -188,6 +188,7 @@ typedef enum {
     NfcProtocolMfDesfire,
     NfcProtocolSlix,
     NfcProtocolSt25tb,
+    NfcProtocolNtag4xx,
     /* Add new protocols here */
 
     NfcProtocolNum, /**< Special value representing the number of available protocols. */
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx.c b/lib/nfc/protocols/ntag4xx/ntag4xx.c
new file mode 100644
index 000000000..7b0991903
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx.c
@@ -0,0 +1,192 @@
+#include "ntag4xx_i.h"
+
+#include <furi.h>
+
+#define NTAG4XX_PROTOCOL_NAME "NTAG4xx"
+
+#define NTAG4XX_HW_MAJOR_TYPE_413_DNA (0x10)
+#define NTAG4XX_HW_MAJOR_TYPE_424_DNA (0x30)
+
+#define NTAG4XX_HW_SUBTYPE_TAGTAMPER_FLAG (0x08)
+
+static const char* ntag4xx_type_strings[] = {
+    [Ntag4xxType413DNA] = "NTAG413 DNA",
+    [Ntag4xxType424DNA] = "NTAG424 DNA",
+    [Ntag4xxType424DNATT] = "NTAG424 DNA TagTamper",
+    [Ntag4xxType426QDNA] = "NTAG426Q DNA",
+    [Ntag4xxType426QDNATT] = "NTAG426Q DNA TagTamper",
+    [Ntag4xxTypeUnknown] = "UNK",
+};
+
+const NfcDeviceBase nfc_device_ntag4xx = {
+    .protocol_name = NTAG4XX_PROTOCOL_NAME,
+    .alloc = (NfcDeviceAlloc)ntag4xx_alloc,
+    .free = (NfcDeviceFree)ntag4xx_free,
+    .reset = (NfcDeviceReset)ntag4xx_reset,
+    .copy = (NfcDeviceCopy)ntag4xx_copy,
+    .verify = (NfcDeviceVerify)ntag4xx_verify,
+    .load = (NfcDeviceLoad)ntag4xx_load,
+    .save = (NfcDeviceSave)ntag4xx_save,
+    .is_equal = (NfcDeviceEqual)ntag4xx_is_equal,
+    .get_name = (NfcDeviceGetName)ntag4xx_get_device_name,
+    .get_uid = (NfcDeviceGetUid)ntag4xx_get_uid,
+    .set_uid = (NfcDeviceSetUid)ntag4xx_set_uid,
+    .get_base_data = (NfcDeviceGetBaseData)ntag4xx_get_base_data,
+};
+
+Ntag4xxData* ntag4xx_alloc(void) {
+    Ntag4xxData* data = malloc(sizeof(Ntag4xxData));
+    data->iso14443_4a_data = iso14443_4a_alloc();
+    data->device_name = furi_string_alloc();
+    return data;
+}
+
+void ntag4xx_free(Ntag4xxData* data) {
+    furi_check(data);
+
+    ntag4xx_reset(data);
+    iso14443_4a_free(data->iso14443_4a_data);
+    furi_string_free(data->device_name);
+    free(data);
+}
+
+void ntag4xx_reset(Ntag4xxData* data) {
+    furi_check(data);
+
+    iso14443_4a_reset(data->iso14443_4a_data);
+
+    memset(&data->version, 0, sizeof(Ntag4xxVersion));
+}
+
+void ntag4xx_copy(Ntag4xxData* data, const Ntag4xxData* other) {
+    furi_check(data);
+    furi_check(other);
+
+    ntag4xx_reset(data);
+
+    iso14443_4a_copy(data->iso14443_4a_data, other->iso14443_4a_data);
+
+    data->version = other->version;
+}
+
+bool ntag4xx_verify(Ntag4xxData* data, const FuriString* device_type) {
+    UNUSED(data);
+    UNUSED(device_type);
+
+    return false;
+}
+
+bool ntag4xx_load(Ntag4xxData* data, FlipperFormat* ff, uint32_t version) {
+    furi_check(data);
+    furi_check(ff);
+
+    FuriString* prefix = furi_string_alloc();
+
+    bool success = false;
+
+    do {
+        if(!iso14443_4a_load(data->iso14443_4a_data, ff, version)) break;
+
+        if(!ntag4xx_version_load(&data->version, ff)) break;
+
+        success = true;
+    } while(false);
+
+    furi_string_free(prefix);
+    return success;
+}
+
+bool ntag4xx_save(const Ntag4xxData* data, FlipperFormat* ff) {
+    furi_check(data);
+    furi_check(ff);
+
+    FuriString* prefix = furi_string_alloc();
+
+    bool success = false;
+
+    do {
+        if(!iso14443_4a_save(data->iso14443_4a_data, ff)) break;
+
+        if(!flipper_format_write_comment_cstr(ff, NTAG4XX_PROTOCOL_NAME " specific data")) break;
+        if(!ntag4xx_version_save(&data->version, ff)) break;
+
+        success = true;
+    } while(false);
+
+    furi_string_free(prefix);
+    return success;
+}
+
+bool ntag4xx_is_equal(const Ntag4xxData* data, const Ntag4xxData* other) {
+    furi_check(data);
+    furi_check(other);
+
+    return iso14443_4a_is_equal(data->iso14443_4a_data, other->iso14443_4a_data) &&
+           memcmp(&data->version, &other->version, sizeof(Ntag4xxVersion)) == 0;
+}
+
+Ntag4xxType ntag4xx_get_type_from_version(const Ntag4xxVersion* const version) {
+    Ntag4xxType type = Ntag4xxTypeUnknown;
+
+    switch(version->hw_major) {
+    case NTAG4XX_HW_MAJOR_TYPE_413_DNA:
+        type = Ntag4xxType413DNA;
+        break;
+    case NTAG4XX_HW_MAJOR_TYPE_424_DNA:
+        if(version->hw_subtype & NTAG4XX_HW_SUBTYPE_TAGTAMPER_FLAG) {
+            type = Ntag4xxType424DNATT;
+        } else {
+            type = Ntag4xxType424DNA;
+        }
+        break;
+    // TODO: there is no info online or in other implementations (NXP TagInfo, NFC Tools, Proxmark3)
+    // about what the HWMajorVersion is supposed to be for NTAG426Q DNA, and they don't seem to be for sale
+    // case NTAG4XX_HW_MAJOR_TYPE_426Q_DNA:
+    //     if(version->hw_subtype & NTAG4XX_HW_SUBTYPE_TAGTAMPER_FLAG) {
+    //         type = Ntag4xxType426QDNATT;
+    //     } else {
+    //         type = Ntag4xxType426QDNA;
+    //     }
+    //     break;
+    default:
+        break;
+    }
+
+    return type;
+}
+
+const char* ntag4xx_get_device_name(const Ntag4xxData* data, NfcDeviceNameType name_type) {
+    furi_check(data);
+
+    const Ntag4xxType type = ntag4xx_get_type_from_version(&data->version);
+
+    if(type == Ntag4xxTypeUnknown) {
+        furi_string_printf(data->device_name, "Unknown %s", NTAG4XX_PROTOCOL_NAME);
+    } else {
+        furi_string_printf(data->device_name, "%s", ntag4xx_type_strings[type]);
+        if(name_type == NfcDeviceNameTypeShort) {
+            furi_string_replace(data->device_name, "TagTamper", "TT");
+        }
+    }
+
+    return furi_string_get_cstr(data->device_name);
+}
+
+const uint8_t* ntag4xx_get_uid(const Ntag4xxData* data, size_t* uid_len) {
+    furi_check(data);
+    furi_check(uid_len);
+
+    return iso14443_4a_get_uid(data->iso14443_4a_data, uid_len);
+}
+
+bool ntag4xx_set_uid(Ntag4xxData* data, const uint8_t* uid, size_t uid_len) {
+    furi_check(data);
+
+    return iso14443_4a_set_uid(data->iso14443_4a_data, uid, uid_len);
+}
+
+Iso14443_4aData* ntag4xx_get_base_data(const Ntag4xxData* data) {
+    furi_check(data);
+
+    return data->iso14443_4a_data;
+}
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx.h b/lib/nfc/protocols/ntag4xx/ntag4xx.h
new file mode 100644
index 000000000..56e5fbd65
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx.h
@@ -0,0 +1,114 @@
+#pragma once
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NTAG4XX_UID_SIZE            (7)
+#define NTAG4XX_BATCH_SIZE          (4)
+#define NTAG4XX_BATCH_EXTRA_BITS    4
+#define NTAG4XX_FAB_KEY_SIZE_BITS_4 4
+#define NTAG4XX_FAB_KEY_SIZE_BITS_1 1
+#define NTAG4XX_PROD_WEEK_SIZE_BITS 7
+
+#define NTAG4XX_CMD_GET_VERSION (0x60)
+
+typedef enum {
+    Ntag4xxErrorNone,
+    Ntag4xxErrorNotPresent,
+    Ntag4xxErrorProtocol,
+    Ntag4xxErrorTimeout,
+} Ntag4xxError;
+
+typedef enum {
+    Ntag4xxType413DNA,
+    Ntag4xxType424DNA,
+    Ntag4xxType424DNATT,
+    Ntag4xxType426QDNA,
+    Ntag4xxType426QDNATT,
+
+    Ntag4xxTypeUnknown,
+    Ntag4xxTypeNum,
+} Ntag4xxType;
+
+#pragma pack(push, 1)
+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[NTAG4XX_UID_SIZE];
+    // [36b batch][5b fab key][7b prod week]
+    // 5b fab key is split 4b in last byte of batch and 1b in prod week
+    // Due to endianness, they appear swapped in the struct definition
+    uint8_t batch[NTAG4XX_BATCH_SIZE];
+    struct {
+        uint8_t fab_key_4b : NTAG4XX_FAB_KEY_SIZE_BITS_4;
+        uint8_t batch_extra : NTAG4XX_BATCH_EXTRA_BITS;
+    };
+    struct {
+        uint8_t prod_week : NTAG4XX_PROD_WEEK_SIZE_BITS;
+        uint8_t fab_key_1b : NTAG4XX_FAB_KEY_SIZE_BITS_1;
+    };
+    uint8_t prod_year;
+    struct {
+        uint8_t fab_key_id;
+    } optional;
+} Ntag4xxVersion;
+#pragma pack(pop)
+
+typedef struct {
+    Iso14443_4aData* iso14443_4a_data;
+    Ntag4xxVersion version;
+    FuriString* device_name;
+} Ntag4xxData;
+
+extern const NfcDeviceBase nfc_device_ntag4xx;
+
+// Virtual methods
+
+Ntag4xxData* ntag4xx_alloc(void);
+
+void ntag4xx_free(Ntag4xxData* data);
+
+void ntag4xx_reset(Ntag4xxData* data);
+
+void ntag4xx_copy(Ntag4xxData* data, const Ntag4xxData* other);
+
+bool ntag4xx_verify(Ntag4xxData* data, const FuriString* device_type);
+
+bool ntag4xx_load(Ntag4xxData* data, FlipperFormat* ff, uint32_t version);
+
+bool ntag4xx_save(const Ntag4xxData* data, FlipperFormat* ff);
+
+bool ntag4xx_is_equal(const Ntag4xxData* data, const Ntag4xxData* other);
+
+const char* ntag4xx_get_device_name(const Ntag4xxData* data, NfcDeviceNameType name_type);
+
+const uint8_t* ntag4xx_get_uid(const Ntag4xxData* data, size_t* uid_len);
+
+bool ntag4xx_set_uid(Ntag4xxData* data, const uint8_t* uid, size_t uid_len);
+
+Iso14443_4aData* ntag4xx_get_base_data(const Ntag4xxData* data);
+
+// Helpers
+
+Ntag4xxType ntag4xx_get_type_from_version(const Ntag4xxVersion* const version);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx_i.c b/lib/nfc/protocols/ntag4xx/ntag4xx_i.c
new file mode 100644
index 000000000..b4ee3a9eb
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx_i.c
@@ -0,0 +1,54 @@
+#include "ntag4xx_i.h"
+
+#define TAG "Ntag4xx"
+
+#define NTAG4XX_FFF_VERSION_KEY \
+    NTAG4XX_FFF_PICC_PREFIX " " \
+                            "Version"
+
+Ntag4xxError ntag4xx_process_error(Iso14443_4aError error) {
+    switch(error) {
+    case Iso14443_4aErrorNone:
+        return Ntag4xxErrorNone;
+    case Iso14443_4aErrorNotPresent:
+        return Ntag4xxErrorNotPresent;
+    case Iso14443_4aErrorTimeout:
+        return Ntag4xxErrorTimeout;
+    default:
+        return Ntag4xxErrorProtocol;
+    }
+}
+
+Ntag4xxError ntag4xx_process_status_code(uint8_t status_code) {
+    switch(status_code) {
+    case NXP_NATIVE_COMMAND_STATUS_OPERATION_OK:
+        return Ntag4xxErrorNone;
+    default:
+        return Ntag4xxErrorProtocol;
+    }
+}
+
+bool ntag4xx_version_parse(Ntag4xxVersion* data, const BitBuffer* buf) {
+    const size_t buf_size = bit_buffer_get_size_bytes(buf);
+    const bool can_parse = buf_size == sizeof(Ntag4xxVersion) ||
+                           buf_size == sizeof(Ntag4xxVersion) - sizeof(data->optional);
+
+    if(can_parse) {
+        bit_buffer_write_bytes(buf, data, sizeof(Ntag4xxVersion));
+        if(buf_size < sizeof(Ntag4xxVersion)) {
+            memset(&data->optional, 0, sizeof(data->optional));
+        }
+    }
+
+    return can_parse && (data->hw_type & 0x0F) == 0x04;
+}
+
+bool ntag4xx_version_load(Ntag4xxVersion* data, FlipperFormat* ff) {
+    return flipper_format_read_hex(
+        ff, NTAG4XX_FFF_VERSION_KEY, (uint8_t*)data, sizeof(Ntag4xxVersion));
+}
+
+bool ntag4xx_version_save(const Ntag4xxVersion* data, FlipperFormat* ff) {
+    return flipper_format_write_hex(
+        ff, NTAG4XX_FFF_VERSION_KEY, (const uint8_t*)data, sizeof(Ntag4xxVersion));
+}
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx_i.h b/lib/nfc/protocols/ntag4xx/ntag4xx_i.h
new file mode 100644
index 000000000..5a71cf05a
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx_i.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ntag4xx.h"
+
+#include <nfc/helpers/nxp_native_command.h>
+
+#define NTAG4XX_FFF_PICC_PREFIX "PICC"
+
+// Internal helpers
+
+Ntag4xxError ntag4xx_process_error(Iso14443_4aError error);
+
+Ntag4xxError ntag4xx_process_status_code(uint8_t status_code);
+
+// Parse internal Ntag4xx structures
+
+bool ntag4xx_version_parse(Ntag4xxVersion* data, const BitBuffer* buf);
+
+// Load internal Ntag4xx structures
+
+bool ntag4xx_version_load(Ntag4xxVersion* data, FlipperFormat* ff);
+
+// Save internal Ntag4xx structures
+
+bool ntag4xx_version_save(const Ntag4xxVersion* data, FlipperFormat* ff);
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx_poller.c b/lib/nfc/protocols/ntag4xx/ntag4xx_poller.c
new file mode 100644
index 000000000..38e6f19d4
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx_poller.c
@@ -0,0 +1,165 @@
+#include "ntag4xx_poller_i.h"
+
+#include <nfc/protocols/nfc_poller_base.h>
+
+#include <furi.h>
+
+#define TAG "Ntag4xxPoller"
+
+#define NTAG4XX_BUF_SIZE        (64U)
+#define NTAG4XX_RESULT_BUF_SIZE (512U)
+
+typedef NfcCommand (*Ntag4xxPollerReadHandler)(Ntag4xxPoller* instance);
+
+static const Ntag4xxData* ntag4xx_poller_get_data(Ntag4xxPoller* instance) {
+    furi_assert(instance);
+
+    return instance->data;
+}
+
+static Ntag4xxPoller* ntag4xx_poller_alloc(Iso14443_4aPoller* iso14443_4a_poller) {
+    Ntag4xxPoller* instance = malloc(sizeof(Ntag4xxPoller));
+    instance->iso14443_4a_poller = iso14443_4a_poller;
+    instance->data = ntag4xx_alloc();
+    instance->tx_buffer = bit_buffer_alloc(NTAG4XX_BUF_SIZE);
+    instance->rx_buffer = bit_buffer_alloc(NTAG4XX_BUF_SIZE);
+    instance->input_buffer = bit_buffer_alloc(NTAG4XX_BUF_SIZE);
+    instance->result_buffer = bit_buffer_alloc(NTAG4XX_RESULT_BUF_SIZE);
+
+    instance->ntag4xx_event.data = &instance->ntag4xx_event_data;
+
+    instance->general_event.protocol = NfcProtocolNtag4xx;
+    instance->general_event.event_data = &instance->ntag4xx_event;
+    instance->general_event.instance = instance;
+
+    return instance;
+}
+
+static void ntag4xx_poller_free(Ntag4xxPoller* instance) {
+    furi_assert(instance);
+
+    ntag4xx_free(instance->data);
+    bit_buffer_free(instance->tx_buffer);
+    bit_buffer_free(instance->rx_buffer);
+    bit_buffer_free(instance->input_buffer);
+    bit_buffer_free(instance->result_buffer);
+    free(instance);
+}
+
+static NfcCommand ntag4xx_poller_handler_idle(Ntag4xxPoller* 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 = Ntag4xxPollerStateReadVersion;
+    return NfcCommandContinue;
+}
+
+static NfcCommand ntag4xx_poller_handler_read_version(Ntag4xxPoller* instance) {
+    instance->error = ntag4xx_poller_read_version(instance, &instance->data->version);
+    if(instance->error == Ntag4xxErrorNone) {
+        FURI_LOG_D(TAG, "Read version success");
+        instance->state = Ntag4xxPollerStateReadSuccess;
+    } else {
+        FURI_LOG_E(TAG, "Failed to read version");
+        iso14443_4a_poller_halt(instance->iso14443_4a_poller);
+        instance->state = Ntag4xxPollerStateReadFailed;
+    }
+
+    return NfcCommandContinue;
+}
+
+static NfcCommand ntag4xx_poller_handler_read_failed(Ntag4xxPoller* instance) {
+    FURI_LOG_D(TAG, "Read Failed");
+    iso14443_4a_poller_halt(instance->iso14443_4a_poller);
+    instance->ntag4xx_event.type = Ntag4xxPollerEventTypeReadFailed;
+    instance->ntag4xx_event.data->error = instance->error;
+    NfcCommand command = instance->callback(instance->general_event, instance->context);
+    instance->state = Ntag4xxPollerStateIdle;
+    return command;
+}
+
+static NfcCommand ntag4xx_poller_handler_read_success(Ntag4xxPoller* instance) {
+    FURI_LOG_D(TAG, "Read success");
+    iso14443_4a_poller_halt(instance->iso14443_4a_poller);
+    instance->ntag4xx_event.type = Ntag4xxPollerEventTypeReadSuccess;
+    NfcCommand command = instance->callback(instance->general_event, instance->context);
+    return command;
+}
+
+static const Ntag4xxPollerReadHandler ntag4xx_poller_read_handler[Ntag4xxPollerStateNum] = {
+    [Ntag4xxPollerStateIdle] = ntag4xx_poller_handler_idle,
+    [Ntag4xxPollerStateReadVersion] = ntag4xx_poller_handler_read_version,
+    [Ntag4xxPollerStateReadFailed] = ntag4xx_poller_handler_read_failed,
+    [Ntag4xxPollerStateReadSuccess] = ntag4xx_poller_handler_read_success,
+};
+
+static void ntag4xx_poller_set_callback(
+    Ntag4xxPoller* instance,
+    NfcGenericCallback callback,
+    void* context) {
+    furi_assert(instance);
+    furi_assert(callback);
+
+    instance->callback = callback;
+    instance->context = context;
+}
+
+static NfcCommand ntag4xx_poller_run(NfcGenericEvent event, void* context) {
+    furi_assert(event.protocol == NfcProtocolIso14443_4a);
+
+    Ntag4xxPoller* instance = context;
+    furi_assert(instance);
+    furi_assert(instance->callback);
+
+    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 = ntag4xx_poller_read_handler[instance->state](instance);
+    } else if(iso14443_4a_event->type == Iso14443_4aPollerEventTypeError) {
+        instance->ntag4xx_event.type = Ntag4xxPollerEventTypeReadFailed;
+        command = instance->callback(instance->general_event, instance->context);
+    }
+
+    return command;
+}
+
+static bool ntag4xx_poller_detect(NfcGenericEvent event, void* context) {
+    furi_assert(event.protocol == NfcProtocolIso14443_4a);
+
+    Ntag4xxPoller* instance = context;
+    furi_assert(instance);
+
+    const Iso14443_4aPollerEvent* iso14443_4a_event = event.event_data;
+    furi_assert(iso14443_4a_event);
+
+    bool protocol_detected = false;
+
+    if(iso14443_4a_event->type == Iso14443_4aPollerEventTypeReady) {
+        do {
+            Ntag4xxError error = ntag4xx_poller_read_version(instance, &instance->data->version);
+            if(error != Ntag4xxErrorNone) break;
+
+            protocol_detected = true;
+        } while(false);
+    }
+
+    return protocol_detected;
+}
+
+const NfcPollerBase ntag4xx_poller = {
+    .alloc = (NfcPollerAlloc)ntag4xx_poller_alloc,
+    .free = (NfcPollerFree)ntag4xx_poller_free,
+    .set_callback = (NfcPollerSetCallback)ntag4xx_poller_set_callback,
+    .run = (NfcPollerRun)ntag4xx_poller_run,
+    .detect = (NfcPollerDetect)ntag4xx_poller_detect,
+    .get_data = (NfcPollerGetData)ntag4xx_poller_get_data,
+};
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx_poller.h b/lib/nfc/protocols/ntag4xx/ntag4xx_poller.h
new file mode 100644
index 000000000..ce7adc785
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx_poller.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "ntag4xx.h"
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a_poller.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Ntag4xxPoller opaque type definition.
+ */
+typedef struct Ntag4xxPoller Ntag4xxPoller;
+
+/**
+ * @brief Enumeration of possible Ntag4xx poller event types.
+ */
+typedef enum {
+    Ntag4xxPollerEventTypeReadSuccess, /**< Card was read successfully. */
+    Ntag4xxPollerEventTypeReadFailed, /**< Poller failed to read card. */
+} Ntag4xxPollerEventType;
+
+/**
+ * @brief Ntag4xx poller event data.
+ */
+typedef union {
+    Ntag4xxError error; /**< Error code indicating card reading fail reason. */
+} Ntag4xxPollerEventData;
+
+/**
+ * @brief Ntag4xx poller event structure.
+ *
+ * Upon emission of an event, an instance of this struct will be passed to the callback.
+ */
+typedef struct {
+    Ntag4xxPollerEventType type; /**< Type of emmitted event. */
+    Ntag4xxPollerEventData* data; /**< Pointer to event specific data. */
+} Ntag4xxPollerEvent;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx_poller_defs.h b/lib/nfc/protocols/ntag4xx/ntag4xx_poller_defs.h
new file mode 100644
index 000000000..ac0cdce9b
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx_poller_defs.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include <nfc/protocols/nfc_poller_base.h>
+
+extern const NfcPollerBase ntag4xx_poller;
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.c b/lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.c
new file mode 100644
index 000000000..5b8b7191d
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.c
@@ -0,0 +1,52 @@
+#include "ntag4xx_poller_i.h"
+
+#include <furi.h>
+
+#include "ntag4xx_i.h"
+
+#define TAG "Ntag4xxPoller"
+
+Ntag4xxError ntag4xx_poller_send_chunks(
+    Ntag4xxPoller* instance,
+    const BitBuffer* tx_buffer,
+    BitBuffer* rx_buffer) {
+    furi_check(instance);
+
+    NxpNativeCommandStatus status_code = NXP_NATIVE_COMMAND_STATUS_OPERATION_OK;
+    Iso14443_4aError iso14443_4a_error = nxp_native_command_iso14443_4a_poller(
+        instance->iso14443_4a_poller,
+        &status_code,
+        tx_buffer,
+        rx_buffer,
+        NxpNativeCommandModeIsoWrapped,
+        instance->tx_buffer,
+        instance->rx_buffer);
+
+    if(iso14443_4a_error != Iso14443_4aErrorNone) {
+        return ntag4xx_process_error(iso14443_4a_error);
+    }
+
+    return ntag4xx_process_status_code(status_code);
+}
+
+Ntag4xxError ntag4xx_poller_read_version(Ntag4xxPoller* instance, Ntag4xxVersion* data) {
+    furi_check(instance);
+
+    bit_buffer_reset(instance->input_buffer);
+    bit_buffer_append_byte(instance->input_buffer, NTAG4XX_CMD_GET_VERSION);
+
+    Ntag4xxError error;
+
+    do {
+        error =
+            ntag4xx_poller_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+
+        if(error != Ntag4xxErrorNone) break;
+
+        if(!ntag4xx_version_parse(data, instance->result_buffer)) {
+            error = Ntag4xxErrorProtocol;
+        }
+    } while(false);
+
+    return error;
+}
diff --git a/lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.h b/lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.h
new file mode 100644
index 000000000..b77e694ef
--- /dev/null
+++ b/lib/nfc/protocols/ntag4xx/ntag4xx_poller_i.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "ntag4xx_poller.h"
+
+#include <lib/nfc/protocols/iso14443_4a/iso14443_4a_poller_i.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    Ntag4xxPollerStateIdle,
+    Ntag4xxPollerStateReadVersion,
+    Ntag4xxPollerStateReadFailed,
+    Ntag4xxPollerStateReadSuccess,
+
+    Ntag4xxPollerStateNum,
+} Ntag4xxPollerState;
+
+struct Ntag4xxPoller {
+    Iso14443_4aPoller* iso14443_4a_poller;
+    Ntag4xxPollerState state;
+    Ntag4xxError error;
+    Ntag4xxData* data;
+    BitBuffer* tx_buffer;
+    BitBuffer* rx_buffer;
+    BitBuffer* input_buffer;
+    BitBuffer* result_buffer;
+    Ntag4xxPollerEventData ntag4xx_event_data;
+    Ntag4xxPollerEvent ntag4xx_event;
+    NfcGenericEvent general_event;
+    NfcGenericCallback callback;
+    void* context;
+};
+
+Ntag4xxError ntag4xx_poller_read_version(Ntag4xxPoller* instance, Ntag4xxVersion* data);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/targets/f18/api_symbols.csv b/targets/f18/api_symbols.csv
index ae056b56c..420daf3fd 100644
--- a/targets/f18/api_symbols.csv
+++ b/targets/f18/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,82.2,,
+Version,+,82.3,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
 Header,+,applications/services/cli/cli.h,,
diff --git a/targets/f7/api_symbols.csv b/targets/f7/api_symbols.csv
index 2696643d8..937fe2780 100644
--- a/targets/f7/api_symbols.csv
+++ b/targets/f7/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,82.2,,
+Version,+,82.3,,
 Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
@@ -167,6 +167,8 @@ 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,,
 Header,+,lib/nfc/protocols/mf_ultralight/mf_ultralight_poller_sync.h,,
+Header,+,lib/nfc/protocols/ntag4xx/ntag4xx.h,,
+Header,+,lib/nfc/protocols/ntag4xx/ntag4xx_poller.h,,
 Header,+,lib/nfc/protocols/slix/slix.h,,
 Header,+,lib/nfc/protocols/slix/slix_listener.h,,
 Header,+,lib/nfc/protocols/slix/slix_poller.h,,
@@ -2895,6 +2897,19 @@ Function,+,notification_internal_message_block,void,"NotificationApp*, const Not
 Function,+,notification_message,void,"NotificationApp*, const NotificationSequence*"
 Function,+,notification_message_block,void,"NotificationApp*, const NotificationSequence*"
 Function,-,nrand48,long,unsigned short[3]
+Function,+,ntag4xx_alloc,Ntag4xxData*,
+Function,+,ntag4xx_copy,void,"Ntag4xxData*, const Ntag4xxData*"
+Function,+,ntag4xx_free,void,Ntag4xxData*
+Function,+,ntag4xx_get_base_data,Iso14443_4aData*,const Ntag4xxData*
+Function,+,ntag4xx_get_device_name,const char*,"const Ntag4xxData*, NfcDeviceNameType"
+Function,+,ntag4xx_get_type_from_version,Ntag4xxType,const Ntag4xxVersion*
+Function,+,ntag4xx_get_uid,const uint8_t*,"const Ntag4xxData*, size_t*"
+Function,+,ntag4xx_is_equal,_Bool,"const Ntag4xxData*, const Ntag4xxData*"
+Function,+,ntag4xx_load,_Bool,"Ntag4xxData*, FlipperFormat*, uint32_t"
+Function,+,ntag4xx_reset,void,Ntag4xxData*
+Function,+,ntag4xx_save,_Bool,"const Ntag4xxData*, FlipperFormat*"
+Function,+,ntag4xx_set_uid,_Bool,"Ntag4xxData*, const uint8_t*, size_t"
+Function,+,ntag4xx_verify,_Bool,"Ntag4xxData*, const FuriString*"
 Function,+,number_input_alloc,NumberInput*,
 Function,+,number_input_free,void,NumberInput*
 Function,+,number_input_get_view,View*,NumberInput*
@@ -4022,6 +4037,7 @@ Variable,-,nfc_device_mf_classic,const NfcDeviceBase,
 Variable,-,nfc_device_mf_desfire,const NfcDeviceBase,
 Variable,-,nfc_device_mf_plus,const NfcDeviceBase,
 Variable,-,nfc_device_mf_ultralight,const NfcDeviceBase,
+Variable,-,nfc_device_ntag4xx,const NfcDeviceBase,
 Variable,-,nfc_device_st25tb,const NfcDeviceBase,
 Variable,+,sequence_audiovisual_alert,const NotificationSequence,
 Variable,+,sequence_blink_blue_10,const NotificationSequence,

From d362cb51e39a69b54967fd5b6d471c9b4007039d Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:51:03 +0000
Subject: [PATCH 4/8] NFC: Allow choosing DESFire poller cmd mode, fix
 send_chunks() naming

---
 .../protocols/mf_desfire/mf_desfire_poller.h  | 18 +++++++-
 .../mf_desfire/mf_desfire_poller_i.c          | 42 +++++++++++++------
 .../mf_desfire/mf_desfire_poller_i.h          |  1 +
 targets/f18/api_symbols.csv                   |  2 +-
 targets/f7/api_symbols.csv                    |  5 ++-
 5 files changed, 52 insertions(+), 16 deletions(-)

diff --git a/lib/nfc/protocols/mf_desfire/mf_desfire_poller.h b/lib/nfc/protocols/mf_desfire/mf_desfire_poller.h
index 707df42cd..8ac4627bb 100644
--- a/lib/nfc/protocols/mf_desfire/mf_desfire_poller.h
+++ b/lib/nfc/protocols/mf_desfire/mf_desfire_poller.h
@@ -3,6 +3,7 @@
 #include "mf_desfire.h"
 
 #include <lib/nfc/protocols/iso14443_4a/iso14443_4a_poller.h>
+#include <lib/nfc/helpers/nxp_native_command_mode.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -38,6 +39,16 @@ typedef struct {
     MfDesfirePollerEventData* data; /**< Pointer to event specific data. */
 } MfDesfirePollerEvent;
 
+/**
+ * @brief Change command mode used in poller mode.
+ *
+ * @param[in, out] instance pointer to the instance to affect.
+ * @param[in] command_mode command mode to use in further communication with the card.
+ */
+void mf_desfire_poller_set_command_mode(
+    MfDesfirePoller* instance,
+    NxpNativeCommandMode command_mode);
+
 /**
  * @brief Transmit and receive MfDesfire chunks in poller mode.
  *
@@ -51,11 +62,16 @@ typedef struct {
  * @param[out] rx_buffer pointer to the buffer to be filled with received data.
  * @return MfDesfireErrorNone on success, an error code on failure.
  */
-MfDesfireError mf_desfire_send_chunks(
+MfDesfireError mf_desfire_poller_send_chunks(
     MfDesfirePoller* instance,
     const BitBuffer* tx_buffer,
     BitBuffer* rx_buffer);
 
+/**
+  * @warning deprecated, use mf_desfire_poller_send_chunks instead
+  */
+#define mf_desfire_send_chunks mf_desfire_poller_send_chunks
+
 /**
  * @brief Read MfDesfire card version.
  *
diff --git a/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c b/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c
index f54133e3c..ebb1d91d0 100644
--- a/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c
+++ b/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.c
@@ -32,7 +32,17 @@ MfDesfireError mf_desfire_process_status_code(uint8_t status_code) {
     }
 }
 
-MfDesfireError mf_desfire_send_chunks(
+void mf_desfire_poller_set_command_mode(
+    MfDesfirePoller* instance,
+    NxpNativeCommandMode command_mode) {
+    furi_check(instance);
+    furi_check(instance->state == MfDesfirePollerStateIdle);
+    furi_check(command_mode < NxpNativeCommandModeMAX);
+
+    instance->command_mode = command_mode;
+}
+
+MfDesfireError mf_desfire_poller_send_chunks(
     MfDesfirePoller* instance,
     const BitBuffer* tx_buffer,
     BitBuffer* rx_buffer) {
@@ -44,7 +54,7 @@ MfDesfireError mf_desfire_send_chunks(
         &status_code,
         tx_buffer,
         rx_buffer,
-        NxpNativeCommandModePlain,
+        instance->command_mode,
         instance->tx_buffer,
         instance->rx_buffer);
 
@@ -64,7 +74,8 @@ MfDesfireError mf_desfire_poller_read_version(MfDesfirePoller* instance, MfDesfi
     MfDesfireError error;
 
     do {
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
 
         if(error != MfDesfireErrorNone) break;
 
@@ -86,7 +97,8 @@ MfDesfireError
     MfDesfireError error;
 
     do {
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
 
         if(error != MfDesfireErrorNone) break;
 
@@ -108,7 +120,8 @@ MfDesfireError
     MfDesfireError error;
 
     do {
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
 
         if(error != MfDesfireErrorNone) break;
 
@@ -132,7 +145,7 @@ MfDesfireError mf_desfire_poller_read_key_version(
     bit_buffer_set_byte(instance->input_buffer, 1, key_num);
 
     MfDesfireError error =
-        mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        mf_desfire_poller_send_chunks(instance, instance->input_buffer, instance->result_buffer);
     if(error == MfDesfireErrorNone) {
         if(!mf_desfire_key_version_parse(data, instance->result_buffer)) {
             error = MfDesfireErrorProtocol;
@@ -172,7 +185,8 @@ MfDesfireError
     MfDesfireError error;
 
     do {
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
 
         if(error != MfDesfireErrorNone) break;
 
@@ -205,7 +219,7 @@ MfDesfireError mf_desfire_poller_select_application(
         instance->input_buffer, (const uint8_t*)id, sizeof(MfDesfireApplicationId));
 
     MfDesfireError error =
-        mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        mf_desfire_poller_send_chunks(instance, instance->input_buffer, instance->result_buffer);
 
     return error;
 }
@@ -220,7 +234,8 @@ MfDesfireError mf_desfire_poller_read_file_ids(MfDesfirePoller* instance, Simple
     MfDesfireError error;
 
     do {
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
 
         if(error != MfDesfireErrorNone) break;
 
@@ -255,7 +270,8 @@ MfDesfireError mf_desfire_poller_read_file_settings(
     MfDesfireError error;
 
     do {
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
 
         if(error != MfDesfireErrorNone) break;
 
@@ -316,7 +332,8 @@ static MfDesfireError mf_desfire_poller_read_file(
         bit_buffer_append_bytes(instance->input_buffer, (const uint8_t*)&current_offset, 3);
         bit_buffer_append_bytes(instance->input_buffer, (const uint8_t*)&bytes_to_read, 3);
 
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
         if(error != MfDesfireErrorNone) break;
 
         size_t bytes_received = bit_buffer_get_size_bytes(instance->result_buffer);
@@ -362,7 +379,8 @@ MfDesfireError mf_desfire_poller_read_file_value(
     MfDesfireError error;
 
     do {
-        error = mf_desfire_send_chunks(instance, instance->input_buffer, instance->result_buffer);
+        error = mf_desfire_poller_send_chunks(
+            instance, instance->input_buffer, instance->result_buffer);
 
         if(error != MfDesfireErrorNone) break;
 
diff --git a/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.h b/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.h
index 19e38bebb..179fd44b5 100644
--- a/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.h
+++ b/lib/nfc/protocols/mf_desfire/mf_desfire_poller_i.h
@@ -30,6 +30,7 @@ typedef enum {
 
 struct MfDesfirePoller {
     Iso14443_4aPoller* iso14443_4a_poller;
+    NxpNativeCommandMode command_mode;
     MfDesfirePollerSessionState session_state;
     MfDesfirePollerState state;
     MfDesfireError error;
diff --git a/targets/f18/api_symbols.csv b/targets/f18/api_symbols.csv
index 420daf3fd..d21b87668 100644
--- a/targets/f18/api_symbols.csv
+++ b/targets/f18/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,82.3,,
+Version,+,83.0,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
 Header,+,applications/services/cli/cli.h,,
diff --git a/targets/f7/api_symbols.csv b/targets/f7/api_symbols.csv
index 937fe2780..c48d4dd11 100644
--- a/targets/f7/api_symbols.csv
+++ b/targets/f7/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,82.3,,
+Version,+,83.0,,
 Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/bt/bt_service/bt_keys_storage.h,,
@@ -2647,9 +2647,10 @@ Function,+,mf_desfire_poller_read_key_version,MfDesfireError,"MfDesfirePoller*,
 Function,+,mf_desfire_poller_read_key_versions,MfDesfireError,"MfDesfirePoller*, SimpleArray*, uint32_t"
 Function,+,mf_desfire_poller_read_version,MfDesfireError,"MfDesfirePoller*, MfDesfireVersion*"
 Function,+,mf_desfire_poller_select_application,MfDesfireError,"MfDesfirePoller*, const MfDesfireApplicationId*"
+Function,+,mf_desfire_poller_send_chunks,MfDesfireError,"MfDesfirePoller*, const BitBuffer*, BitBuffer*"
+Function,+,mf_desfire_poller_set_command_mode,void,"MfDesfirePoller*, NxpNativeCommandMode"
 Function,+,mf_desfire_reset,void,MfDesfireData*
 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*,

From bd6e5f8240c902a0bce53c6cbf254fc7ecdc0c16 Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:53:40 +0000
Subject: [PATCH 5/8] NFC: Check MIFARE types with HWType lower nibble

See: https://www.nxp.com/docs/en/application-note/AN10833.pdf
---
 lib/nfc/protocols/mf_desfire/mf_desfire_i.c | 2 +-
 lib/nfc/protocols/mf_plus/mf_plus_i.c       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/nfc/protocols/mf_desfire/mf_desfire_i.c b/lib/nfc/protocols/mf_desfire/mf_desfire_i.c
index d83a91ad1..ba4311527 100644
--- a/lib/nfc/protocols/mf_desfire/mf_desfire_i.c
+++ b/lib/nfc/protocols/mf_desfire/mf_desfire_i.c
@@ -54,7 +54,7 @@ bool mf_desfire_version_parse(MfDesfireVersion* data, const BitBuffer* buf) {
         bit_buffer_write_bytes(buf, data, sizeof(MfDesfireVersion));
     }
 
-    return can_parse;
+    return can_parse && (data->hw_type & 0x0F) == 0x01;
 }
 
 bool mf_desfire_free_memory_parse(MfDesfireFreeMemory* data, const BitBuffer* buf) {
diff --git a/lib/nfc/protocols/mf_plus/mf_plus_i.c b/lib/nfc/protocols/mf_plus/mf_plus_i.c
index bd32956d6..8f06a644a 100644
--- a/lib/nfc/protocols/mf_plus/mf_plus_i.c
+++ b/lib/nfc/protocols/mf_plus/mf_plus_i.c
@@ -27,7 +27,7 @@ MfPlusError mf_plus_get_type_from_version(
 
     MfPlusError error = MfPlusErrorProtocol;
 
-    if(mf_plus_data->version.hw_type == 0x02 || mf_plus_data->version.hw_type == 0x82) {
+    if((mf_plus_data->version.hw_type & 0x0F) == 0x02) {
         error = MfPlusErrorNone;
         // Mifare Plus EV1/EV2
 

From 9b3d97087c34bd043d83e2ab2aceaa1ba4b5b705 Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:55:28 +0000
Subject: [PATCH 6/8] NFC: Refactor MIFARE Plus with NxpNativeCommand helper

---
 lib/nfc/protocols/mf_plus/mf_plus_i.c        | 16 ++-------
 lib/nfc/protocols/mf_plus/mf_plus_i.h        |  5 ++-
 lib/nfc/protocols/mf_plus/mf_plus_poller_i.c | 38 ++++++++++++--------
 3 files changed, 28 insertions(+), 31 deletions(-)

diff --git a/lib/nfc/protocols/mf_plus/mf_plus_i.c b/lib/nfc/protocols/mf_plus/mf_plus_i.c
index 8f06a644a..42f16079c 100644
--- a/lib/nfc/protocols/mf_plus/mf_plus_i.c
+++ b/lib/nfc/protocols/mf_plus/mf_plus_i.c
@@ -238,22 +238,12 @@ MfPlusError
 }
 
 MfPlusError mf_plus_version_parse(MfPlusVersion* data, const BitBuffer* buf) {
-    bool can_parse = bit_buffer_get_size_bytes(buf) == sizeof(MfPlusVersion);
+    const bool can_parse = bit_buffer_get_size_bytes(buf) == sizeof(MfPlusVersion);
 
     if(can_parse) {
         bit_buffer_write_bytes(buf, data, sizeof(MfPlusVersion));
-    } else if(
-        bit_buffer_get_size_bytes(buf) == 8 &&
-        bit_buffer_get_byte(buf, 0) == MF_PLUS_STATUS_ADDITIONAL_FRAME) {
-        // HACK(-nofl): There are supposed to be three parts to the GetVersion command,
-        // with the second and third parts fetched by sending the AdditionalFrame
-        // command. I don't know whether the entire MIFARE Plus line uses status as
-        // the first byte, so let's just assume we only have the first part of
-        // the response if it's size 8 and starts with the AF status. The second
-        // part of the response is the same size and status byte, but so far
-        // we're only reading one response.
-        can_parse = true;
-        bit_buffer_write_bytes_mid(buf, data, 1, bit_buffer_get_size_bytes(buf) - 1);
+    } else {
+        memset(data, 0, sizeof(MfPlusVersion));
     }
 
     return can_parse ? MfPlusErrorNone : MfPlusErrorProtocol;
diff --git a/lib/nfc/protocols/mf_plus/mf_plus_i.h b/lib/nfc/protocols/mf_plus/mf_plus_i.h
index 302f5a178..cadc435b9 100644
--- a/lib/nfc/protocols/mf_plus/mf_plus_i.h
+++ b/lib/nfc/protocols/mf_plus/mf_plus_i.h
@@ -2,10 +2,9 @@
 
 #include "mf_plus.h"
 
-#define MF_PLUS_FFF_PICC_PREFIX "PICC"
+#include <nfc/helpers/nxp_native_command.h>
 
-#define MF_PLUS_STATUS_OPERATION_OK     (0x90)
-#define MF_PLUS_STATUS_ADDITIONAL_FRAME (0xAF)
+#define MF_PLUS_FFF_PICC_PREFIX "PICC"
 
 MfPlusError mf_plus_get_type_from_version(
     const Iso14443_4aData* iso14443_4a_data,
diff --git a/lib/nfc/protocols/mf_plus/mf_plus_poller_i.c b/lib/nfc/protocols/mf_plus/mf_plus_poller_i.c
index cab906f1d..b2e4231ff 100644
--- a/lib/nfc/protocols/mf_plus/mf_plus_poller_i.c
+++ b/lib/nfc/protocols/mf_plus/mf_plus_poller_i.c
@@ -19,28 +19,36 @@ MfPlusError mf_plus_process_error(Iso14443_4aError error) {
     }
 }
 
-MfPlusError mf_plus_poller_send_chunk(
+MfPlusError mf_plus_process_status_code(uint8_t status_code) {
+    switch(status_code) {
+    case NXP_NATIVE_COMMAND_STATUS_OPERATION_OK:
+        return MfPlusErrorNone;
+    default:
+        return MfPlusErrorProtocol;
+    }
+}
+
+MfPlusError mf_plus_poller_send_chunks(
     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);
 
-    Iso14443_4aError iso14443_4a_error = iso14443_4a_poller_send_block(
-        instance->iso14443_4a_poller, tx_buffer, instance->rx_buffer);
-    MfPlusError error = mf_plus_process_error(iso14443_4a_error);
+    NxpNativeCommandStatus status_code = NXP_NATIVE_COMMAND_STATUS_OPERATION_OK;
+    Iso14443_4aError iso14443_4a_error = nxp_native_command_iso14443_4a_poller(
+        instance->iso14443_4a_poller,
+        &status_code,
+        tx_buffer,
+        rx_buffer,
+        NxpNativeCommandModePlain,
+        instance->tx_buffer,
+        instance->rx_buffer);
 
-    if(error == MfPlusErrorNone) {
-        bit_buffer_copy(rx_buffer, instance->rx_buffer);
+    if(iso14443_4a_error != Iso14443_4aErrorNone) {
+        return mf_plus_process_error(iso14443_4a_error);
     }
 
-    bit_buffer_reset(instance->tx_buffer);
-
-    return error;
+    return mf_plus_process_status_code(status_code);
 }
 
 MfPlusError mf_plus_poller_read_version(MfPlusPoller* instance, MfPlusVersion* data) {
@@ -50,7 +58,7 @@ MfPlusError mf_plus_poller_read_version(MfPlusPoller* instance, MfPlusVersion* d
     bit_buffer_append_byte(instance->input_buffer, MF_PLUS_CMD_GET_VERSION);
 
     MfPlusError error =
-        mf_plus_poller_send_chunk(instance, instance->input_buffer, instance->result_buffer);
+        mf_plus_poller_send_chunks(instance, instance->input_buffer, instance->result_buffer);
     if(error == MfPlusErrorNone) {
         error = mf_plus_version_parse(data, instance->result_buffer);
     }

From 4717966af80fc5e190076e1f4e45add7baf8a003 Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:57:24 +0000
Subject: [PATCH 7/8] NFC: Fix detecting MIFARE Plus SE 1K SL1/3

See: https://www.nxp.com/docs/en/application-note/AN10833.pdf
---
 lib/nfc/protocols/mf_plus/mf_plus_i.c | 64 +++++++++++----------------
 1 file changed, 26 insertions(+), 38 deletions(-)

diff --git a/lib/nfc/protocols/mf_plus/mf_plus_i.c b/lib/nfc/protocols/mf_plus/mf_plus_i.c
index 42f16079c..b66cf5ea2 100644
--- a/lib/nfc/protocols/mf_plus/mf_plus_i.c
+++ b/lib/nfc/protocols/mf_plus/mf_plus_i.c
@@ -15,8 +15,8 @@
 const uint8_t mf_plus_ats_t1_tk_values[][MF_PLUS_T1_TK_VALUE_LEN] = {
     {0xC1, 0x05, 0x2F, 0x2F, 0x00, 0x35, 0xC7}, // Mifare Plus S
     {0xC1, 0x05, 0x2F, 0x2F, 0x01, 0xBC, 0xD6}, // Mifare Plus X
-    {0xC1, 0x05, 0x2F, 0x2F, 0x00, 0xF6, 0xD1}, // Mifare Plus SE
-    {0xC1, 0x05, 0x2F, 0x2F, 0x01, 0xF6, 0xD1}, // Mifare Plus SE
+    {0xC1, 0x05, 0x21, 0x30, 0x00, 0xF6, 0xD1}, // Mifare Plus SE
+    {0xC1, 0x05, 0x21, 0x30, 0x10, 0xF6, 0xD1}, // Mifare Plus SE
 };
 
 MfPlusError mf_plus_get_type_from_version(
@@ -85,16 +85,15 @@ MfPlusError
 
     MfPlusError error = MfPlusErrorProtocol;
 
-    if(simple_array_get_count(iso4_data->ats_data.t1_tk) != MF_PLUS_T1_TK_VALUE_LEN) {
+    const size_t historical_bytes_len = simple_array_get_count(iso4_data->ats_data.t1_tk);
+    if(historical_bytes_len != MF_PLUS_T1_TK_VALUE_LEN) {
         return MfPlusErrorProtocol;
     }
+    const uint8_t* historical_bytes = simple_array_cget_data(iso4_data->ats_data.t1_tk);
 
     switch(iso4_data->iso14443_3a_data->sak) {
     case 0x08:
-        if(memcmp(
-               simple_array_get_data(iso4_data->ats_data.t1_tk),
-               mf_plus_ats_t1_tk_values[0],
-               simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0) {
+        if(memcmp(historical_bytes, mf_plus_ats_t1_tk_values[0], historical_bytes_len) == 0) {
             // Mifare Plus S 2K SL1
             mf_plus_data->type = MfPlusTypeS;
             mf_plus_data->size = MfPlusSize2K;
@@ -102,11 +101,7 @@ MfPlusError
 
             FURI_LOG_D(TAG, "Mifare Plus S 2K SL1");
             error = MfPlusErrorNone;
-        } else if(
-            memcmp(
-                simple_array_get_data(iso4_data->ats_data.t1_tk),
-                mf_plus_ats_t1_tk_values[1],
-                simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0) {
+        } else if(memcmp(historical_bytes, mf_plus_ats_t1_tk_values[1], historical_bytes_len) == 0) {
             // Mifare Plus X 2K SL1
             mf_plus_data->type = MfPlusTypeX;
             mf_plus_data->size = MfPlusSize2K;
@@ -115,14 +110,8 @@ MfPlusError
             FURI_LOG_D(TAG, "Mifare Plus X 2K SL1");
             error = MfPlusErrorNone;
         } else if(
-            memcmp(
-                simple_array_get_data(iso4_data->ats_data.t1_tk),
-                mf_plus_ats_t1_tk_values[2],
-                simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0 ||
-            memcmp(
-                simple_array_get_data(iso4_data->ats_data.t1_tk),
-                mf_plus_ats_t1_tk_values[3],
-                simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0) {
+            memcmp(historical_bytes, mf_plus_ats_t1_tk_values[2], historical_bytes_len) == 0 ||
+            memcmp(historical_bytes, mf_plus_ats_t1_tk_values[3], historical_bytes_len) == 0) {
             // Mifare Plus SE 1K SL1
             mf_plus_data->type = MfPlusTypeSE;
             mf_plus_data->size = MfPlusSize1K;
@@ -154,10 +143,7 @@ MfPlusError
 
         break;
     case 0x18:
-        if(memcmp(
-               simple_array_get_data(iso4_data->ats_data.t1_tk),
-               mf_plus_ats_t1_tk_values[0],
-               simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0) {
+        if(memcmp(historical_bytes, mf_plus_ats_t1_tk_values[0], historical_bytes_len) == 0) {
             // Mifare Plus S 4K SL1
             mf_plus_data->type = MfPlusTypeS;
             mf_plus_data->size = MfPlusSize4K;
@@ -165,11 +151,7 @@ MfPlusError
 
             FURI_LOG_D(TAG, "Mifare Plus S 4K SL1");
             error = MfPlusErrorNone;
-        } else if(
-            memcmp(
-                simple_array_get_data(iso4_data->ats_data.t1_tk),
-                mf_plus_ats_t1_tk_values[1],
-                simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0) {
+        } else if(memcmp(historical_bytes, mf_plus_ats_t1_tk_values[1], historical_bytes_len) == 0) {
             // Mifare Plus X 4K SL1
             mf_plus_data->type = MfPlusTypeX;
             mf_plus_data->size = MfPlusSize4K;
@@ -183,10 +165,7 @@ MfPlusError
 
         break;
     case 0x20:
-        if(memcmp(
-               simple_array_get_data(iso4_data->ats_data.t1_tk),
-               mf_plus_ats_t1_tk_values[0],
-               simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0) {
+        if(memcmp(historical_bytes, mf_plus_ats_t1_tk_values[0], historical_bytes_len) == 0) {
             // Mifare Plus S 2/4K SL3
             FURI_LOG_D(TAG, "Mifare Plus S SL3");
             mf_plus_data->type = MfPlusTypeS;
@@ -207,21 +186,20 @@ MfPlusError
             } else {
                 FURI_LOG_D(TAG, "Sak 20 but no known Mifare Plus type (S)");
             }
-        } else if(
-            memcmp(
-                simple_array_get_data(iso4_data->ats_data.t1_tk),
-                mf_plus_ats_t1_tk_values[1],
-                simple_array_get_count(iso4_data->ats_data.t1_tk)) == 0) {
+        } else if(memcmp(historical_bytes, mf_plus_ats_t1_tk_values[1], historical_bytes_len) == 0) {
+            // Mifare Plus X 2/4K SL3
             mf_plus_data->type = MfPlusTypeX;
             mf_plus_data->security_level = MfPlusSecurityLevel3;
             FURI_LOG_D(TAG, "Mifare Plus X SL3");
 
             if((iso4_data->iso14443_3a_data->atqa[0] & 0x0F) == 0x04) {
+                // Mifare Plus X 2K SL3
                 mf_plus_data->size = MfPlusSize2K;
 
                 FURI_LOG_D(TAG, "Mifare Plus X 2K SL3");
                 error = MfPlusErrorNone;
             } else if((iso4_data->iso14443_3a_data->atqa[0] & 0x0F) == 0x02) {
+                // Mifare Plus X 4K SL3
                 mf_plus_data->size = MfPlusSize4K;
 
                 FURI_LOG_D(TAG, "Mifare Plus X 4K SL3");
@@ -229,6 +207,16 @@ MfPlusError
             } else {
                 FURI_LOG_D(TAG, "Sak 20 but no known Mifare Plus type (X)");
             }
+        } else if(
+            memcmp(historical_bytes, mf_plus_ats_t1_tk_values[2], historical_bytes_len) == 0 ||
+            memcmp(historical_bytes, mf_plus_ats_t1_tk_values[3], historical_bytes_len) == 0) {
+            // Mifare Plus SE 1K SL3
+            mf_plus_data->type = MfPlusTypeSE;
+            mf_plus_data->size = MfPlusSize1K;
+            mf_plus_data->security_level = MfPlusSecurityLevel3;
+
+            FURI_LOG_D(TAG, "Mifare Plus SE 1K SL3");
+            error = MfPlusErrorNone;
         } else {
             FURI_LOG_D(TAG, "Sak 20 but no known Mifare Plus type");
         }

From ec97852939494c631d31fb930a56ce05373c1de5 Mon Sep 17 00:00:00 2001
From: Willy-JL <49810075+Willy-JL@users.noreply.github.com>
Date: Thu, 27 Mar 2025 04:58:23 +0000
Subject: [PATCH 8/8] NFC: Show MIFARE Plus EV1/2 GetVersion info like DESFire

---
 .../helpers/protocol_support/mf_plus/mf_plus.c | 18 ++++++++++++++++--
 .../protocol_support/mf_plus/mf_plus_render.c  | 16 +++++++++++++++-
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus.c b/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus.c
index c7b36e21e..e6746e090 100644
--- a/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus.c
+++ b/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus.c
@@ -25,6 +25,20 @@ static void nfc_scene_info_on_enter_mf_plus(NfcApp* instance) {
 
     furi_string_free(temp_str);
 }
+
+static void nfc_scene_more_info_on_enter_mf_plus(NfcApp* instance) {
+    const NfcDevice* device = instance->nfc_device;
+    const MfPlusData* data = nfc_device_get_data(device, NfcProtocolMfPlus);
+
+    furi_string_reset(instance->text_box_store);
+    nfc_render_mf_plus_data(data, instance->text_box_store);
+
+    text_box_set_font(instance->text_box, TextBoxFontHex);
+    text_box_set_text(instance->text_box, furi_string_get_cstr(instance->text_box_store));
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewTextBox);
+}
+
 static NfcCommand nfc_scene_read_poller_callback_mf_plus(NfcGenericEvent event, void* context) {
     furi_assert(context);
     furi_assert(event.protocol == NfcProtocolMfPlus);
@@ -78,7 +92,7 @@ static void nfc_scene_emulate_on_enter_mf_plus(NfcApp* instance) {
 }
 
 const NfcProtocolSupportBase nfc_protocol_support_mf_plus = {
-    .features = NfcProtocolFeatureEmulateUid,
+    .features = NfcProtocolFeatureEmulateUid | NfcProtocolFeatureMoreInfo,
 
     .scene_info =
         {
@@ -87,7 +101,7 @@ const NfcProtocolSupportBase nfc_protocol_support_mf_plus = {
         },
     .scene_more_info =
         {
-            .on_enter = nfc_protocol_support_common_on_enter_empty,
+            .on_enter = nfc_scene_more_info_on_enter_mf_plus,
             .on_event = nfc_protocol_support_common_on_event_empty,
         },
     .scene_read =
diff --git a/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus_render.c b/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus_render.c
index 8640fa16d..2311004ad 100644
--- a/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus_render.c
+++ b/applications/main/nfc/helpers/protocol_support/mf_plus/mf_plus_render.c
@@ -15,7 +15,21 @@ void nfc_render_mf_plus_info(
 }
 
 void nfc_render_mf_plus_data(const MfPlusData* data, FuriString* str) {
-    nfc_render_mf_plus_version(&data->version, str);
+    MfPlusVersion empty_version = {0};
+    if(memcmp(&data->version, &empty_version, sizeof(MfPlusVersion)) == 0) {
+        const char* device_name = mf_plus_get_device_name(data, NfcDeviceNameTypeFull);
+        if(data->type == MfPlusTypeUnknown || data->size == MfPlusSizeUnknown ||
+           data->security_level == MfPlusSecurityLevelUnknown) {
+            furi_string_cat_printf(str, "This %s", device_name);
+            furi_string_replace(str, " Unknown", "");
+        } else {
+            furi_string_cat(str, device_name);
+        }
+        furi_string_replace(str, "Mifare", "MIFARE");
+        furi_string_cat(str, " does not support the GetVersion command, extra info unavailable\n");
+    } else {
+        nfc_render_mf_plus_version(&data->version, str);
+    }
 }
 
 void nfc_render_mf_plus_version(const MfPlusVersion* data, FuriString* str) {