BankPage.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 "SafeProcess.hpp"
#include "BankPage.hpp"
#include "Backend.hpp"
#include <thread>
#include <fstream>
#include <filesystem>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cctype>
#include <unordered_set>
#include <system_error>
#include <nlohmann/json.hpp>
#include <glibmm/i18n.h>
#include <glibmm/miscutils.h>
#include <glibmm/datetime.h>
#include <cstdlib>
 
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
 
using json = nlohmann::json;
namespace fs = std::filesystem;
 
namespace {
 
static std::string trim_copy(std::string s) {
    auto l = s.find_first_not_of(" \t\r\n");
    auto r = s.find_last_not_of(" \t\r\n");
    if (l == std::string::npos) return {};
    return s.substr(l, r - l + 1);
}
 
static std::string normalize_domain(std::string domain) {
    domain = trim_copy(domain);
    if (domain.empty()) return {};
 
    auto pos = domain.find("://");
    if (pos != std::string::npos)
        domain.erase(0, pos + 3);
 
    pos = domain.find('/');
    if (pos != std::string::npos)
        domain.erase(pos);
 
    pos = domain.find('@');
    if (pos != std::string::npos)
        domain = domain.substr(pos + 1);
 
    pos = domain.find(':');
    if (pos != std::string::npos)
        domain.erase(pos);
 
    if (domain.rfind("www.", 0) == 0)
        domain.erase(0, 4);
 
    std::transform(domain.begin(), domain.end(), domain.begin(),
                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
 
    if (!domain.empty() && domain.front() == '.')
        domain.erase(domain.begin());
 
    while (!domain.empty() && domain.back() == '.')
        domain.pop_back();
 
    domain = trim_copy(domain);
 
    if (domain.empty()) return {};
    if (domain.find('.') == std::string::npos) return {};
 
    return domain;
}
 
static std::string iso_today_yyyy_mm_dd() {
    auto now = Glib::DateTime::create_now_local();
    return now.format("%Y-%m-%d");
}
 
static void restart_cef_service_user() {
    int rc = (bg_process::run({"/usr/libexec/bastionguard/bastionguard-service", "--user", "restart", "BastionGuard-cef.service"}).exit_code);
    if (rc == 0)
        std::cout << _("[BankPage] ✔ BastionGuard-cef.service riavviato\n");
    else
        std::cerr << _("[BankPage] ⚠ Impossibile riavviare BastionGuard-cef.service\n");
}
 
} // namespace
 
BankPage::~BankPage()
{
    if (alive_) alive_->store(false, std::memory_order_release);
    if (auto_update_conn_.connected()) auto_update_conn_.disconnect();
}
 
 
BankPage::BankPage()
    : Gtk::Box(Gtk::Orientation::VERTICAL, 12)
{
    set_margin(16);
    set_vexpand(true);
 
    auto title_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    title_box->add_css_class("secure-headerbar");
    title_box->set_margin_bottom(8);
 
    auto spacer_left = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer_left->set_hexpand(true);
 
    auto title_label = Gtk::make_managed<Gtk::Label>(_("🏦 Zona Sicura – Banche"));
    title_label->set_margin(8);
    title_label->set_halign(Gtk::Align::CENTER);
    title_label->add_css_class("secure-header-title");
 
    auto spacer_right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer_right->set_hexpand(true);
 
    title_box->append(*spacer_left);
    title_box->append(*title_label);
    title_box->append(*spacer_right);
 
    append(*title_box);
 
    entry_url_.set_placeholder_text(_("URL sorgente (es. MISP bank-website/list.json)"));
    entry_url_.set_text("https://raw.githubusercontent.com/MISP/misp-warninglists/main/lists/bank-website/list.json");
    entry_url_.set_margin_bottom(6);
    append(entry_url_);
 
    btn_refresh_.set_label(_("🔄 Aggiorna lista"));
    btn_refresh_.set_margin_bottom(12);
    append(btn_refresh_);
 
    auto toggle_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
    auto_update_switch_.set_active(false);
    auto_update_label_.set_text(_("Aggiornamento automatico ogni 6 ore"));
    toggle_box->append(auto_update_switch_);
    toggle_box->append(auto_update_label_);
    toggle_box->set_margin_bottom(12);
    append(*toggle_box);
 
    auto whitelist_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
    whitelist_entry_.set_placeholder_text(_("Aggiungi dominio alla whitelist..."));
    whitelist_entry_.set_hexpand(true);
    btn_add_whitelist_.set_label(_("➕ Aggiungi"));
    whitelist_box->append(whitelist_entry_);
    whitelist_box->append(btn_add_whitelist_);
    append(*whitelist_box);
 
    // -------------------------------------------------------------------------
    //  Apertura banca dentro sandbox sicura (BastionGuard-secure + bubblewrap).
    //  L'URL viene passato a /usr/bin/BastionGuard-secure-cli, che a sua volta
    //  si re-exec dentro bwrap (Wayland o X11) prima di aprire CEF.
    // -------------------------------------------------------------------------
    auto open_bank_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
    open_bank_entry_.set_placeholder_text(_("Apri URL banca (es. https://www.intesasanpaolo.com)..."));
    open_bank_entry_.set_hexpand(true);
    btn_open_bank_.set_label(_("🔐 Apri in sandbox sicura"));
    open_bank_box->append(open_bank_entry_);
    open_bank_box->append(btn_open_bank_);
    open_bank_box->set_margin_top(4);
    open_bank_box->set_margin_bottom(8);
    append(*open_bank_box);
 
    scroller_banks_.set_vexpand(true);
    scroller_banks_.set_hexpand(true);
    txt_banks_.set_editable(false);
    txt_banks_.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
    scroller_banks_.set_child(txt_banks_);
    append(scroller_banks_);
 
    scroller_white_.set_vexpand(true);
    scroller_white_.set_hexpand(true);
    txt_whitelist_.set_editable(false);
    txt_whitelist_.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
    scroller_white_.set_child(txt_whitelist_);
    append(scroller_white_);
 
    lbl_status_.set_margin_top(8);
    append(lbl_status_);
 
    load_settings();
    load_whitelist();
    merge_whitelist_into_banks_json();
    populate_bank_list();
 
    btn_refresh_.signal_clicked().connect(sigc::mem_fun(*this, &BankPage::on_refresh_clicked));
    btn_add_whitelist_.signal_clicked().connect(sigc::mem_fun(*this, &BankPage::on_add_whitelist_clicked));
    btn_open_bank_.signal_clicked().connect(sigc::mem_fun(*this, &BankPage::on_open_bank_clicked));
    open_bank_entry_.signal_activate().connect(sigc::mem_fun(*this, &BankPage::on_open_bank_clicked));
 
    auto_update_switch_.property_active().signal_changed().connect([this]() {
        auto_update_enabled_ = auto_update_switch_.get_active();
        save_settings();
 
        if (auto_update_enabled_) {
            start_auto_update_timer();
            lbl_status_.set_text(_("🔁 Aggiornamento automatico abilitato."));
        } else {
            stop_auto_update_timer();
            lbl_status_.set_text(_("⏸️ Aggiornamento automatico disattivato."));
        }
    });
 
    if (auto_update_enabled_) {
        auto_update_switch_.set_active(true);
        start_auto_update_timer();
        lbl_status_.set_text(_("🔁 Aggiornamento automatico attivo."));
    }
}
 
void BankPage::on_refresh_clicked() {
    lbl_status_.set_text(_("⬇️ Download in corso..."));
    btn_refresh_.set_sensitive(false);
 
    std::string url = entry_url_.get_text();
 
    std::thread([this, alive = alive_, url]() {
        bool ok = Backend::instance().updateBankListFromURL(url);
        if (!alive->load()) return;
 
        Glib::signal_idle().connect_once([this, alive, ok, url]() {
            BastionGuard::if_alive(alive, [this, ok, &url]() {
                if (ok) {
                    load_whitelist();
 
                    if (merge_whitelist_into_banks_json()) {
                        copy_banklist_to_system(url);
                        populate_bank_list();
                        lbl_status_.set_text(_("✅ Lista aggiornata da MISP, whitelist integrata e servizio CEF riavviato."));
                    } else {
                        lbl_status_.set_text(_("⚠ Lista aggiornata da MISP, ma merge whitelist fallito."));
                    }
                } else {
                    lbl_status_.set_text(_("❌ Errore nel download della lista."));
                }
                btn_refresh_.set_sensitive(true);
            });
        });
    }).detach();
}
 
void BankPage::copy_banklist_to_system(const std::string& source_url) {
    const std::string helper = "/usr/bin/bank-helper";
    const std::string userPath = Glib::get_home_dir() + "/.local/share/BastionGuard/banks.json";
 
    // NON usiamo std::system() con il URL interpolato: sarebbe shell injection
    // (caratteri come ; | $() ` newline scappano dal quoting).
    // Invochiamo sudo + helper direttamente con execvp: ogni argomento è
    // un elemento separato di argv, non c'è shell che lo interpreta.
    const pid_t pid = ::fork();
    if (pid < 0) {
        std::cerr << _("[BankPage] ⚠️ fork fallita per bank-helper") << std::endl;
        return;
    }
 
    if (pid == 0) {
        // child: redirige stdout/stderr su /dev/null (equivalente a >/dev/null 2>&1)
        int devnull = ::open("/dev/null", O_WRONLY);
        if (devnull >= 0) {
            ::dup2(devnull, STDOUT_FILENO);
            ::dup2(devnull, STDERR_FILENO);
            ::close(devnull);
        }
 
        // argv: sudo, helper, userPath, source_url
        // Nota: source_url viene passato come singolo argomento di argv,
        // quindi contenuti come "; rm -rf /" restano una stringa letterale.
        const char* argv[] = {
            "sudo",
            helper.c_str(),
            userPath.c_str(),
            source_url.c_str(),
            nullptr
        };
        ::execvp("sudo", const_cast<char* const*>(argv));
        _exit(127); // execvp fallito
    }
 
    // parent: aspetta il child
    int status = 0;
    if (::waitpid(pid, &status, 0) < 0) {
        std::cerr << _("[BankPage] ⚠️ waitpid fallita per bank-helper") << std::endl;
        return;
    }
 
    const int rc = WIFEXITED(status) ? WEXITSTATUS(status)
                                     : (WIFSIGNALED(status) ? 128 + WTERMSIG(status) : -1);
    if (rc == 0) {
        std::cout << _("[BankPage] ✅ Lista copiata in /usr/share/BastionGuard/data/bank/banks.json\n");
    } else {
        std::cerr << _("[BankPage] ⚠️ bank-helper fallito (rc=") << rc
                  << _("). Verificare /etc/sudoers.d/bastionguard-bank e i permessi di bank-helper.\n");
    }
}
 
void BankPage::populate_bank_list() {
    std::string path = Glib::get_home_dir() + "/.local/share/BastionGuard/banks.json";
 
    if (!fs::exists(path)) {
        txt_banks_.get_buffer()->set_text(_("⚠ Nessuna lista trovata.\n"));
        return;
    }
 
    std::ifstream f(path);
    json j;
    try {
        f >> j;
    } catch (...) {
        txt_banks_.get_buffer()->set_text(_("❌ Errore parsing JSON.\n"));
        return;
    }
 
    std::ostringstream oss_banks;
    oss_banks << _("🌍 Elenco banche conosciute:\n\n");
 
    std::vector<std::string> domains;
    if (j.contains("list") && j["list"].is_array()) {
        for (auto& item : j["list"]) {
            if (item.is_string()) {
                domains.push_back(item.get<std::string>());
            } else if (item.is_object() && item.contains("value") && item["value"].is_string()) {
                domains.push_back(item["value"].get<std::string>());
            }
        }
    }
 
    std::sort(domains.begin(), domains.end());
    domains.erase(std::unique(domains.begin(), domains.end()), domains.end());
 
    int count = 0;
    for (auto& domain : domains) {
        std::string clean = normalize_domain(domain);
        if (clean.empty()) continue;
 
        if (std::find(whitelist_.begin(), whitelist_.end(), clean) == whitelist_.end()) {
            oss_banks << " - " << clean << "\n";
            count++;
        }
    }
 
    oss_banks << _("\nTotale banche: ") << count << "\n";
    txt_banks_.get_buffer()->set_text(oss_banks.str());
 
    std::ostringstream oss_white;
    oss_white << _("🛡️ Nuovi domini bancari:\n\n");
    for (auto& w : whitelist_)
        oss_white << " + " << w << "\n";
 
    if (whitelist_.empty())
        oss_white << _("(Nessun dominio whitelistato)\n");
 
    txt_whitelist_.get_buffer()->set_text(oss_white.str());
}
 
void BankPage::on_add_whitelist_clicked() {
    std::string domain = normalize_domain(whitelist_entry_.get_text());
 
    if (domain.empty()) {
        lbl_status_.set_text(_("⚠ Inserisci un dominio valido."));
        return;
    }
 
    if (std::find(whitelist_.begin(), whitelist_.end(), domain) == whitelist_.end()) {
        whitelist_.push_back(domain);
        std::sort(whitelist_.begin(), whitelist_.end());
        whitelist_.erase(std::unique(whitelist_.begin(), whitelist_.end()), whitelist_.end());
 
        save_whitelist();
 
        if (merge_whitelist_into_banks_json())
            lbl_status_.set_text(_("✅ Dominio aggiunto alla whitelist, integrato in banks.json e servizio CEF riavviato."));
        else
            lbl_status_.set_text(_("⚠ Dominio salvato in whitelist, ma merge su banks.json fallito."));
 
        populate_bank_list();
    } else {
        lbl_status_.set_text(_("ℹ️ Dominio già presente nella whitelist."));
    }
 
    whitelist_entry_.set_text("");
}
 
void BankPage::load_whitelist() {
    whitelist_.clear();
 
    std::string path = Glib::get_home_dir() + "/.config/BastionGuard/whitelist.json";
    if (!fs::exists(path))
        return;
 
    std::ifstream f(path);
    if (!f.is_open())
        return;
 
    json j;
    try {
        f >> j;
    } catch (...) {
        return;
    }
 
    if (j.contains("list") && j["list"].is_array()) {
        for (const auto& w : j["list"]) {
            if (!w.is_string()) continue;
 
            std::string d = normalize_domain(w.get<std::string>());
            if (!d.empty())
                whitelist_.push_back(d);
        }
    }
 
    std::sort(whitelist_.begin(), whitelist_.end());
    whitelist_.erase(std::unique(whitelist_.begin(), whitelist_.end()), whitelist_.end());
}
 
void BankPage::save_whitelist() {
    std::string dir = Glib::get_home_dir() + "/.config/BastionGuard";
    fs::create_directories(dir);
 
    std::vector<std::string> clean = whitelist_;
    for (auto& d : clean)
        d = normalize_domain(d);
 
    clean.erase(std::remove_if(clean.begin(), clean.end(),
                               [](const std::string& s) { return s.empty(); }),
                clean.end());
 
    std::sort(clean.begin(), clean.end());
    clean.erase(std::unique(clean.begin(), clean.end()), clean.end());
 
    json j;
    j["version"] = 1;
    j["updated_at"] = iso_today_yyyy_mm_dd();
    j["enabled"] = true;
    j["list"] = json::array();
 
    for (const auto& d : clean)
        j["list"].push_back(d);
 
    std::ofstream f(dir + "/whitelist.json", std::ios::trunc);
    if (!f.is_open())
        return;
 
    f << j.dump(2);
}
 
bool BankPage::merge_whitelist_into_banks_json() {
    const std::string path = Glib::get_home_dir() + "/.local/share/BastionGuard/banks.json";
 
    json j;
 
    if (fs::exists(path)) {
        try {
            std::ifstream in(path);
            if (in.is_open())
                in >> j;
        } catch (...) {
            j = json::object();
        }
    }
 
    if (!j.is_object())
        j = json::object();
 
    if (!j.contains("list") || !j["list"].is_array())
        j["list"] = json::array();
 
    std::unordered_set<std::string> existing;
    bool changed = false;
 
    for (const auto& item : j["list"]) {
        if (item.is_string()) {
            std::string d = normalize_domain(item.get<std::string>());
            if (!d.empty())
                existing.insert(d);
        } else if (item.is_object() && item.contains("value") && item["value"].is_string()) {
            std::string d = normalize_domain(item["value"].get<std::string>());
            if (!d.empty())
                existing.insert(d);
        }
    }
 
    for (const auto& w : whitelist_) {
        std::string d = normalize_domain(w);
        if (d.empty()) continue;
 
        if (!existing.count(d)) {
            j["list"].push_back("." + d);
            existing.insert(d);
            changed = true;
        }
    }
 
    if (!changed) {
        std::cout << _("[BankPage] ℹ Nessun merge necessario in banks.json\n");
        return true;
    }
 
    const std::string tmp = path + ".tmp";
    try {
        std::ofstream out(tmp, std::ios::trunc);
        if (!out.is_open())
            return false;
 
        out << j.dump(2);
        out.flush();
        out.close();
 
        std::error_code ec;
        fs::rename(tmp, path, ec);
        if (ec) {
            fs::remove(path, ec);
            ec.clear();
            fs::rename(tmp, path, ec);
            if (ec) {
                fs::remove(tmp, ec);
                return false;
            }
        }
 
        std::cout << _("[BankPage] ✔ whitelist integrata in banks.json\n");
        restart_cef_service_user();
        return true;
 
    } catch (...) {
        try { fs::remove(tmp); } catch (...) {}
        return false;
    }
}
 
void BankPage::start_auto_update_timer() {
    if (auto_update_conn_)
        auto_update_conn_.disconnect();
 
    auto_update_conn_ = Glib::signal_timeout().connect_seconds(
        sigc::mem_fun(*this, &BankPage::auto_update_bank_list),
        6 * 60 * 60
    );
 
    std::cout << _("[BankPage] ⏱️ Auto-update attivo ogni 6 ore.") << std::endl;
}
 
void BankPage::stop_auto_update_timer() {
    if (auto_update_conn_)
        auto_update_conn_.disconnect();
 
    std::cout << _("[BankPage] ⏹️ Auto-update disattivato.") << std::endl;
}
 
bool BankPage::auto_update_bank_list() {
    std::string url = entry_url_.get_text();
 
    std::thread([this, alive = alive_, url]() {
        std::cout << _("[BankPage] ⏰ Aggiornamento automatico lista banche...") << std::endl;
        bool ok = Backend::instance().updateBankListFromURL(url);
        if (!alive->load()) return;
 
        Glib::signal_idle().connect_once([this, alive, ok, url]() {
            BastionGuard::if_alive(alive, [this, ok, &url]() {
                if (ok) {
                    load_whitelist();
 
                    if (merge_whitelist_into_banks_json()) {
                        copy_banklist_to_system(url);
                        populate_bank_list();
 
                        auto now = Glib::DateTime::create_now_local();
                        lbl_status_.set_text(_("✅ Lista aggiornata automaticamente il: ") + now.format("%Y-%m-%d %H:%M:%S"));
                    } else {
                        lbl_status_.set_text(_("⚠️ Lista aggiornata, ma merge whitelist fallito."));
                    }
                } else {
                    lbl_status_.set_text(_("⚠️ Errore nell'aggiornamento automatico."));
                }
            });
        });
    }).detach();
 
    return true;
}
 
void BankPage::load_settings() {
    std::string path = Glib::get_home_dir() + "/.config/BastionGuard/settings.json";
    if (!fs::exists(path))
        return;
 
    std::ifstream f(path);
    if (!f.is_open())
        return;
 
    json j;
    try {
        f >> j;
    } catch (...) {
        return;
    }
 
    if (j.contains("auto_update"))
        auto_update_enabled_ = j["auto_update"].get<bool>();
 
    auto_update_switch_.set_active(auto_update_enabled_);
}
 
void BankPage::save_settings() {
    std::string dir = Glib::get_home_dir() + "/.config/BastionGuard";
    fs::create_directories(dir);
 
    std::ofstream f(dir + "/settings.json", std::ios::trunc);
    json j;
    j["auto_update"] = auto_update_enabled_;
    f << j.dump(2);
}
 
// =============================================================================
//  Apertura banca in sandbox sicura.
//
//  Il bottone "🔐 Apri in sandbox sicura" passa l'URL al binario
//  BastionGuard-secure-cli, che:
//    1) si re-exec dentro bubblewrap (con DNS custom + bind X11/Wayland);
//    2) avvia CEF con OZONE_PLATFORM corretto (Wayland o X11);
//    3) fa il match contro payments.json/banks.json e apre la pagina.
//
//  Vantaggio: anche le banche nuove (whitelist utente) vengono aperte in
//  un processo isolato dal browser di sistema, senza dover passare dal
//  proxy CEF (BastionGuard-cef.service).
// =============================================================================
void BankPage::on_open_bank_clicked() {
    std::string raw = trim_copy(open_bank_entry_.get_text());
    if (raw.empty()) {
        lbl_status_.set_text(_("⚠ Inserisci un URL o un dominio bancario."));
        return;
    }
 
    // Se l'utente ha messo solo il dominio, completiamo con https://
    if (raw.find("://") == std::string::npos)
        raw = "https://" + raw;
 
    if (open_bank_in_sandbox(raw)) {
        lbl_status_.set_text(_("🔐 Apertura sandbox sicura in corso: ") + raw);
    } else {
        lbl_status_.set_text(_("❌ Apertura sandbox fallita. Vedi log."));
    }
}
 
bool BankPage::open_bank_in_sandbox(const std::string& url) {
    if (url.empty()) return false;
 
    // Validazione minima: blocca caratteri pericolosi anche se passiamo
    // l'URL come argv separato (non c'è shell-injection, ma evitiamo
    // comunque newline e null bytes che confonderebbero il helper).
    for (char c : url) {
        if (c == '\n' || c == '\r' || c == '\0') {
            std::cerr << _("[BankPage] URL contiene caratteri non validi.") << std::endl;
            return false;
        }
    }
 
    // Cerchiamo il binario in path standard. Lo script di sandbox è
    // BastionGuard-secure-cli; se non c'è, ripieghiamo su BastionGuard-secure
    // (la versione GUI), che fa anch'essa re-exec dentro bwrap.
    static const char* candidates[] = {
        "/usr/bin/BastionGuard-secure-cli",
        "/usr/local/bin/BastionGuard-secure-cli",
        "/usr/bin/BastionGuard-secure",
        "/usr/local/bin/BastionGuard-secure",
        nullptr
    };
 
    const char* bin = nullptr;
    for (int i = 0; candidates[i]; ++i) {
        if (::access(candidates[i], X_OK) == 0) {
            bin = candidates[i];
            break;
        }
    }
    if (!bin) {
        std::cerr << _("[BankPage] BastionGuard-secure-cli non trovato; "
                       "installa il pacchetto BastionGuard completo.") << std::endl;
        return false;
    }
 
    std::cout << _("[BankPage] 🔐 Avvio sandbox sicura via ") << bin
              << _(" per URL: ") << url << std::endl;
 
    const pid_t pid = ::fork();
    if (pid < 0) {
        std::cerr << _("[BankPage] fork() fallita per BastionGuard-secure-cli")
                  << std::endl;
        return false;
    }
 
    if (pid == 0) {
        // Child: detach completo dalla GUI principale.
        // setsid() così la chiusura della GUI di BastionGuard non killa la sandbox.
        ::setsid();
 
        // Redirige stdout/stderr per non sporcare la console di BastionGuard.
        // (I log finiscono comunque nei journald del servizio se è registrato.)
        int devnull = ::open("/dev/null", O_WRONLY);
        if (devnull >= 0) {
            ::dup2(devnull, STDOUT_FILENO);
            ::dup2(devnull, STDERR_FILENO);
            ::close(devnull);
        }
 
        const char* argv[] = { bin, url.c_str(), nullptr };
        ::execvp(bin, const_cast<char* const*>(argv));
        _exit(127);
    }
 
    // Parent: non aspettiamo (è un processo a vita lunga, il browser).
    // setsid + non waitpid = detached: corretto per "spawn and forget".
    return true;
}