Adds tests for SymmetricDefinition.

Derives Eq and PartialEq trait for SymmetricDefinition.
Adds tests for SymmetricDefinition.

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

Author: Superhepper

tss-esapi/src/structures/tagged/symmetric.rs

@@ -13,7 +13,7 @@ use std::convert::{TryFrom, TryInto};
 ///
 /// # Details
 /// This corresponds to TPMT_SYM_DEF.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum SymmetricDefinition {
     // TODO: Investigate why TDES is not included...
     Aes {

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

@@ -35,10 +35,12 @@ mod marshall;
 mod tpma_types_equality_checks;
 mod tpml_types_equality_checks;
 mod tpms_types_equality_checks;
+mod tpmt_types_equality_checks;
 pub use marshall::*;
 pub use tpma_types_equality_checks::*;
 pub use tpml_types_equality_checks::*;
 pub use tpms_types_equality_checks::*;
+pub use tpmt_types_equality_checks::*;
 
 #[allow(dead_code)]
 pub const HASH: [u8; 64] = [

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

@@ -0,0 +1,73 @@
+// Copyright 2021 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use tss_esapi::{
+    constants::tss::{TPM2_ALG_AES, TPM2_ALG_CAMELLIA, TPM2_ALG_NULL, TPM2_ALG_SM4, TPM2_ALG_XOR},
+    tss2_esys::TPMT_SYM_DEF,
+};
+
+pub fn ensure_tpmt_sym_def_equality(expected: &TPMT_SYM_DEF, actual: &TPMT_SYM_DEF) {
+    assert_eq!(
+        expected.algorithm, actual.algorithm,
+        "'algorithm' value in TPMT_SYM_DEF, mismatch between actual and expected",
+    );
+
+    match expected.algorithm {
+        TPM2_ALG_AES => {
+            let expected_key_bits = unsafe { expected.keyBits.aes };
+            let expected_mode = unsafe { expected.mode.aes };
+            let actual_key_bits = unsafe { actual.keyBits.aes };
+            let actual_mode = unsafe { actual.mode.aes };
+            assert_eq!(
+                expected_key_bits, actual_key_bits,
+                "'keyBits' value in TPMT_SYM_DEF, mismatch between actual and expected",
+            );
+
+            assert_eq!(
+                expected_mode, actual_mode,
+                "'mode' value in TPMT_SYM_DEF, mismatch between actual and expected",
+            );
+        }
+        TPM2_ALG_SM4 => {
+            let expected_key_bits = unsafe { expected.keyBits.sm4 };
+            let expected_mode = unsafe { expected.mode.sm4 };
+            let actual_key_bits = unsafe { actual.keyBits.sm4 };
+            let actual_mode = unsafe { actual.mode.sm4 };
+            assert_eq!(
+                expected_key_bits, actual_key_bits,
+                "'keyBits' value in TPMT_SYM_DEF, mismatch between actual and expected",
+            );
+
+            assert_eq!(
+                expected_mode, actual_mode,
+                "'mode' value in TPMT_SYM_DEF, mismatch between actual and expected",
+            );
+        }
+        TPM2_ALG_CAMELLIA => {
+            let expected_key_bits = unsafe { expected.keyBits.camellia };
+            let expected_mode = unsafe { expected.mode.camellia };
+            let actual_key_bits = unsafe { actual.keyBits.camellia };
+            let actual_mode = unsafe { actual.mode.camellia };
+            assert_eq!(
+                expected_key_bits, actual_key_bits,
+                "'keyBits' value in TPMT_SYM_DEF, mismatch between actual and expected",
+            );
+
+            assert_eq!(
+                expected_mode, actual_mode,
+                "'mode' value in TPMT_SYM_DEF, mismatch between actual and expected",
+            );
+        }
+        TPM2_ALG_XOR => {
+            let expected_key_bits = unsafe { expected.keyBits.exclusiveOr };
+            let actual_key_bits = unsafe { actual.keyBits.exclusiveOr };
+            assert_eq!(
+                expected_key_bits, actual_key_bits,
+                "'keyBits' value in TPMT_SYM_DEF, mismatch between actual and expected",
+            );
+        }
+        TPM2_ALG_NULL => {}
+        _ => {
+            panic!("Invalid algorithm in TPMT_SYM_DEF");
+        }
+    }
+}

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

@@ -6,4 +6,5 @@ mod public_rsa_exponent_tests;
 mod public_rsa_parameters_tests;
 mod sensitive;
 mod signature;
+mod symmetric_definition_tests;
 mod tagged_signature_scheme_tests;

tss-esapi/tests/integration_tests/structures_tests/tagged_tests/symmetric_definition_tests.rs

@@ -0,0 +1,244 @@
+// Copyright 2022 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use tss_esapi::{
+    constants::AlgorithmIdentifier,
+    interface_types::{
+        algorithm::{HashingAlgorithm, SymmetricAlgorithm, SymmetricMode},
+        key_bits::{AesKeyBits, CamelliaKeyBits, Sm4KeyBits},
+    },
+    structures::SymmetricDefinition,
+    tss2_esys::{TPMT_SYM_DEF, TPMU_SYM_KEY_BITS, TPMU_SYM_MODE},
+    Error, WrapperErrorKind,
+};
+
+use std::convert::TryFrom;
+
+const SYM_MODES: [SymmetricMode; 5] = [
+    SymmetricMode::Cfb,
+    SymmetricMode::Cbc,
+    SymmetricMode::Ctr,
+    SymmetricMode::Ecb,
+    SymmetricMode::Ofb,
+];
+
+#[test]
+fn test_valid_aes_conversions() {
+    const AES_KEY_BITS: [AesKeyBits; 3] =
+        [AesKeyBits::Aes128, AesKeyBits::Aes192, AesKeyBits::Aes256];
+    for expected_mode in SYM_MODES {
+        for expected_key_bits in AES_KEY_BITS {
+            let expected_tpmt_sym_def = TPMT_SYM_DEF {
+                algorithm: SymmetricAlgorithm::Aes.into(),
+                keyBits: TPMU_SYM_KEY_BITS {
+                    aes: expected_key_bits.into(),
+                },
+                mode: TPMU_SYM_MODE {
+                    aes: expected_mode.into(),
+                },
+            };
+
+            let sym_def = SymmetricDefinition::try_from(expected_tpmt_sym_def)
+                .expect("Failed to convert TPMT_SYM_DEF into SymmetricDefinition");
+
+            if let SymmetricDefinition::Aes { key_bits, mode } = sym_def {
+                assert_eq!(
+                    expected_key_bits, key_bits, "TPMT_SYM_DEF converted into SymmetricDefinition did not contain the correct value for 'key_bits'"
+                );
+                assert_eq!(expected_mode, mode,  "TPMT_SYM_DEF converted into SymmetricDefinition did not contain the correct value for 'mode'");
+            } else {
+                panic!("SymmetricDefinition converted from TPMT_SYM_DEF did not contain the expected algorithm AES");
+            }
+
+            let actual_tpmt_sym_def = TPMT_SYM_DEF::try_from(sym_def)
+                .expect("Failed to Convert SymmetricDefinition into TPMT_SYM_DEF");
+
+            crate::common::ensure_tpmt_sym_def_equality(
+                &expected_tpmt_sym_def,
+                &actual_tpmt_sym_def,
+            );
+        }
+    }
+}
+
+#[test]
+fn test_valid_sm4_conversions() {
+    for expected_mode in SYM_MODES {
+        let expected_key_bits = Sm4KeyBits::Sm4_128;
+        let expected_tpmt_sym_def = TPMT_SYM_DEF {
+            algorithm: SymmetricAlgorithm::Sm4.into(),
+            keyBits: TPMU_SYM_KEY_BITS {
+                sm4: expected_key_bits.into(),
+            },
+            mode: TPMU_SYM_MODE {
+                sm4: expected_mode.into(),
+            },
+        };
+
+        let sym_def = SymmetricDefinition::try_from(expected_tpmt_sym_def)
+            .expect("Failed to convert TPMT_SYM_DEF into SymmetricDefinition");
+
+        if let SymmetricDefinition::Sm4 { key_bits, mode } = sym_def {
+            assert_eq!(
+                    expected_key_bits, key_bits, "TPMT_SYM_DEF converted into SymmetricDefinition did not contain the correct value for 'key_bits'"
+                );
+            assert_eq!(expected_mode, mode,  "TPMT_SYM_DEF converted into SymmetricDefinition did not contain the correct value for 'mode'");
+        } else {
+            panic!("SymmetricDefinition converted from TPMT_SYM_DEF did not contain the expected algorithm SM4");
+        }
+
+        let actual_tpmt_sym_def = TPMT_SYM_DEF::try_from(sym_def)
+            .expect("Failed to Convert SymmetricDefinition into TPMT_SYM_DEF");
+
+        crate::common::ensure_tpmt_sym_def_equality(&expected_tpmt_sym_def, &actual_tpmt_sym_def);
+    }
+}
+
+#[test]
+fn test_valid_camellia_conversions() {
+    const CAMELLIA_KEY_BITS: [CamelliaKeyBits; 3] = [
+        CamelliaKeyBits::Camellia128,
+        CamelliaKeyBits::Camellia192,
+        CamelliaKeyBits::Camellia256,
+    ];
+    for expected_mode in SYM_MODES {
+        for expected_key_bits in CAMELLIA_KEY_BITS {
+            let expected_tpmt_sym_def = TPMT_SYM_DEF {
+                algorithm: SymmetricAlgorithm::Camellia.into(),
+                keyBits: TPMU_SYM_KEY_BITS {
+                    camellia: expected_key_bits.into(),
+                },
+                mode: TPMU_SYM_MODE {
+                    camellia: expected_mode.into(),
+                },
+            };
+
+            let sym_def = SymmetricDefinition::try_from(expected_tpmt_sym_def)
+                .expect("Failed to convert TPMT_SYM_DEF into SymmetricDefinition");
+
+            if let SymmetricDefinition::Camellia { key_bits, mode } = sym_def {
+                assert_eq!(
+                    expected_key_bits, key_bits, "TPMT_SYM_DEF converted into SymmetricDefinition did not contain the correct value for 'key_bits'"
+                );
+                assert_eq!(expected_mode, mode,  "TPMT_SYM_DEF converted into SymmetricDefinition did not contain the correct value for 'mode'");
+            } else {
+                panic!("SymmetricDefinition converted from TPMT_SYM_DEF did not contain the expected algorithm CAMELLIA");
+            }
+
+            let actual_tpmt_sym_def = TPMT_SYM_DEF::try_from(sym_def)
+                .expect("Failed to Convert SymmetricDefinition into TPMT_SYM_DEF");
+
+            crate::common::ensure_tpmt_sym_def_equality(
+                &expected_tpmt_sym_def,
+                &actual_tpmt_sym_def,
+            );
+        }
+    }
+}
+
+#[test]
+fn test_valid_xor_conversions() {
+    const HASHING_ALGORITHMS: [HashingAlgorithm; 8] = [
+        HashingAlgorithm::Sha1,
+        HashingAlgorithm::Sha256,
+        HashingAlgorithm::Sha384,
+        HashingAlgorithm::Sha512,
+        HashingAlgorithm::Sm3_256,
+        HashingAlgorithm::Sha3_256,
+        HashingAlgorithm::Sha3_384,
+        HashingAlgorithm::Sha3_512,
+    ];
+    for expected_hashing_algorithm in HASHING_ALGORITHMS {
+        let expected_tpmt_sym_def = TPMT_SYM_DEF {
+            algorithm: SymmetricAlgorithm::Xor.into(),
+            keyBits: TPMU_SYM_KEY_BITS {
+                exclusiveOr: expected_hashing_algorithm.into(),
+            },
+            mode: Default::default(),
+        };
+
+        let sym_def = SymmetricDefinition::try_from(expected_tpmt_sym_def)
+            .expect("Failed to convert TPMT_SYM_DEF into SymmetricDefinition");
+
+        if let SymmetricDefinition::Xor { hashing_algorithm } = sym_def {
+            assert_eq!(
+                expected_hashing_algorithm,
+                hashing_algorithm,
+                "TPMT_SYM_DEF converted into SymmetricDefinition did not contain the correct value for 'key_bits'",
+                );
+        } else {
+            panic!("SymmetricDefinition converted from TPMT_SYM_DEF did not contain the expected algorithm XOR");
+        }
+
+        let actual_tpmt_sym_def = TPMT_SYM_DEF::try_from(sym_def)
+            .expect("Failed to Convert SymmetricDefinition into TPMT_SYM_DEF");
+
+        crate::common::ensure_tpmt_sym_def_equality(&expected_tpmt_sym_def, &actual_tpmt_sym_def);
+    }
+}
+
+#[test]
+fn test_valid_null_conversions() {
+    let expected_tpmt_sym_def = TPMT_SYM_DEF {
+        algorithm: SymmetricAlgorithm::Null.into(),
+        keyBits: Default::default(),
+        mode: Default::default(),
+    };
+
+    let sym_def = SymmetricDefinition::try_from(expected_tpmt_sym_def)
+        .expect("Failed to convert TPMT_SYM_DEF into SymmetricDefinition");
+
+    if sym_def != SymmetricDefinition::Null {
+        panic!("SymmetricDefinition converted from TPMT_SYM_DEF did not contain the expected algorithm NULL");
+    }
+
+    let actual_tpmt_sym_def = TPMT_SYM_DEF::try_from(sym_def)
+        .expect("Failed to Convert SymmetricDefinition into TPMT_SYM_DEF");
+
+    crate::common::ensure_tpmt_sym_def_equality(&expected_tpmt_sym_def, &actual_tpmt_sym_def);
+}
+
+#[test]
+fn test_invalid_symmetric_algorithm_conversion() {
+    let invalid_alg_tpmt_sym_def = TPMT_SYM_DEF {
+        algorithm: AlgorithmIdentifier::RsaPss.into(),
+        keyBits: Default::default(),
+        mode: Default::default(),
+    };
+
+    assert_eq!(
+        Err(Error::WrapperError(WrapperErrorKind::InvalidParam)),
+        SymmetricDefinition::try_from(invalid_alg_tpmt_sym_def),
+        "Converting TPMT_SYM_DEF with an invalid symmetric algorithm did not produce the expected error"
+    );
+}
+
+#[test]
+fn test_invalid_xor_with_null_conversions() {
+    let invalid_alg_tpmt_sym_def = TPMT_SYM_DEF {
+        algorithm: SymmetricAlgorithm::Xor.into(),
+        keyBits: TPMU_SYM_KEY_BITS {
+            exclusiveOr: HashingAlgorithm::Null.into(),
+        },
+        mode: Default::default(),
+    };
+
+    assert_eq!(
+        Err(Error::WrapperError(WrapperErrorKind::InvalidParam)),
+        SymmetricDefinition::try_from(invalid_alg_tpmt_sym_def),
+        "Converting TPMT_SYM_DEF with an invalid XOR hashing algorithm did not produce the expected error"
+    );
+
+    let invalid_sym_def = SymmetricDefinition::Xor {
+        hashing_algorithm: HashingAlgorithm::Null,
+    };
+
+    if let Err(actual_error) = TPMT_SYM_DEF::try_from(invalid_sym_def) {
+        assert_eq!(
+            Error::WrapperError(WrapperErrorKind::InvalidParam),
+            actual_error,
+            "Converting SymmetricDefinition with invalid XOR hashing algorithm did not produce the expected error"
+        );
+    } else {
+        panic!("Converting SymmetricDefinition with invalid XOR hashing algorithm did not produce an error");
+    }
+}