AboutPage.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 "AboutPage.hpp"
#include "DistroUtils.hpp"
#include <giomm/file.h>
#include <fstream>
#include <sstream>
#include <ctime>
#include <iostream>
#include <filesystem>
#include <glib/gi18n.h>
#include <glibmm/spawn.h>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <glibmm/spawn.h>
#include <glibmm/error.h>
#include <exception>
 
std::pair<std::string, std::string> AboutPage::load_version_build() {
    namespace fs = std::filesystem;
 
    std::string version = "?.?";
    std::string build   = "?";
 
    const std::string path = "/usr/share/BastionGuard/data/version.bs";
 
    if (!fs::exists(path))
        return {version, build};
 
    std::ifstream file(path);
    if (!file.is_open())
        return {version, build};
 
    std::string line;
    while (std::getline(file, line)) {
        line.erase(0, line.find_first_not_of(" \t"));
        line.erase(line.find_last_not_of(" \t") + 1);
 
        if (line.starts_with("version="))
            version = line.substr(8);
        else if (line.starts_with("build="))
            build = line.substr(6);
    }
 
    return {version, build};
}
 
 
 
AboutPage::AboutPage() : Gtk::Box(Gtk::Orientation::VERTICAL) {
    set_margin(12);
 
    // Notebook con i tab
    append(notebook_);
 
    // ===== Tab Programma =====
    auto box_program = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
 
    // Icona
    auto picture_icon = Gtk::make_managed<Gtk::Picture>();
    try {
        picture_icon->set_file(Gio::File::create_for_path(resource("logo.png")));
        picture_icon->set_size_request(64, 64);
    } catch (...) {
        // fallback se l’icona non esiste
    }
    picture_icon->set_halign(Gtk::Align::CENTER);
    box_program->append(*picture_icon);
 
    // Nome programma
    auto [version, build] = load_version_build();
 
    auto label_name = Gtk::make_managed<Gtk::Label>();
    label_name->set_use_markup(true);
    label_name->set_halign(Gtk::Align::CENTER);
 
    label_name->set_markup(
    Glib::ustring::compose(
        "<b>BastionGuard™ Endpoint</b> "
        "<span size='medium'><i>%1 · build %2</i></span>",
        version,
        build
        )
    );
 
 
    box_program->append(*label_name);
 
    // Copyright
    auto label_copy = Gtk::make_managed<Gtk::Label>();
    label_copy->set_use_markup(true);
    std::time_t t = std::time(nullptr);
    std::tm tm{};
    localtime_r(&t, &tm);
 
    int year = tm.tm_year + 1900;
    std::string year_str = std::to_string(year);
    label_copy->set_markup(
    Glib::ustring::compose(
            _("© 2025-%1 Calogero Scarnà — BastionGuard™\n"
            "BastionGuard è stato depositato il 16/12/2025 presso UIBM (Italia) con il numero 302025000196519.\n"
            "Il motore anti-ransomware e anti-phishing è parte integrante della piattaforma di sicurezza.\n"
            "Il sistema include la scansione delle periferiche USB,\n"
            "scansione delle cartelle samba\n"
            "e le funzionalità di blocco di microfono e webcam.\n"
            "La protezione comprende la scansione in tempo reale con inotify.\n"
            "ClamAV® è un marchio registrato da Cisco\n"
            "%2\n"),
            year_str,
            "<a href='https://www.codelinsoft.it' title='Visita CodeLinSoft'>"
            "Powered by <b>CodeLinSoft</b></a>"
        )
    );
 
 
    label_copy->set_halign(Gtk::Align::CENTER);
    label_copy->set_justify(Gtk::Justification::CENTER);
    label_copy->set_wrap(true);
    box_program->append(*label_copy);
 
 
    notebook_.append_page(*box_program, _("Programma"));
 
    // ===== Tab Terze Parti =====
    auto box_thirdparty = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
    Glib::ustring thirdparty_text =
        _("Questa applicazione utilizza:\n"
          "- ClamAV Antivirus Engine\n"
          "- GTK4 / gtkmm-4\n"
          "- Image / libpng\n"
          "- Rules / yara\n"
          "- Udev\n"
          "- Libudev\n"
          "- Nginx\n"
          "- php\n"
          "- Sigc++\n"
          "- Libsecret\n"
          "- IDN2\n"
          "- SQLITE3\n"
          "- HYPERSCAN\n"
          "- RE2\n"
          "- Polkit\n"
          "- Nlohmann_json\n"
          "- DNSmasq /blocco pagine\n"
          "- Antiphishing server/ libsoup\n");
    if (BastionGuard::Platform::cef_available()) {
        thirdparty_text += _("- Sandbox bancario/ chromium sandbox (CEF)\n");
    }
    thirdparty_text += _("- MISP lista per le banche\n");
 
    auto label_thirdparty = Gtk::make_managed<Gtk::Label>(thirdparty_text);
    label_thirdparty->set_wrap(true);
    box_thirdparty->append(*label_thirdparty);
    notebook_.append_page(*box_thirdparty, _("Terze Parti"));
 
    // ===== Tab Licenza =====
    auto box_license = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
 
    auto sw = Gtk::make_managed<Gtk::ScrolledWindow>();
    sw->set_expand(true);
    sw->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
 
    auto tv = Gtk::make_managed<Gtk::TextView>();
    tv->set_editable(false);
    tv->set_wrap_mode(Gtk::WrapMode::WORD);
 
    auto buf = Gtk::TextBuffer::create();
    buf->set_text(load_license_text());
    tv->set_buffer(buf);
 
    sw->set_child(*tv);
    box_license->append(*sw);
 
    notebook_.append_page(*box_license, _("Licenza"));
 
    // ===== Tab Database =====
    auto box_db = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
 
    auto swdb = Gtk::make_managed<Gtk::ScrolledWindow>();
    swdb->set_expand(true);
    swdb->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
 
    auto tvdb = Gtk::make_managed<Gtk::TextView>();
    tvdb->set_editable(false);
    tvdb->set_wrap_mode(Gtk::WrapMode::WORD);
 
    auto bufdb = Gtk::TextBuffer::create();
    bufdb->set_text(load_database_info());
    tvdb->set_buffer(bufdb);
 
    swdb->set_child(*tvdb);
    box_db->append(*swdb);
 
    notebook_.append_page(*box_db, _("Database"));
 
}
 
 
std::string AboutPage::load_license_text() {
    namespace fs = std::filesystem;
 
    std::vector<std::string> candidates = {
        "data/license/COPYING",
        "/usr/share/BastionGuard/data/license/COPYING",
        "COPYING",
        "LICENSE",
        "/usr/share/doc/BastionGuard/COPYING",
        "/usr/share/common-licenses/GPL-3"
    };
 
    for (const auto& path : candidates) {
        if (fs::exists(path)) {
            std::ifstream f(path);
            if (f.is_open()) {
                std::stringstream buf;
                buf << f.rdbuf();
                return buf.str();
            }
        }
    }
 
    return _("GNU GPL v3 license text not found.\n"
             "Assicurati che il file COPYING sia incluso nel progetto "
             "o che la tua distribuzione fornisca /usr/share/common-licenses/GPL-3.");
}
 
std::string AboutPage::load_database_info() {
    namespace fs = std::filesystem;
    const std::string path = "/var/lib/clamav";
 
    if (!fs::exists(path))
        return _("Directory /var/lib/clamav non trovata.\n");
 
    std::stringstream out;
    out << _("📁 Database ClamAV trovati in /var/lib/clamav\n\n");
 
    for (const auto& entry : fs::directory_iterator(path)) {
        auto file = entry.path().filename().string();
 
        if (file.ends_with(".hdb") || file.ends_with(".ndb") ||
            file.ends_with(".ldb") || file.ends_with(".cdb") ||
            file.ends_with(".hsb") || file.ends_with(".fp")) {
 
            out << "✔ " << file << "\n";
        }
        else if (file.ends_with(".cld") || file.ends_with(".cvd")) {
            out << "🔒 " << file << _(" (database ufficiale ClamAV)\n");
        }
        else {
 
            out << "• " << file << "\n";
        }
    }
 
 
    return out.str();
}