PasswordManagerPage.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 "PasswordManagerPage.hpp"
#include "PasswordDialogs.hpp"
#include "PasswordImportDialog.hpp"
#include "PasswordVaultView.hpp"
 
#include <glibmm/i18n.h>
#include <algorithm>
#include <cctype>
 
// ─── Costruttore ─────────────────────────────────────────────────────────────
 
PasswordManagerPage::PasswordManagerPage()
: Gtk::Box(Gtk::Orientation::VERTICAL, 6),
  securityBanner_(Gtk::Orientation::HORIZONTAL, 8),
  topBar_(Gtk::Orientation::HORIZONTAL, 8),
  unlockButton_(_("🔓  Sblocca vault")),
  lockButton_(_("🔒  Blocca")),
  stateBox_(Gtk::Orientation::HORIZONTAL, 0),
  actionBar_(Gtk::Orientation::HORIZONTAL, 8),
  addButton_(_("＋  Nuova")),
  importButton_(_("⬆  Importa")),
  vaultViewButton_(_("🗄  Vault")),
  refreshButton_(_("↺  Aggiorna")),
  deleteAllButton_(_("🗑  Elimina tutto")),
  entriesBox_(Gtk::Orientation::VERTICAL, 6)
{
    auto cssProvider = Gtk::CssProvider::create();
    Gtk::StyleContext::add_provider_for_display(
        Gdk::Display::get_default(),
        cssProvider,
        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
 
    buildUi();
    vault_.initialize();
 
    unlockButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onUnlockClicked));
    lockButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onLockClicked));
    addButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onAddClicked));
    importButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onImportClicked));
    vaultViewButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onVaultViewClicked));
    refreshButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onRefreshClicked));
    deleteAllButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onDeleteAllClicked));
    searchEntry_.signal_search_changed().connect(sigc::mem_fun(*this, &PasswordManagerPage::onSearchChanged));
 
    reload();
}
 
PasswordManagerPage::~PasswordManagerPage() {
    if (alive_) alive_->store(false, std::memory_order_release);
}
 
 
void PasswordManagerPage::buildUi() {
    buffer_ = Gtk::TextBuffer::create();
    outputView_.set_buffer(buffer_);
    outputView_.set_editable(false);
    outputView_.set_monospace(true);
 
    set_margin_top(8);
    set_margin_bottom(8);
    set_margin_start(8);
    set_margin_end(8);
 
    securityBanner_.get_style_context()->add_class("security-banner");
    securityBanner_.get_style_context()->add_class("alert-info");
    securityIcon_.set_text("🔐");
    securityBanner_.append(securityIcon_);
 
    securityLabel_.set_markup(_(
    "<b>Protezione avanzata AES-256-GCM</b> — "
    "Le password sono cifrate con AES-256-GCM e la chiave è derivata dalla master password "
    "tramite PBKDF2-SHA256 (100.000 iterazioni). Il file cifrato include un tag di "
    "autenticazione: qualsiasi manipolazione esterna renderà il vault permanentemente illeggibile."
    ));
    securityLabel_.set_wrap(true);
    securityLabel_.set_xalign(0.0f);
    securityLabel_.set_hexpand(true);
    securityBanner_.append(securityLabel_);
 
    auto* dangerBanner = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    dangerBanner->get_style_context()->add_class("security-banner");
    dangerBanner->get_style_context()->add_class("alert-danger");
 
    auto* dangerIcon = Gtk::make_managed<Gtk::Label>();
    dangerIcon->set_text("⚠️");
    dangerBanner->append(*dangerIcon);
 
    auto* dangerLabel = Gtk::make_managed<Gtk::Label>();
    dangerLabel->set_markup(_(
    "<b>Attenzione:</b> — L'esportazione del vault salva il file CSV con password in chiaro. "
    "Salvare il file in un luogo sicuro e non accessibile."
    ));
    dangerLabel->set_wrap(true);
    dangerLabel->set_xalign(0.0f);
    dangerLabel->set_hexpand(true);
    dangerBanner->append(*dangerLabel);
 
    topBar_.set_margin_bottom(4);
    topBar_.append(unlockButton_);
    topBar_.append(lockButton_);
 
    auto* spacer1 = Gtk::make_managed<Gtk::Box>();
    spacer1->set_hexpand(true);
    topBar_.append(*spacer1);
    stateBox_.set_margin_start(4);
    stateLabel_.set_text(_("🔒  Vault bloccato"));
    stateBox_.append(stateLabel_);
    stateBox_.get_style_context()->add_class("alert-success");
    topBar_.append(stateBox_);
    actionBar_.set_margin_bottom(4);
 
    addButton_.get_style_context()->add_class("suggested-action");
    actionBar_.append(addButton_);
 
    {
        importButton_.get_style_context()->add_class("suggested-action");
        auto p = Gtk::CssProvider::create();
        p->load_from_data(
            "button.suggested-action#importBtn {"
            "  background:linear-gradient(to bottom,#33d17a,#26a269);"
            "  color:white;font-weight:bold;"
            "  padding:6px 16px;border-radius:6px;"
            "  border:1px solid #1e8449;"
            "}");
        importButton_.set_name("importBtn");
        importButton_.get_style_context()->add_provider(p, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    }
    actionBar_.append(importButton_);
    {
        vaultViewButton_.get_style_context()->add_class("suggested-action");
        auto p = Gtk::CssProvider::create();
        p->load_from_data(
            "button.suggested-action#vaultBtn {"
            "  background:linear-gradient(to bottom,#3584e4,#1c71d8);"
            "  color:white;font-weight:bold;"
            "  padding:6px 16px;border-radius:6px;"
            "  border:1px solid #1558b0;"
            "}");
        vaultViewButton_.set_name("vaultBtn");
        vaultViewButton_.get_style_context()->add_provider(p, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    }
    actionBar_.append(vaultViewButton_);
    actionBar_.append(refreshButton_);
 
    auto* spacer2 = Gtk::make_managed<Gtk::Box>();
    spacer2->set_hexpand(true);
    actionBar_.append(*spacer2);
 
    deleteAllButton_.get_style_context()->add_class("destructive-action");
    actionBar_.append(deleteAllButton_);
 
    searchEntry_.set_placeholder_text(_("Cerca credenziali..."));
    searchEntry_.set_size_request(200, -1);
    actionBar_.append(searchEntry_);
 
    auto* sep = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
 
    listScrolled_.set_child(entriesBox_);
    listScrolled_.set_expand(true);
 
    logScrolled_.set_child(outputView_);
    logScrolled_.set_min_content_height(100);
    logScrolled_.set_expand(false);
 
    append(securityBanner_);
    append(*dangerBanner);
    append(topBar_);
    append(actionBar_);
    append(*sep);
    append(listScrolled_);
    append(logScrolled_);
}
 
 
 
 
 
void PasswordManagerPage::setVaultState(bool unlocked, const std::string& msg) {
    auto ctx = stateBox_.get_style_context();
    ctx->remove_class("alert-success");
    ctx->remove_class("alert-danger");
 
    if (unlocked) {
        ctx->add_class("alert-danger");
        stateLabel_.set_text(msg.empty() ? _("🔓  Vault sbloccato") : msg);
    } else {
        ctx->add_class("alert-success");
        stateLabel_.set_text(msg.empty() ? _("🔒  Vault bloccato") : msg);
    }
}
 
 
void PasswordManagerPage::reload() {
    entriesCache_ = vault_.loadIndex();
    refreshEntries(searchEntry_.get_text());
}
 
void PasswordManagerPage::refreshEntries(const std::string& filter) {
    while (auto* child = entriesBox_.get_first_child())
        entriesBox_.remove(*child);
 
    std::string needle = filter;
    std::transform(needle.begin(), needle.end(), needle.begin(), ::tolower);
 
    for (const auto& entry : entriesCache_) {
        std::string hay = entry.name + " " + entry.username + " " + entry.url + " " + entry.notes;
        std::transform(hay.begin(), hay.end(), hay.begin(), ::tolower);
        if (!needle.empty() && hay.find(needle) == std::string::npos) continue;
        createEntryRow(entry);
    }
}
 
void PasswordManagerPage::createEntryRow(const PasswordEntry& entry) {
    auto* row = Gtk::make_managed<PasswordSearchRow>(entry);
    row->signal_reveal().connect([this](const PasswordEntry& e) { onRevealEntry(e); });
    row->signal_edit().connect([this](const PasswordEntry& e)   { onEditEntry(e); });
    row->signal_delete().connect([this](const PasswordEntry& e) { onDeleteEntry(e); });
    entriesBox_.append(*row);
}
 
 
void PasswordManagerPage::onUnlockClicked() {
 
    auto* parent = getParentWindow();
    if (!parent) { logSafe(_("Impossibile trovare la finestra padre.\n")); return; }
 
    if (vault_.isFirstRun()) {
        auto* dialog = Gtk::make_managed<Gtk::Dialog>(_("Crea master password"), *parent, true);
        dialog->get_content_area()->set_margin(12);
        dialog->get_content_area()->set_spacing(8);
 
        auto* infoLabel = Gtk::make_managed<Gtk::Label>(
            _("Prima configurazione: scegli una master password.\n"
              "Minimo 8 caratteri. Non può essere recuperata se dimenticata."));
        infoLabel->set_wrap(true);
        infoLabel->set_xalign(0.0f);
        infoLabel->get_style_context()->add_class("dim-label");
 
        auto* entry1 = Gtk::make_managed<Gtk::Entry>();
        entry1->set_placeholder_text(_("Nuova master password"));
        entry1->set_visibility(false);
        entry1->set_input_purpose(Gtk::InputPurpose::PASSWORD);
 
        auto* entry2 = Gtk::make_managed<Gtk::Entry>();
        entry2->set_placeholder_text(_("Conferma master password"));
        entry2->set_visibility(false);
        entry2->set_input_purpose(Gtk::InputPurpose::PASSWORD);
        entry2->set_activates_default(true);
 
        auto* strengthLabel = Gtk::make_managed<Gtk::Label>("");
        strengthLabel->set_xalign(0.0f);
 
        dialog->get_content_area()->append(*infoLabel);
        dialog->get_content_area()->append(*entry1);
        dialog->get_content_area()->append(*entry2);
        dialog->get_content_area()->append(*strengthLabel);
        dialog->add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
        dialog->add_button(_("Crea vault"), Gtk::ResponseType::OK);
        dialog->set_default_response(Gtk::ResponseType::OK);
 
        entry1->signal_changed().connect([entry1, strengthLabel]() {
            const auto pwd = entry1->get_text();
            const size_t len = pwd.size();
            bool hasUpper = false, hasLower = false, hasDigit = false, hasSymbol = false;
            for (char c : pwd) {
                if (std::isupper(c))      hasUpper  = true;
                else if (std::islower(c)) hasLower  = true;
                else if (std::isdigit(c)) hasDigit  = true;
                else                      hasSymbol = true;
            }
            const int score = (len >= 8) + (len >= 12) + hasUpper + hasLower + hasDigit + hasSymbol;
            std::string markup;
            if (len == 0)        markup = "";
            else if (score <= 2) markup = "<span foreground='red'>⚠ Debole</span>";
            else if (score <= 4) markup = "<span foreground='orange'>◑ Media</span>";
            else                 markup = "<span foreground='green'>✔ Forte</span>";
            strengthLabel->set_markup(markup);
        });
 
        dialog->signal_response().connect([this, dialog, entry1, entry2](int response) {
            if (response == Gtk::ResponseType::OK) {
                const auto pwd1 = entry1->get_text();
                const auto pwd2 = entry2->get_text();
                if (pwd1 != pwd2) {
                    logSafe(_("Le password non coincidono.\n"));
                } else if (pwd1.size() < 8) {
                    logSafe(_("La master password deve essere di almeno 8 caratteri.\n"));
                } else if (vault_.createMasterPassword(pwd1)) {
                    setVaultState(true, _("🔓  Vault creato e sbloccato"));
                    logSafe(_("Vault creato. Master password impostata.\n"));
                } else {
                    logSafe(_("Errore durante la creazione del vault.\n"));
                }
            }
            dialog->hide();
        });
        dialog->present();
 
    } else {
        auto* dialog = Gtk::make_managed<Gtk::Dialog>(_("Sblocca vault"), *parent, true);
        auto* entry  = Gtk::make_managed<Gtk::Entry>();
        entry->set_placeholder_text(_("Master password"));
        entry->set_visibility(false);
        entry->set_input_purpose(Gtk::InputPurpose::PASSWORD);
        entry->set_activates_default(true);
        dialog->get_content_area()->set_margin(12);
        dialog->get_content_area()->append(*entry);
        dialog->add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
        dialog->add_button(_("Sblocca"), Gtk::ResponseType::OK);
        dialog->set_default_response(Gtk::ResponseType::OK);
 
        dialog->signal_response().connect([this, dialog, entry](int response) {
            if (response == Gtk::ResponseType::OK) {
                if (vault_.unlock(entry->get_text())) {
                    setVaultState(true, _("🔓  Vault sbloccato — caricamento cache…"));
                    logSafe(_("Vault sbloccato. Precaricamento password in background…\n"));
                    Glib::signal_timeout().connect_once([this]() {
                        if (vault_.isUnlocked())
                            setVaultState(true);
                    }, 3000);
                } else {
                    logSafe(_("Password errata.\n"));
                }
            }
            dialog->hide();
        });
        dialog->present();
    }
}
 
 
void PasswordManagerPage::onLockClicked() {
 
    vault_.lock();
    setVaultState(false);
    logSafe(_("Vault bloccato.\n"));
}
 
 
void PasswordManagerPage::onAddClicked() {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto* dialog = new PasswordDialog(*parent, _("Nuova credenziale"));
    dialog->signal_response().connect([this, dialog](int response) {
        if (response == Gtk::ResponseType::OK) {
            PasswordEntry entry = dialog->getEntry();
            if (entry.name.empty()) {
                logSafe(_("Nome credenziale obbligatorio.\n"));
            } else {
                entry.id         = vault_.generateId();
                entry.created_at = vault_.nowIso();
                entry.updated_at = entry.created_at;
                if (vault_.addEntry(entry, dialog->getSecret())) {
                    logSafe(std::string(_("Credenziale aggiunta: ")) + entry.name + "\n");
                    reload();
                } else {
                    logSafe(_("Errore durante il salvataggio.\n"));
                }
            }
        }
        dialog->hide();
        delete dialog;
    });
    dialog->present();
}
 
 
void PasswordManagerPage::onImportClicked() {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima di importare.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto* dialog = new PasswordImportDialog(*parent);
    dialog->signal_import_confirmed().connect(
        [this, dialog](std::vector<PasswordImportDialog::BulkItem> items) {
            dialog->hide();
            if (items.empty()) { delete dialog; return; }
 
            const std::string now = vault_.nowIso();
            for (auto& [entry, pwd] : items) {
                entry.id         = vault_.generateId();
                entry.created_at = now;
                entry.updated_at = now;
                if (entry.name.empty() && !entry.url.empty()) {
                    auto url = entry.url;
                    auto p = url.find("://");
                    if (p != std::string::npos) url = url.substr(p + 3);
                    auto sl = url.find('/');
                    if (sl != std::string::npos) url = url.substr(0, sl);
                    entry.name = url;
                }
            }
 
            vault_.addEntriesBulk(items, [this, dialog](int ok, int fail) {
                logSafe(std::string(_("Import completato: ")) + std::to_string(ok) +
                        std::string(_(" importate")) +
                        (fail > 0 ? (", " + std::to_string(fail) + std::string(_(" fallite"))) : "") +
                        ".\n");
                reload();
                delete dialog;
            });
        });
    dialog->present();
}
 
 
void PasswordManagerPage::onVaultViewClicked() {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
    auto* view = new PasswordVaultView(*parent, vault_);
    view->present();
}
 
 
void PasswordManagerPage::onDeleteAllClicked() {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    const auto count = entriesCache_.size();
    if (count == 0) { logSafe(_("Nessuna credenziale da eliminare.\n")); return; }
 
    auto* confirm1 = new Gtk::MessageDialog(
        *parent, _("Eliminare tutte le credenziali?"),
        false, Gtk::MessageType::WARNING, Gtk::ButtonsType::OK_CANCEL, true);
    confirm1->set_secondary_text(
        std::string(_("Questa operazione eliminerà ")) + std::to_string(count) +
        std::string(_(" credenziali e non può essere annullata.")));
 
    confirm1->signal_response().connect([this, confirm1, parent](int r1) {
        confirm1->hide();
        if (r1 != Gtk::ResponseType::OK) { delete confirm1; return; }
 
        auto* confirm2 = new Gtk::MessageDialog(
            *parent, _("Sei sicuro? L'operazione è irreversibile."),
            false, Gtk::MessageType::ERROR, Gtk::ButtonsType::NONE, true);
        confirm2->set_secondary_text(_("Il file cifrato verrà eliminato definitivamente."));
        confirm2->add_button(_("Annulla"),           Gtk::ResponseType::CANCEL);
        confirm2->add_button(_("Sì, elimina tutto"), Gtk::ResponseType::OK);
        auto* ok_btn = confirm2->get_widget_for_response(Gtk::ResponseType::OK);
        if (ok_btn) ok_btn->get_style_context()->add_class("destructive-action");
 
        confirm2->signal_response().connect([this, confirm2](int r2) {
            confirm2->hide();
            if (r2 == Gtk::ResponseType::OK) {
                logSafe(_("Eliminazione in corso…\n"));
                vault_.deleteAllEntries([this](bool ok) {
                    logSafe(ok ? _("✔ Tutte le credenziali eliminate.\n")
                               : _("Errore durante l'eliminazione.\n"));
                    reload();
                });
            }
            delete confirm2;
        });
        confirm2->present();
        delete confirm1;
    });
    confirm1->present();
}
 
 
void PasswordManagerPage::onRefreshClicked() {
 
    reload();
    logSafe(_("Elenco aggiornato.\n"));
}
 
void PasswordManagerPage::onSearchChanged() {
 
    refreshEntries(searchEntry_.get_text());
}
 
void PasswordManagerPage::onRevealEntry(const PasswordEntry& entry) {
 
    if (!vault_.isUnlocked()) { logSafe(_("Vault bloccato.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto alive = alive_;
    vault_.getSecretAsync(entry.id, [this, alive, entry](std::string secret) {
        if (!alive || !alive->load(std::memory_order_acquire)) return;
        auto* p = getParentWindow();
        if (!p) return;
        auto* reveal = new Gtk::MessageDialog(
            *p, _("Password per: ") + entry.name,
            false, Gtk::MessageType::INFO, Gtk::ButtonsType::CLOSE, true);
        reveal->set_secondary_text(secret, false);
        reveal->signal_response().connect([reveal](int) { reveal->hide(); delete reveal; });
        reveal->present();
    });
}
 
 
void PasswordManagerPage::onEditEntry(const PasswordEntry& entry) {
 
    if (!vault_.isUnlocked()) { logSafe(_("Vault bloccato.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto alive = alive_;
    vault_.getSecretAsync(entry.id, [this, alive, entry](std::string secret) {
        if (!alive || !alive->load(std::memory_order_acquire)) return;
        auto* p = getParentWindow();
        if (!p) return;
        auto* dialog = new PasswordDialog(
            *p, _("Modifica credenziale"), entry, secret);
        dialog->signal_response().connect([this, dialog, entry](int response) {
            if (response == Gtk::ResponseType::OK) {
                PasswordEntry updated = dialog->getEntry();
                updated.id         = entry.id;
                updated.created_at = entry.created_at;
                updated.updated_at = vault_.nowIso();
                if (vault_.updateEntry(updated, dialog->getSecret())) {
                    logSafe(std::string(_("Credenziale aggiornata: ")) + updated.name + "\n");
                    reload();
                } else {
                    logSafe(_("Errore durante l'aggiornamento.\n"));
                }
            }
            dialog->hide();
            delete dialog;
        });
        dialog->present();
    });
}
 
 
void PasswordManagerPage::onDeleteEntry(const PasswordEntry& entry) {
 
    if (!vault_.isUnlocked()) { logSafe(_("Vault bloccato.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto* confirm = new Gtk::MessageDialog(
        *parent, _("Eliminare la credenziale selezionata?"),
        false, Gtk::MessageType::QUESTION, Gtk::ButtonsType::OK_CANCEL, true);
    confirm->set_secondary_text(entry.name);
    confirm->signal_response().connect([this, confirm, entry](int response) {
        if (response == Gtk::ResponseType::OK) {
            if (vault_.deleteEntry(entry.id)) {
                logSafe(std::string(_("Credenziale eliminata: ")) + entry.name + "\n");
                reload();
            } else {
                logSafe(_("Errore durante l'eliminazione.\n"));
            }
        }
        confirm->hide();
        delete confirm;
    });
    confirm->present();
}
 
 
Gtk::Window* PasswordManagerPage::getParentWindow() {
    auto* root = get_root();
    return dynamic_cast<Gtk::Window*>(root);
}
 
void PasswordManagerPage::logSafe(const std::string& msg) {
    auto alive = alive_;
    Glib::signal_idle().connect_once([this, alive, msg]() {
        BastionGuard::if_alive(alive, [this, &msg]() {
            buffer_->insert(buffer_->end(), msg);
        });
    });
}