tcs_api.c

TCG软件栈 linux系统上使用 为可信应用软件提供和 TPM通信的 接口 其网站上有很多关于使用此软件的测试用例

/*
 * 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_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;

	/* 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 */