Adapt to new Unified serial PCAPs system

evil_portal/evil_portal_uart.c

@@ -6,9 +6,9 @@ struct Evil_PortalUart {
     Evil_PortalApp* app;
     FuriThread* rx_thread;
     FuriStreamBuffer* rx_stream;
-    uint8_t pcap_test_buf[12];
-    uint8_t pcap_test_idx;
     bool pcap;
+    uint8_t mark_test_buf[11];
+    uint8_t mark_test_idx;
     uint8_t rx_buf[RX_BUF_SIZE + 1];
     void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context);
 };
@@ -31,46 +31,46 @@ void evil_portal_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
     Evil_PortalUart* uart = (Evil_PortalUart*)context;
 
     if(ev == UartIrqEventRXNE) {
-        if(uart->pcap_test_idx != 0) {
-            // We are trying to match a pcap delimiter
-            const char* pcap_begin = "%PCAP_BEGIN%";
-            const char* pcap_close = "%PCAP_CLOSE%";
-            if(data == pcap_begin[uart->pcap_test_idx] ||
-               data == pcap_close[uart->pcap_test_idx]) {
-                // Received char matches next char in a pcap delimiter, append to buffer
-                uart->pcap_test_buf[uart->pcap_test_idx++] = data;
-                if(uart->pcap_test_idx == sizeof(uart->pcap_test_buf)) {
-                    // Buffer reached max length, parse what delimiter this is and discard buffer
+        const char* mark_begin = "[BUF/BEGIN]";
+        const char* mark_close = "[BUF/CLOSE]";
+        if(uart->mark_test_idx != 0) {
+            // We are trying to match a marker
+            if(data == mark_begin[uart->mark_test_idx] ||
+               data == mark_close[uart->mark_test_idx]) {
+                // Received char matches next char in a marker, append to test buffer
+                uart->mark_test_buf[uart->mark_test_idx++] = data;
+                if(uart->mark_test_idx == sizeof(uart->mark_test_buf)) {
+                    // Test buffer reached max length, parse what marker this is and discard buffer
                     if(!memcmp(
-                           uart->pcap_test_buf, (void*)pcap_begin, sizeof(uart->pcap_test_buf))) {
+                           uart->mark_test_buf, (void*)mark_begin, sizeof(uart->mark_test_buf))) {
                         uart->pcap = true;
                     } else if(!memcmp(
-                                  uart->pcap_test_buf,
-                                  (void*)pcap_close,
-                                  sizeof(uart->pcap_test_buf))) {
+                                  uart->mark_test_buf,
+                                  (void*)mark_close,
+                                  sizeof(uart->mark_test_buf))) {
                         uart->pcap = false;
                     }
-                    uart->pcap_test_idx = 0;
+                    uart->mark_test_idx = 0;
                 }
                 // Don't pass to stream
                 return;
             } else {
-                // Received char doesn't match any expected next char, send old buffer
+                // Received char doesn't match any expected next char, send current test buffer
                 if(!uart->pcap) {
                     furi_stream_buffer_send(
-                        uart->rx_stream, uart->pcap_test_buf, uart->pcap_test_idx, 0);
+                        uart->rx_stream, uart->mark_test_buf, uart->mark_test_idx, 0);
                     furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone);
                 }
-                // Reset buffer and try parsing this char from scratch
-                uart->pcap_test_idx = 0;
+                // Reset test buffer and try parsing this char from scratch
+                uart->mark_test_idx = 0;
             }
         }
         // If we reach here the buffer is empty
-        if(data == '%') {
-            // Received delimiter start, append to buffer
-            uart->pcap_test_buf[uart->pcap_test_idx++] = data;
+        if(data == mark_begin[0]) {
+            // Received marker start, append to test buffer
+            uart->mark_test_buf[uart->mark_test_idx++] = data;
         } else {
-            // Not a delimiter start and we aren't matching a delimiter, this is just data
+            // Not a marker start and we aren't matching a marker, this is just data
             if(!uart->pcap) {
                 // We want to ignore pcap data from marauder
                 furi_stream_buffer_send(uart->rx_stream, &data, 1, 0);

wifi_marauder_companion/scenes/wifi_marauder_scene_console_output.c

@@ -51,7 +51,7 @@ void wifi_marauder_console_output_handle_rx_data_cb(uint8_t* buf, size_t len, vo
     view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventRefreshConsoleOutput);
 }
 
-void wifi_marauder_console_output_handle_rx_pcap_cb(uint8_t* buf, size_t len, void* context) {
+void wifi_marauder_console_output_handle_rx_packets_cb(uint8_t* buf, size_t len, void* context) {
     furi_assert(context);
     WifiMarauderApp* app = context;
 
@@ -106,7 +106,7 @@ void wifi_marauder_scene_console_output_on_enter(void* context) {
         wifi_marauder_console_output_handle_rx_data_cb); // setup callback for general log rx thread
     wifi_marauder_uart_set_handle_rx_pcap_cb(
         app->uart,
-        wifi_marauder_console_output_handle_rx_pcap_cb); // setup callback for general log rx thread
+        wifi_marauder_console_output_handle_rx_packets_cb); // setup callback for packets rx thread
 
     // Get ready to send command
     if((app->is_command && app->selected_tx_string) || app->script) {
@@ -158,7 +158,11 @@ void wifi_marauder_scene_console_output_on_enter(void* context) {
         if(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);
+            if(app->is_writing_pcap) {
+                wifi_marauder_uart_tx((uint8_t*)(" -serial\n"), strlen(" -serial\n"));
+            } else {
+                wifi_marauder_uart_tx((uint8_t*)("\n"), 1);
+            }
             if(send_html && the_html) {
                 wifi_marauder_uart_tx(the_html, html_size);
                 wifi_marauder_uart_tx((uint8_t*)("\n"), 1);

wifi_marauder_companion/script/wifi_marauder_script_executor.c

@@ -103,7 +103,7 @@ void _wifi_marauder_script_execute_probe(
 void _wifi_marauder_script_execute_sniff_raw(
     WifiMarauderScriptStageSniffRaw* stage,
     WifiMarauderScriptWorker* worker) {
-    const char sniff_command[] = "sniffraw\n";
+    const char sniff_command[] = "sniffraw -serial\n";
     wifi_marauder_uart_tx((uint8_t*)sniff_command, strlen(sniff_command));
     _wifi_marauder_script_delay(worker, stage->timeout);
     _send_stop();
@@ -112,7 +112,7 @@ void _wifi_marauder_script_execute_sniff_raw(
 void _wifi_marauder_script_execute_sniff_beacon(
     WifiMarauderScriptStageSniffBeacon* stage,
     WifiMarauderScriptWorker* worker) {
-    const char sniff_command[] = "sniffbeacon\n";
+    const char sniff_command[] = "sniffbeacon -serial\n";
     wifi_marauder_uart_tx((uint8_t*)sniff_command, strlen(sniff_command));
     _wifi_marauder_script_delay(worker, stage->timeout);
     _send_stop();
@@ -121,7 +121,7 @@ void _wifi_marauder_script_execute_sniff_beacon(
 void _wifi_marauder_script_execute_sniff_deauth(
     WifiMarauderScriptStageSniffDeauth* stage,
     WifiMarauderScriptWorker* worker) {
-    const char sniff_command[] = "sniffdeauth\n";
+    const char sniff_command[] = "sniffdeauth -serial\n";
     wifi_marauder_uart_tx((uint8_t*)sniff_command, strlen(sniff_command));
     _wifi_marauder_script_delay(worker, stage->timeout);
     _send_stop();
@@ -130,7 +130,7 @@ void _wifi_marauder_script_execute_sniff_deauth(
 void _wifi_marauder_script_execute_sniff_esp(
     WifiMarauderScriptStageSniffEsp* stage,
     WifiMarauderScriptWorker* worker) {
-    const char sniff_command[] = "sniffesp\n";
+    const char sniff_command[] = "sniffesp -serial\n";
     wifi_marauder_uart_tx((uint8_t*)sniff_command, strlen(sniff_command));
     _wifi_marauder_script_delay(worker, stage->timeout);
     _send_stop();
@@ -150,7 +150,7 @@ void _wifi_marauder_script_execute_sniff_pmkid(
                 len += snprintf(attack_command + len, sizeof(attack_command) - len, " -d");
             }
 
-            len += snprintf(attack_command + len, sizeof(attack_command) - len, "\n");
+            len += snprintf(attack_command + len, sizeof(attack_command) - len, " -serial\n");
             wifi_marauder_uart_tx((uint8_t*)attack_command, len);
             _wifi_marauder_script_delay(worker, stage->timeout);
             _send_stop();
@@ -167,7 +167,7 @@ void _wifi_marauder_script_execute_sniff_pmkid(
         if(stage->force_deauth) {
             len += snprintf(attack_command + len, sizeof(attack_command) - len, " -d");
         }
-        len += snprintf(attack_command + len, sizeof(attack_command) - len, "\n");
+        len += snprintf(attack_command + len, sizeof(attack_command) - len, " -serial\n");
         wifi_marauder_uart_tx((uint8_t*)attack_command, len);
         _wifi_marauder_script_delay(worker, stage->timeout);
         _send_stop();
@@ -177,7 +177,7 @@ void _wifi_marauder_script_execute_sniff_pmkid(
 void _wifi_marauder_script_execute_sniff_pwn(
     WifiMarauderScriptStageSniffPwn* stage,
     WifiMarauderScriptWorker* worker) {
-    const char sniff_command[] = "sniffpwn\n";
+    const char sniff_command[] = "sniffpwn -serial\n";
     wifi_marauder_uart_tx((uint8_t*)sniff_command, strlen(sniff_command));
     _wifi_marauder_script_delay(worker, stage->timeout);
     _send_stop();

wifi_marauder_companion/wifi_marauder_uart.c

@@ -13,9 +13,9 @@ struct WifiMarauderUart {
     FuriThread* rx_thread;
     FuriStreamBuffer* rx_stream;
     FuriStreamBuffer* pcap_stream;
-    uint8_t pcap_test_buf[12];
-    uint8_t pcap_test_idx;
     bool pcap;
+    uint8_t mark_test_buf[11];
+    uint8_t mark_test_idx;
     uint8_t rx_buf[RX_BUF_SIZE + 1];
     void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context);
     void (*handle_rx_pcap_cb)(uint8_t* buf, size_t len, void* context);
@@ -47,50 +47,50 @@ void wifi_marauder_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context)
     WifiMarauderUart* uart = (WifiMarauderUart*)context;
 
     if(ev == UartIrqEventRXNE) {
-        if(uart->pcap_test_idx != 0) {
-            // We are trying to match a pcap delimiter
-            const char* pcap_begin = "%PCAP_BEGIN%";
-            const char* pcap_close = "%PCAP_CLOSE%";
-            if(data == pcap_begin[uart->pcap_test_idx] ||
-               data == pcap_close[uart->pcap_test_idx]) {
-                // Received char matches next char in a pcap delimiter, append to buffer
-                uart->pcap_test_buf[uart->pcap_test_idx++] = data;
-                if(uart->pcap_test_idx == sizeof(uart->pcap_test_buf)) {
-                    // Buffer reached max length, parse what delimiter this is and discard buffer
+        const char* mark_begin = "[BUF/BEGIN]";
+        const char* mark_close = "[BUF/CLOSE]";
+        if(uart->mark_test_idx != 0) {
+            // We are trying to match a marker
+            if(data == mark_begin[uart->mark_test_idx] ||
+               data == mark_close[uart->mark_test_idx]) {
+                // Received char matches next char in a marker, append to test buffer
+                uart->mark_test_buf[uart->mark_test_idx++] = data;
+                if(uart->mark_test_idx == sizeof(uart->mark_test_buf)) {
+                    // Test buffer reached max length, parse what marker this is and discard buffer
                     if(!memcmp(
-                           uart->pcap_test_buf, (void*)pcap_begin, sizeof(uart->pcap_test_buf))) {
+                           uart->mark_test_buf, (void*)mark_begin, sizeof(uart->mark_test_buf))) {
                         uart->pcap = true;
                     } else if(!memcmp(
-                                  uart->pcap_test_buf,
-                                  (void*)pcap_close,
-                                  sizeof(uart->pcap_test_buf))) {
+                                  uart->mark_test_buf,
+                                  (void*)mark_close,
+                                  sizeof(uart->mark_test_buf))) {
                         uart->pcap = false;
                     }
-                    uart->pcap_test_idx = 0;
+                    uart->mark_test_idx = 0;
                 }
                 // Don't pass to stream
                 return;
             } else {
-                // Received char doesn't match any expected next char, send old buffer
+                // Received char doesn't match any expected next char, send current test buffer
                 if(uart->pcap) {
                     furi_stream_buffer_send(
-                        uart->pcap_stream, uart->pcap_test_buf, uart->pcap_test_idx, 0);
+                        uart->pcap_stream, uart->mark_test_buf, uart->mark_test_idx, 0);
                     furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtPcapDone);
                 } else {
                     furi_stream_buffer_send(
-                        uart->rx_stream, uart->pcap_test_buf, uart->pcap_test_idx, 0);
+                        uart->rx_stream, uart->mark_test_buf, uart->mark_test_idx, 0);
                     furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone);
                 }
-                // Reset buffer and try parsing this char from scratch
-                uart->pcap_test_idx = 0;
+                // Reset test buffer and try parsing this char from scratch
+                uart->mark_test_idx = 0;
             }
         }
         // If we reach here the buffer is empty
-        if(data == '%') {
-            // Received delimiter start, append to buffer
-            uart->pcap_test_buf[uart->pcap_test_idx++] = data;
+        if(data == mark_begin[0]) {
+            // Received marker start, append to test buffer
+            uart->mark_test_buf[uart->mark_test_idx++] = data;
         } else {
-            // Not a delimiter start and we aren't matching a delimiter, this is just data
+            // Not a marker start and we aren't matching a marker, this is just data
             if(uart->pcap) {
                 furi_stream_buffer_send(uart->pcap_stream, &data, 1, 0);
                 furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtPcapDone);