1 // 2 // Copyright (C) 2015 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 // THIS CODE IS GENERATED - DO NOT MODIFY! 18 19 #include "trunks/tpm_generated.h" 20 21 #include <memory> 22 #include <string> 23 24 #include <base/bind.h> 25 #include <base/callback.h> 26 #include <base/logging.h> 27 #include <base/macros.h> 28 #include <base/stl_util.h> 29 #include <base/strings/string_number_conversions.h> 30 #include <base/sys_byteorder.h> 31 #include <crypto/secure_hash.h> 32 33 #include "trunks/authorization_delegate.h" 34 #include "trunks/command_transceiver.h" 35 #include "trunks/error_codes.h" 36 37 namespace trunks { 38 39 size_t GetNumberOfRequestHandles(TPM_CC command_code) { 40 switch (command_code) { 41 case TPM_CC_Startup: 42 return 0; 43 case TPM_CC_Shutdown: 44 return 0; 45 case TPM_CC_SelfTest: 46 return 0; 47 case TPM_CC_IncrementalSelfTest: 48 return 0; 49 case TPM_CC_GetTestResult: 50 return 0; 51 case TPM_CC_StartAuthSession: 52 return 2; 53 case TPM_CC_PolicyRestart: 54 return 1; 55 case TPM_CC_Create: 56 return 1; 57 case TPM_CC_Load: 58 return 1; 59 case TPM_CC_LoadExternal: 60 return 0; 61 case TPM_CC_ReadPublic: 62 return 1; 63 case TPM_CC_ActivateCredential: 64 return 2; 65 case TPM_CC_MakeCredential: 66 return 1; 67 case TPM_CC_Unseal: 68 return 1; 69 case TPM_CC_ObjectChangeAuth: 70 return 2; 71 case TPM_CC_Duplicate: 72 return 2; 73 case TPM_CC_Rewrap: 74 return 2; 75 case TPM_CC_Import: 76 return 1; 77 case TPM_CC_RSA_Encrypt: 78 return 1; 79 case TPM_CC_RSA_Decrypt: 80 return 1; 81 case TPM_CC_ECDH_KeyGen: 82 return 1; 83 case TPM_CC_ECDH_ZGen: 84 return 1; 85 case TPM_CC_ECC_Parameters: 86 return 0; 87 case TPM_CC_ZGen_2Phase: 88 return 1; 89 case TPM_CC_EncryptDecrypt: 90 return 1; 91 case TPM_CC_Hash: 92 return 0; 93 case TPM_CC_HMAC: 94 return 1; 95 case TPM_CC_GetRandom: 96 return 0; 97 case TPM_CC_StirRandom: 98 return 0; 99 case TPM_CC_HMAC_Start: 100 return 1; 101 case TPM_CC_HashSequenceStart: 102 return 0; 103 case TPM_CC_SequenceUpdate: 104 return 1; 105 case TPM_CC_SequenceComplete: 106 return 1; 107 case TPM_CC_EventSequenceComplete: 108 return 2; 109 case TPM_CC_Certify: 110 return 2; 111 case TPM_CC_CertifyCreation: 112 return 2; 113 case TPM_CC_Quote: 114 return 1; 115 case TPM_CC_GetSessionAuditDigest: 116 return 3; 117 case TPM_CC_GetCommandAuditDigest: 118 return 2; 119 case TPM_CC_GetTime: 120 return 2; 121 case TPM_CC_Commit: 122 return 1; 123 case TPM_CC_EC_Ephemeral: 124 return 0; 125 case TPM_CC_VerifySignature: 126 return 1; 127 case TPM_CC_Sign: 128 return 1; 129 case TPM_CC_SetCommandCodeAuditStatus: 130 return 1; 131 case TPM_CC_PCR_Extend: 132 return 1; 133 case TPM_CC_PCR_Event: 134 return 1; 135 case TPM_CC_PCR_Read: 136 return 0; 137 case TPM_CC_PCR_Allocate: 138 return 1; 139 case TPM_CC_PCR_SetAuthPolicy: 140 return 2; 141 case TPM_CC_PCR_SetAuthValue: 142 return 1; 143 case TPM_CC_PCR_Reset: 144 return 1; 145 case TPM_CC_PolicySigned: 146 return 2; 147 case TPM_CC_PolicySecret: 148 return 2; 149 case TPM_CC_PolicyTicket: 150 return 1; 151 case TPM_CC_PolicyOR: 152 return 1; 153 case TPM_CC_PolicyPCR: 154 return 1; 155 case TPM_CC_PolicyLocality: 156 return 1; 157 case TPM_CC_PolicyNV: 158 return 3; 159 case TPM_CC_PolicyCounterTimer: 160 return 1; 161 case TPM_CC_PolicyCommandCode: 162 return 1; 163 case TPM_CC_PolicyPhysicalPresence: 164 return 1; 165 case TPM_CC_PolicyCpHash: 166 return 1; 167 case TPM_CC_PolicyNameHash: 168 return 1; 169 case TPM_CC_PolicyDuplicationSelect: 170 return 1; 171 case TPM_CC_PolicyAuthorize: 172 return 1; 173 case TPM_CC_PolicyAuthValue: 174 return 1; 175 case TPM_CC_PolicyPassword: 176 return 1; 177 case TPM_CC_PolicyGetDigest: 178 return 1; 179 case TPM_CC_PolicyNvWritten: 180 return 1; 181 case TPM_CC_CreatePrimary: 182 return 1; 183 case TPM_CC_HierarchyControl: 184 return 1; 185 case TPM_CC_SetPrimaryPolicy: 186 return 1; 187 case TPM_CC_ChangePPS: 188 return 1; 189 case TPM_CC_ChangeEPS: 190 return 1; 191 case TPM_CC_Clear: 192 return 1; 193 case TPM_CC_ClearControl: 194 return 1; 195 case TPM_CC_HierarchyChangeAuth: 196 return 1; 197 case TPM_CC_DictionaryAttackLockReset: 198 return 1; 199 case TPM_CC_DictionaryAttackParameters: 200 return 1; 201 case TPM_CC_PP_Commands: 202 return 1; 203 case TPM_CC_SetAlgorithmSet: 204 return 1; 205 case TPM_CC_FieldUpgradeStart: 206 return 2; 207 case TPM_CC_FieldUpgradeData: 208 return 0; 209 case TPM_CC_FirmwareRead: 210 return 0; 211 case TPM_CC_ContextSave: 212 return 1; 213 case TPM_CC_ContextLoad: 214 return 0; 215 case TPM_CC_FlushContext: 216 return 0; 217 case TPM_CC_EvictControl: 218 return 2; 219 case TPM_CC_ReadClock: 220 return 0; 221 case TPM_CC_ClockSet: 222 return 1; 223 case TPM_CC_ClockRateAdjust: 224 return 1; 225 case TPM_CC_GetCapability: 226 return 0; 227 case TPM_CC_TestParms: 228 return 0; 229 case TPM_CC_NV_DefineSpace: 230 return 1; 231 case TPM_CC_NV_UndefineSpace: 232 return 2; 233 case TPM_CC_NV_UndefineSpaceSpecial: 234 return 2; 235 case TPM_CC_NV_ReadPublic: 236 return 1; 237 case TPM_CC_NV_Write: 238 return 2; 239 case TPM_CC_NV_Increment: 240 return 2; 241 case TPM_CC_NV_Extend: 242 return 2; 243 case TPM_CC_NV_SetBits: 244 return 2; 245 case TPM_CC_NV_WriteLock: 246 return 2; 247 case TPM_CC_NV_GlobalWriteLock: 248 return 1; 249 case TPM_CC_NV_Read: 250 return 2; 251 case TPM_CC_NV_ReadLock: 252 return 2; 253 case TPM_CC_NV_ChangeAuth: 254 return 1; 255 case TPM_CC_NV_Certify: 256 return 3; 257 default: 258 LOG(WARNING) << "Unknown command code: " << command_code; 259 } 260 return 0; 261 } 262 263 size_t GetNumberOfResponseHandles(TPM_CC command_code) { 264 switch (command_code) { 265 case TPM_CC_Startup: 266 return 0; 267 case TPM_CC_Shutdown: 268 return 0; 269 case TPM_CC_SelfTest: 270 return 0; 271 case TPM_CC_IncrementalSelfTest: 272 return 0; 273 case TPM_CC_GetTestResult: 274 return 0; 275 case TPM_CC_StartAuthSession: 276 return 1; 277 case TPM_CC_PolicyRestart: 278 return 0; 279 case TPM_CC_Create: 280 return 0; 281 case TPM_CC_Load: 282 return 1; 283 case TPM_CC_LoadExternal: 284 return 1; 285 case TPM_CC_ReadPublic: 286 return 0; 287 case TPM_CC_ActivateCredential: 288 return 0; 289 case TPM_CC_MakeCredential: 290 return 0; 291 case TPM_CC_Unseal: 292 return 0; 293 case TPM_CC_ObjectChangeAuth: 294 return 0; 295 case TPM_CC_Duplicate: 296 return 0; 297 case TPM_CC_Rewrap: 298 return 0; 299 case TPM_CC_Import: 300 return 0; 301 case TPM_CC_RSA_Encrypt: 302 return 0; 303 case TPM_CC_RSA_Decrypt: 304 return 0; 305 case TPM_CC_ECDH_KeyGen: 306 return 0; 307 case TPM_CC_ECDH_ZGen: 308 return 0; 309 case TPM_CC_ECC_Parameters: 310 return 0; 311 case TPM_CC_ZGen_2Phase: 312 return 0; 313 case TPM_CC_EncryptDecrypt: 314 return 0; 315 case TPM_CC_Hash: 316 return 0; 317 case TPM_CC_HMAC: 318 return 0; 319 case TPM_CC_GetRandom: 320 return 0; 321 case TPM_CC_StirRandom: 322 return 0; 323 case TPM_CC_HMAC_Start: 324 return 1; 325 case TPM_CC_HashSequenceStart: 326 return 1; 327 case TPM_CC_SequenceUpdate: 328 return 0; 329 case TPM_CC_SequenceComplete: 330 return 0; 331 case TPM_CC_EventSequenceComplete: 332 return 0; 333 case TPM_CC_Certify: 334 return 0; 335 case TPM_CC_CertifyCreation: 336 return 0; 337 case TPM_CC_Quote: 338 return 0; 339 case TPM_CC_GetSessionAuditDigest: 340 return 0; 341 case TPM_CC_GetCommandAuditDigest: 342 return 0; 343 case TPM_CC_GetTime: 344 return 0; 345 case TPM_CC_Commit: 346 return 0; 347 case TPM_CC_EC_Ephemeral: 348 return 0; 349 case TPM_CC_VerifySignature: 350 return 0; 351 case TPM_CC_Sign: 352 return 0; 353 case TPM_CC_SetCommandCodeAuditStatus: 354 return 0; 355 case TPM_CC_PCR_Extend: 356 return 0; 357 case TPM_CC_PCR_Event: 358 return 0; 359 case TPM_CC_PCR_Read: 360 return 0; 361 case TPM_CC_PCR_Allocate: 362 return 0; 363 case TPM_CC_PCR_SetAuthPolicy: 364 return 0; 365 case TPM_CC_PCR_SetAuthValue: 366 return 0; 367 case TPM_CC_PCR_Reset: 368 return 0; 369 case TPM_CC_PolicySigned: 370 return 0; 371 case TPM_CC_PolicySecret: 372 return 0; 373 case TPM_CC_PolicyTicket: 374 return 0; 375 case TPM_CC_PolicyOR: 376 return 0; 377 case TPM_CC_PolicyPCR: 378 return 0; 379 case TPM_CC_PolicyLocality: 380 return 0; 381 case TPM_CC_PolicyNV: 382 return 0; 383 case TPM_CC_PolicyCounterTimer: 384 return 0; 385 case TPM_CC_PolicyCommandCode: 386 return 0; 387 case TPM_CC_PolicyPhysicalPresence: 388 return 0; 389 case TPM_CC_PolicyCpHash: 390 return 0; 391 case TPM_CC_PolicyNameHash: 392 return 0; 393 case TPM_CC_PolicyDuplicationSelect: 394 return 0; 395 case TPM_CC_PolicyAuthorize: 396 return 0; 397 case TPM_CC_PolicyAuthValue: 398 return 0; 399 case TPM_CC_PolicyPassword: 400 return 0; 401 case TPM_CC_PolicyGetDigest: 402 return 0; 403 case TPM_CC_PolicyNvWritten: 404 return 0; 405 case TPM_CC_CreatePrimary: 406 return 1; 407 case TPM_CC_HierarchyControl: 408 return 0; 409 case TPM_CC_SetPrimaryPolicy: 410 return 0; 411 case TPM_CC_ChangePPS: 412 return 0; 413 case TPM_CC_ChangeEPS: 414 return 0; 415 case TPM_CC_Clear: 416 return 0; 417 case TPM_CC_ClearControl: 418 return 0; 419 case TPM_CC_HierarchyChangeAuth: 420 return 0; 421 case TPM_CC_DictionaryAttackLockReset: 422 return 0; 423 case TPM_CC_DictionaryAttackParameters: 424 return 0; 425 case TPM_CC_PP_Commands: 426 return 0; 427 case TPM_CC_SetAlgorithmSet: 428 return 0; 429 case TPM_CC_FieldUpgradeStart: 430 return 0; 431 case TPM_CC_FieldUpgradeData: 432 return 0; 433 case TPM_CC_FirmwareRead: 434 return 0; 435 case TPM_CC_ContextSave: 436 return 0; 437 case TPM_CC_ContextLoad: 438 return 1; 439 case TPM_CC_FlushContext: 440 return 0; 441 case TPM_CC_EvictControl: 442 return 0; 443 case TPM_CC_ReadClock: 444 return 0; 445 case TPM_CC_ClockSet: 446 return 0; 447 case TPM_CC_ClockRateAdjust: 448 return 0; 449 case TPM_CC_GetCapability: 450 return 0; 451 case TPM_CC_TestParms: 452 return 0; 453 case TPM_CC_NV_DefineSpace: 454 return 0; 455 case TPM_CC_NV_UndefineSpace: 456 return 0; 457 case TPM_CC_NV_UndefineSpaceSpecial: 458 return 0; 459 case TPM_CC_NV_ReadPublic: 460 return 0; 461 case TPM_CC_NV_Write: 462 return 0; 463 case TPM_CC_NV_Increment: 464 return 0; 465 case TPM_CC_NV_Extend: 466 return 0; 467 case TPM_CC_NV_SetBits: 468 return 0; 469 case TPM_CC_NV_WriteLock: 470 return 0; 471 case TPM_CC_NV_GlobalWriteLock: 472 return 0; 473 case TPM_CC_NV_Read: 474 return 0; 475 case TPM_CC_NV_ReadLock: 476 return 0; 477 case TPM_CC_NV_ChangeAuth: 478 return 0; 479 case TPM_CC_NV_Certify: 480 return 0; 481 default: 482 LOG(WARNING) << "Unknown command code: " << command_code; 483 } 484 return 0; 485 } 486 487 TPM_RC Serialize_uint8_t(const uint8_t& value, std::string* buffer) { 488 VLOG(3) << __func__; 489 uint8_t value_net = value; 490 switch (sizeof(uint8_t)) { 491 case 2: 492 value_net = base::HostToNet16(value); 493 break; 494 case 4: 495 value_net = base::HostToNet32(value); 496 break; 497 case 8: 498 value_net = base::HostToNet64(value); 499 break; 500 default: 501 break; 502 } 503 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 504 buffer->append(value_bytes, sizeof(uint8_t)); 505 return TPM_RC_SUCCESS; 506 } 507 508 TPM_RC Parse_uint8_t(std::string* buffer, 509 uint8_t* value, 510 std::string* value_bytes) { 511 VLOG(3) << __func__; 512 if (buffer->size() < sizeof(uint8_t)) 513 return TPM_RC_INSUFFICIENT; 514 uint8_t value_net = 0; 515 memcpy(&value_net, buffer->data(), sizeof(uint8_t)); 516 switch (sizeof(uint8_t)) { 517 case 2: 518 *value = base::NetToHost16(value_net); 519 break; 520 case 4: 521 *value = base::NetToHost32(value_net); 522 break; 523 case 8: 524 *value = base::NetToHost64(value_net); 525 break; 526 default: 527 *value = value_net; 528 } 529 if (value_bytes) { 530 value_bytes->append(buffer->substr(0, sizeof(uint8_t))); 531 } 532 buffer->erase(0, sizeof(uint8_t)); 533 return TPM_RC_SUCCESS; 534 } 535 536 TPM_RC Serialize_int8_t(const int8_t& value, std::string* buffer) { 537 VLOG(3) << __func__; 538 int8_t value_net = value; 539 switch (sizeof(int8_t)) { 540 case 2: 541 value_net = base::HostToNet16(value); 542 break; 543 case 4: 544 value_net = base::HostToNet32(value); 545 break; 546 case 8: 547 value_net = base::HostToNet64(value); 548 break; 549 default: 550 break; 551 } 552 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 553 buffer->append(value_bytes, sizeof(int8_t)); 554 return TPM_RC_SUCCESS; 555 } 556 557 TPM_RC Parse_int8_t(std::string* buffer, 558 int8_t* value, 559 std::string* value_bytes) { 560 VLOG(3) << __func__; 561 if (buffer->size() < sizeof(int8_t)) 562 return TPM_RC_INSUFFICIENT; 563 int8_t value_net = 0; 564 memcpy(&value_net, buffer->data(), sizeof(int8_t)); 565 switch (sizeof(int8_t)) { 566 case 2: 567 *value = base::NetToHost16(value_net); 568 break; 569 case 4: 570 *value = base::NetToHost32(value_net); 571 break; 572 case 8: 573 *value = base::NetToHost64(value_net); 574 break; 575 default: 576 *value = value_net; 577 } 578 if (value_bytes) { 579 value_bytes->append(buffer->substr(0, sizeof(int8_t))); 580 } 581 buffer->erase(0, sizeof(int8_t)); 582 return TPM_RC_SUCCESS; 583 } 584 585 TPM_RC Serialize_int(const int& value, std::string* buffer) { 586 VLOG(3) << __func__; 587 int value_net = value; 588 switch (sizeof(int)) { 589 case 2: 590 value_net = base::HostToNet16(value); 591 break; 592 case 4: 593 value_net = base::HostToNet32(value); 594 break; 595 case 8: 596 value_net = base::HostToNet64(value); 597 break; 598 default: 599 break; 600 } 601 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 602 buffer->append(value_bytes, sizeof(int)); 603 return TPM_RC_SUCCESS; 604 } 605 606 TPM_RC Parse_int(std::string* buffer, int* value, std::string* value_bytes) { 607 VLOG(3) << __func__; 608 if (buffer->size() < sizeof(int)) 609 return TPM_RC_INSUFFICIENT; 610 int value_net = 0; 611 memcpy(&value_net, buffer->data(), sizeof(int)); 612 switch (sizeof(int)) { 613 case 2: 614 *value = base::NetToHost16(value_net); 615 break; 616 case 4: 617 *value = base::NetToHost32(value_net); 618 break; 619 case 8: 620 *value = base::NetToHost64(value_net); 621 break; 622 default: 623 *value = value_net; 624 } 625 if (value_bytes) { 626 value_bytes->append(buffer->substr(0, sizeof(int))); 627 } 628 buffer->erase(0, sizeof(int)); 629 return TPM_RC_SUCCESS; 630 } 631 632 TPM_RC Serialize_uint16_t(const uint16_t& value, std::string* buffer) { 633 VLOG(3) << __func__; 634 uint16_t value_net = value; 635 switch (sizeof(uint16_t)) { 636 case 2: 637 value_net = base::HostToNet16(value); 638 break; 639 case 4: 640 value_net = base::HostToNet32(value); 641 break; 642 case 8: 643 value_net = base::HostToNet64(value); 644 break; 645 default: 646 break; 647 } 648 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 649 buffer->append(value_bytes, sizeof(uint16_t)); 650 return TPM_RC_SUCCESS; 651 } 652 653 TPM_RC Parse_uint16_t(std::string* buffer, 654 uint16_t* value, 655 std::string* value_bytes) { 656 VLOG(3) << __func__; 657 if (buffer->size() < sizeof(uint16_t)) 658 return TPM_RC_INSUFFICIENT; 659 uint16_t value_net = 0; 660 memcpy(&value_net, buffer->data(), sizeof(uint16_t)); 661 switch (sizeof(uint16_t)) { 662 case 2: 663 *value = base::NetToHost16(value_net); 664 break; 665 case 4: 666 *value = base::NetToHost32(value_net); 667 break; 668 case 8: 669 *value = base::NetToHost64(value_net); 670 break; 671 default: 672 *value = value_net; 673 } 674 if (value_bytes) { 675 value_bytes->append(buffer->substr(0, sizeof(uint16_t))); 676 } 677 buffer->erase(0, sizeof(uint16_t)); 678 return TPM_RC_SUCCESS; 679 } 680 681 TPM_RC Serialize_int16_t(const int16_t& value, std::string* buffer) { 682 VLOG(3) << __func__; 683 int16_t value_net = value; 684 switch (sizeof(int16_t)) { 685 case 2: 686 value_net = base::HostToNet16(value); 687 break; 688 case 4: 689 value_net = base::HostToNet32(value); 690 break; 691 case 8: 692 value_net = base::HostToNet64(value); 693 break; 694 default: 695 break; 696 } 697 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 698 buffer->append(value_bytes, sizeof(int16_t)); 699 return TPM_RC_SUCCESS; 700 } 701 702 TPM_RC Parse_int16_t(std::string* buffer, 703 int16_t* value, 704 std::string* value_bytes) { 705 VLOG(3) << __func__; 706 if (buffer->size() < sizeof(int16_t)) 707 return TPM_RC_INSUFFICIENT; 708 int16_t value_net = 0; 709 memcpy(&value_net, buffer->data(), sizeof(int16_t)); 710 switch (sizeof(int16_t)) { 711 case 2: 712 *value = base::NetToHost16(value_net); 713 break; 714 case 4: 715 *value = base::NetToHost32(value_net); 716 break; 717 case 8: 718 *value = base::NetToHost64(value_net); 719 break; 720 default: 721 *value = value_net; 722 } 723 if (value_bytes) { 724 value_bytes->append(buffer->substr(0, sizeof(int16_t))); 725 } 726 buffer->erase(0, sizeof(int16_t)); 727 return TPM_RC_SUCCESS; 728 } 729 730 TPM_RC Serialize_uint32_t(const uint32_t& value, std::string* buffer) { 731 VLOG(3) << __func__; 732 uint32_t value_net = value; 733 switch (sizeof(uint32_t)) { 734 case 2: 735 value_net = base::HostToNet16(value); 736 break; 737 case 4: 738 value_net = base::HostToNet32(value); 739 break; 740 case 8: 741 value_net = base::HostToNet64(value); 742 break; 743 default: 744 break; 745 } 746 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 747 buffer->append(value_bytes, sizeof(uint32_t)); 748 return TPM_RC_SUCCESS; 749 } 750 751 TPM_RC Parse_uint32_t(std::string* buffer, 752 uint32_t* value, 753 std::string* value_bytes) { 754 VLOG(3) << __func__; 755 if (buffer->size() < sizeof(uint32_t)) 756 return TPM_RC_INSUFFICIENT; 757 uint32_t value_net = 0; 758 memcpy(&value_net, buffer->data(), sizeof(uint32_t)); 759 switch (sizeof(uint32_t)) { 760 case 2: 761 *value = base::NetToHost16(value_net); 762 break; 763 case 4: 764 *value = base::NetToHost32(value_net); 765 break; 766 case 8: 767 *value = base::NetToHost64(value_net); 768 break; 769 default: 770 *value = value_net; 771 } 772 if (value_bytes) { 773 value_bytes->append(buffer->substr(0, sizeof(uint32_t))); 774 } 775 buffer->erase(0, sizeof(uint32_t)); 776 return TPM_RC_SUCCESS; 777 } 778 779 TPM_RC Serialize_int32_t(const int32_t& value, std::string* buffer) { 780 VLOG(3) << __func__; 781 int32_t value_net = value; 782 switch (sizeof(int32_t)) { 783 case 2: 784 value_net = base::HostToNet16(value); 785 break; 786 case 4: 787 value_net = base::HostToNet32(value); 788 break; 789 case 8: 790 value_net = base::HostToNet64(value); 791 break; 792 default: 793 break; 794 } 795 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 796 buffer->append(value_bytes, sizeof(int32_t)); 797 return TPM_RC_SUCCESS; 798 } 799 800 TPM_RC Parse_int32_t(std::string* buffer, 801 int32_t* value, 802 std::string* value_bytes) { 803 VLOG(3) << __func__; 804 if (buffer->size() < sizeof(int32_t)) 805 return TPM_RC_INSUFFICIENT; 806 int32_t value_net = 0; 807 memcpy(&value_net, buffer->data(), sizeof(int32_t)); 808 switch (sizeof(int32_t)) { 809 case 2: 810 *value = base::NetToHost16(value_net); 811 break; 812 case 4: 813 *value = base::NetToHost32(value_net); 814 break; 815 case 8: 816 *value = base::NetToHost64(value_net); 817 break; 818 default: 819 *value = value_net; 820 } 821 if (value_bytes) { 822 value_bytes->append(buffer->substr(0, sizeof(int32_t))); 823 } 824 buffer->erase(0, sizeof(int32_t)); 825 return TPM_RC_SUCCESS; 826 } 827 828 TPM_RC Serialize_uint64_t(const uint64_t& value, std::string* buffer) { 829 VLOG(3) << __func__; 830 uint64_t value_net = value; 831 switch (sizeof(uint64_t)) { 832 case 2: 833 value_net = base::HostToNet16(value); 834 break; 835 case 4: 836 value_net = base::HostToNet32(value); 837 break; 838 case 8: 839 value_net = base::HostToNet64(value); 840 break; 841 default: 842 break; 843 } 844 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 845 buffer->append(value_bytes, sizeof(uint64_t)); 846 return TPM_RC_SUCCESS; 847 } 848 849 TPM_RC Parse_uint64_t(std::string* buffer, 850 uint64_t* value, 851 std::string* value_bytes) { 852 VLOG(3) << __func__; 853 if (buffer->size() < sizeof(uint64_t)) 854 return TPM_RC_INSUFFICIENT; 855 uint64_t value_net = 0; 856 memcpy(&value_net, buffer->data(), sizeof(uint64_t)); 857 switch (sizeof(uint64_t)) { 858 case 2: 859 *value = base::NetToHost16(value_net); 860 break; 861 case 4: 862 *value = base::NetToHost32(value_net); 863 break; 864 case 8: 865 *value = base::NetToHost64(value_net); 866 break; 867 default: 868 *value = value_net; 869 } 870 if (value_bytes) { 871 value_bytes->append(buffer->substr(0, sizeof(uint64_t))); 872 } 873 buffer->erase(0, sizeof(uint64_t)); 874 return TPM_RC_SUCCESS; 875 } 876 877 TPM_RC Serialize_int64_t(const int64_t& value, std::string* buffer) { 878 VLOG(3) << __func__; 879 int64_t value_net = value; 880 switch (sizeof(int64_t)) { 881 case 2: 882 value_net = base::HostToNet16(value); 883 break; 884 case 4: 885 value_net = base::HostToNet32(value); 886 break; 887 case 8: 888 value_net = base::HostToNet64(value); 889 break; 890 default: 891 break; 892 } 893 const char* value_bytes = reinterpret_cast<const char*>(&value_net); 894 buffer->append(value_bytes, sizeof(int64_t)); 895 return TPM_RC_SUCCESS; 896 } 897 898 TPM_RC Parse_int64_t(std::string* buffer, 899 int64_t* value, 900 std::string* value_bytes) { 901 VLOG(3) << __func__; 902 if (buffer->size() < sizeof(int64_t)) 903 return TPM_RC_INSUFFICIENT; 904 int64_t value_net = 0; 905 memcpy(&value_net, buffer->data(), sizeof(int64_t)); 906 switch (sizeof(int64_t)) { 907 case 2: 908 *value = base::NetToHost16(value_net); 909 break; 910 case 4: 911 *value = base::NetToHost32(value_net); 912 break; 913 case 8: 914 *value = base::NetToHost64(value_net); 915 break; 916 default: 917 *value = value_net; 918 } 919 if (value_bytes) { 920 value_bytes->append(buffer->substr(0, sizeof(int64_t))); 921 } 922 buffer->erase(0, sizeof(int64_t)); 923 return TPM_RC_SUCCESS; 924 } 925 926 TPM_RC Serialize_UINT8(const UINT8& value, std::string* buffer) { 927 VLOG(3) << __func__; 928 return Serialize_uint8_t(value, buffer); 929 } 930 931 TPM_RC Parse_UINT8(std::string* buffer, 932 UINT8* value, 933 std::string* value_bytes) { 934 VLOG(3) << __func__; 935 return Parse_uint8_t(buffer, value, value_bytes); 936 } 937 938 TPM_RC Serialize_BYTE(const BYTE& value, std::string* buffer) { 939 VLOG(3) << __func__; 940 return Serialize_uint8_t(value, buffer); 941 } 942 943 TPM_RC Parse_BYTE(std::string* buffer, BYTE* value, std::string* value_bytes) { 944 VLOG(3) << __func__; 945 return Parse_uint8_t(buffer, value, value_bytes); 946 } 947 948 TPM_RC Serialize_INT8(const INT8& value, std::string* buffer) { 949 VLOG(3) << __func__; 950 return Serialize_int8_t(value, buffer); 951 } 952 953 TPM_RC Parse_INT8(std::string* buffer, INT8* value, std::string* value_bytes) { 954 VLOG(3) << __func__; 955 return Parse_int8_t(buffer, value, value_bytes); 956 } 957 958 TPM_RC Serialize_BOOL(const BOOL& value, std::string* buffer) { 959 VLOG(3) << __func__; 960 return Serialize_int(value, buffer); 961 } 962 963 TPM_RC Parse_BOOL(std::string* buffer, BOOL* value, std::string* value_bytes) { 964 VLOG(3) << __func__; 965 return Parse_int(buffer, value, value_bytes); 966 } 967 968 TPM_RC Serialize_UINT16(const UINT16& value, std::string* buffer) { 969 VLOG(3) << __func__; 970 return Serialize_uint16_t(value, buffer); 971 } 972 973 TPM_RC Parse_UINT16(std::string* buffer, 974 UINT16* value, 975 std::string* value_bytes) { 976 VLOG(3) << __func__; 977 return Parse_uint16_t(buffer, value, value_bytes); 978 } 979 980 TPM_RC Serialize_INT16(const INT16& value, std::string* buffer) { 981 VLOG(3) << __func__; 982 return Serialize_int16_t(value, buffer); 983 } 984 985 TPM_RC Parse_INT16(std::string* buffer, 986 INT16* value, 987 std::string* value_bytes) { 988 VLOG(3) << __func__; 989 return Parse_int16_t(buffer, value, value_bytes); 990 } 991 992 TPM_RC Serialize_UINT32(const UINT32& value, std::string* buffer) { 993 VLOG(3) << __func__; 994 return Serialize_uint32_t(value, buffer); 995 } 996 997 TPM_RC Parse_UINT32(std::string* buffer, 998 UINT32* value, 999 std::string* value_bytes) { 1000 VLOG(3) << __func__; 1001 return Parse_uint32_t(buffer, value, value_bytes); 1002 } 1003 1004 TPM_RC Serialize_INT32(const INT32& value, std::string* buffer) { 1005 VLOG(3) << __func__; 1006 return Serialize_int32_t(value, buffer); 1007 } 1008 1009 TPM_RC Parse_INT32(std::string* buffer, 1010 INT32* value, 1011 std::string* value_bytes) { 1012 VLOG(3) << __func__; 1013 return Parse_int32_t(buffer, value, value_bytes); 1014 } 1015 1016 TPM_RC Serialize_UINT64(const UINT64& value, std::string* buffer) { 1017 VLOG(3) << __func__; 1018 return Serialize_uint64_t(value, buffer); 1019 } 1020 1021 TPM_RC Parse_UINT64(std::string* buffer, 1022 UINT64* value, 1023 std::string* value_bytes) { 1024 VLOG(3) << __func__; 1025 return Parse_uint64_t(buffer, value, value_bytes); 1026 } 1027 1028 TPM_RC Serialize_INT64(const INT64& value, std::string* buffer) { 1029 VLOG(3) << __func__; 1030 return Serialize_int64_t(value, buffer); 1031 } 1032 1033 TPM_RC Parse_INT64(std::string* buffer, 1034 INT64* value, 1035 std::string* value_bytes) { 1036 VLOG(3) << __func__; 1037 return Parse_int64_t(buffer, value, value_bytes); 1038 } 1039 1040 TPM_RC Serialize_TPM_ALGORITHM_ID(const TPM_ALGORITHM_ID& value, 1041 std::string* buffer) { 1042 VLOG(3) << __func__; 1043 return Serialize_UINT32(value, buffer); 1044 } 1045 1046 TPM_RC Parse_TPM_ALGORITHM_ID(std::string* buffer, 1047 TPM_ALGORITHM_ID* value, 1048 std::string* value_bytes) { 1049 VLOG(3) << __func__; 1050 return Parse_UINT32(buffer, value, value_bytes); 1051 } 1052 1053 TPM_RC Serialize_TPM_MODIFIER_INDICATOR(const TPM_MODIFIER_INDICATOR& value, 1054 std::string* buffer) { 1055 VLOG(3) << __func__; 1056 return Serialize_UINT32(value, buffer); 1057 } 1058 1059 TPM_RC Parse_TPM_MODIFIER_INDICATOR(std::string* buffer, 1060 TPM_MODIFIER_INDICATOR* value, 1061 std::string* value_bytes) { 1062 VLOG(3) << __func__; 1063 return Parse_UINT32(buffer, value, value_bytes); 1064 } 1065 1066 TPM_RC Serialize_TPM_AUTHORIZATION_SIZE(const TPM_AUTHORIZATION_SIZE& value, 1067 std::string* buffer) { 1068 VLOG(3) << __func__; 1069 return Serialize_UINT32(value, buffer); 1070 } 1071 1072 TPM_RC Parse_TPM_AUTHORIZATION_SIZE(std::string* buffer, 1073 TPM_AUTHORIZATION_SIZE* value, 1074 std::string* value_bytes) { 1075 VLOG(3) << __func__; 1076 return Parse_UINT32(buffer, value, value_bytes); 1077 } 1078 1079 TPM_RC Serialize_TPM_PARAMETER_SIZE(const TPM_PARAMETER_SIZE& value, 1080 std::string* buffer) { 1081 VLOG(3) << __func__; 1082 return Serialize_UINT32(value, buffer); 1083 } 1084 1085 TPM_RC Parse_TPM_PARAMETER_SIZE(std::string* buffer, 1086 TPM_PARAMETER_SIZE* value, 1087 std::string* value_bytes) { 1088 VLOG(3) << __func__; 1089 return Parse_UINT32(buffer, value, value_bytes); 1090 } 1091 1092 TPM_RC Serialize_TPM_KEY_SIZE(const TPM_KEY_SIZE& value, std::string* buffer) { 1093 VLOG(3) << __func__; 1094 return Serialize_UINT16(value, buffer); 1095 } 1096 1097 TPM_RC Parse_TPM_KEY_SIZE(std::string* buffer, 1098 TPM_KEY_SIZE* value, 1099 std::string* value_bytes) { 1100 VLOG(3) << __func__; 1101 return Parse_UINT16(buffer, value, value_bytes); 1102 } 1103 1104 TPM_RC Serialize_TPM_KEY_BITS(const TPM_KEY_BITS& value, std::string* buffer) { 1105 VLOG(3) << __func__; 1106 return Serialize_UINT16(value, buffer); 1107 } 1108 1109 TPM_RC Parse_TPM_KEY_BITS(std::string* buffer, 1110 TPM_KEY_BITS* value, 1111 std::string* value_bytes) { 1112 VLOG(3) << __func__; 1113 return Parse_UINT16(buffer, value, value_bytes); 1114 } 1115 1116 TPM_RC Serialize_TPM_HANDLE(const TPM_HANDLE& value, std::string* buffer) { 1117 VLOG(3) << __func__; 1118 return Serialize_UINT32(value, buffer); 1119 } 1120 1121 TPM_RC Parse_TPM_HANDLE(std::string* buffer, 1122 TPM_HANDLE* value, 1123 std::string* value_bytes) { 1124 VLOG(3) << __func__; 1125 return Parse_UINT32(buffer, value, value_bytes); 1126 } 1127 1128 TPM_RC Serialize_TPM2B_DIGEST(const TPM2B_DIGEST& value, std::string* buffer) { 1129 TPM_RC result = TPM_RC_SUCCESS; 1130 VLOG(3) << __func__; 1131 1132 result = Serialize_UINT16(value.size, buffer); 1133 if (result) { 1134 return result; 1135 } 1136 1137 if (arraysize(value.buffer) < value.size) { 1138 return TPM_RC_INSUFFICIENT; 1139 } 1140 for (uint32_t i = 0; i < value.size; ++i) { 1141 result = Serialize_BYTE(value.buffer[i], buffer); 1142 if (result) { 1143 return result; 1144 } 1145 } 1146 return result; 1147 } 1148 1149 TPM_RC Parse_TPM2B_DIGEST(std::string* buffer, 1150 TPM2B_DIGEST* value, 1151 std::string* value_bytes) { 1152 TPM_RC result = TPM_RC_SUCCESS; 1153 VLOG(3) << __func__; 1154 1155 result = Parse_UINT16(buffer, &value->size, value_bytes); 1156 if (result) { 1157 return result; 1158 } 1159 1160 if (arraysize(value->buffer) < value->size) { 1161 return TPM_RC_INSUFFICIENT; 1162 } 1163 for (uint32_t i = 0; i < value->size; ++i) { 1164 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 1165 if (result) { 1166 return result; 1167 } 1168 } 1169 return result; 1170 } 1171 1172 TPM2B_DIGEST Make_TPM2B_DIGEST(const std::string& bytes) { 1173 TPM2B_DIGEST tpm2b; 1174 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 1175 memset(&tpm2b, 0, sizeof(TPM2B_DIGEST)); 1176 tpm2b.size = bytes.size(); 1177 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 1178 return tpm2b; 1179 } 1180 1181 std::string StringFrom_TPM2B_DIGEST(const TPM2B_DIGEST& tpm2b) { 1182 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 1183 return std::string(char_buffer, tpm2b.size); 1184 } 1185 1186 TPM_RC Serialize_TPM2B_NONCE(const TPM2B_NONCE& value, std::string* buffer) { 1187 VLOG(3) << __func__; 1188 return Serialize_TPM2B_DIGEST(value, buffer); 1189 } 1190 1191 TPM_RC Parse_TPM2B_NONCE(std::string* buffer, 1192 TPM2B_NONCE* value, 1193 std::string* value_bytes) { 1194 VLOG(3) << __func__; 1195 return Parse_TPM2B_DIGEST(buffer, value, value_bytes); 1196 } 1197 1198 TPM_RC Serialize_TPM2B_AUTH(const TPM2B_AUTH& value, std::string* buffer) { 1199 VLOG(3) << __func__; 1200 return Serialize_TPM2B_DIGEST(value, buffer); 1201 } 1202 1203 TPM_RC Parse_TPM2B_AUTH(std::string* buffer, 1204 TPM2B_AUTH* value, 1205 std::string* value_bytes) { 1206 VLOG(3) << __func__; 1207 return Parse_TPM2B_DIGEST(buffer, value, value_bytes); 1208 } 1209 1210 TPM_RC Serialize_TPM2B_OPERAND(const TPM2B_OPERAND& value, 1211 std::string* buffer) { 1212 VLOG(3) << __func__; 1213 return Serialize_TPM2B_DIGEST(value, buffer); 1214 } 1215 1216 TPM_RC Parse_TPM2B_OPERAND(std::string* buffer, 1217 TPM2B_OPERAND* value, 1218 std::string* value_bytes) { 1219 VLOG(3) << __func__; 1220 return Parse_TPM2B_DIGEST(buffer, value, value_bytes); 1221 } 1222 1223 TPM_RC Serialize_TPM_ALG_ID(const TPM_ALG_ID& value, std::string* buffer) { 1224 VLOG(3) << __func__; 1225 return Serialize_UINT16(value, buffer); 1226 } 1227 1228 TPM_RC Parse_TPM_ALG_ID(std::string* buffer, 1229 TPM_ALG_ID* value, 1230 std::string* value_bytes) { 1231 VLOG(3) << __func__; 1232 return Parse_UINT16(buffer, value, value_bytes); 1233 } 1234 1235 TPM_RC Serialize_TPMI_ALG_HASH(const TPMI_ALG_HASH& value, 1236 std::string* buffer) { 1237 VLOG(3) << __func__; 1238 return Serialize_TPM_ALG_ID(value, buffer); 1239 } 1240 1241 TPM_RC Parse_TPMI_ALG_HASH(std::string* buffer, 1242 TPMI_ALG_HASH* value, 1243 std::string* value_bytes) { 1244 VLOG(3) << __func__; 1245 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1246 } 1247 1248 TPM_RC Serialize_TPMS_SCHEME_SIGHASH(const TPMS_SCHEME_SIGHASH& value, 1249 std::string* buffer) { 1250 TPM_RC result = TPM_RC_SUCCESS; 1251 VLOG(3) << __func__; 1252 1253 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 1254 if (result) { 1255 return result; 1256 } 1257 return result; 1258 } 1259 1260 TPM_RC Parse_TPMS_SCHEME_SIGHASH(std::string* buffer, 1261 TPMS_SCHEME_SIGHASH* value, 1262 std::string* value_bytes) { 1263 TPM_RC result = TPM_RC_SUCCESS; 1264 VLOG(3) << __func__; 1265 1266 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 1267 if (result) { 1268 return result; 1269 } 1270 return result; 1271 } 1272 1273 TPM_RC Serialize_TPMS_SCHEME_HMAC(const TPMS_SCHEME_HMAC& value, 1274 std::string* buffer) { 1275 VLOG(3) << __func__; 1276 return Serialize_TPMS_SCHEME_SIGHASH(value, buffer); 1277 } 1278 1279 TPM_RC Parse_TPMS_SCHEME_HMAC(std::string* buffer, 1280 TPMS_SCHEME_HMAC* value, 1281 std::string* value_bytes) { 1282 VLOG(3) << __func__; 1283 return Parse_TPMS_SCHEME_SIGHASH(buffer, value, value_bytes); 1284 } 1285 1286 TPM_RC Serialize_TPMS_SCHEME_RSASSA(const TPMS_SCHEME_RSASSA& value, 1287 std::string* buffer) { 1288 VLOG(3) << __func__; 1289 return Serialize_TPMS_SCHEME_SIGHASH(value, buffer); 1290 } 1291 1292 TPM_RC Parse_TPMS_SCHEME_RSASSA(std::string* buffer, 1293 TPMS_SCHEME_RSASSA* value, 1294 std::string* value_bytes) { 1295 VLOG(3) << __func__; 1296 return Parse_TPMS_SCHEME_SIGHASH(buffer, value, value_bytes); 1297 } 1298 1299 TPM_RC Serialize_TPMS_SCHEME_RSAPSS(const TPMS_SCHEME_RSAPSS& value, 1300 std::string* buffer) { 1301 VLOG(3) << __func__; 1302 return Serialize_TPMS_SCHEME_SIGHASH(value, buffer); 1303 } 1304 1305 TPM_RC Parse_TPMS_SCHEME_RSAPSS(std::string* buffer, 1306 TPMS_SCHEME_RSAPSS* value, 1307 std::string* value_bytes) { 1308 VLOG(3) << __func__; 1309 return Parse_TPMS_SCHEME_SIGHASH(buffer, value, value_bytes); 1310 } 1311 1312 TPM_RC Serialize_TPMS_SCHEME_ECDSA(const TPMS_SCHEME_ECDSA& value, 1313 std::string* buffer) { 1314 VLOG(3) << __func__; 1315 return Serialize_TPMS_SCHEME_SIGHASH(value, buffer); 1316 } 1317 1318 TPM_RC Parse_TPMS_SCHEME_ECDSA(std::string* buffer, 1319 TPMS_SCHEME_ECDSA* value, 1320 std::string* value_bytes) { 1321 VLOG(3) << __func__; 1322 return Parse_TPMS_SCHEME_SIGHASH(buffer, value, value_bytes); 1323 } 1324 1325 TPM_RC Serialize_TPMS_SCHEME_SM2(const TPMS_SCHEME_SM2& value, 1326 std::string* buffer) { 1327 VLOG(3) << __func__; 1328 return Serialize_TPMS_SCHEME_SIGHASH(value, buffer); 1329 } 1330 1331 TPM_RC Parse_TPMS_SCHEME_SM2(std::string* buffer, 1332 TPMS_SCHEME_SM2* value, 1333 std::string* value_bytes) { 1334 VLOG(3) << __func__; 1335 return Parse_TPMS_SCHEME_SIGHASH(buffer, value, value_bytes); 1336 } 1337 1338 TPM_RC Serialize_TPMS_SCHEME_ECSCHNORR(const TPMS_SCHEME_ECSCHNORR& value, 1339 std::string* buffer) { 1340 VLOG(3) << __func__; 1341 return Serialize_TPMS_SCHEME_SIGHASH(value, buffer); 1342 } 1343 1344 TPM_RC Parse_TPMS_SCHEME_ECSCHNORR(std::string* buffer, 1345 TPMS_SCHEME_ECSCHNORR* value, 1346 std::string* value_bytes) { 1347 VLOG(3) << __func__; 1348 return Parse_TPMS_SCHEME_SIGHASH(buffer, value, value_bytes); 1349 } 1350 1351 TPM_RC Serialize_TPMI_YES_NO(const TPMI_YES_NO& value, std::string* buffer) { 1352 VLOG(3) << __func__; 1353 return Serialize_BYTE(value, buffer); 1354 } 1355 1356 TPM_RC Parse_TPMI_YES_NO(std::string* buffer, 1357 TPMI_YES_NO* value, 1358 std::string* value_bytes) { 1359 VLOG(3) << __func__; 1360 return Parse_BYTE(buffer, value, value_bytes); 1361 } 1362 1363 TPM_RC Serialize_TPMI_DH_OBJECT(const TPMI_DH_OBJECT& value, 1364 std::string* buffer) { 1365 VLOG(3) << __func__; 1366 return Serialize_TPM_HANDLE(value, buffer); 1367 } 1368 1369 TPM_RC Parse_TPMI_DH_OBJECT(std::string* buffer, 1370 TPMI_DH_OBJECT* value, 1371 std::string* value_bytes) { 1372 VLOG(3) << __func__; 1373 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1374 } 1375 1376 TPM_RC Serialize_TPMI_DH_PERSISTENT(const TPMI_DH_PERSISTENT& value, 1377 std::string* buffer) { 1378 VLOG(3) << __func__; 1379 return Serialize_TPM_HANDLE(value, buffer); 1380 } 1381 1382 TPM_RC Parse_TPMI_DH_PERSISTENT(std::string* buffer, 1383 TPMI_DH_PERSISTENT* value, 1384 std::string* value_bytes) { 1385 VLOG(3) << __func__; 1386 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1387 } 1388 1389 TPM_RC Serialize_TPMI_DH_ENTITY(const TPMI_DH_ENTITY& value, 1390 std::string* buffer) { 1391 VLOG(3) << __func__; 1392 return Serialize_TPM_HANDLE(value, buffer); 1393 } 1394 1395 TPM_RC Parse_TPMI_DH_ENTITY(std::string* buffer, 1396 TPMI_DH_ENTITY* value, 1397 std::string* value_bytes) { 1398 VLOG(3) << __func__; 1399 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1400 } 1401 1402 TPM_RC Serialize_TPMI_DH_PCR(const TPMI_DH_PCR& value, std::string* buffer) { 1403 VLOG(3) << __func__; 1404 return Serialize_TPM_HANDLE(value, buffer); 1405 } 1406 1407 TPM_RC Parse_TPMI_DH_PCR(std::string* buffer, 1408 TPMI_DH_PCR* value, 1409 std::string* value_bytes) { 1410 VLOG(3) << __func__; 1411 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1412 } 1413 1414 TPM_RC Serialize_TPMI_SH_AUTH_SESSION(const TPMI_SH_AUTH_SESSION& value, 1415 std::string* buffer) { 1416 VLOG(3) << __func__; 1417 return Serialize_TPM_HANDLE(value, buffer); 1418 } 1419 1420 TPM_RC Parse_TPMI_SH_AUTH_SESSION(std::string* buffer, 1421 TPMI_SH_AUTH_SESSION* value, 1422 std::string* value_bytes) { 1423 VLOG(3) << __func__; 1424 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1425 } 1426 1427 TPM_RC Serialize_TPMI_SH_HMAC(const TPMI_SH_HMAC& value, std::string* buffer) { 1428 VLOG(3) << __func__; 1429 return Serialize_TPM_HANDLE(value, buffer); 1430 } 1431 1432 TPM_RC Parse_TPMI_SH_HMAC(std::string* buffer, 1433 TPMI_SH_HMAC* value, 1434 std::string* value_bytes) { 1435 VLOG(3) << __func__; 1436 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1437 } 1438 1439 TPM_RC Serialize_TPMI_SH_POLICY(const TPMI_SH_POLICY& value, 1440 std::string* buffer) { 1441 VLOG(3) << __func__; 1442 return Serialize_TPM_HANDLE(value, buffer); 1443 } 1444 1445 TPM_RC Parse_TPMI_SH_POLICY(std::string* buffer, 1446 TPMI_SH_POLICY* value, 1447 std::string* value_bytes) { 1448 VLOG(3) << __func__; 1449 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1450 } 1451 1452 TPM_RC Serialize_TPMI_DH_CONTEXT(const TPMI_DH_CONTEXT& value, 1453 std::string* buffer) { 1454 VLOG(3) << __func__; 1455 return Serialize_TPM_HANDLE(value, buffer); 1456 } 1457 1458 TPM_RC Parse_TPMI_DH_CONTEXT(std::string* buffer, 1459 TPMI_DH_CONTEXT* value, 1460 std::string* value_bytes) { 1461 VLOG(3) << __func__; 1462 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1463 } 1464 1465 TPM_RC Serialize_TPMI_RH_HIERARCHY(const TPMI_RH_HIERARCHY& value, 1466 std::string* buffer) { 1467 VLOG(3) << __func__; 1468 return Serialize_TPM_HANDLE(value, buffer); 1469 } 1470 1471 TPM_RC Parse_TPMI_RH_HIERARCHY(std::string* buffer, 1472 TPMI_RH_HIERARCHY* value, 1473 std::string* value_bytes) { 1474 VLOG(3) << __func__; 1475 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1476 } 1477 1478 TPM_RC Serialize_TPMI_RH_ENABLES(const TPMI_RH_ENABLES& value, 1479 std::string* buffer) { 1480 VLOG(3) << __func__; 1481 return Serialize_TPM_HANDLE(value, buffer); 1482 } 1483 1484 TPM_RC Parse_TPMI_RH_ENABLES(std::string* buffer, 1485 TPMI_RH_ENABLES* value, 1486 std::string* value_bytes) { 1487 VLOG(3) << __func__; 1488 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1489 } 1490 1491 TPM_RC Serialize_TPMI_RH_HIERARCHY_AUTH(const TPMI_RH_HIERARCHY_AUTH& value, 1492 std::string* buffer) { 1493 VLOG(3) << __func__; 1494 return Serialize_TPM_HANDLE(value, buffer); 1495 } 1496 1497 TPM_RC Parse_TPMI_RH_HIERARCHY_AUTH(std::string* buffer, 1498 TPMI_RH_HIERARCHY_AUTH* value, 1499 std::string* value_bytes) { 1500 VLOG(3) << __func__; 1501 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1502 } 1503 1504 TPM_RC Serialize_TPMI_RH_PLATFORM(const TPMI_RH_PLATFORM& value, 1505 std::string* buffer) { 1506 VLOG(3) << __func__; 1507 return Serialize_TPM_HANDLE(value, buffer); 1508 } 1509 1510 TPM_RC Parse_TPMI_RH_PLATFORM(std::string* buffer, 1511 TPMI_RH_PLATFORM* value, 1512 std::string* value_bytes) { 1513 VLOG(3) << __func__; 1514 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1515 } 1516 1517 TPM_RC Serialize_TPMI_RH_OWNER(const TPMI_RH_OWNER& value, 1518 std::string* buffer) { 1519 VLOG(3) << __func__; 1520 return Serialize_TPM_HANDLE(value, buffer); 1521 } 1522 1523 TPM_RC Parse_TPMI_RH_OWNER(std::string* buffer, 1524 TPMI_RH_OWNER* value, 1525 std::string* value_bytes) { 1526 VLOG(3) << __func__; 1527 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1528 } 1529 1530 TPM_RC Serialize_TPMI_RH_ENDORSEMENT(const TPMI_RH_ENDORSEMENT& value, 1531 std::string* buffer) { 1532 VLOG(3) << __func__; 1533 return Serialize_TPM_HANDLE(value, buffer); 1534 } 1535 1536 TPM_RC Parse_TPMI_RH_ENDORSEMENT(std::string* buffer, 1537 TPMI_RH_ENDORSEMENT* value, 1538 std::string* value_bytes) { 1539 VLOG(3) << __func__; 1540 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1541 } 1542 1543 TPM_RC Serialize_TPMI_RH_PROVISION(const TPMI_RH_PROVISION& value, 1544 std::string* buffer) { 1545 VLOG(3) << __func__; 1546 return Serialize_TPM_HANDLE(value, buffer); 1547 } 1548 1549 TPM_RC Parse_TPMI_RH_PROVISION(std::string* buffer, 1550 TPMI_RH_PROVISION* value, 1551 std::string* value_bytes) { 1552 VLOG(3) << __func__; 1553 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1554 } 1555 1556 TPM_RC Serialize_TPMI_RH_CLEAR(const TPMI_RH_CLEAR& value, 1557 std::string* buffer) { 1558 VLOG(3) << __func__; 1559 return Serialize_TPM_HANDLE(value, buffer); 1560 } 1561 1562 TPM_RC Parse_TPMI_RH_CLEAR(std::string* buffer, 1563 TPMI_RH_CLEAR* value, 1564 std::string* value_bytes) { 1565 VLOG(3) << __func__; 1566 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1567 } 1568 1569 TPM_RC Serialize_TPMI_RH_NV_AUTH(const TPMI_RH_NV_AUTH& value, 1570 std::string* buffer) { 1571 VLOG(3) << __func__; 1572 return Serialize_TPM_HANDLE(value, buffer); 1573 } 1574 1575 TPM_RC Parse_TPMI_RH_NV_AUTH(std::string* buffer, 1576 TPMI_RH_NV_AUTH* value, 1577 std::string* value_bytes) { 1578 VLOG(3) << __func__; 1579 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1580 } 1581 1582 TPM_RC Serialize_TPMI_RH_LOCKOUT(const TPMI_RH_LOCKOUT& value, 1583 std::string* buffer) { 1584 VLOG(3) << __func__; 1585 return Serialize_TPM_HANDLE(value, buffer); 1586 } 1587 1588 TPM_RC Parse_TPMI_RH_LOCKOUT(std::string* buffer, 1589 TPMI_RH_LOCKOUT* value, 1590 std::string* value_bytes) { 1591 VLOG(3) << __func__; 1592 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1593 } 1594 1595 TPM_RC Serialize_TPMI_RH_NV_INDEX(const TPMI_RH_NV_INDEX& value, 1596 std::string* buffer) { 1597 VLOG(3) << __func__; 1598 return Serialize_TPM_HANDLE(value, buffer); 1599 } 1600 1601 TPM_RC Parse_TPMI_RH_NV_INDEX(std::string* buffer, 1602 TPMI_RH_NV_INDEX* value, 1603 std::string* value_bytes) { 1604 VLOG(3) << __func__; 1605 return Parse_TPM_HANDLE(buffer, value, value_bytes); 1606 } 1607 1608 TPM_RC Serialize_TPMI_ALG_ASYM(const TPMI_ALG_ASYM& value, 1609 std::string* buffer) { 1610 VLOG(3) << __func__; 1611 return Serialize_TPM_ALG_ID(value, buffer); 1612 } 1613 1614 TPM_RC Parse_TPMI_ALG_ASYM(std::string* buffer, 1615 TPMI_ALG_ASYM* value, 1616 std::string* value_bytes) { 1617 VLOG(3) << __func__; 1618 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1619 } 1620 1621 TPM_RC Serialize_TPMI_ALG_SYM(const TPMI_ALG_SYM& value, std::string* buffer) { 1622 VLOG(3) << __func__; 1623 return Serialize_TPM_ALG_ID(value, buffer); 1624 } 1625 1626 TPM_RC Parse_TPMI_ALG_SYM(std::string* buffer, 1627 TPMI_ALG_SYM* value, 1628 std::string* value_bytes) { 1629 VLOG(3) << __func__; 1630 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1631 } 1632 1633 TPM_RC Serialize_TPMI_ALG_SYM_OBJECT(const TPMI_ALG_SYM_OBJECT& value, 1634 std::string* buffer) { 1635 VLOG(3) << __func__; 1636 return Serialize_TPM_ALG_ID(value, buffer); 1637 } 1638 1639 TPM_RC Parse_TPMI_ALG_SYM_OBJECT(std::string* buffer, 1640 TPMI_ALG_SYM_OBJECT* value, 1641 std::string* value_bytes) { 1642 VLOG(3) << __func__; 1643 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1644 } 1645 1646 TPM_RC Serialize_TPMI_ALG_SYM_MODE(const TPMI_ALG_SYM_MODE& value, 1647 std::string* buffer) { 1648 VLOG(3) << __func__; 1649 return Serialize_TPM_ALG_ID(value, buffer); 1650 } 1651 1652 TPM_RC Parse_TPMI_ALG_SYM_MODE(std::string* buffer, 1653 TPMI_ALG_SYM_MODE* value, 1654 std::string* value_bytes) { 1655 VLOG(3) << __func__; 1656 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1657 } 1658 1659 TPM_RC Serialize_TPMI_ALG_KDF(const TPMI_ALG_KDF& value, std::string* buffer) { 1660 VLOG(3) << __func__; 1661 return Serialize_TPM_ALG_ID(value, buffer); 1662 } 1663 1664 TPM_RC Parse_TPMI_ALG_KDF(std::string* buffer, 1665 TPMI_ALG_KDF* value, 1666 std::string* value_bytes) { 1667 VLOG(3) << __func__; 1668 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1669 } 1670 1671 TPM_RC Serialize_TPMI_ALG_SIG_SCHEME(const TPMI_ALG_SIG_SCHEME& value, 1672 std::string* buffer) { 1673 VLOG(3) << __func__; 1674 return Serialize_TPM_ALG_ID(value, buffer); 1675 } 1676 1677 TPM_RC Parse_TPMI_ALG_SIG_SCHEME(std::string* buffer, 1678 TPMI_ALG_SIG_SCHEME* value, 1679 std::string* value_bytes) { 1680 VLOG(3) << __func__; 1681 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1682 } 1683 1684 TPM_RC Serialize_TPMI_ECC_KEY_EXCHANGE(const TPMI_ECC_KEY_EXCHANGE& value, 1685 std::string* buffer) { 1686 VLOG(3) << __func__; 1687 return Serialize_TPM_ALG_ID(value, buffer); 1688 } 1689 1690 TPM_RC Parse_TPMI_ECC_KEY_EXCHANGE(std::string* buffer, 1691 TPMI_ECC_KEY_EXCHANGE* value, 1692 std::string* value_bytes) { 1693 VLOG(3) << __func__; 1694 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1695 } 1696 1697 TPM_RC Serialize_TPM_ST(const TPM_ST& value, std::string* buffer) { 1698 VLOG(3) << __func__; 1699 return Serialize_UINT16(value, buffer); 1700 } 1701 1702 TPM_RC Parse_TPM_ST(std::string* buffer, 1703 TPM_ST* value, 1704 std::string* value_bytes) { 1705 VLOG(3) << __func__; 1706 return Parse_UINT16(buffer, value, value_bytes); 1707 } 1708 1709 TPM_RC Serialize_TPMI_ST_COMMAND_TAG(const TPMI_ST_COMMAND_TAG& value, 1710 std::string* buffer) { 1711 VLOG(3) << __func__; 1712 return Serialize_TPM_ST(value, buffer); 1713 } 1714 1715 TPM_RC Parse_TPMI_ST_COMMAND_TAG(std::string* buffer, 1716 TPMI_ST_COMMAND_TAG* value, 1717 std::string* value_bytes) { 1718 VLOG(3) << __func__; 1719 return Parse_TPM_ST(buffer, value, value_bytes); 1720 } 1721 1722 TPM_RC Serialize_TPMI_ST_ATTEST(const TPMI_ST_ATTEST& value, 1723 std::string* buffer) { 1724 VLOG(3) << __func__; 1725 return Serialize_TPM_ST(value, buffer); 1726 } 1727 1728 TPM_RC Parse_TPMI_ST_ATTEST(std::string* buffer, 1729 TPMI_ST_ATTEST* value, 1730 std::string* value_bytes) { 1731 VLOG(3) << __func__; 1732 return Parse_TPM_ST(buffer, value, value_bytes); 1733 } 1734 1735 TPM_RC Serialize_TPMI_AES_KEY_BITS(const TPMI_AES_KEY_BITS& value, 1736 std::string* buffer) { 1737 VLOG(3) << __func__; 1738 return Serialize_TPM_KEY_BITS(value, buffer); 1739 } 1740 1741 TPM_RC Parse_TPMI_AES_KEY_BITS(std::string* buffer, 1742 TPMI_AES_KEY_BITS* value, 1743 std::string* value_bytes) { 1744 VLOG(3) << __func__; 1745 return Parse_TPM_KEY_BITS(buffer, value, value_bytes); 1746 } 1747 1748 TPM_RC Serialize_TPMI_SM4_KEY_BITS(const TPMI_SM4_KEY_BITS& value, 1749 std::string* buffer) { 1750 VLOG(3) << __func__; 1751 return Serialize_TPM_KEY_BITS(value, buffer); 1752 } 1753 1754 TPM_RC Parse_TPMI_SM4_KEY_BITS(std::string* buffer, 1755 TPMI_SM4_KEY_BITS* value, 1756 std::string* value_bytes) { 1757 VLOG(3) << __func__; 1758 return Parse_TPM_KEY_BITS(buffer, value, value_bytes); 1759 } 1760 1761 TPM_RC Serialize_TPMI_ALG_KEYEDHASH_SCHEME( 1762 const TPMI_ALG_KEYEDHASH_SCHEME& value, 1763 std::string* buffer) { 1764 VLOG(3) << __func__; 1765 return Serialize_TPM_ALG_ID(value, buffer); 1766 } 1767 1768 TPM_RC Parse_TPMI_ALG_KEYEDHASH_SCHEME(std::string* buffer, 1769 TPMI_ALG_KEYEDHASH_SCHEME* value, 1770 std::string* value_bytes) { 1771 VLOG(3) << __func__; 1772 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1773 } 1774 1775 TPM_RC Serialize_TPMI_ALG_ASYM_SCHEME(const TPMI_ALG_ASYM_SCHEME& value, 1776 std::string* buffer) { 1777 VLOG(3) << __func__; 1778 return Serialize_TPM_ALG_ID(value, buffer); 1779 } 1780 1781 TPM_RC Parse_TPMI_ALG_ASYM_SCHEME(std::string* buffer, 1782 TPMI_ALG_ASYM_SCHEME* value, 1783 std::string* value_bytes) { 1784 VLOG(3) << __func__; 1785 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1786 } 1787 1788 TPM_RC Serialize_TPMI_ALG_RSA_SCHEME(const TPMI_ALG_RSA_SCHEME& value, 1789 std::string* buffer) { 1790 VLOG(3) << __func__; 1791 return Serialize_TPM_ALG_ID(value, buffer); 1792 } 1793 1794 TPM_RC Parse_TPMI_ALG_RSA_SCHEME(std::string* buffer, 1795 TPMI_ALG_RSA_SCHEME* value, 1796 std::string* value_bytes) { 1797 VLOG(3) << __func__; 1798 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1799 } 1800 1801 TPM_RC Serialize_TPMI_ALG_RSA_DECRYPT(const TPMI_ALG_RSA_DECRYPT& value, 1802 std::string* buffer) { 1803 VLOG(3) << __func__; 1804 return Serialize_TPM_ALG_ID(value, buffer); 1805 } 1806 1807 TPM_RC Parse_TPMI_ALG_RSA_DECRYPT(std::string* buffer, 1808 TPMI_ALG_RSA_DECRYPT* value, 1809 std::string* value_bytes) { 1810 VLOG(3) << __func__; 1811 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1812 } 1813 1814 TPM_RC Serialize_TPMI_RSA_KEY_BITS(const TPMI_RSA_KEY_BITS& value, 1815 std::string* buffer) { 1816 VLOG(3) << __func__; 1817 return Serialize_TPM_KEY_BITS(value, buffer); 1818 } 1819 1820 TPM_RC Parse_TPMI_RSA_KEY_BITS(std::string* buffer, 1821 TPMI_RSA_KEY_BITS* value, 1822 std::string* value_bytes) { 1823 VLOG(3) << __func__; 1824 return Parse_TPM_KEY_BITS(buffer, value, value_bytes); 1825 } 1826 1827 TPM_RC Serialize_TPMI_ALG_ECC_SCHEME(const TPMI_ALG_ECC_SCHEME& value, 1828 std::string* buffer) { 1829 VLOG(3) << __func__; 1830 return Serialize_TPM_ALG_ID(value, buffer); 1831 } 1832 1833 TPM_RC Parse_TPMI_ALG_ECC_SCHEME(std::string* buffer, 1834 TPMI_ALG_ECC_SCHEME* value, 1835 std::string* value_bytes) { 1836 VLOG(3) << __func__; 1837 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1838 } 1839 1840 TPM_RC Serialize_TPM_ECC_CURVE(const TPM_ECC_CURVE& value, 1841 std::string* buffer) { 1842 VLOG(3) << __func__; 1843 return Serialize_UINT16(value, buffer); 1844 } 1845 1846 TPM_RC Parse_TPM_ECC_CURVE(std::string* buffer, 1847 TPM_ECC_CURVE* value, 1848 std::string* value_bytes) { 1849 VLOG(3) << __func__; 1850 return Parse_UINT16(buffer, value, value_bytes); 1851 } 1852 1853 TPM_RC Serialize_TPMI_ECC_CURVE(const TPMI_ECC_CURVE& value, 1854 std::string* buffer) { 1855 VLOG(3) << __func__; 1856 return Serialize_TPM_ECC_CURVE(value, buffer); 1857 } 1858 1859 TPM_RC Parse_TPMI_ECC_CURVE(std::string* buffer, 1860 TPMI_ECC_CURVE* value, 1861 std::string* value_bytes) { 1862 VLOG(3) << __func__; 1863 return Parse_TPM_ECC_CURVE(buffer, value, value_bytes); 1864 } 1865 1866 TPM_RC Serialize_TPMI_ALG_PUBLIC(const TPMI_ALG_PUBLIC& value, 1867 std::string* buffer) { 1868 VLOG(3) << __func__; 1869 return Serialize_TPM_ALG_ID(value, buffer); 1870 } 1871 1872 TPM_RC Parse_TPMI_ALG_PUBLIC(std::string* buffer, 1873 TPMI_ALG_PUBLIC* value, 1874 std::string* value_bytes) { 1875 VLOG(3) << __func__; 1876 return Parse_TPM_ALG_ID(buffer, value, value_bytes); 1877 } 1878 1879 TPM_RC Serialize_TPMA_ALGORITHM(const TPMA_ALGORITHM& value, 1880 std::string* buffer) { 1881 VLOG(3) << __func__; 1882 return Serialize_UINT32(value, buffer); 1883 } 1884 1885 TPM_RC Parse_TPMA_ALGORITHM(std::string* buffer, 1886 TPMA_ALGORITHM* value, 1887 std::string* value_bytes) { 1888 VLOG(3) << __func__; 1889 return Parse_UINT32(buffer, value, value_bytes); 1890 } 1891 1892 TPM_RC Serialize_TPMA_OBJECT(const TPMA_OBJECT& value, std::string* buffer) { 1893 VLOG(3) << __func__; 1894 return Serialize_UINT32(value, buffer); 1895 } 1896 1897 TPM_RC Parse_TPMA_OBJECT(std::string* buffer, 1898 TPMA_OBJECT* value, 1899 std::string* value_bytes) { 1900 VLOG(3) << __func__; 1901 return Parse_UINT32(buffer, value, value_bytes); 1902 } 1903 1904 TPM_RC Serialize_TPMA_SESSION(const TPMA_SESSION& value, std::string* buffer) { 1905 VLOG(3) << __func__; 1906 return Serialize_UINT8(value, buffer); 1907 } 1908 1909 TPM_RC Parse_TPMA_SESSION(std::string* buffer, 1910 TPMA_SESSION* value, 1911 std::string* value_bytes) { 1912 VLOG(3) << __func__; 1913 return Parse_UINT8(buffer, value, value_bytes); 1914 } 1915 1916 TPM_RC Serialize_TPMA_LOCALITY(const TPMA_LOCALITY& value, 1917 std::string* buffer) { 1918 VLOG(3) << __func__; 1919 return Serialize_UINT8(value, buffer); 1920 } 1921 1922 TPM_RC Parse_TPMA_LOCALITY(std::string* buffer, 1923 TPMA_LOCALITY* value, 1924 std::string* value_bytes) { 1925 VLOG(3) << __func__; 1926 return Parse_UINT8(buffer, value, value_bytes); 1927 } 1928 1929 TPM_RC Serialize_TPMA_PERMANENT(const TPMA_PERMANENT& value, 1930 std::string* buffer) { 1931 VLOG(3) << __func__; 1932 return Serialize_UINT32(value, buffer); 1933 } 1934 1935 TPM_RC Parse_TPMA_PERMANENT(std::string* buffer, 1936 TPMA_PERMANENT* value, 1937 std::string* value_bytes) { 1938 VLOG(3) << __func__; 1939 return Parse_UINT32(buffer, value, value_bytes); 1940 } 1941 1942 TPM_RC Serialize_TPMA_STARTUP_CLEAR(const TPMA_STARTUP_CLEAR& value, 1943 std::string* buffer) { 1944 VLOG(3) << __func__; 1945 return Serialize_UINT32(value, buffer); 1946 } 1947 1948 TPM_RC Parse_TPMA_STARTUP_CLEAR(std::string* buffer, 1949 TPMA_STARTUP_CLEAR* value, 1950 std::string* value_bytes) { 1951 VLOG(3) << __func__; 1952 return Parse_UINT32(buffer, value, value_bytes); 1953 } 1954 1955 TPM_RC Serialize_TPMA_MEMORY(const TPMA_MEMORY& value, std::string* buffer) { 1956 VLOG(3) << __func__; 1957 return Serialize_UINT32(value, buffer); 1958 } 1959 1960 TPM_RC Parse_TPMA_MEMORY(std::string* buffer, 1961 TPMA_MEMORY* value, 1962 std::string* value_bytes) { 1963 VLOG(3) << __func__; 1964 return Parse_UINT32(buffer, value, value_bytes); 1965 } 1966 1967 TPM_RC Serialize_TPM_CC(const TPM_CC& value, std::string* buffer) { 1968 VLOG(3) << __func__; 1969 return Serialize_UINT32(value, buffer); 1970 } 1971 1972 TPM_RC Parse_TPM_CC(std::string* buffer, 1973 TPM_CC* value, 1974 std::string* value_bytes) { 1975 VLOG(3) << __func__; 1976 return Parse_UINT32(buffer, value, value_bytes); 1977 } 1978 1979 TPM_RC Serialize_TPMA_CC(const TPMA_CC& value, std::string* buffer) { 1980 VLOG(3) << __func__; 1981 return Serialize_TPM_CC(value, buffer); 1982 } 1983 1984 TPM_RC Parse_TPMA_CC(std::string* buffer, 1985 TPMA_CC* value, 1986 std::string* value_bytes) { 1987 VLOG(3) << __func__; 1988 return Parse_TPM_CC(buffer, value, value_bytes); 1989 } 1990 1991 TPM_RC Serialize_TPM_NV_INDEX(const TPM_NV_INDEX& value, std::string* buffer) { 1992 VLOG(3) << __func__; 1993 return Serialize_UINT32(value, buffer); 1994 } 1995 1996 TPM_RC Parse_TPM_NV_INDEX(std::string* buffer, 1997 TPM_NV_INDEX* value, 1998 std::string* value_bytes) { 1999 VLOG(3) << __func__; 2000 return Parse_UINT32(buffer, value, value_bytes); 2001 } 2002 2003 TPM_RC Serialize_TPMA_NV(const TPMA_NV& value, std::string* buffer) { 2004 VLOG(3) << __func__; 2005 return Serialize_UINT32(value, buffer); 2006 } 2007 2008 TPM_RC Parse_TPMA_NV(std::string* buffer, 2009 TPMA_NV* value, 2010 std::string* value_bytes) { 2011 VLOG(3) << __func__; 2012 return Parse_UINT32(buffer, value, value_bytes); 2013 } 2014 2015 TPM_RC Serialize_TPM_SPEC(const TPM_SPEC& value, std::string* buffer) { 2016 VLOG(3) << __func__; 2017 return Serialize_UINT32(value, buffer); 2018 } 2019 2020 TPM_RC Parse_TPM_SPEC(std::string* buffer, 2021 TPM_SPEC* value, 2022 std::string* value_bytes) { 2023 VLOG(3) << __func__; 2024 return Parse_UINT32(buffer, value, value_bytes); 2025 } 2026 2027 TPM_RC Serialize_TPM_GENERATED(const TPM_GENERATED& value, 2028 std::string* buffer) { 2029 VLOG(3) << __func__; 2030 return Serialize_UINT32(value, buffer); 2031 } 2032 2033 TPM_RC Parse_TPM_GENERATED(std::string* buffer, 2034 TPM_GENERATED* value, 2035 std::string* value_bytes) { 2036 VLOG(3) << __func__; 2037 return Parse_UINT32(buffer, value, value_bytes); 2038 } 2039 2040 TPM_RC Serialize_TPM_RC(const TPM_RC& value, std::string* buffer) { 2041 VLOG(3) << __func__; 2042 return Serialize_UINT32(value, buffer); 2043 } 2044 2045 TPM_RC Parse_TPM_RC(std::string* buffer, 2046 TPM_RC* value, 2047 std::string* value_bytes) { 2048 VLOG(3) << __func__; 2049 return Parse_UINT32(buffer, value, value_bytes); 2050 } 2051 2052 TPM_RC Serialize_TPM_CLOCK_ADJUST(const TPM_CLOCK_ADJUST& value, 2053 std::string* buffer) { 2054 VLOG(3) << __func__; 2055 return Serialize_INT8(value, buffer); 2056 } 2057 2058 TPM_RC Parse_TPM_CLOCK_ADJUST(std::string* buffer, 2059 TPM_CLOCK_ADJUST* value, 2060 std::string* value_bytes) { 2061 VLOG(3) << __func__; 2062 return Parse_INT8(buffer, value, value_bytes); 2063 } 2064 2065 TPM_RC Serialize_TPM_EO(const TPM_EO& value, std::string* buffer) { 2066 VLOG(3) << __func__; 2067 return Serialize_UINT16(value, buffer); 2068 } 2069 2070 TPM_RC Parse_TPM_EO(std::string* buffer, 2071 TPM_EO* value, 2072 std::string* value_bytes) { 2073 VLOG(3) << __func__; 2074 return Parse_UINT16(buffer, value, value_bytes); 2075 } 2076 2077 TPM_RC Serialize_TPM_SU(const TPM_SU& value, std::string* buffer) { 2078 VLOG(3) << __func__; 2079 return Serialize_UINT16(value, buffer); 2080 } 2081 2082 TPM_RC Parse_TPM_SU(std::string* buffer, 2083 TPM_SU* value, 2084 std::string* value_bytes) { 2085 VLOG(3) << __func__; 2086 return Parse_UINT16(buffer, value, value_bytes); 2087 } 2088 2089 TPM_RC Serialize_TPM_SE(const TPM_SE& value, std::string* buffer) { 2090 VLOG(3) << __func__; 2091 return Serialize_UINT8(value, buffer); 2092 } 2093 2094 TPM_RC Parse_TPM_SE(std::string* buffer, 2095 TPM_SE* value, 2096 std::string* value_bytes) { 2097 VLOG(3) << __func__; 2098 return Parse_UINT8(buffer, value, value_bytes); 2099 } 2100 2101 TPM_RC Serialize_TPM_CAP(const TPM_CAP& value, std::string* buffer) { 2102 VLOG(3) << __func__; 2103 return Serialize_UINT32(value, buffer); 2104 } 2105 2106 TPM_RC Parse_TPM_CAP(std::string* buffer, 2107 TPM_CAP* value, 2108 std::string* value_bytes) { 2109 VLOG(3) << __func__; 2110 return Parse_UINT32(buffer, value, value_bytes); 2111 } 2112 2113 TPM_RC Serialize_TPM_PT(const TPM_PT& value, std::string* buffer) { 2114 VLOG(3) << __func__; 2115 return Serialize_UINT32(value, buffer); 2116 } 2117 2118 TPM_RC Parse_TPM_PT(std::string* buffer, 2119 TPM_PT* value, 2120 std::string* value_bytes) { 2121 VLOG(3) << __func__; 2122 return Parse_UINT32(buffer, value, value_bytes); 2123 } 2124 2125 TPM_RC Serialize_TPM_PT_PCR(const TPM_PT_PCR& value, std::string* buffer) { 2126 VLOG(3) << __func__; 2127 return Serialize_UINT32(value, buffer); 2128 } 2129 2130 TPM_RC Parse_TPM_PT_PCR(std::string* buffer, 2131 TPM_PT_PCR* value, 2132 std::string* value_bytes) { 2133 VLOG(3) << __func__; 2134 return Parse_UINT32(buffer, value, value_bytes); 2135 } 2136 2137 TPM_RC Serialize_TPM_PS(const TPM_PS& value, std::string* buffer) { 2138 VLOG(3) << __func__; 2139 return Serialize_UINT32(value, buffer); 2140 } 2141 2142 TPM_RC Parse_TPM_PS(std::string* buffer, 2143 TPM_PS* value, 2144 std::string* value_bytes) { 2145 VLOG(3) << __func__; 2146 return Parse_UINT32(buffer, value, value_bytes); 2147 } 2148 2149 TPM_RC Serialize_TPM_HT(const TPM_HT& value, std::string* buffer) { 2150 VLOG(3) << __func__; 2151 return Serialize_UINT8(value, buffer); 2152 } 2153 2154 TPM_RC Parse_TPM_HT(std::string* buffer, 2155 TPM_HT* value, 2156 std::string* value_bytes) { 2157 VLOG(3) << __func__; 2158 return Parse_UINT8(buffer, value, value_bytes); 2159 } 2160 2161 TPM_RC Serialize_TPM_RH(const TPM_RH& value, std::string* buffer) { 2162 VLOG(3) << __func__; 2163 return Serialize_UINT32(value, buffer); 2164 } 2165 2166 TPM_RC Parse_TPM_RH(std::string* buffer, 2167 TPM_RH* value, 2168 std::string* value_bytes) { 2169 VLOG(3) << __func__; 2170 return Parse_UINT32(buffer, value, value_bytes); 2171 } 2172 2173 TPM_RC Serialize_TPM_HC(const TPM_HC& value, std::string* buffer) { 2174 VLOG(3) << __func__; 2175 return Serialize_TPM_HANDLE(value, buffer); 2176 } 2177 2178 TPM_RC Parse_TPM_HC(std::string* buffer, 2179 TPM_HC* value, 2180 std::string* value_bytes) { 2181 VLOG(3) << __func__; 2182 return Parse_TPM_HANDLE(buffer, value, value_bytes); 2183 } 2184 2185 TPM_RC Serialize_TPMS_ALGORITHM_DESCRIPTION( 2186 const TPMS_ALGORITHM_DESCRIPTION& value, 2187 std::string* buffer) { 2188 TPM_RC result = TPM_RC_SUCCESS; 2189 VLOG(3) << __func__; 2190 2191 result = Serialize_TPM_ALG_ID(value.alg, buffer); 2192 if (result) { 2193 return result; 2194 } 2195 2196 result = Serialize_TPMA_ALGORITHM(value.attributes, buffer); 2197 if (result) { 2198 return result; 2199 } 2200 return result; 2201 } 2202 2203 TPM_RC Parse_TPMS_ALGORITHM_DESCRIPTION(std::string* buffer, 2204 TPMS_ALGORITHM_DESCRIPTION* value, 2205 std::string* value_bytes) { 2206 TPM_RC result = TPM_RC_SUCCESS; 2207 VLOG(3) << __func__; 2208 2209 result = Parse_TPM_ALG_ID(buffer, &value->alg, value_bytes); 2210 if (result) { 2211 return result; 2212 } 2213 2214 result = Parse_TPMA_ALGORITHM(buffer, &value->attributes, value_bytes); 2215 if (result) { 2216 return result; 2217 } 2218 return result; 2219 } 2220 2221 TPM_RC Serialize_TPMU_HA(const TPMU_HA& value, 2222 TPMI_ALG_HASH selector, 2223 std::string* buffer) { 2224 TPM_RC result = TPM_RC_SUCCESS; 2225 VLOG(3) << __func__; 2226 2227 if (selector == TPM_ALG_SHA384) { 2228 if (arraysize(value.sha384) < SHA384_DIGEST_SIZE) { 2229 return TPM_RC_INSUFFICIENT; 2230 } 2231 for (uint32_t i = 0; i < SHA384_DIGEST_SIZE; ++i) { 2232 result = Serialize_BYTE(value.sha384[i], buffer); 2233 if (result) { 2234 return result; 2235 } 2236 } 2237 } 2238 2239 if (selector == TPM_ALG_SHA1) { 2240 if (arraysize(value.sha1) < SHA1_DIGEST_SIZE) { 2241 return TPM_RC_INSUFFICIENT; 2242 } 2243 for (uint32_t i = 0; i < SHA1_DIGEST_SIZE; ++i) { 2244 result = Serialize_BYTE(value.sha1[i], buffer); 2245 if (result) { 2246 return result; 2247 } 2248 } 2249 } 2250 2251 if (selector == TPM_ALG_SM3_256) { 2252 if (arraysize(value.sm3_256) < SM3_256_DIGEST_SIZE) { 2253 return TPM_RC_INSUFFICIENT; 2254 } 2255 for (uint32_t i = 0; i < SM3_256_DIGEST_SIZE; ++i) { 2256 result = Serialize_BYTE(value.sm3_256[i], buffer); 2257 if (result) { 2258 return result; 2259 } 2260 } 2261 } 2262 2263 if (selector == TPM_ALG_NULL) { 2264 // Do nothing. 2265 } 2266 2267 if (selector == TPM_ALG_SHA256) { 2268 if (arraysize(value.sha256) < SHA256_DIGEST_SIZE) { 2269 return TPM_RC_INSUFFICIENT; 2270 } 2271 for (uint32_t i = 0; i < SHA256_DIGEST_SIZE; ++i) { 2272 result = Serialize_BYTE(value.sha256[i], buffer); 2273 if (result) { 2274 return result; 2275 } 2276 } 2277 } 2278 2279 if (selector == TPM_ALG_SHA512) { 2280 if (arraysize(value.sha512) < SHA512_DIGEST_SIZE) { 2281 return TPM_RC_INSUFFICIENT; 2282 } 2283 for (uint32_t i = 0; i < SHA512_DIGEST_SIZE; ++i) { 2284 result = Serialize_BYTE(value.sha512[i], buffer); 2285 if (result) { 2286 return result; 2287 } 2288 } 2289 } 2290 return result; 2291 } 2292 2293 TPM_RC Parse_TPMU_HA(std::string* buffer, 2294 TPMI_ALG_HASH selector, 2295 TPMU_HA* value, 2296 std::string* value_bytes) { 2297 TPM_RC result = TPM_RC_SUCCESS; 2298 VLOG(3) << __func__; 2299 2300 if (selector == TPM_ALG_SHA384) { 2301 if (arraysize(value->sha384) < SHA384_DIGEST_SIZE) { 2302 return TPM_RC_INSUFFICIENT; 2303 } 2304 for (uint32_t i = 0; i < SHA384_DIGEST_SIZE; ++i) { 2305 result = Parse_BYTE(buffer, &value->sha384[i], value_bytes); 2306 if (result) { 2307 return result; 2308 } 2309 } 2310 } 2311 2312 if (selector == TPM_ALG_SHA1) { 2313 if (arraysize(value->sha1) < SHA1_DIGEST_SIZE) { 2314 return TPM_RC_INSUFFICIENT; 2315 } 2316 for (uint32_t i = 0; i < SHA1_DIGEST_SIZE; ++i) { 2317 result = Parse_BYTE(buffer, &value->sha1[i], value_bytes); 2318 if (result) { 2319 return result; 2320 } 2321 } 2322 } 2323 2324 if (selector == TPM_ALG_SM3_256) { 2325 if (arraysize(value->sm3_256) < SM3_256_DIGEST_SIZE) { 2326 return TPM_RC_INSUFFICIENT; 2327 } 2328 for (uint32_t i = 0; i < SM3_256_DIGEST_SIZE; ++i) { 2329 result = Parse_BYTE(buffer, &value->sm3_256[i], value_bytes); 2330 if (result) { 2331 return result; 2332 } 2333 } 2334 } 2335 2336 if (selector == TPM_ALG_NULL) { 2337 // Do nothing. 2338 } 2339 2340 if (selector == TPM_ALG_SHA256) { 2341 if (arraysize(value->sha256) < SHA256_DIGEST_SIZE) { 2342 return TPM_RC_INSUFFICIENT; 2343 } 2344 for (uint32_t i = 0; i < SHA256_DIGEST_SIZE; ++i) { 2345 result = Parse_BYTE(buffer, &value->sha256[i], value_bytes); 2346 if (result) { 2347 return result; 2348 } 2349 } 2350 } 2351 2352 if (selector == TPM_ALG_SHA512) { 2353 if (arraysize(value->sha512) < SHA512_DIGEST_SIZE) { 2354 return TPM_RC_INSUFFICIENT; 2355 } 2356 for (uint32_t i = 0; i < SHA512_DIGEST_SIZE; ++i) { 2357 result = Parse_BYTE(buffer, &value->sha512[i], value_bytes); 2358 if (result) { 2359 return result; 2360 } 2361 } 2362 } 2363 return result; 2364 } 2365 2366 TPM_RC Serialize_TPMT_HA(const TPMT_HA& value, std::string* buffer) { 2367 TPM_RC result = TPM_RC_SUCCESS; 2368 VLOG(3) << __func__; 2369 2370 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 2371 if (result) { 2372 return result; 2373 } 2374 2375 result = Serialize_TPMU_HA(value.digest, value.hash_alg, buffer); 2376 if (result) { 2377 return result; 2378 } 2379 return result; 2380 } 2381 2382 TPM_RC Parse_TPMT_HA(std::string* buffer, 2383 TPMT_HA* value, 2384 std::string* value_bytes) { 2385 TPM_RC result = TPM_RC_SUCCESS; 2386 VLOG(3) << __func__; 2387 2388 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 2389 if (result) { 2390 return result; 2391 } 2392 2393 result = Parse_TPMU_HA(buffer, value->hash_alg, &value->digest, value_bytes); 2394 if (result) { 2395 return result; 2396 } 2397 return result; 2398 } 2399 2400 TPM_RC Serialize_TPM2B_DATA(const TPM2B_DATA& value, std::string* buffer) { 2401 TPM_RC result = TPM_RC_SUCCESS; 2402 VLOG(3) << __func__; 2403 2404 result = Serialize_UINT16(value.size, buffer); 2405 if (result) { 2406 return result; 2407 } 2408 2409 if (arraysize(value.buffer) < value.size) { 2410 return TPM_RC_INSUFFICIENT; 2411 } 2412 for (uint32_t i = 0; i < value.size; ++i) { 2413 result = Serialize_BYTE(value.buffer[i], buffer); 2414 if (result) { 2415 return result; 2416 } 2417 } 2418 return result; 2419 } 2420 2421 TPM_RC Parse_TPM2B_DATA(std::string* buffer, 2422 TPM2B_DATA* value, 2423 std::string* value_bytes) { 2424 TPM_RC result = TPM_RC_SUCCESS; 2425 VLOG(3) << __func__; 2426 2427 result = Parse_UINT16(buffer, &value->size, value_bytes); 2428 if (result) { 2429 return result; 2430 } 2431 2432 if (arraysize(value->buffer) < value->size) { 2433 return TPM_RC_INSUFFICIENT; 2434 } 2435 for (uint32_t i = 0; i < value->size; ++i) { 2436 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 2437 if (result) { 2438 return result; 2439 } 2440 } 2441 return result; 2442 } 2443 2444 TPM2B_DATA Make_TPM2B_DATA(const std::string& bytes) { 2445 TPM2B_DATA tpm2b; 2446 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 2447 memset(&tpm2b, 0, sizeof(TPM2B_DATA)); 2448 tpm2b.size = bytes.size(); 2449 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 2450 return tpm2b; 2451 } 2452 2453 std::string StringFrom_TPM2B_DATA(const TPM2B_DATA& tpm2b) { 2454 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 2455 return std::string(char_buffer, tpm2b.size); 2456 } 2457 2458 TPM_RC Serialize_TPM2B_EVENT(const TPM2B_EVENT& value, std::string* buffer) { 2459 TPM_RC result = TPM_RC_SUCCESS; 2460 VLOG(3) << __func__; 2461 2462 result = Serialize_UINT16(value.size, buffer); 2463 if (result) { 2464 return result; 2465 } 2466 2467 if (arraysize(value.buffer) < value.size) { 2468 return TPM_RC_INSUFFICIENT; 2469 } 2470 for (uint32_t i = 0; i < value.size; ++i) { 2471 result = Serialize_BYTE(value.buffer[i], buffer); 2472 if (result) { 2473 return result; 2474 } 2475 } 2476 return result; 2477 } 2478 2479 TPM_RC Parse_TPM2B_EVENT(std::string* buffer, 2480 TPM2B_EVENT* value, 2481 std::string* value_bytes) { 2482 TPM_RC result = TPM_RC_SUCCESS; 2483 VLOG(3) << __func__; 2484 2485 result = Parse_UINT16(buffer, &value->size, value_bytes); 2486 if (result) { 2487 return result; 2488 } 2489 2490 if (arraysize(value->buffer) < value->size) { 2491 return TPM_RC_INSUFFICIENT; 2492 } 2493 for (uint32_t i = 0; i < value->size; ++i) { 2494 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 2495 if (result) { 2496 return result; 2497 } 2498 } 2499 return result; 2500 } 2501 2502 TPM2B_EVENT Make_TPM2B_EVENT(const std::string& bytes) { 2503 TPM2B_EVENT tpm2b; 2504 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 2505 memset(&tpm2b, 0, sizeof(TPM2B_EVENT)); 2506 tpm2b.size = bytes.size(); 2507 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 2508 return tpm2b; 2509 } 2510 2511 std::string StringFrom_TPM2B_EVENT(const TPM2B_EVENT& tpm2b) { 2512 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 2513 return std::string(char_buffer, tpm2b.size); 2514 } 2515 2516 TPM_RC Serialize_TPM2B_MAX_BUFFER(const TPM2B_MAX_BUFFER& value, 2517 std::string* buffer) { 2518 TPM_RC result = TPM_RC_SUCCESS; 2519 VLOG(3) << __func__; 2520 2521 result = Serialize_UINT16(value.size, buffer); 2522 if (result) { 2523 return result; 2524 } 2525 2526 if (arraysize(value.buffer) < value.size) { 2527 return TPM_RC_INSUFFICIENT; 2528 } 2529 for (uint32_t i = 0; i < value.size; ++i) { 2530 result = Serialize_BYTE(value.buffer[i], buffer); 2531 if (result) { 2532 return result; 2533 } 2534 } 2535 return result; 2536 } 2537 2538 TPM_RC Parse_TPM2B_MAX_BUFFER(std::string* buffer, 2539 TPM2B_MAX_BUFFER* value, 2540 std::string* value_bytes) { 2541 TPM_RC result = TPM_RC_SUCCESS; 2542 VLOG(3) << __func__; 2543 2544 result = Parse_UINT16(buffer, &value->size, value_bytes); 2545 if (result) { 2546 return result; 2547 } 2548 2549 if (arraysize(value->buffer) < value->size) { 2550 return TPM_RC_INSUFFICIENT; 2551 } 2552 for (uint32_t i = 0; i < value->size; ++i) { 2553 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 2554 if (result) { 2555 return result; 2556 } 2557 } 2558 return result; 2559 } 2560 2561 TPM2B_MAX_BUFFER Make_TPM2B_MAX_BUFFER(const std::string& bytes) { 2562 TPM2B_MAX_BUFFER tpm2b; 2563 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 2564 memset(&tpm2b, 0, sizeof(TPM2B_MAX_BUFFER)); 2565 tpm2b.size = bytes.size(); 2566 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 2567 return tpm2b; 2568 } 2569 2570 std::string StringFrom_TPM2B_MAX_BUFFER(const TPM2B_MAX_BUFFER& tpm2b) { 2571 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 2572 return std::string(char_buffer, tpm2b.size); 2573 } 2574 2575 TPM_RC Serialize_TPM2B_MAX_NV_BUFFER(const TPM2B_MAX_NV_BUFFER& value, 2576 std::string* buffer) { 2577 TPM_RC result = TPM_RC_SUCCESS; 2578 VLOG(3) << __func__; 2579 2580 result = Serialize_UINT16(value.size, buffer); 2581 if (result) { 2582 return result; 2583 } 2584 2585 if (arraysize(value.buffer) < value.size) { 2586 return TPM_RC_INSUFFICIENT; 2587 } 2588 for (uint32_t i = 0; i < value.size; ++i) { 2589 result = Serialize_BYTE(value.buffer[i], buffer); 2590 if (result) { 2591 return result; 2592 } 2593 } 2594 return result; 2595 } 2596 2597 TPM_RC Parse_TPM2B_MAX_NV_BUFFER(std::string* buffer, 2598 TPM2B_MAX_NV_BUFFER* value, 2599 std::string* value_bytes) { 2600 TPM_RC result = TPM_RC_SUCCESS; 2601 VLOG(3) << __func__; 2602 2603 result = Parse_UINT16(buffer, &value->size, value_bytes); 2604 if (result) { 2605 return result; 2606 } 2607 2608 if (arraysize(value->buffer) < value->size) { 2609 return TPM_RC_INSUFFICIENT; 2610 } 2611 for (uint32_t i = 0; i < value->size; ++i) { 2612 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 2613 if (result) { 2614 return result; 2615 } 2616 } 2617 return result; 2618 } 2619 2620 TPM2B_MAX_NV_BUFFER Make_TPM2B_MAX_NV_BUFFER(const std::string& bytes) { 2621 TPM2B_MAX_NV_BUFFER tpm2b; 2622 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 2623 memset(&tpm2b, 0, sizeof(TPM2B_MAX_NV_BUFFER)); 2624 tpm2b.size = bytes.size(); 2625 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 2626 return tpm2b; 2627 } 2628 2629 std::string StringFrom_TPM2B_MAX_NV_BUFFER(const TPM2B_MAX_NV_BUFFER& tpm2b) { 2630 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 2631 return std::string(char_buffer, tpm2b.size); 2632 } 2633 2634 TPM_RC Serialize_TPM2B_TIMEOUT(const TPM2B_TIMEOUT& value, 2635 std::string* buffer) { 2636 TPM_RC result = TPM_RC_SUCCESS; 2637 VLOG(3) << __func__; 2638 2639 result = Serialize_UINT16(value.size, buffer); 2640 if (result) { 2641 return result; 2642 } 2643 2644 if (arraysize(value.buffer) < value.size) { 2645 return TPM_RC_INSUFFICIENT; 2646 } 2647 for (uint32_t i = 0; i < value.size; ++i) { 2648 result = Serialize_BYTE(value.buffer[i], buffer); 2649 if (result) { 2650 return result; 2651 } 2652 } 2653 return result; 2654 } 2655 2656 TPM_RC Parse_TPM2B_TIMEOUT(std::string* buffer, 2657 TPM2B_TIMEOUT* value, 2658 std::string* value_bytes) { 2659 TPM_RC result = TPM_RC_SUCCESS; 2660 VLOG(3) << __func__; 2661 2662 result = Parse_UINT16(buffer, &value->size, value_bytes); 2663 if (result) { 2664 return result; 2665 } 2666 2667 if (arraysize(value->buffer) < value->size) { 2668 return TPM_RC_INSUFFICIENT; 2669 } 2670 for (uint32_t i = 0; i < value->size; ++i) { 2671 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 2672 if (result) { 2673 return result; 2674 } 2675 } 2676 return result; 2677 } 2678 2679 TPM2B_TIMEOUT Make_TPM2B_TIMEOUT(const std::string& bytes) { 2680 TPM2B_TIMEOUT tpm2b; 2681 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 2682 memset(&tpm2b, 0, sizeof(TPM2B_TIMEOUT)); 2683 tpm2b.size = bytes.size(); 2684 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 2685 return tpm2b; 2686 } 2687 2688 std::string StringFrom_TPM2B_TIMEOUT(const TPM2B_TIMEOUT& tpm2b) { 2689 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 2690 return std::string(char_buffer, tpm2b.size); 2691 } 2692 2693 TPM_RC Serialize_TPM2B_IV(const TPM2B_IV& value, std::string* buffer) { 2694 TPM_RC result = TPM_RC_SUCCESS; 2695 VLOG(3) << __func__; 2696 2697 result = Serialize_UINT16(value.size, buffer); 2698 if (result) { 2699 return result; 2700 } 2701 2702 if (arraysize(value.buffer) < value.size) { 2703 return TPM_RC_INSUFFICIENT; 2704 } 2705 for (uint32_t i = 0; i < value.size; ++i) { 2706 result = Serialize_BYTE(value.buffer[i], buffer); 2707 if (result) { 2708 return result; 2709 } 2710 } 2711 return result; 2712 } 2713 2714 TPM_RC Parse_TPM2B_IV(std::string* buffer, 2715 TPM2B_IV* value, 2716 std::string* value_bytes) { 2717 TPM_RC result = TPM_RC_SUCCESS; 2718 VLOG(3) << __func__; 2719 2720 result = Parse_UINT16(buffer, &value->size, value_bytes); 2721 if (result) { 2722 return result; 2723 } 2724 2725 if (arraysize(value->buffer) < value->size) { 2726 return TPM_RC_INSUFFICIENT; 2727 } 2728 for (uint32_t i = 0; i < value->size; ++i) { 2729 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 2730 if (result) { 2731 return result; 2732 } 2733 } 2734 return result; 2735 } 2736 2737 TPM2B_IV Make_TPM2B_IV(const std::string& bytes) { 2738 TPM2B_IV tpm2b; 2739 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 2740 memset(&tpm2b, 0, sizeof(TPM2B_IV)); 2741 tpm2b.size = bytes.size(); 2742 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 2743 return tpm2b; 2744 } 2745 2746 std::string StringFrom_TPM2B_IV(const TPM2B_IV& tpm2b) { 2747 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 2748 return std::string(char_buffer, tpm2b.size); 2749 } 2750 2751 TPM_RC Serialize_TPM2B_NAME(const TPM2B_NAME& value, std::string* buffer) { 2752 TPM_RC result = TPM_RC_SUCCESS; 2753 VLOG(3) << __func__; 2754 2755 result = Serialize_UINT16(value.size, buffer); 2756 if (result) { 2757 return result; 2758 } 2759 2760 if (arraysize(value.name) < value.size) { 2761 return TPM_RC_INSUFFICIENT; 2762 } 2763 for (uint32_t i = 0; i < value.size; ++i) { 2764 result = Serialize_BYTE(value.name[i], buffer); 2765 if (result) { 2766 return result; 2767 } 2768 } 2769 return result; 2770 } 2771 2772 TPM_RC Parse_TPM2B_NAME(std::string* buffer, 2773 TPM2B_NAME* value, 2774 std::string* value_bytes) { 2775 TPM_RC result = TPM_RC_SUCCESS; 2776 VLOG(3) << __func__; 2777 2778 result = Parse_UINT16(buffer, &value->size, value_bytes); 2779 if (result) { 2780 return result; 2781 } 2782 2783 if (arraysize(value->name) < value->size) { 2784 return TPM_RC_INSUFFICIENT; 2785 } 2786 for (uint32_t i = 0; i < value->size; ++i) { 2787 result = Parse_BYTE(buffer, &value->name[i], value_bytes); 2788 if (result) { 2789 return result; 2790 } 2791 } 2792 return result; 2793 } 2794 2795 TPM2B_NAME Make_TPM2B_NAME(const std::string& bytes) { 2796 TPM2B_NAME tpm2b; 2797 CHECK(bytes.size() <= sizeof(tpm2b.name)); 2798 memset(&tpm2b, 0, sizeof(TPM2B_NAME)); 2799 tpm2b.size = bytes.size(); 2800 memcpy(tpm2b.name, bytes.data(), bytes.size()); 2801 return tpm2b; 2802 } 2803 2804 std::string StringFrom_TPM2B_NAME(const TPM2B_NAME& tpm2b) { 2805 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.name); 2806 return std::string(char_buffer, tpm2b.size); 2807 } 2808 2809 TPM_RC Serialize_TPMS_PCR_SELECT(const TPMS_PCR_SELECT& value, 2810 std::string* buffer) { 2811 TPM_RC result = TPM_RC_SUCCESS; 2812 VLOG(3) << __func__; 2813 2814 result = Serialize_UINT8(value.sizeof_select, buffer); 2815 if (result) { 2816 return result; 2817 } 2818 2819 if (arraysize(value.pcr_select) < value.sizeof_select) { 2820 return TPM_RC_INSUFFICIENT; 2821 } 2822 for (uint32_t i = 0; i < value.sizeof_select; ++i) { 2823 result = Serialize_BYTE(value.pcr_select[i], buffer); 2824 if (result) { 2825 return result; 2826 } 2827 } 2828 return result; 2829 } 2830 2831 TPM_RC Parse_TPMS_PCR_SELECT(std::string* buffer, 2832 TPMS_PCR_SELECT* value, 2833 std::string* value_bytes) { 2834 TPM_RC result = TPM_RC_SUCCESS; 2835 VLOG(3) << __func__; 2836 2837 result = Parse_UINT8(buffer, &value->sizeof_select, value_bytes); 2838 if (result) { 2839 return result; 2840 } 2841 2842 if (arraysize(value->pcr_select) < value->sizeof_select) { 2843 return TPM_RC_INSUFFICIENT; 2844 } 2845 for (uint32_t i = 0; i < value->sizeof_select; ++i) { 2846 result = Parse_BYTE(buffer, &value->pcr_select[i], value_bytes); 2847 if (result) { 2848 return result; 2849 } 2850 } 2851 return result; 2852 } 2853 2854 TPM_RC Serialize_TPMS_PCR_SELECTION(const TPMS_PCR_SELECTION& value, 2855 std::string* buffer) { 2856 TPM_RC result = TPM_RC_SUCCESS; 2857 VLOG(3) << __func__; 2858 2859 result = Serialize_TPMI_ALG_HASH(value.hash, buffer); 2860 if (result) { 2861 return result; 2862 } 2863 2864 result = Serialize_UINT8(value.sizeof_select, buffer); 2865 if (result) { 2866 return result; 2867 } 2868 2869 if (arraysize(value.pcr_select) < value.sizeof_select) { 2870 return TPM_RC_INSUFFICIENT; 2871 } 2872 for (uint32_t i = 0; i < value.sizeof_select; ++i) { 2873 result = Serialize_BYTE(value.pcr_select[i], buffer); 2874 if (result) { 2875 return result; 2876 } 2877 } 2878 return result; 2879 } 2880 2881 TPM_RC Parse_TPMS_PCR_SELECTION(std::string* buffer, 2882 TPMS_PCR_SELECTION* value, 2883 std::string* value_bytes) { 2884 TPM_RC result = TPM_RC_SUCCESS; 2885 VLOG(3) << __func__; 2886 2887 result = Parse_TPMI_ALG_HASH(buffer, &value->hash, value_bytes); 2888 if (result) { 2889 return result; 2890 } 2891 2892 result = Parse_UINT8(buffer, &value->sizeof_select, value_bytes); 2893 if (result) { 2894 return result; 2895 } 2896 2897 if (arraysize(value->pcr_select) < value->sizeof_select) { 2898 return TPM_RC_INSUFFICIENT; 2899 } 2900 for (uint32_t i = 0; i < value->sizeof_select; ++i) { 2901 result = Parse_BYTE(buffer, &value->pcr_select[i], value_bytes); 2902 if (result) { 2903 return result; 2904 } 2905 } 2906 return result; 2907 } 2908 2909 TPM_RC Serialize_TPMT_TK_CREATION(const TPMT_TK_CREATION& value, 2910 std::string* buffer) { 2911 TPM_RC result = TPM_RC_SUCCESS; 2912 VLOG(3) << __func__; 2913 2914 result = Serialize_TPM_ST(value.tag, buffer); 2915 if (result) { 2916 return result; 2917 } 2918 2919 result = Serialize_TPMI_RH_HIERARCHY(value.hierarchy, buffer); 2920 if (result) { 2921 return result; 2922 } 2923 2924 result = Serialize_TPM2B_DIGEST(value.digest, buffer); 2925 if (result) { 2926 return result; 2927 } 2928 return result; 2929 } 2930 2931 TPM_RC Parse_TPMT_TK_CREATION(std::string* buffer, 2932 TPMT_TK_CREATION* value, 2933 std::string* value_bytes) { 2934 TPM_RC result = TPM_RC_SUCCESS; 2935 VLOG(3) << __func__; 2936 2937 result = Parse_TPM_ST(buffer, &value->tag, value_bytes); 2938 if (result) { 2939 return result; 2940 } 2941 2942 result = Parse_TPMI_RH_HIERARCHY(buffer, &value->hierarchy, value_bytes); 2943 if (result) { 2944 return result; 2945 } 2946 2947 result = Parse_TPM2B_DIGEST(buffer, &value->digest, value_bytes); 2948 if (result) { 2949 return result; 2950 } 2951 return result; 2952 } 2953 2954 TPM_RC Serialize_TPMT_TK_VERIFIED(const TPMT_TK_VERIFIED& value, 2955 std::string* buffer) { 2956 TPM_RC result = TPM_RC_SUCCESS; 2957 VLOG(3) << __func__; 2958 2959 result = Serialize_TPM_ST(value.tag, buffer); 2960 if (result) { 2961 return result; 2962 } 2963 2964 result = Serialize_TPMI_RH_HIERARCHY(value.hierarchy, buffer); 2965 if (result) { 2966 return result; 2967 } 2968 2969 result = Serialize_TPM2B_DIGEST(value.digest, buffer); 2970 if (result) { 2971 return result; 2972 } 2973 return result; 2974 } 2975 2976 TPM_RC Parse_TPMT_TK_VERIFIED(std::string* buffer, 2977 TPMT_TK_VERIFIED* value, 2978 std::string* value_bytes) { 2979 TPM_RC result = TPM_RC_SUCCESS; 2980 VLOG(3) << __func__; 2981 2982 result = Parse_TPM_ST(buffer, &value->tag, value_bytes); 2983 if (result) { 2984 return result; 2985 } 2986 2987 result = Parse_TPMI_RH_HIERARCHY(buffer, &value->hierarchy, value_bytes); 2988 if (result) { 2989 return result; 2990 } 2991 2992 result = Parse_TPM2B_DIGEST(buffer, &value->digest, value_bytes); 2993 if (result) { 2994 return result; 2995 } 2996 return result; 2997 } 2998 2999 TPM_RC Serialize_TPMT_TK_AUTH(const TPMT_TK_AUTH& value, std::string* buffer) { 3000 TPM_RC result = TPM_RC_SUCCESS; 3001 VLOG(3) << __func__; 3002 3003 result = Serialize_TPMI_RH_HIERARCHY(value.hierarchy, buffer); 3004 if (result) { 3005 return result; 3006 } 3007 3008 result = Serialize_TPM2B_DIGEST(value.digest, buffer); 3009 if (result) { 3010 return result; 3011 } 3012 return result; 3013 } 3014 3015 TPM_RC Parse_TPMT_TK_AUTH(std::string* buffer, 3016 TPMT_TK_AUTH* value, 3017 std::string* value_bytes) { 3018 TPM_RC result = TPM_RC_SUCCESS; 3019 VLOG(3) << __func__; 3020 3021 result = Parse_TPMI_RH_HIERARCHY(buffer, &value->hierarchy, value_bytes); 3022 if (result) { 3023 return result; 3024 } 3025 3026 result = Parse_TPM2B_DIGEST(buffer, &value->digest, value_bytes); 3027 if (result) { 3028 return result; 3029 } 3030 return result; 3031 } 3032 3033 TPM_RC Serialize_TPMT_TK_HASHCHECK(const TPMT_TK_HASHCHECK& value, 3034 std::string* buffer) { 3035 TPM_RC result = TPM_RC_SUCCESS; 3036 VLOG(3) << __func__; 3037 3038 result = Serialize_TPM_ST(value.tag, buffer); 3039 if (result) { 3040 return result; 3041 } 3042 3043 result = Serialize_TPMI_RH_HIERARCHY(value.hierarchy, buffer); 3044 if (result) { 3045 return result; 3046 } 3047 3048 result = Serialize_TPM2B_DIGEST(value.digest, buffer); 3049 if (result) { 3050 return result; 3051 } 3052 return result; 3053 } 3054 3055 TPM_RC Parse_TPMT_TK_HASHCHECK(std::string* buffer, 3056 TPMT_TK_HASHCHECK* value, 3057 std::string* value_bytes) { 3058 TPM_RC result = TPM_RC_SUCCESS; 3059 VLOG(3) << __func__; 3060 3061 result = Parse_TPM_ST(buffer, &value->tag, value_bytes); 3062 if (result) { 3063 return result; 3064 } 3065 3066 result = Parse_TPMI_RH_HIERARCHY(buffer, &value->hierarchy, value_bytes); 3067 if (result) { 3068 return result; 3069 } 3070 3071 result = Parse_TPM2B_DIGEST(buffer, &value->digest, value_bytes); 3072 if (result) { 3073 return result; 3074 } 3075 return result; 3076 } 3077 3078 TPM_RC Serialize_TPMS_ALG_PROPERTY(const TPMS_ALG_PROPERTY& value, 3079 std::string* buffer) { 3080 TPM_RC result = TPM_RC_SUCCESS; 3081 VLOG(3) << __func__; 3082 3083 result = Serialize_TPM_ALG_ID(value.alg, buffer); 3084 if (result) { 3085 return result; 3086 } 3087 3088 result = Serialize_TPMA_ALGORITHM(value.alg_properties, buffer); 3089 if (result) { 3090 return result; 3091 } 3092 return result; 3093 } 3094 3095 TPM_RC Parse_TPMS_ALG_PROPERTY(std::string* buffer, 3096 TPMS_ALG_PROPERTY* value, 3097 std::string* value_bytes) { 3098 TPM_RC result = TPM_RC_SUCCESS; 3099 VLOG(3) << __func__; 3100 3101 result = Parse_TPM_ALG_ID(buffer, &value->alg, value_bytes); 3102 if (result) { 3103 return result; 3104 } 3105 3106 result = Parse_TPMA_ALGORITHM(buffer, &value->alg_properties, value_bytes); 3107 if (result) { 3108 return result; 3109 } 3110 return result; 3111 } 3112 3113 TPM_RC Serialize_TPMS_TAGGED_PROPERTY(const TPMS_TAGGED_PROPERTY& value, 3114 std::string* buffer) { 3115 TPM_RC result = TPM_RC_SUCCESS; 3116 VLOG(3) << __func__; 3117 3118 result = Serialize_TPM_PT(value.property, buffer); 3119 if (result) { 3120 return result; 3121 } 3122 3123 result = Serialize_UINT32(value.value, buffer); 3124 if (result) { 3125 return result; 3126 } 3127 return result; 3128 } 3129 3130 TPM_RC Parse_TPMS_TAGGED_PROPERTY(std::string* buffer, 3131 TPMS_TAGGED_PROPERTY* value, 3132 std::string* value_bytes) { 3133 TPM_RC result = TPM_RC_SUCCESS; 3134 VLOG(3) << __func__; 3135 3136 result = Parse_TPM_PT(buffer, &value->property, value_bytes); 3137 if (result) { 3138 return result; 3139 } 3140 3141 result = Parse_UINT32(buffer, &value->value, value_bytes); 3142 if (result) { 3143 return result; 3144 } 3145 return result; 3146 } 3147 3148 TPM_RC Serialize_TPMS_TAGGED_PCR_SELECT(const TPMS_TAGGED_PCR_SELECT& value, 3149 std::string* buffer) { 3150 TPM_RC result = TPM_RC_SUCCESS; 3151 VLOG(3) << __func__; 3152 3153 result = Serialize_TPM_PT(value.tag, buffer); 3154 if (result) { 3155 return result; 3156 } 3157 3158 result = Serialize_UINT8(value.sizeof_select, buffer); 3159 if (result) { 3160 return result; 3161 } 3162 3163 if (arraysize(value.pcr_select) < value.sizeof_select) { 3164 return TPM_RC_INSUFFICIENT; 3165 } 3166 for (uint32_t i = 0; i < value.sizeof_select; ++i) { 3167 result = Serialize_BYTE(value.pcr_select[i], buffer); 3168 if (result) { 3169 return result; 3170 } 3171 } 3172 return result; 3173 } 3174 3175 TPM_RC Parse_TPMS_TAGGED_PCR_SELECT(std::string* buffer, 3176 TPMS_TAGGED_PCR_SELECT* value, 3177 std::string* value_bytes) { 3178 TPM_RC result = TPM_RC_SUCCESS; 3179 VLOG(3) << __func__; 3180 3181 result = Parse_TPM_PT(buffer, &value->tag, value_bytes); 3182 if (result) { 3183 return result; 3184 } 3185 3186 result = Parse_UINT8(buffer, &value->sizeof_select, value_bytes); 3187 if (result) { 3188 return result; 3189 } 3190 3191 if (arraysize(value->pcr_select) < value->sizeof_select) { 3192 return TPM_RC_INSUFFICIENT; 3193 } 3194 for (uint32_t i = 0; i < value->sizeof_select; ++i) { 3195 result = Parse_BYTE(buffer, &value->pcr_select[i], value_bytes); 3196 if (result) { 3197 return result; 3198 } 3199 } 3200 return result; 3201 } 3202 3203 TPM_RC Serialize_TPML_CC(const TPML_CC& value, std::string* buffer) { 3204 TPM_RC result = TPM_RC_SUCCESS; 3205 VLOG(3) << __func__; 3206 3207 result = Serialize_UINT32(value.count, buffer); 3208 if (result) { 3209 return result; 3210 } 3211 3212 if (arraysize(value.command_codes) < value.count) { 3213 return TPM_RC_INSUFFICIENT; 3214 } 3215 for (uint32_t i = 0; i < value.count; ++i) { 3216 result = Serialize_TPM_CC(value.command_codes[i], buffer); 3217 if (result) { 3218 return result; 3219 } 3220 } 3221 return result; 3222 } 3223 3224 TPM_RC Parse_TPML_CC(std::string* buffer, 3225 TPML_CC* value, 3226 std::string* value_bytes) { 3227 TPM_RC result = TPM_RC_SUCCESS; 3228 VLOG(3) << __func__; 3229 3230 result = Parse_UINT32(buffer, &value->count, value_bytes); 3231 if (result) { 3232 return result; 3233 } 3234 3235 if (arraysize(value->command_codes) < value->count) { 3236 return TPM_RC_INSUFFICIENT; 3237 } 3238 for (uint32_t i = 0; i < value->count; ++i) { 3239 result = Parse_TPM_CC(buffer, &value->command_codes[i], value_bytes); 3240 if (result) { 3241 return result; 3242 } 3243 } 3244 return result; 3245 } 3246 3247 TPM_RC Serialize_TPML_CCA(const TPML_CCA& value, std::string* buffer) { 3248 TPM_RC result = TPM_RC_SUCCESS; 3249 VLOG(3) << __func__; 3250 3251 result = Serialize_UINT32(value.count, buffer); 3252 if (result) { 3253 return result; 3254 } 3255 3256 if (arraysize(value.command_attributes) < value.count) { 3257 return TPM_RC_INSUFFICIENT; 3258 } 3259 for (uint32_t i = 0; i < value.count; ++i) { 3260 result = Serialize_TPMA_CC(value.command_attributes[i], buffer); 3261 if (result) { 3262 return result; 3263 } 3264 } 3265 return result; 3266 } 3267 3268 TPM_RC Parse_TPML_CCA(std::string* buffer, 3269 TPML_CCA* value, 3270 std::string* value_bytes) { 3271 TPM_RC result = TPM_RC_SUCCESS; 3272 VLOG(3) << __func__; 3273 3274 result = Parse_UINT32(buffer, &value->count, value_bytes); 3275 if (result) { 3276 return result; 3277 } 3278 3279 if (arraysize(value->command_attributes) < value->count) { 3280 return TPM_RC_INSUFFICIENT; 3281 } 3282 for (uint32_t i = 0; i < value->count; ++i) { 3283 result = Parse_TPMA_CC(buffer, &value->command_attributes[i], value_bytes); 3284 if (result) { 3285 return result; 3286 } 3287 } 3288 return result; 3289 } 3290 3291 TPM_RC Serialize_TPML_ALG(const TPML_ALG& value, std::string* buffer) { 3292 TPM_RC result = TPM_RC_SUCCESS; 3293 VLOG(3) << __func__; 3294 3295 result = Serialize_UINT32(value.count, buffer); 3296 if (result) { 3297 return result; 3298 } 3299 3300 if (arraysize(value.algorithms) < value.count) { 3301 return TPM_RC_INSUFFICIENT; 3302 } 3303 for (uint32_t i = 0; i < value.count; ++i) { 3304 result = Serialize_TPM_ALG_ID(value.algorithms[i], buffer); 3305 if (result) { 3306 return result; 3307 } 3308 } 3309 return result; 3310 } 3311 3312 TPM_RC Parse_TPML_ALG(std::string* buffer, 3313 TPML_ALG* value, 3314 std::string* value_bytes) { 3315 TPM_RC result = TPM_RC_SUCCESS; 3316 VLOG(3) << __func__; 3317 3318 result = Parse_UINT32(buffer, &value->count, value_bytes); 3319 if (result) { 3320 return result; 3321 } 3322 3323 if (arraysize(value->algorithms) < value->count) { 3324 return TPM_RC_INSUFFICIENT; 3325 } 3326 for (uint32_t i = 0; i < value->count; ++i) { 3327 result = Parse_TPM_ALG_ID(buffer, &value->algorithms[i], value_bytes); 3328 if (result) { 3329 return result; 3330 } 3331 } 3332 return result; 3333 } 3334 3335 TPM_RC Serialize_TPML_HANDLE(const TPML_HANDLE& value, std::string* buffer) { 3336 TPM_RC result = TPM_RC_SUCCESS; 3337 VLOG(3) << __func__; 3338 3339 result = Serialize_UINT32(value.count, buffer); 3340 if (result) { 3341 return result; 3342 } 3343 3344 if (arraysize(value.handle) < value.count) { 3345 return TPM_RC_INSUFFICIENT; 3346 } 3347 for (uint32_t i = 0; i < value.count; ++i) { 3348 result = Serialize_TPM_HANDLE(value.handle[i], buffer); 3349 if (result) { 3350 return result; 3351 } 3352 } 3353 return result; 3354 } 3355 3356 TPM_RC Parse_TPML_HANDLE(std::string* buffer, 3357 TPML_HANDLE* value, 3358 std::string* value_bytes) { 3359 TPM_RC result = TPM_RC_SUCCESS; 3360 VLOG(3) << __func__; 3361 3362 result = Parse_UINT32(buffer, &value->count, value_bytes); 3363 if (result) { 3364 return result; 3365 } 3366 3367 if (arraysize(value->handle) < value->count) { 3368 return TPM_RC_INSUFFICIENT; 3369 } 3370 for (uint32_t i = 0; i < value->count; ++i) { 3371 result = Parse_TPM_HANDLE(buffer, &value->handle[i], value_bytes); 3372 if (result) { 3373 return result; 3374 } 3375 } 3376 return result; 3377 } 3378 3379 TPM_RC Serialize_TPML_DIGEST(const TPML_DIGEST& value, std::string* buffer) { 3380 TPM_RC result = TPM_RC_SUCCESS; 3381 VLOG(3) << __func__; 3382 3383 result = Serialize_UINT32(value.count, buffer); 3384 if (result) { 3385 return result; 3386 } 3387 3388 if (arraysize(value.digests) < value.count) { 3389 return TPM_RC_INSUFFICIENT; 3390 } 3391 for (uint32_t i = 0; i < value.count; ++i) { 3392 result = Serialize_TPM2B_DIGEST(value.digests[i], buffer); 3393 if (result) { 3394 return result; 3395 } 3396 } 3397 return result; 3398 } 3399 3400 TPM_RC Parse_TPML_DIGEST(std::string* buffer, 3401 TPML_DIGEST* value, 3402 std::string* value_bytes) { 3403 TPM_RC result = TPM_RC_SUCCESS; 3404 VLOG(3) << __func__; 3405 3406 result = Parse_UINT32(buffer, &value->count, value_bytes); 3407 if (result) { 3408 return result; 3409 } 3410 3411 if (arraysize(value->digests) < value->count) { 3412 return TPM_RC_INSUFFICIENT; 3413 } 3414 for (uint32_t i = 0; i < value->count; ++i) { 3415 result = Parse_TPM2B_DIGEST(buffer, &value->digests[i], value_bytes); 3416 if (result) { 3417 return result; 3418 } 3419 } 3420 return result; 3421 } 3422 3423 TPM_RC Serialize_TPML_DIGEST_VALUES(const TPML_DIGEST_VALUES& value, 3424 std::string* buffer) { 3425 TPM_RC result = TPM_RC_SUCCESS; 3426 VLOG(3) << __func__; 3427 3428 result = Serialize_UINT32(value.count, buffer); 3429 if (result) { 3430 return result; 3431 } 3432 3433 if (arraysize(value.digests) < value.count) { 3434 return TPM_RC_INSUFFICIENT; 3435 } 3436 for (uint32_t i = 0; i < value.count; ++i) { 3437 result = Serialize_TPMT_HA(value.digests[i], buffer); 3438 if (result) { 3439 return result; 3440 } 3441 } 3442 return result; 3443 } 3444 3445 TPM_RC Parse_TPML_DIGEST_VALUES(std::string* buffer, 3446 TPML_DIGEST_VALUES* value, 3447 std::string* value_bytes) { 3448 TPM_RC result = TPM_RC_SUCCESS; 3449 VLOG(3) << __func__; 3450 3451 result = Parse_UINT32(buffer, &value->count, value_bytes); 3452 if (result) { 3453 return result; 3454 } 3455 3456 if (arraysize(value->digests) < value->count) { 3457 return TPM_RC_INSUFFICIENT; 3458 } 3459 for (uint32_t i = 0; i < value->count; ++i) { 3460 result = Parse_TPMT_HA(buffer, &value->digests[i], value_bytes); 3461 if (result) { 3462 return result; 3463 } 3464 } 3465 return result; 3466 } 3467 3468 TPM_RC Serialize_TPM2B_DIGEST_VALUES(const TPM2B_DIGEST_VALUES& value, 3469 std::string* buffer) { 3470 TPM_RC result = TPM_RC_SUCCESS; 3471 VLOG(3) << __func__; 3472 3473 result = Serialize_UINT16(value.size, buffer); 3474 if (result) { 3475 return result; 3476 } 3477 3478 if (arraysize(value.buffer) < value.size) { 3479 return TPM_RC_INSUFFICIENT; 3480 } 3481 for (uint32_t i = 0; i < value.size; ++i) { 3482 result = Serialize_BYTE(value.buffer[i], buffer); 3483 if (result) { 3484 return result; 3485 } 3486 } 3487 return result; 3488 } 3489 3490 TPM_RC Parse_TPM2B_DIGEST_VALUES(std::string* buffer, 3491 TPM2B_DIGEST_VALUES* value, 3492 std::string* value_bytes) { 3493 TPM_RC result = TPM_RC_SUCCESS; 3494 VLOG(3) << __func__; 3495 3496 result = Parse_UINT16(buffer, &value->size, value_bytes); 3497 if (result) { 3498 return result; 3499 } 3500 3501 if (arraysize(value->buffer) < value->size) { 3502 return TPM_RC_INSUFFICIENT; 3503 } 3504 for (uint32_t i = 0; i < value->size; ++i) { 3505 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 3506 if (result) { 3507 return result; 3508 } 3509 } 3510 return result; 3511 } 3512 3513 TPM2B_DIGEST_VALUES Make_TPM2B_DIGEST_VALUES(const std::string& bytes) { 3514 TPM2B_DIGEST_VALUES tpm2b; 3515 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 3516 memset(&tpm2b, 0, sizeof(TPM2B_DIGEST_VALUES)); 3517 tpm2b.size = bytes.size(); 3518 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 3519 return tpm2b; 3520 } 3521 3522 std::string StringFrom_TPM2B_DIGEST_VALUES(const TPM2B_DIGEST_VALUES& tpm2b) { 3523 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 3524 return std::string(char_buffer, tpm2b.size); 3525 } 3526 3527 TPM_RC Serialize_TPML_PCR_SELECTION(const TPML_PCR_SELECTION& value, 3528 std::string* buffer) { 3529 TPM_RC result = TPM_RC_SUCCESS; 3530 VLOG(3) << __func__; 3531 3532 result = Serialize_UINT32(value.count, buffer); 3533 if (result) { 3534 return result; 3535 } 3536 3537 if (arraysize(value.pcr_selections) < value.count) { 3538 return TPM_RC_INSUFFICIENT; 3539 } 3540 for (uint32_t i = 0; i < value.count; ++i) { 3541 result = Serialize_TPMS_PCR_SELECTION(value.pcr_selections[i], buffer); 3542 if (result) { 3543 return result; 3544 } 3545 } 3546 return result; 3547 } 3548 3549 TPM_RC Parse_TPML_PCR_SELECTION(std::string* buffer, 3550 TPML_PCR_SELECTION* value, 3551 std::string* value_bytes) { 3552 TPM_RC result = TPM_RC_SUCCESS; 3553 VLOG(3) << __func__; 3554 3555 result = Parse_UINT32(buffer, &value->count, value_bytes); 3556 if (result) { 3557 return result; 3558 } 3559 3560 if (arraysize(value->pcr_selections) < value->count) { 3561 return TPM_RC_INSUFFICIENT; 3562 } 3563 for (uint32_t i = 0; i < value->count; ++i) { 3564 result = Parse_TPMS_PCR_SELECTION(buffer, &value->pcr_selections[i], 3565 value_bytes); 3566 if (result) { 3567 return result; 3568 } 3569 } 3570 return result; 3571 } 3572 3573 TPM_RC Serialize_TPML_ALG_PROPERTY(const TPML_ALG_PROPERTY& value, 3574 std::string* buffer) { 3575 TPM_RC result = TPM_RC_SUCCESS; 3576 VLOG(3) << __func__; 3577 3578 result = Serialize_UINT32(value.count, buffer); 3579 if (result) { 3580 return result; 3581 } 3582 3583 if (arraysize(value.alg_properties) < value.count) { 3584 return TPM_RC_INSUFFICIENT; 3585 } 3586 for (uint32_t i = 0; i < value.count; ++i) { 3587 result = Serialize_TPMS_ALG_PROPERTY(value.alg_properties[i], buffer); 3588 if (result) { 3589 return result; 3590 } 3591 } 3592 return result; 3593 } 3594 3595 TPM_RC Parse_TPML_ALG_PROPERTY(std::string* buffer, 3596 TPML_ALG_PROPERTY* value, 3597 std::string* value_bytes) { 3598 TPM_RC result = TPM_RC_SUCCESS; 3599 VLOG(3) << __func__; 3600 3601 result = Parse_UINT32(buffer, &value->count, value_bytes); 3602 if (result) { 3603 return result; 3604 } 3605 3606 if (arraysize(value->alg_properties) < value->count) { 3607 return TPM_RC_INSUFFICIENT; 3608 } 3609 for (uint32_t i = 0; i < value->count; ++i) { 3610 result = 3611 Parse_TPMS_ALG_PROPERTY(buffer, &value->alg_properties[i], value_bytes); 3612 if (result) { 3613 return result; 3614 } 3615 } 3616 return result; 3617 } 3618 3619 TPM_RC Serialize_TPML_TAGGED_TPM_PROPERTY(const TPML_TAGGED_TPM_PROPERTY& value, 3620 std::string* buffer) { 3621 TPM_RC result = TPM_RC_SUCCESS; 3622 VLOG(3) << __func__; 3623 3624 result = Serialize_UINT32(value.count, buffer); 3625 if (result) { 3626 return result; 3627 } 3628 3629 if (arraysize(value.tpm_property) < value.count) { 3630 return TPM_RC_INSUFFICIENT; 3631 } 3632 for (uint32_t i = 0; i < value.count; ++i) { 3633 result = Serialize_TPMS_TAGGED_PROPERTY(value.tpm_property[i], buffer); 3634 if (result) { 3635 return result; 3636 } 3637 } 3638 return result; 3639 } 3640 3641 TPM_RC Parse_TPML_TAGGED_TPM_PROPERTY(std::string* buffer, 3642 TPML_TAGGED_TPM_PROPERTY* value, 3643 std::string* value_bytes) { 3644 TPM_RC result = TPM_RC_SUCCESS; 3645 VLOG(3) << __func__; 3646 3647 result = Parse_UINT32(buffer, &value->count, value_bytes); 3648 if (result) { 3649 return result; 3650 } 3651 3652 if (arraysize(value->tpm_property) < value->count) { 3653 return TPM_RC_INSUFFICIENT; 3654 } 3655 for (uint32_t i = 0; i < value->count; ++i) { 3656 result = Parse_TPMS_TAGGED_PROPERTY(buffer, &value->tpm_property[i], 3657 value_bytes); 3658 if (result) { 3659 return result; 3660 } 3661 } 3662 return result; 3663 } 3664 3665 TPM_RC Serialize_TPML_TAGGED_PCR_PROPERTY(const TPML_TAGGED_PCR_PROPERTY& value, 3666 std::string* buffer) { 3667 TPM_RC result = TPM_RC_SUCCESS; 3668 VLOG(3) << __func__; 3669 3670 result = Serialize_UINT32(value.count, buffer); 3671 if (result) { 3672 return result; 3673 } 3674 3675 if (arraysize(value.pcr_property) < value.count) { 3676 return TPM_RC_INSUFFICIENT; 3677 } 3678 for (uint32_t i = 0; i < value.count; ++i) { 3679 result = Serialize_TPMS_TAGGED_PCR_SELECT(value.pcr_property[i], buffer); 3680 if (result) { 3681 return result; 3682 } 3683 } 3684 return result; 3685 } 3686 3687 TPM_RC Parse_TPML_TAGGED_PCR_PROPERTY(std::string* buffer, 3688 TPML_TAGGED_PCR_PROPERTY* value, 3689 std::string* value_bytes) { 3690 TPM_RC result = TPM_RC_SUCCESS; 3691 VLOG(3) << __func__; 3692 3693 result = Parse_UINT32(buffer, &value->count, value_bytes); 3694 if (result) { 3695 return result; 3696 } 3697 3698 if (arraysize(value->pcr_property) < value->count) { 3699 return TPM_RC_INSUFFICIENT; 3700 } 3701 for (uint32_t i = 0; i < value->count; ++i) { 3702 result = Parse_TPMS_TAGGED_PCR_SELECT(buffer, &value->pcr_property[i], 3703 value_bytes); 3704 if (result) { 3705 return result; 3706 } 3707 } 3708 return result; 3709 } 3710 3711 TPM_RC Serialize_TPML_ECC_CURVE(const TPML_ECC_CURVE& value, 3712 std::string* buffer) { 3713 TPM_RC result = TPM_RC_SUCCESS; 3714 VLOG(3) << __func__; 3715 3716 result = Serialize_UINT32(value.count, buffer); 3717 if (result) { 3718 return result; 3719 } 3720 3721 if (arraysize(value.ecc_curves) < value.count) { 3722 return TPM_RC_INSUFFICIENT; 3723 } 3724 for (uint32_t i = 0; i < value.count; ++i) { 3725 result = Serialize_TPM_ECC_CURVE(value.ecc_curves[i], buffer); 3726 if (result) { 3727 return result; 3728 } 3729 } 3730 return result; 3731 } 3732 3733 TPM_RC Parse_TPML_ECC_CURVE(std::string* buffer, 3734 TPML_ECC_CURVE* value, 3735 std::string* value_bytes) { 3736 TPM_RC result = TPM_RC_SUCCESS; 3737 VLOG(3) << __func__; 3738 3739 result = Parse_UINT32(buffer, &value->count, value_bytes); 3740 if (result) { 3741 return result; 3742 } 3743 3744 if (arraysize(value->ecc_curves) < value->count) { 3745 return TPM_RC_INSUFFICIENT; 3746 } 3747 for (uint32_t i = 0; i < value->count; ++i) { 3748 result = Parse_TPM_ECC_CURVE(buffer, &value->ecc_curves[i], value_bytes); 3749 if (result) { 3750 return result; 3751 } 3752 } 3753 return result; 3754 } 3755 3756 TPM_RC Serialize_TPMU_CAPABILITIES(const TPMU_CAPABILITIES& value, 3757 TPM_CAP selector, 3758 std::string* buffer) { 3759 TPM_RC result = TPM_RC_SUCCESS; 3760 VLOG(3) << __func__; 3761 3762 if (selector == TPM_CAP_PCRS) { 3763 result = Serialize_TPML_PCR_SELECTION(value.assigned_pcr, buffer); 3764 if (result) { 3765 return result; 3766 } 3767 } 3768 3769 if (selector == TPM_CAP_TPM_PROPERTIES) { 3770 result = Serialize_TPML_TAGGED_TPM_PROPERTY(value.tpm_properties, buffer); 3771 if (result) { 3772 return result; 3773 } 3774 } 3775 3776 if (selector == TPM_CAP_PP_COMMANDS) { 3777 result = Serialize_TPML_CC(value.pp_commands, buffer); 3778 if (result) { 3779 return result; 3780 } 3781 } 3782 3783 if (selector == TPM_CAP_AUDIT_COMMANDS) { 3784 result = Serialize_TPML_CC(value.audit_commands, buffer); 3785 if (result) { 3786 return result; 3787 } 3788 } 3789 3790 if (selector == TPM_CAP_COMMANDS) { 3791 result = Serialize_TPML_CCA(value.command, buffer); 3792 if (result) { 3793 return result; 3794 } 3795 } 3796 3797 if (selector == TPM_CAP_ECC_CURVES) { 3798 result = Serialize_TPML_ECC_CURVE(value.ecc_curves, buffer); 3799 if (result) { 3800 return result; 3801 } 3802 } 3803 3804 if (selector == TPM_CAP_PCR_PROPERTIES) { 3805 result = Serialize_TPML_TAGGED_PCR_PROPERTY(value.pcr_properties, buffer); 3806 if (result) { 3807 return result; 3808 } 3809 } 3810 3811 if (selector == TPM_CAP_HANDLES) { 3812 result = Serialize_TPML_HANDLE(value.handles, buffer); 3813 if (result) { 3814 return result; 3815 } 3816 } 3817 3818 if (selector == TPM_CAP_ALGS) { 3819 result = Serialize_TPML_ALG_PROPERTY(value.algorithms, buffer); 3820 if (result) { 3821 return result; 3822 } 3823 } 3824 return result; 3825 } 3826 3827 TPM_RC Parse_TPMU_CAPABILITIES(std::string* buffer, 3828 TPM_CAP selector, 3829 TPMU_CAPABILITIES* value, 3830 std::string* value_bytes) { 3831 TPM_RC result = TPM_RC_SUCCESS; 3832 VLOG(3) << __func__; 3833 3834 if (selector == TPM_CAP_PCRS) { 3835 result = 3836 Parse_TPML_PCR_SELECTION(buffer, &value->assigned_pcr, value_bytes); 3837 if (result) { 3838 return result; 3839 } 3840 } 3841 3842 if (selector == TPM_CAP_TPM_PROPERTIES) { 3843 result = Parse_TPML_TAGGED_TPM_PROPERTY(buffer, &value->tpm_properties, 3844 value_bytes); 3845 if (result) { 3846 return result; 3847 } 3848 } 3849 3850 if (selector == TPM_CAP_PP_COMMANDS) { 3851 result = Parse_TPML_CC(buffer, &value->pp_commands, value_bytes); 3852 if (result) { 3853 return result; 3854 } 3855 } 3856 3857 if (selector == TPM_CAP_AUDIT_COMMANDS) { 3858 result = Parse_TPML_CC(buffer, &value->audit_commands, value_bytes); 3859 if (result) { 3860 return result; 3861 } 3862 } 3863 3864 if (selector == TPM_CAP_COMMANDS) { 3865 result = Parse_TPML_CCA(buffer, &value->command, value_bytes); 3866 if (result) { 3867 return result; 3868 } 3869 } 3870 3871 if (selector == TPM_CAP_ECC_CURVES) { 3872 result = Parse_TPML_ECC_CURVE(buffer, &value->ecc_curves, value_bytes); 3873 if (result) { 3874 return result; 3875 } 3876 } 3877 3878 if (selector == TPM_CAP_PCR_PROPERTIES) { 3879 result = Parse_TPML_TAGGED_PCR_PROPERTY(buffer, &value->pcr_properties, 3880 value_bytes); 3881 if (result) { 3882 return result; 3883 } 3884 } 3885 3886 if (selector == TPM_CAP_HANDLES) { 3887 result = Parse_TPML_HANDLE(buffer, &value->handles, value_bytes); 3888 if (result) { 3889 return result; 3890 } 3891 } 3892 3893 if (selector == TPM_CAP_ALGS) { 3894 result = Parse_TPML_ALG_PROPERTY(buffer, &value->algorithms, value_bytes); 3895 if (result) { 3896 return result; 3897 } 3898 } 3899 return result; 3900 } 3901 3902 TPM_RC Serialize_TPMS_CAPABILITY_DATA(const TPMS_CAPABILITY_DATA& value, 3903 std::string* buffer) { 3904 TPM_RC result = TPM_RC_SUCCESS; 3905 VLOG(3) << __func__; 3906 3907 result = Serialize_TPM_CAP(value.capability, buffer); 3908 if (result) { 3909 return result; 3910 } 3911 3912 result = Serialize_TPMU_CAPABILITIES(value.data, value.capability, buffer); 3913 if (result) { 3914 return result; 3915 } 3916 return result; 3917 } 3918 3919 TPM_RC Parse_TPMS_CAPABILITY_DATA(std::string* buffer, 3920 TPMS_CAPABILITY_DATA* value, 3921 std::string* value_bytes) { 3922 TPM_RC result = TPM_RC_SUCCESS; 3923 VLOG(3) << __func__; 3924 3925 result = Parse_TPM_CAP(buffer, &value->capability, value_bytes); 3926 if (result) { 3927 return result; 3928 } 3929 3930 result = Parse_TPMU_CAPABILITIES(buffer, value->capability, &value->data, 3931 value_bytes); 3932 if (result) { 3933 return result; 3934 } 3935 return result; 3936 } 3937 3938 TPM_RC Serialize_TPMS_CLOCK_INFO(const TPMS_CLOCK_INFO& value, 3939 std::string* buffer) { 3940 TPM_RC result = TPM_RC_SUCCESS; 3941 VLOG(3) << __func__; 3942 3943 result = Serialize_UINT64(value.clock, buffer); 3944 if (result) { 3945 return result; 3946 } 3947 3948 result = Serialize_UINT32(value.reset_count, buffer); 3949 if (result) { 3950 return result; 3951 } 3952 3953 result = Serialize_UINT32(value.restart_count, buffer); 3954 if (result) { 3955 return result; 3956 } 3957 3958 result = Serialize_TPMI_YES_NO(value.safe, buffer); 3959 if (result) { 3960 return result; 3961 } 3962 return result; 3963 } 3964 3965 TPM_RC Parse_TPMS_CLOCK_INFO(std::string* buffer, 3966 TPMS_CLOCK_INFO* value, 3967 std::string* value_bytes) { 3968 TPM_RC result = TPM_RC_SUCCESS; 3969 VLOG(3) << __func__; 3970 3971 result = Parse_UINT64(buffer, &value->clock, value_bytes); 3972 if (result) { 3973 return result; 3974 } 3975 3976 result = Parse_UINT32(buffer, &value->reset_count, value_bytes); 3977 if (result) { 3978 return result; 3979 } 3980 3981 result = Parse_UINT32(buffer, &value->restart_count, value_bytes); 3982 if (result) { 3983 return result; 3984 } 3985 3986 result = Parse_TPMI_YES_NO(buffer, &value->safe, value_bytes); 3987 if (result) { 3988 return result; 3989 } 3990 return result; 3991 } 3992 3993 TPM_RC Serialize_TPMS_TIME_INFO(const TPMS_TIME_INFO& value, 3994 std::string* buffer) { 3995 TPM_RC result = TPM_RC_SUCCESS; 3996 VLOG(3) << __func__; 3997 3998 result = Serialize_UINT64(value.time, buffer); 3999 if (result) { 4000 return result; 4001 } 4002 4003 result = Serialize_TPMS_CLOCK_INFO(value.clock_info, buffer); 4004 if (result) { 4005 return result; 4006 } 4007 return result; 4008 } 4009 4010 TPM_RC Parse_TPMS_TIME_INFO(std::string* buffer, 4011 TPMS_TIME_INFO* value, 4012 std::string* value_bytes) { 4013 TPM_RC result = TPM_RC_SUCCESS; 4014 VLOG(3) << __func__; 4015 4016 result = Parse_UINT64(buffer, &value->time, value_bytes); 4017 if (result) { 4018 return result; 4019 } 4020 4021 result = Parse_TPMS_CLOCK_INFO(buffer, &value->clock_info, value_bytes); 4022 if (result) { 4023 return result; 4024 } 4025 return result; 4026 } 4027 4028 TPM_RC Serialize_TPMS_TIME_ATTEST_INFO(const TPMS_TIME_ATTEST_INFO& value, 4029 std::string* buffer) { 4030 TPM_RC result = TPM_RC_SUCCESS; 4031 VLOG(3) << __func__; 4032 4033 result = Serialize_TPMS_TIME_INFO(value.time, buffer); 4034 if (result) { 4035 return result; 4036 } 4037 4038 result = Serialize_UINT64(value.firmware_version, buffer); 4039 if (result) { 4040 return result; 4041 } 4042 return result; 4043 } 4044 4045 TPM_RC Parse_TPMS_TIME_ATTEST_INFO(std::string* buffer, 4046 TPMS_TIME_ATTEST_INFO* value, 4047 std::string* value_bytes) { 4048 TPM_RC result = TPM_RC_SUCCESS; 4049 VLOG(3) << __func__; 4050 4051 result = Parse_TPMS_TIME_INFO(buffer, &value->time, value_bytes); 4052 if (result) { 4053 return result; 4054 } 4055 4056 result = Parse_UINT64(buffer, &value->firmware_version, value_bytes); 4057 if (result) { 4058 return result; 4059 } 4060 return result; 4061 } 4062 4063 TPM_RC Serialize_TPMS_CERTIFY_INFO(const TPMS_CERTIFY_INFO& value, 4064 std::string* buffer) { 4065 TPM_RC result = TPM_RC_SUCCESS; 4066 VLOG(3) << __func__; 4067 4068 result = Serialize_TPM2B_NAME(value.name, buffer); 4069 if (result) { 4070 return result; 4071 } 4072 4073 result = Serialize_TPM2B_NAME(value.qualified_name, buffer); 4074 if (result) { 4075 return result; 4076 } 4077 return result; 4078 } 4079 4080 TPM_RC Parse_TPMS_CERTIFY_INFO(std::string* buffer, 4081 TPMS_CERTIFY_INFO* value, 4082 std::string* value_bytes) { 4083 TPM_RC result = TPM_RC_SUCCESS; 4084 VLOG(3) << __func__; 4085 4086 result = Parse_TPM2B_NAME(buffer, &value->name, value_bytes); 4087 if (result) { 4088 return result; 4089 } 4090 4091 result = Parse_TPM2B_NAME(buffer, &value->qualified_name, value_bytes); 4092 if (result) { 4093 return result; 4094 } 4095 return result; 4096 } 4097 4098 TPM_RC Serialize_TPMS_QUOTE_INFO(const TPMS_QUOTE_INFO& value, 4099 std::string* buffer) { 4100 TPM_RC result = TPM_RC_SUCCESS; 4101 VLOG(3) << __func__; 4102 4103 result = Serialize_TPML_PCR_SELECTION(value.pcr_select, buffer); 4104 if (result) { 4105 return result; 4106 } 4107 4108 result = Serialize_TPM2B_DIGEST(value.pcr_digest, buffer); 4109 if (result) { 4110 return result; 4111 } 4112 return result; 4113 } 4114 4115 TPM_RC Parse_TPMS_QUOTE_INFO(std::string* buffer, 4116 TPMS_QUOTE_INFO* value, 4117 std::string* value_bytes) { 4118 TPM_RC result = TPM_RC_SUCCESS; 4119 VLOG(3) << __func__; 4120 4121 result = Parse_TPML_PCR_SELECTION(buffer, &value->pcr_select, value_bytes); 4122 if (result) { 4123 return result; 4124 } 4125 4126 result = Parse_TPM2B_DIGEST(buffer, &value->pcr_digest, value_bytes); 4127 if (result) { 4128 return result; 4129 } 4130 return result; 4131 } 4132 4133 TPM_RC Serialize_TPMS_COMMAND_AUDIT_INFO(const TPMS_COMMAND_AUDIT_INFO& value, 4134 std::string* buffer) { 4135 TPM_RC result = TPM_RC_SUCCESS; 4136 VLOG(3) << __func__; 4137 4138 result = Serialize_UINT64(value.audit_counter, buffer); 4139 if (result) { 4140 return result; 4141 } 4142 4143 result = Serialize_TPM_ALG_ID(value.digest_alg, buffer); 4144 if (result) { 4145 return result; 4146 } 4147 4148 result = Serialize_TPM2B_DIGEST(value.audit_digest, buffer); 4149 if (result) { 4150 return result; 4151 } 4152 4153 result = Serialize_TPM2B_DIGEST(value.command_digest, buffer); 4154 if (result) { 4155 return result; 4156 } 4157 return result; 4158 } 4159 4160 TPM_RC Parse_TPMS_COMMAND_AUDIT_INFO(std::string* buffer, 4161 TPMS_COMMAND_AUDIT_INFO* value, 4162 std::string* value_bytes) { 4163 TPM_RC result = TPM_RC_SUCCESS; 4164 VLOG(3) << __func__; 4165 4166 result = Parse_UINT64(buffer, &value->audit_counter, value_bytes); 4167 if (result) { 4168 return result; 4169 } 4170 4171 result = Parse_TPM_ALG_ID(buffer, &value->digest_alg, value_bytes); 4172 if (result) { 4173 return result; 4174 } 4175 4176 result = Parse_TPM2B_DIGEST(buffer, &value->audit_digest, value_bytes); 4177 if (result) { 4178 return result; 4179 } 4180 4181 result = Parse_TPM2B_DIGEST(buffer, &value->command_digest, value_bytes); 4182 if (result) { 4183 return result; 4184 } 4185 return result; 4186 } 4187 4188 TPM_RC Serialize_TPMS_SESSION_AUDIT_INFO(const TPMS_SESSION_AUDIT_INFO& value, 4189 std::string* buffer) { 4190 TPM_RC result = TPM_RC_SUCCESS; 4191 VLOG(3) << __func__; 4192 4193 result = Serialize_TPMI_YES_NO(value.exclusive_session, buffer); 4194 if (result) { 4195 return result; 4196 } 4197 4198 result = Serialize_TPM2B_DIGEST(value.session_digest, buffer); 4199 if (result) { 4200 return result; 4201 } 4202 return result; 4203 } 4204 4205 TPM_RC Parse_TPMS_SESSION_AUDIT_INFO(std::string* buffer, 4206 TPMS_SESSION_AUDIT_INFO* value, 4207 std::string* value_bytes) { 4208 TPM_RC result = TPM_RC_SUCCESS; 4209 VLOG(3) << __func__; 4210 4211 result = Parse_TPMI_YES_NO(buffer, &value->exclusive_session, value_bytes); 4212 if (result) { 4213 return result; 4214 } 4215 4216 result = Parse_TPM2B_DIGEST(buffer, &value->session_digest, value_bytes); 4217 if (result) { 4218 return result; 4219 } 4220 return result; 4221 } 4222 4223 TPM_RC Serialize_TPMS_CREATION_INFO(const TPMS_CREATION_INFO& value, 4224 std::string* buffer) { 4225 TPM_RC result = TPM_RC_SUCCESS; 4226 VLOG(3) << __func__; 4227 4228 result = Serialize_TPM2B_NAME(value.object_name, buffer); 4229 if (result) { 4230 return result; 4231 } 4232 4233 result = Serialize_TPM2B_DIGEST(value.creation_hash, buffer); 4234 if (result) { 4235 return result; 4236 } 4237 return result; 4238 } 4239 4240 TPM_RC Parse_TPMS_CREATION_INFO(std::string* buffer, 4241 TPMS_CREATION_INFO* value, 4242 std::string* value_bytes) { 4243 TPM_RC result = TPM_RC_SUCCESS; 4244 VLOG(3) << __func__; 4245 4246 result = Parse_TPM2B_NAME(buffer, &value->object_name, value_bytes); 4247 if (result) { 4248 return result; 4249 } 4250 4251 result = Parse_TPM2B_DIGEST(buffer, &value->creation_hash, value_bytes); 4252 if (result) { 4253 return result; 4254 } 4255 return result; 4256 } 4257 4258 TPM_RC Serialize_TPMS_NV_CERTIFY_INFO(const TPMS_NV_CERTIFY_INFO& value, 4259 std::string* buffer) { 4260 TPM_RC result = TPM_RC_SUCCESS; 4261 VLOG(3) << __func__; 4262 4263 result = Serialize_TPM2B_NAME(value.index_name, buffer); 4264 if (result) { 4265 return result; 4266 } 4267 4268 result = Serialize_UINT16(value.offset, buffer); 4269 if (result) { 4270 return result; 4271 } 4272 4273 result = Serialize_TPM2B_MAX_NV_BUFFER(value.nv_contents, buffer); 4274 if (result) { 4275 return result; 4276 } 4277 return result; 4278 } 4279 4280 TPM_RC Parse_TPMS_NV_CERTIFY_INFO(std::string* buffer, 4281 TPMS_NV_CERTIFY_INFO* value, 4282 std::string* value_bytes) { 4283 TPM_RC result = TPM_RC_SUCCESS; 4284 VLOG(3) << __func__; 4285 4286 result = Parse_TPM2B_NAME(buffer, &value->index_name, value_bytes); 4287 if (result) { 4288 return result; 4289 } 4290 4291 result = Parse_UINT16(buffer, &value->offset, value_bytes); 4292 if (result) { 4293 return result; 4294 } 4295 4296 result = Parse_TPM2B_MAX_NV_BUFFER(buffer, &value->nv_contents, value_bytes); 4297 if (result) { 4298 return result; 4299 } 4300 return result; 4301 } 4302 4303 TPM_RC Serialize_TPMU_ATTEST(const TPMU_ATTEST& value, 4304 TPMI_ST_ATTEST selector, 4305 std::string* buffer) { 4306 TPM_RC result = TPM_RC_SUCCESS; 4307 VLOG(3) << __func__; 4308 4309 if (selector == TPM_ST_ATTEST_SESSION_AUDIT) { 4310 result = Serialize_TPMS_SESSION_AUDIT_INFO(value.session_audit, buffer); 4311 if (result) { 4312 return result; 4313 } 4314 } 4315 4316 if (selector == TPM_ST_ATTEST_QUOTE) { 4317 result = Serialize_TPMS_QUOTE_INFO(value.quote, buffer); 4318 if (result) { 4319 return result; 4320 } 4321 } 4322 4323 if (selector == TPM_ST_ATTEST_COMMAND_AUDIT) { 4324 result = Serialize_TPMS_COMMAND_AUDIT_INFO(value.command_audit, buffer); 4325 if (result) { 4326 return result; 4327 } 4328 } 4329 4330 if (selector == TPM_ST_ATTEST_CERTIFY) { 4331 result = Serialize_TPMS_CERTIFY_INFO(value.certify, buffer); 4332 if (result) { 4333 return result; 4334 } 4335 } 4336 4337 if (selector == TPM_ST_ATTEST_NV) { 4338 result = Serialize_TPMS_NV_CERTIFY_INFO(value.nv, buffer); 4339 if (result) { 4340 return result; 4341 } 4342 } 4343 4344 if (selector == TPM_ST_ATTEST_TIME) { 4345 result = Serialize_TPMS_TIME_ATTEST_INFO(value.time, buffer); 4346 if (result) { 4347 return result; 4348 } 4349 } 4350 4351 if (selector == TPM_ST_ATTEST_CREATION) { 4352 result = Serialize_TPMS_CREATION_INFO(value.creation, buffer); 4353 if (result) { 4354 return result; 4355 } 4356 } 4357 return result; 4358 } 4359 4360 TPM_RC Parse_TPMU_ATTEST(std::string* buffer, 4361 TPMI_ST_ATTEST selector, 4362 TPMU_ATTEST* value, 4363 std::string* value_bytes) { 4364 TPM_RC result = TPM_RC_SUCCESS; 4365 VLOG(3) << __func__; 4366 4367 if (selector == TPM_ST_ATTEST_SESSION_AUDIT) { 4368 result = Parse_TPMS_SESSION_AUDIT_INFO(buffer, &value->session_audit, 4369 value_bytes); 4370 if (result) { 4371 return result; 4372 } 4373 } 4374 4375 if (selector == TPM_ST_ATTEST_QUOTE) { 4376 result = Parse_TPMS_QUOTE_INFO(buffer, &value->quote, value_bytes); 4377 if (result) { 4378 return result; 4379 } 4380 } 4381 4382 if (selector == TPM_ST_ATTEST_COMMAND_AUDIT) { 4383 result = Parse_TPMS_COMMAND_AUDIT_INFO(buffer, &value->command_audit, 4384 value_bytes); 4385 if (result) { 4386 return result; 4387 } 4388 } 4389 4390 if (selector == TPM_ST_ATTEST_CERTIFY) { 4391 result = Parse_TPMS_CERTIFY_INFO(buffer, &value->certify, value_bytes); 4392 if (result) { 4393 return result; 4394 } 4395 } 4396 4397 if (selector == TPM_ST_ATTEST_NV) { 4398 result = Parse_TPMS_NV_CERTIFY_INFO(buffer, &value->nv, value_bytes); 4399 if (result) { 4400 return result; 4401 } 4402 } 4403 4404 if (selector == TPM_ST_ATTEST_TIME) { 4405 result = Parse_TPMS_TIME_ATTEST_INFO(buffer, &value->time, value_bytes); 4406 if (result) { 4407 return result; 4408 } 4409 } 4410 4411 if (selector == TPM_ST_ATTEST_CREATION) { 4412 result = Parse_TPMS_CREATION_INFO(buffer, &value->creation, value_bytes); 4413 if (result) { 4414 return result; 4415 } 4416 } 4417 return result; 4418 } 4419 4420 TPM_RC Serialize_TPMS_ATTEST(const TPMS_ATTEST& value, std::string* buffer) { 4421 TPM_RC result = TPM_RC_SUCCESS; 4422 VLOG(3) << __func__; 4423 4424 result = Serialize_TPM_GENERATED(value.magic, buffer); 4425 if (result) { 4426 return result; 4427 } 4428 4429 result = Serialize_TPMI_ST_ATTEST(value.type, buffer); 4430 if (result) { 4431 return result; 4432 } 4433 4434 result = Serialize_TPM2B_NAME(value.qualified_signer, buffer); 4435 if (result) { 4436 return result; 4437 } 4438 4439 result = Serialize_TPM2B_DATA(value.extra_data, buffer); 4440 if (result) { 4441 return result; 4442 } 4443 4444 result = Serialize_TPMS_CLOCK_INFO(value.clock_info, buffer); 4445 if (result) { 4446 return result; 4447 } 4448 4449 result = Serialize_UINT64(value.firmware_version, buffer); 4450 if (result) { 4451 return result; 4452 } 4453 4454 result = Serialize_TPMU_ATTEST(value.attested, value.type, buffer); 4455 if (result) { 4456 return result; 4457 } 4458 return result; 4459 } 4460 4461 TPM_RC Parse_TPMS_ATTEST(std::string* buffer, 4462 TPMS_ATTEST* value, 4463 std::string* value_bytes) { 4464 TPM_RC result = TPM_RC_SUCCESS; 4465 VLOG(3) << __func__; 4466 4467 result = Parse_TPM_GENERATED(buffer, &value->magic, value_bytes); 4468 if (result) { 4469 return result; 4470 } 4471 4472 result = Parse_TPMI_ST_ATTEST(buffer, &value->type, value_bytes); 4473 if (result) { 4474 return result; 4475 } 4476 4477 result = Parse_TPM2B_NAME(buffer, &value->qualified_signer, value_bytes); 4478 if (result) { 4479 return result; 4480 } 4481 4482 result = Parse_TPM2B_DATA(buffer, &value->extra_data, value_bytes); 4483 if (result) { 4484 return result; 4485 } 4486 4487 result = Parse_TPMS_CLOCK_INFO(buffer, &value->clock_info, value_bytes); 4488 if (result) { 4489 return result; 4490 } 4491 4492 result = Parse_UINT64(buffer, &value->firmware_version, value_bytes); 4493 if (result) { 4494 return result; 4495 } 4496 4497 result = 4498 Parse_TPMU_ATTEST(buffer, value->type, &value->attested, value_bytes); 4499 if (result) { 4500 return result; 4501 } 4502 return result; 4503 } 4504 4505 TPM_RC Serialize_TPM2B_ATTEST(const TPM2B_ATTEST& value, std::string* buffer) { 4506 TPM_RC result = TPM_RC_SUCCESS; 4507 VLOG(3) << __func__; 4508 4509 result = Serialize_UINT16(value.size, buffer); 4510 if (result) { 4511 return result; 4512 } 4513 4514 if (arraysize(value.attestation_data) < value.size) { 4515 return TPM_RC_INSUFFICIENT; 4516 } 4517 for (uint32_t i = 0; i < value.size; ++i) { 4518 result = Serialize_BYTE(value.attestation_data[i], buffer); 4519 if (result) { 4520 return result; 4521 } 4522 } 4523 return result; 4524 } 4525 4526 TPM_RC Parse_TPM2B_ATTEST(std::string* buffer, 4527 TPM2B_ATTEST* value, 4528 std::string* value_bytes) { 4529 TPM_RC result = TPM_RC_SUCCESS; 4530 VLOG(3) << __func__; 4531 4532 result = Parse_UINT16(buffer, &value->size, value_bytes); 4533 if (result) { 4534 return result; 4535 } 4536 4537 if (arraysize(value->attestation_data) < value->size) { 4538 return TPM_RC_INSUFFICIENT; 4539 } 4540 for (uint32_t i = 0; i < value->size; ++i) { 4541 result = Parse_BYTE(buffer, &value->attestation_data[i], value_bytes); 4542 if (result) { 4543 return result; 4544 } 4545 } 4546 return result; 4547 } 4548 4549 TPM2B_ATTEST Make_TPM2B_ATTEST(const std::string& bytes) { 4550 TPM2B_ATTEST tpm2b; 4551 CHECK(bytes.size() <= sizeof(tpm2b.attestation_data)); 4552 memset(&tpm2b, 0, sizeof(TPM2B_ATTEST)); 4553 tpm2b.size = bytes.size(); 4554 memcpy(tpm2b.attestation_data, bytes.data(), bytes.size()); 4555 return tpm2b; 4556 } 4557 4558 std::string StringFrom_TPM2B_ATTEST(const TPM2B_ATTEST& tpm2b) { 4559 const char* char_buffer = 4560 reinterpret_cast<const char*>(tpm2b.attestation_data); 4561 return std::string(char_buffer, tpm2b.size); 4562 } 4563 4564 TPM_RC Serialize_TPMS_AUTH_COMMAND(const TPMS_AUTH_COMMAND& value, 4565 std::string* buffer) { 4566 TPM_RC result = TPM_RC_SUCCESS; 4567 VLOG(3) << __func__; 4568 4569 result = Serialize_TPMI_SH_AUTH_SESSION(value.session_handle, buffer); 4570 if (result) { 4571 return result; 4572 } 4573 4574 result = Serialize_TPM2B_NONCE(value.nonce, buffer); 4575 if (result) { 4576 return result; 4577 } 4578 4579 result = Serialize_TPMA_SESSION(value.session_attributes, buffer); 4580 if (result) { 4581 return result; 4582 } 4583 4584 result = Serialize_TPM2B_AUTH(value.hmac, buffer); 4585 if (result) { 4586 return result; 4587 } 4588 return result; 4589 } 4590 4591 TPM_RC Parse_TPMS_AUTH_COMMAND(std::string* buffer, 4592 TPMS_AUTH_COMMAND* value, 4593 std::string* value_bytes) { 4594 TPM_RC result = TPM_RC_SUCCESS; 4595 VLOG(3) << __func__; 4596 4597 result = 4598 Parse_TPMI_SH_AUTH_SESSION(buffer, &value->session_handle, value_bytes); 4599 if (result) { 4600 return result; 4601 } 4602 4603 result = Parse_TPM2B_NONCE(buffer, &value->nonce, value_bytes); 4604 if (result) { 4605 return result; 4606 } 4607 4608 result = Parse_TPMA_SESSION(buffer, &value->session_attributes, value_bytes); 4609 if (result) { 4610 return result; 4611 } 4612 4613 result = Parse_TPM2B_AUTH(buffer, &value->hmac, value_bytes); 4614 if (result) { 4615 return result; 4616 } 4617 return result; 4618 } 4619 4620 TPM_RC Serialize_TPMS_AUTH_RESPONSE(const TPMS_AUTH_RESPONSE& value, 4621 std::string* buffer) { 4622 TPM_RC result = TPM_RC_SUCCESS; 4623 VLOG(3) << __func__; 4624 4625 result = Serialize_TPM2B_NONCE(value.nonce, buffer); 4626 if (result) { 4627 return result; 4628 } 4629 4630 result = Serialize_TPMA_SESSION(value.session_attributes, buffer); 4631 if (result) { 4632 return result; 4633 } 4634 4635 result = Serialize_TPM2B_AUTH(value.hmac, buffer); 4636 if (result) { 4637 return result; 4638 } 4639 return result; 4640 } 4641 4642 TPM_RC Parse_TPMS_AUTH_RESPONSE(std::string* buffer, 4643 TPMS_AUTH_RESPONSE* value, 4644 std::string* value_bytes) { 4645 TPM_RC result = TPM_RC_SUCCESS; 4646 VLOG(3) << __func__; 4647 4648 result = Parse_TPM2B_NONCE(buffer, &value->nonce, value_bytes); 4649 if (result) { 4650 return result; 4651 } 4652 4653 result = Parse_TPMA_SESSION(buffer, &value->session_attributes, value_bytes); 4654 if (result) { 4655 return result; 4656 } 4657 4658 result = Parse_TPM2B_AUTH(buffer, &value->hmac, value_bytes); 4659 if (result) { 4660 return result; 4661 } 4662 return result; 4663 } 4664 4665 TPM_RC Serialize_TPMU_SYM_KEY_BITS(const TPMU_SYM_KEY_BITS& value, 4666 TPMI_ALG_SYM selector, 4667 std::string* buffer) { 4668 TPM_RC result = TPM_RC_SUCCESS; 4669 VLOG(3) << __func__; 4670 4671 if (selector == TPM_ALG_NULL) { 4672 // Do nothing. 4673 } 4674 4675 if (selector == TPM_ALG_SM4) { 4676 result = Serialize_TPMI_SM4_KEY_BITS(value.sm4, buffer); 4677 if (result) { 4678 return result; 4679 } 4680 } 4681 4682 if (selector == TPM_ALG_AES) { 4683 result = Serialize_TPMI_AES_KEY_BITS(value.aes, buffer); 4684 if (result) { 4685 return result; 4686 } 4687 } 4688 4689 if (selector == TPM_ALG_XOR) { 4690 result = Serialize_TPMI_ALG_HASH(value.xor_, buffer); 4691 if (result) { 4692 return result; 4693 } 4694 } 4695 return result; 4696 } 4697 4698 TPM_RC Parse_TPMU_SYM_KEY_BITS(std::string* buffer, 4699 TPMI_ALG_SYM selector, 4700 TPMU_SYM_KEY_BITS* value, 4701 std::string* value_bytes) { 4702 TPM_RC result = TPM_RC_SUCCESS; 4703 VLOG(3) << __func__; 4704 4705 if (selector == TPM_ALG_NULL) { 4706 // Do nothing. 4707 } 4708 4709 if (selector == TPM_ALG_SM4) { 4710 result = Parse_TPMI_SM4_KEY_BITS(buffer, &value->sm4, value_bytes); 4711 if (result) { 4712 return result; 4713 } 4714 } 4715 4716 if (selector == TPM_ALG_AES) { 4717 result = Parse_TPMI_AES_KEY_BITS(buffer, &value->aes, value_bytes); 4718 if (result) { 4719 return result; 4720 } 4721 } 4722 4723 if (selector == TPM_ALG_XOR) { 4724 result = Parse_TPMI_ALG_HASH(buffer, &value->xor_, value_bytes); 4725 if (result) { 4726 return result; 4727 } 4728 } 4729 return result; 4730 } 4731 4732 TPM_RC Serialize_TPMU_SYM_MODE(const TPMU_SYM_MODE& value, 4733 TPMI_ALG_SYM selector, 4734 std::string* buffer) { 4735 TPM_RC result = TPM_RC_SUCCESS; 4736 VLOG(3) << __func__; 4737 4738 if (selector == TPM_ALG_NULL) { 4739 // Do nothing. 4740 } 4741 4742 if (selector == TPM_ALG_SM4) { 4743 result = Serialize_TPMI_ALG_SYM_MODE(value.sm4, buffer); 4744 if (result) { 4745 return result; 4746 } 4747 } 4748 4749 if (selector == TPM_ALG_AES) { 4750 result = Serialize_TPMI_ALG_SYM_MODE(value.aes, buffer); 4751 if (result) { 4752 return result; 4753 } 4754 } 4755 4756 if (selector == TPM_ALG_XOR) { 4757 // Do nothing. 4758 } 4759 return result; 4760 } 4761 4762 TPM_RC Parse_TPMU_SYM_MODE(std::string* buffer, 4763 TPMI_ALG_SYM selector, 4764 TPMU_SYM_MODE* value, 4765 std::string* value_bytes) { 4766 TPM_RC result = TPM_RC_SUCCESS; 4767 VLOG(3) << __func__; 4768 4769 if (selector == TPM_ALG_NULL) { 4770 // Do nothing. 4771 } 4772 4773 if (selector == TPM_ALG_SM4) { 4774 result = Parse_TPMI_ALG_SYM_MODE(buffer, &value->sm4, value_bytes); 4775 if (result) { 4776 return result; 4777 } 4778 } 4779 4780 if (selector == TPM_ALG_AES) { 4781 result = Parse_TPMI_ALG_SYM_MODE(buffer, &value->aes, value_bytes); 4782 if (result) { 4783 return result; 4784 } 4785 } 4786 4787 if (selector == TPM_ALG_XOR) { 4788 // Do nothing. 4789 } 4790 return result; 4791 } 4792 4793 TPM_RC Serialize_TPMU_SYM_DETAILS(const TPMU_SYM_DETAILS& value, 4794 TPMI_ALG_SYM selector, 4795 std::string* buffer) { 4796 TPM_RC result = TPM_RC_SUCCESS; 4797 VLOG(3) << __func__; 4798 return result; 4799 } 4800 4801 TPM_RC Parse_TPMU_SYM_DETAILS(std::string* buffer, 4802 TPMI_ALG_SYM selector, 4803 TPMU_SYM_DETAILS* value, 4804 std::string* value_bytes) { 4805 TPM_RC result = TPM_RC_SUCCESS; 4806 VLOG(3) << __func__; 4807 return result; 4808 } 4809 4810 TPM_RC Serialize_TPMT_SYM_DEF(const TPMT_SYM_DEF& value, std::string* buffer) { 4811 TPM_RC result = TPM_RC_SUCCESS; 4812 VLOG(3) << __func__; 4813 4814 result = Serialize_TPMI_ALG_SYM(value.algorithm, buffer); 4815 if (result) { 4816 return result; 4817 } 4818 4819 result = Serialize_TPMU_SYM_KEY_BITS(value.key_bits, value.algorithm, buffer); 4820 if (result) { 4821 return result; 4822 } 4823 4824 result = Serialize_TPMU_SYM_MODE(value.mode, value.algorithm, buffer); 4825 if (result) { 4826 return result; 4827 } 4828 4829 result = Serialize_TPMU_SYM_DETAILS(value.details, value.algorithm, buffer); 4830 if (result) { 4831 return result; 4832 } 4833 return result; 4834 } 4835 4836 TPM_RC Parse_TPMT_SYM_DEF(std::string* buffer, 4837 TPMT_SYM_DEF* value, 4838 std::string* value_bytes) { 4839 TPM_RC result = TPM_RC_SUCCESS; 4840 VLOG(3) << __func__; 4841 4842 result = Parse_TPMI_ALG_SYM(buffer, &value->algorithm, value_bytes); 4843 if (result) { 4844 return result; 4845 } 4846 4847 result = Parse_TPMU_SYM_KEY_BITS(buffer, value->algorithm, &value->key_bits, 4848 value_bytes); 4849 if (result) { 4850 return result; 4851 } 4852 4853 result = 4854 Parse_TPMU_SYM_MODE(buffer, value->algorithm, &value->mode, value_bytes); 4855 if (result) { 4856 return result; 4857 } 4858 4859 result = Parse_TPMU_SYM_DETAILS(buffer, value->algorithm, &value->details, 4860 value_bytes); 4861 if (result) { 4862 return result; 4863 } 4864 return result; 4865 } 4866 4867 TPM_RC Serialize_TPMT_SYM_DEF_OBJECT(const TPMT_SYM_DEF_OBJECT& value, 4868 std::string* buffer) { 4869 TPM_RC result = TPM_RC_SUCCESS; 4870 VLOG(3) << __func__; 4871 4872 result = Serialize_TPMI_ALG_SYM_OBJECT(value.algorithm, buffer); 4873 if (result) { 4874 return result; 4875 } 4876 4877 result = Serialize_TPMU_SYM_KEY_BITS(value.key_bits, value.algorithm, buffer); 4878 if (result) { 4879 return result; 4880 } 4881 4882 result = Serialize_TPMU_SYM_MODE(value.mode, value.algorithm, buffer); 4883 if (result) { 4884 return result; 4885 } 4886 4887 result = Serialize_TPMU_SYM_DETAILS(value.details, value.algorithm, buffer); 4888 if (result) { 4889 return result; 4890 } 4891 return result; 4892 } 4893 4894 TPM_RC Parse_TPMT_SYM_DEF_OBJECT(std::string* buffer, 4895 TPMT_SYM_DEF_OBJECT* value, 4896 std::string* value_bytes) { 4897 TPM_RC result = TPM_RC_SUCCESS; 4898 VLOG(3) << __func__; 4899 4900 result = Parse_TPMI_ALG_SYM_OBJECT(buffer, &value->algorithm, value_bytes); 4901 if (result) { 4902 return result; 4903 } 4904 4905 result = Parse_TPMU_SYM_KEY_BITS(buffer, value->algorithm, &value->key_bits, 4906 value_bytes); 4907 if (result) { 4908 return result; 4909 } 4910 4911 result = 4912 Parse_TPMU_SYM_MODE(buffer, value->algorithm, &value->mode, value_bytes); 4913 if (result) { 4914 return result; 4915 } 4916 4917 result = Parse_TPMU_SYM_DETAILS(buffer, value->algorithm, &value->details, 4918 value_bytes); 4919 if (result) { 4920 return result; 4921 } 4922 return result; 4923 } 4924 4925 TPM_RC Serialize_TPM2B_SYM_KEY(const TPM2B_SYM_KEY& value, 4926 std::string* buffer) { 4927 TPM_RC result = TPM_RC_SUCCESS; 4928 VLOG(3) << __func__; 4929 4930 result = Serialize_UINT16(value.size, buffer); 4931 if (result) { 4932 return result; 4933 } 4934 4935 if (arraysize(value.buffer) < value.size) { 4936 return TPM_RC_INSUFFICIENT; 4937 } 4938 for (uint32_t i = 0; i < value.size; ++i) { 4939 result = Serialize_BYTE(value.buffer[i], buffer); 4940 if (result) { 4941 return result; 4942 } 4943 } 4944 return result; 4945 } 4946 4947 TPM_RC Parse_TPM2B_SYM_KEY(std::string* buffer, 4948 TPM2B_SYM_KEY* value, 4949 std::string* value_bytes) { 4950 TPM_RC result = TPM_RC_SUCCESS; 4951 VLOG(3) << __func__; 4952 4953 result = Parse_UINT16(buffer, &value->size, value_bytes); 4954 if (result) { 4955 return result; 4956 } 4957 4958 if (arraysize(value->buffer) < value->size) { 4959 return TPM_RC_INSUFFICIENT; 4960 } 4961 for (uint32_t i = 0; i < value->size; ++i) { 4962 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 4963 if (result) { 4964 return result; 4965 } 4966 } 4967 return result; 4968 } 4969 4970 TPM2B_SYM_KEY Make_TPM2B_SYM_KEY(const std::string& bytes) { 4971 TPM2B_SYM_KEY tpm2b; 4972 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 4973 memset(&tpm2b, 0, sizeof(TPM2B_SYM_KEY)); 4974 tpm2b.size = bytes.size(); 4975 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 4976 return tpm2b; 4977 } 4978 4979 std::string StringFrom_TPM2B_SYM_KEY(const TPM2B_SYM_KEY& tpm2b) { 4980 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 4981 return std::string(char_buffer, tpm2b.size); 4982 } 4983 4984 TPM_RC Serialize_TPMS_SYMCIPHER_PARMS(const TPMS_SYMCIPHER_PARMS& value, 4985 std::string* buffer) { 4986 TPM_RC result = TPM_RC_SUCCESS; 4987 VLOG(3) << __func__; 4988 4989 result = Serialize_TPMT_SYM_DEF_OBJECT(value.sym, buffer); 4990 if (result) { 4991 return result; 4992 } 4993 return result; 4994 } 4995 4996 TPM_RC Parse_TPMS_SYMCIPHER_PARMS(std::string* buffer, 4997 TPMS_SYMCIPHER_PARMS* value, 4998 std::string* value_bytes) { 4999 TPM_RC result = TPM_RC_SUCCESS; 5000 VLOG(3) << __func__; 5001 5002 result = Parse_TPMT_SYM_DEF_OBJECT(buffer, &value->sym, value_bytes); 5003 if (result) { 5004 return result; 5005 } 5006 return result; 5007 } 5008 5009 TPM_RC Serialize_TPM2B_SENSITIVE_DATA(const TPM2B_SENSITIVE_DATA& value, 5010 std::string* buffer) { 5011 TPM_RC result = TPM_RC_SUCCESS; 5012 VLOG(3) << __func__; 5013 5014 result = Serialize_UINT16(value.size, buffer); 5015 if (result) { 5016 return result; 5017 } 5018 5019 if (arraysize(value.buffer) < value.size) { 5020 return TPM_RC_INSUFFICIENT; 5021 } 5022 for (uint32_t i = 0; i < value.size; ++i) { 5023 result = Serialize_BYTE(value.buffer[i], buffer); 5024 if (result) { 5025 return result; 5026 } 5027 } 5028 return result; 5029 } 5030 5031 TPM_RC Parse_TPM2B_SENSITIVE_DATA(std::string* buffer, 5032 TPM2B_SENSITIVE_DATA* value, 5033 std::string* value_bytes) { 5034 TPM_RC result = TPM_RC_SUCCESS; 5035 VLOG(3) << __func__; 5036 5037 result = Parse_UINT16(buffer, &value->size, value_bytes); 5038 if (result) { 5039 return result; 5040 } 5041 5042 if (arraysize(value->buffer) < value->size) { 5043 return TPM_RC_INSUFFICIENT; 5044 } 5045 for (uint32_t i = 0; i < value->size; ++i) { 5046 result = Parse_BYTE(buffer, &value->buffer[i], value_bytes); 5047 if (result) { 5048 return result; 5049 } 5050 } 5051 return result; 5052 } 5053 5054 TPM2B_SENSITIVE_DATA Make_TPM2B_SENSITIVE_DATA(const std::string& bytes) { 5055 TPM2B_SENSITIVE_DATA tpm2b; 5056 CHECK(bytes.size() <= sizeof(tpm2b.buffer)); 5057 memset(&tpm2b, 0, sizeof(TPM2B_SENSITIVE_DATA)); 5058 tpm2b.size = bytes.size(); 5059 memcpy(tpm2b.buffer, bytes.data(), bytes.size()); 5060 return tpm2b; 5061 } 5062 5063 std::string StringFrom_TPM2B_SENSITIVE_DATA(const TPM2B_SENSITIVE_DATA& tpm2b) { 5064 const char* char_buffer = reinterpret_cast<const char*>(tpm2b.buffer); 5065 return std::string(char_buffer, tpm2b.size); 5066 } 5067 5068 TPM_RC Serialize_TPMS_SENSITIVE_CREATE(const TPMS_SENSITIVE_CREATE& value, 5069 std::string* buffer) { 5070 TPM_RC result = TPM_RC_SUCCESS; 5071 VLOG(3) << __func__; 5072 5073 result = Serialize_TPM2B_AUTH(value.user_auth, buffer); 5074 if (result) { 5075 return result; 5076 } 5077 5078 result = Serialize_TPM2B_SENSITIVE_DATA(value.data, buffer); 5079 if (result) { 5080 return result; 5081 } 5082 return result; 5083 } 5084 5085 TPM_RC Parse_TPMS_SENSITIVE_CREATE(std::string* buffer, 5086 TPMS_SENSITIVE_CREATE* value, 5087 std::string* value_bytes) { 5088 TPM_RC result = TPM_RC_SUCCESS; 5089 VLOG(3) << __func__; 5090 5091 result = Parse_TPM2B_AUTH(buffer, &value->user_auth, value_bytes); 5092 if (result) { 5093 return result; 5094 } 5095 5096 result = Parse_TPM2B_SENSITIVE_DATA(buffer, &value->data, value_bytes); 5097 if (result) { 5098 return result; 5099 } 5100 return result; 5101 } 5102 5103 TPM_RC Serialize_TPM2B_SENSITIVE_CREATE(const TPM2B_SENSITIVE_CREATE& value, 5104 std::string* buffer) { 5105 TPM_RC result = TPM_RC_SUCCESS; 5106 VLOG(3) << __func__; 5107 5108 std::string field_bytes; 5109 result = Serialize_TPMS_SENSITIVE_CREATE(value.sensitive, &field_bytes); 5110 if (result) { 5111 return result; 5112 } 5113 std::string size_bytes; 5114 result = Serialize_UINT16(field_bytes.size(), &size_bytes); 5115 if (result) { 5116 return result; 5117 } 5118 buffer->append(size_bytes + field_bytes); 5119 return result; 5120 } 5121 5122 TPM_RC Parse_TPM2B_SENSITIVE_CREATE(std::string* buffer, 5123 TPM2B_SENSITIVE_CREATE* value, 5124 std::string* value_bytes) { 5125 TPM_RC result = TPM_RC_SUCCESS; 5126 VLOG(3) << __func__; 5127 5128 result = Parse_UINT16(buffer, &value->size, value_bytes); 5129 if (result) { 5130 return result; 5131 } 5132 5133 result = Parse_TPMS_SENSITIVE_CREATE(buffer, &value->sensitive, value_bytes); 5134 if (result) { 5135 return result; 5136 } 5137 return result; 5138 } 5139 5140 TPM2B_SENSITIVE_CREATE Make_TPM2B_SENSITIVE_CREATE( 5141 const TPMS_SENSITIVE_CREATE& inner) { 5142 TPM2B_SENSITIVE_CREATE tpm2b; 5143 tpm2b.size = sizeof(TPMS_SENSITIVE_CREATE); 5144 tpm2b.sensitive = inner; 5145 return tpm2b; 5146 } 5147 5148 TPM_RC Serialize_TPMS_SCHEME_XOR(const TPMS_SCHEME_XOR& value, 5149 std::string* buffer) { 5150 TPM_RC result = TPM_RC_SUCCESS; 5151 VLOG(3) << __func__; 5152 5153 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5154 if (result) { 5155 return result; 5156 } 5157 5158 result = Serialize_TPMI_ALG_KDF(value.kdf, buffer); 5159 if (result) { 5160 return result; 5161 } 5162 return result; 5163 } 5164 5165 TPM_RC Parse_TPMS_SCHEME_XOR(std::string* buffer, 5166 TPMS_SCHEME_XOR* value, 5167 std::string* value_bytes) { 5168 TPM_RC result = TPM_RC_SUCCESS; 5169 VLOG(3) << __func__; 5170 5171 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 5172 if (result) { 5173 return result; 5174 } 5175 5176 result = Parse_TPMI_ALG_KDF(buffer, &value->kdf, value_bytes); 5177 if (result) { 5178 return result; 5179 } 5180 return result; 5181 } 5182 5183 TPM_RC Serialize_TPMU_SCHEME_KEYEDHASH(const TPMU_SCHEME_KEYEDHASH& value, 5184 TPMI_ALG_KEYEDHASH_SCHEME selector, 5185 std::string* buffer) { 5186 TPM_RC result = TPM_RC_SUCCESS; 5187 VLOG(3) << __func__; 5188 5189 if (selector == TPM_ALG_NULL) { 5190 // Do nothing. 5191 } 5192 5193 if (selector == TPM_ALG_HMAC) { 5194 result = Serialize_TPMS_SCHEME_HMAC(value.hmac, buffer); 5195 if (result) { 5196 return result; 5197 } 5198 } 5199 5200 if (selector == TPM_ALG_XOR) { 5201 result = Serialize_TPMS_SCHEME_XOR(value.xor_, buffer); 5202 if (result) { 5203 return result; 5204 } 5205 } 5206 return result; 5207 } 5208 5209 TPM_RC Parse_TPMU_SCHEME_KEYEDHASH(std::string* buffer, 5210 TPMI_ALG_KEYEDHASH_SCHEME selector, 5211 TPMU_SCHEME_KEYEDHASH* value, 5212 std::string* value_bytes) { 5213 TPM_RC result = TPM_RC_SUCCESS; 5214 VLOG(3) << __func__; 5215 5216 if (selector == TPM_ALG_NULL) { 5217 // Do nothing. 5218 } 5219 5220 if (selector == TPM_ALG_HMAC) { 5221 result = Parse_TPMS_SCHEME_HMAC(buffer, &value->hmac, value_bytes); 5222 if (result) { 5223 return result; 5224 } 5225 } 5226 5227 if (selector == TPM_ALG_XOR) { 5228 result = Parse_TPMS_SCHEME_XOR(buffer, &value->xor_, value_bytes); 5229 if (result) { 5230 return result; 5231 } 5232 } 5233 return result; 5234 } 5235 5236 TPM_RC Serialize_TPMT_KEYEDHASH_SCHEME(const TPMT_KEYEDHASH_SCHEME& value, 5237 std::string* buffer) { 5238 TPM_RC result = TPM_RC_SUCCESS; 5239 VLOG(3) << __func__; 5240 5241 result = Serialize_TPMI_ALG_KEYEDHASH_SCHEME(value.scheme, buffer); 5242 if (result) { 5243 return result; 5244 } 5245 5246 result = Serialize_TPMU_SCHEME_KEYEDHASH(value.details, value.scheme, buffer); 5247 if (result) { 5248 return result; 5249 } 5250 return result; 5251 } 5252 5253 TPM_RC Parse_TPMT_KEYEDHASH_SCHEME(std::string* buffer, 5254 TPMT_KEYEDHASH_SCHEME* value, 5255 std::string* value_bytes) { 5256 TPM_RC result = TPM_RC_SUCCESS; 5257 VLOG(3) << __func__; 5258 5259 result = Parse_TPMI_ALG_KEYEDHASH_SCHEME(buffer, &value->scheme, value_bytes); 5260 if (result) { 5261 return result; 5262 } 5263 5264 result = Parse_TPMU_SCHEME_KEYEDHASH(buffer, value->scheme, &value->details, 5265 value_bytes); 5266 if (result) { 5267 return result; 5268 } 5269 return result; 5270 } 5271 5272 TPM_RC Serialize_TPMS_SCHEME_ECDAA(const TPMS_SCHEME_ECDAA& value, 5273 std::string* buffer) { 5274 TPM_RC result = TPM_RC_SUCCESS; 5275 VLOG(3) << __func__; 5276 5277 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5278 if (result) { 5279 return result; 5280 } 5281 5282 result = Serialize_UINT16(value.count, buffer); 5283 if (result) { 5284 return result; 5285 } 5286 return result; 5287 } 5288 5289 TPM_RC Parse_TPMS_SCHEME_ECDAA(std::string* buffer, 5290 TPMS_SCHEME_ECDAA* value, 5291 std::string* value_bytes) { 5292 TPM_RC result = TPM_RC_SUCCESS; 5293 VLOG(3) << __func__; 5294 5295 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 5296 if (result) { 5297 return result; 5298 } 5299 5300 result = Parse_UINT16(buffer, &value->count, value_bytes); 5301 if (result) { 5302 return result; 5303 } 5304 return result; 5305 } 5306 5307 TPM_RC Serialize_TPMU_SIG_SCHEME(const TPMU_SIG_SCHEME& value, 5308 TPMI_ALG_SIG_SCHEME selector, 5309 std::string* buffer) { 5310 TPM_RC result = TPM_RC_SUCCESS; 5311 VLOG(3) << __func__; 5312 5313 if (selector == TPM_ALG_HMAC) { 5314 result = Serialize_TPMS_SCHEME_HMAC(value.hmac, buffer); 5315 if (result) { 5316 return result; 5317 } 5318 } 5319 5320 if (selector == TPM_ALG_ECSCHNORR) { 5321 result = Serialize_TPMS_SCHEME_ECSCHNORR(value.ec_schnorr, buffer); 5322 if (result) { 5323 return result; 5324 } 5325 } 5326 5327 if (selector == TPM_ALG_RSAPSS) { 5328 result = Serialize_TPMS_SCHEME_RSAPSS(value.rsapss, buffer); 5329 if (result) { 5330 return result; 5331 } 5332 } 5333 5334 if (selector == TPM_ALG_ECDAA) { 5335 result = Serialize_TPMS_SCHEME_ECDAA(value.ecdaa, buffer); 5336 if (result) { 5337 return result; 5338 } 5339 } 5340 5341 if (selector == TPM_ALG_RSASSA) { 5342 result = Serialize_TPMS_SCHEME_RSASSA(value.rsassa, buffer); 5343 if (result) { 5344 return result; 5345 } 5346 } 5347 5348 if (selector == TPM_ALG_SM2) { 5349 result = Serialize_TPMS_SCHEME_SM2(value.sm2, buffer); 5350 if (result) { 5351 return result; 5352 } 5353 } 5354 5355 if (selector == TPM_ALG_ECDSA) { 5356 result = Serialize_TPMS_SCHEME_ECDSA(value.ecdsa, buffer); 5357 if (result) { 5358 return result; 5359 } 5360 } 5361 5362 if (selector == TPM_ALG_NULL) { 5363 // Do nothing. 5364 } 5365 return result; 5366 } 5367 5368 TPM_RC Parse_TPMU_SIG_SCHEME(std::string* buffer, 5369 TPMI_ALG_SIG_SCHEME selector, 5370 TPMU_SIG_SCHEME* value, 5371 std::string* value_bytes) { 5372 TPM_RC result = TPM_RC_SUCCESS; 5373 VLOG(3) << __func__; 5374 5375 if (selector == TPM_ALG_HMAC) { 5376 result = Parse_TPMS_SCHEME_HMAC(buffer, &value->hmac, value_bytes); 5377 if (result) { 5378 return result; 5379 } 5380 } 5381 5382 if (selector == TPM_ALG_ECSCHNORR) { 5383 result = 5384 Parse_TPMS_SCHEME_ECSCHNORR(buffer, &value->ec_schnorr, value_bytes); 5385 if (result) { 5386 return result; 5387 } 5388 } 5389 5390 if (selector == TPM_ALG_RSAPSS) { 5391 result = Parse_TPMS_SCHEME_RSAPSS(buffer, &value->rsapss, value_bytes); 5392 if (result) { 5393 return result; 5394 } 5395 } 5396 5397 if (selector == TPM_ALG_ECDAA) { 5398 result = Parse_TPMS_SCHEME_ECDAA(buffer, &value->ecdaa, value_bytes); 5399 if (result) { 5400 return result; 5401 } 5402 } 5403 5404 if (selector == TPM_ALG_RSASSA) { 5405 result = Parse_TPMS_SCHEME_RSASSA(buffer, &value->rsassa, value_bytes); 5406 if (result) { 5407 return result; 5408 } 5409 } 5410 5411 if (selector == TPM_ALG_SM2) { 5412 result = Parse_TPMS_SCHEME_SM2(buffer, &value->sm2, value_bytes); 5413 if (result) { 5414 return result; 5415 } 5416 } 5417 5418 if (selector == TPM_ALG_ECDSA) { 5419 result = Parse_TPMS_SCHEME_ECDSA(buffer, &value->ecdsa, value_bytes); 5420 if (result) { 5421 return result; 5422 } 5423 } 5424 5425 if (selector == TPM_ALG_NULL) { 5426 // Do nothing. 5427 } 5428 return result; 5429 } 5430 5431 TPM_RC Serialize_TPMT_SIG_SCHEME(const TPMT_SIG_SCHEME& value, 5432 std::string* buffer) { 5433 TPM_RC result = TPM_RC_SUCCESS; 5434 VLOG(3) << __func__; 5435 5436 result = Serialize_TPMI_ALG_SIG_SCHEME(value.scheme, buffer); 5437 if (result) { 5438 return result; 5439 } 5440 5441 result = Serialize_TPMU_SIG_SCHEME(value.details, value.scheme, buffer); 5442 if (result) { 5443 return result; 5444 } 5445 return result; 5446 } 5447 5448 TPM_RC Parse_TPMT_SIG_SCHEME(std::string* buffer, 5449 TPMT_SIG_SCHEME* value, 5450 std::string* value_bytes) { 5451 TPM_RC result = TPM_RC_SUCCESS; 5452 VLOG(3) << __func__; 5453 5454 result = Parse_TPMI_ALG_SIG_SCHEME(buffer, &value->scheme, value_bytes); 5455 if (result) { 5456 return result; 5457 } 5458 5459 result = Parse_TPMU_SIG_SCHEME(buffer, value->scheme, &value->details, 5460 value_bytes); 5461 if (result) { 5462 return result; 5463 } 5464 return result; 5465 } 5466 5467 TPM_RC Serialize_TPMS_SCHEME_OAEP(const TPMS_SCHEME_OAEP& value, 5468 std::string* buffer) { 5469 TPM_RC result = TPM_RC_SUCCESS; 5470 VLOG(3) << __func__; 5471 5472 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5473 if (result) { 5474 return result; 5475 } 5476 return result; 5477 } 5478 5479 TPM_RC Parse_TPMS_SCHEME_OAEP(std::string* buffer, 5480 TPMS_SCHEME_OAEP* value, 5481 std::string* value_bytes) { 5482 TPM_RC result = TPM_RC_SUCCESS; 5483 VLOG(3) << __func__; 5484 5485 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 5486 if (result) { 5487 return result; 5488 } 5489 return result; 5490 } 5491 5492 TPM_RC Serialize_TPMS_SCHEME_ECDH(const TPMS_SCHEME_ECDH& value, 5493 std::string* buffer) { 5494 TPM_RC result = TPM_RC_SUCCESS; 5495 VLOG(3) << __func__; 5496 5497 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5498 if (result) { 5499 return result; 5500 } 5501 return result; 5502 } 5503 5504 TPM_RC Parse_TPMS_SCHEME_ECDH(std::string* buffer, 5505 TPMS_SCHEME_ECDH* value, 5506 std::string* value_bytes) { 5507 TPM_RC result = TPM_RC_SUCCESS; 5508 VLOG(3) << __func__; 5509 5510 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 5511 if (result) { 5512 return result; 5513 } 5514 return result; 5515 } 5516 5517 TPM_RC Serialize_TPMS_SCHEME_MGF1(const TPMS_SCHEME_MGF1& value, 5518 std::string* buffer) { 5519 TPM_RC result = TPM_RC_SUCCESS; 5520 VLOG(3) << __func__; 5521 5522 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5523 if (result) { 5524 return result; 5525 } 5526 return result; 5527 } 5528 5529 TPM_RC Parse_TPMS_SCHEME_MGF1(std::string* buffer, 5530 TPMS_SCHEME_MGF1* value, 5531 std::string* value_bytes) { 5532 TPM_RC result = TPM_RC_SUCCESS; 5533 VLOG(3) << __func__; 5534 5535 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 5536 if (result) { 5537 return result; 5538 } 5539 return result; 5540 } 5541 5542 TPM_RC Serialize_TPMS_SCHEME_KDF1_SP800_56a( 5543 const TPMS_SCHEME_KDF1_SP800_56a& value, 5544 std::string* buffer) { 5545 TPM_RC result = TPM_RC_SUCCESS; 5546 VLOG(3) << __func__; 5547 5548 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5549 if (result) { 5550 return result; 5551 } 5552 return result; 5553 } 5554 5555 TPM_RC Parse_TPMS_SCHEME_KDF1_SP800_56a(std::string* buffer, 5556 TPMS_SCHEME_KDF1_SP800_56a* value, 5557 std::string* value_bytes) { 5558 TPM_RC result = TPM_RC_SUCCESS; 5559 VLOG(3) << __func__; 5560 5561 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 5562 if (result) { 5563 return result; 5564 } 5565 return result; 5566 } 5567 5568 TPM_RC Serialize_TPMS_SCHEME_KDF2(const TPMS_SCHEME_KDF2& value, 5569 std::string* buffer) { 5570 TPM_RC result = TPM_RC_SUCCESS; 5571 VLOG(3) << __func__; 5572 5573 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5574 if (result) { 5575 return result; 5576 } 5577 return result; 5578 } 5579 5580 TPM_RC Parse_TPMS_SCHEME_KDF2(std::string* buffer, 5581 TPMS_SCHEME_KDF2* value, 5582 std::string* value_bytes) { 5583 TPM_RC result = TPM_RC_SUCCESS; 5584 VLOG(3) << __func__; 5585 5586 result = Parse_TPMI_ALG_HASH(buffer, &value->hash_alg, value_bytes); 5587 if (result) { 5588 return result; 5589 } 5590 return result; 5591 } 5592 5593 TPM_RC Serialize_TPMS_SCHEME_KDF1_SP800_108( 5594 const TPMS_SCHEME_KDF1_SP800_108& value, 5595 std::string* buffer) { 5596 TPM_RC result = TPM_RC_SUCCESS; 5597 VLOG(3) << __func__; 5598 5599 result = Serialize_TPMI_ALG_HASH(value.hash_alg, buffer); 5600 if (result) { 5601 return result; 5602 } 5603 return result; 5604 } 5605 5606 TPM_RC Parse_TPMS_SCHEME_KDF1_SP800_108(std::string* buffer, 5607 TPMS_SCHEME_KDF1_SP800_108* value, 5608 std::string* value_bytes) { 5609 TPM_RC result = TPM_RC_SUCCESS; 5610 VLOG(3) << __func__; 5611 5612 result = Par