feat: musig2 support

Author: dufkan

Cargo.lock

@@ -18,7 +18,7 @@ tempfile = "3.3.0"
 lazy_static = "1.4.0"
 openssl = "0.10.60"
 sha2 = "0.10.6"
-meesign-crypto = { git = "https://github.com/crocs-muni/meesign-crypto", rev = "b0e7f14", default-features = false, features = ["elgamal-encrypt"] }
+meesign-crypto = { git = "https://github.com/crocs-muni/meesign-crypto", rev = "ccf6b1d", default-features = false, features = ["elgamal-encrypt"] }
 
 [build-dependencies]
 tonic-build = "0.10"

Cargo.toml

@@ -28,6 +28,7 @@ enum ProtocolType {
   GG18 = 0;
   ELGAMAL = 1;
   FROST = 2;
+  MUSIG2 = 3;
 }
 
 enum KeyType {

proto/meesign.proto

@@ -31,6 +31,7 @@ mod proto {
                 meesign_crypto::proto::ProtocolType::Gg18 => ProtocolType::Gg18,
                 meesign_crypto::proto::ProtocolType::Elgamal => ProtocolType::Elgamal,
                 meesign_crypto::proto::ProtocolType::Frost => ProtocolType::Frost,
+                meesign_crypto::proto::ProtocolType::Musig2 => ProtocolType::Musig2,
             }
         }
     }
@@ -41,14 +42,15 @@ mod proto {
                 ProtocolType::Gg18 => meesign_crypto::proto::ProtocolType::Gg18,
                 ProtocolType::Elgamal => meesign_crypto::proto::ProtocolType::Elgamal,
                 ProtocolType::Frost => meesign_crypto::proto::ProtocolType::Frost,
+                ProtocolType::Musig2 => meesign_crypto::proto::ProtocolType::Musig2,
             }
         }
     }
 
     impl ProtocolType {
         pub fn index_offset(&self) -> u32 {
             match self {
-                ProtocolType::Gg18 | ProtocolType::Elgamal => 0,
+                ProtocolType::Gg18 | ProtocolType::Elgamal | ProtocolType::Musig2 => 0,
                 ProtocolType::Frost => 1,
             }
         }

src/main.rs

@@ -4,13 +4,15 @@ use crate::proto::ProtocolType;
 pub mod elgamal;
 pub mod frost;
 pub mod gg18;
+pub mod musig2;
 
 impl ProtocolType {
     pub fn check_threshold(self, threshold: u32, group_size: u32) -> bool {
         match self {
             ProtocolType::Gg18 | ProtocolType::Elgamal | ProtocolType::Frost => {
                 threshold >= 2 && threshold <= group_size
             }
+            ProtocolType::Musig2 => threshold >= 2 && threshold == group_size,
         }
     }
 }

src/protocols/mod.rs

@@ -0,0 +1,112 @@
+use crate::communicator::Communicator;
+use crate::proto::ProtocolType;
+use crate::protocols::Protocol;
+use meesign_crypto::proto::{Message, ProtocolGroupInit, ProtocolInit};
+use meesign_crypto::protocol::musig2 as protocol;
+
+pub struct MuSig2Group {
+    parties: u32,
+    round: u16,
+}
+
+impl MuSig2Group {
+    pub fn new(parties: u32) -> Self {
+        Self { parties, round: 0 }
+    }
+}
+
+impl Protocol for MuSig2Group {
+    fn initialize(&mut self, communicator: &mut Communicator, _: &[u8]) {
+        communicator.set_active_devices();
+        let parties = self.parties;
+        communicator.send_all(|idx| {
+            (ProtocolGroupInit {
+                protocol_type: meesign_crypto::proto::ProtocolType::Musig2 as i32,
+                index: idx,
+                parties,
+                threshold: parties,
+            })
+            .encode_to_vec()
+        });
+
+        self.round = 1;
+    }
+
+    fn advance(&mut self, communicator: &mut Communicator) {
+        assert!((0..self.last_round()).contains(&self.round));
+
+        communicator.relay();
+        self.round += 1;
+    }
+
+    fn finalize(&mut self, communicator: &mut Communicator) -> Option<Vec<u8>> {
+        assert_eq!(self.last_round(), self.round);
+        self.round += 1;
+        communicator.get_final_message()
+    }
+
+    fn round(&self) -> u16 {
+        self.round
+    }
+
+    fn last_round(&self) -> u16 {
+        protocol::KEYGEN_ROUNDS
+    }
+
+    fn get_type(&self) -> ProtocolType {
+        ProtocolType::Musig2
+    }
+}
+
+pub struct MuSig2Sign {
+    round: u16,
+}
+
+impl MuSig2Sign {
+    pub fn new() -> Self {
+        Self { round: 0 }
+    }
+}
+
+impl Protocol for MuSig2Sign {
+    fn initialize(&mut self, communicator: &mut Communicator, data: &[u8]) {
+        communicator.set_active_devices();
+        let participant_indices = communicator.get_protocol_indices();
+        communicator.send_all(|idx| {
+            (ProtocolInit {
+                protocol_type: meesign_crypto::proto::ProtocolType::Musig2 as i32,
+                indices: participant_indices.clone(),
+                index: idx,
+                data: Vec::from(data),
+            })
+            .encode_to_vec()
+        });
+
+        self.round = 1;
+    }
+
+    fn advance(&mut self, communicator: &mut Communicator) {
+        assert!((0..self.last_round()).contains(&self.round));
+
+        communicator.relay();
+        self.round += 1;
+    }
+
+    fn finalize(&mut self, communicator: &mut Communicator) -> Option<Vec<u8>> {
+        assert_eq!(self.last_round(), self.round);
+        self.round += 1;
+        communicator.get_final_message()
+    }
+
+    fn round(&self) -> u16 {
+        self.round
+    }
+
+    fn last_round(&self) -> u16 {
+        protocol::SIGN_ROUNDS
+    }
+
+    fn get_type(&self) -> ProtocolType {
+        ProtocolType::Musig2
+    }
+}

src/protocols/musig2.rs

@@ -5,6 +5,7 @@ use crate::proto::{KeyType, ProtocolType, TaskType};
 use crate::protocols::elgamal::ElgamalGroup;
 use crate::protocols::frost::FROSTGroup;
 use crate::protocols::gg18::GG18Group;
+use crate::protocols::musig2::MuSig2Group;
 use crate::protocols::Protocol;
 use crate::tasks::{Task, TaskResult, TaskStatus};
 use crate::{get_timestamp, utils};
@@ -51,6 +52,9 @@ impl GroupTask {
             (ProtocolType::Frost, KeyType::SignChallenge) => {
                 Box::new(FROSTGroup::new(devices_len, threshold))
             }
+            (ProtocolType::Musig2, KeyType::SignChallenge) => {
+                Box::new(MuSig2Group::new(devices_len))
+            }
             (ProtocolType::Elgamal, KeyType::Decrypt) => {
                 Box::new(ElgamalGroup::new(devices_len, threshold))
             }

src/tasks/group.rs

@@ -4,6 +4,7 @@ use crate::group::Group;
 use crate::proto::{ProtocolType, SignRequest, TaskType};
 use crate::protocols::frost::FROSTSign;
 use crate::protocols::gg18::GG18Sign;
+use crate::protocols::musig2::MuSig2Sign;
 use crate::protocols::Protocol;
 use crate::tasks::{Task, TaskResult, TaskStatus};
 use crate::{get_timestamp, utils};
@@ -46,6 +47,7 @@ impl SignTask {
             protocol: match protocol_type {
                 ProtocolType::Gg18 => Box::new(GG18Sign::new()),
                 ProtocolType::Frost => Box::new(FROSTSign::new()),
+                ProtocolType::Musig2 => Box::new(MuSig2Sign::new()),
                 _ => {
                     warn!("Protocol type {:?} does not support signing", protocol_type);
                     return Err("Unsupported protocol type for signing".into());