LeakDatabase.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 "LeakDatabase.hpp"
#include <glib/gi18n.h>
#include <sqlite3.h>
#include <filesystem>
#include <stdexcept>
 
namespace fs = std::filesystem;
 
static const char* SCHEMA_SQL = R"SQL(
CREATE TABLE IF NOT EXISTS identity (
    email_hash TEXT PRIMARY KEY,
    first_seen INTEGER DEFAULT (strftime('%s','now'))
);
 
CREATE TABLE IF NOT EXISTS leak (
    email_hash TEXT NOT NULL,
    breach_name TEXT NOT NULL,
    breach_date TEXT NOT NULL,
    severity INTEGER NOT NULL,
    provider TEXT,
    description TEXT,
    PRIMARY KEY (email_hash, breach_name, breach_date)
);
)SQL";
 
LeakDatabase::LeakDatabase()
: db(nullptr)
{
    // getenv("HOME") può restituire NULL (sandbox, setuid, ambiente pulito).
    // std::string(nullptr) è UB: proteggiamoci con un fallback ragionevole.
    const char* home_env = std::getenv("HOME");
    std::string base;
    if (home_env && *home_env) {
        base = std::string(home_env) + "/.local/share/BastionGuard";
    } else {
        base = "/tmp/BastionGuard";
    }
 
    fs::create_directories(base);
    dbPath = base + "/identity_leaks.db";
 
    open();
    initSchema();
}
 
void LeakDatabase::open()
{
    std::lock_guard<std::mutex> lock(dbMutex);
 
    sqlite3* handle = nullptr;
    if (sqlite3_open(dbPath.c_str(), &handle) != SQLITE_OK)
    {
        // Anche se open fallisce, SQLite alloca un handle che va chiuso
        // (documentato in https://sqlite.org/c3ref/open.html).
        if (handle) sqlite3_close(handle);
        throw std::runtime_error(_("SQLite: open failed"));
    }
    db = handle;
}
 
void LeakDatabase::initSchema()
{
    std::lock_guard<std::mutex> lock(dbMutex);
 
    char* err = nullptr;
    if (sqlite3_exec(
        reinterpret_cast<sqlite3*>(db),
        SCHEMA_SQL,
        nullptr,
        nullptr,
        &err) != SQLITE_OK)
    {
        std::string msg = err ? err : "unknown";
        sqlite3_free(err);
        throw std::runtime_error(
            "SQLite schema error: " + msg);
    }
}
 
void LeakDatabase::ensureIdentity(const std::string& emailHash)
{
    std::lock_guard<std::mutex> lock(dbMutex);
 
    const char* sql =
        "INSERT OR IGNORE INTO identity(email_hash) VALUES (?);";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(
            reinterpret_cast<sqlite3*>(db),
            sql,
            -1,
            &stmt,
            nullptr) != SQLITE_OK || !stmt)
    {
        // Se prepare fallisce, stmt è NULL e bind/step andrebbero in crash.
        return;
    }
 
    sqlite3_bind_text(stmt, 1,
        emailHash.c_str(), -1, SQLITE_TRANSIENT);
 
    sqlite3_step(stmt);
    sqlite3_finalize(stmt);
}
 
bool LeakDatabase::isNewLeak(
    const std::string& emailHash,
    const LeakRecord& record)
{
    std::lock_guard<std::mutex> lock(dbMutex);
 
    const char* sql =
        "SELECT 1 FROM leak "
        "WHERE email_hash=? AND breach_name=? AND breach_date=?;";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(
            reinterpret_cast<sqlite3*>(db),
            sql,
            -1,
            &stmt,
            nullptr) != SQLITE_OK || !stmt)
    {
        // prepare fallita: trattiamolo come "nuovo leak" per non perdere notifiche.
        return true;
    }
 
    sqlite3_bind_text(stmt, 1,
        emailHash.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2,
        record.breachName.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3,
        record.breachDate.c_str(), -1, SQLITE_TRANSIENT);
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    return rc != SQLITE_ROW;
}
 
void LeakDatabase::storeLeak(
    const std::string& emailHash,
    const LeakRecord& record)
{
    std::lock_guard<std::mutex> lock(dbMutex);
 
    const char* sql =
        "INSERT INTO leak "
        "(email_hash, breach_name, breach_date, severity, provider, description) "
        "VALUES (?, ?, ?, ?, ?, ?);";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(
            reinterpret_cast<sqlite3*>(db),
            sql,
            -1,
            &stmt,
            nullptr) != SQLITE_OK || !stmt)
    {
        // prepare fallita: non possiamo scrivere, ma non crashiamo.
        return;
    }
 
    sqlite3_bind_text(stmt, 1,
        emailHash.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2,
        record.breachName.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3,
        record.breachDate.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, 4,
        static_cast<int>(record.severity));
    sqlite3_bind_text(stmt, 5,
        record.provider.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6,
        record.description.c_str(), -1, SQLITE_TRANSIENT);
 
    sqlite3_step(stmt);
    sqlite3_finalize(stmt);
}