tcs_api.c

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

			    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 = 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_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;
}

TSS_RESULT RPC_GetCredential(TSS_HCONTEXT tspContext,	/* in */
			     UINT32 ulCredentialType,          /* in */
			     UINT32 ulCredentialAccessMode,    /* in */
			     UINT32 * pulCredentialSize,       /* out */
			     BYTE ** prgbCredentialData)	/* 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_GetCredential_TP(entry, ulCredentialType,
						      ulCredentialAccessMode, pulCredentialSize,
						      prgbCredentialData);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

TSS_RESULT RPC_SetOwnerInstall(TSS_HCONTEXT tspContext,	/* in */
			       TSS_BOOL state)	/* 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_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 = 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_Quote_TP(entry, keyHandle, antiReplay, pcrDataSizeIn,
					      pcrDataIn, privAuth, pcrDataSizeOut, pcrDataOut,
					      sigSize, sig);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

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 = 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_Quote2_TP(entry, keyHandle, antiReplay, pcrDataSizeIn, pcrDataIn,
				       addVersion,privAuth, pcrDataSizeOut, pcrDataOut,
				       versionInfoSize, versionInfo,sigSize, sig);
		break;
	default:
		break;
	}

	put_table_entry(entry);

	return result;
}

TSS_RESULT RPC_DirWriteAuth(TSS_HCONTEXT tspContext,	/* in */
			    TCPA_DIRINDEX dirIndex,	/* in */
			    TCPA_DIRVALUE *newContents,	/* 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_DirWriteAuth_TP(entry, dirIndex, newContents, ownerAuth);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

TSS_RESULT RPC_DirRead(TSS_HCONTEXT tspContext,	/* in */