IdentityLeakPage.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 "IdentityLeakPage.hpp"
#include "../../Resource.hpp"
#include "worker/LeakCheckWorker.hpp"
#include "monitor/LeakMonitor.hpp"
#include "utils/IdentityLeakConfig.hpp"
#include "providers/HibpPasswordProvider.hpp"
#include <sigc++/sigc++.h>
#include <glib/gi18n.h>
 
 
IdentityLeakPage::IdentityLeakPage(Gtk::Window& parent)
: Gtk::Box(Gtk::Orientation::VERTICAL, 12),
  parentWindow(parent)
{
    add_css_class("content");
 
    auto title_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    title_box->add_css_class("secure-headerbar");
    title_box->set_margin_bottom(12);
 
    auto spacer_left = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer_left->set_hexpand(true);
 
    auto title_label = Gtk::make_managed<Gtk::Label>(_("🛡️ Controllo violazioni identità"));
    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);
 
    auto emailBox = Gtk::make_managed<Gtk::Box>(
    Gtk::Orientation::HORIZONTAL, 6);
 
    emailEntry.set_placeholder_text(_("Inserisci email da monitorare"));
    emailEntry.set_hexpand(true);
 
    auto privacyBtn = Gtk::make_managed<Gtk::Button>(_("ℹ️ Privacy"));
    privacyBtn->add_css_class("btn-secondary");
 
    privacyBtn->signal_clicked().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::showPrivacyPopup));
 
    emailBox->append(emailEntry);
    emailBox->append(*privacyBtn);
 
    append(*emailBox);
 
    auto hibpBox = Gtk::make_managed<Gtk::Box>(
        Gtk::Orientation::HORIZONTAL, 6);
 
    apiKeyEntry.set_placeholder_text(_("HIBP API Key"));
    apiKeyEntry.set_visibility(false);
    apiKeyEntry.set_hexpand(true);
    apiKeyEntry.set_text(IdentityLeakConfig::hibpApiKey());
 
    apiToggleButton.set_label(_("Mostra"));
 
    saveHibpButton.set_label(_("Salva"));
 
    apiToggleButton.signal_clicked().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::onToggleApiVisibility));
 
    saveHibpButton.signal_clicked().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::onSaveHibpApi));
 
    hibpBox->append(apiKeyEntry);
    hibpBox->append(apiToggleButton);
    hibpBox->append(saveHibpButton);
    append(*hibpBox);
 
    auto leakCheckBox = Gtk::make_managed<Gtk::Box>(
        Gtk::Orientation::HORIZONTAL, 6);
 
    leakCheckApiEntry.set_placeholder_text(_("LeakCheck API Key"));
    leakCheckApiEntry.set_visibility(false);
    leakCheckApiEntry.set_hexpand(true);
    leakCheckApiEntry.set_text(
        IdentityLeakConfig::leakCheckApiKey());
 
    leakCheckToggleButton.set_label(_("Mostra"));
 
    saveLeakCheckButton.set_label(_("Salva"));
    auto leakCheckInfoBtn =
    Gtk::make_managed<Gtk::Button>(_("⚠️ Info"));
    leakCheckInfoBtn->add_css_class("btn-secondary");
 
    leakCheckInfoBtn->signal_clicked().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::showLeakCheckDisclaimer));
 
    leakCheckToggleButton.signal_clicked().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::onToggleLeakCheckApiVisibility));
 
    saveLeakCheckButton.signal_clicked().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::onSaveLeakCheckApi));
 
    leakCheckBox->append(leakCheckApiEntry);
    leakCheckBox->append(leakCheckToggleButton);
    leakCheckBox->append(saveLeakCheckButton);
    leakCheckBox->append(*leakCheckInfoBtn);
    append(*leakCheckBox);
 
    auto pwdBox = Gtk::make_managed<Gtk::Box>(
        Gtk::Orientation::HORIZONTAL, 6);
 
    passwordEntry.set_placeholder_text(_("Verifica password compromessa"));
    passwordEntry.set_visibility(false);
    passwordEntry.set_hexpand(true);
 
    checkPasswordButton.set_label(_("Verifica password"));
    checkPasswordButton.add_css_class("btn-primary");
 
    checkPasswordButton.signal_clicked().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::onCheckPasswordClicked));
 
    pwdBox->append(passwordEntry);
    pwdBox->append(checkPasswordButton);
    append(*pwdBox);
 
    monitorToggle.set_label(_("Monitor automatico (ogni 24h)"));
    monitorToggle.set_active(
        IdentityLeakConfig::monitorEnabled());
 
    monitorToggle.signal_toggled().connect(
        sigc::mem_fun(*this,
            &IdentityLeakPage::onMonitorToggled));
 
    append(monitorToggle);
 
 
    checkButton.set_label(_("Verifica violazioni"));
    checkButton.add_css_class("btn-primary");
    checkButton.signal_clicked()
        .connect(sigc::mem_fun(*this,
            &IdentityLeakPage::onCheckClicked));
    append(checkButton);
 
    logBuffer = Gtk::TextBuffer::create();
    logView.set_buffer(logBuffer);
    logView.set_editable(false);
    logView.add_css_class("log-card");
 
    logScroller.set_child(logView);
    logScroller.set_policy(
        Gtk::PolicyType::AUTOMATIC,
        Gtk::PolicyType::AUTOMATIC);
    logScroller.set_hexpand(true);
    logScroller.set_vexpand(true);
 
    append(logScroller);
}
 
IdentityLeakPage::~IdentityLeakPage()
{
    if (alive_) alive_->store(false, std::memory_order_release);
 
    stopMonitor();
 
    running = false;
    if (workerThread.joinable())
        workerThread.join();
}
 
 
 
void IdentityLeakPage::appendLog(const Glib::ustring& text)
{
    auto alive = alive_;
    Glib::signal_idle().connect_once(
        [this, alive, text]() {
            BastionGuard::if_alive(alive, [this, &text]() {
                logBuffer->insert(
                    logBuffer->end(),
                    text + "\n");
            });
        });
}
 
 
 
void IdentityLeakPage::onToggleApiVisibility()
{
    bool visible = apiKeyEntry.get_visibility();
    apiKeyEntry.set_visibility(!visible);
    apiToggleButton.set_label(
        visible ? _("Mostra") : _("Nascondi"));
}
 
void IdentityLeakPage::onToggleLeakCheckApiVisibility()
{
    bool visible = leakCheckApiEntry.get_visibility();
    leakCheckApiEntry.set_visibility(!visible);
    leakCheckToggleButton.set_label(
        visible ? _("Mostra") : _("Nascondi"));
}
 
 
void IdentityLeakPage::onSaveHibpApi()
{
    const std::string key = apiKeyEntry.get_text();
    IdentityLeakConfig::setHibpApiKey(key);
 
    appendLog(
        key.empty()
        ? _("⚠ HIBP API rimossa")
        : _("✔ HIBP API salvata"));
}
 
void IdentityLeakPage::onSaveLeakCheckApi()
{
    const std::string key = leakCheckApiEntry.get_text();
    IdentityLeakConfig::setLeakCheckApiKey(key);
 
    appendLog(
        key.empty()
        ? _("⚠ LeakCheck API rimossa")
        : _("✔ LeakCheck API salvata"));
}
 
 
void IdentityLeakPage::startMonitor(const std::string& email)
{
    if (monitorActive)
        return;
 
    appendLog(_("Monitor automatico attivato (24h)"));
 
    monitor = std::make_unique<LeakMonitor>(
        email,
        [this](const std::string& msg) {
            appendLog("[MONITOR] " + msg);
        });
 
    monitor->start();
    monitorActive = true;
}
 
void IdentityLeakPage::stopMonitor()
{
    if (!monitorActive)
        return;
 
    monitor->stop();
    monitor.reset();
    monitorActive = false;
}
 
 
 
void IdentityLeakPage::onMonitorToggled()
{
    bool enabled = monitorToggle.get_active();
    IdentityLeakConfig::setMonitorEnabled(enabled);
 
    if (!enabled) {
        appendLog(_("Monitor automatico disattivato"));
        stopMonitor();
    } else {
        appendLog(_("Monitor automatico abilitato"));
    }
}
 
 
 
void IdentityLeakPage::onCheckClicked()
{
    if (running)
        return;
 
    const std::string email = emailEntry.get_text();
    if (email.empty())
        return;
 
    // A std::thread remains joinable even after its function has returned.
    // Reassigning a joinable std::thread calls std::terminate().
    // running == false means the previous check has finished, so reap it
    // before creating the next worker.
    if (workerThread.joinable())
        workerThread.join();
 
    stopMonitor();
 
    running = true;
    logBuffer->set_text("");
    appendLog(_("Avvio controllo violazioni…"));
 
    try {
        workerThread = std::thread(
            [this, email]() {
                try {
                    LeakCheckWorker worker(
                        email,
                        [this](const std::string& msg) {
                            appendLog(msg);
                        });
 
                    worker.run();
 
                    appendLog(_("Controllo completato."));
 
                    if (IdentityLeakConfig::monitorEnabled())
                        startMonitor(email);
                }
                catch (const std::exception& ex) {
                    appendLog(
                        std::string(_("❌ Errore controllo violazioni: ")) +
                        ex.what());
                }
                catch (...) {
                    appendLog(_("❌ Errore inatteso durante il controllo violazioni"));
                }
 
                running = false;
            });
    }
    catch (const std::exception& ex) {
        running = false;
        appendLog(
            std::string(_("❌ Impossibile avviare il controllo: ")) +
            ex.what());
    }
}
 
void IdentityLeakPage::onCheckPasswordClicked()
{
    const std::string password =
        passwordEntry.get_text();
 
    if (password.empty())
        return;
 
    appendLog(_("🔐 Controllo password (HIBP)…"));
 
    try {
        auto result =
            HibpPasswordProvider::checkPassword(password);
 
        if (result.compromised) {
            appendLog(
                _("❌ Password compromessa – trovata in ") +
                std::to_string(result.count) +
                _(" violazioni"));
            appendLog(
                _("   → Cambiala immediatamente"));
        } else {
            appendLog(
                _("✔ Password NON presente in database noti"));
        }
    }
    catch (const std::exception& ex) {
        appendLog(
            std::string(_("❌ Errore controllo password: ")) +
            ex.what());
    }
 
    passwordEntry.set_text("");
}
 
void IdentityLeakPage::showPrivacyPopup()
{
    auto *dialog = new Gtk::Window();
    dialog->set_title("");
    dialog->set_default_size(520, 260);
    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");
 
    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 *header_wrap =
        Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    header_wrap->append(*header);
    dialog->set_titlebar(*header_wrap);
 
    auto *vbox = Gtk::make_managed<Gtk::Box>(
        Gtk::Orientation::VERTICAL, 14);
    vbox->set_margin(24);
 
    auto title = Gtk::make_managed<Gtk::Label>(
        _("🔐 Tutela della privacy"));
    title->add_css_class("title");
    title->set_halign(Gtk::Align::CENTER);
 
    auto msg = Gtk::make_managed<Gtk::Label>(_(
        "Nessun dato personale viene inviato o memorizzato "
        "da BastionGuard.\n\n"
        "• Le email vengono verificate tramite API ufficiali\n"
        "• Le password NON vengono mai trasmesse\n"
        "• Il controllo password usa solo hash parziali (HIBP Range)\n"
        "• Nessuna informazione viene salvata su server esterni\n\n"
        "Il controllo avviene nel rispetto totale della privacy."));
    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();
}
 
void IdentityLeakPage::showLeakCheckDisclaimer()
{
    auto *dialog = new Gtk::Window();
    dialog->set_title("");
    dialog->set_default_size(540, 280);
    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");
 
    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);
 
    auto *vbox = Gtk::make_managed<Gtk::Box>(
        Gtk::Orientation::VERTICAL, 14);
    vbox->set_margin(24);
 
    auto title = Gtk::make_managed<Gtk::Label>(
        _("⚠️ Avviso su LeakCheck"));
    title->add_css_class("title");
    title->set_halign(Gtk::Align::CENTER);
 
    auto msg = Gtk::make_managed<Gtk::Label>(_(
        "Le API utilizzate da BastionGuard per LeakCheck "
        "NON sono le stesse impiegate dal sito web ufficiale.\n\n"
        "• BastionGuard non è affiliato a LeakCheck\n"
        "• Non esiste alcuna partnership o approvazione implicita\n"
        "• I risultati possono differire da quelli mostrati sul sito\n\n"
        "L’utente è responsabile dell’utilizzo delle API."));
    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();
}