Skip to content

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

17.6 KB
Raw Blame
#include "NmapService.h"
#include <Arduino.h>
#include "lwip/sockets.h"
#include "lwip/netdb.h"
#include "lwip/inet.h"
#include <sys/ioctl.h> 
#include <cstring>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <unordered_set>
#include <ESP32Ping.h>

extern "C" {
#include <getopt.h>   // provides getopt_long
}

struct NmapTaskParams
{
    std::vector<std::string> targetHosts;
    std::vector<uint16_t> targetPorts;
    int verbosity;
    NmapService *service;
};

void NmapService::setDefaultPorts(bool tcp){
    if (tcp) {
        this->targetPorts = TOP_100_TCP_PORTS;
    } else {
        this->targetPorts = TOP_100_UDP_PORTS;
    }
}

void NmapService::setOptions(const NmapOptions& options){
    this->_options = options;
}

std::string NmapService::getHelpText() {
    return
    "Usage: nmap <host> [options]\r\n"
    "\r\n"
    "Options:\r\n"
    "  -h              Show this help\r\n"
    "  -p <spec>       Ports: 80 | 22,80,443 | 8000-8010 | 0x50\r\n"
    "  -sT             TCP connect scan (default)\r\n"
    "  -sU             UDP scan\r\n"
    "  -sn             Ping scan (disable port scan)\r\n"
    "  -v / -vv        Verbosity\r\n"
    "\r\n"
    "Examples:\r\n"
    "  nmap 192.168.1.10 -p 22,80-90 -sT -vv\r\n"
    "  nmap example.com -sU -p 53,123\r\n"
    "  nmap 10.0.0.5 -p 8080\r\n";
}

NmapOptions NmapService::parseNmapArgs(const std::vector<std::string>& tokens) {
    NmapOptions nmapOptions;
    std::vector<char*> argv;

    argv.reserve(tokens.size() + 1);
    argv.push_back(const_cast<char*>("nmap"));
    for (auto& token : tokens) 
        argv.push_back(const_cast<char*>(token.c_str()));
        
    int argc = static_cast<int>(argv.size());

    // Don't print errors to stderr
    opterr = 0;
    // Restart scanning at argv[1]
    optind = 1;

    // Needed for getopt_long
    // If getopt_long matches an option, it returns a char
    static const option longopts[] = {
        {"help",  no_argument,       nullptr, 'h'},
        {"ports", required_argument, nullptr, 'p'},
        {"scan",  required_argument, nullptr, 's'}, // e.g. -sT / -sU
        {nullptr, 0,                 nullptr,  0 }
    };

    int option;
    while ((option = getopt_long(argc, argv.data(), "hp:s:v", longopts, nullptr)) != -1) {
        switch (option) {
            case 'h': nmapOptions.help = true; break;
            case 'p':
                nmapOptions.hasPort = true;
                nmapOptions.ports = optarg ? optarg : "";
                break;
            case 's': // -sT, -sU, -sn
                if (!optarg || !*optarg) {
                    nmapOptions.hasTrash = true;
                    break;
                }
                for (const char* p = optarg; *p; ++p) {
                    // Don't allow both TCP and UDP
                    if (*p == 'T') {nmapOptions.tcp = true; nmapOptions.udp = false; break;}
                    else if (*p == 'U') {nmapOptions.udp = true; nmapOptions.tcp = false; break; }
                    else if (*p == 'n') {nmapOptions.pingOnly = true; break; }
                    else nmapOptions.hasTrash = true; // unknown letter after -s
                }
                break;
            case 'v':
                // If using double verbosity, it will add
                ++nmapOptions.verbosity;
                break;
            default:
                // Unknown options
                nmapOptions.hasTrash = true;
                break;
        }
    }

    return nmapOptions;
}

NmapService::NmapService() : ready(false), argTransformer(nullptr), verbosity(0), layer4Protocol(Layer4Protocol::TCP), icmpService(nullptr) {}

void NmapService::setArgTransformer(ArgTransformer& argTransformer){
    this->argTransformer = &argTransformer;
}

const bool NmapService::isReady() {
    return this->ready;
}

const std::string NmapService::getReport() {
    return this->report;
}

static int udp_probe_with_timeout(in_addr addr, uint16_t port, int timeout_ms,
                                  const void* payload, size_t payload_len, int retries = 2)
{
    int s = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (s < 0) return nmap_rc_enum::OTHER;

    int rcvbuf = 4096;
    (void)setsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));

    sockaddr_in sa{
        .sin_family = AF_INET,
        .sin_port   = htons(port),
        .sin_addr   = addr 
    };

    if (::connect(s, (sockaddr*)&sa, sizeof(sa)) < 0) {
        int e = errno;
        ::close(s);
        if (e == EHOSTUNREACH || e == ENETUNREACH) 
            return nmap_rc_enum::UDP_OPEN_FILTERED;
        return nmap_rc_enum::OTHER;
    }

    timeval tv{
        .tv_sec = timeout_ms / 1000,
        .tv_usec = (timeout_ms % 1000) * 1000
    };
    setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

    // Probe message
    static const char kProbe[] = "PING\n";
    const void* buf   = (payload && payload_len) ? payload : kProbe;
    size_t      blen  = (payload && payload_len) ? payload_len : (sizeof(kProbe)-1);

    uint8_t rbuf[512];

    for (int attempt = 0; attempt <= retries; ++attempt) {
        if (::send(s, buf, blen, 0) < 0) {
            int e = errno; ::close(s);
            if (e == EHOSTUNREACH || e == ENETUNREACH)
                return nmap_rc_enum::UDP_OPEN_FILTERED;
            return nmap_rc_enum::OTHER;
        }

        ssize_t n = ::recvfrom(s, rbuf, sizeof(rbuf), MSG_TRUNC, nullptr, nullptr);
        if (n >= 0) {
            ::close(s);
            return nmap_rc_enum::UDP_OPEN;
        }

        int e = errno;
        if (e == ECONNREFUSED) {           // ICMP Unreachable
            ::close(s);
            return nmap_rc_enum::UDP_CLOSED;
        }
        if (e == EMSGSIZE) {               // Datagram larger buffer
            ::close(s);
            return nmap_rc_enum::UDP_OPEN;
        }
        if (e == EAGAIN || e == EWOULDBLOCK) {
            vTaskDelay(pdMS_TO_TICKS(10));
            continue;                      // Retry
        }
        if (e == EHOSTUNREACH || e == ENETUNREACH) {
            ::close(s);
            return nmap_rc_enum::UDP_OPEN_FILTERED;
        }
        ::close(s);
        return nmap_rc_enum::OTHER;
    }

    ::close(s);
    return nmap_rc_enum::UDP_OPEN_FILTERED;
}

static int tcp_connect_with_timeout(in_addr addr, uint16_t port, int timeout_ms)
{
    int s = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (s < 0) 
        return nmap_rc_enum::OTHER;

    // Make socket non-blocking to avoid blocking the thread
    int nb = 1;
    if (ioctl(s, FIONBIO, &nb) < 0) {
        ::close(s);
        return nmap_rc_enum::OTHER;
    }

    // Setup the sockaddr_in structure
    sockaddr_in sa{
        .sin_family = AF_INET,
        .sin_port   = htons(port),
        .sin_addr   = addr
    };

    int rc = ::connect(s, (sockaddr*)&sa, sizeof(sa));
    if (rc == 0) {
        ::close(s);
        return nmap_rc_enum::TCP_OPEN;
    }

    // Check status of connection
    if (errno != EINPROGRESS && errno != EALREADY) {
        int e = errno;
        ::close(s);
        if (e == ECONNREFUSED || e == ECONNRESET) return nmap_rc_enum::TCP_CLOSED;     // RST
        if (e == ETIMEDOUT || e == EHOSTUNREACH || e == ENETUNREACH || e == EACCES || e == EPERM)
            return nmap_rc_enum::TCP_FILTERED;                                         // Silently dropped / blocked
        return nmap_rc_enum::OTHER;
    }

    // Wait to write
    fd_set wfds, efds;
    FD_ZERO(&wfds); FD_ZERO(&efds);
    FD_SET(s, &wfds); FD_SET(s, &efds);

    struct timeval tv{
        .tv_sec  = timeout_ms / 1000,
        .tv_usec = (timeout_ms % 1000) * 1000
    };

    rc = ::select(s + 1, nullptr, &wfds, &efds, &tv);
    if (rc == 0) {                 // handshake never completed -> should be filtered
        ::close(s);
        return nmap_rc_enum::TCP_FILTERED;
    }
    if (rc < 0)  {
        ::close(s);
        return nmap_rc_enum::OTHER;
    }

    int soerr = 0;
    socklen_t len = sizeof(soerr);
    if (getsockopt(s, SOL_SOCKET, SO_ERROR, &soerr, &len) < 0) {
        ::close(s);
        return nmap_rc_enum::OTHER;
    }

    ::close(s);
    switch (soerr)
    {
    case 0:
        /* code */
        return nmap_rc_enum::TCP_OPEN;
    case ECONNREFUSED:
    case ECONNRESET:
        return nmap_rc_enum::TCP_CLOSED;
    case ETIMEDOUT:
    case EHOSTUNREACH:
    case ENETUNREACH: 
    case EACCES:
    case EPERM:
        return nmap_rc_enum::TCP_FILTERED;
    default:
        return nmap_rc_enum::OTHER;
    }
    return nmap_rc_enum::OTHER;
}

static bool resolveIPv4(const std::string& host, in_addr& out)
{
    struct addrinfo hints{};
    hints.ai_family   = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    struct addrinfo* res = nullptr;
    int rc = getaddrinfo(host.c_str(), nullptr, &hints, &res);
    if (rc != 0 || !res) return false;

    out = ((struct sockaddr_in*)res->ai_addr)->sin_addr;
    freeaddrinfo(res);
    return true;
}

static inline void trimWhitespaces(std::string& input_str) {
    if (input_str.empty()) 
        return;

    const char* whitespaceCharacters = " \t\r\n";
    input_str.erase(0, input_str.find_first_not_of(whitespaceCharacters));

    size_t pos = input_str.find_last_not_of(whitespaceCharacters);
    if (pos != std::string::npos) 
        input_str.erase(pos + 1); 
    else 
        input_str.clear();
}

static inline const char* nmap_guess_service(uint16_t port, Layer4Protocol proto,
                                             const PortService* tbl, size_t n) {
    for (size_t i = 0; i < n; ++i) {
        if (tbl[i].port == port && tbl[i].proto == proto)
            return tbl[i].service;
    }
    return nullptr;
}

static inline void columnString(std::string& dest, const std::string& text, size_t width) {
    dest.append(text);
    if (text.size() < width) dest.append(width - text.size(), ' ');
}

void NmapService::scanTarget(const std::string &host, const std::vector<uint16_t> &ports)
{
    in_addr ip{};
    if (!resolveIPv4(host, ip)) {
        this->report.append("Failed to resolve host: ").append(host).append("\r\n");
        return;
    }

    char ipStr[INET_ADDRSTRLEN]{};
    inet_ntop(AF_INET, &ip, ipStr, sizeof(ipStr));
    this->report.append("Nmap scan report for ").append(host).append(" (").append(ipStr).append(")\r\n");

    if (icmpService != nullptr) {
        #ifndef DEVICE_M5STICK
        icmpService->startPingTask(host, 1, 1000, 200);
        while (!icmpService->isPingReady()) vTaskDelay(pdMS_TO_TICKS(50));
        if (icmpService->lastRc() == ping_rc_t::ping_ok) {
            this->report.append("Host is up (").append(std::to_string(icmpService->lastMedianMs())).append("ms latency).\r\n");
        } else {
            this->report.append("Host is down.\r\n");
            return;
        }
        #else
        const unsigned long t0 = millis();
        const bool ok = Ping.ping(host.c_str(), 1);
        const unsigned long t1 = millis();
        if (ok) this->report.append("Host is up (").append(std::to_string(t1 - t0)).append("ms latency).\r\n");
        else { this->report.append("Host is down.\r\n"); return; }
        #endif
    } else {
        this->report.append("Error: ICMP service not available.\r\n");
        return;
    }

    if (this->_options.pingOnly) return;

    auto columnString = [](std::string& dst, const std::string& txt, size_t width){
        dst += txt;
        if (txt.size() < width) dst.append(width - txt.size(), ' ');
    };

    size_t portCol = std::string("PORT").size();
    for (uint16_t p : ports) {
        size_t len = std::to_string(p).size() + 4;
        if (len > portCol) portCol = len;
    }
    portCol += 2;

    size_t stateCol = std::string("open|filtered").size();
    stateCol += 2;
    std::string header;
    columnString(header, "PORT",  portCol);
    columnString(header, "STATE", stateCol);
    header += "SERVICE\r\n";
    report += header;

    int closed_ports = ports.size();
    for (uint16_t p : ports) {
        std::string state;

        if (this->layer4Protocol == Layer4Protocol::TCP) {
            int st = tcp_connect_with_timeout(ip, p, CONNECT_TIMEOUT_MS);
            switch (st) {
                case nmap_rc_enum::TCP_OPEN:
                    state = "open";
                    closed_ports--;
                    break;
                case nmap_rc_enum::TCP_CLOSED:
                    if (this->verbosity >= 1) 
                        state = "closed";
                    break;
                case nmap_rc_enum::TCP_FILTERED:
                    state = "filtered";
                    closed_ports--;
                    break;
                default:
                    if (this->verbosity >= 1)
                        state = "error";
                    break;
            }
        } else if (this->layer4Protocol == Layer4Protocol::UDP) {
            int st = udp_probe_with_timeout(ip, p, CONNECT_TIMEOUT_MS, nullptr, 0);
            switch (st) {
                case nmap_rc_enum::UDP_OPEN:
                    state = "open";
                    closed_ports--;
                    break;
                case nmap_rc_enum::UDP_CLOSED:
                    if (this->verbosity >= 1)
                        state = "closed";
                    break;
                case nmap_rc_enum::UDP_OPEN_FILTERED:
                    state = "open|filtered";
                    closed_ports--;
                    break;
                default:
                    if (this->verbosity >= 1) state = "error";
                    break;
            }
        } else {
            return;
        }

        if (!state.empty()) {
            std::string row;
            std::string portField = std::to_string(p) + (layer4Protocol == Layer4Protocol::TCP ? "/tcp" : "/udp");
            columnString(row, portField, portCol);
            columnString(row, state,     stateCol);

            const char* svc = nmap_guess_service(
                p,
                layer4Protocol,
                (layer4Protocol == Layer4Protocol::TCP) ? TOP100_TCP_MAP : TOP100_UDP_MAP,
                (layer4Protocol == Layer4Protocol::TCP) ? TOP100_TCP_MAP_COUNT : TOP100_UDP_MAP_COUNT
            );
            if (svc) row += svc;

            report.append(row).append("\r\n");
        }

        vTaskDelay(pdMS_TO_TICKS(SMALL_DELAY_MS));
    }

    if (closed_ports > 0)
        this->report.append("Not shown: ").append(std::to_string(closed_ports)).append(" ports\r\n\n");
}

void NmapService::setICMPService(ICMPService* icmpService){
    this->icmpService = icmpService;
}

void NmapService::clean()
{
    this->targetHosts.clear();
    this->targetPorts.clear();
    this->report.clear();
    this->ready = false;
    this->layer4Protocol = Layer4Protocol::TCP;
    this->verbosity = 0;
}

void NmapService::scanTask(void *pvParams)
{
    auto *params = static_cast<NmapTaskParams *>(pvParams);
    auto &service = *params->service;
    auto &hosts = params->targetHosts;
    for (auto host : hosts) {
        service.scanTarget(host, params->targetPorts);
    }

    service.ready = true;
    service.verbosity = params->verbosity;
    delete params;
    vTaskDelete(nullptr);
}

void NmapService::startTask(int verbosity)
{
    auto *params = new NmapTaskParams{this->targetHosts, this->targetPorts, verbosity, this};
    xTaskCreatePinnedToCore(scanTask, "NmapConnect", 20000, params, 1, nullptr, 1);
    delay(100); // start task delay
}

bool NmapService::parseHosts(const std::string& hosts_arg)
{
    this->targetHosts = std::vector<std::string>();

    // If we find ',' or '-' or '/network_mask' there are multiple hosts
    if (hosts_arg.find(',') == std::string::npos && hosts_arg.find('-') == std::string::npos && hosts_arg.find('/') == std::string::npos) {
        // Single host
        if (isIpv4(hosts_arg)) {
            this->targetHosts.push_back(hosts_arg);
        }
        else {
            return false;
        }
    }
    else {
        // Not yet implemented
        return false;
    }
    return true;
}

void NmapService::setLayer4(bool layer4Protocol){
    if (layer4Protocol == true){
        this->layer4Protocol = Layer4Protocol::TCP;
    }
    else {
        this->layer4Protocol = Layer4Protocol::UDP;
    }
}

bool NmapService::parsePorts(const std::string& ports_arg)
{
    this->targetPorts = std::vector<uint16_t>();

    if (ports_arg.empty())
        return false;

    std::unordered_set<uint16_t> seen;
    std::stringstream portsStream(ports_arg);
    std::string token;

    while (std::getline(portsStream, token, ',')) {
        trimWhitespaces(token);
        if (token.empty()) continue;

        // Range?
        size_t dash = token.find('-');
        if (dash != std::string::npos) {
            std::string a = token.substr(0, dash);
            std::string b = token.substr(dash + 1);
            trimWhitespaces(a);
            trimWhitespaces(b);

            uint16_t port1 = this->argTransformer->parseHexOrDec16(a);
            uint16_t port2 = this->argTransformer->parseHexOrDec16(b);

            if (!port1 || !port2)
                return false;

            if (port1 > port2)
                std::swap(port1, port2);

            for (uint16_t port = port1; port <= port2; ++port) {
                if (seen.insert(port).second)
                    targetPorts.push_back(port);
            }
        } else {
            // Single port
            uint16_t port = this->argTransformer->parseHexOrDec16(token);
            if (!port)
                return false;
            if (seen.insert(port).second)
                targetPorts.push_back(port);
        }
    }

    if (targetPorts.empty()) 
        return false;

    std::sort(targetPorts.begin(), targetPorts.end());
    return true;
}


bool NmapService::isIpv4(const std::string& address)
{
    // Check if the address is a valid IPv4 address
    struct sockaddr_in sa;
    return inet_pton(AF_INET, address.c_str(), &(sa.sin_addr)) != 0;
}