xref: /external/tpm2/Session.c

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

#define SESSION_C
#include "InternalRoutines.h"
#include "Platform.h"
#include "SessionProcess_fp.h"
//
//
//           File Scope Function -- ContextIdSetOldest()
//
//     This function is called when the oldest contextID is being loaded or deleted. Once a saved context
//     becomes the oldest, it stays the oldest until it is deleted.
//     Finding the oldest is a bit tricky. It is not just the numeric comparison of values but is dependent on the
//     value of contextCounter.
//     Assume we have a small contextArray with 8, 4-bit values with values 1 and 2 used to indicate the loaded
//     context slot number. Also assume that the array contains hex values of (0 0 1 0 3 0 9 F) and that the
//     contextCounter is an 8-bit counter with a value of 0x37. Since the low nibble is 7, that means that values
//     above 7 are older than values below it and, in this example, 9 is the oldest value.
//     Note if we subtract the counter value, from each slot that contains a saved contextID we get (- - - - B - 2 -
//     8) and the oldest entry is now easy to find.
//
static void
ContextIdSetOldest(
    void
    )
{
    CONTEXT_SLOT         lowBits;
    CONTEXT_SLOT         entry;
    CONTEXT_SLOT         smallest = ((CONTEXT_SLOT) ~0);
    UINT32 i;
//
   // Set oldestSaveContext to a value indicating none assigned
   s_oldestSavedSession = MAX_ACTIVE_SESSIONS + 1;
   lowBits = (CONTEXT_SLOT)gr.contextCounter;
   for(i = 0; i < MAX_ACTIVE_SESSIONS; i++)
   {
       entry = gr.contextArray[i];
        // only look at entries that are saved contexts
        if(entry > MAX_LOADED_SESSIONS)
        {
            // Use a less than or equal in case the oldest
            // is brand new (= lowBits-1) and equal to our initial
            // value for smallest.
            if(((CONTEXT_SLOT) (entry - lowBits)) <= smallest)
            {
                smallest = (entry - lowBits);
                s_oldestSavedSession = i;
            }
        }
   }
   // When we finish, either the s_oldestSavedSession still has its initial
   // value, or it has the index of the oldest saved context.
}
//
//
//         Startup Function -- SessionStartup()
//
//     This function initializes the session subsystem on TPM2_Startup().
//
void
SessionStartup(
   STARTUP_TYPE         type
   )
{
   UINT32                    i;
   // Initialize session slots. At startup, all the in-memory session slots
   // are cleared and marked as not occupied
   for(i = 0; i < MAX_LOADED_SESSIONS; i++)
       s_sessions[i].occupied = FALSE;   // session slot is not occupied
   // The free session slots the number of maximum allowed loaded sessions
   s_freeSessionSlots = MAX_LOADED_SESSIONS;
   // Initialize context ID data. On a ST_SAVE or hibernate sequence, it             will
   // scan the saved array of session context counts, and clear any entry            that
   // references a session that was in memory during the state save since            that
   // memory was not preserved over the ST_SAVE.
   if(type == SU_RESUME || type == SU_RESTART)
   {
       // On ST_SAVE we preserve the contexts that were saved but not the            ones
       // in memory
       for (i = 0; i < MAX_ACTIVE_SESSIONS; i++)
       {
           // If the array value is unused or references a loaded session            then
           // that loaded session context is lost and the array entry is
           // reclaimed.
           if (gr.contextArray[i] <= MAX_LOADED_SESSIONS)
               gr.contextArray[i] = 0;
       }
       // Find the oldest session in context ID data and set it in
       // s_oldestSavedSession
       ContextIdSetOldest();
//
   }
   else
   {
       // For STARTUP_CLEAR, clear out the contextArray
       for (i = 0; i < MAX_ACTIVE_SESSIONS; i++)
           gr.contextArray[i] = 0;
         // reset the context counter
         gr.contextCounter = MAX_LOADED_SESSIONS + 1;
         // Initialize oldest saved session
         s_oldestSavedSession = MAX_ACTIVE_SESSIONS + 1;
   }
   return;
}
//
//
//           Access Functions
//
//           SessionIsLoaded()
//
//      This function test a session handle references a loaded session. The handle must have previously been
//      checked to make sure that it is a valid handle for an authorization session.
//
//      NOTE:           A PWAP authorization does not have a session.
//
//
//      Return Value                       Meaning
//
//      TRUE                               if session is loaded
//      FALSE                              if it is not loaded
//
BOOL
SessionIsLoaded(
   TPM_HANDLE             handle                // IN: session handle
   )
{
   pAssert(   HandleGetType(handle) == TPM_HT_POLICY_SESSION
           || HandleGetType(handle) == TPM_HT_HMAC_SESSION);
   handle = handle & HR_HANDLE_MASK;
   // if out of range of possible active session, or not assigned to a loaded
   // session return false
   if(   handle >= MAX_ACTIVE_SESSIONS
      || gr.contextArray[handle] == 0
      || gr.contextArray[handle] > MAX_LOADED_SESSIONS
     )
       return FALSE;
   return TRUE;
}
//
//
//           SessionIsSaved()
//
//      This function test a session handle references a saved session. The handle must have previously been
//      checked to make sure that it is a valid handle for an authorization session.
//
//      NOTE:           An password authorization does not have a session.
//
//      This function requires that the handle be a valid session handle.
//
//
//      Return Value                     Meaning
//
//      TRUE                             if session is saved
//      FALSE                            if it is not saved
//
BOOL
SessionIsSaved(
   TPM_HANDLE            handle                // IN: session handle
   )
{
   pAssert(   HandleGetType(handle) == TPM_HT_POLICY_SESSION
           || HandleGetType(handle) == TPM_HT_HMAC_SESSION);
   handle = handle & HR_HANDLE_MASK;
   // if out of range of possible active session, or not assigned, or
   // assigned to a loaded session, return false
   if(   handle >= MAX_ACTIVE_SESSIONS
      || gr.contextArray[handle] == 0
      || gr.contextArray[handle] <= MAX_LOADED_SESSIONS
     )
       return FALSE;
   return TRUE;
}
//
//
//           SessionPCRValueIsCurrent()
//
//      This function is used to check if PCR values have been updated since the last time they were checked in
//      a policy session.
//      This function requires the session is loaded.
//
//      Return Value                     Meaning
//
//      TRUE                             if PCR value is current
//      FALSE                            if PCR value is not current
//
BOOL
SessionPCRValueIsCurrent(
   TPMI_SH_POLICY        handle                // IN: session handle
   )
{
   SESSION                   *session;
   pAssert(SessionIsLoaded(handle));
   session = SessionGet(handle);
   if(   session->pcrCounter != 0
      && session->pcrCounter != gr.pcrCounter
     )
       return FALSE;
   else
       return TRUE;
}
//
//
//           SessionGet()
//
//      This function returns a pointer to the session object associated with a session handle.
//      The function requires that the session is loaded.
//
SESSION *
SessionGet(
    TPM_HANDLE           handle              // IN: session handle
    )
{
    CONTEXT_SLOT        sessionIndex;
    pAssert(   HandleGetType(handle) == TPM_HT_POLICY_SESSION
            || HandleGetType(handle) == TPM_HT_HMAC_SESSION
           );
    pAssert((handle & HR_HANDLE_MASK) < MAX_ACTIVE_SESSIONS);
    // get the contents of the session array. Because session is loaded, we
    // should always get a valid sessionIndex
    sessionIndex = gr.contextArray[handle & HR_HANDLE_MASK] - 1;
    pAssert(sessionIndex < MAX_LOADED_SESSIONS);
    return &s_sessions[sessionIndex].session;
}
//
//
//           Utility Functions
//
//             ContextIdSessionCreate()
//
//      This function is called when a session is created. It will check to see if the current gap would prevent a
//      context from being saved. If so it will return TPM_RC_CONTEXT_GAP. Otherwise, it will try to find an
//      open slot in contextArray, set contextArray to the slot.
//      This routine requires that the caller has determined the session array index for the session.
//
//      return type                       TPM_RC
//
//      TPM_RC_SUCCESS                    context ID was assigned
//      TPM_RC_CONTEXT_GAP                can't assign a new contextID until the oldest saved session context is
//                                        recycled
//      TPM_RC_SESSION_HANDLE             there is no slot available in the context array for tracking of this
//                                        session context
//
static TPM_RC
ContextIdSessionCreate (
    TPM_HANDLE          *handle,             // OUT: receives the assigned handle. This will
                                             //     be an index that must be adjusted by the
                                             //     caller according to the type of the
                                             //     session created
    UINT32               sessionIndex        // IN: The session context array entry that will
                                             //     be occupied by the created session
    )
{
    pAssert(sessionIndex < MAX_LOADED_SESSIONS);
    // check to see if creating the context is safe
    // Is this going to be an assignment for the last session context
    // array entry? If so, then there will be no room to recycle the
    // oldest context if needed. If the gap is not at maximum, then
    // it will be possible to save a context if it becomes necessary.
    if(   s_oldestSavedSession < MAX_ACTIVE_SESSIONS
       && s_freeSessionSlots == 1)
    {
        // See if the gap is at maximum
         if(      (CONTEXT_SLOT)gr.contextCounter
               == gr.contextArray[s_oldestSavedSession])
               // Note: if this is being used on a TPM.combined, this return
               //       code should be transformed to an appropriate 1.2 error
               //       code for this case.
               return TPM_RC_CONTEXT_GAP;
   }
   // Find an unoccupied entry in the contextArray
   for(*handle = 0; *handle < MAX_ACTIVE_SESSIONS; (*handle)++)
   {
       if(gr.contextArray[*handle] == 0)
       {
           // indicate that the session associated with this handle
           // references a loaded session
           gr.contextArray[*handle] = (CONTEXT_SLOT)(sessionIndex+1);
           return TPM_RC_SUCCESS;
       }
   }
   return TPM_RC_SESSION_HANDLES;
}
//
//
//           SessionCreate()
//
//      This function does the detailed work for starting an authorization session. This is done in a support
//      routine rather than in the action code because the session management may differ in implementations.
//      This implementation uses a fixed memory allocation to hold sessions and a fixed allocation to hold the
//      contextID for the saved contexts.
//
//      Error Returns                   Meaning
//
//      TPM_RC_CONTEXT_GAP              need to recycle sessions
//      TPM_RC_SESSION_HANDLE           active session space is full
//      TPM_RC_SESSION_MEMORY           loaded session space is full
//
TPM_RC
SessionCreate(
   TPM_SE               sessionType,        //   IN: the session type
   TPMI_ALG_HASH        authHash,           //   IN: the hash algorithm
   TPM2B_NONCE         *nonceCaller,        //   IN: initial nonceCaller
   TPMT_SYM_DEF        *symmetric,          //   IN: the symmetric algorithm
   TPMI_DH_ENTITY       bind,               //   IN: the bind object
   TPM2B_DATA          *seed,               //   IN: seed data
   TPM_HANDLE          *sessionHandle       //   OUT: the session handle
   )
{
   TPM_RC                     result = TPM_RC_SUCCESS;
   CONTEXT_SLOT               slotIndex;
   SESSION                   *session = NULL;
   pAssert(   sessionType == TPM_SE_HMAC
           || sessionType == TPM_SE_POLICY
           || sessionType == TPM_SE_TRIAL);
   // If there are no open spots in the session array, then no point in searching
   if(s_freeSessionSlots == 0)
       return TPM_RC_SESSION_MEMORY;
   // Find a space for loading a session
   for(slotIndex = 0; slotIndex < MAX_LOADED_SESSIONS; slotIndex++)
   {
        // Is this available?
        if(s_sessions[slotIndex].occupied == FALSE)
        {
            session = &s_sessions[slotIndex].session;
            break;
        }
   }
   // if no spot found, then this is an internal error
   pAssert (slotIndex < MAX_LOADED_SESSIONS);
   // Call context ID function to get a handle. TPM_RC_SESSION_HANDLE may be
   // returned from ContextIdHandelAssign()
   result = ContextIdSessionCreate(sessionHandle, slotIndex);
   if(result != TPM_RC_SUCCESS)
       return result;
   //*** Only return from this point on is TPM_RC_SUCCESS
   // Can now indicate that the session array entry is occupied.
   s_freeSessionSlots--;
   s_sessions[slotIndex].occupied = TRUE;
   // Initialize the session data
   MemorySet(session, 0, sizeof(SESSION));
   // Initialize internal session data
   session->authHashAlg = authHash;
   // Initialize session type
   if(sessionType == TPM_SE_HMAC)
   {
       *sessionHandle += HMAC_SESSION_FIRST;
   }
   else
   {
       *sessionHandle += POLICY_SESSION_FIRST;
        // For TPM_SE_POLICY or TPM_SE_TRIAL
        session->attributes.isPolicy = SET;
        if(sessionType == TPM_SE_TRIAL)
            session->attributes.isTrialPolicy = SET;
        // Initialize policy session data
        SessionInitPolicyData(session);
   }
   // Create initial session nonce
   session->nonceTPM.t.size = nonceCaller->t.size;
   CryptGenerateRandom(session->nonceTPM.t.size, session->nonceTPM.t.buffer);
   // Set up session parameter encryption algorithm
   session->symmetric = *symmetric;
   // If there is a bind object or a session secret, then need to compute
   // a sessionKey.
   if(bind != TPM_RH_NULL || seed->t.size != 0)
   {
       // sessionKey = KDFa(hash, (authValue || seed), "ATH", nonceTPM,
       //                      nonceCaller, bits)
       // The HMAC key for generating the sessionSecret can be the concatenation
       // of an authorization value and a seed value
       TPM2B_TYPE(KEY, (sizeof(TPMT_HA) + sizeof(seed->t.buffer)));
       TPM2B_KEY            key;
        UINT16                   hashSize;     // The size of the hash used by the
                                               // session crated by this command
        TPM2B_AUTH    entityAuth;              // The authValue of the entity
                                                     // associated with HMAC session
         // Get hash size, which is also the length of sessionKey
         hashSize = CryptGetHashDigestSize(session->authHashAlg);
         // Get authValue of associated entity
         entityAuth.t.size = EntityGetAuthValue(bind, &entityAuth.t.buffer);
         // Concatenate authValue and seed
         pAssert(entityAuth.t.size + seed->t.size <= sizeof(key.t.buffer));
         MemoryCopy2B(&key.b, &entityAuth.b, sizeof(key.t.buffer));
         MemoryConcat2B(&key.b, &seed->b, sizeof(key.t.buffer));
         session->sessionKey.t.size = hashSize;
         // Compute the session key
         KDFa(session->authHashAlg, &key.b, "ATH", &session->nonceTPM.b,
              &nonceCaller->b, hashSize * 8, session->sessionKey.t.buffer, NULL);
   }
   // Copy the name of the entity that the HMAC session is bound to
   // Policy session is not bound to an entity
   if(bind != TPM_RH_NULL && sessionType == TPM_SE_HMAC)
   {
       session->attributes.isBound = SET;
       SessionComputeBoundEntity(bind, &session->u1.boundEntity);
   }
   // If there is a bind object and it is subject to DA, then use of this session
   // is subject to DA regardless of how it is used.
   session->attributes.isDaBound =    (bind != TPM_RH_NULL)
                                   && (IsDAExempted(bind) == FALSE);
   // If the session is bound, then check to see if it is bound to lockoutAuth
   session->attributes.isLockoutBound =    (session->attributes.isDaBound == SET)
                                        && (bind == TPM_RH_LOCKOUT);
   return TPM_RC_SUCCESS;
}
//
//
//           SessionContextSave()
//
//      This function is called when a session context is to be saved. The contextID of the saved session is
//      returned. If no contextID can be assigned, then the routine returns TPM_RC_CONTEXT_GAP. If the
//      function completes normally, the session slot will be freed.
//      This function requires that handle references a loaded session. Otherwise, it should not be called at the
//      first place.
//
//      Error Returns                      Meaning
//
//      TPM_RC_CONTEXT_GAP                 a contextID could not be assigned.
//      TPM_RC_TOO_MANY_CONTEXTS           the counter maxed out
//
TPM_RC
SessionContextSave (
   TPM_HANDLE                 handle,           // IN: session handle
   CONTEXT_COUNTER           *contextID         // OUT: assigned contextID
   )
{
   UINT32                            contextIndex;
   CONTEXT_SLOT                      slotIndex;
   pAssert(SessionIsLoaded(handle));
   // check to see if the gap is already maxed out
   // Need to have a saved session
   if(   s_oldestSavedSession < MAX_ACTIVE_SESSIONS
         // if the oldest saved session has the same value as the low bits
         // of the contextCounter, then the GAP is maxed out.
      && gr.contextArray[s_oldestSavedSession] == (CONTEXT_SLOT)gr.contextCounter)
       return TPM_RC_CONTEXT_GAP;
   // if the caller wants the context counter, set it
   if(contextID != NULL)
       *contextID = gr.contextCounter;
   pAssert((handle & HR_HANDLE_MASK) < MAX_ACTIVE_SESSIONS);
   contextIndex = handle & HR_HANDLE_MASK;
   // Extract the session slot number referenced by the contextArray
   // because we are going to overwrite this with the low order
   // contextID value.
   slotIndex = gr.contextArray[contextIndex] - 1;
   // Set the contextID for the contextArray
   gr.contextArray[contextIndex] = (CONTEXT_SLOT)gr.contextCounter;
   // Increment the counter
   gr.contextCounter++;
   // In the unlikely event that the 64-bit context counter rolls over...
   if(gr.contextCounter == 0)
   {
       // back it up
       gr.contextCounter--;
       // return an error
       return TPM_RC_TOO_MANY_CONTEXTS;
   }
   // if the low-order bits wrapped, need to advance the value to skip over
   // the values used to indicate that a session is loaded
   if(((CONTEXT_SLOT)gr.contextCounter) == 0)
       gr.contextCounter += MAX_LOADED_SESSIONS + 1;
   // If no other sessions are saved, this is now the oldest.
   if(s_oldestSavedSession >= MAX_ACTIVE_SESSIONS)
       s_oldestSavedSession = contextIndex;
   // Mark the session slot as unoccupied
   s_sessions[slotIndex].occupied = FALSE;
   // and indicate that there is an additional open slot
   s_freeSessionSlots++;
   return TPM_RC_SUCCESS;
}
//
//
//           SessionContextLoad()
//
//      This function is used to load a session from saved context. The session handle must be for a saved
//      context.
//      If the gap is at a maximum, then the only session that can be loaded is the oldest session, otherwise
//      TPM_RC_CONTEXT_GAP is returned.
//      This function requires that handle references a valid saved session.
//
//
//
//      Error Returns                   Meaning
//
//      TPM_RC_SESSION_MEMORY           no free session slots
//      TPM_RC_CONTEXT_GAP              the gap count is maximum and this is not the oldest saved context
//
TPM_RC
SessionContextLoad(
   SESSION            *session,            // IN: session structure from saved context
   TPM_HANDLE         *handle              // IN/OUT: session handle
   )
{
   UINT32                    contextIndex;
   CONTEXT_SLOT              slotIndex;
   pAssert(   HandleGetType(*handle) == TPM_HT_POLICY_SESSION
           || HandleGetType(*handle) == TPM_HT_HMAC_SESSION);
   // Don't bother looking if no openings
   if(s_freeSessionSlots == 0)
       return TPM_RC_SESSION_MEMORY;
   // Find a free session slot to load the session
   for(slotIndex = 0; slotIndex < MAX_LOADED_SESSIONS; slotIndex++)
       if(s_sessions[slotIndex].occupied == FALSE) break;
   // if no spot found, then this is an internal error
   pAssert (slotIndex < MAX_LOADED_SESSIONS);
   contextIndex = *handle & HR_HANDLE_MASK;               // extract the index
   // If there is only one slot left, and the gap is at maximum, the only session
   // context that we can safely load is the oldest one.
   if(   s_oldestSavedSession < MAX_ACTIVE_SESSIONS
      && s_freeSessionSlots == 1
      && (CONTEXT_SLOT)gr.contextCounter == gr.contextArray[s_oldestSavedSession]
      && contextIndex != s_oldestSavedSession
     )
       return TPM_RC_CONTEXT_GAP;
   pAssert(contextIndex < MAX_ACTIVE_SESSIONS);
   // set the contextArray value to point to the session slot where
   // the context is loaded
   gr.contextArray[contextIndex] = slotIndex + 1;
   // if this was the oldest context, find the new oldest
   if(contextIndex == s_oldestSavedSession)
       ContextIdSetOldest();
   // Copy session data to session slot
   s_sessions[slotIndex].session = *session;
   // Set session slot as occupied
   s_sessions[slotIndex].occupied = TRUE;
   // Reduce the number of open spots
   s_freeSessionSlots--;
   return TPM_RC_SUCCESS;
}
//
//
//
//           SessionFlush()
//
//      This function is used to flush a session referenced by its handle. If the session associated with handle is
//      loaded, the session array entry is marked as available.
//      This function requires that handle be a valid active session.
//
void
SessionFlush(
    TPM_HANDLE           handle             // IN: loaded or saved session handle
    )
{
    CONTEXT_SLOT              slotIndex;
    UINT32                    contextIndex;       // Index into contextArray
    pAssert(      (    HandleGetType(handle) == TPM_HT_POLICY_SESSION
                    || HandleGetType(handle) == TPM_HT_HMAC_SESSION
                  )
               && (SessionIsLoaded(handle) || SessionIsSaved(handle))
              );
    // Flush context ID of this session
    // Convert handle to an index into the contextArray
    contextIndex = handle & HR_HANDLE_MASK;
    pAssert(contextIndex < sizeof(gr.contextArray)/sizeof(gr.contextArray[0]));
    // Get the current contents of the array
    slotIndex = gr.contextArray[contextIndex];
    // Mark context array entry as available
    gr.contextArray[contextIndex] = 0;
    // Is this a saved session being flushed
    if(slotIndex > MAX_LOADED_SESSIONS)
    {
        // Flushing the oldest session?
        if(contextIndex == s_oldestSavedSession)
            // If so, find a new value for oldest.
            ContextIdSetOldest();
    }
    else
    {
        // Adjust slot index to point to session array index
        slotIndex -= 1;
         // Free session array index
         s_sessions[slotIndex].occupied = FALSE;
         s_freeSessionSlots++;
    }
    return;
}
//
//
//           SessionComputeBoundEntity()
//
//      This function computes the binding value for a session. The binding value for a reserved handle is the
//      handle itself. For all the other entities, the authValue at the time of binding is included to prevent
//      squatting. For those values, the Name and the authValue are concatenated into the bind buffer. If they
//      will not both fit, the will be overlapped by XORing() bytes. If XOR is required, the bind value will be full.
//
void
SessionComputeBoundEntity(
    TPMI_DH_ENTITY      entityHandle,     // IN: handle of entity
    TPM2B_NAME         *bind              // OUT: binding value
    )
{
    TPM2B_AUTH               auth;
    INT16                    overlap;
    // Get name
    bind->t.size = EntityGetName(entityHandle, &bind->t.name);
//     // The bound value of a reserved handle is the handle itself
//     if(bind->t.size == sizeof(TPM_HANDLE)) return;
    // For all the other entities, concatenate the auth value to the name.
    // Get a local copy of the auth value because some overlapping
    // may be necessary.
    auth.t.size = EntityGetAuthValue(entityHandle, &auth.t.buffer);
    pAssert(auth.t.size <= sizeof(TPMU_HA));
    // Figure out if there will be any overlap
    overlap = bind->t.size + auth.t.size - sizeof(bind->t.name);
    // There is overlap if the combined sizes are greater than will fit
    if(overlap > 0)
    {
        // The overlap area is at the end of the Name
        BYTE    *result = &bind->t.name[bind->t.size - overlap];
        int     i;
         // XOR the auth value into the Name for the overlap area
         for(i = 0; i < overlap; i++)
             result[i] ^= auth.t.buffer[i];
    }
    else
    {
        // There is no overlap
        overlap = 0;
    }
    //copy the remainder of the authData to the end of the name
    MemoryCopy(&bind->t.name[bind->t.size], &auth.t.buffer[overlap],
               auth.t.size - overlap, sizeof(bind->t.name) - bind->t.size);
    // Increase the size of the bind data by the size of the auth - the overlap
    bind->t.size += auth.t.size-overlap;
    return;
}
//
//
//           SessionInitPolicyData()
//
//      This function initializes the portions of the session policy data that are not set by the allocation of a
//      session.
//
void
SessionInitPolicyData(
    SESSION            *session           // IN: session handle
    )
{
    // Initialize start time
    session->startTime = go.clock;
    // Initialize policyDigest. policyDigest is initialized with a string of 0 of
    // session algorithm digest size. Since the policy already contains all zeros
    // it is only necessary to set the size
     session->u2.policyDigest.t.size = CryptGetHashDigestSize(session->authHashAlg);
     return;
}
//
//
//           SessionResetPolicyData()
//
//      This function is used to reset the policy data without changing the nonce or the start time of the session.
//
void
SessionResetPolicyData(
     SESSION            *session             // IN: the session to reset
     )
{
     session->commandCode = 0;              // No command
     // No locality selected
     MemorySet(&session->commandLocality, 0, sizeof(session->commandLocality));
     // The cpHash size to zero
     session->u1.cpHash.b.size = 0;
     // No timeout
     session->timeOut = 0;
     // Reset the pcrCounter
     session->pcrCounter = 0;
     // Reset the policy hash
     MemorySet(&session->u2.policyDigest.t.buffer, 0,
               session->u2.policyDigest.t.size);
     // Reset the session attributes
     MemorySet(&session->attributes, 0, sizeof(SESSION_ATTRIBUTES));
     // set the policy attribute
     session->attributes.isPolicy = SET;
}
//
//
//           SessionCapGetLoaded()
//
//      This function returns a list of handles of loaded session, started from input handle
//      Handle must be in valid loaded session handle range, but does not have to point to a loaded session.
//
//      Return Value                      Meaning
//
//      YES                               if there are more handles available
//      NO                                all the available handles has been returned
//
TPMI_YES_NO
SessionCapGetLoaded(
     TPMI_SH_POLICY      handle,             // IN: start handle
     UINT32              count,              // IN: count of returned handle
     TPML_HANDLE        *handleList          // OUT: list of handle
     )
{
     TPMI_YES_NO        more = NO;
     UINT32             i;
     pAssert(HandleGetType(handle) == TPM_HT_LOADED_SESSION);
     // Initialize output handle list
     handleList->count = 0;
     // The maximum count of handles we may return is MAX_CAP_HANDLES
     if(count > MAX_CAP_HANDLES) count = MAX_CAP_HANDLES;
     // Iterate session context ID slots to get loaded session handles
     for(i = handle & HR_HANDLE_MASK; i < MAX_ACTIVE_SESSIONS; i++)
     {
         // If session is active
         if(gr.contextArray[i] != 0)
         {
             // If session is loaded
             if (gr.contextArray[i] <= MAX_LOADED_SESSIONS)
             {
                 if(handleList->count < count)
                 {
                     SESSION         *session;
                        // If we have not filled up the return list, add this
                        // session handle to it
                        // assume that this is going to be an HMAC session
                        handle = i + HMAC_SESSION_FIRST;
                        session = SessionGet(handle);
                        if(session->attributes.isPolicy)
                            handle = i + POLICY_SESSION_FIRST;
                        handleList->handle[handleList->count] = handle;
                        handleList->count++;
                   }
                   else
                   {
                       // If the return list is full but we still have loaded object
                       // available, report this and stop iterating
                       more = YES;
                       break;
                   }
               }
          }
     }
     return more;
}
//
//
//             SessionCapGetSaved()
//
//      This function returns a list of handles for saved session, starting at handle.
//      Handle must be in a valid handle range, but does not have to point to a saved session
//
//      Return Value                      Meaning
//
//      YES                               if there are more handles available
//      NO                                all the available handles has been returned
//
TPMI_YES_NO
SessionCapGetSaved(
     TPMI_SH_HMAC        handle,             // IN: start handle
     UINT32              count,              // IN: count of returned handle
     TPML_HANDLE        *handleList          // OUT: list of handle
     )
{
     TPMI_YES_NO        more = NO;
     UINT32             i;
   pAssert(HandleGetType(handle) == TPM_HT_ACTIVE_SESSION);
   // Initialize output handle list
   handleList->count = 0;
   // The maximum count of handles we may return is MAX_CAP_HANDLES
   if(count > MAX_CAP_HANDLES) count = MAX_CAP_HANDLES;
   // Iterate session context ID slots to get loaded session handles
   for(i = handle & HR_HANDLE_MASK; i < MAX_ACTIVE_SESSIONS; i++)
   {
       // If session is active
       if(gr.contextArray[i] != 0)
       {
           // If session is saved
           if (gr.contextArray[i] > MAX_LOADED_SESSIONS)
           {
               if(handleList->count < count)
               {
                   // If we have not filled up the return list, add this
                   // session handle to it
                   handleList->handle[handleList->count] = i + HMAC_SESSION_FIRST;
                   handleList->count++;
               }
               else
               {
                   // If the return list is full but we still have loaded object
                   // available, report this and stop iterating
                   more = YES;
                   break;
               }
           }
       }
   }
   return more;
}
//
//
//          SessionCapGetLoadedNumber()
//
//      This function return the number of authorization sessions currently loaded into TPM RAM.
//
UINT32
SessionCapGetLoadedNumber(
   void
   )
{
   return MAX_LOADED_SESSIONS - s_freeSessionSlots;
}
//
//
//          SessionCapGetLoadedAvail()
//
//      This function returns the number of additional authorization sessions, of any type, that could be loaded
//      into TPM RAM.
//
//      NOTE:           In other implementations, this number may just be an estimate. The only requirement for the estimate is, if it is
//                      one or more, then at least one session must be loadable.
//
UINT32
SessionCapGetLoadedAvail(
   void
   )
{
     return s_freeSessionSlots;
}
//
//
//           SessionCapGetActiveNumber()
//
//      This function returns the number of active authorization sessions currently being tracked by the TPM.
//
UINT32
SessionCapGetActiveNumber(
     void
     )
{
     UINT32                  i;
     UINT32                  num = 0;
     // Iterate the context array to find the number of non-zero slots
     for(i = 0; i < MAX_ACTIVE_SESSIONS; i++)
     {
         if(gr.contextArray[i] != 0) num++;
     }
     return num;
}
//
//
//           SessionCapGetActiveAvail()
//
//      This function returns the number of additional authorization sessions, of any type, that could be created.
//      This not the number of slots for sessions, but the number of additional sessions that the TPM is capable
//      of tracking.
//
UINT32
SessionCapGetActiveAvail(
     void
     )
{
     UINT32                  i;
     UINT32                  num = 0;
     // Iterate the context array to find the number of zero slots
     for(i = 0; i < MAX_ACTIVE_SESSIONS; i++)
     {
         if(gr.contextArray[i] == 0) num++;
     }
     return num;
}