1 /* SPDX-License-Identifier: BSD-2-Clause */ 2 /*********************************************************************** 3 * Copyright (c) 2015 - 2017, Intel Corporation 4 * 5 * All rights reserved. 6 ***********************************************************************/ 7 8 #ifdef HAVE_CONFIG_H 9 #include <config.h> 10 #endif 11 12 #include <inttypes.h> 13 #include <string.h> 14 15 #include "tss2_mu.h" 16 17 #include "util/tss2_endian.h" 18 #define LOGMODULE marshal 19 #include "util/log.h" 20 21 #define ADDR & 22 #define VAL 23 #define TAB_SIZE(tab) (sizeof(tab) / sizeof(tab[0])) 24 25 #define TPMS_PCR_MARSHAL(type, firstFieldMarshal) \ 26 TSS2_RC \ 27 Tss2_MU_##type##_Marshal(const type *src, uint8_t buffer[], \ 28 size_t buffer_size, size_t *offset) \ 29 { \ 30 TSS2_RC ret = TSS2_RC_SUCCESS; \ 31 size_t local_offset = 0; \ 32 UINT8 i; \ 33 \ 34 if (!src) { \ 35 LOG_WARNING("src param is NULL"); \ 36 return TSS2_MU_RC_BAD_REFERENCE; \ 37 } \ 38 \ 39 if (offset) { \ 40 local_offset = *offset; \ 41 } else if (!buffer) { \ 42 return TSS2_MU_RC_BAD_REFERENCE; \ 43 } \ 44 \ 45 LOG_DEBUG( \ 46 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 47 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, \ 48 offset?*offset:0xffff); \ 49 \ 50 if (src->sizeofSelect > TAB_SIZE(src->pcrSelect)) { \ 51 LOG_ERROR("sizeofSelect value %"PRIu8"/%zi too big", src->sizeofSelect, \ 52 TAB_SIZE(src->pcrSelect)); \ 53 return TSS2_SYS_RC_BAD_VALUE; \ 54 } \ 55 \ 56 ret = firstFieldMarshal; \ 57 if (ret != TSS2_RC_SUCCESS) \ 58 return ret; \ 59 \ 60 ret = Tss2_MU_UINT8_Marshal(src->sizeofSelect, buffer, buffer_size, &local_offset); \ 61 if (ret != TSS2_RC_SUCCESS) \ 62 return ret; \ 63 \ 64 for (i = 0; i < src->sizeofSelect; i++) { \ 65 ret = Tss2_MU_BYTE_Marshal(src->pcrSelect[i], buffer, buffer_size, \ 66 &local_offset); \ 67 if (ret != TSS2_RC_SUCCESS) \ 68 return ret; \ 69 } \ 70 \ 71 if (offset) { \ 72 *offset = local_offset; \ 73 } \ 74 \ 75 return TSS2_RC_SUCCESS; \ 76 } 77 78 TPMS_PCR_MARSHAL(TPMS_PCR_SELECT, TSS2_RC_SUCCESS) 79 80 TPMS_PCR_MARSHAL(TPMS_PCR_SELECTION, \ 81 Tss2_MU_TPMI_ALG_HASH_Marshal(src->hash, buffer, buffer_size, &local_offset)) 82 83 TPMS_PCR_MARSHAL(TPMS_TAGGED_PCR_SELECT, \ 84 Tss2_MU_UINT32_Marshal(src->tag, buffer, buffer_size, &local_offset)) 85 86 #define TPMS_PCR_UNMARSHAL(type, firstFieldUnmarshal) \ 87 TSS2_RC \ 88 Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 89 size_t *offset, type *dest) \ 90 { \ 91 TSS2_RC ret = TSS2_RC_SUCCESS; \ 92 size_t local_offset = 0; \ 93 UINT8 i, tmp; \ 94 \ 95 LOG_DEBUG( \ 96 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 97 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, \ 98 offset?*offset:0xffff); \ 99 \ 100 if (offset) { \ 101 local_offset = *offset; \ 102 } else if (!dest) { \ 103 return TSS2_MU_RC_BAD_REFERENCE; \ 104 } \ 105 \ 106 if (dest) \ 107 memset(dest, 0, sizeof(*dest)); \ 108 \ 109 ret = firstFieldUnmarshal; \ 110 if (ret != TSS2_RC_SUCCESS) \ 111 return ret; \ 112 \ 113 ret = Tss2_MU_UINT8_Unmarshal(buffer, buffer_size, &local_offset, \ 114 dest? &dest->sizeofSelect : &tmp); \ 115 if (ret) \ 116 return ret; \ 117 \ 118 if ((dest? dest->sizeofSelect : tmp) > TAB_SIZE(dest->pcrSelect)) { \ 119 LOG_ERROR("sizeofSelect value %"PRIu8" / %zi too big", \ 120 dest? dest->sizeofSelect : tmp, TAB_SIZE(dest->pcrSelect)); \ 121 return TSS2_SYS_RC_MALFORMED_RESPONSE; \ 122 } \ 123 \ 124 for (i = 0; i < (dest? dest->sizeofSelect : tmp); i++) \ 125 { \ 126 ret = Tss2_MU_UINT8_Unmarshal(buffer, buffer_size, &local_offset, \ 127 dest? &dest->pcrSelect[i] : NULL); \ 128 if (ret != TSS2_RC_SUCCESS) \ 129 return ret; \ 130 } \ 131 \ 132 if (offset) { \ 133 *offset = local_offset; \ 134 } \ 135 \ 136 return TSS2_RC_SUCCESS; \ 137 } 138 139 TPMS_PCR_UNMARSHAL(TPMS_PCR_SELECT, TSS2_RC_SUCCESS) 140 141 TPMS_PCR_UNMARSHAL(TPMS_PCR_SELECTION, \ 142 Tss2_MU_TPMI_ALG_HASH_Unmarshal(buffer, buffer_size, &local_offset, \ 143 dest? &dest->hash : NULL)) 144 145 TPMS_PCR_UNMARSHAL(TPMS_TAGGED_PCR_SELECT, \ 146 Tss2_MU_UINT32_Unmarshal(buffer, buffer_size, &local_offset, \ 147 dest? &dest->tag : NULL)) 148 149 #define TPMS_MARSHAL_0(type) \ 150 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 151 size_t buffer_size, size_t *offset) \ 152 { \ 153 (void)(buffer); \ 154 (void)(buffer_size); \ 155 (void)(offset); \ 156 \ 157 if (!src) { \ 158 LOG_WARNING("src param is NULL"); \ 159 return TSS2_MU_RC_BAD_REFERENCE; \ 160 } \ 161 \ 162 LOG_DEBUG( \ 163 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 164 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, *offset); \ 165 \ 166 return TSS2_RC_SUCCESS; \ 167 } 168 169 #define TPMS_UNMARSHAL_0(type) \ 170 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 171 size_t *offset, type *dest) \ 172 { \ 173 (void)(buffer); \ 174 (void)(buffer_size); \ 175 (void)(offset); \ 176 \ 177 if (!dest) { \ 178 LOG_WARNING("src param is NULL"); \ 179 return TSS2_MU_RC_BAD_REFERENCE; \ 180 } \ 181 \ 182 LOG_DEBUG( \ 183 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 184 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, *offset); \ 185 \ 186 return TSS2_RC_SUCCESS; \ 187 } 188 189 #define TPMS_MARSHAL_1(type, m, op, fn) \ 190 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 191 size_t buffer_size, size_t *offset) \ 192 { \ 193 if (!src) { \ 194 LOG_WARNING("src param is NULL"); \ 195 return TSS2_MU_RC_BAD_REFERENCE; \ 196 } \ 197 \ 198 LOG_DEBUG(\ 199 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 200 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 201 \ 202 return fn(op src->m, buffer, buffer_size, offset); \ 203 } 204 205 #define TPMS_UNMARSHAL_1(type, m, fn) \ 206 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 207 size_t *offset, type *dest) \ 208 { \ 209 LOG_DEBUG(\ 210 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 211 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 212 \ 213 return fn(buffer, buffer_size, offset, dest ? &dest->m : NULL); \ 214 } 215 216 #define TPMS_MARSHAL_2_U(type, m1, op1, fn1, m2, op2, fn2) \ 217 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 218 size_t buffer_size, size_t *offset) \ 219 { \ 220 TSS2_RC ret = TSS2_RC_SUCCESS; \ 221 size_t local_offset = 0; \ 222 \ 223 if (!src) { \ 224 LOG_WARNING("src param is NULL"); \ 225 return TSS2_MU_RC_BAD_REFERENCE; \ 226 } \ 227 \ 228 if (offset) {\ 229 local_offset = *offset; \ 230 } else if (!buffer) { \ 231 return TSS2_MU_RC_BAD_REFERENCE; \ 232 } \ 233 \ 234 LOG_DEBUG(\ 235 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 236 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 237 \ 238 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 239 if (ret != TSS2_RC_SUCCESS) \ 240 return ret; \ 241 \ 242 ret = fn2(op2 src->m2, src->m1, buffer, buffer_size, &local_offset); \ 243 \ 244 if (offset && ret == TSS2_RC_SUCCESS) { \ 245 *offset = local_offset; \ 246 } \ 247 return ret; \ 248 } 249 250 #define TPMS_UNMARSHAL_2_U(type, m1, fn1, m2, fn2) \ 251 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 252 size_t *offset, type *dest) \ 253 { \ 254 TSS2_RC ret = TSS2_RC_SUCCESS; \ 255 size_t local_offset = 0; \ 256 type tmp_dest; \ 257 \ 258 LOG_DEBUG(\ 259 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 260 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 261 \ 262 if (offset) { \ 263 local_offset = *offset; \ 264 } else if (!dest) { \ 265 return TSS2_MU_RC_BAD_REFERENCE; \ 266 } \ 267 \ 268 if (dest) \ 269 memset(dest, 0, sizeof(*dest)); \ 270 \ 271 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : &tmp_dest.m1); \ 272 if (ret != TSS2_RC_SUCCESS) \ 273 return ret; \ 274 \ 275 ret = fn2(buffer, buffer_size, &local_offset, dest ? dest->m1 : tmp_dest.m1, dest ? &dest->m2 : NULL); \ 276 \ 277 if (offset && ret == TSS2_RC_SUCCESS) { \ 278 *offset = local_offset; \ 279 } \ 280 return ret; \ 281 } 282 283 #define TPMS_MARSHAL_2(type, m1, op1, fn1, m2, op2, fn2) \ 284 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 285 size_t buffer_size, size_t *offset) \ 286 { \ 287 TSS2_RC ret = TSS2_RC_SUCCESS; \ 288 size_t local_offset = 0; \ 289 \ 290 if (!src) { \ 291 LOG_WARNING("src param is NULL"); \ 292 return TSS2_MU_RC_BAD_REFERENCE; \ 293 } \ 294 \ 295 if (offset) { \ 296 local_offset = *offset; \ 297 } else if (!buffer) { \ 298 return TSS2_MU_RC_BAD_REFERENCE; \ 299 } \ 300 \ 301 LOG_DEBUG(\ 302 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 303 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 304 \ 305 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 306 if (ret != TSS2_RC_SUCCESS) \ 307 return ret; \ 308 \ 309 ret = fn2(op2 src->m2, buffer, buffer_size, &local_offset); \ 310 \ 311 if (offset && ret == TSS2_RC_SUCCESS) { \ 312 *offset = local_offset; \ 313 } \ 314 return ret; \ 315 } 316 317 #define TPMS_UNMARSHAL_2(type, m1, fn1, m2, fn2) \ 318 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 319 size_t *offset, type *dest) \ 320 { \ 321 TSS2_RC ret = TSS2_RC_SUCCESS; \ 322 size_t local_offset = 0; \ 323 \ 324 LOG_DEBUG(\ 325 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 326 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 327 \ 328 if (offset) { \ 329 local_offset = *offset; \ 330 } else if (!dest) { \ 331 return TSS2_MU_RC_BAD_REFERENCE; \ 332 } \ 333 \ 334 if (dest) \ 335 memset(dest, 0, sizeof(*dest)); \ 336 \ 337 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : NULL); \ 338 if (ret != TSS2_RC_SUCCESS) \ 339 return ret; \ 340 \ 341 ret = fn2(buffer, buffer_size, &local_offset, dest ? &dest->m2 : NULL); \ 342 \ 343 if (offset && ret == TSS2_RC_SUCCESS) { \ 344 *offset = local_offset; \ 345 } \ 346 return ret; \ 347 } 348 349 #define TPMS_MARSHAL_3(type, m1, op1, fn1, m2, op2, fn2, m3, op3, fn3) \ 350 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 351 size_t buffer_size, size_t *offset) \ 352 { \ 353 TSS2_RC ret = TSS2_RC_SUCCESS; \ 354 size_t local_offset = 0; \ 355 \ 356 if (!src) { \ 357 LOG_WARNING("src param is NULL"); \ 358 return TSS2_MU_RC_BAD_REFERENCE; \ 359 } \ 360 \ 361 if (offset) { \ 362 local_offset = *offset; \ 363 } else if (!buffer) { \ 364 return TSS2_MU_RC_BAD_REFERENCE; \ 365 } \ 366 \ 367 LOG_DEBUG(\ 368 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 369 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 370 \ 371 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 372 if (ret != TSS2_RC_SUCCESS) \ 373 return ret; \ 374 \ 375 ret = fn2(op2 src->m2, buffer, buffer_size, &local_offset); \ 376 if (ret != TSS2_RC_SUCCESS) \ 377 return ret; \ 378 \ 379 ret = fn3(op3 src->m3, buffer, buffer_size, &local_offset); \ 380 \ 381 if (offset && ret == TSS2_RC_SUCCESS) { \ 382 *offset = local_offset; \ 383 } \ 384 return ret; \ 385 } 386 387 #define TPMS_UNMARSHAL_3(type, m1, fn1, m2, fn2, m3, fn3) \ 388 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 389 size_t *offset, type *dest) \ 390 { \ 391 TSS2_RC ret = TSS2_RC_SUCCESS; \ 392 size_t local_offset = 0; \ 393 \ 394 LOG_DEBUG(\ 395 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 396 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 397 \ 398 if (offset) { \ 399 local_offset = *offset; \ 400 } else if (!dest) { \ 401 return TSS2_MU_RC_BAD_REFERENCE; \ 402 } \ 403 \ 404 if (dest) \ 405 memset(dest, 0, sizeof(*dest)); \ 406 \ 407 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : NULL); \ 408 if (ret != TSS2_RC_SUCCESS) \ 409 return ret; \ 410 \ 411 ret = fn2(buffer, buffer_size, &local_offset, dest ? &dest->m2 : NULL); \ 412 if (ret != TSS2_RC_SUCCESS) \ 413 return ret; \ 414 \ 415 ret = fn3(buffer, buffer_size, &local_offset, dest ? &dest->m3 : NULL); \ 416 \ 417 if (offset && ret == TSS2_RC_SUCCESS) { \ 418 *offset = local_offset; \ 419 } \ 420 return ret; \ 421 } 422 423 #define TPMS_MARSHAL_4(type, m1, op1, fn1, m2, op2, fn2, m3, op3, fn3, m4, op4, fn4) \ 424 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 425 size_t buffer_size, size_t *offset) \ 426 { \ 427 TSS2_RC ret = TSS2_RC_SUCCESS; \ 428 size_t local_offset = 0; \ 429 \ 430 if (!src) { \ 431 LOG_WARNING("src param is NULL"); \ 432 return TSS2_MU_RC_BAD_REFERENCE; \ 433 } \ 434 \ 435 if (offset) { \ 436 local_offset = *offset; \ 437 } else if (!buffer) { \ 438 return TSS2_MU_RC_BAD_REFERENCE; \ 439 } \ 440 \ 441 LOG_DEBUG(\ 442 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 443 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 444 \ 445 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 446 if (ret != TSS2_RC_SUCCESS) \ 447 return ret; \ 448 \ 449 ret = fn2(op2 src->m2, buffer, buffer_size, &local_offset); \ 450 if (ret != TSS2_RC_SUCCESS) \ 451 return ret; \ 452 \ 453 ret = fn3(op3 src->m3, buffer, buffer_size, &local_offset); \ 454 if (ret != TSS2_RC_SUCCESS) \ 455 return ret; \ 456 \ 457 ret = fn4(op4 src->m4, buffer, buffer_size, &local_offset); \ 458 \ 459 if (offset && ret == TSS2_RC_SUCCESS) { \ 460 *offset = local_offset; \ 461 } \ 462 return ret; \ 463 } 464 465 #define TPMS_UNMARSHAL_4(type, m1, fn1, m2, fn2, m3, fn3, m4, fn4) \ 466 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 467 size_t *offset, type *dest) \ 468 { \ 469 TSS2_RC ret = TSS2_RC_SUCCESS; \ 470 size_t local_offset = 0; \ 471 \ 472 if (offset) { \ 473 local_offset = *offset; \ 474 } else if (!dest) { \ 475 return TSS2_MU_RC_BAD_REFERENCE; \ 476 } \ 477 \ 478 if (dest) \ 479 memset(dest, 0, sizeof(*dest)); \ 480 \ 481 LOG_DEBUG(\ 482 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 483 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 484 \ 485 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : NULL); \ 486 if (ret != TSS2_RC_SUCCESS) \ 487 return ret; \ 488 \ 489 ret = fn2(buffer, buffer_size, &local_offset, dest ? &dest->m2 : NULL); \ 490 if (ret != TSS2_RC_SUCCESS) \ 491 return ret; \ 492 \ 493 ret = fn3(buffer, buffer_size, &local_offset, dest ? &dest->m3 : NULL); \ 494 if (ret != TSS2_RC_SUCCESS) \ 495 return ret; \ 496 \ 497 ret = fn4(buffer, buffer_size, &local_offset, dest ? &dest->m4 : NULL); \ 498 \ 499 if (offset && ret == TSS2_RC_SUCCESS) { \ 500 *offset = local_offset; \ 501 } \ 502 return ret; \ 503 } 504 505 #define TPMS_MARSHAL_5(type, m1, op1, fn1, m2, op2, fn2, m3, op3, fn3, \ 506 m4, op4, fn4, m5, op5, fn5) \ 507 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 508 size_t buffer_size, size_t *offset) \ 509 { \ 510 TSS2_RC ret = TSS2_RC_SUCCESS; \ 511 size_t local_offset = 0; \ 512 \ 513 if (!src) { \ 514 LOG_WARNING("src param is NULL"); \ 515 return TSS2_MU_RC_BAD_REFERENCE; \ 516 } \ 517 \ 518 if (offset) { \ 519 local_offset = *offset; \ 520 } else if (!buffer) { \ 521 return TSS2_MU_RC_BAD_REFERENCE; \ 522 } \ 523 \ 524 LOG_DEBUG(\ 525 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 526 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 527 \ 528 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 529 if (ret != TSS2_RC_SUCCESS) \ 530 return ret; \ 531 \ 532 ret = fn2(op2 src->m2, buffer, buffer_size, &local_offset); \ 533 if (ret != TSS2_RC_SUCCESS) \ 534 return ret; \ 535 \ 536 ret = fn3(op3 src->m3, buffer, buffer_size, &local_offset); \ 537 if (ret != TSS2_RC_SUCCESS) \ 538 return ret; \ 539 \ 540 ret = fn4(op4 src->m4, buffer, buffer_size, &local_offset); \ 541 if (ret != TSS2_RC_SUCCESS) \ 542 return ret; \ 543 \ 544 ret = fn5(op5 src->m5, buffer, buffer_size, &local_offset); \ 545 \ 546 if (offset && ret == TSS2_RC_SUCCESS) { \ 547 *offset = local_offset; \ 548 } \ 549 return ret; \ 550 } 551 552 #define TPMS_UNMARSHAL_5(type, m1, fn1, m2, fn2, m3, fn3, m4, fn4, m5, fn5) \ 553 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 554 size_t *offset, type *dest) \ 555 { \ 556 TSS2_RC ret = TSS2_RC_SUCCESS; \ 557 size_t local_offset = 0; \ 558 \ 559 LOG_DEBUG(\ 560 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 561 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 562 \ 563 if (offset) { \ 564 local_offset = *offset; \ 565 } else if (!dest) { \ 566 return TSS2_MU_RC_BAD_REFERENCE; \ 567 } \ 568 \ 569 if (dest) \ 570 memset(dest, 0, sizeof(*dest)); \ 571 \ 572 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : NULL); \ 573 if (ret != TSS2_RC_SUCCESS) \ 574 return ret; \ 575 \ 576 ret = fn2(buffer, buffer_size, &local_offset, dest ? &dest->m2 : NULL); \ 577 if (ret != TSS2_RC_SUCCESS) \ 578 return ret; \ 579 \ 580 ret = fn3(buffer, buffer_size, &local_offset, dest ? &dest->m3 : NULL); \ 581 if (ret != TSS2_RC_SUCCESS) \ 582 return ret; \ 583 \ 584 ret = fn4(buffer, buffer_size, &local_offset, dest ? &dest->m4 : NULL); \ 585 if (ret != TSS2_RC_SUCCESS) \ 586 return ret; \ 587 \ 588 ret = fn5(buffer, buffer_size, &local_offset, dest ? &dest->m5 : NULL); \ 589 \ 590 if (offset && ret == TSS2_RC_SUCCESS) { \ 591 *offset = local_offset; \ 592 } \ 593 return ret; \ 594 } 595 596 #define TPMS_MARSHAL_7(type, m1, op1, fn1, m2, op2, fn2, m3, op3, fn3, \ 597 m4, op4, fn4, m5, op5, fn5, m6, op6, fn6, m7, op7, fn7) \ 598 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 599 size_t buffer_size, size_t *offset) \ 600 { \ 601 TSS2_RC ret = TSS2_RC_SUCCESS; \ 602 size_t local_offset = 0; \ 603 \ 604 if (!src) { \ 605 LOG_WARNING("src param is NULL"); \ 606 return TSS2_MU_RC_BAD_REFERENCE; \ 607 } \ 608 \ 609 if (offset) { \ 610 local_offset = *offset; \ 611 } else if (!buffer) { \ 612 return TSS2_MU_RC_BAD_REFERENCE; \ 613 } \ 614 \ 615 LOG_DEBUG(\ 616 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 617 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 618 \ 619 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 620 if (ret != TSS2_RC_SUCCESS) \ 621 return ret; \ 622 \ 623 ret = fn2(op2 src->m2, buffer, buffer_size, &local_offset); \ 624 if (ret != TSS2_RC_SUCCESS) \ 625 return ret; \ 626 \ 627 ret = fn3(op3 src->m3, buffer, buffer_size, &local_offset); \ 628 if (ret != TSS2_RC_SUCCESS) \ 629 return ret; \ 630 \ 631 ret = fn4(op4 src->m4, buffer, buffer_size, &local_offset); \ 632 if (ret != TSS2_RC_SUCCESS) \ 633 return ret; \ 634 \ 635 ret = fn5(op5 src->m5, buffer, buffer_size, &local_offset); \ 636 if (ret != TSS2_RC_SUCCESS) \ 637 return ret; \ 638 \ 639 ret = fn6(op6 src->m6, buffer, buffer_size, &local_offset); \ 640 if (ret != TSS2_RC_SUCCESS) \ 641 return ret; \ 642 \ 643 ret = fn7(op7 src->m7, buffer, buffer_size, &local_offset); \ 644 \ 645 if (offset && ret == TSS2_RC_SUCCESS) { \ 646 *offset = local_offset; \ 647 } \ 648 return ret; \ 649 } 650 651 #define TPMS_UNMARSHAL_7(type, m1, fn1, m2, fn2, m3, fn3, m4, fn4, m5, fn5, m6, fn6, m7, fn7) \ 652 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 653 size_t *offset, type *dest) \ 654 { \ 655 TSS2_RC ret = TSS2_RC_SUCCESS; \ 656 size_t local_offset = 0; \ 657 \ 658 LOG_DEBUG(\ 659 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 660 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 661 \ 662 if (offset) { \ 663 local_offset = *offset; \ 664 } else if (!dest) { \ 665 return TSS2_MU_RC_BAD_REFERENCE; \ 666 } \ 667 \ 668 if (dest) \ 669 memset(dest, 0, sizeof(*dest)); \ 670 \ 671 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : NULL); \ 672 if (ret != TSS2_RC_SUCCESS) \ 673 return ret; \ 674 \ 675 ret = fn2(buffer, buffer_size, &local_offset, dest ? &dest->m2 : NULL); \ 676 if (ret != TSS2_RC_SUCCESS) \ 677 return ret; \ 678 \ 679 ret = fn3(buffer, buffer_size, &local_offset, dest ? &dest->m3 : NULL); \ 680 if (ret != TSS2_RC_SUCCESS) \ 681 return ret; \ 682 \ 683 ret = fn4(buffer, buffer_size, &local_offset, dest ? &dest->m4 : NULL); \ 684 if (ret != TSS2_RC_SUCCESS) \ 685 return ret; \ 686 \ 687 ret = fn5(buffer, buffer_size, &local_offset, dest ? &dest->m5 : NULL); \ 688 if (ret != TSS2_RC_SUCCESS) \ 689 return ret; \ 690 \ 691 ret = fn6(buffer, buffer_size, &local_offset, dest ? &dest->m6 : NULL); \ 692 if (ret != TSS2_RC_SUCCESS) \ 693 return ret; \ 694 \ 695 ret = fn7(buffer, buffer_size, &local_offset, dest ? &dest->m7 : NULL); \ 696 \ 697 if (offset && ret == TSS2_RC_SUCCESS) { \ 698 *offset = local_offset; \ 699 } \ 700 return ret; \ 701 } 702 703 #define TPMS_MARSHAL_7_U(type, m1, op1, fn1, m2, op2, fn2, m3, op3, fn3, \ 704 m4, op4, fn4, m5, op5, fn5, m6, op6, fn6, m7, op7, fn7) \ 705 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 706 size_t buffer_size, size_t *offset) \ 707 { \ 708 TSS2_RC ret = TSS2_RC_SUCCESS; \ 709 size_t local_offset = 0; \ 710 \ 711 if (!src) { \ 712 LOG_WARNING("src param is NULL"); \ 713 return TSS2_MU_RC_BAD_REFERENCE; \ 714 } \ 715 \ 716 if (offset) { \ 717 local_offset = *offset; \ 718 } else if (!buffer) { \ 719 return TSS2_MU_RC_BAD_REFERENCE; \ 720 } \ 721 \ 722 LOG_DEBUG(\ 723 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 724 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 725 \ 726 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 727 if (ret != TSS2_RC_SUCCESS) \ 728 return ret; \ 729 \ 730 ret = fn2(op2 src->m2, buffer, buffer_size, &local_offset); \ 731 if (ret != TSS2_RC_SUCCESS) \ 732 return ret; \ 733 \ 734 ret = fn3(op3 src->m3, buffer, buffer_size, &local_offset); \ 735 if (ret != TSS2_RC_SUCCESS) \ 736 return ret; \ 737 \ 738 ret = fn4(op4 src->m4, buffer, buffer_size, &local_offset); \ 739 if (ret != TSS2_RC_SUCCESS) \ 740 return ret; \ 741 \ 742 ret = fn5(op5 src->m5, buffer, buffer_size, &local_offset); \ 743 if (ret != TSS2_RC_SUCCESS) \ 744 return ret; \ 745 \ 746 ret = fn6(op6 src->m6, buffer, buffer_size, &local_offset); \ 747 if (ret != TSS2_RC_SUCCESS) \ 748 return ret; \ 749 \ 750 ret = fn7(op7 src->m7, src->m2, buffer, buffer_size, &local_offset); \ 751 \ 752 if (offset && ret == TSS2_RC_SUCCESS) { \ 753 *offset = local_offset; \ 754 } \ 755 return ret; \ 756 } 757 758 #define TPMS_UNMARSHAL_7_U(type, m1, fn1, m2, fn2, m3, fn3, m4, fn4, m5, fn5, m6, fn6, m7, fn7) \ 759 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 760 size_t *offset, type *dest) \ 761 { \ 762 TSS2_RC ret = TSS2_RC_SUCCESS; \ 763 size_t local_offset = 0; \ 764 \ 765 LOG_DEBUG(\ 766 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 767 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 768 \ 769 if (offset) { \ 770 local_offset = *offset; \ 771 } else if (!dest) { \ 772 return TSS2_MU_RC_BAD_REFERENCE; \ 773 } \ 774 \ 775 if (dest) \ 776 memset(dest, 0, sizeof(*dest)); \ 777 \ 778 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : NULL); \ 779 if (ret != TSS2_RC_SUCCESS) \ 780 return ret; \ 781 \ 782 ret = fn2(buffer, buffer_size, &local_offset, dest ? &dest->m2 : NULL); \ 783 if (ret != TSS2_RC_SUCCESS) \ 784 return ret; \ 785 \ 786 ret = fn3(buffer, buffer_size, &local_offset, dest ? &dest->m3 : NULL); \ 787 if (ret != TSS2_RC_SUCCESS) \ 788 return ret; \ 789 \ 790 ret = fn4(buffer, buffer_size, &local_offset, dest ? &dest->m4 : NULL); \ 791 if (ret != TSS2_RC_SUCCESS) \ 792 return ret; \ 793 \ 794 ret = fn5(buffer, buffer_size, &local_offset, dest ? &dest->m5 : NULL); \ 795 if (ret != TSS2_RC_SUCCESS) \ 796 return ret; \ 797 \ 798 ret = fn6(buffer, buffer_size, &local_offset, dest ? &dest->m6 : NULL); \ 799 if (ret != TSS2_RC_SUCCESS) \ 800 return ret; \ 801 \ 802 ret = fn7(buffer, buffer_size, &local_offset, dest ? dest->m2 : 0, dest ? &dest->m7 : NULL); \ 803 \ 804 if (offset && ret == TSS2_RC_SUCCESS) { \ 805 *offset = local_offset; \ 806 } \ 807 return ret; \ 808 } 809 810 #define TPMS_MARSHAL_11(type, m1, op1, fn1, m2, op2, fn2, m3, op3, fn3, \ 811 m4, op4, fn4, m5, op5, fn5, m6, op6, fn6, m7, op7, fn7, \ 812 m8, op8, fn8, m9, op9, fn9, m10, op10, fn10, m11, op11, fn11) \ 813 TSS2_RC Tss2_MU_##type##_Marshal(type const *src, uint8_t buffer[], \ 814 size_t buffer_size, size_t *offset) \ 815 { \ 816 TSS2_RC ret = TSS2_RC_SUCCESS; \ 817 size_t local_offset = 0; \ 818 \ 819 if (!src) { \ 820 LOG_WARNING("src param is NULL"); \ 821 return TSS2_MU_RC_BAD_REFERENCE; \ 822 } \ 823 \ 824 if (offset) { \ 825 local_offset = *offset; \ 826 } else if (!buffer) { \ 827 return TSS2_MU_RC_BAD_REFERENCE; \ 828 } \ 829 \ 830 LOG_DEBUG(\ 831 "Marshalling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 832 " at index 0x%zx", (uintptr_t)&src, (uintptr_t)buffer, offset?*offset:0xffff); \ 833 \ 834 ret = fn1(op1 src->m1, buffer, buffer_size, &local_offset); \ 835 if (ret != TSS2_RC_SUCCESS) \ 836 return ret; \ 837 \ 838 ret = fn2(op2 src->m2, buffer, buffer_size, &local_offset); \ 839 if (ret != TSS2_RC_SUCCESS) \ 840 return ret; \ 841 \ 842 ret = fn3(op3 src->m3, buffer, buffer_size, &local_offset); \ 843 if (ret != TSS2_RC_SUCCESS) \ 844 return ret; \ 845 \ 846 ret = fn4(op4 src->m4, buffer, buffer_size, &local_offset); \ 847 if (ret != TSS2_RC_SUCCESS) \ 848 return ret; \ 849 \ 850 ret = fn5(op5 src->m5, buffer, buffer_size, &local_offset); \ 851 if (ret != TSS2_RC_SUCCESS) \ 852 return ret; \ 853 \ 854 ret = fn6(op6 src->m6, buffer, buffer_size, &local_offset); \ 855 if (ret != TSS2_RC_SUCCESS) \ 856 return ret; \ 857 \ 858 ret = fn7(op7 src->m7, buffer, buffer_size, &local_offset); \ 859 if (ret != TSS2_RC_SUCCESS) \ 860 return ret; \ 861 \ 862 ret = fn8(op8 src->m8, buffer, buffer_size, &local_offset); \ 863 if (ret != TSS2_RC_SUCCESS) \ 864 return ret; \ 865 \ 866 ret = fn9(op9 src->m9, buffer, buffer_size, &local_offset); \ 867 if (ret != TSS2_RC_SUCCESS) \ 868 return ret; \ 869 \ 870 ret = fn10(op10 src->m10, buffer, buffer_size, &local_offset); \ 871 if (ret != TSS2_RC_SUCCESS) \ 872 return ret; \ 873 \ 874 ret = fn11(op11 src->m11, buffer, buffer_size, &local_offset); \ 875 \ 876 if (offset && ret == TSS2_RC_SUCCESS) { \ 877 *offset = local_offset; \ 878 } \ 879 return ret; \ 880 } 881 882 #define TPMS_UNMARSHAL_11(type, m1, fn1, m2, fn2, m3, fn3, m4, fn4, m5, fn5, m6, fn6, m7, fn7, \ 883 m8, fn8, m9, fn9, m10, fn10, m11, fn11) \ 884 TSS2_RC Tss2_MU_##type##_Unmarshal(uint8_t const buffer[], size_t buffer_size, \ 885 size_t *offset, type *dest) \ 886 { \ 887 TSS2_RC ret = TSS2_RC_SUCCESS; \ 888 size_t local_offset = 0; \ 889 \ 890 LOG_DEBUG(\ 891 "Unmarshaling " #type " from 0x%" PRIxPTR " to buffer 0x%" PRIxPTR \ 892 " at index 0x%zx", (uintptr_t)dest, (uintptr_t)buffer, offset?*offset:0xffff); \ 893 \ 894 if (offset) { \ 895 local_offset = *offset; \ 896 } else if (!dest) { \ 897 return TSS2_MU_RC_BAD_REFERENCE; \ 898 } \ 899 \ 900 if (dest) \ 901 memset(dest, 0, sizeof(*dest)); \ 902 \ 903 ret = fn1(buffer, buffer_size, &local_offset, dest ? &dest->m1 : NULL); \ 904 if (ret != TSS2_RC_SUCCESS) \ 905 return ret; \ 906 \ 907 ret = fn2(buffer, buffer_size, &local_offset, dest ? &dest->m2 : NULL); \ 908 if (ret != TSS2_RC_SUCCESS) \ 909 return ret; \ 910 \ 911 ret = fn3(buffer, buffer_size, &local_offset, dest ? &dest->m3 : NULL); \ 912 if (ret != TSS2_RC_SUCCESS) \ 913 return ret; \ 914 \ 915 ret = fn4(buffer, buffer_size, &local_offset, dest ? &dest->m4 : NULL); \ 916 if (ret != TSS2_RC_SUCCESS) \ 917 return ret; \ 918 \ 919 ret = fn5(buffer, buffer_size, &local_offset, dest ? &dest->m5 : NULL); \ 920 if (ret != TSS2_RC_SUCCESS) \ 921 return ret; \ 922 \ 923 ret = fn6(buffer, buffer_size, &local_offset, dest ? &dest->m6 : NULL); \ 924 if (ret != TSS2_RC_SUCCESS) \ 925 return ret; \ 926 \ 927 ret = fn7(buffer, buffer_size, &local_offset, dest ? &dest->m7 : NULL); \ 928 if (ret != TSS2_RC_SUCCESS) \ 929 return ret; \ 930 \ 931 ret = fn8(buffer, buffer_size, &local_offset, dest ? &dest->m8 : NULL); \ 932 if (ret != TSS2_RC_SUCCESS) \ 933 return ret; \ 934 \ 935 ret = fn9(buffer, buffer_size, &local_offset, dest ? &dest->m9 : NULL); \ 936 if (ret != TSS2_RC_SUCCESS) \ 937 return ret; \ 938 \ 939 ret = fn10(buffer, buffer_size, &local_offset, dest ? &dest->m10 : NULL); \ 940 if (ret != TSS2_RC_SUCCESS) \ 941 return ret; \ 942 \ 943 ret = fn11(buffer, buffer_size, &local_offset, dest ? &dest->m11 : NULL); \ 944 \ 945 if (offset && ret == TSS2_RC_SUCCESS) { \ 946 *offset = local_offset; \ 947 } \ 948 return ret; \ 949 } 950 951 /* 952 * These macros expand to (un)marshal functions for each of the TPMS types 953 * the specification part 2. 954 */ 955 TPMS_MARSHAL_2(TPMS_ALG_PROPERTY, 956 alg, VAL, Tss2_MU_UINT16_Marshal, 957 algProperties, VAL, Tss2_MU_TPMA_ALGORITHM_Marshal) 958 959 TPMS_UNMARSHAL_2(TPMS_ALG_PROPERTY, 960 alg, Tss2_MU_UINT16_Unmarshal, 961 algProperties, Tss2_MU_TPMA_ALGORITHM_Unmarshal) 962 963 TPMS_MARSHAL_2(TPMS_ALGORITHM_DESCRIPTION, 964 alg, VAL, Tss2_MU_UINT16_Marshal, 965 attributes, VAL, Tss2_MU_TPMA_ALGORITHM_Marshal) 966 967 TPMS_UNMARSHAL_2(TPMS_ALGORITHM_DESCRIPTION, 968 alg, Tss2_MU_UINT16_Unmarshal, 969 attributes, Tss2_MU_TPMA_ALGORITHM_Unmarshal) 970 971 TPMS_MARSHAL_2(TPMS_TAGGED_PROPERTY, 972 property, VAL, Tss2_MU_UINT32_Marshal, 973 value, VAL, Tss2_MU_UINT32_Marshal) 974 975 TPMS_UNMARSHAL_2(TPMS_TAGGED_PROPERTY, 976 property, Tss2_MU_UINT32_Unmarshal, 977 value, Tss2_MU_UINT32_Unmarshal) 978 979 TPMS_MARSHAL_2(TPMS_TAGGED_POLICY, 980 handle, VAL, Tss2_MU_UINT32_Marshal, 981 policyHash, ADDR, Tss2_MU_TPMT_HA_Marshal) 982 983 TPMS_UNMARSHAL_2(TPMS_TAGGED_POLICY, 984 handle, Tss2_MU_UINT32_Unmarshal, 985 policyHash, Tss2_MU_TPMT_HA_Unmarshal) 986 987 TPMS_MARSHAL_4(TPMS_CLOCK_INFO, 988 clock, VAL, Tss2_MU_UINT64_Marshal, 989 resetCount, VAL, Tss2_MU_UINT32_Marshal, 990 restartCount, VAL, Tss2_MU_UINT32_Marshal, 991 safe, VAL, Tss2_MU_UINT8_Marshal) 992 993 TPMS_UNMARSHAL_4(TPMS_CLOCK_INFO, 994 clock, Tss2_MU_UINT64_Unmarshal, 995 resetCount, Tss2_MU_UINT32_Unmarshal, 996 restartCount, Tss2_MU_UINT32_Unmarshal, 997 safe, Tss2_MU_UINT8_Unmarshal) 998 999 TPMS_MARSHAL_2(TPMS_TIME_INFO, 1000 time, VAL, Tss2_MU_UINT64_Marshal, 1001 clockInfo, ADDR, Tss2_MU_TPMS_CLOCK_INFO_Marshal) 1002 1003 TPMS_UNMARSHAL_2(TPMS_TIME_INFO, 1004 time, Tss2_MU_UINT64_Unmarshal, 1005 clockInfo, Tss2_MU_TPMS_CLOCK_INFO_Unmarshal) 1006 1007 TPMS_MARSHAL_2(TPMS_TIME_ATTEST_INFO, 1008 time, ADDR, Tss2_MU_TPMS_TIME_INFO_Marshal, 1009 firmwareVersion, VAL, Tss2_MU_UINT64_Marshal) 1010 1011 TPMS_UNMARSHAL_2(TPMS_TIME_ATTEST_INFO, 1012 time, Tss2_MU_TPMS_TIME_INFO_Unmarshal, 1013 firmwareVersion, Tss2_MU_UINT64_Unmarshal) 1014 1015 TPMS_MARSHAL_2(TPMS_CERTIFY_INFO, 1016 name, ADDR, Tss2_MU_TPM2B_NAME_Marshal, 1017 qualifiedName, ADDR, Tss2_MU_TPM2B_NAME_Marshal) 1018 1019 TPMS_UNMARSHAL_2(TPMS_CERTIFY_INFO, 1020 name, Tss2_MU_TPM2B_NAME_Unmarshal, 1021 qualifiedName, Tss2_MU_TPM2B_NAME_Unmarshal) 1022 1023 TPMS_MARSHAL_4(TPMS_COMMAND_AUDIT_INFO, 1024 auditCounter, VAL, Tss2_MU_UINT64_Marshal, 1025 digestAlg, VAL, Tss2_MU_UINT16_Marshal, 1026 auditDigest, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1027 commandDigest, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal) 1028 1029 TPMS_UNMARSHAL_4(TPMS_COMMAND_AUDIT_INFO, 1030 auditCounter, Tss2_MU_UINT64_Unmarshal, 1031 digestAlg, Tss2_MU_UINT16_Unmarshal, 1032 auditDigest, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1033 commandDigest, Tss2_MU_TPM2B_DIGEST_Unmarshal) 1034 1035 TPMS_MARSHAL_2(TPMS_SESSION_AUDIT_INFO, 1036 exclusiveSession, VAL, Tss2_MU_UINT8_Marshal, 1037 sessionDigest, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal) 1038 1039 TPMS_UNMARSHAL_2(TPMS_SESSION_AUDIT_INFO, 1040 exclusiveSession, Tss2_MU_UINT8_Unmarshal, 1041 sessionDigest, Tss2_MU_TPM2B_DIGEST_Unmarshal) 1042 1043 TPMS_MARSHAL_2(TPMS_CREATION_INFO, 1044 objectName, ADDR, Tss2_MU_TPM2B_NAME_Marshal, 1045 creationHash, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal) 1046 1047 TPMS_UNMARSHAL_2(TPMS_CREATION_INFO, 1048 objectName, Tss2_MU_TPM2B_NAME_Unmarshal, 1049 creationHash, Tss2_MU_TPM2B_DIGEST_Unmarshal) 1050 1051 TPMS_MARSHAL_3(TPMS_NV_CERTIFY_INFO, 1052 indexName, ADDR, Tss2_MU_TPM2B_NAME_Marshal, 1053 offset, VAL, Tss2_MU_UINT16_Marshal, 1054 nvContents, ADDR, Tss2_MU_TPM2B_MAX_NV_BUFFER_Marshal) 1055 1056 TPMS_UNMARSHAL_3(TPMS_NV_CERTIFY_INFO, 1057 indexName, Tss2_MU_TPM2B_NAME_Unmarshal, 1058 offset, Tss2_MU_UINT16_Unmarshal, 1059 nvContents, Tss2_MU_TPM2B_MAX_NV_BUFFER_Unmarshal) 1060 1061 TPMS_MARSHAL_4(TPMS_AUTH_COMMAND, 1062 sessionHandle, VAL, Tss2_MU_UINT32_Marshal, 1063 nonce, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1064 sessionAttributes, VAL, Tss2_MU_TPMA_SESSION_Marshal, 1065 hmac, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal) 1066 1067 TPMS_UNMARSHAL_4(TPMS_AUTH_COMMAND, 1068 sessionHandle, Tss2_MU_UINT32_Unmarshal, 1069 nonce, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1070 sessionAttributes, Tss2_MU_TPMA_SESSION_Unmarshal, 1071 hmac, Tss2_MU_TPM2B_DIGEST_Unmarshal) 1072 1073 TPMS_MARSHAL_3(TPMS_AUTH_RESPONSE, 1074 nonce, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1075 sessionAttributes, VAL, Tss2_MU_TPMA_SESSION_Marshal, 1076 hmac, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal) 1077 1078 TPMS_UNMARSHAL_3(TPMS_AUTH_RESPONSE, 1079 nonce, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1080 sessionAttributes, Tss2_MU_TPMA_SESSION_Unmarshal, 1081 hmac, Tss2_MU_TPM2B_DIGEST_Unmarshal) 1082 1083 TPMS_MARSHAL_2(TPMS_SENSITIVE_CREATE, 1084 userAuth, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1085 data, ADDR, Tss2_MU_TPM2B_SENSITIVE_DATA_Marshal) 1086 1087 TPMS_UNMARSHAL_2(TPMS_SENSITIVE_CREATE, 1088 userAuth, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1089 data, Tss2_MU_TPM2B_SENSITIVE_DATA_Unmarshal) 1090 1091 TPMS_MARSHAL_1(TPMS_SCHEME_HASH, 1092 hashAlg, VAL, Tss2_MU_UINT16_Marshal) 1093 1094 TPMS_UNMARSHAL_1(TPMS_SCHEME_HASH, 1095 hashAlg, Tss2_MU_UINT16_Unmarshal) 1096 1097 TPMS_MARSHAL_2(TPMS_SCHEME_ECDAA, 1098 hashAlg, VAL, Tss2_MU_UINT16_Marshal, 1099 count, VAL, Tss2_MU_UINT16_Marshal) 1100 1101 TPMS_UNMARSHAL_2(TPMS_SCHEME_ECDAA, 1102 hashAlg, Tss2_MU_UINT16_Unmarshal, 1103 count, Tss2_MU_UINT16_Unmarshal) 1104 1105 TPMS_MARSHAL_2(TPMS_SCHEME_XOR, 1106 hashAlg, VAL, Tss2_MU_UINT16_Marshal, 1107 kdf, VAL, Tss2_MU_UINT16_Marshal) 1108 1109 TPMS_UNMARSHAL_2(TPMS_SCHEME_XOR, 1110 hashAlg, Tss2_MU_UINT16_Unmarshal, 1111 kdf, Tss2_MU_UINT16_Unmarshal) 1112 1113 TPMS_MARSHAL_2(TPMS_ECC_POINT, 1114 x, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1115 y, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal) 1116 1117 TPMS_UNMARSHAL_2(TPMS_ECC_POINT, 1118 x, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1119 y, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal) 1120 1121 TPMS_MARSHAL_2(TPMS_SIGNATURE_RSA, 1122 hash, VAL, Tss2_MU_UINT16_Marshal, 1123 sig, ADDR, Tss2_MU_TPM2B_PUBLIC_KEY_RSA_Marshal) 1124 1125 TPMS_UNMARSHAL_2(TPMS_SIGNATURE_RSA, 1126 hash, Tss2_MU_UINT16_Unmarshal, 1127 sig, Tss2_MU_TPM2B_PUBLIC_KEY_RSA_Unmarshal) 1128 1129 TPMS_MARSHAL_3(TPMS_SIGNATURE_ECC, 1130 hash, VAL, Tss2_MU_UINT16_Marshal, 1131 signatureR, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1132 signatureS, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal) 1133 1134 TPMS_UNMARSHAL_3(TPMS_SIGNATURE_ECC, 1135 hash, Tss2_MU_UINT16_Unmarshal, 1136 signatureR, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1137 signatureS, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal) 1138 1139 TPMS_MARSHAL_2(TPMS_NV_PIN_COUNTER_PARAMETERS, 1140 pinCount, VAL, Tss2_MU_UINT32_Marshal, 1141 pinLimit, VAL, Tss2_MU_UINT32_Marshal) 1142 1143 TPMS_UNMARSHAL_2(TPMS_NV_PIN_COUNTER_PARAMETERS, 1144 pinCount, Tss2_MU_UINT32_Unmarshal, 1145 pinLimit, Tss2_MU_UINT32_Unmarshal) 1146 1147 TPMS_MARSHAL_5(TPMS_NV_PUBLIC, 1148 nvIndex, VAL, Tss2_MU_UINT32_Marshal, 1149 nameAlg, VAL, Tss2_MU_UINT16_Marshal, 1150 attributes, VAL, Tss2_MU_TPMA_NV_Marshal, 1151 authPolicy, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1152 dataSize, VAL, Tss2_MU_UINT16_Marshal) 1153 1154 TPMS_UNMARSHAL_5(TPMS_NV_PUBLIC, 1155 nvIndex, Tss2_MU_UINT32_Unmarshal, 1156 nameAlg, Tss2_MU_UINT16_Unmarshal, 1157 attributes, Tss2_MU_TPMA_NV_Unmarshal, 1158 authPolicy, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1159 dataSize, Tss2_MU_UINT16_Unmarshal) 1160 1161 TPMS_MARSHAL_2(TPMS_CONTEXT_DATA, 1162 integrity, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1163 encrypted, ADDR, Tss2_MU_TPM2B_CONTEXT_SENSITIVE_Marshal) 1164 1165 TPMS_UNMARSHAL_2(TPMS_CONTEXT_DATA, 1166 integrity, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1167 encrypted, Tss2_MU_TPM2B_CONTEXT_SENSITIVE_Unmarshal) 1168 1169 TPMS_MARSHAL_4(TPMS_CONTEXT, 1170 sequence, VAL, Tss2_MU_UINT64_Marshal, 1171 savedHandle, VAL, Tss2_MU_UINT32_Marshal, 1172 hierarchy, VAL, Tss2_MU_UINT32_Marshal, 1173 contextBlob, ADDR, Tss2_MU_TPM2B_CONTEXT_DATA_Marshal) 1174 1175 TPMS_UNMARSHAL_4(TPMS_CONTEXT, 1176 sequence, Tss2_MU_UINT64_Unmarshal, 1177 savedHandle, Tss2_MU_UINT32_Unmarshal, 1178 hierarchy, Tss2_MU_UINT32_Unmarshal, 1179 contextBlob, Tss2_MU_TPM2B_CONTEXT_DATA_Unmarshal) 1180 1181 TPMS_MARSHAL_2(TPMS_QUOTE_INFO, 1182 pcrSelect, ADDR, Tss2_MU_TPML_PCR_SELECTION_Marshal, 1183 pcrDigest, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal) 1184 1185 TPMS_UNMARSHAL_2(TPMS_QUOTE_INFO, 1186 pcrSelect, Tss2_MU_TPML_PCR_SELECTION_Unmarshal, 1187 pcrDigest, Tss2_MU_TPM2B_DIGEST_Unmarshal) 1188 1189 TPMS_MARSHAL_7(TPMS_CREATION_DATA, 1190 pcrSelect, ADDR, Tss2_MU_TPML_PCR_SELECTION_Marshal, 1191 pcrDigest, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1192 locality, VAL, Tss2_MU_TPMA_LOCALITY_Marshal, 1193 parentNameAlg, VAL, Tss2_MU_UINT16_Marshal, 1194 parentName, ADDR, Tss2_MU_TPM2B_NAME_Marshal, 1195 parentQualifiedName, ADDR, Tss2_MU_TPM2B_NAME_Marshal, 1196 outsideInfo, ADDR, Tss2_MU_TPM2B_DATA_Marshal) 1197 1198 TPMS_UNMARSHAL_7(TPMS_CREATION_DATA, 1199 pcrSelect, Tss2_MU_TPML_PCR_SELECTION_Unmarshal, 1200 pcrDigest, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1201 locality, Tss2_MU_TPMA_LOCALITY_Unmarshal, 1202 parentNameAlg, Tss2_MU_UINT16_Unmarshal, 1203 parentName, Tss2_MU_TPM2B_NAME_Unmarshal, 1204 parentQualifiedName, Tss2_MU_TPM2B_NAME_Unmarshal, 1205 outsideInfo, Tss2_MU_TPM2B_DATA_Unmarshal) 1206 1207 TPMS_MARSHAL_4(TPMS_ECC_PARMS, 1208 symmetric, ADDR, Tss2_MU_TPMT_SYM_DEF_OBJECT_Marshal, 1209 scheme, ADDR, Tss2_MU_TPMT_ECC_SCHEME_Marshal, 1210 curveID, VAL, Tss2_MU_UINT16_Marshal, 1211 kdf, ADDR, Tss2_MU_TPMT_KDF_SCHEME_Marshal) 1212 1213 TPMS_UNMARSHAL_4(TPMS_ECC_PARMS, 1214 symmetric, Tss2_MU_TPMT_SYM_DEF_OBJECT_Unmarshal, 1215 scheme, Tss2_MU_TPMT_ECC_SCHEME_Unmarshal, 1216 curveID, Tss2_MU_UINT16_Unmarshal, 1217 kdf, Tss2_MU_TPMT_KDF_SCHEME_Unmarshal) 1218 1219 TPMS_MARSHAL_7_U(TPMS_ATTEST, 1220 magic, VAL, Tss2_MU_UINT32_Marshal, 1221 type, VAL, Tss2_MU_TPM2_ST_Marshal, 1222 qualifiedSigner, ADDR, Tss2_MU_TPM2B_NAME_Marshal, 1223 extraData, ADDR, Tss2_MU_TPM2B_DATA_Marshal, 1224 clockInfo, ADDR, Tss2_MU_TPMS_CLOCK_INFO_Marshal, 1225 firmwareVersion, VAL, Tss2_MU_UINT64_Marshal, 1226 attested, ADDR, Tss2_MU_TPMU_ATTEST_Marshal) 1227 1228 TPMS_UNMARSHAL_7_U(TPMS_ATTEST, 1229 magic, Tss2_MU_UINT32_Unmarshal, 1230 type, Tss2_MU_TPM2_ST_Unmarshal, 1231 qualifiedSigner, Tss2_MU_TPM2B_NAME_Unmarshal, 1232 extraData, Tss2_MU_TPM2B_DATA_Unmarshal, 1233 clockInfo, Tss2_MU_TPMS_CLOCK_INFO_Unmarshal, 1234 firmwareVersion, Tss2_MU_UINT64_Unmarshal, 1235 attested, Tss2_MU_TPMU_ATTEST_Unmarshal) 1236 1237 TPMS_MARSHAL_11(TPMS_ALGORITHM_DETAIL_ECC, 1238 curveID, VAL, Tss2_MU_UINT16_Marshal, 1239 keySize, VAL, Tss2_MU_UINT16_Marshal, 1240 kdf, ADDR, Tss2_MU_TPMT_KDF_SCHEME_Marshal, 1241 sign, ADDR, Tss2_MU_TPMT_ECC_SCHEME_Marshal, 1242 p, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1243 a, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1244 b, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1245 gX, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1246 gY, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1247 n, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal, 1248 h, ADDR, Tss2_MU_TPM2B_ECC_PARAMETER_Marshal) 1249 1250 TPMS_UNMARSHAL_11(TPMS_ALGORITHM_DETAIL_ECC, 1251 curveID, Tss2_MU_UINT16_Unmarshal, 1252 keySize, Tss2_MU_UINT16_Unmarshal, 1253 kdf, Tss2_MU_TPMT_KDF_SCHEME_Unmarshal, 1254 sign, Tss2_MU_TPMT_ECC_SCHEME_Unmarshal, 1255 p, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1256 a, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1257 b, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1258 gX, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1259 gY, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1260 n, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal, 1261 h, Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal) 1262 1263 TPMS_MARSHAL_2_U(TPMS_CAPABILITY_DATA, 1264 capability, VAL, Tss2_MU_UINT32_Marshal, 1265 data, ADDR, Tss2_MU_TPMU_CAPABILITIES_Marshal) 1266 1267 TPMS_UNMARSHAL_2_U(TPMS_CAPABILITY_DATA, 1268 capability, Tss2_MU_UINT32_Unmarshal, 1269 data, Tss2_MU_TPMU_CAPABILITIES_Unmarshal) 1270 1271 TPMS_MARSHAL_1(TPMS_KEYEDHASH_PARMS, 1272 scheme, ADDR, Tss2_MU_TPMT_KEYEDHASH_SCHEME_Marshal) 1273 1274 TPMS_UNMARSHAL_1(TPMS_KEYEDHASH_PARMS, 1275 scheme, Tss2_MU_TPMT_KEYEDHASH_SCHEME_Unmarshal) 1276 1277 TPMS_MARSHAL_4(TPMS_RSA_PARMS, 1278 symmetric, ADDR, Tss2_MU_TPMT_SYM_DEF_OBJECT_Marshal, 1279 scheme, ADDR, Tss2_MU_TPMT_RSA_SCHEME_Marshal, 1280 keyBits, VAL, Tss2_MU_UINT16_Marshal, 1281 exponent, VAL, Tss2_MU_UINT32_Marshal) 1282 1283 TPMS_UNMARSHAL_4(TPMS_RSA_PARMS, 1284 symmetric, Tss2_MU_TPMT_SYM_DEF_OBJECT_Unmarshal, 1285 scheme, Tss2_MU_TPMT_RSA_SCHEME_Unmarshal, 1286 keyBits, Tss2_MU_UINT16_Unmarshal, 1287 exponent, Tss2_MU_UINT32_Unmarshal) 1288 1289 TPMS_MARSHAL_1(TPMS_SYMCIPHER_PARMS, 1290 sym, ADDR, Tss2_MU_TPMT_SYM_DEF_OBJECT_Marshal) 1291 1292 TPMS_UNMARSHAL_1(TPMS_SYMCIPHER_PARMS, 1293 sym, Tss2_MU_TPMT_SYM_DEF_OBJECT_Unmarshal) 1294 1295 TPMS_MARSHAL_0(TPMS_EMPTY); 1296 1297 TPMS_UNMARSHAL_0(TPMS_EMPTY); 1298 1299 TPMS_MARSHAL_2(TPMS_AC_OUTPUT, 1300 tag, VAL, Tss2_MU_UINT32_Marshal, 1301 data, VAL, Tss2_MU_UINT32_Marshal) 1302 1303 TPMS_UNMARSHAL_2(TPMS_AC_OUTPUT, 1304 tag, Tss2_MU_UINT32_Unmarshal, 1305 data, Tss2_MU_UINT32_Unmarshal) 1306 1307 TPMS_MARSHAL_2(TPMS_ID_OBJECT, 1308 integrityHMAC, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal, 1309 encIdentity, ADDR, Tss2_MU_TPM2B_DIGEST_Marshal) 1310 1311 TPMS_UNMARSHAL_2(TPMS_ID_OBJECT, 1312 integrityHMAC, Tss2_MU_TPM2B_DIGEST_Unmarshal, 1313 encIdentity, Tss2_MU_TPM2B_DIGEST_Unmarshal) 1314