2.0.0-rc (#9)

### Issues

* \#1 \[bug\] Unable to mount S3 due to 'item_not_found' exception
* \#2 Require bucket name for S3 mounts
* \#3 \[bug\] File size is not being updated in S3 mount
* \#4 Upgrade to libfuse-3.x.x
* \#5 Switch to renterd for Sia support
* \#6 Switch to cpp-httplib to further reduce dependencies
* \#7 Remove global_data and calculate used disk space per provider
* \#8 Switch to libcurl for S3 mount support

### Changes from v1.x.x

* Added read-only encrypt provider
  * Pass-through mount point that transparently encrypts source data using `XChaCha20-Poly1305`
* Added S3 encryption support via `XChaCha20-Poly1305`
* Added replay protection to remote mounts
* Added support base64 writes in remote FUSE
* Created static linked Linux binaries for `amd64` and `aarch64` using `musl-libc`
* Removed legacy Sia renter support
* Removed Skynet support
* Fixed multiple remote mount WinFSP API issues on \*NIX servers
* Implemented chunked read and write
  * Writes for non-cached files are performed in chunks of 8Mib
* Removed `repertory-ui` support
* Removed `FreeBSD` support
* Switched to `libsodium` over `CryptoPP`
* Switched to `XChaCha20-Poly1305` for remote mounts
* Updated `GoogleTest` to v1.14.0
* Updated `JSON for Modern C++` to v3.11.2
* Updated `OpenSSL` to v1.1.1w
* Updated `RocksDB` to v8.5.3
* Updated `WinFSP` to 2023
* Updated `boost` to v1.78.0
* Updated `cURL` to v8.3.0
* Updated `zlib` to v1.3
* Use `upload_manager` for all providers
  * Adds a delay to uploads to prevent excessive API calls
  * Supports re-upload after mount restart for incomplete uploads
  * NOTE: Uploads for all providers are full file (no resume support)
    * Multipart upload support is planned for S3

Reviewed-on: #9

include/utils/encrypting_reader.hpp

@@ -1,48 +1,67 @@
 /*
-  Copyright <2018-2022> <scott.e.graves@protonmail.com>
+  Copyright <2018-2023> <scott.e.graves@protonmail.com>
 
-  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-  associated documentation files (the "Software"), to deal in the Software without restriction,
-  including without limitation the rights to use, copy, modify, merge, publish, distribute,
-  sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
   furnished to do so, subject to the following conditions:
 
-  The above copyright notice and this permission notice shall be included in all copies or
-  substantial portions of the Software.
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
 
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-  OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
 */
 #ifndef INCLUDE_UTILS_ENCRYPTING_READER_HPP_
 #define INCLUDE_UTILS_ENCRYPTING_READER_HPP_
 
-#include "common.hpp"
+#include "types/repertory.hpp"
 #include "utils/file_utils.hpp"
 
 namespace repertory::utils::encryption {
+using key_type = std::array<unsigned char, 32U>;
+
 class encrypting_reader final {
 public:
-  encrypting_reader(const std::string &file_name, const std::string &source_path,
-                    const bool &stop_requested, const std::string &token,
-                    const size_t error_return = 0);
+  encrypting_reader(
+      const std::string &file_name, const std::string &source_path,
+      stop_type &stop_requested, const std::string &token,
+      std::optional<std::string> relative_parent_path = std::nullopt,
+      const size_t error_return = 0);
+
+  encrypting_reader(
+      const std::string &encrypted_file_path, const std::string &source_path,
+      stop_type &stop_requested, const std::string &token,
+      std::vector<std::array<unsigned char,
+                             crypto_aead_xchacha20poly1305_IETF_NPUBBYTES>>
+          iv_list,
+      const size_t error_return = 0);
 
   encrypting_reader(const encrypting_reader &r);
 
   ~encrypting_reader();
 
 public:
-  typedef std::basic_iostream<char, std::char_traits<char>> iostream;
-  typedef std::basic_streambuf<char, std::char_traits<char>> streambuf;
+  using iostream = std::basic_iostream<char, std::char_traits<char>>;
+  using streambuf = std::basic_streambuf<char, std::char_traits<char>>;
 
 private:
-  const CryptoPP::SecByteBlock key_;
-  const bool &stop_requested_;
+  const key_type key_;
+  stop_type &stop_requested_;
   const size_t error_return_;
-  std::unordered_map<std::size_t, std::vector<char>> chunk_buffers_;
+  std::unordered_map<std::size_t, data_buffer> chunk_buffers_;
   std::string encrypted_file_name_;
+  std::string encrypted_file_path_;
+  std::vector<
+      std::array<unsigned char, crypto_aead_xchacha20poly1305_IETF_NPUBBYTES>>
+      iv_list_;
   std::size_t last_data_chunk_ = 0u;
   std::size_t last_data_chunk_size_ = 0u;
   std::uint64_t read_offset_ = 0u;
@@ -55,32 +74,63 @@ private:
   static const std::size_t encrypted_chunk_size_;
 
 private:
-  size_t reader_function(char *buffer, size_t size, size_t nitems);
+  auto reader_function(char *buffer, size_t size, size_t nitems) -> size_t;
 
 public:
-  static std::uint64_t calculate_decrypted_size(const std::uint64_t &total_size);
+  [[nodiscard]] static auto calculate_decrypted_size(std::uint64_t total_size)
+      -> std::uint64_t;
 
-  std::shared_ptr<iostream> create_iostream() const;
+  [[nodiscard]] static auto
+  calculate_encrypted_size(const std::string &source_path) -> std::uint64_t;
 
-  static constexpr const std::size_t &get_encrypted_chunk_size() { return encrypted_chunk_size_; }
+  [[nodiscard]] auto create_iostream() const -> std::shared_ptr<iostream>;
 
-  static constexpr const std::size_t &get_data_chunk_size() { return data_chunk_size_; }
-
-  std::string get_encrypted_file_name() const { return encrypted_file_name_; }
-
-  std::size_t get_error_return() const { return error_return_; }
-
-  static constexpr const std::size_t &get_header_size() { return header_size_; }
-
-  const bool &get_stop_requested() const { return stop_requested_; }
-
-  std::uint64_t get_total_size() const { return total_size_; }
-
-  static size_t reader_function(char *buffer, size_t size, size_t nitems, void *instream) {
-    return reinterpret_cast<encrypting_reader *>(instream)->reader_function(buffer, size, nitems);
+  [[nodiscard]] static constexpr auto get_encrypted_chunk_size()
+      -> std::size_t {
+    return encrypted_chunk_size_;
   }
 
-  void set_read_position(const std::uint64_t &position) { read_offset_ = position; }
+  [[nodiscard]] static constexpr auto get_data_chunk_size() -> std::size_t {
+    return data_chunk_size_;
+  }
+
+  [[nodiscard]] auto get_encrypted_file_name() const -> std::string {
+    return encrypted_file_name_;
+  }
+
+  [[nodiscard]] auto get_encrypted_file_path() const -> std::string {
+    return encrypted_file_path_;
+  }
+
+  [[nodiscard]] auto get_error_return() const -> std::size_t {
+    return error_return_;
+  }
+
+  [[nodiscard]] static constexpr auto get_header_size() -> std::size_t {
+    return header_size_;
+  }
+
+  [[nodiscard]] auto get_iv_list() -> std::vector<
+      std::array<unsigned char, crypto_aead_xchacha20poly1305_IETF_NPUBBYTES>> {
+    return iv_list_;
+  }
+
+  [[nodiscard]] auto get_stop_requested() const -> bool {
+    return stop_requested_;
+  }
+
+  [[nodiscard]] auto get_total_size() const -> std::uint64_t {
+    return total_size_;
+  }
+
+  [[nodiscard]] static auto reader_function(char *buffer, size_t size,
+                                            size_t nitems, void *instream)
+      -> size_t {
+    return reinterpret_cast<encrypting_reader *>(instream)->reader_function(
+        buffer, size, nitems);
+  }
+
+  void set_read_position(std::uint64_t position) { read_offset_ = position; }
 };
 } // namespace repertory::utils::encryption