yip-ca 0.1.0

Certificate Authority CLI and online threshold (RFC 9591 FROST) signing daemon for yip
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use frost::keys::{IdentifierList, KeyPackage, PublicKeyPackage};
use frost::round1::{SigningCommitments, SigningNonces};
use frost::round2::SignatureShare;
use frost::{Identifier, SigningPackage};
use frost_ed25519 as frost;
pub mod dkg;
pub mod refresh;

use std::collections::BTreeMap;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ThresholdError {
    #[error("FROST error: {0}")]
    Frost(#[from] frost::Error),
    #[error("Invalid parameters: {0}")]
    InvalidParams(&'static str),
    #[error("Serialization error: {0}")]
    Serialization(String),
}

/// Generates a threshold key set using a trusted dealer.
pub fn dealer_generate(
    threshold: u16,
    max_signers: u16,
) -> Result<(PublicKeyPackage, BTreeMap<Identifier, KeyPackage>), ThresholdError> {
    if threshold == 0 || threshold > max_signers {
        return Err(ThresholdError::InvalidParams(
            "threshold must be >= 1 and <= max_signers",
        ));
    }

    let rng = rand::rngs::OsRng;
    let (shares, pubkey_package) =
        frost::keys::generate_with_dealer(max_signers, threshold, IdentifierList::Default, rng)?;

    let mut key_packages = BTreeMap::new();
    for (id, secret_share) in shares {
        let key_package = KeyPackage::try_from(secret_share)?;
        key_packages.insert(id, key_package);
    }

    Ok((pubkey_package, key_packages))
}

/// Executes threshold signing over a canonical message buffer using the provided signers.
/// Returns a standard 64-byte Ed25519 signature.
pub fn threshold_sign_cert(
    tbs: &[u8],
    commitments_map: BTreeMap<Identifier, SigningCommitments>,
    signers: Vec<(Identifier, &KeyPackage, SigningNonces)>,
    pubkey_package: &PublicKeyPackage,
) -> Result<[u8; 64], ThresholdError> {
    let signing_package = SigningPackage::new(commitments_map, tbs);

    let mut signature_shares = BTreeMap::new();
    for (id, kp, nonces) in signers {
        let share: SignatureShare = frost::round2::sign(&signing_package, &nonces, kp)?;
        signature_shares.insert(id, share);
    }

    let signature = frost::aggregate(&signing_package, &signature_shares, pubkey_package)?;
    let sig_bytes = signature.serialize()?;
    let sig_array: [u8; 64] = sig_bytes
        .try_into()
        .map_err(|_| ThresholdError::Serialization("expected 64-byte signature".into()))?;

    Ok(sig_array)
}