Implement serialization for the blinds cache

Author: j-berman

src/fcmp_pp/blinds_cache.cpp

@@ -29,8 +29,17 @@
 #pragma once
 
 #include "common/threadpool.h"
+#include "common/unordered_containers_boost_serialization.h"
 #include "curve_trees.h"
 #include "fcmp_pp_types.h"
+#include "serialization/containers.h"
+#include "serialization/crypto.h"
+#include "serialization/pair.h"
+#include "serialization/serialization.h"
+
+#include <boost/serialization/deque.hpp>
+#include <boost/serialization/vector.hpp>
+#include <boost/serialization/version.hpp>
 
 #include <deque>
 #include <memory>
@@ -43,20 +52,44 @@ namespace fcmp_pp
 namespace curve_trees
 {
 //----------------------------------------------------------------------------------------------------------------------
-struct PendingBlind final
+static constexpr int BLINDS_CACHE_VERSION = 0;
+//----------------------------------------------------------------------------------------------------------------------
+struct OutputBlinds final
 {
-    uint8_t *result{nullptr};
-    PendingBlind() : result{nullptr} {};
+    FcmpRerandomizedOutputCompressed rerandomized_output;
+
+    std::shared_ptr<OutputBlind> blinded_o_blind;
+    std::shared_ptr<OutputBlind> blinded_i_blind;
+    std::shared_ptr<OutputBlind> blinded_i_blind_blind;
+    std::shared_ptr<OutputBlind> blinded_c_blind;
 };
 
-struct PendingOutputBlinds final
+struct SerializableOutputBlinds final
 {
-    FcmpRerandomizedOutputCompressed rerandomized_output;
-
-    std::shared_ptr<PendingBlind> blinded_o_blind;
-    std::shared_ptr<PendingBlind> blinded_i_blind;
-    std::shared_ptr<PendingBlind> blinded_i_blind_blind;
-    std::shared_ptr<PendingBlind> blinded_c_blind;
+    SerializableRerandomizedOutput rerandomized_output;
+
+    OutputBlind blinded_o_blind;
+    OutputBlind blinded_i_blind;
+    OutputBlind blinded_i_blind_blind;
+    OutputBlind blinded_c_blind;
+
+    template <class Archive>
+    inline void serialize(Archive &a, const unsigned int ver)
+    {
+        a & rerandomized_output;
+        a & blinded_o_blind;
+        a & blinded_i_blind;
+        a & blinded_i_blind_blind;
+        a & blinded_c_blind;
+    }
+
+    BEGIN_SERIALIZE_OBJECT()
+        FIELD(rerandomized_output)
+        FIELD(blinded_o_blind)
+        FIELD(blinded_i_blind)
+        FIELD(blinded_i_blind_blind)
+        FIELD(blinded_c_blind)
+    END_SERIALIZE()
 };
 //----------------------------------------------------------------------------------------------------------------------
 template<typename C1, typename C2>
@@ -94,24 +127,32 @@ class BlindsCache final
 
 // Internal helper functions
 private:
-    std::shared_ptr<PendingBlind> get_blinded_o_blind_async(const SeleneScalar o_blind);
-    std::shared_ptr<PendingBlind> get_blinded_i_blind_async(const SeleneScalar i_blind);
-    std::shared_ptr<PendingBlind> get_blinded_i_blind_blind_async(const SeleneScalar i_blind_blind);
-    std::shared_ptr<PendingBlind> get_blinded_c_blind_async(const SeleneScalar c_blind);
+    std::shared_ptr<OutputBlind> get_blinded_o_blind_async(const SeleneScalar o_blind);
+    std::shared_ptr<OutputBlind> get_blinded_i_blind_async(const SeleneScalar i_blind);
+    std::shared_ptr<OutputBlind> get_blinded_i_blind_blind_async(const SeleneScalar i_blind_blind);
+    std::shared_ptr<OutputBlind> get_blinded_c_blind_async(const SeleneScalar c_blind);
+
+    std::shared_ptr<BranchBlind> get_c1_branch_blind_async();
+    std::shared_ptr<BranchBlind> get_c2_branch_blind_async();
 
-    std::shared_ptr<PendingBlind> get_c1_branch_blind_async();
-    std::shared_ptr<PendingBlind> get_c2_branch_blind_async();
+    void export_serializable_members(std::unordered_map<OutputPairRef, SerializableOutputBlinds> &output_blinds_out,
+        std::vector<BranchBlind> &c1_branch_blinds_out,
+        std::vector<BranchBlind> &c2_branch_blinds_out);
+
+    void import_serializable_members(std::unordered_map<OutputPairRef, SerializableOutputBlinds> &&output_blinds,
+        std::vector<BranchBlind> &&c1_branch_blinds,
+        std::vector<BranchBlind> &&c2_branch_blinds);
 
 // State held in memory
 private:
     std::mutex m_mutex;
 
     uint8_t m_n_tree_layers;
 
-    std::unordered_map<OutputPairRef, PendingOutputBlinds> m_output_blindings;
+    std::unordered_map<OutputPairRef, OutputBlinds> m_output_blindings;
 
-    std::deque<std::shared_ptr<PendingBlind>> m_pending_c1_branch_blinds;
-    std::deque<std::shared_ptr<PendingBlind>> m_pending_c2_branch_blinds;
+    std::deque<std::shared_ptr<BranchBlind>> m_pending_c1_branch_blinds;
+    std::deque<std::shared_ptr<BranchBlind>> m_pending_c2_branch_blinds;
 
 // Config
 private:
@@ -122,18 +163,47 @@ class BlindsCache final
     tools::threadpool::waiter m_waiter;
 
 // Serialization
-// TODO: serialization: grab the lock and wait for all tasks to finish, read all results from pending objects into serializable data types
-// TODO: de-serialization: grab the lock and wait for all tasks to finish, clear all pending objects, initialze pending objects by reading the serializable data types
-// public:
-//     template <class Archive>
-//     inline void serialize(Archive &a, const unsigned int ver)
-//     {
-
-//     }
-
-//     BEGIN_SERIALIZE_OBJECT()
-
-//     END_SERIALIZE()
+public:
+    template <class Archive>
+    inline void serialize(Archive &a, const unsigned int ver)
+    {
+        std::unordered_map<OutputPairRef, SerializableOutputBlinds> output_blinds;
+        std::vector<BranchBlind> c1_branch_blinds;
+        std::vector<BranchBlind> c2_branch_blinds;
+
+        if (typename Archive::is_saving())
+           this->export_serializable_members(output_blinds, c1_branch_blinds, c2_branch_blinds);
+
+        a & output_blinds;
+        a & c1_branch_blinds;
+        a & c2_branch_blinds;
+
+        if (!typename Archive::is_saving())
+            this->import_serializable_members(std::move(output_blinds),
+                std::move(c1_branch_blinds),
+                std::move(c2_branch_blinds));
+    }
+
+    BEGIN_SERIALIZE_OBJECT()
+        VERSION_FIELD(BLINDS_CACHE_VERSION)
+
+        std::unordered_map<OutputPairRef, SerializableOutputBlinds> output_blinds;
+        std::vector<BranchBlind> c1_branch_blinds;
+        std::vector<BranchBlind> c2_branch_blinds;
+
+        if (typename Archive<W>::is_saving())
+            this->export_serializable_members(output_blinds, c1_branch_blinds, c2_branch_blinds);
+
+        FIELD(output_blinds)
+        FIELD(c1_branch_blinds)
+        FIELD(c2_branch_blinds)
+
+        if (!typename Archive<W>::is_saving())
+            this->import_serializable_members(std::move(output_blinds),
+                std::move(c1_branch_blinds),
+                std::move(c2_branch_blinds));
+
+    END_SERIALIZE()
 };
 
 using BlindsCacheV1 = BlindsCache<Selene, Helios>;
@@ -143,3 +213,23 @@ using BlindsCacheV1 = BlindsCache<Selene, Helios>;
 }//namespace curve_trees
 }//namespace fcmp_pp
 
+// Since BOOST_CLASS_VERSION does not work for templated class, implement it
+namespace boost
+{
+namespace serialization
+{
+template<typename C1, typename C2>
+struct version<fcmp_pp::curve_trees::BlindsCache<C1, C2>>
+{
+    typedef mpl::int_<fcmp_pp::curve_trees::BLINDS_CACHE_VERSION> type;
+    typedef mpl::integral_c_tag tag;
+    static constexpr int value = version::type::value;
+    BOOST_MPL_ASSERT((
+        boost::mpl::less<
+            boost::mpl::int_<fcmp_pp::curve_trees::BLINDS_CACHE_VERSION>,
+            boost::mpl::int_<256>
+        >
+    ));
+};
+}
+}

src/fcmp_pp/blinds_cache.h

@@ -145,6 +145,12 @@ struct ObjectSlice
   uintptr_t len;
 };
 
+struct U8Slice
+{
+  const uint8_t *buf;
+  uintptr_t len;
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -211,14 +217,33 @@ CResult blind_i_blind(const struct SeleneScalar *i_blind);
 CResult blind_i_blind_blind(const struct SeleneScalar *i_blind_blind);
 CResult blind_c_blind(const struct SeleneScalar *c_blind);
 
+CResult o_blind_to_buf(const uint8_t *o_blind);
+CResult i_blind_to_buf(const uint8_t *i_blind);
+CResult i_blind_blind_to_buf(const uint8_t *i_blind_blind);
+CResult c_blind_to_buf(const uint8_t *c_blind);
+
+CResult o_blind_from_buf(struct U8Slice o_blind);
+CResult i_blind_from_buf(struct U8Slice i_blind);
+CResult i_blind_blind_from_buf(struct U8Slice i_blind_blind);
+CResult c_blind_from_buf(struct U8Slice c_blind);
+
 CResult output_blinds_new(const uint8_t *o_blind,
                                              const uint8_t *i_blind,
                                              const uint8_t *i_blind_blind,
                                              const uint8_t *c_blind);
 
+CResult output_blinds_to_buf(const uint8_t *output_blinds);
+CResult output_blinds_from_buf(struct U8Slice output_blinds);
+
 CResult helios_branch_blind(void);
 CResult selene_branch_blind(void);
 
+CResult selene_branch_blind_to_buf(const uint8_t *selene_blind);
+CResult helios_branch_blind_to_buf(const uint8_t *helios_blind);
+
+CResult selene_branch_blind_from_buf(struct U8Slice selene_blind);
+CResult helios_branch_blind_from_buf(struct U8Slice helios_blind);
+
 CResult fcmp_prove_input_new(const struct FcmpRerandomizedOutputCompressed *rerandomized_output,
                                         const uint8_t *path,
                                         const uint8_t *output_blinds,

src/fcmp_pp/fcmp_pp_rust/fcmp++.h

@@ -103,6 +103,14 @@ const unsafe fn slice_from_raw_parts_0able<'a, T>(p: *const T, len: usize) -> &'
     }
 }
 
+fn buf_to_slice(buf: Vec<u8>) -> Slice<u8> {
+    // Leak the buf into a ptr that the C++ can handle
+    // TODO: Use Box::leak instead, and then in destructor convert back to box https://doc.rust-lang.org/std/boxed/struct.Box.html#method.leak
+    let len = buf.len();
+    let ptr = buf.leak().as_ptr();
+    Slice::<u8>{ buf: ptr, len }
+}
+
 fn ed25519_point_from_bytes(ed25519_point: *const u8) -> EdwardsPoint {
     let mut ed25519_point = unsafe { core::slice::from_raw_parts(ed25519_point, 32) };
     // TODO: Return an error here (instead of unwrapping)
@@ -392,6 +400,37 @@ pub unsafe extern "C" fn blind_o_blind(
     }
 }
 
+macro_rules! buf_conversion_fns {
+    ($typename:ident, $trait:ty, $to_buf_fn:ident, $from_buf_fn:ident) => {
+        #[no_mangle]
+        pub unsafe extern "C" fn $to_buf_fn(
+            blind: *const $typename<$trait>,
+        ) -> CResult<Slice<u8>, ()> {
+            let blind = blind.read();
+            let mut buf = vec![];
+            let Ok(_) = blind.write(&mut buf) else {
+                // TODO: no empty err
+                return CResult::err(());
+            };
+            CResult::ok(buf_to_slice(buf))
+        }
+
+        #[no_mangle]
+        pub unsafe extern "C" fn $from_buf_fn(
+            blind: Slice<u8>,
+        ) -> CResult<$typename<$trait>, ()> {
+            let mut buf: &[u8] = blind.into();
+            let Ok(blind) = $typename::<$trait>::read(&mut buf) else {
+                // TODO: no empty err
+                return CResult::err(());
+            };
+            CResult::ok(blind)
+        }
+    };
+}
+
+buf_conversion_fns!(OBlind, EdwardsPoint, o_blind_to_buf, o_blind_from_buf);
+
 //---------------------------------------------- CBlind
 
 /// # Safety
@@ -425,6 +464,8 @@ pub unsafe extern "C" fn blind_c_blind(
     }
 }
 
+buf_conversion_fns!(CBlind, EdwardsPoint, c_blind_to_buf, c_blind_from_buf);
+
 //---------------------------------------------- IBlind
 
 /// # Safety
@@ -458,6 +499,8 @@ pub unsafe extern "C" fn blind_i_blind(
     }
 }
 
+buf_conversion_fns!(IBlind, EdwardsPoint, i_blind_to_buf, i_blind_from_buf);
+
 //---------------------------------------------- IBlindBlind
 
 /// # Safety
@@ -491,6 +534,13 @@ pub unsafe extern "C" fn blind_i_blind_blind(
     }
 }
 
+buf_conversion_fns!(
+    IBlindBlind,
+    EdwardsPoint,
+    i_blind_blind_to_buf,
+    i_blind_blind_from_buf
+);
+
 //---------------------------------------------- OutputBlinds
 
 /// # Safety
@@ -520,6 +570,13 @@ pub unsafe extern "C" fn output_blinds_new(
     CResult::ok(ob)
 }
 
+buf_conversion_fns!(
+    OutputBlinds,
+    EdwardsPoint,
+    output_blinds_to_buf,
+    output_blinds_from_buf
+);
+
 //---------------------------------------------- BranchBlind
 
 #[no_mangle]
@@ -538,6 +595,19 @@ pub extern "C" fn selene_branch_blind() -> CResult<BranchBlind<<Selene as Cipher
     ))
 }
 
+buf_conversion_fns!(
+    BranchBlind,
+    <Helios as Ciphersuite>::G,
+    helios_branch_blind_to_buf,
+    helios_branch_blind_from_buf
+);
+buf_conversion_fns!(
+    BranchBlind,
+    <Selene as Ciphersuite>::G,
+    selene_branch_blind_to_buf,
+    selene_branch_blind_from_buf
+);
+
 //-------------------------------------------------------------------------------------- Fcmp
 
 #[derive(Clone)]