tcs_api.c

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

	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 = 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_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 = 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_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 = 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_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 = 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_ReadManuMaintPub_TP(entry, antiReplay, checksum);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

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 = 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_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 = 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_DaaSign_TP(entry, daa_session, stage, inputSize0, inputData0,
						inputSize1, inputData1, ownerAuth, outputSize,
						outputData);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

TSS_RESULT
RPC_ReadCounter(TSS_HCONTEXT       tspContext,		/* in */
		TSS_COUNTER_ID     idCounter,		/* in */
		TPM_COUNTER_VALUE* counterValue)	/* 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_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 = 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_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 = 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_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 = 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_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 = 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_ReleaseCounterOwner_TP(entry, idCounter, pOwnerAuth);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

TSS_RESULT
RPC_ReadCurrentTicks(TSS_HCONTEXT tspContext,		/* in */
		     UINT32*      pulCurrentTime,	/* out */
		     BYTE**       prgbCurrentTime)	/* 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_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 = 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_TickStampBlob_TP(entry, hKey, antiReplay, digestToStamp,
						      privAuth, pulSignatureLength,
						      prgbSignature, pulTickCountLength,
						      prgbTickCount);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}


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 = 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_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 = 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_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 = 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_ReleaseTransportSigned_TP(entry, hSignatureKey,
							       AntiReplayNonce, pKeyAuth,
							       pTransAuth, pbLocality,
							       pulCurrentTicksSize,
							       prgbCurrentTicks, pulSignatureSize,
							       prgbSignature);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

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 = TSPERR(TSS_E_INTERNAL_ERROR);
	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 */