fix(iroh-bytes): Hash should be serialized as array not bytes (#1410)

Author: dignifiedquire

Cargo.lock

@@ -43,6 +43,7 @@ tracing-futures = "0.2.5"
 http-body = "0.4.5"
 iroh-test = { path = "../iroh-test" }
 proptest = "1.0.0"
+serde_test = "1.0.176"
 tokio = { version = "1", features = ["macros", "test-util"] }
 
 [features]

iroh-bytes/Cargo.toml

@@ -2,7 +2,11 @@
 use anyhow::Result;
 use bao_tree::blake3;
 use postcard::experimental::max_size::MaxSize;
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{
+    de::{self, SeqAccess},
+    ser::SerializeTuple,
+    Deserialize, Deserializer, Serialize, Serializer,
+};
 use std::{fmt, result, str::FromStr};
 use thiserror::Error;
 pub mod io;
@@ -156,7 +160,13 @@ impl Serialize for Hash {
     where
         S: Serializer,
     {
-        serializer.serialize_bytes(self.0.as_bytes())
+        // Fixed-length structures, including arrays, are supported in Serde as tuples
+        // See: https://serde.rs/impl-serialize.html#serializing-a-tuple
+        let mut s = serializer.serialize_tuple(32)?;
+        for item in self.0.as_bytes() {
+            s.serialize_element(item)?;
+        }
+        s.end()
     }
 }
 
@@ -165,7 +175,7 @@ impl<'de> Deserialize<'de> for Hash {
     where
         D: Deserializer<'de>,
     {
-        deserializer.deserialize_bytes(HashVisitor)
+        deserializer.deserialize_tuple(32, HashVisitor)
     }
 }
 
@@ -178,12 +188,22 @@ impl<'de> de::Visitor<'de> for HashVisitor {
         write!(f, "an array of 32 bytes containing hash data")
     }
 
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+    /// Process a sequence into an array
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
     where
-        E: de::Error,
+        A: SeqAccess<'de>,
     {
-        let bytes: [u8; 32] = v.try_into().map_err(E::custom)?;
-        Ok(Hash::from(bytes))
+        let mut arr = [0u8; 32];
+        let mut i = 0;
+        while let Some(val) = seq.next_element()? {
+            arr[i] = val;
+            i += 1;
+            if i > 32 {
+                return Err(de::Error::invalid_length(i, &self));
+            }
+        }
+
+        Ok(Hash::from(arr))
     }
 }
 
@@ -244,6 +264,8 @@ impl NonSend {
 mod tests {
     use super::*;
 
+    use serde_test::{assert_tokens, Token};
+
     #[test]
     fn test_hash() {
         let data = b"hello world";
@@ -252,4 +274,30 @@ mod tests {
         let encoded = hash.to_string();
         assert_eq!(encoded.parse::<Hash>().unwrap(), hash);
     }
+
+    #[test]
+    fn test_hash_serde() {
+        let hash = Hash::new("hello");
+
+        // Hashes are serialized as 32 tuples
+        let mut tokens = Vec::new();
+        tokens.push(Token::Tuple { len: 32 });
+        for byte in hash.as_bytes() {
+            tokens.push(Token::U8(*byte));
+        }
+        tokens.push(Token::TupleEnd);
+        assert_eq!(tokens.len(), 34);
+
+        assert_tokens(&hash, &tokens);
+    }
+
+    #[test]
+    fn test_hash_postcard() {
+        let hash = Hash::new("hello");
+        let ser = postcard::to_stdvec(&hash).unwrap();
+        let de = postcard::from_bytes(&ser).unwrap();
+        assert_eq!(hash, de);
+
+        assert_eq!(ser.len(), 32);
+    }
 }