update changelog

SubBrute deep refactor

.drone.yml

@@ -28,35 +28,6 @@ steps:
       FBT_TOOLS_CUSTOM_LINK:
         from_secret: fbt_link
 
-  - name: "Bundle resources"
-    image: kramos/alpine-zip
-    commands:
-      - mkdir sd-card
-      - mkdir -p sd-card/subghz/assets
-      - mkdir -p sd-card/nfc/assets
-      - mkdir -p sd-card/infrared/assets
-      - mkdir -p sd-card/unirf
-      - mkdir -p sd-card/rfidfuzzer
-      - mkdir -p sd-card/subplaylist
-      - mkdir -p sd-card/badusb/layouts
-      - cp assets/resources/badusb/layouts/* sd-card/badusb/layouts/
-      - cp assets/resources/subghz/assets/dangerous_settings sd-card/subghz/assets/dangerous_settings
-      - cp assets/resources/subghz/assets/setting_user sd-card/subghz/assets/setting_user
-      - cp assets/resources/subghz/assets/keeloq_mfcodes sd-card/subghz/assets/keeloq_mfcodes
-      - cp assets/resources/nfc/assets/mf_classic_dict.nfc sd-card/nfc/assets/mf_classic_dict.nfc
-      - cp assets/resources/infrared/assets/tv.ir sd-card/infrared/assets/tv.ir
-      - cp assets/resources/infrared/assets/ac.ir sd-card/infrared/assets/ac.ir
-      - cp assets/resources/infrared/assets/fans.ir sd-card/infrared/assets/fans.ir
-      - cp assets/resources/infrared/assets/projectors.ir sd-card/infrared/assets/projectors.ir
-      - cp assets/resources/infrared/assets/audio.ir sd-card/infrared/assets/audio.ir
-      - cp assets/resources/unirf/unirf_map_example.txt sd-card/unirf/unirf_map_example.txt
-      - cp assets/resources/rfidfuzzer/example_uids.txt sd-card/rfidfuzzer/example_uids.txt
-      - cp assets/resources/subplaylist/example_playlist.txt sd-card/subplaylist/example_playlist.txt
-      - cp assets/resources/Manifest sd-card/Manifest
-      - zip -r artifacts-default/sd-card-${DRONE_TAG}.zip sd-card
-      - rm -rf sd-card
-      - ls -laS artifacts-default
-
   - name: "Bundle self-update packages"
     image: kramos/alpine-zip
     commands:
@@ -93,7 +64,6 @@ steps:
       files:
         - artifacts-default/*.tgz
         - artifacts-default/*.zip
-        - artifacts-default/flipper-z-f7-full-${DRONE_TAG}.dfu
       title: ${DRONE_TAG}
       note: CHANGELOG.md
       checksum:

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @xMasterX

.vscode/example/launch.json

@@ -9,6 +9,10 @@
             "type": "command",
             "command": "shellCommand.execute",
             "args": {
+                "useSingleResult": true,
+                "env": {
+                    "PATH": "${workspaceFolder};${env:PATH}"
+                },
                 "command": "./fbt get_blackmagic",
                 "description": "Get Blackmagic device",
             }

.vscode/example/settings.json

@@ -22,4 +22,4 @@
         "SConstruct": "python",
         "*.fam": "python",
     }
-}
+}

CHANGELOG.md

@@ -1,22 +1,16 @@
 ### New changes
-* Critical issue fix: Fixed subghz read mode doesn’t work at all
-* Updated archive app (Rename, File info) (+ fixes) (by @derskythe) [(PR 68)](https://github.com/Eng1n33r/flipperzero-firmware/pull/68)
-* Plugins: Added uart echo and usb mouse apps
-* Plugins: Fix nrfsniff log spam, add new icons for plugins (icons by @Svaarich)
-* Plugins: Changed app types and added new category for music players
-* Plugins: Added new start screen for doom (by @Svaarich)
-* Reduced max SubGHz history items to resolve memory issues, was 99, now 65
-* Updated universal remote assets (by @Amec0e)
-* OFW: Fbt: fixed gdb-py path for MacOS
+* PR: SubGHz bruteforcer plugin - deep refactoring (huge thanks to @derskythe ! | PR #75)
+* OFW: Preliminary Rust support
 
-**Known issues: Picopass reader plugin crash**
+#### **DFU files no longer included in releases to avoid issues with wrong manual installation of assets - use .tgz file with qFlipper, or install automatically via web updater or use microSD update package**
 
-**Note: To avoid issues prefer installing using web updater or by self update package, all needed assets will be installed**
+[- How to install](https://github.com/Eng1n33r/flipperzero-firmware/blob/dev/documentation/HowToInstall.md)
 
-Self-update package (update from microSD) - `flipper-z-f7-update-(version).zip` or `.tgz` for iOS mobile app
+[- Download qFlipper 1.2.0 (allows .tgz installation) (official link)](https://update.flipperzero.one/builds/qFlipper/1.2.0/)
 
-DFU for update using qFlipper - `flipper-z-f7-full-(version).dfu`
+**Note: To avoid issues with .dfu, prefer installing using .tgz with qFlipper, web updater or by self update package, all needed assets will be installed**
 
-If using DFU update method, download this archive and unpack it to your microSD, replacing all files except files you have edited manually -
-`sd-card-(version).zip`
+Self-update package (update from microSD) - `flipper-z-f7-update-(version).zip` or download `.tgz` for iOS mobile app / qFlipper
+
+Update using qFlipper (1.2.0) is now possible with `.tgz` update package! Also you can use Web Updater or self-update package.
 

ReadMe.md

@@ -49,7 +49,7 @@ See changelog in releases for latest updates!
 - Keeloq [Not ALL systems supported yet!]
 - Nice Flor S
 - Security+ v1 & v2
-- Star Line
+- Star Line (saving only)
 
 ## Support us so we can buy equipment and develop new features
 * ETH/BSC/ERC20-Tokens: `0xFebF1bBc8229418FF2408C07AF6Afa49152fEc6a`
@@ -87,7 +87,6 @@ Games:
 - BadUSB -> Keyboard layouts [(by rien > dummy-decoy)](https://github.com/dummy-decoy/flipperzero-firmware/tree/dummy_decoy/bad_usb_keyboard_layout)
 - SubGHz -> New frequency analyzer - [(by ClusterM)](https://github.com/ClusterM)
 - SubGHz -> Detect RAW feature - [(by perspecdev)](https://github.com/RogueMaster/flipperzero-firmware-wPlugins/pull/152)
-- SubGHz -> Save last used config settings - [(by derskythe)](https://github.com/Eng1n33r/flipperzero-firmware/pull/67)
 
 # Instructions
 ## [- How to install firmware](https://github.com/Eng1n33r/flipperzero-firmware/blob/dev/documentation/HowToInstall.md)
@@ -100,6 +99,8 @@ Games:
 
 ### **Plugins**
 
+## [- 💎 Extra plugins precompiled for Unleashed](https://github.com/UberGuidoZ/Flipper/tree/main/Applications/Unleashed)
+
 ## [- Configure Sub-GHz Remote App](https://github.com/Eng1n33r/flipperzero-firmware/blob/dev/documentation/SubGHzRemotePlugin.md)
 
 ## [- Barcode Generator](https://github.com/Eng1n33r/flipperzero-firmware/blob/dev/documentation/BarcodeGenerator.md)
@@ -165,4 +166,4 @@ Games:
 - `site_scons`      - Build helpers
 - `scripts`         - Supplementary scripts and python libraries home
 
-Also pay attention to `ReadMe.md` files inside of those directories.
+Also pay attention to `ReadMe.md` files inside those directories.

SConstruct

@@ -44,6 +44,8 @@ distenv = coreenv.Clone(
         "target extended-remote ${GDBREMOTE}",
         "-ex",
         "set confirm off",
+        "-ex",
+        "set pagination off",
     ],
     GDBOPTS_BLACKMAGIC=[
         "-ex",
@@ -234,10 +236,19 @@ distenv.PhonyTarget(
 distenv.PhonyTarget(
     "debug_other",
     "${GDBPYCOM}",
-    GDBPYOPTS='-ex "source debug/PyCortexMDebug/PyCortexMDebug.py" ',
+    GDBOPTS="${GDBOPTS_BASE}",
     GDBREMOTE="${OPENOCD_GDB_PIPE}",
+    GDBPYOPTS='-ex "source debug/PyCortexMDebug/PyCortexMDebug.py" ',
 )
 
+distenv.PhonyTarget(
+    "debug_other_blackmagic",
+    "${GDBPYCOM}",
+    GDBOPTS="${GDBOPTS_BASE}  ${GDBOPTS_BLACKMAGIC}",
+    GDBREMOTE="$${BLACKMAGIC_ADDR}",
+)
+
+
 # Just start OpenOCD
 distenv.PhonyTarget(
     "openocd",

applications/debug/unit_tests/nfc/nfc_test.c

@@ -3,6 +3,7 @@
 #include <storage/storage.h>
 #include <lib/flipper_format/flipper_format.h>
 #include <lib/nfc/protocols/nfca.h>
+#include <lib/nfc/helpers/mf_classic_dict.h>
 #include <lib/digital_signal/digital_signal.h>
 
 #include <lib/flipper_format/flipper_format_i.h>
@@ -170,10 +171,59 @@ MU_TEST(nfc_digital_signal_test) {
         "NFC long digital signal test failed\r\n");
 }
 
+MU_TEST(mf_classic_dict_test) {
+    MfClassicDict* instance = NULL;
+    uint64_t key = 0;
+    string_t temp_str;
+    string_init(temp_str);
+
+    instance = mf_classic_dict_alloc(MfClassicDictTypeUnitTest);
+    mu_assert(instance != NULL, "mf_classic_dict_alloc\r\n");
+
+    mu_assert(
+        mf_classic_dict_get_total_keys(instance) == 0,
+        "mf_classic_dict_get_total_keys == 0 assert failed\r\n");
+
+    string_set(temp_str, "2196FAD8115B");
+    mu_assert(
+        mf_classic_dict_add_key_str(instance, temp_str),
+        "mf_classic_dict_add_key == true assert failed\r\n");
+
+    mu_assert(
+        mf_classic_dict_get_total_keys(instance) == 1,
+        "mf_classic_dict_get_total_keys == 1 assert failed\r\n");
+
+    mu_assert(mf_classic_dict_rewind(instance), "mf_classic_dict_rewind == 1 assert failed\r\n");
+
+    mu_assert(
+        mf_classic_dict_get_key_at_index_str(instance, temp_str, 0),
+        "mf_classic_dict_get_key_at_index_str == true assert failed\r\n");
+    mu_assert(
+        string_cmp(temp_str, "2196FAD8115B") == 0,
+        "string_cmp(temp_str, \"2196FAD8115B\") == 0 assert failed\r\n");
+
+    mu_assert(mf_classic_dict_rewind(instance), "mf_classic_dict_rewind == 1 assert failed\r\n");
+
+    mu_assert(
+        mf_classic_dict_get_key_at_index(instance, &key, 0),
+        "mf_classic_dict_get_key_at_index == true assert failed\r\n");
+    mu_assert(key == 0x2196FAD8115B, "key == 0x2196FAD8115B assert failed\r\n");
+
+    mu_assert(mf_classic_dict_rewind(instance), "mf_classic_dict_rewind == 1 assert failed\r\n");
+
+    mu_assert(
+        mf_classic_dict_delete_index(instance, 0),
+        "mf_classic_dict_delete_index == true assert failed\r\n");
+
+    mf_classic_dict_free(instance);
+    string_clear(temp_str);
+}
+
 MU_TEST_SUITE(nfc) {
     nfc_test_alloc();
 
     MU_RUN_TEST(nfc_digital_signal_test);
+    MU_RUN_TEST(mf_classic_dict_test);
 
     nfc_test_free();
 }

applications/debug/unit_tests/subghz/subghz_test.c

@@ -13,7 +13,7 @@
 #define CAME_ATOMO_DIR_NAME EXT_PATH("subghz/assets/came_atomo")
 #define NICE_FLOR_S_DIR_NAME EXT_PATH("subghz/assets/nice_flor_s")
 #define TEST_RANDOM_DIR_NAME EXT_PATH("unit_tests/subghz/test_random_raw.sub")
-#define TEST_RANDOM_COUNT_PARSE 232
+#define TEST_RANDOM_COUNT_PARSE 233
 #define TEST_TIMEOUT 10000
 
 static SubGhzEnvironment* environment_handler;
@@ -434,6 +434,13 @@ MU_TEST(subghz_decoder_clemsa_test) {
         "Test decoder " SUBGHZ_PROTOCOL_CLEMSA_NAME " error\r\n");
 }
 
+MU_TEST(subghz_decoder_oregon2_test) {
+    mu_assert(
+        subghz_decoder_test(
+            EXT_PATH("unit_tests/subghz/oregon2_raw.sub"), SUBGHZ_PROTOCOL_OREGON2_NAME),
+        "Test decoder " SUBGHZ_PROTOCOL_OREGON2_NAME " error\r\n");
+}
+
 //test encoders
 MU_TEST(subghz_encoder_princeton_test) {
     mu_assert(
@@ -595,6 +602,7 @@ MU_TEST_SUITE(subghz) {
     MU_RUN_TEST(subghz_decoder_magellen_test);
     MU_RUN_TEST(subghz_decoder_intertechno_v3_test);
     MU_RUN_TEST(subghz_decoder_clemsa_test);
+    MU_RUN_TEST(subghz_decoder_oregon2_test);
 
     MU_RUN_TEST(subghz_encoder_princeton_test);
     MU_RUN_TEST(subghz_encoder_came_test);

applications/main/application.fam

@@ -15,6 +15,23 @@ App(
         "archive",
         "clock",
         "unirfremix",
-        "spectrum_analyzer",
+    ],
+)
+
+App(
+    appid="main_apps_default",
+    name="Basic applications for main menu",
+    apptype=FlipperAppType.METAPACKAGE,
+    provides=[
+        "gpio",
+        #"ibutton",
+        "infrared",
+        "lfrfid",
+        "nfc",
+        "subghz",
+        #"bad_usb",
+        #"u2f",
+        "fap_loader",
+        "archive",
     ],
 )

applications/main/archive/helpers/archive_browser.c

@@ -270,7 +270,7 @@ void archive_file_array_load(ArchiveBrowserView* browser, int8_t dir) {
 ArchiveFile_t* archive_get_current_file(ArchiveBrowserView* browser) {
     furi_assert(browser);
 
-    ArchiveFile_t* selected;
+    ArchiveFile_t* selected = NULL;
     with_view_model(
         browser->view, (ArchiveBrowserViewModel * model) {
             selected = files_array_size(model->files) ?
@@ -284,7 +284,7 @@ ArchiveFile_t* archive_get_current_file(ArchiveBrowserView* browser) {
 ArchiveFile_t* archive_get_file_at(ArchiveBrowserView* browser, size_t idx) {
     furi_assert(browser);
 
-    ArchiveFile_t* selected;
+    ArchiveFile_t* selected = NULL;
 
     with_view_model(
         browser->view, (ArchiveBrowserViewModel * model) {
@@ -298,7 +298,7 @@ ArchiveFile_t* archive_get_file_at(ArchiveBrowserView* browser, size_t idx) {
 ArchiveTabEnum archive_get_tab(ArchiveBrowserView* browser) {
     furi_assert(browser);
 
-    ArchiveTabEnum tab_id;
+    ArchiveTabEnum tab_id = 0;
     with_view_model(
         browser->view, (ArchiveBrowserViewModel * model) {
             tab_id = model->tab_idx;
@@ -452,8 +452,6 @@ void archive_switch_tab(ArchiveBrowserView* browser, InputKey key) {
             archive_file_browser_set_path(
                 browser, browser->path, archive_get_tab_ext(tab), skip_assets);
             tab_empty = false; // Empty check will be performed later
-        } else {
-            tab_empty = true;
         }
     }
 

applications/main/archive/helpers/archive_browser.h

@@ -16,6 +16,7 @@ static const char* tab_default_paths[] = {
     [ArchiveTabInfrared] = ANY_PATH("infrared"),
     [ArchiveTabBadUsb] = ANY_PATH("badusb"),
     [ArchiveTabU2f] = "/app:u2f",
+    [ArchiveTabApps] = ANY_PATH("apps"),
     [ArchiveTabBrowser] = STORAGE_ANY_PATH_PREFIX,
 };
 
@@ -27,6 +28,7 @@ static const char* known_ext[] = {
     [ArchiveFileTypeInfrared] = ".ir",
     [ArchiveFileTypeBadUsb] = ".txt",
     [ArchiveFileTypeU2f] = "?",
+    [ArchiveFileTypeApps] = ".fap",
     [ArchiveFileTypeUpdateManifest] = ".fuf",
     [ArchiveFileTypeFolder] = "?",
     [ArchiveFileTypeUnknown] = "*",
@@ -41,6 +43,7 @@ static const ArchiveFileTypeEnum known_type[] = {
     [ArchiveTabInfrared] = ArchiveFileTypeInfrared,
     [ArchiveTabBadUsb] = ArchiveFileTypeBadUsb,
     [ArchiveTabU2f] = ArchiveFileTypeU2f,
+    [ArchiveTabApps] = ArchiveFileTypeApps,
     [ArchiveTabBrowser] = ArchiveFileTypeUnknown,
 };
 

applications/main/archive/helpers/archive_files.h

@@ -13,6 +13,7 @@ typedef enum {
     ArchiveFileTypeInfrared,
     ArchiveFileTypeBadUsb,
     ArchiveFileTypeU2f,
+    ArchiveFileTypeApps,
     ArchiveFileTypeUpdateManifest,
     ArchiveFileTypeFolder,
     ArchiveFileTypeUnknown,

applications/main/archive/helpers/archive_menu.h

@@ -42,10 +42,7 @@ ARRAY_DEF(
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-function"
 // Using in applications/archive/views/archive_browser_view.c
-static void archive_menu_add_item(
-    ArchiveContextMenuItem_t* obj,
-    string_t text,
-    uint32_t event) {
+static void archive_menu_add_item(ArchiveContextMenuItem_t* obj, string_t text, uint32_t event) {
     string_init_move(obj->text, text);
     obj->event = event;
 }

applications/main/archive/scenes/archive_scene_browser.c

@@ -19,6 +19,7 @@ static const char* flipper_app_name[] = {
     [ArchiveFileTypeInfrared] = "Infrared",
     [ArchiveFileTypeBadUsb] = "Bad USB",
     [ArchiveFileTypeU2f] = "U2F",
+    [ArchiveFileTypeApps] = "Applications",
     [ArchiveFileTypeUpdateManifest] = "UpdaterApp",
 };
 
@@ -132,7 +133,7 @@ bool archive_scene_browser_on_event(void* context, SceneManagerEvent event) {
         case ArchiveBrowserEventFileMenuRename:
             if(favorites) {
                 browser->callback(ArchiveBrowserEventEnterFavMove, browser->context);
-            //} else if((archive_is_known_app(selected->type)) && (selected->is_app == false)) {
+                //} else if((archive_is_known_app(selected->type)) && (selected->is_app == false)) {
             } else {
                 // Added ability to rename files and folders
                 archive_show_file_menu(browser, false);

applications/main/archive/scenes/archive_scene_info.c

@@ -37,7 +37,11 @@ void archive_scene_info_on_enter(void* context) {
 
     // Directory path
     path_extract_dirname(string_get_cstr(current->path), dirname);
-    string_replace_str(dirname, STORAGE_ANY_PATH_PREFIX, "");
+    if(strcmp(string_get_cstr(dirname), "/any") == 0) {
+        string_replace_str(dirname, STORAGE_ANY_PATH_PREFIX, "/");
+    } else {
+        string_replace_str(dirname, STORAGE_ANY_PATH_PREFIX, "");
+    }
 
     // File size
     FileInfo fileinfo;
@@ -60,7 +64,7 @@ void archive_scene_info_on_enter(void* context) {
             string_get_cstr(dirname));
     }
     widget_add_text_box_element(
-        instance->widget, 0, 25, 128, 25, AlignLeft, AlignCenter, file_info_message, false);
+        instance->widget, 0, 25, 128, 25, AlignLeft, AlignCenter, file_info_message, true);
 
     // This one to return and cursor select this file
     path_extract_filename_no_ext(string_get_cstr(current->path), filename);

applications/main/archive/views/archive_browser_view.c

@@ -16,6 +16,7 @@ static const char* ArchiveTabNames[] = {
     [ArchiveTabInfrared] = "Infrared",
     [ArchiveTabBadUsb] = "Bad USB",
     [ArchiveTabU2f] = "U2F",
+    [ArchiveTabApps] = "Apps",
     [ArchiveTabBrowser] = "Browser",
 };
 
@@ -27,6 +28,7 @@ static const Icon* ArchiveItemIcons[] = {
     [ArchiveFileTypeInfrared] = &I_ir_10px,
     [ArchiveFileTypeBadUsb] = &I_badusb_10px,
     [ArchiveFileTypeU2f] = &I_u2f_10px,
+    [ArchiveFileTypeApps] = &I_Apps_10px,
     [ArchiveFileTypeUpdateManifest] = &I_update_10px,
     [ArchiveFileTypeFolder] = &I_dir_10px,
     [ArchiveFileTypeUnknown] = &I_unknown_10px,

applications/main/archive/views/archive_browser_view.h

@@ -27,6 +27,7 @@ typedef enum {
     ArchiveTabIButton,
     ArchiveTabBadUsb,
     ArchiveTabU2f,
+    ArchiveTabApps,
     ArchiveTabBrowser,
     ArchiveTabTotal,
 } ArchiveTabEnum;

applications/main/clock_app/clock_settings.h

@@ -33,5 +33,4 @@ typedef enum {
 typedef struct {
     TimeFormat time_format;
     DateFormat date_format;
-    uint8_t increment_precision;
 } ClockSettings;

applications/main/fap_loader/fap_loader_app.c

@@ -25,7 +25,7 @@ static bool
     FlipperApplication* app = flipper_application_alloc(loader->storage, &hashtable_api_interface);
 
     FlipperApplicationPreloadStatus preload_res =
-        flipper_application_preload(app, string_get_cstr(path));
+        flipper_application_preload_manifest(app, string_get_cstr(path));
 
     bool load_success = false;
 

applications/main/infrared/scenes/common/infrared_scene_universal_common.c

@@ -33,8 +33,6 @@ static void infrared_scene_universal_common_hide_popup(Infrared* infrared) {
 
 void infrared_scene_universal_common_on_enter(void* context) {
     Infrared* infrared = context;
-    infrared_brute_force_clear_records(infrared->brute_force);
-    button_panel_reset_selection(infrared->button_panel);
     view_stack_add_view(infrared->view_stack, button_panel_get_view(infrared->button_panel));
 }
 
@@ -89,5 +87,6 @@ void infrared_scene_universal_common_on_exit(void* context) {
     Infrared* infrared = context;
     ButtonPanel* button_panel = infrared->button_panel;
     view_stack_remove_view(infrared->view_stack, button_panel_get_view(button_panel));
+    infrared_brute_force_clear_records(infrared->brute_force);
     button_panel_reset(button_panel);
 }

applications/main/lfrfid/views/lfrfid_view_read.c

@@ -16,7 +16,7 @@ static void lfrfid_view_read_draw_callback(Canvas* canvas, void* _model) {
     LfRfidReadViewModel* model = _model;
     canvas_set_color(canvas, ColorBlack);
 
-    canvas_draw_icon(canvas, 0, 8, &I_NFC_manual);
+    canvas_draw_icon(canvas, 0, 8, &I_NFC_manual_60x50);
 
     canvas_set_font(canvas, FontPrimary);
 

applications/main/nfc/nfc.c

@@ -231,7 +231,30 @@ void nfc_show_loading_popup(void* context, bool show) {
     }
 }
 
+static bool nfc_is_hal_ready() {
+    if(!furi_hal_nfc_is_init()) {
+        // No connection to the chip, show an error screen
+        DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
+        DialogMessage* message = dialog_message_alloc();
+        dialog_message_set_text(
+            message,
+            "Error!\nNFC chip failed to start\n\n\nSend a photo of this to:\nsupport@flipperzero.one",
+            0,
+            0,
+            AlignLeft,
+            AlignTop);
+        dialog_message_show(dialogs, message);
+        dialog_message_free(message);
+        furi_record_close(RECORD_DIALOGS);
+        return false;
+    } else {
+        return true;
+    }
+}
+
 int32_t nfc_app(void* p) {
+    if(!nfc_is_hal_ready()) return 0;
+
     Nfc* nfc = nfc_alloc();
     char* args = p;
 

applications/main/nfc/nfc_i.h

@@ -33,8 +33,14 @@
 #include <nfc/scenes/nfc_scene.h>
 #include <nfc/helpers/nfc_custom_event.h>
 
+#include <dialogs/dialogs.h>
+
 #include "rpc/rpc_app.h"
 
+#include <m-array.h>
+
+ARRAY_DEF(MfClassicUserKeys, char*, M_PTR_OPLIST);
+
 #define NFC_TEXT_STORE_SIZE 128
 
 typedef enum {
@@ -58,6 +64,7 @@ struct Nfc {
     char text_store[NFC_TEXT_STORE_SIZE + 1];
     string_t text_box_store;
     uint8_t byte_input_store[6];
+    MfClassicUserKeys_t mfc_key_strs; // Used in MFC key listing
 
     void* rpc_ctx;
     NfcRpcState rpc_state;

applications/main/nfc/scenes/nfc_scene_config.h

@@ -32,6 +32,9 @@ ADD_SCENE(nfc, mf_classic_menu, MfClassicMenu)
 ADD_SCENE(nfc, mf_classic_emulate, MfClassicEmulate)
 ADD_SCENE(nfc, mf_classic_keys, MfClassicKeys)
 ADD_SCENE(nfc, mf_classic_keys_add, MfClassicKeysAdd)
+ADD_SCENE(nfc, mf_classic_keys_list, MfClassicKeysList)
+ADD_SCENE(nfc, mf_classic_keys_delete, MfClassicKeysDelete)
+ADD_SCENE(nfc, mf_classic_keys_warn_duplicate, MfClassicKeysWarnDuplicate)
 ADD_SCENE(nfc, mf_classic_dict_attack, MfClassicDictAttack)
 ADD_SCENE(nfc, emv_read_success, EmvReadSuccess)
 ADD_SCENE(nfc, emv_menu, EmvMenu)

applications/main/nfc/scenes/nfc_scene_delete_success.c

@@ -25,8 +25,13 @@ bool nfc_scene_delete_success_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventViewExit) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneFileSelect);
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneMfClassicKeys)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneMfClassicKeys);
+            } else {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneStart);
+            }
         }
     }
     return consumed;

applications/main/nfc/scenes/nfc_scene_device_info.c

@@ -47,7 +47,9 @@ void nfc_scene_device_info_on_enter(void* context) {
             }
             string_clear(country_name);
         }
-    } else if(dev_data->protocol == NfcDeviceProtocolMifareClassic) {
+    } else if(
+        dev_data->protocol == NfcDeviceProtocolMifareClassic ||
+        dev_data->protocol == NfcDeviceProtocolMifareUl) {
         string_set(temp_str, nfc->dev->dev_data.parsed_data);
     }
 

applications/main/nfc/scenes/nfc_scene_dict_not_found.c

@@ -31,7 +31,10 @@ bool nfc_scene_dict_not_found_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventViewExit) {
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneExtraActions)) {
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneMfClassicKeys)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneMfClassicKeys);
+            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneExtraActions)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneExtraActions);
             } else {

applications/main/nfc/scenes/nfc_scene_extra_actions.c

@@ -17,7 +17,7 @@ void nfc_scene_extra_actions_on_enter(void* context) {
 
     submenu_add_item(
         submenu,
-        "Mf Classic Keys",
+        "Mifare Classic Keys",
         SubmenuIndexMfClassicKeys,
         nfc_scene_extra_actions_submenu_callback,
         nfc);

applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c

@@ -26,15 +26,25 @@ void nfc_scene_mf_classic_keys_on_enter(void* context) {
     }
 
     widget_add_string_element(
-        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "MF Classic Keys");
+        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "Mifare Classic Keys");
     char temp_str[32];
-    snprintf(temp_str, sizeof(temp_str), "Flipper dict: %ld", flipper_dict_keys_total);
+    snprintf(temp_str, sizeof(temp_str), "Flipper list: %ld", flipper_dict_keys_total);
     widget_add_string_element(nfc->widget, 0, 20, AlignLeft, AlignTop, FontSecondary, temp_str);
-    snprintf(temp_str, sizeof(temp_str), "User dict: %ld", user_dict_keys_total);
+    snprintf(temp_str, sizeof(temp_str), "User list: %ld", user_dict_keys_total);
     widget_add_string_element(nfc->widget, 0, 32, AlignLeft, AlignTop, FontSecondary, temp_str);
     widget_add_button_element(
         nfc->widget, GuiButtonTypeCenter, "Add", nfc_scene_mf_classic_keys_widget_callback, nfc);
-    widget_add_icon_element(nfc->widget, 90, 12, &I_Keychain);
+    widget_add_button_element(
+        nfc->widget, GuiButtonTypeLeft, "Back", nfc_scene_mf_classic_keys_widget_callback, nfc);
+    widget_add_icon_element(nfc->widget, 87, 13, &I_Keychain_39x36);
+    if(user_dict_keys_total > 0) {
+        widget_add_button_element(
+            nfc->widget,
+            GuiButtonTypeRight,
+            "List",
+            nfc_scene_mf_classic_keys_widget_callback,
+            nfc);
+    }
 
     view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
 }
@@ -47,6 +57,12 @@ bool nfc_scene_mf_classic_keys_on_event(void* context, SceneManagerEvent event)
         if(event.event == GuiButtonTypeCenter) {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeysAdd);
             consumed = true;
+        } else if(event.event == GuiButtonTypeLeft) {
+            scene_manager_previous_scene(nfc->scene_manager);
+            consumed = true;
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeysList);
+            consumed = true;
         }
     }
 

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_add.c

@@ -29,15 +29,16 @@ bool nfc_scene_mf_classic_keys_add_on_event(void* context, SceneManagerEvent eve
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventByteInputDone) {
             // Add key to dict
-            bool key_added = false;
             MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
             if(dict) {
-                if(mf_classic_dict_add_key(dict, nfc->byte_input_store)) {
-                    key_added = true;
+                if(mf_classic_dict_is_key_present(dict, nfc->byte_input_store)) {
+                    scene_manager_next_scene(
+                        nfc->scene_manager, NfcSceneMfClassicKeysWarnDuplicate);
+                } else if(mf_classic_dict_add_key(dict, nfc->byte_input_store)) {
+                    scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
+                } else {
+                    scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
                 }
-            }
-            if(key_added) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
             } else {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
             }

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_delete.c

@@ -0,0 +1,77 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mf_classic_keys_delete_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    Nfc* nfc = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_classic_keys_delete_on_enter(void* context) {
+    Nfc* nfc = context;
+    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+    uint32_t key_index =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicKeysDelete);
+    // Setup Custom Widget view
+    string_t key_str;
+    string_init(key_str);
+
+    widget_add_string_element(
+        nfc->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Delete this key?");
+    widget_add_button_element(
+        nfc->widget,
+        GuiButtonTypeLeft,
+        "Cancel",
+        nfc_scene_mf_classic_keys_delete_widget_callback,
+        nfc);
+    widget_add_button_element(
+        nfc->widget,
+        GuiButtonTypeRight,
+        "Delete",
+        nfc_scene_mf_classic_keys_delete_widget_callback,
+        nfc);
+
+    mf_classic_dict_get_key_at_index_str(dict, key_str, key_index);
+    widget_add_string_element(
+        nfc->widget, 64, 32, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(key_str));
+
+    string_clear(key_str);
+    mf_classic_dict_free(dict);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_classic_keys_delete_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+    uint32_t key_index =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicKeysDelete);
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                nfc->scene_manager, NfcSceneMfClassicKeys);
+        } else if(event.event == GuiButtonTypeRight) {
+            MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+            if(mf_classic_dict_delete_index(dict, key_index)) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneDeleteSuccess);
+            } else {
+                scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneMfClassicKeys);
+            }
+            mf_classic_dict_free(dict);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_keys_delete_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    widget_reset(nfc->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c

@@ -0,0 +1,100 @@
+#include "../nfc_i.h"
+
+#define NFC_SCENE_MF_CLASSIC_KEYS_LIST_MAX (100)
+
+void nfc_scene_mf_classic_keys_list_submenu_callback(void* context, uint32_t index) {
+    furi_assert(context);
+
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_mf_classic_keys_list_popup_callback(void* context) {
+    furi_assert(context);
+
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_mf_classic_keys_list_prepare(Nfc* nfc, MfClassicDict* dict) {
+    Submenu* submenu = nfc->submenu;
+    uint32_t index = 0;
+    string_t temp_key;
+    string_init(temp_key);
+
+    submenu_set_header(submenu, "Select key to delete:");
+    while(mf_classic_dict_get_next_key_str(dict, temp_key)) {
+        char* current_key = (char*)malloc(sizeof(char) * 13);
+        strncpy(current_key, string_get_cstr(temp_key), 12);
+        MfClassicUserKeys_push_back(nfc->mfc_key_strs, current_key);
+        FURI_LOG_D("ListKeys", "Key %d: %s", index, current_key);
+        submenu_add_item(
+            submenu, current_key, index++, nfc_scene_mf_classic_keys_list_submenu_callback, nfc);
+    }
+    string_clear(temp_key);
+}
+
+void nfc_scene_mf_classic_keys_list_on_enter(void* context) {
+    Nfc* nfc = context;
+    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+    MfClassicUserKeys_init(nfc->mfc_key_strs);
+    if(dict) {
+        uint32_t total_user_keys = mf_classic_dict_get_total_keys(dict);
+        if(total_user_keys < NFC_SCENE_MF_CLASSIC_KEYS_LIST_MAX) {
+            nfc_scene_mf_classic_keys_list_prepare(nfc, dict);
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+        } else {
+            popup_set_header(nfc->popup, "Too many keys!", 64, 0, AlignCenter, AlignTop);
+            popup_set_text(
+                nfc->popup,
+                "Edit user dictionary\nwith file browser",
+                64,
+                12,
+                AlignCenter,
+                AlignTop);
+            popup_set_callback(nfc->popup, nfc_scene_mf_classic_keys_list_popup_callback);
+            popup_set_context(nfc->popup, nfc);
+            popup_set_timeout(nfc->popup, 3000);
+            popup_enable_timeout(nfc->popup);
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+        }
+        mf_classic_dict_free(dict);
+    } else {
+        popup_set_header(
+            nfc->popup, "Failed to load dictionary", 64, 32, AlignCenter, AlignCenter);
+        popup_set_callback(nfc->popup, nfc_scene_mf_classic_keys_list_popup_callback);
+        popup_set_context(nfc->popup, nfc);
+        popup_set_timeout(nfc->popup, 3000);
+        popup_enable_timeout(nfc->popup);
+        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    }
+}
+
+bool nfc_scene_mf_classic_keys_list_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_previous_scene(nfc->scene_manager);
+        } else {
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfClassicKeysDelete, event.event);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeysDelete);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_keys_list_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    MfClassicUserKeys_it_t it;
+    for(MfClassicUserKeys_it(it, nfc->mfc_key_strs); !MfClassicUserKeys_end_p(it);
+        MfClassicUserKeys_next(it)) {
+        free(*MfClassicUserKeys_ref(it));
+    }
+    MfClassicUserKeys_clear(nfc->mfc_key_strs);
+    submenu_reset(nfc->submenu);
+    popup_reset(nfc->popup);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_warn_duplicate.c

@@ -0,0 +1,47 @@
+#include "../nfc_i.h"
+
+void nfc_scene_mf_classic_keys_warn_duplicate_popup_callback(void* context) {
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_mf_classic_keys_warn_duplicate_on_enter(void* context) {
+    Nfc* nfc = context;
+
+    // Setup view
+    Popup* popup = nfc->popup;
+    popup_set_icon(popup, 72, 16, &I_DolphinCommon_56x48);
+    popup_set_header(popup, "Key already exists!", 64, 3, AlignCenter, AlignTop);
+    popup_set_text(
+        popup,
+        "Please enter a\n"
+        "different key.",
+        4,
+        24,
+        AlignLeft,
+        AlignTop);
+    popup_set_timeout(popup, 5000);
+    popup_set_context(popup, nfc);
+    popup_set_callback(popup, nfc_scene_mf_classic_keys_warn_duplicate_popup_callback);
+    popup_enable_timeout(popup);
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_mf_classic_keys_warn_duplicate_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                nfc->scene_manager, NfcSceneMfClassicKeysAdd);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_keys_warn_duplicate_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    popup_reset(nfc->popup);
+}

applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c

@@ -7,6 +7,13 @@ enum SubmenuIndex {
     SubmenuIndexDynamic, // dynamic indexes start here
 };
 
+void nfc_scene_mf_desfire_popup_callback(void* context) {
+    furi_assert(context);
+
+    Nfc* nfc = context;
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+}
+
 MifareDesfireApplication* nfc_scene_mf_desfire_app_get_app(Nfc* nfc) {
     uint32_t app_idx = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp) >>
                        1;
@@ -25,46 +32,45 @@ void nfc_scene_mf_desfire_app_submenu_callback(void* context, uint32_t index) {
 
 void nfc_scene_mf_desfire_app_on_enter(void* context) {
     Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
     MifareDesfireApplication* app = nfc_scene_mf_desfire_app_get_app(nfc);
     if(!app) {
         popup_set_icon(nfc->popup, 5, 5, &I_WarningDolphin_45x42);
-        popup_set_header(nfc->popup, "Internal Error!", 55, 12, AlignLeft, AlignBottom);
-        popup_set_text(
-            nfc->popup,
-            "No app selected.\nThis should\nnever happen,\nplease file a bug.",
-            55,
-            15,
-            AlignLeft,
-            AlignTop);
+        popup_set_header(nfc->popup, "Empty card!", 55, 12, AlignLeft, AlignBottom);
+        popup_set_callback(nfc->popup, nfc_scene_mf_desfire_popup_callback);
+        popup_set_context(nfc->popup, nfc);
+        popup_set_timeout(nfc->popup, 3000);
+        popup_enable_timeout(nfc->popup);
+        popup_set_text(nfc->popup, "No application\nfound.", 55, 15, AlignLeft, AlignTop);
         view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-        FURI_LOG_E(TAG, "Bad state. No app selected?");
-        return;
-    }
+    } else {
+        text_box_set_font(nfc->text_box, TextBoxFontHex);
+        submenu_add_item(
+            nfc->submenu,
+            "App info",
+            SubmenuIndexAppInfo,
+            nfc_scene_mf_desfire_app_submenu_callback,
+            nfc);
 
-    text_box_set_font(nfc->text_box, TextBoxFontHex);
-
-    submenu_add_item(
-        submenu, "App info", SubmenuIndexAppInfo, nfc_scene_mf_desfire_app_submenu_callback, nfc);
-
-    uint16_t cap = NFC_TEXT_STORE_SIZE;
-    char* buf = nfc->text_store;
-    int idx = SubmenuIndexDynamic;
-    for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
-        int size = snprintf(buf, cap, "File %d", file->id);
-        if(size < 0 || size >= cap) {
-            FURI_LOG_W(
-                TAG,
-                "Exceeded NFC_TEXT_STORE_SIZE when preparing file id strings; menu truncated");
-            break;
+        uint16_t cap = NFC_TEXT_STORE_SIZE;
+        char* buf = nfc->text_store;
+        int idx = SubmenuIndexDynamic;
+        for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
+            int size = snprintf(buf, cap, "File %d", file->id);
+            if(size < 0 || size >= cap) {
+                FURI_LOG_W(
+                    TAG,
+                    "Exceeded NFC_TEXT_STORE_SIZE when preparing file id strings; menu truncated");
+                break;
+            }
+            char* label = buf;
+            cap -= size + 1;
+            buf += size + 1;
+            submenu_add_item(
+                nfc->submenu, label, idx++, nfc_scene_mf_desfire_app_submenu_callback, nfc);
         }
-        char* label = buf;
-        cap -= size + 1;
-        buf += size + 1;
-        submenu_add_item(submenu, label, idx++, nfc_scene_mf_desfire_app_submenu_callback, nfc);
-    }
 
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+    }
 }
 
 bool nfc_scene_mf_desfire_app_on_event(void* context, SceneManagerEvent event) {
@@ -73,26 +79,30 @@ bool nfc_scene_mf_desfire_app_on_event(void* context, SceneManagerEvent event) {
     uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp);
 
     if(event.type == SceneManagerEventTypeCustom) {
-        MifareDesfireApplication* app = nfc_scene_mf_desfire_app_get_app(nfc);
-        TextBox* text_box = nfc->text_box;
-        string_reset(nfc->text_box_store);
-        if(event.event == SubmenuIndexAppInfo) {
-            mf_df_cat_application_info(app, nfc->text_box_store);
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_previous_scene(nfc->scene_manager);
         } else {
-            uint16_t index = event.event - SubmenuIndexDynamic;
-            MifareDesfireFile* file = app->file_head;
-            for(int i = 0; file && i < index; i++) {
-                file = file->next;
+            MifareDesfireApplication* app = nfc_scene_mf_desfire_app_get_app(nfc);
+            TextBox* text_box = nfc->text_box;
+            string_reset(nfc->text_box_store);
+            if(event.event == SubmenuIndexAppInfo) {
+                mf_df_cat_application_info(app, nfc->text_box_store);
+            } else {
+                uint16_t index = event.event - SubmenuIndexDynamic;
+                MifareDesfireFile* file = app->file_head;
+                for(int i = 0; file && i < index; i++) {
+                    file = file->next;
+                }
+                if(!file) {
+                    return false;
+                }
+                mf_df_cat_file(file, nfc->text_box_store);
             }
-            if(!file) {
-                return false;
-            }
-            mf_df_cat_file(file, nfc->text_box_store);
+            text_box_set_text(text_box, string_get_cstr(nfc->text_box_store));
+            scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, state | 1);
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
+            consumed = true;
         }
-        text_box_set_text(text_box, string_get_cstr(nfc->text_box_store));
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, state | 1);
-        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
-        consumed = true;
     } else if(event.type == SceneManagerEventTypeBack) {
         if(state & 1) {
             view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
@@ -108,6 +118,7 @@ void nfc_scene_mf_desfire_app_on_exit(void* context) {
     Nfc* nfc = context;
 
     // Clear views
+    popup_reset(nfc->popup);
     text_box_reset(nfc->text_box);
     string_reset(nfc->text_box_store);
     submenu_reset(nfc->submenu);

applications/main/nfc/scenes/nfc_scene_mf_ultralight_read_auth.c

@@ -27,7 +27,7 @@ void nfc_scene_mf_ultralight_read_auth_set_state(Nfc* nfc, NfcSceneMfUlReadState
             popup_reset(nfc->popup);
             popup_set_text(
                 nfc->popup, "Apply card to\nFlipper's back", 97, 24, AlignCenter, AlignTop);
-            popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual);
+            popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
         } else if(state == NfcSceneMfUlReadStateReading) {
             popup_reset(nfc->popup);
             popup_set_header(

applications/main/nfc/scenes/nfc_scene_mf_ultralight_read_success.c

@@ -34,15 +34,19 @@ void nfc_scene_mf_ultralight_read_success_on_enter(void* context) {
         nfc);
 
     string_t temp_str;
-    string_init_printf(temp_str, "\e#%s\n", nfc_mf_ul_type(mf_ul_data->type, true));
-    string_cat_printf(temp_str, "UID:");
-    for(size_t i = 0; i < data->uid_len; i++) {
-        string_cat_printf(temp_str, " %02X", data->uid[i]);
-    }
-    string_cat_printf(
-        temp_str, "\nPages Read: %d/%d", mf_ul_data->data_read / 4, mf_ul_data->data_size / 4);
-    if(mf_ul_data->data_read != mf_ul_data->data_size) {
-        string_cat_printf(temp_str, "\nPassword-protected pages!");
+    if(string_size(nfc->dev->dev_data.parsed_data)) {
+        string_init_set(temp_str, nfc->dev->dev_data.parsed_data);
+    } else {
+        string_init_printf(temp_str, "\e#%s\n", nfc_mf_ul_type(mf_ul_data->type, true));
+        string_cat_printf(temp_str, "UID:");
+        for(size_t i = 0; i < data->uid_len; i++) {
+            string_cat_printf(temp_str, " %02X", data->uid[i]);
+        }
+        string_cat_printf(
+            temp_str, "\nPages Read: %d/%d", mf_ul_data->data_read / 4, mf_ul_data->data_size / 4);
+        if(mf_ul_data->data_read != mf_ul_data->data_size) {
+            string_cat_printf(temp_str, "\nPassword-protected pages!");
+        }
     }
     widget_add_text_scroll_element(widget, 0, 0, 128, 52, string_get_cstr(temp_str));
     string_clear(temp_str);

applications/main/nfc/scenes/nfc_scene_mf_ultralight_unlock_menu.c

@@ -20,7 +20,7 @@ void nfc_scene_mf_ultralight_unlock_menu_on_enter(void* context) {
         scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
     submenu_add_item(
         submenu,
-        "Enter Password Manually",
+        "Enter PWD Manually",
         SubmenuIndexMfUlUnlockMenuManual,
         nfc_scene_mf_ultralight_unlock_menu_submenu_callback,
         nfc);

applications/main/nfc/scenes/nfc_scene_read.c

@@ -26,7 +26,7 @@ void nfc_scene_read_set_state(Nfc* nfc, NfcSceneReadState state) {
             popup_reset(nfc->popup);
             popup_set_text(
                 nfc->popup, "Apply card to\nFlipper's back", 97, 24, AlignCenter, AlignTop);
-            popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual);
+            popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
         } else if(state == NfcSceneReadStateReading) {
             popup_reset(nfc->popup);
             popup_set_header(

applications/main/nfc/scenes/nfc_scene_restore_original_confirm.c

@@ -11,7 +11,7 @@ void nfc_scene_restore_original_confirm_on_enter(void* context) {
     DialogEx* dialog_ex = nfc->dialog_ex;
 
     dialog_ex_set_header(dialog_ex, "Restore Card Data?", 64, 0, AlignCenter, AlignTop);
-    dialog_ex_set_icon(dialog_ex, 5, 15, &I_Restoring);
+    dialog_ex_set_icon(dialog_ex, 5, 15, &I_Restoring_38x32);
     dialog_ex_set_text(
         dialog_ex, "It will be returned\nto its original state.", 47, 21, AlignLeft, AlignTop);
     dialog_ex_set_left_button_text(dialog_ex, "Cancel");

applications/main/nfc/scenes/nfc_scene_save_success.c

@@ -27,7 +27,10 @@ bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventViewExit) {
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneMfClassicKeys)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneMfClassicKeys);
+            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneSavedMenu);
             } else {

applications/main/nfc/scenes/nfc_scene_saved_menu.c

@@ -91,7 +91,9 @@ bool nfc_scene_saved_menu_on_event(void* context, SceneManagerEvent event) {
             bool application_info_present = false;
             if(dev_data->protocol == NfcDeviceProtocolEMV) {
                 application_info_present = true;
-            } else if(dev_data->protocol == NfcDeviceProtocolMifareClassic) {
+            } else if(
+                dev_data->protocol == NfcDeviceProtocolMifareClassic ||
+                dev_data->protocol == NfcDeviceProtocolMifareUl) {
                 application_info_present = nfc_supported_card_verify_and_parse(dev_data);
             }
 

applications/main/subghz/scenes/subghz_scene_decode_raw.c

@@ -112,7 +112,7 @@ bool subghz_scene_decode_raw_start(SubGhz* subghz) {
     } while(false);
 
     if(success) {
-        FURI_LOG_I(TAG, "Listening at \033[0;33m%s\033[0m.", string_get_cstr(file_name));
+        //FURI_LOG_I(TAG, "Listening at \033[0;33m%s\033[0m.", string_get_cstr(file_name));
 
         file_worker_encoder = subghz_file_encoder_worker_alloc();
         if(subghz_file_encoder_worker_start(file_worker_encoder, string_get_cstr(file_name))) {
@@ -180,6 +180,7 @@ void subghz_scene_decode_raw_on_enter(void* context) {
         subghz_receiver_search_decoder_base_by_name(
             subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME),
         false);
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
 
     if(decode_raw_state == SubGhzDecodeRawStateStart) {
         //Decode RAW to history
@@ -224,6 +225,8 @@ bool subghz_scene_decode_raw_on_event(void* context, SceneManagerEvent event) {
             subghz_file_encoder_worker_free(file_worker_encoder);
 
             subghz->state_notifications = SubGhzNotificationStateIDLE;
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);
             scene_manager_search_and_switch_to_previous_scene(
                 subghz->scene_manager, SubGhzSceneMoreRAW);
             consumed = true;
@@ -237,7 +240,7 @@ bool subghz_scene_decode_raw_on_event(void* context, SceneManagerEvent event) {
             consumed = true;
             break;
         case SubGhzCustomEventViewReceiverConfig:
-            FURI_LOG_I(TAG, "No config options");
+            FURI_LOG_W(TAG, "No config options");
             consumed = true;
             break;
         case SubGhzCustomEventViewReceiverOffDisplay:
@@ -257,7 +260,7 @@ bool subghz_scene_decode_raw_on_event(void* context, SceneManagerEvent event) {
             notification_message(subghz->notifications, &sequence_blink_cyan_10);
             break;
         case SubGhzNotificationStateRxDone:
-            notification_message(subghz->notifications, &subghs_sequence_rx);
+            notification_message(subghz->notifications, &subghz_sequence_rx);
             subghz->state_notifications = SubGhzNotificationStateRx;
             break;
         default:

applications/main/subghz/scenes/subghz_scene_need_saving.c

@@ -50,8 +50,8 @@ bool subghz_scene_need_saving_on_event(void* context, SceneManagerEvent event) {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
                 subghz_preset_init(
                     subghz,
-                    string_get_cstr(subghz->last_setting->preset_name),
-                    subghz->last_setting->frequency,
+                    "AM650",
+                    subghz_setting_get_default_frequency(subghz->setting),
                     NULL,
                     0);
                 scene_manager_search_and_switch_to_previous_scene(

applications/main/subghz/scenes/subghz_scene_read_raw.c

@@ -113,11 +113,6 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
     if(event.type == SceneManagerEventTypeCustom) {
         switch(event.event) {
         case SubGhzCustomEventViewReadRAWBack:
-            // Check if return from config save values
-            if(subghz->current_scene == SubGhzSceneReceiverConfig) {
-                subghz_last_setting_save(
-                    subghz->last_setting, EXT_PATH("subghz/assets/last_used.txt"));
-            }
             //Stop TX
             if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
                 subghz_tx_stop(subghz);
@@ -136,14 +131,13 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
             if((subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) ||
                (subghz->txrx->rx_key_state == SubGhzRxKeyStateBack)) {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateExit;
-                subghz->current_scene = SubGhzSceneNeedSaving;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
             } else {
                 //Restore default setting
                 subghz_preset_init(
                     subghz,
-                    string_get_cstr(subghz->last_setting->preset_name),
-                    subghz->last_setting->frequency,
+                    "AM650",
+                    subghz_setting_get_default_frequency(subghz->setting),
                     NULL,
                     0);
                 if(!scene_manager_search_and_switch_to_previous_scene(
@@ -152,11 +146,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                            subghz->scene_manager, SubGhzSceneStart)) {
                         scene_manager_stop(subghz->scene_manager);
                         view_dispatcher_stop(subghz->view_dispatcher);
-                    } else {
-                        subghz->current_scene = SubGhzSceneStart;
                     }
-                } else {
-                    subghz->current_scene = SubGhzSceneSaved;
                 }
             }
             consumed = true;
@@ -180,7 +170,6 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
         case SubGhzCustomEventViewReadRAWConfig:
             scene_manager_set_scene_state(
                 subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSet);
-            subghz->current_scene = SubGhzSceneReceiverConfig;
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
             consumed = true;
             break;
@@ -202,7 +191,6 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_set_scene_state(
                     subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSet);
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateRAWLoad;
-                subghz->current_scene = SubGhzSceneMoreRAW;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneMoreRAW);
                 consumed = true;
             } else {
@@ -222,7 +210,6 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                    (subghz->txrx->txrx_state == SubGhzTxRxStateSleep)) {
                     if(!subghz_tx_start(subghz, subghz->txrx->fff_data)) {
                         subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
-                        subghz->current_scene = SubGhzSceneShowOnlyRx;
                         scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
                     } else {
                         DOLPHIN_DEED(DolphinDeedSubGhzSend);
@@ -282,7 +269,6 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
 
         case SubGhzCustomEventViewReadRAWREC:
             if(subghz->txrx->rx_key_state != SubGhzRxKeyStateIDLE) {
-                subghz->current_scene = SubGhzSceneNeedSaving;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
             } else {
                 //subghz_get_preset_name(subghz, subghz->error_str);
@@ -303,7 +289,6 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                     subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
                 } else {
                     string_set_str(subghz->error_str, "Function requires\nan SD card.");
-                    subghz->current_scene = SubGhzSceneShowError;
                     scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
                 }
             }
@@ -315,7 +300,6 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_set_scene_state(
                     subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerSetRAW);
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateBack;
-                subghz->current_scene = SubGhzSceneSaveName;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
             }
             consumed = true;

applications/main/subghz/scenes/subghz_scene_receiver.c

@@ -1,7 +1,7 @@
 #include "../subghz_i.h"
 #include "../views/receiver.h"
 
-const NotificationSequence subghs_sequence_rx = {
+const NotificationSequence subghz_sequence_rx = {
     &message_green_255,
 
     &message_vibro_on,
@@ -14,7 +14,7 @@ const NotificationSequence subghs_sequence_rx = {
     NULL,
 };
 
-const NotificationSequence subghs_sequence_rx_locked = {
+const NotificationSequence subghz_sequence_rx_locked = {
     &message_green_255,
 
     &message_display_backlight_on,
@@ -103,11 +103,7 @@ void subghz_scene_receiver_on_enter(void* context) {
 
     if(subghz->txrx->rx_key_state == SubGhzRxKeyStateIDLE) {
         subghz_preset_init(
-            subghz,
-            string_get_cstr(subghz->last_setting->preset_name),
-            subghz->last_setting->frequency,
-            NULL,
-            0);
+            subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
         subghz_history_reset(subghz->txrx->history);
         subghz->txrx->rx_key_state = SubGhzRxKeyStateStart;
     }
@@ -136,7 +132,7 @@ void subghz_scene_receiver_on_enter(void* context) {
     subghz->state_notifications = SubGhzNotificationStateRx;
     if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
         subghz_rx_end(subghz);
-    };
+    }
     if((subghz->txrx->txrx_state == SubGhzTxRxStateIDLE) ||
        (subghz->txrx->txrx_state == SubGhzTxRxStateSleep)) {
         subghz_begin(
@@ -156,34 +152,27 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
     if(event.type == SceneManagerEventTypeCustom) {
         switch(event.event) {
         case SubGhzCustomEventViewReceiverBack:
-            // Check if return from config save values
-            if(subghz->current_scene == SubGhzSceneReceiverConfig) {
-                subghz_last_setting_save(
-                    subghz->last_setting, EXT_PATH("subghz/assets/last_used.txt"));
-            }
             // Stop CC1101 Rx
             subghz->state_notifications = SubGhzNotificationStateIDLE;
             if(subghz->txrx->txrx_state == SubGhzTxRxStateRx) {
                 subghz_rx_end(subghz);
                 subghz_sleep(subghz);
-            };
+            }
             subghz->txrx->hopper_state = SubGhzHopperStateOFF;
             subghz->txrx->idx_menu_chosen = 0;
             subghz_receiver_set_rx_callback(subghz->txrx->receiver, NULL, subghz);
 
             if(subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateExit;
-                subghz->current_scene = SubGhzSceneNeedSaving;
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
             } else {
                 subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
                 subghz_preset_init(
                     subghz,
-                    string_get_cstr(subghz->last_setting->preset_name),
-                    subghz->last_setting->frequency,
+                    "AM650",
+                    subghz_setting_get_default_frequency(subghz->setting),
                     NULL,
                     0);
-                subghz->current_scene = SubGhzSceneStart;
                 scene_manager_search_and_switch_to_previous_scene(
                     subghz->scene_manager, SubGhzSceneStart);
             }
@@ -192,7 +181,6 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
         case SubGhzCustomEventViewReceiverOK:
             subghz->txrx->idx_menu_chosen =
                 subghz_view_receiver_get_idx_menu(subghz->subghz_receiver);
-            subghz->current_scene = SubGhzSceneReceiverInfo;
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverInfo);
             consumed = true;
             break;
@@ -200,7 +188,6 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
             subghz->state_notifications = SubGhzNotificationStateIDLE;
             subghz->txrx->idx_menu_chosen =
                 subghz_view_receiver_get_idx_menu(subghz->subghz_receiver);
-            subghz->current_scene = SubGhzSceneReceiverConfig;
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiverConfig);
             consumed = true;
             break;
@@ -226,9 +213,9 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
             break;
         case SubGhzNotificationStateRxDone:
             if(subghz->lock != SubGhzLockOn) {
-                notification_message(subghz->notifications, &subghs_sequence_rx);
+                notification_message(subghz->notifications, &subghz_sequence_rx);
             } else {
-                notification_message(subghz->notifications, &subghs_sequence_rx_locked);
+                notification_message(subghz->notifications, &subghz_sequence_rx_locked);
             }
             subghz->state_notifications = SubGhzNotificationStateRx;
             break;

applications/main/subghz/scenes/subghz_scene_receiver_config.c

@@ -145,8 +145,6 @@ static void subghz_scene_receiver_config_set_frequency(VariableItem* item) {
             (subghz_setting_get_frequency(subghz->setting, index) % 1000000) / 10000);
         variable_item_set_current_value_text(item, text_buf);
         subghz->txrx->preset->frequency = subghz_setting_get_frequency(subghz->setting, index);
-        subghz->last_setting->frequency = subghz->txrx->preset->frequency;
-        subghz_setting_set_default_frequency(subghz->setting, subghz->txrx->preset->frequency);
     } else {
         variable_item_set_current_value_index(
             item, subghz_setting_get_frequency_default_index(subghz->setting));
@@ -156,13 +154,11 @@ static void subghz_scene_receiver_config_set_frequency(VariableItem* item) {
 static void subghz_scene_receiver_config_set_preset(VariableItem* item) {
     SubGhz* subghz = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
-    const char* preset_name = subghz_setting_get_preset_name(subghz->setting, index);
-    variable_item_set_current_value_text(item, preset_name);
-    string_set_str(subghz->last_setting->preset_name, preset_name);
-
+    variable_item_set_current_value_text(
+        item, subghz_setting_get_preset_name(subghz->setting, index));
     subghz_preset_init(
         subghz,
-        preset_name,
+        subghz_setting_get_preset_name(subghz->setting, index),
         subghz->txrx->preset->frequency,
         subghz_setting_get_preset_data(subghz->setting, index),
         subghz_setting_get_preset_data_size(subghz->setting, index));
@@ -177,7 +173,6 @@ static void subghz_scene_receiver_config_set_rssi_threshold(VariableItem* item)
         subghz_receiver_search_decoder_base_by_name(
             subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME),
         rssi_threshold_value[index]);
-    subghz->last_setting->rssi_threshold = rssi_threshold_value[index];
 }
 
 static void subghz_scene_receiver_config_set_detect_raw(VariableItem* item) {
@@ -187,8 +182,6 @@ static void subghz_scene_receiver_config_set_detect_raw(VariableItem* item) {
     variable_item_set_current_value_text(item, detect_raw_text[index]);
     subghz_receiver_set_filter(subghz->txrx->receiver, detect_raw_value[index]);
 
-    //subghz->last_setting->detect_raw = detect_raw_value[index];
-
     subghz_protocol_decoder_raw_set_auto_mode(
         subghz_receiver_search_decoder_base_by_name(
             subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME),
@@ -228,7 +221,7 @@ static void subghz_scene_receiver_config_set_hopping_running(VariableItem* item)
             subghz_setting_get_frequency_default_index(subghz->setting));
     }
 
-    subghz->txrx->hopper_state = subghz->last_setting->hopping = hopping_value[index];
+    subghz->txrx->hopper_state = hopping_value[index];
 }
 
 static void subghz_scene_receiver_config_var_list_enter_callback(void* context, uint32_t index) {
@@ -352,6 +345,7 @@ bool subghz_scene_receiver_config_on_event(void* context, SceneManagerEvent even
 
 void subghz_scene_receiver_config_on_exit(void* context) {
     SubGhz* subghz = context;
+    variable_item_list_set_selected_item(subghz->variable_item_list, 0);
     variable_item_list_reset(subghz->variable_item_list);
     scene_manager_set_scene_state(
         subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);

applications/main/subghz/scenes/subghz_scene_save_name.c

@@ -14,6 +14,22 @@ void subghz_scene_save_name_text_input_callback(void* context) {
     view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneSaveName);
 }
 
+void subghz_scene_save_name_get_timefilename(string_t name, uint32_t frequency) {
+    FuriHalRtcDateTime datetime = {0};
+    furi_hal_rtc_get_datetime(&datetime);
+    string_printf(
+        name,
+        "RAW_%.4d.%.2d.%.2d-%.2d.%.2d.%.2d-%d.%.2dMHz",
+        datetime.year,
+        datetime.month,
+        datetime.day,
+        datetime.hour,
+        datetime.minute,
+        datetime.second,
+        frequency / 1000000,
+        (frequency / 10000) % 100);
+}
+
 void subghz_scene_save_name_on_enter(void* context) {
     SubGhz* subghz = context;
 
@@ -42,9 +58,9 @@ void subghz_scene_save_name_on_enter(void* context) {
             if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) ==
                SubGhzCustomEventManagerSetRAW) {
                 dev_name_empty = true;
-                subghz_get_next_name_file(subghz, SUBGHZ_MAX_LEN_NAME);
+                subghz_scene_save_name_get_timefilename(
+                    file_name, subghz->txrx->preset->frequency);
             }
-            path_extract_filename(subghz->file_path, file_name, true);
         }
         string_set(subghz->file_path, dir_name);
     }

applications/main/subghz/scenes/subghz_scene_show_error.c

@@ -1,7 +1,7 @@
 #include "../subghz_i.h"
 #include "../helpers/subghz_custom_event.h"
 
-static const NotificationSequence subghs_sequence_sd_error = {
+static const NotificationSequence subghz_sequence_sd_error = {
     &message_red_255,
     &message_green_255,
     &message_do_not_reset,
@@ -39,7 +39,7 @@ void subghz_scene_show_error_on_enter(void* context) {
         widget_add_button_element(
             subghz->widget, GuiButtonTypeRight, "OK", subghz_scene_show_error_callback, subghz);
     } else {
-        notification_message(subghz->notifications, &subghs_sequence_sd_error);
+        notification_message(subghz->notifications, &subghz_sequence_sd_error);
     }
 
     widget_add_button_element(

applications/main/subghz/scenes/subghz_scene_start.c

@@ -1,5 +1,7 @@
 #include "../subghz_i.h"
 
+#include <lib/subghz/protocols/raw.h>
+
 enum SubmenuIndex {
     SubmenuIndexRead = 10,
     SubmenuIndexSaved,
@@ -19,6 +21,12 @@ void subghz_scene_start_on_enter(void* context) {
     if(subghz->state_notifications == SubGhzNotificationStateStarting) {
         subghz->state_notifications = SubGhzNotificationStateIDLE;
     }
+    subghz_protocol_decoder_raw_set_auto_mode(
+        subghz_receiver_search_decoder_base_by_name(
+            subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME),
+        false);
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
+
     submenu_add_item(
         subghz->submenu, "Read", SubmenuIndexRead, subghz_scene_start_submenu_callback, subghz);
     submenu_add_item(

applications/main/subghz/subghz.c

@@ -1,9 +1,9 @@
 /* Abandon hope, all ye who enter here. */
 
-#include "m-string.h"
-#include "subghz/types.h"
-#include "subghz_i.h"
+#include <m-string.h>
+#include <subghz/types.h>
 #include <lib/toolbox/path.h>
+#include "subghz_i.h"
 
 bool subghz_custom_event_callback(void* context, uint32_t event) {
     furi_assert(context);
@@ -174,25 +174,16 @@ SubGhz* subghz_alloc() {
     subghz->setting = subghz_setting_alloc();
     subghz_setting_load(subghz->setting, EXT_PATH("subghz/assets/setting_user"));
 
-    // Load last used values for Read, Read RAW, etc. or default
-    subghz->last_setting = subghz_last_setting_alloc();
-    subghz_last_setting_load(subghz->last_setting, EXT_PATH("subghz/assets/last_used.txt"));
-    subghz_setting_set_default_frequency(subghz->setting, subghz->last_setting->frequency);
-
     //init Worker & Protocol & History & KeyBoard
     subghz->lock = SubGhzLockOff;
     subghz->txrx = malloc(sizeof(SubGhzTxRx));
     subghz->txrx->preset = malloc(sizeof(SubGhzPresetDefinition));
     string_init(subghz->txrx->preset->name);
     subghz_preset_init(
-        subghz,
-        string_get_cstr(subghz->last_setting->preset_name),
-        subghz->last_setting->frequency,
-        NULL,
-        0);
+        subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
 
     subghz->txrx->txrx_state = SubGhzTxRxStateSleep;
-    subghz->txrx->hopper_state = subghz->last_setting->hopping;
+    subghz->txrx->hopper_state = SubGhzHopperStateOFF;
     subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
     subghz->txrx->history = subghz_history_alloc();
     subghz->txrx->worker = subghz_worker_alloc();
@@ -205,9 +196,7 @@ SubGhz* subghz_alloc() {
     subghz_environment_set_nice_flor_s_rainbow_table_file_name(
         subghz->txrx->environment, EXT_PATH("subghz/assets/nice_flor_s"));
     subghz->txrx->receiver = subghz_receiver_alloc_init(subghz->txrx->environment);
-
-    // Setup values
-    subghz_last_setting_set_receiver_values(subghz->last_setting, subghz->txrx->receiver);
+    subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
 
     subghz_worker_set_overrun_callback(
         subghz->txrx->worker, (SubGhzWorkerOverrunCallback)subghz_receiver_reset);
@@ -299,9 +288,6 @@ void subghz_free(SubGhz* subghz) {
     //setting
     subghz_setting_free(subghz->setting);
 
-    // Last setting
-    subghz_last_setting_free(subghz->last_setting);
-
     //Worker & Protocol & History
     subghz_receiver_free(subghz->txrx->receiver);
     subghz_environment_free(subghz->txrx->environment);

applications/main/subghz/subghz_history.c

@@ -1,7 +1,5 @@
 #include "subghz_history.h"
 #include <lib/subghz/receiver.h>
-#include <lib/subghz/protocols/came.h>
-
 #include <furi.h>
 #include <m-string.h>
 

applications/main/subghz/subghz_i.h

@@ -33,7 +33,6 @@
 
 #include "subghz_history.h"
 #include "subghz_setting.h"
-#include "subghz_last_setting.h"
 
 #include <gui/modules/variable_item_list.h>
 #include <lib/toolbox/path.h>
@@ -101,11 +100,10 @@ struct SubGhz {
     SubGhzTestPacket* subghz_test_packet;
     string_t error_str;
     SubGhzSetting* setting;
-    SubGhzLastSetting* last_setting;
     SubGhzLock lock;
 
     bool in_decoder_scene;
-    SubGhzScene current_scene;
+
     void* rpc_ctx;
 };
 
@@ -142,5 +140,5 @@ bool subghz_path_is_file(string_t path);
 uint32_t subghz_random_serial(void);
 void subghz_hopper_update(SubGhz* subghz);
 
-extern const NotificationSequence subghs_sequence_rx;
-extern const NotificationSequence subghs_sequence_rx_locked;
+extern const NotificationSequence subghz_sequence_rx;
+extern const NotificationSequence subghz_sequence_rx_locked;

applications/main/subghz/subghz_last_setting.c

@@ -1,144 +0,0 @@
-#include "subghz_setting.h"
-#include "subghz_i.h"
-
-#include "subghz_last_setting.h"
-
-#include <furi.h>
-#include <m-list.h>
-#include "furi_hal_subghz.h"
-#include "furi_hal_subghz_configs.h"
-#include <lib/subghz/protocols/raw.h>
-
-#define TAG "SubGhzLastSetting"
-
-#define SUBGHZ_LAST_SETTING_FILE_TYPE "Flipper SubGhz Last Setting File"
-#define SUBGHZ_LAST_SETTING_FILE_VERSION 1
-#define SUBGHZ_LAST_SETTING_DEFAULT_PRESET "AM650"
-#define SUBGHZ_LAST_SETTING_DEFAULT_FREQUENCY 433920000
-
-SubGhzLastSetting* subghz_last_setting_alloc(void) {
-    SubGhzLastSetting* instance = malloc(sizeof(SubGhzLastSetting));
-    string_init(instance->preset_name);
-
-    return instance;
-}
-
-void subghz_last_setting_free(SubGhzLastSetting* instance) {
-    furi_assert(instance);
-
-    string_clear(instance->preset_name);
-    free(instance);
-}
-
-void subghz_last_setting_load(SubGhzLastSetting* instance, const char* file_path) {
-    furi_assert(instance);
-    string_init(instance->preset_name);
-
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
-
-    string_t temp_preset;
-    string_init(temp_preset);
-    uint32_t temp_frequency = 0; // Default 433920000
-    uint32_t temp_hopping = 0; // Default 0
-    //uint32_t temp_detect_raw = 0;  Default 2
-    int32_t temp_rssi_threshold = 0; // Default -72
-
-    if(FSE_OK == storage_sd_status(storage) && file_path &&
-       flipper_format_file_open_existing(fff_data_file, file_path)) {
-        flipper_format_read_string(fff_data_file, "Preset", temp_preset);
-        flipper_format_read_uint32(fff_data_file, "Frequency", (uint32_t*)&temp_frequency, 1);
-        flipper_format_read_uint32(fff_data_file, "Hopping", (uint32_t*)&temp_hopping, 1);
-        //flipper_format_read_uint32(fff_data_file, "DetectRaw", (uint32_t*)&temp_detect_raw, 1);
-        flipper_format_read_int32(fff_data_file, "Rssi", (int32_t*)&temp_rssi_threshold, 1);
-    } else {
-        FURI_LOG_E(TAG, "Error open file %s", file_path);
-    }
-
-    if(string_empty_p(temp_preset)) {
-        //FURI_LOG_I(TAG, "Last used preset not found");
-        string_set(instance->preset_name, SUBGHZ_LAST_SETTING_DEFAULT_PRESET);
-    } else {
-        string_set(instance->preset_name, temp_preset);
-    }
-
-    if(temp_frequency == 0 || !furi_hal_subghz_is_tx_allowed(temp_frequency)) {
-        //FURI_LOG_I(TAG, "Last used frequency not found or can't be used!");
-        instance->frequency = SUBGHZ_LAST_SETTING_DEFAULT_FREQUENCY;
-    } else {
-        instance->frequency = temp_frequency;
-    }
-
-    /*if(temp_detect_raw == 0) {
-        instance->detect_raw = SubGhzProtocolFlag_Decodable;
-    } else {
-        instance->detect_raw = temp_detect_raw;
-    }*/
-
-    if(temp_rssi_threshold == 0) {
-        instance->rssi_threshold = -72;
-    } else {
-        instance->rssi_threshold = temp_rssi_threshold;
-    }
-    instance->hopping = temp_hopping;
-
-    string_clear(temp_preset);
-    flipper_format_free(fff_data_file);
-    furi_record_close(RECORD_STORAGE);
-}
-
-bool subghz_last_setting_save(SubGhzLastSetting* instance, const char* file_path) {
-    furi_assert(instance);
-
-    bool saved = false;
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    FlipperFormat* file = flipper_format_file_alloc(storage);
-
-    do {
-        if(FSE_OK != storage_sd_status(storage)) break;
-
-        // Open file
-        if(!flipper_format_file_open_always(file, file_path)) break;
-
-        // Write header
-        if(!flipper_format_write_header_cstr(
-               file, SUBGHZ_LAST_SETTING_FILE_TYPE, SUBGHZ_LAST_SETTING_FILE_VERSION))
-            break;
-
-        //FURI_LOG_D(TAG, "Preset %s", string_get_cstr(instance->preset_name));
-        if(!flipper_format_insert_or_update_string_cstr(
-               file, "Preset", string_get_cstr(instance->preset_name)))
-            break;
-        if(!flipper_format_insert_or_update_uint32(file, "Frequency", &instance->frequency, 1))
-            break;
-        if(!flipper_format_insert_or_update_uint32(file, "Hopping", &instance->hopping, 1)) break;
-        //if(!flipper_format_insert_or_update_uint32(file, "DetectRaw", &instance->detect_raw, 1))
-        //    break;
-        if(!flipper_format_insert_or_update_int32(file, "Rssi", &instance->rssi_threshold, 1))
-            break;
-
-        saved = true;
-    } while(0);
-
-    if(!saved) {
-        FURI_LOG_E(TAG, "Error save file %s", file_path);
-    }
-
-    flipper_format_free(file);
-    furi_record_close(RECORD_STORAGE);
-
-    return saved;
-}
-
-void subghz_last_setting_set_receiver_values(SubGhzLastSetting* instance, SubGhzReceiver* receiver) {
-    subghz_receiver_set_filter(receiver, SubGhzProtocolFlag_Decodable);
-    /*subghz_receiver_set_filter(receiver, instance->detect_raw);
-
-    subghz_protocol_decoder_raw_set_auto_mode(
-        subghz_receiver_search_decoder_base_by_name(receiver, SUBGHZ_PROTOCOL_RAW_NAME),
-        (instance->detect_raw != SubGhzProtocolFlag_Decodable));*/
-
-    subghz_protocol_decoder_raw_set_rssi_threshold(
-        subghz_receiver_search_decoder_base_by_name(receiver, SUBGHZ_PROTOCOL_RAW_NAME),
-        instance->rssi_threshold);
-}

applications/main/subghz/subghz_last_setting.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <math.h>
-#include <furi.h>
-#include <furi_hal.h>
-#include <lib/flipper_format/flipper_format.h>
-
-typedef struct {
-    string_t preset_name;
-    uint32_t frequency;
-    uint32_t hopping;
-    //uint32_t detect_raw;
-    int32_t rssi_threshold;
-} SubGhzLastSetting;
-
-SubGhzLastSetting* subghz_last_setting_alloc(void);
-
-void subghz_last_setting_free(SubGhzLastSetting* instance);
-
-void subghz_last_setting_load(SubGhzLastSetting* instance, const char* file_path);
-
-bool subghz_last_setting_save(SubGhzLastSetting* instance, const char* file_path);
-
-void subghz_last_setting_set_receiver_values(SubGhzLastSetting* instance, SubGhzReceiver* receiver);

applications/main/subghz/subghz_setting.c

@@ -3,7 +3,7 @@
 
 #include <furi.h>
 #include <m-list.h>
-#include "furi_hal_subghz_configs.h"
+#include <furi_hal_subghz_configs.h>
 
 #define TAG "SubGhzSetting"
 
@@ -260,7 +260,13 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
                 break;
             }
             if(flipper_format_read_uint32(fff_data_file, "Default_frequency", &temp_data32, 1)) {
-                subghz_setting_set_default_frequency(instance, temp_data32);
+                for
+                    M_EACH(frequency, instance->frequencies, FrequencyList_t) {
+                        *frequency &= FREQUENCY_MASK;
+                        if(*frequency == temp_data32) {
+                            *frequency |= FREQUENCY_FLAG_DEFAULT;
+                        }
+                    }
             }
 
             // custom preset (optional)
@@ -288,16 +294,6 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
     }
 }
 
-void subghz_setting_set_default_frequency(SubGhzSetting* instance, uint32_t frequency_to_setup) {
-    for
-        M_EACH(frequency, instance->frequencies, FrequencyList_t) {
-            *frequency &= FREQUENCY_MASK;
-            if(*frequency == frequency_to_setup) {
-                *frequency |= FREQUENCY_FLAG_DEFAULT;
-            }
-        }
-}
-
 size_t subghz_setting_get_frequency_count(SubGhzSetting* instance) {
     furi_assert(instance);
     return FrequencyList_size(instance->frequencies);

applications/main/subghz/subghz_setting.h

@@ -46,5 +46,3 @@ uint32_t subghz_setting_get_hopper_frequency(SubGhzSetting* instance, size_t idx
 uint32_t subghz_setting_get_frequency_default_index(SubGhzSetting* instance);
 
 uint32_t subghz_setting_get_default_frequency(SubGhzSetting* instance);
-
-void subghz_setting_set_default_frequency(SubGhzSetting* instance, uint32_t frequency_to_setup);

applications/main/subghz/views/transmitter.c

@@ -45,7 +45,7 @@ void subghz_view_transmitter_add_data_to_show(
 }
 
 static void subghz_view_transmitter_button_right(Canvas* canvas, const char* str) {
-    const uint8_t button_height = 13;
+    const uint8_t button_height = 12;
     const uint8_t vertical_offset = 3;
     const uint8_t horizontal_offset = 1;
     const uint8_t string_width = canvas_string_width(canvas, str);
@@ -69,7 +69,10 @@ static void subghz_view_transmitter_button_right(Canvas* canvas, const char* str
 
     canvas_invert_color(canvas);
     canvas_draw_icon(
-        canvas, x + horizontal_offset, y - button_height + vertical_offset, &I_ButtonCenter_7x7);
+        canvas,
+        x + horizontal_offset,
+        y - button_height + vertical_offset - 1,
+        &I_ButtonCenter_7x7);
     canvas_draw_str(
         canvas, x + horizontal_offset + icon_width_with_offset, y - vertical_offset, str);
     canvas_invert_color(canvas);

applications/main/unirfremix/unirfremix_app.c

@@ -790,7 +790,7 @@ static void render_callback(Canvas* canvas, void* ctx) {
             break;
         case 1:
             canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
-            canvas_draw_icon(canvas, 116, 17, &I_Pin_arrow_up7x9);
+            canvas_draw_icon(canvas, 116, 17, &I_Pin_arrow_up_7x9);
             break;
         case 2:
             canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
@@ -845,6 +845,8 @@ void unirfremix_subghz_alloc(UniRFRemix* app) {
 UniRFRemix* unirfremix_alloc(void) {
     UniRFRemix* app = malloc(sizeof(UniRFRemix));
 
+    furi_hal_power_suppress_charge_enter();
+
     app->model_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
 
     app->input_queue = furi_message_queue_alloc(32, sizeof(InputEvent));
@@ -862,7 +864,9 @@ UniRFRemix* unirfremix_alloc(void) {
     return app;
 }
 
-void unirfremix_free(UniRFRemix* app) {
+void unirfremix_free(UniRFRemix* app, bool with_subghz) {
+    furi_hal_power_suppress_charge_exit();
+
     string_clear(app->up_file);
     string_clear(app->down_file);
     string_clear(app->left_file);
@@ -882,17 +886,21 @@ void unirfremix_free(UniRFRemix* app) {
     gui_remove_view_port(app->gui, app->view_port);
     furi_record_close(RECORD_GUI);
     view_port_free(app->view_port);
+    app->gui = NULL;
 
     furi_message_queue_free(app->input_queue);
 
     furi_mutex_free(app->model_mutex);
 
-    furi_hal_subghz_sleep();
-    subghz_setting_free(app->setting);
-    subghz_receiver_free(app->subghz_receiver);
-    subghz_environment_free(app->environment);
+    if(with_subghz) {
+        furi_hal_subghz_sleep();
+        subghz_setting_free(app->setting);
+        subghz_receiver_free(app->subghz_receiver);
+        subghz_environment_free(app->environment);
+    }
 
     furi_record_close(RECORD_NOTIFICATION);
+    app->notification = NULL;
 
     free(app);
 }
@@ -937,6 +945,8 @@ int32_t unirfremix_app(void* p) {
     furi_record_close(RECORD_DIALOGS);
     if(!res) {
         FURI_LOG_E(TAG, "No file selected");
+        unirfremix_free(app, false);
+        return 255;
     } else {
         //check map and population variables
         unirfremix_cfg_set_check(app, app->file_path);
@@ -968,8 +978,6 @@ int32_t unirfremix_app(void* p) {
         furi_mutex_release(app->model_mutex);
         view_port_update(app->view_port);
 
-        furi_hal_power_suppress_charge_enter();
-
         //input detect loop start
         InputEvent input;
         while(1) {
@@ -1162,9 +1170,7 @@ int32_t unirfremix_app(void* p) {
     }
 
     // remove & free all stuff created by app
-    unirfremix_free(app);
-
-    furi_hal_power_suppress_charge_exit();
+    unirfremix_free(app, true);
 
     return 0;
 }

applications/plugins/bt_hid_app/views/bt_hid_keyboard.c

@@ -109,7 +109,7 @@ const BtHidKeyboardKey bt_hid_keyboard_keyset[ROW_COUNT][COLUMN_COUNT] = {
         {.width = 1, .icon = NULL, .key = "-", .shift_key = "_", .value = HID_KEYBOARD_MINUS},
     },
     {
-        {.width = 1, .icon = &I_Pin_arrow_up7x9, .value = HID_KEYBOARD_L_SHIFT},
+        {.width = 1, .icon = &I_Pin_arrow_up_7x9, .value = HID_KEYBOARD_L_SHIFT},
         {.width = 1, .icon = NULL, .key = ",", .shift_key = "<", .value = HID_KEYPAD_COMMA},
         {.width = 1, .icon = NULL, .key = ".", .shift_key = ">", .value = HID_KEYBOARD_DOT},
         {.width = 4, .icon = NULL, .key = " ", .value = HID_KEYBOARD_SPACEBAR},

applications/plugins/bt_hid_app/views/bt_hid_mouse.c

@@ -53,7 +53,7 @@ static void bt_hid_mouse_draw_callback(Canvas* canvas, void* context) {
         canvas_set_bitmap_mode(canvas, 0);
         canvas_set_color(canvas, ColorWhite);
     }
-    canvas_draw_icon(canvas, 84, 10, &I_Pin_arrow_up7x9);
+    canvas_draw_icon(canvas, 84, 10, &I_Pin_arrow_up_7x9);
     canvas_set_color(canvas, ColorBlack);
 
     // Down

applications/plugins/flipfrid/README.md

@@ -1,21 +1,35 @@
 # Flipfrid
 
-Basic EM4100 Fuzzer
+Basic EM4100 and HIDProx Fuzzer.
 
 ## Why
 
 Flipfrid is a simple Rfid fuzzer using EM4100 protocol (125khz).
 Objective is to provide a simple to use fuzzer to test readers by emulating various cards.
 
-EM4100 cards use a 1 byte customer id and 4 bytes card id.
+- EM4100 cards use a 1 byte customer id and 4 bytes card id. 
+- HIDProx cards use a 2 byte customer id and 3 byte card id.
 
 ## How
 
-There is 4 modes :
-- Default key loop over 16 factory/default keys and emulate each one after one ;
-- BF customer id. just an iteration from 0X00 to 0XFF on the first byte ;
-- Load Dump file : Load an existing EM4100 dump generated by Flipperzero, select an index and bruteforce from 0X00 to 0XFF;
-- Uids list: loop over a text file (one uid per line)
+1) Select the Protocol with the left and right arrows
+2) Select the Mode with the up and down arrows
+
+### Info 
+
+There are 2 Protocols:
+- EM4100
+- HIDProx
+
+There are 4 modes:
+- Default Values: Try factory/default keys and emulate one after the other.
+- BF customer id: An iteration from 0X00 to 0XFF on the first byte.
+- Load Dump file: Load an existing dump (.rfid) generated by Flipperzero, select an index and bruteforce from 0X00 to 0XFF;
+- Uids list: Iterate over an input text file (one uid per line) and emulate one after the other.
+
+
+
 
 TODO : 
 - blank screen on back press 
+- Add second byte test to `BF customer id`

applications/plugins/flipfrid/flipfrid.c

@@ -64,6 +64,7 @@ FlipFridState* flipfrid_alloc() {
     flipfrid->is_attacking = false;
     flipfrid->key_index = 0;
     flipfrid->menu_index = 0;
+    flipfrid->menu_proto_index = 0;
 
     flipfrid->attack = FlipFridAttackDefaultValues;
     flipfrid->notify = furi_record_open(RECORD_NOTIFICATION);
@@ -73,12 +74,14 @@ FlipFridState* flipfrid_alloc() {
     flipfrid->data[2] = 0x00;
     flipfrid->data[3] = 0x00;
     flipfrid->data[4] = 0x00;
+    flipfrid->data[5] = 0x00;
 
     flipfrid->payload[0] = 0x00;
     flipfrid->payload[1] = 0x00;
     flipfrid->payload[2] = 0x00;
     flipfrid->payload[3] = 0x00;
     flipfrid->payload[4] = 0x00;
+    flipfrid->payload[5] = 0x00;
 
     //Dialog
     flipfrid->dialogs = furi_record_open(RECORD_DIALOGS);

applications/plugins/flipfrid/flipfrid.h

@@ -28,6 +28,11 @@ typedef enum {
     FlipFridAttackLoadFileCustomUids,
 } FlipFridAttacks;
 
+typedef enum {
+    EM4100,
+    HIDProx,
+} FlipFridProtos;
+
 typedef enum {
     NoneScene,
     SceneEntryPoint,
@@ -56,13 +61,16 @@ typedef struct {
     FlipFridScene previous_scene;
     NotificationApp* notify;
     u_int8_t menu_index;
+    u_int8_t menu_proto_index;
 
     string_t data_str;
-    uint8_t data[5];
-    uint8_t payload[5];
+    uint8_t data[6];
+    uint8_t payload[6];
     uint8_t attack_step;
     FlipFridAttacks attack;
+    FlipFridProtos proto;
     string_t attack_name;
+    string_t proto_name;
 
     DialogsApp* dialogs;
     string_t notification_msg;

applications/plugins/flipfrid/scene/flipfrid_scene_entrypoint.c

@@ -1,8 +1,12 @@
 #include "flipfrid_scene_entrypoint.h"
 
 string_t menu_items[4];
+string_t menu_proto_items[2];
 
-void flipfrid_scene_entrypoint_menu_callback(FlipFridState* context, uint32_t index) {
+void flipfrid_scene_entrypoint_menu_callback(
+    FlipFridState* context,
+    uint32_t index,
+    uint32_t proto_index) {
     switch(index) {
     case FlipFridAttackDefaultValues:
         context->attack = FlipFridAttackDefaultValues;
@@ -27,6 +31,19 @@ void flipfrid_scene_entrypoint_menu_callback(FlipFridState* context, uint32_t in
     default:
         break;
     }
+
+    switch(proto_index) {
+    case EM4100:
+        context->proto = EM4100;
+        string_set_str(context->proto_name, "EM4100");
+        break;
+    case HIDProx:
+        context->proto = HIDProx;
+        string_set_str(context->proto_name, "HIDProx");
+        break;
+    default:
+        break;
+    }
 }
 
 void flipfrid_scene_entrypoint_on_enter(FlipFridState* context) {
@@ -36,6 +53,7 @@ void flipfrid_scene_entrypoint_on_enter(FlipFridState* context) {
     context->payload[2] = 0x00;
     context->payload[3] = 0x00;
     context->payload[4] = 0x00;
+    context->payload[5] = 0x00;
 
     context->menu_index = 0;
     for(uint32_t i = 0; i < 4; i++) {
@@ -46,6 +64,14 @@ void flipfrid_scene_entrypoint_on_enter(FlipFridState* context) {
     string_set(menu_items[1], "BF Customer ID");
     string_set(menu_items[2], "Load File");
     string_set(menu_items[3], "Load uids from file");
+
+    context->menu_proto_index = 0;
+    for(uint32_t i = 0; i < 2; i++) {
+        string_init(menu_proto_items[i]);
+    }
+
+    string_set(menu_proto_items[0], "EM4100");
+    string_set(menu_proto_items[1], "HIDProx");
 }
 
 void flipfrid_scene_entrypoint_on_exit(FlipFridState* context) {
@@ -53,6 +79,10 @@ void flipfrid_scene_entrypoint_on_exit(FlipFridState* context) {
     for(uint32_t i = 0; i < 4; i++) {
         string_clear(menu_items[i]);
     }
+
+    for(uint32_t i = 0; i < 2; i++) {
+        string_clear(menu_proto_items[i]);
+    }
 }
 
 void flipfrid_scene_entrypoint_on_tick(FlipFridState* context) {
@@ -74,10 +104,18 @@ void flipfrid_scene_entrypoint_on_event(FlipFridEvent event, FlipFridState* cont
                 }
                 break;
             case InputKeyLeft:
+                if(context->menu_proto_index > EM4100) {
+                    context->menu_proto_index--;
+                }
+                break;
             case InputKeyRight:
+                if(context->menu_proto_index < HIDProx) {
+                    context->menu_proto_index++;
+                }
                 break;
             case InputKeyOk:
-                flipfrid_scene_entrypoint_menu_callback(context, context->menu_index);
+                flipfrid_scene_entrypoint_menu_callback(
+                    context, context->menu_index, context->menu_proto_index);
                 break;
             case InputKeyBack:
                 context->is_running = false;
@@ -91,10 +129,6 @@ void flipfrid_scene_entrypoint_on_draw(Canvas* canvas, FlipFridState* context) {
     canvas_clear(canvas);
     canvas_set_color(canvas, ColorBlack);
 
-    // Title
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 6, AlignCenter, AlignTop, "RFID Fuzzer");
-
     if(context->menu_index > FlipFridAttackDefaultValues) {
         canvas_set_font(canvas, FontSecondary);
         canvas_draw_str_aligned(
@@ -120,4 +154,41 @@ void flipfrid_scene_entrypoint_on_draw(Canvas* canvas, FlipFridState* context) {
             AlignTop,
             string_get_cstr(menu_items[context->menu_index + 1]));
     }
+
+    if(context->menu_proto_index > EM4100) {
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(
+            canvas,
+            64,
+            -12,
+            AlignCenter,
+            AlignTop,
+            string_get_cstr(menu_proto_items[context->menu_proto_index - 1]));
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str_aligned(canvas, 34, 4, AlignCenter, AlignTop, "<");
+
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str_aligned(
+        canvas,
+        64,
+        4,
+        AlignCenter,
+        AlignTop,
+        string_get_cstr(menu_proto_items[context->menu_proto_index]));
+
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str_aligned(canvas, 94, 4, AlignCenter, AlignTop, ">");
+
+    if(context->menu_proto_index < HIDProx) {
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(
+            canvas,
+            64,
+            -12,
+            AlignCenter,
+            AlignTop,
+            string_get_cstr(menu_proto_items[context->menu_proto_index + 1]));
+    }
 }

applications/plugins/flipfrid/scene/flipfrid_scene_load_file.c

@@ -36,11 +36,21 @@ bool flipfrid_load(FlipFridState* context, const char* file_path) {
             break;
         } else {
             FURI_LOG_I(TAG, "Key type: %s", string_get_cstr(temp_str));
-            if(strcmp(string_get_cstr(temp_str), "EM4100") != 0) {
-                FURI_LOG_E(TAG, "Unsupported Key type");
-                string_reset(context->notification_msg);
-                string_set_str(context->notification_msg, "Unsupported Key type");
-                break;
+
+            if(context->proto == EM4100) {
+                if(strcmp(string_get_cstr(temp_str), "EM4100") != 0) {
+                    FURI_LOG_E(TAG, "Unsupported Key type");
+                    string_reset(context->notification_msg);
+                    string_set_str(context->notification_msg, "Unsupported Key type");
+                    break;
+                }
+            } else {
+                if(strcmp(string_get_cstr(temp_str), "HIDProx") != 0) {
+                    FURI_LOG_E(TAG, "Unsupported Key type");
+                    string_reset(context->notification_msg);
+                    string_set_str(context->notification_msg, "Unsupported Key type");
+                    break;
+                }
             }
         }
 
@@ -53,15 +63,24 @@ bool flipfrid_load(FlipFridState* context, const char* file_path) {
         } else {
             FURI_LOG_I(TAG, "Key: %s", string_get_cstr(context->data_str));
 
-            // Check data size
-            if(string_size(context->data_str) != 14) {
-                FURI_LOG_E(TAG, "Incorrect Key length");
-                string_reset(context->notification_msg);
-                string_set_str(context->notification_msg, "Incorrect Key length");
-                break;
+            if(context->proto == EM4100) {
+                if(string_size(context->data_str) != 14) {
+                    FURI_LOG_E(TAG, "Incorrect Key length");
+                    string_reset(context->notification_msg);
+                    string_set_str(context->notification_msg, "Incorrect Key length");
+                    break;
+                }
+            } else {
+                if(string_size(context->data_str) != 17) {
+                    FURI_LOG_E(TAG, "Incorrect Key length");
+                    string_reset(context->notification_msg);
+                    string_set_str(context->notification_msg, "Incorrect Key length");
+                    break;
+                }
             }
+
             // String to uint8_t
-            for(uint8_t i = 0; i < 5; i++) {
+            for(uint8_t i = 0; i < 6; i++) {
                 char temp_str2[3];
                 temp_str2[0] = string_get_cstr(context->data_str)[i * 3];
                 temp_str2[1] = string_get_cstr(context->data_str)[i * 3 + 1];

applications/plugins/flipfrid/scene/flipfrid_scene_run_attack.c

@@ -2,8 +2,8 @@
 #include <gui/elements.h>
 
 uint8_t counter = 0;
-#define TIME_BETWEEN_CARDS 5
-uint8_t id_list[16][5] = {
+#define TIME_BETWEEN_CARDS 6
+uint8_t id_list[17][5] = {
     {0x00, 0x00, 0x00, 0x00, 0x00}, // Null bytes
     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, // Only FF
     {0x11, 0x11, 0x11, 0x11, 0x11}, // Only 11
@@ -16,17 +16,39 @@ uint8_t id_list[16][5] = {
     {0x88, 0x88, 0x88, 0x88, 0x88}, // Only 88
     {0x99, 0x99, 0x99, 0x99, 0x99}, // Only 99
     {0x12, 0x34, 0x56, 0x78, 0x9A}, // Incremental UID
+    {0x9A, 0x78, 0x56, 0x34, 0x12}, // Decremental UID
     {0x04, 0xd0, 0x9b, 0x0d, 0x6a}, // From arha
     {0x34, 0x00, 0x29, 0x3d, 0x9e}, // From arha
     {0x04, 0xdf, 0x00, 0x00, 0x01}, // From arha
     {0xCA, 0xCA, 0xCA, 0xCA, 0xCA}, // From arha
 };
 
+uint8_t id_list_hid[14][6] = {
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Null bytes
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, // Only FF
+    {0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, // Only 11
+    {0x22, 0x22, 0x22, 0x22, 0x22, 0x22}, // Only 22
+    {0x33, 0x33, 0x33, 0x33, 0x33, 0x33}, // Only 33
+    {0x44, 0x44, 0x44, 0x44, 0x44, 0x44}, // Only 44
+    {0x55, 0x55, 0x55, 0x55, 0x55, 0x55}, // Only 55
+    {0x66, 0x66, 0x66, 0x66, 0x66, 0x66}, // Only 66
+    {0x77, 0x77, 0x77, 0x77, 0x77, 0x77}, // Only 77
+    {0x88, 0x88, 0x88, 0x88, 0x88, 0x88}, // Only 88
+    {0x99, 0x99, 0x99, 0x99, 0x99, 0x99}, // Only 99
+    {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC}, // Incremental UID
+    {0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12}, // Decremental UID
+    {0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA}, // From arha
+};
+
 void flipfrid_scene_run_attack_on_enter(FlipFridState* context) {
     context->attack_step = 0;
     context->dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
     context->worker = lfrfid_worker_alloc(context->dict);
-    context->protocol = protocol_dict_get_protocol_by_name(context->dict, "EM4100");
+    if(context->proto == HIDProx) {
+        context->protocol = protocol_dict_get_protocol_by_name(context->dict, "HIDProx");
+    } else {
+        context->protocol = protocol_dict_get_protocol_by_name(context->dict, "EM4100");
+    }
 }
 
 void flipfrid_scene_run_attack_on_exit(FlipFridState* context) {
@@ -40,7 +62,7 @@ void flipfrid_scene_run_attack_on_exit(FlipFridState* context) {
 void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
     if(context->is_attacking) {
         if(1 == counter) {
-            protocol_dict_set_data(context->dict, context->protocol, context->payload, 5);
+            protocol_dict_set_data(context->dict, context->protocol, context->payload, 6);
             lfrfid_worker_free(context->worker);
             context->worker = lfrfid_worker_alloc(context->dict);
             lfrfid_worker_start_thread(context->worker);
@@ -50,87 +72,180 @@ void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
             lfrfid_worker_stop_thread(context->worker);
             switch(context->attack) {
             case FlipFridAttackDefaultValues:
-                context->payload[0] = id_list[context->attack_step][0];
-                context->payload[1] = id_list[context->attack_step][1];
-                context->payload[2] = id_list[context->attack_step][2];
-                context->payload[3] = id_list[context->attack_step][3];
-                context->payload[4] = id_list[context->attack_step][4];
+                if(context->proto == EM4100) {
+                    context->payload[0] = id_list[context->attack_step][0];
+                    context->payload[1] = id_list[context->attack_step][1];
+                    context->payload[2] = id_list[context->attack_step][2];
+                    context->payload[3] = id_list[context->attack_step][3];
+                    context->payload[4] = id_list[context->attack_step][4];
 
-                if(context->attack_step == 15) {
-                    context->attack_step = 0;
-                    counter = 0;
-                    context->is_attacking = false;
-                    notification_message(context->notify, &sequence_blink_stop);
-                    notification_message(context->notify, &sequence_single_vibro);
-
-                } else {
-                    context->attack_step++;
-                }
-                break;
-
-            case FlipFridAttackBfCustomerId:
-                context->payload[0] = context->attack_step;
-                context->payload[1] = 0x00;
-                context->payload[2] = 0x00;
-                context->payload[3] = 0x00;
-                context->payload[4] = 0x00;
-
-                if(context->attack_step == 255) {
-                    context->attack_step = 0;
-                    counter = 0;
-                    context->is_attacking = false;
-                    notification_message(context->notify, &sequence_blink_stop);
-                    notification_message(context->notify, &sequence_single_vibro);
-                } else {
-                    context->attack_step++;
-                }
-                break;
-            case FlipFridAttackLoadFile:
-                context->payload[0] = context->data[0];
-                context->payload[1] = context->data[1];
-                context->payload[2] = context->data[2];
-                context->payload[3] = context->data[3];
-                context->payload[4] = context->data[4];
-
-                context->payload[context->key_index] = context->attack_step;
-
-                if(context->attack_step == 255) {
-                    context->attack_step = 0;
-                    counter = 0;
-                    context->is_attacking = false;
-                    notification_message(context->notify, &sequence_blink_stop);
-                    notification_message(context->notify, &sequence_single_vibro);
+                    if(context->attack_step == 15) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                    } else {
+                        context->attack_step++;
+                    }
                     break;
                 } else {
-                    context->attack_step++;
+                    context->payload[0] = id_list_hid[context->attack_step][0];
+                    context->payload[1] = id_list_hid[context->attack_step][1];
+                    context->payload[2] = id_list_hid[context->attack_step][2];
+                    context->payload[3] = id_list_hid[context->attack_step][3];
+                    context->payload[4] = id_list_hid[context->attack_step][4];
+                    context->payload[5] = id_list_hid[context->attack_step][5];
+
+                    if(context->attack_step == 15) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
                 }
-                break;
-            case FlipFridAttackLoadFileCustomUids:
-                while(true) {
-                    string_reset(context->data_str);
-                    if(!stream_read_line(context->uids_stream, context->data_str)) {
+
+            case FlipFridAttackBfCustomerId:
+                if(context->proto == EM4100) {
+                    context->payload[0] = context->attack_step;
+                    context->payload[1] = 0x00;
+                    context->payload[2] = 0x00;
+                    context->payload[3] = 0x00;
+                    context->payload[4] = 0x00;
+
+                    if(context->attack_step == 255) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else {
+                    context->payload[0] = context->attack_step;
+                    context->payload[1] = 0x00;
+                    context->payload[2] = 0x00;
+                    context->payload[3] = 0x00;
+                    context->payload[4] = 0x00;
+                    context->payload[5] = 0x00;
+
+                    if(context->attack_step == 255) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                }
+
+            case FlipFridAttackLoadFile:
+                if(context->proto == EM4100) {
+                    context->payload[0] = context->data[0];
+                    context->payload[1] = context->data[1];
+                    context->payload[2] = context->data[2];
+                    context->payload[3] = context->data[3];
+                    context->payload[4] = context->data[4];
+
+                    context->payload[context->key_index] = context->attack_step;
+
+                    if(context->attack_step == 255) {
                         context->attack_step = 0;
                         counter = 0;
                         context->is_attacking = false;
                         notification_message(context->notify, &sequence_blink_stop);
                         notification_message(context->notify, &sequence_single_vibro);
                         break;
-                    };
-                    if(string_get_char(context->data_str, 0) == '#') continue;
-                    if(string_size(context->data_str) != 11) continue;
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else {
+                    context->payload[0] = context->data[0];
+                    context->payload[1] = context->data[1];
+                    context->payload[2] = context->data[2];
+                    context->payload[3] = context->data[3];
+                    context->payload[4] = context->data[4];
+                    context->payload[5] = context->data[5];
+
+                    context->payload[context->key_index] = context->attack_step;
+
+                    if(context->attack_step == 255) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                        break;
+                    } else {
+                        context->attack_step++;
+                    }
                     break;
                 }
-                FURI_LOG_D(TAG, string_get_cstr(context->data_str));
 
-                // string is valid, parse it in context->payload
-                for(uint8_t i = 0; i < 5; i++) {
-                    char temp_str[3];
-                    temp_str[0] = string_get_cstr(context->data_str)[i * 2];
-                    temp_str[1] = string_get_cstr(context->data_str)[i * 2 + 1];
-                    temp_str[2] = '\0';
-                    context->payload[i] = (uint8_t)strtol(temp_str, NULL, 16);
+            case FlipFridAttackLoadFileCustomUids:
+                if(context->proto == EM4100) {
+                    while(true) {
+                        string_reset(context->data_str);
+                        if(!stream_read_line(context->uids_stream, context->data_str)) {
+                            context->attack_step = 0;
+                            counter = 0;
+                            context->is_attacking = false;
+                            notification_message(context->notify, &sequence_blink_stop);
+                            notification_message(context->notify, &sequence_single_vibro);
+                            break;
+                        };
+                        if(string_get_char(context->data_str, 0) == '#') continue;
+                        if(string_size(context->data_str) != 11) continue;
+                        break;
+                    }
+                    FURI_LOG_D(TAG, string_get_cstr(context->data_str));
+
+                    // string is valid, parse it in context->payload
+                    for(uint8_t i = 0; i < 5; i++) {
+                        char temp_str[3];
+                        temp_str[0] = string_get_cstr(context->data_str)[i * 2];
+                        temp_str[1] = string_get_cstr(context->data_str)[i * 2 + 1];
+                        temp_str[2] = '\0';
+                        context->payload[i] = (uint8_t)strtol(temp_str, NULL, 16);
+                    }
+                    break;
+                } else {
+                    while(true) {
+                        string_reset(context->data_str);
+                        if(!stream_read_line(context->uids_stream, context->data_str)) {
+                            context->attack_step = 0;
+                            counter = 0;
+                            context->is_attacking = false;
+                            notification_message(context->notify, &sequence_blink_stop);
+                            notification_message(context->notify, &sequence_single_vibro);
+                            break;
+                        };
+                        if(string_get_char(context->data_str, 0) == '#') continue;
+                        if(string_size(context->data_str) != 13) continue;
+                        break;
+                    }
+                    FURI_LOG_D(TAG, string_get_cstr(context->data_str));
+
+                    // string is valid, parse it in context->payload
+                    for(uint8_t i = 0; i < 6; i++) {
+                        char temp_str[3];
+                        temp_str[0] = string_get_cstr(context->data_str)[i * 2];
+                        temp_str[1] = string_get_cstr(context->data_str)[i * 2 + 1];
+                        temp_str[2] = '\0';
+                        context->payload[i] = (uint8_t)strtol(temp_str, NULL, 16);
+                    }
+                    break;
                 }
-                break;
             }
         }
 
@@ -190,16 +305,30 @@ void flipfrid_scene_run_attack_on_draw(Canvas* canvas, FlipFridState* context) {
     canvas_draw_str_aligned(
         canvas, 64, 8, AlignCenter, AlignTop, string_get_cstr(context->attack_name));
 
-    char uid[16];
-    snprintf(
-        uid,
-        sizeof(uid),
-        "%02X:%02X:%02X:%02X:%02X",
-        context->payload[0],
-        context->payload[1],
-        context->payload[2],
-        context->payload[3],
-        context->payload[4]);
+    char uid[18];
+    if(context->proto == HIDProx) {
+        snprintf(
+            uid,
+            sizeof(uid),
+            "%02X:%02X:%02X:%02X:%02X:%02X",
+            context->payload[0],
+            context->payload[1],
+            context->payload[2],
+            context->payload[3],
+            context->payload[4],
+            context->payload[5]);
+    } else {
+        snprintf(
+            uid,
+            sizeof(uid),
+            "%02X:%02X:%02X:%02X:%02X",
+            context->payload[0],
+            context->payload[1],
+            context->payload[2],
+            context->payload[3],
+            context->payload[4]);
+    }
+
     canvas_draw_str_aligned(canvas, 64, 24, AlignCenter, AlignTop, uid);
 
     canvas_set_font(canvas, FontSecondary);

applications/plugins/mousejacker/mousejacker.c

@@ -47,7 +47,8 @@ static void render_callback(Canvas* const canvas, void* ctx) {
     canvas_draw_frame(canvas, 0, 0, 128, 64);
 
     canvas_set_font(canvas, FontSecondary);
-    if(!plugin_state->addr_err && !plugin_state->ducky_err && !plugin_state->is_thread_running) {
+    if(!plugin_state->addr_err && !plugin_state->ducky_err && !plugin_state->is_thread_running &&
+       !plugin_state->is_ducky_running) {
         snprintf(target_text, sizeof(target_text), target_fmt_text, target_address_str);
         canvas_draw_str_aligned(canvas, 7, 10, AlignLeft, AlignBottom, target_text);
         canvas_draw_str_aligned(canvas, 22, 20, AlignLeft, AlignBottom, "<- select address ->");
@@ -66,7 +67,10 @@ static void render_callback(Canvas* const canvas, void* ctx) {
             canvas, 3, 10, AlignLeft, AlignBottom, "Error: No mousejacker folder");
         canvas_draw_str_aligned(canvas, 3, 20, AlignLeft, AlignBottom, "or duckyscript file");
         canvas_draw_str_aligned(canvas, 3, 30, AlignLeft, AlignBottom, "loading error");
-    } else if(plugin_state->is_thread_running) {
+    } else if(plugin_state->is_thread_running && !plugin_state->is_ducky_running) {
+        canvas_draw_str_aligned(canvas, 3, 10, AlignLeft, AlignBottom, "Loading...");
+        canvas_draw_str_aligned(canvas, 3, 20, AlignLeft, AlignBottom, "Please wait!");
+    } else if(plugin_state->is_thread_running && plugin_state->is_ducky_running) {
         canvas_draw_str_aligned(canvas, 3, 10, AlignLeft, AlignBottom, "Running duckyscript");
         canvas_draw_str_aligned(canvas, 3, 20, AlignLeft, AlignBottom, "Please wait!");
         canvas_draw_str_aligned(
@@ -97,7 +101,7 @@ static void hexlify(uint8_t* in, uint8_t size, char* out) {
         snprintf(out + strlen(out), sizeof(out + strlen(out)), "%02X", in[i]);
 }
 
-static bool open_ducky_script(Stream* stream) {
+static bool open_ducky_script(Stream* stream, PluginState* plugin_state) {
     DialogsApp* dialogs = furi_record_open("dialogs");
     bool result = false;
     string_t path;
@@ -120,6 +124,9 @@ static bool open_ducky_script(Stream* stream) {
         }
     }
     string_clear(path);
+
+    plugin_state->is_ducky_running = true;
+
     return result;
 }
 
@@ -160,10 +167,11 @@ static bool process_ducky_file(
     uint8_t* file_buf;
     bool loaded = false;
     FURI_LOG_D(TAG, "opening ducky script");
-    if(open_ducky_script(file_stream)) {
+    if(open_ducky_script(file_stream, plugin_state)) {
         file_size = stream_size(file_stream);
         if(file_size == (size_t)0) {
             FURI_LOG_D(TAG, "load failed. file_size: %d", file_size);
+            plugin_state->is_ducky_running = false;
             return loaded;
         }
         file_buf = malloc(file_size);
@@ -180,6 +188,7 @@ static bool process_ducky_file(
         }
         free(file_buf);
     }
+    plugin_state->is_ducky_running = false;
     return loaded;
 }
 

applications/plugins/mousejacker/mousejacker_ducky.h

@@ -24,6 +24,7 @@ typedef struct {
     bool ducky_err;
     bool addr_err;
     bool is_thread_running;
+    bool is_ducky_running;
     bool close_thread_please;
     Storage* storage;
     FuriThread* mjthread;

applications/plugins/picopass/application.fam

@@ -1,7 +1,7 @@
 App(
     appid="picopass",
     name="PicoPass Reader",
-    apptype=FlipperAppType.PLUGIN,
+    apptype=FlipperAppType.EXTERNAL,
     entry_point="picopass_app",
     requires=[
         "storage",

applications/plugins/picopass/picopass_device.c

@@ -309,10 +309,6 @@ ReturnCode picopass_device_decrypt(uint8_t* enc_data, uint8_t* dec_data) {
 ReturnCode picopass_device_parse_credential(PicopassBlock* AA1, PicopassPacs* pacs) {
     ReturnCode err;
 
-    // Thank you proxmark!
-    pacs->legacy = (memcmp(AA1[5].data, "\xff\xff\xff\xff\xff\xff\xff\xff", 8) == 0);
-    pacs->se_enabled = (memcmp(AA1[5].data, "\xff\xff\xff\x00\x06\xff\xff\xff", 8) == 0);
-
     pacs->biometrics = AA1[6].data[4];
     pacs->pin_length = AA1[6].data[6] & 0x0F;
     pacs->encryption = AA1[6].data[7];
@@ -347,6 +343,8 @@ ReturnCode picopass_device_parse_credential(PicopassBlock* AA1, PicopassPacs* pa
         FURI_LOG_D(TAG, "Unknown encryption");
     }
 
+    pacs->sio = (AA1[10].data[0] == 0x30); // rough check
+
     return ERR_NONE;
 }
 

applications/plugins/picopass/picopass_device.h

@@ -47,6 +47,7 @@ typedef struct {
 typedef struct {
     bool legacy;
     bool se_enabled;
+    bool sio;
     bool biometrics;
     uint8_t pin_length;
     PicopassEncryption encryption;

applications/plugins/picopass/picopass_worker.c

@@ -112,18 +112,12 @@ ReturnCode picopass_detect_card(int timeout) {
     return ERR_NONE;
 }
 
-ReturnCode picopass_read_card(PicopassBlock* AA1) {
+ReturnCode picopass_read_preauth(PicopassBlock* AA1) {
     rfalPicoPassIdentifyRes idRes;
     rfalPicoPassSelectRes selRes;
-    rfalPicoPassReadCheckRes rcRes;
-    rfalPicoPassCheckRes chkRes;
 
     ReturnCode err;
 
-    uint8_t div_key[8] = {0};
-    uint8_t mac[4] = {0};
-    uint8_t ccnr[12] = {0};
-
     err = rfalPicoPassPollerIdentify(&idRes);
     if(err != ERR_NONE) {
         FURI_LOG_E(TAG, "rfalPicoPassPollerIdentify error %d", err);
@@ -136,6 +130,62 @@ ReturnCode picopass_read_card(PicopassBlock* AA1) {
         return err;
     }
 
+    memcpy(AA1[PICOPASS_CSN_BLOCK_INDEX].data, selRes.CSN, sizeof(selRes.CSN));
+    FURI_LOG_D(
+        TAG,
+        "csn %02x%02x%02x%02x%02x%02x%02x%02x",
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[0],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[1],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[2],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[3],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[4],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[5],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[6],
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data[7]);
+
+    rfalPicoPassReadBlockRes cfg = {0};
+    err = rfalPicoPassPollerReadBlock(PICOPASS_CONFIG_BLOCK_INDEX, &cfg);
+    memcpy(AA1[PICOPASS_CONFIG_BLOCK_INDEX].data, cfg.data, sizeof(cfg.data));
+    FURI_LOG_D(
+        TAG,
+        "config %02x%02x%02x%02x%02x%02x%02x%02x",
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[1],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[2],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[3],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[4],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[5],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[6],
+        AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[7]);
+
+    rfalPicoPassReadBlockRes aia;
+    err = rfalPicoPassPollerReadBlock(PICOPASS_AIA_BLOCK_INDEX, &aia);
+    memcpy(AA1[PICOPASS_AIA_BLOCK_INDEX].data, aia.data, sizeof(aia.data));
+    FURI_LOG_D(
+        TAG,
+        "aia %02x%02x%02x%02x%02x%02x%02x%02x",
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[0],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[1],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[2],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[3],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[4],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[5],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[6],
+        AA1[PICOPASS_AIA_BLOCK_INDEX].data[7]);
+
+    return ERR_NONE;
+}
+
+ReturnCode picopass_read_card(PicopassBlock* AA1) {
+    rfalPicoPassReadCheckRes rcRes;
+    rfalPicoPassCheckRes chkRes;
+
+    ReturnCode err;
+
+    uint8_t div_key[8] = {0};
+    uint8_t mac[4] = {0};
+    uint8_t ccnr[12] = {0};
+
     err = rfalPicoPassPollerReadCheck(&rcRes);
     if(err != ERR_NONE) {
         FURI_LOG_E(TAG, "rfalPicoPassPollerReadCheck error %d", err);
@@ -143,7 +193,7 @@ ReturnCode picopass_read_card(PicopassBlock* AA1) {
     }
     memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
 
-    loclass_diversifyKey(selRes.CSN, picopass_iclass_key, div_key);
+    loclass_diversifyKey(AA1[PICOPASS_CSN_BLOCK_INDEX].data, picopass_iclass_key, div_key);
     loclass_opt_doReaderMAC(ccnr, div_key, mac);
 
     err = rfalPicoPassPollerCheck(mac, &chkRes);
@@ -152,18 +202,11 @@ ReturnCode picopass_read_card(PicopassBlock* AA1) {
         return err;
     }
 
-    rfalPicoPassReadBlockRes csn;
-    err = rfalPicoPassPollerReadBlock(PICOPASS_CSN_BLOCK_INDEX, &csn);
-    memcpy(AA1[PICOPASS_CSN_BLOCK_INDEX].data, csn.data, sizeof(csn.data));
-
-    rfalPicoPassReadBlockRes cfg;
-    err = rfalPicoPassPollerReadBlock(PICOPASS_CONFIG_BLOCK_INDEX, &cfg);
-    memcpy(AA1[PICOPASS_CONFIG_BLOCK_INDEX].data, cfg.data, sizeof(cfg.data));
-
-    size_t app_limit = cfg.data[0] < PICOPASS_MAX_APP_LIMIT ? cfg.data[0] : PICOPASS_MAX_APP_LIMIT;
+    size_t app_limit = AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0] < PICOPASS_MAX_APP_LIMIT ?
+                           AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0] :
+                           PICOPASS_MAX_APP_LIMIT;
 
     for(size_t i = 2; i < app_limit; i++) {
-        FURI_LOG_D(TAG, "rfalPicoPassPollerReadBlock block %d", i);
         rfalPicoPassReadBlockRes block;
         err = rfalPicoPassPollerReadBlock(i, &block);
         if(err != ERR_NONE) {
@@ -287,11 +330,30 @@ void picopass_worker_detect(PicopassWorker* picopass_worker) {
     PicopassPacs* pacs = &dev_data->pacs;
     ReturnCode err;
 
+    // reset device data
+    for(size_t i = 0; i < PICOPASS_MAX_APP_LIMIT; i++) {
+        memset(AA1[i].data, 0, sizeof(AA1[i].data));
+    }
+    memset(pacs, 0, sizeof(PicopassPacs));
+
     PicopassWorkerEvent nextState = PicopassWorkerEventSuccess;
 
     while(picopass_worker->state == PicopassWorkerStateDetect) {
         if(picopass_detect_card(1000) == ERR_NONE) {
             // Process first found device
+            err = picopass_read_preauth(AA1);
+            if(err != ERR_NONE) {
+                FURI_LOG_E(TAG, "picopass_read_preauth error %d", err);
+                nextState = PicopassWorkerEventFail;
+            }
+
+            // Thank you proxmark!
+            pacs->legacy = (memcmp(AA1[5].data, "\xff\xff\xff\xff\xff\xff\xff\xff", 8) == 0);
+            pacs->se_enabled = (memcmp(AA1[5].data, "\xff\xff\xff\x00\x06\xff\xff\xff", 8) == 0);
+            if(pacs->se_enabled) {
+                FURI_LOG_D(TAG, "SE enabled");
+            }
+
             err = picopass_read_card(AA1);
             if(err != ERR_NONE) {
                 FURI_LOG_E(TAG, "picopass_read_card error %d", err);

applications/plugins/picopass/picopass_worker.h

@@ -24,6 +24,7 @@ typedef enum {
     PicopassWorkerEventSuccess,
     PicopassWorkerEventFail,
     PicopassWorkerEventNoCardDetected,
+    PicopassWorkerEventSeEnabled,
 
     PicopassWorkerEventStartReading,
 } PicopassWorkerEvent;

applications/plugins/picopass/scenes/picopass_scene_read_card_success.c

@@ -17,8 +17,10 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     Picopass* picopass = context;
     string_t credential_str;
     string_t wiegand_str;
+    string_t sio_str;
     string_init(credential_str);
     string_init(wiegand_str);
+    string_init(sio_str);
 
     DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
 
@@ -32,6 +34,10 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     if(pacs->record.bitLength == 0) {
         string_cat_printf(wiegand_str, "Read Failed");
 
+        if(pacs->se_enabled) {
+            string_cat_printf(credential_str, "SE enabled");
+        }
+
         widget_add_button_element(
             widget,
             GuiButtonTypeLeft,
@@ -39,8 +45,6 @@ void picopass_scene_read_card_success_on_enter(void* context) {
             picopass_scene_read_card_success_widget_callback,
             picopass);
 
-        widget_add_string_element(
-            widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
     } else {
         size_t bytesLength = 1 + pacs->record.bitLength / 8;
         string_set_str(credential_str, "");
@@ -55,6 +59,10 @@ void picopass_scene_read_card_success_on_enter(void* context) {
             string_cat_printf(wiegand_str, "%d bits", pacs->record.bitLength);
         }
 
+        if(pacs->sio) {
+            string_cat_printf(sio_str, "+SIO");
+        }
+
         widget_add_button_element(
             widget,
             GuiButtonTypeLeft,
@@ -68,20 +76,18 @@ void picopass_scene_read_card_success_on_enter(void* context) {
             "More",
             picopass_scene_read_card_success_widget_callback,
             picopass);
-
-        widget_add_string_element(
-            widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
-        widget_add_string_element(
-            widget,
-            64,
-            32,
-            AlignCenter,
-            AlignCenter,
-            FontSecondary,
-            string_get_cstr(credential_str));
     }
+
+    widget_add_string_element(
+        widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
+    widget_add_string_element(
+        widget, 64, 32, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(credential_str));
+    widget_add_string_element(
+        widget, 64, 42, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(sio_str));
+
     string_clear(credential_str);
     string_clear(wiegand_str);
+    string_clear(sio_str);
 
     view_dispatcher_switch_to_view(picopass->view_dispatcher, PicopassViewWidget);
 }

applications/plugins/spectrum_analyzer/application.fam

@@ -1,11 +1,12 @@
 App(
     appid="spectrum_analyzer",
     name="Spectrum Analyzer",
-    apptype=FlipperAppType.APP,
+    apptype=FlipperAppType.EXTERNAL,
     entry_point="spectrum_analyzer_app",
     cdefines=["APP_SPECTRUM_ANALYZER"],
     requires=["gui"],
-    icon="A_SpectrumAnalyzer_14",
     stack_size=2 * 1024,
     order=12,
+    fap_icon="spectrum_10px.png",
+    fap_category="Tools",
 )

applications/plugins/subbrute/application.fam

@@ -2,7 +2,7 @@ App(
     appid="subbrute",
     name="Sub-GHz Bruteforcer",
     apptype=FlipperAppType.EXTERNAL,
-    entry_point="subbrute_start",
+    entry_point="subbrute_app",
     cdefines=["APP_SUB_BRUTE"],
     requires=["gui","dialogs"],
     stack_size=2 * 1024,

applications/plugins/subbrute/helpers/subbrute_worker.c

@@ -0,0 +1,370 @@
+#include "subbrute_worker.h"
+
+#include <subghz/environment.h>
+#include <subghz/transmitter.h>
+#include <flipper_format_i.h>
+
+#define TAG "SubBruteWorker"
+
+struct SubBruteWorker {
+    FuriThread* thread;
+    volatile bool worker_running;
+    volatile bool worker_manual_mode;
+    bool is_manual_init;
+
+    SubGhzEnvironment* environment;
+    SubGhzTransmitter* transmitter;
+    FlipperFormat* flipper_format;
+
+    uint32_t last_time_tx_data;
+
+    // Preset and frequency needed
+    FuriHalSubGhzPreset preset;
+    uint32_t frequency;
+    string_t protocol_name;
+
+    //SubBruteWorkerCallback callback;
+    //void* context;
+};
+
+/** Taken from subghz_tx_rx_worker.c */
+#define SUBBRUTE_TXRX_WORKER_BUF_SIZE 2048
+#define SUBBRUTE_TXRX_WORKER_MAX_TXRX_SIZE 60
+#define SUBBRUTE_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF 40
+#define SUBBRUTE_TX_TIMEOUT 50
+#define SUBBRUTE_SEND_DELAY 260
+
+/**
+ * Entrypoint for worker
+ *
+ * @param context SubBruteWorker*
+ * @return 0 if ok
+ */
+int32_t subbrute_worker_thread(void* context) {
+    furi_assert(context);
+    SubBruteWorker* instance = (SubBruteWorker*)context;
+
+    if(!instance->worker_running) {
+        FURI_LOG_W(TAG, "Worker is not set to running state!");
+        return -1;
+    }
+#ifdef FURI_DEBUG
+    FURI_LOG_I(TAG, "Worker start");
+#endif
+
+    instance->environment = subghz_environment_alloc();
+    instance->transmitter = subghz_transmitter_alloc_init(
+        instance->environment, string_get_cstr(instance->protocol_name));
+
+    furi_hal_subghz_reset();
+    furi_hal_subghz_load_preset(instance->preset);
+    instance->frequency = furi_hal_subghz_set_frequency_and_path(instance->frequency);
+
+    furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
+    furi_hal_gpio_write(&gpio_cc1101_g0, true);
+
+    // Set ready to transmit value
+    instance->last_time_tx_data = furi_get_tick() - SUBBRUTE_SEND_DELAY;
+
+    while(instance->worker_running) {
+        // Transmit
+        if(!furi_hal_subghz_tx()) {
+            FURI_LOG_E(TAG, "Cannot transmit!");
+            break;
+        }
+        furi_delay_ms(SUBBRUTE_TX_TIMEOUT);
+    }
+
+    furi_hal_subghz_set_path(FuriHalSubGhzPathIsolate);
+    furi_hal_subghz_sleep();
+
+    subghz_transmitter_free(instance->transmitter);
+    instance->transmitter = NULL;
+    subghz_environment_free(instance->environment);
+    instance->environment = NULL;
+
+#ifdef FURI_DEBUG
+    FURI_LOG_I(TAG, "Worker stop");
+#endif
+    return 0;
+}
+
+SubBruteWorker* subbrute_worker_alloc() {
+    SubBruteWorker* instance = malloc(sizeof(SubBruteWorker));
+
+    instance->thread = furi_thread_alloc();
+    furi_thread_set_name(instance->thread, "SubBruteAttackWorker");
+    furi_thread_set_stack_size(instance->thread, 2048);
+    furi_thread_set_context(instance->thread, instance);
+    furi_thread_set_callback(instance->thread, subbrute_worker_thread);
+
+    //instance->status = SubBruteWorkerStatusIDLE;
+    instance->worker_running = false;
+    instance->worker_manual_mode = false;
+
+    instance->flipper_format = flipper_format_string_alloc();
+    string_init(instance->protocol_name);
+
+    return instance;
+}
+
+void subbrute_worker_free(SubBruteWorker* instance) {
+    furi_assert(instance);
+    furi_assert(!instance->worker_running);
+
+    if(instance->transmitter != NULL) {
+        subghz_transmitter_free(instance->transmitter);
+        instance->transmitter = NULL;
+    }
+
+    if(instance->environment != NULL) {
+        subghz_environment_free(instance->environment);
+        instance->environment = NULL;
+    }
+
+    furi_thread_free(instance->thread);
+    flipper_format_free(instance->flipper_format);
+
+    string_clear(instance->protocol_name);
+
+    free(instance);
+}
+
+bool subbrute_worker_start(
+    SubBruteWorker* instance,
+    uint32_t frequency,
+    FuriHalSubGhzPreset preset,
+    const char* protocol_name) {
+    furi_assert(instance);
+
+    if(instance->worker_manual_mode) {
+        return false;
+    }
+
+    instance->frequency = frequency;
+    instance->preset = preset;
+
+    string_clear(instance->protocol_name);
+    string_init_printf(instance->protocol_name, "%s", protocol_name);
+
+    bool res = false;
+
+    furi_hal_subghz_reset();
+    furi_hal_subghz_idle();
+    furi_hal_subghz_load_preset(instance->preset);
+
+    furi_hal_subghz_set_frequency_and_path(instance->frequency);
+    furi_hal_subghz_flush_rx();
+
+    if(furi_hal_subghz_is_tx_allowed(frequency)) {
+        instance->frequency = frequency;
+        res = true;
+    }
+    instance->worker_running = res;
+
+#ifdef FURI_DEBUG
+    FURI_LOG_I(TAG, "Frequency: %d", frequency);
+#endif
+    instance->preset = preset;
+
+    furi_thread_start(instance->thread);
+
+    return res;
+}
+
+void subbrute_worker_stop(SubBruteWorker* instance) {
+    furi_assert(instance);
+
+    instance->worker_running = false;
+
+    furi_thread_join(instance->thread);
+
+    furi_hal_subghz_set_path(FuriHalSubGhzPathIsolate);
+    furi_hal_subghz_sleep();
+}
+
+bool subbrute_worker_is_running(SubBruteWorker* instance) {
+    furi_assert(instance);
+
+    return instance->worker_running;
+}
+
+bool subbrute_worker_can_transmit(SubBruteWorker* instance) {
+    furi_assert(instance);
+
+    return (furi_get_tick() - instance->last_time_tx_data) > SUBBRUTE_SEND_DELAY;
+}
+
+bool subbrute_worker_transmit(SubBruteWorker* instance, const char* payload) {
+    furi_assert(instance);
+    furi_assert(instance->worker_running);
+
+    if(!subbrute_worker_can_transmit(instance)) {
+        FURI_LOG_E(TAG, "Too early to transmit");
+
+        return false;
+    }
+    instance->last_time_tx_data = furi_get_tick();
+
+#ifdef FURI_DEBUG
+    //FURI_LOG_D(TAG, "payload: %s", payload);
+#endif
+
+    Stream* stream = flipper_format_get_raw_stream(instance->flipper_format);
+    stream_clean(stream);
+    stream_write_cstring(stream, payload);
+    subghz_transmitter_deserialize(instance->transmitter, instance->flipper_format);
+
+    return true;
+}
+
+bool subbrute_worker_init_manual_transmit(
+    SubBruteWorker* instance,
+    uint32_t frequency,
+    FuriHalSubGhzPreset preset,
+    const char* protocol_name) {
+#ifdef FURI_DEBUG
+    FURI_LOG_D(
+        TAG,
+        "subbrute_worker_init_manual_transmit. frequency: %d, protocol: %s",
+        frequency,
+        protocol_name);
+#endif
+    if(instance->worker_manual_mode || !subbrute_worker_can_transmit(instance)) {
+#ifdef FURI_DEBUG
+        FURI_LOG_D(TAG, "cannot transmit");
+#endif
+        return false;
+    }
+    if(instance->worker_running) {
+#ifdef FURI_DEBUG
+        FURI_LOG_D(TAG, "subbrute_worker_stop");
+#endif
+        subbrute_worker_stop(instance);
+    }
+
+    // Not transmit at this period
+    instance->worker_manual_mode = true;
+
+    if(instance->is_manual_init) {
+        FURI_LOG_E(TAG, "Trying to setup without normally shutdown prev transmit session!");
+        subbrute_worker_manual_transmit_stop(instance);
+    }
+
+    instance->preset = preset;
+    instance->frequency = frequency;
+
+    string_clear(instance->protocol_name);
+    string_init_printf(instance->protocol_name, "%s", protocol_name);
+
+    furi_hal_subghz_reset();
+    furi_hal_subghz_idle();
+    furi_hal_subghz_load_preset(instance->preset);
+
+    furi_hal_subghz_set_frequency_and_path(instance->frequency);
+    furi_hal_subghz_flush_rx();
+
+    if(!furi_hal_subghz_is_tx_allowed(frequency)) {
+        FURI_LOG_E(TAG, "Frequency: %d invalid!", frequency);
+
+        instance->frequency = frequency;
+        instance->worker_manual_mode = false;
+        return false;
+    }
+
+#ifdef FURI_DEBUG
+    FURI_LOG_I(TAG, "Frequency: %d", frequency);
+#endif
+
+    instance->environment = subghz_environment_alloc();
+    instance->transmitter = subghz_transmitter_alloc_init(
+        instance->environment, string_get_cstr(instance->protocol_name));
+
+    furi_hal_subghz_reset();
+    furi_hal_subghz_load_preset(instance->preset);
+    instance->frequency = furi_hal_subghz_set_frequency_and_path(frequency);
+
+    furi_hal_subghz_set_path(FuriHalSubGhzPathIsolate);
+    furi_hal_subghz_sleep();
+    subghz_transmitter_free(instance->transmitter);
+    instance->transmitter = NULL;
+
+    instance->worker_manual_mode = false;
+    instance->is_manual_init = true;
+
+    return true;
+}
+
+void subbrute_worker_manual_transmit_stop(SubBruteWorker* instance) {
+#ifdef FURI_DEBUG
+    FURI_LOG_D(TAG, "subbrute_worker_manual_transmit_stop");
+#endif
+    if(!instance->is_manual_init) {
+        return;
+    }
+
+    furi_hal_subghz_idle();
+    furi_hal_subghz_sleep();
+
+    if(instance->transmitter != NULL) {
+        subghz_transmitter_free(instance->transmitter);
+        instance->transmitter = NULL;
+    }
+    subghz_environment_free(instance->environment);
+    instance->environment = NULL;
+
+    instance->is_manual_init = false;
+}
+
+bool subbrute_worker_manual_transmit(SubBruteWorker* instance, const char* payload) {
+    furi_assert(instance);
+
+    if(instance->worker_manual_mode || !subbrute_worker_can_transmit(instance)) {
+#ifdef FURI_DEBUG
+        FURI_LOG_D(TAG, "cannot transmit");
+#endif
+        return false;
+    }
+    if(instance->worker_running) {
+#ifdef FURI_DEBUG
+        FURI_LOG_D(TAG, "subbrute_worker_stop");
+#endif
+        subbrute_worker_stop(instance);
+    }
+    if(!instance->is_manual_init) {
+        FURI_LOG_E(TAG, "Manually transmit doesn't set!");
+        return false;
+    }
+
+    instance->last_time_tx_data = furi_get_tick();
+    instance->worker_manual_mode = true;
+
+    Stream* stream = flipper_format_get_raw_stream(instance->flipper_format);
+    stream_clean(stream);
+    stream_write_cstring(stream, payload);
+
+    instance->transmitter = subghz_transmitter_alloc_init(
+        instance->environment, string_get_cstr(instance->protocol_name));
+    subghz_transmitter_deserialize(instance->transmitter, instance->flipper_format);
+    furi_hal_subghz_reset();
+    furi_hal_subghz_load_preset(instance->preset);
+    instance->frequency = furi_hal_subghz_set_frequency_and_path(instance->frequency);
+
+    furi_hal_subghz_start_async_tx(subghz_transmitter_yield, instance->transmitter);
+
+    while(!furi_hal_subghz_is_async_tx_complete()) {
+        furi_delay_ms(SUBBRUTE_TX_TIMEOUT);
+    }
+    furi_hal_subghz_stop_async_tx();
+
+    furi_hal_subghz_set_path(FuriHalSubGhzPathIsolate);
+    furi_hal_subghz_sleep();
+    subghz_transmitter_free(instance->transmitter);
+    instance->transmitter = NULL;
+
+    stream_clean(stream);
+
+    instance->worker_manual_mode = false;
+
+    return true;
+}

applications/plugins/subbrute/helpers/subbrute_worker.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <furi_hal_subghz.h>
+
+typedef struct SubBruteWorker SubBruteWorker;
+/**
+ * Same like SubGhzTxRxWorkerStatus in subghz_tx_rx_worker.h
+ * using just to not include that file
+
+typedef enum {
+    SubBruteWorkerStatusIDLE,
+    SubBruteWorkerStatusTx,
+    // SubBruteWorkerStatusRx,
+} SubBruteWorkerStatus;
+
+//typedef void (*SubBruteWorkerCallback)(SubBruteWorkerStatus event, void* context);
+*/
+SubBruteWorker* subbrute_worker_alloc();
+void subbrute_worker_free(SubBruteWorker* instance);
+bool subbrute_worker_start(
+    SubBruteWorker* instance,
+    uint32_t frequency,
+    FuriHalSubGhzPreset preset,
+    const char* protocol_name);
+void subbrute_worker_stop(SubBruteWorker* instance);
+//bool subbrute_worker_write(SubBruteWorker* instance, uint8_t* data, size_t size);
+bool subbrute_worker_is_running(SubBruteWorker* instance);
+bool subbrute_worker_can_transmit(SubBruteWorker* instance);
+bool subbrute_worker_transmit(SubBruteWorker* instance, const char* payload);
+bool subbrute_worker_init_manual_transmit(SubBruteWorker* instance,
+                                          uint32_t frequency,
+                                          FuriHalSubGhzPreset preset,
+                                          const char* protocol_name);
+bool subbrute_worker_manual_transmit(SubBruteWorker* instance, const char* payload);
+void subbrute_worker_manual_transmit_stop(SubBruteWorker* instance);

applications/plugins/subbrute/scene/subbrute_scene_entrypoint.c

@@ -1,197 +0,0 @@
-#include "subbrute_scene_entrypoint.h"
-#include "../subbrute_utils.h"
-
-string_t subbrute_menu_items[10];
-
-void subbrute_scene_entrypoint_menu_callback(SubBruteState* context, uint32_t index) {
-    string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-    string_set_str(context->protocol, "RAW");
-    context->repeat = 5;
-    context->te = 0;
-    context->attack = index;
-    switch(index) {
-    case SubBruteAttackLoadFile:
-        context->current_scene = SceneSelectFile;
-        break;
-    case SubBruteAttackCAME12bit307:
-    case SubBruteAttackCAME12bit433:
-    case SubBruteAttackCAME12bit868:
-        if(index == SubBruteAttackCAME12bit307) {
-            context->frequency = 307800000;
-        } else if(index == SubBruteAttackCAME12bit433) {
-            context->frequency = 433920000;
-        } else if(index == SubBruteAttackCAME12bit868) {
-            context->frequency = 868350000;
-        }
-        context->bit = 12;
-        string_set_str(context->protocol, "CAME");
-        string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-        if(!subbrute_is_frequency_allowed(context)) {
-            return;
-        }
-        context->current_scene = SceneAttack;
-        break;
-    case SubBruteAttackChamberlain9bit315:
-        context->frequency = 315000000;
-        context->bit = 9;
-        string_set_str(context->protocol, "Cham_Code");
-        string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-
-        if(!subbrute_is_frequency_allowed(context)) {
-            return;
-        }
-        context->current_scene = SceneAttack;
-        break;
-    case SubBruteAttackChamberlain9bit390:
-        context->frequency = 390000000;
-        context->bit = 9;
-        string_set_str(context->protocol, "Cham_Code");
-        string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-
-        if(!subbrute_is_frequency_allowed(context)) {
-            return;
-        }
-        context->current_scene = SceneAttack;
-        break;
-    case SubBruteAttackLinear10bit300:
-        context->frequency = 300000000;
-        context->bit = 10;
-        string_set_str(context->protocol, "Linear");
-        string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-        if(!subbrute_is_frequency_allowed(context)) {
-            return;
-        }
-        context->current_scene = SceneAttack;
-        break;
-    case SubBruteAttackLinear10bit310:
-        context->frequency = 310000000;
-        context->bit = 10;
-        string_set_str(context->protocol, "Linear");
-        string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-        if(!subbrute_is_frequency_allowed(context)) {
-            return;
-        }
-        context->current_scene = SceneAttack;
-        break;
-    case SubBruteAttackNICE12bit433:
-        context->frequency = 433920000;
-        context->bit = 12;
-        string_set_str(context->protocol, "Nice FLO");
-        string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-        if(!subbrute_is_frequency_allowed(context)) {
-            return;
-        }
-        context->current_scene = SceneAttack;
-        break;
-    case SubBruteAttackNICE12bit868:
-        context->frequency = 868350000;
-        context->bit = 12;
-        string_set_str(context->protocol, "Nice FLO");
-        string_set_str(context->preset, "FuriHalSubGhzPresetOok650Async");
-        if(!subbrute_is_frequency_allowed(context)) {
-            return;
-        }
-        context->current_scene = SceneAttack;
-        break;
-    default:
-        break;
-    }
-}
-
-void subbrute_scene_entrypoint_on_enter(SubBruteState* context) {
-    // Clear the previous payload
-    context->menu_index = 0;
-    for(uint32_t i = 0; i < 10; i++) {
-        string_init(subbrute_menu_items[i]);
-    }
-
-    string_set(subbrute_menu_items[0], "BF existing dump");
-    string_set(subbrute_menu_items[1], "CAME 12bit 307mhz");
-    string_set(subbrute_menu_items[2], "CAME 12bit 433mhz");
-    string_set(subbrute_menu_items[3], "CAME 12bit 868mhz");
-    string_set(subbrute_menu_items[4], "Chamberlain 9bit 315mhz");
-    string_set(subbrute_menu_items[5], "Chamberlain 9bit 390mhz");
-    string_set(subbrute_menu_items[6], "Linear 10bit 300mhz");
-    string_set(subbrute_menu_items[7], "Linear 10bit 310mhz");
-    string_set(subbrute_menu_items[8], "NICE 12bit 433mhz");
-    string_set(subbrute_menu_items[9], "NICE 12bit 868mhz");
-}
-
-void subbrute_scene_entrypoint_on_exit(SubBruteState* context) {
-    UNUSED(context);
-    for(uint32_t i = 0; i < 10; i++) {
-        string_clear(subbrute_menu_items[i]);
-    }
-}
-
-void subbrute_scene_entrypoint_on_tick(SubBruteState* context) {
-    UNUSED(context);
-}
-
-void subbrute_scene_entrypoint_on_event(SubBruteEvent event, SubBruteState* context) {
-    if(event.evt_type == EventTypeKey) {
-        if(event.input_type == InputTypeShort) {
-            switch(event.key) {
-            case InputKeyDown:
-                if(context->menu_index < SubBruteAttackNICE12bit868) {
-                    context->menu_index++;
-                }
-                break;
-            case InputKeyUp:
-                if(context->menu_index > SubBruteAttackLoadFile) {
-                    context->menu_index--;
-                }
-                break;
-            case InputKeyLeft:
-            case InputKeyRight:
-                break;
-            case InputKeyOk:
-                subbrute_scene_entrypoint_menu_callback(context, context->menu_index);
-                break;
-            case InputKeyBack:
-                context->is_running = false;
-                break;
-            }
-        }
-    }
-}
-
-void subbrute_scene_entrypoint_on_draw(Canvas* canvas, SubBruteState* context) {
-    canvas_clear(canvas);
-    canvas_set_color(canvas, ColorBlack);
-
-    // Title
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 6, AlignCenter, AlignTop, "Sub-GHz Bruteforcer");
-
-    if(context->menu_index > SubBruteAttackLoadFile) {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(
-            canvas,
-            64,
-            24,
-            AlignCenter,
-            AlignTop,
-            string_get_cstr(subbrute_menu_items[context->menu_index - 1]));
-    }
-
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(
-        canvas,
-        64,
-        36,
-        AlignCenter,
-        AlignTop,
-        string_get_cstr(subbrute_menu_items[context->menu_index]));
-
-    if(context->menu_index < SubBruteAttackNICE12bit868) {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(
-            canvas,
-            64,
-            48,
-            AlignCenter,
-            AlignTop,
-            string_get_cstr(subbrute_menu_items[context->menu_index + 1]));
-    }
-}

applications/plugins/subbrute/scene/subbrute_scene_entrypoint.h

@@ -1,8 +0,0 @@
-#pragma once
-#include "../subbrute.h"
-
-void subbrute_scene_entrypoint_on_enter(SubBruteState* context);
-void subbrute_scene_entrypoint_on_exit(SubBruteState* context);
-void subbrute_scene_entrypoint_on_tick(SubBruteState* context);
-void subbrute_scene_entrypoint_on_event(SubBruteEvent event, SubBruteState* context);
-void subbrute_scene_entrypoint_on_draw(Canvas* canvas, SubBruteState* context);

applications/plugins/subbrute/scene/subbrute_scene_load_file.c

@@ -1,222 +0,0 @@
-#include "subbrute_scene_load_file.h"
-#include "subbrute_scene_entrypoint.h"
-#include "../subbrute_utils.h"
-#include <lib/subghz/protocols/registry.h>
-
-#define SUBGHZ_APP_PATH_FOLDER "/ext/subghz"
-
-bool subbrute_load(SubBruteState* context, const char* file_path) {
-    bool result = false;
-
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
-
-    string_t temp_str;
-    string_init(temp_str);
-    uint32_t temp_data32;
-
-    do {
-        if(!flipper_format_file_open_existing(fff_data_file, file_path)) {
-            FURI_LOG_E(TAG, "Error open file %s", file_path);
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Error open file");
-            break;
-        }
-        if(!flipper_format_read_header(fff_data_file, temp_str, &temp_data32)) {
-            FURI_LOG_E(TAG, "Missing or incorrect header");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing or incorrect header");
-            break;
-        }
-        // Frequency
-        if(flipper_format_read_uint32(fff_data_file, "Frequency", &temp_data32, 1)) {
-            FURI_LOG_I(TAG, "Frequency: %d", temp_data32);
-            context->frequency = temp_data32;
-            if(!subbrute_is_frequency_allowed(context)) {
-                break;
-            }
-        } else {
-            FURI_LOG_E(TAG, "Missing or incorrect Frequency");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing or incorrect Frequency");
-            break;
-        }
-        // Preset
-        if(!flipper_format_read_string(fff_data_file, "Preset", context->preset)) {
-            FURI_LOG_E(TAG, "Preset FAIL");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Preset FAIL");
-        }
-        // Protocol
-        if(!flipper_format_read_string(fff_data_file, "Protocol", context->protocol)) {
-            FURI_LOG_E(TAG, "Missing Protocol");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing Protocol");
-            break;
-        } else {
-            FURI_LOG_I(TAG, "Protocol: %s", string_get_cstr(context->protocol));
-        }
-
-        if(strcmp(string_get_cstr(context->protocol), "RAW") == 0) {
-            FURI_LOG_E(TAG, "RAW unsupported");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "RAW unsupported");
-            break;
-        }
-
-        const SubGhzProtocol* registry =
-            subghz_protocol_registry_get_by_name(string_get_cstr(context->protocol));
-
-        if(registry && registry->type == SubGhzProtocolTypeDynamic) {
-            FURI_LOG_D(TAG, "Protocol is dynamic - not supported");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Dynamic protocol unsupported");
-            break;
-        }
-
-        context->decoder_result = subghz_receiver_search_decoder_base_by_name(
-            context->receiver, string_get_cstr(context->protocol));
-
-        if(context->decoder_result) {
-            FURI_LOG_I(TAG, "Found decoder");
-        } else {
-            FURI_LOG_E(TAG, "Protocol not found");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Protocol not found");
-            break;
-        }
-
-        // Bit
-        if(!flipper_format_read_uint32(fff_data_file, "Bit", &temp_data32, 1)) {
-            FURI_LOG_E(TAG, "Missing or incorrect Bit");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing or incorrect Bit");
-            break;
-        } else {
-            FURI_LOG_I(TAG, "Bit: %d", temp_data32);
-            context->bit = temp_data32;
-        }
-
-        // Key
-        if(!flipper_format_read_string(fff_data_file, "Key", temp_str)) {
-            FURI_LOG_E(TAG, "Missing or incorrect Key");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing or incorrect Key");
-            break;
-        } else {
-            FURI_LOG_I(TAG, "Key: %s", string_get_cstr(temp_str));
-            string_set(context->key, string_get_cstr(temp_str));
-        }
-
-        // TE
-        if(!flipper_format_read_uint32(fff_data_file, "TE", &temp_data32, 1)) {
-            FURI_LOG_E(TAG, "Missing or incorrect TE");
-            //string_reset(context->notification_msg);
-            //string_set_str(context->notification_msg, "Missing or incorrect TE");
-            //break;
-        } else {
-            FURI_LOG_I(TAG, "TE: %d", temp_data32);
-            context->te = temp_data32;
-        }
-
-        // Repeat
-        if(flipper_format_read_uint32(fff_data_file, "Repeat", &temp_data32, 1)) {
-            FURI_LOG_I(TAG, "Repeat: %d", temp_data32);
-            context->repeat = temp_data32;
-        } else {
-            FURI_LOG_I(TAG, "Repeat: 3 (default)");
-            context->repeat = 3;
-        }
-
-        result = true;
-    } while(0);
-
-    string_clear(temp_str);
-    flipper_format_file_close(fff_data_file);
-    flipper_format_free(fff_data_file);
-    furi_record_close(RECORD_STORAGE);
-    if(result) {
-        FURI_LOG_I(TAG, "Loaded successfully");
-        string_reset(context->notification_msg);
-        string_set_str(context->notification_msg, "File looks ok.");
-    }
-
-    return result;
-}
-
-void subbrute_scene_load_file_on_enter(SubBruteState* context) {
-    if(subbrute_load_protocol_from_file(context)) {
-        context->current_scene = SceneSelectField;
-    } else {
-        subbrute_scene_entrypoint_on_enter(context);
-        context->current_scene = SceneEntryPoint;
-    }
-}
-
-void subbrute_scene_load_file_on_exit(SubBruteState* context) {
-    UNUSED(context);
-}
-
-void subbrute_scene_load_file_on_tick(SubBruteState* context) {
-    UNUSED(context);
-}
-
-void subbrute_scene_load_file_on_event(SubBruteEvent event, SubBruteState* context) {
-    UNUSED(context);
-    if(event.evt_type == EventTypeKey) {
-        if(event.input_type == InputTypeShort) {
-            switch(event.key) {
-            case InputKeyDown:
-            case InputKeyUp:
-            case InputKeyLeft:
-            case InputKeyRight:
-            case InputKeyOk:
-                break;
-            case InputKeyBack:
-                context->current_scene = SceneEntryPoint;
-                break;
-            }
-        }
-    }
-}
-
-void subbrute_scene_load_file_on_draw(Canvas* canvas, SubBruteState* context) {
-    UNUSED(context);
-    canvas_clear(canvas);
-    canvas_set_color(canvas, ColorBlack);
-
-    // Frame
-    //canvas_draw_frame(canvas, 0, 0, 128, 64);
-
-    // Title
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 16, AlignCenter, AlignTop, "SubGHz Fuzzer");
-    canvas_draw_str_aligned(canvas, 64, 32, AlignCenter, AlignTop, "Error: Press back");
-}
-
-bool subbrute_load_protocol_from_file(SubBruteState* context) {
-    string_t file_path;
-    string_init(file_path);
-    string_set_str(file_path, SUBGHZ_APP_PATH_FOLDER);
-    context->environment = subghz_environment_alloc();
-    context->receiver = subghz_receiver_alloc_init(context->environment);
-    subghz_receiver_set_filter(context->receiver, SubGhzProtocolFlag_Decodable);
-
-    // Input events and views are managed by file_select
-
-    DialogsFileBrowserOptions browser_options;
-    dialog_file_browser_set_basic_options(&browser_options, SUBGHZ_APP_EXTENSION, &I_sub1_10px);
-
-    bool res = dialog_file_browser_show(context->dialogs, file_path, file_path, &browser_options);
-
-    if(res) {
-        res = subbrute_load(context, string_get_cstr(file_path));
-    }
-
-    subghz_environment_free(context->environment);
-    subghz_receiver_free(context->receiver);
-
-    string_clear(file_path);
-
-    return res;
-}

applications/plugins/subbrute/scene/subbrute_scene_load_file.h

@@ -1,8 +0,0 @@
-#include "../subbrute.h"
-
-void subbrute_scene_load_file_on_enter(SubBruteState* context);
-void subbrute_scene_load_file_on_exit(SubBruteState* context);
-void subbrute_scene_load_file_on_tick(SubBruteState* context);
-void subbrute_scene_load_file_on_event(SubBruteEvent event, SubBruteState* context);
-void subbrute_scene_load_file_on_draw(Canvas* canvas, SubBruteState* context);
-bool subbrute_load_protocol_from_file(SubBruteState* context);

applications/plugins/subbrute/scene/subbrute_scene_run_attack.c

@@ -1,384 +0,0 @@
-#include "subbrute_scene_run_attack.h"
-#include <lib/subghz/transmitter.h>
-#include <gui/elements.h>
-
-//uint64_t subbrute_counter = 0;
-uint64_t max_value;
-bool locked = false;
-bool toSave = false;
-char subbrute_payload_byte[4];
-#define SUBBRUTE_DELAY 1
-
-FuriHalSubGhzPreset str_to_preset(string_t preset) {
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetOok270Async") == 0) {
-        return FuriHalSubGhzPresetOok270Async;
-    }
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetOok650Async") == 0) {
-        return FuriHalSubGhzPresetOok650Async;
-    }
-    if(string_cmp_str(preset, "FuriHalSubGhzPreset2FSKDev238Async") == 0) {
-        return FuriHalSubGhzPreset2FSKDev238Async;
-    }
-    if(string_cmp_str(preset, "FuriHalSubGhzPreset2FSKDev476Async") == 0) {
-        return FuriHalSubGhzPreset2FSKDev476Async;
-    }
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetMSK99_97KbAsync") == 0) {
-        return FuriHalSubGhzPresetMSK99_97KbAsync;
-    }
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetMSK99_97KbAsync") == 0) {
-        return FuriHalSubGhzPresetMSK99_97KbAsync;
-    }
-    return FuriHalSubGhzPresetCustom;
-}
-
-void subbrute_emit(SubBruteState* context) {
-    //FURI_LOG_D(TAG, string_get_cstr(context->flipper_format_string));
-
-    context->transmitter =
-        subghz_transmitter_alloc_init(context->environment, string_get_cstr(context->protocol));
-
-    subghz_transmitter_deserialize(context->transmitter, context->flipper_format);
-    furi_hal_subghz_reset();
-    furi_hal_subghz_load_preset(str_to_preset(context->preset));
-
-    context->frequency_cal = furi_hal_subghz_set_frequency_and_path(context->frequency);
-
-    furi_hal_subghz_start_async_tx(subghz_transmitter_yield, context->transmitter);
-    while(!(furi_hal_subghz_is_async_tx_complete())) {
-        furi_delay_ms(1);
-    }
-
-    furi_hal_subghz_stop_async_tx();
-    subghz_transmitter_stop(context->transmitter);
-    furi_hal_subghz_idle();
-    subghz_transmitter_free(context->transmitter);
-}
-
-void prepare_emit(SubBruteState* context) {
-    UNUSED(context);
-
-    furi_hal_subghz_init();
-}
-
-void clear_emit(SubBruteState* context) {
-    UNUSED(context);
-
-    //furi_hal_subghz_stop_async_tx();
-    //furi_hal_subghz_idle();
-    furi_hal_subghz_sleep();
-}
-/*
-void subbrute_send_raw_packet(SubBruteState* context) {
-    string_reset(context->candidate);
-
-    // Payload to padded binary string
-    int* binaryNum = (int*)malloc(sizeof(int) * context->bit);
-    uint32_t i = 0;
-    for(i = 0; i < context->bit; i++) {
-        binaryNum[i] = 0;
-    }
-    i = 0;
-    uint64_t counter = context->payload;
-    while(counter > 0) {
-        binaryNum[i] = counter % 2;
-        counter = counter / 2;
-        i++;
-    }
-
-    // printing binary array in reverse order and build raw payload
-    for(uint32_t loop = 0; loop < context->repeat; loop++) {
-        for(int j = (int)context->bit - 1; j >= 0; j--) {
-            if(binaryNum[j] == 1) {
-                string_cat(context->candidate, context->subbrute_raw_one);
-            } else {
-                string_cat(context->candidate, context->subbrute_raw_zero);
-            }
-        }
-        string_cat(context->candidate, context->subbrute_raw_stop);
-    }
-
-    free(binaryNum);
-
-    string_init_printf(
-        context->flipper_format_string,
-        "Filetype: Flipper SubGhz RAW File\n"
-        "Version: 1\n"
-        "Frequency: %d\n"
-        "Preset: %s\n"
-        "Protocol: RAW\n"
-        "RAW_Data: %s",
-        context->frequency,
-        string_get_cstr(context->preset),
-        string_get_cstr(context->candidate));
-
-    subbrute_emit(context);
-}
-*/
-void subbrute_send_packet_parsed(SubBruteState* context) {
-    if(context->attack == SubBruteAttackLoadFile) {
-        snprintf(subbrute_payload_byte, 4, "%02X ", (uint8_t)context->payload);
-        string_replace_at(context->candidate, context->str_index, 3, subbrute_payload_byte);
-    } else {
-        string_t buffer;
-        string_init(buffer);
-        string_init_printf(buffer, "%16X", context->payload);
-        int j = 0;
-        string_set_str(context->candidate, "                       ");
-        for(uint8_t i = 0; i < 16; i++) {
-            if(string_get_char(buffer, i) != ' ') {
-                string_set_char(context->candidate, i + j, string_get_char(buffer, i));
-            } else {
-                string_set_char(context->candidate, i + j, '0');
-            }
-            if(i % 2 != 0) {
-                j++;
-            }
-        }
-        string_clear(buffer);
-    }
-    if(strcmp(string_get_cstr(context->protocol), "Princeton") == 0) {
-        string_init_printf(
-            context->flipper_format_string,
-            "Filetype: Flipper SubGhz Key File\n"
-            "Version: 1\n"
-            "Frequency: %u\n"
-            "Preset: %s\n"
-            "Protocol: %s\n"
-            "Bit: %d\n"
-            "Key: %s\n"
-            "TE: %d\n",
-            context->frequency,
-            string_get_cstr(context->preset),
-            string_get_cstr(context->protocol),
-            context->bit,
-            string_get_cstr(context->candidate),
-            context->te);
-    } else {
-        string_init_printf(
-            context->flipper_format_string,
-            "Filetype: Flipper SubGhz Key File\n"
-            "Version: 1\n"
-            "Frequency: %u\n"
-            "Preset: %s\n"
-            "Protocol: %s\n"
-            "Bit: %d\n"
-            "Key: %s\n",
-            context->frequency,
-            string_get_cstr(context->preset),
-            string_get_cstr(context->protocol),
-            context->bit,
-            string_get_cstr(context->candidate));
-    }
-
-    stream_clean(context->stream);
-    stream_write_string(context->stream, context->flipper_format_string);
-}
-
-void subbrute_send_packet(SubBruteState* context) {
-    ///if(string_cmp_str(context->protocol, "RAW") == 0) {
-    //   subbrute_send_raw_packet(context);
-    //} else {
-    subbrute_send_packet_parsed(context);
-    subbrute_emit(context);
-    //}
-    string_clear(context->flipper_format_string);
-}
-
-void subbrute_scene_run_attack_on_exit(SubBruteState* context) {
-    if(!toSave) {
-        clear_emit(context);
-        furi_thread_free(context->bruthread);
-        flipper_format_free(context->flipper_format);
-        subghz_receiver_free(context->receiver);
-        subghz_environment_free(context->environment);
-    }
-}
-
-void subbrute_scene_run_attack_on_tick(SubBruteState* context) {
-    if(!context->is_attacking || locked) {
-        return;
-    }
-    //if(0 != subbrute_counter) {
-    locked = true;
-    subbrute_send_packet(context);
-
-    if(context->payload == max_value) {
-        //context->payload = 0x00;
-        //subbrute_counter = 0;
-        context->is_attacking = false;
-        notification_message(context->notify, &sequence_blink_stop);
-        notification_message(context->notify, &sequence_single_vibro);
-    } else {
-        context->payload++;
-    }
-    locked = false;
-    //}
-    /*if(subbrute_counter > SUBBRUTE_DELAY) {
-        subbrute_counter = 0;
-    } else {
-        subbrute_counter++;
-    }*/
-}
-void subbrute_run_timer(SubBruteState* context) {
-    while(true) {
-        if(!context->is_attacking) {
-            context->is_thread_running = false;
-            break;
-        }
-        //furi_delay_ms(10);
-        subbrute_scene_run_attack_on_tick(context);
-    }
-}
-
-// entrypoint for worker
-static int32_t subbrute_worker_thread(void* ctx) {
-    SubBruteState* app = ctx;
-    subbrute_run_timer(app);
-    return 0;
-}
-
-void start_bruthread(SubBruteState* app) {
-    if(!app->is_thread_running) {
-        furi_thread_start(app->bruthread);
-        app->is_thread_running = true;
-    }
-}
-
-void subbrute_scene_run_attack_on_enter(SubBruteState* context) {
-    if(!toSave) {
-        if(context->attack == SubBruteAttackLoadFile) {
-            max_value = 0xFF;
-        } else {
-            string_t max_value_s;
-            string_init(max_value_s);
-            for(uint8_t i = 0; i < context->bit; i++) {
-                string_cat_printf(max_value_s, "1");
-            }
-            max_value = (uint64_t)strtol(string_get_cstr(max_value_s), NULL, 2);
-            string_clear(max_value_s);
-        }
-        context->str_index = (context->key_index * 3);
-        string_init_set(context->candidate, context->key);
-        context->flipper_format = flipper_format_string_alloc();
-        context->stream = flipper_format_get_raw_stream(context->flipper_format);
-        context->environment = subghz_environment_alloc();
-        context->receiver = subghz_receiver_alloc_init(context->environment);
-        subghz_receiver_set_filter(context->receiver, SubGhzProtocolFlag_Decodable);
-
-        prepare_emit(context);
-        context->bruthread = furi_thread_alloc();
-        furi_thread_set_name(context->bruthread, "SubBrute Worker");
-        furi_thread_set_stack_size(context->bruthread, 2048);
-        furi_thread_set_context(context->bruthread, context);
-        furi_thread_set_callback(context->bruthread, subbrute_worker_thread);
-    } else {
-        toSave = false;
-    }
-}
-
-void subbrute_scene_run_attack_on_event(SubBruteEvent event, SubBruteState* context) {
-    if(event.evt_type == EventTypeKey) {
-        if(event.input_type == InputTypeShort) {
-            switch(event.key) {
-            case InputKeyDown:
-                break;
-            case InputKeyUp:
-                if(!context->is_attacking) {
-                    subbrute_send_packet_parsed(context);
-                    string_clear(context->flipper_format_string);
-                    toSave = true;
-                    context->current_scene = SceneSaveName;
-                }
-                break;
-            case InputKeyLeft:
-                if(!context->is_attacking && context->payload > 0x00) {
-                    context->payload--;
-                    subbrute_send_packet(context);
-                    notification_message(context->notify, &sequence_blink_blue_10);
-                } else if(!context->is_attacking && context->payload == 0x00) {
-                    context->payload = max_value;
-                    subbrute_send_packet(context);
-                    notification_message(context->notify, &sequence_blink_blue_10);
-                }
-                break;
-            case InputKeyRight:
-                if(!context->is_attacking && context->payload < max_value) {
-                    context->payload++;
-                    subbrute_send_packet(context);
-                    notification_message(context->notify, &sequence_blink_blue_10);
-                } else if(!context->is_attacking && context->payload == max_value) {
-                    context->payload = 0x00;
-                    subbrute_send_packet(context);
-                    notification_message(context->notify, &sequence_blink_blue_10);
-                }
-                break;
-            case InputKeyOk:
-                if(!context->is_attacking) {
-                    if(context->payload == max_value) {
-                        context->payload = 0x00;
-                        //subbrute_counter = 0;
-                    }
-                    context->is_attacking = true;
-                    start_bruthread(context);
-                    notification_message(context->notify, &sequence_blink_start_blue);
-                } else {
-                    context->is_attacking = false;
-                    //context->close_thread_please = true;
-                    if(context->is_thread_running && context->bruthread) {
-                        furi_thread_join(context->bruthread); // wait until thread is finished
-                    }
-                    //context->close_thread_please = false;
-                    notification_message(context->notify, &sequence_blink_stop);
-                    notification_message(context->notify, &sequence_single_vibro);
-                }
-                break;
-            case InputKeyBack:
-                locked = false;
-                //context->close_thread_please = true;
-                context->is_attacking = false;
-                if(context->is_thread_running && context->bruthread) {
-                    furi_thread_join(context->bruthread); // wait until thread is finished
-                }
-                //context->close_thread_please = false;
-                string_reset(context->notification_msg);
-                context->payload = 0x00;
-                //subbrute_counter = 0;
-                notification_message(context->notify, &sequence_blink_stop);
-                if(context->attack == SubBruteAttackLoadFile) {
-                    context->current_scene = SceneSelectField;
-                } else {
-                    context->current_scene = SceneEntryPoint;
-                }
-                break;
-            }
-        }
-    }
-}
-
-void subbrute_scene_run_attack_on_draw(Canvas* canvas, SubBruteState* context) {
-    canvas_clear(canvas);
-    canvas_set_color(canvas, ColorBlack);
-
-    // Frame
-    //canvas_draw_frame(canvas, 0, 0, 128, 64);
-
-    // Title
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 8, AlignCenter, AlignTop, "Fire in the hole!");
-
-    char msg_index[26];
-    snprintf(
-        msg_index, sizeof(msg_index), "< %04d / %04d >", (int)context->payload, (int)max_value);
-
-    canvas_draw_str_aligned(canvas, 64, 24, AlignCenter, AlignTop, msg_index);
-
-    canvas_set_font(canvas, FontSecondary);
-    char start_stop_msg[20];
-    snprintf(start_stop_msg, sizeof(start_stop_msg), " Press (^) to save ");
-    if(context->is_attacking) {
-        elements_button_center(canvas, "Stop");
-    } else {
-        elements_button_center(canvas, "Start");
-    }
-    canvas_draw_str_aligned(canvas, 64, 39, AlignCenter, AlignTop, start_stop_msg);
-}

applications/plugins/subbrute/scene/subbrute_scene_run_attack.h

@@ -1,8 +0,0 @@
-#include "../subbrute.h"
-
-void subbrute_scene_run_attack_on_enter(SubBruteState* context);
-void subbrute_scene_run_attack_on_exit(SubBruteState* context);
-void subbrute_scene_run_attack_on_tick(SubBruteState* context);
-void subbrute_scene_run_attack_on_event(SubBruteEvent event, SubBruteState* context);
-void subbrute_scene_run_attack_on_draw(Canvas* canvas, SubBruteState* context);
-void send_packet();

applications/plugins/subbrute/scene/subbrute_scene_save_name.c

@@ -1,222 +0,0 @@
-#include "../subbrute.h"
-#include "m-string.h"
-#include "subghz/types.h"
-#include <lib/toolbox/random_name.h>
-#include <gui/modules/validators.h>
-#include <lib/toolbox/path.h>
-
-#define MAX_TEXT_INPUT_LEN 22
-
-bool backpressed = false;
-
-bool subbrute_path_is_file(string_t path) {
-    return string_end_with_str_p(path, ".sub");
-}
-// method modified from subghz_i.c
-// https://github.com/flipperdevices/flipperzero-firmware/blob/b0daa601ad5b87427a45f9089c8b403a01f72c2a/applications/subghz/subghz_i.c#L417-L456
-bool subbrute_save_protocol_to_file(Stream* flipper_format_stream, const char* dev_file_name) {
-    furi_assert(dev_file_name);
-
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-
-    bool saved = false;
-    string_t file_dir;
-    string_init(file_dir);
-
-    path_extract_dirname(dev_file_name, file_dir);
-    do {
-        if(!storage_simply_mkdir(storage, string_get_cstr(file_dir))) {
-            FURI_LOG_E(TAG, "(save) Cannot mkdir");
-            break;
-        }
-
-        if(!storage_simply_remove(storage, dev_file_name)) {
-            FURI_LOG_E(TAG, "(save) Cannot remove");
-            break;
-        }
-
-        stream_seek(flipper_format_stream, 0, StreamOffsetFromStart);
-        stream_save_to_file(flipper_format_stream, storage, dev_file_name, FSOM_CREATE_ALWAYS);
-
-        saved = true;
-        FURI_LOG_D(TAG, "(save) OK Save");
-    } while(0);
-    string_clear(file_dir);
-    furi_record_close(RECORD_STORAGE);
-    return saved;
-}
-
-void custom_callback(SubBruteState* context) {
-    if(strcmp(context->file_name_tmp, "")) {
-        string_cat_printf(context->file_path, "/%s%s", context->file_name_tmp, ".sub");
-        if(subbrute_path_is_file(context->file_path_tmp)) {
-            context->current_scene = SceneAttack;
-            return; //false;
-
-        } else {
-            subbrute_save_protocol_to_file(context->stream, string_get_cstr(context->file_path));
-        }
-
-        string_set_str(context->file_path, EXT_PATH("subghz"));
-        string_reset(context->file_path_tmp);
-
-        //scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveSuccess);
-        context->current_scene = SceneAttack;
-        return; //true;
-    } else {
-        //error no file name
-        context->current_scene = SceneAttack;
-        return; //true;
-    }
-}
-
-void subbrute_scene_save_name_text_input_callback(void* context) {
-    furi_assert(context);
-    SubBruteState* statee = context;
-    custom_callback(statee);
-}
-
-void subbrute_scene_save_name_on_tick(SubBruteState* context) {
-    if(backpressed) {
-        void* validator_context = text_input_get_validator_callback_context(context->text_input);
-        text_input_set_validator(context->text_input, NULL, NULL);
-        validator_is_file_free(validator_context);
-
-        // Clear view
-        text_input_reset(context->text_input);
-
-        // TextInput
-        view_dispatcher_remove_view(context->view_dispatcher, 0);
-        text_input_free(context->text_input);
-
-        // Popup
-        view_dispatcher_remove_view(context->view_dispatcher, 1);
-        popup_free(context->popup);
-
-        context->current_scene = SceneAttack;
-    }
-}
-
-bool subbrute_back_event_callback(void* context) {
-    UNUSED(context);
-    backpressed = true;
-    return true;
-}
-
-void subbrute_scene_save_name_on_enter(SubBruteState* context) {
-    // Text Input
-    context->text_input = text_input_alloc();
-    view_dispatcher_add_view(
-        context->view_dispatcher, 0, text_input_get_view(context->text_input));
-
-    // Popup
-    context->popup = popup_alloc();
-    view_dispatcher_add_view(context->view_dispatcher, 1, popup_get_view(context->popup));
-
-    // Setup view
-    TextInput* text_input = context->text_input;
-    bool dev_name_empty = false;
-
-    string_t file_name;
-    string_t dir_name;
-    string_init(file_name);
-    string_init(dir_name);
-
-    if(!subbrute_path_is_file(context->file_path)) {
-        char file_name_buf[64] = {0};
-        set_random_name(file_name_buf, 64);
-        string_set_str(file_name, file_name_buf);
-        string_set_str(context->file_path, EXT_PATH("subghz"));
-        //highlighting the entire filename by default
-        dev_name_empty = true;
-    } else {
-        string_set(context->file_path_tmp, context->file_path);
-        path_extract_dirname(string_get_cstr(context->file_path), dir_name);
-        path_extract_filename(context->file_path, file_name, true);
-        string_set(context->file_path, dir_name);
-    }
-
-    strncpy(context->file_name_tmp, string_get_cstr(file_name), 64);
-    text_input_set_header_text(text_input, "Name signal");
-    text_input_set_result_callback(
-        text_input,
-        subbrute_scene_save_name_text_input_callback,
-        context,
-        context->file_name_tmp,
-        MAX_TEXT_INPUT_LEN, // buffer size
-        dev_name_empty);
-
-    ValidatorIsFile* validator_is_file =
-        validator_is_file_alloc_init(string_get_cstr(context->file_path), ".sub", "");
-    text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
-
-    string_clear(file_name);
-    string_clear(dir_name);
-
-    view_dispatcher_set_navigation_event_callback(
-        context->view_dispatcher, subbrute_back_event_callback);
-
-    view_dispatcher_switch_to_view(context->view_dispatcher, 0);
-}
-
-void subbrute_scene_save_name_on_event(SubBruteEvent event, SubBruteState* context) {
-    UNUSED(context);
-    if(event.evt_type == EventTypeKey) {
-        if(event.input_type == InputTypeShort) {
-            switch(event.key) {
-            case InputKeyDown:
-            case InputKeyUp:
-            case InputKeyLeft:
-            case InputKeyRight:
-            case InputKeyOk:
-                break;
-            case InputKeyBack:
-                //context->current_scene = SceneAttack;
-                break;
-            }
-        }
-    }
-}
-
-void subbrute_scene_save_name_on_exit(SubBruteState* context) {
-    if(!backpressed) {
-        // Clear validator
-        void* validator_context = text_input_get_validator_callback_context(context->text_input);
-        text_input_set_validator(context->text_input, NULL, NULL);
-        validator_is_file_free(validator_context);
-
-        // Clear view
-        text_input_reset(context->text_input);
-
-        // Setup view
-        Popup* popup = context->popup;
-        popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
-        popup_set_header(popup, "Saved!", 13, 22, AlignLeft, AlignBottom);
-        popup_set_timeout(popup, 1500);
-        popup_set_context(popup, context);
-        popup_set_callback(popup, NULL);
-        popup_enable_timeout(popup);
-        view_dispatcher_switch_to_view(context->view_dispatcher, 1);
-
-        furi_delay_ms(1050);
-        // Clear view
-        //Popup* popup = subghz->popup;
-        popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
-        popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
-        popup_set_icon(popup, 0, 0, NULL);
-        popup_set_callback(popup, NULL);
-        popup_set_context(popup, NULL);
-        popup_set_timeout(popup, 0);
-        popup_disable_timeout(popup);
-
-        // TextInput
-        view_dispatcher_remove_view(context->view_dispatcher, 0);
-        text_input_free(context->text_input);
-
-        // Popup
-        view_dispatcher_remove_view(context->view_dispatcher, 1);
-        popup_free(context->popup);
-    } else {
-        backpressed = false;
-    }
-}

applications/plugins/subbrute/scene/subbrute_scene_save_name.h

@@ -1,6 +0,0 @@
-#include "../subbrute.h"
-
-void subbrute_scene_save_name_on_enter(SubBruteState* context);
-void subbrute_scene_save_name_on_exit(SubBruteState* context);
-void subbrute_scene_save_name_on_event(SubBruteEvent event, SubBruteState* context);
-void subbrute_scene_save_name_on_tick(SubBruteState* context);

applications/plugins/subbrute/scene/subbrute_scene_select_field.c

@@ -1,121 +0,0 @@
-#include "subbrute_scene_select_field.h"
-
-void center_displayed_key(SubBruteState* context, uint8_t index) {
-    const char* key_cstr = string_get_cstr(context->key);
-    uint8_t str_index = (index * 3);
-
-    char display_menu[17] = {
-        'X', 'X', ' ', 'X', 'X', ' ', '<', 'X', 'X', '>', ' ', 'X', 'X', ' ', 'X', 'X', '\0'};
-
-    if(index > 1) {
-        display_menu[0] = key_cstr[str_index - 6];
-        display_menu[1] = key_cstr[str_index - 5];
-    } else {
-        display_menu[0] = ' ';
-        display_menu[1] = ' ';
-    }
-
-    if(index > 0) {
-        display_menu[3] = key_cstr[str_index - 3];
-        display_menu[4] = key_cstr[str_index - 2];
-    } else {
-        display_menu[3] = ' ';
-        display_menu[4] = ' ';
-    }
-
-    display_menu[7] = key_cstr[str_index];
-    display_menu[8] = key_cstr[str_index + 1];
-
-    if((str_index + 4) <= (uint8_t)strlen(key_cstr)) {
-        display_menu[11] = key_cstr[str_index + 3];
-        display_menu[12] = key_cstr[str_index + 4];
-    } else {
-        display_menu[11] = ' ';
-        display_menu[12] = ' ';
-    }
-
-    if((str_index + 8) <= (uint8_t)strlen(key_cstr)) {
-        display_menu[14] = key_cstr[str_index + 6];
-        display_menu[15] = key_cstr[str_index + 7];
-    } else {
-        display_menu[14] = ' ';
-        display_menu[15] = ' ';
-    }
-
-    string_reset(context->notification_msg);
-    string_set_str(context->notification_msg, display_menu);
-}
-
-void subbrute_scene_select_field_on_enter(SubBruteState* context) {
-    string_clear(context->notification_msg);
-}
-
-void subbrute_scene_select_field_on_exit(SubBruteState* context) {
-    UNUSED(context);
-}
-
-void subbrute_scene_select_field_on_tick(SubBruteState* context) {
-    UNUSED(context);
-}
-
-void subbrute_scene_select_field_on_event(SubBruteEvent event, SubBruteState* context) {
-    if(event.evt_type == EventTypeKey) {
-        if(event.input_type == InputTypeShort) {
-            //const char* key_cstr = string_get_cstr(context->key);
-
-            // don't look, it's ugly but I'm a python dev so...
-            /*uint8_t nb_bytes = 0;
-            for(uint8_t i = 0; i < strlen(key_cstr); i++) {
-                if(' ' == key_cstr[i]) {
-                    nb_bytes++;
-                }
-            }*/
-
-            switch(event.key) {
-            case InputKeyDown:
-            case InputKeyUp:
-                break;
-            case InputKeyLeft:
-                if(context->key_index > 0) {
-                    context->key_index--;
-                }
-                break;
-            case InputKeyRight:
-                if(context->key_index < 7) {
-                    context->key_index++;
-                }
-                break;
-            case InputKeyOk:
-                string_reset(context->notification_msg);
-                context->current_scene = SceneAttack;
-                break;
-            case InputKeyBack:
-                string_reset(context->notification_msg);
-                context->current_scene = SceneSelectFile;
-                break;
-            }
-            //FURI_LOG_D(TAG, "Position: %d/%d", context->key_index, nb_bytes);
-        }
-    }
-}
-
-void subbrute_scene_select_field_on_draw(Canvas* canvas, SubBruteState* context) {
-    canvas_clear(canvas);
-    canvas_set_color(canvas, ColorBlack);
-
-    // Frame
-    //canvas_draw_frame(canvas, 0, 0, 128, 64);
-
-    // Title
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 10, AlignCenter, AlignTop, "use < > to select field");
-
-    char msg_index[18];
-    snprintf(msg_index, sizeof(msg_index), "Field index : %d", context->key_index);
-    canvas_draw_str_aligned(canvas, 64, 26, AlignCenter, AlignTop, msg_index);
-
-    center_displayed_key(context, context->key_index);
-    canvas_set_font(canvas, FontSecondary);
-    canvas_draw_str_aligned(
-        canvas, 64, 40, AlignCenter, AlignTop, string_get_cstr(context->notification_msg));
-}

applications/plugins/subbrute/scene/subbrute_scene_select_field.h

@@ -1,8 +0,0 @@
-#include "../subbrute.h"
-
-void subbrute_scene_select_field_on_enter(SubBruteState* context);
-void subbrute_scene_select_field_on_exit(SubBruteState* context);
-void subbrute_scene_select_field_on_tick(SubBruteState* context);
-void subbrute_scene_select_field_on_event(SubBruteEvent event, SubBruteState* context);
-void subbrute_scene_select_field_on_draw(Canvas* canvas, SubBruteState* context);
-void center_displayed_key(SubBruteState* context, uint8_t index);

applications/plugins/subbrute/scenes/subbrute_scene.h

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

applications/plugins/subbrute/scenes/subbrute_scene_config.h

@@ -0,0 +1,7 @@
+ADD_SCENE(subbrute, load_file, LoadFile)
+ADD_SCENE(subbrute, load_select, LoadSelect)
+ADD_SCENE(subbrute, run_attack, RunAttack)
+ADD_SCENE(subbrute, save_name, SaveName)
+ADD_SCENE(subbrute, save_success, SaveSuccess)
+ADD_SCENE(subbrute, setup_attack, SetupAttack)
+ADD_SCENE(subbrute, start, Start)

applications/plugins/subbrute/scenes/subbrute_scene_load_file.c

@@ -0,0 +1,77 @@
+#include "../subbrute_i.h"
+#include "../subbrute_custom_event.h"
+#include <lib/subghz/protocols/registry.h>
+
+#define TAG "SubBruteSceneLoadFile"
+
+//void subbrute_scene_load_file_callback(SubBruteCustomEvent event, void* context) {
+////    furi_assert(context);
+////
+////    SubBruteState* instance = (SubBruteState*)context;
+////    view_dispatcher_send_custom_event(instance->view_dispatcher, event);
+//}
+
+void subbrute_scene_load_file_on_enter(void* context) {
+    furi_assert(context);
+    SubBruteState* instance = (SubBruteState*)context;
+
+    // Input events and views are managed by file_browser
+    string_t app_folder;
+    string_t load_path;
+    string_init(load_path);
+    string_init_set_str(app_folder, SUBBRUTE_PATH);
+
+    DialogsFileBrowserOptions browser_options;
+    dialog_file_browser_set_basic_options(&browser_options, SUBBRUTE_FILE_EXT, &I_sub1_10px);
+
+    SubBruteFileResult load_result = SubBruteFileResultUnknown;
+    bool res =
+        dialog_file_browser_show(instance->dialogs, load_path, app_folder, &browser_options);
+#ifdef FURI_DEBUG
+    FURI_LOG_D(
+        TAG,
+        "load_path: %s, app_folder: %s",
+        string_get_cstr(load_path),
+        string_get_cstr(app_folder));
+#endif
+    if(res) {
+        load_result = subbrute_device_load_from_file(instance->device, load_path);
+        if(load_result == SubBruteFileResultOk) {
+            load_result = subbrute_device_attack_set(instance->device, SubBruteAttackLoadFile);
+            if(load_result == SubBruteFileResultOk) {
+                // Ready to run!
+                instance->device->state = SubBruteDeviceStateReady;
+                FURI_LOG_I(TAG, "Ready to run");
+                res = true;
+            }
+        }
+    }
+
+    if(load_result == SubBruteFileResultOk) {
+        scene_manager_next_scene(instance->scene_manager, SubBruteSceneLoadSelect);
+    } else {
+        FURI_LOG_E(TAG, "Returned error: %d", load_result);
+
+        string_t dialog_msg;
+        string_init(dialog_msg);
+        string_cat_printf(
+            dialog_msg, "Cannot parse\nfile: %s", subbrute_device_error_get_desc(load_result));
+        dialog_message_show_storage_error(instance->dialogs, string_get_cstr(dialog_msg));
+        string_clear(dialog_msg);
+        scene_manager_search_and_switch_to_previous_scene(
+            instance->scene_manager, SubBruteSceneStart);
+    }
+
+    string_clear(app_folder);
+    string_clear(load_path);
+}
+
+void subbrute_scene_load_file_on_exit(void* context) {
+    UNUSED(context);
+}
+
+bool subbrute_scene_load_file_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}

applications/plugins/subbrute/scenes/subbrute_scene_load_select.c

@@ -0,0 +1,61 @@
+#include "../subbrute_i.h"
+#include "../subbrute_custom_event.h"
+#include "../views/subbrute_main_view.h"
+
+#define TAG "SubBruteSceneStart"
+
+void subbrute_scene_load_select_callback(SubBruteCustomEvent event, void* context) {
+    furi_assert(context);
+
+    SubBruteState* instance = (SubBruteState*)context;
+#ifdef FURI_DEBUG
+    FURI_LOG_D(TAG, "subbrute_scene_load_select_callback");
+#endif
+    view_dispatcher_send_custom_event(instance->view_dispatcher, event);
+}
+
+void subbrute_scene_load_select_on_enter(void* context) {
+    furi_assert(context);
+#ifdef FURI_DEBUG
+    FURI_LOG_I(TAG, "subbrute_scene_load_select_on_enter");
+#endif
+    SubBruteState* instance = (SubBruteState*)context;
+    SubBruteMainView* view = instance->view_main;
+
+    instance->current_view = SubBruteViewMain;
+    subbrute_main_view_set_callback(view, subbrute_scene_load_select_callback, instance);
+    subbrute_main_view_set_index(view, 7, true, instance->device->file_key);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, instance->current_view);
+}
+
+void subbrute_scene_load_select_on_exit(void* context) {
+    UNUSED(context);
+#ifdef FURI_DEBUG
+    FURI_LOG_I(TAG, "subbrute_scene_load_select_on_exit");
+#endif
+}
+
+bool subbrute_scene_load_select_on_event(void* context, SceneManagerEvent event) {
+    SubBruteState* instance = (SubBruteState*)context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubBruteCustomEventTypeIndexSelected) {
+            instance->device->load_index = subbrute_main_view_get_index(instance->view_main);
+#ifdef FURI_DEBUG
+            FURI_LOG_D(TAG, "load_index: %d", instance->device->load_index);
+#endif
+            scene_manager_next_scene(instance->scene_manager, SubBruteSceneSetupAttack);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        if(!scene_manager_search_and_switch_to_previous_scene(
+               instance->scene_manager, SubBruteSceneStart)) {
+            scene_manager_next_scene(instance->scene_manager, SubBruteSceneStart);
+        }
+        consumed = true;
+    }
+
+    return consumed;
+}

applications/plugins/subbrute/scenes/subbrute_scene_run_attack.c

@@ -0,0 +1,83 @@
+#include "../subbrute_i.h"
+#include "../subbrute_custom_event.h"
+#include "../views/subbrute_attack_view.h"
+#include "../helpers/subbrute_worker.h"
+
+static void subbrute_scene_run_attack_callback(SubBruteCustomEvent event, void* context) {
+    furi_assert(context);
+
+    SubBruteState* instance = (SubBruteState*)context;
+    view_dispatcher_send_custom_event(instance->view_dispatcher, event);
+}
+
+void subbrute_scene_run_attack_on_exit(void* context) {
+    furi_assert(context);
+
+    SubBruteState* instance = (SubBruteState*)context;
+    notification_message(instance->notifications, &sequence_blink_stop);
+}
+
+void subbrute_scene_run_attack_on_enter(void* context) {
+    furi_assert(context);
+    SubBruteState* instance = (SubBruteState*)context;
+    SubBruteAttackView* view = instance->view_attack;
+
+    instance->current_view = SubBruteViewAttack;
+    subbrute_attack_view_set_callback(view, subbrute_scene_run_attack_callback, instance);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, instance->current_view);
+
+    subbrute_attack_view_init_values(
+        view,
+        (uint8_t)instance->device->attack,
+        instance->device->max_value,
+        instance->device->key_index,
+        true);
+
+    // Start worker if not started
+    subbrute_worker_init_manual_transmit(
+        instance->worker,
+        instance->device->frequency,
+        instance->device->preset,
+        string_get_cstr(instance->device->protocol_name));
+}
+
+bool subbrute_scene_run_attack_on_event(void* context, SceneManagerEvent event) {
+    SubBruteState* instance = (SubBruteState*)context;
+    SubBruteAttackView* view = instance->view_attack;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubBruteCustomEventTypeTransmitNotStarted ||
+           event.event == SubBruteCustomEventTypeTransmitFinished ||
+           event.event == SubBruteCustomEventTypeBackPressed) {
+            // Stop transmit
+            scene_manager_next_scene(instance->scene_manager, SubBruteSceneSetupAttack);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        if(subbrute_worker_can_transmit(instance->worker)) {
+            // Blink
+            notification_message(instance->notifications, &sequence_blink_yellow_100);
+
+            if(subbrute_worker_manual_transmit(instance->worker, instance->device->payload)) {
+                // Make payload for new iteration or exit
+                if(instance->device->key_index + 1 > instance->device->max_value) {
+                    // End of list
+                    scene_manager_next_scene(instance->scene_manager, SubBruteSceneSetupAttack);
+                } else {
+                    instance->device->key_index++;
+                    subbrute_attack_view_set_current_step(view, instance->device->key_index);
+                    subbrute_device_create_packet_parsed(
+                        instance->device, instance->device->key_index);
+                }
+            }
+
+            // Stop
+            notification_message(instance->notifications, &sequence_blink_stop);
+        }
+
+        consumed = true;
+    }
+
+    return consumed;
+}

applications/plugins/subbrute/scenes/subbrute_scene_save_name.c

@@ -0,0 +1,87 @@
+#include <m-string.h>
+#include <subghz/types.h>
+#include <lib/toolbox/random_name.h>
+#include <gui/modules/validators.h>
+#include <lib/toolbox/path.h>
+
+#include "../subbrute_i.h"
+#include "../subbrute_custom_event.h"
+
+#define TAG "SubBruteSceneSaveFile"
+
+void subbrute_scene_save_name_on_enter(void* context) {
+    SubBruteState* instance = (SubBruteState*)context;
+    SubBruteDevice* device = instance->device;
+
+    // Setup view
+    TextInput* text_input = instance->text_input;
+    set_random_name(device->text_store, sizeof(device->text_store));
+
+    text_input_set_header_text(text_input, "Name of file");
+    text_input_set_result_callback(
+        text_input,
+        subbrute_text_input_callback,
+        instance,
+        device->text_store,
+        SUBBRUTE_MAX_LEN_NAME,
+        true);
+
+    string_set_str(device->load_path, SUBBRUTE_PATH);
+
+    ValidatorIsFile* validator_is_file =
+        validator_is_file_alloc_init(string_get_cstr(device->load_path), SUBBRUTE_FILE_EXT, "");
+    text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, SubBruteViewTextInput);
+}
+
+bool subbrute_scene_save_name_on_event(void* context, SceneManagerEvent event) {
+    SubBruteState* instance = (SubBruteState*)context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_previous_scene(instance->scene_manager);
+        return true;
+    } else if(
+        event.type == SceneManagerEventTypeCustom &&
+        event.event == SubBruteCustomEventTypeTextEditDone) {
+#ifdef FURI_DEBUG
+        FURI_LOG_D(TAG, "Saving: %s", instance->device->text_store);
+#endif
+        bool success = false;
+        if(strcmp(instance->device->text_store, "")) {
+            string_cat_printf(
+                instance->device->load_path,
+                "/%s%s",
+                instance->device->text_store,
+                SUBBRUTE_FILE_EXT);
+
+            if(subbrute_device_save_file(
+                   instance->device, string_get_cstr(instance->device->load_path))) {
+                scene_manager_next_scene(instance->scene_manager, SubBruteSceneSaveSuccess);
+                success = true;
+                consumed = true;
+            }
+        }
+
+        if(!success) {
+            dialog_message_show_storage_error(instance->dialogs, "Error during saving!");
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                instance->scene_manager, SubBruteSceneSetupAttack);
+        }
+    }
+    return consumed;
+}
+
+void subbrute_scene_save_name_on_exit(void* context) {
+    SubBruteState* instance = (SubBruteState*)context;
+
+    // Clear view
+    void* validator_context = text_input_get_validator_callback_context(instance->text_input);
+    text_input_set_validator(instance->text_input, NULL, NULL);
+    validator_is_file_free(validator_context);
+
+    text_input_reset(instance->text_input);
+
+    string_reset(instance->device->load_path);
+}