You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1299 lines
47 KiB
1299 lines
47 KiB
/* SPDX-License-Identifier: BSD-2-Clause */
|
|
/*******************************************************************************
|
|
* Copyright 2018, Fraunhofer SIT sponsored by Infineon Technologies AG
|
|
* All rights reserved.
|
|
******************************************************************************/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdarg.h>
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <json-c/json_util.h>
|
|
#include <json-c/json_tokener.h>
|
|
|
|
#include <setjmp.h>
|
|
#include <cmocka.h>
|
|
|
|
#include "tss2_fapi.h"
|
|
#include "tpm_json_serialize.h"
|
|
#include "tpm_json_deserialize.h"
|
|
#include "ifapi_json_serialize.h"
|
|
#include "ifapi_json_deserialize.h"
|
|
#include "fapi_policy.h"
|
|
|
|
#include "util/aux_util.h"
|
|
|
|
#define LOGMODULE tests
|
|
#include "util/log.h"
|
|
|
|
/* 3 copies from ifapi_helpers.c */
|
|
static void
|
|
cleanup_policy_element(TPMT_POLICYELEMENT *policy)
|
|
{
|
|
switch (policy->type) {
|
|
case POLICYSECRET:
|
|
SAFE_FREE(policy->element.PolicySecret.objectPath);
|
|
break;
|
|
case POLICYAUTHORIZE:
|
|
SAFE_FREE(policy->element.PolicyAuthorize.keyPath);
|
|
SAFE_FREE(policy->element.PolicyAuthorize.keyPEM);
|
|
break;
|
|
case POLICYAUTHORIZENV:
|
|
SAFE_FREE( policy->element.PolicyAuthorizeNv.nvPath);
|
|
SAFE_FREE( policy->element.PolicyAuthorizeNv.policy_buffer);
|
|
break;
|
|
case POLICYSIGNED:
|
|
SAFE_FREE(policy->element.PolicySigned.keyPath);
|
|
SAFE_FREE(policy->element.PolicySigned.keyPEM);
|
|
break;
|
|
case POLICYPCR:
|
|
SAFE_FREE(policy->element.PolicyPCR.pcrs);
|
|
break;
|
|
case POLICYNV:
|
|
SAFE_FREE(policy->element.PolicyNV.nvPath);
|
|
break;
|
|
case POLICYDUPLICATIONSELECT:
|
|
SAFE_FREE(policy->element.PolicyDuplicationSelect.newParentPath);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void cleanup_policy_elements(TPML_POLICYELEMENTS *policy)
|
|
{
|
|
size_t i, j;
|
|
if (policy != NULL) {
|
|
for (i = 0; i < policy->count; i++) {
|
|
if (policy->elements[i].type == POLICYOR) {
|
|
/* Policy with sub policies */
|
|
TPML_POLICYBRANCHES *branches = policy->elements[i].element.PolicyOr.branches;
|
|
for (j = 0; j < branches->count; j++) {
|
|
SAFE_FREE(branches->authorizations[j].name);
|
|
SAFE_FREE(branches->authorizations[j].description);
|
|
cleanup_policy_elements(branches->authorizations[j].policy);
|
|
}
|
|
SAFE_FREE(branches);
|
|
} else {
|
|
cleanup_policy_element(&policy->elements[i]);
|
|
}
|
|
}
|
|
SAFE_FREE(policy);
|
|
}
|
|
}
|
|
|
|
/** Free memory allocated during deserialization of policy.
|
|
*
|
|
* The object will not be freed (might be declared on the stack).
|
|
*
|
|
* @param[in] object The policy to be cleaned up.
|
|
*
|
|
*/
|
|
static void ifapi_cleanup_policy(TPMS_POLICY *policy)
|
|
{
|
|
if (policy) {
|
|
SAFE_FREE(policy->description);
|
|
SAFE_FREE(policy->policyAuthorizations);
|
|
cleanup_policy_elements(policy->policy);
|
|
}
|
|
}
|
|
|
|
char * normalize(const char *string) {
|
|
char *string2 = malloc(strlen(string)+1);
|
|
int i;
|
|
int j = 0;
|
|
for(i = 0; string[i] != '\0'; i++) {
|
|
if ((string[i] != '\n' && string[i] != ' ')) {
|
|
string2[j] = string[i];
|
|
j += 1;
|
|
}
|
|
}
|
|
string2[j] = '\0';
|
|
return string2;
|
|
}
|
|
|
|
#define CHECK_ERROR(TYPE, SRC, RC) \
|
|
{ \
|
|
TYPE out; \
|
|
TSS2_RC rc; \
|
|
json_object *jso = json_tokener_parse((SRC)); \
|
|
assert_non_null(jso); \
|
|
rc = ifapi_json_ ## TYPE ## _deserialize (jso, &out); \
|
|
assert_int_equal (rc, RC); \
|
|
json_object_put(jso); \
|
|
}
|
|
|
|
|
|
|
|
#define CHECK_JSON2(TYPE, SRC, DST, PSERIALIZE) \
|
|
{ \
|
|
TYPE out; \
|
|
TSS2_RC rc; \
|
|
json_object *jso = json_tokener_parse((SRC)); \
|
|
if (!jso) fprintf(stderr, "JSON parsing failed\n"); \
|
|
assert_non_null(jso); \
|
|
rc = ifapi_json_ ## TYPE ## _deserialize (jso, &out); \
|
|
if (rc) fprintf(stderr, "Deserialization failed\n"); \
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS); \
|
|
json_object_put(jso); \
|
|
jso = NULL; \
|
|
rc = ifapi_json_ ## TYPE ## _serialize (PSERIALIZE, &jso); \
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS); \
|
|
assert_non_null(jso); \
|
|
const char *jso_string = json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY); \
|
|
assert_non_null(jso_string); \
|
|
char *string1 = normalize(jso_string); \
|
|
char *string2 = normalize(DST); \
|
|
assert_string_equal(string1, string2); \
|
|
json_object_put(jso); \
|
|
free(string1); \
|
|
free(string2); \
|
|
}
|
|
|
|
#define CHECK_JSON(TYPE, SRC, DST) \
|
|
CHECK_JSON2(TYPE, SRC, DST, &out)
|
|
|
|
#define CHECK_JSON_SIMPLE(TYPE, SRC, DST) \
|
|
CHECK_JSON2(TYPE, SRC, DST, out)
|
|
|
|
#define CHECK_JSON_TO_BIN(TYPE, SRC, DST) \
|
|
{ \
|
|
TYPE out; \
|
|
TSS2_RC rc; \
|
|
TYPE expected = DST; \
|
|
json_object *jso = json_tokener_parse((SRC)); \
|
|
assert_non_null(jso); \
|
|
rc = ifapi_json_ ## TYPE ## _deserialize (jso, &out); \
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS); \
|
|
json_object_put(jso); \
|
|
assert_true(out == expected); \
|
|
}
|
|
|
|
#define CHECK_BIN2(TYPE, BIN, PSERIALIZE) \
|
|
TYPE BIN ## 2; \
|
|
{ \
|
|
char *jso_string1, *jso_string2; \
|
|
json_object *jso = NULL; \
|
|
TSS2_RC rc = ifapi_json_ ## TYPE ## _serialize (PSERIALIZE, &jso); \
|
|
jso_string1 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY)); \
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS); \
|
|
rc = ifapi_json_ ## TYPE ## _deserialize (jso, &BIN ## 2); \
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS); \
|
|
json_object_put(jso); \
|
|
jso = NULL; \
|
|
rc = ifapi_json_ ## TYPE ## _serialize (PSERIALIZE ## 2, &jso); \
|
|
jso_string2 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY)); \
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS); \
|
|
if (strcmp(jso_string1, jso_string2)) { \
|
|
fprintf(stderr,"\n jso: %s\n", jso_string1); \
|
|
fprintf(stderr,"\n jso: %s\n", jso_string2); \
|
|
} \
|
|
assert_string_equal(jso_string1, jso_string2); \
|
|
json_object_put(jso); \
|
|
free(jso_string1); \
|
|
free(jso_string2); \
|
|
}
|
|
|
|
#define CHECK_BIN(TYPE, BIN) \
|
|
CHECK_BIN2(TYPE, BIN, &BIN)
|
|
|
|
#define CHECK_BIN_SIMPLE(TYPE, BIN) \
|
|
CHECK_BIN2(TYPE, BIN, BIN)
|
|
|
|
static void
|
|
check_bin(void **state)
|
|
{
|
|
TPM2B_PUBLIC inPublicAES = {
|
|
.size = 0,
|
|
.publicArea = {
|
|
.type = TPM2_ALG_SYMCIPHER,
|
|
.nameAlg = TPM2_ALG_SHA256,
|
|
.objectAttributes = (TPMA_OBJECT_USERWITHAUTH |
|
|
TPMA_OBJECT_SIGN_ENCRYPT |
|
|
TPMA_OBJECT_DECRYPT),
|
|
|
|
.authPolicy = {
|
|
.size = 0,
|
|
},
|
|
.parameters.symDetail = {
|
|
.sym = {
|
|
.algorithm = TPM2_ALG_AES,
|
|
.keyBits = {.aes = 128},
|
|
.mode = {.aes = TPM2_ALG_CFB}}
|
|
},
|
|
.unique.sym = {
|
|
.size = 0,
|
|
.buffer = {}
|
|
}
|
|
}
|
|
};
|
|
|
|
CHECK_BIN(TPM2B_PUBLIC, inPublicAES);
|
|
|
|
TPM2B_PUBLIC inPublicECC = {
|
|
.size = 0,
|
|
.publicArea = {
|
|
.type = TPM2_ALG_ECC,
|
|
.nameAlg = TPM2_ALG_SHA1,
|
|
.objectAttributes = (
|
|
TPMA_OBJECT_USERWITHAUTH |
|
|
TPMA_OBJECT_RESTRICTED |
|
|
TPMA_OBJECT_SIGN_ENCRYPT |
|
|
TPMA_OBJECT_FIXEDTPM |
|
|
TPMA_OBJECT_FIXEDPARENT |
|
|
TPMA_OBJECT_SENSITIVEDATAORIGIN
|
|
),
|
|
.authPolicy = {
|
|
.size = 0,
|
|
},
|
|
|
|
.parameters.eccDetail = {
|
|
.symmetric = {
|
|
.algorithm = TPM2_ALG_NULL,
|
|
.keyBits.aes = 128,
|
|
.mode.aes = TPM2_ALG_ECB,
|
|
},
|
|
.scheme = {
|
|
.scheme = TPM2_ALG_ECDAA,
|
|
.details = { .ecdaa = { .hashAlg = TPM2_ALG_SHA256 }},
|
|
},
|
|
.curveID = TPM2_ECC_BN_P256,
|
|
.kdf = { .scheme = TPM2_ALG_NULL, .details = {} }
|
|
},
|
|
/*
|
|
.parameters.asymDetail.symmetric.algorithm = TPM2_ALG_NULL,
|
|
*/
|
|
.unique.ecc = {
|
|
.x = { .size = 0, .buffer = {} } ,
|
|
.y = { .size = 0, .buffer = {} } ,
|
|
},
|
|
},
|
|
};
|
|
|
|
|
|
CHECK_BIN(TPM2B_PUBLIC, inPublicECC);
|
|
|
|
TPM2B_PUBLIC inPublicRSA2 = {
|
|
.size = 0,
|
|
.publicArea = {
|
|
.type = TPM2_ALG_RSA,
|
|
.nameAlg = TPM2_ALG_SHA1,
|
|
.objectAttributes = (TPMA_OBJECT_USERWITHAUTH |
|
|
TPMA_OBJECT_SIGN_ENCRYPT |
|
|
TPMA_OBJECT_FIXEDTPM |
|
|
TPMA_OBJECT_FIXEDPARENT |
|
|
TPMA_OBJECT_SENSITIVEDATAORIGIN),
|
|
.authPolicy = {
|
|
.size = 0,
|
|
},
|
|
.parameters.rsaDetail = {
|
|
.symmetric = {
|
|
.algorithm = TPM2_ALG_NULL,
|
|
.keyBits.aes = 128,
|
|
.mode.aes = TPM2_ALG_CFB},
|
|
.scheme = {
|
|
.scheme = TPM2_ALG_RSAPSS,
|
|
.details = {
|
|
.rsapss = { .hashAlg = TPM2_ALG_SHA1 }
|
|
}
|
|
},
|
|
.keyBits = 2048,
|
|
.exponent = 0,
|
|
},
|
|
.unique.rsa = {
|
|
.size = 0,
|
|
.buffer = {},
|
|
},
|
|
},
|
|
};
|
|
|
|
CHECK_BIN(TPM2B_PUBLIC, inPublicRSA2);
|
|
|
|
TPMT_SIG_SCHEME ecc_scheme = { .scheme = TPM2_ALG_ECDSA, .details.ecdsa = TPM2_ALG_SHA1 };
|
|
|
|
CHECK_BIN(TPMT_SIG_SCHEME, ecc_scheme);
|
|
|
|
TPMT_SIG_SCHEME rsa_scheme = { .scheme = TPM2_ALG_NULL };
|
|
|
|
CHECK_BIN(TPMT_SIG_SCHEME, rsa_scheme);
|
|
|
|
TPMA_NV testNV = 0xffffff0f ;
|
|
|
|
CHECK_BIN_SIMPLE(TPMA_NV, testNV);
|
|
|
|
TPML_PCR_SELECTION pcr_selection = {
|
|
.count = 3,
|
|
.pcrSelections = {
|
|
{
|
|
.hash = TPM2_ALG_SHA1,
|
|
.sizeofSelect = 3,
|
|
.pcrSelect = { 01, 00, 03 }},
|
|
{
|
|
.hash = TPM2_ALG_SHA256,
|
|
.sizeofSelect = 3,
|
|
.pcrSelect = { 01 ,00 ,03 }},
|
|
{
|
|
.hash = TPM2_ALG_SHA384,
|
|
.sizeofSelect = 3,
|
|
.pcrSelect = { 02, 00, 02 }}
|
|
}
|
|
};
|
|
|
|
CHECK_BIN(TPML_PCR_SELECTION, pcr_selection);
|
|
|
|
IFAPI_IMA_EVENT imaEvent = {
|
|
.eventData = {
|
|
.size = 0,
|
|
.buffer = { 0 }
|
|
},
|
|
.eventName = "Event"
|
|
};
|
|
|
|
CHECK_BIN(IFAPI_IMA_EVENT, imaEvent);
|
|
free(imaEvent2.eventName);
|
|
}
|
|
|
|
static void
|
|
check_policy_bin(void **state)
|
|
{
|
|
TPMS_PCRVALUE pcr_value;
|
|
TPML_PCRVALUES *pcr_value_list;
|
|
TPML_POLICYBRANCHES *or_branch_list;
|
|
TPMS_POLICYPCR pcr_policy;
|
|
TPMT_POLICYELEMENT policy_element0;
|
|
TPMT_POLICYELEMENT policy_element1;
|
|
TPMT_POLICYELEMENT policy_element_or;
|
|
TPML_POLICYELEMENTS *policy_elements_or;
|
|
TPML_POLICYELEMENTS *policy_elements0;
|
|
TPML_POLICYELEMENTS *policy_elements1;
|
|
TPMS_POLICY policy;
|
|
TPMS_POLICYBRANCH branch0;
|
|
TPMS_POLICYBRANCH branch1;
|
|
|
|
pcr_value.pcr = 16;
|
|
pcr_value.hashAlg = TPM2_ALG_SHA1;
|
|
memset(&pcr_value.digest, 0, sizeof(TPMU_HA));
|
|
memset(&pcr_policy, 0, sizeof(TPMS_POLICYPCR));
|
|
pcr_value_list = calloc(1, sizeof(TPML_PCRVALUES) + sizeof(TPMS_PCRVALUE));
|
|
if (pcr_value_list == NULL) {
|
|
LOG_ERROR("%s", "Out of memory.");
|
|
return;
|
|
}
|
|
pcr_value_list->count = 1;
|
|
pcr_value_list->pcrs[0] = pcr_value;
|
|
pcr_policy.pcrs = pcr_value_list;
|
|
memset(&policy_element0, 0, sizeof(TPMT_POLICYELEMENT));
|
|
policy_element0.element.PolicyPCR = pcr_policy;
|
|
policy_element0.type = POLICYPCR;
|
|
memset(&policy_element1, 0, sizeof(TPMT_POLICYELEMENT));
|
|
policy_element1.element.PolicyPCR = pcr_policy;
|
|
policy_element1.type = POLICYPCR;
|
|
policy_elements0 = calloc(1, sizeof(TPML_POLICYELEMENTS) + sizeof(TPMT_POLICYELEMENT));
|
|
if (policy_elements0 == NULL) {
|
|
LOG_ERROR("%s", "Out of memory.");
|
|
if (pcr_policy.pcrs){
|
|
free(pcr_policy.pcrs);
|
|
}
|
|
return;
|
|
}
|
|
policy_elements0->count = 1;
|
|
policy_elements0->elements[0] = policy_element0;
|
|
policy.policy = policy_elements0;
|
|
policy.description = "hareness description";
|
|
policy.policyAuthorizations = NULL;
|
|
memset(&policy.policyDigests, 0, sizeof(TPML_DIGEST_VALUES));
|
|
|
|
//CHECK_BIN(TPMS_POLICY, policy);
|
|
{
|
|
char *jso_string1, *jso_string2;
|
|
json_object *jso = NULL;
|
|
TSS2_RC rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
|
|
jso_string1 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
rc = ifapi_json_TPMS_POLICY_deserialize (jso, &policy);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
json_object_put(jso);
|
|
jso = NULL;
|
|
rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
|
|
jso_string2 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
if (strcmp(jso_string1, jso_string2)) {
|
|
fprintf(stderr,"\n jso: %s\n", jso_string1);
|
|
fprintf(stderr,"\n jso: %s\n", jso_string2);
|
|
}
|
|
assert_string_equal(jso_string1, jso_string2);
|
|
json_object_put(jso);
|
|
free(jso_string1);
|
|
free(jso_string2);
|
|
}
|
|
ifapi_cleanup_policy(&policy);
|
|
|
|
or_branch_list = calloc(2, sizeof(TPML_POLICYBRANCHES) + (2 * sizeof(TPMS_POLICYBRANCH)));
|
|
if (or_branch_list == NULL) {
|
|
LOG_ERROR("%s", "Out of memory.");
|
|
return;
|
|
}
|
|
or_branch_list->count = 2;
|
|
|
|
policy_elements1 = calloc(1, sizeof(TPML_POLICYELEMENTS) + sizeof(TPMT_POLICYELEMENT));
|
|
if (policy_elements1 == NULL) {
|
|
LOG_ERROR("%s", "Out of memory.");
|
|
if (or_branch_list){
|
|
free(or_branch_list);
|
|
}
|
|
return;
|
|
}
|
|
policy_elements1->count = 1;
|
|
policy_elements1->elements[0] = policy_element1;
|
|
|
|
memset(&branch0, 0, sizeof(TPMS_POLICYBRANCH));
|
|
memset(&branch1, 0, sizeof(TPMS_POLICYBRANCH));
|
|
branch0.policy = policy_elements0;
|
|
branch0.name = "branch0";
|
|
branch0.description = "description branch 0";
|
|
branch1.policy = policy_elements1;
|
|
branch1.name = "branch1";
|
|
branch1.description = "description branch 1";
|
|
memcpy(&or_branch_list->authorizations[0], &branch0, sizeof(TPMS_POLICYBRANCH));
|
|
memcpy(&or_branch_list->authorizations[1], &branch1, sizeof(TPMS_POLICYBRANCH));
|
|
//or_policy.pcrs = pcr_branch_list;
|
|
|
|
policy_elements_or = calloc(1, sizeof(TPML_POLICYELEMENTS) + sizeof(TPMT_POLICYELEMENT));
|
|
if (policy_elements_or == NULL) {
|
|
LOG_ERROR("%s", "Out of memory.");
|
|
if (or_branch_list) {
|
|
free(or_branch_list);
|
|
}
|
|
return;
|
|
}
|
|
policy_elements_or->count = 1;
|
|
|
|
memset(&policy_element_or, 0, sizeof(TPMT_POLICYELEMENT));
|
|
policy_element_or.element.PolicyOr.branches = or_branch_list;
|
|
policy_element_or.type = POLICYOR;
|
|
policy_elements_or->elements[0] = policy_element_or;
|
|
policy.policy = policy_elements_or;
|
|
|
|
//CHECK_BIN(TPMS_POLICY, policy);
|
|
{
|
|
char *jso_string1, *jso_string2;
|
|
json_object *jso = NULL;
|
|
TSS2_RC rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
|
|
jso_string1 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
rc = ifapi_json_TPMS_POLICY_deserialize (jso, &policy);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
json_object_put(jso);
|
|
jso = NULL;
|
|
rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
|
|
jso_string2 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
if (strcmp(jso_string1, jso_string2)) {
|
|
fprintf(stderr,"\n jso: %s\n", jso_string1);
|
|
fprintf(stderr,"\n jso: %s\n", jso_string2);
|
|
}
|
|
assert_string_equal(jso_string1, jso_string2);
|
|
json_object_put(jso);
|
|
free(jso_string1);
|
|
free(jso_string2);
|
|
}
|
|
ifapi_cleanup_policy(&policy);
|
|
|
|
free(policy_elements_or);
|
|
free(policy_elements0);
|
|
free(policy_elements1);
|
|
free(or_branch_list);
|
|
free(pcr_value_list);
|
|
}
|
|
|
|
static void
|
|
check_json_to_bin(void **state)
|
|
{
|
|
CHECK_JSON_TO_BIN(UINT64, "22147483647", 22147483647);
|
|
CHECK_JSON_TO_BIN(UINT64, "\"0xffffffff\"", 0xffffffff);
|
|
CHECK_JSON_TO_BIN(UINT64, "\"0xfffffffff\"", 0xfffffffff);
|
|
CHECK_JSON_TO_BIN(UINT32, "\"0xFfffffff\"", 0xffffffff);
|
|
CHECK_JSON_TO_BIN(UINT16, "\"0xffff\"", 0xffff);
|
|
}
|
|
|
|
static void
|
|
check_json_structs(void **state)
|
|
{
|
|
const char *test_json_TPMS_POLICYTEMPLATE =
|
|
"{\n"
|
|
" \"templateHash\": \"0011223344556677889900112233445566778899\"\n"
|
|
"}";
|
|
CHECK_JSON(TPMS_POLICYTEMPLATE, test_json_TPMS_POLICYTEMPLATE, test_json_TPMS_POLICYTEMPLATE);
|
|
|
|
const char *test_json_TPM2B_PUBLIC_expected =
|
|
"{\n"
|
|
" \"size\":0,\n"
|
|
" \"publicArea\":{\n"
|
|
" \"type\":\"ECC\",\n"
|
|
" \"nameAlg\":\"SHA1\",\n"
|
|
"\"objectAttributes\":{"
|
|
" \"fixedTPM\":1,"
|
|
" \"stClear\":0,"
|
|
" \"fixedParent\":1,"
|
|
" \"sensitiveDataOrigin\":1,"
|
|
" \"userWithAuth\":1,"
|
|
" \"adminWithPolicy\":0,"
|
|
" \"noDA\":0,"
|
|
" \"encryptedDuplication\":0,"
|
|
" \"restricted\":1,"
|
|
" \"decrypt\":0,"
|
|
" \"sign\":1"
|
|
" },"
|
|
" \"authPolicy\":\"\",\n"
|
|
" \"parameters\":{\n"
|
|
" \"symmetric\":{\n"
|
|
" \"algorithm\":\"NULL\"\n"
|
|
" },\n"
|
|
" \"scheme\":{\n"
|
|
" \"scheme\":\"ECDAA\",\n"
|
|
" \"details\":{\n"
|
|
" \"hashAlg\":\"SHA256\",\n"
|
|
" \"count\":0\n"
|
|
" }\n"
|
|
" },\n"
|
|
" \"curveID\":\"BN_P256\",\n"
|
|
" \"kdf\":{\n"
|
|
" \"scheme\":\"NULL\"\n"
|
|
" }\n"
|
|
" },\n"
|
|
" \"unique\":{\n"
|
|
" \"x\": \"\",\n"
|
|
" \"y\": \"\"\n"
|
|
" }\n"
|
|
" }\n"
|
|
"}";
|
|
|
|
const char *test_json_TPM2B_PUBLIC_src=
|
|
"{"
|
|
" \"size\":0,"
|
|
" \"publicArea\":{"
|
|
" \"type\":\"ECC\","
|
|
" \"nameAlg\":\"SHA1\","
|
|
" \"objectAttributes\":["
|
|
" \"fixedTPM\","
|
|
" \"fixedParent\","
|
|
" \"sensitiveDataOrigin\","
|
|
" \"userWithAuth\","
|
|
" \"restricted\","
|
|
" \"sign\""
|
|
" ],"
|
|
" \"authPolicy\":\"\","
|
|
" \"parameters\":{"
|
|
" \"symmetric\":{"
|
|
" \"algorithm\":\"NULL\""
|
|
" },"
|
|
" \"scheme\":{"
|
|
" \"scheme\":\"ECDAA\","
|
|
" \"details\":{"
|
|
" \"hashAlg\":\"SHA256\","
|
|
" \"count\":0"
|
|
" }"
|
|
" },"
|
|
" \"curveID\":\"ECC_BN_P256\","
|
|
" \"kdf\":{"
|
|
" \"scheme\":\"NULL\""
|
|
" }"
|
|
" },"
|
|
" \"unique\":{"
|
|
" \"x\": \"\",\n"
|
|
" \"y\": \"\"\n"
|
|
" }"
|
|
" }"
|
|
"}"
|
|
"";
|
|
const char *test_json_TPM2B_PUBLIC_dwnc_src =
|
|
"{"
|
|
" \"size\":0,"
|
|
" \"publicArea\":{"
|
|
" \"type\":\"ecc\","
|
|
" \"nameAlg\":\"sha1\","
|
|
" \"objectAttributes\":["
|
|
" \"fixedTPM\","
|
|
" \"fixedParent\","
|
|
" \"sensitiveDataOrigin\","
|
|
" \"userWithAuth\","
|
|
" \"restricted\","
|
|
" \"sign\""
|
|
" ],"
|
|
" \"authPolicy\":\"\","
|
|
" \"parameters\":{"
|
|
" \"symmetric\":{"
|
|
" \"algorithm\":\"null\""
|
|
" },"
|
|
" \"scheme\":{"
|
|
" \"scheme\":\"ecdaa\","
|
|
" \"details\":{"
|
|
" \"hashAlg\":\"sha256\","
|
|
" \"count\":0"
|
|
" }"
|
|
" },"
|
|
" \"curveID\":\"ecc_BN_P256\","
|
|
" \"kdf\":{"
|
|
" \"scheme\":\"null\""
|
|
" }"
|
|
" },"
|
|
" \"unique\":{"
|
|
" \"x\": \"\",\n"
|
|
" \"y\": \"\"\n"
|
|
" }"
|
|
" }"
|
|
" }"
|
|
"}"
|
|
"";
|
|
|
|
CHECK_JSON(TPM2B_PUBLIC, test_json_TPM2B_PUBLIC_src, test_json_TPM2B_PUBLIC_expected);
|
|
CHECK_JSON(TPM2B_PUBLIC, test_json_TPM2B_PUBLIC_dwnc_src, test_json_TPM2B_PUBLIC_expected);
|
|
|
|
const char *test_json_TPMS_ATTEST_certify_src =
|
|
"{\n"
|
|
" \"magic\": \"0xff544347\",\n"
|
|
" \"type\": \"ST_ATTEST_CERTIFY\",\n"
|
|
" \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"yes\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"name\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"qualifiedName\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMS_ATTEST_certify_expt =
|
|
"{\n"
|
|
" \"magic\": \"VALUE\",\n"
|
|
" \"type\": \"ATTEST_CERTIFY\",\n"
|
|
" \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"YES\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"name\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"qualifiedName\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_certify_src, test_json_TPMS_ATTEST_certify_expt);
|
|
|
|
const char *test_json_TPMS_ATTEST_sessionaudit_src =
|
|
"{\n"
|
|
" \"magic\": \"0xff544347\",\n"
|
|
" \"type\": \"ST_ATTEST_SESSION_AUDIT\",\n"
|
|
" \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": [12345,0],\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"yes\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": [783783,0],\n"
|
|
" \"attested\": {\n"
|
|
" \"exclusiveSession\": \"yes\",\n"
|
|
" \"sessionDigest\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMS_ATTEST_sessionaudit_expt =
|
|
"{\n"
|
|
" \"magic\": \"VALUE\",\n"
|
|
" \"type\": \"ATTEST_SESSION_AUDIT\",\n"
|
|
" \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 53021371269120,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"YES\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": [783783,0],\n"
|
|
" \"attested\": {\n"
|
|
" \"exclusiveSession\": \"YES\",\n"
|
|
" \"sessionDigest\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_sessionaudit_src, test_json_TPMS_ATTEST_sessionaudit_expt);
|
|
|
|
const char *test_json_TPMS_ATTEST_certifycreation_src =
|
|
"{\n"
|
|
" \"magic\": \"0xff544347\",\n"
|
|
" \"type\": \"ST_ATTEST_CREATION\",\n"
|
|
" \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"yes\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": [0,783],\n"
|
|
" \"attested\": {\n"
|
|
" \"objectName\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"creationHash\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMS_ATTEST_certifycreation_expt =
|
|
"{\n"
|
|
" \"magic\": \"VALUE\",\n"
|
|
" \"type\": \"ATTEST_CREATION\",\n"
|
|
" \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"YES\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"objectName\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"creationHash\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_certifycreation_src, test_json_TPMS_ATTEST_certifycreation_expt);
|
|
|
|
const char *test_json_TPMS_ATTEST_commandaudit_src =
|
|
"{\n"
|
|
" \"magic\": \"0xff544347\",\n"
|
|
" \"type\": \"ST_ATTEST_COMMAND_AUDIT\",\n"
|
|
" \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"yes\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"auditCounter\": 456,\n"
|
|
" \"digestAlg\": \"sha1\",\n"
|
|
" \"auditDigest\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"commandDigest\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMS_ATTEST_commandaudit_expt =
|
|
"{\n"
|
|
" \"magic\": \"VALUE\",\n"
|
|
" \"type\": \"ATTEST_COMMAND_AUDIT\",\n"
|
|
" \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"YES\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"auditCounter\": 456,\n"
|
|
" \"digestAlg\": \"SHA1\",\n"
|
|
" \"auditDigest\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"commandDigest\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_commandaudit_src, test_json_TPMS_ATTEST_commandaudit_expt);
|
|
|
|
const char *test_json_TPMS_ATTEST_time_src =
|
|
"{\n"
|
|
" \"magic\": \"0xff544347\",\n"
|
|
" \"type\": \"ST_ATTEST_TIME\",\n"
|
|
" \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"yes\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"time\": {\n"
|
|
" \"time\": 234,\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"yes\"\n"
|
|
" }\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMS_ATTEST_time_expt =
|
|
"{\n"
|
|
" \"magic\": \"VALUE\",\n"
|
|
" \"type\": \"ATTEST_TIME\",\n"
|
|
" \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"YES\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"time\": {\n"
|
|
" \"time\": 234,\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"YES\"\n"
|
|
" }\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_time_src, test_json_TPMS_ATTEST_time_expt);
|
|
|
|
const char *test_json_TPMS_ATTEST_certifynv_src =
|
|
"{\n"
|
|
" \"magic\": \"0xff544347\",\n"
|
|
" \"type\": \"ST_ATTEST_NV\",\n"
|
|
" \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"yes\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"indexName\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"offset\": 10,\n"
|
|
" \"nvContents\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMS_ATTEST_certifynv_expt =
|
|
"{\n"
|
|
" \"magic\": \"VALUE\",\n"
|
|
" \"type\": \"ATTEST_NV\",\n"
|
|
" \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
|
|
" \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
|
|
" \"clockInfo\": {\n"
|
|
" \"clock\": 123,\n"
|
|
" \"resetCount\": 23,\n"
|
|
" \"restartCount\": 1,\n"
|
|
" \"safe\": \"YES\"\n"
|
|
" },\n"
|
|
" \"firmwareVersion\": 783,\n"
|
|
" \"attested\": {\n"
|
|
" \"indexName\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
|
|
" \"offset\": 10,\n"
|
|
" \"nvContents\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_certifynv_src, test_json_TPMS_ATTEST_certifynv_expt);
|
|
|
|
const char *test_json_TPMT_KEYEDHASH_SCHEME_hmac_src =
|
|
"{\n"
|
|
" \"scheme\": \"HMAC\",\n"
|
|
" \"details\": {\n"
|
|
" \"hashAlg\": \"SHA256\"\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMT_KEYEDHASH_SCHEME_hmac_expt =
|
|
"{\n"
|
|
" \"scheme\": \"HMAC\",\n"
|
|
" \"details\": {\n"
|
|
" \"hashAlg\": \"SHA256\"\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMT_KEYEDHASH_SCHEME, test_json_TPMT_KEYEDHASH_SCHEME_hmac_src, test_json_TPMT_KEYEDHASH_SCHEME_hmac_expt);
|
|
|
|
const char *test_json_TPMT_KEYEDHASH_SCHEME_xor_src =
|
|
"{\n"
|
|
" \"scheme\": \"XOR\",\n"
|
|
" \"details\": {\n"
|
|
" \"hashAlg\": \"SHA256\",\n"
|
|
" \"kdf\": \"MGF1\"\n"
|
|
" }\n"
|
|
"}";
|
|
const char *test_json_TPMT_KEYEDHASH_SCHEME_xor_expt =
|
|
"{\n"
|
|
" \"scheme\": \"XOR\",\n"
|
|
" \"details\": {\n"
|
|
" \"hashAlg\": \"SHA256\",\n"
|
|
" \"kdf\": \"MGF1\"\n"
|
|
" }\n"
|
|
"}";
|
|
CHECK_JSON(TPMT_KEYEDHASH_SCHEME, test_json_TPMT_KEYEDHASH_SCHEME_xor_src, test_json_TPMT_KEYEDHASH_SCHEME_xor_expt);
|
|
|
|
}
|
|
|
|
static void
|
|
check_json_constants(void **state)
|
|
{
|
|
CHECK_JSON_SIMPLE(TPMI_ALG_HASH, "\"sha1\"", "\"SHA1\"");
|
|
CHECK_JSON_SIMPLE(TPMI_ALG_HASH, "\"0x04\"", "\"SHA1\"");
|
|
CHECK_JSON_SIMPLE(TPMI_ALG_HASH, "4", "\"SHA1\"");
|
|
}
|
|
|
|
static void
|
|
check_json_numbers(void **state)
|
|
{
|
|
CHECK_JSON_SIMPLE(UINT16, "10", "10");
|
|
CHECK_JSON_SIMPLE(UINT16, "\"0x0a\"", "10");
|
|
CHECK_JSON_SIMPLE(UINT64, "10000000000000000","[2328306,1874919424]");
|
|
}
|
|
|
|
static void
|
|
check_json_bits(void **state)
|
|
{
|
|
const char *test_json_TPMA_NV_expected =\
|
|
"{"
|
|
" \"PPWRITE\":0,"
|
|
" \"OWNERWRITE\":1,"
|
|
" \"AUTHWRITE\":1,"
|
|
" \"POLICYWRITE\":1,"
|
|
" \"POLICY_DELETE\":1,"
|
|
" \"WRITELOCKED\":0,"
|
|
" \"WRITEALL\":0,"
|
|
" \"WRITEDEFINE\":0,"
|
|
" \"WRITE_STCLEAR\":0,"
|
|
" \"GLOBALLOCK\":0,"
|
|
" \"PPREAD\":0,"
|
|
" \"OWNERREAD\":1,"
|
|
" \"AUTHREAD\":1,"
|
|
" \"POLICYREAD\":1,"
|
|
" \"NO_DA\":0,"
|
|
" \"ORDERLY\":1,"
|
|
" \"CLEAR_STCLEAR\":1,"
|
|
" \"READLOCKED\":1,"
|
|
" \"WRITTEN\":1,"
|
|
" \"PLATFORMCREATE\":0,"
|
|
" \"READ_STCLEAR\":0,"
|
|
" \"TPM2_NT\":\"COUNTER\""
|
|
"}";
|
|
|
|
const char *test_json_TPMA_NV_src_array =\
|
|
"["
|
|
" \"nv_ownerwrite\","
|
|
" \"nv_authwrite\","
|
|
" \"nv_policywrite\","
|
|
" \"nv_policy_delete\","
|
|
" \"nv_ownerread\","
|
|
" \"nv_authread\","
|
|
" \"nv_policyread\","
|
|
" \"nv_orderly\","
|
|
" \"nv_clear_stclear\","
|
|
" \"nv_readlocked\","
|
|
" \"nv_written\","
|
|
" {"
|
|
" \"TPM2_NT\": \"NT_COUNTER\""
|
|
" }"
|
|
"]";
|
|
|
|
const char *test_json_TPMA_NV_src_struct =\
|
|
"{"
|
|
" \"TPMA_NV_OWNERWRITE\":\"YES\","
|
|
" \"TPMA_NV_AUTHWRITE\":\"yes\","
|
|
" \"TPMA_NV_POLICYWRITE\":\"TPM2_YES\","
|
|
" \"TPMA_NV_POLICY_DELETE\":\"tpm2_yes\","
|
|
" \"TPMA_NV_OWNERREAD\":\"SET\","
|
|
" \"TPMA_NV_AUTHREAD\":\"set\","
|
|
" \"TPMA_NV_POLICYREAD\":1,"
|
|
" \"TPMA_NV_ORDERLY\":1,"
|
|
" \"TPMA_NV_CLEAR_STCLEAR\":1,"
|
|
" \"TPMA_NV_READLOCKED\":1,"
|
|
" \"TPMA_NV_WRITTEN\":1,"
|
|
" \"TPM2_NT\":1"
|
|
" }";
|
|
|
|
CHECK_JSON_SIMPLE(TPMA_NV, test_json_TPMA_NV_src_array, test_json_TPMA_NV_expected);
|
|
CHECK_JSON_SIMPLE(TPMA_NV, test_json_TPMA_NV_src_struct, test_json_TPMA_NV_expected);
|
|
}
|
|
|
|
static void
|
|
check_json_policy(void **state)
|
|
{
|
|
const char *test_json_policy_nv_src = \
|
|
"{"
|
|
" \"description\":\"Description pol_nv\","
|
|
" \"policyDigests\":["
|
|
" ],"
|
|
" \"policyAuthorizations\":["
|
|
" ],"
|
|
" \"policy\":["
|
|
" {"
|
|
" \"type\": \"POLICYNV\","
|
|
" \"nvPath\": \"myNV\","
|
|
" \"operandB\": \"01030304\""
|
|
" }"
|
|
" ]"
|
|
"}";
|
|
|
|
const char *test_json_policy_nv_expected = \
|
|
"{"
|
|
" \"description\":\"Description pol_nv\","
|
|
" \"policyDigests\":["
|
|
" ],"
|
|
" \"policyAuthorizations\":["
|
|
" ],"
|
|
" \"policy\":["
|
|
" {"
|
|
" \"type\": \"POLICYNV\","
|
|
" \"nvPath\": \"myNV\","
|
|
" \"operandB\": \"01030304\""
|
|
" }"
|
|
" ]"
|
|
"}";
|
|
|
|
|
|
// CHECK_JSON(TPMS_POLICY, test_json_policy_nv_src, test_json_policy_nv_expected);
|
|
{
|
|
TPMS_POLICY out;
|
|
TSS2_RC rc;
|
|
json_object *jso = json_tokener_parse(test_json_policy_nv_src);
|
|
if (!jso) fprintf(stderr, "JSON parsing failed\n");
|
|
assert_non_null(jso);
|
|
rc = ifapi_json_TPMS_POLICY_deserialize (jso, &out);
|
|
if (rc) fprintf(stderr, "Deserialization failed\n");
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
json_object_put(jso);
|
|
jso = NULL;
|
|
rc = ifapi_json_TPMS_POLICY_serialize (&out, &jso);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_non_null(jso);
|
|
const char *jso_string = json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY);
|
|
assert_non_null(jso_string);
|
|
char *string1 = normalize(jso_string);
|
|
char *string2 = normalize(test_json_policy_nv_expected);
|
|
assert_string_equal(string1, string2);
|
|
json_object_put(jso);
|
|
ifapi_cleanup_policy(&out);
|
|
free(string1);
|
|
free(string2);
|
|
}
|
|
|
|
const char *test_json_policy_or_src = \
|
|
"{"
|
|
" \"description\":\"hareness description\","
|
|
" \"policyDigests\":["
|
|
" {"
|
|
" \"hashAlg\":\"SHA256\","
|
|
" \"digest\":\"59215cb6c21a60e26b2cc479334a021113611903795507c1227659e2aef23d16\""
|
|
" }"
|
|
" ],"
|
|
" \"policy\":["
|
|
" {"
|
|
" \"type\":\"POLICYOR\","
|
|
" \"policyDigests\":["
|
|
" {"
|
|
" \"hashAlg\":\"SHA256\","
|
|
" \"digest\":\"59215cb6c21a60e26b2cc479334a021113611903795507c1227659e2aef23d16\""
|
|
" }"
|
|
" ],"
|
|
" \"branches\":["
|
|
" {"
|
|
" \"name\":\"branch1\","
|
|
" \"description\":\"description branch 1\","
|
|
" \"policy\":["
|
|
" {"
|
|
" \"type\":\"POLICYPCR\","
|
|
" \"policyDigests\":["
|
|
" {"
|
|
" \"hashAlg\":\"SHA256\","
|
|
" \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
|
|
" }"
|
|
" ],"
|
|
" \"pcrs\":["
|
|
" {"
|
|
" \"pcr\":16,"
|
|
" \"hashAlg\":\"SHA1\","
|
|
" \"digest\":\"0000000000000000000000000000000000000000\""
|
|
" }"
|
|
" ]"
|
|
" }"
|
|
" ],"
|
|
" \"policyDigests\":["
|
|
" {"
|
|
" \"hashAlg\":\"SHA256\","
|
|
" \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
|
|
" }"
|
|
" ]"
|
|
" },"
|
|
" {"
|
|
" \"name\":\"branch1\","
|
|
" \"description\":\"description branch 1\","
|
|
" \"policy\":["
|
|
" {"
|
|
" \"type\":\"POLICYPCR\","
|
|
" \"policyDigests\":["
|
|
" {"
|
|
" \"hashAlg\":\"SHA256\","
|
|
" \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
|
|
" }"
|
|
" ],"
|
|
" \"pcrs\":["
|
|
" {"
|
|
" \"pcr\":16,"
|
|
" \"hashAlg\":\"SHA1\","
|
|
" \"digest\":\"0000000000000000000000000000000000000000\""
|
|
" }"
|
|
" ]"
|
|
" }"
|
|
" ],"
|
|
" \"policyDigests\":["
|
|
" {"
|
|
" \"hashAlg\":\"SHA256\","
|
|
" \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
|
|
" }"
|
|
" ]"
|
|
" }"
|
|
" ]"
|
|
" }"
|
|
" ]"
|
|
"}";
|
|
|
|
char *test_json_policy_or_expected = strdup(test_json_policy_or_src);
|
|
if (test_json_policy_or_expected == NULL){
|
|
LOG_ERROR("%s", "Out of memory.");
|
|
return;
|
|
}
|
|
// CHECK_JSON(TPMS_POLICY, test_json_policy_or_src, test_json_policy_or_expected);
|
|
{
|
|
TPMS_POLICY out;
|
|
TSS2_RC rc;
|
|
json_object *jso = json_tokener_parse(test_json_policy_or_src);
|
|
if (!jso) fprintf(stderr, "JSON parsing failed\n");
|
|
assert_non_null(jso);
|
|
rc = ifapi_json_TPMS_POLICY_deserialize (jso, &out);
|
|
if (rc) fprintf(stderr, "Deserialization failed\n");
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
json_object_put(jso);
|
|
jso = NULL;
|
|
rc = ifapi_json_TPMS_POLICY_serialize (&out, &jso);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_non_null(jso);
|
|
const char *jso_string = json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY);
|
|
assert_non_null(jso_string);
|
|
char *string1 = normalize(jso_string);
|
|
char *string2 = normalize(test_json_policy_or_expected);
|
|
assert_string_equal(string1, string2);
|
|
json_object_put(jso);
|
|
ifapi_cleanup_policy(&out);
|
|
free(string1);
|
|
free(string2);
|
|
}
|
|
free(test_json_policy_or_expected);
|
|
}
|
|
|
|
|
|
static void
|
|
check_json_tpm2bs(void **state)
|
|
{
|
|
CHECK_JSON(TPM2B_DIGEST, "\"0x0102\"", "\"0102\"");
|
|
CHECK_JSON(TPM2B_DIGEST, "\"0102\"", "\"0102\"");
|
|
CHECK_JSON(TPM2B_DIGEST, "\"caffee\"", "\"caffee\"");
|
|
}
|
|
|
|
static void
|
|
check_error(void **state)
|
|
{
|
|
/* Value is > then max value for UINT */
|
|
CHECK_ERROR(UINT16, "\"0x10000\"", TSS2_FAPI_RC_BAD_VALUE);
|
|
CHECK_ERROR(UINT32, "\"0x100000000\"", TSS2_FAPI_RC_BAD_VALUE);
|
|
|
|
/* Digest/list is too large*/
|
|
CHECK_ERROR(TPM2B_DIGEST, "\"0x0102222222222222222222222222222222222222222222222222222"
|
|
"22222222222222222222222222222222222222222222222222222222222222222222222222222\"",
|
|
TSS2_FAPI_RC_BAD_VALUE);
|
|
|
|
/* Illegal values */
|
|
CHECK_ERROR(TPMI_ALG_HASH, "\"SHA9999\"", TSS2_FAPI_RC_BAD_VALUE);
|
|
CHECK_ERROR(TPM2B_DIGEST, "\"xxxx\"", TSS2_FAPI_RC_BAD_VALUE);
|
|
CHECK_ERROR(TPM2B_DIGEST, "\"0x010x\"", TSS2_FAPI_RC_BAD_VALUE);
|
|
}
|
|
|
|
|
|
static void
|
|
check_tpmjson_tofromtxt(void **state)
|
|
{
|
|
const char *testcase_alg_id[] = { "\"TPM_ALG_ID_SHA1\"", "\"TPM2_ALG_ID_SHA1\"",
|
|
"\"ALG_ID_SHA1\"", "\"SHA1\"", "\"ALG_SHA1\"",
|
|
"\"tpm2_alg_id_sha1\"", "\"sha1\"", "\"0x0004\"" };
|
|
const char *expected_ald_id = { "\"SHA1\"" };
|
|
for (size_t i = 0; i < sizeof(testcase_alg_id) / sizeof(testcase_alg_id[0]); i++) {
|
|
CHECK_JSON_SIMPLE(TPM2_ALG_ID, testcase_alg_id[i], expected_ald_id);
|
|
}
|
|
|
|
const char *testcase_ecc_curve[] = { "\"TPM2_ECC_NIST_P256\"", "\"ECC_NIST_P256\"",
|
|
"\"NIST_P256\"", "\"0x0003\"", "\"nist_p256\"" };
|
|
const char *expected_ecc_curve = { "\"NIST_P256\"" };
|
|
for (size_t i = 0; i < sizeof(testcase_ecc_curve) / sizeof(testcase_ecc_curve[0]); i++) {
|
|
CHECK_JSON_SIMPLE(TPM2_ECC_CURVE, testcase_ecc_curve[i], expected_ecc_curve);
|
|
}
|
|
|
|
const char *testcase_cc[] = { "\"TPM2_CC_Startup\"", "\"CC_Startup\"",
|
|
"\"Startup\"", "\"0x00000144\"" };
|
|
const char *expected_cc = { "\"Startup\"" };
|
|
for (size_t i = 0; i < sizeof(testcase_cc) / sizeof(testcase_cc[0]); i++) {
|
|
CHECK_JSON_SIMPLE(TPM2_CC, testcase_cc[i], expected_cc);
|
|
}
|
|
|
|
const char *testcase_eo[] = { "\"TPM2_EO_EQ\"", "\"EO_EQ\"",
|
|
"\"EQ\"", "\"0x0000\"" };
|
|
const char *expected_eo = { "\"EQ\"" };
|
|
for (size_t i = 0; i < sizeof(testcase_eo) / sizeof(testcase_eo[0]); i++) {
|
|
CHECK_JSON_SIMPLE(TPM2_EO, testcase_eo[i], expected_eo);
|
|
}
|
|
|
|
const char *testcase_st[] = { "\"TPM2_ST_NO_SESSIONS\"", "\"ST_NO_SESSIONS\"",
|
|
"\"no_SESSIONS\"", "\"0x8001\"" };
|
|
const char *expected_st = { "\"NO_SESSIONS\"" };
|
|
for (size_t i = 0; i < sizeof(testcase_st) / sizeof(testcase_st[0]); i++) {
|
|
CHECK_JSON_SIMPLE(TPM2_ST, testcase_st[i], expected_st);
|
|
}
|
|
|
|
const char *testcase_pt_pcr[] = { "\"TPM2_PT_PCR_EXTEND_L0\"", "\"PT_PCR_EXTEND_L0\"",
|
|
"\"PCR_EXTEND_L0\"", "\"EXTEND_L0\"" };
|
|
const char *expected_pt_pcr = { "\"EXTEND_L0\"" };
|
|
for (size_t i = 0; i < sizeof(testcase_pt_pcr) / sizeof(testcase_pt_pcr[0]); i++) {
|
|
CHECK_JSON_SIMPLE(TPM2_PT_PCR, testcase_pt_pcr[i], expected_pt_pcr);
|
|
}
|
|
|
|
const char *testcase_alg_public[] = { "\"TPM2_ALG_RSA\"", "\"ALG_RSA\"",
|
|
"\"RSA\"", "\"0x0001\"" };
|
|
const char *expected_alg_public = { "\"RSA\"" };
|
|
for (size_t i = 0; i < sizeof(testcase_alg_public) / sizeof(testcase_alg_public[0]); i++) {
|
|
CHECK_JSON_SIMPLE(TPMI_ALG_PUBLIC, testcase_alg_public[i], expected_alg_public);
|
|
}
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
const struct CMUnitTest tests[] = {
|
|
cmocka_unit_test(check_tpmjson_tofromtxt),
|
|
cmocka_unit_test(check_json_structs),
|
|
cmocka_unit_test(check_json_constants),
|
|
cmocka_unit_test(check_json_numbers),
|
|
cmocka_unit_test(check_json_bits),
|
|
cmocka_unit_test(check_json_tpm2bs),
|
|
cmocka_unit_test(check_json_to_bin),
|
|
cmocka_unit_test(check_bin),
|
|
cmocka_unit_test(check_policy_bin),
|
|
cmocka_unit_test(check_error),
|
|
cmocka_unit_test(check_json_policy),
|
|
};
|
|
return cmocka_run_group_tests(tests, NULL, NULL);
|
|
}
|