BastionGuard-secure.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 "BastionGuard-secure.hpp"
#include "SecureBrowser.hpp"
#include "SettingsStore.hpp"
#include <glib/gi18n.h>
#include <glibmm.h>
#include <nlohmann/json.hpp>
 
#include <algorithm>
#include <cctype>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <regex>
#include <string>
#include <vector>
#include <sys/wait.h>
#include <unistd.h>
 
namespace fs = std::filesystem;
using json = nlohmann::json;
 
 
static std::string to_lower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c){ return std::tolower(c); });
    return s;
}
 
std::string SecureList::config_path_payments() {
    const auto base = Glib::get_user_config_dir();
    return base + "/BastionGuard/payments.json";
}
 
void SecureList::open_system_browser(const std::string& url) {
    // ANTI-LOOP CRITICO.
    // Questo fallback apre l'URL nel browser di SISTEMA. Ma il browser di
    // sistema è configurato per usare il proxy MITM di BastionGuard, quindi
    // la richiesta verso un dominio bank/secure torna al proxy, che la
    // re-intercetta e rilancia di nuovo BastionGuard-secure → che richiama
    // open_system_browser → xdg-open → ... loop infinito = migliaia di
    // finestre/processi.
    //
    // Due protezioni:
    //  1) BG_OPENER_DEPTH: se siamo già stati invocati dalla catena opener,
    //     NON riapriamo il browser di sistema (interrompe la ricorsione).
    //  2) no_proxy="*"/NO_PROXY="*" nell'ambiente del comando lanciato: il
    //     browser di sistema NON deve instradare QUESTA apertura attraverso
    //     il proxy di BastionGuard, così non viene re-intercettata.
    if (std::getenv("BG_OPENER_DEPTH")) {
        std::cerr << _("[BastionGuard-secure] ⛔ Anti-loop: apertura browser di "
                       "sistema già in corso, non rilancio (") << url << ")\n";
        return;
    }
 
    const char* wayland = std::getenv("WAYLAND_DISPLAY");
    const pid_t pid = ::fork();
    if (pid < 0) {
        std::cerr << _("[BastionGuard-secure] ❌ Impossibile avviare il browser di sistema.\n");
        return;
    }
 
    if (pid == 0) {
        // Neutralizza il proxy soltanto nel processo figlio e passa l'URL come
        // singolo argv: nessuna interpretazione di metacaratteri da una shell.
        ::setenv("BG_OPENER_DEPTH", "1", 1);
        ::setenv("no_proxy", "*", 1);
        ::setenv("NO_PROXY", "*", 1);
        static const char* proxy_vars[] = {
            "http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY", "all_proxy", "ALL_PROXY"
        };
        for (const char* name : proxy_vars)
            ::unsetenv(name);
 
        if (wayland && *wayland) {
            const char* gio_argv[] = {"gio", "open", url.c_str(), nullptr};
            ::execvp("gio", const_cast<char* const*>(gio_argv));
        }
 
        const char* xdg_argv[] = {"xdg-open", url.c_str(), nullptr};
        ::execvp("xdg-open", const_cast<char* const*>(xdg_argv));
        _exit(127);
    }
 
    int status = 0;
    if (::waitpid(pid, &status, 0) < 0)
        std::cerr << _("[BastionGuard-secure] ⚠️ waitpid fallita per browser di sistema.\n");
}
 
std::string SecureList::clean_domain(const std::string& d) {
    std::string s = d;
 
    // trim minimo
    while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front())))
        s.erase(s.begin());
    while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back())))
        s.pop_back();
 
    s = to_lower(s);
 
    if (!s.empty() && s[0] == '.')
        s.erase(0, 1);
 
    if (s.rfind("www.", 0) == 0)
        s.erase(0, 4);
 
    // rimuovi porta
    auto p = s.find(':');
    if (p != std::string::npos)
        s.erase(p);
 
    return s;
}
 
std::string SecureList::extract_domain(const std::string& url) {
    std::regex re(R"(^(?:[a-zA-Z][a-zA-Z0-9+\-.]*:\/\/)?(?:[^\/@]+@)?([^\/:?#]+))",
                  std::regex::icase);
 
    std::smatch match;
    if (std::regex_search(url, match, re) && match.size() >= 2) {
        return clean_domain(match[1].str());
    }
    return "";
}
 
bool SecureList::ends_with(const std::string& s, const std::string& suffix) {
    if (suffix.size() > s.size()) return false;
    return std::equal(
        suffix.rbegin(), suffix.rend(),
        s.rbegin(),
        [](char a, char b) {
            return std::tolower(static_cast<unsigned char>(a)) ==
                   std::tolower(static_cast<unsigned char>(b));
        }
    );
}
 
 
static void load_payments_list_only(const std::string& path, std::vector<std::string>& out) {
    if (!fs::exists(path)) {
        std::cerr << _("[BastionGuard-secure] ⚠ payments.json non trovato: ") << path << "\n";
        return;
    }
 
    std::ifstream f(path, std::ios::binary);
    if (!f.is_open()) {
        std::cerr << _("[BastionGuard-secure] ⚠ Impossibile aprire: ") << path << "\n";
        return;
    }
 
    json j;
    try {
        f >> j;
    } catch (const std::exception& e) {
        std::cerr << Glib::ustring::compose(
            _("[BastionGuard-secure] ❌ Errore parsing JSON (%1): %2"),
            path,
            e.what()
        ) << "\n";
        return;
    }
 
    if (!j.is_object()) {
        std::cerr << _(
    "[BastionGuard-secure] ⚠ payments.json deve essere un oggetto con chiave \"list\"."
        ) << "\n";
 
        return;
    }
 
    if (!j.contains("list") || !j["list"].is_array()) {
        std::cerr << _("[BastionGuard-secure] ⚠ payments.json: chiave \"list\" mancante o non array.\n");
        return;
    }
 
    for (const auto& v : j["list"]) {
        if (!v.is_string()) continue;
        auto cd = SecureList::clean_domain(v.get<std::string>());
        if (!cd.empty()) out.push_back(cd);
    }
 
    std::cerr << _("[BastionGuard-secure] ✅ Caricati ") << out.size()
              << _(" domini da payments.json (list)\n");
}
 
const std::vector<std::string>& SecureList::payments_cache_only() {
    static bool init = false;
    static std::vector<std::string> cached;
 
    if (!init) {
        const std::string path_user = config_path_payments();
        load_payments_list_only(path_user, cached);
        init = true;
    }
 
    return cached;
}
 
static bool matches_payment_domain(const std::string& host_norm,
                                  const std::vector<std::string>& list_norm) {
    for (const auto& d : list_norm) {
        if (d.empty()) continue;
        if (host_norm == d) return true;
        if (SecureList::ends_with(host_norm, "." + d)) return true;
    }
    return false;
}
 
 
bool SecureList::is_payment_domain(const std::string& domain) {
    // Se vuoi che sia sempre attivo a prescindere dalle impostazioni,
    // rimuovi questo controllo.
    if (!SettingsStore::get_secure_payments_enabled())
        return false;
 
    const auto& list = payments_cache_only();
    if (list.empty()) {
        std::cerr << _("[BastionGuard-secure] ⚠ Nessun dominio presente in payments.json.\n");
        return false;
    }
 
    const std::string dnorm = clean_domain(domain);
    return matches_payment_domain(dnorm, list);
}
 
bool SecureList::is_builtin_payment_provider(const std::string& domain) {
    // Domini "navigabili" dei principali provider di pagamento: pagine dove
    // l'utente effettua davvero login/checkout/inserimento carta. Devono
    // SEMPRE aprirsi nella sandbox CEF, anche se l'utente non li ha messi in
    // payments.json.
    //
    // ATTENZIONE: qui NON vanno gli endpoint tecnici (js.stripe.com,
    // api.stripe.com, hooks.*, cdn.*, api.paypal.com, ...). Quelli sono
    // iframe/API caricati DENTRO la pagina di un merchant e restano nelle
    // esclusioni del proxy: intercettarli romperebbe il checkout. Qui solo
    // i domini che l'utente naviga direttamente.
    static const std::vector<std::string> providers = {
        "stripe.com",            // checkout.stripe.com, dashboard.stripe.com, billing.stripe.com
        "paypal.com",            // www.paypal.com, checkout.paypal.com
        "paypalobjects.com",
        "adyen.com",             // ca-live/checkout pages (NB: checkoutshopper-* resta escluso)
        "checkout.com",
        "klarna.com",
        "worldpay.com",
        "braintreegateway.com",
        "nexi.it",
        "nexigroup.com",
        "sisalpay.it",
        "satispay.com",
        "sumup.com",
        "square.com",
        "squareup.com",
        "mollie.com",
        "gocardless.com",
        "wise.com",
        "revolut.com",
        "skrill.com",
        "neteller.com",
        "paysafecard.com",
        "amazonpay.com",
        "wallet.google.com",
        "pay.google.com",
    };
 
    const std::string dnorm = clean_domain(domain);
    for (const auto& d : providers) {
        if (dnorm == d) return true;
        if (ends_with(dnorm, "." + d)) return true;
    }
    return false;
}
 
bool SecureList::open_if_allowed(const std::string& url, int argc, char** argv) {
    if (url.empty()) {
        std::cerr << _("[BastionGuard-secure] ⚠ URL vuoto.\n");
        return false;
    }
 
    const std::string domain = extract_domain(url);
    if (domain.empty()) {
        std::cerr << _("[BastionGuard-secure] ❌ Impossibile estrarre dominio da: ") << url << "\n";
        open_system_browser(url);
        return false;
    }
 
    if (is_payment_domain(domain) || is_builtin_payment_provider(domain)) {
        std::cout << _("[BastionGuard-secure] 🟢 Dominio consentito (payments.json / provider noto): ") << domain << "\n";
        std::cout << _("[BastionGuard-secure] 🔐 Avvio SecureBrowser (CEF)...\n");
        SecureBrowser::open(url, argc, argv);
        return true;
    }
 
    std::cout << _("[BastionGuard-secure] 🔴 Dominio NON presente in payments.json: ") << domain << "\n";
    std::cout << _("[BastionGuard-secure] → Apertura nel browser di sistema.\n");
    open_system_browser(url);
    return false;
}