HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/test/test-tpm2.c
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),