tcs.c

xen虚拟机源代码安装包

  
  // setup the TPM driver input and output buffers
  TDDL_RESULT hRes = TDDL_E_FAIL;
  TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH;
  TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH;
  
  // check input params
  if (encOwnerAuth == NULL || encSrkAuth == NULL || SrkSize == NULL || *Srk == NULL) 
    return TPM_BAD_PARAMETER;
  
  // Convert Byte Input parameter in the input byte stream InBuf
  InLength = BSG_PackList(InBuf, 5, 
			  BSG_TPM_TAG, &tag, 
			  BSG_TYPE_UINT32, &paramSize, 
			  BSG_TPM_COMMAND_CODE, &ordinal, 
			  BSG_TYPE_UINT16, &protocolID, 
			  BSG_TYPE_UINT32, &encOwnerAuthSize);
  
  memcpy(InBuf+InLength, encOwnerAuth, encOwnerAuthSize);
  InLength += encOwnerAuthSize;
  InLength += BSG_Pack(   BSG_TYPE_UINT32, 
			  &encSrkAuthSize, 
			  InBuf+InLength);
  memcpy(InBuf+InLength, encSrkAuth, encSrkAuthSize);
  InLength += encSrkAuthSize;
  memcpy(InBuf+InLength, *Srk, *SrkSize);
  InLength += *SrkSize;
  InLength += packAuth(InBuf+InLength, ownerAuth);
  // fill paramSize again as we now have the correct size
  BSG_Pack(BSG_TYPE_UINT32, 
	   &InLength, 
	   InBuf+2);
  
  vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength);
  
  // call the TPM driver
  if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) 
              == TDDL_SUCCESS){
    
    // unpack to get the tag, paramSize, & returnCode
    int i = BSG_UnpackList( OutBuf, 3, 
			    BSG_TPM_TAG, &tag, 
			    BSG_TYPE_UINT32, &paramSize, 
			    BSG_TPM_COMMAND_CODE, &returnCode);
    
    if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) {
      // Extract the remaining output parameters
      TPM_KEY srkPub;
      i += BSG_Unpack(BSG_TPM_KEY,  OutBuf+i,  &srkPub); 
      unpackAuth(ownerAuth, OutBuf+i);
      
      // fill output params
      BYTE tempBuf[1024];
      *SrkSize = BSG_Pack(BSG_TPM_KEY,  &srkPub, tempBuf);
      if (TCS_Malloc(hContext, *SrkSize, Srk) == TPM_FAIL) {
	return(TPM_SIZE);
      }
      memcpy(*Srk, tempBuf, *SrkSize);
      
      vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize);
    } else 
      vtpmlogerror(VTPM_LOG_TCS, "TCSP_TakeOwnership Failed with return code %s\n", tpm_get_error_name(returnCode));
  }
  
  return(returnCode);
}


TPM_RESULT TCSP_DisablePubekRead (  TCS_CONTEXT_HANDLE hContext, // in
                                    TCS_AUTH*   ownerAuth) { // in, out
 
  // setup input/output parameters block
  TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND;
  UINT32 paramSize = 0;
  TPM_COMMAND_CODE ordinal = TPM_ORD_DisablePubekRead;
  TPM_RESULT returnCode = TPM_SUCCESS;
  
  // setup the TPM driver input and output buffers
  TDDL_RESULT hRes = TDDL_E_FAIL;
  TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH;
  TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH;
    
  // Convert Byte Input parameter in the input byte stream InBuf
  InLength = BSG_PackList(InBuf, 3, 
			  BSG_TPM_TAG, &tag, 
			  BSG_TYPE_UINT32, &paramSize, 
			  BSG_TPM_COMMAND_CODE, &ordinal);
  
  InLength += packAuth(InBuf+InLength, ownerAuth);
 
  // fill paramSize again as we now have the correct size
  BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2);
  
  vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength);
  
  // call the TPM driver
  if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) 
              == TDDL_SUCCESS){
    
    // unpack to get the tag, paramSize, & returnCode
    int i = BSG_UnpackList( OutBuf, 3, 
			    BSG_TPM_TAG, &tag, 
			    BSG_TYPE_UINT32, &paramSize, 
			    BSG_TPM_COMMAND_CODE, &returnCode);
    
    if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) {
      // Extract the remaining output parameters
      unpackAuth(ownerAuth, OutBuf+i);
    } else 
      vtpmlogerror(VTPM_LOG_TCS, "TCSP_DisablePubekRead Failed with return code %s\n", tpm_get_error_name(returnCode));
  }
  
  return(returnCode);
}


TPM_RESULT TCSP_TerminateHandle(TCS_CONTEXT_HANDLE hContext, // in
                                TCS_AUTHHANDLE  handle)  // in
{
  // setup input/output parameters block
  TPM_TAG tag = TPM_TAG_RQU_COMMAND;
  UINT32 paramSize = 0;
  TPM_COMMAND_CODE ordinal = TPM_ORD_Terminate_Handle;
  TPM_RESULT returnCode = TPM_SUCCESS;
  
  // setup the TPM driver input and output buffers
  TDDL_RESULT hRes = TDDL_E_FAIL;
  TDDL_UINT32  InLength = TCPA_MAX_BUFFER_LENGTH;
  TDDL_UINT32  OutLength = TCPA_MAX_BUFFER_LENGTH;
  
  // Convert Byte Input parameter in the input byte stream InBuf
  InLength = BSG_PackList(InBuf, 4, 
			  BSG_TPM_TAG, &tag, 
			  BSG_TYPE_UINT32, &paramSize, 
			  BSG_TPM_COMMAND_CODE, &ordinal, 
			  BSG_TYPE_UINT32, &handle);
  // fill paramSize again as we now have the correct size
  BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2);
  
  // call the TPM driver
  if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) 
              == TDDL_SUCCESS) {
    
    // unpack to get the tag, paramSize, & returnCode
    BSG_UnpackList(OutBuf, 3, 
			   BSG_TPM_TAG, &tag, 
			   BSG_TYPE_UINT32, &paramSize, 
			   BSG_TPM_COMMAND_CODE, &returnCode);
    
    if (!DeleteHandleFromList(hContext, handle)) 
      vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n");
       
    
    if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) {
      // Print debug info
      
      vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize);
    } else 
      vtpmlogerror(VTPM_LOG_TCS, "TCSP_TerminateHandle Failed with return code %s\n", tpm_get_error_name(returnCode));
    
  }
  
  return(returnCode);
}

// TPM Mandatory
TPM_RESULT TCSP_Extend( TCS_CONTEXT_HANDLE hContext, // in
                        TPM_PCRINDEX  pcrNum,  // in
                        TPM_DIGEST  inDigest, // in
                        TPM_PCRVALUE*  outDigest) // out
{
  // setup input/output parameters block
  TPM_TAG tag = TPM_TAG_RQU_COMMAND;
  UINT32 paramSize = 0;
  TPM_COMMAND_CODE ordinal = TPM_ORD_Extend;
  TPM_RESULT returnCode = TPM_SUCCESS;
  
  // setup the TPM driver input and output buffers
  TDDL_RESULT hRes = TDDL_E_FAIL;
  TDDL_UINT32  InLength = TCPA_MAX_BUFFER_LENGTH;
  TDDL_UINT32  OutLength = TCPA_MAX_BUFFER_LENGTH;
  
  // Convert Byte Input parameter in the input byte stream InBuf
  InLength = BSG_PackList(InBuf, 5, 
			  BSG_TPM_TAG, &tag, 
			  BSG_TYPE_UINT32, &paramSize, 
			  BSG_TPM_COMMAND_CODE, &ordinal, 
			  BSG_TYPE_UINT32, &pcrNum, 
			  BSG_TPM_DIGEST, &inDigest);
  // fill paramSize again as we now have the correct size
  BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2);
  
  vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength);
  
  // call the TPM driver
  if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) 
              == TDDL_SUCCESS) {
    
    // unpack to get the tag, paramSize, & returnCode
    int i = BSG_UnpackList(OutBuf, 3, 
			   BSG_TPM_TAG, &tag, 
			   BSG_TYPE_UINT32, &paramSize, 
			   BSG_TPM_COMMAND_CODE, &returnCode);
    
    if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND){
      // Extract the remaining output parameters
      BSG_Unpack(BSG_TPM_PCRVALUE, OutBuf+i, outDigest);
      
      vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize);
    } else 
      vtpmlogerror(VTPM_LOG_TCS, "TCSP_Extend Failed with return code %s\n", tpm_get_error_name(returnCode));
  }
  
  return(returnCode);
}

TPM_RESULT TCSP_Seal(   TCS_CONTEXT_HANDLE hContext,  // in
                        TCS_KEY_HANDLE  keyHandle,  // in
                        TPM_ENCAUTH   encAuth,  // in
                        UINT32    pcrInfoSize, // in
                        BYTE*    PcrInfo,  // in
                        UINT32    inDataSize,  // in
                        BYTE*    inData,   // in
                        TCS_AUTH*   pubAuth,  // in, out
                        UINT32*    SealedDataSize, // out
                        BYTE**    SealedData)  // out
{
  // setup input/output parameters block
  TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND;
  UINT32 paramSize = 0;
  TPM_COMMAND_CODE ordinal = TPM_ORD_Seal;
  TPM_RESULT returnCode = TPM_SUCCESS;
  
  // setup the TPM driver input and output buffers
  TDDL_RESULT hRes = TDDL_E_FAIL;
  TDDL_UINT32  InLength = TCPA_MAX_BUFFER_LENGTH;
  TDDL_UINT32  OutLength = TCPA_MAX_BUFFER_LENGTH;
  
  // check input params
  if (inData == NULL || pubAuth == NULL || SealedDataSize == NULL || SealedData == NULL)
    return TPM_BAD_PARAMETER;
  
  // Convert Byte Input parameter in the input byte stream InBuf
  InLength = BSG_PackList(InBuf, 6, 
			  BSG_TPM_TAG, &tag, 
			  BSG_TYPE_UINT32, &paramSize, 
			  BSG_TPM_COMMAND_CODE, &ordinal, 
			  BSG_TYPE_UINT32, &keyHandle, 
			  BSG_TPM_ENCAUTH, encAuth, 
			  BSG_TYPE_UINT32, &pcrInfoSize);
  memcpy(InBuf+InLength, PcrInfo, pcrInfoSize);
  InLength += pcrInfoSize;
  InLength += BSG_Pack(BSG_TYPE_UINT32, &inDataSize, InBuf+InLength);
  memcpy(InBuf+InLength, inData, inDataSize);
  InLength += inDataSize;
  InLength += packAuth(InBuf+InLength, pubAuth);
  // fill paramSize again as we now have the correct size
  BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2);
    
  // call the TPM driver
  if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) 
              == TDDL_SUCCESS) {
    // unpack OutBuf to get the tag, paramSize, & returnCode
    int i = BSG_UnpackList(OutBuf, 3, 
			   BSG_TPM_TAG, &tag, 
			   BSG_TYPE_UINT32, &paramSize, 
			   BSG_TPM_COMMAND_CODE, &returnCode);
    
    if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) {
      // Extract the remaining output parameters
      TPM_STORED_DATA sealedData;
      
      i += BSG_Unpack(BSG_TPM_STORED_DATA, OutBuf+i, &sealedData); 
      unpackAuth(pubAuth, OutBuf+i);
      
      // fill SealedData
      BYTE tempBuf[1024];
      *SealedDataSize = BSG_Pack(BSG_TPM_STORED_DATA, &sealedData, tempBuf);
      if (TCS_Malloc(hContext, *SealedDataSize, SealedData) == TPM_FAIL) {
	return TPM_SIZE;
      }
      memcpy(*SealedData, tempBuf, *SealedDataSize);
      
      vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize);
    } else 
      vtpmlogerror(VTPM_LOG_TCS, "TCSP_Seal Failed with return code %s\n", tpm_get_error_name(returnCode));
  }
  
  return(returnCode);
}

TPM_RESULT TCSP_Unseal(TCS_CONTEXT_HANDLE hContext,  // in
		       TCS_KEY_HANDLE  parentHandle, // in
		       UINT32    SealedDataSize, // in
		       BYTE*    SealedData,  // in
		       TCS_AUTH*   parentAuth,  // in, out
		       TCS_AUTH*   dataAuth,  // in, out
		       UINT32*   DataSize,  // out
		       BYTE**    Data)   // out
{
  // setup input/output parameters block
  TPM_TAG tag = TPM_TAG_RQU_AUTH2_COMMAND;
  UINT32 paramSize = 0;
  TPM_COMMAND_CODE ordinal = TPM_ORD_Unseal;
  TPM_RESULT returnCode = TPM_SUCCESS;
  
  // setup the TPM driver input and output buffers
  TDDL_RESULT hRes = TDDL_E_FAIL;
  TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH;
  TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH;
  
  // check input params
  if (SealedData == NULL || parentAuth == NULL || dataAuth == NULL || 
      DataSize == NULL || Data == NULL) 
    return TPM_BAD_PARAMETER;
  
  
  // Convert Byte Input parameter in the input byte stream InBuf
  InLength = BSG_PackList(InBuf, 4, 
			              BSG_TPM_TAG, &tag, 
                          BSG_TYPE_UINT32, &paramSize, 
                          BSG_TPM_COMMAND_CODE, &ordinal, 
                          BSG_TYPE_UINT32, &parentHandle);
  memcpy(InBuf+InLength, SealedData, SealedDataSize);
  InLength += SealedDataSize;
  InLength += packAuth(InBuf+InLength, parentAuth);
  InLength += packAuth(InBuf+InLength, dataAuth);
  // fill paramSize again as we now have the correct size
  BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2);
  
  vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength);
    
  // call the TPM driver
  if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) {
    // unpack OutBuf to get the tag, paramSize, & returnCode
    int i = BSG_UnpackList( OutBuf, 3, 
                            BSG_TPM_TAG, &tag, 
                            BSG_TYPE_UINT32, &paramSize, 
                            BSG_TPM_COMMAND_CODE, &returnCode);
    
    if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH2_COMMAND) {
      // Extract the remaining output parameters
      i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, DataSize);
      if (TCS_Malloc(hContext, *DataSize, Data) == TPM_FAIL) {
        return TPM_SIZE;
      }
      memcpy(*Data, OutBuf+i, *DataSize);
      i += *DataSize;
      i += unpackAuth(parentAuth, OutBuf+i);
      unpackAuth(dataAuth, OutBuf+i);
      
      vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize);
    } else 
      vtpmlogerror(VTPM_LOG_TCS, "TCSP_Unseal Failed with return code %s\n", tpm_get_error_name(returnCode));
  }
  
  return(returnCode);
}

TPM_RESULT TCSP_UnBind(TCS_CONTEXT_HANDLE hContext,  // in
		       TCS_KEY_HANDLE  keyHandle,  // in
		       UINT32    inDataSize,  // in
		       BYTE*    inData,   // in
		       TCS_AUTH*   privAuth,  // in, out
		       UINT32*   outDataSize, // out
		       BYTE**    outData)  // out
{
  // setup input/output parameters block
  TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND;
  UINT32 paramSize = 0;
  TPM_COMMAND_CODE ordinal = TPM_ORD_UnBind;
  TPM_RESULT returnCode = TPM_SUCCESS;
  
  // setup the TPM driver input and output buffers
  TDDL_RESULT hRes = TDDL_E_FAIL;
  TDDL_UINT32  InLength = TCPA_MAX_BUFFER_LENGTH;
  TDDL_UINT32  OutLength = TCPA_MAX_BUFFER_LENGTH;
  
  // check input params
  if (inData == NULL || privAuth == NULL || outDataSize == NULL || outData == NULL)
    return TPM_BAD_PARAMETER;
  
  // Convert Byte Input parameter in the input byte stream InBuf
  InLength = BSG_PackList(InBuf, 5, 
			  BSG_TPM_TAG, &tag, 
			  BSG_TYPE_UINT32, &paramSize, 
			  BSG_TPM_COMMAND_CODE, &ordinal, 
			  BSG_TYPE_UINT32, &keyHandle, 
			  BSG_TYPE_UINT32, &inDataSize);
  memcpy(InBuf+InLength, inData, inDataSize);
  InLength += inDataSize;
  InLength += packAuth(InBuf+InLength, privAuth);
  // fill paramSize again as we now have the correct size
  BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2);
  
  vtpmloginfo(VTPM_LOG_TCS_DEEP, "\n\tSending paramSize = %d", InLength);
  
  // call the TPM driver