Sort Group methods

Author: daxpedda

src/group/mod.rs

@@ -78,35 +78,35 @@ pub trait Group {
     where
         <D as Add<U1>>::Output: ArrayLength<u8>;
 
-    /// Return a scalar from its fixed-length bytes representation. If the
-    /// scalar is zero or invalid, then return an error.
-    fn deserialize_scalar(scalar_bits: &GenericArray<u8, Self::ScalarLen>) -> Result<Self::Scalar>;
-
-    /// picks a scalar at random
-    fn random_scalar<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Scalar;
+    /// Get the base point for the group
+    fn base_elem() -> Self::Elem;
 
-    /// Serializes a scalar to bytes
-    fn serialize_scalar(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen>;
+    /// Returns the identity group element
+    fn identity_elem() -> Self::Elem;
 
-    /// The multiplicative inverse of this scalar
-    fn invert_scalar(scalar: Self::Scalar) -> Self::Scalar;
+    /// Serializes the `self` group element
+    fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen>;
 
     /// Return an element from its fixed-length bytes representation. If the
     /// element is the identity element, return an error.
     fn deserialize_elem(element_bits: &GenericArray<u8, Self::ElemLen>) -> Result<Self::Elem>;
 
-    /// Serializes the `self` group element
-    fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen>;
-
-    /// Get the base point for the group
-    fn base_elem() -> Self::Elem;
+    /// picks a scalar at random
+    fn random_scalar<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Scalar;
 
-    /// Returns the identity group element
-    fn identity_elem() -> Self::Elem;
+    /// The multiplicative inverse of this scalar
+    fn invert_scalar(scalar: Self::Scalar) -> Self::Scalar;
 
     /// Returns the scalar representing zero
     #[cfg(test)]
     fn zero_scalar() -> Self::Scalar;
+
+    /// Serializes a scalar to bytes
+    fn serialize_scalar(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen>;
+
+    /// Return a scalar from its fixed-length bytes representation. If the
+    /// scalar is zero or invalid, then return an error.
+    fn deserialize_scalar(scalar_bits: &GenericArray<u8, Self::ScalarLen>) -> Result<Self::Scalar>;
 }
 
 #[cfg(test)]

src/group/p256.rs

@@ -144,28 +144,12 @@ impl Group for NistP256 {
         Ok(Scalar::from_be_bytes_reduced(result))
     }
 
-    fn deserialize_scalar(scalar_bits: &GenericArray<u8, Self::ScalarLen>) -> Result<Self::Scalar> {
-        SecretKey::from_be_bytes(scalar_bits)
-            .map(|secret_key| *secret_key.to_nonzero_scalar())
-            .map_err(|_| Error::ScalarError)
-    }
-
-    fn random_scalar<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Scalar {
-        *SecretKey::random(rng).to_nonzero_scalar()
-    }
-
-    fn serialize_scalar(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen> {
-        scalar.into()
-    }
-
-    fn invert_scalar(scalar: Self::Scalar) -> Self::Scalar {
-        Option::from(scalar.invert()).unwrap()
+    fn base_elem() -> Self::Elem {
+        ProjectivePoint::generator()
     }
 
-    fn deserialize_elem(element_bits: &GenericArray<u8, Self::ElemLen>) -> Result<Self::Elem> {
-        PublicKey::from_sec1_bytes(element_bits)
-            .map(|public_key| public_key.to_projective())
-            .map_err(|_| Error::PointError)
+    fn identity_elem() -> Self::Elem {
+        ProjectivePoint::identity()
     }
 
     fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {
@@ -176,18 +160,34 @@ impl Group for NistP256 {
         result
     }
 
-    fn base_elem() -> Self::Elem {
-        ProjectivePoint::generator()
+    fn deserialize_elem(element_bits: &GenericArray<u8, Self::ElemLen>) -> Result<Self::Elem> {
+        PublicKey::from_sec1_bytes(element_bits)
+            .map(|public_key| public_key.to_projective())
+            .map_err(|_| Error::PointError)
     }
 
-    fn identity_elem() -> Self::Elem {
-        ProjectivePoint::identity()
+    fn random_scalar<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Scalar {
+        *SecretKey::random(rng).to_nonzero_scalar()
+    }
+
+    fn invert_scalar(scalar: Self::Scalar) -> Self::Scalar {
+        Option::from(scalar.invert()).unwrap()
     }
 
     #[cfg(test)]
     fn zero_scalar() -> Self::Scalar {
         Scalar::zero()
     }
+
+    fn serialize_scalar(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen> {
+        scalar.into()
+    }
+
+    fn deserialize_scalar(scalar_bits: &GenericArray<u8, Self::ScalarLen>) -> Result<Self::Scalar> {
+        SecretKey::from_be_bytes(scalar_bits)
+            .map(|secret_key| *secret_key.to_nonzero_scalar())
+            .map_err(|_| Error::ScalarError)
+    }
 }
 
 /// Corresponds to the hash_to_curve_simple_swu() function defined in

src/group/ristretto.rs

@@ -80,10 +80,24 @@ impl Group for Ristretto255 {
         ))
     }
 
-    fn deserialize_scalar(scalar_bits: &GenericArray<u8, Self::ScalarLen>) -> Result<Self::Scalar> {
-        Scalar::from_canonical_bytes((*scalar_bits).into())
-            .filter(|scalar| scalar != &Scalar::zero())
-            .ok_or(Error::ScalarError)
+    fn base_elem() -> Self::Elem {
+        RISTRETTO_BASEPOINT_POINT
+    }
+
+    fn identity_elem() -> Self::Elem {
+        RistrettoPoint::identity()
+    }
+
+    // serialization of a group element
+    fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {
+        elem.compress().to_bytes().into()
+    }
+
+    fn deserialize_elem(element_bits: &GenericArray<u8, Self::ElemLen>) -> Result<Self::Elem> {
+        CompressedRistretto::from_slice(element_bits)
+            .decompress()
+            .filter(|point| point != &RistrettoPoint::identity())
+            .ok_or(Error::PointError)
     }
 
     fn random_scalar<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Scalar {
@@ -100,36 +114,22 @@ impl Group for Ristretto255 {
         }
     }
 
-    fn serialize_scalar(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen> {
-        scalar.to_bytes().into()
-    }
-
     fn invert_scalar(scalar: Self::Scalar) -> Self::Scalar {
         scalar.invert()
     }
 
-    fn deserialize_elem(element_bits: &GenericArray<u8, Self::ElemLen>) -> Result<Self::Elem> {
-        CompressedRistretto::from_slice(element_bits)
-            .decompress()
-            .filter(|point| point != &RistrettoPoint::identity())
-            .ok_or(Error::PointError)
-    }
-
-    // serialization of a group element
-    fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {
-        elem.compress().to_bytes().into()
-    }
-
-    fn base_elem() -> Self::Elem {
-        RISTRETTO_BASEPOINT_POINT
+    #[cfg(test)]
+    fn zero_scalar() -> Self::Scalar {
+        Scalar::zero()
     }
 
-    fn identity_elem() -> Self::Elem {
-        RistrettoPoint::identity()
+    fn serialize_scalar(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen> {
+        scalar.to_bytes().into()
     }
 
-    #[cfg(test)]
-    fn zero_scalar() -> Self::Scalar {
-        Scalar::zero()
+    fn deserialize_scalar(scalar_bits: &GenericArray<u8, Self::ScalarLen>) -> Result<Self::Scalar> {
+        Scalar::from_canonical_bytes((*scalar_bits).into())
+            .filter(|scalar| scalar != &Scalar::zero())
+            .ok_or(Error::ScalarError)
     }
 }