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 27namespace trunks { 28 29class 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( 846 const TPMI_DH_OBJECT& auth_object, 847 const std::string& auth_object_name, 848 const TPMI_SH_POLICY& policy_session, 849 const std::string& policy_session_name, 850 const TPM2B_NONCE& nonce_tpm, 851 const TPM2B_DIGEST& cp_hash_a, 852 const TPM2B_NONCE& policy_ref, 853 const INT32& expiration, 854 const TPMT_SIGNATURE& auth, 855 AuthorizationDelegate* authorization_delegate, 856 const PolicySignedResponse& callback) override; 857 MOCK_METHOD9(PolicySignedShort, 858 void(const TPMI_DH_OBJECT& auth_object, 859 const TPMI_SH_POLICY& policy_session, 860 const TPM2B_NONCE& nonce_tpm, 861 const TPM2B_DIGEST& cp_hash_a, 862 const TPM2B_NONCE& policy_ref, 863 const INT32& expiration, 864 const TPMT_SIGNATURE& auth, 865 AuthorizationDelegate* authorization_delegate, 866 const PolicySignedResponse& callback)); 867 // Too many args to mock, forward to *Short version. 868 TPM_RC PolicySignedSync( 869 const TPMI_DH_OBJECT& auth_object, 870 const std::string& auth_object_name, 871 const TPMI_SH_POLICY& policy_session, 872 const std::string& policy_session_name, 873 const TPM2B_NONCE& nonce_tpm, 874 const TPM2B_DIGEST& cp_hash_a, 875 const TPM2B_NONCE& policy_ref, 876 const INT32& expiration, 877 const TPMT_SIGNATURE& auth, 878 TPM2B_TIMEOUT* timeout, 879 TPMT_TK_AUTH* policy_ticket, 880 AuthorizationDelegate* authorization_delegate) override; 881 MOCK_METHOD10(PolicySignedSyncShort, 882 TPM_RC(const TPMI_DH_OBJECT& auth_object, 883 const TPMI_SH_POLICY& policy_session, 884 const TPM2B_NONCE& nonce_tpm, 885 const TPM2B_DIGEST& cp_hash_a, 886 const TPM2B_NONCE& policy_ref, 887 const INT32& expiration, 888 const TPMT_SIGNATURE& auth, 889 TPM2B_TIMEOUT* timeout, 890 TPMT_TK_AUTH* policy_ticket, 891 AuthorizationDelegate* authorization_delegate)); 892 MOCK_METHOD10(PolicySecret, 893 void(const TPMI_DH_ENTITY& auth_handle, 894 const std::string& auth_handle_name, 895 const TPMI_SH_POLICY& policy_session, 896 const std::string& policy_session_name, 897 const TPM2B_NONCE& nonce_tpm, 898 const TPM2B_DIGEST& cp_hash_a, 899 const TPM2B_NONCE& policy_ref, 900 const INT32& expiration, 901 AuthorizationDelegate* authorization_delegate, 902 const PolicySecretResponse& callback)); 903 // Too many args to mock, forward to *Short version. 904 TPM_RC PolicySecretSync( 905 const TPMI_DH_ENTITY& auth_handle, 906 const std::string& auth_handle_name, 907 const TPMI_SH_POLICY& policy_session, 908 const std::string& policy_session_name, 909 const TPM2B_NONCE& nonce_tpm, 910 const TPM2B_DIGEST& cp_hash_a, 911 const TPM2B_NONCE& policy_ref, 912 const INT32& expiration, 913 TPM2B_TIMEOUT* timeout, 914 TPMT_TK_AUTH* policy_ticket, 915 AuthorizationDelegate* authorization_delegate) override; 916 MOCK_METHOD9(PolicySecretSyncShort, 917 TPM_RC(const TPMI_DH_ENTITY& auth_handle, 918 const TPMI_SH_POLICY& policy_session, 919 const TPM2B_NONCE& nonce_tpm, 920 const TPM2B_DIGEST& cp_hash_a, 921 const TPM2B_NONCE& policy_ref, 922 const INT32& expiration, 923 TPM2B_TIMEOUT* timeout, 924 TPMT_TK_AUTH* policy_ticket, 925 AuthorizationDelegate* authorization_delegate)); 926 MOCK_METHOD9(PolicyTicket, 927 void(const TPMI_SH_POLICY& policy_session, 928 const std::string& policy_session_name, 929 const TPM2B_TIMEOUT& timeout, 930 const TPM2B_DIGEST& cp_hash_a, 931 const TPM2B_NONCE& policy_ref, 932 const TPM2B_NAME& auth_name, 933 const TPMT_TK_AUTH& ticket, 934 AuthorizationDelegate* authorization_delegate, 935 const PolicyTicketResponse& callback)); 936 MOCK_METHOD8(PolicyTicketSync, 937 TPM_RC(const TPMI_SH_POLICY& policy_session, 938 const std::string& policy_session_name, 939 const TPM2B_TIMEOUT& timeout, 940 const TPM2B_DIGEST& cp_hash_a, 941 const TPM2B_NONCE& policy_ref, 942 const TPM2B_NAME& auth_name, 943 const TPMT_TK_AUTH& ticket, 944 AuthorizationDelegate* authorization_delegate)); 945 MOCK_METHOD5(PolicyOR, 946 void(const TPMI_SH_POLICY& policy_session, 947 const std::string& policy_session_name, 948 const TPML_DIGEST& p_hash_list, 949 AuthorizationDelegate* authorization_delegate, 950 const PolicyORResponse& callback)); 951 MOCK_METHOD4(PolicyORSync, 952 TPM_RC(const TPMI_SH_POLICY& policy_session, 953 const std::string& policy_session_name, 954 const TPML_DIGEST& p_hash_list, 955 AuthorizationDelegate* authorization_delegate)); 956 MOCK_METHOD6(PolicyPCR, 957 void(const TPMI_SH_POLICY& policy_session, 958 const std::string& policy_session_name, 959 const TPM2B_DIGEST& pcr_digest, 960 const TPML_PCR_SELECTION& pcrs, 961 AuthorizationDelegate* authorization_delegate, 962 const PolicyPCRResponse& callback)); 963 MOCK_METHOD5(PolicyPCRSync, 964 TPM_RC(const TPMI_SH_POLICY& policy_session, 965 const std::string& policy_session_name, 966 const TPM2B_DIGEST& pcr_digest, 967 const TPML_PCR_SELECTION& pcrs, 968 AuthorizationDelegate* authorization_delegate)); 969 MOCK_METHOD5(PolicyLocality, 970 void(const TPMI_SH_POLICY& policy_session, 971 const std::string& policy_session_name, 972 const TPMA_LOCALITY& locality, 973 AuthorizationDelegate* authorization_delegate, 974 const PolicyLocalityResponse& callback)); 975 MOCK_METHOD4(PolicyLocalitySync, 976 TPM_RC(const TPMI_SH_POLICY& policy_session, 977 const std::string& policy_session_name, 978 const TPMA_LOCALITY& locality, 979 AuthorizationDelegate* authorization_delegate)); 980 // Too many args to mock, forward to *Short version. 981 void PolicyNV(const TPMI_RH_NV_AUTH& auth_handle, 982 const std::string& auth_handle_name, 983 const TPMI_RH_NV_INDEX& nv_index, 984 const std::string& nv_index_name, 985 const TPMI_SH_POLICY& policy_session, 986 const std::string& policy_session_name, 987 const TPM2B_OPERAND& operand_b, 988 const UINT16& offset, 989 const TPM_EO& operation, 990 AuthorizationDelegate* authorization_delegate, 991 const PolicyNVResponse& callback) override; 992 MOCK_METHOD8(PolicyNVShort, 993 void(const TPMI_RH_NV_AUTH& auth_handle, 994 const TPMI_RH_NV_INDEX& nv_index, 995 const TPMI_SH_POLICY& policy_session, 996 const TPM2B_OPERAND& operand_b, 997 const UINT16& offset, 998 const TPM_EO& operation, 999 AuthorizationDelegate* authorization_delegate, 1000 const PolicyNVResponse& callback)); 1001 MOCK_METHOD10(PolicyNVSync, 1002 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1003 const std::string& auth_handle_name, 1004 const TPMI_RH_NV_INDEX& nv_index, 1005 const std::string& nv_index_name, 1006 const TPMI_SH_POLICY& policy_session, 1007 const std::string& policy_session_name, 1008 const TPM2B_OPERAND& operand_b, 1009 const UINT16& offset, 1010 const TPM_EO& operation, 1011 AuthorizationDelegate* authorization_delegate)); 1012 MOCK_METHOD7(PolicyCounterTimer, 1013 void(const TPMI_SH_POLICY& policy_session, 1014 const std::string& policy_session_name, 1015 const TPM2B_OPERAND& operand_b, 1016 const UINT16& offset, 1017 const TPM_EO& operation, 1018 AuthorizationDelegate* authorization_delegate, 1019 const PolicyCounterTimerResponse& callback)); 1020 MOCK_METHOD6(PolicyCounterTimerSync, 1021 TPM_RC(const TPMI_SH_POLICY& policy_session, 1022 const std::string& policy_session_name, 1023 const TPM2B_OPERAND& operand_b, 1024 const UINT16& offset, 1025 const TPM_EO& operation, 1026 AuthorizationDelegate* authorization_delegate)); 1027 MOCK_METHOD5(PolicyCommandCode, 1028 void(const TPMI_SH_POLICY& policy_session, 1029 const std::string& policy_session_name, 1030 const TPM_CC& code, 1031 AuthorizationDelegate* authorization_delegate, 1032 const PolicyCommandCodeResponse& callback)); 1033 MOCK_METHOD4(PolicyCommandCodeSync, 1034 TPM_RC(const TPMI_SH_POLICY& policy_session, 1035 const std::string& policy_session_name, 1036 const TPM_CC& code, 1037 AuthorizationDelegate* authorization_delegate)); 1038 MOCK_METHOD4(PolicyPhysicalPresence, 1039 void(const TPMI_SH_POLICY& policy_session, 1040 const std::string& policy_session_name, 1041 AuthorizationDelegate* authorization_delegate, 1042 const PolicyPhysicalPresenceResponse& callback)); 1043 MOCK_METHOD3(PolicyPhysicalPresenceSync, 1044 TPM_RC(const TPMI_SH_POLICY& policy_session, 1045 const std::string& policy_session_name, 1046 AuthorizationDelegate* authorization_delegate)); 1047 MOCK_METHOD5(PolicyCpHash, 1048 void(const TPMI_SH_POLICY& policy_session, 1049 const std::string& policy_session_name, 1050 const TPM2B_DIGEST& cp_hash_a, 1051 AuthorizationDelegate* authorization_delegate, 1052 const PolicyCpHashResponse& callback)); 1053 MOCK_METHOD4(PolicyCpHashSync, 1054 TPM_RC(const TPMI_SH_POLICY& policy_session, 1055 const std::string& policy_session_name, 1056 const TPM2B_DIGEST& cp_hash_a, 1057 AuthorizationDelegate* authorization_delegate)); 1058 MOCK_METHOD5(PolicyNameHash, 1059 void(const TPMI_SH_POLICY& policy_session, 1060 const std::string& policy_session_name, 1061 const TPM2B_DIGEST& name_hash, 1062 AuthorizationDelegate* authorization_delegate, 1063 const PolicyNameHashResponse& callback)); 1064 MOCK_METHOD4(PolicyNameHashSync, 1065 TPM_RC(const TPMI_SH_POLICY& policy_session, 1066 const std::string& policy_session_name, 1067 const TPM2B_DIGEST& name_hash, 1068 AuthorizationDelegate* authorization_delegate)); 1069 MOCK_METHOD7(PolicyDuplicationSelect, 1070 void(const TPMI_SH_POLICY& policy_session, 1071 const std::string& policy_session_name, 1072 const TPM2B_NAME& object_name, 1073 const TPM2B_NAME& new_parent_name, 1074 const TPMI_YES_NO& include_object, 1075 AuthorizationDelegate* authorization_delegate, 1076 const PolicyDuplicationSelectResponse& callback)); 1077 MOCK_METHOD6(PolicyDuplicationSelectSync, 1078 TPM_RC(const TPMI_SH_POLICY& policy_session, 1079 const std::string& policy_session_name, 1080 const TPM2B_NAME& object_name, 1081 const TPM2B_NAME& new_parent_name, 1082 const TPMI_YES_NO& include_object, 1083 AuthorizationDelegate* authorization_delegate)); 1084 MOCK_METHOD8(PolicyAuthorize, 1085 void(const TPMI_SH_POLICY& policy_session, 1086 const std::string& policy_session_name, 1087 const TPM2B_DIGEST& approved_policy, 1088 const TPM2B_NONCE& policy_ref, 1089 const TPM2B_NAME& key_sign, 1090 const TPMT_TK_VERIFIED& check_ticket, 1091 AuthorizationDelegate* authorization_delegate, 1092 const PolicyAuthorizeResponse& callback)); 1093 MOCK_METHOD7(PolicyAuthorizeSync, 1094 TPM_RC(const TPMI_SH_POLICY& policy_session, 1095 const std::string& policy_session_name, 1096 const TPM2B_DIGEST& approved_policy, 1097 const TPM2B_NONCE& policy_ref, 1098 const TPM2B_NAME& key_sign, 1099 const TPMT_TK_VERIFIED& check_ticket, 1100 AuthorizationDelegate* authorization_delegate)); 1101 MOCK_METHOD4(PolicyAuthValue, 1102 void(const TPMI_SH_POLICY& policy_session, 1103 const std::string& policy_session_name, 1104 AuthorizationDelegate* authorization_delegate, 1105 const PolicyAuthValueResponse& callback)); 1106 MOCK_METHOD3(PolicyAuthValueSync, 1107 TPM_RC(const TPMI_SH_POLICY& policy_session, 1108 const std::string& policy_session_name, 1109 AuthorizationDelegate* authorization_delegate)); 1110 MOCK_METHOD4(PolicyPassword, 1111 void(const TPMI_SH_POLICY& policy_session, 1112 const std::string& policy_session_name, 1113 AuthorizationDelegate* authorization_delegate, 1114 const PolicyPasswordResponse& callback)); 1115 MOCK_METHOD3(PolicyPasswordSync, 1116 TPM_RC(const TPMI_SH_POLICY& policy_session, 1117 const std::string& policy_session_name, 1118 AuthorizationDelegate* authorization_delegate)); 1119 MOCK_METHOD4(PolicyGetDigest, 1120 void(const TPMI_SH_POLICY& policy_session, 1121 const std::string& policy_session_name, 1122 AuthorizationDelegate* authorization_delegate, 1123 const PolicyGetDigestResponse& callback)); 1124 MOCK_METHOD4(PolicyGetDigestSync, 1125 TPM_RC(const TPMI_SH_POLICY& policy_session, 1126 const std::string& policy_session_name, 1127 TPM2B_DIGEST* policy_digest, 1128 AuthorizationDelegate* authorization_delegate)); 1129 MOCK_METHOD5(PolicyNvWritten, 1130 void(const TPMI_SH_POLICY& policy_session, 1131 const std::string& policy_session_name, 1132 const TPMI_YES_NO& written_set, 1133 AuthorizationDelegate* authorization_delegate, 1134 const PolicyNvWrittenResponse& callback)); 1135 MOCK_METHOD4(PolicyNvWrittenSync, 1136 TPM_RC(const TPMI_SH_POLICY& policy_session, 1137 const std::string& policy_session_name, 1138 const TPMI_YES_NO& written_set, 1139 AuthorizationDelegate* authorization_delegate)); 1140 MOCK_METHOD8(CreatePrimary, 1141 void(const TPMI_RH_HIERARCHY& primary_handle, 1142 const std::string& primary_handle_name, 1143 const TPM2B_SENSITIVE_CREATE& in_sensitive, 1144 const TPM2B_PUBLIC& in_public, 1145 const TPM2B_DATA& outside_info, 1146 const TPML_PCR_SELECTION& creation_pcr, 1147 AuthorizationDelegate* authorization_delegate, 1148 const CreatePrimaryResponse& callback)); 1149 // Too many args to mock, forward to *Short version. 1150 TPM_RC CreatePrimarySync( 1151 const TPMI_RH_HIERARCHY& primary_handle, 1152 const std::string& primary_handle_name, 1153 const TPM2B_SENSITIVE_CREATE& in_sensitive, 1154 const TPM2B_PUBLIC& in_public, 1155 const TPM2B_DATA& outside_info, 1156 const TPML_PCR_SELECTION& creation_pcr, 1157 TPM_HANDLE* object_handle, 1158 TPM2B_PUBLIC* out_public, 1159 TPM2B_CREATION_DATA* creation_data, 1160 TPM2B_DIGEST* creation_hash, 1161 TPMT_TK_CREATION* creation_ticket, 1162 TPM2B_NAME* name, 1163 AuthorizationDelegate* authorization_delegate) override; 1164 MOCK_METHOD10(CreatePrimarySyncShort, 1165 TPM_RC(const TPMI_RH_HIERARCHY& primary_handle, 1166 const TPM2B_PUBLIC& in_public, 1167 const TPML_PCR_SELECTION& creation_pcr, 1168 TPM_HANDLE* object_handle, 1169 TPM2B_PUBLIC* out_public, 1170 TPM2B_CREATION_DATA* creation_data, 1171 TPM2B_DIGEST* creation_hash, 1172 TPMT_TK_CREATION* creation_ticket, 1173 TPM2B_NAME* name, 1174 AuthorizationDelegate* authorization_delegate)); 1175 MOCK_METHOD6(HierarchyControl, 1176 void(const TPMI_RH_HIERARCHY& auth_handle, 1177 const std::string& auth_handle_name, 1178 const TPMI_RH_ENABLES& enable, 1179 const TPMI_YES_NO& state, 1180 AuthorizationDelegate* authorization_delegate, 1181 const HierarchyControlResponse& callback)); 1182 MOCK_METHOD5(HierarchyControlSync, 1183 TPM_RC(const TPMI_RH_HIERARCHY& auth_handle, 1184 const std::string& auth_handle_name, 1185 const TPMI_RH_ENABLES& enable, 1186 const TPMI_YES_NO& state, 1187 AuthorizationDelegate* authorization_delegate)); 1188 MOCK_METHOD6(SetPrimaryPolicy, 1189 void(const TPMI_RH_HIERARCHY& auth_handle, 1190 const std::string& auth_handle_name, 1191 const TPM2B_DIGEST& auth_policy, 1192 const TPMI_ALG_HASH& hash_alg, 1193 AuthorizationDelegate* authorization_delegate, 1194 const SetPrimaryPolicyResponse& callback)); 1195 MOCK_METHOD5(SetPrimaryPolicySync, 1196 TPM_RC(const TPMI_RH_HIERARCHY& auth_handle, 1197 const std::string& auth_handle_name, 1198 const TPM2B_DIGEST& auth_policy, 1199 const TPMI_ALG_HASH& hash_alg, 1200 AuthorizationDelegate* authorization_delegate)); 1201 MOCK_METHOD4(ChangePPS, 1202 void(const TPMI_RH_PLATFORM& auth_handle, 1203 const std::string& auth_handle_name, 1204 AuthorizationDelegate* authorization_delegate, 1205 const ChangePPSResponse& callback)); 1206 MOCK_METHOD3(ChangePPSSync, 1207 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 1208 const std::string& auth_handle_name, 1209 AuthorizationDelegate* authorization_delegate)); 1210 MOCK_METHOD4(ChangeEPS, 1211 void(const TPMI_RH_PLATFORM& auth_handle, 1212 const std::string& auth_handle_name, 1213 AuthorizationDelegate* authorization_delegate, 1214 const ChangeEPSResponse& callback)); 1215 MOCK_METHOD3(ChangeEPSSync, 1216 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 1217 const std::string& auth_handle_name, 1218 AuthorizationDelegate* authorization_delegate)); 1219 MOCK_METHOD4(Clear, 1220 void(const TPMI_RH_CLEAR& auth_handle, 1221 const std::string& auth_handle_name, 1222 AuthorizationDelegate* authorization_delegate, 1223 const ClearResponse& callback)); 1224 MOCK_METHOD3(ClearSync, 1225 TPM_RC(const TPMI_RH_CLEAR& auth_handle, 1226 const std::string& auth_handle_name, 1227 AuthorizationDelegate* authorization_delegate)); 1228 MOCK_METHOD5(ClearControl, 1229 void(const TPMI_RH_CLEAR& auth, 1230 const std::string& auth_name, 1231 const TPMI_YES_NO& disable, 1232 AuthorizationDelegate* authorization_delegate, 1233 const ClearControlResponse& callback)); 1234 MOCK_METHOD4(ClearControlSync, 1235 TPM_RC(const TPMI_RH_CLEAR& auth, 1236 const std::string& auth_name, 1237 const TPMI_YES_NO& disable, 1238 AuthorizationDelegate* authorization_delegate)); 1239 MOCK_METHOD5(HierarchyChangeAuth, 1240 void(const TPMI_RH_HIERARCHY_AUTH& auth_handle, 1241 const std::string& auth_handle_name, 1242 const TPM2B_AUTH& new_auth, 1243 AuthorizationDelegate* authorization_delegate, 1244 const HierarchyChangeAuthResponse& callback)); 1245 MOCK_METHOD4(HierarchyChangeAuthSync, 1246 TPM_RC(const TPMI_RH_HIERARCHY_AUTH& auth_handle, 1247 const std::string& auth_handle_name, 1248 const TPM2B_AUTH& new_auth, 1249 AuthorizationDelegate* authorization_delegate)); 1250 MOCK_METHOD4(DictionaryAttackLockReset, 1251 void(const TPMI_RH_LOCKOUT& lock_handle, 1252 const std::string& lock_handle_name, 1253 AuthorizationDelegate* authorization_delegate, 1254 const DictionaryAttackLockResetResponse& callback)); 1255 MOCK_METHOD3(DictionaryAttackLockResetSync, 1256 TPM_RC(const TPMI_RH_LOCKOUT& lock_handle, 1257 const std::string& lock_handle_name, 1258 AuthorizationDelegate* authorization_delegate)); 1259 MOCK_METHOD7(DictionaryAttackParameters, 1260 void(const TPMI_RH_LOCKOUT& lock_handle, 1261 const std::string& lock_handle_name, 1262 const UINT32& new_max_tries, 1263 const UINT32& new_recovery_time, 1264 const UINT32& lockout_recovery, 1265 AuthorizationDelegate* authorization_delegate, 1266 const DictionaryAttackParametersResponse& callback)); 1267 MOCK_METHOD6(DictionaryAttackParametersSync, 1268 TPM_RC(const TPMI_RH_LOCKOUT& lock_handle, 1269 const std::string& lock_handle_name, 1270 const UINT32& new_max_tries, 1271 const UINT32& new_recovery_time, 1272 const UINT32& lockout_recovery, 1273 AuthorizationDelegate* authorization_delegate)); 1274 MOCK_METHOD6(PP_Commands, 1275 void(const TPMI_RH_PLATFORM& auth, 1276 const std::string& auth_name, 1277 const TPML_CC& set_list, 1278 const TPML_CC& clear_list, 1279 AuthorizationDelegate* authorization_delegate, 1280 const PP_CommandsResponse& callback)); 1281 MOCK_METHOD5(PP_CommandsSync, 1282 TPM_RC(const TPMI_RH_PLATFORM& auth, 1283 const std::string& auth_name, 1284 const TPML_CC& set_list, 1285 const TPML_CC& clear_list, 1286 AuthorizationDelegate* authorization_delegate)); 1287 MOCK_METHOD5(SetAlgorithmSet, 1288 void(const TPMI_RH_PLATFORM& auth_handle, 1289 const std::string& auth_handle_name, 1290 const UINT32& algorithm_set, 1291 AuthorizationDelegate* authorization_delegate, 1292 const SetAlgorithmSetResponse& callback)); 1293 MOCK_METHOD4(SetAlgorithmSetSync, 1294 TPM_RC(const TPMI_RH_PLATFORM& auth_handle, 1295 const std::string& auth_handle_name, 1296 const UINT32& algorithm_set, 1297 AuthorizationDelegate* authorization_delegate)); 1298 MOCK_METHOD8(FieldUpgradeStart, 1299 void(const TPMI_RH_PLATFORM& authorization, 1300 const std::string& authorization_name, 1301 const TPMI_DH_OBJECT& key_handle, 1302 const std::string& key_handle_name, 1303 const TPM2B_DIGEST& fu_digest, 1304 const TPMT_SIGNATURE& manifest_signature, 1305 AuthorizationDelegate* authorization_delegate, 1306 const FieldUpgradeStartResponse& callback)); 1307 MOCK_METHOD7(FieldUpgradeStartSync, 1308 TPM_RC(const TPMI_RH_PLATFORM& authorization, 1309 const std::string& authorization_name, 1310 const TPMI_DH_OBJECT& key_handle, 1311 const std::string& key_handle_name, 1312 const TPM2B_DIGEST& fu_digest, 1313 const TPMT_SIGNATURE& manifest_signature, 1314 AuthorizationDelegate* authorization_delegate)); 1315 MOCK_METHOD3(FieldUpgradeData, 1316 void(const TPM2B_MAX_BUFFER& fu_data, 1317 AuthorizationDelegate* authorization_delegate, 1318 const FieldUpgradeDataResponse& callback)); 1319 MOCK_METHOD4(FieldUpgradeDataSync, 1320 TPM_RC(const TPM2B_MAX_BUFFER& fu_data, 1321 TPMT_HA* next_digest, 1322 TPMT_HA* first_digest, 1323 AuthorizationDelegate* authorization_delegate)); 1324 MOCK_METHOD3(FirmwareRead, 1325 void(const UINT32& sequence_number, 1326 AuthorizationDelegate* authorization_delegate, 1327 const FirmwareReadResponse& callback)); 1328 MOCK_METHOD3(FirmwareReadSync, 1329 TPM_RC(const UINT32& sequence_number, 1330 TPM2B_MAX_BUFFER* fu_data, 1331 AuthorizationDelegate* authorization_delegate)); 1332 MOCK_METHOD4(ContextSave, 1333 void(const TPMI_DH_CONTEXT& save_handle, 1334 const std::string& save_handle_name, 1335 AuthorizationDelegate* authorization_delegate, 1336 const ContextSaveResponse& callback)); 1337 MOCK_METHOD4(ContextSaveSync, 1338 TPM_RC(const TPMI_DH_CONTEXT& save_handle, 1339 const std::string& save_handle_name, 1340 TPMS_CONTEXT* context, 1341 AuthorizationDelegate* authorization_delegate)); 1342 MOCK_METHOD3(ContextLoad, 1343 void(const TPMS_CONTEXT& context, 1344 AuthorizationDelegate* authorization_delegate, 1345 const ContextLoadResponse& callback)); 1346 MOCK_METHOD3(ContextLoadSync, 1347 TPM_RC(const TPMS_CONTEXT& context, 1348 TPMI_DH_CONTEXT* loaded_handle, 1349 AuthorizationDelegate* authorization_delegate)); 1350 MOCK_METHOD3(FlushContext, 1351 void(const TPMI_DH_CONTEXT& flush_handle, 1352 AuthorizationDelegate* authorization_delegate, 1353 const FlushContextResponse& callback)); 1354 MOCK_METHOD2(FlushContextSync, 1355 TPM_RC(const TPMI_DH_CONTEXT& flush_handle, 1356 AuthorizationDelegate* authorization_delegate)); 1357 MOCK_METHOD7(EvictControl, 1358 void(const TPMI_RH_PROVISION& auth, 1359 const std::string& auth_name, 1360 const TPMI_DH_OBJECT& object_handle, 1361 const std::string& object_handle_name, 1362 const TPMI_DH_PERSISTENT& persistent_handle, 1363 AuthorizationDelegate* authorization_delegate, 1364 const EvictControlResponse& callback)); 1365 MOCK_METHOD6(EvictControlSync, 1366 TPM_RC(const TPMI_RH_PROVISION& auth, 1367 const std::string& auth_name, 1368 const TPMI_DH_OBJECT& object_handle, 1369 const std::string& object_handle_name, 1370 const TPMI_DH_PERSISTENT& persistent_handle, 1371 AuthorizationDelegate* authorization_delegate)); 1372 MOCK_METHOD2(ReadClock, 1373 void(AuthorizationDelegate* authorization_delegate, 1374 const ReadClockResponse& callback)); 1375 MOCK_METHOD2(ReadClockSync, 1376 TPM_RC(TPMS_TIME_INFO* current_time, 1377 AuthorizationDelegate* authorization_delegate)); 1378 MOCK_METHOD5(ClockSet, 1379 void(const TPMI_RH_PROVISION& auth, 1380 const std::string& auth_name, 1381 const UINT64& new_time, 1382 AuthorizationDelegate* authorization_delegate, 1383 const ClockSetResponse& callback)); 1384 MOCK_METHOD4(ClockSetSync, 1385 TPM_RC(const TPMI_RH_PROVISION& auth, 1386 const std::string& auth_name, 1387 const UINT64& new_time, 1388 AuthorizationDelegate* authorization_delegate)); 1389 MOCK_METHOD5(ClockRateAdjust, 1390 void(const TPMI_RH_PROVISION& auth, 1391 const std::string& auth_name, 1392 const TPM_CLOCK_ADJUST& rate_adjust, 1393 AuthorizationDelegate* authorization_delegate, 1394 const ClockRateAdjustResponse& callback)); 1395 MOCK_METHOD4(ClockRateAdjustSync, 1396 TPM_RC(const TPMI_RH_PROVISION& auth, 1397 const std::string& auth_name, 1398 const TPM_CLOCK_ADJUST& rate_adjust, 1399 AuthorizationDelegate* authorization_delegate)); 1400 MOCK_METHOD5(GetCapability, 1401 void(const TPM_CAP& capability, 1402 const UINT32& property, 1403 const UINT32& property_count, 1404 AuthorizationDelegate* authorization_delegate, 1405 const GetCapabilityResponse& callback)); 1406 MOCK_METHOD6(GetCapabilitySync, 1407 TPM_RC(const TPM_CAP& capability, 1408 const UINT32& property, 1409 const UINT32& property_count, 1410 TPMI_YES_NO* more_data, 1411 TPMS_CAPABILITY_DATA* capability_data, 1412 AuthorizationDelegate* authorization_delegate)); 1413 MOCK_METHOD3(TestParms, 1414 void(const TPMT_PUBLIC_PARMS& parameters, 1415 AuthorizationDelegate* authorization_delegate, 1416 const TestParmsResponse& callback)); 1417 MOCK_METHOD2(TestParmsSync, 1418 TPM_RC(const TPMT_PUBLIC_PARMS& parameters, 1419 AuthorizationDelegate* authorization_delegate)); 1420 MOCK_METHOD6(NV_DefineSpace, 1421 void(const TPMI_RH_PROVISION& auth_handle, 1422 const std::string& auth_handle_name, 1423 const TPM2B_AUTH& auth, 1424 const TPM2B_NV_PUBLIC& public_info, 1425 AuthorizationDelegate* authorization_delegate, 1426 const NV_DefineSpaceResponse& callback)); 1427 MOCK_METHOD5(NV_DefineSpaceSync, 1428 TPM_RC(const TPMI_RH_PROVISION& auth_handle, 1429 const std::string& auth_handle_name, 1430 const TPM2B_AUTH& auth, 1431 const TPM2B_NV_PUBLIC& public_info, 1432 AuthorizationDelegate* authorization_delegate)); 1433 MOCK_METHOD6(NV_UndefineSpace, 1434 void(const TPMI_RH_PROVISION& auth_handle, 1435 const std::string& auth_handle_name, 1436 const TPMI_RH_NV_INDEX& nv_index, 1437 const std::string& nv_index_name, 1438 AuthorizationDelegate* authorization_delegate, 1439 const NV_UndefineSpaceResponse& callback)); 1440 MOCK_METHOD5(NV_UndefineSpaceSync, 1441 TPM_RC(const TPMI_RH_PROVISION& auth_handle, 1442 const std::string& auth_handle_name, 1443 const TPMI_RH_NV_INDEX& nv_index, 1444 const std::string& nv_index_name, 1445 AuthorizationDelegate* authorization_delegate)); 1446 MOCK_METHOD6(NV_UndefineSpaceSpecial, 1447 void(const TPMI_RH_NV_INDEX& nv_index, 1448 const std::string& nv_index_name, 1449 const TPMI_RH_PLATFORM& platform, 1450 const std::string& platform_name, 1451 AuthorizationDelegate* authorization_delegate, 1452 const NV_UndefineSpaceSpecialResponse& callback)); 1453 MOCK_METHOD5(NV_UndefineSpaceSpecialSync, 1454 TPM_RC(const TPMI_RH_NV_INDEX& nv_index, 1455 const std::string& nv_index_name, 1456 const TPMI_RH_PLATFORM& platform, 1457 const std::string& platform_name, 1458 AuthorizationDelegate* authorization_delegate)); 1459 MOCK_METHOD4(NV_ReadPublic, 1460 void(const TPMI_RH_NV_INDEX& nv_index, 1461 const std::string& nv_index_name, 1462 AuthorizationDelegate* authorization_delegate, 1463 const NV_ReadPublicResponse& callback)); 1464 MOCK_METHOD5(NV_ReadPublicSync, 1465 TPM_RC(const TPMI_RH_NV_INDEX& nv_index, 1466 const std::string& nv_index_name, 1467 TPM2B_NV_PUBLIC* nv_public, 1468 TPM2B_NAME* nv_name, 1469 AuthorizationDelegate* authorization_delegate)); 1470 MOCK_METHOD8(NV_Write, 1471 void(const TPMI_RH_NV_AUTH& auth_handle, 1472 const std::string& auth_handle_name, 1473 const TPMI_RH_NV_INDEX& nv_index, 1474 const std::string& nv_index_name, 1475 const TPM2B_MAX_NV_BUFFER& data, 1476 const UINT16& offset, 1477 AuthorizationDelegate* authorization_delegate, 1478 const NV_WriteResponse& callback)); 1479 MOCK_METHOD7(NV_WriteSync, 1480 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1481 const std::string& auth_handle_name, 1482 const TPMI_RH_NV_INDEX& nv_index, 1483 const std::string& nv_index_name, 1484 const TPM2B_MAX_NV_BUFFER& data, 1485 const UINT16& offset, 1486 AuthorizationDelegate* authorization_delegate)); 1487 MOCK_METHOD6(NV_Increment, 1488 void(const TPMI_RH_NV_AUTH& auth_handle, 1489 const std::string& auth_handle_name, 1490 const TPMI_RH_NV_INDEX& nv_index, 1491 const std::string& nv_index_name, 1492 AuthorizationDelegate* authorization_delegate, 1493 const NV_IncrementResponse& callback)); 1494 MOCK_METHOD5(NV_IncrementSync, 1495 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1496 const std::string& auth_handle_name, 1497 const TPMI_RH_NV_INDEX& nv_index, 1498 const std::string& nv_index_name, 1499 AuthorizationDelegate* authorization_delegate)); 1500 MOCK_METHOD7(NV_Extend, 1501 void(const TPMI_RH_NV_AUTH& auth_handle, 1502 const std::string& auth_handle_name, 1503 const TPMI_RH_NV_INDEX& nv_index, 1504 const std::string& nv_index_name, 1505 const TPM2B_MAX_NV_BUFFER& data, 1506 AuthorizationDelegate* authorization_delegate, 1507 const NV_ExtendResponse& callback)); 1508 MOCK_METHOD6(NV_ExtendSync, 1509 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1510 const std::string& auth_handle_name, 1511 const TPMI_RH_NV_INDEX& nv_index, 1512 const std::string& nv_index_name, 1513 const TPM2B_MAX_NV_BUFFER& data, 1514 AuthorizationDelegate* authorization_delegate)); 1515 MOCK_METHOD7(NV_SetBits, 1516 void(const TPMI_RH_NV_AUTH& auth_handle, 1517 const std::string& auth_handle_name, 1518 const TPMI_RH_NV_INDEX& nv_index, 1519 const std::string& nv_index_name, 1520 const UINT64& bits, 1521 AuthorizationDelegate* authorization_delegate, 1522 const NV_SetBitsResponse& callback)); 1523 MOCK_METHOD6(NV_SetBitsSync, 1524 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1525 const std::string& auth_handle_name, 1526 const TPMI_RH_NV_INDEX& nv_index, 1527 const std::string& nv_index_name, 1528 const UINT64& bits, 1529 AuthorizationDelegate* authorization_delegate)); 1530 MOCK_METHOD6(NV_WriteLock, 1531 void(const TPMI_RH_NV_AUTH& auth_handle, 1532 const std::string& auth_handle_name, 1533 const TPMI_RH_NV_INDEX& nv_index, 1534 const std::string& nv_index_name, 1535 AuthorizationDelegate* authorization_delegate, 1536 const NV_WriteLockResponse& callback)); 1537 MOCK_METHOD5(NV_WriteLockSync, 1538 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1539 const std::string& auth_handle_name, 1540 const TPMI_RH_NV_INDEX& nv_index, 1541 const std::string& nv_index_name, 1542 AuthorizationDelegate* authorization_delegate)); 1543 MOCK_METHOD4(NV_GlobalWriteLock, 1544 void(const TPMI_RH_PROVISION& auth_handle, 1545 const std::string& auth_handle_name, 1546 AuthorizationDelegate* authorization_delegate, 1547 const NV_GlobalWriteLockResponse& callback)); 1548 MOCK_METHOD3(NV_GlobalWriteLockSync, 1549 TPM_RC(const TPMI_RH_PROVISION& auth_handle, 1550 const std::string& auth_handle_name, 1551 AuthorizationDelegate* authorization_delegate)); 1552 MOCK_METHOD8(NV_Read, 1553 void(const TPMI_RH_NV_AUTH& auth_handle, 1554 const std::string& auth_handle_name, 1555 const TPMI_RH_NV_INDEX& nv_index, 1556 const std::string& nv_index_name, 1557 const UINT16& size, 1558 const UINT16& offset, 1559 AuthorizationDelegate* authorization_delegate, 1560 const NV_ReadResponse& callback)); 1561 MOCK_METHOD8(NV_ReadSync, 1562 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1563 const std::string& auth_handle_name, 1564 const TPMI_RH_NV_INDEX& nv_index, 1565 const std::string& nv_index_name, 1566 const UINT16& size, 1567 const UINT16& offset, 1568 TPM2B_MAX_NV_BUFFER* data, 1569 AuthorizationDelegate* authorization_delegate)); 1570 MOCK_METHOD6(NV_ReadLock, 1571 void(const TPMI_RH_NV_AUTH& auth_handle, 1572 const std::string& auth_handle_name, 1573 const TPMI_RH_NV_INDEX& nv_index, 1574 const std::string& nv_index_name, 1575 AuthorizationDelegate* authorization_delegate, 1576 const NV_ReadLockResponse& callback)); 1577 MOCK_METHOD5(NV_ReadLockSync, 1578 TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, 1579 const std::string& auth_handle_name, 1580 const TPMI_RH_NV_INDEX& nv_index, 1581 const std::string& nv_index_name, 1582 AuthorizationDelegate* authorization_delegate)); 1583 MOCK_METHOD5(NV_ChangeAuth, 1584 void(const TPMI_RH_NV_INDEX& nv_index, 1585 const std::string& nv_index_name, 1586 const TPM2B_AUTH& new_auth, 1587 AuthorizationDelegate* authorization_delegate, 1588 const NV_ChangeAuthResponse& callback)); 1589 MOCK_METHOD4(NV_ChangeAuthSync, 1590 TPM_RC(const TPMI_RH_NV_INDEX& nv_index, 1591 const std::string& nv_index_name, 1592 const TPM2B_AUTH& new_auth, 1593 AuthorizationDelegate* authorization_delegate)); 1594 // Too many args to mock, forward to *Short version. 1595 void NV_Certify(const TPMI_DH_OBJECT& sign_handle, 1596 const std::string& sign_handle_name, 1597 const TPMI_RH_NV_AUTH& auth_handle, 1598 const std::string& auth_handle_name, 1599 const TPMI_RH_NV_INDEX& nv_index, 1600 const std::string& nv_index_name, 1601 const TPM2B_DATA& qualifying_data, 1602 const TPMT_SIG_SCHEME& in_scheme, 1603 const UINT16& size, 1604 const UINT16& offset, 1605 AuthorizationDelegate* authorization_delegate, 1606 const NV_CertifyResponse& callback) override; 1607 MOCK_METHOD9(NV_CertifyShort, 1608 void(const TPMI_DH_OBJECT& sign_handle, 1609 const TPMI_RH_NV_AUTH& auth_handle, 1610 const TPMI_RH_NV_INDEX& nv_index, 1611 const TPM2B_DATA& qualifying_data, 1612 const TPMT_SIG_SCHEME& in_scheme, 1613 const UINT16& size, 1614 const UINT16& offset, 1615 AuthorizationDelegate* authorization_delegate, 1616 const NV_CertifyResponse& callback)); 1617 // Too many args to mock, forward to *Short version. 1618 TPM_RC NV_CertifySync( 1619 const TPMI_DH_OBJECT& sign_handle, 1620 const std::string& sign_handle_name, 1621 const TPMI_RH_NV_AUTH& auth_handle, 1622 const std::string& auth_handle_name, 1623 const TPMI_RH_NV_INDEX& nv_index, 1624 const std::string& nv_index_name, 1625 const TPM2B_DATA& qualifying_data, 1626 const TPMT_SIG_SCHEME& in_scheme, 1627 const UINT16& size, 1628 const UINT16& offset, 1629 TPM2B_ATTEST* certify_info, 1630 TPMT_SIGNATURE* signature, 1631 AuthorizationDelegate* authorization_delegate) override; 1632 MOCK_METHOD10(NV_CertifySyncShort, 1633 TPM_RC(const TPMI_DH_OBJECT& sign_handle, 1634 const TPMI_RH_NV_AUTH& auth_handle, 1635 const TPMI_RH_NV_INDEX& nv_index, 1636 const TPM2B_DATA& qualifying_data, 1637 const TPMT_SIG_SCHEME& in_scheme, 1638 const UINT16& size, 1639 const UINT16& offset, 1640 TPM2B_ATTEST* certify_info, 1641 TPMT_SIGNATURE* signature, 1642 AuthorizationDelegate* authorization_delegate)); 1643}; 1644 1645} // namespace trunks 1646 1647#endif // TRUNKS_MOCK_TPM_H_ 1648