ContextLoad.c

// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 3: Commands
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014

#include "InternalRoutines.h"
#include "ContextLoad_fp.h"
#include "Context_spt_fp.h"
//
//
//     Error Returns                 Meaning
//
//     TPM_RC_CONTEXT_GAP            there is only one available slot and this is not the oldest saved
//                                   session context
//     TPM_RC_HANDLE                 'context. savedHandle' does not reference a saved session
//     TPM_RC_HIERARCHY              'context.hierarchy' is disabled
//     TPM_RC_INTEGRITY              context integrity check fail
//     TPM_RC_OBJECT_MEMORY          no free slot for an object
//     TPM_RC_SESSION_MEMORY         no free session slots
//     TPM_RC_SIZE                   incorrect context blob size
//
TPM_RC
TPM2_ContextLoad(
   ContextLoad_In     *in,                  // IN: input parameter list
   ContextLoad_Out    *out                  // OUT: output parameter list
   )
{
// Local Variables
   TPM_RC      result = TPM_RC_SUCCESS;

   TPM2B_DIGEST       integrityToCompare;
   TPM2B_DIGEST       integrity;
   UINT16             integritySize;
   UINT64             fingerprint;
   BYTE               *buffer;
   INT32              size;

   TPM_HT             handleType;
   TPM2B_SYM_KEY      symKey;
   TPM2B_IV           iv;

// Input Validation

   // Check context blob size
   handleType = HandleGetType(in->context.savedHandle);

   // Check integrity
   // In this implementation, the same routine is used for both sessions
   // and objects.
   integritySize = CryptGetHashDigestSize(CONTEXT_INTEGRITY_HASH_ALG);

   // Get integrity from context blob
   buffer = in->context.contextBlob.t.buffer;
   size = (INT32) in->context.contextBlob.t.size;
   result = TPM2B_DIGEST_Unmarshal(&integrity, &buffer, &size);
   if(result != TPM_RC_SUCCESS)
       return result;
   if(integrity.t.size != integritySize)
       return TPM_RC_SIZE;

   integritySize += sizeof(integrity.t.size);
//

   // Compute context integrity
   ComputeContextIntegrity(&in->context, &integrityToCompare);

   // Compare integrity
   if(!Memory2BEqual(&integrity.b, &integrityToCompare.b))
       return TPM_RC_INTEGRITY + RC_ContextLoad_context;

   // Compute context encryption key
   ComputeContextProtectionKey(&in->context, &symKey, &iv);

   // Decrypt context data in place
   CryptSymmetricDecrypt(in->context.contextBlob.t.buffer + integritySize,
                         CONTEXT_ENCRYPT_ALG, CONTEXT_ENCRYPT_KEY_BITS,
                         TPM_ALG_CFB, symKey.t.buffer, &iv,
                         in->context.contextBlob.t.size - integritySize,
                         in->context.contextBlob.t.buffer + integritySize);

   // Read the fingerprint value, skip the leading integrity size
   MemoryCopy(&fingerprint, in->context.contextBlob.t.buffer + integritySize,
              sizeof(fingerprint), sizeof(fingerprint));
   // Check fingerprint. If the check fails, TPM should be put to failure mode
   if(fingerprint != in->context.sequence)
       FAIL(FATAL_ERROR_INTERNAL);

   // Perform object or session specific input check
   switch(handleType)
   {
   case TPM_HT_TRANSIENT:
   {
       // Get a pointer to the object in the context blob
       OBJECT      *outObject = (OBJECT *)(in->context.contextBlob.t.buffer
                               + integritySize + sizeof(fingerprint));

       // Discard any changes to the handle that the TRM might have made
       in->context.savedHandle = TRANSIENT_FIRST;

       // If hierarchy is disabled, no object context can be loaded in this
       // hierarchy
       if(!HierarchyIsEnabled(in->context.hierarchy))
           return TPM_RC_HIERARCHY + RC_ContextLoad_context;

       // Restore object. A TPM_RC_OBJECT_MEMORY error may be returned at
       // this point
       result = ObjectContextLoad(outObject, &out->loadedHandle);
       if(result != TPM_RC_SUCCESS)
           return result;

       // If this is a sequence object, the crypto library may need to
       // reformat the data into an internal format
       if(ObjectIsSequence(outObject))
           SequenceDataImportExport(ObjectGet(out->loadedHandle),
                                    outObject, IMPORT_STATE);

       break;
   }
   case TPM_HT_POLICY_SESSION:
   case TPM_HT_HMAC_SESSION:
   {

       SESSION      *session = (SESSION *)(in->context.contextBlob.t.buffer
                                        + integritySize + sizeof(fingerprint));

       // This command may cause the orderlyState to be cleared due to
       // the update of state reset data. If this is the case, check if NV is
       // available first
      if(gp.orderlyState != SHUTDOWN_NONE)
      {
          // The command needs NV update. Check if NV is available.
          // A TPM_RC_NV_UNAVAILABLE or TPM_RC_NV_RATE error may be returned
          // at this point
          result = NvIsAvailable();
          if(result != TPM_RC_SUCCESS)
              return result;
      }

      // Check if input handle points to a valid saved session
      if(!SessionIsSaved(in->context.savedHandle))
          return TPM_RC_HANDLE + RC_ContextLoad_context;

      // Restore session. A TPM_RC_SESSION_MEMORY, TPM_RC_CONTEXT_GAP error
      // may be returned at this point
      result = SessionContextLoad(session, &in->context.savedHandle);
      if(result != TPM_RC_SUCCESS)
          return result;

      out->loadedHandle = in->context.savedHandle;

      // orderly state should be cleared because of the update of state
      // reset and state clear data
      g_clearOrderly = TRUE;

      break;
  }
  default:
      // Context blob may only have an object handle or a session handle.
      // All the other handle type should be filtered out at unmarshal
      pAssert(FALSE);
      break;
  }

   return TPM_RC_SUCCESS;
}