tls_codec: optimize serde serialized size using serde_bytes (#2022)

Author: kkohbrok

tls_codec/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+- [#2022](https://github.com/RustCrypto/formats/pull/2022) Optimize serde serialization of byte vectors using `serde_bytes`. Deserialization of the old serialized format will still work, but newly serialized instances of `VLBytes` will have the new format.
+
 ## 0.4.2
 
 - [#1628](https://github.com/RustCrypto/formats/pull/1628) Bump MSRV to 1.74

tls_codec/Cargo.toml

@@ -21,15 +21,17 @@ zeroize = { version = "1.8", default-features = false, features = [
 arbitrary = { version = "1.4", features = ["derive"], optional = true }
 tls_codec_derive = { version = "=0.4.2", path = "./derive", optional = true }
 serde = { version = "1.0.184", features = ["derive"], optional = true }
+serde_bytes = { version = "0.11.17", optional = true }
 
 [dev-dependencies]
 criterion = { version = "0.6", default-features = false }
+ciborium = "0.2.2"
 
 [features]
 default = ["std"]
 arbitrary = ["std", "dep:arbitrary"]
 derive = ["tls_codec_derive"]
-serde = ["std", "dep:serde"]
+serde = ["std", "dep:serde", "dep:serde_bytes"]
 mls = [] # In MLS variable length vectors are limited compared to QUIC.
 std = ["tls_codec_derive?/std"]
 conditional_deserialization = [

tls_codec/src/quic_vec.rs

@@ -298,6 +298,11 @@ macro_rules! impl_vl_bytes_generic {
 #[cfg_attr(feature = "std", derive(Zeroize))]
 #[derive(Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct VLBytes {
+    #[cfg_attr(feature = "serde", serde(serialize_with = "serde_bytes::serialize"))]
+    #[cfg_attr(
+        feature = "serde",
+        serde(deserialize_with = "serde_impl::de_vec_bytes_compat")
+    )]
     vec: Vec<u8>,
 }
 
@@ -385,6 +390,56 @@ impl Size for &VLBytes {
     }
 }
 
+#[cfg(feature = "serde")]
+mod serde_impl {
+    use std::{fmt, vec::Vec};
+
+    use serde::{Deserializer, de};
+
+    pub(super) fn de_vec_bytes_compat<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct BytesOrSeq;
+
+        impl<'de> de::Visitor<'de> for BytesOrSeq {
+            type Value = Vec<u8>;
+
+            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("either a byte blob or a sequence of u8")
+            }
+
+            // New format (native bytes; e.g., CBOR/Bincode/Msgpack)
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(v.to_vec())
+            }
+
+            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(v)
+            }
+
+            // Old format (seq of u8)
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::SeqAccess<'de>,
+            {
+                let mut out = Vec::new();
+                while let Some(b) = seq.next_element::<u8>()? {
+                    out.push(b);
+                }
+                Ok(out)
+            }
+        }
+
+        deserializer.deserialize_any(BytesOrSeq)
+    }
+}
 pub struct VLByteSlice<'a>(pub &'a [u8]);
 
 impl fmt::Debug for VLByteSlice<'_> {

tls_codec/tests/serde_impls.rs

@@ -0,0 +1,35 @@
+#![cfg(feature = "serde")]
+
+use tls_codec::VLBytes;
+
+// Old VLBytes without serde bytes serialization
+#[derive(serde::Serialize, serde::Deserialize)]
+struct OldVLBytes {
+    vec: Vec<u8>,
+}
+
+impl From<VLBytes> for OldVLBytes {
+    fn from(v: VLBytes) -> Self {
+        OldVLBytes { vec: v.into() }
+    }
+}
+
+#[test]
+fn serde_impls() {
+    let value = VLBytes::from(vec![32; 128]);
+    let old_value: OldVLBytes = value.clone().into();
+    let mut new_serialized = Vec::new();
+    ciborium::into_writer(&value, &mut new_serialized).unwrap();
+    let mut old_serialized = Vec::new();
+    ciborium::into_writer(&old_value, &mut old_serialized).unwrap();
+
+    // Serialization format has changed
+    assert_ne!(new_serialized, old_serialized);
+    assert!(new_serialized.len() < old_serialized.len());
+
+    // We should be able to deserialize both into the new format
+    let deserialized: VLBytes = ciborium::from_reader(new_serialized.as_slice()).unwrap();
+    let old_deserialized: VLBytes = ciborium::from_reader(old_serialized.as_slice()).unwrap();
+
+    assert_eq!(deserialized, old_deserialized);
+}