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