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