Fix testbed shamir seed

Author: Max-7

.cspell/custom-words.txt

@@ -367,6 +367,7 @@ secretkeybytes
 secretservice
 sectionauthor
 seealso
+seedable
 seedbytes
 Sellsy
 SEPA

Cargo.lock

@@ -21,6 +21,8 @@ serde = { workspace = true, features = ["derive", "rc"] }
 serde_with = { workspace = true }
 rmp-serde = { workspace = true }
 lazy_static = { workspace = true }
+# Used to deterministically generate shamir recovery shares (see `events.rs`)
+rand = { workspace = true, features = ["std", "std_rng"] }
 reqwest = { workspace = true, features = ["native-tls", "query"] }
 regex = { workspace = true, features = ["std", "perf", "unicode"] }
 log = { workspace = true }

libparsec/crates/testbed/Cargo.toml

@@ -2168,11 +2168,23 @@ impl TestbedEventNewShamirRecovery {
             NonZeroU8::try_from(total_share_count).expect("Share must be > 0")
         };
 
+        // The shares must be generated deterministically: the testbed materializes
+        // this shamir recovery setup independently on the client and on the server,
+        // and recovering the secret only works if every party's share belongs to
+        // the same secret sharing polynomial. Seeding the RNG from `data_key` (which
+        // is itself deterministically derived from the template builder counters)
+        // guarantees byte-identical share certificates across processes.
+        let mut rng = {
+            let mut seed = <rand::rngs::StdRng as rand::SeedableRng>::Seed::default();
+            seed.copy_from_slice(self.data_key.as_ref());
+            <rand::rngs::StdRng as rand::SeedableRng>::from_seed(seed)
+        };
+
         let mut shark_shares = ShamirRecoverySecret {
             data_key: self.data_key.clone(),
             reveal_token: self.reveal_token,
         }
-        .dump_and_encrypt_into_shares(self.threshold, total_share_count)
+        .dump_and_encrypt_into_shares_with_rng(self.threshold, total_share_count, &mut rng)
         .into_iter();
 
         for (recipient, shares_count) in &self.per_recipient_shares {

libparsec/crates/testbed/src/template/events.rs

@@ -45,12 +45,30 @@ impl ShamirRecoverySecret {
         &self,
         threshold: NonZeroU8,
         shares: NonZeroU8,
+    ) -> Vec<ShamirShare> {
+        self.dump_and_encrypt_into_shares_with_rng(threshold, shares, &mut rand::thread_rng())
+    }
+
+    /// Same as [`Self::dump_and_encrypt_into_shares`], but the share generation is
+    /// driven by the provided RNG.
+    ///
+    /// This is only useful for testing purpose: passing a seeded RNG makes the
+    /// output deterministic, so that a given shamir recovery setup yields
+    /// byte-identical share certificates across processes (e.g. the testbed
+    /// generates the certificates independently on the client and on the server,
+    /// and combining shares obtained from different parties only works if both
+    /// sides used the same secret sharing polynomial).
+    pub fn dump_and_encrypt_into_shares_with_rng(
+        &self,
+        threshold: NonZeroU8,
+        shares: NonZeroU8,
+        rng: &mut impl rand::Rng,
     ) -> Vec<ShamirShare> {
         let secret = self.dump();
 
         let blahaj = blahaj::Sharks(threshold.get());
         blahaj
-            .dealer(&secret)
+            .dealer_rng(&secret, rng)
             .map(ShamirShare)
             // Note, unlike what Sharks's documentation claims, at most
             // 255 shares can be generated !