Added tests for public parameters.

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

Author: Superhepper

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

@@ -14,7 +14,7 @@ use std::convert::{TryFrom, TryInto};
 ///
 /// # Details
 /// This corresponds to TPMT_PUBLIC_PARMS
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PublicParameters {
     Rsa(PublicRsaParameters),
     KeyedHash(PublicKeyedHashParameters),

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

@@ -1,13 +1,17 @@
+// Copyright 2021 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
 use tss_esapi::{
     constants::tss::{
         TPM2_ST_ATTEST_CERTIFY, TPM2_ST_ATTEST_COMMAND_AUDIT, TPM2_ST_ATTEST_CREATION,
         TPM2_ST_ATTEST_NV, TPM2_ST_ATTEST_QUOTE, TPM2_ST_ATTEST_SESSION_AUDIT, TPM2_ST_ATTEST_TIME,
     },
     tss2_esys::{
         TPMS_ALG_PROPERTY, TPMS_ATTEST, TPMS_CERTIFY_INFO, TPMS_CLOCK_INFO,
-        TPMS_COMMAND_AUDIT_INFO, TPMS_CREATION_INFO, TPMS_NV_CERTIFY_INFO, TPMS_PCR_SELECTION,
-        TPMS_QUOTE_INFO, TPMS_SESSION_AUDIT_INFO, TPMS_TAGGED_PCR_SELECT, TPMS_TAGGED_PROPERTY,
-        TPMS_TIME_ATTEST_INFO, TPMS_TIME_INFO,
+        TPMS_COMMAND_AUDIT_INFO, TPMS_CREATION_INFO, TPMS_ECC_PARMS, TPMS_KEYEDHASH_PARMS,
+        TPMS_NV_CERTIFY_INFO, TPMS_PCR_SELECTION, TPMS_QUOTE_INFO, TPMS_RSA_PARMS,
+        TPMS_SCHEME_ECDAA, TPMS_SCHEME_HASH, TPMS_SCHEME_HMAC, TPMS_SCHEME_XOR,
+        TPMS_SESSION_AUDIT_INFO, TPMS_SYMCIPHER_PARMS, TPMS_TAGGED_PCR_SELECT,
+        TPMS_TAGGED_PROPERTY, TPMS_TIME_ATTEST_INFO, TPMS_TIME_INFO,
     },
 };
 
@@ -243,3 +247,77 @@ pub fn ensure_tpms_tagged_pcr_select_equality(
         "'pcrSelect' value TPMS_TAGGED_PCR_SELECT, mismatch between actual and expected"
     );
 }
+
+pub fn ensure_tpms_rsa_parms_equality(expected: &TPMS_RSA_PARMS, actual: &TPMS_RSA_PARMS) {
+    crate::common::ensure_tpmt_sym_def_object_equality(&expected.symmetric, &actual.symmetric);
+    crate::common::ensure_tpmt_rsa_scheme_equality(&expected.scheme, &actual.scheme);
+    assert_eq!(
+        expected.keyBits, actual.keyBits,
+        "'keyBits' value TPMS_RSA_PARMS, mismatch between actual and expected"
+    );
+
+    assert_eq!(
+        expected.exponent, actual.exponent,
+        "'exponent' value TPMS_RSA_PARMS, mismatch between actual and expected"
+    );
+}
+
+pub fn ensure_tpms_scheme_hash_equality(expected: &TPMS_SCHEME_HASH, actual: &TPMS_SCHEME_HASH) {
+    assert_eq!(
+        expected.hashAlg, actual.hashAlg,
+        "'hashAlg' value TPMS_SCHEME_HASH, mismatch between actual and expected"
+    );
+}
+
+pub fn ensure_tpms_ecc_parms_equality(expected: &TPMS_ECC_PARMS, actual: &TPMS_ECC_PARMS) {
+    crate::common::ensure_tpmt_sym_def_object_equality(&expected.symmetric, &actual.symmetric);
+    crate::common::ensure_tpmt_ecc_scheme_equality(&expected.scheme, &actual.scheme);
+    assert_eq!(
+        expected.curveID, actual.curveID,
+        "'curveID' value TPMS_ECC_PARMS, mismatch between actual and expected"
+    );
+    crate::common::ensure_tpmt_kdf_scheme_equality(&expected.kdf, &actual.kdf);
+}
+
+pub fn ensure_tpms_scheme_ecdaa_equality(expected: &TPMS_SCHEME_ECDAA, actual: &TPMS_SCHEME_ECDAA) {
+    assert_eq!(
+        expected.hashAlg, actual.hashAlg,
+        "'hashAlg' value TPMS_SCHEME_ECDAA, mismatch between actual and expected"
+    );
+    assert_eq!(
+        expected.count, actual.count,
+        "'count' value TPMS_SCHEME_ECDAA, mismatch between actual and expected"
+    );
+}
+
+pub fn ensure_tpms_keyedhash_parms_equality(
+    expected: &TPMS_KEYEDHASH_PARMS,
+    actual: &TPMS_KEYEDHASH_PARMS,
+) {
+    crate::common::ensure_tpmt_keyedhash_scheme_equality(&expected.scheme, &actual.scheme);
+}
+
+pub fn ensure_tpms_scheme_xor_equality(expected: &TPMS_SCHEME_XOR, actual: &TPMS_SCHEME_XOR) {
+    assert_eq!(
+        expected.hashAlg, actual.hashAlg,
+        "'hashAlg' value TPMS_SCHEME_XOR, mismatch between actual and expected"
+    );
+    assert_eq!(
+        expected.kdf, actual.kdf,
+        "'count' value TPMS_SCHEME_XOR, mismatch between actual and expected"
+    );
+}
+
+pub fn ensure_tpms_scheme_hmac_equality(expected: &TPMS_SCHEME_HMAC, actual: &TPMS_SCHEME_HMAC) {
+    assert_eq!(
+        expected.hashAlg, actual.hashAlg,
+        "'hashAlg' value TPMS_SCHEME_HMAC, mismatch between actual and expected"
+    );
+}
+
+pub fn ensure_tpms_symcipher_parms_equality(
+    expected: &TPMS_SYMCIPHER_PARMS,
+    actual: &TPMS_SYMCIPHER_PARMS,
+) {
+    crate::common::ensure_tpmt_sym_def_object_equality(&expected.sym, &actual.sym)
+}

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

@@ -1,8 +1,17 @@
 // 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, TPMT_SYM_DEF_OBJECT},
+    constants::tss::{
+        TPM2_ALG_AES, TPM2_ALG_CAMELLIA, TPM2_ALG_ECC, TPM2_ALG_ECDAA, TPM2_ALG_ECDH,
+        TPM2_ALG_ECDSA, TPM2_ALG_ECMQV, TPM2_ALG_ECSCHNORR, TPM2_ALG_HMAC, TPM2_ALG_KDF1_SP800_108,
+        TPM2_ALG_KDF1_SP800_56A, TPM2_ALG_KDF2, TPM2_ALG_KEYEDHASH, TPM2_ALG_MGF1, TPM2_ALG_NULL,
+        TPM2_ALG_OAEP, TPM2_ALG_RSA, TPM2_ALG_RSAES, TPM2_ALG_RSAPSS, TPM2_ALG_RSASSA,
+        TPM2_ALG_SM2, TPM2_ALG_SM4, TPM2_ALG_SYMCIPHER, TPM2_ALG_XOR,
+    },
+    tss2_esys::{
+        TPMT_ECC_SCHEME, TPMT_KDF_SCHEME, TPMT_KEYEDHASH_SCHEME, TPMT_PUBLIC_PARMS,
+        TPMT_RSA_SCHEME, TPMT_SYM_DEF, TPMT_SYM_DEF_OBJECT,
+    },
 };
 
 pub fn ensure_tpmt_sym_def_equality(expected: &TPMT_SYM_DEF, actual: &TPMT_SYM_DEF) {
@@ -133,3 +142,197 @@ pub fn ensure_tpmt_sym_def_object_equality(
         }
     }
 }
+
+pub fn ensure_tpmt_public_parms_equality(expected: &TPMT_PUBLIC_PARMS, actual: &TPMT_PUBLIC_PARMS) {
+    assert_eq!(
+        expected.type_, actual.type_,
+        "'type_' value in TPMT_PUBLIC_PARMS, mismatch between actual and expected",
+    );
+
+    match expected.type_ {
+        TPM2_ALG_RSA => {
+            let expected_rsa_parms = unsafe { &expected.parameters.rsaDetail };
+            let actual_rsa_parms = unsafe { &actual.parameters.rsaDetail };
+            crate::common::ensure_tpms_rsa_parms_equality(expected_rsa_parms, actual_rsa_parms);
+        }
+        TPM2_ALG_KEYEDHASH => {
+            let expected_keyed_hash_parms = unsafe { &expected.parameters.keyedHashDetail };
+            let actual_keyed_hash_parms = unsafe { &actual.parameters.keyedHashDetail };
+            crate::common::ensure_tpms_keyedhash_parms_equality(
+                expected_keyed_hash_parms,
+                actual_keyed_hash_parms,
+            );
+        }
+        TPM2_ALG_ECC => {
+            let expected_ecc_parms = unsafe { &expected.parameters.eccDetail };
+            let actual_ecc_parms = unsafe { &actual.parameters.eccDetail };
+            crate::common::ensure_tpms_ecc_parms_equality(expected_ecc_parms, actual_ecc_parms);
+        }
+        TPM2_ALG_SYMCIPHER => {
+            let expected_symcipher_parms = unsafe { &expected.parameters.symDetail };
+            let actual_symcipher_parms = unsafe { &actual.parameters.symDetail };
+            crate::common::ensure_tpms_symcipher_parms_equality(
+                expected_symcipher_parms,
+                actual_symcipher_parms,
+            );
+        }
+        _ => {
+            panic!("Invalid algorithm in TPMT_PUBLIC_PARMS");
+        }
+    }
+}
+
+pub fn ensure_tpmt_rsa_scheme_equality(expected: &TPMT_RSA_SCHEME, actual: &TPMT_RSA_SCHEME) {
+    assert_eq!(
+        expected.scheme, actual.scheme,
+        "'scheme' value in TPMT_RSA_SCHEME, mismatch between actual and expected",
+    );
+
+    match expected.scheme {
+        TPM2_ALG_RSASSA => {
+            let expected_hash_scheme = unsafe { &expected.details.rsassa };
+            let actual_hash_scheme = unsafe { &actual.details.rsassa };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_RSAES => {}
+        TPM2_ALG_RSAPSS => {
+            let expected_hash_scheme = unsafe { &expected.details.rsapss };
+            let actual_hash_scheme = unsafe { &actual.details.rsapss };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_OAEP => {
+            let expected_hash_scheme = unsafe { &expected.details.oaep };
+            let actual_hash_scheme = unsafe { &actual.details.oaep };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_NULL => {}
+        _ => panic!("Invalid algorithm in TPMT_RSA_SCHEME"),
+    }
+}
+
+pub fn ensure_tpmt_ecc_scheme_equality(expected: &TPMT_ECC_SCHEME, actual: &TPMT_ECC_SCHEME) {
+    assert_eq!(
+        expected.scheme, actual.scheme,
+        "'scheme' value in TPMT_ECC_SCHEME, mismatch between actual and expected",
+    );
+    match expected.scheme {
+        TPM2_ALG_ECDSA => {
+            let expected_hash_scheme = unsafe { &expected.details.ecdsa };
+            let actual_hash_scheme = unsafe { &actual.details.ecdsa };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_ECDH => {
+            let expected_hash_scheme = unsafe { &expected.details.ecdh };
+            let actual_hash_scheme = unsafe { &actual.details.ecdh };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_ECDAA => {
+            let expected_ecdaa_scheme = unsafe { &expected.details.ecdaa };
+            let actual_ecdaa_scheme = unsafe { &actual.details.ecdaa };
+            crate::common::ensure_tpms_scheme_ecdaa_equality(
+                expected_ecdaa_scheme,
+                actual_ecdaa_scheme,
+            );
+        }
+        TPM2_ALG_SM2 => {
+            let expected_hash_scheme = unsafe { &expected.details.sm2 };
+            let actual_hash_scheme = unsafe { &actual.details.sm2 };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_ECSCHNORR => {
+            let expected_hash_scheme = unsafe { &expected.details.ecschnorr };
+            let actual_hash_scheme = unsafe { &actual.details.ecschnorr };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_ECMQV => {
+            let expected_hash_scheme = unsafe { &expected.details.ecmqv };
+            let actual_hash_scheme = unsafe { &actual.details.ecmqv };
+            crate::common::ensure_tpms_scheme_hash_equality(
+                expected_hash_scheme,
+                actual_hash_scheme,
+            );
+        }
+        TPM2_ALG_NULL => {}
+        _ => panic!("Invalid algorithm in TPMT_ECC_SCHEME"),
+    }
+}
+
+pub fn ensure_tpmt_keyedhash_scheme_equality(
+    expected: &TPMT_KEYEDHASH_SCHEME,
+    actual: &TPMT_KEYEDHASH_SCHEME,
+) {
+    assert_eq!(
+        expected.scheme, actual.scheme,
+        "'scheme' value in TPMT_KEYEDHASH_SCHEME, mismatch between actual and expected",
+    );
+    match expected.scheme {
+        TPM2_ALG_XOR => {
+            let expected_xor_scheme = unsafe { &expected.details.exclusiveOr };
+            let actual_xor_scheme = unsafe { &actual.details.exclusiveOr };
+            crate::common::ensure_tpms_scheme_xor_equality(expected_xor_scheme, actual_xor_scheme);
+        }
+        TPM2_ALG_HMAC => {
+            let expected_hmac_scheme = unsafe { &expected.details.hmac };
+            let actual_hmac_scheme = unsafe { &actual.details.hmac };
+            crate::common::ensure_tpms_scheme_hmac_equality(
+                expected_hmac_scheme,
+                actual_hmac_scheme,
+            );
+        }
+        TPM2_ALG_NULL => {}
+        _ => panic!("Invalid algorithm in TPMT_KEYEDHASH_SCHEME"),
+    }
+}
+
+pub fn ensure_tpmt_kdf_scheme_equality(expected: &TPMT_KDF_SCHEME, actual: &TPMT_KDF_SCHEME) {
+    assert_eq!(
+        expected.scheme, actual.scheme,
+        "'scheme' value in TPMT_KDF_SCHEME, mismatch between actual and expected",
+    );
+
+    match expected.scheme {
+        TPM2_ALG_KDF1_SP800_56A => {
+            let expected_scheme = unsafe { &expected.details.kdf1_sp800_56a };
+            let actual_scheme = unsafe { &actual.details.kdf1_sp800_56a };
+            crate::common::ensure_tpms_scheme_hash_equality(expected_scheme, actual_scheme);
+        }
+        TPM2_ALG_KDF2 => {
+            let expected_scheme = unsafe { &expected.details.kdf2 };
+            let actual_scheme = unsafe { &actual.details.kdf2 };
+            crate::common::ensure_tpms_scheme_hash_equality(expected_scheme, actual_scheme);
+        }
+        TPM2_ALG_KDF1_SP800_108 => {
+            let expected_scheme = unsafe { &expected.details.kdf1_sp800_108 };
+            let actual_scheme = unsafe { &actual.details.kdf1_sp800_108 };
+            crate::common::ensure_tpms_scheme_hash_equality(expected_scheme, actual_scheme);
+        }
+        TPM2_ALG_MGF1 => {
+            let expected_scheme = unsafe { &expected.details.mgf1 };
+            let actual_scheme = unsafe { &actual.details.mgf1 };
+            crate::common::ensure_tpms_scheme_hash_equality(expected_scheme, actual_scheme);
+        }
+        TPM2_ALG_NULL => {}
+        _ => panic!("Invalid algorithm in TPMT_KDF_SCHEME"),
+    }
+}

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

@@ -1,5 +1,6 @@
 // Copyright 2021 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
+mod parameters_tests;
 mod public;
 mod public_ecc_parameters_tests;
 mod public_rsa_exponent_tests;