implement different serializers

This commit reviews the serialization approach from the ground to allow using
different serializers and deserializers. For instance, this allows avoiding a
copy after calling `.serialize()`: in the previous version, `serialize()` was
always returning a `Zeroizing<Vec<u8>>`; in this new version, `serialize` takes
an additional type parameter specifying which `Serializer` to use and returns
`Serializer::Output`.

Two serializers are implemented:

- `SecretSerializer` which returns a `Zeroizing<Vec<u8>>`; calling
`.serialize<SecretSerializer>()` is therefore equivalent to the previous
`.serialze()` call.

- `PublicSerializer` which returns a `Vec<u8>` and is therefore appropriate to
for use in deserialization of values that do not need to be zeroized on drop.

Author: tbrezot

src/asymmetric_crypto/curves/curve_25519/curve_secret.rs

@@ -41,19 +41,17 @@ impl SecretCBytes<{ CURVE_25519_SECRET_LENGTH }> for Curve25519Secret {}
 /// Key Serialization framework
 #[cfg(feature = "ser")]
 impl Serializable for Curve25519Secret {
-    type Error = CryptoCoreError;
-
     fn length(&self) -> usize {
         Self::LENGTH
     }
 
-    fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
-        ser.write_array(self.as_bytes())
+    fn write<S: Serializer>(&self, ser: &mut S) -> Result<usize, S::Error> {
+        ser.write_bytes(self.as_bytes())
     }
 
-    fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
-        let bytes = de.read_array::<{ Self::LENGTH }>()?;
-        Self::try_from_bytes(bytes)
+    fn read<D: Deserializer>(de: &mut D) -> Result<Self, D::Error> {
+        let bytes = <[u8; Self::LENGTH]>::read(de)?;
+        Self::try_from_bytes(bytes).map_err(D::Error::from)
     }
 }
 

src/asymmetric_crypto/curves/curve_25519/ristretto_25519/curve_point.rs

@@ -51,18 +51,16 @@ impl From<&R25519PrivateKey> for R25519CurvePoint {
 
 #[cfg(feature = "ser")]
 impl Serializable for R25519CurvePoint {
-    type Error = CryptoCoreError;
-
     fn length(&self) -> usize {
         Self::LENGTH
     }
 
-    fn write(&self, ser: &mut crate::bytes_ser_de::Serializer) -> Result<usize, Self::Error> {
-        ser.write_array(&self.0.compress().to_bytes())
+    fn write<S: crate::bytes_ser_de::Serializer>(&self, ser: &mut S) -> Result<usize, S::Error> {
+        self.0.compress().to_bytes().write(ser)
     }
 
-    fn read(de: &mut crate::bytes_ser_de::Deserializer) -> Result<Self, Self::Error> {
-        Self::try_from_bytes(de.read_array::<{ Self::LENGTH }>()?)
+    fn read<D: crate::bytes_ser_de::Deserializer>(de: &mut D) -> Result<Self, D::Error> {
+        Self::try_from_bytes(<[u8; Self::LENGTH]>::read(de)?).map_err(D::Error::from)
     }
 }
 

src/asymmetric_crypto/curves/curve_25519/ristretto_25519/private_key.rs

@@ -51,19 +51,17 @@ impl SecretCBytes<{ R25519_PRIVATE_KEY_LENGTH }> for R25519PrivateKey {}
 /// Key Serialization framework
 #[cfg(feature = "ser")]
 impl Serializable for R25519PrivateKey {
-    type Error = CryptoCoreError;
-
     fn length(&self) -> usize {
         Self::LENGTH
     }
 
-    fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
-        ser.write_array(self.as_bytes())
+    fn write<S: Serializer>(&self, ser: &mut S) -> Result<usize, S::Error> {
+        ser.write_bytes(self.as_bytes())
     }
 
-    fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
-        let bytes = de.read_array::<{ Self::LENGTH }>()?;
-        Self::try_from_bytes(bytes)
+    fn read<D: Deserializer>(de: &mut D) -> Result<Self, D::Error> {
+        let bytes = <[u8; Self::LENGTH]>::read(de)?;
+        Self::try_from_bytes(bytes).map_err(D::Error::from)
     }
 }
 

src/asymmetric_crypto/curves/nist/private_key.rs

@@ -150,19 +150,17 @@ impl<C: Curve + CurveArithmetic, const LENGTH: usize> crate::PrivateKey
 /// Key Serialization framework
 #[cfg(all(feature = "ser", feature = "aes"))]
 impl<C: Curve + CurveArithmetic, const LENGTH: usize> Serializable for NistPrivateKey<C, LENGTH> {
-    type Error = CryptoCoreError;
-
     fn length(&self) -> usize {
         LENGTH
     }
 
-    fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
-        ser.write_array(self.as_bytes())
+    fn write<S: Serializer>(&self, ser: &mut S) -> Result<usize, S::Error> {
+        ser.write_bytes(self.as_bytes())
     }
 
-    fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
-        let bytes = de.read_array::<LENGTH>()?;
-        Self::try_from_bytes(bytes)
+    fn read<D: Deserializer>(de: &mut D) -> Result<Self, D::Error> {
+        let bytes = <[u8; LENGTH]>::read(de)?;
+        Self::try_from_bytes(bytes).map_err(D::Error::from)
     }
 }
 

src/asymmetric_crypto/curves/nist/public_key.rs

@@ -149,19 +149,17 @@ where
     <C as CurveArithmetic>::AffinePoint: sec1::ToEncodedPoint<C>,
     <C as CurveArithmetic>::AffinePoint: sec1::FromEncodedPoint<C>,
 {
-    type Error = CryptoCoreError;
-
     fn length(&self) -> usize {
         LENGTH
     }
 
-    fn write(&self, ser: &mut Serializer) -> Result<usize, Self::Error> {
-        ser.write_array(self.to_bytes().as_ref())
+    fn write<S: Serializer>(&self, ser: &mut S) -> Result<usize, S::Error> {
+        self.to_bytes().write(ser)
     }
 
-    fn read(de: &mut Deserializer) -> Result<Self, Self::Error> {
-        let bytes = de.read_array::<LENGTH>()?;
-        Self::try_from_bytes(bytes)
+    fn read<D: Deserializer>(de: &mut D) -> Result<Self, D::Error> {
+        let bytes = <[u8; LENGTH]>::read(de)?;
+        Self::try_from_bytes(bytes).map_err(D::Error::from)
     }
 }
 

src/bytes.rs

@@ -29,9 +29,7 @@ macro_rules! _define_byte_type {
 
             use std::ops::{Deref, DerefMut};
 
-            use $crate::{
-                bytes_ser_de::Serializable, reexport::rand_core::RngCore, CryptoCoreError, Sampling,
-            };
+            use $crate::{bytes_ser_de::Serializable, reexport::rand_core::RngCore, Sampling};
 
             impl<const LENGTH: usize> Deref for $name<LENGTH> {
                 type Target = [u8; LENGTH];
@@ -84,21 +82,21 @@ macro_rules! _define_byte_type {
             }
 
             impl<const LENGTH: usize> Serializable for $name<LENGTH> {
-                type Error = CryptoCoreError;
-
                 fn length(&self) -> usize {
                     LENGTH
                 }
 
-                fn write(
+                fn write<S: $crate::bytes_ser_de::Serializer>(
                     &self,
-                    ser: &mut $crate::bytes_ser_de::Serializer,
-                ) -> Result<usize, Self::Error> {
-                    ser.write_array(&self.0)
+                    ser: &mut S,
+                ) -> Result<usize, S::Error> {
+                    ser.write_bytes(&self.0)
                 }
 
-                fn read(de: &mut $crate::bytes_ser_de::Deserializer) -> Result<Self, Self::Error> {
-                    de.read_array::<LENGTH>().map(Self)
+                fn read<D: $crate::bytes_ser_de::Deserializer>(
+                    de: &mut D,
+                ) -> Result<Self, D::Error> {
+                    <[u8; LENGTH]>::read(de).map(Self)
                 }
             }
         }