ScanPage Class Reference

#include <ScanPage.hpp>

Inheritance diagram for ScanPage:

Public Member Functions
	ScanPage (Gtk::Window &parent)
	~ScanPage () override

Private Member Functions
void	enqueueLog (const std::string &msg)
void	flushLog ()
void	saveCloudConfig ()
void	loadCloudConfig ()
void	onApiKeySaveClicked ()
void	showCloudPrivacyDisclaimer ()
void	onToggleApiKeyVisibility ()
void	onChooseFolder ()
void	onChooseFile ()
void	onStartScan ()
void	readOutput (const Glib::RefPtr< Gio::AsyncResult > &result)
void	addFileToList (const std::string &filepath)
void	saveConfig ()
void	loadConfig ()
std::vector< std::string >	detectBrowserDownloadDirs ()
std::vector< std::string >	getXdgUserDirs ()
bool	isOutsideKnownDownloadDirs (const std::string &path)
void	addInotifyRecursive (const std::string &path)
bool	onInotifyEvent (Glib::IOCondition cond)
void	handleInotifyFileEvent (const std::string &path, uint32_t mask)
void	enableAutoScanDownloads ()
void	enableGlobalDownloadMonitor ()
void	disableAllMonitors ()
void	onChooseFolderFinish (const Glib::RefPtr< Gio::AsyncResult > &result, Glib::RefPtr< Gtk::FileDialog > dialog)
void	onChooseFileFinish (const Glib::RefPtr< Gio::AsyncResult > &result, Glib::RefPtr< Gtk::FileDialog > dialog)
void	scanFileAutomatically (const std::string &filepath)
bool	isInterestingDownload (const std::string &path)
std::string	resolveFinalDownloadedFile (const std::string &path)
void	onAurPkgbuildDetected (const std::string &path)
void	scanAurAuto (const std::string &path)
void	cloudCheckMalwareBazaar (const std::string &filepath)
void	cloudCheckMalwareBazaarWorker (const std::string &filepath)
void	handleInfectedFile (const std::string &filepath)
void	handleInfectedFiles (const std::vector< std::string > &files)
void	handleInfectedFileWithName (const std::string &filepath, const std::string &virusName)
void	showAlertWindow (const std::string &file, const std::string &family)
void	logMessage (const std::string &msg)
bool	safeExists (const std::string &p) noexcept

Private Attributes
Gtk::Window &	parentWindow
Gtk::Box	buttonBox {Gtk::Orientation::HORIZONTAL, 5}
Gtk::Button	btnChooseFolder {_("Seleziona cartella")}
Gtk::Button	btnChooseFile {_("Seleziona file")}
Gtk::Button	btnScan {_("Scansiona")}
Gtk::Box	autoScanBox {Gtk::Orientation::HORIZONTAL, 6}
Gtk::Label	autoScanLabel
Gtk::Switch	autoScanSwitch
bool	autoScanEnabled = true
Gtk::TextView	textView
Glib::RefPtr< Gtk::TextBuffer >	textBuffer
Gtk::ListBox	fileListBox
Gtk::Box	apiKeyActionsBox {Gtk::Orientation::HORIZONTAL, 6}
Glib::RefPtr< Gtk::SizeGroup >	apiKeySizeGroup
Glib::RefPtr< Gio::Subprocess >	subprocess
Glib::RefPtr< Gio::InputStream >	stdoutStream
Glib::RefPtr< Gio::DataInputStream >	dataStream
Gtk::Box	apiKeyBox {Gtk::Orientation::HORIZONTAL, 6}
Gtk::Entry	apiKeyEntry
Gtk::Button	btnShowApiKey
Gtk::Button	btnApiKeySave {"Salva"}
Gtk::Button	btnPrivacy
bool	apiKeyVisible = false
std::string	malwareBazaarApiKey
std::mutex	logMutex
std::vector< std::string >	pendingLog
bool	logFlushScheduled = false
std::string	selectedPath
std::vector< std::string >	infectedFilesBuffer
bool	scanInProgress = false
std::vector< std::string >	knownDownloadDirs
int	inotifyFd = -1
Glib::RefPtr< Glib::IOSource >	inotifySource
std::unordered_map< int, std::string >	watchMap
std::unordered_set< std::string >	alreadyWatched
BastionGuard::AliveFlag	alive_ = BastionGuard::make_alive_flag()

Detailed Description

Definition at line 37 of file ScanPage.hpp.

Constructor & Destructor Documentation

ScanPage()

ScanPage::ScanPage ( Gtk::Window & parent )

explicit

Definition at line 131 of file ScanPage.cpp.

: Gtk::Box(Gtk::Orientation::VERTICAL, 5),
parentWindow(parent)
{
    set_margin(8);
    set_spacing(5);
 
 
    buttonBox.set_spacing(8);
    buttonBox.append(btnChooseFolder);
    buttonBox.append(btnChooseFile);
    buttonBox.append(btnScan);
    append(buttonBox);
 
    btnChooseFolder.signal_clicked().connect(sigc::mem_fun(*this, &ScanPage::onChooseFolder));
    btnChooseFile.signal_clicked().connect(sigc::mem_fun(*this, &ScanPage::onChooseFile));
    btnScan.signal_clicked().connect(sigc::mem_fun(*this, &ScanPage::onStartScan));
 
    // ===== UI scansione automatica =====
    autoScanLabel.set_text(_("Scansione automatica"));
    autoScanBox.set_spacing(8);
    autoScanBox.append(autoScanLabel);
    autoScanBox.append(autoScanSwitch);
    append(autoScanBox);
 
    autoScanSwitch.set_active(true);
    autoScanEnabled = true;
 
    autoScanSwitch.property_active().signal_changed().connect([this]() {
        autoScanEnabled = autoScanSwitch.get_active();
        enqueueLog(autoScanEnabled ? _("⚙️ Scansione automatica attiva")
        : _("⛔ Scansione automatica disattivata"));
        if (autoScanEnabled) {
            enableAutoScanDownloads();
            enableGlobalDownloadMonitor();
        } else {
            disableAllMonitors();
        }
        saveConfig();
    });
 
    textBuffer = Gtk::TextBuffer::create();
    textView.set_buffer(textBuffer);
    textView.set_editable(false);
    textView.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
 
    auto scrollLog = Gtk::make_managed<Gtk::ScrolledWindow>();
    scrollLog->set_child(textView);
    scrollLog->set_min_content_height(180);
    scrollLog->set_expand(true);
    append(*scrollLog);
 
 
    auto scrollFiles = Gtk::make_managed<Gtk::ScrolledWindow>();
    scrollFiles->set_child(fileListBox);
    scrollFiles->set_min_content_height(150);
    scrollFiles->set_expand(true);
    append(*scrollFiles);
 
 
    apiKeyBox.set_spacing(8);
    auto lbl = Gtk::make_managed<Gtk::Label>(_("API Key VirusTotal:"));
    lbl->set_valign(Gtk::Align::CENTER);
    apiKeyEntry.set_hexpand(true);
    apiKeyEntry.set_visibility(false);
    apiKeyBox.append(*lbl);
    apiKeyBox.append(apiKeyEntry);
 
    apiKeyBox.set_spacing(8);
 
 
    lbl->set_valign(Gtk::Align::CENTER);
 
 
    apiKeyEntry.set_hexpand(true);
    apiKeyEntry.set_visibility(false);
    apiKeyEntry.set_valign(Gtk::Align::CENTER);
 
 
    btnShowApiKey.set_icon_name("view-reveal-symbolic");
    btnShowApiKey.add_css_class("flat");
    btnShowApiKey.set_valign(Gtk::Align::CENTER);
 
 
    btnApiKeySave.set_valign(Gtk::Align::CENTER);
 
 
    btnPrivacy.set_icon_name("dialog-information-symbolic");
    btnPrivacy.set_tooltip_text(_("Privacy e dati cloud"));
    btnPrivacy.add_css_class("flat");
    btnPrivacy.set_valign(Gtk::Align::CENTER);
 
    btnShowApiKey.signal_clicked().connect(
        sigc::mem_fun(*this, &ScanPage::onToggleApiKeyVisibility)
    );
 
 
    apiKeyActionsBox.set_valign(Gtk::Align::CENTER);
    apiKeyActionsBox.append(btnShowApiKey);
    apiKeyActionsBox.append(btnApiKeySave);
    apiKeyActionsBox.append(btnPrivacy);
 
 
    apiKeySizeGroup = Gtk::SizeGroup::create(Gtk::SizeGroup::Mode::VERTICAL);
    apiKeySizeGroup->add_widget(apiKeyEntry);
    apiKeySizeGroup->add_widget(btnShowApiKey);
    apiKeySizeGroup->add_widget(btnApiKeySave);
    apiKeySizeGroup->add_widget(btnPrivacy);
 
 
    apiKeyBox.append(*lbl);
    apiKeyBox.append(apiKeyEntry);
    apiKeyBox.append(apiKeyActionsBox);
 
    append(apiKeyBox);
 
 
 
    btnPrivacy.set_label(_("Privacy / Dati cloud"));
    btnPrivacy.set_icon_name("dialog-information");
    btnPrivacy.set_halign(Gtk::Align::START);
    btnPrivacy.add_css_class("flat");
 
    btnPrivacy.signal_clicked().connect(
        sigc::mem_fun(*this, &ScanPage::showCloudPrivacyDisclaimer)
    );
 
 
 
    btnApiKeySave.signal_clicked().connect(sigc::mem_fun(*this, &ScanPage::onApiKeySaveClicked));
 
    loadConfig();
    loadCloudApiKeys();
    loadCloudConfig();
 
 
    inotifyFd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
    if (inotifyFd < 0) {
        enqueueLog(_("❌ Errore: inotify non inizializzato"));
    } else {
        enqueueLog(_("📡 Inotify inizializzato"));
 
        inotifySource = Glib::IOSource::create(inotifyFd, Glib::IOCondition::IO_IN);
 
        inotifySource->connect(sigc::mem_fun(*this, &ScanPage::onInotifyEvent));
        inotifySource->attach(Glib::MainContext::get_default());
    }
 
 
    knownDownloadDirs = detectBrowserDownloadDirs();
    enableAutoScanDownloads();
    enableGlobalDownloadMonitor();
}

References _, apiKeyActionsBox, apiKeyBox, apiKeyEntry, apiKeySizeGroup, autoScanBox, autoScanEnabled, autoScanLabel, autoScanSwitch, btnApiKeySave, btnChooseFile, btnChooseFolder, btnPrivacy, btnScan, btnShowApiKey, buttonBox, detectBrowserDownloadDirs(), disableAllMonitors(), enableAutoScanDownloads(), enableGlobalDownloadMonitor(), enqueueLog(), fileListBox, inotifyFd, inotifySource, knownDownloadDirs, loadCloudApiKeys(), loadCloudConfig(), loadConfig(), onApiKeySaveClicked(), onChooseFile(), onChooseFolder(), onInotifyEvent(), onStartScan(), onToggleApiKeyVisibility(), parentWindow, saveConfig(), showCloudPrivacyDisclaimer(), textBuffer, and textView.

~ScanPage()

ScanPage::~ScanPage ( )

override

Definition at line 125 of file ScanPage.cpp.

{
    if (alive_) alive_->store(false, std::memory_order_release);
}

References alive_.

Member Function Documentation

addFileToList()

void ScanPage::addFileToList ( const std::string & filepath )

private

Definition at line 878 of file ScanPage.cpp.

{
    auto row = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
 
    auto icon = Gtk::make_managed<Gtk::Image>();
    icon->set_from_icon_name("text-x-generic");
    icon->set_pixel_size(20);
    row->append(*icon);
 
    auto lbl = Gtk::make_managed<Gtk::Label>(filepath);
    lbl->set_hexpand(true);
    lbl->set_ellipsize(Pango::EllipsizeMode::END);
    row->append(*lbl);
 
    fileListBox.append(*row);
}

References fileListBox.

Referenced by readOutput().

addInotifyRecursive()

void ScanPage::addInotifyRecursive ( const std::string & path )

private

Definition at line 335 of file ScanPage.cpp.

{
    namespace fs = std::filesystem;
 
    if (!fs::exists(root)) return;
 
    std::string norm = normalizePath(root);
 
    // Evita duplicati
    if (alreadyWatched.count(norm)) return;
 
    // ANTI-BOOTLOOP: se la cartella è una directory di build (CMake, Cargo,
    // node_modules, .venv, target/, …), NON aggiungere watch. Durante una
    // compilazione vengono creati migliaia di file in pochi secondi: senza
    // questo filtro inotify scatena un cascade di eventi che a sua volta
    // satura il main loop (handleInotifyFileEvent -> clamdscan async ->
    // ulteriori scritture) → bootloop di ScanPage e degrado del sistema.
    if (isInBuildDir(norm + "/")) {
        return;
    }
 
    alreadyWatched.insert(norm);
 
    int wd = inotify_add_watch(
        inotifyFd,
        norm.c_str(),
                               IN_CREATE | IN_MOVED_TO | IN_CLOSE_WRITE | IN_ATTRIB
    );
 
    if (wd < 0) {
        enqueueLog(_("⚠️ Impossibile monitorare: ") + norm);
        return;
    }
 
    watchMap[wd] = norm;
    enqueueLog(_("📁 Watch attivo: ") + norm);
 
 
    try {
        for (auto& entry : fs::directory_iterator(norm)) {
            if (entry.is_directory()) {
                std::string sub = entry.path().string();
                // ignora cartelle nascoste
                std::string name = entry.path().filename().string();
                if (!name.empty() && name[0] == '.')
                    continue;
 
                // ANTI-BOOTLOOP: non scendere in directory di build note
                // (build/, target/, node_modules/, CMakeFiles/, ecc.).
                // Il check con "/" finale forza isInBuildDir a matchare il
                // segmento completo.
                if (isInBuildDir(sub + "/")) {
                    continue;
                }
 
                addInotifyRecursive(sub);
            }
        }
    } catch (...) {
 
    }
}

References _, addInotifyRecursive(), alreadyWatched, enqueueLog(), inotifyFd, isInBuildDir(), normalizePath(), and watchMap.

Referenced by addInotifyRecursive(), enableAutoScanDownloads(), and enableGlobalDownloadMonitor().

cloudCheckMalwareBazaar()

void ScanPage::cloudCheckMalwareBazaar ( const std::string & filepath )

private

Definition at line 1216 of file ScanPage.cpp.

{
    if (activeCloudChecks.load() >= 4) {
        enqueueLog(_("⏳ Troppi controlli cloud in corso, salto temporaneamente."));
        return;
    }
 
    enqueueLog(_("🌐 Avvio controllo cloud..."));
    activeCloudChecks++;
 
    auto alive = alive_;
    std::thread([this, alive, filepath]() {
        try {
            cloudCheckMalwareBazaarWorker(filepath);
        }
        catch (const std::exception& ex) {
            if (!alive->load()) { activeCloudChecks--; return; }
            Glib::signal_idle().connect_once([this, alive, msg = std::string(ex.what())]() {
                BastionGuard::if_alive(alive, [this, &msg]() {
                    enqueueLog(std::string(_("❌ Errore controllo cloud: ")) + msg);
                });
            });
        }
        catch (...) {
            if (!alive->load()) { activeCloudChecks--; return; }
            Glib::signal_idle().connect_once([this, alive]() {
                BastionGuard::if_alive(alive, [this]() {
                    enqueueLog(_("❌ Errore controllo cloud sconosciuto."));
                });
            });
        }
 
        activeCloudChecks--;
    }).detach();
}

References _, activeCloudChecks, alive_, cloudCheckMalwareBazaarWorker(), enqueueLog(), and BastionGuard::if_alive().

Referenced by resolveFinalDownloadedFile(), and scanFileAutomatically().

cloudCheckMalwareBazaarWorker()

void ScanPage::cloudCheckMalwareBazaarWorker ( const std::string & filepath )

private

Definition at line 1154 of file ScanPage.cpp.

{
    if (!fs::exists(filepath))
        return;
 
    std::string sha = MalwareBazaar::sha256_file(filepath);
    if (sha.empty())
        return;
 
    MBResult r = MalwareBazaar::lookupHash(sha);
 
    if (!alive_->load()) return;
 
    // Rientro nel main loop GTK
    auto alive = alive_;
    Glib::signal_idle().connect_once(
        [this, alive, filepath, r]() {
            BastionGuard::if_alive(alive, [this, &filepath, &r]() {
                if (!r.found) {
                    enqueueLog(_("🔏 Nessun match cloud → File sicuro."));
                    return;
                }
 
                enqueueLog("🚨 Malware identificato:");
                enqueueLog("Nome: " + r.malwareName);
                enqueueLog("Tipo: " + r.fileType);
                enqueueLog("Tags: " + r.tags);
 
                try {
                    auto conn = Gio::DBus::Connection::get_sync(
                        Gio::DBus::BusType::SESSION
                    );
                    auto proxy = Gio::DBus::Proxy::create_sync(
                        conn,
                        "org.BastionGuard.Ransomware.Alert",
                        "/org/BastionGuard/ransomware/alert",
                        "org.BastionGuard.Ransomware.Alert"
                    );
 
                    auto params = Glib::VariantContainerBase::create_tuple({
                        Glib::Variant<Glib::ustring>::create(filepath),
                                                                           Glib::Variant<Glib::ustring>::create(
                                                                               "VirusTotal: " + r.malwareName)
                    });
 
                    proxy->call_sync("ShowAlert", params);
                }
                catch (...) {
                    Utils::show_message(
                        &parentWindow,
                        (Glib::ustring("Malware cloud:\n") + filepath +
                         "\nNome: " + r.malwareName).raw(),
                        Gtk::MessageType::WARNING
                    );
                }
            });
        }
    );
}

References _, alive_, enqueueLog(), BastionGuard::if_alive(), MalwareBazaar::lookupHash(), parentWindow, MalwareBazaar::sha256_file(), and Utils::show_message().

Referenced by cloudCheckMalwareBazaar(), and resolveFinalDownloadedFile().

detectBrowserDownloadDirs()

std::vector< std::string > ScanPage::detectBrowserDownloadDirs ( )

private

Definition at line 895 of file ScanPage.cpp.

{
    std::vector<std::string> dirs;
    std::string home = Glib::get_home_dir();
 
 
    std::string def = home + "/Downloads";
    if (fs::exists(def)) dirs.push_back(def);
 
 
    try {
        std::string base = home + "/.mozilla/firefox";
        if (fs::exists(base)) {
            for (auto& entry : fs::directory_iterator(base)) {
                if (!entry.is_directory()) continue;
 
                fs::path prefs = entry.path() / "prefs.js";
                if (!fs::exists(prefs)) continue;
 
                std::ifstream f(prefs);
                std::string line;
 
                while (std::getline(f, line)) {
                    if (line.find("browser.download.dir") != std::string::npos) {
                        size_t s = line.find('"', line.find(',') + 1);
                        size_t e = line.find('"', s + 1);
                        if (s != std::string::npos && e != std::string::npos) {
                            std::string d = line.substr(s + 1, e - s - 1);
                            if (fs::exists(d)) dirs.push_back(d);
                        }
                    }
                }
            }
        }
    } catch (...) {}
 
 
    std::vector<std::string> cfgs = {
        home + "/.config/google-chrome/Default/Preferences",
        home + "/.config/chromium/Default/Preferences",
        home + "/.config/microsoft-edge/Default/Preferences"
    };
 
    for (auto& pref : cfgs) {
        try {
            if (!fs::exists(pref)) continue;
 
            std::ifstream f(pref);
            std::string content(
                (std::istreambuf_iterator<char>(f)),
                                std::istreambuf_iterator<char>()
            );
 
            std::string key = "\"default_directory\"";
            size_t pos = content.find(key);
            if (pos == std::string::npos) continue;
 
            size_t s = content.find('"', pos + key.size());
            size_t e = content.find('"', s + 1);
 
            if (s != std::string::npos && e != std::string::npos) {
                std::string d = content.substr(s + 1, e - s - 1);
                if (fs::exists(d)) dirs.push_back(d);
            }
        } catch (...) {}
    }
 
 
    std::sort(dirs.begin(), dirs.end());
    dirs.erase(std::unique(dirs.begin(), dirs.end()), dirs.end());
 
    return dirs;
}

Referenced by enableAutoScanDownloads(), and ScanPage().

disableAllMonitors()

void ScanPage::disableAllMonitors ( )

private

Definition at line 638 of file ScanPage.cpp.

{
    alreadyWatched.clear();
    watchMap.clear();
 
    if (inotifyFd >= 0) {
        close(inotifyFd);
        inotifyFd = -1;
    }
 
    enqueueLog(_("🛑 Tutti i monitor inotify sono stati disattivati"));
}

References _, alreadyWatched, enqueueLog(), inotifyFd, and watchMap.

Referenced by ScanPage().

enableAutoScanDownloads()

void ScanPage::enableAutoScanDownloads ( )

private

Definition at line 979 of file ScanPage.cpp.

{
    knownDownloadDirs = detectBrowserDownloadDirs();
 
    for (const auto& d : knownDownloadDirs) {
        if (!fs::exists(d)) continue;
        addInotifyRecursive(normalizePath(d));
    }
 
    enqueueLog(_("📡 Monitoraggio Download attivo (inotify)"));
}

References _, addInotifyRecursive(), detectBrowserDownloadDirs(), enqueueLog(), knownDownloadDirs, and normalizePath().

Referenced by ScanPage().

enableGlobalDownloadMonitor()

void ScanPage::enableGlobalDownloadMonitor ( )

private

Definition at line 1023 of file ScanPage.cpp.

{
    // ANTI-BOOTLOOP: NON monitorare $HOME né /tmp ricorsivamente.
    // Un singolo `make -j` in qualsiasi cartella del home (incluso il
    // checkout di BastionGuard stesso) creerebbe migliaia di file
    // sotto build/CMakeFiles/, e l'inotify watcher genererebbe una
    // cascata di eventi → scansioni clamdscan in serie → main loop
    // bloccato → "bootloop" visivo della ScanPage.
    //
    // Limitiamo i watch alle XDG user dirs (Downloads, Desktop,
    // Documents, …) e a ~/.var/app, che è l'unico path Flatpak
    // dove i browser scrivono i download.
    std::vector<std::string> dirs;
 
    auto xdg = getXdgUserDirs();
    dirs.insert(dirs.end(), xdg.begin(), xdg.end());
 
    std::string varApp = Glib::get_home_dir() + "/.var/app";
    if (fs::exists(varApp)) dirs.push_back(varApp);
 
    std::sort(dirs.begin(), dirs.end());
    dirs.erase(std::unique(dirs.begin(), dirs.end()), dirs.end());
 
    for (auto& d : dirs) {
        if (!fs::exists(d)) continue;
        // addInotifyRecursive a sua volta filtra le build dirs
        // (per esempio se l'utente ha ~/Documents/progetti/foo/build/).
        addInotifyRecursive(normalizePath(d));
    }
 
    enqueueLog(_("🌍 Monitor globale inotify attivo (XDG dirs)"));
}

References _, addInotifyRecursive(), enqueueLog(), getXdgUserDirs(), and normalizePath().

Referenced by ScanPage().

enqueueLog()

void ScanPage::enqueueLog ( const std::string & msg )

private

Definition at line 286 of file ScanPage.cpp.

                                              {
    std::lock_guard<std::mutex> lock(logMutex);
    pendingLog.push_back(msg);
    if (!logFlushScheduled) {
        logFlushScheduled = true;
        Glib::signal_timeout().connect_once(
            [this]() { flushLog(); }, 50
        );
    }
}

References flushLog(), logFlushScheduled, logMutex, and pendingLog.

Referenced by addInotifyRecursive(), cloudCheckMalwareBazaar(), cloudCheckMalwareBazaarWorker(), disableAllMonitors(), enableAutoScanDownloads(), enableGlobalDownloadMonitor(), handleInfectedFiles(), handleInfectedFileWithName(), handleInotifyFileEvent(), loadCloudConfig(), onAurPkgbuildDetected(), onChooseFileFinish(), onChooseFolderFinish(), onStartScan(), saveCloudConfig(), scanAurAuto(), scanFileAutomatically(), and ScanPage().

flushLog()

void ScanPage::flushLog ( )

private

Definition at line 297 of file ScanPage.cpp.

                        {
    std::vector<std::string> batch;
    {
        std::lock_guard<std::mutex> lock(logMutex);
        batch.swap(pendingLog);
        logFlushScheduled = false;
    }
    Glib::ustring s;
    for (auto& m : batch) s += m + "\n";
    textBuffer->insert(textBuffer->end(), s);
}

References logFlushScheduled, logMutex, pendingLog, and textBuffer.

Referenced by enqueueLog().

getXdgUserDirs()

std::vector< std::string > ScanPage::getXdgUserDirs ( )

private

Definition at line 992 of file ScanPage.cpp.

{
    std::vector<std::string> out;
 
    std::string p = Glib::get_home_dir() + "/.config/user-dirs.dirs";
    if (!fs::exists(p)) return out;
 
    std::ifstream f(p);
    std::string line;
 
    while (std::getline(f, line)) {
        if (line.find("XDG_") != 0 || line.find("_DIR=") == std::string::npos)
            continue;
 
        size_t q1 = line.find('"');
        size_t q2 = line.find('"', q1 + 1);
 
        if (q1 == std::string::npos || q2 == std::string::npos)
            continue;
 
        std::string value = line.substr(q1 + 1, q2 - q1 - 1);
        if (value.find("$HOME") == 0)
            value.replace(0, 5, Glib::get_home_dir());
 
        if (fs::exists(value))
            out.push_back(value);
    }
 
    return out;
}

Referenced by enableGlobalDownloadMonitor().

handleInfectedFile()

void ScanPage::handleInfectedFile ( const std::string & filepath )

private

Definition at line 1253 of file ScanPage.cpp.

{
    handleInfectedFileWithName(filepath, "ClamAV.Detected");
}

References handleInfectedFileWithName().

Referenced by resolveFinalDownloadedFile().

handleInfectedFiles()

void ScanPage::handleInfectedFiles ( const std::vector< std::string > & files )

private

Definition at line 1259 of file ScanPage.cpp.

{
    if (files.empty()) return;
 
    try {
        auto conn = Gio::DBus::Connection::get_sync(Gio::DBus::BusType::SESSION);
        auto proxy = Gio::DBus::Proxy::create_sync(
            conn,
            "org.BastionGuard.Ransomware.Alert",
            "/org/BastionGuard/ransomware/alert",
            "org.BastionGuard.Ransomware.Alert"
        );
 
        for (const auto& f : files) {
            auto params = Glib::VariantContainerBase::create_tuple({
                Glib::Variant<Glib::ustring>::create(f),
                                                                   Glib::Variant<Glib::ustring>::create("ClamAV.Detected")
            });
            proxy->call_sync("ShowAlert", params);
 
            enqueueLog(_("⚠️ Alert inviato per file infetto: ") + f);
        }
    }
    catch (...) {
        Utils::show_message(
            &parentWindow,
            _("File infetto rilevato:\n") + files.front(),
            Gtk::MessageType::WARNING
        );
    }
}

References _, enqueueLog(), parentWindow, and Utils::show_message().

Referenced by resolveFinalDownloadedFile().

handleInfectedFileWithName()

void ScanPage::handleInfectedFileWithName ( const std::string & filepath, const std::string & virusName )

private

Definition at line 1292 of file ScanPage.cpp.

{
    try {
        auto conn = Gio::DBus::Connection::get_sync(Gio::DBus::BusType::SESSION);
        auto proxy = Gio::DBus::Proxy::create_sync(
            conn,
            "org.BastionGuard.Ransomware.Alert",
            "/org/BastionGuard/ransomware/alert",
            "org.BastionGuard.Ransomware.Alert"
        );
 
        auto params = Glib::VariantContainerBase::create_tuple({
            Glib::Variant<Glib::ustring>::create(filepath),
                                                               Glib::Variant<Glib::ustring>::create(virusName)
        });
 
        proxy->call_sync("ShowAlert", params);
 
        enqueueLog(_("⚠️ File infetto: ") + filepath + "  (" + virusName + ")");
    }
    catch (...) {
        Utils::show_message(
            &parentWindow,
            _("File infetto:\n") + filepath + "\nVirus: " + virusName,
            Gtk::MessageType::WARNING
        );
    }
}

References _, enqueueLog(), parentWindow, and Utils::show_message().

Referenced by handleInfectedFile(), onAurPkgbuildDetected(), readOutput(), resolveFinalDownloadedFile(), scanAurAuto(), and scanFileAutomatically().

handleInotifyFileEvent()

void ScanPage::handleInotifyFileEvent ( const std::string & path, uint32_t mask )

private

Definition at line 558 of file ScanPage.cpp.

{
    if (!autoScanEnabled) return;
    if (path.empty()) return;
 
    // Filtro directory rumorose / sensibili. Usiamo segmenti con slash su
    // entrambi i lati per evitare falsi positivi come "/builder" o
    // "/.localdomain". Il filtro per le build dir vere è isInBuildDir()
    // poco sotto, qui filtriamo solo cache/git/local privati.
    if (path.find("/.cache/") != std::string::npos ||
        path.find("/.local/") != std::string::npos ||
        path.find("/.git/")   != std::string::npos)
        return;
 
 
    if (!(mask & (IN_CLOSE_WRITE | IN_MOVED_TO)))
        return;
 
 
    if (ends_with(path, ".part") || ends_with(path, ".crdownload"))
        return;
 
    // ---- Anti-compilazione: salta artefatti di build e directory di build.
    // Sui progetti che si compilano si producono molti file in pochi secondi,
    // se partisse una scansione per ognuno il sistema rallenterebbe troppo
    // (bootloop di ScanPage). Questo check va fatto PRIMA del burst counter,
    // così i file di build non lo gonfiano (altrimenti rischiamo di entrare
    // in throttle anche quando l'utente sta solo scaricando legittimamente).
    if (isBuildArtifactExt(path) || isInBuildDir(path))
        return;
 
    // ---- Anti-compilazione (parte 2): rilevamento "burst di scrittura".
    // Se in una finestra breve arrivano molti eventi vicini, presumiamo che
    // sia in corso una compilazione: entriamo in throttle e per qualche
    // secondo non scansioniamo nulla automaticamente.
    {
        const int64_t now = nowMs();
 
        // Se siamo già in throttle, salta direttamente.
        if (now < g_throttleUntilMs.load(std::memory_order_relaxed)) {
            return;
        }
 
        // Aggiorna/azzera la finestra di osservazione.
        int64_t winStart = g_burstWindowStartMs.load(std::memory_order_relaxed);
        if (winStart == 0 || now - winStart > kBurstWindowMs) {
            g_burstWindowStartMs.store(now, std::memory_order_relaxed);
            g_recentEventCount.store(1, std::memory_order_relaxed);
        } else {
            int n = g_recentEventCount.fetch_add(1, std::memory_order_relaxed) + 1;
            if (n > kBurstThreshold) {
                // Burst rilevato → throttle: niente scansione automatica.
                g_throttleUntilMs.store(now + kThrottleHoldMs,
                                        std::memory_order_relaxed);
                g_burstWindowStartMs.store(0, std::memory_order_relaxed);
                g_recentEventCount.store(0, std::memory_order_relaxed);
                enqueueLog(_("⏸️ Compilazione/burst rilevato: scansione automatica sospesa temporaneamente"));
                return;
            }
        }
    }
 
    if (recentlyScanned.count(path)) return;
    recentlyScanned.insert(path);
    Glib::signal_timeout().connect_once([path](){
        recentlyScanned.erase(path);
    }, 1500);
 
 
    Glib::signal_timeout().connect_once(
        [this, path]() {
            if (!fs::exists(path)) return;
            scanFileAutomatically(path);
        },
        100
    );
}

References _, autoScanEnabled, ends_with(), enqueueLog(), g_burstWindowStartMs, g_recentEventCount, g_throttleUntilMs, isBuildArtifactExt(), isInBuildDir(), kBurstThreshold, kBurstWindowMs, kThrottleHoldMs, nowMs(), recentlyScanned, and scanFileAutomatically().

Referenced by onInotifyEvent().

isInterestingDownload()

bool ScanPage::isInterestingDownload ( const std::string & path )

private

isOutsideKnownDownloadDirs()

bool ScanPage::isOutsideKnownDownloadDirs ( const std::string & path )

private

Definition at line 970 of file ScanPage.cpp.

{
    for (const auto& d : knownDownloadDirs) {
        if (path.rfind(d, 0) == 0) return false;
    }
    return true;
}

References knownDownloadDirs.

loadCloudConfig()

void ScanPage::loadCloudConfig ( )

private

Definition at line 494 of file ScanPage.cpp.

{
    std::string path = Glib::get_home_dir() + "/.config/BastionGuard/cloud.conf";
 
    try {
        if (!fs::exists(path)) {
            malwareBazaarApiKey = "";
            return;
        }
 
        std::ifstream f(path);
        std::string line;
 
        while (std::getline(f, line)) {
            line = trim(line);
            if (line.empty() || line[0] == '#') continue;
 
            size_t eq = line.find('=');
            if (eq == std::string::npos) continue;
 
            std::string key = trim(line.substr(0, eq));
            std::string value = trim(line.substr(eq + 1));
 
            if (key == "malware_bazaar_api_key") {
                malwareBazaarApiKey = value;
            }
        }
 
        apiKeyEntry.set_text(malwareBazaarApiKey);
        enqueueLog(_("🔑 API Key VirusTotal caricata da cloud.conf"));
        globalMalwareBazaarApiKey = malwareBazaarApiKey;
    }
    catch (...) {
        enqueueLog(_("⚠️ Errore caricamento cloud.conf"));
    }
}

References _, apiKeyEntry, enqueueLog(), globalMalwareBazaarApiKey, malwareBazaarApiKey, and trim().

Referenced by ScanPage().

loadConfig()

void ScanPage::loadConfig ( )

private

Definition at line 324 of file ScanPage.cpp.

                          {
    try {
        if (!fs::exists(getConfigPath())) return;
        json cfg;
        std::ifstream ifs(getConfigPath());
        ifs >> cfg;
        autoScanEnabled = cfg.value("auto_scan_enabled", true);
        autoScanSwitch.set_active(autoScanEnabled);
    } catch (...) {}
}

References autoScanEnabled, autoScanSwitch, and getConfigPath().

Referenced by ScanPage().

logMessage()

void ScanPage::logMessage ( const std::string & msg )

private

Definition at line 1057 of file ScanPage.cpp.

{
    textBuffer->insert(textBuffer->end(), msg + "\n");
}

References textBuffer.

Referenced by resolveFinalDownloadedFile().

onApiKeySaveClicked()

void ScanPage::onApiKeySaveClicked ( )

private

Definition at line 551 of file ScanPage.cpp.

{
    malwareBazaarApiKey = apiKeyEntry.get_text();
    saveCloudConfig();
}

References apiKeyEntry, malwareBazaarApiKey, and saveCloudConfig().

Referenced by ScanPage().

onAurPkgbuildDetected()

void ScanPage::onAurPkgbuildDetected ( const std::string & path )

private

Definition at line 1063 of file ScanPage.cpp.

{
    // Caso speciale: INFECTED:PATH
    if (path.rfind("INFECTED:", 0) == 0) {
        std::string real = path.substr(11);
        enqueueLog(_("⚠️ PKGBUILD sospetto: ") + real);
        handleInfectedFileWithName(real, "AUR.StaticHeuristic");
        return;
    }
 
    enqueueLog(_("📦 PKGBUILD rilevato: ") + path);
 
 
    AurScan::scanPKGBUILD(path);
 
 
    scanAurAuto(path);
}

References _, enqueueLog(), handleInfectedFileWithName(), scanAurAuto(), and AurScan::scanPKGBUILD().

Referenced by resolveFinalDownloadedFile().

onChooseFile()

void ScanPage::onChooseFile ( )

private

Definition at line 463 of file ScanPage.cpp.

{
    auto dialog = Gtk::FileDialog::create();
    dialog->set_title(_("Seleziona file"));
    dialog->set_modal(true);
 
    dialog->open(
        parentWindow,
        sigc::bind(
            sigc::mem_fun(*this, &ScanPage::onChooseFileFinish),
                   dialog
        )
    );
}

References _, onChooseFileFinish(), and parentWindow.

Referenced by ScanPage().

onChooseFileFinish()

void ScanPage::onChooseFileFinish ( const Glib::RefPtr< Gio::AsyncResult > & result, Glib::RefPtr< Gtk::FileDialog > dialog )

private

Definition at line 478 of file ScanPage.cpp.

{
    try {
        auto file = dialog->open_finish(result);
        if (!file)
            return;
 
        selectedPath = file->get_path();
        enqueueLog(_("📄 File selezionato: ") + selectedPath);
    }
    catch (const Glib::Error&) {
    }
}

References _, enqueueLog(), and selectedPath.

Referenced by onChooseFile().

onChooseFolder()

void ScanPage::onChooseFolder ( )

private

Definition at line 431 of file ScanPage.cpp.

{
    auto dialog = Gtk::FileDialog::create();
    dialog->set_title(_("Seleziona cartella"));
    dialog->set_modal(true);
 
    dialog->select_folder(
        parentWindow,
        sigc::bind(
            sigc::mem_fun(*this, &ScanPage::onChooseFolderFinish),
                   dialog
        )
    );
}

References _, onChooseFolderFinish(), and parentWindow.

Referenced by ScanPage().

onChooseFolderFinish()

void ScanPage::onChooseFolderFinish ( const Glib::RefPtr< Gio::AsyncResult > & result, Glib::RefPtr< Gtk::FileDialog > dialog )

private

Definition at line 446 of file ScanPage.cpp.

{
    try {
        auto file = dialog->select_folder_finish(result);
        if (!file)
            return;
 
        selectedPath = file->get_path();
        enqueueLog(_("📁 Cartella selezionata: ") + selectedPath);
    }
    catch (const Glib::Error&) {
    }
}

References _, enqueueLog(), and selectedPath.

Referenced by onChooseFolder().

onInotifyEvent()

bool ScanPage::onInotifyEvent ( Glib::IOCondition cond )

private

Definition at line 399 of file ScanPage.cpp.

{
    if (!static_cast<bool>(cond & Glib::IOCondition::IO_IN))
        return true;
 
    char buffer[4096]
    __attribute__((aligned(__alignof__(struct inotify_event))));
 
    ssize_t len = read(inotifyFd, buffer, sizeof(buffer));
    if (len <= 0)
        return true;
 
    const char* ptr = buffer;
 
    while (ptr < buffer + len) {
        const inotify_event* ev =
        reinterpret_cast<const inotify_event*>(ptr);
 
        std::string parentDir =
        watchMap.count(ev->wd) ? watchMap[ev->wd] : "";
 
        std::string name = ev->len ? std::string(ev->name) : "";
        std::string fullPath = parentDir + "/" + name;
 
        handleInotifyFileEvent(fullPath, ev->mask);
 
        ptr += sizeof(struct inotify_event) + ev->len;
    }
 
    return true;
}

References handleInotifyFileEvent(), inotifyFd, and watchMap.

Referenced by ScanPage().

onStartScan()

void ScanPage::onStartScan ( )

private

Definition at line 651 of file ScanPage.cpp.

{
    if (scanInProgress) {
        enqueueLog(_("⏳ È già in corso un'altra scansione..."));
        return;
    }
 
    if (selectedPath.empty()) {
        textBuffer->set_text(_("⚠️ Nessun file o cartella selezionato.\n"));
        return;
    }
 
    scanInProgress = true;
    selectedPath = trim(selectedPath);
 
    textBuffer->set_text(_("🔍 Avvio scansione con clamdscan...\n\n"));
 
    infectedFilesBuffer.clear();
    fileListBox.remove_all();
 
    try {
        std::vector<std::string> argv = {
            "clamdscan",
            "--fdpass",
            "--no-summary",
            "--infected",
            selectedPath
        };
 
        subprocess = Gio::Subprocess::create(
            argv,
            Gio::Subprocess::Flags::STDOUT_PIPE |
            Gio::Subprocess::Flags::STDERR_PIPE
        );
 
        stdoutStream = subprocess->get_stdout_pipe();
        dataStream = Gio::DataInputStream::create(stdoutStream);
 
        dataStream->read_line_async(
            sigc::mem_fun(*this, &ScanPage::readOutput),
                                    Glib::RefPtr<Gio::Cancellable>(),
                                    Glib::PRIORITY_DEFAULT
        );
    }
    catch (const Glib::Error& ex) {
        textBuffer->insert(textBuffer->end(),
                           _("❌ Errore avvio clamdscan: ") + Glib::ustring(ex.what()) + "\n"
        );
        scanInProgress = false;
    }
}

References _, dataStream, enqueueLog(), fileListBox, infectedFilesBuffer, readOutput(), scanInProgress, selectedPath, stdoutStream, subprocess, textBuffer, and trim().

Referenced by ScanPage().

onToggleApiKeyVisibility()

void ScanPage::onToggleApiKeyVisibility ( )

private

Definition at line 1435 of file ScanPage.cpp.

{
    apiKeyVisible = !apiKeyVisible;
 
    apiKeyEntry.set_visibility(apiKeyVisible);
 
    btnShowApiKey.set_icon_name(
        apiKeyVisible
        ? "view-conceal-symbolic"
        : "view-reveal-symbolic"
    );
}

References apiKeyEntry, apiKeyVisible, and btnShowApiKey.

Referenced by ScanPage().

readOutput()

void ScanPage::readOutput ( const Glib::RefPtr< Gio::AsyncResult > & result )

private

Definition at line 704 of file ScanPage.cpp.

{
    try {
        std::string line;
        bool ok = dataStream->read_line_finish(result, line);
 
        if (!ok) {
            scanInProgress = false;
            textBuffer->insert(textBuffer->end(), _("✅ Scansione completata.\n"));
            return;
        }
 
        auto alive = alive_;
        Glib::signal_idle().connect_once([this, alive, line]() {
            BastionGuard::if_alive(alive, [this, &line]() {
                textBuffer->insert(textBuffer->end(), line + "\n");
 
                // Esempio: "Scanning /path/file"
                if (line.rfind("Scanning ", 0) == 0) {
                    std::string filepath = line.substr(9);
                    addFileToList(filepath);
                }
 
                // Esempio: "/file: Virus FOUND"
                if (line.find("FOUND") != std::string::npos) {
 
                    size_t pos = line.find(": ");
                    size_t end = line.find(" FOUND");
 
                    if (pos != std::string::npos && end != std::string::npos) {
                        std::string infected = line.substr(0, pos);
                        std::string virus = line.substr(pos + 2, end - (pos + 2));
 
                        infectedFilesBuffer.push_back(infected);
                        handleInfectedFileWithName(infected, virus);
                    }
                }
            });
        });
 
        // Continua lettura
        dataStream->read_line_async(
            sigc::mem_fun(*this, &ScanPage::readOutput),
                                    Glib::RefPtr<Gio::Cancellable>(),
                                    Glib::PRIORITY_DEFAULT
        );
    }
    catch (const Glib::Error& ex) {
        textBuffer->insert(textBuffer->end(),
                           _("❌ Errore lettura output: ") + Glib::ustring(ex.what()) + "\n"
        );
        scanInProgress = false;
    }
}

References _, addFileToList(), alive_, dataStream, handleInfectedFileWithName(), BastionGuard::if_alive(), infectedFilesBuffer, readOutput(), scanInProgress, and textBuffer.

Referenced by onStartScan(), and readOutput().

resolveFinalDownloadedFile()

std::string ScanPage::resolveFinalDownloadedFile ( const std::string & path )

private

References cloudCheckMalwareBazaar(), cloudCheckMalwareBazaarWorker(), handleInfectedFile(), handleInfectedFiles(), handleInfectedFileWithName(), logMessage(), onAurPkgbuildDetected(), safeExists(), scanAurAuto(), and showAlertWindow().

safeExists()

bool ScanPage::safeExists ( const std::string & p )

privatenoexcept

Definition at line 1334 of file ScanPage.cpp.

{
    try { return fs::exists(p); }
    catch (...) { return false; }
}

Referenced by resolveFinalDownloadedFile().

saveCloudConfig()

void ScanPage::saveCloudConfig ( )

private

Definition at line 532 of file ScanPage.cpp.

{
    std::string dir = Glib::get_home_dir() + "/.config/BastionGuard";
    std::string path = dir + "/cloud.conf";
 
    try {
        fs::create_directories(dir);
 
        std::ofstream f(path);
        f << "malware_bazaar_api_key=" << malwareBazaarApiKey << "\n";
 
        enqueueLog(_("💾 API Key salvata in cloud.conf"));
        globalMalwareBazaarApiKey = malwareBazaarApiKey;
    }
    catch (...) {
        enqueueLog(_("❌ Errore salvataggio cloud.conf"));
    }
}

References _, enqueueLog(), globalMalwareBazaarApiKey, and malwareBazaarApiKey.

Referenced by onApiKeySaveClicked().

saveConfig()

void ScanPage::saveConfig ( )

private

Definition at line 314 of file ScanPage.cpp.

                          {
    try {
        fs::create_directories(Glib::get_home_dir() + "/.local/share/BastionGuard");
        json cfg;
        cfg["auto_scan_enabled"] = autoScanEnabled;
        std::ofstream ofs(getConfigPath());
        ofs << cfg.dump(4);
    } catch (...) {}
}

References autoScanEnabled, and getConfigPath().

Referenced by ScanPage().

scanAurAuto()

void ScanPage::scanAurAuto ( const std::string & path )

private

Definition at line 1082 of file ScanPage.cpp.

{
    if (!fs::exists(path)) {
        enqueueLog(_("❌ PKGBUILD non trovato: ") + path);
        return;
    }
 
    enqueueLog(_("🦠 Scansione AUR: ") + path);
 
    std::vector<std::string> argv = {
        "clamdscan",
        "--fdpass",
        "--no-summary",
        "--infected",
        path
    };
 
    try {
        auto proc = Gio::Subprocess::create(
            argv,
            Gio::Subprocess::Flags::STDOUT_PIPE
        );
 
        auto out = proc->get_stdout_pipe();
        auto ds = Gio::DataInputStream::create(out);
 
        ds->read_line_async(
            [this, ds, path](const Glib::RefPtr<Gio::AsyncResult>& res) {
                try {
                    std::string line;
                    bool ok = ds->read_line_finish(res, line);
 
                    if (ok && line.find("FOUND") != std::string::npos) {
 
                        size_t pos = line.find(": ");
                        size_t end = line.find(" FOUND");
 
                        std::string virus = "Sconosciuto";
                        if (pos != std::string::npos && end != std::string::npos)
                            virus = line.substr(pos + 2, end - (pos + 2));
 
                        auto alive = alive_;
                        Glib::signal_idle().connect_once([this, alive, path, virus]() {
                            BastionGuard::if_alive(alive, [this, &path, &virus]() {
                                handleInfectedFileWithName(path, virus);
                            });
                        });
 
                        return;
                    }
 
                    auto alive = alive_;
                    Glib::signal_idle().connect_once([this, alive, path]() {
                        BastionGuard::if_alive(alive, [this, &path]() {
                            enqueueLog(_("✅ PKGBUILD pulito: ") + path);
                        });
                    });
                }
                catch (...) {
                    enqueueLog(_("❌ Errore lettura output AUR"));
                }
            },
            Glib::RefPtr<Gio::Cancellable>(),
                            Glib::PRIORITY_DEFAULT
        );
    }
    catch (...) {
        enqueueLog(_("❌ Errore avvio clamdscan per PKGBUILD"));
    }
}

References _, alive_, enqueueLog(), handleInfectedFileWithName(), and BastionGuard::if_alive().

Referenced by onAurPkgbuildDetected(), and resolveFinalDownloadedFile().

scanFileAutomatically()

void ScanPage::scanFileAutomatically ( const std::string & filepath )

private

Definition at line 760 of file ScanPage.cpp.

{
    if (!autoScanEnabled) return;
    if (!fs::exists(filepath)) return;
 
    if (!fs::is_regular_file(filepath)) {
        enqueueLog(_("📁 Ignorato (non è un file regolare): ") + filepath);
        return;
    }
 
    try {
        std::uintmax_t size = fs::file_size(filepath);
        if (size < 64) {
            enqueueLog(_("⏳ File troppo piccolo, potrebbe essere ancora in scrittura: ") + filepath);
            return;
        }
    }
    catch (...) {
        enqueueLog(_("❌ Impossibile determinare dimensione file: ") + filepath);
        return;
    }
 
    try {
        auto size = fs::file_size(filepath);
        auto timep = fs::last_write_time(filepath).time_since_epoch().count();
 
        std::string key = filepath + "_" + std::to_string(size) + "_" + std::to_string(timep);
 
        if (recentlyScanned.count(key)) return;
        recentlyScanned.insert(key);
 
        Glib::signal_timeout().connect_once([key]() {
            recentlyScanned.erase(key);
        }, 5000);
 
        enqueueLog(_("🔍 Scansione automatica per: ") + filepath);
 
        std::vector<std::string> argv = {
            "clamdscan",
            "--fdpass",
            "--no-summary",
            "--infected",
            filepath
        };
 
        auto proc = Gio::Subprocess::create(
            argv,
            Gio::Subprocess::Flags::STDOUT_PIPE
        );
 
        auto out = proc->get_stdout_pipe();
        auto ds = Gio::DataInputStream::create(out);
 
        auto reader = std::make_shared<std::function<void()>>();
        *reader = [this, ds, filepath, reader]() {
            ds->read_line_async(
                [this, ds, filepath, reader](const Glib::RefPtr<Gio::AsyncResult>& res) {
                    try {
                        std::string line;
                        bool ok = ds->read_line_finish(res, line);
 
                        // EOF: ClamAV non ha trovato nulla
                        if (!ok) {
                            auto alive = alive_;
                            Glib::signal_idle().connect_once([this, alive, filepath]() {
                                BastionGuard::if_alive(alive, [this, &filepath]() {
                                    enqueueLog(_("⬜ ClamAV pulito, avvio controllo cloud..."));
                                    cloudCheckMalwareBazaar(filepath);
                                });
                            });
                            return;
                        }
 
                        // Trovato malware
                        if (line.find("FOUND") != std::string::npos) {
                            size_t pos = line.find(": ");
                            size_t end = line.find(" FOUND");
 
                            std::string virus = "Sconosciuto";
                            if (pos != std::string::npos && end != std::string::npos)
                                virus = line.substr(pos + 2, end - (pos + 2));
 
                            auto alive = alive_;
                            Glib::signal_idle().connect_once([this, alive, filepath, virus]() {
                                BastionGuard::if_alive(alive, [this, &filepath, &virus]() {
                                    handleInfectedFileWithName(filepath, virus);
                                });
                            });
                            return;
                        }
 
                        // Continua a leggere fino a EOF
                        (*reader)();
                    }
                    catch (const Glib::Error& ex) {
                        enqueueLog(std::string(_("❌ Errore scansione automatica: ")) + ex.what());
                    }
                    catch (const std::exception& ex) {
                        enqueueLog(std::string(_("❌ Eccezione scansione automatica: ")) + ex.what());
                    }
                    catch (...) {
                        enqueueLog(_("❌ Errore scansione automatica"));
                    }
                },
                Glib::RefPtr<Gio::Cancellable>(),
                                Glib::PRIORITY_DEFAULT
            );
        };
 
        (*reader)();
    }
    catch (const std::exception& ex) {
        enqueueLog(std::string(_("❌ Errore accesso file: ")) + ex.what());
    }
}

References _, alive_, autoScanEnabled, cloudCheckMalwareBazaar(), enqueueLog(), handleInfectedFileWithName(), BastionGuard::if_alive(), and recentlyScanned.

Referenced by handleInotifyFileEvent().

showAlertWindow()

void ScanPage::showAlertWindow ( const std::string & file, const std::string & family )

private

Definition at line 1324 of file ScanPage.cpp.

{
    Utils::show_message(
        &parentWindow,
        _("Minaccia rilevata:\n") + file + _("\nTipo: ") + family,
        Gtk::MessageType::WARNING
    );
}

References _, parentWindow, and Utils::show_message().

Referenced by resolveFinalDownloadedFile().

showCloudPrivacyDisclaimer()

void ScanPage::showCloudPrivacyDisclaimer ( )

private

Definition at line 1346 of file ScanPage.cpp.

{
    auto *dialog = new Gtk::Window();
    dialog->set_title("");
    dialog->set_default_size(560, 300);
    dialog->set_resizable(false);
    dialog->set_modal(false);
    dialog->add_css_class("app-dialog");
    dialog->add_css_class("main-window");
    dialog->add_css_class("app-window");
 
    /* CSS globale */
    try {
        auto css = Gtk::CssProvider::create();
        css->load_from_path(resource("BastionGuard.css"));
        auto display = Gdk::Display::get_default();
        Gtk::StyleContext::add_provider_for_display(
            display, css,
            GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    } catch (...) {}
 
    /* Header custom */
    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_box = Gtk::make_managed<Gtk::Box>(
        Gtk::Orientation::HORIZONTAL);
    close_box->set_margin_end(6);
 
    try {
        auto icon = Gdk::Pixbuf::create_from_file(
            resource("icon-close.png"), 28, 28, true);
        auto *btn = Gtk::make_managed<Gtk::Button>();
        btn->set_child(
            *Gtk::make_managed<Gtk::Image>(icon));
        btn->add_css_class("header-button");
        btn->signal_clicked().connect(
            [dialog]() { dialog->close(); delete dialog; });
        close_box->append(*btn);
    } catch (...) {}
 
    header->pack_end(*close_box);
 
    auto *wrap =
    Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    wrap->append(*header);
    dialog->set_titlebar(*wrap);
 
    /* Contenuto */
    auto *vbox = Gtk::make_managed<Gtk::Box>(
        Gtk::Orientation::VERTICAL, 14);
    vbox->set_margin(24);
 
    auto title = Gtk::make_managed<Gtk::Label>(
        _("🔐 Privacy – Controllo Cloud"));
    title->add_css_class("title");
    title->set_halign(Gtk::Align::CENTER);
 
    auto msg = Gtk::make_managed<Gtk::Label>(_(
        "BastionGuard NON carica alcun file online.\n\n"
        "• Nessun contenuto locale viene trasmesso\n"
        "• Viene calcolato solo l’hash SHA256 del file\n"
        "• L’hash è confrontato con database pubblici\n"
        "• Nessun percorso o dato personale viene inviato\n"
        "• La API Key resta salvata esclusivamente in locale\n\n"
        "Il controllo cloud è una verifica di reputazione, "
        "non un upload del file.")
    );
    msg->set_wrap(true);
    msg->set_justify(Gtk::Justification::CENTER);
    msg->set_halign(Gtk::Align::CENTER);
 
    auto closeBtn =
    Gtk::make_managed<Gtk::Button>("Ho capito");
    closeBtn->add_css_class("btn-success");
    closeBtn->set_halign(Gtk::Align::CENTER);
    closeBtn->signal_clicked().connect(
        [dialog]() { dialog->close(); delete dialog; });
 
    vbox->append(*title);
    vbox->append(*msg);
    vbox->append(*closeBtn);
 
    dialog->set_child(*vbox);
    dialog->present();
}

References _, and resource().

Referenced by ScanPage().

Member Data Documentation

alive_

BastionGuard::AliveFlag ScanPage::alive_ = BastionGuard::make_alive_flag()

private

Definition at line 166 of file ScanPage.hpp.

Referenced by cloudCheckMalwareBazaar(), cloudCheckMalwareBazaarWorker(), readOutput(), scanAurAuto(), scanFileAutomatically(), and ~ScanPage().

alreadyWatched

std::unordered_set<std::string> ScanPage::alreadyWatched

private

Definition at line 123 of file ScanPage.hpp.

Referenced by addInotifyRecursive(), and disableAllMonitors().

apiKeyActionsBox

Gtk::Box ScanPage::apiKeyActionsBox {Gtk::Orientation::HORIZONTAL, 6}

private

Definition at line 60 of file ScanPage.hpp.

Referenced by ScanPage().

apiKeyBox

Gtk::Box ScanPage::apiKeyBox {Gtk::Orientation::HORIZONTAL, 6}

private

Definition at line 68 of file ScanPage.hpp.

Referenced by ScanPage().

apiKeyEntry

Gtk::Entry ScanPage::apiKeyEntry

private

Definition at line 69 of file ScanPage.hpp.

Referenced by loadCloudConfig(), onApiKeySaveClicked(), onToggleApiKeyVisibility(), and ScanPage().

apiKeySizeGroup

Glib::RefPtr<Gtk::SizeGroup> ScanPage::apiKeySizeGroup

private

Definition at line 61 of file ScanPage.hpp.

Referenced by ScanPage().

apiKeyVisible

bool ScanPage::apiKeyVisible = false

private

Definition at line 74 of file ScanPage.hpp.

Referenced by onToggleApiKeyVisibility().

autoScanBox

Gtk::Box ScanPage::autoScanBox {Gtk::Orientation::HORIZONTAL, 6}

private

Definition at line 51 of file ScanPage.hpp.

Referenced by ScanPage().

autoScanEnabled

bool ScanPage::autoScanEnabled = true

private

Definition at line 54 of file ScanPage.hpp.

Referenced by handleInotifyFileEvent(), loadConfig(), saveConfig(), scanFileAutomatically(), and ScanPage().

autoScanLabel

Gtk::Label ScanPage::autoScanLabel

private

Definition at line 52 of file ScanPage.hpp.

Referenced by ScanPage().

autoScanSwitch

Gtk::Switch ScanPage::autoScanSwitch

private

Definition at line 53 of file ScanPage.hpp.

Referenced by loadConfig(), and ScanPage().

btnApiKeySave

Gtk::Button ScanPage::btnApiKeySave {"Salva"}

private

Definition at line 71 of file ScanPage.hpp.

Referenced by ScanPage().

btnChooseFile

Gtk::Button ScanPage::btnChooseFile {_("Seleziona file")}

private

Definition at line 48 of file ScanPage.hpp.

Referenced by ScanPage().

btnChooseFolder

Gtk::Button ScanPage::btnChooseFolder {_("Seleziona cartella")}

private

Definition at line 47 of file ScanPage.hpp.

Referenced by ScanPage().

btnPrivacy

Gtk::Button ScanPage::btnPrivacy

private

Definition at line 72 of file ScanPage.hpp.

Referenced by ScanPage().

btnScan

Gtk::Button ScanPage::btnScan {_("Scansiona")}

private

Definition at line 49 of file ScanPage.hpp.

Referenced by ScanPage().

btnShowApiKey

Gtk::Button ScanPage::btnShowApiKey

private

Definition at line 70 of file ScanPage.hpp.

Referenced by onToggleApiKeyVisibility(), and ScanPage().

buttonBox

Gtk::Box ScanPage::buttonBox {Gtk::Orientation::HORIZONTAL, 5}

private

Definition at line 46 of file ScanPage.hpp.

Referenced by ScanPage().

dataStream

Glib::RefPtr<Gio::DataInputStream> ScanPage::dataStream

private

Definition at line 65 of file ScanPage.hpp.

Referenced by onStartScan(), and readOutput().

fileListBox

Gtk::ListBox ScanPage::fileListBox

private

Definition at line 59 of file ScanPage.hpp.

Referenced by addFileToList(), onStartScan(), and ScanPage().

infectedFilesBuffer

std::vector<std::string> ScanPage::infectedFilesBuffer

private

Definition at line 96 of file ScanPage.hpp.

Referenced by onStartScan(), and readOutput().

inotifyFd

int ScanPage::inotifyFd = -1

private

Definition at line 116 of file ScanPage.hpp.

Referenced by addInotifyRecursive(), disableAllMonitors(), onInotifyEvent(), and ScanPage().

inotifySource

Glib::RefPtr<Glib::IOSource> ScanPage::inotifySource

private

Definition at line 117 of file ScanPage.hpp.

Referenced by ScanPage().

knownDownloadDirs

std::vector<std::string> ScanPage::knownDownloadDirs

private

Definition at line 110 of file ScanPage.hpp.

Referenced by enableAutoScanDownloads(), isOutsideKnownDownloadDirs(), and ScanPage().

logFlushScheduled

bool ScanPage::logFlushScheduled = false

private

Definition at line 81 of file ScanPage.hpp.

Referenced by enqueueLog(), and flushLog().

logMutex

std::mutex ScanPage::logMutex

private

Definition at line 79 of file ScanPage.hpp.

Referenced by enqueueLog(), and flushLog().

malwareBazaarApiKey

std::string ScanPage::malwareBazaarApiKey

private

Definition at line 75 of file ScanPage.hpp.

Referenced by loadCloudConfig(), onApiKeySaveClicked(), and saveCloudConfig().

parentWindow

Gtk::Window& ScanPage::parentWindow

private

Definition at line 43 of file ScanPage.hpp.

Referenced by cloudCheckMalwareBazaarWorker(), handleInfectedFiles(), handleInfectedFileWithName(), onChooseFile(), onChooseFolder(), ScanPage(), and showAlertWindow().

pendingLog

std::vector<std::string> ScanPage::pendingLog

private

Definition at line 80 of file ScanPage.hpp.

Referenced by enqueueLog(), and flushLog().

scanInProgress

bool ScanPage::scanInProgress = false

private

Definition at line 97 of file ScanPage.hpp.

Referenced by onStartScan(), and readOutput().

selectedPath

std::string ScanPage::selectedPath

private

Definition at line 95 of file ScanPage.hpp.

Referenced by onChooseFileFinish(), onChooseFolderFinish(), and onStartScan().

stdoutStream

Glib::RefPtr<Gio::InputStream> ScanPage::stdoutStream

private

Definition at line 64 of file ScanPage.hpp.

Referenced by onStartScan().

subprocess

Glib::RefPtr<Gio::Subprocess> ScanPage::subprocess

private

Definition at line 63 of file ScanPage.hpp.

Referenced by onStartScan().

textBuffer

Glib::RefPtr<Gtk::TextBuffer> ScanPage::textBuffer

private

Definition at line 57 of file ScanPage.hpp.

Referenced by flushLog(), logMessage(), onStartScan(), readOutput(), and ScanPage().

textView

Gtk::TextView ScanPage::textView

private

Definition at line 56 of file ScanPage.hpp.

Referenced by ScanPage().

watchMap

std::unordered_map<int, std::string> ScanPage::watchMap

private

Definition at line 120 of file ScanPage.hpp.

Referenced by addInotifyRecursive(), disableAllMonitors(), and onInotifyEvent().

---

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

• BastionGuard/src/ScanPage.hpp
• BastionGuard/src/ScanPage.cpp