1 /* Microsoft Reference Implementation for TPM 2.0 2 * 3 * The copyright in this software is being made available under the BSD License, 4 * included below. This software may be subject to other third party and 5 * contributor rights, including patent rights, and no such rights are granted 6 * under this license. 7 * 8 * Copyright (c) Microsoft Corporation 9 * 10 * All rights reserved. 11 * 12 * BSD License 13 * 14 * Redistribution and use in source and binary forms, with or without modification, 15 * are permitted provided that the following conditions are met: 16 * 17 * Redistributions of source code must retain the above copyright notice, this list 18 * of conditions and the following disclaimer. 19 * 20 * Redistributions in binary form must reproduce the above copyright notice, this 21 * list of conditions and the following disclaimer in the documentation and/or 22 * other materials provided with the distribution. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 28 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 29 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 31 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /*(Auto-generated) 36 * Created by TpmDispatch; Version 4.0 July 8,2017 37 * Date: Mar 6, 2020 Time: 01:50:10PM 38 */ 39 40 // This macro is added just so that the code is only excessively long. 41 #define EXIT_IF_ERROR_PLUS(x) \ 42 if(TPM_RC_SUCCESS != result) { result += (x); goto Exit; } 43 #if CC_Startup 44 case TPM_CC_Startup: { 45 Startup_In *in = (Startup_In *) 46 MemoryGetInBuffer(sizeof(Startup_In)); 47 result = TPM_SU_Unmarshal(&in->startupType, paramBuffer, paramBufferSize); 48 EXIT_IF_ERROR_PLUS(RC_Startup_startupType); 49 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 50 result = TPM2_Startup (in); 51 break; 52 } 53 #endif // CC_Startup 54 #if CC_Shutdown 55 case TPM_CC_Shutdown: { 56 Shutdown_In *in = (Shutdown_In *) 57 MemoryGetInBuffer(sizeof(Shutdown_In)); 58 result = TPM_SU_Unmarshal(&in->shutdownType, paramBuffer, paramBufferSize); 59 EXIT_IF_ERROR_PLUS(RC_Shutdown_shutdownType); 60 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 61 result = TPM2_Shutdown (in); 62 break; 63 } 64 #endif // CC_Shutdown 65 #if CC_SelfTest 66 case TPM_CC_SelfTest: { 67 SelfTest_In *in = (SelfTest_In *) 68 MemoryGetInBuffer(sizeof(SelfTest_In)); 69 result = TPMI_YES_NO_Unmarshal(&in->fullTest, paramBuffer, paramBufferSize); 70 EXIT_IF_ERROR_PLUS(RC_SelfTest_fullTest); 71 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 72 result = TPM2_SelfTest (in); 73 break; 74 } 75 #endif // CC_SelfTest 76 #if CC_IncrementalSelfTest 77 case TPM_CC_IncrementalSelfTest: { 78 IncrementalSelfTest_In *in = (IncrementalSelfTest_In *) 79 MemoryGetInBuffer(sizeof(IncrementalSelfTest_In)); 80 IncrementalSelfTest_Out *out = (IncrementalSelfTest_Out *) 81 MemoryGetOutBuffer(sizeof(IncrementalSelfTest_Out)); 82 result = TPML_ALG_Unmarshal(&in->toTest, paramBuffer, paramBufferSize); 83 EXIT_IF_ERROR_PLUS(RC_IncrementalSelfTest_toTest); 84 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 85 result = TPM2_IncrementalSelfTest (in, out); 86 rSize = sizeof(IncrementalSelfTest_Out); 87 *respParmSize += TPML_ALG_Marshal(&out->toDoList, 88 responseBuffer, &rSize); 89 break; 90 } 91 #endif // CC_IncrementalSelfTest 92 #if CC_GetTestResult 93 case TPM_CC_GetTestResult: { 94 GetTestResult_Out *out = (GetTestResult_Out *) 95 MemoryGetOutBuffer(sizeof(GetTestResult_Out)); 96 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 97 result = TPM2_GetTestResult (out); 98 rSize = sizeof(GetTestResult_Out); 99 *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->outData, 100 responseBuffer, &rSize); 101 *respParmSize += TPM_RC_Marshal(&out->testResult, 102 responseBuffer, &rSize); 103 break; 104 } 105 #endif // CC_GetTestResult 106 #if CC_StartAuthSession 107 case TPM_CC_StartAuthSession: { 108 StartAuthSession_In *in = (StartAuthSession_In *) 109 MemoryGetInBuffer(sizeof(StartAuthSession_In)); 110 StartAuthSession_Out *out = (StartAuthSession_Out *) 111 MemoryGetOutBuffer(sizeof(StartAuthSession_Out)); 112 in->tpmKey = handles[0]; 113 in->bind = handles[1]; 114 result = TPM2B_NONCE_Unmarshal(&in->nonceCaller, paramBuffer, paramBufferSize); 115 EXIT_IF_ERROR_PLUS(RC_StartAuthSession_nonceCaller); 116 result = TPM2B_ENCRYPTED_SECRET_Unmarshal(&in->encryptedSalt, paramBuffer, paramBufferSize); 117 EXIT_IF_ERROR_PLUS(RC_StartAuthSession_encryptedSalt); 118 result = TPM_SE_Unmarshal(&in->sessionType, paramBuffer, paramBufferSize); 119 EXIT_IF_ERROR_PLUS(RC_StartAuthSession_sessionType); 120 result = TPMT_SYM_DEF_Unmarshal(&in->symmetric, paramBuffer, paramBufferSize, TRUE); 121 EXIT_IF_ERROR_PLUS(RC_StartAuthSession_symmetric); 122 result = TPMI_ALG_HASH_Unmarshal(&in->authHash, paramBuffer, paramBufferSize, FALSE); 123 EXIT_IF_ERROR_PLUS(RC_StartAuthSession_authHash); 124 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 125 result = TPM2_StartAuthSession (in, out); 126 rSize = sizeof(StartAuthSession_Out); 127 if(TPM_RC_SUCCESS != result) goto Exit; 128 command->handles[command->handleNum++] = out->sessionHandle; 129 *respParmSize += TPM2B_NONCE_Marshal(&out->nonceTPM, 130 responseBuffer, &rSize); 131 break; 132 } 133 #endif // CC_StartAuthSession 134 #if CC_PolicyRestart 135 case TPM_CC_PolicyRestart: { 136 PolicyRestart_In *in = (PolicyRestart_In *) 137 MemoryGetInBuffer(sizeof(PolicyRestart_In)); 138 in->sessionHandle = handles[0]; 139 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 140 result = TPM2_PolicyRestart (in); 141 break; 142 } 143 #endif // CC_PolicyRestart 144 #if CC_Create 145 case TPM_CC_Create: { 146 Create_In *in = (Create_In *) 147 MemoryGetInBuffer(sizeof(Create_In)); 148 Create_Out *out = (Create_Out *) 149 MemoryGetOutBuffer(sizeof(Create_Out)); 150 in->parentHandle = handles[0]; 151 result = TPM2B_SENSITIVE_CREATE_Unmarshal(&in->inSensitive, paramBuffer, paramBufferSize); 152 EXIT_IF_ERROR_PLUS(RC_Create_inSensitive); 153 result = TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, FALSE); 154 EXIT_IF_ERROR_PLUS(RC_Create_inPublic); 155 result = TPM2B_DATA_Unmarshal(&in->outsideInfo, paramBuffer, paramBufferSize); 156 EXIT_IF_ERROR_PLUS(RC_Create_outsideInfo); 157 result = TPML_PCR_SELECTION_Unmarshal(&in->creationPCR, paramBuffer, paramBufferSize); 158 EXIT_IF_ERROR_PLUS(RC_Create_creationPCR); 159 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 160 result = TPM2_Create (in, out); 161 rSize = sizeof(Create_Out); 162 *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, 163 responseBuffer, &rSize); 164 *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, 165 responseBuffer, &rSize); 166 *respParmSize += TPM2B_CREATION_DATA_Marshal(&out->creationData, 167 responseBuffer, &rSize); 168 *respParmSize += TPM2B_DIGEST_Marshal(&out->creationHash, 169 responseBuffer, &rSize); 170 *respParmSize += TPMT_TK_CREATION_Marshal(&out->creationTicket, 171 responseBuffer, &rSize); 172 break; 173 } 174 #endif // CC_Create 175 #if CC_Load 176 case TPM_CC_Load: { 177 Load_In *in = (Load_In *) 178 MemoryGetInBuffer(sizeof(Load_In)); 179 Load_Out *out = (Load_Out *) 180 MemoryGetOutBuffer(sizeof(Load_Out)); 181 in->parentHandle = handles[0]; 182 result = TPM2B_PRIVATE_Unmarshal(&in->inPrivate, paramBuffer, paramBufferSize); 183 EXIT_IF_ERROR_PLUS(RC_Load_inPrivate); 184 result = TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, FALSE); 185 EXIT_IF_ERROR_PLUS(RC_Load_inPublic); 186 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 187 result = TPM2_Load (in, out); 188 rSize = sizeof(Load_Out); 189 if(TPM_RC_SUCCESS != result) goto Exit; 190 command->handles[command->handleNum++] = out->objectHandle; 191 *respParmSize += TPM2B_NAME_Marshal(&out->name, 192 responseBuffer, &rSize); 193 break; 194 } 195 #endif // CC_Load 196 #if CC_LoadExternal 197 case TPM_CC_LoadExternal: { 198 LoadExternal_In *in = (LoadExternal_In *) 199 MemoryGetInBuffer(sizeof(LoadExternal_In)); 200 LoadExternal_Out *out = (LoadExternal_Out *) 201 MemoryGetOutBuffer(sizeof(LoadExternal_Out)); 202 result = TPM2B_SENSITIVE_Unmarshal(&in->inPrivate, paramBuffer, paramBufferSize); 203 EXIT_IF_ERROR_PLUS(RC_LoadExternal_inPrivate); 204 result = TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, TRUE); 205 EXIT_IF_ERROR_PLUS(RC_LoadExternal_inPublic); 206 result = TPMI_RH_HIERARCHY_Unmarshal(&in->hierarchy, paramBuffer, paramBufferSize, TRUE); 207 EXIT_IF_ERROR_PLUS(RC_LoadExternal_hierarchy); 208 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 209 result = TPM2_LoadExternal (in, out); 210 rSize = sizeof(LoadExternal_Out); 211 if(TPM_RC_SUCCESS != result) goto Exit; 212 command->handles[command->handleNum++] = out->objectHandle; 213 *respParmSize += TPM2B_NAME_Marshal(&out->name, 214 responseBuffer, &rSize); 215 break; 216 } 217 #endif // CC_LoadExternal 218 #if CC_ReadPublic 219 case TPM_CC_ReadPublic: { 220 ReadPublic_In *in = (ReadPublic_In *) 221 MemoryGetInBuffer(sizeof(ReadPublic_In)); 222 ReadPublic_Out *out = (ReadPublic_Out *) 223 MemoryGetOutBuffer(sizeof(ReadPublic_Out)); 224 in->objectHandle = handles[0]; 225 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 226 result = TPM2_ReadPublic (in, out); 227 rSize = sizeof(ReadPublic_Out); 228 *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, 229 responseBuffer, &rSize); 230 *respParmSize += TPM2B_NAME_Marshal(&out->name, 231 responseBuffer, &rSize); 232 *respParmSize += TPM2B_NAME_Marshal(&out->qualifiedName, 233 responseBuffer, &rSize); 234 break; 235 } 236 #endif // CC_ReadPublic 237 #if CC_ActivateCredential 238 case TPM_CC_ActivateCredential: { 239 ActivateCredential_In *in = (ActivateCredential_In *) 240 MemoryGetInBuffer(sizeof(ActivateCredential_In)); 241 ActivateCredential_Out *out = (ActivateCredential_Out *) 242 MemoryGetOutBuffer(sizeof(ActivateCredential_Out)); 243 in->activateHandle = handles[0]; 244 in->keyHandle = handles[1]; 245 result = TPM2B_ID_OBJECT_Unmarshal(&in->credentialBlob, paramBuffer, paramBufferSize); 246 EXIT_IF_ERROR_PLUS(RC_ActivateCredential_credentialBlob); 247 result = TPM2B_ENCRYPTED_SECRET_Unmarshal(&in->secret, paramBuffer, paramBufferSize); 248 EXIT_IF_ERROR_PLUS(RC_ActivateCredential_secret); 249 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 250 result = TPM2_ActivateCredential (in, out); 251 rSize = sizeof(ActivateCredential_Out); 252 *respParmSize += TPM2B_DIGEST_Marshal(&out->certInfo, 253 responseBuffer, &rSize); 254 break; 255 } 256 #endif // CC_ActivateCredential 257 #if CC_MakeCredential 258 case TPM_CC_MakeCredential: { 259 MakeCredential_In *in = (MakeCredential_In *) 260 MemoryGetInBuffer(sizeof(MakeCredential_In)); 261 MakeCredential_Out *out = (MakeCredential_Out *) 262 MemoryGetOutBuffer(sizeof(MakeCredential_Out)); 263 in->handle = handles[0]; 264 result = TPM2B_DIGEST_Unmarshal(&in->credential, paramBuffer, paramBufferSize); 265 EXIT_IF_ERROR_PLUS(RC_MakeCredential_credential); 266 result = TPM2B_NAME_Unmarshal(&in->objectName, paramBuffer, paramBufferSize); 267 EXIT_IF_ERROR_PLUS(RC_MakeCredential_objectName); 268 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 269 result = TPM2_MakeCredential (in, out); 270 rSize = sizeof(MakeCredential_Out); 271 *respParmSize += TPM2B_ID_OBJECT_Marshal(&out->credentialBlob, 272 responseBuffer, &rSize); 273 *respParmSize += TPM2B_ENCRYPTED_SECRET_Marshal(&out->secret, 274 responseBuffer, &rSize); 275 break; 276 } 277 #endif // CC_MakeCredential 278 #if CC_Unseal 279 case TPM_CC_Unseal: { 280 Unseal_In *in = (Unseal_In *) 281 MemoryGetInBuffer(sizeof(Unseal_In)); 282 Unseal_Out *out = (Unseal_Out *) 283 MemoryGetOutBuffer(sizeof(Unseal_Out)); 284 in->itemHandle = handles[0]; 285 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 286 result = TPM2_Unseal (in, out); 287 rSize = sizeof(Unseal_Out); 288 *respParmSize += TPM2B_SENSITIVE_DATA_Marshal(&out->outData, 289 responseBuffer, &rSize); 290 break; 291 } 292 #endif // CC_Unseal 293 #if CC_ObjectChangeAuth 294 case TPM_CC_ObjectChangeAuth: { 295 ObjectChangeAuth_In *in = (ObjectChangeAuth_In *) 296 MemoryGetInBuffer(sizeof(ObjectChangeAuth_In)); 297 ObjectChangeAuth_Out *out = (ObjectChangeAuth_Out *) 298 MemoryGetOutBuffer(sizeof(ObjectChangeAuth_Out)); 299 in->objectHandle = handles[0]; 300 in->parentHandle = handles[1]; 301 result = TPM2B_AUTH_Unmarshal(&in->newAuth, paramBuffer, paramBufferSize); 302 EXIT_IF_ERROR_PLUS(RC_ObjectChangeAuth_newAuth); 303 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 304 result = TPM2_ObjectChangeAuth (in, out); 305 rSize = sizeof(ObjectChangeAuth_Out); 306 *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, 307 responseBuffer, &rSize); 308 break; 309 } 310 #endif // CC_ObjectChangeAuth 311 #if CC_CreateLoaded 312 case TPM_CC_CreateLoaded: { 313 CreateLoaded_In *in = (CreateLoaded_In *) 314 MemoryGetInBuffer(sizeof(CreateLoaded_In)); 315 CreateLoaded_Out *out = (CreateLoaded_Out *) 316 MemoryGetOutBuffer(sizeof(CreateLoaded_Out)); 317 in->parentHandle = handles[0]; 318 result = TPM2B_SENSITIVE_CREATE_Unmarshal(&in->inSensitive, paramBuffer, paramBufferSize); 319 EXIT_IF_ERROR_PLUS(RC_CreateLoaded_inSensitive); 320 result = TPM2B_TEMPLATE_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize); 321 EXIT_IF_ERROR_PLUS(RC_CreateLoaded_inPublic); 322 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 323 result = TPM2_CreateLoaded (in, out); 324 rSize = sizeof(CreateLoaded_Out); 325 if(TPM_RC_SUCCESS != result) goto Exit; 326 command->handles[command->handleNum++] = out->objectHandle; 327 *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, 328 responseBuffer, &rSize); 329 *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, 330 responseBuffer, &rSize); 331 *respParmSize += TPM2B_NAME_Marshal(&out->name, 332 responseBuffer, &rSize); 333 break; 334 } 335 #endif // CC_CreateLoaded 336 #if CC_Duplicate 337 case TPM_CC_Duplicate: { 338 Duplicate_In *in = (Duplicate_In *) 339 MemoryGetInBuffer(sizeof(Duplicate_In)); 340 Duplicate_Out *out = (Duplicate_Out *) 341 MemoryGetOutBuffer(sizeof(Duplicate_Out)); 342 in->objectHandle = handles[0]; 343 in->newParentHandle = handles[1]; 344 result = TPM2B_DATA_Unmarshal(&in->encryptionKeyIn, paramBuffer, paramBufferSize); 345 EXIT_IF_ERROR_PLUS(RC_Duplicate_encryptionKeyIn); 346 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&in->symmetricAlg, paramBuffer, paramBufferSize, TRUE); 347 EXIT_IF_ERROR_PLUS(RC_Duplicate_symmetricAlg); 348 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 349 result = TPM2_Duplicate (in, out); 350 rSize = sizeof(Duplicate_Out); 351 *respParmSize += TPM2B_DATA_Marshal(&out->encryptionKeyOut, 352 responseBuffer, &rSize); 353 *respParmSize += TPM2B_PRIVATE_Marshal(&out->duplicate, 354 responseBuffer, &rSize); 355 *respParmSize += TPM2B_ENCRYPTED_SECRET_Marshal(&out->outSymSeed, 356 responseBuffer, &rSize); 357 break; 358 } 359 #endif // CC_Duplicate 360 #if CC_Rewrap 361 case TPM_CC_Rewrap: { 362 Rewrap_In *in = (Rewrap_In *) 363 MemoryGetInBuffer(sizeof(Rewrap_In)); 364 Rewrap_Out *out = (Rewrap_Out *) 365 MemoryGetOutBuffer(sizeof(Rewrap_Out)); 366 in->oldParent = handles[0]; 367 in->newParent = handles[1]; 368 result = TPM2B_PRIVATE_Unmarshal(&in->inDuplicate, paramBuffer, paramBufferSize); 369 EXIT_IF_ERROR_PLUS(RC_Rewrap_inDuplicate); 370 result = TPM2B_NAME_Unmarshal(&in->name, paramBuffer, paramBufferSize); 371 EXIT_IF_ERROR_PLUS(RC_Rewrap_name); 372 result = TPM2B_ENCRYPTED_SECRET_Unmarshal(&in->inSymSeed, paramBuffer, paramBufferSize); 373 EXIT_IF_ERROR_PLUS(RC_Rewrap_inSymSeed); 374 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 375 result = TPM2_Rewrap (in, out); 376 rSize = sizeof(Rewrap_Out); 377 *respParmSize += TPM2B_PRIVATE_Marshal(&out->outDuplicate, 378 responseBuffer, &rSize); 379 *respParmSize += TPM2B_ENCRYPTED_SECRET_Marshal(&out->outSymSeed, 380 responseBuffer, &rSize); 381 break; 382 } 383 #endif // CC_Rewrap 384 #if CC_Import 385 case TPM_CC_Import: { 386 Import_In *in = (Import_In *) 387 MemoryGetInBuffer(sizeof(Import_In)); 388 Import_Out *out = (Import_Out *) 389 MemoryGetOutBuffer(sizeof(Import_Out)); 390 in->parentHandle = handles[0]; 391 result = TPM2B_DATA_Unmarshal(&in->encryptionKey, paramBuffer, paramBufferSize); 392 EXIT_IF_ERROR_PLUS(RC_Import_encryptionKey); 393 result = TPM2B_PUBLIC_Unmarshal(&in->objectPublic, paramBuffer, paramBufferSize, FALSE); 394 EXIT_IF_ERROR_PLUS(RC_Import_objectPublic); 395 result = TPM2B_PRIVATE_Unmarshal(&in->duplicate, paramBuffer, paramBufferSize); 396 EXIT_IF_ERROR_PLUS(RC_Import_duplicate); 397 result = TPM2B_ENCRYPTED_SECRET_Unmarshal(&in->inSymSeed, paramBuffer, paramBufferSize); 398 EXIT_IF_ERROR_PLUS(RC_Import_inSymSeed); 399 result = TPMT_SYM_DEF_OBJECT_Unmarshal(&in->symmetricAlg, paramBuffer, paramBufferSize, TRUE); 400 EXIT_IF_ERROR_PLUS(RC_Import_symmetricAlg); 401 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 402 result = TPM2_Import (in, out); 403 rSize = sizeof(Import_Out); 404 *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, 405 responseBuffer, &rSize); 406 break; 407 } 408 #endif // CC_Import 409 #if CC_RSA_Encrypt 410 case TPM_CC_RSA_Encrypt: { 411 RSA_Encrypt_In *in = (RSA_Encrypt_In *) 412 MemoryGetInBuffer(sizeof(RSA_Encrypt_In)); 413 RSA_Encrypt_Out *out = (RSA_Encrypt_Out *) 414 MemoryGetOutBuffer(sizeof(RSA_Encrypt_Out)); 415 in->keyHandle = handles[0]; 416 result = TPM2B_PUBLIC_KEY_RSA_Unmarshal(&in->message, paramBuffer, paramBufferSize); 417 EXIT_IF_ERROR_PLUS(RC_RSA_Encrypt_message); 418 result = TPMT_RSA_DECRYPT_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 419 EXIT_IF_ERROR_PLUS(RC_RSA_Encrypt_inScheme); 420 result = TPM2B_DATA_Unmarshal(&in->label, paramBuffer, paramBufferSize); 421 EXIT_IF_ERROR_PLUS(RC_RSA_Encrypt_label); 422 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 423 result = TPM2_RSA_Encrypt (in, out); 424 rSize = sizeof(RSA_Encrypt_Out); 425 *respParmSize += TPM2B_PUBLIC_KEY_RSA_Marshal(&out->outData, 426 responseBuffer, &rSize); 427 break; 428 } 429 #endif // CC_RSA_Encrypt 430 #if CC_RSA_Decrypt 431 case TPM_CC_RSA_Decrypt: { 432 RSA_Decrypt_In *in = (RSA_Decrypt_In *) 433 MemoryGetInBuffer(sizeof(RSA_Decrypt_In)); 434 RSA_Decrypt_Out *out = (RSA_Decrypt_Out *) 435 MemoryGetOutBuffer(sizeof(RSA_Decrypt_Out)); 436 in->keyHandle = handles[0]; 437 result = TPM2B_PUBLIC_KEY_RSA_Unmarshal(&in->cipherText, paramBuffer, paramBufferSize); 438 EXIT_IF_ERROR_PLUS(RC_RSA_Decrypt_cipherText); 439 result = TPMT_RSA_DECRYPT_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 440 EXIT_IF_ERROR_PLUS(RC_RSA_Decrypt_inScheme); 441 result = TPM2B_DATA_Unmarshal(&in->label, paramBuffer, paramBufferSize); 442 EXIT_IF_ERROR_PLUS(RC_RSA_Decrypt_label); 443 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 444 result = TPM2_RSA_Decrypt (in, out); 445 rSize = sizeof(RSA_Decrypt_Out); 446 *respParmSize += TPM2B_PUBLIC_KEY_RSA_Marshal(&out->message, 447 responseBuffer, &rSize); 448 break; 449 } 450 #endif // CC_RSA_Decrypt 451 #if CC_ECDH_KeyGen 452 case TPM_CC_ECDH_KeyGen: { 453 ECDH_KeyGen_In *in = (ECDH_KeyGen_In *) 454 MemoryGetInBuffer(sizeof(ECDH_KeyGen_In)); 455 ECDH_KeyGen_Out *out = (ECDH_KeyGen_Out *) 456 MemoryGetOutBuffer(sizeof(ECDH_KeyGen_Out)); 457 in->keyHandle = handles[0]; 458 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 459 result = TPM2_ECDH_KeyGen (in, out); 460 rSize = sizeof(ECDH_KeyGen_Out); 461 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->zPoint, 462 responseBuffer, &rSize); 463 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->pubPoint, 464 responseBuffer, &rSize); 465 break; 466 } 467 #endif // CC_ECDH_KeyGen 468 #if CC_ECDH_ZGen 469 case TPM_CC_ECDH_ZGen: { 470 ECDH_ZGen_In *in = (ECDH_ZGen_In *) 471 MemoryGetInBuffer(sizeof(ECDH_ZGen_In)); 472 ECDH_ZGen_Out *out = (ECDH_ZGen_Out *) 473 MemoryGetOutBuffer(sizeof(ECDH_ZGen_Out)); 474 in->keyHandle = handles[0]; 475 result = TPM2B_ECC_POINT_Unmarshal(&in->inPoint, paramBuffer, paramBufferSize); 476 EXIT_IF_ERROR_PLUS(RC_ECDH_ZGen_inPoint); 477 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 478 result = TPM2_ECDH_ZGen (in, out); 479 rSize = sizeof(ECDH_ZGen_Out); 480 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->outPoint, 481 responseBuffer, &rSize); 482 break; 483 } 484 #endif // CC_ECDH_ZGen 485 #if CC_ECC_Parameters 486 case TPM_CC_ECC_Parameters: { 487 ECC_Parameters_In *in = (ECC_Parameters_In *) 488 MemoryGetInBuffer(sizeof(ECC_Parameters_In)); 489 ECC_Parameters_Out *out = (ECC_Parameters_Out *) 490 MemoryGetOutBuffer(sizeof(ECC_Parameters_Out)); 491 result = TPMI_ECC_CURVE_Unmarshal(&in->curveID, paramBuffer, paramBufferSize); 492 EXIT_IF_ERROR_PLUS(RC_ECC_Parameters_curveID); 493 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 494 result = TPM2_ECC_Parameters (in, out); 495 rSize = sizeof(ECC_Parameters_Out); 496 *respParmSize += TPMS_ALGORITHM_DETAIL_ECC_Marshal(&out->parameters, 497 responseBuffer, &rSize); 498 break; 499 } 500 #endif // CC_ECC_Parameters 501 #if CC_ZGen_2Phase 502 case TPM_CC_ZGen_2Phase: { 503 ZGen_2Phase_In *in = (ZGen_2Phase_In *) 504 MemoryGetInBuffer(sizeof(ZGen_2Phase_In)); 505 ZGen_2Phase_Out *out = (ZGen_2Phase_Out *) 506 MemoryGetOutBuffer(sizeof(ZGen_2Phase_Out)); 507 in->keyA = handles[0]; 508 result = TPM2B_ECC_POINT_Unmarshal(&in->inQsB, paramBuffer, paramBufferSize); 509 EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_inQsB); 510 result = TPM2B_ECC_POINT_Unmarshal(&in->inQeB, paramBuffer, paramBufferSize); 511 EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_inQeB); 512 result = TPMI_ECC_KEY_EXCHANGE_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, FALSE); 513 EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_inScheme); 514 result = UINT16_Unmarshal(&in->counter, paramBuffer, paramBufferSize); 515 EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_counter); 516 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 517 result = TPM2_ZGen_2Phase (in, out); 518 rSize = sizeof(ZGen_2Phase_Out); 519 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->outZ1, 520 responseBuffer, &rSize); 521 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->outZ2, 522 responseBuffer, &rSize); 523 break; 524 } 525 #endif // CC_ZGen_2Phase 526 #if CC_ECC_Encrypt 527 case TPM_CC_ECC_Encrypt: { 528 ECC_Encrypt_In *in = (ECC_Encrypt_In *) 529 MemoryGetInBuffer(sizeof(ECC_Encrypt_In)); 530 ECC_Encrypt_Out *out = (ECC_Encrypt_Out *) 531 MemoryGetOutBuffer(sizeof(ECC_Encrypt_Out)); 532 in->keyHandle = handles[0]; 533 result = TPM2B_MAX_BUFFER_Unmarshal(&in->plainText, paramBuffer, paramBufferSize); 534 EXIT_IF_ERROR_PLUS(RC_ECC_Encrypt_plainText); 535 result = TPMT_KDF_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 536 EXIT_IF_ERROR_PLUS(RC_ECC_Encrypt_inScheme); 537 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 538 result = TPM2_ECC_Encrypt (in, out); 539 rSize = sizeof(ECC_Encrypt_Out); 540 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->C1, 541 responseBuffer, &rSize); 542 *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->C2, 543 responseBuffer, &rSize); 544 *respParmSize += TPM2B_DIGEST_Marshal(&out->C3, 545 responseBuffer, &rSize); 546 break; 547 } 548 #endif // CC_ECC_Encrypt 549 #if CC_ECC_Decrypt 550 case TPM_CC_ECC_Decrypt: { 551 ECC_Decrypt_In *in = (ECC_Decrypt_In *) 552 MemoryGetInBuffer(sizeof(ECC_Decrypt_In)); 553 ECC_Decrypt_Out *out = (ECC_Decrypt_Out *) 554 MemoryGetOutBuffer(sizeof(ECC_Decrypt_Out)); 555 in->keyHandle = handles[0]; 556 result = TPM2B_ECC_POINT_Unmarshal(&in->C1, paramBuffer, paramBufferSize); 557 EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_C1); 558 result = TPM2B_MAX_BUFFER_Unmarshal(&in->C2, paramBuffer, paramBufferSize); 559 EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_C2); 560 result = TPM2B_DIGEST_Unmarshal(&in->C3, paramBuffer, paramBufferSize); 561 EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_C3); 562 result = TPMT_KDF_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 563 EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_inScheme); 564 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 565 result = TPM2_ECC_Decrypt (in, out); 566 rSize = sizeof(ECC_Decrypt_Out); 567 *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->plainText, 568 responseBuffer, &rSize); 569 break; 570 } 571 #endif // CC_ECC_Decrypt 572 #if CC_EncryptDecrypt 573 case TPM_CC_EncryptDecrypt: { 574 EncryptDecrypt_In *in = (EncryptDecrypt_In *) 575 MemoryGetInBuffer(sizeof(EncryptDecrypt_In)); 576 EncryptDecrypt_Out *out = (EncryptDecrypt_Out *) 577 MemoryGetOutBuffer(sizeof(EncryptDecrypt_Out)); 578 in->keyHandle = handles[0]; 579 result = TPMI_YES_NO_Unmarshal(&in->decrypt, paramBuffer, paramBufferSize); 580 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_decrypt); 581 result = TPMI_ALG_CIPHER_MODE_Unmarshal(&in->mode, paramBuffer, paramBufferSize, TRUE); 582 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_mode); 583 result = TPM2B_IV_Unmarshal(&in->ivIn, paramBuffer, paramBufferSize); 584 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_ivIn); 585 result = TPM2B_MAX_BUFFER_Unmarshal(&in->inData, paramBuffer, paramBufferSize); 586 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_inData); 587 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 588 result = TPM2_EncryptDecrypt (in, out); 589 rSize = sizeof(EncryptDecrypt_Out); 590 *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->outData, 591 responseBuffer, &rSize); 592 *respParmSize += TPM2B_IV_Marshal(&out->ivOut, 593 responseBuffer, &rSize); 594 break; 595 } 596 #endif // CC_EncryptDecrypt 597 #if CC_EncryptDecrypt2 598 case TPM_CC_EncryptDecrypt2: { 599 EncryptDecrypt2_In *in = (EncryptDecrypt2_In *) 600 MemoryGetInBuffer(sizeof(EncryptDecrypt2_In)); 601 EncryptDecrypt2_Out *out = (EncryptDecrypt2_Out *) 602 MemoryGetOutBuffer(sizeof(EncryptDecrypt2_Out)); 603 in->keyHandle = handles[0]; 604 result = TPM2B_MAX_BUFFER_Unmarshal(&in->inData, paramBuffer, paramBufferSize); 605 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_inData); 606 result = TPMI_YES_NO_Unmarshal(&in->decrypt, paramBuffer, paramBufferSize); 607 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_decrypt); 608 result = TPMI_ALG_CIPHER_MODE_Unmarshal(&in->mode, paramBuffer, paramBufferSize, TRUE); 609 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_mode); 610 result = TPM2B_IV_Unmarshal(&in->ivIn, paramBuffer, paramBufferSize); 611 EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_ivIn); 612 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 613 result = TPM2_EncryptDecrypt2 (in, out); 614 rSize = sizeof(EncryptDecrypt2_Out); 615 *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->outData, 616 responseBuffer, &rSize); 617 *respParmSize += TPM2B_IV_Marshal(&out->ivOut, 618 responseBuffer, &rSize); 619 break; 620 } 621 #endif // CC_EncryptDecrypt2 622 #if CC_Hash 623 case TPM_CC_Hash: { 624 Hash_In *in = (Hash_In *) 625 MemoryGetInBuffer(sizeof(Hash_In)); 626 Hash_Out *out = (Hash_Out *) 627 MemoryGetOutBuffer(sizeof(Hash_Out)); 628 result = TPM2B_MAX_BUFFER_Unmarshal(&in->data, paramBuffer, paramBufferSize); 629 EXIT_IF_ERROR_PLUS(RC_Hash_data); 630 result = TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, FALSE); 631 EXIT_IF_ERROR_PLUS(RC_Hash_hashAlg); 632 result = TPMI_RH_HIERARCHY_Unmarshal(&in->hierarchy, paramBuffer, paramBufferSize, TRUE); 633 EXIT_IF_ERROR_PLUS(RC_Hash_hierarchy); 634 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 635 result = TPM2_Hash (in, out); 636 rSize = sizeof(Hash_Out); 637 *respParmSize += TPM2B_DIGEST_Marshal(&out->outHash, 638 responseBuffer, &rSize); 639 *respParmSize += TPMT_TK_HASHCHECK_Marshal(&out->validation, 640 responseBuffer, &rSize); 641 break; 642 } 643 #endif // CC_Hash 644 #if CC_HMAC 645 case TPM_CC_HMAC: { 646 HMAC_In *in = (HMAC_In *) 647 MemoryGetInBuffer(sizeof(HMAC_In)); 648 HMAC_Out *out = (HMAC_Out *) 649 MemoryGetOutBuffer(sizeof(HMAC_Out)); 650 in->handle = handles[0]; 651 result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize); 652 EXIT_IF_ERROR_PLUS(RC_HMAC_buffer); 653 result = TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE); 654 EXIT_IF_ERROR_PLUS(RC_HMAC_hashAlg); 655 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 656 result = TPM2_HMAC (in, out); 657 rSize = sizeof(HMAC_Out); 658 *respParmSize += TPM2B_DIGEST_Marshal(&out->outHMAC, 659 responseBuffer, &rSize); 660 break; 661 } 662 #endif // CC_HMAC 663 #if CC_MAC 664 case TPM_CC_MAC: { 665 MAC_In *in = (MAC_In *) 666 MemoryGetInBuffer(sizeof(MAC_In)); 667 MAC_Out *out = (MAC_Out *) 668 MemoryGetOutBuffer(sizeof(MAC_Out)); 669 in->handle = handles[0]; 670 result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize); 671 EXIT_IF_ERROR_PLUS(RC_MAC_buffer); 672 result = TPMI_ALG_MAC_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 673 EXIT_IF_ERROR_PLUS(RC_MAC_inScheme); 674 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 675 result = TPM2_MAC (in, out); 676 rSize = sizeof(MAC_Out); 677 *respParmSize += TPM2B_DIGEST_Marshal(&out->outMAC, 678 responseBuffer, &rSize); 679 break; 680 } 681 #endif // CC_MAC 682 #if CC_GetRandom 683 case TPM_CC_GetRandom: { 684 GetRandom_In *in = (GetRandom_In *) 685 MemoryGetInBuffer(sizeof(GetRandom_In)); 686 GetRandom_Out *out = (GetRandom_Out *) 687 MemoryGetOutBuffer(sizeof(GetRandom_Out)); 688 result = UINT16_Unmarshal(&in->bytesRequested, paramBuffer, paramBufferSize); 689 EXIT_IF_ERROR_PLUS(RC_GetRandom_bytesRequested); 690 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 691 result = TPM2_GetRandom (in, out); 692 rSize = sizeof(GetRandom_Out); 693 *respParmSize += TPM2B_DIGEST_Marshal(&out->randomBytes, 694 responseBuffer, &rSize); 695 break; 696 } 697 #endif // CC_GetRandom 698 #if CC_StirRandom 699 case TPM_CC_StirRandom: { 700 StirRandom_In *in = (StirRandom_In *) 701 MemoryGetInBuffer(sizeof(StirRandom_In)); 702 result = TPM2B_SENSITIVE_DATA_Unmarshal(&in->inData, paramBuffer, paramBufferSize); 703 EXIT_IF_ERROR_PLUS(RC_StirRandom_inData); 704 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 705 result = TPM2_StirRandom (in); 706 break; 707 } 708 #endif // CC_StirRandom 709 #if CC_HMAC_Start 710 case TPM_CC_HMAC_Start: { 711 HMAC_Start_In *in = (HMAC_Start_In *) 712 MemoryGetInBuffer(sizeof(HMAC_Start_In)); 713 HMAC_Start_Out *out = (HMAC_Start_Out *) 714 MemoryGetOutBuffer(sizeof(HMAC_Start_Out)); 715 in->handle = handles[0]; 716 result = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize); 717 EXIT_IF_ERROR_PLUS(RC_HMAC_Start_auth); 718 result = TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE); 719 EXIT_IF_ERROR_PLUS(RC_HMAC_Start_hashAlg); 720 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 721 result = TPM2_HMAC_Start (in, out); 722 rSize = sizeof(HMAC_Start_Out); 723 if(TPM_RC_SUCCESS != result) goto Exit; 724 command->handles[command->handleNum++] = out->sequenceHandle; 725 break; 726 } 727 #endif // CC_HMAC_Start 728 #if CC_MAC_Start 729 case TPM_CC_MAC_Start: { 730 MAC_Start_In *in = (MAC_Start_In *) 731 MemoryGetInBuffer(sizeof(MAC_Start_In)); 732 MAC_Start_Out *out = (MAC_Start_Out *) 733 MemoryGetOutBuffer(sizeof(MAC_Start_Out)); 734 in->handle = handles[0]; 735 result = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize); 736 EXIT_IF_ERROR_PLUS(RC_MAC_Start_auth); 737 result = TPMI_ALG_MAC_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 738 EXIT_IF_ERROR_PLUS(RC_MAC_Start_inScheme); 739 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 740 result = TPM2_MAC_Start (in, out); 741 rSize = sizeof(MAC_Start_Out); 742 if(TPM_RC_SUCCESS != result) goto Exit; 743 command->handles[command->handleNum++] = out->sequenceHandle; 744 break; 745 } 746 #endif // CC_MAC_Start 747 #if CC_HashSequenceStart 748 case TPM_CC_HashSequenceStart: { 749 HashSequenceStart_In *in = (HashSequenceStart_In *) 750 MemoryGetInBuffer(sizeof(HashSequenceStart_In)); 751 HashSequenceStart_Out *out = (HashSequenceStart_Out *) 752 MemoryGetOutBuffer(sizeof(HashSequenceStart_Out)); 753 result = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize); 754 EXIT_IF_ERROR_PLUS(RC_HashSequenceStart_auth); 755 result = TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE); 756 EXIT_IF_ERROR_PLUS(RC_HashSequenceStart_hashAlg); 757 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 758 result = TPM2_HashSequenceStart (in, out); 759 rSize = sizeof(HashSequenceStart_Out); 760 if(TPM_RC_SUCCESS != result) goto Exit; 761 command->handles[command->handleNum++] = out->sequenceHandle; 762 break; 763 } 764 #endif // CC_HashSequenceStart 765 #if CC_SequenceUpdate 766 case TPM_CC_SequenceUpdate: { 767 SequenceUpdate_In *in = (SequenceUpdate_In *) 768 MemoryGetInBuffer(sizeof(SequenceUpdate_In)); 769 in->sequenceHandle = handles[0]; 770 result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize); 771 EXIT_IF_ERROR_PLUS(RC_SequenceUpdate_buffer); 772 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 773 result = TPM2_SequenceUpdate (in); 774 break; 775 } 776 #endif // CC_SequenceUpdate 777 #if CC_SequenceComplete 778 case TPM_CC_SequenceComplete: { 779 SequenceComplete_In *in = (SequenceComplete_In *) 780 MemoryGetInBuffer(sizeof(SequenceComplete_In)); 781 SequenceComplete_Out *out = (SequenceComplete_Out *) 782 MemoryGetOutBuffer(sizeof(SequenceComplete_Out)); 783 in->sequenceHandle = handles[0]; 784 result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize); 785 EXIT_IF_ERROR_PLUS(RC_SequenceComplete_buffer); 786 result = TPMI_RH_HIERARCHY_Unmarshal(&in->hierarchy, paramBuffer, paramBufferSize, TRUE); 787 EXIT_IF_ERROR_PLUS(RC_SequenceComplete_hierarchy); 788 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 789 result = TPM2_SequenceComplete (in, out); 790 rSize = sizeof(SequenceComplete_Out); 791 *respParmSize += TPM2B_DIGEST_Marshal(&out->result, 792 responseBuffer, &rSize); 793 *respParmSize += TPMT_TK_HASHCHECK_Marshal(&out->validation, 794 responseBuffer, &rSize); 795 break; 796 } 797 #endif // CC_SequenceComplete 798 #if CC_EventSequenceComplete 799 case TPM_CC_EventSequenceComplete: { 800 EventSequenceComplete_In *in = (EventSequenceComplete_In *) 801 MemoryGetInBuffer(sizeof(EventSequenceComplete_In)); 802 EventSequenceComplete_Out *out = (EventSequenceComplete_Out *) 803 MemoryGetOutBuffer(sizeof(EventSequenceComplete_Out)); 804 in->pcrHandle = handles[0]; 805 in->sequenceHandle = handles[1]; 806 result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize); 807 EXIT_IF_ERROR_PLUS(RC_EventSequenceComplete_buffer); 808 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 809 result = TPM2_EventSequenceComplete (in, out); 810 rSize = sizeof(EventSequenceComplete_Out); 811 *respParmSize += TPML_DIGEST_VALUES_Marshal(&out->results, 812 responseBuffer, &rSize); 813 break; 814 } 815 #endif // CC_EventSequenceComplete 816 #if CC_Certify 817 case TPM_CC_Certify: { 818 Certify_In *in = (Certify_In *) 819 MemoryGetInBuffer(sizeof(Certify_In)); 820 Certify_Out *out = (Certify_Out *) 821 MemoryGetOutBuffer(sizeof(Certify_Out)); 822 in->objectHandle = handles[0]; 823 in->signHandle = handles[1]; 824 result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize); 825 EXIT_IF_ERROR_PLUS(RC_Certify_qualifyingData); 826 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 827 EXIT_IF_ERROR_PLUS(RC_Certify_inScheme); 828 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 829 result = TPM2_Certify (in, out); 830 rSize = sizeof(Certify_Out); 831 *respParmSize += TPM2B_ATTEST_Marshal(&out->certifyInfo, 832 responseBuffer, &rSize); 833 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 834 responseBuffer, &rSize); 835 break; 836 } 837 #endif // CC_Certify 838 #if CC_CertifyCreation 839 case TPM_CC_CertifyCreation: { 840 CertifyCreation_In *in = (CertifyCreation_In *) 841 MemoryGetInBuffer(sizeof(CertifyCreation_In)); 842 CertifyCreation_Out *out = (CertifyCreation_Out *) 843 MemoryGetOutBuffer(sizeof(CertifyCreation_Out)); 844 in->signHandle = handles[0]; 845 in->objectHandle = handles[1]; 846 result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize); 847 EXIT_IF_ERROR_PLUS(RC_CertifyCreation_qualifyingData); 848 result = TPM2B_DIGEST_Unmarshal(&in->creationHash, paramBuffer, paramBufferSize); 849 EXIT_IF_ERROR_PLUS(RC_CertifyCreation_creationHash); 850 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 851 EXIT_IF_ERROR_PLUS(RC_CertifyCreation_inScheme); 852 result = TPMT_TK_CREATION_Unmarshal(&in->creationTicket, paramBuffer, paramBufferSize); 853 EXIT_IF_ERROR_PLUS(RC_CertifyCreation_creationTicket); 854 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 855 result = TPM2_CertifyCreation (in, out); 856 rSize = sizeof(CertifyCreation_Out); 857 *respParmSize += TPM2B_ATTEST_Marshal(&out->certifyInfo, 858 responseBuffer, &rSize); 859 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 860 responseBuffer, &rSize); 861 break; 862 } 863 #endif // CC_CertifyCreation 864 #if CC_Quote 865 case TPM_CC_Quote: { 866 Quote_In *in = (Quote_In *) 867 MemoryGetInBuffer(sizeof(Quote_In)); 868 Quote_Out *out = (Quote_Out *) 869 MemoryGetOutBuffer(sizeof(Quote_Out)); 870 in->signHandle = handles[0]; 871 result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize); 872 EXIT_IF_ERROR_PLUS(RC_Quote_qualifyingData); 873 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 874 EXIT_IF_ERROR_PLUS(RC_Quote_inScheme); 875 result = TPML_PCR_SELECTION_Unmarshal(&in->PCRselect, paramBuffer, paramBufferSize); 876 EXIT_IF_ERROR_PLUS(RC_Quote_PCRselect); 877 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 878 result = TPM2_Quote (in, out); 879 rSize = sizeof(Quote_Out); 880 *respParmSize += TPM2B_ATTEST_Marshal(&out->quoted, 881 responseBuffer, &rSize); 882 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 883 responseBuffer, &rSize); 884 break; 885 } 886 #endif // CC_Quote 887 #if CC_GetSessionAuditDigest 888 case TPM_CC_GetSessionAuditDigest: { 889 GetSessionAuditDigest_In *in = (GetSessionAuditDigest_In *) 890 MemoryGetInBuffer(sizeof(GetSessionAuditDigest_In)); 891 GetSessionAuditDigest_Out *out = (GetSessionAuditDigest_Out *) 892 MemoryGetOutBuffer(sizeof(GetSessionAuditDigest_Out)); 893 in->privacyAdminHandle = handles[0]; 894 in->signHandle = handles[1]; 895 in->sessionHandle = handles[2]; 896 result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize); 897 EXIT_IF_ERROR_PLUS(RC_GetSessionAuditDigest_qualifyingData); 898 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 899 EXIT_IF_ERROR_PLUS(RC_GetSessionAuditDigest_inScheme); 900 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 901 result = TPM2_GetSessionAuditDigest (in, out); 902 rSize = sizeof(GetSessionAuditDigest_Out); 903 *respParmSize += TPM2B_ATTEST_Marshal(&out->auditInfo, 904 responseBuffer, &rSize); 905 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 906 responseBuffer, &rSize); 907 break; 908 } 909 #endif // CC_GetSessionAuditDigest 910 #if CC_GetCommandAuditDigest 911 case TPM_CC_GetCommandAuditDigest: { 912 GetCommandAuditDigest_In *in = (GetCommandAuditDigest_In *) 913 MemoryGetInBuffer(sizeof(GetCommandAuditDigest_In)); 914 GetCommandAuditDigest_Out *out = (GetCommandAuditDigest_Out *) 915 MemoryGetOutBuffer(sizeof(GetCommandAuditDigest_Out)); 916 in->privacyHandle = handles[0]; 917 in->signHandle = handles[1]; 918 result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize); 919 EXIT_IF_ERROR_PLUS(RC_GetCommandAuditDigest_qualifyingData); 920 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 921 EXIT_IF_ERROR_PLUS(RC_GetCommandAuditDigest_inScheme); 922 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 923 result = TPM2_GetCommandAuditDigest (in, out); 924 rSize = sizeof(GetCommandAuditDigest_Out); 925 *respParmSize += TPM2B_ATTEST_Marshal(&out->auditInfo, 926 responseBuffer, &rSize); 927 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 928 responseBuffer, &rSize); 929 break; 930 } 931 #endif // CC_GetCommandAuditDigest 932 #if CC_GetTime 933 case TPM_CC_GetTime: { 934 GetTime_In *in = (GetTime_In *) 935 MemoryGetInBuffer(sizeof(GetTime_In)); 936 GetTime_Out *out = (GetTime_Out *) 937 MemoryGetOutBuffer(sizeof(GetTime_Out)); 938 in->privacyAdminHandle = handles[0]; 939 in->signHandle = handles[1]; 940 result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize); 941 EXIT_IF_ERROR_PLUS(RC_GetTime_qualifyingData); 942 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 943 EXIT_IF_ERROR_PLUS(RC_GetTime_inScheme); 944 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 945 result = TPM2_GetTime (in, out); 946 rSize = sizeof(GetTime_Out); 947 *respParmSize += TPM2B_ATTEST_Marshal(&out->timeInfo, 948 responseBuffer, &rSize); 949 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 950 responseBuffer, &rSize); 951 break; 952 } 953 #endif // CC_GetTime 954 #if CC_CertifyX509 955 case TPM_CC_CertifyX509: { 956 CertifyX509_In *in = (CertifyX509_In *) 957 MemoryGetInBuffer(sizeof(CertifyX509_In)); 958 CertifyX509_Out *out = (CertifyX509_Out *) 959 MemoryGetOutBuffer(sizeof(CertifyX509_Out)); 960 in->objectHandle = handles[0]; 961 in->signHandle = handles[1]; 962 result = TPM2B_DATA_Unmarshal(&in->reserved, paramBuffer, paramBufferSize); 963 EXIT_IF_ERROR_PLUS(RC_CertifyX509_reserved); 964 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 965 EXIT_IF_ERROR_PLUS(RC_CertifyX509_inScheme); 966 result = TPM2B_MAX_BUFFER_Unmarshal(&in->partialCertificate, paramBuffer, paramBufferSize); 967 EXIT_IF_ERROR_PLUS(RC_CertifyX509_partialCertificate); 968 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 969 result = TPM2_CertifyX509 (in, out); 970 rSize = sizeof(CertifyX509_Out); 971 *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->addedToCertificate, 972 responseBuffer, &rSize); 973 *respParmSize += TPM2B_DIGEST_Marshal(&out->tbsDigest, 974 responseBuffer, &rSize); 975 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 976 responseBuffer, &rSize); 977 break; 978 } 979 #endif // CC_CertifyX509 980 #if CC_Commit 981 case TPM_CC_Commit: { 982 Commit_In *in = (Commit_In *) 983 MemoryGetInBuffer(sizeof(Commit_In)); 984 Commit_Out *out = (Commit_Out *) 985 MemoryGetOutBuffer(sizeof(Commit_Out)); 986 in->signHandle = handles[0]; 987 result = TPM2B_ECC_POINT_Unmarshal(&in->P1, paramBuffer, paramBufferSize); 988 EXIT_IF_ERROR_PLUS(RC_Commit_P1); 989 result = TPM2B_SENSITIVE_DATA_Unmarshal(&in->s2, paramBuffer, paramBufferSize); 990 EXIT_IF_ERROR_PLUS(RC_Commit_s2); 991 result = TPM2B_ECC_PARAMETER_Unmarshal(&in->y2, paramBuffer, paramBufferSize); 992 EXIT_IF_ERROR_PLUS(RC_Commit_y2); 993 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 994 result = TPM2_Commit (in, out); 995 rSize = sizeof(Commit_Out); 996 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->K, 997 responseBuffer, &rSize); 998 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->L, 999 responseBuffer, &rSize); 1000 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->E, 1001 responseBuffer, &rSize); 1002 *respParmSize += UINT16_Marshal(&out->counter, 1003 responseBuffer, &rSize); 1004 break; 1005 } 1006 #endif // CC_Commit 1007 #if CC_EC_Ephemeral 1008 case TPM_CC_EC_Ephemeral: { 1009 EC_Ephemeral_In *in = (EC_Ephemeral_In *) 1010 MemoryGetInBuffer(sizeof(EC_Ephemeral_In)); 1011 EC_Ephemeral_Out *out = (EC_Ephemeral_Out *) 1012 MemoryGetOutBuffer(sizeof(EC_Ephemeral_Out)); 1013 result = TPMI_ECC_CURVE_Unmarshal(&in->curveID, paramBuffer, paramBufferSize); 1014 EXIT_IF_ERROR_PLUS(RC_EC_Ephemeral_curveID); 1015 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1016 result = TPM2_EC_Ephemeral (in, out); 1017 rSize = sizeof(EC_Ephemeral_Out); 1018 *respParmSize += TPM2B_ECC_POINT_Marshal(&out->Q, 1019 responseBuffer, &rSize); 1020 *respParmSize += UINT16_Marshal(&out->counter, 1021 responseBuffer, &rSize); 1022 break; 1023 } 1024 #endif // CC_EC_Ephemeral 1025 #if CC_VerifySignature 1026 case TPM_CC_VerifySignature: { 1027 VerifySignature_In *in = (VerifySignature_In *) 1028 MemoryGetInBuffer(sizeof(VerifySignature_In)); 1029 VerifySignature_Out *out = (VerifySignature_Out *) 1030 MemoryGetOutBuffer(sizeof(VerifySignature_Out)); 1031 in->keyHandle = handles[0]; 1032 result = TPM2B_DIGEST_Unmarshal(&in->digest, paramBuffer, paramBufferSize); 1033 EXIT_IF_ERROR_PLUS(RC_VerifySignature_digest); 1034 result = TPMT_SIGNATURE_Unmarshal(&in->signature, paramBuffer, paramBufferSize, FALSE); 1035 EXIT_IF_ERROR_PLUS(RC_VerifySignature_signature); 1036 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1037 result = TPM2_VerifySignature (in, out); 1038 rSize = sizeof(VerifySignature_Out); 1039 *respParmSize += TPMT_TK_VERIFIED_Marshal(&out->validation, 1040 responseBuffer, &rSize); 1041 break; 1042 } 1043 #endif // CC_VerifySignature 1044 #if CC_Sign 1045 case TPM_CC_Sign: { 1046 Sign_In *in = (Sign_In *) 1047 MemoryGetInBuffer(sizeof(Sign_In)); 1048 Sign_Out *out = (Sign_Out *) 1049 MemoryGetOutBuffer(sizeof(Sign_Out)); 1050 in->keyHandle = handles[0]; 1051 result = TPM2B_DIGEST_Unmarshal(&in->digest, paramBuffer, paramBufferSize); 1052 EXIT_IF_ERROR_PLUS(RC_Sign_digest); 1053 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 1054 EXIT_IF_ERROR_PLUS(RC_Sign_inScheme); 1055 result = TPMT_TK_HASHCHECK_Unmarshal(&in->validation, paramBuffer, paramBufferSize); 1056 EXIT_IF_ERROR_PLUS(RC_Sign_validation); 1057 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1058 result = TPM2_Sign (in, out); 1059 rSize = sizeof(Sign_Out); 1060 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 1061 responseBuffer, &rSize); 1062 break; 1063 } 1064 #endif // CC_Sign 1065 #if CC_SetCommandCodeAuditStatus 1066 case TPM_CC_SetCommandCodeAuditStatus: { 1067 SetCommandCodeAuditStatus_In *in = (SetCommandCodeAuditStatus_In *) 1068 MemoryGetInBuffer(sizeof(SetCommandCodeAuditStatus_In)); 1069 in->auth = handles[0]; 1070 result = TPMI_ALG_HASH_Unmarshal(&in->auditAlg, paramBuffer, paramBufferSize, TRUE); 1071 EXIT_IF_ERROR_PLUS(RC_SetCommandCodeAuditStatus_auditAlg); 1072 result = TPML_CC_Unmarshal(&in->setList, paramBuffer, paramBufferSize); 1073 EXIT_IF_ERROR_PLUS(RC_SetCommandCodeAuditStatus_setList); 1074 result = TPML_CC_Unmarshal(&in->clearList, paramBuffer, paramBufferSize); 1075 EXIT_IF_ERROR_PLUS(RC_SetCommandCodeAuditStatus_clearList); 1076 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1077 result = TPM2_SetCommandCodeAuditStatus (in); 1078 break; 1079 } 1080 #endif // CC_SetCommandCodeAuditStatus 1081 #if CC_PCR_Extend 1082 case TPM_CC_PCR_Extend: { 1083 PCR_Extend_In *in = (PCR_Extend_In *) 1084 MemoryGetInBuffer(sizeof(PCR_Extend_In)); 1085 in->pcrHandle = handles[0]; 1086 result = TPML_DIGEST_VALUES_Unmarshal(&in->digests, paramBuffer, paramBufferSize); 1087 EXIT_IF_ERROR_PLUS(RC_PCR_Extend_digests); 1088 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1089 result = TPM2_PCR_Extend (in); 1090 break; 1091 } 1092 #endif // CC_PCR_Extend 1093 #if CC_PCR_Event 1094 case TPM_CC_PCR_Event: { 1095 PCR_Event_In *in = (PCR_Event_In *) 1096 MemoryGetInBuffer(sizeof(PCR_Event_In)); 1097 PCR_Event_Out *out = (PCR_Event_Out *) 1098 MemoryGetOutBuffer(sizeof(PCR_Event_Out)); 1099 in->pcrHandle = handles[0]; 1100 result = TPM2B_EVENT_Unmarshal(&in->eventData, paramBuffer, paramBufferSize); 1101 EXIT_IF_ERROR_PLUS(RC_PCR_Event_eventData); 1102 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1103 result = TPM2_PCR_Event (in, out); 1104 rSize = sizeof(PCR_Event_Out); 1105 *respParmSize += TPML_DIGEST_VALUES_Marshal(&out->digests, 1106 responseBuffer, &rSize); 1107 break; 1108 } 1109 #endif // CC_PCR_Event 1110 #if CC_PCR_Read 1111 case TPM_CC_PCR_Read: { 1112 PCR_Read_In *in = (PCR_Read_In *) 1113 MemoryGetInBuffer(sizeof(PCR_Read_In)); 1114 PCR_Read_Out *out = (PCR_Read_Out *) 1115 MemoryGetOutBuffer(sizeof(PCR_Read_Out)); 1116 result = TPML_PCR_SELECTION_Unmarshal(&in->pcrSelectionIn, paramBuffer, paramBufferSize); 1117 EXIT_IF_ERROR_PLUS(RC_PCR_Read_pcrSelectionIn); 1118 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1119 result = TPM2_PCR_Read (in, out); 1120 rSize = sizeof(PCR_Read_Out); 1121 *respParmSize += UINT32_Marshal(&out->pcrUpdateCounter, 1122 responseBuffer, &rSize); 1123 *respParmSize += TPML_PCR_SELECTION_Marshal(&out->pcrSelectionOut, 1124 responseBuffer, &rSize); 1125 *respParmSize += TPML_DIGEST_Marshal(&out->pcrValues, 1126 responseBuffer, &rSize); 1127 break; 1128 } 1129 #endif // CC_PCR_Read 1130 #if CC_PCR_Allocate 1131 case TPM_CC_PCR_Allocate: { 1132 PCR_Allocate_In *in = (PCR_Allocate_In *) 1133 MemoryGetInBuffer(sizeof(PCR_Allocate_In)); 1134 PCR_Allocate_Out *out = (PCR_Allocate_Out *) 1135 MemoryGetOutBuffer(sizeof(PCR_Allocate_Out)); 1136 in->authHandle = handles[0]; 1137 result = TPML_PCR_SELECTION_Unmarshal(&in->pcrAllocation, paramBuffer, paramBufferSize); 1138 EXIT_IF_ERROR_PLUS(RC_PCR_Allocate_pcrAllocation); 1139 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1140 result = TPM2_PCR_Allocate (in, out); 1141 rSize = sizeof(PCR_Allocate_Out); 1142 *respParmSize += TPMI_YES_NO_Marshal(&out->allocationSuccess, 1143 responseBuffer, &rSize); 1144 *respParmSize += UINT32_Marshal(&out->maxPCR, 1145 responseBuffer, &rSize); 1146 *respParmSize += UINT32_Marshal(&out->sizeNeeded, 1147 responseBuffer, &rSize); 1148 *respParmSize += UINT32_Marshal(&out->sizeAvailable, 1149 responseBuffer, &rSize); 1150 break; 1151 } 1152 #endif // CC_PCR_Allocate 1153 #if CC_PCR_SetAuthPolicy 1154 case TPM_CC_PCR_SetAuthPolicy: { 1155 PCR_SetAuthPolicy_In *in = (PCR_SetAuthPolicy_In *) 1156 MemoryGetInBuffer(sizeof(PCR_SetAuthPolicy_In)); 1157 in->authHandle = handles[0]; 1158 result = TPM2B_DIGEST_Unmarshal(&in->authPolicy, paramBuffer, paramBufferSize); 1159 EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthPolicy_authPolicy); 1160 result = TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE); 1161 EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthPolicy_hashAlg); 1162 result = TPMI_DH_PCR_Unmarshal(&in->pcrNum, paramBuffer, paramBufferSize, FALSE); 1163 EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthPolicy_pcrNum); 1164 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1165 result = TPM2_PCR_SetAuthPolicy (in); 1166 break; 1167 } 1168 #endif // CC_PCR_SetAuthPolicy 1169 #if CC_PCR_SetAuthValue 1170 case TPM_CC_PCR_SetAuthValue: { 1171 PCR_SetAuthValue_In *in = (PCR_SetAuthValue_In *) 1172 MemoryGetInBuffer(sizeof(PCR_SetAuthValue_In)); 1173 in->pcrHandle = handles[0]; 1174 result = TPM2B_DIGEST_Unmarshal(&in->auth, paramBuffer, paramBufferSize); 1175 EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthValue_auth); 1176 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1177 result = TPM2_PCR_SetAuthValue (in); 1178 break; 1179 } 1180 #endif // CC_PCR_SetAuthValue 1181 #if CC_PCR_Reset 1182 case TPM_CC_PCR_Reset: { 1183 PCR_Reset_In *in = (PCR_Reset_In *) 1184 MemoryGetInBuffer(sizeof(PCR_Reset_In)); 1185 in->pcrHandle = handles[0]; 1186 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1187 result = TPM2_PCR_Reset (in); 1188 break; 1189 } 1190 #endif // CC_PCR_Reset 1191 #if CC_PolicySigned 1192 case TPM_CC_PolicySigned: { 1193 PolicySigned_In *in = (PolicySigned_In *) 1194 MemoryGetInBuffer(sizeof(PolicySigned_In)); 1195 PolicySigned_Out *out = (PolicySigned_Out *) 1196 MemoryGetOutBuffer(sizeof(PolicySigned_Out)); 1197 in->authObject = handles[0]; 1198 in->policySession = handles[1]; 1199 result = TPM2B_NONCE_Unmarshal(&in->nonceTPM, paramBuffer, paramBufferSize); 1200 EXIT_IF_ERROR_PLUS(RC_PolicySigned_nonceTPM); 1201 result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize); 1202 EXIT_IF_ERROR_PLUS(RC_PolicySigned_cpHashA); 1203 result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize); 1204 EXIT_IF_ERROR_PLUS(RC_PolicySigned_policyRef); 1205 result = INT32_Unmarshal(&in->expiration, paramBuffer, paramBufferSize); 1206 EXIT_IF_ERROR_PLUS(RC_PolicySigned_expiration); 1207 result = TPMT_SIGNATURE_Unmarshal(&in->auth, paramBuffer, paramBufferSize, FALSE); 1208 EXIT_IF_ERROR_PLUS(RC_PolicySigned_auth); 1209 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1210 result = TPM2_PolicySigned (in, out); 1211 rSize = sizeof(PolicySigned_Out); 1212 *respParmSize += TPM2B_TIMEOUT_Marshal(&out->timeout, 1213 responseBuffer, &rSize); 1214 *respParmSize += TPMT_TK_AUTH_Marshal(&out->policyTicket, 1215 responseBuffer, &rSize); 1216 break; 1217 } 1218 #endif // CC_PolicySigned 1219 #if CC_PolicySecret 1220 case TPM_CC_PolicySecret: { 1221 PolicySecret_In *in = (PolicySecret_In *) 1222 MemoryGetInBuffer(sizeof(PolicySecret_In)); 1223 PolicySecret_Out *out = (PolicySecret_Out *) 1224 MemoryGetOutBuffer(sizeof(PolicySecret_Out)); 1225 in->authHandle = handles[0]; 1226 in->policySession = handles[1]; 1227 result = TPM2B_NONCE_Unmarshal(&in->nonceTPM, paramBuffer, paramBufferSize); 1228 EXIT_IF_ERROR_PLUS(RC_PolicySecret_nonceTPM); 1229 result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize); 1230 EXIT_IF_ERROR_PLUS(RC_PolicySecret_cpHashA); 1231 result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize); 1232 EXIT_IF_ERROR_PLUS(RC_PolicySecret_policyRef); 1233 result = INT32_Unmarshal(&in->expiration, paramBuffer, paramBufferSize); 1234 EXIT_IF_ERROR_PLUS(RC_PolicySecret_expiration); 1235 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1236 result = TPM2_PolicySecret (in, out); 1237 rSize = sizeof(PolicySecret_Out); 1238 *respParmSize += TPM2B_TIMEOUT_Marshal(&out->timeout, 1239 responseBuffer, &rSize); 1240 *respParmSize += TPMT_TK_AUTH_Marshal(&out->policyTicket, 1241 responseBuffer, &rSize); 1242 break; 1243 } 1244 #endif // CC_PolicySecret 1245 #if CC_PolicyTicket 1246 case TPM_CC_PolicyTicket: { 1247 PolicyTicket_In *in = (PolicyTicket_In *) 1248 MemoryGetInBuffer(sizeof(PolicyTicket_In)); 1249 in->policySession = handles[0]; 1250 result = TPM2B_TIMEOUT_Unmarshal(&in->timeout, paramBuffer, paramBufferSize); 1251 EXIT_IF_ERROR_PLUS(RC_PolicyTicket_timeout); 1252 result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize); 1253 EXIT_IF_ERROR_PLUS(RC_PolicyTicket_cpHashA); 1254 result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize); 1255 EXIT_IF_ERROR_PLUS(RC_PolicyTicket_policyRef); 1256 result = TPM2B_NAME_Unmarshal(&in->authName, paramBuffer, paramBufferSize); 1257 EXIT_IF_ERROR_PLUS(RC_PolicyTicket_authName); 1258 result = TPMT_TK_AUTH_Unmarshal(&in->ticket, paramBuffer, paramBufferSize); 1259 EXIT_IF_ERROR_PLUS(RC_PolicyTicket_ticket); 1260 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1261 result = TPM2_PolicyTicket (in); 1262 break; 1263 } 1264 #endif // CC_PolicyTicket 1265 #if CC_PolicyOR 1266 case TPM_CC_PolicyOR: { 1267 PolicyOR_In *in = (PolicyOR_In *) 1268 MemoryGetInBuffer(sizeof(PolicyOR_In)); 1269 in->policySession = handles[0]; 1270 result = TPML_DIGEST_Unmarshal(&in->pHashList, paramBuffer, paramBufferSize); 1271 EXIT_IF_ERROR_PLUS(RC_PolicyOR_pHashList); 1272 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1273 result = TPM2_PolicyOR (in); 1274 break; 1275 } 1276 #endif // CC_PolicyOR 1277 #if CC_PolicyPCR 1278 case TPM_CC_PolicyPCR: { 1279 PolicyPCR_In *in = (PolicyPCR_In *) 1280 MemoryGetInBuffer(sizeof(PolicyPCR_In)); 1281 in->policySession = handles[0]; 1282 result = TPM2B_DIGEST_Unmarshal(&in->pcrDigest, paramBuffer, paramBufferSize); 1283 EXIT_IF_ERROR_PLUS(RC_PolicyPCR_pcrDigest); 1284 result = TPML_PCR_SELECTION_Unmarshal(&in->pcrs, paramBuffer, paramBufferSize); 1285 EXIT_IF_ERROR_PLUS(RC_PolicyPCR_pcrs); 1286 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1287 result = TPM2_PolicyPCR (in); 1288 break; 1289 } 1290 #endif // CC_PolicyPCR 1291 #if CC_PolicyLocality 1292 case TPM_CC_PolicyLocality: { 1293 PolicyLocality_In *in = (PolicyLocality_In *) 1294 MemoryGetInBuffer(sizeof(PolicyLocality_In)); 1295 in->policySession = handles[0]; 1296 result = TPMA_LOCALITY_Unmarshal(&in->locality, paramBuffer, paramBufferSize); 1297 EXIT_IF_ERROR_PLUS(RC_PolicyLocality_locality); 1298 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1299 result = TPM2_PolicyLocality (in); 1300 break; 1301 } 1302 #endif // CC_PolicyLocality 1303 #if CC_PolicyNV 1304 case TPM_CC_PolicyNV: { 1305 PolicyNV_In *in = (PolicyNV_In *) 1306 MemoryGetInBuffer(sizeof(PolicyNV_In)); 1307 in->authHandle = handles[0]; 1308 in->nvIndex = handles[1]; 1309 in->policySession = handles[2]; 1310 result = TPM2B_OPERAND_Unmarshal(&in->operandB, paramBuffer, paramBufferSize); 1311 EXIT_IF_ERROR_PLUS(RC_PolicyNV_operandB); 1312 result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize); 1313 EXIT_IF_ERROR_PLUS(RC_PolicyNV_offset); 1314 result = TPM_EO_Unmarshal(&in->operation, paramBuffer, paramBufferSize); 1315 EXIT_IF_ERROR_PLUS(RC_PolicyNV_operation); 1316 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1317 result = TPM2_PolicyNV (in); 1318 break; 1319 } 1320 #endif // CC_PolicyNV 1321 #if CC_PolicyCounterTimer 1322 case TPM_CC_PolicyCounterTimer: { 1323 PolicyCounterTimer_In *in = (PolicyCounterTimer_In *) 1324 MemoryGetInBuffer(sizeof(PolicyCounterTimer_In)); 1325 in->policySession = handles[0]; 1326 result = TPM2B_OPERAND_Unmarshal(&in->operandB, paramBuffer, paramBufferSize); 1327 EXIT_IF_ERROR_PLUS(RC_PolicyCounterTimer_operandB); 1328 result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize); 1329 EXIT_IF_ERROR_PLUS(RC_PolicyCounterTimer_offset); 1330 result = TPM_EO_Unmarshal(&in->operation, paramBuffer, paramBufferSize); 1331 EXIT_IF_ERROR_PLUS(RC_PolicyCounterTimer_operation); 1332 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1333 result = TPM2_PolicyCounterTimer (in); 1334 break; 1335 } 1336 #endif // CC_PolicyCounterTimer 1337 #if CC_PolicyCommandCode 1338 case TPM_CC_PolicyCommandCode: { 1339 PolicyCommandCode_In *in = (PolicyCommandCode_In *) 1340 MemoryGetInBuffer(sizeof(PolicyCommandCode_In)); 1341 in->policySession = handles[0]; 1342 result = TPM_CC_Unmarshal(&in->code, paramBuffer, paramBufferSize); 1343 EXIT_IF_ERROR_PLUS(RC_PolicyCommandCode_code); 1344 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1345 result = TPM2_PolicyCommandCode (in); 1346 break; 1347 } 1348 #endif // CC_PolicyCommandCode 1349 #if CC_PolicyPhysicalPresence 1350 case TPM_CC_PolicyPhysicalPresence: { 1351 PolicyPhysicalPresence_In *in = (PolicyPhysicalPresence_In *) 1352 MemoryGetInBuffer(sizeof(PolicyPhysicalPresence_In)); 1353 in->policySession = handles[0]; 1354 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1355 result = TPM2_PolicyPhysicalPresence (in); 1356 break; 1357 } 1358 #endif // CC_PolicyPhysicalPresence 1359 #if CC_PolicyCpHash 1360 case TPM_CC_PolicyCpHash: { 1361 PolicyCpHash_In *in = (PolicyCpHash_In *) 1362 MemoryGetInBuffer(sizeof(PolicyCpHash_In)); 1363 in->policySession = handles[0]; 1364 result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize); 1365 EXIT_IF_ERROR_PLUS(RC_PolicyCpHash_cpHashA); 1366 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1367 result = TPM2_PolicyCpHash (in); 1368 break; 1369 } 1370 #endif // CC_PolicyCpHash 1371 #if CC_PolicyNameHash 1372 case TPM_CC_PolicyNameHash: { 1373 PolicyNameHash_In *in = (PolicyNameHash_In *) 1374 MemoryGetInBuffer(sizeof(PolicyNameHash_In)); 1375 in->policySession = handles[0]; 1376 result = TPM2B_DIGEST_Unmarshal(&in->nameHash, paramBuffer, paramBufferSize); 1377 EXIT_IF_ERROR_PLUS(RC_PolicyNameHash_nameHash); 1378 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1379 result = TPM2_PolicyNameHash (in); 1380 break; 1381 } 1382 #endif // CC_PolicyNameHash 1383 #if CC_PolicyDuplicationSelect 1384 case TPM_CC_PolicyDuplicationSelect: { 1385 PolicyDuplicationSelect_In *in = (PolicyDuplicationSelect_In *) 1386 MemoryGetInBuffer(sizeof(PolicyDuplicationSelect_In)); 1387 in->policySession = handles[0]; 1388 result = TPM2B_NAME_Unmarshal(&in->objectName, paramBuffer, paramBufferSize); 1389 EXIT_IF_ERROR_PLUS(RC_PolicyDuplicationSelect_objectName); 1390 result = TPM2B_NAME_Unmarshal(&in->newParentName, paramBuffer, paramBufferSize); 1391 EXIT_IF_ERROR_PLUS(RC_PolicyDuplicationSelect_newParentName); 1392 result = TPMI_YES_NO_Unmarshal(&in->includeObject, paramBuffer, paramBufferSize); 1393 EXIT_IF_ERROR_PLUS(RC_PolicyDuplicationSelect_includeObject); 1394 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1395 result = TPM2_PolicyDuplicationSelect (in); 1396 break; 1397 } 1398 #endif // CC_PolicyDuplicationSelect 1399 #if CC_PolicyAuthorize 1400 case TPM_CC_PolicyAuthorize: { 1401 PolicyAuthorize_In *in = (PolicyAuthorize_In *) 1402 MemoryGetInBuffer(sizeof(PolicyAuthorize_In)); 1403 in->policySession = handles[0]; 1404 result = TPM2B_DIGEST_Unmarshal(&in->approvedPolicy, paramBuffer, paramBufferSize); 1405 EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_approvedPolicy); 1406 result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize); 1407 EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_policyRef); 1408 result = TPM2B_NAME_Unmarshal(&in->keySign, paramBuffer, paramBufferSize); 1409 EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_keySign); 1410 result = TPMT_TK_VERIFIED_Unmarshal(&in->checkTicket, paramBuffer, paramBufferSize); 1411 EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_checkTicket); 1412 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1413 result = TPM2_PolicyAuthorize (in); 1414 break; 1415 } 1416 #endif // CC_PolicyAuthorize 1417 #if CC_PolicyAuthValue 1418 case TPM_CC_PolicyAuthValue: { 1419 PolicyAuthValue_In *in = (PolicyAuthValue_In *) 1420 MemoryGetInBuffer(sizeof(PolicyAuthValue_In)); 1421 in->policySession = handles[0]; 1422 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1423 result = TPM2_PolicyAuthValue (in); 1424 break; 1425 } 1426 #endif // CC_PolicyAuthValue 1427 #if CC_PolicyPassword 1428 case TPM_CC_PolicyPassword: { 1429 PolicyPassword_In *in = (PolicyPassword_In *) 1430 MemoryGetInBuffer(sizeof(PolicyPassword_In)); 1431 in->policySession = handles[0]; 1432 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1433 result = TPM2_PolicyPassword (in); 1434 break; 1435 } 1436 #endif // CC_PolicyPassword 1437 #if CC_PolicyGetDigest 1438 case TPM_CC_PolicyGetDigest: { 1439 PolicyGetDigest_In *in = (PolicyGetDigest_In *) 1440 MemoryGetInBuffer(sizeof(PolicyGetDigest_In)); 1441 PolicyGetDigest_Out *out = (PolicyGetDigest_Out *) 1442 MemoryGetOutBuffer(sizeof(PolicyGetDigest_Out)); 1443 in->policySession = handles[0]; 1444 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1445 result = TPM2_PolicyGetDigest (in, out); 1446 rSize = sizeof(PolicyGetDigest_Out); 1447 *respParmSize += TPM2B_DIGEST_Marshal(&out->policyDigest, 1448 responseBuffer, &rSize); 1449 break; 1450 } 1451 #endif // CC_PolicyGetDigest 1452 #if CC_PolicyNvWritten 1453 case TPM_CC_PolicyNvWritten: { 1454 PolicyNvWritten_In *in = (PolicyNvWritten_In *) 1455 MemoryGetInBuffer(sizeof(PolicyNvWritten_In)); 1456 in->policySession = handles[0]; 1457 result = TPMI_YES_NO_Unmarshal(&in->writtenSet, paramBuffer, paramBufferSize); 1458 EXIT_IF_ERROR_PLUS(RC_PolicyNvWritten_writtenSet); 1459 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1460 result = TPM2_PolicyNvWritten (in); 1461 break; 1462 } 1463 #endif // CC_PolicyNvWritten 1464 #if CC_PolicyTemplate 1465 case TPM_CC_PolicyTemplate: { 1466 PolicyTemplate_In *in = (PolicyTemplate_In *) 1467 MemoryGetInBuffer(sizeof(PolicyTemplate_In)); 1468 in->policySession = handles[0]; 1469 result = TPM2B_DIGEST_Unmarshal(&in->templateHash, paramBuffer, paramBufferSize); 1470 EXIT_IF_ERROR_PLUS(RC_PolicyTemplate_templateHash); 1471 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1472 result = TPM2_PolicyTemplate (in); 1473 break; 1474 } 1475 #endif // CC_PolicyTemplate 1476 #if CC_PolicyAuthorizeNV 1477 case TPM_CC_PolicyAuthorizeNV: { 1478 PolicyAuthorizeNV_In *in = (PolicyAuthorizeNV_In *) 1479 MemoryGetInBuffer(sizeof(PolicyAuthorizeNV_In)); 1480 in->authHandle = handles[0]; 1481 in->nvIndex = handles[1]; 1482 in->policySession = handles[2]; 1483 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1484 result = TPM2_PolicyAuthorizeNV (in); 1485 break; 1486 } 1487 #endif // CC_PolicyAuthorizeNV 1488 #if CC_CreatePrimary 1489 case TPM_CC_CreatePrimary: { 1490 CreatePrimary_In *in = (CreatePrimary_In *) 1491 MemoryGetInBuffer(sizeof(CreatePrimary_In)); 1492 CreatePrimary_Out *out = (CreatePrimary_Out *) 1493 MemoryGetOutBuffer(sizeof(CreatePrimary_Out)); 1494 in->primaryHandle = handles[0]; 1495 result = TPM2B_SENSITIVE_CREATE_Unmarshal(&in->inSensitive, paramBuffer, paramBufferSize); 1496 EXIT_IF_ERROR_PLUS(RC_CreatePrimary_inSensitive); 1497 result = TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, FALSE); 1498 EXIT_IF_ERROR_PLUS(RC_CreatePrimary_inPublic); 1499 result = TPM2B_DATA_Unmarshal(&in->outsideInfo, paramBuffer, paramBufferSize); 1500 EXIT_IF_ERROR_PLUS(RC_CreatePrimary_outsideInfo); 1501 result = TPML_PCR_SELECTION_Unmarshal(&in->creationPCR, paramBuffer, paramBufferSize); 1502 EXIT_IF_ERROR_PLUS(RC_CreatePrimary_creationPCR); 1503 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1504 result = TPM2_CreatePrimary (in, out); 1505 rSize = sizeof(CreatePrimary_Out); 1506 if(TPM_RC_SUCCESS != result) goto Exit; 1507 command->handles[command->handleNum++] = out->objectHandle; 1508 *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, 1509 responseBuffer, &rSize); 1510 *respParmSize += TPM2B_CREATION_DATA_Marshal(&out->creationData, 1511 responseBuffer, &rSize); 1512 *respParmSize += TPM2B_DIGEST_Marshal(&out->creationHash, 1513 responseBuffer, &rSize); 1514 *respParmSize += TPMT_TK_CREATION_Marshal(&out->creationTicket, 1515 responseBuffer, &rSize); 1516 *respParmSize += TPM2B_NAME_Marshal(&out->name, 1517 responseBuffer, &rSize); 1518 break; 1519 } 1520 #endif // CC_CreatePrimary 1521 #if CC_HierarchyControl 1522 case TPM_CC_HierarchyControl: { 1523 HierarchyControl_In *in = (HierarchyControl_In *) 1524 MemoryGetInBuffer(sizeof(HierarchyControl_In)); 1525 in->authHandle = handles[0]; 1526 result = TPMI_RH_ENABLES_Unmarshal(&in->enable, paramBuffer, paramBufferSize, FALSE); 1527 EXIT_IF_ERROR_PLUS(RC_HierarchyControl_enable); 1528 result = TPMI_YES_NO_Unmarshal(&in->state, paramBuffer, paramBufferSize); 1529 EXIT_IF_ERROR_PLUS(RC_HierarchyControl_state); 1530 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1531 result = TPM2_HierarchyControl (in); 1532 break; 1533 } 1534 #endif // CC_HierarchyControl 1535 #if CC_SetPrimaryPolicy 1536 case TPM_CC_SetPrimaryPolicy: { 1537 SetPrimaryPolicy_In *in = (SetPrimaryPolicy_In *) 1538 MemoryGetInBuffer(sizeof(SetPrimaryPolicy_In)); 1539 in->authHandle = handles[0]; 1540 result = TPM2B_DIGEST_Unmarshal(&in->authPolicy, paramBuffer, paramBufferSize); 1541 EXIT_IF_ERROR_PLUS(RC_SetPrimaryPolicy_authPolicy); 1542 result = TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE); 1543 EXIT_IF_ERROR_PLUS(RC_SetPrimaryPolicy_hashAlg); 1544 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1545 result = TPM2_SetPrimaryPolicy (in); 1546 break; 1547 } 1548 #endif // CC_SetPrimaryPolicy 1549 #if CC_ChangePPS 1550 case TPM_CC_ChangePPS: { 1551 ChangePPS_In *in = (ChangePPS_In *) 1552 MemoryGetInBuffer(sizeof(ChangePPS_In)); 1553 in->authHandle = handles[0]; 1554 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1555 result = TPM2_ChangePPS (in); 1556 break; 1557 } 1558 #endif // CC_ChangePPS 1559 #if CC_ChangeEPS 1560 case TPM_CC_ChangeEPS: { 1561 ChangeEPS_In *in = (ChangeEPS_In *) 1562 MemoryGetInBuffer(sizeof(ChangeEPS_In)); 1563 in->authHandle = handles[0]; 1564 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1565 result = TPM2_ChangeEPS (in); 1566 break; 1567 } 1568 #endif // CC_ChangeEPS 1569 #if CC_Clear 1570 case TPM_CC_Clear: { 1571 Clear_In *in = (Clear_In *) 1572 MemoryGetInBuffer(sizeof(Clear_In)); 1573 in->authHandle = handles[0]; 1574 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1575 result = TPM2_Clear (in); 1576 break; 1577 } 1578 #endif // CC_Clear 1579 #if CC_ClearControl 1580 case TPM_CC_ClearControl: { 1581 ClearControl_In *in = (ClearControl_In *) 1582 MemoryGetInBuffer(sizeof(ClearControl_In)); 1583 in->auth = handles[0]; 1584 result = TPMI_YES_NO_Unmarshal(&in->disable, paramBuffer, paramBufferSize); 1585 EXIT_IF_ERROR_PLUS(RC_ClearControl_disable); 1586 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1587 result = TPM2_ClearControl (in); 1588 break; 1589 } 1590 #endif // CC_ClearControl 1591 #if CC_HierarchyChangeAuth 1592 case TPM_CC_HierarchyChangeAuth: { 1593 HierarchyChangeAuth_In *in = (HierarchyChangeAuth_In *) 1594 MemoryGetInBuffer(sizeof(HierarchyChangeAuth_In)); 1595 in->authHandle = handles[0]; 1596 result = TPM2B_AUTH_Unmarshal(&in->newAuth, paramBuffer, paramBufferSize); 1597 EXIT_IF_ERROR_PLUS(RC_HierarchyChangeAuth_newAuth); 1598 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1599 result = TPM2_HierarchyChangeAuth (in); 1600 break; 1601 } 1602 #endif // CC_HierarchyChangeAuth 1603 #if CC_DictionaryAttackLockReset 1604 case TPM_CC_DictionaryAttackLockReset: { 1605 DictionaryAttackLockReset_In *in = (DictionaryAttackLockReset_In *) 1606 MemoryGetInBuffer(sizeof(DictionaryAttackLockReset_In)); 1607 in->lockHandle = handles[0]; 1608 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1609 result = TPM2_DictionaryAttackLockReset (in); 1610 break; 1611 } 1612 #endif // CC_DictionaryAttackLockReset 1613 #if CC_DictionaryAttackParameters 1614 case TPM_CC_DictionaryAttackParameters: { 1615 DictionaryAttackParameters_In *in = (DictionaryAttackParameters_In *) 1616 MemoryGetInBuffer(sizeof(DictionaryAttackParameters_In)); 1617 in->lockHandle = handles[0]; 1618 result = UINT32_Unmarshal(&in->newMaxTries, paramBuffer, paramBufferSize); 1619 EXIT_IF_ERROR_PLUS(RC_DictionaryAttackParameters_newMaxTries); 1620 result = UINT32_Unmarshal(&in->newRecoveryTime, paramBuffer, paramBufferSize); 1621 EXIT_IF_ERROR_PLUS(RC_DictionaryAttackParameters_newRecoveryTime); 1622 result = UINT32_Unmarshal(&in->lockoutRecovery, paramBuffer, paramBufferSize); 1623 EXIT_IF_ERROR_PLUS(RC_DictionaryAttackParameters_lockoutRecovery); 1624 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1625 result = TPM2_DictionaryAttackParameters (in); 1626 break; 1627 } 1628 #endif // CC_DictionaryAttackParameters 1629 #if CC_PP_Commands 1630 case TPM_CC_PP_Commands: { 1631 PP_Commands_In *in = (PP_Commands_In *) 1632 MemoryGetInBuffer(sizeof(PP_Commands_In)); 1633 in->auth = handles[0]; 1634 result = TPML_CC_Unmarshal(&in->setList, paramBuffer, paramBufferSize); 1635 EXIT_IF_ERROR_PLUS(RC_PP_Commands_setList); 1636 result = TPML_CC_Unmarshal(&in->clearList, paramBuffer, paramBufferSize); 1637 EXIT_IF_ERROR_PLUS(RC_PP_Commands_clearList); 1638 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1639 result = TPM2_PP_Commands (in); 1640 break; 1641 } 1642 #endif // CC_PP_Commands 1643 #if CC_SetAlgorithmSet 1644 case TPM_CC_SetAlgorithmSet: { 1645 SetAlgorithmSet_In *in = (SetAlgorithmSet_In *) 1646 MemoryGetInBuffer(sizeof(SetAlgorithmSet_In)); 1647 in->authHandle = handles[0]; 1648 result = UINT32_Unmarshal(&in->algorithmSet, paramBuffer, paramBufferSize); 1649 EXIT_IF_ERROR_PLUS(RC_SetAlgorithmSet_algorithmSet); 1650 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1651 result = TPM2_SetAlgorithmSet (in); 1652 break; 1653 } 1654 #endif // CC_SetAlgorithmSet 1655 #if CC_FieldUpgradeStart 1656 case TPM_CC_FieldUpgradeStart: { 1657 FieldUpgradeStart_In *in = (FieldUpgradeStart_In *) 1658 MemoryGetInBuffer(sizeof(FieldUpgradeStart_In)); 1659 in->authorization = handles[0]; 1660 in->keyHandle = handles[1]; 1661 result = TPM2B_DIGEST_Unmarshal(&in->fuDigest, paramBuffer, paramBufferSize); 1662 EXIT_IF_ERROR_PLUS(RC_FieldUpgradeStart_fuDigest); 1663 result = TPMT_SIGNATURE_Unmarshal(&in->manifestSignature, paramBuffer, paramBufferSize, FALSE); 1664 EXIT_IF_ERROR_PLUS(RC_FieldUpgradeStart_manifestSignature); 1665 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1666 result = TPM2_FieldUpgradeStart (in); 1667 break; 1668 } 1669 #endif // CC_FieldUpgradeStart 1670 #if CC_FieldUpgradeData 1671 case TPM_CC_FieldUpgradeData: { 1672 FieldUpgradeData_In *in = (FieldUpgradeData_In *) 1673 MemoryGetInBuffer(sizeof(FieldUpgradeData_In)); 1674 FieldUpgradeData_Out *out = (FieldUpgradeData_Out *) 1675 MemoryGetOutBuffer(sizeof(FieldUpgradeData_Out)); 1676 result = TPM2B_MAX_BUFFER_Unmarshal(&in->fuData, paramBuffer, paramBufferSize); 1677 EXIT_IF_ERROR_PLUS(RC_FieldUpgradeData_fuData); 1678 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1679 result = TPM2_FieldUpgradeData (in, out); 1680 rSize = sizeof(FieldUpgradeData_Out); 1681 *respParmSize += TPMT_HA_Marshal(&out->nextDigest, 1682 responseBuffer, &rSize); 1683 *respParmSize += TPMT_HA_Marshal(&out->firstDigest, 1684 responseBuffer, &rSize); 1685 break; 1686 } 1687 #endif // CC_FieldUpgradeData 1688 #if CC_FirmwareRead 1689 case TPM_CC_FirmwareRead: { 1690 FirmwareRead_In *in = (FirmwareRead_In *) 1691 MemoryGetInBuffer(sizeof(FirmwareRead_In)); 1692 FirmwareRead_Out *out = (FirmwareRead_Out *) 1693 MemoryGetOutBuffer(sizeof(FirmwareRead_Out)); 1694 result = UINT32_Unmarshal(&in->sequenceNumber, paramBuffer, paramBufferSize); 1695 EXIT_IF_ERROR_PLUS(RC_FirmwareRead_sequenceNumber); 1696 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1697 result = TPM2_FirmwareRead (in, out); 1698 rSize = sizeof(FirmwareRead_Out); 1699 *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->fuData, 1700 responseBuffer, &rSize); 1701 break; 1702 } 1703 #endif // CC_FirmwareRead 1704 #if CC_ContextSave 1705 case TPM_CC_ContextSave: { 1706 ContextSave_In *in = (ContextSave_In *) 1707 MemoryGetInBuffer(sizeof(ContextSave_In)); 1708 ContextSave_Out *out = (ContextSave_Out *) 1709 MemoryGetOutBuffer(sizeof(ContextSave_Out)); 1710 in->saveHandle = handles[0]; 1711 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1712 result = TPM2_ContextSave (in, out); 1713 rSize = sizeof(ContextSave_Out); 1714 *respParmSize += TPMS_CONTEXT_Marshal(&out->context, 1715 responseBuffer, &rSize); 1716 break; 1717 } 1718 #endif // CC_ContextSave 1719 #if CC_ContextLoad 1720 case TPM_CC_ContextLoad: { 1721 ContextLoad_In *in = (ContextLoad_In *) 1722 MemoryGetInBuffer(sizeof(ContextLoad_In)); 1723 ContextLoad_Out *out = (ContextLoad_Out *) 1724 MemoryGetOutBuffer(sizeof(ContextLoad_Out)); 1725 result = TPMS_CONTEXT_Unmarshal(&in->context, paramBuffer, paramBufferSize); 1726 EXIT_IF_ERROR_PLUS(RC_ContextLoad_context); 1727 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1728 result = TPM2_ContextLoad (in, out); 1729 rSize = sizeof(ContextLoad_Out); 1730 if(TPM_RC_SUCCESS != result) goto Exit; 1731 command->handles[command->handleNum++] = out->loadedHandle; 1732 break; 1733 } 1734 #endif // CC_ContextLoad 1735 #if CC_FlushContext 1736 case TPM_CC_FlushContext: { 1737 FlushContext_In *in = (FlushContext_In *) 1738 MemoryGetInBuffer(sizeof(FlushContext_In)); 1739 result = TPMI_DH_CONTEXT_Unmarshal(&in->flushHandle, paramBuffer, paramBufferSize); 1740 EXIT_IF_ERROR_PLUS(RC_FlushContext_flushHandle); 1741 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1742 result = TPM2_FlushContext (in); 1743 break; 1744 } 1745 #endif // CC_FlushContext 1746 #if CC_EvictControl 1747 case TPM_CC_EvictControl: { 1748 EvictControl_In *in = (EvictControl_In *) 1749 MemoryGetInBuffer(sizeof(EvictControl_In)); 1750 in->auth = handles[0]; 1751 in->objectHandle = handles[1]; 1752 result = TPMI_DH_PERSISTENT_Unmarshal(&in->persistentHandle, paramBuffer, paramBufferSize); 1753 EXIT_IF_ERROR_PLUS(RC_EvictControl_persistentHandle); 1754 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1755 result = TPM2_EvictControl (in); 1756 break; 1757 } 1758 #endif // CC_EvictControl 1759 #if CC_ReadClock 1760 case TPM_CC_ReadClock: { 1761 ReadClock_Out *out = (ReadClock_Out *) 1762 MemoryGetOutBuffer(sizeof(ReadClock_Out)); 1763 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1764 result = TPM2_ReadClock (out); 1765 rSize = sizeof(ReadClock_Out); 1766 *respParmSize += TPMS_TIME_INFO_Marshal(&out->currentTime, 1767 responseBuffer, &rSize); 1768 break; 1769 } 1770 #endif // CC_ReadClock 1771 #if CC_ClockSet 1772 case TPM_CC_ClockSet: { 1773 ClockSet_In *in = (ClockSet_In *) 1774 MemoryGetInBuffer(sizeof(ClockSet_In)); 1775 in->auth = handles[0]; 1776 result = UINT64_Unmarshal(&in->newTime, paramBuffer, paramBufferSize); 1777 EXIT_IF_ERROR_PLUS(RC_ClockSet_newTime); 1778 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1779 result = TPM2_ClockSet (in); 1780 break; 1781 } 1782 #endif // CC_ClockSet 1783 #if CC_ClockRateAdjust 1784 case TPM_CC_ClockRateAdjust: { 1785 ClockRateAdjust_In *in = (ClockRateAdjust_In *) 1786 MemoryGetInBuffer(sizeof(ClockRateAdjust_In)); 1787 in->auth = handles[0]; 1788 result = TPM_CLOCK_ADJUST_Unmarshal(&in->rateAdjust, paramBuffer, paramBufferSize); 1789 EXIT_IF_ERROR_PLUS(RC_ClockRateAdjust_rateAdjust); 1790 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1791 result = TPM2_ClockRateAdjust (in); 1792 break; 1793 } 1794 #endif // CC_ClockRateAdjust 1795 #if CC_GetCapability 1796 case TPM_CC_GetCapability: { 1797 GetCapability_In *in = (GetCapability_In *) 1798 MemoryGetInBuffer(sizeof(GetCapability_In)); 1799 GetCapability_Out *out = (GetCapability_Out *) 1800 MemoryGetOutBuffer(sizeof(GetCapability_Out)); 1801 result = TPM_CAP_Unmarshal(&in->capability, paramBuffer, paramBufferSize); 1802 EXIT_IF_ERROR_PLUS(RC_GetCapability_capability); 1803 result = UINT32_Unmarshal(&in->property, paramBuffer, paramBufferSize); 1804 EXIT_IF_ERROR_PLUS(RC_GetCapability_property); 1805 result = UINT32_Unmarshal(&in->propertyCount, paramBuffer, paramBufferSize); 1806 EXIT_IF_ERROR_PLUS(RC_GetCapability_propertyCount); 1807 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1808 result = TPM2_GetCapability (in, out); 1809 rSize = sizeof(GetCapability_Out); 1810 *respParmSize += TPMI_YES_NO_Marshal(&out->moreData, 1811 responseBuffer, &rSize); 1812 *respParmSize += TPMS_CAPABILITY_DATA_Marshal(&out->capabilityData, 1813 responseBuffer, &rSize); 1814 break; 1815 } 1816 #endif // CC_GetCapability 1817 #if CC_TestParms 1818 case TPM_CC_TestParms: { 1819 TestParms_In *in = (TestParms_In *) 1820 MemoryGetInBuffer(sizeof(TestParms_In)); 1821 result = TPMT_PUBLIC_PARMS_Unmarshal(&in->parameters, paramBuffer, paramBufferSize); 1822 EXIT_IF_ERROR_PLUS(RC_TestParms_parameters); 1823 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1824 result = TPM2_TestParms (in); 1825 break; 1826 } 1827 #endif // CC_TestParms 1828 #if CC_NV_DefineSpace 1829 case TPM_CC_NV_DefineSpace: { 1830 NV_DefineSpace_In *in = (NV_DefineSpace_In *) 1831 MemoryGetInBuffer(sizeof(NV_DefineSpace_In)); 1832 in->authHandle = handles[0]; 1833 result = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize); 1834 EXIT_IF_ERROR_PLUS(RC_NV_DefineSpace_auth); 1835 result = TPM2B_NV_PUBLIC_Unmarshal(&in->publicInfo, paramBuffer, paramBufferSize); 1836 EXIT_IF_ERROR_PLUS(RC_NV_DefineSpace_publicInfo); 1837 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1838 result = TPM2_NV_DefineSpace (in); 1839 break; 1840 } 1841 #endif // CC_NV_DefineSpace 1842 #if CC_NV_UndefineSpace 1843 case TPM_CC_NV_UndefineSpace: { 1844 NV_UndefineSpace_In *in = (NV_UndefineSpace_In *) 1845 MemoryGetInBuffer(sizeof(NV_UndefineSpace_In)); 1846 in->authHandle = handles[0]; 1847 in->nvIndex = handles[1]; 1848 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1849 result = TPM2_NV_UndefineSpace (in); 1850 break; 1851 } 1852 #endif // CC_NV_UndefineSpace 1853 #if CC_NV_UndefineSpaceSpecial 1854 case TPM_CC_NV_UndefineSpaceSpecial: { 1855 NV_UndefineSpaceSpecial_In *in = (NV_UndefineSpaceSpecial_In *) 1856 MemoryGetInBuffer(sizeof(NV_UndefineSpaceSpecial_In)); 1857 in->nvIndex = handles[0]; 1858 in->platform = handles[1]; 1859 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1860 result = TPM2_NV_UndefineSpaceSpecial (in); 1861 break; 1862 } 1863 #endif // CC_NV_UndefineSpaceSpecial 1864 #if CC_NV_ReadPublic 1865 case TPM_CC_NV_ReadPublic: { 1866 NV_ReadPublic_In *in = (NV_ReadPublic_In *) 1867 MemoryGetInBuffer(sizeof(NV_ReadPublic_In)); 1868 NV_ReadPublic_Out *out = (NV_ReadPublic_Out *) 1869 MemoryGetOutBuffer(sizeof(NV_ReadPublic_Out)); 1870 in->nvIndex = handles[0]; 1871 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1872 result = TPM2_NV_ReadPublic (in, out); 1873 rSize = sizeof(NV_ReadPublic_Out); 1874 *respParmSize += TPM2B_NV_PUBLIC_Marshal(&out->nvPublic, 1875 responseBuffer, &rSize); 1876 *respParmSize += TPM2B_NAME_Marshal(&out->nvName, 1877 responseBuffer, &rSize); 1878 break; 1879 } 1880 #endif // CC_NV_ReadPublic 1881 #if CC_NV_Write 1882 case TPM_CC_NV_Write: { 1883 NV_Write_In *in = (NV_Write_In *) 1884 MemoryGetInBuffer(sizeof(NV_Write_In)); 1885 in->authHandle = handles[0]; 1886 in->nvIndex = handles[1]; 1887 result = TPM2B_MAX_NV_BUFFER_Unmarshal(&in->data, paramBuffer, paramBufferSize); 1888 EXIT_IF_ERROR_PLUS(RC_NV_Write_data); 1889 result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize); 1890 EXIT_IF_ERROR_PLUS(RC_NV_Write_offset); 1891 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1892 result = TPM2_NV_Write (in); 1893 break; 1894 } 1895 #endif // CC_NV_Write 1896 #if CC_NV_Increment 1897 case TPM_CC_NV_Increment: { 1898 NV_Increment_In *in = (NV_Increment_In *) 1899 MemoryGetInBuffer(sizeof(NV_Increment_In)); 1900 in->authHandle = handles[0]; 1901 in->nvIndex = handles[1]; 1902 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1903 result = TPM2_NV_Increment (in); 1904 break; 1905 } 1906 #endif // CC_NV_Increment 1907 #if CC_NV_Extend 1908 case TPM_CC_NV_Extend: { 1909 NV_Extend_In *in = (NV_Extend_In *) 1910 MemoryGetInBuffer(sizeof(NV_Extend_In)); 1911 in->authHandle = handles[0]; 1912 in->nvIndex = handles[1]; 1913 result = TPM2B_MAX_NV_BUFFER_Unmarshal(&in->data, paramBuffer, paramBufferSize); 1914 EXIT_IF_ERROR_PLUS(RC_NV_Extend_data); 1915 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1916 result = TPM2_NV_Extend (in); 1917 break; 1918 } 1919 #endif // CC_NV_Extend 1920 #if CC_NV_SetBits 1921 case TPM_CC_NV_SetBits: { 1922 NV_SetBits_In *in = (NV_SetBits_In *) 1923 MemoryGetInBuffer(sizeof(NV_SetBits_In)); 1924 in->authHandle = handles[0]; 1925 in->nvIndex = handles[1]; 1926 result = UINT64_Unmarshal(&in->bits, paramBuffer, paramBufferSize); 1927 EXIT_IF_ERROR_PLUS(RC_NV_SetBits_bits); 1928 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1929 result = TPM2_NV_SetBits (in); 1930 break; 1931 } 1932 #endif // CC_NV_SetBits 1933 #if CC_NV_WriteLock 1934 case TPM_CC_NV_WriteLock: { 1935 NV_WriteLock_In *in = (NV_WriteLock_In *) 1936 MemoryGetInBuffer(sizeof(NV_WriteLock_In)); 1937 in->authHandle = handles[0]; 1938 in->nvIndex = handles[1]; 1939 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1940 result = TPM2_NV_WriteLock (in); 1941 break; 1942 } 1943 #endif // CC_NV_WriteLock 1944 #if CC_NV_GlobalWriteLock 1945 case TPM_CC_NV_GlobalWriteLock: { 1946 NV_GlobalWriteLock_In *in = (NV_GlobalWriteLock_In *) 1947 MemoryGetInBuffer(sizeof(NV_GlobalWriteLock_In)); 1948 in->authHandle = handles[0]; 1949 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1950 result = TPM2_NV_GlobalWriteLock (in); 1951 break; 1952 } 1953 #endif // CC_NV_GlobalWriteLock 1954 #if CC_NV_Read 1955 case TPM_CC_NV_Read: { 1956 NV_Read_In *in = (NV_Read_In *) 1957 MemoryGetInBuffer(sizeof(NV_Read_In)); 1958 NV_Read_Out *out = (NV_Read_Out *) 1959 MemoryGetOutBuffer(sizeof(NV_Read_Out)); 1960 in->authHandle = handles[0]; 1961 in->nvIndex = handles[1]; 1962 result = UINT16_Unmarshal(&in->size, paramBuffer, paramBufferSize); 1963 EXIT_IF_ERROR_PLUS(RC_NV_Read_size); 1964 result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize); 1965 EXIT_IF_ERROR_PLUS(RC_NV_Read_offset); 1966 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1967 result = TPM2_NV_Read (in, out); 1968 rSize = sizeof(NV_Read_Out); 1969 *respParmSize += TPM2B_MAX_NV_BUFFER_Marshal(&out->data, 1970 responseBuffer, &rSize); 1971 break; 1972 } 1973 #endif // CC_NV_Read 1974 #if CC_NV_ReadLock 1975 case TPM_CC_NV_ReadLock: { 1976 NV_ReadLock_In *in = (NV_ReadLock_In *) 1977 MemoryGetInBuffer(sizeof(NV_ReadLock_In)); 1978 in->authHandle = handles[0]; 1979 in->nvIndex = handles[1]; 1980 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1981 result = TPM2_NV_ReadLock (in); 1982 break; 1983 } 1984 #endif // CC_NV_ReadLock 1985 #if CC_NV_ChangeAuth 1986 case TPM_CC_NV_ChangeAuth: { 1987 NV_ChangeAuth_In *in = (NV_ChangeAuth_In *) 1988 MemoryGetInBuffer(sizeof(NV_ChangeAuth_In)); 1989 in->nvIndex = handles[0]; 1990 result = TPM2B_AUTH_Unmarshal(&in->newAuth, paramBuffer, paramBufferSize); 1991 EXIT_IF_ERROR_PLUS(RC_NV_ChangeAuth_newAuth); 1992 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 1993 result = TPM2_NV_ChangeAuth (in); 1994 break; 1995 } 1996 #endif // CC_NV_ChangeAuth 1997 #if CC_NV_Certify 1998 case TPM_CC_NV_Certify: { 1999 NV_Certify_In *in = (NV_Certify_In *) 2000 MemoryGetInBuffer(sizeof(NV_Certify_In)); 2001 NV_Certify_Out *out = (NV_Certify_Out *) 2002 MemoryGetOutBuffer(sizeof(NV_Certify_Out)); 2003 in->signHandle = handles[0]; 2004 in->authHandle = handles[1]; 2005 in->nvIndex = handles[2]; 2006 result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize); 2007 EXIT_IF_ERROR_PLUS(RC_NV_Certify_qualifyingData); 2008 result = TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE); 2009 EXIT_IF_ERROR_PLUS(RC_NV_Certify_inScheme); 2010 result = UINT16_Unmarshal(&in->size, paramBuffer, paramBufferSize); 2011 EXIT_IF_ERROR_PLUS(RC_NV_Certify_size); 2012 result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize); 2013 EXIT_IF_ERROR_PLUS(RC_NV_Certify_offset); 2014 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 2015 result = TPM2_NV_Certify (in, out); 2016 rSize = sizeof(NV_Certify_Out); 2017 *respParmSize += TPM2B_ATTEST_Marshal(&out->certifyInfo, 2018 responseBuffer, &rSize); 2019 *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, 2020 responseBuffer, &rSize); 2021 break; 2022 } 2023 #endif // CC_NV_Certify 2024 #if CC_AC_GetCapability 2025 case TPM_CC_AC_GetCapability: { 2026 AC_GetCapability_In *in = (AC_GetCapability_In *) 2027 MemoryGetInBuffer(sizeof(AC_GetCapability_In)); 2028 AC_GetCapability_Out *out = (AC_GetCapability_Out *) 2029 MemoryGetOutBuffer(sizeof(AC_GetCapability_Out)); 2030 in->ac = handles[0]; 2031 result = TPM_AT_Unmarshal(&in->capability, paramBuffer, paramBufferSize); 2032 EXIT_IF_ERROR_PLUS(RC_AC_GetCapability_capability); 2033 result = UINT32_Unmarshal(&in->count, paramBuffer, paramBufferSize); 2034 EXIT_IF_ERROR_PLUS(RC_AC_GetCapability_count); 2035 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 2036 result = TPM2_AC_GetCapability (in, out); 2037 rSize = sizeof(AC_GetCapability_Out); 2038 *respParmSize += TPMI_YES_NO_Marshal(&out->moreData, 2039 responseBuffer, &rSize); 2040 *respParmSize += TPML_AC_CAPABILITIES_Marshal(&out->capabilitiesData, 2041 responseBuffer, &rSize); 2042 break; 2043 } 2044 #endif // CC_AC_GetCapability 2045 #if CC_AC_Send 2046 case TPM_CC_AC_Send: { 2047 AC_Send_In *in = (AC_Send_In *) 2048 MemoryGetInBuffer(sizeof(AC_Send_In)); 2049 AC_Send_Out *out = (AC_Send_Out *) 2050 MemoryGetOutBuffer(sizeof(AC_Send_Out)); 2051 in->sendObject = handles[0]; 2052 in->authHandle = handles[1]; 2053 in->ac = handles[2]; 2054 result = TPM2B_MAX_BUFFER_Unmarshal(&in->acDataIn, paramBuffer, paramBufferSize); 2055 EXIT_IF_ERROR_PLUS(RC_AC_Send_acDataIn); 2056 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 2057 result = TPM2_AC_Send (in, out); 2058 rSize = sizeof(AC_Send_Out); 2059 *respParmSize += TPMS_AC_OUTPUT_Marshal(&out->acDataOut, 2060 responseBuffer, &rSize); 2061 break; 2062 } 2063 #endif // CC_AC_Send 2064 #if CC_Policy_AC_SendSelect 2065 case TPM_CC_Policy_AC_SendSelect: { 2066 Policy_AC_SendSelect_In *in = (Policy_AC_SendSelect_In *) 2067 MemoryGetInBuffer(sizeof(Policy_AC_SendSelect_In)); 2068 in->policySession = handles[0]; 2069 result = TPM2B_NAME_Unmarshal(&in->objectName, paramBuffer, paramBufferSize); 2070 EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_objectName); 2071 result = TPM2B_NAME_Unmarshal(&in->authHandleName, paramBuffer, paramBufferSize); 2072 EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_authHandleName); 2073 result = TPM2B_NAME_Unmarshal(&in->acName, paramBuffer, paramBufferSize); 2074 EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_acName); 2075 result = TPMI_YES_NO_Unmarshal(&in->includeObject, paramBuffer, paramBufferSize); 2076 EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_includeObject); 2077 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 2078 result = TPM2_Policy_AC_SendSelect (in); 2079 break; 2080 } 2081 #endif // CC_Policy_AC_SendSelect 2082 #if CC_ACT_SetTimeout 2083 case TPM_CC_ACT_SetTimeout: { 2084 ACT_SetTimeout_In *in = (ACT_SetTimeout_In *) 2085 MemoryGetInBuffer(sizeof(ACT_SetTimeout_In)); 2086 in->actHandle = handles[0]; 2087 result = UINT32_Unmarshal(&in->startTimeout, paramBuffer, paramBufferSize); 2088 EXIT_IF_ERROR_PLUS(RC_ACT_SetTimeout_startTimeout); 2089 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 2090 result = TPM2_ACT_SetTimeout (in); 2091 break; 2092 } 2093 #endif // CC_ACT_SetTimeout 2094 #if CC_Vendor_TCG_Test 2095 case TPM_CC_Vendor_TCG_Test: { 2096 Vendor_TCG_Test_In *in = (Vendor_TCG_Test_In *) 2097 MemoryGetInBuffer(sizeof(Vendor_TCG_Test_In)); 2098 Vendor_TCG_Test_Out *out = (Vendor_TCG_Test_Out *) 2099 MemoryGetOutBuffer(sizeof(Vendor_TCG_Test_Out)); 2100 result = TPM2B_DATA_Unmarshal(&in->inputData, paramBuffer, paramBufferSize); 2101 EXIT_IF_ERROR_PLUS(RC_Vendor_TCG_Test_inputData); 2102 if(*paramBufferSize != 0) { result = TPM_RC_SIZE; goto Exit; } 2103 result = TPM2_Vendor_TCG_Test (in, out); 2104 rSize = sizeof(Vendor_TCG_Test_Out); 2105 *respParmSize += TPM2B_DATA_Marshal(&out->outputData, 2106 responseBuffer, &rSize); 2107 break; 2108 } 2109 #endif // CC_Vendor_TCG_Test 2110