| // Copyright 2014 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef TRUNKS_MOCK_TPM_H_ |
| #define TRUNKS_MOCK_TPM_H_ |
| |
| #include <string> |
| #include <vector> |
| |
| #include <base/callback.h> |
| #include <gmock/gmock.h> |
| |
| #include "trunks/tpm_generated.h" |
| |
| namespace trunks { |
| |
| class MockTpm : public Tpm { |
| public: |
| explicit MockTpm(CommandTransceiver* transceiver = nullptr); |
| ~MockTpm() override; |
| |
| MOCK_METHOD0(get_transceiver, CommandTransceiver*()); |
| MOCK_METHOD3(Startup, |
| void(const TPM_SU& startup_type, |
| AuthorizationDelegate* authorization_delegate, |
| StartupResponse callback)); |
| MOCK_METHOD2(StartupSync, |
| TPM_RC(const TPM_SU& startup_type, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(Shutdown, |
| void(const TPM_SU& shutdown_type, |
| AuthorizationDelegate* authorization_delegate, |
| ShutdownResponse callback)); |
| MOCK_METHOD2(ShutdownSync, |
| TPM_RC(const TPM_SU& shutdown_type, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(SelfTest, |
| void(const TPMI_YES_NO& full_test, |
| AuthorizationDelegate* authorization_delegate, |
| SelfTestResponse callback)); |
| MOCK_METHOD2(SelfTestSync, |
| TPM_RC(const TPMI_YES_NO& full_test, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(IncrementalSelfTest, |
| void(const TPML_ALG& to_test, |
| AuthorizationDelegate* authorization_delegate, |
| IncrementalSelfTestResponse callback)); |
| MOCK_METHOD3(IncrementalSelfTestSync, |
| TPM_RC(const TPML_ALG& to_test, |
| TPML_ALG* to_do_list, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD2(GetTestResult, |
| void(AuthorizationDelegate* authorization_delegate, |
| GetTestResultResponse callback)); |
| MOCK_METHOD3(GetTestResultSync, |
| TPM_RC(TPM2B_MAX_BUFFER* out_data, |
| TPM_RC* test_result, |
| AuthorizationDelegate* authorization_delegate)); |
| // Too many args to mock, forward to *Short version. |
| void StartAuthSession(const TPMI_DH_OBJECT& tpm_key, |
| const std::string& tpm_key_name, |
| const TPMI_DH_ENTITY& bind, |
| const std::string& bind_name, |
| const TPM2B_NONCE& nonce_caller, |
| const TPM2B_ENCRYPTED_SECRET& encrypted_salt, |
| const TPM_SE& session_type, |
| const TPMT_SYM_DEF& symmetric, |
| const TPMI_ALG_HASH& auth_hash, |
| AuthorizationDelegate* authorization_delegate, |
| StartAuthSessionResponse callback) override; |
| MOCK_METHOD9(StartAuthSessionShort, |
| void(const TPMI_DH_OBJECT& tpm_key, |
| const TPMI_DH_ENTITY& bind, |
| const TPM2B_NONCE& nonce_caller, |
| const TPM2B_ENCRYPTED_SECRET& encrypted_salt, |
| const TPM_SE& session_type, |
| const TPMT_SYM_DEF& symmetric, |
| const TPMI_ALG_HASH& auth_hash, |
| AuthorizationDelegate* authorization_delegate, |
| StartAuthSessionResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC StartAuthSessionSync( |
| const TPMI_DH_OBJECT& tpm_key, |
| const std::string& tpm_key_name, |
| const TPMI_DH_ENTITY& bind, |
| const std::string& bind_name, |
| const TPM2B_NONCE& nonce_caller, |
| const TPM2B_ENCRYPTED_SECRET& encrypted_salt, |
| const TPM_SE& session_type, |
| const TPMT_SYM_DEF& symmetric, |
| const TPMI_ALG_HASH& auth_hash, |
| TPMI_SH_AUTH_SESSION* session_handle, |
| TPM2B_NONCE* nonce_tpm, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD10(StartAuthSessionSyncShort, |
| TPM_RC(const TPMI_DH_OBJECT& tpm_key, |
| const TPMI_DH_ENTITY& bind, |
| const TPM2B_NONCE& nonce_caller, |
| const TPM2B_ENCRYPTED_SECRET& encrypted_salt, |
| const TPM_SE& session_type, |
| const TPMT_SYM_DEF& symmetric, |
| const TPMI_ALG_HASH& auth_hash, |
| TPMI_SH_AUTH_SESSION* session_handle, |
| TPM2B_NONCE* nonce_tpm, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(PolicyRestart, |
| void(const TPMI_SH_POLICY& session_handle, |
| const std::string& session_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyRestartResponse callback)); |
| MOCK_METHOD3(PolicyRestartSync, |
| TPM_RC(const TPMI_SH_POLICY& session_handle, |
| const std::string& session_handle_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(Create, |
| void(const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_SENSITIVE_CREATE& in_sensitive, |
| const TPM2B_PUBLIC& in_public, |
| const TPM2B_DATA& outside_info, |
| const TPML_PCR_SELECTION& creation_pcr, |
| AuthorizationDelegate* authorization_delegate, |
| CreateResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC CreateSync(const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_SENSITIVE_CREATE& in_sensitive, |
| const TPM2B_PUBLIC& in_public, |
| const TPM2B_DATA& outside_info, |
| const TPML_PCR_SELECTION& creation_pcr, |
| TPM2B_PRIVATE* out_private, |
| TPM2B_PUBLIC* out_public, |
| TPM2B_CREATION_DATA* creation_data, |
| TPM2B_DIGEST* creation_hash, |
| TPMT_TK_CREATION* creation_ticket, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD10(CreateSyncShort, |
| TPM_RC(const TPMI_DH_OBJECT& parent_handle, |
| const TPM2B_SENSITIVE_CREATE& in_sensitive, |
| const TPM2B_PUBLIC& in_public, |
| const TPML_PCR_SELECTION& creation_pcr, |
| TPM2B_PRIVATE* out_private, |
| TPM2B_PUBLIC* out_public, |
| TPM2B_CREATION_DATA* creation_data, |
| TPM2B_DIGEST* creation_hash, |
| TPMT_TK_CREATION* creation_ticket, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(Load, |
| void(const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_PRIVATE& in_private, |
| const TPM2B_PUBLIC& in_public, |
| AuthorizationDelegate* authorization_delegate, |
| LoadResponse callback)); |
| MOCK_METHOD7(LoadSync, |
| TPM_RC(const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_PRIVATE& in_private, |
| const TPM2B_PUBLIC& in_public, |
| TPM_HANDLE* object_handle, |
| TPM2B_NAME* name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(LoadExternal, |
| void(const TPM2B_SENSITIVE& in_private, |
| const TPM2B_PUBLIC& in_public, |
| const TPMI_RH_HIERARCHY& hierarchy, |
| AuthorizationDelegate* authorization_delegate, |
| LoadExternalResponse callback)); |
| MOCK_METHOD6(LoadExternalSync, |
| TPM_RC(const TPM2B_SENSITIVE& in_private, |
| const TPM2B_PUBLIC& in_public, |
| const TPMI_RH_HIERARCHY& hierarchy, |
| TPM_HANDLE* object_handle, |
| TPM2B_NAME* name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(ReadPublic, |
| void(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| ReadPublicResponse callback)); |
| MOCK_METHOD6(ReadPublicSync, |
| TPM_RC(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| TPM2B_PUBLIC* out_public, |
| TPM2B_NAME* name, |
| TPM2B_NAME* qualified_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(ActivateCredential, |
| void(const TPMI_DH_OBJECT& activate_handle, |
| const std::string& activate_handle_name, |
| const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_ID_OBJECT& credential_blob, |
| const TPM2B_ENCRYPTED_SECRET& secret, |
| AuthorizationDelegate* authorization_delegate, |
| ActivateCredentialResponse callback)); |
| MOCK_METHOD8(ActivateCredentialSync, |
| TPM_RC(const TPMI_DH_OBJECT& activate_handle, |
| const std::string& activate_handle_name, |
| const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_ID_OBJECT& credential_blob, |
| const TPM2B_ENCRYPTED_SECRET& secret, |
| TPM2B_DIGEST* cert_info, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(MakeCredential, |
| void(const TPMI_DH_OBJECT& handle, |
| const std::string& handle_name, |
| const TPM2B_DIGEST& credential, |
| const TPM2B_NAME& object_name, |
| AuthorizationDelegate* authorization_delegate, |
| MakeCredentialResponse callback)); |
| MOCK_METHOD7(MakeCredentialSync, |
| TPM_RC(const TPMI_DH_OBJECT& handle, |
| const std::string& handle_name, |
| const TPM2B_DIGEST& credential, |
| const TPM2B_NAME& object_name, |
| TPM2B_ID_OBJECT* credential_blob, |
| TPM2B_ENCRYPTED_SECRET* secret, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(Unseal, |
| void(const TPMI_DH_OBJECT& item_handle, |
| const std::string& item_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| UnsealResponse callback)); |
| MOCK_METHOD4(UnsealSync, |
| TPM_RC(const TPMI_DH_OBJECT& item_handle, |
| const std::string& item_handle_name, |
| TPM2B_SENSITIVE_DATA* out_data, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(ObjectChangeAuth, |
| void(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_AUTH& new_auth, |
| AuthorizationDelegate* authorization_delegate, |
| ObjectChangeAuthResponse callback)); |
| MOCK_METHOD7(ObjectChangeAuthSync, |
| TPM_RC(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_AUTH& new_auth, |
| TPM2B_PRIVATE* out_private, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(Duplicate, |
| void(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_OBJECT& new_parent_handle, |
| const std::string& new_parent_handle_name, |
| const TPM2B_DATA& encryption_key_in, |
| const TPMT_SYM_DEF_OBJECT& symmetric_alg, |
| AuthorizationDelegate* authorization_delegate, |
| DuplicateResponse callback)); |
| MOCK_METHOD10(DuplicateSync, |
| TPM_RC(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_OBJECT& new_parent_handle, |
| const std::string& new_parent_handle_name, |
| const TPM2B_DATA& encryption_key_in, |
| const TPMT_SYM_DEF_OBJECT& symmetric_alg, |
| TPM2B_DATA* encryption_key_out, |
| TPM2B_PRIVATE* duplicate, |
| TPM2B_ENCRYPTED_SECRET* out_sym_seed, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD9(Rewrap, |
| void(const TPMI_DH_OBJECT& old_parent, |
| const std::string& old_parent_name, |
| const TPMI_DH_OBJECT& new_parent, |
| const std::string& new_parent_name, |
| const TPM2B_PRIVATE& in_duplicate, |
| const TPM2B_NAME& name, |
| const TPM2B_ENCRYPTED_SECRET& in_sym_seed, |
| AuthorizationDelegate* authorization_delegate, |
| RewrapResponse callback)); |
| MOCK_METHOD10(RewrapSync, |
| TPM_RC(const TPMI_DH_OBJECT& old_parent, |
| const std::string& old_parent_name, |
| const TPMI_DH_OBJECT& new_parent, |
| const std::string& new_parent_name, |
| const TPM2B_PRIVATE& in_duplicate, |
| const TPM2B_NAME& name, |
| const TPM2B_ENCRYPTED_SECRET& in_sym_seed, |
| TPM2B_PRIVATE* out_duplicate, |
| TPM2B_ENCRYPTED_SECRET* out_sym_seed, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD9(Import, |
| void(const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_DATA& encryption_key, |
| const TPM2B_PUBLIC& object_public, |
| const TPM2B_PRIVATE& duplicate, |
| const TPM2B_ENCRYPTED_SECRET& in_sym_seed, |
| const TPMT_SYM_DEF_OBJECT& symmetric_alg, |
| AuthorizationDelegate* authorization_delegate, |
| ImportResponse callback)); |
| MOCK_METHOD9(ImportSync, |
| TPM_RC(const TPMI_DH_OBJECT& parent_handle, |
| const std::string& parent_handle_name, |
| const TPM2B_DATA& encryption_key, |
| const TPM2B_PUBLIC& object_public, |
| const TPM2B_PRIVATE& duplicate, |
| const TPM2B_ENCRYPTED_SECRET& in_sym_seed, |
| const TPMT_SYM_DEF_OBJECT& symmetric_alg, |
| TPM2B_PRIVATE* out_private, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(RSA_Encrypt, |
| void(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_PUBLIC_KEY_RSA& message, |
| const TPMT_RSA_DECRYPT& in_scheme, |
| const TPM2B_DATA& label, |
| AuthorizationDelegate* authorization_delegate, |
| RSA_EncryptResponse callback)); |
| MOCK_METHOD7(RSA_EncryptSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_PUBLIC_KEY_RSA& message, |
| const TPMT_RSA_DECRYPT& in_scheme, |
| const TPM2B_DATA& label, |
| TPM2B_PUBLIC_KEY_RSA* out_data, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(RSA_Decrypt, |
| void(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_PUBLIC_KEY_RSA& cipher_text, |
| const TPMT_RSA_DECRYPT& in_scheme, |
| const TPM2B_DATA& label, |
| AuthorizationDelegate* authorization_delegate, |
| RSA_DecryptResponse callback)); |
| MOCK_METHOD7(RSA_DecryptSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_PUBLIC_KEY_RSA& cipher_text, |
| const TPMT_RSA_DECRYPT& in_scheme, |
| const TPM2B_DATA& label, |
| TPM2B_PUBLIC_KEY_RSA* message, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(ECDH_KeyGen, |
| void(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| ECDH_KeyGenResponse callback)); |
| MOCK_METHOD5(ECDH_KeyGenSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| TPM2B_ECC_POINT* z_point, |
| TPM2B_ECC_POINT* pub_point, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(ECDH_ZGen, |
| void(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_ECC_POINT& in_point, |
| AuthorizationDelegate* authorization_delegate, |
| ECDH_ZGenResponse callback)); |
| MOCK_METHOD5(ECDH_ZGenSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_ECC_POINT& in_point, |
| TPM2B_ECC_POINT* out_point, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(ECC_Parameters, |
| void(const TPMI_ECC_CURVE& curve_id, |
| AuthorizationDelegate* authorization_delegate, |
| ECC_ParametersResponse callback)); |
| MOCK_METHOD3(ECC_ParametersSync, |
| TPM_RC(const TPMI_ECC_CURVE& curve_id, |
| TPMS_ALGORITHM_DETAIL_ECC* parameters, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(ZGen_2Phase, |
| void(const TPMI_DH_OBJECT& key_a, |
| const std::string& key_a_name, |
| const TPM2B_ECC_POINT& in_qs_b, |
| const TPM2B_ECC_POINT& in_qe_b, |
| const TPMI_ECC_KEY_EXCHANGE& in_scheme, |
| const UINT16& counter, |
| AuthorizationDelegate* authorization_delegate, |
| ZGen_2PhaseResponse callback)); |
| MOCK_METHOD9(ZGen_2PhaseSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_a, |
| const std::string& key_a_name, |
| const TPM2B_ECC_POINT& in_qs_b, |
| const TPM2B_ECC_POINT& in_qe_b, |
| const TPMI_ECC_KEY_EXCHANGE& in_scheme, |
| const UINT16& counter, |
| TPM2B_ECC_POINT* out_z1, |
| TPM2B_ECC_POINT* out_z2, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(EncryptDecrypt, |
| void(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPMI_YES_NO& decrypt, |
| const TPMI_ALG_SYM_MODE& mode, |
| const TPM2B_IV& iv_in, |
| const TPM2B_MAX_BUFFER& in_data, |
| AuthorizationDelegate* authorization_delegate, |
| EncryptDecryptResponse callback)); |
| MOCK_METHOD9(EncryptDecryptSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPMI_YES_NO& decrypt, |
| const TPMI_ALG_SYM_MODE& mode, |
| const TPM2B_IV& iv_in, |
| const TPM2B_MAX_BUFFER& in_data, |
| TPM2B_MAX_BUFFER* out_data, |
| TPM2B_IV* iv_out, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(Hash, |
| void(const TPM2B_MAX_BUFFER& data, |
| const TPMI_ALG_HASH& hash_alg, |
| const TPMI_RH_HIERARCHY& hierarchy, |
| AuthorizationDelegate* authorization_delegate, |
| HashResponse callback)); |
| MOCK_METHOD6(HashSync, |
| TPM_RC(const TPM2B_MAX_BUFFER& data, |
| const TPMI_ALG_HASH& hash_alg, |
| const TPMI_RH_HIERARCHY& hierarchy, |
| TPM2B_DIGEST* out_hash, |
| TPMT_TK_HASHCHECK* validation, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(HMAC, |
| void(const TPMI_DH_OBJECT& handle, |
| const std::string& handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| const TPMI_ALG_HASH& hash_alg, |
| AuthorizationDelegate* authorization_delegate, |
| HMACResponse callback)); |
| MOCK_METHOD6(HMACSync, |
| TPM_RC(const TPMI_DH_OBJECT& handle, |
| const std::string& handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| const TPMI_ALG_HASH& hash_alg, |
| TPM2B_DIGEST* out_hmac, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(GetRandom, |
| void(const UINT16& bytes_requested, |
| AuthorizationDelegate* authorization_delegate, |
| GetRandomResponse callback)); |
| MOCK_METHOD3(GetRandomSync, |
| TPM_RC(const UINT16& bytes_requested, |
| TPM2B_DIGEST* random_bytes, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(StirRandom, |
| void(const TPM2B_SENSITIVE_DATA& in_data, |
| AuthorizationDelegate* authorization_delegate, |
| StirRandomResponse callback)); |
| MOCK_METHOD2(StirRandomSync, |
| TPM_RC(const TPM2B_SENSITIVE_DATA& in_data, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(HMAC_Start, |
| void(const TPMI_DH_OBJECT& handle, |
| const std::string& handle_name, |
| const TPM2B_AUTH& auth, |
| const TPMI_ALG_HASH& hash_alg, |
| AuthorizationDelegate* authorization_delegate, |
| HMAC_StartResponse callback)); |
| MOCK_METHOD6(HMAC_StartSync, |
| TPM_RC(const TPMI_DH_OBJECT& handle, |
| const std::string& handle_name, |
| const TPM2B_AUTH& auth, |
| const TPMI_ALG_HASH& hash_alg, |
| TPMI_DH_OBJECT* sequence_handle, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(HashSequenceStart, |
| void(const TPM2B_AUTH& auth, |
| const TPMI_ALG_HASH& hash_alg, |
| AuthorizationDelegate* authorization_delegate, |
| HashSequenceStartResponse callback)); |
| MOCK_METHOD4(HashSequenceStartSync, |
| TPM_RC(const TPM2B_AUTH& auth, |
| const TPMI_ALG_HASH& hash_alg, |
| TPMI_DH_OBJECT* sequence_handle, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(SequenceUpdate, |
| void(const TPMI_DH_OBJECT& sequence_handle, |
| const std::string& sequence_handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| AuthorizationDelegate* authorization_delegate, |
| SequenceUpdateResponse callback)); |
| MOCK_METHOD4(SequenceUpdateSync, |
| TPM_RC(const TPMI_DH_OBJECT& sequence_handle, |
| const std::string& sequence_handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(SequenceComplete, |
| void(const TPMI_DH_OBJECT& sequence_handle, |
| const std::string& sequence_handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| const TPMI_RH_HIERARCHY& hierarchy, |
| AuthorizationDelegate* authorization_delegate, |
| SequenceCompleteResponse callback)); |
| MOCK_METHOD7(SequenceCompleteSync, |
| TPM_RC(const TPMI_DH_OBJECT& sequence_handle, |
| const std::string& sequence_handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| const TPMI_RH_HIERARCHY& hierarchy, |
| TPM2B_DIGEST* result, |
| TPMT_TK_HASHCHECK* validation, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(EventSequenceComplete, |
| void(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPMI_DH_OBJECT& sequence_handle, |
| const std::string& sequence_handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| AuthorizationDelegate* authorization_delegate, |
| EventSequenceCompleteResponse callback)); |
| MOCK_METHOD7(EventSequenceCompleteSync, |
| TPM_RC(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPMI_DH_OBJECT& sequence_handle, |
| const std::string& sequence_handle_name, |
| const TPM2B_MAX_BUFFER& buffer, |
| TPML_DIGEST_VALUES* results, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(Certify, |
| void(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| AuthorizationDelegate* authorization_delegate, |
| CertifyResponse callback)); |
| MOCK_METHOD9(CertifySync, |
| TPM_RC(const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| TPM2B_ATTEST* certify_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD10(CertifyCreation, |
| void(const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPM2B_DIGEST& creation_hash, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const TPMT_TK_CREATION& creation_ticket, |
| AuthorizationDelegate* authorization_delegate, |
| CertifyCreationResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC CertifyCreationSync( |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPM2B_DIGEST& creation_hash, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const TPMT_TK_CREATION& creation_ticket, |
| TPM2B_ATTEST* certify_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD9(CertifyCreationSyncShort, |
| TPM_RC(const TPMI_DH_OBJECT& sign_handle, |
| const TPMI_DH_OBJECT& object_handle, |
| const TPM2B_DATA& qualifying_data, |
| const TPM2B_DIGEST& creation_hash, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const TPMT_TK_CREATION& creation_ticket, |
| TPM2B_ATTEST* certify_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(Quote, |
| void(const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const TPML_PCR_SELECTION& pcrselect, |
| AuthorizationDelegate* authorization_delegate, |
| QuoteResponse callback)); |
| MOCK_METHOD8(QuoteSync, |
| TPM_RC(const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const TPML_PCR_SELECTION& pcrselect, |
| TPM2B_ATTEST* quoted, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD10(GetSessionAuditDigest, |
| void(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, |
| const std::string& privacy_admin_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPMI_SH_HMAC& session_handle, |
| const std::string& session_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| AuthorizationDelegate* authorization_delegate, |
| GetSessionAuditDigestResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC GetSessionAuditDigestSync( |
| const TPMI_RH_ENDORSEMENT& privacy_admin_handle, |
| const std::string& privacy_admin_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPMI_SH_HMAC& session_handle, |
| const std::string& session_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| TPM2B_ATTEST* audit_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD8(GetSessionAuditDigestSyncShort, |
| TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, |
| const TPMI_DH_OBJECT& sign_handle, |
| const TPMI_SH_HMAC& session_handle, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| TPM2B_ATTEST* audit_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(GetCommandAuditDigest, |
| void(const TPMI_RH_ENDORSEMENT& privacy_handle, |
| const std::string& privacy_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| AuthorizationDelegate* authorization_delegate, |
| GetCommandAuditDigestResponse callback)); |
| MOCK_METHOD9(GetCommandAuditDigestSync, |
| TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_handle, |
| const std::string& privacy_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| TPM2B_ATTEST* audit_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(GetTime, |
| void(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, |
| const std::string& privacy_admin_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| AuthorizationDelegate* authorization_delegate, |
| GetTimeResponse callback)); |
| MOCK_METHOD9(GetTimeSync, |
| TPM_RC(const TPMI_RH_ENDORSEMENT& privacy_admin_handle, |
| const std::string& privacy_admin_handle_name, |
| const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| TPM2B_ATTEST* time_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(Commit, |
| void(const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const UINT32& param_size, |
| const TPM2B_ECC_POINT& p1, |
| const TPM2B_SENSITIVE_DATA& s2, |
| const TPM2B_ECC_PARAMETER& y2, |
| AuthorizationDelegate* authorization_delegate, |
| CommitResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC CommitSync(const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const UINT32& param_size, |
| const TPM2B_ECC_POINT& p1, |
| const TPM2B_SENSITIVE_DATA& s2, |
| const TPM2B_ECC_PARAMETER& y2, |
| UINT32* param_size_out, |
| TPM2B_ECC_POINT* k, |
| TPM2B_ECC_POINT* l, |
| TPM2B_ECC_POINT* e, |
| UINT16* counter, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD10(CommitSyncShort, |
| TPM_RC(const TPMI_DH_OBJECT& sign_handle, |
| const UINT32& param_size, |
| const TPM2B_ECC_POINT& p1, |
| const TPM2B_ECC_PARAMETER& y2, |
| UINT32* param_size_out, |
| TPM2B_ECC_POINT* k, |
| TPM2B_ECC_POINT* l, |
| TPM2B_ECC_POINT* e, |
| UINT16* counter, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(EC_Ephemeral, |
| void(const UINT32& param_size, |
| const TPMI_ECC_CURVE& curve_id, |
| AuthorizationDelegate* authorization_delegate, |
| EC_EphemeralResponse callback)); |
| MOCK_METHOD6(EC_EphemeralSync, |
| TPM_RC(const UINT32& param_size, |
| const TPMI_ECC_CURVE& curve_id, |
| UINT32* param_size_out, |
| TPM2B_ECC_POINT* q, |
| UINT16* counter, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(VerifySignature, |
| void(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_DIGEST& digest, |
| const TPMT_SIGNATURE& signature, |
| AuthorizationDelegate* authorization_delegate, |
| VerifySignatureResponse callback)); |
| MOCK_METHOD6(VerifySignatureSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_DIGEST& digest, |
| const TPMT_SIGNATURE& signature, |
| TPMT_TK_VERIFIED* validation, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(Sign, |
| void(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_DIGEST& digest, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const TPMT_TK_HASHCHECK& validation, |
| AuthorizationDelegate* authorization_delegate, |
| SignResponse callback)); |
| MOCK_METHOD7(SignSync, |
| TPM_RC(const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_DIGEST& digest, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const TPMT_TK_HASHCHECK& validation, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(SetCommandCodeAuditStatus, |
| void(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const TPMI_ALG_HASH& audit_alg, |
| const TPML_CC& set_list, |
| const TPML_CC& clear_list, |
| AuthorizationDelegate* authorization_delegate, |
| SetCommandCodeAuditStatusResponse callback)); |
| MOCK_METHOD6(SetCommandCodeAuditStatusSync, |
| TPM_RC(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const TPMI_ALG_HASH& audit_alg, |
| const TPML_CC& set_list, |
| const TPML_CC& clear_list, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PCR_Extend, |
| void(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPML_DIGEST_VALUES& digests, |
| AuthorizationDelegate* authorization_delegate, |
| PCR_ExtendResponse callback)); |
| MOCK_METHOD4(PCR_ExtendSync, |
| TPM_RC(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPML_DIGEST_VALUES& digests, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PCR_Event, |
| void(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPM2B_EVENT& event_data, |
| AuthorizationDelegate* authorization_delegate, |
| PCR_EventResponse callback)); |
| MOCK_METHOD5(PCR_EventSync, |
| TPM_RC(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPM2B_EVENT& event_data, |
| TPML_DIGEST_VALUES* digests, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(PCR_Read, |
| void(const TPML_PCR_SELECTION& pcr_selection_in, |
| AuthorizationDelegate* authorization_delegate, |
| PCR_ReadResponse callback)); |
| MOCK_METHOD5(PCR_ReadSync, |
| TPM_RC(const TPML_PCR_SELECTION& pcr_selection_in, |
| UINT32* pcr_update_counter, |
| TPML_PCR_SELECTION* pcr_selection_out, |
| TPML_DIGEST* pcr_values, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PCR_Allocate, |
| void(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| const TPML_PCR_SELECTION& pcr_allocation, |
| AuthorizationDelegate* authorization_delegate, |
| PCR_AllocateResponse callback)); |
| MOCK_METHOD8(PCR_AllocateSync, |
| TPM_RC(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| const TPML_PCR_SELECTION& pcr_allocation, |
| TPMI_YES_NO* allocation_success, |
| UINT32* max_pcr, |
| UINT32* size_needed, |
| UINT32* size_available, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(PCR_SetAuthPolicy, |
| void(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_DH_PCR& pcr_num, |
| const std::string& pcr_num_name, |
| const TPM2B_DIGEST& auth_policy, |
| const TPMI_ALG_HASH& policy_digest, |
| AuthorizationDelegate* authorization_delegate, |
| PCR_SetAuthPolicyResponse callback)); |
| MOCK_METHOD7(PCR_SetAuthPolicySync, |
| TPM_RC(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_DH_PCR& pcr_num, |
| const std::string& pcr_num_name, |
| const TPM2B_DIGEST& auth_policy, |
| const TPMI_ALG_HASH& policy_digest, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PCR_SetAuthValue, |
| void(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPM2B_DIGEST& auth, |
| AuthorizationDelegate* authorization_delegate, |
| PCR_SetAuthValueResponse callback)); |
| MOCK_METHOD4(PCR_SetAuthValueSync, |
| TPM_RC(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| const TPM2B_DIGEST& auth, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(PCR_Reset, |
| void(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| PCR_ResetResponse callback)); |
| MOCK_METHOD3(PCR_ResetSync, |
| TPM_RC(const TPMI_DH_PCR& pcr_handle, |
| const std::string& pcr_handle_name, |
| AuthorizationDelegate* authorization_delegate)); |
| // Too many args to mock, forward to *Short version. |
| void PolicySigned(const TPMI_DH_OBJECT& auth_object, |
| const std::string& auth_object_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_NONCE& nonce_tpm, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const INT32& expiration, |
| const TPMT_SIGNATURE& auth, |
| AuthorizationDelegate* authorization_delegate, |
| PolicySignedResponse callback) override; |
| MOCK_METHOD9(PolicySignedShort, |
| void(const TPMI_DH_OBJECT& auth_object, |
| const TPMI_SH_POLICY& policy_session, |
| const TPM2B_NONCE& nonce_tpm, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const INT32& expiration, |
| const TPMT_SIGNATURE& auth, |
| AuthorizationDelegate* authorization_delegate, |
| PolicySignedResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC PolicySignedSync( |
| const TPMI_DH_OBJECT& auth_object, |
| const std::string& auth_object_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_NONCE& nonce_tpm, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const INT32& expiration, |
| const TPMT_SIGNATURE& auth, |
| TPM2B_TIMEOUT* timeout, |
| TPMT_TK_AUTH* policy_ticket, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD10(PolicySignedSyncShort, |
| TPM_RC(const TPMI_DH_OBJECT& auth_object, |
| const TPMI_SH_POLICY& policy_session, |
| const TPM2B_NONCE& nonce_tpm, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const INT32& expiration, |
| const TPMT_SIGNATURE& auth, |
| TPM2B_TIMEOUT* timeout, |
| TPMT_TK_AUTH* policy_ticket, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD9(PolicyFidoSigned, |
| void(const TPMI_DH_OBJECT& auth_object, |
| const std::string& auth_object_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const std::string& auth_data, |
| const std::vector<FIDO_DATA_RANGE>& auth_data_descr, |
| const TPMT_SIGNATURE& auth, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyFidoSignedResponse callback)); |
| MOCK_METHOD8(PolicyFidoSignedSync, |
| TPM_RC(const TPMI_DH_OBJECT& auth_object, |
| const std::string& auth_object_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const std::string& auth_data, |
| const std::vector<FIDO_DATA_RANGE>& auth_data_descr, |
| const TPMT_SIGNATURE& auth, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD10(PolicySecret, |
| void(const TPMI_DH_ENTITY& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_NONCE& nonce_tpm, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const INT32& expiration, |
| AuthorizationDelegate* authorization_delegate, |
| PolicySecretResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC PolicySecretSync( |
| const TPMI_DH_ENTITY& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_NONCE& nonce_tpm, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const INT32& expiration, |
| TPM2B_TIMEOUT* timeout, |
| TPMT_TK_AUTH* policy_ticket, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD9(PolicySecretSyncShort, |
| TPM_RC(const TPMI_DH_ENTITY& auth_handle, |
| const TPMI_SH_POLICY& policy_session, |
| const TPM2B_NONCE& nonce_tpm, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const INT32& expiration, |
| TPM2B_TIMEOUT* timeout, |
| TPMT_TK_AUTH* policy_ticket, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD9(PolicyTicket, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_TIMEOUT& timeout, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const TPM2B_NAME& auth_name, |
| const TPMT_TK_AUTH& ticket, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyTicketResponse callback)); |
| MOCK_METHOD8(PolicyTicketSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_TIMEOUT& timeout, |
| const TPM2B_DIGEST& cp_hash_a, |
| const TPM2B_NONCE& policy_ref, |
| const TPM2B_NAME& auth_name, |
| const TPMT_TK_AUTH& ticket, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PolicyOR, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPML_DIGEST& p_hash_list, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyORResponse callback)); |
| MOCK_METHOD4(PolicyORSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPML_DIGEST& p_hash_list, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(PolicyPCR, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& pcr_digest, |
| const TPML_PCR_SELECTION& pcrs, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyPCRResponse callback)); |
| MOCK_METHOD5(PolicyPCRSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& pcr_digest, |
| const TPML_PCR_SELECTION& pcrs, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PolicyLocality, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPMA_LOCALITY& locality, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyLocalityResponse callback)); |
| MOCK_METHOD4(PolicyLocalitySync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPMA_LOCALITY& locality, |
| AuthorizationDelegate* authorization_delegate)); |
| // Too many args to mock, forward to *Short version. |
| void PolicyNV(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_OPERAND& operand_b, |
| const UINT16& offset, |
| const TPM_EO& operation, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyNVResponse callback) override; |
| MOCK_METHOD8(PolicyNVShort, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const TPMI_SH_POLICY& policy_session, |
| const TPM2B_OPERAND& operand_b, |
| const UINT16& offset, |
| const TPM_EO& operation, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyNVResponse callback)); |
| MOCK_METHOD10(PolicyNVSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_OPERAND& operand_b, |
| const UINT16& offset, |
| const TPM_EO& operation, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(PolicyCounterTimer, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_OPERAND& operand_b, |
| const UINT16& offset, |
| const TPM_EO& operation, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyCounterTimerResponse callback)); |
| MOCK_METHOD6(PolicyCounterTimerSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_OPERAND& operand_b, |
| const UINT16& offset, |
| const TPM_EO& operation, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PolicyCommandCode, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM_CC& code, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyCommandCodeResponse callback)); |
| MOCK_METHOD4(PolicyCommandCodeSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM_CC& code, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(PolicyPhysicalPresence, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyPhysicalPresenceResponse callback)); |
| MOCK_METHOD3(PolicyPhysicalPresenceSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PolicyCpHash, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& cp_hash_a, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyCpHashResponse callback)); |
| MOCK_METHOD4(PolicyCpHashSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& cp_hash_a, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PolicyNameHash, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& name_hash, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyNameHashResponse callback)); |
| MOCK_METHOD4(PolicyNameHashSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& name_hash, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(PolicyDuplicationSelect, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_NAME& object_name, |
| const TPM2B_NAME& new_parent_name, |
| const TPMI_YES_NO& include_object, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyDuplicationSelectResponse callback)); |
| MOCK_METHOD6(PolicyDuplicationSelectSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_NAME& object_name, |
| const TPM2B_NAME& new_parent_name, |
| const TPMI_YES_NO& include_object, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(PolicyAuthorize, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& approved_policy, |
| const TPM2B_NONCE& policy_ref, |
| const TPM2B_NAME& key_sign, |
| const TPMT_TK_VERIFIED& check_ticket, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyAuthorizeResponse callback)); |
| MOCK_METHOD7(PolicyAuthorizeSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPM2B_DIGEST& approved_policy, |
| const TPM2B_NONCE& policy_ref, |
| const TPM2B_NAME& key_sign, |
| const TPMT_TK_VERIFIED& check_ticket, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(PolicyAuthValue, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyAuthValueResponse callback)); |
| MOCK_METHOD3(PolicyAuthValueSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(PolicyPassword, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyPasswordResponse callback)); |
| MOCK_METHOD3(PolicyPasswordSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(PolicyGetDigest, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyGetDigestResponse callback)); |
| MOCK_METHOD4(PolicyGetDigestSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| TPM2B_DIGEST* policy_digest, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(PolicyNvWritten, |
| void(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPMI_YES_NO& written_set, |
| AuthorizationDelegate* authorization_delegate, |
| PolicyNvWrittenResponse callback)); |
| MOCK_METHOD4(PolicyNvWrittenSync, |
| TPM_RC(const TPMI_SH_POLICY& policy_session, |
| const std::string& policy_session_name, |
| const TPMI_YES_NO& written_set, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(CreatePrimary, |
| void(const TPMI_RH_HIERARCHY& primary_handle, |
| const std::string& primary_handle_name, |
| const TPM2B_SENSITIVE_CREATE& in_sensitive, |
| const TPM2B_PUBLIC& in_public, |
| const TPM2B_DATA& outside_info, |
| const TPML_PCR_SELECTION& creation_pcr, |
| AuthorizationDelegate* authorization_delegate, |
| CreatePrimaryResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC CreatePrimarySync( |
| const TPMI_RH_HIERARCHY& primary_handle, |
| const std::string& primary_handle_name, |
| const TPM2B_SENSITIVE_CREATE& in_sensitive, |
| const TPM2B_PUBLIC& in_public, |
| const TPM2B_DATA& outside_info, |
| const TPML_PCR_SELECTION& creation_pcr, |
| TPM_HANDLE* object_handle, |
| TPM2B_PUBLIC* out_public, |
| TPM2B_CREATION_DATA* creation_data, |
| TPM2B_DIGEST* creation_hash, |
| TPMT_TK_CREATION* creation_ticket, |
| TPM2B_NAME* name, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD10(CreatePrimarySyncShort, |
| TPM_RC(const TPMI_RH_HIERARCHY& primary_handle, |
| const TPM2B_PUBLIC& in_public, |
| const TPML_PCR_SELECTION& creation_pcr, |
| TPM_HANDLE* object_handle, |
| TPM2B_PUBLIC* out_public, |
| TPM2B_CREATION_DATA* creation_data, |
| TPM2B_DIGEST* creation_hash, |
| TPMT_TK_CREATION* creation_ticket, |
| TPM2B_NAME* name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(HierarchyControl, |
| void(const TPMI_RH_HIERARCHY& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_ENABLES& enable, |
| const TPMI_YES_NO& state, |
| AuthorizationDelegate* authorization_delegate, |
| HierarchyControlResponse callback)); |
| MOCK_METHOD5(HierarchyControlSync, |
| TPM_RC(const TPMI_RH_HIERARCHY& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_ENABLES& enable, |
| const TPMI_YES_NO& state, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(SetPrimaryPolicy, |
| void(const TPMI_RH_HIERARCHY& auth_handle, |
| const std::string& auth_handle_name, |
| const TPM2B_DIGEST& auth_policy, |
| const TPMI_ALG_HASH& hash_alg, |
| AuthorizationDelegate* authorization_delegate, |
| SetPrimaryPolicyResponse callback)); |
| MOCK_METHOD5(SetPrimaryPolicySync, |
| TPM_RC(const TPMI_RH_HIERARCHY& auth_handle, |
| const std::string& auth_handle_name, |
| const TPM2B_DIGEST& auth_policy, |
| const TPMI_ALG_HASH& hash_alg, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(ChangePPS, |
| void(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| ChangePPSResponse callback)); |
| MOCK_METHOD3(ChangePPSSync, |
| TPM_RC(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(ChangeEPS, |
| void(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| ChangeEPSResponse callback)); |
| MOCK_METHOD3(ChangeEPSSync, |
| TPM_RC(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(Clear, |
| void(const TPMI_RH_CLEAR& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| ClearResponse callback)); |
| MOCK_METHOD3(ClearSync, |
| TPM_RC(const TPMI_RH_CLEAR& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(ClearControl, |
| void(const TPMI_RH_CLEAR& auth, |
| const std::string& auth_name, |
| const TPMI_YES_NO& disable, |
| AuthorizationDelegate* authorization_delegate, |
| ClearControlResponse callback)); |
| MOCK_METHOD4(ClearControlSync, |
| TPM_RC(const TPMI_RH_CLEAR& auth, |
| const std::string& auth_name, |
| const TPMI_YES_NO& disable, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(HierarchyChangeAuth, |
| void(const TPMI_RH_HIERARCHY_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPM2B_AUTH& new_auth, |
| AuthorizationDelegate* authorization_delegate, |
| HierarchyChangeAuthResponse callback)); |
| MOCK_METHOD4(HierarchyChangeAuthSync, |
| TPM_RC(const TPMI_RH_HIERARCHY_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPM2B_AUTH& new_auth, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(DictionaryAttackLockReset, |
| void(const TPMI_RH_LOCKOUT& lock_handle, |
| const std::string& lock_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| DictionaryAttackLockResetResponse callback)); |
| MOCK_METHOD3(DictionaryAttackLockResetSync, |
| TPM_RC(const TPMI_RH_LOCKOUT& lock_handle, |
| const std::string& lock_handle_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(DictionaryAttackParameters, |
| void(const TPMI_RH_LOCKOUT& lock_handle, |
| const std::string& lock_handle_name, |
| const UINT32& new_max_tries, |
| const UINT32& new_recovery_time, |
| const UINT32& lockout_recovery, |
| AuthorizationDelegate* authorization_delegate, |
| DictionaryAttackParametersResponse callback)); |
| MOCK_METHOD6(DictionaryAttackParametersSync, |
| TPM_RC(const TPMI_RH_LOCKOUT& lock_handle, |
| const std::string& lock_handle_name, |
| const UINT32& new_max_tries, |
| const UINT32& new_recovery_time, |
| const UINT32& lockout_recovery, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(PP_Commands, |
| void(const TPMI_RH_PLATFORM& auth, |
| const std::string& auth_name, |
| const TPML_CC& set_list, |
| const TPML_CC& clear_list, |
| AuthorizationDelegate* authorization_delegate, |
| PP_CommandsResponse callback)); |
| MOCK_METHOD5(PP_CommandsSync, |
| TPM_RC(const TPMI_RH_PLATFORM& auth, |
| const std::string& auth_name, |
| const TPML_CC& set_list, |
| const TPML_CC& clear_list, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(SetAlgorithmSet, |
| void(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| const UINT32& algorithm_set, |
| AuthorizationDelegate* authorization_delegate, |
| SetAlgorithmSetResponse callback)); |
| MOCK_METHOD4(SetAlgorithmSetSync, |
| TPM_RC(const TPMI_RH_PLATFORM& auth_handle, |
| const std::string& auth_handle_name, |
| const UINT32& algorithm_set, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(FieldUpgradeStart, |
| void(const TPMI_RH_PLATFORM& authorization, |
| const std::string& authorization_name, |
| const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_DIGEST& fu_digest, |
| const TPMT_SIGNATURE& manifest_signature, |
| AuthorizationDelegate* authorization_delegate, |
| FieldUpgradeStartResponse callback)); |
| MOCK_METHOD7(FieldUpgradeStartSync, |
| TPM_RC(const TPMI_RH_PLATFORM& authorization, |
| const std::string& authorization_name, |
| const TPMI_DH_OBJECT& key_handle, |
| const std::string& key_handle_name, |
| const TPM2B_DIGEST& fu_digest, |
| const TPMT_SIGNATURE& manifest_signature, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(FieldUpgradeData, |
| void(const TPM2B_MAX_BUFFER& fu_data, |
| AuthorizationDelegate* authorization_delegate, |
| FieldUpgradeDataResponse callback)); |
| MOCK_METHOD4(FieldUpgradeDataSync, |
| TPM_RC(const TPM2B_MAX_BUFFER& fu_data, |
| TPMT_HA* next_digest, |
| TPMT_HA* first_digest, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(FirmwareRead, |
| void(const UINT32& sequence_number, |
| AuthorizationDelegate* authorization_delegate, |
| FirmwareReadResponse callback)); |
| MOCK_METHOD3(FirmwareReadSync, |
| TPM_RC(const UINT32& sequence_number, |
| TPM2B_MAX_BUFFER* fu_data, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(ContextSave, |
| void(const TPMI_DH_CONTEXT& save_handle, |
| const std::string& save_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| ContextSaveResponse callback)); |
| MOCK_METHOD4(ContextSaveSync, |
| TPM_RC(const TPMI_DH_CONTEXT& save_handle, |
| const std::string& save_handle_name, |
| TPMS_CONTEXT* context, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(ContextLoad, |
| void(const TPMS_CONTEXT& context, |
| AuthorizationDelegate* authorization_delegate, |
| ContextLoadResponse callback)); |
| MOCK_METHOD3(ContextLoadSync, |
| TPM_RC(const TPMS_CONTEXT& context, |
| TPMI_DH_CONTEXT* loaded_handle, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(FlushContext, |
| void(const TPMI_DH_CONTEXT& flush_handle, |
| AuthorizationDelegate* authorization_delegate, |
| FlushContextResponse callback)); |
| MOCK_METHOD2(FlushContextSync, |
| TPM_RC(const TPMI_DH_CONTEXT& flush_handle, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(EvictControl, |
| void(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_PERSISTENT& persistent_handle, |
| AuthorizationDelegate* authorization_delegate, |
| EvictControlResponse callback)); |
| MOCK_METHOD6(EvictControlSync, |
| TPM_RC(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const TPMI_DH_OBJECT& object_handle, |
| const std::string& object_handle_name, |
| const TPMI_DH_PERSISTENT& persistent_handle, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD2(ReadClock, |
| void(AuthorizationDelegate* authorization_delegate, |
| ReadClockResponse callback)); |
| MOCK_METHOD2(ReadClockSync, |
| TPM_RC(TPMS_TIME_INFO* current_time, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(ClockSet, |
| void(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const UINT64& new_time, |
| AuthorizationDelegate* authorization_delegate, |
| ClockSetResponse callback)); |
| MOCK_METHOD4(ClockSetSync, |
| TPM_RC(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const UINT64& new_time, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(ClockRateAdjust, |
| void(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const TPM_CLOCK_ADJUST& rate_adjust, |
| AuthorizationDelegate* authorization_delegate, |
| ClockRateAdjustResponse callback)); |
| MOCK_METHOD4(ClockRateAdjustSync, |
| TPM_RC(const TPMI_RH_PROVISION& auth, |
| const std::string& auth_name, |
| const TPM_CLOCK_ADJUST& rate_adjust, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(GetCapability, |
| void(const TPM_CAP& capability, |
| const UINT32& property, |
| const UINT32& property_count, |
| AuthorizationDelegate* authorization_delegate, |
| GetCapabilityResponse callback)); |
| MOCK_METHOD6(GetCapabilitySync, |
| TPM_RC(const TPM_CAP& capability, |
| const UINT32& property, |
| const UINT32& property_count, |
| TPMI_YES_NO* more_data, |
| TPMS_CAPABILITY_DATA* capability_data, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD3(TestParms, |
| void(const TPMT_PUBLIC_PARMS& parameters, |
| AuthorizationDelegate* authorization_delegate, |
| TestParmsResponse callback)); |
| MOCK_METHOD2(TestParmsSync, |
| TPM_RC(const TPMT_PUBLIC_PARMS& parameters, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(NV_DefineSpace, |
| void(const TPMI_RH_PROVISION& auth_handle, |
| const std::string& auth_handle_name, |
| const TPM2B_AUTH& auth, |
| const TPM2B_NV_PUBLIC& public_info, |
| AuthorizationDelegate* authorization_delegate, |
| NV_DefineSpaceResponse callback)); |
| MOCK_METHOD5(NV_DefineSpaceSync, |
| TPM_RC(const TPMI_RH_PROVISION& auth_handle, |
| const std::string& auth_handle_name, |
| const TPM2B_AUTH& auth, |
| const TPM2B_NV_PUBLIC& public_info, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(NV_UndefineSpace, |
| void(const TPMI_RH_PROVISION& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate, |
| NV_UndefineSpaceResponse callback)); |
| MOCK_METHOD5(NV_UndefineSpaceSync, |
| TPM_RC(const TPMI_RH_PROVISION& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(NV_UndefineSpaceSpecial, |
| void(const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPMI_RH_PLATFORM& platform, |
| const std::string& platform_name, |
| AuthorizationDelegate* authorization_delegate, |
| NV_UndefineSpaceSpecialResponse callback)); |
| MOCK_METHOD5(NV_UndefineSpaceSpecialSync, |
| TPM_RC(const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPMI_RH_PLATFORM& platform, |
| const std::string& platform_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(NV_ReadPublic, |
| void(const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate, |
| NV_ReadPublicResponse callback)); |
| MOCK_METHOD5(NV_ReadPublicSync, |
| TPM_RC(const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| TPM2B_NV_PUBLIC* nv_public, |
| TPM2B_NAME* nv_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(NV_Write, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_MAX_NV_BUFFER& data, |
| const UINT16& offset, |
| AuthorizationDelegate* authorization_delegate, |
| NV_WriteResponse callback)); |
| MOCK_METHOD7(NV_WriteSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_MAX_NV_BUFFER& data, |
| const UINT16& offset, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(NV_Increment, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate, |
| NV_IncrementResponse callback)); |
| MOCK_METHOD5(NV_IncrementSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(NV_Extend, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_MAX_NV_BUFFER& data, |
| AuthorizationDelegate* authorization_delegate, |
| NV_ExtendResponse callback)); |
| MOCK_METHOD6(NV_ExtendSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_MAX_NV_BUFFER& data, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD7(NV_SetBits, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const UINT64& bits, |
| AuthorizationDelegate* authorization_delegate, |
| NV_SetBitsResponse callback)); |
| MOCK_METHOD6(NV_SetBitsSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const UINT64& bits, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(NV_WriteLock, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate, |
| NV_WriteLockResponse callback)); |
| MOCK_METHOD5(NV_WriteLockSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD4(NV_GlobalWriteLock, |
| void(const TPMI_RH_PROVISION& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate, |
| NV_GlobalWriteLockResponse callback)); |
| MOCK_METHOD3(NV_GlobalWriteLockSync, |
| TPM_RC(const TPMI_RH_PROVISION& auth_handle, |
| const std::string& auth_handle_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD8(NV_Read, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const UINT16& size, |
| const UINT16& offset, |
| AuthorizationDelegate* authorization_delegate, |
| NV_ReadResponse callback)); |
| MOCK_METHOD8(NV_ReadSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const UINT16& size, |
| const UINT16& offset, |
| TPM2B_MAX_NV_BUFFER* data, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD6(NV_ReadLock, |
| void(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate, |
| NV_ReadLockResponse callback)); |
| MOCK_METHOD5(NV_ReadLockSync, |
| TPM_RC(const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| AuthorizationDelegate* authorization_delegate)); |
| MOCK_METHOD5(NV_ChangeAuth, |
| void(const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_AUTH& new_auth, |
| AuthorizationDelegate* authorization_delegate, |
| NV_ChangeAuthResponse callback)); |
| MOCK_METHOD4(NV_ChangeAuthSync, |
| TPM_RC(const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_AUTH& new_auth, |
| AuthorizationDelegate* authorization_delegate)); |
| // Too many args to mock, forward to *Short version. |
| void NV_Certify(const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const UINT16& size, |
| const UINT16& offset, |
| AuthorizationDelegate* authorization_delegate, |
| NV_CertifyResponse callback) override; |
| MOCK_METHOD9(NV_CertifyShort, |
| void(const TPMI_DH_OBJECT& sign_handle, |
| const TPMI_RH_NV_AUTH& auth_handle, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const UINT16& size, |
| const UINT16& offset, |
| AuthorizationDelegate* authorization_delegate, |
| NV_CertifyResponse callback)); |
| // Too many args to mock, forward to *Short version. |
| TPM_RC NV_CertifySync(const TPMI_DH_OBJECT& sign_handle, |
| const std::string& sign_handle_name, |
| const TPMI_RH_NV_AUTH& auth_handle, |
| const std::string& auth_handle_name, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const std::string& nv_index_name, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const UINT16& size, |
| const UINT16& offset, |
| TPM2B_ATTEST* certify_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate) override; |
| MOCK_METHOD10(NV_CertifySyncShort, |
| TPM_RC(const TPMI_DH_OBJECT& sign_handle, |
| const TPMI_RH_NV_AUTH& auth_handle, |
| const TPMI_RH_NV_INDEX& nv_index, |
| const TPM2B_DATA& qualifying_data, |
| const TPMT_SIG_SCHEME& in_scheme, |
| const UINT16& size, |
| const UINT16& offset, |
| TPM2B_ATTEST* certify_info, |
| TPMT_SIGNATURE* signature, |
| AuthorizationDelegate* authorization_delegate)); |
| }; |
| |
| } // namespace trunks |
| |
| #endif // TRUNKS_MOCK_TPM_H_ |