PasswordVault Class Reference

#include <PasswordVault.hpp>

Public Member Functions
	PasswordVault ()
bool	initialize ()
bool	isUnlocked () const
bool	isFirstRun () const
bool	createMasterPassword (const std::string &masterPassword)
bool	unlock (const std::string &masterPassword)
void	lock ()
std::vector< PasswordEntry >	loadIndex () const
bool	saveIndex (const std::vector< PasswordEntry > &entries) const
bool	addEntry (const PasswordEntry &entry, const std::string &secret)
bool	updateEntry (const PasswordEntry &entry, const std::string &secret)
bool	deleteEntry (const std::string &id)
void	deleteAllEntries (std::function< void(bool)> onDone)
void	addEntriesBulk (const std::vector< std::pair< PasswordEntry, std::string > > &items, std::function< void(int ok, int fail)> onDone)
void	exportToCSV (std::function< void(std::string csv, std::string err)> onDone) const
void	getSecretAsync (const std::string &id, std::function< void(std::string)> callback) const
bool	setSecret (const std::string &id, const std::string &secret)
bool	isCacheReady () const
std::string	generateId () const
std::string	nowIso () const
std::string	getIndexPath () const

Private Member Functions
std::string	getHashPath () const
std::string	getSecretsPath () const
std::string	pbkdf2Hex (const std::string &password, const std::string &saltHex, int iterations=200000) const
std::string	generateSaltHex () const
std::string	generateNonceHex () const
bool	saveSecretsFile (const std::unordered_map< std::string, std::string > &secrets) const
bool	loadSecretsFile (std::unordered_map< std::string, std::string > &secrets) const
bool	aesEncrypt (const std::string &key32, const std::string &nonce12, const std::string &plaintext, std::string &ciphertext, std::string &tag16) const
bool	aesDecrypt (const std::string &key32, const std::string &nonce12, const std::string &ciphertext, const std::string &tag16, std::string &plaintext) const
std::string	deriveKey (const std::string &saltHex) const
void	flushAsync (std::unordered_map< std::string, std::string > snapshot) const
std::string	makeSecretKey (const std::string &id) const

Static Private Member Functions
static bool	atomicWriteFile (const std::string &path, const std::string &content)

Private Attributes
std::atomic< bool >	unlocked_ { false }
std::string	masterPassword_
std::unordered_map< std::string, std::string >	secretCache_
std::mutex	cacheMutex_
std::atomic< bool >	cacheReady_ { false }

Detailed Description

Definition at line 32 of file PasswordVault.hpp.

Constructor & Destructor Documentation

PasswordVault()

PasswordVault::PasswordVault

(

)

Definition at line 263 of file PasswordVault.cpp.

: unlocked_(false) {}

References unlocked_.

Member Function Documentation

addEntriesBulk()

void PasswordVault::addEntriesBulk	(	const std::vector< std::pair< PasswordEntry, std::string > > &	items,
		std::function< void(int ok, int fail)>	onDone )

Definition at line 473 of file PasswordVault.cpp.

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

References cacheMutex_, flushAsync(), loadIndex(), saveIndex(), secretCache_, and unlocked_.

Referenced by PasswordManagerPage::onImportClicked().

addEntry()

bool PasswordVault::addEntry	(	const PasswordEntry &	entry,
		const std::string &	secret )

Definition at line 396 of file PasswordVault.cpp.

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

References cacheMutex_, flushAsync(), PasswordEntry::id, loadIndex(), PasswordEntry::name, saveIndex(), secretCache_, and unlocked_.

Referenced by PasswordManagerPage::onAddClicked().

aesDecrypt()

bool PasswordVault::aesDecrypt ( const std::string & key32, const std::string & nonce12, const std::string & ciphertext, const std::string & tag16, std::string & plaintext ) const

private

Definition at line 134 of file PasswordVault.cpp.

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

Referenced by loadSecretsFile().

aesEncrypt()

bool PasswordVault::aesEncrypt ( const std::string & key32, const std::string & nonce12, const std::string & plaintext, std::string & ciphertext, std::string & tag16 ) const

private

Definition at line 97 of file PasswordVault.cpp.

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

Referenced by saveSecretsFile().

atomicWriteFile()

bool PasswordVault::atomicWriteFile ( const std::string & path, const std::string & content )

staticprivate

Definition at line 85 of file PasswordVault.cpp.

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

Referenced by createMasterPassword(), deleteAllEntries(), initialize(), saveIndex(), and saveSecretsFile().

createMasterPassword()

bool PasswordVault::createMasterPassword

(

const std::string &

masterPassword

)

Definition at line 286 of file PasswordVault.cpp.

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

References atomicWriteFile(), cacheReady_, generateSaltHex(), getHashPath(), masterPassword_, pbkdf2Hex(), and unlocked_.

Referenced by PasswordManagerPage::onUnlockClicked().

deleteAllEntries()

void PasswordVault::deleteAllEntries

(

std::function< void(bool)>

onDone

)

Definition at line 455 of file PasswordVault.cpp.

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

References atomicWriteFile(), cacheMutex_, getIndexPath(), getSecretsPath(), secretCache_, and unlocked_.

Referenced by PasswordManagerPage::onDeleteAllClicked().

deleteEntry()

bool PasswordVault::deleteEntry

(

const std::string &

id

)

Definition at line 434 of file PasswordVault.cpp.

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

References cacheMutex_, flushAsync(), loadIndex(), saveIndex(), secretCache_, and unlocked_.

Referenced by PasswordManagerPage::onDeleteEntry().

deriveKey()

std::string PasswordVault::deriveKey ( const std::string & saltHex ) const

private

Definition at line 170 of file PasswordVault.cpp.

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

References fromHex(), and masterPassword_.

Referenced by loadSecretsFile(), and saveSecretsFile().

exportToCSV()

void PasswordVault::exportToCSV

(

std::function< void(std::string csv, std::string err)>

onDone

)

const

Definition at line 507 of file PasswordVault.cpp.

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

References cacheMutex_, csvEscape(), loadIndex(), secretCache_, and unlocked_.

Referenced by PasswordVaultView::onExportClicked().

flushAsync()

void PasswordVault::flushAsync ( std::unordered_map< std::string, std::string > snapshot ) const

private

Definition at line 389 of file PasswordVault.cpp.

                                                          {
    std::thread([this, snapshot]() {
        this->saveSecretsFile(snapshot);
    }).detach();
}

References saveSecretsFile().

Referenced by addEntriesBulk(), addEntry(), deleteEntry(), setSecret(), and updateEntry().

generateId()

std::string PasswordVault::generateId

(

)

const

Definition at line 588 of file PasswordVault.cpp.

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

Referenced by PasswordManagerPage::onAddClicked(), and PasswordManagerPage::onImportClicked().

generateNonceHex()

std::string PasswordVault::generateNonceHex ( ) const

private

Definition at line 196 of file PasswordVault.cpp.

                                                {
    unsigned char nonce[12];
    RAND_bytes(nonce, sizeof(nonce));
    return toHex(nonce, sizeof(nonce));
}

References toHex().

Referenced by saveSecretsFile().

generateSaltHex()

std::string PasswordVault::generateSaltHex ( ) const

private

Definition at line 190 of file PasswordVault.cpp.

                                               {
    unsigned char salt[16];
    RAND_bytes(salt, sizeof(salt));
    return toHex(salt, sizeof(salt));
}

References toHex().

Referenced by createMasterPassword(), and saveSecretsFile().

getHashPath()

std::string PasswordVault::getHashPath ( ) const

private

Definition at line 343 of file PasswordVault.cpp.

                                           {
    return Glib::get_home_dir() + "/.config/BastionGuard/password_manager/master.json";
}

Referenced by createMasterPassword(), isFirstRun(), and unlock().

getIndexPath()

std::string PasswordVault::getIndexPath

(

)

const

Definition at line 340 of file PasswordVault.cpp.

                                            {
    return Glib::get_home_dir() + "/.config/BastionGuard/password_manager/index.json";
}

Referenced by deleteAllEntries(), initialize(), loadIndex(), and saveIndex().

getSecretAsync()

void PasswordVault::getSecretAsync	(	const std::string &	id,
		std::function< void(std::string)>	callback ) const

Definition at line 539 of file PasswordVault.cpp.

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

References cacheMutex_, cacheReady_, secretCache_, and unlocked_.

Referenced by PasswordManagerPage::onEditEntry(), PasswordManagerPage::onRevealEntry(), and PasswordVaultView::showEntryDetail().

getSecretsPath()

std::string PasswordVault::getSecretsPath ( ) const

private

Definition at line 346 of file PasswordVault.cpp.

                                              {
    return Glib::get_home_dir() + "/.config/BastionGuard/password_manager/secrets.enc";
}

Referenced by deleteAllEntries(), loadSecretsFile(), and saveSecretsFile().

initialize()

bool PasswordVault::initialize

(

)

Definition at line 265 of file PasswordVault.cpp.

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

References atomicWriteFile(), and getIndexPath().

Referenced by PasswordManagerPage::PasswordManagerPage().

isCacheReady()

bool PasswordVault::isCacheReady ( ) const

inline

Definition at line 61 of file PasswordVault.hpp.

{ return cacheReady_.load(); }

References cacheReady_.

isFirstRun()

bool PasswordVault::isFirstRun

(

)

const

Definition at line 281 of file PasswordVault.cpp.

                                     {
    std::ifstream f(getHashPath());
    return !f.good();
}

References getHashPath().

Referenced by PasswordManagerPage::onUnlockClicked().

isUnlocked()

bool PasswordVault::isUnlocked

(

)

const

Definition at line 279 of file PasswordVault.cpp.

{ return unlocked_; }

References unlocked_.

Referenced by PasswordManagerPage::onAddClicked(), PasswordManagerPage::onDeleteAllClicked(), PasswordManagerPage::onDeleteEntry(), PasswordManagerPage::onEditEntry(), PasswordManagerPage::onImportClicked(), PasswordManagerPage::onRevealEntry(), PasswordManagerPage::onUnlockClicked(), and PasswordManagerPage::onVaultViewClicked().

loadIndex()

std::vector< PasswordEntry > PasswordVault::loadIndex

(

)

const

Definition at line 353 of file PasswordVault.cpp.

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

References PasswordEntry::created_at, getIndexPath(), PasswordEntry::id, PasswordEntry::name, PasswordEntry::notes, PasswordEntry::tags, PasswordEntry::updated_at, PasswordEntry::url, and PasswordEntry::username.

Referenced by addEntriesBulk(), addEntry(), deleteEntry(), exportToCSV(), PasswordVaultView::present(), PasswordManagerPage::reload(), and updateEntry().

loadSecretsFile()

bool PasswordVault::loadSecretsFile ( std::unordered_map< std::string, std::string > & secrets ) const

private

Definition at line 227 of file PasswordVault.cpp.

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

References aesDecrypt(), deriveKey(), fromHex(), and getSecretsPath().

Referenced by unlock().

lock()

void PasswordVault::lock

(

)

Definition at line 332 of file PasswordVault.cpp.

                         {
    secureClear(masterPassword_);
    unlocked_ = false;
    cacheReady_ = false;
    std::lock_guard<std::mutex> lk(cacheMutex_);
    secretCache_.clear();
}

References cacheMutex_, cacheReady_, masterPassword_, secretCache_, secureClear(), and unlocked_.

Referenced by PasswordManagerPage::onLockClicked().

makeSecretKey()

std::string PasswordVault::makeSecretKey ( const std::string & id ) const

private

Definition at line 349 of file PasswordVault.cpp.

                                                                {
    return id;
}

nowIso()

std::string PasswordVault::nowIso

(

)

const

Definition at line 606 of file PasswordVault.cpp.

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

Referenced by PasswordManagerPage::onAddClicked(), and PasswordManagerPage::onImportClicked().

pbkdf2Hex()

std::string PasswordVault::pbkdf2Hex ( const std::string & password, const std::string & saltHex, int iterations = 200000 ) const

private

Definition at line 179 of file PasswordVault.cpp.

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

References fromHex(), and toHex().

Referenced by createMasterPassword(), and unlock().

saveIndex()

bool PasswordVault::saveIndex

(

const std::vector< PasswordEntry > &

entries

)

const

Definition at line 379 of file PasswordVault.cpp.

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

References atomicWriteFile(), and getIndexPath().

Referenced by addEntriesBulk(), addEntry(), deleteEntry(), and updateEntry().

saveSecretsFile()

bool PasswordVault::saveSecretsFile ( const std::unordered_map< std::string, std::string > & secrets ) const

private

Definition at line 203 of file PasswordVault.cpp.

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

References aesEncrypt(), atomicWriteFile(), deriveKey(), fromHex(), generateNonceHex(), generateSaltHex(), getSecretsPath(), and toHex().

Referenced by flushAsync().

setSecret()

bool PasswordVault::setSecret	(	const std::string &	id,
		const std::string &	secret )

Definition at line 576 of file PasswordVault.cpp.

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

References cacheMutex_, flushAsync(), and secretCache_.

unlock()

bool PasswordVault::unlock

(

const std::string &

masterPassword

)

Definition at line 298 of file PasswordVault.cpp.

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

References cacheMutex_, cacheReady_, getHashPath(), loadSecretsFile(), masterPassword_, pbkdf2Hex(), secretCache_, and unlocked_.

Referenced by PasswordManagerPage::onUnlockClicked().

updateEntry()

bool PasswordVault::updateEntry	(	const PasswordEntry &	entry,
		const std::string &	secret )

Definition at line 414 of file PasswordVault.cpp.

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

References cacheMutex_, flushAsync(), PasswordEntry::id, loadIndex(), saveIndex(), secretCache_, and unlocked_.

Member Data Documentation

cacheMutex_

std::mutex PasswordVault::cacheMutex_

mutableprivate

Definition at line 74 of file PasswordVault.hpp.

Referenced by addEntriesBulk(), addEntry(), deleteAllEntries(), deleteEntry(), exportToCSV(), getSecretAsync(), lock(), setSecret(), unlock(), and updateEntry().

cacheReady_

std::atomic<bool> PasswordVault::cacheReady_ { false }

mutableprivate

Definition at line 75 of file PasswordVault.hpp.

Referenced by createMasterPassword(), getSecretAsync(), isCacheReady(), lock(), and unlock().

masterPassword_

std::string PasswordVault::masterPassword_

private

Definition at line 72 of file PasswordVault.hpp.

Referenced by createMasterPassword(), deriveKey(), lock(), and unlock().

secretCache_

std::unordered_map<std::string, std::string> PasswordVault::secretCache_

mutableprivate

Definition at line 73 of file PasswordVault.hpp.

Referenced by addEntriesBulk(), addEntry(), deleteAllEntries(), deleteEntry(), exportToCSV(), getSecretAsync(), lock(), setSecret(), unlock(), and updateEntry().

unlocked_

std::atomic<bool> PasswordVault::unlocked_ { false }

private

Definition at line 71 of file PasswordVault.hpp.

Referenced by addEntriesBulk(), addEntry(), createMasterPassword(), deleteAllEntries(), deleteEntry(), exportToCSV(), getSecretAsync(), isUnlocked(), lock(), PasswordVault(), unlock(), and updateEntry().

---

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

• BastionGuard/src/password_manager/PasswordVault.hpp
• BastionGuard/src/password_manager/PasswordVault.cpp