General improvements (#34)

* Minor improvements

* Fix `Debug` implementation

* Fix de-serialization

* Fix accidental usage of nightly

* Fix MSRV warning

* Replace macro with derive-where

* Add `rust-version` into `Cargo.toml`

* Move Serde trait implementation macro to `serialization` module

* Add ability to test without a Ristretto backend

* Improve docs

* Fix testing multiple backends together

* Implement `Ord` and `PartialOrd`

* `no_std` by default

* Remove unnecessary `doc_cfg`

* Remove dev-dependency on self

* Implement `Ord` and `PartialOrd` for `InternalError`

* Remove base64 encoding for serde

* Only take references

* Remove unnecessary qualifications from super-trait times

src/group/expand.rs

@@ -40,13 +40,13 @@ pub fn expand_message_xmd<
 where
     <D as Add<U1>>::Output: ArrayLength<u8>,
 {
-    let digest_len = <H as Digest>::OutputSize::USIZE;
+    let digest_len = H::OutputSize::USIZE;
     let ell = div_ceil(L::USIZE, digest_len);
     if ell > 255 {
         return Err(InternalError::HashToCurveError);
     }
     let dst_prime = dst.concat(i2osp::<U1>(D::USIZE)?);
-    let z_pad = i2osp::<<H as BlockInput>::BlockSize>(0)?;
+    let z_pad = i2osp::<H::BlockSize>(0)?;
     let l_i_b_str = i2osp::<U2>(L::USIZE)?;
 
     let mut h = H::new();

src/group/mod.rs

@@ -18,14 +18,9 @@
 mod expand;
 #[cfg(feature = "p256")]
 mod p256;
-#[cfg(any(
-    feature = "ristretto255_u64",
-    feature = "ristretto255_u32",
-    feature = "ristretto255_fiat_u64",
-    feature = "ristretto255_fiat_u32",
-    feature = "ristretto255_simd",
-))]
-mod ristretto;
+cfg_ristretto! {
+    mod ristretto;
+}
 
 use crate::errors::InternalError;
 use core::ops::{Add, Mul, Sub};

src/group/ristretto.rs

@@ -22,113 +22,110 @@ use generic_array::{
 };
 use rand_core::{CryptoRng, RngCore};
 
-/// The implementation of such a subgroup for Ristretto
-#[cfg(any(
-    feature = "ristretto255_u64",
-    feature = "ristretto255_u32",
-    feature = "ristretto255_fiat_u64",
-    feature = "ristretto255_fiat_u32",
-    feature = "ristretto255_simd",
-))]
-impl Group for RistrettoPoint {
-    const SUITE_ID: usize = 0x0001;
+// `cfg` here is only needed because of a bug in Rust's crate feature documentation.
+// See: https://github.com/rust-lang/rust/issues/83428
+cfg_ristretto! {
+    /// The implementation of such a subgroup for Ristretto
+    impl Group for RistrettoPoint {
+        const SUITE_ID: usize = 0x0001;
 
-    // Implements the `hash_to_ristretto255()` function from
-    // https://www.ietf.org/archive/id/draft-irtf-cfrg-hash-to-curve-10.txt
-    fn hash_to_curve<H: BlockInput + Digest, D: ArrayLength<u8> + Add<U1>>(
-        msg: &[u8],
-        dst: GenericArray<u8, D>,
-    ) -> Result<Self, InternalError>
-    where
-        <D as Add<U1>>::Output: ArrayLength<u8>,
-    {
-        let uniform_bytes = super::expand::expand_message_xmd::<H, U64, _, _>(Some(msg), dst)?;
+        // Implements the `hash_to_ristretto255()` function from
+        // https://www.ietf.org/archive/id/draft-irtf-cfrg-hash-to-curve-10.txt
+        fn hash_to_curve<H: BlockInput + Digest, D: ArrayLength<u8> + Add<U1>>(
+            msg: &[u8],
+            dst: GenericArray<u8, D>,
+        ) -> Result<Self, InternalError>
+        where
+            <D as Add<U1>>::Output: ArrayLength<u8>,
+        {
+            let uniform_bytes = super::expand::expand_message_xmd::<H, U64, _, _>(Some(msg), dst)?;
 
-        Ok(RistrettoPoint::from_uniform_bytes(
-            uniform_bytes
-                .as_slice()
-                .try_into()
-                .map_err(|_| InternalError::HashToCurveError)?,
-        ))
-    }
+            Ok(RistrettoPoint::from_uniform_bytes(
+                uniform_bytes
+                    .as_slice()
+                    .try_into()
+                    .map_err(|_| InternalError::HashToCurveError)?,
+            ))
+        }
 
-    // Implements the `HashToScalar()` function from
-    // https://www.ietf.org/archive/id/draft-irtf-cfrg-voprf-07.html#section-4.1
-    fn hash_to_scalar<
-        'a,
-        H: BlockInput + Digest,
-        D: ArrayLength<u8> + Add<U1>,
-        I: IntoIterator<Item = &'a [u8]>,
-    >(
-        input: I,
-        dst: GenericArray<u8, D>,
-    ) -> Result<Self::Scalar, InternalError>
-    where
-        <D as Add<U1>>::Output: ArrayLength<u8>,
-    {
-        let uniform_bytes = super::expand::expand_message_xmd::<H, U64, _, _>(input, dst)?;
+        // Implements the `HashToScalar()` function from
+        // https://www.ietf.org/archive/id/draft-irtf-cfrg-voprf-07.html#section-4.1
+        fn hash_to_scalar<
+            'a,
+            H: BlockInput + Digest,
+            D: ArrayLength<u8> + Add<U1>,
+            I: IntoIterator<Item = &'a [u8]>,
+        >(
+            input: I,
+            dst: GenericArray<u8, D>,
+        ) -> Result<Self::Scalar, InternalError>
+        where
+            <D as Add<U1>>::Output: ArrayLength<u8>,
+        {
+            let uniform_bytes = super::expand::expand_message_xmd::<H, U64, _, _>(input, dst)?;
 
-        Ok(Scalar::from_bytes_mod_order_wide(
-            uniform_bytes
-                .as_slice()
-                .try_into()
-                .map_err(|_| InternalError::HashToCurveError)?,
-        ))
-    }
+            Ok(Scalar::from_bytes_mod_order_wide(
+                uniform_bytes
+                    .as_slice()
+                    .try_into()
+                    .map_err(|_| InternalError::HashToCurveError)?,
+            ))
+        }
 
-    type Scalar = Scalar;
-    type ScalarLen = U32;
-    fn from_scalar_slice_unchecked(
-        scalar_bits: &GenericArray<u8, Self::ScalarLen>,
-    ) -> Result<Self::Scalar, InternalError> {
-        Ok(Scalar::from_bytes_mod_order(*scalar_bits.as_ref()))
-    }
+        type Scalar = Scalar;
+        type ScalarLen = U32;
+        fn from_scalar_slice_unchecked(
+            scalar_bits: &GenericArray<u8, Self::ScalarLen>,
+        ) -> Result<Self::Scalar, InternalError> {
+            Ok(Scalar::from_bytes_mod_order(*scalar_bits.as_ref()))
+        }
 
-    fn random_nonzero_scalar<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Scalar {
-        loop {
-            let scalar = {
-                let mut scalar_bytes = [0u8; 64];
-                rng.fill_bytes(&mut scalar_bytes);
-                Scalar::from_bytes_mod_order_wide(&scalar_bytes)
-            };
+        fn random_nonzero_scalar<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Scalar {
+            loop {
+                let scalar = {
+                    let mut scalar_bytes = [0u8; 64];
+                    rng.fill_bytes(&mut scalar_bytes);
+                    Scalar::from_bytes_mod_order_wide(&scalar_bytes)
+                };
 
-            if scalar != Scalar::zero() {
-                break scalar;
+                if scalar != Scalar::zero() {
+                    break scalar;
+                }
             }
         }
-    }
 
-    fn scalar_as_bytes(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen> {
-        scalar.to_bytes().into()
-    }
+        fn scalar_as_bytes(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen> {
+            scalar.to_bytes().into()
+        }
 
-    fn scalar_invert(scalar: &Self::Scalar) -> Self::Scalar {
-        scalar.invert()
-    }
+        fn scalar_invert(scalar: &Self::Scalar) -> Self::Scalar {
+            scalar.invert()
+        }
 
-    // The byte length necessary to represent group elements
-    type ElemLen = U32;
-    fn from_element_slice_unchecked(
-        element_bits: &GenericArray<u8, Self::ElemLen>,
-    ) -> Result<Self, InternalError> {
-        CompressedRistretto::from_slice(element_bits)
-            .decompress()
-            .ok_or(InternalError::PointError)
-    }
-    // serialization of a group element
-    fn to_arr(&self) -> GenericArray<u8, Self::ElemLen> {
-        self.compress().to_bytes().into()
-    }
+        // The byte length necessary to represent group elements
+        type ElemLen = U32;
+        fn from_element_slice_unchecked(
+            element_bits: &GenericArray<u8, Self::ElemLen>,
+        ) -> Result<Self, InternalError> {
+            CompressedRistretto::from_slice(element_bits)
+                .decompress()
+                .ok_or(InternalError::PointError)
+        }
+        // serialization of a group element
+        fn to_arr(&self) -> GenericArray<u8, Self::ElemLen> {
+            self.compress().to_bytes().into()
+        }
 
-    fn base_point() -> Self {
-        RISTRETTO_BASEPOINT_POINT
-    }
+        fn base_point() -> Self {
+            RISTRETTO_BASEPOINT_POINT
+        }
 
-    fn identity() -> Self {
-        <Self as Identity>::identity()
-    }
+        fn identity() -> Self {
+            <Self as Identity>::identity()
+        }
 
-    fn scalar_zero() -> Self::Scalar {
-        Self::Scalar::zero()
+        fn scalar_zero() -> Self::Scalar {
+            Self::Scalar::zero()
+        }
     }
 }

src/group/tests.rs

@@ -15,10 +15,12 @@ use crate::group::Group;
 
 #[test]
 fn test_group_properties() -> Result<(), InternalError> {
-    use curve25519_dalek::ristretto::RistrettoPoint;
+    cfg_ristretto! { {
+        use curve25519_dalek::ristretto::RistrettoPoint;
 
-    test_identity_element_error::<RistrettoPoint>()?;
-    test_zero_scalar_error::<RistrettoPoint>()?;
+        test_identity_element_error::<RistrettoPoint>()?;
+        test_zero_scalar_error::<RistrettoPoint>()?;
+    } }
 
     #[cfg(feature = "p256")]
     {