LeakDatabase Class Reference

#include <LeakDatabase.hpp>

Public Member Functions
	LeakDatabase ()
void	ensureIdentity (const std::string &emailHash)
bool	isNewLeak (const std::string &emailHash, const LeakRecord &record)
void	storeLeak (const std::string &emailHash, const LeakRecord &record)

Private Member Functions
void	open ()
void	initSchema ()

Private Attributes
std::string	dbPath
void *	db
std::mutex	dbMutex

Detailed Description

Definition at line 27 of file LeakDatabase.hpp.

Constructor & Destructor Documentation

LeakDatabase()

LeakDatabase::LeakDatabase

(

)

Definition at line 46 of file LeakDatabase.cpp.

: 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();
}

References db, dbPath, initSchema(), and open().

Member Function Documentation

ensureIdentity()

void LeakDatabase::ensureIdentity

(

const std::string &

emailHash

)

Definition at line 100 of file LeakDatabase.cpp.

{
    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);
}

References db, and dbMutex.

Referenced by LeakCheckWorker::run().

initSchema()

void LeakDatabase::initSchema ( )

private

Definition at line 81 of file LeakDatabase.cpp.

{
    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);
    }
}

References db, dbMutex, and SCHEMA_SQL.

Referenced by LeakDatabase().

isNewLeak()

bool LeakDatabase::isNewLeak	(	const std::string &	emailHash,
		const LeakRecord &	record )

Definition at line 126 of file LeakDatabase.cpp.

{
    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;
}

References LeakRecord::breachDate, LeakRecord::breachName, db, and dbMutex.

open()

void LeakDatabase::open ( )

private

Definition at line 66 of file LeakDatabase.cpp.

{
    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;
}

References _, db, dbMutex, and dbPath.

Referenced by LeakDatabase().

storeLeak()

void LeakDatabase::storeLeak	(	const std::string &	emailHash,
		const LeakRecord &	record )

Definition at line 161 of file LeakDatabase.cpp.

{
    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);
}

References LeakRecord::breachDate, LeakRecord::breachName, db, dbMutex, LeakRecord::description, LeakRecord::provider, and LeakRecord::severity.

Member Data Documentation

db

void* LeakDatabase::db

private

Definition at line 44 of file LeakDatabase.hpp.

Referenced by ensureIdentity(), initSchema(), isNewLeak(), LeakDatabase(), open(), and storeLeak().

dbMutex

std::mutex LeakDatabase::dbMutex

private

Definition at line 45 of file LeakDatabase.hpp.

Referenced by ensureIdentity(), initSchema(), isNewLeak(), open(), and storeLeak().

dbPath

std::string LeakDatabase::dbPath

private

Definition at line 43 of file LeakDatabase.hpp.

Referenced by LeakDatabase(), and open().

---

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

• BastionGuard/src/IdentityLeakPage/storage/LeakDatabase.hpp
• BastionGuard/src/IdentityLeakPage/storage/LeakDatabase.cpp