1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*******************************************************************************
3 * Copyright 2017-2018, Fraunhofer SIT sponsored by Infineon Technologies AG
4 * All rights reserved.
5 *******************************************************************************/
6
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #include <stdarg.h>
12 #include <stdlib.h>
13 #include <inttypes.h>
14 #include <string.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 * Tests whether all ESAPI finish calls handle wrong internal states with the correct
28 * error response TSS2_ESYS_RC_BAD_SEQUENCE.
29 */
30
31 static TSS2_RC
tcti_failure_transmit(TSS2_TCTI_CONTEXT * tctiContext,size_t size,const uint8_t * buffer)32 tcti_failure_transmit(TSS2_TCTI_CONTEXT * tctiContext,
33 size_t size, const uint8_t * buffer)
34 {
35 UNUSED(tctiContext);
36 UNUSED(size);
37 UNUSED(buffer);
38
39 return TSS2_RC_SUCCESS;
40 }
41
42 const uint8_t failure_response[] = {
43 0x80, 0x01, /* TPM_ST_NO_SESSION */
44 0x00, 0x00, 0x00, 0x0A, /* Response Size 10 */
45 0x00, 0x00, 0x01, 0x01 /* TPM_RC_FAILURE */
46 };
47
48 static TSS2_RC
tcti_failure_receive(TSS2_TCTI_CONTEXT * tctiContext,size_t * response_size,uint8_t * response_buffer,int32_t timeout)49 tcti_failure_receive(TSS2_TCTI_CONTEXT * tctiContext,
50 size_t * response_size,
51 uint8_t * response_buffer, int32_t timeout)
52 {
53 *response_size = sizeof(failure_response);
54 if (response_buffer != NULL)
55 memcpy(response_buffer, &failure_response[0], sizeof(failure_response));
56
57 return TSS2_RC_SUCCESS;
58 }
59
60 /**
61 * Prepare ESAPI context with a reference to SAPI and TCTI context.
62 */
63 static int
esys_unit_setup(void ** state)64 esys_unit_setup(void **state)
65 {
66 TSS2_RC r;
67 ESYS_CONTEXT *esys_context;
68
69 /* This is a fake tcti context */
70 TSS2_TCTI_CONTEXT_COMMON_V1 *tcti =
71 calloc(1, sizeof(TSS2_TCTI_CONTEXT_COMMON_V1));
72 tcti->version = 1;
73 TSS2_TCTI_TRANSMIT (tcti) = tcti_failure_transmit;
74 TSS2_TCTI_RECEIVE (tcti) = tcti_failure_receive;
75
76 r = Esys_Initialize(&esys_context, (TSS2_TCTI_CONTEXT *) tcti, NULL);
77 assert_int_equal(r, TSS2_RC_SUCCESS);
78 *state = (void *)esys_context;
79 return 0;
80 }
81
82 /**
83 * Free ESAPI, SAPI and TCTI context.
84 */
85 static int
esys_unit_teardown(void ** state)86 esys_unit_teardown(void **state)
87 {
88 TSS2_RC r;
89 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
90 TSS2_TCTI_CONTEXT *tcti;
91 r = Esys_GetTcti(esys_context, &tcti);
92 assert_int_equal(r, TSS2_RC_SUCCESS);
93 Esys_Finalize(&esys_context);
94 free(tcti);
95 return 0;
96 }
97
98 void
check_Startup(void ** state)99 check_Startup(void **state)
100 {
101 TSS2_RC r;
102 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
103 enum _ESYS_STATE esys_states[3] = {
104 _ESYS_STATE_INIT,
105 _ESYS_STATE_INTERNALERROR
106 };
107 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
108 esys_context->state = esys_states[i];
109 r = Esys_Startup_Finish(esys_context);
110 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
111 }
112 }
113
114 void
check_Shutdown(void ** state)115 check_Shutdown(void **state)
116 {
117 TSS2_RC r;
118 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
119 enum _ESYS_STATE esys_states[3] = {
120 _ESYS_STATE_INIT,
121 _ESYS_STATE_INTERNALERROR
122 };
123 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
124 esys_context->state = esys_states[i];
125 r = Esys_Shutdown_Finish(esys_context);
126 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
127 }
128 }
129
130 void
check_SelfTest(void ** state)131 check_SelfTest(void **state)
132 {
133 TSS2_RC r;
134 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
135 enum _ESYS_STATE esys_states[3] = {
136 _ESYS_STATE_INIT,
137 _ESYS_STATE_INTERNALERROR
138 };
139 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
140 esys_context->state = esys_states[i];
141 r = Esys_SelfTest_Finish(esys_context);
142 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
143 }
144 }
145
146 void
check_IncrementalSelfTest(void ** state)147 check_IncrementalSelfTest(void **state)
148 {
149 TSS2_RC r;
150 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
151 enum _ESYS_STATE esys_states[3] = {
152 _ESYS_STATE_INIT,
153 _ESYS_STATE_INTERNALERROR
154 };
155 TPML_ALG *toDoList;
156 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
157 esys_context->state = esys_states[i];
158 r = Esys_IncrementalSelfTest_Finish(esys_context, &toDoList);
159 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
160 }
161 }
162
163 void
check_GetTestResult(void ** state)164 check_GetTestResult(void **state)
165 {
166 TSS2_RC r;
167 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
168 enum _ESYS_STATE esys_states[3] = {
169 _ESYS_STATE_INIT,
170 _ESYS_STATE_INTERNALERROR
171 };
172 TPM2B_MAX_BUFFER *outData;
173 TPM2_RC testResult;
174 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
175 esys_context->state = esys_states[i];
176 r = Esys_GetTestResult_Finish(esys_context, &outData, &testResult);
177 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
178 }
179 }
180
181 void
check_StartAuthSession(void ** state)182 check_StartAuthSession(void **state)
183 {
184 TSS2_RC r;
185 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
186 enum _ESYS_STATE esys_states[3] = {
187 _ESYS_STATE_INIT,
188 _ESYS_STATE_INTERNALERROR
189 };
190 ESYS_TR sessionHandle_handle;
191 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
192 esys_context->state = esys_states[i];
193 r = Esys_StartAuthSession_Finish(esys_context,
194 &sessionHandle_handle);
195 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
196 }
197 }
198
199 void
check_PolicyRestart(void ** state)200 check_PolicyRestart(void **state)
201 {
202 TSS2_RC r;
203 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
204 enum _ESYS_STATE esys_states[3] = {
205 _ESYS_STATE_INIT,
206 _ESYS_STATE_INTERNALERROR
207 };
208 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
209 esys_context->state = esys_states[i];
210 r = Esys_PolicyRestart_Finish(esys_context);
211 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
212 }
213 }
214
215 void
check_Create(void ** state)216 check_Create(void **state)
217 {
218 TSS2_RC r;
219 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
220 enum _ESYS_STATE esys_states[3] = {
221 _ESYS_STATE_INIT,
222 _ESYS_STATE_INTERNALERROR
223 };
224 TPM2B_PRIVATE *outPrivate;
225 TPM2B_PUBLIC *outPublic;
226 TPM2B_CREATION_DATA *creationData;
227 TPM2B_DIGEST *creationHash;
228 TPMT_TK_CREATION *creationTicket;
229 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
230 esys_context->state = esys_states[i];
231 r = Esys_Create_Finish(esys_context,
232 &outPrivate,
233 &outPublic,
234 &creationData, &creationHash, &creationTicket);
235 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
236 }
237 }
238
239 void
check_Load(void ** state)240 check_Load(void **state)
241 {
242 TSS2_RC r;
243 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
244 enum _ESYS_STATE esys_states[3] = {
245 _ESYS_STATE_INIT,
246 _ESYS_STATE_INTERNALERROR
247 };
248 ESYS_TR objectHandle_handle;
249 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
250 esys_context->state = esys_states[i];
251 r = Esys_Load_Finish(esys_context, &objectHandle_handle);
252 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
253 }
254 }
255
256 void
check_LoadExternal(void ** state)257 check_LoadExternal(void **state)
258 {
259 TSS2_RC r;
260 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
261 enum _ESYS_STATE esys_states[3] = {
262 _ESYS_STATE_INIT,
263 _ESYS_STATE_INTERNALERROR
264 };
265 ESYS_TR objectHandle_handle;
266 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
267 esys_context->state = esys_states[i];
268 r = Esys_LoadExternal_Finish(esys_context, &objectHandle_handle);
269 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
270 }
271 }
272
273 void
check_ReadPublic(void ** state)274 check_ReadPublic(void **state)
275 {
276 TSS2_RC r;
277 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
278 enum _ESYS_STATE esys_states[3] = {
279 _ESYS_STATE_INIT,
280 _ESYS_STATE_INTERNALERROR
281 };
282 TPM2B_PUBLIC *outPublic;
283 TPM2B_NAME *name;
284 TPM2B_NAME *qualifiedName;
285 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
286 esys_context->state = esys_states[i];
287 r = Esys_ReadPublic_Finish(esys_context,
288 &outPublic, &name, &qualifiedName);
289 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
290 }
291 }
292
293 void
check_ActivateCredential(void ** state)294 check_ActivateCredential(void **state)
295 {
296 TSS2_RC r;
297 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
298 enum _ESYS_STATE esys_states[3] = {
299 _ESYS_STATE_INIT,
300 _ESYS_STATE_INTERNALERROR
301 };
302 TPM2B_DIGEST *certInfo;
303 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
304 esys_context->state = esys_states[i];
305 r = Esys_ActivateCredential_Finish(esys_context, &certInfo);
306 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
307 }
308 }
309
310 void
check_MakeCredential(void ** state)311 check_MakeCredential(void **state)
312 {
313 TSS2_RC r;
314 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
315 enum _ESYS_STATE esys_states[3] = {
316 _ESYS_STATE_INIT,
317 _ESYS_STATE_INTERNALERROR
318 };
319 TPM2B_ID_OBJECT *credentialBlob;
320 TPM2B_ENCRYPTED_SECRET *secret;
321 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
322 esys_context->state = esys_states[i];
323 r = Esys_MakeCredential_Finish(esys_context, &credentialBlob, &secret);
324 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
325 }
326 }
327
328 void
check_Unseal(void ** state)329 check_Unseal(void **state)
330 {
331 TSS2_RC r;
332 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
333 enum _ESYS_STATE esys_states[3] = {
334 _ESYS_STATE_INIT,
335 _ESYS_STATE_INTERNALERROR
336 };
337 TPM2B_SENSITIVE_DATA *outData;
338 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
339 esys_context->state = esys_states[i];
340 r = Esys_Unseal_Finish(esys_context, &outData);
341 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
342 }
343 }
344
345 void
check_ObjectChangeAuth(void ** state)346 check_ObjectChangeAuth(void **state)
347 {
348 TSS2_RC r;
349 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
350 enum _ESYS_STATE esys_states[3] = {
351 _ESYS_STATE_INIT,
352 _ESYS_STATE_INTERNALERROR
353 };
354 TPM2B_PRIVATE *outPrivate;
355 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
356 esys_context->state = esys_states[i];
357 r = Esys_ObjectChangeAuth_Finish(esys_context, &outPrivate);
358 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
359 }
360 }
361
362 void
check_CreateLoaded(void ** state)363 check_CreateLoaded(void **state)
364 {
365 TSS2_RC r;
366 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
367 enum _ESYS_STATE esys_states[3] = {
368 _ESYS_STATE_INIT,
369 _ESYS_STATE_INTERNALERROR
370 };
371 ESYS_TR objectHandle_handle;
372 TPM2B_PRIVATE *outPrivate;
373 TPM2B_PUBLIC *outPublic;
374 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
375 esys_context->state = esys_states[i];
376 r = Esys_CreateLoaded_Finish(esys_context,
377 &objectHandle_handle,
378 &outPrivate, &outPublic);
379 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
380 }
381 }
382
383 void
check_Duplicate(void ** state)384 check_Duplicate(void **state)
385 {
386 TSS2_RC r;
387 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
388 enum _ESYS_STATE esys_states[3] = {
389 _ESYS_STATE_INIT,
390 _ESYS_STATE_INTERNALERROR
391 };
392 TPM2B_DATA *encryptionKeyOut;
393 TPM2B_PRIVATE *duplicate;
394 TPM2B_ENCRYPTED_SECRET *outSymSeed;
395 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
396 esys_context->state = esys_states[i];
397 r = Esys_Duplicate_Finish(esys_context,
398 &encryptionKeyOut, &duplicate, &outSymSeed);
399 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
400 }
401 }
402
403 void
check_Rewrap(void ** state)404 check_Rewrap(void **state)
405 {
406 TSS2_RC r;
407 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
408 enum _ESYS_STATE esys_states[3] = {
409 _ESYS_STATE_INIT,
410 _ESYS_STATE_INTERNALERROR
411 };
412 TPM2B_PRIVATE *outDuplicate;
413 TPM2B_ENCRYPTED_SECRET *outSymSeed;
414 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
415 esys_context->state = esys_states[i];
416 r = Esys_Rewrap_Finish(esys_context, &outDuplicate, &outSymSeed);
417 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
418 }
419 }
420
421 void
check_Import(void ** state)422 check_Import(void **state)
423 {
424 TSS2_RC r;
425 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
426 enum _ESYS_STATE esys_states[3] = {
427 _ESYS_STATE_INIT,
428 _ESYS_STATE_INTERNALERROR
429 };
430 TPM2B_PRIVATE *outPrivate;
431 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
432 esys_context->state = esys_states[i];
433 r = Esys_Import_Finish(esys_context, &outPrivate);
434 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
435 }
436 }
437
438 void
check_RSA_Encrypt(void ** state)439 check_RSA_Encrypt(void **state)
440 {
441 TSS2_RC r;
442 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
443 enum _ESYS_STATE esys_states[3] = {
444 _ESYS_STATE_INIT,
445 _ESYS_STATE_INTERNALERROR
446 };
447 TPM2B_PUBLIC_KEY_RSA *outData;
448 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
449 esys_context->state = esys_states[i];
450 r = Esys_RSA_Encrypt_Finish(esys_context, &outData);
451 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
452 }
453 }
454
455 void
check_RSA_Decrypt(void ** state)456 check_RSA_Decrypt(void **state)
457 {
458 TSS2_RC r;
459 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
460 enum _ESYS_STATE esys_states[3] = {
461 _ESYS_STATE_INIT,
462 _ESYS_STATE_INTERNALERROR
463 };
464 TPM2B_PUBLIC_KEY_RSA *message;
465 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
466 esys_context->state = esys_states[i];
467 r = Esys_RSA_Decrypt_Finish(esys_context, &message);
468 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
469 }
470 }
471
472 void
check_ECDH_KeyGen(void ** state)473 check_ECDH_KeyGen(void **state)
474 {
475 TSS2_RC r;
476 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
477 enum _ESYS_STATE esys_states[3] = {
478 _ESYS_STATE_INIT,
479 _ESYS_STATE_INTERNALERROR
480 };
481 TPM2B_ECC_POINT *zPoint;
482 TPM2B_ECC_POINT *pubPoint;
483 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
484 esys_context->state = esys_states[i];
485 r = Esys_ECDH_KeyGen_Finish(esys_context, &zPoint, &pubPoint);
486 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
487 }
488 }
489
490 void
check_ECDH_ZGen(void ** state)491 check_ECDH_ZGen(void **state)
492 {
493 TSS2_RC r;
494 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
495 enum _ESYS_STATE esys_states[3] = {
496 _ESYS_STATE_INIT,
497 _ESYS_STATE_INTERNALERROR
498 };
499 TPM2B_ECC_POINT *outPoint;
500 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
501 esys_context->state = esys_states[i];
502 r = Esys_ECDH_ZGen_Finish(esys_context, &outPoint);
503 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
504 }
505 }
506
507 void
check_ECC_Parameters(void ** state)508 check_ECC_Parameters(void **state)
509 {
510 TSS2_RC r;
511 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
512 enum _ESYS_STATE esys_states[3] = {
513 _ESYS_STATE_INIT,
514 _ESYS_STATE_INTERNALERROR
515 };
516 TPMS_ALGORITHM_DETAIL_ECC *parameters;
517 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
518 esys_context->state = esys_states[i];
519 r = Esys_ECC_Parameters_Finish(esys_context, ¶meters);
520 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
521 }
522 }
523
524 void
check_ZGen_2Phase(void ** state)525 check_ZGen_2Phase(void **state)
526 {
527 TSS2_RC r;
528 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
529 enum _ESYS_STATE esys_states[3] = {
530 _ESYS_STATE_INIT,
531 _ESYS_STATE_INTERNALERROR
532 };
533 TPM2B_ECC_POINT *outZ1;
534 TPM2B_ECC_POINT *outZ2;
535 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
536 esys_context->state = esys_states[i];
537 r = Esys_ZGen_2Phase_Finish(esys_context, &outZ1, &outZ2);
538 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
539 }
540 }
541
542 void
check_EncryptDecrypt(void ** state)543 check_EncryptDecrypt(void **state)
544 {
545 TSS2_RC r;
546 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
547 enum _ESYS_STATE esys_states[3] = {
548 _ESYS_STATE_INIT,
549 _ESYS_STATE_INTERNALERROR
550 };
551 TPM2B_MAX_BUFFER *outData;
552 TPM2B_IV *ivOut;
553 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
554 esys_context->state = esys_states[i];
555 r = Esys_EncryptDecrypt_Finish(esys_context, &outData, &ivOut);
556 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
557 }
558 }
559
560 void
check_EncryptDecrypt2(void ** state)561 check_EncryptDecrypt2(void **state)
562 {
563 TSS2_RC r;
564 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
565 enum _ESYS_STATE esys_states[3] = {
566 _ESYS_STATE_INIT,
567 _ESYS_STATE_INTERNALERROR
568 };
569 TPM2B_MAX_BUFFER *outData;
570 TPM2B_IV *ivOut;
571 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
572 esys_context->state = esys_states[i];
573 r = Esys_EncryptDecrypt2_Finish(esys_context, &outData, &ivOut);
574 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
575 }
576 }
577
578 void
check_Hash(void ** state)579 check_Hash(void **state)
580 {
581 TSS2_RC r;
582 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
583 enum _ESYS_STATE esys_states[3] = {
584 _ESYS_STATE_INIT,
585 _ESYS_STATE_INTERNALERROR
586 };
587 TPM2B_DIGEST *outHash;
588 TPMT_TK_HASHCHECK *validation;
589 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
590 esys_context->state = esys_states[i];
591 r = Esys_Hash_Finish(esys_context, &outHash, &validation);
592 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
593 }
594 }
595
596 void
check_HMAC(void ** state)597 check_HMAC(void **state)
598 {
599 TSS2_RC r;
600 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
601 enum _ESYS_STATE esys_states[3] = {
602 _ESYS_STATE_INIT,
603 _ESYS_STATE_INTERNALERROR
604 };
605 TPM2B_DIGEST *outHMAC;
606 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
607 esys_context->state = esys_states[i];
608 r = Esys_HMAC_Finish(esys_context, &outHMAC);
609 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
610 }
611 }
612
613 void
check_GetRandom(void ** state)614 check_GetRandom(void **state)
615 {
616 TSS2_RC r;
617 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
618 enum _ESYS_STATE esys_states[3] = {
619 _ESYS_STATE_INIT,
620 _ESYS_STATE_INTERNALERROR
621 };
622 TPM2B_DIGEST *randomBytes;
623 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
624 esys_context->state = esys_states[i];
625 r = Esys_GetRandom_Finish(esys_context, &randomBytes);
626 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
627 }
628 }
629
630 void
check_StirRandom(void ** state)631 check_StirRandom(void **state)
632 {
633 TSS2_RC r;
634 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
635 enum _ESYS_STATE esys_states[3] = {
636 _ESYS_STATE_INIT,
637 _ESYS_STATE_INTERNALERROR
638 };
639 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
640 esys_context->state = esys_states[i];
641 r = Esys_StirRandom_Finish(esys_context);
642 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
643 }
644 }
645
646 void
check_HMAC_Start(void ** state)647 check_HMAC_Start(void **state)
648 {
649 TSS2_RC r;
650 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
651 enum _ESYS_STATE esys_states[3] = {
652 _ESYS_STATE_INIT,
653 _ESYS_STATE_INTERNALERROR
654 };
655 ESYS_TR sequenceHandle_handle;
656 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
657 esys_context->state = esys_states[i];
658 r = Esys_HMAC_Start_Finish(esys_context, &sequenceHandle_handle);
659 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
660 }
661 }
662
663 void
check_HashSequenceStart(void ** state)664 check_HashSequenceStart(void **state)
665 {
666 TSS2_RC r;
667 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
668 enum _ESYS_STATE esys_states[3] = {
669 _ESYS_STATE_INIT,
670 _ESYS_STATE_INTERNALERROR
671 };
672 ESYS_TR sequenceHandle_handle;
673 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
674 esys_context->state = esys_states[i];
675 r = Esys_HashSequenceStart_Finish(esys_context, &sequenceHandle_handle);
676 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
677 }
678 }
679
680 void
check_SequenceUpdate(void ** state)681 check_SequenceUpdate(void **state)
682 {
683 TSS2_RC r;
684 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
685 enum _ESYS_STATE esys_states[3] = {
686 _ESYS_STATE_INIT,
687 _ESYS_STATE_INTERNALERROR
688 };
689 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
690 esys_context->state = esys_states[i];
691 r = Esys_SequenceUpdate_Finish(esys_context);
692 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
693 }
694 }
695
696 void
check_SequenceComplete(void ** state)697 check_SequenceComplete(void **state)
698 {
699 TSS2_RC r;
700 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
701 enum _ESYS_STATE esys_states[3] = {
702 _ESYS_STATE_INIT,
703 _ESYS_STATE_INTERNALERROR
704 };
705 TPM2B_DIGEST *result;
706 TPMT_TK_HASHCHECK *validation;
707 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
708 esys_context->state = esys_states[i];
709 r = Esys_SequenceComplete_Finish(esys_context, &result, &validation);
710 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
711 }
712 }
713
714 void
check_EventSequenceComplete(void ** state)715 check_EventSequenceComplete(void **state)
716 {
717 TSS2_RC r;
718 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
719 enum _ESYS_STATE esys_states[3] = {
720 _ESYS_STATE_INIT,
721 _ESYS_STATE_INTERNALERROR
722 };
723 TPML_DIGEST_VALUES *results;
724 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
725 esys_context->state = esys_states[i];
726 r = Esys_EventSequenceComplete_Finish(esys_context, &results);
727 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
728 }
729 }
730
731 void
check_Certify(void ** state)732 check_Certify(void **state)
733 {
734 TSS2_RC r;
735 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
736 enum _ESYS_STATE esys_states[3] = {
737 _ESYS_STATE_INIT,
738 _ESYS_STATE_INTERNALERROR
739 };
740 TPM2B_ATTEST *certifyInfo;
741 TPMT_SIGNATURE *signature;
742 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
743 esys_context->state = esys_states[i];
744 r = Esys_Certify_Finish(esys_context, &certifyInfo, &signature);
745 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
746 }
747 }
748
749 void
check_CertifyCreation(void ** state)750 check_CertifyCreation(void **state)
751 {
752 TSS2_RC r;
753 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
754 enum _ESYS_STATE esys_states[3] = {
755 _ESYS_STATE_INIT,
756 _ESYS_STATE_INTERNALERROR
757 };
758 TPM2B_ATTEST *certifyInfo;
759 TPMT_SIGNATURE *signature;
760 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
761 esys_context->state = esys_states[i];
762 r = Esys_CertifyCreation_Finish(esys_context, &certifyInfo, &signature);
763 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
764 }
765 }
766
767 void
check_Quote(void ** state)768 check_Quote(void **state)
769 {
770 TSS2_RC r;
771 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
772 enum _ESYS_STATE esys_states[3] = {
773 _ESYS_STATE_INIT,
774 _ESYS_STATE_INTERNALERROR
775 };
776 TPM2B_ATTEST *quoted;
777 TPMT_SIGNATURE *signature;
778 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
779 esys_context->state = esys_states[i];
780 r = Esys_Quote_Finish(esys_context, "ed, &signature);
781 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
782 }
783 }
784
785 void
check_GetSessionAuditDigest(void ** state)786 check_GetSessionAuditDigest(void **state)
787 {
788 TSS2_RC r;
789 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
790 enum _ESYS_STATE esys_states[3] = {
791 _ESYS_STATE_INIT,
792 _ESYS_STATE_INTERNALERROR
793 };
794 TPM2B_ATTEST *auditInfo;
795 TPMT_SIGNATURE *signature;
796 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
797 esys_context->state = esys_states[i];
798 r = Esys_GetSessionAuditDigest_Finish(esys_context,
799 &auditInfo, &signature);
800 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
801 }
802 }
803
804 void
check_GetCommandAuditDigest(void ** state)805 check_GetCommandAuditDigest(void **state)
806 {
807 TSS2_RC r;
808 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
809 enum _ESYS_STATE esys_states[3] = {
810 _ESYS_STATE_INIT,
811 _ESYS_STATE_INTERNALERROR
812 };
813 TPM2B_ATTEST *auditInfo;
814 TPMT_SIGNATURE *signature;
815 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
816 esys_context->state = esys_states[i];
817 r = Esys_GetCommandAuditDigest_Finish(esys_context,
818 &auditInfo, &signature);
819 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
820 }
821 }
822
823 void
check_GetTime(void ** state)824 check_GetTime(void **state)
825 {
826 TSS2_RC r;
827 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
828 enum _ESYS_STATE esys_states[3] = {
829 _ESYS_STATE_INIT,
830 _ESYS_STATE_INTERNALERROR
831 };
832 TPM2B_ATTEST *timeInfo;
833 TPMT_SIGNATURE *signature;
834 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
835 esys_context->state = esys_states[i];
836 r = Esys_GetTime_Finish(esys_context, &timeInfo, &signature);
837 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
838 }
839 }
840
841 void
check_Commit(void ** state)842 check_Commit(void **state)
843 {
844 TSS2_RC r;
845 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
846 enum _ESYS_STATE esys_states[3] = {
847 _ESYS_STATE_INIT,
848 _ESYS_STATE_INTERNALERROR
849 };
850 TPM2B_ECC_POINT *K;
851 TPM2B_ECC_POINT *L;
852 TPM2B_ECC_POINT *E;
853 UINT16 counter;
854 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
855 esys_context->state = esys_states[i];
856 r = Esys_Commit_Finish(esys_context, &K, &L, &E, &counter);
857 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
858 }
859 }
860
861 void
check_EC_Ephemeral(void ** state)862 check_EC_Ephemeral(void **state)
863 {
864 TSS2_RC r;
865 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
866 enum _ESYS_STATE esys_states[3] = {
867 _ESYS_STATE_INIT,
868 _ESYS_STATE_INTERNALERROR
869 };
870 TPM2B_ECC_POINT *Q;
871 UINT16 counter;
872 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
873 esys_context->state = esys_states[i];
874 r = Esys_EC_Ephemeral_Finish(esys_context, &Q, &counter);
875 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
876 }
877 }
878
879 void
check_VerifySignature(void ** state)880 check_VerifySignature(void **state)
881 {
882 TSS2_RC r;
883 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
884 enum _ESYS_STATE esys_states[3] = {
885 _ESYS_STATE_INIT,
886 _ESYS_STATE_INTERNALERROR
887 };
888 TPMT_TK_VERIFIED *validation;
889 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
890 esys_context->state = esys_states[i];
891 r = Esys_VerifySignature_Finish(esys_context, &validation);
892 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
893 }
894 }
895
896 void
check_Sign(void ** state)897 check_Sign(void **state)
898 {
899 TSS2_RC r;
900 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
901 enum _ESYS_STATE esys_states[3] = {
902 _ESYS_STATE_INIT,
903 _ESYS_STATE_INTERNALERROR
904 };
905 TPMT_SIGNATURE *signature;
906 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
907 esys_context->state = esys_states[i];
908 r = Esys_Sign_Finish(esys_context, &signature);
909 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
910 }
911 }
912
913 void
check_SetCommandCodeAuditStatus(void ** state)914 check_SetCommandCodeAuditStatus(void **state)
915 {
916 TSS2_RC r;
917 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
918 enum _ESYS_STATE esys_states[3] = {
919 _ESYS_STATE_INIT,
920 _ESYS_STATE_INTERNALERROR
921 };
922 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
923 esys_context->state = esys_states[i];
924 r = Esys_SetCommandCodeAuditStatus_Finish(esys_context);
925 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
926 }
927 }
928
929 void
check_PCR_Extend(void ** state)930 check_PCR_Extend(void **state)
931 {
932 TSS2_RC r;
933 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
934 enum _ESYS_STATE esys_states[3] = {
935 _ESYS_STATE_INIT,
936 _ESYS_STATE_INTERNALERROR
937 };
938 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
939 esys_context->state = esys_states[i];
940 r = Esys_PCR_Extend_Finish(esys_context);
941 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
942 }
943 }
944
945 void
check_PCR_Event(void ** state)946 check_PCR_Event(void **state)
947 {
948 TSS2_RC r;
949 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
950 enum _ESYS_STATE esys_states[3] = {
951 _ESYS_STATE_INIT,
952 _ESYS_STATE_INTERNALERROR
953 };
954 TPML_DIGEST_VALUES *digests;
955 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
956 esys_context->state = esys_states[i];
957 r = Esys_PCR_Event_Finish(esys_context, &digests);
958 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
959 }
960 }
961
962 void
check_PCR_Read(void ** state)963 check_PCR_Read(void **state)
964 {
965 TSS2_RC r;
966 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
967 enum _ESYS_STATE esys_states[3] = {
968 _ESYS_STATE_INIT,
969 _ESYS_STATE_INTERNALERROR
970 };
971 TPML_PCR_SELECTION *pcrSelectionOut;
972 TPML_DIGEST *pcrValues;
973 UINT32 pcrUpdateCounter;
974 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
975 esys_context->state = esys_states[i];
976 r = Esys_PCR_Read_Finish(esys_context,
977 &pcrUpdateCounter,
978 &pcrSelectionOut, &pcrValues);
979 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
980 }
981 }
982
983 void
check_PCR_Allocate(void ** state)984 check_PCR_Allocate(void **state)
985 {
986 TSS2_RC r;
987 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
988 enum _ESYS_STATE esys_states[3] = {
989 _ESYS_STATE_INIT,
990 _ESYS_STATE_INTERNALERROR
991 };
992 TPMI_YES_NO allocationSuccess;
993 UINT32 maxPCR;
994 UINT32 sizeNeeded;
995 UINT32 sizeAvailable;
996 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
997 esys_context->state = esys_states[i];
998 r = Esys_PCR_Allocate_Finish(esys_context,
999 &allocationSuccess,
1000 &maxPCR, &sizeNeeded, &sizeAvailable);
1001 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1002 }
1003 }
1004
1005 void
check_PCR_SetAuthPolicy(void ** state)1006 check_PCR_SetAuthPolicy(void **state)
1007 {
1008 TSS2_RC r;
1009 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1010 enum _ESYS_STATE esys_states[3] = {
1011 _ESYS_STATE_INIT,
1012 _ESYS_STATE_INTERNALERROR
1013 };
1014 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1015 esys_context->state = esys_states[i];
1016 r = Esys_PCR_SetAuthPolicy_Finish(esys_context);
1017 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1018 }
1019 }
1020
1021 void
check_PCR_SetAuthValue(void ** state)1022 check_PCR_SetAuthValue(void **state)
1023 {
1024 TSS2_RC r;
1025 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1026 enum _ESYS_STATE esys_states[3] = {
1027 _ESYS_STATE_INIT,
1028 _ESYS_STATE_INTERNALERROR
1029 };
1030 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1031 esys_context->state = esys_states[i];
1032 r = Esys_PCR_SetAuthValue_Finish(esys_context);
1033 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1034 }
1035 }
1036
1037 void
check_PCR_Reset(void ** state)1038 check_PCR_Reset(void **state)
1039 {
1040 TSS2_RC r;
1041 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1042 enum _ESYS_STATE esys_states[3] = {
1043 _ESYS_STATE_INIT,
1044 _ESYS_STATE_INTERNALERROR
1045 };
1046 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1047 esys_context->state = esys_states[i];
1048 r = Esys_PCR_Reset_Finish(esys_context);
1049 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1050 }
1051 }
1052
1053 void
check_PolicySigned(void ** state)1054 check_PolicySigned(void **state)
1055 {
1056 TSS2_RC r;
1057 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1058 enum _ESYS_STATE esys_states[3] = {
1059 _ESYS_STATE_INIT,
1060 _ESYS_STATE_INTERNALERROR
1061 };
1062 TPM2B_TIMEOUT *timeout;
1063 TPMT_TK_AUTH *policyTicket;
1064 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1065 esys_context->state = esys_states[i];
1066 r = Esys_PolicySigned_Finish(esys_context, &timeout, &policyTicket);
1067 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1068 }
1069 }
1070
1071 void
check_PolicySecret(void ** state)1072 check_PolicySecret(void **state)
1073 {
1074 TSS2_RC r;
1075 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1076 enum _ESYS_STATE esys_states[3] = {
1077 _ESYS_STATE_INIT,
1078 _ESYS_STATE_INTERNALERROR
1079 };
1080 TPM2B_TIMEOUT *timeout;
1081 TPMT_TK_AUTH *policyTicket;
1082 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1083 esys_context->state = esys_states[i];
1084 r = Esys_PolicySecret_Finish(esys_context, &timeout, &policyTicket);
1085 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1086 }
1087 }
1088
1089 void
check_PolicyTicket(void ** state)1090 check_PolicyTicket(void **state)
1091 {
1092 TSS2_RC r;
1093 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1094 enum _ESYS_STATE esys_states[3] = {
1095 _ESYS_STATE_INIT,
1096 _ESYS_STATE_INTERNALERROR
1097 };
1098 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1099 esys_context->state = esys_states[i];
1100 r = Esys_PolicyTicket_Finish(esys_context);
1101 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1102 }
1103 }
1104
1105 void
check_PolicyOR(void ** state)1106 check_PolicyOR(void **state)
1107 {
1108 TSS2_RC r;
1109 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1110 enum _ESYS_STATE esys_states[3] = {
1111 _ESYS_STATE_INIT,
1112 _ESYS_STATE_INTERNALERROR
1113 };
1114 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1115 esys_context->state = esys_states[i];
1116 r = Esys_PolicyOR_Finish(esys_context);
1117 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1118 }
1119 }
1120
1121 void
check_PolicyPCR(void ** state)1122 check_PolicyPCR(void **state)
1123 {
1124 TSS2_RC r;
1125 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1126 enum _ESYS_STATE esys_states[3] = {
1127 _ESYS_STATE_INIT,
1128 _ESYS_STATE_INTERNALERROR
1129 };
1130 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1131 esys_context->state = esys_states[i];
1132 r = Esys_PolicyPCR_Finish(esys_context);
1133 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1134 }
1135 }
1136
1137 void
check_PolicyLocality(void ** state)1138 check_PolicyLocality(void **state)
1139 {
1140 TSS2_RC r;
1141 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1142 enum _ESYS_STATE esys_states[3] = {
1143 _ESYS_STATE_INIT,
1144 _ESYS_STATE_INTERNALERROR
1145 };
1146 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1147 esys_context->state = esys_states[i];
1148 r = Esys_PolicyLocality_Finish(esys_context);
1149 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1150 }
1151 }
1152
1153 void
check_PolicyNV(void ** state)1154 check_PolicyNV(void **state)
1155 {
1156 TSS2_RC r;
1157 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1158 enum _ESYS_STATE esys_states[3] = {
1159 _ESYS_STATE_INIT,
1160 _ESYS_STATE_INTERNALERROR
1161 };
1162 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1163 esys_context->state = esys_states[i];
1164 r = Esys_PolicyNV_Finish(esys_context);
1165 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1166 }
1167 }
1168
1169 void
check_PolicyCounterTimer(void ** state)1170 check_PolicyCounterTimer(void **state)
1171 {
1172 TSS2_RC r;
1173 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1174 enum _ESYS_STATE esys_states[3] = {
1175 _ESYS_STATE_INIT,
1176 _ESYS_STATE_INTERNALERROR
1177 };
1178 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1179 esys_context->state = esys_states[i];
1180 r = Esys_PolicyCounterTimer_Finish(esys_context);
1181 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1182 }
1183 }
1184
1185 void
check_PolicyCommandCode(void ** state)1186 check_PolicyCommandCode(void **state)
1187 {
1188 TSS2_RC r;
1189 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1190 enum _ESYS_STATE esys_states[3] = {
1191 _ESYS_STATE_INIT,
1192 _ESYS_STATE_INTERNALERROR
1193 };
1194 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1195 esys_context->state = esys_states[i];
1196 r = Esys_PolicyCommandCode_Finish(esys_context);
1197 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1198 }
1199 }
1200
1201 void
check_PolicyPhysicalPresence(void ** state)1202 check_PolicyPhysicalPresence(void **state)
1203 {
1204 TSS2_RC r;
1205 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1206 enum _ESYS_STATE esys_states[3] = {
1207 _ESYS_STATE_INIT,
1208 _ESYS_STATE_INTERNALERROR
1209 };
1210 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1211 esys_context->state = esys_states[i];
1212 r = Esys_PolicyPhysicalPresence_Finish(esys_context);
1213 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1214 }
1215 }
1216
1217 void
check_PolicyCpHash(void ** state)1218 check_PolicyCpHash(void **state)
1219 {
1220 TSS2_RC r;
1221 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1222 enum _ESYS_STATE esys_states[3] = {
1223 _ESYS_STATE_INIT,
1224 _ESYS_STATE_INTERNALERROR
1225 };
1226 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1227 esys_context->state = esys_states[i];
1228 r = Esys_PolicyCpHash_Finish(esys_context);
1229 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1230 }
1231 }
1232
1233 void
check_PolicyNameHash(void ** state)1234 check_PolicyNameHash(void **state)
1235 {
1236 TSS2_RC r;
1237 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1238 enum _ESYS_STATE esys_states[3] = {
1239 _ESYS_STATE_INIT,
1240 _ESYS_STATE_INTERNALERROR
1241 };
1242 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1243 esys_context->state = esys_states[i];
1244 r = Esys_PolicyNameHash_Finish(esys_context);
1245 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1246 }
1247 }
1248
1249 void
check_PolicyDuplicationSelect(void ** state)1250 check_PolicyDuplicationSelect(void **state)
1251 {
1252 TSS2_RC r;
1253 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1254 enum _ESYS_STATE esys_states[3] = {
1255 _ESYS_STATE_INIT,
1256 _ESYS_STATE_INTERNALERROR
1257 };
1258 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1259 esys_context->state = esys_states[i];
1260 r = Esys_PolicyDuplicationSelect_Finish(esys_context);
1261 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1262 }
1263 }
1264
1265 void
check_PolicyAuthorize(void ** state)1266 check_PolicyAuthorize(void **state)
1267 {
1268 TSS2_RC r;
1269 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1270 enum _ESYS_STATE esys_states[3] = {
1271 _ESYS_STATE_INIT,
1272 _ESYS_STATE_INTERNALERROR
1273 };
1274 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1275 esys_context->state = esys_states[i];
1276 r = Esys_PolicyAuthorize_Finish(esys_context);
1277 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1278 }
1279 }
1280
1281 void
check_PolicyAuthValue(void ** state)1282 check_PolicyAuthValue(void **state)
1283 {
1284 TSS2_RC r;
1285 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1286 enum _ESYS_STATE esys_states[3] = {
1287 _ESYS_STATE_INIT,
1288 _ESYS_STATE_INTERNALERROR
1289 };
1290 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1291 esys_context->state = esys_states[i];
1292 r = Esys_PolicyAuthValue_Finish(esys_context);
1293 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1294 }
1295 }
1296
1297 void
check_PolicyPassword(void ** state)1298 check_PolicyPassword(void **state)
1299 {
1300 TSS2_RC r;
1301 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1302 enum _ESYS_STATE esys_states[3] = {
1303 _ESYS_STATE_INIT,
1304 _ESYS_STATE_INTERNALERROR
1305 };
1306 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1307 esys_context->state = esys_states[i];
1308 r = Esys_PolicyPassword_Finish(esys_context);
1309 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1310 }
1311 }
1312
1313 void
check_PolicyGetDigest(void ** state)1314 check_PolicyGetDigest(void **state)
1315 {
1316 TSS2_RC r;
1317 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1318 enum _ESYS_STATE esys_states[3] = {
1319 _ESYS_STATE_INIT,
1320 _ESYS_STATE_INTERNALERROR
1321 };
1322 TPM2B_DIGEST *policyDigest;
1323 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1324 esys_context->state = esys_states[i];
1325 r = Esys_PolicyGetDigest_Finish(esys_context, &policyDigest);
1326 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1327 }
1328 }
1329
1330 void
check_PolicyNvWritten(void ** state)1331 check_PolicyNvWritten(void **state)
1332 {
1333 TSS2_RC r;
1334 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1335 enum _ESYS_STATE esys_states[3] = {
1336 _ESYS_STATE_INIT,
1337 _ESYS_STATE_INTERNALERROR
1338 };
1339 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1340 esys_context->state = esys_states[i];
1341 r = Esys_PolicyNvWritten_Finish(esys_context);
1342 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1343 }
1344 }
1345
1346 void
check_PolicyTemplate(void ** state)1347 check_PolicyTemplate(void **state)
1348 {
1349 TSS2_RC r;
1350 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1351 enum _ESYS_STATE esys_states[3] = {
1352 _ESYS_STATE_INIT,
1353 _ESYS_STATE_INTERNALERROR
1354 };
1355 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1356 esys_context->state = esys_states[i];
1357 r = Esys_PolicyTemplate_Finish(esys_context);
1358 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1359 }
1360 }
1361
1362 void
check_PolicyAuthorizeNV(void ** state)1363 check_PolicyAuthorizeNV(void **state)
1364 {
1365 TSS2_RC r;
1366 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1367 enum _ESYS_STATE esys_states[3] = {
1368 _ESYS_STATE_INIT,
1369 _ESYS_STATE_INTERNALERROR
1370 };
1371 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1372 esys_context->state = esys_states[i];
1373 r = Esys_PolicyAuthorizeNV_Finish(esys_context);
1374 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1375 }
1376 }
1377
1378 void
check_CreatePrimary(void ** state)1379 check_CreatePrimary(void **state)
1380 {
1381 TSS2_RC r;
1382 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1383 enum _ESYS_STATE esys_states[3] = {
1384 _ESYS_STATE_INIT,
1385 _ESYS_STATE_INTERNALERROR
1386 };
1387 ESYS_TR objectHandle_handle;
1388 TPM2B_PUBLIC *outPublic;
1389 TPM2B_CREATION_DATA *creationData;
1390 TPM2B_DIGEST *creationHash;
1391 TPMT_TK_CREATION *creationTicket;
1392 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1393 esys_context->state = esys_states[i];
1394 r = Esys_CreatePrimary_Finish(esys_context,
1395 &objectHandle_handle,
1396 &outPublic,
1397 &creationData,
1398 &creationHash, &creationTicket);
1399 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1400 }
1401 }
1402
1403 void
check_HierarchyControl(void ** state)1404 check_HierarchyControl(void **state)
1405 {
1406 TSS2_RC r;
1407 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1408 enum _ESYS_STATE esys_states[3] = {
1409 _ESYS_STATE_INIT,
1410 _ESYS_STATE_INTERNALERROR
1411 };
1412 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1413 esys_context->state = esys_states[i];
1414 r = Esys_HierarchyControl_Finish(esys_context);
1415 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1416 }
1417 }
1418
1419 void
check_SetPrimaryPolicy(void ** state)1420 check_SetPrimaryPolicy(void **state)
1421 {
1422 TSS2_RC r;
1423 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1424 enum _ESYS_STATE esys_states[3] = {
1425 _ESYS_STATE_INIT,
1426 _ESYS_STATE_INTERNALERROR
1427 };
1428 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1429 esys_context->state = esys_states[i];
1430 r = Esys_SetPrimaryPolicy_Finish(esys_context);
1431 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1432 }
1433 }
1434
1435 void
check_ChangePPS(void ** state)1436 check_ChangePPS(void **state)
1437 {
1438 TSS2_RC r;
1439 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1440 enum _ESYS_STATE esys_states[3] = {
1441 _ESYS_STATE_INIT,
1442 _ESYS_STATE_INTERNALERROR
1443 };
1444 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1445 esys_context->state = esys_states[i];
1446 r = Esys_ChangePPS_Finish(esys_context);
1447 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1448 }
1449 }
1450
1451 void
check_ChangeEPS(void ** state)1452 check_ChangeEPS(void **state)
1453 {
1454 TSS2_RC r;
1455 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1456 enum _ESYS_STATE esys_states[3] = {
1457 _ESYS_STATE_INIT,
1458 _ESYS_STATE_INTERNALERROR
1459 };
1460 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1461 esys_context->state = esys_states[i];
1462 r = Esys_ChangeEPS_Finish(esys_context);
1463 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1464 }
1465 }
1466
1467 void
check_Clear(void ** state)1468 check_Clear(void **state)
1469 {
1470 TSS2_RC r;
1471 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1472 enum _ESYS_STATE esys_states[3] = {
1473 _ESYS_STATE_INIT,
1474 _ESYS_STATE_INTERNALERROR
1475 };
1476 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1477 esys_context->state = esys_states[i];
1478 r = Esys_Clear_Finish(esys_context);
1479 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1480 }
1481 }
1482
1483 void
check_ClearControl(void ** state)1484 check_ClearControl(void **state)
1485 {
1486 TSS2_RC r;
1487 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1488 enum _ESYS_STATE esys_states[3] = {
1489 _ESYS_STATE_INIT,
1490 _ESYS_STATE_INTERNALERROR
1491 };
1492 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1493 esys_context->state = esys_states[i];
1494 r = Esys_ClearControl_Finish(esys_context);
1495 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1496 }
1497 }
1498
1499 void
check_HierarchyChangeAuth(void ** state)1500 check_HierarchyChangeAuth(void **state)
1501 {
1502 TSS2_RC r;
1503 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1504 enum _ESYS_STATE esys_states[3] = {
1505 _ESYS_STATE_INIT,
1506 _ESYS_STATE_INTERNALERROR
1507 };
1508 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1509 esys_context->state = esys_states[i];
1510 r = Esys_HierarchyChangeAuth_Finish(esys_context);
1511 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1512 }
1513 }
1514
1515 void
check_DictionaryAttackLockReset(void ** state)1516 check_DictionaryAttackLockReset(void **state)
1517 {
1518 TSS2_RC r;
1519 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1520 enum _ESYS_STATE esys_states[3] = {
1521 _ESYS_STATE_INIT,
1522 _ESYS_STATE_INTERNALERROR
1523 };
1524 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1525 esys_context->state = esys_states[i];
1526 r = Esys_DictionaryAttackLockReset_Finish(esys_context);
1527 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1528 }
1529 }
1530
1531 void
check_DictionaryAttackParameters(void ** state)1532 check_DictionaryAttackParameters(void **state)
1533 {
1534 TSS2_RC r;
1535 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1536 enum _ESYS_STATE esys_states[3] = {
1537 _ESYS_STATE_INIT,
1538 _ESYS_STATE_INTERNALERROR
1539 };
1540 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1541 esys_context->state = esys_states[i];
1542 r = Esys_DictionaryAttackParameters_Finish(esys_context);
1543 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1544 }
1545 }
1546
1547 void
check_PP_Commands(void ** state)1548 check_PP_Commands(void **state)
1549 {
1550 TSS2_RC r;
1551 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1552 enum _ESYS_STATE esys_states[3] = {
1553 _ESYS_STATE_INIT,
1554 _ESYS_STATE_INTERNALERROR
1555 };
1556 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1557 esys_context->state = esys_states[i];
1558 r = Esys_PP_Commands_Finish(esys_context);
1559 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1560 }
1561 }
1562
1563 void
check_SetAlgorithmSet(void ** state)1564 check_SetAlgorithmSet(void **state)
1565 {
1566 TSS2_RC r;
1567 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1568 enum _ESYS_STATE esys_states[3] = {
1569 _ESYS_STATE_INIT,
1570 _ESYS_STATE_INTERNALERROR
1571 };
1572 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1573 esys_context->state = esys_states[i];
1574 r = Esys_SetAlgorithmSet_Finish(esys_context);
1575 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1576 }
1577 }
1578
1579 void
check_FieldUpgradeStart(void ** state)1580 check_FieldUpgradeStart(void **state)
1581 {
1582 TSS2_RC r;
1583 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1584 enum _ESYS_STATE esys_states[3] = {
1585 _ESYS_STATE_INIT,
1586 _ESYS_STATE_INTERNALERROR
1587 };
1588 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1589 esys_context->state = esys_states[i];
1590 r = Esys_FieldUpgradeStart_Finish(esys_context);
1591 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1592 }
1593 }
1594
1595 void
check_FieldUpgradeData(void ** state)1596 check_FieldUpgradeData(void **state)
1597 {
1598 TSS2_RC r;
1599 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1600 enum _ESYS_STATE esys_states[3] = {
1601 _ESYS_STATE_INIT,
1602 _ESYS_STATE_INTERNALERROR
1603 };
1604 TPMT_HA *nextDigest;
1605 TPMT_HA *firstDigest;
1606 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1607 esys_context->state = esys_states[i];
1608 r = Esys_FieldUpgradeData_Finish(esys_context,
1609 &nextDigest, &firstDigest);
1610 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1611 }
1612 }
1613
1614 void
check_FirmwareRead(void ** state)1615 check_FirmwareRead(void **state)
1616 {
1617 TSS2_RC r;
1618 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1619 enum _ESYS_STATE esys_states[3] = {
1620 _ESYS_STATE_INIT,
1621 _ESYS_STATE_INTERNALERROR
1622 };
1623 TPM2B_MAX_BUFFER *fuData;
1624 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1625 esys_context->state = esys_states[i];
1626 r = Esys_FirmwareRead_Finish(esys_context, &fuData);
1627 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1628 }
1629 }
1630
1631 void
check_ContextSave(void ** state)1632 check_ContextSave(void **state)
1633 {
1634 TSS2_RC r;
1635 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1636 enum _ESYS_STATE esys_states[3] = {
1637 _ESYS_STATE_INIT,
1638 _ESYS_STATE_INTERNALERROR
1639 };
1640 TPMS_CONTEXT *context;
1641 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1642 esys_context->state = esys_states[i];
1643 r = Esys_ContextSave_Finish(esys_context, &context);
1644 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1645 }
1646 }
1647
1648 void
check_ContextLoad(void ** state)1649 check_ContextLoad(void **state)
1650 {
1651 TSS2_RC r;
1652 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1653 enum _ESYS_STATE esys_states[3] = {
1654 _ESYS_STATE_INIT,
1655 _ESYS_STATE_INTERNALERROR
1656 };
1657 ESYS_TR loadedHandle_handle;
1658 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1659 esys_context->state = esys_states[i];
1660 r = Esys_ContextLoad_Finish(esys_context, &loadedHandle_handle);
1661 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1662 }
1663 }
1664
1665 void
check_FlushContext(void ** state)1666 check_FlushContext(void **state)
1667 {
1668 TSS2_RC r;
1669 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1670 enum _ESYS_STATE esys_states[3] = {
1671 _ESYS_STATE_INIT,
1672 _ESYS_STATE_INTERNALERROR
1673 };
1674 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1675 esys_context->state = esys_states[i];
1676 r = Esys_FlushContext_Finish(esys_context);
1677 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1678 }
1679 }
1680
1681 void
check_EvictControl(void ** state)1682 check_EvictControl(void **state)
1683 {
1684 TSS2_RC r;
1685 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1686 enum _ESYS_STATE esys_states[3] = {
1687 _ESYS_STATE_INIT,
1688 _ESYS_STATE_INTERNALERROR
1689 };
1690 ESYS_TR newObjectHandle_handle;
1691 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1692 esys_context->state = esys_states[i];
1693 r = Esys_EvictControl_Finish(esys_context, &newObjectHandle_handle);
1694 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1695 }
1696 }
1697
1698 void
check_ReadClock(void ** state)1699 check_ReadClock(void **state)
1700 {
1701 TSS2_RC r;
1702 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1703 enum _ESYS_STATE esys_states[3] = {
1704 _ESYS_STATE_INIT,
1705 _ESYS_STATE_INTERNALERROR
1706 };
1707 TPMS_TIME_INFO *currentTime;
1708 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1709 esys_context->state = esys_states[i];
1710 r = Esys_ReadClock_Finish(esys_context, ¤tTime);
1711 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1712 }
1713 }
1714
1715 void
check_ClockSet(void ** state)1716 check_ClockSet(void **state)
1717 {
1718 TSS2_RC r;
1719 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1720 enum _ESYS_STATE esys_states[3] = {
1721 _ESYS_STATE_INIT,
1722 _ESYS_STATE_INTERNALERROR
1723 };
1724 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1725 esys_context->state = esys_states[i];
1726 r = Esys_ClockSet_Finish(esys_context);
1727 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1728 }
1729 }
1730
1731 void
check_ClockRateAdjust(void ** state)1732 check_ClockRateAdjust(void **state)
1733 {
1734 TSS2_RC r;
1735 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1736 enum _ESYS_STATE esys_states[3] = {
1737 _ESYS_STATE_INIT,
1738 _ESYS_STATE_INTERNALERROR
1739 };
1740 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1741 esys_context->state = esys_states[i];
1742 r = Esys_ClockRateAdjust_Finish(esys_context);
1743 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1744 }
1745 }
1746
1747 void
check_GetCapability(void ** state)1748 check_GetCapability(void **state)
1749 {
1750 TSS2_RC r;
1751 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1752 enum _ESYS_STATE esys_states[3] = {
1753 _ESYS_STATE_INIT,
1754 _ESYS_STATE_INTERNALERROR
1755 };
1756 TPMS_CAPABILITY_DATA *capabilityData;
1757 TPMI_YES_NO moreData;
1758 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1759 esys_context->state = esys_states[i];
1760 r = Esys_GetCapability_Finish(esys_context, &moreData, &capabilityData);
1761 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1762 }
1763 }
1764
1765 void
check_TestParms(void ** state)1766 check_TestParms(void **state)
1767 {
1768 TSS2_RC r;
1769 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1770 enum _ESYS_STATE esys_states[3] = {
1771 _ESYS_STATE_INIT,
1772 _ESYS_STATE_INTERNALERROR
1773 };
1774 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1775 esys_context->state = esys_states[i];
1776 r = Esys_TestParms_Finish(esys_context);
1777 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1778 }
1779 }
1780
1781 void
check_NV_DefineSpace(void ** state)1782 check_NV_DefineSpace(void **state)
1783 {
1784 TSS2_RC r;
1785 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1786 enum _ESYS_STATE esys_states[3] = {
1787 _ESYS_STATE_INIT,
1788 _ESYS_STATE_INTERNALERROR
1789 };
1790 ESYS_TR nvHandle_handle;
1791 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1792 esys_context->state = esys_states[i];
1793 r = Esys_NV_DefineSpace_Finish(esys_context, &nvHandle_handle);
1794 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1795 }
1796 }
1797
1798 void
check_NV_UndefineSpace(void ** state)1799 check_NV_UndefineSpace(void **state)
1800 {
1801 TSS2_RC r;
1802 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1803 enum _ESYS_STATE esys_states[3] = {
1804 _ESYS_STATE_INIT,
1805 _ESYS_STATE_INTERNALERROR
1806 };
1807 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1808 esys_context->state = esys_states[i];
1809 r = Esys_NV_UndefineSpace_Finish(esys_context);
1810 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1811 }
1812 }
1813
1814 void
check_NV_UndefineSpaceSpecial(void ** state)1815 check_NV_UndefineSpaceSpecial(void **state)
1816 {
1817 TSS2_RC r;
1818 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1819 enum _ESYS_STATE esys_states[3] = {
1820 _ESYS_STATE_INIT,
1821 _ESYS_STATE_INTERNALERROR
1822 };
1823 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1824 esys_context->state = esys_states[i];
1825 r = Esys_NV_UndefineSpaceSpecial_Finish(esys_context);
1826 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1827 }
1828 }
1829
1830 void
check_NV_ReadPublic(void ** state)1831 check_NV_ReadPublic(void **state)
1832 {
1833 TSS2_RC r;
1834 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1835 enum _ESYS_STATE esys_states[3] = {
1836 _ESYS_STATE_INIT,
1837 _ESYS_STATE_INTERNALERROR
1838 };
1839 TPM2B_NV_PUBLIC *nvPublic;
1840 TPM2B_NAME *nvName;
1841 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1842 esys_context->state = esys_states[i];
1843 r = Esys_NV_ReadPublic_Finish(esys_context, &nvPublic, &nvName);
1844 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1845 }
1846 }
1847
1848 void
check_NV_Write(void ** state)1849 check_NV_Write(void **state)
1850 {
1851 TSS2_RC r;
1852 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1853 enum _ESYS_STATE esys_states[3] = {
1854 _ESYS_STATE_INIT,
1855 _ESYS_STATE_INTERNALERROR
1856 };
1857 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1858 esys_context->state = esys_states[i];
1859 r = Esys_NV_Write_Finish(esys_context);
1860 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1861 }
1862 }
1863
1864 void
check_NV_Increment(void ** state)1865 check_NV_Increment(void **state)
1866 {
1867 TSS2_RC r;
1868 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1869 enum _ESYS_STATE esys_states[3] = {
1870 _ESYS_STATE_INIT,
1871 _ESYS_STATE_INTERNALERROR
1872 };
1873 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1874 esys_context->state = esys_states[i];
1875 r = Esys_NV_Increment_Finish(esys_context);
1876 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1877 }
1878 }
1879
1880 void
check_NV_Extend(void ** state)1881 check_NV_Extend(void **state)
1882 {
1883 TSS2_RC r;
1884 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1885 enum _ESYS_STATE esys_states[3] = {
1886 _ESYS_STATE_INIT,
1887 _ESYS_STATE_INTERNALERROR
1888 };
1889 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1890 esys_context->state = esys_states[i];
1891 r = Esys_NV_Extend_Finish(esys_context);
1892 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1893 }
1894 }
1895
1896 void
check_NV_SetBits(void ** state)1897 check_NV_SetBits(void **state)
1898 {
1899 TSS2_RC r;
1900 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1901 enum _ESYS_STATE esys_states[3] = {
1902 _ESYS_STATE_INIT,
1903 _ESYS_STATE_INTERNALERROR
1904 };
1905 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1906 esys_context->state = esys_states[i];
1907 r = Esys_NV_SetBits_Finish(esys_context);
1908 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1909 }
1910 }
1911
1912 void
check_NV_WriteLock(void ** state)1913 check_NV_WriteLock(void **state)
1914 {
1915 TSS2_RC r;
1916 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1917 enum _ESYS_STATE esys_states[3] = {
1918 _ESYS_STATE_INIT,
1919 _ESYS_STATE_INTERNALERROR
1920 };
1921 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1922 esys_context->state = esys_states[i];
1923 r = Esys_NV_WriteLock_Finish(esys_context);
1924 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1925 }
1926 }
1927
1928 void
check_NV_GlobalWriteLock(void ** state)1929 check_NV_GlobalWriteLock(void **state)
1930 {
1931 TSS2_RC r;
1932 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1933 enum _ESYS_STATE esys_states[3] = {
1934 _ESYS_STATE_INIT,
1935 _ESYS_STATE_INTERNALERROR
1936 };
1937 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1938 esys_context->state = esys_states[i];
1939 r = Esys_NV_GlobalWriteLock_Finish(esys_context);
1940 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1941 }
1942 }
1943
1944 void
check_NV_Read(void ** state)1945 check_NV_Read(void **state)
1946 {
1947 TSS2_RC r;
1948 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1949 enum _ESYS_STATE esys_states[3] = {
1950 _ESYS_STATE_INIT,
1951 _ESYS_STATE_INTERNALERROR
1952 };
1953 TPM2B_MAX_NV_BUFFER *data;
1954 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1955 esys_context->state = esys_states[i];
1956 r = Esys_NV_Read_Finish(esys_context, &data);
1957 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1958 }
1959 }
1960
1961 void
check_NV_ReadLock(void ** state)1962 check_NV_ReadLock(void **state)
1963 {
1964 TSS2_RC r;
1965 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1966 enum _ESYS_STATE esys_states[3] = {
1967 _ESYS_STATE_INIT,
1968 _ESYS_STATE_INTERNALERROR
1969 };
1970 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1971 esys_context->state = esys_states[i];
1972 r = Esys_NV_ReadLock_Finish(esys_context);
1973 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1974 }
1975 }
1976
1977 void
check_NV_ChangeAuth(void ** state)1978 check_NV_ChangeAuth(void **state)
1979 {
1980 TSS2_RC r;
1981 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1982 enum _ESYS_STATE esys_states[3] = {
1983 _ESYS_STATE_INIT,
1984 _ESYS_STATE_INTERNALERROR
1985 };
1986 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1987 esys_context->state = esys_states[i];
1988 r = Esys_NV_ChangeAuth_Finish(esys_context);
1989 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1990 }
1991 }
1992
1993 void
check_NV_Certify(void ** state)1994 check_NV_Certify(void **state)
1995 {
1996 TSS2_RC r;
1997 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1998 enum _ESYS_STATE esys_states[3] = {
1999 _ESYS_STATE_INIT,
2000 _ESYS_STATE_INTERNALERROR
2001 };
2002 TPM2B_ATTEST *certifyInfo;
2003 TPMT_SIGNATURE *signature;
2004 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
2005 esys_context->state = esys_states[i];
2006 r = Esys_NV_Certify_Finish(esys_context, &certifyInfo, &signature);
2007 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
2008 }
2009 }
2010
2011 void
check_Vendor_TCG_Test(void ** state)2012 check_Vendor_TCG_Test(void **state)
2013 {
2014 TSS2_RC r;
2015 ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2016 enum _ESYS_STATE esys_states[3] = {
2017 _ESYS_STATE_INIT,
2018 _ESYS_STATE_INTERNALERROR
2019 };
2020 TPM2B_DATA *outputData;
2021 for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
2022 esys_context->state = esys_states[i];
2023 r = Esys_Vendor_TCG_Test_Finish(esys_context, &outputData);
2024 assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
2025 }
2026 }
2027
2028 int
main(void)2029 main(void)
2030 {
2031 const struct CMUnitTest tests[] = {
2032 cmocka_unit_test_setup_teardown(check_Startup, esys_unit_setup,
2033 esys_unit_teardown),
2034 cmocka_unit_test_setup_teardown(check_Shutdown, esys_unit_setup,
2035 esys_unit_teardown),
2036 cmocka_unit_test_setup_teardown(check_SelfTest, esys_unit_setup,
2037 esys_unit_teardown),
2038 cmocka_unit_test_setup_teardown(check_IncrementalSelfTest,
2039 esys_unit_setup, esys_unit_teardown),
2040 cmocka_unit_test_setup_teardown(check_GetTestResult, esys_unit_setup,
2041 esys_unit_teardown),
2042 cmocka_unit_test_setup_teardown(check_StartAuthSession, esys_unit_setup,
2043 esys_unit_teardown),
2044 cmocka_unit_test_setup_teardown(check_PolicyRestart, esys_unit_setup,
2045 esys_unit_teardown),
2046 cmocka_unit_test_setup_teardown(check_Create, esys_unit_setup,
2047 esys_unit_teardown),
2048 cmocka_unit_test_setup_teardown(check_Load, esys_unit_setup,
2049 esys_unit_teardown),
2050 cmocka_unit_test_setup_teardown(check_LoadExternal, esys_unit_setup,
2051 esys_unit_teardown),
2052 cmocka_unit_test_setup_teardown(check_ReadPublic, esys_unit_setup,
2053 esys_unit_teardown),
2054 cmocka_unit_test_setup_teardown(check_ActivateCredential,
2055 esys_unit_setup, esys_unit_teardown),
2056 cmocka_unit_test_setup_teardown(check_MakeCredential, esys_unit_setup,
2057 esys_unit_teardown),
2058 cmocka_unit_test_setup_teardown(check_Unseal, esys_unit_setup,
2059 esys_unit_teardown),
2060 cmocka_unit_test_setup_teardown(check_ObjectChangeAuth, esys_unit_setup,
2061 esys_unit_teardown),
2062 cmocka_unit_test_setup_teardown(check_CreateLoaded, esys_unit_setup,
2063 esys_unit_teardown),
2064 cmocka_unit_test_setup_teardown(check_Duplicate, esys_unit_setup,
2065 esys_unit_teardown),
2066 cmocka_unit_test_setup_teardown(check_Rewrap, esys_unit_setup,
2067 esys_unit_teardown),
2068 cmocka_unit_test_setup_teardown(check_Import, esys_unit_setup,
2069 esys_unit_teardown),
2070 cmocka_unit_test_setup_teardown(check_RSA_Encrypt, esys_unit_setup,
2071 esys_unit_teardown),
2072 cmocka_unit_test_setup_teardown(check_RSA_Decrypt, esys_unit_setup,
2073 esys_unit_teardown),
2074 cmocka_unit_test_setup_teardown(check_ECDH_KeyGen, esys_unit_setup,
2075 esys_unit_teardown),
2076 cmocka_unit_test_setup_teardown(check_ECDH_ZGen, esys_unit_setup,
2077 esys_unit_teardown),
2078 cmocka_unit_test_setup_teardown(check_ECC_Parameters, esys_unit_setup,
2079 esys_unit_teardown),
2080 cmocka_unit_test_setup_teardown(check_ZGen_2Phase, esys_unit_setup,
2081 esys_unit_teardown),
2082 cmocka_unit_test_setup_teardown(check_EncryptDecrypt, esys_unit_setup,
2083 esys_unit_teardown),
2084 cmocka_unit_test_setup_teardown(check_EncryptDecrypt2, esys_unit_setup,
2085 esys_unit_teardown),
2086 cmocka_unit_test_setup_teardown(check_Hash, esys_unit_setup,
2087 esys_unit_teardown),
2088 cmocka_unit_test_setup_teardown(check_HMAC, esys_unit_setup,
2089 esys_unit_teardown),
2090 cmocka_unit_test_setup_teardown(check_GetRandom, esys_unit_setup,
2091 esys_unit_teardown),
2092 cmocka_unit_test_setup_teardown(check_StirRandom, esys_unit_setup,
2093 esys_unit_teardown),
2094 cmocka_unit_test_setup_teardown(check_HMAC_Start, esys_unit_setup,
2095 esys_unit_teardown),
2096 cmocka_unit_test_setup_teardown(check_HashSequenceStart,
2097 esys_unit_setup, esys_unit_teardown),
2098 cmocka_unit_test_setup_teardown(check_SequenceUpdate, esys_unit_setup,
2099 esys_unit_teardown),
2100 cmocka_unit_test_setup_teardown(check_SequenceComplete, esys_unit_setup,
2101 esys_unit_teardown),
2102 cmocka_unit_test_setup_teardown(check_EventSequenceComplete,
2103 esys_unit_setup, esys_unit_teardown),
2104 cmocka_unit_test_setup_teardown(check_Certify, esys_unit_setup,
2105 esys_unit_teardown),
2106 cmocka_unit_test_setup_teardown(check_CertifyCreation, esys_unit_setup,
2107 esys_unit_teardown),
2108 cmocka_unit_test_setup_teardown(check_Quote, esys_unit_setup,
2109 esys_unit_teardown),
2110 cmocka_unit_test_setup_teardown(check_GetSessionAuditDigest,
2111 esys_unit_setup, esys_unit_teardown),
2112 cmocka_unit_test_setup_teardown(check_GetCommandAuditDigest,
2113 esys_unit_setup, esys_unit_teardown),
2114 cmocka_unit_test_setup_teardown(check_GetTime, esys_unit_setup,
2115 esys_unit_teardown),
2116 cmocka_unit_test_setup_teardown(check_Commit, esys_unit_setup,
2117 esys_unit_teardown),
2118 cmocka_unit_test_setup_teardown(check_EC_Ephemeral, esys_unit_setup,
2119 esys_unit_teardown),
2120 cmocka_unit_test_setup_teardown(check_VerifySignature, esys_unit_setup,
2121 esys_unit_teardown),
2122 cmocka_unit_test_setup_teardown(check_Sign, esys_unit_setup,
2123 esys_unit_teardown),
2124 cmocka_unit_test_setup_teardown(check_SetCommandCodeAuditStatus,
2125 esys_unit_setup, esys_unit_teardown),
2126 cmocka_unit_test_setup_teardown(check_PCR_Extend, esys_unit_setup,
2127 esys_unit_teardown),
2128 cmocka_unit_test_setup_teardown(check_PCR_Event, esys_unit_setup,
2129 esys_unit_teardown),
2130 cmocka_unit_test_setup_teardown(check_PCR_Read, esys_unit_setup,
2131 esys_unit_teardown),
2132 cmocka_unit_test_setup_teardown(check_PCR_Allocate, esys_unit_setup,
2133 esys_unit_teardown),
2134 cmocka_unit_test_setup_teardown(check_PCR_SetAuthPolicy,
2135 esys_unit_setup, esys_unit_teardown),
2136 cmocka_unit_test_setup_teardown(check_PCR_SetAuthValue, esys_unit_setup,
2137 esys_unit_teardown),
2138 cmocka_unit_test_setup_teardown(check_PCR_Reset, esys_unit_setup,
2139 esys_unit_teardown),
2140 cmocka_unit_test_setup_teardown(check_PolicySigned, esys_unit_setup,
2141 esys_unit_teardown),
2142 cmocka_unit_test_setup_teardown(check_PolicySecret, esys_unit_setup,
2143 esys_unit_teardown),
2144 cmocka_unit_test_setup_teardown(check_PolicyTicket, esys_unit_setup,
2145 esys_unit_teardown),
2146 cmocka_unit_test_setup_teardown(check_PolicyOR, esys_unit_setup,
2147 esys_unit_teardown),
2148 cmocka_unit_test_setup_teardown(check_PolicyPCR, esys_unit_setup,
2149 esys_unit_teardown),
2150 cmocka_unit_test_setup_teardown(check_PolicyLocality, esys_unit_setup,
2151 esys_unit_teardown),
2152 cmocka_unit_test_setup_teardown(check_PolicyNV, esys_unit_setup,
2153 esys_unit_teardown),
2154 cmocka_unit_test_setup_teardown(check_PolicyCounterTimer,
2155 esys_unit_setup, esys_unit_teardown),
2156 cmocka_unit_test_setup_teardown(check_PolicyCommandCode,
2157 esys_unit_setup, esys_unit_teardown),
2158 cmocka_unit_test_setup_teardown(check_PolicyPhysicalPresence,
2159 esys_unit_setup, esys_unit_teardown),
2160 cmocka_unit_test_setup_teardown(check_PolicyCpHash, esys_unit_setup,
2161 esys_unit_teardown),
2162 cmocka_unit_test_setup_teardown(check_PolicyNameHash, esys_unit_setup,
2163 esys_unit_teardown),
2164 cmocka_unit_test_setup_teardown(check_PolicyDuplicationSelect,
2165 esys_unit_setup, esys_unit_teardown),
2166 cmocka_unit_test_setup_teardown(check_PolicyAuthorize, esys_unit_setup,
2167 esys_unit_teardown),
2168 cmocka_unit_test_setup_teardown(check_PolicyAuthValue, esys_unit_setup,
2169 esys_unit_teardown),
2170 cmocka_unit_test_setup_teardown(check_PolicyPassword, esys_unit_setup,
2171 esys_unit_teardown),
2172 cmocka_unit_test_setup_teardown(check_PolicyGetDigest, esys_unit_setup,
2173 esys_unit_teardown),
2174 cmocka_unit_test_setup_teardown(check_PolicyNvWritten, esys_unit_setup,
2175 esys_unit_teardown),
2176 cmocka_unit_test_setup_teardown(check_PolicyTemplate, esys_unit_setup,
2177 esys_unit_teardown),
2178 cmocka_unit_test_setup_teardown(check_PolicyAuthorizeNV,
2179 esys_unit_setup, esys_unit_teardown),
2180 cmocka_unit_test_setup_teardown(check_CreatePrimary, esys_unit_setup,
2181 esys_unit_teardown),
2182 cmocka_unit_test_setup_teardown(check_HierarchyControl, esys_unit_setup,
2183 esys_unit_teardown),
2184 cmocka_unit_test_setup_teardown(check_SetPrimaryPolicy, esys_unit_setup,
2185 esys_unit_teardown),
2186 cmocka_unit_test_setup_teardown(check_ChangePPS, esys_unit_setup,
2187 esys_unit_teardown),
2188 cmocka_unit_test_setup_teardown(check_ChangeEPS, esys_unit_setup,
2189 esys_unit_teardown),
2190 cmocka_unit_test_setup_teardown(check_Clear, esys_unit_setup,
2191 esys_unit_teardown),
2192 cmocka_unit_test_setup_teardown(check_ClearControl, esys_unit_setup,
2193 esys_unit_teardown),
2194 cmocka_unit_test_setup_teardown(check_HierarchyChangeAuth,
2195 esys_unit_setup, esys_unit_teardown),
2196 cmocka_unit_test_setup_teardown(check_DictionaryAttackLockReset,
2197 esys_unit_setup, esys_unit_teardown),
2198 cmocka_unit_test_setup_teardown(check_DictionaryAttackParameters,
2199 esys_unit_setup, esys_unit_teardown),
2200 cmocka_unit_test_setup_teardown(check_PP_Commands, esys_unit_setup,
2201 esys_unit_teardown),
2202 cmocka_unit_test_setup_teardown(check_SetAlgorithmSet, esys_unit_setup,
2203 esys_unit_teardown),
2204 cmocka_unit_test_setup_teardown(check_FieldUpgradeStart,
2205 esys_unit_setup, esys_unit_teardown),
2206 cmocka_unit_test_setup_teardown(check_FieldUpgradeData, esys_unit_setup,
2207 esys_unit_teardown),
2208 cmocka_unit_test_setup_teardown(check_FirmwareRead, esys_unit_setup,
2209 esys_unit_teardown),
2210 cmocka_unit_test_setup_teardown(check_ContextSave, esys_unit_setup,
2211 esys_unit_teardown),
2212 cmocka_unit_test_setup_teardown(check_ContextLoad, esys_unit_setup,
2213 esys_unit_teardown),
2214 cmocka_unit_test_setup_teardown(check_FlushContext, esys_unit_setup,
2215 esys_unit_teardown),
2216 cmocka_unit_test_setup_teardown(check_EvictControl, esys_unit_setup,
2217 esys_unit_teardown),
2218 cmocka_unit_test_setup_teardown(check_ReadClock, esys_unit_setup,
2219 esys_unit_teardown),
2220 cmocka_unit_test_setup_teardown(check_ClockSet, esys_unit_setup,
2221 esys_unit_teardown),
2222 cmocka_unit_test_setup_teardown(check_ClockRateAdjust, esys_unit_setup,
2223 esys_unit_teardown),
2224 cmocka_unit_test_setup_teardown(check_GetCapability, esys_unit_setup,
2225 esys_unit_teardown),
2226 cmocka_unit_test_setup_teardown(check_TestParms, esys_unit_setup,
2227 esys_unit_teardown),
2228 cmocka_unit_test_setup_teardown(check_NV_DefineSpace, esys_unit_setup,
2229 esys_unit_teardown),
2230 cmocka_unit_test_setup_teardown(check_NV_UndefineSpace, esys_unit_setup,
2231 esys_unit_teardown),
2232 cmocka_unit_test_setup_teardown(check_NV_UndefineSpaceSpecial,
2233 esys_unit_setup, esys_unit_teardown),
2234 cmocka_unit_test_setup_teardown(check_NV_ReadPublic, esys_unit_setup,
2235 esys_unit_teardown),
2236 cmocka_unit_test_setup_teardown(check_NV_Write, esys_unit_setup,
2237 esys_unit_teardown),
2238 cmocka_unit_test_setup_teardown(check_NV_Increment, esys_unit_setup,
2239 esys_unit_teardown),
2240 cmocka_unit_test_setup_teardown(check_NV_Extend, esys_unit_setup,
2241 esys_unit_teardown),
2242 cmocka_unit_test_setup_teardown(check_NV_SetBits, esys_unit_setup,
2243 esys_unit_teardown),
2244 cmocka_unit_test_setup_teardown(check_NV_WriteLock, esys_unit_setup,
2245 esys_unit_teardown),
2246 cmocka_unit_test_setup_teardown(check_NV_GlobalWriteLock,
2247 esys_unit_setup, esys_unit_teardown),
2248 cmocka_unit_test_setup_teardown(check_NV_Read, esys_unit_setup,
2249 esys_unit_teardown),
2250 cmocka_unit_test_setup_teardown(check_NV_ReadLock, esys_unit_setup,
2251 esys_unit_teardown),
2252 cmocka_unit_test_setup_teardown(check_NV_ChangeAuth, esys_unit_setup,
2253 esys_unit_teardown),
2254 cmocka_unit_test_setup_teardown(check_NV_Certify, esys_unit_setup,
2255 esys_unit_teardown),
2256 cmocka_unit_test_setup_teardown(check_Vendor_TCG_Test, esys_unit_setup,
2257 esys_unit_teardown),
2258 };
2259 return cmocka_run_group_tests(tests, NULL, NULL);
2260 }
2261