| // Copyright 2019 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. |
| |
| // This file is GENERATED and do not modify it manually. |
| // To reproduce the generation process, run |
| // //src/platform2/libhwsec/overalls/gen_overalls.py with arguments as: |
| // --filter-by-usage |
| |
| #ifndef LIBHWSEC_OVERALLS_OVERALLS_H_ |
| #define LIBHWSEC_OVERALLS_OVERALLS_H_ |
| |
| #include <trousers/tss.h> |
| #include <trousers/trousers.h> // NOLINT(build/include_alpha) - needs tss.h |
| |
| namespace hwsec { |
| namespace overalls { |
| |
| // |Overalls| wraps trousers API (including Tspi and Trspi family), with the |
| // wrapper API name being the trousers API names of which the first "T" replaced |
| // by "O". For example, |Overalls::Ospi_Context_Create| calls |
| // |Tspi_Context_Create|. |
| // |
| // The purpose of this wrapper class is to make trousers APIs to be mock-able so |
| // we can enable the callers of trouser to be unittested in googletest |
| // framework. |
| class Overalls { |
| public: |
| Overalls() = default; |
| virtual ~Overalls() = default; |
| virtual void Orspi_UnloadBlob_UINT32(UINT64* offset, |
| UINT32* out, |
| BYTE* blob) { |
| return Trspi_UnloadBlob_UINT32(offset, out, blob); |
| } |
| virtual void Orspi_UnloadBlob_UINT16(UINT64* offset, |
| UINT16* out, |
| BYTE* blob) { |
| return Trspi_UnloadBlob_UINT16(offset, out, blob); |
| } |
| virtual TSS_RESULT Orspi_UnloadBlob_PUBKEY(UINT64* offset, |
| BYTE* blob, |
| TCPA_PUBKEY* pubKey) { |
| return Trspi_UnloadBlob_PUBKEY(offset, blob, pubKey); |
| } |
| virtual TSS_RESULT Orspi_UnloadBlob_KEY12(UINT64* offset, |
| BYTE* blob, |
| TPM_KEY12* key) { |
| return Trspi_UnloadBlob_KEY12(offset, blob, key); |
| } |
| virtual void Orspi_LoadBlob_UINT32(UINT64* offset, UINT32 in, BYTE* blob) { |
| return Trspi_LoadBlob_UINT32(offset, in, blob); |
| } |
| virtual void Orspi_LoadBlob_PUBKEY(UINT64* offset, |
| BYTE* blob, |
| TCPA_PUBKEY* pubKey) { |
| return Trspi_LoadBlob_PUBKEY(offset, blob, pubKey); |
| } |
| virtual TSS_RESULT Orspi_SymDecrypt(UINT16 alg, |
| UINT16 mode, |
| BYTE* key, |
| BYTE* iv, |
| BYTE* in, |
| UINT32 in_len, |
| BYTE* out, |
| UINT32* out_len) { |
| return Trspi_SymDecrypt(alg, mode, key, iv, in, in_len, out, out_len); |
| } |
| virtual TSS_RESULT Orspi_MGF1( |
| UINT32 alg, UINT32 seedLen, BYTE* seed, UINT32 outLen, BYTE* out) { |
| return Trspi_MGF1(alg, seedLen, seed, outLen, out); |
| } |
| virtual char* Orspi_Error_String(TSS_RESULT arg0) { |
| return Trspi_Error_String(arg0); |
| } |
| virtual TSS_RESULT Ospi_SetAttribUint32(TSS_HOBJECT hObject, |
| TSS_FLAG attribFlag, |
| TSS_FLAG subFlag, |
| UINT32 ulAttrib) { |
| return Tspi_SetAttribUint32(hObject, attribFlag, subFlag, ulAttrib); |
| } |
| virtual TSS_RESULT Ospi_GetAttribUint32(TSS_HOBJECT hObject, |
| TSS_FLAG attribFlag, |
| TSS_FLAG subFlag, |
| UINT32* pulAttrib) { |
| return Tspi_GetAttribUint32(hObject, attribFlag, subFlag, pulAttrib); |
| } |
| virtual TSS_RESULT Ospi_SetAttribData(TSS_HOBJECT hObject, |
| TSS_FLAG attribFlag, |
| TSS_FLAG subFlag, |
| UINT32 ulAttribDataSize, |
| BYTE* rgbAttribData) { |
| return Tspi_SetAttribData(hObject, attribFlag, subFlag, ulAttribDataSize, |
| rgbAttribData); |
| } |
| virtual TSS_RESULT Ospi_GetAttribData(TSS_HOBJECT hObject, |
| TSS_FLAG attribFlag, |
| TSS_FLAG subFlag, |
| UINT32* pulAttribDataSize, |
| BYTE** prgbAttribData) { |
| return Tspi_GetAttribData(hObject, attribFlag, subFlag, pulAttribDataSize, |
| prgbAttribData); |
| } |
| virtual TSS_RESULT Ospi_ChangeAuth(TSS_HOBJECT hObjectToChange, |
| TSS_HOBJECT hParentObject, |
| TSS_HPOLICY hNewPolicy) { |
| return Tspi_ChangeAuth(hObjectToChange, hParentObject, hNewPolicy); |
| } |
| virtual TSS_RESULT Ospi_GetPolicyObject(TSS_HOBJECT hObject, |
| TSS_FLAG policyType, |
| TSS_HPOLICY* phPolicy) { |
| return Tspi_GetPolicyObject(hObject, policyType, phPolicy); |
| } |
| virtual TSS_RESULT Ospi_Context_Create(TSS_HCONTEXT* phContext) { |
| return Tspi_Context_Create(phContext); |
| } |
| virtual TSS_RESULT Ospi_Context_Close(TSS_HCONTEXT hContext) { |
| return Tspi_Context_Close(hContext); |
| } |
| virtual TSS_RESULT Ospi_Context_Connect(TSS_HCONTEXT hContext, |
| TSS_UNICODE* wszDestination) { |
| return Tspi_Context_Connect(hContext, wszDestination); |
| } |
| virtual TSS_RESULT Ospi_Context_FreeMemory(TSS_HCONTEXT hContext, |
| BYTE* rgbMemory) { |
| return Tspi_Context_FreeMemory(hContext, rgbMemory); |
| } |
| virtual TSS_RESULT Ospi_Context_GetDefaultPolicy(TSS_HCONTEXT hContext, |
| TSS_HPOLICY* phPolicy) { |
| return Tspi_Context_GetDefaultPolicy(hContext, phPolicy); |
| } |
| virtual TSS_RESULT Ospi_Context_CreateObject(TSS_HCONTEXT hContext, |
| TSS_FLAG objectType, |
| TSS_FLAG initFlags, |
| TSS_HOBJECT* phObject) { |
| return Tspi_Context_CreateObject(hContext, objectType, initFlags, phObject); |
| } |
| virtual TSS_RESULT Ospi_Context_CloseObject(TSS_HCONTEXT hContext, |
| TSS_HOBJECT hObject) { |
| return Tspi_Context_CloseObject(hContext, hObject); |
| } |
| virtual TSS_RESULT Ospi_Context_GetTpmObject(TSS_HCONTEXT hContext, |
| TSS_HTPM* phTPM) { |
| return Tspi_Context_GetTpmObject(hContext, phTPM); |
| } |
| virtual TSS_RESULT Ospi_Context_LoadKeyByBlob(TSS_HCONTEXT hContext, |
| TSS_HKEY hUnwrappingKey, |
| UINT32 ulBlobLength, |
| BYTE* rgbBlobData, |
| TSS_HKEY* phKey) { |
| return Tspi_Context_LoadKeyByBlob(hContext, hUnwrappingKey, ulBlobLength, |
| rgbBlobData, phKey); |
| } |
| virtual TSS_RESULT Ospi_Context_LoadKeyByUUID(TSS_HCONTEXT hContext, |
| TSS_FLAG persistentStorageType, |
| TSS_UUID uuidData, |
| TSS_HKEY* phKey) { |
| return Tspi_Context_LoadKeyByUUID(hContext, persistentStorageType, uuidData, |
| phKey); |
| } |
| virtual TSS_RESULT Ospi_Policy_SetSecret(TSS_HPOLICY hPolicy, |
| TSS_FLAG secretMode, |
| UINT32 ulSecretLength, |
| BYTE* rgbSecret) { |
| return Tspi_Policy_SetSecret(hPolicy, secretMode, ulSecretLength, |
| rgbSecret); |
| } |
| virtual TSS_RESULT Ospi_Policy_AssignToObject(TSS_HPOLICY hPolicy, |
| TSS_HOBJECT hObject) { |
| return Tspi_Policy_AssignToObject(hPolicy, hObject); |
| } |
| virtual TSS_RESULT Ospi_TPM_CreateEndorsementKey( |
| TSS_HTPM hTPM, TSS_HKEY hKey, TSS_VALIDATION* pValidationData) { |
| return Tspi_TPM_CreateEndorsementKey(hTPM, hKey, pValidationData); |
| } |
| virtual TSS_RESULT Ospi_TPM_GetPubEndorsementKey( |
| TSS_HTPM hTPM, |
| TSS_BOOL fOwnerAuthorized, |
| TSS_VALIDATION* pValidationData, |
| TSS_HKEY* phEndorsementPubKey) { |
| return Tspi_TPM_GetPubEndorsementKey(hTPM, fOwnerAuthorized, |
| pValidationData, phEndorsementPubKey); |
| } |
| virtual TSS_RESULT Ospi_TPM_TakeOwnership(TSS_HTPM hTPM, |
| TSS_HKEY hKeySRK, |
| TSS_HKEY hEndorsementPubKey) { |
| return Tspi_TPM_TakeOwnership(hTPM, hKeySRK, hEndorsementPubKey); |
| } |
| virtual TSS_RESULT Ospi_TPM_CollateIdentityRequest( |
| TSS_HTPM hTPM, |
| TSS_HKEY hKeySRK, |
| TSS_HKEY hCAPubKey, |
| UINT32 ulIdentityLabelLength, |
| BYTE* rgbIdentityLabelData, |
| TSS_HKEY hIdentityKey, |
| TSS_ALGORITHM_ID algID, |
| UINT32* pulTCPAIdentityReqLength, |
| BYTE** prgbTCPAIdentityReq) { |
| return Tspi_TPM_CollateIdentityRequest( |
| hTPM, hKeySRK, hCAPubKey, ulIdentityLabelLength, rgbIdentityLabelData, |
| hIdentityKey, algID, pulTCPAIdentityReqLength, prgbTCPAIdentityReq); |
| } |
| virtual TSS_RESULT Ospi_TPM_ActivateIdentity( |
| TSS_HTPM hTPM, |
| TSS_HKEY hIdentKey, |
| UINT32 ulAsymCAContentsBlobLength, |
| BYTE* rgbAsymCAContentsBlob, |
| UINT32 ulSymCAAttestationBlobLength, |
| BYTE* rgbSymCAAttestationBlob, |
| UINT32* pulCredentialLength, |
| BYTE** prgbCredential) { |
| return Tspi_TPM_ActivateIdentity( |
| hTPM, hIdentKey, ulAsymCAContentsBlobLength, rgbAsymCAContentsBlob, |
| ulSymCAAttestationBlobLength, rgbSymCAAttestationBlob, |
| pulCredentialLength, prgbCredential); |
| } |
| virtual TSS_RESULT Ospi_TPM_SetStatus(TSS_HTPM hTPM, |
| TSS_FLAG statusFlag, |
| TSS_BOOL fTpmState) { |
| return Tspi_TPM_SetStatus(hTPM, statusFlag, fTpmState); |
| } |
| virtual TSS_RESULT Ospi_TPM_GetStatus(TSS_HTPM hTPM, |
| TSS_FLAG statusFlag, |
| TSS_BOOL* pfTpmState) { |
| return Tspi_TPM_GetStatus(hTPM, statusFlag, pfTpmState); |
| } |
| virtual TSS_RESULT Ospi_TPM_FieldUpgrade(TSS_HTPM hTPM, |
| UINT32 ulDataInLength, |
| BYTE* rgbDataIn, |
| UINT32* pulDataOutLength, |
| BYTE** prgbDataOut) { |
| return Tspi_TPM_FieldUpgrade(hTPM, ulDataInLength, rgbDataIn, |
| pulDataOutLength, prgbDataOut); |
| } |
| virtual TSS_RESULT Ospi_TPM_GetCapability(TSS_HTPM hTPM, |
| TSS_FLAG capArea, |
| UINT32 ulSubCapLength, |
| BYTE* rgbSubCap, |
| UINT32* pulRespDataLength, |
| BYTE** prgbRespData) { |
| return Tspi_TPM_GetCapability(hTPM, capArea, ulSubCapLength, rgbSubCap, |
| pulRespDataLength, prgbRespData); |
| } |
| virtual TSS_RESULT Ospi_TPM_GetRandom(TSS_HTPM hTPM, |
| UINT32 ulRandomDataLength, |
| BYTE** prgbRandomData) { |
| return Tspi_TPM_GetRandom(hTPM, ulRandomDataLength, prgbRandomData); |
| } |
| virtual TSS_RESULT Ospi_TPM_StirRandom(TSS_HTPM hTPM, |
| UINT32 ulEntropyDataLength, |
| BYTE* rgbEntropyData) { |
| return Tspi_TPM_StirRandom(hTPM, ulEntropyDataLength, rgbEntropyData); |
| } |
| virtual TSS_RESULT Ospi_TPM_Quote(TSS_HTPM hTPM, |
| TSS_HKEY hIdentKey, |
| TSS_HPCRS hPcrComposite, |
| TSS_VALIDATION* pValidationData) { |
| return Tspi_TPM_Quote(hTPM, hIdentKey, hPcrComposite, pValidationData); |
| } |
| virtual TSS_RESULT Ospi_TPM_PcrExtend(TSS_HTPM hTPM, |
| UINT32 ulPcrIndex, |
| UINT32 ulPcrDataLength, |
| BYTE* pbPcrData, |
| TSS_PCR_EVENT* pPcrEvent, |
| UINT32* pulPcrValueLength, |
| BYTE** prgbPcrValue) { |
| return Tspi_TPM_PcrExtend(hTPM, ulPcrIndex, ulPcrDataLength, pbPcrData, |
| pPcrEvent, pulPcrValueLength, prgbPcrValue); |
| } |
| virtual TSS_RESULT Ospi_TPM_PcrRead(TSS_HTPM hTPM, |
| UINT32 ulPcrIndex, |
| UINT32* pulPcrValueLength, |
| BYTE** prgbPcrValue) { |
| return Tspi_TPM_PcrRead(hTPM, ulPcrIndex, pulPcrValueLength, prgbPcrValue); |
| } |
| virtual TSS_RESULT Ospi_TPM_AuthorizeMigrationTicket( |
| TSS_HTPM hTPM, |
| TSS_HKEY hMigrationKey, |
| TSS_MIGRATE_SCHEME migrationScheme, |
| UINT32* pulMigTicketLength, |
| BYTE** prgbMigTicket) { |
| return Tspi_TPM_AuthorizeMigrationTicket(hTPM, hMigrationKey, |
| migrationScheme, |
| pulMigTicketLength, prgbMigTicket); |
| } |
| virtual TSS_RESULT Ospi_TPM_CMKApproveMA(TSS_HTPM hTPM, |
| TSS_HMIGDATA hMaAuthData) { |
| return Tspi_TPM_CMKApproveMA(hTPM, hMaAuthData); |
| } |
| virtual TSS_RESULT Ospi_TPM_CMKCreateTicket(TSS_HTPM hTPM, |
| TSS_HKEY hVerifyKey, |
| TSS_HMIGDATA hSigData) { |
| return Tspi_TPM_CMKCreateTicket(hTPM, hVerifyKey, hSigData); |
| } |
| virtual TSS_RESULT Ospi_PcrComposite_SelectPcrIndex(TSS_HPCRS hPcrComposite, |
| UINT32 ulPcrIndex) { |
| return Tspi_PcrComposite_SelectPcrIndex(hPcrComposite, ulPcrIndex); |
| } |
| virtual TSS_RESULT Ospi_PcrComposite_SetPcrValue(TSS_HPCRS hPcrComposite, |
| UINT32 ulPcrIndex, |
| UINT32 ulPcrValueLength, |
| BYTE* rgbPcrValue) { |
| return Tspi_PcrComposite_SetPcrValue(hPcrComposite, ulPcrIndex, |
| ulPcrValueLength, rgbPcrValue); |
| } |
| virtual TSS_RESULT Ospi_PcrComposite_GetPcrValue(TSS_HPCRS hPcrComposite, |
| UINT32 ulPcrIndex, |
| UINT32* pulPcrValueLength, |
| BYTE** prgbPcrValue) { |
| return Tspi_PcrComposite_GetPcrValue(hPcrComposite, ulPcrIndex, |
| pulPcrValueLength, prgbPcrValue); |
| } |
| virtual TSS_RESULT Ospi_PcrComposite_SetPcrLocality(TSS_HPCRS hPcrComposite, |
| UINT32 LocalityValue) { |
| return Tspi_PcrComposite_SetPcrLocality(hPcrComposite, LocalityValue); |
| } |
| virtual TSS_RESULT Ospi_Key_LoadKey(TSS_HKEY hKey, TSS_HKEY hUnwrappingKey) { |
| return Tspi_Key_LoadKey(hKey, hUnwrappingKey); |
| } |
| virtual TSS_RESULT Ospi_Key_UnloadKey(TSS_HKEY hKey) { |
| return Tspi_Key_UnloadKey(hKey); |
| } |
| virtual TSS_RESULT Ospi_Key_GetPubKey(TSS_HKEY hKey, |
| UINT32* pulPubKeyLength, |
| BYTE** prgbPubKey) { |
| return Tspi_Key_GetPubKey(hKey, pulPubKeyLength, prgbPubKey); |
| } |
| virtual TSS_RESULT Ospi_Key_CertifyKey(TSS_HKEY hKey, |
| TSS_HKEY hCertifyingKey, |
| TSS_VALIDATION* pValidationData) { |
| return Tspi_Key_CertifyKey(hKey, hCertifyingKey, pValidationData); |
| } |
| virtual TSS_RESULT Ospi_Key_CreateKey(TSS_HKEY hKey, |
| TSS_HKEY hWrappingKey, |
| TSS_HPCRS hPcrComposite) { |
| return Tspi_Key_CreateKey(hKey, hWrappingKey, hPcrComposite); |
| } |
| virtual TSS_RESULT Ospi_Key_WrapKey(TSS_HKEY hKey, |
| TSS_HKEY hWrappingKey, |
| TSS_HPCRS hPcrComposite) { |
| return Tspi_Key_WrapKey(hKey, hWrappingKey, hPcrComposite); |
| } |
| virtual TSS_RESULT Ospi_Key_CMKCreateBlob(TSS_HKEY hKeyToMigrate, |
| TSS_HKEY hParentKey, |
| TSS_HMIGDATA hMigrationData, |
| UINT32* pulRandomLength, |
| BYTE** prgbRandom) { |
| return Tspi_Key_CMKCreateBlob(hKeyToMigrate, hParentKey, hMigrationData, |
| pulRandomLength, prgbRandom); |
| } |
| virtual TSS_RESULT Ospi_Hash_Sign(TSS_HHASH hHash, |
| TSS_HKEY hKey, |
| UINT32* pulSignatureLength, |
| BYTE** prgbSignature) { |
| return Tspi_Hash_Sign(hHash, hKey, pulSignatureLength, prgbSignature); |
| } |
| virtual TSS_RESULT Ospi_Hash_SetHashValue(TSS_HHASH hHash, |
| UINT32 ulHashValueLength, |
| BYTE* rgbHashValue) { |
| return Tspi_Hash_SetHashValue(hHash, ulHashValueLength, rgbHashValue); |
| } |
| virtual TSS_RESULT Ospi_Data_Bind(TSS_HENCDATA hEncData, |
| TSS_HKEY hEncKey, |
| UINT32 ulDataLength, |
| BYTE* rgbDataToBind) { |
| return Tspi_Data_Bind(hEncData, hEncKey, ulDataLength, rgbDataToBind); |
| } |
| virtual TSS_RESULT Ospi_Data_Unbind(TSS_HENCDATA hEncData, |
| TSS_HKEY hKey, |
| UINT32* pulUnboundDataLength, |
| BYTE** prgbUnboundData) { |
| return Tspi_Data_Unbind(hEncData, hKey, pulUnboundDataLength, |
| prgbUnboundData); |
| } |
| virtual TSS_RESULT Ospi_Data_Seal(TSS_HENCDATA hEncData, |
| TSS_HKEY hEncKey, |
| UINT32 ulDataLength, |
| BYTE* rgbDataToSeal, |
| TSS_HPCRS hPcrComposite) { |
| return Tspi_Data_Seal(hEncData, hEncKey, ulDataLength, rgbDataToSeal, |
| hPcrComposite); |
| } |
| virtual TSS_RESULT Ospi_Data_Unseal(TSS_HENCDATA hEncData, |
| TSS_HKEY hKey, |
| UINT32* pulUnsealedDataLength, |
| BYTE** prgbUnsealedData) { |
| return Tspi_Data_Unseal(hEncData, hKey, pulUnsealedDataLength, |
| prgbUnsealedData); |
| } |
| virtual TSS_RESULT Ospi_NV_DefineSpace(TSS_HNVSTORE hNVStore, |
| TSS_HPCRS hReadPcrComposite, |
| TSS_HPCRS hWritePcrComposite) { |
| return Tspi_NV_DefineSpace(hNVStore, hReadPcrComposite, hWritePcrComposite); |
| } |
| virtual TSS_RESULT Ospi_NV_ReleaseSpace(TSS_HNVSTORE hNVStore) { |
| return Tspi_NV_ReleaseSpace(hNVStore); |
| } |
| virtual TSS_RESULT Ospi_NV_WriteValue(TSS_HNVSTORE hNVStore, |
| UINT32 offset, |
| UINT32 ulDataLength, |
| BYTE* rgbDataToWrite) { |
| return Tspi_NV_WriteValue(hNVStore, offset, ulDataLength, rgbDataToWrite); |
| } |
| virtual TSS_RESULT Ospi_NV_ReadValue(TSS_HNVSTORE hNVStore, |
| UINT32 offset, |
| UINT32* ulDataLength, |
| BYTE** rgbDataRead) { |
| return Tspi_NV_ReadValue(hNVStore, offset, ulDataLength, rgbDataRead); |
| } |
| }; |
| |
| } // namespace overalls |
| } // namespace hwsec |
| |
| #endif // LIBHWSEC_OVERALLS_OVERALLS_H_ |
