move decoding functionalities to separate module

Author: Mr-Leshiy

rust/catalyst-voting/src/crypto/elgamal/decoding.rs

@@ -0,0 +1,46 @@
+//! Elgamal objects decoding implementation
+
+use anyhow::anyhow;
+
+use super::{Ciphertext, GroupElement};
+
+impl Ciphertext {
+    /// `Ciphertext` bytes size
+    pub const BYTES_SIZE: usize = GroupElement::BYTES_SIZE * 2;
+
+    /// Convert this `Ciphertext` to its underlying sequence of bytes.
+    pub fn to_bytes(&self) -> [u8; Self::BYTES_SIZE] {
+        let mut res = [0; Self::BYTES_SIZE];
+        res[0..32].copy_from_slice(&self.0.to_bytes());
+        res[32..64].copy_from_slice(&self.1.to_bytes());
+        res
+    }
+
+    /// Attempt to construct a `Scalar` from a compressed value byte representation.
+    ///
+    /// # Errors
+    ///   - Cannot decode group element field.
+    #[allow(clippy::unwrap_used)]
+    pub fn from_bytes(bytes: &[u8; Self::BYTES_SIZE]) -> anyhow::Result<Self> {
+        Ok(Self(
+            GroupElement::from_bytes(bytes[0..32].try_into().unwrap())
+                .map_err(|_| anyhow!("Cannot decode first group element field."))?,
+            GroupElement::from_bytes(bytes[32..64].try_into().unwrap())
+                .map_err(|_| anyhow!("Cannot decode second group element field."))?,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use test_strategy::proptest;
+
+    use super::*;
+
+    #[proptest]
+    fn ciphertext_to_bytes_from_bytes_test(c1: Ciphertext) {
+        let bytes = c1.to_bytes();
+        let c2 = Ciphertext::from_bytes(&bytes).unwrap();
+        assert_eq!(c1, c2);
+    }
+}

rust/catalyst-voting/src/crypto/elgamal.rs renamed to rust/catalyst-voting/src/crypto/elgamal/mod.rs

@@ -1,9 +1,10 @@
 //! Implementation of the lifted ``ElGamal`` crypto system, and combine with `ChaCha`
 //! stream cipher to produce a hybrid encryption scheme.
 
+mod decoding;
+
 use std::ops::{Add, Deref, Mul};
 
-use anyhow::anyhow;
 use rand_core::CryptoRngCore;
 
 use crate::crypto::group::{GroupElement, Scalar};
@@ -50,9 +51,6 @@ impl SecretKey {
 }
 
 impl Ciphertext {
-    /// `Ciphertext` bytes size
-    pub const BYTES_SIZE: usize = GroupElement::BYTES_SIZE * 2;
-
     /// Generate a zero `Ciphertext`.
     /// The same as encrypt a `Scalar::zero()` message and `Scalar::zero()` randomness.
     pub fn zero() -> Self {
@@ -68,28 +66,6 @@ impl Ciphertext {
     pub fn second(&self) -> &GroupElement {
         &self.1
     }
-
-    /// Convert this `Ciphertext` to its underlying sequence of bytes.
-    pub fn to_bytes(&self) -> [u8; Self::BYTES_SIZE] {
-        let mut res = [0; Self::BYTES_SIZE];
-        res[0..32].copy_from_slice(&self.0.to_bytes());
-        res[32..64].copy_from_slice(&self.1.to_bytes());
-        res
-    }
-
-    /// Attempt to construct a `Scalar` from a compressed value byte representation.
-    ///
-    /// # Errors
-    ///   - Cannot decode group element field.
-    #[allow(clippy::unwrap_used)]
-    pub fn from_bytes(bytes: &[u8; Self::BYTES_SIZE]) -> anyhow::Result<Self> {
-        Ok(Self(
-            GroupElement::from_bytes(bytes[0..32].try_into().unwrap())
-                .map_err(|_| anyhow!("Cannot decode first group element field."))?,
-            GroupElement::from_bytes(bytes[32..64].try_into().unwrap())
-                .map_err(|_| anyhow!("Cannot decode second group element field."))?,
-        ))
-    }
 }
 
 /// Given a `message` represented as a `Scalar`, return a ciphertext using the
@@ -153,13 +129,6 @@ mod tests {
         }
     }
 
-    #[proptest]
-    fn ciphertext_to_bytes_from_bytes_test(c1: Ciphertext) {
-        let bytes = c1.to_bytes();
-        let c2 = Ciphertext::from_bytes(&bytes).unwrap();
-        assert_eq!(c1, c2);
-    }
-
     #[proptest]
     fn ciphertext_add_test(e1: Scalar, e2: Scalar, e3: Scalar, e4: Scalar) {
         let g1 = GroupElement::GENERATOR.mul(&e1);

rust/catalyst-voting/src/crypto/group/ristretto255/decoding.rs

@@ -0,0 +1,71 @@
+//! ristretto255 objects decoding implementation
+
+use anyhow::anyhow;
+use curve25519_dalek::{ristretto::CompressedRistretto, scalar::Scalar as IScalar};
+
+use super::{GroupElement, Scalar};
+
+impl Scalar {
+    /// `Scalar` bytes size
+    pub const BYTES_SIZE: usize = 32;
+
+    /// Attempt to construct a `Scalar` from a canonical byte representation.
+    ///
+    /// # Errors
+    ///   - Cannot decode scalar.
+    pub fn from_bytes(bytes: [u8; Self::BYTES_SIZE]) -> anyhow::Result<Scalar> {
+        IScalar::from_canonical_bytes(bytes)
+            .map(Scalar)
+            .into_option()
+            .ok_or(anyhow!("Cannot decode scalar."))
+    }
+
+    /// Convert this `Scalar` to its underlying sequence of bytes.
+    pub fn to_bytes(&self) -> [u8; Self::BYTES_SIZE] {
+        self.0.to_bytes()
+    }
+}
+
+impl GroupElement {
+    /// `Scalar` bytes size
+    pub const BYTES_SIZE: usize = 32;
+
+    /// Attempt to construct a `Scalar` from a compressed value byte representation.
+    ///
+    /// # Errors
+    ///   - Cannot decode group element.
+    pub fn from_bytes(bytes: &[u8; Self::BYTES_SIZE]) -> anyhow::Result<Self> {
+        Ok(GroupElement(
+            CompressedRistretto::from_slice(bytes)?
+                .decompress()
+                .ok_or(anyhow!("Cannot decode group element."))?,
+        ))
+    }
+
+    /// Convert this `GroupElement` to its underlying sequence of bytes.
+    /// Always encode the compressed value.
+    pub fn to_bytes(&self) -> [u8; Self::BYTES_SIZE] {
+        self.0.compress().to_bytes()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use test_strategy::proptest;
+
+    use super::*;
+
+    #[proptest]
+    fn scalar_to_bytes_from_bytes_test(e1: Scalar) {
+        let bytes = e1.to_bytes();
+        let e2 = Scalar::from_bytes(bytes).unwrap();
+        assert_eq!(e1, e2);
+    }
+
+    #[proptest]
+    fn group_element_to_bytes_from_bytes_test(ge1: GroupElement) {
+        let bytes = ge1.to_bytes();
+        let ge2 = GroupElement::from_bytes(&bytes).unwrap();
+        assert_eq!(ge1, ge2);
+    }
+}

rust/catalyst-voting/src/crypto/group/ristretto255.rs renamed to rust/catalyst-voting/src/crypto/group/ristretto255/mod.rs

@@ -2,16 +2,17 @@
 
 // cspell: words BASEPOINT
 
+mod decoding;
+
 use std::{
     hash::Hash,
     ops::{Add, Mul, Sub},
 };
 
-use anyhow::anyhow;
 use curve25519_dalek::{
     constants::{RISTRETTO_BASEPOINT_POINT, RISTRETTO_BASEPOINT_TABLE},
     digest::{consts::U64, Digest},
-    ristretto::{CompressedRistretto, RistrettoPoint as Point},
+    ristretto::RistrettoPoint as Point,
     scalar::Scalar as IScalar,
     traits::Identity,
 };
@@ -38,9 +39,6 @@ impl Hash for GroupElement {
 }
 
 impl Scalar {
-    /// `Scalar` bytes size
-    pub const BYTES_SIZE: usize = 32;
-
     /// Generate a random scalar value from the random number generator.
     pub fn random<R: CryptoRngCore>(rng: &mut R) -> Self {
         let mut scalar_bytes = [0u8; 64];
@@ -73,22 +71,6 @@ impl Scalar {
         Scalar(self.0.invert())
     }
 
-    /// Convert this `Scalar` to its underlying sequence of bytes.
-    pub fn to_bytes(&self) -> [u8; Self::BYTES_SIZE] {
-        self.0.to_bytes()
-    }
-
-    /// Attempt to construct a `Scalar` from a canonical byte representation.
-    ///
-    /// # Errors
-    ///   - Cannot decode scalar.
-    pub fn from_bytes(bytes: [u8; Self::BYTES_SIZE]) -> anyhow::Result<Scalar> {
-        IScalar::from_canonical_bytes(bytes)
-            .map(Scalar)
-            .into_option()
-            .ok_or(anyhow!("Cannot decode scalar."))
-    }
-
     /// Generate a `Scalar` from a hash digest.
     pub fn from_hash<D>(hash: D) -> Scalar
     where D: Digest<OutputSize = U64> {
@@ -97,33 +79,13 @@ impl Scalar {
 }
 
 impl GroupElement {
-    /// `GroupElement` bytes size
-    pub const BYTES_SIZE: usize = 32;
     /// ristretto255 group generator.
     pub const GENERATOR: GroupElement = GroupElement(RISTRETTO_BASEPOINT_POINT);
 
     /// Generate a zero group element.
     pub fn zero() -> Self {
         GroupElement(Point::identity())
     }
-
-    /// Convert this `GroupElement` to its underlying sequence of bytes.
-    /// Always encode the compressed value.
-    pub fn to_bytes(&self) -> [u8; Self::BYTES_SIZE] {
-        self.0.compress().to_bytes()
-    }
-
-    /// Attempt to construct a `Scalar` from a compressed value byte representation.
-    ///
-    /// # Errors
-    ///   - Cannot decode group element.
-    pub fn from_bytes(bytes: &[u8; Self::BYTES_SIZE]) -> anyhow::Result<Self> {
-        Ok(GroupElement(
-            CompressedRistretto::from_slice(bytes)?
-                .decompress()
-                .ok_or(anyhow!("Cannot decode group element."))?,
-        ))
-    }
 }
 
 // `std::ops` traits implementations
@@ -218,20 +180,6 @@ mod tests {
         }
     }
 
-    #[proptest]
-    fn scalar_to_bytes_from_bytes_test(e1: Scalar) {
-        let bytes = e1.to_bytes();
-        let e2 = Scalar::from_bytes(bytes).unwrap();
-        assert_eq!(e1, e2);
-    }
-
-    #[proptest]
-    fn group_element_to_bytes_from_bytes_test(ge1: GroupElement) {
-        let bytes = ge1.to_bytes();
-        let ge2 = GroupElement::from_bytes(&bytes).unwrap();
-        assert_eq!(ge1, ge2);
-    }
-
     #[proptest]
     fn scalar_arithmetic_tests(e1: Scalar, e2: Scalar, e3: Scalar) {
         assert_eq!(&(&e1 + &e2) + &e3, &e1 + &(&e2 + &e3));