.

Author: argmarco-tkd

CMakeLists.txt

@@ -129,6 +129,7 @@ add_library(dbps_common_lib STATIC
 )
 target_include_directories(dbps_common_lib PUBLIC
   src/common
+  src/server
   ${CMAKE_BINARY_DIR}/_deps/crow-src/include
   ${CMAKE_BINARY_DIR}/_deps/cppcodec-src
 )

src/common/value_encryption_utils.cpp

@@ -230,21 +230,16 @@ inline void append_f64_le(std::vector<uint8_t>& out, double v) {
 }
 } // anon
 
-//TODO: we need a better name. 
+// TODO: find better name?
 std::vector<uint8_t> EncryptTypedListValues(
-    const std::vector<TypedListValues>& elements,
+    const TypedListValues& elements,
     const std::vector<uint8_t>& key) {
     std::vector<EncryptedValue> encrypted_elements;
-    if (elements.empty()) {
-        return ConcatenateEncryptedValues(encrypted_elements);
-    }
 
-    // Determine the concrete vector/element type from the first entry
-    std::visit([&](const auto& first_vec) {
-        typedef std::decay_t<decltype(first_vec)> VecT;
+    std::visit([&](const auto& vec) {
+        typedef std::decay_t<decltype(vec)> VecT;
         typedef typename VecT::value_type ElemT;
 
-        // Serializer for a single element
         auto serialize = [&](const ElemT& elem) -> std::vector<uint8_t> {
             std::vector<uint8_t> serialized;
             if constexpr (std::is_same<ElemT, int32_t>::value) {
@@ -269,20 +264,12 @@ std::vector<uint8_t> EncryptTypedListValues(
             return serialized;
         };
 
-        // Process all entries, assuming homogeneous type across elements
-        for (size_t i = 0; i < elements.size(); ++i) {
-            const TypedListValues& v = elements[i];
-            if (!std::holds_alternative<VecT>(v)) {
-                throw std::runtime_error("EncryptTypedListValues: heterogeneous TypedListValues not supported");
-            }
-            const VecT& vec = std::get<VecT>(v);
-            for (size_t j = 0; j < vec.size(); ++j) {
-                const ElemT& elem = vec[j];
-                std::vector<uint8_t> bytes = serialize(elem);
-                encrypted_elements.push_back(EncryptValue(bytes, key));
-            }
+        for (size_t i = 0; i < vec.size(); ++i) {
+            const ElemT& elem = vec[i];
+            std::vector<uint8_t> bytes = serialize(elem);
+            encrypted_elements.push_back(EncryptValue(bytes, key));
         }
-    }, elements.front());
+    }, elements);
 
     return ConcatenateEncryptedValues(encrypted_elements);
 }
@@ -433,7 +420,7 @@ TypedListValues DecryptTypedListValues(
 }
 
 std::vector<uint8_t> EncryptTypedListValuesWithLevelBytes(
-    const std::vector<TypedListValues>& elements,
+    const TypedListValues& elements,
     const std::vector<uint8_t>& level_bytes,
     const std::vector<uint8_t>& key) {
 
@@ -463,7 +450,5 @@ std::pair<TypedListValues, std::vector<uint8_t> > DecryptTypedListValuesWithLeve
     TypedListValues values = DecryptTypedListValues(encrypted_values_blob, datatype, key);
     return std::make_pair(values, level_bytes);
 }
- 
-
 
 } // namespace dbps::value_encryption_utils

src/common/value_encryption_utils.h

@@ -105,17 +105,17 @@ std::vector<std::vector<uint8_t> > ParseBuffersWithLength(const std::vector<uint
  * @param key Byte-array key for XOR encryption (cycled per byte)
  * @return Concatenated binary blob of encrypted, length-prefixed element payloads
  */
+// Single TypedListValues input
 std::vector<uint8_t> EncryptTypedListValues(
-    const std::vector<TypedListValues>& elements,
+    const TypedListValues& elements,
     const std::vector<uint8_t>& key);
-
 /**
  * Variant of EncryptTypedListValues that also prefixes the resulting encrypted values
  * alongside provided level bytes using ConcatenateBuffersWithLength:
  *   buffers = [encrypted_values_blob, level_bytes]
  */
 std::vector<uint8_t> EncryptTypedListValuesWithLevelBytes(
-    const std::vector<TypedListValues>& elements,
+    const TypedListValues& elements,
     const std::vector<uint8_t>& level_bytes,
     const std::vector<uint8_t>& key);
 

src/common/value_encryption_utils_test.cpp

@@ -209,11 +209,8 @@ static std::vector<uint8_t> serialize_i32_le(int32_t v) {
 }
 
 TEST(ValueEncryptionUtilsTest, EncryptTypedListValuesWithLevelBytesRoundTrip) {
-    // Homogeneous TypedListValues: all int32_t vectors
-    std::vector<TypedListValues> elements;
-    elements.push_back(std::vector<int32_t>{10, -20, 30});
-    elements.push_back(std::vector<int32_t>{}); // empty chunk
-    elements.push_back(std::vector<int32_t>{-1});
+    // Homogeneous TypedListValues: single int32_t vector
+    TypedListValues elements = std::vector<int32_t>{10, -20, 30, -1};
 
     std::vector<uint8_t> level_bytes;
     level_bytes.push_back(0xAA);
@@ -243,7 +240,6 @@ TEST(ValueEncryptionUtilsTest, EncryptTypedListValuesWithLevelBytesRoundTrip) {
     expected_serialized.push_back(serialize_i32_le(10));
     expected_serialized.push_back(serialize_i32_le(-20));
     expected_serialized.push_back(serialize_i32_le(30));
-    // empty chunk contributes 0 elements
     expected_serialized.push_back(serialize_i32_le(-1));
 
     ASSERT_EQ(encrypted_values.size(), expected_serialized.size());
@@ -254,12 +250,8 @@ TEST(ValueEncryptionUtilsTest, EncryptTypedListValuesWithLevelBytesRoundTrip) {
 }
 
 TEST(ValueEncryptionUtilsTest, DecryptTypedListValuesWithLevelBytesRoundTrip) {
-    // Build inputs
-    std::vector<TypedListValues> elements;
-    elements.push_back(std::vector<int32_t>{1, 2, 3});
-
-    //TODO: this should not be supported - revise - we intend to only support homogeneous typed lists.
-    elements.push_back(std::vector<int32_t>{-7});
+    // Build inputs (single list)
+    TypedListValues elements = std::vector<int32_t>{1, 2, 3, -7};
 
     std::vector<uint8_t> level_bytes;
     level_bytes.push_back(0x10);