BastionGuard-secure-main.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 <gtkmm.h>
#include <giomm.h>
#include <glib/gi18n.h>
 
#include <csignal>
#include <iostream>
#include <memory>
#include <unistd.h>
 
#include <fstream>
#include <filesystem>
#include <nlohmann/json.hpp>
 
#include <glibmm.h>
#include <clocale>
#include <cstring>
#include "StyleProvider.hpp"
#include "Resource.hpp"
#include "dns_secure.hpp"
#ifndef LOCALEDIR
#error "LOCALEDIR non definita per questo target"
#endif
 
namespace fs = std::filesystem;
using json = nlohmann::json;
 
class SecureGuiWindow : public Gtk::Window {
public:
    SecureGuiWindow() {
        set_title("");
        set_resizable(false);
        set_default_size(640, 300);
        build_headerbar();
 
        auto main_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
        set_child(*main_box);
 
        auto sidebar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
        sidebar->set_size_request(240, -1);
        sidebar->get_style_context()->add_class("sidebar");
 
        {
            auto header = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
            header->get_style_context()->add_class("sidebar-header");
 
            try {
                auto pixbuf = Gdk::Pixbuf::create_from_file(resource("logo-sidebar.png"), 96, 96, true);
                auto logo = Gtk::make_managed<Gtk::Image>(pixbuf);
                header->append(*logo);
            } catch (...) {
                std::cerr << _("⚠ Impossibile caricare data/logo-sidebar.png") << "\n";
            }
 
            auto lbl = Gtk::make_managed<Gtk::Label>("BastionGuard");
            lbl->set_halign(Gtk::Align::START);
            lbl->get_style_context()->add_class("sidebar-title");
            header->append(*lbl);
 
            sidebar->append(*header);
        }
 
        auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
        spacer->set_vexpand(true);
        sidebar->append(*spacer);
 
        main_box->append(*sidebar);
        auto content_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
        content_box->set_margin(24);
        content_box->set_hexpand(true);
        content_box->get_style_context()->add_class("content");
        main_box->append(*content_box);
 
        auto label = Gtk::make_managed<Gtk::Label>(
            _("Seleziona un sito sicuro per i pagamenti/e-commerce:")
        );
        label->set_wrap(true);
        label->set_halign(Gtk::Align::START);
        content_box->append(*label);
 
        domains_ = load_domains_from_config();
        if (domains_.empty())
            domains_.push_back("paypal.com");
 
        auto string_list = Gtk::StringList::create(domains_);
        dropdown_.set_model(string_list);
        dropdown_.set_selected(0);
        content_box->append(dropdown_);
 
        auto hint = Gtk::make_managed<Gtk::Label>(
            _("La lista proviene da ~/.config/BastionGuard/payments.json (chiave: \"list\").")
        );
        hint->set_halign(Gtk::Align::START);
        hint->get_style_context()->add_class("hint");
        content_box->append(*hint);
 
        auto buttons = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
        buttons->set_halign(Gtk::Align::END);
 
        btn_cancel_.set_label(_("Annulla"));
        btn_cancel_.signal_clicked().connect(sigc::mem_fun(*this, &SecureGuiWindow::on_cancel_clicked));
        buttons->append(btn_cancel_);
 
        btn_open_.set_label(_("Apri in Secure Browser"));
        btn_open_.signal_clicked().connect(sigc::mem_fun(*this, &SecureGuiWindow::on_open_clicked));
        buttons->append(btn_open_);
 
        content_box->append(*buttons);
    }
 
protected:
    bool on_close_request() override {
        terminate_sandbox();
        return false;
    }
 
private:
    Gtk::DropDown dropdown_;
    std::vector<Glib::ustring> domains_;
 
    Gtk::Button btn_open_;
    Gtk::Button btn_cancel_;
    Glib::RefPtr<Gio::Subprocess> sandbox_proc_;
 
    void build_headerbar() {
        auto header = Gtk::make_managed<Gtk::HeaderBar>();
        header->set_show_title_buttons(false);
        header->set_decoration_layout("");
        header->get_style_context()->add_class("custom-headerbar");
 
        auto title_label = Gtk::make_managed<Gtk::Label>("BastionGuard Secure Browser");
        title_label->get_style_context()->add_class("header-title");
        title_label->set_halign(Gtk::Align::CENTER);
        title_label->set_valign(Gtk::Align::CENTER);
        header->set_title_widget(*title_label);
 
        auto header_right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
        header_right->get_style_context()->add_class("header-right");
 
        try {
            auto pix_min = Gdk::Pixbuf::create_from_file(resource("icon-minimize.png"), 32, 32, true);
            auto btn_min = Gtk::make_managed<Gtk::Button>();
            btn_min->set_child(*Gtk::make_managed<Gtk::Image>(pix_min));
            btn_min->get_style_context()->add_class("header-button");
            header_right->append(*btn_min);
            btn_min->signal_clicked().connect([this]() { minimize(); });
        } catch (...) {
            std::cerr << _("⚠ Errore caricamento icona minimize") << "\n";
        }
 
        try {
            auto pix_close = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 32, 32, true);
            auto btn_close = Gtk::make_managed<Gtk::Button>();
            btn_close->set_child(*Gtk::make_managed<Gtk::Image>(pix_close));
            btn_close->get_style_context()->add_class("header-button");
            header_right->append(*btn_close);
            btn_close->signal_clicked().connect([this]() {
                terminate_sandbox();
                this->hide();
            });
        } catch (...) {
            std::cerr << _("⚠ Errore caricamento icona close") << "\n";
        }
 
        header->pack_end(*header_right);
        set_titlebar(*header);
    }
 
    void minimize() {
#if GTKMM_CHECK_VERSION(4,10,0)
        this->hide();
#endif
    }
 
    static std::string config_path_payments() {
        const auto base = Glib::get_user_config_dir();
        return base + "/BastionGuard/payments.json";
    }
 
    static std::vector<Glib::ustring> load_domains_from_config() {
        std::vector<Glib::ustring> out;
        const auto path = config_path_payments();
 
        if (!fs::exists(path)) {
            std::cerr << "⚠ Config non trovata: " << path << "\n";
            return out;
        }
 
        std::ifstream f(path, std::ios::binary);
        if (!f.is_open()) {
            std::cerr << "⚠ Impossibile aprire: " << path << "\n";
            return out;
        }
 
        json j;
        try {
            f >> j;
        } catch (const std::exception& e) {
            std::cerr << "⚠ Errore parsing JSON: " << e.what() << "\n";
            return out;
        }
 
        if (!j.is_object() || !j.contains("list") || !j["list"].is_array()) {
            std::cerr << "⚠ payments.json invalido: manca \"list\" (array).\n";
            return out;
        }
 
        for (const auto& v : j["list"]) {
            if (!v.is_string()) continue;
            const auto s = v.get<std::string>();
            if (!s.empty()) out.emplace_back(s);
        }
 
        return out;
    }
 
    void show_warning(const Glib::ustring& msg, const Glib::ustring& secondary = {}) {
        auto* dialog = new Gtk::MessageDialog(
            *this, msg, false, Gtk::MessageType::WARNING, Gtk::ButtonsType::OK, true);
        if (!secondary.empty()) dialog->set_secondary_text(secondary);
        dialog->set_modal(true);
        dialog->signal_response().connect([dialog](int){ dialog->hide(); delete dialog; });
        dialog->present();
    }
 
    void on_cancel_clicked() {
        terminate_sandbox();
        hide();
    }
 
    void on_open_clicked() {
        const auto idx = dropdown_.get_selected();
        if (idx < 0 || static_cast<size_t>(idx) >= domains_.size()) {
            show_warning(_("Seleziona un elemento valido."));
            return;
        }
 
        const auto domain = domains_[static_cast<size_t>(idx)];
        if (domain.empty()) {
            show_warning(_("Dominio non valido."));
            return;
        }
 
        const std::string url = "https://" + domain.raw();
 
        set_sensitive(false);
        try {
            sandbox_proc_ = Gio::Subprocess::create(
                {"BastionGuard-secure", url},
                Gio::Subprocess::Flags::NONE
            );
            sandbox_proc_->wait_check_async(
                sigc::mem_fun(*this, &SecureGuiWindow::on_sandbox_finished)
            );
        } catch (const Glib::Error& ex) {
            show_warning(_("Errore avvio subprocess."), ex.what());
            set_sensitive(true);
        }
    }
 
    void on_sandbox_finished(const Glib::RefPtr<Gio::AsyncResult>& ) {
        hide();
    }
 
    void terminate_sandbox() {
        if (!sandbox_proc_) return;
 
        try {
            sandbox_proc_->send_signal(SIGTERM);
        } catch (...) {
            try { sandbox_proc_->force_exit(); } catch (...) {}
        }
    }
};
static bool load_lang_conf()
{
    const std::string lang_conf = Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    std::ifstream f(lang_conf);
    if (!f.is_open())
        return false;
 
    std::string line;
    bool any = false;
 
    while (std::getline(f, line)) {
        if (line.empty() || line[0] == '#')
            continue;
 
        auto pos = line.find('=');
        if (pos == std::string::npos)
            continue;
 
        std::string key = line.substr(0, pos);
        std::string val = line.substr(pos + 1);
 
        auto ltrim = [](std::string& s){
            s.erase(0, s.find_first_not_of(" \t\r\n"));
        };
        auto rtrim = [](std::string& s){
            s.erase(s.find_last_not_of(" \t\r\n") + 1);
        };
        ltrim(key); rtrim(key);
        ltrim(val); rtrim(val);
 
        if (!key.empty() && !val.empty()) {
            setenv(key.c_str(), val.c_str(), 1);
            any = true;
        }
    }
 
    return any;
}
int main(int argc, char* argv[]) {
    bool loaded = load_lang_conf();
 
    std::setlocale(LC_ALL, "");
    bindtextdomain("BastionGuard", LOCALEDIR);
    bind_textdomain_codeset("BastionGuard", "UTF-8");
    textdomain("BastionGuard");
 
    if (loaded) {
        std::cerr << _("[Lang] Config caricata da ~/.config/BastionGuard/lang.conf") << "\n";
    } else {
        std::cerr << _("[Lang] Nessuna config trovata, uso locale di sistema") << "\n";
    }
 
    // Isola anche la GUI dei pagamenti dentro bubblewrap (Wayland o X11).
    // Stesso meccanismo del CLI: il flag BASTIONGUARD_NO_BWRAP=1 disattiva.
    // Importante: niente bwrap se siamo già dentro (BASTIONGUARD_IN_BWRAP=1)
    // e niente bwrap se siamo root (Gtk e dbus user-session non lo gradiscono).
    {
        const char* no_bwrap = std::getenv("BASTIONGUARD_NO_BWRAP");
        const bool  bypass   = (no_bwrap && std::strcmp(no_bwrap, "1") == 0);
        if (!bypass && geteuid() != 0) {
            reexec_inside_bwrap_with_custom_dns(argc, argv);
            // Se siamo qui, bwrap non c'era oppure ha fallito: continuiamo
            // comunque ma loggiamo (la GUI deve sempre aprirsi).
        }
    }
 
    auto app = Gtk::Application::create("org.BastionGuard.secure.gui");
    load_style();
    return app->make_window_and_run<SecureGuiWindow>(argc, argv);
}