Skip to main content

tss_esapi/structures/buffers/
sensitive_create.rs

1// Copyright 2022 Contributors to the Parsec project.
2// SPDX-License-Identifier: Apache-2.0
3use crate::{
4    structures::SensitiveCreate,
5    traits::{impl_mu_complex, Marshall, UnMarshall},
6    tss2_esys::{TPM2B_SENSITIVE_CREATE, TPMS_SENSITIVE_CREATE},
7    Error, Result, WrapperErrorKind,
8};
9use log::error;
10use std::{
11    convert::{TryFrom, TryInto},
12    mem::size_of,
13    ops::Deref,
14};
15use zeroize::{Zeroize, ZeroizeOnDrop};
16
17/// The [SensitiveCreate] buffer type.
18///
19/// # Details
20/// The SensitiveCreateBuffer contains [SensitiveCreate] in marshalled
21/// form. It can be unmarshalled into [SensitiveCreate] or [TPM2B_SENSITIVE_CREATE].
22/// structure.
23#[derive(Debug, Clone, PartialEq, Eq, Zeroize, ZeroizeOnDrop)]
24pub struct SensitiveCreateBuffer(Vec<u8>);
25
26impl SensitiveCreateBuffer {
27    pub const MAX_SIZE: usize = size_of::<TPMS_SENSITIVE_CREATE>();
28    pub const MIN_SIZE: usize = 4;
29
30    /// Returns the content of the buffer.
31    pub fn value(&self) -> &[u8] {
32        &self.0
33    }
34
35    /// Private function for ensuring that a buffer size is valid.
36    fn ensure_valid_buffer_size(buffer_size: usize, container_name: &str) -> Result<()> {
37        if (Self::MIN_SIZE..=Self::MAX_SIZE).contains(&buffer_size) {
38            Ok(())
39        } else {
40            error!(
41                "Error: Invalid {} size ({} >= {} >= {})",
42                container_name,
43                Self::MAX_SIZE,
44                buffer_size,
45                Self::MIN_SIZE,
46            );
47            Err(Error::local_error(WrapperErrorKind::WrongParamSize))
48        }
49    }
50}
51
52impl Deref for SensitiveCreateBuffer {
53    type Target = Vec<u8>;
54
55    fn deref(&self) -> &Self::Target {
56        &self.0
57    }
58}
59
60impl TryFrom<Vec<u8>> for SensitiveCreateBuffer {
61    type Error = Error;
62
63    fn try_from(bytes: Vec<u8>) -> Result<Self> {
64        Self::ensure_valid_buffer_size(bytes.len(), "Vec<u8>")?;
65        Ok(SensitiveCreateBuffer(bytes))
66    }
67}
68
69impl TryFrom<&[u8]> for SensitiveCreateBuffer {
70    type Error = Error;
71
72    fn try_from(bytes: &[u8]) -> Result<Self> {
73        Self::ensure_valid_buffer_size(bytes.len(), "&[u8]")?;
74        Ok(SensitiveCreateBuffer(bytes.to_vec()))
75    }
76}
77
78impl TryFrom<TPM2B_SENSITIVE_CREATE> for SensitiveCreateBuffer {
79    type Error = Error;
80
81    fn try_from(tss: TPM2B_SENSITIVE_CREATE) -> Result<Self> {
82        Self::ensure_valid_buffer_size(tss.size as usize, "buffer")?;
83        SensitiveCreate::try_from(tss.sensitive)
84            .and_then(|sensitive_create| sensitive_create.marshall())
85            .map(SensitiveCreateBuffer)
86    }
87}
88
89impl TryFrom<SensitiveCreateBuffer> for TPM2B_SENSITIVE_CREATE {
90    type Error = Error;
91
92    fn try_from(native: SensitiveCreateBuffer) -> Result<Self> {
93        SensitiveCreate::unmarshall(&native.0).map(|sensitive_create| TPM2B_SENSITIVE_CREATE {
94            size: native.0.len() as u16,
95            sensitive: sensitive_create.into(),
96        })
97    }
98}
99
100impl TryFrom<SensitiveCreateBuffer> for SensitiveCreate {
101    type Error = Error;
102
103    fn try_from(buf: SensitiveCreateBuffer) -> Result<Self> {
104        SensitiveCreate::unmarshall(&buf.0)
105    }
106}
107
108impl TryFrom<SensitiveCreate> for SensitiveCreateBuffer {
109    type Error = Error;
110
111    fn try_from(sensitve_create: SensitiveCreate) -> Result<SensitiveCreateBuffer> {
112        Ok(SensitiveCreateBuffer(sensitve_create.marshall()?))
113    }
114}
115
116impl_mu_complex!(SensitiveCreateBuffer, TPM2B_SENSITIVE_CREATE);