1 // 2 // Copyright (C) 2014 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 #ifndef TRUNKS_MOCK_TPM_H_ 18 #define TRUNKS_MOCK_TPM_H_ 19 20 #include <string> 21 22 #include <base/callback.h> 23 #include <gmock/gmock.h> 24 25 #include "trunks/tpm_generated.h" 26 27 namespace trunks { 28 29 class MockTpm : public Tpm { 30 public: 31 MockTpm(); 32 ~MockTpm() override; 33 34 MOCK_METHOD3(Startup, 35 void(const TPM_SU& startup_type, 36 AuthorizationDelegate* authorization_delegate, 37 const StartupResponse& callback)); 38 MOCK_METHOD2(StartupSync, 39 TPM_RC(const TPM_SU& startup_type, 40 AuthorizationDelegate* authorization_delegate)); 41 MOCK_METHOD3(Shutdown, 42 void(const TPM_SU& shutdown_type, 43 AuthorizationDelegate* authorization_delegate, 44 const ShutdownResponse& callback)); 45 MOCK_METHOD2(ShutdownSync, 46 TPM_RC(const TPM_SU& shutdown_type, 47 AuthorizationDelegate* authorization_delegate)); 48 MOCK_METHOD3(SelfTest, 49 void(const TPMI_YES_NO& full_test, 50 AuthorizationDelegate* authorization_delegate, 51 const SelfTestResponse& callback)); 52 MOCK_METHOD2(SelfTestSync, 53 TPM_RC(const TPMI_YES_NO& full_test, 54 AuthorizationDelegate* authorization_delegate)); 55 MOCK_METHOD3(IncrementalSelfTest, 56 void(const TPML_ALG& to_test, 57 AuthorizationDelegate* authorization_delegate, 58 const IncrementalSelfTestResponse& callback)); 59 MOCK_METHOD3(IncrementalSelfTestSync, 60 TPM_RC(const TPML_ALG& to_test, 61 TPML_ALG* to_do_list, 62 AuthorizationDelegate* authorization_delegate)); 63 MOCK_METHOD2(GetTestResult, 64 void(AuthorizationDelegate* authorization_delegate, 65 const GetTestResultResponse& callback)); 66 MOCK_METHOD3(GetTestResultSync, 67 TPM_RC(TPM2B_MAX_BUFFER* out_data, 68 TPM_RC* test_result, 69 AuthorizationDelegate* authorization_delegate)); 70 // Too many args to mock, forward to *Short version. 71 void StartAuthSession(const TPMI_DH_OBJECT& tpm_key, 72 const std::string& tpm_key_name, 73 const TPMI_DH_ENTITY& bind, 74 const std::string& bind_name, 75 const TPM2B_NONCE& nonce_caller, 76 const TPM2B_ENCRYPTED_SECRET& encrypted_salt, 77 const TPM_SE& session_type, 78 const TPMT_SYM_DEF& symmetric, 79 const TPMI_ALG_HASH& auth_hash, 80 AuthorizationDelegate* authorization_delegate, 81 const StartAuthSessionResponse& callback) override; 82 MOCK_METHOD9(StartAuthSessionShort, 83 void(const TPMI_DH_OBJECT& tpm_key, 84 const TPMI_DH_ENTITY& bind, 85 const TPM2B_NONCE& nonce_caller, 86 const TPM2B_ENCRYPTED_SECRET& encrypted_salt, 87 const TPM_SE& session_type, 88 const TPMT_SYM_DEF& symmetric, 89 const TPMI_ALG_HASH& auth_hash, 90 AuthorizationDelegate* authorization_delegate, 91 const StartAuthSessionResponse& callback)); 92 // Too many args to mock, forward to *Short version. 93 TPM_RC StartAuthSessionSync( 94 const TPMI_DH_OBJECT& tpm_key, 95 const std::string& tpm_key_name, 96 const TPMI_DH_ENTITY& bind, 97 const std::string& bind_name, 98 const TPM2B_NONCE& nonce_caller, 99 const TPM2B_ENCRYPTED_SECRET& encrypted_salt, 100 const TPM_SE& session_type, 101 const TPMT_SYM_DEF& symmetric, 102 const TPMI_ALG_HASH& auth_hash, 103 TPMI_SH_AUTH_SESSION* session_handle, 104 TPM2B_NONCE* nonce_tpm, 105 AuthorizationDelegate* authorization_delegate) override; 106 MOCK_METHOD10(StartAuthSessionSyncShort, 107 TPM_RC(const TPMI_DH_OBJECT& tpm_key, 108 const TPMI_DH_ENTITY& bind, 109 const TPM2B_NONCE& nonce_caller, 110 const TPM2B_ENCRYPTED_SECRET& encrypted_salt, 111 const TPM_SE& session_type, 112 const TPMT_SYM_DEF& symmetric, 113 const TPMI_ALG_HASH& auth_hash, 114 TPMI_SH_AUTH_SESSION* session_handle, 115 TPM2B_NONCE* nonce_tpm, 116 AuthorizationDelegate* authorization_delegate)); 117 MOCK_METHOD4(PolicyRestart, 118 void(const TPMI_SH_POLICY& session_handle, 119 const std::string& session_handle_name, 120 AuthorizationDelegate* authorization_delegate, 121 const PolicyRestartResponse& callback)); 122 MOCK_METHOD3(PolicyRestartSync, 123 TPM_RC(const TPMI_SH_POLICY& session_handle, 124 const std::string& session_handle_name, 125 AuthorizationDelegate* authorization_delegate)); 126 MOCK_METHOD8(Create, 127 void(const TPMI_DH_OBJECT& parent_handle, 128 const std::string& parent_handle_name, 129 const TPM2B_SENSITIVE_CREATE& in_sensitive, 130 const TPM2B_PUBLIC& in_public, 131 const TPM2B_DATA& outside_info, 132 const TPML_PCR_SELECTION& creation_pcr, 133 AuthorizationDelegate* authorization_delegate, 134 const CreateResponse& callback)); 135 // Too many args to mock, forward to *Short version. 136 TPM_RC CreateSync(const TPMI_DH_OBJECT& parent_handle, 137 const std::string& parent_handle_name, 138 const TPM2B_SENSITIVE_CREATE& in_sensitive, 139 const TPM2B_PUBLIC& in_public, 140 const TPM2B_DATA& outside_info, 141 const TPML_PCR_SELECTION& creation_pcr, 142 TPM2B_PRIVATE* out_private, 143 TPM2B_PUBLIC* out_public, 144 TPM2B_CREATION_DATA* creation_data, 145 TPM2B_DIGEST* creation_hash, 146 TPMT_TK_CREATION* creation_ticket, 147 AuthorizationDelegate* authorization_delegate) override; 148 MOCK_METHOD10(CreateSyncShort, 149 TPM_RC(const TPMI_DH_OBJECT& parent_handle, 150 const TPM2B_SENSITIVE_CREATE& in_sensitive, 151 const TPM2B_PUBLIC& in_public, 152 const TPML_PCR_SELECTION& creation_pcr, 153 TPM2B_PRIVATE* out_private, 154 TPM2B_PUBLIC* out_public, 155 TPM2B_CREATION_DATA* creation_data, 156 TPM2B_DIGEST* creation_hash, 157 TPMT_TK_CREATION* creation_ticket, 158 AuthorizationDelegate* authorization_delegate)); 159 MOCK_METHOD6(Load, 160 void(const TPMI_DH_OBJECT& parent_handle, 161 const std::string& parent_handle_name, 162 const TPM2B_PRIVATE& in_private, 163 const TPM2B_PUBLIC& in_public, 164 AuthorizationDelegate* authorization_delegate, 165 const LoadResponse& callback)); 166 MOCK_METHOD7(LoadSync, 167 TPM_RC(const TPMI_DH_OBJECT& parent_handle, 168 const std::string& parent_handle_name, 169 const TPM2B_PRIVATE& in_private, 170 const TPM2B_PUBLIC& in_public, 171 TPM_HANDLE* object_handle, 172 TPM2B_NAME* name, 173 AuthorizationDelegate* authorization_delegate)); 174 MOCK_METHOD5(LoadExternal, 175 void(const TPM2B_SENSITIVE& in_private, 176 const TPM2B_PUBLIC& in_public, 177 const TPMI_RH_HIERARCHY& hierarchy, 178 AuthorizationDelegate* authorization_delegate, 179 const LoadExternalResponse& callback)); 180 MOCK_METHOD6(LoadExternalSync, 181 TPM_RC(const TPM2B_SENSITIVE& in_private, 182 const TPM2B_PUBLIC& in_public, 183 const TPMI_RH_HIERARCHY& hierarchy, 184 TPM_HANDLE* object_handle, 185 TPM2B_NAME* name, 186 AuthorizationDelegate* authorization_delegate)); 187 MOCK_METHOD4(ReadPublic, 188 void(const TPMI_DH_OBJECT& object_handle, 189 const std::string& object_handle_name, 190 AuthorizationDelegate* authorization_delegate, 191 const ReadPublicResponse& callback)); 192 MOCK_METHOD6(ReadPublicSync, 193 TPM_RC(const TPMI_DH_OBJECT& object_handle, 194 const std::string& object_handle_name, 195 TPM2B_PUBLIC* out_public, 196 TPM2B_NAME* name, 197 TPM2B_NAME* qualified_name, 198 AuthorizationDelegate* authorization_delegate)); 199 MOCK_METHOD8(ActivateCredential, 200 void(const TPMI_DH_OBJECT& activate_handle, 201 const std::string& activate_handle_name, 202 const TPMI_DH_OBJECT& key_handle, 203 const std::string& key_handle_name, 204 const TPM2B_ID_OBJECT& credential_blob, 205 const TPM2B_ENCRYPTED_SECRET& secret, 206 AuthorizationDelegate* authorization_delegate, 207 const ActivateCredentialResponse& callback)); 208 MOCK_METHOD8(ActivateCredentialSync, 209 TPM_RC(const TPMI_DH_OBJECT& activate_handle, 210 const std::string& activate_handle_name, 211 const TPMI_DH_OBJECT& key_handle, 212 const std::string& key_handle_name, 213 const TPM2B_ID_OBJECT& credential_blob, 214 const TPM2B_ENCRYPTED_SECRET& secret, 215 TPM2B_DIGEST* cert_info, 216 AuthorizationDelegate* authorization_delegate)); 217 MOCK_METHOD6(MakeCredential, 218 void(const TPMI_DH_OBJECT& handle, 219 const std::string& handle_name, 220 const TPM2B_DIGEST& credential, 221 const TPM2B_NAME& object_name, 222 AuthorizationDelegate* authorization_delegate, 223 const MakeCredentialResponse& callback)); 224 MOCK_METHOD7(MakeCredentialSync, 225 TPM_RC(const TPMI_DH_OBJECT& handle, 226 const std::string& handle_name, 227 const TPM2B_DIGEST& credential, 228 const TPM2B_NAME& object_name, 229 TPM2B_ID_OBJECT* credential_blob, 230 TPM2B_ENCRYPTED_SECRET* secret, 231 AuthorizationDelegate* authorization_delegate)); 232 MOCK_METHOD4(Unseal, 233 void(const TPMI_DH_OBJECT& item_handle, 234 const std::string& item_handle_name, 235 AuthorizationDelegate* authorization_delegate, 236 const UnsealResponse& callback)); 237 MOCK_METHOD4(UnsealSync, 238 TPM_RC(const TPMI_DH_OBJECT& item_handle, 239 const std::string& item_handle_name, 240 TPM2B_SENSITIVE_DATA* out_data, 241 AuthorizationDelegate* authorization_delegate)); 242 MOCK_METHOD7(ObjectChangeAuth, 243 void(const TPMI_DH_OBJECT& object_handle, 244 const std::string& object_handle_name, 245 const TPMI_DH_OBJECT& parent_handle, 246 const std::string& parent_handle_name, 247 const TPM2B_AUTH& new_auth, 248 AuthorizationDelegate* authorization_delegate, 249 const ObjectChangeAuthResponse& callback)); 250 MOCK_METHOD7(ObjectChangeAuthSync, 251 TPM_RC(const TPMI_DH_OBJECT& object_handle, 252 const std::string& object_handle_name, 253 const TPMI_DH_OBJECT& parent_handle, 254 const std::string& parent_handle_name, 255 const TPM2B_AUTH& new_auth, 256 TPM2B_PRIVATE* out_private, 257 AuthorizationDelegate* authorization_delegate)); 258 MOCK_METHOD8(Duplicate, 259 void(const TPMI_DH_OBJECT& object_handle, 260 const std::string& object_handle_name, 261 const TPMI_DH_OBJECT& new_parent_handle, 262 const std::string& new_parent_handle_name, 263 const TPM2B_DATA& encryption_key_in, 264 const TPMT_SYM_DEF_OBJECT& symmetric_alg, 265 AuthorizationDelegate* authorization_delegate, 266 const DuplicateResponse& callback)); 267 MOCK_METHOD10(DuplicateSync, 268 TPM_RC(const TPMI_DH_OBJECT& object_handle, 269 const std::string& object_handle_name, 270 const TPMI_DH_OBJECT& new_parent_handle, 271 const std::string& new_parent_handle_name, 272 const TPM2B_DATA& encryption_key_in, 273 const TPMT_SYM_DEF_OBJECT& symmetric_alg, 274 TPM2B_DATA* encryption_key_out, 275 TPM2B_PRIVATE* duplicate, 276 TPM2B_ENCRYPTED_SECRET* out_sym_seed, 277 AuthorizationDelegate* authorization_delegate)); 278 MOCK_METHOD9(Rewrap, 279 void(const TPMI_DH_OBJECT& old_parent, 280 const std::string& old_parent_name, 281 const TPMI_DH_OBJECT& new_parent, 282 const std::string& new_parent_name, 283 const TPM2B_PRIVATE& in_duplicate, 284 const TPM2B_NAME& name, 285 const TPM2B_ENCRYPTED_SECRET& in_sym_seed, 286 AuthorizationDelegate* authorization_delegate, 287 const RewrapResponse& callback)); 288 MOCK_METHOD10(RewrapSync, 289 TPM_RC(const TPMI_DH_OBJECT& old_parent, 290 const std::string& old_parent_name, 291 const TPMI_DH_OBJECT& new_parent, 292 const std::string& new_parent_name, 293 const TPM2B_PRIVATE& in_duplicate, 294 const TPM2B_NAME& name, 295 const TPM2B_ENCRYPTED_SECRET& in_sym_seed, 296 TPM2B_PRIVATE* out_duplicate, 297 TPM2B_ENCRYPTED_SECRET* out_sym_seed, 298 AuthorizationDelegate* authorization_delegate)); 299 MOCK_METHOD9(Import, 300 void(const TPMI_DH_OBJECT& parent_handle, 301 const std::string& parent_handle_name, 302 const TPM2B_DATA& encryption_key, 303 const TPM2B_PUBLIC& object_public, 304 const TPM2B_PRIVATE& duplicate, 305 const TPM2B_ENCRYPTED_SECRET& in_sym_seed, 306 const TPMT_SYM_DEF_OBJECT& symmetric_alg, 307 AuthorizationDelegate* authorization_delegate, 308 const ImportResponse& callback)); 309 MOCK_METHOD9(ImportSync, 310 TPM_RC(const TPMI_DH_OBJECT& parent_handle, 311 const std::string& parent_handle_name, 312 const TPM2B_DATA& encryption_key, 313 const TPM2B_PUBLIC& object_public, 314 const TPM2B_PRIVATE& duplicate, 315 const TPM2B_ENCRYPTED_SECRET& in_sym_seed, 316 const TPMT_SYM_DEF_OBJECT& symmetric_alg, 317 TPM2B_PRIVATE* out_private, 318 AuthorizationDelegate* authorization_delegate)); 319 MOCK_METHOD7(RSA_Encrypt, 320 void(const TPMI_DH_OBJECT& key_handle, 321 const std::string& key_handle_name, 322 const TPM2B_PUBLIC_KEY_RSA& message, 323 const TPMT_RSA_DECRYPT& in_scheme, 324 const TPM2B_DATA& label, 325 AuthorizationDelegate* authorization_delegate, 326 const RSA_EncryptResponse& callback)); 327 MOCK_METHOD7(RSA_EncryptSync, 328 TPM_RC(const TPMI_DH_OBJECT& key_handle, 329 const std::string& key_handle_name, 330 const TPM2B_PUBLIC_KEY_RSA& message, 331 const TPMT_RSA_DECRYPT& in_scheme, 332 const TPM2B_DATA& label, 333 TPM2B_PUBLIC_KEY_RSA* out_data, 334 AuthorizationDelegate* authorization_delegate)); 335 MOCK_METHOD7(RSA_Decrypt, 336 void(const TPMI_DH_OBJECT& key_handle, 337 const std::string& key_handle_name, 338 const TPM2B_PUBLIC_KEY_RSA& cipher_text, 339 const TPMT_RSA_DECRYPT& in_scheme, 340 const TPM2B_DATA& label, 341 AuthorizationDelegate* authorization_delegate, 342 const RSA_DecryptResponse& callback)); 343 MOCK_METHOD7(RSA_DecryptSync, 344 TPM_RC(const TPMI_DH_OBJECT& key_handle, 345 const std::string& key_handle_name, 346 const TPM2B_PUBLIC_KEY_RSA& cipher_text, 347 const TPMT_RSA_DECRYPT& in_scheme, 348 const TPM2B_DATA& label, 349 TPM2B_PUBLIC_KEY_RSA* message, 350 AuthorizationDelegate* authorization_delegate)); 351 MOCK_METHOD4(ECDH_KeyGen, 352 void(const TPMI_DH_OBJECT& key_handle, 353 const std::string& key_handle_name, 354 AuthorizationDelegate* authorization_delegate, 355 const ECDH_KeyGenResponse& callback)); 356 MOCK_METHOD5(ECDH_KeyGenSync, 357 TPM_RC(const TPMI_DH_OBJECT& key_handle, 358 const std::string& key_handle_name, 359 TPM2B_ECC_POINT* z_point, 360 TPM2B_ECC_POINT* pub_point, 361 AuthorizationDelegate* authorization_delegate)); 362 MOCK_METHOD5(ECDH_ZGen, 363 void(const TPMI_DH_OBJECT& key_handle, 364 const std::string& key_handle_name, 365 const TPM2B_ECC_POINT& in_point, 366 AuthorizationDelegate* authorization_delegate, 367 const ECDH_ZGenResponse& callback)); 368 MOCK_METHOD5(ECDH_ZGenSync, 369 TPM_RC(const TPMI_DH_OBJECT& key_handle, 370 const std::string& key_handle_name, 371 const TPM2B_ECC_POINT& in_point, 372 TPM2B_ECC_POINT* out_point, 373 AuthorizationDelegate* authorization_delegate)); 374 MOCK_METHOD3(ECC_Parameters, 375 void(const TPMI_ECC_CURVE& curve_id, 376 AuthorizationDelegate* authorization_delegate, 377 const ECC_ParametersResponse& callback)); 378 MOCK_METHOD3(ECC_ParametersSync, 379 TPM_RC(const TPMI_ECC_CURVE& curve_id, 380 TPMS_ALGORITHM_DETAIL_ECC* parameters, 381 AuthorizationDelegate* authorization_delegate)); 382 MOCK_METHOD8(ZGen_2Phase, 383 void(const TPMI_DH_OBJECT& key_a, 384 const std::string& key_a_name, 385 const TPM2B_ECC_POINT& in_qs_b, 386 const TPM2B_ECC_POINT& in_qe_b, 387 const TPMI_ECC_KEY_EXCHANGE& in_scheme, 388 const UINT16& counter, 389 AuthorizationDelegate* authorization_delegate, 390 const ZGen_2PhaseResponse& callback)); 391 MOCK_METHOD9(ZGen_2PhaseSync, 392 TPM_RC(const TPMI_DH_OBJECT& key_a, 393 const std::string& key_a_name, 394 const TPM2B_ECC_POINT& in_qs_b, 395 const TPM2B_ECC_POINT& in_qe_b, 396 const TPMI_ECC_KEY_EXCHANGE& in_scheme, 397 const UINT16& counter, 398 TPM2B_ECC_POINT* out_z1, 399 TPM2B_ECC_POINT* out_z2, 400 AuthorizationDelegate* authorization_delegate)); 401 MOCK_METHOD8(EncryptDecrypt, 402 void(const TPMI_DH_OBJECT& key_handle, 403 const std::string& key_handle_name, 404 const TPMI_YES_NO& decrypt, 405 const TPMI_ALG_SYM_MODE& mode, 406 const TPM2B_IV& iv_in, 407 const TPM2B_MAX_BUFFER& in_data, 408 AuthorizationDelegate* authorization_delegate, 409 const EncryptDecryptResponse& callback)); 410 MOCK_METHOD9(EncryptDecryptSync, 411 TPM_RC(const TPMI_DH_OBJECT& key_handle, 412 const std::string& key_handle_name, 413 const TPMI_YES_NO& decrypt, 414 const TPMI_ALG_SYM_MODE& mode, 415 const TPM2B_IV& iv_in, 416 const TPM2B_MAX_BUFFER& in_data, 417 TPM2B_MAX_BUFFER* out_data, 418 TPM2B_IV* iv_out, 419 AuthorizationDelegate* authorization_delegate)); 420 MOCK_METHOD5(Hash, 421 void(const TPM2B_MAX_BUFFER& data, 422 const TPMI_ALG_HASH& hash_alg, 423 const TPMI_RH_HIERARCHY& hierarchy, 424 AuthorizationDelegate* authorization_delegate, 425 const HashResponse& callback)); 426 MOCK_METHOD6(HashSync, 427 TPM_RC(const TPM2B_MAX_BUFFER& data, 428 const TPMI_ALG_HASH& hash_alg, 429 const TPMI_RH_HIERARCHY& hierarchy, 430 TPM2B_DIGEST* out_hash, 431 TPMT_TK_HASHCHECK* validation, 432 AuthorizationDelegate* authorization_delegate)); 433 MOCK_METHOD6(HMAC, 434 void(const TPMI_DH_OBJECT& handle, 435 const std::string& handle_name, 436 const TPM2B_MAX_BUFFER& buffer, 437 const TPMI_ALG_HASH& hash_alg, 438 AuthorizationDelegate* authorization_delegate, 439 const HMACResponse& callback)); 440 MOCK_METHOD6(HMACSync, 441 TPM_RC(const TPMI_DH_OBJECT& handle, 442 const std::string& handle_name, 443 const TPM2B_MAX_BUFFER& buffer, 444 const TPMI_ALG_HASH& hash_alg, 445 TPM2B_DIGEST* out_hmac, 446 AuthorizationDelegate* authorization_delegate)); 447 MOCK_METHOD3(GetRandom, 448 void(const UINT16& bytes_requested, 449 AuthorizationDelegate* authorization_delegate, 450 const GetRandomResponse& callback)); 451 MOCK_METHOD3(GetRandomSync, 452 TPM_RC(const UINT16& bytes_requested, 453 TPM2B_DIGEST* random_bytes, 454 AuthorizationDelegate* authorization_delegate)); 455 MOCK_METHOD3(StirRandom, 456 void(const TPM2B_SENSITIVE_DATA& in_data, 457 AuthorizationDelegate* authorization_delegate, 458 const StirRandomResponse& callback)); 459 MOCK_METHOD2(StirRandomSync, 460 TPM_RC(const TPM2B_SENSITIVE_DATA& in_data, 461 AuthorizationDelegate* authorization_delegate)); 462 MOCK_METHOD6(HMAC_Start, 463 void(const TPMI_DH_OBJECT& handle, 464 const std::string& handle_name, 465 const TPM2B_AUTH& auth, 466 const TPMI_ALG_HASH& hash_alg, 467 AuthorizationDelegate* authorization_delegate, 468 const HMAC_StartResponse& callback)); 469 MOCK_METHOD6(HMAC_StartSync, 470 TPM_RC(const TPMI_DH_OBJECT& handle, 471 const std::string& handle_name, 472 const TPM2B_AUTH& auth, 473 const TPMI_ALG_HASH& hash_alg, 474 TPMI_DH_OBJECT* sequence_handle, 475 AuthorizationDelegate* authorization_delegate)); 476 MOCK_METHOD4(HashSequenceStart, 477 void(const TPM2B_AUTH& auth, 478 const TPMI_ALG_HASH& hash_alg, 479 AuthorizationDelegate* authorization_delegate, 480 const HashSequenceStartResponse& callback)); 481 MOCK_METHOD4(HashSequenceStartSync, 482 TPM_RC(const TPM2B_AUTH& auth, 483 const TPMI_ALG_HASH& hash_alg, 484 TPMI_DH_OBJECT* sequence_handle, 485 AuthorizationDelegate* authorization_delegate)); 486 MOCK_METHOD5(SequenceUpdate, 487 void(const TPMI_DH_OBJECT& sequence_handle, 488 const std::string& sequence_handle_name, 489 const TPM2B_MAX_BUFFER& buffer, 490 AuthorizationDelegate* authorization_delegate, 491 const SequenceUpdateResponse& callback)); 492 MOCK_METHOD4(SequenceUpdateSync, 493 TPM_RC(const TPMI_DH_OBJECT& sequence_handle, 494 const std::string& sequence_handle_name, 495 const TPM2B_MAX_BUFFER& buffer, 496 AuthorizationDelegate* authorization_delegate)); 497 MOCK_METHOD6(SequenceComplete, 498 void(const TPMI_DH_OBJECT& sequence_handle, 499 const std::string& sequence_handle_name, 500 const TPM2B_MAX_BUFFER& buffer, 501 const TPMI_RH_HIERARCHY& hierarchy, 502 AuthorizationDelegate* authorization_delegate, 503 const SequenceCompleteResponse& callback)); 504 MOCK_METHOD7(SequenceCompleteSync, 505 TPM_RC(const TPMI_DH_OBJECT& sequence_handle, 506 const std::string& sequence_handle_name, 507 const TPM2B_MAX_BUFFER& buffer, 508 const TPMI_RH_HIERARCHY& hierarchy, 509 TPM2B_DIGEST* result, 510 TPMT_TK_HASHCHECK* validation, 511 AuthorizationDelegate* authorization_delegate)); 512 MOCK_METHOD7(EventSequenceComplete, 513 void(const TPMI_DH_PCR& pcr_handle, 514 const std::string& pcr_handle_name, 515 const TPMI_DH_OBJECT& sequence_handle, 516 const std::string& sequence_handle_name, 517 const TPM2B_MAX_BUFFER& buffer, 518 AuthorizationDelegate* authorization_delegate, 519 const EventSequenceCompleteResponse& callback)); 520 MOCK_METHOD7(EventSequenceCompleteSync, 521 TPM_RC(const TPMI_DH_PCR& pcr_handle, 522 const std::string& pcr_handle_name, 523 const TPMI_DH_OBJECT& sequence_handle, 524 const std::string& sequence_handle_name, 525 const TPM2B_MAX_BUFFER& buffer, 526 TPML_DIGEST_VALUES* results, 527 AuthorizationDelegate* authorization_delegate)); 528 MOCK_METHOD8(Certify, 529 void(const TPMI_DH_OBJECT& object_handle, 530 const std::string& object_handle_name, 531 const TPMI_DH_OBJECT& sign_handle, 532 const std::string& sign_handle_name, 533 const TPM2B_DATA& qualifying_data, 534 const TPMT_SIG_SCHEME& in_scheme, 535 AuthorizationDelegate* authorization_delegate, 536 const CertifyResponse& callback)); 537 MOCK_METHOD9(CertifySync, 538 TPM_RC(const TPMI_DH_OBJECT& object_handle, 539 const std::string& object_handle_name, 540 const TPMI_DH_OBJECT& sign_handle, 541 const std::string& sign_handle_name, 542 const TPM2B_DATA& qualifying_data, 543 const TPMT_SIG_SCHEME& in_scheme, 544 TPM2B_ATTEST* certify_info, 545 TPMT_SIGNATURE* signature, 546 AuthorizationDelegate* authorization_delegate)); 547 MOCK_METHOD10(CertifyCreation, 548 void(const TPMI_DH_OBJECT& sign_handle, 549 const std::string& sign_handle_name, 550 const TPMI_DH_OBJECT& object_handle, 551 const std::string& object_handle_name, 552 const TPM2B_DATA& qualifying_data, 553 const TPM2B_DIGEST& creation_hash, 554 const TPMT_SIG_SCHEME& in_scheme, 555 const TPMT_TK_CREATION& creation_ticket, 556 AuthorizationDelegate* authorization_delegate, 557 const CertifyCreationResponse& callback)); 558 // Too many args to mock, forward to *Short version. 559 TPM_RC CertifyCreationSync( 560 const TPMI_DH_OBJECT& sign_handle, 561 const std::string& sign_handle_name, 562 const TPMI_DH_OBJECT& object_handle, 563 const std::string& object_handle_name, 564 const TPM2B_DATA& qualifying_data, 565 const TPM2B_DIGEST& creation_hash, 566 const TPMT_SIG_SCHEME& in_scheme, 567 const TPMT_TK_CREATION& creation_ticket, 568 TPM2B_ATTEST* certify_info, 569 TPMT_SIGNATURE* signature, 570 AuthorizationDelegate* authorization_delegate) override; 571 MOCK_METHOD9(CertifyCreationSyncShort, 572 TPM_RC(const TPMI_DH_OBJECT& sign_handle, 573 const TPMI_DH_OBJECT& object_handle, 574 const TPM2B_DATA& qualifying_data, 575 const TPM2B_DIGEST& creation_hash, 576 const TPMT_SIG_SCHEME& in_scheme, 577 const TPMT_TK_CREATION& creation_ticket, 578 TPM2B_ATTEST* certify_info, 579 TPMT_SIGNATURE* signature, 580 AuthorizationDelegate* authorization_delegate)); 581 MOCK_METHOD7(Quote, 582 void(const TPMI_DH_OBJECT& sign_handle, 583 const std::string& sign_handle_name, 584 const TPM2B_DATA& qualifying_data, 585 const TPMT_SIG_SCHEME& in_scheme, 586 const TPML_PCR_SELECTION& pcrselect, 587 AuthorizationDelegate* authorization_delegate, 588 const QuoteResponse& callback)); 589 MOCK_METHOD8(QuoteSync, 590 TPM_RC(const TPMI_DH_OBJECT& sign_handle, 591 const std::string& sign_handle_name, 592 const TPM2B_DATA& qualifying_data, 593 const TPMT_SIG_SCHEME& in_scheme, 594 const TPML_PCR_SELECTION& pcrselect, 595 TPM2B_ATTEST* quoted, 596 TPMT_SIGNATURE* signature, 597 AuthorizationDelegate* authorization_delegate)); 598 MOCK_METHOD10(GetSessionAuditDigest, 599 void(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, 600 const std::string& privacy_admin_handle_name, 601 const TPMI_DH_OBJECT& sign_handle, 602 const std::string& sign_handle_name, 603 const TPMI_SH_HMAC& session_handle, 604 const std::string& session_handle_name, 605 const TPM2B_DATA& qualifying_data, 606 const TPMT_SIG_SCHEME& in_scheme, 607 AuthorizationDelegate* authorization_delegate, 608 const GetSessionAuditDigestResponse& callback)); 609 // Too many args to mock, forward to *Short version. 610 TPM_RC GetSessionAuditDigestSync( 611 const TPMI_RH_ENDORSEMENT& privacy_admin_handle, 612 const std::string& privacy_admin_handle_name, 613 const TPMI_DH_OBJECT& sign_handle, 614 const std::string& sign_handle_name, 615 const TPMI_SH_HMAC& session_handle, 616 const std::string& session_handle_name, 617 const TPM2B_DATA& qualifying_data, 618 const TPMT_SIG_SCHEME& in_scheme, 619 TPM2B_ATTEST* audit_info, 620 TPMT_SIGNATURE* signature, 621 AuthorizationDelegate* authorization_delegate) override; 622 MOCK_METHOD8(GetSessionAuditDigestSyncShort, 623 TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, 624 const TPMI_DH_OBJECT& sign_handle, 625 const TPMI_SH_HMAC& session_handle, 626 const TPM2B_DATA& qualifying_data, 627 const TPMT_SIG_SCHEME& in_scheme, 628 TPM2B_ATTEST* audit_info, 629 TPMT_SIGNATURE* signature, 630 AuthorizationDelegate* authorization_delegate)); 631 MOCK_METHOD8(GetCommandAuditDigest, 632 void(const TPMI_RH_ENDORSEMENT& privacy_handle, 633 const std::string& privacy_handle_name, 634 const TPMI_DH_OBJECT& sign_handle, 635 const std::string& sign_handle_name, 636 const TPM2B_DATA& qualifying_data, 637 const TPMT_SIG_SCHEME& in_scheme, 638 AuthorizationDelegate* authorization_delegate, 639 const GetCommandAuditDigestResponse& callback)); 640 MOCK_METHOD9(GetCommandAuditDigestSync, 641 TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_handle, 642 const std::string& privacy_handle_name, 643 const TPMI_DH_OBJECT& sign_handle, 644 const std::string& sign_handle_name, 645 const TPM2B_DATA& qualifying_data, 646 const TPMT_SIG_SCHEME& in_scheme, 647 TPM2B_ATTEST* audit_info, 648 TPMT_SIGNATURE* signature, 649 AuthorizationDelegate* authorization_delegate)); 650 MOCK_METHOD8(GetTime, 651 void(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, 652 const std::string& privacy_admin_handle_name, 653 const TPMI_DH_OBJECT& sign_handle, 654 const std::string& sign_handle_name, 655 const TPM2B_DATA& qualifying_data, 656 const TPMT_SIG_SCHEME& in_scheme, 657 AuthorizationDelegate* authorization_delegate, 658 const GetTimeResponse& callback)); 659 MOCK_METHOD9(GetTimeSync, 660 TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, 661 const std::string& privacy_admin_handle_name, 662 const TPMI_DH_OBJECT& sign_handle, 663 const std::string& sign_handle_name, 664 const TPM2B_DATA& qualifying_data, 665 const TPMT_SIG_SCHEME& in_scheme, 666 TPM2B_ATTEST* time_info, 667 TPMT_SIGNATURE* signature, 668 AuthorizationDelegate* authorization_delegate)); 669 MOCK_METHOD8(Commit, 670 void(const TPMI_DH_OBJECT& sign_handle, 671 const std::string& sign_handle_name, 672 const UINT32& param_size, 673 const TPM2B_ECC_POINT& p1, 674 const TPM2B_SENSITIVE_DATA& s2, 675 const TPM2B_ECC_PARAMETER& y2, 676 AuthorizationDelegate* authorization_delegate, 677 const CommitResponse& callback)); 678 // Too many args to mock, forward to *Short version. 679 TPM_RC CommitSync(const TPMI_DH_OBJECT& sign_handle, 680 const std::string& sign_handle_name, 681 const UINT32& param_size, 682 const TPM2B_ECC_POINT& p1, 683 const TPM2B_SENSITIVE_DATA& s2, 684 const TPM2B_ECC_PARAMETER& y2, 685 UINT32* param_size_out, 686 TPM2B_ECC_POINT* k, 687 TPM2B_ECC_POINT* l, 688 TPM2B_ECC_POINT* e, 689 UINT16* counter, 690 AuthorizationDelegate* authorization_delegate) override; 691 MOCK_METHOD10(CommitSyncShort, 692 TPM_RC(const TPMI_DH_OBJECT& sign_handle, 693 const UINT32& param_size, 694 const TPM2B_ECC_POINT& p1, 695 const TPM2B_ECC_PARAMETER& y2, 696 UINT32* param_size_out, 697 TPM2B_ECC_POINT* k, 698 TPM2B_ECC_POINT* l, 699 TPM2B_ECC_POINT* e, 700 UINT16* counter, 701 AuthorizationDelegate* authorization_delegate)); 702 MOCK_METHOD4(EC_Ephemeral, 703 void(const UINT32& param_size, 704 const TPMI_ECC_CURVE& curve_id, 705 AuthorizationDelegate* authorization_delegate, 706 const EC_EphemeralResponse& callback)); 707 MOCK_METHOD6(EC_EphemeralSync, 708 TPM_RC(const UINT32& param_size, 709 const TPMI_ECC_CURVE& curve_id, 710 UINT32* param_size_out, 711 TPM2B_ECC_POINT* q, 712 UINT16* counter, 713 AuthorizationDelegate* authorization_delegate)); 714 MOCK_METHOD6(VerifySignature, 715 void(const TPMI_DH_OBJECT& key_handle, 716 const std::string& key_handle_name, 717 const TPM2B_DIGEST& digest, 718 const TPMT_SIGNATURE& signature, 719 AuthorizationDelegate* authorization_delegate, 720 const VerifySignatureResponse& callback)); 721 MOCK_METHOD6(VerifySignatureSync, 722 TPM_RC(const TPMI_DH_OBJECT& key_handle, 723 const std::string& key_handle_name, 724 const TPM2B_DIGEST& digest, 725 const TPMT_SIGNATURE& signature, 726 TPMT_TK_VERIFIED* validation, 727 AuthorizationDelegate* authorization_delegate)); 728 MOCK_METHOD7(Sign, 729 void(const TPMI_DH_OBJECT& key_handle, 730 const std::string& key_handle_name, 731 const TPM2B_DIGEST& digest, 732 const TPMT_SIG_SCHEME& in_scheme, 733 const TPMT_TK_HASHCHECK& validation, 734 AuthorizationDelegate* authorization_delegate, 735 const SignResponse& callback)); 736 MOCK_METHOD7(SignSync, 737 TPM_RC(const TPMI_DH_OBJECT& key_handle, 738 const std::string& key_handle_name, 739 const TPM2B_DIGEST& digest, 740 const TPMT_SIG_SCHEME& in_scheme, 741 const TPMT_TK_HASHCHECK& validation, 742 TPMT_SIGNATURE* signature, 743 AuthorizationDelegate* authorization_delegate)); 744 MOCK_METHOD7(SetCommandCodeAuditStatus, 745 void(const TPMI_RH_PROVISION& auth, 746 const std::string& auth_name, 747 const TPMI_ALG_HASH& audit_alg, 748 const TPML_CC& set_list, 749 const TPML_CC& clear_list, 750 AuthorizationDelegate* authorization_delegate, 751 const SetCommandCodeAuditStatusResponse& callback)); 752 MOCK_METHOD6(SetCommandCodeAuditStatusSync, 753 TPM_RC(const TPMI_RH_PROVISION& auth, 754 const std::string& auth_name, 755 const TPMI_ALG_HASH& audit_alg, 756 const TPML_CC& set_list, 757 const TPML_CC& clear_list, 758 AuthorizationDelegate* authorization_delegate)); 759 MOCK_METHOD5(PCR_Extend, 760 void(const TPMI_DH_PCR& pcr_handle, 761 const std::string& pcr_handle_name, 762 const TPML_DIGEST_VALUES& digests, 763 AuthorizationDelegate* authorization_delegate, 764 const PCR_ExtendResponse& callback)); 765 MOCK_METHOD4(PCR_ExtendSync, 766 TPM_RC(const TPMI_DH_PCR& pcr_handle, 767 const std::string& pcr_handle_name, 768 const TPML_DIGEST_VALUES& digests, 769 AuthorizationDelegate* authorization_delegate)); 770 MOCK_METHOD5(PCR_Event, 771 void(const TPMI_DH_PCR& pcr_handle, 772 const std::string& pcr_handle_name, 773 const TPM2B_EVENT& event_data, 774 AuthorizationDelegate* authorization_delegate, 775 const PCR_EventResponse& callback)); 776 MOCK_METHOD5(PCR_EventSync, 777 TPM_RC(const TPMI_DH_PCR& pcr_handle, 778 const std::string& pcr_handle_name, 779 const TPM2B_EVENT& event_data, 780 TPML_DIGEST_VALUES* digests, 781 AuthorizationDelegate* authorization_delegate)); 782 MOCK_METHOD3(PCR_Read, 783 void(const TPML_PCR_SELECTION& pcr_selection_in, 784 AuthorizationDelegate* authorization_delegate, 785 const PCR_ReadResponse& callback)); 786 MOCK_METHOD5(PCR_ReadSync, 787 TPM_RC(const TPML_PCR_SELECTION& pcr_selection_in, 788 UINT32* pcr_update_counter, 789 TPML_PCR_SELECTION* pcr_selection_out, 790 TPML_DIGEST* pcr_values, 791 AuthorizationDelegate* authorization_delegate)); 792 MOCK_METHOD5(PCR_Allocate, 793 void(const TPMI_RH_PLATFORM& auth_handle, 794 const std::string& auth_handle_name, 795 const TPML_PCR_SELECTION& pcr_allocation, 796 AuthorizationDelegate* authorization_delegate, 797 const PCR_AllocateResponse& callback)); 798 MOCK_METHOD8(PCR_AllocateSync, 799 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 800 const std::string& auth_handle_name, 801 const TPML_PCR_SELECTION& pcr_allocation, 802 TPMI_YES_NO* allocation_success, 803 UINT32* max_pcr, 804 UINT32* size_needed, 805 UINT32* size_available, 806 AuthorizationDelegate* authorization_delegate)); 807 MOCK_METHOD8(PCR_SetAuthPolicy, 808 void(const TPMI_RH_PLATFORM& auth_handle, 809 const std::string& auth_handle_name, 810 const TPMI_DH_PCR& pcr_num, 811 const std::string& pcr_num_name, 812 const TPM2B_DIGEST& auth_policy, 813 const TPMI_ALG_HASH& policy_digest, 814 AuthorizationDelegate* authorization_delegate, 815 const PCR_SetAuthPolicyResponse& callback)); 816 MOCK_METHOD7(PCR_SetAuthPolicySync, 817 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 818 const std::string& auth_handle_name, 819 const TPMI_DH_PCR& pcr_num, 820 const std::string& pcr_num_name, 821 const TPM2B_DIGEST& auth_policy, 822 const TPMI_ALG_HASH& policy_digest, 823 AuthorizationDelegate* authorization_delegate)); 824 MOCK_METHOD5(PCR_SetAuthValue, 825 void(const TPMI_DH_PCR& pcr_handle, 826 const std::string& pcr_handle_name, 827 const TPM2B_DIGEST& auth, 828 AuthorizationDelegate* authorization_delegate, 829 const PCR_SetAuthValueResponse& callback)); 830 MOCK_METHOD4(PCR_SetAuthValueSync, 831 TPM_RC(const TPMI_DH_PCR& pcr_handle, 832 const std::string& pcr_handle_name, 833 const TPM2B_DIGEST& auth, 834 AuthorizationDelegate* authorization_delegate)); 835 MOCK_METHOD4(PCR_Reset, 836 void(const TPMI_DH_PCR& pcr_handle, 837 const std::string& pcr_handle_name, 838 AuthorizationDelegate* authorization_delegate, 839 const PCR_ResetResponse& callback)); 840 MOCK_METHOD3(PCR_ResetSync, 841 TPM_RC(const TPMI_DH_PCR& pcr_handle, 842 const std::string& pcr_handle_name, 843 AuthorizationDelegate* authorization_delegate)); 844 // Too many args to mock, forward to *Short version. 845 void PolicySigned(const TPMI_DH_OBJECT& auth_object, 846 const std::string& auth_object_name, 847 const TPMI_SH_POLICY& policy_session, 848 const std::string& policy_session_name, 849 const TPM2B_NONCE& nonce_tpm, 850 const TPM2B_DIGEST& cp_hash_a, 851 const TPM2B_NONCE& policy_ref, 852 const INT32& expiration, 853 const TPMT_SIGNATURE& auth, 854 AuthorizationDelegate* authorization_delegate, 855 const PolicySignedResponse& callback) override; 856 MOCK_METHOD9(PolicySignedShort, 857 void(const TPMI_DH_OBJECT& auth_object, 858 const TPMI_SH_POLICY& policy_session, 859 const TPM2B_NONCE& nonce_tpm, 860 const TPM2B_DIGEST& cp_hash_a, 861 const TPM2B_NONCE& policy_ref, 862 const INT32& expiration, 863 const TPMT_SIGNATURE& auth, 864 AuthorizationDelegate* authorization_delegate, 865 const PolicySignedResponse& callback)); 866 // Too many args to mock, forward to *Short version. 867 TPM_RC PolicySignedSync( 868 const TPMI_DH_OBJECT& auth_object, 869 const std::string& auth_object_name, 870 const TPMI_SH_POLICY& policy_session, 871 const std::string& policy_session_name, 872 const TPM2B_NONCE& nonce_tpm, 873 const TPM2B_DIGEST& cp_hash_a, 874 const TPM2B_NONCE& policy_ref, 875 const INT32& expiration, 876 const TPMT_SIGNATURE& auth, 877 TPM2B_TIMEOUT* timeout, 878 TPMT_TK_AUTH* policy_ticket, 879 AuthorizationDelegate* authorization_delegate) override; 880 MOCK_METHOD10(PolicySignedSyncShort, 881 TPM_RC(const TPMI_DH_OBJECT& auth_object, 882 const TPMI_SH_POLICY& policy_session, 883 const TPM2B_NONCE& nonce_tpm, 884 const TPM2B_DIGEST& cp_hash_a, 885 const TPM2B_NONCE& policy_ref, 886 const INT32& expiration, 887 const TPMT_SIGNATURE& auth, 888 TPM2B_TIMEOUT* timeout, 889 TPMT_TK_AUTH* policy_ticket, 890 AuthorizationDelegate* authorization_delegate)); 891 MOCK_METHOD10(PolicySecret, 892 void(const TPMI_DH_ENTITY& auth_handle, 893 const std::string& auth_handle_name, 894 const TPMI_SH_POLICY& policy_session, 895 const std::string& policy_session_name, 896 const TPM2B_NONCE& nonce_tpm, 897 const TPM2B_DIGEST& cp_hash_a, 898 const TPM2B_NONCE& policy_ref, 899 const INT32& expiration, 900 AuthorizationDelegate* authorization_delegate, 901 const PolicySecretResponse& callback)); 902 // Too many args to mock, forward to *Short version. 903 TPM_RC PolicySecretSync( 904 const TPMI_DH_ENTITY& auth_handle, 905 const std::string& auth_handle_name, 906 const TPMI_SH_POLICY& policy_session, 907 const std::string& policy_session_name, 908 const TPM2B_NONCE& nonce_tpm, 909 const TPM2B_DIGEST& cp_hash_a, 910 const TPM2B_NONCE& policy_ref, 911 const INT32& expiration, 912 TPM2B_TIMEOUT* timeout, 913 TPMT_TK_AUTH* policy_ticket, 914 AuthorizationDelegate* authorization_delegate) override; 915 MOCK_METHOD9(PolicySecretSyncShort, 916 TPM_RC(const TPMI_DH_ENTITY& auth_handle, 917 const TPMI_SH_POLICY& policy_session, 918 const TPM2B_NONCE& nonce_tpm, 919 const TPM2B_DIGEST& cp_hash_a, 920 const TPM2B_NONCE& policy_ref, 921 const INT32& expiration, 922 TPM2B_TIMEOUT* timeout, 923 TPMT_TK_AUTH* policy_ticket, 924 AuthorizationDelegate* authorization_delegate)); 925 MOCK_METHOD9(PolicyTicket, 926 void(const TPMI_SH_POLICY& policy_session, 927 const std::string& policy_session_name, 928 const TPM2B_TIMEOUT& timeout, 929 const TPM2B_DIGEST& cp_hash_a, 930 const TPM2B_NONCE& policy_ref, 931 const TPM2B_NAME& auth_name, 932 const TPMT_TK_AUTH& ticket, 933 AuthorizationDelegate* authorization_delegate, 934 const PolicyTicketResponse& callback)); 935 MOCK_METHOD8(PolicyTicketSync, 936 TPM_RC(const TPMI_SH_POLICY& policy_session, 937 const std::string& policy_session_name, 938 const TPM2B_TIMEOUT& timeout, 939 const TPM2B_DIGEST& cp_hash_a, 940 const TPM2B_NONCE& policy_ref, 941 const TPM2B_NAME& auth_name, 942 const TPMT_TK_AUTH& ticket, 943 AuthorizationDelegate* authorization_delegate)); 944 MOCK_METHOD5(PolicyOR, 945 void(const TPMI_SH_POLICY& policy_session, 946 const std::string& policy_session_name, 947 const TPML_DIGEST& p_hash_list, 948 AuthorizationDelegate* authorization_delegate, 949 const PolicyORResponse& callback)); 950 MOCK_METHOD4(PolicyORSync, 951 TPM_RC(const TPMI_SH_POLICY& policy_session, 952 const std::string& policy_session_name, 953 const TPML_DIGEST& p_hash_list, 954 AuthorizationDelegate* authorization_delegate)); 955 MOCK_METHOD6(PolicyPCR, 956 void(const TPMI_SH_POLICY& policy_session, 957 const std::string& policy_session_name, 958 const TPM2B_DIGEST& pcr_digest, 959 const TPML_PCR_SELECTION& pcrs, 960 AuthorizationDelegate* authorization_delegate, 961 const PolicyPCRResponse& callback)); 962 MOCK_METHOD5(PolicyPCRSync, 963 TPM_RC(const TPMI_SH_POLICY& policy_session, 964 const std::string& policy_session_name, 965 const TPM2B_DIGEST& pcr_digest, 966 const TPML_PCR_SELECTION& pcrs, 967 AuthorizationDelegate* authorization_delegate)); 968 MOCK_METHOD5(PolicyLocality, 969 void(const TPMI_SH_POLICY& policy_session, 970 const std::string& policy_session_name, 971 const TPMA_LOCALITY& locality, 972 AuthorizationDelegate* authorization_delegate, 973 const PolicyLocalityResponse& callback)); 974 MOCK_METHOD4(PolicyLocalitySync, 975 TPM_RC(const TPMI_SH_POLICY& policy_session, 976 const std::string& policy_session_name, 977 const TPMA_LOCALITY& locality, 978 AuthorizationDelegate* authorization_delegate)); 979 // Too many args to mock, forward to *Short version. 980 void PolicyNV(const TPMI_RH_NV_AUTH& auth_handle, 981 const std::string& auth_handle_name, 982 const TPMI_RH_NV_INDEX& nv_index, 983 const std::string& nv_index_name, 984 const TPMI_SH_POLICY& policy_session, 985 const std::string& policy_session_name, 986 const TPM2B_OPERAND& operand_b, 987 const UINT16& offset, 988 const TPM_EO& operation, 989 AuthorizationDelegate* authorization_delegate, 990 const PolicyNVResponse& callback) override; 991 MOCK_METHOD8(PolicyNVShort, 992 void(const TPMI_RH_NV_AUTH& auth_handle, 993 const TPMI_RH_NV_INDEX& nv_index, 994 const TPMI_SH_POLICY& policy_session, 995 const TPM2B_OPERAND& operand_b, 996 const UINT16& offset, 997 const TPM_EO& operation, 998 AuthorizationDelegate* authorization_delegate, 999 const PolicyNVResponse& callback)); 1000 MOCK_METHOD10(PolicyNVSync, 1001 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1002 const std::string& auth_handle_name, 1003 const TPMI_RH_NV_INDEX& nv_index, 1004 const std::string& nv_index_name, 1005 const TPMI_SH_POLICY& policy_session, 1006 const std::string& policy_session_name, 1007 const TPM2B_OPERAND& operand_b, 1008 const UINT16& offset, 1009 const TPM_EO& operation, 1010 AuthorizationDelegate* authorization_delegate)); 1011 MOCK_METHOD7(PolicyCounterTimer, 1012 void(const TPMI_SH_POLICY& policy_session, 1013 const std::string& policy_session_name, 1014 const TPM2B_OPERAND& operand_b, 1015 const UINT16& offset, 1016 const TPM_EO& operation, 1017 AuthorizationDelegate* authorization_delegate, 1018 const PolicyCounterTimerResponse& callback)); 1019 MOCK_METHOD6(PolicyCounterTimerSync, 1020 TPM_RC(const TPMI_SH_POLICY& policy_session, 1021 const std::string& policy_session_name, 1022 const TPM2B_OPERAND& operand_b, 1023 const UINT16& offset, 1024 const TPM_EO& operation, 1025 AuthorizationDelegate* authorization_delegate)); 1026 MOCK_METHOD5(PolicyCommandCode, 1027 void(const TPMI_SH_POLICY& policy_session, 1028 const std::string& policy_session_name, 1029 const TPM_CC& code, 1030 AuthorizationDelegate* authorization_delegate, 1031 const PolicyCommandCodeResponse& callback)); 1032 MOCK_METHOD4(PolicyCommandCodeSync, 1033 TPM_RC(const TPMI_SH_POLICY& policy_session, 1034 const std::string& policy_session_name, 1035 const TPM_CC& code, 1036 AuthorizationDelegate* authorization_delegate)); 1037 MOCK_METHOD4(PolicyPhysicalPresence, 1038 void(const TPMI_SH_POLICY& policy_session, 1039 const std::string& policy_session_name, 1040 AuthorizationDelegate* authorization_delegate, 1041 const PolicyPhysicalPresenceResponse& callback)); 1042 MOCK_METHOD3(PolicyPhysicalPresenceSync, 1043 TPM_RC(const TPMI_SH_POLICY& policy_session, 1044 const std::string& policy_session_name, 1045 AuthorizationDelegate* authorization_delegate)); 1046 MOCK_METHOD5(PolicyCpHash, 1047 void(const TPMI_SH_POLICY& policy_session, 1048 const std::string& policy_session_name, 1049 const TPM2B_DIGEST& cp_hash_a, 1050 AuthorizationDelegate* authorization_delegate, 1051 const PolicyCpHashResponse& callback)); 1052 MOCK_METHOD4(PolicyCpHashSync, 1053 TPM_RC(const TPMI_SH_POLICY& policy_session, 1054 const std::string& policy_session_name, 1055 const TPM2B_DIGEST& cp_hash_a, 1056 AuthorizationDelegate* authorization_delegate)); 1057 MOCK_METHOD5(PolicyNameHash, 1058 void(const TPMI_SH_POLICY& policy_session, 1059 const std::string& policy_session_name, 1060 const TPM2B_DIGEST& name_hash, 1061 AuthorizationDelegate* authorization_delegate, 1062 const PolicyNameHashResponse& callback)); 1063 MOCK_METHOD4(PolicyNameHashSync, 1064 TPM_RC(const TPMI_SH_POLICY& policy_session, 1065 const std::string& policy_session_name, 1066 const TPM2B_DIGEST& name_hash, 1067 AuthorizationDelegate* authorization_delegate)); 1068 MOCK_METHOD7(PolicyDuplicationSelect, 1069 void(const TPMI_SH_POLICY& policy_session, 1070 const std::string& policy_session_name, 1071 const TPM2B_NAME& object_name, 1072 const TPM2B_NAME& new_parent_name, 1073 const TPMI_YES_NO& include_object, 1074 AuthorizationDelegate* authorization_delegate, 1075 const PolicyDuplicationSelectResponse& callback)); 1076 MOCK_METHOD6(PolicyDuplicationSelectSync, 1077 TPM_RC(const TPMI_SH_POLICY& policy_session, 1078 const std::string& policy_session_name, 1079 const TPM2B_NAME& object_name, 1080 const TPM2B_NAME& new_parent_name, 1081 const TPMI_YES_NO& include_object, 1082 AuthorizationDelegate* authorization_delegate)); 1083 MOCK_METHOD8(PolicyAuthorize, 1084 void(const TPMI_SH_POLICY& policy_session, 1085 const std::string& policy_session_name, 1086 const TPM2B_DIGEST& approved_policy, 1087 const TPM2B_NONCE& policy_ref, 1088 const TPM2B_NAME& key_sign, 1089 const TPMT_TK_VERIFIED& check_ticket, 1090 AuthorizationDelegate* authorization_delegate, 1091 const PolicyAuthorizeResponse& callback)); 1092 MOCK_METHOD7(PolicyAuthorizeSync, 1093 TPM_RC(const TPMI_SH_POLICY& policy_session, 1094 const std::string& policy_session_name, 1095 const TPM2B_DIGEST& approved_policy, 1096 const TPM2B_NONCE& policy_ref, 1097 const TPM2B_NAME& key_sign, 1098 const TPMT_TK_VERIFIED& check_ticket, 1099 AuthorizationDelegate* authorization_delegate)); 1100 MOCK_METHOD4(PolicyAuthValue, 1101 void(const TPMI_SH_POLICY& policy_session, 1102 const std::string& policy_session_name, 1103 AuthorizationDelegate* authorization_delegate, 1104 const PolicyAuthValueResponse& callback)); 1105 MOCK_METHOD3(PolicyAuthValueSync, 1106 TPM_RC(const TPMI_SH_POLICY& policy_session, 1107 const std::string& policy_session_name, 1108 AuthorizationDelegate* authorization_delegate)); 1109 MOCK_METHOD4(PolicyPassword, 1110 void(const TPMI_SH_POLICY& policy_session, 1111 const std::string& policy_session_name, 1112 AuthorizationDelegate* authorization_delegate, 1113 const PolicyPasswordResponse& callback)); 1114 MOCK_METHOD3(PolicyPasswordSync, 1115 TPM_RC(const TPMI_SH_POLICY& policy_session, 1116 const std::string& policy_session_name, 1117 AuthorizationDelegate* authorization_delegate)); 1118 MOCK_METHOD4(PolicyGetDigest, 1119 void(const TPMI_SH_POLICY& policy_session, 1120 const std::string& policy_session_name, 1121 AuthorizationDelegate* authorization_delegate, 1122 const PolicyGetDigestResponse& callback)); 1123 MOCK_METHOD4(PolicyGetDigestSync, 1124 TPM_RC(const TPMI_SH_POLICY& policy_session, 1125 const std::string& policy_session_name, 1126 TPM2B_DIGEST* policy_digest, 1127 AuthorizationDelegate* authorization_delegate)); 1128 MOCK_METHOD5(PolicyNvWritten, 1129 void(const TPMI_SH_POLICY& policy_session, 1130 const std::string& policy_session_name, 1131 const TPMI_YES_NO& written_set, 1132 AuthorizationDelegate* authorization_delegate, 1133 const PolicyNvWrittenResponse& callback)); 1134 MOCK_METHOD4(PolicyNvWrittenSync, 1135 TPM_RC(const TPMI_SH_POLICY& policy_session, 1136 const std::string& policy_session_name, 1137 const TPMI_YES_NO& written_set, 1138 AuthorizationDelegate* authorization_delegate)); 1139 MOCK_METHOD8(CreatePrimary, 1140 void(const TPMI_RH_HIERARCHY& primary_handle, 1141 const std::string& primary_handle_name, 1142 const TPM2B_SENSITIVE_CREATE& in_sensitive, 1143 const TPM2B_PUBLIC& in_public, 1144 const TPM2B_DATA& outside_info, 1145 const TPML_PCR_SELECTION& creation_pcr, 1146 AuthorizationDelegate* authorization_delegate, 1147 const CreatePrimaryResponse& callback)); 1148 // Too many args to mock, forward to *Short version. 1149 TPM_RC CreatePrimarySync( 1150 const TPMI_RH_HIERARCHY& primary_handle, 1151 const std::string& primary_handle_name, 1152 const TPM2B_SENSITIVE_CREATE& in_sensitive, 1153 const TPM2B_PUBLIC& in_public, 1154 const TPM2B_DATA& outside_info, 1155 const TPML_PCR_SELECTION& creation_pcr, 1156 TPM_HANDLE* object_handle, 1157 TPM2B_PUBLIC* out_public, 1158 TPM2B_CREATION_DATA* creation_data, 1159 TPM2B_DIGEST* creation_hash, 1160 TPMT_TK_CREATION* creation_ticket, 1161 TPM2B_NAME* name, 1162 AuthorizationDelegate* authorization_delegate) override; 1163 MOCK_METHOD10(CreatePrimarySyncShort, 1164 TPM_RC(const TPMI_RH_HIERARCHY& primary_handle, 1165 const TPM2B_PUBLIC& in_public, 1166 const TPML_PCR_SELECTION& creation_pcr, 1167 TPM_HANDLE* object_handle, 1168 TPM2B_PUBLIC* out_public, 1169 TPM2B_CREATION_DATA* creation_data, 1170 TPM2B_DIGEST* creation_hash, 1171 TPMT_TK_CREATION* creation_ticket, 1172 TPM2B_NAME* name, 1173 AuthorizationDelegate* authorization_delegate)); 1174 MOCK_METHOD6(HierarchyControl, 1175 void(const TPMI_RH_HIERARCHY& auth_handle, 1176 const std::string& auth_handle_name, 1177 const TPMI_RH_ENABLES& enable, 1178 const TPMI_YES_NO& state, 1179 AuthorizationDelegate* authorization_delegate, 1180 const HierarchyControlResponse& callback)); 1181 MOCK_METHOD5(HierarchyControlSync, 1182 TPM_RC(const TPMI_RH_HIERARCHY& auth_handle, 1183 const std::string& auth_handle_name, 1184 const TPMI_RH_ENABLES& enable, 1185 const TPMI_YES_NO& state, 1186 AuthorizationDelegate* authorization_delegate)); 1187 MOCK_METHOD6(SetPrimaryPolicy, 1188 void(const TPMI_RH_HIERARCHY& auth_handle, 1189 const std::string& auth_handle_name, 1190 const TPM2B_DIGEST& auth_policy, 1191 const TPMI_ALG_HASH& hash_alg, 1192 AuthorizationDelegate* authorization_delegate, 1193 const SetPrimaryPolicyResponse& callback)); 1194 MOCK_METHOD5(SetPrimaryPolicySync, 1195 TPM_RC(const TPMI_RH_HIERARCHY& auth_handle, 1196 const std::string& auth_handle_name, 1197 const TPM2B_DIGEST& auth_policy, 1198 const TPMI_ALG_HASH& hash_alg, 1199 AuthorizationDelegate* authorization_delegate)); 1200 MOCK_METHOD4(ChangePPS, 1201 void(const TPMI_RH_PLATFORM& auth_handle, 1202 const std::string& auth_handle_name, 1203 AuthorizationDelegate* authorization_delegate, 1204 const ChangePPSResponse& callback)); 1205 MOCK_METHOD3(ChangePPSSync, 1206 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 1207 const std::string& auth_handle_name, 1208 AuthorizationDelegate* authorization_delegate)); 1209 MOCK_METHOD4(ChangeEPS, 1210 void(const TPMI_RH_PLATFORM& auth_handle, 1211 const std::string& auth_handle_name, 1212 AuthorizationDelegate* authorization_delegate, 1213 const ChangeEPSResponse& callback)); 1214 MOCK_METHOD3(ChangeEPSSync, 1215 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 1216 const std::string& auth_handle_name, 1217 AuthorizationDelegate* authorization_delegate)); 1218 MOCK_METHOD4(Clear, 1219 void(const TPMI_RH_CLEAR& auth_handle, 1220 const std::string& auth_handle_name, 1221 AuthorizationDelegate* authorization_delegate, 1222 const ClearResponse& callback)); 1223 MOCK_METHOD3(ClearSync, 1224 TPM_RC(const TPMI_RH_CLEAR& auth_handle, 1225 const std::string& auth_handle_name, 1226 AuthorizationDelegate* authorization_delegate)); 1227 MOCK_METHOD5(ClearControl, 1228 void(const TPMI_RH_CLEAR& auth, 1229 const std::string& auth_name, 1230 const TPMI_YES_NO& disable, 1231 AuthorizationDelegate* authorization_delegate, 1232 const ClearControlResponse& callback)); 1233 MOCK_METHOD4(ClearControlSync, 1234 TPM_RC(const TPMI_RH_CLEAR& auth, 1235 const std::string& auth_name, 1236 const TPMI_YES_NO& disable, 1237 AuthorizationDelegate* authorization_delegate)); 1238 MOCK_METHOD5(HierarchyChangeAuth, 1239 void(const TPMI_RH_HIERARCHY_AUTH& auth_handle, 1240 const std::string& auth_handle_name, 1241 const TPM2B_AUTH& new_auth, 1242 AuthorizationDelegate* authorization_delegate, 1243 const HierarchyChangeAuthResponse& callback)); 1244 MOCK_METHOD4(HierarchyChangeAuthSync, 1245 TPM_RC(const TPMI_RH_HIERARCHY_AUTH& auth_handle, 1246 const std::string& auth_handle_name, 1247 const TPM2B_AUTH& new_auth, 1248 AuthorizationDelegate* authorization_delegate)); 1249 MOCK_METHOD4(DictionaryAttackLockReset, 1250 void(const TPMI_RH_LOCKOUT& lock_handle, 1251 const std::string& lock_handle_name, 1252 AuthorizationDelegate* authorization_delegate, 1253 const DictionaryAttackLockResetResponse& callback)); 1254 MOCK_METHOD3(DictionaryAttackLockResetSync, 1255 TPM_RC(const TPMI_RH_LOCKOUT& lock_handle, 1256 const std::string& lock_handle_name, 1257 AuthorizationDelegate* authorization_delegate)); 1258 MOCK_METHOD7(DictionaryAttackParameters, 1259 void(const TPMI_RH_LOCKOUT& lock_handle, 1260 const std::string& lock_handle_name, 1261 const UINT32& new_max_tries, 1262 const UINT32& new_recovery_time, 1263 const UINT32& lockout_recovery, 1264 AuthorizationDelegate* authorization_delegate, 1265 const DictionaryAttackParametersResponse& callback)); 1266 MOCK_METHOD6(DictionaryAttackParametersSync, 1267 TPM_RC(const TPMI_RH_LOCKOUT& lock_handle, 1268 const std::string& lock_handle_name, 1269 const UINT32& new_max_tries, 1270 const UINT32& new_recovery_time, 1271 const UINT32& lockout_recovery, 1272 AuthorizationDelegate* authorization_delegate)); 1273 MOCK_METHOD6(PP_Commands, 1274 void(const TPMI_RH_PLATFORM& auth, 1275 const std::string& auth_name, 1276 const TPML_CC& set_list, 1277 const TPML_CC& clear_list, 1278 AuthorizationDelegate* authorization_delegate, 1279 const PP_CommandsResponse& callback)); 1280 MOCK_METHOD5(PP_CommandsSync, 1281 TPM_RC(const TPMI_RH_PLATFORM& auth, 1282 const std::string& auth_name, 1283 const TPML_CC& set_list, 1284 const TPML_CC& clear_list, 1285 AuthorizationDelegate* authorization_delegate)); 1286 MOCK_METHOD5(SetAlgorithmSet, 1287 void(const TPMI_RH_PLATFORM& auth_handle, 1288 const std::string& auth_handle_name, 1289 const UINT32& algorithm_set, 1290 AuthorizationDelegate* authorization_delegate, 1291 const SetAlgorithmSetResponse& callback)); 1292 MOCK_METHOD4(SetAlgorithmSetSync, 1293 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 1294 const std::string& auth_handle_name, 1295 const UINT32& algorithm_set, 1296 AuthorizationDelegate* authorization_delegate)); 1297 MOCK_METHOD8(FieldUpgradeStart, 1298 void(const TPMI_RH_PLATFORM& authorization, 1299 const std::string& authorization_name, 1300 const TPMI_DH_OBJECT& key_handle, 1301 const std::string& key_handle_name, 1302 const TPM2B_DIGEST& fu_digest, 1303 const TPMT_SIGNATURE& manifest_signature, 1304 AuthorizationDelegate* authorization_delegate, 1305 const FieldUpgradeStartResponse& callback)); 1306 MOCK_METHOD7(FieldUpgradeStartSync, 1307 TPM_RC(const TPMI_RH_PLATFORM& authorization, 1308 const std::string& authorization_name, 1309 const TPMI_DH_OBJECT& key_handle, 1310 const std::string& key_handle_name, 1311 const TPM2B_DIGEST& fu_digest, 1312 const TPMT_SIGNATURE& manifest_signature, 1313 AuthorizationDelegate* authorization_delegate)); 1314 MOCK_METHOD3(FieldUpgradeData, 1315 void(const TPM2B_MAX_BUFFER& fu_data, 1316 AuthorizationDelegate* authorization_delegate, 1317 const FieldUpgradeDataResponse& callback)); 1318 MOCK_METHOD4(FieldUpgradeDataSync, 1319 TPM_RC(const TPM2B_MAX_BUFFER& fu_data, 1320 TPMT_HA* next_digest, 1321 TPMT_HA* first_digest, 1322 AuthorizationDelegate* authorization_delegate)); 1323 MOCK_METHOD3(FirmwareRead, 1324 void(const UINT32& sequence_number, 1325 AuthorizationDelegate* authorization_delegate, 1326 const FirmwareReadResponse& callback)); 1327 MOCK_METHOD3(FirmwareReadSync, 1328 TPM_RC(const UINT32& sequence_number, 1329 TPM2B_MAX_BUFFER* fu_data, 1330 AuthorizationDelegate* authorization_delegate)); 1331 MOCK_METHOD4(ContextSave, 1332 void(const TPMI_DH_CONTEXT& save_handle, 1333 const std::string& save_handle_name, 1334 AuthorizationDelegate* authorization_delegate, 1335 const ContextSaveResponse& callback)); 1336 MOCK_METHOD4(ContextSaveSync, 1337 TPM_RC(const TPMI_DH_CONTEXT& save_handle, 1338 const std::string& save_handle_name, 1339 TPMS_CONTEXT* context, 1340 AuthorizationDelegate* authorization_delegate)); 1341 MOCK_METHOD3(ContextLoad, 1342 void(const TPMS_CONTEXT& context, 1343 AuthorizationDelegate* authorization_delegate, 1344 const ContextLoadResponse& callback)); 1345 MOCK_METHOD3(ContextLoadSync, 1346 TPM_RC(const TPMS_CONTEXT& context, 1347 TPMI_DH_CONTEXT* loaded_handle, 1348 AuthorizationDelegate* authorization_delegate)); 1349 MOCK_METHOD3(FlushContext, 1350 void(const TPMI_DH_CONTEXT& flush_handle, 1351 AuthorizationDelegate* authorization_delegate, 1352 const FlushContextResponse& callback)); 1353 MOCK_METHOD2(FlushContextSync, 1354 TPM_RC(const TPMI_DH_CONTEXT& flush_handle, 1355 AuthorizationDelegate* authorization_delegate)); 1356 MOCK_METHOD7(EvictControl, 1357 void(const TPMI_RH_PROVISION& auth, 1358 const std::string& auth_name, 1359 const TPMI_DH_OBJECT& object_handle, 1360 const std::string& object_handle_name, 1361 const TPMI_DH_PERSISTENT& persistent_handle, 1362 AuthorizationDelegate* authorization_delegate, 1363 const EvictControlResponse& callback)); 1364 MOCK_METHOD6(EvictControlSync, 1365 TPM_RC(const TPMI_RH_PROVISION& auth, 1366 const std::string& auth_name, 1367 const TPMI_DH_OBJECT& object_handle, 1368 const std::string& object_handle_name, 1369 const TPMI_DH_PERSISTENT& persistent_handle, 1370 AuthorizationDelegate* authorization_delegate)); 1371 MOCK_METHOD2(ReadClock, 1372 void(AuthorizationDelegate* authorization_delegate, 1373 const ReadClockResponse& callback)); 1374 MOCK_METHOD2(ReadClockSync, 1375 TPM_RC(TPMS_TIME_INFO* current_time, 1376 AuthorizationDelegate* authorization_delegate)); 1377 MOCK_METHOD5(ClockSet, 1378 void(const TPMI_RH_PROVISION& auth, 1379 const std::string& auth_name, 1380 const UINT64& new_time, 1381 AuthorizationDelegate* authorization_delegate, 1382 const ClockSetResponse& callback)); 1383 MOCK_METHOD4(ClockSetSync, 1384 TPM_RC(const TPMI_RH_PROVISION& auth, 1385 const std::string& auth_name, 1386 const UINT64& new_time, 1387 AuthorizationDelegate* authorization_delegate)); 1388 MOCK_METHOD5(ClockRateAdjust, 1389 void(const TPMI_RH_PROVISION& auth, 1390 const std::string& auth_name, 1391 const TPM_CLOCK_ADJUST& rate_adjust, 1392 AuthorizationDelegate* authorization_delegate, 1393 const ClockRateAdjustResponse& callback)); 1394 MOCK_METHOD4(ClockRateAdjustSync, 1395 TPM_RC(const TPMI_RH_PROVISION& auth, 1396 const std::string& auth_name, 1397 const TPM_CLOCK_ADJUST& rate_adjust, 1398 AuthorizationDelegate* authorization_delegate)); 1399 MOCK_METHOD5(GetCapability, 1400 void(const TPM_CAP& capability, 1401 const UINT32& property, 1402 const UINT32& property_count, 1403 AuthorizationDelegate* authorization_delegate, 1404 const GetCapabilityResponse& callback)); 1405 MOCK_METHOD6(GetCapabilitySync, 1406 TPM_RC(const TPM_CAP& capability, 1407 const UINT32& property, 1408 const UINT32& property_count, 1409 TPMI_YES_NO* more_data, 1410 TPMS_CAPABILITY_DATA* capability_data, 1411 AuthorizationDelegate* authorization_delegate)); 1412 MOCK_METHOD3(TestParms, 1413 void(const TPMT_PUBLIC_PARMS& parameters, 1414 AuthorizationDelegate* authorization_delegate, 1415 const TestParmsResponse& callback)); 1416 MOCK_METHOD2(TestParmsSync, 1417 TPM_RC(const TPMT_PUBLIC_PARMS& parameters, 1418 AuthorizationDelegate* authorization_delegate)); 1419 MOCK_METHOD6(NV_DefineSpace, 1420 void(const TPMI_RH_PROVISION& auth_handle, 1421 const std::string& auth_handle_name, 1422 const TPM2B_AUTH& auth, 1423 const TPM2B_NV_PUBLIC& public_info, 1424 AuthorizationDelegate* authorization_delegate, 1425 const NV_DefineSpaceResponse& callback)); 1426 MOCK_METHOD5(NV_DefineSpaceSync, 1427 TPM_RC(const TPMI_RH_PROVISION& auth_handle, 1428 const std::string& auth_handle_name, 1429 const TPM2B_AUTH& auth, 1430 const TPM2B_NV_PUBLIC& public_info, 1431 AuthorizationDelegate* authorization_delegate)); 1432 MOCK_METHOD6(NV_UndefineSpace, 1433 void(const TPMI_RH_PROVISION& auth_handle, 1434 const std::string& auth_handle_name, 1435 const TPMI_RH_NV_INDEX& nv_index, 1436 const std::string& nv_index_name, 1437 AuthorizationDelegate* authorization_delegate, 1438 const NV_UndefineSpaceResponse& callback)); 1439 MOCK_METHOD5(NV_UndefineSpaceSync, 1440 TPM_RC(const TPMI_RH_PROVISION& auth_handle, 1441 const std::string& auth_handle_name, 1442 const TPMI_RH_NV_INDEX& nv_index, 1443 const std::string& nv_index_name, 1444 AuthorizationDelegate* authorization_delegate)); 1445 MOCK_METHOD6(NV_UndefineSpaceSpecial, 1446 void(const TPMI_RH_NV_INDEX& nv_index, 1447 const std::string& nv_index_name, 1448 const TPMI_RH_PLATFORM& platform, 1449 const std::string& platform_name, 1450 AuthorizationDelegate* authorization_delegate, 1451 const NV_UndefineSpaceSpecialResponse& callback)); 1452 MOCK_METHOD5(NV_UndefineSpaceSpecialSync, 1453 TPM_RC(const TPMI_RH_NV_INDEX& nv_index, 1454 const std::string& nv_index_name, 1455 const TPMI_RH_PLATFORM& platform, 1456 const std::string& platform_name, 1457 AuthorizationDelegate* authorization_delegate)); 1458 MOCK_METHOD4(NV_ReadPublic, 1459 void(const TPMI_RH_NV_INDEX& nv_index, 1460 const std::string& nv_index_name, 1461 AuthorizationDelegate* authorization_delegate, 1462 const NV_ReadPublicResponse& callback)); 1463 MOCK_METHOD5(NV_ReadPublicSync, 1464 TPM_RC(const TPMI_RH_NV_INDEX& nv_index, 1465 const std::string& nv_index_name, 1466 TPM2B_NV_PUBLIC* nv_public, 1467 TPM2B_NAME* nv_name, 1468 AuthorizationDelegate* authorization_delegate)); 1469 MOCK_METHOD8(NV_Write, 1470 void(const TPMI_RH_NV_AUTH& auth_handle, 1471 const std::string& auth_handle_name, 1472 const TPMI_RH_NV_INDEX& nv_index, 1473 const std::string& nv_index_name, 1474 const TPM2B_MAX_NV_BUFFER& data, 1475 const UINT16& offset, 1476 AuthorizationDelegate* authorization_delegate, 1477 const NV_WriteResponse& callback)); 1478 MOCK_METHOD7(NV_WriteSync, 1479 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1480 const std::string& auth_handle_name, 1481 const TPMI_RH_NV_INDEX& nv_index, 1482 const std::string& nv_index_name, 1483 const TPM2B_MAX_NV_BUFFER& data, 1484 const UINT16& offset, 1485 AuthorizationDelegate* authorization_delegate)); 1486 MOCK_METHOD6(NV_Increment, 1487 void(const TPMI_RH_NV_AUTH& auth_handle, 1488 const std::string& auth_handle_name, 1489 const TPMI_RH_NV_INDEX& nv_index, 1490 const std::string& nv_index_name, 1491 AuthorizationDelegate* authorization_delegate, 1492 const NV_IncrementResponse& callback)); 1493 MOCK_METHOD5(NV_IncrementSync, 1494 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1495 const std::string& auth_handle_name, 1496 const TPMI_RH_NV_INDEX& nv_index, 1497 const std::string& nv_index_name, 1498 AuthorizationDelegate* authorization_delegate)); 1499 MOCK_METHOD7(NV_Extend, 1500 void(const TPMI_RH_NV_AUTH& auth_handle, 1501 const std::string& auth_handle_name, 1502 const TPMI_RH_NV_INDEX& nv_index, 1503 const std::string& nv_index_name, 1504 const TPM2B_MAX_NV_BUFFER& data, 1505 AuthorizationDelegate* authorization_delegate, 1506 const NV_ExtendResponse& callback)); 1507 MOCK_METHOD6(NV_ExtendSync, 1508 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1509 const std::string& auth_handle_name, 1510 const TPMI_RH_NV_INDEX& nv_index, 1511 const std::string& nv_index_name, 1512 const TPM2B_MAX_NV_BUFFER& data, 1513 AuthorizationDelegate* authorization_delegate)); 1514 MOCK_METHOD7(NV_SetBits, 1515 void(const TPMI_RH_NV_AUTH& auth_handle, 1516 const std::string& auth_handle_name, 1517 const TPMI_RH_NV_INDEX& nv_index, 1518 const std::string& nv_index_name, 1519 const UINT64& bits, 1520 AuthorizationDelegate* authorization_delegate, 1521 const NV_SetBitsResponse& callback)); 1522 MOCK_METHOD6(NV_SetBitsSync, 1523 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1524 const std::string& auth_handle_name, 1525 const TPMI_RH_NV_INDEX& nv_index, 1526 const std::string& nv_index_name, 1527 const UINT64& bits, 1528 AuthorizationDelegate* authorization_delegate)); 1529 MOCK_METHOD6(NV_WriteLock, 1530 void(const TPMI_RH_NV_AUTH& auth_handle, 1531 const std::string& auth_handle_name, 1532 const TPMI_RH_NV_INDEX& nv_index, 1533 const std::string& nv_index_name, 1534 AuthorizationDelegate* authorization_delegate, 1535 const NV_WriteLockResponse& callback)); 1536 MOCK_METHOD5(NV_WriteLockSync, 1537 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1538 const std::string& auth_handle_name, 1539 const TPMI_RH_NV_INDEX& nv_index, 1540 const std::string& nv_index_name, 1541 AuthorizationDelegate* authorization_delegate)); 1542 MOCK_METHOD4(NV_GlobalWriteLock, 1543 void(const TPMI_RH_PROVISION& auth_handle, 1544 const std::string& auth_handle_name, 1545 AuthorizationDelegate* authorization_delegate, 1546 const NV_GlobalWriteLockResponse& callback)); 1547 MOCK_METHOD3(NV_GlobalWriteLockSync, 1548 TPM_RC(const TPMI_RH_PROVISION& auth_handle, 1549 const std::string& auth_handle_name, 1550 AuthorizationDelegate* authorization_delegate)); 1551 MOCK_METHOD8(NV_Read, 1552 void(const TPMI_RH_NV_AUTH& auth_handle, 1553 const std::string& auth_handle_name, 1554 const TPMI_RH_NV_INDEX& nv_index, 1555 const std::string& nv_index_name, 1556 const UINT16& size, 1557 const UINT16& offset, 1558 AuthorizationDelegate* authorization_delegate, 1559 const NV_ReadResponse& callback)); 1560 MOCK_METHOD8(NV_ReadSync, 1561 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1562 const std::string& auth_handle_name, 1563 const TPMI_RH_NV_INDEX& nv_index, 1564 const std::string& nv_index_name, 1565 const UINT16& size, 1566 const UINT16& offset, 1567 TPM2B_MAX_NV_BUFFER* data, 1568 AuthorizationDelegate* authorization_delegate)); 1569 MOCK_METHOD6(NV_ReadLock, 1570 void(const TPMI_RH_NV_AUTH& auth_handle, 1571 const std::string& auth_handle_name, 1572 const TPMI_RH_NV_INDEX& nv_index, 1573 const std::string& nv_index_name, 1574 AuthorizationDelegate* authorization_delegate, 1575 const NV_ReadLockResponse& callback)); 1576 MOCK_METHOD5(NV_ReadLockSync, 1577 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1578 const std::string& auth_handle_name, 1579 const TPMI_RH_NV_INDEX& nv_index, 1580 const std::string& nv_index_name, 1581 AuthorizationDelegate* authorization_delegate)); 1582 MOCK_METHOD5(NV_ChangeAuth, 1583 void(const TPMI_RH_NV_INDEX& nv_index, 1584 const std::string& nv_index_name, 1585 const TPM2B_AUTH& new_auth, 1586 AuthorizationDelegate* authorization_delegate, 1587 const NV_ChangeAuthResponse& callback)); 1588 MOCK_METHOD4(NV_ChangeAuthSync, 1589 TPM_RC(const TPMI_RH_NV_INDEX& nv_index, 1590 const std::string& nv_index_name, 1591 const TPM2B_AUTH& new_auth, 1592 AuthorizationDelegate* authorization_delegate)); 1593 // Too many args to mock, forward to *Short version. 1594 void NV_Certify(const TPMI_DH_OBJECT& sign_handle, 1595 const std::string& sign_handle_name, 1596 const TPMI_RH_NV_AUTH& auth_handle, 1597 const std::string& auth_handle_name, 1598 const TPMI_RH_NV_INDEX& nv_index, 1599 const std::string& nv_index_name, 1600 const TPM2B_DATA& qualifying_data, 1601 const TPMT_SIG_SCHEME& in_scheme, 1602 const UINT16& size, 1603 const UINT16& offset, 1604 AuthorizationDelegate* authorization_delegate, 1605 const NV_CertifyResponse& callback) override; 1606 MOCK_METHOD9(NV_CertifyShort, 1607 void(const TPMI_DH_OBJECT& sign_handle, 1608 const TPMI_RH_NV_AUTH& auth_handle, 1609 const TPMI_RH_NV_INDEX& nv_index, 1610 const TPM2B_DATA& qualifying_data, 1611 const TPMT_SIG_SCHEME& in_scheme, 1612 const UINT16& size, 1613 const UINT16& offset, 1614 AuthorizationDelegate* authorization_delegate, 1615 const NV_CertifyResponse& callback)); 1616 // Too many args to mock, forward to *Short version. 1617 TPM_RC NV_CertifySync(const TPMI_DH_OBJECT& sign_handle, 1618 const std::string& sign_handle_name, 1619 const TPMI_RH_NV_AUTH& auth_handle, 1620 const std::string& auth_handle_name, 1621 const TPMI_RH_NV_INDEX& nv_index, 1622 const std::string& nv_index_name, 1623 const TPM2B_DATA& qualifying_data, 1624 const TPMT_SIG_SCHEME& in_scheme, 1625 const UINT16& size, 1626 const UINT16& offset, 1627 TPM2B_ATTEST* certify_info, 1628 TPMT_SIGNATURE* signature, 1629 AuthorizationDelegate* authorization_delegate) override; 1630 MOCK_METHOD10(NV_CertifySyncShort, 1631 TPM_RC(const TPMI_DH_OBJECT& sign_handle, 1632 const TPMI_RH_NV_AUTH& auth_handle, 1633 const TPMI_RH_NV_INDEX& nv_index, 1634 const TPM2B_DATA& qualifying_data, 1635 const TPMT_SIG_SCHEME& in_scheme, 1636 const UINT16& size, 1637 const UINT16& offset, 1638 TPM2B_ATTEST* certify_info, 1639 TPMT_SIGNATURE* signature, 1640 AuthorizationDelegate* authorization_delegate)); 1641 }; 1642 1643 } // namespace trunks 1644 1645 #endif // TRUNKS_MOCK_TPM_H_ 1646