WebProbe.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "async_dns_resolver.hpp"
#include "WebProbe.hpp"
#include "network_quality.hpp"
#include "dns_util.hpp"
#include "dns_cache.hpp"
#include "Backend.hpp"
#include <glibmm/i18n.h>
#include <glibmm/miscutils.h>
 
#include <iostream>
#include <regex>
#include <thread>
#include <future>
#include <chrono>
#include <cstring>
#include <arpa/inet.h>
#include <unordered_map>
#include <unordered_set>
#include <mutex>
#include <shared_mutex>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <set>
#include <idn2.h>
 
using namespace std::chrono_literals;
 
 
struct VerdictEntry {
    bool suspicious;
    uint64_t expires_ms;
};
 
static std::mutex g_verdict_mutex;
static std::unordered_map<std::string, VerdictEntry> g_verdicts;
static std::unordered_set<std::string> g_blocklist;
static std::shared_mutex g_hot_mtx;
static std::unordered_map<std::string, std::pair<bool,uint64_t>> g_hot;
static constexpr uint64_t TTL_MS = 15000;
 
static inline uint64_t now_ms() {
    return std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::steady_clock::now().time_since_epoch()).count();
}
 
static std::string expand_user_path(const std::string& rel) {
    std::string home = Glib::get_home_dir();
    if (rel.empty()) return home;
    return home + rel;
}
 
static std::string to_ascii_idna(const std::string& host) {
    if (host.empty()) return host;
    char *out = nullptr;
    int rc = idn2_lookup_ul(host.c_str(), &out, 0);
    if (rc == IDN2_OK && out) {
        std::string r(out);
        idn2_free(out);
        return r;
    }
    return host;
}
 
 
 
static const std::string kBlocklistFile = "/.local/share/BastionGuard/blocklist_hosts.txt";
 
static void load_blocklist(const std::string& hint) {
    std::lock_guard<std::mutex> lg(g_verdict_mutex);
    g_blocklist.clear();
 
    std::vector<std::string> tries;
    if (!hint.empty()) tries.push_back(hint);
    tries.push_back(expand_user_path(kBlocklistFile));
    tries.push_back("/etc/BastionGuard/blocklist_hosts.txt");
 
    for (const auto& p : tries) {
        if (std::filesystem::exists(p)) {
            std::ifstream ifs(p);
            if (!ifs) continue;
            std::string line;
            while (std::getline(ifs, line)) {
                line.erase(std::remove_if(line.begin(), line.end(), ::isspace), line.end());
                if (!line.empty()) {
                    std::string lower = to_ascii_idna(line);
                    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
                    g_blocklist.insert(lower);
                }
            }
            std::cout << _("[WebProbe] ✅ Caricata blocklist da: ") << p
                      << " (" << g_blocklist.size() << _(" domini)\n");
            return;
        }
    }
    std::cout << _("[WebProbe] ⚠️ Nessuna blocklist trovata.\n");
}
 
static bool match_blocklist_pattern(const std::string& pattern, const std::string& host) {
    if (pattern.size() > 2 && pattern[0]=='*' && pattern[1]=='.') {
        const std::string tail = pattern.substr(2);
        if (host == tail) return true;
        if (host.size() > tail.size()+1 &&
            host.compare(host.size()-tail.size(), tail.size(), tail) == 0 &&
            host[host.size()-tail.size()-1] == '.') return true;
    }
    return host == pattern;
}
 
static bool is_blocked_host(const std::string& host) {
    std::lock_guard<std::mutex> lg(g_verdict_mutex);
    for (const auto& pat : g_blocklist)
        if (match_blocklist_pattern(pat, host))
            return true;
    return false;
}
 
 
WebProbe::WebProbe(const std::string& blocklist_path_hint, int warning_port)
    : warning_port_(warning_port)
{
    load_blocklist(blocklist_path_hint);
}
 
WebProbe::~WebProbe() = default;
 
std::string WebProbe::extract_host(const std::string& raw) {
    if (raw.empty()) return {};
    std::string s = raw;
    auto notspace = [](int ch){ return !std::isspace(ch); };
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), notspace));
    s.erase(std::find_if(s.rbegin(), s.rend(), notspace).base(), s.end());
    if (s.empty()) return {};
 
    const char* schemes[] = {"http://","https://","ftp://"};
    for (auto sch : schemes) {
        size_t n = std::strlen(sch);
        if (s.rfind(sch, 0) == 0) { s.erase(0, n); break; }
    }
    auto at = s.find('@');
    if (at != std::string::npos) s.erase(0, at + 1);
    size_t slash = s.find_first_of("/?#");
    if (slash != std::string::npos) s = s.substr(0, slash);
    size_t colon = s.rfind(':');
    if (colon != std::string::npos) {
        std::string after = s.substr(colon + 1);
        if (std::all_of(after.begin(), after.end(), ::isdigit))
            s = s.substr(0, colon);
    }
    if (!s.empty() && s.back() == '.') s.pop_back();
 
    std::string ascii = to_ascii_idna(s);
    std::transform(ascii.begin(), ascii.end(), ascii.begin(), ::tolower);
    return ascii;
}
 
 
std::string WebProbe::build_local_warning_redirect(const std::string& url) const {
    std::string enc;
    for (unsigned char c : url)
        enc += (c == ' ') ? "%20" : std::string(1, c);
    return "http://127.0.0.2:" + std::to_string(warning_port_) + "/?target=" + enc;
}
 
std::string WebProbe::check_url(const std::string& url) {
    if (url.empty()) return url;
    std::string host = extract_host(url);
    if (host.empty()) return url;
 
    auto now = now_ms();
    {
        std::shared_lock<std::shared_mutex> lk(g_hot_mtx);
        auto it = g_hot.find(host);
        if (it != g_hot.end() && now < it->second.second)
            return it->second.first ? build_local_warning_redirect(url) : url;
    }
 
 
    if (Backend::instance().isBankDomain(host)) {
        std::unique_lock<std::shared_mutex> lk(g_hot_mtx);
        g_hot[host] = {false, now + TTL_MS};
        return url;
    }
 
    if (is_blocked_host(host)) {
        std::cout << "[WebProbe] 🔴 Bloccato: " << host << "\n";
        std::unique_lock<std::shared_mutex> lk(g_hot_mtx);
        g_hot[host] = {true, now + TTL_MS};
        return build_local_warning_redirect(url);
    }
 
    std::string cached_ip = AsyncDNSResolver::instance().resolve_cached(host);
    if (cached_ip == "127.0.0.2") {
        std::cout << _("[WebProbe] ⚠️ DNS ha restituito 127.0.0.2 per ") << host << "\n";
        std::unique_lock<std::shared_mutex> lk(g_hot_mtx);
        g_hot[host] = {true, now + TTL_MS};
        return build_local_warning_redirect(url);
    }
 
 
    std::unique_lock<std::shared_mutex> lk(g_hot_mtx);
    g_hot[host] = {false, now + TTL_MS};
    return url;
}
 
 
void WebProbe::register_callback(NotifyCb cb) {
    std::unique_lock<std::shared_mutex> lock(mutex_);
    notify_cb_ = std::move(cb);
}
 
void WebProbe::reload_blocklist(const std::string& path) {
    load_blocklist(path);
}