Skip to main content

tss_esapi/structures/buffers/
sensitive.rs

1// Copyright 2022 Contributors to the Parsec project.
2// SPDX-License-Identifier: Apache-2.0
3use crate::{
4    structures::Sensitive,
5    traits::{impl_mu_complex, Marshall, UnMarshall},
6    tss2_esys::{TPM2B_SENSITIVE, TPMT_SENSITIVE},
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/// Sensitive data buffer.
18///
19/// # Details
20/// Corresponds to `TPM2B_SENSITIVE`. The contents of
21/// the buffer can be unmarshalled into a [Sensitive]
22/// structure.
23#[derive(Debug, Clone, PartialEq, Eq, Zeroize, ZeroizeOnDrop)]
24pub struct SensitiveBuffer(Vec<u8>);
25
26impl SensitiveBuffer {
27    pub const MAX_SIZE: usize = size_of::<TPMT_SENSITIVE>();
28
29    pub fn value(&self) -> &[u8] {
30        &self.0
31    }
32
33    /// Private function for ensuring that a buffer size is valid.
34    fn ensure_valid_buffer_size(buffer_size: usize, container_name: &str) -> Result<()> {
35        if buffer_size > Self::MAX_SIZE {
36            error!("Invalid {} size(> {})", container_name, Self::MAX_SIZE);
37            return Err(Error::local_error(WrapperErrorKind::WrongParamSize));
38        }
39        Ok(())
40    }
41}
42
43impl Deref for SensitiveBuffer {
44    type Target = Vec<u8>;
45
46    fn deref(&self) -> &Self::Target {
47        &self.0
48    }
49}
50
51impl TryFrom<Vec<u8>> for SensitiveBuffer {
52    type Error = Error;
53
54    fn try_from(bytes: Vec<u8>) -> Result<Self> {
55        Self::ensure_valid_buffer_size(bytes.len(), "Vec<u8>")?;
56        Ok(SensitiveBuffer(bytes))
57    }
58}
59
60impl TryFrom<&[u8]> for SensitiveBuffer {
61    type Error = Error;
62
63    fn try_from(bytes: &[u8]) -> Result<Self> {
64        Self::ensure_valid_buffer_size(bytes.len(), "&[u8]")?;
65        Ok(SensitiveBuffer(bytes.to_vec()))
66    }
67}
68
69impl TryFrom<TPM2B_SENSITIVE> for SensitiveBuffer {
70    type Error = Error;
71
72    fn try_from(tss: TPM2B_SENSITIVE) -> Result<Self> {
73        let size = tss.size as usize;
74        Self::ensure_valid_buffer_size(size, "buffer")?;
75        Sensitive::try_from(tss.sensitiveArea)
76            .and_then(|sensitive| sensitive.marshall())
77            .map(SensitiveBuffer)
78    }
79}
80
81impl TryFrom<SensitiveBuffer> for TPM2B_SENSITIVE {
82    type Error = Error;
83
84    fn try_from(native: SensitiveBuffer) -> Result<Self> {
85        let mut buffer = TPM2B_SENSITIVE {
86            size: native.0.len() as u16,
87            ..Default::default()
88        };
89        let sensitive = Sensitive::unmarshall(&native.0)?;
90        buffer.sensitiveArea = sensitive.into();
91        Ok(buffer)
92    }
93}
94
95impl TryFrom<SensitiveBuffer> for Sensitive {
96    type Error = Error;
97
98    fn try_from(buf: SensitiveBuffer) -> Result<Self> {
99        Sensitive::unmarshall(&buf.0)
100    }
101}
102
103impl TryFrom<Sensitive> for SensitiveBuffer {
104    type Error = Error;
105
106    fn try_from(sensitive: Sensitive) -> Result<SensitiveBuffer> {
107        Ok(SensitiveBuffer(sensitive.marshall()?))
108    }
109}
110
111impl_mu_complex!(SensitiveBuffer, TPM2B_SENSITIVE);