Skip to main content

tss_esapi/structures/algorithm/symmetric/
sensitive_create.rs

1// Copyright 2022 Contributors to the Parsec project.
2// SPDX-License-Identifier: Apache-2.0
3use crate::{
4    structures::{Auth, SensitiveData},
5    traits::{impl_mu_standard, Marshall},
6    tss2_esys::{TPM2B_SENSITIVE_CREATE, TPMS_SENSITIVE_CREATE},
7    Error, Result, ReturnCode, WrapperErrorKind,
8};
9use log::error;
10use std::convert::{TryFrom, TryInto};
11use zeroize::Zeroize;
12
13/// Structure that defines the values to be placed in the sensitive
14/// area of a created object.
15///
16/// # Details
17/// This corresponds to the TPMS_SENSITIVE_CREATE
18/// structure.
19///
20/// There is a corresponding buffer type [SensitiveCreateBuffer](crate::structures::SensitiveCreateBuffer)
21/// that holds the data in a marshalled form.
22#[derive(Debug, Clone, Eq, PartialEq, Zeroize)]
23pub struct SensitiveCreate {
24    user_auth: Auth,
25    data: SensitiveData,
26}
27
28impl SensitiveCreate {
29    /// Creates new SensitiveCreate.
30    pub const fn new(user_auth: Auth, data: SensitiveData) -> Self {
31        SensitiveCreate { user_auth, data }
32    }
33
34    /// Returns the user auth
35    pub const fn user_auth(&self) -> &Auth {
36        &self.user_auth
37    }
38
39    /// Returns the sensitive data
40    pub const fn data(&self) -> &SensitiveData {
41        &self.data
42    }
43}
44
45impl From<SensitiveCreate> for TPMS_SENSITIVE_CREATE {
46    fn from(sensitive_create: SensitiveCreate) -> Self {
47        TPMS_SENSITIVE_CREATE {
48            userAuth: sensitive_create.user_auth.into(),
49            data: sensitive_create.data.into(),
50        }
51    }
52}
53
54impl TryFrom<TPMS_SENSITIVE_CREATE> for SensitiveCreate {
55    type Error = Error;
56
57    fn try_from(tpms_sensitive_create: TPMS_SENSITIVE_CREATE) -> Result<Self> {
58        Ok(SensitiveCreate {
59            user_auth: tpms_sensitive_create.userAuth.try_into()?,
60            data: tpms_sensitive_create.data.try_into()?,
61        })
62    }
63}
64
65// Implement marshalling traits.
66impl_mu_standard!(SensitiveCreate, TPMS_SENSITIVE_CREATE);
67
68impl TryFrom<TPM2B_SENSITIVE_CREATE> for SensitiveCreate {
69    type Error = Error;
70
71    fn try_from(tpm2b_sensitive_create: TPM2B_SENSITIVE_CREATE) -> Result<Self> {
72        SensitiveCreate::try_from(tpm2b_sensitive_create.sensitive)
73    }
74}
75
76impl TryFrom<SensitiveCreate> for TPM2B_SENSITIVE_CREATE {
77    type Error = Error;
78
79    fn try_from(sensitive_create: SensitiveCreate) -> Result<Self> {
80        let mut buffer = vec![0; SensitiveCreate::BUFFER_SIZE];
81        let mut size = 0;
82        let sensitive = TPMS_SENSITIVE_CREATE::from(sensitive_create);
83
84        ReturnCode::ensure_success(
85            unsafe {
86                crate::tss2_esys::Tss2_MU_TPMS_SENSITIVE_CREATE_Marshal(
87                    &sensitive,
88                    buffer.as_mut_ptr(),
89                    SensitiveCreate::BUFFER_SIZE.try_into().map_err(|e| {
90                        error!("Failed to convert size of buffer to TSS size_t type: {}", e);
91                        Error::local_error(WrapperErrorKind::InvalidParam)
92                    })?,
93                    &mut size,
94                )
95            },
96            |ret| error!("Failed to marshal SensitiveCreate: {}", ret),
97        )?;
98
99        Ok(TPM2B_SENSITIVE_CREATE {
100            size: size.try_into().map_err(|e| {
101                error!(
102                    "Failed to convert size of buffer from TSS size_t type: {}",
103                    e
104                );
105                Error::local_error(WrapperErrorKind::InvalidParam)
106            })?,
107            sensitive,
108        })
109    }
110}