PasswordVault.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 "PasswordVault.hpp"
 
#include <fstream>
#include <iomanip>
#include <random>
#include <sstream>
#include <ctime>
#include <cstring>
#include <thread>
#include <unordered_set>
 
#include <giomm/file.h>
#include <glibmm/miscutils.h>
#include <glibmm/dispatcher.h>
#include <nlohmann/json.hpp>
#include <openssl/evp.h>
#include <openssl/rand.h>
 
using json = nlohmann::json;
 
static void secureClear(std::string& s) {
    if (!s.empty()) {
        volatile char* p = const_cast<volatile char*>(s.data());
        std::memset(const_cast<char*>(s.data()), 0, s.size());
        (void)p;
        s.clear();
    }
}
 
static std::string toHex(const unsigned char* data, size_t len) {
    std::ostringstream oss;
    oss << std::hex << std::setfill('0');
    for (size_t i = 0; i < len; ++i)
        oss << std::setw(2) << static_cast<int>(data[i]);
    return oss.str();
}
 
static std::string toHex(const std::string& s) {
    return toHex(reinterpret_cast<const unsigned char*>(s.data()), s.size());
}
 
static std::string fromHex(const std::string& hex) {
    std::string out;
    out.reserve(hex.size() / 2);
    for (size_t i = 0; i + 1 < hex.size(); i += 2) {
        try {
            out.push_back(static_cast<char>(std::stoi(hex.substr(i, 2), nullptr, 16)));
        } catch (...) {
            // byte non valido (vault corrotto o non-hex): restituisci vuoto
            // così il caller sa che la decodifica è fallita.
            return {};
        }
    }
    return out;
}
 
static std::string csvEscape(const std::string& s) {
    bool needs = s.find_first_of(",\"\n\r") != std::string::npos;
    if (!needs) return s;
    std::string out = "\"";
    for (char c : s) { if (c == '"') out += "\"\""; else out += c; }
    return out + '"';
}
 
bool PasswordVault::atomicWriteFile(const std::string& path, const std::string& content) {
    const std::string tmp = path + ".tmp";
    {
        std::ofstream out(tmp, std::ios::trunc | std::ios::binary);
        if (!out.good()) return false;
        out << content;
        if (!out.good()) return false;
    }
    return std::rename(tmp.c_str(), path.c_str()) == 0;
}
 
 
bool PasswordVault::aesEncrypt(const std::string& key32,
                                const std::string& nonce12,
                                const std::string& plaintext,
                                std::string& ciphertext,
                                std::string& tag16) const
{
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx) return false;
 
    ciphertext.resize(plaintext.size());
    tag16.resize(16);
 
    int len = 0;
    bool ok = true;
 
    ok = ok && EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr, nullptr, nullptr) == 1;
    ok = ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, 12, nullptr) == 1;
    ok = ok && EVP_EncryptInit_ex(ctx, nullptr, nullptr,
                                   reinterpret_cast<const unsigned char*>(key32.data()),
                                   reinterpret_cast<const unsigned char*>(nonce12.data())) == 1;
    ok = ok && EVP_EncryptUpdate(ctx, nullptr, &len, nullptr, 0) == 1; // no AAD
    if (!plaintext.empty())
        ok = ok && EVP_EncryptUpdate(ctx,
                                      reinterpret_cast<unsigned char*>(ciphertext.data()),
                                      &len,
                                      reinterpret_cast<const unsigned char*>(plaintext.data()),
                                      (int)plaintext.size()) == 1;
    int finalLen = 0;
    ok = ok && EVP_EncryptFinal_ex(ctx,
                                    reinterpret_cast<unsigned char*>(ciphertext.data()) + len,
                                    &finalLen) == 1;
    ok = ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, 16,
                                    reinterpret_cast<void*>(tag16.data())) == 1;
    EVP_CIPHER_CTX_free(ctx);
    return ok;
}
 
bool PasswordVault::aesDecrypt(const std::string& key32,
                                const std::string& nonce12,
                                const std::string& ciphertext,
                                const std::string& tag16,
                                std::string& plaintext) const
{
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx) return false;
 
    plaintext.resize(ciphertext.size());
    int len = 0;
    bool ok = true;
 
    ok = ok && EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr, nullptr, nullptr) == 1;
    ok = ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, 12, nullptr) == 1;
    ok = ok && EVP_DecryptInit_ex(ctx, nullptr, nullptr,
                                   reinterpret_cast<const unsigned char*>(key32.data()),
                                   reinterpret_cast<const unsigned char*>(nonce12.data())) == 1;
    if (!ciphertext.empty())
        ok = ok && EVP_DecryptUpdate(ctx,
                                      reinterpret_cast<unsigned char*>(plaintext.data()),
                                      &len,
                                      reinterpret_cast<const unsigned char*>(ciphertext.data()),
                                      (int)ciphertext.size()) == 1;
    ok = ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, 16,
                                    const_cast<void*>(static_cast<const void*>(tag16.data()))) == 1;
    int finalLen = 0;
    bool authOk = ok && EVP_DecryptFinal_ex(ctx,
                                             reinterpret_cast<unsigned char*>(plaintext.data()) + len,
                                             &finalLen) > 0;
    EVP_CIPHER_CTX_free(ctx);
    if (!authOk) { plaintext.clear(); return false; }
    plaintext.resize(len + finalLen);
    return true;
}
 
std::string PasswordVault::deriveKey(const std::string& saltHex) const {
    const std::string salt = fromHex(saltHex);
    unsigned char key[32];
    PKCS5_PBKDF2_HMAC(masterPassword_.c_str(), (int)masterPassword_.size(),
                       reinterpret_cast<const unsigned char*>(salt.data()), (int)salt.size(),
                       100000, EVP_sha256(), 32, key);
    return std::string(reinterpret_cast<char*>(key), 32);
}
 
std::string PasswordVault::pbkdf2Hex(const std::string& password,
                                      const std::string& saltHex,
                                      int iterations) const {
    const std::string salt = fromHex(saltHex);
    unsigned char out[32];
    PKCS5_PBKDF2_HMAC(password.c_str(), (int)password.size(),
                       reinterpret_cast<const unsigned char*>(salt.data()), (int)salt.size(),
                       iterations, EVP_sha256(), 32, out);
    return toHex(out, 32);
}
 
std::string PasswordVault::generateSaltHex() const {
    unsigned char salt[16];
    RAND_bytes(salt, sizeof(salt));
    return toHex(salt, sizeof(salt));
}
 
std::string PasswordVault::generateNonceHex() const {
    unsigned char nonce[12];
    RAND_bytes(nonce, sizeof(nonce));
    return toHex(nonce, sizeof(nonce));
}
 
 
bool PasswordVault::saveSecretsFile(
    const std::unordered_map<std::string,std::string>& secrets) const
{
    json plainJ = json::object();
    for (const auto& [id, pwd] : secrets)
        plainJ[id] = pwd;
    const std::string plaintext = plainJ.dump();
    const std::string saltHex  = generateSaltHex();
    const std::string nonceHex = generateNonceHex();
    const std::string key32    = deriveKey(saltHex);
    const std::string nonce12  = fromHex(nonceHex);
 
    std::string ct, tag;
    if (!aesEncrypt(key32, nonce12, plaintext, ct, tag)) return false;
 
    json fileJ = {
        {"salt",  saltHex},
        {"nonce", nonceHex},
        {"ct",    toHex(ct)},
        {"tag",   toHex(tag)}
    };
    return atomicWriteFile(getSecretsPath(), fileJ.dump());
}
 
bool PasswordVault::loadSecretsFile(
    std::unordered_map<std::string,std::string>& secrets) const
{
    secrets.clear();
    std::ifstream in(getSecretsPath());
    if (!in.good()) return true;
 
    json fileJ;
    try { in >> fileJ; } catch (...) { return false; }
 
    const std::string saltHex  = fileJ.value("salt",  "");
    const std::string nonceHex = fileJ.value("nonce", "");
    const std::string ctHex    = fileJ.value("ct",    "");
    const std::string tagHex   = fileJ.value("tag",   "");
    if (saltHex.empty() || nonceHex.empty()) return false;
 
    const std::string key32   = deriveKey(saltHex);
    const std::string nonce12 = fromHex(nonceHex);
    const std::string ct      = fromHex(ctHex);
    const std::string tag     = fromHex(tagHex);
 
    std::string plaintext;
    if (!aesDecrypt(key32, nonce12, ct, tag, plaintext)) return false;
 
    json plainJ;
    try { plainJ = json::parse(plaintext); } catch (...) { return false; }
    if (!plainJ.is_object()) return false;
 
    for (auto it = plainJ.begin(); it != plainJ.end(); ++it)
        if (it.value().is_string())
            secrets[it.key()] = it.value().get<std::string>();
 
    return true;
}
 
 
PasswordVault::PasswordVault() : unlocked_(false) {}
 
bool PasswordVault::initialize() {
    const auto dir = Glib::get_home_dir() + "/.config/BastionGuard/password_manager";
    auto dirFile = Gio::File::create_for_path(dir);
    try {
        if (!dirFile->query_exists())
            dirFile->make_directory_with_parents();
    } catch (...) { return false; }
    const auto indexPath = getIndexPath();
    std::ifstream in(indexPath);
    if (!in.good())
        if (!atomicWriteFile(indexPath, "[]")) return false;
    return true;
}
 
bool PasswordVault::isUnlocked() const { return unlocked_; }
 
bool PasswordVault::isFirstRun() const {
    std::ifstream f(getHashPath());
    return !f.good();
}
 
bool PasswordVault::createMasterPassword(const std::string& masterPassword) {
    if (masterPassword.size() < 8) return false;
    const std::string saltHex = generateSaltHex();
    const std::string hashHex = pbkdf2Hex(masterPassword, saltHex);
    json j = { {"salt", saltHex}, {"hash", hashHex}, {"iterations", 200000} };
    if (!atomicWriteFile(getHashPath(), j.dump())) return false;
    masterPassword_ = masterPassword;
    unlocked_ = true;
    cacheReady_ = true; // nessun secret da caricare al primo avvio
    return true;
}
 
bool PasswordVault::unlock(const std::string& masterPassword) {
    if (masterPassword.size() < 8) return false;
    std::ifstream f(getHashPath());
    if (!f.good()) return false;
    json j;
    try { f >> j; } catch (...) { return false; }
    const std::string saltHex   = j.value("salt", "");
    const std::string savedHash = j.value("hash", "");
    const int iterations        = j.value("iterations", 200000);
    if (saltHex.empty() || savedHash.empty()) return false;
    const std::string derived = pbkdf2Hex(masterPassword, saltHex, iterations);
    if (derived.size() != savedHash.size()) return false;
    unsigned char diff = 0;
    for (size_t i = 0; i < derived.size(); ++i)
        diff |= static_cast<unsigned char>(derived[i]) ^
                static_cast<unsigned char>(savedHash[i]);
    if (diff != 0) return false;
 
    masterPassword_ = masterPassword;
    unlocked_ = true;
    cacheReady_ = false;
    std::thread([this]() {
        std::unordered_map<std::string, std::string> loaded;
        const bool ok = loadSecretsFile(loaded);
        if (unlocked_) {
            std::lock_guard<std::mutex> lk(cacheMutex_);
            if (ok) secretCache_ = std::move(loaded);
        }
        cacheReady_ = true;
    }).detach();
 
    return true;
}
 
void PasswordVault::lock() {
    secureClear(masterPassword_);
    unlocked_ = false;
    cacheReady_ = false;
    std::lock_guard<std::mutex> lk(cacheMutex_);
    secretCache_.clear();
}
 
std::string PasswordVault::getIndexPath() const {
    return Glib::get_home_dir() + "/.config/BastionGuard/password_manager/index.json";
}
std::string PasswordVault::getHashPath() const {
    return Glib::get_home_dir() + "/.config/BastionGuard/password_manager/master.json";
}
std::string PasswordVault::getSecretsPath() const {
    return Glib::get_home_dir() + "/.config/BastionGuard/password_manager/secrets.enc";
}
std::string PasswordVault::makeSecretKey(const std::string& id) const {
    return id;
}
 
std::vector<PasswordEntry> PasswordVault::loadIndex() const {
    std::vector<PasswordEntry> entries;
    std::ifstream in(getIndexPath());
    if (!in.good()) return entries;
    json j;
    try { in >> j; } catch (...) { return entries; }
    if (!j.is_array()) return entries;
    for (const auto& item : j) {
        if (!item.is_object()) continue;
        PasswordEntry e;
        e.id         = item.value("id",         "");
        e.name       = item.value("name",       "");
        e.username   = item.value("username",   "");
        e.url        = item.value("url",        "");
        e.notes      = item.value("notes",      "");
        e.created_at = item.value("created_at", "");
        e.updated_at = item.value("updated_at", "");
        if (e.id.empty()) continue;
        if (item.contains("tags") && item["tags"].is_array())
            for (const auto& tag : item["tags"])
                if (tag.is_string()) e.tags.push_back(tag.get<std::string>());
        entries.push_back(std::move(e));
    }
    return entries;
}
 
bool PasswordVault::saveIndex(const std::vector<PasswordEntry>& entries) const {
    json j = json::array();
    for (const auto& e : entries)
        j.push_back({{"id",e.id},{"name",e.name},{"username",e.username},
                     {"url",e.url},{"notes",e.notes},{"tags",e.tags},
                     {"created_at",e.created_at},{"updated_at",e.updated_at}});
    return atomicWriteFile(getIndexPath(), j.dump(4));
}
 
 
void PasswordVault::flushAsync(
    std::unordered_map<std::string,std::string> snapshot) const {
    std::thread([this, snapshot]() {
        this->saveSecretsFile(snapshot);
    }).detach();
}
 
bool PasswordVault::addEntry(const PasswordEntry& entry, const std::string& secret) {
    if (!unlocked_ || entry.id.empty() || entry.name.empty()) return false;
    auto entries = loadIndex();
    for (const auto& e : entries)
        if (e.id == entry.id) return false;
    entries.push_back(entry);
    if (!saveIndex(entries)) return false;
 
    std::unordered_map<std::string,std::string> snap;
    {
        std::lock_guard<std::mutex> lk(cacheMutex_);
        secretCache_[entry.id] = secret;
        snap = secretCache_;
    }
    flushAsync(std::move(snap));
    return true;
}
 
bool PasswordVault::updateEntry(const PasswordEntry& entry, const std::string& secret) {
    if (!unlocked_ || entry.id.empty()) return false;
    auto entries = loadIndex();
    for (auto& e : entries) {
        if (e.id == entry.id) {
            e = entry;
            if (!saveIndex(entries)) return false;
            std::unordered_map<std::string,std::string> snap;
            {
                std::lock_guard<std::mutex> lk(cacheMutex_);
                secretCache_[entry.id] = secret;
                snap = secretCache_;
            }
            flushAsync(std::move(snap));
            return true;
        }
    }
    return false;
}
 
bool PasswordVault::deleteEntry(const std::string& id) {
    if (!unlocked_ || id.empty()) return false;
    auto entries = loadIndex();
    const auto before = entries.size();
    std::vector<PasswordEntry> filtered;
    filtered.reserve(before);
    for (const auto& e : entries)
        if (e.id != id) filtered.push_back(e);
    if (filtered.size() == before) return false;
    if (!saveIndex(filtered)) return false;
 
    std::unordered_map<std::string,std::string> snap;
    {
        std::lock_guard<std::mutex> lk(cacheMutex_);
        secretCache_.erase(id);
        snap = secretCache_;
    }
    flushAsync(std::move(snap));
    return true;
}
 
void PasswordVault::deleteAllEntries(std::function<void(bool)> onDone) {
    if (!unlocked_) { if (onDone) onDone(false); return; }
    if (!atomicWriteFile(getIndexPath(), "[]")) { if (onDone) onDone(false); return; }
    {
        std::lock_guard<std::mutex> lk(cacheMutex_);
        secretCache_.clear();
    }
    auto disp   = std::make_shared<Glib::Dispatcher>();
    auto result = std::make_shared<bool>(false);
    auto cb     = std::make_shared<std::function<void(bool)>>(std::move(onDone));
    disp->connect([disp, result, cb]() { if (*cb) (*cb)(*result); });
    const std::string path = getSecretsPath();
    std::thread([disp, result, path]() {
        *result = (std::remove(path.c_str()) == 0 || errno == ENOENT);
        disp->emit();
    }).detach();
}
 
void PasswordVault::addEntriesBulk(
    const std::vector<std::pair<PasswordEntry, std::string>>& items,
    std::function<void(int ok, int fail)> onDone)
{
    if (!unlocked_) { if (onDone) onDone(0, (int)items.size()); return; }
 
    auto entries = loadIndex();
    std::unordered_set<std::string> existingIds;
    existingIds.reserve(entries.size());
    for (const auto& e : entries) existingIds.insert(e.id);
 
    int ok = 0, fail = 0;
    for (const auto& [entry, secret] : items) {
        if (entry.id.empty() || entry.name.empty() || existingIds.count(entry.id)) {
            ++fail; continue;
        }
        entries.push_back(entry);
        existingIds.insert(entry.id);
        ++ok;
    }
 
    if (!saveIndex(entries)) { if (onDone) onDone(0, (int)items.size()); return; }
    {
        std::lock_guard<std::mutex> lk(cacheMutex_);
        for (const auto& [entry, secret] : items)
            if (!entry.id.empty()) secretCache_[entry.id] = secret;
    }
    if (onDone) onDone(ok, fail);
    std::unordered_map<std::string,std::string> snap;
    { std::lock_guard<std::mutex> lk(cacheMutex_); snap = secretCache_; }
    flushAsync(std::move(snap));
}
 
 
void PasswordVault::exportToCSV(
    std::function<void(std::string csv, std::string err)> onDone) const
{
    if (!unlocked_) { if (onDone) onDone("", "Vault bloccato."); return; }
    const auto entries = loadIndex();
    auto resultCsv = std::make_shared<std::string>();
    auto disp = std::make_shared<Glib::Dispatcher>();
    auto cb   = std::make_shared<std::function<void(std::string,std::string)>>(onDone);
    disp->connect([disp, resultCsv, cb]() { if (*cb) (*cb)(std::move(*resultCsv), ""); });
 
    std::unordered_map<std::string,std::string> snap;
    { std::lock_guard<std::mutex> lk(cacheMutex_); snap = secretCache_; }
 
    std::thread([entries, snap, resultCsv, disp]() {
        std::ostringstream csv;
        csv << "name,url,username,password,notes\n";
        for (const auto& e : entries) {
            std::string pwd;
            auto it = snap.find(e.id);
            if (it != snap.end()) pwd = it->second;
            csv << csvEscape(e.name)     << ","
                << csvEscape(e.url)      << ","
                << csvEscape(e.username) << ","
                << csvEscape(pwd)        << ","
                << csvEscape(e.notes)    << "\n";
        }
        *resultCsv = csv.str();
        disp->emit();
    }).detach();
}
 
 
void PasswordVault::getSecretAsync(const std::string& id,
                                    std::function<void(std::string)> callback) const
{
    if (!unlocked_ || id.empty()) { if (callback) callback({}); return; }
 
    {
        std::lock_guard<std::mutex> lk(cacheMutex_);
        auto it = secretCache_.find(id);
        if (it != secretCache_.end()) {
            const std::string cached = it->second;
            Glib::signal_idle().connect_once([callback, cached]() {
                if (callback) callback(cached);
            });
            return;
        }
    }
 
    auto retries = std::make_shared<int>(0);
    Glib::signal_timeout().connect(
        [this, id, callback, retries]() -> bool {
            ++(*retries);
            {
                std::lock_guard<std::mutex> lk(cacheMutex_);
                auto it = secretCache_.find(id);
                if (it != secretCache_.end()) {
                    if (callback) callback(it->second);
                    return false;
                }
            }
            if (cacheReady_.load() || *retries > 100) {
                if (callback) callback({});
                return false;
            }
            return true;
        }, 50);
}
 
bool PasswordVault::setSecret(const std::string& id, const std::string& secret) {
    if (id.empty()) return false;
    std::unordered_map<std::string,std::string> snap;
    {
        std::lock_guard<std::mutex> lk(cacheMutex_);
        secretCache_[id] = secret;
        snap = secretCache_;
    }
    flushAsync(std::move(snap));
    return true;
}
 
std::string PasswordVault::generateId() const {
    std::random_device rd;
    std::mt19937_64 gen(rd());
    std::uniform_int_distribution<uint32_t> dist32;
    uint32_t data[4] = { dist32(gen), dist32(gen), dist32(gen), dist32(gen) };
    data[1] = (data[1] & 0xFFFF0FFF) | 0x00004000;
    data[2] = (data[2] & 0x3FFFFFFF) | 0x80000000;
    std::ostringstream oss;
    oss << std::hex << std::setfill('0');
    oss << std::setw(8) << data[0] << "-"
        << std::setw(4) << (data[1] >> 16) << "-"
        << std::setw(4) << (data[1] & 0xFFFF) << "-"
        << std::setw(4) << (data[2] >> 16) << "-"
        << std::setw(4) << (data[2] & 0xFFFF)
        << std::setw(8) << data[3];
    return oss.str();
}
 
std::string PasswordVault::nowIso() const {
    std::time_t t = std::time(nullptr);
    std::tm tm{};
    localtime_r(&t, &tm);
    std::ostringstream oss;
    oss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
    return oss.str();
}