// 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 "ContextSave_fp.h"

#include "Context_spt_fp.h"

//

//

//     Error Returns                     Meaning

//

//     TPM_RC_CONTEXT_GAP                a contextID could not be assigned for a session context save

//     TPM_RC_TOO_MANY_CONTEXTS          no more contexts can be saved as the counter has maxed out

//

TPM_RC

TPM2_ContextSave(

   ContextSave_In        *in,              // IN: input parameter list

   ContextSave_Out       *out              // OUT: output parameter list

   )

{

   TPM_RC            result;

   UINT16            fingerprintSize;      // The size of fingerprint in context

   // blob.

   UINT64            contextID = 0;        // session context ID

   TPM2B_SYM_KEY     symKey;

   TPM2B_IV          iv;

   TPM2B_DIGEST      integrity;

   UINT16            integritySize;

   BYTE              *buffer;

   INT32             bufferSize;

   // 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;

   }

// Internal Data Update

   // Initialize output handle. At the end of command action, the output

   // handle of an object will be replaced, while the output handle

   // for a session will be the same as input

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

   // Get the size of fingerprint in context blob. The sequence value in

   // TPMS_CONTEXT structure is used as the fingerprint

   fingerprintSize = sizeof(out->context.sequence);

   // Compute the integrity size at the beginning of context blob

   integritySize = sizeof(integrity.t.size)

                   + CryptGetHashDigestSize(CONTEXT_INTEGRITY_HASH_ALG);

   // Perform object or session specific context save

   switch(HandleGetType(in->saveHandle))

   {

   case TPM_HT_TRANSIENT:

   {

       OBJECT          *object = ObjectGet(in->saveHandle);

      OBJECT         *outObject =

                             (OBJECT *)(out->context.contextBlob.t.buffer

                                         + integritySize + fingerprintSize);

      // Set size of the context data. The contents of context blob is vendor

      // defined. In this implementation, the size is size of integrity

      // plus fingerprint plus the whole internal OBJECT structure

      out->context.contextBlob.t.size = integritySize +

                                        fingerprintSize + sizeof(OBJECT);

      // Make sure things fit

      pAssert(out->context.contextBlob.t.size

              < sizeof(out->context.contextBlob.t.buffer));

      // Copy the whole internal OBJECT structure to context blob, leave

      // the size for fingerprint

      *outObject = *object;

      // Increment object context ID

      gr.objectContextID++;

      // If object context ID overflows, TPM should be put in failure mode

      if(gr.objectContextID == 0)

          FAIL(FATAL_ERROR_INTERNAL);

      // Fill in other return values for an object.

      out->context.sequence = gr.objectContextID;

      // For regular object, savedHandle is 0x80000000. For sequence object,

      // savedHandle is 0x80000001. For object with stClear, savedHandle

      // is 0x80000002

      if(ObjectIsSequence(object))

      {

          out->context.savedHandle = 0x80000001;

          SequenceDataImportExport(object, outObject, EXPORT_STATE);

      }

      else if(object->attributes.stClear == SET)

      {

          out->context.savedHandle = 0x80000002;

      }

      else

      {

          out->context.savedHandle = 0x80000000;

      }

      // Get object hierarchy

      out->context.hierarchy = ObjectDataGetHierarchy(object);

      break;

  }

  case TPM_HT_HMAC_SESSION:

  case TPM_HT_POLICY_SESSION:

  {

      SESSION         *session = SessionGet(in->saveHandle);

      // Set size of the context data. The contents of context blob is vendor

      // defined. In this implementation, the size of context blob is the

      // size of a internal session structure plus the size of

      // fingerprint plus the size of integrity

      out->context.contextBlob.t.size = integritySize +

                                        fingerprintSize + sizeof(*session);

      // Make sure things fit

      pAssert(out->context.contextBlob.t.size

              < sizeof(out->context.contextBlob.t.buffer));

      // Copy the whole internal SESSION structure to context blob.

      // Save space for fingerprint at the beginning of the buffer

      // This is done before anything else so that the actual context

       // can be reclaimed after this call

       MemoryCopy(out->context.contextBlob.t.buffer

                  + integritySize + fingerprintSize,

                  session, sizeof(*session),

                  sizeof(out->context.contextBlob.t.buffer)

                           - integritySize - fingerprintSize);

       // Fill in the other return parameters for a session

       // Get a context ID and set the session tracking values appropriately

       // TPM_RC_CONTEXT_GAP is a possible error.

       // SessionContextSave() will flush the in-memory context

       // so no additional errors may occur after this call.

       result = SessionContextSave(out->context.savedHandle, &contextID);

       if(result != TPM_RC_SUCCESS) return result;

       // sequence number is the current session contextID

       out->context.sequence = contextID;

       // use TPM_RH_NULL as hierarchy for session context

       out->context.hierarchy = TPM_RH_NULL;

       break;

   }

   default:

       // SaveContext may only take an object handle or a session handle.

       // All the other handle type should be filtered out at unmarshal

       pAssert(FALSE);

       break;

   }

   // Save fingerprint at the beginning of encrypted area of context blob.

   // Reserve the integrity space

   MemoryCopy(out->context.contextBlob.t.buffer + integritySize,

              &out->context.sequence, sizeof(out->context.sequence),

              sizeof(out->context.contextBlob.t.buffer) - integritySize);

   // Compute context encryption key

   ComputeContextProtectionKey(&out->context, &symKey, &iv);

   // Encrypt context blob

   CryptSymmetricEncrypt(out->context.contextBlob.t.buffer + integritySize,

                         CONTEXT_ENCRYPT_ALG, CONTEXT_ENCRYPT_KEY_BITS,

                         TPM_ALG_CFB, symKey.t.buffer, &iv,

                         out->context.contextBlob.t.size - integritySize,

                         out->context.contextBlob.t.buffer + integritySize);

   // Compute integrity hash for the object

   // In this implementation, the same routine is used for both sessions

   // and objects.

   ComputeContextIntegrity(&out->context, &integrity);

   // add integrity at the beginning of context blob

   buffer = out->context.contextBlob.t.buffer;

   bufferSize = sizeof(TPM2B_DIGEST);

   TPM2B_DIGEST_Marshal(&integrity, &buffer, &bufferSize);

   // orderly state should be cleared because of the update of state reset and

   // state clear data

   g_clearOrderly = TRUE;

   return TPM_RC_SUCCESS;

}