tcs_api.c

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

		       TCPA_DIRINDEX dirIndex,	/* in */
		       TCPA_DIRVALUE * dirValue)	/* 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_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 = 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_Seal_TP(entry, keyHandle, encAuth, pcrInfoSize, PcrInfo,
					     inDataSize, inData, pubAuth, SealedDataSize,
					     SealedData);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

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 = 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_Sealx_TP(entry, keyHandle, encAuth, pcrInfoSize, PcrInfo,
					      inDataSize, inData, pubAuth, SealedDataSize,
					      SealedData);
			break;
		default:
			break;
	}

	put_table_entry(entry);

	return result;
}

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