LeakMonitor.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 "LeakMonitor.hpp"
 
#include "../core/LeakAggregator.hpp"
#include "../providers/HibpProvider.hpp"
#include "../providers/LeakCheckProvider.hpp"
#include "../utils/HashUtil.hpp"
#include "../utils/IdentityLeakConfig.hpp"
#include <glib/gi18n.h>
#include <chrono>
#include <memory>
 
LeakMonitor::LeakMonitor(
    const std::string& e,
    NotifyFn n)
    : email(e),
      notify(std::move(n)),
      running(false)
{
}
 
LeakMonitor::~LeakMonitor()
{
    stop();
}
 
void LeakMonitor::start()
{
    if (running)
        return;
 
    running = true;
    worker = std::thread(&LeakMonitor::loop, this);
}
 
void LeakMonitor::stop()
{
    running = false;
 
    if (worker.joinable())
        worker.join();
}
 
void LeakMonitor::loop()
{
    LeakAggregator aggregator;
 
 
    const std::string hibpApiKey =
        IdentityLeakConfig::hibpApiKey();
 
    const bool hibpEnabled = !hibpApiKey.empty();
 
    if (hibpEnabled) {
        aggregator.addProvider(
            std::make_unique<HibpProvider>(hibpApiKey));
    }
 
    // LeakCheck SEMPRE disponibile (fallback)
    aggregator.addProvider(
        std::make_unique<LeakCheckProvider>());
 
    const std::string emailHash =
        HashUtil::sha256(email);
 
    if (hibpEnabled) {
        notify(_("Monitor Identity Leak attivo (HIBP + LeakCheck)"));
    } else {
        notify(_(
            "⚠ Monitor Identity Leak attivo in modalità LIMITATA "
            "(solo LeakCheck, API HIBP mancante)"));
    }
 
 
    while (running) {
 
        try {
            auto leaks = aggregator.queryAll(email);
 
            if (!leaks.empty()) {
 
                if (hibpEnabled) {
                    notify(_(
                        "⚠ Nuova violazione rilevata per identità: ") +
                        emailHash);
                } else {
                    notify(_(
                        "⚠ Possibile esposizione rilevata "
                        "(fonte LeakCheck, verifica manuale consigliata)"));
                }
            }
        }
        catch (const std::exception& ex) {
            notify(
                std::string(_("❌ Errore monitor Identity Leak: ")) +
                ex.what());
        }
 
        for (int i = 0; i < 24 * 60 && running; ++i) {
            std::this_thread::sleep_for(
                std::chrono::minutes(1));
        }
    }
 
    notify(_("Monitor Identity Leak fermato"));
}