feat(rtc_types,binhelpers): add binhelpers module, supporting rkyv

Author: PiDelport

rtc_types/src/binhelpers.rs

@@ -0,0 +1,128 @@
+//! Binary data serialization helpers
+//!
+//! # Naming convention
+//!
+//! Functions in this module use the following naming convention:
+//!
+//! > `{format}_(write|read|view)_(array|slice)`
+//!
+//! 1. Format prefix, identifying the binary format (or library):
+//!
+//!    - [`rkyv`]
+//!
+//! 2. Operation:
+//!
+//!    - `write` to serialize a structure to bytes
+//!    - `read` to deserialize bytes to a new Rust structure (copying data)
+//!    - `view` to deserialize bytes to a structured view (sharing data)
+//!
+//! 3. Type suffix, for the binary data representation:
+//!
+//!    - `array` for working with constant-sized arrays (`[u8; ?]`)
+//!    - `slice` for working with variable-sized slices (`[u8]`)
+
+use core::mem::size_of;
+
+use rkyv::{
+    archived_root,
+    ser::{
+        serializers::{BufferSerializer, BufferSerializerError},
+        Serializer,
+    },
+    Aligned, Archive, Deserialize, Infallible, Serialize, Unreachable,
+};
+
+pub fn rkyv_write_array<T>(
+    value: &T,
+) -> Result<[u8; size_of::<T::Archived>()], BufferSerializerError>
+where
+    T: Serialize<BufferSerializer<Aligned<[u8; size_of::<T::Archived>()]>>>,
+{
+    let mut serializer = BufferSerializer::new(Aligned([0u8; size_of::<T::Archived>()]));
+    serializer.serialize_value(value)?;
+    let buf = serializer.into_inner();
+    Ok(buf.0)
+}
+
+/// # Safety
+///
+/// This does not perform input validation, and may have undefined behaviour for untrusted input.
+///
+/// See safety of [`archived_root`]:
+///
+/// > The caller must guarantee that the byte slice represents an archived object and that the root
+/// > object is stored at the end of the byte slice.
+///
+/// TODO: Use `check_archived_root` once it's stable without `std` (rkyv 0.7.0?).
+///       See issue: [no_std validation #107](https://github.com/djkoloski/rkyv/issues/107)
+pub unsafe fn rkyv_view_array<T>(bytes: &[u8; size_of::<T::Archived>()]) -> &T::Archived
+where
+    T: Archive,
+{
+    archived_root::<T>(bytes)
+}
+
+/// # Safety
+///
+/// See safety of [`rkyv_view_array`].
+pub unsafe fn rkyv_read_array<T>(bytes: &[u8; size_of::<T::Archived>()]) -> T
+where
+    T: Archive,
+    T::Archived: Deserialize<T, Infallible>,
+{
+    let archived = rkyv_view_array::<T>(bytes);
+    let result: Result<T, Unreachable> = archived.deserialize(&mut Infallible);
+    // Safety: this should not allocate, so it should not fail.
+    result.expect("rkyv_read_array: unexpected deserialize failure!")
+}
+
+#[cfg(test)]
+mod tests {
+    use core::mem::{size_of, size_of_val};
+
+    use rkyv::{Archive, Deserialize, Serialize};
+
+    use super::*;
+
+    use proptest::prelude::*;
+    use proptest_derive::Arbitrary;
+
+    /// Arbitrary structure to test with.
+    #[derive(
+        Debug,
+        PartialEq,
+        // rkyv:
+        Archive,
+        Deserialize,
+        Serialize,
+        // proptest:
+        Arbitrary,
+    )]
+    struct Foo {
+        byte: u8,
+        int: u32,
+        opt: Option<i32>,
+        ary: [u8; 16],
+    }
+
+    const ARCHIVED_FOO_SIZE: usize = size_of::<ArchivedFoo>();
+
+    /// [`rkyv_write_array`] roundtrips with [`rkyv_view_array`] and [`rkyv_read_array`].
+    #[test]
+    fn prop_rkyv_array_roundtrip() {
+        let test = |value: &Foo| {
+            let bytes = &rkyv_write_array(value).unwrap();
+            assert_eq!(size_of_val(bytes), ARCHIVED_FOO_SIZE);
+
+            let view = unsafe { rkyv_view_array::<Foo>(bytes) };
+            assert_eq!(value.byte, view.byte);
+            assert_eq!(value.int, view.int);
+            assert_eq!(value.opt, view.opt);
+            assert_eq!(value.ary, view.ary);
+
+            let read = &unsafe { rkyv_read_array(bytes) };
+            assert_eq!(value, read);
+        };
+        proptest!(|(value: Foo)| test(&value));
+    }
+}

rtc_types/src/lib.rs

@@ -1,3 +1,7 @@
+// Used by: rtc_types::binhelpers
+#![allow(incomplete_features)]
+#![feature(const_generics)]
+#![feature(const_evaluatable_checked)]
 // TODO: Document
 #![cfg_attr(feature = "teaclave_sgx", no_std)]
 #[cfg(feature = "teaclave_sgx")]
@@ -25,6 +29,8 @@ pub use exec_token::*;
 mod ecall_result;
 pub use ecall_result::*;
 
+pub mod binhelpers;
+
 #[repr(C)]
 #[derive(Clone, Debug)]
 pub struct EncryptedMessage {