gitea-mirror/esp8266_deauther
1
0
Fork 0
mirror of https://github.com/SpacehuhnTech/esp8266_deauther.git synced 2025-12-12 15:50:47 -08:00
Code Issues Packages Projects Releases Wiki Activity

Basic RSSI scan

Browse Source
This commit is contained in:
Spacehuhn
2020-11-25 19:42:29 +01:00
parent 9789ca216a
commit 607d9a2d67
5 changed files with 191 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@@ -61,6 +61,7 @@
7. Connect and find port of ESP8266 dev board
`arduino-cli board list`
8. Compile
`cd esp8266_deauther`
`arduino-cli compile esp8266_deauther --fqbn deauther:esp8266:d1_mini`
9. Upload
`arduino-cli upload -p <PORT> --fqbn deauther:esp8266:d1_mini`

55
esp8266_deauther/cli.cpp
View File

@@ -700,20 +700,6 @@ namespace cli {
" -r: keep previous scan results"
);
/*
Command cmd_rssi = cli.addCommand("rssi", [](cmd* c) {
Command cmd(c);
String mac_str = cmd.getArg("mac").getValue();
MACList macs(mac_str, ",");
scan::startRSSI(&rssi_meter_cb, macs);
});
cmd_rssi.addPosArg("mac", "");
cmd_rssi.setDescription(
" RSSI meter\r\n"
" -mac: MAC addresses");
*/
Command cmd_auth = cli.addCommand("auth", [](cmd* c) {
Command cmd(c);
@@ -782,6 +768,43 @@ namespace cli {
" -ct: channel scan time in milliseconds (default=284)\r\n"
" -t: scan timeout (default=none)\r\n"
" -save: save recorded probe requests");
Command cmd_rssi = cli.addCommand("rssi", [](cmd* c) {
Command cmd(c);
rssi_scan_settings_t rssi_settings;
{ // MACs
String bssid_str { cmd.getArg("mac").getValue() };
rssi_settings.macs += MacArr { bssid_str };
}
{ // Channels
String ch_str = cmd.getArg("ch").getValue();
rssi_settings.channels = parse_channels(ch_str);
}
{ // Channel scan time
String time_str = cmd.getArg("ct").getValue();
rssi_settings.ch_time = parse_time(time_str, 1);
}
{ // Update Time
String time_str = cmd.getArg("ut").getValue();
rssi_settings.update_time = parse_time(time_str, 1000);
}
scan::startRSSI(rssi_settings);
});
cmd_rssi.addPosArg("mac", "");
cmd_rssi.addArg("ch/annel", "all");
cmd_rssi.addArg("ct/ime", "284");
cmd_rssi.addArg("ut,u/pdate/time", "1s");
cmd_rssi.setDescription(" Signal Strength scan\r\n"
" -mac: filter by MAC(s)\r\n"
" -ch: 2.4 GHz channel(s) for scan [1-14] (default=all)\r\n"
" -ct: channel scan time in milliseconds (default=284)\r\n"
" -ut: update time (default=1s)");
Command cmd_results = cli.addCommand("results", [](cmd* c) {
Command cmd(c);
@@ -1251,6 +1274,8 @@ namespace cli {
scan::stopST();
} else if (mode == "auth") {
scan::stopAuth();
} else if (mode == "rssi") {
scan::stopRSSI();
} else if (mode == "attack") {
attack::stop();
} else if (mode == "beacon") {
@@ -1267,7 +1292,7 @@ namespace cli {
});
cmd_stop.addPosArg("mode", "all");
cmd_stop.setDescription(" Stop scans or attacks\r\n"
" -mode: all,scan,auth,attack,beacon,deauth,probe,ap (default=all)");
" -mode: all,scan,auth,rssi,attack,beacon,deauth,probe,ap (default=all)");
#ifdef ENABLE_HISTORY
Command cmd_history = cli.addCommand("history", [](cmd* c) {

38
esp8266_deauther/scan.cpp
View File

@@ -95,45 +95,15 @@ namespace scan {
#include "scan_ap.h"
#include "scan_st.h"
#include "scan_auth.h"
// #include "scan_rssi.h"
#include "scan_rssi.h"
// ===== PUBLIC ===== //
/*
void startRSSI(rssi_cb_f rssi_cb, MACList& mac_filter, uint16_t channels, unsigned long ch_time) {
if (!rssi_cb) {
// ERROR
return;
}
data.rssi_cb = rssi_cb;
data.mac_filter.moveFrom(mac_filter);
data.channels = channels;
data.ch_time = ch_time;
uint8_t num_of_channels = 0;
for (uint8_t i = 0; i<14; ++i) {
num_of_channels += ((channels >> i) & 0x01);
}
unsigned long current_time = millis();
data.rssi = true;
data.num_of_channels = num_of_channels;
data.start_time = current_time;
data.ch_update_time = current_time;
start_rssi_scan();
}
*/
void stop() {
stopAP();
stopST();
stopAuth();
// stop_rssi_scan();
stopRSSI();
}
void printAPs(const result_filter_t* filter) {
@@ -156,7 +126,7 @@ namespace scan {
update_ap_scan();
update_st_scan();
update_auth_scan();
// update_rssi_scan();
update_rssi_scan();
}
AccessPointList& getAccessPoints() {
@@ -168,6 +138,6 @@ namespace scan {
}
bool active(){
return ap_scan_active() || st_scan_active() || auth_scan_active()/* || rssi_scan_active()*/;
return ap_scan_active() || st_scan_active() || auth_scan_active() || rssi_scan_active();
}
}

12
esp8266_deauther/scan.h
View File

@@ -35,9 +35,17 @@ typedef struct auth_scan_settings_t {
bool save;
} auth_scan_settings_t;
typedef struct rssi_scan_settings_t {
uint16_t channels;
unsigned long ch_time;
unsigned long update_time;
MacArr macs;
} rssi_scan_settings_t;
const st_scan_settings_t ST_SCAN_DEFAULT { 0x3FFF, 284, 20000, false };
const ap_scan_settings_t AP_SCAN_DEFAULT { 0x3FFF, false, false, ST_SCAN_DEFAULT };
const auth_scan_settings_t AUTH_SCAN_DEFAULT { 0x3FFF, 284, 20000, false, MacArr {}, false };
const rssi_scan_settings_t RSSI_SCAN_DEFAULT { 0x3FFF, 284, 5000, MacArr {} };
namespace scan {
void clearAPresults();
@@ -46,12 +54,12 @@ namespace scan {
void startAP(const ap_scan_settings_t& settings = AP_SCAN_DEFAULT);
void startST(const st_scan_settings_t& settings = ST_SCAN_DEFAULT);
void startAuth(const auth_scan_settings_t& settings = AUTH_SCAN_DEFAULT);
// void startRSSI(rssi_cb_f rssi_cb, MACList& mac_filter, uint16_t channels = 0x3FFF, unsigned long ch_time = 1000);
void startRSSI(const rssi_scan_settings_t& settings = RSSI_SCAN_DEFAULT);
void stopAP();
void stopST();
void stopAuth();
void stopRSSI();
void stop();
void print(const result_filter_t* filter = nullptr);

162
esp8266_deauther/scan_rssi.h
View File

@@ -6,6 +6,33 @@
#pragma once
typedef struct rssi_t {
double min;
double max;
uint32_t pkts;
unsigned long start_time;
} rssi_t;
typedef struct rssi_tmp_t {
double rssi;
uint32_t pkts;
} rssi_tmp_t;
typedef struct rssi_data_t {
bool enabled;
// Settings
rssi_scan_settings_t settings;
// Temp
unsigned long last_update_time;
unsigned long last_ch_update_time;
} rssi_data_t;
rssi_data_t rssi_data;
rssi_tmp_t rssi_buffer;
rssi_t rssi_stats;
void rssi_sniffer(uint8_t* buf, uint16_t len) {
SNIFFER_PREAMBLE();
@@ -16,48 +43,131 @@ void rssi_sniffer(uint8_t* buf, uint16_t len) {
const uint8_t* sender = &payload[10];
const int8_t rssi = ctrl->rssi;
if ((data.mac_filter.size() == 0) || data.mac_filter.contains(sender)) {
data.rssi_cb(rssi);
if ((rssi_data.settings.macs.size() == 0) || rssi_data.settings.macs.contains(sender)) {
if(rssi_buffer.pkts == 0) {
rssi_buffer.pkts = 1;
rssi_buffer.rssi = rssi;
} else {
++rssi_buffer.pkts;
rssi_buffer.rssi += ((double)rssi - rssi_buffer.rssi) / (double)rssi_buffer.pkts;
}
}
}
void start_rssi_scan() {
debugF("Scanning for RSSI on ");
debug(data.num_of_channels);
debugF(" different channels");
debugln();
debuglnF("Type 'stop' to stop the scan");
void startRSSI(const rssi_scan_settings_t& settings) {
{ // Error checks
if ((settings.channels & 0x3FFF) == 0) {
debuglnF("ERROR: No channel specified");
return;
}
uint8_t ch = 1;
sysh::channel(ch);
if ((data.channels >> (ch-1)) & 0x01) {
// print_ch(ch);
} else {
sysh::set_next_ch(data.channels);
if (settings.update_time < 100) {
debuglnF("ERROR: Update time must be at least 100ms long");
return;
}
}
wifi_set_promiscuous_rx_cb(rssi_sniffer);
wifi_promiscuous_enable(true);
scan::stop();
unsigned long current_time = millis();
rssi_data.enabled = true;
rssi_data.settings = settings;
rssi_data.last_update_time = current_time;
rssi_data.last_ch_update_time = current_time;
rssi_stats.min = 0;
rssi_stats.max = -99;
rssi_stats.pkts = 0;
rssi_stats.start_time = current_time;
rssi_buffer.rssi = -99;
rssi_buffer.pkts = 0;
{ // Auto correct
if (sysh::count_ch(rssi_data.settings.channels) <= 1) rssi_data.settings.ch_time = 0;
else if (rssi_data.settings.ch_time == 0) rssi_data.settings.ch_time = 284;
}
{ // Output
debuglnF("[ ===== RSSI Scan ===== ]");
debugF("Channels: ");
debugln(strh::channels(rssi_data.settings.channels));
debugF("Channel time: ");
if (rssi_data.settings.ch_time > 0) debugln(strh::time(rssi_data.settings.ch_time));
else debuglnF("-");
debugF("Refresh time: ");
debugln(strh::time(rssi_data.settings.update_time));
debugF("MAC addresses: ");
debugln(rssi_data.settings.macs.size());
if (!rssi_data.settings.macs.empty()) {
debugln();
debuglnF("MAC");
debuglnF("=================");
rssi_data.settings.macs.begin();
while (rssi_data.settings.macs.available()) {
debugln(strh::mac(rssi_data.settings.macs.iterate()));
}
debuglnF("=================");
}
debugln();
debuglnF("Type 'stop rssi' to stop the scan");
debugln();
debuglnF("RSSI Pkts/s");
debuglnF("==============");
sysh::set_next_ch(rssi_data.settings.channels);
wifi_set_promiscuous_rx_cb(rssi_sniffer);
wifi_promiscuous_enable(true);
}
}
void stop_rssi_scan() {
if (data.rssi) {
void stopRSSI() {
if (rssi_data.enabled) {
wifi_promiscuous_enable(false);
data.rssi = false;
rssi_data.enabled = false;
rssi_data.settings.macs.clear();
debuglnF("==============");
debugln();
debuglnF("> Stopped RSSI scanner");
debugln();
}
}
void update_rssi_scan() { /*
unsigned long current_time = millis();
void update_rssi_scan() {
if (rssi_data.enabled) {
unsigned long current_time = millis();
if ((data.ch_time > 0) && (current_time - data.ch_update_time >= data.ch_time)) {
sysh::set_next_ch(data.channels);
data.ch_update_time = current_time;
}*/
if(current_time - rssi_data.last_update_time >= rssi_data.settings.update_time) {
debug((int)rssi_buffer.rssi);
debug(' ');
debugln((int)rssi_buffer.pkts);
rssi_stats.pkts += rssi_buffer.pkts;
if(rssi_buffer.rssi < rssi_stats.min) rssi_stats.min = rssi_buffer.rssi;
if(rssi_buffer.rssi > rssi_stats.max) rssi_stats.max = rssi_buffer.rssi;
rssi_buffer.pkts = 0;
rssi_data.last_update_time = current_time;
}
if ((rssi_data.settings.ch_time > 0) && (current_time - rssi_data.last_ch_update_time >= rssi_data.settings.ch_time)) {
sysh::set_next_ch(rssi_data.settings.channels);
rssi_data.last_ch_update_time = current_time;
}
}
}
bool rssi_scan_active() {