king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd5f7aa4152'
${ noResults }
v811_spc009/external/tpm2-tss/test/unit/esys-resubmissions.c

3027 lines
107 KiB
Raw Blame History

/* SPDX-License-Identifier: BSD-2-Clause */
/*******************************************************************************
* Copyright 2017-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 <setjmp.h>
#include <cmocka.h>
#include "tss2_esys.h"
#include "tss2-esys/esys_iutil.h"
#define LOGMODULE tests
#include "util/log.h"
#include "util/aux_util.h"
/**
* This unit test looks into a set of Esys_<cmd>() functions and tests the
* resubmission behaviour. The ESAPI is expected to resubmit a command for a
* certain number of times if the TPM return RC_YIELDED. After this number of
* times, the ESAPI shall not try it any further but return the TPM's error.
* For all these resubmissions the command must be the same as before.
* This shall be extended to cover all functions at some point.
*/
#define TCTI_YIELDER_MAGIC 0x5949454c44455200ULL /* 'YIELDER\0' */
#define TCTI_YIELDER_VERSION 0x1
/*
* Esys handles for dummy session and key objects, and initialization values for
* other objects, which can be used in ESAPI test calls
*/
#define DUMMY_TR_HANDLE_POLICY_SESSION ESYS_TR_MIN_OBJECT
#define DUMMY_TR_HANDLE_KEY ESYS_TR_MIN_OBJECT+1
#define DUMMY_TR_HANDLE_NV_INDEX ESYS_TR_MIN_OBJECT+2
#define DUMMY_TR_HANDLE_HIERARCHY_OWNER ESYS_TR_MIN_OBJECT+3
#define DUMMY_TR_HANDLE_HIERARCHY_PLATFORM ESYS_TR_MIN_OBJECT+4
#define DUMMY_TR_HANDLE_PRIVACY_ADMIN ESYS_TR_MIN_OBJECT+5
#define DUMMY_TR_HANDLE_HMAC_SESSION ESYS_TR_MIN_OBJECT+6
#define DUMMY_TR_HANDLE_LOCKOUT ESYS_TR_MIN_OBJECT+7
#define DUMMY_IN_PUBLIC_DATA { \
.size = 0, \
.publicArea = { \
.type = TPM2_ALG_ECC, \
.nameAlg = TPM2_ALG_SHA256, \
.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_ECDSA, \
.details = { \
.ecdsa = \
{. \
hashAlg \
= \
TPM2_ALG_SHA256}}, \
}, \
.curveID = TPM2_ECC_NIST_P256, \
.kdf = { \
.scheme = TPM2_ALG_NULL, \
.details = {}} \
}, \
.unique.ecc = { \
.x = {.size = 0,.buffer = {}}, \
.y = {.size = 0,.buffer = {}}, \
}, \
}, \
}
#define DUMMY_TPMT_PUBLIC_PARAMS { \
.type = TPM2_ALG_ECC, \
.parameters.eccDetail = { \
.symmetric = { \
.algorithm = \
TPM2_ALG_NULL, \
.keyBits.aes = \
128, \
.mode.aes = \
TPM2_ALG_ECB, \
}, \
.scheme = { \
.scheme = \
TPM2_ALG_ECDSA, \
.details = { \
.ecdsa = \
{. \
hashAlg \
= \
TPM2_ALG_SHA256}}, \
}, \
.curveID = TPM2_ECC_NIST_P256, \
.kdf = { \
.scheme = TPM2_ALG_NULL, \
.details = {}} \
} \
}
#define DUMMY_2B_DATA(NAME) { \
.size = 20, \
NAME = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, \
11, 12, 13, 14, 15, 16, 17, 18, 19, 20} \
}
#define DUMMY_2B_DATA16(NAME) { \
.size = 16, \
NAME = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, \
11, 12, 13, 14, 15, 16 } \
}
#define DUMMY_2B_DATA0 { \
.size = 0, \
.buffer = {}, \
}
#define DUMMY_SYMMETRIC {.algorithm = TPM2_ALG_AES, \
.keyBits = {.aes = 128}, \
.mode = {.aes = TPM2_ALG_CFB} \
}
#define DUMMY_TPMT_TK_AUTH { .tag = TPM2_ST_AUTH_SIGNED , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
#define DUMMY_TPMT_TK_CREATION { .tag = TPM2_ST_CREATION , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
#define DUMMY_TPMT_TK_VERIFIED { .tag = TPM2_ST_VERIFIED , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
#define DUMMY_TPMT_TK_HASHCHECK { .tag = TPM2_ST_HASHCHECK , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
#define DUMMY_RSA_DECRYPT { .scheme = TPM2_ALG_NULL }
#define DUMMY_TPMT_SIGNATURE { \
.sigAlg = TPM2_ALG_RSAPSS, \
.signature = { \
.rsapss = { \
.hash = TPM2_ALG_SHA1, .sig= {0} \
} \
} \
};
typedef struct {
uint64_t magic;
uint32_t version;
TSS2_TCTI_TRANSMIT_FCN transmit;
TSS2_TCTI_RECEIVE_FCN receive;
TSS2_RC(*finalize) (TSS2_TCTI_CONTEXT * tctiContext);
TSS2_RC(*cancel) (TSS2_TCTI_CONTEXT * tctiContext);
TSS2_RC(*getPollHandles) (TSS2_TCTI_CONTEXT * tctiContext,
TSS2_TCTI_POLL_HANDLE * handles,
size_t * num_handles);
TSS2_RC(*setLocality) (TSS2_TCTI_CONTEXT * tctiContext, uint8_t locality);
uint32_t count;
uint8_t cmd[4096];
} TSS2_TCTI_CONTEXT_YIELDER;
static TSS2_TCTI_CONTEXT_YIELDER *
tcti_yielder_cast(TSS2_TCTI_CONTEXT * ctx)
{
TSS2_TCTI_CONTEXT_YIELDER *ctxi = (TSS2_TCTI_CONTEXT_YIELDER *) ctx;
if (ctxi == NULL || ctxi->magic != TCTI_YIELDER_MAGIC) {
LOG_ERROR("Bad tcti passed.");
return NULL;
}
return ctxi;
}
static TSS2_RC
tcti_yielder_transmit(TSS2_TCTI_CONTEXT * tctiContext,
size_t size, const uint8_t * buffer)
{
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tctiContext);
if (size > sizeof(tcti_yielder->cmd)) {
LOG_ERROR("Bad size value.");
return TSS2_TCTI_RC_INSUFFICIENT_BUFFER;
}
if (tcti_yielder->count != 0)
assert_memory_equal(&tcti_yielder->cmd[0], buffer, size);
tcti_yielder->count++;
memcpy(&tcti_yielder->cmd[0], buffer, size);
return TSS2_RC_SUCCESS;
}
const uint8_t yielded_response[] = {
0x80, 0x01, /* TPM_ST_NO_SESSION */
0x00, 0x00, 0x00, 0x0A, /* Response Size 10 */
0x00, 0x00, 0x09, 0x08 /* TPM_RC_YIELDED */
};
static TSS2_RC
tcti_yielder_receive(TSS2_TCTI_CONTEXT * tctiContext,
size_t * response_size,
uint8_t * response_buffer, int32_t timeout)
{
*response_size = sizeof(yielded_response);
if (response_buffer != NULL)
memcpy(response_buffer, &yielded_response[0], sizeof(yielded_response));
return TSS2_RC_SUCCESS;
}
static void
tcti_yielder_finalize(TSS2_TCTI_CONTEXT * tctiContext)
{
memset(tctiContext, 0, sizeof(TSS2_TCTI_CONTEXT_YIELDER));
}
static TSS2_RC
tcti_yielder_initialize(TSS2_TCTI_CONTEXT * tctiContext, size_t * contextSize)
{
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder =
(TSS2_TCTI_CONTEXT_YIELDER *) tctiContext;
if (tctiContext == NULL && contextSize == NULL) {
return TSS2_TCTI_RC_BAD_VALUE;
} else if (tctiContext == NULL) {
*contextSize = sizeof(*tcti_yielder);
return TSS2_RC_SUCCESS;
}
/* Init TCTI context */
memset(tcti_yielder, 0, sizeof(*tcti_yielder));
TSS2_TCTI_MAGIC(tctiContext) = TCTI_YIELDER_MAGIC;
TSS2_TCTI_VERSION(tctiContext) = TCTI_YIELDER_VERSION;
TSS2_TCTI_TRANSMIT(tctiContext) = tcti_yielder_transmit;
TSS2_TCTI_RECEIVE(tctiContext) = tcti_yielder_receive;
TSS2_TCTI_FINALIZE(tctiContext) = tcti_yielder_finalize;
TSS2_TCTI_CANCEL(tctiContext) = NULL;
TSS2_TCTI_GET_POLL_HANDLES(tctiContext) = NULL;
TSS2_TCTI_SET_LOCALITY(tctiContext) = NULL;
tcti_yielder->count = 0;
return TSS2_RC_SUCCESS;
}
static int
setup(void **state)
{
TSS2_RC r;
ESYS_CONTEXT *ectx;
size_t size = sizeof(TSS2_TCTI_CONTEXT_YIELDER);
TSS2_TCTI_CONTEXT *tcti = malloc(size);
ESYS_TR objectHandle;
RSRC_NODE_T *objectHandleNode = NULL;
r = tcti_yielder_initialize(tcti, &size);
if (r)
return (int)r;
r = Esys_Initialize(&ectx, tcti, NULL);
if (r)
return (int)r;
/* Create dummy object to enable usage of SAPI prepare functions in the tests */
objectHandle = DUMMY_TR_HANDLE_POLICY_SESSION;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_SESSION_RSRC;
objectHandleNode->rsrc.handle = TPM2_POLICY_SESSION_FIRST;
objectHandle = DUMMY_TR_HANDLE_HMAC_SESSION;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_SESSION_RSRC;
objectHandleNode->rsrc.handle = TPM2_HMAC_SESSION_FIRST;
objectHandle = DUMMY_TR_HANDLE_KEY;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_KEY_RSRC;
objectHandleNode->rsrc.handle = TPM2_TRANSIENT_FIRST;
objectHandle = DUMMY_TR_HANDLE_HIERARCHY_OWNER;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
objectHandleNode->rsrc.handle = TPM2_RH_OWNER;
objectHandle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
objectHandleNode->rsrc.handle = TPM2_RH_PLATFORM;
objectHandle = DUMMY_TR_HANDLE_LOCKOUT;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
objectHandleNode->rsrc.handle = TPM2_RH_LOCKOUT;
objectHandle = DUMMY_TR_HANDLE_NV_INDEX;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
objectHandleNode->rsrc.handle = TPM2_NV_INDEX_FIRST;
objectHandle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
if (r)
return (int)r;
objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
objectHandleNode->rsrc.handle = TPM2_RH_ENDORSEMENT;
*state = (void *)ectx;
return 0;
}
static int
teardown(void **state)
{
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *ectx = (ESYS_CONTEXT *) * state;
Esys_GetTcti(ectx, &tcti);
Esys_Finalize(&ectx);
free(tcti);
return 0;
}
static void
test_Startup(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2_SU startupType = TPM2_SU_CLEAR;
r = Esys_Startup(esys_context, startupType);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Shutdown(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2_SU shutdownType = TPM2_SU_CLEAR;
r = Esys_Shutdown(esys_context,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, shutdownType);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_SelfTest(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
r = Esys_SelfTest(esys_context,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, 0);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_IncrementalSelfTest(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPML_ALG toTest = {0};
TPML_ALG *toDoList = {0} ;
r = Esys_IncrementalSelfTest(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &toTest, &toDoList);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_GetTestResult(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_MAX_BUFFER *outData;
TPM2_RC testResult;
r = Esys_GetTestResult(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, &outData, &testResult);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_StartAuthSession(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR tpmKey_handle = ESYS_TR_NONE;
ESYS_TR bind_handle = ESYS_TR_NONE;
TPM2B_NONCE nonceCaller = DUMMY_2B_DATA(.buffer);
TPM2_SE sessionType = TPM2_SE_HMAC;
TPMT_SYM_DEF symmetric = {.algorithm = TPM2_ALG_AES,
.keyBits = {.aes = 128},
.mode = {.aes = TPM2_ALG_CFB}
};
TPMI_ALG_HASH authHash = TPM2_ALG_SHA1;
ESYS_TR sessionHandle_handle;
r = Esys_StartAuthSession(esys_context,
tpmKey_handle,
bind_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&nonceCaller,
sessionType,
&symmetric,
authHash, &sessionHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyRestart(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
r = Esys_PolicyRestart(esys_context,
DUMMY_TR_HANDLE_POLICY_SESSION,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Create(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_SENSITIVE_CREATE inSensitive = { 0 };
TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
TPM2B_DATA outsideInfo = DUMMY_2B_DATA0;
TPML_PCR_SELECTION creationPCR = {
.count = 0,
};
TPM2B_PRIVATE *outPrivate;
TPM2B_PUBLIC *outPublic;
TPM2B_CREATION_DATA *creationData;
TPM2B_DIGEST *creationHash;
TPMT_TK_CREATION *creationTicket;
r = Esys_Create(esys_context,
DUMMY_TR_HANDLE_KEY,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&inSensitive,
&inPublic,
&outsideInfo,
&creationPCR,
&outPrivate,
&outPublic, &creationData, &creationHash, &creationTicket);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Load(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_PRIVATE inPrivate = DUMMY_2B_DATA(.buffer);
TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
ESYS_TR objectHandle_handle;
r = Esys_Load(esys_context,
DUMMY_TR_HANDLE_KEY,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &inPrivate, &inPublic, &objectHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_LoadExternal(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
ESYS_TR objectHandle_handle;
r = Esys_LoadExternal(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
NULL, &inPublic, TPM2_RH_OWNER, &objectHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ReadPublic(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_PUBLIC *outPublic;
TPM2B_NAME *name;
TPM2B_NAME *qualifiedName;
r = Esys_ReadPublic(esys_context,
objectHandle_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &outPublic, &name, &qualifiedName);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ActivateCredential(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR activateHandle_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_ID_OBJECT credentialBlob = DUMMY_2B_DATA(.credential);
TPM2B_ENCRYPTED_SECRET secret = DUMMY_2B_DATA(.secret);;
TPM2B_DIGEST *certInfo;
r = Esys_ActivateCredential(esys_context,
activateHandle_handle,
keyHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
&credentialBlob, &secret, &certInfo);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_MakeCredential(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR handle_handle = ESYS_TR_NONE;
TPM2B_DIGEST credential = DUMMY_2B_DATA(.buffer);
TPM2B_NAME objectName = DUMMY_2B_DATA(.name);;
TPM2B_ID_OBJECT *credentialBlob;
TPM2B_ENCRYPTED_SECRET *secret;
r = Esys_MakeCredential(esys_context,
handle_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&credential, &objectName, &credentialBlob, &secret);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Unseal(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR itemHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_SENSITIVE_DATA *outData;
r = Esys_Unseal(esys_context,
itemHandle_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, &outData);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ObjectChangeAuth(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR parentHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_AUTH newAuth = DUMMY_2B_DATA(.buffer);
TPM2B_PRIVATE *outPrivate;
r = Esys_ObjectChangeAuth(esys_context,
objectHandle_handle,
parentHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &newAuth, &outPrivate);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Duplicate(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR newParentHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DATA encryptionKeyIn = DUMMY_2B_DATA(.buffer);
TPMT_SYM_DEF_OBJECT symmetricAlg = DUMMY_SYMMETRIC;
TPM2B_DATA *encryptionKeyOut;
TPM2B_PRIVATE *duplicate;
TPM2B_ENCRYPTED_SECRET *outSymSeed;
r = Esys_Duplicate(esys_context,
objectHandle_handle,
newParentHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&encryptionKeyIn,
&symmetricAlg,
&encryptionKeyOut, &duplicate, &outSymSeed);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Rewrap(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR oldParent_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR newParent_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_PRIVATE inDuplicate = DUMMY_2B_DATA(.buffer);
TPM2B_NAME name = DUMMY_2B_DATA(.name);
TPM2B_ENCRYPTED_SECRET inSymSeed = DUMMY_2B_DATA(.secret);
TPM2B_PRIVATE *outDuplicate;
TPM2B_ENCRYPTED_SECRET *outSymSeed;
r = Esys_Rewrap(esys_context,
oldParent_handle,
newParent_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&inDuplicate,
&name, &inSymSeed, &outDuplicate, &outSymSeed);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Import(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR parentHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DATA encryptionKey = DUMMY_2B_DATA(.buffer);
TPM2B_PUBLIC objectPublic = DUMMY_IN_PUBLIC_DATA;
TPM2B_PRIVATE duplicate = DUMMY_2B_DATA(.buffer);
TPM2B_ENCRYPTED_SECRET inSymSeed = DUMMY_2B_DATA(.secret);
TPMT_SYM_DEF_OBJECT symmetricAlg = DUMMY_SYMMETRIC;
TPM2B_PRIVATE *outPrivate;
r = Esys_Import(esys_context,
parentHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&encryptionKey,
&objectPublic,
&duplicate, &inSymSeed, &symmetricAlg, &outPrivate);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_RSA_Encrypt(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_PUBLIC_KEY_RSA message = DUMMY_2B_DATA(.buffer);
TPMT_RSA_DECRYPT inScheme = DUMMY_RSA_DECRYPT;
TPM2B_DATA label = DUMMY_2B_DATA(.buffer);
TPM2B_PUBLIC_KEY_RSA *outData;
r = Esys_RSA_Encrypt(esys_context,
keyHandle_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &message, &inScheme, &label, &outData);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_RSA_Decrypt(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_PUBLIC_KEY_RSA cipherText = DUMMY_2B_DATA(.buffer);
TPMT_RSA_DECRYPT inScheme = DUMMY_RSA_DECRYPT;
TPM2B_DATA label = DUMMY_2B_DATA(.buffer);
TPM2B_PUBLIC_KEY_RSA *message;
r = Esys_RSA_Decrypt(esys_context,
keyHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&cipherText, &inScheme, &label, &message);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ECDH_KeyGen(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_ECC_POINT *zPoint;
TPM2B_ECC_POINT *pubPoint;
r = Esys_ECDH_KeyGen(esys_context,
keyHandle_handle,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, &zPoint, &pubPoint);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ECDH_ZGen(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_ECC_POINT inPoint = { 0 };
TPM2B_ECC_POINT *outPoint;
r = Esys_ECDH_ZGen(esys_context,
keyHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &inPoint, &outPoint);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ECC_Parameters(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPMI_ECC_CURVE curveID = TPM2_ECC_BN_P256;
TPMS_ALGORITHM_DETAIL_ECC *parameters;
r = Esys_ECC_Parameters(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, curveID, &parameters);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ZGen_2Phase(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyA_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_ECC_POINT inQsB = { 0 };
TPM2B_ECC_POINT inQeB = { 0 };
TPMI_ECC_KEY_EXCHANGE inScheme = TPM2_ALG_NULL;
UINT16 counter = 0;
TPM2B_ECC_POINT *outZ1;
TPM2B_ECC_POINT *outZ2;
r = Esys_ZGen_2Phase(esys_context,
keyA_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&inQsB, &inQeB, inScheme, counter, &outZ1, &outZ2);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_EncryptDecrypt(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPMI_YES_NO decrypt = 0;
TPMI_ALG_SYM_MODE mode = TPM2_ALG_NULL;
TPM2B_IV ivIn = DUMMY_2B_DATA16(.buffer);
TPM2B_MAX_BUFFER inData = DUMMY_2B_DATA(.buffer);
TPM2B_MAX_BUFFER *outData;
TPM2B_IV *ivOut;
r = Esys_EncryptDecrypt(esys_context,
keyHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
decrypt, mode, &ivIn, &inData, &outData, &ivOut);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_EncryptDecrypt2(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_MAX_BUFFER inData = DUMMY_2B_DATA(.buffer);
TPMI_YES_NO decrypt = 0;
TPMI_ALG_SYM_MODE mode = TPM2_ALG_NULL;
TPM2B_IV ivIn = DUMMY_2B_DATA16(.buffer);
TPM2B_MAX_BUFFER *outData;
TPM2B_IV *ivOut;
r = Esys_EncryptDecrypt2(esys_context,
keyHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&inData, decrypt, mode, &ivIn, &outData, &ivOut);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Hash(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_MAX_BUFFER data = DUMMY_2B_DATA(.buffer);
TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
TPMI_RH_HIERARCHY hierarchy = TPM2_RH_OWNER;
TPM2B_DIGEST *outHash;
TPMT_TK_HASHCHECK *validation;
r = Esys_Hash(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&data, hashAlg, hierarchy, &outHash, &validation);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_HMAC(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR handle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
TPM2B_DIGEST *outHMAC;
r = Esys_HMAC(esys_context,
handle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &buffer, hashAlg, &outHMAC);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_GetRandom(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
UINT16 bytesRequested = 0;
TPM2B_DIGEST *randomBytes;
r = Esys_GetRandom(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, bytesRequested, &randomBytes);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_StirRandom(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_SENSITIVE_DATA inData = DUMMY_2B_DATA(.buffer);
r = Esys_StirRandom(esys_context,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &inData);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_HMAC_Start(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR handle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_AUTH auth = DUMMY_2B_DATA(.buffer);
TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
ESYS_TR sequenceHandle_handle;
r = Esys_HMAC_Start(esys_context,
handle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &auth, hashAlg, &sequenceHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_HashSequenceStart(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_AUTH auth = DUMMY_2B_DATA(.buffer);
TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
ESYS_TR sequenceHandle_handle;
r = Esys_HashSequenceStart(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&auth, hashAlg, &sequenceHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_SequenceUpdate(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR sequenceHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
r = Esys_SequenceUpdate(esys_context,
sequenceHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &buffer);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_SequenceComplete(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR sequenceHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
TPMI_RH_HIERARCHY hierarchy = TPM2_RH_OWNER;
TPM2B_DIGEST *result;
TPMT_TK_HASHCHECK *validation;
r = Esys_SequenceComplete(esys_context,
sequenceHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&buffer, hierarchy, &result, &validation);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_EventSequenceComplete(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR pcrHandle_handle = 16;
ESYS_TR sequenceHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
TPML_DIGEST_VALUES *results;
r = Esys_EventSequenceComplete(esys_context,
pcrHandle_handle,
sequenceHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, &buffer, &results);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Certify(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
TPM2B_ATTEST *certifyInfo;
TPMT_SIGNATURE *signature;
r = Esys_Certify(esys_context,
objectHandle_handle,
signHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
&qualifyingData, &inScheme, &certifyInfo, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_CertifyCreation(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
TPM2B_DIGEST creationHash = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
TPMT_TK_CREATION creationTicket = DUMMY_TPMT_TK_CREATION;
TPM2B_ATTEST *certifyInfo;
TPMT_SIGNATURE *signature;
r = Esys_CertifyCreation(esys_context,
signHandle_handle,
objectHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&qualifyingData,
&creationHash,
&inScheme,
&creationTicket, &certifyInfo, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Quote(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
TPML_PCR_SELECTION PCRselect = { 0 };
TPM2B_ATTEST *quoted;
TPMT_SIGNATURE *signature;
r = Esys_Quote(esys_context,
signHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&qualifyingData, &inScheme, &PCRselect, &quoted, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_GetSessionAuditDigest(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR privacyAdminHandle_handle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR sessionHandle_handle = DUMMY_TR_HANDLE_HMAC_SESSION;
TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
TPM2B_ATTEST *auditInfo;
TPMT_SIGNATURE *signature;
r = Esys_GetSessionAuditDigest(esys_context,
privacyAdminHandle_handle,
signHandle_handle,
sessionHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
&qualifyingData,
&inScheme, &auditInfo, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_GetCommandAuditDigest(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR privacyHandle_handle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
TPM2B_ATTEST *auditInfo;
TPMT_SIGNATURE *signature;
r = Esys_GetCommandAuditDigest(esys_context,
privacyHandle_handle,
signHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
&qualifyingData,
&inScheme, &auditInfo, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_GetTime(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR privacyAdminHandle_handle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
TPM2B_ATTEST *timeInfo;
TPMT_SIGNATURE *signature;
r = Esys_GetTime(esys_context,
privacyAdminHandle_handle,
signHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
&qualifyingData, &inScheme, &timeInfo, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Commit(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_ECC_POINT P1 = { 0 };
TPM2B_SENSITIVE_DATA s2 = DUMMY_2B_DATA(.buffer);
TPM2B_ECC_PARAMETER y2 = { 0 };
TPM2B_ECC_POINT *K;
TPM2B_ECC_POINT *L;
TPM2B_ECC_POINT *E;
UINT16 counter;
r = Esys_Commit(esys_context,
signHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &P1, &s2, &y2, &K, &L, &E, &counter);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_EC_Ephemeral(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPMI_ECC_CURVE curveID = TPM2_ECC_BN_P256;
TPM2B_ECC_POINT *Q;
UINT16 counter;
r = Esys_EC_Ephemeral(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, curveID, &Q, &counter);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_VerifySignature(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DIGEST digest = DUMMY_2B_DATA(.buffer);
TPMT_SIGNATURE signature = DUMMY_TPMT_SIGNATURE;
TPMT_TK_VERIFIED *validation;
r = Esys_VerifySignature(esys_context,
keyHandle_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &digest, &signature, &validation);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Sign(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DIGEST digest = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
TPMT_TK_HASHCHECK validation = DUMMY_TPMT_TK_HASHCHECK;
TPMT_SIGNATURE *signature;
r = Esys_Sign(esys_context,
keyHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &digest, &inScheme, &validation, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_SetCommandCodeAuditStatus(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPMI_ALG_HASH auditAlg = TPM2_ALG_SHA1;
TPML_CC setList = { 0 };
TPML_CC clearList = { 0 };
r = Esys_SetCommandCodeAuditStatus(esys_context,
auth_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
auditAlg, &setList, &clearList);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PCR_Extend(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR pcrHandle_handle = 16;
TPML_DIGEST_VALUES digests = { 0 };
r = Esys_PCR_Extend(esys_context,
pcrHandle_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, &digests);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PCR_Event(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR pcrHandle_handle = 16;
TPM2B_EVENT eventData = DUMMY_2B_DATA(.buffer);
TPML_DIGEST_VALUES *digests;
r = Esys_PCR_Event(esys_context,
pcrHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &eventData, &digests);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PCR_Read(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPML_PCR_SELECTION pcrSelectionIn = { 0 };
TPML_PCR_SELECTION *pcrSelectionOut;
TPML_DIGEST *pcrValues;
UINT32 pcrUpdateCounter;
r = Esys_PCR_Read(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&pcrSelectionIn,
&pcrUpdateCounter, &pcrSelectionOut, &pcrValues);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PCR_Allocate(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPML_PCR_SELECTION pcrAllocation = { 0 };
TPMI_YES_NO allocationSuccess;
UINT32 maxPCR;
UINT32 sizeNeeded;
UINT32 sizeAvailable;
r = Esys_PCR_Allocate(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&pcrAllocation,
&allocationSuccess,
&maxPCR, &sizeNeeded, &sizeAvailable);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PCR_SetAuthPolicy(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPM2B_DIGEST authPolicy = DUMMY_2B_DATA(.buffer);
TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
TPMI_DH_PCR pcrNum = 0;
r = Esys_PCR_SetAuthPolicy(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &authPolicy, hashAlg, pcrNum);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PCR_SetAuthValue(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR pcrHandle_handle = 16;
TPM2B_DIGEST auth = DUMMY_2B_DATA(.buffer);
r = Esys_PCR_SetAuthValue(esys_context,
pcrHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &auth);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PCR_Reset(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR pcrHandle_handle = 16;
r = Esys_PCR_Reset(esys_context,
pcrHandle_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicySigned(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authObject_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_NONCE nonceTPM = DUMMY_2B_DATA(.buffer);
TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
INT32 expiration = 0;
TPMT_SIGNATURE auth = DUMMY_TPMT_SIGNATURE;
TPM2B_TIMEOUT *timeout;
TPMT_TK_AUTH *policyTicket;
r = Esys_PolicySigned(esys_context,
authObject_handle,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&nonceTPM,
&cpHashA,
&policyRef,
expiration, &auth, &timeout, &policyTicket);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicySecret(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_NONCE nonceTPM = DUMMY_2B_DATA(.buffer);
TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
INT32 expiration = 0;
TPM2B_TIMEOUT *timeout;
TPMT_TK_AUTH *policyTicket;
r = Esys_PolicySecret(esys_context,
authHandle_handle,
policySession_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&nonceTPM,
&cpHashA,
&policyRef, expiration, &timeout, &policyTicket);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyTicket(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_TIMEOUT timeout = DUMMY_2B_DATA(.buffer);
TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
TPM2B_NAME authName = DUMMY_2B_DATA(.name);
TPMT_TK_AUTH ticket = DUMMY_TPMT_TK_AUTH;
r = Esys_PolicyTicket(esys_context,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&timeout, &cpHashA, &policyRef, &authName, &ticket);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyOR(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPML_DIGEST pHashList = { 0 };
r = Esys_PolicyOR(esys_context,
policySession_handle,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &pHashList);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyPCR(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_DIGEST pcrDigest = DUMMY_2B_DATA(.buffer);
TPML_PCR_SELECTION pcrs = { 0 };
r = Esys_PolicyPCR(esys_context,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, &pcrDigest, &pcrs);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyLocality(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPMA_LOCALITY locality = TPMA_LOCALITY_TPM2_LOC_ZERO;
r = Esys_PolicyLocality(esys_context,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
locality);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyNV(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_OPERAND operandB = DUMMY_2B_DATA(.buffer);
UINT16 offset = 0;
TPM2_EO operation = 0;
r = Esys_PolicyNV(esys_context,
authHandle_handle,
nvIndex_handle,
policySession_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &operandB, offset, operation);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyCounterTimer(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_OPERAND operandB = DUMMY_2B_DATA(.buffer);
UINT16 offset = 0;
TPM2_EO operation = 0;
r = Esys_PolicyCounterTimer(esys_context,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &operandB, offset, operation);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyCommandCode(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2_CC code = TPM2_CC_FIRST;
r = Esys_PolicyCommandCode(esys_context,
policySession_handle,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, code);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyPhysicalPresence(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
r = Esys_PolicyPhysicalPresence(esys_context,
policySession_handle,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyCpHash(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
r = Esys_PolicyCpHash(esys_context,
policySession,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, &cpHashA);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyNameHash(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_DIGEST nameHash = DUMMY_2B_DATA(.buffer);
r = Esys_PolicyNameHash(esys_context,
policySession,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &nameHash);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyDuplicationSelect(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_NAME objectName = DUMMY_2B_DATA(.name);
TPM2B_NAME newParentName = DUMMY_2B_DATA(.name);
TPMI_YES_NO includeObject = 0;
r = Esys_PolicyDuplicationSelect(esys_context,
policySession,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&objectName,
&newParentName, includeObject);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyAuthorize(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_DIGEST approvedPolicy = DUMMY_2B_DATA(.buffer);
TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
TPM2B_NAME keySign = DUMMY_2B_DATA(.name);
TPMT_TK_VERIFIED checkTicket = DUMMY_TPMT_TK_VERIFIED;
r = Esys_PolicyAuthorize(esys_context,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
&approvedPolicy,
&policyRef, &keySign, &checkTicket);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyAuthValue(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
r = Esys_PolicyAuthValue(esys_context,
policySession_handle,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyPassword(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
r = Esys_PolicyPassword(esys_context,
policySession_handle,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyGetDigest(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_DIGEST *policyDigest;
r = Esys_PolicyGetDigest(esys_context,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, &policyDigest);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyNvWritten(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
TPMI_YES_NO writtenSet = 0;
r = Esys_PolicyNvWritten(esys_context,
policySession_handle,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, writtenSet);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyTemplate(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
TPM2B_DIGEST templateHash = DUMMY_2B_DATA(.buffer);
r = Esys_PolicyTemplate(esys_context,
policySession,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &templateHash);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PolicyAuthorizeNV(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
r = Esys_PolicyAuthorizeNV(esys_context,
authHandle_handle,
nvIndex_handle,
policySession_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_CreatePrimary(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR primaryHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPM2B_SENSITIVE_CREATE inSensitive = { 0 };
TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
TPM2B_DATA outsideInfo = DUMMY_2B_DATA(.buffer);
TPML_PCR_SELECTION creationPCR = { 0 };
ESYS_TR objectHandle_handle;
TPM2B_PUBLIC *outPublic;
TPM2B_CREATION_DATA *creationData;
TPM2B_DIGEST *creationHash;
TPMT_TK_CREATION *creationTicket;
r = Esys_CreatePrimary(esys_context,
primaryHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
&inSensitive,
&inPublic,
&outsideInfo,
&creationPCR,
&objectHandle_handle,
&outPublic,
&creationData, &creationHash, &creationTicket);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_HierarchyControl(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPMI_RH_ENABLES enable = TPM2_RH_OWNER;
TPMI_YES_NO state2 = 0;
r = Esys_HierarchyControl(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, enable, state2);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_SetPrimaryPolicy(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPM2B_DIGEST authPolicy = DUMMY_2B_DATA(.buffer);
TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
r = Esys_SetPrimaryPolicy(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &authPolicy, hashAlg);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ChangePPS(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
r = Esys_ChangePPS(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ChangeEPS(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
r = Esys_ChangeEPS(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Clear(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
r = Esys_Clear(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ClearControl(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPMI_YES_NO disable = 0;
r = Esys_ClearControl(esys_context,
auth_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, disable);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_HierarchyChangeAuth(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPM2B_AUTH newAuth = DUMMY_2B_DATA(.buffer);
r = Esys_HierarchyChangeAuth(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &newAuth);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_DictionaryAttackLockReset(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR lockHandle_handle = DUMMY_TR_HANDLE_LOCKOUT;;
r = Esys_DictionaryAttackLockReset(esys_context,
lockHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_DictionaryAttackParameters(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR lockHandle_handle = DUMMY_TR_HANDLE_LOCKOUT;
UINT32 newMaxTries = 0;
UINT32 newRecoveryTime = 0;
UINT32 lockoutRecovery = 0;
r = Esys_DictionaryAttackParameters(esys_context,
lockHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
newMaxTries,
newRecoveryTime, lockoutRecovery);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_PP_Commands(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPML_CC setList = { 0 };
TPML_CC clearList = { 0 };
r = Esys_PP_Commands(esys_context,
auth_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &setList, &clearList);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_SetAlgorithmSet(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
UINT32 algorithmSet = 0;
r = Esys_SetAlgorithmSet(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, algorithmSet);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_FieldUpgradeStart(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authorization_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;;
ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
TPM2B_DIGEST fuDigest = DUMMY_2B_DATA(.buffer);
TPMT_SIGNATURE manifestSignature = DUMMY_TPMT_SIGNATURE;
r = Esys_FieldUpgradeStart(esys_context,
authorization_handle,
keyHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &fuDigest, &manifestSignature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_FieldUpgradeData(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_MAX_BUFFER fuData = DUMMY_2B_DATA(.buffer);
TPMT_HA *nextDigest;
TPMT_HA *firstDigest;
r = Esys_FieldUpgradeData(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &fuData, &nextDigest, &firstDigest);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_FirmwareRead(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
UINT32 sequenceNumber = 0;
TPM2B_MAX_BUFFER *fuData;
r = Esys_FirmwareRead(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, sequenceNumber, &fuData);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ContextSave(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR saveHandle_handle = DUMMY_TR_HANDLE_KEY;
TPMS_CONTEXT *context;
r = Esys_ContextSave(esys_context, saveHandle_handle, &context);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ContextLoad(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPMS_CONTEXT context = { 0 };
ESYS_TR loadedHandle_handle;
context.contextBlob.size = 0x100;
context.savedHandle = TPM2_TRANSIENT_FIRST;
context.hierarchy = TPM2_RH_OWNER;
r = Esys_ContextLoad(esys_context, &context, &loadedHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_FlushContext(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR flushHandle_handle = DUMMY_TR_HANDLE_KEY;
r = Esys_FlushContext(esys_context, flushHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_EvictControl(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
TPMI_DH_PERSISTENT persistentHandle = TPM2_PERSISTENT_FIRST;
ESYS_TR newObjectHandle_handle;
r = Esys_EvictControl(esys_context,
auth_handle,
objectHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE,
persistentHandle, &newObjectHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ReadClock(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPMS_TIME_INFO *currentTime;
r = Esys_ReadClock(esys_context,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &currentTime);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ClockSet(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
UINT64 newTime = 0;
r = Esys_ClockSet(esys_context,
auth_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, newTime);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_ClockRateAdjust(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPM2_CLOCK_ADJUST rateAdjust = 0;
r = Esys_ClockRateAdjust(esys_context,
auth_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, rateAdjust);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_GetCapability(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2_CAP capability = 0;
UINT32 property = 0;
UINT32 propertyCount = 0;
TPMS_CAPABILITY_DATA *capabilityData;
TPMI_YES_NO moreData;
r = Esys_GetCapability(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE,
capability,
property, propertyCount, &moreData, &capabilityData);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_TestParms(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPMT_PUBLIC_PARMS parameters = DUMMY_TPMT_PUBLIC_PARAMS;
r = Esys_TestParms(esys_context,
ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &parameters);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_DefineSpace(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
TPM2B_AUTH auth = DUMMY_2B_DATA(.buffer);
TPM2B_NV_PUBLIC publicInfo = {
.size = 0,
.nvPublic = {
.nvIndex = TPM2_NV_INDEX_FIRST,
.nameAlg = TPM2_ALG_SHA1,
.attributes = (TPMA_NV_PPWRITE |
TPMA_NV_AUTHWRITE |
1 << TPMA_NV_TPM2_NT_SHIFT |
TPMA_NV_WRITE_STCLEAR |
TPMA_NV_PPREAD |
TPMA_NV_AUTHREAD | TPMA_NV_PLATFORMCREATE),
.authPolicy = {
.size = 0,
.buffer = {},
},
.dataSize = 32,
}
};
ESYS_TR nvHandle_handle;
r = Esys_NV_DefineSpace(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
ESYS_TR_NONE, &auth, &publicInfo, &nvHandle_handle);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_UndefineSpace(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
r = Esys_NV_UndefineSpace(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_UndefineSpaceSpecial(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
ESYS_TR platform_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
r = Esys_NV_UndefineSpaceSpecial(esys_context,
nvIndex_handle,
platform_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_ReadPublic(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
TPM2B_NV_PUBLIC *nvPublic;
TPM2B_NAME *nvName;
r = Esys_NV_ReadPublic(esys_context,
nvIndex_handle,
ESYS_TR_NONE,
ESYS_TR_NONE, ESYS_TR_NONE, &nvPublic, &nvName);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_Write(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
TPM2B_MAX_NV_BUFFER data = DUMMY_2B_DATA(.buffer);
UINT16 offset = 0;
r = Esys_NV_Write(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &data, offset);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_Increment(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
r = Esys_NV_Increment(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_Extend(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
TPM2B_MAX_NV_BUFFER data = DUMMY_2B_DATA(.buffer);
r = Esys_NV_Extend(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, &data);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_SetBits(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
UINT64 bits = 0;
r = Esys_NV_SetBits(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, bits);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_WriteLock(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
r = Esys_NV_WriteLock(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_GlobalWriteLock(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
r = Esys_NV_GlobalWriteLock(esys_context,
authHandle_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_Read(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
UINT16 size = 0;
UINT16 offset = 0;
TPM2B_MAX_NV_BUFFER *data;
r = Esys_NV_Read(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, size, offset, &data);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_ReadLock(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
r = Esys_NV_ReadLock(esys_context,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_ChangeAuth(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
TPM2B_AUTH newAuth = DUMMY_2B_DATA(.buffer);
r = Esys_NV_ChangeAuth(esys_context,
nvIndex_handle,
ESYS_TR_PASSWORD,
ESYS_TR_NONE, ESYS_TR_NONE, &newAuth);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_NV_Certify(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
UINT16 size = 0;
UINT16 offset = 0;
TPM2B_ATTEST *certifyInfo;
TPMT_SIGNATURE *signature;
r = Esys_NV_Certify(esys_context,
signHandle_handle,
authHandle_handle,
nvIndex_handle,
ESYS_TR_PASSWORD,
ESYS_TR_PASSWORD,
ESYS_TR_NONE,
&qualifyingData,
&inScheme, size, offset, &certifyInfo, &signature);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
static void
test_Vendor_TCG_Test(void **state)
{
TSS2_RC r;
TSS2_TCTI_CONTEXT *tcti;
ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
Esys_GetTcti(esys_context, &tcti);
TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
TPM2B_DATA inputData = DUMMY_2B_DATA(.buffer);
TPM2B_DATA *outputData;
r = Esys_Vendor_TCG_Test(esys_context,
ESYS_TR_NONE,
ESYS_TR_NONE,
ESYS_TR_NONE, &inputData, &outputData);
assert_int_equal(r, TPM2_RC_YIELDED);
assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
}
int
main(int argc, char *argv[])
{
const struct CMUnitTest tests[] = {
cmocka_unit_test_setup_teardown(test_Startup, setup, teardown),
cmocka_unit_test_setup_teardown(test_Shutdown, setup, teardown),
cmocka_unit_test_setup_teardown(test_SelfTest, setup, teardown),
cmocka_unit_test_setup_teardown(test_IncrementalSelfTest, setup,
teardown),
cmocka_unit_test_setup_teardown(test_GetTestResult, setup, teardown),
cmocka_unit_test_setup_teardown(test_StartAuthSession, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyRestart, setup, teardown),
cmocka_unit_test_setup_teardown(test_Create, setup, teardown),
cmocka_unit_test_setup_teardown(test_Load, setup, teardown),
cmocka_unit_test_setup_teardown(test_LoadExternal, setup, teardown),
cmocka_unit_test_setup_teardown(test_ReadPublic, setup, teardown),
cmocka_unit_test_setup_teardown(test_ActivateCredential, setup,
teardown),
cmocka_unit_test_setup_teardown(test_MakeCredential, setup, teardown),
cmocka_unit_test_setup_teardown(test_Unseal, setup, teardown),
cmocka_unit_test_setup_teardown(test_ObjectChangeAuth, setup, teardown),
cmocka_unit_test_setup_teardown(test_Duplicate, setup, teardown),
cmocka_unit_test_setup_teardown(test_Rewrap, setup, teardown),
cmocka_unit_test_setup_teardown(test_Import, setup, teardown),
cmocka_unit_test_setup_teardown(test_RSA_Encrypt, setup, teardown),
cmocka_unit_test_setup_teardown(test_RSA_Decrypt, setup, teardown),
cmocka_unit_test_setup_teardown(test_ECDH_KeyGen, setup, teardown),
cmocka_unit_test_setup_teardown(test_ECDH_ZGen, setup, teardown),
cmocka_unit_test_setup_teardown(test_ECC_Parameters, setup, teardown),
cmocka_unit_test_setup_teardown(test_ZGen_2Phase, setup, teardown),
cmocka_unit_test_setup_teardown(test_EncryptDecrypt, setup, teardown),
cmocka_unit_test_setup_teardown(test_EncryptDecrypt2, setup, teardown),
cmocka_unit_test_setup_teardown(test_Hash, setup, teardown),
cmocka_unit_test_setup_teardown(test_HMAC, setup, teardown),
cmocka_unit_test_setup_teardown(test_GetRandom, setup, teardown),
cmocka_unit_test_setup_teardown(test_StirRandom, setup, teardown),
cmocka_unit_test_setup_teardown(test_HMAC_Start, setup, teardown),
cmocka_unit_test_setup_teardown(test_HashSequenceStart, setup,
teardown),
cmocka_unit_test_setup_teardown(test_SequenceUpdate, setup, teardown),
cmocka_unit_test_setup_teardown(test_SequenceComplete, setup, teardown),
cmocka_unit_test_setup_teardown(test_EventSequenceComplete, setup,
teardown),
cmocka_unit_test_setup_teardown(test_Certify, setup, teardown),
cmocka_unit_test_setup_teardown(test_CertifyCreation, setup, teardown),
cmocka_unit_test_setup_teardown(test_Quote, setup, teardown),
cmocka_unit_test_setup_teardown(test_GetSessionAuditDigest, setup,
teardown),
cmocka_unit_test_setup_teardown(test_GetCommandAuditDigest, setup,
teardown),
cmocka_unit_test_setup_teardown(test_GetTime, setup, teardown),
cmocka_unit_test_setup_teardown(test_Commit, setup, teardown),
cmocka_unit_test_setup_teardown(test_EC_Ephemeral, setup, teardown),
cmocka_unit_test_setup_teardown(test_VerifySignature, setup, teardown),
cmocka_unit_test_setup_teardown(test_Sign, setup, teardown),
cmocka_unit_test_setup_teardown(test_SetCommandCodeAuditStatus, setup,
teardown),
cmocka_unit_test_setup_teardown(test_PCR_Extend, setup, teardown),
cmocka_unit_test_setup_teardown(test_PCR_Event, setup, teardown),
cmocka_unit_test_setup_teardown(test_PCR_Read, setup, teardown),
cmocka_unit_test_setup_teardown(test_PCR_Allocate, setup, teardown),
cmocka_unit_test_setup_teardown(test_PCR_SetAuthPolicy, setup,
teardown),
cmocka_unit_test_setup_teardown(test_PCR_SetAuthValue, setup, teardown),
cmocka_unit_test_setup_teardown(test_PCR_Reset, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicySigned, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicySecret, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyTicket, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyOR, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyPCR, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyLocality, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyNV, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyCounterTimer, setup,
teardown),
cmocka_unit_test_setup_teardown(test_PolicyCommandCode, setup,
teardown),
cmocka_unit_test_setup_teardown(test_PolicyPhysicalPresence, setup,
teardown),
cmocka_unit_test_setup_teardown(test_PolicyCpHash, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyNameHash, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyDuplicationSelect, setup,
teardown),
cmocka_unit_test_setup_teardown(test_PolicyAuthorize, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyAuthValue, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyPassword, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyGetDigest, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyNvWritten, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyTemplate, setup, teardown),
cmocka_unit_test_setup_teardown(test_PolicyAuthorizeNV, setup,
teardown),
cmocka_unit_test_setup_teardown(test_CreatePrimary, setup, teardown),
cmocka_unit_test_setup_teardown(test_HierarchyControl, setup, teardown),
cmocka_unit_test_setup_teardown(test_SetPrimaryPolicy, setup, teardown),
cmocka_unit_test_setup_teardown(test_ChangePPS, setup, teardown),
cmocka_unit_test_setup_teardown(test_ChangeEPS, setup, teardown),
cmocka_unit_test_setup_teardown(test_Clear, setup, teardown),
cmocka_unit_test_setup_teardown(test_ClearControl, setup, teardown),
cmocka_unit_test_setup_teardown(test_HierarchyChangeAuth, setup,
teardown),
cmocka_unit_test_setup_teardown(test_DictionaryAttackLockReset, setup,
teardown),
cmocka_unit_test_setup_teardown(test_DictionaryAttackParameters, setup,
teardown),
cmocka_unit_test_setup_teardown(test_PP_Commands, setup, teardown),
cmocka_unit_test_setup_teardown(test_SetAlgorithmSet, setup, teardown),
cmocka_unit_test_setup_teardown(test_FieldUpgradeStart, setup,
teardown),
cmocka_unit_test_setup_teardown(test_FieldUpgradeData, setup, teardown),
cmocka_unit_test_setup_teardown(test_FirmwareRead, setup, teardown),
cmocka_unit_test_setup_teardown(test_ContextSave, setup, teardown),
cmocka_unit_test_setup_teardown(test_ContextLoad, setup, teardown),
cmocka_unit_test_setup_teardown(test_FlushContext, setup, teardown),
cmocka_unit_test_setup_teardown(test_EvictControl, setup, teardown),
cmocka_unit_test_setup_teardown(test_ReadClock, setup, teardown),
cmocka_unit_test_setup_teardown(test_ClockSet, setup, teardown),
cmocka_unit_test_setup_teardown(test_ClockRateAdjust, setup, teardown),
cmocka_unit_test_setup_teardown(test_GetCapability, setup, teardown),
cmocka_unit_test_setup_teardown(test_TestParms, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_DefineSpace, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_UndefineSpace, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_UndefineSpaceSpecial, setup,
teardown),
cmocka_unit_test_setup_teardown(test_NV_ReadPublic, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_Write, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_Increment, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_Extend, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_SetBits, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_WriteLock, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_GlobalWriteLock, setup,
teardown),
cmocka_unit_test_setup_teardown(test_NV_Read, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_ReadLock, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_ChangeAuth, setup, teardown),
cmocka_unit_test_setup_teardown(test_NV_Certify, setup, teardown),
cmocka_unit_test_setup_teardown(test_Vendor_TCG_Test, setup, teardown),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
Reference in new issue View Git Blame Copy Permalink