secure.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 <cstring>
#include <iosfwd>
#include <string>
#include <vector>
 
#include "libkeepass/export.hh"
 
namespace keepass {
 
 
LIBKEEPASS_API void secure_zero(void* data, std::size_t size) noexcept;
 
 
LIBKEEPASS_API void* secure_alloc(std::size_t size) noexcept;
 
 
LIBKEEPASS_API void secure_free(void* data, std::size_t size) noexcept;
 
template <std::size_t N> class SecureBuffer {
public:
  SecureBuffer() = default;
 
  SecureBuffer(const std::array<uint8_t, N>& other) { std::memcpy(data_.data(), other.data(), N); }
 
  ~SecureBuffer() { secure_zero(data_.data(), data_.size()); }
 
  SecureBuffer(const SecureBuffer&) = delete;
 
  SecureBuffer& operator=(const SecureBuffer&) = delete;
 
  SecureBuffer(SecureBuffer&& other) noexcept {
    std::memcpy(data_.data(), other.data_.data(), N);
    other.Wipe();
  }
 
  SecureBuffer& operator=(SecureBuffer&& other) noexcept {
    if (this != &other) {
      std::memcpy(data_.data(), other.data_.data(), N);
      other.Wipe();
    }
    return *this;
  }
 
  uint8_t* data() noexcept { return data_.data(); }
 
  const uint8_t* data() const noexcept { return data_.data(); }
 
  std::size_t size() const noexcept { return N; }
 
  uint8_t* begin() noexcept { return data_.data(); }
 
  uint8_t* end() noexcept { return data_.data() + N; }
 
  const uint8_t* begin() const noexcept { return data_.data(); }
 
  const uint8_t* end() const noexcept { return data_.data() + N; }
 
  uint8_t& operator[](std::size_t index) noexcept { return data_[index]; }
 
  const uint8_t& operator[](std::size_t index) const noexcept { return data_[index]; }
 
  void fill(uint8_t value) noexcept { data_.fill(value); }
 
  SecureBuffer Clone() const {
    SecureBuffer copy;
    std::memcpy(copy.data_.data(), data_.data(), N);
    return copy;
  }
 
private:
  void Wipe() noexcept { secure_zero(data_.data(), data_.size()); }
 
  std::array<uint8_t, N> data_ = {{0}};
};
 
class LIBKEEPASS_API SecureBytes {
public:
  SecureBytes() = default;
 
 
  SecureBytes(const uint8_t* data, std::size_t size);
 
  explicit SecureBytes(const std::vector<uint8_t>& data);
 
  ~SecureBytes();
 
  SecureBytes(const SecureBytes&) = delete;
 
  SecureBytes& operator=(const SecureBytes&) = delete;
 
  SecureBytes(SecureBytes&& other) noexcept;
 
  SecureBytes& operator=(SecureBytes&& other) noexcept;
 
  SecureBytes& operator=(const std::vector<uint8_t>& data);
 
  uint8_t* data() noexcept { return data_; }
 
  const uint8_t* data() const noexcept { return data_; }
 
  std::size_t size() const noexcept { return size_; }
 
  bool empty() const noexcept { return size_ == 0; }
 
  uint8_t* begin() noexcept { return data_; }
 
  uint8_t* end() noexcept { return data_ + size_; }
 
  const uint8_t* begin() const noexcept { return data_; }
 
  const uint8_t* end() const noexcept { return data_ + size_; }
 
  uint8_t& operator[](std::size_t index) noexcept { return data_[index]; }
 
  const uint8_t& operator[](std::size_t index) const noexcept { return data_[index]; }
 
  void Assign(const uint8_t* data, std::size_t size);
 
  void Assign(const std::vector<uint8_t>& data);
 
  void Clear() noexcept;
 
  SecureBytes Clone() const;
 
  bool operator==(const SecureBytes& other) const;
 
  bool operator!=(const SecureBytes& other) const { return !(*this == other); }
 
private:
  uint8_t* data_ = nullptr;
  std::size_t size_ = 0;
};
 
class LIBKEEPASS_API secure_string {
public:
  secure_string();
 
  secure_string(const char* str);
 
  explicit secure_string(const std::string& str);
 
  secure_string(const secure_string& other);
 
  secure_string(secure_string&& other) noexcept;
 
  secure_string& operator=(const secure_string& other);
 
  secure_string& operator=(secure_string&& other) noexcept;
 
  secure_string& operator=(const char* str) {
    assign(str);
    return *this;
  }
 
  secure_string& operator=(const std::string& str) {
    assign(str);
    return *this;
  }
 
  ~secure_string();
 
  const char* data() const noexcept { return data_; }
 
  char* data() noexcept { return data_; }
 
  char* begin() noexcept { return data_; }
 
  const char* begin() const noexcept { return data_; }
 
  char* end() noexcept { return data_ + size_; }
 
  const char* end() const noexcept { return data_ + size_; }
 
  std::size_t size() const noexcept { return size_; }
 
  std::size_t length() const noexcept { return size_; }
 
  bool empty() const noexcept { return size_ == 0; }
 
  const char* c_str() const noexcept { return data_; }
 
  std::string str() const;
 
  void clear();
 
  void assign(const char* str);
 
  void assign(const std::string& str);
 
  void assign(const char* data, std::size_t size);
 
private:
  void Allocate(const char* data, std::size_t size);
  void Release() noexcept;
 
  char* data_ = nullptr;
  std::size_t size_ = 0;
};
 
LIBKEEPASS_API bool operator==(const secure_string& lhs, const secure_string& rhs);
 
LIBKEEPASS_API bool operator!=(const secure_string& lhs, const secure_string& rhs);
 
LIBKEEPASS_API bool operator==(const secure_string& lhs, const std::string& rhs);
 
LIBKEEPASS_API bool operator==(const std::string& lhs, const secure_string& rhs);
 
LIBKEEPASS_API bool operator!=(const secure_string& lhs, const std::string& rhs);
 
LIBKEEPASS_API bool operator!=(const std::string& lhs, const secure_string& rhs);
 
LIBKEEPASS_API bool operator==(const secure_string& lhs, const char* rhs);
 
LIBKEEPASS_API bool operator==(const char* lhs, const secure_string& rhs);
 
LIBKEEPASS_API bool operator!=(const secure_string& lhs, const char* rhs);
 
LIBKEEPASS_API bool operator!=(const char* lhs, const secure_string& rhs);
 
LIBKEEPASS_API std::ostream& operator<<(std::ostream& os, const secure_string& str);
 
} // namespace keepass