1 /********************************************************************************/
2 /* */
3 /* Command Parameter Unmarshaling */
4 /* Written by Ken Goldman */
5 /* IBM Thomas J. Watson Research Center */
6 /* */
7 /* Licenses and Notices */
8 /* */
9 /* 1. Copyright Licenses: */
10 /* */
11 /* - Trusted Computing Group (TCG) grants to the user of the source code in */
12 /* this specification (the "Source Code") a worldwide, irrevocable, */
13 /* nonexclusive, royalty free, copyright license to reproduce, create */
14 /* derivative works, distribute, display and perform the Source Code and */
15 /* derivative works thereof, and to grant others the rights granted herein. */
16 /* */
17 /* - The TCG grants to the user of the other parts of the specification */
18 /* (other than the Source Code) the rights to reproduce, distribute, */
19 /* display, and perform the specification solely for the purpose of */
20 /* developing products based on such documents. */
21 /* */
22 /* 2. Source Code Distribution Conditions: */
23 /* */
24 /* - Redistributions of Source Code must retain the above copyright licenses, */
25 /* this list of conditions and the following disclaimers. */
26 /* */
27 /* - Redistributions in binary form must reproduce the above copyright */
28 /* licenses, this list of conditions and the following disclaimers in the */
29 /* documentation and/or other materials provided with the distribution. */
30 /* */
31 /* 3. Disclaimers: */
32 /* */
33 /* - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF */
34 /* LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH */
35 /* RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES) */
36 /* THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE. */
37 /* Contact TCG Administration (admin@trustedcomputinggroup.org) for */
38 /* information on specification licensing rights available through TCG */
39 /* membership agreements. */
40 /* */
41 /* - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED */
42 /* WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR */
43 /* FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR */
44 /* NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY */
45 /* OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE. */
46 /* */
47 /* - Without limitation, TCG and its members and licensors disclaim all */
48 /* liability, including liability for infringement of any proprietary */
49 /* rights, relating to use of information in this specification and to the */
50 /* implementation of this specification, and TCG disclaims all liability for */
51 /* cost of procurement of substitute goods or services, lost profits, loss */
52 /* of use, loss of data or any incidental, consequential, direct, indirect, */
53 /* or special damages, whether under contract, tort, warranty or otherwise, */
54 /* arising in any way out of use or reliance upon this specification or any */
55 /* information herein. */
56 /* */
57 /* (c) Copyright IBM Corp. and others, 2012 - 2019 */
58 /* */
59 /********************************************************************************/
60
61 /* The TSS using the command parameter unmarshaling to validate caller input parameters before
62 sending them to the TPM.
63
64 It is essentially the same as the TPM side code.
65 */
66
67 #include "Commands_fp.h"
68 #include <ibmtss/Parameters.h>
69
70 #include <ibmtss/Unmarshal_fp.h>
71
72 #ifndef TPM_TSS_NOCMDCHECK
73
74 /*
75 In_Unmarshal - shared by TPM and TSS
76 */
77
78 TPM_RC
Startup_In_Unmarshal(Startup_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])79 Startup_In_Unmarshal(Startup_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
80 {
81 TPM_RC rc = TPM_RC_SUCCESS;
82 handles = handles;
83
84 if (rc == TPM_RC_SUCCESS) {
85 rc = TSS_TPM_SU_Unmarshalu(&target->startupType, buffer, size);
86 if (rc != TPM_RC_SUCCESS) {
87 rc += RC_Startup_startupType;
88 }
89 }
90 return rc;
91 }
92 TPM_RC
Shutdown_In_Unmarshal(Shutdown_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])93 Shutdown_In_Unmarshal(Shutdown_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
94 {
95 TPM_RC rc = TPM_RC_SUCCESS;
96 handles = handles;
97
98 if (rc == TPM_RC_SUCCESS) {
99 rc = TSS_TPM_SU_Unmarshalu(&target->shutdownType, buffer, size);
100 if (rc != TPM_RC_SUCCESS) {
101 rc += RC_Shutdown_shutdownType;
102 }
103 }
104 return rc;
105 }
106 TPM_RC
SelfTest_In_Unmarshal(SelfTest_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])107 SelfTest_In_Unmarshal(SelfTest_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
108 {
109 TPM_RC rc = TPM_RC_SUCCESS;
110 handles = handles;
111
112 if (rc == TPM_RC_SUCCESS) {
113 rc = TSS_TPMI_YES_NO_Unmarshalu(&target->fullTest, buffer, size);
114 if (rc != TPM_RC_SUCCESS) {
115 rc += RC_SelfTest_fullTest;
116 }
117 }
118 return rc;
119 }
120 TPM_RC
IncrementalSelfTest_In_Unmarshal(IncrementalSelfTest_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])121 IncrementalSelfTest_In_Unmarshal(IncrementalSelfTest_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
122 {
123 TPM_RC rc = TPM_RC_SUCCESS;
124 handles = handles;
125
126 if (rc == TPM_RC_SUCCESS) {
127 rc = TSS_TPML_ALG_Unmarshalu(&target->toTest, buffer, size);
128 if (rc != TPM_RC_SUCCESS) {
129 rc += RC_IncrementalSelfTest_toTest;
130 }
131 }
132 return rc;
133 }
134 TPM_RC
StartAuthSession_In_Unmarshal(StartAuthSession_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])135 StartAuthSession_In_Unmarshal(StartAuthSession_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
136 {
137 TPM_RC rc = TPM_RC_SUCCESS;
138
139 if (rc == TPM_RC_SUCCESS) {
140 target->tpmKey = handles[0];
141 target->bind = handles[1];
142 }
143 if (rc == TPM_RC_SUCCESS) {
144 rc = TSS_TPM2B_NONCE_Unmarshalu(&target->nonceCaller, buffer, size);
145 if (rc != TPM_RC_SUCCESS) {
146 rc += RC_StartAuthSession_nonceCaller;
147 }
148 }
149 if (rc == TPM_RC_SUCCESS) {
150 rc = TSS_TPM2B_ENCRYPTED_SECRET_Unmarshalu(&target->encryptedSalt, buffer, size);
151 if (rc != TPM_RC_SUCCESS) {
152 rc += RC_StartAuthSession_encryptedSalt;
153 }
154 }
155 if (rc == TPM_RC_SUCCESS) {
156 rc = TSS_TPM_SE_Unmarshalu(&target->sessionType, buffer, size);
157 if (rc != TPM_RC_SUCCESS) {
158 rc += RC_StartAuthSession_sessionType;
159 }
160 }
161 if (rc == TPM_RC_SUCCESS) {
162 rc = TSS_TPMT_SYM_DEF_Unmarshalu(&target->symmetric, buffer, size, YES);
163 if (rc != TPM_RC_SUCCESS) {
164 rc += RC_StartAuthSession_symmetric;
165 }
166 }
167 if (rc == TPM_RC_SUCCESS) {
168 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->authHash, buffer, size, NO);
169 if (rc != TPM_RC_SUCCESS) {
170 rc += RC_StartAuthSession_authHash;
171 }
172 }
173 return rc;
174 }
175 TPM_RC
PolicyRestart_In_Unmarshal(PolicyRestart_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])176 PolicyRestart_In_Unmarshal(PolicyRestart_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
177 {
178 TPM_RC rc = TPM_RC_SUCCESS;
179 buffer = buffer;
180 size = size;
181
182 if (rc == TPM_RC_SUCCESS) {
183 target->sessionHandle = handles[0];
184 }
185 return rc;
186 }
187 TPM_RC
Create_In_Unmarshal(Create_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])188 Create_In_Unmarshal(Create_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
189 {
190 TPM_RC rc = TPM_RC_SUCCESS;
191
192 if (rc == TPM_RC_SUCCESS) {
193 target->parentHandle = handles[0];
194 }
195 if (rc == TPM_RC_SUCCESS) {
196 rc = TSS_TPM2B_SENSITIVE_CREATE_Unmarshalu(&target->inSensitive, buffer, size);
197 if (rc != TPM_RC_SUCCESS) {
198 rc += RC_Create_inSensitive;
199 }
200 }
201 if (rc == TPM_RC_SUCCESS) {
202 rc = TSS_TPM2B_PUBLIC_Unmarshalu(&target->inPublic, buffer, size, NO);
203 if (rc != TPM_RC_SUCCESS) {
204 rc += RC_Create_inPublic;
205 }
206 }
207 if (rc == TPM_RC_SUCCESS) {
208 rc = TSS_TPM2B_DATA_Unmarshalu(&target->outsideInfo, buffer, size);
209 if (rc != TPM_RC_SUCCESS) {
210 rc += RC_Create_outsideInfo;
211 }
212 }
213 if (rc == TPM_RC_SUCCESS) {
214 rc = TSS_TPML_PCR_SELECTION_Unmarshalu(&target->creationPCR, buffer, size);
215 if (rc != TPM_RC_SUCCESS) {
216 rc += RC_Create_creationPCR;
217 }
218 }
219 return rc;
220 }
221 TPM_RC
Load_In_Unmarshal(Load_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])222 Load_In_Unmarshal(Load_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
223 {
224 TPM_RC rc = TPM_RC_SUCCESS;
225
226 if (rc == TPM_RC_SUCCESS) {
227 target->parentHandle = handles[0];
228 }
229 if (rc == TPM_RC_SUCCESS) {
230 rc = TSS_TPM2B_PRIVATE_Unmarshalu(&target->inPrivate, buffer, size);
231 if (rc != TPM_RC_SUCCESS) {
232 rc += RC_Load_inPrivate;
233 }
234 }
235 if (rc == TPM_RC_SUCCESS) {
236 rc = TSS_TPM2B_PUBLIC_Unmarshalu(&target->inPublic, buffer, size, NO);
237 if (rc != TPM_RC_SUCCESS) {
238 rc += RC_Load_inPublic;
239 }
240 }
241 return rc;
242 }
243 TPM_RC
LoadExternal_In_Unmarshal(LoadExternal_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])244 LoadExternal_In_Unmarshal(LoadExternal_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
245 {
246 TPM_RC rc = TPM_RC_SUCCESS;
247 handles = handles;
248
249 if (rc == TPM_RC_SUCCESS) {
250 rc = TSS_TPM2B_SENSITIVE_Unmarshalu(&target->inPrivate, buffer, size);
251 if (rc != TPM_RC_SUCCESS) {
252 rc += RC_LoadExternal_inPrivate;
253 }
254 }
255 if (rc == TPM_RC_SUCCESS) {
256 rc = TSS_TPM2B_PUBLIC_Unmarshalu(&target->inPublic, buffer, size, YES);
257 if (rc != TPM_RC_SUCCESS) {
258 rc += RC_LoadExternal_inPublic;
259 }
260 }
261 if (rc == TPM_RC_SUCCESS) {
262 rc = TSS_TPMI_RH_HIERARCHY_Unmarshalu(&target->hierarchy, buffer, size, YES);
263 if (rc != TPM_RC_SUCCESS) {
264 rc += RC_LoadExternal_hierarchy;
265 }
266 }
267 return rc;
268 }
269
270 TPM_RC
ReadPublic_In_Unmarshal(ReadPublic_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])271 ReadPublic_In_Unmarshal(ReadPublic_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
272 {
273 TPM_RC rc = TPM_RC_SUCCESS;
274 buffer = buffer;
275 size = size;
276
277 if (rc == TPM_RC_SUCCESS) {
278 target->objectHandle = handles[0];
279 }
280 return rc;
281 }
282 TPM_RC
ActivateCredential_In_Unmarshal(ActivateCredential_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])283 ActivateCredential_In_Unmarshal(ActivateCredential_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
284 {
285 TPM_RC rc = TPM_RC_SUCCESS;
286
287 if (rc == TPM_RC_SUCCESS) {
288 target->activateHandle = handles[0];
289 target->keyHandle = handles[1];
290 }
291 if (rc == TPM_RC_SUCCESS) {
292 rc = TSS_TPM2B_ID_OBJECT_Unmarshalu(&target->credentialBlob, buffer, size);
293 if (rc != TPM_RC_SUCCESS) {
294 rc += RC_ActivateCredential_credentialBlob;
295 }
296 }
297 if (rc == TPM_RC_SUCCESS) {
298 rc = TSS_TPM2B_ENCRYPTED_SECRET_Unmarshalu(&target->secret, buffer, size);
299 if (rc != TPM_RC_SUCCESS) {
300 rc += RC_ActivateCredential_secret;
301 }
302 }
303 return rc;
304 }
305 TPM_RC
MakeCredential_In_Unmarshal(MakeCredential_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])306 MakeCredential_In_Unmarshal(MakeCredential_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
307 {
308 TPM_RC rc = TPM_RC_SUCCESS;
309
310 if (rc == TPM_RC_SUCCESS) {
311 target->handle = handles[0];
312 }
313 if (rc == TPM_RC_SUCCESS) {
314 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->credential, buffer, size);
315 if (rc != TPM_RC_SUCCESS) {
316 rc += RC_MakeCredential_credential;
317 }
318 }
319 if (rc == TPM_RC_SUCCESS) {
320 rc = TSS_TPM2B_NAME_Unmarshalu(&target->objectName, buffer, size);
321 if (rc != TPM_RC_SUCCESS) {
322 rc += RC_MakeCredential_objectName;
323 }
324 }
325 return rc;
326 }
327 TPM_RC
Unseal_In_Unmarshal(Unseal_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])328 Unseal_In_Unmarshal(Unseal_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
329 {
330 TPM_RC rc = TPM_RC_SUCCESS;
331 buffer = buffer;
332 size = size;
333
334 if (rc == TPM_RC_SUCCESS) {
335 target->itemHandle = handles[0];
336 }
337 return rc;
338 }
339 TPM_RC
ObjectChangeAuth_In_Unmarshal(ObjectChangeAuth_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])340 ObjectChangeAuth_In_Unmarshal(ObjectChangeAuth_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
341 {
342 TPM_RC rc = TPM_RC_SUCCESS;
343
344 if (rc == TPM_RC_SUCCESS) {
345 target->objectHandle = handles[0];
346 target->parentHandle = handles[1];
347 }
348 if (rc == TPM_RC_SUCCESS) {
349 rc = TSS_TPM2B_AUTH_Unmarshalu(&target->newAuth, buffer, size);
350 }
351 return rc;
352 }
353 TPM_RC
CreateLoaded_In_Unmarshal(CreateLoaded_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])354 CreateLoaded_In_Unmarshal(CreateLoaded_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
355 {
356 TPM_RC rc = TPM_RC_SUCCESS;
357
358 if (rc == TPM_RC_SUCCESS) {
359 target->parentHandle = handles[0];
360 }
361 if (rc == TPM_RC_SUCCESS) {
362 rc = TSS_TPM2B_SENSITIVE_CREATE_Unmarshalu(&target->inSensitive, buffer, size);
363 if (rc != TPM_RC_SUCCESS) {
364 rc += RC_Create_inSensitive;
365 }
366 }
367 if (rc == TPM_RC_SUCCESS) {
368 rc = TSS_TPM2B_TEMPLATE_Unmarshalu(&target->inPublic, buffer, size);
369 if (rc != TPM_RC_SUCCESS) {
370 rc += RC_CreateLoaded_inPublic;
371 }
372 }
373 return rc;
374 }
375 TPM_RC
Duplicate_In_Unmarshal(Duplicate_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])376 Duplicate_In_Unmarshal(Duplicate_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
377 {
378 TPM_RC rc = TPM_RC_SUCCESS;
379
380 if (rc == TPM_RC_SUCCESS) {
381 target->objectHandle = handles[0];
382 target->newParentHandle = handles[1];
383 }
384 if (rc == TPM_RC_SUCCESS) {
385 rc = TSS_TPM2B_DATA_Unmarshalu(&target->encryptionKeyIn, buffer, size);
386 if (rc != TPM_RC_SUCCESS) {
387 rc += RC_Duplicate_encryptionKeyIn;
388 }
389 }
390 if (rc == TPM_RC_SUCCESS) {
391 rc = TSS_TPMT_SYM_DEF_OBJECT_Unmarshalu(&target->symmetricAlg, buffer, size, YES);
392 if (rc != TPM_RC_SUCCESS) {
393 rc += RC_Duplicate_symmetricAlg;
394 }
395 }
396 return rc;
397 }
398 TPM_RC
Rewrap_In_Unmarshal(Rewrap_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])399 Rewrap_In_Unmarshal(Rewrap_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
400 {
401 TPM_RC rc = TPM_RC_SUCCESS;
402
403 if (rc == TPM_RC_SUCCESS) {
404 target->oldParent = handles[0];
405 target->newParent = handles[1];
406 }
407 if (rc == TPM_RC_SUCCESS) {
408 rc = TSS_TPM2B_PRIVATE_Unmarshalu(&target->inDuplicate, buffer, size);
409 if (rc != TPM_RC_SUCCESS) {
410 rc += RC_Rewrap_inDuplicate;
411 }
412 }
413 if (rc == TPM_RC_SUCCESS) {
414 rc = TSS_TPM2B_NAME_Unmarshalu(&target->name, buffer, size);
415 if (rc != TPM_RC_SUCCESS) {
416 rc += RC_Rewrap_name;
417 }
418 }
419 if (rc == TPM_RC_SUCCESS) {
420 rc = TSS_TPM2B_ENCRYPTED_SECRET_Unmarshalu(&target->inSymSeed, buffer, size);
421 if (rc != TPM_RC_SUCCESS) {
422 rc += RC_Rewrap_inSymSeed;
423 }
424 }
425 return rc;
426 }
427 TPM_RC
Import_In_Unmarshal(Import_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])428 Import_In_Unmarshal(Import_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
429 {
430 TPM_RC rc = TPM_RC_SUCCESS;
431
432 if (rc == TPM_RC_SUCCESS) {
433 target->parentHandle = handles[0];
434 }
435 if (rc == TPM_RC_SUCCESS) {
436 rc = TSS_TPM2B_DATA_Unmarshalu(&target->encryptionKey, buffer, size);
437 }
438 if (rc == TPM_RC_SUCCESS) {
439 rc = TSS_TPM2B_PUBLIC_Unmarshalu(&target->objectPublic, buffer, size, NO);
440 if (rc != TPM_RC_SUCCESS) {
441 rc += RC_Import_objectPublic;
442 }
443 }
444 if (rc == TPM_RC_SUCCESS) {
445 rc = TSS_TPM2B_PRIVATE_Unmarshalu(&target->duplicate, buffer, size);
446 if (rc != TPM_RC_SUCCESS) {
447 rc += RC_Import_duplicate;
448 }
449 }
450 if (rc == TPM_RC_SUCCESS) {
451 rc = TSS_TPM2B_ENCRYPTED_SECRET_Unmarshalu(&target->inSymSeed, buffer, size);
452 if (rc != TPM_RC_SUCCESS) {
453 rc += RC_Import_inSymSeed;
454 }
455 }
456 if (rc == TPM_RC_SUCCESS) {
457 rc = TSS_TPMT_SYM_DEF_OBJECT_Unmarshalu(&target->symmetricAlg, buffer, size, YES);
458 if (rc != TPM_RC_SUCCESS) {
459 rc += RC_Import_symmetricAlg;
460 }
461 }
462 return rc;
463 }
464 TPM_RC
RSA_Encrypt_In_Unmarshal(RSA_Encrypt_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])465 RSA_Encrypt_In_Unmarshal(RSA_Encrypt_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
466 {
467 TPM_RC rc = TPM_RC_SUCCESS;
468
469 if (rc == TPM_RC_SUCCESS) {
470 target->keyHandle = handles[0];
471 }
472 if (rc == TPM_RC_SUCCESS) {
473 rc = TSS_TPM2B_PUBLIC_KEY_RSA_Unmarshalu(&target->message, buffer, size);
474 if (rc != TPM_RC_SUCCESS) {
475 rc += RC_RSA_Encrypt_message;
476 }
477 }
478 if (rc == TPM_RC_SUCCESS) {
479 rc = TSS_TPMT_RSA_DECRYPT_Unmarshalu(&target->inScheme, buffer, size, YES);
480 if (rc != TPM_RC_SUCCESS) {
481 rc += RC_RSA_Encrypt_inScheme;
482 }
483 }
484 if (rc == TPM_RC_SUCCESS) {
485 rc = TSS_TPM2B_DATA_Unmarshalu(&target->label, buffer, size);
486 if (rc != TPM_RC_SUCCESS) {
487 rc += RC_RSA_Encrypt_label;
488 }
489 }
490 return rc;
491 }
492 TPM_RC
RSA_Decrypt_In_Unmarshal(RSA_Decrypt_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])493 RSA_Decrypt_In_Unmarshal(RSA_Decrypt_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
494 {
495 TPM_RC rc = TPM_RC_SUCCESS;
496
497 if (rc == TPM_RC_SUCCESS) {
498 target->keyHandle = handles[0];
499 }
500 if (rc == TPM_RC_SUCCESS) {
501 rc = TSS_TPM2B_PUBLIC_KEY_RSA_Unmarshalu(&target->cipherText, buffer, size);
502 if (rc != TPM_RC_SUCCESS) {
503 rc += RC_RSA_Decrypt_cipherText;
504 }
505 }
506 if (rc == TPM_RC_SUCCESS) {
507 rc = TSS_TPMT_RSA_DECRYPT_Unmarshalu(&target->inScheme, buffer, size, YES);
508 if (rc != TPM_RC_SUCCESS) {
509 rc += RC_RSA_Decrypt_inScheme;
510 }
511 }
512 if (rc == TPM_RC_SUCCESS) {
513 rc = TSS_TPM2B_DATA_Unmarshalu(&target->label, buffer, size);
514 if (rc != TPM_RC_SUCCESS) {
515 rc += RC_RSA_Decrypt_label;
516 }
517 }
518 return rc;
519 }
520 TPM_RC
ECDH_KeyGen_In_Unmarshal(ECDH_KeyGen_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])521 ECDH_KeyGen_In_Unmarshal(ECDH_KeyGen_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
522 {
523 TPM_RC rc = TPM_RC_SUCCESS;
524 buffer = buffer;
525 size = size;
526
527 if (rc == TPM_RC_SUCCESS) {
528 target->keyHandle = handles[0];
529 }
530 return rc;
531 }
532 TPM_RC
ECDH_ZGen_In_Unmarshal(ECDH_ZGen_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])533 ECDH_ZGen_In_Unmarshal(ECDH_ZGen_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
534 {
535 TPM_RC rc = TPM_RC_SUCCESS;
536
537 if (rc == TPM_RC_SUCCESS) {
538 target->keyHandle = handles[0];
539 }
540 if (rc == TPM_RC_SUCCESS) {
541 rc = TSS_TPM2B_ECC_POINT_Unmarshalu(&target->inPoint, buffer, size);
542 if (rc != TPM_RC_SUCCESS) {
543 rc += RC_ECDH_ZGen_inPoint;
544 }
545 }
546 return rc;
547 }
548 TPM_RC
ECC_Parameters_In_Unmarshal(ECC_Parameters_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])549 ECC_Parameters_In_Unmarshal(ECC_Parameters_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
550 {
551 TPM_RC rc = TPM_RC_SUCCESS;
552 handles = handles;
553
554 if (rc == TPM_RC_SUCCESS) {
555 rc = TSS_TPMI_ECC_CURVE_Unmarshalu(&target->curveID, buffer, size);
556 if (rc != TPM_RC_SUCCESS) {
557 rc += RC_ECC_Parameters_curveID;
558 }
559 }
560 return rc;
561 }
562 TPM_RC
ZGen_2Phase_In_Unmarshal(ZGen_2Phase_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])563 ZGen_2Phase_In_Unmarshal(ZGen_2Phase_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
564 {
565 TPM_RC rc = TPM_RC_SUCCESS;
566
567 if (rc == TPM_RC_SUCCESS) {
568 target->keyA = handles[0];
569 }
570 if (rc == TPM_RC_SUCCESS) {
571 rc = TSS_TPM2B_ECC_POINT_Unmarshalu(&target->inQsB, buffer, size);
572 if (rc != TPM_RC_SUCCESS) {
573 rc += RC_ZGen_2Phase_inQsB;
574 }
575 }
576 if (rc == TPM_RC_SUCCESS) {
577 rc = TSS_TPM2B_ECC_POINT_Unmarshalu(&target->inQeB, buffer, size);
578 if (rc != TPM_RC_SUCCESS) {
579 rc += RC_ZGen_2Phase_inQeB;
580 }
581 }
582 if (rc == TPM_RC_SUCCESS) {
583 rc = TSS_TPMI_ECC_KEY_EXCHANGE_Unmarshalu(&target->inScheme, buffer, size, NO);
584 if (rc != TPM_RC_SUCCESS) {
585 rc += RC_ZGen_2Phase_inScheme;
586 }
587 }
588 if (rc == TPM_RC_SUCCESS) {
589 rc = TSS_UINT16_Unmarshalu(&target->counter, buffer, size);
590 if (rc != TPM_RC_SUCCESS) {
591 rc += RC_ZGen_2Phase_counter;
592 }
593 }
594 return rc;
595 }
596 TPM_RC
EncryptDecrypt_In_Unmarshal(EncryptDecrypt_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])597 EncryptDecrypt_In_Unmarshal(EncryptDecrypt_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
598 {
599 TPM_RC rc = TPM_RC_SUCCESS;
600
601 if (rc == TPM_RC_SUCCESS) {
602 target->keyHandle = handles[0];
603 }
604 if (rc == TPM_RC_SUCCESS) {
605 rc = TSS_TPMI_YES_NO_Unmarshalu(&target->decrypt, buffer, size);
606 if (rc != TPM_RC_SUCCESS) {
607 rc += RC_EncryptDecrypt_decrypt;
608 }
609 }
610 if (rc == TPM_RC_SUCCESS) {
611 rc = TSS_TPMI_ALG_SYM_MODE_Unmarshalu(&target->mode, buffer, size, YES);
612 if (rc != TPM_RC_SUCCESS) {
613 rc += RC_EncryptDecrypt_mode;
614 }
615 }
616 if (rc == TPM_RC_SUCCESS) {
617 rc = TSS_TPM2B_IV_Unmarshalu(&target->ivIn, buffer, size);
618 if (rc != TPM_RC_SUCCESS) {
619 rc += RC_EncryptDecrypt_ivIn;
620 }
621 }
622 if (rc == TPM_RC_SUCCESS) {
623 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->inData, buffer, size);
624 if (rc != TPM_RC_SUCCESS) {
625 rc += RC_EncryptDecrypt_inData;
626 }
627 }
628 return rc;
629 }
630 TPM_RC
EncryptDecrypt2_In_Unmarshal(EncryptDecrypt2_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])631 EncryptDecrypt2_In_Unmarshal(EncryptDecrypt2_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
632 {
633 TPM_RC rc = TPM_RC_SUCCESS;
634
635 if (rc == TPM_RC_SUCCESS) {
636 target->keyHandle = handles[0];
637 }
638 if (rc == TPM_RC_SUCCESS) {
639 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->inData, buffer, size);
640 if (rc != TPM_RC_SUCCESS) {
641 rc += RC_EncryptDecrypt2_inData;
642 }
643 }
644 if (rc == TPM_RC_SUCCESS) {
645 rc = TSS_TPMI_YES_NO_Unmarshalu(&target->decrypt, buffer, size);
646 if (rc != TPM_RC_SUCCESS) {
647 rc += RC_EncryptDecrypt2_decrypt;
648 }
649 }
650 if (rc == TPM_RC_SUCCESS) {
651 rc = TSS_TPMI_ALG_SYM_MODE_Unmarshalu(&target->mode, buffer, size, YES);
652 if (rc != TPM_RC_SUCCESS) {
653 rc += RC_EncryptDecrypt2_mode;
654 }
655 }
656 if (rc == TPM_RC_SUCCESS) {
657 rc = TSS_TPM2B_IV_Unmarshalu(&target->ivIn, buffer, size);
658 if (rc != TPM_RC_SUCCESS) {
659 rc += RC_EncryptDecrypt2_ivIn;
660 }
661 }
662 return rc;
663 }
664 TPM_RC
Hash_In_Unmarshal(Hash_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])665 Hash_In_Unmarshal(Hash_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
666 {
667 TPM_RC rc = TPM_RC_SUCCESS;
668 handles = handles;
669
670 if (rc == TPM_RC_SUCCESS) {
671 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->data, buffer, size);
672 if (rc != TPM_RC_SUCCESS) {
673 rc += RC_Hash_data;
674 }
675 }
676 if (rc == TPM_RC_SUCCESS) {
677 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->hashAlg, buffer, size, NO);
678 if (rc != TPM_RC_SUCCESS) {
679 rc += RC_Hash_hashAlg;
680 }
681 }
682 if (rc == TPM_RC_SUCCESS) {
683 rc = TSS_TPMI_RH_HIERARCHY_Unmarshalu(&target->hierarchy, buffer, size, YES);
684 if (rc != TPM_RC_SUCCESS) {
685 rc += RC_Hash_hierarchy;
686 }
687 }
688 return rc;
689 }
690 TPM_RC
HMAC_In_Unmarshal(HMAC_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])691 HMAC_In_Unmarshal(HMAC_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
692 {
693 TPM_RC rc = TPM_RC_SUCCESS;
694
695 if (rc == TPM_RC_SUCCESS) {
696 target->handle = handles[0];
697 }
698 if (rc == TPM_RC_SUCCESS) {
699 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->buffer, buffer, size);
700 if (rc != TPM_RC_SUCCESS) {
701 rc += RC_HMAC_buffer;
702 }
703 }
704 if (rc == TPM_RC_SUCCESS) {
705 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->hashAlg, buffer, size, YES);
706 if (rc != TPM_RC_SUCCESS) {
707 rc += RC_HMAC_hashAlg;
708 }
709 }
710 return rc;
711 }
712 TPM_RC
GetRandom_In_Unmarshal(GetRandom_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])713 GetRandom_In_Unmarshal(GetRandom_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
714 {
715 TPM_RC rc = TPM_RC_SUCCESS;
716 handles = handles;
717
718 if (rc == TPM_RC_SUCCESS) {
719 rc = TSS_UINT16_Unmarshalu(&target->bytesRequested, buffer, size);
720 if (rc != TPM_RC_SUCCESS) {
721 rc += RC_GetRandom_bytesRequested;
722 }
723 }
724 return rc;
725 }
726 TPM_RC
StirRandom_In_Unmarshal(StirRandom_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])727 StirRandom_In_Unmarshal(StirRandom_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
728 {
729 TPM_RC rc = TPM_RC_SUCCESS;
730 handles = handles;
731
732 if (rc == TPM_RC_SUCCESS) {
733 rc = TSS_TPM2B_SENSITIVE_DATA_Unmarshalu(&target->inData, buffer, size);
734 if (rc != TPM_RC_SUCCESS) {
735 rc += RC_StirRandom_inData;
736 }
737 }
738 return rc;
739 }
740 TPM_RC
HMAC_Start_In_Unmarshal(HMAC_Start_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])741 HMAC_Start_In_Unmarshal(HMAC_Start_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
742 {
743 TPM_RC rc = TPM_RC_SUCCESS;
744
745 if (rc == TPM_RC_SUCCESS) {
746 target->handle = handles[0];
747 }
748 if (rc == TPM_RC_SUCCESS) {
749 rc = TSS_TPM2B_AUTH_Unmarshalu(&target->auth, buffer, size);
750 if (rc != TPM_RC_SUCCESS) {
751 rc += RC_HMAC_Start_auth;
752 }
753 }
754 if (rc == TPM_RC_SUCCESS) {
755 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->hashAlg, buffer, size, YES);
756 if (rc != TPM_RC_SUCCESS) {
757 rc += RC_HMAC_Start_hashAlg;
758 }
759 }
760 return rc;
761 }
762 TPM_RC
HashSequenceStart_In_Unmarshal(HashSequenceStart_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])763 HashSequenceStart_In_Unmarshal(HashSequenceStart_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
764 {
765 TPM_RC rc = TPM_RC_SUCCESS;
766 handles = handles;
767
768 if (rc == TPM_RC_SUCCESS) {
769 rc = TSS_TPM2B_AUTH_Unmarshalu(&target->auth, buffer, size);
770 if (rc != TPM_RC_SUCCESS) {
771 rc += RC_HashSequenceStart_auth;
772 }
773 }
774 if (rc == TPM_RC_SUCCESS) {
775 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->hashAlg, buffer, size, YES);
776 if (rc != TPM_RC_SUCCESS) {
777 rc += RC_HashSequenceStart_hashAlg;
778 }
779 }
780 return rc;
781 }
782 TPM_RC
SequenceUpdate_In_Unmarshal(SequenceUpdate_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])783 SequenceUpdate_In_Unmarshal(SequenceUpdate_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
784 {
785 TPM_RC rc = TPM_RC_SUCCESS;
786 buffer = buffer;
787 size = size;
788
789 if (rc == TPM_RC_SUCCESS) {
790 target->sequenceHandle = handles[0];
791 }
792 if (rc == TPM_RC_SUCCESS) {
793 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->buffer, buffer, size);
794 if (rc != TPM_RC_SUCCESS) {
795 rc += RC_SequenceUpdate_buffer;
796 }
797 }
798 return rc;
799 }
800 TPM_RC
SequenceComplete_In_Unmarshal(SequenceComplete_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])801 SequenceComplete_In_Unmarshal(SequenceComplete_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
802 {
803 TPM_RC rc = TPM_RC_SUCCESS;
804
805 if (rc == TPM_RC_SUCCESS) {
806 target->sequenceHandle = handles[0];
807 }
808 if (rc == TPM_RC_SUCCESS) {
809 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->buffer, buffer, size);
810 if (rc != TPM_RC_SUCCESS) {
811 rc += RC_SequenceComplete_buffer;
812 }
813 }
814 if (rc == TPM_RC_SUCCESS) {
815 rc = TSS_TPMI_RH_HIERARCHY_Unmarshalu(&target->hierarchy, buffer, size, YES);
816 if (rc != TPM_RC_SUCCESS) {
817 rc += RC_SequenceComplete_hierarchy;
818 }
819 }
820 return rc;
821 }
822 TPM_RC
EventSequenceComplete_In_Unmarshal(EventSequenceComplete_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])823 EventSequenceComplete_In_Unmarshal(EventSequenceComplete_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
824 {
825 TPM_RC rc = TPM_RC_SUCCESS;
826
827 if (rc == TPM_RC_SUCCESS) {
828 target->pcrHandle = handles[0];
829 target->sequenceHandle = handles[1];
830 }
831 if (rc == TPM_RC_SUCCESS) {
832 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->buffer, buffer, size);
833 if (rc != TPM_RC_SUCCESS) {
834 rc += RC_EventSequenceComplete_buffer;
835 }
836 }
837 return rc;
838 }
839 TPM_RC
Certify_In_Unmarshal(Certify_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])840 Certify_In_Unmarshal(Certify_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
841 {
842 TPM_RC rc = TPM_RC_SUCCESS;
843
844 if (rc == TPM_RC_SUCCESS) {
845 target->objectHandle = handles[0];
846 target->signHandle = handles[1];
847 }
848 if (rc == TPM_RC_SUCCESS) {
849 rc = TSS_TPM2B_DATA_Unmarshalu(&target->qualifyingData, buffer, size);
850 if (rc != TPM_RC_SUCCESS) {
851 rc += RC_Certify_qualifyingData;
852 }
853 }
854 if (rc == TPM_RC_SUCCESS) {
855 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
856 if (rc != TPM_RC_SUCCESS) {
857 rc += RC_Certify_inScheme;
858 }
859 }
860 return rc;
861 }
862 TPM_RC
CertifyX509_In_Unmarshal(CertifyX509_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])863 CertifyX509_In_Unmarshal(CertifyX509_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
864 {
865 TPM_RC rc = TPM_RC_SUCCESS;
866
867 if (rc == TPM_RC_SUCCESS) {
868 target->objectHandle = handles[0];
869 target->signHandle = handles[1];
870 }
871 if (rc == TPM_RC_SUCCESS) {
872 rc = TSS_TPM2B_DATA_Unmarshalu(&target->reserved, buffer, size);
873 if (rc != TPM_RC_SUCCESS) {
874 rc += RC_CertifyX509_reserved;
875 }
876 }
877 if (rc == TPM_RC_SUCCESS) {
878 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
879 if (rc != TPM_RC_SUCCESS) {
880 rc += RC_CertifyX509_inScheme;
881 }
882 }
883 if (rc == TPM_RC_SUCCESS) {
884 rc = TSS_TPM2B_MAX_BUFFER_Unmarshalu(&target->partialCertificate, buffer, size);
885 if (rc != TPM_RC_SUCCESS) {
886 rc += RC_CertifyX509_partialCertificate;
887 }
888 }
889 return rc;
890 }
891 TPM_RC
CertifyCreation_In_Unmarshal(CertifyCreation_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])892 CertifyCreation_In_Unmarshal(CertifyCreation_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
893 {
894 TPM_RC rc = TPM_RC_SUCCESS;
895
896 if (rc == TPM_RC_SUCCESS) {
897 target->signHandle = handles[0];
898 target->objectHandle = handles[1];
899 }
900 if (rc == TPM_RC_SUCCESS) {
901 rc = TSS_TPM2B_DATA_Unmarshalu(&target->qualifyingData, buffer, size);
902 if (rc != TPM_RC_SUCCESS) {
903 rc += RC_CertifyCreation_creationHash;
904 }
905 }
906 if (rc == TPM_RC_SUCCESS) {
907 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->creationHash, buffer, size);
908 if (rc != TPM_RC_SUCCESS) {
909 rc += RC_CertifyCreation_creationHash;
910 }
911 }
912 if (rc == TPM_RC_SUCCESS) {
913 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
914 if (rc != TPM_RC_SUCCESS) {
915 rc += RC_CertifyCreation_inScheme;
916 }
917 }
918 if (rc == TPM_RC_SUCCESS) {
919 rc = TSS_TPMT_TK_CREATION_Unmarshalu(&target->creationTicket, buffer, size);
920 if (rc != TPM_RC_SUCCESS) {
921 rc += RC_CertifyCreation_creationTicket;
922 }
923 }
924 return rc;
925 }
926 TPM_RC
Quote_In_Unmarshal(Quote_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])927 Quote_In_Unmarshal(Quote_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
928 {
929 TPM_RC rc = TPM_RC_SUCCESS;
930
931 if (rc == TPM_RC_SUCCESS) {
932 target->signHandle = handles[0];
933 }
934 if (rc == TPM_RC_SUCCESS) {
935 rc = TSS_TPM2B_DATA_Unmarshalu(&target->qualifyingData, buffer, size);
936 if (rc != TPM_RC_SUCCESS) {
937 rc += RC_Quote_qualifyingData;
938 }
939 }
940 if (rc == TPM_RC_SUCCESS) {
941 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
942 if (rc != TPM_RC_SUCCESS) {
943 rc += RC_Quote_inScheme;
944 }
945 }
946 if (rc == TPM_RC_SUCCESS) {
947 rc = TSS_TPML_PCR_SELECTION_Unmarshalu(&target->PCRselect, buffer, size);
948 if (rc != TPM_RC_SUCCESS) {
949 rc += RC_Quote_PCRselect;
950 }
951 }
952 return rc;
953 }
954 TPM_RC
GetSessionAuditDigest_In_Unmarshal(GetSessionAuditDigest_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])955 GetSessionAuditDigest_In_Unmarshal(GetSessionAuditDigest_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
956 {
957 TPM_RC rc = TPM_RC_SUCCESS;
958
959 if (rc == TPM_RC_SUCCESS) {
960 target->privacyAdminHandle = handles[0];
961 target->signHandle = handles[1];
962 target->sessionHandle = handles[2];
963 }
964 if (rc == TPM_RC_SUCCESS) {
965 rc = TSS_TPM2B_DATA_Unmarshalu(&target->qualifyingData, buffer, size);
966 if (rc != TPM_RC_SUCCESS) {
967 rc += RC_GetSessionAuditDigest_qualifyingData;
968 }
969 }
970 if (rc == TPM_RC_SUCCESS) {
971 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
972 if (rc != TPM_RC_SUCCESS) {
973 rc += RC_GetSessionAuditDigest_inScheme;
974 }
975 }
976 return rc;
977 }
978 TPM_RC
GetCommandAuditDigest_In_Unmarshal(GetCommandAuditDigest_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])979 GetCommandAuditDigest_In_Unmarshal(GetCommandAuditDigest_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
980 {
981 TPM_RC rc = TPM_RC_SUCCESS;
982
983 if (rc == TPM_RC_SUCCESS) {
984 target->privacyHandle = handles[0];
985 target->signHandle = handles[1];
986 }
987 if (rc == TPM_RC_SUCCESS) {
988 rc = TSS_TPM2B_DATA_Unmarshalu(&target->qualifyingData, buffer, size);
989 if (rc != TPM_RC_SUCCESS) {
990 rc += RC_GetCommandAuditDigest_qualifyingData;
991 }
992 }
993 if (rc == TPM_RC_SUCCESS) {
994 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
995 if (rc != TPM_RC_SUCCESS) {
996 rc += RC_GetCommandAuditDigest_inScheme;
997 }
998 }
999 return rc;
1000 }
1001 TPM_RC
GetTime_In_Unmarshal(GetTime_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1002 GetTime_In_Unmarshal(GetTime_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1003 {
1004 TPM_RC rc = TPM_RC_SUCCESS;
1005
1006 if (rc == TPM_RC_SUCCESS) {
1007 target->privacyAdminHandle = handles[0];
1008 target->signHandle = handles[1];
1009 }
1010 if (rc == TPM_RC_SUCCESS) {
1011 rc = TSS_TPM2B_DATA_Unmarshalu(&target->qualifyingData, buffer, size);
1012 if (rc != TPM_RC_SUCCESS) {
1013 rc += RC_GetTime_qualifyingData;
1014 }
1015 }
1016 if (rc == TPM_RC_SUCCESS) {
1017 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
1018 if (rc != TPM_RC_SUCCESS) {
1019 rc += RC_GetTime_inScheme;
1020 }
1021 }
1022 return rc;
1023 }
1024 TPM_RC
Commit_In_Unmarshal(Commit_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1025 Commit_In_Unmarshal(Commit_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1026 {
1027 TPM_RC rc = TPM_RC_SUCCESS;
1028
1029 if (rc == TPM_RC_SUCCESS) {
1030 target->signHandle = handles[0];
1031 }
1032 if (rc == TPM_RC_SUCCESS) {
1033 rc = TSS_TPM2B_ECC_POINT_Unmarshalu(&target->P1, buffer, size);
1034 if (rc != TPM_RC_SUCCESS) {
1035 rc += RC_Commit_P1;
1036 }
1037 }
1038 if (rc == TPM_RC_SUCCESS) {
1039 rc = TSS_TPM2B_SENSITIVE_DATA_Unmarshalu(&target->s2, buffer, size);
1040 if (rc != TPM_RC_SUCCESS) {
1041 rc += RC_Commit_s2;
1042 }
1043 }
1044 if (rc == TPM_RC_SUCCESS) {
1045 rc = TSS_TPM2B_ECC_PARAMETER_Unmarshalu(&target->y2, buffer, size);
1046 if (rc != TPM_RC_SUCCESS) {
1047 rc += RC_Commit_y2;
1048 }
1049 }
1050 return rc;
1051 }
1052 TPM_RC
EC_Ephemeral_In_Unmarshal(EC_Ephemeral_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1053 EC_Ephemeral_In_Unmarshal(EC_Ephemeral_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1054 {
1055 TPM_RC rc = TPM_RC_SUCCESS;
1056 handles = handles;
1057
1058 if (rc == TPM_RC_SUCCESS) {
1059 rc = TSS_TPMI_ECC_CURVE_Unmarshalu(&target->curveID, buffer, size);
1060 if (rc != TPM_RC_SUCCESS) {
1061 rc += RC_EC_Ephemeral_curveID;
1062 }
1063 }
1064 return rc;
1065 }
1066 TPM_RC
VerifySignature_In_Unmarshal(VerifySignature_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1067 VerifySignature_In_Unmarshal(VerifySignature_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1068 {
1069 TPM_RC rc = TPM_RC_SUCCESS;
1070
1071 if (rc == TPM_RC_SUCCESS) {
1072 target->keyHandle = handles[0];
1073 }
1074 if (rc == TPM_RC_SUCCESS) {
1075 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->digest, buffer, size);
1076 if (rc != TPM_RC_SUCCESS) {
1077 rc += RC_VerifySignature_digest;
1078 }
1079 }
1080 if (rc == TPM_RC_SUCCESS) {
1081 rc = TSS_TPMT_SIGNATURE_Unmarshalu(&target->signature, buffer, size, NO);
1082 if (rc != TPM_RC_SUCCESS) {
1083 rc += RC_VerifySignature_signature;
1084 }
1085 }
1086 return rc;
1087 }
1088 TPM_RC
Sign_In_Unmarshal(Sign_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1089 Sign_In_Unmarshal(Sign_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1090 {
1091 TPM_RC rc = TPM_RC_SUCCESS;
1092
1093 if (rc == TPM_RC_SUCCESS) {
1094 target->keyHandle = handles[0];
1095 }
1096 if (rc == TPM_RC_SUCCESS) {
1097 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->digest, buffer, size);
1098 if (rc != TPM_RC_SUCCESS) {
1099 rc += RC_Sign_digest;
1100 }
1101 }
1102 if (rc == TPM_RC_SUCCESS) {
1103 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
1104 if (rc != TPM_RC_SUCCESS) {
1105 rc += RC_Sign_inScheme;
1106 }
1107 }
1108 if (rc == TPM_RC_SUCCESS) {
1109 rc = TSS_TPMT_TK_HASHCHECK_Unmarshalu(&target->validation, buffer, size);
1110 if (rc != TPM_RC_SUCCESS) {
1111 rc += RC_Sign_validation;
1112 }
1113 }
1114 return rc;
1115 }
1116 TPM_RC
SetCommandCodeAuditStatus_In_Unmarshal(SetCommandCodeAuditStatus_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1117 SetCommandCodeAuditStatus_In_Unmarshal(SetCommandCodeAuditStatus_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1118 {
1119 TPM_RC rc = TPM_RC_SUCCESS;
1120
1121 if (rc == TPM_RC_SUCCESS) {
1122 target->auth = handles[0];
1123 }
1124 if (rc == TPM_RC_SUCCESS) {
1125 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->auditAlg, buffer, size, YES);
1126 if (rc != TPM_RC_SUCCESS) {
1127 rc += RC_SetCommandCodeAuditStatus_auditAlg;
1128 }
1129 }
1130 if (rc == TPM_RC_SUCCESS) {
1131 rc = TSS_TPML_CC_Unmarshalu(&target->setList, buffer, size);
1132 if (rc != TPM_RC_SUCCESS) {
1133 rc += RC_SetCommandCodeAuditStatus_setList;
1134 }
1135 }
1136 if (rc == TPM_RC_SUCCESS) {
1137 rc = TSS_TPML_CC_Unmarshalu(&target->clearList, buffer, size);
1138 if (rc != TPM_RC_SUCCESS) {
1139 rc += RC_SetCommandCodeAuditStatus_clearList;
1140 }
1141 }
1142 return rc;
1143 }
1144 TPM_RC
PCR_Extend_In_Unmarshal(PCR_Extend_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1145 PCR_Extend_In_Unmarshal(PCR_Extend_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1146 {
1147 TPM_RC rc = TPM_RC_SUCCESS;
1148
1149 if (rc == TPM_RC_SUCCESS) {
1150 target->pcrHandle = handles[0];
1151 }
1152 if (rc == TPM_RC_SUCCESS) {
1153 rc = TSS_TPML_DIGEST_VALUES_Unmarshalu(&target->digests, buffer, size);
1154 if (rc != TPM_RC_SUCCESS) {
1155 rc += RC_PCR_Extend_digests;
1156 }
1157 }
1158 return rc;
1159 }
1160 TPM_RC
PCR_Event_In_Unmarshal(PCR_Event_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1161 PCR_Event_In_Unmarshal(PCR_Event_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1162 {
1163 TPM_RC rc = TPM_RC_SUCCESS;
1164
1165 if (rc == TPM_RC_SUCCESS) {
1166 target->pcrHandle = handles[0];
1167 }
1168 if (rc == TPM_RC_SUCCESS) {
1169 rc = TSS_TPM2B_EVENT_Unmarshalu(&target->eventData, buffer, size);
1170 if (rc != TPM_RC_SUCCESS) {
1171 rc += RC_PCR_Event_eventData;
1172 }
1173 }
1174 return rc;
1175 }
1176 TPM_RC
PCR_Read_In_Unmarshal(PCR_Read_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1177 PCR_Read_In_Unmarshal(PCR_Read_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1178 {
1179 TPM_RC rc = TPM_RC_SUCCESS;
1180 handles = handles;
1181
1182 if (rc == TPM_RC_SUCCESS) {
1183 rc = TSS_TPML_PCR_SELECTION_Unmarshalu(&target->pcrSelectionIn, buffer, size);
1184 if (rc != TPM_RC_SUCCESS) {
1185 rc += RC_PCR_Read_pcrSelectionIn;
1186 }
1187 }
1188 return rc;
1189 }
1190 TPM_RC
PCR_Allocate_In_Unmarshal(PCR_Allocate_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1191 PCR_Allocate_In_Unmarshal(PCR_Allocate_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1192 {
1193 TPM_RC rc = TPM_RC_SUCCESS;
1194
1195 if (rc == TPM_RC_SUCCESS) {
1196 target->authHandle = handles[0];
1197 }
1198 if (rc == TPM_RC_SUCCESS) {
1199 rc = TSS_TPML_PCR_SELECTION_Unmarshalu(&target->pcrAllocation, buffer, size);
1200 if (rc != TPM_RC_SUCCESS) {
1201 rc += RC_PCR_Allocate_pcrAllocation;
1202 }
1203 }
1204 return rc;
1205 }
1206 TPM_RC
PCR_SetAuthPolicy_In_Unmarshal(PCR_SetAuthPolicy_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1207 PCR_SetAuthPolicy_In_Unmarshal(PCR_SetAuthPolicy_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1208 {
1209 TPM_RC rc = TPM_RC_SUCCESS;
1210
1211 if (rc == TPM_RC_SUCCESS) {
1212 target->authHandle = handles[0];
1213 }
1214 if (rc == TPM_RC_SUCCESS) {
1215 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->authPolicy, buffer, size);
1216 if (rc != TPM_RC_SUCCESS) {
1217 rc += RC_PCR_SetAuthPolicy_authPolicy;
1218 }
1219 }
1220 if (rc == TPM_RC_SUCCESS) {
1221 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->hashAlg, buffer, size, YES);
1222 if (rc != TPM_RC_SUCCESS) {
1223 rc += RC_PCR_SetAuthPolicy_hashAlg;
1224 }
1225 }
1226 if (rc == TPM_RC_SUCCESS) {
1227 rc = TSS_TPMI_DH_PCR_Unmarshalu(&target->pcrNum, buffer, size, NO);
1228 if (rc != TPM_RC_SUCCESS) {
1229 rc += RC_PCR_SetAuthPolicy_pcrNum;
1230 }
1231 }
1232 return rc;
1233 }
1234 TPM_RC
PCR_SetAuthValue_In_Unmarshal(PCR_SetAuthValue_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1235 PCR_SetAuthValue_In_Unmarshal(PCR_SetAuthValue_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1236 {
1237 TPM_RC rc = TPM_RC_SUCCESS;
1238
1239 if (rc == TPM_RC_SUCCESS) {
1240 target->pcrHandle = handles[0];
1241 }
1242 if (rc == TPM_RC_SUCCESS) {
1243 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->auth, buffer, size);
1244 if (rc != TPM_RC_SUCCESS) {
1245 rc += RC_PCR_SetAuthValue_auth;
1246 }
1247 }
1248 return rc;
1249 }
1250 TPM_RC
PCR_Reset_In_Unmarshal(PCR_Reset_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1251 PCR_Reset_In_Unmarshal(PCR_Reset_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1252 {
1253 TPM_RC rc = TPM_RC_SUCCESS;
1254 buffer = buffer;
1255 size = size;
1256
1257 if (rc == TPM_RC_SUCCESS) {
1258 target->pcrHandle = handles[0];
1259 }
1260 return rc;
1261 }
1262 TPM_RC
PolicySigned_In_Unmarshal(PolicySigned_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1263 PolicySigned_In_Unmarshal(PolicySigned_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1264 {
1265 TPM_RC rc = TPM_RC_SUCCESS;
1266
1267 if (rc == TPM_RC_SUCCESS) {
1268 target->authObject = handles[0];
1269 target->policySession = handles[1];
1270 }
1271 if (rc == TPM_RC_SUCCESS) {
1272 rc = TSS_TPM2B_NONCE_Unmarshalu(&target->nonceTPM, buffer, size);
1273 if (rc != TPM_RC_SUCCESS) {
1274 rc += RC_PolicySigned_nonceTPM;
1275 }
1276 }
1277 if (rc == TPM_RC_SUCCESS) {
1278 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->cpHashA, buffer, size);
1279 if (rc != TPM_RC_SUCCESS) {
1280 rc += RC_PolicySigned_cpHashA;
1281 }
1282 }
1283 if (rc == TPM_RC_SUCCESS) {
1284 rc = TSS_TPM2B_NONCE_Unmarshalu(&target->policyRef, buffer, size);
1285 if (rc != TPM_RC_SUCCESS) {
1286 rc += RC_PolicySigned_policyRef;
1287 }
1288 }
1289 if (rc == TPM_RC_SUCCESS) {
1290 rc = TSS_INT32_Unmarshalu(&target->expiration, buffer, size);
1291 if (rc != TPM_RC_SUCCESS) {
1292 rc += RC_PolicySigned_expiration;
1293 }
1294 }
1295 if (rc == TPM_RC_SUCCESS) {
1296 rc = TSS_TPMT_SIGNATURE_Unmarshalu(&target->auth, buffer, size, NO);
1297 if (rc != TPM_RC_SUCCESS) {
1298 rc += RC_PolicySigned_auth;
1299 }
1300 }
1301 return rc;
1302 }
1303 TPM_RC
PolicySecret_In_Unmarshal(PolicySecret_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1304 PolicySecret_In_Unmarshal(PolicySecret_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1305 {
1306 TPM_RC rc = TPM_RC_SUCCESS;
1307
1308 if (rc == TPM_RC_SUCCESS) {
1309 target->authHandle = handles[0];
1310 target->policySession = handles[1];
1311 }
1312 if (rc == TPM_RC_SUCCESS) {
1313 rc = TSS_TPM2B_NONCE_Unmarshalu(&target->nonceTPM, buffer, size);
1314 if (rc != TPM_RC_SUCCESS) {
1315 rc += RC_PolicySecret_nonceTPM;
1316 }
1317 }
1318 if (rc == TPM_RC_SUCCESS) {
1319 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->cpHashA, buffer, size);
1320 if (rc != TPM_RC_SUCCESS) {
1321 rc += RC_PolicySecret_cpHashA;
1322 }
1323 }
1324 if (rc == TPM_RC_SUCCESS) {
1325 rc = TSS_TPM2B_NONCE_Unmarshalu(&target->policyRef, buffer, size);
1326 if (rc != TPM_RC_SUCCESS) {
1327 rc += RC_PolicySecret_policyRef;
1328 }
1329 }
1330 if (rc == TPM_RC_SUCCESS) {
1331 rc = TSS_INT32_Unmarshalu(&target->expiration, buffer, size);
1332 if (rc != TPM_RC_SUCCESS) {
1333 rc += RC_PolicySecret_expiration;
1334 }
1335 }
1336 return rc;
1337 }
1338 TPM_RC
PolicyTicket_In_Unmarshal(PolicyTicket_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1339 PolicyTicket_In_Unmarshal(PolicyTicket_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1340 {
1341 TPM_RC rc = TPM_RC_SUCCESS;
1342
1343 if (rc == TPM_RC_SUCCESS) {
1344 target->policySession = handles[0];
1345 }
1346 if (rc == TPM_RC_SUCCESS) {
1347 rc = TSS_TPM2B_TIMEOUT_Unmarshalu(&target->timeout, buffer, size);
1348 if (rc != TPM_RC_SUCCESS) {
1349 rc += RC_PolicyTicket_timeout;
1350 }
1351 }
1352 if (rc == TPM_RC_SUCCESS) {
1353 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->cpHashA, buffer, size);
1354 if (rc != TPM_RC_SUCCESS) {
1355 rc += RC_PolicyTicket_cpHashA;
1356 }
1357 }
1358 if (rc == TPM_RC_SUCCESS) {
1359 rc = TSS_TPM2B_NONCE_Unmarshalu(&target->policyRef, buffer, size);
1360 if (rc != TPM_RC_SUCCESS) {
1361 rc += RC_PolicyTicket_policyRef;
1362 }
1363 }
1364 if (rc == TPM_RC_SUCCESS) {
1365 rc = TSS_TPM2B_NAME_Unmarshalu(&target->authName, buffer, size);
1366 if (rc != TPM_RC_SUCCESS) {
1367 rc += RC_PolicyTicket_authName;
1368 }
1369 }
1370 if (rc == TPM_RC_SUCCESS) {
1371 rc = TSS_TPMT_TK_AUTH_Unmarshalu(&target->ticket, buffer, size);
1372 if (rc != TPM_RC_SUCCESS) {
1373 rc += RC_PolicyTicket_ticket;
1374 }
1375 }
1376 return rc;
1377 }
1378 TPM_RC
PolicyOR_In_Unmarshal(PolicyOR_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1379 PolicyOR_In_Unmarshal(PolicyOR_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1380 {
1381 TPM_RC rc = TPM_RC_SUCCESS;
1382
1383 if (rc == TPM_RC_SUCCESS) {
1384 target->policySession = handles[0];
1385 }
1386 if (rc == TPM_RC_SUCCESS) {
1387 /* Policy OR requires at least two OR terms */
1388 rc = TSS_TPML_DIGEST_Unmarshalu(&target->pHashList, buffer, size, 2);
1389 if (rc != TPM_RC_SUCCESS) {
1390 rc += RC_PolicyOR_pHashList;
1391 }
1392 }
1393 return rc;
1394 }
1395 TPM_RC
PolicyPCR_In_Unmarshal(PolicyPCR_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1396 PolicyPCR_In_Unmarshal(PolicyPCR_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1397 {
1398 TPM_RC rc = TPM_RC_SUCCESS;
1399
1400 if (rc == TPM_RC_SUCCESS) {
1401 target->policySession = handles[0];
1402 }
1403 if (rc == TPM_RC_SUCCESS) {
1404 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->pcrDigest, buffer, size);
1405 if (rc != TPM_RC_SUCCESS) {
1406 rc += RC_PolicyPCR_pcrDigest;
1407 }
1408 }
1409 if (rc == TPM_RC_SUCCESS) {
1410 rc = TSS_TPML_PCR_SELECTION_Unmarshalu(&target->pcrs, buffer, size);
1411 if (rc != TPM_RC_SUCCESS) {
1412 rc += RC_PolicyPCR_pcrs;
1413 }
1414 }
1415 return rc;
1416 }
1417 TPM_RC
PolicyLocality_In_Unmarshal(PolicyLocality_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1418 PolicyLocality_In_Unmarshal(PolicyLocality_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1419 {
1420 TPM_RC rc = TPM_RC_SUCCESS;
1421
1422 if (rc == TPM_RC_SUCCESS) {
1423 target->policySession = handles[0];
1424 }
1425 if (rc == TPM_RC_SUCCESS) {
1426 rc = TSS_TPMA_LOCALITY_Unmarshalu(&target->locality, buffer, size);
1427 if (rc != TPM_RC_SUCCESS) {
1428 rc += RC_PolicyLocality_locality;
1429 }
1430 }
1431 return rc;
1432 }
1433 TPM_RC
PolicyNV_In_Unmarshal(PolicyNV_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1434 PolicyNV_In_Unmarshal(PolicyNV_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1435 {
1436 TPM_RC rc = TPM_RC_SUCCESS;
1437
1438 if (rc == TPM_RC_SUCCESS) {
1439 target->authHandle = handles[0];
1440 target->nvIndex = handles[1];
1441 target->policySession = handles[2];
1442 }
1443 if (rc == TPM_RC_SUCCESS) {
1444 rc = TSS_TPM2B_OPERAND_Unmarshalu(&target->operandB, buffer, size);
1445 if (rc != TPM_RC_SUCCESS) {
1446 rc += RC_PolicyNV_operandB;
1447 }
1448 }
1449 if (rc == TPM_RC_SUCCESS) {
1450 rc = TSS_UINT16_Unmarshalu(&target->offset, buffer, size);
1451 if (rc != TPM_RC_SUCCESS) {
1452 rc += RC_PolicyNV_offset;
1453 }
1454 }
1455 if (rc == TPM_RC_SUCCESS) {
1456 rc = TSS_TPM_EO_Unmarshalu(&target->operation, buffer, size);
1457 if (rc != TPM_RC_SUCCESS) {
1458 rc += RC_PolicyNV_operation;
1459 }
1460 }
1461 return rc;
1462 }
1463 TPM_RC
PolicyAuthorizeNV_In_Unmarshal(PolicyAuthorizeNV_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1464 PolicyAuthorizeNV_In_Unmarshal(PolicyAuthorizeNV_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1465 {
1466 TPM_RC rc = TPM_RC_SUCCESS;
1467 buffer = buffer;
1468 size = size;
1469
1470 if (rc == TPM_RC_SUCCESS) {
1471 target->authHandle = handles[0];
1472 target->nvIndex = handles[1];
1473 target->policySession = handles[2];
1474 }
1475 return rc;
1476 }
1477 TPM_RC
PolicyCounterTimer_In_Unmarshal(PolicyCounterTimer_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1478 PolicyCounterTimer_In_Unmarshal(PolicyCounterTimer_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1479 {
1480 TPM_RC rc = TPM_RC_SUCCESS;
1481
1482 if (rc == TPM_RC_SUCCESS) {
1483 target->policySession = handles[0];
1484 }
1485 if (rc == TPM_RC_SUCCESS) {
1486 rc = TSS_TPM2B_OPERAND_Unmarshalu(&target->operandB, buffer, size);
1487 if (rc != TPM_RC_SUCCESS) {
1488 rc += RC_PolicyCounterTimer_operandB;
1489 }
1490 }
1491 if (rc == TPM_RC_SUCCESS) {
1492 rc = TSS_UINT16_Unmarshalu(&target->offset, buffer, size);
1493 if (rc != TPM_RC_SUCCESS) {
1494 rc += RC_PolicyCounterTimer_offset;
1495 }
1496 }
1497 if (rc == TPM_RC_SUCCESS) {
1498 rc = TSS_TPM_EO_Unmarshalu(&target->operation, buffer, size);
1499 if (rc != TPM_RC_SUCCESS) {
1500 rc += RC_PolicyCounterTimer_operation;
1501 }
1502 }
1503 return rc;
1504 }
1505 TPM_RC
PolicyCommandCode_In_Unmarshal(PolicyCommandCode_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1506 PolicyCommandCode_In_Unmarshal(PolicyCommandCode_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1507 {
1508 TPM_RC rc = TPM_RC_SUCCESS;
1509
1510 if (rc == TPM_RC_SUCCESS) {
1511 target->policySession = handles[0];
1512 }
1513 if (rc == TPM_RC_SUCCESS) {
1514 rc = TSS_TPM_CC_Unmarshalu(&target->code, buffer, size);
1515 if (rc != TPM_RC_SUCCESS) {
1516 rc += RC_PolicyCommandCode_code;
1517 }
1518 }
1519 return rc;
1520 }
1521 TPM_RC
PolicyPhysicalPresence_In_Unmarshal(PolicyPhysicalPresence_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1522 PolicyPhysicalPresence_In_Unmarshal(PolicyPhysicalPresence_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1523 {
1524 TPM_RC rc = TPM_RC_SUCCESS;
1525 buffer = buffer;
1526 size = size;
1527
1528 if (rc == TPM_RC_SUCCESS) {
1529 target->policySession = handles[0];
1530 }
1531 return rc;
1532 }
1533 TPM_RC
PolicyCpHash_In_Unmarshal(PolicyCpHash_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1534 PolicyCpHash_In_Unmarshal(PolicyCpHash_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1535 {
1536 TPM_RC rc = TPM_RC_SUCCESS;
1537
1538 if (rc == TPM_RC_SUCCESS) {
1539 target->policySession = handles[0];
1540 }
1541 if (rc == TPM_RC_SUCCESS) {
1542 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->cpHashA, buffer, size);
1543 if (rc != TPM_RC_SUCCESS) {
1544 rc += RC_PolicyCpHash_cpHashA;
1545 }
1546 }
1547 return rc;
1548 }
1549 TPM_RC
PolicyNameHash_In_Unmarshal(PolicyNameHash_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1550 PolicyNameHash_In_Unmarshal(PolicyNameHash_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1551 {
1552 TPM_RC rc = TPM_RC_SUCCESS;
1553
1554 if (rc == TPM_RC_SUCCESS) {
1555 target->policySession = handles[0];
1556 }
1557 if (rc == TPM_RC_SUCCESS) {
1558 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->nameHash, buffer, size);
1559 if (rc != TPM_RC_SUCCESS) {
1560 rc += RC_PolicyNameHash_nameHash;
1561 }
1562 }
1563 return rc;
1564 }
1565 TPM_RC
PolicyDuplicationSelect_In_Unmarshal(PolicyDuplicationSelect_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1566 PolicyDuplicationSelect_In_Unmarshal(PolicyDuplicationSelect_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1567 {
1568 TPM_RC rc = TPM_RC_SUCCESS;
1569
1570 if (rc == TPM_RC_SUCCESS) {
1571 target->policySession = handles[0];
1572 }
1573 if (rc == TPM_RC_SUCCESS) {
1574 rc = TSS_TPM2B_NAME_Unmarshalu(&target->objectName, buffer, size);
1575 if (rc != TPM_RC_SUCCESS) {
1576 rc += RC_PolicyDuplicationSelect_objectName;
1577 }
1578 }
1579 if (rc == TPM_RC_SUCCESS) {
1580 rc = TSS_TPM2B_NAME_Unmarshalu(&target->newParentName, buffer, size);
1581 if (rc != TPM_RC_SUCCESS) {
1582 rc += RC_PolicyDuplicationSelect_newParentName;
1583 }
1584 }
1585 if (rc == TPM_RC_SUCCESS) {
1586 rc = TSS_TPMI_YES_NO_Unmarshalu(&target->includeObject, buffer, size);
1587 if (rc != TPM_RC_SUCCESS) {
1588 rc += RC_PolicyDuplicationSelect_includeObject;
1589 }
1590 }
1591 return rc;
1592 }
1593 TPM_RC
PolicyAuthorize_In_Unmarshal(PolicyAuthorize_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1594 PolicyAuthorize_In_Unmarshal(PolicyAuthorize_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1595 {
1596 TPM_RC rc = TPM_RC_SUCCESS;
1597
1598 if (rc == TPM_RC_SUCCESS) {
1599 target->policySession = handles[0];
1600 }
1601 if (rc == TPM_RC_SUCCESS) {
1602 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->approvedPolicy, buffer, size);
1603 if (rc != TPM_RC_SUCCESS) {
1604 rc += RC_PolicyAuthorize_approvedPolicy;
1605 }
1606 }
1607 if (rc == TPM_RC_SUCCESS) {
1608 rc = TSS_TPM2B_NONCE_Unmarshalu(&target->policyRef, buffer, size);
1609 if (rc != TPM_RC_SUCCESS) {
1610 rc += RC_PolicyAuthorize_policyRef;
1611 }
1612 }
1613 if (rc == TPM_RC_SUCCESS) {
1614 rc = TSS_TPM2B_NAME_Unmarshalu(&target->keySign, buffer, size);
1615 if (rc != TPM_RC_SUCCESS) {
1616 rc += RC_PolicyAuthorize_keySign;
1617 }
1618 }
1619 if (rc == TPM_RC_SUCCESS) {
1620 rc = TSS_TPMT_TK_VERIFIED_Unmarshalu(&target->checkTicket, buffer, size);
1621 if (rc != TPM_RC_SUCCESS) {
1622 rc += RC_PolicyAuthorize_checkTicket;
1623 }
1624 }
1625 return rc;
1626 }
1627 TPM_RC
PolicyAuthValue_In_Unmarshal(PolicyAuthValue_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1628 PolicyAuthValue_In_Unmarshal(PolicyAuthValue_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1629 {
1630 TPM_RC rc = TPM_RC_SUCCESS;
1631 buffer = buffer;
1632 size = size;
1633
1634 if (rc == TPM_RC_SUCCESS) {
1635 target->policySession = handles[0];
1636 }
1637 return rc;
1638 }
1639 TPM_RC
PolicyPassword_In_Unmarshal(PolicyPassword_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1640 PolicyPassword_In_Unmarshal(PolicyPassword_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1641 {
1642 TPM_RC rc = TPM_RC_SUCCESS;
1643 buffer = buffer;
1644 size = size;
1645
1646 if (rc == TPM_RC_SUCCESS) {
1647 target->policySession = handles[0];
1648 }
1649 return rc;
1650 }
1651 TPM_RC
PolicyGetDigest_In_Unmarshal(PolicyGetDigest_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1652 PolicyGetDigest_In_Unmarshal(PolicyGetDigest_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1653 {
1654 TPM_RC rc = TPM_RC_SUCCESS;
1655 buffer = buffer;
1656 size = size;
1657
1658 if (rc == TPM_RC_SUCCESS) {
1659 target->policySession = handles[0];
1660 }
1661 return rc;
1662 }
1663 TPM_RC
PolicyNvWritten_In_Unmarshal(PolicyNvWritten_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1664 PolicyNvWritten_In_Unmarshal(PolicyNvWritten_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1665 {
1666 TPM_RC rc = TPM_RC_SUCCESS;
1667
1668 if (rc == TPM_RC_SUCCESS) {
1669 target->policySession = handles[0];
1670 }
1671 if (rc == TPM_RC_SUCCESS) {
1672 rc = TSS_TPMI_YES_NO_Unmarshalu(&target->writtenSet, buffer, size);
1673 if (rc != TPM_RC_SUCCESS) {
1674 rc += RC_PolicyNvWritten_writtenSet;
1675 }
1676 }
1677 return rc;
1678 }
1679 TPM_RC
PolicyTemplate_In_Unmarshal(PolicyTemplate_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1680 PolicyTemplate_In_Unmarshal(PolicyTemplate_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1681 {
1682 TPM_RC rc = TPM_RC_SUCCESS;
1683 buffer = buffer;
1684 size = size;
1685
1686 if (rc == TPM_RC_SUCCESS) {
1687 target->policySession = handles[0];
1688 }
1689 if (rc == TPM_RC_SUCCESS) {
1690 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->templateHash, buffer, size);
1691 if (rc != TPM_RC_SUCCESS) {
1692 rc += RC_PolicyTemplate_templateHash;
1693 }
1694 }
1695 return rc;
1696 }
1697 TPM_RC
CreatePrimary_In_Unmarshal(CreatePrimary_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1698 CreatePrimary_In_Unmarshal(CreatePrimary_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1699 {
1700 TPM_RC rc = TPM_RC_SUCCESS;
1701
1702 if (rc == TPM_RC_SUCCESS) {
1703 target->primaryHandle = handles[0];
1704 }
1705 if (rc == TPM_RC_SUCCESS) {
1706 rc = TSS_TPM2B_SENSITIVE_CREATE_Unmarshalu(&target->inSensitive, buffer, size);
1707 if (rc != TPM_RC_SUCCESS) {
1708 rc += RC_CreatePrimary_inSensitive;
1709 }
1710 }
1711 if (rc == TPM_RC_SUCCESS) {
1712 rc = TSS_TPM2B_PUBLIC_Unmarshalu(&target->inPublic, buffer, size, NO);
1713 if (rc != TPM_RC_SUCCESS) {
1714 rc += RC_CreatePrimary_inPublic;
1715 }
1716 }
1717 if (rc == TPM_RC_SUCCESS) {
1718 rc = TSS_TPM2B_DATA_Unmarshalu(&target->outsideInfo, buffer, size);
1719 if (rc != TPM_RC_SUCCESS) {
1720 rc += RC_CreatePrimary_outsideInfo;
1721 }
1722 }
1723 if (rc == TPM_RC_SUCCESS) {
1724 rc = TSS_TPML_PCR_SELECTION_Unmarshalu(&target->creationPCR, buffer, size);
1725 if (rc != TPM_RC_SUCCESS) {
1726 rc += RC_CreatePrimary_creationPCR;
1727 }
1728 }
1729 return rc;
1730 }
1731 TPM_RC
HierarchyControl_In_Unmarshal(HierarchyControl_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1732 HierarchyControl_In_Unmarshal(HierarchyControl_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1733 {
1734 TPM_RC rc = TPM_RC_SUCCESS;
1735
1736 if (rc == TPM_RC_SUCCESS) {
1737 target->authHandle = handles[0];
1738 }
1739 if (rc == TPM_RC_SUCCESS) {
1740 rc = TSS_TPMI_RH_ENABLES_Unmarshalu(&target->enable, buffer, size, NO);
1741 if (rc != TPM_RC_SUCCESS) {
1742 rc += RC_HierarchyControl_enable;
1743 }
1744 }
1745 if (rc == TPM_RC_SUCCESS) {
1746 rc = TSS_TPMI_YES_NO_Unmarshalu(&target->state, buffer, size);
1747 if (rc != TPM_RC_SUCCESS) {
1748 rc += RC_HierarchyControl_state;
1749 }
1750 }
1751 return rc;
1752 }
1753 TPM_RC
SetPrimaryPolicy_In_Unmarshal(SetPrimaryPolicy_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1754 SetPrimaryPolicy_In_Unmarshal(SetPrimaryPolicy_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1755 {
1756 TPM_RC rc = TPM_RC_SUCCESS;
1757
1758 if (rc == TPM_RC_SUCCESS) {
1759 target->authHandle = handles[0];
1760 }
1761 if (rc == TPM_RC_SUCCESS) {
1762 rc = TSS_TPM2B_DIGEST_Unmarshalu(&target->authPolicy, buffer, size);
1763 if (rc != TPM_RC_SUCCESS) {
1764 rc += RC_SetPrimaryPolicy_authPolicy;
1765 }
1766 }
1767 if (rc == TPM_RC_SUCCESS) {
1768 rc = TSS_TPMI_ALG_HASH_Unmarshalu(&target->hashAlg, buffer, size, YES);
1769 if (rc != TPM_RC_SUCCESS) {
1770 rc += RC_SetPrimaryPolicy_hashAlg;
1771 }
1772 }
1773 return rc;
1774 }
1775 TPM_RC
ChangePPS_In_Unmarshal(ChangePPS_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1776 ChangePPS_In_Unmarshal(ChangePPS_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1777 {
1778 TPM_RC rc = TPM_RC_SUCCESS;
1779 buffer = buffer;
1780 size = size;
1781
1782 if (rc == TPM_RC_SUCCESS) {
1783 target->authHandle = handles[0];
1784 }
1785 return rc;
1786 }
1787 TPM_RC
ChangeEPS_In_Unmarshal(ChangeEPS_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1788 ChangeEPS_In_Unmarshal(ChangeEPS_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1789 {
1790 TPM_RC rc = TPM_RC_SUCCESS;
1791 buffer = buffer;
1792 size = size;
1793
1794 if (rc == TPM_RC_SUCCESS) {
1795 target->authHandle = handles[0];
1796 }
1797 return rc;
1798 }
1799 TPM_RC
Clear_In_Unmarshal(Clear_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1800 Clear_In_Unmarshal(Clear_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1801 {
1802 TPM_RC rc = TPM_RC_SUCCESS;
1803 buffer = buffer;
1804 size = size;
1805
1806 if (rc == TPM_RC_SUCCESS) {
1807 target->authHandle = handles[0];
1808 }
1809 return rc;
1810 }
1811 TPM_RC
ClearControl_In_Unmarshal(ClearControl_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1812 ClearControl_In_Unmarshal(ClearControl_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1813 {
1814 TPM_RC rc = TPM_RC_SUCCESS;
1815
1816 if (rc == TPM_RC_SUCCESS) {
1817 target->auth = handles[0];
1818 }
1819 if (rc == TPM_RC_SUCCESS) {
1820 rc = TSS_TPMI_YES_NO_Unmarshalu(&target->disable, buffer, size);
1821 if (rc != TPM_RC_SUCCESS) {
1822 rc += RC_ClearControl_disable;
1823 }
1824 }
1825 return rc;
1826 }
1827 TPM_RC
HierarchyChangeAuth_In_Unmarshal(HierarchyChangeAuth_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1828 HierarchyChangeAuth_In_Unmarshal(HierarchyChangeAuth_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1829 {
1830 TPM_RC rc = TPM_RC_SUCCESS;
1831
1832 if (rc == TPM_RC_SUCCESS) {
1833 target->authHandle = handles[0];
1834 }
1835 if (rc == TPM_RC_SUCCESS) {
1836 rc = TSS_TPM2B_AUTH_Unmarshalu(&target->newAuth, buffer, size);
1837 if (rc != TPM_RC_SUCCESS) {
1838 rc += RC_HierarchyChangeAuth_newAuth;
1839 }
1840 }
1841 return rc;
1842 }
1843 TPM_RC
DictionaryAttackLockReset_In_Unmarshal(DictionaryAttackLockReset_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1844 DictionaryAttackLockReset_In_Unmarshal(DictionaryAttackLockReset_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1845 {
1846 TPM_RC rc = TPM_RC_SUCCESS;
1847 buffer = buffer;
1848 size = size;
1849
1850 if (rc == TPM_RC_SUCCESS) {
1851 target->lockHandle = handles[0];
1852 }
1853 return rc;
1854 }
1855 TPM_RC
DictionaryAttackParameters_In_Unmarshal(DictionaryAttackParameters_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1856 DictionaryAttackParameters_In_Unmarshal(DictionaryAttackParameters_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1857 {
1858 TPM_RC rc = TPM_RC_SUCCESS;
1859
1860 if (rc == TPM_RC_SUCCESS) {
1861 target->lockHandle = handles[0];
1862 }
1863 if (rc == TPM_RC_SUCCESS) {
1864 rc = TSS_UINT32_Unmarshalu(&target->newMaxTries, buffer, size);
1865 if (rc != TPM_RC_SUCCESS) {
1866 rc += RC_DictionaryAttackParameters_newMaxTries;
1867 }
1868 }
1869 if (rc == TPM_RC_SUCCESS) {
1870 rc = TSS_UINT32_Unmarshalu(&target->newRecoveryTime, buffer, size);
1871 if (rc != TPM_RC_SUCCESS) {
1872 rc += RC_DictionaryAttackParameters_newRecoveryTime;
1873 }
1874 }
1875 if (rc == TPM_RC_SUCCESS) {
1876 rc = TSS_UINT32_Unmarshalu(&target->lockoutRecovery, buffer, size);
1877 if (rc != TPM_RC_SUCCESS) {
1878 rc += RC_DictionaryAttackParameters_lockoutRecovery;
1879 }
1880 }
1881 return rc;
1882 }
1883 TPM_RC
PP_Commands_In_Unmarshal(PP_Commands_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1884 PP_Commands_In_Unmarshal(PP_Commands_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1885 {
1886 TPM_RC rc = TPM_RC_SUCCESS;
1887
1888 if (rc == TPM_RC_SUCCESS) {
1889 target->auth = handles[0];
1890 }
1891 if (rc == TPM_RC_SUCCESS) {
1892 rc = TSS_TPML_CC_Unmarshalu(&target->setList, buffer, size);
1893 if (rc != TPM_RC_SUCCESS) {
1894 rc += RC_PP_Commands_setList;
1895 }
1896 }
1897 if (rc == TPM_RC_SUCCESS) {
1898 rc = TSS_TPML_CC_Unmarshalu(&target->clearList, buffer, size);
1899 if (rc != TPM_RC_SUCCESS) {
1900 rc += RC_PP_Commands_clearList;
1901 }
1902 }
1903 return rc;
1904 }
1905 TPM_RC
SetAlgorithmSet_In_Unmarshal(SetAlgorithmSet_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1906 SetAlgorithmSet_In_Unmarshal(SetAlgorithmSet_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1907 {
1908 TPM_RC rc = TPM_RC_SUCCESS;
1909
1910 if (rc == TPM_RC_SUCCESS) {
1911 target->authHandle = handles[0];
1912 }
1913 if (rc == TPM_RC_SUCCESS) {
1914 rc = TSS_UINT32_Unmarshalu(&target->algorithmSet, buffer, size);
1915 if (rc != TPM_RC_SUCCESS) {
1916 rc += RC_SetAlgorithmSet_algorithmSet;
1917 }
1918 }
1919 return rc;
1920 }
1921 TPM_RC
ContextSave_In_Unmarshal(ContextSave_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1922 ContextSave_In_Unmarshal(ContextSave_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1923 {
1924 TPM_RC rc = TPM_RC_SUCCESS;
1925 buffer = buffer;
1926 size = size;
1927
1928 if (rc == TPM_RC_SUCCESS) {
1929 target->saveHandle = handles[0];
1930 }
1931 return rc;
1932 }
1933 TPM_RC
ContextLoad_In_Unmarshal(ContextLoad_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1934 ContextLoad_In_Unmarshal(ContextLoad_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1935 {
1936 TPM_RC rc = TPM_RC_SUCCESS;
1937 handles = handles;
1938
1939 if (rc == TPM_RC_SUCCESS) {
1940 rc = TSS_TPMS_CONTEXT_Unmarshalu(&target->context, buffer, size);
1941 if (rc != TPM_RC_SUCCESS) {
1942 rc += RC_ContextLoad_context;
1943 }
1944 }
1945 return rc;
1946 }
1947 TPM_RC
FlushContext_In_Unmarshal(FlushContext_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1948 FlushContext_In_Unmarshal(FlushContext_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1949 {
1950 TPM_RC rc = TPM_RC_SUCCESS;
1951 handles = handles;
1952
1953 if (rc == TPM_RC_SUCCESS) {
1954 rc = TSS_TPMI_DH_CONTEXT_Unmarshalu(&target->flushHandle, buffer, size, NO);
1955 if (rc != TPM_RC_SUCCESS) {
1956 rc += RC_FlushContext_flushHandle;
1957 }
1958 }
1959 return rc;
1960 }
1961 TPM_RC
EvictControl_In_Unmarshal(EvictControl_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1962 EvictControl_In_Unmarshal(EvictControl_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1963 {
1964 TPM_RC rc = TPM_RC_SUCCESS;
1965
1966 if (rc == TPM_RC_SUCCESS) {
1967 target->auth = handles[0];
1968 target->objectHandle = handles[1];
1969 }
1970 if (rc == TPM_RC_SUCCESS) {
1971 rc = TSS_TPMI_DH_PERSISTENT_Unmarshalu(&target->persistentHandle, buffer, size);
1972 if (rc != TPM_RC_SUCCESS) {
1973 rc += RC_EvictControl_persistentHandle;
1974 }
1975 }
1976 return rc;
1977 }
1978 TPM_RC
ClockSet_In_Unmarshal(ClockSet_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1979 ClockSet_In_Unmarshal(ClockSet_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1980 {
1981 TPM_RC rc = TPM_RC_SUCCESS;
1982
1983 if (rc == TPM_RC_SUCCESS) {
1984 target->auth = handles[0];
1985 }
1986 if (rc == TPM_RC_SUCCESS) {
1987 rc = TSS_UINT64_Unmarshalu(&target->newTime, buffer, size);
1988 if (rc != TPM_RC_SUCCESS) {
1989 rc += RC_ClockSet_newTime;
1990 }
1991 }
1992 return rc;
1993 }
1994 TPM_RC
ClockRateAdjust_In_Unmarshal(ClockRateAdjust_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])1995 ClockRateAdjust_In_Unmarshal(ClockRateAdjust_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
1996 {
1997 TPM_RC rc = TPM_RC_SUCCESS;
1998
1999 if (rc == TPM_RC_SUCCESS) {
2000 target->auth = handles[0];
2001 }
2002 if (rc == TPM_RC_SUCCESS) {
2003 rc = TSS_TPM_CLOCK_ADJUST_Unmarshalu(&target->rateAdjust, buffer, size);
2004 if (rc != TPM_RC_SUCCESS) {
2005 rc += RC_ClockRateAdjust_rateAdjust;
2006 }
2007 }
2008 return rc;
2009 }
2010 TPM_RC
GetCapability_In_Unmarshal(GetCapability_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2011 GetCapability_In_Unmarshal(GetCapability_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2012 {
2013 TPM_RC rc = TPM_RC_SUCCESS;
2014 handles = handles;
2015
2016 if (rc == TPM_RC_SUCCESS) {
2017 rc = TSS_TPM_CAP_Unmarshalu(&target->capability, buffer, size);
2018 if (rc != TPM_RC_SUCCESS) {
2019 rc += RC_GetCapability_capability;
2020 }
2021 }
2022 if (rc == TPM_RC_SUCCESS) {
2023 rc = TSS_UINT32_Unmarshalu(&target->property, buffer, size);
2024 if (rc != TPM_RC_SUCCESS) {
2025 rc += RC_GetCapability_property;
2026 }
2027 }
2028 if (rc == TPM_RC_SUCCESS) {
2029 rc = TSS_UINT32_Unmarshalu(&target->propertyCount, buffer, size);
2030 if (rc != TPM_RC_SUCCESS) {
2031 rc += RC_GetCapability_propertyCount;
2032 }
2033 }
2034 return rc;
2035 }
2036 TPM_RC
TestParms_In_Unmarshal(TestParms_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2037 TestParms_In_Unmarshal(TestParms_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2038 {
2039 TPM_RC rc = TPM_RC_SUCCESS;
2040 handles = handles;
2041
2042 if (rc == TPM_RC_SUCCESS) {
2043 rc = TSS_TPMT_PUBLIC_PARMS_Unmarshalu(&target->parameters, buffer, size);
2044 if (rc != TPM_RC_SUCCESS) {
2045 rc += RC_TestParms_parameters;
2046 }
2047 }
2048 return rc;
2049 }
2050 TPM_RC
NV_DefineSpace_In_Unmarshal(NV_DefineSpace_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2051 NV_DefineSpace_In_Unmarshal(NV_DefineSpace_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2052 {
2053 TPM_RC rc = TPM_RC_SUCCESS;
2054
2055 if (rc == TPM_RC_SUCCESS) {
2056 target->authHandle = handles[0];
2057 }
2058 if (rc == TPM_RC_SUCCESS) {
2059 rc = TSS_TPM2B_AUTH_Unmarshalu(&target->auth, buffer, size);
2060 if (rc != TPM_RC_SUCCESS) {
2061 rc += RC_NV_DefineSpace_auth;
2062 }
2063 }
2064 if (rc == TPM_RC_SUCCESS) {
2065 rc = TSS_TPM2B_NV_PUBLIC_Unmarshalu(&target->publicInfo, buffer, size);
2066 if (rc != TPM_RC_SUCCESS) {
2067 rc += RC_NV_DefineSpace_publicInfo;
2068 }
2069 }
2070 return rc;
2071 }
2072 TPM_RC
NV_UndefineSpace_In_Unmarshal(NV_UndefineSpace_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2073 NV_UndefineSpace_In_Unmarshal(NV_UndefineSpace_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2074 {
2075 TPM_RC rc = TPM_RC_SUCCESS;
2076 buffer = buffer;
2077 size = size;
2078
2079 if (rc == TPM_RC_SUCCESS) {
2080 target->authHandle = handles[0];
2081 target->nvIndex = handles[1];
2082 }
2083 return rc;
2084 }
2085 TPM_RC
NV_UndefineSpaceSpecial_In_Unmarshal(NV_UndefineSpaceSpecial_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2086 NV_UndefineSpaceSpecial_In_Unmarshal(NV_UndefineSpaceSpecial_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2087 {
2088 TPM_RC rc = TPM_RC_SUCCESS;
2089 buffer = buffer;
2090 size = size;
2091
2092 if (rc == TPM_RC_SUCCESS) {
2093 target->nvIndex = handles[0];
2094 target->platform = handles[1];
2095 }
2096 return rc;
2097 }
2098 TPM_RC
NV_ReadPublic_In_Unmarshal(NV_ReadPublic_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2099 NV_ReadPublic_In_Unmarshal(NV_ReadPublic_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2100 {
2101 TPM_RC rc = TPM_RC_SUCCESS;
2102 buffer = buffer;
2103 size = size;
2104
2105 if (rc == TPM_RC_SUCCESS) {
2106 target->nvIndex = handles[0];
2107 }
2108 return rc;
2109 }
2110 TPM_RC
NV_Write_In_Unmarshal(NV_Write_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2111 NV_Write_In_Unmarshal(NV_Write_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2112 {
2113 TPM_RC rc = TPM_RC_SUCCESS;
2114
2115 if (rc == TPM_RC_SUCCESS) {
2116 target->authHandle = handles[0];
2117 target->nvIndex = handles[1];
2118 }
2119 if (rc == TPM_RC_SUCCESS) {
2120 rc = TSS_TPM2B_MAX_NV_BUFFER_Unmarshalu(&target->data, buffer, size);
2121 if (rc != TPM_RC_SUCCESS) {
2122 rc += RC_NV_Write_data;
2123 }
2124 }
2125 if (rc == TPM_RC_SUCCESS) {
2126 rc = TSS_UINT16_Unmarshalu(&target->offset, buffer, size);
2127 if (rc != TPM_RC_SUCCESS) {
2128 rc += RC_NV_Write_offset;
2129 }
2130 }
2131 return rc;
2132 }
2133 TPM_RC
NV_Increment_In_Unmarshal(NV_Increment_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2134 NV_Increment_In_Unmarshal(NV_Increment_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2135 {
2136 TPM_RC rc = TPM_RC_SUCCESS;
2137 buffer = buffer;
2138 size = size;
2139
2140 if (rc == TPM_RC_SUCCESS) {
2141 target->authHandle = handles[0];
2142 target->nvIndex = handles[1];
2143 }
2144 return rc;
2145 }
2146 TPM_RC
NV_Extend_In_Unmarshal(NV_Extend_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2147 NV_Extend_In_Unmarshal(NV_Extend_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2148 {
2149 TPM_RC rc = TPM_RC_SUCCESS;
2150
2151 if (rc == TPM_RC_SUCCESS) {
2152 target->authHandle = handles[0];
2153 target->nvIndex = handles[1];
2154 }
2155 if (rc == TPM_RC_SUCCESS) {
2156 rc = TSS_TPM2B_MAX_NV_BUFFER_Unmarshalu(&target->data, buffer, size);
2157 if (rc != TPM_RC_SUCCESS) {
2158 rc += RC_NV_Extend_data;
2159 }
2160 }
2161 return rc;
2162 }
2163 TPM_RC
NV_SetBits_In_Unmarshal(NV_SetBits_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2164 NV_SetBits_In_Unmarshal(NV_SetBits_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2165 {
2166 TPM_RC rc = TPM_RC_SUCCESS;
2167
2168 if (rc == TPM_RC_SUCCESS) {
2169 target->authHandle = handles[0];
2170 target->nvIndex = handles[1];
2171 }
2172 if (rc == TPM_RC_SUCCESS) {
2173 rc = TSS_UINT64_Unmarshalu(&target->bits, buffer, size);
2174 if (rc != TPM_RC_SUCCESS) {
2175 rc += RC_NV_SetBits_bits;
2176 }
2177 }
2178 return rc;
2179 }
2180 TPM_RC
NV_WriteLock_In_Unmarshal(NV_WriteLock_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2181 NV_WriteLock_In_Unmarshal(NV_WriteLock_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2182 {
2183 TPM_RC rc = TPM_RC_SUCCESS;
2184 buffer = buffer;
2185 size = size;
2186
2187 if (rc == TPM_RC_SUCCESS) {
2188 target->authHandle = handles[0];
2189 target->nvIndex = handles[1];
2190 }
2191 return rc;
2192 }
2193 TPM_RC
NV_GlobalWriteLock_In_Unmarshal(NV_GlobalWriteLock_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2194 NV_GlobalWriteLock_In_Unmarshal(NV_GlobalWriteLock_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2195 {
2196 TPM_RC rc = TPM_RC_SUCCESS;
2197 buffer = buffer;
2198 size = size;
2199
2200 if (rc == TPM_RC_SUCCESS) {
2201 target->authHandle = handles[0];
2202 }
2203 return rc;
2204 }
2205 TPM_RC
NV_Read_In_Unmarshal(NV_Read_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2206 NV_Read_In_Unmarshal(NV_Read_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2207 {
2208 TPM_RC rc = TPM_RC_SUCCESS;
2209
2210 if (rc == TPM_RC_SUCCESS) {
2211 target->authHandle = handles[0];
2212 target->nvIndex = handles[1];
2213 }
2214 if (rc == TPM_RC_SUCCESS) {
2215 rc = TSS_UINT16_Unmarshalu(&target->size, buffer, size);
2216 if (rc != TPM_RC_SUCCESS) {
2217 rc += RC_NV_Read_size;
2218 }
2219 }
2220 if (rc == TPM_RC_SUCCESS) {
2221 rc = TSS_UINT16_Unmarshalu(&target->offset, buffer, size);
2222 if (rc != TPM_RC_SUCCESS) {
2223 rc += RC_NV_Read_offset;
2224 }
2225 }
2226 return rc;
2227 }
2228 TPM_RC
NV_ReadLock_In_Unmarshal(NV_ReadLock_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2229 NV_ReadLock_In_Unmarshal(NV_ReadLock_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2230 {
2231 TPM_RC rc = TPM_RC_SUCCESS;
2232 buffer = buffer;
2233 size = size;
2234
2235 if (rc == TPM_RC_SUCCESS) {
2236 target->authHandle = handles[0];
2237 target->nvIndex = handles[1];
2238 }
2239 return rc;
2240 }
2241 TPM_RC
NV_ChangeAuth_In_Unmarshal(NV_ChangeAuth_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2242 NV_ChangeAuth_In_Unmarshal(NV_ChangeAuth_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2243 {
2244 TPM_RC rc = TPM_RC_SUCCESS;
2245
2246 if (rc == TPM_RC_SUCCESS) {
2247 target->nvIndex = handles[0];
2248 }
2249 if (rc == TPM_RC_SUCCESS) {
2250 rc = TSS_TPM2B_AUTH_Unmarshalu(&target->newAuth, buffer, size);
2251 if (rc != TPM_RC_SUCCESS) {
2252 rc += RC_NV_ChangeAuth_newAuth;
2253 }
2254 }
2255 return rc;
2256 }
2257 TPM_RC
NV_Certify_In_Unmarshal(NV_Certify_In * target,BYTE ** buffer,uint32_t * size,TPM_HANDLE handles[])2258 NV_Certify_In_Unmarshal(NV_Certify_In *target, BYTE **buffer, uint32_t *size, TPM_HANDLE handles[])
2259 {
2260 TPM_RC rc = TPM_RC_SUCCESS;
2261
2262 if (rc == TPM_RC_SUCCESS) {
2263 target->signHandle = handles[0];
2264 target->authHandle = handles[1];
2265 target->nvIndex = handles[2];
2266 }
2267 if (rc == TPM_RC_SUCCESS) {
2268 rc = TSS_TPM2B_DATA_Unmarshalu(&target->qualifyingData, buffer, size);
2269 if (rc != TPM_RC_SUCCESS) {
2270 rc += RC_NV_Certify_qualifyingData;
2271 }
2272 }
2273 if (rc == TPM_RC_SUCCESS) {
2274 rc = TSS_TPMT_SIG_SCHEME_Unmarshalu(&target->inScheme, buffer, size, YES);
2275 if (rc != TPM_RC_SUCCESS) {
2276 rc += RC_NV_Certify_inScheme;
2277 }
2278 }
2279 if (rc == TPM_RC_SUCCESS) {
2280 rc = TSS_UINT16_Unmarshalu(&target->size, buffer, size);
2281 if (rc != TPM_RC_SUCCESS) {
2282 rc += RC_NV_Certify_size;
2283 }
2284 }
2285 if (rc == TPM_RC_SUCCESS) {
2286 rc = TSS_UINT16_Unmarshalu(&target->offset, buffer, size);
2287 if (rc != TPM_RC_SUCCESS) {
2288 rc += RC_NV_Certify_offset;
2289 }
2290 }
2291 return rc;
2292 }
2293
2294 #endif /* TPM_TSS_NOCMDCHECK */
2295