Replace Misbehave with Extend

Author: fjarri

Cargo.lock

@@ -4,4 +4,4 @@ pub mod simple;
 pub mod simple_chain;
 
 #[cfg(test)]
-mod simple_malicious;
+mod simple_test;

examples/src/lib.rs

@@ -0,0 +1,152 @@
+use alloc::collections::BTreeSet;
+
+use core::marker::PhantomData;
+
+use manul::{
+    combinators::extend::{Extendable, Extension},
+    dev::{run_sync, BinaryFormat, TestSessionParams, TestSigner, TestVerifier},
+    protocol::{LocalError, PartyId, StaticRound},
+    signature::Keypair,
+};
+use rand_core::{CryptoRngCore, OsRng};
+use test_log::test;
+
+use crate::simple::{Round1, Round1Message, Round2, Round2Message, SimpleProtocolEntryPoint};
+
+#[derive(Debug, Clone)]
+struct Round1InvalidDirectMessage<Id>(PhantomData<Id>);
+
+impl<Id> Extension<Id> for Round1InvalidDirectMessage<Id>
+where
+    Id: PartyId,
+{
+    type Round = Round1<Id>;
+
+    fn extend_direct_message(
+        &self,
+        _rng: &mut dyn CryptoRngCore,
+        round: &Self::Round,
+        _destination: &Id,
+    ) -> Result<
+        Option<(
+            <Self::Round as StaticRound<Id>>::DirectMessage,
+            <Self::Round as StaticRound<Id>>::Artifact,
+        )>,
+        LocalError,
+    > {
+        Ok(Some((
+            Round1Message {
+                my_position: round.context.ids_to_positions[&round.context.id],
+                your_position: round.context.ids_to_positions[&round.context.id],
+            },
+            (),
+        )))
+    }
+}
+
+#[test]
+fn round1_attributable_failure() {
+    let signers = (0..3).map(TestSigner::new).collect::<Vec<_>>();
+    let all_ids = signers
+        .iter()
+        .map(|signer| signer.verifying_key())
+        .collect::<BTreeSet<_>>();
+
+    let entry_points = signers
+        .iter()
+        .enumerate()
+        .map(|(idx, signer)| {
+            let entry_point = SimpleProtocolEntryPoint::new(all_ids.clone());
+            let mut entry_point = Extendable::new(entry_point);
+            if idx == 0 {
+                entry_point.extend(Round1InvalidDirectMessage::<TestVerifier>(PhantomData));
+            }
+
+            (*signer, entry_point)
+        })
+        .collect::<Vec<_>>();
+
+    let mut reports = run_sync::<_, TestSessionParams<BinaryFormat>>(&mut OsRng, entry_points)
+        .unwrap()
+        .reports;
+
+    let v0 = signers[0].verifying_key();
+    let v1 = signers[1].verifying_key();
+    let v2 = signers[2].verifying_key();
+
+    let _report0 = reports.remove(&v0).unwrap();
+    let report1 = reports.remove(&v1).unwrap();
+    let report2 = reports.remove(&v2).unwrap();
+
+    assert!(report1.provable_errors[&v0].verify(&()).is_ok());
+    assert!(report2.provable_errors[&v0].verify(&()).is_ok());
+}
+
+#[derive(Debug, Clone)]
+struct Round2InvalidDirectMessage<Id>(PhantomData<Id>);
+
+impl<Id> Extension<Id> for Round2InvalidDirectMessage<Id>
+where
+    Id: PartyId,
+{
+    type Round = Round2<Id>;
+
+    fn extend_direct_message(
+        &self,
+        _rng: &mut dyn CryptoRngCore,
+        round: &Self::Round,
+        _destination: &Id,
+    ) -> Result<
+        Option<(
+            <Self::Round as StaticRound<Id>>::DirectMessage,
+            <Self::Round as StaticRound<Id>>::Artifact,
+        )>,
+        LocalError,
+    > {
+        Ok(Some((
+            Round2Message {
+                my_position: round.context.ids_to_positions[&round.context.id],
+                your_position: round.context.ids_to_positions[&round.context.id],
+            },
+            (),
+        )))
+    }
+}
+
+#[test]
+fn round2_attributable_failure() {
+    let signers = (0..3).map(TestSigner::new).collect::<Vec<_>>();
+    let all_ids = signers
+        .iter()
+        .map(|signer| signer.verifying_key())
+        .collect::<BTreeSet<_>>();
+
+    let entry_points = signers
+        .iter()
+        .enumerate()
+        .map(|(idx, signer)| {
+            let entry_point = SimpleProtocolEntryPoint::new(all_ids.clone());
+            let mut entry_point = Extendable::new(entry_point);
+            if idx == 0 {
+                entry_point.extend(Round2InvalidDirectMessage::<TestVerifier>(PhantomData));
+            }
+
+            (*signer, entry_point)
+        })
+        .collect::<Vec<_>>();
+
+    let mut reports = run_sync::<_, TestSessionParams<BinaryFormat>>(&mut OsRng, entry_points)
+        .unwrap()
+        .reports;
+
+    let v0 = signers[0].verifying_key();
+    let v1 = signers[1].verifying_key();
+    let v2 = signers[2].verifying_key();
+
+    let _report0 = reports.remove(&v0).unwrap();
+    let report1 = reports.remove(&v1).unwrap();
+    let report2 = reports.remove(&v2).unwrap();
+
+    assert!(report1.provable_errors[&v0].verify(&()).is_ok());
+    assert!(report2.provable_errors[&v0].verify(&()).is_ok());
+}

examples/src/simple_malicious.rs

@@ -22,6 +22,7 @@ tracing = { version = "0.1", default-features = false }
 displaydoc = { version = "0.2", default-features = false }
 derive-where = { version = "1.5", default-features = false, features = ["serde"] }
 tinyvec = { version = "1", default-features = false, features = ["alloc", "serde"] }
+dyn-clone = "1"
 
 # Optional dependencies
 rand = { version = "0.8", default-features = false, optional = true }

examples/src/simple_test.rs

@@ -1,4 +1,4 @@
 //! Combinators operating on protocols.
 
 pub mod chain;
-pub mod misbehave;
+pub mod extend;