Merge pull request #312 from ionut-arm/ecc-curves

Replace type in CapabilityData::EccCurves

Author: Superhepper

tss-esapi/src/constants/ecc.rs

@@ -14,6 +14,9 @@ use num_traits::{FromPrimitive, ToPrimitive};
 use std::convert::TryFrom;
 /// Enum that contains the constants for the
 /// implemented elliptic curves.
+///
+/// # Details
+/// This corresponds to `TPM2_ECC_CURVE`
 #[derive(FromPrimitive, ToPrimitive, Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u16)]
 pub enum EccCurveIdentifier {

tss-esapi/src/lib.rs

@@ -28,7 +28,6 @@
     unused_results,
     missing_copy_implementations
 )]
-#![allow(clippy::upper_case_acronyms)]
 //! # TSS 2.0 Rust Wrapper over Enhanced System API
 //! This crate exposes the functionality of the TCG Software Stack Enhanced System API to
 //! Rust developers, both directly through FFI bindings and through more Rust-tailored interfaces

tss-esapi/src/structures/capabilitydata.rs

@@ -2,34 +2,38 @@
 // SPDX-License-Identifier: Apache-2.0
 use crate::{
     constants::tss::*,
-    handles::TpmHandle,
     structures::{
-        AlgorithmPropertyList, CommandCodeList, PcrSelectionList, TaggedPcrPropertyList,
-        TaggedTpmPropertyList,
+        AlgorithmPropertyList, CommandCodeList, EccCurveList, HandleList, PcrSelectionList,
+        TaggedPcrPropertyList, TaggedTpmPropertyList,
     },
     tss2_esys::*,
     Error, Result, WrapperErrorKind,
 };
 use std::convert::{TryFrom, TryInto};
 use std::mem::size_of;
 
+/// A representation of all the capabilites that can be associated
+/// with a TPM.
+///
+/// # Details
+/// This corresponds to `TPMS_CAPABILITY_DATA`
 #[derive(Debug, Clone)]
 pub enum CapabilityData {
     Algorithms(AlgorithmPropertyList),
-    Handles(Vec<TpmHandle>),
+    Handles(HandleList),
     Commands(Vec<TPMA_CC>),
     PpCommands(CommandCodeList),
     AuditCommands(CommandCodeList),
-    AssignedPCR(PcrSelectionList),
+    AssignedPcr(PcrSelectionList),
     TpmProperties(TaggedTpmPropertyList),
     PcrProperties(TaggedPcrPropertyList),
-    ECCCurves(Vec<TPM2_ECC_CURVE>),
+    EccCurves(EccCurveList),
     // These are in the TPM TPMU_CAPABILITIES, but are not defined by esapi-2.4.1
     // AuthPolicies(),
     // ActData(),
 }
 
-fn max_cap_size<T>() -> u32 {
+pub(crate) const fn max_cap_size<T>() -> u32 {
     ((TPM2_MAX_CAP_BUFFER as usize - size_of::<TPM2_CAP>() - size_of::<u32>()) / size_of::<T>())
         as u32
 }
@@ -39,19 +43,7 @@ fn cd_from_alg_properties(props: TPML_ALG_PROPERTY) -> Result<CapabilityData> {
 }
 
 fn cd_from_handles(props: TPML_HANDLE) -> Result<CapabilityData> {
-    if props.count > max_cap_size::<TPM2_HANDLE>() {
-        return Err(Error::WrapperError(WrapperErrorKind::InvalidParam));
-    }
-
-    let mut data: Vec<TpmHandle> = Vec::new();
-    data.reserve_exact(props.count as usize);
-
-    for i in 0..props.count {
-        let handle: TPM2_HANDLE = props.handle[i as usize];
-        data.push(handle.try_into()?);
-    }
-
-    Ok(CapabilityData::Handles(data))
+    Ok(CapabilityData::Handles(HandleList::try_from(props)?))
 }
 
 fn cd_from_command(props: TPML_CCA) -> Result<CapabilityData> {
@@ -82,7 +74,7 @@ fn cd_from_audit_commands(props: TPML_CC) -> Result<CapabilityData> {
 }
 
 fn cd_from_assigned_pcrs(props: TPML_PCR_SELECTION) -> Result<CapabilityData> {
-    Ok(CapabilityData::AssignedPCR(props.try_into()?))
+    Ok(CapabilityData::AssignedPcr(props.try_into()?))
 }
 
 fn cd_from_tpm_properties(props: TPML_TAGGED_TPM_PROPERTY) -> Result<CapabilityData> {
@@ -94,18 +86,7 @@ fn cd_from_pcr_properties(props: TPML_TAGGED_PCR_PROPERTY) -> Result<CapabilityD
 }
 
 fn cd_from_ecc_curves(props: TPML_ECC_CURVE) -> Result<CapabilityData> {
-    if props.count > max_cap_size::<TPM2_ECC_CURVE>() {
-        return Err(Error::WrapperError(WrapperErrorKind::InvalidParam));
-    }
-
-    let mut data = Vec::new();
-    data.reserve_exact(props.count as usize);
-
-    for i in 0..props.count {
-        data.push(props.eccCurves[i as usize]);
-    }
-
-    Ok(CapabilityData::ECCCurves(data))
+    Ok(CapabilityData::EccCurves(EccCurveList::try_from(props)?))
 }
 
 impl TryFrom<TPMS_CAPABILITY_DATA> for CapabilityData {

tss-esapi/src/structures/lists/ecc_curves.rs

@@ -0,0 +1,106 @@
+// Copyright 2022 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use crate::constants::ecc::EccCurveIdentifier;
+use crate::tss2_esys::{TPM2_ECC_CURVE, TPML_ECC_CURVE};
+use crate::{Error, Result, WrapperErrorKind};
+use log::error;
+use std::convert::TryFrom;
+use std::ops::Deref;
+
+/// A list of ECC curves
+///
+/// # Details
+/// This corresponds to `TPML_ECC_CURVE`.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct EccCurveList {
+    ecc_curves: Vec<EccCurveIdentifier>,
+}
+
+impl EccCurveList {
+    pub const MAX_SIZE: usize =
+        crate::structures::capabilitydata::max_cap_size::<TPM2_ECC_CURVE>() as usize;
+
+    pub fn new() -> Self {
+        EccCurveList {
+            ecc_curves: Vec::new(),
+        }
+    }
+
+    /// Adds an ECC curve to the list of curves.
+    pub fn add(&mut self, ecc_curve: EccCurveIdentifier) -> Result<()> {
+        if self.ecc_curves.len() + 1 > EccCurveList::MAX_SIZE {
+            error!(
+                "Adding ECC curve to list will make the list exceeded its maximum count(> {})",
+                EccCurveList::MAX_SIZE
+            );
+            return Err(Error::local_error(WrapperErrorKind::WrongParamSize));
+        }
+        self.ecc_curves.push(ecc_curve);
+        Ok(())
+    }
+
+    /// Returns the inner type.
+    pub fn into_inner(self) -> Vec<EccCurveIdentifier> {
+        self.ecc_curves
+    }
+}
+
+impl TryFrom<TPML_ECC_CURVE> for EccCurveList {
+    type Error = Error;
+
+    fn try_from(ecc_curves: TPML_ECC_CURVE) -> Result<Self> {
+        let ecc_curve_count = ecc_curves.count as usize;
+        if ecc_curve_count > Self::MAX_SIZE {
+            error!("Error: Invalid TPML_ECC_CURVE count(> {})", Self::MAX_SIZE);
+            return Err(Error::local_error(WrapperErrorKind::InvalidParam));
+        }
+        ecc_curves.eccCurves[..ecc_curve_count]
+            .iter()
+            .map(|&cc| EccCurveIdentifier::try_from(cc))
+            .collect::<Result<Vec<EccCurveIdentifier>>>()
+            .map(|ecc_curves| EccCurveList { ecc_curves })
+    }
+}
+
+impl From<EccCurveList> for TPML_ECC_CURVE {
+    fn from(ecc_curves: EccCurveList) -> Self {
+        let mut tss_ecc_curves: TPML_ECC_CURVE = Default::default();
+        for ecc_curve in ecc_curves.ecc_curves {
+            tss_ecc_curves.eccCurves[tss_ecc_curves.count as usize] = ecc_curve.into();
+            tss_ecc_curves.count += 1;
+        }
+        tss_ecc_curves
+    }
+}
+
+impl TryFrom<Vec<EccCurveIdentifier>> for EccCurveList {
+    type Error = Error;
+
+    fn try_from(ecc_curves: Vec<EccCurveIdentifier>) -> Result<Self> {
+        if ecc_curves.len() > Self::MAX_SIZE {
+            error!("Error: Invalid TPML_ECC_CURVE count(> {})", Self::MAX_SIZE);
+            return Err(Error::local_error(WrapperErrorKind::InvalidParam));
+        }
+        Ok(EccCurveList { ecc_curves })
+    }
+}
+
+impl From<EccCurveList> for Vec<EccCurveIdentifier> {
+    fn from(ecc_curve_list: EccCurveList) -> Self {
+        ecc_curve_list.ecc_curves
+    }
+}
+
+impl AsRef<[EccCurveIdentifier]> for EccCurveList {
+    fn as_ref(&self) -> &[EccCurveIdentifier] {
+        self.ecc_curves.as_slice()
+    }
+}
+
+impl Deref for EccCurveList {
+    type Target = Vec<EccCurveIdentifier>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.ecc_curves
+    }
+}

tss-esapi/src/structures/lists/handles.rs

@@ -0,0 +1,106 @@
+// Copyright 2022 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use crate::handles::TpmHandle;
+use crate::tss2_esys::{TPM2_HANDLE, TPML_HANDLE};
+use crate::{Error, Result, WrapperErrorKind};
+use log::error;
+use std::convert::TryFrom;
+use std::ops::Deref;
+
+/// A list of TPM handles
+///
+/// # Details
+/// This corresponds to `TPML_HANDLE`.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct HandleList {
+    handles: Vec<TpmHandle>,
+}
+
+impl HandleList {
+    pub const MAX_SIZE: usize =
+        crate::structures::capabilitydata::max_cap_size::<TPM2_HANDLE>() as usize;
+
+    pub fn new() -> Self {
+        HandleList {
+            handles: Vec::new(),
+        }
+    }
+
+    /// Adds a handle to the current list of handles.
+    pub fn add(&mut self, handle: TpmHandle) -> Result<()> {
+        if self.handles.len() + 1 > HandleList::MAX_SIZE {
+            error!(
+                "Adding TPM handle to list will make the list exceeded its maximum count(> {})",
+                HandleList::MAX_SIZE
+            );
+            return Err(Error::local_error(WrapperErrorKind::WrongParamSize));
+        }
+        self.handles.push(handle);
+        Ok(())
+    }
+
+    /// Returns the inner type.
+    pub fn into_inner(self) -> Vec<TpmHandle> {
+        self.handles
+    }
+}
+
+impl TryFrom<TPML_HANDLE> for HandleList {
+    type Error = Error;
+
+    fn try_from(handles: TPML_HANDLE) -> Result<Self> {
+        let handle_count = handles.count as usize;
+        if handle_count > Self::MAX_SIZE {
+            error!("Error: Invalid TPML_HANDLE count(> {})", Self::MAX_SIZE);
+            return Err(Error::local_error(WrapperErrorKind::InvalidParam));
+        }
+        handles.handle[..handle_count]
+            .iter()
+            .map(|&cc| TpmHandle::try_from(cc))
+            .collect::<Result<Vec<TpmHandle>>>()
+            .map(|handles| HandleList { handles })
+    }
+}
+
+impl From<HandleList> for TPML_HANDLE {
+    fn from(handles: HandleList) -> Self {
+        let mut tss_handles: TPML_HANDLE = Default::default();
+        for handle in handles.handles {
+            tss_handles.handle[tss_handles.count as usize] = handle.into();
+            tss_handles.count += 1;
+        }
+        tss_handles
+    }
+}
+
+impl TryFrom<Vec<TpmHandle>> for HandleList {
+    type Error = Error;
+
+    fn try_from(handles: Vec<TpmHandle>) -> Result<Self> {
+        if handles.len() > Self::MAX_SIZE {
+            error!("Error: Invalid TPML_HANDLE count(> {})", Self::MAX_SIZE);
+            return Err(Error::local_error(WrapperErrorKind::InvalidParam));
+        }
+        Ok(HandleList { handles })
+    }
+}
+
+impl From<HandleList> for Vec<TpmHandle> {
+    fn from(handle_list: HandleList) -> Self {
+        handle_list.handles
+    }
+}
+
+impl AsRef<[TpmHandle]> for HandleList {
+    fn as_ref(&self) -> &[TpmHandle] {
+        self.handles.as_slice()
+    }
+}
+
+impl Deref for HandleList {
+    type Target = Vec<TpmHandle>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.handles
+    }
+}

tss-esapi/src/structures/lists/mod.rs

@@ -4,6 +4,8 @@ pub mod algorithm_property;
 pub mod command_code;
 pub mod digest;
 pub mod digest_values;
+pub mod ecc_curves;
+pub mod handles;
 pub mod pcr_selection;
 pub mod tagged_pcr_property;
 pub mod tagged_tpm_property;

tss-esapi/src/structures/mod.rs

@@ -90,6 +90,16 @@ pub mod digest_values {
     pub use super::lists::digest_values::*;
 }
 
+pub use self::ecc_curves::EccCurveList;
+pub mod ecc_curves {
+    pub use super::lists::ecc_curves::*;
+}
+
+pub use self::handle_list::HandleList;
+pub mod handle_list {
+    pub use super::lists::handles::*;
+}
+
 pub use self::pcr_selection_list::PcrSelectionList;
 pub use self::pcr_selection_list::PcrSelectionListBuilder;
 pub mod pcr_selection_list {