Simple Example - Centralized Telescope with BLS

Cargo.toml

@@ -15,6 +15,7 @@ blake2 = "0.10.6"
 rand_core = "0.6.4"
 rand_chacha = "0.3.1"
 test-case = "3.3.1"
+blst = "0.3.13"
 
 [lints.rust]
 missing-copy-implementations = "warn"

examples/simple_example.rs

@@ -0,0 +1,64 @@
+//! Centralized Telescope example with BLS signatures
+
+mod simple_threshold_signature;
+
+use crate::simple_threshold_signature::signature::Signature;
+use crate::simple_threshold_signature::signer::Signer;
+use crate::simple_threshold_signature::threshold_signature::ThresholdSignature;
+use alba::centralized_telescope::Telescope;
+use blst::min_sig::PublicKey;
+use rand_chacha::ChaCha20Rng;
+use rand_core::{RngCore, SeedableRng};
+
+const DATA_LENGTH: usize = 48;
+type Element = [u8; DATA_LENGTH];
+
+fn main() {
+    let mut rng = ChaCha20Rng::from_seed(Default::default());
+    let mut msg = [0u8; 16];
+    rng.fill_bytes(&mut msg);
+
+    println!("\n-------------- ALBA with Multi-Signature ---------------");
+    println!("--------------------------------------------------------");
+
+    let nb_elements: u64 = 1_000;
+    let soundness_param = 128.0;
+    let completeness_param = 128.0;
+    let set_size = nb_elements.saturating_mul(80).div_ceil(100);
+    let lower_bound = nb_elements.saturating_mul(20).div_ceil(100);
+
+    println!(" - Soundness parameter: {soundness_param}");
+    println!(" - Completeness parameter: {completeness_param}");
+    println!(" - Prover set size: {set_size}");
+    println!(" - Lower bound: {lower_bound}");
+
+    let alba = Telescope::create(soundness_param, completeness_param, set_size, lower_bound);
+
+    let mut key_list: Vec<(usize, PublicKey)> = Vec::with_capacity(set_size as usize);
+    let mut signature_list: Vec<Signature> = Vec::with_capacity(set_size as usize);
+
+    for i in 0..set_size as usize {
+        let signer = Signer::new(&mut rng);
+        key_list.push((i, signer.verification_key));
+        signature_list.push(signer.sign(&msg, i));
+    }
+    println!("--------------------------------------------------------");
+    println!(" -- {set_size} (sk, pk) are generated.");
+    println!(" -- {set_size} signatures are generated.");
+
+    println!("--------------------------------------------------------");
+    println!("----------- Generating Alba multi-signature. -----------");
+    let (threshold_signature, public_keys) =
+        ThresholdSignature::aggregate(&signature_list, &alba, &key_list);
+
+    println!("-- Alba multi-signature is generated.");
+    println!("--------------------------------------------------------");
+    println!("----------- Verifying Alba multi-signature. ------------");
+
+    if threshold_signature.verify(&msg, &alba, &public_keys) {
+        println!("-- Verification successful.");
+    } else {
+        println!("-- Verification failed.");
+    }
+    println!("--------------------------------------------------------");
+}

examples/simple_threshold_signature/mod.rs

@@ -0,0 +1,3 @@
+pub(crate) mod signature;
+pub(crate) mod signer;
+pub(crate) mod threshold_signature;

examples/simple_threshold_signature/signature.rs

@@ -0,0 +1,10 @@
+use blst::min_sig::Signature as BLSSignature;
+
+/// Single signature
+#[derive(Debug, Clone)]
+pub(crate) struct Signature {
+    /// Signature of type bls signature
+    pub(crate) signature: BLSSignature,
+    /// Verification index of the signer
+    pub(crate) index: usize,
+}

examples/simple_threshold_signature/signer.rs

@@ -0,0 +1,29 @@
+use crate::simple_threshold_signature::signature::Signature;
+use blst::min_sig::{PublicKey, SecretKey};
+use rand_core::{CryptoRng, RngCore};
+
+pub(crate) struct Signer {
+    signing_key: SecretKey,
+    pub(crate) verification_key: PublicKey,
+}
+
+impl Signer {
+    pub(crate) fn new(rng: &mut (impl RngCore + CryptoRng)) -> Self {
+        let mut ikm = [0u8; 32];
+        rng.fill_bytes(&mut ikm);
+        let sk = SecretKey::key_gen(&ikm, &[])
+            .expect("Error occurs when the length of ikm < 32. This will not happen here.");
+        let pk: PublicKey = sk.sk_to_pk();
+        Self {
+            signing_key: sk,
+            verification_key: pk,
+        }
+    }
+
+    pub(crate) fn sign(&self, msg: &[u8], index: usize) -> Signature {
+        Signature {
+            signature: self.signing_key.sign(msg, &[], &[]),
+            index,
+        }
+    }
+}

examples/simple_threshold_signature/threshold_signature.rs

@@ -0,0 +1,89 @@
+use crate::simple_threshold_signature::signature::Signature;
+use crate::Element;
+use alba::centralized_telescope::proof::Proof;
+use alba::centralized_telescope::Telescope;
+use blst::min_sig::{PublicKey, Signature as BLSSignature};
+use blst::BLST_ERROR;
+
+pub(crate) struct ThresholdSignature {
+    proof: Proof,
+}
+
+impl ThresholdSignature {
+    pub(crate) fn aggregate(
+        signatures: &[Signature],
+        alba: &Telescope,
+        key_list: &[(usize, PublicKey)],
+    ) -> (Self, Vec<PublicKey>) {
+        let prover_set = signatures
+            .iter()
+            .map(|s| s.signature.to_bytes())
+            .collect::<Vec<Element>>();
+        println!("-- Creating alba proof. ");
+        let proof = alba.prove(&prover_set).unwrap();
+        println!("-- Alba proof created: ");
+        println!(
+            " - Numbers of retries done to find the proof: {}",
+            proof.retry_counter
+        );
+        println!(
+            " - Index of the searched subtree to find the proof: {}",
+            proof.search_counter
+        );
+        println!(
+            " - Number of elements in the proof sequence: {}",
+            proof.element_sequence.len()
+        );
+
+        let proof_signatures: Vec<BLSSignature> = proof
+            .element_sequence
+            .iter()
+            .filter_map(|element| BLSSignature::from_bytes(element).ok())
+            .collect();
+
+        let mut public_keys = Vec::with_capacity(proof_signatures.len());
+        for sig in &proof_signatures {
+            if let Some(signature_entry) = signatures.iter().find(|entry| entry.signature == *sig) {
+                if let Some((_, public_key)) = key_list
+                    .iter()
+                    .find(|entry| entry.0 == signature_entry.index)
+                {
+                    public_keys.push(*public_key);
+                }
+            }
+        }
+        (Self { proof }, public_keys)
+    }
+
+    /// Validates individual signatures in the threshold signature
+    /// This function verifies each individual signature separately.
+    /// The verification could also be done by using aggregation from blst library as follows:
+    ///     - Aggregate signatures with: `AggregateSignature::aggregate`,
+    ///     - Aggregate public keys with: `AggregatePublicKey::aggregate`,
+    ///     - Convert aggregate signature to a signature and aggregate public key to a public key
+    ///     - Verify the signature with public key against given message.
+    fn validate_signatures(&self, msg: &[u8], public_keys: &[PublicKey]) -> bool {
+        let mut signatures = Vec::with_capacity(self.proof.element_sequence.len());
+        for sig_bytes in &self.proof.element_sequence {
+            let Ok(signature) = BLSSignature::from_bytes(sig_bytes.as_slice()) else {
+                return false;
+            };
+            signatures.push(signature);
+        }
+        for (i, signature) in signatures.iter().enumerate() {
+            if signature.verify(false, msg, &[], &[], &public_keys[i], false)
+                != BLST_ERROR::BLST_SUCCESS
+            {
+                return false;
+            }
+        }
+        true
+    }
+
+    pub(crate) fn verify(&self, msg: &[u8], alba: &Telescope, public_keys: &[PublicKey]) -> bool {
+        if self.validate_signatures(msg, public_keys) {
+            return alba.verify(&self.proof);
+        }
+        false
+    }
+}