/* * Licensed Materials - Property of IBM * * trousers - An open source TCG Software Stack * * (C) Copyright International Business Machines Corp. 2004, 2007 * */#include <stdlib.h>#include <syslog.h>#include <unistd.h>#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_RESULTRPC_Error(TSS_HCONTEXT tspContext, ...){	LogDebugFn("Context: 0x%x", tspContext);	return TSPERR(TSS_E_INTERNAL_ERROR);}TSS_RESULTRPC_OpenContext(TSS_HCONTEXT tspContext, BYTE *hostname, int type){	TSS_RESULT result;	TCS_CONTEXT_HANDLE tcsContext;	struct host_table_entry *entry;	UINT32 tpm_version;	/* add_table_entry() will make sure an entry doesn't already exist for this tsp context */	if ((result = 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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 = TSPERR(TSS_E_INTERNAL_ERROR);	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 */