database.hh

Go to the documentation of this file.

/*
 * libkeepass - KeePass key database importer/exporter
 * Copyright (C) 2014 Christian Kindahl
 * Copyright (C) 2024 Dominik Krümpelmann
 *
 * 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, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 <http://www.gnu.org/licenses/>.
 */
 
#pragma once
#include <array>
#include <cstring>
#include <memory>
#include <string>
#include <vector>
 
#include "group.hh"
#include "libkeepass/export.hh"
#include "libkeepass/secure.hh"
 
namespace keepass {
 
class Metadata;
class Visitor;
 
enum class CsvFormat { kCsv, kCsvWithPasswords, kCsvWithCustomFields, kCsvKeePass2 };
 
struct LIBKEEPASS_API EntryDelta {
  std::shared_ptr<Entry> entry;
  std::string group_path;
};
 
struct LIBKEEPASS_API DatabaseDelta {
  std::vector<EntryDelta> added;
  std::vector<EntryDelta> modified;
  std::vector<std::array<uint8_t, 16>> deleted;
  std::vector<std::string> deleted_paths;
 
  bool empty() const { return added.empty() && modified.empty() && deleted.empty(); }
 
  std::string ToJson() const;
};
 
class LIBKEEPASS_API Database final {
public:
  enum class Cipher { kAes, kTwofish, kChaCha20 };
 
  enum class Kdf { kAes, kArgon2d, kArgon2id };
 
  static constexpr uint64_t kMaxTransformRounds = 1U << 28;
 
  static constexpr uint64_t kMaxArgon2MemoryKiB = 1U << 20; // 1 GiB
  static constexpr uint64_t kMaxArgon2Iterations = 1U << 20;
 
private:
  std::shared_ptr<Group> root_;
  Cipher cipher_ = Cipher::kAes;
  Kdf kdf_ = Kdf::kAes;
  SecureBytes master_seed_;
  std::array<uint8_t, 16> init_vector_ = {{0}};
  SecureBuffer<32> transform_seed_;
  SecureBuffer<32> inner_random_stream_key_;
  uint64_t transform_rounds_ = 8192;
  uint64_t argon2_memory_ = 0;
  uint32_t argon2_parallelism_ = 0;
  uint32_t argon2_version_ = 0;
  SecureBytes argon2_salt_;
  uint64_t argon2_iterations_ = 0;
  bool compress_ = false;
  std::shared_ptr<Metadata> meta_;
  SecureBuffer<32> transformed_key_;
  bool has_transformed_key_ = false;
 
public:
  std::shared_ptr<Group> root() const { return root_; }
 
  void set_root(std::shared_ptr<Group> root) { root_ = std::move(root); }
 
  Cipher cipher() const { return cipher_; }
 
  void set_cipher(Cipher cipher) { cipher_ = cipher; }
 
  Kdf kdf() const { return kdf_; }
 
  void set_kdf(Kdf kdf) {
    if (kdf_ != kdf) {
      kdf_ = kdf;
      clear_transformed_key();
    }
  }
 
  const SecureBytes& master_seed() const { return master_seed_; }
 
  void set_master_seed(const std::array<uint8_t, 16>& master_seed) {
    master_seed_.Assign(master_seed.data(), master_seed.size());
  }
 
  void set_master_seed(const std::vector<uint8_t>& master_seed) {
    master_seed_.Assign(master_seed);
  }
 
  void set_master_seed(SecureBytes master_seed) { master_seed_ = std::move(master_seed); }
 
  const std::array<uint8_t, 16>& init_vector() const { return init_vector_; }
 
  void set_init_vector(const std::array<uint8_t, 16>& init_vector) { init_vector_ = init_vector; }
 
  const SecureBuffer<32>& transform_seed() const { return transform_seed_; }
 
  void set_transform_seed(const std::array<uint8_t, 32>& transform_seed) {
    std::memcpy(transform_seed_.data(), transform_seed.data(), transform_seed.size());
    clear_transformed_key();
  }
 
  void set_transform_seed(const SecureBuffer<32>& transform_seed) {
    transform_seed_ = transform_seed.Clone();
    clear_transformed_key();
  }
 
  const SecureBuffer<32>& inner_random_stream_key() const { return inner_random_stream_key_; }
 
 
  void set_inner_random_stream_key(const SecureBuffer<32>& key) {
    inner_random_stream_key_ = key.Clone();
  }
 
 
  void set_inner_random_stream_key(const std::array<uint8_t, 32>& key) {
    SecureBuffer<32> secure_key;
    std::memcpy(secure_key.data(), key.data(), key.size());
    inner_random_stream_key_ = std::move(secure_key);
  }
 
  uint64_t transform_rounds() const { return transform_rounds_; }
 
  void set_transform_rounds(uint64_t transform_rounds) {
    transform_rounds_ = transform_rounds;
    clear_transformed_key();
  }
 
  uint64_t argon2_memory() const { return argon2_memory_; }
 
  void set_argon2_memory(uint64_t argon2_memory) {
    argon2_memory_ = argon2_memory;
    clear_transformed_key();
  }
 
  uint32_t argon2_parallelism() const { return argon2_parallelism_; }
 
  void set_argon2_parallelism(uint32_t argon2_parallelism) {
    argon2_parallelism_ = argon2_parallelism;
    clear_transformed_key();
  }
 
  uint32_t argon2_version() const { return argon2_version_; }
 
  void set_argon2_version(uint32_t argon2_version) {
    argon2_version_ = argon2_version;
    clear_transformed_key();
  }
 
  const SecureBytes& argon2_salt() const { return argon2_salt_; }
 
  void set_argon2_salt(const std::vector<uint8_t>& salt) {
    argon2_salt_.Assign(salt);
    clear_transformed_key();
  }
 
  void set_argon2_salt(SecureBytes salt) {
    argon2_salt_ = std::move(salt);
    clear_transformed_key();
  }
 
  uint64_t argon2_iterations() const { return argon2_iterations_; }
 
  void set_argon2_iterations(uint64_t iterations) {
    argon2_iterations_ = iterations;
    clear_transformed_key();
  }
 
  bool compress() const { return compress_; }
 
  void set_compress(bool compress) { compress_ = compress; }
 
  const SecureBuffer<32>& transformed_key() const { return transformed_key_; }
 
  bool has_transformed_key() const { return has_transformed_key_; }
 
  void set_transformed_key(SecureBuffer<32> key) {
    transformed_key_ = std::move(key);
    has_transformed_key_ = true;
  }
 
  void clear_transformed_key() {
    has_transformed_key_ = false;
    SecureBuffer<32> empty;
    transformed_key_ = std::move(empty);
  }
 
  std::shared_ptr<Metadata> meta() const { return meta_; }
 
  void set_meta(std::shared_ptr<Metadata> meta) { meta_ = std::move(meta); }
 
 
  std::vector<std::shared_ptr<Entry>> FindEntries(const std::string& query,
                                                  bool regex = false) const;
 
 
  std::vector<std::shared_ptr<Group>> FindGroups(const std::string& query,
                                                 bool regex = false) const;
 
 
  std::shared_ptr<Entry> FindEntry(const std::string& title) const;
 
 
  std::shared_ptr<Group> FindGroup(const std::string& name) const;
 
  static std::shared_ptr<Entry> NewEntry(const std::string& title = "");
 
  static std::shared_ptr<Group> NewGroup(const std::string& name = "");
 
  static void AddEntry(const std::shared_ptr<Group>& group, const std::shared_ptr<Entry>& entry);
 
  static void AddGroup(const std::shared_ptr<Group>& parent, const std::shared_ptr<Group>& group);
 
  void DeleteEntry(const std::array<uint8_t, 16>& uuid);
 
  void DeleteGroup(const std::array<uint8_t, 16>& uuid);
 
  static void MoveEntry(const std::shared_ptr<Entry>& entry,
                        const std::shared_ptr<Group>& new_group);
 
  static void MoveGroup(const std::shared_ptr<Group>& group,
                        const std::shared_ptr<Group>& new_parent);
 
 
  void DeleteOldHistory();
 
  void delete_old_history() { DeleteOldHistory(); }
 
  void TrashEntry(const std::shared_ptr<Entry>& entry);
 
  void TrashGroup(const std::shared_ptr<Group>& group);
 
  void EmptyRecycleBin();
 
  bool IsRecycleBinEnabled() const;
 
  void EnableRecycleBin(bool enable = true);
 
  std::string ToJson(bool include_attachments = false) const;
 
 
  std::string ToCsv(CsvFormat format = CsvFormat::kCsv) const;
 
 
  DatabaseDelta DeltaSince(const Database& previous) const;
 
  size_t EntryCount() const;
 
  size_t GroupCount() const;
 
  void Visit(Visitor& visitor) const;
};
 
} // namespace keepass