Cleans up CapabilityData.

Cleans up CapabilityData enum by removing all conversions functions
and instead implment TryFrom and From using the conversions of the
underlaying list types.

Makes use of the max_cap_size function in all the list types that
contain capability data to reduce the number items they depend on
from the bindgen types and constants.

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

Author: Superhepper

tss-esapi/src/structures/capabilitydata.rs

@@ -1,14 +1,15 @@
 // Copyright 2020 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
 use crate::{
-    constants::tss::*,
+    constants::CapabilityType,
     structures::{
-        AlgorithmPropertyList, CommandCodeList, EccCurveList, HandleList, PcrSelectionList,
-        TaggedPcrPropertyList, TaggedTpmPropertyList,
+        AlgorithmPropertyList, CommandCodeAttributesList, CommandCodeList, EccCurveList,
+        HandleList, PcrSelectionList, TaggedPcrPropertyList, TaggedTpmPropertyList,
     },
-    tss2_esys::*,
+    tss2_esys::{TPM2_CAP, TPM2_MAX_CAP_BUFFER, TPMS_CAPABILITY_DATA, TPMU_CAPABILITIES},
     Error, Result, WrapperErrorKind,
 };
+use log::error;
 use std::convert::{TryFrom, TryInto};
 use std::mem::size_of;
 
@@ -17,11 +18,12 @@ use std::mem::size_of;
 ///
 /// # Details
 /// This corresponds to `TPMS_CAPABILITY_DATA`
+#[non_exhaustive]
 #[derive(Debug, Clone)]
 pub enum CapabilityData {
     Algorithms(AlgorithmPropertyList),
     Handles(HandleList),
-    Commands(Vec<TPMA_CC>),
+    Commands(CommandCodeAttributesList),
     PpCommands(CommandCodeList),
     AuditCommands(CommandCodeList),
     AssignedPcr(PcrSelectionList),
@@ -33,85 +35,113 @@ pub enum CapabilityData {
     // ActData(),
 }
 
-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
+pub const fn max_cap_size<T>() -> usize {
+    (TPM2_MAX_CAP_BUFFER as usize - size_of::<TPM2_CAP>() - size_of::<u32>()) / size_of::<T>()
 }
 
-fn cd_from_alg_properties(props: TPML_ALG_PROPERTY) -> Result<CapabilityData> {
-    Ok(CapabilityData::Algorithms(props.try_into()?))
-}
-
-fn cd_from_handles(props: TPML_HANDLE) -> Result<CapabilityData> {
-    Ok(CapabilityData::Handles(HandleList::try_from(props)?))
-}
-
-fn cd_from_command(props: TPML_CCA) -> Result<CapabilityData> {
-    if props.count > TPM2_MAX_CAP_CC {
-        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.commandAttributes[i as usize]);
+impl From<CapabilityData> for TPMS_CAPABILITY_DATA {
+    fn from(capability_data: CapabilityData) -> Self {
+        match capability_data {
+            CapabilityData::Algorithms(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::Algorithms.into(),
+                data: TPMU_CAPABILITIES {
+                    algorithms: data.into(),
+                },
+            },
+            CapabilityData::Handles(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::Handles.into(),
+                data: TPMU_CAPABILITIES {
+                    handles: data.into(),
+                },
+            },
+            CapabilityData::Commands(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::Command.into(),
+                data: TPMU_CAPABILITIES {
+                    command: data.into(),
+                },
+            },
+            CapabilityData::PpCommands(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::PpCommands.into(),
+                data: TPMU_CAPABILITIES {
+                    ppCommands: data.into(),
+                },
+            },
+            CapabilityData::AuditCommands(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::AuditCommands.into(),
+                data: TPMU_CAPABILITIES {
+                    auditCommands: data.into(),
+                },
+            },
+            CapabilityData::AssignedPcr(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::AssignedPcr.into(),
+                data: TPMU_CAPABILITIES {
+                    assignedPCR: data.into(),
+                },
+            },
+            CapabilityData::TpmProperties(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::TpmProperties.into(),
+                data: TPMU_CAPABILITIES {
+                    tpmProperties: data.into(),
+                },
+            },
+            CapabilityData::PcrProperties(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::PcrProperties.into(),
+                data: TPMU_CAPABILITIES {
+                    pcrProperties: data.into(),
+                },
+            },
+            CapabilityData::EccCurves(data) => TPMS_CAPABILITY_DATA {
+                capability: CapabilityType::EccCurves.into(),
+                data: TPMU_CAPABILITIES {
+                    eccCurves: data.into(),
+                },
+            },
+        }
     }
-
-    Ok(CapabilityData::Commands(data))
-}
-
-fn cd_from_pp_commands(props: TPML_CC) -> Result<CapabilityData> {
-    Ok(CapabilityData::PpCommands(CommandCodeList::try_from(
-        props,
-    )?))
-}
-
-fn cd_from_audit_commands(props: TPML_CC) -> Result<CapabilityData> {
-    Ok(CapabilityData::AuditCommands(CommandCodeList::try_from(
-        props,
-    )?))
-}
-
-fn cd_from_assigned_pcrs(props: TPML_PCR_SELECTION) -> Result<CapabilityData> {
-    Ok(CapabilityData::AssignedPcr(props.try_into()?))
-}
-
-fn cd_from_tpm_properties(props: TPML_TAGGED_TPM_PROPERTY) -> Result<CapabilityData> {
-    Ok(CapabilityData::TpmProperties(props.try_into()?))
-}
-
-fn cd_from_pcr_properties(props: TPML_TAGGED_PCR_PROPERTY) -> Result<CapabilityData> {
-    Ok(CapabilityData::PcrProperties(props.try_into()?))
-}
-
-fn cd_from_ecc_curves(props: TPML_ECC_CURVE) -> Result<CapabilityData> {
-    Ok(CapabilityData::EccCurves(EccCurveList::try_from(props)?))
 }
 
 impl TryFrom<TPMS_CAPABILITY_DATA> for CapabilityData {
     type Error = Error;
 
-    fn try_from(capab_data: TPMS_CAPABILITY_DATA) -> Result<Self> {
+    fn try_from(tpms_capability_data: TPMS_CAPABILITY_DATA) -> Result<Self> {
         // SAFETY: This is a C union, and Rust wants us to make sure we're using the correct item.
         // These unsafe blocks are fine because we ensure the correct type is used.
-        match capab_data.capability {
-            TPM2_CAP_ALGS => cd_from_alg_properties(unsafe { capab_data.data.algorithms }),
-            TPM2_CAP_HANDLES => cd_from_handles(unsafe { capab_data.data.handles }),
-            TPM2_CAP_COMMANDS => cd_from_command(unsafe { capab_data.data.command }),
-            TPM2_CAP_PP_COMMANDS => cd_from_pp_commands(unsafe { capab_data.data.ppCommands }),
-            TPM2_CAP_AUDIT_COMMANDS => {
-                cd_from_audit_commands(unsafe { capab_data.data.auditCommands })
-            }
-            TPM2_CAP_PCRS => cd_from_assigned_pcrs(unsafe { capab_data.data.assignedPCR }),
-            TPM2_CAP_TPM_PROPERTIES => {
-                cd_from_tpm_properties(unsafe { capab_data.data.tpmProperties })
+        match CapabilityType::try_from(tpms_capability_data.capability)? {
+            CapabilityType::Algorithms => Ok(CapabilityData::Algorithms(
+                unsafe { tpms_capability_data.data.algorithms }.try_into()?,
+            )),
+            CapabilityType::Handles => Ok(CapabilityData::Handles(
+                unsafe { tpms_capability_data.data.handles }.try_into()?,
+            )),
+            CapabilityType::Command => Ok(CapabilityData::Commands(
+                unsafe { tpms_capability_data.data.command }.try_into()?,
+            )),
+            CapabilityType::PpCommands => Ok(CapabilityData::PpCommands(
+                unsafe { tpms_capability_data.data.ppCommands }.try_into()?,
+            )),
+            CapabilityType::AuditCommands => Ok(CapabilityData::AuditCommands(
+                unsafe { tpms_capability_data.data.auditCommands }.try_into()?,
+            )),
+            CapabilityType::AssignedPcr => Ok(CapabilityData::AssignedPcr(
+                unsafe { tpms_capability_data.data.assignedPCR }.try_into()?,
+            )),
+            CapabilityType::TpmProperties => Ok(CapabilityData::TpmProperties(
+                unsafe { tpms_capability_data.data.tpmProperties }.try_into()?,
+            )),
+            CapabilityType::PcrProperties => Ok(CapabilityData::PcrProperties(
+                unsafe { tpms_capability_data.data.pcrProperties }.try_into()?,
+            )),
+            CapabilityType::EccCurves => Ok(CapabilityData::EccCurves(
+                unsafe { tpms_capability_data.data.eccCurves }.try_into()?,
+            )),
+            CapabilityType::AuthPolicies => {
+                error!("AuthPolicies capability type is currently not supported");
+                Err(Error::WrapperError(WrapperErrorKind::UnsupportedParam))
             }
-            TPM2_CAP_PCR_PROPERTIES => {
-                cd_from_pcr_properties(unsafe { capab_data.data.pcrProperties })
+            CapabilityType::Act => {
+                error!("Act capability type is currently not supported");
+                Err(Error::WrapperError(WrapperErrorKind::UnsupportedParam))
             }
-            TPM2_CAP_ECC_CURVES => cd_from_ecc_curves(unsafe { capab_data.data.eccCurves }),
-            _ => Err(Error::WrapperError(WrapperErrorKind::UnsupportedParam)),
         }
     }
 }

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

@@ -4,7 +4,7 @@
 use crate::{
     constants::AlgorithmIdentifier,
     structures::AlgorithmProperty,
-    tss2_esys::{TPM2_CAP, TPM2_MAX_CAP_BUFFER, TPML_ALG_PROPERTY, TPMS_ALG_PROPERTY},
+    tss2_esys::{TPML_ALG_PROPERTY, TPMS_ALG_PROPERTY},
     Error, Result, WrapperErrorKind,
 };
 use log::error;
@@ -29,10 +29,7 @@ impl AlgorithmPropertyList {
     /// Private function that calculates the maximum number
     /// elements allowed in internal storage.
     const fn calculate_max_size() -> usize {
-        (TPM2_MAX_CAP_BUFFER as usize
-            - std::mem::size_of::<TPM2_CAP>()
-            - std::mem::size_of::<u32>())
-            / std::mem::size_of::<TPMS_ALG_PROPERTY>()
+        crate::structures::capabilitydata::max_cap_size::<TPMS_ALG_PROPERTY>()
     }
 }
 

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 use crate::{
     attributes::CommandCodeAttributes,
-    tss2_esys::{TPM2_CAP, TPM2_MAX_CAP_BUFFER, TPMA_CC, TPML_CCA},
+    tss2_esys::{TPMA_CC, TPML_CCA},
     Error, Result, WrapperErrorKind,
 };
 use log::error;
@@ -31,13 +31,7 @@ impl CommandCodeAttributesList {
     /// Private function that calculates the maximum number
     /// elements allowed in internal storage.
     const fn calculate_max_size() -> usize {
-        // According to the specification the size is vendor specific.
-        // So if someone is using modified values in their TSS libraries
-        // it is picked up here.
-        (TPM2_MAX_CAP_BUFFER as usize
-            - std::mem::size_of::<TPM2_CAP>()
-            - std::mem::size_of::<u32>())
-            / std::mem::size_of::<TPMA_CC>()
+        crate::structures::capabilitydata::max_cap_size::<TPMA_CC>()
     }
 }
 

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

@@ -17,8 +17,7 @@ pub struct EccCurveList {
 }
 
 impl EccCurveList {
-    pub const MAX_SIZE: usize =
-        crate::structures::capabilitydata::max_cap_size::<TPM2_ECC_CURVE>() as usize;
+    pub const MAX_SIZE: usize = Self::calculate_max_size();
 
     pub fn new() -> Self {
         EccCurveList {
@@ -43,6 +42,12 @@ impl EccCurveList {
     pub fn into_inner(self) -> Vec<EccCurveIdentifier> {
         self.ecc_curves
     }
+
+    /// Private function that calculates the maximum number
+    /// elements allowed in internal storage.
+    const fn calculate_max_size() -> usize {
+        crate::structures::capabilitydata::max_cap_size::<TPM2_ECC_CURVE>()
+    }
 }
 
 impl TryFrom<TPML_ECC_CURVE> for EccCurveList {

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

@@ -17,8 +17,7 @@ pub struct HandleList {
 }
 
 impl HandleList {
-    pub const MAX_SIZE: usize =
-        crate::structures::capabilitydata::max_cap_size::<TPM2_HANDLE>() as usize;
+    pub const MAX_SIZE: usize = Self::calculate_max_size();
 
     pub fn new() -> Self {
         HandleList {
@@ -43,6 +42,12 @@ impl HandleList {
     pub fn into_inner(self) -> Vec<TpmHandle> {
         self.handles
     }
+
+    /// Private function that calculates the maximum number
+    /// elements allowed in internal storage.
+    const fn calculate_max_size() -> usize {
+        crate::structures::capabilitydata::max_cap_size::<TPM2_HANDLE>()
+    }
 }
 
 impl TryFrom<TPML_HANDLE> for HandleList {

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

@@ -4,7 +4,7 @@
 use crate::{
     constants::PcrPropertyTag,
     structures::{PcrSlot, TaggedPcrSelect},
-    tss2_esys::{TPM2_CAP, TPM2_MAX_CAP_BUFFER, TPML_TAGGED_PCR_PROPERTY, TPMS_TAGGED_PCR_SELECT},
+    tss2_esys::{TPML_TAGGED_PCR_PROPERTY, TPMS_TAGGED_PCR_SELECT},
     Error, Result, WrapperErrorKind,
 };
 use log::error;
@@ -44,13 +44,7 @@ impl TaggedPcrPropertyList {
     /// Private function that calculates the maximum number
     /// elements allowed in internal storage.
     const fn calculate_max_size() -> usize {
-        // According to the specification the size is vendor specific.
-        // So if someone is using modified values in their TSS libraries
-        // it is picked up here.
-        (TPM2_MAX_CAP_BUFFER as usize
-            - std::mem::size_of::<TPM2_CAP>()
-            - std::mem::size_of::<u32>())
-            / std::mem::size_of::<TPMS_TAGGED_PCR_SELECT>()
+        crate::structures::capabilitydata::max_cap_size::<TPMS_TAGGED_PCR_SELECT>()
     }
 }
 

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

@@ -4,7 +4,7 @@
 use crate::{
     constants::PropertyTag,
     structures::TaggedProperty,
-    tss2_esys::{TPM2_CAP, TPM2_MAX_CAP_BUFFER, TPML_TAGGED_TPM_PROPERTY, TPMS_TAGGED_PROPERTY},
+    tss2_esys::{TPML_TAGGED_TPM_PROPERTY, TPMS_TAGGED_PROPERTY},
     Error, Result, WrapperErrorKind,
 };
 use log::error;
@@ -32,13 +32,7 @@ impl TaggedTpmPropertyList {
     /// Private function that calculates the maximum number
     /// elements allowed in internal storage.
     const fn calculate_max_size() -> usize {
-        // According to the specification the size is vendor specific.
-        // So if someone is using modified values in their TSS libraries
-        // it is picked up here.
-        (TPM2_MAX_CAP_BUFFER as usize
-            - std::mem::size_of::<TPM2_CAP>()
-            - std::mem::size_of::<u32>())
-            / std::mem::size_of::<TPMS_TAGGED_PROPERTY>()
+        crate::structures::capabilitydata::max_cap_size::<TPMS_TAGGED_PROPERTY>()
     }
 }