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