Adds CommandCodeAttributesList type.

Adds the CommandCodeAttributesList type this corresponds
to the TPML_CCA structure.

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

Author: Superhepper

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

@@ -16,7 +16,7 @@ pub struct CommandCodeList {
 }
 
 impl CommandCodeList {
-    pub const MAX_SIZE: usize = TPM2_MAX_CAP_CC as usize;
+    pub const MAX_SIZE: usize = Self::calculate_max_size();
     /// Creates a new CommandCodeList
     pub const fn new() -> Self {
         CommandCodeList {
@@ -41,6 +41,12 @@ impl CommandCodeList {
     pub fn into_inner(self) -> Vec<CommandCode> {
         self.command_codes
     }
+
+    /// Private function that calculates the maximum number
+    /// elements allowed in internal storage.
+    const fn calculate_max_size() -> usize {
+        TPM2_MAX_CAP_CC as usize
+    }
 }
 
 impl TryFrom<TPML_CC> for CommandCodeList {

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

@@ -0,0 +1,114 @@
+// Copyright 2022 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use crate::{
+    attributes::CommandCodeAttributes,
+    tss2_esys::{TPM2_CAP, TPM2_MAX_CAP_BUFFER, TPMA_CC, TPML_CCA},
+    Error, Result, WrapperErrorKind,
+};
+use log::error;
+use std::{convert::TryFrom, iter::IntoIterator, ops::Deref};
+
+/// A structure holding a list of command code attributes.
+///
+/// # Details
+/// This corresponds to the TPML_CCA strucutre.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CommandCodeAttributesList {
+    command_code_attributes: Vec<CommandCodeAttributes>,
+}
+
+impl CommandCodeAttributesList {
+    pub const MAX_SIZE: usize = Self::calculate_max_size();
+
+    /// Finds a command code attributes with a specific
+    /// command index
+    pub fn find(&self, command_index: u16) -> Option<&CommandCodeAttributes> {
+        self.command_code_attributes
+            .iter()
+            .find(|cca| cca.command_index() == command_index)
+    }
+
+    /// 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>()
+    }
+}
+
+impl Deref for CommandCodeAttributesList {
+    type Target = Vec<CommandCodeAttributes>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.command_code_attributes
+    }
+}
+
+impl AsRef<[CommandCodeAttributes]> for CommandCodeAttributesList {
+    fn as_ref(&self) -> &[CommandCodeAttributes] {
+        self.command_code_attributes.as_slice()
+    }
+}
+
+impl TryFrom<Vec<CommandCodeAttributes>> for CommandCodeAttributesList {
+    type Error = Error;
+
+    fn try_from(command_code_attributes: Vec<CommandCodeAttributes>) -> Result<Self> {
+        if command_code_attributes.len() > Self::MAX_SIZE {
+            error!("Failed to convert Vec<CommandCodeAttributes> into CommandCodeAttributesList, to many items (> {})", Self::MAX_SIZE);
+            return Err(Error::local_error(WrapperErrorKind::InvalidParam));
+        }
+        Ok(CommandCodeAttributesList {
+            command_code_attributes,
+        })
+    }
+}
+
+impl IntoIterator for CommandCodeAttributesList {
+    type Item = CommandCodeAttributes;
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.command_code_attributes.into_iter()
+    }
+}
+
+impl TryFrom<TPML_CCA> for CommandCodeAttributesList {
+    type Error = Error;
+
+    fn try_from(tpml_cca: TPML_CCA) -> Result<Self> {
+        let count = usize::try_from(tpml_cca.count).map_err(|e| {
+            error!("Failed to parse count in TPML_CCA as usize: {}", e);
+            Error::local_error(WrapperErrorKind::InvalidParam)
+        })?;
+
+        if count > Self::MAX_SIZE {
+            error!("Invalid size value in TPML_CCA (> {})", Self::MAX_SIZE,);
+            return Err(Error::local_error(WrapperErrorKind::InvalidParam));
+        }
+
+        tpml_cca.commandAttributes[..count]
+            .iter()
+            .map(|&tp| CommandCodeAttributes::try_from(tp))
+            .collect::<Result<Vec<CommandCodeAttributes>>>()
+            .map(|command_code_attributes| CommandCodeAttributesList {
+                command_code_attributes,
+            })
+    }
+}
+
+impl From<CommandCodeAttributesList> for TPML_CCA {
+    fn from(command_code_attributes_list: CommandCodeAttributesList) -> Self {
+        let mut tpml_cca: TPML_CCA = Default::default();
+        for command_code_attributes in command_code_attributes_list {
+            tpml_cca.commandAttributes[tpml_cca.count as usize] = command_code_attributes.into();
+            tpml_cca.count += 1;
+        }
+        tpml_cca
+    }
+}

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pub mod algorithm_property;
 pub mod command_code;
+pub mod command_code_attributes;
 pub mod digest;
 pub mod digest_values;
 pub mod ecc_curves;

tss-esapi/src/structures/mod.rs

@@ -125,6 +125,11 @@ pub use tagged_pcr_property_list::TaggedPcrPropertyList;
 pub mod tagged_pcr_property_list {
     pub use super::lists::tagged_pcr_property::*;
 }
+
+pub use self::command_code_attributes_list::CommandCodeAttributesList;
+pub mod command_code_attributes_list {
+    pub use super::lists::command_code_attributes::*;
+}
 /////////////////////////////////////////////////////////
 /// The parameters section
 /////////////////////////////////////////////////////////

tss-esapi/tests/integration_tests/common/mod.rs

@@ -32,9 +32,11 @@ use tss_esapi::{
 };
 
 mod marshall;
+mod tpma_types_equality_checks;
 mod tpml_types_equality_checks;
 mod tpms_types_equality_checks;
 pub use marshall::*;
+pub use tpma_types_equality_checks::*;
 pub use tpml_types_equality_checks::*;
 pub use tpms_types_equality_checks::*;
 

tss-esapi/tests/integration_tests/common/tpma_types_equality_checks.rs

@@ -0,0 +1,11 @@
+// Copyright 2022 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+
+use tss_esapi::tss2_esys::TPMA_CC;
+
+pub fn ensure_tpma_cc_equality(expected: &TPMA_CC, actual: &TPMA_CC) {
+    assert_eq!(
+        expected, actual,
+        "mismatch between actual and expected TPMA_CC value"
+    );
+}

tss-esapi/tests/integration_tests/common/tpml_types_equality_checks.rs

@@ -1,7 +1,8 @@
 // Copyright 2021 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
 use tss_esapi::tss2_esys::{
-    TPML_ALG_PROPERTY, TPML_PCR_SELECTION, TPML_TAGGED_PCR_PROPERTY, TPML_TAGGED_TPM_PROPERTY,
+    TPML_ALG_PROPERTY, TPML_CCA, TPML_PCR_SELECTION, TPML_TAGGED_PCR_PROPERTY,
+    TPML_TAGGED_TPM_PROPERTY,
 };
 
 macro_rules! ensure_list_equality {
@@ -50,3 +51,10 @@ ensure_list_equality!(
     pcrProperty,
     ensure_tpms_tagged_pcr_select_equality
 );
+
+ensure_list_equality!(
+    ensure_tpml_cca_equality,
+    TPML_CCA,
+    commandAttributes,
+    ensure_tpma_cc_equality
+);

tss-esapi/tests/integration_tests/structures_tests/lists_tests/command_code_attributes_list_tests.rs

@@ -0,0 +1,140 @@
+// Copyright 2022 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+
+use std::convert::{TryFrom, TryInto};
+use tss_esapi::{
+    attributes::CommandCodeAttributes, constants::CommandCode,
+    structures::CommandCodeAttributesList, tss2_esys::TPML_CCA, Error, WrapperErrorKind,
+};
+
+#[test]
+fn test_valid_conversions() {
+    let expected_command_code_attributes = vec![
+        CommandCodeAttributes::try_from(u32::from(CommandCode::NvUndefineSpaceSpecial)).expect(
+            "Failed to create CommandCodeAttributes using CommandCode::NvUndefineSpaceSpecia",
+        ),
+        CommandCodeAttributes::try_from(u32::from(CommandCode::EvictControl))
+            .expect("Failed to create CommandCodeAttributes using CommandCode::EvictControl"),
+        CommandCodeAttributes::try_from(u32::from(CommandCode::PcrRead))
+            .expect("Failed to create CommandCodeAttributes using CommandCode::PcrRead"),
+    ];
+
+    let expected_tpml_cca: TPML_CCA =
+        expected_command_code_attributes
+            .iter()
+            .fold(Default::default(), |mut acc, &v| {
+                acc.commandAttributes[acc.count as usize] = v.into();
+                acc.count += 1;
+                acc
+            });
+
+    let command_code_attributes_list_from_vec: CommandCodeAttributesList =
+        expected_command_code_attributes
+            .clone()
+            .try_into()
+            .expect("Failed to convert Vec<CommandCodeAttributes> to CommandCodeAttributesList");
+
+    assert_eq!(
+        expected_command_code_attributes.len(),
+        command_code_attributes_list_from_vec.len(),
+        "Mismatch in 'len()' between the Vec<CommandCodeAttributes> and the CommandCodeAttributesList(from vec)"
+    );
+
+    expected_command_code_attributes
+        .iter()
+        .zip(command_code_attributes_list_from_vec.as_ref())
+        .for_each(|(expected, actual)| {
+            assert_eq!(expected, actual, "Mismatch between an expected CommandCodeAttributes in the Vec<CommandCodeAttributes> the actual command code attributes in CommandCodeAttributesList(from vec)");
+        });
+
+    let command_code_attributes_list_from_tss: CommandCodeAttributesList = expected_tpml_cca
+        .try_into()
+        .expect("Failed to convert expected_tpml_cca into CommandCodeAttributesList");
+
+    assert_eq!(
+            expected_command_code_attributes.len(),
+            command_code_attributes_list_from_tss.len(),
+            "Mismatch in 'len()' between the Vec<CommandCodeAttributes> and the CommandCodeAttributesList(from tss)"
+        );
+
+    expected_command_code_attributes
+        .iter()
+        .zip(command_code_attributes_list_from_tss.as_ref())
+        .for_each(|(expected, actual)| {
+            assert_eq!(expected, actual, "Mismatch between an expected CommandCodeAttributes in the Vec<CommandCodeAttributes> the actual tagged property in CommandCodeAttributesList(from tss)");
+        });
+
+    let actual_tpml_cca: TPML_CCA = command_code_attributes_list_from_vec.into();
+
+    crate::common::ensure_tpml_cca_equality(&expected_tpml_cca, &actual_tpml_cca);
+}
+
+#[test]
+fn test_invalid_conversions() {
+    assert_eq!(
+        Err(Error::WrapperError(WrapperErrorKind::InvalidParam)),
+        CommandCodeAttributesList::try_from(vec![CommandCodeAttributes::try_from(u32::from(CommandCode::NvUndefineSpaceSpecial)).expect(
+            "Failed to create CommandCodeAttributes using CommandCode::NvUndefineSpaceSpecia",
+        ); CommandCodeAttributesList::MAX_SIZE + 1]),
+        "Converting a vector with to many elements into a CommandCodeAttributesList did not produce the expected error",
+    );
+
+    assert_eq!(
+        Err(Error::WrapperError(WrapperErrorKind::InvalidParam)),
+        CommandCodeAttributesList::try_from(TPML_CCA {
+            count: CommandCodeAttributesList::MAX_SIZE as u32 + 1u32,
+            commandAttributes: [Default::default(); 256],
+        }),
+        "Converting a TPML_CCA with an invalid 'count' value into a CommandCodeAttributesList did not produce the expected error",
+    );
+}
+
+#[test]
+fn test_find() {
+    let command_code_attributes_list = CommandCodeAttributesList::try_from(vec![
+        CommandCodeAttributes::try_from(u32::from(CommandCode::NvUndefineSpaceSpecial)).expect(
+            "Failed to create CommandCodeAttributes using CommandCode::NvUndefineSpaceSpecial",
+        ),
+        CommandCodeAttributes::try_from(u32::from(CommandCode::EvictControl))
+            .expect("Failed to create CommandCodeAttributes using CommandCode::EvictControl"),
+        CommandCodeAttributes::try_from(u32::from(CommandCode::PcrRead))
+            .expect("Failed to create CommandCodeAttributes using CommandCode::PcrRead"),
+    ])
+    .expect("Failed to convert Vec<CommandCodeAttributes> to CommandCodeAttributesList");
+
+    assert_eq!(
+        &CommandCodeAttributes::try_from(u32::from(CommandCode::NvUndefineSpaceSpecial)).expect(
+            "Failed to create CommandCodeAttributes using CommandCode::NvUndefineSpaceSpecial",
+        ),
+        command_code_attributes_list
+            .find(
+                u16::try_from(u32::from(CommandCode::NvUndefineSpaceSpecial))
+                .expect("Failed to convert CommandCode::NvUndefineSpaceSpecial into command code index")
+            )
+            .expect("Calling 'find' using CommandCode::NvUndefineSpaceSpecial as command code index returned an unexpected 'None'"),
+        "Calling 'find' using CommandCode::NvUndefineSpaceSpecial as command code index did not return the expected CommandCodeAttributes value"
+    );
+
+    assert_eq!(
+        &CommandCodeAttributes::try_from(u32::from(CommandCode::EvictControl)).expect(
+            "Failed to create CommandCodeAttributes using CommandCode::EvictControl",
+        ),
+        command_code_attributes_list
+            .find(
+                u16::try_from(u32::from(CommandCode::EvictControl))
+                .expect("Failed to convert CommandCode::EvictControl into command code index")
+            )
+            .expect("Calling 'find' using CommandCode::NvUndefineSpaceSpecial as command code index returned an unexpected 'None'"),
+        "Calling 'find' using CommandCode::EvictControl as command code index did not return the expected CommandCodeAttributes value"
+    );
+
+    assert!(
+        command_code_attributes_list
+            .find(
+                u16::try_from(u32::from(CommandCode::PcrAllocate))
+                    .expect("Failed to convert CommandCode::PcrRead into command code index")
+            )
+            .is_none(),
+        "A value that should not exist was found in the CommandCodeAttributesList"
+    );
+}

tss-esapi/tests/integration_tests/structures_tests/lists_tests/mod.rs

@@ -1,6 +1,7 @@
 // Copyright 2021 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
 mod algorithm_property_list_tests;
+mod command_code_attributes_list_tests;
 mod command_code_list_tests;
 mod digest_list_tests;
 mod ecc_curve_list_tests;