| // |
| // Copyright (C) 2014 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #ifndef TRUNKS_MOCK_TPM_H_ |
| #define TRUNKS_MOCK_TPM_H_ |
| |
| #include <string> |
| |
| #include <base/callback.h> |
| #include <gmock/gmock.h> |
| |
| #include "trunks/tpm_generated.h" |
| |
| namespace trunks { |
| |
| class MockTpm : public Tpm { |
| public: |
| MockTpm(); |
| ~MockTpm() override; |
| |
| MOCK_METHOD3(Startup, |
| void(const TPM_SU& startup_type, |
| AuthorizationDelegate* authorization_delegate, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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_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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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, |
| const 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_ |
