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