1use core::num::TryFromIntError;
2use hashbrown::{HashMap, HashSet};
3use rand_core::{CryptoRng, RngCore};
4use std::{
5 collections::{BTreeMap, BTreeSet},
6 fmt,
7};
8use tracing::{debug, error, info, trace, warn};
9
10use crate::{
11 common::{
12 check_public_shares, validate_key_id, validate_signer_id, PolyCommitment, PublicNonce,
13 TupleProof,
14 },
15 curve::{
16 ecdsa,
17 point::{Error as PointError, Point, G},
18 scalar::Scalar,
19 },
20 errors::{DkgError, EncryptionError},
21 net::{
22 BadPrivateShare, DkgBegin, DkgEnd, DkgEndBegin, DkgFailure, DkgPrivateBegin,
23 DkgPrivateShares, DkgPrivateSharesDone, DkgPrivateSharesDoneAck, DkgPublicShares,
24 DkgPublicSharesDone, DkgPublicSharesDoneAck, DkgStatus, Message, NonceRequest,
25 NonceResponse, Packet, SignatureShareRequest, SignatureShareResponse, SignatureType,
26 },
27 state_machine::{PublicKeys, StateMachine},
28 traits::{Signer as SignerTrait, SignerState as SignerSavedState},
29 util::{decrypt, encrypt, make_shared_secret},
30};
31
32#[cfg(any(test, feature = "testing"))]
33use crate::net::Signable;
34
35#[derive(Debug, Clone, PartialEq)]
36pub enum State {
38 Idle,
40 DkgPublicDistribute,
42 DkgPublicGather,
44 DkgPublicSharesDoneAck,
46 DkgPrivateDistribute,
48 DkgPrivateGather,
50 DkgPrivateSharesDoneAck,
52 SignGather,
54}
55
56#[derive(thiserror::Error, Clone, Debug)]
57pub enum ConfigError {
59 #[error("Insufficient keys for the number of signers")]
61 InsufficientKeys,
62 #[error("InvalidThreshold")]
64 InvalidThreshold,
65 #[error("Invalid signer ID {0}")]
67 InvalidSignerId(u32),
68 #[error("Invalid key ID {0}")]
70 InvalidKeyId(u32),
71}
72
73#[derive(thiserror::Error, Clone, Debug)]
74pub enum Error {
76 #[error("Config error {0}")]
78 Config(#[from] ConfigError),
79 #[error("InvalidPartyID")]
81 InvalidPartyID,
82 #[error("InvalidDkgPublicShares")]
84 InvalidDkgPublicShares,
85 #[error("InvalidDkgPrivateShares")]
87 InvalidDkgPrivateShares(Vec<u32>),
88 #[error("InvalidNonceResponse")]
90 InvalidNonceResponse,
91 #[error("InvalidSignatureShare")]
93 InvalidSignatureShare,
94 #[error("Bad State Change: {0}")]
96 BadStateChange(String),
97 #[error("Encryption error: {0}")]
99 Encryption(#[from] EncryptionError),
100 #[error("integer conversion error")]
101 TryFromInt(#[from] TryFromIntError),
103 #[error("Missing coordinator public key")]
104 MissingCoordinatorPublicKey,
106 #[error("A packet had an invalid signature")]
107 InvalidPacketSignature,
109 #[error("A curve point error {0}")]
110 Point(#[from] PointError),
112 #[error("missing kex public key for key_id {0}")]
113 MissingKexPublicKey(u32),
115}
116
117#[derive(Clone)]
119pub struct SavedState {
120 pub dkg_id: u64,
122 pub sign_id: u64,
124 pub sign_iter_id: u64,
126 pub threshold: u32,
128 pub dkg_threshold: u32,
130 pub total_signers: u32,
132 pub total_keys: u32,
134 pub signer: SignerSavedState,
136 pub signer_id: u32,
138 pub state: State,
140 pub commitments: HashMap<u32, PolyCommitment>,
143 decrypted_shares: HashMap<u32, HashMap<u32, Scalar>>,
146 decryption_keys: HashMap<u32, (u32, Point)>,
149 pub invalid_private_shares: HashMap<u32, BadPrivateShare>,
152 pub public_nonces: Vec<PublicNonce>,
154 network_private_key: Scalar,
156 pub public_keys: PublicKeys,
158 pub dkg_public_shares: BTreeMap<u32, DkgPublicShares>,
160 pub dkg_private_shares: BTreeMap<u32, DkgPrivateShares>,
162 pub dkg_private_begin_msg: Option<DkgPrivateBegin>,
164 pub dkg_end_begin_msg: Option<DkgEndBegin>,
166 pending_public_shares_done: Option<DkgPublicSharesDone>,
168 pending_private_shares_done: Option<DkgPrivateSharesDone>,
170 pub verify_packet_sigs: bool,
172 pub coordinator_public_key: Option<ecdsa::PublicKey>,
174 kex_private_key: Scalar,
176 kex_public_keys: HashMap<u32, Point>,
178 dkg_completed: bool,
180}
181
182impl fmt::Debug for SavedState {
183 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
184 f.debug_struct("SavedState")
185 .field("dkg_id", &self.dkg_id)
186 .field("sign_id", &self.sign_id)
187 .field("sign_iter_id", &self.sign_iter_id)
188 .field("threshold", &self.threshold)
189 .field("dkg_threshold", &self.dkg_threshold)
190 .field("total_signers", &self.total_signers)
191 .field("total_keys", &self.total_keys)
192 .field("signer", &self.signer)
193 .field("signer_id", &self.signer_id)
194 .field("state", &self.state)
195 .field("commitments", &self.commitments)
196 .field("invalid_private_shares", &self.invalid_private_shares)
197 .field("public_nonces", &self.public_nonces)
198 .field("public_keys", &self.public_keys)
199 .field("dkg_public_shares", &self.dkg_public_shares)
200 .field("dkg_private_begin_msg", &self.dkg_private_begin_msg)
201 .field("dkg_end_begin_msg", &self.dkg_end_begin_msg)
202 .finish_non_exhaustive()
203 }
204}
205
206#[derive(Clone, PartialEq)]
208pub struct Signer<SignerType: SignerTrait> {
209 pub dkg_id: u64,
211 pub sign_id: u64,
213 pub sign_iter_id: u64,
215 pub threshold: u32,
217 pub dkg_threshold: u32,
219 pub total_signers: u32,
221 pub total_keys: u32,
223 pub signer: SignerType,
225 pub signer_id: u32,
227 pub state: State,
229 pub commitments: HashMap<u32, PolyCommitment>,
232 pub decrypted_shares: HashMap<u32, HashMap<u32, Scalar>>,
235 pub decryption_keys: HashMap<u32, (u32, Point)>,
238 pub invalid_private_shares: HashMap<u32, BadPrivateShare>,
241 pub public_nonces: Vec<PublicNonce>,
243 pub network_private_key: Scalar,
245 pub public_keys: PublicKeys,
247 pub dkg_public_shares: BTreeMap<u32, DkgPublicShares>,
249 pub dkg_private_shares: BTreeMap<u32, DkgPrivateShares>,
251 pub dkg_private_begin_msg: Option<DkgPrivateBegin>,
253 pub dkg_end_begin_msg: Option<DkgEndBegin>,
255 pending_public_shares_done: Option<DkgPublicSharesDone>,
257 pending_private_shares_done: Option<DkgPrivateSharesDone>,
259 pub verify_packet_sigs: bool,
261 pub coordinator_public_key: Option<ecdsa::PublicKey>,
263 kex_private_key: Scalar,
265 kex_public_keys: HashMap<u32, Point>,
267 dkg_completed: bool,
269}
270
271impl<SignerType: SignerTrait> fmt::Debug for Signer<SignerType> {
272 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
273 f.debug_struct("Signer")
274 .field("dkg_id", &self.dkg_id)
275 .field("sign_id", &self.sign_id)
276 .field("sign_iter_id", &self.sign_iter_id)
277 .field("threshold", &self.threshold)
278 .field("dkg_threshold", &self.dkg_threshold)
279 .field("total_signers", &self.total_signers)
280 .field("total_keys", &self.total_keys)
281 .field("signer", &self.signer)
282 .field("signer_id", &self.signer_id)
283 .field("state", &self.state)
284 .field("commitments", &self.commitments)
285 .field("invalid_private_shares", &self.invalid_private_shares)
286 .field("public_nonces", &self.public_nonces)
287 .field("public_keys", &self.public_keys)
288 .field("dkg_public_shares", &self.dkg_public_shares)
289 .field("dkg_private_begin_msg", &self.dkg_private_begin_msg)
290 .field("dkg_end_begin_msg", &self.dkg_end_begin_msg)
291 .finish_non_exhaustive()
292 }
293}
294
295impl<SignerType: SignerTrait> Signer<SignerType> {
296 #[allow(clippy::too_many_arguments)]
298 pub fn new<R: RngCore + CryptoRng>(
299 threshold: u32,
300 dkg_threshold: u32,
301 total_signers: u32,
302 total_keys: u32,
303 signer_id: u32,
304 key_ids: Vec<u32>,
305 network_private_key: Scalar,
306 public_keys: PublicKeys,
307 rng: &mut R,
308 ) -> Result<Self, Error> {
309 if total_signers > total_keys {
310 return Err(Error::Config(ConfigError::InsufficientKeys));
311 }
312
313 if threshold == 0 || threshold > total_keys {
314 return Err(Error::Config(ConfigError::InvalidThreshold));
315 }
316
317 if dkg_threshold == 0 || dkg_threshold < threshold {
318 return Err(Error::Config(ConfigError::InvalidThreshold));
319 }
320
321 if !validate_signer_id(signer_id, total_signers) {
322 return Err(Error::Config(ConfigError::InvalidSignerId(signer_id)));
323 }
324
325 for key_id in &key_ids {
326 if !validate_key_id(*key_id, total_keys) {
327 return Err(Error::Config(ConfigError::InvalidKeyId(*key_id)));
328 }
329 }
330
331 public_keys.validate(total_signers, total_keys)?;
332
333 let mut signer = SignerType::new(
334 signer_id,
335 &key_ids,
336 total_signers,
337 total_keys,
338 threshold,
339 rng,
340 );
341
342 signer.gen_nonces(&network_private_key, rng);
344
345 debug!("new Signer for signer_id {signer_id} with key_ids {key_ids:?}");
346 Ok(Self {
347 dkg_id: 0,
348 sign_id: 1,
349 sign_iter_id: 1,
350 threshold,
351 dkg_threshold,
352 total_signers,
353 total_keys,
354 signer,
355 signer_id,
356 state: State::Idle,
357 commitments: Default::default(),
358 decrypted_shares: Default::default(),
359 decryption_keys: Default::default(),
360 invalid_private_shares: Default::default(),
361 public_nonces: vec![],
362 network_private_key,
363 public_keys,
364 dkg_public_shares: Default::default(),
365 dkg_private_shares: Default::default(),
366 dkg_private_begin_msg: Default::default(),
367 dkg_end_begin_msg: Default::default(),
368 pending_public_shares_done: None,
369 pending_private_shares_done: None,
370 verify_packet_sigs: true,
371 coordinator_public_key: None,
372 kex_private_key: Scalar::random(rng),
373 kex_public_keys: Default::default(),
374 dkg_completed: false,
375 })
376 }
377
378 pub fn load(state: &SavedState) -> Self {
380 Self {
381 dkg_id: state.dkg_id,
382 sign_id: state.sign_id,
383 sign_iter_id: state.sign_iter_id,
384 threshold: state.threshold,
385 dkg_threshold: state.dkg_threshold,
386 total_signers: state.total_signers,
387 total_keys: state.total_keys,
388 signer: SignerType::load(&state.signer),
389 signer_id: state.signer_id,
390 state: state.state.clone(),
391 commitments: state.commitments.clone(),
392 decrypted_shares: state.decrypted_shares.clone(),
393 decryption_keys: state.decryption_keys.clone(),
394 invalid_private_shares: state.invalid_private_shares.clone(),
395 public_nonces: state.public_nonces.clone(),
396 network_private_key: state.network_private_key,
397 public_keys: state.public_keys.clone(),
398 dkg_public_shares: state.dkg_public_shares.clone(),
399 dkg_private_shares: state.dkg_private_shares.clone(),
400 dkg_private_begin_msg: state.dkg_private_begin_msg.clone(),
401 dkg_end_begin_msg: state.dkg_end_begin_msg.clone(),
402 pending_public_shares_done: state.pending_public_shares_done.clone(),
403 pending_private_shares_done: state.pending_private_shares_done.clone(),
404 verify_packet_sigs: state.verify_packet_sigs,
405 coordinator_public_key: state.coordinator_public_key,
406 kex_private_key: state.kex_private_key,
407 kex_public_keys: state.kex_public_keys.clone(),
408 dkg_completed: state.dkg_completed,
409 }
410 }
411
412 pub fn save(&self) -> SavedState {
414 SavedState {
415 dkg_id: self.dkg_id,
416 sign_id: self.sign_id,
417 sign_iter_id: self.sign_iter_id,
418 threshold: self.threshold,
419 dkg_threshold: self.dkg_threshold,
420 total_signers: self.total_signers,
421 total_keys: self.total_keys,
422 signer: self.signer.save(),
423 signer_id: self.signer_id,
424 state: self.state.clone(),
425 commitments: self.commitments.clone(),
426 decrypted_shares: self.decrypted_shares.clone(),
427 decryption_keys: self.decryption_keys.clone(),
428 invalid_private_shares: self.invalid_private_shares.clone(),
429 public_nonces: self.public_nonces.clone(),
430 network_private_key: self.network_private_key,
431 public_keys: self.public_keys.clone(),
432 dkg_public_shares: self.dkg_public_shares.clone(),
433 dkg_private_shares: self.dkg_private_shares.clone(),
434 dkg_private_begin_msg: self.dkg_private_begin_msg.clone(),
435 dkg_end_begin_msg: self.dkg_end_begin_msg.clone(),
436 pending_public_shares_done: self.pending_public_shares_done.clone(),
437 pending_private_shares_done: self.pending_private_shares_done.clone(),
438 verify_packet_sigs: self.verify_packet_sigs,
439 coordinator_public_key: self.coordinator_public_key,
440 kex_private_key: self.kex_private_key,
441 kex_public_keys: self.kex_public_keys.clone(),
442 dkg_completed: self.dkg_completed,
443 }
444 }
445
446 pub fn reset<T: RngCore + CryptoRng>(&mut self, dkg_id: u64, rng: &mut T) {
448 self.dkg_id = dkg_id;
449 self.commitments.clear();
450 self.decrypted_shares.clear();
451 self.decryption_keys.clear();
452 self.invalid_private_shares.clear();
453 self.public_nonces.clear();
454 self.signer.reset_polys(rng);
455 self.dkg_public_shares.clear();
456 self.dkg_private_shares.clear();
457 self.dkg_private_begin_msg = None;
458 self.dkg_end_begin_msg = None;
459 self.pending_public_shares_done = None;
460 self.pending_private_shares_done = None;
461 self.kex_private_key = Scalar::random(rng);
462 self.kex_public_keys.clear();
463 self.dkg_completed = false;
464 self.state = State::Idle;
465 }
466
467 #[cfg(any(test, feature = "testing"))]
469 pub fn process_inbound_messages<R: RngCore + CryptoRng>(
470 &mut self,
471 packets: &[Packet],
472 rng: &mut R,
473 ) -> Result<Vec<Packet>, Error> {
474 let mut responses = vec![];
475 for packet in packets {
476 let outbounds = self.process(packet, rng)?;
477 for out in outbounds {
478 let msg = Packet {
479 sig: out
480 .sign(&self.network_private_key)
481 .expect("Failed to sign message"),
482 msg: out,
483 };
484 responses.push(msg);
485 }
486 }
487 Ok(responses)
488 }
489
490 pub fn process<R: RngCore + CryptoRng>(
492 &mut self,
493 packet: &Packet,
494 rng: &mut R,
495 ) -> Result<Vec<Message>, Error> {
496 if self.verify_packet_sigs {
497 let Some(coordinator_public_key) = self.coordinator_public_key else {
498 return Err(Error::MissingCoordinatorPublicKey);
499 };
500 if !packet.verify(&self.public_keys, &coordinator_public_key) {
501 return Err(Error::InvalidPacketSignature);
502 }
503 }
504 let out_msgs = match (&self.state, &packet.msg) {
505 (_, Message::DkgBegin(msg)) => self.dkg_begin(msg, rng),
507 (State::DkgPublicGather, Message::DkgPublicShares(msg)) => self.dkg_public_share(msg),
509 (State::DkgPublicGather, Message::DkgPublicSharesDone(msg)) => {
510 self.dkg_public_shares_done(msg)
511 }
512 (State::DkgPublicSharesDoneAck, Message::DkgPrivateBegin(msg)) => {
514 self.dkg_private_begin(msg, rng)
515 }
516 (State::DkgPrivateGather, Message::DkgPrivateShares(msg)) => {
517 self.dkg_private_shares(msg, rng)
518 }
519 (State::DkgPrivateGather, Message::DkgPrivateSharesDone(msg)) => {
520 self.dkg_private_shares_done(msg)
521 }
522 (State::DkgPrivateSharesDoneAck, Message::DkgEndBegin(msg)) => {
525 let mut out = self.dkg_end_begin(msg)?;
526 out.push(self.dkg_ended(rng)?);
527 self.move_to(State::Idle)?;
528 Ok(out)
529 }
530 (State::Idle | State::SignGather, Message::NonceRequest(msg)) => {
532 self.nonce_request(msg, rng)
533 }
534 (State::SignGather, Message::SignatureShareRequest(msg)) => {
535 self.sign_share_request(msg, rng)
536 }
537 (
539 _,
540 Message::DkgEnd(_)
541 | Message::DkgPublicSharesDoneAck(_)
542 | Message::DkgPrivateSharesDoneAck(_)
543 | Message::NonceResponse(_)
544 | Message::SignatureShareResponse(_),
545 ) => Ok(vec![]),
546 (state, msg) => {
548 warn!(
549 signer_id = %self.signer_id,
550 ?state,
551 msg_type = ?std::mem::discriminant(msg),
552 "unexpected message in state, dropping"
553 );
554 Ok(vec![])
555 }
556 };
557
558 out_msgs
559 }
560
561 pub fn dkg_ended<R: RngCore + CryptoRng>(&mut self, rng: &mut R) -> Result<Message, Error> {
563 if !self.can_dkg_end() {
564 return Ok(Message::DkgEnd(DkgEnd {
565 dkg_id: self.dkg_id,
566 signer_id: self.signer_id,
567 status: DkgStatus::Failure(DkgFailure::BadState),
568 }));
569 }
570
571 let mut missing_public_shares = HashSet::new();
573 let mut missing_private_shares = HashSet::new();
574 let mut bad_public_shares = HashSet::new();
575 let threshold: usize = self.threshold.try_into().unwrap();
576
577 let Some(dkg_end_begin) = &self.dkg_end_begin_msg else {
578 return Ok(Message::DkgEnd(DkgEnd {
580 dkg_id: self.dkg_id,
581 signer_id: self.signer_id,
582 status: DkgStatus::Failure(DkgFailure::BadState),
583 }));
584 };
585
586 let signer_ids_set: HashSet<u32> = dkg_end_begin
588 .signer_ids
589 .iter()
590 .filter(|&&id| id < self.total_signers)
591 .copied()
592 .collect::<HashSet<u32>>();
593 let mut num_dkg_keys = 0u32;
594 for id in &signer_ids_set {
595 if let Some(key_ids) = self.public_keys.signer_key_ids.get(id) {
596 let len: u32 = key_ids.len().try_into()?;
597 num_dkg_keys = num_dkg_keys.saturating_add(len);
598 }
599 }
600
601 if num_dkg_keys < self.dkg_threshold {
602 return Ok(Message::DkgEnd(DkgEnd {
603 dkg_id: self.dkg_id,
604 signer_id: self.signer_id,
605 status: DkgStatus::Failure(DkgFailure::Threshold),
606 }));
607 }
608
609 for signer_id in &signer_ids_set {
610 if let Some(shares) = self.dkg_public_shares.get(signer_id) {
611 if shares.comms.is_empty() {
612 missing_public_shares.insert(*signer_id);
613 } else {
614 for (party_id, comm) in shares.comms.iter() {
615 if !check_public_shares(comm, threshold, &self.dkg_id.to_be_bytes()) {
616 bad_public_shares.insert(*signer_id);
617 } else {
618 self.commitments.insert(*party_id, comm.clone());
619 }
620 }
621 }
622 } else {
623 missing_public_shares.insert(*signer_id);
624 }
625 if let Some(shares) = self.dkg_private_shares.get(signer_id) {
626 if shares.shares.is_empty() {
628 missing_private_shares.insert(*signer_id);
629 } else {
630 for dst_key_id in self.signer.get_key_ids() {
631 for (_src_key_id, shares) in &shares.shares {
632 if shares.get(&dst_key_id).is_none() {
633 missing_private_shares.insert(*signer_id);
634 }
635 }
636 }
637 }
638 } else {
639 missing_private_shares.insert(*signer_id);
640 }
641 }
642
643 if !missing_public_shares.is_empty() {
644 return Ok(Message::DkgEnd(DkgEnd {
645 dkg_id: self.dkg_id,
646 signer_id: self.signer_id,
647 status: DkgStatus::Failure(DkgFailure::MissingPublicShares(missing_public_shares)),
648 }));
649 }
650
651 if !bad_public_shares.is_empty() {
652 return Ok(Message::DkgEnd(DkgEnd {
653 dkg_id: self.dkg_id,
654 signer_id: self.signer_id,
655 status: DkgStatus::Failure(DkgFailure::BadPublicShares(bad_public_shares)),
656 }));
657 }
658
659 if !missing_private_shares.is_empty() {
660 return Ok(Message::DkgEnd(DkgEnd {
661 dkg_id: self.dkg_id,
662 signer_id: self.signer_id,
663 status: DkgStatus::Failure(DkgFailure::MissingPrivateShares(
664 missing_private_shares,
665 )),
666 }));
667 }
668
669 let dkg_end = if self.invalid_private_shares.is_empty() {
670 match self.signer.compute_secrets(
671 &self.decrypted_shares,
672 &self.commitments,
673 &self.dkg_id.to_be_bytes(),
674 ) {
675 Ok(()) => DkgEnd {
676 dkg_id: self.dkg_id,
677 signer_id: self.signer_id,
678 status: DkgStatus::Success,
679 },
680 Err(dkg_error_map) => {
681 let mut bad_private_shares = HashMap::new();
683 for (_my_party_id, dkg_error) in dkg_error_map {
684 if let DkgError::BadPrivateShares(party_ids) = dkg_error {
685 for party_id in party_ids {
686 if let Some((party_signer_id, _shared_key)) =
687 &self.decryption_keys.get(&party_id)
688 {
689 bad_private_shares.insert(
690 *party_signer_id,
691 self.make_bad_private_share(*party_signer_id, rng)?,
692 );
693 } else {
694 warn!("DkgError::BadPrivateShares from party_id {party_id} but no (signer_id, shared_secret) cached");
695 }
696 }
697 } else {
698 warn!("Got unexpected dkg_error {dkg_error:?}");
699 }
700 }
701 DkgEnd {
702 dkg_id: self.dkg_id,
703 signer_id: self.signer_id,
704 status: DkgStatus::Failure(DkgFailure::BadPrivateShares(
705 bad_private_shares,
706 )),
707 }
708 }
709 }
710 } else {
711 DkgEnd {
712 dkg_id: self.dkg_id,
713 signer_id: self.signer_id,
714 status: DkgStatus::Failure(DkgFailure::BadPrivateShares(
715 self.invalid_private_shares.clone(),
716 )),
717 }
718 };
719
720 if matches!(dkg_end.status, DkgStatus::Success) {
721 self.dkg_completed = true;
722 }
723
724 info!(
725 signer_id = %self.signer_id,
726 dkg_id = %self.dkg_id,
727 status = ?dkg_end.status,
728 "sending DkgEnd"
729 );
730
731 let dkg_end = Message::DkgEnd(dkg_end);
732 Ok(dkg_end)
733 }
734
735 pub fn public_shares_done(&self) -> bool {
737 debug!(
738 "public_shares_done state {:?} commitments {}",
739 self.state,
740 self.commitments.len(),
741 );
742 self.state == State::DkgPublicGather
743 && self.commitments.len() == usize::try_from(self.signer.get_num_parties()).unwrap()
744 }
745
746 pub fn can_dkg_end(&self) -> bool {
748 debug!(
749 "can_dkg_end: state {:?} DkgPrivateBegin {} DkgEndBegin {}",
750 self.state,
751 self.dkg_private_begin_msg.is_some(),
752 self.dkg_end_begin_msg.is_some(),
753 );
754
755 if self.state == State::DkgPrivateGather || self.state == State::DkgPrivateSharesDoneAck {
756 if let Some(dkg_private_begin) = &self.dkg_private_begin_msg {
757 for signer_id in &dkg_private_begin.signer_ids {
759 if !self.dkg_public_shares.contains_key(signer_id) {
760 debug!("can_dkg_end: false, missing public shares from signer {signer_id}");
761 return false;
762 }
763 }
764
765 if let Some(dkg_end_begin) = &self.dkg_end_begin_msg {
766 for signer_id in &dkg_end_begin.signer_ids {
768 if !self.dkg_private_shares.contains_key(signer_id) {
769 debug!("can_dkg_end: false, missing private shares from signer {signer_id}");
770 return false;
771 }
772 }
773 debug!("can_dkg_end: true");
774
775 return true;
776 }
777 }
778 } else {
779 debug!("can_dkg_end: false, bad state {:?}", self.state);
780 return false;
781 }
782 false
783 }
784
785 fn nonce_request<R: RngCore + CryptoRng>(
786 &mut self,
787 nonce_request: &NonceRequest,
788 rng: &mut R,
789 ) -> Result<Vec<Message>, Error> {
790 if nonce_request.dkg_id != self.dkg_id {
791 warn!(
792 signer_id = %self.signer_id,
793 got = %nonce_request.dkg_id,
794 expected = %self.dkg_id,
795 "NonceRequest dkg_id mismatch"
796 );
797 return Ok(vec![]);
798 }
799 if !self.dkg_completed {
800 warn!(
801 signer_id = %self.signer_id,
802 dkg_id = %self.dkg_id,
803 "NonceRequest rejected: DKG not completed"
804 );
805 return Ok(vec![]);
806 }
807 let mut msgs = vec![];
808 let signer_id = self.signer_id;
809 let key_ids = self.signer.get_key_ids();
810 let nonces = self.signer.gen_nonces(&self.network_private_key, rng);
811
812 let response = NonceResponse {
813 dkg_id: nonce_request.dkg_id,
814 sign_id: nonce_request.sign_id,
815 sign_iter_id: nonce_request.sign_iter_id,
816 signer_id,
817 key_ids,
818 nonces,
819 message: nonce_request.message.clone(),
820 };
821
822 let response = Message::NonceResponse(response);
823
824 info!(
825 %signer_id,
826 dkg_id = %nonce_request.dkg_id,
827 sign_id = %nonce_request.sign_id,
828 sign_iter_id = %nonce_request.sign_iter_id,
829 "sending NonceResponse"
830 );
831 msgs.push(response);
832 self.move_to(State::SignGather)?;
833
834 Ok(msgs)
835 }
836
837 fn sign_share_request<R: RngCore + CryptoRng>(
838 &mut self,
839 sign_request: &SignatureShareRequest,
840 rng: &mut R,
841 ) -> Result<Vec<Message>, Error> {
842 if sign_request.dkg_id != self.dkg_id {
843 warn!(
844 signer_id = %self.signer_id,
845 got = %sign_request.dkg_id,
846 expected = %self.dkg_id,
847 "SignatureShareRequest dkg_id mismatch"
848 );
849 return Ok(vec![]);
850 }
851 if !self.dkg_completed {
852 warn!(
853 signer_id = %self.signer_id,
854 dkg_id = %self.dkg_id,
855 "SignatureShareRequest rejected: DKG not completed"
856 );
857 return Ok(vec![]);
858 }
859 let signer_id_set = sign_request
860 .nonce_responses
861 .iter()
862 .map(|nr| nr.signer_id)
863 .collect::<BTreeSet<u32>>();
864
865 let is_invalid_request = sign_request.nonce_responses.len() != signer_id_set.len()
870 || signer_id_set.is_empty()
871 || signer_id_set.last() >= Some(&self.total_signers);
872
873 if is_invalid_request {
874 warn!("received an invalid SignatureShareRequest");
875 return Err(Error::InvalidNonceResponse);
876 }
877
878 let nonces = sign_request
879 .nonce_responses
880 .iter()
881 .flat_map(|nr| nr.nonces.clone())
882 .collect::<Vec<PublicNonce>>();
883
884 for nonce in &nonces {
885 if !nonce.is_valid() {
886 warn!(
887 signer_id = %self.signer_id,
888 "received an SignatureShareRequest with invalid nonce"
889 );
890 return Err(Error::InvalidNonceResponse);
891 }
892 }
893
894 debug!(signer_id = %self.signer_id, "received a valid SignatureShareRequest");
895
896 if signer_id_set.contains(&self.signer_id) {
897 let key_ids: Vec<u32> = sign_request
898 .nonce_responses
899 .iter()
900 .flat_map(|nr| nr.key_ids.iter().copied())
901 .collect::<Vec<u32>>();
902
903 let signer_ids = signer_id_set.into_iter().collect::<Vec<_>>();
904 let msg = &sign_request.message;
905 let signature_shares = match sign_request.signature_type {
906 SignatureType::Taproot(merkle_root) => {
907 self.signer
908 .sign_taproot(msg, &signer_ids, &key_ids, &nonces, merkle_root)
909 }
910 SignatureType::Schnorr => {
911 self.signer
912 .sign_schnorr(msg, &signer_ids, &key_ids, &nonces)
913 }
914 SignatureType::Frost => self.signer.sign(msg, &signer_ids, &key_ids, &nonces),
915 };
916
917 self.signer.gen_nonces(&self.network_private_key, rng);
918
919 let response = SignatureShareResponse {
920 dkg_id: sign_request.dkg_id,
921 sign_id: sign_request.sign_id,
922 sign_iter_id: sign_request.sign_iter_id,
923 signer_id: self.signer_id,
924 signature_shares,
925 };
926 info!(
927 signer_id = %self.signer_id,
928 dkg_id = %sign_request.dkg_id,
929 sign_id = %sign_request.sign_id,
930 sign_iter_id = %sign_request.sign_iter_id,
931 "sending SignatureShareResponse"
932 );
933
934 self.move_to(State::Idle)?;
935 Ok(vec![Message::SignatureShareResponse(response)])
936 } else {
937 debug!(signer_id = %self.signer_id, "signer not included in SignatureShareRequest");
938 self.move_to(State::Idle)?;
939 Ok(Vec::new())
940 }
941 }
942
943 fn dkg_begin<R: RngCore + CryptoRng>(
944 &mut self,
945 dkg_begin: &DkgBegin,
946 rng: &mut R,
947 ) -> Result<Vec<Message>, Error> {
948 self.reset(dkg_begin.dkg_id, rng);
949 self.move_to(State::DkgPublicDistribute)?;
950
951 self.dkg_public_begin(rng)
952 }
953
954 fn dkg_public_shares_done(&mut self, msg: &DkgPublicSharesDone) -> Result<Vec<Message>, Error> {
955 if msg.dkg_id != self.dkg_id {
956 warn!(
957 signer_id = %self.signer_id,
958 got = %msg.dkg_id,
959 expected = %self.dkg_id,
960 "DkgPublicSharesDone dkg_id mismatch"
961 );
962 return Ok(vec![]);
963 }
964 let unknown_ids: Vec<u32> = msg
966 .signer_ids
967 .iter()
968 .filter(|id| !self.public_keys.signers.contains_key(*id))
969 .copied()
970 .collect();
971 if !unknown_ids.is_empty() {
972 warn!(
973 signer_id = %self.signer_id,
974 ?unknown_ids,
975 "DkgPublicSharesDone contains unknown signer_ids"
976 );
977 return Ok(vec![]);
978 }
979 if !msg.signer_ids.contains(&self.signer_id) {
980 warn!(
981 signer_id = %self.signer_id,
982 "signer_id not in DkgPublicSharesDone, coordinator did not receive our public shares"
983 );
984 self.move_to(State::Idle)?;
985 return Ok(vec![]);
986 }
987 self.dkg_public_shares
989 .retain(|id, _| msg.signer_ids.contains(id));
990
991 let have_all = msg
992 .signer_ids
993 .iter()
994 .all(|id| self.dkg_public_shares.contains_key(id));
995 if have_all {
996 let ack = DkgPublicSharesDoneAck {
997 dkg_id: self.dkg_id,
998 signer_id: self.signer_id,
999 };
1000 self.move_to(State::DkgPublicSharesDoneAck)?;
1001 Ok(vec![Message::DkgPublicSharesDoneAck(ack)])
1002 } else {
1003 debug!(
1004 signer_id = %self.signer_id,
1005 "DkgPublicSharesDone received but missing some public shares, waiting"
1006 );
1007 self.pending_public_shares_done = Some(msg.clone());
1008 Ok(vec![])
1009 }
1010 }
1011
1012 fn dkg_private_shares_done(
1013 &mut self,
1014 msg: &DkgPrivateSharesDone,
1015 ) -> Result<Vec<Message>, Error> {
1016 if msg.dkg_id != self.dkg_id {
1017 warn!(
1018 signer_id = %self.signer_id,
1019 got = %msg.dkg_id,
1020 expected = %self.dkg_id,
1021 "DkgPrivateSharesDone dkg_id mismatch"
1022 );
1023 return Ok(vec![]);
1024 }
1025 let unknown_ids: Vec<u32> = msg
1027 .signer_ids
1028 .iter()
1029 .filter(|id| !self.public_keys.signers.contains_key(*id))
1030 .copied()
1031 .collect();
1032 if !unknown_ids.is_empty() {
1033 warn!(
1034 signer_id = %self.signer_id,
1035 ?unknown_ids,
1036 "DkgPrivateSharesDone contains unknown signer_ids"
1037 );
1038 return Ok(vec![]);
1039 }
1040 if !msg.signer_ids.contains(&self.signer_id) {
1041 warn!(
1042 signer_id = %self.signer_id,
1043 "signer_id not in DkgPrivateSharesDone, coordinator did not receive our private shares"
1044 );
1045 self.move_to(State::Idle)?;
1046 return Ok(vec![]);
1047 }
1048 self.dkg_private_shares
1050 .retain(|id, _| msg.signer_ids.contains(id));
1051
1052 let have_all = msg
1053 .signer_ids
1054 .iter()
1055 .all(|id| self.dkg_private_shares.contains_key(id));
1056 if have_all {
1057 let ack = DkgPrivateSharesDoneAck {
1058 dkg_id: self.dkg_id,
1059 signer_id: self.signer_id,
1060 };
1061 self.move_to(State::DkgPrivateSharesDoneAck)?;
1062 Ok(vec![Message::DkgPrivateSharesDoneAck(ack)])
1063 } else {
1064 debug!(
1065 signer_id = %self.signer_id,
1066 "DkgPrivateSharesDone received but missing some private shares, waiting"
1067 );
1068 self.pending_private_shares_done = Some(msg.clone());
1069 Ok(vec![])
1070 }
1071 }
1072
1073 fn dkg_public_begin<R: RngCore + CryptoRng>(
1074 &mut self,
1075 rng: &mut R,
1076 ) -> Result<Vec<Message>, Error> {
1077 let mut msgs = vec![];
1078 let comms = self
1079 .signer
1080 .get_poly_commitments(&self.dkg_id.to_be_bytes(), rng);
1081 let comms = comms
1082 .iter()
1083 .map(|poly| (poly.id.id.get_u32(), poly.clone()))
1084 .collect();
1085
1086 info!(
1087 signer_id = %self.signer_id,
1088 dkg_id = %self.dkg_id,
1089 "sending DkgPublicShares"
1090 );
1091
1092 let kex_proof = DkgPublicShares::kex_prove(
1093 self.dkg_id,
1094 self.signer_id,
1095 &comms,
1096 &self.kex_private_key,
1097 rng,
1098 );
1099 let public_share = DkgPublicShares {
1100 dkg_id: self.dkg_id,
1101 signer_id: self.signer_id,
1102 comms,
1103 kex_public_key: self.kex_private_key * G,
1104 kex_proof,
1105 };
1106
1107 let public_share = Message::DkgPublicShares(public_share);
1108 msgs.push(public_share);
1109
1110 self.move_to(State::DkgPublicGather)?;
1111 Ok(msgs)
1112 }
1113
1114 fn dkg_private_begin<R: RngCore + CryptoRng>(
1115 &mut self,
1116 dkg_private_begin: &DkgPrivateBegin,
1117 rng: &mut R,
1118 ) -> Result<Vec<Message>, Error> {
1119 if dkg_private_begin.dkg_id != self.dkg_id {
1120 warn!(
1121 signer_id = %self.signer_id,
1122 got = %dkg_private_begin.dkg_id,
1123 expected = %self.dkg_id,
1124 "DkgPrivateBegin dkg_id mismatch"
1125 );
1126 return Ok(vec![]);
1127 }
1128 let mut msgs = vec![];
1129 let mut private_shares = DkgPrivateShares {
1130 dkg_id: self.dkg_id,
1131 signer_id: self.signer_id,
1132 shares: Vec::new(),
1133 };
1134 let mut active_key_ids = HashSet::new();
1135 for signer_id in &dkg_private_begin.signer_ids {
1136 if let Some(key_ids) = self.public_keys.signer_key_ids.get(signer_id) {
1137 for key_id in key_ids {
1138 active_key_ids.insert(*key_id);
1139 }
1140 }
1141 }
1142
1143 self.dkg_private_begin_msg = Some(dkg_private_begin.clone());
1144 self.move_to(State::DkgPrivateDistribute)?;
1145
1146 info!(
1147 signer_id = %self.signer_id,
1148 dkg_id = %self.dkg_id,
1149 "sending DkgPrivateShares"
1150 );
1151
1152 trace!(
1153 "Signer {} shares {:?}",
1154 self.signer_id,
1155 &self.signer.get_shares()
1156 );
1157 for (party_id, shares) in &self.signer.get_shares() {
1158 debug!(
1159 "Signer {} addding dkg private share for party_id {party_id}",
1160 self.signer_id
1161 );
1162 let mut encrypted_shares = HashMap::new();
1164
1165 for (dst_key_id, private_share) in shares {
1166 if active_key_ids.contains(dst_key_id) {
1167 debug!("encrypting dkg private share for key_id {dst_key_id}");
1168 let Some(kex_public_key) = self.kex_public_keys.get(dst_key_id) else {
1169 error!("No KEX public key for key_id {dst_key_id}");
1170 return Err(Error::MissingKexPublicKey(*dst_key_id));
1171 };
1172 let shared_secret = make_shared_secret(&self.kex_private_key, kex_public_key);
1173 let encrypted_share = encrypt(&shared_secret, &private_share.to_bytes(), rng)?;
1174
1175 encrypted_shares.insert(*dst_key_id, encrypted_share);
1176 }
1177 }
1178
1179 private_shares.shares.push((*party_id, encrypted_shares));
1180 }
1181
1182 let private_shares = Message::DkgPrivateShares(private_shares);
1183 msgs.push(private_shares);
1184
1185 self.move_to(State::DkgPrivateGather)?;
1186 Ok(msgs)
1187 }
1188
1189 pub fn dkg_end_begin(&mut self, dkg_end_begin: &DkgEndBegin) -> Result<Vec<Message>, Error> {
1191 if dkg_end_begin.dkg_id != self.dkg_id {
1192 warn!(
1193 signer_id = %self.signer_id,
1194 got = %dkg_end_begin.dkg_id,
1195 expected = %self.dkg_id,
1196 "DkgEndBegin dkg_id mismatch"
1197 );
1198 return Ok(vec![]);
1199 }
1200 let unknown_ids: Vec<u32> = dkg_end_begin
1202 .signer_ids
1203 .iter()
1204 .filter(|id| !self.public_keys.signers.contains_key(*id))
1205 .copied()
1206 .collect();
1207 if !unknown_ids.is_empty() {
1208 warn!(
1209 signer_id = %self.signer_id,
1210 ?unknown_ids,
1211 "DkgEndBegin contains unknown signer_ids"
1212 );
1213 return Ok(vec![]);
1214 }
1215 let num_keys: u32 = dkg_end_begin
1216 .signer_ids
1217 .iter()
1218 .filter_map(|id| self.public_keys.signer_key_ids.get(id))
1219 .map(|key_ids| key_ids.len() as u32)
1220 .sum();
1221 if num_keys < self.dkg_threshold {
1222 warn!(
1223 signer_id = %self.signer_id,
1224 num_keys,
1225 dkg_threshold = self.dkg_threshold,
1226 "DkgEndBegin below dkg_threshold"
1227 );
1228 }
1229 let msgs = vec![];
1230
1231 self.dkg_end_begin_msg = Some(dkg_end_begin.clone());
1232
1233 info!(
1234 signer_id = %self.signer_id,
1235 dkg_id = %self.dkg_id,
1236 "received DkgEndBegin"
1237 );
1238
1239 Ok(msgs)
1240 }
1241
1242 pub fn dkg_public_share(
1244 &mut self,
1245 dkg_public_shares: &DkgPublicShares,
1246 ) -> Result<Vec<Message>, Error> {
1247 if dkg_public_shares.dkg_id != self.dkg_id {
1248 warn!(
1249 signer_id = %self.signer_id,
1250 got = %dkg_public_shares.dkg_id,
1251 expected = %self.dkg_id,
1252 "DkgPublicShares dkg_id mismatch"
1253 );
1254 return Ok(vec![]);
1255 }
1256 debug!(
1257 "received DkgPublicShares from signer {} {}/{}",
1258 dkg_public_shares.signer_id,
1259 self.commitments.len(),
1260 self.signer.get_num_parties(),
1261 );
1262
1263 let signer_id = dkg_public_shares.signer_id;
1264
1265 let Some(_signer_public_key) = self.public_keys.signers.get(&signer_id) else {
1267 warn!(%signer_id, "No public key configured");
1268 return Ok(vec![]);
1269 };
1270
1271 for (party_id, _) in &dkg_public_shares.comms {
1272 if !SignerType::validate_party_id(
1273 signer_id,
1274 *party_id,
1275 &self.public_keys.signer_key_ids,
1276 ) {
1277 warn!(%signer_id, %party_id, "signer sent polynomial commitment for wrong party");
1278 return Ok(vec![]);
1279 }
1280 }
1281
1282 if let Some(pending) = &self.pending_public_shares_done {
1284 if !pending.signer_ids.contains(&signer_id) {
1285 debug!(%signer_id, "discarding DkgPublicShares from signer not in DkgPublicSharesDone");
1286 return Ok(vec![]);
1287 }
1288 }
1289
1290 let have_shares = self
1291 .dkg_public_shares
1292 .contains_key(&dkg_public_shares.signer_id);
1293
1294 if have_shares {
1295 info!(signer_id = %dkg_public_shares.signer_id, "received duplicate DkgPublicShares");
1296 return Ok(vec![]);
1297 }
1298
1299 let Some(signer_key_ids) = self.public_keys.signer_key_ids.get(&signer_id) else {
1300 warn!(%signer_id, "No key_ids configured");
1301 return Ok(vec![]);
1302 };
1303
1304 if !dkg_public_shares.kex_verify() {
1305 warn!(signer_id = %dkg_public_shares.signer_id, "received DkgPublicShares with invalid kex_proof");
1306 return Ok(vec![]);
1307 }
1308
1309 for key_id in signer_key_ids {
1310 self.kex_public_keys
1311 .insert(*key_id, dkg_public_shares.kex_public_key);
1312 }
1313
1314 self.dkg_public_shares
1315 .insert(dkg_public_shares.signer_id, dkg_public_shares.clone());
1316
1317 if let Some(pending) = self.pending_public_shares_done.take() {
1319 if pending
1320 .signer_ids
1321 .iter()
1322 .all(|id| self.dkg_public_shares.contains_key(id))
1323 {
1324 let ack = DkgPublicSharesDoneAck {
1325 dkg_id: self.dkg_id,
1326 signer_id: self.signer_id,
1327 };
1328 self.move_to(State::DkgPublicSharesDoneAck)?;
1329 return Ok(vec![Message::DkgPublicSharesDoneAck(ack)]);
1330 }
1331 self.pending_public_shares_done = Some(pending);
1332 }
1333 Ok(vec![])
1334 }
1335
1336 pub fn dkg_private_shares<R: RngCore + CryptoRng>(
1338 &mut self,
1339 dkg_private_shares: &DkgPrivateShares,
1340 rng: &mut R,
1341 ) -> Result<Vec<Message>, Error> {
1342 if dkg_private_shares.dkg_id != self.dkg_id {
1343 warn!(
1344 signer_id = %self.signer_id,
1345 got = %dkg_private_shares.dkg_id,
1346 expected = %self.dkg_id,
1347 "DkgPrivateShares dkg_id mismatch"
1348 );
1349 return Ok(vec![]);
1350 }
1351 let src_signer_id = dkg_private_shares.signer_id;
1353
1354 let Some(_signer_public_key) = self.public_keys.signers.get(&src_signer_id) else {
1356 warn!(%src_signer_id, "No public key configured");
1357 return Ok(vec![]);
1358 };
1359
1360 let Ok(kex_public_key) = self.get_kex_public_key(src_signer_id) else {
1361 return Ok(vec![]);
1362 };
1363
1364 for (party_id, _shares) in &dkg_private_shares.shares {
1365 if !SignerType::validate_party_id(
1366 src_signer_id,
1367 *party_id,
1368 &self.public_keys.signer_key_ids,
1369 ) {
1370 warn!("Signer {src_signer_id} sent a polynomial commitment for party {party_id}");
1371 return Ok(vec![]);
1372 }
1373 }
1374
1375 if let Some(pending) = &self.pending_private_shares_done {
1377 if !pending.signer_ids.contains(&src_signer_id) {
1378 debug!(%src_signer_id, "discarding DkgPrivateShares from signer not in DkgPrivateSharesDone");
1379 return Ok(vec![]);
1380 }
1381 }
1382
1383 if self.dkg_private_shares.contains_key(&src_signer_id) {
1384 info!(signer_id = %dkg_private_shares.signer_id, "received duplicate DkgPrivateShares");
1385 return Ok(vec![]);
1386 }
1387
1388 self.dkg_private_shares
1389 .insert(src_signer_id, dkg_private_shares.clone());
1390
1391 let key_ids: HashSet<u32> = self.signer.get_key_ids().into_iter().collect();
1393
1394 let shared_key = self.kex_private_key * kex_public_key;
1395 let shared_secret = make_shared_secret(&self.kex_private_key, &kex_public_key);
1396
1397 for (src_id, shares) in &dkg_private_shares.shares {
1398 let mut decrypted_shares = HashMap::new();
1399 for (dst_key_id, bytes) in shares {
1400 if key_ids.contains(dst_key_id) {
1401 match decrypt(&shared_secret, bytes) {
1402 Ok(plain) => match Scalar::try_from(&plain[..]) {
1403 Ok(s) => {
1404 decrypted_shares.insert(*dst_key_id, s);
1405 }
1406 Err(e) => {
1407 warn!("Failed to parse Scalar for dkg private share from src_id {src_id} to dst_id {dst_key_id}: {e:?}");
1408 self.invalid_private_shares.insert(
1409 src_signer_id,
1410 self.make_bad_private_share(src_signer_id, rng)?,
1411 );
1412 }
1413 },
1414 Err(e) => {
1415 warn!("Failed to decrypt dkg private share from src_id {src_id} to dst_id {dst_key_id}: {e:?}");
1416 self.invalid_private_shares.insert(
1417 src_signer_id,
1418 self.make_bad_private_share(src_signer_id, rng)?,
1419 );
1420 }
1421 }
1422 }
1423 }
1424 self.decrypted_shares.insert(*src_id, decrypted_shares);
1425 self.decryption_keys
1426 .insert(*src_id, (dkg_private_shares.signer_id, shared_key));
1427 }
1428 debug!(
1429 "received DkgPrivateShares from signer {} {}/{}",
1430 dkg_private_shares.signer_id,
1431 self.decrypted_shares.len(),
1432 self.signer.get_num_parties(),
1433 );
1434
1435 if let Some(pending) = self.pending_private_shares_done.take() {
1437 if pending
1438 .signer_ids
1439 .iter()
1440 .all(|id| self.dkg_private_shares.contains_key(id))
1441 {
1442 let ack = DkgPrivateSharesDoneAck {
1443 dkg_id: self.dkg_id,
1444 signer_id: self.signer_id,
1445 };
1446 self.move_to(State::DkgPrivateSharesDoneAck)?;
1447 return Ok(vec![Message::DkgPrivateSharesDoneAck(ack)]);
1448 }
1449 self.pending_private_shares_done = Some(pending);
1450 }
1451 Ok(vec![])
1452 }
1453
1454 fn get_kex_public_key(&self, signer_id: u32) -> Result<Point, Error> {
1455 let Some(signer_key_ids) = self.public_keys.signer_key_ids.get(&signer_id) else {
1456 warn!(%signer_id, "No key_ids configured");
1457 return Err(Error::Config(ConfigError::InvalidSignerId(signer_id)));
1458 };
1459
1460 let Some(signer_key_id) = signer_key_ids.iter().next() else {
1461 warn!(%signer_id, "No key_ids configured");
1462 return Err(Error::Config(ConfigError::InvalidSignerId(signer_id)));
1463 };
1464
1465 let Some(kex_public_key) = self.kex_public_keys.get(signer_key_id) else {
1466 warn!(%signer_id, %signer_key_id, "No KEX public key configured");
1467 return Err(Error::MissingKexPublicKey(*signer_key_id));
1468 };
1469
1470 Ok(*kex_public_key)
1471 }
1472
1473 #[allow(non_snake_case)]
1474 fn make_bad_private_share<R: RngCore + CryptoRng>(
1475 &self,
1476 signer_id: u32,
1477 rng: &mut R,
1478 ) -> Result<BadPrivateShare, Error> {
1479 let a = self.kex_private_key;
1480 let A = a * G;
1481 let B = self.get_kex_public_key(signer_id)?;
1482 let K = a * B;
1483 let tuple_proof = TupleProof::new(&a, &A, &B, &K, rng);
1484
1485 Ok(BadPrivateShare {
1486 shared_key: K,
1487 tuple_proof,
1488 })
1489 }
1490}
1491
1492impl<SignerType: SignerTrait> StateMachine<State, Error> for Signer<SignerType> {
1493 fn move_to(&mut self, state: State) -> Result<(), Error> {
1494 self.can_move_to(&state)?;
1495 self.state = state;
1496 Ok(())
1497 }
1498
1499 fn can_move_to(&self, state: &State) -> Result<(), Error> {
1500 let prev_state = &self.state;
1501 let accepted = match state {
1502 State::Idle => true,
1503 State::DkgPublicDistribute => matches!(
1505 prev_state,
1506 State::Idle
1507 | State::DkgPublicDistribute
1508 | State::DkgPublicGather
1509 | State::DkgPublicSharesDoneAck
1510 | State::DkgPrivateDistribute
1511 | State::DkgPrivateGather
1512 | State::DkgPrivateSharesDoneAck
1513 ),
1514 State::DkgPublicGather => prev_state == &State::DkgPublicDistribute,
1515 State::DkgPublicSharesDoneAck => prev_state == &State::DkgPublicGather,
1516 State::DkgPrivateDistribute => prev_state == &State::DkgPublicSharesDoneAck,
1517 State::DkgPrivateGather => prev_state == &State::DkgPrivateDistribute,
1518 State::DkgPrivateSharesDoneAck => prev_state == &State::DkgPrivateGather,
1519 State::SignGather => prev_state == &State::Idle || prev_state == &State::SignGather,
1520 };
1521 if accepted {
1522 debug!("state change from {prev_state:?} to {state:?}");
1523 Ok(())
1524 } else {
1525 Err(Error::BadStateChange(format!(
1526 "{prev_state:?} to {state:?}"
1527 )))
1528 }
1529 }
1530}
1531#[cfg(test)]
1532pub mod test {
1534 use super::*;
1535 #[cfg(feature = "with_v1")]
1536 use crate::v1;
1537 use crate::{
1538 common::PolyCommitment,
1539 curve::{ecdsa, scalar::Scalar},
1540 net::{
1541 DkgBegin, DkgEndBegin, DkgPrivateBegin, DkgPrivateSharesDone, DkgPublicShares,
1542 DkgPublicSharesDone, DkgStatus, Message,
1543 },
1544 schnorr::ID,
1545 state_machine::{
1546 signer::{ConfigError, Error, Signer, State as SignerState},
1547 PublicKeys,
1548 },
1549 traits::Signer as SignerTrait,
1550 util::create_rng,
1551 v2,
1552 };
1553
1554 use hashbrown::HashSet;
1555
1556 #[test]
1557 #[cfg(feature = "with_v1")]
1558 fn bad_config_v1() {
1559 bad_config::<v1::Signer>();
1560 }
1561
1562 #[test]
1563 fn bad_config_v2() {
1564 bad_config::<v2::Signer>();
1565 }
1566
1567 fn bad_config<SignerType: SignerTrait>() {
1568 let mut rng = create_rng();
1569
1570 assert!(matches!(
1572 Signer::<SignerType>::new(
1573 1,
1574 1,
1575 2,
1576 1,
1577 0,
1578 vec![1],
1579 Default::default(),
1580 Default::default(),
1581 &mut rng,
1582 ),
1583 Err(Error::Config(ConfigError::InsufficientKeys))
1584 ));
1585
1586 assert!(matches!(
1588 Signer::<SignerType>::new(
1589 0,
1590 1,
1591 4,
1592 4,
1593 0,
1594 vec![1],
1595 Default::default(),
1596 Default::default(),
1597 &mut rng,
1598 ),
1599 Err(Error::Config(ConfigError::InvalidThreshold))
1600 ));
1601
1602 assert!(matches!(
1604 Signer::<SignerType>::new(
1605 1,
1606 0,
1607 4,
1608 4,
1609 0,
1610 vec![1],
1611 Default::default(),
1612 Default::default(),
1613 &mut rng,
1614 ),
1615 Err(Error::Config(ConfigError::InvalidThreshold))
1616 ));
1617
1618 assert!(matches!(
1620 Signer::<SignerType>::new(
1621 5,
1622 5,
1623 4,
1624 4,
1625 0,
1626 vec![1],
1627 Default::default(),
1628 Default::default(),
1629 &mut rng,
1630 ),
1631 Err(Error::Config(ConfigError::InvalidThreshold))
1632 ));
1633
1634 assert!(matches!(
1636 Signer::<SignerType>::new(
1637 2,
1638 1,
1639 4,
1640 4,
1641 0,
1642 vec![1],
1643 Default::default(),
1644 Default::default(),
1645 &mut rng,
1646 ),
1647 Err(Error::Config(ConfigError::InvalidThreshold))
1648 ));
1649
1650 assert!(matches!(
1652 Signer::<SignerType>::new(
1653 2,
1654 2,
1655 4,
1656 4,
1657 4,
1658 vec![1],
1659 Default::default(),
1660 Default::default(),
1661 &mut rng,
1662 ),
1663 Err(Error::Config(ConfigError::InvalidSignerId(4)))
1664 ));
1665
1666 assert!(matches!(
1668 Signer::<SignerType>::new(
1669 2,
1670 2,
1671 4,
1672 4,
1673 0,
1674 vec![0],
1675 Default::default(),
1676 Default::default(),
1677 &mut rng,
1678 ),
1679 Err(Error::Config(ConfigError::InvalidKeyId(0)))
1680 ));
1681
1682 assert!(matches!(
1684 Signer::<SignerType>::new(
1685 2,
1686 2,
1687 4,
1688 4,
1689 0,
1690 vec![5],
1691 Default::default(),
1692 Default::default(),
1693 &mut rng,
1694 ),
1695 Err(Error::Config(ConfigError::InvalidKeyId(5)))
1696 ));
1697
1698 }
1700
1701 #[test]
1702 #[cfg(feature = "with_v1")]
1703 fn dkg_public_share_v1() {
1704 dkg_public_share::<v1::Signer>();
1705 }
1706
1707 #[test]
1708 fn dkg_public_share_v2() {
1709 dkg_public_share::<v2::Signer>();
1710 }
1711
1712 fn dkg_public_share<SignerType: SignerTrait>() {
1713 let ctx = 0u64.to_be_bytes();
1714 let mut rng = create_rng();
1715 let private_key = Scalar::random(&mut rng);
1716 let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1717 let mut public_keys: PublicKeys = Default::default();
1718 let mut key_ids = HashSet::new();
1719
1720 public_keys.signers.insert(0, public_key);
1721 public_keys.key_ids.insert(1, public_key);
1722
1723 key_ids.insert(1);
1724 public_keys.signer_key_ids.insert(0, key_ids);
1725
1726 let mut signer =
1727 Signer::<SignerType>::new(1, 1, 1, 1, 0, vec![1], private_key, public_keys, &mut rng)
1728 .unwrap();
1729 let comms: Vec<(u32, PolyCommitment)> = signer
1730 .signer
1731 .get_poly_commitments(&ctx, &mut rng)
1732 .iter()
1733 .map(|comm| (comm.id.id.get_u32(), comm.clone()))
1734 .collect();
1735 let kex_private_key = Scalar::random(&mut rng);
1736 let kex_proof = DkgPublicShares::kex_prove(0, 0, &comms, &kex_private_key, &mut rng);
1737 let public_share = DkgPublicShares {
1738 dkg_id: 0,
1739 signer_id: 0,
1740 comms: comms.clone(),
1741 kex_public_key: Point::from(kex_private_key),
1742 kex_proof: kex_proof.clone(),
1743 };
1744 signer.dkg_public_share(&public_share).unwrap();
1745 assert_eq!(1, signer.dkg_public_shares.len());
1746
1747 let dup_public_share = DkgPublicShares {
1749 dkg_id: 0,
1750 signer_id: 0,
1751 comms: comms.clone(),
1752 kex_public_key: Point::from(kex_private_key),
1753 kex_proof: kex_proof.clone(),
1754 };
1755 signer.dkg_public_share(&dup_public_share).unwrap();
1756 assert_eq!(1, signer.dkg_public_shares.len());
1757 assert_eq!(
1758 public_share,
1759 signer.dkg_public_shares.iter().next().unwrap().1.clone()
1760 );
1761 }
1762
1763 #[test]
1764 #[cfg(feature = "with_v1")]
1765 fn public_shares_done_v1() {
1766 public_shares_done::<v1::Signer>();
1767 }
1768
1769 #[test]
1770 fn public_shares_done_v2() {
1771 public_shares_done::<v2::Signer>();
1772 }
1773
1774 fn public_shares_done<SignerType: SignerTrait>() {
1775 let ctx = 0u64.to_be_bytes();
1776 let mut rng = create_rng();
1777 let mut signer = Signer::<SignerType>::new(
1778 1,
1779 1,
1780 1,
1781 1,
1782 0,
1783 vec![1],
1784 Default::default(),
1785 Default::default(),
1786 &mut rng,
1787 )
1788 .unwrap();
1789 assert!(!signer.public_shares_done());
1791
1792 signer.state = SignerState::DkgPublicGather;
1794 signer.commitments.insert(
1795 1,
1796 PolyCommitment {
1797 id: ID::new(&Scalar::new(), &Scalar::new(), &ctx, &mut rng),
1798 poly: vec![],
1799 },
1800 );
1801
1802 assert!(signer.public_shares_done());
1804 }
1805
1806 #[test]
1807 #[cfg(feature = "with_v1")]
1808 fn dkg_private_share_v1() {
1810 let mut rng = create_rng();
1811
1812 let private_key = Scalar::random(&mut rng);
1813 let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1814 let private_key2 = Scalar::random(&mut rng);
1815 let public_key2 = ecdsa::PublicKey::new(&private_key2).unwrap();
1816 let mut public_keys: PublicKeys = Default::default();
1817 let kex_private_key = Scalar::random(&mut rng);
1818 let kex_public_key = Point::from(&kex_private_key);
1819
1820 public_keys.signers.insert(0, public_key);
1821 public_keys.signers.insert(1, public_key2);
1822 public_keys.key_ids.insert(1, public_key);
1823 public_keys.key_ids.insert(2, public_key2);
1824
1825 let mut key_ids = HashSet::new();
1826 key_ids.insert(1);
1827 public_keys.signer_key_ids.insert(0, key_ids);
1828
1829 let mut key_ids2 = HashSet::new();
1830 key_ids2.insert(2);
1831 public_keys.signer_key_ids.insert(1, key_ids2);
1832
1833 let mut signer =
1834 Signer::<v1::Signer>::new(1, 1, 2, 2, 0, vec![1], private_key, public_keys, &mut rng)
1835 .unwrap();
1836
1837 let kex_proof = DkgPublicShares::kex_prove(0, 1, &vec![], &kex_private_key, &mut rng);
1838 let public_share = DkgPublicShares {
1839 dkg_id: 0,
1840 signer_id: 1,
1841 comms: vec![],
1842 kex_public_key,
1843 kex_proof: kex_proof.clone(),
1844 };
1845 signer.dkg_public_share(&public_share).unwrap();
1846 assert_eq!(1, signer.dkg_public_shares.len());
1847
1848 let private_share = DkgPrivateShares {
1849 dkg_id: 0,
1850 signer_id: 1,
1851 shares: vec![(2, HashMap::new())],
1852 };
1853 signer.dkg_private_shares(&private_share, &mut rng).unwrap();
1854 assert_eq!(1, signer.dkg_private_shares.len());
1855
1856 let dup_private_share = DkgPrivateShares {
1858 dkg_id: 0,
1859 signer_id: 1,
1860 shares: vec![(2, HashMap::new())],
1861 };
1862 signer
1863 .dkg_private_shares(&dup_private_share, &mut rng)
1864 .unwrap();
1865 assert_eq!(1, signer.dkg_private_shares.len());
1866 assert_eq!(
1867 private_share,
1868 signer.dkg_private_shares.iter().next().unwrap().1.clone()
1869 );
1870 }
1871
1872 #[test]
1873 fn dkg_private_share_v2() {
1875 let mut rng = create_rng();
1876
1877 let private_key = Scalar::random(&mut rng);
1878 let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1879 let private_key2 = Scalar::random(&mut rng);
1880 let public_key2 = ecdsa::PublicKey::new(&private_key2).unwrap();
1881 let mut public_keys: PublicKeys = Default::default();
1882 let kex_private_key = Scalar::random(&mut rng);
1883 let kex_public_key = Point::from(&kex_private_key);
1884
1885 public_keys.signers.insert(0, public_key);
1886 public_keys.signers.insert(1, public_key2);
1887 public_keys.key_ids.insert(1, public_key);
1888 public_keys.key_ids.insert(2, public_key2);
1889
1890 let mut key_ids = HashSet::new();
1891 key_ids.insert(1);
1892 public_keys.signer_key_ids.insert(0, key_ids);
1893
1894 let mut key_ids2 = HashSet::new();
1895 key_ids2.insert(2);
1896 public_keys.signer_key_ids.insert(1, key_ids2);
1897
1898 let mut signer =
1899 Signer::<v2::Signer>::new(1, 1, 2, 2, 0, vec![1], private_key, public_keys, &mut rng)
1900 .unwrap();
1901
1902 let kex_proof = DkgPublicShares::kex_prove(0, 1, &vec![], &kex_private_key, &mut rng);
1903 let public_share = DkgPublicShares {
1904 dkg_id: 0,
1905 signer_id: 1,
1906 comms: vec![],
1907 kex_public_key,
1908 kex_proof: kex_proof.clone(),
1909 };
1910 signer.dkg_public_share(&public_share).unwrap();
1911 assert_eq!(1, signer.dkg_public_shares.len());
1912
1913 let private_share = DkgPrivateShares {
1914 dkg_id: 0,
1915 signer_id: 1,
1916 shares: vec![(1, HashMap::new())],
1917 };
1918 signer.dkg_private_shares(&private_share, &mut rng).unwrap();
1919 assert_eq!(1, signer.dkg_private_shares.len());
1920
1921 let dup_private_share = DkgPrivateShares {
1923 dkg_id: 0,
1924 signer_id: 1,
1925 shares: vec![(1, HashMap::new())],
1926 };
1927 signer
1928 .dkg_private_shares(&dup_private_share, &mut rng)
1929 .unwrap();
1930 assert_eq!(1, signer.dkg_private_shares.len());
1931 assert_eq!(
1932 private_share,
1933 signer.dkg_private_shares.iter().next().unwrap().1.clone()
1934 );
1935 }
1936
1937 #[test]
1938 #[cfg(feature = "with_v1")]
1939 fn can_dkg_end_v1() {
1940 can_dkg_end::<v1::Signer>();
1941 }
1942
1943 #[test]
1944 fn can_dkg_end_v2() {
1945 can_dkg_end::<v2::Signer>();
1946 }
1947
1948 fn can_dkg_end<SignerType: SignerTrait>() {
1949 let mut rng = create_rng();
1950 let private_key = Scalar::random(&mut rng);
1951 let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1952 let mut public_keys: PublicKeys = Default::default();
1953 let mut key_ids = HashSet::new();
1954
1955 public_keys.signers.insert(0, public_key);
1956 public_keys.key_ids.insert(1, public_key);
1957
1958 key_ids.insert(1);
1959 public_keys.signer_key_ids.insert(0, key_ids);
1960
1961 let mut signer =
1962 Signer::<SignerType>::new(1, 1, 1, 1, 0, vec![1], private_key, public_keys, &mut rng)
1963 .unwrap();
1964 signer.verify_packet_sigs = false;
1965 assert!(!signer.can_dkg_end());
1967
1968 let dkg_begin = Message::DkgBegin(DkgBegin { dkg_id: 1 });
1970 let dkg_begin_packet = Packet {
1971 msg: dkg_begin,
1972 sig: vec![],
1973 };
1974 let dkg_public_shares = signer
1975 .process(&dkg_begin_packet, &mut rng)
1976 .expect("failed to process DkgBegin");
1977 let dkg_public_shares_packet = Packet {
1978 msg: dkg_public_shares[0].clone(),
1979 sig: vec![],
1980 };
1981 let _ = signer
1982 .process(&dkg_public_shares_packet, &mut rng)
1983 .expect("failed to process DkgPublicShares");
1984 let dkg_public_shares_done = Message::DkgPublicSharesDone(DkgPublicSharesDone {
1986 dkg_id: 1,
1987 signer_ids: vec![0],
1988 });
1989 let dkg_public_shares_done_packet = Packet {
1990 msg: dkg_public_shares_done,
1991 sig: vec![],
1992 };
1993 let _ = signer
1994 .process(&dkg_public_shares_done_packet, &mut rng)
1995 .expect("failed to process DkgPublicSharesDone");
1996 let dkg_private_begin = Message::DkgPrivateBegin(DkgPrivateBegin {
1997 dkg_id: 1,
1998 signer_ids: vec![0],
1999 key_ids: vec![],
2000 });
2001 let dkg_private_begin_packet = Packet {
2002 msg: dkg_private_begin,
2003 sig: vec![],
2004 };
2005 let dkg_private_shares = signer
2006 .process(&dkg_private_begin_packet, &mut rng)
2007 .expect("failed to process DkgPrivateBegin");
2008 let dkg_private_shares_packet = Packet {
2009 msg: dkg_private_shares[0].clone(),
2010 sig: vec![],
2011 };
2012 let _ = signer
2013 .process(&dkg_private_shares_packet, &mut rng)
2014 .expect("failed to process DkgPrivateShares");
2015 let dkg_private_shares_done = Message::DkgPrivateSharesDone(DkgPrivateSharesDone {
2017 dkg_id: 1,
2018 signer_ids: vec![0],
2019 });
2020 let dkg_private_shares_done_packet = Packet {
2021 msg: dkg_private_shares_done,
2022 sig: vec![],
2023 };
2024 let _ = signer
2025 .process(&dkg_private_shares_done_packet, &mut rng)
2026 .expect("failed to process DkgPrivateSharesDone");
2027 let dkg_end_begin = DkgEndBegin {
2028 dkg_id: 1,
2029 signer_ids: vec![0],
2030 key_ids: vec![],
2031 };
2032 let _ = signer
2033 .dkg_end_begin(&dkg_end_begin)
2034 .expect("failed to process DkgPrivateShares");
2035
2036 assert!(signer.can_dkg_end());
2038 }
2039
2040 #[test]
2041 #[cfg(feature = "with_v1")]
2042 fn dkg_ended_v1() {
2043 dkg_ended::<v1::Signer>();
2044 }
2045
2046 #[test]
2047 fn dkg_ended_v2() {
2048 dkg_ended::<v2::Signer>();
2049 }
2050
2051 fn dkg_ended<SignerType: SignerTrait>() {
2052 let mut rng = create_rng();
2053 let mut signer = Signer::<SignerType>::new(
2054 1,
2055 1,
2056 1,
2057 1,
2058 0,
2059 vec![1],
2060 Default::default(),
2061 Default::default(),
2062 &mut rng,
2063 )
2064 .unwrap();
2065
2066 let Ok(Message::DkgEnd(dkg_end)) = signer.dkg_ended(&mut rng) else {
2067 panic!("Unexpected Error");
2068 };
2069 assert!(
2070 matches!(dkg_end.status, DkgStatus::Failure(_)),
2071 "Expected DkgStatus::Failure"
2072 );
2073 }
2074}