SecureList Class Reference

#include <BastionGuard-secure.hpp>

Static Public Member Functions
static bool	open_if_allowed (const std::string &url, int argc, char **argv)
static bool	is_payment_domain (const std::string &domain)
static bool	is_builtin_payment_provider (const std::string &domain)
static std::string	extract_domain (const std::string &url)
static std::string	clean_domain (const std::string &d)
static bool	ends_with (const std::string &s, const std::string &suffix)

Static Private Member Functions
static std::string	config_path_payments ()
static void	open_system_browser (const std::string &url)
static const std::vector< std::string > &	payments_cache_only ()

Detailed Description

Definition at line 26 of file BastionGuard-secure.hpp.

Member Function Documentation

clean_domain()

std::string SecureList::clean_domain ( const std::string & d )

static

Definition at line 110 of file BastionGuard-secure.cpp.

                                                     {
    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;
}

References to_lower().

Referenced by extract_domain(), is_builtin_payment_provider(), is_payment_domain(), and load_payments_list_only().

config_path_payments()

std::string SecureList::config_path_payments ( )

staticprivate

Definition at line 50 of file BastionGuard-secure.cpp.

                                           {
    const auto base = Glib::get_user_config_dir();
    return base + "/BastionGuard/payments.json";
}

Referenced by payments_cache_only().

ends_with()

bool SecureList::ends_with ( const std::string & s, const std::string & suffix )

static

Definition at line 146 of file BastionGuard-secure.cpp.

                                                                      {
    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));
        }
    );
}

Referenced by is_builtin_payment_provider(), and matches_payment_domain().

extract_domain()

std::string SecureList::extract_domain ( const std::string & url )

static

Definition at line 135 of file BastionGuard-secure.cpp.

                                                         {
    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 "";
}

References clean_domain().

Referenced by open_if_allowed().

is_builtin_payment_provider()

bool SecureList::is_builtin_payment_provider ( const std::string & domain )

static

Definition at line 246 of file BastionGuard-secure.cpp.

                                                                    {
    // 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;
}

References clean_domain(), and ends_with().

Referenced by open_if_allowed().

is_payment_domain()

bool SecureList::is_payment_domain ( const std::string & domain )

static

Definition at line 230 of file BastionGuard-secure.cpp.

                                                          {
    // 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);
}

References _, clean_domain(), SettingsStore::get_secure_payments_enabled(), matches_payment_domain(), and payments_cache_only().

Referenced by open_if_allowed().

open_if_allowed()

bool SecureList::open_if_allowed ( const std::string & url, int argc, char ** argv )

static

Definition at line 293 of file BastionGuard-secure.cpp.

                                                                            {
    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;
}

References _, extract_domain(), is_builtin_payment_provider(), is_payment_domain(), SecureBrowser::open(), and open_system_browser().

Referenced by main().

open_system_browser()

void SecureList::open_system_browser ( const std::string & url )

staticprivate

Definition at line 55 of file BastionGuard-secure.cpp.

                                                         {
    // 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");
}

References _.

Referenced by open_if_allowed().

payments_cache_only()

const std::vector< std::string > & SecureList::payments_cache_only ( )

staticprivate

Definition at line 206 of file BastionGuard-secure.cpp.

                                                            {
    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;
}

References config_path_payments(), and load_payments_list_only().

Referenced by is_payment_domain().

---

The documentation for this class was generated from the following files:

• BastionGuard/src/payment_secure/BastionGuard-secure.hpp
• BastionGuard/src/payment_secure/BastionGuard-secure.cpp