key.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 <cstddef>
#include <cstdint>
#include <iosfwd>
#include <string>
#include <vector>
 
#include "libkeepass/export.hh"
#include "libkeepass/secure.hh"
 
namespace keepass {
 
class LIBKEEPASS_API Key final {
public:
 
  static constexpr std::size_t kMaxKeyFileBytes = 1024 * 1024;
 
  enum class SubKeyResolution {
    kHashSubKeys,
 
    kHashSubKeysOnlyIfCompositeKey
  };
 
  enum class Kdf {
    kAes,
 
    kArgon2d,
 
    kArgon2id
  };
 
private:
  struct CompositeKey {
    SecureBuffer<32> password_key_;
    SecureBuffer<32> keyfile_key_;
 
    void Resolve(SubKeyResolution resolution, SecureBuffer<32>& out) const;
  } key_;
 
  bool has_transformed_key_ = false;
  SecureBuffer<32> transformed_key_;
 
public:
  Key() = default;
 
  Key(const Key& other);
 
  Key& operator=(const Key& other);
 
 
  explicit Key(const std::string& password);
 
 
  Key(const std::string& password, const std::string& keyfile);
 
 
  explicit Key(const std::vector<uint8_t>& transformed_key);
 
 
  void SetPassword(const std::string& password);
 
 
  void SetKeyFile(const std::string& path);
 
 
  void SetKeyFile(std::istream& src);
 
 
  void SetKeyFileData(const uint8_t* data, std::size_t size);
 
 
  static Key FromBytes(const std::string& password, const std::vector<uint8_t>& keyfile);
 
 
  static Key FromStream(const std::string& password, std::istream& keyfile);
 
 
  SecureBuffer<32> Transform(const SecureBuffer<32>& seed, uint64_t rounds,
                             SubKeyResolution resolution) const;
 
 
  SecureBuffer<32> TransformArgon2(Kdf kdf, const SecureBytes& salt, uint64_t iterations,
                                   uint64_t memory_bytes, uint32_t parallelism,
                                   uint32_t argon2_version, SubKeyResolution resolution) const;
};
 
} // namespace keepass