Move plugins to external folder

applications/external/wifi_marauder_companion/scenes/wifi_marauder_scene.c

@@ -0,0 +1,30 @@
+#include "wifi_marauder_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const wifi_marauder_scene_on_enter_handlers[])(void*) = {
+#include "wifi_marauder_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 wifi_marauder_scene_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "wifi_marauder_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 wifi_marauder_scene_on_exit_handlers[])(void* context) = {
+#include "wifi_marauder_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers wifi_marauder_scene_handlers = {
+    .on_enter_handlers = wifi_marauder_scene_on_enter_handlers,
+    .on_event_handlers = wifi_marauder_scene_on_event_handlers,
+    .on_exit_handlers = wifi_marauder_scene_on_exit_handlers,
+    .scene_num = WifiMarauderSceneNum,
+};

applications/external/wifi_marauder_companion/scenes/wifi_marauder_scene.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) WifiMarauderScene##id,
+typedef enum {
+#include "wifi_marauder_scene_config.h"
+    WifiMarauderSceneNum,
+} WifiMarauderScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers wifi_marauder_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "wifi_marauder_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 "wifi_marauder_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 "wifi_marauder_scene_config.h"
+#undef ADD_SCENE

applications/external/wifi_marauder_companion/scenes/wifi_marauder_scene_config.h

@@ -0,0 +1,3 @@
+ADD_SCENE(wifi_marauder, start, Start)
+ADD_SCENE(wifi_marauder, console_output, ConsoleOutput)
+ADD_SCENE(wifi_marauder, text_input, TextInput)

applications/external/wifi_marauder_companion/scenes/wifi_marauder_scene_console_output.c

@@ -0,0 +1,92 @@
+#include "../wifi_marauder_app_i.h"
+
+void wifi_marauder_console_output_handle_rx_data_cb(uint8_t* buf, size_t len, void* context) {
+    furi_assert(context);
+    WifiMarauderApp* app = context;
+
+    // If text box store gets too big, then truncate it
+    app->text_box_store_strlen += len;
+    if(app->text_box_store_strlen >= WIFI_MARAUDER_TEXT_BOX_STORE_SIZE - 1) {
+        furi_string_right(app->text_box_store, app->text_box_store_strlen / 2);
+        app->text_box_store_strlen = furi_string_size(app->text_box_store) + len;
+    }
+
+    // Null-terminate buf and append to text box store
+    buf[len] = '\0';
+    furi_string_cat_printf(app->text_box_store, "%s", buf);
+
+    view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventRefreshConsoleOutput);
+}
+
+void wifi_marauder_scene_console_output_on_enter(void* context) {
+    WifiMarauderApp* app = context;
+
+    TextBox* text_box = app->text_box;
+    text_box_reset(app->text_box);
+    text_box_set_font(text_box, TextBoxFontText);
+    if(app->focus_console_start) {
+        text_box_set_focus(text_box, TextBoxFocusStart);
+    } else {
+        text_box_set_focus(text_box, TextBoxFocusEnd);
+    }
+    if(app->is_command) {
+        furi_string_reset(app->text_box_store);
+        app->text_box_store_strlen = 0;
+        if(0 == strncmp("help", app->selected_tx_string, strlen("help"))) {
+            const char* help_msg =
+                "Marauder companion v0.3.0\nFor app support/feedback,\nreach out to me:\n@cococode#6011 (discord)\n0xchocolate (github)\n";
+            furi_string_cat_str(app->text_box_store, help_msg);
+            app->text_box_store_strlen += strlen(help_msg);
+        }
+
+        if(app->show_stopscan_tip) {
+            const char* help_msg = "Press BACK to send stopscan\n";
+            furi_string_cat_str(app->text_box_store, help_msg);
+            app->text_box_store_strlen += strlen(help_msg);
+        }
+    }
+
+    // Set starting text - for "View Log", this will just be what was already in the text box store
+    text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store));
+
+    scene_manager_set_scene_state(app->scene_manager, WifiMarauderSceneConsoleOutput, 0);
+    view_dispatcher_switch_to_view(app->view_dispatcher, WifiMarauderAppViewConsoleOutput);
+
+    // Register callback to receive data
+    wifi_marauder_uart_set_handle_rx_data_cb(
+        app->uart, wifi_marauder_console_output_handle_rx_data_cb); // setup callback for rx thread
+
+    // Send command with newline '\n'
+    if(app->is_command && app->selected_tx_string) {
+        wifi_marauder_uart_tx(
+            (uint8_t*)(app->selected_tx_string), strlen(app->selected_tx_string));
+        wifi_marauder_uart_tx((uint8_t*)("\n"), 1);
+    }
+}
+
+bool wifi_marauder_scene_console_output_on_event(void* context, SceneManagerEvent event) {
+    WifiMarauderApp* app = context;
+
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store));
+        consumed = true;
+    } else if(event.type == SceneManagerEventTypeTick) {
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void wifi_marauder_scene_console_output_on_exit(void* context) {
+    WifiMarauderApp* app = context;
+
+    // Unregister rx callback
+    wifi_marauder_uart_set_handle_rx_data_cb(app->uart, NULL);
+
+    // Automatically stop the scan when exiting view
+    if(app->is_command) {
+        wifi_marauder_uart_tx((uint8_t*)("stopscan\n"), strlen("stopscan\n"));
+    }
+}

applications/external/wifi_marauder_companion/scenes/wifi_marauder_scene_start.c

@@ -0,0 +1,225 @@
+//** Includes sniffbt and sniffskim for compatible ESP32-WROOM hardware.
+//wifi_marauder_app_i.h also changed **//
+#include "../wifi_marauder_app_i.h"
+
+// For each command, define whether additional arguments are needed
+// (enabling text input to fill them out), and whether the console
+// text box should focus at the start of the output or the end
+typedef enum { NO_ARGS = 0, INPUT_ARGS, TOGGLE_ARGS } InputArgs;
+
+typedef enum { FOCUS_CONSOLE_END = 0, FOCUS_CONSOLE_START, FOCUS_CONSOLE_TOGGLE } FocusConsole;
+
+#define SHOW_STOPSCAN_TIP (true)
+#define NO_TIP (false)
+
+#define MAX_OPTIONS (9)
+typedef struct {
+    const char* item_string;
+    const char* options_menu[MAX_OPTIONS];
+    int num_options_menu;
+    const char* actual_commands[MAX_OPTIONS];
+    InputArgs needs_keyboard;
+    FocusConsole focus_console;
+    bool show_stopscan_tip;
+} WifiMarauderItem;
+
+// NUM_MENU_ITEMS defined in wifi_marauder_app_i.h - if you add an entry here, increment it!
+const WifiMarauderItem items[NUM_MENU_ITEMS] = {
+    {"View Log from", {"start", "end"}, 2, {"", ""}, NO_ARGS, FOCUS_CONSOLE_TOGGLE, NO_TIP},
+    {"Scan",
+     {"ap", "station"},
+     2,
+     {"scanap", "scansta"},
+     NO_ARGS,
+     FOCUS_CONSOLE_END,
+     SHOW_STOPSCAN_TIP},
+    {"SSID",
+     {"add rand", "add name", "remove"},
+     3,
+     {"ssid -a -g", "ssid -a -n", "ssid -r"},
+     INPUT_ARGS,
+     FOCUS_CONSOLE_START,
+     NO_TIP},
+    {"List",
+     {"ap", "ssid", "station"},
+     3,
+     {"list -a", "list -s", "list -c"},
+     NO_ARGS,
+     FOCUS_CONSOLE_START,
+     NO_TIP},
+    {"Select",
+     {"ap", "ssid", "station"},
+     3,
+     {"select -a", "select -s", "select -c"},
+     INPUT_ARGS,
+     FOCUS_CONSOLE_END,
+     NO_TIP},
+    {"Clear List",
+     {"ap", "ssid", "station"},
+     3,
+     {"clearlist -a", "clearlist -s", "clearlist -c"},
+     NO_ARGS,
+     FOCUS_CONSOLE_END,
+     NO_TIP},
+    {"Attack",
+     {"deauth", "probe", "rickroll"},
+     3,
+     {"attack -t deauth", "attack -t probe", "attack -t rickroll"},
+     NO_ARGS,
+     FOCUS_CONSOLE_END,
+     SHOW_STOPSCAN_TIP},
+    {"Targeted Deauth",
+     {"station", "manual"},
+     2,
+     {"attack -t deauth -c", "attack -t deauth -s"},
+     TOGGLE_ARGS,
+     FOCUS_CONSOLE_END,
+     SHOW_STOPSCAN_TIP},
+    {"Beacon Spam",
+     {"ap list", "ssid list", "random"},
+     3,
+     {"attack -t beacon -a", "attack -t beacon -l", "attack -t beacon -r"},
+     NO_ARGS,
+     FOCUS_CONSOLE_END,
+     SHOW_STOPSCAN_TIP},
+    {"Sniff",
+     {"beacon", "deauth", "esp", "pmkid", "probe", "pwn", "raw", "bt", "skim"},
+     9,
+     {"sniffbeacon",
+      "sniffdeauth",
+      "sniffesp",
+      "sniffpmkid",
+      "sniffprobe",
+      "sniffpwn",
+      "sniffraw",
+      "sniffbt",
+      "sniffskim"},
+     NO_ARGS,
+     FOCUS_CONSOLE_END,
+     SHOW_STOPSCAN_TIP},
+    {"Sniff PMKID on channel",
+     {""},
+     1,
+     {"sniffpmkid -c"},
+     INPUT_ARGS,
+     FOCUS_CONSOLE_END,
+     SHOW_STOPSCAN_TIP},
+    {"Channel",
+     {"get", "set"},
+     2,
+     {"channel", "channel -s"},
+     TOGGLE_ARGS,
+     FOCUS_CONSOLE_END,
+     NO_TIP},
+    {"Settings",
+     {"display", "restore", "ForcePMKID", "ForceProbe", "SavePCAP", "EnableLED", "other"},
+     7,
+     {"settings",
+      "settings -r",
+      "settings -s ForcePMKID enable",
+      "settings -s ForceProbe enable",
+      "settings -s SavePCAP enable",
+      "settings -s EnableLED enable",
+      "settings -s"},
+     TOGGLE_ARGS,
+     FOCUS_CONSOLE_START,
+     NO_TIP},
+    {"Update", {"ota", "sd"}, 2, {"update -w", "update -s"}, NO_ARGS, FOCUS_CONSOLE_END, NO_TIP},
+    {"Reboot", {""}, 1, {"reboot"}, NO_ARGS, FOCUS_CONSOLE_END, NO_TIP},
+    {"Help", {""}, 1, {"help"}, NO_ARGS, FOCUS_CONSOLE_START, SHOW_STOPSCAN_TIP},
+};
+
+static void wifi_marauder_scene_start_var_list_enter_callback(void* context, uint32_t index) {
+    furi_assert(context);
+    WifiMarauderApp* app = context;
+
+    furi_assert(index < NUM_MENU_ITEMS);
+    const WifiMarauderItem* item = &items[index];
+
+    const int selected_option_index = app->selected_option_index[index];
+    furi_assert(selected_option_index < item->num_options_menu);
+    app->selected_tx_string = item->actual_commands[selected_option_index];
+    app->is_command = (1 <= index);
+    app->is_custom_tx_string = false;
+    app->selected_menu_index = index;
+    app->focus_console_start = (item->focus_console == FOCUS_CONSOLE_TOGGLE) ?
+                                   (selected_option_index == 0) :
+                                   item->focus_console;
+    app->show_stopscan_tip = item->show_stopscan_tip;
+
+    bool needs_keyboard = (item->needs_keyboard == TOGGLE_ARGS) ? (selected_option_index != 0) :
+                                                                  item->needs_keyboard;
+    if(needs_keyboard) {
+        view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventStartKeyboard);
+    } else {
+        view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventStartConsole);
+    }
+}
+
+static void wifi_marauder_scene_start_var_list_change_callback(VariableItem* item) {
+    furi_assert(item);
+
+    WifiMarauderApp* app = variable_item_get_context(item);
+    furi_assert(app);
+
+    const WifiMarauderItem* menu_item = &items[app->selected_menu_index];
+    uint8_t item_index = variable_item_get_current_value_index(item);
+    furi_assert(item_index < menu_item->num_options_menu);
+    variable_item_set_current_value_text(item, menu_item->options_menu[item_index]);
+    app->selected_option_index[app->selected_menu_index] = item_index;
+}
+
+void wifi_marauder_scene_start_on_enter(void* context) {
+    WifiMarauderApp* app = context;
+    VariableItemList* var_item_list = app->var_item_list;
+
+    variable_item_list_set_enter_callback(
+        var_item_list, wifi_marauder_scene_start_var_list_enter_callback, app);
+
+    VariableItem* item;
+    for(int i = 0; i < NUM_MENU_ITEMS; ++i) {
+        item = variable_item_list_add(
+            var_item_list,
+            items[i].item_string,
+            items[i].num_options_menu,
+            wifi_marauder_scene_start_var_list_change_callback,
+            app);
+        variable_item_set_current_value_index(item, app->selected_option_index[i]);
+        variable_item_set_current_value_text(
+            item, items[i].options_menu[app->selected_option_index[i]]);
+    }
+
+    variable_item_list_set_selected_item(
+        var_item_list, scene_manager_get_scene_state(app->scene_manager, WifiMarauderSceneStart));
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, WifiMarauderAppViewVarItemList);
+}
+
+bool wifi_marauder_scene_start_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    WifiMarauderApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == WifiMarauderEventStartKeyboard) {
+            scene_manager_set_scene_state(
+                app->scene_manager, WifiMarauderSceneStart, app->selected_menu_index);
+            scene_manager_next_scene(app->scene_manager, WifiMarauderAppViewTextInput);
+        } else if(event.event == WifiMarauderEventStartConsole) {
+            scene_manager_set_scene_state(
+                app->scene_manager, WifiMarauderSceneStart, app->selected_menu_index);
+            scene_manager_next_scene(app->scene_manager, WifiMarauderAppViewConsoleOutput);
+        }
+        consumed = true;
+    } else if(event.type == SceneManagerEventTypeTick) {
+        app->selected_menu_index = variable_item_list_get_selected_item_index(app->var_item_list);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void wifi_marauder_scene_start_on_exit(void* context) {
+    WifiMarauderApp* app = context;
+    variable_item_list_reset(app->var_item_list);
+}

applications/external/wifi_marauder_companion/scenes/wifi_marauder_scene_text_input.c

@@ -0,0 +1,154 @@
+#include "../wifi_marauder_app_i.h"
+
+void wifi_marauder_scene_text_input_callback(void* context) {
+    WifiMarauderApp* app = context;
+
+    switch(app->special_case_input_step) {
+    case 0: // most commands
+        view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventStartConsole);
+        break;
+    case 1: // special case for deauth: save source MAC
+        view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventSaveSourceMac);
+        break;
+    case 2: // special case for deauth: save destination MAC
+        view_dispatcher_send_custom_event(
+            app->view_dispatcher, WifiMarauderEventSaveDestinationMac);
+        break;
+    default:
+        break;
+    }
+}
+
+void wifi_marauder_scene_text_input_on_enter(void* context) {
+    WifiMarauderApp* app = context;
+
+    if(0 ==
+       strncmp("attack -t deauth -s", app->selected_tx_string, strlen("attack -t deauth -s"))) {
+        // Special case for manual deauth input
+        app->special_case_input_step = 1;
+        bzero(app->text_input_store, WIFI_MARAUDER_TEXT_INPUT_STORE_SIZE);
+    } else if(false == app->is_custom_tx_string) {
+        // Most commands
+        app->special_case_input_step = 0;
+
+        // Fill text input with selected string so that user can add to it
+        size_t length = strlen(app->selected_tx_string);
+        furi_assert(length < WIFI_MARAUDER_TEXT_INPUT_STORE_SIZE);
+        bzero(app->text_input_store, WIFI_MARAUDER_TEXT_INPUT_STORE_SIZE);
+        strncpy(app->text_input_store, app->selected_tx_string, length);
+
+        // Add space - because flipper keyboard currently doesn't have a space
+        app->text_input_store[length] = ' ';
+        app->text_input_store[length + 1] = '\0';
+        app->is_custom_tx_string = true;
+    }
+
+    // Setup view
+    TextInput* text_input = app->text_input;
+    // Add help message to header
+    if(app->special_case_input_step == 1) {
+        text_input_set_header_text(text_input, "Enter source MAC");
+    } else if(0 == strncmp("ssid -a -g", app->selected_tx_string, strlen("ssid -a -g"))) {
+        text_input_set_header_text(text_input, "Enter # SSIDs to generate");
+    } else if(0 == strncmp("ssid -a -n", app->selected_tx_string, strlen("ssid -a -n"))) {
+        text_input_set_header_text(text_input, "Enter SSID name to add");
+    } else if(0 == strncmp("ssid -r", app->selected_tx_string, strlen("ssid -r"))) {
+        text_input_set_header_text(text_input, "Remove target from SSID list");
+    } else if(0 == strncmp("select -a", app->selected_tx_string, strlen("select -a"))) {
+        text_input_set_header_text(text_input, "Add target from AP list");
+    } else if(0 == strncmp("select -s", app->selected_tx_string, strlen("select -s"))) {
+        text_input_set_header_text(text_input, "Add target from SSID list");
+    } else {
+        text_input_set_header_text(text_input, "Add command arguments");
+    }
+    text_input_set_result_callback(
+        text_input,
+        wifi_marauder_scene_text_input_callback,
+        app,
+        app->text_input_store,
+        WIFI_MARAUDER_TEXT_INPUT_STORE_SIZE,
+        false);
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, WifiMarauderAppViewTextInput);
+}
+
+bool wifi_marauder_scene_text_input_on_event(void* context, SceneManagerEvent event) {
+    WifiMarauderApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == WifiMarauderEventStartConsole) {
+            // Point to custom string to send
+            app->selected_tx_string = app->text_input_store;
+            scene_manager_next_scene(app->scene_manager, WifiMarauderAppViewConsoleOutput);
+            consumed = true;
+        } else if(event.event == WifiMarauderEventSaveSourceMac) {
+            if(12 != strlen(app->text_input_store)) {
+                text_input_set_header_text(app->text_input, "MAC must be 12 hex chars!");
+            } else {
+                snprintf(
+                    app->special_case_input_src_addr,
+                    sizeof(app->special_case_input_src_addr),
+                    "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
+                    app->text_input_store[0],
+                    app->text_input_store[1],
+                    app->text_input_store[2],
+                    app->text_input_store[3],
+                    app->text_input_store[4],
+                    app->text_input_store[5],
+                    app->text_input_store[6],
+                    app->text_input_store[7],
+                    app->text_input_store[8],
+                    app->text_input_store[9],
+                    app->text_input_store[10],
+                    app->text_input_store[11]);
+
+                // Advance scene to input destination MAC, clear text input
+                app->special_case_input_step = 2;
+                bzero(app->text_input_store, WIFI_MARAUDER_TEXT_INPUT_STORE_SIZE);
+                text_input_set_header_text(app->text_input, "Enter destination MAC");
+            }
+            consumed = true;
+        } else if(event.event == WifiMarauderEventSaveDestinationMac) {
+            if(12 != strlen(app->text_input_store)) {
+                text_input_set_header_text(app->text_input, "MAC must be 12 hex chars!");
+            } else {
+                snprintf(
+                    app->special_case_input_dst_addr,
+                    sizeof(app->special_case_input_dst_addr),
+                    "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
+                    app->text_input_store[0],
+                    app->text_input_store[1],
+                    app->text_input_store[2],
+                    app->text_input_store[3],
+                    app->text_input_store[4],
+                    app->text_input_store[5],
+                    app->text_input_store[6],
+                    app->text_input_store[7],
+                    app->text_input_store[8],
+                    app->text_input_store[9],
+                    app->text_input_store[10],
+                    app->text_input_store[11]);
+
+                // Construct command with source and destination MACs
+                snprintf(
+                    app->text_input_store,
+                    WIFI_MARAUDER_TEXT_INPUT_STORE_SIZE,
+                    "attack -t deauth -s %18s -d %18s",
+                    app->special_case_input_src_addr,
+                    app->special_case_input_dst_addr);
+                app->selected_tx_string = app->text_input_store;
+                scene_manager_next_scene(app->scene_manager, WifiMarauderAppViewConsoleOutput);
+            }
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void wifi_marauder_scene_text_input_on_exit(void* context) {
+    WifiMarauderApp* app = context;
+
+    text_input_reset(app->text_input);
+}