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 1001–2000 of 2,387

        tpm2b_public_ecc_init(&public, TPM2_ECC_NIST_P256, "238e02ee4fd5598add6b502429f1815418515e4b0d6551c8e816b38cb15451d1", "70c2d491769775ec43ccd5a571c429233e9d30cf0f486c2e01acd6cb32ba93b6");
        assert_se(tpm2_calculate_pubkey_name(&public.publicArea, &name) >= 0);
        check_name(&name, "000b302787187ba19c82011c987bd2dcdbb652b3a543ccc5cb0b49c33d4caae604a6");
}
 
TEST(calculate_policy_auth_value) {
        TPM2B_DIGEST d;
 
        digest_init(&d, "0000000000000000000000000000000000000000000000000000000000000000");
        assert_se(tpm2_calculate_policy_auth_value(&d) == 0);
        assert_se(digest_check(&d, "8fcd2169ab92694e0c633f1ab772842b8241bbc20288981fc7ac1eddc1fddb0e"));
        assert_se(tpm2_calculate_policy_auth_value(&d) == 0);
        assert_se(digest_check(&d, "759ebd5ed65100e0b4aa2d04b4b789c2672d92ecc9cdda4b5fa16a303132e008"));
}
 
TEST(calculate_policy_nv_written) {
        TPM2B_DIGEST d;
 
        digest_init(&d, "0000000000000000000000000000000000000000000000000000000000000000");
        ASSERT_OK_ZERO(tpm2_calculate_policy_nv_written(false, &d));
        ASSERT_TRUE(digest_check(&d, "3c326323670e28ad37bd57f63b4cc34d26ab205ef22f275c58d47fab2485466e"));
        ASSERT_OK_ZERO(tpm2_calculate_policy_nv_written(true, &d));
        ASSERT_TRUE(digest_check(&d, "af595f3b5b4930da0d29921745c970bea2d8e6cdb9aa7cc40ce4916d0dc185fa"));
}
 
TEST(calculate_policy_authorize) {
        TPM2B_PUBLIC public;
        TPM2B_DIGEST d;
 
        /* RSA */
        tpm2b_public_rsa_init(&public, "9ec7341c52093ac40a1965a5df10432513c539adcf905e30577ab6ebc88ffe53cd08cef12ed9bec6125432f4fada3629b8b96d31b8f507aa35029188fe396da823fcb236027f7fbb01b0da3d87be7f999390449ced604bdf7e26c48657cc0671000f1147da195c3861c96642e54427cb7a11572e07567ec3fd6316978abc4bd92b27bb0a0e4958e599804eeb41d682b3b7fc1f960209f80a4fb8a1b64abfd96bf5d554e73cdd6ad1c8becb4fcf5e8f0c3e621d210e5e2f308f6520ad9a966779231b99f06c5989e5a23a9415c8808ab89ce81117632e2f8461cd4428bded40979236aeadafe8de3f51660a45e1dbc87694e6a36360201cca3ff9e7263e712727");
        digest_init(&d, "0000000000000000000000000000000000000000000000000000000000000000");
        assert_se(tpm2_calculate_policy_authorize(&public, NULL, &d) == 0);
        assert_se(digest_check(&d, "95213a3784eaab04f427bc7e8851c2f1df0903be8e42428ec25dcefd907baff1"));
        assert_se(tpm2_calculate_policy_authorize(&public, NULL, &d) == 0);
        assert_se(digest_check(&d, "95213a3784eaab04f427bc7e8851c2f1df0903be8e42428ec25dcefd907baff1"));
 
        /* ECC */
        tpm2b_public_ecc_init(&public, TPM2_ECC_NIST_P256, "423a89da6f0998f510489ab9682706e762031ef8f9faef2a185eff67065a187e", "996f73291670cef9e303d6cd9fa19ddf2c9c1fb1e283324ca9acca07c405c8d0");
        digest_init(&d, "0000000000000000000000000000000000000000000000000000000000000000");
        assert_se(tpm2_calculate_policy_authorize(&public, NULL, &d) == 0);
        assert_se(digest_check(&d, "2a5b705e83f949c27ac4d2e79e54fb5fb0a60f0b37bbd54a0ee1022ba00d3628"));
        assert_se(tpm2_calculate_policy_authorize(&public, NULL, &d) == 0);
        assert_se(digest_check(&d, "2a5b705e83f949c27ac4d2e79e54fb5fb0a60f0b37bbd54a0ee1022ba00d3628"));
}
 
TEST(make_policy_authorize_tbs_data) {
        _cleanup_(iovec_done) struct iovec tbs = {};
 
        DEFINE_HEX_PTR(digest, "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
        TPM2B_DIGEST d = TPM2B_DIGEST_MAKE(digest, digest_len);
 
        /* Without a policy reference the to-be-signed data is just the approved policy digest. */
        ASSERT_OK_ZERO(tpm2_make_policy_authorize_tbs_data(&d, NULL, &tbs));
        ASSERT_EQ(tbs.iov_len, d.size);
        ASSERT_EQ(memcmp(tbs.iov_base, d.buffer, d.size), 0);
        iovec_done(&tbs);
 
        /* An empty (zero-length) policy reference should not result in a SHA256 digest being appended. */
        const char empty[] = "";
        ASSERT_OK_ZERO(tpm2_make_policy_authorize_tbs_data(&d, empty, &tbs));
        ASSERT_EQ(tbs.iov_len, d.size);
        iovec_done(&tbs);
 
        /* A non-empty policy reference should result in a SHA256 digest being appended. */
        const char ref[] = "initrd";
        ASSERT_OK_ZERO(tpm2_make_policy_authorize_tbs_data(&d, ref, &tbs));
        ASSERT_EQ(tbs.iov_len, (size_t) d.size + SHA256_DIGEST_SIZE);
        ASSERT_EQ(memcmp(tbs.iov_base, d.buffer, d.size), 0);
        ASSERT_EQ(memcmp((const uint8_t*) tbs.iov_base + d.size, SHA256_DIRECT(ref, strlen(ref)), SHA256_DIGEST_SIZE), 0);
}
 
TEST(calculate_policy_pcr) {
        TPM2B_DIGEST d, dN[16];
 
        digest_init(&dN[ 0], "2124793cbbe60c3a8637d3b84a5d054e87c351e1469a285acc04755e8b204dec");
        digest_init(&dN[ 1], "bf7592f18adcfdc549fc0b94939f5069a24697f9cff4a0dca29014767b97559d");
        digest_init(&dN[ 2], "4b00cff9dee3a364979b2dc241b34568a8ad49fcf2713df259e47dff8875feed");
        digest_init(&dN[ 3], "3d458cfe55cc03ea1f443f1562beec8df51c75e14a9fcf9a7234a13f198e7969");
        digest_init(&dN[ 4], "368f85b3013041dfe203faaa364f00b07c5da7b1e5f1dbf2efb06fa6b9bd92de");
        digest_init(&dN[ 5], "c97c40369691c8e4aa78fb3a52655cd193b780a838b8e23f5f476576919db5e5");
        digest_init(&dN[ 6], "3d458cfe55cc03ea1f443f1562beec8df51c75e14a9fcf9a7234a13f198e7969");
        digest_init(&dN[ 7], "aa1154c9e0a774854ccbed4c8ce7e9b906b3d700a1a8db1772d0341a62dbe51b");
        digest_init(&dN[ 8], "cfde439a2c06af3479ca6bdc60429b90553d65300c5cfcc40004a08c6b5ad81a");
        digest_init(&dN[ 9], "9c2bac22ef5ec84fcdb71c3ebf776cba1247e5da980e5ee08e45666a2edf0b8b");
        digest_init(&dN[10], "9885873f4d7348199ad286f8f2476d4f866940950f6f9fb9f945ed352dbdcbd2");
        digest_init(&dN[11], "42400ab950d21aa79d12cc4fdef67d1087a39ad64900619831c0974dbae54e44");
        digest_init(&dN[12], "767d064382e56ca1ad3bdcc6bc596112e6c2008b593d3570d24c2bfa64c4628c");
        digest_init(&dN[13], "30c16133175959408c9745d8dafadef5daf4b39cb2be04df0d60089bd46d3cc4");
        digest_init(&dN[14], "e3991b7ddd47be7e92726a832d6874c5349b52b789fa0db8b558c69fea29574e");
        digest_init(&dN[15], "852dae3ecb992bdeb13d6002fefeeffdd90feca8b378d56681ef2c885d0e5137");
 
        digest_init(&d, "0000000000000000000000000000000000000000000000000000000000000000");
        Tpm2PCRValue v1[] = {
                TPM2_PCR_VALUE_MAKE(4, TPM2_ALG_SHA256, dN[4]),
                TPM2_PCR_VALUE_MAKE(7, TPM2_ALG_SHA256, dN[7]),
                TPM2_PCR_VALUE_MAKE(8, TPM2_ALG_SHA256, dN[8]),
        };
        assert_se(tpm2_calculate_policy_pcr(v1, ELEMENTSOF(v1), &d) == 0);
        assert_se(digest_check(&d, "76532a0e16f7e6bf6b02918c11f75d99d729fab0cc81d0df2c4284a2c4fe6e05"));
        assert_se(tpm2_calculate_policy_pcr(v1, ELEMENTSOF(v1), &d) == 0);
        assert_se(digest_check(&d, "97e64bcabb64c1fa4b726528644926c8029f5b4458b0575c98c04fe225629a0b"));
 
        digest_init(&d, "0000000000000000000000000000000000000000000000000000000000000000");
        Tpm2PCRValue v2[] = {
                TPM2_PCR_VALUE_MAKE( 0, TPM2_ALG_SHA256, dN[ 0]),
                TPM2_PCR_VALUE_MAKE( 1, TPM2_ALG_SHA256, dN[ 1]),
                TPM2_PCR_VALUE_MAKE( 2, TPM2_ALG_SHA256, dN[ 2]),
                TPM2_PCR_VALUE_MAKE( 3, TPM2_ALG_SHA256, dN[ 3]),
                TPM2_PCR_VALUE_MAKE( 4, TPM2_ALG_SHA256, dN[ 4]),
                TPM2_PCR_VALUE_MAKE( 5, TPM2_ALG_SHA256, dN[ 5]),
                TPM2_PCR_VALUE_MAKE( 6, TPM2_ALG_SHA256, dN[ 6]),
                TPM2_PCR_VALUE_MAKE( 7, TPM2_ALG_SHA256, dN[ 7]),
                TPM2_PCR_VALUE_MAKE( 8, TPM2_ALG_SHA256, dN[ 8]),
                TPM2_PCR_VALUE_MAKE( 9, TPM2_ALG_SHA256, dN[ 9]),
                TPM2_PCR_VALUE_MAKE(10, TPM2_ALG_SHA256, dN[10]),
                TPM2_PCR_VALUE_MAKE(11, TPM2_ALG_SHA256, dN[11]),
                TPM2_PCR_VALUE_MAKE(12, TPM2_ALG_SHA256, dN[12]),
                TPM2_PCR_VALUE_MAKE(13, TPM2_ALG_SHA256, dN[13]),
                TPM2_PCR_VALUE_MAKE(14, TPM2_ALG_SHA256, dN[14]),
                TPM2_PCR_VALUE_MAKE(15, TPM2_ALG_SHA256, dN[15]),
        };
        assert_se(tpm2_calculate_policy_pcr(v2, ELEMENTSOF(v2), &d) == 0);
        assert_se(digest_check(&d, "22be4f1674f792d6345cea9427701068f0e8d9f42755dcc0e927e545a68f9c13"));
        assert_se(tpm2_calculate_policy_pcr(v2, ELEMENTSOF(v2), &d) == 0);
        assert_se(digest_check(&d, "7481fd1b116078eb3ac2456e4ad542c9b46b9b8eb891335771ca8e7c8f8e4415"));
}
 
static void check_srk_rsa_template(TPMT_PUBLIC *template) {
        assert_se(template->type == TPM2_ALG_RSA);
        assert_se(template->nameAlg == TPM2_ALG_SHA256);
        assert_se(template->objectAttributes == 0x30472);
        assert_se(template->parameters.rsaDetail.symmetric.algorithm == TPM2_ALG_AES);
        assert_se(template->parameters.rsaDetail.symmetric.keyBits.sym == 128);
        assert_se(template->parameters.rsaDetail.symmetric.mode.sym == TPM2_ALG_CFB);
        assert_se(template->parameters.rsaDetail.scheme.scheme == TPM2_ALG_NULL);
        assert_se(template->parameters.rsaDetail.keyBits == 2048);
}
 
static void check_srk_ecc_template(TPMT_PUBLIC *template) {
        assert_se(template->type == TPM2_ALG_ECC);
        assert_se(template->nameAlg == TPM2_ALG_SHA256);
        assert_se(template->objectAttributes == 0x30472);
        assert_se(template->parameters.eccDetail.symmetric.algorithm == TPM2_ALG_AES);
        assert_se(template->parameters.eccDetail.symmetric.keyBits.sym == 128);
        assert_se(template->parameters.eccDetail.symmetric.mode.sym == TPM2_ALG_CFB);
        assert_se(template->parameters.eccDetail.scheme.scheme == TPM2_ALG_NULL);
        assert_se(template->parameters.eccDetail.kdf.scheme == TPM2_ALG_NULL);
        assert_se(template->parameters.eccDetail.curveID == TPM2_ECC_NIST_P256);
}
 
TEST(tpm2_get_srk_template) {
        TPMT_PUBLIC template;
 
        assert_se(tpm2_get_srk_template(TPM2_ALG_RSA, &template) >= 0);
        check_srk_rsa_template(&template);
 
        assert_se(tpm2_get_srk_template(TPM2_ALG_ECC, &template) >= 0);
        check_srk_ecc_template(&template);
}
 
static void check_best_srk_template(Tpm2Context *c) {
        TEST_LOG_FUNC();
 
        TPMT_PUBLIC template;
        assert_se(tpm2_get_best_srk_template(c, &template) >= 0);
 
        assert_se(IN_SET(template.type, TPM2_ALG_ECC, TPM2_ALG_RSA));
 
        if (template.type == TPM2_ALG_RSA)
                check_srk_rsa_template(&template);
        else
                check_srk_ecc_template(&template);
}
 
static void check_ek_template_a(TPMT_PUBLIC *template) {
        ASSERT_EQ(template->nameAlg, TPM2_ALG_SHA256);
        ASSERT_EQ(template->objectAttributes, TPMA_OBJECT_FIXEDTPM | TPMA_OBJECT_FIXEDPARENT | TPMA_OBJECT_SENSITIVEDATAORIGIN | TPMA_OBJECT_ADMINWITHPOLICY | TPMA_OBJECT_RESTRICTED | TPMA_OBJECT_DECRYPT);
        ASSERT_TRUE(digest_check(&template->authPolicy, "837197674484B3F81A90CC8D46A5D724FD52D76E06520B64F2A1DA1B331469AA"));
        ASSERT_EQ(template->parameters.asymDetail.symmetric.algorithm, TPM2_ALG_AES);
        ASSERT_EQ(template->parameters.asymDetail.symmetric.keyBits.sym, 128);
        ASSERT_EQ(template->parameters.asymDetail.symmetric.mode.sym, TPM2_ALG_CFB);
}
 
static void check_ek_rsa_template_a(TPMT_PUBLIC *template) {
        ASSERT_EQ(template->type, TPM2_ALG_RSA);
 
        check_ek_template_a(template);
 
        ASSERT_EQ(template->parameters.rsaDetail.scheme.scheme, TPM2_ALG_NULL);
        ASSERT_EQ(template->parameters.rsaDetail.keyBits, 2048);
}
 
static void check_ek_ecc_template_a(TPMT_PUBLIC *template) {
        ASSERT_EQ(template->type, TPM2_ALG_ECC);
 
        check_ek_template_a(template);
 
        ASSERT_EQ(template->parameters.eccDetail.scheme.scheme, TPM2_ALG_NULL);
        ASSERT_EQ(template->parameters.eccDetail.kdf.scheme, TPM2_ALG_NULL);
        ASSERT_EQ(template->parameters.eccDetail.curveID, TPM2_ECC_NIST_P256);
}
 
static void check_ek_template_b(TPMT_PUBLIC *template, TPMI_ALG_HASH expect_name_alg) {
        ASSERT_EQ(template->nameAlg, expect_name_alg);
        ASSERT_EQ(template->objectAttributes, TPMA_OBJECT_FIXEDTPM | TPMA_OBJECT_FIXEDPARENT | TPMA_OBJECT_SENSITIVEDATAORIGIN | TPMA_OBJECT_ADMINWITHPOLICY | TPMA_OBJECT_RESTRICTED | TPMA_OBJECT_DECRYPT | TPMA_OBJECT_USERWITHAUTH);
 
        switch (expect_name_alg) {
        case TPM2_ALG_SHA256:
                ASSERT_TRUE(digest_check(&template->authPolicy, "CA3D0A99A2B93906F7A3342414EFCFB3A385D44CD1FD459089D19B5071C0B7A0"));
                break;
        case TPM2_ALG_SHA384:
                ASSERT_TRUE(digest_check(&template->authPolicy, "B26E7D28D11A50BC53D882BCF5FD3A1A074148BB35D3B4E4CB1C0AD9BDE419CACB47BA09699646150F9FC000F3F80E12"));
                break;
        default:
                assert_not_reached();
        }
 
        ASSERT_EQ(template->parameters.asymDetail.symmetric.algorithm, TPM2_ALG_AES);
        ASSERT_EQ(template->parameters.asymDetail.symmetric.keyBits.sym, expect_name_alg == TPM2_ALG_SHA256 ? 128 : 256);
        ASSERT_EQ(template->parameters.asymDetail.symmetric.mode.sym, TPM2_ALG_CFB);
}
 
static void check_ek_rsa_template_b(
                TPMT_PUBLIC *template,
                TPMI_ALG_HASH expect_name_alg,
                uint16_t expect_key_bits) {
        ASSERT_EQ(template->type, TPM2_ALG_RSA);
 
        check_ek_template_b(template, expect_name_alg);
 
        ASSERT_EQ(template->parameters.rsaDetail.scheme.scheme, TPM2_ALG_NULL);
        ASSERT_EQ(template->parameters.rsaDetail.keyBits, expect_key_bits);
}
 
static void check_ek_ecc_template_b(
                TPMT_PUBLIC *template,
                TPMI_ALG_HASH expect_name_alg,
                TPMI_ECC_CURVE expect_curve_id) {
        ASSERT_EQ(template->type, TPM2_ALG_ECC);
 
        check_ek_template_b(template, expect_name_alg);
 
        ASSERT_EQ(template->parameters.eccDetail.scheme.scheme, TPM2_ALG_NULL);
        ASSERT_EQ(template->parameters.eccDetail.kdf.scheme, TPM2_ALG_NULL);
        ASSERT_EQ(template->parameters.eccDetail.curveID, expect_curve_id);
}
 
TEST(tpm2_get_default_ek_template) {
        TPMT_PUBLIC template;
 
        tpm2_get_default_ek_template(TPM2_EK_TEMPLATE_RSA_2048_LEGACY, &template);
        check_ek_rsa_template_a(&template);
        memset(&template, 0, sizeof(template));
 
        tpm2_get_default_ek_template(TPM2_EK_TEMPLATE_ECC_NIST_P256_LEGACY, &template);
        check_ek_ecc_template_a(&template);
        memset(&template, 0, sizeof(template));
 
        tpm2_get_default_ek_template(TPM2_EK_TEMPLATE_RSA_2048, &template);
        check_ek_rsa_template_b(&template, TPM2_ALG_SHA256, 2048);
        memset(&template, 0, sizeof(template));
 
        tpm2_get_default_ek_template(TPM2_EK_TEMPLATE_ECC_NIST_P256, &template);
        check_ek_ecc_template_b(&template, TPM2_ALG_SHA256, TPM2_ECC_NIST_P256);
        memset(&template, 0, sizeof(template));
 
        tpm2_get_default_ek_template(TPM2_EK_TEMPLATE_ECC_NIST_P384, &template);
        check_ek_ecc_template_b(&template, TPM2_ALG_SHA384, TPM2_ECC_NIST_P384);
        memset(&template, 0, sizeof(template));
 
        tpm2_get_default_ek_template(TPM2_EK_TEMPLATE_RSA_3072, &template);
        check_ek_rsa_template_b(&template, TPM2_ALG_SHA384, 3072);
        memset(&template, 0, sizeof(template));
}
 
static void check_test_parms(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        TPMU_PUBLIC_PARMS parms = {
                .symDetail.sym = {
                        .algorithm = TPM2_ALG_AES,
                        .keyBits.aes = 128,
                        .mode.aes = TPM2_ALG_CFB,
                },
        };
 
        /* Test with invalid parms */
        assert_se(!tpm2_test_parms(c, TPM2_ALG_CFB, &parms));
 
        TPMU_PUBLIC_PARMS invalid_parms = parms;
        invalid_parms.symDetail.sym.keyBits.aes = 1;
        assert_se(!tpm2_test_parms(c, TPM2_ALG_SYMCIPHER, &invalid_parms));
 
        /* Test with valid parms */
        assert_se(tpm2_test_parms(c, TPM2_ALG_SYMCIPHER, &parms));
}
 
static void check_supports_alg(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        /* Test invalid algs */
        assert_se(!tpm2_supports_alg(c, TPM2_ALG_ERROR));
        assert_se(!tpm2_supports_alg(c, TPM2_ALG_LAST + 1));
 
        /* Test valid algs */
        assert_se(tpm2_supports_alg(c, TPM2_ALG_RSA));
        assert_se(tpm2_supports_alg(c, TPM2_ALG_AES));
        assert_se(tpm2_supports_alg(c, TPM2_ALG_CFB));
}
 
static void check_supports_command(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        /* Test invalid commands. TPM specification Part 2 ("Structures") section "TPM_CC (Command Codes)"
         * states bits 31:30 and 28:16 are reserved and must be 0. */
        assert_se(!tpm2_supports_command(c, UINT32_C(0x80000000)));
        assert_se(!tpm2_supports_command(c, UINT32_C(0x40000000)));
        assert_se(!tpm2_supports_command(c, UINT32_C(0x00100000)));
        assert_se(!tpm2_supports_command(c, UINT32_C(0x80000144)));
        assert_se(!tpm2_supports_command(c, UINT32_C(0x40000144)));
        assert_se(!tpm2_supports_command(c, UINT32_C(0x00100144)));
 
        /* Test valid commands. We should be able to expect all TPMs support these. */
        assert_se(tpm2_supports_command(c, TPM2_CC_Startup));
        assert_se(tpm2_supports_command(c, TPM2_CC_StartAuthSession));
        assert_se(tpm2_supports_command(c, TPM2_CC_Create));
        assert_se(tpm2_supports_command(c, TPM2_CC_CreatePrimary));
        assert_se(tpm2_supports_command(c, TPM2_CC_Unseal));
}
 
static void check_get_or_create_srk(Tpm2Context *c) {
        TEST_LOG_FUNC();
 
        _cleanup_free_ TPM2B_PUBLIC *public = NULL;
        _cleanup_free_ TPM2B_NAME *name = NULL, *qname = NULL;
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle = NULL;
        assert_se(tpm2_get_or_create_srk(c, NULL, &public, &name, &qname, &handle) >= 0);
        assert_se(public && name && qname && handle);
 
        _cleanup_free_ TPM2B_PUBLIC *public2 = NULL;
        _cleanup_free_ TPM2B_NAME *name2 = NULL, *qname2 = NULL;
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle2 = NULL;
        assert_se(tpm2_get_srk(c, NULL, &public2, &name2, &qname2, &handle2) >= 0);
        assert_se(public2 && name2 && qname2 && handle2);
 
        assert_se(memcmp_nn(public, sizeof(*public), public2, sizeof(*public2)) == 0);
        assert_se(memcmp_nn(name->name, name->size, name2->name, name2->size) == 0);
        assert_se(memcmp_nn(qname->name, qname->size, qname2->name, qname2->size) == 0);
}
 
#if HAVE_OPENSSL
static void calculate_seal_and_unseal(
                Tpm2Context *c,
                TPM2_HANDLE parent_index,
                const TPM2B_PUBLIC *parent_public) {
 
        _cleanup_free_ char *secret_string = NULL;
        assert_se(asprintf(&secret_string, "The classified documents are in room %x", parent_index) > 0);
        size_t secret_size = strlen(secret_string) + 1;
 
        _cleanup_(iovec_done) struct iovec blob = {}, serialized_parent = {};
        assert_se(tpm2_calculate_seal(
                        parent_index,
                        parent_public,
                        /* attributes= */ NULL,
                        &IOVEC_MAKE(secret_string, secret_size),
                        /* policy= */ NULL,
                        /* pin= */ NULL,
                        /* ret_secret= */ NULL,
                        &blob,
                        &serialized_parent) >= 0);
 
        _cleanup_(iovec_done) struct iovec unsealed_secret = {};
        assert_se(tpm2_unseal(
                        c,
                        /* hash_pcr_mask= */ 0,
                        /* pcr_bank= */ 0,
                        /* pubkey= */ NULL,
                        /* pubkey_policy_ref = */ NULL,
                        /* pubkey_pcr_mask= */ 0,
                        /* signature= */ NULL,
                        /* pin= */ NULL,
                        /* pcrlock_policy= */ NULL,
                        /* primary_alg= */ 0,
                        &blob,
                        /* n_blobs= */ 1,
                        /* known_policy_hash= */ NULL,
                        /* n_known_policy_hash= */ 0,
                        &serialized_parent,
                        &unsealed_secret) >= 0);
 
        assert_se(memcmp_nn(secret_string, secret_size, unsealed_secret.iov_base, unsealed_secret.iov_len) == 0);
 
        char unsealed_string[unsealed_secret.iov_len];
        assert_se(snprintf(unsealed_string, unsealed_secret.iov_len, "%s", (char*) unsealed_secret.iov_base) == (int) unsealed_secret.iov_len - 1);
        log_debug("Unsealed secret is: %s", unsealed_string);
}
 
static int check_calculate_seal(Tpm2Context *c) {
        assert(c);
        int r;
 
        if (detect_virtualization() == VIRTUALIZATION_NONE && !slow_tests_enabled()) {
                log_notice("Skipping slow calculate seal TPM2 tests. Physical system detected, and slow tests disabled. (To enable, run again with $SYSTEMD_SLOW_TESTS=1.)");
                return 0;
        }
 
        TEST_LOG_FUNC();
 
        _cleanup_free_ TPM2B_PUBLIC *srk_public = NULL;
        assert_se(tpm2_get_srk(c, NULL, &srk_public, NULL, NULL, NULL) >= 0);
        calculate_seal_and_unseal(c, TPM2_SRK_HANDLE, srk_public);
 
        TPMI_ALG_ASYM test_algs[] = { TPM2_ALG_RSA, TPM2_ALG_ECC, };
        FOREACH_ELEMENT(alg, test_algs) {
                TPM2B_PUBLIC template = { .size = sizeof(TPMT_PUBLIC), };
                assert_se(tpm2_get_srk_template(*alg, &template.publicArea) >= 0);
 
                _cleanup_free_ TPM2B_PUBLIC *public = NULL;
                _cleanup_(tpm2_handle_freep) Tpm2Handle *handle = NULL;
                assert_se(tpm2_create_primary(c, NULL, ESYS_TR_RH_OWNER, &template, NULL, &public, &handle) >= 0);
 
                /* Once our minimum libtss2-esys version is 2.4.0 or later, this can assume
                 * tpm2_index_from_handle() should always work. */
                TPM2_HANDLE index;
                r = tpm2_index_from_handle(c, handle, &index);
                if (r == -EOPNOTSUPP)
                        return log_tests_skipped("libtss2-esys version too old to support tpm2_index_from_handle()");
                assert_se(r >= 0);
 
                calculate_seal_and_unseal(c, index, public);
        }
 
        return 0;
}
#endif /* HAVE_OPENSSL */
 
static void check_seal_unseal_for_handle(Tpm2Context *c, TPM2_HANDLE handle) {
        TPM2B_DIGEST policy = TPM2B_DIGEST_MAKE(NULL, TPM2_SHA256_DIGEST_SIZE);
 
        assert(c);
 
        log_debug("Check seal/unseal for handle 0x%" PRIx32, handle);
 
        _cleanup_(iovec_done) struct iovec secret = {}, srk = {}, unsealed_secret = {};
        struct iovec *blobs = NULL;
        size_t n_blobs = 0;
        CLEANUP_ARRAY(blobs, n_blobs, iovec_array_free);
 
        assert_se(tpm2_seal(
                        c,
                        handle,
                        &policy,
                        1,
                        /* pin= */ NULL,
                        &secret,
                        &blobs,
                        &n_blobs,
                        /* ret_primary_alg= */ NULL,
                        &srk) >= 0);
 
        assert_se(tpm2_unseal(
                        c,
                        /* hash_pcr_mask= */ 0,
                        /* pcr_bank= */ 0,
                        /* pubkey= */ NULL,
                        /* pubkey_policy_ref= */ NULL,
                        /* pubkey_pcr_mask= */ 0,
                        /* signature= */ NULL,
                        /* pin= */ NULL,
                        /* pcrlock_policy= */ NULL,
                        /* primary_alg= */ 0,
                        blobs,
                        n_blobs,
                        /* known_policy_hash= */ NULL,
                        /* n_known_policy_hash= */ 0,
                        &srk,
                        &unsealed_secret) >= 0);
 
        assert_se(iovec_equal(&secret, &unsealed_secret));
}
 
static void check_seal_unseal(Tpm2Context *c) {
        int r;
 
        assert(c);
 
        if (detect_virtualization() == VIRTUALIZATION_NONE && !slow_tests_enabled()) {
                log_notice("Skipping slow seal/unseal TPM2 tests. Physical system detected, and slow tests disabled. (To enable, run again with $SYSTEMD_SLOW_TESTS=1.)");
                return;
        }
 
        TEST_LOG_FUNC();
 
        check_seal_unseal_for_handle(c, 0);
        check_seal_unseal_for_handle(c, TPM2_SRK_HANDLE);
 
        FOREACH_ELEMENT(template, test_templates) {
                TPM2B_PUBLIC public = {
                        .publicArea = **template,
                        .size = sizeof(**template),
                };
                _cleanup_(tpm2_handle_freep) Tpm2Handle *transient_handle = NULL;
                assert_se(tpm2_create_primary(
                                c,
                                /* session= */ NULL,
                                ESYS_TR_RH_OWNER,
                                &public,
                                /* sensitive= */ NULL,
                                /* ret_public= */ NULL,
                                &transient_handle) >= 0);
 
                TPMI_DH_PERSISTENT transient_handle_index;
                r = tpm2_index_from_handle(c, transient_handle, &transient_handle_index);
                if (r == -EOPNOTSUPP) {
                        /* libesys too old */
                        log_tests_skipped("libesys too old for tpm2_index_from_handle");
                        return;
                }
                assert_se(r >= 0);
 
                check_seal_unseal_for_handle(c, transient_handle_index);
        }
}
 
static void check_nv_index_read(Tpm2Context *c) {
        int r;
        uint8_t payload[1031];
 
        assert(c);
 
        TEST_LOG_FUNC();
 
        random_bytes(payload, sizeof(payload));
        struct iovec data = IOVEC_MAKE(payload, sizeof(payload));
 
        /* Test chunked reads first by mocking c->max_nv_buffer_size with several values that are less than
         * the payload size and the TPM's reported size for TPM2_PT_NV_BUFFER_MAX. */
        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, &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 index read test: %m");
                return;
        }
        ASSERT_NE(nv_index, 0U);
        ASSERT_NOT_NULL(nv_handle);
 
        uint16_t saved_max_nv_buffer_size = c->max_nv_buffer_size;
 
        static const uint16_t chunk_sizes[] = { 128, 256, 512, 1024 };
        FOREACH_ELEMENT(cs, chunk_sizes) {
                if (*cs >= saved_max_nv_buffer_size)
                        continue;
 
                c->max_nv_buffer_size = *cs;
 
                _cleanup_(iovec_done) struct iovec value = {};
                ASSERT_OK_ZERO(tpm2_read_nv_index(c, /* session= */ NULL, nv_index, nv_handle, &value));
                ASSERT_TRUE(iovec_equal(&value, &data));
        }
 
        c->max_nv_buffer_size = saved_max_nv_buffer_size;
 
        ASSERT_OK_ZERO(tpm2_undefine_nv_index(c, /* session= */ NULL, nv_index, nv_handle));
        nv_index = 0;
        nv_handle = tpm2_handle_free(nv_handle);
 
        /* Test reading of a payload with the size of the reported TPM2_PT_NV_BUFFER_MAX. */
        _cleanup_free_ void *payload2 = malloc(c->max_nv_buffer_size);
        ASSERT_NOT_NULL(payload2);
        random_bytes(payload2, c->max_nv_buffer_size);
        struct iovec data2 = IOVEC_MAKE(payload2, c->max_nv_buffer_size);
        ASSERT_OK_ZERO(tpm2_define_data_nv_index(c, /* session= */ NULL, /* requested_nv_index= */ 0, &data2, &nv_index, &nv_handle));
        ASSERT_NE(nv_index, 0U);
        ASSERT_NOT_NULL(nv_handle);
 
        _cleanup_(iovec_done) struct iovec value = {};
        ASSERT_OK_ZERO(tpm2_read_nv_index(c, /* session= */ NULL, nv_index, nv_handle, &value));
        ASSERT_TRUE(iovec_equal(&value, &data2));
 
        ASSERT_OK_ZERO(tpm2_undefine_nv_index(c, /* session= */ NULL, nv_index, nv_handle));
        nv_index = 0;
        nv_handle = tpm2_handle_free(nv_handle);
        iovec_done(&value);
 
        /* Test reading of a payload which is smaller than the reported size of TPM2_PT_NV_BUFFER_MAX. */
        data.iov_len = 36;
        ASSERT_OK_ZERO(tpm2_define_data_nv_index(c, /* session= */ NULL, /* requested_nv_index= */ 0, &data, &nv_index, &nv_handle));
        ASSERT_NE(nv_index, 0U);
        ASSERT_NOT_NULL(nv_handle);
 
        ASSERT_OK_ZERO(tpm2_read_nv_index(c, /* session= */ NULL, nv_index, nv_handle, &value));
        ASSERT_TRUE(iovec_equal(&value, &data));
 
        ASSERT_OK_ZERO(tpm2_undefine_nv_index(c, /* session= */ NULL, nv_index, nv_handle));
}
 
static void check_get_ek_template(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        /* Note that this assumes that there aren't any custom templates, and doesn't test the support for
         * custom templates. Testing this requires the use of the TPM simulator for platform hierarchy
         * access. */
 
        TPMT_PUBLIC template;
 
        ASSERT_OK_ZERO(tpm2_get_ek_template(c, /* session= */ NULL, TPM2_EK_TEMPLATE_RSA_2048_LEGACY, &template));
        check_ek_rsa_template_a(&template);
        memset(&template, 0, sizeof(template));
 
        ASSERT_OK_ZERO(tpm2_get_ek_template(c, /* session= */ NULL, TPM2_EK_TEMPLATE_ECC_NIST_P256_LEGACY, &template));
        check_ek_ecc_template_a(&template);
        memset(&template, 0, sizeof(template));
 
        ASSERT_OK_ZERO(tpm2_get_ek_template(c, /* session= */ NULL, TPM2_EK_TEMPLATE_RSA_2048, &template));
        check_ek_rsa_template_b(&template, TPM2_ALG_SHA256, 2048);
        memset(&template, 0, sizeof(template));
 
        ASSERT_OK_ZERO(tpm2_get_ek_template(c, /* session= */ NULL, TPM2_EK_TEMPLATE_ECC_NIST_P256, &template));
        check_ek_ecc_template_b(&template, TPM2_ALG_SHA256, TPM2_ECC_NIST_P256);
        memset(&template, 0, sizeof(template));
 
        ASSERT_OK_ZERO(tpm2_get_ek_template(c, /* session= */ NULL, TPM2_EK_TEMPLATE_ECC_NIST_P384, &template));
        check_ek_ecc_template_b(&template, TPM2_ALG_SHA384, TPM2_ECC_NIST_P384);
        memset(&template, 0, sizeof(template));
 
        ASSERT_OK_ZERO(tpm2_get_ek_template(c, /* session= */ NULL, TPM2_EK_TEMPLATE_RSA_3072, &template));
        check_ek_rsa_template_b(&template, TPM2_ALG_SHA384, 3072);
        memset(&template, 0, sizeof(template));
}
 
static void check_get_or_create_ek(Tpm2Context *c) {
        int r;
 
        assert(c);
 
        TEST_LOG_FUNC();
 
        /* This test relies on the existance of an EKcert for a supported profile. Don't fail the test if
         * there isn't one. */
        _cleanup_free_ TPM2B_PUBLIC *public = NULL;
        _cleanup_free_ TPM2B_NAME *name = NULL, *qname = NULL;
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle = NULL;
        r = tpm2_get_or_create_ek(c, /* session= */ NULL, &public, &name, &qname, &handle);
        ASSERT_OK_OR(r, -EOPNOTSUPP);
        if (r < 0)
                return;
 
        ASSERT_NOT_NULL(public);
        ASSERT_NOT_NULL(name);
        ASSERT_NOT_NULL(qname);
        ASSERT_NOT_NULL(handle);
 
        ASSERT_TRUE(IN_SET(public->publicArea.type, TPM2_ALG_RSA, TPM2_ALG_ECC));
 
        if ((public->publicArea.objectAttributes & TPMA_OBJECT_USERWITHAUTH) == 0) {
                /* Test against the low-range expectations. */
                switch (public->publicArea.type) {
                case TPM2_ALG_RSA:
                        check_ek_rsa_template_a(&public->publicArea);
                        break;
                case TPM2_ALG_ECC:
                        check_ek_ecc_template_a(&public->publicArea);
                        break;
                default:
                        assert_not_reached();
                }
        } else {
                /* Test against the high-range expectations. */
                switch (public->publicArea.type) {
                case TPM2_ALG_RSA:
                        check_ek_rsa_template_b(&public->publicArea, public->publicArea.nameAlg, public->publicArea.parameters.rsaDetail.keyBits);
                        break;
                case TPM2_ALG_ECC:
                        check_ek_ecc_template_b(&public->publicArea, public->publicArea.nameAlg, public->publicArea.parameters.eccDetail.curveID);
                        break;
                default:
                        assert_not_reached();
                }
        }
 
        _cleanup_free_ TPM2B_PUBLIC *public2 = NULL;
        _cleanup_free_ TPM2B_NAME *name2 = NULL, *qname2 = NULL;
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle2 = NULL;
        ASSERT_OK_POSITIVE(tpm2_get_ek(c, /* session= */ NULL, &public2, &name2, &qname2, &handle2));
        ASSERT_NOT_NULL(public2);
        ASSERT_NOT_NULL(name2);
        ASSERT_NOT_NULL(qname2);
        ASSERT_NOT_NULL(handle2);
 
        ASSERT_EQ(memcmp_nn(public, sizeof(*public), public2, sizeof(*public2)), 0);
        ASSERT_EQ(memcmp_nn(name->name, name->size, name2->name, name2->size), 0);
        ASSERT_EQ(memcmp_nn(qname->name, qname->size, qname2->name, qname2->size), 0);
}
 
static void check_max_data_size(Tpm2Context *c) {
        int r;
 
        assert(c);
 
        TEST_LOG_FUNC();
 
        r = tpm2_max_data_size(c);
        ASSERT_OK_POSITIVE(r);
        ASSERT_TRUE(IN_SET(r, 22, 34, 50, 66));
}
 
TEST(tpm2_digest_to_data) {
        DEFINE_HEX_PTR(h, "b48a7bdf4214ed87d617690ff108e0089939a6d6754b2b6be324e2bfb2bbc54a");
        DEFINE_HEX_PTR(expected, "000bb48a7bdf4214ed87d617690ff108e0089939a6d6754b2b6be324e2bfb2bbc54a");
 
        TPM2B_DATA d;
        ASSERT_OK(tpm2_digest_buf_to_data(TPM2_ALG_SHA256, h, h_len, &d));
        ASSERT_EQ(memcmp_nn(d.buffer, d.size, expected, expected_len), 0);
 
        memset(&d, 0, sizeof(d));
        ASSERT_OK(tpm2_digest_iovec_to_data(TPM2_ALG_SHA256, &IOVEC_MAKE(h, h_len), &d));
        ASSERT_EQ(memcmp_nn(d.buffer, d.size, expected, expected_len), 0);
}
 
static void check_context_saving(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        TPM2B_PUBLIC template = { .size = sizeof(TPMT_PUBLIC), };
        ASSERT_OK(tpm2_get_srk_template(TPM2_ALG_ECC, &template.publicArea));
 
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle = NULL;
        ASSERT_OK(tpm2_create_primary(c, NULL, ESYS_TR_RH_OWNER, &template, NULL, NULL, &handle));
 
        _cleanup_(Esys_Freep) TPMS_CONTEXT *context = NULL;
        ASSERT_OK(tpm2_save_handle_context(c, handle, &context));
 
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle2 = NULL;
        ASSERT_OK(tpm2_load_saved_handle_context(c, context, NULL, &handle2));
 
        _cleanup_(Esys_Freep) TPM2B_NAME *name1 = NULL, *name2 = NULL;
        ASSERT_OK(tpm2_get_name(c, handle, &name1));
        ASSERT_OK(tpm2_get_name(c, handle2, &name2));
 
        ASSERT_EQ(memcmp_nn(name1->name, name1->size, name2->name, name2->size), 0);
}
 
static void check_saved_context_marshaling(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        TPM2B_PUBLIC template = { .size = sizeof(TPMT_PUBLIC), };
        ASSERT_OK(tpm2_get_srk_template(TPM2_ALG_ECC, &template.publicArea));
 
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle = NULL;
        ASSERT_OK(tpm2_create_primary(c, NULL, ESYS_TR_RH_OWNER, &template, NULL, NULL, &handle));
 
        _cleanup_(Esys_Freep) TPMS_CONTEXT *context = NULL;
        ASSERT_OK(tpm2_save_handle_context(c, handle, &context));
 
        _cleanup_free_ void *buf = NULL;
        size_t sz;
        ASSERT_OK(tpm2_marshal_saved_handle_context(context, &buf, &sz));
 
        TPMS_CONTEXT context2;
        ASSERT_OK(tpm2_unmarshal_saved_handle_context(buf, sz, &context2));
 
        _cleanup_(tpm2_handle_freep) Tpm2Handle *handle2 = NULL;
        ASSERT_OK(tpm2_load_saved_handle_context(c, &context2, NULL, &handle2));
 
        _cleanup_(Esys_Freep) TPM2B_NAME *name1 = NULL, *name2 = NULL;
        ASSERT_OK(tpm2_get_name(c, handle, &name1));
        ASSERT_OK(tpm2_get_name(c, handle2, &name2));
 
        ASSERT_EQ(memcmp_nn(name1->name, name1->size, name2->name, name2->size), 0);
}
 
static void check_policy_secret(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        _cleanup_(tpm2_handle_freep) Tpm2Handle *session = NULL;
        ASSERT_OK(tpm2_make_policy_session(c, NULL, NULL, &session));
 
        _cleanup_(Esys_Freep) TPM2B_DIGEST *digest = NULL;
        ASSERT_OK(tpm2_policy_secret(c, NULL, session, &TPM2_HANDLE_RH_ENDORSEMENT, NULL, &digest));
        ASSERT_TRUE(digest_check(digest, "837197674484b3f81a90cc8d46a5d724fd52d76e06520b64f2a1da1b331469aa"));
 
        session = tpm2_handle_free(session);
        ASSERT_OK(tpm2_make_policy_session(c, NULL, NULL, &session));
 
        const char *s = "foo";
 
        _cleanup_(Esys_Freep) TPM2B_DIGEST *digest2 = NULL;
        TPM2B_NONCE ref = TPM2B_NONCE_MAKE(s, strlen(s));
        ASSERT_OK(tpm2_policy_secret(c, NULL, session, &TPM2_HANDLE_RH_OWNER, &ref, &digest2));
        ASSERT_TRUE(digest_check(digest2, "62fd94980db2a746545cab626e9df21a1d0f00472f637d4bf567026e40a6ebed"));
}
 
static void check_best_attestation_key_template(Tpm2Context *c) {
        assert(c);
 
        TEST_LOG_FUNC();
 
        TPMT_PUBLIC template;
        ASSERT_OK(tpm2_get_best_attestation_key_template(c, &template));
 
        ASSERT_TRUE(IN_SET(template.type, TPM2_ALG_RSA, TPM2_ALG_ECC));
        ASSERT_TRUE(IN_SET(template.nameAlg, TPM2_ALG_SHA256, TPM2_ALG_SHA384));
        ASSERT_EQ(template.objectAttributes, TPMA_OBJECT_FIXEDTPM | TPMA_OBJECT_FIXEDPARENT | TPMA_OBJECT_SENSITIVEDATAORIGIN | TPMA_OBJECT_USERWITHAUTH | TPMA_OBJECT_RESTRICTED | TPMA_OBJECT_SIGN_ENCRYPT);
        ASSERT_EQ(template.parameters.asymDetail.symmetric.algorithm, TPM2_ALG_NULL);
        ASSERT_NE(template.parameters.asymDetail.scheme.scheme, TPM2_ALG_NULL);
        ASSERT_TRUE(IN_SET(template.parameters.asymDetail.scheme.details.anySig.hashAlg, TPM2_ALG_SHA256, TPM2_ALG_SHA384));
 
        if (template.type == TPM2_ALG_RSA) {
                ASSERT_TRUE(IN_SET(template.parameters.rsaDetail.scheme.scheme, TPM2_ALG_RSASSA, TPM2_ALG_RSAPSS));
                ASSERT_TRUE(IN_SET(template.parameters.rsaDetail.keyBits, 2048, 3072));
        } else {
                ASSERT_EQ(template.parameters.eccDetail.scheme.scheme, TPM2_ALG_ECDSA);
                ASSERT_TRUE(IN_SET(template.parameters.eccDetail.curveID, TPM2_ECC_NIST_P256, TPM2_ECC_NIST_P384));
        }
}
 
TEST(tpm2_tpmt_signature_to_pem) {
        DEFINE_HEX_PTR(rsa,
                       "dc3d4338b3a20f081f2204c54c0ddfd633fba8e49c2029d6612d1412e3204344fc64ee4b9ce9f4d37d0efe2637291643bbedea8e3af30f9396db7c33d02f7cf6"
                       "ab8d2a668b6610092507370b9eebf4f044e248b89af6474085250d47de3cb40825f49d85a829df7915e6956bb48ad92a5765423698a13ee847c0edc1a25675bf"
                       "e058c04992bc662c8734fc8a4dfc8276593cf3538e123a06e41b74ee012f7f7bca5d672cf3183d08e17eae0f9798455682902122bbbee3d76c89a851485c3461"
                       "1158ec1a3abfc088753896d6739758ac99548df1b53ed0552789c5a007d75917aa680f2610117479544d13ae9234f14349d37a833999a43c9db4b16c26d0fb31");
 
        TPMT_SIGNATURE rsa_sig = {
                .sigAlg = TPM2_ALG_RSAPSS,
                .signature.rsapss = {
                        .hash = TPM2_ALG_SHA256,
                        .sig = TPM2B_PUBLIC_KEY_RSA_MAKE(rsa, rsa_len),
                },
        };
 
        _cleanup_free_ char *rsa_pem = NULL;
        ASSERT_OK(tpm2_tpmt_signature_to_pem(&rsa_sig, &rsa_pem));
        ASSERT_STREQ(rsa_pem,
                     "-----BEGIN RSA SIGNATURE-----\n"
                     "3D1DOLOiDwgfIgTFTA3f1jP7qOScICnWYS0UEuMgQ0T8ZO5LnOn0030O/iY3KRZD\n"
                     "u+3qjjrzD5OW23wz0C989quNKmaLZhAJJQc3C57r9PBE4ki4mvZHQIUlDUfePLQI\n"
                     "JfSdhagp33kV5pVrtIrZKldlQjaYoT7oR8DtwaJWdb/gWMBJkrxmLIc0/IpN/IJ2\n"
                     "WTzzU44SOgbkG3TuAS9/e8pdZyzzGD0I4X6uD5eYRVaCkCEiu77j12yJqFFIXDRh\n"
                     "EVjsGjq/wIh1OJbWc5dYrJlUjfG1PtBVJ4nFoAfXWReqaA8mEBF0eVRNE66SNPFD\n"
                     "SdN6gzmZpDydtLFsJtD7MQ==\n"
                     "-----END RSA SIGNATURE-----\n");
 
        DEFINE_HEX_PTR(ecc_r, "d9eb686422a6fb9a64a5cf9806495d7e787f11b77f5f5928680c02558a2467ec526f04a9745dc4f196248dd2198a17d4");
        DEFINE_HEX_PTR(ecc_s, "8e9f92622c4cd4c00ae4c551feecbc4e0cc5b321e023acf6f8b67f9075ecac5c9cea3cd1b6d76055a46c20ecd080d2cf");
 
        TPMT_SIGNATURE ecc_sig = {
                .sigAlg = TPM2_ALG_ECDSA,
                .signature.ecdsa = {
                        .hash = TPM2_ALG_SHA384,
                        .signatureR = TPM2B_ECC_PARAMETER_MAKE(ecc_r, ecc_r_len),
                        .signatureS = TPM2B_ECC_PARAMETER_MAKE(ecc_s, ecc_s_len),
                },
        };
 
        _cleanup_free_ char *ecc_pem = NULL;
        ASSERT_OK(tpm2_tpmt_signature_to_pem(&ecc_sig, &ecc_pem));
        ASSERT_STREQ(ecc_pem,
                     "-----BEGIN ECDSA SIGNATURE-----\n"
                     "MGYCMQDZ62hkIqb7mmSlz5gGSV1+eH8Rt39fWShoDAJViiRn7FJvBKl0XcTxliSN\n"
                     "0hmKF9QCMQCOn5JiLEzUwArkxVH+7LxODMWzIeAjrPb4tn+QdeysXJzqPNG212BV\n"
                     "pGwg7NCA0s8=\n"
                     "-----END ECDSA SIGNATURE-----\n");
}
 
TEST(tpm2_tpmt_public_to_pem) {
        DEFINE_HEX_PTR(rsa,
                       "615fc18fec08de00721ae55823d2e2c631fe3d7cb2bd7117a40d9be3cd7623c386db5c60ebcdccca39443c1203297f91b59945544efc7977e16e202e5938a37b"
                       "ae31ee0b7e5249fe7f76f36c94428b3e0f0d53b730270dbb44b3c007a0b45733018f1d8feba462a5e67c7b87a5b913e4a606e105f97828732491686be253d0d7"
                       "f20ad3450ae7b86fe36a7163013487c2659fe56420623241edbd1ecc9c6d2443143a4db68f6c449008e8b4fec5ad5b56598ffd22f67d317e46e4c48e693c38ee"
                       "389886b1084e51cfe56408e7e8eee1ab65615d36aff585e25fb198df519b961054b6cfae85717ba387c597146f4d36e548101409a1ceddf321571d3364c968ef");
 
        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_free_ char *rsa_pem = NULL;
        ASSERT_OK(tpm2_tpmt_public_to_pem(&rsa_public, &rsa_pem));
        ASSERT_STREQ(rsa_pem,
                     "-----BEGIN PUBLIC KEY-----\n"
                     "MIIBITANBgkqhkiG9w0BAQEFAAOCAQ4AMIIBCQKCAQBhX8GP7AjeAHIa5Vgj0uLG\n"
                     "Mf49fLK9cRekDZvjzXYjw4bbXGDrzczKOUQ8EgMpf5G1mUVUTvx5d+FuIC5ZOKN7\n"
                     "rjHuC35SSf5/dvNslEKLPg8NU7cwJw27RLPAB6C0VzMBjx2P66RipeZ8e4eluRPk\n"
                     "pgbhBfl4KHMkkWhr4lPQ1/IK00UK57hv42pxYwE0h8Jln+VkIGIyQe29HsycbSRD\n"
                     "FDpNto9sRJAI6LT+xa1bVlmP/SL2fTF+RuTEjmk8OO44mIaxCE5Rz+VkCOfo7uGr\n"
                     "ZWFdNq/1heJfsZjfUZuWEFS2z66FcXujh8WXFG9NNuVIEBQJoc7d8yFXHTNkyWjv\n"
                     "AgMBAAE=\n"
                     "-----END PUBLIC KEY-----\n");
 
        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_free_ char *ecc_pem = NULL;
        ASSERT_OK(tpm2_tpmt_public_to_pem(&ecc_public, &ecc_pem));
        ASSERT_STREQ(ecc_pem,
                     "-----BEGIN PUBLIC KEY-----\n"
                     "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEY4HUpq68xG1ZaO+oBmWCDtiy6oBp5i3f\n"
                     "ooEw96gjYgv0Tgd54rn+GMn4t4OADnwsRz/L4Bgxw75GPcwAk6NOuBluCVZxvBDj\n"
                     "jgyPs65FnFCkCN/kUUL62l/Cm+5lgMUe\n"
                     "-----END PUBLIC KEY-----\n");
}
 
TEST(tpm2_tpmt_signature_to_json) {
        TPMT_SIGNATURE rsa_sig = {
                .sigAlg = TPM2_ALG_RSAPSS,
                .signature.rsapss = {
                        .hash = TPM2_ALG_SHA256,
                        .sig = {
                                .size = 256,
                        },
                },
        };
        assert(sizeof(rsa_sig.signature.rsapss.sig.buffer) >= 256);
        random_bytes(rsa_sig.signature.rsapss.sig.buffer, 256);
 
        _cleanup_free_ char *h_rsa = hexmem(rsa_sig.signature.rsapss.sig.buffer, 256);
        ASSERT_NOT_NULL(h_rsa);
 
        _cleanup_free_ char *rsa_expected = NULL;
        ASSERT_OK(asprintf(&rsa_expected, "{\"sigAlg\":\"RSAPSS\",\"signature\":{\"hash\":\"SHA256\",\"sig\":\"%s\"}}", h_rsa));
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *rsav = NULL;
        ASSERT_OK(tpm2_tpmt_signature_to_json(&rsa_sig, &rsav));
 
        _cleanup_free_ char *rsa_json = NULL;
        ASSERT_OK(sd_json_variant_format(rsav, 0, &rsa_json));
        ASSERT_STREQ(rsa_json, rsa_expected);
 
        DEFINE_HEX_PTR(ecc_r, "d9eb686422a6fb9a64a5cf9806495d7e787f11b77f5f5928680c02558a2467ec526f04a9745dc4f196248dd2198a17d4");
        DEFINE_HEX_PTR(ecc_s, "8e9f92622c4cd4c00ae4c551feecbc4e0cc5b321e023acf6f8b67f9075ecac5c9cea3cd1b6d76055a46c20ecd080d2cf");
 
        TPMT_SIGNATURE ecc_sig = {
                .sigAlg = TPM2_ALG_ECDSA,
                .signature.ecdsa = {
                        .hash = TPM2_ALG_SHA384,
                        .signatureR = TPM2B_ECC_PARAMETER_MAKE(ecc_r, ecc_r_len),
                        .signatureS = TPM2B_ECC_PARAMETER_MAKE(ecc_s, ecc_s_len),