HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/test/test-tpm2.c
Git blob: 82c452a8a61c5f88a9c88ae0bf31a4f4256bcb86
Lines 2001–2387 of 2,387
},
};
_cleanup_(sd_json_variant_unrefp) sd_json_variant *eccv = NULL;
ASSERT_OK(tpm2_tpmt_signature_to_json(&ecc_sig, &eccv));
_cleanup_free_ char *ecc_json = NULL;
ASSERT_OK(sd_json_variant_format(eccv, 0, &ecc_json));
ASSERT_STREQ(ecc_json, "{\"sigAlg\":\"ECDSA\",\"signature\":{\"hash\":\"SHA384\",\"signatureR\":\"d9eb686422a6fb9a64a5cf9806495d7e787f11b77f5f5928680c02558a2467ec526f04a9745dc4f196248dd2198a17d4\",\"signatureS\":\"8e9f92622c4cd4c00ae4c551feecbc4e0cc5b321e023acf6f8b67f9075ecac5c9cea3cd1b6d76055a46c20ecd080d2cf\"}}");
}
TEST(tpm2_attest_info_to_json) {
TPMT_SIG_SCHEME scheme1 = {
.scheme = TPM2_ALG_RSAPSS,
.details.rsapss.hashAlg = TPM2_ALG_SHA256,
};
DEFINE_HEX_PTR(signer1, "000b8f80817492905f8b4014186c828a5e0191d5146c70e644af0605e2cdd2093bfd");
TPML_PCR_SELECTION pcrs;
tpm2_tpml_pcr_selection_from_mask(64191, TPM2_ALG_SHA256, &pcrs);
DEFINE_HEX_PTR(pcr_digest, "4cdecd069d7522065dfa70e6d31292fe87ee99d0053d5582abddb2a6b5c2640c");
TPMS_ATTEST attest1 = {
.magic = TPM2_GENERATED_VALUE,
.type = TPM2_ST_ATTEST_QUOTE,
.qualifiedSigner = TPM2B_NAME_MAKE(signer1, signer1_len),
.clockInfo = {
.clock = 8726451,
.resetCount = 72,
.restartCount = 0,
.safe = TPM2_YES,
},
.firmwareVersion = 4294967300,
.attested.quote = {
.pcrSelect = pcrs,
.pcrDigest = TPM2B_DIGEST_MAKE(pcr_digest, pcr_digest_len),
},
};
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v1 = NULL;
ASSERT_OK(tpm2_attest_info_to_json(&scheme1, &attest1, &v1));
_cleanup_free_ char *json1 = NULL;
ASSERT_OK(sd_json_variant_format(v1, 0, &json1));
ASSERT_STREQ(json1, "{\"sig_scheme\":{\"scheme\":\"RSAPSS\",\"details\":{\"hashAlg\":\"SHA256\"}},\"attest\":{\"magic\":\"VALUE\",\"type\":\"ATTEST_QUOTE\",\"qualifiedSigner\":\"000b8f80817492905f8b4014186c828a5e0191d5146c70e644af0605e2cdd2093bfd\",\"extraData\":\"\",\"clockInfo\":{\"clock\":8726451,\"resetCount\":72,\"restartCount\":0,\"safe\":\"YES\"},\"firmwareVersion\":4294967300,\"attested\":{\"pcrSelect\":[{\"hash\":\"SHA256\",\"pcrSelect\":[0,1,2,3,4,5,7,9,11,12,13,14,15]}],\"pcrDigest\":\"4cdecd069d7522065dfa70e6d31292fe87ee99d0053d5582abddb2a6b5c2640c\"}}}");
TPMT_SIG_SCHEME scheme2 = {
.scheme = TPM2_ALG_ECDSA,
.details.ecdsa.hashAlg = TPM2_ALG_SHA384,
};
DEFINE_HEX_PTR(signer2, "000cf8d4b1e869e68f96f37b3cbe1106fd5566fa2de9ffbe3ab5a7b9a3193e10e35e7072bd7c3d3c4d081c931511e7aa5166");
DEFINE_HEX_PTR(extra_data, "000b7c88777e5165ac16f59fb7f74c6d54a2f77a2266974d6f811f2d4ee575203667");
DEFINE_HEX_PTR(nv_name, "000b743f1f9cf4b7e7f0e4e5d234d72310b4661c2b30d51801c8096e104325ccce9d");
DEFINE_HEX_PTR(nv_contents, "aefb5cd55ce0546baacb0ed96440eb796a0f10091f5c22b3c3b1d207ed338c7e");
TPMS_ATTEST attest2 = {
.magic = TPM2_GENERATED_VALUE,
.type = TPM2_ST_ATTEST_NV,
.qualifiedSigner = TPM2B_NAME_MAKE(signer2, signer2_len),
.extraData = TPM2B_DATA_MAKE(extra_data, extra_data_len),
.clockInfo = {
.clock = 25924398,
.resetCount = 151,
.restartCount = 1,
.safe = TPM2_YES,
},
.firmwareVersion = 8589934602,
.attested.nv = {
.indexName = TPM2B_NAME_MAKE(nv_name, nv_name_len),
.offset = 0,
.nvContents = TPM2B_MAX_NV_BUFFER_MAKE(nv_contents, nv_contents_len),
},
};
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v2 = NULL;
ASSERT_OK(tpm2_attest_info_to_json(&scheme2, &attest2, &v2));
_cleanup_free_ char *json2 = NULL;
ASSERT_OK(sd_json_variant_format(v2, 0, &json2));
ASSERT_STREQ(json2, "{\"sig_scheme\":{\"scheme\":\"ECDSA\",\"details\":{\"hashAlg\":\"SHA384\"}},\"attest\":{\"magic\":\"VALUE\",\"type\":\"ATTEST_NV\",\"qualifiedSigner\":\"000cf8d4b1e869e68f96f37b3cbe1106fd5566fa2de9ffbe3ab5a7b9a3193e10e35e7072bd7c3d3c4d081c931511e7aa5166\",\"extraData\":\"000b7c88777e5165ac16f59fb7f74c6d54a2f77a2266974d6f811f2d4ee575203667\",\"clockInfo\":{\"clock\":25924398,\"resetCount\":151,\"restartCount\":1,\"safe\":\"YES\"},\"firmwareVersion\":8589934602,\"attested\":{\"indexName\":\"000b743f1f9cf4b7e7f0e4e5d234d72310b4661c2b30d51801c8096e104325ccce9d\",\"offset\":0,\"nvContents\":\"aefb5cd55ce0546baacb0ed96440eb796a0f10091f5c22b3c3b1d207ed338c7e\"}}}");
}
TEST(tpm2_tpmt_public_to_json) {
const char *rsa_h =
"615fc18fec08de00721ae55823d2e2c631fe3d7cb2bd7117a40d9be3cd7623c386db5c60ebcdccca39443c1203297f91b59945544efc7977e16e202e5938a37b"
"ae31ee0b7e5249fe7f76f36c94428b3e0f0d53b730270dbb44b3c007a0b45733018f1d8feba462a5e67c7b87a5b913e4a606e105f97828732491686be253d0d7"
"f20ad3450ae7b86fe36a7163013487c2659fe56420623241edbd1ecc9c6d2443143a4db68f6c449008e8b4fec5ad5b56598ffd22f67d317e46e4c48e693c38ee"
"389886b1084e51cfe56408e7e8eee1ab65615d36aff585e25fb198df519b961054b6cfae85717ba387c597146f4d36e548101409a1ceddf321571d3364c968ef";
DEFINE_HEX_PTR(rsa, rsa_h);
TPMT_PUBLIC rsa_public = {
.type = TPM2_ALG_RSA,
.nameAlg = TPM2_ALG_SHA256,
.objectAttributes =
TPMA_OBJECT_FIXEDTPM |
TPMA_OBJECT_FIXEDPARENT |
TPMA_OBJECT_SENSITIVEDATAORIGIN |
TPMA_OBJECT_USERWITHAUTH |
TPMA_OBJECT_ADMINWITHPOLICY |
TPMA_OBJECT_RESTRICTED |
TPMA_OBJECT_SIGN_ENCRYPT,
.parameters.rsaDetail = {
.symmetric.algorithm = TPM2_ALG_NULL,
.scheme = {
.scheme = TPM2_ALG_RSAPSS,
.details.rsapss.hashAlg = TPM2_ALG_SHA256,
},
.keyBits = 2048,
.exponent = 0,
},
.unique.rsa = TPM2B_PUBLIC_KEY_RSA_MAKE(rsa, rsa_len),
};
_cleanup_(sd_json_variant_unrefp) sd_json_variant *rsav = NULL;
ASSERT_OK(tpm2_tpmt_public_to_json(&rsa_public, &rsav));
_cleanup_free_ char *rsa_json = NULL;
ASSERT_OK(sd_json_variant_format(rsav, 0, &rsa_json));
_cleanup_free_ char *rsa_expected = NULL;
ASSERT_OK(asprintf(&rsa_expected, "{\"type\":\"RSA\",\"nameAlg\":\"SHA256\",\"objectAttributes\":327922,\"authPolicy\":\"\",\"parameters\":{\"symmetric\":{\"algorithm\":\"NULL\"},\"scheme\":{\"scheme\":\"RSAPSS\",\"details\":{\"hashAlg\":\"SHA256\"}},\"keyBits\":2048,\"exponent\":0},\"unique\":\"%s\"}", rsa_h));
ASSERT_STREQ(rsa_json, rsa_expected);
DEFINE_HEX_PTR(ecc_x, "6381d4a6aebcc46d5968efa80665820ed8b2ea8069e62ddfa28130f7a823620bf44e0779e2b9fe18c9f8b783800e7c2c");
DEFINE_HEX_PTR(ecc_y, "473fcbe01831c3be463dcc0093a34eb8196e095671bc10e38e0c8fb3ae459c50a408dfe45142fada5fc29bee6580c51e");
TPMT_PUBLIC ecc_public = {
.type = TPM2_ALG_ECC,
.nameAlg = TPM2_ALG_SHA384,
.objectAttributes =
TPMA_OBJECT_FIXEDTPM |
TPMA_OBJECT_FIXEDPARENT |
TPMA_OBJECT_SENSITIVEDATAORIGIN |
TPMA_OBJECT_USERWITHAUTH |
TPMA_OBJECT_ADMINWITHPOLICY |
TPMA_OBJECT_RESTRICTED |
TPMA_OBJECT_SIGN_ENCRYPT,
.parameters.eccDetail = {
.symmetric.algorithm = TPM2_ALG_NULL,
.scheme = {
.scheme = TPM2_ALG_ECDSA,
.details.ecdsa.hashAlg = TPM2_ALG_SHA384,
},
.curveID = TPM2_ECC_NIST_P384,
.kdf.scheme = TPM2_ALG_NULL,
},
.unique.ecc = {
.x = TPM2B_ECC_PARAMETER_MAKE(ecc_x, ecc_x_len),
.y = TPM2B_ECC_PARAMETER_MAKE(ecc_y, ecc_y_len),
},
};
_cleanup_(sd_json_variant_unrefp) sd_json_variant *eccv = NULL;
ASSERT_OK(tpm2_tpmt_public_to_json(&ecc_public, &eccv));
_cleanup_free_ char *ecc_json = NULL;
ASSERT_OK(sd_json_variant_format(eccv, 0, &ecc_json));
ASSERT_STREQ(ecc_json, "{\"type\":\"ECC\",\"nameAlg\":\"SHA384\",\"objectAttributes\":327922,\"authPolicy\":\"\",\"parameters\":{\"symmetric\":{\"algorithm\":\"NULL\"},\"scheme\":{\"scheme\":\"ECDSA\",\"details\":{\"hashAlg\":\"SHA384\"}},\"curveID\":\"NIST_P384\",\"kdf\":{\"scheme\":\"NULL\"}},\"unique\":{\"x\":\"6381d4a6aebcc46d5968efa80665820ed8b2ea8069e62ddfa28130f7a823620bf44e0779e2b9fe18c9f8b783800e7c2c\",\"y\":\"473fcbe01831c3be463dcc0093a34eb8196e095671bc10e38e0c8fb3ae459c50a408dfe45142fada5fc29bee6580c51e\"}}");
}
TEST(tpm2_tpms_nv_public_to_json) {
DEFINE_HEX_PTR(policy, "c0f52d0be7f6c1666d90a181a99a74b99c5e0bfd00bc52cc27ae0e66d89afcf5");
TPMS_NV_PUBLIC nv_public = {
.nvIndex = 0x01d10202,
.nameAlg = TPM2_ALG_SHA256,
.attributes =
TPMA_NV_CLEAR_STCLEAR |
TPMA_NV_ORDERLY |
TPMA_NV_POLICYWRITE |
TPMA_NV_OWNERREAD |
TPMA_NV_AUTHREAD |
TPMA_NV_WRITTEN |
(TPM2_NT_EXTEND << TPMA_NV_TPM2_NT_SHIFT),
.authPolicy = TPM2B_DIGEST_MAKE(policy, policy_len),
.dataSize = 32,
};
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
ASSERT_OK(tpm2_tpms_nv_public_to_json(&nv_public, &v));
_cleanup_free_ char *json = NULL;
ASSERT_OK(sd_json_variant_format(v, 0, &json));
ASSERT_STREQ(json, "{\"nvIndex\":30474754,\"nameAlg\":\"SHA256\",\"attributes\":738590792,\"authPolicy\":\"c0f52d0be7f6c1666d90a181a99a74b99c5e0bfd00bc52cc27ae0e66d89afcf5\",\"dataSize\":32}");
}
static void check_attest_common(const TPMS_ATTEST *attest, TPMI_ST_ATTEST type, const TPM2B_DATA *extra_data) {
ASSERT_EQ(attest->magic, TPM2_GENERATED_VALUE);
ASSERT_EQ(attest->type, type);
ASSERT_EQ(memcmp_nn(attest->extraData.buffer, attest->extraData.size, extra_data->buffer, extra_data->size), 0);
}
static void check_attest_signature(const TPM2B_PUBLIC *public, const TPMT_SIGNATURE *sig) {
ASSERT_NOT_NULL(sig);
ASSERT_EQ(sig->sigAlg, public->publicArea.parameters.asymDetail.scheme.scheme);
ASSERT_EQ(sig->signature.any.hashAlg, public->publicArea.parameters.asymDetail.scheme.details.anySig.hashAlg);
switch (public->publicArea.parameters.asymDetail.scheme.scheme) {
case TPM2_ALG_RSAPSS:
ASSERT_EQ(sig->signature.rsapss.sig.size, public->publicArea.parameters.rsaDetail.keyBits / 8);
break;
case TPM2_ALG_RSASSA:
ASSERT_EQ(sig->signature.rsapss.sig.size, public->publicArea.parameters.rsaDetail.keyBits / 8);
break;
case TPM2_ALG_ECDSA: {
size_t expected_sz;
switch (public->publicArea.parameters.eccDetail.curveID) {
case TPM2_ECC_NIST_P256:
expected_sz = 32;
break;
case TPM2_ECC_NIST_P384:
expected_sz = 48;
break;
default:
assert_not_reached();
}
ASSERT_EQ(sig->signature.ecdsa.signatureR.size, expected_sz);
ASSERT_EQ(sig->signature.ecdsa.signatureS.size, expected_sz);
break;
}
default:
assert_not_reached();
}
/* XXX: Probably would be good to verify the actual signature here. We could do that with
* TPM2_VerifySignature, we would just need to implement that in tpm2-util.c. */
}
static void check_quote(Tpm2Context *c) {
assert(c);
TEST_LOG_FUNC();
TPM2B_PUBLIC template = {
.size = sizeof(TPMT_PUBLIC),
};
ASSERT_OK(tpm2_get_best_attestation_key_template(c, &template.publicArea));
_cleanup_(tpm2_handle_freep) Tpm2Handle *key = NULL;
ASSERT_OK(tpm2_create_primary(c, NULL, ESYS_TR_RH_OWNER, &template, NULL, NULL, &key));
const char *s = "foo";
TPM2B_DATA data = TPM2B_DATA_MAKE(s, strlen(s));
TPML_PCR_SELECTION pcrs;
tpm2_tpml_pcr_selection_from_mask(191, TPM2_ALG_SHA256, &pcrs);
_cleanup_(Esys_Freep) TPMS_ATTEST *quote = NULL;
_cleanup_(Esys_Freep) TPMT_SIGNATURE *sig = NULL;
ASSERT_OK(tpm2_quote(c, NULL, NULL, key, &data, &pcrs, "e, &sig));
check_attest_common(quote, TPM2_ST_ATTEST_QUOTE, &data);
ASSERT_EQ(memcmp("e->attested.quote.pcrSelect, &pcrs, sizeof(pcrs)), 0);
check_attest_signature(&template, sig);
}
static void check_nv_certify(Tpm2Context *c) {
int r;
assert(c);
TEST_LOG_FUNC();
char payload[16];
random_bytes(payload, sizeof(payload));
struct iovec nv_data = IOVEC_MAKE(payload, sizeof(payload));
TPM2_HANDLE nv_index = 0;
_cleanup_(tpm2_handle_freep) Tpm2Handle *nv_handle = NULL;
r = tpm2_define_data_nv_index(c, /* session= */ NULL, /* requested_nv_index= */ 0, &nv_data, &nv_index, &nv_handle);
if (r < 0) {
/* Could fail because the index size is greater than the value of TPM2_PT_NV_INDEX_MAX, or
* there isn't enough space available. */
log_notice_errno(r, "Could not allocate NV index, skipping NV certify test: %m");
return;
}
ASSERT_NE(nv_index, 0U);
ASSERT_NOT_NULL(nv_handle);
TPMS_NV_PUBLIC nv_public = {
.nvIndex = nv_index,
.nameAlg = TPM2_ALG_SHA256,
.attributes = TPM2_NT_ORDINARY | TPMA_NV_AUTHWRITE | TPMA_NV_AUTHREAD | TPMA_NV_NO_DA,
.dataSize = nv_data.iov_len,
};
_cleanup_(Esys_Freep) TPM2B_NAME *nv_name = NULL;
ASSERT_OK(tpm2_get_name(c, nv_handle, &nv_name));
TPM2B_PUBLIC template = {
.size = sizeof(TPMT_PUBLIC),
};
ASSERT_OK(tpm2_get_best_attestation_key_template(c, &template.publicArea));
_cleanup_(tpm2_handle_freep) Tpm2Handle *key = NULL;
ASSERT_OK(tpm2_create_primary(c, NULL, ESYS_TR_RH_OWNER, &template, NULL, NULL, &key));
const char *s = "bar";
TPM2B_DATA data = TPM2B_DATA_MAKE(s, strlen(s));
_cleanup_(Esys_Freep) TPMS_ATTEST *certify_info = NULL;
_cleanup_(Esys_Freep) TPMT_SIGNATURE *sig = NULL;
ASSERT_OK(tpm2_nv_certify(c, NULL, NULL, NULL, key, &nv_public, nv_handle, &data, &certify_info, &sig));
ASSERT_OK(tpm2_undefine_nv_index(c, NULL, nv_index, nv_handle));
check_attest_common(certify_info, TPM2_ST_ATTEST_NV, &data);
ASSERT_EQ(memcmp_nn(certify_info->attested.nv.indexName.name, certify_info->attested.nv.indexName.size, nv_name->name, nv_name->size), 0);
ASSERT_EQ(certify_info->attested.nv.offset, 0);
ASSERT_EQ(memcmp_nn(certify_info->attested.nv.nvContents.buffer, certify_info->attested.nv.nvContents.size, nv_data.iov_base, nv_data.iov_len), 0);
check_attest_signature(&template, sig);
}
static void check_get_session_audit_digest(Tpm2Context *c) {
assert(c);
TEST_LOG_FUNC();
TPM2B_PUBLIC template = {
.size = sizeof(TPMT_PUBLIC),
};
ASSERT_OK(tpm2_get_best_attestation_key_template(c, &template.publicArea));
_cleanup_(tpm2_handle_freep) Tpm2Handle *key = NULL;
ASSERT_OK(tpm2_create_primary(c, NULL, ESYS_TR_RH_OWNER, &template, NULL, NULL, &key));
_cleanup_(tpm2_handle_freep) Tpm2Handle *session = NULL;
ASSERT_OK(tpm2_make_exclusive_audit_session(c, &session));
/* Use the session */
TPML_PCR_SELECTION pcrs;
tpm2_tpml_pcr_selection_from_mask(191, TPM2_ALG_SHA256, &pcrs);
ASSERT_OK(tpm2_quote(c, NULL, session, key, NULL, &pcrs, NULL, NULL));
const char *s = "foo";
TPM2B_DATA data = TPM2B_DATA_MAKE(s, strlen(s));
_cleanup_(Esys_Freep) TPMS_ATTEST *audit_info = NULL;
_cleanup_(Esys_Freep) TPMT_SIGNATURE *sig = NULL;
ASSERT_OK(tpm2_get_session_audit_digest(c, NULL, NULL, session, key, &data, &audit_info, &sig));
check_attest_common(audit_info, TPM2_ST_ATTEST_SESSION_AUDIT, &data);
ASSERT_EQ(audit_info->attested.sessionAudit.exclusiveSession, TPM2_YES);
ASSERT_EQ(audit_info->attested.sessionAudit.sessionDigest.size, 32);
check_attest_signature(&template, sig);
}
TEST_RET(tests_which_require_tpm) {
_cleanup_(tpm2_context_unrefp) Tpm2Context *c = NULL;
int r = 0;
if (tpm2_context_new(NULL, &c) < 0)
return log_tests_skipped("Could not find TPM");
check_test_parms(c);
check_supports_alg(c);
check_supports_command(c);
check_best_srk_template(c);
check_get_or_create_srk(c);
check_seal_unseal(c);
check_nv_index_read(c);
check_get_ek_template(c);
check_get_or_create_ek(c);
check_max_data_size(c);
check_context_saving(c);
check_saved_context_marshaling(c);
check_policy_secret(c);
check_best_attestation_key_template(c);
check_quote(c);
check_nv_certify(c);
check_get_session_audit_digest(c);
#if HAVE_OPENSSL
r = check_calculate_seal(c);
#endif
return r;
}
#endif /* HAVE_TPM2 */
DEFINE_TEST_MAIN(LOG_DEBUG);