1 // Copyright 2015 The Chromium OS Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // THIS CODE IS GENERATED - DO NOT MODIFY!
6
7 #include "tpm_generated.h"
8
uint8_t_Marshal(uint8_t * source,BYTE ** buffer,INT32 * size)9 UINT16 uint8_t_Marshal(uint8_t* source, BYTE** buffer, INT32* size) {
10 uint8_t value_net = *source;
11 if (!size || *size < sizeof(uint8_t)) {
12 return 0; // Nothing has been marshaled.
13 }
14 switch (sizeof(uint8_t)) {
15 case 2:
16 value_net = htobe16(*source);
17 break;
18 case 4:
19 value_net = htobe32(*source);
20 break;
21 case 8:
22 value_net = htobe64(*source);
23 break;
24 default:
25 break;
26 }
27 memcpy(*buffer, &value_net, sizeof(uint8_t));
28 *buffer += sizeof(uint8_t);
29 *size -= sizeof(uint8_t);
30 return sizeof(uint8_t);
31 }
32
uint8_t_Unmarshal(uint8_t * target,BYTE ** buffer,INT32 * size)33 TPM_RC uint8_t_Unmarshal(uint8_t* target, BYTE** buffer, INT32* size) {
34 uint8_t value_net = 0;
35 if (!size || *size < sizeof(uint8_t)) {
36 return TPM_RC_INSUFFICIENT;
37 }
38 memcpy(&value_net, *buffer, sizeof(uint8_t));
39 switch (sizeof(uint8_t)) {
40 case 2:
41 *target = be16toh(value_net);
42 break;
43 case 4:
44 *target = be32toh(value_net);
45 break;
46 case 8:
47 *target = be64toh(value_net);
48 break;
49 default:
50 *target = value_net;
51 }
52 *buffer += sizeof(uint8_t);
53 *size -= sizeof(uint8_t);
54 return TPM_RC_SUCCESS;
55 }
56
int8_t_Marshal(int8_t * source,BYTE ** buffer,INT32 * size)57 UINT16 int8_t_Marshal(int8_t* source, BYTE** buffer, INT32* size) {
58 int8_t value_net = *source;
59 if (!size || *size < sizeof(int8_t)) {
60 return 0; // Nothing has been marshaled.
61 }
62 switch (sizeof(int8_t)) {
63 case 2:
64 value_net = htobe16(*source);
65 break;
66 case 4:
67 value_net = htobe32(*source);
68 break;
69 case 8:
70 value_net = htobe64(*source);
71 break;
72 default:
73 break;
74 }
75 memcpy(*buffer, &value_net, sizeof(int8_t));
76 *buffer += sizeof(int8_t);
77 *size -= sizeof(int8_t);
78 return sizeof(int8_t);
79 }
80
int8_t_Unmarshal(int8_t * target,BYTE ** buffer,INT32 * size)81 TPM_RC int8_t_Unmarshal(int8_t* target, BYTE** buffer, INT32* size) {
82 int8_t value_net = 0;
83 if (!size || *size < sizeof(int8_t)) {
84 return TPM_RC_INSUFFICIENT;
85 }
86 memcpy(&value_net, *buffer, sizeof(int8_t));
87 switch (sizeof(int8_t)) {
88 case 2:
89 *target = be16toh(value_net);
90 break;
91 case 4:
92 *target = be32toh(value_net);
93 break;
94 case 8:
95 *target = be64toh(value_net);
96 break;
97 default:
98 *target = value_net;
99 }
100 *buffer += sizeof(int8_t);
101 *size -= sizeof(int8_t);
102 return TPM_RC_SUCCESS;
103 }
104
uint16_t_Marshal(uint16_t * source,BYTE ** buffer,INT32 * size)105 UINT16 uint16_t_Marshal(uint16_t* source, BYTE** buffer, INT32* size) {
106 uint16_t value_net = *source;
107 if (!size || *size < sizeof(uint16_t)) {
108 return 0; // Nothing has been marshaled.
109 }
110 switch (sizeof(uint16_t)) {
111 case 2:
112 value_net = htobe16(*source);
113 break;
114 case 4:
115 value_net = htobe32(*source);
116 break;
117 case 8:
118 value_net = htobe64(*source);
119 break;
120 default:
121 break;
122 }
123 memcpy(*buffer, &value_net, sizeof(uint16_t));
124 *buffer += sizeof(uint16_t);
125 *size -= sizeof(uint16_t);
126 return sizeof(uint16_t);
127 }
128
uint16_t_Unmarshal(uint16_t * target,BYTE ** buffer,INT32 * size)129 TPM_RC uint16_t_Unmarshal(uint16_t* target, BYTE** buffer, INT32* size) {
130 uint16_t value_net = 0;
131 if (!size || *size < sizeof(uint16_t)) {
132 return TPM_RC_INSUFFICIENT;
133 }
134 memcpy(&value_net, *buffer, sizeof(uint16_t));
135 switch (sizeof(uint16_t)) {
136 case 2:
137 *target = be16toh(value_net);
138 break;
139 case 4:
140 *target = be32toh(value_net);
141 break;
142 case 8:
143 *target = be64toh(value_net);
144 break;
145 default:
146 *target = value_net;
147 }
148 *buffer += sizeof(uint16_t);
149 *size -= sizeof(uint16_t);
150 return TPM_RC_SUCCESS;
151 }
152
int16_t_Marshal(int16_t * source,BYTE ** buffer,INT32 * size)153 UINT16 int16_t_Marshal(int16_t* source, BYTE** buffer, INT32* size) {
154 int16_t value_net = *source;
155 if (!size || *size < sizeof(int16_t)) {
156 return 0; // Nothing has been marshaled.
157 }
158 switch (sizeof(int16_t)) {
159 case 2:
160 value_net = htobe16(*source);
161 break;
162 case 4:
163 value_net = htobe32(*source);
164 break;
165 case 8:
166 value_net = htobe64(*source);
167 break;
168 default:
169 break;
170 }
171 memcpy(*buffer, &value_net, sizeof(int16_t));
172 *buffer += sizeof(int16_t);
173 *size -= sizeof(int16_t);
174 return sizeof(int16_t);
175 }
176
int16_t_Unmarshal(int16_t * target,BYTE ** buffer,INT32 * size)177 TPM_RC int16_t_Unmarshal(int16_t* target, BYTE** buffer, INT32* size) {
178 int16_t value_net = 0;
179 if (!size || *size < sizeof(int16_t)) {
180 return TPM_RC_INSUFFICIENT;
181 }
182 memcpy(&value_net, *buffer, sizeof(int16_t));
183 switch (sizeof(int16_t)) {
184 case 2:
185 *target = be16toh(value_net);
186 break;
187 case 4:
188 *target = be32toh(value_net);
189 break;
190 case 8:
191 *target = be64toh(value_net);
192 break;
193 default:
194 *target = value_net;
195 }
196 *buffer += sizeof(int16_t);
197 *size -= sizeof(int16_t);
198 return TPM_RC_SUCCESS;
199 }
200
uint32_t_Marshal(uint32_t * source,BYTE ** buffer,INT32 * size)201 UINT16 uint32_t_Marshal(uint32_t* source, BYTE** buffer, INT32* size) {
202 uint32_t value_net = *source;
203 if (!size || *size < sizeof(uint32_t)) {
204 return 0; // Nothing has been marshaled.
205 }
206 switch (sizeof(uint32_t)) {
207 case 2:
208 value_net = htobe16(*source);
209 break;
210 case 4:
211 value_net = htobe32(*source);
212 break;
213 case 8:
214 value_net = htobe64(*source);
215 break;
216 default:
217 break;
218 }
219 memcpy(*buffer, &value_net, sizeof(uint32_t));
220 *buffer += sizeof(uint32_t);
221 *size -= sizeof(uint32_t);
222 return sizeof(uint32_t);
223 }
224
uint32_t_Unmarshal(uint32_t * target,BYTE ** buffer,INT32 * size)225 TPM_RC uint32_t_Unmarshal(uint32_t* target, BYTE** buffer, INT32* size) {
226 uint32_t value_net = 0;
227 if (!size || *size < sizeof(uint32_t)) {
228 return TPM_RC_INSUFFICIENT;
229 }
230 memcpy(&value_net, *buffer, sizeof(uint32_t));
231 switch (sizeof(uint32_t)) {
232 case 2:
233 *target = be16toh(value_net);
234 break;
235 case 4:
236 *target = be32toh(value_net);
237 break;
238 case 8:
239 *target = be64toh(value_net);
240 break;
241 default:
242 *target = value_net;
243 }
244 *buffer += sizeof(uint32_t);
245 *size -= sizeof(uint32_t);
246 return TPM_RC_SUCCESS;
247 }
248
int32_t_Marshal(int32_t * source,BYTE ** buffer,INT32 * size)249 UINT16 int32_t_Marshal(int32_t* source, BYTE** buffer, INT32* size) {
250 int32_t value_net = *source;
251 if (!size || *size < sizeof(int32_t)) {
252 return 0; // Nothing has been marshaled.
253 }
254 switch (sizeof(int32_t)) {
255 case 2:
256 value_net = htobe16(*source);
257 break;
258 case 4:
259 value_net = htobe32(*source);
260 break;
261 case 8:
262 value_net = htobe64(*source);
263 break;
264 default:
265 break;
266 }
267 memcpy(*buffer, &value_net, sizeof(int32_t));
268 *buffer += sizeof(int32_t);
269 *size -= sizeof(int32_t);
270 return sizeof(int32_t);
271 }
272
int32_t_Unmarshal(int32_t * target,BYTE ** buffer,INT32 * size)273 TPM_RC int32_t_Unmarshal(int32_t* target, BYTE** buffer, INT32* size) {
274 int32_t value_net = 0;
275 if (!size || *size < sizeof(int32_t)) {
276 return TPM_RC_INSUFFICIENT;
277 }
278 memcpy(&value_net, *buffer, sizeof(int32_t));
279 switch (sizeof(int32_t)) {
280 case 2:
281 *target = be16toh(value_net);
282 break;
283 case 4:
284 *target = be32toh(value_net);
285 break;
286 case 8:
287 *target = be64toh(value_net);
288 break;
289 default:
290 *target = value_net;
291 }
292 *buffer += sizeof(int32_t);
293 *size -= sizeof(int32_t);
294 return TPM_RC_SUCCESS;
295 }
296
uint64_t_Marshal(uint64_t * source,BYTE ** buffer,INT32 * size)297 UINT16 uint64_t_Marshal(uint64_t* source, BYTE** buffer, INT32* size) {
298 uint64_t value_net = *source;
299 if (!size || *size < sizeof(uint64_t)) {
300 return 0; // Nothing has been marshaled.
301 }
302 switch (sizeof(uint64_t)) {
303 case 2:
304 value_net = htobe16(*source);
305 break;
306 case 4:
307 value_net = htobe32(*source);
308 break;
309 case 8:
310 value_net = htobe64(*source);
311 break;
312 default:
313 break;
314 }
315 memcpy(*buffer, &value_net, sizeof(uint64_t));
316 *buffer += sizeof(uint64_t);
317 *size -= sizeof(uint64_t);
318 return sizeof(uint64_t);
319 }
320
uint64_t_Unmarshal(uint64_t * target,BYTE ** buffer,INT32 * size)321 TPM_RC uint64_t_Unmarshal(uint64_t* target, BYTE** buffer, INT32* size) {
322 uint64_t value_net = 0;
323 if (!size || *size < sizeof(uint64_t)) {
324 return TPM_RC_INSUFFICIENT;
325 }
326 memcpy(&value_net, *buffer, sizeof(uint64_t));
327 switch (sizeof(uint64_t)) {
328 case 2:
329 *target = be16toh(value_net);
330 break;
331 case 4:
332 *target = be32toh(value_net);
333 break;
334 case 8:
335 *target = be64toh(value_net);
336 break;
337 default:
338 *target = value_net;
339 }
340 *buffer += sizeof(uint64_t);
341 *size -= sizeof(uint64_t);
342 return TPM_RC_SUCCESS;
343 }
344
int64_t_Marshal(int64_t * source,BYTE ** buffer,INT32 * size)345 UINT16 int64_t_Marshal(int64_t* source, BYTE** buffer, INT32* size) {
346 int64_t value_net = *source;
347 if (!size || *size < sizeof(int64_t)) {
348 return 0; // Nothing has been marshaled.
349 }
350 switch (sizeof(int64_t)) {
351 case 2:
352 value_net = htobe16(*source);
353 break;
354 case 4:
355 value_net = htobe32(*source);
356 break;
357 case 8:
358 value_net = htobe64(*source);
359 break;
360 default:
361 break;
362 }
363 memcpy(*buffer, &value_net, sizeof(int64_t));
364 *buffer += sizeof(int64_t);
365 *size -= sizeof(int64_t);
366 return sizeof(int64_t);
367 }
368
int64_t_Unmarshal(int64_t * target,BYTE ** buffer,INT32 * size)369 TPM_RC int64_t_Unmarshal(int64_t* target, BYTE** buffer, INT32* size) {
370 int64_t value_net = 0;
371 if (!size || *size < sizeof(int64_t)) {
372 return TPM_RC_INSUFFICIENT;
373 }
374 memcpy(&value_net, *buffer, sizeof(int64_t));
375 switch (sizeof(int64_t)) {
376 case 2:
377 *target = be16toh(value_net);
378 break;
379 case 4:
380 *target = be32toh(value_net);
381 break;
382 case 8:
383 *target = be64toh(value_net);
384 break;
385 default:
386 *target = value_net;
387 }
388 *buffer += sizeof(int64_t);
389 *size -= sizeof(int64_t);
390 return TPM_RC_SUCCESS;
391 }
392
BYTE_Marshal(BYTE * source,BYTE ** buffer,INT32 * size)393 UINT16 BYTE_Marshal(BYTE* source, BYTE** buffer, INT32* size) {
394 return uint8_t_Marshal(source, buffer, size);
395 }
396
BYTE_Unmarshal(BYTE * target,BYTE ** buffer,INT32 * size)397 TPM_RC BYTE_Unmarshal(BYTE* target, BYTE** buffer, INT32* size) {
398 return uint8_t_Unmarshal(target, buffer, size);
399 }
400
INT16_Marshal(INT16 * source,BYTE ** buffer,INT32 * size)401 UINT16 INT16_Marshal(INT16* source, BYTE** buffer, INT32* size) {
402 return int16_t_Marshal(source, buffer, size);
403 }
404
INT16_Unmarshal(INT16 * target,BYTE ** buffer,INT32 * size)405 TPM_RC INT16_Unmarshal(INT16* target, BYTE** buffer, INT32* size) {
406 return int16_t_Unmarshal(target, buffer, size);
407 }
408
INT32_Marshal(INT32 * source,BYTE ** buffer,INT32 * size)409 UINT16 INT32_Marshal(INT32* source, BYTE** buffer, INT32* size) {
410 return int32_t_Marshal(source, buffer, size);
411 }
412
INT32_Unmarshal(INT32 * target,BYTE ** buffer,INT32 * size)413 TPM_RC INT32_Unmarshal(INT32* target, BYTE** buffer, INT32* size) {
414 return int32_t_Unmarshal(target, buffer, size);
415 }
416
INT64_Marshal(INT64 * source,BYTE ** buffer,INT32 * size)417 UINT16 INT64_Marshal(INT64* source, BYTE** buffer, INT32* size) {
418 return int64_t_Marshal(source, buffer, size);
419 }
420
INT64_Unmarshal(INT64 * target,BYTE ** buffer,INT32 * size)421 TPM_RC INT64_Unmarshal(INT64* target, BYTE** buffer, INT32* size) {
422 return int64_t_Unmarshal(target, buffer, size);
423 }
424
INT8_Marshal(INT8 * source,BYTE ** buffer,INT32 * size)425 UINT16 INT8_Marshal(INT8* source, BYTE** buffer, INT32* size) {
426 return int8_t_Marshal(source, buffer, size);
427 }
428
INT8_Unmarshal(INT8 * target,BYTE ** buffer,INT32 * size)429 TPM_RC INT8_Unmarshal(INT8* target, BYTE** buffer, INT32* size) {
430 return int8_t_Unmarshal(target, buffer, size);
431 }
432
UINT16_Marshal(UINT16 * source,BYTE ** buffer,INT32 * size)433 UINT16 UINT16_Marshal(UINT16* source, BYTE** buffer, INT32* size) {
434 return uint16_t_Marshal(source, buffer, size);
435 }
436
UINT16_Unmarshal(UINT16 * target,BYTE ** buffer,INT32 * size)437 TPM_RC UINT16_Unmarshal(UINT16* target, BYTE** buffer, INT32* size) {
438 return uint16_t_Unmarshal(target, buffer, size);
439 }
440
TPM2B_ATTEST_Marshal(TPM2B_ATTEST * source,BYTE ** buffer,INT32 * size)441 UINT16 TPM2B_ATTEST_Marshal(TPM2B_ATTEST* source, BYTE** buffer, INT32* size) {
442 UINT16 total_size = 0;
443 INT32 i;
444 total_size += UINT16_Marshal(&source->t.size, buffer, size);
445 for (i = 0; i < source->t.size; ++i) {
446 total_size += BYTE_Marshal(&source->t.attestationData[i], buffer, size);
447 }
448 return total_size;
449 }
450
TPM2B_ATTEST_Unmarshal(TPM2B_ATTEST * target,BYTE ** buffer,INT32 * size)451 TPM_RC TPM2B_ATTEST_Unmarshal(TPM2B_ATTEST* target,
452 BYTE** buffer,
453 INT32* size) {
454 TPM_RC result;
455 INT32 i;
456 result = UINT16_Unmarshal(&target->t.size, buffer, size);
457 if (result != TPM_RC_SUCCESS) {
458 return result;
459 }
460 if (target->t.size == 0) {
461 return TPM_RC_SUCCESS;
462 }
463 if (target->t.size > sizeof(TPMS_ATTEST)) {
464 return TPM_RC_SIZE;
465 }
466 for (i = 0; i < target->t.size; ++i) {
467 result = BYTE_Unmarshal(&target->t.attestationData[i], buffer, size);
468 if (result != TPM_RC_SUCCESS) {
469 return result;
470 }
471 }
472 return TPM_RC_SUCCESS;
473 }
474
TPM2B_DIGEST_Marshal(TPM2B_DIGEST * source,BYTE ** buffer,INT32 * size)475 UINT16 TPM2B_DIGEST_Marshal(TPM2B_DIGEST* source, BYTE** buffer, INT32* size) {
476 UINT16 total_size = 0;
477 INT32 i;
478 total_size += UINT16_Marshal(&source->t.size, buffer, size);
479 for (i = 0; i < source->t.size; ++i) {
480 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
481 }
482 return total_size;
483 }
484
TPM2B_DIGEST_Unmarshal(TPM2B_DIGEST * target,BYTE ** buffer,INT32 * size)485 TPM_RC TPM2B_DIGEST_Unmarshal(TPM2B_DIGEST* target,
486 BYTE** buffer,
487 INT32* size) {
488 TPM_RC result;
489 INT32 i;
490 result = UINT16_Unmarshal(&target->t.size, buffer, size);
491 if (result != TPM_RC_SUCCESS) {
492 return result;
493 }
494 if (target->t.size == 0) {
495 return TPM_RC_SUCCESS;
496 }
497 if (target->t.size > sizeof(TPMU_HA)) {
498 return TPM_RC_SIZE;
499 }
500 for (i = 0; i < target->t.size; ++i) {
501 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
502 if (result != TPM_RC_SUCCESS) {
503 return result;
504 }
505 }
506 return TPM_RC_SUCCESS;
507 }
508
TPM2B_AUTH_Marshal(TPM2B_AUTH * source,BYTE ** buffer,INT32 * size)509 UINT16 TPM2B_AUTH_Marshal(TPM2B_AUTH* source, BYTE** buffer, INT32* size) {
510 return TPM2B_DIGEST_Marshal(source, buffer, size);
511 }
512
TPM2B_AUTH_Unmarshal(TPM2B_AUTH * target,BYTE ** buffer,INT32 * size)513 TPM_RC TPM2B_AUTH_Unmarshal(TPM2B_AUTH* target, BYTE** buffer, INT32* size) {
514 return TPM2B_DIGEST_Unmarshal(target, buffer, size);
515 }
516
TPM2B_CONTEXT_DATA_Marshal(TPM2B_CONTEXT_DATA * source,BYTE ** buffer,INT32 * size)517 UINT16 TPM2B_CONTEXT_DATA_Marshal(TPM2B_CONTEXT_DATA* source,
518 BYTE** buffer,
519 INT32* size) {
520 UINT16 total_size = 0;
521 INT32 i;
522 total_size += UINT16_Marshal(&source->t.size, buffer, size);
523 for (i = 0; i < source->t.size; ++i) {
524 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
525 }
526 return total_size;
527 }
528
TPM2B_CONTEXT_DATA_Unmarshal(TPM2B_CONTEXT_DATA * target,BYTE ** buffer,INT32 * size)529 TPM_RC TPM2B_CONTEXT_DATA_Unmarshal(TPM2B_CONTEXT_DATA* target,
530 BYTE** buffer,
531 INT32* size) {
532 TPM_RC result;
533 INT32 i;
534 result = UINT16_Unmarshal(&target->t.size, buffer, size);
535 if (result != TPM_RC_SUCCESS) {
536 return result;
537 }
538 if (target->t.size == 0) {
539 return TPM_RC_SUCCESS;
540 }
541 if (target->t.size > sizeof(TPMS_CONTEXT_DATA)) {
542 return TPM_RC_SIZE;
543 }
544 for (i = 0; i < target->t.size; ++i) {
545 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
546 if (result != TPM_RC_SUCCESS) {
547 return result;
548 }
549 }
550 return TPM_RC_SUCCESS;
551 }
552
TPM2B_CONTEXT_SENSITIVE_Marshal(TPM2B_CONTEXT_SENSITIVE * source,BYTE ** buffer,INT32 * size)553 UINT16 TPM2B_CONTEXT_SENSITIVE_Marshal(TPM2B_CONTEXT_SENSITIVE* source,
554 BYTE** buffer,
555 INT32* size) {
556 UINT16 total_size = 0;
557 INT32 i;
558 total_size += UINT16_Marshal(&source->t.size, buffer, size);
559 for (i = 0; i < source->t.size; ++i) {
560 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
561 }
562 return total_size;
563 }
564
TPM2B_CONTEXT_SENSITIVE_Unmarshal(TPM2B_CONTEXT_SENSITIVE * target,BYTE ** buffer,INT32 * size)565 TPM_RC TPM2B_CONTEXT_SENSITIVE_Unmarshal(TPM2B_CONTEXT_SENSITIVE* target,
566 BYTE** buffer,
567 INT32* size) {
568 TPM_RC result;
569 INT32 i;
570 result = UINT16_Unmarshal(&target->t.size, buffer, size);
571 if (result != TPM_RC_SUCCESS) {
572 return result;
573 }
574 if (target->t.size == 0) {
575 return TPM_RC_SUCCESS;
576 }
577 if (target->t.size > MAX_CONTEXT_SIZE) {
578 return TPM_RC_SIZE;
579 }
580 for (i = 0; i < target->t.size; ++i) {
581 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
582 if (result != TPM_RC_SUCCESS) {
583 return result;
584 }
585 }
586 return TPM_RC_SUCCESS;
587 }
588
TPM_ALG_ID_Marshal(TPM_ALG_ID * source,BYTE ** buffer,INT32 * size)589 UINT16 TPM_ALG_ID_Marshal(TPM_ALG_ID* source, BYTE** buffer, INT32* size) {
590 return uint16_t_Marshal(source, buffer, size);
591 }
592
TPM_ALG_ID_Unmarshal(TPM_ALG_ID * target,BYTE ** buffer,INT32 * size)593 TPM_RC TPM_ALG_ID_Unmarshal(TPM_ALG_ID* target, BYTE** buffer, INT32* size) {
594 TPM_RC result;
595 result = uint16_t_Unmarshal(target, buffer, size);
596 if (result != TPM_RC_SUCCESS) {
597 return result;
598 }
599 #ifdef TPM_ALG_ERROR
600 if (*target == TPM_ALG_ERROR) {
601 return TPM_RC_SUCCESS;
602 }
603 #endif
604 #ifdef TPM_ALG_RSA
605 if (*target == TPM_ALG_RSA) {
606 return TPM_RC_SUCCESS;
607 }
608 #endif
609 #ifdef TPM_ALG_SHA
610 if (*target == TPM_ALG_SHA) {
611 return TPM_RC_SUCCESS;
612 }
613 #endif
614 #ifdef TPM_ALG_SHA1
615 if (*target == TPM_ALG_SHA1) {
616 return TPM_RC_SUCCESS;
617 }
618 #endif
619 #ifdef TPM_ALG_HMAC
620 if (*target == TPM_ALG_HMAC) {
621 return TPM_RC_SUCCESS;
622 }
623 #endif
624 #ifdef TPM_ALG_AES
625 if (*target == TPM_ALG_AES) {
626 return TPM_RC_SUCCESS;
627 }
628 #endif
629 #ifdef TPM_ALG_MGF1
630 if (*target == TPM_ALG_MGF1) {
631 return TPM_RC_SUCCESS;
632 }
633 #endif
634 #ifdef TPM_ALG_KEYEDHASH
635 if (*target == TPM_ALG_KEYEDHASH) {
636 return TPM_RC_SUCCESS;
637 }
638 #endif
639 #ifdef TPM_ALG_XOR
640 if (*target == TPM_ALG_XOR) {
641 return TPM_RC_SUCCESS;
642 }
643 #endif
644 #ifdef TPM_ALG_SHA256
645 if (*target == TPM_ALG_SHA256) {
646 return TPM_RC_SUCCESS;
647 }
648 #endif
649 #ifdef TPM_ALG_SHA384
650 if (*target == TPM_ALG_SHA384) {
651 return TPM_RC_SUCCESS;
652 }
653 #endif
654 #ifdef TPM_ALG_SHA512
655 if (*target == TPM_ALG_SHA512) {
656 return TPM_RC_SUCCESS;
657 }
658 #endif
659 #ifdef TPM_ALG_NULL
660 if (*target == TPM_ALG_NULL) {
661 return TPM_RC_SUCCESS;
662 }
663 #endif
664 #ifdef TPM_ALG_SM3_256
665 if (*target == TPM_ALG_SM3_256) {
666 return TPM_RC_SUCCESS;
667 }
668 #endif
669 #ifdef TPM_ALG_SM4
670 if (*target == TPM_ALG_SM4) {
671 return TPM_RC_SUCCESS;
672 }
673 #endif
674 #ifdef TPM_ALG_RSASSA
675 if (*target == TPM_ALG_RSASSA) {
676 return TPM_RC_SUCCESS;
677 }
678 #endif
679 #ifdef TPM_ALG_RSAES
680 if (*target == TPM_ALG_RSAES) {
681 return TPM_RC_SUCCESS;
682 }
683 #endif
684 #ifdef TPM_ALG_RSAPSS
685 if (*target == TPM_ALG_RSAPSS) {
686 return TPM_RC_SUCCESS;
687 }
688 #endif
689 #ifdef TPM_ALG_OAEP
690 if (*target == TPM_ALG_OAEP) {
691 return TPM_RC_SUCCESS;
692 }
693 #endif
694 #ifdef TPM_ALG_ECDSA
695 if (*target == TPM_ALG_ECDSA) {
696 return TPM_RC_SUCCESS;
697 }
698 #endif
699 #ifdef TPM_ALG_ECDH
700 if (*target == TPM_ALG_ECDH) {
701 return TPM_RC_SUCCESS;
702 }
703 #endif
704 #ifdef TPM_ALG_ECDAA
705 if (*target == TPM_ALG_ECDAA) {
706 return TPM_RC_SUCCESS;
707 }
708 #endif
709 #ifdef TPM_ALG_SM2
710 if (*target == TPM_ALG_SM2) {
711 return TPM_RC_SUCCESS;
712 }
713 #endif
714 #ifdef TPM_ALG_ECSCHNORR
715 if (*target == TPM_ALG_ECSCHNORR) {
716 return TPM_RC_SUCCESS;
717 }
718 #endif
719 #ifdef TPM_ALG_ECMQV
720 if (*target == TPM_ALG_ECMQV) {
721 return TPM_RC_SUCCESS;
722 }
723 #endif
724 #ifdef TPM_ALG_KDF1_SP800_56A
725 if (*target == TPM_ALG_KDF1_SP800_56A) {
726 return TPM_RC_SUCCESS;
727 }
728 #endif
729 #ifdef TPM_ALG_KDF2
730 if (*target == TPM_ALG_KDF2) {
731 return TPM_RC_SUCCESS;
732 }
733 #endif
734 #ifdef TPM_ALG_KDF1_SP800_108
735 if (*target == TPM_ALG_KDF1_SP800_108) {
736 return TPM_RC_SUCCESS;
737 }
738 #endif
739 #ifdef TPM_ALG_ECC
740 if (*target == TPM_ALG_ECC) {
741 return TPM_RC_SUCCESS;
742 }
743 #endif
744 #ifdef TPM_ALG_SYMCIPHER
745 if (*target == TPM_ALG_SYMCIPHER) {
746 return TPM_RC_SUCCESS;
747 }
748 #endif
749 #ifdef TPM_ALG_CAMELLIA
750 if (*target == TPM_ALG_CAMELLIA) {
751 return TPM_RC_SUCCESS;
752 }
753 #endif
754 #ifdef TPM_ALG_CTR
755 if (*target == TPM_ALG_CTR) {
756 return TPM_RC_SUCCESS;
757 }
758 #endif
759 #ifdef TPM_ALG_OFB
760 if (*target == TPM_ALG_OFB) {
761 return TPM_RC_SUCCESS;
762 }
763 #endif
764 #ifdef TPM_ALG_CBC
765 if (*target == TPM_ALG_CBC) {
766 return TPM_RC_SUCCESS;
767 }
768 #endif
769 #ifdef TPM_ALG_CFB
770 if (*target == TPM_ALG_CFB) {
771 return TPM_RC_SUCCESS;
772 }
773 #endif
774 #ifdef TPM_ALG_ECB
775 if (*target == TPM_ALG_ECB) {
776 return TPM_RC_SUCCESS;
777 }
778 #endif
779 return TPM_RC_VALUE;
780 }
781
TPM2B_DATA_Marshal(TPM2B_DATA * source,BYTE ** buffer,INT32 * size)782 UINT16 TPM2B_DATA_Marshal(TPM2B_DATA* source, BYTE** buffer, INT32* size) {
783 UINT16 total_size = 0;
784 INT32 i;
785 total_size += UINT16_Marshal(&source->t.size, buffer, size);
786 for (i = 0; i < source->t.size; ++i) {
787 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
788 }
789 return total_size;
790 }
791
TPM2B_DATA_Unmarshal(TPM2B_DATA * target,BYTE ** buffer,INT32 * size)792 TPM_RC TPM2B_DATA_Unmarshal(TPM2B_DATA* target, BYTE** buffer, INT32* size) {
793 TPM_RC result;
794 INT32 i;
795 result = UINT16_Unmarshal(&target->t.size, buffer, size);
796 if (result != TPM_RC_SUCCESS) {
797 return result;
798 }
799 if (target->t.size == 0) {
800 return TPM_RC_SUCCESS;
801 }
802 if (target->t.size > sizeof(TPMT_HA)) {
803 return TPM_RC_SIZE;
804 }
805 for (i = 0; i < target->t.size; ++i) {
806 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
807 if (result != TPM_RC_SUCCESS) {
808 return result;
809 }
810 }
811 return TPM_RC_SUCCESS;
812 }
813
TPMA_LOCALITY_Marshal(TPMA_LOCALITY * source,BYTE ** buffer,INT32 * size)814 UINT16 TPMA_LOCALITY_Marshal(TPMA_LOCALITY* source,
815 BYTE** buffer,
816 INT32* size) {
817 return uint8_t_Marshal((uint8_t*)source, buffer, size);
818 }
819
TPMA_LOCALITY_Unmarshal(TPMA_LOCALITY * target,BYTE ** buffer,INT32 * size)820 TPM_RC TPMA_LOCALITY_Unmarshal(TPMA_LOCALITY* target,
821 BYTE** buffer,
822 INT32* size) {
823 TPM_RC result;
824 result = uint8_t_Unmarshal((uint8_t*)target, buffer, size);
825 if (result != TPM_RC_SUCCESS) {
826 return result;
827 }
828 return TPM_RC_SUCCESS;
829 }
830
TPM2B_NAME_Marshal(TPM2B_NAME * source,BYTE ** buffer,INT32 * size)831 UINT16 TPM2B_NAME_Marshal(TPM2B_NAME* source, BYTE** buffer, INT32* size) {
832 UINT16 total_size = 0;
833 INT32 i;
834 total_size += UINT16_Marshal(&source->t.size, buffer, size);
835 for (i = 0; i < source->t.size; ++i) {
836 total_size += BYTE_Marshal(&source->t.name[i], buffer, size);
837 }
838 return total_size;
839 }
840
TPM2B_NAME_Unmarshal(TPM2B_NAME * target,BYTE ** buffer,INT32 * size)841 TPM_RC TPM2B_NAME_Unmarshal(TPM2B_NAME* target, BYTE** buffer, INT32* size) {
842 TPM_RC result;
843 INT32 i;
844 result = UINT16_Unmarshal(&target->t.size, buffer, size);
845 if (result != TPM_RC_SUCCESS) {
846 return result;
847 }
848 if (target->t.size == 0) {
849 return TPM_RC_SUCCESS;
850 }
851 if (target->t.size > sizeof(TPMU_NAME)) {
852 return TPM_RC_SIZE;
853 }
854 for (i = 0; i < target->t.size; ++i) {
855 result = BYTE_Unmarshal(&target->t.name[i], buffer, size);
856 if (result != TPM_RC_SUCCESS) {
857 return result;
858 }
859 }
860 return TPM_RC_SUCCESS;
861 }
862
TPMI_ALG_HASH_Marshal(TPMI_ALG_HASH * source,BYTE ** buffer,INT32 * size)863 UINT16 TPMI_ALG_HASH_Marshal(TPMI_ALG_HASH* source,
864 BYTE** buffer,
865 INT32* size) {
866 return uint16_t_Marshal(source, buffer, size);
867 }
868
TPMI_ALG_HASH_Unmarshal(TPMI_ALG_HASH * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)869 TPM_RC TPMI_ALG_HASH_Unmarshal(TPMI_ALG_HASH* target,
870 BYTE** buffer,
871 INT32* size,
872 BOOL allow_conditional_value) {
873 TPM_RC result;
874 BOOL has_valid_value = FALSE;
875 result = uint16_t_Unmarshal(target, buffer, size);
876 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
877 return result;
878 }
879 if (*target == TPM_ALG_NULL) {
880 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_HASH;
881 }
882 switch (*target) {
883 #ifdef TPM_ALG_SHA
884 case TPM_ALG_SHA:
885 #endif
886 #ifdef TPM_ALG_SHA1
887 case TPM_ALG_SHA1:
888 #endif
889 #ifdef TPM_ALG_SHA256
890 case TPM_ALG_SHA256:
891 #endif
892 #ifdef TPM_ALG_SHA384
893 case TPM_ALG_SHA384:
894 #endif
895 #ifdef TPM_ALG_SHA512
896 case TPM_ALG_SHA512:
897 #endif
898 #ifdef TPM_ALG_SM3_256
899 case TPM_ALG_SM3_256:
900 #endif
901 has_valid_value = TRUE;
902 break;
903 }
904 if (!has_valid_value) {
905 return TPM_RC_HASH;
906 }
907 return TPM_RC_SUCCESS;
908 }
909
UINT8_Marshal(UINT8 * source,BYTE ** buffer,INT32 * size)910 UINT16 UINT8_Marshal(UINT8* source, BYTE** buffer, INT32* size) {
911 return uint8_t_Marshal(source, buffer, size);
912 }
913
UINT8_Unmarshal(UINT8 * target,BYTE ** buffer,INT32 * size)914 TPM_RC UINT8_Unmarshal(UINT8* target, BYTE** buffer, INT32* size) {
915 return uint8_t_Unmarshal(target, buffer, size);
916 }
917
TPMS_PCR_SELECTION_Marshal(TPMS_PCR_SELECTION * source,BYTE ** buffer,INT32 * size)918 UINT16 TPMS_PCR_SELECTION_Marshal(TPMS_PCR_SELECTION* source,
919 BYTE** buffer,
920 INT32* size) {
921 UINT16 total_size = 0;
922 INT32 i;
923 total_size += TPMI_ALG_HASH_Marshal(&source->hash, buffer, size);
924 total_size += UINT8_Marshal(&source->sizeofSelect, buffer, size);
925 for (i = 0; i < source->sizeofSelect; ++i) {
926 total_size += BYTE_Marshal(&source->pcrSelect[i], buffer, size);
927 }
928 return total_size;
929 }
930
TPMS_PCR_SELECTION_Unmarshal(TPMS_PCR_SELECTION * target,BYTE ** buffer,INT32 * size)931 TPM_RC TPMS_PCR_SELECTION_Unmarshal(TPMS_PCR_SELECTION* target,
932 BYTE** buffer,
933 INT32* size) {
934 TPM_RC result;
935 INT32 i;
936 result = TPMI_ALG_HASH_Unmarshal(&target->hash, buffer, size, FALSE);
937 if (result != TPM_RC_SUCCESS) {
938 return result;
939 }
940 result = UINT8_Unmarshal(&target->sizeofSelect, buffer, size);
941 if (result != TPM_RC_SUCCESS) {
942 return result;
943 }
944 if (target->sizeofSelect > PCR_SELECT_MAX) {
945 return TPM_RC_VALUE;
946 }
947 if (target->sizeofSelect < PCR_SELECT_MIN) {
948 return TPM_RC_VALUE;
949 }
950 for (i = 0; i < target->sizeofSelect; ++i) {
951 result = BYTE_Unmarshal(&target->pcrSelect[i], buffer, size);
952 if (result != TPM_RC_SUCCESS) {
953 return result;
954 }
955 }
956 return TPM_RC_SUCCESS;
957 }
958
UINT32_Marshal(UINT32 * source,BYTE ** buffer,INT32 * size)959 UINT16 UINT32_Marshal(UINT32* source, BYTE** buffer, INT32* size) {
960 return uint32_t_Marshal(source, buffer, size);
961 }
962
UINT32_Unmarshal(UINT32 * target,BYTE ** buffer,INT32 * size)963 TPM_RC UINT32_Unmarshal(UINT32* target, BYTE** buffer, INT32* size) {
964 return uint32_t_Unmarshal(target, buffer, size);
965 }
966
TPML_PCR_SELECTION_Marshal(TPML_PCR_SELECTION * source,BYTE ** buffer,INT32 * size)967 UINT16 TPML_PCR_SELECTION_Marshal(TPML_PCR_SELECTION* source,
968 BYTE** buffer,
969 INT32* size) {
970 UINT16 total_size = 0;
971 INT32 i;
972 total_size += UINT32_Marshal(&source->count, buffer, size);
973 for (i = 0; i < source->count; ++i) {
974 total_size +=
975 TPMS_PCR_SELECTION_Marshal(&source->pcrSelections[i], buffer, size);
976 }
977 return total_size;
978 }
979
TPML_PCR_SELECTION_Unmarshal(TPML_PCR_SELECTION * target,BYTE ** buffer,INT32 * size)980 TPM_RC TPML_PCR_SELECTION_Unmarshal(TPML_PCR_SELECTION* target,
981 BYTE** buffer,
982 INT32* size) {
983 TPM_RC result;
984 INT32 i;
985 result = UINT32_Unmarshal(&target->count, buffer, size);
986 if (result != TPM_RC_SUCCESS) {
987 return result;
988 }
989 if (target->count > HASH_COUNT) {
990 return TPM_RC_SIZE;
991 }
992 for (i = 0; i < target->count; ++i) {
993 result =
994 TPMS_PCR_SELECTION_Unmarshal(&target->pcrSelections[i], buffer, size);
995 if (result != TPM_RC_SUCCESS) {
996 return result;
997 }
998 }
999 return TPM_RC_SUCCESS;
1000 }
1001
TPMS_CREATION_DATA_Marshal(TPMS_CREATION_DATA * source,BYTE ** buffer,INT32 * size)1002 UINT16 TPMS_CREATION_DATA_Marshal(TPMS_CREATION_DATA* source,
1003 BYTE** buffer,
1004 INT32* size) {
1005 UINT16 total_size = 0;
1006 total_size += TPML_PCR_SELECTION_Marshal(&source->pcrSelect, buffer, size);
1007 total_size += TPM2B_DIGEST_Marshal(&source->pcrDigest, buffer, size);
1008 total_size += TPMA_LOCALITY_Marshal(&source->locality, buffer, size);
1009 total_size += TPM_ALG_ID_Marshal(&source->parentNameAlg, buffer, size);
1010 total_size += TPM2B_NAME_Marshal(&source->parentName, buffer, size);
1011 total_size += TPM2B_NAME_Marshal(&source->parentQualifiedName, buffer, size);
1012 total_size += TPM2B_DATA_Marshal(&source->outsideInfo, buffer, size);
1013 return total_size;
1014 }
1015
TPMS_CREATION_DATA_Unmarshal(TPMS_CREATION_DATA * target,BYTE ** buffer,INT32 * size)1016 TPM_RC TPMS_CREATION_DATA_Unmarshal(TPMS_CREATION_DATA* target,
1017 BYTE** buffer,
1018 INT32* size) {
1019 TPM_RC result;
1020 result = TPML_PCR_SELECTION_Unmarshal(&target->pcrSelect, buffer, size);
1021 if (result != TPM_RC_SUCCESS) {
1022 return result;
1023 }
1024 result = TPM2B_DIGEST_Unmarshal(&target->pcrDigest, buffer, size);
1025 if (result != TPM_RC_SUCCESS) {
1026 return result;
1027 }
1028 result = TPMA_LOCALITY_Unmarshal(&target->locality, buffer, size);
1029 if (result != TPM_RC_SUCCESS) {
1030 return result;
1031 }
1032 result = TPM_ALG_ID_Unmarshal(&target->parentNameAlg, buffer, size);
1033 if (result != TPM_RC_SUCCESS) {
1034 return result;
1035 }
1036 result = TPM2B_NAME_Unmarshal(&target->parentName, buffer, size);
1037 if (result != TPM_RC_SUCCESS) {
1038 return result;
1039 }
1040 result = TPM2B_NAME_Unmarshal(&target->parentQualifiedName, buffer, size);
1041 if (result != TPM_RC_SUCCESS) {
1042 return result;
1043 }
1044 result = TPM2B_DATA_Unmarshal(&target->outsideInfo, buffer, size);
1045 if (result != TPM_RC_SUCCESS) {
1046 return result;
1047 }
1048 return TPM_RC_SUCCESS;
1049 }
1050
TPM2B_CREATION_DATA_Marshal(TPM2B_CREATION_DATA * source,BYTE ** buffer,INT32 * size)1051 UINT16 TPM2B_CREATION_DATA_Marshal(TPM2B_CREATION_DATA* source,
1052 BYTE** buffer,
1053 INT32* size) {
1054 UINT16 total_size = 0;
1055 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1056 total_size +=
1057 TPMS_CREATION_DATA_Marshal(&source->t.creationData, buffer, size);
1058 {
1059 BYTE* size_location = *buffer - total_size;
1060 INT32 size_field_size = sizeof(UINT16);
1061 UINT16 payload_size = total_size - (UINT16)size_field_size;
1062 UINT16_Marshal(&payload_size, &size_location, &size_field_size);
1063 }
1064 return total_size;
1065 }
1066
TPM2B_CREATION_DATA_Unmarshal(TPM2B_CREATION_DATA * target,BYTE ** buffer,INT32 * size)1067 TPM_RC TPM2B_CREATION_DATA_Unmarshal(TPM2B_CREATION_DATA* target,
1068 BYTE** buffer,
1069 INT32* size) {
1070 TPM_RC result;
1071 UINT32 start_size = *size;
1072 UINT32 struct_size;
1073 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1074 if (result != TPM_RC_SUCCESS) {
1075 return result;
1076 }
1077 if (target->t.size == 0) {
1078 return TPM_RC_SIZE;
1079 }
1080 result = TPMS_CREATION_DATA_Unmarshal(&target->t.creationData, buffer, size);
1081 if (result != TPM_RC_SUCCESS) {
1082 return result;
1083 }
1084 struct_size = start_size - *size - sizeof(target->t.size);
1085 if (struct_size != target->t.size) {
1086 return TPM_RC_SIZE;
1087 }
1088 return TPM_RC_SUCCESS;
1089 }
1090
TPM2B_DIGEST_VALUES_Marshal(TPM2B_DIGEST_VALUES * source,BYTE ** buffer,INT32 * size)1091 UINT16 TPM2B_DIGEST_VALUES_Marshal(TPM2B_DIGEST_VALUES* source,
1092 BYTE** buffer,
1093 INT32* size) {
1094 UINT16 total_size = 0;
1095 INT32 i;
1096 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1097 for (i = 0; i < source->t.size; ++i) {
1098 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1099 }
1100 return total_size;
1101 }
1102
TPM2B_DIGEST_VALUES_Unmarshal(TPM2B_DIGEST_VALUES * target,BYTE ** buffer,INT32 * size)1103 TPM_RC TPM2B_DIGEST_VALUES_Unmarshal(TPM2B_DIGEST_VALUES* target,
1104 BYTE** buffer,
1105 INT32* size) {
1106 TPM_RC result;
1107 INT32 i;
1108 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1109 if (result != TPM_RC_SUCCESS) {
1110 return result;
1111 }
1112 if (target->t.size == 0) {
1113 return TPM_RC_SUCCESS;
1114 }
1115 if (target->t.size > sizeof(TPML_DIGEST_VALUES)) {
1116 return TPM_RC_SIZE;
1117 }
1118 for (i = 0; i < target->t.size; ++i) {
1119 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1120 if (result != TPM_RC_SUCCESS) {
1121 return result;
1122 }
1123 }
1124 return TPM_RC_SUCCESS;
1125 }
1126
TPM2B_ECC_PARAMETER_Marshal(TPM2B_ECC_PARAMETER * source,BYTE ** buffer,INT32 * size)1127 UINT16 TPM2B_ECC_PARAMETER_Marshal(TPM2B_ECC_PARAMETER* source,
1128 BYTE** buffer,
1129 INT32* size) {
1130 UINT16 total_size = 0;
1131 INT32 i;
1132 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1133 for (i = 0; i < source->t.size; ++i) {
1134 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1135 }
1136 return total_size;
1137 }
1138
TPM2B_ECC_PARAMETER_Unmarshal(TPM2B_ECC_PARAMETER * target,BYTE ** buffer,INT32 * size)1139 TPM_RC TPM2B_ECC_PARAMETER_Unmarshal(TPM2B_ECC_PARAMETER* target,
1140 BYTE** buffer,
1141 INT32* size) {
1142 TPM_RC result;
1143 INT32 i;
1144 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1145 if (result != TPM_RC_SUCCESS) {
1146 return result;
1147 }
1148 if (target->t.size == 0) {
1149 return TPM_RC_SUCCESS;
1150 }
1151 if (target->t.size > MAX_ECC_KEY_BYTES) {
1152 return TPM_RC_SIZE;
1153 }
1154 for (i = 0; i < target->t.size; ++i) {
1155 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1156 if (result != TPM_RC_SUCCESS) {
1157 return result;
1158 }
1159 }
1160 return TPM_RC_SUCCESS;
1161 }
1162
TPMS_ECC_POINT_Marshal(TPMS_ECC_POINT * source,BYTE ** buffer,INT32 * size)1163 UINT16 TPMS_ECC_POINT_Marshal(TPMS_ECC_POINT* source,
1164 BYTE** buffer,
1165 INT32* size) {
1166 UINT16 total_size = 0;
1167 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->x, buffer, size);
1168 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->y, buffer, size);
1169 return total_size;
1170 }
1171
TPMS_ECC_POINT_Unmarshal(TPMS_ECC_POINT * target,BYTE ** buffer,INT32 * size)1172 TPM_RC TPMS_ECC_POINT_Unmarshal(TPMS_ECC_POINT* target,
1173 BYTE** buffer,
1174 INT32* size) {
1175 TPM_RC result;
1176 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->x, buffer, size);
1177 if (result != TPM_RC_SUCCESS) {
1178 return result;
1179 }
1180 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->y, buffer, size);
1181 if (result != TPM_RC_SUCCESS) {
1182 return result;
1183 }
1184 return TPM_RC_SUCCESS;
1185 }
1186
TPM2B_ECC_POINT_Marshal(TPM2B_ECC_POINT * source,BYTE ** buffer,INT32 * size)1187 UINT16 TPM2B_ECC_POINT_Marshal(TPM2B_ECC_POINT* source,
1188 BYTE** buffer,
1189 INT32* size) {
1190 UINT16 total_size = 0;
1191 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1192 total_size += TPMS_ECC_POINT_Marshal(&source->t.point, buffer, size);
1193 {
1194 BYTE* size_location = *buffer - total_size;
1195 INT32 size_field_size = sizeof(UINT16);
1196 UINT16 payload_size = total_size - (UINT16)size_field_size;
1197 UINT16_Marshal(&payload_size, &size_location, &size_field_size);
1198 }
1199 return total_size;
1200 }
1201
TPM2B_ECC_POINT_Unmarshal(TPM2B_ECC_POINT * target,BYTE ** buffer,INT32 * size)1202 TPM_RC TPM2B_ECC_POINT_Unmarshal(TPM2B_ECC_POINT* target,
1203 BYTE** buffer,
1204 INT32* size) {
1205 TPM_RC result;
1206 UINT32 start_size = *size;
1207 UINT32 struct_size;
1208 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1209 if (result != TPM_RC_SUCCESS) {
1210 return result;
1211 }
1212 if (target->t.size == 0) {
1213 return TPM_RC_SIZE;
1214 }
1215 result = TPMS_ECC_POINT_Unmarshal(&target->t.point, buffer, size);
1216 if (result != TPM_RC_SUCCESS) {
1217 return result;
1218 }
1219 struct_size = start_size - *size - sizeof(target->t.size);
1220 if (struct_size != target->t.size) {
1221 return TPM_RC_SIZE;
1222 }
1223 return TPM_RC_SUCCESS;
1224 }
1225
TPM2B_ENCRYPTED_SECRET_Marshal(TPM2B_ENCRYPTED_SECRET * source,BYTE ** buffer,INT32 * size)1226 UINT16 TPM2B_ENCRYPTED_SECRET_Marshal(TPM2B_ENCRYPTED_SECRET* source,
1227 BYTE** buffer,
1228 INT32* size) {
1229 UINT16 total_size = 0;
1230 INT32 i;
1231 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1232 for (i = 0; i < source->t.size; ++i) {
1233 total_size += BYTE_Marshal(&source->t.secret[i], buffer, size);
1234 }
1235 return total_size;
1236 }
1237
TPM2B_ENCRYPTED_SECRET_Unmarshal(TPM2B_ENCRYPTED_SECRET * target,BYTE ** buffer,INT32 * size)1238 TPM_RC TPM2B_ENCRYPTED_SECRET_Unmarshal(TPM2B_ENCRYPTED_SECRET* target,
1239 BYTE** buffer,
1240 INT32* size) {
1241 TPM_RC result;
1242 INT32 i;
1243 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1244 if (result != TPM_RC_SUCCESS) {
1245 return result;
1246 }
1247 if (target->t.size == 0) {
1248 return TPM_RC_SUCCESS;
1249 }
1250 if (target->t.size > sizeof(TPMU_ENCRYPTED_SECRET)) {
1251 return TPM_RC_SIZE;
1252 }
1253 for (i = 0; i < target->t.size; ++i) {
1254 result = BYTE_Unmarshal(&target->t.secret[i], buffer, size);
1255 if (result != TPM_RC_SUCCESS) {
1256 return result;
1257 }
1258 }
1259 return TPM_RC_SUCCESS;
1260 }
1261
TPM2B_EVENT_Marshal(TPM2B_EVENT * source,BYTE ** buffer,INT32 * size)1262 UINT16 TPM2B_EVENT_Marshal(TPM2B_EVENT* source, BYTE** buffer, INT32* size) {
1263 UINT16 total_size = 0;
1264 INT32 i;
1265 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1266 for (i = 0; i < source->t.size; ++i) {
1267 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1268 }
1269 return total_size;
1270 }
1271
TPM2B_EVENT_Unmarshal(TPM2B_EVENT * target,BYTE ** buffer,INT32 * size)1272 TPM_RC TPM2B_EVENT_Unmarshal(TPM2B_EVENT* target, BYTE** buffer, INT32* size) {
1273 TPM_RC result;
1274 INT32 i;
1275 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1276 if (result != TPM_RC_SUCCESS) {
1277 return result;
1278 }
1279 if (target->t.size == 0) {
1280 return TPM_RC_SUCCESS;
1281 }
1282 if (target->t.size > 1024) {
1283 return TPM_RC_SIZE;
1284 }
1285 for (i = 0; i < target->t.size; ++i) {
1286 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1287 if (result != TPM_RC_SUCCESS) {
1288 return result;
1289 }
1290 }
1291 return TPM_RC_SUCCESS;
1292 }
1293
TPM2B_ID_OBJECT_Marshal(TPM2B_ID_OBJECT * source,BYTE ** buffer,INT32 * size)1294 UINT16 TPM2B_ID_OBJECT_Marshal(TPM2B_ID_OBJECT* source,
1295 BYTE** buffer,
1296 INT32* size) {
1297 UINT16 total_size = 0;
1298 INT32 i;
1299 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1300 for (i = 0; i < source->t.size; ++i) {
1301 total_size += BYTE_Marshal(&source->t.credential[i], buffer, size);
1302 }
1303 return total_size;
1304 }
1305
TPM2B_ID_OBJECT_Unmarshal(TPM2B_ID_OBJECT * target,BYTE ** buffer,INT32 * size)1306 TPM_RC TPM2B_ID_OBJECT_Unmarshal(TPM2B_ID_OBJECT* target,
1307 BYTE** buffer,
1308 INT32* size) {
1309 TPM_RC result;
1310 INT32 i;
1311 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1312 if (result != TPM_RC_SUCCESS) {
1313 return result;
1314 }
1315 if (target->t.size == 0) {
1316 return TPM_RC_SUCCESS;
1317 }
1318 if (target->t.size > sizeof(_ID_OBJECT)) {
1319 return TPM_RC_SIZE;
1320 }
1321 for (i = 0; i < target->t.size; ++i) {
1322 result = BYTE_Unmarshal(&target->t.credential[i], buffer, size);
1323 if (result != TPM_RC_SUCCESS) {
1324 return result;
1325 }
1326 }
1327 return TPM_RC_SUCCESS;
1328 }
1329
TPM2B_IV_Marshal(TPM2B_IV * source,BYTE ** buffer,INT32 * size)1330 UINT16 TPM2B_IV_Marshal(TPM2B_IV* source, BYTE** buffer, INT32* size) {
1331 UINT16 total_size = 0;
1332 INT32 i;
1333 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1334 for (i = 0; i < source->t.size; ++i) {
1335 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1336 }
1337 return total_size;
1338 }
1339
TPM2B_IV_Unmarshal(TPM2B_IV * target,BYTE ** buffer,INT32 * size)1340 TPM_RC TPM2B_IV_Unmarshal(TPM2B_IV* target, BYTE** buffer, INT32* size) {
1341 TPM_RC result;
1342 INT32 i;
1343 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1344 if (result != TPM_RC_SUCCESS) {
1345 return result;
1346 }
1347 if (target->t.size == 0) {
1348 return TPM_RC_SUCCESS;
1349 }
1350 if (target->t.size > MAX_SYM_BLOCK_SIZE) {
1351 return TPM_RC_SIZE;
1352 }
1353 for (i = 0; i < target->t.size; ++i) {
1354 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1355 if (result != TPM_RC_SUCCESS) {
1356 return result;
1357 }
1358 }
1359 return TPM_RC_SUCCESS;
1360 }
1361
TPM2B_MAX_BUFFER_Marshal(TPM2B_MAX_BUFFER * source,BYTE ** buffer,INT32 * size)1362 UINT16 TPM2B_MAX_BUFFER_Marshal(TPM2B_MAX_BUFFER* source,
1363 BYTE** buffer,
1364 INT32* size) {
1365 UINT16 total_size = 0;
1366 INT32 i;
1367 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1368 for (i = 0; i < source->t.size; ++i) {
1369 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1370 }
1371 return total_size;
1372 }
1373
TPM2B_MAX_BUFFER_Unmarshal(TPM2B_MAX_BUFFER * target,BYTE ** buffer,INT32 * size)1374 TPM_RC TPM2B_MAX_BUFFER_Unmarshal(TPM2B_MAX_BUFFER* target,
1375 BYTE** buffer,
1376 INT32* size) {
1377 TPM_RC result;
1378 INT32 i;
1379 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1380 if (result != TPM_RC_SUCCESS) {
1381 return result;
1382 }
1383 if (target->t.size == 0) {
1384 return TPM_RC_SUCCESS;
1385 }
1386 if (target->t.size > MAX_DIGEST_BUFFER) {
1387 return TPM_RC_SIZE;
1388 }
1389 for (i = 0; i < target->t.size; ++i) {
1390 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1391 if (result != TPM_RC_SUCCESS) {
1392 return result;
1393 }
1394 }
1395 return TPM_RC_SUCCESS;
1396 }
1397
TPM2B_MAX_NV_BUFFER_Marshal(TPM2B_MAX_NV_BUFFER * source,BYTE ** buffer,INT32 * size)1398 UINT16 TPM2B_MAX_NV_BUFFER_Marshal(TPM2B_MAX_NV_BUFFER* source,
1399 BYTE** buffer,
1400 INT32* size) {
1401 UINT16 total_size = 0;
1402 INT32 i;
1403 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1404 for (i = 0; i < source->t.size; ++i) {
1405 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1406 }
1407 return total_size;
1408 }
1409
TPM2B_MAX_NV_BUFFER_Unmarshal(TPM2B_MAX_NV_BUFFER * target,BYTE ** buffer,INT32 * size)1410 TPM_RC TPM2B_MAX_NV_BUFFER_Unmarshal(TPM2B_MAX_NV_BUFFER* target,
1411 BYTE** buffer,
1412 INT32* size) {
1413 TPM_RC result;
1414 INT32 i;
1415 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1416 if (result != TPM_RC_SUCCESS) {
1417 return result;
1418 }
1419 if (target->t.size == 0) {
1420 return TPM_RC_SUCCESS;
1421 }
1422 if (target->t.size > MAX_NV_BUFFER_SIZE) {
1423 return TPM_RC_SIZE;
1424 }
1425 for (i = 0; i < target->t.size; ++i) {
1426 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1427 if (result != TPM_RC_SUCCESS) {
1428 return result;
1429 }
1430 }
1431 return TPM_RC_SUCCESS;
1432 }
1433
TPM2B_NONCE_Marshal(TPM2B_NONCE * source,BYTE ** buffer,INT32 * size)1434 UINT16 TPM2B_NONCE_Marshal(TPM2B_NONCE* source, BYTE** buffer, INT32* size) {
1435 return TPM2B_DIGEST_Marshal(source, buffer, size);
1436 }
1437
TPM2B_NONCE_Unmarshal(TPM2B_NONCE * target,BYTE ** buffer,INT32 * size)1438 TPM_RC TPM2B_NONCE_Unmarshal(TPM2B_NONCE* target, BYTE** buffer, INT32* size) {
1439 return TPM2B_DIGEST_Unmarshal(target, buffer, size);
1440 }
1441
TPMI_RH_NV_INDEX_Marshal(TPMI_RH_NV_INDEX * source,BYTE ** buffer,INT32 * size)1442 UINT16 TPMI_RH_NV_INDEX_Marshal(TPMI_RH_NV_INDEX* source,
1443 BYTE** buffer,
1444 INT32* size) {
1445 return uint32_t_Marshal(source, buffer, size);
1446 }
1447
TPMI_RH_NV_INDEX_Unmarshal(TPMI_RH_NV_INDEX * target,BYTE ** buffer,INT32 * size)1448 TPM_RC TPMI_RH_NV_INDEX_Unmarshal(TPMI_RH_NV_INDEX* target,
1449 BYTE** buffer,
1450 INT32* size) {
1451 TPM_RC result;
1452 BOOL has_valid_value = FALSE;
1453 result = uint32_t_Unmarshal(target, buffer, size);
1454 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
1455 return result;
1456 }
1457 if ((*target >= NV_INDEX_FIRST) && (*target <= NV_INDEX_LAST)) {
1458 has_valid_value = TRUE;
1459 }
1460 if (!has_valid_value) {
1461 return TPM_RC_VALUE;
1462 }
1463 return TPM_RC_SUCCESS;
1464 }
1465
TPMA_NV_Marshal(TPMA_NV * source,BYTE ** buffer,INT32 * size)1466 UINT16 TPMA_NV_Marshal(TPMA_NV* source, BYTE** buffer, INT32* size) {
1467 return uint32_t_Marshal((uint32_t*)source, buffer, size);
1468 }
1469
TPMA_NV_Unmarshal(TPMA_NV * target,BYTE ** buffer,INT32 * size)1470 TPM_RC TPMA_NV_Unmarshal(TPMA_NV* target, BYTE** buffer, INT32* size) {
1471 TPM_RC result;
1472 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
1473 if (result != TPM_RC_SUCCESS) {
1474 return result;
1475 }
1476 if (target->reserved7_9 != 0) {
1477 return TPM_RC_RESERVED_BITS;
1478 }
1479 if (target->reserved20_24 != 0) {
1480 return TPM_RC_RESERVED_BITS;
1481 }
1482 return TPM_RC_SUCCESS;
1483 }
1484
TPMS_NV_PUBLIC_Marshal(TPMS_NV_PUBLIC * source,BYTE ** buffer,INT32 * size)1485 UINT16 TPMS_NV_PUBLIC_Marshal(TPMS_NV_PUBLIC* source,
1486 BYTE** buffer,
1487 INT32* size) {
1488 UINT16 total_size = 0;
1489 total_size += TPMI_RH_NV_INDEX_Marshal(&source->nvIndex, buffer, size);
1490 total_size += TPMI_ALG_HASH_Marshal(&source->nameAlg, buffer, size);
1491 total_size += TPMA_NV_Marshal(&source->attributes, buffer, size);
1492 total_size += TPM2B_DIGEST_Marshal(&source->authPolicy, buffer, size);
1493 total_size += UINT16_Marshal(&source->dataSize, buffer, size);
1494 return total_size;
1495 }
1496
TPMS_NV_PUBLIC_Unmarshal(TPMS_NV_PUBLIC * target,BYTE ** buffer,INT32 * size)1497 TPM_RC TPMS_NV_PUBLIC_Unmarshal(TPMS_NV_PUBLIC* target,
1498 BYTE** buffer,
1499 INT32* size) {
1500 TPM_RC result;
1501 result = TPMI_RH_NV_INDEX_Unmarshal(&target->nvIndex, buffer, size);
1502 if (result != TPM_RC_SUCCESS) {
1503 return result;
1504 }
1505 result = TPMI_ALG_HASH_Unmarshal(&target->nameAlg, buffer, size, FALSE);
1506 if (result != TPM_RC_SUCCESS) {
1507 return result;
1508 }
1509 result = TPMA_NV_Unmarshal(&target->attributes, buffer, size);
1510 if (result != TPM_RC_SUCCESS) {
1511 return result;
1512 }
1513 result = TPM2B_DIGEST_Unmarshal(&target->authPolicy, buffer, size);
1514 if (result != TPM_RC_SUCCESS) {
1515 return result;
1516 }
1517 result = UINT16_Unmarshal(&target->dataSize, buffer, size);
1518 if (result != TPM_RC_SUCCESS) {
1519 return result;
1520 }
1521 if (target->dataSize > MAX_NV_INDEX_SIZE) {
1522 return TPM_RC_SIZE;
1523 }
1524 return TPM_RC_SUCCESS;
1525 }
1526
TPM2B_NV_PUBLIC_Marshal(TPM2B_NV_PUBLIC * source,BYTE ** buffer,INT32 * size)1527 UINT16 TPM2B_NV_PUBLIC_Marshal(TPM2B_NV_PUBLIC* source,
1528 BYTE** buffer,
1529 INT32* size) {
1530 UINT16 total_size = 0;
1531 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1532 total_size += TPMS_NV_PUBLIC_Marshal(&source->t.nvPublic, buffer, size);
1533 {
1534 BYTE* size_location = *buffer - total_size;
1535 INT32 size_field_size = sizeof(UINT16);
1536 UINT16 payload_size = total_size - (UINT16)size_field_size;
1537 UINT16_Marshal(&payload_size, &size_location, &size_field_size);
1538 }
1539 return total_size;
1540 }
1541
TPM2B_NV_PUBLIC_Unmarshal(TPM2B_NV_PUBLIC * target,BYTE ** buffer,INT32 * size)1542 TPM_RC TPM2B_NV_PUBLIC_Unmarshal(TPM2B_NV_PUBLIC* target,
1543 BYTE** buffer,
1544 INT32* size) {
1545 TPM_RC result;
1546 UINT32 start_size = *size;
1547 UINT32 struct_size;
1548 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1549 if (result != TPM_RC_SUCCESS) {
1550 return result;
1551 }
1552 if (target->t.size == 0) {
1553 return TPM_RC_SIZE;
1554 }
1555 result = TPMS_NV_PUBLIC_Unmarshal(&target->t.nvPublic, buffer, size);
1556 if (result != TPM_RC_SUCCESS) {
1557 return result;
1558 }
1559 struct_size = start_size - *size - sizeof(target->t.size);
1560 if (struct_size != target->t.size) {
1561 return TPM_RC_SIZE;
1562 }
1563 return TPM_RC_SUCCESS;
1564 }
1565
TPM2B_OPERAND_Marshal(TPM2B_OPERAND * source,BYTE ** buffer,INT32 * size)1566 UINT16 TPM2B_OPERAND_Marshal(TPM2B_OPERAND* source,
1567 BYTE** buffer,
1568 INT32* size) {
1569 return TPM2B_DIGEST_Marshal(source, buffer, size);
1570 }
1571
TPM2B_OPERAND_Unmarshal(TPM2B_OPERAND * target,BYTE ** buffer,INT32 * size)1572 TPM_RC TPM2B_OPERAND_Unmarshal(TPM2B_OPERAND* target,
1573 BYTE** buffer,
1574 INT32* size) {
1575 return TPM2B_DIGEST_Unmarshal(target, buffer, size);
1576 }
1577
TPM2B_PRIVATE_Marshal(TPM2B_PRIVATE * source,BYTE ** buffer,INT32 * size)1578 UINT16 TPM2B_PRIVATE_Marshal(TPM2B_PRIVATE* source,
1579 BYTE** buffer,
1580 INT32* size) {
1581 UINT16 total_size = 0;
1582 INT32 i;
1583 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1584 for (i = 0; i < source->t.size; ++i) {
1585 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1586 }
1587 return total_size;
1588 }
1589
TPM2B_PRIVATE_Unmarshal(TPM2B_PRIVATE * target,BYTE ** buffer,INT32 * size)1590 TPM_RC TPM2B_PRIVATE_Unmarshal(TPM2B_PRIVATE* target,
1591 BYTE** buffer,
1592 INT32* size) {
1593 TPM_RC result;
1594 INT32 i;
1595 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1596 if (result != TPM_RC_SUCCESS) {
1597 return result;
1598 }
1599 if (target->t.size == 0) {
1600 return TPM_RC_SUCCESS;
1601 }
1602 if (target->t.size > sizeof(_PRIVATE)) {
1603 return TPM_RC_SIZE;
1604 }
1605 for (i = 0; i < target->t.size; ++i) {
1606 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1607 if (result != TPM_RC_SUCCESS) {
1608 return result;
1609 }
1610 }
1611 return TPM_RC_SUCCESS;
1612 }
1613
TPM2B_PRIVATE_KEY_RSA_Marshal(TPM2B_PRIVATE_KEY_RSA * source,BYTE ** buffer,INT32 * size)1614 UINT16 TPM2B_PRIVATE_KEY_RSA_Marshal(TPM2B_PRIVATE_KEY_RSA* source,
1615 BYTE** buffer,
1616 INT32* size) {
1617 UINT16 total_size = 0;
1618 INT32 i;
1619 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1620 for (i = 0; i < source->t.size; ++i) {
1621 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1622 }
1623 return total_size;
1624 }
1625
TPM2B_PRIVATE_KEY_RSA_Unmarshal(TPM2B_PRIVATE_KEY_RSA * target,BYTE ** buffer,INT32 * size)1626 TPM_RC TPM2B_PRIVATE_KEY_RSA_Unmarshal(TPM2B_PRIVATE_KEY_RSA* target,
1627 BYTE** buffer,
1628 INT32* size) {
1629 TPM_RC result;
1630 INT32 i;
1631 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1632 if (result != TPM_RC_SUCCESS) {
1633 return result;
1634 }
1635 if (target->t.size == 0) {
1636 return TPM_RC_SUCCESS;
1637 }
1638 if (target->t.size > MAX_RSA_KEY_BYTES / 2) {
1639 return TPM_RC_SIZE;
1640 }
1641 for (i = 0; i < target->t.size; ++i) {
1642 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1643 if (result != TPM_RC_SUCCESS) {
1644 return result;
1645 }
1646 }
1647 return TPM_RC_SUCCESS;
1648 }
1649
TPM2B_PRIVATE_VENDOR_SPECIFIC_Marshal(TPM2B_PRIVATE_VENDOR_SPECIFIC * source,BYTE ** buffer,INT32 * size)1650 UINT16 TPM2B_PRIVATE_VENDOR_SPECIFIC_Marshal(
1651 TPM2B_PRIVATE_VENDOR_SPECIFIC* source,
1652 BYTE** buffer,
1653 INT32* size) {
1654 UINT16 total_size = 0;
1655 INT32 i;
1656 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1657 for (i = 0; i < source->t.size; ++i) {
1658 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1659 }
1660 return total_size;
1661 }
1662
TPM2B_PRIVATE_VENDOR_SPECIFIC_Unmarshal(TPM2B_PRIVATE_VENDOR_SPECIFIC * target,BYTE ** buffer,INT32 * size)1663 TPM_RC TPM2B_PRIVATE_VENDOR_SPECIFIC_Unmarshal(
1664 TPM2B_PRIVATE_VENDOR_SPECIFIC* target,
1665 BYTE** buffer,
1666 INT32* size) {
1667 TPM_RC result;
1668 INT32 i;
1669 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1670 if (result != TPM_RC_SUCCESS) {
1671 return result;
1672 }
1673 if (target->t.size == 0) {
1674 return TPM_RC_SUCCESS;
1675 }
1676 if (target->t.size > PRIVATE_VENDOR_SPECIFIC_BYTES) {
1677 return TPM_RC_SIZE;
1678 }
1679 for (i = 0; i < target->t.size; ++i) {
1680 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1681 if (result != TPM_RC_SUCCESS) {
1682 return result;
1683 }
1684 }
1685 return TPM_RC_SUCCESS;
1686 }
1687
TPMA_OBJECT_Marshal(TPMA_OBJECT * source,BYTE ** buffer,INT32 * size)1688 UINT16 TPMA_OBJECT_Marshal(TPMA_OBJECT* source, BYTE** buffer, INT32* size) {
1689 return uint32_t_Marshal((uint32_t*)source, buffer, size);
1690 }
1691
TPMA_OBJECT_Unmarshal(TPMA_OBJECT * target,BYTE ** buffer,INT32 * size)1692 TPM_RC TPMA_OBJECT_Unmarshal(TPMA_OBJECT* target, BYTE** buffer, INT32* size) {
1693 TPM_RC result;
1694 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
1695 if (result != TPM_RC_SUCCESS) {
1696 return result;
1697 }
1698 if (target->reserved0 != 0) {
1699 return TPM_RC_RESERVED_BITS;
1700 }
1701 if (target->reserved3 != 0) {
1702 return TPM_RC_RESERVED_BITS;
1703 }
1704 if (target->reserved8_9 != 0) {
1705 return TPM_RC_RESERVED_BITS;
1706 }
1707 if (target->reserved12_15 != 0) {
1708 return TPM_RC_RESERVED_BITS;
1709 }
1710 if (target->reserved19_31 != 0) {
1711 return TPM_RC_RESERVED_BITS;
1712 }
1713 return TPM_RC_SUCCESS;
1714 }
1715
TPMI_ALG_PUBLIC_Marshal(TPMI_ALG_PUBLIC * source,BYTE ** buffer,INT32 * size)1716 UINT16 TPMI_ALG_PUBLIC_Marshal(TPMI_ALG_PUBLIC* source,
1717 BYTE** buffer,
1718 INT32* size) {
1719 return uint16_t_Marshal(source, buffer, size);
1720 }
1721
TPMI_ALG_PUBLIC_Unmarshal(TPMI_ALG_PUBLIC * target,BYTE ** buffer,INT32 * size)1722 TPM_RC TPMI_ALG_PUBLIC_Unmarshal(TPMI_ALG_PUBLIC* target,
1723 BYTE** buffer,
1724 INT32* size) {
1725 TPM_RC result;
1726 BOOL has_valid_value = FALSE;
1727 result = uint16_t_Unmarshal(target, buffer, size);
1728 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
1729 return result;
1730 }
1731 switch (*target) {
1732 #ifdef TPM_ALG_RSA
1733 case TPM_ALG_RSA:
1734 #endif
1735 #ifdef TPM_ALG_KEYEDHASH
1736 case TPM_ALG_KEYEDHASH:
1737 #endif
1738 #ifdef TPM_ALG_ECC
1739 case TPM_ALG_ECC:
1740 #endif
1741 #ifdef TPM_ALG_SYMCIPHER
1742 case TPM_ALG_SYMCIPHER:
1743 #endif
1744 has_valid_value = TRUE;
1745 break;
1746 }
1747 if (!has_valid_value) {
1748 return TPM_RC_TYPE;
1749 }
1750 return TPM_RC_SUCCESS;
1751 }
1752
TPM2B_PUBLIC_KEY_RSA_Marshal(TPM2B_PUBLIC_KEY_RSA * source,BYTE ** buffer,INT32 * size)1753 UINT16 TPM2B_PUBLIC_KEY_RSA_Marshal(TPM2B_PUBLIC_KEY_RSA* source,
1754 BYTE** buffer,
1755 INT32* size) {
1756 UINT16 total_size = 0;
1757 INT32 i;
1758 total_size += UINT16_Marshal(&source->t.size, buffer, size);
1759 for (i = 0; i < source->t.size; ++i) {
1760 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
1761 }
1762 return total_size;
1763 }
1764
TPM2B_PUBLIC_KEY_RSA_Unmarshal(TPM2B_PUBLIC_KEY_RSA * target,BYTE ** buffer,INT32 * size)1765 TPM_RC TPM2B_PUBLIC_KEY_RSA_Unmarshal(TPM2B_PUBLIC_KEY_RSA* target,
1766 BYTE** buffer,
1767 INT32* size) {
1768 TPM_RC result;
1769 INT32 i;
1770 result = UINT16_Unmarshal(&target->t.size, buffer, size);
1771 if (result != TPM_RC_SUCCESS) {
1772 return result;
1773 }
1774 if (target->t.size == 0) {
1775 return TPM_RC_SUCCESS;
1776 }
1777 if (target->t.size > MAX_RSA_KEY_BYTES) {
1778 return TPM_RC_SIZE;
1779 }
1780 for (i = 0; i < target->t.size; ++i) {
1781 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
1782 if (result != TPM_RC_SUCCESS) {
1783 return result;
1784 }
1785 }
1786 return TPM_RC_SUCCESS;
1787 }
1788
TPMU_PUBLIC_ID_Marshal(TPMU_PUBLIC_ID * source,BYTE ** buffer,INT32 * size,UINT32 selector)1789 UINT16 TPMU_PUBLIC_ID_Marshal(TPMU_PUBLIC_ID* source,
1790 BYTE** buffer,
1791 INT32* size,
1792 UINT32 selector) {
1793 switch (selector) {
1794 #ifdef TPM_ALG_KEYEDHASH
1795 case TPM_ALG_KEYEDHASH:
1796 return TPM2B_DIGEST_Marshal((TPM2B_DIGEST*)&source->keyedHash, buffer,
1797 size);
1798 #endif
1799 #ifdef TPM_ALG_SYMCIPHER
1800 case TPM_ALG_SYMCIPHER:
1801 return TPM2B_DIGEST_Marshal((TPM2B_DIGEST*)&source->sym, buffer, size);
1802 #endif
1803 #ifdef TPM_ALG_RSA
1804 case TPM_ALG_RSA:
1805 return TPM2B_PUBLIC_KEY_RSA_Marshal((TPM2B_PUBLIC_KEY_RSA*)&source->rsa,
1806 buffer, size);
1807 #endif
1808 #ifdef TPM_ALG_ECC
1809 case TPM_ALG_ECC:
1810 return TPMS_ECC_POINT_Marshal((TPMS_ECC_POINT*)&source->ecc, buffer,
1811 size);
1812 #endif
1813 }
1814 return 0;
1815 }
1816
TPMU_PUBLIC_ID_Unmarshal(TPMU_PUBLIC_ID * target,BYTE ** buffer,INT32 * size,UINT32 selector)1817 TPM_RC TPMU_PUBLIC_ID_Unmarshal(TPMU_PUBLIC_ID* target,
1818 BYTE** buffer,
1819 INT32* size,
1820 UINT32 selector) {
1821 switch (selector) {
1822 #ifdef TPM_ALG_KEYEDHASH
1823 case TPM_ALG_KEYEDHASH:
1824 return TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST*)&target->keyedHash, buffer,
1825 size);
1826 #endif
1827 #ifdef TPM_ALG_SYMCIPHER
1828 case TPM_ALG_SYMCIPHER:
1829 return TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST*)&target->sym, buffer, size);
1830 #endif
1831 #ifdef TPM_ALG_RSA
1832 case TPM_ALG_RSA:
1833 return TPM2B_PUBLIC_KEY_RSA_Unmarshal((TPM2B_PUBLIC_KEY_RSA*)&target->rsa,
1834 buffer, size);
1835 #endif
1836 #ifdef TPM_ALG_ECC
1837 case TPM_ALG_ECC:
1838 return TPMS_ECC_POINT_Unmarshal((TPMS_ECC_POINT*)&target->ecc, buffer,
1839 size);
1840 #endif
1841 }
1842 return TPM_RC_SELECTOR;
1843 }
1844
TPM_KEY_BITS_Marshal(TPM_KEY_BITS * source,BYTE ** buffer,INT32 * size)1845 UINT16 TPM_KEY_BITS_Marshal(TPM_KEY_BITS* source, BYTE** buffer, INT32* size) {
1846 return uint16_t_Marshal(source, buffer, size);
1847 }
1848
TPM_KEY_BITS_Unmarshal(TPM_KEY_BITS * target,BYTE ** buffer,INT32 * size)1849 TPM_RC TPM_KEY_BITS_Unmarshal(TPM_KEY_BITS* target,
1850 BYTE** buffer,
1851 INT32* size) {
1852 return uint16_t_Unmarshal(target, buffer, size);
1853 }
1854
TPMI_AES_KEY_BITS_Marshal(TPMI_AES_KEY_BITS * source,BYTE ** buffer,INT32 * size)1855 UINT16 TPMI_AES_KEY_BITS_Marshal(TPMI_AES_KEY_BITS* source,
1856 BYTE** buffer,
1857 INT32* size) {
1858 return TPM_KEY_BITS_Marshal(source, buffer, size);
1859 }
1860
TPMI_AES_KEY_BITS_Unmarshal(TPMI_AES_KEY_BITS * target,BYTE ** buffer,INT32 * size)1861 TPM_RC TPMI_AES_KEY_BITS_Unmarshal(TPMI_AES_KEY_BITS* target,
1862 BYTE** buffer,
1863 INT32* size) {
1864 TPM_RC result;
1865 uint16_t supported_values[] = AES_KEY_SIZES_BITS;
1866 size_t length = sizeof(supported_values) / sizeof(supported_values[0]);
1867 size_t i;
1868 BOOL is_supported_value = FALSE;
1869 result = TPM_KEY_BITS_Unmarshal(target, buffer, size);
1870 if (result != TPM_RC_SUCCESS) {
1871 return result;
1872 }
1873 for (i = 0; i < length; ++i) {
1874 if (*target == supported_values[i]) {
1875 is_supported_value = TRUE;
1876 break;
1877 }
1878 }
1879 if (!is_supported_value) {
1880 return TPM_RC_VALUE;
1881 }
1882 return TPM_RC_SUCCESS;
1883 }
1884
TPMI_SM4_KEY_BITS_Marshal(TPMI_SM4_KEY_BITS * source,BYTE ** buffer,INT32 * size)1885 UINT16 TPMI_SM4_KEY_BITS_Marshal(TPMI_SM4_KEY_BITS* source,
1886 BYTE** buffer,
1887 INT32* size) {
1888 return TPM_KEY_BITS_Marshal(source, buffer, size);
1889 }
1890
TPMI_SM4_KEY_BITS_Unmarshal(TPMI_SM4_KEY_BITS * target,BYTE ** buffer,INT32 * size)1891 TPM_RC TPMI_SM4_KEY_BITS_Unmarshal(TPMI_SM4_KEY_BITS* target,
1892 BYTE** buffer,
1893 INT32* size) {
1894 TPM_RC result;
1895 uint16_t supported_values[] = SM4_KEY_SIZES_BITS;
1896 size_t length = sizeof(supported_values) / sizeof(supported_values[0]);
1897 size_t i;
1898 BOOL is_supported_value = FALSE;
1899 result = TPM_KEY_BITS_Unmarshal(target, buffer, size);
1900 if (result != TPM_RC_SUCCESS) {
1901 return result;
1902 }
1903 for (i = 0; i < length; ++i) {
1904 if (*target == supported_values[i]) {
1905 is_supported_value = TRUE;
1906 break;
1907 }
1908 }
1909 if (!is_supported_value) {
1910 return TPM_RC_VALUE;
1911 }
1912 return TPM_RC_SUCCESS;
1913 }
1914
TPMI_CAMELLIA_KEY_BITS_Marshal(TPMI_CAMELLIA_KEY_BITS * source,BYTE ** buffer,INT32 * size)1915 UINT16 TPMI_CAMELLIA_KEY_BITS_Marshal(TPMI_CAMELLIA_KEY_BITS* source,
1916 BYTE** buffer,
1917 INT32* size) {
1918 return TPM_KEY_BITS_Marshal(source, buffer, size);
1919 }
1920
TPMI_CAMELLIA_KEY_BITS_Unmarshal(TPMI_CAMELLIA_KEY_BITS * target,BYTE ** buffer,INT32 * size)1921 TPM_RC TPMI_CAMELLIA_KEY_BITS_Unmarshal(TPMI_CAMELLIA_KEY_BITS* target,
1922 BYTE** buffer,
1923 INT32* size) {
1924 TPM_RC result;
1925 uint16_t supported_values[] = CAMELLIA_KEY_SIZES_BITS;
1926 size_t length = sizeof(supported_values) / sizeof(supported_values[0]);
1927 size_t i;
1928 BOOL is_supported_value = FALSE;
1929 result = TPM_KEY_BITS_Unmarshal(target, buffer, size);
1930 if (result != TPM_RC_SUCCESS) {
1931 return result;
1932 }
1933 for (i = 0; i < length; ++i) {
1934 if (*target == supported_values[i]) {
1935 is_supported_value = TRUE;
1936 break;
1937 }
1938 }
1939 if (!is_supported_value) {
1940 return TPM_RC_VALUE;
1941 }
1942 return TPM_RC_SUCCESS;
1943 }
1944
TPMU_SYM_KEY_BITS_Marshal(TPMU_SYM_KEY_BITS * source,BYTE ** buffer,INT32 * size,UINT32 selector)1945 UINT16 TPMU_SYM_KEY_BITS_Marshal(TPMU_SYM_KEY_BITS* source,
1946 BYTE** buffer,
1947 INT32* size,
1948 UINT32 selector) {
1949 switch (selector) {
1950 #ifdef TPM_ALG_AES
1951 case TPM_ALG_AES:
1952 return TPMI_AES_KEY_BITS_Marshal((TPMI_AES_KEY_BITS*)&source->aes, buffer,
1953 size);
1954 #endif
1955 #ifdef TPM_ALG_SM4
1956 case TPM_ALG_SM4:
1957 return TPMI_SM4_KEY_BITS_Marshal((TPMI_SM4_KEY_BITS*)&source->sm4, buffer,
1958 size);
1959 #endif
1960 #ifdef TPM_ALG_CAMELLIA
1961 case TPM_ALG_CAMELLIA:
1962 return TPMI_CAMELLIA_KEY_BITS_Marshal(
1963 (TPMI_CAMELLIA_KEY_BITS*)&source->camellia, buffer, size);
1964 #endif
1965 #ifdef TPM_ALG_XOR
1966 case TPM_ALG_XOR:
1967 return TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH*)&source->xor_, buffer, size);
1968 #endif
1969 #ifdef TPM_ALG_NULL
1970 case TPM_ALG_NULL:
1971 return 0;
1972 #endif
1973 }
1974 return 0;
1975 }
1976
TPMU_SYM_KEY_BITS_Unmarshal(TPMU_SYM_KEY_BITS * target,BYTE ** buffer,INT32 * size,UINT32 selector)1977 TPM_RC TPMU_SYM_KEY_BITS_Unmarshal(TPMU_SYM_KEY_BITS* target,
1978 BYTE** buffer,
1979 INT32* size,
1980 UINT32 selector) {
1981 switch (selector) {
1982 #ifdef TPM_ALG_AES
1983 case TPM_ALG_AES:
1984 return TPMI_AES_KEY_BITS_Unmarshal((TPMI_AES_KEY_BITS*)&target->aes,
1985 buffer, size);
1986 #endif
1987 #ifdef TPM_ALG_SM4
1988 case TPM_ALG_SM4:
1989 return TPMI_SM4_KEY_BITS_Unmarshal((TPMI_SM4_KEY_BITS*)&target->sm4,
1990 buffer, size);
1991 #endif
1992 #ifdef TPM_ALG_CAMELLIA
1993 case TPM_ALG_CAMELLIA:
1994 return TPMI_CAMELLIA_KEY_BITS_Unmarshal(
1995 (TPMI_CAMELLIA_KEY_BITS*)&target->camellia, buffer, size);
1996 #endif
1997 #ifdef TPM_ALG_XOR
1998 case TPM_ALG_XOR:
1999 return TPMI_ALG_HASH_Unmarshal(&target->xor_, buffer, size, FALSE);
2000 #endif
2001 #ifdef TPM_ALG_NULL
2002 case TPM_ALG_NULL:
2003 return TPM_RC_SUCCESS;
2004 #endif
2005 }
2006 return TPM_RC_SELECTOR;
2007 }
2008
TPMI_ALG_SYM_MODE_Marshal(TPMI_ALG_SYM_MODE * source,BYTE ** buffer,INT32 * size)2009 UINT16 TPMI_ALG_SYM_MODE_Marshal(TPMI_ALG_SYM_MODE* source,
2010 BYTE** buffer,
2011 INT32* size) {
2012 return uint16_t_Marshal(source, buffer, size);
2013 }
2014
TPMI_ALG_SYM_MODE_Unmarshal(TPMI_ALG_SYM_MODE * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2015 TPM_RC TPMI_ALG_SYM_MODE_Unmarshal(TPMI_ALG_SYM_MODE* target,
2016 BYTE** buffer,
2017 INT32* size,
2018 BOOL allow_conditional_value) {
2019 TPM_RC result;
2020 BOOL has_valid_value = FALSE;
2021 result = uint16_t_Unmarshal(target, buffer, size);
2022 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2023 return result;
2024 }
2025 if (*target == TPM_ALG_NULL) {
2026 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_MODE;
2027 }
2028 switch (*target) {
2029 #ifdef TPM_ALG_CTR
2030 case TPM_ALG_CTR:
2031 #endif
2032 #ifdef TPM_ALG_OFB
2033 case TPM_ALG_OFB:
2034 #endif
2035 #ifdef TPM_ALG_CBC
2036 case TPM_ALG_CBC:
2037 #endif
2038 #ifdef TPM_ALG_CFB
2039 case TPM_ALG_CFB:
2040 #endif
2041 #ifdef TPM_ALG_ECB
2042 case TPM_ALG_ECB:
2043 #endif
2044 has_valid_value = TRUE;
2045 break;
2046 }
2047 if (!has_valid_value) {
2048 return TPM_RC_MODE;
2049 }
2050 return TPM_RC_SUCCESS;
2051 }
2052
TPMU_SYM_MODE_Marshal(TPMU_SYM_MODE * source,BYTE ** buffer,INT32 * size,UINT32 selector)2053 UINT16 TPMU_SYM_MODE_Marshal(TPMU_SYM_MODE* source,
2054 BYTE** buffer,
2055 INT32* size,
2056 UINT32 selector) {
2057 switch (selector) {
2058 #ifdef TPM_ALG_AES
2059 case TPM_ALG_AES:
2060 return TPMI_ALG_SYM_MODE_Marshal((TPMI_ALG_SYM_MODE*)&source->aes, buffer,
2061 size);
2062 #endif
2063 #ifdef TPM_ALG_SM4
2064 case TPM_ALG_SM4:
2065 return TPMI_ALG_SYM_MODE_Marshal((TPMI_ALG_SYM_MODE*)&source->sm4, buffer,
2066 size);
2067 #endif
2068 #ifdef TPM_ALG_CAMELLIA
2069 case TPM_ALG_CAMELLIA:
2070 return TPMI_ALG_SYM_MODE_Marshal((TPMI_ALG_SYM_MODE*)&source->camellia,
2071 buffer, size);
2072 #endif
2073 #ifdef TPM_ALG_XOR
2074 case TPM_ALG_XOR:
2075 return 0;
2076 #endif
2077 #ifdef TPM_ALG_NULL
2078 case TPM_ALG_NULL:
2079 return 0;
2080 #endif
2081 }
2082 return 0;
2083 }
2084
TPMU_SYM_MODE_Unmarshal(TPMU_SYM_MODE * target,BYTE ** buffer,INT32 * size,UINT32 selector)2085 TPM_RC TPMU_SYM_MODE_Unmarshal(TPMU_SYM_MODE* target,
2086 BYTE** buffer,
2087 INT32* size,
2088 UINT32 selector) {
2089 switch (selector) {
2090 #ifdef TPM_ALG_AES
2091 case TPM_ALG_AES:
2092 return TPMI_ALG_SYM_MODE_Unmarshal(&target->aes, buffer, size, FALSE);
2093 #endif
2094 #ifdef TPM_ALG_SM4
2095 case TPM_ALG_SM4:
2096 return TPMI_ALG_SYM_MODE_Unmarshal(&target->sm4, buffer, size, FALSE);
2097 #endif
2098 #ifdef TPM_ALG_CAMELLIA
2099 case TPM_ALG_CAMELLIA:
2100 return TPMI_ALG_SYM_MODE_Unmarshal(&target->camellia, buffer, size,
2101 FALSE);
2102 #endif
2103 #ifdef TPM_ALG_XOR
2104 case TPM_ALG_XOR:
2105 return TPM_RC_SUCCESS;
2106 #endif
2107 #ifdef TPM_ALG_NULL
2108 case TPM_ALG_NULL:
2109 return TPM_RC_SUCCESS;
2110 #endif
2111 }
2112 return TPM_RC_SELECTOR;
2113 }
2114
TPMI_ALG_SYM_OBJECT_Marshal(TPMI_ALG_SYM_OBJECT * source,BYTE ** buffer,INT32 * size)2115 UINT16 TPMI_ALG_SYM_OBJECT_Marshal(TPMI_ALG_SYM_OBJECT* source,
2116 BYTE** buffer,
2117 INT32* size) {
2118 return uint16_t_Marshal(source, buffer, size);
2119 }
2120
TPMI_ALG_SYM_OBJECT_Unmarshal(TPMI_ALG_SYM_OBJECT * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2121 TPM_RC TPMI_ALG_SYM_OBJECT_Unmarshal(TPMI_ALG_SYM_OBJECT* target,
2122 BYTE** buffer,
2123 INT32* size,
2124 BOOL allow_conditional_value) {
2125 TPM_RC result;
2126 BOOL has_valid_value = FALSE;
2127 result = uint16_t_Unmarshal(target, buffer, size);
2128 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2129 return result;
2130 }
2131 if (*target == TPM_ALG_NULL) {
2132 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SYMMETRIC;
2133 }
2134 switch (*target) {
2135 #ifdef TPM_ALG_AES
2136 case TPM_ALG_AES:
2137 #endif
2138 #ifdef TPM_ALG_SM4
2139 case TPM_ALG_SM4:
2140 #endif
2141 #ifdef TPM_ALG_CAMELLIA
2142 case TPM_ALG_CAMELLIA:
2143 #endif
2144 has_valid_value = TRUE;
2145 break;
2146 }
2147 if (!has_valid_value) {
2148 return TPM_RC_SYMMETRIC;
2149 }
2150 return TPM_RC_SUCCESS;
2151 }
2152
TPMT_SYM_DEF_OBJECT_Marshal(TPMT_SYM_DEF_OBJECT * source,BYTE ** buffer,INT32 * size)2153 UINT16 TPMT_SYM_DEF_OBJECT_Marshal(TPMT_SYM_DEF_OBJECT* source,
2154 BYTE** buffer,
2155 INT32* size) {
2156 UINT16 total_size = 0;
2157 total_size += TPMI_ALG_SYM_OBJECT_Marshal(&source->algorithm, buffer, size);
2158 total_size += TPMU_SYM_KEY_BITS_Marshal(&source->keyBits, buffer, size,
2159 source->algorithm);
2160 total_size +=
2161 TPMU_SYM_MODE_Marshal(&source->mode, buffer, size, source->algorithm);
2162 return total_size;
2163 }
2164
TPMT_SYM_DEF_OBJECT_Unmarshal(TPMT_SYM_DEF_OBJECT * target,BYTE ** buffer,INT32 * size)2165 TPM_RC TPMT_SYM_DEF_OBJECT_Unmarshal(TPMT_SYM_DEF_OBJECT* target,
2166 BYTE** buffer,
2167 INT32* size) {
2168 TPM_RC result;
2169 result =
2170 TPMI_ALG_SYM_OBJECT_Unmarshal(&target->algorithm, buffer, size, TRUE);
2171 if (result != TPM_RC_SUCCESS) {
2172 return result;
2173 }
2174 result = TPMU_SYM_KEY_BITS_Unmarshal(&target->keyBits, buffer, size,
2175 target->algorithm);
2176 if (result != TPM_RC_SUCCESS) {
2177 return result;
2178 }
2179 result =
2180 TPMU_SYM_MODE_Unmarshal(&target->mode, buffer, size, target->algorithm);
2181 if (result != TPM_RC_SUCCESS) {
2182 return result;
2183 }
2184 return TPM_RC_SUCCESS;
2185 }
2186
TPMI_ALG_RSA_SCHEME_Marshal(TPMI_ALG_RSA_SCHEME * source,BYTE ** buffer,INT32 * size)2187 UINT16 TPMI_ALG_RSA_SCHEME_Marshal(TPMI_ALG_RSA_SCHEME* source,
2188 BYTE** buffer,
2189 INT32* size) {
2190 return uint16_t_Marshal(source, buffer, size);
2191 }
2192
TPMI_ALG_RSA_SCHEME_Unmarshal(TPMI_ALG_RSA_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2193 TPM_RC TPMI_ALG_RSA_SCHEME_Unmarshal(TPMI_ALG_RSA_SCHEME* target,
2194 BYTE** buffer,
2195 INT32* size,
2196 BOOL allow_conditional_value) {
2197 TPM_RC result;
2198 BOOL has_valid_value = FALSE;
2199 result = uint16_t_Unmarshal(target, buffer, size);
2200 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2201 return result;
2202 }
2203 if (*target == TPM_ALG_NULL) {
2204 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
2205 }
2206 switch (*target) {
2207 #ifdef TPM_ALG_RSAES
2208 case TPM_ALG_RSAES:
2209 #endif
2210 #ifdef TPM_ALG_OAEP
2211 case TPM_ALG_OAEP:
2212 #endif
2213 #ifdef TPM_ALG_RSASSA
2214 case TPM_ALG_RSASSA:
2215 #endif
2216 #ifdef TPM_ALG_RSAPSS
2217 case TPM_ALG_RSAPSS:
2218 #endif
2219 has_valid_value = TRUE;
2220 break;
2221 }
2222 if (!has_valid_value) {
2223 return TPM_RC_VALUE;
2224 }
2225 return TPM_RC_SUCCESS;
2226 }
2227
TPMS_SCHEME_HASH_Marshal(TPMS_SCHEME_HASH * source,BYTE ** buffer,INT32 * size)2228 UINT16 TPMS_SCHEME_HASH_Marshal(TPMS_SCHEME_HASH* source,
2229 BYTE** buffer,
2230 INT32* size) {
2231 UINT16 total_size = 0;
2232 total_size += TPMI_ALG_HASH_Marshal(&source->hashAlg, buffer, size);
2233 return total_size;
2234 }
2235
TPMS_SCHEME_HASH_Unmarshal(TPMS_SCHEME_HASH * target,BYTE ** buffer,INT32 * size)2236 TPM_RC TPMS_SCHEME_HASH_Unmarshal(TPMS_SCHEME_HASH* target,
2237 BYTE** buffer,
2238 INT32* size) {
2239 TPM_RC result;
2240 result = TPMI_ALG_HASH_Unmarshal(&target->hashAlg, buffer, size, FALSE);
2241 if (result != TPM_RC_SUCCESS) {
2242 return result;
2243 }
2244 return TPM_RC_SUCCESS;
2245 }
2246
TPMS_SIG_SCHEME_RSAPSS_Marshal(TPMS_SIG_SCHEME_RSAPSS * source,BYTE ** buffer,INT32 * size)2247 UINT16 TPMS_SIG_SCHEME_RSAPSS_Marshal(TPMS_SIG_SCHEME_RSAPSS* source,
2248 BYTE** buffer,
2249 INT32* size) {
2250 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2251 }
2252
TPMS_SIG_SCHEME_RSAPSS_Unmarshal(TPMS_SIG_SCHEME_RSAPSS * target,BYTE ** buffer,INT32 * size)2253 TPM_RC TPMS_SIG_SCHEME_RSAPSS_Unmarshal(TPMS_SIG_SCHEME_RSAPSS* target,
2254 BYTE** buffer,
2255 INT32* size) {
2256 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2257 }
2258
TPMS_SIG_SCHEME_SM2_Marshal(TPMS_SIG_SCHEME_SM2 * source,BYTE ** buffer,INT32 * size)2259 UINT16 TPMS_SIG_SCHEME_SM2_Marshal(TPMS_SIG_SCHEME_SM2* source,
2260 BYTE** buffer,
2261 INT32* size) {
2262 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2263 }
2264
TPMS_SIG_SCHEME_SM2_Unmarshal(TPMS_SIG_SCHEME_SM2 * target,BYTE ** buffer,INT32 * size)2265 TPM_RC TPMS_SIG_SCHEME_SM2_Unmarshal(TPMS_SIG_SCHEME_SM2* target,
2266 BYTE** buffer,
2267 INT32* size) {
2268 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2269 }
2270
TPMS_SIG_SCHEME_ECSCHNORR_Marshal(TPMS_SIG_SCHEME_ECSCHNORR * source,BYTE ** buffer,INT32 * size)2271 UINT16 TPMS_SIG_SCHEME_ECSCHNORR_Marshal(TPMS_SIG_SCHEME_ECSCHNORR* source,
2272 BYTE** buffer,
2273 INT32* size) {
2274 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2275 }
2276
TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(TPMS_SIG_SCHEME_ECSCHNORR * target,BYTE ** buffer,INT32 * size)2277 TPM_RC TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(TPMS_SIG_SCHEME_ECSCHNORR* target,
2278 BYTE** buffer,
2279 INT32* size) {
2280 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2281 }
2282
TPMS_SCHEME_ECDAA_Marshal(TPMS_SCHEME_ECDAA * source,BYTE ** buffer,INT32 * size)2283 UINT16 TPMS_SCHEME_ECDAA_Marshal(TPMS_SCHEME_ECDAA* source,
2284 BYTE** buffer,
2285 INT32* size) {
2286 UINT16 total_size = 0;
2287 total_size += TPMI_ALG_HASH_Marshal(&source->hashAlg, buffer, size);
2288 total_size += UINT16_Marshal(&source->count, buffer, size);
2289 return total_size;
2290 }
2291
TPMS_SCHEME_ECDAA_Unmarshal(TPMS_SCHEME_ECDAA * target,BYTE ** buffer,INT32 * size)2292 TPM_RC TPMS_SCHEME_ECDAA_Unmarshal(TPMS_SCHEME_ECDAA* target,
2293 BYTE** buffer,
2294 INT32* size) {
2295 TPM_RC result;
2296 result = TPMI_ALG_HASH_Unmarshal(&target->hashAlg, buffer, size, FALSE);
2297 if (result != TPM_RC_SUCCESS) {
2298 return result;
2299 }
2300 result = UINT16_Unmarshal(&target->count, buffer, size);
2301 if (result != TPM_RC_SUCCESS) {
2302 return result;
2303 }
2304 return TPM_RC_SUCCESS;
2305 }
2306
TPMS_SIG_SCHEME_ECDAA_Marshal(TPMS_SIG_SCHEME_ECDAA * source,BYTE ** buffer,INT32 * size)2307 UINT16 TPMS_SIG_SCHEME_ECDAA_Marshal(TPMS_SIG_SCHEME_ECDAA* source,
2308 BYTE** buffer,
2309 INT32* size) {
2310 return TPMS_SCHEME_ECDAA_Marshal(source, buffer, size);
2311 }
2312
TPMS_SIG_SCHEME_ECDAA_Unmarshal(TPMS_SIG_SCHEME_ECDAA * target,BYTE ** buffer,INT32 * size)2313 TPM_RC TPMS_SIG_SCHEME_ECDAA_Unmarshal(TPMS_SIG_SCHEME_ECDAA* target,
2314 BYTE** buffer,
2315 INT32* size) {
2316 return TPMS_SCHEME_ECDAA_Unmarshal(target, buffer, size);
2317 }
2318
TPMS_KEY_SCHEME_ECDH_Marshal(TPMS_KEY_SCHEME_ECDH * source,BYTE ** buffer,INT32 * size)2319 UINT16 TPMS_KEY_SCHEME_ECDH_Marshal(TPMS_KEY_SCHEME_ECDH* source,
2320 BYTE** buffer,
2321 INT32* size) {
2322 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2323 }
2324
TPMS_KEY_SCHEME_ECDH_Unmarshal(TPMS_KEY_SCHEME_ECDH * target,BYTE ** buffer,INT32 * size)2325 TPM_RC TPMS_KEY_SCHEME_ECDH_Unmarshal(TPMS_KEY_SCHEME_ECDH* target,
2326 BYTE** buffer,
2327 INT32* size) {
2328 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2329 }
2330
TPMS_KEY_SCHEME_ECMQV_Marshal(TPMS_KEY_SCHEME_ECMQV * source,BYTE ** buffer,INT32 * size)2331 UINT16 TPMS_KEY_SCHEME_ECMQV_Marshal(TPMS_KEY_SCHEME_ECMQV* source,
2332 BYTE** buffer,
2333 INT32* size) {
2334 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2335 }
2336
TPMS_KEY_SCHEME_ECMQV_Unmarshal(TPMS_KEY_SCHEME_ECMQV * target,BYTE ** buffer,INT32 * size)2337 TPM_RC TPMS_KEY_SCHEME_ECMQV_Unmarshal(TPMS_KEY_SCHEME_ECMQV* target,
2338 BYTE** buffer,
2339 INT32* size) {
2340 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2341 }
2342
TPMS_SIG_SCHEME_RSASSA_Marshal(TPMS_SIG_SCHEME_RSASSA * source,BYTE ** buffer,INT32 * size)2343 UINT16 TPMS_SIG_SCHEME_RSASSA_Marshal(TPMS_SIG_SCHEME_RSASSA* source,
2344 BYTE** buffer,
2345 INT32* size) {
2346 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2347 }
2348
TPMS_SIG_SCHEME_RSASSA_Unmarshal(TPMS_SIG_SCHEME_RSASSA * target,BYTE ** buffer,INT32 * size)2349 TPM_RC TPMS_SIG_SCHEME_RSASSA_Unmarshal(TPMS_SIG_SCHEME_RSASSA* target,
2350 BYTE** buffer,
2351 INT32* size) {
2352 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2353 }
2354
TPMS_ENC_SCHEME_OAEP_Marshal(TPMS_ENC_SCHEME_OAEP * source,BYTE ** buffer,INT32 * size)2355 UINT16 TPMS_ENC_SCHEME_OAEP_Marshal(TPMS_ENC_SCHEME_OAEP* source,
2356 BYTE** buffer,
2357 INT32* size) {
2358 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2359 }
2360
TPMS_ENC_SCHEME_OAEP_Unmarshal(TPMS_ENC_SCHEME_OAEP * target,BYTE ** buffer,INT32 * size)2361 TPM_RC TPMS_ENC_SCHEME_OAEP_Unmarshal(TPMS_ENC_SCHEME_OAEP* target,
2362 BYTE** buffer,
2363 INT32* size) {
2364 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2365 }
2366
TPMS_EMPTY_Marshal(TPMS_EMPTY * source,BYTE ** buffer,INT32 * size)2367 UINT16 TPMS_EMPTY_Marshal(TPMS_EMPTY* source, BYTE** buffer, INT32* size) {
2368 UINT16 total_size = 0;
2369 return total_size;
2370 }
2371
TPMS_EMPTY_Unmarshal(TPMS_EMPTY * target,BYTE ** buffer,INT32 * size)2372 TPM_RC TPMS_EMPTY_Unmarshal(TPMS_EMPTY* target, BYTE** buffer, INT32* size) {
2373 TPM_RC result;
2374 (void)result;
2375
2376 return TPM_RC_SUCCESS;
2377 }
2378
TPMS_ENC_SCHEME_RSAES_Marshal(TPMS_ENC_SCHEME_RSAES * source,BYTE ** buffer,INT32 * size)2379 UINT16 TPMS_ENC_SCHEME_RSAES_Marshal(TPMS_ENC_SCHEME_RSAES* source,
2380 BYTE** buffer,
2381 INT32* size) {
2382 return TPMS_EMPTY_Marshal(source, buffer, size);
2383 }
2384
TPMS_ENC_SCHEME_RSAES_Unmarshal(TPMS_ENC_SCHEME_RSAES * target,BYTE ** buffer,INT32 * size)2385 TPM_RC TPMS_ENC_SCHEME_RSAES_Unmarshal(TPMS_ENC_SCHEME_RSAES* target,
2386 BYTE** buffer,
2387 INT32* size) {
2388 return TPMS_EMPTY_Unmarshal(target, buffer, size);
2389 }
2390
TPMS_SIG_SCHEME_ECDSA_Marshal(TPMS_SIG_SCHEME_ECDSA * source,BYTE ** buffer,INT32 * size)2391 UINT16 TPMS_SIG_SCHEME_ECDSA_Marshal(TPMS_SIG_SCHEME_ECDSA* source,
2392 BYTE** buffer,
2393 INT32* size) {
2394 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2395 }
2396
TPMS_SIG_SCHEME_ECDSA_Unmarshal(TPMS_SIG_SCHEME_ECDSA * target,BYTE ** buffer,INT32 * size)2397 TPM_RC TPMS_SIG_SCHEME_ECDSA_Unmarshal(TPMS_SIG_SCHEME_ECDSA* target,
2398 BYTE** buffer,
2399 INT32* size) {
2400 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2401 }
2402
TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)2403 UINT16 TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME* source,
2404 BYTE** buffer,
2405 INT32* size,
2406 UINT32 selector) {
2407 switch (selector) {
2408 #ifdef TPM_ALG_ECDH
2409 case TPM_ALG_ECDH:
2410 return TPMS_KEY_SCHEME_ECDH_Marshal((TPMS_KEY_SCHEME_ECDH*)&source->ecdh,
2411 buffer, size);
2412 #endif
2413 #ifdef TPM_ALG_ECMQV
2414 case TPM_ALG_ECMQV:
2415 return TPMS_KEY_SCHEME_ECMQV_Marshal(
2416 (TPMS_KEY_SCHEME_ECMQV*)&source->ecmqv, buffer, size);
2417 #endif
2418 #ifdef TPM_ALG_RSASSA
2419 case TPM_ALG_RSASSA:
2420 return TPMS_SIG_SCHEME_RSASSA_Marshal(
2421 (TPMS_SIG_SCHEME_RSASSA*)&source->rsassa, buffer, size);
2422 #endif
2423 #ifdef TPM_ALG_RSAPSS
2424 case TPM_ALG_RSAPSS:
2425 return TPMS_SIG_SCHEME_RSAPSS_Marshal(
2426 (TPMS_SIG_SCHEME_RSAPSS*)&source->rsapss, buffer, size);
2427 #endif
2428 #ifdef TPM_ALG_ECDSA
2429 case TPM_ALG_ECDSA:
2430 return TPMS_SIG_SCHEME_ECDSA_Marshal(
2431 (TPMS_SIG_SCHEME_ECDSA*)&source->ecdsa, buffer, size);
2432 #endif
2433 #ifdef TPM_ALG_ECDAA
2434 case TPM_ALG_ECDAA:
2435 return TPMS_SIG_SCHEME_ECDAA_Marshal(
2436 (TPMS_SIG_SCHEME_ECDAA*)&source->ecdaa, buffer, size);
2437 #endif
2438 #ifdef TPM_ALG_SM2
2439 case TPM_ALG_SM2:
2440 return TPMS_SIG_SCHEME_SM2_Marshal((TPMS_SIG_SCHEME_SM2*)&source->sm2,
2441 buffer, size);
2442 #endif
2443 #ifdef TPM_ALG_ECSCHNORR
2444 case TPM_ALG_ECSCHNORR:
2445 return TPMS_SIG_SCHEME_ECSCHNORR_Marshal(
2446 (TPMS_SIG_SCHEME_ECSCHNORR*)&source->ecschnorr, buffer, size);
2447 #endif
2448 #ifdef TPM_ALG_RSAES
2449 case TPM_ALG_RSAES:
2450 return TPMS_ENC_SCHEME_RSAES_Marshal(
2451 (TPMS_ENC_SCHEME_RSAES*)&source->rsaes, buffer, size);
2452 #endif
2453 #ifdef TPM_ALG_OAEP
2454 case TPM_ALG_OAEP:
2455 return TPMS_ENC_SCHEME_OAEP_Marshal((TPMS_ENC_SCHEME_OAEP*)&source->oaep,
2456 buffer, size);
2457 #endif
2458 #ifdef TPM_ALG_NULL
2459 case TPM_ALG_NULL:
2460 return 0;
2461 #endif
2462 }
2463 return 0;
2464 }
2465
TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)2466 TPM_RC TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME* target,
2467 BYTE** buffer,
2468 INT32* size,
2469 UINT32 selector) {
2470 switch (selector) {
2471 #ifdef TPM_ALG_ECDH
2472 case TPM_ALG_ECDH:
2473 return TPMS_KEY_SCHEME_ECDH_Unmarshal(
2474 (TPMS_KEY_SCHEME_ECDH*)&target->ecdh, buffer, size);
2475 #endif
2476 #ifdef TPM_ALG_ECMQV
2477 case TPM_ALG_ECMQV:
2478 return TPMS_KEY_SCHEME_ECMQV_Unmarshal(
2479 (TPMS_KEY_SCHEME_ECMQV*)&target->ecmqv, buffer, size);
2480 #endif
2481 #ifdef TPM_ALG_RSASSA
2482 case TPM_ALG_RSASSA:
2483 return TPMS_SIG_SCHEME_RSASSA_Unmarshal(
2484 (TPMS_SIG_SCHEME_RSASSA*)&target->rsassa, buffer, size);
2485 #endif
2486 #ifdef TPM_ALG_RSAPSS
2487 case TPM_ALG_RSAPSS:
2488 return TPMS_SIG_SCHEME_RSAPSS_Unmarshal(
2489 (TPMS_SIG_SCHEME_RSAPSS*)&target->rsapss, buffer, size);
2490 #endif
2491 #ifdef TPM_ALG_ECDSA
2492 case TPM_ALG_ECDSA:
2493 return TPMS_SIG_SCHEME_ECDSA_Unmarshal(
2494 (TPMS_SIG_SCHEME_ECDSA*)&target->ecdsa, buffer, size);
2495 #endif
2496 #ifdef TPM_ALG_ECDAA
2497 case TPM_ALG_ECDAA:
2498 return TPMS_SIG_SCHEME_ECDAA_Unmarshal(
2499 (TPMS_SIG_SCHEME_ECDAA*)&target->ecdaa, buffer, size);
2500 #endif
2501 #ifdef TPM_ALG_SM2
2502 case TPM_ALG_SM2:
2503 return TPMS_SIG_SCHEME_SM2_Unmarshal((TPMS_SIG_SCHEME_SM2*)&target->sm2,
2504 buffer, size);
2505 #endif
2506 #ifdef TPM_ALG_ECSCHNORR
2507 case TPM_ALG_ECSCHNORR:
2508 return TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(
2509 (TPMS_SIG_SCHEME_ECSCHNORR*)&target->ecschnorr, buffer, size);
2510 #endif
2511 #ifdef TPM_ALG_RSAES
2512 case TPM_ALG_RSAES:
2513 return TPMS_ENC_SCHEME_RSAES_Unmarshal(
2514 (TPMS_ENC_SCHEME_RSAES*)&target->rsaes, buffer, size);
2515 #endif
2516 #ifdef TPM_ALG_OAEP
2517 case TPM_ALG_OAEP:
2518 return TPMS_ENC_SCHEME_OAEP_Unmarshal(
2519 (TPMS_ENC_SCHEME_OAEP*)&target->oaep, buffer, size);
2520 #endif
2521 #ifdef TPM_ALG_NULL
2522 case TPM_ALG_NULL:
2523 return TPM_RC_SUCCESS;
2524 #endif
2525 }
2526 return TPM_RC_SELECTOR;
2527 }
2528
TPMT_RSA_SCHEME_Marshal(TPMT_RSA_SCHEME * source,BYTE ** buffer,INT32 * size)2529 UINT16 TPMT_RSA_SCHEME_Marshal(TPMT_RSA_SCHEME* source,
2530 BYTE** buffer,
2531 INT32* size) {
2532 UINT16 total_size = 0;
2533 total_size += TPMI_ALG_RSA_SCHEME_Marshal(&source->scheme, buffer, size);
2534 total_size +=
2535 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2536 return total_size;
2537 }
2538
TPMT_RSA_SCHEME_Unmarshal(TPMT_RSA_SCHEME * target,BYTE ** buffer,INT32 * size)2539 TPM_RC TPMT_RSA_SCHEME_Unmarshal(TPMT_RSA_SCHEME* target,
2540 BYTE** buffer,
2541 INT32* size) {
2542 TPM_RC result;
2543 result = TPMI_ALG_RSA_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
2544 if (result != TPM_RC_SUCCESS) {
2545 return result;
2546 }
2547 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
2548 target->scheme);
2549 if (result != TPM_RC_SUCCESS) {
2550 return result;
2551 }
2552 return TPM_RC_SUCCESS;
2553 }
2554
TPMI_RSA_KEY_BITS_Marshal(TPMI_RSA_KEY_BITS * source,BYTE ** buffer,INT32 * size)2555 UINT16 TPMI_RSA_KEY_BITS_Marshal(TPMI_RSA_KEY_BITS* source,
2556 BYTE** buffer,
2557 INT32* size) {
2558 return uint16_t_Marshal(source, buffer, size);
2559 }
2560
TPMI_RSA_KEY_BITS_Unmarshal(TPMI_RSA_KEY_BITS * target,BYTE ** buffer,INT32 * size)2561 TPM_RC TPMI_RSA_KEY_BITS_Unmarshal(TPMI_RSA_KEY_BITS* target,
2562 BYTE** buffer,
2563 INT32* size) {
2564 TPM_RC result;
2565 uint16_t supported_values[] = RSA_KEY_SIZES_BITS;
2566 size_t length = sizeof(supported_values) / sizeof(supported_values[0]);
2567 size_t i;
2568 BOOL is_supported_value = FALSE;
2569 result = uint16_t_Unmarshal(target, buffer, size);
2570 if (result != TPM_RC_SUCCESS) {
2571 return result;
2572 }
2573 for (i = 0; i < length; ++i) {
2574 if (*target == supported_values[i]) {
2575 is_supported_value = TRUE;
2576 break;
2577 }
2578 }
2579 if (!is_supported_value) {
2580 return TPM_RC_VALUE;
2581 }
2582 return TPM_RC_SUCCESS;
2583 }
2584
TPMS_RSA_PARMS_Marshal(TPMS_RSA_PARMS * source,BYTE ** buffer,INT32 * size)2585 UINT16 TPMS_RSA_PARMS_Marshal(TPMS_RSA_PARMS* source,
2586 BYTE** buffer,
2587 INT32* size) {
2588 UINT16 total_size = 0;
2589 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->symmetric, buffer, size);
2590 total_size += TPMT_RSA_SCHEME_Marshal(&source->scheme, buffer, size);
2591 total_size += TPMI_RSA_KEY_BITS_Marshal(&source->keyBits, buffer, size);
2592 total_size += UINT32_Marshal(&source->exponent, buffer, size);
2593 return total_size;
2594 }
2595
TPMS_RSA_PARMS_Unmarshal(TPMS_RSA_PARMS * target,BYTE ** buffer,INT32 * size)2596 TPM_RC TPMS_RSA_PARMS_Unmarshal(TPMS_RSA_PARMS* target,
2597 BYTE** buffer,
2598 INT32* size) {
2599 TPM_RC result;
2600 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->symmetric, buffer, size);
2601 if (result != TPM_RC_SUCCESS) {
2602 return result;
2603 }
2604 result = TPMT_RSA_SCHEME_Unmarshal(&target->scheme, buffer, size);
2605 if (result != TPM_RC_SUCCESS) {
2606 return result;
2607 }
2608 result = TPMI_RSA_KEY_BITS_Unmarshal(&target->keyBits, buffer, size);
2609 if (result != TPM_RC_SUCCESS) {
2610 return result;
2611 }
2612 result = UINT32_Unmarshal(&target->exponent, buffer, size);
2613 if (result != TPM_RC_SUCCESS) {
2614 return result;
2615 }
2616 return TPM_RC_SUCCESS;
2617 }
2618
TPMS_SYMCIPHER_PARMS_Marshal(TPMS_SYMCIPHER_PARMS * source,BYTE ** buffer,INT32 * size)2619 UINT16 TPMS_SYMCIPHER_PARMS_Marshal(TPMS_SYMCIPHER_PARMS* source,
2620 BYTE** buffer,
2621 INT32* size) {
2622 UINT16 total_size = 0;
2623 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->sym, buffer, size);
2624 return total_size;
2625 }
2626
TPMS_SYMCIPHER_PARMS_Unmarshal(TPMS_SYMCIPHER_PARMS * target,BYTE ** buffer,INT32 * size)2627 TPM_RC TPMS_SYMCIPHER_PARMS_Unmarshal(TPMS_SYMCIPHER_PARMS* target,
2628 BYTE** buffer,
2629 INT32* size) {
2630 TPM_RC result;
2631 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->sym, buffer, size);
2632 if (result != TPM_RC_SUCCESS) {
2633 return result;
2634 }
2635 return TPM_RC_SUCCESS;
2636 }
2637
TPMI_ALG_ASYM_SCHEME_Marshal(TPMI_ALG_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size)2638 UINT16 TPMI_ALG_ASYM_SCHEME_Marshal(TPMI_ALG_ASYM_SCHEME* source,
2639 BYTE** buffer,
2640 INT32* size) {
2641 return uint16_t_Marshal(source, buffer, size);
2642 }
2643
TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2644 TPM_RC TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME* target,
2645 BYTE** buffer,
2646 INT32* size,
2647 BOOL allow_conditional_value) {
2648 TPM_RC result;
2649 BOOL has_valid_value = FALSE;
2650 result = uint16_t_Unmarshal(target, buffer, size);
2651 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2652 return result;
2653 }
2654 if (*target == TPM_ALG_NULL) {
2655 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
2656 }
2657 switch (*target) {
2658 #ifdef TPM_ALG_ECDH
2659 case TPM_ALG_ECDH:
2660 #endif
2661 #ifdef TPM_ALG_ECMQV
2662 case TPM_ALG_ECMQV:
2663 #endif
2664 #ifdef TPM_ALG_RSASSA
2665 case TPM_ALG_RSASSA:
2666 #endif
2667 #ifdef TPM_ALG_RSAPSS
2668 case TPM_ALG_RSAPSS:
2669 #endif
2670 #ifdef TPM_ALG_ECDSA
2671 case TPM_ALG_ECDSA:
2672 #endif
2673 #ifdef TPM_ALG_ECDAA
2674 case TPM_ALG_ECDAA:
2675 #endif
2676 #ifdef TPM_ALG_SM2
2677 case TPM_ALG_SM2:
2678 #endif
2679 #ifdef TPM_ALG_ECSCHNORR
2680 case TPM_ALG_ECSCHNORR:
2681 #endif
2682 #ifdef TPM_ALG_RSAES
2683 case TPM_ALG_RSAES:
2684 #endif
2685 #ifdef TPM_ALG_OAEP
2686 case TPM_ALG_OAEP:
2687 #endif
2688 has_valid_value = TRUE;
2689 break;
2690 }
2691 if (!has_valid_value) {
2692 return TPM_RC_VALUE;
2693 }
2694 return TPM_RC_SUCCESS;
2695 }
2696
TPMT_ASYM_SCHEME_Marshal(TPMT_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size)2697 UINT16 TPMT_ASYM_SCHEME_Marshal(TPMT_ASYM_SCHEME* source,
2698 BYTE** buffer,
2699 INT32* size) {
2700 UINT16 total_size = 0;
2701 total_size += TPMI_ALG_ASYM_SCHEME_Marshal(&source->scheme, buffer, size);
2702 total_size +=
2703 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2704 return total_size;
2705 }
2706
TPMT_ASYM_SCHEME_Unmarshal(TPMT_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size)2707 TPM_RC TPMT_ASYM_SCHEME_Unmarshal(TPMT_ASYM_SCHEME* target,
2708 BYTE** buffer,
2709 INT32* size) {
2710 TPM_RC result;
2711 result = TPMI_ALG_ASYM_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
2712 if (result != TPM_RC_SUCCESS) {
2713 return result;
2714 }
2715 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
2716 target->scheme);
2717 if (result != TPM_RC_SUCCESS) {
2718 return result;
2719 }
2720 return TPM_RC_SUCCESS;
2721 }
2722
TPMS_ASYM_PARMS_Marshal(TPMS_ASYM_PARMS * source,BYTE ** buffer,INT32 * size)2723 UINT16 TPMS_ASYM_PARMS_Marshal(TPMS_ASYM_PARMS* source,
2724 BYTE** buffer,
2725 INT32* size) {
2726 UINT16 total_size = 0;
2727 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->symmetric, buffer, size);
2728 total_size += TPMT_ASYM_SCHEME_Marshal(&source->scheme, buffer, size);
2729 return total_size;
2730 }
2731
TPMS_ASYM_PARMS_Unmarshal(TPMS_ASYM_PARMS * target,BYTE ** buffer,INT32 * size)2732 TPM_RC TPMS_ASYM_PARMS_Unmarshal(TPMS_ASYM_PARMS* target,
2733 BYTE** buffer,
2734 INT32* size) {
2735 TPM_RC result;
2736 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->symmetric, buffer, size);
2737 if (result != TPM_RC_SUCCESS) {
2738 return result;
2739 }
2740 result = TPMT_ASYM_SCHEME_Unmarshal(&target->scheme, buffer, size);
2741 if (result != TPM_RC_SUCCESS) {
2742 return result;
2743 }
2744 return TPM_RC_SUCCESS;
2745 }
2746
TPMI_ALG_KDF_Marshal(TPMI_ALG_KDF * source,BYTE ** buffer,INT32 * size)2747 UINT16 TPMI_ALG_KDF_Marshal(TPMI_ALG_KDF* source, BYTE** buffer, INT32* size) {
2748 return uint16_t_Marshal(source, buffer, size);
2749 }
2750
TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2751 TPM_RC TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF* target,
2752 BYTE** buffer,
2753 INT32* size,
2754 BOOL allow_conditional_value) {
2755 TPM_RC result;
2756 BOOL has_valid_value = FALSE;
2757 result = uint16_t_Unmarshal(target, buffer, size);
2758 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2759 return result;
2760 }
2761 if (*target == TPM_ALG_NULL) {
2762 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_KDF;
2763 }
2764 switch (*target) {
2765 #ifdef TPM_ALG_MGF1
2766 case TPM_ALG_MGF1:
2767 #endif
2768 #ifdef TPM_ALG_KDF1_SP800_56A
2769 case TPM_ALG_KDF1_SP800_56A:
2770 #endif
2771 #ifdef TPM_ALG_KDF2
2772 case TPM_ALG_KDF2:
2773 #endif
2774 #ifdef TPM_ALG_KDF1_SP800_108
2775 case TPM_ALG_KDF1_SP800_108:
2776 #endif
2777 has_valid_value = TRUE;
2778 break;
2779 }
2780 if (!has_valid_value) {
2781 return TPM_RC_KDF;
2782 }
2783 return TPM_RC_SUCCESS;
2784 }
2785
TPMS_SCHEME_KDF1_SP800_108_Marshal(TPMS_SCHEME_KDF1_SP800_108 * source,BYTE ** buffer,INT32 * size)2786 UINT16 TPMS_SCHEME_KDF1_SP800_108_Marshal(TPMS_SCHEME_KDF1_SP800_108* source,
2787 BYTE** buffer,
2788 INT32* size) {
2789 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2790 }
2791
TPMS_SCHEME_KDF1_SP800_108_Unmarshal(TPMS_SCHEME_KDF1_SP800_108 * target,BYTE ** buffer,INT32 * size)2792 TPM_RC TPMS_SCHEME_KDF1_SP800_108_Unmarshal(TPMS_SCHEME_KDF1_SP800_108* target,
2793 BYTE** buffer,
2794 INT32* size) {
2795 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2796 }
2797
TPMS_SCHEME_KDF2_Marshal(TPMS_SCHEME_KDF2 * source,BYTE ** buffer,INT32 * size)2798 UINT16 TPMS_SCHEME_KDF2_Marshal(TPMS_SCHEME_KDF2* source,
2799 BYTE** buffer,
2800 INT32* size) {
2801 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2802 }
2803
TPMS_SCHEME_KDF2_Unmarshal(TPMS_SCHEME_KDF2 * target,BYTE ** buffer,INT32 * size)2804 TPM_RC TPMS_SCHEME_KDF2_Unmarshal(TPMS_SCHEME_KDF2* target,
2805 BYTE** buffer,
2806 INT32* size) {
2807 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2808 }
2809
TPMS_SCHEME_KDF1_SP800_56A_Marshal(TPMS_SCHEME_KDF1_SP800_56A * source,BYTE ** buffer,INT32 * size)2810 UINT16 TPMS_SCHEME_KDF1_SP800_56A_Marshal(TPMS_SCHEME_KDF1_SP800_56A* source,
2811 BYTE** buffer,
2812 INT32* size) {
2813 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2814 }
2815
TPMS_SCHEME_KDF1_SP800_56A_Unmarshal(TPMS_SCHEME_KDF1_SP800_56A * target,BYTE ** buffer,INT32 * size)2816 TPM_RC TPMS_SCHEME_KDF1_SP800_56A_Unmarshal(TPMS_SCHEME_KDF1_SP800_56A* target,
2817 BYTE** buffer,
2818 INT32* size) {
2819 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2820 }
2821
TPMS_SCHEME_MGF1_Marshal(TPMS_SCHEME_MGF1 * source,BYTE ** buffer,INT32 * size)2822 UINT16 TPMS_SCHEME_MGF1_Marshal(TPMS_SCHEME_MGF1* source,
2823 BYTE** buffer,
2824 INT32* size) {
2825 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2826 }
2827
TPMS_SCHEME_MGF1_Unmarshal(TPMS_SCHEME_MGF1 * target,BYTE ** buffer,INT32 * size)2828 TPM_RC TPMS_SCHEME_MGF1_Unmarshal(TPMS_SCHEME_MGF1* target,
2829 BYTE** buffer,
2830 INT32* size) {
2831 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2832 }
2833
TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)2834 UINT16 TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME* source,
2835 BYTE** buffer,
2836 INT32* size,
2837 UINT32 selector) {
2838 switch (selector) {
2839 #ifdef TPM_ALG_MGF1
2840 case TPM_ALG_MGF1:
2841 return TPMS_SCHEME_MGF1_Marshal((TPMS_SCHEME_MGF1*)&source->mgf1, buffer,
2842 size);
2843 #endif
2844 #ifdef TPM_ALG_KDF1_SP800_56A
2845 case TPM_ALG_KDF1_SP800_56A:
2846 return TPMS_SCHEME_KDF1_SP800_56A_Marshal(
2847 (TPMS_SCHEME_KDF1_SP800_56A*)&source->kdf1_sp800_56a, buffer, size);
2848 #endif
2849 #ifdef TPM_ALG_KDF2
2850 case TPM_ALG_KDF2:
2851 return TPMS_SCHEME_KDF2_Marshal((TPMS_SCHEME_KDF2*)&source->kdf2, buffer,
2852 size);
2853 #endif
2854 #ifdef TPM_ALG_KDF1_SP800_108
2855 case TPM_ALG_KDF1_SP800_108:
2856 return TPMS_SCHEME_KDF1_SP800_108_Marshal(
2857 (TPMS_SCHEME_KDF1_SP800_108*)&source->kdf1_sp800_108, buffer, size);
2858 #endif
2859 #ifdef TPM_ALG_NULL
2860 case TPM_ALG_NULL:
2861 return 0;
2862 #endif
2863 }
2864 return 0;
2865 }
2866
TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)2867 TPM_RC TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME* target,
2868 BYTE** buffer,
2869 INT32* size,
2870 UINT32 selector) {
2871 switch (selector) {
2872 #ifdef TPM_ALG_MGF1
2873 case TPM_ALG_MGF1:
2874 return TPMS_SCHEME_MGF1_Unmarshal((TPMS_SCHEME_MGF1*)&target->mgf1,
2875 buffer, size);
2876 #endif
2877 #ifdef TPM_ALG_KDF1_SP800_56A
2878 case TPM_ALG_KDF1_SP800_56A:
2879 return TPMS_SCHEME_KDF1_SP800_56A_Unmarshal(
2880 (TPMS_SCHEME_KDF1_SP800_56A*)&target->kdf1_sp800_56a, buffer, size);
2881 #endif
2882 #ifdef TPM_ALG_KDF2
2883 case TPM_ALG_KDF2:
2884 return TPMS_SCHEME_KDF2_Unmarshal((TPMS_SCHEME_KDF2*)&target->kdf2,
2885 buffer, size);
2886 #endif
2887 #ifdef TPM_ALG_KDF1_SP800_108
2888 case TPM_ALG_KDF1_SP800_108:
2889 return TPMS_SCHEME_KDF1_SP800_108_Unmarshal(
2890 (TPMS_SCHEME_KDF1_SP800_108*)&target->kdf1_sp800_108, buffer, size);
2891 #endif
2892 #ifdef TPM_ALG_NULL
2893 case TPM_ALG_NULL:
2894 return TPM_RC_SUCCESS;
2895 #endif
2896 }
2897 return TPM_RC_SELECTOR;
2898 }
2899
TPMT_KDF_SCHEME_Marshal(TPMT_KDF_SCHEME * source,BYTE ** buffer,INT32 * size)2900 UINT16 TPMT_KDF_SCHEME_Marshal(TPMT_KDF_SCHEME* source,
2901 BYTE** buffer,
2902 INT32* size) {
2903 UINT16 total_size = 0;
2904 total_size += TPMI_ALG_KDF_Marshal(&source->scheme, buffer, size);
2905 total_size +=
2906 TPMU_KDF_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2907 return total_size;
2908 }
2909
TPMT_KDF_SCHEME_Unmarshal(TPMT_KDF_SCHEME * target,BYTE ** buffer,INT32 * size)2910 TPM_RC TPMT_KDF_SCHEME_Unmarshal(TPMT_KDF_SCHEME* target,
2911 BYTE** buffer,
2912 INT32* size) {
2913 TPM_RC result;
2914 result = TPMI_ALG_KDF_Unmarshal(&target->scheme, buffer, size, TRUE);
2915 if (result != TPM_RC_SUCCESS) {
2916 return result;
2917 }
2918 result =
2919 TPMU_KDF_SCHEME_Unmarshal(&target->details, buffer, size, target->scheme);
2920 if (result != TPM_RC_SUCCESS) {
2921 return result;
2922 }
2923 return TPM_RC_SUCCESS;
2924 }
2925
TPMI_ALG_ECC_SCHEME_Marshal(TPMI_ALG_ECC_SCHEME * source,BYTE ** buffer,INT32 * size)2926 UINT16 TPMI_ALG_ECC_SCHEME_Marshal(TPMI_ALG_ECC_SCHEME* source,
2927 BYTE** buffer,
2928 INT32* size) {
2929 return uint16_t_Marshal(source, buffer, size);
2930 }
2931
TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2932 TPM_RC TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME* target,
2933 BYTE** buffer,
2934 INT32* size,
2935 BOOL allow_conditional_value) {
2936 TPM_RC result;
2937 BOOL has_valid_value = FALSE;
2938 result = uint16_t_Unmarshal(target, buffer, size);
2939 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2940 return result;
2941 }
2942 if (*target == TPM_ALG_NULL) {
2943 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SCHEME;
2944 }
2945 switch (*target) {
2946 #ifdef TPM_ALG_ECDSA
2947 case TPM_ALG_ECDSA:
2948 #endif
2949 #ifdef TPM_ALG_ECDAA
2950 case TPM_ALG_ECDAA:
2951 #endif
2952 #ifdef TPM_ALG_SM2
2953 case TPM_ALG_SM2:
2954 #endif
2955 #ifdef TPM_ALG_ECSCHNORR
2956 case TPM_ALG_ECSCHNORR:
2957 #endif
2958 #ifdef TPM_ALG_ECDH
2959 case TPM_ALG_ECDH:
2960 #endif
2961 #ifdef TPM_ALG_ECMQV
2962 case TPM_ALG_ECMQV:
2963 #endif
2964 has_valid_value = TRUE;
2965 break;
2966 }
2967 if (!has_valid_value) {
2968 return TPM_RC_SCHEME;
2969 }
2970 return TPM_RC_SUCCESS;
2971 }
2972
TPMT_ECC_SCHEME_Marshal(TPMT_ECC_SCHEME * source,BYTE ** buffer,INT32 * size)2973 UINT16 TPMT_ECC_SCHEME_Marshal(TPMT_ECC_SCHEME* source,
2974 BYTE** buffer,
2975 INT32* size) {
2976 UINT16 total_size = 0;
2977 total_size += TPMI_ALG_ECC_SCHEME_Marshal(&source->scheme, buffer, size);
2978 total_size +=
2979 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2980 return total_size;
2981 }
2982
TPMT_ECC_SCHEME_Unmarshal(TPMT_ECC_SCHEME * target,BYTE ** buffer,INT32 * size)2983 TPM_RC TPMT_ECC_SCHEME_Unmarshal(TPMT_ECC_SCHEME* target,
2984 BYTE** buffer,
2985 INT32* size) {
2986 TPM_RC result;
2987 result = TPMI_ALG_ECC_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
2988 if (result != TPM_RC_SUCCESS) {
2989 return result;
2990 }
2991 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
2992 target->scheme);
2993 if (result != TPM_RC_SUCCESS) {
2994 return result;
2995 }
2996 return TPM_RC_SUCCESS;
2997 }
2998
TPMI_ECC_CURVE_Marshal(TPMI_ECC_CURVE * source,BYTE ** buffer,INT32 * size)2999 UINT16 TPMI_ECC_CURVE_Marshal(TPMI_ECC_CURVE* source,
3000 BYTE** buffer,
3001 INT32* size) {
3002 return uint16_t_Marshal(source, buffer, size);
3003 }
3004
TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE * target,BYTE ** buffer,INT32 * size)3005 TPM_RC TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE* target,
3006 BYTE** buffer,
3007 INT32* size) {
3008 TPM_RC result;
3009 uint16_t supported_values[] = ECC_CURVES;
3010 size_t length = sizeof(supported_values) / sizeof(supported_values[0]);
3011 size_t i;
3012 BOOL is_supported_value = FALSE;
3013 result = uint16_t_Unmarshal(target, buffer, size);
3014 if (result != TPM_RC_SUCCESS) {
3015 return result;
3016 }
3017 for (i = 0; i < length; ++i) {
3018 if (*target == supported_values[i]) {
3019 is_supported_value = TRUE;
3020 break;
3021 }
3022 }
3023 if (!is_supported_value) {
3024 return TPM_RC_CURVE;
3025 }
3026 return TPM_RC_SUCCESS;
3027 }
3028
TPMS_ECC_PARMS_Marshal(TPMS_ECC_PARMS * source,BYTE ** buffer,INT32 * size)3029 UINT16 TPMS_ECC_PARMS_Marshal(TPMS_ECC_PARMS* source,
3030 BYTE** buffer,
3031 INT32* size) {
3032 UINT16 total_size = 0;
3033 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->symmetric, buffer, size);
3034 total_size += TPMT_ECC_SCHEME_Marshal(&source->scheme, buffer, size);
3035 total_size += TPMI_ECC_CURVE_Marshal(&source->curveID, buffer, size);
3036 total_size += TPMT_KDF_SCHEME_Marshal(&source->kdf, buffer, size);
3037 return total_size;
3038 }
3039
TPMS_ECC_PARMS_Unmarshal(TPMS_ECC_PARMS * target,BYTE ** buffer,INT32 * size)3040 TPM_RC TPMS_ECC_PARMS_Unmarshal(TPMS_ECC_PARMS* target,
3041 BYTE** buffer,
3042 INT32* size) {
3043 TPM_RC result;
3044 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->symmetric, buffer, size);
3045 if (result != TPM_RC_SUCCESS) {
3046 return result;
3047 }
3048 result = TPMT_ECC_SCHEME_Unmarshal(&target->scheme, buffer, size);
3049 if (result != TPM_RC_SUCCESS) {
3050 return result;
3051 }
3052 result = TPMI_ECC_CURVE_Unmarshal(&target->curveID, buffer, size);
3053 if (result != TPM_RC_SUCCESS) {
3054 return result;
3055 }
3056 result = TPMT_KDF_SCHEME_Unmarshal(&target->kdf, buffer, size);
3057 if (result != TPM_RC_SUCCESS) {
3058 return result;
3059 }
3060 return TPM_RC_SUCCESS;
3061 }
3062
TPMI_ALG_KEYEDHASH_SCHEME_Marshal(TPMI_ALG_KEYEDHASH_SCHEME * source,BYTE ** buffer,INT32 * size)3063 UINT16 TPMI_ALG_KEYEDHASH_SCHEME_Marshal(TPMI_ALG_KEYEDHASH_SCHEME* source,
3064 BYTE** buffer,
3065 INT32* size) {
3066 return uint16_t_Marshal(source, buffer, size);
3067 }
3068
TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3069 TPM_RC TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME* target,
3070 BYTE** buffer,
3071 INT32* size,
3072 BOOL allow_conditional_value) {
3073 TPM_RC result;
3074 BOOL has_valid_value = FALSE;
3075 result = uint16_t_Unmarshal(target, buffer, size);
3076 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3077 return result;
3078 }
3079 if (*target == TPM_ALG_NULL) {
3080 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
3081 }
3082 switch (*target) {
3083 #ifdef TPM_ALG_HMAC
3084 case TPM_ALG_HMAC:
3085 #endif
3086 #ifdef TPM_ALG_XOR
3087 case TPM_ALG_XOR:
3088 #endif
3089 has_valid_value = TRUE;
3090 break;
3091 }
3092 if (!has_valid_value) {
3093 return TPM_RC_VALUE;
3094 }
3095 return TPM_RC_SUCCESS;
3096 }
3097
TPMS_SCHEME_HMAC_Marshal(TPMS_SCHEME_HMAC * source,BYTE ** buffer,INT32 * size)3098 UINT16 TPMS_SCHEME_HMAC_Marshal(TPMS_SCHEME_HMAC* source,
3099 BYTE** buffer,
3100 INT32* size) {
3101 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
3102 }
3103
TPMS_SCHEME_HMAC_Unmarshal(TPMS_SCHEME_HMAC * target,BYTE ** buffer,INT32 * size)3104 TPM_RC TPMS_SCHEME_HMAC_Unmarshal(TPMS_SCHEME_HMAC* target,
3105 BYTE** buffer,
3106 INT32* size) {
3107 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
3108 }
3109
TPMS_SCHEME_XOR_Marshal(TPMS_SCHEME_XOR * source,BYTE ** buffer,INT32 * size)3110 UINT16 TPMS_SCHEME_XOR_Marshal(TPMS_SCHEME_XOR* source,
3111 BYTE** buffer,
3112 INT32* size) {
3113 UINT16 total_size = 0;
3114 total_size += TPMI_ALG_HASH_Marshal(&source->hashAlg, buffer, size);
3115 total_size += TPMI_ALG_KDF_Marshal(&source->kdf, buffer, size);
3116 return total_size;
3117 }
3118
TPMS_SCHEME_XOR_Unmarshal(TPMS_SCHEME_XOR * target,BYTE ** buffer,INT32 * size)3119 TPM_RC TPMS_SCHEME_XOR_Unmarshal(TPMS_SCHEME_XOR* target,
3120 BYTE** buffer,
3121 INT32* size) {
3122 TPM_RC result;
3123 result = TPMI_ALG_HASH_Unmarshal(&target->hashAlg, buffer, size, TRUE);
3124 if (result != TPM_RC_SUCCESS) {
3125 return result;
3126 }
3127 result = TPMI_ALG_KDF_Unmarshal(&target->kdf, buffer, size, FALSE);
3128 if (result != TPM_RC_SUCCESS) {
3129 return result;
3130 }
3131 return TPM_RC_SUCCESS;
3132 }
3133
TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH * source,BYTE ** buffer,INT32 * size,UINT32 selector)3134 UINT16 TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH* source,
3135 BYTE** buffer,
3136 INT32* size,
3137 UINT32 selector) {
3138 switch (selector) {
3139 #ifdef TPM_ALG_HMAC
3140 case TPM_ALG_HMAC:
3141 return TPMS_SCHEME_HMAC_Marshal((TPMS_SCHEME_HMAC*)&source->hmac, buffer,
3142 size);
3143 #endif
3144 #ifdef TPM_ALG_XOR
3145 case TPM_ALG_XOR:
3146 return TPMS_SCHEME_XOR_Marshal((TPMS_SCHEME_XOR*)&source->xor_, buffer,
3147 size);
3148 #endif
3149 #ifdef TPM_ALG_NULL
3150 case TPM_ALG_NULL:
3151 return 0;
3152 #endif
3153 }
3154 return 0;
3155 }
3156
TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH * target,BYTE ** buffer,INT32 * size,UINT32 selector)3157 TPM_RC TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH* target,
3158 BYTE** buffer,
3159 INT32* size,
3160 UINT32 selector) {
3161 switch (selector) {
3162 #ifdef TPM_ALG_HMAC
3163 case TPM_ALG_HMAC:
3164 return TPMS_SCHEME_HMAC_Unmarshal((TPMS_SCHEME_HMAC*)&target->hmac,
3165 buffer, size);
3166 #endif
3167 #ifdef TPM_ALG_XOR
3168 case TPM_ALG_XOR:
3169 return TPMS_SCHEME_XOR_Unmarshal((TPMS_SCHEME_XOR*)&target->xor_, buffer,
3170 size);
3171 #endif
3172 #ifdef TPM_ALG_NULL
3173 case TPM_ALG_NULL:
3174 return TPM_RC_SUCCESS;
3175 #endif
3176 }
3177 return TPM_RC_SELECTOR;
3178 }
3179
TPMT_KEYEDHASH_SCHEME_Marshal(TPMT_KEYEDHASH_SCHEME * source,BYTE ** buffer,INT32 * size)3180 UINT16 TPMT_KEYEDHASH_SCHEME_Marshal(TPMT_KEYEDHASH_SCHEME* source,
3181 BYTE** buffer,
3182 INT32* size) {
3183 UINT16 total_size = 0;
3184 total_size +=
3185 TPMI_ALG_KEYEDHASH_SCHEME_Marshal(&source->scheme, buffer, size);
3186 total_size += TPMU_SCHEME_KEYEDHASH_Marshal(&source->details, buffer, size,
3187 source->scheme);
3188 return total_size;
3189 }
3190
TPMT_KEYEDHASH_SCHEME_Unmarshal(TPMT_KEYEDHASH_SCHEME * target,BYTE ** buffer,INT32 * size)3191 TPM_RC TPMT_KEYEDHASH_SCHEME_Unmarshal(TPMT_KEYEDHASH_SCHEME* target,
3192 BYTE** buffer,
3193 INT32* size) {
3194 TPM_RC result;
3195 result =
3196 TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
3197 if (result != TPM_RC_SUCCESS) {
3198 return result;
3199 }
3200 result = TPMU_SCHEME_KEYEDHASH_Unmarshal(&target->details, buffer, size,
3201 target->scheme);
3202 if (result != TPM_RC_SUCCESS) {
3203 return result;
3204 }
3205 return TPM_RC_SUCCESS;
3206 }
3207
TPMS_KEYEDHASH_PARMS_Marshal(TPMS_KEYEDHASH_PARMS * source,BYTE ** buffer,INT32 * size)3208 UINT16 TPMS_KEYEDHASH_PARMS_Marshal(TPMS_KEYEDHASH_PARMS* source,
3209 BYTE** buffer,
3210 INT32* size) {
3211 UINT16 total_size = 0;
3212 total_size += TPMT_KEYEDHASH_SCHEME_Marshal(&source->scheme, buffer, size);
3213 return total_size;
3214 }
3215
TPMS_KEYEDHASH_PARMS_Unmarshal(TPMS_KEYEDHASH_PARMS * target,BYTE ** buffer,INT32 * size)3216 TPM_RC TPMS_KEYEDHASH_PARMS_Unmarshal(TPMS_KEYEDHASH_PARMS* target,
3217 BYTE** buffer,
3218 INT32* size) {
3219 TPM_RC result;
3220 result = TPMT_KEYEDHASH_SCHEME_Unmarshal(&target->scheme, buffer, size);
3221 if (result != TPM_RC_SUCCESS) {
3222 return result;
3223 }
3224 return TPM_RC_SUCCESS;
3225 }
3226
TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS * source,BYTE ** buffer,INT32 * size,UINT32 selector)3227 UINT16 TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS* source,
3228 BYTE** buffer,
3229 INT32* size,
3230 UINT32 selector) {
3231 switch (selector) {
3232 #ifdef TPM_ALG_KEYEDHASH
3233 case TPM_ALG_KEYEDHASH:
3234 return TPMS_KEYEDHASH_PARMS_Marshal(
3235 (TPMS_KEYEDHASH_PARMS*)&source->keyedHashDetail, buffer, size);
3236 #endif
3237 #ifdef TPM_ALG_SYMCIPHER
3238 case TPM_ALG_SYMCIPHER:
3239 return TPMS_SYMCIPHER_PARMS_Marshal(
3240 (TPMS_SYMCIPHER_PARMS*)&source->symDetail, buffer, size);
3241 #endif
3242 #ifdef TPM_ALG_RSA
3243 case TPM_ALG_RSA:
3244 return TPMS_RSA_PARMS_Marshal((TPMS_RSA_PARMS*)&source->rsaDetail, buffer,
3245 size);
3246 #endif
3247 #ifdef TPM_ALG_ECC
3248 case TPM_ALG_ECC:
3249 return TPMS_ECC_PARMS_Marshal((TPMS_ECC_PARMS*)&source->eccDetail, buffer,
3250 size);
3251 #endif
3252 }
3253 return 0;
3254 }
3255
TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS * target,BYTE ** buffer,INT32 * size,UINT32 selector)3256 TPM_RC TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS* target,
3257 BYTE** buffer,
3258 INT32* size,
3259 UINT32 selector) {
3260 switch (selector) {
3261 #ifdef TPM_ALG_KEYEDHASH
3262 case TPM_ALG_KEYEDHASH:
3263 return TPMS_KEYEDHASH_PARMS_Unmarshal(
3264 (TPMS_KEYEDHASH_PARMS*)&target->keyedHashDetail, buffer, size);
3265 #endif
3266 #ifdef TPM_ALG_SYMCIPHER
3267 case TPM_ALG_SYMCIPHER:
3268 return TPMS_SYMCIPHER_PARMS_Unmarshal(
3269 (TPMS_SYMCIPHER_PARMS*)&target->symDetail, buffer, size);
3270 #endif
3271 #ifdef TPM_ALG_RSA
3272 case TPM_ALG_RSA:
3273 return TPMS_RSA_PARMS_Unmarshal((TPMS_RSA_PARMS*)&target->rsaDetail,
3274 buffer, size);
3275 #endif
3276 #ifdef TPM_ALG_ECC
3277 case TPM_ALG_ECC:
3278 return TPMS_ECC_PARMS_Unmarshal((TPMS_ECC_PARMS*)&target->eccDetail,
3279 buffer, size);
3280 #endif
3281 }
3282 return TPM_RC_SELECTOR;
3283 }
3284
TPMT_PUBLIC_Marshal(TPMT_PUBLIC * source,BYTE ** buffer,INT32 * size)3285 UINT16 TPMT_PUBLIC_Marshal(TPMT_PUBLIC* source, BYTE** buffer, INT32* size) {
3286 UINT16 total_size = 0;
3287 total_size += TPMI_ALG_PUBLIC_Marshal(&source->type, buffer, size);
3288 total_size += TPMI_ALG_HASH_Marshal(&source->nameAlg, buffer, size);
3289 total_size += TPMA_OBJECT_Marshal(&source->objectAttributes, buffer, size);
3290 total_size += TPM2B_DIGEST_Marshal(&source->authPolicy, buffer, size);
3291 total_size += TPMU_PUBLIC_PARMS_Marshal(&source->parameters, buffer, size,
3292 source->type);
3293 total_size +=
3294 TPMU_PUBLIC_ID_Marshal(&source->unique, buffer, size, source->type);
3295 return total_size;
3296 }
3297
TPMT_PUBLIC_Unmarshal(TPMT_PUBLIC * target,BYTE ** buffer,INT32 * size)3298 TPM_RC TPMT_PUBLIC_Unmarshal(TPMT_PUBLIC* target, BYTE** buffer, INT32* size) {
3299 TPM_RC result;
3300 result = TPMI_ALG_PUBLIC_Unmarshal(&target->type, buffer, size);
3301 if (result != TPM_RC_SUCCESS) {
3302 return result;
3303 }
3304 result = TPMI_ALG_HASH_Unmarshal(&target->nameAlg, buffer, size, TRUE);
3305 if (result != TPM_RC_SUCCESS) {
3306 return result;
3307 }
3308 result = TPMA_OBJECT_Unmarshal(&target->objectAttributes, buffer, size);
3309 if (result != TPM_RC_SUCCESS) {
3310 return result;
3311 }
3312 result = TPM2B_DIGEST_Unmarshal(&target->authPolicy, buffer, size);
3313 if (result != TPM_RC_SUCCESS) {
3314 return result;
3315 }
3316 result = TPMU_PUBLIC_PARMS_Unmarshal(&target->parameters, buffer, size,
3317 target->type);
3318 if (result != TPM_RC_SUCCESS) {
3319 return result;
3320 }
3321 result =
3322 TPMU_PUBLIC_ID_Unmarshal(&target->unique, buffer, size, target->type);
3323 if (result != TPM_RC_SUCCESS) {
3324 return result;
3325 }
3326 return TPM_RC_SUCCESS;
3327 }
3328
TPM2B_PUBLIC_Marshal(TPM2B_PUBLIC * source,BYTE ** buffer,INT32 * size)3329 UINT16 TPM2B_PUBLIC_Marshal(TPM2B_PUBLIC* source, BYTE** buffer, INT32* size) {
3330 UINT16 total_size = 0;
3331 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3332 total_size += TPMT_PUBLIC_Marshal(&source->t.publicArea, buffer, size);
3333 {
3334 BYTE* size_location = *buffer - total_size;
3335 INT32 size_field_size = sizeof(UINT16);
3336 UINT16 payload_size = total_size - (UINT16)size_field_size;
3337 UINT16_Marshal(&payload_size, &size_location, &size_field_size);
3338 }
3339 return total_size;
3340 }
3341
TPM2B_PUBLIC_Unmarshal(TPM2B_PUBLIC * target,BYTE ** buffer,INT32 * size)3342 TPM_RC TPM2B_PUBLIC_Unmarshal(TPM2B_PUBLIC* target,
3343 BYTE** buffer,
3344 INT32* size) {
3345 TPM_RC result;
3346 UINT32 start_size = *size;
3347 UINT32 struct_size;
3348 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3349 if (result != TPM_RC_SUCCESS) {
3350 return result;
3351 }
3352 if (target->t.size == 0) {
3353 return TPM_RC_SIZE;
3354 }
3355 result = TPMT_PUBLIC_Unmarshal(&target->t.publicArea, buffer, size);
3356 if (result != TPM_RC_SUCCESS) {
3357 return result;
3358 }
3359 struct_size = start_size - *size - sizeof(target->t.size);
3360 if (struct_size != target->t.size) {
3361 return TPM_RC_SIZE;
3362 }
3363 return TPM_RC_SUCCESS;
3364 }
3365
TPM2B_SENSITIVE_DATA_Marshal(TPM2B_SENSITIVE_DATA * source,BYTE ** buffer,INT32 * size)3366 UINT16 TPM2B_SENSITIVE_DATA_Marshal(TPM2B_SENSITIVE_DATA* source,
3367 BYTE** buffer,
3368 INT32* size) {
3369 UINT16 total_size = 0;
3370 INT32 i;
3371 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3372 for (i = 0; i < source->t.size; ++i) {
3373 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
3374 }
3375 return total_size;
3376 }
3377
TPM2B_SENSITIVE_DATA_Unmarshal(TPM2B_SENSITIVE_DATA * target,BYTE ** buffer,INT32 * size)3378 TPM_RC TPM2B_SENSITIVE_DATA_Unmarshal(TPM2B_SENSITIVE_DATA* target,
3379 BYTE** buffer,
3380 INT32* size) {
3381 TPM_RC result;
3382 INT32 i;
3383 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3384 if (result != TPM_RC_SUCCESS) {
3385 return result;
3386 }
3387 if (target->t.size == 0) {
3388 return TPM_RC_SUCCESS;
3389 }
3390 if (target->t.size > MAX_SYM_DATA) {
3391 return TPM_RC_SIZE;
3392 }
3393 for (i = 0; i < target->t.size; ++i) {
3394 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
3395 if (result != TPM_RC_SUCCESS) {
3396 return result;
3397 }
3398 }
3399 return TPM_RC_SUCCESS;
3400 }
3401
TPM2B_SYM_KEY_Marshal(TPM2B_SYM_KEY * source,BYTE ** buffer,INT32 * size)3402 UINT16 TPM2B_SYM_KEY_Marshal(TPM2B_SYM_KEY* source,
3403 BYTE** buffer,
3404 INT32* size) {
3405 UINT16 total_size = 0;
3406 INT32 i;
3407 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3408 for (i = 0; i < source->t.size; ++i) {
3409 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
3410 }
3411 return total_size;
3412 }
3413
TPM2B_SYM_KEY_Unmarshal(TPM2B_SYM_KEY * target,BYTE ** buffer,INT32 * size)3414 TPM_RC TPM2B_SYM_KEY_Unmarshal(TPM2B_SYM_KEY* target,
3415 BYTE** buffer,
3416 INT32* size) {
3417 TPM_RC result;
3418 INT32 i;
3419 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3420 if (result != TPM_RC_SUCCESS) {
3421 return result;
3422 }
3423 if (target->t.size == 0) {
3424 return TPM_RC_SUCCESS;
3425 }
3426 if (target->t.size > MAX_SYM_KEY_BYTES) {
3427 return TPM_RC_SIZE;
3428 }
3429 for (i = 0; i < target->t.size; ++i) {
3430 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
3431 if (result != TPM_RC_SUCCESS) {
3432 return result;
3433 }
3434 }
3435 return TPM_RC_SUCCESS;
3436 }
3437
TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE * source,BYTE ** buffer,INT32 * size,UINT32 selector)3438 UINT16 TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE* source,
3439 BYTE** buffer,
3440 INT32* size,
3441 UINT32 selector) {
3442 switch (selector) {
3443 #ifdef TPM_ALG_RSA
3444 case TPM_ALG_RSA:
3445 return TPM2B_PRIVATE_KEY_RSA_Marshal((TPM2B_PRIVATE_KEY_RSA*)&source->rsa,
3446 buffer, size);
3447 #endif
3448 #ifdef TPM_ALG_ECC
3449 case TPM_ALG_ECC:
3450 return TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER*)&source->ecc,
3451 buffer, size);
3452 #endif
3453 #ifdef TPM_ALG_KEYEDHASH
3454 case TPM_ALG_KEYEDHASH:
3455 return TPM2B_SENSITIVE_DATA_Marshal((TPM2B_SENSITIVE_DATA*)&source->bits,
3456 buffer, size);
3457 #endif
3458 #ifdef TPM_ALG_SYMCIPHER
3459 case TPM_ALG_SYMCIPHER:
3460 return TPM2B_SYM_KEY_Marshal((TPM2B_SYM_KEY*)&source->sym, buffer, size);
3461 #endif
3462 }
3463 return 0;
3464 }
3465
TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE * target,BYTE ** buffer,INT32 * size,UINT32 selector)3466 TPM_RC TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE* target,
3467 BYTE** buffer,
3468 INT32* size,
3469 UINT32 selector) {
3470 switch (selector) {
3471 #ifdef TPM_ALG_RSA
3472 case TPM_ALG_RSA:
3473 return TPM2B_PRIVATE_KEY_RSA_Unmarshal(
3474 (TPM2B_PRIVATE_KEY_RSA*)&target->rsa, buffer, size);
3475 #endif
3476 #ifdef TPM_ALG_ECC
3477 case TPM_ALG_ECC:
3478 return TPM2B_ECC_PARAMETER_Unmarshal((TPM2B_ECC_PARAMETER*)&target->ecc,
3479 buffer, size);
3480 #endif
3481 #ifdef TPM_ALG_KEYEDHASH
3482 case TPM_ALG_KEYEDHASH:
3483 return TPM2B_SENSITIVE_DATA_Unmarshal(
3484 (TPM2B_SENSITIVE_DATA*)&target->bits, buffer, size);
3485 #endif
3486 #ifdef TPM_ALG_SYMCIPHER
3487 case TPM_ALG_SYMCIPHER:
3488 return TPM2B_SYM_KEY_Unmarshal((TPM2B_SYM_KEY*)&target->sym, buffer,
3489 size);
3490 #endif
3491 }
3492 return TPM_RC_SELECTOR;
3493 }
3494
TPMT_SENSITIVE_Marshal(TPMT_SENSITIVE * source,BYTE ** buffer,INT32 * size)3495 UINT16 TPMT_SENSITIVE_Marshal(TPMT_SENSITIVE* source,
3496 BYTE** buffer,
3497 INT32* size) {
3498 UINT16 total_size = 0;
3499 total_size += TPMI_ALG_PUBLIC_Marshal(&source->sensitiveType, buffer, size);
3500 total_size += TPM2B_AUTH_Marshal(&source->authValue, buffer, size);
3501 total_size += TPM2B_DIGEST_Marshal(&source->seedValue, buffer, size);
3502 total_size += TPMU_SENSITIVE_COMPOSITE_Marshal(&source->sensitive, buffer,
3503 size, source->sensitiveType);
3504 return total_size;
3505 }
3506
TPMT_SENSITIVE_Unmarshal(TPMT_SENSITIVE * target,BYTE ** buffer,INT32 * size)3507 TPM_RC TPMT_SENSITIVE_Unmarshal(TPMT_SENSITIVE* target,
3508 BYTE** buffer,
3509 INT32* size) {
3510 TPM_RC result;
3511 result = TPMI_ALG_PUBLIC_Unmarshal(&target->sensitiveType, buffer, size);
3512 if (result != TPM_RC_SUCCESS) {
3513 return result;
3514 }
3515 result = TPM2B_AUTH_Unmarshal(&target->authValue, buffer, size);
3516 if (result != TPM_RC_SUCCESS) {
3517 return result;
3518 }
3519 result = TPM2B_DIGEST_Unmarshal(&target->seedValue, buffer, size);
3520 if (result != TPM_RC_SUCCESS) {
3521 return result;
3522 }
3523 result = TPMU_SENSITIVE_COMPOSITE_Unmarshal(&target->sensitive, buffer, size,
3524 target->sensitiveType);
3525 if (result != TPM_RC_SUCCESS) {
3526 return result;
3527 }
3528 return TPM_RC_SUCCESS;
3529 }
3530
TPM2B_SENSITIVE_Marshal(TPM2B_SENSITIVE * source,BYTE ** buffer,INT32 * size)3531 UINT16 TPM2B_SENSITIVE_Marshal(TPM2B_SENSITIVE* source,
3532 BYTE** buffer,
3533 INT32* size) {
3534 UINT16 total_size = 0;
3535 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3536 total_size += TPMT_SENSITIVE_Marshal(&source->t.sensitiveArea, buffer, size);
3537 return total_size;
3538 }
3539
TPM2B_SENSITIVE_Unmarshal(TPM2B_SENSITIVE * target,BYTE ** buffer,INT32 * size)3540 TPM_RC TPM2B_SENSITIVE_Unmarshal(TPM2B_SENSITIVE* target,
3541 BYTE** buffer,
3542 INT32* size) {
3543 TPM_RC result;
3544 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3545 if (result != TPM_RC_SUCCESS) {
3546 return result;
3547 }
3548 if (target->t.size == 0) {
3549 return TPM_RC_SUCCESS;
3550 }
3551 result = TPMT_SENSITIVE_Unmarshal(&target->t.sensitiveArea, buffer, size);
3552 if (result != TPM_RC_SUCCESS) {
3553 return result;
3554 }
3555 return TPM_RC_SUCCESS;
3556 }
3557
TPMS_SENSITIVE_CREATE_Marshal(TPMS_SENSITIVE_CREATE * source,BYTE ** buffer,INT32 * size)3558 UINT16 TPMS_SENSITIVE_CREATE_Marshal(TPMS_SENSITIVE_CREATE* source,
3559 BYTE** buffer,
3560 INT32* size) {
3561 UINT16 total_size = 0;
3562 total_size += TPM2B_AUTH_Marshal(&source->userAuth, buffer, size);
3563 total_size += TPM2B_SENSITIVE_DATA_Marshal(&source->data, buffer, size);
3564 return total_size;
3565 }
3566
TPMS_SENSITIVE_CREATE_Unmarshal(TPMS_SENSITIVE_CREATE * target,BYTE ** buffer,INT32 * size)3567 TPM_RC TPMS_SENSITIVE_CREATE_Unmarshal(TPMS_SENSITIVE_CREATE* target,
3568 BYTE** buffer,
3569 INT32* size) {
3570 TPM_RC result;
3571 result = TPM2B_AUTH_Unmarshal(&target->userAuth, buffer, size);
3572 if (result != TPM_RC_SUCCESS) {
3573 return result;
3574 }
3575 result = TPM2B_SENSITIVE_DATA_Unmarshal(&target->data, buffer, size);
3576 if (result != TPM_RC_SUCCESS) {
3577 return result;
3578 }
3579 return TPM_RC_SUCCESS;
3580 }
3581
TPM2B_SENSITIVE_CREATE_Marshal(TPM2B_SENSITIVE_CREATE * source,BYTE ** buffer,INT32 * size)3582 UINT16 TPM2B_SENSITIVE_CREATE_Marshal(TPM2B_SENSITIVE_CREATE* source,
3583 BYTE** buffer,
3584 INT32* size) {
3585 UINT16 total_size = 0;
3586 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3587 total_size +=
3588 TPMS_SENSITIVE_CREATE_Marshal(&source->t.sensitive, buffer, size);
3589 {
3590 BYTE* size_location = *buffer - total_size;
3591 INT32 size_field_size = sizeof(UINT16);
3592 UINT16 payload_size = total_size - (UINT16)size_field_size;
3593 UINT16_Marshal(&payload_size, &size_location, &size_field_size);
3594 }
3595 return total_size;
3596 }
3597
TPM2B_SENSITIVE_CREATE_Unmarshal(TPM2B_SENSITIVE_CREATE * target,BYTE ** buffer,INT32 * size)3598 TPM_RC TPM2B_SENSITIVE_CREATE_Unmarshal(TPM2B_SENSITIVE_CREATE* target,
3599 BYTE** buffer,
3600 INT32* size) {
3601 TPM_RC result;
3602 UINT32 start_size = *size;
3603 UINT32 struct_size;
3604 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3605 if (result != TPM_RC_SUCCESS) {
3606 return result;
3607 }
3608 if (target->t.size == 0) {
3609 return TPM_RC_SIZE;
3610 }
3611 result = TPMS_SENSITIVE_CREATE_Unmarshal(&target->t.sensitive, buffer, size);
3612 if (result != TPM_RC_SUCCESS) {
3613 return result;
3614 }
3615 struct_size = start_size - *size - sizeof(target->t.size);
3616 if (struct_size != target->t.size) {
3617 return TPM_RC_SIZE;
3618 }
3619 return TPM_RC_SUCCESS;
3620 }
3621
TPM2B_TIMEOUT_Marshal(TPM2B_TIMEOUT * source,BYTE ** buffer,INT32 * size)3622 UINT16 TPM2B_TIMEOUT_Marshal(TPM2B_TIMEOUT* source,
3623 BYTE** buffer,
3624 INT32* size) {
3625 UINT16 total_size = 0;
3626 INT32 i;
3627 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3628 for (i = 0; i < source->t.size; ++i) {
3629 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
3630 }
3631 return total_size;
3632 }
3633
TPM2B_TIMEOUT_Unmarshal(TPM2B_TIMEOUT * target,BYTE ** buffer,INT32 * size)3634 TPM_RC TPM2B_TIMEOUT_Unmarshal(TPM2B_TIMEOUT* target,
3635 BYTE** buffer,
3636 INT32* size) {
3637 TPM_RC result;
3638 INT32 i;
3639 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3640 if (result != TPM_RC_SUCCESS) {
3641 return result;
3642 }
3643 if (target->t.size == 0) {
3644 return TPM_RC_SUCCESS;
3645 }
3646 if (target->t.size > sizeof(UINT64)) {
3647 return TPM_RC_SIZE;
3648 }
3649 for (i = 0; i < target->t.size; ++i) {
3650 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
3651 if (result != TPM_RC_SUCCESS) {
3652 return result;
3653 }
3654 }
3655 return TPM_RC_SUCCESS;
3656 }
3657
TPMA_ALGORITHM_Marshal(TPMA_ALGORITHM * source,BYTE ** buffer,INT32 * size)3658 UINT16 TPMA_ALGORITHM_Marshal(TPMA_ALGORITHM* source,
3659 BYTE** buffer,
3660 INT32* size) {
3661 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3662 }
3663
TPMA_ALGORITHM_Unmarshal(TPMA_ALGORITHM * target,BYTE ** buffer,INT32 * size)3664 TPM_RC TPMA_ALGORITHM_Unmarshal(TPMA_ALGORITHM* target,
3665 BYTE** buffer,
3666 INT32* size) {
3667 TPM_RC result;
3668 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3669 if (result != TPM_RC_SUCCESS) {
3670 return result;
3671 }
3672 if (target->reserved4_7 != 0) {
3673 return TPM_RC_RESERVED_BITS;
3674 }
3675 if (target->reserved11_31 != 0) {
3676 return TPM_RC_RESERVED_BITS;
3677 }
3678 return TPM_RC_SUCCESS;
3679 }
3680
TPMA_CC_Marshal(TPMA_CC * source,BYTE ** buffer,INT32 * size)3681 UINT16 TPMA_CC_Marshal(TPMA_CC* source, BYTE** buffer, INT32* size) {
3682 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3683 }
3684
TPMA_CC_Unmarshal(TPMA_CC * target,BYTE ** buffer,INT32 * size)3685 TPM_RC TPMA_CC_Unmarshal(TPMA_CC* target, BYTE** buffer, INT32* size) {
3686 TPM_RC result;
3687 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3688 if (result != TPM_RC_SUCCESS) {
3689 return result;
3690 }
3691 if (target->reserved16_21 != 0) {
3692 return TPM_RC_RESERVED_BITS;
3693 }
3694 return TPM_RC_SUCCESS;
3695 }
3696
TPMA_MEMORY_Marshal(TPMA_MEMORY * source,BYTE ** buffer,INT32 * size)3697 UINT16 TPMA_MEMORY_Marshal(TPMA_MEMORY* source, BYTE** buffer, INT32* size) {
3698 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3699 }
3700
TPMA_MEMORY_Unmarshal(TPMA_MEMORY * target,BYTE ** buffer,INT32 * size)3701 TPM_RC TPMA_MEMORY_Unmarshal(TPMA_MEMORY* target, BYTE** buffer, INT32* size) {
3702 TPM_RC result;
3703 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3704 if (result != TPM_RC_SUCCESS) {
3705 return result;
3706 }
3707 if (target->reserved3_31 != 0) {
3708 return TPM_RC_RESERVED_BITS;
3709 }
3710 return TPM_RC_SUCCESS;
3711 }
3712
TPMA_PERMANENT_Marshal(TPMA_PERMANENT * source,BYTE ** buffer,INT32 * size)3713 UINT16 TPMA_PERMANENT_Marshal(TPMA_PERMANENT* source,
3714 BYTE** buffer,
3715 INT32* size) {
3716 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3717 }
3718
TPMA_PERMANENT_Unmarshal(TPMA_PERMANENT * target,BYTE ** buffer,INT32 * size)3719 TPM_RC TPMA_PERMANENT_Unmarshal(TPMA_PERMANENT* target,
3720 BYTE** buffer,
3721 INT32* size) {
3722 TPM_RC result;
3723 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3724 if (result != TPM_RC_SUCCESS) {
3725 return result;
3726 }
3727 if (target->reserved3_7 != 0) {
3728 return TPM_RC_RESERVED_BITS;
3729 }
3730 if (target->reserved11_31 != 0) {
3731 return TPM_RC_RESERVED_BITS;
3732 }
3733 return TPM_RC_SUCCESS;
3734 }
3735
TPMA_SESSION_Marshal(TPMA_SESSION * source,BYTE ** buffer,INT32 * size)3736 UINT16 TPMA_SESSION_Marshal(TPMA_SESSION* source, BYTE** buffer, INT32* size) {
3737 return uint8_t_Marshal((uint8_t*)source, buffer, size);
3738 }
3739
TPMA_SESSION_Unmarshal(TPMA_SESSION * target,BYTE ** buffer,INT32 * size)3740 TPM_RC TPMA_SESSION_Unmarshal(TPMA_SESSION* target,
3741 BYTE** buffer,
3742 INT32* size) {
3743 TPM_RC result;
3744 result = uint8_t_Unmarshal((uint8_t*)target, buffer, size);
3745 if (result != TPM_RC_SUCCESS) {
3746 return result;
3747 }
3748 if (target->reserved3_4 != 0) {
3749 return TPM_RC_RESERVED_BITS;
3750 }
3751 return TPM_RC_SUCCESS;
3752 }
3753
TPMA_STARTUP_CLEAR_Marshal(TPMA_STARTUP_CLEAR * source,BYTE ** buffer,INT32 * size)3754 UINT16 TPMA_STARTUP_CLEAR_Marshal(TPMA_STARTUP_CLEAR* source,
3755 BYTE** buffer,
3756 INT32* size) {
3757 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3758 }
3759
TPMA_STARTUP_CLEAR_Unmarshal(TPMA_STARTUP_CLEAR * target,BYTE ** buffer,INT32 * size)3760 TPM_RC TPMA_STARTUP_CLEAR_Unmarshal(TPMA_STARTUP_CLEAR* target,
3761 BYTE** buffer,
3762 INT32* size) {
3763 TPM_RC result;
3764 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3765 if (result != TPM_RC_SUCCESS) {
3766 return result;
3767 }
3768 if (target->reserved4_30 != 0) {
3769 return TPM_RC_RESERVED_BITS;
3770 }
3771 return TPM_RC_SUCCESS;
3772 }
3773
TPMI_ALG_ASYM_Marshal(TPMI_ALG_ASYM * source,BYTE ** buffer,INT32 * size)3774 UINT16 TPMI_ALG_ASYM_Marshal(TPMI_ALG_ASYM* source,
3775 BYTE** buffer,
3776 INT32* size) {
3777 return uint16_t_Marshal(source, buffer, size);
3778 }
3779
TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3780 TPM_RC TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM* target,
3781 BYTE** buffer,
3782 INT32* size,
3783 BOOL allow_conditional_value) {
3784 TPM_RC result;
3785 BOOL has_valid_value = FALSE;
3786 result = uint16_t_Unmarshal(target, buffer, size);
3787 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3788 return result;
3789 }
3790 if (*target == TPM_ALG_NULL) {
3791 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_ASYMMETRIC;
3792 }
3793 switch (*target) {
3794 #ifdef TPM_ALG_RSA
3795 case TPM_ALG_RSA:
3796 #endif
3797 #ifdef TPM_ALG_ECC
3798 case TPM_ALG_ECC:
3799 #endif
3800 has_valid_value = TRUE;
3801 break;
3802 }
3803 if (!has_valid_value) {
3804 return TPM_RC_ASYMMETRIC;
3805 }
3806 return TPM_RC_SUCCESS;
3807 }
3808
TPMI_ALG_RSA_DECRYPT_Marshal(TPMI_ALG_RSA_DECRYPT * source,BYTE ** buffer,INT32 * size)3809 UINT16 TPMI_ALG_RSA_DECRYPT_Marshal(TPMI_ALG_RSA_DECRYPT* source,
3810 BYTE** buffer,
3811 INT32* size) {
3812 return uint16_t_Marshal(source, buffer, size);
3813 }
3814
TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3815 TPM_RC TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT* target,
3816 BYTE** buffer,
3817 INT32* size,
3818 BOOL allow_conditional_value) {
3819 TPM_RC result;
3820 BOOL has_valid_value = FALSE;
3821 result = uint16_t_Unmarshal(target, buffer, size);
3822 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3823 return result;
3824 }
3825 if (*target == TPM_ALG_NULL) {
3826 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
3827 }
3828 switch (*target) {
3829 #ifdef TPM_ALG_RSAES
3830 case TPM_ALG_RSAES:
3831 #endif
3832 #ifdef TPM_ALG_OAEP
3833 case TPM_ALG_OAEP:
3834 #endif
3835 has_valid_value = TRUE;
3836 break;
3837 }
3838 if (!has_valid_value) {
3839 return TPM_RC_VALUE;
3840 }
3841 return TPM_RC_SUCCESS;
3842 }
3843
TPMI_ALG_SIG_SCHEME_Marshal(TPMI_ALG_SIG_SCHEME * source,BYTE ** buffer,INT32 * size)3844 UINT16 TPMI_ALG_SIG_SCHEME_Marshal(TPMI_ALG_SIG_SCHEME* source,
3845 BYTE** buffer,
3846 INT32* size) {
3847 return uint16_t_Marshal(source, buffer, size);
3848 }
3849
TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3850 TPM_RC TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME* target,
3851 BYTE** buffer,
3852 INT32* size,
3853 BOOL allow_conditional_value) {
3854 TPM_RC result;
3855 BOOL has_valid_value = FALSE;
3856 result = uint16_t_Unmarshal(target, buffer, size);
3857 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3858 return result;
3859 }
3860 if (*target == TPM_ALG_NULL) {
3861 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SCHEME;
3862 }
3863 switch (*target) {
3864 #ifdef TPM_ALG_RSASSA
3865 case TPM_ALG_RSASSA:
3866 #endif
3867 #ifdef TPM_ALG_RSAPSS
3868 case TPM_ALG_RSAPSS:
3869 #endif
3870 #ifdef TPM_ALG_ECDSA
3871 case TPM_ALG_ECDSA:
3872 #endif
3873 #ifdef TPM_ALG_ECDAA
3874 case TPM_ALG_ECDAA:
3875 #endif
3876 #ifdef TPM_ALG_SM2
3877 case TPM_ALG_SM2:
3878 #endif
3879 #ifdef TPM_ALG_ECSCHNORR
3880 case TPM_ALG_ECSCHNORR:
3881 #endif
3882 #ifdef TPM_ALG_HMAC
3883 case TPM_ALG_HMAC:
3884 #endif
3885 has_valid_value = TRUE;
3886 break;
3887 }
3888 if (!has_valid_value) {
3889 return TPM_RC_SCHEME;
3890 }
3891 return TPM_RC_SUCCESS;
3892 }
3893
TPMI_ALG_SYM_Marshal(TPMI_ALG_SYM * source,BYTE ** buffer,INT32 * size)3894 UINT16 TPMI_ALG_SYM_Marshal(TPMI_ALG_SYM* source, BYTE** buffer, INT32* size) {
3895 return uint16_t_Marshal(source, buffer, size);
3896 }
3897
TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3898 TPM_RC TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM* target,
3899 BYTE** buffer,
3900 INT32* size,
3901 BOOL allow_conditional_value) {
3902 TPM_RC result;
3903 BOOL has_valid_value = FALSE;
3904 result = uint16_t_Unmarshal(target, buffer, size);
3905 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3906 return result;
3907 }
3908 if (*target == TPM_ALG_NULL) {
3909 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SYMMETRIC;
3910 }
3911 switch (*target) {
3912 #ifdef TPM_ALG_AES
3913 case TPM_ALG_AES:
3914 #endif
3915 #ifdef TPM_ALG_SM4
3916 case TPM_ALG_SM4:
3917 #endif
3918 #ifdef TPM_ALG_CAMELLIA
3919 case TPM_ALG_CAMELLIA:
3920 #endif
3921 #ifdef TPM_ALG_XOR
3922 case TPM_ALG_XOR:
3923 #endif
3924 has_valid_value = TRUE;
3925 break;
3926 }
3927 if (!has_valid_value) {
3928 return TPM_RC_SYMMETRIC;
3929 }
3930 return TPM_RC_SUCCESS;
3931 }
3932
TPMI_DH_CONTEXT_Marshal(TPMI_DH_CONTEXT * source,BYTE ** buffer,INT32 * size)3933 UINT16 TPMI_DH_CONTEXT_Marshal(TPMI_DH_CONTEXT* source,
3934 BYTE** buffer,
3935 INT32* size) {
3936 return uint32_t_Marshal(source, buffer, size);
3937 }
3938
TPMI_DH_CONTEXT_Unmarshal(TPMI_DH_CONTEXT * target,BYTE ** buffer,INT32 * size)3939 TPM_RC TPMI_DH_CONTEXT_Unmarshal(TPMI_DH_CONTEXT* target,
3940 BYTE** buffer,
3941 INT32* size) {
3942 TPM_RC result;
3943 BOOL has_valid_value = FALSE;
3944 result = uint32_t_Unmarshal(target, buffer, size);
3945 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3946 return result;
3947 }
3948 if ((*target >= HMAC_SESSION_FIRST) && (*target <= HMAC_SESSION_LAST)) {
3949 has_valid_value = TRUE;
3950 }
3951 if ((*target >= POLICY_SESSION_FIRST) && (*target <= POLICY_SESSION_LAST)) {
3952 has_valid_value = TRUE;
3953 }
3954 if ((*target >= TRANSIENT_FIRST) && (*target <= TRANSIENT_LAST)) {
3955 has_valid_value = TRUE;
3956 }
3957 if (!has_valid_value) {
3958 return TPM_RC_VALUE;
3959 }
3960 return TPM_RC_SUCCESS;
3961 }
3962
TPMI_DH_ENTITY_Marshal(TPMI_DH_ENTITY * source,BYTE ** buffer,INT32 * size)3963 UINT16 TPMI_DH_ENTITY_Marshal(TPMI_DH_ENTITY* source,
3964 BYTE** buffer,
3965 INT32* size) {
3966 return uint32_t_Marshal(source, buffer, size);
3967 }
3968
TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3969 TPM_RC TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY* target,
3970 BYTE** buffer,
3971 INT32* size,
3972 BOOL allow_conditional_value) {
3973 TPM_RC result;
3974 BOOL has_valid_value = FALSE;
3975 result = uint32_t_Unmarshal(target, buffer, size);
3976 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3977 return result;
3978 }
3979 if (*target == TPM_RH_NULL) {
3980 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
3981 }
3982 switch (*target) {
3983 case TPM_RH_OWNER:
3984 case TPM_RH_ENDORSEMENT:
3985 case TPM_RH_PLATFORM:
3986 case TPM_RH_LOCKOUT:
3987 has_valid_value = TRUE;
3988 break;
3989 }
3990 if ((*target >= TRANSIENT_FIRST) && (*target <= TRANSIENT_LAST)) {
3991 has_valid_value = TRUE;
3992 }
3993 if ((*target >= PERSISTENT_FIRST) && (*target <= PERSISTENT_LAST)) {
3994 has_valid_value = TRUE;
3995 }
3996 if ((*target >= NV_INDEX_FIRST) && (*target <= NV_INDEX_LAST)) {
3997 has_valid_value = TRUE;
3998 }
3999 if ((*target >= PCR_FIRST) && (*target <= PCR_LAST)) {
4000 has_valid_value = TRUE;
4001 }
4002 if ((*target >= TPM_RH_AUTH_00) && (*target <= TPM_RH_AUTH_FF)) {
4003 has_valid_value = TRUE;
4004 }
4005 if (!has_valid_value) {
4006 return TPM_RC_VALUE;
4007 }
4008 return TPM_RC_SUCCESS;
4009 }
4010
TPMI_DH_OBJECT_Marshal(TPMI_DH_OBJECT * source,BYTE ** buffer,INT32 * size)4011 UINT16 TPMI_DH_OBJECT_Marshal(TPMI_DH_OBJECT* source,
4012 BYTE** buffer,
4013 INT32* size) {
4014 return uint32_t_Marshal(source, buffer, size);
4015 }
4016
TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4017 TPM_RC TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT* target,
4018 BYTE** buffer,
4019 INT32* size,
4020 BOOL allow_conditional_value) {
4021 TPM_RC result;
4022 BOOL has_valid_value = FALSE;
4023 result = uint32_t_Unmarshal(target, buffer, size);
4024 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4025 return result;
4026 }
4027 if (*target == TPM_RH_NULL) {
4028 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4029 }
4030 if ((*target >= TRANSIENT_FIRST) && (*target <= TRANSIENT_LAST)) {
4031 has_valid_value = TRUE;
4032 }
4033 if ((*target >= PERSISTENT_FIRST) && (*target <= PERSISTENT_LAST)) {
4034 has_valid_value = TRUE;
4035 }
4036 if (!has_valid_value) {
4037 return TPM_RC_VALUE;
4038 }
4039 return TPM_RC_SUCCESS;
4040 }
4041
TPMI_DH_PCR_Marshal(TPMI_DH_PCR * source,BYTE ** buffer,INT32 * size)4042 UINT16 TPMI_DH_PCR_Marshal(TPMI_DH_PCR* source, BYTE** buffer, INT32* size) {
4043 return uint32_t_Marshal(source, buffer, size);
4044 }
4045
TPMI_DH_PCR_Unmarshal(TPMI_DH_PCR * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4046 TPM_RC TPMI_DH_PCR_Unmarshal(TPMI_DH_PCR* target,
4047 BYTE** buffer,
4048 INT32* size,
4049 BOOL allow_conditional_value) {
4050 TPM_RC result;
4051 BOOL has_valid_value = FALSE;
4052 result = uint32_t_Unmarshal(target, buffer, size);
4053 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4054 return result;
4055 }
4056 if (*target == TPM_RH_NULL) {
4057 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4058 }
4059 if ((*target >= PCR_FIRST) && (*target <= PCR_LAST)) {
4060 has_valid_value = TRUE;
4061 }
4062 if (!has_valid_value) {
4063 return TPM_RC_VALUE;
4064 }
4065 return TPM_RC_SUCCESS;
4066 }
4067
TPMI_DH_PERSISTENT_Marshal(TPMI_DH_PERSISTENT * source,BYTE ** buffer,INT32 * size)4068 UINT16 TPMI_DH_PERSISTENT_Marshal(TPMI_DH_PERSISTENT* source,
4069 BYTE** buffer,
4070 INT32* size) {
4071 return uint32_t_Marshal(source, buffer, size);
4072 }
4073
TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT * target,BYTE ** buffer,INT32 * size)4074 TPM_RC TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT* target,
4075 BYTE** buffer,
4076 INT32* size) {
4077 TPM_RC result;
4078 BOOL has_valid_value = FALSE;
4079 result = uint32_t_Unmarshal(target, buffer, size);
4080 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4081 return result;
4082 }
4083 if ((*target >= PERSISTENT_FIRST) && (*target <= PERSISTENT_LAST)) {
4084 has_valid_value = TRUE;
4085 }
4086 if (!has_valid_value) {
4087 return TPM_RC_VALUE;
4088 }
4089 return TPM_RC_SUCCESS;
4090 }
4091
TPMI_ECC_KEY_EXCHANGE_Marshal(TPMI_ECC_KEY_EXCHANGE * source,BYTE ** buffer,INT32 * size)4092 UINT16 TPMI_ECC_KEY_EXCHANGE_Marshal(TPMI_ECC_KEY_EXCHANGE* source,
4093 BYTE** buffer,
4094 INT32* size) {
4095 return uint16_t_Marshal(source, buffer, size);
4096 }
4097
TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4098 TPM_RC TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE* target,
4099 BYTE** buffer,
4100 INT32* size,
4101 BOOL allow_conditional_value) {
4102 TPM_RC result;
4103 BOOL has_valid_value = FALSE;
4104 result = uint16_t_Unmarshal(target, buffer, size);
4105 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4106 return result;
4107 }
4108 if (*target == TPM_ALG_NULL) {
4109 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SCHEME;
4110 }
4111 switch (*target) {
4112 #ifdef TPM_ALG_ECDH
4113 case TPM_ALG_ECDH:
4114 #endif
4115 #ifdef TPM_ALG_ECMQV
4116 case TPM_ALG_ECMQV:
4117 #endif
4118 #ifdef TPM_ALG_SM2
4119 case TPM_ALG_SM2:
4120 #endif
4121 has_valid_value = TRUE;
4122 break;
4123 }
4124 if (!has_valid_value) {
4125 return TPM_RC_SCHEME;
4126 }
4127 return TPM_RC_SUCCESS;
4128 }
4129
TPMI_RH_CLEAR_Marshal(TPMI_RH_CLEAR * source,BYTE ** buffer,INT32 * size)4130 UINT16 TPMI_RH_CLEAR_Marshal(TPMI_RH_CLEAR* source,
4131 BYTE** buffer,
4132 INT32* size) {
4133 return uint32_t_Marshal(source, buffer, size);
4134 }
4135
TPMI_RH_CLEAR_Unmarshal(TPMI_RH_CLEAR * target,BYTE ** buffer,INT32 * size)4136 TPM_RC TPMI_RH_CLEAR_Unmarshal(TPMI_RH_CLEAR* target,
4137 BYTE** buffer,
4138 INT32* size) {
4139 TPM_RC result;
4140 BOOL has_valid_value = FALSE;
4141 result = uint32_t_Unmarshal(target, buffer, size);
4142 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4143 return result;
4144 }
4145 switch (*target) {
4146 case TPM_RH_LOCKOUT:
4147 case TPM_RH_PLATFORM:
4148 has_valid_value = TRUE;
4149 break;
4150 }
4151 if (!has_valid_value) {
4152 return TPM_RC_VALUE;
4153 }
4154 return TPM_RC_SUCCESS;
4155 }
4156
TPMI_RH_ENABLES_Marshal(TPMI_RH_ENABLES * source,BYTE ** buffer,INT32 * size)4157 UINT16 TPMI_RH_ENABLES_Marshal(TPMI_RH_ENABLES* source,
4158 BYTE** buffer,
4159 INT32* size) {
4160 return uint32_t_Marshal(source, buffer, size);
4161 }
4162
TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4163 TPM_RC TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES* target,
4164 BYTE** buffer,
4165 INT32* size,
4166 BOOL allow_conditional_value) {
4167 TPM_RC result;
4168 BOOL has_valid_value = FALSE;
4169 result = uint32_t_Unmarshal(target, buffer, size);
4170 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4171 return result;
4172 }
4173 if (*target == TPM_RH_NULL) {
4174 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4175 }
4176 switch (*target) {
4177 case TPM_RH_OWNER:
4178 case TPM_RH_PLATFORM:
4179 case TPM_RH_ENDORSEMENT:
4180 case TPM_RH_PLATFORM_NV:
4181 has_valid_value = TRUE;
4182 break;
4183 }
4184 if (!has_valid_value) {
4185 return TPM_RC_VALUE;
4186 }
4187 return TPM_RC_SUCCESS;
4188 }
4189
TPMI_RH_ENDORSEMENT_Marshal(TPMI_RH_ENDORSEMENT * source,BYTE ** buffer,INT32 * size)4190 UINT16 TPMI_RH_ENDORSEMENT_Marshal(TPMI_RH_ENDORSEMENT* source,
4191 BYTE** buffer,
4192 INT32* size) {
4193 return uint32_t_Marshal(source, buffer, size);
4194 }
4195
TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4196 TPM_RC TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT* target,
4197 BYTE** buffer,
4198 INT32* size,
4199 BOOL allow_conditional_value) {
4200 TPM_RC result;
4201 BOOL has_valid_value = FALSE;
4202 result = uint32_t_Unmarshal(target, buffer, size);
4203 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4204 return result;
4205 }
4206 if (*target == TPM_RH_NULL) {
4207 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4208 }
4209 switch (*target) {
4210 case TPM_RH_ENDORSEMENT:
4211 has_valid_value = TRUE;
4212 break;
4213 }
4214 if (!has_valid_value) {
4215 return TPM_RC_VALUE;
4216 }
4217 return TPM_RC_SUCCESS;
4218 }
4219
TPMI_RH_HIERARCHY_Marshal(TPMI_RH_HIERARCHY * source,BYTE ** buffer,INT32 * size)4220 UINT16 TPMI_RH_HIERARCHY_Marshal(TPMI_RH_HIERARCHY* source,
4221 BYTE** buffer,
4222 INT32* size) {
4223 return uint32_t_Marshal(source, buffer, size);
4224 }
4225
TPMI_RH_HIERARCHY_Unmarshal(TPMI_RH_HIERARCHY * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4226 TPM_RC TPMI_RH_HIERARCHY_Unmarshal(TPMI_RH_HIERARCHY* target,
4227 BYTE** buffer,
4228 INT32* size,
4229 BOOL allow_conditional_value) {
4230 TPM_RC result;
4231 BOOL has_valid_value = FALSE;
4232 result = uint32_t_Unmarshal(target, buffer, size);
4233 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4234 return result;
4235 }
4236 if (*target == TPM_RH_NULL) {
4237 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4238 }
4239 switch (*target) {
4240 case TPM_RH_OWNER:
4241 case TPM_RH_PLATFORM:
4242 case TPM_RH_ENDORSEMENT:
4243 has_valid_value = TRUE;
4244 break;
4245 }
4246 if (!has_valid_value) {
4247 return TPM_RC_VALUE;
4248 }
4249 return TPM_RC_SUCCESS;
4250 }
4251
TPMI_RH_HIERARCHY_AUTH_Marshal(TPMI_RH_HIERARCHY_AUTH * source,BYTE ** buffer,INT32 * size)4252 UINT16 TPMI_RH_HIERARCHY_AUTH_Marshal(TPMI_RH_HIERARCHY_AUTH* source,
4253 BYTE** buffer,
4254 INT32* size) {
4255 return uint32_t_Marshal(source, buffer, size);
4256 }
4257
TPMI_RH_HIERARCHY_AUTH_Unmarshal(TPMI_RH_HIERARCHY_AUTH * target,BYTE ** buffer,INT32 * size)4258 TPM_RC TPMI_RH_HIERARCHY_AUTH_Unmarshal(TPMI_RH_HIERARCHY_AUTH* target,
4259 BYTE** buffer,
4260 INT32* size) {
4261 TPM_RC result;
4262 BOOL has_valid_value = FALSE;
4263 result = uint32_t_Unmarshal(target, buffer, size);
4264 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4265 return result;
4266 }
4267 switch (*target) {
4268 case TPM_RH_OWNER:
4269 case TPM_RH_PLATFORM:
4270 case TPM_RH_ENDORSEMENT:
4271 case TPM_RH_LOCKOUT:
4272 has_valid_value = TRUE;
4273 break;
4274 }
4275 if (!has_valid_value) {
4276 return TPM_RC_VALUE;
4277 }
4278 return TPM_RC_SUCCESS;
4279 }
4280
TPMI_RH_LOCKOUT_Marshal(TPMI_RH_LOCKOUT * source,BYTE ** buffer,INT32 * size)4281 UINT16 TPMI_RH_LOCKOUT_Marshal(TPMI_RH_LOCKOUT* source,
4282 BYTE** buffer,
4283 INT32* size) {
4284 return uint32_t_Marshal(source, buffer, size);
4285 }
4286
TPMI_RH_LOCKOUT_Unmarshal(TPMI_RH_LOCKOUT * target,BYTE ** buffer,INT32 * size)4287 TPM_RC TPMI_RH_LOCKOUT_Unmarshal(TPMI_RH_LOCKOUT* target,
4288 BYTE** buffer,
4289 INT32* size) {
4290 TPM_RC result;
4291 BOOL has_valid_value = FALSE;
4292 result = uint32_t_Unmarshal(target, buffer, size);
4293 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4294 return result;
4295 }
4296 switch (*target) {
4297 case TPM_RH_LOCKOUT:
4298 has_valid_value = TRUE;
4299 break;
4300 }
4301 if (!has_valid_value) {
4302 return TPM_RC_VALUE;
4303 }
4304 return TPM_RC_SUCCESS;
4305 }
4306
TPMI_RH_NV_AUTH_Marshal(TPMI_RH_NV_AUTH * source,BYTE ** buffer,INT32 * size)4307 UINT16 TPMI_RH_NV_AUTH_Marshal(TPMI_RH_NV_AUTH* source,
4308 BYTE** buffer,
4309 INT32* size) {
4310 return uint32_t_Marshal(source, buffer, size);
4311 }
4312
TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH * target,BYTE ** buffer,INT32 * size)4313 TPM_RC TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH* target,
4314 BYTE** buffer,
4315 INT32* size) {
4316 TPM_RC result;
4317 BOOL has_valid_value = FALSE;
4318 result = uint32_t_Unmarshal(target, buffer, size);
4319 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4320 return result;
4321 }
4322 switch (*target) {
4323 case TPM_RH_PLATFORM:
4324 case TPM_RH_OWNER:
4325 has_valid_value = TRUE;
4326 break;
4327 }
4328 if ((*target >= NV_INDEX_FIRST) && (*target <= NV_INDEX_LAST)) {
4329 has_valid_value = TRUE;
4330 }
4331 if (!has_valid_value) {
4332 return TPM_RC_VALUE;
4333 }
4334 return TPM_RC_SUCCESS;
4335 }
4336
TPMI_RH_OWNER_Marshal(TPMI_RH_OWNER * source,BYTE ** buffer,INT32 * size)4337 UINT16 TPMI_RH_OWNER_Marshal(TPMI_RH_OWNER* source,
4338 BYTE** buffer,
4339 INT32* size) {
4340 return uint32_t_Marshal(source, buffer, size);
4341 }
4342
TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4343 TPM_RC TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER* target,
4344 BYTE** buffer,
4345 INT32* size,
4346 BOOL allow_conditional_value) {
4347 TPM_RC result;
4348 BOOL has_valid_value = FALSE;
4349 result = uint32_t_Unmarshal(target, buffer, size);
4350 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4351 return result;
4352 }
4353 if (*target == TPM_RH_NULL) {
4354 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4355 }
4356 switch (*target) {
4357 case TPM_RH_OWNER:
4358 has_valid_value = TRUE;
4359 break;
4360 }
4361 if (!has_valid_value) {
4362 return TPM_RC_VALUE;
4363 }
4364 return TPM_RC_SUCCESS;
4365 }
4366
TPMI_RH_PLATFORM_Marshal(TPMI_RH_PLATFORM * source,BYTE ** buffer,INT32 * size)4367 UINT16 TPMI_RH_PLATFORM_Marshal(TPMI_RH_PLATFORM* source,
4368 BYTE** buffer,
4369 INT32* size) {
4370 return uint32_t_Marshal(source, buffer, size);
4371 }
4372
TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM * target,BYTE ** buffer,INT32 * size)4373 TPM_RC TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM* target,
4374 BYTE** buffer,
4375 INT32* size) {
4376 TPM_RC result;
4377 BOOL has_valid_value = FALSE;
4378 result = uint32_t_Unmarshal(target, buffer, size);
4379 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4380 return result;
4381 }
4382 switch (*target) {
4383 case TPM_RH_PLATFORM:
4384 has_valid_value = TRUE;
4385 break;
4386 }
4387 if (!has_valid_value) {
4388 return TPM_RC_VALUE;
4389 }
4390 return TPM_RC_SUCCESS;
4391 }
4392
TPMI_RH_PROVISION_Marshal(TPMI_RH_PROVISION * source,BYTE ** buffer,INT32 * size)4393 UINT16 TPMI_RH_PROVISION_Marshal(TPMI_RH_PROVISION* source,
4394 BYTE** buffer,
4395 INT32* size) {
4396 return uint32_t_Marshal(source, buffer, size);
4397 }
4398
TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION * target,BYTE ** buffer,INT32 * size)4399 TPM_RC TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION* target,
4400 BYTE** buffer,
4401 INT32* size) {
4402 TPM_RC result;
4403 BOOL has_valid_value = FALSE;
4404 result = uint32_t_Unmarshal(target, buffer, size);
4405 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4406 return result;
4407 }
4408 switch (*target) {
4409 case TPM_RH_OWNER:
4410 case TPM_RH_PLATFORM:
4411 has_valid_value = TRUE;
4412 break;
4413 }
4414 if (!has_valid_value) {
4415 return TPM_RC_VALUE;
4416 }
4417 return TPM_RC_SUCCESS;
4418 }
4419
TPMI_SH_AUTH_SESSION_Marshal(TPMI_SH_AUTH_SESSION * source,BYTE ** buffer,INT32 * size)4420 UINT16 TPMI_SH_AUTH_SESSION_Marshal(TPMI_SH_AUTH_SESSION* source,
4421 BYTE** buffer,
4422 INT32* size) {
4423 return uint32_t_Marshal(source, buffer, size);
4424 }
4425
TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4426 TPM_RC TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION* target,
4427 BYTE** buffer,
4428 INT32* size,
4429 BOOL allow_conditional_value) {
4430 TPM_RC result;
4431 BOOL has_valid_value = FALSE;
4432 result = uint32_t_Unmarshal(target, buffer, size);
4433 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4434 return result;
4435 }
4436 if (*target == TPM_RS_PW) {
4437 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4438 }
4439 if ((*target >= HMAC_SESSION_FIRST) && (*target <= HMAC_SESSION_LAST)) {
4440 has_valid_value = TRUE;
4441 }
4442 if ((*target >= POLICY_SESSION_FIRST) && (*target <= POLICY_SESSION_LAST)) {
4443 has_valid_value = TRUE;
4444 }
4445 if (!has_valid_value) {
4446 return TPM_RC_VALUE;
4447 }
4448 return TPM_RC_SUCCESS;
4449 }
4450
TPMI_SH_HMAC_Marshal(TPMI_SH_HMAC * source,BYTE ** buffer,INT32 * size)4451 UINT16 TPMI_SH_HMAC_Marshal(TPMI_SH_HMAC* source, BYTE** buffer, INT32* size) {
4452 return uint32_t_Marshal(source, buffer, size);
4453 }
4454
TPMI_SH_HMAC_Unmarshal(TPMI_SH_HMAC * target,BYTE ** buffer,INT32 * size)4455 TPM_RC TPMI_SH_HMAC_Unmarshal(TPMI_SH_HMAC* target,
4456 BYTE** buffer,
4457 INT32* size) {
4458 TPM_RC result;
4459 BOOL has_valid_value = FALSE;
4460 result = uint32_t_Unmarshal(target, buffer, size);
4461 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4462 return result;
4463 }
4464 if ((*target >= HMAC_SESSION_FIRST) && (*target <= HMAC_SESSION_LAST)) {
4465 has_valid_value = TRUE;
4466 }
4467 if (!has_valid_value) {
4468 return TPM_RC_VALUE;
4469 }
4470 return TPM_RC_SUCCESS;
4471 }
4472
TPMI_SH_POLICY_Marshal(TPMI_SH_POLICY * source,BYTE ** buffer,INT32 * size)4473 UINT16 TPMI_SH_POLICY_Marshal(TPMI_SH_POLICY* source,
4474 BYTE** buffer,
4475 INT32* size) {
4476 return uint32_t_Marshal(source, buffer, size);
4477 }
4478
TPMI_SH_POLICY_Unmarshal(TPMI_SH_POLICY * target,BYTE ** buffer,INT32 * size)4479 TPM_RC TPMI_SH_POLICY_Unmarshal(TPMI_SH_POLICY* target,
4480 BYTE** buffer,
4481 INT32* size) {
4482 TPM_RC result;
4483 BOOL has_valid_value = FALSE;
4484 result = uint32_t_Unmarshal(target, buffer, size);
4485 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4486 return result;
4487 }
4488 if ((*target >= POLICY_SESSION_FIRST) && (*target <= POLICY_SESSION_LAST)) {
4489 has_valid_value = TRUE;
4490 }
4491 if (!has_valid_value) {
4492 return TPM_RC_VALUE;
4493 }
4494 return TPM_RC_SUCCESS;
4495 }
4496
TPMI_ST_ATTEST_Marshal(TPMI_ST_ATTEST * source,BYTE ** buffer,INT32 * size)4497 UINT16 TPMI_ST_ATTEST_Marshal(TPMI_ST_ATTEST* source,
4498 BYTE** buffer,
4499 INT32* size) {
4500 return uint16_t_Marshal(source, buffer, size);
4501 }
4502
TPMI_ST_ATTEST_Unmarshal(TPMI_ST_ATTEST * target,BYTE ** buffer,INT32 * size)4503 TPM_RC TPMI_ST_ATTEST_Unmarshal(TPMI_ST_ATTEST* target,
4504 BYTE** buffer,
4505 INT32* size) {
4506 TPM_RC result;
4507 BOOL has_valid_value = FALSE;
4508 result = uint16_t_Unmarshal(target, buffer, size);
4509 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4510 return result;
4511 }
4512 switch (*target) {
4513 case TPM_ST_ATTEST_CERTIFY:
4514 case TPM_ST_ATTEST_QUOTE:
4515 case TPM_ST_ATTEST_SESSION_AUDIT:
4516 case TPM_ST_ATTEST_COMMAND_AUDIT:
4517 case TPM_ST_ATTEST_TIME:
4518 case TPM_ST_ATTEST_CREATION:
4519 case TPM_ST_ATTEST_NV:
4520 has_valid_value = TRUE;
4521 break;
4522 }
4523 if (!has_valid_value) {
4524 return TPM_RC_VALUE;
4525 }
4526 return TPM_RC_SUCCESS;
4527 }
4528
TPMI_ST_COMMAND_TAG_Marshal(TPMI_ST_COMMAND_TAG * source,BYTE ** buffer,INT32 * size)4529 UINT16 TPMI_ST_COMMAND_TAG_Marshal(TPMI_ST_COMMAND_TAG* source,
4530 BYTE** buffer,
4531 INT32* size) {
4532 return uint16_t_Marshal(source, buffer, size);
4533 }
4534
TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG * target,BYTE ** buffer,INT32 * size)4535 TPM_RC TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG* target,
4536 BYTE** buffer,
4537 INT32* size) {
4538 TPM_RC result;
4539 BOOL has_valid_value = FALSE;
4540 result = uint16_t_Unmarshal(target, buffer, size);
4541 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4542 return result;
4543 }
4544 switch (*target) {
4545 case TPM_ST_NO_SESSIONS:
4546 case TPM_ST_SESSIONS:
4547 has_valid_value = TRUE;
4548 break;
4549 }
4550 if (!has_valid_value) {
4551 return TPM_RC_BAD_TAG;
4552 }
4553 return TPM_RC_SUCCESS;
4554 }
4555
TPMI_YES_NO_Marshal(TPMI_YES_NO * source,BYTE ** buffer,INT32 * size)4556 UINT16 TPMI_YES_NO_Marshal(TPMI_YES_NO* source, BYTE** buffer, INT32* size) {
4557 return uint8_t_Marshal(source, buffer, size);
4558 }
4559
TPMI_YES_NO_Unmarshal(TPMI_YES_NO * target,BYTE ** buffer,INT32 * size)4560 TPM_RC TPMI_YES_NO_Unmarshal(TPMI_YES_NO* target, BYTE** buffer, INT32* size) {
4561 TPM_RC result;
4562 BOOL has_valid_value = FALSE;
4563 result = uint8_t_Unmarshal(target, buffer, size);
4564 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4565 return result;
4566 }
4567 switch (*target) {
4568 case NO:
4569 case YES:
4570 has_valid_value = TRUE;
4571 break;
4572 }
4573 if (!has_valid_value) {
4574 return TPM_RC_VALUE;
4575 }
4576 return TPM_RC_SUCCESS;
4577 }
4578
TPML_ALG_Marshal(TPML_ALG * source,BYTE ** buffer,INT32 * size)4579 UINT16 TPML_ALG_Marshal(TPML_ALG* source, BYTE** buffer, INT32* size) {
4580 UINT16 total_size = 0;
4581 INT32 i;
4582 total_size += UINT32_Marshal(&source->count, buffer, size);
4583 for (i = 0; i < source->count; ++i) {
4584 total_size += TPM_ALG_ID_Marshal(&source->algorithms[i], buffer, size);
4585 }
4586 return total_size;
4587 }
4588
TPML_ALG_Unmarshal(TPML_ALG * target,BYTE ** buffer,INT32 * size)4589 TPM_RC TPML_ALG_Unmarshal(TPML_ALG* target, BYTE** buffer, INT32* size) {
4590 TPM_RC result;
4591 INT32 i;
4592 result = UINT32_Unmarshal(&target->count, buffer, size);
4593 if (result != TPM_RC_SUCCESS) {
4594 return result;
4595 }
4596 if (target->count > MAX_ALG_LIST_SIZE) {
4597 return TPM_RC_SIZE;
4598 }
4599 for (i = 0; i < target->count; ++i) {
4600 result = TPM_ALG_ID_Unmarshal(&target->algorithms[i], buffer, size);
4601 if (result != TPM_RC_SUCCESS) {
4602 return result;
4603 }
4604 }
4605 return TPM_RC_SUCCESS;
4606 }
4607
TPMS_ALG_PROPERTY_Marshal(TPMS_ALG_PROPERTY * source,BYTE ** buffer,INT32 * size)4608 UINT16 TPMS_ALG_PROPERTY_Marshal(TPMS_ALG_PROPERTY* source,
4609 BYTE** buffer,
4610 INT32* size) {
4611 UINT16 total_size = 0;
4612 total_size += TPM_ALG_ID_Marshal(&source->alg, buffer, size);
4613 total_size += TPMA_ALGORITHM_Marshal(&source->algProperties, buffer, size);
4614 return total_size;
4615 }
4616
TPMS_ALG_PROPERTY_Unmarshal(TPMS_ALG_PROPERTY * target,BYTE ** buffer,INT32 * size)4617 TPM_RC TPMS_ALG_PROPERTY_Unmarshal(TPMS_ALG_PROPERTY* target,
4618 BYTE** buffer,
4619 INT32* size) {
4620 TPM_RC result;
4621 result = TPM_ALG_ID_Unmarshal(&target->alg, buffer, size);
4622 if (result != TPM_RC_SUCCESS) {
4623 return result;
4624 }
4625 result = TPMA_ALGORITHM_Unmarshal(&target->algProperties, buffer, size);
4626 if (result != TPM_RC_SUCCESS) {
4627 return result;
4628 }
4629 return TPM_RC_SUCCESS;
4630 }
4631
TPML_ALG_PROPERTY_Marshal(TPML_ALG_PROPERTY * source,BYTE ** buffer,INT32 * size)4632 UINT16 TPML_ALG_PROPERTY_Marshal(TPML_ALG_PROPERTY* source,
4633 BYTE** buffer,
4634 INT32* size) {
4635 UINT16 total_size = 0;
4636 INT32 i;
4637 total_size += UINT32_Marshal(&source->count, buffer, size);
4638 for (i = 0; i < source->count; ++i) {
4639 total_size +=
4640 TPMS_ALG_PROPERTY_Marshal(&source->algProperties[i], buffer, size);
4641 }
4642 return total_size;
4643 }
4644
TPML_ALG_PROPERTY_Unmarshal(TPML_ALG_PROPERTY * target,BYTE ** buffer,INT32 * size)4645 TPM_RC TPML_ALG_PROPERTY_Unmarshal(TPML_ALG_PROPERTY* target,
4646 BYTE** buffer,
4647 INT32* size) {
4648 TPM_RC result;
4649 INT32 i;
4650 result = UINT32_Unmarshal(&target->count, buffer, size);
4651 if (result != TPM_RC_SUCCESS) {
4652 return result;
4653 }
4654 if (target->count > MAX_CAP_ALGS) {
4655 return TPM_RC_SIZE;
4656 }
4657 for (i = 0; i < target->count; ++i) {
4658 result =
4659 TPMS_ALG_PROPERTY_Unmarshal(&target->algProperties[i], buffer, size);
4660 if (result != TPM_RC_SUCCESS) {
4661 return result;
4662 }
4663 }
4664 return TPM_RC_SUCCESS;
4665 }
4666
TPM_CC_Marshal(TPM_CC * source,BYTE ** buffer,INT32 * size)4667 UINT16 TPM_CC_Marshal(TPM_CC* source, BYTE** buffer, INT32* size) {
4668 return uint32_t_Marshal(source, buffer, size);
4669 }
4670
TPM_CC_Unmarshal(TPM_CC * target,BYTE ** buffer,INT32 * size)4671 TPM_RC TPM_CC_Unmarshal(TPM_CC* target, BYTE** buffer, INT32* size) {
4672 TPM_RC result;
4673 result = uint32_t_Unmarshal(target, buffer, size);
4674 if (result != TPM_RC_SUCCESS) {
4675 return result;
4676 }
4677 #ifdef TPM_CC_FIRST
4678 if (*target == TPM_CC_FIRST) {
4679 return TPM_RC_SUCCESS;
4680 }
4681 #endif
4682 #ifdef TPM_CC_PP_FIRST
4683 if (*target == TPM_CC_PP_FIRST) {
4684 return TPM_RC_SUCCESS;
4685 }
4686 #endif
4687 #ifdef TPM_CC_NV_UndefineSpaceSpecial
4688 if (*target == TPM_CC_NV_UndefineSpaceSpecial) {
4689 return TPM_RC_SUCCESS;
4690 }
4691 #endif
4692 #ifdef TPM_CC_EvictControl
4693 if (*target == TPM_CC_EvictControl) {
4694 return TPM_RC_SUCCESS;
4695 }
4696 #endif
4697 #ifdef TPM_CC_HierarchyControl
4698 if (*target == TPM_CC_HierarchyControl) {
4699 return TPM_RC_SUCCESS;
4700 }
4701 #endif
4702 #ifdef TPM_CC_NV_UndefineSpace
4703 if (*target == TPM_CC_NV_UndefineSpace) {
4704 return TPM_RC_SUCCESS;
4705 }
4706 #endif
4707 #ifdef TPM_CC_ChangeEPS
4708 if (*target == TPM_CC_ChangeEPS) {
4709 return TPM_RC_SUCCESS;
4710 }
4711 #endif
4712 #ifdef TPM_CC_ChangePPS
4713 if (*target == TPM_CC_ChangePPS) {
4714 return TPM_RC_SUCCESS;
4715 }
4716 #endif
4717 #ifdef TPM_CC_Clear
4718 if (*target == TPM_CC_Clear) {
4719 return TPM_RC_SUCCESS;
4720 }
4721 #endif
4722 #ifdef TPM_CC_ClearControl
4723 if (*target == TPM_CC_ClearControl) {
4724 return TPM_RC_SUCCESS;
4725 }
4726 #endif
4727 #ifdef TPM_CC_ClockSet
4728 if (*target == TPM_CC_ClockSet) {
4729 return TPM_RC_SUCCESS;
4730 }
4731 #endif
4732 #ifdef TPM_CC_HierarchyChangeAuth
4733 if (*target == TPM_CC_HierarchyChangeAuth) {
4734 return TPM_RC_SUCCESS;
4735 }
4736 #endif
4737 #ifdef TPM_CC_NV_DefineSpace
4738 if (*target == TPM_CC_NV_DefineSpace) {
4739 return TPM_RC_SUCCESS;
4740 }
4741 #endif
4742 #ifdef TPM_CC_PCR_Allocate
4743 if (*target == TPM_CC_PCR_Allocate) {
4744 return TPM_RC_SUCCESS;
4745 }
4746 #endif
4747 #ifdef TPM_CC_PCR_SetAuthPolicy
4748 if (*target == TPM_CC_PCR_SetAuthPolicy) {
4749 return TPM_RC_SUCCESS;
4750 }
4751 #endif
4752 #ifdef TPM_CC_PP_Commands
4753 if (*target == TPM_CC_PP_Commands) {
4754 return TPM_RC_SUCCESS;
4755 }
4756 #endif
4757 #ifdef TPM_CC_SetPrimaryPolicy
4758 if (*target == TPM_CC_SetPrimaryPolicy) {
4759 return TPM_RC_SUCCESS;
4760 }
4761 #endif
4762 #ifdef TPM_CC_FieldUpgradeStart
4763 if (*target == TPM_CC_FieldUpgradeStart) {
4764 return TPM_RC_SUCCESS;
4765 }
4766 #endif
4767 #ifdef TPM_CC_ClockRateAdjust
4768 if (*target == TPM_CC_ClockRateAdjust) {
4769 return TPM_RC_SUCCESS;
4770 }
4771 #endif
4772 #ifdef TPM_CC_CreatePrimary
4773 if (*target == TPM_CC_CreatePrimary) {
4774 return TPM_RC_SUCCESS;
4775 }
4776 #endif
4777 #ifdef TPM_CC_NV_GlobalWriteLock
4778 if (*target == TPM_CC_NV_GlobalWriteLock) {
4779 return TPM_RC_SUCCESS;
4780 }
4781 #endif
4782 #ifdef TPM_CC_PP_LAST
4783 if (*target == TPM_CC_PP_LAST) {
4784 return TPM_RC_SUCCESS;
4785 }
4786 #endif
4787 #ifdef TPM_CC_GetCommandAuditDigest
4788 if (*target == TPM_CC_GetCommandAuditDigest) {
4789 return TPM_RC_SUCCESS;
4790 }
4791 #endif
4792 #ifdef TPM_CC_NV_Increment
4793 if (*target == TPM_CC_NV_Increment) {
4794 return TPM_RC_SUCCESS;
4795 }
4796 #endif
4797 #ifdef TPM_CC_NV_SetBits
4798 if (*target == TPM_CC_NV_SetBits) {
4799 return TPM_RC_SUCCESS;
4800 }
4801 #endif
4802 #ifdef TPM_CC_NV_Extend
4803 if (*target == TPM_CC_NV_Extend) {
4804 return TPM_RC_SUCCESS;
4805 }
4806 #endif
4807 #ifdef TPM_CC_NV_Write
4808 if (*target == TPM_CC_NV_Write) {
4809 return TPM_RC_SUCCESS;
4810 }
4811 #endif
4812 #ifdef TPM_CC_NV_WriteLock
4813 if (*target == TPM_CC_NV_WriteLock) {
4814 return TPM_RC_SUCCESS;
4815 }
4816 #endif
4817 #ifdef TPM_CC_DictionaryAttackLockReset
4818 if (*target == TPM_CC_DictionaryAttackLockReset) {
4819 return TPM_RC_SUCCESS;
4820 }
4821 #endif
4822 #ifdef TPM_CC_DictionaryAttackParameters
4823 if (*target == TPM_CC_DictionaryAttackParameters) {
4824 return TPM_RC_SUCCESS;
4825 }
4826 #endif
4827 #ifdef TPM_CC_NV_ChangeAuth
4828 if (*target == TPM_CC_NV_ChangeAuth) {
4829 return TPM_RC_SUCCESS;
4830 }
4831 #endif
4832 #ifdef TPM_CC_PCR_Event
4833 if (*target == TPM_CC_PCR_Event) {
4834 return TPM_RC_SUCCESS;
4835 }
4836 #endif
4837 #ifdef TPM_CC_PCR_Reset
4838 if (*target == TPM_CC_PCR_Reset) {
4839 return TPM_RC_SUCCESS;
4840 }
4841 #endif
4842 #ifdef TPM_CC_SequenceComplete
4843 if (*target == TPM_CC_SequenceComplete) {
4844 return TPM_RC_SUCCESS;
4845 }
4846 #endif
4847 #ifdef TPM_CC_SetAlgorithmSet
4848 if (*target == TPM_CC_SetAlgorithmSet) {
4849 return TPM_RC_SUCCESS;
4850 }
4851 #endif
4852 #ifdef TPM_CC_SetCommandCodeAuditStatus
4853 if (*target == TPM_CC_SetCommandCodeAuditStatus) {
4854 return TPM_RC_SUCCESS;
4855 }
4856 #endif
4857 #ifdef TPM_CC_FieldUpgradeData
4858 if (*target == TPM_CC_FieldUpgradeData) {
4859 return TPM_RC_SUCCESS;
4860 }
4861 #endif
4862 #ifdef TPM_CC_IncrementalSelfTest
4863 if (*target == TPM_CC_IncrementalSelfTest) {
4864 return TPM_RC_SUCCESS;
4865 }
4866 #endif
4867 #ifdef TPM_CC_SelfTest
4868 if (*target == TPM_CC_SelfTest) {
4869 return TPM_RC_SUCCESS;
4870 }
4871 #endif
4872 #ifdef TPM_CC_Startup
4873 if (*target == TPM_CC_Startup) {
4874 return TPM_RC_SUCCESS;
4875 }
4876 #endif
4877 #ifdef TPM_CC_Shutdown
4878 if (*target == TPM_CC_Shutdown) {
4879 return TPM_RC_SUCCESS;
4880 }
4881 #endif
4882 #ifdef TPM_CC_StirRandom
4883 if (*target == TPM_CC_StirRandom) {
4884 return TPM_RC_SUCCESS;
4885 }
4886 #endif
4887 #ifdef TPM_CC_ActivateCredential
4888 if (*target == TPM_CC_ActivateCredential) {
4889 return TPM_RC_SUCCESS;
4890 }
4891 #endif
4892 #ifdef TPM_CC_Certify
4893 if (*target == TPM_CC_Certify) {
4894 return TPM_RC_SUCCESS;
4895 }
4896 #endif
4897 #ifdef TPM_CC_PolicyNV
4898 if (*target == TPM_CC_PolicyNV) {
4899 return TPM_RC_SUCCESS;
4900 }
4901 #endif
4902 #ifdef TPM_CC_CertifyCreation
4903 if (*target == TPM_CC_CertifyCreation) {
4904 return TPM_RC_SUCCESS;
4905 }
4906 #endif
4907 #ifdef TPM_CC_Duplicate
4908 if (*target == TPM_CC_Duplicate) {
4909 return TPM_RC_SUCCESS;
4910 }
4911 #endif
4912 #ifdef TPM_CC_GetTime
4913 if (*target == TPM_CC_GetTime) {
4914 return TPM_RC_SUCCESS;
4915 }
4916 #endif
4917 #ifdef TPM_CC_GetSessionAuditDigest
4918 if (*target == TPM_CC_GetSessionAuditDigest) {
4919 return TPM_RC_SUCCESS;
4920 }
4921 #endif
4922 #ifdef TPM_CC_NV_Read
4923 if (*target == TPM_CC_NV_Read) {
4924 return TPM_RC_SUCCESS;
4925 }
4926 #endif
4927 #ifdef TPM_CC_NV_ReadLock
4928 if (*target == TPM_CC_NV_ReadLock) {
4929 return TPM_RC_SUCCESS;
4930 }
4931 #endif
4932 #ifdef TPM_CC_ObjectChangeAuth
4933 if (*target == TPM_CC_ObjectChangeAuth) {
4934 return TPM_RC_SUCCESS;
4935 }
4936 #endif
4937 #ifdef TPM_CC_PolicySecret
4938 if (*target == TPM_CC_PolicySecret) {
4939 return TPM_RC_SUCCESS;
4940 }
4941 #endif
4942 #ifdef TPM_CC_Rewrap
4943 if (*target == TPM_CC_Rewrap) {
4944 return TPM_RC_SUCCESS;
4945 }
4946 #endif
4947 #ifdef TPM_CC_Create
4948 if (*target == TPM_CC_Create) {
4949 return TPM_RC_SUCCESS;
4950 }
4951 #endif
4952 #ifdef TPM_CC_ECDH_ZGen
4953 if (*target == TPM_CC_ECDH_ZGen) {
4954 return TPM_RC_SUCCESS;
4955 }
4956 #endif
4957 #ifdef TPM_CC_HMAC
4958 if (*target == TPM_CC_HMAC) {
4959 return TPM_RC_SUCCESS;
4960 }
4961 #endif
4962 #ifdef TPM_CC_Import
4963 if (*target == TPM_CC_Import) {
4964 return TPM_RC_SUCCESS;
4965 }
4966 #endif
4967 #ifdef TPM_CC_Load
4968 if (*target == TPM_CC_Load) {
4969 return TPM_RC_SUCCESS;
4970 }
4971 #endif
4972 #ifdef TPM_CC_Quote
4973 if (*target == TPM_CC_Quote) {
4974 return TPM_RC_SUCCESS;
4975 }
4976 #endif
4977 #ifdef TPM_CC_RSA_Decrypt
4978 if (*target == TPM_CC_RSA_Decrypt) {
4979 return TPM_RC_SUCCESS;
4980 }
4981 #endif
4982 #ifdef TPM_CC_HMAC_Start
4983 if (*target == TPM_CC_HMAC_Start) {
4984 return TPM_RC_SUCCESS;
4985 }
4986 #endif
4987 #ifdef TPM_CC_SequenceUpdate
4988 if (*target == TPM_CC_SequenceUpdate) {
4989 return TPM_RC_SUCCESS;
4990 }
4991 #endif
4992 #ifdef TPM_CC_Sign
4993 if (*target == TPM_CC_Sign) {
4994 return TPM_RC_SUCCESS;
4995 }
4996 #endif
4997 #ifdef TPM_CC_Unseal
4998 if (*target == TPM_CC_Unseal) {
4999 return TPM_RC_SUCCESS;
5000 }
5001 #endif
5002 #ifdef TPM_CC_PolicySigned
5003 if (*target == TPM_CC_PolicySigned) {
5004 return TPM_RC_SUCCESS;
5005 }
5006 #endif
5007 #ifdef TPM_CC_ContextLoad
5008 if (*target == TPM_CC_ContextLoad) {
5009 return TPM_RC_SUCCESS;
5010 }
5011 #endif
5012 #ifdef TPM_CC_ContextSave
5013 if (*target == TPM_CC_ContextSave) {
5014 return TPM_RC_SUCCESS;
5015 }
5016 #endif
5017 #ifdef TPM_CC_ECDH_KeyGen
5018 if (*target == TPM_CC_ECDH_KeyGen) {
5019 return TPM_RC_SUCCESS;
5020 }
5021 #endif
5022 #ifdef TPM_CC_EncryptDecrypt
5023 if (*target == TPM_CC_EncryptDecrypt) {
5024 return TPM_RC_SUCCESS;
5025 }
5026 #endif
5027 #ifdef TPM_CC_FlushContext
5028 if (*target == TPM_CC_FlushContext) {
5029 return TPM_RC_SUCCESS;
5030 }
5031 #endif
5032 #ifdef TPM_CC_LoadExternal
5033 if (*target == TPM_CC_LoadExternal) {
5034 return TPM_RC_SUCCESS;
5035 }
5036 #endif
5037 #ifdef TPM_CC_MakeCredential
5038 if (*target == TPM_CC_MakeCredential) {
5039 return TPM_RC_SUCCESS;
5040 }
5041 #endif
5042 #ifdef TPM_CC_NV_ReadPublic
5043 if (*target == TPM_CC_NV_ReadPublic) {
5044 return TPM_RC_SUCCESS;
5045 }
5046 #endif
5047 #ifdef TPM_CC_PolicyAuthorize
5048 if (*target == TPM_CC_PolicyAuthorize) {
5049 return TPM_RC_SUCCESS;
5050 }
5051 #endif
5052 #ifdef TPM_CC_PolicyAuthValue
5053 if (*target == TPM_CC_PolicyAuthValue) {
5054 return TPM_RC_SUCCESS;
5055 }
5056 #endif
5057 #ifdef TPM_CC_PolicyCommandCode
5058 if (*target == TPM_CC_PolicyCommandCode) {
5059 return TPM_RC_SUCCESS;
5060 }
5061 #endif
5062 #ifdef TPM_CC_PolicyCounterTimer
5063 if (*target == TPM_CC_PolicyCounterTimer) {
5064 return TPM_RC_SUCCESS;
5065 }
5066 #endif
5067 #ifdef TPM_CC_PolicyCpHash
5068 if (*target == TPM_CC_PolicyCpHash) {
5069 return TPM_RC_SUCCESS;
5070 }
5071 #endif
5072 #ifdef TPM_CC_PolicyLocality
5073 if (*target == TPM_CC_PolicyLocality) {
5074 return TPM_RC_SUCCESS;
5075 }
5076 #endif
5077 #ifdef TPM_CC_PolicyNameHash
5078 if (*target == TPM_CC_PolicyNameHash) {
5079 return TPM_RC_SUCCESS;
5080 }
5081 #endif
5082 #ifdef TPM_CC_PolicyOR
5083 if (*target == TPM_CC_PolicyOR) {
5084 return TPM_RC_SUCCESS;
5085 }
5086 #endif
5087 #ifdef TPM_CC_PolicyTicket
5088 if (*target == TPM_CC_PolicyTicket) {
5089 return TPM_RC_SUCCESS;
5090 }
5091 #endif
5092 #ifdef TPM_CC_ReadPublic
5093 if (*target == TPM_CC_ReadPublic) {
5094 return TPM_RC_SUCCESS;
5095 }
5096 #endif
5097 #ifdef TPM_CC_RSA_Encrypt
5098 if (*target == TPM_CC_RSA_Encrypt) {
5099 return TPM_RC_SUCCESS;
5100 }
5101 #endif
5102 #ifdef TPM_CC_StartAuthSession
5103 if (*target == TPM_CC_StartAuthSession) {
5104 return TPM_RC_SUCCESS;
5105 }
5106 #endif
5107 #ifdef TPM_CC_VerifySignature
5108 if (*target == TPM_CC_VerifySignature) {
5109 return TPM_RC_SUCCESS;
5110 }
5111 #endif
5112 #ifdef TPM_CC_ECC_Parameters
5113 if (*target == TPM_CC_ECC_Parameters) {
5114 return TPM_RC_SUCCESS;
5115 }
5116 #endif
5117 #ifdef TPM_CC_FirmwareRead
5118 if (*target == TPM_CC_FirmwareRead) {
5119 return TPM_RC_SUCCESS;
5120 }
5121 #endif
5122 #ifdef TPM_CC_GetCapability
5123 if (*target == TPM_CC_GetCapability) {
5124 return TPM_RC_SUCCESS;
5125 }
5126 #endif
5127 #ifdef TPM_CC_GetRandom
5128 if (*target == TPM_CC_GetRandom) {
5129 return TPM_RC_SUCCESS;
5130 }
5131 #endif
5132 #ifdef TPM_CC_GetTestResult
5133 if (*target == TPM_CC_GetTestResult) {
5134 return TPM_RC_SUCCESS;
5135 }
5136 #endif
5137 #ifdef TPM_CC_Hash
5138 if (*target == TPM_CC_Hash) {
5139 return TPM_RC_SUCCESS;
5140 }
5141 #endif
5142 #ifdef TPM_CC_PCR_Read
5143 if (*target == TPM_CC_PCR_Read) {
5144 return TPM_RC_SUCCESS;
5145 }
5146 #endif
5147 #ifdef TPM_CC_PolicyPCR
5148 if (*target == TPM_CC_PolicyPCR) {
5149 return TPM_RC_SUCCESS;
5150 }
5151 #endif
5152 #ifdef TPM_CC_PolicyRestart
5153 if (*target == TPM_CC_PolicyRestart) {
5154 return TPM_RC_SUCCESS;
5155 }
5156 #endif
5157 #ifdef TPM_CC_ReadClock
5158 if (*target == TPM_CC_ReadClock) {
5159 return TPM_RC_SUCCESS;
5160 }
5161 #endif
5162 #ifdef TPM_CC_PCR_Extend
5163 if (*target == TPM_CC_PCR_Extend) {
5164 return TPM_RC_SUCCESS;
5165 }
5166 #endif
5167 #ifdef TPM_CC_PCR_SetAuthValue
5168 if (*target == TPM_CC_PCR_SetAuthValue) {
5169 return TPM_RC_SUCCESS;
5170 }
5171 #endif
5172 #ifdef TPM_CC_NV_Certify
5173 if (*target == TPM_CC_NV_Certify) {
5174 return TPM_RC_SUCCESS;
5175 }
5176 #endif
5177 #ifdef TPM_CC_EventSequenceComplete
5178 if (*target == TPM_CC_EventSequenceComplete) {
5179 return TPM_RC_SUCCESS;
5180 }
5181 #endif
5182 #ifdef TPM_CC_HashSequenceStart
5183 if (*target == TPM_CC_HashSequenceStart) {
5184 return TPM_RC_SUCCESS;
5185 }
5186 #endif
5187 #ifdef TPM_CC_PolicyPhysicalPresence
5188 if (*target == TPM_CC_PolicyPhysicalPresence) {
5189 return TPM_RC_SUCCESS;
5190 }
5191 #endif
5192 #ifdef TPM_CC_PolicyDuplicationSelect
5193 if (*target == TPM_CC_PolicyDuplicationSelect) {
5194 return TPM_RC_SUCCESS;
5195 }
5196 #endif
5197 #ifdef TPM_CC_PolicyGetDigest
5198 if (*target == TPM_CC_PolicyGetDigest) {
5199 return TPM_RC_SUCCESS;
5200 }
5201 #endif
5202 #ifdef TPM_CC_TestParms
5203 if (*target == TPM_CC_TestParms) {
5204 return TPM_RC_SUCCESS;
5205 }
5206 #endif
5207 #ifdef TPM_CC_Commit
5208 if (*target == TPM_CC_Commit) {
5209 return TPM_RC_SUCCESS;
5210 }
5211 #endif
5212 #ifdef TPM_CC_PolicyPassword
5213 if (*target == TPM_CC_PolicyPassword) {
5214 return TPM_RC_SUCCESS;
5215 }
5216 #endif
5217 #ifdef TPM_CC_ZGen_2Phase
5218 if (*target == TPM_CC_ZGen_2Phase) {
5219 return TPM_RC_SUCCESS;
5220 }
5221 #endif
5222 #ifdef TPM_CC_EC_Ephemeral
5223 if (*target == TPM_CC_EC_Ephemeral) {
5224 return TPM_RC_SUCCESS;
5225 }
5226 #endif
5227 #ifdef TPM_CC_PolicyNvWritten
5228 if (*target == TPM_CC_PolicyNvWritten) {
5229 return TPM_RC_SUCCESS;
5230 }
5231 #endif
5232 #ifdef TPM_CC_LAST
5233 if (*target == TPM_CC_LAST) {
5234 return TPM_RC_SUCCESS;
5235 }
5236 #endif
5237 return TPM_RC_COMMAND_CODE;
5238 }
5239
TPML_CC_Marshal(TPML_CC * source,BYTE ** buffer,INT32 * size)5240 UINT16 TPML_CC_Marshal(TPML_CC* source, BYTE** buffer, INT32* size) {
5241 UINT16 total_size = 0;
5242 INT32 i;
5243 total_size += UINT32_Marshal(&source->count, buffer, size);
5244 for (i = 0; i < source->count; ++i) {
5245 total_size += TPM_CC_Marshal(&source->commandCodes[i], buffer, size);
5246 }
5247 return total_size;
5248 }
5249
TPML_CC_Unmarshal(TPML_CC * target,BYTE ** buffer,INT32 * size)5250 TPM_RC TPML_CC_Unmarshal(TPML_CC* target, BYTE** buffer, INT32* size) {
5251 TPM_RC result;
5252 INT32 i;
5253 result = UINT32_Unmarshal(&target->count, buffer, size);
5254 if (result != TPM_RC_SUCCESS) {
5255 return result;
5256 }
5257 if (target->count > MAX_CAP_CC) {
5258 return TPM_RC_SIZE;
5259 }
5260 for (i = 0; i < target->count; ++i) {
5261 result = TPM_CC_Unmarshal(&target->commandCodes[i], buffer, size);
5262 if (result != TPM_RC_SUCCESS) {
5263 return result;
5264 }
5265 }
5266 return TPM_RC_SUCCESS;
5267 }
5268
TPML_CCA_Marshal(TPML_CCA * source,BYTE ** buffer,INT32 * size)5269 UINT16 TPML_CCA_Marshal(TPML_CCA* source, BYTE** buffer, INT32* size) {
5270 UINT16 total_size = 0;
5271 INT32 i;
5272 total_size += UINT32_Marshal(&source->count, buffer, size);
5273 for (i = 0; i < source->count; ++i) {
5274 total_size += TPMA_CC_Marshal(&source->commandAttributes[i], buffer, size);
5275 }
5276 return total_size;
5277 }
5278
TPML_CCA_Unmarshal(TPML_CCA * target,BYTE ** buffer,INT32 * size)5279 TPM_RC TPML_CCA_Unmarshal(TPML_CCA* target, BYTE** buffer, INT32* size) {
5280 TPM_RC result;
5281 INT32 i;
5282 result = UINT32_Unmarshal(&target->count, buffer, size);
5283 if (result != TPM_RC_SUCCESS) {
5284 return result;
5285 }
5286 if (target->count > MAX_CAP_CC) {
5287 return TPM_RC_SIZE;
5288 }
5289 for (i = 0; i < target->count; ++i) {
5290 result = TPMA_CC_Unmarshal(&target->commandAttributes[i], buffer, size);
5291 if (result != TPM_RC_SUCCESS) {
5292 return result;
5293 }
5294 }
5295 return TPM_RC_SUCCESS;
5296 }
5297
TPML_DIGEST_Marshal(TPML_DIGEST * source,BYTE ** buffer,INT32 * size)5298 UINT16 TPML_DIGEST_Marshal(TPML_DIGEST* source, BYTE** buffer, INT32* size) {
5299 UINT16 total_size = 0;
5300 INT32 i;
5301 total_size += UINT32_Marshal(&source->count, buffer, size);
5302 for (i = 0; i < source->count; ++i) {
5303 total_size += TPM2B_DIGEST_Marshal(&source->digests[i], buffer, size);
5304 }
5305 return total_size;
5306 }
5307
TPML_DIGEST_Unmarshal(TPML_DIGEST * target,BYTE ** buffer,INT32 * size)5308 TPM_RC TPML_DIGEST_Unmarshal(TPML_DIGEST* target, BYTE** buffer, INT32* size) {
5309 TPM_RC result;
5310 INT32 i;
5311 result = UINT32_Unmarshal(&target->count, buffer, size);
5312 if (result != TPM_RC_SUCCESS) {
5313 return result;
5314 }
5315 if (target->count > 8) {
5316 return TPM_RC_SIZE;
5317 }
5318 if (target->count < 2) {
5319 return TPM_RC_SIZE;
5320 }
5321 for (i = 0; i < target->count; ++i) {
5322 result = TPM2B_DIGEST_Unmarshal(&target->digests[i], buffer, size);
5323 if (result != TPM_RC_SUCCESS) {
5324 return result;
5325 }
5326 }
5327 return TPM_RC_SUCCESS;
5328 }
5329
TPMU_HA_Marshal(TPMU_HA * source,BYTE ** buffer,INT32 * size,UINT32 selector)5330 UINT16 TPMU_HA_Marshal(TPMU_HA* source,
5331 BYTE** buffer,
5332 INT32* size,
5333 UINT32 selector) {
5334 INT32 i;
5335 UINT16 total_size = 0;
5336 switch (selector) {
5337 #ifdef TPM_ALG_SHA
5338 case TPM_ALG_SHA:
5339 for (i = 0; i < SHA_DIGEST_SIZE; ++i) {
5340 total_size += BYTE_Marshal(&source->sha[i], buffer, size);
5341 }
5342 return total_size;
5343 #endif
5344 #ifdef TPM_ALG_SHA1
5345 case TPM_ALG_SHA1:
5346 for (i = 0; i < SHA1_DIGEST_SIZE; ++i) {
5347 total_size += BYTE_Marshal(&source->sha1[i], buffer, size);
5348 }
5349 return total_size;
5350 #endif
5351 #ifdef TPM_ALG_SHA256
5352 case TPM_ALG_SHA256:
5353 for (i = 0; i < SHA256_DIGEST_SIZE; ++i) {
5354 total_size += BYTE_Marshal(&source->sha256[i], buffer, size);
5355 }
5356 return total_size;
5357 #endif
5358 #ifdef TPM_ALG_SHA384
5359 case TPM_ALG_SHA384:
5360 for (i = 0; i < SHA384_DIGEST_SIZE; ++i) {
5361 total_size += BYTE_Marshal(&source->sha384[i], buffer, size);
5362 }
5363 return total_size;
5364 #endif
5365 #ifdef TPM_ALG_SHA512
5366 case TPM_ALG_SHA512:
5367 for (i = 0; i < SHA512_DIGEST_SIZE; ++i) {
5368 total_size += BYTE_Marshal(&source->sha512[i], buffer, size);
5369 }
5370 return total_size;
5371 #endif
5372 #ifdef TPM_ALG_SM3_256
5373 case TPM_ALG_SM3_256:
5374 for (i = 0; i < SM3_256_DIGEST_SIZE; ++i) {
5375 total_size += BYTE_Marshal(&source->sm3_256[i], buffer, size);
5376 }
5377 return total_size;
5378 #endif
5379 #ifdef TPM_ALG_NULL
5380 case TPM_ALG_NULL:
5381 return 0;
5382 #endif
5383 }
5384 return 0;
5385 }
5386
TPMU_HA_Unmarshal(TPMU_HA * target,BYTE ** buffer,INT32 * size,UINT32 selector)5387 TPM_RC TPMU_HA_Unmarshal(TPMU_HA* target,
5388 BYTE** buffer,
5389 INT32* size,
5390 UINT32 selector) {
5391 switch (selector) {
5392 INT32 i;
5393 TPM_RC result = TPM_RC_SUCCESS;
5394 #ifdef TPM_ALG_SHA
5395 case TPM_ALG_SHA:
5396 for (i = 0; i < SHA_DIGEST_SIZE; ++i) {
5397 result = BYTE_Unmarshal(&target->sha[i], buffer, size);
5398 if (result != TPM_RC_SUCCESS) {
5399 return result;
5400 }
5401 }
5402 return TPM_RC_SUCCESS;
5403 #endif
5404 #ifdef TPM_ALG_SHA1
5405 case TPM_ALG_SHA1:
5406 for (i = 0; i < SHA1_DIGEST_SIZE; ++i) {
5407 result = BYTE_Unmarshal(&target->sha1[i], buffer, size);
5408 if (result != TPM_RC_SUCCESS) {
5409 return result;
5410 }
5411 }
5412 return TPM_RC_SUCCESS;
5413 #endif
5414 #ifdef TPM_ALG_SHA256
5415 case TPM_ALG_SHA256:
5416 for (i = 0; i < SHA256_DIGEST_SIZE; ++i) {
5417 result = BYTE_Unmarshal(&target->sha256[i], buffer, size);
5418 if (result != TPM_RC_SUCCESS) {
5419 return result;
5420 }
5421 }
5422 return TPM_RC_SUCCESS;
5423 #endif
5424 #ifdef TPM_ALG_SHA384
5425 case TPM_ALG_SHA384:
5426 for (i = 0; i < SHA384_DIGEST_SIZE; ++i) {
5427 result = BYTE_Unmarshal(&target->sha384[i], buffer, size);
5428 if (result != TPM_RC_SUCCESS) {
5429 return result;
5430 }
5431 }
5432 return TPM_RC_SUCCESS;
5433 #endif
5434 #ifdef TPM_ALG_SHA512
5435 case TPM_ALG_SHA512:
5436 for (i = 0; i < SHA512_DIGEST_SIZE; ++i) {
5437 result = BYTE_Unmarshal(&target->sha512[i], buffer, size);
5438 if (result != TPM_RC_SUCCESS) {
5439 return result;
5440 }
5441 }
5442 return TPM_RC_SUCCESS;
5443 #endif
5444 #ifdef TPM_ALG_SM3_256
5445 case TPM_ALG_SM3_256:
5446 for (i = 0; i < SM3_256_DIGEST_SIZE; ++i) {
5447 result = BYTE_Unmarshal(&target->sm3_256[i], buffer, size);
5448 if (result != TPM_RC_SUCCESS) {
5449 return result;
5450 }
5451 }
5452 return TPM_RC_SUCCESS;
5453 #endif
5454 #ifdef TPM_ALG_NULL
5455 case TPM_ALG_NULL:
5456 return TPM_RC_SUCCESS;
5457 #endif
5458 }
5459 return TPM_RC_SELECTOR;
5460 }
5461
TPMT_HA_Marshal(TPMT_HA * source,BYTE ** buffer,INT32 * size)5462 UINT16 TPMT_HA_Marshal(TPMT_HA* source, BYTE** buffer, INT32* size) {
5463 UINT16 total_size = 0;
5464 total_size += TPMI_ALG_HASH_Marshal(&source->hashAlg, buffer, size);
5465 total_size += TPMU_HA_Marshal(&source->digest, buffer, size, source->hashAlg);
5466 return total_size;
5467 }
5468
TPMT_HA_Unmarshal(TPMT_HA * target,BYTE ** buffer,INT32 * size)5469 TPM_RC TPMT_HA_Unmarshal(TPMT_HA* target, BYTE** buffer, INT32* size) {
5470 TPM_RC result;
5471 result = TPMI_ALG_HASH_Unmarshal(&target->hashAlg, buffer, size, TRUE);
5472 if (result != TPM_RC_SUCCESS) {
5473 return result;
5474 }
5475 result = TPMU_HA_Unmarshal(&target->digest, buffer, size, target->hashAlg);
5476 if (result != TPM_RC_SUCCESS) {
5477 return result;
5478 }
5479 return TPM_RC_SUCCESS;
5480 }
5481
TPML_DIGEST_VALUES_Marshal(TPML_DIGEST_VALUES * source,BYTE ** buffer,INT32 * size)5482 UINT16 TPML_DIGEST_VALUES_Marshal(TPML_DIGEST_VALUES* source,
5483 BYTE** buffer,
5484 INT32* size) {
5485 UINT16 total_size = 0;
5486 INT32 i;
5487 total_size += UINT32_Marshal(&source->count, buffer, size);
5488 for (i = 0; i < source->count; ++i) {
5489 total_size += TPMT_HA_Marshal(&source->digests[i], buffer, size);
5490 }
5491 return total_size;
5492 }
5493
TPML_DIGEST_VALUES_Unmarshal(TPML_DIGEST_VALUES * target,BYTE ** buffer,INT32 * size)5494 TPM_RC TPML_DIGEST_VALUES_Unmarshal(TPML_DIGEST_VALUES* target,
5495 BYTE** buffer,
5496 INT32* size) {
5497 TPM_RC result;
5498 INT32 i;
5499 result = UINT32_Unmarshal(&target->count, buffer, size);
5500 if (result != TPM_RC_SUCCESS) {
5501 return result;
5502 }
5503 if (target->count > HASH_COUNT) {
5504 return TPM_RC_SIZE;
5505 }
5506 for (i = 0; i < target->count; ++i) {
5507 result = TPMT_HA_Unmarshal(&target->digests[i], buffer, size);
5508 if (result != TPM_RC_SUCCESS) {
5509 return result;
5510 }
5511 }
5512 return TPM_RC_SUCCESS;
5513 }
5514
TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE * source,BYTE ** buffer,INT32 * size)5515 UINT16 TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE* source,
5516 BYTE** buffer,
5517 INT32* size) {
5518 return uint16_t_Marshal(source, buffer, size);
5519 }
5520
TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE * target,BYTE ** buffer,INT32 * size)5521 TPM_RC TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE* target,
5522 BYTE** buffer,
5523 INT32* size) {
5524 TPM_RC result;
5525 result = uint16_t_Unmarshal(target, buffer, size);
5526 if (result != TPM_RC_SUCCESS) {
5527 return result;
5528 }
5529 if (*target == TPM_ECC_NONE) {
5530 return TPM_RC_SUCCESS;
5531 }
5532 if (*target == TPM_ECC_NIST_P192) {
5533 return TPM_RC_SUCCESS;
5534 }
5535 if (*target == TPM_ECC_NIST_P224) {
5536 return TPM_RC_SUCCESS;
5537 }
5538 if (*target == TPM_ECC_NIST_P256) {
5539 return TPM_RC_SUCCESS;
5540 }
5541 if (*target == TPM_ECC_NIST_P384) {
5542 return TPM_RC_SUCCESS;
5543 }
5544 if (*target == TPM_ECC_NIST_P521) {
5545 return TPM_RC_SUCCESS;
5546 }
5547 if (*target == TPM_ECC_BN_P256) {
5548 return TPM_RC_SUCCESS;
5549 }
5550 if (*target == TPM_ECC_BN_P638) {
5551 return TPM_RC_SUCCESS;
5552 }
5553 if (*target == TPM_ECC_SM2_P256) {
5554 return TPM_RC_SUCCESS;
5555 }
5556 return TPM_RC_CURVE;
5557 }
5558
TPML_ECC_CURVE_Marshal(TPML_ECC_CURVE * source,BYTE ** buffer,INT32 * size)5559 UINT16 TPML_ECC_CURVE_Marshal(TPML_ECC_CURVE* source,
5560 BYTE** buffer,
5561 INT32* size) {
5562 UINT16 total_size = 0;
5563 INT32 i;
5564 total_size += UINT32_Marshal(&source->count, buffer, size);
5565 for (i = 0; i < source->count; ++i) {
5566 total_size += TPM_ECC_CURVE_Marshal(&source->eccCurves[i], buffer, size);
5567 }
5568 return total_size;
5569 }
5570
TPML_ECC_CURVE_Unmarshal(TPML_ECC_CURVE * target,BYTE ** buffer,INT32 * size)5571 TPM_RC TPML_ECC_CURVE_Unmarshal(TPML_ECC_CURVE* target,
5572 BYTE** buffer,
5573 INT32* size) {
5574 TPM_RC result;
5575 INT32 i;
5576 result = UINT32_Unmarshal(&target->count, buffer, size);
5577 if (result != TPM_RC_SUCCESS) {
5578 return result;
5579 }
5580 if (target->count > MAX_ECC_CURVES) {
5581 return TPM_RC_SIZE;
5582 }
5583 for (i = 0; i < target->count; ++i) {
5584 result = TPM_ECC_CURVE_Unmarshal(&target->eccCurves[i], buffer, size);
5585 if (result != TPM_RC_SUCCESS) {
5586 return result;
5587 }
5588 }
5589 return TPM_RC_SUCCESS;
5590 }
5591
TPM_HANDLE_Marshal(TPM_HANDLE * source,BYTE ** buffer,INT32 * size)5592 UINT16 TPM_HANDLE_Marshal(TPM_HANDLE* source, BYTE** buffer, INT32* size) {
5593 return uint32_t_Marshal(source, buffer, size);
5594 }
5595
TPM_HANDLE_Unmarshal(TPM_HANDLE * target,BYTE ** buffer,INT32 * size)5596 TPM_RC TPM_HANDLE_Unmarshal(TPM_HANDLE* target, BYTE** buffer, INT32* size) {
5597 return uint32_t_Unmarshal(target, buffer, size);
5598 }
5599
TPML_HANDLE_Marshal(TPML_HANDLE * source,BYTE ** buffer,INT32 * size)5600 UINT16 TPML_HANDLE_Marshal(TPML_HANDLE* source, BYTE** buffer, INT32* size) {
5601 UINT16 total_size = 0;
5602 INT32 i;
5603 total_size += UINT32_Marshal(&source->count, buffer, size);
5604 for (i = 0; i < source->count; ++i) {
5605 total_size += TPM_HANDLE_Marshal(&source->handle[i], buffer, size);
5606 }
5607 return total_size;
5608 }
5609
TPML_HANDLE_Unmarshal(TPML_HANDLE * target,BYTE ** buffer,INT32 * size)5610 TPM_RC TPML_HANDLE_Unmarshal(TPML_HANDLE* target, BYTE** buffer, INT32* size) {
5611 TPM_RC result;
5612 INT32 i;
5613 result = UINT32_Unmarshal(&target->count, buffer, size);
5614 if (result != TPM_RC_SUCCESS) {
5615 return result;
5616 }
5617 if (target->count > MAX_CAP_HANDLES) {
5618 return TPM_RC_SIZE;
5619 }
5620 for (i = 0; i < target->count; ++i) {
5621 result = TPM_HANDLE_Unmarshal(&target->handle[i], buffer, size);
5622 if (result != TPM_RC_SUCCESS) {
5623 return result;
5624 }
5625 }
5626 return TPM_RC_SUCCESS;
5627 }
5628
TPM_PT_Marshal(TPM_PT * source,BYTE ** buffer,INT32 * size)5629 UINT16 TPM_PT_Marshal(TPM_PT* source, BYTE** buffer, INT32* size) {
5630 return uint32_t_Marshal(source, buffer, size);
5631 }
5632
TPM_PT_Unmarshal(TPM_PT * target,BYTE ** buffer,INT32 * size)5633 TPM_RC TPM_PT_Unmarshal(TPM_PT* target, BYTE** buffer, INT32* size) {
5634 TPM_RC result;
5635 result = uint32_t_Unmarshal(target, buffer, size);
5636 if (result != TPM_RC_SUCCESS) {
5637 return result;
5638 }
5639 if (*target == TPM_PT_NONE) {
5640 return TPM_RC_SUCCESS;
5641 }
5642 if (*target == PT_GROUP) {
5643 return TPM_RC_SUCCESS;
5644 }
5645 if (*target == PT_FIXED) {
5646 return TPM_RC_SUCCESS;
5647 }
5648 if (*target == TPM_PT_FAMILY_INDICATOR) {
5649 return TPM_RC_SUCCESS;
5650 }
5651 if (*target == TPM_PT_LEVEL) {
5652 return TPM_RC_SUCCESS;
5653 }
5654 if (*target == TPM_PT_REVISION) {
5655 return TPM_RC_SUCCESS;
5656 }
5657 if (*target == TPM_PT_DAY_OF_YEAR) {
5658 return TPM_RC_SUCCESS;
5659 }
5660 if (*target == TPM_PT_YEAR) {
5661 return TPM_RC_SUCCESS;
5662 }
5663 if (*target == TPM_PT_MANUFACTURER) {
5664 return TPM_RC_SUCCESS;
5665 }
5666 if (*target == TPM_PT_VENDOR_STRING_1) {
5667 return TPM_RC_SUCCESS;
5668 }
5669 if (*target == TPM_PT_VENDOR_STRING_2) {
5670 return TPM_RC_SUCCESS;
5671 }
5672 if (*target == TPM_PT_VENDOR_STRING_3) {
5673 return TPM_RC_SUCCESS;
5674 }
5675 if (*target == TPM_PT_VENDOR_STRING_4) {
5676 return TPM_RC_SUCCESS;
5677 }
5678 if (*target == TPM_PT_VENDOR_TPM_TYPE) {
5679 return TPM_RC_SUCCESS;
5680 }
5681 if (*target == TPM_PT_FIRMWARE_VERSION_1) {
5682 return TPM_RC_SUCCESS;
5683 }
5684 if (*target == TPM_PT_FIRMWARE_VERSION_2) {
5685 return TPM_RC_SUCCESS;
5686 }
5687 if (*target == TPM_PT_INPUT_BUFFER) {
5688 return TPM_RC_SUCCESS;
5689 }
5690 if (*target == TPM_PT_HR_TRANSIENT_MIN) {
5691 return TPM_RC_SUCCESS;
5692 }
5693 if (*target == TPM_PT_HR_PERSISTENT_MIN) {
5694 return TPM_RC_SUCCESS;
5695 }
5696 if (*target == TPM_PT_HR_LOADED_MIN) {
5697 return TPM_RC_SUCCESS;
5698 }
5699 if (*target == TPM_PT_ACTIVE_SESSIONS_MAX) {
5700 return TPM_RC_SUCCESS;
5701 }
5702 if (*target == TPM_PT_PCR_COUNT) {
5703 return TPM_RC_SUCCESS;
5704 }
5705 if (*target == TPM_PT_PCR_SELECT_MIN) {
5706 return TPM_RC_SUCCESS;
5707 }
5708 if (*target == TPM_PT_CONTEXT_GAP_MAX) {
5709 return TPM_RC_SUCCESS;
5710 }
5711 if (*target == TPM_PT_NV_COUNTERS_MAX) {
5712 return TPM_RC_SUCCESS;
5713 }
5714 if (*target == TPM_PT_NV_INDEX_MAX) {
5715 return TPM_RC_SUCCESS;
5716 }
5717 if (*target == TPM_PT_MEMORY) {
5718 return TPM_RC_SUCCESS;
5719 }
5720 if (*target == TPM_PT_CLOCK_UPDATE) {
5721 return TPM_RC_SUCCESS;
5722 }
5723 if (*target == TPM_PT_CONTEXT_HASH) {
5724 return TPM_RC_SUCCESS;
5725 }
5726 if (*target == TPM_PT_CONTEXT_SYM) {
5727 return TPM_RC_SUCCESS;
5728 }
5729 if (*target == TPM_PT_CONTEXT_SYM_SIZE) {
5730 return TPM_RC_SUCCESS;
5731 }
5732 if (*target == TPM_PT_ORDERLY_COUNT) {
5733 return TPM_RC_SUCCESS;
5734 }
5735 if (*target == TPM_PT_MAX_COMMAND_SIZE) {
5736 return TPM_RC_SUCCESS;
5737 }
5738 if (*target == TPM_PT_MAX_RESPONSE_SIZE) {
5739 return TPM_RC_SUCCESS;
5740 }
5741 if (*target == TPM_PT_MAX_DIGEST) {
5742 return TPM_RC_SUCCESS;
5743 }
5744 if (*target == TPM_PT_MAX_OBJECT_CONTEXT) {
5745 return TPM_RC_SUCCESS;
5746 }
5747 if (*target == TPM_PT_MAX_SESSION_CONTEXT) {
5748 return TPM_RC_SUCCESS;
5749 }
5750 if (*target == TPM_PT_PS_FAMILY_INDICATOR) {
5751 return TPM_RC_SUCCESS;
5752 }
5753 if (*target == TPM_PT_PS_LEVEL) {
5754 return TPM_RC_SUCCESS;
5755 }
5756 if (*target == TPM_PT_PS_REVISION) {
5757 return TPM_RC_SUCCESS;
5758 }
5759 if (*target == TPM_PT_PS_DAY_OF_YEAR) {
5760 return TPM_RC_SUCCESS;
5761 }
5762 if (*target == TPM_PT_PS_YEAR) {
5763 return TPM_RC_SUCCESS;
5764 }
5765 if (*target == TPM_PT_SPLIT_MAX) {
5766 return TPM_RC_SUCCESS;
5767 }
5768 if (*target == TPM_PT_TOTAL_COMMANDS) {
5769 return TPM_RC_SUCCESS;
5770 }
5771 if (*target == TPM_PT_LIBRARY_COMMANDS) {
5772 return TPM_RC_SUCCESS;
5773 }
5774 if (*target == TPM_PT_VENDOR_COMMANDS) {
5775 return TPM_RC_SUCCESS;
5776 }
5777 if (*target == TPM_PT_NV_BUFFER_MAX) {
5778 return TPM_RC_SUCCESS;
5779 }
5780 if (*target == PT_VAR) {
5781 return TPM_RC_SUCCESS;
5782 }
5783 if (*target == TPM_PT_PERMANENT) {
5784 return TPM_RC_SUCCESS;
5785 }
5786 if (*target == TPM_PT_STARTUP_CLEAR) {
5787 return TPM_RC_SUCCESS;
5788 }
5789 if (*target == TPM_PT_HR_NV_INDEX) {
5790 return TPM_RC_SUCCESS;
5791 }
5792 if (*target == TPM_PT_HR_LOADED) {
5793 return TPM_RC_SUCCESS;
5794 }
5795 if (*target == TPM_PT_HR_LOADED_AVAIL) {
5796 return TPM_RC_SUCCESS;
5797 }
5798 if (*target == TPM_PT_HR_ACTIVE) {
5799 return TPM_RC_SUCCESS;
5800 }
5801 if (*target == TPM_PT_HR_ACTIVE_AVAIL) {
5802 return TPM_RC_SUCCESS;
5803 }
5804 if (*target == TPM_PT_HR_TRANSIENT_AVAIL) {
5805 return TPM_RC_SUCCESS;
5806 }
5807 if (*target == TPM_PT_HR_PERSISTENT) {
5808 return TPM_RC_SUCCESS;
5809 }
5810 if (*target == TPM_PT_HR_PERSISTENT_AVAIL) {
5811 return TPM_RC_SUCCESS;
5812 }
5813 if (*target == TPM_PT_NV_COUNTERS) {
5814 return TPM_RC_SUCCESS;
5815 }
5816 if (*target == TPM_PT_NV_COUNTERS_AVAIL) {
5817 return TPM_RC_SUCCESS;
5818 }
5819 if (*target == TPM_PT_ALGORITHM_SET) {
5820 return TPM_RC_SUCCESS;
5821 }
5822 if (*target == TPM_PT_LOADED_CURVES) {
5823 return TPM_RC_SUCCESS;
5824 }
5825 if (*target == TPM_PT_LOCKOUT_COUNTER) {
5826 return TPM_RC_SUCCESS;
5827 }
5828 if (*target == TPM_PT_MAX_AUTH_FAIL) {
5829 return TPM_RC_SUCCESS;
5830 }
5831 if (*target == TPM_PT_LOCKOUT_INTERVAL) {
5832 return TPM_RC_SUCCESS;
5833 }
5834 if (*target == TPM_PT_LOCKOUT_RECOVERY) {
5835 return TPM_RC_SUCCESS;
5836 }
5837 if (*target == TPM_PT_NV_WRITE_RECOVERY) {
5838 return TPM_RC_SUCCESS;
5839 }
5840 if (*target == TPM_PT_AUDIT_COUNTER_0) {
5841 return TPM_RC_SUCCESS;
5842 }
5843 if (*target == TPM_PT_AUDIT_COUNTER_1) {
5844 return TPM_RC_SUCCESS;
5845 }
5846 return TPM_RC_VALUE;
5847 }
5848
TPMS_TAGGED_PCR_SELECT_Marshal(TPMS_TAGGED_PCR_SELECT * source,BYTE ** buffer,INT32 * size)5849 UINT16 TPMS_TAGGED_PCR_SELECT_Marshal(TPMS_TAGGED_PCR_SELECT* source,
5850 BYTE** buffer,
5851 INT32* size) {
5852 UINT16 total_size = 0;
5853 INT32 i;
5854 total_size += TPM_PT_Marshal(&source->tag, buffer, size);
5855 total_size += UINT8_Marshal(&source->sizeofSelect, buffer, size);
5856 for (i = 0; i < source->sizeofSelect; ++i) {
5857 total_size += BYTE_Marshal(&source->pcrSelect[i], buffer, size);
5858 }
5859 return total_size;
5860 }
5861
TPMS_TAGGED_PCR_SELECT_Unmarshal(TPMS_TAGGED_PCR_SELECT * target,BYTE ** buffer,INT32 * size)5862 TPM_RC TPMS_TAGGED_PCR_SELECT_Unmarshal(TPMS_TAGGED_PCR_SELECT* target,
5863 BYTE** buffer,
5864 INT32* size) {
5865 TPM_RC result;
5866 INT32 i;
5867 result = TPM_PT_Unmarshal(&target->tag, buffer, size);
5868 if (result != TPM_RC_SUCCESS) {
5869 return result;
5870 }
5871 result = UINT8_Unmarshal(&target->sizeofSelect, buffer, size);
5872 if (result != TPM_RC_SUCCESS) {
5873 return result;
5874 }
5875 if (target->sizeofSelect > PCR_SELECT_MAX) {
5876 return TPM_RC_VALUE;
5877 }
5878 if (target->sizeofSelect < PCR_SELECT_MIN) {
5879 return TPM_RC_VALUE;
5880 }
5881 for (i = 0; i < target->sizeofSelect; ++i) {
5882 result = BYTE_Unmarshal(&target->pcrSelect[i], buffer, size);
5883 if (result != TPM_RC_SUCCESS) {
5884 return result;
5885 }
5886 }
5887 return TPM_RC_SUCCESS;
5888 }
5889
TPML_TAGGED_PCR_PROPERTY_Marshal(TPML_TAGGED_PCR_PROPERTY * source,BYTE ** buffer,INT32 * size)5890 UINT16 TPML_TAGGED_PCR_PROPERTY_Marshal(TPML_TAGGED_PCR_PROPERTY* source,
5891 BYTE** buffer,
5892 INT32* size) {
5893 UINT16 total_size = 0;
5894 INT32 i;
5895 total_size += UINT32_Marshal(&source->count, buffer, size);
5896 for (i = 0; i < source->count; ++i) {
5897 total_size +=
5898 TPMS_TAGGED_PCR_SELECT_Marshal(&source->pcrProperty[i], buffer, size);
5899 }
5900 return total_size;
5901 }
5902
TPML_TAGGED_PCR_PROPERTY_Unmarshal(TPML_TAGGED_PCR_PROPERTY * target,BYTE ** buffer,INT32 * size)5903 TPM_RC TPML_TAGGED_PCR_PROPERTY_Unmarshal(TPML_TAGGED_PCR_PROPERTY* target,
5904 BYTE** buffer,
5905 INT32* size) {
5906 TPM_RC result;
5907 INT32 i;
5908 result = UINT32_Unmarshal(&target->count, buffer, size);
5909 if (result != TPM_RC_SUCCESS) {
5910 return result;
5911 }
5912 if (target->count > MAX_PCR_PROPERTIES) {
5913 return TPM_RC_SIZE;
5914 }
5915 for (i = 0; i < target->count; ++i) {
5916 result =
5917 TPMS_TAGGED_PCR_SELECT_Unmarshal(&target->pcrProperty[i], buffer, size);
5918 if (result != TPM_RC_SUCCESS) {
5919 return result;
5920 }
5921 }
5922 return TPM_RC_SUCCESS;
5923 }
5924
TPMS_TAGGED_PROPERTY_Marshal(TPMS_TAGGED_PROPERTY * source,BYTE ** buffer,INT32 * size)5925 UINT16 TPMS_TAGGED_PROPERTY_Marshal(TPMS_TAGGED_PROPERTY* source,
5926 BYTE** buffer,
5927 INT32* size) {
5928 UINT16 total_size = 0;
5929 total_size += TPM_PT_Marshal(&source->property, buffer, size);
5930 total_size += UINT32_Marshal(&source->value, buffer, size);
5931 return total_size;
5932 }
5933
TPMS_TAGGED_PROPERTY_Unmarshal(TPMS_TAGGED_PROPERTY * target,BYTE ** buffer,INT32 * size)5934 TPM_RC TPMS_TAGGED_PROPERTY_Unmarshal(TPMS_TAGGED_PROPERTY* target,
5935 BYTE** buffer,
5936 INT32* size) {
5937 TPM_RC result;
5938 result = TPM_PT_Unmarshal(&target->property, buffer, size);
5939 if (result != TPM_RC_SUCCESS) {
5940 return result;
5941 }
5942 result = UINT32_Unmarshal(&target->value, buffer, size);
5943 if (result != TPM_RC_SUCCESS) {
5944 return result;
5945 }
5946 return TPM_RC_SUCCESS;
5947 }
5948
TPML_TAGGED_TPM_PROPERTY_Marshal(TPML_TAGGED_TPM_PROPERTY * source,BYTE ** buffer,INT32 * size)5949 UINT16 TPML_TAGGED_TPM_PROPERTY_Marshal(TPML_TAGGED_TPM_PROPERTY* source,
5950 BYTE** buffer,
5951 INT32* size) {
5952 UINT16 total_size = 0;
5953 INT32 i;
5954 total_size += UINT32_Marshal(&source->count, buffer, size);
5955 for (i = 0; i < source->count; ++i) {
5956 total_size +=
5957 TPMS_TAGGED_PROPERTY_Marshal(&source->tpmProperty[i], buffer, size);
5958 }
5959 return total_size;
5960 }
5961
TPML_TAGGED_TPM_PROPERTY_Unmarshal(TPML_TAGGED_TPM_PROPERTY * target,BYTE ** buffer,INT32 * size)5962 TPM_RC TPML_TAGGED_TPM_PROPERTY_Unmarshal(TPML_TAGGED_TPM_PROPERTY* target,
5963 BYTE** buffer,
5964 INT32* size) {
5965 TPM_RC result;
5966 INT32 i;
5967 result = UINT32_Unmarshal(&target->count, buffer, size);
5968 if (result != TPM_RC_SUCCESS) {
5969 return result;
5970 }
5971 if (target->count > MAX_TPM_PROPERTIES) {
5972 return TPM_RC_SIZE;
5973 }
5974 for (i = 0; i < target->count; ++i) {
5975 result =
5976 TPMS_TAGGED_PROPERTY_Unmarshal(&target->tpmProperty[i], buffer, size);
5977 if (result != TPM_RC_SUCCESS) {
5978 return result;
5979 }
5980 }
5981 return TPM_RC_SUCCESS;
5982 }
5983
TPMS_ALGORITHM_DESCRIPTION_Marshal(TPMS_ALGORITHM_DESCRIPTION * source,BYTE ** buffer,INT32 * size)5984 UINT16 TPMS_ALGORITHM_DESCRIPTION_Marshal(TPMS_ALGORITHM_DESCRIPTION* source,
5985 BYTE** buffer,
5986 INT32* size) {
5987 UINT16 total_size = 0;
5988 total_size += TPM_ALG_ID_Marshal(&source->alg, buffer, size);
5989 total_size += TPMA_ALGORITHM_Marshal(&source->attributes, buffer, size);
5990 return total_size;
5991 }
5992
TPMS_ALGORITHM_DESCRIPTION_Unmarshal(TPMS_ALGORITHM_DESCRIPTION * target,BYTE ** buffer,INT32 * size)5993 TPM_RC TPMS_ALGORITHM_DESCRIPTION_Unmarshal(TPMS_ALGORITHM_DESCRIPTION* target,
5994 BYTE** buffer,
5995 INT32* size) {
5996 TPM_RC result;
5997 result = TPM_ALG_ID_Unmarshal(&target->alg, buffer, size);
5998 if (result != TPM_RC_SUCCESS) {
5999 return result;
6000 }
6001 result = TPMA_ALGORITHM_Unmarshal(&target->attributes, buffer, size);
6002 if (result != TPM_RC_SUCCESS) {
6003 return result;
6004 }
6005 return TPM_RC_SUCCESS;
6006 }
6007
TPMS_ALGORITHM_DETAIL_ECC_Marshal(TPMS_ALGORITHM_DETAIL_ECC * source,BYTE ** buffer,INT32 * size)6008 UINT16 TPMS_ALGORITHM_DETAIL_ECC_Marshal(TPMS_ALGORITHM_DETAIL_ECC* source,
6009 BYTE** buffer,
6010 INT32* size) {
6011 UINT16 total_size = 0;
6012 total_size += TPM_ECC_CURVE_Marshal(&source->curveID, buffer, size);
6013 total_size += UINT16_Marshal(&source->keySize, buffer, size);
6014 total_size += TPMT_KDF_SCHEME_Marshal(&source->kdf, buffer, size);
6015 total_size += TPMT_ECC_SCHEME_Marshal(&source->sign, buffer, size);
6016 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->p, buffer, size);
6017 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->a, buffer, size);
6018 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->b, buffer, size);
6019 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->gX, buffer, size);
6020 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->gY, buffer, size);
6021 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->n, buffer, size);
6022 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->h, buffer, size);
6023 return total_size;
6024 }
6025
TPMS_ALGORITHM_DETAIL_ECC_Unmarshal(TPMS_ALGORITHM_DETAIL_ECC * target,BYTE ** buffer,INT32 * size)6026 TPM_RC TPMS_ALGORITHM_DETAIL_ECC_Unmarshal(TPMS_ALGORITHM_DETAIL_ECC* target,
6027 BYTE** buffer,
6028 INT32* size) {
6029 TPM_RC result;
6030 result = TPM_ECC_CURVE_Unmarshal(&target->curveID, buffer, size);
6031 if (result != TPM_RC_SUCCESS) {
6032 return result;
6033 }
6034 result = UINT16_Unmarshal(&target->keySize, buffer, size);
6035 if (result != TPM_RC_SUCCESS) {
6036 return result;
6037 }
6038 result = TPMT_KDF_SCHEME_Unmarshal(&target->kdf, buffer, size);
6039 if (result != TPM_RC_SUCCESS) {
6040 return result;
6041 }
6042 result = TPMT_ECC_SCHEME_Unmarshal(&target->sign, buffer, size);
6043 if (result != TPM_RC_SUCCESS) {
6044 return result;
6045 }
6046 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->p, buffer, size);
6047 if (result != TPM_RC_SUCCESS) {
6048 return result;
6049 }
6050 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->a, buffer, size);
6051 if (result != TPM_RC_SUCCESS) {
6052 return result;
6053 }
6054 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->b, buffer, size);
6055 if (result != TPM_RC_SUCCESS) {
6056 return result;
6057 }
6058 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->gX, buffer, size);
6059 if (result != TPM_RC_SUCCESS) {
6060 return result;
6061 }
6062 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->gY, buffer, size);
6063 if (result != TPM_RC_SUCCESS) {
6064 return result;
6065 }
6066 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->n, buffer, size);
6067 if (result != TPM_RC_SUCCESS) {
6068 return result;
6069 }
6070 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->h, buffer, size);
6071 if (result != TPM_RC_SUCCESS) {
6072 return result;
6073 }
6074 return TPM_RC_SUCCESS;
6075 }
6076
UINT64_Marshal(UINT64 * source,BYTE ** buffer,INT32 * size)6077 UINT16 UINT64_Marshal(UINT64* source, BYTE** buffer, INT32* size) {
6078 return uint64_t_Marshal(source, buffer, size);
6079 }
6080
UINT64_Unmarshal(UINT64 * target,BYTE ** buffer,INT32 * size)6081 TPM_RC UINT64_Unmarshal(UINT64* target, BYTE** buffer, INT32* size) {
6082 return uint64_t_Unmarshal(target, buffer, size);
6083 }
6084
TPM_GENERATED_Marshal(TPM_GENERATED * source,BYTE ** buffer,INT32 * size)6085 UINT16 TPM_GENERATED_Marshal(TPM_GENERATED* source,
6086 BYTE** buffer,
6087 INT32* size) {
6088 return uint32_t_Marshal(source, buffer, size);
6089 }
6090
TPM_GENERATED_Unmarshal(TPM_GENERATED * target,BYTE ** buffer,INT32 * size)6091 TPM_RC TPM_GENERATED_Unmarshal(TPM_GENERATED* target,
6092 BYTE** buffer,
6093 INT32* size) {
6094 TPM_RC result;
6095 result = uint32_t_Unmarshal(target, buffer, size);
6096 if (result != TPM_RC_SUCCESS) {
6097 return result;
6098 }
6099 if (*target == TPM_GENERATED_VALUE) {
6100 return TPM_RC_SUCCESS;
6101 }
6102 return TPM_RC_VALUE;
6103 }
6104
TPMS_CREATION_INFO_Marshal(TPMS_CREATION_INFO * source,BYTE ** buffer,INT32 * size)6105 UINT16 TPMS_CREATION_INFO_Marshal(TPMS_CREATION_INFO* source,
6106 BYTE** buffer,
6107 INT32* size) {
6108 UINT16 total_size = 0;
6109 total_size += TPM2B_NAME_Marshal(&source->objectName, buffer, size);
6110 total_size += TPM2B_DIGEST_Marshal(&source->creationHash, buffer, size);
6111 return total_size;
6112 }
6113
TPMS_CREATION_INFO_Unmarshal(TPMS_CREATION_INFO * target,BYTE ** buffer,INT32 * size)6114 TPM_RC TPMS_CREATION_INFO_Unmarshal(TPMS_CREATION_INFO* target,
6115 BYTE** buffer,
6116 INT32* size) {
6117 TPM_RC result;
6118 result = TPM2B_NAME_Unmarshal(&target->objectName, buffer, size);
6119 if (result != TPM_RC_SUCCESS) {
6120 return result;
6121 }
6122 result = TPM2B_DIGEST_Unmarshal(&target->creationHash, buffer, size);
6123 if (result != TPM_RC_SUCCESS) {
6124 return result;
6125 }
6126 return TPM_RC_SUCCESS;
6127 }
6128
TPMS_COMMAND_AUDIT_INFO_Marshal(TPMS_COMMAND_AUDIT_INFO * source,BYTE ** buffer,INT32 * size)6129 UINT16 TPMS_COMMAND_AUDIT_INFO_Marshal(TPMS_COMMAND_AUDIT_INFO* source,
6130 BYTE** buffer,
6131 INT32* size) {
6132 UINT16 total_size = 0;
6133 total_size += UINT64_Marshal(&source->auditCounter, buffer, size);
6134 total_size += TPM_ALG_ID_Marshal(&source->digestAlg, buffer, size);
6135 total_size += TPM2B_DIGEST_Marshal(&source->auditDigest, buffer, size);
6136 total_size += TPM2B_DIGEST_Marshal(&source->commandDigest, buffer, size);
6137 return total_size;
6138 }
6139
TPMS_COMMAND_AUDIT_INFO_Unmarshal(TPMS_COMMAND_AUDIT_INFO * target,BYTE ** buffer,INT32 * size)6140 TPM_RC TPMS_COMMAND_AUDIT_INFO_Unmarshal(TPMS_COMMAND_AUDIT_INFO* target,
6141 BYTE** buffer,
6142 INT32* size) {
6143 TPM_RC result;
6144 result = UINT64_Unmarshal(&target->auditCounter, buffer, size);
6145 if (result != TPM_RC_SUCCESS) {
6146 return result;
6147 }
6148 result = TPM_ALG_ID_Unmarshal(&target->digestAlg, buffer, size);
6149 if (result != TPM_RC_SUCCESS) {
6150 return result;
6151 }
6152 result = TPM2B_DIGEST_Unmarshal(&target->auditDigest, buffer, size);
6153 if (result != TPM_RC_SUCCESS) {
6154 return result;
6155 }
6156 result = TPM2B_DIGEST_Unmarshal(&target->commandDigest, buffer, size);
6157 if (result != TPM_RC_SUCCESS) {
6158 return result;
6159 }
6160 return TPM_RC_SUCCESS;
6161 }
6162
TPMS_QUOTE_INFO_Marshal(TPMS_QUOTE_INFO * source,BYTE ** buffer,INT32 * size)6163 UINT16 TPMS_QUOTE_INFO_Marshal(TPMS_QUOTE_INFO* source,
6164 BYTE** buffer,
6165 INT32* size) {
6166 UINT16 total_size = 0;
6167 total_size += TPML_PCR_SELECTION_Marshal(&source->pcrSelect, buffer, size);
6168 total_size += TPM2B_DIGEST_Marshal(&source->pcrDigest, buffer, size);
6169 return total_size;
6170 }
6171
TPMS_QUOTE_INFO_Unmarshal(TPMS_QUOTE_INFO * target,BYTE ** buffer,INT32 * size)6172 TPM_RC TPMS_QUOTE_INFO_Unmarshal(TPMS_QUOTE_INFO* target,
6173 BYTE** buffer,
6174 INT32* size) {
6175 TPM_RC result;
6176 result = TPML_PCR_SELECTION_Unmarshal(&target->pcrSelect, buffer, size);
6177 if (result != TPM_RC_SUCCESS) {
6178 return result;
6179 }
6180 result = TPM2B_DIGEST_Unmarshal(&target->pcrDigest, buffer, size);
6181 if (result != TPM_RC_SUCCESS) {
6182 return result;
6183 }
6184 return TPM_RC_SUCCESS;
6185 }
6186
TPMS_CERTIFY_INFO_Marshal(TPMS_CERTIFY_INFO * source,BYTE ** buffer,INT32 * size)6187 UINT16 TPMS_CERTIFY_INFO_Marshal(TPMS_CERTIFY_INFO* source,
6188 BYTE** buffer,
6189 INT32* size) {
6190 UINT16 total_size = 0;
6191 total_size += TPM2B_NAME_Marshal(&source->name, buffer, size);
6192 total_size += TPM2B_NAME_Marshal(&source->qualifiedName, buffer, size);
6193 return total_size;
6194 }
6195
TPMS_CERTIFY_INFO_Unmarshal(TPMS_CERTIFY_INFO * target,BYTE ** buffer,INT32 * size)6196 TPM_RC TPMS_CERTIFY_INFO_Unmarshal(TPMS_CERTIFY_INFO* target,
6197 BYTE** buffer,
6198 INT32* size) {
6199 TPM_RC result;
6200 result = TPM2B_NAME_Unmarshal(&target->name, buffer, size);
6201 if (result != TPM_RC_SUCCESS) {
6202 return result;
6203 }
6204 result = TPM2B_NAME_Unmarshal(&target->qualifiedName, buffer, size);
6205 if (result != TPM_RC_SUCCESS) {
6206 return result;
6207 }
6208 return TPM_RC_SUCCESS;
6209 }
6210
TPMS_SESSION_AUDIT_INFO_Marshal(TPMS_SESSION_AUDIT_INFO * source,BYTE ** buffer,INT32 * size)6211 UINT16 TPMS_SESSION_AUDIT_INFO_Marshal(TPMS_SESSION_AUDIT_INFO* source,
6212 BYTE** buffer,
6213 INT32* size) {
6214 UINT16 total_size = 0;
6215 total_size += TPMI_YES_NO_Marshal(&source->exclusiveSession, buffer, size);
6216 total_size += TPM2B_DIGEST_Marshal(&source->sessionDigest, buffer, size);
6217 return total_size;
6218 }
6219
TPMS_SESSION_AUDIT_INFO_Unmarshal(TPMS_SESSION_AUDIT_INFO * target,BYTE ** buffer,INT32 * size)6220 TPM_RC TPMS_SESSION_AUDIT_INFO_Unmarshal(TPMS_SESSION_AUDIT_INFO* target,
6221 BYTE** buffer,
6222 INT32* size) {
6223 TPM_RC result;
6224 result = TPMI_YES_NO_Unmarshal(&target->exclusiveSession, buffer, size);
6225 if (result != TPM_RC_SUCCESS) {
6226 return result;
6227 }
6228 result = TPM2B_DIGEST_Unmarshal(&target->sessionDigest, buffer, size);
6229 if (result != TPM_RC_SUCCESS) {
6230 return result;
6231 }
6232 return TPM_RC_SUCCESS;
6233 }
6234
TPMS_CLOCK_INFO_Marshal(TPMS_CLOCK_INFO * source,BYTE ** buffer,INT32 * size)6235 UINT16 TPMS_CLOCK_INFO_Marshal(TPMS_CLOCK_INFO* source,
6236 BYTE** buffer,
6237 INT32* size) {
6238 UINT16 total_size = 0;
6239 total_size += UINT64_Marshal(&source->clock, buffer, size);
6240 total_size += UINT32_Marshal(&source->resetCount, buffer, size);
6241 total_size += UINT32_Marshal(&source->restartCount, buffer, size);
6242 total_size += TPMI_YES_NO_Marshal(&source->safe, buffer, size);
6243 return total_size;
6244 }
6245
TPMS_CLOCK_INFO_Unmarshal(TPMS_CLOCK_INFO * target,BYTE ** buffer,INT32 * size)6246 TPM_RC TPMS_CLOCK_INFO_Unmarshal(TPMS_CLOCK_INFO* target,
6247 BYTE** buffer,
6248 INT32* size) {
6249 TPM_RC result;
6250 result = UINT64_Unmarshal(&target->clock, buffer, size);
6251 if (result != TPM_RC_SUCCESS) {
6252 return result;
6253 }
6254 result = UINT32_Unmarshal(&target->resetCount, buffer, size);
6255 if (result != TPM_RC_SUCCESS) {
6256 return result;
6257 }
6258 result = UINT32_Unmarshal(&target->restartCount, buffer, size);
6259 if (result != TPM_RC_SUCCESS) {
6260 return result;
6261 }
6262 result = TPMI_YES_NO_Unmarshal(&target->safe, buffer, size);
6263 if (result != TPM_RC_SUCCESS) {
6264 return result;
6265 }
6266 return TPM_RC_SUCCESS;
6267 }
6268
TPMS_TIME_INFO_Marshal(TPMS_TIME_INFO * source,BYTE ** buffer,INT32 * size)6269 UINT16 TPMS_TIME_INFO_Marshal(TPMS_TIME_INFO* source,
6270 BYTE** buffer,
6271 INT32* size) {
6272 UINT16 total_size = 0;
6273 total_size += UINT64_Marshal(&source->time, buffer, size);
6274 total_size += TPMS_CLOCK_INFO_Marshal(&source->clockInfo, buffer, size);
6275 return total_size;
6276 }
6277
TPMS_TIME_INFO_Unmarshal(TPMS_TIME_INFO * target,BYTE ** buffer,INT32 * size)6278 TPM_RC TPMS_TIME_INFO_Unmarshal(TPMS_TIME_INFO* target,
6279 BYTE** buffer,
6280 INT32* size) {
6281 TPM_RC result;
6282 result = UINT64_Unmarshal(&target->time, buffer, size);
6283 if (result != TPM_RC_SUCCESS) {
6284 return result;
6285 }
6286 result = TPMS_CLOCK_INFO_Unmarshal(&target->clockInfo, buffer, size);
6287 if (result != TPM_RC_SUCCESS) {
6288 return result;
6289 }
6290 return TPM_RC_SUCCESS;
6291 }
6292
TPMS_TIME_ATTEST_INFO_Marshal(TPMS_TIME_ATTEST_INFO * source,BYTE ** buffer,INT32 * size)6293 UINT16 TPMS_TIME_ATTEST_INFO_Marshal(TPMS_TIME_ATTEST_INFO* source,
6294 BYTE** buffer,
6295 INT32* size) {
6296 UINT16 total_size = 0;
6297 total_size += TPMS_TIME_INFO_Marshal(&source->time, buffer, size);
6298 total_size += UINT64_Marshal(&source->firmwareVersion, buffer, size);
6299 return total_size;
6300 }
6301
TPMS_TIME_ATTEST_INFO_Unmarshal(TPMS_TIME_ATTEST_INFO * target,BYTE ** buffer,INT32 * size)6302 TPM_RC TPMS_TIME_ATTEST_INFO_Unmarshal(TPMS_TIME_ATTEST_INFO* target,
6303 BYTE** buffer,
6304 INT32* size) {
6305 TPM_RC result;
6306 result = TPMS_TIME_INFO_Unmarshal(&target->time, buffer, size);
6307 if (result != TPM_RC_SUCCESS) {
6308 return result;
6309 }
6310 result = UINT64_Unmarshal(&target->firmwareVersion, buffer, size);
6311 if (result != TPM_RC_SUCCESS) {
6312 return result;
6313 }
6314 return TPM_RC_SUCCESS;
6315 }
6316
TPMS_NV_CERTIFY_INFO_Marshal(TPMS_NV_CERTIFY_INFO * source,BYTE ** buffer,INT32 * size)6317 UINT16 TPMS_NV_CERTIFY_INFO_Marshal(TPMS_NV_CERTIFY_INFO* source,
6318 BYTE** buffer,
6319 INT32* size) {
6320 UINT16 total_size = 0;
6321 total_size += TPM2B_NAME_Marshal(&source->indexName, buffer, size);
6322 total_size += UINT16_Marshal(&source->offset, buffer, size);
6323 total_size += TPM2B_MAX_NV_BUFFER_Marshal(&source->nvContents, buffer, size);
6324 return total_size;
6325 }
6326
TPMS_NV_CERTIFY_INFO_Unmarshal(TPMS_NV_CERTIFY_INFO * target,BYTE ** buffer,INT32 * size)6327 TPM_RC TPMS_NV_CERTIFY_INFO_Unmarshal(TPMS_NV_CERTIFY_INFO* target,
6328 BYTE** buffer,
6329 INT32* size) {
6330 TPM_RC result;
6331 result = TPM2B_NAME_Unmarshal(&target->indexName, buffer, size);
6332 if (result != TPM_RC_SUCCESS) {
6333 return result;
6334 }
6335 result = UINT16_Unmarshal(&target->offset, buffer, size);
6336 if (result != TPM_RC_SUCCESS) {
6337 return result;
6338 }
6339 result = TPM2B_MAX_NV_BUFFER_Unmarshal(&target->nvContents, buffer, size);
6340 if (result != TPM_RC_SUCCESS) {
6341 return result;
6342 }
6343 return TPM_RC_SUCCESS;
6344 }
6345
TPMU_ATTEST_Marshal(TPMU_ATTEST * source,BYTE ** buffer,INT32 * size,UINT32 selector)6346 UINT16 TPMU_ATTEST_Marshal(TPMU_ATTEST* source,
6347 BYTE** buffer,
6348 INT32* size,
6349 UINT32 selector) {
6350 switch (selector) {
6351 case TPM_ST_ATTEST_CERTIFY:
6352 return TPMS_CERTIFY_INFO_Marshal((TPMS_CERTIFY_INFO*)&source->certify,
6353 buffer, size);
6354 case TPM_ST_ATTEST_CREATION:
6355 return TPMS_CREATION_INFO_Marshal((TPMS_CREATION_INFO*)&source->creation,
6356 buffer, size);
6357 case TPM_ST_ATTEST_QUOTE:
6358 return TPMS_QUOTE_INFO_Marshal((TPMS_QUOTE_INFO*)&source->quote, buffer,
6359 size);
6360 case TPM_ST_ATTEST_COMMAND_AUDIT:
6361 return TPMS_COMMAND_AUDIT_INFO_Marshal(
6362 (TPMS_COMMAND_AUDIT_INFO*)&source->commandAudit, buffer, size);
6363 case TPM_ST_ATTEST_SESSION_AUDIT:
6364 return TPMS_SESSION_AUDIT_INFO_Marshal(
6365 (TPMS_SESSION_AUDIT_INFO*)&source->sessionAudit, buffer, size);
6366 case TPM_ST_ATTEST_TIME:
6367 return TPMS_TIME_ATTEST_INFO_Marshal(
6368 (TPMS_TIME_ATTEST_INFO*)&source->time, buffer, size);
6369 case TPM_ST_ATTEST_NV:
6370 return TPMS_NV_CERTIFY_INFO_Marshal((TPMS_NV_CERTIFY_INFO*)&source->nv,
6371 buffer, size);
6372 }
6373 return 0;
6374 }
6375
TPMU_ATTEST_Unmarshal(TPMU_ATTEST * target,BYTE ** buffer,INT32 * size,UINT32 selector)6376 TPM_RC TPMU_ATTEST_Unmarshal(TPMU_ATTEST* target,
6377 BYTE** buffer,
6378 INT32* size,
6379 UINT32 selector) {
6380 switch (selector) {
6381 case TPM_ST_ATTEST_CERTIFY:
6382 return TPMS_CERTIFY_INFO_Unmarshal((TPMS_CERTIFY_INFO*)&target->certify,
6383 buffer, size);
6384 case TPM_ST_ATTEST_CREATION:
6385 return TPMS_CREATION_INFO_Unmarshal(
6386 (TPMS_CREATION_INFO*)&target->creation, buffer, size);
6387 case TPM_ST_ATTEST_QUOTE:
6388 return TPMS_QUOTE_INFO_Unmarshal((TPMS_QUOTE_INFO*)&target->quote, buffer,
6389 size);
6390 case TPM_ST_ATTEST_COMMAND_AUDIT:
6391 return TPMS_COMMAND_AUDIT_INFO_Unmarshal(
6392 (TPMS_COMMAND_AUDIT_INFO*)&target->commandAudit, buffer, size);
6393 case TPM_ST_ATTEST_SESSION_AUDIT:
6394 return TPMS_SESSION_AUDIT_INFO_Unmarshal(
6395 (TPMS_SESSION_AUDIT_INFO*)&target->sessionAudit, buffer, size);
6396 case TPM_ST_ATTEST_TIME:
6397 return TPMS_TIME_ATTEST_INFO_Unmarshal(
6398 (TPMS_TIME_ATTEST_INFO*)&target->time, buffer, size);
6399 case TPM_ST_ATTEST_NV:
6400 return TPMS_NV_CERTIFY_INFO_Unmarshal((TPMS_NV_CERTIFY_INFO*)&target->nv,
6401 buffer, size);
6402 }
6403 return TPM_RC_SELECTOR;
6404 }
6405
TPMS_ATTEST_Marshal(TPMS_ATTEST * source,BYTE ** buffer,INT32 * size)6406 UINT16 TPMS_ATTEST_Marshal(TPMS_ATTEST* source, BYTE** buffer, INT32* size) {
6407 UINT16 total_size = 0;
6408 total_size += TPM_GENERATED_Marshal(&source->magic, buffer, size);
6409 total_size += TPMI_ST_ATTEST_Marshal(&source->type, buffer, size);
6410 total_size += TPM2B_NAME_Marshal(&source->qualifiedSigner, buffer, size);
6411 total_size += TPM2B_DATA_Marshal(&source->extraData, buffer, size);
6412 total_size += TPMS_CLOCK_INFO_Marshal(&source->clockInfo, buffer, size);
6413 total_size += UINT64_Marshal(&source->firmwareVersion, buffer, size);
6414 total_size +=
6415 TPMU_ATTEST_Marshal(&source->attested, buffer, size, source->type);
6416 return total_size;
6417 }
6418
TPMS_ATTEST_Unmarshal(TPMS_ATTEST * target,BYTE ** buffer,INT32 * size)6419 TPM_RC TPMS_ATTEST_Unmarshal(TPMS_ATTEST* target, BYTE** buffer, INT32* size) {
6420 TPM_RC result;
6421 result = TPM_GENERATED_Unmarshal(&target->magic, buffer, size);
6422 if (result != TPM_RC_SUCCESS) {
6423 return result;
6424 }
6425 result = TPMI_ST_ATTEST_Unmarshal(&target->type, buffer, size);
6426 if (result != TPM_RC_SUCCESS) {
6427 return result;
6428 }
6429 result = TPM2B_NAME_Unmarshal(&target->qualifiedSigner, buffer, size);
6430 if (result != TPM_RC_SUCCESS) {
6431 return result;
6432 }
6433 result = TPM2B_DATA_Unmarshal(&target->extraData, buffer, size);
6434 if (result != TPM_RC_SUCCESS) {
6435 return result;
6436 }
6437 result = TPMS_CLOCK_INFO_Unmarshal(&target->clockInfo, buffer, size);
6438 if (result != TPM_RC_SUCCESS) {
6439 return result;
6440 }
6441 result = UINT64_Unmarshal(&target->firmwareVersion, buffer, size);
6442 if (result != TPM_RC_SUCCESS) {
6443 return result;
6444 }
6445 result = TPMU_ATTEST_Unmarshal(&target->attested, buffer, size, target->type);
6446 if (result != TPM_RC_SUCCESS) {
6447 return result;
6448 }
6449 return TPM_RC_SUCCESS;
6450 }
6451
TPMS_AUTH_COMMAND_Marshal(TPMS_AUTH_COMMAND * source,BYTE ** buffer,INT32 * size)6452 UINT16 TPMS_AUTH_COMMAND_Marshal(TPMS_AUTH_COMMAND* source,
6453 BYTE** buffer,
6454 INT32* size) {
6455 UINT16 total_size = 0;
6456 total_size +=
6457 TPMI_SH_AUTH_SESSION_Marshal(&source->sessionHandle, buffer, size);
6458 total_size += TPM2B_NONCE_Marshal(&source->nonce, buffer, size);
6459 total_size += TPMA_SESSION_Marshal(&source->sessionAttributes, buffer, size);
6460 total_size += TPM2B_AUTH_Marshal(&source->hmac, buffer, size);
6461 return total_size;
6462 }
6463
TPMS_AUTH_COMMAND_Unmarshal(TPMS_AUTH_COMMAND * target,BYTE ** buffer,INT32 * size)6464 TPM_RC TPMS_AUTH_COMMAND_Unmarshal(TPMS_AUTH_COMMAND* target,
6465 BYTE** buffer,
6466 INT32* size) {
6467 TPM_RC result;
6468 result = TPMI_SH_AUTH_SESSION_Unmarshal(&target->sessionHandle, buffer, size,
6469 TRUE);
6470 if (result != TPM_RC_SUCCESS) {
6471 return result;
6472 }
6473 result = TPM2B_NONCE_Unmarshal(&target->nonce, buffer, size);
6474 if (result != TPM_RC_SUCCESS) {
6475 return result;
6476 }
6477 result = TPMA_SESSION_Unmarshal(&target->sessionAttributes, buffer, size);
6478 if (result != TPM_RC_SUCCESS) {
6479 return result;
6480 }
6481 result = TPM2B_AUTH_Unmarshal(&target->hmac, buffer, size);
6482 if (result != TPM_RC_SUCCESS) {
6483 return result;
6484 }
6485 return TPM_RC_SUCCESS;
6486 }
6487
TPMS_AUTH_RESPONSE_Marshal(TPMS_AUTH_RESPONSE * source,BYTE ** buffer,INT32 * size)6488 UINT16 TPMS_AUTH_RESPONSE_Marshal(TPMS_AUTH_RESPONSE* source,
6489 BYTE** buffer,
6490 INT32* size) {
6491 UINT16 total_size = 0;
6492 total_size += TPM2B_NONCE_Marshal(&source->nonce, buffer, size);
6493 total_size += TPMA_SESSION_Marshal(&source->sessionAttributes, buffer, size);
6494 total_size += TPM2B_AUTH_Marshal(&source->hmac, buffer, size);
6495 return total_size;
6496 }
6497
TPMS_AUTH_RESPONSE_Unmarshal(TPMS_AUTH_RESPONSE * target,BYTE ** buffer,INT32 * size)6498 TPM_RC TPMS_AUTH_RESPONSE_Unmarshal(TPMS_AUTH_RESPONSE* target,
6499 BYTE** buffer,
6500 INT32* size) {
6501 TPM_RC result;
6502 result = TPM2B_NONCE_Unmarshal(&target->nonce, buffer, size);
6503 if (result != TPM_RC_SUCCESS) {
6504 return result;
6505 }
6506 result = TPMA_SESSION_Unmarshal(&target->sessionAttributes, buffer, size);
6507 if (result != TPM_RC_SUCCESS) {
6508 return result;
6509 }
6510 result = TPM2B_AUTH_Unmarshal(&target->hmac, buffer, size);
6511 if (result != TPM_RC_SUCCESS) {
6512 return result;
6513 }
6514 return TPM_RC_SUCCESS;
6515 }
6516
TPM_CAP_Marshal(TPM_CAP * source,BYTE ** buffer,INT32 * size)6517 UINT16 TPM_CAP_Marshal(TPM_CAP* source, BYTE** buffer, INT32* size) {
6518 return uint32_t_Marshal(source, buffer, size);
6519 }
6520
TPM_CAP_Unmarshal(TPM_CAP * target,BYTE ** buffer,INT32 * size)6521 TPM_RC TPM_CAP_Unmarshal(TPM_CAP* target, BYTE** buffer, INT32* size) {
6522 TPM_RC result;
6523 result = uint32_t_Unmarshal(target, buffer, size);
6524 if (result != TPM_RC_SUCCESS) {
6525 return result;
6526 }
6527 if (*target == TPM_CAP_FIRST) {
6528 return TPM_RC_SUCCESS;
6529 }
6530 if (*target == TPM_CAP_ALGS) {
6531 return TPM_RC_SUCCESS;
6532 }
6533 if (*target == TPM_CAP_HANDLES) {
6534 return TPM_RC_SUCCESS;
6535 }
6536 if (*target == TPM_CAP_COMMANDS) {
6537 return TPM_RC_SUCCESS;
6538 }
6539 if (*target == TPM_CAP_PP_COMMANDS) {
6540 return TPM_RC_SUCCESS;
6541 }
6542 if (*target == TPM_CAP_AUDIT_COMMANDS) {
6543 return TPM_RC_SUCCESS;
6544 }
6545 if (*target == TPM_CAP_PCRS) {
6546 return TPM_RC_SUCCESS;
6547 }
6548 if (*target == TPM_CAP_TPM_PROPERTIES) {
6549 return TPM_RC_SUCCESS;
6550 }
6551 if (*target == TPM_CAP_PCR_PROPERTIES) {
6552 return TPM_RC_SUCCESS;
6553 }
6554 if (*target == TPM_CAP_ECC_CURVES) {
6555 return TPM_RC_SUCCESS;
6556 }
6557 if (*target == TPM_CAP_LAST) {
6558 return TPM_RC_SUCCESS;
6559 }
6560 if (*target == TPM_CAP_VENDOR_PROPERTY) {
6561 return TPM_RC_SUCCESS;
6562 }
6563 return TPM_RC_VALUE;
6564 }
6565
TPMU_CAPABILITIES_Marshal(TPMU_CAPABILITIES * source,BYTE ** buffer,INT32 * size,UINT32 selector)6566 UINT16 TPMU_CAPABILITIES_Marshal(TPMU_CAPABILITIES* source,
6567 BYTE** buffer,
6568 INT32* size,
6569 UINT32 selector) {
6570 switch (selector) {
6571 case TPM_CAP_ALGS:
6572 return TPML_ALG_PROPERTY_Marshal((TPML_ALG_PROPERTY*)&source->algorithms,
6573 buffer, size);
6574 case TPM_CAP_HANDLES:
6575 return TPML_HANDLE_Marshal((TPML_HANDLE*)&source->handles, buffer, size);
6576 case TPM_CAP_COMMANDS:
6577 return TPML_CCA_Marshal((TPML_CCA*)&source->command, buffer, size);
6578 case TPM_CAP_PP_COMMANDS:
6579 return TPML_CC_Marshal((TPML_CC*)&source->ppCommands, buffer, size);
6580 case TPM_CAP_AUDIT_COMMANDS:
6581 return TPML_CC_Marshal((TPML_CC*)&source->auditCommands, buffer, size);
6582 case TPM_CAP_PCRS:
6583 return TPML_PCR_SELECTION_Marshal(
6584 (TPML_PCR_SELECTION*)&source->assignedPCR, buffer, size);
6585 case TPM_CAP_TPM_PROPERTIES:
6586 return TPML_TAGGED_TPM_PROPERTY_Marshal(
6587 (TPML_TAGGED_TPM_PROPERTY*)&source->tpmProperties, buffer, size);
6588 case TPM_CAP_PCR_PROPERTIES:
6589 return TPML_TAGGED_PCR_PROPERTY_Marshal(
6590 (TPML_TAGGED_PCR_PROPERTY*)&source->pcrProperties, buffer, size);
6591 case TPM_CAP_ECC_CURVES:
6592 return TPML_ECC_CURVE_Marshal((TPML_ECC_CURVE*)&source->eccCurves, buffer,
6593 size);
6594 }
6595 return 0;
6596 }
6597
TPMU_CAPABILITIES_Unmarshal(TPMU_CAPABILITIES * target,BYTE ** buffer,INT32 * size,UINT32 selector)6598 TPM_RC TPMU_CAPABILITIES_Unmarshal(TPMU_CAPABILITIES* target,
6599 BYTE** buffer,
6600 INT32* size,
6601 UINT32 selector) {
6602 switch (selector) {
6603 case TPM_CAP_ALGS:
6604 return TPML_ALG_PROPERTY_Unmarshal(
6605 (TPML_ALG_PROPERTY*)&target->algorithms, buffer, size);
6606 case TPM_CAP_HANDLES:
6607 return TPML_HANDLE_Unmarshal((TPML_HANDLE*)&target->handles, buffer,
6608 size);
6609 case TPM_CAP_COMMANDS:
6610 return TPML_CCA_Unmarshal((TPML_CCA*)&target->command, buffer, size);
6611 case TPM_CAP_PP_COMMANDS:
6612 return TPML_CC_Unmarshal((TPML_CC*)&target->ppCommands, buffer, size);
6613 case TPM_CAP_AUDIT_COMMANDS:
6614 return TPML_CC_Unmarshal((TPML_CC*)&target->auditCommands, buffer, size);
6615 case TPM_CAP_PCRS:
6616 return TPML_PCR_SELECTION_Unmarshal(
6617 (TPML_PCR_SELECTION*)&target->assignedPCR, buffer, size);
6618 case TPM_CAP_TPM_PROPERTIES:
6619 return TPML_TAGGED_TPM_PROPERTY_Unmarshal(
6620 (TPML_TAGGED_TPM_PROPERTY*)&target->tpmProperties, buffer, size);
6621 case TPM_CAP_PCR_PROPERTIES:
6622 return TPML_TAGGED_PCR_PROPERTY_Unmarshal(
6623 (TPML_TAGGED_PCR_PROPERTY*)&target->pcrProperties, buffer, size);
6624 case TPM_CAP_ECC_CURVES:
6625 return TPML_ECC_CURVE_Unmarshal((TPML_ECC_CURVE*)&target->eccCurves,
6626 buffer, size);
6627 }
6628 return TPM_RC_SELECTOR;
6629 }
6630
TPMS_CAPABILITY_DATA_Marshal(TPMS_CAPABILITY_DATA * source,BYTE ** buffer,INT32 * size)6631 UINT16 TPMS_CAPABILITY_DATA_Marshal(TPMS_CAPABILITY_DATA* source,
6632 BYTE** buffer,
6633 INT32* size) {
6634 UINT16 total_size = 0;
6635 total_size += TPM_CAP_Marshal(&source->capability, buffer, size);
6636 total_size += TPMU_CAPABILITIES_Marshal(&source->data, buffer, size,
6637 source->capability);
6638 return total_size;
6639 }
6640
TPMS_CAPABILITY_DATA_Unmarshal(TPMS_CAPABILITY_DATA * target,BYTE ** buffer,INT32 * size)6641 TPM_RC TPMS_CAPABILITY_DATA_Unmarshal(TPMS_CAPABILITY_DATA* target,
6642 BYTE** buffer,
6643 INT32* size) {
6644 TPM_RC result;
6645 result = TPM_CAP_Unmarshal(&target->capability, buffer, size);
6646 if (result != TPM_RC_SUCCESS) {
6647 return result;
6648 }
6649 result = TPMU_CAPABILITIES_Unmarshal(&target->data, buffer, size,
6650 target->capability);
6651 if (result != TPM_RC_SUCCESS) {
6652 return result;
6653 }
6654 return TPM_RC_SUCCESS;
6655 }
6656
TPMS_CONTEXT_Marshal(TPMS_CONTEXT * source,BYTE ** buffer,INT32 * size)6657 UINT16 TPMS_CONTEXT_Marshal(TPMS_CONTEXT* source, BYTE** buffer, INT32* size) {
6658 UINT16 total_size = 0;
6659 total_size += UINT64_Marshal(&source->sequence, buffer, size);
6660 total_size += TPMI_DH_CONTEXT_Marshal(&source->savedHandle, buffer, size);
6661 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
6662 total_size += TPM2B_CONTEXT_DATA_Marshal(&source->contextBlob, buffer, size);
6663 return total_size;
6664 }
6665
TPMS_CONTEXT_Unmarshal(TPMS_CONTEXT * target,BYTE ** buffer,INT32 * size)6666 TPM_RC TPMS_CONTEXT_Unmarshal(TPMS_CONTEXT* target,
6667 BYTE** buffer,
6668 INT32* size) {
6669 TPM_RC result;
6670 result = UINT64_Unmarshal(&target->sequence, buffer, size);
6671 if (result != TPM_RC_SUCCESS) {
6672 return result;
6673 }
6674 result = TPMI_DH_CONTEXT_Unmarshal(&target->savedHandle, buffer, size);
6675 if (result != TPM_RC_SUCCESS) {
6676 return result;
6677 }
6678 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
6679 if (result != TPM_RC_SUCCESS) {
6680 return result;
6681 }
6682 result = TPM2B_CONTEXT_DATA_Unmarshal(&target->contextBlob, buffer, size);
6683 if (result != TPM_RC_SUCCESS) {
6684 return result;
6685 }
6686 return TPM_RC_SUCCESS;
6687 }
6688
TPMS_CONTEXT_DATA_Marshal(TPMS_CONTEXT_DATA * source,BYTE ** buffer,INT32 * size)6689 UINT16 TPMS_CONTEXT_DATA_Marshal(TPMS_CONTEXT_DATA* source,
6690 BYTE** buffer,
6691 INT32* size) {
6692 UINT16 total_size = 0;
6693 total_size += TPM2B_DIGEST_Marshal(&source->integrity, buffer, size);
6694 total_size +=
6695 TPM2B_CONTEXT_SENSITIVE_Marshal(&source->encrypted, buffer, size);
6696 return total_size;
6697 }
6698
TPMS_CONTEXT_DATA_Unmarshal(TPMS_CONTEXT_DATA * target,BYTE ** buffer,INT32 * size)6699 TPM_RC TPMS_CONTEXT_DATA_Unmarshal(TPMS_CONTEXT_DATA* target,
6700 BYTE** buffer,
6701 INT32* size) {
6702 TPM_RC result;
6703 result = TPM2B_DIGEST_Unmarshal(&target->integrity, buffer, size);
6704 if (result != TPM_RC_SUCCESS) {
6705 return result;
6706 }
6707 result = TPM2B_CONTEXT_SENSITIVE_Unmarshal(&target->encrypted, buffer, size);
6708 if (result != TPM_RC_SUCCESS) {
6709 return result;
6710 }
6711 return TPM_RC_SUCCESS;
6712 }
6713
TPMS_PCR_SELECT_Marshal(TPMS_PCR_SELECT * source,BYTE ** buffer,INT32 * size)6714 UINT16 TPMS_PCR_SELECT_Marshal(TPMS_PCR_SELECT* source,
6715 BYTE** buffer,
6716 INT32* size) {
6717 UINT16 total_size = 0;
6718 INT32 i;
6719 total_size += UINT8_Marshal(&source->sizeofSelect, buffer, size);
6720 for (i = 0; i < source->sizeofSelect; ++i) {
6721 total_size += BYTE_Marshal(&source->pcrSelect[i], buffer, size);
6722 }
6723 return total_size;
6724 }
6725
TPMS_PCR_SELECT_Unmarshal(TPMS_PCR_SELECT * target,BYTE ** buffer,INT32 * size)6726 TPM_RC TPMS_PCR_SELECT_Unmarshal(TPMS_PCR_SELECT* target,
6727 BYTE** buffer,
6728 INT32* size) {
6729 TPM_RC result;
6730 INT32 i;
6731 result = UINT8_Unmarshal(&target->sizeofSelect, buffer, size);
6732 if (result != TPM_RC_SUCCESS) {
6733 return result;
6734 }
6735 if (target->sizeofSelect > PCR_SELECT_MAX) {
6736 return TPM_RC_VALUE;
6737 }
6738 if (target->sizeofSelect < PCR_SELECT_MIN) {
6739 return TPM_RC_VALUE;
6740 }
6741 for (i = 0; i < target->sizeofSelect; ++i) {
6742 result = BYTE_Unmarshal(&target->pcrSelect[i], buffer, size);
6743 if (result != TPM_RC_SUCCESS) {
6744 return result;
6745 }
6746 }
6747 return TPM_RC_SUCCESS;
6748 }
6749
TPMS_SIGNATURE_ECC_Marshal(TPMS_SIGNATURE_ECC * source,BYTE ** buffer,INT32 * size)6750 UINT16 TPMS_SIGNATURE_ECC_Marshal(TPMS_SIGNATURE_ECC* source,
6751 BYTE** buffer,
6752 INT32* size) {
6753 UINT16 total_size = 0;
6754 total_size += TPMI_ALG_HASH_Marshal(&source->hash, buffer, size);
6755 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->signatureR, buffer, size);
6756 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->signatureS, buffer, size);
6757 return total_size;
6758 }
6759
TPMS_SIGNATURE_ECC_Unmarshal(TPMS_SIGNATURE_ECC * target,BYTE ** buffer,INT32 * size)6760 TPM_RC TPMS_SIGNATURE_ECC_Unmarshal(TPMS_SIGNATURE_ECC* target,
6761 BYTE** buffer,
6762 INT32* size) {
6763 TPM_RC result;
6764 result = TPMI_ALG_HASH_Unmarshal(&target->hash, buffer, size, FALSE);
6765 if (result != TPM_RC_SUCCESS) {
6766 return result;
6767 }
6768 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->signatureR, buffer, size);
6769 if (result != TPM_RC_SUCCESS) {
6770 return result;
6771 }
6772 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->signatureS, buffer, size);
6773 if (result != TPM_RC_SUCCESS) {
6774 return result;
6775 }
6776 return TPM_RC_SUCCESS;
6777 }
6778
TPMS_SIGNATURE_ECDAA_Marshal(TPMS_SIGNATURE_ECDAA * source,BYTE ** buffer,INT32 * size)6779 UINT16 TPMS_SIGNATURE_ECDAA_Marshal(TPMS_SIGNATURE_ECDAA* source,
6780 BYTE** buffer,
6781 INT32* size) {
6782 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6783 }
6784
TPMS_SIGNATURE_ECDAA_Unmarshal(TPMS_SIGNATURE_ECDAA * target,BYTE ** buffer,INT32 * size)6785 TPM_RC TPMS_SIGNATURE_ECDAA_Unmarshal(TPMS_SIGNATURE_ECDAA* target,
6786 BYTE** buffer,
6787 INT32* size) {
6788 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6789 }
6790
TPMS_SIGNATURE_ECDSA_Marshal(TPMS_SIGNATURE_ECDSA * source,BYTE ** buffer,INT32 * size)6791 UINT16 TPMS_SIGNATURE_ECDSA_Marshal(TPMS_SIGNATURE_ECDSA* source,
6792 BYTE** buffer,
6793 INT32* size) {
6794 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6795 }
6796
TPMS_SIGNATURE_ECDSA_Unmarshal(TPMS_SIGNATURE_ECDSA * target,BYTE ** buffer,INT32 * size)6797 TPM_RC TPMS_SIGNATURE_ECDSA_Unmarshal(TPMS_SIGNATURE_ECDSA* target,
6798 BYTE** buffer,
6799 INT32* size) {
6800 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6801 }
6802
TPMS_SIGNATURE_ECSCHNORR_Marshal(TPMS_SIGNATURE_ECSCHNORR * source,BYTE ** buffer,INT32 * size)6803 UINT16 TPMS_SIGNATURE_ECSCHNORR_Marshal(TPMS_SIGNATURE_ECSCHNORR* source,
6804 BYTE** buffer,
6805 INT32* size) {
6806 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6807 }
6808
TPMS_SIGNATURE_ECSCHNORR_Unmarshal(TPMS_SIGNATURE_ECSCHNORR * target,BYTE ** buffer,INT32 * size)6809 TPM_RC TPMS_SIGNATURE_ECSCHNORR_Unmarshal(TPMS_SIGNATURE_ECSCHNORR* target,
6810 BYTE** buffer,
6811 INT32* size) {
6812 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6813 }
6814
TPMS_SIGNATURE_RSA_Marshal(TPMS_SIGNATURE_RSA * source,BYTE ** buffer,INT32 * size)6815 UINT16 TPMS_SIGNATURE_RSA_Marshal(TPMS_SIGNATURE_RSA* source,
6816 BYTE** buffer,
6817 INT32* size) {
6818 UINT16 total_size = 0;
6819 total_size += TPMI_ALG_HASH_Marshal(&source->hash, buffer, size);
6820 total_size += TPM2B_PUBLIC_KEY_RSA_Marshal(&source->sig, buffer, size);
6821 return total_size;
6822 }
6823
TPMS_SIGNATURE_RSA_Unmarshal(TPMS_SIGNATURE_RSA * target,BYTE ** buffer,INT32 * size)6824 TPM_RC TPMS_SIGNATURE_RSA_Unmarshal(TPMS_SIGNATURE_RSA* target,
6825 BYTE** buffer,
6826 INT32* size) {
6827 TPM_RC result;
6828 result = TPMI_ALG_HASH_Unmarshal(&target->hash, buffer, size, FALSE);
6829 if (result != TPM_RC_SUCCESS) {
6830 return result;
6831 }
6832 result = TPM2B_PUBLIC_KEY_RSA_Unmarshal(&target->sig, buffer, size);
6833 if (result != TPM_RC_SUCCESS) {
6834 return result;
6835 }
6836 return TPM_RC_SUCCESS;
6837 }
6838
TPMS_SIGNATURE_RSAPSS_Marshal(TPMS_SIGNATURE_RSAPSS * source,BYTE ** buffer,INT32 * size)6839 UINT16 TPMS_SIGNATURE_RSAPSS_Marshal(TPMS_SIGNATURE_RSAPSS* source,
6840 BYTE** buffer,
6841 INT32* size) {
6842 return TPMS_SIGNATURE_RSA_Marshal(source, buffer, size);
6843 }
6844
TPMS_SIGNATURE_RSAPSS_Unmarshal(TPMS_SIGNATURE_RSAPSS * target,BYTE ** buffer,INT32 * size)6845 TPM_RC TPMS_SIGNATURE_RSAPSS_Unmarshal(TPMS_SIGNATURE_RSAPSS* target,
6846 BYTE** buffer,
6847 INT32* size) {
6848 return TPMS_SIGNATURE_RSA_Unmarshal(target, buffer, size);
6849 }
6850
TPMS_SIGNATURE_RSASSA_Marshal(TPMS_SIGNATURE_RSASSA * source,BYTE ** buffer,INT32 * size)6851 UINT16 TPMS_SIGNATURE_RSASSA_Marshal(TPMS_SIGNATURE_RSASSA* source,
6852 BYTE** buffer,
6853 INT32* size) {
6854 return TPMS_SIGNATURE_RSA_Marshal(source, buffer, size);
6855 }
6856
TPMS_SIGNATURE_RSASSA_Unmarshal(TPMS_SIGNATURE_RSASSA * target,BYTE ** buffer,INT32 * size)6857 TPM_RC TPMS_SIGNATURE_RSASSA_Unmarshal(TPMS_SIGNATURE_RSASSA* target,
6858 BYTE** buffer,
6859 INT32* size) {
6860 return TPMS_SIGNATURE_RSA_Unmarshal(target, buffer, size);
6861 }
6862
TPMS_SIGNATURE_SM2_Marshal(TPMS_SIGNATURE_SM2 * source,BYTE ** buffer,INT32 * size)6863 UINT16 TPMS_SIGNATURE_SM2_Marshal(TPMS_SIGNATURE_SM2* source,
6864 BYTE** buffer,
6865 INT32* size) {
6866 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6867 }
6868
TPMS_SIGNATURE_SM2_Unmarshal(TPMS_SIGNATURE_SM2 * target,BYTE ** buffer,INT32 * size)6869 TPM_RC TPMS_SIGNATURE_SM2_Unmarshal(TPMS_SIGNATURE_SM2* target,
6870 BYTE** buffer,
6871 INT32* size) {
6872 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6873 }
6874
TPMT_PUBLIC_PARMS_Marshal(TPMT_PUBLIC_PARMS * source,BYTE ** buffer,INT32 * size)6875 UINT16 TPMT_PUBLIC_PARMS_Marshal(TPMT_PUBLIC_PARMS* source,
6876 BYTE** buffer,
6877 INT32* size) {
6878 UINT16 total_size = 0;
6879 total_size += TPMI_ALG_PUBLIC_Marshal(&source->type, buffer, size);
6880 total_size += TPMU_PUBLIC_PARMS_Marshal(&source->parameters, buffer, size,
6881 source->type);
6882 return total_size;
6883 }
6884
TPMT_PUBLIC_PARMS_Unmarshal(TPMT_PUBLIC_PARMS * target,BYTE ** buffer,INT32 * size)6885 TPM_RC TPMT_PUBLIC_PARMS_Unmarshal(TPMT_PUBLIC_PARMS* target,
6886 BYTE** buffer,
6887 INT32* size) {
6888 TPM_RC result;
6889 result = TPMI_ALG_PUBLIC_Unmarshal(&target->type, buffer, size);
6890 if (result != TPM_RC_SUCCESS) {
6891 return result;
6892 }
6893 result = TPMU_PUBLIC_PARMS_Unmarshal(&target->parameters, buffer, size,
6894 target->type);
6895 if (result != TPM_RC_SUCCESS) {
6896 return result;
6897 }
6898 return TPM_RC_SUCCESS;
6899 }
6900
TPMT_RSA_DECRYPT_Marshal(TPMT_RSA_DECRYPT * source,BYTE ** buffer,INT32 * size)6901 UINT16 TPMT_RSA_DECRYPT_Marshal(TPMT_RSA_DECRYPT* source,
6902 BYTE** buffer,
6903 INT32* size) {
6904 UINT16 total_size = 0;
6905 total_size += TPMI_ALG_RSA_DECRYPT_Marshal(&source->scheme, buffer, size);
6906 total_size +=
6907 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
6908 return total_size;
6909 }
6910
TPMT_RSA_DECRYPT_Unmarshal(TPMT_RSA_DECRYPT * target,BYTE ** buffer,INT32 * size)6911 TPM_RC TPMT_RSA_DECRYPT_Unmarshal(TPMT_RSA_DECRYPT* target,
6912 BYTE** buffer,
6913 INT32* size) {
6914 TPM_RC result;
6915 result = TPMI_ALG_RSA_DECRYPT_Unmarshal(&target->scheme, buffer, size, TRUE);
6916 if (result != TPM_RC_SUCCESS) {
6917 return result;
6918 }
6919 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
6920 target->scheme);
6921 if (result != TPM_RC_SUCCESS) {
6922 return result;
6923 }
6924 return TPM_RC_SUCCESS;
6925 }
6926
TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE * source,BYTE ** buffer,INT32 * size,UINT32 selector)6927 UINT16 TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE* source,
6928 BYTE** buffer,
6929 INT32* size,
6930 UINT32 selector) {
6931 switch (selector) {
6932 #ifdef TPM_ALG_RSASSA
6933 case TPM_ALG_RSASSA:
6934 return TPMS_SIGNATURE_RSASSA_Marshal(
6935 (TPMS_SIGNATURE_RSASSA*)&source->rsassa, buffer, size);
6936 #endif
6937 #ifdef TPM_ALG_RSAPSS
6938 case TPM_ALG_RSAPSS:
6939 return TPMS_SIGNATURE_RSAPSS_Marshal(
6940 (TPMS_SIGNATURE_RSAPSS*)&source->rsapss, buffer, size);
6941 #endif
6942 #ifdef TPM_ALG_ECDSA
6943 case TPM_ALG_ECDSA:
6944 return TPMS_SIGNATURE_ECDSA_Marshal((TPMS_SIGNATURE_ECDSA*)&source->ecdsa,
6945 buffer, size);
6946 #endif
6947 #ifdef TPM_ALG_ECDAA
6948 case TPM_ALG_ECDAA:
6949 return TPMS_SIGNATURE_ECDAA_Marshal((TPMS_SIGNATURE_ECDAA*)&source->ecdaa,
6950 buffer, size);
6951 #endif
6952 #ifdef TPM_ALG_SM2
6953 case TPM_ALG_SM2:
6954 return TPMS_SIGNATURE_SM2_Marshal((TPMS_SIGNATURE_SM2*)&source->sm2,
6955 buffer, size);
6956 #endif
6957 #ifdef TPM_ALG_ECSCHNORR
6958 case TPM_ALG_ECSCHNORR:
6959 return TPMS_SIGNATURE_ECSCHNORR_Marshal(
6960 (TPMS_SIGNATURE_ECSCHNORR*)&source->ecschnorr, buffer, size);
6961 #endif
6962 #ifdef TPM_ALG_HMAC
6963 case TPM_ALG_HMAC:
6964 return TPMT_HA_Marshal((TPMT_HA*)&source->hmac, buffer, size);
6965 #endif
6966 #ifdef TPM_ALG_NULL
6967 case TPM_ALG_NULL:
6968 return 0;
6969 #endif
6970 }
6971 return 0;
6972 }
6973
TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE * target,BYTE ** buffer,INT32 * size,UINT32 selector)6974 TPM_RC TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE* target,
6975 BYTE** buffer,
6976 INT32* size,
6977 UINT32 selector) {
6978 switch (selector) {
6979 #ifdef TPM_ALG_RSASSA
6980 case TPM_ALG_RSASSA:
6981 return TPMS_SIGNATURE_RSASSA_Unmarshal(
6982 (TPMS_SIGNATURE_RSASSA*)&target->rsassa, buffer, size);
6983 #endif
6984 #ifdef TPM_ALG_RSAPSS
6985 case TPM_ALG_RSAPSS:
6986 return TPMS_SIGNATURE_RSAPSS_Unmarshal(
6987 (TPMS_SIGNATURE_RSAPSS*)&target->rsapss, buffer, size);
6988 #endif
6989 #ifdef TPM_ALG_ECDSA
6990 case TPM_ALG_ECDSA:
6991 return TPMS_SIGNATURE_ECDSA_Unmarshal(
6992 (TPMS_SIGNATURE_ECDSA*)&target->ecdsa, buffer, size);
6993 #endif
6994 #ifdef TPM_ALG_ECDAA
6995 case TPM_ALG_ECDAA:
6996 return TPMS_SIGNATURE_ECDAA_Unmarshal(
6997 (TPMS_SIGNATURE_ECDAA*)&target->ecdaa, buffer, size);
6998 #endif
6999 #ifdef TPM_ALG_SM2
7000 case TPM_ALG_SM2:
7001 return TPMS_SIGNATURE_SM2_Unmarshal((TPMS_SIGNATURE_SM2*)&target->sm2,
7002 buffer, size);
7003 #endif
7004 #ifdef TPM_ALG_ECSCHNORR
7005 case TPM_ALG_ECSCHNORR:
7006 return TPMS_SIGNATURE_ECSCHNORR_Unmarshal(
7007 (TPMS_SIGNATURE_ECSCHNORR*)&target->ecschnorr, buffer, size);
7008 #endif
7009 #ifdef TPM_ALG_HMAC
7010 case TPM_ALG_HMAC:
7011 return TPMT_HA_Unmarshal((TPMT_HA*)&target->hmac, buffer, size);
7012 #endif
7013 #ifdef TPM_ALG_NULL
7014 case TPM_ALG_NULL:
7015 return TPM_RC_SUCCESS;
7016 #endif
7017 }
7018 return TPM_RC_SELECTOR;
7019 }
7020
TPMT_SIGNATURE_Marshal(TPMT_SIGNATURE * source,BYTE ** buffer,INT32 * size)7021 UINT16 TPMT_SIGNATURE_Marshal(TPMT_SIGNATURE* source,
7022 BYTE** buffer,
7023 INT32* size) {
7024 UINT16 total_size = 0;
7025 total_size += TPMI_ALG_SIG_SCHEME_Marshal(&source->sigAlg, buffer, size);
7026 total_size +=
7027 TPMU_SIGNATURE_Marshal(&source->signature, buffer, size, source->sigAlg);
7028 return total_size;
7029 }
7030
TPMT_SIGNATURE_Unmarshal(TPMT_SIGNATURE * target,BYTE ** buffer,INT32 * size)7031 TPM_RC TPMT_SIGNATURE_Unmarshal(TPMT_SIGNATURE* target,
7032 BYTE** buffer,
7033 INT32* size) {
7034 TPM_RC result;
7035 result = TPMI_ALG_SIG_SCHEME_Unmarshal(&target->sigAlg, buffer, size, TRUE);
7036 if (result != TPM_RC_SUCCESS) {
7037 return result;
7038 }
7039 result = TPMU_SIGNATURE_Unmarshal(&target->signature, buffer, size,
7040 target->sigAlg);
7041 if (result != TPM_RC_SUCCESS) {
7042 return result;
7043 }
7044 return TPM_RC_SUCCESS;
7045 }
7046
TPMU_SIG_SCHEME_Marshal(TPMU_SIG_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)7047 UINT16 TPMU_SIG_SCHEME_Marshal(TPMU_SIG_SCHEME* source,
7048 BYTE** buffer,
7049 INT32* size,
7050 UINT32 selector) {
7051 switch (selector) {
7052 #ifdef TPM_ALG_RSASSA
7053 case TPM_ALG_RSASSA:
7054 return TPMS_SIG_SCHEME_RSASSA_Marshal(
7055 (TPMS_SIG_SCHEME_RSASSA*)&source->rsassa, buffer, size);
7056 #endif
7057 #ifdef TPM_ALG_RSAPSS
7058 case TPM_ALG_RSAPSS:
7059 return TPMS_SIG_SCHEME_RSAPSS_Marshal(
7060 (TPMS_SIG_SCHEME_RSAPSS*)&source->rsapss, buffer, size);
7061 #endif
7062 #ifdef TPM_ALG_ECDSA
7063 case TPM_ALG_ECDSA:
7064 return TPMS_SIG_SCHEME_ECDSA_Marshal(
7065 (TPMS_SIG_SCHEME_ECDSA*)&source->ecdsa, buffer, size);
7066 #endif
7067 #ifdef TPM_ALG_ECDAA
7068 case TPM_ALG_ECDAA:
7069 return TPMS_SIG_SCHEME_ECDAA_Marshal(
7070 (TPMS_SIG_SCHEME_ECDAA*)&source->ecdaa, buffer, size);
7071 #endif
7072 #ifdef TPM_ALG_SM2
7073 case TPM_ALG_SM2:
7074 return TPMS_SIG_SCHEME_SM2_Marshal((TPMS_SIG_SCHEME_SM2*)&source->sm2,
7075 buffer, size);
7076 #endif
7077 #ifdef TPM_ALG_ECSCHNORR
7078 case TPM_ALG_ECSCHNORR:
7079 return TPMS_SIG_SCHEME_ECSCHNORR_Marshal(
7080 (TPMS_SIG_SCHEME_ECSCHNORR*)&source->ecschnorr, buffer, size);
7081 #endif
7082 #ifdef TPM_ALG_HMAC
7083 case TPM_ALG_HMAC:
7084 return TPMS_SCHEME_HMAC_Marshal((TPMS_SCHEME_HMAC*)&source->hmac, buffer,
7085 size);
7086 #endif
7087 #ifdef TPM_ALG_NULL
7088 case TPM_ALG_NULL:
7089 return 0;
7090 #endif
7091 }
7092 return 0;
7093 }
7094
TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)7095 TPM_RC TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME* target,
7096 BYTE** buffer,
7097 INT32* size,
7098 UINT32 selector) {
7099 switch (selector) {
7100 #ifdef TPM_ALG_RSASSA
7101 case TPM_ALG_RSASSA:
7102 return TPMS_SIG_SCHEME_RSASSA_Unmarshal(
7103 (TPMS_SIG_SCHEME_RSASSA*)&target->rsassa, buffer, size);
7104 #endif
7105 #ifdef TPM_ALG_RSAPSS
7106 case TPM_ALG_RSAPSS:
7107 return TPMS_SIG_SCHEME_RSAPSS_Unmarshal(
7108 (TPMS_SIG_SCHEME_RSAPSS*)&target->rsapss, buffer, size);
7109 #endif
7110 #ifdef TPM_ALG_ECDSA
7111 case TPM_ALG_ECDSA:
7112 return TPMS_SIG_SCHEME_ECDSA_Unmarshal(
7113 (TPMS_SIG_SCHEME_ECDSA*)&target->ecdsa, buffer, size);
7114 #endif
7115 #ifdef TPM_ALG_ECDAA
7116 case TPM_ALG_ECDAA:
7117 return TPMS_SIG_SCHEME_ECDAA_Unmarshal(
7118 (TPMS_SIG_SCHEME_ECDAA*)&target->ecdaa, buffer, size);
7119 #endif
7120 #ifdef TPM_ALG_SM2
7121 case TPM_ALG_SM2:
7122 return TPMS_SIG_SCHEME_SM2_Unmarshal((TPMS_SIG_SCHEME_SM2*)&target->sm2,
7123 buffer, size);
7124 #endif
7125 #ifdef TPM_ALG_ECSCHNORR
7126 case TPM_ALG_ECSCHNORR:
7127 return TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(
7128 (TPMS_SIG_SCHEME_ECSCHNORR*)&target->ecschnorr, buffer, size);
7129 #endif
7130 #ifdef TPM_ALG_HMAC
7131 case TPM_ALG_HMAC:
7132 return TPMS_SCHEME_HMAC_Unmarshal((TPMS_SCHEME_HMAC*)&target->hmac,
7133 buffer, size);
7134 #endif
7135 #ifdef TPM_ALG_NULL
7136 case TPM_ALG_NULL:
7137 return TPM_RC_SUCCESS;
7138 #endif
7139 }
7140 return TPM_RC_SELECTOR;
7141 }
7142
TPMT_SIG_SCHEME_Marshal(TPMT_SIG_SCHEME * source,BYTE ** buffer,INT32 * size)7143 UINT16 TPMT_SIG_SCHEME_Marshal(TPMT_SIG_SCHEME* source,
7144 BYTE** buffer,
7145 INT32* size) {
7146 UINT16 total_size = 0;
7147 total_size += TPMI_ALG_SIG_SCHEME_Marshal(&source->scheme, buffer, size);
7148 total_size +=
7149 TPMU_SIG_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
7150 return total_size;
7151 }
7152
TPMT_SIG_SCHEME_Unmarshal(TPMT_SIG_SCHEME * target,BYTE ** buffer,INT32 * size)7153 TPM_RC TPMT_SIG_SCHEME_Unmarshal(TPMT_SIG_SCHEME* target,
7154 BYTE** buffer,
7155 INT32* size) {
7156 TPM_RC result;
7157 result = TPMI_ALG_SIG_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
7158 if (result != TPM_RC_SUCCESS) {
7159 return result;
7160 }
7161 result =
7162 TPMU_SIG_SCHEME_Unmarshal(&target->details, buffer, size, target->scheme);
7163 if (result != TPM_RC_SUCCESS) {
7164 return result;
7165 }
7166 return TPM_RC_SUCCESS;
7167 }
7168
TPMT_SYM_DEF_Marshal(TPMT_SYM_DEF * source,BYTE ** buffer,INT32 * size)7169 UINT16 TPMT_SYM_DEF_Marshal(TPMT_SYM_DEF* source, BYTE** buffer, INT32* size) {
7170 UINT16 total_size = 0;
7171 total_size += TPMI_ALG_SYM_Marshal(&source->algorithm, buffer, size);
7172 total_size += TPMU_SYM_KEY_BITS_Marshal(&source->keyBits, buffer, size,
7173 source->algorithm);
7174 total_size +=
7175 TPMU_SYM_MODE_Marshal(&source->mode, buffer, size, source->algorithm);
7176 return total_size;
7177 }
7178
TPMT_SYM_DEF_Unmarshal(TPMT_SYM_DEF * target,BYTE ** buffer,INT32 * size)7179 TPM_RC TPMT_SYM_DEF_Unmarshal(TPMT_SYM_DEF* target,
7180 BYTE** buffer,
7181 INT32* size) {
7182 TPM_RC result;
7183 result = TPMI_ALG_SYM_Unmarshal(&target->algorithm, buffer, size, TRUE);
7184 if (result != TPM_RC_SUCCESS) {
7185 return result;
7186 }
7187 result = TPMU_SYM_KEY_BITS_Unmarshal(&target->keyBits, buffer, size,
7188 target->algorithm);
7189 if (result != TPM_RC_SUCCESS) {
7190 return result;
7191 }
7192 result =
7193 TPMU_SYM_MODE_Unmarshal(&target->mode, buffer, size, target->algorithm);
7194 if (result != TPM_RC_SUCCESS) {
7195 return result;
7196 }
7197 return TPM_RC_SUCCESS;
7198 }
7199
TPM_ST_Marshal(TPM_ST * source,BYTE ** buffer,INT32 * size)7200 UINT16 TPM_ST_Marshal(TPM_ST* source, BYTE** buffer, INT32* size) {
7201 return uint16_t_Marshal(source, buffer, size);
7202 }
7203
TPM_ST_Unmarshal(TPM_ST * target,BYTE ** buffer,INT32 * size)7204 TPM_RC TPM_ST_Unmarshal(TPM_ST* target, BYTE** buffer, INT32* size) {
7205 TPM_RC result;
7206 result = uint16_t_Unmarshal(target, buffer, size);
7207 if (result != TPM_RC_SUCCESS) {
7208 return result;
7209 }
7210 if (*target == TPM_ST_RSP_COMMAND) {
7211 return TPM_RC_SUCCESS;
7212 }
7213 if (*target == TPM_ST_NULL) {
7214 return TPM_RC_SUCCESS;
7215 }
7216 if (*target == TPM_ST_NO_SESSIONS) {
7217 return TPM_RC_SUCCESS;
7218 }
7219 if (*target == TPM_ST_SESSIONS) {
7220 return TPM_RC_SUCCESS;
7221 }
7222 if (*target == TPM_ST_ATTEST_NV) {
7223 return TPM_RC_SUCCESS;
7224 }
7225 if (*target == TPM_ST_ATTEST_COMMAND_AUDIT) {
7226 return TPM_RC_SUCCESS;
7227 }
7228 if (*target == TPM_ST_ATTEST_SESSION_AUDIT) {
7229 return TPM_RC_SUCCESS;
7230 }
7231 if (*target == TPM_ST_ATTEST_CERTIFY) {
7232 return TPM_RC_SUCCESS;
7233 }
7234 if (*target == TPM_ST_ATTEST_QUOTE) {
7235 return TPM_RC_SUCCESS;
7236 }
7237 if (*target == TPM_ST_ATTEST_TIME) {
7238 return TPM_RC_SUCCESS;
7239 }
7240 if (*target == TPM_ST_ATTEST_CREATION) {
7241 return TPM_RC_SUCCESS;
7242 }
7243 if (*target == TPM_ST_CREATION) {
7244 return TPM_RC_SUCCESS;
7245 }
7246 if (*target == TPM_ST_VERIFIED) {
7247 return TPM_RC_SUCCESS;
7248 }
7249 if (*target == TPM_ST_AUTH_SECRET) {
7250 return TPM_RC_SUCCESS;
7251 }
7252 if (*target == TPM_ST_HASHCHECK) {
7253 return TPM_RC_SUCCESS;
7254 }
7255 if (*target == TPM_ST_AUTH_SIGNED) {
7256 return TPM_RC_SUCCESS;
7257 }
7258 if (*target == TPM_ST_FU_MANIFEST) {
7259 return TPM_RC_SUCCESS;
7260 }
7261 return TPM_RC_VALUE;
7262 }
7263
TPMT_TK_AUTH_Marshal(TPMT_TK_AUTH * source,BYTE ** buffer,INT32 * size)7264 UINT16 TPMT_TK_AUTH_Marshal(TPMT_TK_AUTH* source, BYTE** buffer, INT32* size) {
7265 UINT16 total_size = 0;
7266 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7267 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7268 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7269 return total_size;
7270 }
7271
TPMT_TK_AUTH_Unmarshal(TPMT_TK_AUTH * target,BYTE ** buffer,INT32 * size)7272 TPM_RC TPMT_TK_AUTH_Unmarshal(TPMT_TK_AUTH* target,
7273 BYTE** buffer,
7274 INT32* size) {
7275 TPM_RC result;
7276 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7277 if (result != TPM_RC_SUCCESS) {
7278 return result;
7279 }
7280 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7281 if (result != TPM_RC_SUCCESS) {
7282 return result;
7283 }
7284 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7285 if (result != TPM_RC_SUCCESS) {
7286 return result;
7287 }
7288 return TPM_RC_SUCCESS;
7289 }
7290
TPMT_TK_CREATION_Marshal(TPMT_TK_CREATION * source,BYTE ** buffer,INT32 * size)7291 UINT16 TPMT_TK_CREATION_Marshal(TPMT_TK_CREATION* source,
7292 BYTE** buffer,
7293 INT32* size) {
7294 UINT16 total_size = 0;
7295 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7296 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7297 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7298 return total_size;
7299 }
7300
TPMT_TK_CREATION_Unmarshal(TPMT_TK_CREATION * target,BYTE ** buffer,INT32 * size)7301 TPM_RC TPMT_TK_CREATION_Unmarshal(TPMT_TK_CREATION* target,
7302 BYTE** buffer,
7303 INT32* size) {
7304 TPM_RC result;
7305 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7306 if (result != TPM_RC_SUCCESS) {
7307 return result;
7308 }
7309 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7310 if (result != TPM_RC_SUCCESS) {
7311 return result;
7312 }
7313 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7314 if (result != TPM_RC_SUCCESS) {
7315 return result;
7316 }
7317 return TPM_RC_SUCCESS;
7318 }
7319
TPMT_TK_HASHCHECK_Marshal(TPMT_TK_HASHCHECK * source,BYTE ** buffer,INT32 * size)7320 UINT16 TPMT_TK_HASHCHECK_Marshal(TPMT_TK_HASHCHECK* source,
7321 BYTE** buffer,
7322 INT32* size) {
7323 UINT16 total_size = 0;
7324 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7325 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7326 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7327 return total_size;
7328 }
7329
TPMT_TK_HASHCHECK_Unmarshal(TPMT_TK_HASHCHECK * target,BYTE ** buffer,INT32 * size)7330 TPM_RC TPMT_TK_HASHCHECK_Unmarshal(TPMT_TK_HASHCHECK* target,
7331 BYTE** buffer,
7332 INT32* size) {
7333 TPM_RC result;
7334 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7335 if (result != TPM_RC_SUCCESS) {
7336 return result;
7337 }
7338 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7339 if (result != TPM_RC_SUCCESS) {
7340 return result;
7341 }
7342 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7343 if (result != TPM_RC_SUCCESS) {
7344 return result;
7345 }
7346 return TPM_RC_SUCCESS;
7347 }
7348
TPMT_TK_VERIFIED_Marshal(TPMT_TK_VERIFIED * source,BYTE ** buffer,INT32 * size)7349 UINT16 TPMT_TK_VERIFIED_Marshal(TPMT_TK_VERIFIED* source,
7350 BYTE** buffer,
7351 INT32* size) {
7352 UINT16 total_size = 0;
7353 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7354 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7355 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7356 return total_size;
7357 }
7358
TPMT_TK_VERIFIED_Unmarshal(TPMT_TK_VERIFIED * target,BYTE ** buffer,INT32 * size)7359 TPM_RC TPMT_TK_VERIFIED_Unmarshal(TPMT_TK_VERIFIED* target,
7360 BYTE** buffer,
7361 INT32* size) {
7362 TPM_RC result;
7363 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7364 if (result != TPM_RC_SUCCESS) {
7365 return result;
7366 }
7367 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7368 if (result != TPM_RC_SUCCESS) {
7369 return result;
7370 }
7371 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7372 if (result != TPM_RC_SUCCESS) {
7373 return result;
7374 }
7375 return TPM_RC_SUCCESS;
7376 }
7377
TPMU_SYM_DETAILS_Marshal(TPMU_SYM_DETAILS * source,BYTE ** buffer,INT32 * size,UINT32 selector)7378 UINT16 TPMU_SYM_DETAILS_Marshal(TPMU_SYM_DETAILS* source,
7379 BYTE** buffer,
7380 INT32* size,
7381 UINT32 selector) {
7382 switch (selector) {
7383 #ifdef TPM_ALG_AES
7384 case TPM_ALG_AES:
7385 return 0;
7386 #endif
7387 #ifdef TPM_ALG_SM4
7388 case TPM_ALG_SM4:
7389 return 0;
7390 #endif
7391 #ifdef TPM_ALG_CAMELLIA
7392 case TPM_ALG_CAMELLIA:
7393 return 0;
7394 #endif
7395 #ifdef TPM_ALG_XOR
7396 case TPM_ALG_XOR:
7397 return 0;
7398 #endif
7399 #ifdef TPM_ALG_NULL
7400 case TPM_ALG_NULL:
7401 return 0;
7402 #endif
7403 }
7404 return 0;
7405 }
7406
TPMU_SYM_DETAILS_Unmarshal(TPMU_SYM_DETAILS * target,BYTE ** buffer,INT32 * size,UINT32 selector)7407 TPM_RC TPMU_SYM_DETAILS_Unmarshal(TPMU_SYM_DETAILS* target,
7408 BYTE** buffer,
7409 INT32* size,
7410 UINT32 selector) {
7411 switch (selector) {
7412 #ifdef TPM_ALG_AES
7413 case TPM_ALG_AES:
7414 return TPM_RC_SUCCESS;
7415 #endif
7416 #ifdef TPM_ALG_SM4
7417 case TPM_ALG_SM4:
7418 return TPM_RC_SUCCESS;
7419 #endif
7420 #ifdef TPM_ALG_CAMELLIA
7421 case TPM_ALG_CAMELLIA:
7422 return TPM_RC_SUCCESS;
7423 #endif
7424 #ifdef TPM_ALG_XOR
7425 case TPM_ALG_XOR:
7426 return TPM_RC_SUCCESS;
7427 #endif
7428 #ifdef TPM_ALG_NULL
7429 case TPM_ALG_NULL:
7430 return TPM_RC_SUCCESS;
7431 #endif
7432 }
7433 return TPM_RC_SELECTOR;
7434 }
7435
TPM_ALGORITHM_ID_Marshal(TPM_ALGORITHM_ID * source,BYTE ** buffer,INT32 * size)7436 UINT16 TPM_ALGORITHM_ID_Marshal(TPM_ALGORITHM_ID* source,
7437 BYTE** buffer,
7438 INT32* size) {
7439 return uint32_t_Marshal(source, buffer, size);
7440 }
7441
TPM_ALGORITHM_ID_Unmarshal(TPM_ALGORITHM_ID * target,BYTE ** buffer,INT32 * size)7442 TPM_RC TPM_ALGORITHM_ID_Unmarshal(TPM_ALGORITHM_ID* target,
7443 BYTE** buffer,
7444 INT32* size) {
7445 return uint32_t_Unmarshal(target, buffer, size);
7446 }
7447
TPM_AUTHORIZATION_SIZE_Marshal(TPM_AUTHORIZATION_SIZE * source,BYTE ** buffer,INT32 * size)7448 UINT16 TPM_AUTHORIZATION_SIZE_Marshal(TPM_AUTHORIZATION_SIZE* source,
7449 BYTE** buffer,
7450 INT32* size) {
7451 return uint32_t_Marshal(source, buffer, size);
7452 }
7453
TPM_AUTHORIZATION_SIZE_Unmarshal(TPM_AUTHORIZATION_SIZE * target,BYTE ** buffer,INT32 * size)7454 TPM_RC TPM_AUTHORIZATION_SIZE_Unmarshal(TPM_AUTHORIZATION_SIZE* target,
7455 BYTE** buffer,
7456 INT32* size) {
7457 return uint32_t_Unmarshal(target, buffer, size);
7458 }
7459
TPM_CLOCK_ADJUST_Marshal(TPM_CLOCK_ADJUST * source,BYTE ** buffer,INT32 * size)7460 UINT16 TPM_CLOCK_ADJUST_Marshal(TPM_CLOCK_ADJUST* source,
7461 BYTE** buffer,
7462 INT32* size) {
7463 return int8_t_Marshal(source, buffer, size);
7464 }
7465
TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST * target,BYTE ** buffer,INT32 * size)7466 TPM_RC TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST* target,
7467 BYTE** buffer,
7468 INT32* size) {
7469 TPM_RC result;
7470 result = int8_t_Unmarshal(target, buffer, size);
7471 if (result != TPM_RC_SUCCESS) {
7472 return result;
7473 }
7474 if (*target == TPM_CLOCK_COARSE_SLOWER) {
7475 return TPM_RC_SUCCESS;
7476 }
7477 if (*target == TPM_CLOCK_MEDIUM_SLOWER) {
7478 return TPM_RC_SUCCESS;
7479 }
7480 if (*target == TPM_CLOCK_FINE_SLOWER) {
7481 return TPM_RC_SUCCESS;
7482 }
7483 if (*target == TPM_CLOCK_NO_CHANGE) {
7484 return TPM_RC_SUCCESS;
7485 }
7486 if (*target == TPM_CLOCK_FINE_FASTER) {
7487 return TPM_RC_SUCCESS;
7488 }
7489 if (*target == TPM_CLOCK_MEDIUM_FASTER) {
7490 return TPM_RC_SUCCESS;
7491 }
7492 if (*target == TPM_CLOCK_COARSE_FASTER) {
7493 return TPM_RC_SUCCESS;
7494 }
7495 return TPM_RC_VALUE;
7496 }
7497
TPM_EO_Marshal(TPM_EO * source,BYTE ** buffer,INT32 * size)7498 UINT16 TPM_EO_Marshal(TPM_EO* source, BYTE** buffer, INT32* size) {
7499 return uint16_t_Marshal(source, buffer, size);
7500 }
7501
TPM_EO_Unmarshal(TPM_EO * target,BYTE ** buffer,INT32 * size)7502 TPM_RC TPM_EO_Unmarshal(TPM_EO* target, BYTE** buffer, INT32* size) {
7503 TPM_RC result;
7504 result = uint16_t_Unmarshal(target, buffer, size);
7505 if (result != TPM_RC_SUCCESS) {
7506 return result;
7507 }
7508 if (*target == TPM_EO_EQ) {
7509 return TPM_RC_SUCCESS;
7510 }
7511 if (*target == TPM_EO_NEQ) {
7512 return TPM_RC_SUCCESS;
7513 }
7514 if (*target == TPM_EO_SIGNED_GT) {
7515 return TPM_RC_SUCCESS;
7516 }
7517 if (*target == TPM_EO_UNSIGNED_GT) {
7518 return TPM_RC_SUCCESS;
7519 }
7520 if (*target == TPM_EO_SIGNED_LT) {
7521 return TPM_RC_SUCCESS;
7522 }
7523 if (*target == TPM_EO_UNSIGNED_LT) {
7524 return TPM_RC_SUCCESS;
7525 }
7526 if (*target == TPM_EO_SIGNED_GE) {
7527 return TPM_RC_SUCCESS;
7528 }
7529 if (*target == TPM_EO_UNSIGNED_GE) {
7530 return TPM_RC_SUCCESS;
7531 }
7532 if (*target == TPM_EO_SIGNED_LE) {
7533 return TPM_RC_SUCCESS;
7534 }
7535 if (*target == TPM_EO_UNSIGNED_LE) {
7536 return TPM_RC_SUCCESS;
7537 }
7538 if (*target == TPM_EO_BITSET) {
7539 return TPM_RC_SUCCESS;
7540 }
7541 if (*target == TPM_EO_BITCLEAR) {
7542 return TPM_RC_SUCCESS;
7543 }
7544 return TPM_RC_VALUE;
7545 }
7546
TPM_HC_Marshal(TPM_HC * source,BYTE ** buffer,INT32 * size)7547 UINT16 TPM_HC_Marshal(TPM_HC* source, BYTE** buffer, INT32* size) {
7548 return uint32_t_Marshal(source, buffer, size);
7549 }
7550
TPM_HC_Unmarshal(TPM_HC * target,BYTE ** buffer,INT32 * size)7551 TPM_RC TPM_HC_Unmarshal(TPM_HC* target, BYTE** buffer, INT32* size) {
7552 TPM_RC result;
7553 result = uint32_t_Unmarshal(target, buffer, size);
7554 if (result != TPM_RC_SUCCESS) {
7555 return result;
7556 }
7557 if (*target == HR_HANDLE_MASK) {
7558 return TPM_RC_SUCCESS;
7559 }
7560 if (*target == HR_RANGE_MASK) {
7561 return TPM_RC_SUCCESS;
7562 }
7563 if (*target == HR_SHIFT) {
7564 return TPM_RC_SUCCESS;
7565 }
7566 if (*target == HR_PCR) {
7567 return TPM_RC_SUCCESS;
7568 }
7569 if (*target == HR_HMAC_SESSION) {
7570 return TPM_RC_SUCCESS;
7571 }
7572 if (*target == HR_POLICY_SESSION) {
7573 return TPM_RC_SUCCESS;
7574 }
7575 if (*target == HR_TRANSIENT) {
7576 return TPM_RC_SUCCESS;
7577 }
7578 if (*target == HR_PERSISTENT) {
7579 return TPM_RC_SUCCESS;
7580 }
7581 if (*target == HR_NV_INDEX) {
7582 return TPM_RC_SUCCESS;
7583 }
7584 if (*target == HR_PERMANENT) {
7585 return TPM_RC_SUCCESS;
7586 }
7587 if (*target == PCR_FIRST) {
7588 return TPM_RC_SUCCESS;
7589 }
7590 if (*target == PCR_LAST) {
7591 return TPM_RC_SUCCESS;
7592 }
7593 if (*target == HMAC_SESSION_FIRST) {
7594 return TPM_RC_SUCCESS;
7595 }
7596 if (*target == HMAC_SESSION_LAST) {
7597 return TPM_RC_SUCCESS;
7598 }
7599 if (*target == LOADED_SESSION_FIRST) {
7600 return TPM_RC_SUCCESS;
7601 }
7602 if (*target == LOADED_SESSION_LAST) {
7603 return TPM_RC_SUCCESS;
7604 }
7605 if (*target == POLICY_SESSION_FIRST) {
7606 return TPM_RC_SUCCESS;
7607 }
7608 if (*target == POLICY_SESSION_LAST) {
7609 return TPM_RC_SUCCESS;
7610 }
7611 if (*target == TRANSIENT_FIRST) {
7612 return TPM_RC_SUCCESS;
7613 }
7614 if (*target == ACTIVE_SESSION_FIRST) {
7615 return TPM_RC_SUCCESS;
7616 }
7617 if (*target == ACTIVE_SESSION_LAST) {
7618 return TPM_RC_SUCCESS;
7619 }
7620 if (*target == TRANSIENT_LAST) {
7621 return TPM_RC_SUCCESS;
7622 }
7623 if (*target == PERSISTENT_FIRST) {
7624 return TPM_RC_SUCCESS;
7625 }
7626 if (*target == PERSISTENT_LAST) {
7627 return TPM_RC_SUCCESS;
7628 }
7629 if (*target == PLATFORM_PERSISTENT) {
7630 return TPM_RC_SUCCESS;
7631 }
7632 if (*target == NV_INDEX_FIRST) {
7633 return TPM_RC_SUCCESS;
7634 }
7635 if (*target == NV_INDEX_LAST) {
7636 return TPM_RC_SUCCESS;
7637 }
7638 if (*target == PERMANENT_FIRST) {
7639 return TPM_RC_SUCCESS;
7640 }
7641 if (*target == PERMANENT_LAST) {
7642 return TPM_RC_SUCCESS;
7643 }
7644 return TPM_RC_VALUE;
7645 }
7646
TPM_HT_Marshal(TPM_HT * source,BYTE ** buffer,INT32 * size)7647 UINT16 TPM_HT_Marshal(TPM_HT* source, BYTE** buffer, INT32* size) {
7648 return uint8_t_Marshal(source, buffer, size);
7649 }
7650
TPM_HT_Unmarshal(TPM_HT * target,BYTE ** buffer,INT32 * size)7651 TPM_RC TPM_HT_Unmarshal(TPM_HT* target, BYTE** buffer, INT32* size) {
7652 TPM_RC result;
7653 result = uint8_t_Unmarshal(target, buffer, size);
7654 if (result != TPM_RC_SUCCESS) {
7655 return result;
7656 }
7657 if (*target == TPM_HT_PCR) {
7658 return TPM_RC_SUCCESS;
7659 }
7660 if (*target == TPM_HT_NV_INDEX) {
7661 return TPM_RC_SUCCESS;
7662 }
7663 if (*target == TPM_HT_HMAC_SESSION) {
7664 return TPM_RC_SUCCESS;
7665 }
7666 if (*target == TPM_HT_LOADED_SESSION) {
7667 return TPM_RC_SUCCESS;
7668 }
7669 if (*target == TPM_HT_POLICY_SESSION) {
7670 return TPM_RC_SUCCESS;
7671 }
7672 if (*target == TPM_HT_ACTIVE_SESSION) {
7673 return TPM_RC_SUCCESS;
7674 }
7675 if (*target == TPM_HT_PERMANENT) {
7676 return TPM_RC_SUCCESS;
7677 }
7678 if (*target == TPM_HT_TRANSIENT) {
7679 return TPM_RC_SUCCESS;
7680 }
7681 if (*target == TPM_HT_PERSISTENT) {
7682 return TPM_RC_SUCCESS;
7683 }
7684 return TPM_RC_VALUE;
7685 }
7686
TPM_KEY_SIZE_Marshal(TPM_KEY_SIZE * source,BYTE ** buffer,INT32 * size)7687 UINT16 TPM_KEY_SIZE_Marshal(TPM_KEY_SIZE* source, BYTE** buffer, INT32* size) {
7688 return uint16_t_Marshal(source, buffer, size);
7689 }
7690
TPM_KEY_SIZE_Unmarshal(TPM_KEY_SIZE * target,BYTE ** buffer,INT32 * size)7691 TPM_RC TPM_KEY_SIZE_Unmarshal(TPM_KEY_SIZE* target,
7692 BYTE** buffer,
7693 INT32* size) {
7694 return uint16_t_Unmarshal(target, buffer, size);
7695 }
7696
TPM_MODIFIER_INDICATOR_Marshal(TPM_MODIFIER_INDICATOR * source,BYTE ** buffer,INT32 * size)7697 UINT16 TPM_MODIFIER_INDICATOR_Marshal(TPM_MODIFIER_INDICATOR* source,
7698 BYTE** buffer,
7699 INT32* size) {
7700 return uint32_t_Marshal(source, buffer, size);
7701 }
7702
TPM_MODIFIER_INDICATOR_Unmarshal(TPM_MODIFIER_INDICATOR * target,BYTE ** buffer,INT32 * size)7703 TPM_RC TPM_MODIFIER_INDICATOR_Unmarshal(TPM_MODIFIER_INDICATOR* target,
7704 BYTE** buffer,
7705 INT32* size) {
7706 return uint32_t_Unmarshal(target, buffer, size);
7707 }
7708
TPM_NV_INDEX_Marshal(TPM_NV_INDEX * source,BYTE ** buffer,INT32 * size)7709 UINT16 TPM_NV_INDEX_Marshal(TPM_NV_INDEX* source, BYTE** buffer, INT32* size) {
7710 return uint32_t_Marshal((uint32_t*)source, buffer, size);
7711 }
7712
TPM_NV_INDEX_Unmarshal(TPM_NV_INDEX * target,BYTE ** buffer,INT32 * size)7713 TPM_RC TPM_NV_INDEX_Unmarshal(TPM_NV_INDEX* target,
7714 BYTE** buffer,
7715 INT32* size) {
7716 TPM_RC result;
7717 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
7718 if (result != TPM_RC_SUCCESS) {
7719 return result;
7720 }
7721 return TPM_RC_SUCCESS;
7722 }
7723
TPM_PARAMETER_SIZE_Marshal(TPM_PARAMETER_SIZE * source,BYTE ** buffer,INT32 * size)7724 UINT16 TPM_PARAMETER_SIZE_Marshal(TPM_PARAMETER_SIZE* source,
7725 BYTE** buffer,
7726 INT32* size) {
7727 return uint32_t_Marshal(source, buffer, size);
7728 }
7729
TPM_PARAMETER_SIZE_Unmarshal(TPM_PARAMETER_SIZE * target,BYTE ** buffer,INT32 * size)7730 TPM_RC TPM_PARAMETER_SIZE_Unmarshal(TPM_PARAMETER_SIZE* target,
7731 BYTE** buffer,
7732 INT32* size) {
7733 return uint32_t_Unmarshal(target, buffer, size);
7734 }
7735
TPM_PS_Marshal(TPM_PS * source,BYTE ** buffer,INT32 * size)7736 UINT16 TPM_PS_Marshal(TPM_PS* source, BYTE** buffer, INT32* size) {
7737 return uint32_t_Marshal(source, buffer, size);
7738 }
7739
TPM_PS_Unmarshal(TPM_PS * target,BYTE ** buffer,INT32 * size)7740 TPM_RC TPM_PS_Unmarshal(TPM_PS* target, BYTE** buffer, INT32* size) {
7741 TPM_RC result;
7742 result = uint32_t_Unmarshal(target, buffer, size);
7743 if (result != TPM_RC_SUCCESS) {
7744 return result;
7745 }
7746 if (*target == TPM_PS_MAIN) {
7747 return TPM_RC_SUCCESS;
7748 }
7749 if (*target == TPM_PS_PC) {
7750 return TPM_RC_SUCCESS;
7751 }
7752 if (*target == TPM_PS_PDA) {
7753 return TPM_RC_SUCCESS;
7754 }
7755 if (*target == TPM_PS_CELL_PHONE) {
7756 return TPM_RC_SUCCESS;
7757 }
7758 if (*target == TPM_PS_SERVER) {
7759 return TPM_RC_SUCCESS;
7760 }
7761 if (*target == TPM_PS_PERIPHERAL) {
7762 return TPM_RC_SUCCESS;
7763 }
7764 if (*target == TPM_PS_TSS) {
7765 return TPM_RC_SUCCESS;
7766 }
7767 if (*target == TPM_PS_STORAGE) {
7768 return TPM_RC_SUCCESS;
7769 }
7770 if (*target == TPM_PS_AUTHENTICATION) {
7771 return TPM_RC_SUCCESS;
7772 }
7773 if (*target == TPM_PS_EMBEDDED) {
7774 return TPM_RC_SUCCESS;
7775 }
7776 if (*target == TPM_PS_HARDCOPY) {
7777 return TPM_RC_SUCCESS;
7778 }
7779 if (*target == TPM_PS_INFRASTRUCTURE) {
7780 return TPM_RC_SUCCESS;
7781 }
7782 if (*target == TPM_PS_VIRTUALIZATION) {
7783 return TPM_RC_SUCCESS;
7784 }
7785 if (*target == TPM_PS_TNC) {
7786 return TPM_RC_SUCCESS;
7787 }
7788 if (*target == TPM_PS_MULTI_TENANT) {
7789 return TPM_RC_SUCCESS;
7790 }
7791 if (*target == TPM_PS_TC) {
7792 return TPM_RC_SUCCESS;
7793 }
7794 return TPM_RC_VALUE;
7795 }
7796
TPM_PT_PCR_Marshal(TPM_PT_PCR * source,BYTE ** buffer,INT32 * size)7797 UINT16 TPM_PT_PCR_Marshal(TPM_PT_PCR* source, BYTE** buffer, INT32* size) {
7798 return uint32_t_Marshal(source, buffer, size);
7799 }
7800
TPM_PT_PCR_Unmarshal(TPM_PT_PCR * target,BYTE ** buffer,INT32 * size)7801 TPM_RC TPM_PT_PCR_Unmarshal(TPM_PT_PCR* target, BYTE** buffer, INT32* size) {
7802 TPM_RC result;
7803 result = uint32_t_Unmarshal(target, buffer, size);
7804 if (result != TPM_RC_SUCCESS) {
7805 return result;
7806 }
7807 if (*target == TPM_PT_PCR_FIRST) {
7808 return TPM_RC_SUCCESS;
7809 }
7810 if (*target == TPM_PT_PCR_SAVE) {
7811 return TPM_RC_SUCCESS;
7812 }
7813 if (*target == TPM_PT_PCR_EXTEND_L0) {
7814 return TPM_RC_SUCCESS;
7815 }
7816 if (*target == TPM_PT_PCR_RESET_L0) {
7817 return TPM_RC_SUCCESS;
7818 }
7819 if (*target == TPM_PT_PCR_EXTEND_L1) {
7820 return TPM_RC_SUCCESS;
7821 }
7822 if (*target == TPM_PT_PCR_RESET_L1) {
7823 return TPM_RC_SUCCESS;
7824 }
7825 if (*target == TPM_PT_PCR_EXTEND_L2) {
7826 return TPM_RC_SUCCESS;
7827 }
7828 if (*target == TPM_PT_PCR_RESET_L2) {
7829 return TPM_RC_SUCCESS;
7830 }
7831 if (*target == TPM_PT_PCR_EXTEND_L3) {
7832 return TPM_RC_SUCCESS;
7833 }
7834 if (*target == TPM_PT_PCR_RESET_L3) {
7835 return TPM_RC_SUCCESS;
7836 }
7837 if (*target == TPM_PT_PCR_EXTEND_L4) {
7838 return TPM_RC_SUCCESS;
7839 }
7840 if (*target == TPM_PT_PCR_RESET_L4) {
7841 return TPM_RC_SUCCESS;
7842 }
7843 if (*target == TPM_PT_PCR_NO_INCREMENT) {
7844 return TPM_RC_SUCCESS;
7845 }
7846 if (*target == TPM_PT_PCR_DRTM_RESET) {
7847 return TPM_RC_SUCCESS;
7848 }
7849 if (*target == TPM_PT_PCR_POLICY) {
7850 return TPM_RC_SUCCESS;
7851 }
7852 if (*target == TPM_PT_PCR_AUTH) {
7853 return TPM_RC_SUCCESS;
7854 }
7855 if (*target == TPM_PT_PCR_LAST) {
7856 return TPM_RC_SUCCESS;
7857 }
7858 return TPM_RC_VALUE;
7859 }
7860
TPM_RC_Marshal(TPM_RC * source,BYTE ** buffer,INT32 * size)7861 UINT16 TPM_RC_Marshal(TPM_RC* source, BYTE** buffer, INT32* size) {
7862 return uint32_t_Marshal(source, buffer, size);
7863 }
7864
TPM_RC_Unmarshal(TPM_RC * target,BYTE ** buffer,INT32 * size)7865 TPM_RC TPM_RC_Unmarshal(TPM_RC* target, BYTE** buffer, INT32* size) {
7866 TPM_RC result;
7867 result = uint32_t_Unmarshal(target, buffer, size);
7868 if (result != TPM_RC_SUCCESS) {
7869 return result;
7870 }
7871 if (*target == TPM_RC_SUCCESS) {
7872 return TPM_RC_SUCCESS;
7873 }
7874 if (*target == TPM_RC_BAD_TAG) {
7875 return TPM_RC_SUCCESS;
7876 }
7877 if (*target == RC_VER1) {
7878 return TPM_RC_SUCCESS;
7879 }
7880 if (*target == TPM_RC_INITIALIZE) {
7881 return TPM_RC_SUCCESS;
7882 }
7883 if (*target == TPM_RC_FAILURE) {
7884 return TPM_RC_SUCCESS;
7885 }
7886 if (*target == TPM_RC_SEQUENCE) {
7887 return TPM_RC_SUCCESS;
7888 }
7889 if (*target == TPM_RC_PRIVATE) {
7890 return TPM_RC_SUCCESS;
7891 }
7892 if (*target == TPM_RC_HMAC) {
7893 return TPM_RC_SUCCESS;
7894 }
7895 if (*target == TPM_RC_DISABLED) {
7896 return TPM_RC_SUCCESS;
7897 }
7898 if (*target == TPM_RC_EXCLUSIVE) {
7899 return TPM_RC_SUCCESS;
7900 }
7901 if (*target == TPM_RC_AUTH_TYPE) {
7902 return TPM_RC_SUCCESS;
7903 }
7904 if (*target == TPM_RC_AUTH_MISSING) {
7905 return TPM_RC_SUCCESS;
7906 }
7907 if (*target == TPM_RC_POLICY) {
7908 return TPM_RC_SUCCESS;
7909 }
7910 if (*target == TPM_RC_PCR) {
7911 return TPM_RC_SUCCESS;
7912 }
7913 if (*target == TPM_RC_PCR_CHANGED) {
7914 return TPM_RC_SUCCESS;
7915 }
7916 if (*target == TPM_RC_UPGRADE) {
7917 return TPM_RC_SUCCESS;
7918 }
7919 if (*target == TPM_RC_TOO_MANY_CONTEXTS) {
7920 return TPM_RC_SUCCESS;
7921 }
7922 if (*target == TPM_RC_AUTH_UNAVAILABLE) {
7923 return TPM_RC_SUCCESS;
7924 }
7925 if (*target == TPM_RC_REBOOT) {
7926 return TPM_RC_SUCCESS;
7927 }
7928 if (*target == TPM_RC_UNBALANCED) {
7929 return TPM_RC_SUCCESS;
7930 }
7931 if (*target == TPM_RC_COMMAND_SIZE) {
7932 return TPM_RC_SUCCESS;
7933 }
7934 if (*target == TPM_RC_COMMAND_CODE) {
7935 return TPM_RC_SUCCESS;
7936 }
7937 if (*target == TPM_RC_AUTHSIZE) {
7938 return TPM_RC_SUCCESS;
7939 }
7940 if (*target == TPM_RC_AUTH_CONTEXT) {
7941 return TPM_RC_SUCCESS;
7942 }
7943 if (*target == TPM_RC_NV_RANGE) {
7944 return TPM_RC_SUCCESS;
7945 }
7946 if (*target == TPM_RC_NV_SIZE) {
7947 return TPM_RC_SUCCESS;
7948 }
7949 if (*target == TPM_RC_NV_LOCKED) {
7950 return TPM_RC_SUCCESS;
7951 }
7952 if (*target == TPM_RC_NV_AUTHORIZATION) {
7953 return TPM_RC_SUCCESS;
7954 }
7955 if (*target == TPM_RC_NV_UNINITIALIZED) {
7956 return TPM_RC_SUCCESS;
7957 }
7958 if (*target == TPM_RC_NV_SPACE) {
7959 return TPM_RC_SUCCESS;
7960 }
7961 if (*target == TPM_RC_NV_DEFINED) {
7962 return TPM_RC_SUCCESS;
7963 }
7964 if (*target == TPM_RC_BAD_CONTEXT) {
7965 return TPM_RC_SUCCESS;
7966 }
7967 if (*target == TPM_RC_CPHASH) {
7968 return TPM_RC_SUCCESS;
7969 }
7970 if (*target == TPM_RC_PARENT) {
7971 return TPM_RC_SUCCESS;
7972 }
7973 if (*target == TPM_RC_NEEDS_TEST) {
7974 return TPM_RC_SUCCESS;
7975 }
7976 if (*target == TPM_RC_NO_RESULT) {
7977 return TPM_RC_SUCCESS;
7978 }
7979 if (*target == TPM_RC_SENSITIVE) {
7980 return TPM_RC_SUCCESS;
7981 }
7982 if (*target == RC_MAX_FM0) {
7983 return TPM_RC_SUCCESS;
7984 }
7985 if (*target == RC_FMT1) {
7986 return TPM_RC_SUCCESS;
7987 }
7988 if (*target == TPM_RC_ASYMMETRIC) {
7989 return TPM_RC_SUCCESS;
7990 }
7991 if (*target == TPM_RC_ATTRIBUTES) {
7992 return TPM_RC_SUCCESS;
7993 }
7994 if (*target == TPM_RC_HASH) {
7995 return TPM_RC_SUCCESS;
7996 }
7997 if (*target == TPM_RC_VALUE) {
7998 return TPM_RC_SUCCESS;
7999 }
8000 if (*target == TPM_RC_HIERARCHY) {
8001 return TPM_RC_SUCCESS;
8002 }
8003 if (*target == TPM_RC_KEY_SIZE) {
8004 return TPM_RC_SUCCESS;
8005 }
8006 if (*target == TPM_RC_MGF) {
8007 return TPM_RC_SUCCESS;
8008 }
8009 if (*target == TPM_RC_MODE) {
8010 return TPM_RC_SUCCESS;
8011 }
8012 if (*target == TPM_RC_TYPE) {
8013 return TPM_RC_SUCCESS;
8014 }
8015 if (*target == TPM_RC_HANDLE) {
8016 return TPM_RC_SUCCESS;
8017 }
8018 if (*target == TPM_RC_KDF) {
8019 return TPM_RC_SUCCESS;
8020 }
8021 if (*target == TPM_RC_RANGE) {
8022 return TPM_RC_SUCCESS;
8023 }
8024 if (*target == TPM_RC_AUTH_FAIL) {
8025 return TPM_RC_SUCCESS;
8026 }
8027 if (*target == TPM_RC_NONCE) {
8028 return TPM_RC_SUCCESS;
8029 }
8030 if (*target == TPM_RC_PP) {
8031 return TPM_RC_SUCCESS;
8032 }
8033 if (*target == TPM_RC_SCHEME) {
8034 return TPM_RC_SUCCESS;
8035 }
8036 if (*target == TPM_RC_SIZE) {
8037 return TPM_RC_SUCCESS;
8038 }
8039 if (*target == TPM_RC_SYMMETRIC) {
8040 return TPM_RC_SUCCESS;
8041 }
8042 if (*target == TPM_RC_TAG) {
8043 return TPM_RC_SUCCESS;
8044 }
8045 if (*target == TPM_RC_SELECTOR) {
8046 return TPM_RC_SUCCESS;
8047 }
8048 if (*target == TPM_RC_INSUFFICIENT) {
8049 return TPM_RC_SUCCESS;
8050 }
8051 if (*target == TPM_RC_SIGNATURE) {
8052 return TPM_RC_SUCCESS;
8053 }
8054 if (*target == TPM_RC_KEY) {
8055 return TPM_RC_SUCCESS;
8056 }
8057 if (*target == TPM_RC_POLICY_FAIL) {
8058 return TPM_RC_SUCCESS;
8059 }
8060 if (*target == TPM_RC_INTEGRITY) {
8061 return TPM_RC_SUCCESS;
8062 }
8063 if (*target == TPM_RC_TICKET) {
8064 return TPM_RC_SUCCESS;
8065 }
8066 if (*target == TPM_RC_RESERVED_BITS) {
8067 return TPM_RC_SUCCESS;
8068 }
8069 if (*target == TPM_RC_BAD_AUTH) {
8070 return TPM_RC_SUCCESS;
8071 }
8072 if (*target == TPM_RC_EXPIRED) {
8073 return TPM_RC_SUCCESS;
8074 }
8075 if (*target == TPM_RC_POLICY_CC) {
8076 return TPM_RC_SUCCESS;
8077 }
8078 if (*target == TPM_RC_BINDING) {
8079 return TPM_RC_SUCCESS;
8080 }
8081 if (*target == TPM_RC_CURVE) {
8082 return TPM_RC_SUCCESS;
8083 }
8084 if (*target == TPM_RC_ECC_POINT) {
8085 return TPM_RC_SUCCESS;
8086 }
8087 if (*target == RC_WARN) {
8088 return TPM_RC_SUCCESS;
8089 }
8090 if (*target == TPM_RC_CONTEXT_GAP) {
8091 return TPM_RC_SUCCESS;
8092 }
8093 if (*target == TPM_RC_OBJECT_MEMORY) {
8094 return TPM_RC_SUCCESS;
8095 }
8096 if (*target == TPM_RC_SESSION_MEMORY) {
8097 return TPM_RC_SUCCESS;
8098 }
8099 if (*target == TPM_RC_MEMORY) {
8100 return TPM_RC_SUCCESS;
8101 }
8102 if (*target == TPM_RC_SESSION_HANDLES) {
8103 return TPM_RC_SUCCESS;
8104 }
8105 if (*target == TPM_RC_OBJECT_HANDLES) {
8106 return TPM_RC_SUCCESS;
8107 }
8108 if (*target == TPM_RC_LOCALITY) {
8109 return TPM_RC_SUCCESS;
8110 }
8111 if (*target == TPM_RC_YIELDED) {
8112 return TPM_RC_SUCCESS;
8113 }
8114 if (*target == TPM_RC_CANCELED) {
8115 return TPM_RC_SUCCESS;
8116 }
8117 if (*target == TPM_RC_TESTING) {
8118 return TPM_RC_SUCCESS;
8119 }
8120 if (*target == TPM_RC_REFERENCE_H0) {
8121 return TPM_RC_SUCCESS;
8122 }
8123 if (*target == TPM_RC_REFERENCE_H1) {
8124 return TPM_RC_SUCCESS;
8125 }
8126 if (*target == TPM_RC_REFERENCE_H2) {
8127 return TPM_RC_SUCCESS;
8128 }
8129 if (*target == TPM_RC_REFERENCE_H3) {
8130 return TPM_RC_SUCCESS;
8131 }
8132 if (*target == TPM_RC_REFERENCE_H4) {
8133 return TPM_RC_SUCCESS;
8134 }
8135 if (*target == TPM_RC_REFERENCE_H5) {
8136 return TPM_RC_SUCCESS;
8137 }
8138 if (*target == TPM_RC_REFERENCE_H6) {
8139 return TPM_RC_SUCCESS;
8140 }
8141 if (*target == TPM_RC_REFERENCE_S0) {
8142 return TPM_RC_SUCCESS;
8143 }
8144 if (*target == TPM_RC_REFERENCE_S1) {
8145 return TPM_RC_SUCCESS;
8146 }
8147 if (*target == TPM_RC_REFERENCE_S2) {
8148 return TPM_RC_SUCCESS;
8149 }
8150 if (*target == TPM_RC_REFERENCE_S3) {
8151 return TPM_RC_SUCCESS;
8152 }
8153 if (*target == TPM_RC_REFERENCE_S4) {
8154 return TPM_RC_SUCCESS;
8155 }
8156 if (*target == TPM_RC_REFERENCE_S5) {
8157 return TPM_RC_SUCCESS;
8158 }
8159 if (*target == TPM_RC_REFERENCE_S6) {
8160 return TPM_RC_SUCCESS;
8161 }
8162 if (*target == TPM_RC_NV_RATE) {
8163 return TPM_RC_SUCCESS;
8164 }
8165 if (*target == TPM_RC_LOCKOUT) {
8166 return TPM_RC_SUCCESS;
8167 }
8168 if (*target == TPM_RC_RETRY) {
8169 return TPM_RC_SUCCESS;
8170 }
8171 if (*target == TPM_RC_NV_UNAVAILABLE) {
8172 return TPM_RC_SUCCESS;
8173 }
8174 if (*target == TPM_RC_NOT_USED) {
8175 return TPM_RC_SUCCESS;
8176 }
8177 if (*target == TPM_RC_H) {
8178 return TPM_RC_SUCCESS;
8179 }
8180 if (*target == TPM_RC_P) {
8181 return TPM_RC_SUCCESS;
8182 }
8183 if (*target == TPM_RC_S) {
8184 return TPM_RC_SUCCESS;
8185 }
8186 if (*target == TPM_RC_1) {
8187 return TPM_RC_SUCCESS;
8188 }
8189 if (*target == TPM_RC_2) {
8190 return TPM_RC_SUCCESS;
8191 }
8192 if (*target == TPM_RC_3) {
8193 return TPM_RC_SUCCESS;
8194 }
8195 if (*target == TPM_RC_4) {
8196 return TPM_RC_SUCCESS;
8197 }
8198 if (*target == TPM_RC_5) {
8199 return TPM_RC_SUCCESS;
8200 }
8201 if (*target == TPM_RC_6) {
8202 return TPM_RC_SUCCESS;
8203 }
8204 if (*target == TPM_RC_7) {
8205 return TPM_RC_SUCCESS;
8206 }
8207 if (*target == TPM_RC_8) {
8208 return TPM_RC_SUCCESS;
8209 }
8210 if (*target == TPM_RC_9) {
8211 return TPM_RC_SUCCESS;
8212 }
8213 if (*target == TPM_RC_A) {
8214 return TPM_RC_SUCCESS;
8215 }
8216 if (*target == TPM_RC_B) {
8217 return TPM_RC_SUCCESS;
8218 }
8219 if (*target == TPM_RC_C) {
8220 return TPM_RC_SUCCESS;
8221 }
8222 if (*target == TPM_RC_D) {
8223 return TPM_RC_SUCCESS;
8224 }
8225 if (*target == TPM_RC_E) {
8226 return TPM_RC_SUCCESS;
8227 }
8228 if (*target == TPM_RC_F) {
8229 return TPM_RC_SUCCESS;
8230 }
8231 if (*target == TPM_RC_N_MASK) {
8232 return TPM_RC_SUCCESS;
8233 }
8234 return TPM_RC_VALUE;
8235 }
8236
TPM_RH_Marshal(TPM_RH * source,BYTE ** buffer,INT32 * size)8237 UINT16 TPM_RH_Marshal(TPM_RH* source, BYTE** buffer, INT32* size) {
8238 return uint32_t_Marshal(source, buffer, size);
8239 }
8240
TPM_RH_Unmarshal(TPM_RH * target,BYTE ** buffer,INT32 * size)8241 TPM_RC TPM_RH_Unmarshal(TPM_RH* target, BYTE** buffer, INT32* size) {
8242 TPM_RC result;
8243 result = uint32_t_Unmarshal(target, buffer, size);
8244 if (result != TPM_RC_SUCCESS) {
8245 return result;
8246 }
8247 if (*target == TPM_RH_FIRST) {
8248 return TPM_RC_SUCCESS;
8249 }
8250 if (*target == TPM_RH_SRK) {
8251 return TPM_RC_SUCCESS;
8252 }
8253 if (*target == TPM_RH_OWNER) {
8254 return TPM_RC_SUCCESS;
8255 }
8256 if (*target == TPM_RH_REVOKE) {
8257 return TPM_RC_SUCCESS;
8258 }
8259 if (*target == TPM_RH_TRANSPORT) {
8260 return TPM_RC_SUCCESS;
8261 }
8262 if (*target == TPM_RH_OPERATOR) {
8263 return TPM_RC_SUCCESS;
8264 }
8265 if (*target == TPM_RH_ADMIN) {
8266 return TPM_RC_SUCCESS;
8267 }
8268 if (*target == TPM_RH_EK) {
8269 return TPM_RC_SUCCESS;
8270 }
8271 if (*target == TPM_RH_NULL) {
8272 return TPM_RC_SUCCESS;
8273 }
8274 if (*target == TPM_RH_UNASSIGNED) {
8275 return TPM_RC_SUCCESS;
8276 }
8277 if (*target == TPM_RS_PW) {
8278 return TPM_RC_SUCCESS;
8279 }
8280 if (*target == TPM_RH_LOCKOUT) {
8281 return TPM_RC_SUCCESS;
8282 }
8283 if (*target == TPM_RH_ENDORSEMENT) {
8284 return TPM_RC_SUCCESS;
8285 }
8286 if (*target == TPM_RH_PLATFORM) {
8287 return TPM_RC_SUCCESS;
8288 }
8289 if (*target == TPM_RH_PLATFORM_NV) {
8290 return TPM_RC_SUCCESS;
8291 }
8292 if (*target == TPM_RH_AUTH_00) {
8293 return TPM_RC_SUCCESS;
8294 }
8295 if (*target == TPM_RH_AUTH_FF) {
8296 return TPM_RC_SUCCESS;
8297 }
8298 if (*target == TPM_RH_LAST) {
8299 return TPM_RC_SUCCESS;
8300 }
8301 return TPM_RC_VALUE;
8302 }
8303
TPM_SE_Marshal(TPM_SE * source,BYTE ** buffer,INT32 * size)8304 UINT16 TPM_SE_Marshal(TPM_SE* source, BYTE** buffer, INT32* size) {
8305 return uint8_t_Marshal(source, buffer, size);
8306 }
8307
TPM_SE_Unmarshal(TPM_SE * target,BYTE ** buffer,INT32 * size)8308 TPM_RC TPM_SE_Unmarshal(TPM_SE* target, BYTE** buffer, INT32* size) {
8309 TPM_RC result;
8310 result = uint8_t_Unmarshal(target, buffer, size);
8311 if (result != TPM_RC_SUCCESS) {
8312 return result;
8313 }
8314 if (*target == TPM_SE_HMAC) {
8315 return TPM_RC_SUCCESS;
8316 }
8317 if (*target == TPM_SE_POLICY) {
8318 return TPM_RC_SUCCESS;
8319 }
8320 if (*target == TPM_SE_TRIAL) {
8321 return TPM_RC_SUCCESS;
8322 }
8323 return TPM_RC_VALUE;
8324 }
8325
TPM_SPEC_Marshal(TPM_SPEC * source,BYTE ** buffer,INT32 * size)8326 UINT16 TPM_SPEC_Marshal(TPM_SPEC* source, BYTE** buffer, INT32* size) {
8327 return uint32_t_Marshal(source, buffer, size);
8328 }
8329
TPM_SPEC_Unmarshal(TPM_SPEC * target,BYTE ** buffer,INT32 * size)8330 TPM_RC TPM_SPEC_Unmarshal(TPM_SPEC* target, BYTE** buffer, INT32* size) {
8331 TPM_RC result;
8332 result = uint32_t_Unmarshal(target, buffer, size);
8333 if (result != TPM_RC_SUCCESS) {
8334 return result;
8335 }
8336 if (*target == TPM_SPEC_FAMILY) {
8337 return TPM_RC_SUCCESS;
8338 }
8339 if (*target == TPM_SPEC_LEVEL) {
8340 return TPM_RC_SUCCESS;
8341 }
8342 if (*target == TPM_SPEC_VERSION) {
8343 return TPM_RC_SUCCESS;
8344 }
8345 if (*target == TPM_SPEC_YEAR) {
8346 return TPM_RC_SUCCESS;
8347 }
8348 if (*target == TPM_SPEC_DAY_OF_YEAR) {
8349 return TPM_RC_SUCCESS;
8350 }
8351 return TPM_RC_VALUE;
8352 }
8353
TPM_SU_Marshal(TPM_SU * source,BYTE ** buffer,INT32 * size)8354 UINT16 TPM_SU_Marshal(TPM_SU* source, BYTE** buffer, INT32* size) {
8355 return uint16_t_Marshal(source, buffer, size);
8356 }
8357
TPM_SU_Unmarshal(TPM_SU * target,BYTE ** buffer,INT32 * size)8358 TPM_RC TPM_SU_Unmarshal(TPM_SU* target, BYTE** buffer, INT32* size) {
8359 TPM_RC result;
8360 result = uint16_t_Unmarshal(target, buffer, size);
8361 if (result != TPM_RC_SUCCESS) {
8362 return result;
8363 }
8364 if (*target == TPM_SU_CLEAR) {
8365 return TPM_RC_SUCCESS;
8366 }
8367 if (*target == TPM_SU_STATE) {
8368 return TPM_RC_SUCCESS;
8369 }
8370 return TPM_RC_VALUE;
8371 }
8372
_ID_OBJECT_Marshal(_ID_OBJECT * source,BYTE ** buffer,INT32 * size)8373 UINT16 _ID_OBJECT_Marshal(_ID_OBJECT* source, BYTE** buffer, INT32* size) {
8374 UINT16 total_size = 0;
8375 total_size += TPM2B_DIGEST_Marshal(&source->integrityHMAC, buffer, size);
8376 total_size += TPM2B_DIGEST_Marshal(&source->encIdentity, buffer, size);
8377 return total_size;
8378 }
8379
_ID_OBJECT_Unmarshal(_ID_OBJECT * target,BYTE ** buffer,INT32 * size)8380 TPM_RC _ID_OBJECT_Unmarshal(_ID_OBJECT* target, BYTE** buffer, INT32* size) {
8381 TPM_RC result;
8382 result = TPM2B_DIGEST_Unmarshal(&target->integrityHMAC, buffer, size);
8383 if (result != TPM_RC_SUCCESS) {
8384 return result;
8385 }
8386 result = TPM2B_DIGEST_Unmarshal(&target->encIdentity, buffer, size);
8387 if (result != TPM_RC_SUCCESS) {
8388 return result;
8389 }
8390 return TPM_RC_SUCCESS;
8391 }
8392
_PRIVATE_Marshal(_PRIVATE * source,BYTE ** buffer,INT32 * size)8393 UINT16 _PRIVATE_Marshal(_PRIVATE* source, BYTE** buffer, INT32* size) {
8394 UINT16 total_size = 0;
8395 total_size += TPM2B_DIGEST_Marshal(&source->integrityOuter, buffer, size);
8396 total_size += TPM2B_DIGEST_Marshal(&source->integrityInner, buffer, size);
8397 total_size += TPMT_SENSITIVE_Marshal(&source->sensitive, buffer, size);
8398 return total_size;
8399 }
8400
_PRIVATE_Unmarshal(_PRIVATE * target,BYTE ** buffer,INT32 * size)8401 TPM_RC _PRIVATE_Unmarshal(_PRIVATE* target, BYTE** buffer, INT32* size) {
8402 TPM_RC result;
8403 result = TPM2B_DIGEST_Unmarshal(&target->integrityOuter, buffer, size);
8404 if (result != TPM_RC_SUCCESS) {
8405 return result;
8406 }
8407 result = TPM2B_DIGEST_Unmarshal(&target->integrityInner, buffer, size);
8408 if (result != TPM_RC_SUCCESS) {
8409 return result;
8410 }
8411 result = TPMT_SENSITIVE_Unmarshal(&target->sensitive, buffer, size);
8412 if (result != TPM_RC_SUCCESS) {
8413 return result;
8414 }
8415 return TPM_RC_SUCCESS;
8416 }
8417