updated build system

support/include/utils/encryption.hpp

@@ -178,6 +178,18 @@ encrypt_data(const std::array<unsigned char,
                          reinterpret_cast<const unsigned char *>(buf.data()),
                          buf.size(), res);
 }
+
+#if defined(PROJECT_ENABLE_CURL)
+using reader_func_t =
+    std::function<bool(data_buffer &cypher_text, std::uint64_t start_offset,
+                       std::uint64_t end_offset)>;
+
+[[nodiscard]] 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;
+#endif // defined(PROJECT_ENABLE_CURL)
 #endif // defined(PROJECT_ENABLE_BOOST)
 
 template <typename hash_t>

support/src/utils/encryption.cpp

@@ -62,6 +62,55 @@ auto decrypt_file_name(std::string_view encryption_token,
 
   return true;
 }
+
+#if defined(PROJECT_ENABLE_CURL)
+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 =
+      utils::encryption::encrypting_reader::get_encrypted_chunk_size();
+  const 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 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(
+        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();
+
+    const 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::back_inserter(data));
+    remain -= data_size;
+    source_offset = 0U;
+  }
+
+  return false;
+}
+#endif // defined(PROJECT_ENABLE_CURL)
 } // namespace repertory::utils::encryption
 
 #endif // defined(PROJECT_ENABLE_LIBSODIUM) && defined (PROJECT_ENABLE_BOOST)