Adds the ContextDataHandle interface type.

Signed-off-by: Jesper Brynolf <[email protected]>

Author: Superhepper

tss-esapi/src/interface_types/data_handles.rs

@@ -1,10 +1,17 @@
-// Copyright 2020 Contributors to the Parsec project.
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::handles::{NvIndexTpmHandle, PcrTpmHandle, PersistentTpmHandle, TransientTpmHandle};
-
-/// Can be created with either a persistent
-/// or transient TPM handle.
+/// This module contains native representations of the TPMI_DH types.
+use crate::{
+    handles::{
+        HmacSessionTpmHandle, NvIndexTpmHandle, PcrTpmHandle, PersistentTpmHandle,
+        PolicySessionTpmHandle, TpmHandle, TransientTpmHandle,
+    },
+    tss2_esys::TPMI_DH_CONTEXT,
+    Error, Result, WrapperErrorKind,
+};
+use std::convert::TryFrom;
+/// Enum representing the 'Object' data handles interface type.
+///
+/// # Details
+/// This corresponds to the TPMI_DH_OBJECT interface type.
 #[derive(Debug, Copy, Clone)]
 pub enum Object {
     Transient(TransientTpmHandle),
@@ -53,10 +60,52 @@ pub enum Entity {
     Platform,
     Endorsement,
     Lockout,
-    // TODO: Handle Auth
+    // TODO: Handle Auth, that is vendor specific.
 }
 
 #[derive(Debug, Copy, Clone)]
 pub enum Pcr {
     Pcr(PcrTpmHandle),
 }
+
+/// Enum representing the 'Context' data handles interface type.
+///
+/// # Details
+/// This corresponds to the TPMI_DH_CONTEXT interface type.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum ContextDataHandle {
+    Hmac(HmacSessionTpmHandle),
+    Policy(PolicySessionTpmHandle),
+    Transient(TransientTpmHandle),
+}
+
+impl From<HmacSessionTpmHandle> for ContextDataHandle {
+    fn from(hmac_session_tpm_handle: HmacSessionTpmHandle) -> Self {
+        ContextDataHandle::Hmac(hmac_session_tpm_handle)
+    }
+}
+
+impl From<PolicySessionTpmHandle> for ContextDataHandle {
+    fn from(policy_session_tpm_handle: PolicySessionTpmHandle) -> Self {
+        ContextDataHandle::Policy(policy_session_tpm_handle)
+    }
+}
+
+impl From<TransientTpmHandle> for ContextDataHandle {
+    fn from(transient_tpm_handle: TransientTpmHandle) -> Self {
+        ContextDataHandle::Transient(transient_tpm_handle)
+    }
+}
+
+impl TryFrom<TPMI_DH_CONTEXT> for ContextDataHandle {
+    type Error = Error;
+
+    fn try_from(ffi: TPMI_DH_CONTEXT) -> Result<Self> {
+        TpmHandle::try_from(ffi).and_then(|tpm_handle| match tpm_handle {
+            TpmHandle::HmacSession(handle) => Ok(Self::Hmac(handle)),
+            TpmHandle::PolicySession(handle) => Ok(Self::Policy(handle)),
+            TpmHandle::Transient(handle) => Ok(Self::Transient(handle)),
+            _ => Err(Error::local_error(WrapperErrorKind::InvalidParam)),
+        })
+    }
+}

tss-esapi/tests/integration_tests/interface_types_tests/data_handles_tests.rs

@@ -0,0 +1,76 @@
+// Copyright 2023 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use std::convert::TryFrom;
+use tss_esapi::{
+    constants::tss::{
+        TPM2_HMAC_SESSION_LAST, TPM2_PERMANENT_LAST, TPM2_POLICY_SESSION_LAST, TPM2_TRANSIENT_LAST,
+    },
+    handles::{HmacSessionTpmHandle, PolicySessionTpmHandle, TransientTpmHandle},
+    interface_types::data_handles::ContextDataHandle,
+    Error, WrapperErrorKind,
+};
+
+macro_rules! context_data_handle_valid_conversions {
+    (ContextDataHandle::$enum_item:ident, $handle_type:ident, $tss:ident) => {
+        let context_data_handle = ContextDataHandle::try_from($tss).unwrap_or_else(|_| {
+            panic!(
+                "Converting {} into ContextDataHandle should not cause an error.",
+                std::stringify!($tss)
+            );
+        });
+        let expected_handle = $handle_type::try_from($tss).unwrap_or_else(|_| {
+            panic!(
+                "Converting {} into {} should not cause an error.",
+                std::stringify!($tss),
+                std::stringify!($handle_type)
+            );
+        });
+        if let ContextDataHandle::$enum_item(actual_handle) = context_data_handle {
+            assert_eq!(
+                expected_handle,
+                actual_handle,
+                "{} was converted into the expected handle.",
+                std::stringify!($tss)
+            );
+        } else {
+            panic!(
+                "{} should convert into a {}",
+                std::stringify!($tss),
+                std::stringify!(ContextDataHandle::$enum_item)
+            );
+        }
+        assert_eq!(
+            context_data_handle,
+            ContextDataHandle::from(expected_handle)
+        );
+    };
+}
+
+#[test]
+fn test_context_data_handle_valid_conversions() {
+    context_data_handle_valid_conversions!(
+        ContextDataHandle::Hmac,
+        HmacSessionTpmHandle,
+        TPM2_HMAC_SESSION_LAST
+    );
+    context_data_handle_valid_conversions!(
+        ContextDataHandle::Policy,
+        PolicySessionTpmHandle,
+        TPM2_POLICY_SESSION_LAST
+    );
+    context_data_handle_valid_conversions!(
+        ContextDataHandle::Transient,
+        TransientTpmHandle,
+        TPM2_TRANSIENT_LAST
+    );
+}
+
+#[test]
+fn test_context_data_handle_invalid_conversion() {
+    let result = ContextDataHandle::try_from(TPM2_PERMANENT_LAST);
+    if let Err(error) = result {
+        assert_eq!(Error::WrapperError(WrapperErrorKind::InvalidParam), error);
+    } else {
+        panic!("Converting an invalid value `TPM2_PERMANENT_LAST` into a ContextDataHandle should produce an error.");
+    }
+}

tss-esapi/tests/integration_tests/interface_types_tests/mod.rs

@@ -1,6 +1,7 @@
 // Copyright 2021 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
 mod algorithms_tests;
+mod data_handles_tests;
 mod key_bits_tests;
 mod reserved_handles_tests;
 mod structure_tags_tests;