Rename and remove Group methods

daxpedda · daxpedda · commit c255d6426cc3 · 2022-01-10T01:57:10.000+01:00
`to_arr` -&gt; `serialize_elem`
`base_point` -&gt; `base_elem`
`is_identity` -&gt; removed
`identity` -&gt; `identity_elem`
`zero_scalar` -&gt; hidden behind `cfg(test)`
diff --git a/src/group/mod.rs b/src/group/mod.rs
@@ -96,21 +96,17 @@ pub trait Group {
     fn deserialize_elem(element_bits: &GenericArray<u8, Self::ElemLen>) -> Result<Self::Elem>;
 
     /// Serializes the `self` group element
-    fn to_arr(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen>;
+    fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen>;
 
     /// Get the base point for the group
-    fn base_point() -> Self::Elem;
-
-    /// Returns if the group element is equal to the identity (1)
-    fn is_identity(elem: Self::Elem) -> bool {
-        elem.ct_eq(&Self::identity()).into()
-    }
+    fn base_elem() -> Self::Elem;
 
     /// Returns the identity group element
-    fn identity() -> Self::Elem;
+    fn identity_elem() -> Self::Elem;
 
     /// Returns the scalar representing zero
-    fn scalar_zero() -> Self::Scalar;
+    #[cfg(test)]
+    fn zero_scalar() -> Self::Scalar;
 }
 
 #[cfg(test)]
diff --git a/src/group/p256.rs b/src/group/p256.rs
@@ -27,6 +27,7 @@ use once_cell::unsync::Lazy;
 use p256_::elliptic_curve::group::prime::PrimeCurveAffine;
 use p256_::elliptic_curve::ops::Reduce;
 use p256_::elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint};
+#[cfg(test)]
 use p256_::elliptic_curve::Field;
 use p256_::{AffinePoint, EncodedPoint, NistP256, ProjectivePoint, PublicKey, Scalar, SecretKey};
 use rand_core::{CryptoRng, RngCore};
@@ -167,23 +168,24 @@ impl Group for NistP256 {
             .map_err(|_| Error::PointError)
     }
 
-    fn to_arr(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {
+    fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {
         let bytes = elem.to_affine().to_encoded_point(true);
         let bytes = bytes.as_bytes();
         let mut result = GenericArray::default();
         result[..bytes.len()].copy_from_slice(bytes);
         result
     }
 
-    fn base_point() -> Self::Elem {
+    fn base_elem() -> Self::Elem {
         ProjectivePoint::generator()
     }
 
-    fn identity() -> Self::Elem {
+    fn identity_elem() -> Self::Elem {
         ProjectivePoint::identity()
     }
 
-    fn scalar_zero() -> Self::Scalar {
+    #[cfg(test)]
+    fn zero_scalar() -> Self::Scalar {
         Scalar::zero()
     }
 }
diff --git a/src/group/ristretto.rs b/src/group/ristretto.rs
@@ -116,19 +116,20 @@ impl Group for Ristretto255 {
     }
 
     // serialization of a group element
-    fn to_arr(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {
+    fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {
         elem.compress().to_bytes().into()
     }
 
-    fn base_point() -> Self::Elem {
+    fn base_elem() -> Self::Elem {
         RISTRETTO_BASEPOINT_POINT
     }
 
-    fn identity() -> Self::Elem {
+    fn identity_elem() -> Self::Elem {
         RistrettoPoint::identity()
     }
 
-    fn scalar_zero() -> Self::Scalar {
+    #[cfg(test)]
+    fn zero_scalar() -> Self::Scalar {
         Scalar::zero()
     }
 }
diff --git a/src/group/tests.rs b/src/group/tests.rs
@@ -35,16 +35,16 @@ fn test_group_properties() -> Result<()> {
 
 // Checks that the identity element cannot be deserialized
 fn test_identity_element_error<G: Group>() -> Result<()> {
-    let identity = G::identity();
-    let result = G::deserialize_elem(&G::to_arr(identity));
+    let identity = G::identity_elem();
+    let result = G::deserialize_elem(&G::serialize_elem(identity));
     assert!(matches!(result, Err(Error::PointError)));
 
     Ok(())
 }
 
 // Checks that the zero scalar cannot be deserialized
 fn test_zero_scalar_error<G: Group>() -> Result<()> {
-    let zero_scalar = G::scalar_zero();
+    let zero_scalar = G::zero_scalar();
     let result = G::deserialize_scalar(&G::serialize_scalar(zero_scalar));
     assert!(matches!(result, Err(Error::ScalarError)));
 
diff --git a/src/serialization.rs b/src/serialization.rs
@@ -53,7 +53,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> VerifiableClient<G,
         G::ScalarLen: Add<G::ElemLen>,
         Sum<G::ScalarLen, G::ElemLen>: ArrayLength<u8>,
     {
-        G::serialize_scalar(self.blind).concat(G::to_arr(self.blinded_element))
+        G::serialize_scalar(self.blind).concat(G::serialize_elem(self.blinded_element))
     }
 
     /// Deserialization from bytes
@@ -97,7 +97,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> VerifiableServer<G,
         G::ScalarLen: Add<G::ElemLen>,
         Sum<G::ScalarLen, G::ElemLen>: ArrayLength<u8>,
     {
-        G::serialize_scalar(self.sk).concat(G::to_arr(self.pk))
+        G::serialize_scalar(self.sk).concat(G::serialize_elem(self.pk))
     }
 
     /// Deserialization from bytes
@@ -143,7 +143,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> Proof<G, H> {
 impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> BlindedElement<G, H> {
     /// Serialization into bytes
     pub fn serialize(&self) -> GenericArray<u8, G::ElemLen> {
-        G::to_arr(self.value)
+        G::serialize_elem(self.value)
     }
 
     /// Deserialization from bytes
@@ -162,7 +162,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> BlindedElement<G, H
 impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> EvaluationElement<G, H> {
     /// Serialization into bytes
     pub fn serialize(&self) -> GenericArray<u8, G::ElemLen> {
-        G::to_arr(self.value)
+        G::serialize_elem(self.value)
     }
 
     /// Deserialization from bytes
diff --git a/src/tests/voprf_test_vectors.rs b/src/tests/voprf_test_vectors.rs
@@ -171,7 +171,7 @@ fn test_verifiable_seed_to_key<G: Group, H: BlockSizeUser + Digest + FixedOutput
         );
         assert_eq!(
             &parameters.pksm,
-            G::to_arr(server.get_public_key()).as_slice()
+            G::serialize_elem(server.get_public_key()).as_slice()
         );
     }
     Ok(())
diff --git a/src/voprf.rs b/src/voprf.rs
@@ -481,7 +481,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> VerifiableServer<G,
     /// bytes to represent the server's private key
     pub fn new_with_key(key: &[u8]) -> Result<Self> {
         let sk = G::deserialize_scalar(key.into())?;
-        let pk = G::base_point() * &sk;
+        let pk = G::base_elem() * &sk;
         Ok(Self {
             sk,
             pk,
@@ -497,7 +497,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> VerifiableServer<G,
         let dst = GenericArray::from(STR_HASH_TO_SCALAR)
             .concat(get_context_string::<G>(Mode::Verifiable));
         let sk = G::hash_to_scalar::<H, _, _>(Some(seed), dst)?;
-        let pk = G::base_point() * &sk;
+        let pk = G::base_elem() * &sk;
         Ok(Self {
             sk,
             pk,
@@ -632,7 +632,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> VerifiableServer<G,
         &'b IE: IntoIterator<Item = &'b PreparedEvaluationElement<G, H>>,
         <&'b IE as IntoIterator>::IntoIter: ExactSizeIterator,
     {
-        let g = G::base_point();
+        let g = G::base_elem();
         let u = g * t;
 
         let proof = generate_proof(
@@ -901,7 +901,7 @@ where
         GenericArray::from(STR_HASH_TO_SCALAR).concat(get_context_string::<G>(Mode::Verifiable));
     let m = G::hash_to_scalar::<H, _, _>(context, dst)?;
 
-    let g = G::base_point();
+    let g = G::base_elem();
     let t = g * &m;
     let u = t + &pk;
 
@@ -945,11 +945,11 @@ fn generate_proof<
         GenericArray::from(STR_CHALLENGE).concat(get_context_string::<G>(Mode::Verifiable));
     chain!(
         h2_input,
-        Serialize::<U2, _>::from_owned(G::to_arr(b))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(m))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(z))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(t2))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(t3))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(b))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(m))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(z))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(t2))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(t3))?,
         Serialize::<U2, _>::from_owned(challenge_dst)?,
     );
 
@@ -982,11 +982,11 @@ fn verify_proof<G: Group, H: BlockSizeUser + Digest + FixedOutputReset>(
         GenericArray::from(STR_CHALLENGE).concat(get_context_string::<G>(Mode::Verifiable));
     chain!(
         h2_input,
-        Serialize::<U2, _>::from_owned(G::to_arr(b))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(m))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(z))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(t2))?,
-        Serialize::<U2, _>::from_owned(G::to_arr(t3))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(b))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(m))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(z))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(t2))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(t3))?,
         Serialize::<U2, _>::from_owned(challenge_dst)?,
     );
 
@@ -1027,7 +1027,7 @@ fn finalize_after_unblind<
                 hash_input,
                 Serialize::<U2>::from(input.as_ref())?,
                 Serialize::<U2>::from(info)?,
-                Serialize::<U2, _>::from_owned(G::to_arr(unblinded_element))?,
+                Serialize::<U2, _>::from_owned(G::serialize_elem(unblinded_element))?,
                 Serialize::<U2, _>::from_owned(finalize_dst)?,
             );
 
@@ -1053,22 +1053,22 @@ fn compute_composites<G: Group, H: BlockSizeUser + Digest + FixedOutputReset>(
 
     chain!(
         h1_input,
-        Serialize::<U2, _>::from_owned(G::to_arr(b))?,
+        Serialize::<U2, _>::from_owned(G::serialize_elem(b))?,
         Serialize::<U2, _>::from_owned(seed_dst)?,
     );
     let seed = h1_input
         .fold(H::new(), |h, bytes| h.chain_update(bytes))
         .finalize();
 
-    let mut m = G::identity();
-    let mut z = G::identity();
+    let mut m = G::identity_elem();
+    let mut z = G::identity_elem();
 
     for (i, (c, d)) in c_slice.zip(d_slice).enumerate() {
         chain!(h2_input,
             Serialize::<U2, _>::from_owned(seed.clone())?,
             i2osp::<U2>(i)? => |x| Some(x.as_slice()),
-            Serialize::<U2, _>::from_owned(G::to_arr(c.value))?,
-            Serialize::<U2, _>::from_owned(G::to_arr(d.value))?,
+            Serialize::<U2, _>::from_owned(G::serialize_elem(c.value))?,
+            Serialize::<U2, _>::from_owned(G::serialize_elem(d.value))?,
             Serialize::<U2, _>::from_owned(composite_dst)?,
         );
         let dst = GenericArray::from(STR_HASH_TO_SCALAR)

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ use once_cell::unsync::Lazy;`
`27`	`27`	`use p256_::elliptic_curve::group::prime::PrimeCurveAffine;`
`28`	`28`	`use p256_::elliptic_curve::ops::Reduce;`
`29`	`29`	`use p256_::elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint};`
	`30`	`+#[cfg(test)]`
`30`	`31`	`use p256_::elliptic_curve::Field;`
`31`	`32`	`use p256_::{AffinePoint, EncodedPoint, NistP256, ProjectivePoint, PublicKey, Scalar, SecretKey};`
`32`	`33`	`use rand_core::{CryptoRng, RngCore};`
`@@ -167,23 +168,24 @@ impl Group for NistP256 {`
`167`	`168`	`.map_err(\|_\| Error::PointError)`
`168`	`169`	`}`
`169`	`170`
`170`		`- fn to_arr(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {`
	`171`	`+ fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {`
`171`	`172`	`let bytes = elem.to_affine().to_encoded_point(true);`
`172`	`173`	`let bytes = bytes.as_bytes();`
`173`	`174`	`let mut result = GenericArray::default();`
`174`	`175`	`result[..bytes.len()].copy_from_slice(bytes);`
`175`	`176`	`result`
`176`	`177`	`}`
`177`	`178`
`178`		`- fn base_point() -> Self::Elem {`
	`179`	`+ fn base_elem() -> Self::Elem {`
`179`	`180`	`ProjectivePoint::generator()`
`180`	`181`	`}`
`181`	`182`
`182`		`- fn identity() -> Self::Elem {`
	`183`	`+ fn identity_elem() -> Self::Elem {`
`183`	`184`	`ProjectivePoint::identity()`
`184`	`185`	`}`
`185`	`186`
`186`		`- fn scalar_zero() -> Self::Scalar {`
	`187`	`+ #[cfg(test)]`
	`188`	`+ fn zero_scalar() -> Self::Scalar {`
`187`	`189`	`Scalar::zero()`
`188`	`190`	`}`
`189`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -116,19 +116,20 @@ impl Group for Ristretto255 {`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`// serialization of a group element`
`119`		`- fn to_arr(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {`
	`119`	`+ fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen> {`
`120`	`120`	`elem.compress().to_bytes().into()`
`121`	`121`	`}`
`122`	`122`
`123`		`- fn base_point() -> Self::Elem {`
	`123`	`+ fn base_elem() -> Self::Elem {`
`124`	`124`	`RISTRETTO_BASEPOINT_POINT`
`125`	`125`	`}`
`126`	`126`
`127`		`- fn identity() -> Self::Elem {`
	`127`	`+ fn identity_elem() -> Self::Elem {`
`128`	`128`	`RistrettoPoint::identity()`
`129`	`129`	`}`
`130`	`130`
`131`		`- fn scalar_zero() -> Self::Scalar {`
	`131`	`+ #[cfg(test)]`
	`132`	`+ fn zero_scalar() -> Self::Scalar {`
`132`	`133`	`Scalar::zero()`
`133`	`134`	`}`
`134`	`135`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> VerifiableClient<G,`
`53`	`53`	`G::ScalarLen: Add<G::ElemLen>,`
`54`	`54`	`Sum<G::ScalarLen, G::ElemLen>: ArrayLength<u8>,`
`55`	`55`	`{`
`56`		`- G::serialize_scalar(self.blind).concat(G::to_arr(self.blinded_element))`
	`56`	`+ G::serialize_scalar(self.blind).concat(G::serialize_elem(self.blinded_element))`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`/// Deserialization from bytes`
`@@ -97,7 +97,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> VerifiableServer<G,`
`97`	`97`	`G::ScalarLen: Add<G::ElemLen>,`
`98`	`98`	`Sum<G::ScalarLen, G::ElemLen>: ArrayLength<u8>,`
`99`	`99`	`{`
`100`		`- G::serialize_scalar(self.sk).concat(G::to_arr(self.pk))`
	`100`	`+ G::serialize_scalar(self.sk).concat(G::serialize_elem(self.pk))`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`/// Deserialization from bytes`
`@@ -143,7 +143,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> Proof<G, H> {`
`143`	`143`	`impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> BlindedElement<G, H> {`
`144`	`144`	`/// Serialization into bytes`
`145`	`145`	`pub fn serialize(&self) -> GenericArray<u8, G::ElemLen> {`
`146`		`- G::to_arr(self.value)`
	`146`	`+ G::serialize_elem(self.value)`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`/// Deserialization from bytes`
`@@ -162,7 +162,7 @@ impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> BlindedElement<G, H`
`162`	`162`	`impl<G: Group, H: BlockSizeUser + Digest + FixedOutputReset> EvaluationElement<G, H> {`
`163`	`163`	`/// Serialization into bytes`
`164`	`164`	`pub fn serialize(&self) -> GenericArray<u8, G::ElemLen> {`
`165`		`- G::to_arr(self.value)`
	`165`	`+ G::serialize_elem(self.value)`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`/// Deserialization from bytes`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ fn test_verifiable_seed_to_key<G: Group, H: BlockSizeUser + Digest + FixedOutput`
`171`	`171`	`);`
`172`	`172`	`assert_eq!(`
`173`	`173`	`&parameters.pksm,`
`174`		`- G::to_arr(server.get_public_key()).as_slice()`
	`174`	`+ G::serialize_elem(server.get_public_key()).as_slice()`
`175`	`175`	`);`
`176`	`176`	`}`
`177`	`177`	`Ok(())`