crypto_secure.h

#ifndef SOURCEMETA_CORE_CRYPTO_SECURE_H_
#define SOURCEMETA_CORE_CRYPTO_SECURE_H_
 
#ifndef SOURCEMETA_CORE_CRYPTO_EXPORT
#include <sourcemeta/core/crypto_export.h>
#endif
 
#include <cstddef>     // std::size_t
#include <functional>  // std::less
#include <limits>      // std::numeric_limits
#include <new>         // operator new, operator delete, std::align_val_t
#include <string>      // std::string
#include <string_view> // std::string_view
#include <vector>      // std::vector
 
namespace sourcemeta::core {

inline auto secure_zero(void *const data, const std::size_t size) noexcept
    -> void {
  if (data == nullptr) {
    return;
  }
 
  auto *pointer{static_cast<volatile unsigned char *>(data)};
  for (std::size_t index{0}; index < size; index += 1) {
    pointer[index] = 0;
  }
}

inline auto secure_zero(std::string &value) noexcept -> void {
  secure_zero(value.data(), value.size());
}

struct SecureStringScope {
  explicit SecureStringScope(std::string &value) noexcept : target{value} {}
  SecureStringScope(const SecureStringScope &) = delete;
  auto operator=(const SecureStringScope &) -> SecureStringScope & = delete;
  SecureStringScope(SecureStringScope &&) = delete;
  auto operator=(SecureStringScope &&) -> SecureStringScope & = delete;
  ~SecureStringScope() { secure_zero(this->target); }
  std::string &target;
};

template <typename T> struct SecureAllocator {
  using value_type = T;

  SecureAllocator() noexcept = default;

  template <typename Other>
  constexpr SecureAllocator(const SecureAllocator<Other> &) noexcept {}

  [[nodiscard]] auto allocate(const std::size_t count) -> T * {
    if (count > std::numeric_limits<std::size_t>::max() / sizeof(T)) {
      throw std::bad_array_new_length{};
    }
 
    return static_cast<T *>(
        ::operator new(count * sizeof(T), std::align_val_t{alignof(T)}));
  }

  auto deallocate(T *const pointer, const std::size_t count) noexcept -> void {
    secure_zero(pointer, count * sizeof(T));
    ::operator delete(pointer, std::align_val_t{alignof(T)});
  }

  template <typename Other>
  auto operator==(const SecureAllocator<Other> &) const noexcept -> bool {
    return true;
  }

  template <typename Other>
  auto operator!=(const SecureAllocator<Other> &) const noexcept -> bool {
    return false;
  }
};

class SecureString {
public:
  using size_type = std::vector<char, SecureAllocator<char>>::size_type;

  SecureString() = default;

  SecureString(const std::string_view value)
      : buffer_(value.begin(), value.end()) {}

  SecureString(const char *const data, const size_type length)
      : buffer_(data, data + length) {}

  SecureString(const size_type count, const char value)
      : buffer_(count, value) {}

  [[nodiscard]] auto size() const noexcept -> size_type {
    return this->buffer_.size();
  }

  [[nodiscard]] auto empty() const noexcept -> bool {
    return this->buffer_.empty();
  }

  auto reserve(const size_type capacity) -> void {
    this->buffer_.reserve(capacity);
  }

  [[nodiscard]] auto capacity() const noexcept -> size_type {
    return this->buffer_.capacity();
  }

  auto resize(const size_type count, const char value) -> void {
    this->buffer_.resize(count, value);
  }

  auto push_back(const char value) -> void { this->buffer_.push_back(value); }

  auto append(const std::string_view value) -> void {
    // Inserting a range whose iterators point into this container is undefined,
    // so a view that aliases the storage is taken through an independent buffer
    // that wipes itself, while an independent view is inserted directly. The
    // ordering uses the total order over pointers, which is defined even for
    // pointers into different objects
    const char *const first{this->buffer_.data()};
    const std::less<const char *> before{};
    if (!this->buffer_.empty() && !before(value.data(), first) &&
        before(value.data(), first + this->buffer_.size())) {
      const std::vector<char, SecureAllocator<char>> copy(value.begin(),
                                                          value.end());
      this->buffer_.insert(this->buffer_.end(), copy.begin(), copy.end());
    } else {
      this->buffer_.insert(this->buffer_.end(), value.begin(), value.end());
    }
  }

  auto append(const size_type count, const char value) -> void {
    this->buffer_.insert(this->buffer_.end(), count, value);
  }

  [[nodiscard]] auto operator[](const size_type index) noexcept -> char & {
    return this->buffer_[index];
  }

  [[nodiscard]] auto operator[](const size_type index) const noexcept -> char {
    return this->buffer_[index];
  }

  [[nodiscard]] auto front() const noexcept -> char {
    return this->buffer_.front();
  }

  [[nodiscard]] auto back() const noexcept -> char {
    return this->buffer_.back();
  }

  [[nodiscard]] operator std::string_view() const noexcept {
    // An empty buffer may expose a null data pointer, so a default view is
    // returned rather than constructing one from a possibly-null pointer
    if (this->buffer_.empty()) {
      return {};
    }
 
    return {this->buffer_.data(), this->buffer_.size()};
  }

  [[nodiscard]] auto data() const noexcept -> const char * {
    return this->buffer_.data();
  }

  [[nodiscard]] auto operator==(const std::string_view other) const noexcept
      -> bool {
    return std::string_view{*this} == other;
  }
 
private:
  std::vector<char, SecureAllocator<char>> buffer_;
};
 
} // namespace sourcemeta::core
 
#endif