From 6a5d63803aeadc9f2b3cb4f150bb32dee841dc03 Mon Sep 17 00:00:00 2001
From: RebornedBrain <138568282+RebornedBrain@users.noreply.github.com>
Date: Sat, 2 Dec 2023 07:45:47 +0300
Subject: [PATCH 1/5] [FL-3675] Ntag21x write (#3246)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* New scenes for ultralight poller write mode
* Added new button and transition logic for write operation
   For now write is only possible for NTAG21x cards with default password and no AUTHLIM set
* Poller states extended
* Enums and datatypes extended for new poller mode
* Added mode field to poller instance datatype
* New states for poller added in order to implement write mode
* Added new event type for locked cards in order to simplify state flow
* New logic for poller write commands
* Scenes adjustments
* Scenes renamed
* New field added to poller instance
* Now we write in 'page per call' mode
* Now function takes callback return value into account
* Callback will be called only in write mode
* Event type added
* Log adjusted and start page to write set
* Logs added and check in now false at start, then it moves to true
* Now mf_ultralight_poller_handler_request_write_data halts card in case of check failure and stops poller
* All fail events now returns NfcCommandStop callback
* In case of fail we move back properly
* Remove garbage

Co-authored-by: gornekich <n.gorbadey@gmail.com>
Co-authored-by: あく <alleteam@gmail.com>
---
 .../mf_ultralight/mf_ultralight.c             |  13 ++
 .../main/nfc/scenes/nfc_scene_config.h        |   4 +
 .../scenes/nfc_scene_mf_ultralight_write.c    | 119 +++++++++++++++
 .../nfc_scene_mf_ultralight_write_fail.c      |  67 +++++++++
 .../nfc_scene_mf_ultralight_write_success.c   |  43 ++++++
 .../nfc_scene_mf_ultralight_wrong_card.c      |  58 ++++++++
 .../mf_ultralight/mf_ultralight_poller.c      | 139 +++++++++++++++++-
 .../mf_ultralight/mf_ultralight_poller.h      |  16 ++
 .../mf_ultralight/mf_ultralight_poller_i.h    |   7 +
 9 files changed, 462 insertions(+), 4 deletions(-)
 create mode 100644 applications/main/nfc/scenes/nfc_scene_mf_ultralight_write.c
 create mode 100644 applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_fail.c
 create mode 100644 applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_success.c
 create mode 100644 applications/main/nfc/scenes/nfc_scene_mf_ultralight_wrong_card.c

diff --git a/applications/main/nfc/helpers/protocol_support/mf_ultralight/mf_ultralight.c b/applications/main/nfc/helpers/protocol_support/mf_ultralight/mf_ultralight.c
index c4fd04c7e..3e27fc539 100644
--- a/applications/main/nfc/helpers/protocol_support/mf_ultralight/mf_ultralight.c
+++ b/applications/main/nfc/helpers/protocol_support/mf_ultralight/mf_ultralight.c
@@ -12,6 +12,7 @@ enum {
     SubmenuIndexUnlock = SubmenuIndexCommonMax,
     SubmenuIndexUnlockByReader,
     SubmenuIndexUnlockByPassword,
+    SubmenuIndexWrite,
 };
 
 static void nfc_scene_info_on_enter_mf_ultralight(NfcApp* instance) {
@@ -106,6 +107,15 @@ static void nfc_scene_read_and_saved_menu_on_enter_mf_ultralight(NfcApp* instanc
             SubmenuIndexUnlock,
             nfc_protocol_support_common_submenu_callback,
             instance);
+    } else if(
+        data->type == MfUltralightTypeNTAG213 || data->type == MfUltralightTypeNTAG215 ||
+        data->type == MfUltralightTypeNTAG216) {
+        submenu_add_item(
+            submenu,
+            "Write",
+            SubmenuIndexWrite,
+            nfc_protocol_support_common_submenu_callback,
+            instance);
     }
 }
 
@@ -146,6 +156,9 @@ static bool
     if(event == SubmenuIndexUnlock) {
         scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightUnlockMenu);
         return true;
+    } else if(event == SubmenuIndexWrite) {
+        scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightWrite);
+        return true;
     }
     return false;
 }
diff --git a/applications/main/nfc/scenes/nfc_scene_config.h b/applications/main/nfc/scenes/nfc_scene_config.h
index f415c66a6..a9887996d 100644
--- a/applications/main/nfc/scenes/nfc_scene_config.h
+++ b/applications/main/nfc/scenes/nfc_scene_config.h
@@ -24,6 +24,10 @@ ADD_SCENE(nfc, field, Field)
 ADD_SCENE(nfc, retry_confirm, RetryConfirm)
 ADD_SCENE(nfc, exit_confirm, ExitConfirm)
 
+ADD_SCENE(nfc, mf_ultralight_write, MfUltralightWrite)
+ADD_SCENE(nfc, mf_ultralight_write_success, MfUltralightWriteSuccess)
+ADD_SCENE(nfc, mf_ultralight_write_fail, MfUltralightWriteFail)
+ADD_SCENE(nfc, mf_ultralight_wrong_card, MfUltralightWrongCard)
 ADD_SCENE(nfc, mf_ultralight_unlock_menu, MfUltralightUnlockMenu)
 ADD_SCENE(nfc, mf_ultralight_unlock_warn, MfUltralightUnlockWarn)
 ADD_SCENE(nfc, mf_ultralight_key_input, MfUltralightKeyInput)
diff --git a/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write.c b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write.c
new file mode 100644
index 000000000..b3c1beef5
--- /dev/null
+++ b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write.c
@@ -0,0 +1,119 @@
+#include "../nfc_app_i.h"
+
+#include <nfc/protocols/mf_ultralight/mf_ultralight_poller.h>
+
+enum {
+    NfcSceneMfUltralightWriteStateCardSearch,
+    NfcSceneMfUltralightWriteStateCardFound,
+};
+
+NfcCommand nfc_scene_mf_ultralight_write_worker_callback(NfcGenericEvent event, void* context) {
+    furi_assert(context);
+    furi_assert(event.event_data);
+    furi_assert(event.protocol == NfcProtocolMfUltralight);
+
+    NfcCommand command = NfcCommandContinue;
+    NfcApp* instance = context;
+    MfUltralightPollerEvent* mfu_event = event.event_data;
+
+    if(mfu_event->type == MfUltralightPollerEventTypeRequestMode) {
+        mfu_event->data->poller_mode = MfUltralightPollerModeWrite;
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventCardDetected);
+    } else if(mfu_event->type == MfUltralightPollerEventTypeAuthRequest) {
+        mfu_event->data->auth_context.skip_auth = true;
+    } else if(mfu_event->type == MfUltralightPollerEventTypeRequestWriteData) {
+        mfu_event->data->write_data =
+            nfc_device_get_data(instance->nfc_device, NfcProtocolMfUltralight);
+    } else if(mfu_event->type == MfUltralightPollerEventTypeCardMismatch) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventWrongCard);
+        command = NfcCommandStop;
+    } else if(mfu_event->type == MfUltralightPollerEventTypeCardLocked) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventPollerFailure);
+        command = NfcCommandStop;
+    } else if(mfu_event->type == MfUltralightPollerEventTypeWriteFail) {
+        command = NfcCommandStop;
+    } else if(mfu_event->type == MfUltralightPollerEventTypeWriteSuccess) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventPollerSuccess);
+        command = NfcCommandStop;
+    }
+    return command;
+}
+
+static void nfc_scene_mf_ultralight_write_setup_view(NfcApp* instance) {
+    Popup* popup = instance->popup;
+    popup_reset(popup);
+    uint32_t state =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfUltralightWrite);
+
+    if(state == NfcSceneMfUltralightWriteStateCardSearch) {
+        popup_set_text(
+            instance->popup, "Apply the initial\ncard only", 128, 32, AlignRight, AlignCenter);
+        popup_set_icon(instance->popup, 0, 8, &I_NFC_manual_60x50);
+    } else {
+        popup_set_header(popup, "Writing\nDon't move...", 52, 32, AlignLeft, AlignCenter);
+        popup_set_icon(popup, 12, 23, &A_Loading_24);
+    }
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+}
+
+void nfc_scene_mf_ultralight_write_on_enter(void* context) {
+    NfcApp* instance = context;
+    dolphin_deed(DolphinDeedNfcEmulate);
+
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfUltralightWrite,
+        NfcSceneMfUltralightWriteStateCardSearch);
+    nfc_scene_mf_ultralight_write_setup_view(instance);
+
+    // Setup and start worker
+    FURI_LOG_D("WMFU", "Card searching...");
+    instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfUltralight);
+    nfc_poller_start(instance->poller, nfc_scene_mf_ultralight_write_worker_callback, instance);
+
+    nfc_blink_emulate_start(instance);
+}
+
+bool nfc_scene_mf_ultralight_write_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventCardDetected) {
+            scene_manager_set_scene_state(
+                instance->scene_manager,
+                NfcSceneMfUltralightWrite,
+                NfcSceneMfUltralightWriteStateCardFound);
+            nfc_scene_mf_ultralight_write_setup_view(instance);
+            consumed = true;
+        } else if(event.event == NfcCustomEventWrongCard) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightWrongCard);
+            consumed = true;
+        } else if(event.event == NfcCustomEventPollerSuccess) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightWriteSuccess);
+            consumed = true;
+        } else if(event.event == NfcCustomEventPollerFailure) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightWriteFail);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_write_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    nfc_poller_stop(instance->poller);
+    nfc_poller_free(instance->poller);
+
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfUltralightWrite,
+        NfcSceneMfUltralightWriteStateCardSearch);
+    // Clear view
+    popup_reset(instance->popup);
+
+    nfc_blink_stop(instance);
+}
diff --git a/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_fail.c b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_fail.c
new file mode 100644
index 000000000..dff5f2781
--- /dev/null
+++ b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_fail.c
@@ -0,0 +1,67 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_ultralight_write_fail_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcApp* instance = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_ultralight_write_fail_on_enter(void* context) {
+    NfcApp* instance = context;
+    Widget* widget = instance->widget;
+
+    notification_message(instance->notifications, &sequence_error);
+
+    widget_add_icon_element(widget, 72, 17, &I_DolphinCommon_56x48);
+    widget_add_string_element(
+        widget, 7, 4, AlignLeft, AlignTop, FontPrimary, "Writing gone wrong!");
+    widget_add_string_multiline_element(
+        widget,
+        7,
+        17,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        "Card protected by\npassword, AUTH0\nor lock bits");
+
+    widget_add_button_element(
+        widget,
+        GuiButtonTypeLeft,
+        "Finish",
+        nfc_scene_mf_ultralight_write_fail_widget_callback,
+        instance);
+
+    // Setup and start worker
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+}
+
+static bool nfc_scene_mf_ultralight_write_fail_move_to_back_scene(const NfcApp* const instance) {
+    bool was_saved = scene_manager_has_previous_scene(instance->scene_manager, NfcSceneSavedMenu);
+    uint32_t scene_id = was_saved ? NfcSceneSavedMenu : NfcSceneReadMenu;
+
+    return scene_manager_search_and_switch_to_previous_scene(instance->scene_manager, scene_id);
+}
+
+bool nfc_scene_mf_ultralight_write_fail_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = nfc_scene_mf_ultralight_write_fail_move_to_back_scene(instance);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = nfc_scene_mf_ultralight_write_fail_move_to_back_scene(instance);
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_write_fail_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    widget_reset(instance->widget);
+}
diff --git a/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_success.c b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_success.c
new file mode 100644
index 000000000..c1fbc35ee
--- /dev/null
+++ b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_write_success.c
@@ -0,0 +1,43 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_ultralight_write_success_popup_callback(void* context) {
+    NfcApp* instance = context;
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_mf_ultralight_write_success_on_enter(void* context) {
+    NfcApp* instance = context;
+    dolphin_deed(DolphinDeedNfcSave);
+
+    notification_message(instance->notifications, &sequence_success);
+
+    Popup* popup = instance->popup;
+    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
+    popup_set_header(popup, "Successfully\nwritten", 13, 22, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, instance);
+    popup_set_callback(popup, nfc_scene_mf_ultralight_write_success_popup_callback);
+    popup_enable_timeout(popup);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_mf_ultralight_write_success_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                instance->scene_manager, NfcSceneSavedMenu);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_write_success_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    // Clear view
+    popup_reset(instance->popup);
+}
diff --git a/applications/main/nfc/scenes/nfc_scene_mf_ultralight_wrong_card.c b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_wrong_card.c
new file mode 100644
index 000000000..a225c474d
--- /dev/null
+++ b/applications/main/nfc/scenes/nfc_scene_mf_ultralight_wrong_card.c
@@ -0,0 +1,58 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_ultralight_wrong_card_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcApp* instance = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_ultralight_wrong_card_on_enter(void* context) {
+    NfcApp* instance = context;
+    Widget* widget = instance->widget;
+
+    notification_message(instance->notifications, &sequence_error);
+
+    widget_add_icon_element(widget, 73, 17, &I_DolphinCommon_56x48);
+    widget_add_string_element(
+        widget, 3, 4, AlignLeft, AlignTop, FontPrimary, "This is wrong card");
+    widget_add_string_multiline_element(
+        widget,
+        4,
+        17,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        "Card of the same\ntype should be\n presented");
+    //"Data management\nis only possible\nwith card of same type");
+    widget_add_button_element(
+        widget,
+        GuiButtonTypeLeft,
+        "Retry",
+        nfc_scene_mf_ultralight_wrong_card_widget_callback,
+        instance);
+
+    // Setup and start worker
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_ultralight_wrong_card_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = scene_manager_previous_scene(instance->scene_manager);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_wrong_card_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    widget_reset(instance->widget);
+}
\ No newline at end of file
diff --git a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c
index 86ab68c8b..619cd8c5f 100644
--- a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c
+++ b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c
@@ -224,11 +224,24 @@ static NfcCommand mf_ultralight_poller_handler_idle(MfUltralightPoller* instance
     instance->tearing_flag_read = 0;
     instance->tearing_flag_total = 3;
     instance->pages_read = 0;
-    instance->state = MfUltralightPollerStateReadVersion;
-
+    instance->state = MfUltralightPollerStateRequestMode;
+    instance->current_page = 0;
     return NfcCommandContinue;
 }
 
+static NfcCommand mf_ultralight_poller_handler_request_mode(MfUltralightPoller* instance) {
+    NfcCommand command = NfcCommandContinue;
+
+    instance->mfu_event.type = MfUltralightPollerEventTypeRequestMode;
+    instance->mfu_event.data->poller_mode = MfUltralightPollerModeRead;
+
+    command = instance->callback(instance->general_event, instance->context);
+    instance->mode = instance->mfu_event.data->poller_mode;
+
+    instance->state = MfUltralightPollerStateReadVersion;
+    return command;
+}
+
 static NfcCommand mf_ultralight_poller_handler_read_version(MfUltralightPoller* instance) {
     instance->error = mf_ultralight_poller_read_version(instance, &instance->data->version);
     if(instance->error == MfUltralightErrorNone) {
@@ -259,6 +272,7 @@ static NfcCommand mf_ultralight_poller_handler_check_ultralight_c(MfUltralightPo
 }
 
 static NfcCommand mf_ultralight_poller_handler_check_ntag_203(MfUltralightPoller* instance) {
+    MfUltralightPollerState next_state = MfUltralightPollerStateGetFeatureSet;
     MfUltralightPageReadCommandData data = {};
     instance->error = mf_ultralight_poller_read_page(instance, 41, &data);
     if(instance->error == MfUltralightErrorNone) {
@@ -268,8 +282,13 @@ static NfcCommand mf_ultralight_poller_handler_check_ntag_203(MfUltralightPoller
         FURI_LOG_D(TAG, "Original Ultralight detected");
         iso14443_3a_poller_halt(instance->iso14443_3a_poller);
         instance->data->type = MfUltralightTypeUnknown;
+        if(instance->mode == MfUltralightPollerModeWrite) {
+            instance->mfu_event.type = MfUltralightPollerEventTypeCardMismatch;
+            instance->callback(instance->general_event, instance->context);
+            next_state = MfUltralightPollerStateWriteFail;
+        }
     }
-    instance->state = MfUltralightPollerStateGetFeatureSet;
+    instance->state = next_state;
 
     return NfcCommandContinue;
 }
@@ -508,6 +527,7 @@ static NfcCommand mf_ultralight_poller_handler_try_default_pass(MfUltralightPoll
 static NfcCommand mf_ultralight_poller_handler_read_fail(MfUltralightPoller* instance) {
     FURI_LOG_D(TAG, "Read Failed");
     iso14443_3a_poller_halt(instance->iso14443_3a_poller);
+    instance->mfu_event.type = MfUltralightPollerEventTypeReadFailed;
     instance->mfu_event.data->error = instance->error;
     NfcCommand command = instance->callback(instance->general_event, instance->context);
     instance->state = MfUltralightPollerStateIdle;
@@ -516,15 +536,121 @@ static NfcCommand mf_ultralight_poller_handler_read_fail(MfUltralightPoller* ins
 
 static NfcCommand mf_ultralight_poller_handler_read_success(MfUltralightPoller* instance) {
     FURI_LOG_D(TAG, "Read success");
-    iso14443_3a_poller_halt(instance->iso14443_3a_poller);
     instance->mfu_event.type = MfUltralightPollerEventTypeReadSuccess;
     NfcCommand command = instance->callback(instance->general_event, instance->context);
+
+    if(instance->mode == MfUltralightPollerModeRead) {
+        iso14443_3a_poller_halt(instance->iso14443_3a_poller);
+        instance->state = MfUltralightPollerStateIdle;
+    } else {
+        instance->state = MfUltralightPollerStateRequestWriteData;
+    }
+
+    return command;
+}
+
+static NfcCommand mf_ultralight_poller_handler_request_write_data(MfUltralightPoller* instance) {
+    FURI_LOG_D(TAG, "Check writing capability");
+    NfcCommand command = NfcCommandContinue;
+    MfUltralightPollerState next_state = MfUltralightPollerStateWritePages;
+    instance->current_page = 4;
+
+    instance->mfu_event.type = MfUltralightPollerEventTypeRequestWriteData;
+    instance->callback(instance->general_event, instance->context);
+
+    const MfUltralightData* write_data = instance->mfu_event.data->write_data;
+    const MfUltralightData* tag_data = instance->data;
+    uint32_t features = mf_ultralight_get_feature_support_set(tag_data->type);
+
+    bool check_passed = false;
+    do {
+        if(write_data->type != tag_data->type) {
+            FURI_LOG_D(TAG, "Incorrect tag type");
+            instance->mfu_event.type = MfUltralightPollerEventTypeCardMismatch;
+            break;
+        }
+
+        if(!instance->auth_context.auth_success) {
+            FURI_LOG_D(TAG, "Unknown password");
+            instance->mfu_event.type = MfUltralightPollerEventTypeCardLocked;
+            break;
+        }
+
+        const MfUltralightPage staticlock_page = tag_data->page[2];
+        if(staticlock_page.data[2] != 0 || staticlock_page.data[3] != 0) {
+            FURI_LOG_D(TAG, "Static lock bits are set");
+            instance->mfu_event.type = MfUltralightPollerEventTypeCardLocked;
+            break;
+        }
+
+        if(mf_ultralight_support_feature(features, MfUltralightFeatureSupportDynamicLock)) {
+            uint8_t dynlock_num = mf_ultralight_get_config_page_num(tag_data->type) - 1;
+            const MfUltralightPage dynlock_page = tag_data->page[dynlock_num];
+            if(dynlock_page.data[0] != 0 || dynlock_page.data[1] != 0) {
+                FURI_LOG_D(TAG, "Dynamic lock bits are set");
+                instance->mfu_event.type = MfUltralightPollerEventTypeCardLocked;
+                break;
+            }
+        }
+
+        check_passed = true;
+    } while(false);
+
+    if(!check_passed) {
+        iso14443_3a_poller_halt(instance->iso14443_3a_poller);
+        command = instance->callback(instance->general_event, instance->context);
+        next_state = MfUltralightPollerStateWriteFail;
+    }
+
+    instance->state = next_state;
+    return command;
+}
+
+static NfcCommand mf_ultralight_poller_handler_write_pages(MfUltralightPoller* instance) {
+    NfcCommand command = NfcCommandContinue;
+
+    do {
+        const MfUltralightData* write_data = instance->mfu_event.data->write_data;
+        uint8_t end_page = mf_ultralight_get_config_page_num(write_data->type) - 1;
+        if(instance->current_page == end_page) {
+            instance->state = MfUltralightPollerStateWriteSuccess;
+            break;
+        }
+        FURI_LOG_D(TAG, "Writing page %d", instance->current_page);
+        MfUltralightError error = mf_ultralight_poller_write_page(
+            instance, instance->current_page, &write_data->page[instance->current_page]);
+        if(error != MfUltralightErrorNone) {
+            instance->state = MfUltralightPollerStateWriteFail;
+            instance->error = error;
+            break;
+        }
+        instance->current_page++;
+    } while(false);
+
+    return command;
+}
+
+static NfcCommand mf_ultralight_poller_handler_write_fail(MfUltralightPoller* instance) {
+    FURI_LOG_D(TAG, "Write failed");
+    iso14443_3a_poller_halt(instance->iso14443_3a_poller);
+    instance->mfu_event.data->error = instance->error;
+    instance->mfu_event.type = MfUltralightPollerEventTypeWriteFail;
+    NfcCommand command = instance->callback(instance->general_event, instance->context);
+    return command;
+}
+
+static NfcCommand mf_ultralight_poller_handler_write_success(MfUltralightPoller* instance) {
+    FURI_LOG_D(TAG, "Write success");
+    iso14443_3a_poller_halt(instance->iso14443_3a_poller);
+    instance->mfu_event.type = MfUltralightPollerEventTypeWriteSuccess;
+    NfcCommand command = instance->callback(instance->general_event, instance->context);
     return command;
 }
 
 static const MfUltralightPollerReadHandler
     mf_ultralight_poller_read_handler[MfUltralightPollerStateNum] = {
         [MfUltralightPollerStateIdle] = mf_ultralight_poller_handler_idle,
+        [MfUltralightPollerStateRequestMode] = mf_ultralight_poller_handler_request_mode,
         [MfUltralightPollerStateReadVersion] = mf_ultralight_poller_handler_read_version,
         [MfUltralightPollerStateDetectMfulC] = mf_ultralight_poller_handler_check_ultralight_c,
         [MfUltralightPollerStateDetectNtag203] = mf_ultralight_poller_handler_check_ntag_203,
@@ -538,6 +664,11 @@ static const MfUltralightPollerReadHandler
         [MfUltralightPollerStateReadPages] = mf_ultralight_poller_handler_read_pages,
         [MfUltralightPollerStateReadFailed] = mf_ultralight_poller_handler_read_fail,
         [MfUltralightPollerStateReadSuccess] = mf_ultralight_poller_handler_read_success,
+        [MfUltralightPollerStateRequestWriteData] =
+            mf_ultralight_poller_handler_request_write_data,
+        [MfUltralightPollerStateWritePages] = mf_ultralight_poller_handler_write_pages,
+        [MfUltralightPollerStateWriteFail] = mf_ultralight_poller_handler_write_fail,
+        [MfUltralightPollerStateWriteSuccess] = mf_ultralight_poller_handler_write_success,
 
 };
 
diff --git a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.h b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.h
index 665d90cb7..2343be089 100644
--- a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.h
+++ b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.h
@@ -16,13 +16,27 @@ typedef struct MfUltralightPoller MfUltralightPoller;
  * @brief Enumeration of possible MfUltralight poller event types.
  */
 typedef enum {
+    MfUltralightPollerEventTypeRequestMode, /**< Poller requests for operating mode. */
     MfUltralightPollerEventTypeAuthRequest, /**< Poller requests to fill authentication context. */
     MfUltralightPollerEventTypeAuthSuccess, /**< Authentication succeeded. */
     MfUltralightPollerEventTypeAuthFailed, /**< Authentication failed. */
     MfUltralightPollerEventTypeReadSuccess, /**< Poller read card successfully. */
     MfUltralightPollerEventTypeReadFailed, /**< Poller failed to read card. */
+    MfUltralightPollerEventTypeRequestWriteData, /**< Poller request card data for write operation. */
+    MfUltralightPollerEventTypeCardMismatch, /**< Type of card for writing differs from presented one. */
+    MfUltralightPollerEventTypeCardLocked, /**< Presented card is locked by password, AUTH0 or lock bytes. */
+    MfUltralightPollerEventTypeWriteSuccess, /**< Poller wrote card successfully. */
+    MfUltralightPollerEventTypeWriteFail, /**< Poller failed to write card. */
 } MfUltralightPollerEventType;
 
+/**
+ * @brief Enumeration of possible MfUltralight poller operating modes.
+ */
+typedef enum {
+    MfUltralightPollerModeRead, /**< Poller will only read card. It's a default mode. */
+    MfUltralightPollerModeWrite, /**< Poller will write already saved card to another presented card. */
+} MfUltralightPollerMode;
+
 /**
  * @brief MfUltralight poller authentication context.
  */
@@ -39,6 +53,8 @@ typedef struct {
 typedef union {
     MfUltralightPollerAuthContext auth_context; /**< Authentication context. */
     MfUltralightError error; /**< Error code indicating reading fail reason. */
+    const MfUltralightData* write_data;
+    MfUltralightPollerMode poller_mode;
 } MfUltralightPollerEventData;
 
 /**
diff --git a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller_i.h b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller_i.h
index c89402b42..7c7354b1c 100644
--- a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller_i.h
+++ b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller_i.h
@@ -49,6 +49,7 @@ typedef union {
 
 typedef enum {
     MfUltralightPollerStateIdle,
+    MfUltralightPollerStateRequestMode,
     MfUltralightPollerStateReadVersion,
     MfUltralightPollerStateDetectMfulC,
     MfUltralightPollerStateDetectNtag203,
@@ -61,6 +62,10 @@ typedef enum {
     MfUltralightPollerStateTryDefaultPass,
     MfUltralightPollerStateReadFailed,
     MfUltralightPollerStateReadSuccess,
+    MfUltralightPollerStateRequestWriteData,
+    MfUltralightPollerStateWritePages,
+    MfUltralightPollerStateWriteFail,
+    MfUltralightPollerStateWriteSuccess,
 
     MfUltralightPollerStateNum,
 } MfUltralightPollerState;
@@ -68,6 +73,7 @@ typedef enum {
 struct MfUltralightPoller {
     Iso14443_3aPoller* iso14443_3a_poller;
     MfUltralightPollerState state;
+    MfUltralightPollerMode mode;
     BitBuffer* tx_buffer;
     BitBuffer* rx_buffer;
     MfUltralightData* data;
@@ -79,6 +85,7 @@ struct MfUltralightPoller {
     uint8_t counters_total;
     uint8_t tearing_flag_read;
     uint8_t tearing_flag_total;
+    uint16_t current_page;
     MfUltralightError error;
 
     NfcGenericEvent general_event;

From 93732865acac9053cb0c580a2bf3e58962b3a678 Mon Sep 17 00:00:00 2001
From: Astra <93453568+Astrrra@users.noreply.github.com>
Date: Sat, 2 Dec 2023 08:52:04 +0400
Subject: [PATCH 2/5] [FL-3132] HID app: Add new function key icons (#3236)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Add new function key icons
* Fix graphical glitches on the buttons

Co-authored-by: あく <alleteam@gmail.com>
---
 applications/system/hid_app/assets/Alt_11x7.png  | Bin 2417 -> 0 bytes
 applications/system/hid_app/assets/Alt_17x10.png | Bin 0 -> 550 bytes
 applications/system/hid_app/assets/Cmd_15x7.png  | Bin 2426 -> 0 bytes
 applications/system/hid_app/assets/Cmd_17x10.png | Bin 0 -> 556 bytes
 applications/system/hid_app/assets/Ctrl_15x7.png | Bin 2433 -> 0 bytes
 .../system/hid_app/assets/Ctrl_17x10.png         | Bin 0 -> 552 bytes
 applications/system/hid_app/assets/Del_12x7.png  | Bin 2417 -> 0 bytes
 applications/system/hid_app/assets/Del_17x10.png | Bin 0 -> 551 bytes
 applications/system/hid_app/assets/Esc_14x7.png  | Bin 2430 -> 0 bytes
 applications/system/hid_app/assets/Esc_17x10.png | Bin 0 -> 550 bytes
 applications/system/hid_app/assets/Tab_15x7.png  | Bin 2419 -> 0 bytes
 applications/system/hid_app/assets/Tab_17x10.png | Bin 0 -> 549 bytes
 applications/system/hid_app/views/hid_keyboard.c |  14 +++++++-------
 13 files changed, 7 insertions(+), 7 deletions(-)
 delete mode 100644 applications/system/hid_app/assets/Alt_11x7.png
 create mode 100644 applications/system/hid_app/assets/Alt_17x10.png
 delete mode 100644 applications/system/hid_app/assets/Cmd_15x7.png
 create mode 100644 applications/system/hid_app/assets/Cmd_17x10.png
 delete mode 100644 applications/system/hid_app/assets/Ctrl_15x7.png
 create mode 100644 applications/system/hid_app/assets/Ctrl_17x10.png
 delete mode 100644 applications/system/hid_app/assets/Del_12x7.png
 create mode 100644 applications/system/hid_app/assets/Del_17x10.png
 delete mode 100644 applications/system/hid_app/assets/Esc_14x7.png
 create mode 100644 applications/system/hid_app/assets/Esc_17x10.png
 delete mode 100644 applications/system/hid_app/assets/Tab_15x7.png
 create mode 100644 applications/system/hid_app/assets/Tab_17x10.png

diff --git a/applications/system/hid_app/assets/Alt_11x7.png b/applications/system/hid_app/assets/Alt_11x7.png
deleted file mode 100644
index 3e4bf320ee313c725e228356b6bf58989e804441..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2417
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
M`~vwGe0TrlKUw^nx&QzG

diff --git a/applications/system/hid_app/assets/Alt_17x10.png b/applications/system/hid_app/assets/Alt_17x10.png
new file mode 100644
index 0000000000000000000000000000000000000000..93041d25039a763a50c63398840767da293643fe
GIT binary patch
literal 550
zcmV+>0@?kEP)<h;3K|Lk000e1NJLTq000pH000UI0ssI2-5w(K0004jX+uL$b5ch_
zAW20-HZeIiHZ3wPF#rH4k#&*JD@0Kg$3HWO3{fZxY0|J^<VQ_xl#x)AG)DQgnR(`i
znm6-$?@gL)m93)0#;*l`0b6CQ6p@lGYhuInoad>L%(<O=KKFa?Io*3MxFcyrHOhNH
z&6s+4Ea;t`oA*{e;h~i#`ss`+hBiDk6{4iQ-{P|4wcoB)`rN<fS&AD9xT=JQ6iqjU
z$Av>Hre^b&aHEonE(xCqcj<CL;Tv0zIs9yM(&0~=^+<RG-1WlV<S&l>VkM=k!t!!_
zYC5O<+{b=NO*}I*EwN3!1%ohS1o1M#C?f>uWl-h-e){N^6(#a}zVj!^O0FWaMjoAI
zlB6){5;Z5);}R31$7Q6++x`FBS0mBi=Txr=LdBzHy|zQ;CKNU->*K((3Wrek0Oy%v
zes&)Q-bCLhYQ8<FTZ7Y!q88hRvvp{`*P?p#TPhQGClc^-47GF6a0S&1PS1Y!Il6<$
zs(jTY?Ce5^oUdE_0?~tL788&D+W-In32;bRa{vGf6951U69E94oEQKA082?kK~yM_
zrIAYtKp_kR9q)hVc?&^8@u6Z?{ibb-+Ah)40f1>|eBA@6YN^=FSz=Hm(eG{(<KR5I
om-LAw``s>jQj8)Dum3s32i>k78GhN>N&o-=07*qoM6N<$g1ch(GXMYp

literal 0
HcmV?d00001

diff --git a/applications/system/hid_app/assets/Cmd_15x7.png b/applications/system/hid_app/assets/Cmd_15x7.png
deleted file mode 100644
index a63a4be747a89745cbb32b5c9fb55d754f600dae..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2426
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

diff --git a/applications/system/hid_app/assets/Cmd_17x10.png b/applications/system/hid_app/assets/Cmd_17x10.png
new file mode 100644
index 0000000000000000000000000000000000000000..26ca3395c699cd19f2ae3c12d46954a45310eab7
GIT binary patch
literal 556
zcmV+{0@MA8P)<h;3K|Lk000e1NJLTq000pH000UI0ssI2-5w(K0004jX+uL$b5ch_
zAW20-HZeIiHZ3wPF#rH4k#&*JD@0Kg$3HWO3{fZxY0|J^<VQ_xl#x)AG)DQgnR(`i
znm6-$?@gL)m93)0#;*l`0b6CQ6p@lGYhuInoad>L%(<O=KKFa?Io*3MxFcyrHOhNH
z&6s+4Ea;t`oA*{e;h~i#`ss`+hBiDk6{4iQ-{P|4wcoB)`rN<fS&AD9xT=JQ6iqjU
z$Av>Hre^b&aHEonE(xCqcj<CL;Tv0zIs9yM(&0~=^+<RG-1WlV<S&l>VkM=k!t!!_
zYC5O<+{b=NO*}I*EwN3!1%ohS1o1M#C?f>uWl-h-e){N^6(#a}zVj!^O0FWaMjoAI
zlB6){5;Z5);}R31$7Q6++x`FBS0mBi=Txr=LdBzHy|zQ;CKNU->*K((3Wrek0Oy%v
zes&)Q-bCLhYQ8<FTZ7Y!q88hRvvp{`*P?p#TPhQGClc^-47GF6a0S&1PS1Y!Il6<$
zs(jTY?Ce5^oUdE_0?~tL788&D+W-In32;bRa{vGf6951U69E94oEQKA08vRqK~yM_
zosmHjz#s?%jnn^sc|BxAdaxC9fde7SAfOf1T_j2Ro%T$32LLCwm1CJRGV_WI^73S}
u!^3QlFHeE(@SZ0~+Pr6nx>n!+r=$Vtj3glk1^)H`0000<MNUMnLSTYF82KCk

literal 0
HcmV?d00001

diff --git a/applications/system/hid_app/assets/Ctrl_15x7.png b/applications/system/hid_app/assets/Ctrl_15x7.png
deleted file mode 100644
index b15c249b2e897430a8062c07937f058f7e73208c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2433
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

diff --git a/applications/system/hid_app/assets/Ctrl_17x10.png b/applications/system/hid_app/assets/Ctrl_17x10.png
new file mode 100644
index 0000000000000000000000000000000000000000..0eda72160009907c74a5f44e2dd90cd923f1fdfb
GIT binary patch
literal 552
zcmV+@0@wYCP)<h;3K|Lk000e1NJLTq000pH000UI0ssI2-5w(K0004jX+uL$b5ch_
zAW20-HZeIiHZ3wPF#rH4k#&*JD@0Kg$3HWO3{fZxY0|J^<VQ_xl#x)AG)DQgnR(`i
znm6-$?@gL)m93)0#;*l`0b6CQ6p@lGYhuInoad>L%(<O=KKFa?Io*3MxFcyrHOhNH
z&6s+4Ea;t`oA*{e;h~i#`ss`+hBiDk6{4iQ-{P|4wcoB)`rN<fS&AD9xT=JQ6iqjU
z$Av>Hre^b&aHEonE(xCqcj<CL;Tv0zIs9yM(&0~=^+<RG-1WlV<S&l>VkM=k!t!!_
zYC5O<+{b=NO*}I*EwN3!1%ohS1o1M#C?f>uWl-h-e){N^6(#a}zVj!^O0FWaMjoAI
zlB6){5;Z5);}R31$7Q6++x`FBS0mBi=Txr=LdBzHy|zQ;CKNU->*K((3Wrek0Oy%v
zes&)Q-bCLhYQ8<FTZ7Y!q88hRvvp{`*P?p#TPhQGClc^-47GF6a0S&1PS1Y!Il6<$
zs(jTY?Ce5^oUdE_0?~tL788&D+W-In32;bRa{vGf6951U69E94oEQKA08L3mK~yM_
zosmfj03Z;<tpERWJQRw!AY(6TF_=LCt(fjblBBfrelNQZ0C2o|eaEq<$?%K9%FJYV
qD?FH*TVWngZ;j~fd`kWQPbmYJ#3vlh5)ps^0000<MNUMnLSTZLGWPcX

literal 0
HcmV?d00001

diff --git a/applications/system/hid_app/assets/Del_12x7.png b/applications/system/hid_app/assets/Del_12x7.png
deleted file mode 100644
index fd6b3947f7d40cc0abfea296147923d198cd129a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2417
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
UIr2qlrGD-ReFFp+eD;3yA0-x>VgLXD

diff --git a/applications/system/hid_app/assets/Del_17x10.png b/applications/system/hid_app/assets/Del_17x10.png
new file mode 100644
index 0000000000000000000000000000000000000000..13d736983079f920184d157d83054efe809a6981
GIT binary patch
literal 551
zcmV+?0@(eDP)<h;3K|Lk000e1NJLTq000pH000UI0ssI2-5w(K0004jX+uL$b5ch_
zAW20-HZeIiHZ3wPF#rH4k#&*JD@0Kg$3HWO3{fZxY0|J^<VQ_xl#x)AG)DQgnR(`i
znm6-$?@gL)m93)0#;*l`0b6CQ6p@lGYhuInoad>L%(<O=KKFa?Io*3MxFcyrHOhNH
z&6s+4Ea;t`oA*{e;h~i#`ss`+hBiDk6{4iQ-{P|4wcoB)`rN<fS&AD9xT=JQ6iqjU
z$Av>Hre^b&aHEonE(xCqcj<CL;Tv0zIs9yM(&0~=^+<RG-1WlV<S&l>VkM=k!t!!_
zYC5O<+{b=NO*}I*EwN3!1%ohS1o1M#C?f>uWl-h-e){N^6(#a}zVj!^O0FWaMjoAI
zlB6){5;Z5);}R31$7Q6++x`FBS0mBi=Txr=LdBzHy|zQ;CKNU->*K((3Wrek0Oy%v
zes&)Q-bCLhYQ8<FTZ7Y!q88hRvvp{`*P?p#TPhQGClc^-47GF6a0S&1PS1Y!Il6<$
zs(jTY?Ce5^oUdE_0?~tL788&D+W-In32;bRa{vGf6951U69E94oEQKA08B|lK~yM_
zm5@OS05J#yo3j7^^7J4pv^7F=QPhc|fbpmqLBGnOqdqeO0EgAg?d|xQk<_gHnmw*%
pndYC0Ub^P!QHg6e=1KN%jTYL>Askdnas~hZ002ovPDHLkV1h}~`Pcve

literal 0
HcmV?d00001

diff --git a/applications/system/hid_app/assets/Esc_14x7.png b/applications/system/hid_app/assets/Esc_14x7.png
deleted file mode 100644
index 3be4691d8a3d050bf14f5bd29099705d984eead7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2430
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
bCa#;5Jap7X#>0<mhLE4PKkuT~o<IEpr8}ks

diff --git a/applications/system/hid_app/assets/Esc_17x10.png b/applications/system/hid_app/assets/Esc_17x10.png
new file mode 100644
index 0000000000000000000000000000000000000000..6a011e97a8aa56bdb3444156ecc91943872a3dd1
GIT binary patch
literal 550
zcmV+>0@?kEP)<h;3K|Lk000e1NJLTq000pH000UI0ssI2-5w(K0004jX+uL$b5ch_
zAW20-HZeIiHZ3wPF#rH4k#&*JD@0Kg$3HWO3{fZxY0|J^<VQ_xl#x)AG)DQgnR(`i
znm6-$?@gL)m93)0#;*l`0b6CQ6p@lGYhuInoad>L%(<O=KKFa?Io*3MxFcyrHOhNH
z&6s+4Ea;t`oA*{e;h~i#`ss`+hBiDk6{4iQ-{P|4wcoB)`rN<fS&AD9xT=JQ6iqjU
z$Av>Hre^b&aHEonE(xCqcj<CL;Tv0zIs9yM(&0~=^+<RG-1WlV<S&l>VkM=k!t!!_
zYC5O<+{b=NO*}I*EwN3!1%ohS1o1M#C?f>uWl-h-e){N^6(#a}zVj!^O0FWaMjoAI
zlB6){5;Z5);}R31$7Q6++x`FBS0mBi=Txr=LdBzHy|zQ;CKNU->*K((3Wrek0Oy%v
zes&)Q-bCLhYQ8<FTZ7Y!q88hRvvp{`*P?p#TPhQGClc^-47GF6a0S&1PS1Y!Il6<$
zs(jTY?Ce5^oUdE_0?~tL788&D+W-In32;bRa{vGf6951U69E94oEQKA082?kK~yM_
zl}<ql05Ax$(f_~f4naf-Yo4-9HIn#*12D7X8w=k{`%lA6j!n#7MR{(qZ6mso%pBQS
ocT4Ha6i$-{DpfWwoZklk7uH!m_Dt%!2LJ#707*qoM6N<$f-ThZQvd(}

literal 0
HcmV?d00001

diff --git a/applications/system/hid_app/assets/Tab_15x7.png b/applications/system/hid_app/assets/Tab_15x7.png
deleted file mode 100644
index 06ccccee79d0f0833e2b1cc31f899a88c2ea1ff5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2419
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
OBM1oQpYz}Im;V5=ewrcx

diff --git a/applications/system/hid_app/assets/Tab_17x10.png b/applications/system/hid_app/assets/Tab_17x10.png
new file mode 100644
index 0000000000000000000000000000000000000000..c62d75c0db531f4ed1d9d7759500ba50dd47ed19
GIT binary patch
literal 549
zcmV+=0^0qFP)<h;3K|Lk000e1NJLTq000pH000UI0ssI2-5w(K0004jX+uL$b5ch_
zAW20-HZeIiHZ3wPF#rH4k#&*JD@0Kg$3HWO3{fZxY0|J^<VQ_xl#x)AG)DQgnR(`i
znm6-$?@gL)m93)0#;*l`0b6CQ6p@lGYhuInoad>L%(<O=KKFa?Io*3MxFcyrHOhNH
z&6s+4Ea;t`oA*{e;h~i#`ss`+hBiDk6{4iQ-{P|4wcoB)`rN<fS&AD9xT=JQ6iqjU
z$Av>Hre^b&aHEonE(xCqcj<CL;Tv0zIs9yM(&0~=^+<RG-1WlV<S&l>VkM=k!t!!_
zYC5O<+{b=NO*}I*EwN3!1%ohS1o1M#C?f>uWl-h-e){N^6(#a}zVj!^O0FWaMjoAI
zlB6){5;Z5);}R31$7Q6++x`FBS0mBi=Txr=LdBzHy|zQ;CKNU->*K((3Wrek0Oy%v
zes&)Q-bCLhYQ8<FTZ7Y!q88hRvvp{`*P?p#TPhQGClc^-47GF6a0S&1PS1Y!Il6<$
zs(jTY?Ce5^oUdE_0?~tL788&D+W-In32;bRa{vGf6951U69E94oEQKA07^+jK~yM_
zrBFu>05AxW#{Ykr9-0u-+Re!Ys32*Va5DoCOQQ;aSac0_jg3zVnM+Y|nGr}v+m<$F
n&ROGyli#B?gm};CuYPx{fw(FRB*KjF00000NkvXXu0mjf2deXy

literal 0
HcmV?d00001

diff --git a/applications/system/hid_app/views/hid_keyboard.c b/applications/system/hid_app/views/hid_keyboard.c
index 17ff754f5..9060c1d6a 100644
--- a/applications/system/hid_app/views/hid_keyboard.c
+++ b/applications/system/hid_app/views/hid_keyboard.c
@@ -49,7 +49,7 @@ typedef struct {
 #define ROW_COUNT 7
 #define COLUMN_COUNT 12
 
-// 0 width items are not drawn, but there value is used
+// 0 width items are not drawn, but their value is used
 const HidKeyboardKey hid_keyboard_keyset[ROW_COUNT][COLUMN_COUNT] = {
     {
         {.width = 1, .icon = &I_ButtonF1_5x8, .value = HID_KEYBOARD_F1},
@@ -140,17 +140,17 @@ const HidKeyboardKey hid_keyboard_keyset[ROW_COUNT][COLUMN_COUNT] = {
         {.width = 1, .icon = &I_ButtonRight_4x7, .value = HID_KEYBOARD_RIGHT_ARROW},
     },
     {
-        {.width = 2, .icon = &I_Ctrl_15x7, .value = HID_KEYBOARD_L_CTRL},
+        {.width = 2, .icon = &I_Ctrl_17x10, .value = HID_KEYBOARD_L_CTRL},
         {.width = 0, .value = HID_KEYBOARD_L_CTRL},
-        {.width = 2, .icon = &I_Alt_11x7, .value = HID_KEYBOARD_L_ALT},
+        {.width = 2, .icon = &I_Alt_17x10, .value = HID_KEYBOARD_L_ALT},
         {.width = 0, .value = HID_KEYBOARD_L_ALT},
-        {.width = 2, .icon = &I_Cmd_15x7, .value = HID_KEYBOARD_L_GUI},
+        {.width = 2, .icon = &I_Cmd_17x10, .value = HID_KEYBOARD_L_GUI},
         {.width = 0, .value = HID_KEYBOARD_L_GUI},
-        {.width = 2, .icon = &I_Tab_15x7, .value = HID_KEYBOARD_TAB},
+        {.width = 2, .icon = &I_Tab_17x10, .value = HID_KEYBOARD_TAB},
         {.width = 0, .value = HID_KEYBOARD_TAB},
-        {.width = 2, .icon = &I_Esc_14x7, .value = HID_KEYBOARD_ESCAPE},
+        {.width = 2, .icon = &I_Esc_17x10, .value = HID_KEYBOARD_ESCAPE},
         {.width = 0, .value = HID_KEYBOARD_ESCAPE},
-        {.width = 2, .icon = &I_Del_12x7, .value = HID_KEYBOARD_DELETE_FORWARD},
+        {.width = 2, .icon = &I_Del_17x10, .value = HID_KEYBOARD_DELETE_FORWARD},
         {.width = 0, .value = HID_KEYBOARD_DELETE_FORWARD},
     },
 };

From 04cead1fc56d4093bffee8d3a4a7b47fba93061f Mon Sep 17 00:00:00 2001
From: Astra <93453568+Astrrra@users.noreply.github.com>
Date: Sat, 2 Dec 2023 09:03:10 +0400
Subject: [PATCH 3/5] [FL-3620] Add the "remove pairing" button to BLE hid
 (#3237)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: あく <alleteam@gmail.com>
---
 applications/system/hid_app/hid.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/applications/system/hid_app/hid.c b/applications/system/hid_app/hid.c
index a42fc6091..88a68f09d 100644
--- a/applications/system/hid_app/hid.c
+++ b/applications/system/hid_app/hid.c
@@ -14,8 +14,22 @@ enum HidDebugSubmenuIndex {
     HidSubmenuIndexMouse,
     HidSubmenuIndexMouseClicker,
     HidSubmenuIndexMouseJiggler,
+    HidSubmenuIndexRemovePairing,
 };
 
+static void bt_hid_remove_pairing(Bt* bt) {
+    bt_disconnect(bt);
+
+    // Wait 2nd core to update nvm storage
+    furi_delay_ms(200);
+
+    furi_hal_bt_stop_advertising();
+
+    bt_forget_bonded_devices(bt);
+
+    furi_hal_bt_start_advertising();
+}
+
 static void hid_submenu_callback(void* context, uint32_t index) {
     furi_assert(context);
     Hid* app = context;
@@ -45,6 +59,8 @@ static void hid_submenu_callback(void* context, uint32_t index) {
     } else if(index == HidSubmenuIndexMouseJiggler) {
         app->view_id = HidViewMouseJiggler;
         view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMouseJiggler);
+    } else if(index == HidSubmenuIndexRemovePairing) {
+        bt_hid_remove_pairing(app->bt);
     }
 }
 
@@ -143,6 +159,14 @@ Hid* hid_alloc(HidTransport transport) {
         HidSubmenuIndexMouseJiggler,
         hid_submenu_callback,
         app);
+    if(transport == HidTransportBle) {
+        submenu_add_item(
+            app->device_type_submenu,
+            "Remove Pairing",
+            HidSubmenuIndexRemovePairing,
+            hid_submenu_callback,
+            app);
+    }
     view_set_previous_callback(submenu_get_view(app->device_type_submenu), hid_exit);
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewSubmenu, submenu_get_view(app->device_type_submenu));

From c6a14e1a6779ded87b848b06b2cbc51a147f96b3 Mon Sep 17 00:00:00 2001
From: pborsutzki <pborsutzki@users.noreply.github.com>
Date: Sat, 2 Dec 2023 08:27:58 +0100
Subject: [PATCH 4/5] Fixed a zero allocation error when reading an iso15693
 nfc tag with no additional blocks. (#3229)

Co-authored-by: gornekich <n.gorbadey@gmail.com>
---
 .../iso15693_3/iso15693_3_poller_i.c          | 44 ++++++++++---------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/lib/nfc/protocols/iso15693_3/iso15693_3_poller_i.c b/lib/nfc/protocols/iso15693_3/iso15693_3_poller_i.c
index 917f7dbb8..ca6f5435e 100644
--- a/lib/nfc/protocols/iso15693_3/iso15693_3_poller_i.c
+++ b/lib/nfc/protocols/iso15693_3/iso15693_3_poller_i.c
@@ -108,28 +108,30 @@ Iso15693_3Error iso15693_3_poller_activate(Iso15693_3Poller* instance, Iso15693_
             break;
         }
 
-        // Read blocks: Optional command
-        simple_array_init(data->block_data, system_info->block_count * system_info->block_size);
-        ret = iso15693_3_poller_read_blocks(
-            instance,
-            simple_array_get_data(data->block_data),
-            system_info->block_count,
-            system_info->block_size);
-        if(ret != Iso15693_3ErrorNone) {
-            ret = iso15693_3_poller_filter_error(ret);
-            break;
+        if(system_info->block_count > 0) {
+            // Read blocks: Optional command
+            simple_array_init(
+                data->block_data, system_info->block_count * system_info->block_size);
+            ret = iso15693_3_poller_read_blocks(
+                instance,
+                simple_array_get_data(data->block_data),
+                system_info->block_count,
+                system_info->block_size);
+            if(ret != Iso15693_3ErrorNone) {
+                ret = iso15693_3_poller_filter_error(ret);
+                break;
+            }
+
+            // Get block security status: Optional command
+            simple_array_init(data->block_security, system_info->block_count);
+
+            ret = iso15693_3_poller_get_blocks_security(
+                instance, simple_array_get_data(data->block_security), system_info->block_count);
+            if(ret != Iso15693_3ErrorNone) {
+                ret = iso15693_3_poller_filter_error(ret);
+                break;
+            }
         }
-
-        // Get block security status: Optional command
-        simple_array_init(data->block_security, system_info->block_count);
-
-        ret = iso15693_3_poller_get_blocks_security(
-            instance, simple_array_get_data(data->block_security), system_info->block_count);
-        if(ret != Iso15693_3ErrorNone) {
-            ret = iso15693_3_poller_filter_error(ret);
-            break;
-        }
-
     } while(false);
 
     return ret;

From eb6fe0a4dbe2e6d3776483e6a191de2307b0060e Mon Sep 17 00:00:00 2001
From: Skorpionm <85568270+Skorpionm@users.noreply.github.com>
Date: Sat, 2 Dec 2023 11:34:02 +0400
Subject: [PATCH 5/5] SubGhz: fix count bit for detect gate_tx protocol (#3253)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: あく <alleteam@gmail.com>
---
 lib/subghz/protocols/gate_tx.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/subghz/protocols/gate_tx.c b/lib/subghz/protocols/gate_tx.c
index 51a424fed..2ebd6bb03 100644
--- a/lib/subghz/protocols/gate_tx.c
+++ b/lib/subghz/protocols/gate_tx.c
@@ -227,7 +227,7 @@ void subghz_protocol_decoder_gate_tx_feed(void* context, bool level, uint32_t du
             if(duration >= ((uint32_t)subghz_protocol_gate_tx_const.te_short * 10 +
                             subghz_protocol_gate_tx_const.te_delta)) {
                 instance->decoder.parser_step = GateTXDecoderStepFoundStartBit;
-                if(instance->decoder.decode_count_bit >=
+                if(instance->decoder.decode_count_bit ==
                    subghz_protocol_gate_tx_const.min_count_bit_for_found) {
                     instance->generic.data = instance->decoder.decode_data;
                     instance->generic.data_count_bit = instance->decoder.decode_count_bit;