Add unmarshall_offset to UnMarshall trait

Adding a second method to the UnMarshall trait - unmarshall_offset -
which takes a second parameter, a mutable offset, which is modified
during unmarshalling to point to the first position in the input buffer
that was not used for unmarshalling. The new method can be easily used
to implement the basic `unmarshall` method by passing `&mut 0` as the
offset.

Also adding `Marshall` and `UnMarshall` for `CommandCode` and `u32`.

Signed-off-by: Ionut Mihalcea <ionut.mihalcea@arm.com>

Author: ionut-arm

tss-esapi/src/constants/command_code.rs

@@ -2,11 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 mod structure;
 
-use crate::{tss2_esys::TPM2_CC, Error, Result, WrapperErrorKind};
+use crate::{
+    traits::{Marshall, UnMarshall},
+    tss2_esys::TPM2_CC,
+    Error, Result, ReturnCode, WrapperErrorKind,
+};
 use log::error;
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
-use std::convert::TryFrom;
+use std::convert::{TryFrom, TryInto};
 use structure::CommandCodeStructure;
 
 /// Enum representing the command code constants.
@@ -150,3 +154,70 @@ impl From<CommandCode> for TPM2_CC {
         command_code.to_u32().unwrap()
     }
 }
+
+impl Marshall for CommandCode {
+    const BUFFER_SIZE: usize = std::mem::size_of::<TPM2_CC>();
+
+    /// Produce a marshalled [TPM2_CC]
+    fn marshall(&self) -> Result<Vec<u8>> {
+        let mut buffer = vec![0; Self::BUFFER_SIZE];
+        let mut offset = 0;
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_TPM2_CC_Marshal(
+                    (*self).into(),
+                    buffer.as_mut_ptr(),
+                    Self::BUFFER_SIZE.try_into().map_err(|e| {
+                        error!("Failed to convert size of buffer to TSS size_t type: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    &mut offset,
+                )
+            },
+            |ret| {
+                error!("Failed to marshal CommandCode: {}", ret);
+            },
+        )?;
+
+        let checked_offset = usize::try_from(offset).map_err(|e| {
+            error!("Failed to parse offset as usize: {}", e);
+            Error::local_error(WrapperErrorKind::InvalidParam)
+        })?;
+
+        buffer.truncate(checked_offset);
+
+        Ok(buffer)
+    }
+}
+
+impl UnMarshall for CommandCode {
+    /// Unmarshall the structure from [`TPM2_CC`]
+    fn unmarshall(marshalled_data: &[u8]) -> Result<Self> {
+        CommandCode::unmarshall_offset(marshalled_data, &mut 0)
+    }
+
+    fn unmarshall_offset(
+        marshalled_data: &[u8],
+        offset: &mut std::os::raw::c_ulong,
+    ) -> Result<Self> {
+        let mut dest = TPM2_CC::default();
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_TPM2_CC_Unmarshal(
+                    marshalled_data.as_ptr(),
+                    marshalled_data.len().try_into().map_err(|e| {
+                        error!("Failed to convert length of marshalled data: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    offset,
+                    &mut dest,
+                )
+            },
+            |ret| error!("Failed to unmarshal SensitiveCreate: {}", ret),
+        )?;
+
+        CommandCode::try_from(dest)
+    }
+}

tss-esapi/src/traits.rs

@@ -1,6 +1,11 @@
+use std::convert::{TryFrom, TryInto};
+
+use log::error;
+use tss_esapi_sys::UINT32;
+
 // Copyright 2021 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
-use crate::Result;
+use crate::{Error, Result, ReturnCode, WrapperErrorKind};
 
 /// Trait for types that can be converted into
 /// TPM marshalled data.
@@ -15,4 +20,80 @@ pub trait Marshall: Sized {
 pub trait UnMarshall: Sized {
     /// Creates the type from marshalled data.
     fn unmarshall(marshalled_data: &[u8]) -> Result<Self>;
+
+    /// Creates the type from the marshalled data, and modifies
+    /// the `offset` to point to the first byte in the `marshalled_data`
+    /// buffer which was not used in the conversion.
+    fn unmarshall_offset(
+        _marshalled_data: &[u8],
+        _offset: &mut std::os::raw::c_ulong,
+    ) -> Result<Self> {
+        unimplemented!();
+    }
+}
+
+impl Marshall for u32 {
+    const BUFFER_SIZE: usize = std::mem::size_of::<UINT32>();
+
+    /// Produce a marshalled [UINT32]
+    fn marshall(&self) -> Result<Vec<u8>> {
+        let mut buffer = vec![0; Self::BUFFER_SIZE];
+        let mut offset = 0;
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_UINT32_Marshal(
+                    *self,
+                    buffer.as_mut_ptr(),
+                    Self::BUFFER_SIZE.try_into().map_err(|e| {
+                        error!("Failed to convert size of buffer to TSS size_t type: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    &mut offset,
+                )
+            },
+            |ret| {
+                error!("Failed to marshall u32: {}", ret);
+            },
+        )?;
+
+        let checked_offset = usize::try_from(offset).map_err(|e| {
+            error!("Failed to parse offset as usize: {}", e);
+            Error::local_error(WrapperErrorKind::InvalidParam)
+        })?;
+
+        buffer.truncate(checked_offset);
+
+        Ok(buffer)
+    }
+}
+
+impl UnMarshall for u32 {
+    fn unmarshall(marshalled_data: &[u8]) -> Result<Self> {
+        u32::unmarshall_offset(marshalled_data, &mut 0)
+    }
+
+    fn unmarshall_offset(
+        marshalled_data: &[u8],
+        offset: &mut std::os::raw::c_ulong,
+    ) -> Result<Self> {
+        let mut dest = 0_u32;
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_UINT32_Unmarshal(
+                    marshalled_data.as_ptr(),
+                    marshalled_data.len().try_into().map_err(|e| {
+                        error!("Failed to convert length of marshalled data: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    offset,
+                    &mut dest,
+                )
+            },
+            |ret| error!("Failed to unmarshal SensitiveCreate: {}", ret),
+        )?;
+
+        Ok(dest)
+    }
 }

tss-esapi/tests/integration_tests/common/marshall.rs

@@ -9,3 +9,22 @@ pub fn check_marshall_unmarshall<T: Marshall + UnMarshall + Eq + std::fmt::Debug
 
     assert_eq!(val, &unmarshalled);
 }
+
+pub fn check_marshall_unmarshall_offset<T: Marshall + UnMarshall + Eq + std::fmt::Debug>(val: &T) {
+    let mut buf = val.marshall().expect("Failed to marshall value");
+    let len = buf.len();
+    let mut offset = 0;
+
+    buf.append(&mut buf.clone());
+    buf.append(&mut vec![0xff; 256]);
+
+    let unmarshalled_one =
+        T::unmarshall_offset(&buf, &mut offset).expect("Failed to unmarshall first copy");
+    assert_eq!(offset, len as u64);
+    assert_eq!(val, &unmarshalled_one);
+
+    let unmarshalled_two =
+        T::unmarshall_offset(&buf, &mut offset).expect("Failed to unmarshall second copy");
+    assert_eq!(offset, (len * 2) as u64);
+    assert_eq!(val, &unmarshalled_two);
+}

tss-esapi/tests/integration_tests/constants_tests/command_code_tests.rs

@@ -218,3 +218,10 @@ fn test_invalid_conversions() {
         "A value representing a non existing command code did not produce the expected error"
     );
 }
+
+#[test]
+fn test_marshall_unmarshall() {
+    let cc = CommandCode::EvictControl;
+    crate::common::check_marshall_unmarshall(&cc);
+    crate::common::check_marshall_unmarshall_offset(&cc);
+}

tss-esapi/tests/integration_tests/main.rs

@@ -15,4 +15,5 @@ mod handles_tests;
 mod interface_types_tests;
 mod structures_tests;
 mod tcti_ldr_tests;
+mod traits;
 mod utils_tests;

tss-esapi/tests/integration_tests/traits.rs

@@ -0,0 +1,9 @@
+// Copyright 2023 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+
+#[test]
+fn test_u32_marshall_unmarshall() {
+    let val = 0xdeadbeef_u32;
+    crate::common::check_marshall_unmarshall(&val);
+    crate::common::check_marshall_unmarshall_offset(&val);
+}