Bad-BLE (#116)

applications/ReadMe.md

@@ -25,7 +25,7 @@ Applications for factory testing the Flipper.
 Applications for main Flipper menu.
 
 - `archive`             - Archive and file manager 
-- `bad_usb`             - Bad USB application
+- `bad_kb`              - Bad KB application
 - `fap_loader`          - External applications loader
 - `gpio`                - GPIO application: includes USART bridge and GPIO control
 - `ibutton`             - iButton application, onewire keys and more

applications/debug/file_browser_test/file_browser_app.c

@@ -49,7 +49,7 @@ FileBrowserApp* file_browser_app_alloc(char* arg) {
 
     app->file_path = furi_string_alloc();
     app->file_browser = file_browser_alloc(app->file_path);
-    file_browser_configure(app->file_browser, "*", NULL, true, false, &I_badusb_10px, true);
+    file_browser_configure(app->file_browser, "*", NULL, true, false, &I_badkb_10px, true);
 
     view_dispatcher_add_view(
         app->view_dispatcher, FileBrowserAppViewStart, widget_get_view(app->widget));

applications/debug/file_browser_test/scenes/file_browser_scene_start.c

@@ -19,7 +19,7 @@ bool file_browser_scene_start_on_event(void* context, SceneManagerEvent event) {
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        furi_string_set(app->file_path, ANY_PATH("badusb/demo_windows.txt"));
+        furi_string_set(app->file_path, ANY_PATH("badkb/demo_windows.txt"));
         scene_manager_next_scene(app->scene_manager, FileBrowserSceneBrowser);
         consumed = true;
     } else if(event.type == SceneManagerEventTypeTick) {

applications/main/application.fam

@@ -9,7 +9,7 @@ App(
         "lfrfid",
         "nfc",
         "subghz",
-        "bad_usb",
+        "bad_kb",
         "u2f",
         "fap_loader",
         "sub_playlist",
@@ -30,7 +30,7 @@ App(
         "lfrfid",
         "nfc",
         "subghz",
-        # "bad_usb",
+        # "bad_kb",
         # "u2f",
         "fap_loader",
         "archive",

applications/main/archive/helpers/archive_browser.h

@@ -14,7 +14,7 @@ static const char* tab_default_paths[] = {
     [ArchiveTabSubGhz] = ANY_PATH("subghz"),
     [ArchiveTabLFRFID] = ANY_PATH("lfrfid"),
     [ArchiveTabInfrared] = ANY_PATH("infrared"),
-    [ArchiveTabBadUsb] = ANY_PATH("badusb"),
+    [ArchiveTabBadKb] = ANY_PATH("badkb"),
     [ArchiveTabU2f] = "/app:u2f",
     [ArchiveTabApplications] = ANY_PATH("apps"),
     [ArchiveTabInternal] = STORAGE_INT_PATH_PREFIX,
@@ -27,7 +27,7 @@ static const char* known_ext[] = {
     [ArchiveFileTypeSubGhz] = ".sub",
     [ArchiveFileTypeLFRFID] = ".rfid",
     [ArchiveFileTypeInfrared] = ".ir",
-    [ArchiveFileTypeBadUsb] = ".txt",
+    [ArchiveFileTypeBadKb] = ".txt",
     [ArchiveFileTypeU2f] = "?",
     [ArchiveFileTypeApplication] = ".fap",
     [ArchiveFileTypeUpdateManifest] = ".fuf",
@@ -42,7 +42,7 @@ static const ArchiveFileTypeEnum known_type[] = {
     [ArchiveTabSubGhz] = ArchiveFileTypeSubGhz,
     [ArchiveTabLFRFID] = ArchiveFileTypeLFRFID,
     [ArchiveTabInfrared] = ArchiveFileTypeInfrared,
-    [ArchiveTabBadUsb] = ArchiveFileTypeBadUsb,
+    [ArchiveTabBadKb] = ArchiveFileTypeBadKb,
     [ArchiveTabU2f] = ArchiveFileTypeU2f,
     [ArchiveTabApplications] = ArchiveFileTypeApplication,
     [ArchiveTabInternal] = ArchiveFileTypeUnknown,

applications/main/archive/helpers/archive_files.c

@@ -16,11 +16,11 @@ void archive_set_file_type(ArchiveFile_t* file, const char* path, bool is_folder
         for(size_t i = 0; i < COUNT_OF(known_ext); i++) {
             if((known_ext[i][0] == '?') || (known_ext[i][0] == '*')) continue;
             if(furi_string_search(file->path, known_ext[i], 0) != FURI_STRING_FAILURE) {
-                if(i == ArchiveFileTypeBadUsb) {
-                    if(furi_string_search(
-                           file->path, archive_get_default_path(ArchiveTabBadUsb)) == 0) {
+                if(i == ArchiveFileTypeBadKb) {
+                    if(furi_string_search(file->path, archive_get_default_path(ArchiveTabBadKb)) ==
+                       0) {
                         file->type = i;
-                        return; // *.txt file is a BadUSB script only if it is in BadUSB folder
+                        return; // *.txt file is a BadKB script only if it is in BadKB folder
                     }
                 } else {
                     file->type = i;

applications/main/archive/helpers/archive_files.h

@@ -15,7 +15,7 @@ typedef enum {
     ArchiveFileTypeSubGhz,
     ArchiveFileTypeLFRFID,
     ArchiveFileTypeInfrared,
-    ArchiveFileTypeBadUsb,
+    ArchiveFileTypeBadKb,
     ArchiveFileTypeU2f,
     ArchiveFileTypeApplication,
     ArchiveFileTypeUpdateManifest,

applications/main/archive/scenes/archive_scene_browser.c

@@ -17,7 +17,7 @@ static const char* flipper_app_name[] = {
     [ArchiveFileTypeSubGhz] = "Sub-GHz",
     [ArchiveFileTypeLFRFID] = "125 kHz RFID",
     [ArchiveFileTypeInfrared] = "Infrared",
-    [ArchiveFileTypeBadUsb] = "Bad USB",
+    [ArchiveFileTypeBadKb] = "Bad KB",
     [ArchiveFileTypeU2f] = "U2F",
     [ArchiveFileTypeApplication] = "Applications",
     [ArchiveFileTypeUpdateManifest] = "UpdaterApp",

applications/main/archive/views/archive_browser_view.c

@@ -16,7 +16,7 @@ static const char* ArchiveTabNames[] = {
     [ArchiveTabSubGhz] = "Sub-GHz",
     [ArchiveTabLFRFID] = "RFID LF",
     [ArchiveTabInfrared] = "Infrared",
-    [ArchiveTabBadUsb] = "Bad USB",
+    [ArchiveTabBadKb] = "Bad KB",
     [ArchiveTabU2f] = "U2F",
     [ArchiveTabApplications] = "Apps",
     [ArchiveTabInternal] = "Internal",
@@ -29,7 +29,7 @@ static const Icon* ArchiveItemIcons[] = {
     [ArchiveFileTypeSubGhz] = &I_sub1_10px,
     [ArchiveFileTypeLFRFID] = &I_125_10px,
     [ArchiveFileTypeInfrared] = &I_ir_10px,
-    [ArchiveFileTypeBadUsb] = &I_badusb_10px,
+    [ArchiveFileTypeBadKb] = &I_badkb_10px,
     [ArchiveFileTypeU2f] = &I_u2f_10px,
     [ArchiveFileTypeApplication] = &I_Apps_10px,
     [ArchiveFileTypeUpdateManifest] = &I_update_10px,
@@ -110,7 +110,7 @@ static void render_item_menu(Canvas* canvas, ArchiveBrowserViewModel* model) {
                 menu_array_push_raw(model->context_menu),
                 item_pin,
                 ArchiveBrowserEventFileMenuPin);
-            if(selected->type <= ArchiveFileTypeBadUsb) {
+            if(selected->type <= ArchiveFileTypeBadKb) {
                 archive_menu_add_item(
                     menu_array_push_raw(model->context_menu),
                     item_show,
@@ -130,7 +130,7 @@ static void render_item_menu(Canvas* canvas, ArchiveBrowserViewModel* model) {
                 menu_array_push_raw(model->context_menu),
                 item_info,
                 ArchiveBrowserEventFileMenuInfo);
-            if(selected->type <= ArchiveFileTypeBadUsb) {
+            if(selected->type <= ArchiveFileTypeBadKb) {
                 archive_menu_add_item(
                     menu_array_push_raw(model->context_menu),
                     item_show,
@@ -158,7 +158,7 @@ static void render_item_menu(Canvas* canvas, ArchiveBrowserViewModel* model) {
                 menu_array_push_raw(model->context_menu),
                 item_info,
                 ArchiveBrowserEventFileMenuInfo);
-            if(selected->type <= ArchiveFileTypeBadUsb) {
+            if(selected->type <= ArchiveFileTypeBadKb) {
                 archive_menu_add_item(
                     menu_array_push_raw(model->context_menu),
                     item_show,
@@ -589,4 +589,4 @@ void browser_free(ArchiveBrowserView* browser) {
 
     view_free(browser->view);
     free(browser);
-}
+}

applications/main/archive/views/archive_browser_view.h

@@ -28,7 +28,7 @@ typedef enum {
     ArchiveTabNFC,
     ArchiveTabInfrared,
     ArchiveTabIButton,
-    ArchiveTabBadUsb,
+    ArchiveTabBadKb,
     ArchiveTabU2f,
     ArchiveTabApplications,
     ArchiveTabInternal,

applications/main/bad_kb/application.fam

@@ -1,15 +1,15 @@
 App(
-    appid="bad_usb",
-    name="Bad USB",
+    appid="bad_kb",
+    name="Bad KB",
     apptype=FlipperAppType.APP,
-    entry_point="bad_usb_app",
-    cdefines=["APP_BAD_USB"],
+    entry_point="bad_kb_app",
+    cdefines=["APP_BAD_KB"],
     requires=[
         "gui",
         "dialogs",
     ],
     stack_size=2 * 1024,
-    icon="A_BadUsb_14",
+    icon="A_BadKb_14",
     order=70,
     fap_libs=["assets"],
 )

applications/main/bad_kb/bad_kb_app.c

@@ -0,0 +1,221 @@
+#include "bad_kb_app_i.h"
+#include "bad_kb_settings_filename.h"
+#include <furi.h>
+#include <furi_hal.h>
+#include <storage/storage.h>
+#include <lib/toolbox/path.h>
+
+#include <bt/bt_service/bt_i.h>
+#include <bt/bt_service/bt.h>
+
+#define BAD_KB_SETTINGS_PATH BAD_KB_APP_BASE_FOLDER "/" BAD_KB_SETTINGS_FILE_NAME
+
+static bool bad_kb_app_custom_event_callback(void* context, uint32_t event) {
+    furi_assert(context);
+    BadKbApp* app = context;
+    return scene_manager_handle_custom_event(app->scene_manager, event);
+}
+
+static bool bad_kb_app_back_event_callback(void* context) {
+    furi_assert(context);
+    BadKbApp* app = context;
+    return scene_manager_handle_back_event(app->scene_manager);
+}
+
+static void bad_kb_app_tick_event_callback(void* context) {
+    furi_assert(context);
+    BadKbApp* app = context;
+    scene_manager_handle_tick_event(app->scene_manager);
+}
+
+static void bad_kb_load_settings(BadKbApp* app) {
+    File* settings_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
+    if(storage_file_open(settings_file, BAD_KB_SETTINGS_PATH, FSAM_READ, FSOM_OPEN_EXISTING)) {
+        char chr;
+        while((storage_file_read(settings_file, &chr, 1) == 1) &&
+              !storage_file_eof(settings_file) && !isspace(chr)) {
+            furi_string_push_back(app->keyboard_layout, chr);
+        }
+    }
+    storage_file_close(settings_file);
+    storage_file_free(settings_file);
+}
+
+static void bad_kb_save_settings(BadKbApp* app) {
+    File* settings_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
+    if(storage_file_open(settings_file, BAD_KB_SETTINGS_PATH, FSAM_WRITE, FSOM_OPEN_ALWAYS)) {
+        storage_file_write(
+            settings_file,
+            furi_string_get_cstr(app->keyboard_layout),
+            furi_string_size(app->keyboard_layout));
+        storage_file_write(settings_file, "\n", 1);
+    }
+    storage_file_close(settings_file);
+    storage_file_free(settings_file);
+}
+
+void bad_kb_set_name(BadKbApp* app, const char* fmt, ...) {
+    furi_assert(app);
+
+    va_list args;
+    va_start(args, fmt);
+
+    vsnprintf(app->name, BAD_KB_ADV_NAME_MAX_LEN, fmt, args);
+
+    va_end(args);
+}
+
+BadKbApp* bad_kb_app_alloc(char* arg) {
+    BadKbApp* app = malloc(sizeof(BadKbApp));
+
+    app->bad_kb_script = NULL;
+
+    app->file_path = furi_string_alloc();
+    app->keyboard_layout = furi_string_alloc();
+    if(arg && strlen(arg)) {
+        furi_string_set(app->file_path, arg);
+    }
+
+    bad_kb_load_settings(app);
+
+    app->gui = furi_record_open(RECORD_GUI);
+    app->notifications = furi_record_open(RECORD_NOTIFICATION);
+    app->dialogs = furi_record_open(RECORD_DIALOGS);
+
+    app->view_dispatcher = view_dispatcher_alloc();
+    view_dispatcher_enable_queue(app->view_dispatcher);
+
+    app->scene_manager = scene_manager_alloc(&bad_kb_scene_handlers, app);
+
+    view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
+    view_dispatcher_set_tick_event_callback(
+        app->view_dispatcher, bad_kb_app_tick_event_callback, 500);
+    view_dispatcher_set_custom_event_callback(
+        app->view_dispatcher, bad_kb_app_custom_event_callback);
+    view_dispatcher_set_navigation_event_callback(
+        app->view_dispatcher, bad_kb_app_back_event_callback);
+
+    Bt* bt = furi_record_open(RECORD_BT);
+    app->bt = bt;
+    const char* adv_name = bt_get_profile_adv_name(bt);
+    memcpy(app->name, adv_name, BAD_KB_ADV_NAME_MAX_LEN);
+    memcpy(app->bt_old_config.name, adv_name, BAD_KB_ADV_NAME_MAX_LEN);
+
+    const uint8_t* mac_addr = bt_get_profile_mac_address(bt);
+    memcpy(app->mac, mac_addr, BAD_KB_MAC_ADDRESS_LEN);
+    memcpy(app->bt_old_config.mac, mac_addr, BAD_KB_MAC_ADDRESS_LEN);
+
+    // Custom Widget
+    app->widget = widget_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, BadKbAppViewError, widget_get_view(app->widget));
+
+    app->var_item_list_bt = variable_item_list_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        BadKbAppViewConfigBt,
+        variable_item_list_get_view(app->var_item_list_bt));
+    app->var_item_list_usb = variable_item_list_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        BadKbAppViewConfigUsb,
+        variable_item_list_get_view(app->var_item_list_usb));
+
+    app->bad_kb_view = bad_kb_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, BadKbAppViewWork, bad_kb_get_view(app->bad_kb_view));
+
+    app->text_input = text_input_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, BadKbAppViewConfigName, text_input_get_view(app->text_input));
+
+    app->byte_input = byte_input_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, BadKbAppViewConfigMac, byte_input_get_view(app->byte_input));
+
+    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
+
+    if(furi_hal_usb_is_locked()) {
+        app->error = BadKbAppErrorCloseRpc;
+        scene_manager_next_scene(app->scene_manager, BadKbSceneError);
+    } else {
+        if(!furi_string_empty(app->file_path)) {
+            app->bad_kb_script = bad_kb_script_open(app->file_path, app->is_bt ? app->bt : NULL);
+            bad_kb_script_set_keyboard_layout(app->bad_kb_script, app->keyboard_layout);
+            scene_manager_next_scene(app->scene_manager, BadKbSceneWork);
+        } else {
+            furi_string_set(app->file_path, BAD_KB_APP_BASE_FOLDER);
+            scene_manager_next_scene(app->scene_manager, BadKbSceneFileSelect);
+        }
+    }
+
+    return app;
+}
+
+void bad_kb_app_free(BadKbApp* app) {
+    furi_assert(app);
+
+    if(app->bad_kb_script) {
+        bad_kb_script_close(app->bad_kb_script);
+        app->bad_kb_script = NULL;
+    }
+
+    // Views
+    view_dispatcher_remove_view(app->view_dispatcher, BadKbAppViewWork);
+    bad_kb_free(app->bad_kb_view);
+
+    // Custom Widget
+    view_dispatcher_remove_view(app->view_dispatcher, BadKbAppViewError);
+    widget_free(app->widget);
+
+    // Variable item list
+    view_dispatcher_remove_view(app->view_dispatcher, BadKbAppViewConfigBt);
+    variable_item_list_free(app->var_item_list_bt);
+    view_dispatcher_remove_view(app->view_dispatcher, BadKbAppViewConfigUsb);
+    variable_item_list_free(app->var_item_list_usb);
+
+    // Text Input
+    view_dispatcher_remove_view(app->view_dispatcher, BadKbAppViewConfigName);
+    text_input_free(app->text_input);
+
+    // Byte Input
+    view_dispatcher_remove_view(app->view_dispatcher, BadKbAppViewConfigMac);
+    byte_input_free(app->byte_input);
+
+    // View dispatcher
+    view_dispatcher_free(app->view_dispatcher);
+    scene_manager_free(app->scene_manager);
+
+    // restores bt config
+    // BtProfile have already been switched to the previous one
+    // so we directly modify the right profile
+    bad_kb_connection_deinit(app->bt);
+    if(strcmp(app->bt_old_config.name, app->name) != 0) {
+        furi_hal_bt_set_profile_adv_name(FuriHalBtProfileHidKeyboard, app->bt_old_config.name);
+    }
+    if(memcmp(app->bt_old_config.mac, app->mac, BAD_KB_MAC_ADDRESS_LEN) != 0) {
+        furi_hal_bt_set_profile_mac_addr(FuriHalBtProfileHidKeyboard, app->bt_old_config.mac);
+    }
+
+    // Close records
+    furi_record_close(RECORD_GUI);
+    furi_record_close(RECORD_NOTIFICATION);
+    furi_record_close(RECORD_DIALOGS);
+    furi_record_close(RECORD_BT);
+
+    bad_kb_save_settings(app);
+
+    furi_string_free(app->file_path);
+    furi_string_free(app->keyboard_layout);
+
+    free(app);
+}
+
+int32_t bad_kb_app(void* p) {
+    BadKbApp* bad_kb_app = bad_kb_app_alloc((char*)p);
+
+    view_dispatcher_run(bad_kb_app->view_dispatcher);
+
+    bad_kb_app_free(bad_kb_app);
+    return 0;
+}

applications/main/bad_kb/bad_kb_app.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct BadKbApp BadKbApp;
+
+void bad_kb_set_name(BadKbApp* app, const char* fmt, ...);
+
+#ifdef __cplusplus
+}
+#endif

applications/main/bad_kb/bad_kb_app_i.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "bad_kb_app.h"
+#include "scenes/bad_kb_scene.h"
+#include "bad_kb_script.h"
+
+#include <gui/gui.h>
+#include <assets_icons.h>
+#include <gui/view_dispatcher.h>
+#include <gui/scene_manager.h>
+#include <dialogs/dialogs.h>
+#include <notification/notification_messages.h>
+#include <gui/modules/variable_item_list.h>
+#include <gui/modules/widget.h>
+#include <gui/modules/text_input.h>
+#include <gui/modules/byte_input.h>
+#include "views/bad_kb_view.h"
+
+#define BAD_KB_APP_BASE_FOLDER ANY_PATH("badkb")
+#define BAD_KB_APP_PATH_LAYOUT_FOLDER BAD_KB_APP_BASE_FOLDER "/layouts"
+#define BAD_KB_APP_SCRIPT_EXTENSION ".txt"
+#define BAD_KB_APP_LAYOUT_EXTENSION ".kl"
+
+#define BAD_KB_MAC_ADDRESS_LEN 6 // need replace with MAC size maccro
+#define BAD_KB_ADV_NAME_MAX_LEN 18
+
+typedef enum {
+    BadKbAppErrorNoFiles,
+    BadKbAppErrorCloseRpc,
+} BadKbAppError;
+
+typedef enum BadKbCustomEvent {
+    BadKbAppCustomEventTextEditResult,
+    BadKbAppCustomEventByteInputDone,
+    BadKbCustomEventErrorBack
+} BadKbCustomEvent;
+
+typedef struct {
+    uint8_t mac[BAD_KB_MAC_ADDRESS_LEN];
+    char name[BAD_KB_ADV_NAME_MAX_LEN + 1];
+
+    // number of bt keys before starting the app (all keys added in
+    // the bt keys file then will be removed)
+    uint16_t n_keys;
+} BadKbBtConfig;
+
+struct BadKbApp {
+    Gui* gui;
+    ViewDispatcher* view_dispatcher;
+    SceneManager* scene_manager;
+    NotificationApp* notifications;
+    DialogsApp* dialogs;
+    Widget* widget;
+    VariableItemList* var_item_list_bt;
+    VariableItemList* var_item_list_usb;
+
+    Bt* bt;
+    TextInput* text_input;
+    ByteInput* byte_input;
+    uint8_t mac[BAD_KB_MAC_ADDRESS_LEN];
+    char name[BAD_KB_ADV_NAME_MAX_LEN + 1];
+    BadKbBtConfig bt_old_config;
+
+    BadKbAppError error;
+    FuriString* file_path;
+    FuriString* keyboard_layout;
+    BadKb* bad_kb_view;
+    BadKbScript* bad_kb_script;
+
+    bool is_bt;
+};
+
+typedef enum {
+    BadKbAppViewError,
+    BadKbAppViewWork,
+    BadKbAppViewConfigBt,
+    BadKbAppViewConfigUsb,
+    BadKbAppViewConfigMac,
+    BadKbAppViewConfigName
+} BadKbAppView;

applications/main/bad_kb/bad_kb_script.c

@@ -0,0 +1,978 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <lib/toolbox/args.h>
+#include <furi_hal_bt_hid.h>
+#include <furi_hal_usb_hid.h>
+#include <storage/storage.h>
+#include "bad_kb_script.h"
+#include <dolphin/dolphin.h>
+
+#include <bt/bt_service/bt.h>
+
+#define HID_BT_KEYS_STORAGE_PATH EXT_PATH("apps/Tools/.bt_hid.keys")
+
+#define TAG "BadKB"
+#define WORKER_TAG TAG "Worker"
+#define FILE_BUFFER_LEN 16
+
+#define SCRIPT_STATE_ERROR (-1)
+#define SCRIPT_STATE_END (-2)
+#define SCRIPT_STATE_NEXT_LINE (-3)
+
+#define BADKB_ASCII_TO_KEY(script, x) \
+    (((uint8_t)x < 128) ? (script->layout[(uint8_t)x]) : HID_KEYBOARD_NONE)
+
+typedef enum {
+    WorkerEvtToggle = (1 << 0),
+    WorkerEvtEnd = (1 << 1),
+    WorkerEvtConnect = (1 << 2),
+    WorkerEvtDisconnect = (1 << 3),
+} WorkerEvtFlags;
+
+typedef enum {
+    LevelRssi122_100,
+    LevelRssi99_80,
+    LevelRssi79_60,
+    LevelRssi59_40,
+    LevelRssi39_0,
+    LevelRssiNum,
+    LevelRssiError = 0xFF,
+} LevelRssiRange;
+
+typedef enum {
+    BadKbConnectionModeNone,
+    BadKbConnectionModeUsb,
+    BadKbConnectionModeBt,
+} BadKbConnectionMode;
+
+/**
+ * Delays for waiting between HID key press and key release
+*/
+const uint8_t bt_hid_delays[LevelRssiNum] = {
+    30, // LevelRssi122_100
+    25, // LevelRssi99_80
+    20, // LevelRssi79_60
+    17, // LevelRssi59_40
+    14, // LevelRssi39_0
+};
+
+struct BadKbScript {
+    FuriHalUsbHidConfig hid_cfg;
+    BadKbState st;
+    FuriString* file_path;
+    FuriString* keyboard_layout;
+    uint32_t defdelay;
+    uint16_t layout[128];
+    FuriThread* thread;
+    uint8_t file_buf[FILE_BUFFER_LEN + 1];
+    uint8_t buf_start;
+    uint8_t buf_len;
+    bool file_end;
+    FuriString* line;
+
+    FuriString* line_prev;
+    uint32_t repeat_cnt;
+
+    Bt* bt;
+};
+
+typedef struct {
+    char* name;
+    uint16_t keycode;
+} DuckyKey;
+
+static const DuckyKey ducky_keys[] = {
+    {"CTRL-ALT", KEY_MOD_LEFT_CTRL | KEY_MOD_LEFT_ALT},
+    {"CTRL-SHIFT", KEY_MOD_LEFT_CTRL | KEY_MOD_LEFT_SHIFT},
+    {"ALT-SHIFT", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_SHIFT},
+    {"ALT-GUI", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_GUI},
+    {"GUI-SHIFT", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_SHIFT},
+    {"GUI-CTRL", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_CTRL},
+
+    {"CTRL", KEY_MOD_LEFT_CTRL},
+    {"CONTROL", KEY_MOD_LEFT_CTRL},
+    {"SHIFT", KEY_MOD_LEFT_SHIFT},
+    {"ALT", KEY_MOD_LEFT_ALT},
+    {"GUI", KEY_MOD_LEFT_GUI},
+    {"WINDOWS", KEY_MOD_LEFT_GUI},
+
+    {"DOWNARROW", HID_KEYBOARD_DOWN_ARROW},
+    {"DOWN", HID_KEYBOARD_DOWN_ARROW},
+    {"LEFTARROW", HID_KEYBOARD_LEFT_ARROW},
+    {"LEFT", HID_KEYBOARD_LEFT_ARROW},
+    {"RIGHTARROW", HID_KEYBOARD_RIGHT_ARROW},
+    {"RIGHT", HID_KEYBOARD_RIGHT_ARROW},
+    {"UPARROW", HID_KEYBOARD_UP_ARROW},
+    {"UP", HID_KEYBOARD_UP_ARROW},
+
+    {"ENTER", HID_KEYBOARD_RETURN},
+    {"BREAK", HID_KEYBOARD_PAUSE},
+    {"PAUSE", HID_KEYBOARD_PAUSE},
+    {"CAPSLOCK", HID_KEYBOARD_CAPS_LOCK},
+    {"DELETE", HID_KEYBOARD_DELETE},
+    {"BACKSPACE", HID_KEYPAD_BACKSPACE},
+    {"END", HID_KEYBOARD_END},
+    {"ESC", HID_KEYBOARD_ESCAPE},
+    {"ESCAPE", HID_KEYBOARD_ESCAPE},
+    {"HOME", HID_KEYBOARD_HOME},
+    {"INSERT", HID_KEYBOARD_INSERT},
+    {"NUMLOCK", HID_KEYPAD_NUMLOCK},
+    {"PAGEUP", HID_KEYBOARD_PAGE_UP},
+    {"PAGEDOWN", HID_KEYBOARD_PAGE_DOWN},
+    {"PRINTSCREEN", HID_KEYBOARD_PRINT_SCREEN},
+    {"SCROLLLOCK", HID_KEYBOARD_SCROLL_LOCK},
+    {"SPACE", HID_KEYBOARD_SPACEBAR},
+    {"TAB", HID_KEYBOARD_TAB},
+    {"MENU", HID_KEYBOARD_APPLICATION},
+    {"APP", HID_KEYBOARD_APPLICATION},
+
+    {"F1", HID_KEYBOARD_F1},
+    {"F2", HID_KEYBOARD_F2},
+    {"F3", HID_KEYBOARD_F3},
+    {"F4", HID_KEYBOARD_F4},
+    {"F5", HID_KEYBOARD_F5},
+    {"F6", HID_KEYBOARD_F6},
+    {"F7", HID_KEYBOARD_F7},
+    {"F8", HID_KEYBOARD_F8},
+    {"F9", HID_KEYBOARD_F9},
+    {"F10", HID_KEYBOARD_F10},
+    {"F11", HID_KEYBOARD_F11},
+    {"F12", HID_KEYBOARD_F12},
+};
+
+static const char ducky_cmd_comment[] = {"REM"};
+static const char ducky_cmd_id[] = {"ID"};
+static const char ducky_cmd_delay[] = {"DELAY "};
+static const char ducky_cmd_string[] = {"STRING "};
+static const char ducky_cmd_defdelay_1[] = {"DEFAULT_DELAY "};
+static const char ducky_cmd_defdelay_2[] = {"DEFAULTDELAY "};
+static const char ducky_cmd_repeat[] = {"REPEAT "};
+static const char ducky_cmd_sysrq[] = {"SYSRQ "};
+
+static const char ducky_cmd_altchar[] = {"ALTCHAR "};
+static const char ducky_cmd_altstr_1[] = {"ALTSTRING "};
+static const char ducky_cmd_altstr_2[] = {"ALTCODE "};
+
+static const char ducky_cmd_lang[] = {"DUCKY_LANG"};
+
+static const uint8_t numpad_keys[10] = {
+    HID_KEYPAD_0,
+    HID_KEYPAD_1,
+    HID_KEYPAD_2,
+    HID_KEYPAD_3,
+    HID_KEYPAD_4,
+    HID_KEYPAD_5,
+    HID_KEYPAD_6,
+    HID_KEYPAD_7,
+    HID_KEYPAD_8,
+    HID_KEYPAD_9,
+};
+
+BadKbConnectionMode connection_mode = BadKbConnectionModeNone;
+FuriHalUsbInterface* usb_mode_prev = NULL;
+GapPairing bt_mode_prev = GapPairingNone;
+bool bt_connected = false;
+bool usb_connected = false;
+uint8_t bt_timeout = 0;
+
+static LevelRssiRange bt_remote_rssi_range(Bt* bt) {
+    BtRssi rssi_data = {0};
+
+    if(!bt_remote_rssi(bt, &rssi_data)) return LevelRssiError;
+
+    if(rssi_data.rssi <= 39)
+        return LevelRssi39_0;
+    else if(rssi_data.rssi <= 59)
+        return LevelRssi59_40;
+    else if(rssi_data.rssi <= 79)
+        return LevelRssi79_60;
+    else if(rssi_data.rssi <= 99)
+        return LevelRssi99_80;
+    else if(rssi_data.rssi <= 122)
+        return LevelRssi122_100;
+
+    return LevelRssiError;
+}
+
+static inline void update_bt_timeout(Bt* bt) {
+    LevelRssiRange r = bt_remote_rssi_range(bt);
+    if(r < LevelRssiNum) {
+        bt_timeout = bt_hid_delays[r];
+        FURI_LOG_D(WORKER_TAG, "BLE Key timeout : %u", bt_timeout);
+    }
+}
+
+static bool ducky_get_number(const char* param, uint32_t* val) {
+    uint32_t value = 0;
+    if(sscanf(param, "%lu", &value) == 1) {
+        *val = value;
+        return true;
+    }
+    return false;
+}
+
+static uint32_t ducky_get_command_len(const char* line) {
+    uint32_t len = strlen(line);
+    for(uint32_t i = 0; i < len; i++) {
+        if(line[i] == ' ') return i;
+    }
+    return 0;
+}
+
+static bool ducky_is_line_end(const char chr) {
+    return ((chr == ' ') || (chr == '\0') || (chr == '\r') || (chr == '\n'));
+}
+
+static void ducky_numlock_on(BadKbScript* bad_kb) {
+    if(bad_kb->bt) {
+        if((furi_hal_bt_hid_get_led_state() & HID_KB_LED_NUM) == 0) { // FIXME
+            furi_hal_bt_hid_kb_press(HID_KEYBOARD_LOCK_NUM_LOCK);
+            furi_delay_ms(bt_timeout);
+            furi_hal_bt_hid_kb_release(HID_KEYBOARD_LOCK_NUM_LOCK);
+        }
+    } else {
+        if((furi_hal_hid_get_led_state() & HID_KB_LED_NUM) == 0) {
+            furi_hal_hid_kb_press(HID_KEYBOARD_LOCK_NUM_LOCK);
+            furi_hal_hid_kb_release(HID_KEYBOARD_LOCK_NUM_LOCK);
+        }
+    }
+}
+
+static bool ducky_numpad_press(BadKbScript* bad_kb, const char num) {
+    if((num < '0') || (num > '9')) return false;
+
+    uint16_t key = numpad_keys[num - '0'];
+    if(bad_kb->bt) {
+        furi_hal_bt_hid_kb_press(key);
+        furi_delay_ms(bt_timeout);
+        furi_hal_bt_hid_kb_release(key);
+    } else {
+        furi_hal_hid_kb_press(key);
+        furi_hal_hid_kb_release(key);
+    }
+
+    return true;
+}
+
+static bool ducky_altchar(BadKbScript* bad_kb, const char* charcode) {
+    uint8_t i = 0;
+    bool state = false;
+
+    FURI_LOG_I(WORKER_TAG, "char %s", charcode);
+
+    if(bad_kb->bt) {
+        furi_hal_bt_hid_kb_press(KEY_MOD_LEFT_ALT);
+    } else {
+        furi_hal_hid_kb_press(KEY_MOD_LEFT_ALT);
+    }
+
+    while(!ducky_is_line_end(charcode[i])) {
+        state = ducky_numpad_press(bad_kb, charcode[i]);
+        if(state == false) break;
+        i++;
+    }
+
+    if(bad_kb->bt) {
+        furi_hal_bt_hid_kb_release(KEY_MOD_LEFT_ALT);
+    } else {
+        furi_hal_hid_kb_release(KEY_MOD_LEFT_ALT);
+    }
+    return state;
+}
+
+static bool ducky_altstring(BadKbScript* bad_kb, const char* param) {
+    uint32_t i = 0;
+    bool state = false;
+
+    while(param[i] != '\0') {
+        if((param[i] < ' ') || (param[i] > '~')) {
+            i++;
+            continue; // Skip non-printable chars
+        }
+
+        char temp_str[4];
+        snprintf(temp_str, 4, "%u", param[i]);
+
+        state = ducky_altchar(bad_kb, temp_str);
+        if(state == false) break;
+        i++;
+    }
+    return state;
+}
+
+static bool ducky_string(BadKbScript* bad_kb, const char* param) {
+    uint32_t i = 0;
+    while(param[i] != '\0') {
+        uint16_t keycode = BADKB_ASCII_TO_KEY(bad_kb, param[i]);
+        if(keycode != HID_KEYBOARD_NONE) {
+            if(bad_kb->bt) {
+                furi_hal_bt_hid_kb_press(keycode);
+                furi_delay_ms(bt_timeout);
+                furi_hal_bt_hid_kb_release(keycode);
+            } else {
+                furi_hal_hid_kb_press(keycode);
+                furi_hal_hid_kb_release(keycode);
+            }
+        }
+        i++;
+    }
+    return true;
+}
+
+static uint16_t ducky_get_keycode(BadKbScript* bad_kb, const char* param, bool accept_chars) {
+    for(size_t i = 0; i < (sizeof(ducky_keys) / sizeof(ducky_keys[0])); i++) {
+        size_t key_cmd_len = strlen(ducky_keys[i].name);
+        if((strncmp(param, ducky_keys[i].name, key_cmd_len) == 0) &&
+           (ducky_is_line_end(param[key_cmd_len]))) {
+            return ducky_keys[i].keycode;
+        }
+    }
+    if((accept_chars) && (strlen(param) > 0)) {
+        return (BADKB_ASCII_TO_KEY(bad_kb, param[0]) & 0xFF);
+    }
+    return 0;
+}
+
+static int32_t
+    ducky_parse_line(BadKbScript* bad_kb, FuriString* line, char* error, size_t error_len) {
+    uint32_t line_len = furi_string_size(line);
+    const char* line_tmp = furi_string_get_cstr(line);
+    bool state = false;
+
+    if(line_len == 0) {
+        return SCRIPT_STATE_NEXT_LINE; // Skip empty lines
+    }
+
+    FURI_LOG_D(WORKER_TAG, "line:%s", line_tmp);
+
+    // General commands
+    if(strncmp(line_tmp, ducky_cmd_comment, strlen(ducky_cmd_comment)) == 0) {
+        // REM - comment line
+        return (0);
+    } else if(strncmp(line_tmp, ducky_cmd_id, strlen(ducky_cmd_id)) == 0) {
+        // ID - executed in ducky_script_preload
+        return (0);
+    } else if(strncmp(line_tmp, ducky_cmd_lang, strlen(ducky_cmd_lang)) == 0) {
+        // DUCKY_LANG - ignore command to retain compatibility with existing scripts
+        return (0);
+    } else if(strncmp(line_tmp, ducky_cmd_delay, strlen(ducky_cmd_delay)) == 0) {
+        // DELAY
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        uint32_t delay_val = 0;
+        state = ducky_get_number(line_tmp, &delay_val);
+        if((state) && (delay_val > 0)) {
+            return (int32_t)delay_val;
+        }
+        if(error != NULL) {
+            snprintf(error, error_len, "Invalid number %s", line_tmp);
+        }
+        return SCRIPT_STATE_ERROR;
+    } else if(
+        (strncmp(line_tmp, ducky_cmd_defdelay_1, strlen(ducky_cmd_defdelay_1)) == 0) ||
+        (strncmp(line_tmp, ducky_cmd_defdelay_2, strlen(ducky_cmd_defdelay_2)) == 0)) {
+        // DEFAULT_DELAY
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        state = ducky_get_number(line_tmp, &bad_kb->defdelay);
+        if(!state && error != NULL) {
+            snprintf(error, error_len, "Invalid number %s", line_tmp);
+        }
+        return (state) ? (0) : SCRIPT_STATE_ERROR;
+    } else if(strncmp(line_tmp, ducky_cmd_string, strlen(ducky_cmd_string)) == 0) {
+        // STRING
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        state = ducky_string(bad_kb, line_tmp);
+        if(!state && error != NULL) {
+            snprintf(error, error_len, "Invalid string %s", line_tmp);
+        }
+        return (state) ? (0) : SCRIPT_STATE_ERROR;
+    } else if(strncmp(line_tmp, ducky_cmd_altchar, strlen(ducky_cmd_altchar)) == 0) {
+        // ALTCHAR
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        ducky_numlock_on(bad_kb);
+        state = ducky_altchar(bad_kb, line_tmp);
+        if(!state && error != NULL) {
+            snprintf(error, error_len, "Invalid altchar %s", line_tmp);
+        }
+        return (state) ? (0) : SCRIPT_STATE_ERROR;
+    } else if(
+        (strncmp(line_tmp, ducky_cmd_altstr_1, strlen(ducky_cmd_altstr_1)) == 0) ||
+        (strncmp(line_tmp, ducky_cmd_altstr_2, strlen(ducky_cmd_altstr_2)) == 0)) {
+        // ALTSTRING
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        ducky_numlock_on(bad_kb);
+        state = ducky_altstring(bad_kb, line_tmp);
+        if(!state && error != NULL) {
+            snprintf(error, error_len, "Invalid altstring %s", line_tmp);
+        }
+        return (state) ? (0) : SCRIPT_STATE_ERROR;
+    } else if(strncmp(line_tmp, ducky_cmd_repeat, strlen(ducky_cmd_repeat)) == 0) {
+        // REPEAT
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        state = ducky_get_number(line_tmp, &bad_kb->repeat_cnt);
+        if(!state && error != NULL) {
+            snprintf(error, error_len, "Invalid number %s", line_tmp);
+        }
+        return (state) ? (0) : SCRIPT_STATE_ERROR;
+    } else if(strncmp(line_tmp, ducky_cmd_sysrq, strlen(ducky_cmd_sysrq)) == 0) {
+        // SYSRQ
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        uint16_t key = ducky_get_keycode(bad_kb, line_tmp, true);
+        if(bad_kb->bt) {
+            furi_hal_bt_hid_kb_press(KEY_MOD_LEFT_ALT | HID_KEYBOARD_PRINT_SCREEN);
+            furi_hal_bt_hid_kb_press(key);
+            furi_delay_ms(bt_timeout);
+            furi_hal_bt_hid_kb_release(key);
+            furi_hal_bt_hid_kb_release(KEY_MOD_LEFT_ALT | HID_KEYBOARD_PRINT_SCREEN);
+        } else {
+            furi_hal_hid_kb_press(KEY_MOD_LEFT_ALT | HID_KEYBOARD_PRINT_SCREEN);
+            furi_hal_hid_kb_press(key);
+            furi_hal_hid_kb_release_all();
+        }
+        return (0);
+    } else {
+        // Special keys + modifiers
+        uint16_t key = ducky_get_keycode(bad_kb, line_tmp, false);
+        if(key == HID_KEYBOARD_NONE) {
+            if(error != NULL) {
+                snprintf(error, error_len, "No keycode defined for %s", line_tmp);
+            }
+            return SCRIPT_STATE_ERROR;
+        }
+        if((key & 0xFF00) != 0) {
+            // It's a modifier key
+            line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+            key |= ducky_get_keycode(bad_kb, line_tmp, true);
+        }
+        if(bad_kb->bt) {
+            furi_hal_bt_hid_kb_press(key);
+            furi_delay_ms(bt_timeout);
+            furi_hal_bt_hid_kb_release(key);
+        } else {
+            furi_hal_hid_kb_press(key);
+            furi_hal_hid_kb_release(key);
+        }
+        return (0);
+    }
+}
+
+static bool ducky_set_usb_id(BadKbScript* bad_kb, const char* line) {
+    if(sscanf(line, "%lX:%lX", &bad_kb->hid_cfg.vid, &bad_kb->hid_cfg.pid) == 2) {
+        bad_kb->hid_cfg.manuf[0] = '\0';
+        bad_kb->hid_cfg.product[0] = '\0';
+
+        uint8_t id_len = ducky_get_command_len(line);
+        if(!ducky_is_line_end(line[id_len + 1])) {
+            sscanf(
+                &line[id_len + 1],
+                "%31[^\r\n:]:%31[^\r\n]",
+                bad_kb->hid_cfg.manuf,
+                bad_kb->hid_cfg.product);
+        }
+        FURI_LOG_D(
+            WORKER_TAG,
+            "set id: %04lX:%04lX mfr:%s product:%s",
+            bad_kb->hid_cfg.vid,
+            bad_kb->hid_cfg.pid,
+            bad_kb->hid_cfg.manuf,
+            bad_kb->hid_cfg.product);
+        return true;
+    }
+    return false;
+}
+
+static bool ducky_script_preload(BadKbScript* bad_kb, File* script_file) {
+    uint8_t ret = 0;
+    uint32_t line_len = 0;
+
+    furi_string_reset(bad_kb->line);
+
+    do {
+        ret = storage_file_read(script_file, bad_kb->file_buf, FILE_BUFFER_LEN);
+        for(uint16_t i = 0; i < ret; i++) {
+            if(bad_kb->file_buf[i] == '\n' && line_len > 0) {
+                bad_kb->st.line_nb++;
+                line_len = 0;
+            } else {
+                if(bad_kb->st.line_nb == 0) { // Save first line
+                    furi_string_push_back(bad_kb->line, bad_kb->file_buf[i]);
+                }
+                line_len++;
+            }
+        }
+        if(storage_file_eof(script_file)) {
+            if(line_len > 0) {
+                bad_kb->st.line_nb++;
+                break;
+            }
+        }
+    } while(ret > 0);
+
+    if(!bad_kb->bt) {
+        const char* line_tmp = furi_string_get_cstr(bad_kb->line);
+        bool id_set = false; // Looking for ID command at first line
+        if(strncmp(line_tmp, ducky_cmd_id, strlen(ducky_cmd_id)) == 0) {
+            id_set = ducky_set_usb_id(bad_kb, &line_tmp[strlen(ducky_cmd_id) + 1]);
+        }
+
+        if(id_set) {
+            furi_check(furi_hal_usb_set_config(&usb_hid, &bad_kb->hid_cfg));
+        } else {
+            furi_check(furi_hal_usb_set_config(&usb_hid, NULL));
+        }
+    }
+
+    storage_file_seek(script_file, 0, true);
+    furi_string_reset(bad_kb->line);
+
+    return true;
+}
+
+static int32_t ducky_script_execute_next(BadKbScript* bad_kb, File* script_file) {
+    int32_t delay_val = 0;
+
+    if(bad_kb->repeat_cnt > 0) {
+        bad_kb->repeat_cnt--;
+        delay_val = ducky_parse_line(
+            bad_kb, bad_kb->line_prev, bad_kb->st.error, sizeof(bad_kb->st.error));
+        if(delay_val == SCRIPT_STATE_NEXT_LINE) { // Empty line
+            return 0;
+        } else if(delay_val < 0) { // Script error
+            bad_kb->st.error_line = bad_kb->st.line_cur - 1;
+            FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_kb->st.line_cur - 1U);
+            return SCRIPT_STATE_ERROR;
+        } else {
+            return (delay_val + bad_kb->defdelay);
+        }
+    }
+
+    furi_string_set(bad_kb->line_prev, bad_kb->line);
+    furi_string_reset(bad_kb->line);
+
+    while(1) {
+        if(bad_kb->buf_len == 0) {
+            bad_kb->buf_len = storage_file_read(script_file, bad_kb->file_buf, FILE_BUFFER_LEN);
+            if(storage_file_eof(script_file)) {
+                if((bad_kb->buf_len < FILE_BUFFER_LEN) && (bad_kb->file_end == false)) {
+                    bad_kb->file_buf[bad_kb->buf_len] = '\n';
+                    bad_kb->buf_len++;
+                    bad_kb->file_end = true;
+                }
+            }
+
+            bad_kb->buf_start = 0;
+            if(bad_kb->buf_len == 0) return SCRIPT_STATE_END;
+        }
+        for(uint8_t i = bad_kb->buf_start; i < (bad_kb->buf_start + bad_kb->buf_len); i++) {
+            if(bad_kb->file_buf[i] == '\n' && furi_string_size(bad_kb->line) > 0) {
+                bad_kb->st.line_cur++;
+                bad_kb->buf_len = bad_kb->buf_len + bad_kb->buf_start - (i + 1);
+                bad_kb->buf_start = i + 1;
+                furi_string_trim(bad_kb->line);
+                delay_val = ducky_parse_line(
+                    bad_kb, bad_kb->line, bad_kb->st.error, sizeof(bad_kb->st.error));
+                if(delay_val == SCRIPT_STATE_NEXT_LINE) { // Empty line
+                    return 0;
+                } else if(delay_val < 0) {
+                    bad_kb->st.error_line = bad_kb->st.line_cur;
+                    if(delay_val == SCRIPT_STATE_NEXT_LINE) {
+                        snprintf(
+                            bad_kb->st.error, sizeof(bad_kb->st.error), "Forbidden empty line");
+                        FURI_LOG_E(
+                            WORKER_TAG, "Forbidden empty line at line %u", bad_kb->st.line_cur);
+                    } else {
+                        FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_kb->st.line_cur);
+                    }
+                    return SCRIPT_STATE_ERROR;
+                } else {
+                    return (delay_val + bad_kb->defdelay);
+                }
+            } else {
+                furi_string_push_back(bad_kb->line, bad_kb->file_buf[i]);
+            }
+        }
+        bad_kb->buf_len = 0;
+        if(bad_kb->file_end) return SCRIPT_STATE_END;
+    }
+
+    return 0;
+}
+
+static void bad_kb_bt_hid_state_callback(BtStatus status, void* context) {
+    furi_assert(context);
+    BadKbScript* bad_kb = (BadKbScript*)context;
+    bool state = (status == BtStatusConnected);
+
+    if(state == true) {
+        LevelRssiRange r = bt_remote_rssi_range(bad_kb->bt);
+        if(r != LevelRssiError) {
+            bt_timeout = bt_hid_delays[r];
+        }
+        bt_connected = true;
+        furi_thread_flags_set(furi_thread_get_id(bad_kb->thread), WorkerEvtConnect);
+    } else {
+        bt_connected = false;
+        furi_thread_flags_set(furi_thread_get_id(bad_kb->thread), WorkerEvtDisconnect);
+    }
+}
+
+static void bad_kb_usb_hid_state_callback(bool state, void* context) {
+    furi_assert(context);
+    BadKbScript* bad_kb = context;
+
+    if(state == true) {
+        usb_connected = true;
+        furi_thread_flags_set(furi_thread_get_id(bad_kb->thread), WorkerEvtConnect);
+    } else {
+        usb_connected = false;
+        furi_thread_flags_set(furi_thread_get_id(bad_kb->thread), WorkerEvtDisconnect);
+    }
+}
+
+void bad_kb_bt_init(Bt* bt) {
+    bt_timeout = bt_hid_delays[LevelRssi39_0];
+    bt_disconnect(bt);
+    furi_delay_ms(200);
+    bt_keys_storage_set_storage_path(bt, HID_BT_KEYS_STORAGE_PATH);
+    furi_assert(bt_set_profile(bt, BtProfileHidKeyboard));
+    bt_mode_prev = bt_get_profile_pairing_method(bt);
+    bt_set_profile_pairing_method(bt, GapPairingNone);
+    furi_hal_bt_start_advertising();
+    // disable peer key adding to bt SRAM storage
+    bt_disable_peer_key_update(bt);
+
+    connection_mode = BadKbConnectionModeBt;
+}
+
+void bad_kb_bt_deinit(Bt* bt) {
+    // release all keys
+    // bt_hid_hold_while_keyboard_buffer_full(6, 3000);
+
+    // stop ble
+    bt_disconnect(bt);
+
+    // Wait 2nd core to update nvm storage
+    furi_delay_ms(200);
+
+    bt_keys_storage_set_default_path(bt);
+
+    bt_set_profile_pairing_method(bt, bt_mode_prev);
+
+    // fails if ble radio stack isn't ready when switching profile
+    // if it happens, maybe we should increase the delay after bt_disconnect
+    bt_set_profile(bt, BtProfileSerial);
+
+    // starts saving peer keys (bounded devices)
+    bt_enable_peer_key_update(bt);
+
+    connection_mode = BadKbConnectionModeNone;
+}
+
+void bad_kb_usb_init() {
+    usb_mode_prev = furi_hal_usb_get_config();
+
+    connection_mode = BadKbConnectionModeUsb;
+}
+
+void bad_kb_usb_deinit() {
+    furi_hal_usb_set_config(usb_mode_prev, NULL);
+
+    connection_mode = BadKbConnectionModeNone;
+}
+
+void bad_kb_connection_init(Bt* bt) {
+    if(connection_mode != BadKbConnectionModeNone) return;
+
+    if(bt) {
+        bad_kb_bt_init(bt);
+    } else {
+        bad_kb_usb_init();
+    }
+}
+
+void bad_kb_connection_deinit(Bt* bt) {
+    if(connection_mode == BadKbConnectionModeNone) return;
+
+    if(connection_mode == BadKbConnectionModeBt) {
+        bad_kb_bt_deinit(bt);
+    } else {
+        bad_kb_usb_deinit();
+    }
+}
+
+static int32_t bad_kb_worker(void* context) {
+    BadKbScript* bad_kb = context;
+
+    BadKbWorkerState worker_state = BadKbStateInit;
+    int32_t delay_val = 0;
+
+    bad_kb_connection_init(bad_kb->bt);
+
+    if(bad_kb->bt) {
+        bt_set_status_changed_callback(bad_kb->bt, bad_kb_bt_hid_state_callback, bad_kb);
+    } else {
+        furi_hal_hid_set_state_callback(bad_kb_usb_hid_state_callback, bad_kb);
+    }
+
+    FURI_LOG_I(WORKER_TAG, "Init");
+    File* script_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
+    bad_kb->line = furi_string_alloc();
+    bad_kb->line_prev = furi_string_alloc();
+
+    while(1) {
+        if(worker_state == BadKbStateInit) { // State: initialization
+            if(storage_file_open(
+                   script_file,
+                   furi_string_get_cstr(bad_kb->file_path),
+                   FSAM_READ,
+                   FSOM_OPEN_EXISTING)) {
+                if((ducky_script_preload(bad_kb, script_file)) && (bad_kb->st.line_nb > 0)) {
+                    if(bad_kb->bt) {
+                        worker_state = BadKbStateNotConnected; // Ready to run
+                    } else {
+                        if(furi_hal_hid_is_connected()) {
+                            worker_state = BadKbStateIdle; // Ready to run
+                        } else {
+                            worker_state = BadKbStateNotConnected; // Not connected
+                        }
+                    }
+                } else {
+                    worker_state = BadKbStateScriptError; // Script preload error
+                }
+            } else {
+                FURI_LOG_E(WORKER_TAG, "File open error");
+                worker_state = BadKbStateFileError; // File open error
+            }
+            bad_kb->st.state = worker_state;
+
+        } else if(worker_state == BadKbStateNotConnected) { // State: Not connected
+            if((bad_kb->bt && bt_connected) || (!bad_kb->bt && usb_connected)) {
+                worker_state = BadKbStateIdle; // Ready to run
+            } else {
+                uint32_t flags = furi_thread_flags_wait(
+                    WorkerEvtEnd | WorkerEvtConnect | WorkerEvtToggle,
+                    FuriFlagWaitAny,
+                    FuriWaitForever);
+                furi_check((flags & FuriFlagError) == 0);
+                if(flags & WorkerEvtEnd) {
+                    break;
+                } else if(flags & WorkerEvtConnect) {
+                    worker_state = BadKbStateIdle; // Ready to run
+                } else if(flags & WorkerEvtToggle) {
+                    worker_state = BadKbStateWillRun; // Will run when connected
+                }
+            }
+            bad_kb->st.state = worker_state;
+
+        } else if(worker_state == BadKbStateIdle) { // State: ready to start
+            uint32_t flags = furi_thread_flags_wait(
+                WorkerEvtEnd | WorkerEvtToggle | WorkerEvtDisconnect,
+                FuriFlagWaitAny,
+                FuriWaitForever);
+            furi_check((flags & FuriFlagError) == 0);
+            if(flags & WorkerEvtEnd) {
+                break;
+            } else if(flags & WorkerEvtToggle) { // Start executing script
+                DOLPHIN_DEED(DolphinDeedBadKbPlayScript);
+                delay_val = 0;
+                bad_kb->buf_len = 0;
+                bad_kb->st.line_cur = 0;
+                bad_kb->defdelay = 0;
+                bad_kb->repeat_cnt = 0;
+                bad_kb->file_end = false;
+                storage_file_seek(script_file, 0, true);
+                bad_kb_script_set_keyboard_layout(bad_kb, bad_kb->keyboard_layout);
+                worker_state = BadKbStateRunning;
+            } else if(flags & WorkerEvtDisconnect) {
+                worker_state = BadKbStateNotConnected; // Disconnected
+            }
+            bad_kb->st.state = worker_state;
+
+        } else if(worker_state == BadKbStateWillRun) { // State: start on connection
+            uint32_t flags = furi_thread_flags_wait(
+                WorkerEvtEnd | WorkerEvtConnect | WorkerEvtToggle,
+                FuriFlagWaitAny,
+                FuriWaitForever);
+            furi_check((flags & FuriFlagError) == 0);
+            if(flags & WorkerEvtEnd) {
+                break;
+            } else if(flags & WorkerEvtConnect) { // Start executing script
+                DOLPHIN_DEED(DolphinDeedBadKbPlayScript);
+                delay_val = 0;
+                bad_kb->buf_len = 0;
+                bad_kb->st.line_cur = 0;
+                bad_kb->defdelay = 0;
+                bad_kb->repeat_cnt = 0;
+                bad_kb->file_end = false;
+                storage_file_seek(script_file, 0, true);
+                // extra time for PC to recognize Flipper as keyboard
+                furi_thread_flags_wait(0, FuriFlagWaitAny, 1500);
+                if(bad_kb->bt) {
+                    update_bt_timeout(bad_kb->bt);
+                }
+                bad_kb_script_set_keyboard_layout(bad_kb, bad_kb->keyboard_layout);
+                worker_state = BadKbStateRunning;
+            } else if(flags & WorkerEvtToggle) { // Cancel scheduled execution
+                worker_state = BadKbStateNotConnected;
+            }
+            bad_kb->st.state = worker_state;
+
+        } else if(worker_state == BadKbStateRunning) { // State: running
+            uint16_t delay_cur = (delay_val > 1000) ? (1000) : (delay_val);
+            uint32_t flags = furi_thread_flags_wait(
+                WorkerEvtEnd | WorkerEvtToggle | WorkerEvtDisconnect, FuriFlagWaitAny, delay_cur);
+            delay_val -= delay_cur;
+            if(!(flags & FuriFlagError)) {
+                if(flags & WorkerEvtEnd) {
+                    break;
+                } else if(flags & WorkerEvtToggle) {
+                    worker_state = BadKbStateIdle; // Stop executing script
+                    if(bad_kb->bt) {
+                        furi_hal_bt_hid_kb_release_all();
+                    } else {
+                        furi_hal_hid_kb_release_all();
+                    }
+                } else if(flags & WorkerEvtDisconnect) {
+                    worker_state = BadKbStateNotConnected; // Disconnected
+                    if(bad_kb->bt) {
+                        furi_hal_bt_hid_kb_release_all();
+                    } else {
+                        furi_hal_hid_kb_release_all();
+                    }
+                }
+                bad_kb->st.state = worker_state;
+                continue;
+            } else if(
+                (flags == (unsigned)FuriFlagErrorTimeout) ||
+                (flags == (unsigned)FuriFlagErrorResource)) {
+                if(delay_val > 0) {
+                    bad_kb->st.delay_remain--;
+                    continue;
+                }
+                bad_kb->st.state = BadKbStateRunning;
+                delay_val = ducky_script_execute_next(bad_kb, script_file);
+                if(delay_val == SCRIPT_STATE_ERROR) { // Script error
+                    delay_val = 0;
+                    worker_state = BadKbStateScriptError;
+                    bad_kb->st.state = worker_state;
+                } else if(delay_val == SCRIPT_STATE_END) { // End of script
+                    delay_val = 0;
+                    worker_state = BadKbStateIdle;
+                    bad_kb->st.state = BadKbStateDone;
+                    if(bad_kb->bt) {
+                        furi_hal_bt_hid_kb_release_all();
+                    } else {
+                        furi_hal_hid_kb_release_all();
+                    }
+                    continue;
+                } else if(delay_val > 1000) {
+                    bad_kb->st.state = BadKbStateDelay; // Show long delays
+                    bad_kb->st.delay_remain = delay_val / 1000;
+                }
+            } else {
+                furi_check((flags & FuriFlagError) == 0);
+            }
+
+        } else if(
+            (worker_state == BadKbStateFileError) ||
+            (worker_state == BadKbStateScriptError)) { // State: error
+            uint32_t flags = furi_thread_flags_wait(
+                WorkerEvtEnd, FuriFlagWaitAny, FuriWaitForever); // Waiting for exit command
+            furi_check((flags & FuriFlagError) == 0);
+            if(flags & WorkerEvtEnd) {
+                break;
+            }
+        }
+        if(bad_kb->bt) {
+            update_bt_timeout(bad_kb->bt);
+        }
+    }
+
+    if(bad_kb->bt) {
+        bt_set_status_changed_callback(bad_kb->bt, NULL, NULL);
+    } else {
+        furi_hal_hid_set_state_callback(NULL, NULL);
+    }
+
+    storage_file_close(script_file);
+    storage_file_free(script_file);
+    furi_string_free(bad_kb->line);
+    furi_string_free(bad_kb->line_prev);
+
+    FURI_LOG_I(WORKER_TAG, "End");
+
+    return 0;
+}
+
+static void bad_kb_script_set_default_keyboard_layout(BadKbScript* bad_kb) {
+    furi_assert(bad_kb);
+    furi_string_set_str(bad_kb->keyboard_layout, "");
+    memset(bad_kb->layout, HID_KEYBOARD_NONE, sizeof(bad_kb->layout));
+    memcpy(bad_kb->layout, hid_asciimap, MIN(sizeof(hid_asciimap), sizeof(bad_kb->layout)));
+}
+
+BadKbScript* bad_kb_script_open(FuriString* file_path, Bt* bt) {
+    furi_assert(file_path);
+
+    BadKbScript* bad_kb = malloc(sizeof(BadKbScript));
+    bad_kb->file_path = furi_string_alloc();
+    furi_string_set(bad_kb->file_path, file_path);
+    bad_kb->keyboard_layout = furi_string_alloc();
+    bad_kb_script_set_default_keyboard_layout(bad_kb);
+
+    bad_kb->st.state = BadKbStateInit;
+    bad_kb->st.error[0] = '\0';
+
+    bad_kb->bt = bt;
+
+    bad_kb->thread = furi_thread_alloc_ex("BadKbWorker", 2048, bad_kb_worker, bad_kb);
+    furi_thread_start(bad_kb->thread);
+    return bad_kb;
+} //-V773
+
+void bad_kb_script_close(BadKbScript* bad_kb) {
+    furi_assert(bad_kb);
+    furi_record_close(RECORD_STORAGE);
+    furi_thread_flags_set(furi_thread_get_id(bad_kb->thread), WorkerEvtEnd);
+    furi_thread_join(bad_kb->thread);
+    furi_thread_free(bad_kb->thread);
+    furi_string_free(bad_kb->file_path);
+    furi_string_free(bad_kb->keyboard_layout);
+    free(bad_kb);
+}
+
+void bad_kb_script_set_keyboard_layout(BadKbScript* bad_kb, FuriString* layout_path) {
+    furi_assert(bad_kb);
+
+    if((bad_kb->st.state == BadKbStateRunning) || (bad_kb->st.state == BadKbStateDelay)) {
+        // do not update keyboard layout while a script is running
+        return;
+    }
+
+    File* layout_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
+    if(!furi_string_empty(layout_path)) {
+        furi_string_set(bad_kb->keyboard_layout, layout_path);
+        if(storage_file_open(
+               layout_file, furi_string_get_cstr(layout_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+            uint16_t layout[128];
+            if(storage_file_read(layout_file, layout, sizeof(layout)) == sizeof(layout)) {
+                memcpy(bad_kb->layout, layout, sizeof(layout));
+            }
+        }
+        storage_file_close(layout_file);
+    } else {
+        bad_kb_script_set_default_keyboard_layout(bad_kb);
+    }
+    storage_file_free(layout_file);
+}
+
+void bad_kb_script_toggle(BadKbScript* bad_kb) {
+    furi_assert(bad_kb);
+    furi_thread_flags_set(furi_thread_get_id(bad_kb->thread), WorkerEvtToggle);
+}
+
+BadKbState* bad_kb_script_get_state(BadKbScript* bad_kb) {
+    furi_assert(bad_kb);
+    return &(bad_kb->st);
+}

applications/main/bad_kb/bad_kb_script.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <furi.h>
+#include <bt/bt_service/bt_i.h>
+
+typedef struct BadKbScript BadKbScript;
+
+typedef enum {
+    BadKbStateInit,
+    BadKbStateNotConnected,
+    BadKbStateIdle,
+    BadKbStateWillRun,
+    BadKbStateRunning,
+    BadKbStateDelay,
+    BadKbStateDone,
+    BadKbStateScriptError,
+    BadKbStateFileError,
+} BadKbWorkerState;
+
+typedef struct {
+    BadKbWorkerState state;
+    uint16_t line_cur;
+    uint16_t line_nb;
+    uint32_t delay_remain;
+    uint16_t error_line;
+    char error[64];
+} BadKbState;
+
+void bad_kb_connection_init(Bt* bt);
+
+void bad_kb_connection_deinit(Bt* bt);
+
+BadKbScript* bad_kb_script_open(FuriString* file_path, Bt* bt);
+
+void bad_kb_script_close(BadKbScript* bad_kb);
+
+void bad_kb_script_set_keyboard_layout(BadKbScript* bad_kb, FuriString* layout_path);
+
+void bad_kb_script_start(BadKbScript* bad_kb);
+
+void bad_kb_script_stop(BadKbScript* bad_kb);
+
+void bad_kb_script_toggle(BadKbScript* bad_kb);
+
+BadKbState* bad_kb_script_get_state(BadKbScript* bad_kb);
+
+#ifdef __cplusplus
+}
+#endif

applications/main/bad_kb/bad_kb_settings_filename.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define BAD_KB_SETTINGS_FILE_NAME ".badkb.settings"

applications/main/bad_kb/scenes/bad_kb_scene.c

@@ -0,0 +1,30 @@
+#include "bad_kb_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const bad_kb_scene_on_enter_handlers[])(void*) = {
+#include "bad_kb_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const bad_kb_scene_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "bad_kb_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const bad_kb_scene_on_exit_handlers[])(void* context) = {
+#include "bad_kb_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers bad_kb_scene_handlers = {
+    .on_enter_handlers = bad_kb_scene_on_enter_handlers,
+    .on_event_handlers = bad_kb_scene_on_event_handlers,
+    .on_exit_handlers = bad_kb_scene_on_exit_handlers,
+    .scene_num = BadKbSceneNum,
+};

applications/main/bad_kb/scenes/bad_kb_scene.h

@@ -3,27 +3,27 @@
 #include <gui/scene_manager.h>
 
 // Generate scene id and total number
-#define ADD_SCENE(prefix, name, id) BadUsbScene##id,
+#define ADD_SCENE(prefix, name, id) BadKbScene##id,
 typedef enum {
-#include "bad_usb_scene_config.h"
-    BadUsbSceneNum,
-} BadUsbScene;
+#include "bad_kb_scene_config.h"
+    BadKbSceneNum,
+} BadKbScene;
 #undef ADD_SCENE
 
-extern const SceneManagerHandlers bad_usb_scene_handlers;
+extern const SceneManagerHandlers bad_kb_scene_handlers;
 
 // Generate scene on_enter handlers declaration
 #define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
-#include "bad_usb_scene_config.h"
+#include "bad_kb_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 "bad_usb_scene_config.h"
+#include "bad_kb_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 "bad_usb_scene_config.h"
+#include "bad_kb_scene_config.h"
 #undef ADD_SCENE

applications/main/bad_kb/scenes/bad_kb_scene_config.h

@@ -0,0 +1,8 @@
+ADD_SCENE(bad_kb, file_select, FileSelect)
+ADD_SCENE(bad_kb, work, Work)
+ADD_SCENE(bad_kb, error, Error)
+ADD_SCENE(bad_kb, config_bt, ConfigBt)
+ADD_SCENE(bad_kb, config_usb, ConfigUsb)
+ADD_SCENE(bad_kb, config_layout, ConfigLayout)
+ADD_SCENE(bad_kb, config_name, ConfigName)
+ADD_SCENE(bad_kb, config_mac, ConfigMac)

applications/main/bad_kb/scenes/bad_kb_scene_config_bt.c

@@ -0,0 +1,84 @@
+#include "../bad_kb_app_i.h"
+#include "furi_hal_power.h"
+#include "furi_hal_usb.h"
+
+enum VarItemListIndex {
+    VarItemListIndexConnection,
+    VarItemListIndexKeyboardLayout,
+    VarItemListIndexAdvertisementName,
+    VarItemListIndexMacAddress,
+};
+
+void bad_kb_scene_config_bt_connection_callback(VariableItem* item) {
+    BadKbApp* bad_kb = variable_item_get_context(item);
+    bad_kb->is_bt = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, bad_kb->is_bt ? "BT" : "USB");
+    view_dispatcher_send_custom_event(bad_kb->view_dispatcher, VarItemListIndexConnection);
+}
+
+void bad_kb_scene_config_bt_var_item_list_callback(void* context, uint32_t index) {
+    BadKbApp* bad_kb = context;
+    view_dispatcher_send_custom_event(bad_kb->view_dispatcher, index);
+}
+
+void bad_kb_scene_config_bt_on_enter(void* context) {
+    BadKbApp* bad_kb = context;
+    VariableItemList* var_item_list = bad_kb->var_item_list_bt;
+    VariableItem* item;
+
+    item = variable_item_list_add(
+        var_item_list, "Connection", 2, bad_kb_scene_config_bt_connection_callback, bad_kb);
+    variable_item_set_current_value_index(item, bad_kb->is_bt);
+    variable_item_set_current_value_text(item, bad_kb->is_bt ? "BT" : "USB");
+
+    item = variable_item_list_add(var_item_list, "Keyboard layout", 0, NULL, bad_kb);
+
+    item = variable_item_list_add(var_item_list, "BT device name", 0, NULL, bad_kb);
+
+    item = variable_item_list_add(var_item_list, "BT MAC address", 0, NULL, bad_kb);
+
+    variable_item_list_set_enter_callback(
+        var_item_list, bad_kb_scene_config_bt_var_item_list_callback, bad_kb);
+
+    view_dispatcher_switch_to_view(bad_kb->view_dispatcher, BadKbAppViewConfigBt);
+}
+
+bool bad_kb_scene_config_bt_on_event(void* context, SceneManagerEvent event) {
+    BadKbApp* bad_kb = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        scene_manager_set_scene_state(bad_kb->scene_manager, BadKbSceneConfigBt, event.event);
+        consumed = true;
+        if(event.event == VarItemListIndexKeyboardLayout) {
+            scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigLayout);
+        } else if(event.event == VarItemListIndexConnection) {
+            bad_kb_script_close(bad_kb->bad_kb_script);
+            bad_kb_connection_deinit(bad_kb->bt);
+            bad_kb->bad_kb_script =
+                bad_kb_script_open(bad_kb->file_path, bad_kb->is_bt ? bad_kb->bt : NULL);
+            bad_kb_script_set_keyboard_layout(bad_kb->bad_kb_script, bad_kb->keyboard_layout);
+            scene_manager_previous_scene(bad_kb->scene_manager);
+            if(bad_kb->is_bt) {
+                scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigBt);
+            } else {
+                scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigUsb);
+            }
+        } else if(event.event == VarItemListIndexAdvertisementName) {
+            scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigName);
+        } else if(event.event == VarItemListIndexMacAddress) {
+            scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigMac);
+            // } else {
+            //     furi_crash("Unknown key type");
+        }
+    }
+
+    return consumed;
+}
+
+void bad_kb_scene_config_bt_on_exit(void* context) {
+    BadKbApp* bad_kb = context;
+    VariableItemList* var_item_list = bad_kb->var_item_list_bt;
+
+    variable_item_list_reset(var_item_list);
+}

applications/main/bad_kb/scenes/bad_kb_scene_config_layout.c

@@ -0,0 +1,48 @@
+#include "../bad_kb_app_i.h"
+#include "furi_hal_power.h"
+#include "furi_hal_usb.h"
+#include <storage/storage.h>
+
+static bool bad_kb_layout_select(BadKbApp* bad_kb) {
+    furi_assert(bad_kb);
+
+    FuriString* predefined_path;
+    predefined_path = furi_string_alloc();
+    if(!furi_string_empty(bad_kb->keyboard_layout)) {
+        furi_string_set(predefined_path, bad_kb->keyboard_layout);
+    } else {
+        furi_string_set(predefined_path, BAD_KB_APP_PATH_LAYOUT_FOLDER);
+    }
+
+    DialogsFileBrowserOptions browser_options;
+    dialog_file_browser_set_basic_options(
+        &browser_options, BAD_KB_APP_LAYOUT_EXTENSION, &I_keyboard_10px);
+
+    // Input events and views are managed by file_browser
+    bool res = dialog_file_browser_show(
+        bad_kb->dialogs, bad_kb->keyboard_layout, predefined_path, &browser_options);
+
+    furi_string_free(predefined_path);
+    return res;
+}
+
+void bad_kb_scene_config_layout_on_enter(void* context) {
+    BadKbApp* bad_kb = context;
+
+    if(bad_kb_layout_select(bad_kb)) {
+        bad_kb_script_set_keyboard_layout(bad_kb->bad_kb_script, bad_kb->keyboard_layout);
+    }
+    scene_manager_previous_scene(bad_kb->scene_manager);
+}
+
+bool bad_kb_scene_config_layout_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    // BadKbApp* bad_kb = context;
+    return false;
+}
+
+void bad_kb_scene_config_layout_on_exit(void* context) {
+    UNUSED(context);
+    // BadKbApp* bad_kb = context;
+}

applications/main/bad_kb/scenes/bad_kb_scene_config_mac.c

@@ -0,0 +1,57 @@
+#include "../bad_kb_app_i.h"
+
+#define TAG "BadKbConfigMac"
+
+static uint8_t* reverse_mac_addr(uint8_t* mac) {
+    uint8_t tmp;
+    for(int i = 0; i < 3; i++) {
+        tmp = mac[i];
+        mac[i] = mac[5 - i];
+        mac[5 - i] = tmp;
+    }
+    return mac;
+}
+
+void bad_kb_scene_config_mac_byte_input_callback(void* context) {
+    BadKbApp* bad_kb = context;
+
+    view_dispatcher_send_custom_event(bad_kb->view_dispatcher, BadKbAppCustomEventByteInputDone);
+}
+
+void bad_kb_scene_config_mac_on_enter(void* context) {
+    BadKbApp* bad_kb = context;
+
+    // Setup view
+    ByteInput* byte_input = bad_kb->byte_input;
+    byte_input_set_header_text(byte_input, "Enter new MAC address");
+    byte_input_set_result_callback(
+        byte_input,
+        bad_kb_scene_config_mac_byte_input_callback,
+        NULL,
+        bad_kb,
+        reverse_mac_addr(bad_kb->mac),
+        GAP_MAC_ADDR_SIZE);
+    view_dispatcher_switch_to_view(bad_kb->view_dispatcher, BadKbAppViewConfigMac);
+}
+
+bool bad_kb_scene_config_mac_on_event(void* context, SceneManagerEvent event) {
+    BadKbApp* bad_kb = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == BadKbAppCustomEventByteInputDone) {
+            bt_set_profile_mac_address(bad_kb->bt, reverse_mac_addr(bad_kb->mac));
+            scene_manager_previous_scene(bad_kb->scene_manager);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void bad_kb_scene_config_mac_on_exit(void* context) {
+    BadKbApp* bad_kb = context;
+
+    // Clear view
+    byte_input_set_result_callback(bad_kb->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(bad_kb->byte_input, "");
+}

applications/main/bad_kb/scenes/bad_kb_scene_config_name.c

@@ -0,0 +1,45 @@
+#include "../bad_kb_app_i.h"
+
+static void bad_kb_scene_config_name_text_input_callback(void* context) {
+    BadKbApp* bad_kb = context;
+
+    view_dispatcher_send_custom_event(bad_kb->view_dispatcher, BadKbAppCustomEventTextEditResult);
+}
+
+void bad_kb_scene_config_name_on_enter(void* context) {
+    BadKbApp* bad_kb = context;
+    TextInput* text_input = bad_kb->text_input;
+
+    text_input_set_header_text(text_input, "Set BLE adv name");
+
+    text_input_set_result_callback(
+        text_input,
+        bad_kb_scene_config_name_text_input_callback,
+        bad_kb,
+        bad_kb->name,
+        BAD_KB_ADV_NAME_MAX_LEN,
+        true);
+
+    view_dispatcher_switch_to_view(bad_kb->view_dispatcher, BadKbAppViewConfigName);
+}
+
+bool bad_kb_scene_config_name_on_event(void* context, SceneManagerEvent event) {
+    BadKbApp* bad_kb = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        consumed = true;
+        if(event.event == BadKbAppCustomEventTextEditResult) {
+            bt_set_profile_adv_name(bad_kb->bt, bad_kb->name);
+        }
+        scene_manager_previous_scene(bad_kb->scene_manager);
+    }
+    return consumed;
+}
+
+void bad_kb_scene_config_name_on_exit(void* context) {
+    BadKbApp* bad_kb = context;
+    TextInput* text_input = bad_kb->text_input;
+
+    text_input_reset(text_input);
+}

applications/main/bad_kb/scenes/bad_kb_scene_config_usb.c

@@ -0,0 +1,74 @@
+#include "../bad_kb_app_i.h"
+#include "furi_hal_power.h"
+#include "furi_hal_usb.h"
+
+enum VarItemListIndex {
+    VarItemListIndexConnection,
+    VarItemListIndexKeyboardLayout,
+};
+
+void bad_kb_scene_config_usb_connection_callback(VariableItem* item) {
+    BadKbApp* bad_kb = variable_item_get_context(item);
+    bad_kb->is_bt = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, bad_kb->is_bt ? "BT" : "USB");
+    view_dispatcher_send_custom_event(bad_kb->view_dispatcher, VarItemListIndexConnection);
+}
+
+void bad_kb_scene_config_usb_var_item_list_callback(void* context, uint32_t index) {
+    BadKbApp* bad_kb = context;
+    view_dispatcher_send_custom_event(bad_kb->view_dispatcher, index);
+}
+
+void bad_kb_scene_config_usb_on_enter(void* context) {
+    BadKbApp* bad_kb = context;
+    VariableItemList* var_item_list = bad_kb->var_item_list_usb;
+    VariableItem* item;
+
+    item = variable_item_list_add(
+        var_item_list, "Connection", 2, bad_kb_scene_config_usb_connection_callback, bad_kb);
+    variable_item_set_current_value_index(item, bad_kb->is_bt);
+    variable_item_set_current_value_text(item, bad_kb->is_bt ? "BT" : "USB");
+
+    item = variable_item_list_add(var_item_list, "Keyboard layout", 0, NULL, bad_kb);
+
+    variable_item_list_set_enter_callback(
+        var_item_list, bad_kb_scene_config_usb_var_item_list_callback, bad_kb);
+
+    view_dispatcher_switch_to_view(bad_kb->view_dispatcher, BadKbAppViewConfigUsb);
+}
+
+bool bad_kb_scene_config_usb_on_event(void* context, SceneManagerEvent event) {
+    BadKbApp* bad_kb = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        scene_manager_set_scene_state(bad_kb->scene_manager, BadKbSceneConfigUsb, event.event);
+        consumed = true;
+        if(event.event == VarItemListIndexKeyboardLayout) {
+            scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigLayout);
+        } else if(event.event == VarItemListIndexConnection) {
+            bad_kb_script_close(bad_kb->bad_kb_script);
+            bad_kb_connection_deinit(bad_kb->bt);
+            bad_kb->bad_kb_script =
+                bad_kb_script_open(bad_kb->file_path, bad_kb->is_bt ? bad_kb->bt : NULL);
+            bad_kb_script_set_keyboard_layout(bad_kb->bad_kb_script, bad_kb->keyboard_layout);
+            scene_manager_previous_scene(bad_kb->scene_manager);
+            if(bad_kb->is_bt) {
+                scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigBt);
+            } else {
+                scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneConfigUsb);
+            }
+            // } else {
+            //     furi_crash("Unknown key type");
+        }
+    }
+
+    return consumed;
+}
+
+void bad_kb_scene_config_usb_on_exit(void* context) {
+    BadKbApp* bad_kb = context;
+    VariableItemList* var_item_list = bad_kb->var_item_list_usb;
+
+    variable_item_list_reset(var_item_list);
+}

applications/main/bad_kb/scenes/bad_kb_scene_error.c

@@ -1,24 +1,20 @@
-#include "../bad_usb_app_i.h"
+#include "../bad_kb_app_i.h"
 #include "xtreme/assets.h"
 
-typedef enum {
-    BadUsbCustomEventErrorBack,
-} BadUsbCustomEvent;
-
 static void
-    bad_usb_scene_error_event_callback(GuiButtonType result, InputType type, void* context) {
+    bad_kb_scene_error_event_callback(GuiButtonType result, InputType type, void* context) {
     furi_assert(context);
-    BadUsbApp* app = context;
+    BadKbApp* app = context;
 
     if((result == GuiButtonTypeLeft) && (type == InputTypeShort)) {
-        view_dispatcher_send_custom_event(app->view_dispatcher, BadUsbCustomEventErrorBack);
+        view_dispatcher_send_custom_event(app->view_dispatcher, BadKbCustomEventErrorBack);
     }
 }
 
-void bad_usb_scene_error_on_enter(void* context) {
-    BadUsbApp* app = context;
+void bad_kb_scene_error_on_enter(void* context) {
+    BadKbApp* app = context;
 
-    if(app->error == BadUsbAppErrorNoFiles) {
+    if(app->error == BadKbAppErrorNoFiles) {
         widget_add_icon_element(app->widget, 0, 0, &I_SDQuestion_35x43);
         widget_add_string_multiline_element(
             app->widget,
@@ -29,8 +25,8 @@ void bad_usb_scene_error_on_enter(void* context) {
             FontSecondary,
             "No SD card or\napp data found.\nThis app will not\nwork without\nrequired files.");
         widget_add_button_element(
-            app->widget, GuiButtonTypeLeft, "Back", bad_usb_scene_error_event_callback, app);
-    } else if(app->error == BadUsbAppErrorCloseRpc) {
+            app->widget, GuiButtonTypeLeft, "Back", bad_kb_scene_error_event_callback, app);
+    } else if(app->error == BadKbAppErrorCloseRpc) {
         widget_add_icon_element(app->widget, 78, 0, &I_ActiveConnection_50x64);
         if(XTREME_ASSETS()->is_nsfw) {
             widget_add_string_multiline_element(
@@ -57,15 +53,15 @@ void bad_usb_scene_error_on_enter(void* context) {
         }
     }
 
-    view_dispatcher_switch_to_view(app->view_dispatcher, BadUsbAppViewError);
+    view_dispatcher_switch_to_view(app->view_dispatcher, BadKbAppViewError);
 }
 
-bool bad_usb_scene_error_on_event(void* context, SceneManagerEvent event) {
-    BadUsbApp* app = context;
+bool bad_kb_scene_error_on_event(void* context, SceneManagerEvent event) {
+    BadKbApp* app = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == BadUsbCustomEventErrorBack) {
+        if(event.event == BadKbCustomEventErrorBack) {
             view_dispatcher_stop(app->view_dispatcher);
             consumed = true;
         }
@@ -73,7 +69,7 @@ bool bad_usb_scene_error_on_event(void* context, SceneManagerEvent event) {
     return consumed;
 }
 
-void bad_usb_scene_error_on_exit(void* context) {
-    BadUsbApp* app = context;
+void bad_kb_scene_error_on_exit(void* context) {
+    BadKbApp* app = context;
     widget_reset(app->widget);
 }

applications/main/bad_kb/scenes/bad_kb_scene_file_select.c

@@ -0,0 +1,53 @@
+#include "../bad_kb_app_i.h"
+#include <furi_hal_power.h>
+#include <furi_hal_usb.h>
+#include <storage/storage.h>
+
+static bool bad_kb_file_select(BadKbApp* bad_kb) {
+    furi_assert(bad_kb);
+
+    DialogsFileBrowserOptions browser_options;
+    dialog_file_browser_set_basic_options(
+        &browser_options, BAD_KB_APP_SCRIPT_EXTENSION, &I_badkb_10px);
+    browser_options.base_path = BAD_KB_APP_BASE_FOLDER;
+    browser_options.skip_assets = true;
+
+    // Input events and views are managed by file_browser
+    bool res = dialog_file_browser_show(
+        bad_kb->dialogs, bad_kb->file_path, bad_kb->file_path, &browser_options);
+
+    return res;
+}
+
+void bad_kb_scene_file_select_on_enter(void* context) {
+    BadKbApp* bad_kb = context;
+
+    furi_hal_usb_disable();
+    if(bad_kb->bad_kb_script) {
+        bad_kb_script_close(bad_kb->bad_kb_script);
+        bad_kb->bad_kb_script = NULL;
+    }
+
+    if(bad_kb_file_select(bad_kb)) {
+        bad_kb->bad_kb_script =
+            bad_kb_script_open(bad_kb->file_path, bad_kb->is_bt ? bad_kb->bt : NULL);
+        bad_kb_script_set_keyboard_layout(bad_kb->bad_kb_script, bad_kb->keyboard_layout);
+
+        scene_manager_next_scene(bad_kb->scene_manager, BadKbSceneWork);
+    } else {
+        furi_hal_usb_enable();
+        view_dispatcher_stop(bad_kb->view_dispatcher);
+    }
+}
+
+bool bad_kb_scene_file_select_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    // BadKbApp* bad_kb = context;
+    return false;
+}
+
+void bad_kb_scene_file_select_on_exit(void* context) {
+    UNUSED(context);
+    // BadKbApp* bad_kb = context;
+}

applications/main/bad_kb/scenes/bad_kb_scene_work.c

@@ -0,0 +1,58 @@
+#include "../bad_kb_script.h"
+#include "../bad_kb_app_i.h"
+#include "../views/bad_kb_view.h"
+#include <furi_hal.h>
+#include "toolbox/path.h"
+
+void bad_kb_scene_work_button_callback(InputKey key, void* context) {
+    furi_assert(context);
+    BadKbApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, key);
+}
+
+bool bad_kb_scene_work_on_event(void* context, SceneManagerEvent event) {
+    BadKbApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == InputKeyLeft) {
+            if(app->is_bt) {
+                scene_manager_next_scene(app->scene_manager, BadKbSceneConfigBt);
+            } else {
+                scene_manager_next_scene(app->scene_manager, BadKbSceneConfigUsb);
+            }
+            consumed = true;
+        } else if(event.event == InputKeyOk) {
+            bad_kb_script_toggle(app->bad_kb_script);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        bad_kb_set_state(app->bad_kb_view, bad_kb_script_get_state(app->bad_kb_script));
+    }
+    return consumed;
+}
+
+void bad_kb_scene_work_on_enter(void* context) {
+    BadKbApp* app = context;
+
+    FuriString* file_name;
+    file_name = furi_string_alloc();
+    path_extract_filename(app->file_path, file_name, true);
+    bad_kb_set_file_name(app->bad_kb_view, furi_string_get_cstr(file_name));
+    furi_string_free(file_name);
+
+    FuriString* layout;
+    layout = furi_string_alloc();
+    path_extract_filename(app->keyboard_layout, layout, true);
+    bad_kb_set_layout(app->bad_kb_view, furi_string_get_cstr(layout));
+    furi_string_free(layout);
+
+    bad_kb_set_state(app->bad_kb_view, bad_kb_script_get_state(app->bad_kb_script));
+
+    bad_kb_set_button_callback(app->bad_kb_view, bad_kb_scene_work_button_callback, app);
+    view_dispatcher_switch_to_view(app->view_dispatcher, BadKbAppViewWork);
+}
+
+void bad_kb_scene_work_on_exit(void* context) {
+    UNUSED(context);
+}

applications/main/bad_kb/views/bad_kb_view.c

@@ -1,5 +1,5 @@
-#include "bad_usb_view.h"
-#include "../bad_usb_script.h"
+#include "bad_kb_view.h"
+#include "../bad_kb_script.h"
 #include <toolbox/path.h>
 #include <gui/elements.h>
 #include <assets_icons.h>
@@ -7,21 +7,21 @@
 
 #define MAX_NAME_LEN 64
 
-struct BadUsb {
+struct BadKb {
     View* view;
-    BadUsbButtonCallback callback;
+    BadKbButtonCallback callback;
     void* context;
 };
 
 typedef struct {
     char file_name[MAX_NAME_LEN];
     char layout[MAX_NAME_LEN];
-    BadUsbState state;
+    BadKbState state;
     uint8_t anim_frame;
-} BadUsbModel;
+} BadKbModel;
 
-static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
-    BadUsbModel* model = _model;
+static void bad_kb_draw_callback(Canvas* canvas, void* _model) {
+    BadKbModel* model = _model;
 
     FuriString* disp_str;
     disp_str = furi_string_alloc_set(model->file_name);
@@ -46,25 +46,25 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
 
     canvas_draw_icon(canvas, 22, 24, &I_UsbTree_48x22);
 
-    if((model->state.state == BadUsbStateIdle) || (model->state.state == BadUsbStateDone) ||
-       (model->state.state == BadUsbStateNotConnected)) {
+    if((model->state.state == BadKbStateIdle) || (model->state.state == BadKbStateDone) ||
+       (model->state.state == BadKbStateNotConnected)) {
         if(XTREME_ASSETS()->is_nsfw) {
             elements_button_center(canvas, "Cum");
         } else {
             elements_button_center(canvas, "Start");
         }
-    } else if((model->state.state == BadUsbStateRunning) || (model->state.state == BadUsbStateDelay)) {
+    } else if((model->state.state == BadKbStateRunning) || (model->state.state == BadKbStateDelay)) {
         elements_button_center(canvas, "Stop");
-    } else if(model->state.state == BadUsbStateWillRun) {
+    } else if(model->state.state == BadKbStateWillRun) {
         elements_button_center(canvas, "Cancel");
     }
 
-    if((model->state.state == BadUsbStateNotConnected) ||
-       (model->state.state == BadUsbStateIdle) || (model->state.state == BadUsbStateDone)) {
+    if((model->state.state == BadKbStateNotConnected) || (model->state.state == BadKbStateIdle) ||
+       (model->state.state == BadKbStateDone)) {
         elements_button_left(canvas, "Config");
     }
 
-    if(model->state.state == BadUsbStateNotConnected) {
+    if(model->state.state == BadKbStateNotConnected) {
         canvas_draw_icon(canvas, 4, 26, &I_Clock_18x18);
         canvas_set_font(canvas, FontPrimary);
         if(XTREME_ASSETS()->is_nsfw) {
@@ -74,7 +74,7 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
             canvas_draw_str_aligned(canvas, 127, 31, AlignRight, AlignBottom, "Connect to");
             canvas_draw_str_aligned(canvas, 127, 43, AlignRight, AlignBottom, "a device");
         }
-    } else if(model->state.state == BadUsbStateWillRun) {
+    } else if(model->state.state == BadKbStateWillRun) {
         canvas_draw_icon(canvas, 4, 26, &I_Clock_18x18);
         canvas_set_font(canvas, FontPrimary);
         if(XTREME_ASSETS()->is_nsfw) {
@@ -83,12 +83,12 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
             canvas_draw_str_aligned(canvas, 127, 31, AlignRight, AlignBottom, "Will run");
         }
         canvas_draw_str_aligned(canvas, 127, 43, AlignRight, AlignBottom, "on connect");
-    } else if(model->state.state == BadUsbStateFileError) {
+    } else if(model->state.state == BadKbStateFileError) {
         canvas_draw_icon(canvas, 4, 26, &I_Error_18x18);
         canvas_set_font(canvas, FontPrimary);
         canvas_draw_str_aligned(canvas, 127, 31, AlignRight, AlignBottom, "File");
         canvas_draw_str_aligned(canvas, 127, 43, AlignRight, AlignBottom, "ERROR");
-    } else if(model->state.state == BadUsbStateScriptError) {
+    } else if(model->state.state == BadKbStateScriptError) {
         canvas_draw_icon(canvas, 4, 26, &I_Error_18x18);
         canvas_set_font(canvas, FontPrimary);
         canvas_draw_str_aligned(canvas, 127, 33, AlignRight, AlignBottom, "ERROR:");
@@ -98,12 +98,12 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
             canvas, 127, 46, AlignRight, AlignBottom, furi_string_get_cstr(disp_str));
         furi_string_reset(disp_str);
         canvas_draw_str_aligned(canvas, 127, 56, AlignRight, AlignBottom, model->state.error);
-    } else if(model->state.state == BadUsbStateIdle) {
+    } else if(model->state.state == BadKbStateIdle) {
         canvas_draw_icon(canvas, 4, 26, &I_Smile_18x18);
         canvas_set_font(canvas, FontBigNumbers);
         canvas_draw_str_aligned(canvas, 114, 40, AlignRight, AlignBottom, "0");
         canvas_draw_icon(canvas, 117, 26, &I_Percent_10x14);
-    } else if(model->state.state == BadUsbStateRunning) {
+    } else if(model->state.state == BadKbStateRunning) {
         if(model->anim_frame == 0) {
             canvas_draw_icon(canvas, 4, 23, &I_EviSmile1_18x21);
         } else {
@@ -116,13 +116,13 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
             canvas, 114, 40, AlignRight, AlignBottom, furi_string_get_cstr(disp_str));
         furi_string_reset(disp_str);
         canvas_draw_icon(canvas, 117, 26, &I_Percent_10x14);
-    } else if(model->state.state == BadUsbStateDone) {
+    } else if(model->state.state == BadKbStateDone) {
         canvas_draw_icon(canvas, 4, 23, &I_EviSmile1_18x21);
         canvas_set_font(canvas, FontBigNumbers);
         canvas_draw_str_aligned(canvas, 114, 40, AlignRight, AlignBottom, "100");
         furi_string_reset(disp_str);
         canvas_draw_icon(canvas, 117, 26, &I_Percent_10x14);
-    } else if(model->state.state == BadUsbStateDelay) {
+    } else if(model->state.state == BadKbStateDelay) {
         if(model->anim_frame == 0) {
             canvas_draw_icon(canvas, 4, 23, &I_EviWaiting1_18x21);
         } else {
@@ -147,84 +147,78 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
     furi_string_free(disp_str);
 }
 
-static bool bad_usb_input_callback(InputEvent* event, void* context) {
+static bool bad_kb_input_callback(InputEvent* event, void* context) {
     furi_assert(context);
-    BadUsb* bad_usb = context;
+    BadKb* bad_kb = context;
     bool consumed = false;
 
     if(event->type == InputTypeShort) {
         if((event->key == InputKeyLeft) || (event->key == InputKeyOk)) {
             consumed = true;
-            furi_assert(bad_usb->callback);
-            bad_usb->callback(event->key, bad_usb->context);
+            furi_assert(bad_kb->callback);
+            bad_kb->callback(event->key, bad_kb->context);
         }
     }
 
     return consumed;
 }
 
-BadUsb* bad_usb_alloc() {
-    BadUsb* bad_usb = malloc(sizeof(BadUsb));
+BadKb* bad_kb_alloc() {
+    BadKb* bad_kb = malloc(sizeof(BadKb));
 
-    bad_usb->view = view_alloc();
-    view_allocate_model(bad_usb->view, ViewModelTypeLocking, sizeof(BadUsbModel));
-    view_set_context(bad_usb->view, bad_usb);
-    view_set_draw_callback(bad_usb->view, bad_usb_draw_callback);
-    view_set_input_callback(bad_usb->view, bad_usb_input_callback);
+    bad_kb->view = view_alloc();
+    view_allocate_model(bad_kb->view, ViewModelTypeLocking, sizeof(BadKbModel));
+    view_set_context(bad_kb->view, bad_kb);
+    view_set_draw_callback(bad_kb->view, bad_kb_draw_callback);
+    view_set_input_callback(bad_kb->view, bad_kb_input_callback);
 
-    return bad_usb;
+    return bad_kb;
 }
 
-void bad_usb_free(BadUsb* bad_usb) {
-    furi_assert(bad_usb);
-    view_free(bad_usb->view);
-    free(bad_usb);
+void bad_kb_free(BadKb* bad_kb) {
+    furi_assert(bad_kb);
+    view_free(bad_kb->view);
+    free(bad_kb);
 }
 
-View* bad_usb_get_view(BadUsb* bad_usb) {
-    furi_assert(bad_usb);
-    return bad_usb->view;
+View* bad_kb_get_view(BadKb* bad_kb) {
+    furi_assert(bad_kb);
+    return bad_kb->view;
 }
 
-void bad_usb_set_button_callback(BadUsb* bad_usb, BadUsbButtonCallback callback, void* context) {
-    furi_assert(bad_usb);
+void bad_kb_set_button_callback(BadKb* bad_kb, BadKbButtonCallback callback, void* context) {
+    furi_assert(bad_kb);
     furi_assert(callback);
     with_view_model(
-        bad_usb->view,
-        BadUsbModel * model,
+        bad_kb->view,
+        BadKbModel * model,
         {
             UNUSED(model);
-            bad_usb->callback = callback;
-            bad_usb->context = context;
+            bad_kb->callback = callback;
+            bad_kb->context = context;
         },
         true);
 }
 
-void bad_usb_set_file_name(BadUsb* bad_usb, const char* name) {
+void bad_kb_set_file_name(BadKb* bad_kb, const char* name) {
     furi_assert(name);
     with_view_model(
-        bad_usb->view,
-        BadUsbModel * model,
-        { strlcpy(model->file_name, name, MAX_NAME_LEN); },
-        true);
+        bad_kb->view, BadKbModel * model, { strlcpy(model->file_name, name, MAX_NAME_LEN); }, true);
 }
 
-void bad_usb_set_layout(BadUsb* bad_usb, const char* layout) {
+void bad_kb_set_layout(BadKb* bad_kb, const char* layout) {
     furi_assert(layout);
     with_view_model(
-        bad_usb->view,
-        BadUsbModel * model,
-        { strlcpy(model->layout, layout, MAX_NAME_LEN); },
-        true);
+        bad_kb->view, BadKbModel * model, { strlcpy(model->layout, layout, MAX_NAME_LEN); }, true);
 }
 
-void bad_usb_set_state(BadUsb* bad_usb, BadUsbState* st) {
+void bad_kb_set_state(BadKb* bad_kb, BadKbState* st) {
     furi_assert(st);
     with_view_model(
-        bad_usb->view,
-        BadUsbModel * model,
+        bad_kb->view,
+        BadKbModel * model,
         {
-            memcpy(&(model->state), st, sizeof(BadUsbState));
+            memcpy(&(model->state), st, sizeof(BadKbState));
             model->anim_frame ^= 1;
         },
         true);

applications/main/bad_kb/views/bad_kb_view.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <gui/view.h>
+#include "../bad_kb_script.h"
+
+typedef struct BadKb BadKb;
+typedef void (*BadKbButtonCallback)(InputKey key, void* context);
+
+BadKb* bad_kb_alloc();
+
+void bad_kb_free(BadKb* bad_kb);
+
+View* bad_kb_get_view(BadKb* bad_kb);
+
+void bad_kb_set_button_callback(BadKb* bad_kb, BadKbButtonCallback callback, void* context);
+
+void bad_kb_set_file_name(BadKb* bad_kb, const char* name);
+
+void bad_kb_set_layout(BadKb* bad_kb, const char* layout);
+
+void bad_kb_set_state(BadKb* bad_kb, BadKbState* st);

applications/main/bad_usb/bad_usb_app.c

@@ -1,160 +0,0 @@
-#include "bad_usb_app_i.h"
-#include "bad_usb_settings_filename.h"
-#include <furi.h>
-#include <furi_hal.h>
-#include <storage/storage.h>
-#include <lib/toolbox/path.h>
-
-#define BAD_USB_SETTINGS_PATH BAD_USB_APP_BASE_FOLDER "/" BAD_USB_SETTINGS_FILE_NAME
-
-static bool bad_usb_app_custom_event_callback(void* context, uint32_t event) {
-    furi_assert(context);
-    BadUsbApp* app = context;
-    return scene_manager_handle_custom_event(app->scene_manager, event);
-}
-
-static bool bad_usb_app_back_event_callback(void* context) {
-    furi_assert(context);
-    BadUsbApp* app = context;
-    return scene_manager_handle_back_event(app->scene_manager);
-}
-
-static void bad_usb_app_tick_event_callback(void* context) {
-    furi_assert(context);
-    BadUsbApp* app = context;
-    scene_manager_handle_tick_event(app->scene_manager);
-}
-
-static void bad_usb_load_settings(BadUsbApp* app) {
-    File* settings_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
-    if(storage_file_open(settings_file, BAD_USB_SETTINGS_PATH, FSAM_READ, FSOM_OPEN_EXISTING)) {
-        char chr;
-        while((storage_file_read(settings_file, &chr, 1) == 1) &&
-              !storage_file_eof(settings_file) && !isspace(chr)) {
-            furi_string_push_back(app->keyboard_layout, chr);
-        }
-    }
-    storage_file_close(settings_file);
-    storage_file_free(settings_file);
-}
-
-static void bad_usb_save_settings(BadUsbApp* app) {
-    File* settings_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
-    if(storage_file_open(settings_file, BAD_USB_SETTINGS_PATH, FSAM_WRITE, FSOM_OPEN_ALWAYS)) {
-        storage_file_write(
-            settings_file,
-            furi_string_get_cstr(app->keyboard_layout),
-            furi_string_size(app->keyboard_layout));
-        storage_file_write(settings_file, "\n", 1);
-    }
-    storage_file_close(settings_file);
-    storage_file_free(settings_file);
-}
-
-BadUsbApp* bad_usb_app_alloc(char* arg) {
-    BadUsbApp* app = malloc(sizeof(BadUsbApp));
-
-    app->bad_usb_script = NULL;
-
-    app->file_path = furi_string_alloc();
-    app->keyboard_layout = furi_string_alloc();
-    if(arg && strlen(arg)) {
-        furi_string_set(app->file_path, arg);
-    }
-
-    bad_usb_load_settings(app);
-
-    app->gui = furi_record_open(RECORD_GUI);
-    app->notifications = furi_record_open(RECORD_NOTIFICATION);
-    app->dialogs = furi_record_open(RECORD_DIALOGS);
-
-    app->view_dispatcher = view_dispatcher_alloc();
-    view_dispatcher_enable_queue(app->view_dispatcher);
-
-    app->scene_manager = scene_manager_alloc(&bad_usb_scene_handlers, app);
-
-    view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
-    view_dispatcher_set_tick_event_callback(
-        app->view_dispatcher, bad_usb_app_tick_event_callback, 500);
-    view_dispatcher_set_custom_event_callback(
-        app->view_dispatcher, bad_usb_app_custom_event_callback);
-    view_dispatcher_set_navigation_event_callback(
-        app->view_dispatcher, bad_usb_app_back_event_callback);
-
-    // Custom Widget
-    app->widget = widget_alloc();
-    view_dispatcher_add_view(
-        app->view_dispatcher, BadUsbAppViewError, widget_get_view(app->widget));
-
-    app->submenu = submenu_alloc();
-    view_dispatcher_add_view(
-        app->view_dispatcher, BadUsbAppViewConfig, submenu_get_view(app->submenu));
-
-    app->bad_usb_view = bad_usb_alloc();
-    view_dispatcher_add_view(
-        app->view_dispatcher, BadUsbAppViewWork, bad_usb_get_view(app->bad_usb_view));
-
-    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
-
-    if(furi_hal_usb_is_locked()) {
-        app->error = BadUsbAppErrorCloseRpc;
-        scene_manager_next_scene(app->scene_manager, BadUsbSceneError);
-    } else {
-        if(!furi_string_empty(app->file_path)) {
-            app->bad_usb_script = bad_usb_script_open(app->file_path);
-            bad_usb_script_set_keyboard_layout(app->bad_usb_script, app->keyboard_layout);
-            scene_manager_next_scene(app->scene_manager, BadUsbSceneWork);
-        } else {
-            furi_string_set(app->file_path, BAD_USB_APP_BASE_FOLDER);
-            scene_manager_next_scene(app->scene_manager, BadUsbSceneFileSelect);
-        }
-    }
-
-    return app;
-}
-
-void bad_usb_app_free(BadUsbApp* app) {
-    furi_assert(app);
-
-    if(app->bad_usb_script) {
-        bad_usb_script_close(app->bad_usb_script);
-        app->bad_usb_script = NULL;
-    }
-
-    // Views
-    view_dispatcher_remove_view(app->view_dispatcher, BadUsbAppViewWork);
-    bad_usb_free(app->bad_usb_view);
-
-    // Custom Widget
-    view_dispatcher_remove_view(app->view_dispatcher, BadUsbAppViewError);
-    widget_free(app->widget);
-
-    // Submenu
-    view_dispatcher_remove_view(app->view_dispatcher, BadUsbAppViewConfig);
-    submenu_free(app->submenu);
-
-    // View dispatcher
-    view_dispatcher_free(app->view_dispatcher);
-    scene_manager_free(app->scene_manager);
-
-    // Close records
-    furi_record_close(RECORD_GUI);
-    furi_record_close(RECORD_NOTIFICATION);
-    furi_record_close(RECORD_DIALOGS);
-
-    bad_usb_save_settings(app);
-
-    furi_string_free(app->file_path);
-    furi_string_free(app->keyboard_layout);
-
-    free(app);
-}
-
-int32_t bad_usb_app(void* p) {
-    BadUsbApp* bad_usb_app = bad_usb_app_alloc((char*)p);
-
-    view_dispatcher_run(bad_usb_app->view_dispatcher);
-
-    bad_usb_app_free(bad_usb_app);
-    return 0;
-}

applications/main/bad_usb/bad_usb_app.h

@@ -1,11 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct BadUsbApp BadUsbApp;
-
-#ifdef __cplusplus
-}
-#endif

applications/main/bad_usb/bad_usb_app_i.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "bad_usb_app.h"
-#include "scenes/bad_usb_scene.h"
-#include "bad_usb_script.h"
-
-#include <gui/gui.h>
-#include <assets_icons.h>
-#include <gui/view_dispatcher.h>
-#include <gui/scene_manager.h>
-#include <gui/modules/submenu.h>
-#include <dialogs/dialogs.h>
-#include <notification/notification_messages.h>
-#include <gui/modules/variable_item_list.h>
-#include <gui/modules/widget.h>
-#include "views/bad_usb_view.h"
-
-#define BAD_USB_APP_BASE_FOLDER ANY_PATH("badusb")
-#define BAD_USB_APP_PATH_LAYOUT_FOLDER BAD_USB_APP_BASE_FOLDER "/layouts"
-#define BAD_USB_APP_SCRIPT_EXTENSION ".txt"
-#define BAD_USB_APP_LAYOUT_EXTENSION ".kl"
-
-typedef enum {
-    BadUsbAppErrorNoFiles,
-    BadUsbAppErrorCloseRpc,
-} BadUsbAppError;
-
-struct BadUsbApp {
-    Gui* gui;
-    ViewDispatcher* view_dispatcher;
-    SceneManager* scene_manager;
-    NotificationApp* notifications;
-    DialogsApp* dialogs;
-    Widget* widget;
-    Submenu* submenu;
-
-    BadUsbAppError error;
-    FuriString* file_path;
-    FuriString* keyboard_layout;
-    BadUsb* bad_usb_view;
-    BadUsbScript* bad_usb_script;
-};
-
-typedef enum {
-    BadUsbAppViewError,
-    BadUsbAppViewWork,
-    BadUsbAppViewConfig,
-} BadUsbAppView;

applications/main/bad_usb/bad_usb_script.c

@@ -1,725 +0,0 @@
-#include <furi.h>
-#include <furi_hal.h>
-#include <gui/gui.h>
-#include <input/input.h>
-#include <lib/toolbox/args.h>
-#include <furi_hal_usb_hid.h>
-#include <storage/storage.h>
-#include "bad_usb_script.h"
-#include <dolphin/dolphin.h>
-
-#define TAG "BadUSB"
-#define WORKER_TAG TAG "Worker"
-#define FILE_BUFFER_LEN 16
-
-#define SCRIPT_STATE_ERROR (-1)
-#define SCRIPT_STATE_END (-2)
-#define SCRIPT_STATE_NEXT_LINE (-3)
-
-#define BADUSB_ASCII_TO_KEY(script, x) \
-    (((uint8_t)x < 128) ? (script->layout[(uint8_t)x]) : HID_KEYBOARD_NONE)
-
-typedef enum {
-    WorkerEvtToggle = (1 << 0),
-    WorkerEvtEnd = (1 << 1),
-    WorkerEvtConnect = (1 << 2),
-    WorkerEvtDisconnect = (1 << 3),
-} WorkerEvtFlags;
-
-struct BadUsbScript {
-    FuriHalUsbHidConfig hid_cfg;
-    BadUsbState st;
-    FuriString* file_path;
-    uint32_t defdelay;
-    uint16_t layout[128];
-    FuriThread* thread;
-    uint8_t file_buf[FILE_BUFFER_LEN + 1];
-    uint8_t buf_start;
-    uint8_t buf_len;
-    bool file_end;
-    FuriString* line;
-
-    FuriString* line_prev;
-    uint32_t repeat_cnt;
-};
-
-typedef struct {
-    char* name;
-    uint16_t keycode;
-} DuckyKey;
-
-static const DuckyKey ducky_keys[] = {
-    {"CTRL-ALT", KEY_MOD_LEFT_CTRL | KEY_MOD_LEFT_ALT},
-    {"CTRL-SHIFT", KEY_MOD_LEFT_CTRL | KEY_MOD_LEFT_SHIFT},
-    {"ALT-SHIFT", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_SHIFT},
-    {"ALT-GUI", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_GUI},
-    {"GUI-SHIFT", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_SHIFT},
-    {"GUI-CTRL", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_CTRL},
-
-    {"CTRL", KEY_MOD_LEFT_CTRL},
-    {"CONTROL", KEY_MOD_LEFT_CTRL},
-    {"SHIFT", KEY_MOD_LEFT_SHIFT},
-    {"ALT", KEY_MOD_LEFT_ALT},
-    {"GUI", KEY_MOD_LEFT_GUI},
-    {"WINDOWS", KEY_MOD_LEFT_GUI},
-
-    {"DOWNARROW", HID_KEYBOARD_DOWN_ARROW},
-    {"DOWN", HID_KEYBOARD_DOWN_ARROW},
-    {"LEFTARROW", HID_KEYBOARD_LEFT_ARROW},
-    {"LEFT", HID_KEYBOARD_LEFT_ARROW},
-    {"RIGHTARROW", HID_KEYBOARD_RIGHT_ARROW},
-    {"RIGHT", HID_KEYBOARD_RIGHT_ARROW},
-    {"UPARROW", HID_KEYBOARD_UP_ARROW},
-    {"UP", HID_KEYBOARD_UP_ARROW},
-
-    {"ENTER", HID_KEYBOARD_RETURN},
-    {"BREAK", HID_KEYBOARD_PAUSE},
-    {"PAUSE", HID_KEYBOARD_PAUSE},
-    {"CAPSLOCK", HID_KEYBOARD_CAPS_LOCK},
-    {"DELETE", HID_KEYBOARD_DELETE_FORWARD},
-    {"BACKSPACE", HID_KEYBOARD_DELETE},
-    {"END", HID_KEYBOARD_END},
-    {"ESC", HID_KEYBOARD_ESCAPE},
-    {"ESCAPE", HID_KEYBOARD_ESCAPE},
-    {"HOME", HID_KEYBOARD_HOME},
-    {"INSERT", HID_KEYBOARD_INSERT},
-    {"NUMLOCK", HID_KEYPAD_NUMLOCK},
-    {"PAGEUP", HID_KEYBOARD_PAGE_UP},
-    {"PAGEDOWN", HID_KEYBOARD_PAGE_DOWN},
-    {"PRINTSCREEN", HID_KEYBOARD_PRINT_SCREEN},
-    {"SCROLLLOCK", HID_KEYBOARD_SCROLL_LOCK},
-    {"SPACE", HID_KEYBOARD_SPACEBAR},
-    {"TAB", HID_KEYBOARD_TAB},
-    {"MENU", HID_KEYBOARD_APPLICATION},
-    {"APP", HID_KEYBOARD_APPLICATION},
-
-    {"F1", HID_KEYBOARD_F1},
-    {"F2", HID_KEYBOARD_F2},
-    {"F3", HID_KEYBOARD_F3},
-    {"F4", HID_KEYBOARD_F4},
-    {"F5", HID_KEYBOARD_F5},
-    {"F6", HID_KEYBOARD_F6},
-    {"F7", HID_KEYBOARD_F7},
-    {"F8", HID_KEYBOARD_F8},
-    {"F9", HID_KEYBOARD_F9},
-    {"F10", HID_KEYBOARD_F10},
-    {"F11", HID_KEYBOARD_F11},
-    {"F12", HID_KEYBOARD_F12},
-};
-
-static const char ducky_cmd_comment[] = {"REM"};
-static const char ducky_cmd_id[] = {"ID"};
-static const char ducky_cmd_delay[] = {"DELAY "};
-static const char ducky_cmd_string[] = {"STRING "};
-static const char ducky_cmd_defdelay_1[] = {"DEFAULT_DELAY "};
-static const char ducky_cmd_defdelay_2[] = {"DEFAULTDELAY "};
-static const char ducky_cmd_repeat[] = {"REPEAT "};
-static const char ducky_cmd_sysrq[] = {"SYSRQ "};
-
-static const char ducky_cmd_altchar[] = {"ALTCHAR "};
-static const char ducky_cmd_altstr_1[] = {"ALTSTRING "};
-static const char ducky_cmd_altstr_2[] = {"ALTCODE "};
-
-static const char ducky_cmd_lang[] = {"DUCKY_LANG"};
-
-static const uint8_t numpad_keys[10] = {
-    HID_KEYPAD_0,
-    HID_KEYPAD_1,
-    HID_KEYPAD_2,
-    HID_KEYPAD_3,
-    HID_KEYPAD_4,
-    HID_KEYPAD_5,
-    HID_KEYPAD_6,
-    HID_KEYPAD_7,
-    HID_KEYPAD_8,
-    HID_KEYPAD_9,
-};
-
-static bool ducky_get_number(const char* param, uint32_t* val) {
-    uint32_t value = 0;
-    if(sscanf(param, "%lu", &value) == 1) {
-        *val = value;
-        return true;
-    }
-    return false;
-}
-
-static uint32_t ducky_get_command_len(const char* line) {
-    uint32_t len = strlen(line);
-    for(uint32_t i = 0; i < len; i++) {
-        if(line[i] == ' ') return i;
-    }
-    return 0;
-}
-
-static bool ducky_is_line_end(const char chr) {
-    return ((chr == ' ') || (chr == '\0') || (chr == '\r') || (chr == '\n'));
-}
-
-static void ducky_numlock_on() {
-    if((furi_hal_hid_get_led_state() & HID_KB_LED_NUM) == 0) {
-        furi_hal_hid_kb_press(HID_KEYBOARD_LOCK_NUM_LOCK);
-        furi_hal_hid_kb_release(HID_KEYBOARD_LOCK_NUM_LOCK);
-    }
-}
-
-static bool ducky_numpad_press(const char num) {
-    if((num < '0') || (num > '9')) return false;
-
-    uint16_t key = numpad_keys[num - '0'];
-    furi_hal_hid_kb_press(key);
-    furi_hal_hid_kb_release(key);
-
-    return true;
-}
-
-static bool ducky_altchar(const char* charcode) {
-    uint8_t i = 0;
-    bool state = false;
-
-    FURI_LOG_I(WORKER_TAG, "char %s", charcode);
-
-    furi_hal_hid_kb_press(KEY_MOD_LEFT_ALT);
-
-    while(!ducky_is_line_end(charcode[i])) {
-        state = ducky_numpad_press(charcode[i]);
-        if(state == false) break;
-        i++;
-    }
-
-    furi_hal_hid_kb_release(KEY_MOD_LEFT_ALT);
-    return state;
-}
-
-static bool ducky_altstring(const char* param) {
-    uint32_t i = 0;
-    bool state = false;
-
-    while(param[i] != '\0') {
-        if((param[i] < ' ') || (param[i] > '~')) {
-            i++;
-            continue; // Skip non-printable chars
-        }
-
-        char temp_str[4];
-        snprintf(temp_str, 4, "%u", param[i]);
-
-        state = ducky_altchar(temp_str);
-        if(state == false) break;
-        i++;
-    }
-    return state;
-}
-
-static bool ducky_string(BadUsbScript* bad_usb, const char* param) {
-    uint32_t i = 0;
-    while(param[i] != '\0') {
-        uint16_t keycode = BADUSB_ASCII_TO_KEY(bad_usb, param[i]);
-        if(keycode != HID_KEYBOARD_NONE) {
-            furi_hal_hid_kb_press(keycode);
-            furi_hal_hid_kb_release(keycode);
-        }
-        i++;
-    }
-    return true;
-}
-
-static uint16_t ducky_get_keycode(BadUsbScript* bad_usb, const char* param, bool accept_chars) {
-    for(size_t i = 0; i < (sizeof(ducky_keys) / sizeof(ducky_keys[0])); i++) {
-        size_t key_cmd_len = strlen(ducky_keys[i].name);
-        if((strncmp(param, ducky_keys[i].name, key_cmd_len) == 0) &&
-           (ducky_is_line_end(param[key_cmd_len]))) {
-            return ducky_keys[i].keycode;
-        }
-    }
-    if((accept_chars) && (strlen(param) > 0)) {
-        return (BADUSB_ASCII_TO_KEY(bad_usb, param[0]) & 0xFF);
-    }
-    return 0;
-}
-
-static int32_t
-    ducky_parse_line(BadUsbScript* bad_usb, FuriString* line, char* error, size_t error_len) {
-    uint32_t line_len = furi_string_size(line);
-    const char* line_tmp = furi_string_get_cstr(line);
-    bool state = false;
-
-    if(line_len == 0) {
-        return SCRIPT_STATE_NEXT_LINE; // Skip empty lines
-    }
-
-    FURI_LOG_D(WORKER_TAG, "line:%s", line_tmp);
-
-    // General commands
-    if(strncmp(line_tmp, ducky_cmd_comment, strlen(ducky_cmd_comment)) == 0) {
-        // REM - comment line
-        return (0);
-    } else if(strncmp(line_tmp, ducky_cmd_id, strlen(ducky_cmd_id)) == 0) {
-        // ID - executed in ducky_script_preload
-        return (0);
-    } else if(strncmp(line_tmp, ducky_cmd_lang, strlen(ducky_cmd_lang)) == 0) {
-        // DUCKY_LANG - ignore command to retain compatibility with existing scripts
-        return (0);
-    } else if(strncmp(line_tmp, ducky_cmd_delay, strlen(ducky_cmd_delay)) == 0) {
-        // DELAY
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        uint32_t delay_val = 0;
-        state = ducky_get_number(line_tmp, &delay_val);
-        if((state) && (delay_val > 0)) {
-            return (int32_t)delay_val;
-        }
-        if(error != NULL) {
-            snprintf(error, error_len, "Invalid number %s", line_tmp);
-        }
-        return SCRIPT_STATE_ERROR;
-    } else if(
-        (strncmp(line_tmp, ducky_cmd_defdelay_1, strlen(ducky_cmd_defdelay_1)) == 0) ||
-        (strncmp(line_tmp, ducky_cmd_defdelay_2, strlen(ducky_cmd_defdelay_2)) == 0)) {
-        // DEFAULT_DELAY
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        state = ducky_get_number(line_tmp, &bad_usb->defdelay);
-        if(!state && error != NULL) {
-            snprintf(error, error_len, "Invalid number %s", line_tmp);
-        }
-        return (state) ? (0) : SCRIPT_STATE_ERROR;
-    } else if(strncmp(line_tmp, ducky_cmd_string, strlen(ducky_cmd_string)) == 0) {
-        // STRING
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        state = ducky_string(bad_usb, line_tmp);
-        if(!state && error != NULL) {
-            snprintf(error, error_len, "Invalid string %s", line_tmp);
-        }
-        return (state) ? (0) : SCRIPT_STATE_ERROR;
-    } else if(strncmp(line_tmp, ducky_cmd_altchar, strlen(ducky_cmd_altchar)) == 0) {
-        // ALTCHAR
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        ducky_numlock_on();
-        state = ducky_altchar(line_tmp);
-        if(!state && error != NULL) {
-            snprintf(error, error_len, "Invalid altchar %s", line_tmp);
-        }
-        return (state) ? (0) : SCRIPT_STATE_ERROR;
-    } else if(
-        (strncmp(line_tmp, ducky_cmd_altstr_1, strlen(ducky_cmd_altstr_1)) == 0) ||
-        (strncmp(line_tmp, ducky_cmd_altstr_2, strlen(ducky_cmd_altstr_2)) == 0)) {
-        // ALTSTRING
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        ducky_numlock_on();
-        state = ducky_altstring(line_tmp);
-        if(!state && error != NULL) {
-            snprintf(error, error_len, "Invalid altstring %s", line_tmp);
-        }
-        return (state) ? (0) : SCRIPT_STATE_ERROR;
-    } else if(strncmp(line_tmp, ducky_cmd_repeat, strlen(ducky_cmd_repeat)) == 0) {
-        // REPEAT
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        state = ducky_get_number(line_tmp, &bad_usb->repeat_cnt);
-        if(!state && error != NULL) {
-            snprintf(error, error_len, "Invalid number %s", line_tmp);
-        }
-        return (state) ? (0) : SCRIPT_STATE_ERROR;
-    } else if(strncmp(line_tmp, ducky_cmd_sysrq, strlen(ducky_cmd_sysrq)) == 0) {
-        // SYSRQ
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        uint16_t key = ducky_get_keycode(bad_usb, line_tmp, true);
-        furi_hal_hid_kb_press(KEY_MOD_LEFT_ALT | HID_KEYBOARD_PRINT_SCREEN);
-        furi_hal_hid_kb_press(key);
-        furi_hal_hid_kb_release_all();
-        return (0);
-    } else {
-        // Special keys + modifiers
-        uint16_t key = ducky_get_keycode(bad_usb, line_tmp, false);
-        if(key == HID_KEYBOARD_NONE) {
-            if(error != NULL) {
-                snprintf(error, error_len, "No keycode defined for %s", line_tmp);
-            }
-            return SCRIPT_STATE_ERROR;
-        }
-        if((key & 0xFF00) != 0) {
-            // It's a modifier key
-            line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-            key |= ducky_get_keycode(bad_usb, line_tmp, true);
-        }
-        furi_hal_hid_kb_press(key);
-        furi_hal_hid_kb_release(key);
-        return (0);
-    }
-}
-
-static bool ducky_set_usb_id(BadUsbScript* bad_usb, const char* line) {
-    if(sscanf(line, "%lX:%lX", &bad_usb->hid_cfg.vid, &bad_usb->hid_cfg.pid) == 2) {
-        bad_usb->hid_cfg.manuf[0] = '\0';
-        bad_usb->hid_cfg.product[0] = '\0';
-
-        uint8_t id_len = ducky_get_command_len(line);
-        if(!ducky_is_line_end(line[id_len + 1])) {
-            sscanf(
-                &line[id_len + 1],
-                "%31[^\r\n:]:%31[^\r\n]",
-                bad_usb->hid_cfg.manuf,
-                bad_usb->hid_cfg.product);
-        }
-        FURI_LOG_D(
-            WORKER_TAG,
-            "set id: %04lX:%04lX mfr:%s product:%s",
-            bad_usb->hid_cfg.vid,
-            bad_usb->hid_cfg.pid,
-            bad_usb->hid_cfg.manuf,
-            bad_usb->hid_cfg.product);
-        return true;
-    }
-    return false;
-}
-
-static bool ducky_script_preload(BadUsbScript* bad_usb, File* script_file) {
-    uint8_t ret = 0;
-    uint32_t line_len = 0;
-
-    furi_string_reset(bad_usb->line);
-
-    do {
-        ret = storage_file_read(script_file, bad_usb->file_buf, FILE_BUFFER_LEN);
-        for(uint16_t i = 0; i < ret; i++) {
-            if(bad_usb->file_buf[i] == '\n' && line_len > 0) {
-                bad_usb->st.line_nb++;
-                line_len = 0;
-            } else {
-                if(bad_usb->st.line_nb == 0) { // Save first line
-                    furi_string_push_back(bad_usb->line, bad_usb->file_buf[i]);
-                }
-                line_len++;
-            }
-        }
-        if(storage_file_eof(script_file)) {
-            if(line_len > 0) {
-                bad_usb->st.line_nb++;
-                break;
-            }
-        }
-    } while(ret > 0);
-
-    const char* line_tmp = furi_string_get_cstr(bad_usb->line);
-    bool id_set = false; // Looking for ID command at first line
-    if(strncmp(line_tmp, ducky_cmd_id, strlen(ducky_cmd_id)) == 0) {
-        id_set = ducky_set_usb_id(bad_usb, &line_tmp[strlen(ducky_cmd_id) + 1]);
-    }
-
-    if(id_set) {
-        furi_check(furi_hal_usb_set_config(&usb_hid, &bad_usb->hid_cfg));
-    } else {
-        furi_check(furi_hal_usb_set_config(&usb_hid, NULL));
-    }
-
-    storage_file_seek(script_file, 0, true);
-    furi_string_reset(bad_usb->line);
-
-    return true;
-}
-
-static int32_t ducky_script_execute_next(BadUsbScript* bad_usb, File* script_file) {
-    int32_t delay_val = 0;
-
-    if(bad_usb->repeat_cnt > 0) {
-        bad_usb->repeat_cnt--;
-        delay_val = ducky_parse_line(
-            bad_usb, bad_usb->line_prev, bad_usb->st.error, sizeof(bad_usb->st.error));
-        if(delay_val == SCRIPT_STATE_NEXT_LINE) { // Empty line
-            return 0;
-        } else if(delay_val < 0) { // Script error
-            bad_usb->st.error_line = bad_usb->st.line_cur - 1;
-            FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur - 1U);
-            return SCRIPT_STATE_ERROR;
-        } else {
-            return (delay_val + bad_usb->defdelay);
-        }
-    }
-
-    furi_string_set(bad_usb->line_prev, bad_usb->line);
-    furi_string_reset(bad_usb->line);
-
-    while(1) {
-        if(bad_usb->buf_len == 0) {
-            bad_usb->buf_len = storage_file_read(script_file, bad_usb->file_buf, FILE_BUFFER_LEN);
-            if(storage_file_eof(script_file)) {
-                if((bad_usb->buf_len < FILE_BUFFER_LEN) && (bad_usb->file_end == false)) {
-                    bad_usb->file_buf[bad_usb->buf_len] = '\n';
-                    bad_usb->buf_len++;
-                    bad_usb->file_end = true;
-                }
-            }
-
-            bad_usb->buf_start = 0;
-            if(bad_usb->buf_len == 0) return SCRIPT_STATE_END;
-        }
-        for(uint8_t i = bad_usb->buf_start; i < (bad_usb->buf_start + bad_usb->buf_len); i++) {
-            if(bad_usb->file_buf[i] == '\n' && furi_string_size(bad_usb->line) > 0) {
-                bad_usb->st.line_cur++;
-                bad_usb->buf_len = bad_usb->buf_len + bad_usb->buf_start - (i + 1);
-                bad_usb->buf_start = i + 1;
-                furi_string_trim(bad_usb->line);
-                delay_val = ducky_parse_line(
-                    bad_usb, bad_usb->line, bad_usb->st.error, sizeof(bad_usb->st.error));
-                if(delay_val == SCRIPT_STATE_NEXT_LINE) { // Empty line
-                    return 0;
-                } else if(delay_val < 0) {
-                    bad_usb->st.error_line = bad_usb->st.line_cur;
-                    FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur);
-                    return SCRIPT_STATE_ERROR;
-                } else {
-                    return (delay_val + bad_usb->defdelay);
-                }
-            } else {
-                furi_string_push_back(bad_usb->line, bad_usb->file_buf[i]);
-            }
-        }
-        bad_usb->buf_len = 0;
-        if(bad_usb->file_end) return SCRIPT_STATE_END;
-    }
-
-    return 0;
-}
-
-static void bad_usb_hid_state_callback(bool state, void* context) {
-    furi_assert(context);
-    BadUsbScript* bad_usb = context;
-
-    if(state == true)
-        furi_thread_flags_set(furi_thread_get_id(bad_usb->thread), WorkerEvtConnect);
-    else
-        furi_thread_flags_set(furi_thread_get_id(bad_usb->thread), WorkerEvtDisconnect);
-}
-
-static int32_t bad_usb_worker(void* context) {
-    BadUsbScript* bad_usb = context;
-
-    BadUsbWorkerState worker_state = BadUsbStateInit;
-    int32_t delay_val = 0;
-
-    FuriHalUsbInterface* usb_mode_prev = furi_hal_usb_get_config();
-
-    FURI_LOG_I(WORKER_TAG, "Init");
-    File* script_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
-    bad_usb->line = furi_string_alloc();
-    bad_usb->line_prev = furi_string_alloc();
-
-    furi_hal_hid_set_state_callback(bad_usb_hid_state_callback, bad_usb);
-
-    while(1) {
-        if(worker_state == BadUsbStateInit) { // State: initialization
-            if(storage_file_open(
-                   script_file,
-                   furi_string_get_cstr(bad_usb->file_path),
-                   FSAM_READ,
-                   FSOM_OPEN_EXISTING)) {
-                if((ducky_script_preload(bad_usb, script_file)) && (bad_usb->st.line_nb > 0)) {
-                    if(furi_hal_hid_is_connected()) {
-                        worker_state = BadUsbStateIdle; // Ready to run
-                    } else {
-                        worker_state = BadUsbStateNotConnected; // USB not connected
-                    }
-                } else {
-                    worker_state = BadUsbStateScriptError; // Script preload error
-                }
-            } else {
-                FURI_LOG_E(WORKER_TAG, "File open error");
-                worker_state = BadUsbStateFileError; // File open error
-            }
-            bad_usb->st.state = worker_state;
-
-        } else if(worker_state == BadUsbStateNotConnected) { // State: USB not connected
-            uint32_t flags = furi_thread_flags_wait(
-                WorkerEvtEnd | WorkerEvtConnect | WorkerEvtToggle,
-                FuriFlagWaitAny,
-                FuriWaitForever);
-            furi_check((flags & FuriFlagError) == 0);
-            if(flags & WorkerEvtEnd) {
-                break;
-            } else if(flags & WorkerEvtConnect) {
-                worker_state = BadUsbStateIdle; // Ready to run
-            } else if(flags & WorkerEvtToggle) {
-                worker_state = BadUsbStateWillRun; // Will run when USB is connected
-            }
-            bad_usb->st.state = worker_state;
-
-        } else if(worker_state == BadUsbStateIdle) { // State: ready to start
-            uint32_t flags = furi_thread_flags_wait(
-                WorkerEvtEnd | WorkerEvtToggle | WorkerEvtDisconnect,
-                FuriFlagWaitAny,
-                FuriWaitForever);
-            furi_check((flags & FuriFlagError) == 0);
-            if(flags & WorkerEvtEnd) {
-                break;
-            } else if(flags & WorkerEvtToggle) { // Start executing script
-                DOLPHIN_DEED(DolphinDeedBadUsbPlayScript);
-                delay_val = 0;
-                bad_usb->buf_len = 0;
-                bad_usb->st.line_cur = 0;
-                bad_usb->defdelay = 0;
-                bad_usb->repeat_cnt = 0;
-                bad_usb->file_end = false;
-                storage_file_seek(script_file, 0, true);
-                worker_state = BadUsbStateRunning;
-            } else if(flags & WorkerEvtDisconnect) {
-                worker_state = BadUsbStateNotConnected; // USB disconnected
-            }
-            bad_usb->st.state = worker_state;
-
-        } else if(worker_state == BadUsbStateWillRun) { // State: start on connection
-            uint32_t flags = furi_thread_flags_wait(
-                WorkerEvtEnd | WorkerEvtConnect | WorkerEvtToggle,
-                FuriFlagWaitAny,
-                FuriWaitForever);
-            furi_check((flags & FuriFlagError) == 0);
-            if(flags & WorkerEvtEnd) {
-                break;
-            } else if(flags & WorkerEvtConnect) { // Start executing script
-                DOLPHIN_DEED(DolphinDeedBadUsbPlayScript);
-                delay_val = 0;
-                bad_usb->buf_len = 0;
-                bad_usb->st.line_cur = 0;
-                bad_usb->defdelay = 0;
-                bad_usb->repeat_cnt = 0;
-                bad_usb->file_end = false;
-                storage_file_seek(script_file, 0, true);
-                // extra time for PC to recognize Flipper as keyboard
-                furi_thread_flags_wait(0, FuriFlagWaitAny, 1500);
-                worker_state = BadUsbStateRunning;
-            } else if(flags & WorkerEvtToggle) { // Cancel scheduled execution
-                worker_state = BadUsbStateNotConnected;
-            }
-            bad_usb->st.state = worker_state;
-
-        } else if(worker_state == BadUsbStateRunning) { // State: running
-            uint16_t delay_cur = (delay_val > 1000) ? (1000) : (delay_val);
-            uint32_t flags = furi_thread_flags_wait(
-                WorkerEvtEnd | WorkerEvtToggle | WorkerEvtDisconnect, FuriFlagWaitAny, delay_cur);
-            delay_val -= delay_cur;
-            if(!(flags & FuriFlagError)) {
-                if(flags & WorkerEvtEnd) {
-                    break;
-                } else if(flags & WorkerEvtToggle) {
-                    worker_state = BadUsbStateIdle; // Stop executing script
-                    furi_hal_hid_kb_release_all();
-                } else if(flags & WorkerEvtDisconnect) {
-                    worker_state = BadUsbStateNotConnected; // USB disconnected
-                    furi_hal_hid_kb_release_all();
-                }
-                bad_usb->st.state = worker_state;
-                continue;
-            } else if(
-                (flags == (unsigned)FuriFlagErrorTimeout) ||
-                (flags == (unsigned)FuriFlagErrorResource)) {
-                if(delay_val > 0) {
-                    bad_usb->st.delay_remain--;
-                    continue;
-                }
-                bad_usb->st.state = BadUsbStateRunning;
-                delay_val = ducky_script_execute_next(bad_usb, script_file);
-                if(delay_val == SCRIPT_STATE_ERROR) { // Script error
-                    delay_val = 0;
-                    worker_state = BadUsbStateScriptError;
-                    bad_usb->st.state = worker_state;
-                } else if(delay_val == SCRIPT_STATE_END) { // End of script
-                    delay_val = 0;
-                    worker_state = BadUsbStateIdle;
-                    bad_usb->st.state = BadUsbStateDone;
-                    furi_hal_hid_kb_release_all();
-                    continue;
-                } else if(delay_val > 1000) {
-                    bad_usb->st.state = BadUsbStateDelay; // Show long delays
-                    bad_usb->st.delay_remain = delay_val / 1000;
-                }
-            } else {
-                furi_check((flags & FuriFlagError) == 0);
-            }
-
-        } else if(
-            (worker_state == BadUsbStateFileError) ||
-            (worker_state == BadUsbStateScriptError)) { // State: error
-            uint32_t flags = furi_thread_flags_wait(
-                WorkerEvtEnd, FuriFlagWaitAny, FuriWaitForever); // Waiting for exit command
-            furi_check((flags & FuriFlagError) == 0);
-            if(flags & WorkerEvtEnd) {
-                break;
-            }
-        }
-    }
-
-    furi_hal_hid_set_state_callback(NULL, NULL);
-
-    furi_hal_usb_set_config(usb_mode_prev, NULL);
-
-    storage_file_close(script_file);
-    storage_file_free(script_file);
-    furi_string_free(bad_usb->line);
-    furi_string_free(bad_usb->line_prev);
-
-    FURI_LOG_I(WORKER_TAG, "End");
-
-    return 0;
-}
-
-static void bad_usb_script_set_default_keyboard_layout(BadUsbScript* bad_usb) {
-    furi_assert(bad_usb);
-    memset(bad_usb->layout, HID_KEYBOARD_NONE, sizeof(bad_usb->layout));
-    memcpy(bad_usb->layout, hid_asciimap, MIN(sizeof(hid_asciimap), sizeof(bad_usb->layout)));
-}
-
-BadUsbScript* bad_usb_script_open(FuriString* file_path) {
-    furi_assert(file_path);
-
-    BadUsbScript* bad_usb = malloc(sizeof(BadUsbScript));
-    bad_usb->file_path = furi_string_alloc();
-    furi_string_set(bad_usb->file_path, file_path);
-    bad_usb_script_set_default_keyboard_layout(bad_usb);
-
-    bad_usb->st.state = BadUsbStateInit;
-    bad_usb->st.error[0] = '\0';
-
-    bad_usb->thread = furi_thread_alloc_ex("BadUsbWorker", 2048, bad_usb_worker, bad_usb);
-    furi_thread_start(bad_usb->thread);
-    return bad_usb;
-} //-V773
-
-void bad_usb_script_close(BadUsbScript* bad_usb) {
-    furi_assert(bad_usb);
-    furi_thread_flags_set(furi_thread_get_id(bad_usb->thread), WorkerEvtEnd);
-    furi_thread_join(bad_usb->thread);
-    furi_thread_free(bad_usb->thread);
-    furi_string_free(bad_usb->file_path);
-    free(bad_usb);
-}
-
-void bad_usb_script_set_keyboard_layout(BadUsbScript* bad_usb, FuriString* layout_path) {
-    furi_assert(bad_usb);
-
-    if((bad_usb->st.state == BadUsbStateRunning) || (bad_usb->st.state == BadUsbStateDelay)) {
-        // do not update keyboard layout while a script is running
-        return;
-    }
-
-    File* layout_file = storage_file_alloc(furi_record_open(RECORD_STORAGE));
-    if(!furi_string_empty(layout_path)) {
-        if(storage_file_open(
-               layout_file, furi_string_get_cstr(layout_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
-            uint16_t layout[128];
-            if(storage_file_read(layout_file, layout, sizeof(layout)) == sizeof(layout)) {
-                memcpy(bad_usb->layout, layout, sizeof(layout));
-            }
-        }
-        storage_file_close(layout_file);
-    } else {
-        bad_usb_script_set_default_keyboard_layout(bad_usb);
-    }
-    storage_file_free(layout_file);
-}
-
-void bad_usb_script_toggle(BadUsbScript* bad_usb) {
-    furi_assert(bad_usb);
-    furi_thread_flags_set(furi_thread_get_id(bad_usb->thread), WorkerEvtToggle);
-}
-
-BadUsbState* bad_usb_script_get_state(BadUsbScript* bad_usb) {
-    furi_assert(bad_usb);
-    return &(bad_usb->st);
-}

applications/main/bad_usb/bad_usb_script.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <furi.h>
-
-typedef struct BadUsbScript BadUsbScript;
-
-typedef enum {
-    BadUsbStateInit,
-    BadUsbStateNotConnected,
-    BadUsbStateIdle,
-    BadUsbStateWillRun,
-    BadUsbStateRunning,
-    BadUsbStateDelay,
-    BadUsbStateDone,
-    BadUsbStateScriptError,
-    BadUsbStateFileError,
-} BadUsbWorkerState;
-
-typedef struct {
-    BadUsbWorkerState state;
-    uint16_t line_cur;
-    uint16_t line_nb;
-    uint32_t delay_remain;
-    uint16_t error_line;
-    char error[64];
-} BadUsbState;
-
-BadUsbScript* bad_usb_script_open(FuriString* file_path);
-
-void bad_usb_script_close(BadUsbScript* bad_usb);
-
-void bad_usb_script_set_keyboard_layout(BadUsbScript* bad_usb, FuriString* layout_path);
-
-void bad_usb_script_start(BadUsbScript* bad_usb);
-
-void bad_usb_script_stop(BadUsbScript* bad_usb);
-
-void bad_usb_script_toggle(BadUsbScript* bad_usb);
-
-BadUsbState* bad_usb_script_get_state(BadUsbScript* bad_usb);
-
-#ifdef __cplusplus
-}
-#endif

applications/main/bad_usb/bad_usb_settings_filename.h

@@ -1,3 +0,0 @@
-#pragma once
-
-#define BAD_USB_SETTINGS_FILE_NAME ".badusb.settings"

applications/main/bad_usb/scenes/bad_usb_scene.c

@@ -1,30 +0,0 @@
-#include "bad_usb_scene.h"
-
-// Generate scene on_enter handlers array
-#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
-void (*const bad_usb_scene_on_enter_handlers[])(void*) = {
-#include "bad_usb_scene_config.h"
-};
-#undef ADD_SCENE
-
-// Generate scene on_event handlers array
-#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
-bool (*const bad_usb_scene_on_event_handlers[])(void* context, SceneManagerEvent event) = {
-#include "bad_usb_scene_config.h"
-};
-#undef ADD_SCENE
-
-// Generate scene on_exit handlers array
-#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
-void (*const bad_usb_scene_on_exit_handlers[])(void* context) = {
-#include "bad_usb_scene_config.h"
-};
-#undef ADD_SCENE
-
-// Initialize scene handlers configuration structure
-const SceneManagerHandlers bad_usb_scene_handlers = {
-    .on_enter_handlers = bad_usb_scene_on_enter_handlers,
-    .on_event_handlers = bad_usb_scene_on_event_handlers,
-    .on_exit_handlers = bad_usb_scene_on_exit_handlers,
-    .scene_num = BadUsbSceneNum,
-};

applications/main/bad_usb/scenes/bad_usb_scene_config.c

@@ -1,53 +0,0 @@
-#include "../bad_usb_app_i.h"
-#include "furi_hal_power.h"
-#include "furi_hal_usb.h"
-
-enum SubmenuIndex {
-    SubmenuIndexKeyboardLayout,
-};
-
-void bad_usb_scene_config_submenu_callback(void* context, uint32_t index) {
-    BadUsbApp* bad_usb = context;
-    view_dispatcher_send_custom_event(bad_usb->view_dispatcher, index);
-}
-
-void bad_usb_scene_config_on_enter(void* context) {
-    BadUsbApp* bad_usb = context;
-    Submenu* submenu = bad_usb->submenu;
-
-    submenu_add_item(
-        submenu,
-        "Keyboard layout",
-        SubmenuIndexKeyboardLayout,
-        bad_usb_scene_config_submenu_callback,
-        bad_usb);
-
-    submenu_set_selected_item(
-        submenu, scene_manager_get_scene_state(bad_usb->scene_manager, BadUsbSceneConfig));
-
-    view_dispatcher_switch_to_view(bad_usb->view_dispatcher, BadUsbAppViewConfig);
-}
-
-bool bad_usb_scene_config_on_event(void* context, SceneManagerEvent event) {
-    BadUsbApp* bad_usb = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        scene_manager_set_scene_state(bad_usb->scene_manager, BadUsbSceneConfig, event.event);
-        consumed = true;
-        if(event.event == SubmenuIndexKeyboardLayout) {
-            scene_manager_next_scene(bad_usb->scene_manager, BadUsbSceneConfigLayout);
-        } else {
-            furi_crash("Unknown key type");
-        }
-    }
-
-    return consumed;
-}
-
-void bad_usb_scene_config_on_exit(void* context) {
-    BadUsbApp* bad_usb = context;
-    Submenu* submenu = bad_usb->submenu;
-
-    submenu_reset(submenu);
-}

applications/main/bad_usb/scenes/bad_usb_scene_config.h

@@ -1,5 +0,0 @@
-ADD_SCENE(bad_usb, file_select, FileSelect)
-ADD_SCENE(bad_usb, work, Work)
-ADD_SCENE(bad_usb, error, Error)
-ADD_SCENE(bad_usb, config, Config)
-ADD_SCENE(bad_usb, config_layout, ConfigLayout)

applications/main/bad_usb/scenes/bad_usb_scene_config_layout.c

@@ -1,48 +0,0 @@
-#include "../bad_usb_app_i.h"
-#include "furi_hal_power.h"
-#include "furi_hal_usb.h"
-#include <storage/storage.h>
-
-static bool bad_usb_layout_select(BadUsbApp* bad_usb) {
-    furi_assert(bad_usb);
-
-    FuriString* predefined_path;
-    predefined_path = furi_string_alloc();
-    if(!furi_string_empty(bad_usb->keyboard_layout)) {
-        furi_string_set(predefined_path, bad_usb->keyboard_layout);
-    } else {
-        furi_string_set(predefined_path, BAD_USB_APP_PATH_LAYOUT_FOLDER);
-    }
-
-    DialogsFileBrowserOptions browser_options;
-    dialog_file_browser_set_basic_options(
-        &browser_options, BAD_USB_APP_LAYOUT_EXTENSION, &I_keyboard_10px);
-
-    // Input events and views are managed by file_browser
-    bool res = dialog_file_browser_show(
-        bad_usb->dialogs, bad_usb->keyboard_layout, predefined_path, &browser_options);
-
-    furi_string_free(predefined_path);
-    return res;
-}
-
-void bad_usb_scene_config_layout_on_enter(void* context) {
-    BadUsbApp* bad_usb = context;
-
-    if(bad_usb_layout_select(bad_usb)) {
-        bad_usb_script_set_keyboard_layout(bad_usb->bad_usb_script, bad_usb->keyboard_layout);
-    }
-    scene_manager_previous_scene(bad_usb->scene_manager);
-}
-
-bool bad_usb_scene_config_layout_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    // BadUsbApp* bad_usb = context;
-    return false;
-}
-
-void bad_usb_scene_config_layout_on_exit(void* context) {
-    UNUSED(context);
-    // BadUsbApp* bad_usb = context;
-}

applications/main/bad_usb/scenes/bad_usb_scene_file_select.c

@@ -1,52 +0,0 @@
-#include "../bad_usb_app_i.h"
-#include <furi_hal_power.h>
-#include <furi_hal_usb.h>
-#include <storage/storage.h>
-
-static bool bad_usb_file_select(BadUsbApp* bad_usb) {
-    furi_assert(bad_usb);
-
-    DialogsFileBrowserOptions browser_options;
-    dialog_file_browser_set_basic_options(
-        &browser_options, BAD_USB_APP_SCRIPT_EXTENSION, &I_badusb_10px);
-    browser_options.base_path = BAD_USB_APP_BASE_FOLDER;
-    browser_options.skip_assets = true;
-
-    // Input events and views are managed by file_browser
-    bool res = dialog_file_browser_show(
-        bad_usb->dialogs, bad_usb->file_path, bad_usb->file_path, &browser_options);
-
-    return res;
-}
-
-void bad_usb_scene_file_select_on_enter(void* context) {
-    BadUsbApp* bad_usb = context;
-
-    furi_hal_usb_disable();
-    if(bad_usb->bad_usb_script) {
-        bad_usb_script_close(bad_usb->bad_usb_script);
-        bad_usb->bad_usb_script = NULL;
-    }
-
-    if(bad_usb_file_select(bad_usb)) {
-        bad_usb->bad_usb_script = bad_usb_script_open(bad_usb->file_path);
-        bad_usb_script_set_keyboard_layout(bad_usb->bad_usb_script, bad_usb->keyboard_layout);
-
-        scene_manager_next_scene(bad_usb->scene_manager, BadUsbSceneWork);
-    } else {
-        furi_hal_usb_enable();
-        view_dispatcher_stop(bad_usb->view_dispatcher);
-    }
-}
-
-bool bad_usb_scene_file_select_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    // BadUsbApp* bad_usb = context;
-    return false;
-}
-
-void bad_usb_scene_file_select_on_exit(void* context) {
-    UNUSED(context);
-    // BadUsbApp* bad_usb = context;
-}

applications/main/bad_usb/scenes/bad_usb_scene_work.c

@@ -1,54 +0,0 @@
-#include "../bad_usb_script.h"
-#include "../bad_usb_app_i.h"
-#include "../views/bad_usb_view.h"
-#include <furi_hal.h>
-#include "toolbox/path.h"
-
-void bad_usb_scene_work_button_callback(InputKey key, void* context) {
-    furi_assert(context);
-    BadUsbApp* app = context;
-    view_dispatcher_send_custom_event(app->view_dispatcher, key);
-}
-
-bool bad_usb_scene_work_on_event(void* context, SceneManagerEvent event) {
-    BadUsbApp* app = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == InputKeyLeft) {
-            scene_manager_next_scene(app->scene_manager, BadUsbSceneConfig);
-            consumed = true;
-        } else if(event.event == InputKeyOk) {
-            bad_usb_script_toggle(app->bad_usb_script);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeTick) {
-        bad_usb_set_state(app->bad_usb_view, bad_usb_script_get_state(app->bad_usb_script));
-    }
-    return consumed;
-}
-
-void bad_usb_scene_work_on_enter(void* context) {
-    BadUsbApp* app = context;
-
-    FuriString* file_name;
-    file_name = furi_string_alloc();
-    path_extract_filename(app->file_path, file_name, true);
-    bad_usb_set_file_name(app->bad_usb_view, furi_string_get_cstr(file_name));
-    furi_string_free(file_name);
-
-    FuriString* layout;
-    layout = furi_string_alloc();
-    path_extract_filename(app->keyboard_layout, layout, true);
-    bad_usb_set_layout(app->bad_usb_view, furi_string_get_cstr(layout));
-    furi_string_free(layout);
-
-    bad_usb_set_state(app->bad_usb_view, bad_usb_script_get_state(app->bad_usb_script));
-
-    bad_usb_set_button_callback(app->bad_usb_view, bad_usb_scene_work_button_callback, app);
-    view_dispatcher_switch_to_view(app->view_dispatcher, BadUsbAppViewWork);
-}
-
-void bad_usb_scene_work_on_exit(void* context) {
-    UNUSED(context);
-}

applications/main/bad_usb/views/bad_usb_view.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include <gui/view.h>
-#include "../bad_usb_script.h"
-
-typedef struct BadUsb BadUsb;
-typedef void (*BadUsbButtonCallback)(InputKey key, void* context);
-
-BadUsb* bad_usb_alloc();
-
-void bad_usb_free(BadUsb* bad_usb);
-
-View* bad_usb_get_view(BadUsb* bad_usb);
-
-void bad_usb_set_button_callback(BadUsb* bad_usb, BadUsbButtonCallback callback, void* context);
-
-void bad_usb_set_file_name(BadUsb* bad_usb, const char* name);
-
-void bad_usb_set_layout(BadUsb* bad_usb, const char* layout);
-
-void bad_usb_set_state(BadUsb* bad_usb, BadUsbState* st);

applications/main/gpio/scenes/gpio_scene_start.c

@@ -1,3 +1,6 @@
+#ifndef __GPIO_SCENE_START_H__
+#define __GPIO_SCENE_START_H__
+
 #include "../gpio_app_i.h"
 #include <furi_hal_power.h>
 #include <furi_hal_usb.h>
@@ -118,3 +121,5 @@ void gpio_scene_start_on_exit(void* context) {
     GpioApp* app = context;
     variable_item_list_reset(app->var_item_list);
 }
+
+#endif // __GPIO_SCENE_START_H__

applications/plugins/dolphinbackup/storage_DolphinBackup.c

@@ -16,7 +16,7 @@ static const char* app_dirsDolphinBackup[] = {
     "nfc",
     "infrared",
     "ibutton",
-    "badusb",
+    "badkb",
     ".bt.settings",
     ".desktop.settings",
     ".dolphin.state",

applications/plugins/mousejacker/mousejacker.c

@@ -112,7 +112,7 @@ static bool open_ducky_script(Stream* stream, PluginState* plugin_state) {
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(
-        &browser_options, MOUSEJACKER_APP_PATH_EXTENSION, &I_badusb_10px);
+        &browser_options, MOUSEJACKER_APP_PATH_EXTENSION, &I_badkb_10px);
     browser_options.hide_ext = false;
 
     bool ret = dialog_file_browser_show(dialogs, path, path, &browser_options);
@@ -396,4 +396,4 @@ int32_t mousejacker_app(void* p) {
     free(plugin_state);
 
     return 0;
-}
+}

applications/plugins/totp/services/config/config.c

@@ -132,7 +132,7 @@ static TotpConfigFileOpenResult totp_open_config_file(Storage* storage, FlipperF
         flipper_format_write_comment_cstr(fff_data_file, " ");
         flipper_format_write_comment_cstr(
             fff_data_file,
-            "How to notify user when new token is generated or badusb mode is activated (possible values: 0 - do not notify, 1 - sound, 2 - vibro, 3 sound and vibro)");
+            "How to notify user when new token is generated or badkb mode is activated (possible values: 0 - do not notify, 1 - sound, 2 - vibro, 3 sound and vibro)");
         flipper_format_write_uint32(
             fff_data_file, TOTP_CONFIG_KEY_NOTIFICATION_METHOD, &tmp_uint32, 1);
 
@@ -769,4 +769,4 @@ void totp_config_file_reset() {
     Storage* storage = totp_open_storage();
     storage_simply_remove(storage, CONFIG_FILE_PATH);
     totp_close_storage();
-}
+}

applications/plugins/totp/ui/scenes/generate_token/totp_scene_generate_token.c

@@ -24,7 +24,7 @@ typedef struct {
     uint32_t last_token_gen_time;
     TotpTypeCodeWorkerContext* type_code_worker_context;
     NotificationMessage const** notification_sequence_new_token;
-    NotificationMessage const** notification_sequence_badusb;
+    NotificationMessage const** notification_sequence_badkb;
 } SceneState;
 
 static const NotificationSequence*
@@ -69,8 +69,8 @@ static const NotificationSequence*
 }
 
 static const NotificationSequence*
-    get_notification_sequence_badusb(const PluginState* plugin_state, SceneState* scene_state) {
-    if(scene_state->notification_sequence_badusb == NULL) {
+    get_notification_sequence_badkb(const PluginState* plugin_state, SceneState* scene_state) {
+    if(scene_state->notification_sequence_badkb == NULL) {
         uint8_t i = 0;
         uint8_t length = 3;
         if(plugin_state->notification_method & NotificationMethodVibro) {
@@ -81,36 +81,36 @@ static const NotificationSequence*
             length += 6;
         }
 
-        scene_state->notification_sequence_badusb = malloc(sizeof(void*) * length);
-        furi_check(scene_state->notification_sequence_badusb != NULL);
+        scene_state->notification_sequence_badkb = malloc(sizeof(void*) * length);
+        furi_check(scene_state->notification_sequence_badkb != NULL);
 
-        scene_state->notification_sequence_badusb[i++] = &message_blue_255;
+        scene_state->notification_sequence_badkb[i++] = &message_blue_255;
         if(plugin_state->notification_method & NotificationMethodVibro) {
-            scene_state->notification_sequence_badusb[i++] = &message_vibro_on;
+            scene_state->notification_sequence_badkb[i++] = &message_vibro_on;
         }
 
         if(plugin_state->notification_method & NotificationMethodSound) {
-            scene_state->notification_sequence_badusb[i++] = &message_note_d5; //-V525
-            scene_state->notification_sequence_badusb[i++] = &message_delay_50;
-            scene_state->notification_sequence_badusb[i++] = &message_note_e4;
-            scene_state->notification_sequence_badusb[i++] = &message_delay_50;
-            scene_state->notification_sequence_badusb[i++] = &message_note_f3;
+            scene_state->notification_sequence_badkb[i++] = &message_note_d5; //-V525
+            scene_state->notification_sequence_badkb[i++] = &message_delay_50;
+            scene_state->notification_sequence_badkb[i++] = &message_note_e4;
+            scene_state->notification_sequence_badkb[i++] = &message_delay_50;
+            scene_state->notification_sequence_badkb[i++] = &message_note_f3;
         }
 
-        scene_state->notification_sequence_badusb[i++] = &message_delay_50;
+        scene_state->notification_sequence_badkb[i++] = &message_delay_50;
 
         if(plugin_state->notification_method & NotificationMethodVibro) {
-            scene_state->notification_sequence_badusb[i++] = &message_vibro_off;
+            scene_state->notification_sequence_badkb[i++] = &message_vibro_off;
         }
 
         if(plugin_state->notification_method & NotificationMethodSound) {
-            scene_state->notification_sequence_badusb[i++] = &message_sound_off;
+            scene_state->notification_sequence_badkb[i++] = &message_sound_off;
         }
 
-        scene_state->notification_sequence_badusb[i++] = NULL;
+        scene_state->notification_sequence_badkb[i++] = NULL;
     }
 
-    return (NotificationSequence*)scene_state->notification_sequence_badusb;
+    return (NotificationSequence*)scene_state->notification_sequence_badkb;
 }
 
 static void int_token_to_str(uint32_t i_token_code, char* str, TokenDigitsCount len) {
@@ -340,7 +340,7 @@ bool totp_scene_generate_token_handle_event(
             scene_state->type_code_worker_context, TotpTypeCodeWorkerEventType);
         notification_message(
             plugin_state->notification_app,
-            get_notification_sequence_badusb(plugin_state, scene_state));
+            get_notification_sequence_badkb(plugin_state, scene_state));
         return true;
     }
 
@@ -399,8 +399,8 @@ void totp_scene_generate_token_deactivate(PluginState* plugin_state) {
         free(scene_state->notification_sequence_new_token);
     }
 
-    if(scene_state->notification_sequence_badusb != NULL) {
-        free(scene_state->notification_sequence_badusb);
+    if(scene_state->notification_sequence_badkb != NULL) {
+        free(scene_state->notification_sequence_badkb);
     }
 
     free(scene_state);

applications/services/bt/bt_service/bt.c

@@ -77,6 +77,8 @@ static void bt_pin_code_hide(Bt* bt) {
 static bool bt_pin_code_verify_event_handler(Bt* bt, uint32_t pin) {
     furi_assert(bt);
 
+    if(bt_get_profile_pairing_method(bt) == GapPairingNone) return true;
+
     notification_message(bt->notification, &sequence_display_backlight_on);
     FuriString* pin_str;
     dialog_message_set_icon(bt->dialog_message, XTREME_ASSETS()->I_BLE_Pairing_128x64, 0, 0);
@@ -86,6 +88,7 @@ static bool bt_pin_code_verify_event_handler(Bt* bt, uint32_t pin) {
     dialog_message_set_buttons(bt->dialog_message, "Cancel", "OK", NULL);
     DialogMessageButton button = dialog_message_show(bt->dialogs, bt->dialog_message);
     furi_string_free(pin_str);
+
     return button == DialogMessageButtonCenter;
 }
 
@@ -370,6 +373,87 @@ static void bt_close_connection(Bt* bt) {
     furi_event_flag_set(bt->api_event, BT_API_UNLOCK_EVENT);
 }
 
+static inline FuriHalBtProfile get_hal_bt_profile(BtProfile profile) {
+    if(profile == BtProfileHidKeyboard) {
+        return FuriHalBtProfileHidKeyboard;
+    } else {
+        return FuriHalBtProfileSerial;
+    }
+}
+
+static void bt_restart(Bt* bt) {
+    furi_hal_bt_change_app(get_hal_bt_profile(bt->profile), bt_on_gap_event_callback, bt);
+    furi_hal_bt_start_advertising();
+}
+
+void bt_set_profile_adv_name(Bt* bt, const char* fmt, ...) {
+    furi_assert(bt);
+    furi_assert(fmt);
+
+    char name[FURI_HAL_VERSION_DEVICE_NAME_LENGTH];
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(name, sizeof(name), fmt, args);
+    va_end(args);
+    furi_hal_bt_set_profile_adv_name(get_hal_bt_profile(bt->profile), name);
+
+    bt_restart(bt);
+}
+
+const char* bt_get_profile_adv_name(Bt* bt) {
+    furi_assert(bt);
+    return furi_hal_bt_get_profile_adv_name(get_hal_bt_profile(bt->profile));
+}
+
+void bt_set_profile_mac_address(Bt* bt, const uint8_t mac[6]) {
+    furi_assert(bt);
+    furi_assert(mac);
+
+    furi_hal_bt_set_profile_mac_addr(get_hal_bt_profile(bt->profile), mac);
+
+    bt_restart(bt);
+}
+
+const uint8_t* bt_get_profile_mac_address(Bt* bt) {
+    furi_assert(bt);
+    return furi_hal_bt_get_profile_mac_addr(get_hal_bt_profile(bt->profile));
+}
+
+bool bt_remote_rssi(Bt* bt, BtRssi* rssi) {
+    furi_assert(bt);
+    UNUSED(rssi);
+
+    uint8_t rssi_val;
+    uint32_t since = furi_hal_bt_get_conn_rssi(&rssi_val);
+
+    if(since == 0) return false;
+
+    rssi->rssi = rssi_val;
+    rssi->since = since;
+
+    return true;
+}
+
+void bt_set_profile_pairing_method(Bt* bt, GapPairing pairing_method) {
+    furi_assert(bt);
+    furi_hal_bt_set_profile_pairing_method(get_hal_bt_profile(bt->profile), pairing_method);
+    bt_restart(bt);
+}
+
+GapPairing bt_get_profile_pairing_method(Bt* bt) {
+    furi_assert(bt);
+    return furi_hal_bt_get_profile_pairing_method(get_hal_bt_profile(bt->profile));
+}
+
+void bt_disable_peer_key_update(Bt* bt) {
+    UNUSED(bt);
+    furi_hal_bt_set_key_storage_change_callback(NULL, NULL);
+}
+
+void bt_enable_peer_key_update(Bt* bt) {
+    furi_hal_bt_set_key_storage_change_callback(bt_on_key_storage_change_callback, bt);
+}
+
 int32_t bt_srv(void* p) {
     UNUSED(p);
     Bt* bt = bt_alloc();

applications/services/bt/bt_service/bt.h

@@ -2,6 +2,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include <furi_hal_bt.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -23,6 +24,11 @@ typedef enum {
     BtProfileHidKeyboard,
 } BtProfile;
 
+typedef struct {
+    uint8_t rssi;
+    uint32_t since;
+} BtRssi;
+
 typedef void (*BtStatusChangedCallback)(BtStatus status, void* context);
 
 /** Change BLE Profile
@@ -35,6 +41,28 @@ typedef void (*BtStatusChangedCallback)(BtStatus status, void* context);
  */
 bool bt_set_profile(Bt* bt, BtProfile profile);
 
+void bt_set_profile_adv_name(Bt* bt, const char* fmt, ...);
+const char* bt_get_profile_adv_name(Bt* bt);
+
+void bt_set_profile_mac_address(Bt* bt, const uint8_t mac[6]);
+const uint8_t* bt_get_profile_mac_address(Bt* bt);
+
+bool bt_remote_rssi(Bt* bt, BtRssi* rssi);
+
+void bt_set_profile_pairing_method(Bt* bt, GapPairing pairing_method);
+GapPairing bt_get_profile_pairing_method(Bt* bt);
+
+/** Stop saving new peer key to flash (in .bt.keys file)
+ * 
+*/
+void bt_disable_peer_key_update(Bt* bt);
+
+/** Enable saving peer key to internal flash (enable by default)
+ * 
+ * @note This function should be called if bt_disable_peer_key_update was called before
+*/
+void bt_enable_peer_key_update(Bt* bt);
+
 /** Disconnect from Central
  *
  * @param bt        Bt instance

applications/services/dolphin/helpers/dolphin_deed.c

@@ -34,7 +34,7 @@ static const DolphinDeedWeight dolphin_deed_weights[] = {
     {2, DolphinAppIbutton}, // DolphinDeedIbuttonEmulate
     {2, DolphinAppIbutton}, // DolphinDeedIbuttonAdd
 
-    {3, DolphinAppBadusb}, // DolphinDeedBadUsbPlayScript
+    {3, DolphinAppBadKb}, // DolphinDeedBadKbPlayScript
     {3, DolphinAppPlugin}, // DolphinDeedU2fAuthorized
 
     {1, DolphinAppPlugin}, // DolphinDeedGpioUartBridge
@@ -50,7 +50,7 @@ static uint8_t dolphin_deed_limits[] = {
     20, // DolphinAppNfc
     20, // DolphinAppIr
     20, // DolphinAppIbutton
-    20, // DolphinAppBadusb
+    20, // DolphinAppBadKb
     20, // DolphinAppPlugin
 };
 

applications/services/dolphin/helpers/dolphin_deed.h

@@ -12,7 +12,7 @@ typedef enum {
     DolphinAppNfc,
     DolphinAppIr,
     DolphinAppIbutton,
-    DolphinAppBadusb,
+    DolphinAppBadKb,
     DolphinAppPlugin,
     DolphinAppMAX,
 } DolphinApp;
@@ -50,7 +50,7 @@ typedef enum {
     DolphinDeedIbuttonEmulate,
     DolphinDeedIbuttonAdd,
 
-    DolphinDeedBadUsbPlayScript,
+    DolphinDeedBadKbPlayScript,
 
     DolphinDeedU2fAuthorized,
     DolphinDeedGpioUartBridge,

assets/resources/badkb/.badkb.settings

@@ -0,0 +1 @@
+/any/badkb/layouts/en-US.kl

assets/resources/badkb/demo_macos.txt

@@ -2,7 +2,7 @@ ID 1234:5678 Apple:Keyboard
 REM You can change these values to VID/PID of original Apple keyboard
 REM to bypass Keyboard Setup Assistant
 
-REM This is BadUSB demo script for macOS
+REM This is BadKB demo script for macOS
 
 REM Open terminal window
 DELAY 1000
@@ -75,7 +75,7 @@ ENTER
 HOME
 ENTER
 
-STRING Flipper Zero BadUSB feature is compatible with USB Rubber Ducky script format
+STRING Flipper Zero BadKB feature is compatible with USB Rubber Ducky script format
 ENTER
 STRING More information about script syntax can be found here:
 ENTER

assets/resources/badkb/demo_windows.txt

@@ -1,4 +1,4 @@
-REM This is BadUSB demo script for windows
+REM This is BadKB demo script for windows
 
 REM Open windows notepad
 DELAY 1000
@@ -76,7 +76,7 @@ ENTER
 HOME
 ENTER
 
-STRING Flipper Zero BadUSB feature is compatible with USB Rubber Ducky script format
+STRING Flipper Zero BadKB feature is compatible with USB Rubber Ducky script format
 ENTER
 STRING More information about script syntax can be found here:
 ENTER