wip

Author: Mr-Leshiy

rust/catalyst-voting/src/crypto/mod.rs

@@ -1,8 +1,8 @@
 //! Crypto primitives which are used by voting protocol.
 
-pub(crate) mod babystep_giantstep;
-pub(crate) mod elgamal;
-pub(crate) mod group;
-pub(crate) mod hash;
-pub(crate) mod zk_dl_equality;
-pub(crate) mod zk_unit_vector;
+pub mod babystep_giantstep;
+pub mod elgamal;
+pub mod group;
+pub mod hash;
+pub mod zk_dl_equality;
+pub mod zk_unit_vector;

rust/catalyst-voting/src/crypto/zk_unit_vector/mod.rs

@@ -11,7 +11,7 @@ mod polynomial;
 mod randomness_announcements;
 mod utils;
 
-use std::ops::Mul;
+use std::{io::Read, ops::Mul};
 
 use challenges::{calculate_first_challenge_hash, calculate_second_challenge_hash};
 use polynomial::{calculate_polynomial_val, generate_polynomial, Polynomial};
@@ -25,13 +25,72 @@ use crate::crypto::{
 };
 
 /// Unit vector proof struct
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UnitVectorProof(
     Vec<Announcement>,
     Vec<Ciphertext>,
     Vec<ResponseRandomness>,
     Scalar,
 );
 
+impl UnitVectorProof {
+    /// Decode `UnitVectorProof` from bytes.
+    pub fn from_bytes(mut bytes: &[u8], size: usize) -> Option<Self> {
+        let mut ann_buf = [0u8; Announcement::BYTES_SIZE];
+        let mut dl_buf = [0u8; Ciphertext::BYTES_SIZE];
+        let mut rr_buf = [0u8; ResponseRandomness::BYTES_SIZE];
+
+        let ann = (0..size)
+            .map(|_| {
+                bytes.read_exact(&mut ann_buf).ok()?;
+                Announcement::from_bytes(&ann_buf)
+            })
+            .collect::<Option<_>>()?;
+        let dl = (0..size)
+            .map(|_| {
+                bytes.read_exact(&mut dl_buf).ok()?;
+                Ciphertext::from_bytes(&dl_buf)
+            })
+            .collect::<Option<_>>()?;
+        let rr = (0..size)
+            .map(|_| {
+                bytes.read_exact(&mut rr_buf).ok()?;
+                ResponseRandomness::from_bytes(&rr_buf)
+            })
+            .collect::<Option<_>>()?;
+
+        let mut scalar_buf = [0u8; Scalar::BYTES_SIZE];
+        bytes.read_exact(&mut scalar_buf).ok()?;
+        let scalar = Scalar::from_bytes(scalar_buf)?;
+        Some(Self(ann, dl, rr, scalar))
+    }
+
+    /// Get a deserialized bytes size
+    #[must_use]
+    pub fn bytes_size(&self) -> usize {
+        self.0.len() * Announcement::BYTES_SIZE
+            + self.0.len() * Ciphertext::BYTES_SIZE
+            + self.0.len() * ResponseRandomness::BYTES_SIZE
+    }
+
+    /// Encode `EncryptedVote` tos bytes.
+    #[must_use]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut res = Vec::with_capacity(self.bytes_size());
+        self.0
+            .iter()
+            .for_each(|c| res.extend_from_slice(&c.to_bytes()));
+        self.1
+            .iter()
+            .for_each(|c| res.extend_from_slice(&c.to_bytes()));
+        self.2
+            .iter()
+            .for_each(|c| res.extend_from_slice(&c.to_bytes()));
+        res.extend_from_slice(&self.3.to_bytes());
+        res
+    }
+}
+
 /// Generates a unit vector proof.
 ///
 /// `unit_vector` must be a collection of `Scalar` where only one element is equal to
@@ -232,12 +291,40 @@ fn check_2(
 
 #[cfg(test)]
 mod tests {
-    use proptest::sample::size_range;
+    use proptest::{
+        prelude::{any_with, Arbitrary, BoxedStrategy, Strategy},
+        sample::size_range,
+    };
     use rand_core::OsRng;
     use test_strategy::proptest;
 
     use super::{super::elgamal::SecretKey, *};
 
+    impl Arbitrary for UnitVectorProof {
+        type Parameters = usize;
+        type Strategy = BoxedStrategy<Self>;
+
+        fn arbitrary_with(size: Self::Parameters) -> Self::Strategy {
+            any_with::<(
+                Vec<((Announcement, Ciphertext), ResponseRandomness)>,
+                Scalar,
+            )>(((size_range(size), (((), ()), ())), ()))
+            .prop_map(|(val, scalar)| {
+                let (vec, rr): (Vec<_>, Vec<_>) = val.into_iter().unzip();
+                let (an, ciph) = vec.into_iter().unzip();
+                Self(an, ciph, rr, scalar)
+            })
+            .boxed()
+        }
+    }
+
+    #[proptest]
+    fn proof_to_bytes_from_bytes_test(p1: UnitVectorProof) {
+        let bytes = p1.to_bytes();
+        let p2 = UnitVectorProof::from_bytes(&bytes, p1.0.len()).unwrap();
+        assert_eq!(p1, p2);
+    }
+
     fn is_unit_vector(vector: &[Scalar]) -> bool {
         let ones = vector.iter().filter(|s| s == &&Scalar::one()).count();
         let zeros = vector.iter().filter(|s| s == &&Scalar::zero()).count();

rust/catalyst-voting/src/crypto/zk_unit_vector/randomness_announcements.rs

@@ -1,6 +1,6 @@
 //! Randomness and announcements structs for the ZK unit vector algorithm
 
-#![allow(clippy::missing_docs_in_private_items, dead_code)]
+#![allow(clippy::missing_docs_in_private_items)]
 
 use std::ops::Mul;
 
@@ -37,14 +37,6 @@ pub struct Announcement {
     pub(crate) a: GroupElement,
 }
 
-/// `EncryptedVote` decoding error
-#[derive(thiserror::Error, Debug)]
-pub enum AnnouncementDecodingError {
-    /// Cannot decode ciphertext
-    #[error("Cannot decode group element {0} field.")]
-    CannotDecodeGroupElement(char),
-}
-
 impl Announcement {
     /// `Announcement` bytes size
     pub const BYTES_SIZE: usize = GroupElement::BYTES_SIZE * 3;
@@ -71,14 +63,11 @@ impl Announcement {
     /// # Errors
     ///   - `AnnouncementDecodingError`
     #[allow(clippy::unwrap_used)]
-    pub fn from_bytes(bytes: &[u8; Self::BYTES_SIZE]) -> Result<Self, AnnouncementDecodingError> {
-        let i = GroupElement::from_bytes(bytes[0..32].try_into().unwrap())
-            .ok_or(AnnouncementDecodingError::CannotDecodeGroupElement('i'))?;
-        let b = GroupElement::from_bytes(bytes[32..64].try_into().unwrap())
-            .ok_or(AnnouncementDecodingError::CannotDecodeGroupElement('b'))?;
-        let a = GroupElement::from_bytes(bytes[64..96].try_into().unwrap())
-            .ok_or(AnnouncementDecodingError::CannotDecodeGroupElement('a'))?;
-        Ok(Self { i, b, a })
+    pub fn from_bytes(bytes: &[u8; Self::BYTES_SIZE]) -> Option<Self> {
+        let i = GroupElement::from_bytes(bytes[0..32].try_into().unwrap())?;
+        let b = GroupElement::from_bytes(bytes[32..64].try_into().unwrap())?;
+        let a = GroupElement::from_bytes(bytes[64..96].try_into().unwrap())?;
+        Some(Self { i, b, a })
     }
 
     /// Encode `Announcement` tos bytes.
@@ -101,14 +90,6 @@ pub struct ResponseRandomness {
     pub(crate) v: Scalar,
 }
 
-/// `EncryptedVote` decoding error
-#[derive(thiserror::Error, Debug)]
-pub enum ResponseRandomnessDecodingError {
-    /// Cannot decode ciphertext
-    #[error("Cannot decode scalar {0} field.")]
-    CannotDecodeScalar(char),
-}
-
 impl ResponseRandomness {
     /// `ResponseRandomness` bytes size
     pub const BYTES_SIZE: usize = Scalar::BYTES_SIZE * 3;
@@ -129,16 +110,11 @@ impl ResponseRandomness {
     /// # Errors
     ///   - `ResponseRandomnessDecodingError`
     #[allow(clippy::unwrap_used)]
-    pub fn from_bytes(
-        bytes: &[u8; Self::BYTES_SIZE],
-    ) -> Result<Self, ResponseRandomnessDecodingError> {
-        let z = Scalar::from_bytes(bytes[0..32].try_into().unwrap())
-            .ok_or(ResponseRandomnessDecodingError::CannotDecodeScalar('z'))?;
-        let w = Scalar::from_bytes(bytes[32..64].try_into().unwrap())
-            .ok_or(ResponseRandomnessDecodingError::CannotDecodeScalar('w'))?;
-        let v = Scalar::from_bytes(bytes[64..96].try_into().unwrap())
-            .ok_or(ResponseRandomnessDecodingError::CannotDecodeScalar('v'))?;
-        Ok(Self { z, w, v })
+    pub fn from_bytes(bytes: &[u8; Self::BYTES_SIZE]) -> Option<Self> {
+        let z = Scalar::from_bytes(bytes[0..32].try_into().unwrap())?;
+        let w = Scalar::from_bytes(bytes[32..64].try_into().unwrap())?;
+        let v = Scalar::from_bytes(bytes[64..96].try_into().unwrap())?;
+        Some(Self { z, w, v })
     }
 
     /// Encode `ResponseRandomness` tos bytes.

rust/catalyst-voting/src/txs/v1.rs

@@ -4,7 +4,7 @@
 
 use std::io::Read;
 
-use crate::vote_protocol::voter::{DecodingError as EncryptedVoteDecodingError, EncryptedVote};
+use crate::vote_protocol::voter::EncryptedVote;
 
 /// A v1 (Jörmungandr) transaction struct
 pub struct Tx {
@@ -61,8 +61,8 @@ pub enum DecodingError {
     #[error("Cannot decode encrypted vote size field.")]
     CannotDecodeEncryptedVoteSize,
     /// Cannot decode encrypted vote
-    #[error(transparent)]
-    CannotDecodeEncryptedVote(#[from] EncryptedVoteDecodingError),
+    #[error("Cannot decode ecnrypted vote field.")]
+    CannotDecodeEncryptedVote,
 }
 
 impl Tx {
@@ -119,7 +119,8 @@ impl Tx {
                 bytes
                     .read_exact(&mut u8_buf)
                     .map_err(|_| DecodingError::CannotDecodeEncryptedVoteSize)?;
-                let encrypted_vote = EncryptedVote::from_bytes(bytes, u8_buf[0].into())?;
+                let encrypted_vote = EncryptedVote::from_bytes(bytes, u8_buf[0].into())
+                    .ok_or(DecodingError::CannotDecodeEncryptedVote)?;
 
                 Vote::Private(encrypted_vote)
             },

rust/catalyst-voting/src/vote_protocol/voter/mod.rs

@@ -38,33 +38,20 @@ impl EncryptionRandomness {
     }
 }
 
-/// `EncryptedVote` decoding error
-#[derive(thiserror::Error, Debug)]
-pub enum DecodingError {
-    /// Cannot decode ciphertext
-    #[error("Cannot decode ciphertext {0} field.")]
-    CannotDecodeCiphertext(usize),
-}
-
 impl EncryptedVote {
     /// Decode `EncryptedVote` from bytes.
-    ///
-    /// # Errors
-    ///   - `DecodingError`
-    pub fn from_bytes(mut bytes: &[u8], size: usize) -> Result<Self, DecodingError> {
+    #[must_use]
+    pub fn from_bytes(mut bytes: &[u8], size: usize) -> Option<Self> {
         let mut ciph_buf = [0u8; Ciphertext::BYTES_SIZE];
 
-        let mut ciphertexts = Vec::with_capacity(size);
-        for i in 0..size {
-            bytes
-                .read_exact(&mut ciph_buf)
-                .map_err(|_| DecodingError::CannotDecodeCiphertext(i))?;
-            ciphertexts.push(
+        let ciphertexts = (0..size)
+            .map(|_| {
+                bytes.read_exact(&mut ciph_buf).ok()?;
                 Ciphertext::from_bytes(&ciph_buf)
-                    .ok_or(DecodingError::CannotDecodeCiphertext(i))?,
-            );
-        }
-        Ok(Self(ciphertexts))
+            })
+            .collect::<Option<_>>()?;
+
+        Some(Self(ciphertexts))
     }
 
     /// Get a deserialized bytes size

rust/catalyst-voting/src/vote_protocol/voter/proof.rs

@@ -1,7 +1,7 @@
 //! Voter proof generation and verification procedures.
 //! It allows to transparently verify the correctness voter generation and encryption.
 
-use std::ops::Mul;
+use std::ops::{Deref, Mul};
 
 use rand_core::CryptoRngCore;
 
@@ -18,6 +18,14 @@ use crate::{
 #[allow(clippy::module_name_repetitions)]
 pub struct VoterProof(UnitVectorProof);
 
+impl Deref for VoterProof {
+    type Target = UnitVectorProof;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 /// Voter proof commitment struct.
 pub struct VoterProofCommitment(GroupElement);