Skip to content

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

10.1 KB
Raw Blame
#include "ICMPService.h"
#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <vector>
#include <algorithm>
#include <ESP32Ping.h>

#include "lwip/inet.h"
#include "lwip/netdb.h"
#include "ping/ping_sock.h"
extern "C"
{
#include "esp_ping.h"
}

portMUX_TYPE ICMPService::icmpMux = portMUX_INITIALIZER_UNLOCKED;
std::vector<std::string> ICMPService::icmpLog;
bool ICMPService::stopICMPFlag = false;

// Task params
struct ICMPTaskParams
{
    std::string targetIP;
    int count;
    int timeout_ms;
    int interval_ms;
    ICMPService *service;
};

struct DiscoveryTaskParams
{
    std::string deviceIP;
    ICMPService *service;
};

ICMPService::ICMPService() {}

ICMPService::~ICMPService()
{
    cleanupICMPService();
}

void ICMPService::cleanupICMPService()
{
    // Reset last results
    pingReady = false;
    pingRC = ping_rc_t::ping_error;
    pingMedianMs = -1;
    pingTX = 0;
    pingRX = 0;
    report.clear();
}

std::string ICMPService::getPingHelp() const{
    std::string helpMenu = std::string("Usage: ping <host> [-c <count>] [-t <timeout>] [-i <interval>]\r\nOptions:\r\n ") + 
        "\t-c <count>    Number of pings (default: 5)\r\n " +
        "\t-t <timeout>  Timeout in milliseconds (default: 1000)\r\n" +
        "\t-i <interval> Interval between pings in milliseconds (default: 200)";
    return helpMenu;
}

static bool resolve_ipv4_to_ip_addr(const std::string &targetIP, ip_addr_t &out)
{
    // literal first
    ip4_addr_t a4{};
    if (ip4addr_aton(targetIP.c_str(), &a4))
    {
        out.type = IPADDR_TYPE_V4;
        out.u_addr.ip4 = a4;
        return true;
    }
    // DNS fallback
    struct addrinfo hints{};
    hints.ai_family = AF_INET;
    struct addrinfo *res = nullptr;
    if (getaddrinfo(targetIP.c_str(), nullptr, &hints, &res) != 0 || !res)
        return false;
    out.type = IPADDR_TYPE_V4;
    out.u_addr.ip4.addr = ((sockaddr_in *)res->ai_addr)->sin_addr.s_addr;
    freeaddrinfo(res);
    return true;
}

static int median_ms(std::vector<uint32_t> &v)
{
    if (v.empty())
        return -1;
    std::sort(v.begin(), v.end());
    size_t n = v.size();
    if (n & 1)
        return (int)v[n / 2];
    return (int)((v[n / 2 - 1] + v[n / 2] + 1) / 2);
}

void ICMPService::discoveryTask(void* params){
    auto* taskParams = static_cast<DiscoveryTaskParams*>(params);
    std::string deviceIP = taskParams->deviceIP;
    ICMPService* service = taskParams->service;
    ip4_addr_t targetIP;
    uint32_t targetsResponded = 0;

    pushICMPLog("Discovery: Scanning network for devices... Press [ENTER] to stop.\r\n");

    if (!ip4addr_aton(deviceIP.c_str(), &targetIP))
    {
        pushICMPLog("Discovery: failed to parse IP address " + deviceIP);
        delete taskParams;
        vTaskDelete(nullptr);
        return;
    }

    // Octets of an IPv4 addr
    uint8_t o1 = ip4_addr1(&targetIP);
    uint8_t o2 = ip4_addr2(&targetIP);
    uint8_t o3 = ip4_addr3(&targetIP);
    uint8_t deviceIndex = ip4_addr4(&targetIP);

    for (uint8_t targetIndex = 1; targetIndex < 255; targetIndex++)
    {
        if (ICMPService::getICMPServiceStatus() == true)
        {
            pushICMPLog("Discovery: Stopped by user\r\n");
            delete taskParams;
            vTaskDelete(nullptr);
            return;
        }

        if (targetIndex == deviceIndex)
            continue;

        // Rebuild the target IP from octets
        IP4_ADDR(&targetIP, o1, o2, o3, targetIndex);

        // Convert to dotted string
        char targetIPCStr[16];
        ip4addr_ntoa_r(&targetIP, targetIPCStr, sizeof(targetIPCStr));
        std::string targetIPStr(targetIPCStr);

        service->cleanupICMPService();
        auto *params = new ICMPTaskParams{targetIPStr, 2, 150, 100, service};

        #ifndef DEVICE_M5STICK

        xTaskCreatePinnedToCore(pingAPI, "ICMPPing", 4096, params, 1, nullptr, 1);

        while (!service->pingReady)
        {
            vTaskDelay(pdMS_TO_TICKS(10));
        }
        if (service->pingRC == ping_rc_t::ping_ok){
            pushICMPLog("Device found: " + targetIPStr);
            targetsResponded++;
        }

        #else
        // Using ESP32Ping library to avoid IRAM overflow
        // Can't set timeout response for ping with the Ping lib
        // This is quite unusable since it takes 5sec per ping
        // TODO: find a better way
        const unsigned long t0 = millis();
        const bool ok = Ping.ping(targetIPStr.c_str(), 1);
        const unsigned long t1 = millis();
        if (ok) {
            pushICMPLog("Device found: " + targetIPStr);
            targetsResponded++;
        } else {
            pushICMPLog("Device not found: " + targetIPStr);
        }

        #endif
    }

    pushICMPLog(std::to_string(targetsResponded) + " devices up, pinged " + 
        std::to_string(254 - targetsResponded) + " devices down");

    service->discoveryReady = true;

    delete taskParams;
    vTaskDelete(nullptr);
}

void ICMPService::startDiscoveryTask(const std::string deviceIP)
{
    report.clear();
    discoveryReady = false;
    stopICMPFlag = false;

    // Start job
    auto* p = new DiscoveryTaskParams{deviceIP, this};
    xTaskCreatePinnedToCore(discoveryTask, "ICMPDiscover", 8192, p, 1, nullptr, 0);
}

void ICMPService::startPingTask(const std::string &targetIP, int count, int timeout_ms, int interval_ms)
{
    // Cleanup first
    this->cleanupICMPService();

    auto *params = new ICMPTaskParams{targetIP,
                                      count > 0 ? count : 5,
                                      timeout_ms > 0 ? timeout_ms : 1000,
                                      interval_ms > 0 ? interval_ms : 200,
                                      this};
    xTaskCreatePinnedToCore(pingAPI, "ICMPPing", 4096, params, 1, nullptr, 1);

    while(!this->pingReady)
        vTaskDelay(pdMS_TO_TICKS(10));

    // Prepare the report
    this->report.clear();
    if (this->pingRC == ping_rc_t::ping_ok || this->pingRC == ping_rc_t::ping_timeout) {
        this->report = "--- " + targetIP + " ping statistics ---\r\n";
        this->report += std::to_string(this->pingTX) + " packets transmitted, ";
        this->report += std::to_string(this->pingRX) + " received, ";
        this->report += std::to_string(100 - this->pingRX * 100 / this->pingTX) + "\% packet loss,";
        this->report += " time " + std::to_string(this->pingMedianMs) + " ms\r\n";
    } else if (this->pingRC == ping_rc_t::ping_resolve_fail) {
        this->report = "Failed to resolve \"" + targetIP + "\"\r\n";
    } else if (this->pingRC == ping_rc_t::ping_session_fail) {
        this->report = "Failed to create session\r\n";
    } else {
        report = "Unknown error\r\n";
    }
        
}

void ICMPService::pingAPI(void *pvParams)
{
    auto *params = static_cast<ICMPTaskParams *>(pvParams);
    ICMPService *service = params->service;

    ip_addr_t target{};
    if (!resolve_ipv4_to_ip_addr(params->targetIP, target))
    {
        service->pingRC = ping_rc_t::ping_resolve_fail;
        service->pingReady = true;
        delete params;
        vTaskDelete(nullptr);
        return;
    }

    // esp_ping setup
    esp_ping_config_t config = ESP_PING_DEFAULT_CONFIG();
    config.target_addr = target;  // destination
    config.count = params->count; // total probes
    config.interval_ms = params->interval_ms;
    config.timeout_ms = params->timeout_ms;

    struct Ctx
    {
        std::vector<uint32_t> rtts;
        volatile uint32_t rx = 0;
        volatile bool done = false;
    } ctx;

    esp_ping_callbacks_t cbs{};
    cbs.on_ping_success = [](esp_ping_handle_t h, void *arg)
    {
        uint32_t time_ms = 0;
        esp_ping_get_profile(h, ESP_PING_PROF_TIMEGAP, &time_ms, sizeof(time_ms)); // RTT
        auto *c = static_cast<Ctx *>(arg);
        c->rtts.push_back(time_ms);
        c->rx++;
    };
    cbs.on_ping_timeout = [](esp_ping_handle_t, void *)
    {
        // Count successes only for median
    };
    cbs.on_ping_end = [](esp_ping_handle_t, void *arg)
    {
        static_cast<Ctx *>(arg)->done = true;
    };
    cbs.cb_args = &ctx;

    esp_ping_handle_t h = nullptr;
    if (esp_ping_new_session(&config, &cbs, &h) != ESP_OK)
    {
        service->pingRC = ping_rc_t::ping_session_fail;
        service->pingReady = true;
        delete params;
        vTaskDelete(nullptr);
        return;
    }

    esp_ping_start(h);

    // Wait up to count * (timeout + interval) + a small delay
    uint32_t wait_ms = (uint32_t)config.count * (config.timeout_ms + config.interval_ms) + 100;
    uint32_t t0 = millis();
    while (!ctx.done && (millis() - t0) < wait_ms)
    {
        vTaskDelay(pdMS_TO_TICKS(10));
    }

    esp_ping_stop(h);
    esp_ping_delete_session(h);

    // Results
    service->pingTX = (int)config.count;
    service->pingRX = (int)ctx.rx;
    service->pingRC = (service->pingRX > 0) ? ping_rc_t::ping_ok : ping_rc_t::ping_timeout;
    service->pingMedianMs = median_ms(ctx.rtts);

    if (service->pingRX > 0)
        service->pingRC = ping_rc_t::ping_ok;
    else if (service->pingRX == 0)
        service->pingRC = ping_rc_t::ping_timeout;

    service->pingReady = true;

    delete params;
    vTaskDelete(nullptr);
}

void ICMPService::clearICMPLogging() {
    portENTER_CRITICAL(&icmpMux);
    icmpLog.clear();
    stopICMPFlag = false;
    portEXIT_CRITICAL(&icmpMux);
}

void ICMPService::pushICMPLog(const std::string& line) {
    portENTER_CRITICAL(&icmpMux);
    icmpLog.push_back(line);
    if (icmpLog.size() > ICMP_LOG_MAX) {
        size_t excess = icmpLog.size() - ICMP_LOG_MAX;
        icmpLog.erase(icmpLog.begin(), icmpLog.begin() + excess);
    }
    portEXIT_CRITICAL(&icmpMux);
}

bool ICMPService::getICMPServiceStatus() {
    bool v;
    portENTER_CRITICAL(&ICMPService::icmpMux);
    v = ICMPService::stopICMPFlag;
    portEXIT_CRITICAL(&ICMPService::icmpMux);
    return v;
}

std::vector<std::string> ICMPService::fetchICMPLog() {
    std::vector<std::string> batch;
    portENTER_CRITICAL(&ICMPService::icmpMux);
    batch.swap(ICMPService::icmpLog);
    portEXIT_CRITICAL(&ICMPService::icmpMux);
    return batch;
}

void ICMPService::stopICMPService(){
    portENTER_CRITICAL(&ICMPService::icmpMux);
    ICMPService::stopICMPFlag = true;
    portEXIT_CRITICAL(&ICMPService::icmpMux);
}