digest: implement SerializableState for CoreWrapper

digest/src/core_api/wrapper.rs

@@ -5,11 +5,12 @@ use super::{
 use crate::{
     ExtendableOutput, ExtendableOutputReset, FixedOutput, FixedOutputReset, HashMarker, Update,
 };
-use block_buffer::BlockBuffer;
-use core::fmt;
+use block_buffer::{generic_array::ArrayLength, BlockBuffer};
+use core::{fmt, mem::size_of_val, ops::Add};
 use crypto_common::{
-    typenum::{IsLess, Le, NonZero, U256},
-    BlockSizeUser, InvalidLength, Key, KeyInit, KeySizeUser, Output,
+    typenum::{Add1, IsLess, Le, NonZero, Sum, Unsigned, B1, U256},
+    BlockSizeUser, DeserializeStateError, InvalidLength, Key, KeyInit, KeySizeUser, Output,
+    SerializableState, SerializedState,
 };
 
 #[cfg(feature = "mac")]
@@ -227,6 +228,59 @@ where
     }
 }
 
+impl<T> SerializableState for CoreWrapper<T>
+where
+    T: BufferKindUser,
+    T::BlockSize: IsLess<U256>,
+    Le<T::BlockSize, U256>: NonZero,
+    T: SerializableState,
+    T::SerializedStateSize: Add<B1>,
+    <T::SerializedStateSize as Add<B1>>::Output: Add<T::BlockSize>,
+    <<T::SerializedStateSize as Add<B1>>::Output as Add<T::BlockSize>>::Output: ArrayLength<u8>,
+{
+    type SerializedStateSize = Sum<Add1<T::SerializedStateSize>, T::BlockSize>;
+
+    fn serialize(&self) -> SerializedState<Self> {
+        let mut serialized_state = SerializedState::<Self>::default();
+        let serialization_buffer = serialized_state.as_mut_slice();
+
+        let serialized_core = self.core.serialize();
+        let (buffer, serialization_buffer) =
+            serialization_buffer.split_at_mut(serialized_core.len());
+        buffer.copy_from_slice(serialized_core.as_slice());
+
+        let pos = self.buffer.get_pos() as u8;
+        let (buffer, serialization_buffer) = serialization_buffer.split_at_mut(size_of_val(&pos));
+        buffer[0] = pos;
+
+        let data = self.buffer.get_data();
+        let (buffer, _) = serialization_buffer.split_at_mut(data.len());
+        buffer.copy_from_slice(data);
+
+        serialized_state
+    }
+
+    fn deserialize(
+        serialized_state: &SerializedState<Self>,
+    ) -> Result<Self, DeserializeStateError> {
+        let serialization_buffer = serialized_state.as_slice();
+
+        let (buffer, serialization_buffer) =
+            serialization_buffer.split_at(T::SerializedStateSize::USIZE);
+        let serialized_core = SerializedState::<T>::from_slice(buffer);
+
+        let (buffer, serialization_buffer) = serialization_buffer.split_at(1);
+        let pos = buffer[0] as usize;
+
+        let (block_buffer, _) = serialization_buffer.split_at(pos);
+
+        Ok(Self {
+            core: T::deserialize(serialized_core)?,
+            buffer: BlockBuffer::new(block_buffer),
+        })
+    }
+}
+
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl<T> std::io::Write for CoreWrapper<T>