One web dashboard, two ESP32 Marauders, driven at once from a third ESP32.
MarauderNet turns a spare ESP32 into a Wi-Fi access point + web console that controls two boards running ESP32 Marauder firmware simultaneously over UART. You get the full Marauder command set — live consoles, AP/station tables, target selection, logging — for both boards in one browser tab, with no PC attached at runtime.
This is a controller, not the firmware. ESP32 Marauder is a separate project by justcallmekoko (see Credits). MarauderNet does not include or modify it — you flash the official Marauder firmware onto your two target boards yourself.
- Drives two Marauders at once — target Board A, Board B, or Both from one UI.
- Two live consoles side by side, each streaming its board's serial output.
- Per-board AP & station tables that fill during scans, with checkbox target selection.
- The full Marauder CLI as searchable buttons (scan, sniff, attack, BLE, GPS, SD, system), with red confirms on the disruptive commands.
- Raw command box and CSV / log download per board.
- Global STOP for both boards (
Ctrl+.). - Thin, safe bridge — the controller only relays bytes and injects newline-terminated commands; all parsing and UI logic run in the browser, so the ESP32 stays small and robust. Control characters are stripped from every command to block serial-command injection.
Browser (phone / laptop)
│ Wi-Fi (WPA2)
▼
┌───────────────────────────────┐
│ Controller ESP32 │ controller/controller.ino
│ SoftAP + web server + 2×UART │ dashboard served from PROGMEM
└──────┬─────────────────┬───────┘
│ UART1 115200 │ UART2 115200
▼ ▼
Marauder A Marauder B ← official Marauder firmware, unchanged
The browser talks to the controller over a WebSocket. The controller relays each command to Board A and/or Board B on a dedicated 115200-baud UART and streams every line back. Marauder's serial CLI is the only control channel it exposes, which is why the link is UART (see Wireless option to make that hop wireless).
- 3 × ESP32 dev boards — classic ESP32-WROOM-32 (e.g. ELEGOO / DevKitC). Two are the Marauder targets, one is the controller. (Non-PSRAM WROOM; on WROVER/PSRAM move the UART pins — see below.)
- 6 jumper wires minimum (female-to-female if your boards have male headers): 4 signal + 2 ground.
- Power — a USB cable per board, or one 5 V ≥ 2 A supply to power all three from the
VIN/5Vpins. - Optional: a breadboard (only useful as a power/ground rail — the signals are point-to-point).
- Optional: a FAT32 microSD per Marauder, for PMKID/PCAP capture, Evil Portal, and wardrive CSVs.
- Optional: an ESP-01 / ESP8266 / ESP32-C3 per board for the wireless variant.
- The official ESP32 Marauder firmware for your board — the four
.binfiles (seefirmware/README.md). Not included here. - Arduino IDE (or
arduino-cli) with the ESP32 Arduino core 3.x. - Two libraries (publisher ESP32Async): Async TCP and ESP Async WebServer.
- Python 3 with esptool and pyserial (
pip install esptool pyserial) forflash_targets.py.
MarauderNet/
├─ flash_targets.py Checksum-verified flasher for the two Marauder target boards
├─ controller/
│ ├─ controller.ino Controller firmware: SoftAP + web server + dual-UART bridge
│ └─ web_index.h The dual-device dashboard (HTML/JS), embedded in the sketch
├─ firmware/ Drop the official Marauder .bin files here (git-ignored)
└─ docs/ Wiring diagrams and the interface preview
Download the official build for your board from
justcallmekoko/ESP32Marauder releases
and place the four .bin files in firmware/ — details in firmware/README.md.
python flash_targets.py --list # find the COM port
python flash_targets.py --port COM5 # flash board A
python flash_targets.py --port COM6 # flash board BIt re-computes each image's SHA-256 and refuses to flash on a mismatch. Add --erase for a
blank board, --both to do two in a row, or --no-verify for a build other than the baked-in one.
Install the Async TCP and ESP Async WebServer libraries (ESP32Async), then in controller.ino
set your AP_SSID / AP_PASS (and optionally the STA settings). Upload to the third board.
arduino-cli lib install "Async TCP" "ESP Async WebServer"
arduino-cli compile --fqbn esp32:esp32:esp32 controller
arduino-cli upload --fqbn esp32:esp32:esp32 -p COM7 controller
Six wires, by silk label (pins map to any classic ESP32; labels shown for ELEGOO/DevKitC):
| Controller | → | Target |
|---|---|---|
TX2 (GPIO17) |
→ | Board A RX0 (GPIO3) |
RX2 (GPIO16) |
← | Board A TX0 (GPIO1) |
D19 (GPIO19) |
→ | Board B RX0 (GPIO3) |
D18 (GPIO18) |
← | Board B TX0 (GPIO1) |
GND |
— | Board A GND |
GND |
— | Board B GND |
TX always goes to the other side's RX. More views in docs/:
schematic · board-level ·
breadboard · best for a small breadboard.
Cautions
- Each Marauder's RX0/TX0 (GPIO3/1) are its USB-serial pins — keep that board's USB data unplugged while wired to the controller (USB for power only, or a shared 5 V supply).
- Common ground is mandatory, even when boards are powered separately.
- WROVER / PSRAM boards: GPIO16/17 are unavailable — move the pins in
controller.ino(e.g. 25/26/32/33) and rewire.
Power all three. Simplest is one USB per board; or feed one 5 V ≥ 2 A supply to every board's
VIN/5V pin (never the 3.3 V pin) with grounds common.
- Join the Wi-Fi the controller broadcasts (its serial log prints the name/IP).
- Open
http://192.168.4.1. - Pick a target (A / B / Both), Scan APs → tables fill → tick rows → Select checked APs → run an action. STOP BOTH halts everything.
The Marauder boards can't be controlled over Wi-Fi directly — their only control channel is the
serial CLI, and they need the radio for their own scans/attacks. To cut the UART wire anyway, give
each Marauder its own tiny serial-to-Wi-Fi bridge: an ESP-01 / ESP8266 (or ESP32-C3) wired to
that board's RX0/TX0/GND, running a WebSocket-to-UART bridge and joined to your control network.
The browser then reaches each node wirelessly.
- Trade-off: one extra bridge board per Marauder (so 2 Marauders + 2 bridges), but the boards can be physically separated and there are no long UART runs.
- The dashboard barely changes — it opens one WebSocket per node instead of one to a central controller.
- With three boards, the wired controller in this repo is the right fit; the ESP-01 path is for when you want distance or more nodes.
- A board's dot stays grey / its console is silent → that board's TX/RX are swapped (swap its two signal wires). If both are silent, the grounds aren't common.
- Console shows scan lines but the AP table stays 0 → the table is filled by
list -a; turn Auto-list on, or click List APs for that board. - WS dot blinks / no console on iPhone → older builds gated the WebSocket on the HTTP login, which iOS Safari drops on the upgrade request. This build gates only on WPA2 — reflash the controller if you're on an older copy.
- Deauth "not working" → the ESP32 is 2.4 GHz only (it can't touch 5 GHz clients), and modern routers with 802.11w / PMF ignore deauth by design. Test with a 2.4 GHz client and a continuous ping; if frames send but nothing drops, PMF is on — which means the network is well-hardened.
- ESP32 Marauder by justcallmekoko — the firmware that runs on the target boards and provides every command this dashboard sends. All the real capability is theirs; MarauderNet is only a remote console for it. Please star and support the original project.
- ESP32Async — the
AsyncTCPandESPAsyncWebServerlibraries the controller is built on.
For authorized testing only — networks and devices you own or have written permission to test. Marauder can transmit deauthentication, Evil Portal, beacon/BLE-spam, and karma traffic; using these against others is illegal in most jurisdictions (e.g. US CFAA, FCC rules, and equivalents). The dashboard renders those actions in red and confirms before sending — keep it that way. You are solely responsible for what your boards do.
MIT — see LICENSE. Covers the original controller, flasher, and docs in this repo only. The ESP32 Marauder firmware is licensed separately by its own authors and is not included here.