serdect: safer bytes handling

serdect/Cargo.toml

@@ -26,6 +26,7 @@ bincode = "1"
 ciborium = "0.2"
 hex-literal = "0.4"
 proptest = "1"
+rmp-serde = "1"
 serde = { version = "1.0.119", default-features = false, features = ["derive"] }
 serde_json = "1"
 serde-json-core = { version = "0.5", default-features = false, features = ["std"] }

serdect/README.md

@@ -30,6 +30,15 @@ other kinds of data-dependent branching on the contents of the serialized data,
 using a constant-time hex serialization with human-readable formats should
 help reduce the overall timing variability.
 
+`serdect` is tested against the following crates:
+- [`bincode`](https://crates.io/crates/bincode) v1
+- [`ciborium`](https://crates.io/crates/ciborium) v0.2
+- [`rmp-serde`](https://crates.io/crates/rmp-serde) v1
+- [`serde-json-core`](https://crates.io/crates/serde-json-core) v0.5
+- [`serde-json`](https://crates.io/crates/serde-json) v1
+- [`toml`](https://crates.io/crates/toml) v0.7
+
+
 ## Minimum Supported Rust Version
 
 Rust **1.60** or newer.

serdect/src/array.rs

@@ -1,11 +1,20 @@
 //! Serialization primitives for arrays.
 
-use core::fmt;
+// Unfortunately, we currently cannot assert generically that we are serializing
+// a fixed-size byte array.
+// See https://github.com/serde-rs/serde/issues/2120 for the discussion.
+// Therefore we have to fall back to the slice methods,
+// which will add the size information in the binary formats.
+// The only difference is that for the arrays we require the size of the data
+// to be exactly equal to the size of the buffer during deserialization,
+// while for slices the buffer can be larger than the deserialized data.
+
+use core::marker::PhantomData;
 
-use serde::de::{Error, SeqAccess, Visitor};
-use serde::ser::SerializeTuple;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+use crate::slice;
+
 #[cfg(feature = "zeroize")]
 use zeroize::Zeroize;
 
@@ -16,17 +25,7 @@ where
     S: Serializer,
     T: AsRef<[u8]>,
 {
-    if serializer.is_human_readable() {
-        crate::serialize_hex::<_, _, false>(value, serializer)
-    } else {
-        let mut seq = serializer.serialize_tuple(value.as_ref().len())?;
-
-        for byte in value.as_ref() {
-            seq.serialize_element(byte)?;
-        }
-
-        seq.end()
-    }
+    slice::serialize_hex_lower_or_bin(value, serializer)
 }
 
 /// Serialize the given type as upper case hex when using human-readable
@@ -36,17 +35,7 @@ where
     S: Serializer,
     T: AsRef<[u8]>,
 {
-    if serializer.is_human_readable() {
-        crate::serialize_hex::<_, _, true>(value, serializer)
-    } else {
-        let mut seq = serializer.serialize_tuple(value.as_ref().len())?;
-
-        for byte in value.as_ref() {
-            seq.serialize_element(byte)?;
-        }
-
-        seq.end()
-    }
+    slice::serialize_hex_upper_or_bin(value, serializer)
 }
 
 /// Deserialize from hex when using human-readable formats or binary if the
@@ -57,56 +46,12 @@ where
     D: Deserializer<'de>,
 {
     if deserializer.is_human_readable() {
-        struct StrVisitor<'b>(&'b mut [u8]);
-
-        impl<'de> Visitor<'de> for StrVisitor<'_> {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                write!(formatter, "a string of length {}", self.0.len() * 2)
-            }
-
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                if v.len() != self.0.len() * 2 {
-                    return Err(Error::invalid_length(v.len(), &self));
-                }
-
-                base16ct::mixed::decode(v, self.0).map_err(E::custom)?;
-
-                Ok(())
-            }
-        }
-
-        deserializer.deserialize_str(StrVisitor(buffer))
+        deserializer.deserialize_str(slice::StrVisitor::<slice::ExactLength>(buffer, PhantomData))
     } else {
-        struct ArrayVisitor<'b>(&'b mut [u8]);
-
-        impl<'de> Visitor<'de> for ArrayVisitor<'_> {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                write!(formatter, "an array of length {}", self.0.len())
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                for (index, byte) in self.0.iter_mut().enumerate() {
-                    *byte = match seq.next_element()? {
-                        Some(byte) => byte,
-                        None => return Err(Error::invalid_length(index, &self)),
-                    };
-                }
-
-                Ok(())
-            }
-        }
-
-        deserializer.deserialize_tuple(buffer.len(), ArrayVisitor(buffer))
+        deserializer.deserialize_byte_buf(slice::SliceVisitor::<slice::ExactLength>(
+            buffer,
+            PhantomData,
+        ))
     }
 }
 

serdect/src/lib.rs

@@ -49,8 +49,17 @@
 //! let data = SecretData([42; 32]);
 //!
 //! let serialized = bincode::serialize(&data).unwrap();
-//! // bincode, a binary serialization format, is serialized into bytes.
-//! assert_eq!(serialized.as_slice(), [42; 32]);
+//! // bincode, a binary serialization format is serialized into bytes.
+//! assert_eq!(
+//!     serialized.as_slice(),
+//!     [
+//!         // Array size.
+//!         32, 0, 0, 0, 0, 0, 0, 0,
+//!         // Actual data.
+//!         42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+//!         42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+//!     ]
+//! );
 //! # let deserialized: SecretData = bincode::deserialize(&serialized).unwrap();
 //! # assert_eq!(deserialized, data);
 //!
@@ -98,7 +107,7 @@
 //! assert_eq!(
 //!     serialized.as_slice(),
 //!     [
-//!         // Not fixed-size, so a size will be encoded.
+//!         // Slice size.
 //!         32, 0, 0, 0, 0, 0, 0, 0,
 //!         // Actual data.
 //!         42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,