// 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 OBJECT_C
#include "InternalRoutines.h"
#include "Platform.h"
//
//
// Functions
//
// ObjectStartup()
//
// This function is called at TPM2_Startup() to initialize the object subsystem.
//
void
ObjectStartup(
void
)
{
UINT32 i;
// object slots initialization
for(i = 0; i < MAX_LOADED_OBJECTS; i++)
{
//Set the slot to not occupied
s_objects[i].occupied = FALSE;
}
return;
}
//
//
// ObjectCleanupEvict()
//
// In this implementation, a persistent object is moved from NV into an object slot for processing. It is
// flushed after command execution. This function is called from ExecuteCommand().
//
void
ObjectCleanupEvict(
void
)
{
UINT32 i;
// This has to be iterated because a command may have two handles
// and they may both be persistent.
// This could be made to be more efficient so that a search is not needed.
for(i = 0; i < MAX_LOADED_OBJECTS; i++)
{
// If an object is a temporary evict object, flush it from slot
if(s_objects[i].object.entity.attributes.evict == SET)
s_objects[i].occupied = FALSE;
}
return;
}
//
//
// ObjectIsPresent()
//
// This function checks to see if a transient handle references a loaded object. This routine should not be
// called if the handle is not a transient handle. The function validates that the handle is in the
// implementation-dependent allowed in range for loaded transient objects.
//
// Return Value Meaning
//
// TRUE if the handle references a loaded object
// FALSE if the handle is not an object handle, or it does not reference to a
// loaded object
//
BOOL
ObjectIsPresent(
TPMI_DH_OBJECT handle // IN: handle to be checked
)
{
UINT32 slotIndex; // index of object slot
pAssert(HandleGetType(handle) == TPM_HT_TRANSIENT);
// The index in the loaded object array is found by subtracting the first
// object handle number from the input handle number. If the indicated
// slot is occupied, then indicate that there is already is a loaded
// object associated with the handle.
slotIndex = handle - TRANSIENT_FIRST;
if(slotIndex >= MAX_LOADED_OBJECTS)
return FALSE;
return s_objects[slotIndex].occupied;
}
//
//
// ObjectIsSequence()
//
// This function is used to check if the object is a sequence object. This function should not be called if the
// handle does not reference a loaded object.
//
// Return Value Meaning
//
// TRUE object is an HMAC, hash, or event sequence object
// FALSE object is not an HMAC, hash, or event sequence object
//
BOOL
ObjectIsSequence(
OBJECT *object // IN: handle to be checked
)
{
pAssert (object != NULL);
if( object->attributes.hmacSeq == SET
|| object->attributes.hashSeq == SET
|| object->attributes.eventSeq == SET)
return TRUE;
else
return FALSE;
}
//
//
// ObjectGet()
//
// This function is used to find the object structure associated with a handle.
// This function requires that handle references a loaded object.
//
OBJECT*
ObjectGet(
TPMI_DH_OBJECT handle // IN: handle of the object
)
{
pAssert( handle >= TRANSIENT_FIRST
&& handle - TRANSIENT_FIRST < MAX_LOADED_OBJECTS);
pAssert(s_objects[handle - TRANSIENT_FIRST].occupied == TRUE);
// In this implementation, the handle is determined by the slot occupied by the
// object.
return &s_objects[handle - TRANSIENT_FIRST].object.entity;
}
//
//
// ObjectGetName()
//
// This function is used to access the Name of the object. In this implementation, the Name is computed
// when the object is loaded and is saved in the internal representation of the object. This function copies
// the Name data from the object into the buffer at name and returns the number of octets copied.
// This function requires that handle references a loaded object.
//
UINT16
ObjectGetName(
TPMI_DH_OBJECT handle, // IN: handle of the object
NAME *name // OUT: name of the object
)
{
OBJECT *object = ObjectGet(handle);
if(object->publicArea.nameAlg == TPM_ALG_NULL)
return 0;
// Copy the Name data to the output
MemoryCopy(name, object->name.t.name, object->name.t.size, sizeof(NAME));
return object->name.t.size;
}
//
//
// ObjectGetNameAlg()
//
// This function is used to get the Name algorithm of a object.
// This function requires that handle references a loaded object.
//
TPMI_ALG_HASH
ObjectGetNameAlg(
TPMI_DH_OBJECT handle // IN: handle of the object
)
{
OBJECT *object = ObjectGet(handle);
return object->publicArea.nameAlg;
}
//
//
//
// ObjectGetQualifiedName()
//
// This function returns the Qualified Name of the object. In this implementation, the Qualified Name is
// computed when the object is loaded and is saved in the internal representation of the object. The
// alternative would be to retain the Name of the parent and compute the QN when needed. This would take
// the same amount of space so it is not recommended that the alternate be used.
// This function requires that handle references a loaded object.
//
void
ObjectGetQualifiedName(
TPMI_DH_OBJECT handle, // IN: handle of the object
TPM2B_NAME *qualifiedName // OUT: qualified name of the object
)
{
OBJECT *object = ObjectGet(handle);
if(object->publicArea.nameAlg == TPM_ALG_NULL)
qualifiedName->t.size = 0;
else
// Copy the name
*qualifiedName = object->qualifiedName;
return;
}
//
//
// ObjectDataGetHierarchy()
//
// This function returns the handle for the hierarchy of an object.
//
TPMI_RH_HIERARCHY
ObjectDataGetHierarchy(
OBJECT *object // IN :object
)
{
if(object->attributes.spsHierarchy)
{
return TPM_RH_OWNER;
}
else if(object->attributes.epsHierarchy)
{
return TPM_RH_ENDORSEMENT;
}
else if(object->attributes.ppsHierarchy)
{
return TPM_RH_PLATFORM;
}
else
{
return TPM_RH_NULL;
}
}
//
//
// ObjectGetHierarchy()
//
// This function returns the handle of the hierarchy to which a handle belongs. This function is similar to
// ObjectDataGetHierarchy() but this routine takes a handle but ObjectDataGetHierarchy() takes an pointer
// to an object.
// This function requires that handle references a loaded object.
//
TPMI_RH_HIERARCHY
ObjectGetHierarchy(
TPMI_DH_OBJECT handle // IN :object handle
)
{
OBJECT *object = ObjectGet(handle);
return ObjectDataGetHierarchy(object);
}
//
//
// ObjectAllocateSlot()
//
// This function is used to allocate a slot in internal object array.
//
// Return Value Meaning
//
// TRUE allocate success
// FALSE do not have free slot
//
static BOOL
ObjectAllocateSlot(
TPMI_DH_OBJECT *handle, // OUT: handle of allocated object
OBJECT **object // OUT: points to the allocated object
)
{
UINT32 i;
// find an unoccupied handle slot
for(i = 0; i < MAX_LOADED_OBJECTS; i++)
{
if(!s_objects[i].occupied) // If found a free slot
{
// Mark the slot as occupied
s_objects[i].occupied = TRUE;
break;
}
}
// If we reach the end of object slot without finding a free one, return
// error.
if(i == MAX_LOADED_OBJECTS) return FALSE;
*handle = i + TRANSIENT_FIRST;
*object = &s_objects[i].object.entity;
// Initialize the container.
MemorySet(*object, 0, sizeof(**object));
return TRUE;
}
//
//
// ObjectLoad()
//
// This function loads an object into an internal object structure. If an error is returned, the internal state is
// unchanged.
//
//
//
//
// Error Returns Meaning
//
// TPM_RC_BINDING if the public and sensitive parts of the object are not matched
// TPM_RC_KEY if the parameters in the public area of the object are not consistent
// TPM_RC_OBJECT_MEMORY if there is no free slot for an object
// TPM_RC_TYPE the public and private parts are not the same type
//
TPM_RC
ObjectLoad(
TPMI_RH_HIERARCHY hierarchy, // IN: hierarchy to which the object belongs
TPMT_PUBLIC *publicArea, // IN: public area
TPMT_SENSITIVE *sensitive, // IN: sensitive area (may be null)
TPM2B_NAME *name, // IN: object's name (may be null)
TPM_HANDLE parentHandle, // IN: handle of parent
BOOL skipChecks, // IN: flag to indicate if it is OK to skip
// consistency checks.
TPMI_DH_OBJECT *handle // OUT: object handle
)
{
OBJECT *object = NULL;
OBJECT *parent = NULL;
TPM_RC result = TPM_RC_SUCCESS;
TPM2B_NAME parentQN; // Parent qualified name
// Try to allocate a slot for new object
if(!ObjectAllocateSlot(handle, &object))
return TPM_RC_OBJECT_MEMORY;
// Initialize public
object->publicArea = *publicArea;
if(sensitive != NULL)
object->sensitive = *sensitive;
// Are the consistency checks needed
if(!skipChecks)
{
// Check if key size matches
if(!CryptObjectIsPublicConsistent(&object->publicArea))
{
result = TPM_RC_KEY;
goto ErrorExit;
}
if(sensitive != NULL)
{
// Check if public type matches sensitive type
result = CryptObjectPublicPrivateMatch(object);
if(result != TPM_RC_SUCCESS)
goto ErrorExit;
}
}
object->attributes.publicOnly = (sensitive == NULL);
// If 'name' is NULL, then there is nothing left to do for this
// object as it has no qualified name and it is not a member of any
// hierarchy and it is temporary
if(name == NULL || name->t.size == 0)
{
object->qualifiedName.t.size = 0;
object->name.t.size = 0;
object->attributes.temporary = SET;
return TPM_RC_SUCCESS;
}
// If parent handle is a permanent handle, it is a primary or temporary
// object
if(HandleGetType(parentHandle) == TPM_HT_PERMANENT)
{
// initialize QN
parentQN.t.size = 4;
// for a primary key, parent qualified name is the handle of hierarchy
UINT32_TO_BYTE_ARRAY(parentHandle, parentQN.t.name);
}
else
{
// Get hierarchy and qualified name of parent
ObjectGetQualifiedName(parentHandle, &parentQN);
// Check for stClear object
parent = ObjectGet(parentHandle);
if( publicArea->objectAttributes.stClear == SET
|| parent->attributes.stClear == SET)
object->attributes.stClear = SET;
}
object->name = *name;
// Compute object qualified name
ObjectComputeQualifiedName(&parentQN, publicArea->nameAlg,
name, &object->qualifiedName);
// Any object in TPM_RH_NULL hierarchy is temporary
if(hierarchy == TPM_RH_NULL)
{
object->attributes.temporary = SET;
}
else if(parentQN.t.size == sizeof(TPM_HANDLE))
{
// Otherwise, if the size of parent's qualified name is the size of a
// handle, this object is a primary object
object->attributes.primary = SET;
}
switch(hierarchy)
{
case TPM_RH_PLATFORM:
object->attributes.ppsHierarchy = SET;
break;
case TPM_RH_OWNER:
object->attributes.spsHierarchy = SET;
break;
case TPM_RH_ENDORSEMENT:
object->attributes.epsHierarchy = SET;
break;
case TPM_RH_NULL:
break;
default:
pAssert(FALSE);
break;
}
return TPM_RC_SUCCESS;
ErrorExit:
ObjectFlush(*handle);
return result;
}
//
//
//
// AllocateSequenceSlot()
//
// This function allocates a sequence slot and initializes the parts that are used by the normal objects so
// that a sequence object is not inadvertently used for an operation that is not appropriate for a sequence.
//
static BOOL
AllocateSequenceSlot(
TPM_HANDLE *newHandle, // OUT: receives the allocated handle
HASH_OBJECT **object, // OUT: receives pointer to allocated object
TPM2B_AUTH *auth // IN: the authValue for the slot
)
{
OBJECT *objectHash; // the hash as an object
if(!ObjectAllocateSlot(newHandle, &objectHash))
return FALSE;
*object = (HASH_OBJECT *)objectHash;
// Validate that the proper location of the hash state data relative to the
// object state data.
pAssert(&((*object)->auth) == &objectHash->publicArea.authPolicy);
// Set the common values that a sequence object shares with an ordinary object
// The type is TPM_ALG_NULL
(*object)->type = TPM_ALG_NULL;
// This has no name algorithm and the name is the Empty Buffer
(*object)->nameAlg = TPM_ALG_NULL;
// Clear the attributes
MemorySet(&((*object)->objectAttributes), 0, sizeof(TPMA_OBJECT));
// A sequence object is considered to be in the NULL hierarchy so it should
// be marked as temporary so that it can't be persisted
(*object)->attributes.temporary = SET;
// A sequence object is DA exempt.
(*object)->objectAttributes.noDA = SET;
if(auth != NULL)
{
MemoryRemoveTrailingZeros(auth);
(*object)->auth = *auth;
}
else
(*object)->auth.t.size = 0;
return TRUE;
}
//
//
// ObjectCreateHMACSequence()
//
// This function creates an internal HMAC sequence object.
//
// Error Returns Meaning
//
// TPM_RC_OBJECT_MEMORY if there is no free slot for an object
//
TPM_RC
ObjectCreateHMACSequence(
TPMI_ALG_HASH hashAlg, // IN: hash algorithm
TPM_HANDLE handle, // IN: the handle associated with sequence
// object
TPM2B_AUTH *auth, // IN: authValue
TPMI_DH_OBJECT *newHandle // OUT: HMAC sequence object handle
)
{
HASH_OBJECT *hmacObject;
OBJECT *keyObject;
// Try to allocate a slot for new object
if(!AllocateSequenceSlot(newHandle, &hmacObject, auth))
return TPM_RC_OBJECT_MEMORY;
// Set HMAC sequence bit
hmacObject->attributes.hmacSeq = SET;
// Get pointer to the HMAC key object
keyObject = ObjectGet(handle);
CryptStartHMACSequence2B(hashAlg, &keyObject->sensitive.sensitive.bits.b,
&hmacObject->state.hmacState);
return TPM_RC_SUCCESS;
}
//
//
// ObjectCreateHashSequence()
//
// This function creates a hash sequence object.
//
// Error Returns Meaning
//
// TPM_RC_OBJECT_MEMORY if there is no free slot for an object
//
TPM_RC
ObjectCreateHashSequence(
TPMI_ALG_HASH hashAlg, // IN: hash algorithm
TPM2B_AUTH *auth, // IN: authValue
TPMI_DH_OBJECT *newHandle // OUT: sequence object handle
)
{
HASH_OBJECT *hashObject;
// Try to allocate a slot for new object
if(!AllocateSequenceSlot(newHandle, &hashObject, auth))
return TPM_RC_OBJECT_MEMORY;
// Set hash sequence bit
hashObject->attributes.hashSeq = SET;
// Start hash for hash sequence
CryptStartHashSequence(hashAlg, &hashObject->state.hashState[0]);
return TPM_RC_SUCCESS;
}
//
//
// ObjectCreateEventSequence()
//
// This function creates an event sequence object.
//
// Error Returns Meaning
//
// TPM_RC_OBJECT_MEMORY if there is no free slot for an object
//
TPM_RC
ObjectCreateEventSequence(
TPM2B_AUTH *auth, // IN: authValue
TPMI_DH_OBJECT *newHandle // OUT: sequence object handle
)
{
HASH_OBJECT *hashObject;
UINT32 count;
TPM_ALG_ID hash;
// Try to allocate a slot for new object
if(!AllocateSequenceSlot(newHandle, &hashObject, auth))
return TPM_RC_OBJECT_MEMORY;
// Set the event sequence attribute
hashObject->attributes.eventSeq = SET;
// Initialize hash states for each implemented PCR algorithms
for(count = 0; (hash = CryptGetHashAlgByIndex(count)) != TPM_ALG_NULL; count++)
{
// If this is a _TPM_Init or _TPM_HashStart, the sequence object will
// not leave the TPM so it doesn't need the sequence handling
if(auth == NULL)
CryptStartHash(hash, &hashObject->state.hashState[count]);
else
CryptStartHashSequence(hash, &hashObject->state.hashState[count]);
}
return TPM_RC_SUCCESS;
}
//
//
// ObjectTerminateEvent()
//
// This function is called to close out the event sequence and clean up the hash context states.
//
void
ObjectTerminateEvent(
void
)
{
HASH_OBJECT *hashObject;
int count;
BYTE buffer[MAX_DIGEST_SIZE];
hashObject = (HASH_OBJECT *)ObjectGet(g_DRTMHandle);
// Don't assume that this is a proper sequence object
if(hashObject->attributes.eventSeq)
{
// If it is, close any open hash contexts. This is done in case
// the crypto implementation has some context values that need to be
// cleaned up (hygiene).
//
for(count = 0; CryptGetHashAlgByIndex(count) != TPM_ALG_NULL; count++)
{
CryptCompleteHash(&hashObject->state.hashState[count], 0, buffer);
}
// Flush sequence object
ObjectFlush(g_DRTMHandle);
}
g_DRTMHandle = TPM_RH_UNASSIGNED;
}
//
//
//
// ObjectContextLoad()
//
// This function loads an object from a saved object context.
//
// Error Returns Meaning
//
// TPM_RC_OBJECT_MEMORY if there is no free slot for an object
//
TPM_RC
ObjectContextLoad(
OBJECT *object, // IN: object structure from saved context
TPMI_DH_OBJECT *handle // OUT: object handle
)
{
OBJECT *newObject;
// Try to allocate a slot for new object
if(!ObjectAllocateSlot(handle, &newObject))
return TPM_RC_OBJECT_MEMORY;
// Copy input object data to internal structure
*newObject = *object;
return TPM_RC_SUCCESS;
}
//
//
// ObjectFlush()
//
// This function frees an object slot.
// This function requires that the object is loaded.
//
void
ObjectFlush(
TPMI_DH_OBJECT handle // IN: handle to be freed
)
{
UINT32 index = handle - TRANSIENT_FIRST;
pAssert(ObjectIsPresent(handle));
// Mark the handle slot as unoccupied
s_objects[index].occupied = FALSE;
// With no attributes
MemorySet((BYTE*)&(s_objects[index].object.entity.attributes),
0, sizeof(OBJECT_ATTRIBUTES));
return;
}
//
//
// ObjectFlushHierarchy()
//
// This function is called to flush all the loaded transient objects associated with a hierarchy when the
// hierarchy is disabled.
//
void
ObjectFlushHierarchy(
TPMI_RH_HIERARCHY hierarchy // IN: hierarchy to be flush
)
{
UINT16 i;
// iterate object slots
for(i = 0; i < MAX_LOADED_OBJECTS; i++)
{
if(s_objects[i].occupied) // If found an occupied slot
{
switch(hierarchy)
{
case TPM_RH_PLATFORM:
if(s_objects[i].object.entity.attributes.ppsHierarchy == SET)
s_objects[i].occupied = FALSE;
break;
case TPM_RH_OWNER:
if(s_objects[i].object.entity.attributes.spsHierarchy == SET)
s_objects[i].occupied = FALSE;
break;
case TPM_RH_ENDORSEMENT:
if(s_objects[i].object.entity.attributes.epsHierarchy == SET)
s_objects[i].occupied = FALSE;
break;
default:
pAssert(FALSE);
break;
}
}
}
return;
}
//
//
// ObjectLoadEvict()
//
// This function loads a persistent object into a transient object slot.
// This function requires that handle is associated with a persistent object.
//
// Error Returns Meaning
//
// TPM_RC_HANDLE the persistent object does not exist or the associated hierarchy is
// disabled.
// TPM_RC_OBJECT_MEMORY no object slot
//
TPM_RC
ObjectLoadEvict(
TPM_HANDLE *handle, // IN:OUT: evict object handle. If success, it
// will be replace by the loaded object handle
TPM_CC commandCode // IN: the command being processed
)
{
TPM_RC result;
TPM_HANDLE evictHandle = *handle; // Save the evict handle
OBJECT *object;
// If this is an index that references a persistent object created by
// the platform, then return TPM_RH_HANDLE if the phEnable is FALSE
if(*handle >= PLATFORM_PERSISTENT)
{
// belongs to platform
if(g_phEnable == CLEAR)
return TPM_RC_HANDLE;
}
// belongs to owner
else if(gc.shEnable == CLEAR)
return TPM_RC_HANDLE;
// Try to allocate a slot for an object
if(!ObjectAllocateSlot(handle, &object))
return TPM_RC_OBJECT_MEMORY;
// Copy persistent object to transient object slot. A TPM_RC_HANDLE
// may be returned at this point. This will mark the slot as containing
// a transient object so that it will be flushed at the end of the
// command
result = NvGetEvictObject(evictHandle, object);
// Bail out if this failed
if(result != TPM_RC_SUCCESS)
return result;
// check the object to see if it is in the endorsement hierarchy
// if it is and this is not a TPM2_EvictControl() command, indicate
// that the hierarchy is disabled.
// If the associated hierarchy is disabled, make it look like the
// handle is not defined
if( ObjectDataGetHierarchy(object) == TPM_RH_ENDORSEMENT
&& gc.ehEnable == CLEAR
&& commandCode != TPM_CC_EvictControl
)
return TPM_RC_HANDLE;
return result;
}
//
//
// ObjectComputeName()
//
// This function computes the Name of an object from its public area.
//
void
ObjectComputeName(
TPMT_PUBLIC *publicArea, // IN: public area of an object
TPM2B_NAME *name // OUT: name of the object
)
{
TPM2B_PUBLIC marshalBuffer;
BYTE *buffer; // auxiliary marshal buffer pointer
INT32 bufferSize;
HASH_STATE hashState; // hash state
// if the nameAlg is NULL then there is no name.
if(publicArea->nameAlg == TPM_ALG_NULL)
{
name->t.size = 0;
return;
}
// Start hash stack
name->t.size = CryptStartHash(publicArea->nameAlg, &hashState);
// Marshal the public area into its canonical form
buffer = marshalBuffer.b.buffer;
bufferSize = sizeof(TPMT_PUBLIC);
marshalBuffer.t.size = TPMT_PUBLIC_Marshal(publicArea, &buffer, &bufferSize);
// Adding public area
CryptUpdateDigest2B(&hashState, &marshalBuffer.b);
// Complete hash leaving room for the name algorithm
CryptCompleteHash(&hashState, name->t.size, &name->t.name[2]);
// set the nameAlg
UINT16_TO_BYTE_ARRAY(publicArea->nameAlg, name->t.name);
//
name->t.size += 2;
return;
}
//
//
// ObjectComputeQualifiedName()
//
// This function computes the qualified name of an object.
//
void
ObjectComputeQualifiedName(
TPM2B_NAME *parentQN, // IN: parent's qualified name
TPM_ALG_ID nameAlg, // IN: name hash
TPM2B_NAME *name, // IN: name of the object
TPM2B_NAME *qualifiedName // OUT: qualified name of the object
)
{
HASH_STATE hashState; // hash state
// QN_A = hash_A (QN of parent || NAME_A)
// Start hash
qualifiedName->t.size = CryptStartHash(nameAlg, &hashState);
// Add parent's qualified name
CryptUpdateDigest2B(&hashState, &parentQN->b);
// Add self name
CryptUpdateDigest2B(&hashState, &name->b);
// Complete hash leaving room for the name algorithm
CryptCompleteHash(&hashState, qualifiedName->t.size,
&qualifiedName->t.name[2]);
UINT16_TO_BYTE_ARRAY(nameAlg, qualifiedName->t.name);
qualifiedName->t.size += 2;
return;
}
//
//
// ObjectDataIsStorage()
//
// This function determines if a public area has the attributes associated with a storage key. A storage key is
// an asymmetric object that has its restricted and decrypt attributes SET, and sign CLEAR.
//
// Return Value Meaning
//
// TRUE if the object is a storage key
// FALSE if the object is not a storage key
//
BOOL
ObjectDataIsStorage(
TPMT_PUBLIC *publicArea // IN: public area of the object
)
{
if( CryptIsAsymAlgorithm(publicArea->type) // must be asymmetric,
&& publicArea->objectAttributes.restricted == SET // restricted,
&& publicArea->objectAttributes.decrypt == SET // decryption key
&& publicArea->objectAttributes.sign == CLEAR // can not be sign key
)
return TRUE;
else
return FALSE;
}
//
// ObjectIsStorage()
//
// This function determines if an object has the attributes associated with a storage key. A storage key is an
// asymmetric object that has its restricted and decrypt attributes SET, and sign CLEAR.
//
// Return Value Meaning
//
// TRUE if the object is a storage key
// FALSE if the object is not a storage key
//
BOOL
ObjectIsStorage(
TPMI_DH_OBJECT handle // IN: object handle
)
{
OBJECT *object = ObjectGet(handle);
return ObjectDataIsStorage(&object->publicArea);
}
//
//
// ObjectCapGetLoaded()
//
// This function returns a a list of handles of loaded object, starting from handle. Handle must be in the
// range of valid transient object handles, but does not have to be the handle of a loaded transient object.
//
// Return Value Meaning
//
// YES if there are more handles available
// NO all the available handles has been returned
//
TPMI_YES_NO
ObjectCapGetLoaded(
TPMI_DH_OBJECT handle, // IN: start handle
UINT32 count, // IN: count of returned handles
TPML_HANDLE *handleList // OUT: list of handle
)
{
TPMI_YES_NO more = NO;
UINT32 i;
pAssert(HandleGetType(handle) == TPM_HT_TRANSIENT);
// 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 object slots to get loaded object handles
for(i = handle - TRANSIENT_FIRST; i < MAX_LOADED_OBJECTS; i++)
{
if(s_objects[i].occupied == TRUE)
{
// A valid transient object can not be the copy of a persistent object
pAssert(s_objects[i].object.entity.attributes.evict == CLEAR);
if(handleList->count < count)
{
// If we have not filled up the return list, add this object
// handle to it
handleList->handle[handleList->count] = i + TRANSIENT_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;
}
//
//
// ObjectCapGetTransientAvail()
//
// This function returns an estimate of the number of additional transient objects that could be loaded into
// the TPM.
//
UINT32
ObjectCapGetTransientAvail(
void
)
{
UINT32 i;
UINT32 num = 0;
// Iterate object slot to get the number of unoccupied slots
for(i = 0; i < MAX_LOADED_OBJECTS; i++)
{
if(s_objects[i].occupied == FALSE) num++;
}
return num;
}