/* * Licensed Materials - Property of IBM * * trousers - An open source TCG Software Stack * * (C) Copyright International Business Machines Corp. 2004, 2007 * */ #include #include #include #include "trousers/tss.h" #include "trousers_types.h" #include "trousers_types.h" #include "spi_utils.h" #include "hosttable.h" #include "tsplog.h" #include "rpc_tcstp_tsp.h" #include "obj_context.h" TSS_RESULT RPC_Error(TSS_HCONTEXT tspContext, ...) { LogDebugFn("Context: 0x%x", tspContext); return TSPERR(TSS_E_INTERNAL_ERROR); } TSS_RESULT RPC_OpenContext(TSS_HCONTEXT tspContext, BYTE *hostname, int type) { TSS_RESULT result; TCS_CONTEXT_HANDLE tcsContext; struct host_table_entry *entry; UINT32 tpm_version; /* __tspi_add_table_entry() will make sure an entry doesn't already exist for this tsp context */ if ((result = __tspi_add_table_entry(tspContext, hostname, type, &entry))) return result; switch (type) { case CONNECTION_TYPE_TCP_PERSISTANT: if ((result = RPC_OpenContext_TP(entry, &tpm_version, &tcsContext))) remove_table_entry(tspContext); else { entry->tcsContext = tcsContext; if (obj_context_set_tpm_version(tspContext, tpm_version)) { remove_table_entry(tspContext); result = TSPERR(TSS_E_INTERNAL_ERROR); } } return result; default: break; } return TSPERR(TSS_E_INTERNAL_ERROR); } TSS_RESULT RPC_GetRegisteredKeyByPublicInfo(TSS_HCONTEXT tspContext, TCPA_ALGORITHM_ID algID, /* in */ UINT32 ulPublicInfoLength, /* in */ BYTE * rgbPublicInfo, /* in */ UINT32 * keySize, BYTE ** keyBlob) { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetRegisteredKeyByPublicInfo_TP(entry, algID, ulPublicInfoLength, rgbPublicInfo, keySize, keyBlob); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CloseContext(TSS_HCONTEXT tspContext) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: if ((result = RPC_CloseContext_TP(entry)) == TSS_SUCCESS) { close(entry->socket); remove_table_entry(tspContext); } break; default: break; } if (result != TSS_SUCCESS) put_table_entry(entry); return result; } TSS_RESULT RPC_FreeMemory(TSS_HCONTEXT tspContext, /* in */ BYTE * pMemory) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_FreeMemory_TP(entry, pMemory); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_LogPcrEvent(TSS_HCONTEXT tspContext, /* in */ TSS_PCR_EVENT Event, /* in */ UINT32 * pNumber) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_LogPcrEvent_TP(entry, Event, pNumber); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetPcrEvent(TSS_HCONTEXT tspContext, /* in */ UINT32 PcrIndex, /* in */ UINT32 * pNumber, /* in, out */ TSS_PCR_EVENT ** ppEvent) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetPcrEvent_TP(entry, PcrIndex, pNumber, ppEvent); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetPcrEventsByPcr(TSS_HCONTEXT tspContext, /* in */ UINT32 PcrIndex, /* in */ UINT32 FirstEvent, /* in */ UINT32 * pEventCount, /* in,out */ TSS_PCR_EVENT ** ppEvents) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetPcrEventsByPcr_TP(entry, PcrIndex, FirstEvent, pEventCount, ppEvents); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetPcrEventLog(TSS_HCONTEXT tspContext, /* in */ UINT32 * pEventCount, /* out */ TSS_PCR_EVENT ** ppEvents) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetPcrEventLog_TP(entry, pEventCount, ppEvents); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_RegisterKey(TSS_HCONTEXT tspContext, /* in */ TSS_UUID WrappingKeyUUID, /* in */ TSS_UUID KeyUUID, /* in */ UINT32 cKeySize, /* in */ BYTE * rgbKey, /* in */ UINT32 cVendorData, /* in */ BYTE * gbVendorData) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_RegisterKey_TP(entry, WrappingKeyUUID, KeyUUID, cKeySize, rgbKey, cVendorData, gbVendorData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_UnregisterKey(TSS_HCONTEXT tspContext, /* in */ TSS_UUID KeyUUID) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_UnregisterKey_TP(entry, KeyUUID); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_EnumRegisteredKeys(TSS_HCONTEXT tspContext, /* in */ TSS_UUID * pKeyUUID, /* in */ UINT32 * pcKeyHierarchySize, /* out */ TSS_KM_KEYINFO ** ppKeyHierarchy) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_EnumRegisteredKeys_TP(entry, pKeyUUID, pcKeyHierarchySize, ppKeyHierarchy); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_EnumRegisteredKeys2(TSS_HCONTEXT tspContext, /* in */ TSS_UUID * pKeyUUID, /* in */ UINT32 * pcKeyHierarchySize, /* out */ TSS_KM_KEYINFO2 ** ppKeyHierarchy) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_EnumRegisteredKeys2_TP(entry, pKeyUUID, pcKeyHierarchySize, ppKeyHierarchy); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetRegisteredKey(TSS_HCONTEXT tspContext, /* in */ TSS_UUID KeyUUID, /* in */ TSS_KM_KEYINFO ** ppKeyInfo) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetRegisteredKey_TP(entry, KeyUUID, ppKeyInfo); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetRegisteredKeyBlob(TSS_HCONTEXT tspContext, /* in */ TSS_UUID KeyUUID, /* in */ UINT32 * pcKeySize, /* out */ BYTE ** prgbKey) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetRegisteredKeyBlob_TP(entry, KeyUUID, pcKeySize, prgbKey); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_LoadKeyByBlob(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE hUnwrappingKey, /* in */ UINT32 cWrappedKeyBlobSize, /* in */ BYTE * rgbWrappedKeyBlob, /* in */ TPM_AUTH * pAuth, /* in, out */ TCS_KEY_HANDLE * phKeyTCSI, /* out */ TCS_KEY_HANDLE * phKeyHMAC) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_LoadKeyByBlob_TP(entry, hUnwrappingKey, cWrappedKeyBlobSize, rgbWrappedKeyBlob, pAuth, phKeyTCSI, phKeyHMAC); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_LoadKeyByUUID(TSS_HCONTEXT tspContext, /* in */ TSS_UUID KeyUUID, /* in */ TCS_LOADKEY_INFO * pLoadKeyInfo, /* in, out */ TCS_KEY_HANDLE * phKeyTCSI) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_LoadKeyByUUID_TP(entry, KeyUUID, pLoadKeyInfo, phKeyTCSI); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_EvictKey(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE hKey) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_EvictKey_TP(entry, hKey); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CreateWrapKey(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE hWrappingKey, /* in */ TCPA_ENCAUTH *KeyUsageAuth, /* in */ TCPA_ENCAUTH *KeyMigrationAuth, /* in */ UINT32 keyInfoSize, /* in */ BYTE * keyInfo, /* in */ UINT32 * keyDataSize, /* out */ BYTE ** keyData, /* out */ TPM_AUTH * pAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CreateWrapKey_TP(entry, hWrappingKey, KeyUsageAuth, KeyMigrationAuth, keyInfoSize, keyInfo, keyDataSize, keyData, pAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetPubKey(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE hKey, /* in */ TPM_AUTH * pAuth, /* in, out */ UINT32 * pcPubKeySize, /* out */ BYTE ** prgbPubKey) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetPubKey_TP(entry, hKey, pAuth, pcPubKeySize, prgbPubKey); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_MakeIdentity(TSS_HCONTEXT tspContext, /* in */ TCPA_ENCAUTH identityAuth, /* in */ TCPA_CHOSENID_HASH IDLabel_PrivCAHash, /* in */ UINT32 idKeyInfoSize, /* in */ BYTE * idKeyInfo, /* in */ TPM_AUTH * pSrkAuth, /* in, out */ TPM_AUTH * pOwnerAuth, /* in, out */ UINT32 * idKeySize, /* out */ BYTE ** idKey, /* out */ UINT32 * pcIdentityBindingSize, /* out */ BYTE ** prgbIdentityBinding, /* out */ UINT32 * pcEndorsementCredentialSize, /* out */ BYTE ** prgbEndorsementCredential, /* out */ UINT32 * pcPlatformCredentialSize, /* out */ BYTE ** prgbPlatformCredential, /* out */ UINT32 * pcConformanceCredentialSize, /* out */ BYTE ** prgbConformanceCredential) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_MakeIdentity_TP(entry, identityAuth, IDLabel_PrivCAHash, idKeyInfoSize, idKeyInfo, pSrkAuth, pOwnerAuth, idKeySize, idKey, pcIdentityBindingSize, prgbIdentityBinding, pcEndorsementCredentialSize, prgbEndorsementCredential, pcPlatformCredentialSize, prgbPlatformCredential, pcConformanceCredentialSize, prgbConformanceCredential); break; default: break; } put_table_entry(entry); return result; } #ifdef TSS_BUILD_TSS12 TSS_RESULT RPC_GetCredential(TSS_HCONTEXT tspContext, /* in */ UINT32 ulCredentialType, /* in */ UINT32 ulCredentialAccessMode, /* in */ UINT32 * pulCredentialSize, /* out */ BYTE ** prgbCredentialData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetCredential_TP(entry, ulCredentialType, ulCredentialAccessMode, pulCredentialSize, prgbCredentialData); break; default: break; } put_table_entry(entry); return result; } #endif TSS_RESULT RPC_SetOwnerInstall(TSS_HCONTEXT tspContext, /* in */ TSS_BOOL state) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_SetOwnerInstall_TP(entry, state); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_TakeOwnership(TSS_HCONTEXT tspContext, /* in */ UINT16 protocolID, /* in */ UINT32 encOwnerAuthSize, /* in */ BYTE * encOwnerAuth, /* in */ UINT32 encSrkAuthSize, /* in */ BYTE * encSrkAuth, /* in */ UINT32 srkInfoSize, /* in */ BYTE * srkInfo, /* in */ TPM_AUTH * ownerAuth, /* in, out */ UINT32 * srkKeySize, BYTE ** srkKey) { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_TakeOwnership_TP(entry, protocolID, encOwnerAuthSize, encOwnerAuth, encSrkAuthSize, encSrkAuth, srkInfoSize, srkInfo, ownerAuth, srkKeySize, srkKey); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_OIAP(TSS_HCONTEXT tspContext, /* in */ TCS_AUTHHANDLE * authHandle, /* out */ TCPA_NONCE * nonce0) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_OIAP_TP(entry, authHandle, nonce0); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_OSAP(TSS_HCONTEXT tspContext, /* in */ TCPA_ENTITY_TYPE entityType, /* in */ UINT32 entityValue, /* in */ TPM_NONCE *nonceOddOSAP, /* in */ TCS_AUTHHANDLE * authHandle, /* out */ TCPA_NONCE * nonceEven, /* out */ TCPA_NONCE * nonceEvenOSAP) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_OSAP_TP(entry, entityType, entityValue, nonceOddOSAP, authHandle, nonceEven, nonceEvenOSAP); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ChangeAuth(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE parentHandle, /* in */ TCPA_PROTOCOL_ID protocolID, /* in */ TCPA_ENCAUTH *newAuth, /* in */ TCPA_ENTITY_TYPE entityType, /* in */ UINT32 encDataSize, /* in */ BYTE * encData, /* in */ TPM_AUTH * ownerAuth, /* in, out */ TPM_AUTH * entityAuth, /* in, out */ UINT32 * outDataSize, /* out */ BYTE ** outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ChangeAuth_TP(entry, parentHandle, protocolID, newAuth, entityType, encDataSize, encData, ownerAuth, entityAuth, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ChangeAuthOwner(TSS_HCONTEXT tspContext, /* in */ TCPA_PROTOCOL_ID protocolID, /* in */ TCPA_ENCAUTH *newAuth, /* in */ TCPA_ENTITY_TYPE entityType, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ChangeAuthOwner_TP(entry, protocolID, newAuth, entityType, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ChangeAuthAsymStart(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE idHandle, /* in */ TCPA_NONCE antiReplay, /* in */ UINT32 KeySizeIn, /* in */ BYTE * KeyDataIn, /* in */ TPM_AUTH * pAuth, /* in, out */ UINT32 * KeySizeOut, /* out */ BYTE ** KeyDataOut, /* out */ UINT32 * CertifyInfoSize, /* out */ BYTE ** CertifyInfo, /* out */ UINT32 * sigSize, /* out */ BYTE ** sig, /* out */ TCS_KEY_HANDLE * ephHandle) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ChangeAuthAsymStart_TP(entry, idHandle, antiReplay, KeySizeIn, KeyDataIn, pAuth, KeySizeOut, KeyDataOut, CertifyInfoSize, CertifyInfo, sigSize, sig, ephHandle); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ChangeAuthAsymFinish(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE parentHandle, /* in */ TCS_KEY_HANDLE ephHandle, /* in */ TCPA_ENTITY_TYPE entityType, /* in */ TCPA_HMAC newAuthLink, /* in */ UINT32 newAuthSize, /* in */ BYTE * encNewAuth, /* in */ UINT32 encDataSizeIn, /* in */ BYTE * encDataIn, /* in */ TPM_AUTH * ownerAuth, /* in, out */ UINT32 * encDataSizeOut, /* out */ BYTE ** encDataOut, /* out */ TCPA_SALT_NONCE * saltNonce, /* out */ TCPA_DIGEST * changeProof) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ChangeAuthAsymFinish_TP(entry, parentHandle, ephHandle, entityType, newAuthLink, newAuthSize, encNewAuth, encDataSizeIn, encDataIn, ownerAuth, encDataSizeOut, encDataOut, saltNonce, changeProof); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_TerminateHandle(TSS_HCONTEXT tspContext, /* in */ TCS_AUTHHANDLE handle) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_TerminateHandle_TP(entry, handle); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ActivateTPMIdentity(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE idKey, /* in */ UINT32 blobSize, /* in */ BYTE * blob, /* in */ TPM_AUTH * idKeyAuth, /* in, out */ TPM_AUTH * ownerAuth, /* in, out */ UINT32 * SymmetricKeySize, /* out */ BYTE ** SymmetricKey) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ActivateTPMIdentity_TP(entry, idKey, blobSize, blob, idKeyAuth, ownerAuth, SymmetricKeySize, SymmetricKey); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Extend(TSS_HCONTEXT tspContext, /* in */ TCPA_PCRINDEX pcrNum, /* in */ TCPA_DIGEST inDigest, /* in */ TCPA_PCRVALUE * outDigest) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Extend_TP(entry, pcrNum, inDigest, outDigest); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_PcrRead(TSS_HCONTEXT tspContext, /* in */ TCPA_PCRINDEX pcrNum, /* in */ TCPA_PCRVALUE * outDigest) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_PcrRead_TP(entry, pcrNum, outDigest); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_PcrReset(TSS_HCONTEXT tspContext, /* in */ UINT32 pcrDataSizeIn, /* in */ BYTE * pcrDataIn) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_PcrReset_TP(entry, pcrDataSizeIn, pcrDataIn); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Quote(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TCPA_NONCE *antiReplay, /* in */ UINT32 pcrDataSizeIn, /* in */ BYTE * pcrDataIn, /* in */ TPM_AUTH * privAuth, /* in, out */ UINT32 * pcrDataSizeOut, /* out */ BYTE ** pcrDataOut, /* out */ UINT32 * sigSize, /* out */ BYTE ** sig) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Quote_TP(entry, keyHandle, antiReplay, pcrDataSizeIn, pcrDataIn, privAuth, pcrDataSizeOut, pcrDataOut, sigSize, sig); break; default: break; } put_table_entry(entry); return result; } #ifdef TSS_BUILD_TSS12 TSS_RESULT RPC_Quote2(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TCPA_NONCE *antiReplay, /* in */ UINT32 pcrDataSizeIn, /* in */ BYTE * pcrDataIn, /* in */ TSS_BOOL addVersion, /* in */ TPM_AUTH * privAuth, /* in,out */ UINT32 * pcrDataSizeOut, /* out */ BYTE ** pcrDataOut, /* out */ UINT32 * versionInfoSize, /* out */ BYTE ** versionInfo, /* out */ UINT32 * sigSize, /* out */ BYTE ** sig) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Quote2_TP(entry, keyHandle, antiReplay, pcrDataSizeIn, pcrDataIn, addVersion,privAuth, pcrDataSizeOut, pcrDataOut, versionInfoSize, versionInfo,sigSize, sig); break; default: break; } put_table_entry(entry); return result; } #endif TSS_RESULT RPC_DirWriteAuth(TSS_HCONTEXT tspContext, /* in */ TCPA_DIRINDEX dirIndex, /* in */ TCPA_DIRVALUE *newContents, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DirWriteAuth_TP(entry, dirIndex, newContents, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_DirRead(TSS_HCONTEXT tspContext, /* in */ TCPA_DIRINDEX dirIndex, /* in */ TCPA_DIRVALUE * dirValue) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DirRead_TP(entry, dirIndex, dirValue); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Seal(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TCPA_ENCAUTH *encAuth, /* in */ UINT32 pcrInfoSize, /* in */ BYTE * PcrInfo, /* in */ UINT32 inDataSize, /* in */ BYTE * inData, /* in */ TPM_AUTH * pubAuth, /* in, out */ UINT32 * SealedDataSize, /* out */ BYTE ** SealedData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Seal_TP(entry, keyHandle, encAuth, pcrInfoSize, PcrInfo, inDataSize, inData, pubAuth, SealedDataSize, SealedData); break; default: break; } put_table_entry(entry); return result; } #ifdef TSS_BUILD_SEALX TSS_RESULT RPC_Sealx(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TCPA_ENCAUTH *encAuth, /* in */ UINT32 pcrInfoSize, /* in */ BYTE * PcrInfo, /* in */ UINT32 inDataSize, /* in */ BYTE * inData, /* in */ TPM_AUTH * pubAuth, /* in, out */ UINT32 * SealedDataSize, /* out */ BYTE ** SealedData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Sealx_TP(entry, keyHandle, encAuth, pcrInfoSize, PcrInfo, inDataSize, inData, pubAuth, SealedDataSize, SealedData); break; default: break; } put_table_entry(entry); return result; } #endif TSS_RESULT RPC_Unseal(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE parentHandle, /* in */ UINT32 SealedDataSize, /* in */ BYTE * SealedData, /* in */ TPM_AUTH * parentAuth, /* in, out */ TPM_AUTH * dataAuth, /* in, out */ UINT32 * DataSize, /* out */ BYTE ** Data) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Unseal_TP(entry, parentHandle, SealedDataSize, SealedData, parentAuth, dataAuth, DataSize, Data); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_UnBind(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ UINT32 inDataSize, /* in */ BYTE * inData, /* in */ TPM_AUTH * privAuth, /* in, out */ UINT32 * outDataSize, /* out */ BYTE ** outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_UnBind_TP(entry, keyHandle, inDataSize, inData, privAuth, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CreateMigrationBlob(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE parentHandle, /* in */ TCPA_MIGRATE_SCHEME migrationType, /* in */ UINT32 MigrationKeyAuthSize, /* in */ BYTE * MigrationKeyAuth, /* in */ UINT32 encDataSize, /* in */ BYTE * encData, /* in */ TPM_AUTH * parentAuth, /* in, out */ TPM_AUTH * entityAuth, /* in, out */ UINT32 * randomSize, /* out */ BYTE ** random, /* out */ UINT32 * outDataSize, /* out */ BYTE ** outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CreateMigrationBlob_TP(entry, parentHandle, migrationType, MigrationKeyAuthSize, MigrationKeyAuth, encDataSize, encData, parentAuth, entityAuth, randomSize, random, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ConvertMigrationBlob(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE parentHandle, /* in */ UINT32 inDataSize, /* in */ BYTE * inData, /* in */ UINT32 randomSize, /* in */ BYTE * random, /* in */ TPM_AUTH * parentAuth, /* in, out */ UINT32 * outDataSize, /* out */ BYTE ** outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ConvertMigrationBlob_TP(entry, parentHandle, inDataSize, inData, randomSize, random, parentAuth, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_AuthorizeMigrationKey(TSS_HCONTEXT tspContext, /* in */ TCPA_MIGRATE_SCHEME migrateScheme, /* in */ UINT32 MigrationKeySize, /* in */ BYTE * MigrationKey, /* in */ TPM_AUTH * ownerAuth, /* in, out */ UINT32 * MigrationKeyAuthSize, /* out */ BYTE ** MigrationKeyAuth) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_AuthorizeMigrationKey_TP(entry, migrateScheme, MigrationKeySize, MigrationKey, ownerAuth, MigrationKeyAuthSize, MigrationKeyAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CertifyKey(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE certHandle, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TPM_NONCE * antiReplay, /* in */ TPM_AUTH * certAuth, /* in, out */ TPM_AUTH * keyAuth, /* in, out */ UINT32 * CertifyInfoSize, /* out */ BYTE ** CertifyInfo, /* out */ UINT32 * outDataSize, /* out */ BYTE ** outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CertifyKey_TP(entry, certHandle, keyHandle, antiReplay, certAuth, keyAuth, CertifyInfoSize, CertifyInfo, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Sign(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ UINT32 areaToSignSize, /* in */ BYTE * areaToSign, /* in */ TPM_AUTH * privAuth, /* in, out */ UINT32 * sigSize, /* out */ BYTE ** sig) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Sign_TP(entry, keyHandle, areaToSignSize, areaToSign, privAuth, sigSize, sig); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetRandom(TSS_HCONTEXT tspContext, /* in */ UINT32 bytesRequested, /* in */ BYTE ** randomBytes) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetRandom_TP(entry, bytesRequested, randomBytes); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_StirRandom(TSS_HCONTEXT tspContext, /* in */ UINT32 inDataSize, /* in */ BYTE * inData) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_StirRandom_TP(entry, inDataSize, inData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetTPMCapability(TSS_HCONTEXT tspContext, /* in */ TCPA_CAPABILITY_AREA capArea, /* in */ UINT32 subCapSize, /* in */ BYTE * subCap, /* in */ UINT32 * respSize, /* out */ BYTE ** resp) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetTPMCapability_TP(entry, capArea, subCapSize, subCap, respSize, resp); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_SetCapability(TSS_HCONTEXT tspContext, /* in */ TCPA_CAPABILITY_AREA capArea, /* in */ UINT32 subCapSize, /* in */ BYTE * subCap, /* in */ UINT32 valueSize, /* in */ BYTE * value, /* in */ TPM_AUTH *ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_SetCapability_TP(entry, capArea, subCapSize, subCap, valueSize, value, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetCapability(TSS_HCONTEXT tspContext, /* in */ TCPA_CAPABILITY_AREA capArea, /* in */ UINT32 subCapSize, /* in */ BYTE * subCap, /* in */ UINT32 * respSize, /* out */ BYTE ** resp) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetCapability_TP(entry, capArea, subCapSize, subCap, respSize, resp); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetCapabilitySigned(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TCPA_NONCE antiReplay, /* in */ TCPA_CAPABILITY_AREA capArea, /* in */ UINT32 subCapSize, /* in */ BYTE * subCap, /* in */ TPM_AUTH * privAuth, /* in, out */ TCPA_VERSION * Version, /* out */ UINT32 * respSize, /* out */ BYTE ** resp, /* out */ UINT32 * sigSize, /* out */ BYTE ** sig) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetCapabilitySigned_TP(entry, keyHandle, antiReplay, capArea, subCapSize, subCap, privAuth, Version, respSize, resp, sigSize, sig); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetCapabilityOwner(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH * pOwnerAuth, /* out */ TCPA_VERSION * pVersion, /* out */ UINT32 * pNonVolatileFlags, /* out */ UINT32 * pVolatileFlags) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetCapabilityOwner_TP(entry, pOwnerAuth, pVersion, pNonVolatileFlags, pVolatileFlags); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CreateEndorsementKeyPair(TSS_HCONTEXT tspContext, /* in */ TCPA_NONCE antiReplay, /* in */ UINT32 endorsementKeyInfoSize, /* in */ BYTE * endorsementKeyInfo, /* in */ UINT32 * endorsementKeySize, /* out */ BYTE ** endorsementKey, /* out */ TCPA_DIGEST * checksum) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CreateEndorsementKeyPair_TP(entry, antiReplay, endorsementKeyInfoSize, endorsementKeyInfo, endorsementKeySize, endorsementKey, checksum); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ReadPubek(TSS_HCONTEXT tspContext, /* in */ TCPA_NONCE antiReplay, /* in */ UINT32 * pubEndorsementKeySize, /* out */ BYTE ** pubEndorsementKey, /* out */ TCPA_DIGEST * checksum) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ReadPubek_TP(entry, antiReplay, pubEndorsementKeySize, pubEndorsementKey, checksum); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_DisablePubekRead(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DisablePubekRead_TP(entry, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_OwnerReadPubek(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH * ownerAuth, /* in, out */ UINT32 * pubEndorsementKeySize, /* out */ BYTE ** pubEndorsementKey) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_OwnerReadPubek_TP(entry, ownerAuth, pubEndorsementKeySize, pubEndorsementKey); break; default: break; } put_table_entry(entry); return result; } #ifdef TSS_BUILD_TSS12 TSS_RESULT RPC_CreateRevocableEndorsementKeyPair(TSS_HCONTEXT tspContext, /* in */ TPM_NONCE antiReplay, /* in */ UINT32 endorsementKeyInfoSize,/* in */ BYTE * endorsementKeyInfo, /* in */ TSS_BOOL genResetAuth, /* in */ TPM_DIGEST * eKResetAuth, /* in, out */ UINT32 * endorsementKeySize, /* out */ BYTE ** endorsementKey, /* out */ TPM_DIGEST * checksum) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CreateRevocableEndorsementKeyPair_TP(entry, antiReplay, endorsementKeyInfoSize, endorsementKeyInfo, genResetAuth, eKResetAuth, endorsementKeySize, endorsementKey, checksum); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_RevokeEndorsementKeyPair(TSS_HCONTEXT tspContext, /* in */ TPM_DIGEST *EKResetAuth) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_RevokeEndorsementKeyPair_TP(entry, EKResetAuth); break; default: break; } put_table_entry(entry); return result; } #endif TSS_RESULT RPC_SelfTestFull(TSS_HCONTEXT tspContext) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_SelfTestFull_TP(entry); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CertifySelfTest(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TCPA_NONCE antiReplay, /* in */ TPM_AUTH * privAuth, /* in, out */ UINT32 * sigSize, /* out */ BYTE ** sig) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CertifySelfTest_TP(entry, keyHandle, antiReplay, privAuth, sigSize, sig); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetTestResult(TSS_HCONTEXT tspContext, /* in */ UINT32 * outDataSize, /* out */ BYTE ** outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetTestResult_TP(entry, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_OwnerSetDisable(TSS_HCONTEXT tspContext, /* in */ TSS_BOOL disableState, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_OwnerSetDisable_TP(entry, disableState, ownerAuth); break; default: break; } put_table_entry(entry); return result; } #ifdef TSS_BUILD_TSS12 TSS_RESULT RPC_ResetLockValue(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ResetLockValue_TP(entry, ownerAuth); break; default: break; } put_table_entry(entry); return result; } #endif TSS_RESULT RPC_OwnerClear(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_OwnerClear_TP(entry, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_DisableOwnerClear(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DisableOwnerClear_TP(entry, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ForceClear(TSS_HCONTEXT tspContext) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ForceClear_TP(entry); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_DisableForceClear(TSS_HCONTEXT tspContext) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DisableForceClear_TP(entry); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_PhysicalDisable(TSS_HCONTEXT tspContext) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_PhysicalDisable_TP(entry); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_PhysicalEnable(TSS_HCONTEXT tspContext) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_PhysicalEnable_TP(entry); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_PhysicalSetDeactivated(TSS_HCONTEXT tspContext, /* in */ TSS_BOOL state) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_PhysicalSetDeactivated_TP(entry, state); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_PhysicalPresence(TSS_HCONTEXT tspContext, /* in */ TCPA_PHYSICAL_PRESENCE fPhysicalPresence) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_PhysicalPresence_TP(entry, fPhysicalPresence); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_SetTempDeactivated(TSS_HCONTEXT tspContext) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_SetTempDeactivated_TP(entry); break; default: break; } put_table_entry(entry); return result; } #ifdef TSS_BUILD_TSS12 TSS_RESULT RPC_SetTempDeactivated2(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH *operatorAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_SetTempDeactivated2_TP(entry, operatorAuth); break; default: break; } put_table_entry(entry); return result; } #endif TSS_RESULT RPC_FieldUpgrade(TSS_HCONTEXT tspContext, /* in */ UINT32 dataInSize, /* in */ BYTE * dataIn, /* in */ UINT32 * dataOutSize, /* out */ BYTE ** dataOut, /* out */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = (UINT32) TSPERR(TSS_E_INTERNAL_ERROR); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_SetRedirection(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ UINT32 c1, /* in */ UINT32 c2, /* in */ TPM_AUTH * privAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = (UINT32) TSPERR(TSS_E_INTERNAL_ERROR); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CreateMaintenanceArchive(TSS_HCONTEXT tspContext, /* in */ TSS_BOOL generateRandom, /* in */ TPM_AUTH * ownerAuth, /* in, out */ UINT32 * randomSize, /* out */ BYTE ** random, /* out */ UINT32 * archiveSize, /* out */ BYTE ** archive) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CreateMaintenanceArchive_TP(entry, generateRandom, ownerAuth, randomSize, random, archiveSize, archive); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_LoadMaintenanceArchive(TSS_HCONTEXT tspContext, /* in */ UINT32 dataInSize, /* in */ BYTE * dataIn, /* in */ TPM_AUTH * ownerAuth, /* in, out */ UINT32 * dataOutSize, /* out */ BYTE ** dataOut) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_LoadMaintenanceArchive_TP(entry, dataInSize, dataIn, ownerAuth, dataOutSize, dataOut); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_KillMaintenanceFeature(TSS_HCONTEXT tspContext, /* in */ TPM_AUTH * ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_KillMaintenanceFeature_TP(entry, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_LoadManuMaintPub(TSS_HCONTEXT tspContext, /* in */ TCPA_NONCE antiReplay, /* in */ UINT32 PubKeySize, /* in */ BYTE * PubKey, /* in */ TCPA_DIGEST * checksum) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_LoadManuMaintPub_TP(entry, antiReplay, PubKeySize, PubKey, checksum); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ReadManuMaintPub(TSS_HCONTEXT tspContext, /* in */ TCPA_NONCE antiReplay, /* in */ TCPA_DIGEST * checksum) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ReadManuMaintPub_TP(entry, antiReplay, checksum); break; default: break; } put_table_entry(entry); return result; } #ifdef TSS_BUILD_DAA TSS_RESULT RPC_DaaJoin(TSS_HCONTEXT tspContext, /* in */ TPM_HANDLE daa_session, /* in */ BYTE stage, /* in */ UINT32 inputSize0, /* in */ BYTE* inputData0, /* in */ UINT32 inputSize1, /* in */ BYTE* inputData1, /* in */ TPM_AUTH* ownerAuth, /* in, out */ UINT32* outputSize, /* out */ BYTE** outputData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DaaJoin_TP(entry, daa_session, stage, inputSize0, inputData0, inputSize1, inputData1, ownerAuth, outputSize, outputData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_DaaSign(TSS_HCONTEXT tspContext, /* in */ TPM_HANDLE daa_session, /* in */ BYTE stage, /* in */ UINT32 inputSize0, /* in */ BYTE* inputData0, /* in */ UINT32 inputSize1, /* in */ BYTE* inputData1, /* in */ TPM_AUTH* ownerAuth, /* in, out */ UINT32* outputSize, /* out */ BYTE** outputData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DaaSign_TP(entry, daa_session, stage, inputSize0, inputData0, inputSize1, inputData1, ownerAuth, outputSize, outputData); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_COUNTER TSS_RESULT RPC_ReadCounter(TSS_HCONTEXT tspContext, /* in */ TSS_COUNTER_ID idCounter, /* in */ TPM_COUNTER_VALUE* counterValue) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ReadCounter_TP(entry, idCounter, counterValue); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CreateCounter(TSS_HCONTEXT tspContext, /* in */ UINT32 LabelSize, /* in (=4) */ BYTE* pLabel, /* in */ TPM_ENCAUTH CounterAuth, /* in */ TPM_AUTH* pOwnerAuth, /* in, out */ TSS_COUNTER_ID* idCounter, /* out */ TPM_COUNTER_VALUE* counterValue) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CreateCounter_TP(entry, LabelSize, pLabel, CounterAuth, pOwnerAuth, idCounter, counterValue); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_IncrementCounter(TSS_HCONTEXT tspContext, /* in */ TSS_COUNTER_ID idCounter, /* in */ TPM_AUTH* pCounterAuth, /* in, out */ TPM_COUNTER_VALUE* counterValue) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_IncrementCounter_TP(entry, idCounter, pCounterAuth, counterValue); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ReleaseCounter(TSS_HCONTEXT tspContext, /* in */ TSS_COUNTER_ID idCounter, /* in */ TPM_AUTH* pCounterAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ReleaseCounter_TP(entry, idCounter, pCounterAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ReleaseCounterOwner(TSS_HCONTEXT tspContext, /* in */ TSS_COUNTER_ID idCounter, /* in */ TPM_AUTH* pOwnerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ReleaseCounterOwner_TP(entry, idCounter, pOwnerAuth); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_TICK TSS_RESULT RPC_ReadCurrentTicks(TSS_HCONTEXT tspContext, /* in */ UINT32* pulCurrentTime, /* out */ BYTE** prgbCurrentTime) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ReadCurrentTicks_TP(entry, pulCurrentTime, prgbCurrentTime); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_TickStampBlob(TSS_HCONTEXT tspContext, /* in */ TCS_KEY_HANDLE hKey, /* in */ TPM_NONCE* antiReplay, /* in */ TPM_DIGEST* digestToStamp, /* in */ TPM_AUTH* privAuth, /* in, out */ UINT32* pulSignatureLength, /* out */ BYTE** prgbSignature, /* out */ UINT32* pulTickCountLength, /* out */ BYTE** prgbTickCount) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_TickStampBlob_TP(entry, hKey, antiReplay, digestToStamp, privAuth, pulSignatureLength, prgbSignature, pulTickCountLength, prgbTickCount); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_TRANSPORT TSS_RESULT RPC_EstablishTransport(TSS_HCONTEXT tspContext, UINT32 ulTransControlFlags, TCS_KEY_HANDLE hEncKey, UINT32 ulTransSessionInfoSize, BYTE* rgbTransSessionInfo, UINT32 ulSecretSize, BYTE* rgbSecret, TPM_AUTH* pEncKeyAuth, /* in, out */ TPM_MODIFIER_INDICATOR* pbLocality, TCS_HANDLE* hTransSession, UINT32* ulCurrentTicksSize, BYTE** prgbCurrentTicks, TPM_NONCE* pTransNonce) { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_EstablishTransport_TP(entry, ulTransControlFlags, hEncKey, ulTransSessionInfoSize, rgbTransSessionInfo, ulSecretSize, rgbSecret, pEncKeyAuth, pbLocality, hTransSession, ulCurrentTicksSize, prgbCurrentTicks, pTransNonce); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ExecuteTransport(TSS_HCONTEXT tspContext, TPM_COMMAND_CODE unWrappedCommandOrdinal, UINT32 ulWrappedCmdParamInSize, BYTE* rgbWrappedCmdParamIn, UINT32* pulHandleListSize, /* in, out */ TCS_HANDLE** rghHandles, /* in, out */ TPM_AUTH* pWrappedCmdAuth1, /* in, out */ TPM_AUTH* pWrappedCmdAuth2, /* in, out */ TPM_AUTH* pTransAuth, /* in, out */ UINT64* punCurrentTicks, TPM_MODIFIER_INDICATOR* pbLocality, TPM_RESULT* pulWrappedCmdReturnCode, UINT32* ulWrappedCmdParamOutSize, BYTE** rgbWrappedCmdParamOut) { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ExecuteTransport_TP(entry, unWrappedCommandOrdinal, ulWrappedCmdParamInSize, rgbWrappedCmdParamIn, pulHandleListSize, rghHandles, pWrappedCmdAuth1, pWrappedCmdAuth2, pTransAuth, punCurrentTicks, pbLocality, pulWrappedCmdReturnCode, ulWrappedCmdParamOutSize, rgbWrappedCmdParamOut); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_ReleaseTransportSigned(TSS_HCONTEXT tspContext, TCS_KEY_HANDLE hSignatureKey, TPM_NONCE* AntiReplayNonce, TPM_AUTH* pKeyAuth, /* in, out */ TPM_AUTH* pTransAuth, /* in, out */ TPM_MODIFIER_INDICATOR* pbLocality, UINT32* pulCurrentTicksSize, BYTE** prgbCurrentTicks, UINT32* pulSignatureSize, BYTE** prgbSignature) { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(tspContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_ReleaseTransportSigned_TP(entry, hSignatureKey, AntiReplayNonce, pKeyAuth, pTransAuth, pbLocality, pulCurrentTicksSize, prgbCurrentTicks, pulSignatureSize, prgbSignature); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_NV TSS_RESULT RPC_NV_DefineOrReleaseSpace(TSS_HCONTEXT hContext, /* in */ UINT32 cPubInfoSize, /* in */ BYTE* pPubInfo, /* in */ TCPA_ENCAUTH encAuth, /* in */ TPM_AUTH* pAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_NV_DefineOrReleaseSpace_TP(entry, cPubInfoSize, pPubInfo, encAuth, pAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_NV_WriteValue(TSS_HCONTEXT hContext, /* in */ TSS_NV_INDEX hNVStore, /* in */ UINT32 offset, /* in */ UINT32 ulDataLength, /* in */ BYTE* rgbDataToWrite, /* in */ TPM_AUTH* privAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_NV_WriteValue_TP(entry, hNVStore, offset, ulDataLength, rgbDataToWrite, privAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_NV_WriteValueAuth(TSS_HCONTEXT hContext, /* in */ TSS_NV_INDEX hNVStore, /* in */ UINT32 offset, /* in */ UINT32 ulDataLength, /* in */ BYTE* rgbDataToWrite, /* in */ TPM_AUTH* NVAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_NV_WriteValueAuth_TP(entry, hNVStore, offset, ulDataLength, rgbDataToWrite, NVAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_NV_ReadValue(TSS_HCONTEXT hContext, /* in */ TSS_NV_INDEX hNVStore, /* in */ UINT32 offset, /* in */ UINT32* pulDataLength, /* in, out */ TPM_AUTH* privAuth, /* in, out */ BYTE** rgbDataRead) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_NV_ReadValue_TP(entry, hNVStore, offset, pulDataLength, privAuth, rgbDataRead); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_NV_ReadValueAuth(TSS_HCONTEXT hContext, /* in */ TSS_NV_INDEX hNVStore, /* in */ UINT32 offset, /* in */ UINT32* pulDataLength, /* in, out */ TPM_AUTH* NVAuth, /* in, out */ BYTE** rgbDataRead) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_NV_ReadValueAuth_TP(entry, hNVStore, offset, pulDataLength, NVAuth, rgbDataRead); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_AUDIT TSS_RESULT RPC_SetOrdinalAuditStatus(TSS_HCONTEXT hContext, /* in */ TPM_AUTH *ownerAuth, /* in/out */ UINT32 ulOrdinal, /* in */ TSS_BOOL bAuditState) /* in */ { TSS_RESULT result = TSS_SUCCESS; struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_SetOrdinalAuditStatus_TP(entry, ownerAuth, ulOrdinal, bAuditState); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetAuditDigest(TSS_HCONTEXT hContext, /* in */ UINT32 startOrdinal, /* in */ TPM_DIGEST *auditDigest, /* out */ UINT32 *counterValueSize, /* out */ BYTE **counterValue, /* out */ TSS_BOOL *more, /* out */ UINT32 *ordSize, /* out */ UINT32 **ordList) /* out */ { TSS_RESULT result = TSS_SUCCESS; struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetAuditDigest_TP(entry, startOrdinal, auditDigest, counterValueSize, counterValue, more, ordSize, ordList); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_GetAuditDigestSigned(TSS_HCONTEXT hContext, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TSS_BOOL closeAudit, /* in */ TPM_NONCE *antiReplay, /* in */ TPM_AUTH *privAuth, /* in/out */ UINT32 *counterValueSize, /* out */ BYTE **counterValue, /* out */ TPM_DIGEST *auditDigest, /* out */ TPM_DIGEST *ordinalDigest, /* out */ UINT32 *sigSize, /* out */ BYTE **sig) /* out */ { TSS_RESULT result = TSS_SUCCESS; struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_GetAuditDigestSigned_TP(entry, keyHandle, closeAudit, antiReplay, privAuth, counterValueSize, counterValue, auditDigest, ordinalDigest, sigSize, sig); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_TSS12 TSS_RESULT RPC_SetOperatorAuth(TSS_HCONTEXT hContext, /* in */ TCPA_SECRET *operatorAuth) /* in */ { TSS_RESULT result = TSS_SUCCESS; struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_SetOperatorAuth_TP(entry, operatorAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_OwnerReadInternalPub(TSS_HCONTEXT hContext, /* in */ TCS_KEY_HANDLE hKey, /* in */ TPM_AUTH* pOwnerAuth, /* in, out */ UINT32* punPubKeySize, /* out */ BYTE** ppbPubKeyData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_OwnerReadInternalPub_TP(entry, hKey, pOwnerAuth, punPubKeySize, ppbPubKeyData); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_DELEGATION TSS_RESULT RPC_Delegate_Manage(TSS_HCONTEXT hContext, /* in */ TPM_FAMILY_ID familyID, /* in */ TPM_FAMILY_OPERATION opFlag, /* in */ UINT32 opDataSize, /* in */ BYTE *opData, /* in */ TPM_AUTH *ownerAuth, /* in, out */ UINT32 *retDataSize, /* out */ BYTE **retData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Delegate_Manage_TP(entry, familyID, opFlag, opDataSize, opData, ownerAuth, retDataSize, retData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Delegate_CreateKeyDelegation(TSS_HCONTEXT hContext, /* in */ TCS_KEY_HANDLE hKey, /* in */ UINT32 publicInfoSize, /* in */ BYTE *publicInfo, /* in */ TPM_ENCAUTH *encDelAuth, /* in */ TPM_AUTH *keyAuth, /* in, out */ UINT32 *blobSize, /* out */ BYTE **blob) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Delegate_CreateKeyDelegation_TP(entry, hKey, publicInfoSize, publicInfo, encDelAuth, keyAuth, blobSize, blob); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Delegate_CreateOwnerDelegation(TSS_HCONTEXT hContext, /* in */ TSS_BOOL increment, /* in */ UINT32 publicInfoSize, /* in */ BYTE *publicInfo, /* in */ TPM_ENCAUTH *encDelAuth, /* in */ TPM_AUTH *ownerAuth, /* in, out */ UINT32 *blobSize, /* out */ BYTE **blob) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Delegate_CreateOwnerDelegation_TP(entry, increment, publicInfoSize, publicInfo, encDelAuth, ownerAuth, blobSize, blob); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Delegate_LoadOwnerDelegation(TSS_HCONTEXT hContext, /* in */ TPM_DELEGATE_INDEX index, /* in */ UINT32 blobSize, /* in */ BYTE *blob, /* in */ TPM_AUTH *ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Delegate_LoadOwnerDelegation_TP(entry, index, blobSize, blob, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Delegate_ReadTable(TSS_HCONTEXT hContext, /* in */ UINT32 *familyTableSize, /* out */ BYTE **familyTable, /* out */ UINT32 *delegateTableSize, /* out */ BYTE **delegateTable) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Delegate_ReadTable_TP(entry, familyTableSize, familyTable, delegateTableSize, delegateTable); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Delegate_UpdateVerificationCount(TSS_HCONTEXT hContext, /* in */ UINT32 inputSize, /* in */ BYTE *input, /* in */ TPM_AUTH *ownerAuth, /* in, out */ UINT32 *outputSize, /* out */ BYTE **output) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Delegate_UpdateVerificationCount_TP(entry, inputSize, input, ownerAuth, outputSize, output); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_Delegate_VerifyDelegation(TSS_HCONTEXT hContext, /* in */ UINT32 delegateSize, /* in */ BYTE *delegate) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_Delegate_VerifyDelegation_TP(entry, delegateSize, delegate); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_DSAP(TSS_HCONTEXT hContext, /* in */ TPM_ENTITY_TYPE entityType, /* in */ TCS_KEY_HANDLE keyHandle, /* in */ TPM_NONCE *nonceOddDSAP, /* in */ UINT32 entityValueSize, /* in */ BYTE * entityValue, /* in */ TCS_AUTHHANDLE *authHandle, /* out */ TPM_NONCE *nonceEven, /* out */ TPM_NONCE *nonceEvenDSAP) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_DSAP_TP(entry, entityType, keyHandle, nonceOddDSAP, entityValueSize, entityValue, authHandle, nonceEven, nonceEvenDSAP); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_CMK TSS_RESULT RPC_CMK_SetRestrictions(TSS_HCONTEXT hContext, /* in */ TSS_CMK_DELEGATE restriction, /* in */ TPM_AUTH *ownerAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CMK_SetRestrictions_TP(entry, restriction, ownerAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CMK_ApproveMA(TSS_HCONTEXT hContext, /* in */ TPM_DIGEST migAuthorityDigest, /* in */ TPM_AUTH *ownerAuth, /* in, out */ TPM_HMAC *migAuthorityApproval) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CMK_ApproveMA_TP(entry, migAuthorityDigest, ownerAuth, migAuthorityApproval); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CMK_CreateKey(TSS_HCONTEXT hContext, /* in */ TCS_KEY_HANDLE hWrappingKey, /* in */ TPM_ENCAUTH *keyUsageAuth, /* in */ TPM_HMAC *migAuthorityApproval, /* in */ TPM_DIGEST *migAuthorityDigest, /* in */ UINT32 *keyDataSize, /* in, out */ BYTE **keyData, /* in, out */ TPM_AUTH *pAuth) /* in, out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CMK_CreateKey_TP(entry, hWrappingKey, keyUsageAuth, migAuthorityApproval, migAuthorityDigest, keyDataSize, keyData, pAuth); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CMK_CreateTicket(TSS_HCONTEXT hContext, /* in */ UINT32 publicVerifyKeySize, /* in */ BYTE *publicVerifyKey, /* in */ TPM_DIGEST signedData, /* in */ UINT32 sigValueSize, /* in */ BYTE *sigValue, /* in */ TPM_AUTH *ownerAuth, /* in, out */ TPM_HMAC *sigTicket) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CMK_CreateTicket_TP(entry, publicVerifyKeySize, publicVerifyKey, signedData, sigValueSize, sigValue, ownerAuth, sigTicket); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CMK_CreateBlob(TSS_HCONTEXT hContext, /* in */ TCS_KEY_HANDLE hParentKey, /* in */ TSS_MIGRATE_SCHEME migrationType, /* in */ UINT32 migKeyAuthSize, /* in */ BYTE *migKeyAuth, /* in */ TPM_DIGEST pubSourceKeyDigest, /* in */ UINT32 msaListSize, /* in */ BYTE *msaList, /* in */ UINT32 restrictTicketSize, /* in */ BYTE *restrictTicket, /* in */ UINT32 sigTicketSize, /* in */ BYTE *sigTicket, /* in */ UINT32 encDataSize, /* in */ BYTE *encData, /* in */ TPM_AUTH *pAuth, /* in, out */ UINT32 *randomSize, /* out */ BYTE **random, /* out */ UINT32 *outDataSize, /* out */ BYTE **outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CMK_CreateBlob_TP(entry, hParentKey, migrationType, migKeyAuthSize, migKeyAuth, pubSourceKeyDigest, msaListSize, msaList, restrictTicketSize, restrictTicket, sigTicketSize, sigTicket, encDataSize, encData, pAuth, randomSize, random, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_CMK_ConvertMigration(TSS_HCONTEXT hContext, /* in */ TCS_KEY_HANDLE hParentHandle, /* in */ TPM_CMK_AUTH restrictTicket, /* in */ TPM_HMAC sigTicket, /* in */ UINT32 keyDataSize, /* in */ BYTE *keyData, /* in */ UINT32 msaListSize, /* in */ BYTE *msaList, /* in */ UINT32 randomSize, /* in */ BYTE *random, /* in */ TPM_AUTH *pAuth, /* in, out */ UINT32 *outDataSize, /* out */ BYTE **outData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_CMK_ConvertMigration_TP(entry, hParentHandle, restrictTicket, sigTicket, keyDataSize, keyData, msaListSize, msaList, randomSize, random, pAuth, outDataSize, outData); break; default: break; } put_table_entry(entry); return result; } #endif #ifdef TSS_BUILD_TSS12 TSS_RESULT RPC_FlushSpecific(TSS_HCONTEXT hContext, /* in */ TCS_HANDLE hResHandle, /* in */ TPM_RESOURCE_TYPE resourceType) /* in */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_FlushSpecific_TP(entry, hResHandle, resourceType); break; default: break; } put_table_entry(entry); return result; } TSS_RESULT RPC_KeyControlOwner(TCS_CONTEXT_HANDLE hContext, /* in */ TCS_KEY_HANDLE hKey, /* in */ UINT32 ulPublicInfoLength, /* in */ BYTE* rgbPublicInfo, /* in */ UINT32 attribName, /* in */ TSS_BOOL attribValue, /* in */ TPM_AUTH* pOwnerAuth, /* in, out */ TSS_UUID* pUuidData) /* out */ { TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); struct host_table_entry *entry = get_table_entry(hContext); if (entry == NULL) return TSPERR(TSS_E_NO_CONNECTION); switch (entry->type) { case CONNECTION_TYPE_TCP_PERSISTANT: result = RPC_KeyControlOwner_TP(entry, hKey, ulPublicInfoLength, rgbPublicInfo, attribName, attribValue, pOwnerAuth, pUuidData); break; default: break; } put_table_entry(entry); return result; } #endif