- Replaced the useless Modulable trait with a generic cardinal<G>() function for G:PrimeField

- Restructured the spec tests

Author: nougzarm

src/toolbox/sigma/transcript/keccak_transcript.rs

@@ -5,6 +5,7 @@ use group::{Group, GroupEncoding};
 use num_bigint::BigUint;
 use std::convert::TryInto;
 use tiny_keccak::keccakf;
+use num_traits::identities::One;
 
 const R: usize = 136;
 const N: usize = 136 + 64;
@@ -145,32 +146,28 @@ impl DuplexSpongeInterface for KeccakDuplexSponge {
     }
 }
 
-pub trait Modulable: PrimeField {
-    fn cardinal() -> BigUint;
+fn cardinal<F: PrimeField>() -> BigUint {
+    let bytes = (F::ZERO - F::ONE).to_repr();
+    BigUint::from_bytes_le(bytes.as_ref()) + BigUint::one()
 }
 
 pub struct ByteSchnorrCodec<G, H>
 where
     G: Group + GroupEncoding + GroupSerialisation,
-    G::Scalar: Modulable,
     H: DuplexSpongeInterface,
 {
-    order: BigUint,
     hasher: H,
     _marker: core::marker::PhantomData<G>,
 }
 
 impl<G, H> TranscriptCodec<G> for ByteSchnorrCodec<G, H>
 where
     G: Group + GroupEncoding + GroupSerialisation,
-    G::Scalar: Modulable,
     H: DuplexSpongeInterface,
 {
     fn new(domain_sep: &[u8]) -> Self {
         let hasher = H::new(domain_sep);
-        let order = G::Scalar::cardinal();
         Self {
-            order,
             hasher,
             _marker: Default::default(),
         }
@@ -190,7 +187,7 @@ where
 
         let uniform_bytes = self.hasher.squeeze(scalar_byte_length + 16);
         let scalar = BigUint::from_bytes_be(&uniform_bytes);
-        let reduced = scalar % self.order.clone();
+        let reduced = scalar % cardinal::<G::Scalar>();
 
         let mut bytes = vec![0u8; scalar_byte_length];
         let reduced_bytes = reduced.to_bytes_be();

src/toolbox/sigma/transcript/mod.rs

@@ -2,6 +2,6 @@ pub mod keccak_transcript;
 pub mod shake_transcript;
 pub mod r#trait;
 
-pub use keccak_transcript::{ByteSchnorrCodec, KeccakDuplexSponge, Modulable};
+pub use keccak_transcript::{ByteSchnorrCodec, KeccakDuplexSponge};
 pub use r#trait::TranscriptCodec;
 pub use shake_transcript::ShakeTranscript;

tests/spec/bls12_381.rs

@@ -1,14 +1,14 @@
-use sigma_rs::tests::spec::random::{SInput, SRandom};
-use sigma_rs::toolbox::sigma::transcript::keccak_transcript::Modulable;
 use group::Group;
 use ff::PrimeField;
-use bls12_381::{G1Projective, Scalar};
+use bls12_381::G1Projective;
 use rand::{Rng, CryptoRng};
 use subtle::CtOption;
 use num_bigint::BigUint;
 use hex::FromHex;
 use num_traits::One;
 
+use crate::random::{SInput, SRandom};
+
 impl SInput for G1Projective {
     fn scalar_from_hex_be(
             hex_str: &str
@@ -65,10 +65,4 @@ impl SRandom for G1Projective {
         }
         G1Projective::scalar_from_hex_be(&hex_string).unwrap()
     }
-}
-
-impl Modulable for Scalar {
-    fn cardinal() -> BigUint {
-        BigUint::parse_bytes(b"111001111101101101001110101001100101001100111010111110101001000001100110011100111011000000010000000100110100001110110000000010101010011101111011010010000000010111111111111111001011011111111101111111111111111111111111111111100000000000000000000000000000001", 2).unwrap()
-    }
 }

tests/spec/custom_schnorr_proof.rs

@@ -1,10 +1,10 @@
 use rand::{CryptoRng, Rng};
 use group::{Group, GroupEncoding};
 use ff::PrimeField;
-use crate::toolbox::sigma::{GroupMorphismPreimage, SigmaProtocol, GroupSerialisation};
-use crate::errors::ProofError;
+use sigma_rs::toolbox::sigma::{GroupMorphismPreimage, SigmaProtocol, GroupSerialisation};
+use sigma_rs::ProofError;
 
-use crate::tests::spec::random::SRandom;
+use crate::random::SRandom;
 
 pub struct SchnorrProofCustom<G>
 where
@@ -13,11 +13,6 @@ where
     pub morphismp: GroupMorphismPreimage<G>
 }
 
-pub struct SchnorrState<S> {
-    pub nonces: Vec<S>,
-    pub witness: Vec<S>,
-}
-
 impl<G> SigmaProtocol for SchnorrProofCustom<G>
 where
     G: SRandom + GroupEncoding + GroupSerialisation

tests/spec/low_level_tests.rs

@@ -0,0 +1,61 @@
+use rand::RngCore;
+use group::{Group, ff::Field};
+use bls12_381::{G1Projective, G1Affine};
+use num_bigint::BigUint;
+
+use crate::test_drng::TestDRNG;
+
+type Gp = G1Projective;
+type Ga = G1Affine;
+
+#[allow(non_snake_case)]
+#[test]
+fn DRNG_testing() {
+    let mut rng = TestDRNG::new(b"hello world");
+    println!("Next u32 : {}", rng.next_u32());
+    println!("randint : {}", rng.randint(0, 1000000000));
+    // println!("randint : {}", rng.randint(0, 52435875175126190479447740508185965837690552500527637822603658699938581184513));
+    let low = BigUint::parse_bytes(b"0", 10).unwrap();
+    let high = BigUint::parse_bytes(b"73EDA753299D7C00000000000000000000000000000000000000000000000000", 16).unwrap();
+    let rand = rng.randint_big(&low, &high);
+    println!("{}", rand);
+}
+
+
+#[allow(non_snake_case)]
+#[test]
+fn Scalar_test() {
+    let rng = TestDRNG::new(b"hello world");
+    let y = <Gp as Group>::Scalar::random(rng);
+    let ZERO = <Gp as Group>::Scalar::ZERO;
+    let ONE = y * y.invert().unwrap();
+    let ONE_inv = ONE.invert().unwrap();
+    let TWO = ONE + ONE;
+    let TWO_INV = TWO.invert().unwrap();
+    println!("y = {}", y);
+    println!("ZERO = {}", ZERO);
+    println!("ONE = {}", ONE);
+    println!("ONE_inv = {}", ONE_inv);
+    println!("TWO = {}", TWO);
+    println!("TWO_INV = {}", TWO_INV);
+}
+
+#[allow(non_snake_case)]
+#[test]
+fn DRNG_test_on_Scalar() {
+    let mut rng = TestDRNG::new(b"hello world");
+    let x = G1Projective::random(&mut rng);
+    let y = G1Projective::random(&mut rng);
+    println!("x = {}", x);
+    println!("y = {}", y);
+}
+
+
+#[allow(non_snake_case)]
+#[test]
+fn DRNG_test_on_Group() {
+    let mut _rng = TestDRNG::new(b"hello world");
+    let H = Ga::identity();
+    let _bytes = H.to_uncompressed();
+    println!("H : {}", H);
+}

tests/spec/random.rs

@@ -20,75 +20,3 @@ pub trait SRandom: Group {
     ) -> Self::Scalar;
 }
 
-
-use num_bigint::BigUint;
-
-use rand::RngCore;
-use group::{Group, ff::Field};
-use bls12_381::{G1Projective, G1Affine};
-
-
-use spec::{TestDRNG, SInput, SRandom};
-
-type Gp = G1Projective;
-type Ga = G1Affine;
-
-#[allow(non_snake_case)]
-#[test]
-fn DRNG_testing() {
-    let mut rng = TestDRNG::new(b"hello world");
-    println!("Next u32 : {}", rng.next_u32());
-    println!("randint : {}", rng.randint(0, 1000000000));
-    // println!("randint : {}", rng.randint(0, 52435875175126190479447740508185965837690552500527637822603658699938581184513));
-    let low = BigUint::parse_bytes(b"0", 10).unwrap();
-    let high = BigUint::parse_bytes(b"73EDA753299D7C00000000000000000000000000000000000000000000000000", 16).unwrap();
-    let rand = rng.randint_big(&low, &high);
-    println!("{}", rand);
-}
-
-
-#[allow(non_snake_case)]
-#[test]
-fn Scalar_test() {
-    let rng = TestDRNG::new(b"hello world");
-    let y = <Gp as Group>::Scalar::random(rng);
-    let ZERO = <Gp as Group>::Scalar::ZERO;
-    let ONE = y * y.invert().unwrap();
-    let ONE_inv = ONE.invert().unwrap();
-    let TWO = ONE + ONE;
-    let TWO_INV = TWO.invert().unwrap();
-    let ch = hex::decode("26a48d1bb889d46d66689d580335f2ac713f36abaaaa1eaa5555555500000003").into().unwrap();
-    let Z = <Gp as Group>::Scalar::from_bytes(ch).unwrap();
-    let Z_inv = Z.invert().unwrap();
-    let _W = <Gp as Group>::Scalar::from_bytes(&Z_inv.to_bytes()).unwrap();
-    println!("y = {}", y);
-    println!("ZERO = {}", ZERO);
-    println!("ONE = {}", ONE);
-    println!("ONE_inv = {}", ONE_inv);
-    println!("TWO = {}", TWO);
-    println!("TWO_INV = {}", TWO_INV);
-    println!("Z = {}", Z);
-    println!("Z_inv = {}", Z_inv);
-    println!("W = {}", TWO * TWO);
-}
-
-#[allow(non_snake_case)]
-#[test]
-fn DRNG_test_on_Scalar() {
-    let mut rng = TestDRNG::new(b"hello world");
-    let x = G1Projective::random(&mut rng);
-    let y = G1Projective::random(&mut rng);
-    println!("x = {}", x);
-    println!("y = {}", y);
-}
-
-
-#[allow(non_snake_case)]
-#[test]
-fn DRNG_test_on_Group() {
-    let mut _rng = TestDRNG::new(b"hello world");
-    let H = Ga::identity();
-    let _bytes = H.to_uncompressed();
-    println!("Voici H : {}", H);
-}
-

tests/spec/sage_test_vectors.rs

@@ -1,20 +1,24 @@
 use bls12_381::G1Projective;
 use rand::{Rng, CryptoRng};
 use group::{Group, GroupEncoding};
-use random::{SRandom, TestDRNG};
-use custom_schnorr_proof::SchnorrProofCustom;
 
-use sigma_rs::toolbox::sigma::transcript::KeccakDuplexSponge;
 use sigma_rs::toolbox::sigma::{
+    transcript::{ByteSchnorrCodec, KeccakDuplexSponge},
     GroupMorphismPreimage,
-    transcript::ByteSchnorrCodec,
     NISigmaProtocol,
 };
 
+use crate::{
+    random::SRandom,
+    test_drng::TestDRNG,
+    custom_schnorr_proof::SchnorrProofCustom,
+};
+
 type Gp = G1Projective;
 type Codec = ByteSchnorrCodec::<Gp, KeccakDuplexSponge>;
 type SigmaP = SchnorrProofCustom<Gp>;
 
+
 fn msm_pr<G: Group>(scalars: &[G::Scalar], bases: &[G]) -> G {
     let mut acc = G::identity();
     for (s, p) in scalars.iter().zip(bases.iter()) {

tests/spec/test_sponge.rs

@@ -0,0 +1,17 @@
+#[path = "spec/bls12_381.rs"]
+mod bls12_381;
+
+#[path = "spec/custom_schnorr_proof.rs"]
+mod custom_schnorr_proof;
+
+#[path = "spec/low_level_tests.rs"]
+mod low_level_tests;
+
+#[path = "spec/random.rs"]
+mod random;
+
+#[path = "spec/sage_test_vectors.rs"]
+mod sage_test_vectors;
+
+#[path = "spec/test_drng.rs"]
+mod test_drng;