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 #if defined(SUPPORT_PADDING_ONLY_RSASSA) && SUPPORT_PADDING_ONLY_RSASSA == YES
2353 return TPMI_ALG_HASH_Unmarshal(&target->hashAlg, buffer, size, TRUE);
2354 #else
2355 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2356 #endif
2357 }
2358
TPMS_ENC_SCHEME_OAEP_Marshal(TPMS_ENC_SCHEME_OAEP * source,BYTE ** buffer,INT32 * size)2359 UINT16 TPMS_ENC_SCHEME_OAEP_Marshal(TPMS_ENC_SCHEME_OAEP* source,
2360 BYTE** buffer,
2361 INT32* size) {
2362 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2363 }
2364
TPMS_ENC_SCHEME_OAEP_Unmarshal(TPMS_ENC_SCHEME_OAEP * target,BYTE ** buffer,INT32 * size)2365 TPM_RC TPMS_ENC_SCHEME_OAEP_Unmarshal(TPMS_ENC_SCHEME_OAEP* target,
2366 BYTE** buffer,
2367 INT32* size) {
2368 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2369 }
2370
TPMS_EMPTY_Marshal(TPMS_EMPTY * source,BYTE ** buffer,INT32 * size)2371 UINT16 TPMS_EMPTY_Marshal(TPMS_EMPTY* source, BYTE** buffer, INT32* size) {
2372 UINT16 total_size = 0;
2373 return total_size;
2374 }
2375
TPMS_EMPTY_Unmarshal(TPMS_EMPTY * target,BYTE ** buffer,INT32 * size)2376 TPM_RC TPMS_EMPTY_Unmarshal(TPMS_EMPTY* target, BYTE** buffer, INT32* size) {
2377 TPM_RC result;
2378 (void)result;
2379
2380 return TPM_RC_SUCCESS;
2381 }
2382
TPMS_ENC_SCHEME_RSAES_Marshal(TPMS_ENC_SCHEME_RSAES * source,BYTE ** buffer,INT32 * size)2383 UINT16 TPMS_ENC_SCHEME_RSAES_Marshal(TPMS_ENC_SCHEME_RSAES* source,
2384 BYTE** buffer,
2385 INT32* size) {
2386 return TPMS_EMPTY_Marshal(source, buffer, size);
2387 }
2388
TPMS_ENC_SCHEME_RSAES_Unmarshal(TPMS_ENC_SCHEME_RSAES * target,BYTE ** buffer,INT32 * size)2389 TPM_RC TPMS_ENC_SCHEME_RSAES_Unmarshal(TPMS_ENC_SCHEME_RSAES* target,
2390 BYTE** buffer,
2391 INT32* size) {
2392 return TPMS_EMPTY_Unmarshal(target, buffer, size);
2393 }
2394
TPMS_SIG_SCHEME_ECDSA_Marshal(TPMS_SIG_SCHEME_ECDSA * source,BYTE ** buffer,INT32 * size)2395 UINT16 TPMS_SIG_SCHEME_ECDSA_Marshal(TPMS_SIG_SCHEME_ECDSA* source,
2396 BYTE** buffer,
2397 INT32* size) {
2398 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2399 }
2400
TPMS_SIG_SCHEME_ECDSA_Unmarshal(TPMS_SIG_SCHEME_ECDSA * target,BYTE ** buffer,INT32 * size)2401 TPM_RC TPMS_SIG_SCHEME_ECDSA_Unmarshal(TPMS_SIG_SCHEME_ECDSA* target,
2402 BYTE** buffer,
2403 INT32* size) {
2404 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2405 }
2406
TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)2407 UINT16 TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME* source,
2408 BYTE** buffer,
2409 INT32* size,
2410 UINT32 selector) {
2411 switch (selector) {
2412 #ifdef TPM_ALG_ECDH
2413 case TPM_ALG_ECDH:
2414 return TPMS_KEY_SCHEME_ECDH_Marshal((TPMS_KEY_SCHEME_ECDH*)&source->ecdh,
2415 buffer, size);
2416 #endif
2417 #ifdef TPM_ALG_ECMQV
2418 case TPM_ALG_ECMQV:
2419 return TPMS_KEY_SCHEME_ECMQV_Marshal(
2420 (TPMS_KEY_SCHEME_ECMQV*)&source->ecmqv, buffer, size);
2421 #endif
2422 #ifdef TPM_ALG_RSASSA
2423 case TPM_ALG_RSASSA:
2424 return TPMS_SIG_SCHEME_RSASSA_Marshal(
2425 (TPMS_SIG_SCHEME_RSASSA*)&source->rsassa, buffer, size);
2426 #endif
2427 #ifdef TPM_ALG_RSAPSS
2428 case TPM_ALG_RSAPSS:
2429 return TPMS_SIG_SCHEME_RSAPSS_Marshal(
2430 (TPMS_SIG_SCHEME_RSAPSS*)&source->rsapss, buffer, size);
2431 #endif
2432 #ifdef TPM_ALG_ECDSA
2433 case TPM_ALG_ECDSA:
2434 return TPMS_SIG_SCHEME_ECDSA_Marshal(
2435 (TPMS_SIG_SCHEME_ECDSA*)&source->ecdsa, buffer, size);
2436 #endif
2437 #ifdef TPM_ALG_ECDAA
2438 case TPM_ALG_ECDAA:
2439 return TPMS_SIG_SCHEME_ECDAA_Marshal(
2440 (TPMS_SIG_SCHEME_ECDAA*)&source->ecdaa, buffer, size);
2441 #endif
2442 #ifdef TPM_ALG_SM2
2443 case TPM_ALG_SM2:
2444 return TPMS_SIG_SCHEME_SM2_Marshal((TPMS_SIG_SCHEME_SM2*)&source->sm2,
2445 buffer, size);
2446 #endif
2447 #ifdef TPM_ALG_ECSCHNORR
2448 case TPM_ALG_ECSCHNORR:
2449 return TPMS_SIG_SCHEME_ECSCHNORR_Marshal(
2450 (TPMS_SIG_SCHEME_ECSCHNORR*)&source->ecschnorr, buffer, size);
2451 #endif
2452 #ifdef TPM_ALG_RSAES
2453 case TPM_ALG_RSAES:
2454 return TPMS_ENC_SCHEME_RSAES_Marshal(
2455 (TPMS_ENC_SCHEME_RSAES*)&source->rsaes, buffer, size);
2456 #endif
2457 #ifdef TPM_ALG_OAEP
2458 case TPM_ALG_OAEP:
2459 return TPMS_ENC_SCHEME_OAEP_Marshal((TPMS_ENC_SCHEME_OAEP*)&source->oaep,
2460 buffer, size);
2461 #endif
2462 #ifdef TPM_ALG_NULL
2463 case TPM_ALG_NULL:
2464 return 0;
2465 #endif
2466 }
2467 return 0;
2468 }
2469
TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)2470 TPM_RC TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME* target,
2471 BYTE** buffer,
2472 INT32* size,
2473 UINT32 selector) {
2474 switch (selector) {
2475 #ifdef TPM_ALG_ECDH
2476 case TPM_ALG_ECDH:
2477 return TPMS_KEY_SCHEME_ECDH_Unmarshal(
2478 (TPMS_KEY_SCHEME_ECDH*)&target->ecdh, buffer, size);
2479 #endif
2480 #ifdef TPM_ALG_ECMQV
2481 case TPM_ALG_ECMQV:
2482 return TPMS_KEY_SCHEME_ECMQV_Unmarshal(
2483 (TPMS_KEY_SCHEME_ECMQV*)&target->ecmqv, buffer, size);
2484 #endif
2485 #ifdef TPM_ALG_RSASSA
2486 case TPM_ALG_RSASSA:
2487 return TPMS_SIG_SCHEME_RSASSA_Unmarshal(
2488 (TPMS_SIG_SCHEME_RSASSA*)&target->rsassa, buffer, size);
2489 #endif
2490 #ifdef TPM_ALG_RSAPSS
2491 case TPM_ALG_RSAPSS:
2492 return TPMS_SIG_SCHEME_RSAPSS_Unmarshal(
2493 (TPMS_SIG_SCHEME_RSAPSS*)&target->rsapss, buffer, size);
2494 #endif
2495 #ifdef TPM_ALG_ECDSA
2496 case TPM_ALG_ECDSA:
2497 return TPMS_SIG_SCHEME_ECDSA_Unmarshal(
2498 (TPMS_SIG_SCHEME_ECDSA*)&target->ecdsa, buffer, size);
2499 #endif
2500 #ifdef TPM_ALG_ECDAA
2501 case TPM_ALG_ECDAA:
2502 return TPMS_SIG_SCHEME_ECDAA_Unmarshal(
2503 (TPMS_SIG_SCHEME_ECDAA*)&target->ecdaa, buffer, size);
2504 #endif
2505 #ifdef TPM_ALG_SM2
2506 case TPM_ALG_SM2:
2507 return TPMS_SIG_SCHEME_SM2_Unmarshal((TPMS_SIG_SCHEME_SM2*)&target->sm2,
2508 buffer, size);
2509 #endif
2510 #ifdef TPM_ALG_ECSCHNORR
2511 case TPM_ALG_ECSCHNORR:
2512 return TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(
2513 (TPMS_SIG_SCHEME_ECSCHNORR*)&target->ecschnorr, buffer, size);
2514 #endif
2515 #ifdef TPM_ALG_RSAES
2516 case TPM_ALG_RSAES:
2517 return TPMS_ENC_SCHEME_RSAES_Unmarshal(
2518 (TPMS_ENC_SCHEME_RSAES*)&target->rsaes, buffer, size);
2519 #endif
2520 #ifdef TPM_ALG_OAEP
2521 case TPM_ALG_OAEP:
2522 return TPMS_ENC_SCHEME_OAEP_Unmarshal(
2523 (TPMS_ENC_SCHEME_OAEP*)&target->oaep, buffer, size);
2524 #endif
2525 #ifdef TPM_ALG_NULL
2526 case TPM_ALG_NULL:
2527 return TPM_RC_SUCCESS;
2528 #endif
2529 }
2530 return TPM_RC_SELECTOR;
2531 }
2532
TPMT_RSA_SCHEME_Marshal(TPMT_RSA_SCHEME * source,BYTE ** buffer,INT32 * size)2533 UINT16 TPMT_RSA_SCHEME_Marshal(TPMT_RSA_SCHEME* source,
2534 BYTE** buffer,
2535 INT32* size) {
2536 UINT16 total_size = 0;
2537 total_size += TPMI_ALG_RSA_SCHEME_Marshal(&source->scheme, buffer, size);
2538 total_size +=
2539 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2540 return total_size;
2541 }
2542
TPMT_RSA_SCHEME_Unmarshal(TPMT_RSA_SCHEME * target,BYTE ** buffer,INT32 * size)2543 TPM_RC TPMT_RSA_SCHEME_Unmarshal(TPMT_RSA_SCHEME* target,
2544 BYTE** buffer,
2545 INT32* size) {
2546 TPM_RC result;
2547 result = TPMI_ALG_RSA_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
2548 if (result != TPM_RC_SUCCESS) {
2549 return result;
2550 }
2551 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
2552 target->scheme);
2553 if (result != TPM_RC_SUCCESS) {
2554 return result;
2555 }
2556 return TPM_RC_SUCCESS;
2557 }
2558
TPMI_RSA_KEY_BITS_Marshal(TPMI_RSA_KEY_BITS * source,BYTE ** buffer,INT32 * size)2559 UINT16 TPMI_RSA_KEY_BITS_Marshal(TPMI_RSA_KEY_BITS* source,
2560 BYTE** buffer,
2561 INT32* size) {
2562 return uint16_t_Marshal(source, buffer, size);
2563 }
2564
TPMI_RSA_KEY_BITS_Unmarshal(TPMI_RSA_KEY_BITS * target,BYTE ** buffer,INT32 * size)2565 TPM_RC TPMI_RSA_KEY_BITS_Unmarshal(TPMI_RSA_KEY_BITS* target,
2566 BYTE** buffer,
2567 INT32* size) {
2568 TPM_RC result;
2569 uint16_t supported_values[] = RSA_KEY_SIZES_BITS;
2570 size_t length = sizeof(supported_values) / sizeof(supported_values[0]);
2571 size_t i;
2572 BOOL is_supported_value = FALSE;
2573 result = uint16_t_Unmarshal(target, buffer, size);
2574 if (result != TPM_RC_SUCCESS) {
2575 return result;
2576 }
2577 for (i = 0; i < length; ++i) {
2578 if (*target == supported_values[i]) {
2579 is_supported_value = TRUE;
2580 break;
2581 }
2582 }
2583 if (!is_supported_value) {
2584 return TPM_RC_VALUE;
2585 }
2586 return TPM_RC_SUCCESS;
2587 }
2588
TPMS_RSA_PARMS_Marshal(TPMS_RSA_PARMS * source,BYTE ** buffer,INT32 * size)2589 UINT16 TPMS_RSA_PARMS_Marshal(TPMS_RSA_PARMS* source,
2590 BYTE** buffer,
2591 INT32* size) {
2592 UINT16 total_size = 0;
2593 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->symmetric, buffer, size);
2594 total_size += TPMT_RSA_SCHEME_Marshal(&source->scheme, buffer, size);
2595 total_size += TPMI_RSA_KEY_BITS_Marshal(&source->keyBits, buffer, size);
2596 total_size += UINT32_Marshal(&source->exponent, buffer, size);
2597 return total_size;
2598 }
2599
TPMS_RSA_PARMS_Unmarshal(TPMS_RSA_PARMS * target,BYTE ** buffer,INT32 * size)2600 TPM_RC TPMS_RSA_PARMS_Unmarshal(TPMS_RSA_PARMS* target,
2601 BYTE** buffer,
2602 INT32* size) {
2603 TPM_RC result;
2604 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->symmetric, buffer, size);
2605 if (result != TPM_RC_SUCCESS) {
2606 return result;
2607 }
2608 result = TPMT_RSA_SCHEME_Unmarshal(&target->scheme, buffer, size);
2609 if (result != TPM_RC_SUCCESS) {
2610 return result;
2611 }
2612 result = TPMI_RSA_KEY_BITS_Unmarshal(&target->keyBits, buffer, size);
2613 if (result != TPM_RC_SUCCESS) {
2614 return result;
2615 }
2616 result = UINT32_Unmarshal(&target->exponent, buffer, size);
2617 if (result != TPM_RC_SUCCESS) {
2618 return result;
2619 }
2620 return TPM_RC_SUCCESS;
2621 }
2622
TPMS_SYMCIPHER_PARMS_Marshal(TPMS_SYMCIPHER_PARMS * source,BYTE ** buffer,INT32 * size)2623 UINT16 TPMS_SYMCIPHER_PARMS_Marshal(TPMS_SYMCIPHER_PARMS* source,
2624 BYTE** buffer,
2625 INT32* size) {
2626 UINT16 total_size = 0;
2627 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->sym, buffer, size);
2628 return total_size;
2629 }
2630
TPMS_SYMCIPHER_PARMS_Unmarshal(TPMS_SYMCIPHER_PARMS * target,BYTE ** buffer,INT32 * size)2631 TPM_RC TPMS_SYMCIPHER_PARMS_Unmarshal(TPMS_SYMCIPHER_PARMS* target,
2632 BYTE** buffer,
2633 INT32* size) {
2634 TPM_RC result;
2635 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->sym, buffer, size);
2636 if (result != TPM_RC_SUCCESS) {
2637 return result;
2638 }
2639 return TPM_RC_SUCCESS;
2640 }
2641
TPMI_ALG_ASYM_SCHEME_Marshal(TPMI_ALG_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size)2642 UINT16 TPMI_ALG_ASYM_SCHEME_Marshal(TPMI_ALG_ASYM_SCHEME* source,
2643 BYTE** buffer,
2644 INT32* size) {
2645 return uint16_t_Marshal(source, buffer, size);
2646 }
2647
TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2648 TPM_RC TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME* target,
2649 BYTE** buffer,
2650 INT32* size,
2651 BOOL allow_conditional_value) {
2652 TPM_RC result;
2653 BOOL has_valid_value = FALSE;
2654 result = uint16_t_Unmarshal(target, buffer, size);
2655 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2656 return result;
2657 }
2658 if (*target == TPM_ALG_NULL) {
2659 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
2660 }
2661 switch (*target) {
2662 #ifdef TPM_ALG_ECDH
2663 case TPM_ALG_ECDH:
2664 #endif
2665 #ifdef TPM_ALG_ECMQV
2666 case TPM_ALG_ECMQV:
2667 #endif
2668 #ifdef TPM_ALG_RSASSA
2669 case TPM_ALG_RSASSA:
2670 #endif
2671 #ifdef TPM_ALG_RSAPSS
2672 case TPM_ALG_RSAPSS:
2673 #endif
2674 #ifdef TPM_ALG_ECDSA
2675 case TPM_ALG_ECDSA:
2676 #endif
2677 #ifdef TPM_ALG_ECDAA
2678 case TPM_ALG_ECDAA:
2679 #endif
2680 #ifdef TPM_ALG_SM2
2681 case TPM_ALG_SM2:
2682 #endif
2683 #ifdef TPM_ALG_ECSCHNORR
2684 case TPM_ALG_ECSCHNORR:
2685 #endif
2686 #ifdef TPM_ALG_RSAES
2687 case TPM_ALG_RSAES:
2688 #endif
2689 #ifdef TPM_ALG_OAEP
2690 case TPM_ALG_OAEP:
2691 #endif
2692 has_valid_value = TRUE;
2693 break;
2694 }
2695 if (!has_valid_value) {
2696 return TPM_RC_VALUE;
2697 }
2698 return TPM_RC_SUCCESS;
2699 }
2700
TPMT_ASYM_SCHEME_Marshal(TPMT_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size)2701 UINT16 TPMT_ASYM_SCHEME_Marshal(TPMT_ASYM_SCHEME* source,
2702 BYTE** buffer,
2703 INT32* size) {
2704 UINT16 total_size = 0;
2705 total_size += TPMI_ALG_ASYM_SCHEME_Marshal(&source->scheme, buffer, size);
2706 total_size +=
2707 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2708 return total_size;
2709 }
2710
TPMT_ASYM_SCHEME_Unmarshal(TPMT_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size)2711 TPM_RC TPMT_ASYM_SCHEME_Unmarshal(TPMT_ASYM_SCHEME* target,
2712 BYTE** buffer,
2713 INT32* size) {
2714 TPM_RC result;
2715 result = TPMI_ALG_ASYM_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
2716 if (result != TPM_RC_SUCCESS) {
2717 return result;
2718 }
2719 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
2720 target->scheme);
2721 if (result != TPM_RC_SUCCESS) {
2722 return result;
2723 }
2724 return TPM_RC_SUCCESS;
2725 }
2726
TPMS_ASYM_PARMS_Marshal(TPMS_ASYM_PARMS * source,BYTE ** buffer,INT32 * size)2727 UINT16 TPMS_ASYM_PARMS_Marshal(TPMS_ASYM_PARMS* source,
2728 BYTE** buffer,
2729 INT32* size) {
2730 UINT16 total_size = 0;
2731 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->symmetric, buffer, size);
2732 total_size += TPMT_ASYM_SCHEME_Marshal(&source->scheme, buffer, size);
2733 return total_size;
2734 }
2735
TPMS_ASYM_PARMS_Unmarshal(TPMS_ASYM_PARMS * target,BYTE ** buffer,INT32 * size)2736 TPM_RC TPMS_ASYM_PARMS_Unmarshal(TPMS_ASYM_PARMS* target,
2737 BYTE** buffer,
2738 INT32* size) {
2739 TPM_RC result;
2740 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->symmetric, buffer, size);
2741 if (result != TPM_RC_SUCCESS) {
2742 return result;
2743 }
2744 result = TPMT_ASYM_SCHEME_Unmarshal(&target->scheme, buffer, size);
2745 if (result != TPM_RC_SUCCESS) {
2746 return result;
2747 }
2748 return TPM_RC_SUCCESS;
2749 }
2750
TPMI_ALG_KDF_Marshal(TPMI_ALG_KDF * source,BYTE ** buffer,INT32 * size)2751 UINT16 TPMI_ALG_KDF_Marshal(TPMI_ALG_KDF* source, BYTE** buffer, INT32* size) {
2752 return uint16_t_Marshal(source, buffer, size);
2753 }
2754
TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2755 TPM_RC TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF* target,
2756 BYTE** buffer,
2757 INT32* size,
2758 BOOL allow_conditional_value) {
2759 TPM_RC result;
2760 BOOL has_valid_value = FALSE;
2761 result = uint16_t_Unmarshal(target, buffer, size);
2762 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2763 return result;
2764 }
2765 if (*target == TPM_ALG_NULL) {
2766 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_KDF;
2767 }
2768 switch (*target) {
2769 #ifdef TPM_ALG_MGF1
2770 case TPM_ALG_MGF1:
2771 #endif
2772 #ifdef TPM_ALG_KDF1_SP800_56A
2773 case TPM_ALG_KDF1_SP800_56A:
2774 #endif
2775 #ifdef TPM_ALG_KDF2
2776 case TPM_ALG_KDF2:
2777 #endif
2778 #ifdef TPM_ALG_KDF1_SP800_108
2779 case TPM_ALG_KDF1_SP800_108:
2780 #endif
2781 has_valid_value = TRUE;
2782 break;
2783 }
2784 if (!has_valid_value) {
2785 return TPM_RC_KDF;
2786 }
2787 return TPM_RC_SUCCESS;
2788 }
2789
TPMS_SCHEME_KDF1_SP800_108_Marshal(TPMS_SCHEME_KDF1_SP800_108 * source,BYTE ** buffer,INT32 * size)2790 UINT16 TPMS_SCHEME_KDF1_SP800_108_Marshal(TPMS_SCHEME_KDF1_SP800_108* source,
2791 BYTE** buffer,
2792 INT32* size) {
2793 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2794 }
2795
TPMS_SCHEME_KDF1_SP800_108_Unmarshal(TPMS_SCHEME_KDF1_SP800_108 * target,BYTE ** buffer,INT32 * size)2796 TPM_RC TPMS_SCHEME_KDF1_SP800_108_Unmarshal(TPMS_SCHEME_KDF1_SP800_108* target,
2797 BYTE** buffer,
2798 INT32* size) {
2799 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2800 }
2801
TPMS_SCHEME_KDF2_Marshal(TPMS_SCHEME_KDF2 * source,BYTE ** buffer,INT32 * size)2802 UINT16 TPMS_SCHEME_KDF2_Marshal(TPMS_SCHEME_KDF2* source,
2803 BYTE** buffer,
2804 INT32* size) {
2805 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2806 }
2807
TPMS_SCHEME_KDF2_Unmarshal(TPMS_SCHEME_KDF2 * target,BYTE ** buffer,INT32 * size)2808 TPM_RC TPMS_SCHEME_KDF2_Unmarshal(TPMS_SCHEME_KDF2* target,
2809 BYTE** buffer,
2810 INT32* size) {
2811 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2812 }
2813
TPMS_SCHEME_KDF1_SP800_56A_Marshal(TPMS_SCHEME_KDF1_SP800_56A * source,BYTE ** buffer,INT32 * size)2814 UINT16 TPMS_SCHEME_KDF1_SP800_56A_Marshal(TPMS_SCHEME_KDF1_SP800_56A* source,
2815 BYTE** buffer,
2816 INT32* size) {
2817 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2818 }
2819
TPMS_SCHEME_KDF1_SP800_56A_Unmarshal(TPMS_SCHEME_KDF1_SP800_56A * target,BYTE ** buffer,INT32 * size)2820 TPM_RC TPMS_SCHEME_KDF1_SP800_56A_Unmarshal(TPMS_SCHEME_KDF1_SP800_56A* target,
2821 BYTE** buffer,
2822 INT32* size) {
2823 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2824 }
2825
TPMS_SCHEME_MGF1_Marshal(TPMS_SCHEME_MGF1 * source,BYTE ** buffer,INT32 * size)2826 UINT16 TPMS_SCHEME_MGF1_Marshal(TPMS_SCHEME_MGF1* source,
2827 BYTE** buffer,
2828 INT32* size) {
2829 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
2830 }
2831
TPMS_SCHEME_MGF1_Unmarshal(TPMS_SCHEME_MGF1 * target,BYTE ** buffer,INT32 * size)2832 TPM_RC TPMS_SCHEME_MGF1_Unmarshal(TPMS_SCHEME_MGF1* target,
2833 BYTE** buffer,
2834 INT32* size) {
2835 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
2836 }
2837
TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)2838 UINT16 TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME* source,
2839 BYTE** buffer,
2840 INT32* size,
2841 UINT32 selector) {
2842 switch (selector) {
2843 #ifdef TPM_ALG_MGF1
2844 case TPM_ALG_MGF1:
2845 return TPMS_SCHEME_MGF1_Marshal((TPMS_SCHEME_MGF1*)&source->mgf1, buffer,
2846 size);
2847 #endif
2848 #ifdef TPM_ALG_KDF1_SP800_56A
2849 case TPM_ALG_KDF1_SP800_56A:
2850 return TPMS_SCHEME_KDF1_SP800_56A_Marshal(
2851 (TPMS_SCHEME_KDF1_SP800_56A*)&source->kdf1_sp800_56a, buffer, size);
2852 #endif
2853 #ifdef TPM_ALG_KDF2
2854 case TPM_ALG_KDF2:
2855 return TPMS_SCHEME_KDF2_Marshal((TPMS_SCHEME_KDF2*)&source->kdf2, buffer,
2856 size);
2857 #endif
2858 #ifdef TPM_ALG_KDF1_SP800_108
2859 case TPM_ALG_KDF1_SP800_108:
2860 return TPMS_SCHEME_KDF1_SP800_108_Marshal(
2861 (TPMS_SCHEME_KDF1_SP800_108*)&source->kdf1_sp800_108, buffer, size);
2862 #endif
2863 #ifdef TPM_ALG_NULL
2864 case TPM_ALG_NULL:
2865 return 0;
2866 #endif
2867 }
2868 return 0;
2869 }
2870
TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)2871 TPM_RC TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME* target,
2872 BYTE** buffer,
2873 INT32* size,
2874 UINT32 selector) {
2875 switch (selector) {
2876 #ifdef TPM_ALG_MGF1
2877 case TPM_ALG_MGF1:
2878 return TPMS_SCHEME_MGF1_Unmarshal((TPMS_SCHEME_MGF1*)&target->mgf1,
2879 buffer, size);
2880 #endif
2881 #ifdef TPM_ALG_KDF1_SP800_56A
2882 case TPM_ALG_KDF1_SP800_56A:
2883 return TPMS_SCHEME_KDF1_SP800_56A_Unmarshal(
2884 (TPMS_SCHEME_KDF1_SP800_56A*)&target->kdf1_sp800_56a, buffer, size);
2885 #endif
2886 #ifdef TPM_ALG_KDF2
2887 case TPM_ALG_KDF2:
2888 return TPMS_SCHEME_KDF2_Unmarshal((TPMS_SCHEME_KDF2*)&target->kdf2,
2889 buffer, size);
2890 #endif
2891 #ifdef TPM_ALG_KDF1_SP800_108
2892 case TPM_ALG_KDF1_SP800_108:
2893 return TPMS_SCHEME_KDF1_SP800_108_Unmarshal(
2894 (TPMS_SCHEME_KDF1_SP800_108*)&target->kdf1_sp800_108, buffer, size);
2895 #endif
2896 #ifdef TPM_ALG_NULL
2897 case TPM_ALG_NULL:
2898 return TPM_RC_SUCCESS;
2899 #endif
2900 }
2901 return TPM_RC_SELECTOR;
2902 }
2903
TPMT_KDF_SCHEME_Marshal(TPMT_KDF_SCHEME * source,BYTE ** buffer,INT32 * size)2904 UINT16 TPMT_KDF_SCHEME_Marshal(TPMT_KDF_SCHEME* source,
2905 BYTE** buffer,
2906 INT32* size) {
2907 UINT16 total_size = 0;
2908 total_size += TPMI_ALG_KDF_Marshal(&source->scheme, buffer, size);
2909 total_size +=
2910 TPMU_KDF_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2911 return total_size;
2912 }
2913
TPMT_KDF_SCHEME_Unmarshal(TPMT_KDF_SCHEME * target,BYTE ** buffer,INT32 * size)2914 TPM_RC TPMT_KDF_SCHEME_Unmarshal(TPMT_KDF_SCHEME* target,
2915 BYTE** buffer,
2916 INT32* size) {
2917 TPM_RC result;
2918 result = TPMI_ALG_KDF_Unmarshal(&target->scheme, buffer, size, TRUE);
2919 if (result != TPM_RC_SUCCESS) {
2920 return result;
2921 }
2922 result =
2923 TPMU_KDF_SCHEME_Unmarshal(&target->details, buffer, size, target->scheme);
2924 if (result != TPM_RC_SUCCESS) {
2925 return result;
2926 }
2927 return TPM_RC_SUCCESS;
2928 }
2929
TPMI_ALG_ECC_SCHEME_Marshal(TPMI_ALG_ECC_SCHEME * source,BYTE ** buffer,INT32 * size)2930 UINT16 TPMI_ALG_ECC_SCHEME_Marshal(TPMI_ALG_ECC_SCHEME* source,
2931 BYTE** buffer,
2932 INT32* size) {
2933 return uint16_t_Marshal(source, buffer, size);
2934 }
2935
TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)2936 TPM_RC TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME* target,
2937 BYTE** buffer,
2938 INT32* size,
2939 BOOL allow_conditional_value) {
2940 TPM_RC result;
2941 BOOL has_valid_value = FALSE;
2942 result = uint16_t_Unmarshal(target, buffer, size);
2943 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
2944 return result;
2945 }
2946 if (*target == TPM_ALG_NULL) {
2947 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SCHEME;
2948 }
2949 switch (*target) {
2950 #ifdef TPM_ALG_ECDSA
2951 case TPM_ALG_ECDSA:
2952 #endif
2953 #ifdef TPM_ALG_ECDAA
2954 case TPM_ALG_ECDAA:
2955 #endif
2956 #ifdef TPM_ALG_SM2
2957 case TPM_ALG_SM2:
2958 #endif
2959 #ifdef TPM_ALG_ECSCHNORR
2960 case TPM_ALG_ECSCHNORR:
2961 #endif
2962 #ifdef TPM_ALG_ECDH
2963 case TPM_ALG_ECDH:
2964 #endif
2965 #ifdef TPM_ALG_ECMQV
2966 case TPM_ALG_ECMQV:
2967 #endif
2968 has_valid_value = TRUE;
2969 break;
2970 }
2971 if (!has_valid_value) {
2972 return TPM_RC_SCHEME;
2973 }
2974 return TPM_RC_SUCCESS;
2975 }
2976
TPMT_ECC_SCHEME_Marshal(TPMT_ECC_SCHEME * source,BYTE ** buffer,INT32 * size)2977 UINT16 TPMT_ECC_SCHEME_Marshal(TPMT_ECC_SCHEME* source,
2978 BYTE** buffer,
2979 INT32* size) {
2980 UINT16 total_size = 0;
2981 total_size += TPMI_ALG_ECC_SCHEME_Marshal(&source->scheme, buffer, size);
2982 total_size +=
2983 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
2984 return total_size;
2985 }
2986
TPMT_ECC_SCHEME_Unmarshal(TPMT_ECC_SCHEME * target,BYTE ** buffer,INT32 * size)2987 TPM_RC TPMT_ECC_SCHEME_Unmarshal(TPMT_ECC_SCHEME* target,
2988 BYTE** buffer,
2989 INT32* size) {
2990 TPM_RC result;
2991 result = TPMI_ALG_ECC_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
2992 if (result != TPM_RC_SUCCESS) {
2993 return result;
2994 }
2995 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
2996 target->scheme);
2997 if (result != TPM_RC_SUCCESS) {
2998 return result;
2999 }
3000 return TPM_RC_SUCCESS;
3001 }
3002
TPMI_ECC_CURVE_Marshal(TPMI_ECC_CURVE * source,BYTE ** buffer,INT32 * size)3003 UINT16 TPMI_ECC_CURVE_Marshal(TPMI_ECC_CURVE* source,
3004 BYTE** buffer,
3005 INT32* size) {
3006 return uint16_t_Marshal(source, buffer, size);
3007 }
3008
TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE * target,BYTE ** buffer,INT32 * size)3009 TPM_RC TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE* target,
3010 BYTE** buffer,
3011 INT32* size) {
3012 TPM_RC result;
3013 uint16_t supported_values[] = ECC_CURVES;
3014 size_t length = sizeof(supported_values) / sizeof(supported_values[0]);
3015 size_t i;
3016 BOOL is_supported_value = FALSE;
3017 result = uint16_t_Unmarshal(target, buffer, size);
3018 if (result != TPM_RC_SUCCESS) {
3019 return result;
3020 }
3021 for (i = 0; i < length; ++i) {
3022 if (*target == supported_values[i]) {
3023 is_supported_value = TRUE;
3024 break;
3025 }
3026 }
3027 if (!is_supported_value) {
3028 return TPM_RC_CURVE;
3029 }
3030 return TPM_RC_SUCCESS;
3031 }
3032
TPMS_ECC_PARMS_Marshal(TPMS_ECC_PARMS * source,BYTE ** buffer,INT32 * size)3033 UINT16 TPMS_ECC_PARMS_Marshal(TPMS_ECC_PARMS* source,
3034 BYTE** buffer,
3035 INT32* size) {
3036 UINT16 total_size = 0;
3037 total_size += TPMT_SYM_DEF_OBJECT_Marshal(&source->symmetric, buffer, size);
3038 total_size += TPMT_ECC_SCHEME_Marshal(&source->scheme, buffer, size);
3039 total_size += TPMI_ECC_CURVE_Marshal(&source->curveID, buffer, size);
3040 total_size += TPMT_KDF_SCHEME_Marshal(&source->kdf, buffer, size);
3041 return total_size;
3042 }
3043
TPMS_ECC_PARMS_Unmarshal(TPMS_ECC_PARMS * target,BYTE ** buffer,INT32 * size)3044 TPM_RC TPMS_ECC_PARMS_Unmarshal(TPMS_ECC_PARMS* target,
3045 BYTE** buffer,
3046 INT32* size) {
3047 TPM_RC result;
3048 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&target->symmetric, buffer, size);
3049 if (result != TPM_RC_SUCCESS) {
3050 return result;
3051 }
3052 result = TPMT_ECC_SCHEME_Unmarshal(&target->scheme, buffer, size);
3053 if (result != TPM_RC_SUCCESS) {
3054 return result;
3055 }
3056 result = TPMI_ECC_CURVE_Unmarshal(&target->curveID, buffer, size);
3057 if (result != TPM_RC_SUCCESS) {
3058 return result;
3059 }
3060 result = TPMT_KDF_SCHEME_Unmarshal(&target->kdf, buffer, size);
3061 if (result != TPM_RC_SUCCESS) {
3062 return result;
3063 }
3064 return TPM_RC_SUCCESS;
3065 }
3066
TPMI_ALG_KEYEDHASH_SCHEME_Marshal(TPMI_ALG_KEYEDHASH_SCHEME * source,BYTE ** buffer,INT32 * size)3067 UINT16 TPMI_ALG_KEYEDHASH_SCHEME_Marshal(TPMI_ALG_KEYEDHASH_SCHEME* source,
3068 BYTE** buffer,
3069 INT32* size) {
3070 return uint16_t_Marshal(source, buffer, size);
3071 }
3072
TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3073 TPM_RC TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME* target,
3074 BYTE** buffer,
3075 INT32* size,
3076 BOOL allow_conditional_value) {
3077 TPM_RC result;
3078 BOOL has_valid_value = FALSE;
3079 result = uint16_t_Unmarshal(target, buffer, size);
3080 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3081 return result;
3082 }
3083 if (*target == TPM_ALG_NULL) {
3084 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
3085 }
3086 switch (*target) {
3087 #ifdef TPM_ALG_HMAC
3088 case TPM_ALG_HMAC:
3089 #endif
3090 #ifdef TPM_ALG_XOR
3091 case TPM_ALG_XOR:
3092 #endif
3093 has_valid_value = TRUE;
3094 break;
3095 }
3096 if (!has_valid_value) {
3097 return TPM_RC_VALUE;
3098 }
3099 return TPM_RC_SUCCESS;
3100 }
3101
TPMS_SCHEME_HMAC_Marshal(TPMS_SCHEME_HMAC * source,BYTE ** buffer,INT32 * size)3102 UINT16 TPMS_SCHEME_HMAC_Marshal(TPMS_SCHEME_HMAC* source,
3103 BYTE** buffer,
3104 INT32* size) {
3105 return TPMS_SCHEME_HASH_Marshal(source, buffer, size);
3106 }
3107
TPMS_SCHEME_HMAC_Unmarshal(TPMS_SCHEME_HMAC * target,BYTE ** buffer,INT32 * size)3108 TPM_RC TPMS_SCHEME_HMAC_Unmarshal(TPMS_SCHEME_HMAC* target,
3109 BYTE** buffer,
3110 INT32* size) {
3111 return TPMS_SCHEME_HASH_Unmarshal(target, buffer, size);
3112 }
3113
TPMS_SCHEME_XOR_Marshal(TPMS_SCHEME_XOR * source,BYTE ** buffer,INT32 * size)3114 UINT16 TPMS_SCHEME_XOR_Marshal(TPMS_SCHEME_XOR* source,
3115 BYTE** buffer,
3116 INT32* size) {
3117 UINT16 total_size = 0;
3118 total_size += TPMI_ALG_HASH_Marshal(&source->hashAlg, buffer, size);
3119 total_size += TPMI_ALG_KDF_Marshal(&source->kdf, buffer, size);
3120 return total_size;
3121 }
3122
TPMS_SCHEME_XOR_Unmarshal(TPMS_SCHEME_XOR * target,BYTE ** buffer,INT32 * size)3123 TPM_RC TPMS_SCHEME_XOR_Unmarshal(TPMS_SCHEME_XOR* target,
3124 BYTE** buffer,
3125 INT32* size) {
3126 TPM_RC result;
3127 result = TPMI_ALG_HASH_Unmarshal(&target->hashAlg, buffer, size, TRUE);
3128 if (result != TPM_RC_SUCCESS) {
3129 return result;
3130 }
3131 result = TPMI_ALG_KDF_Unmarshal(&target->kdf, buffer, size, FALSE);
3132 if (result != TPM_RC_SUCCESS) {
3133 return result;
3134 }
3135 return TPM_RC_SUCCESS;
3136 }
3137
TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH * source,BYTE ** buffer,INT32 * size,UINT32 selector)3138 UINT16 TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH* source,
3139 BYTE** buffer,
3140 INT32* size,
3141 UINT32 selector) {
3142 switch (selector) {
3143 #ifdef TPM_ALG_HMAC
3144 case TPM_ALG_HMAC:
3145 return TPMS_SCHEME_HMAC_Marshal((TPMS_SCHEME_HMAC*)&source->hmac, buffer,
3146 size);
3147 #endif
3148 #ifdef TPM_ALG_XOR
3149 case TPM_ALG_XOR:
3150 return TPMS_SCHEME_XOR_Marshal((TPMS_SCHEME_XOR*)&source->xor_, buffer,
3151 size);
3152 #endif
3153 #ifdef TPM_ALG_NULL
3154 case TPM_ALG_NULL:
3155 return 0;
3156 #endif
3157 }
3158 return 0;
3159 }
3160
TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH * target,BYTE ** buffer,INT32 * size,UINT32 selector)3161 TPM_RC TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH* target,
3162 BYTE** buffer,
3163 INT32* size,
3164 UINT32 selector) {
3165 switch (selector) {
3166 #ifdef TPM_ALG_HMAC
3167 case TPM_ALG_HMAC:
3168 return TPMS_SCHEME_HMAC_Unmarshal((TPMS_SCHEME_HMAC*)&target->hmac,
3169 buffer, size);
3170 #endif
3171 #ifdef TPM_ALG_XOR
3172 case TPM_ALG_XOR:
3173 return TPMS_SCHEME_XOR_Unmarshal((TPMS_SCHEME_XOR*)&target->xor_, buffer,
3174 size);
3175 #endif
3176 #ifdef TPM_ALG_NULL
3177 case TPM_ALG_NULL:
3178 return TPM_RC_SUCCESS;
3179 #endif
3180 }
3181 return TPM_RC_SELECTOR;
3182 }
3183
TPMT_KEYEDHASH_SCHEME_Marshal(TPMT_KEYEDHASH_SCHEME * source,BYTE ** buffer,INT32 * size)3184 UINT16 TPMT_KEYEDHASH_SCHEME_Marshal(TPMT_KEYEDHASH_SCHEME* source,
3185 BYTE** buffer,
3186 INT32* size) {
3187 UINT16 total_size = 0;
3188 total_size +=
3189 TPMI_ALG_KEYEDHASH_SCHEME_Marshal(&source->scheme, buffer, size);
3190 total_size += TPMU_SCHEME_KEYEDHASH_Marshal(&source->details, buffer, size,
3191 source->scheme);
3192 return total_size;
3193 }
3194
TPMT_KEYEDHASH_SCHEME_Unmarshal(TPMT_KEYEDHASH_SCHEME * target,BYTE ** buffer,INT32 * size)3195 TPM_RC TPMT_KEYEDHASH_SCHEME_Unmarshal(TPMT_KEYEDHASH_SCHEME* target,
3196 BYTE** buffer,
3197 INT32* size) {
3198 TPM_RC result;
3199 result =
3200 TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
3201 if (result != TPM_RC_SUCCESS) {
3202 return result;
3203 }
3204 result = TPMU_SCHEME_KEYEDHASH_Unmarshal(&target->details, buffer, size,
3205 target->scheme);
3206 if (result != TPM_RC_SUCCESS) {
3207 return result;
3208 }
3209 return TPM_RC_SUCCESS;
3210 }
3211
TPMS_KEYEDHASH_PARMS_Marshal(TPMS_KEYEDHASH_PARMS * source,BYTE ** buffer,INT32 * size)3212 UINT16 TPMS_KEYEDHASH_PARMS_Marshal(TPMS_KEYEDHASH_PARMS* source,
3213 BYTE** buffer,
3214 INT32* size) {
3215 UINT16 total_size = 0;
3216 total_size += TPMT_KEYEDHASH_SCHEME_Marshal(&source->scheme, buffer, size);
3217 return total_size;
3218 }
3219
TPMS_KEYEDHASH_PARMS_Unmarshal(TPMS_KEYEDHASH_PARMS * target,BYTE ** buffer,INT32 * size)3220 TPM_RC TPMS_KEYEDHASH_PARMS_Unmarshal(TPMS_KEYEDHASH_PARMS* target,
3221 BYTE** buffer,
3222 INT32* size) {
3223 TPM_RC result;
3224 result = TPMT_KEYEDHASH_SCHEME_Unmarshal(&target->scheme, buffer, size);
3225 if (result != TPM_RC_SUCCESS) {
3226 return result;
3227 }
3228 return TPM_RC_SUCCESS;
3229 }
3230
TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS * source,BYTE ** buffer,INT32 * size,UINT32 selector)3231 UINT16 TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS* source,
3232 BYTE** buffer,
3233 INT32* size,
3234 UINT32 selector) {
3235 switch (selector) {
3236 #ifdef TPM_ALG_KEYEDHASH
3237 case TPM_ALG_KEYEDHASH:
3238 return TPMS_KEYEDHASH_PARMS_Marshal(
3239 (TPMS_KEYEDHASH_PARMS*)&source->keyedHashDetail, buffer, size);
3240 #endif
3241 #ifdef TPM_ALG_SYMCIPHER
3242 case TPM_ALG_SYMCIPHER:
3243 return TPMS_SYMCIPHER_PARMS_Marshal(
3244 (TPMS_SYMCIPHER_PARMS*)&source->symDetail, buffer, size);
3245 #endif
3246 #ifdef TPM_ALG_RSA
3247 case TPM_ALG_RSA:
3248 return TPMS_RSA_PARMS_Marshal((TPMS_RSA_PARMS*)&source->rsaDetail, buffer,
3249 size);
3250 #endif
3251 #ifdef TPM_ALG_ECC
3252 case TPM_ALG_ECC:
3253 return TPMS_ECC_PARMS_Marshal((TPMS_ECC_PARMS*)&source->eccDetail, buffer,
3254 size);
3255 #endif
3256 }
3257 return 0;
3258 }
3259
TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS * target,BYTE ** buffer,INT32 * size,UINT32 selector)3260 TPM_RC TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS* target,
3261 BYTE** buffer,
3262 INT32* size,
3263 UINT32 selector) {
3264 switch (selector) {
3265 #ifdef TPM_ALG_KEYEDHASH
3266 case TPM_ALG_KEYEDHASH:
3267 return TPMS_KEYEDHASH_PARMS_Unmarshal(
3268 (TPMS_KEYEDHASH_PARMS*)&target->keyedHashDetail, buffer, size);
3269 #endif
3270 #ifdef TPM_ALG_SYMCIPHER
3271 case TPM_ALG_SYMCIPHER:
3272 return TPMS_SYMCIPHER_PARMS_Unmarshal(
3273 (TPMS_SYMCIPHER_PARMS*)&target->symDetail, buffer, size);
3274 #endif
3275 #ifdef TPM_ALG_RSA
3276 case TPM_ALG_RSA:
3277 return TPMS_RSA_PARMS_Unmarshal((TPMS_RSA_PARMS*)&target->rsaDetail,
3278 buffer, size);
3279 #endif
3280 #ifdef TPM_ALG_ECC
3281 case TPM_ALG_ECC:
3282 return TPMS_ECC_PARMS_Unmarshal((TPMS_ECC_PARMS*)&target->eccDetail,
3283 buffer, size);
3284 #endif
3285 }
3286 return TPM_RC_SELECTOR;
3287 }
3288
TPMT_PUBLIC_Marshal(TPMT_PUBLIC * source,BYTE ** buffer,INT32 * size)3289 UINT16 TPMT_PUBLIC_Marshal(TPMT_PUBLIC* source, BYTE** buffer, INT32* size) {
3290 UINT16 total_size = 0;
3291 total_size += TPMI_ALG_PUBLIC_Marshal(&source->type, buffer, size);
3292 total_size += TPMI_ALG_HASH_Marshal(&source->nameAlg, buffer, size);
3293 total_size += TPMA_OBJECT_Marshal(&source->objectAttributes, buffer, size);
3294 total_size += TPM2B_DIGEST_Marshal(&source->authPolicy, buffer, size);
3295 total_size += TPMU_PUBLIC_PARMS_Marshal(&source->parameters, buffer, size,
3296 source->type);
3297 total_size +=
3298 TPMU_PUBLIC_ID_Marshal(&source->unique, buffer, size, source->type);
3299 return total_size;
3300 }
3301
TPMT_PUBLIC_Unmarshal(TPMT_PUBLIC * target,BYTE ** buffer,INT32 * size)3302 TPM_RC TPMT_PUBLIC_Unmarshal(TPMT_PUBLIC* target, BYTE** buffer, INT32* size) {
3303 TPM_RC result;
3304 result = TPMI_ALG_PUBLIC_Unmarshal(&target->type, buffer, size);
3305 if (result != TPM_RC_SUCCESS) {
3306 return result;
3307 }
3308 result = TPMI_ALG_HASH_Unmarshal(&target->nameAlg, buffer, size, TRUE);
3309 if (result != TPM_RC_SUCCESS) {
3310 return result;
3311 }
3312 result = TPMA_OBJECT_Unmarshal(&target->objectAttributes, buffer, size);
3313 if (result != TPM_RC_SUCCESS) {
3314 return result;
3315 }
3316 result = TPM2B_DIGEST_Unmarshal(&target->authPolicy, buffer, size);
3317 if (result != TPM_RC_SUCCESS) {
3318 return result;
3319 }
3320 result = TPMU_PUBLIC_PARMS_Unmarshal(&target->parameters, buffer, size,
3321 target->type);
3322 if (result != TPM_RC_SUCCESS) {
3323 return result;
3324 }
3325 result =
3326 TPMU_PUBLIC_ID_Unmarshal(&target->unique, buffer, size, target->type);
3327 if (result != TPM_RC_SUCCESS) {
3328 return result;
3329 }
3330 return TPM_RC_SUCCESS;
3331 }
3332
TPM2B_PUBLIC_Marshal(TPM2B_PUBLIC * source,BYTE ** buffer,INT32 * size)3333 UINT16 TPM2B_PUBLIC_Marshal(TPM2B_PUBLIC* source, BYTE** buffer, INT32* size) {
3334 UINT16 total_size = 0;
3335 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3336 total_size += TPMT_PUBLIC_Marshal(&source->t.publicArea, buffer, size);
3337 {
3338 BYTE* size_location = *buffer - total_size;
3339 INT32 size_field_size = sizeof(UINT16);
3340 UINT16 payload_size = total_size - (UINT16)size_field_size;
3341 UINT16_Marshal(&payload_size, &size_location, &size_field_size);
3342 }
3343 return total_size;
3344 }
3345
TPM2B_PUBLIC_Unmarshal(TPM2B_PUBLIC * target,BYTE ** buffer,INT32 * size)3346 TPM_RC TPM2B_PUBLIC_Unmarshal(TPM2B_PUBLIC* target,
3347 BYTE** buffer,
3348 INT32* size) {
3349 TPM_RC result;
3350 UINT32 start_size = *size;
3351 UINT32 struct_size;
3352 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3353 if (result != TPM_RC_SUCCESS) {
3354 return result;
3355 }
3356 if (target->t.size == 0) {
3357 return TPM_RC_SIZE;
3358 }
3359 result = TPMT_PUBLIC_Unmarshal(&target->t.publicArea, buffer, size);
3360 if (result != TPM_RC_SUCCESS) {
3361 return result;
3362 }
3363 struct_size = start_size - *size - sizeof(target->t.size);
3364 if (struct_size != target->t.size) {
3365 return TPM_RC_SIZE;
3366 }
3367 return TPM_RC_SUCCESS;
3368 }
3369
TPM2B_SENSITIVE_DATA_Marshal(TPM2B_SENSITIVE_DATA * source,BYTE ** buffer,INT32 * size)3370 UINT16 TPM2B_SENSITIVE_DATA_Marshal(TPM2B_SENSITIVE_DATA* source,
3371 BYTE** buffer,
3372 INT32* size) {
3373 UINT16 total_size = 0;
3374 INT32 i;
3375 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3376 for (i = 0; i < source->t.size; ++i) {
3377 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
3378 }
3379 return total_size;
3380 }
3381
TPM2B_SENSITIVE_DATA_Unmarshal(TPM2B_SENSITIVE_DATA * target,BYTE ** buffer,INT32 * size)3382 TPM_RC TPM2B_SENSITIVE_DATA_Unmarshal(TPM2B_SENSITIVE_DATA* target,
3383 BYTE** buffer,
3384 INT32* size) {
3385 TPM_RC result;
3386 INT32 i;
3387 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3388 if (result != TPM_RC_SUCCESS) {
3389 return result;
3390 }
3391 if (target->t.size == 0) {
3392 return TPM_RC_SUCCESS;
3393 }
3394 if (target->t.size > MAX_SYM_DATA) {
3395 return TPM_RC_SIZE;
3396 }
3397 for (i = 0; i < target->t.size; ++i) {
3398 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
3399 if (result != TPM_RC_SUCCESS) {
3400 return result;
3401 }
3402 }
3403 return TPM_RC_SUCCESS;
3404 }
3405
TPM2B_SYM_KEY_Marshal(TPM2B_SYM_KEY * source,BYTE ** buffer,INT32 * size)3406 UINT16 TPM2B_SYM_KEY_Marshal(TPM2B_SYM_KEY* source,
3407 BYTE** buffer,
3408 INT32* size) {
3409 UINT16 total_size = 0;
3410 INT32 i;
3411 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3412 for (i = 0; i < source->t.size; ++i) {
3413 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
3414 }
3415 return total_size;
3416 }
3417
TPM2B_SYM_KEY_Unmarshal(TPM2B_SYM_KEY * target,BYTE ** buffer,INT32 * size)3418 TPM_RC TPM2B_SYM_KEY_Unmarshal(TPM2B_SYM_KEY* target,
3419 BYTE** buffer,
3420 INT32* size) {
3421 TPM_RC result;
3422 INT32 i;
3423 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3424 if (result != TPM_RC_SUCCESS) {
3425 return result;
3426 }
3427 if (target->t.size == 0) {
3428 return TPM_RC_SUCCESS;
3429 }
3430 if (target->t.size > MAX_SYM_KEY_BYTES) {
3431 return TPM_RC_SIZE;
3432 }
3433 for (i = 0; i < target->t.size; ++i) {
3434 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
3435 if (result != TPM_RC_SUCCESS) {
3436 return result;
3437 }
3438 }
3439 return TPM_RC_SUCCESS;
3440 }
3441
TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE * source,BYTE ** buffer,INT32 * size,UINT32 selector)3442 UINT16 TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE* source,
3443 BYTE** buffer,
3444 INT32* size,
3445 UINT32 selector) {
3446 switch (selector) {
3447 #ifdef TPM_ALG_RSA
3448 case TPM_ALG_RSA:
3449 return TPM2B_PRIVATE_KEY_RSA_Marshal((TPM2B_PRIVATE_KEY_RSA*)&source->rsa,
3450 buffer, size);
3451 #endif
3452 #ifdef TPM_ALG_ECC
3453 case TPM_ALG_ECC:
3454 return TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER*)&source->ecc,
3455 buffer, size);
3456 #endif
3457 #ifdef TPM_ALG_KEYEDHASH
3458 case TPM_ALG_KEYEDHASH:
3459 return TPM2B_SENSITIVE_DATA_Marshal((TPM2B_SENSITIVE_DATA*)&source->bits,
3460 buffer, size);
3461 #endif
3462 #ifdef TPM_ALG_SYMCIPHER
3463 case TPM_ALG_SYMCIPHER:
3464 return TPM2B_SYM_KEY_Marshal((TPM2B_SYM_KEY*)&source->sym, buffer, size);
3465 #endif
3466 }
3467 return 0;
3468 }
3469
TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE * target,BYTE ** buffer,INT32 * size,UINT32 selector)3470 TPM_RC TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE* target,
3471 BYTE** buffer,
3472 INT32* size,
3473 UINT32 selector) {
3474 switch (selector) {
3475 #ifdef TPM_ALG_RSA
3476 case TPM_ALG_RSA:
3477 return TPM2B_PRIVATE_KEY_RSA_Unmarshal(
3478 (TPM2B_PRIVATE_KEY_RSA*)&target->rsa, buffer, size);
3479 #endif
3480 #ifdef TPM_ALG_ECC
3481 case TPM_ALG_ECC:
3482 return TPM2B_ECC_PARAMETER_Unmarshal((TPM2B_ECC_PARAMETER*)&target->ecc,
3483 buffer, size);
3484 #endif
3485 #ifdef TPM_ALG_KEYEDHASH
3486 case TPM_ALG_KEYEDHASH:
3487 return TPM2B_SENSITIVE_DATA_Unmarshal(
3488 (TPM2B_SENSITIVE_DATA*)&target->bits, buffer, size);
3489 #endif
3490 #ifdef TPM_ALG_SYMCIPHER
3491 case TPM_ALG_SYMCIPHER:
3492 return TPM2B_SYM_KEY_Unmarshal((TPM2B_SYM_KEY*)&target->sym, buffer,
3493 size);
3494 #endif
3495 }
3496 return TPM_RC_SELECTOR;
3497 }
3498
TPMT_SENSITIVE_Marshal(TPMT_SENSITIVE * source,BYTE ** buffer,INT32 * size)3499 UINT16 TPMT_SENSITIVE_Marshal(TPMT_SENSITIVE* source,
3500 BYTE** buffer,
3501 INT32* size) {
3502 UINT16 total_size = 0;
3503 total_size += TPMI_ALG_PUBLIC_Marshal(&source->sensitiveType, buffer, size);
3504 total_size += TPM2B_AUTH_Marshal(&source->authValue, buffer, size);
3505 total_size += TPM2B_DIGEST_Marshal(&source->seedValue, buffer, size);
3506 total_size += TPMU_SENSITIVE_COMPOSITE_Marshal(&source->sensitive, buffer,
3507 size, source->sensitiveType);
3508 return total_size;
3509 }
3510
TPMT_SENSITIVE_Unmarshal(TPMT_SENSITIVE * target,BYTE ** buffer,INT32 * size)3511 TPM_RC TPMT_SENSITIVE_Unmarshal(TPMT_SENSITIVE* target,
3512 BYTE** buffer,
3513 INT32* size) {
3514 TPM_RC result;
3515 result = TPMI_ALG_PUBLIC_Unmarshal(&target->sensitiveType, buffer, size);
3516 if (result != TPM_RC_SUCCESS) {
3517 return result;
3518 }
3519 result = TPM2B_AUTH_Unmarshal(&target->authValue, buffer, size);
3520 if (result != TPM_RC_SUCCESS) {
3521 return result;
3522 }
3523 result = TPM2B_DIGEST_Unmarshal(&target->seedValue, buffer, size);
3524 if (result != TPM_RC_SUCCESS) {
3525 return result;
3526 }
3527 result = TPMU_SENSITIVE_COMPOSITE_Unmarshal(&target->sensitive, buffer, size,
3528 target->sensitiveType);
3529 if (result != TPM_RC_SUCCESS) {
3530 return result;
3531 }
3532 return TPM_RC_SUCCESS;
3533 }
3534
TPM2B_SENSITIVE_Marshal(TPM2B_SENSITIVE * source,BYTE ** buffer,INT32 * size)3535 UINT16 TPM2B_SENSITIVE_Marshal(TPM2B_SENSITIVE* source,
3536 BYTE** buffer,
3537 INT32* size) {
3538 UINT16 total_size = 0;
3539 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3540 total_size += TPMT_SENSITIVE_Marshal(&source->t.sensitiveArea, buffer, size);
3541 return total_size;
3542 }
3543
TPM2B_SENSITIVE_Unmarshal(TPM2B_SENSITIVE * target,BYTE ** buffer,INT32 * size)3544 TPM_RC TPM2B_SENSITIVE_Unmarshal(TPM2B_SENSITIVE* target,
3545 BYTE** buffer,
3546 INT32* size) {
3547 TPM_RC result;
3548 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3549 if (result != TPM_RC_SUCCESS) {
3550 return result;
3551 }
3552 if (target->t.size == 0) {
3553 return TPM_RC_SUCCESS;
3554 }
3555 result = TPMT_SENSITIVE_Unmarshal(&target->t.sensitiveArea, buffer, size);
3556 if (result != TPM_RC_SUCCESS) {
3557 return result;
3558 }
3559 return TPM_RC_SUCCESS;
3560 }
3561
TPMS_SENSITIVE_CREATE_Marshal(TPMS_SENSITIVE_CREATE * source,BYTE ** buffer,INT32 * size)3562 UINT16 TPMS_SENSITIVE_CREATE_Marshal(TPMS_SENSITIVE_CREATE* source,
3563 BYTE** buffer,
3564 INT32* size) {
3565 UINT16 total_size = 0;
3566 total_size += TPM2B_AUTH_Marshal(&source->userAuth, buffer, size);
3567 total_size += TPM2B_SENSITIVE_DATA_Marshal(&source->data, buffer, size);
3568 return total_size;
3569 }
3570
TPMS_SENSITIVE_CREATE_Unmarshal(TPMS_SENSITIVE_CREATE * target,BYTE ** buffer,INT32 * size)3571 TPM_RC TPMS_SENSITIVE_CREATE_Unmarshal(TPMS_SENSITIVE_CREATE* target,
3572 BYTE** buffer,
3573 INT32* size) {
3574 TPM_RC result;
3575 result = TPM2B_AUTH_Unmarshal(&target->userAuth, buffer, size);
3576 if (result != TPM_RC_SUCCESS) {
3577 return result;
3578 }
3579 result = TPM2B_SENSITIVE_DATA_Unmarshal(&target->data, buffer, size);
3580 if (result != TPM_RC_SUCCESS) {
3581 return result;
3582 }
3583 return TPM_RC_SUCCESS;
3584 }
3585
TPM2B_SENSITIVE_CREATE_Marshal(TPM2B_SENSITIVE_CREATE * source,BYTE ** buffer,INT32 * size)3586 UINT16 TPM2B_SENSITIVE_CREATE_Marshal(TPM2B_SENSITIVE_CREATE* source,
3587 BYTE** buffer,
3588 INT32* size) {
3589 UINT16 total_size = 0;
3590 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3591 total_size +=
3592 TPMS_SENSITIVE_CREATE_Marshal(&source->t.sensitive, buffer, size);
3593 {
3594 BYTE* size_location = *buffer - total_size;
3595 INT32 size_field_size = sizeof(UINT16);
3596 UINT16 payload_size = total_size - (UINT16)size_field_size;
3597 UINT16_Marshal(&payload_size, &size_location, &size_field_size);
3598 }
3599 return total_size;
3600 }
3601
TPM2B_SENSITIVE_CREATE_Unmarshal(TPM2B_SENSITIVE_CREATE * target,BYTE ** buffer,INT32 * size)3602 TPM_RC TPM2B_SENSITIVE_CREATE_Unmarshal(TPM2B_SENSITIVE_CREATE* target,
3603 BYTE** buffer,
3604 INT32* size) {
3605 TPM_RC result;
3606 UINT32 start_size = *size;
3607 UINT32 struct_size;
3608 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3609 if (result != TPM_RC_SUCCESS) {
3610 return result;
3611 }
3612 if (target->t.size == 0) {
3613 return TPM_RC_SIZE;
3614 }
3615 result = TPMS_SENSITIVE_CREATE_Unmarshal(&target->t.sensitive, buffer, size);
3616 if (result != TPM_RC_SUCCESS) {
3617 return result;
3618 }
3619 struct_size = start_size - *size - sizeof(target->t.size);
3620 if (struct_size != target->t.size) {
3621 return TPM_RC_SIZE;
3622 }
3623 return TPM_RC_SUCCESS;
3624 }
3625
TPM2B_TIMEOUT_Marshal(TPM2B_TIMEOUT * source,BYTE ** buffer,INT32 * size)3626 UINT16 TPM2B_TIMEOUT_Marshal(TPM2B_TIMEOUT* source,
3627 BYTE** buffer,
3628 INT32* size) {
3629 UINT16 total_size = 0;
3630 INT32 i;
3631 total_size += UINT16_Marshal(&source->t.size, buffer, size);
3632 for (i = 0; i < source->t.size; ++i) {
3633 total_size += BYTE_Marshal(&source->t.buffer[i], buffer, size);
3634 }
3635 return total_size;
3636 }
3637
TPM2B_TIMEOUT_Unmarshal(TPM2B_TIMEOUT * target,BYTE ** buffer,INT32 * size)3638 TPM_RC TPM2B_TIMEOUT_Unmarshal(TPM2B_TIMEOUT* target,
3639 BYTE** buffer,
3640 INT32* size) {
3641 TPM_RC result;
3642 INT32 i;
3643 result = UINT16_Unmarshal(&target->t.size, buffer, size);
3644 if (result != TPM_RC_SUCCESS) {
3645 return result;
3646 }
3647 if (target->t.size == 0) {
3648 return TPM_RC_SUCCESS;
3649 }
3650 if (target->t.size > sizeof(UINT64)) {
3651 return TPM_RC_SIZE;
3652 }
3653 for (i = 0; i < target->t.size; ++i) {
3654 result = BYTE_Unmarshal(&target->t.buffer[i], buffer, size);
3655 if (result != TPM_RC_SUCCESS) {
3656 return result;
3657 }
3658 }
3659 return TPM_RC_SUCCESS;
3660 }
3661
TPMA_ALGORITHM_Marshal(TPMA_ALGORITHM * source,BYTE ** buffer,INT32 * size)3662 UINT16 TPMA_ALGORITHM_Marshal(TPMA_ALGORITHM* source,
3663 BYTE** buffer,
3664 INT32* size) {
3665 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3666 }
3667
TPMA_ALGORITHM_Unmarshal(TPMA_ALGORITHM * target,BYTE ** buffer,INT32 * size)3668 TPM_RC TPMA_ALGORITHM_Unmarshal(TPMA_ALGORITHM* target,
3669 BYTE** buffer,
3670 INT32* size) {
3671 TPM_RC result;
3672 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3673 if (result != TPM_RC_SUCCESS) {
3674 return result;
3675 }
3676 if (target->reserved4_7 != 0) {
3677 return TPM_RC_RESERVED_BITS;
3678 }
3679 if (target->reserved11_31 != 0) {
3680 return TPM_RC_RESERVED_BITS;
3681 }
3682 return TPM_RC_SUCCESS;
3683 }
3684
TPMA_CC_Marshal(TPMA_CC * source,BYTE ** buffer,INT32 * size)3685 UINT16 TPMA_CC_Marshal(TPMA_CC* source, BYTE** buffer, INT32* size) {
3686 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3687 }
3688
TPMA_CC_Unmarshal(TPMA_CC * target,BYTE ** buffer,INT32 * size)3689 TPM_RC TPMA_CC_Unmarshal(TPMA_CC* target, BYTE** buffer, INT32* size) {
3690 TPM_RC result;
3691 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3692 if (result != TPM_RC_SUCCESS) {
3693 return result;
3694 }
3695 if (target->reserved16_21 != 0) {
3696 return TPM_RC_RESERVED_BITS;
3697 }
3698 return TPM_RC_SUCCESS;
3699 }
3700
TPMA_MEMORY_Marshal(TPMA_MEMORY * source,BYTE ** buffer,INT32 * size)3701 UINT16 TPMA_MEMORY_Marshal(TPMA_MEMORY* source, BYTE** buffer, INT32* size) {
3702 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3703 }
3704
TPMA_MEMORY_Unmarshal(TPMA_MEMORY * target,BYTE ** buffer,INT32 * size)3705 TPM_RC TPMA_MEMORY_Unmarshal(TPMA_MEMORY* target, BYTE** buffer, INT32* size) {
3706 TPM_RC result;
3707 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3708 if (result != TPM_RC_SUCCESS) {
3709 return result;
3710 }
3711 if (target->reserved3_31 != 0) {
3712 return TPM_RC_RESERVED_BITS;
3713 }
3714 return TPM_RC_SUCCESS;
3715 }
3716
TPMA_PERMANENT_Marshal(TPMA_PERMANENT * source,BYTE ** buffer,INT32 * size)3717 UINT16 TPMA_PERMANENT_Marshal(TPMA_PERMANENT* source,
3718 BYTE** buffer,
3719 INT32* size) {
3720 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3721 }
3722
TPMA_PERMANENT_Unmarshal(TPMA_PERMANENT * target,BYTE ** buffer,INT32 * size)3723 TPM_RC TPMA_PERMANENT_Unmarshal(TPMA_PERMANENT* target,
3724 BYTE** buffer,
3725 INT32* size) {
3726 TPM_RC result;
3727 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3728 if (result != TPM_RC_SUCCESS) {
3729 return result;
3730 }
3731 if (target->reserved3_7 != 0) {
3732 return TPM_RC_RESERVED_BITS;
3733 }
3734 if (target->reserved11_31 != 0) {
3735 return TPM_RC_RESERVED_BITS;
3736 }
3737 return TPM_RC_SUCCESS;
3738 }
3739
TPMA_SESSION_Marshal(TPMA_SESSION * source,BYTE ** buffer,INT32 * size)3740 UINT16 TPMA_SESSION_Marshal(TPMA_SESSION* source, BYTE** buffer, INT32* size) {
3741 return uint8_t_Marshal((uint8_t*)source, buffer, size);
3742 }
3743
TPMA_SESSION_Unmarshal(TPMA_SESSION * target,BYTE ** buffer,INT32 * size)3744 TPM_RC TPMA_SESSION_Unmarshal(TPMA_SESSION* target,
3745 BYTE** buffer,
3746 INT32* size) {
3747 TPM_RC result;
3748 result = uint8_t_Unmarshal((uint8_t*)target, buffer, size);
3749 if (result != TPM_RC_SUCCESS) {
3750 return result;
3751 }
3752 if (target->reserved3_4 != 0) {
3753 return TPM_RC_RESERVED_BITS;
3754 }
3755 return TPM_RC_SUCCESS;
3756 }
3757
TPMA_STARTUP_CLEAR_Marshal(TPMA_STARTUP_CLEAR * source,BYTE ** buffer,INT32 * size)3758 UINT16 TPMA_STARTUP_CLEAR_Marshal(TPMA_STARTUP_CLEAR* source,
3759 BYTE** buffer,
3760 INT32* size) {
3761 return uint32_t_Marshal((uint32_t*)source, buffer, size);
3762 }
3763
TPMA_STARTUP_CLEAR_Unmarshal(TPMA_STARTUP_CLEAR * target,BYTE ** buffer,INT32 * size)3764 TPM_RC TPMA_STARTUP_CLEAR_Unmarshal(TPMA_STARTUP_CLEAR* target,
3765 BYTE** buffer,
3766 INT32* size) {
3767 TPM_RC result;
3768 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
3769 if (result != TPM_RC_SUCCESS) {
3770 return result;
3771 }
3772 if (target->reserved4_30 != 0) {
3773 return TPM_RC_RESERVED_BITS;
3774 }
3775 return TPM_RC_SUCCESS;
3776 }
3777
TPMI_ALG_ASYM_Marshal(TPMI_ALG_ASYM * source,BYTE ** buffer,INT32 * size)3778 UINT16 TPMI_ALG_ASYM_Marshal(TPMI_ALG_ASYM* source,
3779 BYTE** buffer,
3780 INT32* size) {
3781 return uint16_t_Marshal(source, buffer, size);
3782 }
3783
TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3784 TPM_RC TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM* target,
3785 BYTE** buffer,
3786 INT32* size,
3787 BOOL allow_conditional_value) {
3788 TPM_RC result;
3789 BOOL has_valid_value = FALSE;
3790 result = uint16_t_Unmarshal(target, buffer, size);
3791 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3792 return result;
3793 }
3794 if (*target == TPM_ALG_NULL) {
3795 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_ASYMMETRIC;
3796 }
3797 switch (*target) {
3798 #ifdef TPM_ALG_RSA
3799 case TPM_ALG_RSA:
3800 #endif
3801 #ifdef TPM_ALG_ECC
3802 case TPM_ALG_ECC:
3803 #endif
3804 has_valid_value = TRUE;
3805 break;
3806 }
3807 if (!has_valid_value) {
3808 return TPM_RC_ASYMMETRIC;
3809 }
3810 return TPM_RC_SUCCESS;
3811 }
3812
TPMI_ALG_RSA_DECRYPT_Marshal(TPMI_ALG_RSA_DECRYPT * source,BYTE ** buffer,INT32 * size)3813 UINT16 TPMI_ALG_RSA_DECRYPT_Marshal(TPMI_ALG_RSA_DECRYPT* source,
3814 BYTE** buffer,
3815 INT32* size) {
3816 return uint16_t_Marshal(source, buffer, size);
3817 }
3818
TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3819 TPM_RC TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT* target,
3820 BYTE** buffer,
3821 INT32* size,
3822 BOOL allow_conditional_value) {
3823 TPM_RC result;
3824 BOOL has_valid_value = FALSE;
3825 result = uint16_t_Unmarshal(target, buffer, size);
3826 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3827 return result;
3828 }
3829 if (*target == TPM_ALG_NULL) {
3830 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
3831 }
3832 switch (*target) {
3833 #ifdef TPM_ALG_RSAES
3834 case TPM_ALG_RSAES:
3835 #endif
3836 #ifdef TPM_ALG_OAEP
3837 case TPM_ALG_OAEP:
3838 #endif
3839 has_valid_value = TRUE;
3840 break;
3841 }
3842 if (!has_valid_value) {
3843 return TPM_RC_VALUE;
3844 }
3845 return TPM_RC_SUCCESS;
3846 }
3847
TPMI_ALG_SIG_SCHEME_Marshal(TPMI_ALG_SIG_SCHEME * source,BYTE ** buffer,INT32 * size)3848 UINT16 TPMI_ALG_SIG_SCHEME_Marshal(TPMI_ALG_SIG_SCHEME* source,
3849 BYTE** buffer,
3850 INT32* size) {
3851 return uint16_t_Marshal(source, buffer, size);
3852 }
3853
TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3854 TPM_RC TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME* target,
3855 BYTE** buffer,
3856 INT32* size,
3857 BOOL allow_conditional_value) {
3858 TPM_RC result;
3859 BOOL has_valid_value = FALSE;
3860 result = uint16_t_Unmarshal(target, buffer, size);
3861 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3862 return result;
3863 }
3864 if (*target == TPM_ALG_NULL) {
3865 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SCHEME;
3866 }
3867 switch (*target) {
3868 #ifdef TPM_ALG_RSASSA
3869 case TPM_ALG_RSASSA:
3870 #endif
3871 #ifdef TPM_ALG_RSAPSS
3872 case TPM_ALG_RSAPSS:
3873 #endif
3874 #ifdef TPM_ALG_ECDSA
3875 case TPM_ALG_ECDSA:
3876 #endif
3877 #ifdef TPM_ALG_ECDAA
3878 case TPM_ALG_ECDAA:
3879 #endif
3880 #ifdef TPM_ALG_SM2
3881 case TPM_ALG_SM2:
3882 #endif
3883 #ifdef TPM_ALG_ECSCHNORR
3884 case TPM_ALG_ECSCHNORR:
3885 #endif
3886 #ifdef TPM_ALG_HMAC
3887 case TPM_ALG_HMAC:
3888 #endif
3889 has_valid_value = TRUE;
3890 break;
3891 }
3892 if (!has_valid_value) {
3893 return TPM_RC_SCHEME;
3894 }
3895 return TPM_RC_SUCCESS;
3896 }
3897
TPMI_ALG_SYM_Marshal(TPMI_ALG_SYM * source,BYTE ** buffer,INT32 * size)3898 UINT16 TPMI_ALG_SYM_Marshal(TPMI_ALG_SYM* source, BYTE** buffer, INT32* size) {
3899 return uint16_t_Marshal(source, buffer, size);
3900 }
3901
TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3902 TPM_RC TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM* target,
3903 BYTE** buffer,
3904 INT32* size,
3905 BOOL allow_conditional_value) {
3906 TPM_RC result;
3907 BOOL has_valid_value = FALSE;
3908 result = uint16_t_Unmarshal(target, buffer, size);
3909 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3910 return result;
3911 }
3912 if (*target == TPM_ALG_NULL) {
3913 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SYMMETRIC;
3914 }
3915 switch (*target) {
3916 #ifdef TPM_ALG_AES
3917 case TPM_ALG_AES:
3918 #endif
3919 #ifdef TPM_ALG_SM4
3920 case TPM_ALG_SM4:
3921 #endif
3922 #ifdef TPM_ALG_CAMELLIA
3923 case TPM_ALG_CAMELLIA:
3924 #endif
3925 #ifdef TPM_ALG_XOR
3926 case TPM_ALG_XOR:
3927 #endif
3928 has_valid_value = TRUE;
3929 break;
3930 }
3931 if (!has_valid_value) {
3932 return TPM_RC_SYMMETRIC;
3933 }
3934 return TPM_RC_SUCCESS;
3935 }
3936
TPMI_DH_CONTEXT_Marshal(TPMI_DH_CONTEXT * source,BYTE ** buffer,INT32 * size)3937 UINT16 TPMI_DH_CONTEXT_Marshal(TPMI_DH_CONTEXT* source,
3938 BYTE** buffer,
3939 INT32* size) {
3940 return uint32_t_Marshal(source, buffer, size);
3941 }
3942
TPMI_DH_CONTEXT_Unmarshal(TPMI_DH_CONTEXT * target,BYTE ** buffer,INT32 * size)3943 TPM_RC TPMI_DH_CONTEXT_Unmarshal(TPMI_DH_CONTEXT* target,
3944 BYTE** buffer,
3945 INT32* size) {
3946 TPM_RC result;
3947 BOOL has_valid_value = FALSE;
3948 result = uint32_t_Unmarshal(target, buffer, size);
3949 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3950 return result;
3951 }
3952 if ((*target >= HMAC_SESSION_FIRST) && (*target <= HMAC_SESSION_LAST)) {
3953 has_valid_value = TRUE;
3954 }
3955 if ((*target >= POLICY_SESSION_FIRST) && (*target <= POLICY_SESSION_LAST)) {
3956 has_valid_value = TRUE;
3957 }
3958 if ((*target >= TRANSIENT_FIRST) && (*target <= TRANSIENT_LAST)) {
3959 has_valid_value = TRUE;
3960 }
3961 if (!has_valid_value) {
3962 return TPM_RC_VALUE;
3963 }
3964 return TPM_RC_SUCCESS;
3965 }
3966
TPMI_DH_ENTITY_Marshal(TPMI_DH_ENTITY * source,BYTE ** buffer,INT32 * size)3967 UINT16 TPMI_DH_ENTITY_Marshal(TPMI_DH_ENTITY* source,
3968 BYTE** buffer,
3969 INT32* size) {
3970 return uint32_t_Marshal(source, buffer, size);
3971 }
3972
TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)3973 TPM_RC TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY* target,
3974 BYTE** buffer,
3975 INT32* size,
3976 BOOL allow_conditional_value) {
3977 TPM_RC result;
3978 BOOL has_valid_value = FALSE;
3979 result = uint32_t_Unmarshal(target, buffer, size);
3980 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
3981 return result;
3982 }
3983 if (*target == TPM_RH_NULL) {
3984 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
3985 }
3986 switch (*target) {
3987 case TPM_RH_OWNER:
3988 case TPM_RH_ENDORSEMENT:
3989 case TPM_RH_PLATFORM:
3990 case TPM_RH_LOCKOUT:
3991 has_valid_value = TRUE;
3992 break;
3993 }
3994 if ((*target >= TRANSIENT_FIRST) && (*target <= TRANSIENT_LAST)) {
3995 has_valid_value = TRUE;
3996 }
3997 if ((*target >= PERSISTENT_FIRST) && (*target <= PERSISTENT_LAST)) {
3998 has_valid_value = TRUE;
3999 }
4000 if ((*target >= NV_INDEX_FIRST) && (*target <= NV_INDEX_LAST)) {
4001 has_valid_value = TRUE;
4002 }
4003 if ((*target >= PCR_FIRST) && (*target <= PCR_LAST)) {
4004 has_valid_value = TRUE;
4005 }
4006 if ((*target >= TPM_RH_AUTH_00) && (*target <= TPM_RH_AUTH_FF)) {
4007 has_valid_value = TRUE;
4008 }
4009 if (!has_valid_value) {
4010 return TPM_RC_VALUE;
4011 }
4012 return TPM_RC_SUCCESS;
4013 }
4014
TPMI_DH_OBJECT_Marshal(TPMI_DH_OBJECT * source,BYTE ** buffer,INT32 * size)4015 UINT16 TPMI_DH_OBJECT_Marshal(TPMI_DH_OBJECT* source,
4016 BYTE** buffer,
4017 INT32* size) {
4018 return uint32_t_Marshal(source, buffer, size);
4019 }
4020
TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4021 TPM_RC TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT* target,
4022 BYTE** buffer,
4023 INT32* size,
4024 BOOL allow_conditional_value) {
4025 TPM_RC result;
4026 BOOL has_valid_value = FALSE;
4027 result = uint32_t_Unmarshal(target, buffer, size);
4028 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4029 return result;
4030 }
4031 if (*target == TPM_RH_NULL) {
4032 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4033 }
4034 if ((*target >= TRANSIENT_FIRST) && (*target <= TRANSIENT_LAST)) {
4035 has_valid_value = TRUE;
4036 }
4037 if ((*target >= PERSISTENT_FIRST) && (*target <= PERSISTENT_LAST)) {
4038 has_valid_value = TRUE;
4039 }
4040 if (!has_valid_value) {
4041 return TPM_RC_VALUE;
4042 }
4043 return TPM_RC_SUCCESS;
4044 }
4045
TPMI_DH_PCR_Marshal(TPMI_DH_PCR * source,BYTE ** buffer,INT32 * size)4046 UINT16 TPMI_DH_PCR_Marshal(TPMI_DH_PCR* source, BYTE** buffer, INT32* size) {
4047 return uint32_t_Marshal(source, buffer, size);
4048 }
4049
TPMI_DH_PCR_Unmarshal(TPMI_DH_PCR * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4050 TPM_RC TPMI_DH_PCR_Unmarshal(TPMI_DH_PCR* target,
4051 BYTE** buffer,
4052 INT32* size,
4053 BOOL allow_conditional_value) {
4054 TPM_RC result;
4055 BOOL has_valid_value = FALSE;
4056 result = uint32_t_Unmarshal(target, buffer, size);
4057 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4058 return result;
4059 }
4060 if (*target == TPM_RH_NULL) {
4061 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4062 }
4063 if ((*target >= PCR_FIRST) && (*target <= PCR_LAST)) {
4064 has_valid_value = TRUE;
4065 }
4066 if (!has_valid_value) {
4067 return TPM_RC_VALUE;
4068 }
4069 return TPM_RC_SUCCESS;
4070 }
4071
TPMI_DH_PERSISTENT_Marshal(TPMI_DH_PERSISTENT * source,BYTE ** buffer,INT32 * size)4072 UINT16 TPMI_DH_PERSISTENT_Marshal(TPMI_DH_PERSISTENT* source,
4073 BYTE** buffer,
4074 INT32* size) {
4075 return uint32_t_Marshal(source, buffer, size);
4076 }
4077
TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT * target,BYTE ** buffer,INT32 * size)4078 TPM_RC TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT* target,
4079 BYTE** buffer,
4080 INT32* size) {
4081 TPM_RC result;
4082 BOOL has_valid_value = FALSE;
4083 result = uint32_t_Unmarshal(target, buffer, size);
4084 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4085 return result;
4086 }
4087 if ((*target >= PERSISTENT_FIRST) && (*target <= PERSISTENT_LAST)) {
4088 has_valid_value = TRUE;
4089 }
4090 if (!has_valid_value) {
4091 return TPM_RC_VALUE;
4092 }
4093 return TPM_RC_SUCCESS;
4094 }
4095
TPMI_ECC_KEY_EXCHANGE_Marshal(TPMI_ECC_KEY_EXCHANGE * source,BYTE ** buffer,INT32 * size)4096 UINT16 TPMI_ECC_KEY_EXCHANGE_Marshal(TPMI_ECC_KEY_EXCHANGE* source,
4097 BYTE** buffer,
4098 INT32* size) {
4099 return uint16_t_Marshal(source, buffer, size);
4100 }
4101
TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4102 TPM_RC TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE* target,
4103 BYTE** buffer,
4104 INT32* size,
4105 BOOL allow_conditional_value) {
4106 TPM_RC result;
4107 BOOL has_valid_value = FALSE;
4108 result = uint16_t_Unmarshal(target, buffer, size);
4109 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4110 return result;
4111 }
4112 if (*target == TPM_ALG_NULL) {
4113 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_SCHEME;
4114 }
4115 switch (*target) {
4116 #ifdef TPM_ALG_ECDH
4117 case TPM_ALG_ECDH:
4118 #endif
4119 #ifdef TPM_ALG_ECMQV
4120 case TPM_ALG_ECMQV:
4121 #endif
4122 #ifdef TPM_ALG_SM2
4123 case TPM_ALG_SM2:
4124 #endif
4125 has_valid_value = TRUE;
4126 break;
4127 }
4128 if (!has_valid_value) {
4129 return TPM_RC_SCHEME;
4130 }
4131 return TPM_RC_SUCCESS;
4132 }
4133
TPMI_RH_CLEAR_Marshal(TPMI_RH_CLEAR * source,BYTE ** buffer,INT32 * size)4134 UINT16 TPMI_RH_CLEAR_Marshal(TPMI_RH_CLEAR* source,
4135 BYTE** buffer,
4136 INT32* size) {
4137 return uint32_t_Marshal(source, buffer, size);
4138 }
4139
TPMI_RH_CLEAR_Unmarshal(TPMI_RH_CLEAR * target,BYTE ** buffer,INT32 * size)4140 TPM_RC TPMI_RH_CLEAR_Unmarshal(TPMI_RH_CLEAR* target,
4141 BYTE** buffer,
4142 INT32* size) {
4143 TPM_RC result;
4144 BOOL has_valid_value = FALSE;
4145 result = uint32_t_Unmarshal(target, buffer, size);
4146 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4147 return result;
4148 }
4149 switch (*target) {
4150 case TPM_RH_LOCKOUT:
4151 case TPM_RH_PLATFORM:
4152 has_valid_value = TRUE;
4153 break;
4154 }
4155 if (!has_valid_value) {
4156 return TPM_RC_VALUE;
4157 }
4158 return TPM_RC_SUCCESS;
4159 }
4160
TPMI_RH_ENABLES_Marshal(TPMI_RH_ENABLES * source,BYTE ** buffer,INT32 * size)4161 UINT16 TPMI_RH_ENABLES_Marshal(TPMI_RH_ENABLES* source,
4162 BYTE** buffer,
4163 INT32* size) {
4164 return uint32_t_Marshal(source, buffer, size);
4165 }
4166
TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4167 TPM_RC TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES* target,
4168 BYTE** buffer,
4169 INT32* size,
4170 BOOL allow_conditional_value) {
4171 TPM_RC result;
4172 BOOL has_valid_value = FALSE;
4173 result = uint32_t_Unmarshal(target, buffer, size);
4174 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4175 return result;
4176 }
4177 if (*target == TPM_RH_NULL) {
4178 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4179 }
4180 switch (*target) {
4181 case TPM_RH_OWNER:
4182 case TPM_RH_PLATFORM:
4183 case TPM_RH_ENDORSEMENT:
4184 case TPM_RH_PLATFORM_NV:
4185 has_valid_value = TRUE;
4186 break;
4187 }
4188 if (!has_valid_value) {
4189 return TPM_RC_VALUE;
4190 }
4191 return TPM_RC_SUCCESS;
4192 }
4193
TPMI_RH_ENDORSEMENT_Marshal(TPMI_RH_ENDORSEMENT * source,BYTE ** buffer,INT32 * size)4194 UINT16 TPMI_RH_ENDORSEMENT_Marshal(TPMI_RH_ENDORSEMENT* source,
4195 BYTE** buffer,
4196 INT32* size) {
4197 return uint32_t_Marshal(source, buffer, size);
4198 }
4199
TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4200 TPM_RC TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT* target,
4201 BYTE** buffer,
4202 INT32* size,
4203 BOOL allow_conditional_value) {
4204 TPM_RC result;
4205 BOOL has_valid_value = FALSE;
4206 result = uint32_t_Unmarshal(target, buffer, size);
4207 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4208 return result;
4209 }
4210 if (*target == TPM_RH_NULL) {
4211 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4212 }
4213 switch (*target) {
4214 case TPM_RH_ENDORSEMENT:
4215 has_valid_value = TRUE;
4216 break;
4217 }
4218 if (!has_valid_value) {
4219 return TPM_RC_VALUE;
4220 }
4221 return TPM_RC_SUCCESS;
4222 }
4223
TPMI_RH_HIERARCHY_Marshal(TPMI_RH_HIERARCHY * source,BYTE ** buffer,INT32 * size)4224 UINT16 TPMI_RH_HIERARCHY_Marshal(TPMI_RH_HIERARCHY* source,
4225 BYTE** buffer,
4226 INT32* size) {
4227 return uint32_t_Marshal(source, buffer, size);
4228 }
4229
TPMI_RH_HIERARCHY_Unmarshal(TPMI_RH_HIERARCHY * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4230 TPM_RC TPMI_RH_HIERARCHY_Unmarshal(TPMI_RH_HIERARCHY* target,
4231 BYTE** buffer,
4232 INT32* size,
4233 BOOL allow_conditional_value) {
4234 TPM_RC result;
4235 BOOL has_valid_value = FALSE;
4236 result = uint32_t_Unmarshal(target, buffer, size);
4237 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4238 return result;
4239 }
4240 if (*target == TPM_RH_NULL) {
4241 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4242 }
4243 switch (*target) {
4244 case TPM_RH_OWNER:
4245 case TPM_RH_PLATFORM:
4246 case TPM_RH_ENDORSEMENT:
4247 has_valid_value = TRUE;
4248 break;
4249 }
4250 if (!has_valid_value) {
4251 return TPM_RC_VALUE;
4252 }
4253 return TPM_RC_SUCCESS;
4254 }
4255
TPMI_RH_HIERARCHY_AUTH_Marshal(TPMI_RH_HIERARCHY_AUTH * source,BYTE ** buffer,INT32 * size)4256 UINT16 TPMI_RH_HIERARCHY_AUTH_Marshal(TPMI_RH_HIERARCHY_AUTH* source,
4257 BYTE** buffer,
4258 INT32* size) {
4259 return uint32_t_Marshal(source, buffer, size);
4260 }
4261
TPMI_RH_HIERARCHY_AUTH_Unmarshal(TPMI_RH_HIERARCHY_AUTH * target,BYTE ** buffer,INT32 * size)4262 TPM_RC TPMI_RH_HIERARCHY_AUTH_Unmarshal(TPMI_RH_HIERARCHY_AUTH* target,
4263 BYTE** buffer,
4264 INT32* size) {
4265 TPM_RC result;
4266 BOOL has_valid_value = FALSE;
4267 result = uint32_t_Unmarshal(target, buffer, size);
4268 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4269 return result;
4270 }
4271 switch (*target) {
4272 case TPM_RH_OWNER:
4273 case TPM_RH_PLATFORM:
4274 case TPM_RH_ENDORSEMENT:
4275 case TPM_RH_LOCKOUT:
4276 has_valid_value = TRUE;
4277 break;
4278 }
4279 if (!has_valid_value) {
4280 return TPM_RC_VALUE;
4281 }
4282 return TPM_RC_SUCCESS;
4283 }
4284
TPMI_RH_LOCKOUT_Marshal(TPMI_RH_LOCKOUT * source,BYTE ** buffer,INT32 * size)4285 UINT16 TPMI_RH_LOCKOUT_Marshal(TPMI_RH_LOCKOUT* source,
4286 BYTE** buffer,
4287 INT32* size) {
4288 return uint32_t_Marshal(source, buffer, size);
4289 }
4290
TPMI_RH_LOCKOUT_Unmarshal(TPMI_RH_LOCKOUT * target,BYTE ** buffer,INT32 * size)4291 TPM_RC TPMI_RH_LOCKOUT_Unmarshal(TPMI_RH_LOCKOUT* target,
4292 BYTE** buffer,
4293 INT32* size) {
4294 TPM_RC result;
4295 BOOL has_valid_value = FALSE;
4296 result = uint32_t_Unmarshal(target, buffer, size);
4297 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4298 return result;
4299 }
4300 switch (*target) {
4301 case TPM_RH_LOCKOUT:
4302 has_valid_value = TRUE;
4303 break;
4304 }
4305 if (!has_valid_value) {
4306 return TPM_RC_VALUE;
4307 }
4308 return TPM_RC_SUCCESS;
4309 }
4310
TPMI_RH_NV_AUTH_Marshal(TPMI_RH_NV_AUTH * source,BYTE ** buffer,INT32 * size)4311 UINT16 TPMI_RH_NV_AUTH_Marshal(TPMI_RH_NV_AUTH* source,
4312 BYTE** buffer,
4313 INT32* size) {
4314 return uint32_t_Marshal(source, buffer, size);
4315 }
4316
TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH * target,BYTE ** buffer,INT32 * size)4317 TPM_RC TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH* target,
4318 BYTE** buffer,
4319 INT32* size) {
4320 TPM_RC result;
4321 BOOL has_valid_value = FALSE;
4322 result = uint32_t_Unmarshal(target, buffer, size);
4323 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4324 return result;
4325 }
4326 switch (*target) {
4327 case TPM_RH_PLATFORM:
4328 case TPM_RH_OWNER:
4329 has_valid_value = TRUE;
4330 break;
4331 }
4332 if ((*target >= NV_INDEX_FIRST) && (*target <= NV_INDEX_LAST)) {
4333 has_valid_value = TRUE;
4334 }
4335 if (!has_valid_value) {
4336 return TPM_RC_VALUE;
4337 }
4338 return TPM_RC_SUCCESS;
4339 }
4340
TPMI_RH_OWNER_Marshal(TPMI_RH_OWNER * source,BYTE ** buffer,INT32 * size)4341 UINT16 TPMI_RH_OWNER_Marshal(TPMI_RH_OWNER* source,
4342 BYTE** buffer,
4343 INT32* size) {
4344 return uint32_t_Marshal(source, buffer, size);
4345 }
4346
TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4347 TPM_RC TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER* target,
4348 BYTE** buffer,
4349 INT32* size,
4350 BOOL allow_conditional_value) {
4351 TPM_RC result;
4352 BOOL has_valid_value = FALSE;
4353 result = uint32_t_Unmarshal(target, buffer, size);
4354 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4355 return result;
4356 }
4357 if (*target == TPM_RH_NULL) {
4358 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4359 }
4360 switch (*target) {
4361 case TPM_RH_OWNER:
4362 has_valid_value = TRUE;
4363 break;
4364 }
4365 if (!has_valid_value) {
4366 return TPM_RC_VALUE;
4367 }
4368 return TPM_RC_SUCCESS;
4369 }
4370
TPMI_RH_PLATFORM_Marshal(TPMI_RH_PLATFORM * source,BYTE ** buffer,INT32 * size)4371 UINT16 TPMI_RH_PLATFORM_Marshal(TPMI_RH_PLATFORM* source,
4372 BYTE** buffer,
4373 INT32* size) {
4374 return uint32_t_Marshal(source, buffer, size);
4375 }
4376
TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM * target,BYTE ** buffer,INT32 * size)4377 TPM_RC TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM* target,
4378 BYTE** buffer,
4379 INT32* size) {
4380 TPM_RC result;
4381 BOOL has_valid_value = FALSE;
4382 result = uint32_t_Unmarshal(target, buffer, size);
4383 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4384 return result;
4385 }
4386 switch (*target) {
4387 case TPM_RH_PLATFORM:
4388 has_valid_value = TRUE;
4389 break;
4390 }
4391 if (!has_valid_value) {
4392 return TPM_RC_VALUE;
4393 }
4394 return TPM_RC_SUCCESS;
4395 }
4396
TPMI_RH_PROVISION_Marshal(TPMI_RH_PROVISION * source,BYTE ** buffer,INT32 * size)4397 UINT16 TPMI_RH_PROVISION_Marshal(TPMI_RH_PROVISION* source,
4398 BYTE** buffer,
4399 INT32* size) {
4400 return uint32_t_Marshal(source, buffer, size);
4401 }
4402
TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION * target,BYTE ** buffer,INT32 * size)4403 TPM_RC TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION* target,
4404 BYTE** buffer,
4405 INT32* size) {
4406 TPM_RC result;
4407 BOOL has_valid_value = FALSE;
4408 result = uint32_t_Unmarshal(target, buffer, size);
4409 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4410 return result;
4411 }
4412 switch (*target) {
4413 case TPM_RH_OWNER:
4414 case TPM_RH_PLATFORM:
4415 has_valid_value = TRUE;
4416 break;
4417 }
4418 if (!has_valid_value) {
4419 return TPM_RC_VALUE;
4420 }
4421 return TPM_RC_SUCCESS;
4422 }
4423
TPMI_SH_AUTH_SESSION_Marshal(TPMI_SH_AUTH_SESSION * source,BYTE ** buffer,INT32 * size)4424 UINT16 TPMI_SH_AUTH_SESSION_Marshal(TPMI_SH_AUTH_SESSION* source,
4425 BYTE** buffer,
4426 INT32* size) {
4427 return uint32_t_Marshal(source, buffer, size);
4428 }
4429
TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION * target,BYTE ** buffer,INT32 * size,BOOL allow_conditional_value)4430 TPM_RC TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION* target,
4431 BYTE** buffer,
4432 INT32* size,
4433 BOOL allow_conditional_value) {
4434 TPM_RC result;
4435 BOOL has_valid_value = FALSE;
4436 result = uint32_t_Unmarshal(target, buffer, size);
4437 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4438 return result;
4439 }
4440 if (*target == TPM_RS_PW) {
4441 return allow_conditional_value ? TPM_RC_SUCCESS : TPM_RC_VALUE;
4442 }
4443 if ((*target >= HMAC_SESSION_FIRST) && (*target <= HMAC_SESSION_LAST)) {
4444 has_valid_value = TRUE;
4445 }
4446 if ((*target >= POLICY_SESSION_FIRST) && (*target <= POLICY_SESSION_LAST)) {
4447 has_valid_value = TRUE;
4448 }
4449 if (!has_valid_value) {
4450 return TPM_RC_VALUE;
4451 }
4452 return TPM_RC_SUCCESS;
4453 }
4454
TPMI_SH_HMAC_Marshal(TPMI_SH_HMAC * source,BYTE ** buffer,INT32 * size)4455 UINT16 TPMI_SH_HMAC_Marshal(TPMI_SH_HMAC* source, BYTE** buffer, INT32* size) {
4456 return uint32_t_Marshal(source, buffer, size);
4457 }
4458
TPMI_SH_HMAC_Unmarshal(TPMI_SH_HMAC * target,BYTE ** buffer,INT32 * size)4459 TPM_RC TPMI_SH_HMAC_Unmarshal(TPMI_SH_HMAC* target,
4460 BYTE** buffer,
4461 INT32* size) {
4462 TPM_RC result;
4463 BOOL has_valid_value = FALSE;
4464 result = uint32_t_Unmarshal(target, buffer, size);
4465 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4466 return result;
4467 }
4468 if ((*target >= HMAC_SESSION_FIRST) && (*target <= HMAC_SESSION_LAST)) {
4469 has_valid_value = TRUE;
4470 }
4471 if (!has_valid_value) {
4472 return TPM_RC_VALUE;
4473 }
4474 return TPM_RC_SUCCESS;
4475 }
4476
TPMI_SH_POLICY_Marshal(TPMI_SH_POLICY * source,BYTE ** buffer,INT32 * size)4477 UINT16 TPMI_SH_POLICY_Marshal(TPMI_SH_POLICY* source,
4478 BYTE** buffer,
4479 INT32* size) {
4480 return uint32_t_Marshal(source, buffer, size);
4481 }
4482
TPMI_SH_POLICY_Unmarshal(TPMI_SH_POLICY * target,BYTE ** buffer,INT32 * size)4483 TPM_RC TPMI_SH_POLICY_Unmarshal(TPMI_SH_POLICY* target,
4484 BYTE** buffer,
4485 INT32* size) {
4486 TPM_RC result;
4487 BOOL has_valid_value = FALSE;
4488 result = uint32_t_Unmarshal(target, buffer, size);
4489 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4490 return result;
4491 }
4492 if ((*target >= POLICY_SESSION_FIRST) && (*target <= POLICY_SESSION_LAST)) {
4493 has_valid_value = TRUE;
4494 }
4495 if (!has_valid_value) {
4496 return TPM_RC_VALUE;
4497 }
4498 return TPM_RC_SUCCESS;
4499 }
4500
TPMI_ST_ATTEST_Marshal(TPMI_ST_ATTEST * source,BYTE ** buffer,INT32 * size)4501 UINT16 TPMI_ST_ATTEST_Marshal(TPMI_ST_ATTEST* source,
4502 BYTE** buffer,
4503 INT32* size) {
4504 return uint16_t_Marshal(source, buffer, size);
4505 }
4506
TPMI_ST_ATTEST_Unmarshal(TPMI_ST_ATTEST * target,BYTE ** buffer,INT32 * size)4507 TPM_RC TPMI_ST_ATTEST_Unmarshal(TPMI_ST_ATTEST* target,
4508 BYTE** buffer,
4509 INT32* size) {
4510 TPM_RC result;
4511 BOOL has_valid_value = FALSE;
4512 result = uint16_t_Unmarshal(target, buffer, size);
4513 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4514 return result;
4515 }
4516 switch (*target) {
4517 case TPM_ST_ATTEST_CERTIFY:
4518 case TPM_ST_ATTEST_QUOTE:
4519 case TPM_ST_ATTEST_SESSION_AUDIT:
4520 case TPM_ST_ATTEST_COMMAND_AUDIT:
4521 case TPM_ST_ATTEST_TIME:
4522 case TPM_ST_ATTEST_CREATION:
4523 case TPM_ST_ATTEST_NV:
4524 has_valid_value = TRUE;
4525 break;
4526 }
4527 if (!has_valid_value) {
4528 return TPM_RC_VALUE;
4529 }
4530 return TPM_RC_SUCCESS;
4531 }
4532
TPMI_ST_COMMAND_TAG_Marshal(TPMI_ST_COMMAND_TAG * source,BYTE ** buffer,INT32 * size)4533 UINT16 TPMI_ST_COMMAND_TAG_Marshal(TPMI_ST_COMMAND_TAG* source,
4534 BYTE** buffer,
4535 INT32* size) {
4536 return uint16_t_Marshal(source, buffer, size);
4537 }
4538
TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG * target,BYTE ** buffer,INT32 * size)4539 TPM_RC TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG* target,
4540 BYTE** buffer,
4541 INT32* size) {
4542 TPM_RC result;
4543 BOOL has_valid_value = FALSE;
4544 result = uint16_t_Unmarshal(target, buffer, size);
4545 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4546 return result;
4547 }
4548 switch (*target) {
4549 case TPM_ST_NO_SESSIONS:
4550 case TPM_ST_SESSIONS:
4551 has_valid_value = TRUE;
4552 break;
4553 }
4554 if (!has_valid_value) {
4555 return TPM_RC_BAD_TAG;
4556 }
4557 return TPM_RC_SUCCESS;
4558 }
4559
TPMI_YES_NO_Marshal(TPMI_YES_NO * source,BYTE ** buffer,INT32 * size)4560 UINT16 TPMI_YES_NO_Marshal(TPMI_YES_NO* source, BYTE** buffer, INT32* size) {
4561 return uint8_t_Marshal(source, buffer, size);
4562 }
4563
TPMI_YES_NO_Unmarshal(TPMI_YES_NO * target,BYTE ** buffer,INT32 * size)4564 TPM_RC TPMI_YES_NO_Unmarshal(TPMI_YES_NO* target, BYTE** buffer, INT32* size) {
4565 TPM_RC result;
4566 BOOL has_valid_value = FALSE;
4567 result = uint8_t_Unmarshal(target, buffer, size);
4568 if ((result != TPM_RC_VALUE) && (result != TPM_RC_SUCCESS)) {
4569 return result;
4570 }
4571 switch (*target) {
4572 case NO:
4573 case YES:
4574 has_valid_value = TRUE;
4575 break;
4576 }
4577 if (!has_valid_value) {
4578 return TPM_RC_VALUE;
4579 }
4580 return TPM_RC_SUCCESS;
4581 }
4582
TPML_ALG_Marshal(TPML_ALG * source,BYTE ** buffer,INT32 * size)4583 UINT16 TPML_ALG_Marshal(TPML_ALG* source, BYTE** buffer, INT32* size) {
4584 UINT16 total_size = 0;
4585 INT32 i;
4586 total_size += UINT32_Marshal(&source->count, buffer, size);
4587 for (i = 0; i < source->count; ++i) {
4588 total_size += TPM_ALG_ID_Marshal(&source->algorithms[i], buffer, size);
4589 }
4590 return total_size;
4591 }
4592
TPML_ALG_Unmarshal(TPML_ALG * target,BYTE ** buffer,INT32 * size)4593 TPM_RC TPML_ALG_Unmarshal(TPML_ALG* target, BYTE** buffer, INT32* size) {
4594 TPM_RC result;
4595 INT32 i;
4596 result = UINT32_Unmarshal(&target->count, buffer, size);
4597 if (result != TPM_RC_SUCCESS) {
4598 return result;
4599 }
4600 if (target->count > MAX_ALG_LIST_SIZE) {
4601 return TPM_RC_SIZE;
4602 }
4603 for (i = 0; i < target->count; ++i) {
4604 result = TPM_ALG_ID_Unmarshal(&target->algorithms[i], buffer, size);
4605 if (result != TPM_RC_SUCCESS) {
4606 return result;
4607 }
4608 }
4609 return TPM_RC_SUCCESS;
4610 }
4611
TPMS_ALG_PROPERTY_Marshal(TPMS_ALG_PROPERTY * source,BYTE ** buffer,INT32 * size)4612 UINT16 TPMS_ALG_PROPERTY_Marshal(TPMS_ALG_PROPERTY* source,
4613 BYTE** buffer,
4614 INT32* size) {
4615 UINT16 total_size = 0;
4616 total_size += TPM_ALG_ID_Marshal(&source->alg, buffer, size);
4617 total_size += TPMA_ALGORITHM_Marshal(&source->algProperties, buffer, size);
4618 return total_size;
4619 }
4620
TPMS_ALG_PROPERTY_Unmarshal(TPMS_ALG_PROPERTY * target,BYTE ** buffer,INT32 * size)4621 TPM_RC TPMS_ALG_PROPERTY_Unmarshal(TPMS_ALG_PROPERTY* target,
4622 BYTE** buffer,
4623 INT32* size) {
4624 TPM_RC result;
4625 result = TPM_ALG_ID_Unmarshal(&target->alg, buffer, size);
4626 if (result != TPM_RC_SUCCESS) {
4627 return result;
4628 }
4629 result = TPMA_ALGORITHM_Unmarshal(&target->algProperties, buffer, size);
4630 if (result != TPM_RC_SUCCESS) {
4631 return result;
4632 }
4633 return TPM_RC_SUCCESS;
4634 }
4635
TPML_ALG_PROPERTY_Marshal(TPML_ALG_PROPERTY * source,BYTE ** buffer,INT32 * size)4636 UINT16 TPML_ALG_PROPERTY_Marshal(TPML_ALG_PROPERTY* source,
4637 BYTE** buffer,
4638 INT32* size) {
4639 UINT16 total_size = 0;
4640 INT32 i;
4641 total_size += UINT32_Marshal(&source->count, buffer, size);
4642 for (i = 0; i < source->count; ++i) {
4643 total_size +=
4644 TPMS_ALG_PROPERTY_Marshal(&source->algProperties[i], buffer, size);
4645 }
4646 return total_size;
4647 }
4648
TPML_ALG_PROPERTY_Unmarshal(TPML_ALG_PROPERTY * target,BYTE ** buffer,INT32 * size)4649 TPM_RC TPML_ALG_PROPERTY_Unmarshal(TPML_ALG_PROPERTY* target,
4650 BYTE** buffer,
4651 INT32* size) {
4652 TPM_RC result;
4653 INT32 i;
4654 result = UINT32_Unmarshal(&target->count, buffer, size);
4655 if (result != TPM_RC_SUCCESS) {
4656 return result;
4657 }
4658 if (target->count > MAX_CAP_ALGS) {
4659 return TPM_RC_SIZE;
4660 }
4661 for (i = 0; i < target->count; ++i) {
4662 result =
4663 TPMS_ALG_PROPERTY_Unmarshal(&target->algProperties[i], buffer, size);
4664 if (result != TPM_RC_SUCCESS) {
4665 return result;
4666 }
4667 }
4668 return TPM_RC_SUCCESS;
4669 }
4670
TPM_CC_Marshal(TPM_CC * source,BYTE ** buffer,INT32 * size)4671 UINT16 TPM_CC_Marshal(TPM_CC* source, BYTE** buffer, INT32* size) {
4672 return uint32_t_Marshal(source, buffer, size);
4673 }
4674
TPM_CC_Unmarshal(TPM_CC * target,BYTE ** buffer,INT32 * size)4675 TPM_RC TPM_CC_Unmarshal(TPM_CC* target, BYTE** buffer, INT32* size) {
4676 TPM_RC result;
4677 result = uint32_t_Unmarshal(target, buffer, size);
4678 if (result != TPM_RC_SUCCESS) {
4679 return result;
4680 }
4681 #ifdef TPM_CC_FIRST
4682 if (*target == TPM_CC_FIRST) {
4683 return TPM_RC_SUCCESS;
4684 }
4685 #endif
4686 #ifdef TPM_CC_PP_FIRST
4687 if (*target == TPM_CC_PP_FIRST) {
4688 return TPM_RC_SUCCESS;
4689 }
4690 #endif
4691 #ifdef TPM_CC_NV_UndefineSpaceSpecial
4692 if (*target == TPM_CC_NV_UndefineSpaceSpecial) {
4693 return TPM_RC_SUCCESS;
4694 }
4695 #endif
4696 #ifdef TPM_CC_EvictControl
4697 if (*target == TPM_CC_EvictControl) {
4698 return TPM_RC_SUCCESS;
4699 }
4700 #endif
4701 #ifdef TPM_CC_HierarchyControl
4702 if (*target == TPM_CC_HierarchyControl) {
4703 return TPM_RC_SUCCESS;
4704 }
4705 #endif
4706 #ifdef TPM_CC_NV_UndefineSpace
4707 if (*target == TPM_CC_NV_UndefineSpace) {
4708 return TPM_RC_SUCCESS;
4709 }
4710 #endif
4711 #ifdef TPM_CC_ChangeEPS
4712 if (*target == TPM_CC_ChangeEPS) {
4713 return TPM_RC_SUCCESS;
4714 }
4715 #endif
4716 #ifdef TPM_CC_ChangePPS
4717 if (*target == TPM_CC_ChangePPS) {
4718 return TPM_RC_SUCCESS;
4719 }
4720 #endif
4721 #ifdef TPM_CC_Clear
4722 if (*target == TPM_CC_Clear) {
4723 return TPM_RC_SUCCESS;
4724 }
4725 #endif
4726 #ifdef TPM_CC_ClearControl
4727 if (*target == TPM_CC_ClearControl) {
4728 return TPM_RC_SUCCESS;
4729 }
4730 #endif
4731 #ifdef TPM_CC_ClockSet
4732 if (*target == TPM_CC_ClockSet) {
4733 return TPM_RC_SUCCESS;
4734 }
4735 #endif
4736 #ifdef TPM_CC_HierarchyChangeAuth
4737 if (*target == TPM_CC_HierarchyChangeAuth) {
4738 return TPM_RC_SUCCESS;
4739 }
4740 #endif
4741 #ifdef TPM_CC_NV_DefineSpace
4742 if (*target == TPM_CC_NV_DefineSpace) {
4743 return TPM_RC_SUCCESS;
4744 }
4745 #endif
4746 #ifdef TPM_CC_PCR_Allocate
4747 if (*target == TPM_CC_PCR_Allocate) {
4748 return TPM_RC_SUCCESS;
4749 }
4750 #endif
4751 #ifdef TPM_CC_PCR_SetAuthPolicy
4752 if (*target == TPM_CC_PCR_SetAuthPolicy) {
4753 return TPM_RC_SUCCESS;
4754 }
4755 #endif
4756 #ifdef TPM_CC_PP_Commands
4757 if (*target == TPM_CC_PP_Commands) {
4758 return TPM_RC_SUCCESS;
4759 }
4760 #endif
4761 #ifdef TPM_CC_SetPrimaryPolicy
4762 if (*target == TPM_CC_SetPrimaryPolicy) {
4763 return TPM_RC_SUCCESS;
4764 }
4765 #endif
4766 #ifdef TPM_CC_FieldUpgradeStart
4767 if (*target == TPM_CC_FieldUpgradeStart) {
4768 return TPM_RC_SUCCESS;
4769 }
4770 #endif
4771 #ifdef TPM_CC_ClockRateAdjust
4772 if (*target == TPM_CC_ClockRateAdjust) {
4773 return TPM_RC_SUCCESS;
4774 }
4775 #endif
4776 #ifdef TPM_CC_CreatePrimary
4777 if (*target == TPM_CC_CreatePrimary) {
4778 return TPM_RC_SUCCESS;
4779 }
4780 #endif
4781 #ifdef TPM_CC_NV_GlobalWriteLock
4782 if (*target == TPM_CC_NV_GlobalWriteLock) {
4783 return TPM_RC_SUCCESS;
4784 }
4785 #endif
4786 #ifdef TPM_CC_PP_LAST
4787 if (*target == TPM_CC_PP_LAST) {
4788 return TPM_RC_SUCCESS;
4789 }
4790 #endif
4791 #ifdef TPM_CC_GetCommandAuditDigest
4792 if (*target == TPM_CC_GetCommandAuditDigest) {
4793 return TPM_RC_SUCCESS;
4794 }
4795 #endif
4796 #ifdef TPM_CC_NV_Increment
4797 if (*target == TPM_CC_NV_Increment) {
4798 return TPM_RC_SUCCESS;
4799 }
4800 #endif
4801 #ifdef TPM_CC_NV_SetBits
4802 if (*target == TPM_CC_NV_SetBits) {
4803 return TPM_RC_SUCCESS;
4804 }
4805 #endif
4806 #ifdef TPM_CC_NV_Extend
4807 if (*target == TPM_CC_NV_Extend) {
4808 return TPM_RC_SUCCESS;
4809 }
4810 #endif
4811 #ifdef TPM_CC_NV_Write
4812 if (*target == TPM_CC_NV_Write) {
4813 return TPM_RC_SUCCESS;
4814 }
4815 #endif
4816 #ifdef TPM_CC_NV_WriteLock
4817 if (*target == TPM_CC_NV_WriteLock) {
4818 return TPM_RC_SUCCESS;
4819 }
4820 #endif
4821 #ifdef TPM_CC_DictionaryAttackLockReset
4822 if (*target == TPM_CC_DictionaryAttackLockReset) {
4823 return TPM_RC_SUCCESS;
4824 }
4825 #endif
4826 #ifdef TPM_CC_DictionaryAttackParameters
4827 if (*target == TPM_CC_DictionaryAttackParameters) {
4828 return TPM_RC_SUCCESS;
4829 }
4830 #endif
4831 #ifdef TPM_CC_NV_ChangeAuth
4832 if (*target == TPM_CC_NV_ChangeAuth) {
4833 return TPM_RC_SUCCESS;
4834 }
4835 #endif
4836 #ifdef TPM_CC_PCR_Event
4837 if (*target == TPM_CC_PCR_Event) {
4838 return TPM_RC_SUCCESS;
4839 }
4840 #endif
4841 #ifdef TPM_CC_PCR_Reset
4842 if (*target == TPM_CC_PCR_Reset) {
4843 return TPM_RC_SUCCESS;
4844 }
4845 #endif
4846 #ifdef TPM_CC_SequenceComplete
4847 if (*target == TPM_CC_SequenceComplete) {
4848 return TPM_RC_SUCCESS;
4849 }
4850 #endif
4851 #ifdef TPM_CC_SetAlgorithmSet
4852 if (*target == TPM_CC_SetAlgorithmSet) {
4853 return TPM_RC_SUCCESS;
4854 }
4855 #endif
4856 #ifdef TPM_CC_SetCommandCodeAuditStatus
4857 if (*target == TPM_CC_SetCommandCodeAuditStatus) {
4858 return TPM_RC_SUCCESS;
4859 }
4860 #endif
4861 #ifdef TPM_CC_FieldUpgradeData
4862 if (*target == TPM_CC_FieldUpgradeData) {
4863 return TPM_RC_SUCCESS;
4864 }
4865 #endif
4866 #ifdef TPM_CC_IncrementalSelfTest
4867 if (*target == TPM_CC_IncrementalSelfTest) {
4868 return TPM_RC_SUCCESS;
4869 }
4870 #endif
4871 #ifdef TPM_CC_SelfTest
4872 if (*target == TPM_CC_SelfTest) {
4873 return TPM_RC_SUCCESS;
4874 }
4875 #endif
4876 #ifdef TPM_CC_Startup
4877 if (*target == TPM_CC_Startup) {
4878 return TPM_RC_SUCCESS;
4879 }
4880 #endif
4881 #ifdef TPM_CC_Shutdown
4882 if (*target == TPM_CC_Shutdown) {
4883 return TPM_RC_SUCCESS;
4884 }
4885 #endif
4886 #ifdef TPM_CC_StirRandom
4887 if (*target == TPM_CC_StirRandom) {
4888 return TPM_RC_SUCCESS;
4889 }
4890 #endif
4891 #ifdef TPM_CC_ActivateCredential
4892 if (*target == TPM_CC_ActivateCredential) {
4893 return TPM_RC_SUCCESS;
4894 }
4895 #endif
4896 #ifdef TPM_CC_Certify
4897 if (*target == TPM_CC_Certify) {
4898 return TPM_RC_SUCCESS;
4899 }
4900 #endif
4901 #ifdef TPM_CC_PolicyNV
4902 if (*target == TPM_CC_PolicyNV) {
4903 return TPM_RC_SUCCESS;
4904 }
4905 #endif
4906 #ifdef TPM_CC_CertifyCreation
4907 if (*target == TPM_CC_CertifyCreation) {
4908 return TPM_RC_SUCCESS;
4909 }
4910 #endif
4911 #ifdef TPM_CC_Duplicate
4912 if (*target == TPM_CC_Duplicate) {
4913 return TPM_RC_SUCCESS;
4914 }
4915 #endif
4916 #ifdef TPM_CC_GetTime
4917 if (*target == TPM_CC_GetTime) {
4918 return TPM_RC_SUCCESS;
4919 }
4920 #endif
4921 #ifdef TPM_CC_GetSessionAuditDigest
4922 if (*target == TPM_CC_GetSessionAuditDigest) {
4923 return TPM_RC_SUCCESS;
4924 }
4925 #endif
4926 #ifdef TPM_CC_NV_Read
4927 if (*target == TPM_CC_NV_Read) {
4928 return TPM_RC_SUCCESS;
4929 }
4930 #endif
4931 #ifdef TPM_CC_NV_ReadLock
4932 if (*target == TPM_CC_NV_ReadLock) {
4933 return TPM_RC_SUCCESS;
4934 }
4935 #endif
4936 #ifdef TPM_CC_ObjectChangeAuth
4937 if (*target == TPM_CC_ObjectChangeAuth) {
4938 return TPM_RC_SUCCESS;
4939 }
4940 #endif
4941 #ifdef TPM_CC_PolicySecret
4942 if (*target == TPM_CC_PolicySecret) {
4943 return TPM_RC_SUCCESS;
4944 }
4945 #endif
4946 #ifdef TPM_CC_Rewrap
4947 if (*target == TPM_CC_Rewrap) {
4948 return TPM_RC_SUCCESS;
4949 }
4950 #endif
4951 #ifdef TPM_CC_Create
4952 if (*target == TPM_CC_Create) {
4953 return TPM_RC_SUCCESS;
4954 }
4955 #endif
4956 #ifdef TPM_CC_ECDH_ZGen
4957 if (*target == TPM_CC_ECDH_ZGen) {
4958 return TPM_RC_SUCCESS;
4959 }
4960 #endif
4961 #ifdef TPM_CC_HMAC
4962 if (*target == TPM_CC_HMAC) {
4963 return TPM_RC_SUCCESS;
4964 }
4965 #endif
4966 #ifdef TPM_CC_Import
4967 if (*target == TPM_CC_Import) {
4968 return TPM_RC_SUCCESS;
4969 }
4970 #endif
4971 #ifdef TPM_CC_Load
4972 if (*target == TPM_CC_Load) {
4973 return TPM_RC_SUCCESS;
4974 }
4975 #endif
4976 #ifdef TPM_CC_Quote
4977 if (*target == TPM_CC_Quote) {
4978 return TPM_RC_SUCCESS;
4979 }
4980 #endif
4981 #ifdef TPM_CC_RSA_Decrypt
4982 if (*target == TPM_CC_RSA_Decrypt) {
4983 return TPM_RC_SUCCESS;
4984 }
4985 #endif
4986 #ifdef TPM_CC_HMAC_Start
4987 if (*target == TPM_CC_HMAC_Start) {
4988 return TPM_RC_SUCCESS;
4989 }
4990 #endif
4991 #ifdef TPM_CC_SequenceUpdate
4992 if (*target == TPM_CC_SequenceUpdate) {
4993 return TPM_RC_SUCCESS;
4994 }
4995 #endif
4996 #ifdef TPM_CC_Sign
4997 if (*target == TPM_CC_Sign) {
4998 return TPM_RC_SUCCESS;
4999 }
5000 #endif
5001 #ifdef TPM_CC_Unseal
5002 if (*target == TPM_CC_Unseal) {
5003 return TPM_RC_SUCCESS;
5004 }
5005 #endif
5006 #ifdef TPM_CC_PolicySigned
5007 if (*target == TPM_CC_PolicySigned) {
5008 return TPM_RC_SUCCESS;
5009 }
5010 #endif
5011 #ifdef TPM_CC_ContextLoad
5012 if (*target == TPM_CC_ContextLoad) {
5013 return TPM_RC_SUCCESS;
5014 }
5015 #endif
5016 #ifdef TPM_CC_ContextSave
5017 if (*target == TPM_CC_ContextSave) {
5018 return TPM_RC_SUCCESS;
5019 }
5020 #endif
5021 #ifdef TPM_CC_ECDH_KeyGen
5022 if (*target == TPM_CC_ECDH_KeyGen) {
5023 return TPM_RC_SUCCESS;
5024 }
5025 #endif
5026 #ifdef TPM_CC_EncryptDecrypt
5027 if (*target == TPM_CC_EncryptDecrypt) {
5028 return TPM_RC_SUCCESS;
5029 }
5030 #endif
5031 #ifdef TPM_CC_FlushContext
5032 if (*target == TPM_CC_FlushContext) {
5033 return TPM_RC_SUCCESS;
5034 }
5035 #endif
5036 #ifdef TPM_CC_LoadExternal
5037 if (*target == TPM_CC_LoadExternal) {
5038 return TPM_RC_SUCCESS;
5039 }
5040 #endif
5041 #ifdef TPM_CC_MakeCredential
5042 if (*target == TPM_CC_MakeCredential) {
5043 return TPM_RC_SUCCESS;
5044 }
5045 #endif
5046 #ifdef TPM_CC_NV_ReadPublic
5047 if (*target == TPM_CC_NV_ReadPublic) {
5048 return TPM_RC_SUCCESS;
5049 }
5050 #endif
5051 #ifdef TPM_CC_PolicyAuthorize
5052 if (*target == TPM_CC_PolicyAuthorize) {
5053 return TPM_RC_SUCCESS;
5054 }
5055 #endif
5056 #ifdef TPM_CC_PolicyAuthValue
5057 if (*target == TPM_CC_PolicyAuthValue) {
5058 return TPM_RC_SUCCESS;
5059 }
5060 #endif
5061 #ifdef TPM_CC_PolicyCommandCode
5062 if (*target == TPM_CC_PolicyCommandCode) {
5063 return TPM_RC_SUCCESS;
5064 }
5065 #endif
5066 #ifdef TPM_CC_PolicyCounterTimer
5067 if (*target == TPM_CC_PolicyCounterTimer) {
5068 return TPM_RC_SUCCESS;
5069 }
5070 #endif
5071 #ifdef TPM_CC_PolicyCpHash
5072 if (*target == TPM_CC_PolicyCpHash) {
5073 return TPM_RC_SUCCESS;
5074 }
5075 #endif
5076 #ifdef TPM_CC_PolicyLocality
5077 if (*target == TPM_CC_PolicyLocality) {
5078 return TPM_RC_SUCCESS;
5079 }
5080 #endif
5081 #ifdef TPM_CC_PolicyNameHash
5082 if (*target == TPM_CC_PolicyNameHash) {
5083 return TPM_RC_SUCCESS;
5084 }
5085 #endif
5086 #ifdef TPM_CC_PolicyOR
5087 if (*target == TPM_CC_PolicyOR) {
5088 return TPM_RC_SUCCESS;
5089 }
5090 #endif
5091 #ifdef TPM_CC_PolicyTicket
5092 if (*target == TPM_CC_PolicyTicket) {
5093 return TPM_RC_SUCCESS;
5094 }
5095 #endif
5096 #ifdef TPM_CC_ReadPublic
5097 if (*target == TPM_CC_ReadPublic) {
5098 return TPM_RC_SUCCESS;
5099 }
5100 #endif
5101 #ifdef TPM_CC_RSA_Encrypt
5102 if (*target == TPM_CC_RSA_Encrypt) {
5103 return TPM_RC_SUCCESS;
5104 }
5105 #endif
5106 #ifdef TPM_CC_StartAuthSession
5107 if (*target == TPM_CC_StartAuthSession) {
5108 return TPM_RC_SUCCESS;
5109 }
5110 #endif
5111 #ifdef TPM_CC_VerifySignature
5112 if (*target == TPM_CC_VerifySignature) {
5113 return TPM_RC_SUCCESS;
5114 }
5115 #endif
5116 #ifdef TPM_CC_ECC_Parameters
5117 if (*target == TPM_CC_ECC_Parameters) {
5118 return TPM_RC_SUCCESS;
5119 }
5120 #endif
5121 #ifdef TPM_CC_FirmwareRead
5122 if (*target == TPM_CC_FirmwareRead) {
5123 return TPM_RC_SUCCESS;
5124 }
5125 #endif
5126 #ifdef TPM_CC_GetCapability
5127 if (*target == TPM_CC_GetCapability) {
5128 return TPM_RC_SUCCESS;
5129 }
5130 #endif
5131 #ifdef TPM_CC_GetRandom
5132 if (*target == TPM_CC_GetRandom) {
5133 return TPM_RC_SUCCESS;
5134 }
5135 #endif
5136 #ifdef TPM_CC_GetTestResult
5137 if (*target == TPM_CC_GetTestResult) {
5138 return TPM_RC_SUCCESS;
5139 }
5140 #endif
5141 #ifdef TPM_CC_Hash
5142 if (*target == TPM_CC_Hash) {
5143 return TPM_RC_SUCCESS;
5144 }
5145 #endif
5146 #ifdef TPM_CC_PCR_Read
5147 if (*target == TPM_CC_PCR_Read) {
5148 return TPM_RC_SUCCESS;
5149 }
5150 #endif
5151 #ifdef TPM_CC_PolicyPCR
5152 if (*target == TPM_CC_PolicyPCR) {
5153 return TPM_RC_SUCCESS;
5154 }
5155 #endif
5156 #ifdef TPM_CC_PolicyRestart
5157 if (*target == TPM_CC_PolicyRestart) {
5158 return TPM_RC_SUCCESS;
5159 }
5160 #endif
5161 #ifdef TPM_CC_ReadClock
5162 if (*target == TPM_CC_ReadClock) {
5163 return TPM_RC_SUCCESS;
5164 }
5165 #endif
5166 #ifdef TPM_CC_PCR_Extend
5167 if (*target == TPM_CC_PCR_Extend) {
5168 return TPM_RC_SUCCESS;
5169 }
5170 #endif
5171 #ifdef TPM_CC_PCR_SetAuthValue
5172 if (*target == TPM_CC_PCR_SetAuthValue) {
5173 return TPM_RC_SUCCESS;
5174 }
5175 #endif
5176 #ifdef TPM_CC_NV_Certify
5177 if (*target == TPM_CC_NV_Certify) {
5178 return TPM_RC_SUCCESS;
5179 }
5180 #endif
5181 #ifdef TPM_CC_EventSequenceComplete
5182 if (*target == TPM_CC_EventSequenceComplete) {
5183 return TPM_RC_SUCCESS;
5184 }
5185 #endif
5186 #ifdef TPM_CC_HashSequenceStart
5187 if (*target == TPM_CC_HashSequenceStart) {
5188 return TPM_RC_SUCCESS;
5189 }
5190 #endif
5191 #ifdef TPM_CC_PolicyPhysicalPresence
5192 if (*target == TPM_CC_PolicyPhysicalPresence) {
5193 return TPM_RC_SUCCESS;
5194 }
5195 #endif
5196 #ifdef TPM_CC_PolicyDuplicationSelect
5197 if (*target == TPM_CC_PolicyDuplicationSelect) {
5198 return TPM_RC_SUCCESS;
5199 }
5200 #endif
5201 #ifdef TPM_CC_PolicyGetDigest
5202 if (*target == TPM_CC_PolicyGetDigest) {
5203 return TPM_RC_SUCCESS;
5204 }
5205 #endif
5206 #ifdef TPM_CC_TestParms
5207 if (*target == TPM_CC_TestParms) {
5208 return TPM_RC_SUCCESS;
5209 }
5210 #endif
5211 #ifdef TPM_CC_Commit
5212 if (*target == TPM_CC_Commit) {
5213 return TPM_RC_SUCCESS;
5214 }
5215 #endif
5216 #ifdef TPM_CC_PolicyPassword
5217 if (*target == TPM_CC_PolicyPassword) {
5218 return TPM_RC_SUCCESS;
5219 }
5220 #endif
5221 #ifdef TPM_CC_ZGen_2Phase
5222 if (*target == TPM_CC_ZGen_2Phase) {
5223 return TPM_RC_SUCCESS;
5224 }
5225 #endif
5226 #ifdef TPM_CC_EC_Ephemeral
5227 if (*target == TPM_CC_EC_Ephemeral) {
5228 return TPM_RC_SUCCESS;
5229 }
5230 #endif
5231 #ifdef TPM_CC_PolicyNvWritten
5232 if (*target == TPM_CC_PolicyNvWritten) {
5233 return TPM_RC_SUCCESS;
5234 }
5235 #endif
5236 #ifdef TPM_CC_LAST
5237 if (*target == TPM_CC_LAST) {
5238 return TPM_RC_SUCCESS;
5239 }
5240 #endif
5241 return TPM_RC_COMMAND_CODE;
5242 }
5243
TPML_CC_Marshal(TPML_CC * source,BYTE ** buffer,INT32 * size)5244 UINT16 TPML_CC_Marshal(TPML_CC* source, BYTE** buffer, INT32* size) {
5245 UINT16 total_size = 0;
5246 INT32 i;
5247 total_size += UINT32_Marshal(&source->count, buffer, size);
5248 for (i = 0; i < source->count; ++i) {
5249 total_size += TPM_CC_Marshal(&source->commandCodes[i], buffer, size);
5250 }
5251 return total_size;
5252 }
5253
TPML_CC_Unmarshal(TPML_CC * target,BYTE ** buffer,INT32 * size)5254 TPM_RC TPML_CC_Unmarshal(TPML_CC* target, BYTE** buffer, INT32* size) {
5255 TPM_RC result;
5256 INT32 i;
5257 result = UINT32_Unmarshal(&target->count, buffer, size);
5258 if (result != TPM_RC_SUCCESS) {
5259 return result;
5260 }
5261 if (target->count > MAX_CAP_CC) {
5262 return TPM_RC_SIZE;
5263 }
5264 for (i = 0; i < target->count; ++i) {
5265 result = TPM_CC_Unmarshal(&target->commandCodes[i], buffer, size);
5266 if (result != TPM_RC_SUCCESS) {
5267 return result;
5268 }
5269 }
5270 return TPM_RC_SUCCESS;
5271 }
5272
TPML_CCA_Marshal(TPML_CCA * source,BYTE ** buffer,INT32 * size)5273 UINT16 TPML_CCA_Marshal(TPML_CCA* source, BYTE** buffer, INT32* size) {
5274 UINT16 total_size = 0;
5275 INT32 i;
5276 total_size += UINT32_Marshal(&source->count, buffer, size);
5277 for (i = 0; i < source->count; ++i) {
5278 total_size += TPMA_CC_Marshal(&source->commandAttributes[i], buffer, size);
5279 }
5280 return total_size;
5281 }
5282
TPML_CCA_Unmarshal(TPML_CCA * target,BYTE ** buffer,INT32 * size)5283 TPM_RC TPML_CCA_Unmarshal(TPML_CCA* target, BYTE** buffer, INT32* size) {
5284 TPM_RC result;
5285 INT32 i;
5286 result = UINT32_Unmarshal(&target->count, buffer, size);
5287 if (result != TPM_RC_SUCCESS) {
5288 return result;
5289 }
5290 if (target->count > MAX_CAP_CC) {
5291 return TPM_RC_SIZE;
5292 }
5293 for (i = 0; i < target->count; ++i) {
5294 result = TPMA_CC_Unmarshal(&target->commandAttributes[i], buffer, size);
5295 if (result != TPM_RC_SUCCESS) {
5296 return result;
5297 }
5298 }
5299 return TPM_RC_SUCCESS;
5300 }
5301
TPML_DIGEST_Marshal(TPML_DIGEST * source,BYTE ** buffer,INT32 * size)5302 UINT16 TPML_DIGEST_Marshal(TPML_DIGEST* source, BYTE** buffer, INT32* size) {
5303 UINT16 total_size = 0;
5304 INT32 i;
5305 total_size += UINT32_Marshal(&source->count, buffer, size);
5306 for (i = 0; i < source->count; ++i) {
5307 total_size += TPM2B_DIGEST_Marshal(&source->digests[i], buffer, size);
5308 }
5309 return total_size;
5310 }
5311
TPML_DIGEST_Unmarshal(TPML_DIGEST * target,BYTE ** buffer,INT32 * size)5312 TPM_RC TPML_DIGEST_Unmarshal(TPML_DIGEST* target, BYTE** buffer, INT32* size) {
5313 TPM_RC result;
5314 INT32 i;
5315 result = UINT32_Unmarshal(&target->count, buffer, size);
5316 if (result != TPM_RC_SUCCESS) {
5317 return result;
5318 }
5319 if (target->count > 8) {
5320 return TPM_RC_SIZE;
5321 }
5322 if (target->count < 2) {
5323 return TPM_RC_SIZE;
5324 }
5325 for (i = 0; i < target->count; ++i) {
5326 result = TPM2B_DIGEST_Unmarshal(&target->digests[i], buffer, size);
5327 if (result != TPM_RC_SUCCESS) {
5328 return result;
5329 }
5330 }
5331 return TPM_RC_SUCCESS;
5332 }
5333
TPMU_HA_Marshal(TPMU_HA * source,BYTE ** buffer,INT32 * size,UINT32 selector)5334 UINT16 TPMU_HA_Marshal(TPMU_HA* source,
5335 BYTE** buffer,
5336 INT32* size,
5337 UINT32 selector) {
5338 INT32 i;
5339 UINT16 total_size = 0;
5340 switch (selector) {
5341 #ifdef TPM_ALG_SHA
5342 case TPM_ALG_SHA:
5343 for (i = 0; i < SHA_DIGEST_SIZE; ++i) {
5344 total_size += BYTE_Marshal(&source->sha[i], buffer, size);
5345 }
5346 return total_size;
5347 #endif
5348 #ifdef TPM_ALG_SHA1
5349 case TPM_ALG_SHA1:
5350 for (i = 0; i < SHA1_DIGEST_SIZE; ++i) {
5351 total_size += BYTE_Marshal(&source->sha1[i], buffer, size);
5352 }
5353 return total_size;
5354 #endif
5355 #ifdef TPM_ALG_SHA256
5356 case TPM_ALG_SHA256:
5357 for (i = 0; i < SHA256_DIGEST_SIZE; ++i) {
5358 total_size += BYTE_Marshal(&source->sha256[i], buffer, size);
5359 }
5360 return total_size;
5361 #endif
5362 #ifdef TPM_ALG_SHA384
5363 case TPM_ALG_SHA384:
5364 for (i = 0; i < SHA384_DIGEST_SIZE; ++i) {
5365 total_size += BYTE_Marshal(&source->sha384[i], buffer, size);
5366 }
5367 return total_size;
5368 #endif
5369 #ifdef TPM_ALG_SHA512
5370 case TPM_ALG_SHA512:
5371 for (i = 0; i < SHA512_DIGEST_SIZE; ++i) {
5372 total_size += BYTE_Marshal(&source->sha512[i], buffer, size);
5373 }
5374 return total_size;
5375 #endif
5376 #ifdef TPM_ALG_SM3_256
5377 case TPM_ALG_SM3_256:
5378 for (i = 0; i < SM3_256_DIGEST_SIZE; ++i) {
5379 total_size += BYTE_Marshal(&source->sm3_256[i], buffer, size);
5380 }
5381 return total_size;
5382 #endif
5383 #ifdef TPM_ALG_NULL
5384 case TPM_ALG_NULL:
5385 return 0;
5386 #endif
5387 }
5388 return 0;
5389 }
5390
TPMU_HA_Unmarshal(TPMU_HA * target,BYTE ** buffer,INT32 * size,UINT32 selector)5391 TPM_RC TPMU_HA_Unmarshal(TPMU_HA* target,
5392 BYTE** buffer,
5393 INT32* size,
5394 UINT32 selector) {
5395 switch (selector) {
5396 INT32 i;
5397 TPM_RC result = TPM_RC_SUCCESS;
5398 #ifdef TPM_ALG_SHA
5399 case TPM_ALG_SHA:
5400 for (i = 0; i < SHA_DIGEST_SIZE; ++i) {
5401 result = BYTE_Unmarshal(&target->sha[i], buffer, size);
5402 if (result != TPM_RC_SUCCESS) {
5403 return result;
5404 }
5405 }
5406 return TPM_RC_SUCCESS;
5407 #endif
5408 #ifdef TPM_ALG_SHA1
5409 case TPM_ALG_SHA1:
5410 for (i = 0; i < SHA1_DIGEST_SIZE; ++i) {
5411 result = BYTE_Unmarshal(&target->sha1[i], buffer, size);
5412 if (result != TPM_RC_SUCCESS) {
5413 return result;
5414 }
5415 }
5416 return TPM_RC_SUCCESS;
5417 #endif
5418 #ifdef TPM_ALG_SHA256
5419 case TPM_ALG_SHA256:
5420 for (i = 0; i < SHA256_DIGEST_SIZE; ++i) {
5421 result = BYTE_Unmarshal(&target->sha256[i], buffer, size);
5422 if (result != TPM_RC_SUCCESS) {
5423 return result;
5424 }
5425 }
5426 return TPM_RC_SUCCESS;
5427 #endif
5428 #ifdef TPM_ALG_SHA384
5429 case TPM_ALG_SHA384:
5430 for (i = 0; i < SHA384_DIGEST_SIZE; ++i) {
5431 result = BYTE_Unmarshal(&target->sha384[i], buffer, size);
5432 if (result != TPM_RC_SUCCESS) {
5433 return result;
5434 }
5435 }
5436 return TPM_RC_SUCCESS;
5437 #endif
5438 #ifdef TPM_ALG_SHA512
5439 case TPM_ALG_SHA512:
5440 for (i = 0; i < SHA512_DIGEST_SIZE; ++i) {
5441 result = BYTE_Unmarshal(&target->sha512[i], buffer, size);
5442 if (result != TPM_RC_SUCCESS) {
5443 return result;
5444 }
5445 }
5446 return TPM_RC_SUCCESS;
5447 #endif
5448 #ifdef TPM_ALG_SM3_256
5449 case TPM_ALG_SM3_256:
5450 for (i = 0; i < SM3_256_DIGEST_SIZE; ++i) {
5451 result = BYTE_Unmarshal(&target->sm3_256[i], buffer, size);
5452 if (result != TPM_RC_SUCCESS) {
5453 return result;
5454 }
5455 }
5456 return TPM_RC_SUCCESS;
5457 #endif
5458 #ifdef TPM_ALG_NULL
5459 case TPM_ALG_NULL:
5460 return TPM_RC_SUCCESS;
5461 #endif
5462 }
5463 return TPM_RC_SELECTOR;
5464 }
5465
TPMT_HA_Marshal(TPMT_HA * source,BYTE ** buffer,INT32 * size)5466 UINT16 TPMT_HA_Marshal(TPMT_HA* source, BYTE** buffer, INT32* size) {
5467 UINT16 total_size = 0;
5468 total_size += TPMI_ALG_HASH_Marshal(&source->hashAlg, buffer, size);
5469 total_size += TPMU_HA_Marshal(&source->digest, buffer, size, source->hashAlg);
5470 return total_size;
5471 }
5472
TPMT_HA_Unmarshal(TPMT_HA * target,BYTE ** buffer,INT32 * size)5473 TPM_RC TPMT_HA_Unmarshal(TPMT_HA* target, BYTE** buffer, INT32* size) {
5474 TPM_RC result;
5475 result = TPMI_ALG_HASH_Unmarshal(&target->hashAlg, buffer, size, TRUE);
5476 if (result != TPM_RC_SUCCESS) {
5477 return result;
5478 }
5479 result = TPMU_HA_Unmarshal(&target->digest, buffer, size, target->hashAlg);
5480 if (result != TPM_RC_SUCCESS) {
5481 return result;
5482 }
5483 return TPM_RC_SUCCESS;
5484 }
5485
TPML_DIGEST_VALUES_Marshal(TPML_DIGEST_VALUES * source,BYTE ** buffer,INT32 * size)5486 UINT16 TPML_DIGEST_VALUES_Marshal(TPML_DIGEST_VALUES* source,
5487 BYTE** buffer,
5488 INT32* size) {
5489 UINT16 total_size = 0;
5490 INT32 i;
5491 total_size += UINT32_Marshal(&source->count, buffer, size);
5492 for (i = 0; i < source->count; ++i) {
5493 total_size += TPMT_HA_Marshal(&source->digests[i], buffer, size);
5494 }
5495 return total_size;
5496 }
5497
TPML_DIGEST_VALUES_Unmarshal(TPML_DIGEST_VALUES * target,BYTE ** buffer,INT32 * size)5498 TPM_RC TPML_DIGEST_VALUES_Unmarshal(TPML_DIGEST_VALUES* target,
5499 BYTE** buffer,
5500 INT32* size) {
5501 TPM_RC result;
5502 INT32 i;
5503 result = UINT32_Unmarshal(&target->count, buffer, size);
5504 if (result != TPM_RC_SUCCESS) {
5505 return result;
5506 }
5507 if (target->count > HASH_COUNT) {
5508 return TPM_RC_SIZE;
5509 }
5510 for (i = 0; i < target->count; ++i) {
5511 result = TPMT_HA_Unmarshal(&target->digests[i], buffer, size);
5512 if (result != TPM_RC_SUCCESS) {
5513 return result;
5514 }
5515 }
5516 return TPM_RC_SUCCESS;
5517 }
5518
TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE * source,BYTE ** buffer,INT32 * size)5519 UINT16 TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE* source,
5520 BYTE** buffer,
5521 INT32* size) {
5522 return uint16_t_Marshal(source, buffer, size);
5523 }
5524
TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE * target,BYTE ** buffer,INT32 * size)5525 TPM_RC TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE* target,
5526 BYTE** buffer,
5527 INT32* size) {
5528 TPM_RC result;
5529 result = uint16_t_Unmarshal(target, buffer, size);
5530 if (result != TPM_RC_SUCCESS) {
5531 return result;
5532 }
5533 if (*target == TPM_ECC_NONE) {
5534 return TPM_RC_SUCCESS;
5535 }
5536 if (*target == TPM_ECC_NIST_P192) {
5537 return TPM_RC_SUCCESS;
5538 }
5539 if (*target == TPM_ECC_NIST_P224) {
5540 return TPM_RC_SUCCESS;
5541 }
5542 if (*target == TPM_ECC_NIST_P256) {
5543 return TPM_RC_SUCCESS;
5544 }
5545 if (*target == TPM_ECC_NIST_P384) {
5546 return TPM_RC_SUCCESS;
5547 }
5548 if (*target == TPM_ECC_NIST_P521) {
5549 return TPM_RC_SUCCESS;
5550 }
5551 if (*target == TPM_ECC_BN_P256) {
5552 return TPM_RC_SUCCESS;
5553 }
5554 if (*target == TPM_ECC_BN_P638) {
5555 return TPM_RC_SUCCESS;
5556 }
5557 if (*target == TPM_ECC_SM2_P256) {
5558 return TPM_RC_SUCCESS;
5559 }
5560 return TPM_RC_CURVE;
5561 }
5562
TPML_ECC_CURVE_Marshal(TPML_ECC_CURVE * source,BYTE ** buffer,INT32 * size)5563 UINT16 TPML_ECC_CURVE_Marshal(TPML_ECC_CURVE* source,
5564 BYTE** buffer,
5565 INT32* size) {
5566 UINT16 total_size = 0;
5567 INT32 i;
5568 total_size += UINT32_Marshal(&source->count, buffer, size);
5569 for (i = 0; i < source->count; ++i) {
5570 total_size += TPM_ECC_CURVE_Marshal(&source->eccCurves[i], buffer, size);
5571 }
5572 return total_size;
5573 }
5574
TPML_ECC_CURVE_Unmarshal(TPML_ECC_CURVE * target,BYTE ** buffer,INT32 * size)5575 TPM_RC TPML_ECC_CURVE_Unmarshal(TPML_ECC_CURVE* target,
5576 BYTE** buffer,
5577 INT32* size) {
5578 TPM_RC result;
5579 INT32 i;
5580 result = UINT32_Unmarshal(&target->count, buffer, size);
5581 if (result != TPM_RC_SUCCESS) {
5582 return result;
5583 }
5584 if (target->count > MAX_ECC_CURVES) {
5585 return TPM_RC_SIZE;
5586 }
5587 for (i = 0; i < target->count; ++i) {
5588 result = TPM_ECC_CURVE_Unmarshal(&target->eccCurves[i], buffer, size);
5589 if (result != TPM_RC_SUCCESS) {
5590 return result;
5591 }
5592 }
5593 return TPM_RC_SUCCESS;
5594 }
5595
TPM_HANDLE_Marshal(TPM_HANDLE * source,BYTE ** buffer,INT32 * size)5596 UINT16 TPM_HANDLE_Marshal(TPM_HANDLE* source, BYTE** buffer, INT32* size) {
5597 return uint32_t_Marshal(source, buffer, size);
5598 }
5599
TPM_HANDLE_Unmarshal(TPM_HANDLE * target,BYTE ** buffer,INT32 * size)5600 TPM_RC TPM_HANDLE_Unmarshal(TPM_HANDLE* target, BYTE** buffer, INT32* size) {
5601 return uint32_t_Unmarshal(target, buffer, size);
5602 }
5603
TPML_HANDLE_Marshal(TPML_HANDLE * source,BYTE ** buffer,INT32 * size)5604 UINT16 TPML_HANDLE_Marshal(TPML_HANDLE* source, BYTE** buffer, INT32* size) {
5605 UINT16 total_size = 0;
5606 INT32 i;
5607 total_size += UINT32_Marshal(&source->count, buffer, size);
5608 for (i = 0; i < source->count; ++i) {
5609 total_size += TPM_HANDLE_Marshal(&source->handle[i], buffer, size);
5610 }
5611 return total_size;
5612 }
5613
TPML_HANDLE_Unmarshal(TPML_HANDLE * target,BYTE ** buffer,INT32 * size)5614 TPM_RC TPML_HANDLE_Unmarshal(TPML_HANDLE* target, BYTE** buffer, INT32* size) {
5615 TPM_RC result;
5616 INT32 i;
5617 result = UINT32_Unmarshal(&target->count, buffer, size);
5618 if (result != TPM_RC_SUCCESS) {
5619 return result;
5620 }
5621 if (target->count > MAX_CAP_HANDLES) {
5622 return TPM_RC_SIZE;
5623 }
5624 for (i = 0; i < target->count; ++i) {
5625 result = TPM_HANDLE_Unmarshal(&target->handle[i], buffer, size);
5626 if (result != TPM_RC_SUCCESS) {
5627 return result;
5628 }
5629 }
5630 return TPM_RC_SUCCESS;
5631 }
5632
TPM_PT_Marshal(TPM_PT * source,BYTE ** buffer,INT32 * size)5633 UINT16 TPM_PT_Marshal(TPM_PT* source, BYTE** buffer, INT32* size) {
5634 return uint32_t_Marshal(source, buffer, size);
5635 }
5636
TPM_PT_Unmarshal(TPM_PT * target,BYTE ** buffer,INT32 * size)5637 TPM_RC TPM_PT_Unmarshal(TPM_PT* target, BYTE** buffer, INT32* size) {
5638 TPM_RC result;
5639 result = uint32_t_Unmarshal(target, buffer, size);
5640 if (result != TPM_RC_SUCCESS) {
5641 return result;
5642 }
5643 if (*target == TPM_PT_NONE) {
5644 return TPM_RC_SUCCESS;
5645 }
5646 if (*target == PT_GROUP) {
5647 return TPM_RC_SUCCESS;
5648 }
5649 if (*target == PT_FIXED) {
5650 return TPM_RC_SUCCESS;
5651 }
5652 if (*target == TPM_PT_FAMILY_INDICATOR) {
5653 return TPM_RC_SUCCESS;
5654 }
5655 if (*target == TPM_PT_LEVEL) {
5656 return TPM_RC_SUCCESS;
5657 }
5658 if (*target == TPM_PT_REVISION) {
5659 return TPM_RC_SUCCESS;
5660 }
5661 if (*target == TPM_PT_DAY_OF_YEAR) {
5662 return TPM_RC_SUCCESS;
5663 }
5664 if (*target == TPM_PT_YEAR) {
5665 return TPM_RC_SUCCESS;
5666 }
5667 if (*target == TPM_PT_MANUFACTURER) {
5668 return TPM_RC_SUCCESS;
5669 }
5670 if (*target == TPM_PT_VENDOR_STRING_1) {
5671 return TPM_RC_SUCCESS;
5672 }
5673 if (*target == TPM_PT_VENDOR_STRING_2) {
5674 return TPM_RC_SUCCESS;
5675 }
5676 if (*target == TPM_PT_VENDOR_STRING_3) {
5677 return TPM_RC_SUCCESS;
5678 }
5679 if (*target == TPM_PT_VENDOR_STRING_4) {
5680 return TPM_RC_SUCCESS;
5681 }
5682 if (*target == TPM_PT_VENDOR_TPM_TYPE) {
5683 return TPM_RC_SUCCESS;
5684 }
5685 if (*target == TPM_PT_FIRMWARE_VERSION_1) {
5686 return TPM_RC_SUCCESS;
5687 }
5688 if (*target == TPM_PT_FIRMWARE_VERSION_2) {
5689 return TPM_RC_SUCCESS;
5690 }
5691 if (*target == TPM_PT_INPUT_BUFFER) {
5692 return TPM_RC_SUCCESS;
5693 }
5694 if (*target == TPM_PT_HR_TRANSIENT_MIN) {
5695 return TPM_RC_SUCCESS;
5696 }
5697 if (*target == TPM_PT_HR_PERSISTENT_MIN) {
5698 return TPM_RC_SUCCESS;
5699 }
5700 if (*target == TPM_PT_HR_LOADED_MIN) {
5701 return TPM_RC_SUCCESS;
5702 }
5703 if (*target == TPM_PT_ACTIVE_SESSIONS_MAX) {
5704 return TPM_RC_SUCCESS;
5705 }
5706 if (*target == TPM_PT_PCR_COUNT) {
5707 return TPM_RC_SUCCESS;
5708 }
5709 if (*target == TPM_PT_PCR_SELECT_MIN) {
5710 return TPM_RC_SUCCESS;
5711 }
5712 if (*target == TPM_PT_CONTEXT_GAP_MAX) {
5713 return TPM_RC_SUCCESS;
5714 }
5715 if (*target == TPM_PT_NV_COUNTERS_MAX) {
5716 return TPM_RC_SUCCESS;
5717 }
5718 if (*target == TPM_PT_NV_INDEX_MAX) {
5719 return TPM_RC_SUCCESS;
5720 }
5721 if (*target == TPM_PT_MEMORY) {
5722 return TPM_RC_SUCCESS;
5723 }
5724 if (*target == TPM_PT_CLOCK_UPDATE) {
5725 return TPM_RC_SUCCESS;
5726 }
5727 if (*target == TPM_PT_CONTEXT_HASH) {
5728 return TPM_RC_SUCCESS;
5729 }
5730 if (*target == TPM_PT_CONTEXT_SYM) {
5731 return TPM_RC_SUCCESS;
5732 }
5733 if (*target == TPM_PT_CONTEXT_SYM_SIZE) {
5734 return TPM_RC_SUCCESS;
5735 }
5736 if (*target == TPM_PT_ORDERLY_COUNT) {
5737 return TPM_RC_SUCCESS;
5738 }
5739 if (*target == TPM_PT_MAX_COMMAND_SIZE) {
5740 return TPM_RC_SUCCESS;
5741 }
5742 if (*target == TPM_PT_MAX_RESPONSE_SIZE) {
5743 return TPM_RC_SUCCESS;
5744 }
5745 if (*target == TPM_PT_MAX_DIGEST) {
5746 return TPM_RC_SUCCESS;
5747 }
5748 if (*target == TPM_PT_MAX_OBJECT_CONTEXT) {
5749 return TPM_RC_SUCCESS;
5750 }
5751 if (*target == TPM_PT_MAX_SESSION_CONTEXT) {
5752 return TPM_RC_SUCCESS;
5753 }
5754 if (*target == TPM_PT_PS_FAMILY_INDICATOR) {
5755 return TPM_RC_SUCCESS;
5756 }
5757 if (*target == TPM_PT_PS_LEVEL) {
5758 return TPM_RC_SUCCESS;
5759 }
5760 if (*target == TPM_PT_PS_REVISION) {
5761 return TPM_RC_SUCCESS;
5762 }
5763 if (*target == TPM_PT_PS_DAY_OF_YEAR) {
5764 return TPM_RC_SUCCESS;
5765 }
5766 if (*target == TPM_PT_PS_YEAR) {
5767 return TPM_RC_SUCCESS;
5768 }
5769 if (*target == TPM_PT_SPLIT_MAX) {
5770 return TPM_RC_SUCCESS;
5771 }
5772 if (*target == TPM_PT_TOTAL_COMMANDS) {
5773 return TPM_RC_SUCCESS;
5774 }
5775 if (*target == TPM_PT_LIBRARY_COMMANDS) {
5776 return TPM_RC_SUCCESS;
5777 }
5778 if (*target == TPM_PT_VENDOR_COMMANDS) {
5779 return TPM_RC_SUCCESS;
5780 }
5781 if (*target == TPM_PT_NV_BUFFER_MAX) {
5782 return TPM_RC_SUCCESS;
5783 }
5784 if (*target == PT_VAR) {
5785 return TPM_RC_SUCCESS;
5786 }
5787 if (*target == TPM_PT_PERMANENT) {
5788 return TPM_RC_SUCCESS;
5789 }
5790 if (*target == TPM_PT_STARTUP_CLEAR) {
5791 return TPM_RC_SUCCESS;
5792 }
5793 if (*target == TPM_PT_HR_NV_INDEX) {
5794 return TPM_RC_SUCCESS;
5795 }
5796 if (*target == TPM_PT_HR_LOADED) {
5797 return TPM_RC_SUCCESS;
5798 }
5799 if (*target == TPM_PT_HR_LOADED_AVAIL) {
5800 return TPM_RC_SUCCESS;
5801 }
5802 if (*target == TPM_PT_HR_ACTIVE) {
5803 return TPM_RC_SUCCESS;
5804 }
5805 if (*target == TPM_PT_HR_ACTIVE_AVAIL) {
5806 return TPM_RC_SUCCESS;
5807 }
5808 if (*target == TPM_PT_HR_TRANSIENT_AVAIL) {
5809 return TPM_RC_SUCCESS;
5810 }
5811 if (*target == TPM_PT_HR_PERSISTENT) {
5812 return TPM_RC_SUCCESS;
5813 }
5814 if (*target == TPM_PT_HR_PERSISTENT_AVAIL) {
5815 return TPM_RC_SUCCESS;
5816 }
5817 if (*target == TPM_PT_NV_COUNTERS) {
5818 return TPM_RC_SUCCESS;
5819 }
5820 if (*target == TPM_PT_NV_COUNTERS_AVAIL) {
5821 return TPM_RC_SUCCESS;
5822 }
5823 if (*target == TPM_PT_ALGORITHM_SET) {
5824 return TPM_RC_SUCCESS;
5825 }
5826 if (*target == TPM_PT_LOADED_CURVES) {
5827 return TPM_RC_SUCCESS;
5828 }
5829 if (*target == TPM_PT_LOCKOUT_COUNTER) {
5830 return TPM_RC_SUCCESS;
5831 }
5832 if (*target == TPM_PT_MAX_AUTH_FAIL) {
5833 return TPM_RC_SUCCESS;
5834 }
5835 if (*target == TPM_PT_LOCKOUT_INTERVAL) {
5836 return TPM_RC_SUCCESS;
5837 }
5838 if (*target == TPM_PT_LOCKOUT_RECOVERY) {
5839 return TPM_RC_SUCCESS;
5840 }
5841 if (*target == TPM_PT_NV_WRITE_RECOVERY) {
5842 return TPM_RC_SUCCESS;
5843 }
5844 if (*target == TPM_PT_AUDIT_COUNTER_0) {
5845 return TPM_RC_SUCCESS;
5846 }
5847 if (*target == TPM_PT_AUDIT_COUNTER_1) {
5848 return TPM_RC_SUCCESS;
5849 }
5850 return TPM_RC_VALUE;
5851 }
5852
TPMS_TAGGED_PCR_SELECT_Marshal(TPMS_TAGGED_PCR_SELECT * source,BYTE ** buffer,INT32 * size)5853 UINT16 TPMS_TAGGED_PCR_SELECT_Marshal(TPMS_TAGGED_PCR_SELECT* source,
5854 BYTE** buffer,
5855 INT32* size) {
5856 UINT16 total_size = 0;
5857 INT32 i;
5858 total_size += TPM_PT_Marshal(&source->tag, buffer, size);
5859 total_size += UINT8_Marshal(&source->sizeofSelect, buffer, size);
5860 for (i = 0; i < source->sizeofSelect; ++i) {
5861 total_size += BYTE_Marshal(&source->pcrSelect[i], buffer, size);
5862 }
5863 return total_size;
5864 }
5865
TPMS_TAGGED_PCR_SELECT_Unmarshal(TPMS_TAGGED_PCR_SELECT * target,BYTE ** buffer,INT32 * size)5866 TPM_RC TPMS_TAGGED_PCR_SELECT_Unmarshal(TPMS_TAGGED_PCR_SELECT* target,
5867 BYTE** buffer,
5868 INT32* size) {
5869 TPM_RC result;
5870 INT32 i;
5871 result = TPM_PT_Unmarshal(&target->tag, buffer, size);
5872 if (result != TPM_RC_SUCCESS) {
5873 return result;
5874 }
5875 result = UINT8_Unmarshal(&target->sizeofSelect, buffer, size);
5876 if (result != TPM_RC_SUCCESS) {
5877 return result;
5878 }
5879 if (target->sizeofSelect > PCR_SELECT_MAX) {
5880 return TPM_RC_VALUE;
5881 }
5882 if (target->sizeofSelect < PCR_SELECT_MIN) {
5883 return TPM_RC_VALUE;
5884 }
5885 for (i = 0; i < target->sizeofSelect; ++i) {
5886 result = BYTE_Unmarshal(&target->pcrSelect[i], buffer, size);
5887 if (result != TPM_RC_SUCCESS) {
5888 return result;
5889 }
5890 }
5891 return TPM_RC_SUCCESS;
5892 }
5893
TPML_TAGGED_PCR_PROPERTY_Marshal(TPML_TAGGED_PCR_PROPERTY * source,BYTE ** buffer,INT32 * size)5894 UINT16 TPML_TAGGED_PCR_PROPERTY_Marshal(TPML_TAGGED_PCR_PROPERTY* source,
5895 BYTE** buffer,
5896 INT32* size) {
5897 UINT16 total_size = 0;
5898 INT32 i;
5899 total_size += UINT32_Marshal(&source->count, buffer, size);
5900 for (i = 0; i < source->count; ++i) {
5901 total_size +=
5902 TPMS_TAGGED_PCR_SELECT_Marshal(&source->pcrProperty[i], buffer, size);
5903 }
5904 return total_size;
5905 }
5906
TPML_TAGGED_PCR_PROPERTY_Unmarshal(TPML_TAGGED_PCR_PROPERTY * target,BYTE ** buffer,INT32 * size)5907 TPM_RC TPML_TAGGED_PCR_PROPERTY_Unmarshal(TPML_TAGGED_PCR_PROPERTY* target,
5908 BYTE** buffer,
5909 INT32* size) {
5910 TPM_RC result;
5911 INT32 i;
5912 result = UINT32_Unmarshal(&target->count, buffer, size);
5913 if (result != TPM_RC_SUCCESS) {
5914 return result;
5915 }
5916 if (target->count > MAX_PCR_PROPERTIES) {
5917 return TPM_RC_SIZE;
5918 }
5919 for (i = 0; i < target->count; ++i) {
5920 result =
5921 TPMS_TAGGED_PCR_SELECT_Unmarshal(&target->pcrProperty[i], buffer, size);
5922 if (result != TPM_RC_SUCCESS) {
5923 return result;
5924 }
5925 }
5926 return TPM_RC_SUCCESS;
5927 }
5928
TPMS_TAGGED_PROPERTY_Marshal(TPMS_TAGGED_PROPERTY * source,BYTE ** buffer,INT32 * size)5929 UINT16 TPMS_TAGGED_PROPERTY_Marshal(TPMS_TAGGED_PROPERTY* source,
5930 BYTE** buffer,
5931 INT32* size) {
5932 UINT16 total_size = 0;
5933 total_size += TPM_PT_Marshal(&source->property, buffer, size);
5934 total_size += UINT32_Marshal(&source->value, buffer, size);
5935 return total_size;
5936 }
5937
TPMS_TAGGED_PROPERTY_Unmarshal(TPMS_TAGGED_PROPERTY * target,BYTE ** buffer,INT32 * size)5938 TPM_RC TPMS_TAGGED_PROPERTY_Unmarshal(TPMS_TAGGED_PROPERTY* target,
5939 BYTE** buffer,
5940 INT32* size) {
5941 TPM_RC result;
5942 result = TPM_PT_Unmarshal(&target->property, buffer, size);
5943 if (result != TPM_RC_SUCCESS) {
5944 return result;
5945 }
5946 result = UINT32_Unmarshal(&target->value, buffer, size);
5947 if (result != TPM_RC_SUCCESS) {
5948 return result;
5949 }
5950 return TPM_RC_SUCCESS;
5951 }
5952
TPML_TAGGED_TPM_PROPERTY_Marshal(TPML_TAGGED_TPM_PROPERTY * source,BYTE ** buffer,INT32 * size)5953 UINT16 TPML_TAGGED_TPM_PROPERTY_Marshal(TPML_TAGGED_TPM_PROPERTY* source,
5954 BYTE** buffer,
5955 INT32* size) {
5956 UINT16 total_size = 0;
5957 INT32 i;
5958 total_size += UINT32_Marshal(&source->count, buffer, size);
5959 for (i = 0; i < source->count; ++i) {
5960 total_size +=
5961 TPMS_TAGGED_PROPERTY_Marshal(&source->tpmProperty[i], buffer, size);
5962 }
5963 return total_size;
5964 }
5965
TPML_TAGGED_TPM_PROPERTY_Unmarshal(TPML_TAGGED_TPM_PROPERTY * target,BYTE ** buffer,INT32 * size)5966 TPM_RC TPML_TAGGED_TPM_PROPERTY_Unmarshal(TPML_TAGGED_TPM_PROPERTY* target,
5967 BYTE** buffer,
5968 INT32* size) {
5969 TPM_RC result;
5970 INT32 i;
5971 result = UINT32_Unmarshal(&target->count, buffer, size);
5972 if (result != TPM_RC_SUCCESS) {
5973 return result;
5974 }
5975 if (target->count > MAX_TPM_PROPERTIES) {
5976 return TPM_RC_SIZE;
5977 }
5978 for (i = 0; i < target->count; ++i) {
5979 result =
5980 TPMS_TAGGED_PROPERTY_Unmarshal(&target->tpmProperty[i], buffer, size);
5981 if (result != TPM_RC_SUCCESS) {
5982 return result;
5983 }
5984 }
5985 return TPM_RC_SUCCESS;
5986 }
5987
TPMS_ALGORITHM_DESCRIPTION_Marshal(TPMS_ALGORITHM_DESCRIPTION * source,BYTE ** buffer,INT32 * size)5988 UINT16 TPMS_ALGORITHM_DESCRIPTION_Marshal(TPMS_ALGORITHM_DESCRIPTION* source,
5989 BYTE** buffer,
5990 INT32* size) {
5991 UINT16 total_size = 0;
5992 total_size += TPM_ALG_ID_Marshal(&source->alg, buffer, size);
5993 total_size += TPMA_ALGORITHM_Marshal(&source->attributes, buffer, size);
5994 return total_size;
5995 }
5996
TPMS_ALGORITHM_DESCRIPTION_Unmarshal(TPMS_ALGORITHM_DESCRIPTION * target,BYTE ** buffer,INT32 * size)5997 TPM_RC TPMS_ALGORITHM_DESCRIPTION_Unmarshal(TPMS_ALGORITHM_DESCRIPTION* target,
5998 BYTE** buffer,
5999 INT32* size) {
6000 TPM_RC result;
6001 result = TPM_ALG_ID_Unmarshal(&target->alg, buffer, size);
6002 if (result != TPM_RC_SUCCESS) {
6003 return result;
6004 }
6005 result = TPMA_ALGORITHM_Unmarshal(&target->attributes, buffer, size);
6006 if (result != TPM_RC_SUCCESS) {
6007 return result;
6008 }
6009 return TPM_RC_SUCCESS;
6010 }
6011
TPMS_ALGORITHM_DETAIL_ECC_Marshal(TPMS_ALGORITHM_DETAIL_ECC * source,BYTE ** buffer,INT32 * size)6012 UINT16 TPMS_ALGORITHM_DETAIL_ECC_Marshal(TPMS_ALGORITHM_DETAIL_ECC* source,
6013 BYTE** buffer,
6014 INT32* size) {
6015 UINT16 total_size = 0;
6016 total_size += TPM_ECC_CURVE_Marshal(&source->curveID, buffer, size);
6017 total_size += UINT16_Marshal(&source->keySize, buffer, size);
6018 total_size += TPMT_KDF_SCHEME_Marshal(&source->kdf, buffer, size);
6019 total_size += TPMT_ECC_SCHEME_Marshal(&source->sign, buffer, size);
6020 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->p, buffer, size);
6021 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->a, buffer, size);
6022 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->b, buffer, size);
6023 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->gX, buffer, size);
6024 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->gY, buffer, size);
6025 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->n, buffer, size);
6026 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->h, buffer, size);
6027 return total_size;
6028 }
6029
TPMS_ALGORITHM_DETAIL_ECC_Unmarshal(TPMS_ALGORITHM_DETAIL_ECC * target,BYTE ** buffer,INT32 * size)6030 TPM_RC TPMS_ALGORITHM_DETAIL_ECC_Unmarshal(TPMS_ALGORITHM_DETAIL_ECC* target,
6031 BYTE** buffer,
6032 INT32* size) {
6033 TPM_RC result;
6034 result = TPM_ECC_CURVE_Unmarshal(&target->curveID, buffer, size);
6035 if (result != TPM_RC_SUCCESS) {
6036 return result;
6037 }
6038 result = UINT16_Unmarshal(&target->keySize, buffer, size);
6039 if (result != TPM_RC_SUCCESS) {
6040 return result;
6041 }
6042 result = TPMT_KDF_SCHEME_Unmarshal(&target->kdf, buffer, size);
6043 if (result != TPM_RC_SUCCESS) {
6044 return result;
6045 }
6046 result = TPMT_ECC_SCHEME_Unmarshal(&target->sign, buffer, size);
6047 if (result != TPM_RC_SUCCESS) {
6048 return result;
6049 }
6050 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->p, buffer, size);
6051 if (result != TPM_RC_SUCCESS) {
6052 return result;
6053 }
6054 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->a, buffer, size);
6055 if (result != TPM_RC_SUCCESS) {
6056 return result;
6057 }
6058 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->b, buffer, size);
6059 if (result != TPM_RC_SUCCESS) {
6060 return result;
6061 }
6062 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->gX, buffer, size);
6063 if (result != TPM_RC_SUCCESS) {
6064 return result;
6065 }
6066 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->gY, buffer, size);
6067 if (result != TPM_RC_SUCCESS) {
6068 return result;
6069 }
6070 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->n, buffer, size);
6071 if (result != TPM_RC_SUCCESS) {
6072 return result;
6073 }
6074 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->h, buffer, size);
6075 if (result != TPM_RC_SUCCESS) {
6076 return result;
6077 }
6078 return TPM_RC_SUCCESS;
6079 }
6080
UINT64_Marshal(UINT64 * source,BYTE ** buffer,INT32 * size)6081 UINT16 UINT64_Marshal(UINT64* source, BYTE** buffer, INT32* size) {
6082 return uint64_t_Marshal(source, buffer, size);
6083 }
6084
UINT64_Unmarshal(UINT64 * target,BYTE ** buffer,INT32 * size)6085 TPM_RC UINT64_Unmarshal(UINT64* target, BYTE** buffer, INT32* size) {
6086 return uint64_t_Unmarshal(target, buffer, size);
6087 }
6088
TPM_GENERATED_Marshal(TPM_GENERATED * source,BYTE ** buffer,INT32 * size)6089 UINT16 TPM_GENERATED_Marshal(TPM_GENERATED* source,
6090 BYTE** buffer,
6091 INT32* size) {
6092 return uint32_t_Marshal(source, buffer, size);
6093 }
6094
TPM_GENERATED_Unmarshal(TPM_GENERATED * target,BYTE ** buffer,INT32 * size)6095 TPM_RC TPM_GENERATED_Unmarshal(TPM_GENERATED* target,
6096 BYTE** buffer,
6097 INT32* size) {
6098 TPM_RC result;
6099 result = uint32_t_Unmarshal(target, buffer, size);
6100 if (result != TPM_RC_SUCCESS) {
6101 return result;
6102 }
6103 if (*target == TPM_GENERATED_VALUE) {
6104 return TPM_RC_SUCCESS;
6105 }
6106 return TPM_RC_VALUE;
6107 }
6108
TPMS_CREATION_INFO_Marshal(TPMS_CREATION_INFO * source,BYTE ** buffer,INT32 * size)6109 UINT16 TPMS_CREATION_INFO_Marshal(TPMS_CREATION_INFO* source,
6110 BYTE** buffer,
6111 INT32* size) {
6112 UINT16 total_size = 0;
6113 total_size += TPM2B_NAME_Marshal(&source->objectName, buffer, size);
6114 total_size += TPM2B_DIGEST_Marshal(&source->creationHash, buffer, size);
6115 return total_size;
6116 }
6117
TPMS_CREATION_INFO_Unmarshal(TPMS_CREATION_INFO * target,BYTE ** buffer,INT32 * size)6118 TPM_RC TPMS_CREATION_INFO_Unmarshal(TPMS_CREATION_INFO* target,
6119 BYTE** buffer,
6120 INT32* size) {
6121 TPM_RC result;
6122 result = TPM2B_NAME_Unmarshal(&target->objectName, buffer, size);
6123 if (result != TPM_RC_SUCCESS) {
6124 return result;
6125 }
6126 result = TPM2B_DIGEST_Unmarshal(&target->creationHash, buffer, size);
6127 if (result != TPM_RC_SUCCESS) {
6128 return result;
6129 }
6130 return TPM_RC_SUCCESS;
6131 }
6132
TPMS_COMMAND_AUDIT_INFO_Marshal(TPMS_COMMAND_AUDIT_INFO * source,BYTE ** buffer,INT32 * size)6133 UINT16 TPMS_COMMAND_AUDIT_INFO_Marshal(TPMS_COMMAND_AUDIT_INFO* source,
6134 BYTE** buffer,
6135 INT32* size) {
6136 UINT16 total_size = 0;
6137 total_size += UINT64_Marshal(&source->auditCounter, buffer, size);
6138 total_size += TPM_ALG_ID_Marshal(&source->digestAlg, buffer, size);
6139 total_size += TPM2B_DIGEST_Marshal(&source->auditDigest, buffer, size);
6140 total_size += TPM2B_DIGEST_Marshal(&source->commandDigest, buffer, size);
6141 return total_size;
6142 }
6143
TPMS_COMMAND_AUDIT_INFO_Unmarshal(TPMS_COMMAND_AUDIT_INFO * target,BYTE ** buffer,INT32 * size)6144 TPM_RC TPMS_COMMAND_AUDIT_INFO_Unmarshal(TPMS_COMMAND_AUDIT_INFO* target,
6145 BYTE** buffer,
6146 INT32* size) {
6147 TPM_RC result;
6148 result = UINT64_Unmarshal(&target->auditCounter, buffer, size);
6149 if (result != TPM_RC_SUCCESS) {
6150 return result;
6151 }
6152 result = TPM_ALG_ID_Unmarshal(&target->digestAlg, buffer, size);
6153 if (result != TPM_RC_SUCCESS) {
6154 return result;
6155 }
6156 result = TPM2B_DIGEST_Unmarshal(&target->auditDigest, buffer, size);
6157 if (result != TPM_RC_SUCCESS) {
6158 return result;
6159 }
6160 result = TPM2B_DIGEST_Unmarshal(&target->commandDigest, buffer, size);
6161 if (result != TPM_RC_SUCCESS) {
6162 return result;
6163 }
6164 return TPM_RC_SUCCESS;
6165 }
6166
TPMS_QUOTE_INFO_Marshal(TPMS_QUOTE_INFO * source,BYTE ** buffer,INT32 * size)6167 UINT16 TPMS_QUOTE_INFO_Marshal(TPMS_QUOTE_INFO* source,
6168 BYTE** buffer,
6169 INT32* size) {
6170 UINT16 total_size = 0;
6171 total_size += TPML_PCR_SELECTION_Marshal(&source->pcrSelect, buffer, size);
6172 total_size += TPM2B_DIGEST_Marshal(&source->pcrDigest, buffer, size);
6173 return total_size;
6174 }
6175
TPMS_QUOTE_INFO_Unmarshal(TPMS_QUOTE_INFO * target,BYTE ** buffer,INT32 * size)6176 TPM_RC TPMS_QUOTE_INFO_Unmarshal(TPMS_QUOTE_INFO* target,
6177 BYTE** buffer,
6178 INT32* size) {
6179 TPM_RC result;
6180 result = TPML_PCR_SELECTION_Unmarshal(&target->pcrSelect, buffer, size);
6181 if (result != TPM_RC_SUCCESS) {
6182 return result;
6183 }
6184 result = TPM2B_DIGEST_Unmarshal(&target->pcrDigest, buffer, size);
6185 if (result != TPM_RC_SUCCESS) {
6186 return result;
6187 }
6188 return TPM_RC_SUCCESS;
6189 }
6190
TPMS_CERTIFY_INFO_Marshal(TPMS_CERTIFY_INFO * source,BYTE ** buffer,INT32 * size)6191 UINT16 TPMS_CERTIFY_INFO_Marshal(TPMS_CERTIFY_INFO* source,
6192 BYTE** buffer,
6193 INT32* size) {
6194 UINT16 total_size = 0;
6195 total_size += TPM2B_NAME_Marshal(&source->name, buffer, size);
6196 total_size += TPM2B_NAME_Marshal(&source->qualifiedName, buffer, size);
6197 return total_size;
6198 }
6199
TPMS_CERTIFY_INFO_Unmarshal(TPMS_CERTIFY_INFO * target,BYTE ** buffer,INT32 * size)6200 TPM_RC TPMS_CERTIFY_INFO_Unmarshal(TPMS_CERTIFY_INFO* target,
6201 BYTE** buffer,
6202 INT32* size) {
6203 TPM_RC result;
6204 result = TPM2B_NAME_Unmarshal(&target->name, buffer, size);
6205 if (result != TPM_RC_SUCCESS) {
6206 return result;
6207 }
6208 result = TPM2B_NAME_Unmarshal(&target->qualifiedName, buffer, size);
6209 if (result != TPM_RC_SUCCESS) {
6210 return result;
6211 }
6212 return TPM_RC_SUCCESS;
6213 }
6214
TPMS_SESSION_AUDIT_INFO_Marshal(TPMS_SESSION_AUDIT_INFO * source,BYTE ** buffer,INT32 * size)6215 UINT16 TPMS_SESSION_AUDIT_INFO_Marshal(TPMS_SESSION_AUDIT_INFO* source,
6216 BYTE** buffer,
6217 INT32* size) {
6218 UINT16 total_size = 0;
6219 total_size += TPMI_YES_NO_Marshal(&source->exclusiveSession, buffer, size);
6220 total_size += TPM2B_DIGEST_Marshal(&source->sessionDigest, buffer, size);
6221 return total_size;
6222 }
6223
TPMS_SESSION_AUDIT_INFO_Unmarshal(TPMS_SESSION_AUDIT_INFO * target,BYTE ** buffer,INT32 * size)6224 TPM_RC TPMS_SESSION_AUDIT_INFO_Unmarshal(TPMS_SESSION_AUDIT_INFO* target,
6225 BYTE** buffer,
6226 INT32* size) {
6227 TPM_RC result;
6228 result = TPMI_YES_NO_Unmarshal(&target->exclusiveSession, buffer, size);
6229 if (result != TPM_RC_SUCCESS) {
6230 return result;
6231 }
6232 result = TPM2B_DIGEST_Unmarshal(&target->sessionDigest, buffer, size);
6233 if (result != TPM_RC_SUCCESS) {
6234 return result;
6235 }
6236 return TPM_RC_SUCCESS;
6237 }
6238
TPMS_CLOCK_INFO_Marshal(TPMS_CLOCK_INFO * source,BYTE ** buffer,INT32 * size)6239 UINT16 TPMS_CLOCK_INFO_Marshal(TPMS_CLOCK_INFO* source,
6240 BYTE** buffer,
6241 INT32* size) {
6242 UINT16 total_size = 0;
6243 total_size += UINT64_Marshal(&source->clock, buffer, size);
6244 total_size += UINT32_Marshal(&source->resetCount, buffer, size);
6245 total_size += UINT32_Marshal(&source->restartCount, buffer, size);
6246 total_size += TPMI_YES_NO_Marshal(&source->safe, buffer, size);
6247 return total_size;
6248 }
6249
TPMS_CLOCK_INFO_Unmarshal(TPMS_CLOCK_INFO * target,BYTE ** buffer,INT32 * size)6250 TPM_RC TPMS_CLOCK_INFO_Unmarshal(TPMS_CLOCK_INFO* target,
6251 BYTE** buffer,
6252 INT32* size) {
6253 TPM_RC result;
6254 result = UINT64_Unmarshal(&target->clock, buffer, size);
6255 if (result != TPM_RC_SUCCESS) {
6256 return result;
6257 }
6258 result = UINT32_Unmarshal(&target->resetCount, buffer, size);
6259 if (result != TPM_RC_SUCCESS) {
6260 return result;
6261 }
6262 result = UINT32_Unmarshal(&target->restartCount, buffer, size);
6263 if (result != TPM_RC_SUCCESS) {
6264 return result;
6265 }
6266 result = TPMI_YES_NO_Unmarshal(&target->safe, buffer, size);
6267 if (result != TPM_RC_SUCCESS) {
6268 return result;
6269 }
6270 return TPM_RC_SUCCESS;
6271 }
6272
TPMS_TIME_INFO_Marshal(TPMS_TIME_INFO * source,BYTE ** buffer,INT32 * size)6273 UINT16 TPMS_TIME_INFO_Marshal(TPMS_TIME_INFO* source,
6274 BYTE** buffer,
6275 INT32* size) {
6276 UINT16 total_size = 0;
6277 total_size += UINT64_Marshal(&source->time, buffer, size);
6278 total_size += TPMS_CLOCK_INFO_Marshal(&source->clockInfo, buffer, size);
6279 return total_size;
6280 }
6281
TPMS_TIME_INFO_Unmarshal(TPMS_TIME_INFO * target,BYTE ** buffer,INT32 * size)6282 TPM_RC TPMS_TIME_INFO_Unmarshal(TPMS_TIME_INFO* target,
6283 BYTE** buffer,
6284 INT32* size) {
6285 TPM_RC result;
6286 result = UINT64_Unmarshal(&target->time, buffer, size);
6287 if (result != TPM_RC_SUCCESS) {
6288 return result;
6289 }
6290 result = TPMS_CLOCK_INFO_Unmarshal(&target->clockInfo, buffer, size);
6291 if (result != TPM_RC_SUCCESS) {
6292 return result;
6293 }
6294 return TPM_RC_SUCCESS;
6295 }
6296
TPMS_TIME_ATTEST_INFO_Marshal(TPMS_TIME_ATTEST_INFO * source,BYTE ** buffer,INT32 * size)6297 UINT16 TPMS_TIME_ATTEST_INFO_Marshal(TPMS_TIME_ATTEST_INFO* source,
6298 BYTE** buffer,
6299 INT32* size) {
6300 UINT16 total_size = 0;
6301 total_size += TPMS_TIME_INFO_Marshal(&source->time, buffer, size);
6302 total_size += UINT64_Marshal(&source->firmwareVersion, buffer, size);
6303 return total_size;
6304 }
6305
TPMS_TIME_ATTEST_INFO_Unmarshal(TPMS_TIME_ATTEST_INFO * target,BYTE ** buffer,INT32 * size)6306 TPM_RC TPMS_TIME_ATTEST_INFO_Unmarshal(TPMS_TIME_ATTEST_INFO* target,
6307 BYTE** buffer,
6308 INT32* size) {
6309 TPM_RC result;
6310 result = TPMS_TIME_INFO_Unmarshal(&target->time, buffer, size);
6311 if (result != TPM_RC_SUCCESS) {
6312 return result;
6313 }
6314 result = UINT64_Unmarshal(&target->firmwareVersion, buffer, size);
6315 if (result != TPM_RC_SUCCESS) {
6316 return result;
6317 }
6318 return TPM_RC_SUCCESS;
6319 }
6320
TPMS_NV_CERTIFY_INFO_Marshal(TPMS_NV_CERTIFY_INFO * source,BYTE ** buffer,INT32 * size)6321 UINT16 TPMS_NV_CERTIFY_INFO_Marshal(TPMS_NV_CERTIFY_INFO* source,
6322 BYTE** buffer,
6323 INT32* size) {
6324 UINT16 total_size = 0;
6325 total_size += TPM2B_NAME_Marshal(&source->indexName, buffer, size);
6326 total_size += UINT16_Marshal(&source->offset, buffer, size);
6327 total_size += TPM2B_MAX_NV_BUFFER_Marshal(&source->nvContents, buffer, size);
6328 return total_size;
6329 }
6330
TPMS_NV_CERTIFY_INFO_Unmarshal(TPMS_NV_CERTIFY_INFO * target,BYTE ** buffer,INT32 * size)6331 TPM_RC TPMS_NV_CERTIFY_INFO_Unmarshal(TPMS_NV_CERTIFY_INFO* target,
6332 BYTE** buffer,
6333 INT32* size) {
6334 TPM_RC result;
6335 result = TPM2B_NAME_Unmarshal(&target->indexName, buffer, size);
6336 if (result != TPM_RC_SUCCESS) {
6337 return result;
6338 }
6339 result = UINT16_Unmarshal(&target->offset, buffer, size);
6340 if (result != TPM_RC_SUCCESS) {
6341 return result;
6342 }
6343 result = TPM2B_MAX_NV_BUFFER_Unmarshal(&target->nvContents, buffer, size);
6344 if (result != TPM_RC_SUCCESS) {
6345 return result;
6346 }
6347 return TPM_RC_SUCCESS;
6348 }
6349
TPMU_ATTEST_Marshal(TPMU_ATTEST * source,BYTE ** buffer,INT32 * size,UINT32 selector)6350 UINT16 TPMU_ATTEST_Marshal(TPMU_ATTEST* source,
6351 BYTE** buffer,
6352 INT32* size,
6353 UINT32 selector) {
6354 switch (selector) {
6355 case TPM_ST_ATTEST_CERTIFY:
6356 return TPMS_CERTIFY_INFO_Marshal((TPMS_CERTIFY_INFO*)&source->certify,
6357 buffer, size);
6358 case TPM_ST_ATTEST_CREATION:
6359 return TPMS_CREATION_INFO_Marshal((TPMS_CREATION_INFO*)&source->creation,
6360 buffer, size);
6361 case TPM_ST_ATTEST_QUOTE:
6362 return TPMS_QUOTE_INFO_Marshal((TPMS_QUOTE_INFO*)&source->quote, buffer,
6363 size);
6364 case TPM_ST_ATTEST_COMMAND_AUDIT:
6365 return TPMS_COMMAND_AUDIT_INFO_Marshal(
6366 (TPMS_COMMAND_AUDIT_INFO*)&source->commandAudit, buffer, size);
6367 case TPM_ST_ATTEST_SESSION_AUDIT:
6368 return TPMS_SESSION_AUDIT_INFO_Marshal(
6369 (TPMS_SESSION_AUDIT_INFO*)&source->sessionAudit, buffer, size);
6370 case TPM_ST_ATTEST_TIME:
6371 return TPMS_TIME_ATTEST_INFO_Marshal(
6372 (TPMS_TIME_ATTEST_INFO*)&source->time, buffer, size);
6373 case TPM_ST_ATTEST_NV:
6374 return TPMS_NV_CERTIFY_INFO_Marshal((TPMS_NV_CERTIFY_INFO*)&source->nv,
6375 buffer, size);
6376 }
6377 return 0;
6378 }
6379
TPMU_ATTEST_Unmarshal(TPMU_ATTEST * target,BYTE ** buffer,INT32 * size,UINT32 selector)6380 TPM_RC TPMU_ATTEST_Unmarshal(TPMU_ATTEST* target,
6381 BYTE** buffer,
6382 INT32* size,
6383 UINT32 selector) {
6384 switch (selector) {
6385 case TPM_ST_ATTEST_CERTIFY:
6386 return TPMS_CERTIFY_INFO_Unmarshal((TPMS_CERTIFY_INFO*)&target->certify,
6387 buffer, size);
6388 case TPM_ST_ATTEST_CREATION:
6389 return TPMS_CREATION_INFO_Unmarshal(
6390 (TPMS_CREATION_INFO*)&target->creation, buffer, size);
6391 case TPM_ST_ATTEST_QUOTE:
6392 return TPMS_QUOTE_INFO_Unmarshal((TPMS_QUOTE_INFO*)&target->quote, buffer,
6393 size);
6394 case TPM_ST_ATTEST_COMMAND_AUDIT:
6395 return TPMS_COMMAND_AUDIT_INFO_Unmarshal(
6396 (TPMS_COMMAND_AUDIT_INFO*)&target->commandAudit, buffer, size);
6397 case TPM_ST_ATTEST_SESSION_AUDIT:
6398 return TPMS_SESSION_AUDIT_INFO_Unmarshal(
6399 (TPMS_SESSION_AUDIT_INFO*)&target->sessionAudit, buffer, size);
6400 case TPM_ST_ATTEST_TIME:
6401 return TPMS_TIME_ATTEST_INFO_Unmarshal(
6402 (TPMS_TIME_ATTEST_INFO*)&target->time, buffer, size);
6403 case TPM_ST_ATTEST_NV:
6404 return TPMS_NV_CERTIFY_INFO_Unmarshal((TPMS_NV_CERTIFY_INFO*)&target->nv,
6405 buffer, size);
6406 }
6407 return TPM_RC_SELECTOR;
6408 }
6409
TPMS_ATTEST_Marshal(TPMS_ATTEST * source,BYTE ** buffer,INT32 * size)6410 UINT16 TPMS_ATTEST_Marshal(TPMS_ATTEST* source, BYTE** buffer, INT32* size) {
6411 UINT16 total_size = 0;
6412 total_size += TPM_GENERATED_Marshal(&source->magic, buffer, size);
6413 total_size += TPMI_ST_ATTEST_Marshal(&source->type, buffer, size);
6414 total_size += TPM2B_NAME_Marshal(&source->qualifiedSigner, buffer, size);
6415 total_size += TPM2B_DATA_Marshal(&source->extraData, buffer, size);
6416 total_size += TPMS_CLOCK_INFO_Marshal(&source->clockInfo, buffer, size);
6417 total_size += UINT64_Marshal(&source->firmwareVersion, buffer, size);
6418 total_size +=
6419 TPMU_ATTEST_Marshal(&source->attested, buffer, size, source->type);
6420 return total_size;
6421 }
6422
TPMS_ATTEST_Unmarshal(TPMS_ATTEST * target,BYTE ** buffer,INT32 * size)6423 TPM_RC TPMS_ATTEST_Unmarshal(TPMS_ATTEST* target, BYTE** buffer, INT32* size) {
6424 TPM_RC result;
6425 result = TPM_GENERATED_Unmarshal(&target->magic, buffer, size);
6426 if (result != TPM_RC_SUCCESS) {
6427 return result;
6428 }
6429 result = TPMI_ST_ATTEST_Unmarshal(&target->type, buffer, size);
6430 if (result != TPM_RC_SUCCESS) {
6431 return result;
6432 }
6433 result = TPM2B_NAME_Unmarshal(&target->qualifiedSigner, buffer, size);
6434 if (result != TPM_RC_SUCCESS) {
6435 return result;
6436 }
6437 result = TPM2B_DATA_Unmarshal(&target->extraData, buffer, size);
6438 if (result != TPM_RC_SUCCESS) {
6439 return result;
6440 }
6441 result = TPMS_CLOCK_INFO_Unmarshal(&target->clockInfo, buffer, size);
6442 if (result != TPM_RC_SUCCESS) {
6443 return result;
6444 }
6445 result = UINT64_Unmarshal(&target->firmwareVersion, buffer, size);
6446 if (result != TPM_RC_SUCCESS) {
6447 return result;
6448 }
6449 result = TPMU_ATTEST_Unmarshal(&target->attested, buffer, size, target->type);
6450 if (result != TPM_RC_SUCCESS) {
6451 return result;
6452 }
6453 return TPM_RC_SUCCESS;
6454 }
6455
TPMS_AUTH_COMMAND_Marshal(TPMS_AUTH_COMMAND * source,BYTE ** buffer,INT32 * size)6456 UINT16 TPMS_AUTH_COMMAND_Marshal(TPMS_AUTH_COMMAND* source,
6457 BYTE** buffer,
6458 INT32* size) {
6459 UINT16 total_size = 0;
6460 total_size +=
6461 TPMI_SH_AUTH_SESSION_Marshal(&source->sessionHandle, buffer, size);
6462 total_size += TPM2B_NONCE_Marshal(&source->nonce, buffer, size);
6463 total_size += TPMA_SESSION_Marshal(&source->sessionAttributes, buffer, size);
6464 total_size += TPM2B_AUTH_Marshal(&source->hmac, buffer, size);
6465 return total_size;
6466 }
6467
TPMS_AUTH_COMMAND_Unmarshal(TPMS_AUTH_COMMAND * target,BYTE ** buffer,INT32 * size)6468 TPM_RC TPMS_AUTH_COMMAND_Unmarshal(TPMS_AUTH_COMMAND* target,
6469 BYTE** buffer,
6470 INT32* size) {
6471 TPM_RC result;
6472 result = TPMI_SH_AUTH_SESSION_Unmarshal(&target->sessionHandle, buffer, size,
6473 TRUE);
6474 if (result != TPM_RC_SUCCESS) {
6475 return result;
6476 }
6477 result = TPM2B_NONCE_Unmarshal(&target->nonce, buffer, size);
6478 if (result != TPM_RC_SUCCESS) {
6479 return result;
6480 }
6481 result = TPMA_SESSION_Unmarshal(&target->sessionAttributes, buffer, size);
6482 if (result != TPM_RC_SUCCESS) {
6483 return result;
6484 }
6485 result = TPM2B_AUTH_Unmarshal(&target->hmac, buffer, size);
6486 if (result != TPM_RC_SUCCESS) {
6487 return result;
6488 }
6489 return TPM_RC_SUCCESS;
6490 }
6491
TPMS_AUTH_RESPONSE_Marshal(TPMS_AUTH_RESPONSE * source,BYTE ** buffer,INT32 * size)6492 UINT16 TPMS_AUTH_RESPONSE_Marshal(TPMS_AUTH_RESPONSE* source,
6493 BYTE** buffer,
6494 INT32* size) {
6495 UINT16 total_size = 0;
6496 total_size += TPM2B_NONCE_Marshal(&source->nonce, buffer, size);
6497 total_size += TPMA_SESSION_Marshal(&source->sessionAttributes, buffer, size);
6498 total_size += TPM2B_AUTH_Marshal(&source->hmac, buffer, size);
6499 return total_size;
6500 }
6501
TPMS_AUTH_RESPONSE_Unmarshal(TPMS_AUTH_RESPONSE * target,BYTE ** buffer,INT32 * size)6502 TPM_RC TPMS_AUTH_RESPONSE_Unmarshal(TPMS_AUTH_RESPONSE* target,
6503 BYTE** buffer,
6504 INT32* size) {
6505 TPM_RC result;
6506 result = TPM2B_NONCE_Unmarshal(&target->nonce, buffer, size);
6507 if (result != TPM_RC_SUCCESS) {
6508 return result;
6509 }
6510 result = TPMA_SESSION_Unmarshal(&target->sessionAttributes, buffer, size);
6511 if (result != TPM_RC_SUCCESS) {
6512 return result;
6513 }
6514 result = TPM2B_AUTH_Unmarshal(&target->hmac, buffer, size);
6515 if (result != TPM_RC_SUCCESS) {
6516 return result;
6517 }
6518 return TPM_RC_SUCCESS;
6519 }
6520
TPM_CAP_Marshal(TPM_CAP * source,BYTE ** buffer,INT32 * size)6521 UINT16 TPM_CAP_Marshal(TPM_CAP* source, BYTE** buffer, INT32* size) {
6522 return uint32_t_Marshal(source, buffer, size);
6523 }
6524
TPM_CAP_Unmarshal(TPM_CAP * target,BYTE ** buffer,INT32 * size)6525 TPM_RC TPM_CAP_Unmarshal(TPM_CAP* target, BYTE** buffer, INT32* size) {
6526 TPM_RC result;
6527 result = uint32_t_Unmarshal(target, buffer, size);
6528 if (result != TPM_RC_SUCCESS) {
6529 return result;
6530 }
6531 if (*target == TPM_CAP_FIRST) {
6532 return TPM_RC_SUCCESS;
6533 }
6534 if (*target == TPM_CAP_ALGS) {
6535 return TPM_RC_SUCCESS;
6536 }
6537 if (*target == TPM_CAP_HANDLES) {
6538 return TPM_RC_SUCCESS;
6539 }
6540 if (*target == TPM_CAP_COMMANDS) {
6541 return TPM_RC_SUCCESS;
6542 }
6543 if (*target == TPM_CAP_PP_COMMANDS) {
6544 return TPM_RC_SUCCESS;
6545 }
6546 if (*target == TPM_CAP_AUDIT_COMMANDS) {
6547 return TPM_RC_SUCCESS;
6548 }
6549 if (*target == TPM_CAP_PCRS) {
6550 return TPM_RC_SUCCESS;
6551 }
6552 if (*target == TPM_CAP_TPM_PROPERTIES) {
6553 return TPM_RC_SUCCESS;
6554 }
6555 if (*target == TPM_CAP_PCR_PROPERTIES) {
6556 return TPM_RC_SUCCESS;
6557 }
6558 if (*target == TPM_CAP_ECC_CURVES) {
6559 return TPM_RC_SUCCESS;
6560 }
6561 if (*target == TPM_CAP_LAST) {
6562 return TPM_RC_SUCCESS;
6563 }
6564 if (*target == TPM_CAP_VENDOR_PROPERTY) {
6565 return TPM_RC_SUCCESS;
6566 }
6567 return TPM_RC_VALUE;
6568 }
6569
TPMU_CAPABILITIES_Marshal(TPMU_CAPABILITIES * source,BYTE ** buffer,INT32 * size,UINT32 selector)6570 UINT16 TPMU_CAPABILITIES_Marshal(TPMU_CAPABILITIES* source,
6571 BYTE** buffer,
6572 INT32* size,
6573 UINT32 selector) {
6574 switch (selector) {
6575 case TPM_CAP_ALGS:
6576 return TPML_ALG_PROPERTY_Marshal((TPML_ALG_PROPERTY*)&source->algorithms,
6577 buffer, size);
6578 case TPM_CAP_HANDLES:
6579 return TPML_HANDLE_Marshal((TPML_HANDLE*)&source->handles, buffer, size);
6580 case TPM_CAP_COMMANDS:
6581 return TPML_CCA_Marshal((TPML_CCA*)&source->command, buffer, size);
6582 case TPM_CAP_PP_COMMANDS:
6583 return TPML_CC_Marshal((TPML_CC*)&source->ppCommands, buffer, size);
6584 case TPM_CAP_AUDIT_COMMANDS:
6585 return TPML_CC_Marshal((TPML_CC*)&source->auditCommands, buffer, size);
6586 case TPM_CAP_PCRS:
6587 return TPML_PCR_SELECTION_Marshal(
6588 (TPML_PCR_SELECTION*)&source->assignedPCR, buffer, size);
6589 case TPM_CAP_TPM_PROPERTIES:
6590 return TPML_TAGGED_TPM_PROPERTY_Marshal(
6591 (TPML_TAGGED_TPM_PROPERTY*)&source->tpmProperties, buffer, size);
6592 case TPM_CAP_PCR_PROPERTIES:
6593 return TPML_TAGGED_PCR_PROPERTY_Marshal(
6594 (TPML_TAGGED_PCR_PROPERTY*)&source->pcrProperties, buffer, size);
6595 case TPM_CAP_ECC_CURVES:
6596 return TPML_ECC_CURVE_Marshal((TPML_ECC_CURVE*)&source->eccCurves, buffer,
6597 size);
6598 }
6599 return 0;
6600 }
6601
TPMU_CAPABILITIES_Unmarshal(TPMU_CAPABILITIES * target,BYTE ** buffer,INT32 * size,UINT32 selector)6602 TPM_RC TPMU_CAPABILITIES_Unmarshal(TPMU_CAPABILITIES* target,
6603 BYTE** buffer,
6604 INT32* size,
6605 UINT32 selector) {
6606 switch (selector) {
6607 case TPM_CAP_ALGS:
6608 return TPML_ALG_PROPERTY_Unmarshal(
6609 (TPML_ALG_PROPERTY*)&target->algorithms, buffer, size);
6610 case TPM_CAP_HANDLES:
6611 return TPML_HANDLE_Unmarshal((TPML_HANDLE*)&target->handles, buffer,
6612 size);
6613 case TPM_CAP_COMMANDS:
6614 return TPML_CCA_Unmarshal((TPML_CCA*)&target->command, buffer, size);
6615 case TPM_CAP_PP_COMMANDS:
6616 return TPML_CC_Unmarshal((TPML_CC*)&target->ppCommands, buffer, size);
6617 case TPM_CAP_AUDIT_COMMANDS:
6618 return TPML_CC_Unmarshal((TPML_CC*)&target->auditCommands, buffer, size);
6619 case TPM_CAP_PCRS:
6620 return TPML_PCR_SELECTION_Unmarshal(
6621 (TPML_PCR_SELECTION*)&target->assignedPCR, buffer, size);
6622 case TPM_CAP_TPM_PROPERTIES:
6623 return TPML_TAGGED_TPM_PROPERTY_Unmarshal(
6624 (TPML_TAGGED_TPM_PROPERTY*)&target->tpmProperties, buffer, size);
6625 case TPM_CAP_PCR_PROPERTIES:
6626 return TPML_TAGGED_PCR_PROPERTY_Unmarshal(
6627 (TPML_TAGGED_PCR_PROPERTY*)&target->pcrProperties, buffer, size);
6628 case TPM_CAP_ECC_CURVES:
6629 return TPML_ECC_CURVE_Unmarshal((TPML_ECC_CURVE*)&target->eccCurves,
6630 buffer, size);
6631 }
6632 return TPM_RC_SELECTOR;
6633 }
6634
TPMS_CAPABILITY_DATA_Marshal(TPMS_CAPABILITY_DATA * source,BYTE ** buffer,INT32 * size)6635 UINT16 TPMS_CAPABILITY_DATA_Marshal(TPMS_CAPABILITY_DATA* source,
6636 BYTE** buffer,
6637 INT32* size) {
6638 UINT16 total_size = 0;
6639 total_size += TPM_CAP_Marshal(&source->capability, buffer, size);
6640 total_size += TPMU_CAPABILITIES_Marshal(&source->data, buffer, size,
6641 source->capability);
6642 return total_size;
6643 }
6644
TPMS_CAPABILITY_DATA_Unmarshal(TPMS_CAPABILITY_DATA * target,BYTE ** buffer,INT32 * size)6645 TPM_RC TPMS_CAPABILITY_DATA_Unmarshal(TPMS_CAPABILITY_DATA* target,
6646 BYTE** buffer,
6647 INT32* size) {
6648 TPM_RC result;
6649 result = TPM_CAP_Unmarshal(&target->capability, buffer, size);
6650 if (result != TPM_RC_SUCCESS) {
6651 return result;
6652 }
6653 result = TPMU_CAPABILITIES_Unmarshal(&target->data, buffer, size,
6654 target->capability);
6655 if (result != TPM_RC_SUCCESS) {
6656 return result;
6657 }
6658 return TPM_RC_SUCCESS;
6659 }
6660
TPMS_CONTEXT_Marshal(TPMS_CONTEXT * source,BYTE ** buffer,INT32 * size)6661 UINT16 TPMS_CONTEXT_Marshal(TPMS_CONTEXT* source, BYTE** buffer, INT32* size) {
6662 UINT16 total_size = 0;
6663 total_size += UINT64_Marshal(&source->sequence, buffer, size);
6664 total_size += TPMI_DH_CONTEXT_Marshal(&source->savedHandle, buffer, size);
6665 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
6666 total_size += TPM2B_CONTEXT_DATA_Marshal(&source->contextBlob, buffer, size);
6667 return total_size;
6668 }
6669
TPMS_CONTEXT_Unmarshal(TPMS_CONTEXT * target,BYTE ** buffer,INT32 * size)6670 TPM_RC TPMS_CONTEXT_Unmarshal(TPMS_CONTEXT* target,
6671 BYTE** buffer,
6672 INT32* size) {
6673 TPM_RC result;
6674 result = UINT64_Unmarshal(&target->sequence, buffer, size);
6675 if (result != TPM_RC_SUCCESS) {
6676 return result;
6677 }
6678 result = TPMI_DH_CONTEXT_Unmarshal(&target->savedHandle, buffer, size);
6679 if (result != TPM_RC_SUCCESS) {
6680 return result;
6681 }
6682 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
6683 if (result != TPM_RC_SUCCESS) {
6684 return result;
6685 }
6686 result = TPM2B_CONTEXT_DATA_Unmarshal(&target->contextBlob, buffer, size);
6687 if (result != TPM_RC_SUCCESS) {
6688 return result;
6689 }
6690 return TPM_RC_SUCCESS;
6691 }
6692
TPMS_CONTEXT_DATA_Marshal(TPMS_CONTEXT_DATA * source,BYTE ** buffer,INT32 * size)6693 UINT16 TPMS_CONTEXT_DATA_Marshal(TPMS_CONTEXT_DATA* source,
6694 BYTE** buffer,
6695 INT32* size) {
6696 UINT16 total_size = 0;
6697 total_size += TPM2B_DIGEST_Marshal(&source->integrity, buffer, size);
6698 total_size +=
6699 TPM2B_CONTEXT_SENSITIVE_Marshal(&source->encrypted, buffer, size);
6700 return total_size;
6701 }
6702
TPMS_CONTEXT_DATA_Unmarshal(TPMS_CONTEXT_DATA * target,BYTE ** buffer,INT32 * size)6703 TPM_RC TPMS_CONTEXT_DATA_Unmarshal(TPMS_CONTEXT_DATA* target,
6704 BYTE** buffer,
6705 INT32* size) {
6706 TPM_RC result;
6707 result = TPM2B_DIGEST_Unmarshal(&target->integrity, buffer, size);
6708 if (result != TPM_RC_SUCCESS) {
6709 return result;
6710 }
6711 result = TPM2B_CONTEXT_SENSITIVE_Unmarshal(&target->encrypted, buffer, size);
6712 if (result != TPM_RC_SUCCESS) {
6713 return result;
6714 }
6715 return TPM_RC_SUCCESS;
6716 }
6717
TPMS_PCR_SELECT_Marshal(TPMS_PCR_SELECT * source,BYTE ** buffer,INT32 * size)6718 UINT16 TPMS_PCR_SELECT_Marshal(TPMS_PCR_SELECT* source,
6719 BYTE** buffer,
6720 INT32* size) {
6721 UINT16 total_size = 0;
6722 INT32 i;
6723 total_size += UINT8_Marshal(&source->sizeofSelect, buffer, size);
6724 for (i = 0; i < source->sizeofSelect; ++i) {
6725 total_size += BYTE_Marshal(&source->pcrSelect[i], buffer, size);
6726 }
6727 return total_size;
6728 }
6729
TPMS_PCR_SELECT_Unmarshal(TPMS_PCR_SELECT * target,BYTE ** buffer,INT32 * size)6730 TPM_RC TPMS_PCR_SELECT_Unmarshal(TPMS_PCR_SELECT* target,
6731 BYTE** buffer,
6732 INT32* size) {
6733 TPM_RC result;
6734 INT32 i;
6735 result = UINT8_Unmarshal(&target->sizeofSelect, buffer, size);
6736 if (result != TPM_RC_SUCCESS) {
6737 return result;
6738 }
6739 if (target->sizeofSelect > PCR_SELECT_MAX) {
6740 return TPM_RC_VALUE;
6741 }
6742 if (target->sizeofSelect < PCR_SELECT_MIN) {
6743 return TPM_RC_VALUE;
6744 }
6745 for (i = 0; i < target->sizeofSelect; ++i) {
6746 result = BYTE_Unmarshal(&target->pcrSelect[i], buffer, size);
6747 if (result != TPM_RC_SUCCESS) {
6748 return result;
6749 }
6750 }
6751 return TPM_RC_SUCCESS;
6752 }
6753
TPMS_SIGNATURE_ECC_Marshal(TPMS_SIGNATURE_ECC * source,BYTE ** buffer,INT32 * size)6754 UINT16 TPMS_SIGNATURE_ECC_Marshal(TPMS_SIGNATURE_ECC* source,
6755 BYTE** buffer,
6756 INT32* size) {
6757 UINT16 total_size = 0;
6758 total_size += TPMI_ALG_HASH_Marshal(&source->hash, buffer, size);
6759 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->signatureR, buffer, size);
6760 total_size += TPM2B_ECC_PARAMETER_Marshal(&source->signatureS, buffer, size);
6761 return total_size;
6762 }
6763
TPMS_SIGNATURE_ECC_Unmarshal(TPMS_SIGNATURE_ECC * target,BYTE ** buffer,INT32 * size)6764 TPM_RC TPMS_SIGNATURE_ECC_Unmarshal(TPMS_SIGNATURE_ECC* target,
6765 BYTE** buffer,
6766 INT32* size) {
6767 TPM_RC result;
6768 result = TPMI_ALG_HASH_Unmarshal(&target->hash, buffer, size, FALSE);
6769 if (result != TPM_RC_SUCCESS) {
6770 return result;
6771 }
6772 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->signatureR, buffer, size);
6773 if (result != TPM_RC_SUCCESS) {
6774 return result;
6775 }
6776 result = TPM2B_ECC_PARAMETER_Unmarshal(&target->signatureS, buffer, size);
6777 if (result != TPM_RC_SUCCESS) {
6778 return result;
6779 }
6780 return TPM_RC_SUCCESS;
6781 }
6782
TPMS_SIGNATURE_ECDAA_Marshal(TPMS_SIGNATURE_ECDAA * source,BYTE ** buffer,INT32 * size)6783 UINT16 TPMS_SIGNATURE_ECDAA_Marshal(TPMS_SIGNATURE_ECDAA* source,
6784 BYTE** buffer,
6785 INT32* size) {
6786 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6787 }
6788
TPMS_SIGNATURE_ECDAA_Unmarshal(TPMS_SIGNATURE_ECDAA * target,BYTE ** buffer,INT32 * size)6789 TPM_RC TPMS_SIGNATURE_ECDAA_Unmarshal(TPMS_SIGNATURE_ECDAA* target,
6790 BYTE** buffer,
6791 INT32* size) {
6792 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6793 }
6794
TPMS_SIGNATURE_ECDSA_Marshal(TPMS_SIGNATURE_ECDSA * source,BYTE ** buffer,INT32 * size)6795 UINT16 TPMS_SIGNATURE_ECDSA_Marshal(TPMS_SIGNATURE_ECDSA* source,
6796 BYTE** buffer,
6797 INT32* size) {
6798 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6799 }
6800
TPMS_SIGNATURE_ECDSA_Unmarshal(TPMS_SIGNATURE_ECDSA * target,BYTE ** buffer,INT32 * size)6801 TPM_RC TPMS_SIGNATURE_ECDSA_Unmarshal(TPMS_SIGNATURE_ECDSA* target,
6802 BYTE** buffer,
6803 INT32* size) {
6804 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6805 }
6806
TPMS_SIGNATURE_ECSCHNORR_Marshal(TPMS_SIGNATURE_ECSCHNORR * source,BYTE ** buffer,INT32 * size)6807 UINT16 TPMS_SIGNATURE_ECSCHNORR_Marshal(TPMS_SIGNATURE_ECSCHNORR* source,
6808 BYTE** buffer,
6809 INT32* size) {
6810 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6811 }
6812
TPMS_SIGNATURE_ECSCHNORR_Unmarshal(TPMS_SIGNATURE_ECSCHNORR * target,BYTE ** buffer,INT32 * size)6813 TPM_RC TPMS_SIGNATURE_ECSCHNORR_Unmarshal(TPMS_SIGNATURE_ECSCHNORR* target,
6814 BYTE** buffer,
6815 INT32* size) {
6816 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6817 }
6818
TPMS_SIGNATURE_RSA_Marshal(TPMS_SIGNATURE_RSA * source,BYTE ** buffer,INT32 * size)6819 UINT16 TPMS_SIGNATURE_RSA_Marshal(TPMS_SIGNATURE_RSA* source,
6820 BYTE** buffer,
6821 INT32* size) {
6822 UINT16 total_size = 0;
6823 total_size += TPMI_ALG_HASH_Marshal(&source->hash, buffer, size);
6824 total_size += TPM2B_PUBLIC_KEY_RSA_Marshal(&source->sig, buffer, size);
6825 return total_size;
6826 }
6827
TPMS_SIGNATURE_RSA_Unmarshal(TPMS_SIGNATURE_RSA * target,BYTE ** buffer,INT32 * size)6828 TPM_RC TPMS_SIGNATURE_RSA_Unmarshal(TPMS_SIGNATURE_RSA* target,
6829 BYTE** buffer,
6830 INT32* size) {
6831 TPM_RC result;
6832 result = TPMI_ALG_HASH_Unmarshal(&target->hash, buffer, size, FALSE);
6833 if (result != TPM_RC_SUCCESS) {
6834 return result;
6835 }
6836 result = TPM2B_PUBLIC_KEY_RSA_Unmarshal(&target->sig, buffer, size);
6837 if (result != TPM_RC_SUCCESS) {
6838 return result;
6839 }
6840 return TPM_RC_SUCCESS;
6841 }
6842
TPMS_SIGNATURE_RSAPSS_Marshal(TPMS_SIGNATURE_RSAPSS * source,BYTE ** buffer,INT32 * size)6843 UINT16 TPMS_SIGNATURE_RSAPSS_Marshal(TPMS_SIGNATURE_RSAPSS* source,
6844 BYTE** buffer,
6845 INT32* size) {
6846 return TPMS_SIGNATURE_RSA_Marshal(source, buffer, size);
6847 }
6848
TPMS_SIGNATURE_RSAPSS_Unmarshal(TPMS_SIGNATURE_RSAPSS * target,BYTE ** buffer,INT32 * size)6849 TPM_RC TPMS_SIGNATURE_RSAPSS_Unmarshal(TPMS_SIGNATURE_RSAPSS* target,
6850 BYTE** buffer,
6851 INT32* size) {
6852 return TPMS_SIGNATURE_RSA_Unmarshal(target, buffer, size);
6853 }
6854
TPMS_SIGNATURE_RSASSA_Marshal(TPMS_SIGNATURE_RSASSA * source,BYTE ** buffer,INT32 * size)6855 UINT16 TPMS_SIGNATURE_RSASSA_Marshal(TPMS_SIGNATURE_RSASSA* source,
6856 BYTE** buffer,
6857 INT32* size) {
6858 return TPMS_SIGNATURE_RSA_Marshal(source, buffer, size);
6859 }
6860
TPMS_SIGNATURE_RSASSA_Unmarshal(TPMS_SIGNATURE_RSASSA * target,BYTE ** buffer,INT32 * size)6861 TPM_RC TPMS_SIGNATURE_RSASSA_Unmarshal(TPMS_SIGNATURE_RSASSA* target,
6862 BYTE** buffer,
6863 INT32* size) {
6864 return TPMS_SIGNATURE_RSA_Unmarshal(target, buffer, size);
6865 }
6866
TPMS_SIGNATURE_SM2_Marshal(TPMS_SIGNATURE_SM2 * source,BYTE ** buffer,INT32 * size)6867 UINT16 TPMS_SIGNATURE_SM2_Marshal(TPMS_SIGNATURE_SM2* source,
6868 BYTE** buffer,
6869 INT32* size) {
6870 return TPMS_SIGNATURE_ECC_Marshal(source, buffer, size);
6871 }
6872
TPMS_SIGNATURE_SM2_Unmarshal(TPMS_SIGNATURE_SM2 * target,BYTE ** buffer,INT32 * size)6873 TPM_RC TPMS_SIGNATURE_SM2_Unmarshal(TPMS_SIGNATURE_SM2* target,
6874 BYTE** buffer,
6875 INT32* size) {
6876 return TPMS_SIGNATURE_ECC_Unmarshal(target, buffer, size);
6877 }
6878
TPMT_PUBLIC_PARMS_Marshal(TPMT_PUBLIC_PARMS * source,BYTE ** buffer,INT32 * size)6879 UINT16 TPMT_PUBLIC_PARMS_Marshal(TPMT_PUBLIC_PARMS* source,
6880 BYTE** buffer,
6881 INT32* size) {
6882 UINT16 total_size = 0;
6883 total_size += TPMI_ALG_PUBLIC_Marshal(&source->type, buffer, size);
6884 total_size += TPMU_PUBLIC_PARMS_Marshal(&source->parameters, buffer, size,
6885 source->type);
6886 return total_size;
6887 }
6888
TPMT_PUBLIC_PARMS_Unmarshal(TPMT_PUBLIC_PARMS * target,BYTE ** buffer,INT32 * size)6889 TPM_RC TPMT_PUBLIC_PARMS_Unmarshal(TPMT_PUBLIC_PARMS* target,
6890 BYTE** buffer,
6891 INT32* size) {
6892 TPM_RC result;
6893 result = TPMI_ALG_PUBLIC_Unmarshal(&target->type, buffer, size);
6894 if (result != TPM_RC_SUCCESS) {
6895 return result;
6896 }
6897 result = TPMU_PUBLIC_PARMS_Unmarshal(&target->parameters, buffer, size,
6898 target->type);
6899 if (result != TPM_RC_SUCCESS) {
6900 return result;
6901 }
6902 return TPM_RC_SUCCESS;
6903 }
6904
TPMT_RSA_DECRYPT_Marshal(TPMT_RSA_DECRYPT * source,BYTE ** buffer,INT32 * size)6905 UINT16 TPMT_RSA_DECRYPT_Marshal(TPMT_RSA_DECRYPT* source,
6906 BYTE** buffer,
6907 INT32* size) {
6908 UINT16 total_size = 0;
6909 total_size += TPMI_ALG_RSA_DECRYPT_Marshal(&source->scheme, buffer, size);
6910 total_size +=
6911 TPMU_ASYM_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
6912 return total_size;
6913 }
6914
TPMT_RSA_DECRYPT_Unmarshal(TPMT_RSA_DECRYPT * target,BYTE ** buffer,INT32 * size)6915 TPM_RC TPMT_RSA_DECRYPT_Unmarshal(TPMT_RSA_DECRYPT* target,
6916 BYTE** buffer,
6917 INT32* size) {
6918 TPM_RC result;
6919 result = TPMI_ALG_RSA_DECRYPT_Unmarshal(&target->scheme, buffer, size, TRUE);
6920 if (result != TPM_RC_SUCCESS) {
6921 return result;
6922 }
6923 result = TPMU_ASYM_SCHEME_Unmarshal(&target->details, buffer, size,
6924 target->scheme);
6925 if (result != TPM_RC_SUCCESS) {
6926 return result;
6927 }
6928 return TPM_RC_SUCCESS;
6929 }
6930
TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE * source,BYTE ** buffer,INT32 * size,UINT32 selector)6931 UINT16 TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE* source,
6932 BYTE** buffer,
6933 INT32* size,
6934 UINT32 selector) {
6935 switch (selector) {
6936 #ifdef TPM_ALG_RSASSA
6937 case TPM_ALG_RSASSA:
6938 return TPMS_SIGNATURE_RSASSA_Marshal(
6939 (TPMS_SIGNATURE_RSASSA*)&source->rsassa, buffer, size);
6940 #endif
6941 #ifdef TPM_ALG_RSAPSS
6942 case TPM_ALG_RSAPSS:
6943 return TPMS_SIGNATURE_RSAPSS_Marshal(
6944 (TPMS_SIGNATURE_RSAPSS*)&source->rsapss, buffer, size);
6945 #endif
6946 #ifdef TPM_ALG_ECDSA
6947 case TPM_ALG_ECDSA:
6948 return TPMS_SIGNATURE_ECDSA_Marshal((TPMS_SIGNATURE_ECDSA*)&source->ecdsa,
6949 buffer, size);
6950 #endif
6951 #ifdef TPM_ALG_ECDAA
6952 case TPM_ALG_ECDAA:
6953 return TPMS_SIGNATURE_ECDAA_Marshal((TPMS_SIGNATURE_ECDAA*)&source->ecdaa,
6954 buffer, size);
6955 #endif
6956 #ifdef TPM_ALG_SM2
6957 case TPM_ALG_SM2:
6958 return TPMS_SIGNATURE_SM2_Marshal((TPMS_SIGNATURE_SM2*)&source->sm2,
6959 buffer, size);
6960 #endif
6961 #ifdef TPM_ALG_ECSCHNORR
6962 case TPM_ALG_ECSCHNORR:
6963 return TPMS_SIGNATURE_ECSCHNORR_Marshal(
6964 (TPMS_SIGNATURE_ECSCHNORR*)&source->ecschnorr, buffer, size);
6965 #endif
6966 #ifdef TPM_ALG_HMAC
6967 case TPM_ALG_HMAC:
6968 return TPMT_HA_Marshal((TPMT_HA*)&source->hmac, buffer, size);
6969 #endif
6970 #ifdef TPM_ALG_NULL
6971 case TPM_ALG_NULL:
6972 return 0;
6973 #endif
6974 }
6975 return 0;
6976 }
6977
TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE * target,BYTE ** buffer,INT32 * size,UINT32 selector)6978 TPM_RC TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE* target,
6979 BYTE** buffer,
6980 INT32* size,
6981 UINT32 selector) {
6982 switch (selector) {
6983 #ifdef TPM_ALG_RSASSA
6984 case TPM_ALG_RSASSA:
6985 return TPMS_SIGNATURE_RSASSA_Unmarshal(
6986 (TPMS_SIGNATURE_RSASSA*)&target->rsassa, buffer, size);
6987 #endif
6988 #ifdef TPM_ALG_RSAPSS
6989 case TPM_ALG_RSAPSS:
6990 return TPMS_SIGNATURE_RSAPSS_Unmarshal(
6991 (TPMS_SIGNATURE_RSAPSS*)&target->rsapss, buffer, size);
6992 #endif
6993 #ifdef TPM_ALG_ECDSA
6994 case TPM_ALG_ECDSA:
6995 return TPMS_SIGNATURE_ECDSA_Unmarshal(
6996 (TPMS_SIGNATURE_ECDSA*)&target->ecdsa, buffer, size);
6997 #endif
6998 #ifdef TPM_ALG_ECDAA
6999 case TPM_ALG_ECDAA:
7000 return TPMS_SIGNATURE_ECDAA_Unmarshal(
7001 (TPMS_SIGNATURE_ECDAA*)&target->ecdaa, buffer, size);
7002 #endif
7003 #ifdef TPM_ALG_SM2
7004 case TPM_ALG_SM2:
7005 return TPMS_SIGNATURE_SM2_Unmarshal((TPMS_SIGNATURE_SM2*)&target->sm2,
7006 buffer, size);
7007 #endif
7008 #ifdef TPM_ALG_ECSCHNORR
7009 case TPM_ALG_ECSCHNORR:
7010 return TPMS_SIGNATURE_ECSCHNORR_Unmarshal(
7011 (TPMS_SIGNATURE_ECSCHNORR*)&target->ecschnorr, buffer, size);
7012 #endif
7013 #ifdef TPM_ALG_HMAC
7014 case TPM_ALG_HMAC:
7015 return TPMT_HA_Unmarshal((TPMT_HA*)&target->hmac, buffer, size);
7016 #endif
7017 #ifdef TPM_ALG_NULL
7018 case TPM_ALG_NULL:
7019 return TPM_RC_SUCCESS;
7020 #endif
7021 }
7022 return TPM_RC_SELECTOR;
7023 }
7024
TPMT_SIGNATURE_Marshal(TPMT_SIGNATURE * source,BYTE ** buffer,INT32 * size)7025 UINT16 TPMT_SIGNATURE_Marshal(TPMT_SIGNATURE* source,
7026 BYTE** buffer,
7027 INT32* size) {
7028 UINT16 total_size = 0;
7029 total_size += TPMI_ALG_SIG_SCHEME_Marshal(&source->sigAlg, buffer, size);
7030 total_size +=
7031 TPMU_SIGNATURE_Marshal(&source->signature, buffer, size, source->sigAlg);
7032 return total_size;
7033 }
7034
TPMT_SIGNATURE_Unmarshal(TPMT_SIGNATURE * target,BYTE ** buffer,INT32 * size)7035 TPM_RC TPMT_SIGNATURE_Unmarshal(TPMT_SIGNATURE* target,
7036 BYTE** buffer,
7037 INT32* size) {
7038 TPM_RC result;
7039 result = TPMI_ALG_SIG_SCHEME_Unmarshal(&target->sigAlg, buffer, size, TRUE);
7040 if (result != TPM_RC_SUCCESS) {
7041 return result;
7042 }
7043 result = TPMU_SIGNATURE_Unmarshal(&target->signature, buffer, size,
7044 target->sigAlg);
7045 if (result != TPM_RC_SUCCESS) {
7046 return result;
7047 }
7048 return TPM_RC_SUCCESS;
7049 }
7050
TPMU_SIG_SCHEME_Marshal(TPMU_SIG_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)7051 UINT16 TPMU_SIG_SCHEME_Marshal(TPMU_SIG_SCHEME* source,
7052 BYTE** buffer,
7053 INT32* size,
7054 UINT32 selector) {
7055 switch (selector) {
7056 #ifdef TPM_ALG_RSASSA
7057 case TPM_ALG_RSASSA:
7058 return TPMS_SIG_SCHEME_RSASSA_Marshal(
7059 (TPMS_SIG_SCHEME_RSASSA*)&source->rsassa, buffer, size);
7060 #endif
7061 #ifdef TPM_ALG_RSAPSS
7062 case TPM_ALG_RSAPSS:
7063 return TPMS_SIG_SCHEME_RSAPSS_Marshal(
7064 (TPMS_SIG_SCHEME_RSAPSS*)&source->rsapss, buffer, size);
7065 #endif
7066 #ifdef TPM_ALG_ECDSA
7067 case TPM_ALG_ECDSA:
7068 return TPMS_SIG_SCHEME_ECDSA_Marshal(
7069 (TPMS_SIG_SCHEME_ECDSA*)&source->ecdsa, buffer, size);
7070 #endif
7071 #ifdef TPM_ALG_ECDAA
7072 case TPM_ALG_ECDAA:
7073 return TPMS_SIG_SCHEME_ECDAA_Marshal(
7074 (TPMS_SIG_SCHEME_ECDAA*)&source->ecdaa, buffer, size);
7075 #endif
7076 #ifdef TPM_ALG_SM2
7077 case TPM_ALG_SM2:
7078 return TPMS_SIG_SCHEME_SM2_Marshal((TPMS_SIG_SCHEME_SM2*)&source->sm2,
7079 buffer, size);
7080 #endif
7081 #ifdef TPM_ALG_ECSCHNORR
7082 case TPM_ALG_ECSCHNORR:
7083 return TPMS_SIG_SCHEME_ECSCHNORR_Marshal(
7084 (TPMS_SIG_SCHEME_ECSCHNORR*)&source->ecschnorr, buffer, size);
7085 #endif
7086 #ifdef TPM_ALG_HMAC
7087 case TPM_ALG_HMAC:
7088 return TPMS_SCHEME_HMAC_Marshal((TPMS_SCHEME_HMAC*)&source->hmac, buffer,
7089 size);
7090 #endif
7091 #ifdef TPM_ALG_NULL
7092 case TPM_ALG_NULL:
7093 return 0;
7094 #endif
7095 }
7096 return 0;
7097 }
7098
TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)7099 TPM_RC TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME* target,
7100 BYTE** buffer,
7101 INT32* size,
7102 UINT32 selector) {
7103 switch (selector) {
7104 #ifdef TPM_ALG_RSASSA
7105 case TPM_ALG_RSASSA:
7106 return TPMS_SIG_SCHEME_RSASSA_Unmarshal(
7107 (TPMS_SIG_SCHEME_RSASSA*)&target->rsassa, buffer, size);
7108 #endif
7109 #ifdef TPM_ALG_RSAPSS
7110 case TPM_ALG_RSAPSS:
7111 return TPMS_SIG_SCHEME_RSAPSS_Unmarshal(
7112 (TPMS_SIG_SCHEME_RSAPSS*)&target->rsapss, buffer, size);
7113 #endif
7114 #ifdef TPM_ALG_ECDSA
7115 case TPM_ALG_ECDSA:
7116 return TPMS_SIG_SCHEME_ECDSA_Unmarshal(
7117 (TPMS_SIG_SCHEME_ECDSA*)&target->ecdsa, buffer, size);
7118 #endif
7119 #ifdef TPM_ALG_ECDAA
7120 case TPM_ALG_ECDAA:
7121 return TPMS_SIG_SCHEME_ECDAA_Unmarshal(
7122 (TPMS_SIG_SCHEME_ECDAA*)&target->ecdaa, buffer, size);
7123 #endif
7124 #ifdef TPM_ALG_SM2
7125 case TPM_ALG_SM2:
7126 return TPMS_SIG_SCHEME_SM2_Unmarshal((TPMS_SIG_SCHEME_SM2*)&target->sm2,
7127 buffer, size);
7128 #endif
7129 #ifdef TPM_ALG_ECSCHNORR
7130 case TPM_ALG_ECSCHNORR:
7131 return TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(
7132 (TPMS_SIG_SCHEME_ECSCHNORR*)&target->ecschnorr, buffer, size);
7133 #endif
7134 #ifdef TPM_ALG_HMAC
7135 case TPM_ALG_HMAC:
7136 return TPMS_SCHEME_HMAC_Unmarshal((TPMS_SCHEME_HMAC*)&target->hmac,
7137 buffer, size);
7138 #endif
7139 #ifdef TPM_ALG_NULL
7140 case TPM_ALG_NULL:
7141 return TPM_RC_SUCCESS;
7142 #endif
7143 }
7144 return TPM_RC_SELECTOR;
7145 }
7146
TPMT_SIG_SCHEME_Marshal(TPMT_SIG_SCHEME * source,BYTE ** buffer,INT32 * size)7147 UINT16 TPMT_SIG_SCHEME_Marshal(TPMT_SIG_SCHEME* source,
7148 BYTE** buffer,
7149 INT32* size) {
7150 UINT16 total_size = 0;
7151 total_size += TPMI_ALG_SIG_SCHEME_Marshal(&source->scheme, buffer, size);
7152 total_size +=
7153 TPMU_SIG_SCHEME_Marshal(&source->details, buffer, size, source->scheme);
7154 return total_size;
7155 }
7156
TPMT_SIG_SCHEME_Unmarshal(TPMT_SIG_SCHEME * target,BYTE ** buffer,INT32 * size)7157 TPM_RC TPMT_SIG_SCHEME_Unmarshal(TPMT_SIG_SCHEME* target,
7158 BYTE** buffer,
7159 INT32* size) {
7160 TPM_RC result;
7161 result = TPMI_ALG_SIG_SCHEME_Unmarshal(&target->scheme, buffer, size, TRUE);
7162 if (result != TPM_RC_SUCCESS) {
7163 return result;
7164 }
7165 result =
7166 TPMU_SIG_SCHEME_Unmarshal(&target->details, buffer, size, target->scheme);
7167 if (result != TPM_RC_SUCCESS) {
7168 return result;
7169 }
7170 return TPM_RC_SUCCESS;
7171 }
7172
TPMT_SYM_DEF_Marshal(TPMT_SYM_DEF * source,BYTE ** buffer,INT32 * size)7173 UINT16 TPMT_SYM_DEF_Marshal(TPMT_SYM_DEF* source, BYTE** buffer, INT32* size) {
7174 UINT16 total_size = 0;
7175 total_size += TPMI_ALG_SYM_Marshal(&source->algorithm, buffer, size);
7176 total_size += TPMU_SYM_KEY_BITS_Marshal(&source->keyBits, buffer, size,
7177 source->algorithm);
7178 total_size +=
7179 TPMU_SYM_MODE_Marshal(&source->mode, buffer, size, source->algorithm);
7180 return total_size;
7181 }
7182
TPMT_SYM_DEF_Unmarshal(TPMT_SYM_DEF * target,BYTE ** buffer,INT32 * size)7183 TPM_RC TPMT_SYM_DEF_Unmarshal(TPMT_SYM_DEF* target,
7184 BYTE** buffer,
7185 INT32* size) {
7186 TPM_RC result;
7187 result = TPMI_ALG_SYM_Unmarshal(&target->algorithm, buffer, size, TRUE);
7188 if (result != TPM_RC_SUCCESS) {
7189 return result;
7190 }
7191 result = TPMU_SYM_KEY_BITS_Unmarshal(&target->keyBits, buffer, size,
7192 target->algorithm);
7193 if (result != TPM_RC_SUCCESS) {
7194 return result;
7195 }
7196 result =
7197 TPMU_SYM_MODE_Unmarshal(&target->mode, buffer, size, target->algorithm);
7198 if (result != TPM_RC_SUCCESS) {
7199 return result;
7200 }
7201 return TPM_RC_SUCCESS;
7202 }
7203
TPM_ST_Marshal(TPM_ST * source,BYTE ** buffer,INT32 * size)7204 UINT16 TPM_ST_Marshal(TPM_ST* source, BYTE** buffer, INT32* size) {
7205 return uint16_t_Marshal(source, buffer, size);
7206 }
7207
TPM_ST_Unmarshal(TPM_ST * target,BYTE ** buffer,INT32 * size)7208 TPM_RC TPM_ST_Unmarshal(TPM_ST* target, BYTE** buffer, INT32* size) {
7209 TPM_RC result;
7210 result = uint16_t_Unmarshal(target, buffer, size);
7211 if (result != TPM_RC_SUCCESS) {
7212 return result;
7213 }
7214 if (*target == TPM_ST_RSP_COMMAND) {
7215 return TPM_RC_SUCCESS;
7216 }
7217 if (*target == TPM_ST_NULL) {
7218 return TPM_RC_SUCCESS;
7219 }
7220 if (*target == TPM_ST_NO_SESSIONS) {
7221 return TPM_RC_SUCCESS;
7222 }
7223 if (*target == TPM_ST_SESSIONS) {
7224 return TPM_RC_SUCCESS;
7225 }
7226 if (*target == TPM_ST_ATTEST_NV) {
7227 return TPM_RC_SUCCESS;
7228 }
7229 if (*target == TPM_ST_ATTEST_COMMAND_AUDIT) {
7230 return TPM_RC_SUCCESS;
7231 }
7232 if (*target == TPM_ST_ATTEST_SESSION_AUDIT) {
7233 return TPM_RC_SUCCESS;
7234 }
7235 if (*target == TPM_ST_ATTEST_CERTIFY) {
7236 return TPM_RC_SUCCESS;
7237 }
7238 if (*target == TPM_ST_ATTEST_QUOTE) {
7239 return TPM_RC_SUCCESS;
7240 }
7241 if (*target == TPM_ST_ATTEST_TIME) {
7242 return TPM_RC_SUCCESS;
7243 }
7244 if (*target == TPM_ST_ATTEST_CREATION) {
7245 return TPM_RC_SUCCESS;
7246 }
7247 if (*target == TPM_ST_CREATION) {
7248 return TPM_RC_SUCCESS;
7249 }
7250 if (*target == TPM_ST_VERIFIED) {
7251 return TPM_RC_SUCCESS;
7252 }
7253 if (*target == TPM_ST_AUTH_SECRET) {
7254 return TPM_RC_SUCCESS;
7255 }
7256 if (*target == TPM_ST_HASHCHECK) {
7257 return TPM_RC_SUCCESS;
7258 }
7259 if (*target == TPM_ST_AUTH_SIGNED) {
7260 return TPM_RC_SUCCESS;
7261 }
7262 if (*target == TPM_ST_FU_MANIFEST) {
7263 return TPM_RC_SUCCESS;
7264 }
7265 return TPM_RC_VALUE;
7266 }
7267
TPMT_TK_AUTH_Marshal(TPMT_TK_AUTH * source,BYTE ** buffer,INT32 * size)7268 UINT16 TPMT_TK_AUTH_Marshal(TPMT_TK_AUTH* source, BYTE** buffer, INT32* size) {
7269 UINT16 total_size = 0;
7270 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7271 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7272 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7273 return total_size;
7274 }
7275
TPMT_TK_AUTH_Unmarshal(TPMT_TK_AUTH * target,BYTE ** buffer,INT32 * size)7276 TPM_RC TPMT_TK_AUTH_Unmarshal(TPMT_TK_AUTH* target,
7277 BYTE** buffer,
7278 INT32* size) {
7279 TPM_RC result;
7280 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7281 if (result != TPM_RC_SUCCESS) {
7282 return result;
7283 }
7284 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7285 if (result != TPM_RC_SUCCESS) {
7286 return result;
7287 }
7288 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7289 if (result != TPM_RC_SUCCESS) {
7290 return result;
7291 }
7292 return TPM_RC_SUCCESS;
7293 }
7294
TPMT_TK_CREATION_Marshal(TPMT_TK_CREATION * source,BYTE ** buffer,INT32 * size)7295 UINT16 TPMT_TK_CREATION_Marshal(TPMT_TK_CREATION* source,
7296 BYTE** buffer,
7297 INT32* size) {
7298 UINT16 total_size = 0;
7299 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7300 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7301 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7302 return total_size;
7303 }
7304
TPMT_TK_CREATION_Unmarshal(TPMT_TK_CREATION * target,BYTE ** buffer,INT32 * size)7305 TPM_RC TPMT_TK_CREATION_Unmarshal(TPMT_TK_CREATION* target,
7306 BYTE** buffer,
7307 INT32* size) {
7308 TPM_RC result;
7309 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7310 if (result != TPM_RC_SUCCESS) {
7311 return result;
7312 }
7313 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7314 if (result != TPM_RC_SUCCESS) {
7315 return result;
7316 }
7317 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7318 if (result != TPM_RC_SUCCESS) {
7319 return result;
7320 }
7321 return TPM_RC_SUCCESS;
7322 }
7323
TPMT_TK_HASHCHECK_Marshal(TPMT_TK_HASHCHECK * source,BYTE ** buffer,INT32 * size)7324 UINT16 TPMT_TK_HASHCHECK_Marshal(TPMT_TK_HASHCHECK* source,
7325 BYTE** buffer,
7326 INT32* size) {
7327 UINT16 total_size = 0;
7328 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7329 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7330 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7331 return total_size;
7332 }
7333
TPMT_TK_HASHCHECK_Unmarshal(TPMT_TK_HASHCHECK * target,BYTE ** buffer,INT32 * size)7334 TPM_RC TPMT_TK_HASHCHECK_Unmarshal(TPMT_TK_HASHCHECK* target,
7335 BYTE** buffer,
7336 INT32* size) {
7337 TPM_RC result;
7338 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7339 if (result != TPM_RC_SUCCESS) {
7340 return result;
7341 }
7342 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7343 if (result != TPM_RC_SUCCESS) {
7344 return result;
7345 }
7346 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7347 if (result != TPM_RC_SUCCESS) {
7348 return result;
7349 }
7350 return TPM_RC_SUCCESS;
7351 }
7352
TPMT_TK_VERIFIED_Marshal(TPMT_TK_VERIFIED * source,BYTE ** buffer,INT32 * size)7353 UINT16 TPMT_TK_VERIFIED_Marshal(TPMT_TK_VERIFIED* source,
7354 BYTE** buffer,
7355 INT32* size) {
7356 UINT16 total_size = 0;
7357 total_size += TPM_ST_Marshal(&source->tag, buffer, size);
7358 total_size += TPMI_RH_HIERARCHY_Marshal(&source->hierarchy, buffer, size);
7359 total_size += TPM2B_DIGEST_Marshal(&source->digest, buffer, size);
7360 return total_size;
7361 }
7362
TPMT_TK_VERIFIED_Unmarshal(TPMT_TK_VERIFIED * target,BYTE ** buffer,INT32 * size)7363 TPM_RC TPMT_TK_VERIFIED_Unmarshal(TPMT_TK_VERIFIED* target,
7364 BYTE** buffer,
7365 INT32* size) {
7366 TPM_RC result;
7367 result = TPM_ST_Unmarshal(&target->tag, buffer, size);
7368 if (result != TPM_RC_SUCCESS) {
7369 return result;
7370 }
7371 result = TPMI_RH_HIERARCHY_Unmarshal(&target->hierarchy, buffer, size, TRUE);
7372 if (result != TPM_RC_SUCCESS) {
7373 return result;
7374 }
7375 result = TPM2B_DIGEST_Unmarshal(&target->digest, buffer, size);
7376 if (result != TPM_RC_SUCCESS) {
7377 return result;
7378 }
7379 return TPM_RC_SUCCESS;
7380 }
7381
TPMU_SYM_DETAILS_Marshal(TPMU_SYM_DETAILS * source,BYTE ** buffer,INT32 * size,UINT32 selector)7382 UINT16 TPMU_SYM_DETAILS_Marshal(TPMU_SYM_DETAILS* source,
7383 BYTE** buffer,
7384 INT32* size,
7385 UINT32 selector) {
7386 switch (selector) {
7387 #ifdef TPM_ALG_AES
7388 case TPM_ALG_AES:
7389 return 0;
7390 #endif
7391 #ifdef TPM_ALG_SM4
7392 case TPM_ALG_SM4:
7393 return 0;
7394 #endif
7395 #ifdef TPM_ALG_CAMELLIA
7396 case TPM_ALG_CAMELLIA:
7397 return 0;
7398 #endif
7399 #ifdef TPM_ALG_XOR
7400 case TPM_ALG_XOR:
7401 return 0;
7402 #endif
7403 #ifdef TPM_ALG_NULL
7404 case TPM_ALG_NULL:
7405 return 0;
7406 #endif
7407 }
7408 return 0;
7409 }
7410
TPMU_SYM_DETAILS_Unmarshal(TPMU_SYM_DETAILS * target,BYTE ** buffer,INT32 * size,UINT32 selector)7411 TPM_RC TPMU_SYM_DETAILS_Unmarshal(TPMU_SYM_DETAILS* target,
7412 BYTE** buffer,
7413 INT32* size,
7414 UINT32 selector) {
7415 switch (selector) {
7416 #ifdef TPM_ALG_AES
7417 case TPM_ALG_AES:
7418 return TPM_RC_SUCCESS;
7419 #endif
7420 #ifdef TPM_ALG_SM4
7421 case TPM_ALG_SM4:
7422 return TPM_RC_SUCCESS;
7423 #endif
7424 #ifdef TPM_ALG_CAMELLIA
7425 case TPM_ALG_CAMELLIA:
7426 return TPM_RC_SUCCESS;
7427 #endif
7428 #ifdef TPM_ALG_XOR
7429 case TPM_ALG_XOR:
7430 return TPM_RC_SUCCESS;
7431 #endif
7432 #ifdef TPM_ALG_NULL
7433 case TPM_ALG_NULL:
7434 return TPM_RC_SUCCESS;
7435 #endif
7436 }
7437 return TPM_RC_SELECTOR;
7438 }
7439
TPM_ALGORITHM_ID_Marshal(TPM_ALGORITHM_ID * source,BYTE ** buffer,INT32 * size)7440 UINT16 TPM_ALGORITHM_ID_Marshal(TPM_ALGORITHM_ID* source,
7441 BYTE** buffer,
7442 INT32* size) {
7443 return uint32_t_Marshal(source, buffer, size);
7444 }
7445
TPM_ALGORITHM_ID_Unmarshal(TPM_ALGORITHM_ID * target,BYTE ** buffer,INT32 * size)7446 TPM_RC TPM_ALGORITHM_ID_Unmarshal(TPM_ALGORITHM_ID* target,
7447 BYTE** buffer,
7448 INT32* size) {
7449 return uint32_t_Unmarshal(target, buffer, size);
7450 }
7451
TPM_AUTHORIZATION_SIZE_Marshal(TPM_AUTHORIZATION_SIZE * source,BYTE ** buffer,INT32 * size)7452 UINT16 TPM_AUTHORIZATION_SIZE_Marshal(TPM_AUTHORIZATION_SIZE* source,
7453 BYTE** buffer,
7454 INT32* size) {
7455 return uint32_t_Marshal(source, buffer, size);
7456 }
7457
TPM_AUTHORIZATION_SIZE_Unmarshal(TPM_AUTHORIZATION_SIZE * target,BYTE ** buffer,INT32 * size)7458 TPM_RC TPM_AUTHORIZATION_SIZE_Unmarshal(TPM_AUTHORIZATION_SIZE* target,
7459 BYTE** buffer,
7460 INT32* size) {
7461 return uint32_t_Unmarshal(target, buffer, size);
7462 }
7463
TPM_CLOCK_ADJUST_Marshal(TPM_CLOCK_ADJUST * source,BYTE ** buffer,INT32 * size)7464 UINT16 TPM_CLOCK_ADJUST_Marshal(TPM_CLOCK_ADJUST* source,
7465 BYTE** buffer,
7466 INT32* size) {
7467 return int8_t_Marshal(source, buffer, size);
7468 }
7469
TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST * target,BYTE ** buffer,INT32 * size)7470 TPM_RC TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST* target,
7471 BYTE** buffer,
7472 INT32* size) {
7473 TPM_RC result;
7474 result = int8_t_Unmarshal(target, buffer, size);
7475 if (result != TPM_RC_SUCCESS) {
7476 return result;
7477 }
7478 if (*target == TPM_CLOCK_COARSE_SLOWER) {
7479 return TPM_RC_SUCCESS;
7480 }
7481 if (*target == TPM_CLOCK_MEDIUM_SLOWER) {
7482 return TPM_RC_SUCCESS;
7483 }
7484 if (*target == TPM_CLOCK_FINE_SLOWER) {
7485 return TPM_RC_SUCCESS;
7486 }
7487 if (*target == TPM_CLOCK_NO_CHANGE) {
7488 return TPM_RC_SUCCESS;
7489 }
7490 if (*target == TPM_CLOCK_FINE_FASTER) {
7491 return TPM_RC_SUCCESS;
7492 }
7493 if (*target == TPM_CLOCK_MEDIUM_FASTER) {
7494 return TPM_RC_SUCCESS;
7495 }
7496 if (*target == TPM_CLOCK_COARSE_FASTER) {
7497 return TPM_RC_SUCCESS;
7498 }
7499 return TPM_RC_VALUE;
7500 }
7501
TPM_EO_Marshal(TPM_EO * source,BYTE ** buffer,INT32 * size)7502 UINT16 TPM_EO_Marshal(TPM_EO* source, BYTE** buffer, INT32* size) {
7503 return uint16_t_Marshal(source, buffer, size);
7504 }
7505
TPM_EO_Unmarshal(TPM_EO * target,BYTE ** buffer,INT32 * size)7506 TPM_RC TPM_EO_Unmarshal(TPM_EO* target, BYTE** buffer, INT32* size) {
7507 TPM_RC result;
7508 result = uint16_t_Unmarshal(target, buffer, size);
7509 if (result != TPM_RC_SUCCESS) {
7510 return result;
7511 }
7512 if (*target == TPM_EO_EQ) {
7513 return TPM_RC_SUCCESS;
7514 }
7515 if (*target == TPM_EO_NEQ) {
7516 return TPM_RC_SUCCESS;
7517 }
7518 if (*target == TPM_EO_SIGNED_GT) {
7519 return TPM_RC_SUCCESS;
7520 }
7521 if (*target == TPM_EO_UNSIGNED_GT) {
7522 return TPM_RC_SUCCESS;
7523 }
7524 if (*target == TPM_EO_SIGNED_LT) {
7525 return TPM_RC_SUCCESS;
7526 }
7527 if (*target == TPM_EO_UNSIGNED_LT) {
7528 return TPM_RC_SUCCESS;
7529 }
7530 if (*target == TPM_EO_SIGNED_GE) {
7531 return TPM_RC_SUCCESS;
7532 }
7533 if (*target == TPM_EO_UNSIGNED_GE) {
7534 return TPM_RC_SUCCESS;
7535 }
7536 if (*target == TPM_EO_SIGNED_LE) {
7537 return TPM_RC_SUCCESS;
7538 }
7539 if (*target == TPM_EO_UNSIGNED_LE) {
7540 return TPM_RC_SUCCESS;
7541 }
7542 if (*target == TPM_EO_BITSET) {
7543 return TPM_RC_SUCCESS;
7544 }
7545 if (*target == TPM_EO_BITCLEAR) {
7546 return TPM_RC_SUCCESS;
7547 }
7548 return TPM_RC_VALUE;
7549 }
7550
TPM_HC_Marshal(TPM_HC * source,BYTE ** buffer,INT32 * size)7551 UINT16 TPM_HC_Marshal(TPM_HC* source, BYTE** buffer, INT32* size) {
7552 return uint32_t_Marshal(source, buffer, size);
7553 }
7554
TPM_HC_Unmarshal(TPM_HC * target,BYTE ** buffer,INT32 * size)7555 TPM_RC TPM_HC_Unmarshal(TPM_HC* target, BYTE** buffer, INT32* size) {
7556 TPM_RC result;
7557 result = uint32_t_Unmarshal(target, buffer, size);
7558 if (result != TPM_RC_SUCCESS) {
7559 return result;
7560 }
7561 if (*target == HR_HANDLE_MASK) {
7562 return TPM_RC_SUCCESS;
7563 }
7564 if (*target == HR_RANGE_MASK) {
7565 return TPM_RC_SUCCESS;
7566 }
7567 if (*target == HR_SHIFT) {
7568 return TPM_RC_SUCCESS;
7569 }
7570 if (*target == HR_PCR) {
7571 return TPM_RC_SUCCESS;
7572 }
7573 if (*target == HR_HMAC_SESSION) {
7574 return TPM_RC_SUCCESS;
7575 }
7576 if (*target == HR_POLICY_SESSION) {
7577 return TPM_RC_SUCCESS;
7578 }
7579 if (*target == HR_TRANSIENT) {
7580 return TPM_RC_SUCCESS;
7581 }
7582 if (*target == HR_PERSISTENT) {
7583 return TPM_RC_SUCCESS;
7584 }
7585 if (*target == HR_NV_INDEX) {
7586 return TPM_RC_SUCCESS;
7587 }
7588 if (*target == HR_PERMANENT) {
7589 return TPM_RC_SUCCESS;
7590 }
7591 if (*target == PCR_FIRST) {
7592 return TPM_RC_SUCCESS;
7593 }
7594 if (*target == PCR_LAST) {
7595 return TPM_RC_SUCCESS;
7596 }
7597 if (*target == HMAC_SESSION_FIRST) {
7598 return TPM_RC_SUCCESS;
7599 }
7600 if (*target == HMAC_SESSION_LAST) {
7601 return TPM_RC_SUCCESS;
7602 }
7603 if (*target == LOADED_SESSION_FIRST) {
7604 return TPM_RC_SUCCESS;
7605 }
7606 if (*target == LOADED_SESSION_LAST) {
7607 return TPM_RC_SUCCESS;
7608 }
7609 if (*target == POLICY_SESSION_FIRST) {
7610 return TPM_RC_SUCCESS;
7611 }
7612 if (*target == POLICY_SESSION_LAST) {
7613 return TPM_RC_SUCCESS;
7614 }
7615 if (*target == TRANSIENT_FIRST) {
7616 return TPM_RC_SUCCESS;
7617 }
7618 if (*target == ACTIVE_SESSION_FIRST) {
7619 return TPM_RC_SUCCESS;
7620 }
7621 if (*target == ACTIVE_SESSION_LAST) {
7622 return TPM_RC_SUCCESS;
7623 }
7624 if (*target == TRANSIENT_LAST) {
7625 return TPM_RC_SUCCESS;
7626 }
7627 if (*target == PERSISTENT_FIRST) {
7628 return TPM_RC_SUCCESS;
7629 }
7630 if (*target == PERSISTENT_LAST) {
7631 return TPM_RC_SUCCESS;
7632 }
7633 if (*target == PLATFORM_PERSISTENT) {
7634 return TPM_RC_SUCCESS;
7635 }
7636 if (*target == NV_INDEX_FIRST) {
7637 return TPM_RC_SUCCESS;
7638 }
7639 if (*target == NV_INDEX_LAST) {
7640 return TPM_RC_SUCCESS;
7641 }
7642 if (*target == PERMANENT_FIRST) {
7643 return TPM_RC_SUCCESS;
7644 }
7645 if (*target == PERMANENT_LAST) {
7646 return TPM_RC_SUCCESS;
7647 }
7648 return TPM_RC_VALUE;
7649 }
7650
TPM_HT_Marshal(TPM_HT * source,BYTE ** buffer,INT32 * size)7651 UINT16 TPM_HT_Marshal(TPM_HT* source, BYTE** buffer, INT32* size) {
7652 return uint8_t_Marshal(source, buffer, size);
7653 }
7654
TPM_HT_Unmarshal(TPM_HT * target,BYTE ** buffer,INT32 * size)7655 TPM_RC TPM_HT_Unmarshal(TPM_HT* target, BYTE** buffer, INT32* size) {
7656 TPM_RC result;
7657 result = uint8_t_Unmarshal(target, buffer, size);
7658 if (result != TPM_RC_SUCCESS) {
7659 return result;
7660 }
7661 if (*target == TPM_HT_PCR) {
7662 return TPM_RC_SUCCESS;
7663 }
7664 if (*target == TPM_HT_NV_INDEX) {
7665 return TPM_RC_SUCCESS;
7666 }
7667 if (*target == TPM_HT_HMAC_SESSION) {
7668 return TPM_RC_SUCCESS;
7669 }
7670 if (*target == TPM_HT_LOADED_SESSION) {
7671 return TPM_RC_SUCCESS;
7672 }
7673 if (*target == TPM_HT_POLICY_SESSION) {
7674 return TPM_RC_SUCCESS;
7675 }
7676 if (*target == TPM_HT_ACTIVE_SESSION) {
7677 return TPM_RC_SUCCESS;
7678 }
7679 if (*target == TPM_HT_PERMANENT) {
7680 return TPM_RC_SUCCESS;
7681 }
7682 if (*target == TPM_HT_TRANSIENT) {
7683 return TPM_RC_SUCCESS;
7684 }
7685 if (*target == TPM_HT_PERSISTENT) {
7686 return TPM_RC_SUCCESS;
7687 }
7688 return TPM_RC_VALUE;
7689 }
7690
TPM_KEY_SIZE_Marshal(TPM_KEY_SIZE * source,BYTE ** buffer,INT32 * size)7691 UINT16 TPM_KEY_SIZE_Marshal(TPM_KEY_SIZE* source, BYTE** buffer, INT32* size) {
7692 return uint16_t_Marshal(source, buffer, size);
7693 }
7694
TPM_KEY_SIZE_Unmarshal(TPM_KEY_SIZE * target,BYTE ** buffer,INT32 * size)7695 TPM_RC TPM_KEY_SIZE_Unmarshal(TPM_KEY_SIZE* target,
7696 BYTE** buffer,
7697 INT32* size) {
7698 return uint16_t_Unmarshal(target, buffer, size);
7699 }
7700
TPM_MODIFIER_INDICATOR_Marshal(TPM_MODIFIER_INDICATOR * source,BYTE ** buffer,INT32 * size)7701 UINT16 TPM_MODIFIER_INDICATOR_Marshal(TPM_MODIFIER_INDICATOR* source,
7702 BYTE** buffer,
7703 INT32* size) {
7704 return uint32_t_Marshal(source, buffer, size);
7705 }
7706
TPM_MODIFIER_INDICATOR_Unmarshal(TPM_MODIFIER_INDICATOR * target,BYTE ** buffer,INT32 * size)7707 TPM_RC TPM_MODIFIER_INDICATOR_Unmarshal(TPM_MODIFIER_INDICATOR* target,
7708 BYTE** buffer,
7709 INT32* size) {
7710 return uint32_t_Unmarshal(target, buffer, size);
7711 }
7712
TPM_NV_INDEX_Marshal(TPM_NV_INDEX * source,BYTE ** buffer,INT32 * size)7713 UINT16 TPM_NV_INDEX_Marshal(TPM_NV_INDEX* source, BYTE** buffer, INT32* size) {
7714 return uint32_t_Marshal((uint32_t*)source, buffer, size);
7715 }
7716
TPM_NV_INDEX_Unmarshal(TPM_NV_INDEX * target,BYTE ** buffer,INT32 * size)7717 TPM_RC TPM_NV_INDEX_Unmarshal(TPM_NV_INDEX* target,
7718 BYTE** buffer,
7719 INT32* size) {
7720 TPM_RC result;
7721 result = uint32_t_Unmarshal((uint32_t*)target, buffer, size);
7722 if (result != TPM_RC_SUCCESS) {
7723 return result;
7724 }
7725 return TPM_RC_SUCCESS;
7726 }
7727
TPM_PARAMETER_SIZE_Marshal(TPM_PARAMETER_SIZE * source,BYTE ** buffer,INT32 * size)7728 UINT16 TPM_PARAMETER_SIZE_Marshal(TPM_PARAMETER_SIZE* source,
7729 BYTE** buffer,
7730 INT32* size) {
7731 return uint32_t_Marshal(source, buffer, size);
7732 }
7733
TPM_PARAMETER_SIZE_Unmarshal(TPM_PARAMETER_SIZE * target,BYTE ** buffer,INT32 * size)7734 TPM_RC TPM_PARAMETER_SIZE_Unmarshal(TPM_PARAMETER_SIZE* target,
7735 BYTE** buffer,
7736 INT32* size) {
7737 return uint32_t_Unmarshal(target, buffer, size);
7738 }
7739
TPM_PS_Marshal(TPM_PS * source,BYTE ** buffer,INT32 * size)7740 UINT16 TPM_PS_Marshal(TPM_PS* source, BYTE** buffer, INT32* size) {
7741 return uint32_t_Marshal(source, buffer, size);
7742 }
7743
TPM_PS_Unmarshal(TPM_PS * target,BYTE ** buffer,INT32 * size)7744 TPM_RC TPM_PS_Unmarshal(TPM_PS* target, BYTE** buffer, INT32* size) {
7745 TPM_RC result;
7746 result = uint32_t_Unmarshal(target, buffer, size);
7747 if (result != TPM_RC_SUCCESS) {
7748 return result;
7749 }
7750 if (*target == TPM_PS_MAIN) {
7751 return TPM_RC_SUCCESS;
7752 }
7753 if (*target == TPM_PS_PC) {
7754 return TPM_RC_SUCCESS;
7755 }
7756 if (*target == TPM_PS_PDA) {
7757 return TPM_RC_SUCCESS;
7758 }
7759 if (*target == TPM_PS_CELL_PHONE) {
7760 return TPM_RC_SUCCESS;
7761 }
7762 if (*target == TPM_PS_SERVER) {
7763 return TPM_RC_SUCCESS;
7764 }
7765 if (*target == TPM_PS_PERIPHERAL) {
7766 return TPM_RC_SUCCESS;
7767 }
7768 if (*target == TPM_PS_TSS) {
7769 return TPM_RC_SUCCESS;
7770 }
7771 if (*target == TPM_PS_STORAGE) {
7772 return TPM_RC_SUCCESS;
7773 }
7774 if (*target == TPM_PS_AUTHENTICATION) {
7775 return TPM_RC_SUCCESS;
7776 }
7777 if (*target == TPM_PS_EMBEDDED) {
7778 return TPM_RC_SUCCESS;
7779 }
7780 if (*target == TPM_PS_HARDCOPY) {
7781 return TPM_RC_SUCCESS;
7782 }
7783 if (*target == TPM_PS_INFRASTRUCTURE) {
7784 return TPM_RC_SUCCESS;
7785 }
7786 if (*target == TPM_PS_VIRTUALIZATION) {
7787 return TPM_RC_SUCCESS;
7788 }
7789 if (*target == TPM_PS_TNC) {
7790 return TPM_RC_SUCCESS;
7791 }
7792 if (*target == TPM_PS_MULTI_TENANT) {
7793 return TPM_RC_SUCCESS;
7794 }
7795 if (*target == TPM_PS_TC) {
7796 return TPM_RC_SUCCESS;
7797 }
7798 return TPM_RC_VALUE;
7799 }
7800
TPM_PT_PCR_Marshal(TPM_PT_PCR * source,BYTE ** buffer,INT32 * size)7801 UINT16 TPM_PT_PCR_Marshal(TPM_PT_PCR* source, BYTE** buffer, INT32* size) {
7802 return uint32_t_Marshal(source, buffer, size);
7803 }
7804
TPM_PT_PCR_Unmarshal(TPM_PT_PCR * target,BYTE ** buffer,INT32 * size)7805 TPM_RC TPM_PT_PCR_Unmarshal(TPM_PT_PCR* target, BYTE** buffer, INT32* size) {
7806 TPM_RC result;
7807 result = uint32_t_Unmarshal(target, buffer, size);
7808 if (result != TPM_RC_SUCCESS) {
7809 return result;
7810 }
7811 if (*target == TPM_PT_PCR_FIRST) {
7812 return TPM_RC_SUCCESS;
7813 }
7814 if (*target == TPM_PT_PCR_SAVE) {
7815 return TPM_RC_SUCCESS;
7816 }
7817 if (*target == TPM_PT_PCR_EXTEND_L0) {
7818 return TPM_RC_SUCCESS;
7819 }
7820 if (*target == TPM_PT_PCR_RESET_L0) {
7821 return TPM_RC_SUCCESS;
7822 }
7823 if (*target == TPM_PT_PCR_EXTEND_L1) {
7824 return TPM_RC_SUCCESS;
7825 }
7826 if (*target == TPM_PT_PCR_RESET_L1) {
7827 return TPM_RC_SUCCESS;
7828 }
7829 if (*target == TPM_PT_PCR_EXTEND_L2) {
7830 return TPM_RC_SUCCESS;
7831 }
7832 if (*target == TPM_PT_PCR_RESET_L2) {
7833 return TPM_RC_SUCCESS;
7834 }
7835 if (*target == TPM_PT_PCR_EXTEND_L3) {
7836 return TPM_RC_SUCCESS;
7837 }
7838 if (*target == TPM_PT_PCR_RESET_L3) {
7839 return TPM_RC_SUCCESS;
7840 }
7841 if (*target == TPM_PT_PCR_EXTEND_L4) {
7842 return TPM_RC_SUCCESS;
7843 }
7844 if (*target == TPM_PT_PCR_RESET_L4) {
7845 return TPM_RC_SUCCESS;
7846 }
7847 if (*target == TPM_PT_PCR_NO_INCREMENT) {
7848 return TPM_RC_SUCCESS;
7849 }
7850 if (*target == TPM_PT_PCR_DRTM_RESET) {
7851 return TPM_RC_SUCCESS;
7852 }
7853 if (*target == TPM_PT_PCR_POLICY) {
7854 return TPM_RC_SUCCESS;
7855 }
7856 if (*target == TPM_PT_PCR_AUTH) {
7857 return TPM_RC_SUCCESS;
7858 }
7859 if (*target == TPM_PT_PCR_LAST) {
7860 return TPM_RC_SUCCESS;
7861 }
7862 return TPM_RC_VALUE;
7863 }
7864
TPM_RC_Marshal(TPM_RC * source,BYTE ** buffer,INT32 * size)7865 UINT16 TPM_RC_Marshal(TPM_RC* source, BYTE** buffer, INT32* size) {
7866 return uint32_t_Marshal(source, buffer, size);
7867 }
7868
TPM_RC_Unmarshal(TPM_RC * target,BYTE ** buffer,INT32 * size)7869 TPM_RC TPM_RC_Unmarshal(TPM_RC* target, BYTE** buffer, INT32* size) {
7870 TPM_RC result;
7871 result = uint32_t_Unmarshal(target, buffer, size);
7872 if (result != TPM_RC_SUCCESS) {
7873 return result;
7874 }
7875 if (*target == TPM_RC_SUCCESS) {
7876 return TPM_RC_SUCCESS;
7877 }
7878 if (*target == TPM_RC_BAD_TAG) {
7879 return TPM_RC_SUCCESS;
7880 }
7881 if (*target == RC_VER1) {
7882 return TPM_RC_SUCCESS;
7883 }
7884 if (*target == TPM_RC_INITIALIZE) {
7885 return TPM_RC_SUCCESS;
7886 }
7887 if (*target == TPM_RC_FAILURE) {
7888 return TPM_RC_SUCCESS;
7889 }
7890 if (*target == TPM_RC_SEQUENCE) {
7891 return TPM_RC_SUCCESS;
7892 }
7893 if (*target == TPM_RC_PRIVATE) {
7894 return TPM_RC_SUCCESS;
7895 }
7896 if (*target == TPM_RC_HMAC) {
7897 return TPM_RC_SUCCESS;
7898 }
7899 if (*target == TPM_RC_DISABLED) {
7900 return TPM_RC_SUCCESS;
7901 }
7902 if (*target == TPM_RC_EXCLUSIVE) {
7903 return TPM_RC_SUCCESS;
7904 }
7905 if (*target == TPM_RC_AUTH_TYPE) {
7906 return TPM_RC_SUCCESS;
7907 }
7908 if (*target == TPM_RC_AUTH_MISSING) {
7909 return TPM_RC_SUCCESS;
7910 }
7911 if (*target == TPM_RC_POLICY) {
7912 return TPM_RC_SUCCESS;
7913 }
7914 if (*target == TPM_RC_PCR) {
7915 return TPM_RC_SUCCESS;
7916 }
7917 if (*target == TPM_RC_PCR_CHANGED) {
7918 return TPM_RC_SUCCESS;
7919 }
7920 if (*target == TPM_RC_UPGRADE) {
7921 return TPM_RC_SUCCESS;
7922 }
7923 if (*target == TPM_RC_TOO_MANY_CONTEXTS) {
7924 return TPM_RC_SUCCESS;
7925 }
7926 if (*target == TPM_RC_AUTH_UNAVAILABLE) {
7927 return TPM_RC_SUCCESS;
7928 }
7929 if (*target == TPM_RC_REBOOT) {
7930 return TPM_RC_SUCCESS;
7931 }
7932 if (*target == TPM_RC_UNBALANCED) {
7933 return TPM_RC_SUCCESS;
7934 }
7935 if (*target == TPM_RC_COMMAND_SIZE) {
7936 return TPM_RC_SUCCESS;
7937 }
7938 if (*target == TPM_RC_COMMAND_CODE) {
7939 return TPM_RC_SUCCESS;
7940 }
7941 if (*target == TPM_RC_AUTHSIZE) {
7942 return TPM_RC_SUCCESS;
7943 }
7944 if (*target == TPM_RC_AUTH_CONTEXT) {
7945 return TPM_RC_SUCCESS;
7946 }
7947 if (*target == TPM_RC_NV_RANGE) {
7948 return TPM_RC_SUCCESS;
7949 }
7950 if (*target == TPM_RC_NV_SIZE) {
7951 return TPM_RC_SUCCESS;
7952 }
7953 if (*target == TPM_RC_NV_LOCKED) {
7954 return TPM_RC_SUCCESS;
7955 }
7956 if (*target == TPM_RC_NV_AUTHORIZATION) {
7957 return TPM_RC_SUCCESS;
7958 }
7959 if (*target == TPM_RC_NV_UNINITIALIZED) {
7960 return TPM_RC_SUCCESS;
7961 }
7962 if (*target == TPM_RC_NV_SPACE) {
7963 return TPM_RC_SUCCESS;
7964 }
7965 if (*target == TPM_RC_NV_DEFINED) {
7966 return TPM_RC_SUCCESS;
7967 }
7968 if (*target == TPM_RC_BAD_CONTEXT) {
7969 return TPM_RC_SUCCESS;
7970 }
7971 if (*target == TPM_RC_CPHASH) {
7972 return TPM_RC_SUCCESS;
7973 }
7974 if (*target == TPM_RC_PARENT) {
7975 return TPM_RC_SUCCESS;
7976 }
7977 if (*target == TPM_RC_NEEDS_TEST) {
7978 return TPM_RC_SUCCESS;
7979 }
7980 if (*target == TPM_RC_NO_RESULT) {
7981 return TPM_RC_SUCCESS;
7982 }
7983 if (*target == TPM_RC_SENSITIVE) {
7984 return TPM_RC_SUCCESS;
7985 }
7986 if (*target == RC_MAX_FM0) {
7987 return TPM_RC_SUCCESS;
7988 }
7989 if (*target == RC_FMT1) {
7990 return TPM_RC_SUCCESS;
7991 }
7992 if (*target == TPM_RC_ASYMMETRIC) {
7993 return TPM_RC_SUCCESS;
7994 }
7995 if (*target == TPM_RC_ATTRIBUTES) {
7996 return TPM_RC_SUCCESS;
7997 }
7998 if (*target == TPM_RC_HASH) {
7999 return TPM_RC_SUCCESS;
8000 }
8001 if (*target == TPM_RC_VALUE) {
8002 return TPM_RC_SUCCESS;
8003 }
8004 if (*target == TPM_RC_HIERARCHY) {
8005 return TPM_RC_SUCCESS;
8006 }
8007 if (*target == TPM_RC_KEY_SIZE) {
8008 return TPM_RC_SUCCESS;
8009 }
8010 if (*target == TPM_RC_MGF) {
8011 return TPM_RC_SUCCESS;
8012 }
8013 if (*target == TPM_RC_MODE) {
8014 return TPM_RC_SUCCESS;
8015 }
8016 if (*target == TPM_RC_TYPE) {
8017 return TPM_RC_SUCCESS;
8018 }
8019 if (*target == TPM_RC_HANDLE) {
8020 return TPM_RC_SUCCESS;
8021 }
8022 if (*target == TPM_RC_KDF) {
8023 return TPM_RC_SUCCESS;
8024 }
8025 if (*target == TPM_RC_RANGE) {
8026 return TPM_RC_SUCCESS;
8027 }
8028 if (*target == TPM_RC_AUTH_FAIL) {
8029 return TPM_RC_SUCCESS;
8030 }
8031 if (*target == TPM_RC_NONCE) {
8032 return TPM_RC_SUCCESS;
8033 }
8034 if (*target == TPM_RC_PP) {
8035 return TPM_RC_SUCCESS;
8036 }
8037 if (*target == TPM_RC_SCHEME) {
8038 return TPM_RC_SUCCESS;
8039 }
8040 if (*target == TPM_RC_SIZE) {
8041 return TPM_RC_SUCCESS;
8042 }
8043 if (*target == TPM_RC_SYMMETRIC) {
8044 return TPM_RC_SUCCESS;
8045 }
8046 if (*target == TPM_RC_TAG) {
8047 return TPM_RC_SUCCESS;
8048 }
8049 if (*target == TPM_RC_SELECTOR) {
8050 return TPM_RC_SUCCESS;
8051 }
8052 if (*target == TPM_RC_INSUFFICIENT) {
8053 return TPM_RC_SUCCESS;
8054 }
8055 if (*target == TPM_RC_SIGNATURE) {
8056 return TPM_RC_SUCCESS;
8057 }
8058 if (*target == TPM_RC_KEY) {
8059 return TPM_RC_SUCCESS;
8060 }
8061 if (*target == TPM_RC_POLICY_FAIL) {
8062 return TPM_RC_SUCCESS;
8063 }
8064 if (*target == TPM_RC_INTEGRITY) {
8065 return TPM_RC_SUCCESS;
8066 }
8067 if (*target == TPM_RC_TICKET) {
8068 return TPM_RC_SUCCESS;
8069 }
8070 if (*target == TPM_RC_RESERVED_BITS) {
8071 return TPM_RC_SUCCESS;
8072 }
8073 if (*target == TPM_RC_BAD_AUTH) {
8074 return TPM_RC_SUCCESS;
8075 }
8076 if (*target == TPM_RC_EXPIRED) {
8077 return TPM_RC_SUCCESS;
8078 }
8079 if (*target == TPM_RC_POLICY_CC) {
8080 return TPM_RC_SUCCESS;
8081 }
8082 if (*target == TPM_RC_BINDING) {
8083 return TPM_RC_SUCCESS;
8084 }
8085 if (*target == TPM_RC_CURVE) {
8086 return TPM_RC_SUCCESS;
8087 }
8088 if (*target == TPM_RC_ECC_POINT) {
8089 return TPM_RC_SUCCESS;
8090 }
8091 if (*target == RC_WARN) {
8092 return TPM_RC_SUCCESS;
8093 }
8094 if (*target == TPM_RC_CONTEXT_GAP) {
8095 return TPM_RC_SUCCESS;
8096 }
8097 if (*target == TPM_RC_OBJECT_MEMORY) {
8098 return TPM_RC_SUCCESS;
8099 }
8100 if (*target == TPM_RC_SESSION_MEMORY) {
8101 return TPM_RC_SUCCESS;
8102 }
8103 if (*target == TPM_RC_MEMORY) {
8104 return TPM_RC_SUCCESS;
8105 }
8106 if (*target == TPM_RC_SESSION_HANDLES) {
8107 return TPM_RC_SUCCESS;
8108 }
8109 if (*target == TPM_RC_OBJECT_HANDLES) {
8110 return TPM_RC_SUCCESS;
8111 }
8112 if (*target == TPM_RC_LOCALITY) {
8113 return TPM_RC_SUCCESS;
8114 }
8115 if (*target == TPM_RC_YIELDED) {
8116 return TPM_RC_SUCCESS;
8117 }
8118 if (*target == TPM_RC_CANCELED) {
8119 return TPM_RC_SUCCESS;
8120 }
8121 if (*target == TPM_RC_TESTING) {
8122 return TPM_RC_SUCCESS;
8123 }
8124 if (*target == TPM_RC_REFERENCE_H0) {
8125 return TPM_RC_SUCCESS;
8126 }
8127 if (*target == TPM_RC_REFERENCE_H1) {
8128 return TPM_RC_SUCCESS;
8129 }
8130 if (*target == TPM_RC_REFERENCE_H2) {
8131 return TPM_RC_SUCCESS;
8132 }
8133 if (*target == TPM_RC_REFERENCE_H3) {
8134 return TPM_RC_SUCCESS;
8135 }
8136 if (*target == TPM_RC_REFERENCE_H4) {
8137 return TPM_RC_SUCCESS;
8138 }
8139 if (*target == TPM_RC_REFERENCE_H5) {
8140 return TPM_RC_SUCCESS;
8141 }
8142 if (*target == TPM_RC_REFERENCE_H6) {
8143 return TPM_RC_SUCCESS;
8144 }
8145 if (*target == TPM_RC_REFERENCE_S0) {
8146 return TPM_RC_SUCCESS;
8147 }
8148 if (*target == TPM_RC_REFERENCE_S1) {
8149 return TPM_RC_SUCCESS;
8150 }
8151 if (*target == TPM_RC_REFERENCE_S2) {
8152 return TPM_RC_SUCCESS;
8153 }
8154 if (*target == TPM_RC_REFERENCE_S3) {
8155 return TPM_RC_SUCCESS;
8156 }
8157 if (*target == TPM_RC_REFERENCE_S4) {
8158 return TPM_RC_SUCCESS;
8159 }
8160 if (*target == TPM_RC_REFERENCE_S5) {
8161 return TPM_RC_SUCCESS;
8162 }
8163 if (*target == TPM_RC_REFERENCE_S6) {
8164 return TPM_RC_SUCCESS;
8165 }
8166 if (*target == TPM_RC_NV_RATE) {
8167 return TPM_RC_SUCCESS;
8168 }
8169 if (*target == TPM_RC_LOCKOUT) {
8170 return TPM_RC_SUCCESS;
8171 }
8172 if (*target == TPM_RC_RETRY) {
8173 return TPM_RC_SUCCESS;
8174 }
8175 if (*target == TPM_RC_NV_UNAVAILABLE) {
8176 return TPM_RC_SUCCESS;
8177 }
8178 if (*target == TPM_RC_NOT_USED) {
8179 return TPM_RC_SUCCESS;
8180 }
8181 if (*target == TPM_RC_H) {
8182 return TPM_RC_SUCCESS;
8183 }
8184 if (*target == TPM_RC_P) {
8185 return TPM_RC_SUCCESS;
8186 }
8187 if (*target == TPM_RC_S) {
8188 return TPM_RC_SUCCESS;
8189 }
8190 if (*target == TPM_RC_1) {
8191 return TPM_RC_SUCCESS;
8192 }
8193 if (*target == TPM_RC_2) {
8194 return TPM_RC_SUCCESS;
8195 }
8196 if (*target == TPM_RC_3) {
8197 return TPM_RC_SUCCESS;
8198 }
8199 if (*target == TPM_RC_4) {
8200 return TPM_RC_SUCCESS;
8201 }
8202 if (*target == TPM_RC_5) {
8203 return TPM_RC_SUCCESS;
8204 }
8205 if (*target == TPM_RC_6) {
8206 return TPM_RC_SUCCESS;
8207 }
8208 if (*target == TPM_RC_7) {
8209 return TPM_RC_SUCCESS;
8210 }
8211 if (*target == TPM_RC_8) {
8212 return TPM_RC_SUCCESS;
8213 }
8214 if (*target == TPM_RC_9) {
8215 return TPM_RC_SUCCESS;
8216 }
8217 if (*target == TPM_RC_A) {
8218 return TPM_RC_SUCCESS;
8219 }
8220 if (*target == TPM_RC_B) {
8221 return TPM_RC_SUCCESS;
8222 }
8223 if (*target == TPM_RC_C) {
8224 return TPM_RC_SUCCESS;
8225 }
8226 if (*target == TPM_RC_D) {
8227 return TPM_RC_SUCCESS;
8228 }
8229 if (*target == TPM_RC_E) {
8230 return TPM_RC_SUCCESS;
8231 }
8232 if (*target == TPM_RC_F) {
8233 return TPM_RC_SUCCESS;
8234 }
8235 if (*target == TPM_RC_N_MASK) {
8236 return TPM_RC_SUCCESS;
8237 }
8238 return TPM_RC_VALUE;
8239 }
8240
TPM_RH_Marshal(TPM_RH * source,BYTE ** buffer,INT32 * size)8241 UINT16 TPM_RH_Marshal(TPM_RH* source, BYTE** buffer, INT32* size) {
8242 return uint32_t_Marshal(source, buffer, size);
8243 }
8244
TPM_RH_Unmarshal(TPM_RH * target,BYTE ** buffer,INT32 * size)8245 TPM_RC TPM_RH_Unmarshal(TPM_RH* target, BYTE** buffer, INT32* size) {
8246 TPM_RC result;
8247 result = uint32_t_Unmarshal(target, buffer, size);
8248 if (result != TPM_RC_SUCCESS) {
8249 return result;
8250 }
8251 if (*target == TPM_RH_FIRST) {
8252 return TPM_RC_SUCCESS;
8253 }
8254 if (*target == TPM_RH_SRK) {
8255 return TPM_RC_SUCCESS;
8256 }
8257 if (*target == TPM_RH_OWNER) {
8258 return TPM_RC_SUCCESS;
8259 }
8260 if (*target == TPM_RH_REVOKE) {
8261 return TPM_RC_SUCCESS;
8262 }
8263 if (*target == TPM_RH_TRANSPORT) {
8264 return TPM_RC_SUCCESS;
8265 }
8266 if (*target == TPM_RH_OPERATOR) {
8267 return TPM_RC_SUCCESS;
8268 }
8269 if (*target == TPM_RH_ADMIN) {
8270 return TPM_RC_SUCCESS;
8271 }
8272 if (*target == TPM_RH_EK) {
8273 return TPM_RC_SUCCESS;
8274 }
8275 if (*target == TPM_RH_NULL) {
8276 return TPM_RC_SUCCESS;
8277 }
8278 if (*target == TPM_RH_UNASSIGNED) {
8279 return TPM_RC_SUCCESS;
8280 }
8281 if (*target == TPM_RS_PW) {
8282 return TPM_RC_SUCCESS;
8283 }
8284 if (*target == TPM_RH_LOCKOUT) {
8285 return TPM_RC_SUCCESS;
8286 }
8287 if (*target == TPM_RH_ENDORSEMENT) {
8288 return TPM_RC_SUCCESS;
8289 }
8290 if (*target == TPM_RH_PLATFORM) {
8291 return TPM_RC_SUCCESS;
8292 }
8293 if (*target == TPM_RH_PLATFORM_NV) {
8294 return TPM_RC_SUCCESS;
8295 }
8296 if (*target == TPM_RH_AUTH_00) {
8297 return TPM_RC_SUCCESS;
8298 }
8299 if (*target == TPM_RH_AUTH_FF) {
8300 return TPM_RC_SUCCESS;
8301 }
8302 if (*target == TPM_RH_LAST) {
8303 return TPM_RC_SUCCESS;
8304 }
8305 return TPM_RC_VALUE;
8306 }
8307
TPM_SE_Marshal(TPM_SE * source,BYTE ** buffer,INT32 * size)8308 UINT16 TPM_SE_Marshal(TPM_SE* source, BYTE** buffer, INT32* size) {
8309 return uint8_t_Marshal(source, buffer, size);
8310 }
8311
TPM_SE_Unmarshal(TPM_SE * target,BYTE ** buffer,INT32 * size)8312 TPM_RC TPM_SE_Unmarshal(TPM_SE* target, BYTE** buffer, INT32* size) {
8313 TPM_RC result;
8314 result = uint8_t_Unmarshal(target, buffer, size);
8315 if (result != TPM_RC_SUCCESS) {
8316 return result;
8317 }
8318 if (*target == TPM_SE_HMAC) {
8319 return TPM_RC_SUCCESS;
8320 }
8321 if (*target == TPM_SE_POLICY) {
8322 return TPM_RC_SUCCESS;
8323 }
8324 if (*target == TPM_SE_TRIAL) {
8325 return TPM_RC_SUCCESS;
8326 }
8327 return TPM_RC_VALUE;
8328 }
8329
TPM_SPEC_Marshal(TPM_SPEC * source,BYTE ** buffer,INT32 * size)8330 UINT16 TPM_SPEC_Marshal(TPM_SPEC* source, BYTE** buffer, INT32* size) {
8331 return uint32_t_Marshal(source, buffer, size);
8332 }
8333
TPM_SPEC_Unmarshal(TPM_SPEC * target,BYTE ** buffer,INT32 * size)8334 TPM_RC TPM_SPEC_Unmarshal(TPM_SPEC* target, BYTE** buffer, INT32* size) {
8335 TPM_RC result;
8336 result = uint32_t_Unmarshal(target, buffer, size);
8337 if (result != TPM_RC_SUCCESS) {
8338 return result;
8339 }
8340 if (*target == TPM_SPEC_FAMILY) {
8341 return TPM_RC_SUCCESS;
8342 }
8343 if (*target == TPM_SPEC_LEVEL) {
8344 return TPM_RC_SUCCESS;
8345 }
8346 if (*target == TPM_SPEC_VERSION) {
8347 return TPM_RC_SUCCESS;
8348 }
8349 if (*target == TPM_SPEC_YEAR) {
8350 return TPM_RC_SUCCESS;
8351 }
8352 if (*target == TPM_SPEC_DAY_OF_YEAR) {
8353 return TPM_RC_SUCCESS;
8354 }
8355 return TPM_RC_VALUE;
8356 }
8357
TPM_SU_Marshal(TPM_SU * source,BYTE ** buffer,INT32 * size)8358 UINT16 TPM_SU_Marshal(TPM_SU* source, BYTE** buffer, INT32* size) {
8359 return uint16_t_Marshal(source, buffer, size);
8360 }
8361
TPM_SU_Unmarshal(TPM_SU * target,BYTE ** buffer,INT32 * size)8362 TPM_RC TPM_SU_Unmarshal(TPM_SU* target, BYTE** buffer, INT32* size) {
8363 TPM_RC result;
8364 result = uint16_t_Unmarshal(target, buffer, size);
8365 if (result != TPM_RC_SUCCESS) {
8366 return result;
8367 }
8368 if (*target == TPM_SU_CLEAR) {
8369 return TPM_RC_SUCCESS;
8370 }
8371 if (*target == TPM_SU_STATE) {
8372 return TPM_RC_SUCCESS;
8373 }
8374 return TPM_RC_VALUE;
8375 }
8376
_ID_OBJECT_Marshal(_ID_OBJECT * source,BYTE ** buffer,INT32 * size)8377 UINT16 _ID_OBJECT_Marshal(_ID_OBJECT* source, BYTE** buffer, INT32* size) {
8378 UINT16 total_size = 0;
8379 total_size += TPM2B_DIGEST_Marshal(&source->integrityHMAC, buffer, size);
8380 total_size += TPM2B_DIGEST_Marshal(&source->encIdentity, buffer, size);
8381 return total_size;
8382 }
8383
_ID_OBJECT_Unmarshal(_ID_OBJECT * target,BYTE ** buffer,INT32 * size)8384 TPM_RC _ID_OBJECT_Unmarshal(_ID_OBJECT* target, BYTE** buffer, INT32* size) {
8385 TPM_RC result;
8386 result = TPM2B_DIGEST_Unmarshal(&target->integrityHMAC, buffer, size);
8387 if (result != TPM_RC_SUCCESS) {
8388 return result;
8389 }
8390 result = TPM2B_DIGEST_Unmarshal(&target->encIdentity, buffer, size);
8391 if (result != TPM_RC_SUCCESS) {
8392 return result;
8393 }
8394 return TPM_RC_SUCCESS;
8395 }
8396
_PRIVATE_Marshal(_PRIVATE * source,BYTE ** buffer,INT32 * size)8397 UINT16 _PRIVATE_Marshal(_PRIVATE* source, BYTE** buffer, INT32* size) {
8398 UINT16 total_size = 0;
8399 total_size += TPM2B_DIGEST_Marshal(&source->integrityOuter, buffer, size);
8400 total_size += TPM2B_DIGEST_Marshal(&source->integrityInner, buffer, size);
8401 total_size += TPMT_SENSITIVE_Marshal(&source->sensitive, buffer, size);
8402 return total_size;
8403 }
8404
_PRIVATE_Unmarshal(_PRIVATE * target,BYTE ** buffer,INT32 * size)8405 TPM_RC _PRIVATE_Unmarshal(_PRIVATE* target, BYTE** buffer, INT32* size) {
8406 TPM_RC result;
8407 result = TPM2B_DIGEST_Unmarshal(&target->integrityOuter, buffer, size);
8408 if (result != TPM_RC_SUCCESS) {
8409 return result;
8410 }
8411 result = TPM2B_DIGEST_Unmarshal(&target->integrityInner, buffer, size);
8412 if (result != TPM_RC_SUCCESS) {
8413 return result;
8414 }
8415 result = TPMT_SENSITIVE_Unmarshal(&target->sensitive, buffer, size);
8416 if (result != TPM_RC_SUCCESS) {
8417 return result;
8418 }
8419 return TPM_RC_SUCCESS;
8420 }
8421