some suggestions resolved

Author: curiecrypt

mithril-stm/src/signature_scheme/schnorr_signature/error.rs

@@ -13,21 +13,21 @@ pub enum SchnorrSignatureError {
     #[error("Invalid bytes")]
     SerializationError,
 
-    /// This error occurs when the serialization of the signing key bytes failed
+    /// This error occurs when the serialization of the scalar field bytes failed
     #[error("Invalid scalar field element bytes")]
-    ScalarFieldElementSerializationError,
+    ScalarFieldElementSerialization,
 
     /// This error occurs when the serialization of the projective point bytes failed
     #[error("Invalid projective point bytes")]
-    ProjectivePointSerializationError,
+    ProjectivePointSerialization,
 
     /// This error occurs when the serialization of the prime order projective point bytes failed
     #[error("Invalid prime order projective point bytes")]
-    PrimeOrderProjectivePointSerializationError,
+    PrimeOrderProjectivePointSerialization,
 
     /// This error occurs when the random scalar fails to generate during the signature
     #[error("Failed generation of the signature's random scalar")]
-    RandomScalarGenerationError,
+    RandomScalarGeneration,
 
     /// This error occurs when signing key is zero or one.
     #[error("The signing key is invalid.")]

mithril-stm/src/signature_scheme/schnorr_signature/jubjub/curve_points.rs

@@ -4,6 +4,7 @@ use dusk_jubjub::{
     SubgroupPoint as JubjubSubgroup,
 };
 use group::{Group, GroupEncoding};
+use std::ops::{Add, Mul};
 
 use super::{BaseFieldElement, ScalarFieldElement};
 use crate::{StmResult, signature_scheme::SchnorrSignatureError};
@@ -16,14 +17,6 @@ impl AffinePoint {
         AffinePoint(JubjubAffinePoint::from(projective_point.0))
     }
 
-    pub(crate) fn from_prime_order_projective_point(
-        prime_order_projective_point: &PrimeOrderProjectivePoint,
-    ) -> Self {
-        AffinePoint(JubjubAffinePoint::from(
-            ProjectivePoint::from_prime_order_projective_point(*prime_order_projective_point).0,
-        ))
-    }
-
     pub(crate) fn get_u(&self) -> BaseFieldElement {
         BaseFieldElement(self.0.get_u())
     }
@@ -33,6 +26,14 @@ impl AffinePoint {
     }
 }
 
+impl From<&PrimeOrderProjectivePoint> for AffinePoint {
+    fn from(prime_order_projective_point: &PrimeOrderProjectivePoint) -> Self {
+        AffinePoint(JubjubAffinePoint::from(JubjubExtended::from(
+            prime_order_projective_point.0,
+        )))
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct ProjectivePoint(pub(crate) JubjubExtended);
 
@@ -41,14 +42,6 @@ impl ProjectivePoint {
         ProjectivePoint(JubjubExtended::hash_to_point(input))
     }
 
-    pub(crate) fn add(&self, other: Self) -> Self {
-        ProjectivePoint(self.0 + other.0)
-    }
-
-    pub(crate) fn scalar_multiplication(&self, scalar: &ScalarFieldElement) -> Self {
-        ProjectivePoint(self.0 * scalar.0)
-    }
-
     pub(crate) fn get_coordinates(&self) -> (BaseFieldElement, BaseFieldElement) {
         let affine_point = AffinePoint::from_projective_point(*self);
 
@@ -66,23 +59,37 @@ impl ProjectivePoint {
 
         match JubjubExtended::from_bytes(&projective_point_bytes).into_option() {
             Some(projective_point) => Ok(Self(projective_point)),
-            None => Err(anyhow!(
-                SchnorrSignatureError::ProjectivePointSerializationError
-            )),
+            None => Err(anyhow!(SchnorrSignatureError::ProjectivePointSerialization)),
         }
     }
 
-    pub(crate) fn from_prime_order_projective_point(
-        prime_order_projective_point: PrimeOrderProjectivePoint,
-    ) -> Self {
-        ProjectivePoint(JubjubExtended::from(prime_order_projective_point.0))
-    }
-
     pub(crate) fn is_prime_order(self) -> bool {
         self.0.is_prime_order().into()
     }
 }
 
+impl Add for ProjectivePoint {
+    type Output = ProjectivePoint;
+
+    fn add(self, other: ProjectivePoint) -> ProjectivePoint {
+        ProjectivePoint(self.0 + other.0)
+    }
+}
+
+impl Mul<ProjectivePoint> for ScalarFieldElement {
+    type Output = ProjectivePoint;
+
+    fn mul(self, point: ProjectivePoint) -> ProjectivePoint {
+        ProjectivePoint(point.0 * self.0)
+    }
+}
+
+impl From<PrimeOrderProjectivePoint> for ProjectivePoint {
+    fn from(prime_order_projective_point: PrimeOrderProjectivePoint) -> Self {
+        ProjectivePoint(JubjubExtended::from(prime_order_projective_point.0))
+    }
+}
+
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub(crate) struct PrimeOrderProjectivePoint(pub(crate) JubjubSubgroup);
 
@@ -91,28 +98,18 @@ impl PrimeOrderProjectivePoint {
         PrimeOrderProjectivePoint(JubjubSubgroup::generator())
     }
 
-    pub(crate) fn add(&self, other: Self) -> Self {
-        PrimeOrderProjectivePoint(self.0 + other.0)
-    }
-
-    pub(crate) fn scalar_multiplication(&self, scalar: &ScalarFieldElement) -> Self {
-        PrimeOrderProjectivePoint(self.0 * scalar.0)
-    }
-
     /// Check if the given point is on the curve using its coordinates
     pub(crate) fn is_on_curve(&self) -> StmResult<PrimeOrderProjectivePoint> {
-        let point_affine_representation = AffinePoint::from_prime_order_projective_point(self);
+        let point_affine_representation = AffinePoint::from(self);
         let (x, y) = (
             point_affine_representation.get_u(),
             point_affine_representation.get_v(),
         );
-        let x_square = x.square();
-        let y_square = y.square();
+        let x_square = &x * &x;
+        let y_square = &y * &y;
 
-        let lhs = y_square.sub(&x_square);
-        let mut rhs = x_square.mul(&y_square);
-        rhs = rhs.mul(&BaseFieldElement(EDWARDS_D));
-        rhs = rhs.add(&BaseFieldElement::get_one());
+        let lhs = &y_square - &x_square;
+        let rhs = (x_square * y_square) * BaseFieldElement(EDWARDS_D) + BaseFieldElement::get_one();
 
         if lhs != rhs {
             return Err(anyhow!(SchnorrSignatureError::PointIsNotOnCurve(Box::new(
@@ -134,12 +131,28 @@ impl PrimeOrderProjectivePoint {
         match JubjubSubgroup::from_bytes(&prime_order_projective_point_bytes).into_option() {
             Some(prime_order_projective_point) => Ok(Self(prime_order_projective_point)),
             None => Err(anyhow!(
-                SchnorrSignatureError::PrimeOrderProjectivePointSerializationError
+                SchnorrSignatureError::PrimeOrderProjectivePointSerialization
             )),
         }
     }
 }
 
+impl Add for PrimeOrderProjectivePoint {
+    type Output = PrimeOrderProjectivePoint;
+
+    fn add(self, other: PrimeOrderProjectivePoint) -> PrimeOrderProjectivePoint {
+        PrimeOrderProjectivePoint(self.0 + other.0)
+    }
+}
+
+impl Mul<PrimeOrderProjectivePoint> for ScalarFieldElement {
+    type Output = PrimeOrderProjectivePoint;
+
+    fn mul(self, point: PrimeOrderProjectivePoint) -> PrimeOrderProjectivePoint {
+        PrimeOrderProjectivePoint(point.0 * self.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -156,7 +169,7 @@ mod tests {
             let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
             let scalar = ScalarFieldElement::new_random_nonzero_scalar(&mut rng).unwrap();
             let point = PrimeOrderProjectivePoint::create_generator();
-            point.scalar_multiplication(&scalar)
+            PrimeOrderProjectivePoint(point.0 * scalar.0)
         }
 
         #[test]

mithril-stm/src/signature_scheme/schnorr_signature/jubjub/field_elements.rs

@@ -2,44 +2,48 @@ use anyhow::anyhow;
 use dusk_jubjub::{Fq as JubjubBase, Fr as JubjubScalar};
 use ff::Field;
 use rand_core::{CryptoRng, RngCore};
+use std::ops::{Add, Mul, Sub};
 
-use super::ProjectivePoint;
 use crate::{StmResult, signature_scheme::SchnorrSignatureError};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct BaseFieldElement(pub(crate) JubjubBase);
 
 impl BaseFieldElement {
-    pub(crate) fn add(&self, other: &Self) -> Self {
+    pub(crate) fn get_one() -> Self {
+        BaseFieldElement(JubjubBase::ONE)
+    }
+}
+
+impl Add for BaseFieldElement {
+    type Output = BaseFieldElement;
+
+    fn add(self, other: BaseFieldElement) -> BaseFieldElement {
         BaseFieldElement(self.0 + other.0)
     }
+}
 
-    pub(crate) fn sub(&self, other: &Self) -> Self {
+impl Sub for &BaseFieldElement {
+    type Output = BaseFieldElement;
+
+    fn sub(self, other: &BaseFieldElement) -> BaseFieldElement {
         BaseFieldElement(self.0 - other.0)
     }
+}
 
-    pub(crate) fn mul(&self, other: &Self) -> Self {
-        BaseFieldElement(self.0 * other.0)
-    }
+impl Mul for BaseFieldElement {
+    type Output = BaseFieldElement;
 
-    pub(crate) fn square(&self) -> Self {
-        BaseFieldElement(self.0.square())
+    fn mul(self, other: BaseFieldElement) -> BaseFieldElement {
+        BaseFieldElement(self.0 * other.0)
     }
+}
 
-    pub(crate) fn get_one() -> Self {
-        BaseFieldElement(JubjubBase::ONE)
-    }
+impl Mul for &BaseFieldElement {
+    type Output = BaseFieldElement;
 
-    pub(crate) fn collect_coordinates_of_list_of_points(
-        point_list: &[ProjectivePoint],
-    ) -> Vec<Self> {
-        let mut coordinates: Vec<BaseFieldElement> = Vec::new();
-        for point in point_list {
-            let (u, v) = point.get_coordinates();
-            coordinates.push(u);
-            coordinates.push(v);
-        }
-        coordinates
+    fn mul(self, other: &BaseFieldElement) -> BaseFieldElement {
+        BaseFieldElement(self.0 * other.0)
     }
 }
 
@@ -74,15 +78,7 @@ impl ScalarFieldElement {
                 return Ok(random_scalar);
             }
         }
-        Err(anyhow!(SchnorrSignatureError::RandomScalarGenerationError))
-    }
-
-    pub(crate) fn sub(&self, other: &Self) -> Self {
-        ScalarFieldElement(self.0 - other.0)
-    }
-
-    pub(crate) fn mul(&self, other: &Self) -> Self {
-        ScalarFieldElement(self.0 * other.0)
+        Err(anyhow!(SchnorrSignatureError::RandomScalarGeneration))
     }
 
     pub(crate) fn to_bytes(self) -> [u8; 32] {
@@ -94,18 +90,34 @@ impl ScalarFieldElement {
         scalar_bytes.copy_from_slice(
             bytes
                 .get(..32)
-                .ok_or(SchnorrSignatureError::ScalarFieldElementSerializationError)?,
+                .ok_or(SchnorrSignatureError::ScalarFieldElementSerialization)?,
         );
 
         match JubjubScalar::from_bytes(&scalar_bytes).into_option() {
             Some(scalar_field_element) => Ok(Self(scalar_field_element)),
             None => Err(anyhow!(
-                SchnorrSignatureError::ScalarFieldElementSerializationError
+                SchnorrSignatureError::ScalarFieldElementSerialization
             )),
         }
     }
 }
 
+impl Mul for ScalarFieldElement {
+    type Output = ScalarFieldElement;
+
+    fn mul(self, other: ScalarFieldElement) -> ScalarFieldElement {
+        ScalarFieldElement(self.0 * other.0)
+    }
+}
+
+impl Sub for ScalarFieldElement {
+    type Output = ScalarFieldElement;
+
+    fn sub(self, other: ScalarFieldElement) -> ScalarFieldElement {
+        ScalarFieldElement(self.0 - other.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

mithril-stm/src/signature_scheme/schnorr_signature/mod.rs

@@ -29,7 +29,7 @@ mod tests {
             // Valid generation check
             let sk = SchnorrSigningKey::generate(&mut ChaCha20Rng::from_seed(seed)).unwrap();
             let g = PrimeOrderProjectivePoint::create_generator();
-            let vk = g.scalar_multiplication(&sk.0);
+            let vk = sk.0 * g;
             let vk_from_sk = SchnorrVerificationKey::new_from_signing_key(sk).unwrap();
             assert_eq!(vk, vk_from_sk.0);
 
@@ -110,7 +110,7 @@ mod tests {
             assert!(
                 matches!(
                     result.downcast_ref::<SchnorrSignatureError>(),
-                    Some(SchnorrSignatureError::ScalarFieldElementSerializationError)
+                    Some(SchnorrSignatureError::ScalarFieldElementSerialization)
                 ),
                 "Unexpected error: {result:?}"
             );
@@ -145,7 +145,7 @@ mod tests {
             assert!(
                 matches!(
                     result.downcast_ref::<SchnorrSignatureError>(),
-                    Some(SchnorrSignatureError::PrimeOrderProjectivePointSerializationError)
+                    Some(SchnorrSignatureError::PrimeOrderProjectivePointSerialization)
                 ),
                 "Unexpected error: {result:?}"
             );
@@ -169,7 +169,7 @@ mod tests {
             assert!(
                 matches!(
                     result.downcast_ref::<SchnorrSignatureError>(),
-                    Some(SchnorrSignatureError::ProjectivePointSerializationError)
+                    Some(SchnorrSignatureError::ProjectivePointSerialization)
                 ),
                 "Unexpected error: {result:?}"
             );
@@ -181,7 +181,7 @@ mod tests {
             assert!(
                 matches!(
                     result.downcast_ref::<SchnorrSignatureError>(),
-                    Some(SchnorrSignatureError::ScalarFieldElementSerializationError)
+                    Some(SchnorrSignatureError::ScalarFieldElementSerialization)
                 ),
                 "Unexpected error: {result:?}"
             );
@@ -193,7 +193,7 @@ mod tests {
             assert!(
                 matches!(
                     result.downcast_ref::<SchnorrSignatureError>(),
-                    Some(SchnorrSignatureError::ScalarFieldElementSerializationError)
+                    Some(SchnorrSignatureError::ScalarFieldElementSerialization)
                 ),
                 "Unexpected error: {result:?}"
             );