Implementation of Schnorr signature module for mithril-stm.

mithril-stm/Cargo.toml

@@ -19,13 +19,25 @@ rug-backend = ["rug/default"]
 num-integer-backend = ["num-bigint", "num-rational", "num-traits"]
 benchmark-internals = [] # For benchmarking multi_sig
 future_proof_system = [] # For activating future proof systems
+future_snark = [
+    "ff",
+    "group",
+    "num-traits",
+    "dusk-poseidon",
+    "dusk-jubjub",
+] # For activating snark features
 
 [dependencies]
 anyhow = { workspace = true }
 blake2 = "0.10.6"
 # Enforce blst portable feature for runtime detection of Intel ADX instruction set.
 blst = { version = "0.3.16", features = ["portable"] }
 digest = { workspace = true }
+dusk-jubjub = { version = "0.15.1", optional = true }
+dusk-poseidon = { version = "0.41.0", optional = true }
+ff = { version = "0.13.1", optional = true }
+group = { version = "0.13.0", optional = true }
+num-traits = { version = "0.2.19", optional = true }
 rand_core = { workspace = true }
 rayon = { workspace = true }
 serde = { workspace = true }
@@ -58,6 +70,11 @@ name = "multi_sig"
 harness = false
 required-features = ["benchmark-internals"]
 
+[[bench]]
+name = "schnorr_sig"
+harness = false
+required-features = ["future_snark"]
+
 [[bench]]
 name = "stm"
 harness = false

mithril-stm/benches/schnorr_sig.rs

@@ -0,0 +1,41 @@
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use mithril_stm::{SchnorrSigningKey, SchnorrVerificationKey};
+use rand_chacha::ChaCha20Rng;
+use rand_core::{RngCore, SeedableRng};
+
+fn sign_and_verify(c: &mut Criterion, nr_sigs: usize) {
+    let mut group = c.benchmark_group("Schnorr".to_string());
+    let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
+    let mut rng_sig = ChaCha20Rng::from_seed([1u8; 32]);
+
+    let mut msg = [0u8; 32];
+    rng.fill_bytes(&mut msg);
+    let mut mvks = Vec::new();
+    let mut sigs = Vec::new();
+    for _ in 0..nr_sigs {
+        let sk = SchnorrSigningKey::generate(&mut rng);
+        let vk = SchnorrVerificationKey::from(&sk);
+        let sig = sk.sign(&msg, &mut rng_sig).unwrap();
+        sigs.push(sig);
+        mvks.push(vk);
+    }
+
+    group.bench_function(BenchmarkId::new("Individual verif", nr_sigs), |b| {
+        b.iter(|| {
+            for (vk, sig) in mvks.iter().zip(sigs.iter()) {
+                assert!(sig.verify(&msg, vk).is_ok());
+            }
+        })
+    });
+}
+
+fn schnorr_benches(c: &mut Criterion) {
+    sign_and_verify(c, 856);
+}
+
+criterion_group!(name = benches;
+                 config = Criterion::default().nresamples(1000);
+                 targets =
+    schnorr_benches
+);
+criterion_main!(benches);

mithril-stm/src/error.rs

@@ -7,6 +7,8 @@ use crate::aggregate_signature::AggregateSignatureType;
 use crate::bls_multi_signature::{
     BlsSignature, BlsVerificationKey, BlsVerificationKeyProofOfPossession,
 };
+#[cfg(feature = "future_snark")]
+use crate::{SchnorrSignature, SchnorrVerificationKey};
 
 /// Error types for multi signatures.
 #[derive(Debug, thiserror::Error, Eq, PartialEq)]
@@ -40,6 +42,23 @@ pub enum MultiSignatureError {
     VerificationKeyInfinity(Box<BlsVerificationKey>),
 }
 
+/// Error types for Schnorr signatures.
+#[cfg(feature = "future_snark")]
+#[derive(Debug, thiserror::Error, Eq, PartialEq)]
+pub enum SchnorrSignatureError {
+    /// Invalid Single signature
+    #[error("Invalid Schnorr single signature")]
+    SignatureInvalid(Box<SchnorrSignature>),
+
+    /// Invalid Verification key
+    #[error("Invalid Schnorr Verification key")]
+    VerificationKeyInvalid(Box<SchnorrVerificationKey>),
+
+    /// This error occurs when the the serialization of the raw bytes failed
+    #[error("Invalid bytes")]
+    SerializationError,
+}
+
 /// Error types related to merkle trees.
 #[derive(Debug, Clone, thiserror::Error)]
 pub enum MerkleTreeError {

mithril-stm/src/lib.rs

@@ -119,6 +119,8 @@ mod key_registration;
 mod merkle_tree;
 mod parameters;
 mod participant;
+#[cfg(feature = "future_snark")]
+mod schnorr_signature;
 mod single_signature;
 
 pub use aggregate_signature::{
@@ -138,6 +140,9 @@ pub use bls_multi_signature::{
     BlsVerificationKeyProofOfPossession,
 };
 
+#[cfg(feature = "future_snark")]
+pub use schnorr_signature::{SchnorrSignature, SchnorrSigningKey, SchnorrVerificationKey};
+
 /// The quantity of stake held by a party, represented as a `u64`.
 pub type Stake = u64;