stream.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 <algorithm>
#include <array>
#include <cassert>
#include <cstring>
#include <istream>
#include <memory>
#include <ostream>
#include <vector>
 
#include <zlib.h>
 
#include "libkeepass/detail/limits.hh"
#include "libkeepass/export.hh"
#include "util.hh"
 
namespace keepass {
 
template <std::size_t N> class Cipher;
class ChaCha20Cipher;
 
template <std::size_t N>
class array_iostreambuf : public std::basic_streambuf<char, std::char_traits<char>> {
private:
  std::array<uint8_t, N>& buffer_;
 
protected:
  std::streampos seekoff(std::streamoff off, std::ios_base::seekdir way,
                         std::ios_base::openmode which) override {
    if (which == 0)
      return {std::streamoff(-1)};
 
    off = clamp<std::streamoff>(0, static_cast<long long>(buffer_.size()), off);
 
    std::streamoff lin_off = 0;
    switch (way) {
    case std::ios_base::beg:
      lin_off = clamp<std::streamoff>(0, static_cast<long long>(buffer_.size()), off);
      break;
    case std::ios_base::cur:
      lin_off = clamp<std::streamoff>(0, static_cast<long long>(buffer_.size()),
                                      (gptr() - eback()) + off);
      break;
    case std::ios_base::end:
      lin_off = clamp<std::streamoff>(0, static_cast<std::streamoff>(buffer_.size()),
                                      static_cast<std::streamoff>(buffer_.size()) - off);
      break;
    default:
      assert(false);
      break;
    };
 
    if (which & std::ios_base::in) {
      char* buffer_ptr = reinterpret_cast<char*>(buffer_.data());
      setg(buffer_ptr, buffer_ptr + lin_off, buffer_ptr + buffer_.size());
    }
 
    return lin_off;
  }
 
  std::streampos seekpos(std::streampos sp, std::ios_base::openmode which) override {
    if (which == 0 || sp < 0 || sp >= static_cast<std::streamoff>(buffer_.size())) {
      return {std::streamoff(-1)};
      ;
    }
 
    if (which & std::ios_base::in) {
      char* buffer_ptr = reinterpret_cast<char*>(buffer_.data());
      setg(buffer_ptr, buffer_ptr + sp, buffer_ptr + buffer_.size());
    }
 
    return sp;
  }
 
public:
  explicit array_iostreambuf(std::array<uint8_t, N>& buffer) : buffer_(buffer) {
    char* buffer_ptr = reinterpret_cast<char*>(buffer.data());
    setg(buffer_ptr, buffer_ptr, buffer_ptr + buffer.size());
    setp(buffer_ptr, buffer_ptr + buffer.size());
  }
};
 
class hashed_basic_streambuf {
protected:
  struct BlockHeader {
    uint32_t block_index{};
    std::array<uint8_t, 32> block_hash{};
    uint32_t block_size = 0;
  };
 
  uint32_t block_index_ = 0;
  std::vector<char> block_;
 
  std::array<uint8_t, 32> GetBlockHash() const;
 
public:
  virtual ~hashed_basic_streambuf();
};
 
class LIBKEEPASS_API hashed_istreambuf final
    : private hashed_basic_streambuf,
      public std::basic_streambuf<char, std::char_traits<char>> {
private:
  std::istream& src_;
  detail::ResourceLimits limits_;
 
  uint64_t decoded_bytes_ = 0;
 
  bool budget_exceeded_ = false;
 
public:
  explicit hashed_istreambuf(std::istream& src) : src_(src) {}
 
  bool BudgetExceeded() const { return budget_exceeded_; }
 
  hashed_istreambuf(std::istream& src, const detail::ResourceLimits& limits)
      : src_(src), limits_(limits) {}
 
  int underflow() override;
};
 
class LIBKEEPASS_API hashed_ostreambuf final
    : private hashed_basic_streambuf,
      public std::basic_streambuf<char, std::char_traits<char>> {
private:
  static constexpr uint32_t kDefaultBlockSize = 1024 * 1024;
 
  std::ostream& dst_;
  const uint32_t block_size_;
 
  bool FlushBlock();
 
public:
  explicit hashed_ostreambuf(std::ostream& dst) : dst_(dst), block_size_(kDefaultBlockSize) {}
 
  hashed_ostreambuf(std::ostream& dst, uint32_t block_size) : dst_(dst), block_size_(block_size) {}
 
  int overflow(int c) override;
 
  int sync() override;
};
 
class LIBKEEPASS_API hmac_istreambuf final
    : public std::basic_streambuf<char, std::char_traits<char>> {
private:
  std::istream& src_;
  std::array<uint8_t, 64> hmac_key_ = {{0}};
  detail::ResourceLimits limits_;
 
  uint64_t block_index_ = 0;
  std::vector<char> block_;
 
  uint64_t decoded_bytes_ = 0;
 
  bool budget_exceeded_ = false;
 
  std::array<uint8_t, 64> GetCurrentHmacKey() const;
 
public:
  hmac_istreambuf(std::istream& src, const uint8_t* hmac_key) : src_(src) {
    if (hmac_key != nullptr)
      std::memcpy(hmac_key_.data(), hmac_key, hmac_key_.size());
  }
 
  bool BudgetExceeded() const { return budget_exceeded_; }
 
  hmac_istreambuf(std::istream& src, const uint8_t* hmac_key, const detail::ResourceLimits& limits)
      : src_(src), limits_(limits) {
    if (hmac_key != nullptr)
      std::memcpy(hmac_key_.data(), hmac_key, hmac_key_.size());
  }
 
  ~hmac_istreambuf();
 
  int underflow() override;
};
 
class LIBKEEPASS_API hmac_ostreambuf final
    : public std::basic_streambuf<char, std::char_traits<char>> {
private:
  static constexpr uint32_t kDefaultBlockSize = 1024 * 1024;
 
  std::ostream& dst_;
  std::array<uint8_t, 64> hmac_key_ = {{0}};
  const uint32_t block_size_;
 
  uint64_t block_index_ = 0;
  std::vector<char> block_;
 
  std::array<uint8_t, 64> GetCurrentHmacKey() const;
 
  bool FlushBlock();
 
public:
  hmac_ostreambuf(std::ostream& dst, const uint8_t* hmac_key)
      : dst_(dst), block_size_(kDefaultBlockSize) {
    if (hmac_key != nullptr)
      std::memcpy(hmac_key_.data(), hmac_key, hmac_key_.size());
  }
 
  hmac_ostreambuf(std::ostream& dst, const uint8_t* hmac_key, uint32_t block_size)
      : dst_(dst), block_size_(block_size) {
    if (hmac_key != nullptr)
      std::memcpy(hmac_key_.data(), hmac_key, hmac_key_.size());
  }
 
  ~hmac_ostreambuf();
 
  int overflow(int c) override;
 
  int sync() override;
};
 
class LIBKEEPASS_API gzip_istreambuf final
    : public std::basic_streambuf<char, std::char_traits<char>> {
private:
  static const std::size_t kBufferSize = 16384;
 
  std::istream& src_;
  detail::ResourceLimits limits_;
  z_stream z_stream_{};
 
  std::array<char, kBufferSize> input_ = {{0}};
  std::array<char, kBufferSize> output_ = {{0}};
 
  uint64_t decoded_bytes_ = 0;
 
  bool budget_exceeded_ = false;
 
  void Init();
 
public:
  explicit gzip_istreambuf(std::istream& src) : src_(src) { Init(); }
 
  gzip_istreambuf(std::istream& src, const detail::ResourceLimits& limits)
      : src_(src), limits_(limits) {
    Init();
  }
 
  ~gzip_istreambuf() override;
 
  bool BudgetExceeded() const { return budget_exceeded_; }
 
  int underflow() override;
};
 
class LIBKEEPASS_API gzip_ostreambuf final
    : public std::basic_streambuf<char, std::char_traits<char>> {
private:
  static const std::size_t kBufferSize = 16384;
 
  std::ostream& dst_;
  z_stream z_stream_{};
 
  std::vector<char> buffer_;
 
  bool WriteOutput(bool flush);
 
public:
  explicit gzip_ostreambuf(std::ostream& dst);
 
  ~gzip_ostreambuf() override;
 
  int overflow(int c) override;
 
  int sync() override;
};
 
class LIBKEEPASS_API encrypt_ostreambuf final
    : public std::basic_streambuf<char, std::char_traits<char>> {
private:
  static constexpr std::size_t kChaChaBlockSize = 64;
 
  std::ostream& dst_;
  Cipher<16>* const block_cipher_;
  ChaCha20Cipher* const chacha_cipher_;
 
  std::array<uint8_t, 64> pending_{};
  std::size_t pending_n_ = 0;
  std::array<uint8_t, 16> prev_block_{};
  bool finalized_ = false;
 
  bool FlushPending();
 
public:
  encrypt_ostreambuf(std::ostream& dst, Cipher<16>& cipher);
 
  encrypt_ostreambuf(std::ostream& dst, ChaCha20Cipher& cipher);
 
  ~encrypt_ostreambuf() override;
 
  int overflow(int c) override;
 
  std::streamsize xsputn(const char* s, std::streamsize count) override;
 
  int sync() override;
};
 
} // namespace keepass