HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/test/test-tpm2.c

123,790 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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, &quote, &sig));
 
        check_attest_common(quote, TPM2_ST_ATTEST_QUOTE, &data);
        ASSERT_EQ(memcmp(&quote->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);