ProxyDetect.cpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0
 */
 
#include "ProxyDetect.hpp"
 
#include <algorithm>
#include <cctype>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <mutex>
#include <sstream>
 
namespace bsc::ui_util {
namespace fs = std::filesystem;
namespace {
 
std::string to_lower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return s;
}
 
std::string trim(std::string s) {
    auto not_space = [](unsigned char c) { return !std::isspace(c); };
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), not_space));
    s.erase(std::find_if(s.rbegin(), s.rend(), not_space).base(), s.end());
    // Rimuovi eventuali quote
    if (s.size() >= 2 && (s.front() == '"' || s.front() == '\'')) {
        if (s.back() == s.front()) s = s.substr(1, s.size() - 2);
    }
    return s;
}
 
// Parse URL del tipo http://host:port, socks5://user:pass@host:port, ecc.
// Non abbiamo una libreria URL: parsing manuale robusto a casi comuni.
bool parse_proxy_url(const std::string& raw, ProxyEndpoint& out) {
    auto url = trim(raw);
    if (url.empty()) return false;
 
    // scheme://
    auto scheme_end = url.find("://");
    if (scheme_end != std::string::npos) {
        out.scheme = to_lower(url.substr(0, scheme_end));
        url = url.substr(scheme_end + 3);
    } else {
        // host:port senza scheme
        out.scheme = "http";
    }
 
    // Rimuovi user:pass@
    auto at = url.find('@');
    if (at != std::string::npos) url = url.substr(at + 1);
 
    // Taglia path dopo /
    auto slash = url.find('/');
    if (slash != std::string::npos) url = url.substr(0, slash);
    if (url.empty()) return false;
 
    // host:port (gestisce anche [::1]:8080 per IPv6)
    if (url.front() == '[') {
        auto rb = url.find(']');
        if (rb == std::string::npos) return false;
        out.host = url.substr(1, rb - 1);
        if (rb + 1 < url.size() && url[rb + 1] == ':') {
            try { out.port = static_cast<std::uint16_t>(std::stoul(url.substr(rb + 2))); }
            catch (...) { return false; }
        }
    } else {
        auto colon = url.find(':');
        if (colon == std::string::npos) {
            out.host = url;
            out.port = (out.scheme == "https") ? 443 : 8080;
        } else {
            out.host = url.substr(0, colon);
            try { out.port = static_cast<std::uint16_t>(std::stoul(url.substr(colon + 1))); }
            catch (...) { return false; }
        }
    }
 
    if (out.host.empty() || out.port == 0) return false;
    return true;
}
 
void collect_env_proxies(std::vector<ProxyEndpoint>& out) {
    // Le variabili sono case-insensitive su POSIX: cerchiamo entrambe le forme.
    static const char* kVars[] = {
        "http_proxy", "HTTP_PROXY",
        "https_proxy", "HTTPS_PROXY",
        "all_proxy", "ALL_PROXY",
        "socks_proxy", "SOCKS_PROXY",
    };
    for (const char* var : kVars) {
        const char* v = std::getenv(var);
        if (!v || !*v) continue;
        ProxyEndpoint ep;
        if (parse_proxy_url(v, ep)) out.push_back(std::move(ep));
    }
}
 
void collect_file_proxies(const fs::path& path, std::vector<ProxyEndpoint>& out) {
    std::error_code ec;
    if (!fs::exists(path, ec)) return;
    std::ifstream f(path);
    if (!f) return;
    std::string line;
    while (std::getline(f, line)) {
        const auto low = to_lower(line);
        // Match key=value dove key contiene "_proxy"
        auto eq = line.find('=');
        if (eq == std::string::npos) continue;
        const auto key = to_lower(trim(line.substr(0, eq)));
        if (key.find("_proxy") == std::string::npos) continue;
        // Evita ignore_proxy/no_proxy
        if (key.find("no_proxy") != std::string::npos) continue;
        ProxyEndpoint ep;
        auto val = trim(line.substr(eq + 1));
        // Spesso sono nella forma 'export KEY="val"' — il trim toglie quote.
        // Per le righe 'export foo=bar' il trim della key ci ha lasciato
        // "export foo" — accettiamo comunque.
        if (parse_proxy_url(val, ep)) out.push_back(std::move(ep));
    }
}
 
// Deduplica (host, port, scheme).
void dedup(std::vector<ProxyEndpoint>& v) {
    std::sort(v.begin(), v.end(), [](const ProxyEndpoint& a, const ProxyEndpoint& b) {
        if (a.host != b.host) return a.host < b.host;
        if (a.port != b.port) return a.port < b.port;
        return a.scheme < b.scheme;
    });
    v.erase(std::unique(v.begin(), v.end(),
                        [](const ProxyEndpoint& a, const ProxyEndpoint& b) {
        return a.host == b.host && a.port == b.port && a.scheme == b.scheme;
    }), v.end());
}
 
bool host_equals(const std::string& a, const std::string& b) {
    const auto la = to_lower(a);
    const auto lb = to_lower(b);
    if (la == lb) return true;
    // Alias localhost
    static const std::vector<std::string> localhosts = {
        "localhost", "127.0.0.1", "::1", "0.0.0.0"
    };
    const bool a_is_local = std::find(localhosts.begin(), localhosts.end(), la) != localhosts.end();
    const bool b_is_local = std::find(localhosts.begin(), localhosts.end(), lb) != localhosts.end();
    return a_is_local && b_is_local;
}
 
} // namespace
 
const std::vector<ProxyEndpoint>& detected_proxies() {
    static std::once_flag once;
    static std::vector<ProxyEndpoint> cache;
    std::call_once(once, []() {
        collect_env_proxies(cache);
        collect_file_proxies("/etc/environment", cache);
        if (const char* home = std::getenv("HOME")) {
            collect_file_proxies(fs::path(home) / ".profile", cache);
            collect_file_proxies(fs::path(home) / ".bashrc", cache);
        }
        dedup(cache);
    });
    return cache;
}
 
bool matches_configured_proxy(const std::string& host, std::uint16_t port) {
    for (const auto& p : detected_proxies()) {
        if (p.port == port && host_equals(host, p.host)) return true;
    }
    return false;
}
 
} // namespace bsc::ui_util