1 /* Microsoft Reference Implementation for TPM 2.0
2 *
3 * The copyright in this software is being made available under the BSD License,
4 * included below. This software may be subject to other third party and
5 * contributor rights, including patent rights, and no such rights are granted
6 * under this license.
7 *
8 * Copyright (c) Microsoft Corporation
9 *
10 * All rights reserved.
11 *
12 * BSD License
13 *
14 * Redistribution and use in source and binary forms, with or without modification,
15 * are permitted provided that the following conditions are met:
16 *
17 * Redistributions of source code must retain the above copyright notice, this list
18 * of conditions and the following disclaimer.
19 *
20 * Redistributions in binary form must reproduce the above copyright notice, this
21 * list of conditions and the following disclaimer in the documentation and/or
22 * other materials provided with the distribution.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
28 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
29 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
31 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 */
35 /*(Auto-generated)
36 * Created by TpmMarshal; Version 4.1 Dec 10, 2018
37 * Date: Mar 6, 2020 Time: 01:50:10PM
38 */
39
40 #include "Tpm.h"
41 #if !TABLE_DRIVEN_MARSHAL
42 #include "Marshal_fp.h"
43
44 // Table 2:3 - Definition of Base Types
45 // UINT8 definition from table 2:3
46 TPM_RC
UINT8_Unmarshal(UINT8 * target,BYTE ** buffer,INT32 * size)47 UINT8_Unmarshal(UINT8 *target, BYTE **buffer, INT32 *size)
48 {
49 if((*size -= 1) < 0)
50 return TPM_RC_INSUFFICIENT;
51 *target = BYTE_ARRAY_TO_UINT8(*buffer);
52 *buffer += 1;
53 return TPM_RC_SUCCESS;
54 }
55 UINT16
UINT8_Marshal(UINT8 * source,BYTE ** buffer,INT32 * size)56 UINT8_Marshal(UINT8 *source, BYTE **buffer, INT32 *size)
57 {
58 if (buffer != 0)
59 {
60 if ((size == 0) || ((*size -= 1) >= 0))
61 {
62 UINT8_TO_BYTE_ARRAY(*source, *buffer);
63 *buffer += 1;
64 }
65 pAssert(size == 0 || (*size >= 0));
66 }
67 return (1);
68 }
69
70 // BYTE definition from table 2:3
71 #if !USE_MARSHALING_DEFINES
72 TPM_RC
BYTE_Unmarshal(BYTE * target,BYTE ** buffer,INT32 * size)73 BYTE_Unmarshal(BYTE *target, BYTE **buffer, INT32 *size)
74 {
75 return UINT8_Unmarshal((UINT8 *)target, buffer, size);
76 }
77 UINT16
BYTE_Marshal(BYTE * source,BYTE ** buffer,INT32 * size)78 BYTE_Marshal(BYTE *source, BYTE **buffer, INT32 *size)
79 {
80 return UINT8_Marshal((UINT8 *)source, buffer, size);
81 }
82 #endif // !USE_MARSHALING_DEFINES
83
84 // INT8 definition from table 2:3
85 #if !USE_MARSHALING_DEFINES
86 TPM_RC
INT8_Unmarshal(INT8 * target,BYTE ** buffer,INT32 * size)87 INT8_Unmarshal(INT8 *target, BYTE **buffer, INT32 *size)
88 {
89 return UINT8_Unmarshal((UINT8 *)target, buffer, size);
90 }
91 UINT16
INT8_Marshal(INT8 * source,BYTE ** buffer,INT32 * size)92 INT8_Marshal(INT8 *source, BYTE **buffer, INT32 *size)
93 {
94 return UINT8_Marshal((UINT8 *)source, buffer, size);
95 }
96 #endif // !USE_MARSHALING_DEFINES
97
98 // UINT16 definition from table 2:3
99 TPM_RC
UINT16_Unmarshal(UINT16 * target,BYTE ** buffer,INT32 * size)100 UINT16_Unmarshal(UINT16 *target, BYTE **buffer, INT32 *size)
101 {
102 if((*size -= 2) < 0)
103 return TPM_RC_INSUFFICIENT;
104 *target = BYTE_ARRAY_TO_UINT16(*buffer);
105 *buffer += 2;
106 return TPM_RC_SUCCESS;
107 }
108 UINT16
UINT16_Marshal(UINT16 * source,BYTE ** buffer,INT32 * size)109 UINT16_Marshal(UINT16 *source, BYTE **buffer, INT32 *size)
110 {
111 if (buffer != 0)
112 {
113 if ((size == 0) || ((*size -= 2) >= 0))
114 {
115 UINT16_TO_BYTE_ARRAY(*source, *buffer);
116 *buffer += 2;
117 }
118 pAssert(size == 0 || (*size >= 0));
119 }
120 return (2);
121 }
122
123 // INT16 definition from table 2:3
124 #if !USE_MARSHALING_DEFINES
125 TPM_RC
INT16_Unmarshal(INT16 * target,BYTE ** buffer,INT32 * size)126 INT16_Unmarshal(INT16 *target, BYTE **buffer, INT32 *size)
127 {
128 return UINT16_Unmarshal((UINT16 *)target, buffer, size);
129 }
130 UINT16
INT16_Marshal(INT16 * source,BYTE ** buffer,INT32 * size)131 INT16_Marshal(INT16 *source, BYTE **buffer, INT32 *size)
132 {
133 return UINT16_Marshal((UINT16 *)source, buffer, size);
134 }
135 #endif // !USE_MARSHALING_DEFINES
136
137 // UINT32 definition from table 2:3
138 TPM_RC
UINT32_Unmarshal(UINT32 * target,BYTE ** buffer,INT32 * size)139 UINT32_Unmarshal(UINT32 *target, BYTE **buffer, INT32 *size)
140 {
141 if((*size -= 4) < 0)
142 return TPM_RC_INSUFFICIENT;
143 *target = BYTE_ARRAY_TO_UINT32(*buffer);
144 *buffer += 4;
145 return TPM_RC_SUCCESS;
146 }
147 UINT16
UINT32_Marshal(UINT32 * source,BYTE ** buffer,INT32 * size)148 UINT32_Marshal(UINT32 *source, BYTE **buffer, INT32 *size)
149 {
150 if (buffer != 0)
151 {
152 if ((size == 0) || ((*size -= 4) >= 0))
153 {
154 UINT32_TO_BYTE_ARRAY(*source, *buffer);
155 *buffer += 4;
156 }
157 pAssert(size == 0 || (*size >= 0));
158 }
159 return (4);
160 }
161
162 // INT32 definition from table 2:3
163 #if !USE_MARSHALING_DEFINES
164 TPM_RC
INT32_Unmarshal(INT32 * target,BYTE ** buffer,INT32 * size)165 INT32_Unmarshal(INT32 *target, BYTE **buffer, INT32 *size)
166 {
167 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
168 }
169 UINT16
INT32_Marshal(INT32 * source,BYTE ** buffer,INT32 * size)170 INT32_Marshal(INT32 *source, BYTE **buffer, INT32 *size)
171 {
172 return UINT32_Marshal((UINT32 *)source, buffer, size);
173 }
174 #endif // !USE_MARSHALING_DEFINES
175
176 // UINT64 definition from table 2:3
177 TPM_RC
UINT64_Unmarshal(UINT64 * target,BYTE ** buffer,INT32 * size)178 UINT64_Unmarshal(UINT64 *target, BYTE **buffer, INT32 *size)
179 {
180 if((*size -= 8) < 0)
181 return TPM_RC_INSUFFICIENT;
182 *target = BYTE_ARRAY_TO_UINT64(*buffer);
183 *buffer += 8;
184 return TPM_RC_SUCCESS;
185 }
186 UINT16
UINT64_Marshal(UINT64 * source,BYTE ** buffer,INT32 * size)187 UINT64_Marshal(UINT64 *source, BYTE **buffer, INT32 *size)
188 {
189 if (buffer != 0)
190 {
191 if ((size == 0) || ((*size -= 8) >= 0))
192 {
193 UINT64_TO_BYTE_ARRAY(*source, *buffer);
194 *buffer += 8;
195 }
196 pAssert(size == 0 || (*size >= 0));
197 }
198 return (8);
199 }
200
201 // INT64 definition from table 2:3
202 #if !USE_MARSHALING_DEFINES
203 TPM_RC
INT64_Unmarshal(INT64 * target,BYTE ** buffer,INT32 * size)204 INT64_Unmarshal(INT64 *target, BYTE **buffer, INT32 *size)
205 {
206 return UINT64_Unmarshal((UINT64 *)target, buffer, size);
207 }
208 UINT16
INT64_Marshal(INT64 * source,BYTE ** buffer,INT32 * size)209 INT64_Marshal(INT64 *source, BYTE **buffer, INT32 *size)
210 {
211 return UINT64_Marshal((UINT64 *)source, buffer, size);
212 }
213 #endif // !USE_MARSHALING_DEFINES
214
215 // Table 2:4 - Defines for Logic Values
216 // Table 2:5 - Definition of Types for Documentation Clarity
217 #if !USE_MARSHALING_DEFINES
218 TPM_RC
TPM_ALGORITHM_ID_Unmarshal(TPM_ALGORITHM_ID * target,BYTE ** buffer,INT32 * size)219 TPM_ALGORITHM_ID_Unmarshal(TPM_ALGORITHM_ID *target, BYTE **buffer, INT32 *size)
220 {
221 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
222 }
223 UINT16
TPM_ALGORITHM_ID_Marshal(TPM_ALGORITHM_ID * source,BYTE ** buffer,INT32 * size)224 TPM_ALGORITHM_ID_Marshal(TPM_ALGORITHM_ID *source, BYTE **buffer, INT32 *size)
225 {
226 return UINT32_Marshal((UINT32 *)source, buffer, size);
227 }
228 TPM_RC
TPM_MODIFIER_INDICATOR_Unmarshal(TPM_MODIFIER_INDICATOR * target,BYTE ** buffer,INT32 * size)229 TPM_MODIFIER_INDICATOR_Unmarshal(TPM_MODIFIER_INDICATOR *target, BYTE **buffer, INT32 *size)
230 {
231 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
232 }
233 UINT16
TPM_MODIFIER_INDICATOR_Marshal(TPM_MODIFIER_INDICATOR * source,BYTE ** buffer,INT32 * size)234 TPM_MODIFIER_INDICATOR_Marshal(TPM_MODIFIER_INDICATOR *source, BYTE **buffer, INT32 *size)
235 {
236 return UINT32_Marshal((UINT32 *)source, buffer, size);
237 }
238 TPM_RC
TPM_AUTHORIZATION_SIZE_Unmarshal(TPM_AUTHORIZATION_SIZE * target,BYTE ** buffer,INT32 * size)239 TPM_AUTHORIZATION_SIZE_Unmarshal(TPM_AUTHORIZATION_SIZE *target, BYTE **buffer, INT32 *size)
240 {
241 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
242 }
243 UINT16
TPM_AUTHORIZATION_SIZE_Marshal(TPM_AUTHORIZATION_SIZE * source,BYTE ** buffer,INT32 * size)244 TPM_AUTHORIZATION_SIZE_Marshal(TPM_AUTHORIZATION_SIZE *source, BYTE **buffer, INT32 *size)
245 {
246 return UINT32_Marshal((UINT32 *)source, buffer, size);
247 }
248 TPM_RC
TPM_PARAMETER_SIZE_Unmarshal(TPM_PARAMETER_SIZE * target,BYTE ** buffer,INT32 * size)249 TPM_PARAMETER_SIZE_Unmarshal(TPM_PARAMETER_SIZE *target, BYTE **buffer, INT32 *size)
250 {
251 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
252 }
253 UINT16
TPM_PARAMETER_SIZE_Marshal(TPM_PARAMETER_SIZE * source,BYTE ** buffer,INT32 * size)254 TPM_PARAMETER_SIZE_Marshal(TPM_PARAMETER_SIZE *source, BYTE **buffer, INT32 *size)
255 {
256 return UINT32_Marshal((UINT32 *)source, buffer, size);
257 }
258 TPM_RC
TPM_KEY_SIZE_Unmarshal(TPM_KEY_SIZE * target,BYTE ** buffer,INT32 * size)259 TPM_KEY_SIZE_Unmarshal(TPM_KEY_SIZE *target, BYTE **buffer, INT32 *size)
260 {
261 return UINT16_Unmarshal((UINT16 *)target, buffer, size);
262 }
263 UINT16
TPM_KEY_SIZE_Marshal(TPM_KEY_SIZE * source,BYTE ** buffer,INT32 * size)264 TPM_KEY_SIZE_Marshal(TPM_KEY_SIZE *source, BYTE **buffer, INT32 *size)
265 {
266 return UINT16_Marshal((UINT16 *)source, buffer, size);
267 }
268 TPM_RC
TPM_KEY_BITS_Unmarshal(TPM_KEY_BITS * target,BYTE ** buffer,INT32 * size)269 TPM_KEY_BITS_Unmarshal(TPM_KEY_BITS *target, BYTE **buffer, INT32 *size)
270 {
271 return UINT16_Unmarshal((UINT16 *)target, buffer, size);
272 }
273 UINT16
TPM_KEY_BITS_Marshal(TPM_KEY_BITS * source,BYTE ** buffer,INT32 * size)274 TPM_KEY_BITS_Marshal(TPM_KEY_BITS *source, BYTE **buffer, INT32 *size)
275 {
276 return UINT16_Marshal((UINT16 *)source, buffer, size);
277 }
278 #endif // !USE_MARSHALING_DEFINES
279
280 // Table 2:6 - Definition of TPM_SPEC Constants
281 // Table 2:7 - Definition of TPM_CONSTANTS32 Constants
282 #if !USE_MARSHALING_DEFINES
283 UINT16
TPM_CONSTANTS32_Marshal(TPM_CONSTANTS32 * source,BYTE ** buffer,INT32 * size)284 TPM_CONSTANTS32_Marshal(TPM_CONSTANTS32 *source, BYTE **buffer, INT32 *size)
285 {
286 return UINT32_Marshal((UINT32 *)source, buffer, size);
287 }
288 #endif // !USE_MARSHALING_DEFINES
289
290 // Table 2:9 - Definition of TPM_ALG_ID Constants
291 #if !USE_MARSHALING_DEFINES
292 TPM_RC
TPM_ALG_ID_Unmarshal(TPM_ALG_ID * target,BYTE ** buffer,INT32 * size)293 TPM_ALG_ID_Unmarshal(TPM_ALG_ID *target, BYTE **buffer, INT32 *size)
294 {
295 return UINT16_Unmarshal((UINT16 *)target, buffer, size);
296 }
297 UINT16
TPM_ALG_ID_Marshal(TPM_ALG_ID * source,BYTE ** buffer,INT32 * size)298 TPM_ALG_ID_Marshal(TPM_ALG_ID *source, BYTE **buffer, INT32 *size)
299 {
300 return UINT16_Marshal((UINT16 *)source, buffer, size);
301 }
302 #endif // !USE_MARSHALING_DEFINES
303
304 // Table 2:10 - Definition of TPM_ECC_CURVE Constants
305 #if ALG_ECC
306 TPM_RC
TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE * target,BYTE ** buffer,INT32 * size)307 TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE *target, BYTE **buffer, INT32 *size)
308 {
309 TPM_RC result;
310 result = UINT16_Unmarshal((UINT16 *)target, buffer, size);
311 if(result == TPM_RC_SUCCESS)
312 {
313 switch(*target)
314 {
315 case TPM_ECC_NIST_P192 :
316 case TPM_ECC_NIST_P224 :
317 case TPM_ECC_NIST_P256 :
318 case TPM_ECC_NIST_P384 :
319 case TPM_ECC_NIST_P521 :
320 case TPM_ECC_BN_P256 :
321 case TPM_ECC_BN_P638 :
322 case TPM_ECC_SM2_P256 :
323 break;
324 default :
325 result = TPM_RC_CURVE;
326 break;
327 }
328 }
329 return result;
330 }
331 #if !USE_MARSHALING_DEFINES
332 UINT16
TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE * source,BYTE ** buffer,INT32 * size)333 TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE *source, BYTE **buffer, INT32 *size)
334 {
335 return UINT16_Marshal((UINT16 *)source, buffer, size);
336 }
337 #endif // !USE_MARSHALING_DEFINES
338 #endif // ALG_ECC
339
340 // Table 2:12 - Definition of TPM_CC Constants
341 #if !USE_MARSHALING_DEFINES
342 TPM_RC
TPM_CC_Unmarshal(TPM_CC * target,BYTE ** buffer,INT32 * size)343 TPM_CC_Unmarshal(TPM_CC *target, BYTE **buffer, INT32 *size)
344 {
345 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
346 }
347 UINT16
TPM_CC_Marshal(TPM_CC * source,BYTE ** buffer,INT32 * size)348 TPM_CC_Marshal(TPM_CC *source, BYTE **buffer, INT32 *size)
349 {
350 return UINT32_Marshal((UINT32 *)source, buffer, size);
351 }
352 #endif // !USE_MARSHALING_DEFINES
353
354 // Table 2:16 - Definition of TPM_RC Constants
355 #if !USE_MARSHALING_DEFINES
356 UINT16
TPM_RC_Marshal(TPM_RC * source,BYTE ** buffer,INT32 * size)357 TPM_RC_Marshal(TPM_RC *source, BYTE **buffer, INT32 *size)
358 {
359 return UINT32_Marshal((UINT32 *)source, buffer, size);
360 }
361 #endif // !USE_MARSHALING_DEFINES
362
363 // Table 2:17 - Definition of TPM_CLOCK_ADJUST Constants
364 TPM_RC
TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST * target,BYTE ** buffer,INT32 * size)365 TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST *target, BYTE **buffer, INT32 *size)
366 {
367 TPM_RC result;
368 result = INT8_Unmarshal((INT8 *)target, buffer, size);
369 if(result == TPM_RC_SUCCESS)
370 {
371 switch(*target)
372 {
373 case TPM_CLOCK_COARSE_SLOWER :
374 case TPM_CLOCK_MEDIUM_SLOWER :
375 case TPM_CLOCK_FINE_SLOWER :
376 case TPM_CLOCK_NO_CHANGE :
377 case TPM_CLOCK_FINE_FASTER :
378 case TPM_CLOCK_MEDIUM_FASTER :
379 case TPM_CLOCK_COARSE_FASTER :
380 break;
381 default :
382 result = TPM_RC_VALUE;
383 break;
384 }
385 }
386 return result;
387 }
388
389 // Table 2:18 - Definition of TPM_EO Constants
390 TPM_RC
TPM_EO_Unmarshal(TPM_EO * target,BYTE ** buffer,INT32 * size)391 TPM_EO_Unmarshal(TPM_EO *target, BYTE **buffer, INT32 *size)
392 {
393 TPM_RC result;
394 result = UINT16_Unmarshal((UINT16 *)target, buffer, size);
395 if(result == TPM_RC_SUCCESS)
396 {
397 switch(*target)
398 {
399 case TPM_EO_EQ :
400 case TPM_EO_NEQ :
401 case TPM_EO_SIGNED_GT :
402 case TPM_EO_UNSIGNED_GT :
403 case TPM_EO_SIGNED_LT :
404 case TPM_EO_UNSIGNED_LT :
405 case TPM_EO_SIGNED_GE :
406 case TPM_EO_UNSIGNED_GE :
407 case TPM_EO_SIGNED_LE :
408 case TPM_EO_UNSIGNED_LE :
409 case TPM_EO_BITSET :
410 case TPM_EO_BITCLEAR :
411 break;
412 default :
413 result = TPM_RC_VALUE;
414 break;
415 }
416 }
417 return result;
418 }
419 #if !USE_MARSHALING_DEFINES
420 UINT16
TPM_EO_Marshal(TPM_EO * source,BYTE ** buffer,INT32 * size)421 TPM_EO_Marshal(TPM_EO *source, BYTE **buffer, INT32 *size)
422 {
423 return UINT16_Marshal((UINT16 *)source, buffer, size);
424 }
425 #endif // !USE_MARSHALING_DEFINES
426
427 // Table 2:19 - Definition of TPM_ST Constants
428 #if !USE_MARSHALING_DEFINES
429 TPM_RC
TPM_ST_Unmarshal(TPM_ST * target,BYTE ** buffer,INT32 * size)430 TPM_ST_Unmarshal(TPM_ST *target, BYTE **buffer, INT32 *size)
431 {
432 return UINT16_Unmarshal((UINT16 *)target, buffer, size);
433 }
434 UINT16
TPM_ST_Marshal(TPM_ST * source,BYTE ** buffer,INT32 * size)435 TPM_ST_Marshal(TPM_ST *source, BYTE **buffer, INT32 *size)
436 {
437 return UINT16_Marshal((UINT16 *)source, buffer, size);
438 }
439 #endif // !USE_MARSHALING_DEFINES
440
441 // Table 2:20 - Definition of TPM_SU Constants
442 TPM_RC
TPM_SU_Unmarshal(TPM_SU * target,BYTE ** buffer,INT32 * size)443 TPM_SU_Unmarshal(TPM_SU *target, BYTE **buffer, INT32 *size)
444 {
445 TPM_RC result;
446 result = UINT16_Unmarshal((UINT16 *)target, buffer, size);
447 if(result == TPM_RC_SUCCESS)
448 {
449 switch(*target)
450 {
451 case TPM_SU_CLEAR :
452 case TPM_SU_STATE :
453 break;
454 default :
455 result = TPM_RC_VALUE;
456 break;
457 }
458 }
459 return result;
460 }
461
462 // Table 2:21 - Definition of TPM_SE Constants
463 TPM_RC
TPM_SE_Unmarshal(TPM_SE * target,BYTE ** buffer,INT32 * size)464 TPM_SE_Unmarshal(TPM_SE *target, BYTE **buffer, INT32 *size)
465 {
466 TPM_RC result;
467 result = UINT8_Unmarshal((UINT8 *)target, buffer, size);
468 if(result == TPM_RC_SUCCESS)
469 {
470 switch(*target)
471 {
472 case TPM_SE_HMAC :
473 case TPM_SE_POLICY :
474 case TPM_SE_TRIAL :
475 break;
476 default :
477 result = TPM_RC_VALUE;
478 break;
479 }
480 }
481 return result;
482 }
483
484 // Table 2:22 - Definition of TPM_CAP Constants
485 TPM_RC
TPM_CAP_Unmarshal(TPM_CAP * target,BYTE ** buffer,INT32 * size)486 TPM_CAP_Unmarshal(TPM_CAP *target, BYTE **buffer, INT32 *size)
487 {
488 TPM_RC result;
489 result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
490 if(result == TPM_RC_SUCCESS)
491 {
492 switch(*target)
493 {
494 case TPM_CAP_ALGS :
495 case TPM_CAP_HANDLES :
496 case TPM_CAP_COMMANDS :
497 case TPM_CAP_PP_COMMANDS :
498 case TPM_CAP_AUDIT_COMMANDS :
499 case TPM_CAP_PCRS :
500 case TPM_CAP_TPM_PROPERTIES :
501 case TPM_CAP_PCR_PROPERTIES :
502 case TPM_CAP_ECC_CURVES :
503 case TPM_CAP_AUTH_POLICIES :
504 case TPM_CAP_ACT :
505 case TPM_CAP_VENDOR_PROPERTY :
506 break;
507 default :
508 result = TPM_RC_VALUE;
509 break;
510 }
511 }
512 return result;
513 }
514 #if !USE_MARSHALING_DEFINES
515 UINT16
TPM_CAP_Marshal(TPM_CAP * source,BYTE ** buffer,INT32 * size)516 TPM_CAP_Marshal(TPM_CAP *source, BYTE **buffer, INT32 *size)
517 {
518 return UINT32_Marshal((UINT32 *)source, buffer, size);
519 }
520 #endif // !USE_MARSHALING_DEFINES
521
522 // Table 2:23 - Definition of TPM_PT Constants
523 #if !USE_MARSHALING_DEFINES
524 TPM_RC
TPM_PT_Unmarshal(TPM_PT * target,BYTE ** buffer,INT32 * size)525 TPM_PT_Unmarshal(TPM_PT *target, BYTE **buffer, INT32 *size)
526 {
527 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
528 }
529 UINT16
TPM_PT_Marshal(TPM_PT * source,BYTE ** buffer,INT32 * size)530 TPM_PT_Marshal(TPM_PT *source, BYTE **buffer, INT32 *size)
531 {
532 return UINT32_Marshal((UINT32 *)source, buffer, size);
533 }
534 #endif // !USE_MARSHALING_DEFINES
535
536 // Table 2:24 - Definition of TPM_PT_PCR Constants
537 #if !USE_MARSHALING_DEFINES
538 TPM_RC
TPM_PT_PCR_Unmarshal(TPM_PT_PCR * target,BYTE ** buffer,INT32 * size)539 TPM_PT_PCR_Unmarshal(TPM_PT_PCR *target, BYTE **buffer, INT32 *size)
540 {
541 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
542 }
543 UINT16
TPM_PT_PCR_Marshal(TPM_PT_PCR * source,BYTE ** buffer,INT32 * size)544 TPM_PT_PCR_Marshal(TPM_PT_PCR *source, BYTE **buffer, INT32 *size)
545 {
546 return UINT32_Marshal((UINT32 *)source, buffer, size);
547 }
548 #endif // !USE_MARSHALING_DEFINES
549
550 // Table 2:25 - Definition of TPM_PS Constants
551 #if !USE_MARSHALING_DEFINES
552 UINT16
TPM_PS_Marshal(TPM_PS * source,BYTE ** buffer,INT32 * size)553 TPM_PS_Marshal(TPM_PS *source, BYTE **buffer, INT32 *size)
554 {
555 return UINT32_Marshal((UINT32 *)source, buffer, size);
556 }
557 #endif // !USE_MARSHALING_DEFINES
558
559 // Table 2:26 - Definition of Types for Handles
560 #if !USE_MARSHALING_DEFINES
561 TPM_RC
TPM_HANDLE_Unmarshal(TPM_HANDLE * target,BYTE ** buffer,INT32 * size)562 TPM_HANDLE_Unmarshal(TPM_HANDLE *target, BYTE **buffer, INT32 *size)
563 {
564 return UINT32_Unmarshal((UINT32 *)target, buffer, size);
565 }
566 UINT16
TPM_HANDLE_Marshal(TPM_HANDLE * source,BYTE ** buffer,INT32 * size)567 TPM_HANDLE_Marshal(TPM_HANDLE *source, BYTE **buffer, INT32 *size)
568 {
569 return UINT32_Marshal((UINT32 *)source, buffer, size);
570 }
571 #endif // !USE_MARSHALING_DEFINES
572
573 // Table 2:27 - Definition of TPM_HT Constants
574 #if !USE_MARSHALING_DEFINES
575 TPM_RC
TPM_HT_Unmarshal(TPM_HT * target,BYTE ** buffer,INT32 * size)576 TPM_HT_Unmarshal(TPM_HT *target, BYTE **buffer, INT32 *size)
577 {
578 return UINT8_Unmarshal((UINT8 *)target, buffer, size);
579 }
580 UINT16
TPM_HT_Marshal(TPM_HT * source,BYTE ** buffer,INT32 * size)581 TPM_HT_Marshal(TPM_HT *source, BYTE **buffer, INT32 *size)
582 {
583 return UINT8_Marshal((UINT8 *)source, buffer, size);
584 }
585 #endif // !USE_MARSHALING_DEFINES
586
587 // Table 2:28 - Definition of TPM_RH Constants
588 #if !USE_MARSHALING_DEFINES
589 TPM_RC
TPM_RH_Unmarshal(TPM_RH * target,BYTE ** buffer,INT32 * size)590 TPM_RH_Unmarshal(TPM_RH *target, BYTE **buffer, INT32 *size)
591 {
592 return TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
593 }
594 UINT16
TPM_RH_Marshal(TPM_RH * source,BYTE ** buffer,INT32 * size)595 TPM_RH_Marshal(TPM_RH *source, BYTE **buffer, INT32 *size)
596 {
597 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
598 }
599 #endif // !USE_MARSHALING_DEFINES
600
601 // Table 2:29 - Definition of TPM_HC Constants
602 #if !USE_MARSHALING_DEFINES
603 TPM_RC
TPM_HC_Unmarshal(TPM_HC * target,BYTE ** buffer,INT32 * size)604 TPM_HC_Unmarshal(TPM_HC *target, BYTE **buffer, INT32 *size)
605 {
606 return TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
607 }
608 UINT16
TPM_HC_Marshal(TPM_HC * source,BYTE ** buffer,INT32 * size)609 TPM_HC_Marshal(TPM_HC *source, BYTE **buffer, INT32 *size)
610 {
611 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
612 }
613 #endif // !USE_MARSHALING_DEFINES
614
615 // Table 2:30 - Definition of TPMA_ALGORITHM Bits
616 TPM_RC
TPMA_ALGORITHM_Unmarshal(TPMA_ALGORITHM * target,BYTE ** buffer,INT32 * size)617 TPMA_ALGORITHM_Unmarshal(TPMA_ALGORITHM *target, BYTE **buffer, INT32 *size)
618 {
619 TPM_RC result;
620 result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
621 if(result == TPM_RC_SUCCESS)
622 {
623 if(*((UINT32 *)target) & (UINT32)0xfffff8f0)
624 result = TPM_RC_RESERVED_BITS;
625 }
626 return result;
627 }
628
629 #if !USE_MARSHALING_DEFINES
630 UINT16
TPMA_ALGORITHM_Marshal(TPMA_ALGORITHM * source,BYTE ** buffer,INT32 * size)631 TPMA_ALGORITHM_Marshal(TPMA_ALGORITHM *source, BYTE **buffer, INT32 *size)
632 {
633 return UINT32_Marshal((UINT32 *)source, buffer, size);
634 }
635 #endif // !USE_MARSHALING_DEFINES
636
637 // Table 2:31 - Definition of TPMA_OBJECT Bits
638 TPM_RC
TPMA_OBJECT_Unmarshal(TPMA_OBJECT * target,BYTE ** buffer,INT32 * size)639 TPMA_OBJECT_Unmarshal(TPMA_OBJECT *target, BYTE **buffer, INT32 *size)
640 {
641 TPM_RC result;
642 result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
643 if(result == TPM_RC_SUCCESS)
644 {
645 if(*((UINT32 *)target) & (UINT32)0xfff0f309)
646 result = TPM_RC_RESERVED_BITS;
647 }
648 return result;
649 }
650
651 #if !USE_MARSHALING_DEFINES
652 UINT16
TPMA_OBJECT_Marshal(TPMA_OBJECT * source,BYTE ** buffer,INT32 * size)653 TPMA_OBJECT_Marshal(TPMA_OBJECT *source, BYTE **buffer, INT32 *size)
654 {
655 return UINT32_Marshal((UINT32 *)source, buffer, size);
656 }
657 #endif // !USE_MARSHALING_DEFINES
658
659 // Table 2:32 - Definition of TPMA_SESSION Bits
660 TPM_RC
TPMA_SESSION_Unmarshal(TPMA_SESSION * target,BYTE ** buffer,INT32 * size)661 TPMA_SESSION_Unmarshal(TPMA_SESSION *target, BYTE **buffer, INT32 *size)
662 {
663 TPM_RC result;
664 result = UINT8_Unmarshal((UINT8 *)target, buffer, size);
665 if(result == TPM_RC_SUCCESS)
666 {
667 if(*((UINT8 *)target) & (UINT8)0x18)
668 result = TPM_RC_RESERVED_BITS;
669 }
670 return result;
671 }
672
673 #if !USE_MARSHALING_DEFINES
674 UINT16
TPMA_SESSION_Marshal(TPMA_SESSION * source,BYTE ** buffer,INT32 * size)675 TPMA_SESSION_Marshal(TPMA_SESSION *source, BYTE **buffer, INT32 *size)
676 {
677 return UINT8_Marshal((UINT8 *)source, buffer, size);
678 }
679 #endif // !USE_MARSHALING_DEFINES
680
681 // Table 2:33 - Definition of TPMA_LOCALITY Bits
682 #if !USE_MARSHALING_DEFINES
683 TPM_RC
TPMA_LOCALITY_Unmarshal(TPMA_LOCALITY * target,BYTE ** buffer,INT32 * size)684 TPMA_LOCALITY_Unmarshal(TPMA_LOCALITY *target, BYTE **buffer, INT32 *size)
685 {
686 return UINT8_Unmarshal((UINT8 *)target, buffer, size);
687 }
688 UINT16
TPMA_LOCALITY_Marshal(TPMA_LOCALITY * source,BYTE ** buffer,INT32 * size)689 TPMA_LOCALITY_Marshal(TPMA_LOCALITY *source, BYTE **buffer, INT32 *size)
690 {
691 return UINT8_Marshal((UINT8 *)source, buffer, size);
692 }
693 #endif // !USE_MARSHALING_DEFINES
694
695 // Table 2:34 - Definition of TPMA_PERMANENT Bits
696 #if !USE_MARSHALING_DEFINES
697 UINT16
TPMA_PERMANENT_Marshal(TPMA_PERMANENT * source,BYTE ** buffer,INT32 * size)698 TPMA_PERMANENT_Marshal(TPMA_PERMANENT *source, BYTE **buffer, INT32 *size)
699 {
700 return UINT32_Marshal((UINT32 *)source, buffer, size);
701 }
702 #endif // !USE_MARSHALING_DEFINES
703
704 // Table 2:35 - Definition of TPMA_STARTUP_CLEAR Bits
705 #if !USE_MARSHALING_DEFINES
706 UINT16
TPMA_STARTUP_CLEAR_Marshal(TPMA_STARTUP_CLEAR * source,BYTE ** buffer,INT32 * size)707 TPMA_STARTUP_CLEAR_Marshal(TPMA_STARTUP_CLEAR *source, BYTE **buffer, INT32 *size)
708 {
709 return UINT32_Marshal((UINT32 *)source, buffer, size);
710 }
711 #endif // !USE_MARSHALING_DEFINES
712
713 // Table 2:36 - Definition of TPMA_MEMORY Bits
714 #if !USE_MARSHALING_DEFINES
715 UINT16
TPMA_MEMORY_Marshal(TPMA_MEMORY * source,BYTE ** buffer,INT32 * size)716 TPMA_MEMORY_Marshal(TPMA_MEMORY *source, BYTE **buffer, INT32 *size)
717 {
718 return UINT32_Marshal((UINT32 *)source, buffer, size);
719 }
720 #endif // !USE_MARSHALING_DEFINES
721
722 // Table 2:37 - Definition of TPMA_CC Bits
723 #if !USE_MARSHALING_DEFINES
724 UINT16
TPMA_CC_Marshal(TPMA_CC * source,BYTE ** buffer,INT32 * size)725 TPMA_CC_Marshal(TPMA_CC *source, BYTE **buffer, INT32 *size)
726 {
727 return TPM_CC_Marshal((TPM_CC *)source, buffer, size);
728 }
729 #endif // !USE_MARSHALING_DEFINES
730
731 // Table 2:38 - Definition of TPMA_MODES Bits
732 #if !USE_MARSHALING_DEFINES
733 UINT16
TPMA_MODES_Marshal(TPMA_MODES * source,BYTE ** buffer,INT32 * size)734 TPMA_MODES_Marshal(TPMA_MODES *source, BYTE **buffer, INT32 *size)
735 {
736 return UINT32_Marshal((UINT32 *)source, buffer, size);
737 }
738 #endif // !USE_MARSHALING_DEFINES
739
740 // Table 2:39 - Definition of TPMA_X509_KEY_USAGE Bits
741 #if !USE_MARSHALING_DEFINES
742 UINT16
TPMA_X509_KEY_USAGE_Marshal(TPMA_X509_KEY_USAGE * source,BYTE ** buffer,INT32 * size)743 TPMA_X509_KEY_USAGE_Marshal(TPMA_X509_KEY_USAGE *source, BYTE **buffer, INT32 *size)
744 {
745 return UINT32_Marshal((UINT32 *)source, buffer, size);
746 }
747 #endif // !USE_MARSHALING_DEFINES
748
749 // Table 2:40 - Definition of TPMA_ACT Bits
750 TPM_RC
TPMA_ACT_Unmarshal(TPMA_ACT * target,BYTE ** buffer,INT32 * size)751 TPMA_ACT_Unmarshal(TPMA_ACT *target, BYTE **buffer, INT32 *size)
752 {
753 TPM_RC result;
754 result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
755 if(result == TPM_RC_SUCCESS)
756 {
757 if(*((UINT32 *)target) & (UINT32)0xfffffffc)
758 result = TPM_RC_RESERVED_BITS;
759 }
760 return result;
761 }
762
763 #if !USE_MARSHALING_DEFINES
764 UINT16
TPMA_ACT_Marshal(TPMA_ACT * source,BYTE ** buffer,INT32 * size)765 TPMA_ACT_Marshal(TPMA_ACT *source, BYTE **buffer, INT32 *size)
766 {
767 return UINT32_Marshal((UINT32 *)source, buffer, size);
768 }
769 #endif // !USE_MARSHALING_DEFINES
770
771 // Table 2:41 - Definition of TPMI_YES_NO Type
772 TPM_RC
TPMI_YES_NO_Unmarshal(TPMI_YES_NO * target,BYTE ** buffer,INT32 * size)773 TPMI_YES_NO_Unmarshal(TPMI_YES_NO *target, BYTE **buffer, INT32 *size)
774 {
775 TPM_RC result;
776 result = BYTE_Unmarshal((BYTE *)target, buffer, size);
777 if(result == TPM_RC_SUCCESS)
778 {
779 switch (*target)
780 {
781 case NO:
782 case YES:
783 break;
784 default:
785 result = TPM_RC_VALUE;
786 break;
787 }
788 }
789 return result;
790 }
791 #if !USE_MARSHALING_DEFINES
792 UINT16
TPMI_YES_NO_Marshal(TPMI_YES_NO * source,BYTE ** buffer,INT32 * size)793 TPMI_YES_NO_Marshal(TPMI_YES_NO *source, BYTE **buffer, INT32 *size)
794 {
795 return BYTE_Marshal((BYTE *)source, buffer, size);
796 }
797 #endif // !USE_MARSHALING_DEFINES
798
799 // Table 2:42 - Definition of TPMI_DH_OBJECT Type
800 TPM_RC
TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT * target,BYTE ** buffer,INT32 * size,BOOL flag)801 TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT *target, BYTE **buffer, INT32 *size, BOOL flag)
802 {
803 TPM_RC result;
804 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
805 if(result == TPM_RC_SUCCESS)
806 {
807 if(*target == TPM_RH_NULL)
808 {
809 if(!flag)
810 result = TPM_RC_VALUE;
811 }
812 else if( ((*target < TRANSIENT_FIRST) || (*target > TRANSIENT_LAST))
813 && ((*target < PERSISTENT_FIRST) || (*target > PERSISTENT_LAST)))
814 result = TPM_RC_VALUE;
815 }
816 return result;
817 }
818 #if !USE_MARSHALING_DEFINES
819 UINT16
TPMI_DH_OBJECT_Marshal(TPMI_DH_OBJECT * source,BYTE ** buffer,INT32 * size)820 TPMI_DH_OBJECT_Marshal(TPMI_DH_OBJECT *source, BYTE **buffer, INT32 *size)
821 {
822 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
823 }
824 #endif // !USE_MARSHALING_DEFINES
825
826 // Table 2:43 - Definition of TPMI_DH_PARENT Type
827 TPM_RC
TPMI_DH_PARENT_Unmarshal(TPMI_DH_PARENT * target,BYTE ** buffer,INT32 * size,BOOL flag)828 TPMI_DH_PARENT_Unmarshal(TPMI_DH_PARENT *target, BYTE **buffer, INT32 *size, BOOL flag)
829 {
830 TPM_RC result;
831 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
832 if(result == TPM_RC_SUCCESS)
833 {
834 switch (*target)
835 {
836 case TPM_RH_OWNER:
837 case TPM_RH_PLATFORM:
838 case TPM_RH_ENDORSEMENT:
839 break;
840 case TPM_RH_NULL:
841 if(!flag)
842 result = TPM_RC_VALUE;
843 break;
844 default:
845 if( ((*target < TRANSIENT_FIRST) || (*target > TRANSIENT_LAST))
846 && ((*target < PERSISTENT_FIRST) || (*target > PERSISTENT_LAST)))
847 result = TPM_RC_VALUE;
848 break;
849 }
850 }
851 return result;
852 }
853 #if !USE_MARSHALING_DEFINES
854 UINT16
TPMI_DH_PARENT_Marshal(TPMI_DH_PARENT * source,BYTE ** buffer,INT32 * size)855 TPMI_DH_PARENT_Marshal(TPMI_DH_PARENT *source, BYTE **buffer, INT32 *size)
856 {
857 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
858 }
859 #endif // !USE_MARSHALING_DEFINES
860
861 // Table 2:44 - Definition of TPMI_DH_PERSISTENT Type
862 TPM_RC
TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT * target,BYTE ** buffer,INT32 * size)863 TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT *target, BYTE **buffer, INT32 *size)
864 {
865 TPM_RC result;
866 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
867 if(result == TPM_RC_SUCCESS)
868 {
869 if((*target < PERSISTENT_FIRST) || (*target > PERSISTENT_LAST))
870 result = TPM_RC_VALUE;
871 }
872 return result;
873 }
874 #if !USE_MARSHALING_DEFINES
875 UINT16
TPMI_DH_PERSISTENT_Marshal(TPMI_DH_PERSISTENT * source,BYTE ** buffer,INT32 * size)876 TPMI_DH_PERSISTENT_Marshal(TPMI_DH_PERSISTENT *source, BYTE **buffer, INT32 *size)
877 {
878 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
879 }
880 #endif // !USE_MARSHALING_DEFINES
881
882 // Table 2:45 - Definition of TPMI_DH_ENTITY Type
883 TPM_RC
TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY * target,BYTE ** buffer,INT32 * size,BOOL flag)884 TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY *target, BYTE **buffer, INT32 *size, BOOL flag)
885 {
886 TPM_RC result;
887 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
888 if(result == TPM_RC_SUCCESS)
889 {
890 switch (*target)
891 {
892 case TPM_RH_OWNER:
893 case TPM_RH_ENDORSEMENT:
894 case TPM_RH_PLATFORM:
895 case TPM_RH_LOCKOUT:
896 break;
897 case TPM_RH_NULL:
898 if(!flag)
899 result = TPM_RC_VALUE;
900 break;
901 default:
902 if( ((*target < TRANSIENT_FIRST) || (*target > TRANSIENT_LAST))
903 && ((*target < PERSISTENT_FIRST) || (*target > PERSISTENT_LAST))
904 && ((*target < NV_INDEX_FIRST) || (*target > NV_INDEX_LAST))
905 && (*target > PCR_LAST)
906 && ((*target < TPM_RH_AUTH_00) || (*target > TPM_RH_AUTH_FF)))
907 result = TPM_RC_VALUE;
908 break;
909 }
910 }
911 return result;
912 }
913
914 // Table 2:46 - Definition of TPMI_DH_PCR Type
915 TPM_RC
TPMI_DH_PCR_Unmarshal(TPMI_DH_PCR * target,BYTE ** buffer,INT32 * size,BOOL flag)916 TPMI_DH_PCR_Unmarshal(TPMI_DH_PCR *target, BYTE **buffer, INT32 *size, BOOL flag)
917 {
918 TPM_RC result;
919 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
920 if(result == TPM_RC_SUCCESS)
921 {
922 if(*target == TPM_RH_NULL)
923 {
924 if(!flag)
925 result = TPM_RC_VALUE;
926 }
927 else if(*target > PCR_LAST)
928 result = TPM_RC_VALUE;
929 }
930 return result;
931 }
932
933 // Table 2:47 - Definition of TPMI_SH_AUTH_SESSION Type
934 TPM_RC
TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION * target,BYTE ** buffer,INT32 * size,BOOL flag)935 TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION *target, BYTE **buffer, INT32 *size, BOOL flag)
936 {
937 TPM_RC result;
938 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
939 if(result == TPM_RC_SUCCESS)
940 {
941 if(*target == TPM_RS_PW)
942 {
943 if(!flag)
944 result = TPM_RC_VALUE;
945 }
946 else if( ((*target < HMAC_SESSION_FIRST) || (*target > HMAC_SESSION_LAST))
947 && ((*target < POLICY_SESSION_FIRST) || (*target > POLICY_SESSION_LAST)))
948 result = TPM_RC_VALUE;
949 }
950 return result;
951 }
952 #if !USE_MARSHALING_DEFINES
953 UINT16
TPMI_SH_AUTH_SESSION_Marshal(TPMI_SH_AUTH_SESSION * source,BYTE ** buffer,INT32 * size)954 TPMI_SH_AUTH_SESSION_Marshal(TPMI_SH_AUTH_SESSION *source, BYTE **buffer, INT32 *size)
955 {
956 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
957 }
958 #endif // !USE_MARSHALING_DEFINES
959
960 // Table 2:48 - Definition of TPMI_SH_HMAC Type
961 TPM_RC
TPMI_SH_HMAC_Unmarshal(TPMI_SH_HMAC * target,BYTE ** buffer,INT32 * size)962 TPMI_SH_HMAC_Unmarshal(TPMI_SH_HMAC *target, BYTE **buffer, INT32 *size)
963 {
964 TPM_RC result;
965 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
966 if(result == TPM_RC_SUCCESS)
967 {
968 if((*target < HMAC_SESSION_FIRST) || (*target > HMAC_SESSION_LAST))
969 result = TPM_RC_VALUE;
970 }
971 return result;
972 }
973 #if !USE_MARSHALING_DEFINES
974 UINT16
TPMI_SH_HMAC_Marshal(TPMI_SH_HMAC * source,BYTE ** buffer,INT32 * size)975 TPMI_SH_HMAC_Marshal(TPMI_SH_HMAC *source, BYTE **buffer, INT32 *size)
976 {
977 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
978 }
979 #endif // !USE_MARSHALING_DEFINES
980
981 // Table 2:49 - Definition of TPMI_SH_POLICY Type
982 TPM_RC
TPMI_SH_POLICY_Unmarshal(TPMI_SH_POLICY * target,BYTE ** buffer,INT32 * size)983 TPMI_SH_POLICY_Unmarshal(TPMI_SH_POLICY *target, BYTE **buffer, INT32 *size)
984 {
985 TPM_RC result;
986 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
987 if(result == TPM_RC_SUCCESS)
988 {
989 if((*target < POLICY_SESSION_FIRST) || (*target > POLICY_SESSION_LAST))
990 result = TPM_RC_VALUE;
991 }
992 return result;
993 }
994 #if !USE_MARSHALING_DEFINES
995 UINT16
TPMI_SH_POLICY_Marshal(TPMI_SH_POLICY * source,BYTE ** buffer,INT32 * size)996 TPMI_SH_POLICY_Marshal(TPMI_SH_POLICY *source, BYTE **buffer, INT32 *size)
997 {
998 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
999 }
1000 #endif // !USE_MARSHALING_DEFINES
1001
1002 // Table 2:50 - Definition of TPMI_DH_CONTEXT Type
1003 TPM_RC
TPMI_DH_CONTEXT_Unmarshal(TPMI_DH_CONTEXT * target,BYTE ** buffer,INT32 * size)1004 TPMI_DH_CONTEXT_Unmarshal(TPMI_DH_CONTEXT *target, BYTE **buffer, INT32 *size)
1005 {
1006 TPM_RC result;
1007 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1008 if(result == TPM_RC_SUCCESS)
1009 {
1010 if( ((*target < HMAC_SESSION_FIRST) || (*target > HMAC_SESSION_LAST))
1011 && ((*target < POLICY_SESSION_FIRST) || (*target > POLICY_SESSION_LAST))
1012 && ((*target < TRANSIENT_FIRST) || (*target > TRANSIENT_LAST)))
1013 result = TPM_RC_VALUE;
1014 }
1015 return result;
1016 }
1017 #if !USE_MARSHALING_DEFINES
1018 UINT16
TPMI_DH_CONTEXT_Marshal(TPMI_DH_CONTEXT * source,BYTE ** buffer,INT32 * size)1019 TPMI_DH_CONTEXT_Marshal(TPMI_DH_CONTEXT *source, BYTE **buffer, INT32 *size)
1020 {
1021 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
1022 }
1023 #endif // !USE_MARSHALING_DEFINES
1024
1025 // Table 2:51 - Definition of TPMI_DH_SAVED Type
1026 TPM_RC
TPMI_DH_SAVED_Unmarshal(TPMI_DH_SAVED * target,BYTE ** buffer,INT32 * size)1027 TPMI_DH_SAVED_Unmarshal(TPMI_DH_SAVED *target, BYTE **buffer, INT32 *size)
1028 {
1029 TPM_RC result;
1030 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1031 if(result == TPM_RC_SUCCESS)
1032 {
1033 switch (*target)
1034 {
1035 case 0x80000000:
1036 case 0x80000001:
1037 case 0x80000002:
1038 break;
1039 default:
1040 if( ((*target < HMAC_SESSION_FIRST) || (*target > HMAC_SESSION_LAST))
1041 && ((*target < POLICY_SESSION_FIRST) || (*target > POLICY_SESSION_LAST)))
1042 result = TPM_RC_VALUE;
1043 break;
1044 }
1045 }
1046 return result;
1047 }
1048 #if !USE_MARSHALING_DEFINES
1049 UINT16
TPMI_DH_SAVED_Marshal(TPMI_DH_SAVED * source,BYTE ** buffer,INT32 * size)1050 TPMI_DH_SAVED_Marshal(TPMI_DH_SAVED *source, BYTE **buffer, INT32 *size)
1051 {
1052 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
1053 }
1054 #endif // !USE_MARSHALING_DEFINES
1055
1056 // Table 2:52 - Definition of TPMI_RH_HIERARCHY Type
1057 TPM_RC
TPMI_RH_HIERARCHY_Unmarshal(TPMI_RH_HIERARCHY * target,BYTE ** buffer,INT32 * size,BOOL flag)1058 TPMI_RH_HIERARCHY_Unmarshal(TPMI_RH_HIERARCHY *target, BYTE **buffer, INT32 *size, BOOL flag)
1059 {
1060 TPM_RC result;
1061 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1062 if(result == TPM_RC_SUCCESS)
1063 {
1064 switch (*target)
1065 {
1066 case TPM_RH_OWNER:
1067 case TPM_RH_PLATFORM:
1068 case TPM_RH_ENDORSEMENT:
1069 break;
1070 case TPM_RH_NULL:
1071 if(!flag)
1072 result = TPM_RC_VALUE;
1073 break;
1074 default:
1075 result = TPM_RC_VALUE;
1076 break;
1077 }
1078 }
1079 return result;
1080 }
1081 #if !USE_MARSHALING_DEFINES
1082 UINT16
TPMI_RH_HIERARCHY_Marshal(TPMI_RH_HIERARCHY * source,BYTE ** buffer,INT32 * size)1083 TPMI_RH_HIERARCHY_Marshal(TPMI_RH_HIERARCHY *source, BYTE **buffer, INT32 *size)
1084 {
1085 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
1086 }
1087 #endif // !USE_MARSHALING_DEFINES
1088
1089 // Table 2:53 - Definition of TPMI_RH_ENABLES Type
1090 TPM_RC
TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES * target,BYTE ** buffer,INT32 * size,BOOL flag)1091 TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES *target, BYTE **buffer, INT32 *size, BOOL flag)
1092 {
1093 TPM_RC result;
1094 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1095 if(result == TPM_RC_SUCCESS)
1096 {
1097 switch (*target)
1098 {
1099 case TPM_RH_OWNER:
1100 case TPM_RH_PLATFORM:
1101 case TPM_RH_ENDORSEMENT:
1102 case TPM_RH_PLATFORM_NV:
1103 break;
1104 case TPM_RH_NULL:
1105 if(!flag)
1106 result = TPM_RC_VALUE;
1107 break;
1108 default:
1109 result = TPM_RC_VALUE;
1110 break;
1111 }
1112 }
1113 return result;
1114 }
1115 #if !USE_MARSHALING_DEFINES
1116 UINT16
TPMI_RH_ENABLES_Marshal(TPMI_RH_ENABLES * source,BYTE ** buffer,INT32 * size)1117 TPMI_RH_ENABLES_Marshal(TPMI_RH_ENABLES *source, BYTE **buffer, INT32 *size)
1118 {
1119 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
1120 }
1121 #endif // !USE_MARSHALING_DEFINES
1122
1123 // Table 2:54 - Definition of TPMI_RH_HIERARCHY_AUTH Type
1124 TPM_RC
TPMI_RH_HIERARCHY_AUTH_Unmarshal(TPMI_RH_HIERARCHY_AUTH * target,BYTE ** buffer,INT32 * size)1125 TPMI_RH_HIERARCHY_AUTH_Unmarshal(TPMI_RH_HIERARCHY_AUTH *target, BYTE **buffer, INT32 *size)
1126 {
1127 TPM_RC result;
1128 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1129 if(result == TPM_RC_SUCCESS)
1130 {
1131 switch (*target)
1132 {
1133 case TPM_RH_OWNER:
1134 case TPM_RH_PLATFORM:
1135 case TPM_RH_ENDORSEMENT:
1136 case TPM_RH_LOCKOUT:
1137 break;
1138 default:
1139 result = TPM_RC_VALUE;
1140 break;
1141 }
1142 }
1143 return result;
1144 }
1145
1146 // Table 2:55 - Definition of TPMI_RH_HIERARCHY_POLICY Type
1147 TPM_RC
TPMI_RH_HIERARCHY_POLICY_Unmarshal(TPMI_RH_HIERARCHY_POLICY * target,BYTE ** buffer,INT32 * size)1148 TPMI_RH_HIERARCHY_POLICY_Unmarshal(TPMI_RH_HIERARCHY_POLICY *target, BYTE **buffer, INT32 *size)
1149 {
1150 TPM_RC result;
1151 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1152 if(result == TPM_RC_SUCCESS)
1153 {
1154 switch (*target)
1155 {
1156 case TPM_RH_OWNER:
1157 case TPM_RH_PLATFORM:
1158 case TPM_RH_ENDORSEMENT:
1159 case TPM_RH_LOCKOUT:
1160 break;
1161 default:
1162 if((*target < TPM_RH_ACT_0) || (*target > TPM_RH_ACT_F))
1163 result = TPM_RC_VALUE;
1164 break;
1165 }
1166 }
1167 return result;
1168 }
1169
1170 // Table 2:56 - Definition of TPMI_RH_PLATFORM Type
1171 TPM_RC
TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM * target,BYTE ** buffer,INT32 * size)1172 TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM *target, BYTE **buffer, INT32 *size)
1173 {
1174 TPM_RC result;
1175 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1176 if(result == TPM_RC_SUCCESS)
1177 {
1178 switch (*target)
1179 {
1180 case TPM_RH_PLATFORM:
1181 break;
1182 default:
1183 result = TPM_RC_VALUE;
1184 break;
1185 }
1186 }
1187 return result;
1188 }
1189
1190 // Table 2:57 - Definition of TPMI_RH_OWNER Type
1191 TPM_RC
TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER * target,BYTE ** buffer,INT32 * size,BOOL flag)1192 TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER *target, BYTE **buffer, INT32 *size, BOOL flag)
1193 {
1194 TPM_RC result;
1195 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1196 if(result == TPM_RC_SUCCESS)
1197 {
1198 switch (*target)
1199 {
1200 case TPM_RH_OWNER:
1201 break;
1202 case TPM_RH_NULL:
1203 if(!flag)
1204 result = TPM_RC_VALUE;
1205 break;
1206 default:
1207 result = TPM_RC_VALUE;
1208 break;
1209 }
1210 }
1211 return result;
1212 }
1213
1214 // Table 2:58 - Definition of TPMI_RH_ENDORSEMENT Type
1215 TPM_RC
TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT * target,BYTE ** buffer,INT32 * size,BOOL flag)1216 TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT *target, BYTE **buffer, INT32 *size, BOOL flag)
1217 {
1218 TPM_RC result;
1219 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1220 if(result == TPM_RC_SUCCESS)
1221 {
1222 switch (*target)
1223 {
1224 case TPM_RH_ENDORSEMENT:
1225 break;
1226 case TPM_RH_NULL:
1227 if(!flag)
1228 result = TPM_RC_VALUE;
1229 break;
1230 default:
1231 result = TPM_RC_VALUE;
1232 break;
1233 }
1234 }
1235 return result;
1236 }
1237
1238 // Table 2:59 - Definition of TPMI_RH_PROVISION Type
1239 TPM_RC
TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION * target,BYTE ** buffer,INT32 * size)1240 TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION *target, BYTE **buffer, INT32 *size)
1241 {
1242 TPM_RC result;
1243 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1244 if(result == TPM_RC_SUCCESS)
1245 {
1246 switch (*target)
1247 {
1248 case TPM_RH_OWNER:
1249 case TPM_RH_PLATFORM:
1250 break;
1251 default:
1252 result = TPM_RC_VALUE;
1253 break;
1254 }
1255 }
1256 return result;
1257 }
1258
1259 // Table 2:60 - Definition of TPMI_RH_CLEAR Type
1260 TPM_RC
TPMI_RH_CLEAR_Unmarshal(TPMI_RH_CLEAR * target,BYTE ** buffer,INT32 * size)1261 TPMI_RH_CLEAR_Unmarshal(TPMI_RH_CLEAR *target, BYTE **buffer, INT32 *size)
1262 {
1263 TPM_RC result;
1264 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1265 if(result == TPM_RC_SUCCESS)
1266 {
1267 switch (*target)
1268 {
1269 case TPM_RH_LOCKOUT:
1270 case TPM_RH_PLATFORM:
1271 break;
1272 default:
1273 result = TPM_RC_VALUE;
1274 break;
1275 }
1276 }
1277 return result;
1278 }
1279
1280 // Table 2:61 - Definition of TPMI_RH_NV_AUTH Type
1281 TPM_RC
TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH * target,BYTE ** buffer,INT32 * size)1282 TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH *target, BYTE **buffer, INT32 *size)
1283 {
1284 TPM_RC result;
1285 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1286 if(result == TPM_RC_SUCCESS)
1287 {
1288 switch (*target)
1289 {
1290 case TPM_RH_PLATFORM:
1291 case TPM_RH_OWNER:
1292 break;
1293 default:
1294 if((*target < NV_INDEX_FIRST) || (*target > NV_INDEX_LAST))
1295 result = TPM_RC_VALUE;
1296 break;
1297 }
1298 }
1299 return result;
1300 }
1301
1302 // Table 2:62 - Definition of TPMI_RH_LOCKOUT Type
1303 TPM_RC
TPMI_RH_LOCKOUT_Unmarshal(TPMI_RH_LOCKOUT * target,BYTE ** buffer,INT32 * size)1304 TPMI_RH_LOCKOUT_Unmarshal(TPMI_RH_LOCKOUT *target, BYTE **buffer, INT32 *size)
1305 {
1306 TPM_RC result;
1307 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1308 if(result == TPM_RC_SUCCESS)
1309 {
1310 switch (*target)
1311 {
1312 case TPM_RH_LOCKOUT:
1313 break;
1314 default:
1315 result = TPM_RC_VALUE;
1316 break;
1317 }
1318 }
1319 return result;
1320 }
1321
1322 // Table 2:63 - Definition of TPMI_RH_NV_INDEX Type
1323 TPM_RC
TPMI_RH_NV_INDEX_Unmarshal(TPMI_RH_NV_INDEX * target,BYTE ** buffer,INT32 * size)1324 TPMI_RH_NV_INDEX_Unmarshal(TPMI_RH_NV_INDEX *target, BYTE **buffer, INT32 *size)
1325 {
1326 TPM_RC result;
1327 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1328 if(result == TPM_RC_SUCCESS)
1329 {
1330 if((*target < NV_INDEX_FIRST) || (*target > NV_INDEX_LAST))
1331 result = TPM_RC_VALUE;
1332 }
1333 return result;
1334 }
1335 #if !USE_MARSHALING_DEFINES
1336 UINT16
TPMI_RH_NV_INDEX_Marshal(TPMI_RH_NV_INDEX * source,BYTE ** buffer,INT32 * size)1337 TPMI_RH_NV_INDEX_Marshal(TPMI_RH_NV_INDEX *source, BYTE **buffer, INT32 *size)
1338 {
1339 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
1340 }
1341 #endif // !USE_MARSHALING_DEFINES
1342
1343 // Table 2:64 - Definition of TPMI_RH_AC Type
1344 TPM_RC
TPMI_RH_AC_Unmarshal(TPMI_RH_AC * target,BYTE ** buffer,INT32 * size)1345 TPMI_RH_AC_Unmarshal(TPMI_RH_AC *target, BYTE **buffer, INT32 *size)
1346 {
1347 TPM_RC result;
1348 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1349 if(result == TPM_RC_SUCCESS)
1350 {
1351 if((*target < AC_FIRST) || (*target > AC_LAST))
1352 result = TPM_RC_VALUE;
1353 }
1354 return result;
1355 }
1356
1357 // Table 2:65 - Definition of TPMI_RH_ACT Type
1358 TPM_RC
TPMI_RH_ACT_Unmarshal(TPMI_RH_ACT * target,BYTE ** buffer,INT32 * size)1359 TPMI_RH_ACT_Unmarshal(TPMI_RH_ACT *target, BYTE **buffer, INT32 *size)
1360 {
1361 TPM_RC result;
1362 result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
1363 if(result == TPM_RC_SUCCESS)
1364 {
1365 if((*target < TPM_RH_ACT_0) || (*target > TPM_RH_ACT_F))
1366 result = TPM_RC_VALUE;
1367 }
1368 return result;
1369 }
1370 #if !USE_MARSHALING_DEFINES
1371 UINT16
TPMI_RH_ACT_Marshal(TPMI_RH_ACT * source,BYTE ** buffer,INT32 * size)1372 TPMI_RH_ACT_Marshal(TPMI_RH_ACT *source, BYTE **buffer, INT32 *size)
1373 {
1374 return TPM_HANDLE_Marshal((TPM_HANDLE *)source, buffer, size);
1375 }
1376 #endif // !USE_MARSHALING_DEFINES
1377
1378 // Table 2:66 - Definition of TPMI_ALG_HASH Type
1379 TPM_RC
TPMI_ALG_HASH_Unmarshal(TPMI_ALG_HASH * target,BYTE ** buffer,INT32 * size,BOOL flag)1380 TPMI_ALG_HASH_Unmarshal(TPMI_ALG_HASH *target, BYTE **buffer, INT32 *size, BOOL flag)
1381 {
1382 TPM_RC result;
1383 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1384 if(result == TPM_RC_SUCCESS)
1385 {
1386 switch (*target)
1387 {
1388 #if ALG_SHA1
1389 case TPM_ALG_SHA1:
1390 #endif // ALG_SHA1
1391 #if ALG_SHA256
1392 case TPM_ALG_SHA256:
1393 #endif // ALG_SHA256
1394 #if ALG_SHA384
1395 case TPM_ALG_SHA384:
1396 #endif // ALG_SHA384
1397 #if ALG_SHA512
1398 case TPM_ALG_SHA512:
1399 #endif // ALG_SHA512
1400 #if ALG_SM3_256
1401 case TPM_ALG_SM3_256:
1402 #endif // ALG_SM3_256
1403 #if ALG_SHA3_256
1404 case TPM_ALG_SHA3_256:
1405 #endif // ALG_SHA3_256
1406 #if ALG_SHA3_384
1407 case TPM_ALG_SHA3_384:
1408 #endif // ALG_SHA3_384
1409 #if ALG_SHA3_512
1410 case TPM_ALG_SHA3_512:
1411 #endif // ALG_SHA3_512
1412 break;
1413 case TPM_ALG_NULL:
1414 if(!flag)
1415 result = TPM_RC_HASH;
1416 break;
1417 default:
1418 result = TPM_RC_HASH;
1419 break;
1420 }
1421 }
1422 return result;
1423 }
1424 #if !USE_MARSHALING_DEFINES
1425 UINT16
TPMI_ALG_HASH_Marshal(TPMI_ALG_HASH * source,BYTE ** buffer,INT32 * size)1426 TPMI_ALG_HASH_Marshal(TPMI_ALG_HASH *source, BYTE **buffer, INT32 *size)
1427 {
1428 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1429 }
1430 #endif // !USE_MARSHALING_DEFINES
1431
1432 // Table 2:67 - Definition of TPMI_ALG_ASYM Type
1433 TPM_RC
TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM * target,BYTE ** buffer,INT32 * size,BOOL flag)1434 TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM *target, BYTE **buffer, INT32 *size, BOOL flag)
1435 {
1436 TPM_RC result;
1437 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1438 if(result == TPM_RC_SUCCESS)
1439 {
1440 switch (*target)
1441 {
1442 #if ALG_RSA
1443 case TPM_ALG_RSA:
1444 #endif // ALG_RSA
1445 #if ALG_ECC
1446 case TPM_ALG_ECC:
1447 #endif // ALG_ECC
1448 break;
1449 case TPM_ALG_NULL:
1450 if(!flag)
1451 result = TPM_RC_ASYMMETRIC;
1452 break;
1453 default:
1454 result = TPM_RC_ASYMMETRIC;
1455 break;
1456 }
1457 }
1458 return result;
1459 }
1460 #if !USE_MARSHALING_DEFINES
1461 UINT16
TPMI_ALG_ASYM_Marshal(TPMI_ALG_ASYM * source,BYTE ** buffer,INT32 * size)1462 TPMI_ALG_ASYM_Marshal(TPMI_ALG_ASYM *source, BYTE **buffer, INT32 *size)
1463 {
1464 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1465 }
1466 #endif // !USE_MARSHALING_DEFINES
1467
1468 // Table 2:68 - Definition of TPMI_ALG_SYM Type
1469 TPM_RC
TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM * target,BYTE ** buffer,INT32 * size,BOOL flag)1470 TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM *target, BYTE **buffer, INT32 *size, BOOL flag)
1471 {
1472 TPM_RC result;
1473 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1474 if(result == TPM_RC_SUCCESS)
1475 {
1476 switch (*target)
1477 {
1478 #if ALG_TDES
1479 case TPM_ALG_TDES:
1480 #endif // ALG_TDES
1481 #if ALG_AES
1482 case TPM_ALG_AES:
1483 #endif // ALG_AES
1484 #if ALG_SM4
1485 case TPM_ALG_SM4:
1486 #endif // ALG_SM4
1487 #if ALG_CAMELLIA
1488 case TPM_ALG_CAMELLIA:
1489 #endif // ALG_CAMELLIA
1490 #if ALG_XOR
1491 case TPM_ALG_XOR:
1492 #endif // ALG_XOR
1493 break;
1494 case TPM_ALG_NULL:
1495 if(!flag)
1496 result = TPM_RC_SYMMETRIC;
1497 break;
1498 default:
1499 result = TPM_RC_SYMMETRIC;
1500 break;
1501 }
1502 }
1503 return result;
1504 }
1505 #if !USE_MARSHALING_DEFINES
1506 UINT16
TPMI_ALG_SYM_Marshal(TPMI_ALG_SYM * source,BYTE ** buffer,INT32 * size)1507 TPMI_ALG_SYM_Marshal(TPMI_ALG_SYM *source, BYTE **buffer, INT32 *size)
1508 {
1509 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1510 }
1511 #endif // !USE_MARSHALING_DEFINES
1512
1513 // Table 2:69 - Definition of TPMI_ALG_SYM_OBJECT Type
1514 TPM_RC
TPMI_ALG_SYM_OBJECT_Unmarshal(TPMI_ALG_SYM_OBJECT * target,BYTE ** buffer,INT32 * size,BOOL flag)1515 TPMI_ALG_SYM_OBJECT_Unmarshal(TPMI_ALG_SYM_OBJECT *target, BYTE **buffer, INT32 *size, BOOL flag)
1516 {
1517 TPM_RC result;
1518 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1519 if(result == TPM_RC_SUCCESS)
1520 {
1521 switch (*target)
1522 {
1523 #if ALG_TDES
1524 case TPM_ALG_TDES:
1525 #endif // ALG_TDES
1526 #if ALG_AES
1527 case TPM_ALG_AES:
1528 #endif // ALG_AES
1529 #if ALG_SM4
1530 case TPM_ALG_SM4:
1531 #endif // ALG_SM4
1532 #if ALG_CAMELLIA
1533 case TPM_ALG_CAMELLIA:
1534 #endif // ALG_CAMELLIA
1535 break;
1536 case TPM_ALG_NULL:
1537 if(!flag)
1538 result = TPM_RC_SYMMETRIC;
1539 break;
1540 default:
1541 result = TPM_RC_SYMMETRIC;
1542 break;
1543 }
1544 }
1545 return result;
1546 }
1547 #if !USE_MARSHALING_DEFINES
1548 UINT16
TPMI_ALG_SYM_OBJECT_Marshal(TPMI_ALG_SYM_OBJECT * source,BYTE ** buffer,INT32 * size)1549 TPMI_ALG_SYM_OBJECT_Marshal(TPMI_ALG_SYM_OBJECT *source, BYTE **buffer, INT32 *size)
1550 {
1551 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1552 }
1553 #endif // !USE_MARSHALING_DEFINES
1554
1555 // Table 2:70 - Definition of TPMI_ALG_SYM_MODE Type
1556 TPM_RC
TPMI_ALG_SYM_MODE_Unmarshal(TPMI_ALG_SYM_MODE * target,BYTE ** buffer,INT32 * size,BOOL flag)1557 TPMI_ALG_SYM_MODE_Unmarshal(TPMI_ALG_SYM_MODE *target, BYTE **buffer, INT32 *size, BOOL flag)
1558 {
1559 TPM_RC result;
1560 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1561 if(result == TPM_RC_SUCCESS)
1562 {
1563 switch (*target)
1564 {
1565 #if ALG_CTR
1566 case TPM_ALG_CTR:
1567 #endif // ALG_CTR
1568 #if ALG_OFB
1569 case TPM_ALG_OFB:
1570 #endif // ALG_OFB
1571 #if ALG_CBC
1572 case TPM_ALG_CBC:
1573 #endif // ALG_CBC
1574 #if ALG_CFB
1575 case TPM_ALG_CFB:
1576 #endif // ALG_CFB
1577 #if ALG_ECB
1578 case TPM_ALG_ECB:
1579 #endif // ALG_ECB
1580 #if ALG_CMAC
1581 case TPM_ALG_CMAC:
1582 #endif // ALG_CMAC
1583 break;
1584 case TPM_ALG_NULL:
1585 if(!flag)
1586 result = TPM_RC_MODE;
1587 break;
1588 default:
1589 result = TPM_RC_MODE;
1590 break;
1591 }
1592 }
1593 return result;
1594 }
1595 #if !USE_MARSHALING_DEFINES
1596 UINT16
TPMI_ALG_SYM_MODE_Marshal(TPMI_ALG_SYM_MODE * source,BYTE ** buffer,INT32 * size)1597 TPMI_ALG_SYM_MODE_Marshal(TPMI_ALG_SYM_MODE *source, BYTE **buffer, INT32 *size)
1598 {
1599 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1600 }
1601 #endif // !USE_MARSHALING_DEFINES
1602
1603 // Table 2:71 - Definition of TPMI_ALG_KDF Type
1604 TPM_RC
TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF * target,BYTE ** buffer,INT32 * size,BOOL flag)1605 TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF *target, BYTE **buffer, INT32 *size, BOOL flag)
1606 {
1607 TPM_RC result;
1608 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1609 if(result == TPM_RC_SUCCESS)
1610 {
1611 switch (*target)
1612 {
1613 #if ALG_MGF1
1614 case TPM_ALG_MGF1:
1615 #endif // ALG_MGF1
1616 #if ALG_KDF1_SP800_56A
1617 case TPM_ALG_KDF1_SP800_56A:
1618 #endif // ALG_KDF1_SP800_56A
1619 #if ALG_KDF2
1620 case TPM_ALG_KDF2:
1621 #endif // ALG_KDF2
1622 #if ALG_KDF1_SP800_108
1623 case TPM_ALG_KDF1_SP800_108:
1624 #endif // ALG_KDF1_SP800_108
1625 break;
1626 case TPM_ALG_NULL:
1627 if(!flag)
1628 result = TPM_RC_KDF;
1629 break;
1630 default:
1631 result = TPM_RC_KDF;
1632 break;
1633 }
1634 }
1635 return result;
1636 }
1637 #if !USE_MARSHALING_DEFINES
1638 UINT16
TPMI_ALG_KDF_Marshal(TPMI_ALG_KDF * source,BYTE ** buffer,INT32 * size)1639 TPMI_ALG_KDF_Marshal(TPMI_ALG_KDF *source, BYTE **buffer, INT32 *size)
1640 {
1641 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1642 }
1643 #endif // !USE_MARSHALING_DEFINES
1644
1645 // Table 2:72 - Definition of TPMI_ALG_SIG_SCHEME Type
1646 TPM_RC
TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)1647 TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
1648 {
1649 TPM_RC result;
1650 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1651 if(result == TPM_RC_SUCCESS)
1652 {
1653 switch (*target)
1654 {
1655 #if ALG_ECDAA
1656 case TPM_ALG_ECDAA:
1657 #endif // ALG_ECDAA
1658 #if ALG_RSASSA
1659 case TPM_ALG_RSASSA:
1660 #endif // ALG_RSASSA
1661 #if ALG_RSAPSS
1662 case TPM_ALG_RSAPSS:
1663 #endif // ALG_RSAPSS
1664 #if ALG_ECDSA
1665 case TPM_ALG_ECDSA:
1666 #endif // ALG_ECDSA
1667 #if ALG_SM2
1668 case TPM_ALG_SM2:
1669 #endif // ALG_SM2
1670 #if ALG_ECSCHNORR
1671 case TPM_ALG_ECSCHNORR:
1672 #endif // ALG_ECSCHNORR
1673 #if ALG_HMAC
1674 case TPM_ALG_HMAC:
1675 #endif // ALG_HMAC
1676 break;
1677 case TPM_ALG_NULL:
1678 if(!flag)
1679 result = TPM_RC_SCHEME;
1680 break;
1681 default:
1682 result = TPM_RC_SCHEME;
1683 break;
1684 }
1685 }
1686 return result;
1687 }
1688 #if !USE_MARSHALING_DEFINES
1689 UINT16
TPMI_ALG_SIG_SCHEME_Marshal(TPMI_ALG_SIG_SCHEME * source,BYTE ** buffer,INT32 * size)1690 TPMI_ALG_SIG_SCHEME_Marshal(TPMI_ALG_SIG_SCHEME *source, BYTE **buffer, INT32 *size)
1691 {
1692 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1693 }
1694 #endif // !USE_MARSHALING_DEFINES
1695
1696 // Table 2:73 - Definition of TPMI_ECC_KEY_EXCHANGE Type
1697 #if ALG_ECC
1698 TPM_RC
TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE * target,BYTE ** buffer,INT32 * size,BOOL flag)1699 TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE *target, BYTE **buffer, INT32 *size, BOOL flag)
1700 {
1701 TPM_RC result;
1702 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1703 if(result == TPM_RC_SUCCESS)
1704 {
1705 switch (*target)
1706 {
1707 #if ALG_ECDH
1708 case TPM_ALG_ECDH:
1709 #endif // ALG_ECDH
1710 #if ALG_ECMQV
1711 case TPM_ALG_ECMQV:
1712 #endif // ALG_ECMQV
1713 #if ALG_SM2
1714 case TPM_ALG_SM2:
1715 #endif // ALG_SM2
1716 break;
1717 case TPM_ALG_NULL:
1718 if(!flag)
1719 result = TPM_RC_SCHEME;
1720 break;
1721 default:
1722 result = TPM_RC_SCHEME;
1723 break;
1724 }
1725 }
1726 return result;
1727 }
1728 #if !USE_MARSHALING_DEFINES
1729 UINT16
TPMI_ECC_KEY_EXCHANGE_Marshal(TPMI_ECC_KEY_EXCHANGE * source,BYTE ** buffer,INT32 * size)1730 TPMI_ECC_KEY_EXCHANGE_Marshal(TPMI_ECC_KEY_EXCHANGE *source, BYTE **buffer, INT32 *size)
1731 {
1732 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1733 }
1734 #endif // !USE_MARSHALING_DEFINES
1735 #endif // ALG_ECC
1736
1737 // Table 2:74 - Definition of TPMI_ST_COMMAND_TAG Type
1738 TPM_RC
TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG * target,BYTE ** buffer,INT32 * size)1739 TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG *target, BYTE **buffer, INT32 *size)
1740 {
1741 TPM_RC result;
1742 result = TPM_ST_Unmarshal((TPM_ST *)target, buffer, size);
1743 if(result == TPM_RC_SUCCESS)
1744 {
1745 switch (*target)
1746 {
1747 case TPM_ST_NO_SESSIONS:
1748 case TPM_ST_SESSIONS:
1749 break;
1750 default:
1751 result = TPM_RC_BAD_TAG;
1752 break;
1753 }
1754 }
1755 return result;
1756 }
1757 #if !USE_MARSHALING_DEFINES
1758 UINT16
TPMI_ST_COMMAND_TAG_Marshal(TPMI_ST_COMMAND_TAG * source,BYTE ** buffer,INT32 * size)1759 TPMI_ST_COMMAND_TAG_Marshal(TPMI_ST_COMMAND_TAG *source, BYTE **buffer, INT32 *size)
1760 {
1761 return TPM_ST_Marshal((TPM_ST *)source, buffer, size);
1762 }
1763 #endif // !USE_MARSHALING_DEFINES
1764
1765 // Table 2:75 - Definition of TPMI_ALG_MAC_SCHEME Type
1766 TPM_RC
TPMI_ALG_MAC_SCHEME_Unmarshal(TPMI_ALG_MAC_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)1767 TPMI_ALG_MAC_SCHEME_Unmarshal(TPMI_ALG_MAC_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
1768 {
1769 TPM_RC result;
1770 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1771 if(result == TPM_RC_SUCCESS)
1772 {
1773 switch (*target)
1774 {
1775 #if ALG_CMAC
1776 case TPM_ALG_CMAC:
1777 #endif // ALG_CMAC
1778 #if ALG_SHA1
1779 case TPM_ALG_SHA1:
1780 #endif // ALG_SHA1
1781 #if ALG_SHA256
1782 case TPM_ALG_SHA256:
1783 #endif // ALG_SHA256
1784 #if ALG_SHA384
1785 case TPM_ALG_SHA384:
1786 #endif // ALG_SHA384
1787 #if ALG_SHA512
1788 case TPM_ALG_SHA512:
1789 #endif // ALG_SHA512
1790 #if ALG_SM3_256
1791 case TPM_ALG_SM3_256:
1792 #endif // ALG_SM3_256
1793 #if ALG_SHA3_256
1794 case TPM_ALG_SHA3_256:
1795 #endif // ALG_SHA3_256
1796 #if ALG_SHA3_384
1797 case TPM_ALG_SHA3_384:
1798 #endif // ALG_SHA3_384
1799 #if ALG_SHA3_512
1800 case TPM_ALG_SHA3_512:
1801 #endif // ALG_SHA3_512
1802 break;
1803 case TPM_ALG_NULL:
1804 if(!flag)
1805 result = TPM_RC_SYMMETRIC;
1806 break;
1807 default:
1808 result = TPM_RC_SYMMETRIC;
1809 break;
1810 }
1811 }
1812 return result;
1813 }
1814 #if !USE_MARSHALING_DEFINES
1815 UINT16
TPMI_ALG_MAC_SCHEME_Marshal(TPMI_ALG_MAC_SCHEME * source,BYTE ** buffer,INT32 * size)1816 TPMI_ALG_MAC_SCHEME_Marshal(TPMI_ALG_MAC_SCHEME *source, BYTE **buffer, INT32 *size)
1817 {
1818 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1819 }
1820 #endif // !USE_MARSHALING_DEFINES
1821
1822 // Table 2:76 - Definition of TPMI_ALG_CIPHER_MODE Type
1823 TPM_RC
TPMI_ALG_CIPHER_MODE_Unmarshal(TPMI_ALG_CIPHER_MODE * target,BYTE ** buffer,INT32 * size,BOOL flag)1824 TPMI_ALG_CIPHER_MODE_Unmarshal(TPMI_ALG_CIPHER_MODE *target, BYTE **buffer, INT32 *size, BOOL flag)
1825 {
1826 TPM_RC result;
1827 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
1828 if(result == TPM_RC_SUCCESS)
1829 {
1830 switch (*target)
1831 {
1832 #if ALG_CTR
1833 case TPM_ALG_CTR:
1834 #endif // ALG_CTR
1835 #if ALG_OFB
1836 case TPM_ALG_OFB:
1837 #endif // ALG_OFB
1838 #if ALG_CBC
1839 case TPM_ALG_CBC:
1840 #endif // ALG_CBC
1841 #if ALG_CFB
1842 case TPM_ALG_CFB:
1843 #endif // ALG_CFB
1844 #if ALG_ECB
1845 case TPM_ALG_ECB:
1846 #endif // ALG_ECB
1847 break;
1848 case TPM_ALG_NULL:
1849 if(!flag)
1850 result = TPM_RC_MODE;
1851 break;
1852 default:
1853 result = TPM_RC_MODE;
1854 break;
1855 }
1856 }
1857 return result;
1858 }
1859 #if !USE_MARSHALING_DEFINES
1860 UINT16
TPMI_ALG_CIPHER_MODE_Marshal(TPMI_ALG_CIPHER_MODE * source,BYTE ** buffer,INT32 * size)1861 TPMI_ALG_CIPHER_MODE_Marshal(TPMI_ALG_CIPHER_MODE *source, BYTE **buffer, INT32 *size)
1862 {
1863 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
1864 }
1865 #endif // !USE_MARSHALING_DEFINES
1866
1867 // Table 2:77 - Definition of TPMS_EMPTY Structure
1868 TPM_RC
TPMS_EMPTY_Unmarshal(TPMS_EMPTY * target,BYTE ** buffer,INT32 * size)1869 TPMS_EMPTY_Unmarshal(TPMS_EMPTY *target, BYTE **buffer, INT32 *size)
1870 {
1871 // to prevent the compiler from complaining
1872 NOT_REFERENCED(target);
1873 NOT_REFERENCED(buffer);
1874 NOT_REFERENCED(size);
1875 return TPM_RC_SUCCESS;
1876 }
1877 UINT16
TPMS_EMPTY_Marshal(TPMS_EMPTY * source,BYTE ** buffer,INT32 * size)1878 TPMS_EMPTY_Marshal(TPMS_EMPTY *source, BYTE **buffer, INT32 *size)
1879 {
1880 // to prevent the compiler from complaining
1881 NOT_REFERENCED(source);
1882 NOT_REFERENCED(buffer);
1883 NOT_REFERENCED(size);
1884 return 0;
1885 }
1886
1887 // Table 2:78 - Definition of TPMS_ALGORITHM_DESCRIPTION Structure
1888 UINT16
TPMS_ALGORITHM_DESCRIPTION_Marshal(TPMS_ALGORITHM_DESCRIPTION * source,BYTE ** buffer,INT32 * size)1889 TPMS_ALGORITHM_DESCRIPTION_Marshal(TPMS_ALGORITHM_DESCRIPTION *source, BYTE **buffer, INT32 *size)
1890 {
1891 UINT16 result = 0;
1892 result = (UINT16)(result + TPM_ALG_ID_Marshal((TPM_ALG_ID *)&(source->alg), buffer, size));
1893 result = (UINT16)(result + TPMA_ALGORITHM_Marshal((TPMA_ALGORITHM *)&(source->attributes), buffer, size));
1894 return result;
1895 }
1896
1897 // Table 2:79 - Definition of TPMU_HA Union
1898 TPM_RC
TPMU_HA_Unmarshal(TPMU_HA * target,BYTE ** buffer,INT32 * size,UINT32 selector)1899 TPMU_HA_Unmarshal(TPMU_HA *target, BYTE **buffer, INT32 *size, UINT32 selector)
1900 {
1901 switch(selector) {
1902 #if ALG_SHA1
1903 case TPM_ALG_SHA1:
1904 return BYTE_Array_Unmarshal((BYTE *)(target->sha1), buffer, size, (INT32)SHA1_DIGEST_SIZE);
1905 #endif // ALG_SHA1
1906 #if ALG_SHA256
1907 case TPM_ALG_SHA256:
1908 return BYTE_Array_Unmarshal((BYTE *)(target->sha256), buffer, size, (INT32)SHA256_DIGEST_SIZE);
1909 #endif // ALG_SHA256
1910 #if ALG_SHA384
1911 case TPM_ALG_SHA384:
1912 return BYTE_Array_Unmarshal((BYTE *)(target->sha384), buffer, size, (INT32)SHA384_DIGEST_SIZE);
1913 #endif // ALG_SHA384
1914 #if ALG_SHA512
1915 case TPM_ALG_SHA512:
1916 return BYTE_Array_Unmarshal((BYTE *)(target->sha512), buffer, size, (INT32)SHA512_DIGEST_SIZE);
1917 #endif // ALG_SHA512
1918 #if ALG_SM3_256
1919 case TPM_ALG_SM3_256:
1920 return BYTE_Array_Unmarshal((BYTE *)(target->sm3_256), buffer, size, (INT32)SM3_256_DIGEST_SIZE);
1921 #endif // ALG_SM3_256
1922 #if ALG_SHA3_256
1923 case TPM_ALG_SHA3_256:
1924 return BYTE_Array_Unmarshal((BYTE *)(target->sha3_256), buffer, size, (INT32)SHA3_256_DIGEST_SIZE);
1925 #endif // ALG_SHA3_256
1926 #if ALG_SHA3_384
1927 case TPM_ALG_SHA3_384:
1928 return BYTE_Array_Unmarshal((BYTE *)(target->sha3_384), buffer, size, (INT32)SHA3_384_DIGEST_SIZE);
1929 #endif // ALG_SHA3_384
1930 #if ALG_SHA3_512
1931 case TPM_ALG_SHA3_512:
1932 return BYTE_Array_Unmarshal((BYTE *)(target->sha3_512), buffer, size, (INT32)SHA3_512_DIGEST_SIZE);
1933 #endif // ALG_SHA3_512
1934 case TPM_ALG_NULL:
1935 return TPM_RC_SUCCESS;
1936 }
1937 return TPM_RC_SELECTOR;
1938 }
1939 UINT16
TPMU_HA_Marshal(TPMU_HA * source,BYTE ** buffer,INT32 * size,UINT32 selector)1940 TPMU_HA_Marshal(TPMU_HA *source, BYTE **buffer, INT32 *size, UINT32 selector)
1941 {
1942 switch(selector) {
1943 #if ALG_SHA1
1944 case TPM_ALG_SHA1:
1945 return BYTE_Array_Marshal((BYTE *)(source->sha1), buffer, size, (INT32)SHA1_DIGEST_SIZE);
1946 #endif // ALG_SHA1
1947 #if ALG_SHA256
1948 case TPM_ALG_SHA256:
1949 return BYTE_Array_Marshal((BYTE *)(source->sha256), buffer, size, (INT32)SHA256_DIGEST_SIZE);
1950 #endif // ALG_SHA256
1951 #if ALG_SHA384
1952 case TPM_ALG_SHA384:
1953 return BYTE_Array_Marshal((BYTE *)(source->sha384), buffer, size, (INT32)SHA384_DIGEST_SIZE);
1954 #endif // ALG_SHA384
1955 #if ALG_SHA512
1956 case TPM_ALG_SHA512:
1957 return BYTE_Array_Marshal((BYTE *)(source->sha512), buffer, size, (INT32)SHA512_DIGEST_SIZE);
1958 #endif // ALG_SHA512
1959 #if ALG_SM3_256
1960 case TPM_ALG_SM3_256:
1961 return BYTE_Array_Marshal((BYTE *)(source->sm3_256), buffer, size, (INT32)SM3_256_DIGEST_SIZE);
1962 #endif // ALG_SM3_256
1963 #if ALG_SHA3_256
1964 case TPM_ALG_SHA3_256:
1965 return BYTE_Array_Marshal((BYTE *)(source->sha3_256), buffer, size, (INT32)SHA3_256_DIGEST_SIZE);
1966 #endif // ALG_SHA3_256
1967 #if ALG_SHA3_384
1968 case TPM_ALG_SHA3_384:
1969 return BYTE_Array_Marshal((BYTE *)(source->sha3_384), buffer, size, (INT32)SHA3_384_DIGEST_SIZE);
1970 #endif // ALG_SHA3_384
1971 #if ALG_SHA3_512
1972 case TPM_ALG_SHA3_512:
1973 return BYTE_Array_Marshal((BYTE *)(source->sha3_512), buffer, size, (INT32)SHA3_512_DIGEST_SIZE);
1974 #endif // ALG_SHA3_512
1975 case TPM_ALG_NULL:
1976 return 0;
1977 }
1978 return 0;
1979 }
1980
1981 // Table 2:80 - Definition of TPMT_HA Structure
1982 TPM_RC
TPMT_HA_Unmarshal(TPMT_HA * target,BYTE ** buffer,INT32 * size,BOOL flag)1983 TPMT_HA_Unmarshal(TPMT_HA *target, BYTE **buffer, INT32 *size, BOOL flag)
1984 {
1985 TPM_RC result;
1986 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->hashAlg), buffer, size, flag);
1987 if(result == TPM_RC_SUCCESS)
1988 result = TPMU_HA_Unmarshal((TPMU_HA *)&(target->digest), buffer, size, (UINT32)target->hashAlg);
1989 return result;
1990 }
1991 UINT16
TPMT_HA_Marshal(TPMT_HA * source,BYTE ** buffer,INT32 * size)1992 TPMT_HA_Marshal(TPMT_HA *source, BYTE **buffer, INT32 *size)
1993 {
1994 UINT16 result = 0;
1995 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->hashAlg), buffer, size));
1996 result = (UINT16)(result + TPMU_HA_Marshal((TPMU_HA *)&(source->digest), buffer, size, (UINT32)source->hashAlg));
1997 return result;
1998 }
1999
2000 // Table 2:81 - Definition of TPM2B_DIGEST Structure
2001 TPM_RC
TPM2B_DIGEST_Unmarshal(TPM2B_DIGEST * target,BYTE ** buffer,INT32 * size)2002 TPM2B_DIGEST_Unmarshal(TPM2B_DIGEST *target, BYTE **buffer, INT32 *size)
2003 {
2004 TPM_RC result;
2005 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2006 if(result == TPM_RC_SUCCESS)
2007 {
2008 if((target->t.size) > sizeof(TPMU_HA))
2009 result = TPM_RC_SIZE;
2010 else
2011 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
2012 }
2013 return result;
2014 }
2015 UINT16
TPM2B_DIGEST_Marshal(TPM2B_DIGEST * source,BYTE ** buffer,INT32 * size)2016 TPM2B_DIGEST_Marshal(TPM2B_DIGEST *source, BYTE **buffer, INT32 *size)
2017 {
2018 UINT16 result = 0;
2019 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2020 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2021 if(source->t.size == 0)
2022 return result;
2023 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
2024 return result;
2025 }
2026
2027 // Table 2:82 - Definition of TPM2B_DATA Structure
2028 TPM_RC
TPM2B_DATA_Unmarshal(TPM2B_DATA * target,BYTE ** buffer,INT32 * size)2029 TPM2B_DATA_Unmarshal(TPM2B_DATA *target, BYTE **buffer, INT32 *size)
2030 {
2031 TPM_RC result;
2032 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2033 if(result == TPM_RC_SUCCESS)
2034 {
2035 if((target->t.size) > sizeof(TPMT_HA))
2036 result = TPM_RC_SIZE;
2037 else
2038 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
2039 }
2040 return result;
2041 }
2042 UINT16
TPM2B_DATA_Marshal(TPM2B_DATA * source,BYTE ** buffer,INT32 * size)2043 TPM2B_DATA_Marshal(TPM2B_DATA *source, BYTE **buffer, INT32 *size)
2044 {
2045 UINT16 result = 0;
2046 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2047 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2048 if(source->t.size == 0)
2049 return result;
2050 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
2051 return result;
2052 }
2053
2054 // Table 2:83 - Definition of Types for TPM2B_NONCE
2055 #if !USE_MARSHALING_DEFINES
2056 TPM_RC
TPM2B_NONCE_Unmarshal(TPM2B_NONCE * target,BYTE ** buffer,INT32 * size)2057 TPM2B_NONCE_Unmarshal(TPM2B_NONCE *target, BYTE **buffer, INT32 *size)
2058 {
2059 return TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)target, buffer, size);
2060 }
2061 UINT16
TPM2B_NONCE_Marshal(TPM2B_NONCE * source,BYTE ** buffer,INT32 * size)2062 TPM2B_NONCE_Marshal(TPM2B_NONCE *source, BYTE **buffer, INT32 *size)
2063 {
2064 return TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)source, buffer, size);
2065 }
2066 #endif // !USE_MARSHALING_DEFINES
2067
2068 // Table 2:84 - Definition of Types for TPM2B_AUTH
2069 #if !USE_MARSHALING_DEFINES
2070 TPM_RC
TPM2B_AUTH_Unmarshal(TPM2B_AUTH * target,BYTE ** buffer,INT32 * size)2071 TPM2B_AUTH_Unmarshal(TPM2B_AUTH *target, BYTE **buffer, INT32 *size)
2072 {
2073 return TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)target, buffer, size);
2074 }
2075 UINT16
TPM2B_AUTH_Marshal(TPM2B_AUTH * source,BYTE ** buffer,INT32 * size)2076 TPM2B_AUTH_Marshal(TPM2B_AUTH *source, BYTE **buffer, INT32 *size)
2077 {
2078 return TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)source, buffer, size);
2079 }
2080 #endif // !USE_MARSHALING_DEFINES
2081
2082 // Table 2:85 - Definition of Types for TPM2B_OPERAND
2083 #if !USE_MARSHALING_DEFINES
2084 TPM_RC
TPM2B_OPERAND_Unmarshal(TPM2B_OPERAND * target,BYTE ** buffer,INT32 * size)2085 TPM2B_OPERAND_Unmarshal(TPM2B_OPERAND *target, BYTE **buffer, INT32 *size)
2086 {
2087 return TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)target, buffer, size);
2088 }
2089 UINT16
TPM2B_OPERAND_Marshal(TPM2B_OPERAND * source,BYTE ** buffer,INT32 * size)2090 TPM2B_OPERAND_Marshal(TPM2B_OPERAND *source, BYTE **buffer, INT32 *size)
2091 {
2092 return TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)source, buffer, size);
2093 }
2094 #endif // !USE_MARSHALING_DEFINES
2095
2096 // Table 2:86 - Definition of TPM2B_EVENT Structure
2097 TPM_RC
TPM2B_EVENT_Unmarshal(TPM2B_EVENT * target,BYTE ** buffer,INT32 * size)2098 TPM2B_EVENT_Unmarshal(TPM2B_EVENT *target, BYTE **buffer, INT32 *size)
2099 {
2100 TPM_RC result;
2101 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2102 if(result == TPM_RC_SUCCESS)
2103 {
2104 if((target->t.size) > 1024)
2105 result = TPM_RC_SIZE;
2106 else
2107 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
2108 }
2109 return result;
2110 }
2111 UINT16
TPM2B_EVENT_Marshal(TPM2B_EVENT * source,BYTE ** buffer,INT32 * size)2112 TPM2B_EVENT_Marshal(TPM2B_EVENT *source, BYTE **buffer, INT32 *size)
2113 {
2114 UINT16 result = 0;
2115 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2116 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2117 if(source->t.size == 0)
2118 return result;
2119 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
2120 return result;
2121 }
2122
2123 // Table 2:87 - Definition of TPM2B_MAX_BUFFER Structure
2124 TPM_RC
TPM2B_MAX_BUFFER_Unmarshal(TPM2B_MAX_BUFFER * target,BYTE ** buffer,INT32 * size)2125 TPM2B_MAX_BUFFER_Unmarshal(TPM2B_MAX_BUFFER *target, BYTE **buffer, INT32 *size)
2126 {
2127 TPM_RC result;
2128 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2129 if(result == TPM_RC_SUCCESS)
2130 {
2131 if((target->t.size) > MAX_DIGEST_BUFFER)
2132 result = TPM_RC_SIZE;
2133 else
2134 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
2135 }
2136 return result;
2137 }
2138 UINT16
TPM2B_MAX_BUFFER_Marshal(TPM2B_MAX_BUFFER * source,BYTE ** buffer,INT32 * size)2139 TPM2B_MAX_BUFFER_Marshal(TPM2B_MAX_BUFFER *source, BYTE **buffer, INT32 *size)
2140 {
2141 UINT16 result = 0;
2142 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2143 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2144 if(source->t.size == 0)
2145 return result;
2146 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
2147 return result;
2148 }
2149
2150 // Table 2:88 - Definition of TPM2B_MAX_NV_BUFFER Structure
2151 TPM_RC
TPM2B_MAX_NV_BUFFER_Unmarshal(TPM2B_MAX_NV_BUFFER * target,BYTE ** buffer,INT32 * size)2152 TPM2B_MAX_NV_BUFFER_Unmarshal(TPM2B_MAX_NV_BUFFER *target, BYTE **buffer, INT32 *size)
2153 {
2154 TPM_RC result;
2155 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2156 if(result == TPM_RC_SUCCESS)
2157 {
2158 if((target->t.size) > MAX_NV_BUFFER_SIZE)
2159 result = TPM_RC_SIZE;
2160 else
2161 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
2162 }
2163 return result;
2164 }
2165 UINT16
TPM2B_MAX_NV_BUFFER_Marshal(TPM2B_MAX_NV_BUFFER * source,BYTE ** buffer,INT32 * size)2166 TPM2B_MAX_NV_BUFFER_Marshal(TPM2B_MAX_NV_BUFFER *source, BYTE **buffer, INT32 *size)
2167 {
2168 UINT16 result = 0;
2169 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2170 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2171 if(source->t.size == 0)
2172 return result;
2173 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
2174 return result;
2175 }
2176
2177 // Table 2:89 - Definition of TPM2B_TIMEOUT Structure
2178 TPM_RC
TPM2B_TIMEOUT_Unmarshal(TPM2B_TIMEOUT * target,BYTE ** buffer,INT32 * size)2179 TPM2B_TIMEOUT_Unmarshal(TPM2B_TIMEOUT *target, BYTE **buffer, INT32 *size)
2180 {
2181 TPM_RC result;
2182 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2183 if(result == TPM_RC_SUCCESS)
2184 {
2185 if((target->t.size) > sizeof(UINT64))
2186 result = TPM_RC_SIZE;
2187 else
2188 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
2189 }
2190 return result;
2191 }
2192 UINT16
TPM2B_TIMEOUT_Marshal(TPM2B_TIMEOUT * source,BYTE ** buffer,INT32 * size)2193 TPM2B_TIMEOUT_Marshal(TPM2B_TIMEOUT *source, BYTE **buffer, INT32 *size)
2194 {
2195 UINT16 result = 0;
2196 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2197 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2198 if(source->t.size == 0)
2199 return result;
2200 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
2201 return result;
2202 }
2203
2204 // Table 2:90 - Definition of TPM2B_IV Structure
2205 TPM_RC
TPM2B_IV_Unmarshal(TPM2B_IV * target,BYTE ** buffer,INT32 * size)2206 TPM2B_IV_Unmarshal(TPM2B_IV *target, BYTE **buffer, INT32 *size)
2207 {
2208 TPM_RC result;
2209 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2210 if(result == TPM_RC_SUCCESS)
2211 {
2212 if((target->t.size) > MAX_SYM_BLOCK_SIZE)
2213 result = TPM_RC_SIZE;
2214 else
2215 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
2216 }
2217 return result;
2218 }
2219 UINT16
TPM2B_IV_Marshal(TPM2B_IV * source,BYTE ** buffer,INT32 * size)2220 TPM2B_IV_Marshal(TPM2B_IV *source, BYTE **buffer, INT32 *size)
2221 {
2222 UINT16 result = 0;
2223 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2224 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2225 if(source->t.size == 0)
2226 return result;
2227 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
2228 return result;
2229 }
2230
2231 // Table 2:91 - Definition of TPMU_NAME Union
2232 // Table 2:92 - Definition of TPM2B_NAME Structure
2233 TPM_RC
TPM2B_NAME_Unmarshal(TPM2B_NAME * target,BYTE ** buffer,INT32 * size)2234 TPM2B_NAME_Unmarshal(TPM2B_NAME *target, BYTE **buffer, INT32 *size)
2235 {
2236 TPM_RC result;
2237 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
2238 if(result == TPM_RC_SUCCESS)
2239 {
2240 if((target->t.size) > sizeof(TPMU_NAME))
2241 result = TPM_RC_SIZE;
2242 else
2243 result = BYTE_Array_Unmarshal((BYTE *)(target->t.name), buffer, size, (INT32)(target->t.size));
2244 }
2245 return result;
2246 }
2247 UINT16
TPM2B_NAME_Marshal(TPM2B_NAME * source,BYTE ** buffer,INT32 * size)2248 TPM2B_NAME_Marshal(TPM2B_NAME *source, BYTE **buffer, INT32 *size)
2249 {
2250 UINT16 result = 0;
2251 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2252 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2253 if(source->t.size == 0)
2254 return result;
2255 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.name), buffer, size, (INT32)(source->t.size)));
2256 return result;
2257 }
2258
2259 // Table 2:93 - Definition of TPMS_PCR_SELECT Structure
2260 TPM_RC
TPMS_PCR_SELECT_Unmarshal(TPMS_PCR_SELECT * target,BYTE ** buffer,INT32 * size)2261 TPMS_PCR_SELECT_Unmarshal(TPMS_PCR_SELECT *target, BYTE **buffer, INT32 *size)
2262 {
2263 TPM_RC result;
2264 result = UINT8_Unmarshal((UINT8 *)&(target->sizeofSelect), buffer, size);
2265 if( (result == TPM_RC_SUCCESS)
2266 && (target->sizeofSelect < PCR_SELECT_MIN))
2267 result = TPM_RC_VALUE;
2268 if(result == TPM_RC_SUCCESS)
2269 {
2270 if((target->sizeofSelect) > PCR_SELECT_MAX)
2271 result = TPM_RC_VALUE;
2272 else
2273 result = BYTE_Array_Unmarshal((BYTE *)(target->pcrSelect), buffer, size, (INT32)(target->sizeofSelect));
2274 }
2275 return result;
2276 }
2277 UINT16
TPMS_PCR_SELECT_Marshal(TPMS_PCR_SELECT * source,BYTE ** buffer,INT32 * size)2278 TPMS_PCR_SELECT_Marshal(TPMS_PCR_SELECT *source, BYTE **buffer, INT32 *size)
2279 {
2280 UINT16 result = 0;
2281 result = (UINT16)(result + UINT8_Marshal((UINT8 *)&(source->sizeofSelect), buffer, size));
2282 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->pcrSelect), buffer, size, (INT32)(source->sizeofSelect)));
2283 return result;
2284 }
2285
2286 // Table 2:94 - Definition of TPMS_PCR_SELECTION Structure
2287 TPM_RC
TPMS_PCR_SELECTION_Unmarshal(TPMS_PCR_SELECTION * target,BYTE ** buffer,INT32 * size)2288 TPMS_PCR_SELECTION_Unmarshal(TPMS_PCR_SELECTION *target, BYTE **buffer, INT32 *size)
2289 {
2290 TPM_RC result;
2291 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->hash), buffer, size, 0);
2292 if(result == TPM_RC_SUCCESS)
2293 result = UINT8_Unmarshal((UINT8 *)&(target->sizeofSelect), buffer, size);
2294 if( (result == TPM_RC_SUCCESS)
2295 && (target->sizeofSelect < PCR_SELECT_MIN))
2296 result = TPM_RC_VALUE;
2297 if(result == TPM_RC_SUCCESS)
2298 {
2299 if((target->sizeofSelect) > PCR_SELECT_MAX)
2300 result = TPM_RC_VALUE;
2301 else
2302 result = BYTE_Array_Unmarshal((BYTE *)(target->pcrSelect), buffer, size, (INT32)(target->sizeofSelect));
2303 }
2304 return result;
2305 }
2306 UINT16
TPMS_PCR_SELECTION_Marshal(TPMS_PCR_SELECTION * source,BYTE ** buffer,INT32 * size)2307 TPMS_PCR_SELECTION_Marshal(TPMS_PCR_SELECTION *source, BYTE **buffer, INT32 *size)
2308 {
2309 UINT16 result = 0;
2310 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->hash), buffer, size));
2311 result = (UINT16)(result + UINT8_Marshal((UINT8 *)&(source->sizeofSelect), buffer, size));
2312 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->pcrSelect), buffer, size, (INT32)(source->sizeofSelect)));
2313 return result;
2314 }
2315
2316 // Table 2:97 - Definition of TPMT_TK_CREATION Structure
2317 TPM_RC
TPMT_TK_CREATION_Unmarshal(TPMT_TK_CREATION * target,BYTE ** buffer,INT32 * size)2318 TPMT_TK_CREATION_Unmarshal(TPMT_TK_CREATION *target, BYTE **buffer, INT32 *size)
2319 {
2320 TPM_RC result;
2321 result = TPM_ST_Unmarshal((TPM_ST *)&(target->tag), buffer, size);
2322 if( (result == TPM_RC_SUCCESS)
2323 && (target->tag != TPM_ST_CREATION))
2324 result = TPM_RC_TAG;
2325 if(result == TPM_RC_SUCCESS)
2326 result = TPMI_RH_HIERARCHY_Unmarshal((TPMI_RH_HIERARCHY *)&(target->hierarchy), buffer, size, 1);
2327 if(result == TPM_RC_SUCCESS)
2328 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->digest), buffer, size);
2329 return result;
2330 }
2331 UINT16
TPMT_TK_CREATION_Marshal(TPMT_TK_CREATION * source,BYTE ** buffer,INT32 * size)2332 TPMT_TK_CREATION_Marshal(TPMT_TK_CREATION *source, BYTE **buffer, INT32 *size)
2333 {
2334 UINT16 result = 0;
2335 result = (UINT16)(result + TPM_ST_Marshal((TPM_ST *)&(source->tag), buffer, size));
2336 result = (UINT16)(result + TPMI_RH_HIERARCHY_Marshal((TPMI_RH_HIERARCHY *)&(source->hierarchy), buffer, size));
2337 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->digest), buffer, size));
2338 return result;
2339 }
2340
2341 // Table 2:98 - Definition of TPMT_TK_VERIFIED Structure
2342 TPM_RC
TPMT_TK_VERIFIED_Unmarshal(TPMT_TK_VERIFIED * target,BYTE ** buffer,INT32 * size)2343 TPMT_TK_VERIFIED_Unmarshal(TPMT_TK_VERIFIED *target, BYTE **buffer, INT32 *size)
2344 {
2345 TPM_RC result;
2346 result = TPM_ST_Unmarshal((TPM_ST *)&(target->tag), buffer, size);
2347 if( (result == TPM_RC_SUCCESS)
2348 && (target->tag != TPM_ST_VERIFIED))
2349 result = TPM_RC_TAG;
2350 if(result == TPM_RC_SUCCESS)
2351 result = TPMI_RH_HIERARCHY_Unmarshal((TPMI_RH_HIERARCHY *)&(target->hierarchy), buffer, size, 1);
2352 if(result == TPM_RC_SUCCESS)
2353 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->digest), buffer, size);
2354 return result;
2355 }
2356 UINT16
TPMT_TK_VERIFIED_Marshal(TPMT_TK_VERIFIED * source,BYTE ** buffer,INT32 * size)2357 TPMT_TK_VERIFIED_Marshal(TPMT_TK_VERIFIED *source, BYTE **buffer, INT32 *size)
2358 {
2359 UINT16 result = 0;
2360 result = (UINT16)(result + TPM_ST_Marshal((TPM_ST *)&(source->tag), buffer, size));
2361 result = (UINT16)(result + TPMI_RH_HIERARCHY_Marshal((TPMI_RH_HIERARCHY *)&(source->hierarchy), buffer, size));
2362 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->digest), buffer, size));
2363 return result;
2364 }
2365
2366 // Table 2:99 - Definition of TPMT_TK_AUTH Structure
2367 TPM_RC
TPMT_TK_AUTH_Unmarshal(TPMT_TK_AUTH * target,BYTE ** buffer,INT32 * size)2368 TPMT_TK_AUTH_Unmarshal(TPMT_TK_AUTH *target, BYTE **buffer, INT32 *size)
2369 {
2370 TPM_RC result;
2371 result = TPM_ST_Unmarshal((TPM_ST *)&(target->tag), buffer, size);
2372 if( (result == TPM_RC_SUCCESS)
2373 && (target->tag != TPM_ST_AUTH_SIGNED)
2374 && (target->tag != TPM_ST_AUTH_SECRET))
2375 result = TPM_RC_TAG;
2376 if(result == TPM_RC_SUCCESS)
2377 result = TPMI_RH_HIERARCHY_Unmarshal((TPMI_RH_HIERARCHY *)&(target->hierarchy), buffer, size, 1);
2378 if(result == TPM_RC_SUCCESS)
2379 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->digest), buffer, size);
2380 return result;
2381 }
2382 UINT16
TPMT_TK_AUTH_Marshal(TPMT_TK_AUTH * source,BYTE ** buffer,INT32 * size)2383 TPMT_TK_AUTH_Marshal(TPMT_TK_AUTH *source, BYTE **buffer, INT32 *size)
2384 {
2385 UINT16 result = 0;
2386 result = (UINT16)(result + TPM_ST_Marshal((TPM_ST *)&(source->tag), buffer, size));
2387 result = (UINT16)(result + TPMI_RH_HIERARCHY_Marshal((TPMI_RH_HIERARCHY *)&(source->hierarchy), buffer, size));
2388 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->digest), buffer, size));
2389 return result;
2390 }
2391
2392 // Table 2:100 - Definition of TPMT_TK_HASHCHECK Structure
2393 TPM_RC
TPMT_TK_HASHCHECK_Unmarshal(TPMT_TK_HASHCHECK * target,BYTE ** buffer,INT32 * size)2394 TPMT_TK_HASHCHECK_Unmarshal(TPMT_TK_HASHCHECK *target, BYTE **buffer, INT32 *size)
2395 {
2396 TPM_RC result;
2397 result = TPM_ST_Unmarshal((TPM_ST *)&(target->tag), buffer, size);
2398 if( (result == TPM_RC_SUCCESS)
2399 && (target->tag != TPM_ST_HASHCHECK))
2400 result = TPM_RC_TAG;
2401 if(result == TPM_RC_SUCCESS)
2402 result = TPMI_RH_HIERARCHY_Unmarshal((TPMI_RH_HIERARCHY *)&(target->hierarchy), buffer, size, 1);
2403 if(result == TPM_RC_SUCCESS)
2404 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->digest), buffer, size);
2405 return result;
2406 }
2407 UINT16
TPMT_TK_HASHCHECK_Marshal(TPMT_TK_HASHCHECK * source,BYTE ** buffer,INT32 * size)2408 TPMT_TK_HASHCHECK_Marshal(TPMT_TK_HASHCHECK *source, BYTE **buffer, INT32 *size)
2409 {
2410 UINT16 result = 0;
2411 result = (UINT16)(result + TPM_ST_Marshal((TPM_ST *)&(source->tag), buffer, size));
2412 result = (UINT16)(result + TPMI_RH_HIERARCHY_Marshal((TPMI_RH_HIERARCHY *)&(source->hierarchy), buffer, size));
2413 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->digest), buffer, size));
2414 return result;
2415 }
2416
2417 // Table 2:101 - Definition of TPMS_ALG_PROPERTY Structure
2418 UINT16
TPMS_ALG_PROPERTY_Marshal(TPMS_ALG_PROPERTY * source,BYTE ** buffer,INT32 * size)2419 TPMS_ALG_PROPERTY_Marshal(TPMS_ALG_PROPERTY *source, BYTE **buffer, INT32 *size)
2420 {
2421 UINT16 result = 0;
2422 result = (UINT16)(result + TPM_ALG_ID_Marshal((TPM_ALG_ID *)&(source->alg), buffer, size));
2423 result = (UINT16)(result + TPMA_ALGORITHM_Marshal((TPMA_ALGORITHM *)&(source->algProperties), buffer, size));
2424 return result;
2425 }
2426
2427 // Table 2:102 - Definition of TPMS_TAGGED_PROPERTY Structure
2428 UINT16
TPMS_TAGGED_PROPERTY_Marshal(TPMS_TAGGED_PROPERTY * source,BYTE ** buffer,INT32 * size)2429 TPMS_TAGGED_PROPERTY_Marshal(TPMS_TAGGED_PROPERTY *source, BYTE **buffer, INT32 *size)
2430 {
2431 UINT16 result = 0;
2432 result = (UINT16)(result + TPM_PT_Marshal((TPM_PT *)&(source->property), buffer, size));
2433 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->value), buffer, size));
2434 return result;
2435 }
2436
2437 // Table 2:103 - Definition of TPMS_TAGGED_PCR_SELECT Structure
2438 UINT16
TPMS_TAGGED_PCR_SELECT_Marshal(TPMS_TAGGED_PCR_SELECT * source,BYTE ** buffer,INT32 * size)2439 TPMS_TAGGED_PCR_SELECT_Marshal(TPMS_TAGGED_PCR_SELECT *source, BYTE **buffer, INT32 *size)
2440 {
2441 UINT16 result = 0;
2442 result = (UINT16)(result + TPM_PT_PCR_Marshal((TPM_PT_PCR *)&(source->tag), buffer, size));
2443 result = (UINT16)(result + UINT8_Marshal((UINT8 *)&(source->sizeofSelect), buffer, size));
2444 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->pcrSelect), buffer, size, (INT32)(source->sizeofSelect)));
2445 return result;
2446 }
2447
2448 // Table 2:104 - Definition of TPMS_TAGGED_POLICY Structure
2449 UINT16
TPMS_TAGGED_POLICY_Marshal(TPMS_TAGGED_POLICY * source,BYTE ** buffer,INT32 * size)2450 TPMS_TAGGED_POLICY_Marshal(TPMS_TAGGED_POLICY *source, BYTE **buffer, INT32 *size)
2451 {
2452 UINT16 result = 0;
2453 result = (UINT16)(result + TPM_HANDLE_Marshal((TPM_HANDLE *)&(source->handle), buffer, size));
2454 result = (UINT16)(result + TPMT_HA_Marshal((TPMT_HA *)&(source->policyHash), buffer, size));
2455 return result;
2456 }
2457
2458 // Table 2:105 - Definition of TPMS_ACT_DATA Structure
2459 UINT16
TPMS_ACT_DATA_Marshal(TPMS_ACT_DATA * source,BYTE ** buffer,INT32 * size)2460 TPMS_ACT_DATA_Marshal(TPMS_ACT_DATA *source, BYTE **buffer, INT32 *size)
2461 {
2462 UINT16 result = 0;
2463 result = (UINT16)(result + TPM_HANDLE_Marshal((TPM_HANDLE *)&(source->handle), buffer, size));
2464 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->timeout), buffer, size));
2465 result = (UINT16)(result + TPMA_ACT_Marshal((TPMA_ACT *)&(source->attributes), buffer, size));
2466 return result;
2467 }
2468
2469 // Table 2:106 - Definition of TPML_CC Structure
2470 TPM_RC
TPML_CC_Unmarshal(TPML_CC * target,BYTE ** buffer,INT32 * size)2471 TPML_CC_Unmarshal(TPML_CC *target, BYTE **buffer, INT32 *size)
2472 {
2473 TPM_RC result;
2474 result = UINT32_Unmarshal((UINT32 *)&(target->count), buffer, size);
2475 if(result == TPM_RC_SUCCESS)
2476 {
2477 if((target->count) > MAX_CAP_CC)
2478 result = TPM_RC_SIZE;
2479 else
2480 result = TPM_CC_Array_Unmarshal((TPM_CC *)(target->commandCodes), buffer, size, (INT32)(target->count));
2481 }
2482 return result;
2483 }
2484 UINT16
TPML_CC_Marshal(TPML_CC * source,BYTE ** buffer,INT32 * size)2485 TPML_CC_Marshal(TPML_CC *source, BYTE **buffer, INT32 *size)
2486 {
2487 UINT16 result = 0;
2488 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2489 result = (UINT16)(result + TPM_CC_Array_Marshal((TPM_CC *)(source->commandCodes), buffer, size, (INT32)(source->count)));
2490 return result;
2491 }
2492
2493 // Table 2:107 - Definition of TPML_CCA Structure
2494 UINT16
TPML_CCA_Marshal(TPML_CCA * source,BYTE ** buffer,INT32 * size)2495 TPML_CCA_Marshal(TPML_CCA *source, BYTE **buffer, INT32 *size)
2496 {
2497 UINT16 result = 0;
2498 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2499 result = (UINT16)(result + TPMA_CC_Array_Marshal((TPMA_CC *)(source->commandAttributes), buffer, size, (INT32)(source->count)));
2500 return result;
2501 }
2502
2503 // Table 2:108 - Definition of TPML_ALG Structure
2504 TPM_RC
TPML_ALG_Unmarshal(TPML_ALG * target,BYTE ** buffer,INT32 * size)2505 TPML_ALG_Unmarshal(TPML_ALG *target, BYTE **buffer, INT32 *size)
2506 {
2507 TPM_RC result;
2508 result = UINT32_Unmarshal((UINT32 *)&(target->count), buffer, size);
2509 if(result == TPM_RC_SUCCESS)
2510 {
2511 if((target->count) > MAX_ALG_LIST_SIZE)
2512 result = TPM_RC_SIZE;
2513 else
2514 result = TPM_ALG_ID_Array_Unmarshal((TPM_ALG_ID *)(target->algorithms), buffer, size, (INT32)(target->count));
2515 }
2516 return result;
2517 }
2518 UINT16
TPML_ALG_Marshal(TPML_ALG * source,BYTE ** buffer,INT32 * size)2519 TPML_ALG_Marshal(TPML_ALG *source, BYTE **buffer, INT32 *size)
2520 {
2521 UINT16 result = 0;
2522 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2523 result = (UINT16)(result + TPM_ALG_ID_Array_Marshal((TPM_ALG_ID *)(source->algorithms), buffer, size, (INT32)(source->count)));
2524 return result;
2525 }
2526
2527 // Table 2:109 - Definition of TPML_HANDLE Structure
2528 UINT16
TPML_HANDLE_Marshal(TPML_HANDLE * source,BYTE ** buffer,INT32 * size)2529 TPML_HANDLE_Marshal(TPML_HANDLE *source, BYTE **buffer, INT32 *size)
2530 {
2531 UINT16 result = 0;
2532 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2533 result = (UINT16)(result + TPM_HANDLE_Array_Marshal((TPM_HANDLE *)(source->handle), buffer, size, (INT32)(source->count)));
2534 return result;
2535 }
2536
2537 // Table 2:110 - Definition of TPML_DIGEST Structure
2538 TPM_RC
TPML_DIGEST_Unmarshal(TPML_DIGEST * target,BYTE ** buffer,INT32 * size)2539 TPML_DIGEST_Unmarshal(TPML_DIGEST *target, BYTE **buffer, INT32 *size)
2540 {
2541 TPM_RC result;
2542 result = UINT32_Unmarshal((UINT32 *)&(target->count), buffer, size);
2543 if( (result == TPM_RC_SUCCESS)
2544 && (target->count < 2))
2545 result = TPM_RC_SIZE;
2546 if(result == TPM_RC_SUCCESS)
2547 {
2548 if((target->count) > 8)
2549 result = TPM_RC_SIZE;
2550 else
2551 result = TPM2B_DIGEST_Array_Unmarshal((TPM2B_DIGEST *)(target->digests), buffer, size, (INT32)(target->count));
2552 }
2553 return result;
2554 }
2555 UINT16
TPML_DIGEST_Marshal(TPML_DIGEST * source,BYTE ** buffer,INT32 * size)2556 TPML_DIGEST_Marshal(TPML_DIGEST *source, BYTE **buffer, INT32 *size)
2557 {
2558 UINT16 result = 0;
2559 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2560 result = (UINT16)(result + TPM2B_DIGEST_Array_Marshal((TPM2B_DIGEST *)(source->digests), buffer, size, (INT32)(source->count)));
2561 return result;
2562 }
2563
2564 // Table 2:111 - Definition of TPML_DIGEST_VALUES Structure
2565 TPM_RC
TPML_DIGEST_VALUES_Unmarshal(TPML_DIGEST_VALUES * target,BYTE ** buffer,INT32 * size)2566 TPML_DIGEST_VALUES_Unmarshal(TPML_DIGEST_VALUES *target, BYTE **buffer, INT32 *size)
2567 {
2568 TPM_RC result;
2569 result = UINT32_Unmarshal((UINT32 *)&(target->count), buffer, size);
2570 if(result == TPM_RC_SUCCESS)
2571 {
2572 if((target->count) > HASH_COUNT)
2573 result = TPM_RC_SIZE;
2574 else
2575 result = TPMT_HA_Array_Unmarshal((TPMT_HA *)(target->digests), buffer, size, 0, (INT32)(target->count));
2576 }
2577 return result;
2578 }
2579 UINT16
TPML_DIGEST_VALUES_Marshal(TPML_DIGEST_VALUES * source,BYTE ** buffer,INT32 * size)2580 TPML_DIGEST_VALUES_Marshal(TPML_DIGEST_VALUES *source, BYTE **buffer, INT32 *size)
2581 {
2582 UINT16 result = 0;
2583 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2584 result = (UINT16)(result + TPMT_HA_Array_Marshal((TPMT_HA *)(source->digests), buffer, size, (INT32)(source->count)));
2585 return result;
2586 }
2587
2588 // Table 2:112 - Definition of TPML_PCR_SELECTION Structure
2589 TPM_RC
TPML_PCR_SELECTION_Unmarshal(TPML_PCR_SELECTION * target,BYTE ** buffer,INT32 * size)2590 TPML_PCR_SELECTION_Unmarshal(TPML_PCR_SELECTION *target, BYTE **buffer, INT32 *size)
2591 {
2592 TPM_RC result;
2593 result = UINT32_Unmarshal((UINT32 *)&(target->count), buffer, size);
2594 if(result == TPM_RC_SUCCESS)
2595 {
2596 if((target->count) > HASH_COUNT)
2597 result = TPM_RC_SIZE;
2598 else
2599 result = TPMS_PCR_SELECTION_Array_Unmarshal((TPMS_PCR_SELECTION *)(target->pcrSelections), buffer, size, (INT32)(target->count));
2600 }
2601 return result;
2602 }
2603 UINT16
TPML_PCR_SELECTION_Marshal(TPML_PCR_SELECTION * source,BYTE ** buffer,INT32 * size)2604 TPML_PCR_SELECTION_Marshal(TPML_PCR_SELECTION *source, BYTE **buffer, INT32 *size)
2605 {
2606 UINT16 result = 0;
2607 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2608 result = (UINT16)(result + TPMS_PCR_SELECTION_Array_Marshal((TPMS_PCR_SELECTION *)(source->pcrSelections), buffer, size, (INT32)(source->count)));
2609 return result;
2610 }
2611
2612 // Table 2:113 - Definition of TPML_ALG_PROPERTY Structure
2613 UINT16
TPML_ALG_PROPERTY_Marshal(TPML_ALG_PROPERTY * source,BYTE ** buffer,INT32 * size)2614 TPML_ALG_PROPERTY_Marshal(TPML_ALG_PROPERTY *source, BYTE **buffer, INT32 *size)
2615 {
2616 UINT16 result = 0;
2617 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2618 result = (UINT16)(result + TPMS_ALG_PROPERTY_Array_Marshal((TPMS_ALG_PROPERTY *)(source->algProperties), buffer, size, (INT32)(source->count)));
2619 return result;
2620 }
2621
2622 // Table 2:114 - Definition of TPML_TAGGED_TPM_PROPERTY Structure
2623 UINT16
TPML_TAGGED_TPM_PROPERTY_Marshal(TPML_TAGGED_TPM_PROPERTY * source,BYTE ** buffer,INT32 * size)2624 TPML_TAGGED_TPM_PROPERTY_Marshal(TPML_TAGGED_TPM_PROPERTY *source, BYTE **buffer, INT32 *size)
2625 {
2626 UINT16 result = 0;
2627 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2628 result = (UINT16)(result + TPMS_TAGGED_PROPERTY_Array_Marshal((TPMS_TAGGED_PROPERTY *)(source->tpmProperty), buffer, size, (INT32)(source->count)));
2629 return result;
2630 }
2631
2632 // Table 2:115 - Definition of TPML_TAGGED_PCR_PROPERTY Structure
2633 UINT16
TPML_TAGGED_PCR_PROPERTY_Marshal(TPML_TAGGED_PCR_PROPERTY * source,BYTE ** buffer,INT32 * size)2634 TPML_TAGGED_PCR_PROPERTY_Marshal(TPML_TAGGED_PCR_PROPERTY *source, BYTE **buffer, INT32 *size)
2635 {
2636 UINT16 result = 0;
2637 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2638 result = (UINT16)(result + TPMS_TAGGED_PCR_SELECT_Array_Marshal((TPMS_TAGGED_PCR_SELECT *)(source->pcrProperty), buffer, size, (INT32)(source->count)));
2639 return result;
2640 }
2641
2642 // Table 2:116 - Definition of TPML_ECC_CURVE Structure
2643 #if ALG_ECC
2644 UINT16
TPML_ECC_CURVE_Marshal(TPML_ECC_CURVE * source,BYTE ** buffer,INT32 * size)2645 TPML_ECC_CURVE_Marshal(TPML_ECC_CURVE *source, BYTE **buffer, INT32 *size)
2646 {
2647 UINT16 result = 0;
2648 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2649 result = (UINT16)(result + TPM_ECC_CURVE_Array_Marshal((TPM_ECC_CURVE *)(source->eccCurves), buffer, size, (INT32)(source->count)));
2650 return result;
2651 }
2652 #endif // ALG_ECC
2653
2654 // Table 2:117 - Definition of TPML_TAGGED_POLICY Structure
2655 UINT16
TPML_TAGGED_POLICY_Marshal(TPML_TAGGED_POLICY * source,BYTE ** buffer,INT32 * size)2656 TPML_TAGGED_POLICY_Marshal(TPML_TAGGED_POLICY *source, BYTE **buffer, INT32 *size)
2657 {
2658 UINT16 result = 0;
2659 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2660 result = (UINT16)(result + TPMS_TAGGED_POLICY_Array_Marshal((TPMS_TAGGED_POLICY *)(source->policies), buffer, size, (INT32)(source->count)));
2661 return result;
2662 }
2663
2664 // Table 2:118 - Definition of TPML_ACT_DATA Structure
2665 UINT16
TPML_ACT_DATA_Marshal(TPML_ACT_DATA * source,BYTE ** buffer,INT32 * size)2666 TPML_ACT_DATA_Marshal(TPML_ACT_DATA *source, BYTE **buffer, INT32 *size)
2667 {
2668 UINT16 result = 0;
2669 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
2670 result = (UINT16)(result + TPMS_ACT_DATA_Array_Marshal((TPMS_ACT_DATA *)(source->actData), buffer, size, (INT32)(source->count)));
2671 return result;
2672 }
2673
2674 // Table 2:119 - Definition of TPMU_CAPABILITIES Union
2675 UINT16
TPMU_CAPABILITIES_Marshal(TPMU_CAPABILITIES * source,BYTE ** buffer,INT32 * size,UINT32 selector)2676 TPMU_CAPABILITIES_Marshal(TPMU_CAPABILITIES *source, BYTE **buffer, INT32 *size, UINT32 selector)
2677 {
2678 switch(selector) {
2679 case TPM_CAP_ALGS:
2680 return TPML_ALG_PROPERTY_Marshal((TPML_ALG_PROPERTY *)&(source->algorithms), buffer, size);
2681 case TPM_CAP_HANDLES:
2682 return TPML_HANDLE_Marshal((TPML_HANDLE *)&(source->handles), buffer, size);
2683 case TPM_CAP_COMMANDS:
2684 return TPML_CCA_Marshal((TPML_CCA *)&(source->command), buffer, size);
2685 case TPM_CAP_PP_COMMANDS:
2686 return TPML_CC_Marshal((TPML_CC *)&(source->ppCommands), buffer, size);
2687 case TPM_CAP_AUDIT_COMMANDS:
2688 return TPML_CC_Marshal((TPML_CC *)&(source->auditCommands), buffer, size);
2689 case TPM_CAP_PCRS:
2690 return TPML_PCR_SELECTION_Marshal((TPML_PCR_SELECTION *)&(source->assignedPCR), buffer, size);
2691 case TPM_CAP_TPM_PROPERTIES:
2692 return TPML_TAGGED_TPM_PROPERTY_Marshal((TPML_TAGGED_TPM_PROPERTY *)&(source->tpmProperties), buffer, size);
2693 case TPM_CAP_PCR_PROPERTIES:
2694 return TPML_TAGGED_PCR_PROPERTY_Marshal((TPML_TAGGED_PCR_PROPERTY *)&(source->pcrProperties), buffer, size);
2695 #if ALG_ECC
2696 case TPM_CAP_ECC_CURVES:
2697 return TPML_ECC_CURVE_Marshal((TPML_ECC_CURVE *)&(source->eccCurves), buffer, size);
2698 #endif // ALG_ECC
2699 case TPM_CAP_AUTH_POLICIES:
2700 return TPML_TAGGED_POLICY_Marshal((TPML_TAGGED_POLICY *)&(source->authPolicies), buffer, size);
2701 case TPM_CAP_ACT:
2702 return TPML_ACT_DATA_Marshal((TPML_ACT_DATA *)&(source->actData), buffer, size);
2703 }
2704 return 0;
2705 }
2706
2707 // Table 2:120 - Definition of TPMS_CAPABILITY_DATA Structure
2708 UINT16
TPMS_CAPABILITY_DATA_Marshal(TPMS_CAPABILITY_DATA * source,BYTE ** buffer,INT32 * size)2709 TPMS_CAPABILITY_DATA_Marshal(TPMS_CAPABILITY_DATA *source, BYTE **buffer, INT32 *size)
2710 {
2711 UINT16 result = 0;
2712 result = (UINT16)(result + TPM_CAP_Marshal((TPM_CAP *)&(source->capability), buffer, size));
2713 result = (UINT16)(result + TPMU_CAPABILITIES_Marshal((TPMU_CAPABILITIES *)&(source->data), buffer, size, (UINT32)source->capability));
2714 return result;
2715 }
2716
2717 // Table 2:121 - Definition of TPMS_CLOCK_INFO Structure
2718 TPM_RC
TPMS_CLOCK_INFO_Unmarshal(TPMS_CLOCK_INFO * target,BYTE ** buffer,INT32 * size)2719 TPMS_CLOCK_INFO_Unmarshal(TPMS_CLOCK_INFO *target, BYTE **buffer, INT32 *size)
2720 {
2721 TPM_RC result;
2722 result = UINT64_Unmarshal((UINT64 *)&(target->clock), buffer, size);
2723 if(result == TPM_RC_SUCCESS)
2724 result = UINT32_Unmarshal((UINT32 *)&(target->resetCount), buffer, size);
2725 if(result == TPM_RC_SUCCESS)
2726 result = UINT32_Unmarshal((UINT32 *)&(target->restartCount), buffer, size);
2727 if(result == TPM_RC_SUCCESS)
2728 result = TPMI_YES_NO_Unmarshal((TPMI_YES_NO *)&(target->safe), buffer, size);
2729 return result;
2730 }
2731 UINT16
TPMS_CLOCK_INFO_Marshal(TPMS_CLOCK_INFO * source,BYTE ** buffer,INT32 * size)2732 TPMS_CLOCK_INFO_Marshal(TPMS_CLOCK_INFO *source, BYTE **buffer, INT32 *size)
2733 {
2734 UINT16 result = 0;
2735 result = (UINT16)(result + UINT64_Marshal((UINT64 *)&(source->clock), buffer, size));
2736 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->resetCount), buffer, size));
2737 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->restartCount), buffer, size));
2738 result = (UINT16)(result + TPMI_YES_NO_Marshal((TPMI_YES_NO *)&(source->safe), buffer, size));
2739 return result;
2740 }
2741
2742 // Table 2:122 - Definition of TPMS_TIME_INFO Structure
2743 TPM_RC
TPMS_TIME_INFO_Unmarshal(TPMS_TIME_INFO * target,BYTE ** buffer,INT32 * size)2744 TPMS_TIME_INFO_Unmarshal(TPMS_TIME_INFO *target, BYTE **buffer, INT32 *size)
2745 {
2746 TPM_RC result;
2747 result = UINT64_Unmarshal((UINT64 *)&(target->time), buffer, size);
2748 if(result == TPM_RC_SUCCESS)
2749 result = TPMS_CLOCK_INFO_Unmarshal((TPMS_CLOCK_INFO *)&(target->clockInfo), buffer, size);
2750 return result;
2751 }
2752 UINT16
TPMS_TIME_INFO_Marshal(TPMS_TIME_INFO * source,BYTE ** buffer,INT32 * size)2753 TPMS_TIME_INFO_Marshal(TPMS_TIME_INFO *source, BYTE **buffer, INT32 *size)
2754 {
2755 UINT16 result = 0;
2756 result = (UINT16)(result + UINT64_Marshal((UINT64 *)&(source->time), buffer, size));
2757 result = (UINT16)(result + TPMS_CLOCK_INFO_Marshal((TPMS_CLOCK_INFO *)&(source->clockInfo), buffer, size));
2758 return result;
2759 }
2760
2761 // Table 2:123 - Definition of TPMS_TIME_ATTEST_INFO Structure
2762 UINT16
TPMS_TIME_ATTEST_INFO_Marshal(TPMS_TIME_ATTEST_INFO * source,BYTE ** buffer,INT32 * size)2763 TPMS_TIME_ATTEST_INFO_Marshal(TPMS_TIME_ATTEST_INFO *source, BYTE **buffer, INT32 *size)
2764 {
2765 UINT16 result = 0;
2766 result = (UINT16)(result + TPMS_TIME_INFO_Marshal((TPMS_TIME_INFO *)&(source->time), buffer, size));
2767 result = (UINT16)(result + UINT64_Marshal((UINT64 *)&(source->firmwareVersion), buffer, size));
2768 return result;
2769 }
2770
2771 // Table 2:124 - Definition of TPMS_CERTIFY_INFO Structure
2772 UINT16
TPMS_CERTIFY_INFO_Marshal(TPMS_CERTIFY_INFO * source,BYTE ** buffer,INT32 * size)2773 TPMS_CERTIFY_INFO_Marshal(TPMS_CERTIFY_INFO *source, BYTE **buffer, INT32 *size)
2774 {
2775 UINT16 result = 0;
2776 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->name), buffer, size));
2777 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->qualifiedName), buffer, size));
2778 return result;
2779 }
2780
2781 // Table 2:125 - Definition of TPMS_QUOTE_INFO Structure
2782 UINT16
TPMS_QUOTE_INFO_Marshal(TPMS_QUOTE_INFO * source,BYTE ** buffer,INT32 * size)2783 TPMS_QUOTE_INFO_Marshal(TPMS_QUOTE_INFO *source, BYTE **buffer, INT32 *size)
2784 {
2785 UINT16 result = 0;
2786 result = (UINT16)(result + TPML_PCR_SELECTION_Marshal((TPML_PCR_SELECTION *)&(source->pcrSelect), buffer, size));
2787 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->pcrDigest), buffer, size));
2788 return result;
2789 }
2790
2791 // Table 2:126 - Definition of TPMS_COMMAND_AUDIT_INFO Structure
2792 UINT16
TPMS_COMMAND_AUDIT_INFO_Marshal(TPMS_COMMAND_AUDIT_INFO * source,BYTE ** buffer,INT32 * size)2793 TPMS_COMMAND_AUDIT_INFO_Marshal(TPMS_COMMAND_AUDIT_INFO *source, BYTE **buffer, INT32 *size)
2794 {
2795 UINT16 result = 0;
2796 result = (UINT16)(result + UINT64_Marshal((UINT64 *)&(source->auditCounter), buffer, size));
2797 result = (UINT16)(result + TPM_ALG_ID_Marshal((TPM_ALG_ID *)&(source->digestAlg), buffer, size));
2798 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->auditDigest), buffer, size));
2799 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->commandDigest), buffer, size));
2800 return result;
2801 }
2802
2803 // Table 2:127 - Definition of TPMS_SESSION_AUDIT_INFO Structure
2804 UINT16
TPMS_SESSION_AUDIT_INFO_Marshal(TPMS_SESSION_AUDIT_INFO * source,BYTE ** buffer,INT32 * size)2805 TPMS_SESSION_AUDIT_INFO_Marshal(TPMS_SESSION_AUDIT_INFO *source, BYTE **buffer, INT32 *size)
2806 {
2807 UINT16 result = 0;
2808 result = (UINT16)(result + TPMI_YES_NO_Marshal((TPMI_YES_NO *)&(source->exclusiveSession), buffer, size));
2809 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->sessionDigest), buffer, size));
2810 return result;
2811 }
2812
2813 // Table 2:128 - Definition of TPMS_CREATION_INFO Structure
2814 UINT16
TPMS_CREATION_INFO_Marshal(TPMS_CREATION_INFO * source,BYTE ** buffer,INT32 * size)2815 TPMS_CREATION_INFO_Marshal(TPMS_CREATION_INFO *source, BYTE **buffer, INT32 *size)
2816 {
2817 UINT16 result = 0;
2818 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->objectName), buffer, size));
2819 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->creationHash), buffer, size));
2820 return result;
2821 }
2822
2823 // Table 2:129 - Definition of TPMS_NV_CERTIFY_INFO Structure
2824 UINT16
TPMS_NV_CERTIFY_INFO_Marshal(TPMS_NV_CERTIFY_INFO * source,BYTE ** buffer,INT32 * size)2825 TPMS_NV_CERTIFY_INFO_Marshal(TPMS_NV_CERTIFY_INFO *source, BYTE **buffer, INT32 *size)
2826 {
2827 UINT16 result = 0;
2828 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->indexName), buffer, size));
2829 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->offset), buffer, size));
2830 result = (UINT16)(result + TPM2B_MAX_NV_BUFFER_Marshal((TPM2B_MAX_NV_BUFFER *)&(source->nvContents), buffer, size));
2831 return result;
2832 }
2833
2834 // Table 2:130 - Definition of TPMS_NV_DIGEST_CERTIFY_INFO Structure
2835 UINT16
TPMS_NV_DIGEST_CERTIFY_INFO_Marshal(TPMS_NV_DIGEST_CERTIFY_INFO * source,BYTE ** buffer,INT32 * size)2836 TPMS_NV_DIGEST_CERTIFY_INFO_Marshal(TPMS_NV_DIGEST_CERTIFY_INFO *source, BYTE **buffer, INT32 *size)
2837 {
2838 UINT16 result = 0;
2839 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->indexName), buffer, size));
2840 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->nvDigest), buffer, size));
2841 return result;
2842 }
2843
2844 // Table 2:131 - Definition of TPMI_ST_ATTEST Type
2845 #if !USE_MARSHALING_DEFINES
2846 UINT16
TPMI_ST_ATTEST_Marshal(TPMI_ST_ATTEST * source,BYTE ** buffer,INT32 * size)2847 TPMI_ST_ATTEST_Marshal(TPMI_ST_ATTEST *source, BYTE **buffer, INT32 *size)
2848 {
2849 return TPM_ST_Marshal((TPM_ST *)source, buffer, size);
2850 }
2851 #endif // !USE_MARSHALING_DEFINES
2852
2853 // Table 2:132 - Definition of TPMU_ATTEST Union
2854 UINT16
TPMU_ATTEST_Marshal(TPMU_ATTEST * source,BYTE ** buffer,INT32 * size,UINT32 selector)2855 TPMU_ATTEST_Marshal(TPMU_ATTEST *source, BYTE **buffer, INT32 *size, UINT32 selector)
2856 {
2857 switch(selector) {
2858 case TPM_ST_ATTEST_CERTIFY:
2859 return TPMS_CERTIFY_INFO_Marshal((TPMS_CERTIFY_INFO *)&(source->certify), buffer, size);
2860 case TPM_ST_ATTEST_CREATION:
2861 return TPMS_CREATION_INFO_Marshal((TPMS_CREATION_INFO *)&(source->creation), buffer, size);
2862 case TPM_ST_ATTEST_QUOTE:
2863 return TPMS_QUOTE_INFO_Marshal((TPMS_QUOTE_INFO *)&(source->quote), buffer, size);
2864 case TPM_ST_ATTEST_COMMAND_AUDIT:
2865 return TPMS_COMMAND_AUDIT_INFO_Marshal((TPMS_COMMAND_AUDIT_INFO *)&(source->commandAudit), buffer, size);
2866 case TPM_ST_ATTEST_SESSION_AUDIT:
2867 return TPMS_SESSION_AUDIT_INFO_Marshal((TPMS_SESSION_AUDIT_INFO *)&(source->sessionAudit), buffer, size);
2868 case TPM_ST_ATTEST_TIME:
2869 return TPMS_TIME_ATTEST_INFO_Marshal((TPMS_TIME_ATTEST_INFO *)&(source->time), buffer, size);
2870 case TPM_ST_ATTEST_NV:
2871 return TPMS_NV_CERTIFY_INFO_Marshal((TPMS_NV_CERTIFY_INFO *)&(source->nv), buffer, size);
2872 case TPM_ST_ATTEST_NV_DIGEST:
2873 return TPMS_NV_DIGEST_CERTIFY_INFO_Marshal((TPMS_NV_DIGEST_CERTIFY_INFO *)&(source->nvDigest), buffer, size);
2874 }
2875 return 0;
2876 }
2877
2878 // Table 2:133 - Definition of TPMS_ATTEST Structure
2879 UINT16
TPMS_ATTEST_Marshal(TPMS_ATTEST * source,BYTE ** buffer,INT32 * size)2880 TPMS_ATTEST_Marshal(TPMS_ATTEST *source, BYTE **buffer, INT32 *size)
2881 {
2882 UINT16 result = 0;
2883 result = (UINT16)(result + TPM_CONSTANTS32_Marshal((TPM_CONSTANTS32 *)&(source->magic), buffer, size));
2884 result = (UINT16)(result + TPMI_ST_ATTEST_Marshal((TPMI_ST_ATTEST *)&(source->type), buffer, size));
2885 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->qualifiedSigner), buffer, size));
2886 result = (UINT16)(result + TPM2B_DATA_Marshal((TPM2B_DATA *)&(source->extraData), buffer, size));
2887 result = (UINT16)(result + TPMS_CLOCK_INFO_Marshal((TPMS_CLOCK_INFO *)&(source->clockInfo), buffer, size));
2888 result = (UINT16)(result + UINT64_Marshal((UINT64 *)&(source->firmwareVersion), buffer, size));
2889 result = (UINT16)(result + TPMU_ATTEST_Marshal((TPMU_ATTEST *)&(source->attested), buffer, size, (UINT32)source->type));
2890 return result;
2891 }
2892
2893 // Table 2:134 - Definition of TPM2B_ATTEST Structure
2894 UINT16
TPM2B_ATTEST_Marshal(TPM2B_ATTEST * source,BYTE ** buffer,INT32 * size)2895 TPM2B_ATTEST_Marshal(TPM2B_ATTEST *source, BYTE **buffer, INT32 *size)
2896 {
2897 UINT16 result = 0;
2898 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
2899 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
2900 if(source->t.size == 0)
2901 return result;
2902 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.attestationData), buffer, size, (INT32)(source->t.size)));
2903 return result;
2904 }
2905
2906 // Table 2:135 - Definition of TPMS_AUTH_COMMAND Structure
2907 TPM_RC
TPMS_AUTH_COMMAND_Unmarshal(TPMS_AUTH_COMMAND * target,BYTE ** buffer,INT32 * size)2908 TPMS_AUTH_COMMAND_Unmarshal(TPMS_AUTH_COMMAND *target, BYTE **buffer, INT32 *size)
2909 {
2910 TPM_RC result;
2911 result = TPMI_SH_AUTH_SESSION_Unmarshal((TPMI_SH_AUTH_SESSION *)&(target->sessionHandle), buffer, size, 1);
2912 if(result == TPM_RC_SUCCESS)
2913 result = TPM2B_NONCE_Unmarshal((TPM2B_NONCE *)&(target->nonce), buffer, size);
2914 if(result == TPM_RC_SUCCESS)
2915 result = TPMA_SESSION_Unmarshal((TPMA_SESSION *)&(target->sessionAttributes), buffer, size);
2916 if(result == TPM_RC_SUCCESS)
2917 result = TPM2B_AUTH_Unmarshal((TPM2B_AUTH *)&(target->hmac), buffer, size);
2918 return result;
2919 }
2920
2921 // Table 2:136 - Definition of TPMS_AUTH_RESPONSE Structure
2922 UINT16
TPMS_AUTH_RESPONSE_Marshal(TPMS_AUTH_RESPONSE * source,BYTE ** buffer,INT32 * size)2923 TPMS_AUTH_RESPONSE_Marshal(TPMS_AUTH_RESPONSE *source, BYTE **buffer, INT32 *size)
2924 {
2925 UINT16 result = 0;
2926 result = (UINT16)(result + TPM2B_NONCE_Marshal((TPM2B_NONCE *)&(source->nonce), buffer, size));
2927 result = (UINT16)(result + TPMA_SESSION_Marshal((TPMA_SESSION *)&(source->sessionAttributes), buffer, size));
2928 result = (UINT16)(result + TPM2B_AUTH_Marshal((TPM2B_AUTH *)&(source->hmac), buffer, size));
2929 return result;
2930 }
2931
2932 // Table 2:137 - Definition of TPMI_TDES_KEY_BITS Type
2933 #if ALG_TDES
2934 TPM_RC
TPMI_TDES_KEY_BITS_Unmarshal(TPMI_TDES_KEY_BITS * target,BYTE ** buffer,INT32 * size)2935 TPMI_TDES_KEY_BITS_Unmarshal(TPMI_TDES_KEY_BITS *target, BYTE **buffer, INT32 *size)
2936 {
2937 TPM_RC result;
2938 result = TPM_KEY_BITS_Unmarshal((TPM_KEY_BITS *)target, buffer, size);
2939 if(result == TPM_RC_SUCCESS)
2940 {
2941 switch (*target)
2942 {
2943 #if TDES_128
2944 case 128:
2945 #endif // TDES_128
2946 #if TDES_192
2947 case 192:
2948 #endif // TDES_192
2949 break;
2950 default:
2951 result = TPM_RC_VALUE;
2952 break;
2953 }
2954 }
2955 return result;
2956 }
2957 #if !USE_MARSHALING_DEFINES
2958 UINT16
TPMI_TDES_KEY_BITS_Marshal(TPMI_TDES_KEY_BITS * source,BYTE ** buffer,INT32 * size)2959 TPMI_TDES_KEY_BITS_Marshal(TPMI_TDES_KEY_BITS *source, BYTE **buffer, INT32 *size)
2960 {
2961 return TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)source, buffer, size);
2962 }
2963 #endif // !USE_MARSHALING_DEFINES
2964 #endif // ALG_TDES
2965
2966 // Table 2:137 - Definition of TPMI_AES_KEY_BITS Type
2967 #if ALG_AES
2968 TPM_RC
TPMI_AES_KEY_BITS_Unmarshal(TPMI_AES_KEY_BITS * target,BYTE ** buffer,INT32 * size)2969 TPMI_AES_KEY_BITS_Unmarshal(TPMI_AES_KEY_BITS *target, BYTE **buffer, INT32 *size)
2970 {
2971 TPM_RC result;
2972 result = TPM_KEY_BITS_Unmarshal((TPM_KEY_BITS *)target, buffer, size);
2973 if(result == TPM_RC_SUCCESS)
2974 {
2975 switch (*target)
2976 {
2977 #if AES_128
2978 case 128:
2979 #endif // AES_128
2980 #if AES_192
2981 case 192:
2982 #endif // AES_192
2983 #if AES_256
2984 case 256:
2985 #endif // AES_256
2986 break;
2987 default:
2988 result = TPM_RC_VALUE;
2989 break;
2990 }
2991 }
2992 return result;
2993 }
2994 #if !USE_MARSHALING_DEFINES
2995 UINT16
TPMI_AES_KEY_BITS_Marshal(TPMI_AES_KEY_BITS * source,BYTE ** buffer,INT32 * size)2996 TPMI_AES_KEY_BITS_Marshal(TPMI_AES_KEY_BITS *source, BYTE **buffer, INT32 *size)
2997 {
2998 return TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)source, buffer, size);
2999 }
3000 #endif // !USE_MARSHALING_DEFINES
3001 #endif // ALG_AES
3002
3003 // Table 2:137 - Definition of TPMI_SM4_KEY_BITS Type
3004 #if ALG_SM4
3005 TPM_RC
TPMI_SM4_KEY_BITS_Unmarshal(TPMI_SM4_KEY_BITS * target,BYTE ** buffer,INT32 * size)3006 TPMI_SM4_KEY_BITS_Unmarshal(TPMI_SM4_KEY_BITS *target, BYTE **buffer, INT32 *size)
3007 {
3008 TPM_RC result;
3009 result = TPM_KEY_BITS_Unmarshal((TPM_KEY_BITS *)target, buffer, size);
3010 if(result == TPM_RC_SUCCESS)
3011 {
3012 switch (*target)
3013 {
3014 #if SM4_128
3015 case 128:
3016 #endif // SM4_128
3017 break;
3018 default:
3019 result = TPM_RC_VALUE;
3020 break;
3021 }
3022 }
3023 return result;
3024 }
3025 #if !USE_MARSHALING_DEFINES
3026 UINT16
TPMI_SM4_KEY_BITS_Marshal(TPMI_SM4_KEY_BITS * source,BYTE ** buffer,INT32 * size)3027 TPMI_SM4_KEY_BITS_Marshal(TPMI_SM4_KEY_BITS *source, BYTE **buffer, INT32 *size)
3028 {
3029 return TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)source, buffer, size);
3030 }
3031 #endif // !USE_MARSHALING_DEFINES
3032 #endif // ALG_SM4
3033
3034 // Table 2:137 - Definition of TPMI_CAMELLIA_KEY_BITS Type
3035 #if ALG_CAMELLIA
3036 TPM_RC
TPMI_CAMELLIA_KEY_BITS_Unmarshal(TPMI_CAMELLIA_KEY_BITS * target,BYTE ** buffer,INT32 * size)3037 TPMI_CAMELLIA_KEY_BITS_Unmarshal(TPMI_CAMELLIA_KEY_BITS *target, BYTE **buffer, INT32 *size)
3038 {
3039 TPM_RC result;
3040 result = TPM_KEY_BITS_Unmarshal((TPM_KEY_BITS *)target, buffer, size);
3041 if(result == TPM_RC_SUCCESS)
3042 {
3043 switch (*target)
3044 {
3045 #if CAMELLIA_128
3046 case 128:
3047 #endif // CAMELLIA_128
3048 #if CAMELLIA_192
3049 case 192:
3050 #endif // CAMELLIA_192
3051 #if CAMELLIA_256
3052 case 256:
3053 #endif // CAMELLIA_256
3054 break;
3055 default:
3056 result = TPM_RC_VALUE;
3057 break;
3058 }
3059 }
3060 return result;
3061 }
3062 #if !USE_MARSHALING_DEFINES
3063 UINT16
TPMI_CAMELLIA_KEY_BITS_Marshal(TPMI_CAMELLIA_KEY_BITS * source,BYTE ** buffer,INT32 * size)3064 TPMI_CAMELLIA_KEY_BITS_Marshal(TPMI_CAMELLIA_KEY_BITS *source, BYTE **buffer, INT32 *size)
3065 {
3066 return TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)source, buffer, size);
3067 }
3068 #endif // !USE_MARSHALING_DEFINES
3069 #endif // ALG_CAMELLIA
3070
3071 // Table 2:138 - Definition of TPMU_SYM_KEY_BITS Union
3072 TPM_RC
TPMU_SYM_KEY_BITS_Unmarshal(TPMU_SYM_KEY_BITS * target,BYTE ** buffer,INT32 * size,UINT32 selector)3073 TPMU_SYM_KEY_BITS_Unmarshal(TPMU_SYM_KEY_BITS *target, BYTE **buffer, INT32 *size, UINT32 selector)
3074 {
3075 switch(selector) {
3076 #if ALG_TDES
3077 case TPM_ALG_TDES:
3078 return TPMI_TDES_KEY_BITS_Unmarshal((TPMI_TDES_KEY_BITS *)&(target->tdes), buffer, size);
3079 #endif // ALG_TDES
3080 #if ALG_AES
3081 case TPM_ALG_AES:
3082 return TPMI_AES_KEY_BITS_Unmarshal((TPMI_AES_KEY_BITS *)&(target->aes), buffer, size);
3083 #endif // ALG_AES
3084 #if ALG_SM4
3085 case TPM_ALG_SM4:
3086 return TPMI_SM4_KEY_BITS_Unmarshal((TPMI_SM4_KEY_BITS *)&(target->sm4), buffer, size);
3087 #endif // ALG_SM4
3088 #if ALG_CAMELLIA
3089 case TPM_ALG_CAMELLIA:
3090 return TPMI_CAMELLIA_KEY_BITS_Unmarshal((TPMI_CAMELLIA_KEY_BITS *)&(target->camellia), buffer, size);
3091 #endif // ALG_CAMELLIA
3092 #if ALG_XOR
3093 case TPM_ALG_XOR:
3094 return TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->xor), buffer, size, 0);
3095 #endif // ALG_XOR
3096 case TPM_ALG_NULL:
3097 return TPM_RC_SUCCESS;
3098 }
3099 return TPM_RC_SELECTOR;
3100 }
3101 UINT16
TPMU_SYM_KEY_BITS_Marshal(TPMU_SYM_KEY_BITS * source,BYTE ** buffer,INT32 * size,UINT32 selector)3102 TPMU_SYM_KEY_BITS_Marshal(TPMU_SYM_KEY_BITS *source, BYTE **buffer, INT32 *size, UINT32 selector)
3103 {
3104 switch(selector) {
3105 #if ALG_TDES
3106 case TPM_ALG_TDES:
3107 return TPMI_TDES_KEY_BITS_Marshal((TPMI_TDES_KEY_BITS *)&(source->tdes), buffer, size);
3108 #endif // ALG_TDES
3109 #if ALG_AES
3110 case TPM_ALG_AES:
3111 return TPMI_AES_KEY_BITS_Marshal((TPMI_AES_KEY_BITS *)&(source->aes), buffer, size);
3112 #endif // ALG_AES
3113 #if ALG_SM4
3114 case TPM_ALG_SM4:
3115 return TPMI_SM4_KEY_BITS_Marshal((TPMI_SM4_KEY_BITS *)&(source->sm4), buffer, size);
3116 #endif // ALG_SM4
3117 #if ALG_CAMELLIA
3118 case TPM_ALG_CAMELLIA:
3119 return TPMI_CAMELLIA_KEY_BITS_Marshal((TPMI_CAMELLIA_KEY_BITS *)&(source->camellia), buffer, size);
3120 #endif // ALG_CAMELLIA
3121 #if ALG_XOR
3122 case TPM_ALG_XOR:
3123 return TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->xor), buffer, size);
3124 #endif // ALG_XOR
3125 case TPM_ALG_NULL:
3126 return 0;
3127 }
3128 return 0;
3129 }
3130
3131 // Table 2:139 - Definition of TPMU_SYM_MODE Union
3132 TPM_RC
TPMU_SYM_MODE_Unmarshal(TPMU_SYM_MODE * target,BYTE ** buffer,INT32 * size,UINT32 selector)3133 TPMU_SYM_MODE_Unmarshal(TPMU_SYM_MODE *target, BYTE **buffer, INT32 *size, UINT32 selector)
3134 {
3135 switch(selector) {
3136 #if ALG_TDES
3137 case TPM_ALG_TDES:
3138 return TPMI_ALG_SYM_MODE_Unmarshal((TPMI_ALG_SYM_MODE *)&(target->tdes), buffer, size, 1);
3139 #endif // ALG_TDES
3140 #if ALG_AES
3141 case TPM_ALG_AES:
3142 return TPMI_ALG_SYM_MODE_Unmarshal((TPMI_ALG_SYM_MODE *)&(target->aes), buffer, size, 1);
3143 #endif // ALG_AES
3144 #if ALG_SM4
3145 case TPM_ALG_SM4:
3146 return TPMI_ALG_SYM_MODE_Unmarshal((TPMI_ALG_SYM_MODE *)&(target->sm4), buffer, size, 1);
3147 #endif // ALG_SM4
3148 #if ALG_CAMELLIA
3149 case TPM_ALG_CAMELLIA:
3150 return TPMI_ALG_SYM_MODE_Unmarshal((TPMI_ALG_SYM_MODE *)&(target->camellia), buffer, size, 1);
3151 #endif // ALG_CAMELLIA
3152 #if ALG_XOR
3153 case TPM_ALG_XOR:
3154 return TPM_RC_SUCCESS;
3155 #endif // ALG_XOR
3156 case TPM_ALG_NULL:
3157 return TPM_RC_SUCCESS;
3158 }
3159 return TPM_RC_SELECTOR;
3160 }
3161 UINT16
TPMU_SYM_MODE_Marshal(TPMU_SYM_MODE * source,BYTE ** buffer,INT32 * size,UINT32 selector)3162 TPMU_SYM_MODE_Marshal(TPMU_SYM_MODE *source, BYTE **buffer, INT32 *size, UINT32 selector)
3163 {
3164 switch(selector) {
3165 #if ALG_TDES
3166 case TPM_ALG_TDES:
3167 return TPMI_ALG_SYM_MODE_Marshal((TPMI_ALG_SYM_MODE *)&(source->tdes), buffer, size);
3168 #endif // ALG_TDES
3169 #if ALG_AES
3170 case TPM_ALG_AES:
3171 return TPMI_ALG_SYM_MODE_Marshal((TPMI_ALG_SYM_MODE *)&(source->aes), buffer, size);
3172 #endif // ALG_AES
3173 #if ALG_SM4
3174 case TPM_ALG_SM4:
3175 return TPMI_ALG_SYM_MODE_Marshal((TPMI_ALG_SYM_MODE *)&(source->sm4), buffer, size);
3176 #endif // ALG_SM4
3177 #if ALG_CAMELLIA
3178 case TPM_ALG_CAMELLIA:
3179 return TPMI_ALG_SYM_MODE_Marshal((TPMI_ALG_SYM_MODE *)&(source->camellia), buffer, size);
3180 #endif // ALG_CAMELLIA
3181 #if ALG_XOR
3182 case TPM_ALG_XOR:
3183 return 0;
3184 #endif // ALG_XOR
3185 case TPM_ALG_NULL:
3186 return 0;
3187 }
3188 return 0;
3189 }
3190
3191 // Table 2:141 - Definition of TPMT_SYM_DEF Structure
3192 TPM_RC
TPMT_SYM_DEF_Unmarshal(TPMT_SYM_DEF * target,BYTE ** buffer,INT32 * size,BOOL flag)3193 TPMT_SYM_DEF_Unmarshal(TPMT_SYM_DEF *target, BYTE **buffer, INT32 *size, BOOL flag)
3194 {
3195 TPM_RC result;
3196 result = TPMI_ALG_SYM_Unmarshal((TPMI_ALG_SYM *)&(target->algorithm), buffer, size, flag);
3197 if(result == TPM_RC_SUCCESS)
3198 result = TPMU_SYM_KEY_BITS_Unmarshal((TPMU_SYM_KEY_BITS *)&(target->keyBits), buffer, size, (UINT32)target->algorithm);
3199 if(result == TPM_RC_SUCCESS)
3200 result = TPMU_SYM_MODE_Unmarshal((TPMU_SYM_MODE *)&(target->mode), buffer, size, (UINT32)target->algorithm);
3201 return result;
3202 }
3203 UINT16
TPMT_SYM_DEF_Marshal(TPMT_SYM_DEF * source,BYTE ** buffer,INT32 * size)3204 TPMT_SYM_DEF_Marshal(TPMT_SYM_DEF *source, BYTE **buffer, INT32 *size)
3205 {
3206 UINT16 result = 0;
3207 result = (UINT16)(result + TPMI_ALG_SYM_Marshal((TPMI_ALG_SYM *)&(source->algorithm), buffer, size));
3208 result = (UINT16)(result + TPMU_SYM_KEY_BITS_Marshal((TPMU_SYM_KEY_BITS *)&(source->keyBits), buffer, size, (UINT32)source->algorithm));
3209 result = (UINT16)(result + TPMU_SYM_MODE_Marshal((TPMU_SYM_MODE *)&(source->mode), buffer, size, (UINT32)source->algorithm));
3210 return result;
3211 }
3212
3213 // Table 2:142 - Definition of TPMT_SYM_DEF_OBJECT Structure
3214 TPM_RC
TPMT_SYM_DEF_OBJECT_Unmarshal(TPMT_SYM_DEF_OBJECT * target,BYTE ** buffer,INT32 * size,BOOL flag)3215 TPMT_SYM_DEF_OBJECT_Unmarshal(TPMT_SYM_DEF_OBJECT *target, BYTE **buffer, INT32 *size, BOOL flag)
3216 {
3217 TPM_RC result;
3218 result = TPMI_ALG_SYM_OBJECT_Unmarshal((TPMI_ALG_SYM_OBJECT *)&(target->algorithm), buffer, size, flag);
3219 if(result == TPM_RC_SUCCESS)
3220 result = TPMU_SYM_KEY_BITS_Unmarshal((TPMU_SYM_KEY_BITS *)&(target->keyBits), buffer, size, (UINT32)target->algorithm);
3221 if(result == TPM_RC_SUCCESS)
3222 result = TPMU_SYM_MODE_Unmarshal((TPMU_SYM_MODE *)&(target->mode), buffer, size, (UINT32)target->algorithm);
3223 return result;
3224 }
3225 UINT16
TPMT_SYM_DEF_OBJECT_Marshal(TPMT_SYM_DEF_OBJECT * source,BYTE ** buffer,INT32 * size)3226 TPMT_SYM_DEF_OBJECT_Marshal(TPMT_SYM_DEF_OBJECT *source, BYTE **buffer, INT32 *size)
3227 {
3228 UINT16 result = 0;
3229 result = (UINT16)(result + TPMI_ALG_SYM_OBJECT_Marshal((TPMI_ALG_SYM_OBJECT *)&(source->algorithm), buffer, size));
3230 result = (UINT16)(result + TPMU_SYM_KEY_BITS_Marshal((TPMU_SYM_KEY_BITS *)&(source->keyBits), buffer, size, (UINT32)source->algorithm));
3231 result = (UINT16)(result + TPMU_SYM_MODE_Marshal((TPMU_SYM_MODE *)&(source->mode), buffer, size, (UINT32)source->algorithm));
3232 return result;
3233 }
3234
3235 // Table 2:143 - Definition of TPM2B_SYM_KEY Structure
3236 TPM_RC
TPM2B_SYM_KEY_Unmarshal(TPM2B_SYM_KEY * target,BYTE ** buffer,INT32 * size)3237 TPM2B_SYM_KEY_Unmarshal(TPM2B_SYM_KEY *target, BYTE **buffer, INT32 *size)
3238 {
3239 TPM_RC result;
3240 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
3241 if(result == TPM_RC_SUCCESS)
3242 {
3243 if((target->t.size) > MAX_SYM_KEY_BYTES)
3244 result = TPM_RC_SIZE;
3245 else
3246 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
3247 }
3248 return result;
3249 }
3250 UINT16
TPM2B_SYM_KEY_Marshal(TPM2B_SYM_KEY * source,BYTE ** buffer,INT32 * size)3251 TPM2B_SYM_KEY_Marshal(TPM2B_SYM_KEY *source, BYTE **buffer, INT32 *size)
3252 {
3253 UINT16 result = 0;
3254 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
3255 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
3256 if(source->t.size == 0)
3257 return result;
3258 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
3259 return result;
3260 }
3261
3262 // Table 2:144 - Definition of TPMS_SYMCIPHER_PARMS Structure
3263 TPM_RC
TPMS_SYMCIPHER_PARMS_Unmarshal(TPMS_SYMCIPHER_PARMS * target,BYTE ** buffer,INT32 * size)3264 TPMS_SYMCIPHER_PARMS_Unmarshal(TPMS_SYMCIPHER_PARMS *target, BYTE **buffer, INT32 *size)
3265 {
3266 return TPMT_SYM_DEF_OBJECT_Unmarshal((TPMT_SYM_DEF_OBJECT *)&(target->sym), buffer, size, 0);
3267 }
3268 UINT16
TPMS_SYMCIPHER_PARMS_Marshal(TPMS_SYMCIPHER_PARMS * source,BYTE ** buffer,INT32 * size)3269 TPMS_SYMCIPHER_PARMS_Marshal(TPMS_SYMCIPHER_PARMS *source, BYTE **buffer, INT32 *size)
3270 {
3271 return TPMT_SYM_DEF_OBJECT_Marshal((TPMT_SYM_DEF_OBJECT *)&(source->sym), buffer, size);
3272 }
3273
3274 // Table 2:145 - Definition of TPM2B_LABEL Structure
3275 TPM_RC
TPM2B_LABEL_Unmarshal(TPM2B_LABEL * target,BYTE ** buffer,INT32 * size)3276 TPM2B_LABEL_Unmarshal(TPM2B_LABEL *target, BYTE **buffer, INT32 *size)
3277 {
3278 TPM_RC result;
3279 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
3280 if(result == TPM_RC_SUCCESS)
3281 {
3282 if((target->t.size) > LABEL_MAX_BUFFER)
3283 result = TPM_RC_SIZE;
3284 else
3285 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
3286 }
3287 return result;
3288 }
3289 UINT16
TPM2B_LABEL_Marshal(TPM2B_LABEL * source,BYTE ** buffer,INT32 * size)3290 TPM2B_LABEL_Marshal(TPM2B_LABEL *source, BYTE **buffer, INT32 *size)
3291 {
3292 UINT16 result = 0;
3293 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
3294 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
3295 if(source->t.size == 0)
3296 return result;
3297 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
3298 return result;
3299 }
3300
3301 // Table 2:146 - Definition of TPMS_DERIVE Structure
3302 TPM_RC
TPMS_DERIVE_Unmarshal(TPMS_DERIVE * target,BYTE ** buffer,INT32 * size)3303 TPMS_DERIVE_Unmarshal(TPMS_DERIVE *target, BYTE **buffer, INT32 *size)
3304 {
3305 TPM_RC result;
3306 result = TPM2B_LABEL_Unmarshal((TPM2B_LABEL *)&(target->label), buffer, size);
3307 if(result == TPM_RC_SUCCESS)
3308 result = TPM2B_LABEL_Unmarshal((TPM2B_LABEL *)&(target->context), buffer, size);
3309 return result;
3310 }
3311 UINT16
TPMS_DERIVE_Marshal(TPMS_DERIVE * source,BYTE ** buffer,INT32 * size)3312 TPMS_DERIVE_Marshal(TPMS_DERIVE *source, BYTE **buffer, INT32 *size)
3313 {
3314 UINT16 result = 0;
3315 result = (UINT16)(result + TPM2B_LABEL_Marshal((TPM2B_LABEL *)&(source->label), buffer, size));
3316 result = (UINT16)(result + TPM2B_LABEL_Marshal((TPM2B_LABEL *)&(source->context), buffer, size));
3317 return result;
3318 }
3319
3320 // Table 2:147 - Definition of TPM2B_DERIVE Structure
3321 TPM_RC
TPM2B_DERIVE_Unmarshal(TPM2B_DERIVE * target,BYTE ** buffer,INT32 * size)3322 TPM2B_DERIVE_Unmarshal(TPM2B_DERIVE *target, BYTE **buffer, INT32 *size)
3323 {
3324 TPM_RC result;
3325 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
3326 if(result == TPM_RC_SUCCESS)
3327 {
3328 if((target->t.size) > sizeof(TPMS_DERIVE))
3329 result = TPM_RC_SIZE;
3330 else
3331 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
3332 }
3333 return result;
3334 }
3335 UINT16
TPM2B_DERIVE_Marshal(TPM2B_DERIVE * source,BYTE ** buffer,INT32 * size)3336 TPM2B_DERIVE_Marshal(TPM2B_DERIVE *source, BYTE **buffer, INT32 *size)
3337 {
3338 UINT16 result = 0;
3339 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
3340 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
3341 if(source->t.size == 0)
3342 return result;
3343 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
3344 return result;
3345 }
3346
3347 // Table 2:148 - Definition of TPMU_SENSITIVE_CREATE Union
3348 // Table 2:149 - Definition of TPM2B_SENSITIVE_DATA Structure
3349 TPM_RC
TPM2B_SENSITIVE_DATA_Unmarshal(TPM2B_SENSITIVE_DATA * target,BYTE ** buffer,INT32 * size)3350 TPM2B_SENSITIVE_DATA_Unmarshal(TPM2B_SENSITIVE_DATA *target, BYTE **buffer, INT32 *size)
3351 {
3352 TPM_RC result;
3353 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
3354 if(result == TPM_RC_SUCCESS)
3355 {
3356 if((target->t.size) > sizeof(TPMU_SENSITIVE_CREATE))
3357 result = TPM_RC_SIZE;
3358 else
3359 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
3360 }
3361 return result;
3362 }
3363 UINT16
TPM2B_SENSITIVE_DATA_Marshal(TPM2B_SENSITIVE_DATA * source,BYTE ** buffer,INT32 * size)3364 TPM2B_SENSITIVE_DATA_Marshal(TPM2B_SENSITIVE_DATA *source, BYTE **buffer, INT32 *size)
3365 {
3366 UINT16 result = 0;
3367 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
3368 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
3369 if(source->t.size == 0)
3370 return result;
3371 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
3372 return result;
3373 }
3374
3375 // Table 2:150 - Definition of TPMS_SENSITIVE_CREATE Structure
3376 TPM_RC
TPMS_SENSITIVE_CREATE_Unmarshal(TPMS_SENSITIVE_CREATE * target,BYTE ** buffer,INT32 * size)3377 TPMS_SENSITIVE_CREATE_Unmarshal(TPMS_SENSITIVE_CREATE *target, BYTE **buffer, INT32 *size)
3378 {
3379 TPM_RC result;
3380 result = TPM2B_AUTH_Unmarshal((TPM2B_AUTH *)&(target->userAuth), buffer, size);
3381 if(result == TPM_RC_SUCCESS)
3382 result = TPM2B_SENSITIVE_DATA_Unmarshal((TPM2B_SENSITIVE_DATA *)&(target->data), buffer, size);
3383 return result;
3384 }
3385
3386 // Table 2:151 - Definition of TPM2B_SENSITIVE_CREATE Structure
3387 TPM_RC
TPM2B_SENSITIVE_CREATE_Unmarshal(TPM2B_SENSITIVE_CREATE * target,BYTE ** buffer,INT32 * size)3388 TPM2B_SENSITIVE_CREATE_Unmarshal(TPM2B_SENSITIVE_CREATE *target, BYTE **buffer, INT32 *size)
3389 {
3390 TPM_RC result;
3391 result = UINT16_Unmarshal((UINT16 *)&(target->size), buffer, size); // =a
3392 if(result == TPM_RC_SUCCESS)
3393 {
3394 // if size is zero, then the required structure is missing
3395 if(target->size == 0)
3396 result = TPM_RC_SIZE;
3397 else
3398 {
3399 INT32 startSize = *size;
3400 result = TPMS_SENSITIVE_CREATE_Unmarshal((TPMS_SENSITIVE_CREATE *)&(target->sensitive), buffer, size); // =b
3401 if(result == TPM_RC_SUCCESS)
3402 {
3403 if(target->size != (startSize - *size))
3404 result = TPM_RC_SIZE;
3405 }
3406 }
3407 }
3408 return result;
3409 }
3410
3411 // Table 2:152 - Definition of TPMS_SCHEME_HASH Structure
3412 TPM_RC
TPMS_SCHEME_HASH_Unmarshal(TPMS_SCHEME_HASH * target,BYTE ** buffer,INT32 * size)3413 TPMS_SCHEME_HASH_Unmarshal(TPMS_SCHEME_HASH *target, BYTE **buffer, INT32 *size)
3414 {
3415 return TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->hashAlg), buffer, size, 0);
3416 }
3417 UINT16
TPMS_SCHEME_HASH_Marshal(TPMS_SCHEME_HASH * source,BYTE ** buffer,INT32 * size)3418 TPMS_SCHEME_HASH_Marshal(TPMS_SCHEME_HASH *source, BYTE **buffer, INT32 *size)
3419 {
3420 return TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->hashAlg), buffer, size);
3421 }
3422
3423 // Table 2:153 - Definition of TPMS_SCHEME_ECDAA Structure
3424 #if ALG_ECC
3425 TPM_RC
TPMS_SCHEME_ECDAA_Unmarshal(TPMS_SCHEME_ECDAA * target,BYTE ** buffer,INT32 * size)3426 TPMS_SCHEME_ECDAA_Unmarshal(TPMS_SCHEME_ECDAA *target, BYTE **buffer, INT32 *size)
3427 {
3428 TPM_RC result;
3429 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->hashAlg), buffer, size, 0);
3430 if(result == TPM_RC_SUCCESS)
3431 result = UINT16_Unmarshal((UINT16 *)&(target->count), buffer, size);
3432 return result;
3433 }
3434 UINT16
TPMS_SCHEME_ECDAA_Marshal(TPMS_SCHEME_ECDAA * source,BYTE ** buffer,INT32 * size)3435 TPMS_SCHEME_ECDAA_Marshal(TPMS_SCHEME_ECDAA *source, BYTE **buffer, INT32 *size)
3436 {
3437 UINT16 result = 0;
3438 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->hashAlg), buffer, size));
3439 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->count), buffer, size));
3440 return result;
3441 }
3442 #endif // ALG_ECC
3443
3444 // Table 2:154 - Definition of TPMI_ALG_KEYEDHASH_SCHEME Type
3445 TPM_RC
TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)3446 TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
3447 {
3448 TPM_RC result;
3449 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
3450 if(result == TPM_RC_SUCCESS)
3451 {
3452 switch (*target)
3453 {
3454 #if ALG_HMAC
3455 case TPM_ALG_HMAC:
3456 #endif // ALG_HMAC
3457 #if ALG_XOR
3458 case TPM_ALG_XOR:
3459 #endif // ALG_XOR
3460 break;
3461 case TPM_ALG_NULL:
3462 if(!flag)
3463 result = TPM_RC_VALUE;
3464 break;
3465 default:
3466 result = TPM_RC_VALUE;
3467 break;
3468 }
3469 }
3470 return result;
3471 }
3472 #if !USE_MARSHALING_DEFINES
3473 UINT16
TPMI_ALG_KEYEDHASH_SCHEME_Marshal(TPMI_ALG_KEYEDHASH_SCHEME * source,BYTE ** buffer,INT32 * size)3474 TPMI_ALG_KEYEDHASH_SCHEME_Marshal(TPMI_ALG_KEYEDHASH_SCHEME *source, BYTE **buffer, INT32 *size)
3475 {
3476 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
3477 }
3478 #endif // !USE_MARSHALING_DEFINES
3479
3480 // Table 2:155 - Definition of Types for HMAC_SIG_SCHEME
3481 #if !USE_MARSHALING_DEFINES
3482 TPM_RC
TPMS_SCHEME_HMAC_Unmarshal(TPMS_SCHEME_HMAC * target,BYTE ** buffer,INT32 * size)3483 TPMS_SCHEME_HMAC_Unmarshal(TPMS_SCHEME_HMAC *target, BYTE **buffer, INT32 *size)
3484 {
3485 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3486 }
3487 UINT16
TPMS_SCHEME_HMAC_Marshal(TPMS_SCHEME_HMAC * source,BYTE ** buffer,INT32 * size)3488 TPMS_SCHEME_HMAC_Marshal(TPMS_SCHEME_HMAC *source, BYTE **buffer, INT32 *size)
3489 {
3490 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3491 }
3492 #endif // !USE_MARSHALING_DEFINES
3493
3494 // Table 2:156 - Definition of TPMS_SCHEME_XOR Structure
3495 TPM_RC
TPMS_SCHEME_XOR_Unmarshal(TPMS_SCHEME_XOR * target,BYTE ** buffer,INT32 * size)3496 TPMS_SCHEME_XOR_Unmarshal(TPMS_SCHEME_XOR *target, BYTE **buffer, INT32 *size)
3497 {
3498 TPM_RC result;
3499 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->hashAlg), buffer, size, 0);
3500 if(result == TPM_RC_SUCCESS)
3501 result = TPMI_ALG_KDF_Unmarshal((TPMI_ALG_KDF *)&(target->kdf), buffer, size, 1);
3502 return result;
3503 }
3504 UINT16
TPMS_SCHEME_XOR_Marshal(TPMS_SCHEME_XOR * source,BYTE ** buffer,INT32 * size)3505 TPMS_SCHEME_XOR_Marshal(TPMS_SCHEME_XOR *source, BYTE **buffer, INT32 *size)
3506 {
3507 UINT16 result = 0;
3508 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->hashAlg), buffer, size));
3509 result = (UINT16)(result + TPMI_ALG_KDF_Marshal((TPMI_ALG_KDF *)&(source->kdf), buffer, size));
3510 return result;
3511 }
3512
3513 // Table 2:157 - Definition of TPMU_SCHEME_KEYEDHASH Union
3514 TPM_RC
TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH * target,BYTE ** buffer,INT32 * size,UINT32 selector)3515 TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH *target, BYTE **buffer, INT32 *size, UINT32 selector)
3516 {
3517 switch(selector) {
3518 #if ALG_HMAC
3519 case TPM_ALG_HMAC:
3520 return TPMS_SCHEME_HMAC_Unmarshal((TPMS_SCHEME_HMAC *)&(target->hmac), buffer, size);
3521 #endif // ALG_HMAC
3522 #if ALG_XOR
3523 case TPM_ALG_XOR:
3524 return TPMS_SCHEME_XOR_Unmarshal((TPMS_SCHEME_XOR *)&(target->xor), buffer, size);
3525 #endif // ALG_XOR
3526 case TPM_ALG_NULL:
3527 return TPM_RC_SUCCESS;
3528 }
3529 return TPM_RC_SELECTOR;
3530 }
3531 UINT16
TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH * source,BYTE ** buffer,INT32 * size,UINT32 selector)3532 TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH *source, BYTE **buffer, INT32 *size, UINT32 selector)
3533 {
3534 switch(selector) {
3535 #if ALG_HMAC
3536 case TPM_ALG_HMAC:
3537 return TPMS_SCHEME_HMAC_Marshal((TPMS_SCHEME_HMAC *)&(source->hmac), buffer, size);
3538 #endif // ALG_HMAC
3539 #if ALG_XOR
3540 case TPM_ALG_XOR:
3541 return TPMS_SCHEME_XOR_Marshal((TPMS_SCHEME_XOR *)&(source->xor), buffer, size);
3542 #endif // ALG_XOR
3543 case TPM_ALG_NULL:
3544 return 0;
3545 }
3546 return 0;
3547 }
3548
3549 // Table 2:158 - Definition of TPMT_KEYEDHASH_SCHEME Structure
3550 TPM_RC
TPMT_KEYEDHASH_SCHEME_Unmarshal(TPMT_KEYEDHASH_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)3551 TPMT_KEYEDHASH_SCHEME_Unmarshal(TPMT_KEYEDHASH_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
3552 {
3553 TPM_RC result;
3554 result = TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal((TPMI_ALG_KEYEDHASH_SCHEME *)&(target->scheme), buffer, size, flag);
3555 if(result == TPM_RC_SUCCESS)
3556 result = TPMU_SCHEME_KEYEDHASH_Unmarshal((TPMU_SCHEME_KEYEDHASH *)&(target->details), buffer, size, (UINT32)target->scheme);
3557 return result;
3558 }
3559 UINT16
TPMT_KEYEDHASH_SCHEME_Marshal(TPMT_KEYEDHASH_SCHEME * source,BYTE ** buffer,INT32 * size)3560 TPMT_KEYEDHASH_SCHEME_Marshal(TPMT_KEYEDHASH_SCHEME *source, BYTE **buffer, INT32 *size)
3561 {
3562 UINT16 result = 0;
3563 result = (UINT16)(result + TPMI_ALG_KEYEDHASH_SCHEME_Marshal((TPMI_ALG_KEYEDHASH_SCHEME *)&(source->scheme), buffer, size));
3564 result = (UINT16)(result + TPMU_SCHEME_KEYEDHASH_Marshal((TPMU_SCHEME_KEYEDHASH *)&(source->details), buffer, size, (UINT32)source->scheme));
3565 return result;
3566 }
3567
3568 // Table 2:159 - Definition of Types for RSA Signature Schemes
3569 #if ALG_RSA
3570 #if !USE_MARSHALING_DEFINES
3571 TPM_RC
TPMS_SIG_SCHEME_RSASSA_Unmarshal(TPMS_SIG_SCHEME_RSASSA * target,BYTE ** buffer,INT32 * size)3572 TPMS_SIG_SCHEME_RSASSA_Unmarshal(TPMS_SIG_SCHEME_RSASSA *target, BYTE **buffer, INT32 *size)
3573 {
3574 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3575 }
3576 UINT16
TPMS_SIG_SCHEME_RSASSA_Marshal(TPMS_SIG_SCHEME_RSASSA * source,BYTE ** buffer,INT32 * size)3577 TPMS_SIG_SCHEME_RSASSA_Marshal(TPMS_SIG_SCHEME_RSASSA *source, BYTE **buffer, INT32 *size)
3578 {
3579 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3580 }
3581 TPM_RC
TPMS_SIG_SCHEME_RSAPSS_Unmarshal(TPMS_SIG_SCHEME_RSAPSS * target,BYTE ** buffer,INT32 * size)3582 TPMS_SIG_SCHEME_RSAPSS_Unmarshal(TPMS_SIG_SCHEME_RSAPSS *target, BYTE **buffer, INT32 *size)
3583 {
3584 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3585 }
3586 UINT16
TPMS_SIG_SCHEME_RSAPSS_Marshal(TPMS_SIG_SCHEME_RSAPSS * source,BYTE ** buffer,INT32 * size)3587 TPMS_SIG_SCHEME_RSAPSS_Marshal(TPMS_SIG_SCHEME_RSAPSS *source, BYTE **buffer, INT32 *size)
3588 {
3589 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3590 }
3591 #endif // !USE_MARSHALING_DEFINES
3592 #endif // ALG_RSA
3593
3594 // Table 2:160 - Definition of Types for ECC Signature Schemes
3595 #if ALG_ECC
3596 #if !USE_MARSHALING_DEFINES
3597 TPM_RC
TPMS_SIG_SCHEME_ECDSA_Unmarshal(TPMS_SIG_SCHEME_ECDSA * target,BYTE ** buffer,INT32 * size)3598 TPMS_SIG_SCHEME_ECDSA_Unmarshal(TPMS_SIG_SCHEME_ECDSA *target, BYTE **buffer, INT32 *size)
3599 {
3600 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3601 }
3602 UINT16
TPMS_SIG_SCHEME_ECDSA_Marshal(TPMS_SIG_SCHEME_ECDSA * source,BYTE ** buffer,INT32 * size)3603 TPMS_SIG_SCHEME_ECDSA_Marshal(TPMS_SIG_SCHEME_ECDSA *source, BYTE **buffer, INT32 *size)
3604 {
3605 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3606 }
3607 TPM_RC
TPMS_SIG_SCHEME_SM2_Unmarshal(TPMS_SIG_SCHEME_SM2 * target,BYTE ** buffer,INT32 * size)3608 TPMS_SIG_SCHEME_SM2_Unmarshal(TPMS_SIG_SCHEME_SM2 *target, BYTE **buffer, INT32 *size)
3609 {
3610 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3611 }
3612 UINT16
TPMS_SIG_SCHEME_SM2_Marshal(TPMS_SIG_SCHEME_SM2 * source,BYTE ** buffer,INT32 * size)3613 TPMS_SIG_SCHEME_SM2_Marshal(TPMS_SIG_SCHEME_SM2 *source, BYTE **buffer, INT32 *size)
3614 {
3615 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3616 }
3617 TPM_RC
TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(TPMS_SIG_SCHEME_ECSCHNORR * target,BYTE ** buffer,INT32 * size)3618 TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(TPMS_SIG_SCHEME_ECSCHNORR *target, BYTE **buffer, INT32 *size)
3619 {
3620 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3621 }
3622 UINT16
TPMS_SIG_SCHEME_ECSCHNORR_Marshal(TPMS_SIG_SCHEME_ECSCHNORR * source,BYTE ** buffer,INT32 * size)3623 TPMS_SIG_SCHEME_ECSCHNORR_Marshal(TPMS_SIG_SCHEME_ECSCHNORR *source, BYTE **buffer, INT32 *size)
3624 {
3625 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3626 }
3627 TPM_RC
TPMS_SIG_SCHEME_ECDAA_Unmarshal(TPMS_SIG_SCHEME_ECDAA * target,BYTE ** buffer,INT32 * size)3628 TPMS_SIG_SCHEME_ECDAA_Unmarshal(TPMS_SIG_SCHEME_ECDAA *target, BYTE **buffer, INT32 *size)
3629 {
3630 return TPMS_SCHEME_ECDAA_Unmarshal((TPMS_SCHEME_ECDAA *)target, buffer, size);
3631 }
3632 UINT16
TPMS_SIG_SCHEME_ECDAA_Marshal(TPMS_SIG_SCHEME_ECDAA * source,BYTE ** buffer,INT32 * size)3633 TPMS_SIG_SCHEME_ECDAA_Marshal(TPMS_SIG_SCHEME_ECDAA *source, BYTE **buffer, INT32 *size)
3634 {
3635 return TPMS_SCHEME_ECDAA_Marshal((TPMS_SCHEME_ECDAA *)source, buffer, size);
3636 }
3637 #endif // !USE_MARSHALING_DEFINES
3638 #endif // ALG_ECC
3639
3640 // Table 2:161 - Definition of TPMU_SIG_SCHEME Union
3641 TPM_RC
TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)3642 TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME *target, BYTE **buffer, INT32 *size, UINT32 selector)
3643 {
3644 switch(selector) {
3645 #if ALG_ECDAA
3646 case TPM_ALG_ECDAA:
3647 return TPMS_SIG_SCHEME_ECDAA_Unmarshal((TPMS_SIG_SCHEME_ECDAA *)&(target->ecdaa), buffer, size);
3648 #endif // ALG_ECDAA
3649 #if ALG_RSASSA
3650 case TPM_ALG_RSASSA:
3651 return TPMS_SIG_SCHEME_RSASSA_Unmarshal((TPMS_SIG_SCHEME_RSASSA *)&(target->rsassa), buffer, size);
3652 #endif // ALG_RSASSA
3653 #if ALG_RSAPSS
3654 case TPM_ALG_RSAPSS:
3655 return TPMS_SIG_SCHEME_RSAPSS_Unmarshal((TPMS_SIG_SCHEME_RSAPSS *)&(target->rsapss), buffer, size);
3656 #endif // ALG_RSAPSS
3657 #if ALG_ECDSA
3658 case TPM_ALG_ECDSA:
3659 return TPMS_SIG_SCHEME_ECDSA_Unmarshal((TPMS_SIG_SCHEME_ECDSA *)&(target->ecdsa), buffer, size);
3660 #endif // ALG_ECDSA
3661 #if ALG_SM2
3662 case TPM_ALG_SM2:
3663 return TPMS_SIG_SCHEME_SM2_Unmarshal((TPMS_SIG_SCHEME_SM2 *)&(target->sm2), buffer, size);
3664 #endif // ALG_SM2
3665 #if ALG_ECSCHNORR
3666 case TPM_ALG_ECSCHNORR:
3667 return TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal((TPMS_SIG_SCHEME_ECSCHNORR *)&(target->ecschnorr), buffer, size);
3668 #endif // ALG_ECSCHNORR
3669 #if ALG_HMAC
3670 case TPM_ALG_HMAC:
3671 return TPMS_SCHEME_HMAC_Unmarshal((TPMS_SCHEME_HMAC *)&(target->hmac), buffer, size);
3672 #endif // ALG_HMAC
3673 case TPM_ALG_NULL:
3674 return TPM_RC_SUCCESS;
3675 }
3676 return TPM_RC_SELECTOR;
3677 }
3678 UINT16
TPMU_SIG_SCHEME_Marshal(TPMU_SIG_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)3679 TPMU_SIG_SCHEME_Marshal(TPMU_SIG_SCHEME *source, BYTE **buffer, INT32 *size, UINT32 selector)
3680 {
3681 switch(selector) {
3682 #if ALG_ECDAA
3683 case TPM_ALG_ECDAA:
3684 return TPMS_SIG_SCHEME_ECDAA_Marshal((TPMS_SIG_SCHEME_ECDAA *)&(source->ecdaa), buffer, size);
3685 #endif // ALG_ECDAA
3686 #if ALG_RSASSA
3687 case TPM_ALG_RSASSA:
3688 return TPMS_SIG_SCHEME_RSASSA_Marshal((TPMS_SIG_SCHEME_RSASSA *)&(source->rsassa), buffer, size);
3689 #endif // ALG_RSASSA
3690 #if ALG_RSAPSS
3691 case TPM_ALG_RSAPSS:
3692 return TPMS_SIG_SCHEME_RSAPSS_Marshal((TPMS_SIG_SCHEME_RSAPSS *)&(source->rsapss), buffer, size);
3693 #endif // ALG_RSAPSS
3694 #if ALG_ECDSA
3695 case TPM_ALG_ECDSA:
3696 return TPMS_SIG_SCHEME_ECDSA_Marshal((TPMS_SIG_SCHEME_ECDSA *)&(source->ecdsa), buffer, size);
3697 #endif // ALG_ECDSA
3698 #if ALG_SM2
3699 case TPM_ALG_SM2:
3700 return TPMS_SIG_SCHEME_SM2_Marshal((TPMS_SIG_SCHEME_SM2 *)&(source->sm2), buffer, size);
3701 #endif // ALG_SM2
3702 #if ALG_ECSCHNORR
3703 case TPM_ALG_ECSCHNORR:
3704 return TPMS_SIG_SCHEME_ECSCHNORR_Marshal((TPMS_SIG_SCHEME_ECSCHNORR *)&(source->ecschnorr), buffer, size);
3705 #endif // ALG_ECSCHNORR
3706 #if ALG_HMAC
3707 case TPM_ALG_HMAC:
3708 return TPMS_SCHEME_HMAC_Marshal((TPMS_SCHEME_HMAC *)&(source->hmac), buffer, size);
3709 #endif // ALG_HMAC
3710 case TPM_ALG_NULL:
3711 return 0;
3712 }
3713 return 0;
3714 }
3715
3716 // Table 2:162 - Definition of TPMT_SIG_SCHEME Structure
3717 TPM_RC
TPMT_SIG_SCHEME_Unmarshal(TPMT_SIG_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)3718 TPMT_SIG_SCHEME_Unmarshal(TPMT_SIG_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
3719 {
3720 TPM_RC result;
3721 result = TPMI_ALG_SIG_SCHEME_Unmarshal((TPMI_ALG_SIG_SCHEME *)&(target->scheme), buffer, size, flag);
3722 if(result == TPM_RC_SUCCESS)
3723 result = TPMU_SIG_SCHEME_Unmarshal((TPMU_SIG_SCHEME *)&(target->details), buffer, size, (UINT32)target->scheme);
3724 return result;
3725 }
3726 UINT16
TPMT_SIG_SCHEME_Marshal(TPMT_SIG_SCHEME * source,BYTE ** buffer,INT32 * size)3727 TPMT_SIG_SCHEME_Marshal(TPMT_SIG_SCHEME *source, BYTE **buffer, INT32 *size)
3728 {
3729 UINT16 result = 0;
3730 result = (UINT16)(result + TPMI_ALG_SIG_SCHEME_Marshal((TPMI_ALG_SIG_SCHEME *)&(source->scheme), buffer, size));
3731 result = (UINT16)(result + TPMU_SIG_SCHEME_Marshal((TPMU_SIG_SCHEME *)&(source->details), buffer, size, (UINT32)source->scheme));
3732 return result;
3733 }
3734
3735 // Table 2:163 - Definition of Types for Encryption Schemes
3736 #if ALG_RSA
3737 #if !USE_MARSHALING_DEFINES
3738 TPM_RC
TPMS_ENC_SCHEME_OAEP_Unmarshal(TPMS_ENC_SCHEME_OAEP * target,BYTE ** buffer,INT32 * size)3739 TPMS_ENC_SCHEME_OAEP_Unmarshal(TPMS_ENC_SCHEME_OAEP *target, BYTE **buffer, INT32 *size)
3740 {
3741 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3742 }
3743 UINT16
TPMS_ENC_SCHEME_OAEP_Marshal(TPMS_ENC_SCHEME_OAEP * source,BYTE ** buffer,INT32 * size)3744 TPMS_ENC_SCHEME_OAEP_Marshal(TPMS_ENC_SCHEME_OAEP *source, BYTE **buffer, INT32 *size)
3745 {
3746 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3747 }
3748 TPM_RC
TPMS_ENC_SCHEME_RSAES_Unmarshal(TPMS_ENC_SCHEME_RSAES * target,BYTE ** buffer,INT32 * size)3749 TPMS_ENC_SCHEME_RSAES_Unmarshal(TPMS_ENC_SCHEME_RSAES *target, BYTE **buffer, INT32 *size)
3750 {
3751 return TPMS_EMPTY_Unmarshal((TPMS_EMPTY *)target, buffer, size);
3752 }
3753 UINT16
TPMS_ENC_SCHEME_RSAES_Marshal(TPMS_ENC_SCHEME_RSAES * source,BYTE ** buffer,INT32 * size)3754 TPMS_ENC_SCHEME_RSAES_Marshal(TPMS_ENC_SCHEME_RSAES *source, BYTE **buffer, INT32 *size)
3755 {
3756 return TPMS_EMPTY_Marshal((TPMS_EMPTY *)source, buffer, size);
3757 }
3758 #endif // !USE_MARSHALING_DEFINES
3759 #endif // ALG_RSA
3760
3761 // Table 2:164 - Definition of Types for ECC Key Exchange
3762 #if ALG_ECC
3763 #if !USE_MARSHALING_DEFINES
3764 TPM_RC
TPMS_KEY_SCHEME_ECDH_Unmarshal(TPMS_KEY_SCHEME_ECDH * target,BYTE ** buffer,INT32 * size)3765 TPMS_KEY_SCHEME_ECDH_Unmarshal(TPMS_KEY_SCHEME_ECDH *target, BYTE **buffer, INT32 *size)
3766 {
3767 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3768 }
3769 UINT16
TPMS_KEY_SCHEME_ECDH_Marshal(TPMS_KEY_SCHEME_ECDH * source,BYTE ** buffer,INT32 * size)3770 TPMS_KEY_SCHEME_ECDH_Marshal(TPMS_KEY_SCHEME_ECDH *source, BYTE **buffer, INT32 *size)
3771 {
3772 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3773 }
3774 TPM_RC
TPMS_KEY_SCHEME_ECMQV_Unmarshal(TPMS_KEY_SCHEME_ECMQV * target,BYTE ** buffer,INT32 * size)3775 TPMS_KEY_SCHEME_ECMQV_Unmarshal(TPMS_KEY_SCHEME_ECMQV *target, BYTE **buffer, INT32 *size)
3776 {
3777 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3778 }
3779 UINT16
TPMS_KEY_SCHEME_ECMQV_Marshal(TPMS_KEY_SCHEME_ECMQV * source,BYTE ** buffer,INT32 * size)3780 TPMS_KEY_SCHEME_ECMQV_Marshal(TPMS_KEY_SCHEME_ECMQV *source, BYTE **buffer, INT32 *size)
3781 {
3782 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3783 }
3784 #endif // !USE_MARSHALING_DEFINES
3785 #endif // ALG_ECC
3786
3787 // Table 2:165 - Definition of Types for KDF Schemes
3788 #if !USE_MARSHALING_DEFINES
3789 TPM_RC
TPMS_KDF_SCHEME_MGF1_Unmarshal(TPMS_KDF_SCHEME_MGF1 * target,BYTE ** buffer,INT32 * size)3790 TPMS_KDF_SCHEME_MGF1_Unmarshal(TPMS_KDF_SCHEME_MGF1 *target, BYTE **buffer, INT32 *size)
3791 {
3792 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3793 }
3794 UINT16
TPMS_KDF_SCHEME_MGF1_Marshal(TPMS_KDF_SCHEME_MGF1 * source,BYTE ** buffer,INT32 * size)3795 TPMS_KDF_SCHEME_MGF1_Marshal(TPMS_KDF_SCHEME_MGF1 *source, BYTE **buffer, INT32 *size)
3796 {
3797 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3798 }
3799 TPM_RC
TPMS_KDF_SCHEME_KDF1_SP800_56A_Unmarshal(TPMS_KDF_SCHEME_KDF1_SP800_56A * target,BYTE ** buffer,INT32 * size)3800 TPMS_KDF_SCHEME_KDF1_SP800_56A_Unmarshal(TPMS_KDF_SCHEME_KDF1_SP800_56A *target, BYTE **buffer, INT32 *size)
3801 {
3802 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3803 }
3804 UINT16
TPMS_KDF_SCHEME_KDF1_SP800_56A_Marshal(TPMS_KDF_SCHEME_KDF1_SP800_56A * source,BYTE ** buffer,INT32 * size)3805 TPMS_KDF_SCHEME_KDF1_SP800_56A_Marshal(TPMS_KDF_SCHEME_KDF1_SP800_56A *source, BYTE **buffer, INT32 *size)
3806 {
3807 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3808 }
3809 TPM_RC
TPMS_KDF_SCHEME_KDF2_Unmarshal(TPMS_KDF_SCHEME_KDF2 * target,BYTE ** buffer,INT32 * size)3810 TPMS_KDF_SCHEME_KDF2_Unmarshal(TPMS_KDF_SCHEME_KDF2 *target, BYTE **buffer, INT32 *size)
3811 {
3812 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3813 }
3814 UINT16
TPMS_KDF_SCHEME_KDF2_Marshal(TPMS_KDF_SCHEME_KDF2 * source,BYTE ** buffer,INT32 * size)3815 TPMS_KDF_SCHEME_KDF2_Marshal(TPMS_KDF_SCHEME_KDF2 *source, BYTE **buffer, INT32 *size)
3816 {
3817 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3818 }
3819 TPM_RC
TPMS_KDF_SCHEME_KDF1_SP800_108_Unmarshal(TPMS_KDF_SCHEME_KDF1_SP800_108 * target,BYTE ** buffer,INT32 * size)3820 TPMS_KDF_SCHEME_KDF1_SP800_108_Unmarshal(TPMS_KDF_SCHEME_KDF1_SP800_108 *target, BYTE **buffer, INT32 *size)
3821 {
3822 return TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)target, buffer, size);
3823 }
3824 UINT16
TPMS_KDF_SCHEME_KDF1_SP800_108_Marshal(TPMS_KDF_SCHEME_KDF1_SP800_108 * source,BYTE ** buffer,INT32 * size)3825 TPMS_KDF_SCHEME_KDF1_SP800_108_Marshal(TPMS_KDF_SCHEME_KDF1_SP800_108 *source, BYTE **buffer, INT32 *size)
3826 {
3827 return TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)source, buffer, size);
3828 }
3829 #endif // !USE_MARSHALING_DEFINES
3830
3831 // Table 2:166 - Definition of TPMU_KDF_SCHEME Union
3832 TPM_RC
TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)3833 TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME *target, BYTE **buffer, INT32 *size, UINT32 selector)
3834 {
3835 switch(selector) {
3836 #if ALG_MGF1
3837 case TPM_ALG_MGF1:
3838 return TPMS_KDF_SCHEME_MGF1_Unmarshal((TPMS_KDF_SCHEME_MGF1 *)&(target->mgf1), buffer, size);
3839 #endif // ALG_MGF1
3840 #if ALG_KDF1_SP800_56A
3841 case TPM_ALG_KDF1_SP800_56A:
3842 return TPMS_KDF_SCHEME_KDF1_SP800_56A_Unmarshal((TPMS_KDF_SCHEME_KDF1_SP800_56A *)&(target->kdf1_sp800_56a), buffer, size);
3843 #endif // ALG_KDF1_SP800_56A
3844 #if ALG_KDF2
3845 case TPM_ALG_KDF2:
3846 return TPMS_KDF_SCHEME_KDF2_Unmarshal((TPMS_KDF_SCHEME_KDF2 *)&(target->kdf2), buffer, size);
3847 #endif // ALG_KDF2
3848 #if ALG_KDF1_SP800_108
3849 case TPM_ALG_KDF1_SP800_108:
3850 return TPMS_KDF_SCHEME_KDF1_SP800_108_Unmarshal((TPMS_KDF_SCHEME_KDF1_SP800_108 *)&(target->kdf1_sp800_108), buffer, size);
3851 #endif // ALG_KDF1_SP800_108
3852 case TPM_ALG_NULL:
3853 return TPM_RC_SUCCESS;
3854 }
3855 return TPM_RC_SELECTOR;
3856 }
3857 UINT16
TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)3858 TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME *source, BYTE **buffer, INT32 *size, UINT32 selector)
3859 {
3860 switch(selector) {
3861 #if ALG_MGF1
3862 case TPM_ALG_MGF1:
3863 return TPMS_KDF_SCHEME_MGF1_Marshal((TPMS_KDF_SCHEME_MGF1 *)&(source->mgf1), buffer, size);
3864 #endif // ALG_MGF1
3865 #if ALG_KDF1_SP800_56A
3866 case TPM_ALG_KDF1_SP800_56A:
3867 return TPMS_KDF_SCHEME_KDF1_SP800_56A_Marshal((TPMS_KDF_SCHEME_KDF1_SP800_56A *)&(source->kdf1_sp800_56a), buffer, size);
3868 #endif // ALG_KDF1_SP800_56A
3869 #if ALG_KDF2
3870 case TPM_ALG_KDF2:
3871 return TPMS_KDF_SCHEME_KDF2_Marshal((TPMS_KDF_SCHEME_KDF2 *)&(source->kdf2), buffer, size);
3872 #endif // ALG_KDF2
3873 #if ALG_KDF1_SP800_108
3874 case TPM_ALG_KDF1_SP800_108:
3875 return TPMS_KDF_SCHEME_KDF1_SP800_108_Marshal((TPMS_KDF_SCHEME_KDF1_SP800_108 *)&(source->kdf1_sp800_108), buffer, size);
3876 #endif // ALG_KDF1_SP800_108
3877 case TPM_ALG_NULL:
3878 return 0;
3879 }
3880 return 0;
3881 }
3882
3883 // Table 2:167 - Definition of TPMT_KDF_SCHEME Structure
3884 TPM_RC
TPMT_KDF_SCHEME_Unmarshal(TPMT_KDF_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)3885 TPMT_KDF_SCHEME_Unmarshal(TPMT_KDF_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
3886 {
3887 TPM_RC result;
3888 result = TPMI_ALG_KDF_Unmarshal((TPMI_ALG_KDF *)&(target->scheme), buffer, size, flag);
3889 if(result == TPM_RC_SUCCESS)
3890 result = TPMU_KDF_SCHEME_Unmarshal((TPMU_KDF_SCHEME *)&(target->details), buffer, size, (UINT32)target->scheme);
3891 return result;
3892 }
3893 UINT16
TPMT_KDF_SCHEME_Marshal(TPMT_KDF_SCHEME * source,BYTE ** buffer,INT32 * size)3894 TPMT_KDF_SCHEME_Marshal(TPMT_KDF_SCHEME *source, BYTE **buffer, INT32 *size)
3895 {
3896 UINT16 result = 0;
3897 result = (UINT16)(result + TPMI_ALG_KDF_Marshal((TPMI_ALG_KDF *)&(source->scheme), buffer, size));
3898 result = (UINT16)(result + TPMU_KDF_SCHEME_Marshal((TPMU_KDF_SCHEME *)&(source->details), buffer, size, (UINT32)source->scheme));
3899 return result;
3900 }
3901
3902 // Table 2:168 - Definition of TPMI_ALG_ASYM_SCHEME Type
3903 TPM_RC
TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)3904 TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
3905 {
3906 TPM_RC result;
3907 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
3908 if(result == TPM_RC_SUCCESS)
3909 {
3910 switch (*target)
3911 {
3912 #if ALG_ECDH
3913 case TPM_ALG_ECDH:
3914 #endif // ALG_ECDH
3915 #if ALG_ECMQV
3916 case TPM_ALG_ECMQV:
3917 #endif // ALG_ECMQV
3918 #if ALG_ECDAA
3919 case TPM_ALG_ECDAA:
3920 #endif // ALG_ECDAA
3921 #if ALG_RSASSA
3922 case TPM_ALG_RSASSA:
3923 #endif // ALG_RSASSA
3924 #if ALG_RSAPSS
3925 case TPM_ALG_RSAPSS:
3926 #endif // ALG_RSAPSS
3927 #if ALG_ECDSA
3928 case TPM_ALG_ECDSA:
3929 #endif // ALG_ECDSA
3930 #if ALG_SM2
3931 case TPM_ALG_SM2:
3932 #endif // ALG_SM2
3933 #if ALG_ECSCHNORR
3934 case TPM_ALG_ECSCHNORR:
3935 #endif // ALG_ECSCHNORR
3936 #if ALG_RSAES
3937 case TPM_ALG_RSAES:
3938 #endif // ALG_RSAES
3939 #if ALG_OAEP
3940 case TPM_ALG_OAEP:
3941 #endif // ALG_OAEP
3942 break;
3943 case TPM_ALG_NULL:
3944 if(!flag)
3945 result = TPM_RC_VALUE;
3946 break;
3947 default:
3948 result = TPM_RC_VALUE;
3949 break;
3950 }
3951 }
3952 return result;
3953 }
3954 #if !USE_MARSHALING_DEFINES
3955 UINT16
TPMI_ALG_ASYM_SCHEME_Marshal(TPMI_ALG_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size)3956 TPMI_ALG_ASYM_SCHEME_Marshal(TPMI_ALG_ASYM_SCHEME *source, BYTE **buffer, INT32 *size)
3957 {
3958 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
3959 }
3960 #endif // !USE_MARSHALING_DEFINES
3961
3962 // Table 2:169 - Definition of TPMU_ASYM_SCHEME Union
3963 TPM_RC
TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME * target,BYTE ** buffer,INT32 * size,UINT32 selector)3964 TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME *target, BYTE **buffer, INT32 *size, UINT32 selector)
3965 {
3966 switch(selector) {
3967 #if ALG_ECDH
3968 case TPM_ALG_ECDH:
3969 return TPMS_KEY_SCHEME_ECDH_Unmarshal((TPMS_KEY_SCHEME_ECDH *)&(target->ecdh), buffer, size);
3970 #endif // ALG_ECDH
3971 #if ALG_ECMQV
3972 case TPM_ALG_ECMQV:
3973 return TPMS_KEY_SCHEME_ECMQV_Unmarshal((TPMS_KEY_SCHEME_ECMQV *)&(target->ecmqv), buffer, size);
3974 #endif // ALG_ECMQV
3975 #if ALG_ECDAA
3976 case TPM_ALG_ECDAA:
3977 return TPMS_SIG_SCHEME_ECDAA_Unmarshal((TPMS_SIG_SCHEME_ECDAA *)&(target->ecdaa), buffer, size);
3978 #endif // ALG_ECDAA
3979 #if ALG_RSASSA
3980 case TPM_ALG_RSASSA:
3981 return TPMS_SIG_SCHEME_RSASSA_Unmarshal((TPMS_SIG_SCHEME_RSASSA *)&(target->rsassa), buffer, size);
3982 #endif // ALG_RSASSA
3983 #if ALG_RSAPSS
3984 case TPM_ALG_RSAPSS:
3985 return TPMS_SIG_SCHEME_RSAPSS_Unmarshal((TPMS_SIG_SCHEME_RSAPSS *)&(target->rsapss), buffer, size);
3986 #endif // ALG_RSAPSS
3987 #if ALG_ECDSA
3988 case TPM_ALG_ECDSA:
3989 return TPMS_SIG_SCHEME_ECDSA_Unmarshal((TPMS_SIG_SCHEME_ECDSA *)&(target->ecdsa), buffer, size);
3990 #endif // ALG_ECDSA
3991 #if ALG_SM2
3992 case TPM_ALG_SM2:
3993 return TPMS_SIG_SCHEME_SM2_Unmarshal((TPMS_SIG_SCHEME_SM2 *)&(target->sm2), buffer, size);
3994 #endif // ALG_SM2
3995 #if ALG_ECSCHNORR
3996 case TPM_ALG_ECSCHNORR:
3997 return TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal((TPMS_SIG_SCHEME_ECSCHNORR *)&(target->ecschnorr), buffer, size);
3998 #endif // ALG_ECSCHNORR
3999 #if ALG_RSAES
4000 case TPM_ALG_RSAES:
4001 return TPMS_ENC_SCHEME_RSAES_Unmarshal((TPMS_ENC_SCHEME_RSAES *)&(target->rsaes), buffer, size);
4002 #endif // ALG_RSAES
4003 #if ALG_OAEP
4004 case TPM_ALG_OAEP:
4005 return TPMS_ENC_SCHEME_OAEP_Unmarshal((TPMS_ENC_SCHEME_OAEP *)&(target->oaep), buffer, size);
4006 #endif // ALG_OAEP
4007 case TPM_ALG_NULL:
4008 return TPM_RC_SUCCESS;
4009 }
4010 return TPM_RC_SELECTOR;
4011 }
4012 UINT16
TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME * source,BYTE ** buffer,INT32 * size,UINT32 selector)4013 TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME *source, BYTE **buffer, INT32 *size, UINT32 selector)
4014 {
4015 switch(selector) {
4016 #if ALG_ECDH
4017 case TPM_ALG_ECDH:
4018 return TPMS_KEY_SCHEME_ECDH_Marshal((TPMS_KEY_SCHEME_ECDH *)&(source->ecdh), buffer, size);
4019 #endif // ALG_ECDH
4020 #if ALG_ECMQV
4021 case TPM_ALG_ECMQV:
4022 return TPMS_KEY_SCHEME_ECMQV_Marshal((TPMS_KEY_SCHEME_ECMQV *)&(source->ecmqv), buffer, size);
4023 #endif // ALG_ECMQV
4024 #if ALG_ECDAA
4025 case TPM_ALG_ECDAA:
4026 return TPMS_SIG_SCHEME_ECDAA_Marshal((TPMS_SIG_SCHEME_ECDAA *)&(source->ecdaa), buffer, size);
4027 #endif // ALG_ECDAA
4028 #if ALG_RSASSA
4029 case TPM_ALG_RSASSA:
4030 return TPMS_SIG_SCHEME_RSASSA_Marshal((TPMS_SIG_SCHEME_RSASSA *)&(source->rsassa), buffer, size);
4031 #endif // ALG_RSASSA
4032 #if ALG_RSAPSS
4033 case TPM_ALG_RSAPSS:
4034 return TPMS_SIG_SCHEME_RSAPSS_Marshal((TPMS_SIG_SCHEME_RSAPSS *)&(source->rsapss), buffer, size);
4035 #endif // ALG_RSAPSS
4036 #if ALG_ECDSA
4037 case TPM_ALG_ECDSA:
4038 return TPMS_SIG_SCHEME_ECDSA_Marshal((TPMS_SIG_SCHEME_ECDSA *)&(source->ecdsa), buffer, size);
4039 #endif // ALG_ECDSA
4040 #if ALG_SM2
4041 case TPM_ALG_SM2:
4042 return TPMS_SIG_SCHEME_SM2_Marshal((TPMS_SIG_SCHEME_SM2 *)&(source->sm2), buffer, size);
4043 #endif // ALG_SM2
4044 #if ALG_ECSCHNORR
4045 case TPM_ALG_ECSCHNORR:
4046 return TPMS_SIG_SCHEME_ECSCHNORR_Marshal((TPMS_SIG_SCHEME_ECSCHNORR *)&(source->ecschnorr), buffer, size);
4047 #endif // ALG_ECSCHNORR
4048 #if ALG_RSAES
4049 case TPM_ALG_RSAES:
4050 return TPMS_ENC_SCHEME_RSAES_Marshal((TPMS_ENC_SCHEME_RSAES *)&(source->rsaes), buffer, size);
4051 #endif // ALG_RSAES
4052 #if ALG_OAEP
4053 case TPM_ALG_OAEP:
4054 return TPMS_ENC_SCHEME_OAEP_Marshal((TPMS_ENC_SCHEME_OAEP *)&(source->oaep), buffer, size);
4055 #endif // ALG_OAEP
4056 case TPM_ALG_NULL:
4057 return 0;
4058 }
4059 return 0;
4060 }
4061
4062 // Table 2:170 - Definition of TPMT_ASYM_SCHEME Structure
4063 // Table 2:171 - Definition of TPMI_ALG_RSA_SCHEME Type
4064 #if ALG_RSA
4065 TPM_RC
TPMI_ALG_RSA_SCHEME_Unmarshal(TPMI_ALG_RSA_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)4066 TPMI_ALG_RSA_SCHEME_Unmarshal(TPMI_ALG_RSA_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
4067 {
4068 TPM_RC result;
4069 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
4070 if(result == TPM_RC_SUCCESS)
4071 {
4072 switch (*target)
4073 {
4074 #if ALG_RSAES
4075 case TPM_ALG_RSAES:
4076 #endif // ALG_RSAES
4077 #if ALG_OAEP
4078 case TPM_ALG_OAEP:
4079 #endif // ALG_OAEP
4080 #if ALG_RSASSA
4081 case TPM_ALG_RSASSA:
4082 #endif // ALG_RSASSA
4083 #if ALG_RSAPSS
4084 case TPM_ALG_RSAPSS:
4085 #endif // ALG_RSAPSS
4086 break;
4087 case TPM_ALG_NULL:
4088 if(!flag)
4089 result = TPM_RC_VALUE;
4090 break;
4091 default:
4092 result = TPM_RC_VALUE;
4093 break;
4094 }
4095 }
4096 return result;
4097 }
4098 #if !USE_MARSHALING_DEFINES
4099 UINT16
TPMI_ALG_RSA_SCHEME_Marshal(TPMI_ALG_RSA_SCHEME * source,BYTE ** buffer,INT32 * size)4100 TPMI_ALG_RSA_SCHEME_Marshal(TPMI_ALG_RSA_SCHEME *source, BYTE **buffer, INT32 *size)
4101 {
4102 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
4103 }
4104 #endif // !USE_MARSHALING_DEFINES
4105 #endif // ALG_RSA
4106
4107 // Table 2:172 - Definition of TPMT_RSA_SCHEME Structure
4108 #if ALG_RSA
4109 TPM_RC
TPMT_RSA_SCHEME_Unmarshal(TPMT_RSA_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)4110 TPMT_RSA_SCHEME_Unmarshal(TPMT_RSA_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
4111 {
4112 TPM_RC result;
4113 result = TPMI_ALG_RSA_SCHEME_Unmarshal((TPMI_ALG_RSA_SCHEME *)&(target->scheme), buffer, size, flag);
4114 if(result == TPM_RC_SUCCESS)
4115 result = TPMU_ASYM_SCHEME_Unmarshal((TPMU_ASYM_SCHEME *)&(target->details), buffer, size, (UINT32)target->scheme);
4116 return result;
4117 }
4118 UINT16
TPMT_RSA_SCHEME_Marshal(TPMT_RSA_SCHEME * source,BYTE ** buffer,INT32 * size)4119 TPMT_RSA_SCHEME_Marshal(TPMT_RSA_SCHEME *source, BYTE **buffer, INT32 *size)
4120 {
4121 UINT16 result = 0;
4122 result = (UINT16)(result + TPMI_ALG_RSA_SCHEME_Marshal((TPMI_ALG_RSA_SCHEME *)&(source->scheme), buffer, size));
4123 result = (UINT16)(result + TPMU_ASYM_SCHEME_Marshal((TPMU_ASYM_SCHEME *)&(source->details), buffer, size, (UINT32)source->scheme));
4124 return result;
4125 }
4126 #endif // ALG_RSA
4127
4128 // Table 2:173 - Definition of TPMI_ALG_RSA_DECRYPT Type
4129 #if ALG_RSA
4130 TPM_RC
TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT * target,BYTE ** buffer,INT32 * size,BOOL flag)4131 TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT *target, BYTE **buffer, INT32 *size, BOOL flag)
4132 {
4133 TPM_RC result;
4134 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
4135 if(result == TPM_RC_SUCCESS)
4136 {
4137 switch (*target)
4138 {
4139 #if ALG_RSAES
4140 case TPM_ALG_RSAES:
4141 #endif // ALG_RSAES
4142 #if ALG_OAEP
4143 case TPM_ALG_OAEP:
4144 #endif // ALG_OAEP
4145 break;
4146 case TPM_ALG_NULL:
4147 if(!flag)
4148 result = TPM_RC_VALUE;
4149 break;
4150 default:
4151 result = TPM_RC_VALUE;
4152 break;
4153 }
4154 }
4155 return result;
4156 }
4157 #if !USE_MARSHALING_DEFINES
4158 UINT16
TPMI_ALG_RSA_DECRYPT_Marshal(TPMI_ALG_RSA_DECRYPT * source,BYTE ** buffer,INT32 * size)4159 TPMI_ALG_RSA_DECRYPT_Marshal(TPMI_ALG_RSA_DECRYPT *source, BYTE **buffer, INT32 *size)
4160 {
4161 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
4162 }
4163 #endif // !USE_MARSHALING_DEFINES
4164 #endif // ALG_RSA
4165
4166 // Table 2:174 - Definition of TPMT_RSA_DECRYPT Structure
4167 #if ALG_RSA
4168 TPM_RC
TPMT_RSA_DECRYPT_Unmarshal(TPMT_RSA_DECRYPT * target,BYTE ** buffer,INT32 * size,BOOL flag)4169 TPMT_RSA_DECRYPT_Unmarshal(TPMT_RSA_DECRYPT *target, BYTE **buffer, INT32 *size, BOOL flag)
4170 {
4171 TPM_RC result;
4172 result = TPMI_ALG_RSA_DECRYPT_Unmarshal((TPMI_ALG_RSA_DECRYPT *)&(target->scheme), buffer, size, flag);
4173 if(result == TPM_RC_SUCCESS)
4174 result = TPMU_ASYM_SCHEME_Unmarshal((TPMU_ASYM_SCHEME *)&(target->details), buffer, size, (UINT32)target->scheme);
4175 return result;
4176 }
4177 UINT16
TPMT_RSA_DECRYPT_Marshal(TPMT_RSA_DECRYPT * source,BYTE ** buffer,INT32 * size)4178 TPMT_RSA_DECRYPT_Marshal(TPMT_RSA_DECRYPT *source, BYTE **buffer, INT32 *size)
4179 {
4180 UINT16 result = 0;
4181 result = (UINT16)(result + TPMI_ALG_RSA_DECRYPT_Marshal((TPMI_ALG_RSA_DECRYPT *)&(source->scheme), buffer, size));
4182 result = (UINT16)(result + TPMU_ASYM_SCHEME_Marshal((TPMU_ASYM_SCHEME *)&(source->details), buffer, size, (UINT32)source->scheme));
4183 return result;
4184 }
4185 #endif // ALG_RSA
4186
4187 // Table 2:175 - Definition of TPM2B_PUBLIC_KEY_RSA Structure
4188 #if ALG_RSA
4189 TPM_RC
TPM2B_PUBLIC_KEY_RSA_Unmarshal(TPM2B_PUBLIC_KEY_RSA * target,BYTE ** buffer,INT32 * size)4190 TPM2B_PUBLIC_KEY_RSA_Unmarshal(TPM2B_PUBLIC_KEY_RSA *target, BYTE **buffer, INT32 *size)
4191 {
4192 TPM_RC result;
4193 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
4194 if(result == TPM_RC_SUCCESS)
4195 {
4196 if((target->t.size) > MAX_RSA_KEY_BYTES)
4197 result = TPM_RC_SIZE;
4198 else
4199 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
4200 }
4201 return result;
4202 }
4203 UINT16
TPM2B_PUBLIC_KEY_RSA_Marshal(TPM2B_PUBLIC_KEY_RSA * source,BYTE ** buffer,INT32 * size)4204 TPM2B_PUBLIC_KEY_RSA_Marshal(TPM2B_PUBLIC_KEY_RSA *source, BYTE **buffer, INT32 *size)
4205 {
4206 UINT16 result = 0;
4207 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
4208 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
4209 if(source->t.size == 0)
4210 return result;
4211 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
4212 return result;
4213 }
4214 #endif // ALG_RSA
4215
4216 // Table 2:176 - Definition of TPMI_RSA_KEY_BITS Type
4217 #if ALG_RSA
4218 TPM_RC
TPMI_RSA_KEY_BITS_Unmarshal(TPMI_RSA_KEY_BITS * target,BYTE ** buffer,INT32 * size)4219 TPMI_RSA_KEY_BITS_Unmarshal(TPMI_RSA_KEY_BITS *target, BYTE **buffer, INT32 *size)
4220 {
4221 TPM_RC result;
4222 result = TPM_KEY_BITS_Unmarshal((TPM_KEY_BITS *)target, buffer, size);
4223 if(result == TPM_RC_SUCCESS)
4224 {
4225 switch (*target)
4226 {
4227 #if RSA_1024
4228 case 1024:
4229 #endif // RSA_1024
4230 #if RSA_2048
4231 case 2048:
4232 #endif // RSA_2048
4233 #if RSA_3072
4234 case 3072:
4235 #endif // RSA_3072
4236 #if RSA_4096
4237 case 4096:
4238 #endif // RSA_4096
4239 #if RSA_16384
4240 case 16384:
4241 #endif // RSA_16384
4242 break;
4243 default:
4244 result = TPM_RC_VALUE;
4245 break;
4246 }
4247 }
4248 return result;
4249 }
4250 #if !USE_MARSHALING_DEFINES
4251 UINT16
TPMI_RSA_KEY_BITS_Marshal(TPMI_RSA_KEY_BITS * source,BYTE ** buffer,INT32 * size)4252 TPMI_RSA_KEY_BITS_Marshal(TPMI_RSA_KEY_BITS *source, BYTE **buffer, INT32 *size)
4253 {
4254 return TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)source, buffer, size);
4255 }
4256 #endif // !USE_MARSHALING_DEFINES
4257 #endif // ALG_RSA
4258
4259 // Table 2:177 - Definition of TPM2B_PRIVATE_KEY_RSA Structure
4260 #if ALG_RSA
4261 TPM_RC
TPM2B_PRIVATE_KEY_RSA_Unmarshal(TPM2B_PRIVATE_KEY_RSA * target,BYTE ** buffer,INT32 * size)4262 TPM2B_PRIVATE_KEY_RSA_Unmarshal(TPM2B_PRIVATE_KEY_RSA *target, BYTE **buffer, INT32 *size)
4263 {
4264 TPM_RC result;
4265 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
4266 if(result == TPM_RC_SUCCESS)
4267 {
4268 if((target->t.size) > RSA_PRIVATE_SIZE)
4269 result = TPM_RC_SIZE;
4270 else
4271 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
4272 }
4273 return result;
4274 }
4275 UINT16
TPM2B_PRIVATE_KEY_RSA_Marshal(TPM2B_PRIVATE_KEY_RSA * source,BYTE ** buffer,INT32 * size)4276 TPM2B_PRIVATE_KEY_RSA_Marshal(TPM2B_PRIVATE_KEY_RSA *source, BYTE **buffer, INT32 *size)
4277 {
4278 UINT16 result = 0;
4279 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
4280 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
4281 if(source->t.size == 0)
4282 return result;
4283 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
4284 return result;
4285 }
4286 #endif // ALG_RSA
4287
4288 // Table 2:178 - Definition of TPM2B_ECC_PARAMETER Structure
4289 TPM_RC
TPM2B_ECC_PARAMETER_Unmarshal(TPM2B_ECC_PARAMETER * target,BYTE ** buffer,INT32 * size)4290 TPM2B_ECC_PARAMETER_Unmarshal(TPM2B_ECC_PARAMETER *target, BYTE **buffer, INT32 *size)
4291 {
4292 TPM_RC result;
4293 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
4294 if(result == TPM_RC_SUCCESS)
4295 {
4296 if((target->t.size) > MAX_ECC_KEY_BYTES)
4297 result = TPM_RC_SIZE;
4298 else
4299 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
4300 }
4301 return result;
4302 }
4303 UINT16
TPM2B_ECC_PARAMETER_Marshal(TPM2B_ECC_PARAMETER * source,BYTE ** buffer,INT32 * size)4304 TPM2B_ECC_PARAMETER_Marshal(TPM2B_ECC_PARAMETER *source, BYTE **buffer, INT32 *size)
4305 {
4306 UINT16 result = 0;
4307 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
4308 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
4309 if(source->t.size == 0)
4310 return result;
4311 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
4312 return result;
4313 }
4314
4315 // Table 2:179 - Definition of TPMS_ECC_POINT Structure
4316 #if ALG_ECC
4317 TPM_RC
TPMS_ECC_POINT_Unmarshal(TPMS_ECC_POINT * target,BYTE ** buffer,INT32 * size)4318 TPMS_ECC_POINT_Unmarshal(TPMS_ECC_POINT *target, BYTE **buffer, INT32 *size)
4319 {
4320 TPM_RC result;
4321 result = TPM2B_ECC_PARAMETER_Unmarshal((TPM2B_ECC_PARAMETER *)&(target->x), buffer, size);
4322 if(result == TPM_RC_SUCCESS)
4323 result = TPM2B_ECC_PARAMETER_Unmarshal((TPM2B_ECC_PARAMETER *)&(target->y), buffer, size);
4324 return result;
4325 }
4326 UINT16
TPMS_ECC_POINT_Marshal(TPMS_ECC_POINT * source,BYTE ** buffer,INT32 * size)4327 TPMS_ECC_POINT_Marshal(TPMS_ECC_POINT *source, BYTE **buffer, INT32 *size)
4328 {
4329 UINT16 result = 0;
4330 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->x), buffer, size));
4331 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->y), buffer, size));
4332 return result;
4333 }
4334 #endif // ALG_ECC
4335
4336 // Table 2:180 - Definition of TPM2B_ECC_POINT Structure
4337 #if ALG_ECC
4338 TPM_RC
TPM2B_ECC_POINT_Unmarshal(TPM2B_ECC_POINT * target,BYTE ** buffer,INT32 * size)4339 TPM2B_ECC_POINT_Unmarshal(TPM2B_ECC_POINT *target, BYTE **buffer, INT32 *size)
4340 {
4341 TPM_RC result;
4342 result = UINT16_Unmarshal((UINT16 *)&(target->size), buffer, size); // =a
4343 if(result == TPM_RC_SUCCESS)
4344 {
4345 // if size is zero, then the required structure is missing
4346 if(target->size == 0)
4347 result = TPM_RC_SIZE;
4348 else
4349 {
4350 INT32 startSize = *size;
4351 result = TPMS_ECC_POINT_Unmarshal((TPMS_ECC_POINT *)&(target->point), buffer, size); // =b
4352 if(result == TPM_RC_SUCCESS)
4353 {
4354 if(target->size != (startSize - *size))
4355 result = TPM_RC_SIZE;
4356 }
4357 }
4358 }
4359 return result;
4360 }
4361 UINT16
TPM2B_ECC_POINT_Marshal(TPM2B_ECC_POINT * source,BYTE ** buffer,INT32 * size)4362 TPM2B_ECC_POINT_Marshal(TPM2B_ECC_POINT *source, BYTE **buffer, INT32 *size)
4363 {
4364 UINT16 result = 0;
4365 // Marshal a dummy value of the 2B size. This makes sure that 'buffer'
4366 // and 'size' are advanced as necessary (i.e., if they are present)
4367 result = UINT16_Marshal(&result, buffer, size);
4368 // Marshal the structure
4369 result = (UINT16)(result + TPMS_ECC_POINT_Marshal((TPMS_ECC_POINT *)&(source->point), buffer, size));
4370 // if a buffer was provided, go back and fill in the actual size
4371 if(buffer != NULL)
4372 UINT16_TO_BYTE_ARRAY((result - 2), (*buffer - result));
4373 return result;
4374 }
4375 #endif // ALG_ECC
4376
4377 // Table 2:181 - Definition of TPMI_ALG_ECC_SCHEME Type
4378 #if ALG_ECC
4379 TPM_RC
TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)4380 TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
4381 {
4382 TPM_RC result;
4383 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
4384 if(result == TPM_RC_SUCCESS)
4385 {
4386 switch (*target)
4387 {
4388 #if ALG_ECDAA
4389 case TPM_ALG_ECDAA:
4390 #endif // ALG_ECDAA
4391 #if ALG_ECDSA
4392 case TPM_ALG_ECDSA:
4393 #endif // ALG_ECDSA
4394 #if ALG_SM2
4395 case TPM_ALG_SM2:
4396 #endif // ALG_SM2
4397 #if ALG_ECSCHNORR
4398 case TPM_ALG_ECSCHNORR:
4399 #endif // ALG_ECSCHNORR
4400 #if ALG_ECDH
4401 case TPM_ALG_ECDH:
4402 #endif // ALG_ECDH
4403 #if ALG_ECMQV
4404 case TPM_ALG_ECMQV:
4405 #endif // ALG_ECMQV
4406 break;
4407 case TPM_ALG_NULL:
4408 if(!flag)
4409 result = TPM_RC_SCHEME;
4410 break;
4411 default:
4412 result = TPM_RC_SCHEME;
4413 break;
4414 }
4415 }
4416 return result;
4417 }
4418 #if !USE_MARSHALING_DEFINES
4419 UINT16
TPMI_ALG_ECC_SCHEME_Marshal(TPMI_ALG_ECC_SCHEME * source,BYTE ** buffer,INT32 * size)4420 TPMI_ALG_ECC_SCHEME_Marshal(TPMI_ALG_ECC_SCHEME *source, BYTE **buffer, INT32 *size)
4421 {
4422 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
4423 }
4424 #endif // !USE_MARSHALING_DEFINES
4425 #endif // ALG_ECC
4426
4427 // Table 2:182 - Definition of TPMI_ECC_CURVE Type
4428 #if ALG_ECC
4429 TPM_RC
TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE * target,BYTE ** buffer,INT32 * size)4430 TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE *target, BYTE **buffer, INT32 *size)
4431 {
4432 TPM_RC result;
4433 result = TPM_ECC_CURVE_Unmarshal((TPM_ECC_CURVE *)target, buffer, size);
4434 if(result == TPM_RC_SUCCESS)
4435 {
4436 switch (*target)
4437 {
4438 #if ECC_BN_P256
4439 case TPM_ECC_BN_P256:
4440 #endif // ECC_BN_P256
4441 #if ECC_BN_P638
4442 case TPM_ECC_BN_P638:
4443 #endif // ECC_BN_P638
4444 #if ECC_NIST_P192
4445 case TPM_ECC_NIST_P192:
4446 #endif // ECC_NIST_P192
4447 #if ECC_NIST_P224
4448 case TPM_ECC_NIST_P224:
4449 #endif // ECC_NIST_P224
4450 #if ECC_NIST_P256
4451 case TPM_ECC_NIST_P256:
4452 #endif // ECC_NIST_P256
4453 #if ECC_NIST_P384
4454 case TPM_ECC_NIST_P384:
4455 #endif // ECC_NIST_P384
4456 #if ECC_NIST_P521
4457 case TPM_ECC_NIST_P521:
4458 #endif // ECC_NIST_P521
4459 #if ECC_SM2_P256
4460 case TPM_ECC_SM2_P256:
4461 #endif // ECC_SM2_P256
4462 break;
4463 default:
4464 result = TPM_RC_CURVE;
4465 break;
4466 }
4467 }
4468 return result;
4469 }
4470 #if !USE_MARSHALING_DEFINES
4471 UINT16
TPMI_ECC_CURVE_Marshal(TPMI_ECC_CURVE * source,BYTE ** buffer,INT32 * size)4472 TPMI_ECC_CURVE_Marshal(TPMI_ECC_CURVE *source, BYTE **buffer, INT32 *size)
4473 {
4474 return TPM_ECC_CURVE_Marshal((TPM_ECC_CURVE *)source, buffer, size);
4475 }
4476 #endif // !USE_MARSHALING_DEFINES
4477 #endif // ALG_ECC
4478
4479 // Table 2:183 - Definition of TPMT_ECC_SCHEME Structure
4480 #if ALG_ECC
4481 TPM_RC
TPMT_ECC_SCHEME_Unmarshal(TPMT_ECC_SCHEME * target,BYTE ** buffer,INT32 * size,BOOL flag)4482 TPMT_ECC_SCHEME_Unmarshal(TPMT_ECC_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
4483 {
4484 TPM_RC result;
4485 result = TPMI_ALG_ECC_SCHEME_Unmarshal((TPMI_ALG_ECC_SCHEME *)&(target->scheme), buffer, size, flag);
4486 if(result == TPM_RC_SUCCESS)
4487 result = TPMU_ASYM_SCHEME_Unmarshal((TPMU_ASYM_SCHEME *)&(target->details), buffer, size, (UINT32)target->scheme);
4488 return result;
4489 }
4490 UINT16
TPMT_ECC_SCHEME_Marshal(TPMT_ECC_SCHEME * source,BYTE ** buffer,INT32 * size)4491 TPMT_ECC_SCHEME_Marshal(TPMT_ECC_SCHEME *source, BYTE **buffer, INT32 *size)
4492 {
4493 UINT16 result = 0;
4494 result = (UINT16)(result + TPMI_ALG_ECC_SCHEME_Marshal((TPMI_ALG_ECC_SCHEME *)&(source->scheme), buffer, size));
4495 result = (UINT16)(result + TPMU_ASYM_SCHEME_Marshal((TPMU_ASYM_SCHEME *)&(source->details), buffer, size, (UINT32)source->scheme));
4496 return result;
4497 }
4498 #endif // ALG_ECC
4499
4500 // Table 2:184 - Definition of TPMS_ALGORITHM_DETAIL_ECC Structure
4501 #if ALG_ECC
4502 UINT16
TPMS_ALGORITHM_DETAIL_ECC_Marshal(TPMS_ALGORITHM_DETAIL_ECC * source,BYTE ** buffer,INT32 * size)4503 TPMS_ALGORITHM_DETAIL_ECC_Marshal(TPMS_ALGORITHM_DETAIL_ECC *source, BYTE **buffer, INT32 *size)
4504 {
4505 UINT16 result = 0;
4506 result = (UINT16)(result + TPM_ECC_CURVE_Marshal((TPM_ECC_CURVE *)&(source->curveID), buffer, size));
4507 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->keySize), buffer, size));
4508 result = (UINT16)(result + TPMT_KDF_SCHEME_Marshal((TPMT_KDF_SCHEME *)&(source->kdf), buffer, size));
4509 result = (UINT16)(result + TPMT_ECC_SCHEME_Marshal((TPMT_ECC_SCHEME *)&(source->sign), buffer, size));
4510 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->p), buffer, size));
4511 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->a), buffer, size));
4512 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->b), buffer, size));
4513 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->gX), buffer, size));
4514 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->gY), buffer, size));
4515 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->n), buffer, size));
4516 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->h), buffer, size));
4517 return result;
4518 }
4519 #endif // ALG_ECC
4520
4521 // Table 2:185 - Definition of TPMS_SIGNATURE_RSA Structure
4522 #if ALG_RSA
4523 TPM_RC
TPMS_SIGNATURE_RSA_Unmarshal(TPMS_SIGNATURE_RSA * target,BYTE ** buffer,INT32 * size)4524 TPMS_SIGNATURE_RSA_Unmarshal(TPMS_SIGNATURE_RSA *target, BYTE **buffer, INT32 *size)
4525 {
4526 TPM_RC result;
4527 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->hash), buffer, size, 0);
4528 if(result == TPM_RC_SUCCESS)
4529 result = TPM2B_PUBLIC_KEY_RSA_Unmarshal((TPM2B_PUBLIC_KEY_RSA *)&(target->sig), buffer, size);
4530 return result;
4531 }
4532 UINT16
TPMS_SIGNATURE_RSA_Marshal(TPMS_SIGNATURE_RSA * source,BYTE ** buffer,INT32 * size)4533 TPMS_SIGNATURE_RSA_Marshal(TPMS_SIGNATURE_RSA *source, BYTE **buffer, INT32 *size)
4534 {
4535 UINT16 result = 0;
4536 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->hash), buffer, size));
4537 result = (UINT16)(result + TPM2B_PUBLIC_KEY_RSA_Marshal((TPM2B_PUBLIC_KEY_RSA *)&(source->sig), buffer, size));
4538 return result;
4539 }
4540 #endif // ALG_RSA
4541
4542 // Table 2:186 - Definition of Types for Signature
4543 #if ALG_RSA
4544 #if !USE_MARSHALING_DEFINES
4545 TPM_RC
TPMS_SIGNATURE_RSASSA_Unmarshal(TPMS_SIGNATURE_RSASSA * target,BYTE ** buffer,INT32 * size)4546 TPMS_SIGNATURE_RSASSA_Unmarshal(TPMS_SIGNATURE_RSASSA *target, BYTE **buffer, INT32 *size)
4547 {
4548 return TPMS_SIGNATURE_RSA_Unmarshal((TPMS_SIGNATURE_RSA *)target, buffer, size);
4549 }
4550 UINT16
TPMS_SIGNATURE_RSASSA_Marshal(TPMS_SIGNATURE_RSASSA * source,BYTE ** buffer,INT32 * size)4551 TPMS_SIGNATURE_RSASSA_Marshal(TPMS_SIGNATURE_RSASSA *source, BYTE **buffer, INT32 *size)
4552 {
4553 return TPMS_SIGNATURE_RSA_Marshal((TPMS_SIGNATURE_RSA *)source, buffer, size);
4554 }
4555 TPM_RC
TPMS_SIGNATURE_RSAPSS_Unmarshal(TPMS_SIGNATURE_RSAPSS * target,BYTE ** buffer,INT32 * size)4556 TPMS_SIGNATURE_RSAPSS_Unmarshal(TPMS_SIGNATURE_RSAPSS *target, BYTE **buffer, INT32 *size)
4557 {
4558 return TPMS_SIGNATURE_RSA_Unmarshal((TPMS_SIGNATURE_RSA *)target, buffer, size);
4559 }
4560 UINT16
TPMS_SIGNATURE_RSAPSS_Marshal(TPMS_SIGNATURE_RSAPSS * source,BYTE ** buffer,INT32 * size)4561 TPMS_SIGNATURE_RSAPSS_Marshal(TPMS_SIGNATURE_RSAPSS *source, BYTE **buffer, INT32 *size)
4562 {
4563 return TPMS_SIGNATURE_RSA_Marshal((TPMS_SIGNATURE_RSA *)source, buffer, size);
4564 }
4565 #endif // !USE_MARSHALING_DEFINES
4566 #endif // ALG_RSA
4567
4568 // Table 2:187 - Definition of TPMS_SIGNATURE_ECC Structure
4569 #if ALG_ECC
4570 TPM_RC
TPMS_SIGNATURE_ECC_Unmarshal(TPMS_SIGNATURE_ECC * target,BYTE ** buffer,INT32 * size)4571 TPMS_SIGNATURE_ECC_Unmarshal(TPMS_SIGNATURE_ECC *target, BYTE **buffer, INT32 *size)
4572 {
4573 TPM_RC result;
4574 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->hash), buffer, size, 0);
4575 if(result == TPM_RC_SUCCESS)
4576 result = TPM2B_ECC_PARAMETER_Unmarshal((TPM2B_ECC_PARAMETER *)&(target->signatureR), buffer, size);
4577 if(result == TPM_RC_SUCCESS)
4578 result = TPM2B_ECC_PARAMETER_Unmarshal((TPM2B_ECC_PARAMETER *)&(target->signatureS), buffer, size);
4579 return result;
4580 }
4581 UINT16
TPMS_SIGNATURE_ECC_Marshal(TPMS_SIGNATURE_ECC * source,BYTE ** buffer,INT32 * size)4582 TPMS_SIGNATURE_ECC_Marshal(TPMS_SIGNATURE_ECC *source, BYTE **buffer, INT32 *size)
4583 {
4584 UINT16 result = 0;
4585 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->hash), buffer, size));
4586 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->signatureR), buffer, size));
4587 result = (UINT16)(result + TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->signatureS), buffer, size));
4588 return result;
4589 }
4590 #endif // ALG_ECC
4591
4592 // Table 2:188 - Definition of Types for TPMS_SIGNATURE_ECC
4593 #if ALG_ECC
4594 #if !USE_MARSHALING_DEFINES
4595 TPM_RC
TPMS_SIGNATURE_ECDAA_Unmarshal(TPMS_SIGNATURE_ECDAA * target,BYTE ** buffer,INT32 * size)4596 TPMS_SIGNATURE_ECDAA_Unmarshal(TPMS_SIGNATURE_ECDAA *target, BYTE **buffer, INT32 *size)
4597 {
4598 return TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)target, buffer, size);
4599 }
4600 UINT16
TPMS_SIGNATURE_ECDAA_Marshal(TPMS_SIGNATURE_ECDAA * source,BYTE ** buffer,INT32 * size)4601 TPMS_SIGNATURE_ECDAA_Marshal(TPMS_SIGNATURE_ECDAA *source, BYTE **buffer, INT32 *size)
4602 {
4603 return TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)source, buffer, size);
4604 }
4605 TPM_RC
TPMS_SIGNATURE_ECDSA_Unmarshal(TPMS_SIGNATURE_ECDSA * target,BYTE ** buffer,INT32 * size)4606 TPMS_SIGNATURE_ECDSA_Unmarshal(TPMS_SIGNATURE_ECDSA *target, BYTE **buffer, INT32 *size)
4607 {
4608 return TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)target, buffer, size);
4609 }
4610 UINT16
TPMS_SIGNATURE_ECDSA_Marshal(TPMS_SIGNATURE_ECDSA * source,BYTE ** buffer,INT32 * size)4611 TPMS_SIGNATURE_ECDSA_Marshal(TPMS_SIGNATURE_ECDSA *source, BYTE **buffer, INT32 *size)
4612 {
4613 return TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)source, buffer, size);
4614 }
4615 TPM_RC
TPMS_SIGNATURE_SM2_Unmarshal(TPMS_SIGNATURE_SM2 * target,BYTE ** buffer,INT32 * size)4616 TPMS_SIGNATURE_SM2_Unmarshal(TPMS_SIGNATURE_SM2 *target, BYTE **buffer, INT32 *size)
4617 {
4618 return TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)target, buffer, size);
4619 }
4620 UINT16
TPMS_SIGNATURE_SM2_Marshal(TPMS_SIGNATURE_SM2 * source,BYTE ** buffer,INT32 * size)4621 TPMS_SIGNATURE_SM2_Marshal(TPMS_SIGNATURE_SM2 *source, BYTE **buffer, INT32 *size)
4622 {
4623 return TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)source, buffer, size);
4624 }
4625 TPM_RC
TPMS_SIGNATURE_ECSCHNORR_Unmarshal(TPMS_SIGNATURE_ECSCHNORR * target,BYTE ** buffer,INT32 * size)4626 TPMS_SIGNATURE_ECSCHNORR_Unmarshal(TPMS_SIGNATURE_ECSCHNORR *target, BYTE **buffer, INT32 *size)
4627 {
4628 return TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)target, buffer, size);
4629 }
4630 UINT16
TPMS_SIGNATURE_ECSCHNORR_Marshal(TPMS_SIGNATURE_ECSCHNORR * source,BYTE ** buffer,INT32 * size)4631 TPMS_SIGNATURE_ECSCHNORR_Marshal(TPMS_SIGNATURE_ECSCHNORR *source, BYTE **buffer, INT32 *size)
4632 {
4633 return TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)source, buffer, size);
4634 }
4635 #endif // !USE_MARSHALING_DEFINES
4636 #endif // ALG_ECC
4637
4638 // Table 2:189 - Definition of TPMU_SIGNATURE Union
4639 TPM_RC
TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE * target,BYTE ** buffer,INT32 * size,UINT32 selector)4640 TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE *target, BYTE **buffer, INT32 *size, UINT32 selector)
4641 {
4642 switch(selector) {
4643 #if ALG_ECDAA
4644 case TPM_ALG_ECDAA:
4645 return TPMS_SIGNATURE_ECDAA_Unmarshal((TPMS_SIGNATURE_ECDAA *)&(target->ecdaa), buffer, size);
4646 #endif // ALG_ECDAA
4647 #if ALG_RSASSA
4648 case TPM_ALG_RSASSA:
4649 return TPMS_SIGNATURE_RSASSA_Unmarshal((TPMS_SIGNATURE_RSASSA *)&(target->rsassa), buffer, size);
4650 #endif // ALG_RSASSA
4651 #if ALG_RSAPSS
4652 case TPM_ALG_RSAPSS:
4653 return TPMS_SIGNATURE_RSAPSS_Unmarshal((TPMS_SIGNATURE_RSAPSS *)&(target->rsapss), buffer, size);
4654 #endif // ALG_RSAPSS
4655 #if ALG_ECDSA
4656 case TPM_ALG_ECDSA:
4657 return TPMS_SIGNATURE_ECDSA_Unmarshal((TPMS_SIGNATURE_ECDSA *)&(target->ecdsa), buffer, size);
4658 #endif // ALG_ECDSA
4659 #if ALG_SM2
4660 case TPM_ALG_SM2:
4661 return TPMS_SIGNATURE_SM2_Unmarshal((TPMS_SIGNATURE_SM2 *)&(target->sm2), buffer, size);
4662 #endif // ALG_SM2
4663 #if ALG_ECSCHNORR
4664 case TPM_ALG_ECSCHNORR:
4665 return TPMS_SIGNATURE_ECSCHNORR_Unmarshal((TPMS_SIGNATURE_ECSCHNORR *)&(target->ecschnorr), buffer, size);
4666 #endif // ALG_ECSCHNORR
4667 #if ALG_HMAC
4668 case TPM_ALG_HMAC:
4669 return TPMT_HA_Unmarshal((TPMT_HA *)&(target->hmac), buffer, size, 0);
4670 #endif // ALG_HMAC
4671 case TPM_ALG_NULL:
4672 return TPM_RC_SUCCESS;
4673 }
4674 return TPM_RC_SELECTOR;
4675 }
4676 UINT16
TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE * source,BYTE ** buffer,INT32 * size,UINT32 selector)4677 TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE *source, BYTE **buffer, INT32 *size, UINT32 selector)
4678 {
4679 switch(selector) {
4680 #if ALG_ECDAA
4681 case TPM_ALG_ECDAA:
4682 return TPMS_SIGNATURE_ECDAA_Marshal((TPMS_SIGNATURE_ECDAA *)&(source->ecdaa), buffer, size);
4683 #endif // ALG_ECDAA
4684 #if ALG_RSASSA
4685 case TPM_ALG_RSASSA:
4686 return TPMS_SIGNATURE_RSASSA_Marshal((TPMS_SIGNATURE_RSASSA *)&(source->rsassa), buffer, size);
4687 #endif // ALG_RSASSA
4688 #if ALG_RSAPSS
4689 case TPM_ALG_RSAPSS:
4690 return TPMS_SIGNATURE_RSAPSS_Marshal((TPMS_SIGNATURE_RSAPSS *)&(source->rsapss), buffer, size);
4691 #endif // ALG_RSAPSS
4692 #if ALG_ECDSA
4693 case TPM_ALG_ECDSA:
4694 return TPMS_SIGNATURE_ECDSA_Marshal((TPMS_SIGNATURE_ECDSA *)&(source->ecdsa), buffer, size);
4695 #endif // ALG_ECDSA
4696 #if ALG_SM2
4697 case TPM_ALG_SM2:
4698 return TPMS_SIGNATURE_SM2_Marshal((TPMS_SIGNATURE_SM2 *)&(source->sm2), buffer, size);
4699 #endif // ALG_SM2
4700 #if ALG_ECSCHNORR
4701 case TPM_ALG_ECSCHNORR:
4702 return TPMS_SIGNATURE_ECSCHNORR_Marshal((TPMS_SIGNATURE_ECSCHNORR *)&(source->ecschnorr), buffer, size);
4703 #endif // ALG_ECSCHNORR
4704 #if ALG_HMAC
4705 case TPM_ALG_HMAC:
4706 return TPMT_HA_Marshal((TPMT_HA *)&(source->hmac), buffer, size);
4707 #endif // ALG_HMAC
4708 case TPM_ALG_NULL:
4709 return 0;
4710 }
4711 return 0;
4712 }
4713
4714 // Table 2:190 - Definition of TPMT_SIGNATURE Structure
4715 TPM_RC
TPMT_SIGNATURE_Unmarshal(TPMT_SIGNATURE * target,BYTE ** buffer,INT32 * size,BOOL flag)4716 TPMT_SIGNATURE_Unmarshal(TPMT_SIGNATURE *target, BYTE **buffer, INT32 *size, BOOL flag)
4717 {
4718 TPM_RC result;
4719 result = TPMI_ALG_SIG_SCHEME_Unmarshal((TPMI_ALG_SIG_SCHEME *)&(target->sigAlg), buffer, size, flag);
4720 if(result == TPM_RC_SUCCESS)
4721 result = TPMU_SIGNATURE_Unmarshal((TPMU_SIGNATURE *)&(target->signature), buffer, size, (UINT32)target->sigAlg);
4722 return result;
4723 }
4724 UINT16
TPMT_SIGNATURE_Marshal(TPMT_SIGNATURE * source,BYTE ** buffer,INT32 * size)4725 TPMT_SIGNATURE_Marshal(TPMT_SIGNATURE *source, BYTE **buffer, INT32 *size)
4726 {
4727 UINT16 result = 0;
4728 result = (UINT16)(result + TPMI_ALG_SIG_SCHEME_Marshal((TPMI_ALG_SIG_SCHEME *)&(source->sigAlg), buffer, size));
4729 result = (UINT16)(result + TPMU_SIGNATURE_Marshal((TPMU_SIGNATURE *)&(source->signature), buffer, size, (UINT32)source->sigAlg));
4730 return result;
4731 }
4732
4733 // Table 2:191 - Definition of TPMU_ENCRYPTED_SECRET Union
4734 TPM_RC
TPMU_ENCRYPTED_SECRET_Unmarshal(TPMU_ENCRYPTED_SECRET * target,BYTE ** buffer,INT32 * size,UINT32 selector)4735 TPMU_ENCRYPTED_SECRET_Unmarshal(TPMU_ENCRYPTED_SECRET *target, BYTE **buffer, INT32 *size, UINT32 selector)
4736 {
4737 switch(selector) {
4738 #if ALG_ECC
4739 case TPM_ALG_ECC:
4740 return BYTE_Array_Unmarshal((BYTE *)(target->ecc), buffer, size, (INT32)sizeof(TPMS_ECC_POINT));
4741 #endif // ALG_ECC
4742 #if ALG_RSA
4743 case TPM_ALG_RSA:
4744 return BYTE_Array_Unmarshal((BYTE *)(target->rsa), buffer, size, (INT32)MAX_RSA_KEY_BYTES);
4745 #endif // ALG_RSA
4746 #if ALG_SYMCIPHER
4747 case TPM_ALG_SYMCIPHER:
4748 return BYTE_Array_Unmarshal((BYTE *)(target->symmetric), buffer, size, (INT32)sizeof(TPM2B_DIGEST));
4749 #endif // ALG_SYMCIPHER
4750 #if ALG_KEYEDHASH
4751 case TPM_ALG_KEYEDHASH:
4752 return BYTE_Array_Unmarshal((BYTE *)(target->keyedHash), buffer, size, (INT32)sizeof(TPM2B_DIGEST));
4753 #endif // ALG_KEYEDHASH
4754 }
4755 return TPM_RC_SELECTOR;
4756 }
4757 UINT16
TPMU_ENCRYPTED_SECRET_Marshal(TPMU_ENCRYPTED_SECRET * source,BYTE ** buffer,INT32 * size,UINT32 selector)4758 TPMU_ENCRYPTED_SECRET_Marshal(TPMU_ENCRYPTED_SECRET *source, BYTE **buffer, INT32 *size, UINT32 selector)
4759 {
4760 switch(selector) {
4761 #if ALG_ECC
4762 case TPM_ALG_ECC:
4763 return BYTE_Array_Marshal((BYTE *)(source->ecc), buffer, size, (INT32)sizeof(TPMS_ECC_POINT));
4764 #endif // ALG_ECC
4765 #if ALG_RSA
4766 case TPM_ALG_RSA:
4767 return BYTE_Array_Marshal((BYTE *)(source->rsa), buffer, size, (INT32)MAX_RSA_KEY_BYTES);
4768 #endif // ALG_RSA
4769 #if ALG_SYMCIPHER
4770 case TPM_ALG_SYMCIPHER:
4771 return BYTE_Array_Marshal((BYTE *)(source->symmetric), buffer, size, (INT32)sizeof(TPM2B_DIGEST));
4772 #endif // ALG_SYMCIPHER
4773 #if ALG_KEYEDHASH
4774 case TPM_ALG_KEYEDHASH:
4775 return BYTE_Array_Marshal((BYTE *)(source->keyedHash), buffer, size, (INT32)sizeof(TPM2B_DIGEST));
4776 #endif // ALG_KEYEDHASH
4777 }
4778 return 0;
4779 }
4780
4781 // Table 2:192 - Definition of TPM2B_ENCRYPTED_SECRET Structure
4782 TPM_RC
TPM2B_ENCRYPTED_SECRET_Unmarshal(TPM2B_ENCRYPTED_SECRET * target,BYTE ** buffer,INT32 * size)4783 TPM2B_ENCRYPTED_SECRET_Unmarshal(TPM2B_ENCRYPTED_SECRET *target, BYTE **buffer, INT32 *size)
4784 {
4785 TPM_RC result;
4786 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
4787 if(result == TPM_RC_SUCCESS)
4788 {
4789 if((target->t.size) > sizeof(TPMU_ENCRYPTED_SECRET))
4790 result = TPM_RC_SIZE;
4791 else
4792 result = BYTE_Array_Unmarshal((BYTE *)(target->t.secret), buffer, size, (INT32)(target->t.size));
4793 }
4794 return result;
4795 }
4796 UINT16
TPM2B_ENCRYPTED_SECRET_Marshal(TPM2B_ENCRYPTED_SECRET * source,BYTE ** buffer,INT32 * size)4797 TPM2B_ENCRYPTED_SECRET_Marshal(TPM2B_ENCRYPTED_SECRET *source, BYTE **buffer, INT32 *size)
4798 {
4799 UINT16 result = 0;
4800 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
4801 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
4802 if(source->t.size == 0)
4803 return result;
4804 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.secret), buffer, size, (INT32)(source->t.size)));
4805 return result;
4806 }
4807
4808 // Table 2:193 - Definition of TPMI_ALG_PUBLIC Type
4809 TPM_RC
TPMI_ALG_PUBLIC_Unmarshal(TPMI_ALG_PUBLIC * target,BYTE ** buffer,INT32 * size)4810 TPMI_ALG_PUBLIC_Unmarshal(TPMI_ALG_PUBLIC *target, BYTE **buffer, INT32 *size)
4811 {
4812 TPM_RC result;
4813 result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
4814 if(result == TPM_RC_SUCCESS)
4815 {
4816 switch (*target)
4817 {
4818 #if ALG_RSA
4819 case TPM_ALG_RSA:
4820 #endif // ALG_RSA
4821 #if ALG_ECC
4822 case TPM_ALG_ECC:
4823 #endif // ALG_ECC
4824 #if ALG_KEYEDHASH
4825 case TPM_ALG_KEYEDHASH:
4826 #endif // ALG_KEYEDHASH
4827 #if ALG_SYMCIPHER
4828 case TPM_ALG_SYMCIPHER:
4829 #endif // ALG_SYMCIPHER
4830 break;
4831 default:
4832 result = TPM_RC_TYPE;
4833 break;
4834 }
4835 }
4836 return result;
4837 }
4838 #if !USE_MARSHALING_DEFINES
4839 UINT16
TPMI_ALG_PUBLIC_Marshal(TPMI_ALG_PUBLIC * source,BYTE ** buffer,INT32 * size)4840 TPMI_ALG_PUBLIC_Marshal(TPMI_ALG_PUBLIC *source, BYTE **buffer, INT32 *size)
4841 {
4842 return TPM_ALG_ID_Marshal((TPM_ALG_ID *)source, buffer, size);
4843 }
4844 #endif // !USE_MARSHALING_DEFINES
4845
4846 // Table 2:194 - Definition of TPMU_PUBLIC_ID Union
4847 TPM_RC
TPMU_PUBLIC_ID_Unmarshal(TPMU_PUBLIC_ID * target,BYTE ** buffer,INT32 * size,UINT32 selector)4848 TPMU_PUBLIC_ID_Unmarshal(TPMU_PUBLIC_ID *target, BYTE **buffer, INT32 *size, UINT32 selector)
4849 {
4850 switch(selector) {
4851 #if ALG_KEYEDHASH
4852 case TPM_ALG_KEYEDHASH:
4853 return TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->keyedHash), buffer, size);
4854 #endif // ALG_KEYEDHASH
4855 #if ALG_SYMCIPHER
4856 case TPM_ALG_SYMCIPHER:
4857 return TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->sym), buffer, size);
4858 #endif // ALG_SYMCIPHER
4859 #if ALG_RSA
4860 case TPM_ALG_RSA:
4861 return TPM2B_PUBLIC_KEY_RSA_Unmarshal((TPM2B_PUBLIC_KEY_RSA *)&(target->rsa), buffer, size);
4862 #endif // ALG_RSA
4863 #if ALG_ECC
4864 case TPM_ALG_ECC:
4865 return TPMS_ECC_POINT_Unmarshal((TPMS_ECC_POINT *)&(target->ecc), buffer, size);
4866 #endif // ALG_ECC
4867 }
4868 return TPM_RC_SELECTOR;
4869 }
4870 UINT16
TPMU_PUBLIC_ID_Marshal(TPMU_PUBLIC_ID * source,BYTE ** buffer,INT32 * size,UINT32 selector)4871 TPMU_PUBLIC_ID_Marshal(TPMU_PUBLIC_ID *source, BYTE **buffer, INT32 *size, UINT32 selector)
4872 {
4873 switch(selector) {
4874 #if ALG_KEYEDHASH
4875 case TPM_ALG_KEYEDHASH:
4876 return TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->keyedHash), buffer, size);
4877 #endif // ALG_KEYEDHASH
4878 #if ALG_SYMCIPHER
4879 case TPM_ALG_SYMCIPHER:
4880 return TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->sym), buffer, size);
4881 #endif // ALG_SYMCIPHER
4882 #if ALG_RSA
4883 case TPM_ALG_RSA:
4884 return TPM2B_PUBLIC_KEY_RSA_Marshal((TPM2B_PUBLIC_KEY_RSA *)&(source->rsa), buffer, size);
4885 #endif // ALG_RSA
4886 #if ALG_ECC
4887 case TPM_ALG_ECC:
4888 return TPMS_ECC_POINT_Marshal((TPMS_ECC_POINT *)&(source->ecc), buffer, size);
4889 #endif // ALG_ECC
4890 }
4891 return 0;
4892 }
4893
4894 // Table 2:195 - Definition of TPMS_KEYEDHASH_PARMS Structure
4895 TPM_RC
TPMS_KEYEDHASH_PARMS_Unmarshal(TPMS_KEYEDHASH_PARMS * target,BYTE ** buffer,INT32 * size)4896 TPMS_KEYEDHASH_PARMS_Unmarshal(TPMS_KEYEDHASH_PARMS *target, BYTE **buffer, INT32 *size)
4897 {
4898 return TPMT_KEYEDHASH_SCHEME_Unmarshal((TPMT_KEYEDHASH_SCHEME *)&(target->scheme), buffer, size, 1);
4899 }
4900 UINT16
TPMS_KEYEDHASH_PARMS_Marshal(TPMS_KEYEDHASH_PARMS * source,BYTE ** buffer,INT32 * size)4901 TPMS_KEYEDHASH_PARMS_Marshal(TPMS_KEYEDHASH_PARMS *source, BYTE **buffer, INT32 *size)
4902 {
4903 return TPMT_KEYEDHASH_SCHEME_Marshal((TPMT_KEYEDHASH_SCHEME *)&(source->scheme), buffer, size);
4904 }
4905
4906 // Table 2:196 - Definition of TPMS_ASYM_PARMS Structure
4907 // Table 2:197 - Definition of TPMS_RSA_PARMS Structure
4908 #if ALG_RSA
4909 TPM_RC
TPMS_RSA_PARMS_Unmarshal(TPMS_RSA_PARMS * target,BYTE ** buffer,INT32 * size)4910 TPMS_RSA_PARMS_Unmarshal(TPMS_RSA_PARMS *target, BYTE **buffer, INT32 *size)
4911 {
4912 TPM_RC result;
4913 result = TPMT_SYM_DEF_OBJECT_Unmarshal((TPMT_SYM_DEF_OBJECT *)&(target->symmetric), buffer, size, 1);
4914 if(result == TPM_RC_SUCCESS)
4915 result = TPMT_RSA_SCHEME_Unmarshal((TPMT_RSA_SCHEME *)&(target->scheme), buffer, size, 1);
4916 if(result == TPM_RC_SUCCESS)
4917 result = TPMI_RSA_KEY_BITS_Unmarshal((TPMI_RSA_KEY_BITS *)&(target->keyBits), buffer, size);
4918 if(result == TPM_RC_SUCCESS)
4919 result = UINT32_Unmarshal((UINT32 *)&(target->exponent), buffer, size);
4920 return result;
4921 }
4922 UINT16
TPMS_RSA_PARMS_Marshal(TPMS_RSA_PARMS * source,BYTE ** buffer,INT32 * size)4923 TPMS_RSA_PARMS_Marshal(TPMS_RSA_PARMS *source, BYTE **buffer, INT32 *size)
4924 {
4925 UINT16 result = 0;
4926 result = (UINT16)(result + TPMT_SYM_DEF_OBJECT_Marshal((TPMT_SYM_DEF_OBJECT *)&(source->symmetric), buffer, size));
4927 result = (UINT16)(result + TPMT_RSA_SCHEME_Marshal((TPMT_RSA_SCHEME *)&(source->scheme), buffer, size));
4928 result = (UINT16)(result + TPMI_RSA_KEY_BITS_Marshal((TPMI_RSA_KEY_BITS *)&(source->keyBits), buffer, size));
4929 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->exponent), buffer, size));
4930 return result;
4931 }
4932 #endif // ALG_RSA
4933
4934 // Table 2:198 - Definition of TPMS_ECC_PARMS Structure
4935 #if ALG_ECC
4936 TPM_RC
TPMS_ECC_PARMS_Unmarshal(TPMS_ECC_PARMS * target,BYTE ** buffer,INT32 * size)4937 TPMS_ECC_PARMS_Unmarshal(TPMS_ECC_PARMS *target, BYTE **buffer, INT32 *size)
4938 {
4939 TPM_RC result;
4940 result = TPMT_SYM_DEF_OBJECT_Unmarshal((TPMT_SYM_DEF_OBJECT *)&(target->symmetric), buffer, size, 1);
4941 if(result == TPM_RC_SUCCESS)
4942 result = TPMT_ECC_SCHEME_Unmarshal((TPMT_ECC_SCHEME *)&(target->scheme), buffer, size, 1);
4943 if(result == TPM_RC_SUCCESS)
4944 result = TPMI_ECC_CURVE_Unmarshal((TPMI_ECC_CURVE *)&(target->curveID), buffer, size);
4945 if(result == TPM_RC_SUCCESS)
4946 result = TPMT_KDF_SCHEME_Unmarshal((TPMT_KDF_SCHEME *)&(target->kdf), buffer, size, 1);
4947 return result;
4948 }
4949 UINT16
TPMS_ECC_PARMS_Marshal(TPMS_ECC_PARMS * source,BYTE ** buffer,INT32 * size)4950 TPMS_ECC_PARMS_Marshal(TPMS_ECC_PARMS *source, BYTE **buffer, INT32 *size)
4951 {
4952 UINT16 result = 0;
4953 result = (UINT16)(result + TPMT_SYM_DEF_OBJECT_Marshal((TPMT_SYM_DEF_OBJECT *)&(source->symmetric), buffer, size));
4954 result = (UINT16)(result + TPMT_ECC_SCHEME_Marshal((TPMT_ECC_SCHEME *)&(source->scheme), buffer, size));
4955 result = (UINT16)(result + TPMI_ECC_CURVE_Marshal((TPMI_ECC_CURVE *)&(source->curveID), buffer, size));
4956 result = (UINT16)(result + TPMT_KDF_SCHEME_Marshal((TPMT_KDF_SCHEME *)&(source->kdf), buffer, size));
4957 return result;
4958 }
4959 #endif // ALG_ECC
4960
4961 // Table 2:199 - Definition of TPMU_PUBLIC_PARMS Union
4962 TPM_RC
TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS * target,BYTE ** buffer,INT32 * size,UINT32 selector)4963 TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS *target, BYTE **buffer, INT32 *size, UINT32 selector)
4964 {
4965 switch(selector) {
4966 #if ALG_KEYEDHASH
4967 case TPM_ALG_KEYEDHASH:
4968 return TPMS_KEYEDHASH_PARMS_Unmarshal((TPMS_KEYEDHASH_PARMS *)&(target->keyedHashDetail), buffer, size);
4969 #endif // ALG_KEYEDHASH
4970 #if ALG_SYMCIPHER
4971 case TPM_ALG_SYMCIPHER:
4972 return TPMS_SYMCIPHER_PARMS_Unmarshal((TPMS_SYMCIPHER_PARMS *)&(target->symDetail), buffer, size);
4973 #endif // ALG_SYMCIPHER
4974 #if ALG_RSA
4975 case TPM_ALG_RSA:
4976 return TPMS_RSA_PARMS_Unmarshal((TPMS_RSA_PARMS *)&(target->rsaDetail), buffer, size);
4977 #endif // ALG_RSA
4978 #if ALG_ECC
4979 case TPM_ALG_ECC:
4980 return TPMS_ECC_PARMS_Unmarshal((TPMS_ECC_PARMS *)&(target->eccDetail), buffer, size);
4981 #endif // ALG_ECC
4982 }
4983 return TPM_RC_SELECTOR;
4984 }
4985 UINT16
TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS * source,BYTE ** buffer,INT32 * size,UINT32 selector)4986 TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS *source, BYTE **buffer, INT32 *size, UINT32 selector)
4987 {
4988 switch(selector) {
4989 #if ALG_KEYEDHASH
4990 case TPM_ALG_KEYEDHASH:
4991 return TPMS_KEYEDHASH_PARMS_Marshal((TPMS_KEYEDHASH_PARMS *)&(source->keyedHashDetail), buffer, size);
4992 #endif // ALG_KEYEDHASH
4993 #if ALG_SYMCIPHER
4994 case TPM_ALG_SYMCIPHER:
4995 return TPMS_SYMCIPHER_PARMS_Marshal((TPMS_SYMCIPHER_PARMS *)&(source->symDetail), buffer, size);
4996 #endif // ALG_SYMCIPHER
4997 #if ALG_RSA
4998 case TPM_ALG_RSA:
4999 return TPMS_RSA_PARMS_Marshal((TPMS_RSA_PARMS *)&(source->rsaDetail), buffer, size);
5000 #endif // ALG_RSA
5001 #if ALG_ECC
5002 case TPM_ALG_ECC:
5003 return TPMS_ECC_PARMS_Marshal((TPMS_ECC_PARMS *)&(source->eccDetail), buffer, size);
5004 #endif // ALG_ECC
5005 }
5006 return 0;
5007 }
5008
5009 // Table 2:200 - Definition of TPMT_PUBLIC_PARMS Structure
5010 TPM_RC
TPMT_PUBLIC_PARMS_Unmarshal(TPMT_PUBLIC_PARMS * target,BYTE ** buffer,INT32 * size)5011 TPMT_PUBLIC_PARMS_Unmarshal(TPMT_PUBLIC_PARMS *target, BYTE **buffer, INT32 *size)
5012 {
5013 TPM_RC result;
5014 result = TPMI_ALG_PUBLIC_Unmarshal((TPMI_ALG_PUBLIC *)&(target->type), buffer, size);
5015 if(result == TPM_RC_SUCCESS)
5016 result = TPMU_PUBLIC_PARMS_Unmarshal((TPMU_PUBLIC_PARMS *)&(target->parameters), buffer, size, (UINT32)target->type);
5017 return result;
5018 }
5019 UINT16
TPMT_PUBLIC_PARMS_Marshal(TPMT_PUBLIC_PARMS * source,BYTE ** buffer,INT32 * size)5020 TPMT_PUBLIC_PARMS_Marshal(TPMT_PUBLIC_PARMS *source, BYTE **buffer, INT32 *size)
5021 {
5022 UINT16 result = 0;
5023 result = (UINT16)(result + TPMI_ALG_PUBLIC_Marshal((TPMI_ALG_PUBLIC *)&(source->type), buffer, size));
5024 result = (UINT16)(result + TPMU_PUBLIC_PARMS_Marshal((TPMU_PUBLIC_PARMS *)&(source->parameters), buffer, size, (UINT32)source->type));
5025 return result;
5026 }
5027
5028 // Table 2:201 - Definition of TPMT_PUBLIC Structure
5029 TPM_RC
TPMT_PUBLIC_Unmarshal(TPMT_PUBLIC * target,BYTE ** buffer,INT32 * size,BOOL flag)5030 TPMT_PUBLIC_Unmarshal(TPMT_PUBLIC *target, BYTE **buffer, INT32 *size, BOOL flag)
5031 {
5032 TPM_RC result;
5033 result = TPMI_ALG_PUBLIC_Unmarshal((TPMI_ALG_PUBLIC *)&(target->type), buffer, size);
5034 if(result == TPM_RC_SUCCESS)
5035 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->nameAlg), buffer, size, flag);
5036 if(result == TPM_RC_SUCCESS)
5037 result = TPMA_OBJECT_Unmarshal((TPMA_OBJECT *)&(target->objectAttributes), buffer, size);
5038 if(result == TPM_RC_SUCCESS)
5039 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->authPolicy), buffer, size);
5040 if(result == TPM_RC_SUCCESS)
5041 result = TPMU_PUBLIC_PARMS_Unmarshal((TPMU_PUBLIC_PARMS *)&(target->parameters), buffer, size, (UINT32)target->type);
5042 if(result == TPM_RC_SUCCESS)
5043 result = TPMU_PUBLIC_ID_Unmarshal((TPMU_PUBLIC_ID *)&(target->unique), buffer, size, (UINT32)target->type);
5044 return result;
5045 }
5046 UINT16
TPMT_PUBLIC_Marshal(TPMT_PUBLIC * source,BYTE ** buffer,INT32 * size)5047 TPMT_PUBLIC_Marshal(TPMT_PUBLIC *source, BYTE **buffer, INT32 *size)
5048 {
5049 UINT16 result = 0;
5050 result = (UINT16)(result + TPMI_ALG_PUBLIC_Marshal((TPMI_ALG_PUBLIC *)&(source->type), buffer, size));
5051 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->nameAlg), buffer, size));
5052 result = (UINT16)(result + TPMA_OBJECT_Marshal((TPMA_OBJECT *)&(source->objectAttributes), buffer, size));
5053 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->authPolicy), buffer, size));
5054 result = (UINT16)(result + TPMU_PUBLIC_PARMS_Marshal((TPMU_PUBLIC_PARMS *)&(source->parameters), buffer, size, (UINT32)source->type));
5055 result = (UINT16)(result + TPMU_PUBLIC_ID_Marshal((TPMU_PUBLIC_ID *)&(source->unique), buffer, size, (UINT32)source->type));
5056 return result;
5057 }
5058
5059 // Table 2:202 - Definition of TPM2B_PUBLIC Structure
5060 TPM_RC
TPM2B_PUBLIC_Unmarshal(TPM2B_PUBLIC * target,BYTE ** buffer,INT32 * size,BOOL flag)5061 TPM2B_PUBLIC_Unmarshal(TPM2B_PUBLIC *target, BYTE **buffer, INT32 *size, BOOL flag)
5062 {
5063 TPM_RC result;
5064 result = UINT16_Unmarshal((UINT16 *)&(target->size), buffer, size); // =a
5065 if(result == TPM_RC_SUCCESS)
5066 {
5067 // if size is zero, then the required structure is missing
5068 if(target->size == 0)
5069 result = TPM_RC_SIZE;
5070 else
5071 {
5072 INT32 startSize = *size;
5073 result = TPMT_PUBLIC_Unmarshal((TPMT_PUBLIC *)&(target->publicArea), buffer, size, flag); // =b
5074 if(result == TPM_RC_SUCCESS)
5075 {
5076 if(target->size != (startSize - *size))
5077 result = TPM_RC_SIZE;
5078 }
5079 }
5080 }
5081 return result;
5082 }
5083 UINT16
TPM2B_PUBLIC_Marshal(TPM2B_PUBLIC * source,BYTE ** buffer,INT32 * size)5084 TPM2B_PUBLIC_Marshal(TPM2B_PUBLIC *source, BYTE **buffer, INT32 *size)
5085 {
5086 UINT16 result = 0;
5087 // Marshal a dummy value of the 2B size. This makes sure that 'buffer'
5088 // and 'size' are advanced as necessary (i.e., if they are present)
5089 result = UINT16_Marshal(&result, buffer, size);
5090 // Marshal the structure
5091 result = (UINT16)(result + TPMT_PUBLIC_Marshal((TPMT_PUBLIC *)&(source->publicArea), buffer, size));
5092 // if a buffer was provided, go back and fill in the actual size
5093 if(buffer != NULL)
5094 UINT16_TO_BYTE_ARRAY((result - 2), (*buffer - result));
5095 return result;
5096 }
5097
5098 // Table 2:203 - Definition of TPM2B_TEMPLATE Structure
5099 TPM_RC
TPM2B_TEMPLATE_Unmarshal(TPM2B_TEMPLATE * target,BYTE ** buffer,INT32 * size)5100 TPM2B_TEMPLATE_Unmarshal(TPM2B_TEMPLATE *target, BYTE **buffer, INT32 *size)
5101 {
5102 TPM_RC result;
5103 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
5104 if(result == TPM_RC_SUCCESS)
5105 {
5106 if((target->t.size) > sizeof(TPMT_PUBLIC))
5107 result = TPM_RC_SIZE;
5108 else
5109 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
5110 }
5111 return result;
5112 }
5113 UINT16
TPM2B_TEMPLATE_Marshal(TPM2B_TEMPLATE * source,BYTE ** buffer,INT32 * size)5114 TPM2B_TEMPLATE_Marshal(TPM2B_TEMPLATE *source, BYTE **buffer, INT32 *size)
5115 {
5116 UINT16 result = 0;
5117 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
5118 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
5119 if(source->t.size == 0)
5120 return result;
5121 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
5122 return result;
5123 }
5124
5125 // Table 2:204 - Definition of TPM2B_PRIVATE_VENDOR_SPECIFIC Structure
5126 TPM_RC
TPM2B_PRIVATE_VENDOR_SPECIFIC_Unmarshal(TPM2B_PRIVATE_VENDOR_SPECIFIC * target,BYTE ** buffer,INT32 * size)5127 TPM2B_PRIVATE_VENDOR_SPECIFIC_Unmarshal(TPM2B_PRIVATE_VENDOR_SPECIFIC *target, BYTE **buffer, INT32 *size)
5128 {
5129 TPM_RC result;
5130 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
5131 if(result == TPM_RC_SUCCESS)
5132 {
5133 if((target->t.size) > PRIVATE_VENDOR_SPECIFIC_BYTES)
5134 result = TPM_RC_SIZE;
5135 else
5136 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
5137 }
5138 return result;
5139 }
5140 UINT16
TPM2B_PRIVATE_VENDOR_SPECIFIC_Marshal(TPM2B_PRIVATE_VENDOR_SPECIFIC * source,BYTE ** buffer,INT32 * size)5141 TPM2B_PRIVATE_VENDOR_SPECIFIC_Marshal(TPM2B_PRIVATE_VENDOR_SPECIFIC *source, BYTE **buffer, INT32 *size)
5142 {
5143 UINT16 result = 0;
5144 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
5145 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
5146 if(source->t.size == 0)
5147 return result;
5148 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
5149 return result;
5150 }
5151
5152 // Table 2:205 - Definition of TPMU_SENSITIVE_COMPOSITE Union
5153 TPM_RC
TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE * target,BYTE ** buffer,INT32 * size,UINT32 selector)5154 TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE *target, BYTE **buffer, INT32 *size, UINT32 selector)
5155 {
5156 switch(selector) {
5157 #if ALG_RSA
5158 case TPM_ALG_RSA:
5159 return TPM2B_PRIVATE_KEY_RSA_Unmarshal((TPM2B_PRIVATE_KEY_RSA *)&(target->rsa), buffer, size);
5160 #endif // ALG_RSA
5161 #if ALG_ECC
5162 case TPM_ALG_ECC:
5163 return TPM2B_ECC_PARAMETER_Unmarshal((TPM2B_ECC_PARAMETER *)&(target->ecc), buffer, size);
5164 #endif // ALG_ECC
5165 #if ALG_KEYEDHASH
5166 case TPM_ALG_KEYEDHASH:
5167 return TPM2B_SENSITIVE_DATA_Unmarshal((TPM2B_SENSITIVE_DATA *)&(target->bits), buffer, size);
5168 #endif // ALG_KEYEDHASH
5169 #if ALG_SYMCIPHER
5170 case TPM_ALG_SYMCIPHER:
5171 return TPM2B_SYM_KEY_Unmarshal((TPM2B_SYM_KEY *)&(target->sym), buffer, size);
5172 #endif // ALG_SYMCIPHER
5173 }
5174 return TPM_RC_SELECTOR;
5175 }
5176 UINT16
TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE * source,BYTE ** buffer,INT32 * size,UINT32 selector)5177 TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE *source, BYTE **buffer, INT32 *size, UINT32 selector)
5178 {
5179 switch(selector) {
5180 #if ALG_RSA
5181 case TPM_ALG_RSA:
5182 return TPM2B_PRIVATE_KEY_RSA_Marshal((TPM2B_PRIVATE_KEY_RSA *)&(source->rsa), buffer, size);
5183 #endif // ALG_RSA
5184 #if ALG_ECC
5185 case TPM_ALG_ECC:
5186 return TPM2B_ECC_PARAMETER_Marshal((TPM2B_ECC_PARAMETER *)&(source->ecc), buffer, size);
5187 #endif // ALG_ECC
5188 #if ALG_KEYEDHASH
5189 case TPM_ALG_KEYEDHASH:
5190 return TPM2B_SENSITIVE_DATA_Marshal((TPM2B_SENSITIVE_DATA *)&(source->bits), buffer, size);
5191 #endif // ALG_KEYEDHASH
5192 #if ALG_SYMCIPHER
5193 case TPM_ALG_SYMCIPHER:
5194 return TPM2B_SYM_KEY_Marshal((TPM2B_SYM_KEY *)&(source->sym), buffer, size);
5195 #endif // ALG_SYMCIPHER
5196 }
5197 return 0;
5198 }
5199
5200 // Table 2:206 - Definition of TPMT_SENSITIVE Structure
5201 TPM_RC
TPMT_SENSITIVE_Unmarshal(TPMT_SENSITIVE * target,BYTE ** buffer,INT32 * size)5202 TPMT_SENSITIVE_Unmarshal(TPMT_SENSITIVE *target, BYTE **buffer, INT32 *size)
5203 {
5204 TPM_RC result;
5205 result = TPMI_ALG_PUBLIC_Unmarshal((TPMI_ALG_PUBLIC *)&(target->sensitiveType), buffer, size);
5206 if(result == TPM_RC_SUCCESS)
5207 result = TPM2B_AUTH_Unmarshal((TPM2B_AUTH *)&(target->authValue), buffer, size);
5208 if(result == TPM_RC_SUCCESS)
5209 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->seedValue), buffer, size);
5210 if(result == TPM_RC_SUCCESS)
5211 result = TPMU_SENSITIVE_COMPOSITE_Unmarshal((TPMU_SENSITIVE_COMPOSITE *)&(target->sensitive), buffer, size, (UINT32)target->sensitiveType);
5212 return result;
5213 }
5214 UINT16
TPMT_SENSITIVE_Marshal(TPMT_SENSITIVE * source,BYTE ** buffer,INT32 * size)5215 TPMT_SENSITIVE_Marshal(TPMT_SENSITIVE *source, BYTE **buffer, INT32 *size)
5216 {
5217 UINT16 result = 0;
5218 result = (UINT16)(result + TPMI_ALG_PUBLIC_Marshal((TPMI_ALG_PUBLIC *)&(source->sensitiveType), buffer, size));
5219 result = (UINT16)(result + TPM2B_AUTH_Marshal((TPM2B_AUTH *)&(source->authValue), buffer, size));
5220 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->seedValue), buffer, size));
5221 result = (UINT16)(result + TPMU_SENSITIVE_COMPOSITE_Marshal((TPMU_SENSITIVE_COMPOSITE *)&(source->sensitive), buffer, size, (UINT32)source->sensitiveType));
5222 return result;
5223 }
5224
5225 // Table 2:207 - Definition of TPM2B_SENSITIVE Structure
5226 TPM_RC
TPM2B_SENSITIVE_Unmarshal(TPM2B_SENSITIVE * target,BYTE ** buffer,INT32 * size)5227 TPM2B_SENSITIVE_Unmarshal(TPM2B_SENSITIVE *target, BYTE **buffer, INT32 *size)
5228 {
5229 TPM_RC result;
5230 result = UINT16_Unmarshal((UINT16 *)&(target->size), buffer, size); // =a
5231 // if there was an error or if target->size equal to 0,
5232 // skip unmarshaling of the structure
5233 if((result == TPM_RC_SUCCESS) && (target->size != 0))
5234 {
5235 INT32 startSize = *size;
5236 result = TPMT_SENSITIVE_Unmarshal((TPMT_SENSITIVE *)&(target->sensitiveArea), buffer, size); // =b
5237 if(result == TPM_RC_SUCCESS)
5238 {
5239 if(target->size != (startSize - *size))
5240 result = TPM_RC_SIZE;
5241 }
5242 }
5243 return result;
5244 }
5245 UINT16
TPM2B_SENSITIVE_Marshal(TPM2B_SENSITIVE * source,BYTE ** buffer,INT32 * size)5246 TPM2B_SENSITIVE_Marshal(TPM2B_SENSITIVE *source, BYTE **buffer, INT32 *size)
5247 {
5248 UINT16 result = 0;
5249 // Marshal a dummy value of the 2B size. This makes sure that 'buffer'
5250 // and 'size' are advanced as necessary (i.e., if they are present)
5251 result = UINT16_Marshal(&result, buffer, size);
5252 // Marshal the structure
5253 result = (UINT16)(result + TPMT_SENSITIVE_Marshal((TPMT_SENSITIVE *)&(source->sensitiveArea), buffer, size));
5254 // if a buffer was provided, go back and fill in the actual size
5255 if(buffer != NULL)
5256 UINT16_TO_BYTE_ARRAY((result - 2), (*buffer - result));
5257 return result;
5258 }
5259
5260 // Table 2:208 - Definition of _PRIVATE Structure
5261 // Table 2:209 - Definition of TPM2B_PRIVATE Structure
5262 TPM_RC
TPM2B_PRIVATE_Unmarshal(TPM2B_PRIVATE * target,BYTE ** buffer,INT32 * size)5263 TPM2B_PRIVATE_Unmarshal(TPM2B_PRIVATE *target, BYTE **buffer, INT32 *size)
5264 {
5265 TPM_RC result;
5266 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
5267 if(result == TPM_RC_SUCCESS)
5268 {
5269 if((target->t.size) > sizeof(_PRIVATE))
5270 result = TPM_RC_SIZE;
5271 else
5272 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
5273 }
5274 return result;
5275 }
5276 UINT16
TPM2B_PRIVATE_Marshal(TPM2B_PRIVATE * source,BYTE ** buffer,INT32 * size)5277 TPM2B_PRIVATE_Marshal(TPM2B_PRIVATE *source, BYTE **buffer, INT32 *size)
5278 {
5279 UINT16 result = 0;
5280 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
5281 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
5282 if(source->t.size == 0)
5283 return result;
5284 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
5285 return result;
5286 }
5287
5288 // Table 2:210 - Definition of TPMS_ID_OBJECT Structure
5289 // Table 2:211 - Definition of TPM2B_ID_OBJECT Structure
5290 TPM_RC
TPM2B_ID_OBJECT_Unmarshal(TPM2B_ID_OBJECT * target,BYTE ** buffer,INT32 * size)5291 TPM2B_ID_OBJECT_Unmarshal(TPM2B_ID_OBJECT *target, BYTE **buffer, INT32 *size)
5292 {
5293 TPM_RC result;
5294 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
5295 if(result == TPM_RC_SUCCESS)
5296 {
5297 if((target->t.size) > sizeof(TPMS_ID_OBJECT))
5298 result = TPM_RC_SIZE;
5299 else
5300 result = BYTE_Array_Unmarshal((BYTE *)(target->t.credential), buffer, size, (INT32)(target->t.size));
5301 }
5302 return result;
5303 }
5304 UINT16
TPM2B_ID_OBJECT_Marshal(TPM2B_ID_OBJECT * source,BYTE ** buffer,INT32 * size)5305 TPM2B_ID_OBJECT_Marshal(TPM2B_ID_OBJECT *source, BYTE **buffer, INT32 *size)
5306 {
5307 UINT16 result = 0;
5308 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
5309 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
5310 if(source->t.size == 0)
5311 return result;
5312 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.credential), buffer, size, (INT32)(source->t.size)));
5313 return result;
5314 }
5315
5316 // Table 2:212 - Definition of TPM_NV_INDEX Bits
5317 #if !USE_MARSHALING_DEFINES
5318 UINT16
TPM_NV_INDEX_Marshal(TPM_NV_INDEX * source,BYTE ** buffer,INT32 * size)5319 TPM_NV_INDEX_Marshal(TPM_NV_INDEX *source, BYTE **buffer, INT32 *size)
5320 {
5321 return UINT32_Marshal((UINT32 *)source, buffer, size);
5322 }
5323 #endif // !USE_MARSHALING_DEFINES
5324
5325 // Table 2:213 - Definition of TPM_NT Constants
5326 // Table 2:214 - Definition of TPMS_NV_PIN_COUNTER_PARAMETERS Structure
5327 TPM_RC
TPMS_NV_PIN_COUNTER_PARAMETERS_Unmarshal(TPMS_NV_PIN_COUNTER_PARAMETERS * target,BYTE ** buffer,INT32 * size)5328 TPMS_NV_PIN_COUNTER_PARAMETERS_Unmarshal(TPMS_NV_PIN_COUNTER_PARAMETERS *target, BYTE **buffer, INT32 *size)
5329 {
5330 TPM_RC result;
5331 result = UINT32_Unmarshal((UINT32 *)&(target->pinCount), buffer, size);
5332 if(result == TPM_RC_SUCCESS)
5333 result = UINT32_Unmarshal((UINT32 *)&(target->pinLimit), buffer, size);
5334 return result;
5335 }
5336 UINT16
TPMS_NV_PIN_COUNTER_PARAMETERS_Marshal(TPMS_NV_PIN_COUNTER_PARAMETERS * source,BYTE ** buffer,INT32 * size)5337 TPMS_NV_PIN_COUNTER_PARAMETERS_Marshal(TPMS_NV_PIN_COUNTER_PARAMETERS *source, BYTE **buffer, INT32 *size)
5338 {
5339 UINT16 result = 0;
5340 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->pinCount), buffer, size));
5341 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->pinLimit), buffer, size));
5342 return result;
5343 }
5344
5345 // Table 2:215 - Definition of TPMA_NV Bits
5346 TPM_RC
TPMA_NV_Unmarshal(TPMA_NV * target,BYTE ** buffer,INT32 * size)5347 TPMA_NV_Unmarshal(TPMA_NV *target, BYTE **buffer, INT32 *size)
5348 {
5349 TPM_RC result;
5350 result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
5351 if(result == TPM_RC_SUCCESS)
5352 {
5353 if(*((UINT32 *)target) & (UINT32)0x01f00300)
5354 result = TPM_RC_RESERVED_BITS;
5355 }
5356 return result;
5357 }
5358
5359 #if !USE_MARSHALING_DEFINES
5360 UINT16
TPMA_NV_Marshal(TPMA_NV * source,BYTE ** buffer,INT32 * size)5361 TPMA_NV_Marshal(TPMA_NV *source, BYTE **buffer, INT32 *size)
5362 {
5363 return UINT32_Marshal((UINT32 *)source, buffer, size);
5364 }
5365 #endif // !USE_MARSHALING_DEFINES
5366
5367 // Table 2:216 - Definition of TPMS_NV_PUBLIC Structure
5368 TPM_RC
TPMS_NV_PUBLIC_Unmarshal(TPMS_NV_PUBLIC * target,BYTE ** buffer,INT32 * size)5369 TPMS_NV_PUBLIC_Unmarshal(TPMS_NV_PUBLIC *target, BYTE **buffer, INT32 *size)
5370 {
5371 TPM_RC result;
5372 result = TPMI_RH_NV_INDEX_Unmarshal((TPMI_RH_NV_INDEX *)&(target->nvIndex), buffer, size);
5373 if(result == TPM_RC_SUCCESS)
5374 result = TPMI_ALG_HASH_Unmarshal((TPMI_ALG_HASH *)&(target->nameAlg), buffer, size, 0);
5375 if(result == TPM_RC_SUCCESS)
5376 result = TPMA_NV_Unmarshal((TPMA_NV *)&(target->attributes), buffer, size);
5377 if(result == TPM_RC_SUCCESS)
5378 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->authPolicy), buffer, size);
5379 if(result == TPM_RC_SUCCESS)
5380 result = UINT16_Unmarshal((UINT16 *)&(target->dataSize), buffer, size);
5381 if( (result == TPM_RC_SUCCESS)
5382 && (target->dataSize > MAX_NV_INDEX_SIZE))
5383 result = TPM_RC_SIZE;
5384 return result;
5385 }
5386 UINT16
TPMS_NV_PUBLIC_Marshal(TPMS_NV_PUBLIC * source,BYTE ** buffer,INT32 * size)5387 TPMS_NV_PUBLIC_Marshal(TPMS_NV_PUBLIC *source, BYTE **buffer, INT32 *size)
5388 {
5389 UINT16 result = 0;
5390 result = (UINT16)(result + TPMI_RH_NV_INDEX_Marshal((TPMI_RH_NV_INDEX *)&(source->nvIndex), buffer, size));
5391 result = (UINT16)(result + TPMI_ALG_HASH_Marshal((TPMI_ALG_HASH *)&(source->nameAlg), buffer, size));
5392 result = (UINT16)(result + TPMA_NV_Marshal((TPMA_NV *)&(source->attributes), buffer, size));
5393 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->authPolicy), buffer, size));
5394 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->dataSize), buffer, size));
5395 return result;
5396 }
5397
5398 // Table 2:217 - Definition of TPM2B_NV_PUBLIC Structure
5399 TPM_RC
TPM2B_NV_PUBLIC_Unmarshal(TPM2B_NV_PUBLIC * target,BYTE ** buffer,INT32 * size)5400 TPM2B_NV_PUBLIC_Unmarshal(TPM2B_NV_PUBLIC *target, BYTE **buffer, INT32 *size)
5401 {
5402 TPM_RC result;
5403 result = UINT16_Unmarshal((UINT16 *)&(target->size), buffer, size); // =a
5404 if(result == TPM_RC_SUCCESS)
5405 {
5406 // if size is zero, then the required structure is missing
5407 if(target->size == 0)
5408 result = TPM_RC_SIZE;
5409 else
5410 {
5411 INT32 startSize = *size;
5412 result = TPMS_NV_PUBLIC_Unmarshal((TPMS_NV_PUBLIC *)&(target->nvPublic), buffer, size); // =b
5413 if(result == TPM_RC_SUCCESS)
5414 {
5415 if(target->size != (startSize - *size))
5416 result = TPM_RC_SIZE;
5417 }
5418 }
5419 }
5420 return result;
5421 }
5422 UINT16
TPM2B_NV_PUBLIC_Marshal(TPM2B_NV_PUBLIC * source,BYTE ** buffer,INT32 * size)5423 TPM2B_NV_PUBLIC_Marshal(TPM2B_NV_PUBLIC *source, BYTE **buffer, INT32 *size)
5424 {
5425 UINT16 result = 0;
5426 // Marshal a dummy value of the 2B size. This makes sure that 'buffer'
5427 // and 'size' are advanced as necessary (i.e., if they are present)
5428 result = UINT16_Marshal(&result, buffer, size);
5429 // Marshal the structure
5430 result = (UINT16)(result + TPMS_NV_PUBLIC_Marshal((TPMS_NV_PUBLIC *)&(source->nvPublic), buffer, size));
5431 // if a buffer was provided, go back and fill in the actual size
5432 if(buffer != NULL)
5433 UINT16_TO_BYTE_ARRAY((result - 2), (*buffer - result));
5434 return result;
5435 }
5436
5437 // Table 2:218 - Definition of TPM2B_CONTEXT_SENSITIVE Structure
5438 TPM_RC
TPM2B_CONTEXT_SENSITIVE_Unmarshal(TPM2B_CONTEXT_SENSITIVE * target,BYTE ** buffer,INT32 * size)5439 TPM2B_CONTEXT_SENSITIVE_Unmarshal(TPM2B_CONTEXT_SENSITIVE *target, BYTE **buffer, INT32 *size)
5440 {
5441 TPM_RC result;
5442 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
5443 if(result == TPM_RC_SUCCESS)
5444 {
5445 if((target->t.size) > MAX_CONTEXT_SIZE)
5446 result = TPM_RC_SIZE;
5447 else
5448 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
5449 }
5450 return result;
5451 }
5452 UINT16
TPM2B_CONTEXT_SENSITIVE_Marshal(TPM2B_CONTEXT_SENSITIVE * source,BYTE ** buffer,INT32 * size)5453 TPM2B_CONTEXT_SENSITIVE_Marshal(TPM2B_CONTEXT_SENSITIVE *source, BYTE **buffer, INT32 *size)
5454 {
5455 UINT16 result = 0;
5456 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
5457 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
5458 if(source->t.size == 0)
5459 return result;
5460 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
5461 return result;
5462 }
5463
5464 // Table 2:219 - Definition of TPMS_CONTEXT_DATA Structure
5465 TPM_RC
TPMS_CONTEXT_DATA_Unmarshal(TPMS_CONTEXT_DATA * target,BYTE ** buffer,INT32 * size)5466 TPMS_CONTEXT_DATA_Unmarshal(TPMS_CONTEXT_DATA *target, BYTE **buffer, INT32 *size)
5467 {
5468 TPM_RC result;
5469 result = TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)&(target->integrity), buffer, size);
5470 if(result == TPM_RC_SUCCESS)
5471 result = TPM2B_CONTEXT_SENSITIVE_Unmarshal((TPM2B_CONTEXT_SENSITIVE *)&(target->encrypted), buffer, size);
5472 return result;
5473 }
5474 UINT16
TPMS_CONTEXT_DATA_Marshal(TPMS_CONTEXT_DATA * source,BYTE ** buffer,INT32 * size)5475 TPMS_CONTEXT_DATA_Marshal(TPMS_CONTEXT_DATA *source, BYTE **buffer, INT32 *size)
5476 {
5477 UINT16 result = 0;
5478 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->integrity), buffer, size));
5479 result = (UINT16)(result + TPM2B_CONTEXT_SENSITIVE_Marshal((TPM2B_CONTEXT_SENSITIVE *)&(source->encrypted), buffer, size));
5480 return result;
5481 }
5482
5483 // Table 2:220 - Definition of TPM2B_CONTEXT_DATA Structure
5484 TPM_RC
TPM2B_CONTEXT_DATA_Unmarshal(TPM2B_CONTEXT_DATA * target,BYTE ** buffer,INT32 * size)5485 TPM2B_CONTEXT_DATA_Unmarshal(TPM2B_CONTEXT_DATA *target, BYTE **buffer, INT32 *size)
5486 {
5487 TPM_RC result;
5488 result = UINT16_Unmarshal((UINT16 *)&(target->t.size), buffer, size);
5489 if(result == TPM_RC_SUCCESS)
5490 {
5491 if((target->t.size) > sizeof(TPMS_CONTEXT_DATA))
5492 result = TPM_RC_SIZE;
5493 else
5494 result = BYTE_Array_Unmarshal((BYTE *)(target->t.buffer), buffer, size, (INT32)(target->t.size));
5495 }
5496 return result;
5497 }
5498 UINT16
TPM2B_CONTEXT_DATA_Marshal(TPM2B_CONTEXT_DATA * source,BYTE ** buffer,INT32 * size)5499 TPM2B_CONTEXT_DATA_Marshal(TPM2B_CONTEXT_DATA *source, BYTE **buffer, INT32 *size)
5500 {
5501 UINT16 result = 0;
5502 result = (UINT16)(result + UINT16_Marshal((UINT16 *)&(source->t.size), buffer, size));
5503 // if size equal to 0, the rest of the structure is a zero buffer. Stop processing
5504 if(source->t.size == 0)
5505 return result;
5506 result = (UINT16)(result + BYTE_Array_Marshal((BYTE *)(source->t.buffer), buffer, size, (INT32)(source->t.size)));
5507 return result;
5508 }
5509
5510 // Table 2:221 - Definition of TPMS_CONTEXT Structure
5511 TPM_RC
TPMS_CONTEXT_Unmarshal(TPMS_CONTEXT * target,BYTE ** buffer,INT32 * size)5512 TPMS_CONTEXT_Unmarshal(TPMS_CONTEXT *target, BYTE **buffer, INT32 *size)
5513 {
5514 TPM_RC result;
5515 result = UINT64_Unmarshal((UINT64 *)&(target->sequence), buffer, size);
5516 if(result == TPM_RC_SUCCESS)
5517 result = TPMI_DH_SAVED_Unmarshal((TPMI_DH_SAVED *)&(target->savedHandle), buffer, size);
5518 if(result == TPM_RC_SUCCESS)
5519 result = TPMI_RH_HIERARCHY_Unmarshal((TPMI_RH_HIERARCHY *)&(target->hierarchy), buffer, size, 1);
5520 if(result == TPM_RC_SUCCESS)
5521 result = TPM2B_CONTEXT_DATA_Unmarshal((TPM2B_CONTEXT_DATA *)&(target->contextBlob), buffer, size);
5522 return result;
5523 }
5524 UINT16
TPMS_CONTEXT_Marshal(TPMS_CONTEXT * source,BYTE ** buffer,INT32 * size)5525 TPMS_CONTEXT_Marshal(TPMS_CONTEXT *source, BYTE **buffer, INT32 *size)
5526 {
5527 UINT16 result = 0;
5528 result = (UINT16)(result + UINT64_Marshal((UINT64 *)&(source->sequence), buffer, size));
5529 result = (UINT16)(result + TPMI_DH_SAVED_Marshal((TPMI_DH_SAVED *)&(source->savedHandle), buffer, size));
5530 result = (UINT16)(result + TPMI_RH_HIERARCHY_Marshal((TPMI_RH_HIERARCHY *)&(source->hierarchy), buffer, size));
5531 result = (UINT16)(result + TPM2B_CONTEXT_DATA_Marshal((TPM2B_CONTEXT_DATA *)&(source->contextBlob), buffer, size));
5532 return result;
5533 }
5534
5535 // Table 2:223 - Definition of TPMS_CREATION_DATA Structure
5536 UINT16
TPMS_CREATION_DATA_Marshal(TPMS_CREATION_DATA * source,BYTE ** buffer,INT32 * size)5537 TPMS_CREATION_DATA_Marshal(TPMS_CREATION_DATA *source, BYTE **buffer, INT32 *size)
5538 {
5539 UINT16 result = 0;
5540 result = (UINT16)(result + TPML_PCR_SELECTION_Marshal((TPML_PCR_SELECTION *)&(source->pcrSelect), buffer, size));
5541 result = (UINT16)(result + TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)&(source->pcrDigest), buffer, size));
5542 result = (UINT16)(result + TPMA_LOCALITY_Marshal((TPMA_LOCALITY *)&(source->locality), buffer, size));
5543 result = (UINT16)(result + TPM_ALG_ID_Marshal((TPM_ALG_ID *)&(source->parentNameAlg), buffer, size));
5544 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->parentName), buffer, size));
5545 result = (UINT16)(result + TPM2B_NAME_Marshal((TPM2B_NAME *)&(source->parentQualifiedName), buffer, size));
5546 result = (UINT16)(result + TPM2B_DATA_Marshal((TPM2B_DATA *)&(source->outsideInfo), buffer, size));
5547 return result;
5548 }
5549
5550 // Table 2:224 - Definition of TPM2B_CREATION_DATA Structure
5551 UINT16
TPM2B_CREATION_DATA_Marshal(TPM2B_CREATION_DATA * source,BYTE ** buffer,INT32 * size)5552 TPM2B_CREATION_DATA_Marshal(TPM2B_CREATION_DATA *source, BYTE **buffer, INT32 *size)
5553 {
5554 UINT16 result = 0;
5555 // Marshal a dummy value of the 2B size. This makes sure that 'buffer'
5556 // and 'size' are advanced as necessary (i.e., if they are present)
5557 result = UINT16_Marshal(&result, buffer, size);
5558 // Marshal the structure
5559 result = (UINT16)(result + TPMS_CREATION_DATA_Marshal((TPMS_CREATION_DATA *)&(source->creationData), buffer, size));
5560 // if a buffer was provided, go back and fill in the actual size
5561 if(buffer != NULL)
5562 UINT16_TO_BYTE_ARRAY((result - 2), (*buffer - result));
5563 return result;
5564 }
5565
5566 // Table 2:225 - Definition of TPM_AT Constants
5567 TPM_RC
TPM_AT_Unmarshal(TPM_AT * target,BYTE ** buffer,INT32 * size)5568 TPM_AT_Unmarshal(TPM_AT *target, BYTE **buffer, INT32 *size)
5569 {
5570 TPM_RC result;
5571 result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
5572 if(result == TPM_RC_SUCCESS)
5573 {
5574 switch(*target)
5575 {
5576 case TPM_AT_ANY :
5577 case TPM_AT_ERROR :
5578 case TPM_AT_PV1 :
5579 case TPM_AT_VEND :
5580 break;
5581 default :
5582 result = TPM_RC_VALUE;
5583 break;
5584 }
5585 }
5586 return result;
5587 }
5588 #if !USE_MARSHALING_DEFINES
5589 UINT16
TPM_AT_Marshal(TPM_AT * source,BYTE ** buffer,INT32 * size)5590 TPM_AT_Marshal(TPM_AT *source, BYTE **buffer, INT32 *size)
5591 {
5592 return UINT32_Marshal((UINT32 *)source, buffer, size);
5593 }
5594 #endif // !USE_MARSHALING_DEFINES
5595
5596 // Table 2:226 - Definition of TPM_AE Constants
5597 #if !USE_MARSHALING_DEFINES
5598 UINT16
TPM_AE_Marshal(TPM_AE * source,BYTE ** buffer,INT32 * size)5599 TPM_AE_Marshal(TPM_AE *source, BYTE **buffer, INT32 *size)
5600 {
5601 return UINT32_Marshal((UINT32 *)source, buffer, size);
5602 }
5603 #endif // !USE_MARSHALING_DEFINES
5604
5605 // Table 2:227 - Definition of TPMS_AC_OUTPUT Structure
5606 UINT16
TPMS_AC_OUTPUT_Marshal(TPMS_AC_OUTPUT * source,BYTE ** buffer,INT32 * size)5607 TPMS_AC_OUTPUT_Marshal(TPMS_AC_OUTPUT *source, BYTE **buffer, INT32 *size)
5608 {
5609 UINT16 result = 0;
5610 result = (UINT16)(result + TPM_AT_Marshal((TPM_AT *)&(source->tag), buffer, size));
5611 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->data), buffer, size));
5612 return result;
5613 }
5614
5615 // Table 2:228 - Definition of TPML_AC_CAPABILITIES Structure
5616 UINT16
TPML_AC_CAPABILITIES_Marshal(TPML_AC_CAPABILITIES * source,BYTE ** buffer,INT32 * size)5617 TPML_AC_CAPABILITIES_Marshal(TPML_AC_CAPABILITIES *source, BYTE **buffer, INT32 *size)
5618 {
5619 UINT16 result = 0;
5620 result = (UINT16)(result + UINT32_Marshal((UINT32 *)&(source->count), buffer, size));
5621 result = (UINT16)(result + TPMS_AC_OUTPUT_Array_Marshal((TPMS_AC_OUTPUT *)(source->acCapabilities), buffer, size, (INT32)(source->count)));
5622 return result;
5623 }
5624
5625 // Array Marshal/Unmarshal for BYTE
5626 TPM_RC
BYTE_Array_Unmarshal(BYTE * target,BYTE ** buffer,INT32 * size,INT32 count)5627 BYTE_Array_Unmarshal(BYTE *target, BYTE **buffer, INT32 *size, INT32 count)
5628 {
5629 if(*size < count)
5630 return TPM_RC_INSUFFICIENT;
5631 memcpy(target, *buffer, count);
5632 *size -= count;
5633 *buffer += count;
5634 return TPM_RC_SUCCESS;
5635 }
5636 UINT16
BYTE_Array_Marshal(BYTE * source,BYTE ** buffer,INT32 * size,INT32 count)5637 BYTE_Array_Marshal(BYTE *source, BYTE **buffer, INT32 *size, INT32 count)
5638 {
5639 if (buffer != 0)
5640 {
5641 if ((size == 0) || ((*size -= count) >= 0))
5642 {
5643 memcpy(*buffer, source, count);
5644 *buffer += count;
5645 }
5646 pAssert(size == 0 || (*size >= 0));
5647 }
5648 pAssert(count < INT16_MAX);
5649 return ((UINT16)count);
5650 }
5651
5652 // Array Marshal/Unmarshal for TPM2B_DIGEST
5653 TPM_RC
TPM2B_DIGEST_Array_Unmarshal(TPM2B_DIGEST * target,BYTE ** buffer,INT32 * size,INT32 count)5654 TPM2B_DIGEST_Array_Unmarshal(TPM2B_DIGEST *target, BYTE **buffer, INT32 *size, INT32 count)
5655 {
5656 TPM_RC result;
5657 INT32 i;
5658 for(result = TPM_RC_SUCCESS, i = 0;
5659 ((result == TPM_RC_SUCCESS) && (i < count)); i++)
5660 {
5661 result = TPM2B_DIGEST_Unmarshal(&target[i], buffer, size);
5662 }
5663 return result;
5664 }
5665 UINT16
TPM2B_DIGEST_Array_Marshal(TPM2B_DIGEST * source,BYTE ** buffer,INT32 * size,INT32 count)5666 TPM2B_DIGEST_Array_Marshal(TPM2B_DIGEST *source, BYTE **buffer, INT32 *size, INT32 count)
5667 {
5668 UINT16 result = 0;
5669 INT32 i;
5670 for(i = 0; i < count; i++)
5671 {
5672 result = (UINT16)(result + TPM2B_DIGEST_Marshal(&source[i], buffer, size));
5673 }
5674 return result;
5675 }
5676
5677 // Array Marshal for TPMA_CC
5678 UINT16
TPMA_CC_Array_Marshal(TPMA_CC * source,BYTE ** buffer,INT32 * size,INT32 count)5679 TPMA_CC_Array_Marshal(TPMA_CC *source, BYTE **buffer, INT32 *size, INT32 count)
5680 {
5681 UINT16 result = 0;
5682 INT32 i;
5683 for(i = 0; i < count; i++)
5684 {
5685 result = (UINT16)(result + TPMA_CC_Marshal(&source[i], buffer, size));
5686 }
5687 return result;
5688 }
5689
5690 // Array Marshal for TPMS_ACT_DATA
5691 UINT16
TPMS_ACT_DATA_Array_Marshal(TPMS_ACT_DATA * source,BYTE ** buffer,INT32 * size,INT32 count)5692 TPMS_ACT_DATA_Array_Marshal(TPMS_ACT_DATA *source, BYTE **buffer, INT32 *size, INT32 count)
5693 {
5694 UINT16 result = 0;
5695 INT32 i;
5696 for(i = 0; i < count; i++)
5697 {
5698 result = (UINT16)(result + TPMS_ACT_DATA_Marshal(&source[i], buffer, size));
5699 }
5700 return result;
5701 }
5702
5703 // Array Marshal for TPMS_AC_OUTPUT
5704 UINT16
TPMS_AC_OUTPUT_Array_Marshal(TPMS_AC_OUTPUT * source,BYTE ** buffer,INT32 * size,INT32 count)5705 TPMS_AC_OUTPUT_Array_Marshal(TPMS_AC_OUTPUT *source, BYTE **buffer, INT32 *size, INT32 count)
5706 {
5707 UINT16 result = 0;
5708 INT32 i;
5709 for(i = 0; i < count; i++)
5710 {
5711 result = (UINT16)(result + TPMS_AC_OUTPUT_Marshal(&source[i], buffer, size));
5712 }
5713 return result;
5714 }
5715
5716 // Array Marshal for TPMS_ALG_PROPERTY
5717 UINT16
TPMS_ALG_PROPERTY_Array_Marshal(TPMS_ALG_PROPERTY * source,BYTE ** buffer,INT32 * size,INT32 count)5718 TPMS_ALG_PROPERTY_Array_Marshal(TPMS_ALG_PROPERTY *source, BYTE **buffer, INT32 *size, INT32 count)
5719 {
5720 UINT16 result = 0;
5721 INT32 i;
5722 for(i = 0; i < count; i++)
5723 {
5724 result = (UINT16)(result + TPMS_ALG_PROPERTY_Marshal(&source[i], buffer, size));
5725 }
5726 return result;
5727 }
5728
5729 // Array Marshal/Unmarshal for TPMS_PCR_SELECTION
5730 TPM_RC
TPMS_PCR_SELECTION_Array_Unmarshal(TPMS_PCR_SELECTION * target,BYTE ** buffer,INT32 * size,INT32 count)5731 TPMS_PCR_SELECTION_Array_Unmarshal(TPMS_PCR_SELECTION *target, BYTE **buffer, INT32 *size, INT32 count)
5732 {
5733 TPM_RC result;
5734 INT32 i;
5735 for(result = TPM_RC_SUCCESS, i = 0;
5736 ((result == TPM_RC_SUCCESS) && (i < count)); i++)
5737 {
5738 result = TPMS_PCR_SELECTION_Unmarshal(&target[i], buffer, size);
5739 }
5740 return result;
5741 }
5742 UINT16
TPMS_PCR_SELECTION_Array_Marshal(TPMS_PCR_SELECTION * source,BYTE ** buffer,INT32 * size,INT32 count)5743 TPMS_PCR_SELECTION_Array_Marshal(TPMS_PCR_SELECTION *source, BYTE **buffer, INT32 *size, INT32 count)
5744 {
5745 UINT16 result = 0;
5746 INT32 i;
5747 for(i = 0; i < count; i++)
5748 {
5749 result = (UINT16)(result + TPMS_PCR_SELECTION_Marshal(&source[i], buffer, size));
5750 }
5751 return result;
5752 }
5753
5754 // Array Marshal for TPMS_TAGGED_PCR_SELECT
5755 UINT16
TPMS_TAGGED_PCR_SELECT_Array_Marshal(TPMS_TAGGED_PCR_SELECT * source,BYTE ** buffer,INT32 * size,INT32 count)5756 TPMS_TAGGED_PCR_SELECT_Array_Marshal(TPMS_TAGGED_PCR_SELECT *source, BYTE **buffer, INT32 *size, INT32 count)
5757 {
5758 UINT16 result = 0;
5759 INT32 i;
5760 for(i = 0; i < count; i++)
5761 {
5762 result = (UINT16)(result + TPMS_TAGGED_PCR_SELECT_Marshal(&source[i], buffer, size));
5763 }
5764 return result;
5765 }
5766
5767 // Array Marshal for TPMS_TAGGED_POLICY
5768 UINT16
TPMS_TAGGED_POLICY_Array_Marshal(TPMS_TAGGED_POLICY * source,BYTE ** buffer,INT32 * size,INT32 count)5769 TPMS_TAGGED_POLICY_Array_Marshal(TPMS_TAGGED_POLICY *source, BYTE **buffer, INT32 *size, INT32 count)
5770 {
5771 UINT16 result = 0;
5772 INT32 i;
5773 for(i = 0; i < count; i++)
5774 {
5775 result = (UINT16)(result + TPMS_TAGGED_POLICY_Marshal(&source[i], buffer, size));
5776 }
5777 return result;
5778 }
5779
5780 // Array Marshal for TPMS_TAGGED_PROPERTY
5781 UINT16
TPMS_TAGGED_PROPERTY_Array_Marshal(TPMS_TAGGED_PROPERTY * source,BYTE ** buffer,INT32 * size,INT32 count)5782 TPMS_TAGGED_PROPERTY_Array_Marshal(TPMS_TAGGED_PROPERTY *source, BYTE **buffer, INT32 *size, INT32 count)
5783 {
5784 UINT16 result = 0;
5785 INT32 i;
5786 for(i = 0; i < count; i++)
5787 {
5788 result = (UINT16)(result + TPMS_TAGGED_PROPERTY_Marshal(&source[i], buffer, size));
5789 }
5790 return result;
5791 }
5792
5793 // Array Marshal/Unmarshal for TPMT_HA
5794 TPM_RC
TPMT_HA_Array_Unmarshal(TPMT_HA * target,BYTE ** buffer,INT32 * size,BOOL flag,INT32 count)5795 TPMT_HA_Array_Unmarshal(TPMT_HA *target, BYTE **buffer, INT32 *size, BOOL flag, INT32 count)
5796 {
5797 TPM_RC result;
5798 INT32 i;
5799 for(result = TPM_RC_SUCCESS, i = 0;
5800 ((result == TPM_RC_SUCCESS) && (i < count)); i++)
5801 {
5802 result = TPMT_HA_Unmarshal(&target[i], buffer, size, flag);
5803 }
5804 return result;
5805 }
5806 UINT16
TPMT_HA_Array_Marshal(TPMT_HA * source,BYTE ** buffer,INT32 * size,INT32 count)5807 TPMT_HA_Array_Marshal(TPMT_HA *source, BYTE **buffer, INT32 *size, INT32 count)
5808 {
5809 UINT16 result = 0;
5810 INT32 i;
5811 for(i = 0; i < count; i++)
5812 {
5813 result = (UINT16)(result + TPMT_HA_Marshal(&source[i], buffer, size));
5814 }
5815 return result;
5816 }
5817
5818 // Array Marshal/Unmarshal for TPM_ALG_ID
5819 TPM_RC
TPM_ALG_ID_Array_Unmarshal(TPM_ALG_ID * target,BYTE ** buffer,INT32 * size,INT32 count)5820 TPM_ALG_ID_Array_Unmarshal(TPM_ALG_ID *target, BYTE **buffer, INT32 *size, INT32 count)
5821 {
5822 TPM_RC result;
5823 INT32 i;
5824 for(result = TPM_RC_SUCCESS, i = 0;
5825 ((result == TPM_RC_SUCCESS) && (i < count)); i++)
5826 {
5827 result = TPM_ALG_ID_Unmarshal(&target[i], buffer, size);
5828 }
5829 return result;
5830 }
5831 UINT16
TPM_ALG_ID_Array_Marshal(TPM_ALG_ID * source,BYTE ** buffer,INT32 * size,INT32 count)5832 TPM_ALG_ID_Array_Marshal(TPM_ALG_ID *source, BYTE **buffer, INT32 *size, INT32 count)
5833 {
5834 UINT16 result = 0;
5835 INT32 i;
5836 for(i = 0; i < count; i++)
5837 {
5838 result = (UINT16)(result + TPM_ALG_ID_Marshal(&source[i], buffer, size));
5839 }
5840 return result;
5841 }
5842
5843 // Array Marshal/Unmarshal for TPM_CC
5844 TPM_RC
TPM_CC_Array_Unmarshal(TPM_CC * target,BYTE ** buffer,INT32 * size,INT32 count)5845 TPM_CC_Array_Unmarshal(TPM_CC *target, BYTE **buffer, INT32 *size, INT32 count)
5846 {
5847 TPM_RC result;
5848 INT32 i;
5849 for(result = TPM_RC_SUCCESS, i = 0;
5850 ((result == TPM_RC_SUCCESS) && (i < count)); i++)
5851 {
5852 result = TPM_CC_Unmarshal(&target[i], buffer, size);
5853 }
5854 return result;
5855 }
5856 UINT16
TPM_CC_Array_Marshal(TPM_CC * source,BYTE ** buffer,INT32 * size,INT32 count)5857 TPM_CC_Array_Marshal(TPM_CC *source, BYTE **buffer, INT32 *size, INT32 count)
5858 {
5859 UINT16 result = 0;
5860 INT32 i;
5861 for(i = 0; i < count; i++)
5862 {
5863 result = (UINT16)(result + TPM_CC_Marshal(&source[i], buffer, size));
5864 }
5865 return result;
5866 }
5867
5868 // Array Marshal/Unmarshal for TPM_ECC_CURVE
5869 #if ALG_ECC
5870 TPM_RC
TPM_ECC_CURVE_Array_Unmarshal(TPM_ECC_CURVE * target,BYTE ** buffer,INT32 * size,INT32 count)5871 TPM_ECC_CURVE_Array_Unmarshal(TPM_ECC_CURVE *target, BYTE **buffer, INT32 *size, INT32 count)
5872 {
5873 TPM_RC result;
5874 INT32 i;
5875 for(result = TPM_RC_SUCCESS, i = 0;
5876 ((result == TPM_RC_SUCCESS) && (i < count)); i++)
5877 {
5878 result = TPM_ECC_CURVE_Unmarshal(&target[i], buffer, size);
5879 }
5880 return result;
5881 }
5882 UINT16
TPM_ECC_CURVE_Array_Marshal(TPM_ECC_CURVE * source,BYTE ** buffer,INT32 * size,INT32 count)5883 TPM_ECC_CURVE_Array_Marshal(TPM_ECC_CURVE *source, BYTE **buffer, INT32 *size, INT32 count)
5884 {
5885 UINT16 result = 0;
5886 INT32 i;
5887 for(i = 0; i < count; i++)
5888 {
5889 result = (UINT16)(result + TPM_ECC_CURVE_Marshal(&source[i], buffer, size));
5890 }
5891 return result;
5892 }
5893 #endif // ALG_ECC
5894
5895 // Array Marshal/Unmarshal for TPM_HANDLE
5896 TPM_RC
TPM_HANDLE_Array_Unmarshal(TPM_HANDLE * target,BYTE ** buffer,INT32 * size,INT32 count)5897 TPM_HANDLE_Array_Unmarshal(TPM_HANDLE *target, BYTE **buffer, INT32 *size, INT32 count)
5898 {
5899 TPM_RC result;
5900 INT32 i;
5901 for(result = TPM_RC_SUCCESS, i = 0;
5902 ((result == TPM_RC_SUCCESS) && (i < count)); i++)
5903 {
5904 result = TPM_HANDLE_Unmarshal(&target[i], buffer, size);
5905 }
5906 return result;
5907 }
5908 UINT16
TPM_HANDLE_Array_Marshal(TPM_HANDLE * source,BYTE ** buffer,INT32 * size,INT32 count)5909 TPM_HANDLE_Array_Marshal(TPM_HANDLE *source, BYTE **buffer, INT32 *size, INT32 count)
5910 {
5911 UINT16 result = 0;
5912 INT32 i;
5913 for(i = 0; i < count; i++)
5914 {
5915 result = (UINT16)(result + TPM_HANDLE_Marshal(&source[i], buffer, size));
5916 }
5917 return result;
5918 }
5919
5920 #endif // !TABLE_DRIVEN_MARSHAL
5921