BastionGuard-ransomware-alert.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 "Resource.hpp"
#include "Backend.hpp"
#include "Quarantine.hpp"
#include <gtkmm.h>
#include <giomm.h>
#include <glibmm/i18n.h>
 
#include <iostream>
#include <queue>
#include <filesystem>
#include <fstream>
#include <clocale>
#ifndef LOCALEDIR
#error "LOCALEDIR non definita per questo target"
#endif
 
 
 
static std::string resolve_theme_css() {
    const std::string conf =
        Glib::get_home_dir() + "/.config/BastionGuard/theme.conf";
    std::ifstream tf(conf);
    std::string theme;
    if (tf >> theme && theme == "dark")
        return "BastionGuard-dark.css";
    return "BastionGuard.css";
}
namespace fs = std::filesystem;
 
class AlertWindow : public Gtk::Window {
public:
    AlertWindow(const std::string& file,
                const std::string& family,
                size_t pending = 0)
    : filePath(file),
    vbox(Gtk::Orientation::VERTICAL, 15),
    titleLabel(_("⚠️ Attenzione: BastionGuard ha rilevato un'infezione")),
    messageLabel(_("Famiglia: ") + family + "\n" + _("File: ") + file),
    quarantineButton(_("Metti in quarantena")),
    ignoreButton(_("Ignora")),
    ignoreAllButton(_("Ignora tutti"))
    {
        set_title("");
        set_default_size(620, 240);
        set_resizable(false);
        set_modal(true);
 
        auto ctx = get_style_context();
        ctx->add_class("app-dialog");
        ctx->add_class("main-window");
        ctx->add_class("app-window");
 
        // CSS
        try {
            auto css = Gtk::CssProvider::create();
            css->load_from_path(resource(resolve_theme_css()));
            Gtk::StyleContext::add_provider_for_display(
                Gdk::Display::get_default(),
                                                        css,
                                                        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
            );
        } catch (...) {}
        auto header = Gtk::make_managed<Gtk::HeaderBar>();
        header->set_show_title_buttons(false);
        header->set_decoration_layout("");
        header->add_css_class("custom-headerbar");
 
        auto close_btn = Gtk::make_managed<Gtk::Button>();
        try {
            auto px = Gdk::Pixbuf::create_from_file(
                resource("icon-close.png"), 28, 28, true
            );
            close_btn->set_child(*Gtk::make_managed<Gtk::Image>(px));
        } catch (...) {}
 
        close_btn->add_css_class("header-button");
        close_btn->signal_clicked().connect([this]() {
            close();
        });
 
        header->pack_end(*close_btn);
        set_titlebar(*header);
        titleLabel.set_halign(Gtk::Align::CENTER);
        titleLabel.get_style_context()->add_class("title");
 
        std::string iconPath =
        (family == "OK" || family == "Clean" || family == "None")
        ? "/usr/share/BastionGuard/data/icons/true.png"
        : "/usr/share/BastionGuard/data/icons/false.png";
 
        auto icon = Gtk::make_managed<Gtk::Picture>();
        icon->set_halign(Gtk::Align::CENTER);
 
        if (fs::exists(iconPath)) {
            try {
                auto pb = Gdk::Pixbuf::create_from_file(iconPath);
                auto scaled = pb->scale_simple(68, 68, Gdk::InterpType::BILINEAR);
                icon->set_paintable(Gdk::Texture::create_for_pixbuf(scaled));
            } catch (...) {}
        }
 
        messageLabel.set_wrap(true);
        messageLabel.set_justify(Gtk::Justification::CENTER);
        messageLabel.set_halign(Gtk::Align::CENTER);
 
        if (pending > 0) {
            pendingLabel.set_text(
                Glib::ustring::compose(_("🕒 %1 altri in attesa..."), pending)
            );
            pendingLabel.set_halign(Gtk::Align::CENTER);
        }
 
        quarantineButton.add_css_class("btn-danger");
        ignoreButton.add_css_class("btn-success");
        ignoreAllButton.add_css_class("btn-warning");
 
        auto buttons = Gtk::make_managed<Gtk::Box>(
            Gtk::Orientation::HORIZONTAL, 20
        );
        buttons->set_halign(Gtk::Align::CENTER);
        buttons->append(quarantineButton);
        buttons->append(ignoreButton);
        buttons->append(ignoreAllButton);
 
        set_child(vbox);
        vbox.set_margin(25);
        vbox.set_halign(Gtk::Align::CENTER);
        vbox.append(titleLabel);
        vbox.append(*icon);
        vbox.append(messageLabel);
        if (pending > 0) vbox.append(pendingLabel);
        vbox.append(*buttons);
 
        quarantineButton.signal_clicked().connect([this]() {
            move_to_quarantine();
            close();
        });
 
        ignoreButton.signal_clicked().connect([this]() {
            close();
        });
 
        ignoreAllButton.signal_clicked().connect([this]() {
            signal_ignore_all.emit();
            close();
        });
    }
 
    sigc::signal<void()> signal_ignore_all;
 
private:
    std::string filePath;
 
    Gtk::Box vbox;
    Gtk::Label titleLabel;
    Gtk::Label messageLabel;
    Gtk::Label pendingLabel;
 
    Gtk::Button quarantineButton;
    Gtk::Button ignoreButton;
    Gtk::Button ignoreAllButton;
 
    void move_to_quarantine() {
        if (Quarantine::move(filePath))
            std::cout << _("[✔] File in quarantena: ") << filePath << "\n";
        else
            std::cerr << _("❌ Errore quarantena: ") << filePath << "\n";
    }
};
 
const char introspection_xml[] =
"<node>"
"  <interface name='org.BastionGuard.Ransomware.Alert'>"
"    <method name='ShowAlert'>"
"      <arg type='s' direction='in'/>"
"      <arg type='s' direction='in'/>"
"    </method>"
"  </interface>"
"</node>";
 
class AlertApp {
public:
    AlertApp()
    : app(Gtk::Application::create(
        "org.BastionGuard.ransomware.alert"))
    {
        app->hold();
    }
 
    int run(int argc, char* argv[]) {
        auto connection = Gio::DBus::Connection::get_sync(
            Gio::DBus::BusType::SESSION
        );
 
        auto node_info =
        Gio::DBus::NodeInfo::create_for_xml(introspection_xml);
        auto iface_info =
        node_info->lookup_interface(
            "org.BastionGuard.Ransomware.Alert");
 
        Gio::DBus::InterfaceVTable vtable(
            sigc::mem_fun(*this, &AlertApp::on_method_call)
        );
 
        connection->register_object(
            "/org/BastionGuard/ransomware/alert",
            iface_info,
            vtable
        );
        auto msg = Glib::VariantContainerBase::create_tuple({
            Glib::Variant<Glib::ustring>::create(
                "org.BastionGuard.Ransomware.Alert"),
                Glib::Variant<guint32>::create(0)
        });
 
        connection->call_sync(
            "/org/freedesktop/DBus",
            "org.freedesktop.DBus",
            "RequestName",
            msg,
            "org.freedesktop.DBus"
        );
 
        return app->run(argc, argv);
    }
 
private:
    Glib::RefPtr<Gtk::Application> app;
    std::queue<std::pair<std::string, std::string>> queue;
    AlertWindow* current_window = nullptr;
 
    void on_method_call(
        const Glib::RefPtr<Gio::DBus::Connection>&,
        const Glib::ustring&,
        const Glib::ustring&,
        const Glib::ustring&,
        const Glib::ustring& method,
        const Glib::VariantContainerBase& params,
        const Glib::RefPtr<Gio::DBus::MethodInvocation>& inv)
    {
        if (method == "ShowAlert") {
            Glib::Variant<Glib::ustring> file, family;
            params.get_child(file, 0);
            params.get_child(family, 1);
 
            queue.push({file.get(), family.get()});
            inv->return_value({});
 
            if (!current_window)
                show_next();
        }
    }
 
    void show_next() {
        if (current_window || queue.empty())
            return;
 
        auto [file, family] = queue.front();
        queue.pop();
 
        current_window = new AlertWindow(
            file, family, queue.size());
 
        app->add_window(*current_window);
 
        current_window->signal_ignore_all.connect([this]() {
            std::queue<std::pair<std::string, std::string>> empty;
            std::swap(queue, empty);
        });
 
        current_window->signal_close_request().connect(
            [this]() -> bool {
                current_window = nullptr;
                show_next();
                return false;
            },
            false
        );
 
        current_window->present();
    }
};
 
 
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);
 
        // trim minimo (spazi attorno)
        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";
    }
    AlertApp app;
    return app.run(argc, argv);
}