updated build system

support/src/utils/encryption.cpp

@@ -65,21 +65,20 @@ auto read_encrypted_range(const http_range &range,
                           const utils::encryption::hash_256_t &key,
                           reader_func_t reader_func, std::uint64_t total_size,
                           data_buffer &data) -> bool {
-  const auto encrypted_chunk_size =
+  auto encrypted_chunk_size =
       utils::encryption::encrypting_reader::get_encrypted_chunk_size();
-  const auto data_chunk_size =
+  auto data_chunk_size =
       utils::encryption::encrypting_reader::get_data_chunk_size();
 
-  const auto start_chunk =
-      static_cast<std::size_t>(range.begin / data_chunk_size);
-  const auto end_chunk = static_cast<std::size_t>(range.end / data_chunk_size);
+  auto start_chunk = static_cast<std::size_t>(range.begin / data_chunk_size);
+  auto end_chunk = static_cast<std::size_t>(range.end / data_chunk_size);
   auto remain = range.end - range.begin + 1U;
   auto source_offset = static_cast<std::size_t>(range.begin % data_chunk_size);
 
   for (std::size_t chunk = start_chunk; chunk <= end_chunk; chunk++) {
     data_buffer cypher;
-    const auto start_offset = chunk * encrypted_chunk_size;
-    const auto end_offset = std::min(
+    auto start_offset = chunk * encrypted_chunk_size;
+    auto end_offset = std::min(
         start_offset + (total_size - (chunk * data_chunk_size)) +
             encryption_header_size - 1U,
         static_cast<std::uint64_t>(start_offset + encrypted_chunk_size - 1U));
@@ -94,7 +93,7 @@ auto read_encrypted_range(const http_range &range,
     }
     cypher.clear();
 
-    const auto data_size = static_cast<std::size_t>(std::min(
+    auto data_size = static_cast<std::size_t>(std::min(
         remain, static_cast<std::uint64_t>(data_chunk_size - source_offset)));
     std::copy(std::next(source_buffer.begin(),
                         static_cast<std::int64_t>(source_offset)),
@@ -107,6 +106,58 @@ auto read_encrypted_range(const http_range &range,
 
   return true;
 }
+
+auto read_encrypted_range(const http_range &range,
+                          const utils::encryption::hash_256_t &key,
+                          reader_func_t reader_func, std::uint64_t total_size,
+                          unsigned char *data, std::size_t size,
+                          std::size_t &bytes_read) -> bool {
+  bytes_read = 0U;
+
+  auto encrypted_chunk_size =
+      utils::encryption::encrypting_reader::get_encrypted_chunk_size();
+  auto data_chunk_size =
+      utils::encryption::encrypting_reader::get_data_chunk_size();
+
+  auto start_chunk = static_cast<std::size_t>(range.begin / data_chunk_size);
+  auto end_chunk = static_cast<std::size_t>(range.end / data_chunk_size);
+  auto remain = range.end - range.begin + 1U;
+  auto source_offset = static_cast<std::size_t>(range.begin % data_chunk_size);
+
+  std::span dest_buffer(data, size);
+  for (std::size_t chunk = start_chunk; chunk <= end_chunk; chunk++) {
+    data_buffer cypher;
+    auto start_offset = chunk * encrypted_chunk_size;
+    auto end_offset = std::min(
+        start_offset + (total_size - (chunk * data_chunk_size)) +
+            encryption_header_size - 1U,
+        static_cast<std::uint64_t>(start_offset + encrypted_chunk_size - 1U));
+
+    if (not reader_func(cypher, start_offset, end_offset)) {
+      return false;
+    }
+
+    data_buffer source_buffer;
+    if (not utils::encryption::decrypt_data(key, cypher, source_buffer)) {
+      return false;
+    }
+    cypher.clear();
+
+    auto data_size = static_cast<std::size_t>(std::min(
+        remain, static_cast<std::uint64_t>(data_chunk_size - source_offset)));
+    std::copy(
+        std::next(source_buffer.begin(),
+                  static_cast<std::int64_t>(source_offset)),
+        std::next(source_buffer.begin(),
+                  static_cast<std::int64_t>(source_offset + data_size)),
+        std::next(dest_buffer.begin(), static_cast<std::int64_t>(bytes_read)));
+    remain -= data_size;
+    bytes_read += data_size;
+    source_offset = 0U;
+  }
+
+  return true;
+}
 #endif // defined(PROJECT_ENABLE_CURL)
 } // namespace repertory::utils::encryption
 

support/src/utils/file_enc_file.cpp

@@ -23,31 +23,166 @@
 
 #include "utils/file_enc_file.hpp"
 
+#include "utils/common.hpp"
+#include "utils/encrypting_reader.hpp"
+#include "utils/encryption.hpp"
+
 namespace repertory::utils::file {
-auto enc_file::attach_file(fs_file_t file) -> fs_file_t {}
+auto enc_file::attach_file(fs_file_t file) -> fs_file_t {
+  return fs_file_t{
+      new enc_file(std::move(file)),
+  };
+}
 
 enc_file::enc_file(fs_file_t file) : file_(std::move(file)) {}
 
-void enc_file::close() {}
+void enc_file::close() { file_->close(); }
 
-auto enc_file::copy_to(std::string_view new_path,
-                       bool overwrite) const -> bool {}
+auto enc_file::copy_to(std::string_view new_path, bool overwrite) const
+    -> bool {
+  return file_->copy_to(new_path, overwrite);
+}
 
-void enc_file::flush() const {}
+void enc_file::flush() const { return file_->flush(); }
 
-auto enc_file::move_to(std::string_view path) -> bool {}
+auto enc_file::move_to(std::string_view path) -> bool {
+  return file_->move_to(path);
+}
 
 auto enc_file::read(unsigned char *data, std::size_t to_read,
-                    std::uint64_t offset, std::size_t *total_read) -> bool {}
+                    std::uint64_t offset, std::size_t *total_read) -> bool {
+  if (total_read != nullptr) {
+    *total_read = 0U;
+  }
 
-auto enc_file::remove() -> bool {}
+  auto file_size{size()};
+  if (not file_size.has_value()) {
+    return false;
+  }
 
-auto enc_file::truncate(std::size_t size) -> bool {}
+  to_read = utils::calculate_read_size(file_size.value(), to_read, offset);
+  if (to_read == 0U) {
+    return true;
+  }
+
+  std::size_t bytes_read{};
+  auto ret{
+      utils::encryption::read_encrypted_range(
+          {offset, offset + to_read - 1U},
+          utils::encryption::generate_key<utils::encryption::hash_256_t>(
+              encryption_token_),
+          [&](auto &&ct_buffer, auto &&start_offset,
+              auto &&end_offset) -> bool {
+            ct_buffer.resize(end_offset - start_offset + 1U);
+            return file_->read(ct_buffer, start_offset);
+          },
+          file_size.value(), data, to_read, bytes_read),
+  };
+  if (ret && total_read != nullptr) {
+    *total_read = bytes_read;
+  }
+
+  return ret;
+}
+
+auto enc_file::remove() -> bool { return file_->remove(); }
+
+auto enc_file::truncate(std::size_t size) -> bool {
+  if (size == 0U) {
+    return file_->truncate(size);
+  }
+
+  auto file_size{this->size()};
+  if (not file_size.has_value()) {
+    return false;
+  }
+
+  if (size == file_size.value()) {
+    return true;
+  }
+
+  auto chunks{
+      size / utils::encryption::encrypting_reader::get_data_chunk_size(),
+  };
+  auto real_size{
+      (chunks * utils::encryption::encrypting_reader::get_data_chunk_size()) +
+          (chunks * utils::encryption::encrypting_reader::get_header_size()),
+  };
+  auto remain{
+      size % utils::encryption::encrypting_reader::get_data_chunk_size(),
+  };
+  if (remain > 0U) {
+    real_size +=
+        (remain + utils::encryption::encrypting_reader::get_header_size());
+  }
+
+  if (size < file_size.value()) {
+    if (remain == 0U) {
+      return file_->truncate(real_size);
+    }
+
+    auto begin_chunk{
+        size / utils::encryption::encrypting_reader::get_data_chunk_size(),
+    };
+
+    auto offset{
+        begin_chunk *
+            utils::encryption::encrypting_reader::get_data_chunk_size(),
+    };
+
+    std::size_t total_read{};
+    data_buffer data(
+        utils::encryption::encrypting_reader::get_data_chunk_size());
+    if (not read(data, offset), &total_read) {
+      return false;
+    }
+    data.resize(remain);
+
+    if (not file_->truncate(real_size)) {
+      return false;
+    }
+
+    return write(data, offset);
+  }
+
+  auto begin_chunk{
+      file_size.value() /
+          utils::encryption::encrypting_reader::get_data_chunk_size(),
+  };
+  auto end_chunk{
+      utils::divide_with_ceiling(
+          file_size.value(),
+          utils::encryption::encrypting_reader::get_data_chunk_size()),
+  };
+
+  return false;
+}
 
 auto enc_file::write(const unsigned char *data, std::size_t to_write,
-                     std::size_t offset, std::size_t *total_written) -> bool {}
+                     std::size_t offset, std::size_t *total_written) -> bool {
+  auto file_size{size()};
+  if (not file_size.has_value()) {
+    return false;
+  }
 
-auto enc_file::size() const -> std::optional<std::uint64_t> {}
+  if ((offset + to_write) > file_size.value()) {
+    if (not truncate((offset + to_write) - file_size.value())) {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+auto enc_file::size() const -> std::optional<std::uint64_t> {
+  auto file_size = file_->size();
+  if (not file_size.has_value()) {
+    return std::nullopt;
+  }
+
+  return utils::encryption::encrypting_reader::calculate_decrypted_size(
+      file_size.value());
+}
 } // namespace repertory::utils::file
 
 #endif // defined(PROJECT_ENABLE_LIBSODIUM) && defined(PROJECT_ENABLE_BOOST)