1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*******************************************************************************
3 * Copyright 2017-2018, Fraunhofer SIT sponsored by Infineon Technologies AG All
4 * rights reserved.
5 ******************************************************************************/
6
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #include <stdarg.h>
12 #include <inttypes.h>
13 #include <string.h>
14 #include <stdlib.h>
15
16 #include <setjmp.h>
17 #include <cmocka.h>
18
19 #include "tss2_esys.h"
20
21 #include "tss2-esys/esys_iutil.h"
22 #define LOGMODULE tests
23 #include "util/log.h"
24 #include "util/aux_util.h"
25
26 /**
27 * This unit test looks into a set of Esys_<cmd>() functions and tests the
28 * resubmission behaviour. The ESAPI is expected to resubmit a command for a
29 * certain number of times if the TPM return RC_YIELDED. After this number of
30 * times, the ESAPI shall not try it any further but return the TPM's error.
31 * For all these resubmissions the command must be the same as before.
32 * This shall be extended to cover all functions at some point.
33 */
34
35 #define TCTI_YIELDER_MAGIC 0x5949454c44455200ULL /* 'YIELDER\0' */
36 #define TCTI_YIELDER_VERSION 0x1
37
38 /*
39 * Esys handles for dummy session and key objects, and initialization values for
40 * other objects, which can be used in ESAPI test calls
41 */
42 #define DUMMY_TR_HANDLE_POLICY_SESSION ESYS_TR_MIN_OBJECT
43 #define DUMMY_TR_HANDLE_KEY ESYS_TR_MIN_OBJECT+1
44 #define DUMMY_TR_HANDLE_NV_INDEX ESYS_TR_MIN_OBJECT+2
45 #define DUMMY_TR_HANDLE_HIERARCHY_OWNER ESYS_TR_MIN_OBJECT+3
46 #define DUMMY_TR_HANDLE_HIERARCHY_PLATFORM ESYS_TR_MIN_OBJECT+4
47 #define DUMMY_TR_HANDLE_PRIVACY_ADMIN ESYS_TR_MIN_OBJECT+5
48 #define DUMMY_TR_HANDLE_HMAC_SESSION ESYS_TR_MIN_OBJECT+6
49 #define DUMMY_TR_HANDLE_LOCKOUT ESYS_TR_MIN_OBJECT+7
50 #define DUMMY_IN_PUBLIC_DATA { \
51 .size = 0, \
52 .publicArea = { \
53 .type = TPM2_ALG_ECC, \
54 .nameAlg = TPM2_ALG_SHA256, \
55 .objectAttributes = (TPMA_OBJECT_USERWITHAUTH | \
56 TPMA_OBJECT_RESTRICTED | \
57 TPMA_OBJECT_SIGN_ENCRYPT | \
58 TPMA_OBJECT_FIXEDTPM | \
59 TPMA_OBJECT_FIXEDPARENT | \
60 TPMA_OBJECT_SENSITIVEDATAORIGIN), \
61 .authPolicy = { \
62 .size = 0, \
63 }, \
64 .parameters.eccDetail = { \
65 .symmetric = { \
66 .algorithm = \
67 TPM2_ALG_NULL, \
68 .keyBits.aes = \
69 128, \
70 .mode.aes = \
71 TPM2_ALG_ECB, \
72 }, \
73 .scheme = { \
74 .scheme = \
75 TPM2_ALG_ECDSA, \
76 .details = { \
77 .ecdsa = \
78 {. \
79 hashAlg \
80 = \
81 TPM2_ALG_SHA256}}, \
82 }, \
83 .curveID = TPM2_ECC_NIST_P256, \
84 .kdf = { \
85 .scheme = TPM2_ALG_NULL, \
86 .details = {}} \
87 }, \
88 .unique.ecc = { \
89 .x = {.size = 0,.buffer = {}}, \
90 .y = {.size = 0,.buffer = {}}, \
91 }, \
92 }, \
93 }
94
95 #define DUMMY_TPMT_PUBLIC_PARAMS { \
96 .type = TPM2_ALG_ECC, \
97 .parameters.eccDetail = { \
98 .symmetric = { \
99 .algorithm = \
100 TPM2_ALG_NULL, \
101 .keyBits.aes = \
102 128, \
103 .mode.aes = \
104 TPM2_ALG_ECB, \
105 }, \
106 .scheme = { \
107 .scheme = \
108 TPM2_ALG_ECDSA, \
109 .details = { \
110 .ecdsa = \
111 {. \
112 hashAlg \
113 = \
114 TPM2_ALG_SHA256}}, \
115 }, \
116 .curveID = TPM2_ECC_NIST_P256, \
117 .kdf = { \
118 .scheme = TPM2_ALG_NULL, \
119 .details = {}} \
120 } \
121 }
122
123 #define DUMMY_2B_DATA(NAME) { \
124 .size = 20, \
125 NAME = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, \
126 11, 12, 13, 14, 15, 16, 17, 18, 19, 20} \
127 }
128
129 #define DUMMY_2B_DATA16(NAME) { \
130 .size = 16, \
131 NAME = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, \
132 11, 12, 13, 14, 15, 16 } \
133 }
134
135 #define DUMMY_2B_DATA0 { \
136 .size = 0, \
137 .buffer = {}, \
138 }
139
140 #define DUMMY_SYMMETRIC {.algorithm = TPM2_ALG_AES, \
141 .keyBits = {.aes = 128}, \
142 .mode = {.aes = TPM2_ALG_CFB} \
143 }
144
145 #define DUMMY_TPMT_TK_AUTH { .tag = TPM2_ST_AUTH_SIGNED , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
146
147 #define DUMMY_TPMT_TK_CREATION { .tag = TPM2_ST_CREATION , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
148
149 #define DUMMY_TPMT_TK_VERIFIED { .tag = TPM2_ST_VERIFIED , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
150
151 #define DUMMY_TPMT_TK_HASHCHECK { .tag = TPM2_ST_HASHCHECK , .hierarchy = TPM2_RH_OWNER, .digest = {0} }
152
153 #define DUMMY_RSA_DECRYPT { .scheme = TPM2_ALG_NULL }
154
155 #define DUMMY_TPMT_SIGNATURE { \
156 .sigAlg = TPM2_ALG_RSAPSS, \
157 .signature = { \
158 .rsapss = { \
159 .hash = TPM2_ALG_SHA1, .sig= {0} \
160 } \
161 } \
162 };
163
164 typedef struct {
165 uint64_t magic;
166 uint32_t version;
167 TSS2_TCTI_TRANSMIT_FCN transmit;
168 TSS2_TCTI_RECEIVE_FCN receive;
169 TSS2_RC(*finalize) (TSS2_TCTI_CONTEXT * tctiContext);
170 TSS2_RC(*cancel) (TSS2_TCTI_CONTEXT * tctiContext);
171 TSS2_RC(*getPollHandles) (TSS2_TCTI_CONTEXT * tctiContext,
172 TSS2_TCTI_POLL_HANDLE * handles,
173 size_t * num_handles);
174 TSS2_RC(*setLocality) (TSS2_TCTI_CONTEXT * tctiContext, uint8_t locality);
175 uint32_t count;
176 uint8_t cmd[4096];
177 } TSS2_TCTI_CONTEXT_YIELDER;
178
179 static TSS2_TCTI_CONTEXT_YIELDER *
tcti_yielder_cast(TSS2_TCTI_CONTEXT * ctx)180 tcti_yielder_cast(TSS2_TCTI_CONTEXT * ctx)
181 {
182 TSS2_TCTI_CONTEXT_YIELDER *ctxi = (TSS2_TCTI_CONTEXT_YIELDER *) ctx;
183 if (ctxi == NULL || ctxi->magic != TCTI_YIELDER_MAGIC) {
184 LOG_ERROR("Bad tcti passed.");
185 return NULL;
186 }
187 return ctxi;
188 }
189
190 static TSS2_RC
tcti_yielder_transmit(TSS2_TCTI_CONTEXT * tctiContext,size_t size,const uint8_t * buffer)191 tcti_yielder_transmit(TSS2_TCTI_CONTEXT * tctiContext,
192 size_t size, const uint8_t * buffer)
193 {
194 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tctiContext);
195
196 if (size > sizeof(tcti_yielder->cmd)) {
197 LOG_ERROR("Bad size value.");
198 return TSS2_TCTI_RC_INSUFFICIENT_BUFFER;
199 }
200
201 if (tcti_yielder->count != 0)
202 assert_memory_equal(&tcti_yielder->cmd[0], buffer, size);
203
204 tcti_yielder->count++;
205 memcpy(&tcti_yielder->cmd[0], buffer, size);
206
207 return TSS2_RC_SUCCESS;
208 }
209
210 const uint8_t yielded_response[] = {
211 0x80, 0x01, /* TPM_ST_NO_SESSION */
212 0x00, 0x00, 0x00, 0x0A, /* Response Size 10 */
213 0x00, 0x00, 0x09, 0x08 /* TPM_RC_YIELDED */
214 };
215
216 static TSS2_RC
tcti_yielder_receive(TSS2_TCTI_CONTEXT * tctiContext,size_t * response_size,uint8_t * response_buffer,int32_t timeout)217 tcti_yielder_receive(TSS2_TCTI_CONTEXT * tctiContext,
218 size_t * response_size,
219 uint8_t * response_buffer, int32_t timeout)
220 {
221 *response_size = sizeof(yielded_response);
222 if (response_buffer != NULL)
223 memcpy(response_buffer, &yielded_response[0], sizeof(yielded_response));
224
225 return TSS2_RC_SUCCESS;
226 }
227
228 static void
tcti_yielder_finalize(TSS2_TCTI_CONTEXT * tctiContext)229 tcti_yielder_finalize(TSS2_TCTI_CONTEXT * tctiContext)
230 {
231 memset(tctiContext, 0, sizeof(TSS2_TCTI_CONTEXT_YIELDER));
232 }
233
234 static TSS2_RC
tcti_yielder_initialize(TSS2_TCTI_CONTEXT * tctiContext,size_t * contextSize)235 tcti_yielder_initialize(TSS2_TCTI_CONTEXT * tctiContext, size_t * contextSize)
236 {
237 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder =
238 (TSS2_TCTI_CONTEXT_YIELDER *) tctiContext;
239
240 if (tctiContext == NULL && contextSize == NULL) {
241 return TSS2_TCTI_RC_BAD_VALUE;
242 } else if (tctiContext == NULL) {
243 *contextSize = sizeof(*tcti_yielder);
244 return TSS2_RC_SUCCESS;
245 }
246
247 /* Init TCTI context */
248 memset(tcti_yielder, 0, sizeof(*tcti_yielder));
249 TSS2_TCTI_MAGIC(tctiContext) = TCTI_YIELDER_MAGIC;
250 TSS2_TCTI_VERSION(tctiContext) = TCTI_YIELDER_VERSION;
251 TSS2_TCTI_TRANSMIT(tctiContext) = tcti_yielder_transmit;
252 TSS2_TCTI_RECEIVE(tctiContext) = tcti_yielder_receive;
253 TSS2_TCTI_FINALIZE(tctiContext) = tcti_yielder_finalize;
254 TSS2_TCTI_CANCEL(tctiContext) = NULL;
255 TSS2_TCTI_GET_POLL_HANDLES(tctiContext) = NULL;
256 TSS2_TCTI_SET_LOCALITY(tctiContext) = NULL;
257 tcti_yielder->count = 0;
258
259 return TSS2_RC_SUCCESS;
260 }
261
262 static int
setup(void ** state)263 setup(void **state)
264 {
265 TSS2_RC r;
266 ESYS_CONTEXT *ectx;
267 size_t size = sizeof(TSS2_TCTI_CONTEXT_YIELDER);
268 TSS2_TCTI_CONTEXT *tcti = malloc(size);
269 ESYS_TR objectHandle;
270 RSRC_NODE_T *objectHandleNode = NULL;
271
272 r = tcti_yielder_initialize(tcti, &size);
273 if (r)
274 return (int)r;
275 r = Esys_Initialize(&ectx, tcti, NULL);
276 if (r)
277 return (int)r;
278
279 /* Create dummy object to enable usage of SAPI prepare functions in the tests */
280 objectHandle = DUMMY_TR_HANDLE_POLICY_SESSION;
281 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
282 if (r)
283 return (int)r;
284 objectHandleNode->rsrc.rsrcType = IESYSC_SESSION_RSRC;
285 objectHandleNode->rsrc.handle = TPM2_POLICY_SESSION_FIRST;
286
287 objectHandle = DUMMY_TR_HANDLE_HMAC_SESSION;
288 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
289 if (r)
290 return (int)r;
291 objectHandleNode->rsrc.rsrcType = IESYSC_SESSION_RSRC;
292 objectHandleNode->rsrc.handle = TPM2_HMAC_SESSION_FIRST;
293
294 objectHandle = DUMMY_TR_HANDLE_KEY;
295 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
296 if (r)
297 return (int)r;
298 objectHandleNode->rsrc.rsrcType = IESYSC_KEY_RSRC;
299 objectHandleNode->rsrc.handle = TPM2_TRANSIENT_FIRST;
300
301 objectHandle = DUMMY_TR_HANDLE_HIERARCHY_OWNER;
302 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
303 if (r)
304 return (int)r;
305 objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
306 objectHandleNode->rsrc.handle = TPM2_RH_OWNER;
307
308 objectHandle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
309 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
310 if (r)
311 return (int)r;
312 objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
313 objectHandleNode->rsrc.handle = TPM2_RH_PLATFORM;
314
315 objectHandle = DUMMY_TR_HANDLE_LOCKOUT;
316 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
317 if (r)
318 return (int)r;
319 objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
320 objectHandleNode->rsrc.handle = TPM2_RH_LOCKOUT;
321
322 objectHandle = DUMMY_TR_HANDLE_NV_INDEX;
323 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
324 if (r)
325 return (int)r;
326 objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
327 objectHandleNode->rsrc.handle = TPM2_NV_INDEX_FIRST;
328
329 objectHandle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
330 r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
331 if (r)
332 return (int)r;
333 objectHandleNode->rsrc.rsrcType = IESYSC_WITHOUT_MISC_RSRC;
334 objectHandleNode->rsrc.handle = TPM2_RH_ENDORSEMENT;
335 *state = (void *)ectx;
336 return 0;
337 }
338
339 static int
teardown(void ** state)340 teardown(void **state)
341 {
342 TSS2_TCTI_CONTEXT *tcti;
343 ESYS_CONTEXT *ectx = (ESYS_CONTEXT *) * state;
344 Esys_GetTcti(ectx, &tcti);
345 Esys_Finalize(&ectx);
346 free(tcti);
347 return 0;
348 }
349
350 static void
test_Startup(void ** state)351 test_Startup(void **state)
352 {
353 TSS2_RC r;
354 TSS2_TCTI_CONTEXT *tcti;
355 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
356 Esys_GetTcti(esys_context, &tcti);
357 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
358
359 TPM2_SU startupType = TPM2_SU_CLEAR;
360 r = Esys_Startup(esys_context, startupType);
361
362 assert_int_equal(r, TPM2_RC_YIELDED);
363 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
364 }
365
366 static void
test_Shutdown(void ** state)367 test_Shutdown(void **state)
368 {
369 TSS2_RC r;
370 TSS2_TCTI_CONTEXT *tcti;
371 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
372 Esys_GetTcti(esys_context, &tcti);
373 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
374
375 TPM2_SU shutdownType = TPM2_SU_CLEAR;
376 r = Esys_Shutdown(esys_context,
377 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, shutdownType);
378
379 assert_int_equal(r, TPM2_RC_YIELDED);
380 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
381 }
382
383 static void
test_SelfTest(void ** state)384 test_SelfTest(void **state)
385 {
386 TSS2_RC r;
387 TSS2_TCTI_CONTEXT *tcti;
388 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
389 Esys_GetTcti(esys_context, &tcti);
390 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
391
392 r = Esys_SelfTest(esys_context,
393 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, 0);
394 assert_int_equal(r, TPM2_RC_YIELDED);
395 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
396 }
397
398 static void
test_IncrementalSelfTest(void ** state)399 test_IncrementalSelfTest(void **state)
400 {
401 TSS2_RC r;
402 TSS2_TCTI_CONTEXT *tcti;
403 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
404 Esys_GetTcti(esys_context, &tcti);
405 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
406
407 TPML_ALG toTest = {0};
408 TPML_ALG *toDoList = {0} ;
409 r = Esys_IncrementalSelfTest(esys_context,
410 ESYS_TR_NONE,
411 ESYS_TR_NONE,
412 ESYS_TR_NONE, &toTest, &toDoList);
413
414 assert_int_equal(r, TPM2_RC_YIELDED);
415 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
416 }
417
418 static void
test_GetTestResult(void ** state)419 test_GetTestResult(void **state)
420 {
421 TSS2_RC r;
422 TSS2_TCTI_CONTEXT *tcti;
423 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
424 Esys_GetTcti(esys_context, &tcti);
425 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
426
427 TPM2B_MAX_BUFFER *outData;
428 TPM2_RC testResult;
429 r = Esys_GetTestResult(esys_context,
430 ESYS_TR_NONE,
431 ESYS_TR_NONE, ESYS_TR_NONE, &outData, &testResult);
432
433 assert_int_equal(r, TPM2_RC_YIELDED);
434 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
435 }
436
437 static void
test_StartAuthSession(void ** state)438 test_StartAuthSession(void **state)
439 {
440 TSS2_RC r;
441 TSS2_TCTI_CONTEXT *tcti;
442 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
443 Esys_GetTcti(esys_context, &tcti);
444 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
445
446 ESYS_TR tpmKey_handle = ESYS_TR_NONE;
447 ESYS_TR bind_handle = ESYS_TR_NONE;
448 TPM2B_NONCE nonceCaller = DUMMY_2B_DATA(.buffer);
449 TPM2_SE sessionType = TPM2_SE_HMAC;
450 TPMT_SYM_DEF symmetric = {.algorithm = TPM2_ALG_AES,
451 .keyBits = {.aes = 128},
452 .mode = {.aes = TPM2_ALG_CFB}
453 };
454 TPMI_ALG_HASH authHash = TPM2_ALG_SHA1;
455 ESYS_TR sessionHandle_handle;
456
457 r = Esys_StartAuthSession(esys_context,
458 tpmKey_handle,
459 bind_handle,
460 ESYS_TR_NONE,
461 ESYS_TR_NONE,
462 ESYS_TR_NONE,
463 &nonceCaller,
464 sessionType,
465 &symmetric,
466 authHash, &sessionHandle_handle);
467
468 assert_int_equal(r, TPM2_RC_YIELDED);
469 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
470 }
471
472 static void
test_PolicyRestart(void ** state)473 test_PolicyRestart(void **state)
474 {
475 TSS2_RC r;
476 TSS2_TCTI_CONTEXT *tcti;
477 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
478 Esys_GetTcti(esys_context, &tcti);
479 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
480
481 r = Esys_PolicyRestart(esys_context,
482 DUMMY_TR_HANDLE_POLICY_SESSION,
483 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
484
485 assert_int_equal(r, TPM2_RC_YIELDED);
486 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
487 }
488
489 static void
test_Create(void ** state)490 test_Create(void **state)
491 {
492 TSS2_RC r;
493 TSS2_TCTI_CONTEXT *tcti;
494 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
495 Esys_GetTcti(esys_context, &tcti);
496 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
497 TPM2B_SENSITIVE_CREATE inSensitive = { 0 };
498 TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
499 TPM2B_DATA outsideInfo = DUMMY_2B_DATA0;
500 TPML_PCR_SELECTION creationPCR = {
501 .count = 0,
502 };
503 TPM2B_PRIVATE *outPrivate;
504 TPM2B_PUBLIC *outPublic;
505 TPM2B_CREATION_DATA *creationData;
506 TPM2B_DIGEST *creationHash;
507 TPMT_TK_CREATION *creationTicket;
508
509 r = Esys_Create(esys_context,
510 DUMMY_TR_HANDLE_KEY,
511 ESYS_TR_PASSWORD,
512 ESYS_TR_NONE,
513 ESYS_TR_NONE,
514 &inSensitive,
515 &inPublic,
516 &outsideInfo,
517 &creationPCR,
518 &outPrivate,
519 &outPublic, &creationData, &creationHash, &creationTicket);
520
521 assert_int_equal(r, TPM2_RC_YIELDED);
522 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
523 }
524
525 static void
test_Load(void ** state)526 test_Load(void **state)
527 {
528 TSS2_RC r;
529 TSS2_TCTI_CONTEXT *tcti;
530 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
531 Esys_GetTcti(esys_context, &tcti);
532 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
533
534 TPM2B_PRIVATE inPrivate = DUMMY_2B_DATA(.buffer);
535 TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
536 ESYS_TR objectHandle_handle;
537 r = Esys_Load(esys_context,
538 DUMMY_TR_HANDLE_KEY,
539 ESYS_TR_PASSWORD,
540 ESYS_TR_NONE,
541 ESYS_TR_NONE, &inPrivate, &inPublic, &objectHandle_handle);
542
543 assert_int_equal(r, TPM2_RC_YIELDED);
544 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
545 }
546
547 static void
test_LoadExternal(void ** state)548 test_LoadExternal(void **state)
549 {
550 TSS2_RC r;
551 TSS2_TCTI_CONTEXT *tcti;
552 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
553 Esys_GetTcti(esys_context, &tcti);
554 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
555
556 TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
557 ESYS_TR objectHandle_handle;
558 r = Esys_LoadExternal(esys_context,
559 ESYS_TR_NONE,
560 ESYS_TR_NONE,
561 ESYS_TR_NONE,
562 NULL, &inPublic, TPM2_RH_OWNER, &objectHandle_handle);
563
564 assert_int_equal(r, TPM2_RC_YIELDED);
565 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
566 }
567
568 static void
test_ReadPublic(void ** state)569 test_ReadPublic(void **state)
570 {
571 TSS2_RC r;
572 TSS2_TCTI_CONTEXT *tcti;
573 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
574 Esys_GetTcti(esys_context, &tcti);
575 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
576
577 ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
578 TPM2B_PUBLIC *outPublic;
579 TPM2B_NAME *name;
580 TPM2B_NAME *qualifiedName;
581 r = Esys_ReadPublic(esys_context,
582 objectHandle_handle,
583 ESYS_TR_NONE,
584 ESYS_TR_NONE,
585 ESYS_TR_NONE, &outPublic, &name, &qualifiedName);
586
587 assert_int_equal(r, TPM2_RC_YIELDED);
588 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
589 }
590
591 static void
test_ActivateCredential(void ** state)592 test_ActivateCredential(void **state)
593 {
594 TSS2_RC r;
595 TSS2_TCTI_CONTEXT *tcti;
596 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
597 Esys_GetTcti(esys_context, &tcti);
598 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
599
600 ESYS_TR activateHandle_handle = DUMMY_TR_HANDLE_KEY;
601 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
602 TPM2B_ID_OBJECT credentialBlob = DUMMY_2B_DATA(.credential);
603 TPM2B_ENCRYPTED_SECRET secret = DUMMY_2B_DATA(.secret);;
604 TPM2B_DIGEST *certInfo;
605 r = Esys_ActivateCredential(esys_context,
606 activateHandle_handle,
607 keyHandle_handle,
608 ESYS_TR_PASSWORD,
609 ESYS_TR_PASSWORD,
610 ESYS_TR_NONE,
611 &credentialBlob, &secret, &certInfo);
612
613 assert_int_equal(r, TPM2_RC_YIELDED);
614 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
615 }
616
617 static void
test_MakeCredential(void ** state)618 test_MakeCredential(void **state)
619 {
620 TSS2_RC r;
621 TSS2_TCTI_CONTEXT *tcti;
622 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
623 Esys_GetTcti(esys_context, &tcti);
624 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
625
626 ESYS_TR handle_handle = ESYS_TR_NONE;
627 TPM2B_DIGEST credential = DUMMY_2B_DATA(.buffer);
628 TPM2B_NAME objectName = DUMMY_2B_DATA(.name);;
629 TPM2B_ID_OBJECT *credentialBlob;
630 TPM2B_ENCRYPTED_SECRET *secret;
631 r = Esys_MakeCredential(esys_context,
632 handle_handle,
633 ESYS_TR_NONE,
634 ESYS_TR_NONE,
635 ESYS_TR_NONE,
636 &credential, &objectName, &credentialBlob, &secret);
637
638 assert_int_equal(r, TPM2_RC_YIELDED);
639 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
640 }
641
642 static void
test_Unseal(void ** state)643 test_Unseal(void **state)
644 {
645 TSS2_RC r;
646 TSS2_TCTI_CONTEXT *tcti;
647 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
648 Esys_GetTcti(esys_context, &tcti);
649 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
650
651 ESYS_TR itemHandle_handle = DUMMY_TR_HANDLE_KEY;
652 TPM2B_SENSITIVE_DATA *outData;
653 r = Esys_Unseal(esys_context,
654 itemHandle_handle,
655 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, &outData);
656
657 assert_int_equal(r, TPM2_RC_YIELDED);
658 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
659 }
660
661 static void
test_ObjectChangeAuth(void ** state)662 test_ObjectChangeAuth(void **state)
663 {
664 TSS2_RC r;
665 TSS2_TCTI_CONTEXT *tcti;
666 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
667 Esys_GetTcti(esys_context, &tcti);
668 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
669
670 ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
671 ESYS_TR parentHandle_handle = DUMMY_TR_HANDLE_KEY;
672 TPM2B_AUTH newAuth = DUMMY_2B_DATA(.buffer);
673 TPM2B_PRIVATE *outPrivate;
674 r = Esys_ObjectChangeAuth(esys_context,
675 objectHandle_handle,
676 parentHandle_handle,
677 ESYS_TR_PASSWORD,
678 ESYS_TR_NONE,
679 ESYS_TR_NONE, &newAuth, &outPrivate);
680
681 assert_int_equal(r, TPM2_RC_YIELDED);
682 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
683 }
684
685 static void
test_Duplicate(void ** state)686 test_Duplicate(void **state)
687 {
688 TSS2_RC r;
689 TSS2_TCTI_CONTEXT *tcti;
690 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
691 Esys_GetTcti(esys_context, &tcti);
692 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
693
694 ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
695 ESYS_TR newParentHandle_handle = DUMMY_TR_HANDLE_KEY;
696 TPM2B_DATA encryptionKeyIn = DUMMY_2B_DATA(.buffer);
697 TPMT_SYM_DEF_OBJECT symmetricAlg = DUMMY_SYMMETRIC;
698 TPM2B_DATA *encryptionKeyOut;
699 TPM2B_PRIVATE *duplicate;
700 TPM2B_ENCRYPTED_SECRET *outSymSeed;
701 r = Esys_Duplicate(esys_context,
702 objectHandle_handle,
703 newParentHandle_handle,
704 ESYS_TR_PASSWORD,
705 ESYS_TR_NONE,
706 ESYS_TR_NONE,
707 &encryptionKeyIn,
708 &symmetricAlg,
709 &encryptionKeyOut, &duplicate, &outSymSeed);
710
711 assert_int_equal(r, TPM2_RC_YIELDED);
712 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
713 }
714
715 static void
test_Rewrap(void ** state)716 test_Rewrap(void **state)
717 {
718 TSS2_RC r;
719 TSS2_TCTI_CONTEXT *tcti;
720 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
721 Esys_GetTcti(esys_context, &tcti);
722 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
723
724 ESYS_TR oldParent_handle = DUMMY_TR_HANDLE_KEY;
725 ESYS_TR newParent_handle = DUMMY_TR_HANDLE_KEY;
726 TPM2B_PRIVATE inDuplicate = DUMMY_2B_DATA(.buffer);
727 TPM2B_NAME name = DUMMY_2B_DATA(.name);
728 TPM2B_ENCRYPTED_SECRET inSymSeed = DUMMY_2B_DATA(.secret);
729 TPM2B_PRIVATE *outDuplicate;
730 TPM2B_ENCRYPTED_SECRET *outSymSeed;
731 r = Esys_Rewrap(esys_context,
732 oldParent_handle,
733 newParent_handle,
734 ESYS_TR_PASSWORD,
735 ESYS_TR_NONE,
736 ESYS_TR_NONE,
737 &inDuplicate,
738 &name, &inSymSeed, &outDuplicate, &outSymSeed);
739
740 assert_int_equal(r, TPM2_RC_YIELDED);
741 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
742 }
743
744 static void
test_Import(void ** state)745 test_Import(void **state)
746 {
747 TSS2_RC r;
748 TSS2_TCTI_CONTEXT *tcti;
749 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
750 Esys_GetTcti(esys_context, &tcti);
751 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
752
753 ESYS_TR parentHandle_handle = DUMMY_TR_HANDLE_KEY;
754 TPM2B_DATA encryptionKey = DUMMY_2B_DATA(.buffer);
755 TPM2B_PUBLIC objectPublic = DUMMY_IN_PUBLIC_DATA;
756 TPM2B_PRIVATE duplicate = DUMMY_2B_DATA(.buffer);
757 TPM2B_ENCRYPTED_SECRET inSymSeed = DUMMY_2B_DATA(.secret);
758 TPMT_SYM_DEF_OBJECT symmetricAlg = DUMMY_SYMMETRIC;
759 TPM2B_PRIVATE *outPrivate;
760 r = Esys_Import(esys_context,
761 parentHandle_handle,
762 ESYS_TR_PASSWORD,
763 ESYS_TR_NONE,
764 ESYS_TR_NONE,
765 &encryptionKey,
766 &objectPublic,
767 &duplicate, &inSymSeed, &symmetricAlg, &outPrivate);
768
769 assert_int_equal(r, TPM2_RC_YIELDED);
770 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
771 }
772
773 static void
test_RSA_Encrypt(void ** state)774 test_RSA_Encrypt(void **state)
775 {
776 TSS2_RC r;
777 TSS2_TCTI_CONTEXT *tcti;
778 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
779 Esys_GetTcti(esys_context, &tcti);
780 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
781
782 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
783 TPM2B_PUBLIC_KEY_RSA message = DUMMY_2B_DATA(.buffer);
784 TPMT_RSA_DECRYPT inScheme = DUMMY_RSA_DECRYPT;
785 TPM2B_DATA label = DUMMY_2B_DATA(.buffer);
786 TPM2B_PUBLIC_KEY_RSA *outData;
787 r = Esys_RSA_Encrypt(esys_context,
788 keyHandle_handle,
789 ESYS_TR_NONE,
790 ESYS_TR_NONE,
791 ESYS_TR_NONE, &message, &inScheme, &label, &outData);
792
793 assert_int_equal(r, TPM2_RC_YIELDED);
794 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
795 }
796
797 static void
test_RSA_Decrypt(void ** state)798 test_RSA_Decrypt(void **state)
799 {
800 TSS2_RC r;
801 TSS2_TCTI_CONTEXT *tcti;
802 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
803 Esys_GetTcti(esys_context, &tcti);
804 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
805
806 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
807 TPM2B_PUBLIC_KEY_RSA cipherText = DUMMY_2B_DATA(.buffer);
808 TPMT_RSA_DECRYPT inScheme = DUMMY_RSA_DECRYPT;
809 TPM2B_DATA label = DUMMY_2B_DATA(.buffer);
810 TPM2B_PUBLIC_KEY_RSA *message;
811 r = Esys_RSA_Decrypt(esys_context,
812 keyHandle_handle,
813 ESYS_TR_PASSWORD,
814 ESYS_TR_NONE,
815 ESYS_TR_NONE,
816 &cipherText, &inScheme, &label, &message);
817
818 assert_int_equal(r, TPM2_RC_YIELDED);
819 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
820 }
821
822 static void
test_ECDH_KeyGen(void ** state)823 test_ECDH_KeyGen(void **state)
824 {
825 TSS2_RC r;
826 TSS2_TCTI_CONTEXT *tcti;
827 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
828 Esys_GetTcti(esys_context, &tcti);
829 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
830
831 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
832 TPM2B_ECC_POINT *zPoint;
833 TPM2B_ECC_POINT *pubPoint;
834 r = Esys_ECDH_KeyGen(esys_context,
835 keyHandle_handle,
836 ESYS_TR_NONE,
837 ESYS_TR_NONE, ESYS_TR_NONE, &zPoint, &pubPoint);
838
839 assert_int_equal(r, TPM2_RC_YIELDED);
840 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
841 }
842
843 static void
test_ECDH_ZGen(void ** state)844 test_ECDH_ZGen(void **state)
845 {
846 TSS2_RC r;
847 TSS2_TCTI_CONTEXT *tcti;
848 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
849 Esys_GetTcti(esys_context, &tcti);
850 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
851
852 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
853 TPM2B_ECC_POINT inPoint = { 0 };
854 TPM2B_ECC_POINT *outPoint;
855 r = Esys_ECDH_ZGen(esys_context,
856 keyHandle_handle,
857 ESYS_TR_PASSWORD,
858 ESYS_TR_NONE, ESYS_TR_NONE, &inPoint, &outPoint);
859
860 assert_int_equal(r, TPM2_RC_YIELDED);
861 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
862 }
863
864 static void
test_ECC_Parameters(void ** state)865 test_ECC_Parameters(void **state)
866 {
867 TSS2_RC r;
868 TSS2_TCTI_CONTEXT *tcti;
869 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
870 Esys_GetTcti(esys_context, &tcti);
871 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
872
873 TPMI_ECC_CURVE curveID = TPM2_ECC_BN_P256;
874 TPMS_ALGORITHM_DETAIL_ECC *parameters;
875 r = Esys_ECC_Parameters(esys_context,
876 ESYS_TR_NONE,
877 ESYS_TR_NONE, ESYS_TR_NONE, curveID, ¶meters);
878
879 assert_int_equal(r, TPM2_RC_YIELDED);
880 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
881 }
882
883 static void
test_ZGen_2Phase(void ** state)884 test_ZGen_2Phase(void **state)
885 {
886 TSS2_RC r;
887 TSS2_TCTI_CONTEXT *tcti;
888 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
889 Esys_GetTcti(esys_context, &tcti);
890 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
891
892 ESYS_TR keyA_handle = DUMMY_TR_HANDLE_KEY;
893 TPM2B_ECC_POINT inQsB = { 0 };
894 TPM2B_ECC_POINT inQeB = { 0 };
895 TPMI_ECC_KEY_EXCHANGE inScheme = TPM2_ALG_NULL;
896 UINT16 counter = 0;
897 TPM2B_ECC_POINT *outZ1;
898 TPM2B_ECC_POINT *outZ2;
899 r = Esys_ZGen_2Phase(esys_context,
900 keyA_handle,
901 ESYS_TR_PASSWORD,
902 ESYS_TR_NONE,
903 ESYS_TR_NONE,
904 &inQsB, &inQeB, inScheme, counter, &outZ1, &outZ2);
905
906 assert_int_equal(r, TPM2_RC_YIELDED);
907 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
908 }
909
910 static void
test_EncryptDecrypt(void ** state)911 test_EncryptDecrypt(void **state)
912 {
913 TSS2_RC r;
914 TSS2_TCTI_CONTEXT *tcti;
915 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
916 Esys_GetTcti(esys_context, &tcti);
917 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
918
919 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
920 TPMI_YES_NO decrypt = 0;
921 TPMI_ALG_SYM_MODE mode = TPM2_ALG_NULL;
922 TPM2B_IV ivIn = DUMMY_2B_DATA16(.buffer);
923 TPM2B_MAX_BUFFER inData = DUMMY_2B_DATA(.buffer);
924 TPM2B_MAX_BUFFER *outData;
925 TPM2B_IV *ivOut;
926 r = Esys_EncryptDecrypt(esys_context,
927 keyHandle_handle,
928 ESYS_TR_PASSWORD,
929 ESYS_TR_NONE,
930 ESYS_TR_NONE,
931 decrypt, mode, &ivIn, &inData, &outData, &ivOut);
932
933 assert_int_equal(r, TPM2_RC_YIELDED);
934 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
935 }
936
937 static void
test_EncryptDecrypt2(void ** state)938 test_EncryptDecrypt2(void **state)
939 {
940 TSS2_RC r;
941 TSS2_TCTI_CONTEXT *tcti;
942 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
943 Esys_GetTcti(esys_context, &tcti);
944 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
945
946 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
947 TPM2B_MAX_BUFFER inData = DUMMY_2B_DATA(.buffer);
948 TPMI_YES_NO decrypt = 0;
949 TPMI_ALG_SYM_MODE mode = TPM2_ALG_NULL;
950 TPM2B_IV ivIn = DUMMY_2B_DATA16(.buffer);
951 TPM2B_MAX_BUFFER *outData;
952 TPM2B_IV *ivOut;
953 r = Esys_EncryptDecrypt2(esys_context,
954 keyHandle_handle,
955 ESYS_TR_PASSWORD,
956 ESYS_TR_NONE,
957 ESYS_TR_NONE,
958 &inData, decrypt, mode, &ivIn, &outData, &ivOut);
959
960 assert_int_equal(r, TPM2_RC_YIELDED);
961 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
962 }
963
964 static void
test_Hash(void ** state)965 test_Hash(void **state)
966 {
967 TSS2_RC r;
968 TSS2_TCTI_CONTEXT *tcti;
969 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
970 Esys_GetTcti(esys_context, &tcti);
971 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
972
973 TPM2B_MAX_BUFFER data = DUMMY_2B_DATA(.buffer);
974 TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
975 TPMI_RH_HIERARCHY hierarchy = TPM2_RH_OWNER;
976 TPM2B_DIGEST *outHash;
977 TPMT_TK_HASHCHECK *validation;
978 r = Esys_Hash(esys_context,
979 ESYS_TR_NONE,
980 ESYS_TR_NONE,
981 ESYS_TR_NONE,
982 &data, hashAlg, hierarchy, &outHash, &validation);
983
984 assert_int_equal(r, TPM2_RC_YIELDED);
985 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
986 }
987
988 static void
test_HMAC(void ** state)989 test_HMAC(void **state)
990 {
991 TSS2_RC r;
992 TSS2_TCTI_CONTEXT *tcti;
993 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
994 Esys_GetTcti(esys_context, &tcti);
995 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
996
997 ESYS_TR handle_handle = DUMMY_TR_HANDLE_KEY;
998 TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
999 TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
1000 TPM2B_DIGEST *outHMAC;
1001 r = Esys_HMAC(esys_context,
1002 handle_handle,
1003 ESYS_TR_PASSWORD,
1004 ESYS_TR_NONE, ESYS_TR_NONE, &buffer, hashAlg, &outHMAC);
1005
1006 assert_int_equal(r, TPM2_RC_YIELDED);
1007 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1008 }
1009
1010 static void
test_GetRandom(void ** state)1011 test_GetRandom(void **state)
1012 {
1013 TSS2_RC r;
1014 TSS2_TCTI_CONTEXT *tcti;
1015 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1016 Esys_GetTcti(esys_context, &tcti);
1017 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1018
1019 UINT16 bytesRequested = 0;
1020 TPM2B_DIGEST *randomBytes;
1021 r = Esys_GetRandom(esys_context,
1022 ESYS_TR_NONE,
1023 ESYS_TR_NONE,
1024 ESYS_TR_NONE, bytesRequested, &randomBytes);
1025
1026 assert_int_equal(r, TPM2_RC_YIELDED);
1027 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1028 }
1029
1030 static void
test_StirRandom(void ** state)1031 test_StirRandom(void **state)
1032 {
1033 TSS2_RC r;
1034 TSS2_TCTI_CONTEXT *tcti;
1035 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1036 Esys_GetTcti(esys_context, &tcti);
1037 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1038
1039 TPM2B_SENSITIVE_DATA inData = DUMMY_2B_DATA(.buffer);
1040 r = Esys_StirRandom(esys_context,
1041 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &inData);
1042
1043 assert_int_equal(r, TPM2_RC_YIELDED);
1044 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1045 }
1046
1047 static void
test_HMAC_Start(void ** state)1048 test_HMAC_Start(void **state)
1049 {
1050 TSS2_RC r;
1051 TSS2_TCTI_CONTEXT *tcti;
1052 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1053 Esys_GetTcti(esys_context, &tcti);
1054 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1055
1056 ESYS_TR handle_handle = DUMMY_TR_HANDLE_KEY;
1057 TPM2B_AUTH auth = DUMMY_2B_DATA(.buffer);
1058 TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
1059 ESYS_TR sequenceHandle_handle;
1060 r = Esys_HMAC_Start(esys_context,
1061 handle_handle,
1062 ESYS_TR_PASSWORD,
1063 ESYS_TR_NONE,
1064 ESYS_TR_NONE, &auth, hashAlg, &sequenceHandle_handle);
1065
1066 assert_int_equal(r, TPM2_RC_YIELDED);
1067 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1068 }
1069
1070 static void
test_HashSequenceStart(void ** state)1071 test_HashSequenceStart(void **state)
1072 {
1073 TSS2_RC r;
1074 TSS2_TCTI_CONTEXT *tcti;
1075 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1076 Esys_GetTcti(esys_context, &tcti);
1077 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1078
1079 TPM2B_AUTH auth = DUMMY_2B_DATA(.buffer);
1080 TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
1081 ESYS_TR sequenceHandle_handle;
1082 r = Esys_HashSequenceStart(esys_context,
1083 ESYS_TR_NONE,
1084 ESYS_TR_NONE,
1085 ESYS_TR_NONE,
1086 &auth, hashAlg, &sequenceHandle_handle);
1087
1088 assert_int_equal(r, TPM2_RC_YIELDED);
1089 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1090 }
1091
1092 static void
test_SequenceUpdate(void ** state)1093 test_SequenceUpdate(void **state)
1094 {
1095 TSS2_RC r;
1096 TSS2_TCTI_CONTEXT *tcti;
1097 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1098 Esys_GetTcti(esys_context, &tcti);
1099 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1100
1101 ESYS_TR sequenceHandle_handle = DUMMY_TR_HANDLE_KEY;
1102 TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
1103 r = Esys_SequenceUpdate(esys_context,
1104 sequenceHandle_handle,
1105 ESYS_TR_PASSWORD,
1106 ESYS_TR_NONE, ESYS_TR_NONE, &buffer);
1107
1108 assert_int_equal(r, TPM2_RC_YIELDED);
1109 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1110 }
1111
1112 static void
test_SequenceComplete(void ** state)1113 test_SequenceComplete(void **state)
1114 {
1115 TSS2_RC r;
1116 TSS2_TCTI_CONTEXT *tcti;
1117 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1118 Esys_GetTcti(esys_context, &tcti);
1119 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1120
1121 ESYS_TR sequenceHandle_handle = DUMMY_TR_HANDLE_KEY;
1122 TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
1123 TPMI_RH_HIERARCHY hierarchy = TPM2_RH_OWNER;
1124 TPM2B_DIGEST *result;
1125 TPMT_TK_HASHCHECK *validation;
1126 r = Esys_SequenceComplete(esys_context,
1127 sequenceHandle_handle,
1128 ESYS_TR_PASSWORD,
1129 ESYS_TR_NONE,
1130 ESYS_TR_NONE,
1131 &buffer, hierarchy, &result, &validation);
1132
1133 assert_int_equal(r, TPM2_RC_YIELDED);
1134 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1135 }
1136
1137 static void
test_EventSequenceComplete(void ** state)1138 test_EventSequenceComplete(void **state)
1139 {
1140 TSS2_RC r;
1141 TSS2_TCTI_CONTEXT *tcti;
1142 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1143 Esys_GetTcti(esys_context, &tcti);
1144 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1145
1146 ESYS_TR pcrHandle_handle = 16;
1147 ESYS_TR sequenceHandle_handle = DUMMY_TR_HANDLE_KEY;
1148 TPM2B_MAX_BUFFER buffer = DUMMY_2B_DATA(.buffer);
1149 TPML_DIGEST_VALUES *results;
1150 r = Esys_EventSequenceComplete(esys_context,
1151 pcrHandle_handle,
1152 sequenceHandle_handle,
1153 ESYS_TR_PASSWORD,
1154 ESYS_TR_PASSWORD,
1155 ESYS_TR_NONE, &buffer, &results);
1156
1157 assert_int_equal(r, TPM2_RC_YIELDED);
1158 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1159 }
1160
1161 static void
test_Certify(void ** state)1162 test_Certify(void **state)
1163 {
1164 TSS2_RC r;
1165 TSS2_TCTI_CONTEXT *tcti;
1166 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1167 Esys_GetTcti(esys_context, &tcti);
1168 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1169
1170 ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
1171 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
1172 TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
1173 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
1174 TPM2B_ATTEST *certifyInfo;
1175 TPMT_SIGNATURE *signature;
1176 r = Esys_Certify(esys_context,
1177 objectHandle_handle,
1178 signHandle_handle,
1179 ESYS_TR_PASSWORD,
1180 ESYS_TR_PASSWORD,
1181 ESYS_TR_NONE,
1182 &qualifyingData, &inScheme, &certifyInfo, &signature);
1183
1184 assert_int_equal(r, TPM2_RC_YIELDED);
1185 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1186 }
1187
1188 static void
test_CertifyCreation(void ** state)1189 test_CertifyCreation(void **state)
1190 {
1191 TSS2_RC r;
1192 TSS2_TCTI_CONTEXT *tcti;
1193 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1194 Esys_GetTcti(esys_context, &tcti);
1195 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1196
1197 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
1198 ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
1199 TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
1200 TPM2B_DIGEST creationHash = DUMMY_2B_DATA(.buffer);
1201 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
1202 TPMT_TK_CREATION creationTicket = DUMMY_TPMT_TK_CREATION;
1203 TPM2B_ATTEST *certifyInfo;
1204 TPMT_SIGNATURE *signature;
1205 r = Esys_CertifyCreation(esys_context,
1206 signHandle_handle,
1207 objectHandle_handle,
1208 ESYS_TR_PASSWORD,
1209 ESYS_TR_NONE,
1210 ESYS_TR_NONE,
1211 &qualifyingData,
1212 &creationHash,
1213 &inScheme,
1214 &creationTicket, &certifyInfo, &signature);
1215
1216 assert_int_equal(r, TPM2_RC_YIELDED);
1217 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1218 }
1219
1220 static void
test_Quote(void ** state)1221 test_Quote(void **state)
1222 {
1223 TSS2_RC r;
1224 TSS2_TCTI_CONTEXT *tcti;
1225 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1226 Esys_GetTcti(esys_context, &tcti);
1227 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1228
1229 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
1230 TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
1231 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
1232 TPML_PCR_SELECTION PCRselect = { 0 };
1233 TPM2B_ATTEST *quoted;
1234 TPMT_SIGNATURE *signature;
1235 r = Esys_Quote(esys_context,
1236 signHandle_handle,
1237 ESYS_TR_PASSWORD,
1238 ESYS_TR_NONE,
1239 ESYS_TR_NONE,
1240 &qualifyingData, &inScheme, &PCRselect, "ed, &signature);
1241
1242 assert_int_equal(r, TPM2_RC_YIELDED);
1243 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1244 }
1245
1246 static void
test_GetSessionAuditDigest(void ** state)1247 test_GetSessionAuditDigest(void **state)
1248 {
1249 TSS2_RC r;
1250 TSS2_TCTI_CONTEXT *tcti;
1251 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1252 Esys_GetTcti(esys_context, &tcti);
1253 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1254
1255 ESYS_TR privacyAdminHandle_handle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
1256 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
1257 ESYS_TR sessionHandle_handle = DUMMY_TR_HANDLE_HMAC_SESSION;
1258 TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
1259 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
1260 TPM2B_ATTEST *auditInfo;
1261 TPMT_SIGNATURE *signature;
1262 r = Esys_GetSessionAuditDigest(esys_context,
1263 privacyAdminHandle_handle,
1264 signHandle_handle,
1265 sessionHandle_handle,
1266 ESYS_TR_PASSWORD,
1267 ESYS_TR_PASSWORD,
1268 ESYS_TR_NONE,
1269 &qualifyingData,
1270 &inScheme, &auditInfo, &signature);
1271
1272 assert_int_equal(r, TPM2_RC_YIELDED);
1273 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1274 }
1275
1276 static void
test_GetCommandAuditDigest(void ** state)1277 test_GetCommandAuditDigest(void **state)
1278 {
1279 TSS2_RC r;
1280 TSS2_TCTI_CONTEXT *tcti;
1281 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1282 Esys_GetTcti(esys_context, &tcti);
1283 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1284
1285 ESYS_TR privacyHandle_handle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
1286 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
1287 TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
1288 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
1289 TPM2B_ATTEST *auditInfo;
1290 TPMT_SIGNATURE *signature;
1291 r = Esys_GetCommandAuditDigest(esys_context,
1292 privacyHandle_handle,
1293 signHandle_handle,
1294 ESYS_TR_PASSWORD,
1295 ESYS_TR_PASSWORD,
1296 ESYS_TR_NONE,
1297 &qualifyingData,
1298 &inScheme, &auditInfo, &signature);
1299
1300 assert_int_equal(r, TPM2_RC_YIELDED);
1301 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1302 }
1303
1304 static void
test_GetTime(void ** state)1305 test_GetTime(void **state)
1306 {
1307 TSS2_RC r;
1308 TSS2_TCTI_CONTEXT *tcti;
1309 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1310 Esys_GetTcti(esys_context, &tcti);
1311 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1312
1313 ESYS_TR privacyAdminHandle_handle = DUMMY_TR_HANDLE_PRIVACY_ADMIN;
1314 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
1315 TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
1316 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
1317 TPM2B_ATTEST *timeInfo;
1318 TPMT_SIGNATURE *signature;
1319 r = Esys_GetTime(esys_context,
1320 privacyAdminHandle_handle,
1321 signHandle_handle,
1322 ESYS_TR_PASSWORD,
1323 ESYS_TR_PASSWORD,
1324 ESYS_TR_NONE,
1325 &qualifyingData, &inScheme, &timeInfo, &signature);
1326
1327 assert_int_equal(r, TPM2_RC_YIELDED);
1328 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1329 }
1330
1331 static void
test_Commit(void ** state)1332 test_Commit(void **state)
1333 {
1334 TSS2_RC r;
1335 TSS2_TCTI_CONTEXT *tcti;
1336 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1337 Esys_GetTcti(esys_context, &tcti);
1338 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1339
1340 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
1341 TPM2B_ECC_POINT P1 = { 0 };
1342 TPM2B_SENSITIVE_DATA s2 = DUMMY_2B_DATA(.buffer);
1343 TPM2B_ECC_PARAMETER y2 = { 0 };
1344 TPM2B_ECC_POINT *K;
1345 TPM2B_ECC_POINT *L;
1346 TPM2B_ECC_POINT *E;
1347 UINT16 counter;
1348 r = Esys_Commit(esys_context,
1349 signHandle_handle,
1350 ESYS_TR_PASSWORD,
1351 ESYS_TR_NONE,
1352 ESYS_TR_NONE, &P1, &s2, &y2, &K, &L, &E, &counter);
1353
1354 assert_int_equal(r, TPM2_RC_YIELDED);
1355 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1356 }
1357
1358 static void
test_EC_Ephemeral(void ** state)1359 test_EC_Ephemeral(void **state)
1360 {
1361 TSS2_RC r;
1362 TSS2_TCTI_CONTEXT *tcti;
1363 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1364 Esys_GetTcti(esys_context, &tcti);
1365 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1366
1367 TPMI_ECC_CURVE curveID = TPM2_ECC_BN_P256;
1368 TPM2B_ECC_POINT *Q;
1369 UINT16 counter;
1370 r = Esys_EC_Ephemeral(esys_context,
1371 ESYS_TR_NONE,
1372 ESYS_TR_NONE, ESYS_TR_NONE, curveID, &Q, &counter);
1373
1374 assert_int_equal(r, TPM2_RC_YIELDED);
1375 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1376 }
1377
1378 static void
test_VerifySignature(void ** state)1379 test_VerifySignature(void **state)
1380 {
1381 TSS2_RC r;
1382 TSS2_TCTI_CONTEXT *tcti;
1383 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1384 Esys_GetTcti(esys_context, &tcti);
1385 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1386
1387 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
1388 TPM2B_DIGEST digest = DUMMY_2B_DATA(.buffer);
1389 TPMT_SIGNATURE signature = DUMMY_TPMT_SIGNATURE;
1390 TPMT_TK_VERIFIED *validation;
1391 r = Esys_VerifySignature(esys_context,
1392 keyHandle_handle,
1393 ESYS_TR_NONE,
1394 ESYS_TR_NONE,
1395 ESYS_TR_NONE, &digest, &signature, &validation);
1396
1397 assert_int_equal(r, TPM2_RC_YIELDED);
1398 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1399 }
1400
1401 static void
test_Sign(void ** state)1402 test_Sign(void **state)
1403 {
1404 TSS2_RC r;
1405 TSS2_TCTI_CONTEXT *tcti;
1406 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1407 Esys_GetTcti(esys_context, &tcti);
1408 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1409
1410 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
1411 TPM2B_DIGEST digest = DUMMY_2B_DATA(.buffer);
1412 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
1413 TPMT_TK_HASHCHECK validation = DUMMY_TPMT_TK_HASHCHECK;
1414 TPMT_SIGNATURE *signature;
1415 r = Esys_Sign(esys_context,
1416 keyHandle_handle,
1417 ESYS_TR_PASSWORD,
1418 ESYS_TR_NONE,
1419 ESYS_TR_NONE, &digest, &inScheme, &validation, &signature);
1420
1421 assert_int_equal(r, TPM2_RC_YIELDED);
1422 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1423 }
1424
1425 static void
test_SetCommandCodeAuditStatus(void ** state)1426 test_SetCommandCodeAuditStatus(void **state)
1427 {
1428 TSS2_RC r;
1429 TSS2_TCTI_CONTEXT *tcti;
1430 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1431 Esys_GetTcti(esys_context, &tcti);
1432 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1433
1434 ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
1435 TPMI_ALG_HASH auditAlg = TPM2_ALG_SHA1;
1436 TPML_CC setList = { 0 };
1437 TPML_CC clearList = { 0 };
1438 r = Esys_SetCommandCodeAuditStatus(esys_context,
1439 auth_handle,
1440 ESYS_TR_PASSWORD,
1441 ESYS_TR_NONE,
1442 ESYS_TR_NONE,
1443 auditAlg, &setList, &clearList);
1444
1445 assert_int_equal(r, TPM2_RC_YIELDED);
1446 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1447 }
1448
1449 static void
test_PCR_Extend(void ** state)1450 test_PCR_Extend(void **state)
1451 {
1452 TSS2_RC r;
1453 TSS2_TCTI_CONTEXT *tcti;
1454 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1455 Esys_GetTcti(esys_context, &tcti);
1456 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1457
1458 ESYS_TR pcrHandle_handle = 16;
1459 TPML_DIGEST_VALUES digests = { 0 };
1460 r = Esys_PCR_Extend(esys_context,
1461 pcrHandle_handle,
1462 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, &digests);
1463
1464 assert_int_equal(r, TPM2_RC_YIELDED);
1465 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1466 }
1467
1468 static void
test_PCR_Event(void ** state)1469 test_PCR_Event(void **state)
1470 {
1471 TSS2_RC r;
1472 TSS2_TCTI_CONTEXT *tcti;
1473 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1474 Esys_GetTcti(esys_context, &tcti);
1475 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1476
1477 ESYS_TR pcrHandle_handle = 16;
1478 TPM2B_EVENT eventData = DUMMY_2B_DATA(.buffer);
1479 TPML_DIGEST_VALUES *digests;
1480 r = Esys_PCR_Event(esys_context,
1481 pcrHandle_handle,
1482 ESYS_TR_PASSWORD,
1483 ESYS_TR_NONE, ESYS_TR_NONE, &eventData, &digests);
1484
1485 assert_int_equal(r, TPM2_RC_YIELDED);
1486 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1487 }
1488
1489 static void
test_PCR_Read(void ** state)1490 test_PCR_Read(void **state)
1491 {
1492 TSS2_RC r;
1493 TSS2_TCTI_CONTEXT *tcti;
1494 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1495 Esys_GetTcti(esys_context, &tcti);
1496 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1497
1498 TPML_PCR_SELECTION pcrSelectionIn = { 0 };
1499 TPML_PCR_SELECTION *pcrSelectionOut;
1500 TPML_DIGEST *pcrValues;
1501 UINT32 pcrUpdateCounter;
1502 r = Esys_PCR_Read(esys_context,
1503 ESYS_TR_NONE,
1504 ESYS_TR_NONE,
1505 ESYS_TR_NONE,
1506 &pcrSelectionIn,
1507 &pcrUpdateCounter, &pcrSelectionOut, &pcrValues);
1508
1509 assert_int_equal(r, TPM2_RC_YIELDED);
1510 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1511 }
1512
1513 static void
test_PCR_Allocate(void ** state)1514 test_PCR_Allocate(void **state)
1515 {
1516 TSS2_RC r;
1517 TSS2_TCTI_CONTEXT *tcti;
1518 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1519 Esys_GetTcti(esys_context, &tcti);
1520 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1521
1522 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
1523 TPML_PCR_SELECTION pcrAllocation = { 0 };
1524 TPMI_YES_NO allocationSuccess;
1525 UINT32 maxPCR;
1526 UINT32 sizeNeeded;
1527 UINT32 sizeAvailable;
1528 r = Esys_PCR_Allocate(esys_context,
1529 authHandle_handle,
1530 ESYS_TR_PASSWORD,
1531 ESYS_TR_NONE,
1532 ESYS_TR_NONE,
1533 &pcrAllocation,
1534 &allocationSuccess,
1535 &maxPCR, &sizeNeeded, &sizeAvailable);
1536
1537 assert_int_equal(r, TPM2_RC_YIELDED);
1538 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1539 }
1540
1541 static void
test_PCR_SetAuthPolicy(void ** state)1542 test_PCR_SetAuthPolicy(void **state)
1543 {
1544 TSS2_RC r;
1545 TSS2_TCTI_CONTEXT *tcti;
1546 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1547 Esys_GetTcti(esys_context, &tcti);
1548 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1549
1550 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
1551 TPM2B_DIGEST authPolicy = DUMMY_2B_DATA(.buffer);
1552 TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
1553 TPMI_DH_PCR pcrNum = 0;
1554 r = Esys_PCR_SetAuthPolicy(esys_context,
1555 authHandle_handle,
1556 ESYS_TR_PASSWORD,
1557 ESYS_TR_NONE,
1558 ESYS_TR_NONE, &authPolicy, hashAlg, pcrNum);
1559
1560 assert_int_equal(r, TPM2_RC_YIELDED);
1561 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1562 }
1563
1564 static void
test_PCR_SetAuthValue(void ** state)1565 test_PCR_SetAuthValue(void **state)
1566 {
1567 TSS2_RC r;
1568 TSS2_TCTI_CONTEXT *tcti;
1569 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1570 Esys_GetTcti(esys_context, &tcti);
1571 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1572
1573 ESYS_TR pcrHandle_handle = 16;
1574 TPM2B_DIGEST auth = DUMMY_2B_DATA(.buffer);
1575 r = Esys_PCR_SetAuthValue(esys_context,
1576 pcrHandle_handle,
1577 ESYS_TR_PASSWORD,
1578 ESYS_TR_NONE, ESYS_TR_NONE, &auth);
1579
1580 assert_int_equal(r, TPM2_RC_YIELDED);
1581 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1582 }
1583
1584 static void
test_PCR_Reset(void ** state)1585 test_PCR_Reset(void **state)
1586 {
1587 TSS2_RC r;
1588 TSS2_TCTI_CONTEXT *tcti;
1589 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1590 Esys_GetTcti(esys_context, &tcti);
1591 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1592
1593 ESYS_TR pcrHandle_handle = 16;
1594 r = Esys_PCR_Reset(esys_context,
1595 pcrHandle_handle,
1596 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
1597
1598 assert_int_equal(r, TPM2_RC_YIELDED);
1599 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1600 }
1601
1602 static void
test_PolicySigned(void ** state)1603 test_PolicySigned(void **state)
1604 {
1605 TSS2_RC r;
1606 TSS2_TCTI_CONTEXT *tcti;
1607 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1608 Esys_GetTcti(esys_context, &tcti);
1609 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1610
1611 ESYS_TR authObject_handle = DUMMY_TR_HANDLE_KEY;
1612 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1613 TPM2B_NONCE nonceTPM = DUMMY_2B_DATA(.buffer);
1614 TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
1615 TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
1616 INT32 expiration = 0;
1617 TPMT_SIGNATURE auth = DUMMY_TPMT_SIGNATURE;
1618 TPM2B_TIMEOUT *timeout;
1619 TPMT_TK_AUTH *policyTicket;
1620 r = Esys_PolicySigned(esys_context,
1621 authObject_handle,
1622 policySession_handle,
1623 ESYS_TR_NONE,
1624 ESYS_TR_NONE,
1625 ESYS_TR_NONE,
1626 &nonceTPM,
1627 &cpHashA,
1628 &policyRef,
1629 expiration, &auth, &timeout, &policyTicket);
1630
1631 assert_int_equal(r, TPM2_RC_YIELDED);
1632 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1633 }
1634
1635 static void
test_PolicySecret(void ** state)1636 test_PolicySecret(void **state)
1637 {
1638 TSS2_RC r;
1639 TSS2_TCTI_CONTEXT *tcti;
1640 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1641 Esys_GetTcti(esys_context, &tcti);
1642 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1643
1644 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
1645 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1646 TPM2B_NONCE nonceTPM = DUMMY_2B_DATA(.buffer);
1647 TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
1648 TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
1649 INT32 expiration = 0;
1650 TPM2B_TIMEOUT *timeout;
1651 TPMT_TK_AUTH *policyTicket;
1652 r = Esys_PolicySecret(esys_context,
1653 authHandle_handle,
1654 policySession_handle,
1655 ESYS_TR_PASSWORD,
1656 ESYS_TR_NONE,
1657 ESYS_TR_NONE,
1658 &nonceTPM,
1659 &cpHashA,
1660 &policyRef, expiration, &timeout, &policyTicket);
1661
1662 assert_int_equal(r, TPM2_RC_YIELDED);
1663 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1664 }
1665
1666 static void
test_PolicyTicket(void ** state)1667 test_PolicyTicket(void **state)
1668 {
1669 TSS2_RC r;
1670 TSS2_TCTI_CONTEXT *tcti;
1671 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1672 Esys_GetTcti(esys_context, &tcti);
1673 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1674
1675 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1676 TPM2B_TIMEOUT timeout = DUMMY_2B_DATA(.buffer);
1677 TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
1678 TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
1679 TPM2B_NAME authName = DUMMY_2B_DATA(.name);
1680 TPMT_TK_AUTH ticket = DUMMY_TPMT_TK_AUTH;
1681 r = Esys_PolicyTicket(esys_context,
1682 policySession_handle,
1683 ESYS_TR_NONE,
1684 ESYS_TR_NONE,
1685 ESYS_TR_NONE,
1686 &timeout, &cpHashA, &policyRef, &authName, &ticket);
1687
1688 assert_int_equal(r, TPM2_RC_YIELDED);
1689 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1690 }
1691
1692 static void
test_PolicyOR(void ** state)1693 test_PolicyOR(void **state)
1694 {
1695 TSS2_RC r;
1696 TSS2_TCTI_CONTEXT *tcti;
1697 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1698 Esys_GetTcti(esys_context, &tcti);
1699 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1700
1701 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1702 TPML_DIGEST pHashList = { 0 };
1703 r = Esys_PolicyOR(esys_context,
1704 policySession_handle,
1705 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &pHashList);
1706
1707 assert_int_equal(r, TPM2_RC_YIELDED);
1708 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1709 }
1710
1711 static void
test_PolicyPCR(void ** state)1712 test_PolicyPCR(void **state)
1713 {
1714 TSS2_RC r;
1715 TSS2_TCTI_CONTEXT *tcti;
1716 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1717 Esys_GetTcti(esys_context, &tcti);
1718 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1719
1720 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1721 TPM2B_DIGEST pcrDigest = DUMMY_2B_DATA(.buffer);
1722 TPML_PCR_SELECTION pcrs = { 0 };
1723 r = Esys_PolicyPCR(esys_context,
1724 policySession_handle,
1725 ESYS_TR_NONE,
1726 ESYS_TR_NONE, ESYS_TR_NONE, &pcrDigest, &pcrs);
1727
1728 assert_int_equal(r, TPM2_RC_YIELDED);
1729 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1730 }
1731
1732 static void
test_PolicyLocality(void ** state)1733 test_PolicyLocality(void **state)
1734 {
1735 TSS2_RC r;
1736 TSS2_TCTI_CONTEXT *tcti;
1737 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1738 Esys_GetTcti(esys_context, &tcti);
1739 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1740 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1741 TPMA_LOCALITY locality = TPMA_LOCALITY_TPM2_LOC_ZERO;
1742 r = Esys_PolicyLocality(esys_context,
1743 policySession_handle,
1744 ESYS_TR_NONE,
1745 ESYS_TR_NONE,
1746 ESYS_TR_NONE,
1747 locality);
1748
1749 assert_int_equal(r, TPM2_RC_YIELDED);
1750 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1751 }
1752
1753 static void
test_PolicyNV(void ** state)1754 test_PolicyNV(void **state)
1755 {
1756 TSS2_RC r;
1757 TSS2_TCTI_CONTEXT *tcti;
1758 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1759 Esys_GetTcti(esys_context, &tcti);
1760 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1761
1762 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
1763 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
1764 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1765 TPM2B_OPERAND operandB = DUMMY_2B_DATA(.buffer);
1766 UINT16 offset = 0;
1767 TPM2_EO operation = 0;
1768 r = Esys_PolicyNV(esys_context,
1769 authHandle_handle,
1770 nvIndex_handle,
1771 policySession_handle,
1772 ESYS_TR_PASSWORD,
1773 ESYS_TR_NONE, ESYS_TR_NONE, &operandB, offset, operation);
1774
1775 assert_int_equal(r, TPM2_RC_YIELDED);
1776 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1777 }
1778
1779 static void
test_PolicyCounterTimer(void ** state)1780 test_PolicyCounterTimer(void **state)
1781 {
1782 TSS2_RC r;
1783 TSS2_TCTI_CONTEXT *tcti;
1784 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1785 Esys_GetTcti(esys_context, &tcti);
1786 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1787
1788 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1789 TPM2B_OPERAND operandB = DUMMY_2B_DATA(.buffer);
1790 UINT16 offset = 0;
1791 TPM2_EO operation = 0;
1792 r = Esys_PolicyCounterTimer(esys_context,
1793 policySession_handle,
1794 ESYS_TR_NONE,
1795 ESYS_TR_NONE,
1796 ESYS_TR_NONE, &operandB, offset, operation);
1797
1798 assert_int_equal(r, TPM2_RC_YIELDED);
1799 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1800 }
1801
1802 static void
test_PolicyCommandCode(void ** state)1803 test_PolicyCommandCode(void **state)
1804 {
1805 TSS2_RC r;
1806 TSS2_TCTI_CONTEXT *tcti;
1807 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1808 Esys_GetTcti(esys_context, &tcti);
1809 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1810
1811 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1812 TPM2_CC code = TPM2_CC_FIRST;
1813 r = Esys_PolicyCommandCode(esys_context,
1814 policySession_handle,
1815 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, code);
1816
1817 assert_int_equal(r, TPM2_RC_YIELDED);
1818 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1819 }
1820
1821 static void
test_PolicyPhysicalPresence(void ** state)1822 test_PolicyPhysicalPresence(void **state)
1823 {
1824 TSS2_RC r;
1825 TSS2_TCTI_CONTEXT *tcti;
1826 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1827 Esys_GetTcti(esys_context, &tcti);
1828 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1829
1830 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1831 r = Esys_PolicyPhysicalPresence(esys_context,
1832 policySession_handle,
1833 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
1834
1835 assert_int_equal(r, TPM2_RC_YIELDED);
1836 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1837 }
1838
1839 static void
test_PolicyCpHash(void ** state)1840 test_PolicyCpHash(void **state)
1841 {
1842 TSS2_RC r;
1843 TSS2_TCTI_CONTEXT *tcti;
1844 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1845 Esys_GetTcti(esys_context, &tcti);
1846 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1847
1848 ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
1849 TPM2B_DIGEST cpHashA = DUMMY_2B_DATA(.buffer);
1850 r = Esys_PolicyCpHash(esys_context,
1851 policySession,
1852 ESYS_TR_NONE,
1853 ESYS_TR_NONE, ESYS_TR_NONE, &cpHashA);
1854
1855 assert_int_equal(r, TPM2_RC_YIELDED);
1856 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1857 }
1858
1859 static void
test_PolicyNameHash(void ** state)1860 test_PolicyNameHash(void **state)
1861 {
1862 TSS2_RC r;
1863 TSS2_TCTI_CONTEXT *tcti;
1864 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1865 Esys_GetTcti(esys_context, &tcti);
1866 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1867
1868 ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
1869 TPM2B_DIGEST nameHash = DUMMY_2B_DATA(.buffer);
1870 r = Esys_PolicyNameHash(esys_context,
1871 policySession,
1872 ESYS_TR_NONE,
1873 ESYS_TR_NONE,
1874 ESYS_TR_NONE, &nameHash);
1875
1876 assert_int_equal(r, TPM2_RC_YIELDED);
1877 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1878 }
1879
1880 static void
test_PolicyDuplicationSelect(void ** state)1881 test_PolicyDuplicationSelect(void **state)
1882 {
1883 TSS2_RC r;
1884 TSS2_TCTI_CONTEXT *tcti;
1885 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1886 Esys_GetTcti(esys_context, &tcti);
1887 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1888
1889 ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
1890 TPM2B_NAME objectName = DUMMY_2B_DATA(.name);
1891 TPM2B_NAME newParentName = DUMMY_2B_DATA(.name);
1892 TPMI_YES_NO includeObject = 0;
1893 r = Esys_PolicyDuplicationSelect(esys_context,
1894 policySession,
1895 ESYS_TR_NONE,
1896 ESYS_TR_NONE,
1897 ESYS_TR_NONE,
1898 &objectName,
1899 &newParentName, includeObject);
1900
1901 assert_int_equal(r, TPM2_RC_YIELDED);
1902 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1903 }
1904
1905 static void
test_PolicyAuthorize(void ** state)1906 test_PolicyAuthorize(void **state)
1907 {
1908 TSS2_RC r;
1909 TSS2_TCTI_CONTEXT *tcti;
1910 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1911 Esys_GetTcti(esys_context, &tcti);
1912 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1913
1914 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1915 TPM2B_DIGEST approvedPolicy = DUMMY_2B_DATA(.buffer);
1916 TPM2B_NONCE policyRef = DUMMY_2B_DATA(.buffer);
1917 TPM2B_NAME keySign = DUMMY_2B_DATA(.name);
1918 TPMT_TK_VERIFIED checkTicket = DUMMY_TPMT_TK_VERIFIED;
1919 r = Esys_PolicyAuthorize(esys_context,
1920 policySession_handle,
1921 ESYS_TR_NONE,
1922 ESYS_TR_NONE,
1923 ESYS_TR_NONE,
1924 &approvedPolicy,
1925 &policyRef, &keySign, &checkTicket);
1926
1927 assert_int_equal(r, TPM2_RC_YIELDED);
1928 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1929 }
1930
1931 static void
test_PolicyAuthValue(void ** state)1932 test_PolicyAuthValue(void **state)
1933 {
1934 TSS2_RC r;
1935 TSS2_TCTI_CONTEXT *tcti;
1936 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1937 Esys_GetTcti(esys_context, &tcti);
1938 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1939
1940 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1941 r = Esys_PolicyAuthValue(esys_context,
1942 policySession_handle,
1943 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
1944
1945 assert_int_equal(r, TPM2_RC_YIELDED);
1946 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1947 }
1948
1949 static void
test_PolicyPassword(void ** state)1950 test_PolicyPassword(void **state)
1951 {
1952 TSS2_RC r;
1953 TSS2_TCTI_CONTEXT *tcti;
1954 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1955 Esys_GetTcti(esys_context, &tcti);
1956 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1957
1958 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1959 r = Esys_PolicyPassword(esys_context,
1960 policySession_handle,
1961 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
1962
1963 assert_int_equal(r, TPM2_RC_YIELDED);
1964 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1965 }
1966
1967 static void
test_PolicyGetDigest(void ** state)1968 test_PolicyGetDigest(void **state)
1969 {
1970 TSS2_RC r;
1971 TSS2_TCTI_CONTEXT *tcti;
1972 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1973 Esys_GetTcti(esys_context, &tcti);
1974 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1975
1976 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1977 TPM2B_DIGEST *policyDigest;
1978 r = Esys_PolicyGetDigest(esys_context,
1979 policySession_handle,
1980 ESYS_TR_NONE,
1981 ESYS_TR_NONE, ESYS_TR_NONE, &policyDigest);
1982
1983 assert_int_equal(r, TPM2_RC_YIELDED);
1984 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
1985 }
1986
1987 static void
test_PolicyNvWritten(void ** state)1988 test_PolicyNvWritten(void **state)
1989 {
1990 TSS2_RC r;
1991 TSS2_TCTI_CONTEXT *tcti;
1992 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1993 Esys_GetTcti(esys_context, &tcti);
1994 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
1995
1996 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
1997 TPMI_YES_NO writtenSet = 0;
1998 r = Esys_PolicyNvWritten(esys_context,
1999 policySession_handle,
2000 ESYS_TR_NONE,
2001 ESYS_TR_NONE, ESYS_TR_NONE, writtenSet);
2002
2003 assert_int_equal(r, TPM2_RC_YIELDED);
2004 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2005 }
2006
2007 static void
test_PolicyTemplate(void ** state)2008 test_PolicyTemplate(void **state)
2009 {
2010 TSS2_RC r;
2011 TSS2_TCTI_CONTEXT *tcti;
2012 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2013 Esys_GetTcti(esys_context, &tcti);
2014 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2015
2016 ESYS_TR policySession = DUMMY_TR_HANDLE_POLICY_SESSION;
2017 TPM2B_DIGEST templateHash = DUMMY_2B_DATA(.buffer);
2018 r = Esys_PolicyTemplate(esys_context,
2019 policySession,
2020 ESYS_TR_NONE,
2021 ESYS_TR_NONE,
2022 ESYS_TR_NONE, &templateHash);
2023
2024 assert_int_equal(r, TPM2_RC_YIELDED);
2025 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2026 }
2027
2028 static void
test_PolicyAuthorizeNV(void ** state)2029 test_PolicyAuthorizeNV(void **state)
2030 {
2031 TSS2_RC r;
2032 TSS2_TCTI_CONTEXT *tcti;
2033 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2034 Esys_GetTcti(esys_context, &tcti);
2035 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2036
2037 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2038 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2039 ESYS_TR policySession_handle = DUMMY_TR_HANDLE_POLICY_SESSION;
2040 r = Esys_PolicyAuthorizeNV(esys_context,
2041 authHandle_handle,
2042 nvIndex_handle,
2043 policySession_handle,
2044 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2045
2046 assert_int_equal(r, TPM2_RC_YIELDED);
2047 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2048 }
2049
2050 static void
test_CreatePrimary(void ** state)2051 test_CreatePrimary(void **state)
2052 {
2053 TSS2_RC r;
2054 TSS2_TCTI_CONTEXT *tcti;
2055 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2056 Esys_GetTcti(esys_context, &tcti);
2057 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2058
2059 ESYS_TR primaryHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2060 TPM2B_SENSITIVE_CREATE inSensitive = { 0 };
2061 TPM2B_PUBLIC inPublic = DUMMY_IN_PUBLIC_DATA;
2062 TPM2B_DATA outsideInfo = DUMMY_2B_DATA(.buffer);
2063 TPML_PCR_SELECTION creationPCR = { 0 };
2064 ESYS_TR objectHandle_handle;
2065 TPM2B_PUBLIC *outPublic;
2066 TPM2B_CREATION_DATA *creationData;
2067 TPM2B_DIGEST *creationHash;
2068 TPMT_TK_CREATION *creationTicket;
2069 r = Esys_CreatePrimary(esys_context,
2070 primaryHandle_handle,
2071 ESYS_TR_PASSWORD,
2072 ESYS_TR_NONE,
2073 ESYS_TR_NONE,
2074 &inSensitive,
2075 &inPublic,
2076 &outsideInfo,
2077 &creationPCR,
2078 &objectHandle_handle,
2079 &outPublic,
2080 &creationData, &creationHash, &creationTicket);
2081
2082 assert_int_equal(r, TPM2_RC_YIELDED);
2083 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2084 }
2085
2086 static void
test_HierarchyControl(void ** state)2087 test_HierarchyControl(void **state)
2088 {
2089 TSS2_RC r;
2090 TSS2_TCTI_CONTEXT *tcti;
2091 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2092 Esys_GetTcti(esys_context, &tcti);
2093 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2094
2095 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2096 TPMI_RH_ENABLES enable = TPM2_RH_OWNER;
2097 TPMI_YES_NO state2 = 0;
2098 r = Esys_HierarchyControl(esys_context,
2099 authHandle_handle,
2100 ESYS_TR_PASSWORD,
2101 ESYS_TR_NONE, ESYS_TR_NONE, enable, state2);
2102
2103 assert_int_equal(r, TPM2_RC_YIELDED);
2104 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2105 }
2106
2107 static void
test_SetPrimaryPolicy(void ** state)2108 test_SetPrimaryPolicy(void **state)
2109 {
2110 TSS2_RC r;
2111 TSS2_TCTI_CONTEXT *tcti;
2112 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2113 Esys_GetTcti(esys_context, &tcti);
2114 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2115
2116 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2117 TPM2B_DIGEST authPolicy = DUMMY_2B_DATA(.buffer);
2118 TPMI_ALG_HASH hashAlg = TPM2_ALG_SHA1;
2119 r = Esys_SetPrimaryPolicy(esys_context,
2120 authHandle_handle,
2121 ESYS_TR_PASSWORD,
2122 ESYS_TR_NONE, ESYS_TR_NONE, &authPolicy, hashAlg);
2123
2124 assert_int_equal(r, TPM2_RC_YIELDED);
2125 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2126 }
2127
2128 static void
test_ChangePPS(void ** state)2129 test_ChangePPS(void **state)
2130 {
2131 TSS2_RC r;
2132 TSS2_TCTI_CONTEXT *tcti;
2133 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2134 Esys_GetTcti(esys_context, &tcti);
2135 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2136
2137 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2138 r = Esys_ChangePPS(esys_context,
2139 authHandle_handle,
2140 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2141
2142 assert_int_equal(r, TPM2_RC_YIELDED);
2143 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2144 }
2145
2146 static void
test_ChangeEPS(void ** state)2147 test_ChangeEPS(void **state)
2148 {
2149 TSS2_RC r;
2150 TSS2_TCTI_CONTEXT *tcti;
2151 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2152 Esys_GetTcti(esys_context, &tcti);
2153 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2154
2155 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2156 r = Esys_ChangeEPS(esys_context,
2157 authHandle_handle,
2158 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2159
2160 assert_int_equal(r, TPM2_RC_YIELDED);
2161 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2162 }
2163
2164 static void
test_Clear(void ** state)2165 test_Clear(void **state)
2166 {
2167 TSS2_RC r;
2168 TSS2_TCTI_CONTEXT *tcti;
2169 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2170 Esys_GetTcti(esys_context, &tcti);
2171 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2172
2173 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2174 r = Esys_Clear(esys_context,
2175 authHandle_handle,
2176 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2177
2178 assert_int_equal(r, TPM2_RC_YIELDED);
2179 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2180 }
2181
2182 static void
test_ClearControl(void ** state)2183 test_ClearControl(void **state)
2184 {
2185 TSS2_RC r;
2186 TSS2_TCTI_CONTEXT *tcti;
2187 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2188 Esys_GetTcti(esys_context, &tcti);
2189 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2190
2191 ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2192 TPMI_YES_NO disable = 0;
2193 r = Esys_ClearControl(esys_context,
2194 auth_handle,
2195 ESYS_TR_PASSWORD,
2196 ESYS_TR_NONE, ESYS_TR_NONE, disable);
2197
2198 assert_int_equal(r, TPM2_RC_YIELDED);
2199 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2200 }
2201
2202 static void
test_HierarchyChangeAuth(void ** state)2203 test_HierarchyChangeAuth(void **state)
2204 {
2205 TSS2_RC r;
2206 TSS2_TCTI_CONTEXT *tcti;
2207 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2208 Esys_GetTcti(esys_context, &tcti);
2209 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2210
2211 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2212 TPM2B_AUTH newAuth = DUMMY_2B_DATA(.buffer);
2213 r = Esys_HierarchyChangeAuth(esys_context,
2214 authHandle_handle,
2215 ESYS_TR_PASSWORD,
2216 ESYS_TR_NONE, ESYS_TR_NONE, &newAuth);
2217
2218 assert_int_equal(r, TPM2_RC_YIELDED);
2219 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2220 }
2221
2222 static void
test_DictionaryAttackLockReset(void ** state)2223 test_DictionaryAttackLockReset(void **state)
2224 {
2225 TSS2_RC r;
2226 TSS2_TCTI_CONTEXT *tcti;
2227 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2228 Esys_GetTcti(esys_context, &tcti);
2229 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2230
2231 ESYS_TR lockHandle_handle = DUMMY_TR_HANDLE_LOCKOUT;;
2232 r = Esys_DictionaryAttackLockReset(esys_context,
2233 lockHandle_handle,
2234 ESYS_TR_PASSWORD,
2235 ESYS_TR_NONE, ESYS_TR_NONE);
2236
2237 assert_int_equal(r, TPM2_RC_YIELDED);
2238 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2239 }
2240
2241 static void
test_DictionaryAttackParameters(void ** state)2242 test_DictionaryAttackParameters(void **state)
2243 {
2244 TSS2_RC r;
2245 TSS2_TCTI_CONTEXT *tcti;
2246 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2247 Esys_GetTcti(esys_context, &tcti);
2248 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2249
2250 ESYS_TR lockHandle_handle = DUMMY_TR_HANDLE_LOCKOUT;
2251 UINT32 newMaxTries = 0;
2252 UINT32 newRecoveryTime = 0;
2253 UINT32 lockoutRecovery = 0;
2254 r = Esys_DictionaryAttackParameters(esys_context,
2255 lockHandle_handle,
2256 ESYS_TR_PASSWORD,
2257 ESYS_TR_NONE,
2258 ESYS_TR_NONE,
2259 newMaxTries,
2260 newRecoveryTime, lockoutRecovery);
2261
2262 assert_int_equal(r, TPM2_RC_YIELDED);
2263 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2264 }
2265
2266 static void
test_PP_Commands(void ** state)2267 test_PP_Commands(void **state)
2268 {
2269 TSS2_RC r;
2270 TSS2_TCTI_CONTEXT *tcti;
2271 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2272 Esys_GetTcti(esys_context, &tcti);
2273 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2274
2275 ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2276 TPML_CC setList = { 0 };
2277 TPML_CC clearList = { 0 };
2278 r = Esys_PP_Commands(esys_context,
2279 auth_handle,
2280 ESYS_TR_PASSWORD,
2281 ESYS_TR_NONE, ESYS_TR_NONE, &setList, &clearList);
2282
2283 assert_int_equal(r, TPM2_RC_YIELDED);
2284 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2285 }
2286
2287 static void
test_SetAlgorithmSet(void ** state)2288 test_SetAlgorithmSet(void **state)
2289 {
2290 TSS2_RC r;
2291 TSS2_TCTI_CONTEXT *tcti;
2292 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2293 Esys_GetTcti(esys_context, &tcti);
2294 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2295
2296 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2297 UINT32 algorithmSet = 0;
2298 r = Esys_SetAlgorithmSet(esys_context,
2299 authHandle_handle,
2300 ESYS_TR_PASSWORD,
2301 ESYS_TR_NONE, ESYS_TR_NONE, algorithmSet);
2302
2303 assert_int_equal(r, TPM2_RC_YIELDED);
2304 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2305 }
2306
2307 static void
test_FieldUpgradeStart(void ** state)2308 test_FieldUpgradeStart(void **state)
2309 {
2310 TSS2_RC r;
2311 TSS2_TCTI_CONTEXT *tcti;
2312 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2313 Esys_GetTcti(esys_context, &tcti);
2314 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2315
2316 ESYS_TR authorization_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;;
2317 ESYS_TR keyHandle_handle = DUMMY_TR_HANDLE_KEY;
2318 TPM2B_DIGEST fuDigest = DUMMY_2B_DATA(.buffer);
2319 TPMT_SIGNATURE manifestSignature = DUMMY_TPMT_SIGNATURE;
2320 r = Esys_FieldUpgradeStart(esys_context,
2321 authorization_handle,
2322 keyHandle_handle,
2323 ESYS_TR_PASSWORD,
2324 ESYS_TR_NONE,
2325 ESYS_TR_NONE, &fuDigest, &manifestSignature);
2326
2327 assert_int_equal(r, TPM2_RC_YIELDED);
2328 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2329 }
2330
2331 static void
test_FieldUpgradeData(void ** state)2332 test_FieldUpgradeData(void **state)
2333 {
2334 TSS2_RC r;
2335 TSS2_TCTI_CONTEXT *tcti;
2336 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2337 Esys_GetTcti(esys_context, &tcti);
2338 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2339
2340 TPM2B_MAX_BUFFER fuData = DUMMY_2B_DATA(.buffer);
2341 TPMT_HA *nextDigest;
2342 TPMT_HA *firstDigest;
2343 r = Esys_FieldUpgradeData(esys_context,
2344 ESYS_TR_NONE,
2345 ESYS_TR_NONE,
2346 ESYS_TR_NONE, &fuData, &nextDigest, &firstDigest);
2347
2348 assert_int_equal(r, TPM2_RC_YIELDED);
2349 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2350 }
2351
2352 static void
test_FirmwareRead(void ** state)2353 test_FirmwareRead(void **state)
2354 {
2355 TSS2_RC r;
2356 TSS2_TCTI_CONTEXT *tcti;
2357 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2358 Esys_GetTcti(esys_context, &tcti);
2359 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2360
2361 UINT32 sequenceNumber = 0;
2362 TPM2B_MAX_BUFFER *fuData;
2363 r = Esys_FirmwareRead(esys_context,
2364 ESYS_TR_NONE,
2365 ESYS_TR_NONE, ESYS_TR_NONE, sequenceNumber, &fuData);
2366
2367 assert_int_equal(r, TPM2_RC_YIELDED);
2368 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2369 }
2370
2371 static void
test_ContextSave(void ** state)2372 test_ContextSave(void **state)
2373 {
2374 TSS2_RC r;
2375 TSS2_TCTI_CONTEXT *tcti;
2376 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2377 Esys_GetTcti(esys_context, &tcti);
2378 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2379
2380 ESYS_TR saveHandle_handle = DUMMY_TR_HANDLE_KEY;
2381 TPMS_CONTEXT *context;
2382 r = Esys_ContextSave(esys_context, saveHandle_handle, &context);
2383
2384 assert_int_equal(r, TPM2_RC_YIELDED);
2385 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2386 }
2387
2388 static void
test_ContextLoad(void ** state)2389 test_ContextLoad(void **state)
2390 {
2391 TSS2_RC r;
2392 TSS2_TCTI_CONTEXT *tcti;
2393 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2394 Esys_GetTcti(esys_context, &tcti);
2395 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2396
2397 TPMS_CONTEXT context = { 0 };
2398 ESYS_TR loadedHandle_handle;
2399
2400 context.contextBlob.size = 0x100;
2401 context.savedHandle = TPM2_TRANSIENT_FIRST;
2402 context.hierarchy = TPM2_RH_OWNER;
2403 r = Esys_ContextLoad(esys_context, &context, &loadedHandle_handle);
2404
2405 assert_int_equal(r, TPM2_RC_YIELDED);
2406 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2407 }
2408
2409 static void
test_FlushContext(void ** state)2410 test_FlushContext(void **state)
2411 {
2412 TSS2_RC r;
2413 TSS2_TCTI_CONTEXT *tcti;
2414 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2415 Esys_GetTcti(esys_context, &tcti);
2416 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2417
2418 ESYS_TR flushHandle_handle = DUMMY_TR_HANDLE_KEY;
2419 r = Esys_FlushContext(esys_context, flushHandle_handle);
2420
2421 assert_int_equal(r, TPM2_RC_YIELDED);
2422 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2423 }
2424
2425 static void
test_EvictControl(void ** state)2426 test_EvictControl(void **state)
2427 {
2428 TSS2_RC r;
2429 TSS2_TCTI_CONTEXT *tcti;
2430 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2431 Esys_GetTcti(esys_context, &tcti);
2432 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2433
2434 ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2435 ESYS_TR objectHandle_handle = DUMMY_TR_HANDLE_KEY;
2436 TPMI_DH_PERSISTENT persistentHandle = TPM2_PERSISTENT_FIRST;
2437 ESYS_TR newObjectHandle_handle;
2438 r = Esys_EvictControl(esys_context,
2439 auth_handle,
2440 objectHandle_handle,
2441 ESYS_TR_PASSWORD,
2442 ESYS_TR_NONE,
2443 ESYS_TR_NONE,
2444 persistentHandle, &newObjectHandle_handle);
2445
2446 assert_int_equal(r, TPM2_RC_YIELDED);
2447 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2448 }
2449
2450 static void
test_ReadClock(void ** state)2451 test_ReadClock(void **state)
2452 {
2453 TSS2_RC r;
2454 TSS2_TCTI_CONTEXT *tcti;
2455 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2456 Esys_GetTcti(esys_context, &tcti);
2457 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2458
2459 TPMS_TIME_INFO *currentTime;
2460 r = Esys_ReadClock(esys_context,
2461 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, ¤tTime);
2462
2463 assert_int_equal(r, TPM2_RC_YIELDED);
2464 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2465 }
2466
2467 static void
test_ClockSet(void ** state)2468 test_ClockSet(void **state)
2469 {
2470 TSS2_RC r;
2471 TSS2_TCTI_CONTEXT *tcti;
2472 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2473 Esys_GetTcti(esys_context, &tcti);
2474 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2475
2476 ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2477 UINT64 newTime = 0;
2478 r = Esys_ClockSet(esys_context,
2479 auth_handle,
2480 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, newTime);
2481
2482 assert_int_equal(r, TPM2_RC_YIELDED);
2483 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2484 }
2485
2486 static void
test_ClockRateAdjust(void ** state)2487 test_ClockRateAdjust(void **state)
2488 {
2489 TSS2_RC r;
2490 TSS2_TCTI_CONTEXT *tcti;
2491 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2492 Esys_GetTcti(esys_context, &tcti);
2493 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2494
2495 ESYS_TR auth_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2496 TPM2_CLOCK_ADJUST rateAdjust = 0;
2497 r = Esys_ClockRateAdjust(esys_context,
2498 auth_handle,
2499 ESYS_TR_PASSWORD,
2500 ESYS_TR_NONE, ESYS_TR_NONE, rateAdjust);
2501
2502 assert_int_equal(r, TPM2_RC_YIELDED);
2503 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2504 }
2505
2506 static void
test_GetCapability(void ** state)2507 test_GetCapability(void **state)
2508 {
2509 TSS2_RC r;
2510 TSS2_TCTI_CONTEXT *tcti;
2511 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2512 Esys_GetTcti(esys_context, &tcti);
2513 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2514
2515 TPM2_CAP capability = 0;
2516 UINT32 property = 0;
2517 UINT32 propertyCount = 0;
2518 TPMS_CAPABILITY_DATA *capabilityData;
2519 TPMI_YES_NO moreData;
2520 r = Esys_GetCapability(esys_context,
2521 ESYS_TR_NONE,
2522 ESYS_TR_NONE,
2523 ESYS_TR_NONE,
2524 capability,
2525 property, propertyCount, &moreData, &capabilityData);
2526
2527 assert_int_equal(r, TPM2_RC_YIELDED);
2528 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2529 }
2530
2531 static void
test_TestParms(void ** state)2532 test_TestParms(void **state)
2533 {
2534 TSS2_RC r;
2535 TSS2_TCTI_CONTEXT *tcti;
2536 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2537 Esys_GetTcti(esys_context, &tcti);
2538 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2539
2540 TPMT_PUBLIC_PARMS parameters = DUMMY_TPMT_PUBLIC_PARAMS;
2541 r = Esys_TestParms(esys_context,
2542 ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, ¶meters);
2543
2544 assert_int_equal(r, TPM2_RC_YIELDED);
2545 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2546 }
2547
2548 static void
test_NV_DefineSpace(void ** state)2549 test_NV_DefineSpace(void **state)
2550 {
2551 TSS2_RC r;
2552 TSS2_TCTI_CONTEXT *tcti;
2553 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2554 Esys_GetTcti(esys_context, &tcti);
2555 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2556
2557 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2558 TPM2B_AUTH auth = DUMMY_2B_DATA(.buffer);
2559 TPM2B_NV_PUBLIC publicInfo = {
2560 .size = 0,
2561 .nvPublic = {
2562 .nvIndex = TPM2_NV_INDEX_FIRST,
2563 .nameAlg = TPM2_ALG_SHA1,
2564 .attributes = (TPMA_NV_PPWRITE |
2565 TPMA_NV_AUTHWRITE |
2566 1 << TPMA_NV_TPM2_NT_SHIFT |
2567 TPMA_NV_WRITE_STCLEAR |
2568 TPMA_NV_PPREAD |
2569 TPMA_NV_AUTHREAD | TPMA_NV_PLATFORMCREATE),
2570 .authPolicy = {
2571 .size = 0,
2572 .buffer = {},
2573 },
2574 .dataSize = 32,
2575 }
2576 };
2577 ESYS_TR nvHandle_handle;
2578 r = Esys_NV_DefineSpace(esys_context,
2579 authHandle_handle,
2580 ESYS_TR_PASSWORD,
2581 ESYS_TR_NONE,
2582 ESYS_TR_NONE, &auth, &publicInfo, &nvHandle_handle);
2583
2584 assert_int_equal(r, TPM2_RC_YIELDED);
2585 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2586 }
2587
2588 static void
test_NV_UndefineSpace(void ** state)2589 test_NV_UndefineSpace(void **state)
2590 {
2591 TSS2_RC r;
2592 TSS2_TCTI_CONTEXT *tcti;
2593 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2594 Esys_GetTcti(esys_context, &tcti);
2595 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2596
2597 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2598 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2599 r = Esys_NV_UndefineSpace(esys_context,
2600 authHandle_handle,
2601 nvIndex_handle,
2602 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2603
2604 assert_int_equal(r, TPM2_RC_YIELDED);
2605 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2606 }
2607
2608 static void
test_NV_UndefineSpaceSpecial(void ** state)2609 test_NV_UndefineSpaceSpecial(void **state)
2610 {
2611 TSS2_RC r;
2612 TSS2_TCTI_CONTEXT *tcti;
2613 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2614 Esys_GetTcti(esys_context, &tcti);
2615 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2616
2617 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2618 ESYS_TR platform_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2619 r = Esys_NV_UndefineSpaceSpecial(esys_context,
2620 nvIndex_handle,
2621 platform_handle,
2622 ESYS_TR_PASSWORD,
2623 ESYS_TR_PASSWORD, ESYS_TR_NONE);
2624
2625 assert_int_equal(r, TPM2_RC_YIELDED);
2626 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2627 }
2628
2629 static void
test_NV_ReadPublic(void ** state)2630 test_NV_ReadPublic(void **state)
2631 {
2632 TSS2_RC r;
2633 TSS2_TCTI_CONTEXT *tcti;
2634 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2635 Esys_GetTcti(esys_context, &tcti);
2636 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2637
2638 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2639 TPM2B_NV_PUBLIC *nvPublic;
2640 TPM2B_NAME *nvName;
2641 r = Esys_NV_ReadPublic(esys_context,
2642 nvIndex_handle,
2643 ESYS_TR_NONE,
2644 ESYS_TR_NONE, ESYS_TR_NONE, &nvPublic, &nvName);
2645
2646 assert_int_equal(r, TPM2_RC_YIELDED);
2647 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2648 }
2649
2650 static void
test_NV_Write(void ** state)2651 test_NV_Write(void **state)
2652 {
2653 TSS2_RC r;
2654 TSS2_TCTI_CONTEXT *tcti;
2655 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2656 Esys_GetTcti(esys_context, &tcti);
2657 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2658
2659 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2660 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2661 TPM2B_MAX_NV_BUFFER data = DUMMY_2B_DATA(.buffer);
2662 UINT16 offset = 0;
2663 r = Esys_NV_Write(esys_context,
2664 authHandle_handle,
2665 nvIndex_handle,
2666 ESYS_TR_PASSWORD,
2667 ESYS_TR_NONE, ESYS_TR_NONE, &data, offset);
2668
2669 assert_int_equal(r, TPM2_RC_YIELDED);
2670 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2671 }
2672
2673 static void
test_NV_Increment(void ** state)2674 test_NV_Increment(void **state)
2675 {
2676 TSS2_RC r;
2677 TSS2_TCTI_CONTEXT *tcti;
2678 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2679 Esys_GetTcti(esys_context, &tcti);
2680 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2681
2682 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2683 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2684 r = Esys_NV_Increment(esys_context,
2685 authHandle_handle,
2686 nvIndex_handle,
2687 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2688
2689 assert_int_equal(r, TPM2_RC_YIELDED);
2690 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2691 }
2692
2693 static void
test_NV_Extend(void ** state)2694 test_NV_Extend(void **state)
2695 {
2696 TSS2_RC r;
2697 TSS2_TCTI_CONTEXT *tcti;
2698 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2699 Esys_GetTcti(esys_context, &tcti);
2700 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2701
2702 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2703 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2704 TPM2B_MAX_NV_BUFFER data = DUMMY_2B_DATA(.buffer);
2705 r = Esys_NV_Extend(esys_context,
2706 authHandle_handle,
2707 nvIndex_handle,
2708 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, &data);
2709
2710 assert_int_equal(r, TPM2_RC_YIELDED);
2711 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2712 }
2713
2714 static void
test_NV_SetBits(void ** state)2715 test_NV_SetBits(void **state)
2716 {
2717 TSS2_RC r;
2718 TSS2_TCTI_CONTEXT *tcti;
2719 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2720 Esys_GetTcti(esys_context, &tcti);
2721 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2722
2723 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2724 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2725 UINT64 bits = 0;
2726 r = Esys_NV_SetBits(esys_context,
2727 authHandle_handle,
2728 nvIndex_handle,
2729 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE, bits);
2730
2731 assert_int_equal(r, TPM2_RC_YIELDED);
2732 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2733 }
2734
2735 static void
test_NV_WriteLock(void ** state)2736 test_NV_WriteLock(void **state)
2737 {
2738 TSS2_RC r;
2739 TSS2_TCTI_CONTEXT *tcti;
2740 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2741 Esys_GetTcti(esys_context, &tcti);
2742 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2743
2744 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2745 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2746 r = Esys_NV_WriteLock(esys_context,
2747 authHandle_handle,
2748 nvIndex_handle,
2749 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2750
2751 assert_int_equal(r, TPM2_RC_YIELDED);
2752 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2753 }
2754
2755 static void
test_NV_GlobalWriteLock(void ** state)2756 test_NV_GlobalWriteLock(void **state)
2757 {
2758 TSS2_RC r;
2759 TSS2_TCTI_CONTEXT *tcti;
2760 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2761 Esys_GetTcti(esys_context, &tcti);
2762 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2763
2764 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2765 r = Esys_NV_GlobalWriteLock(esys_context,
2766 authHandle_handle,
2767 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2768
2769 assert_int_equal(r, TPM2_RC_YIELDED);
2770 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2771 }
2772
2773 static void
test_NV_Read(void ** state)2774 test_NV_Read(void **state)
2775 {
2776 TSS2_RC r;
2777 TSS2_TCTI_CONTEXT *tcti;
2778 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2779 Esys_GetTcti(esys_context, &tcti);
2780 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2781
2782 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2783 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2784 UINT16 size = 0;
2785 UINT16 offset = 0;
2786 TPM2B_MAX_NV_BUFFER *data;
2787 r = Esys_NV_Read(esys_context,
2788 authHandle_handle,
2789 nvIndex_handle,
2790 ESYS_TR_PASSWORD,
2791 ESYS_TR_NONE, ESYS_TR_NONE, size, offset, &data);
2792
2793 assert_int_equal(r, TPM2_RC_YIELDED);
2794 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2795 }
2796
2797 static void
test_NV_ReadLock(void ** state)2798 test_NV_ReadLock(void **state)
2799 {
2800 TSS2_RC r;
2801 TSS2_TCTI_CONTEXT *tcti;
2802 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2803 Esys_GetTcti(esys_context, &tcti);
2804 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2805
2806 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2807 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2808 r = Esys_NV_ReadLock(esys_context,
2809 authHandle_handle,
2810 nvIndex_handle,
2811 ESYS_TR_PASSWORD, ESYS_TR_NONE, ESYS_TR_NONE);
2812
2813 assert_int_equal(r, TPM2_RC_YIELDED);
2814 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2815 }
2816
2817 static void
test_NV_ChangeAuth(void ** state)2818 test_NV_ChangeAuth(void **state)
2819 {
2820 TSS2_RC r;
2821 TSS2_TCTI_CONTEXT *tcti;
2822 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2823 Esys_GetTcti(esys_context, &tcti);
2824 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2825
2826 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2827 TPM2B_AUTH newAuth = DUMMY_2B_DATA(.buffer);
2828 r = Esys_NV_ChangeAuth(esys_context,
2829 nvIndex_handle,
2830 ESYS_TR_PASSWORD,
2831 ESYS_TR_NONE, ESYS_TR_NONE, &newAuth);
2832
2833 assert_int_equal(r, TPM2_RC_YIELDED);
2834 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2835 }
2836
2837 static void
test_NV_Certify(void ** state)2838 test_NV_Certify(void **state)
2839 {
2840 TSS2_RC r;
2841 TSS2_TCTI_CONTEXT *tcti;
2842 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2843 Esys_GetTcti(esys_context, &tcti);
2844 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2845
2846 ESYS_TR signHandle_handle = DUMMY_TR_HANDLE_KEY;
2847 ESYS_TR authHandle_handle = DUMMY_TR_HANDLE_HIERARCHY_PLATFORM;
2848 ESYS_TR nvIndex_handle = DUMMY_TR_HANDLE_NV_INDEX;
2849 TPM2B_DATA qualifyingData = DUMMY_2B_DATA(.buffer);
2850 TPMT_SIG_SCHEME inScheme = {.scheme = TPM2_ALG_NULL,.details = {} };
2851 UINT16 size = 0;
2852 UINT16 offset = 0;
2853 TPM2B_ATTEST *certifyInfo;
2854 TPMT_SIGNATURE *signature;
2855 r = Esys_NV_Certify(esys_context,
2856 signHandle_handle,
2857 authHandle_handle,
2858 nvIndex_handle,
2859 ESYS_TR_PASSWORD,
2860 ESYS_TR_PASSWORD,
2861 ESYS_TR_NONE,
2862 &qualifyingData,
2863 &inScheme, size, offset, &certifyInfo, &signature);
2864
2865 assert_int_equal(r, TPM2_RC_YIELDED);
2866 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2867 }
2868
2869 static void
test_Vendor_TCG_Test(void ** state)2870 test_Vendor_TCG_Test(void **state)
2871 {
2872 TSS2_RC r;
2873 TSS2_TCTI_CONTEXT *tcti;
2874 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2875 Esys_GetTcti(esys_context, &tcti);
2876 TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
2877
2878 TPM2B_DATA inputData = DUMMY_2B_DATA(.buffer);
2879 TPM2B_DATA *outputData;
2880 r = Esys_Vendor_TCG_Test(esys_context,
2881 ESYS_TR_NONE,
2882 ESYS_TR_NONE,
2883 ESYS_TR_NONE, &inputData, &outputData);
2884
2885 assert_int_equal(r, TPM2_RC_YIELDED);
2886 assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
2887 }
2888
2889 int
main(int argc,char * argv[])2890 main(int argc, char *argv[])
2891 {
2892 const struct CMUnitTest tests[] = {
2893 cmocka_unit_test_setup_teardown(test_Startup, setup, teardown),
2894 cmocka_unit_test_setup_teardown(test_Shutdown, setup, teardown),
2895 cmocka_unit_test_setup_teardown(test_SelfTest, setup, teardown),
2896 cmocka_unit_test_setup_teardown(test_IncrementalSelfTest, setup,
2897 teardown),
2898 cmocka_unit_test_setup_teardown(test_GetTestResult, setup, teardown),
2899 cmocka_unit_test_setup_teardown(test_StartAuthSession, setup, teardown),
2900 cmocka_unit_test_setup_teardown(test_PolicyRestart, setup, teardown),
2901 cmocka_unit_test_setup_teardown(test_Create, setup, teardown),
2902 cmocka_unit_test_setup_teardown(test_Load, setup, teardown),
2903 cmocka_unit_test_setup_teardown(test_LoadExternal, setup, teardown),
2904 cmocka_unit_test_setup_teardown(test_ReadPublic, setup, teardown),
2905 cmocka_unit_test_setup_teardown(test_ActivateCredential, setup,
2906 teardown),
2907 cmocka_unit_test_setup_teardown(test_MakeCredential, setup, teardown),
2908 cmocka_unit_test_setup_teardown(test_Unseal, setup, teardown),
2909 cmocka_unit_test_setup_teardown(test_ObjectChangeAuth, setup, teardown),
2910 cmocka_unit_test_setup_teardown(test_Duplicate, setup, teardown),
2911 cmocka_unit_test_setup_teardown(test_Rewrap, setup, teardown),
2912 cmocka_unit_test_setup_teardown(test_Import, setup, teardown),
2913 cmocka_unit_test_setup_teardown(test_RSA_Encrypt, setup, teardown),
2914 cmocka_unit_test_setup_teardown(test_RSA_Decrypt, setup, teardown),
2915 cmocka_unit_test_setup_teardown(test_ECDH_KeyGen, setup, teardown),
2916 cmocka_unit_test_setup_teardown(test_ECDH_ZGen, setup, teardown),
2917 cmocka_unit_test_setup_teardown(test_ECC_Parameters, setup, teardown),
2918 cmocka_unit_test_setup_teardown(test_ZGen_2Phase, setup, teardown),
2919 cmocka_unit_test_setup_teardown(test_EncryptDecrypt, setup, teardown),
2920 cmocka_unit_test_setup_teardown(test_EncryptDecrypt2, setup, teardown),
2921 cmocka_unit_test_setup_teardown(test_Hash, setup, teardown),
2922 cmocka_unit_test_setup_teardown(test_HMAC, setup, teardown),
2923 cmocka_unit_test_setup_teardown(test_GetRandom, setup, teardown),
2924 cmocka_unit_test_setup_teardown(test_StirRandom, setup, teardown),
2925 cmocka_unit_test_setup_teardown(test_HMAC_Start, setup, teardown),
2926 cmocka_unit_test_setup_teardown(test_HashSequenceStart, setup,
2927 teardown),
2928 cmocka_unit_test_setup_teardown(test_SequenceUpdate, setup, teardown),
2929 cmocka_unit_test_setup_teardown(test_SequenceComplete, setup, teardown),
2930 cmocka_unit_test_setup_teardown(test_EventSequenceComplete, setup,
2931 teardown),
2932 cmocka_unit_test_setup_teardown(test_Certify, setup, teardown),
2933 cmocka_unit_test_setup_teardown(test_CertifyCreation, setup, teardown),
2934 cmocka_unit_test_setup_teardown(test_Quote, setup, teardown),
2935 cmocka_unit_test_setup_teardown(test_GetSessionAuditDigest, setup,
2936 teardown),
2937 cmocka_unit_test_setup_teardown(test_GetCommandAuditDigest, setup,
2938 teardown),
2939 cmocka_unit_test_setup_teardown(test_GetTime, setup, teardown),
2940 cmocka_unit_test_setup_teardown(test_Commit, setup, teardown),
2941 cmocka_unit_test_setup_teardown(test_EC_Ephemeral, setup, teardown),
2942 cmocka_unit_test_setup_teardown(test_VerifySignature, setup, teardown),
2943 cmocka_unit_test_setup_teardown(test_Sign, setup, teardown),
2944 cmocka_unit_test_setup_teardown(test_SetCommandCodeAuditStatus, setup,
2945 teardown),
2946 cmocka_unit_test_setup_teardown(test_PCR_Extend, setup, teardown),
2947 cmocka_unit_test_setup_teardown(test_PCR_Event, setup, teardown),
2948 cmocka_unit_test_setup_teardown(test_PCR_Read, setup, teardown),
2949 cmocka_unit_test_setup_teardown(test_PCR_Allocate, setup, teardown),
2950 cmocka_unit_test_setup_teardown(test_PCR_SetAuthPolicy, setup,
2951 teardown),
2952 cmocka_unit_test_setup_teardown(test_PCR_SetAuthValue, setup, teardown),
2953 cmocka_unit_test_setup_teardown(test_PCR_Reset, setup, teardown),
2954 cmocka_unit_test_setup_teardown(test_PolicySigned, setup, teardown),
2955 cmocka_unit_test_setup_teardown(test_PolicySecret, setup, teardown),
2956 cmocka_unit_test_setup_teardown(test_PolicyTicket, setup, teardown),
2957 cmocka_unit_test_setup_teardown(test_PolicyOR, setup, teardown),
2958 cmocka_unit_test_setup_teardown(test_PolicyPCR, setup, teardown),
2959 cmocka_unit_test_setup_teardown(test_PolicyLocality, setup, teardown),
2960 cmocka_unit_test_setup_teardown(test_PolicyNV, setup, teardown),
2961 cmocka_unit_test_setup_teardown(test_PolicyCounterTimer, setup,
2962 teardown),
2963 cmocka_unit_test_setup_teardown(test_PolicyCommandCode, setup,
2964 teardown),
2965 cmocka_unit_test_setup_teardown(test_PolicyPhysicalPresence, setup,
2966 teardown),
2967 cmocka_unit_test_setup_teardown(test_PolicyCpHash, setup, teardown),
2968 cmocka_unit_test_setup_teardown(test_PolicyNameHash, setup, teardown),
2969 cmocka_unit_test_setup_teardown(test_PolicyDuplicationSelect, setup,
2970 teardown),
2971 cmocka_unit_test_setup_teardown(test_PolicyAuthorize, setup, teardown),
2972 cmocka_unit_test_setup_teardown(test_PolicyAuthValue, setup, teardown),
2973 cmocka_unit_test_setup_teardown(test_PolicyPassword, setup, teardown),
2974 cmocka_unit_test_setup_teardown(test_PolicyGetDigest, setup, teardown),
2975 cmocka_unit_test_setup_teardown(test_PolicyNvWritten, setup, teardown),
2976 cmocka_unit_test_setup_teardown(test_PolicyTemplate, setup, teardown),
2977 cmocka_unit_test_setup_teardown(test_PolicyAuthorizeNV, setup,
2978 teardown),
2979 cmocka_unit_test_setup_teardown(test_CreatePrimary, setup, teardown),
2980 cmocka_unit_test_setup_teardown(test_HierarchyControl, setup, teardown),
2981 cmocka_unit_test_setup_teardown(test_SetPrimaryPolicy, setup, teardown),
2982 cmocka_unit_test_setup_teardown(test_ChangePPS, setup, teardown),
2983 cmocka_unit_test_setup_teardown(test_ChangeEPS, setup, teardown),
2984 cmocka_unit_test_setup_teardown(test_Clear, setup, teardown),
2985 cmocka_unit_test_setup_teardown(test_ClearControl, setup, teardown),
2986 cmocka_unit_test_setup_teardown(test_HierarchyChangeAuth, setup,
2987 teardown),
2988 cmocka_unit_test_setup_teardown(test_DictionaryAttackLockReset, setup,
2989 teardown),
2990 cmocka_unit_test_setup_teardown(test_DictionaryAttackParameters, setup,
2991 teardown),
2992 cmocka_unit_test_setup_teardown(test_PP_Commands, setup, teardown),
2993 cmocka_unit_test_setup_teardown(test_SetAlgorithmSet, setup, teardown),
2994 cmocka_unit_test_setup_teardown(test_FieldUpgradeStart, setup,
2995 teardown),
2996 cmocka_unit_test_setup_teardown(test_FieldUpgradeData, setup, teardown),
2997 cmocka_unit_test_setup_teardown(test_FirmwareRead, setup, teardown),
2998 cmocka_unit_test_setup_teardown(test_ContextSave, setup, teardown),
2999 cmocka_unit_test_setup_teardown(test_ContextLoad, setup, teardown),
3000 cmocka_unit_test_setup_teardown(test_FlushContext, setup, teardown),
3001 cmocka_unit_test_setup_teardown(test_EvictControl, setup, teardown),
3002 cmocka_unit_test_setup_teardown(test_ReadClock, setup, teardown),
3003 cmocka_unit_test_setup_teardown(test_ClockSet, setup, teardown),
3004 cmocka_unit_test_setup_teardown(test_ClockRateAdjust, setup, teardown),
3005 cmocka_unit_test_setup_teardown(test_GetCapability, setup, teardown),
3006 cmocka_unit_test_setup_teardown(test_TestParms, setup, teardown),
3007 cmocka_unit_test_setup_teardown(test_NV_DefineSpace, setup, teardown),
3008 cmocka_unit_test_setup_teardown(test_NV_UndefineSpace, setup, teardown),
3009 cmocka_unit_test_setup_teardown(test_NV_UndefineSpaceSpecial, setup,
3010 teardown),
3011 cmocka_unit_test_setup_teardown(test_NV_ReadPublic, setup, teardown),
3012 cmocka_unit_test_setup_teardown(test_NV_Write, setup, teardown),
3013 cmocka_unit_test_setup_teardown(test_NV_Increment, setup, teardown),
3014 cmocka_unit_test_setup_teardown(test_NV_Extend, setup, teardown),
3015 cmocka_unit_test_setup_teardown(test_NV_SetBits, setup, teardown),
3016 cmocka_unit_test_setup_teardown(test_NV_WriteLock, setup, teardown),
3017 cmocka_unit_test_setup_teardown(test_NV_GlobalWriteLock, setup,
3018 teardown),
3019 cmocka_unit_test_setup_teardown(test_NV_Read, setup, teardown),
3020 cmocka_unit_test_setup_teardown(test_NV_ReadLock, setup, teardown),
3021 cmocka_unit_test_setup_teardown(test_NV_ChangeAuth, setup, teardown),
3022 cmocka_unit_test_setup_teardown(test_NV_Certify, setup, teardown),
3023 cmocka_unit_test_setup_teardown(test_Vendor_TCG_Test, setup, teardown),
3024 };
3025 return cmocka_run_group_tests(tests, NULL, NULL);
3026 }
3027