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

#include "InternalRoutines.h"

#include "Platform.h"

//

//      The initial value of PCR attributes. The value of these fields should be consistent with PC Client

//      specification In this implementation, we assume the total number of implemented PCR is 24.

//

static const PCR_Attributes s_initAttributes[] =

{

    // PCR    0 - 15, static RTM

    {1, 0,    0x1F}, {1, 0, 0x1F},     {1,   0,    0x1F},   {1,   0,   0x1F},

    {1, 0,    0x1F}, {1, 0, 0x1F},     {1,   0,    0x1F},   {1,   0,   0x1F},

    {1, 0,    0x1F}, {1, 0, 0x1F},     {1,   0,    0x1F},   {1,   0,   0x1F},

    {1, 0,    0x1F}, {1, 0, 0x1F},     {1,   0,    0x1F},   {1,   0,   0x1F},

    {0,   0x0F,   0x1F},         //   PCR    16,   Debug

    {0,   0x10,   0x1C},         //   PCR    17,   Locality 4

    {0,   0x10,   0x1C},         //   PCR    18,   Locality 3

    {0,   0x10,   0x0C},         //   PCR    19,   Locality 2

    {0,   0x1C,   0x0E},         //   PCR    20,   Locality 1

    {0,   0x1C,   0x04},         //   PCR    21,   Dynamic OS

    {0,   0x1C,   0x04},         //   PCR    22,   Dynamic OS

    {0,   0x0F,   0x1F},         //   PCR    23,   App specific

    {0,   0x0F,   0x1F}          //   PCR    24,   testing policy

};

//

//

//           Functions

//

//          PCRBelongsAuthGroup()

//

//     This function indicates if a PCR belongs to a group that requires an authValue in order to modify the

//     PCR. If it does, groupIndex is set to value of the group index. This feature of PCR is decided by the

//     platform specification.

//

//     Return Value                    Meaning

//

//     TRUE:                           PCR belongs an auth group

//     FALSE:                          PCR does not belong an auth group

//

BOOL

PCRBelongsAuthGroup(

    TPMI_DH_PCR          handle,              // IN: handle of PCR

    UINT32              *groupIndex           // OUT: group index if PCR belongs a

                                              //      group that allows authValue. If PCR

                                              //      does not belong to an auth group,

                                              //      the value in this parameter is

                                              //      invalid

)

{

  // None of the PCRs belong to a group requiring an authValue, as defined in

  // Table 4 "PCR Attributes" of the "TCG PC Client Platform TPM Profile (TPT)

  // Specification Level 00 Revision 00.43".

  return FALSE;

}

//

//

//          PCRBelongsPolicyGroup()

//

//     This function indicates if a PCR belongs to a group that requires a policy authorization in order to modify

//     the PCR. If it does, groupIndex is set to value of the group index. This feature of PCR is decided by the

//     platform specification.

//     Family "2.0"                                   TCG Published                                          Page 169

//     Level 00 Revision 01.16                Copyright © TCG 2006-2014                             October 30, 2014

//     Trusted Platform Module Library                                          Part 4: Supporting Routines

//

//

//     Return Value                      Meaning

//

//     TRUE:                             PCR belongs a policy group

//     FALSE:                            PCR does not belong a policy group

//

BOOL

PCRBelongsPolicyGroup(

    TPMI_DH_PCR           handle,            // IN: handle of PCR

    UINT32               *groupIndex         // OUT: group index if PCR belongs a group that

                                             //     allows policy. If PCR does not belong to

                                             //     a policy group, the value in this

                                             //     parameter is invalid

   )

{

  // None of the PCRs belong to the policy group, as defined in Table 4

  // "PCR Attributes" of the "TCG PC Client Platform TPM Profile (TPT)

  // Specification Level 00 Revision 00.43".

  return FALSE;

}

//

//

//           PCRBelongsTCBGroup()

//

//     This function indicates if a PCR belongs to the TCB group.

//

//     Return Value                      Meaning

//

//     TRUE:                             PCR belongs to TCB group

//     FALSE:                            PCR does not belong to TCB group

//

static BOOL

PCRBelongsTCBGroup(

    TPMI_DH_PCR           handle             // IN: handle of PCR

    )

{

#if ENABLE_PCR_NO_INCREMENT == YES

  // Platform specification decides if a PCR belongs to a TCB group. In this

  // implementation, we assume PCR[16, 21-23] belong to TCB group as defined

  // in Table 4. If the platform specification requires differently, the

  // implementation should be changed accordingly

  if(handle == 16 || (handle >= 21 && handle <= 23))

    return TRUE;

#endif

   return FALSE;

}

//

//

//           PCRPolicyIsAvailable()

//

//     This function indicates if a policy is available for a PCR.

//

//

//

//

//      Return Value                     Meaning

//

//      TRUE                             the PCR should be authorized by policy

//      FALSE                            the PCR does not allow policy

//

BOOL

PCRPolicyIsAvailable(

    TPMI_DH_PCR          handle             // IN: PCR handle

    )

{

    UINT32              groupIndex;

    return PCRBelongsPolicyGroup(handle, &groupIndex);

}

//

//

//           PCRGetAuthValue()

//

//      This function is used to access the authValue of a PCR. If PCR does not belong to an authValue group,

//      an Empty Auth will be returned.

//

void

PCRGetAuthValue(

    TPMI_DH_PCR          handle,            // IN: PCR handle

    TPM2B_AUTH          *auth               // OUT: authValue of PCR

    )

{

    UINT32         groupIndex;

    if(PCRBelongsAuthGroup(handle, &groupIndex))

    {

        *auth = gc.pcrAuthValues.auth[groupIndex];

    }

    else

    {

        auth->t.size = 0;

    }

    return;

}

//

//

//           PCRGetAuthPolicy()

//

//      This function is used to access the authorization policy of a PCR. It sets policy to the authorization policy

//      and returns the hash algorithm for policy If the PCR does not allow a policy, TPM_ALG_NULL is returned.

//

TPMI_ALG_HASH

PCRGetAuthPolicy(

    TPMI_DH_PCR          handle,            // IN: PCR handle

    TPM2B_DIGEST        *policy             // OUT: policy of PCR

    )

{

    UINT32               groupIndex;

    if(PCRBelongsPolicyGroup(handle, &groupIndex))

    {

        *policy = gp.pcrPolicies.policy[groupIndex];

        return gp.pcrPolicies.hashAlg[groupIndex];

    }

    else

    {

        policy->t.size = 0;

          return TPM_ALG_NULL;

   }

}

//

//

//            PCRSimStart()

//

//      This function is used to initialize the policies when a TPM is manufactured. This function would only be

//      called in a manufacturing environment or in a TPM simulator.

//

void

PCRSimStart(

   void

   )

{

   UINT32 i;

   for(i = 0; i < NUM_POLICY_PCR_GROUP; i++)

   {

       gp.pcrPolicies.hashAlg[i] = TPM_ALG_NULL;

       gp.pcrPolicies.policy[i].t.size = 0;

   }

   for(i = 0; i < NUM_AUTHVALUE_PCR_GROUP; i++)

   {

       gc.pcrAuthValues.auth[i].t.size = 0;

   }

   // We need to give an initial configuration on allocated PCR before

   // receiving any TPM2_PCR_Allocate command to change this configuration

   // When the simulation environment starts, we allocate all the PCRs

   for(gp.pcrAllocated.count = 0; gp.pcrAllocated.count < HASH_COUNT;

           gp.pcrAllocated.count++)

   {

       gp.pcrAllocated.pcrSelections[gp.pcrAllocated.count].hash

           = CryptGetHashAlgByIndex(gp.pcrAllocated.count);

          gp.pcrAllocated.pcrSelections[gp.pcrAllocated.count].sizeofSelect

              = PCR_SELECT_MAX;

          for(i = 0; i < PCR_SELECT_MAX; i++)

              gp.pcrAllocated.pcrSelections[gp.pcrAllocated.count].pcrSelect[i]

                  = 0xFF;

   }

   // Store the initial configuration to NV

   NvWriteReserved(NV_PCR_POLICIES, &gp.pcrPolicies);

   NvWriteReserved(NV_PCR_ALLOCATED, &gp.pcrAllocated);

   return;

}

//

//

//            GetSavedPcrPointer()

//

//      This function returns the address of an array of state saved PCR based on the hash algorithm.

//

//      Return Value                      Meaning

//

//      NULL                              no such algorithm

//      not NULL                          pointer to the 0th byte of the 0th PCR

//

static BYTE *

GetSavedPcrPointer (

   TPM_ALG_ID           alg,                 // IN: algorithm for bank

   UINT32               pcrIndex             // IN: PCR index in PCR_SAVE

    )

{

   switch(alg)

   {

#ifdef TPM_ALG_SHA1

   case TPM_ALG_SHA1:

       return gc.pcrSave.sha1[pcrIndex];

       break;

#endif

#ifdef TPM_ALG_SHA256

   case TPM_ALG_SHA256:

       return gc.pcrSave.sha256[pcrIndex];

       break;

#endif

#ifdef TPM_ALG_SHA384

   case TPM_ALG_SHA384:

       return gc.pcrSave.sha384[pcrIndex];

       break;

#endif

#ifdef TPM_ALG_SHA512

   case TPM_ALG_SHA512:

       return gc.pcrSave.sha512[pcrIndex];

       break;

#endif

#ifdef TPM_ALG_SM3_256

   case TPM_ALG_SM3_256:

       return gc.pcrSave.sm3_256[pcrIndex];

       break;

#endif

   default:

       FAIL(FATAL_ERROR_INTERNAL);

   }

   return NULL; // Never reached.

}

//

//

//           PcrIsAllocated()

//

//      This function indicates if a PCR number for the particular hash algorithm is allocated.

//

//      Return Value                     Meaning

//

//      FALSE                            PCR is not allocated

//      TRUE                             PCR is allocated

//

BOOL

PcrIsAllocated (

    UINT32               pcr,               // IN: The number of the PCR

    TPMI_ALG_HASH        hashAlg            // IN: The PCR algorithm

    )

{

    UINT32                    i;

    BOOL                      allocated = FALSE;

    if(pcr < IMPLEMENTATION_PCR)

    {

         for(i = 0; i < gp.pcrAllocated.count; i++)

         {

             if(gp.pcrAllocated.pcrSelections[i].hash == hashAlg)

             {

                 if(((gp.pcrAllocated.pcrSelections[i].pcrSelect[pcr/8])

                         & (1 << (pcr % 8))) != 0)

//

                        allocated = TRUE;

                    else

                        allocated = FALSE;

                    break;

                }

          }

   }

   return allocated;

}

//

//

//             GetPcrPointer()

//

//      This function returns the address of an array of PCR based on the hash algorithm.

//

//      Return Value                      Meaning

//

//      NULL                              no such algorithm

//      not NULL                          pointer to the 0th byte of the 0th PCR

//

static BYTE *

GetPcrPointer (

   TPM_ALG_ID            alg,                // IN: algorithm for bank

   UINT32                pcrNumber           // IN: PCR number

   )

{

   static BYTE          *pcr = NULL;

   if(!PcrIsAllocated(pcrNumber, alg))

       return NULL;

   switch(alg)

   {

#ifdef TPM_ALG_SHA1

   case TPM_ALG_SHA1:

       pcr = s_pcrs[pcrNumber].sha1Pcr;

       break;

#endif

#ifdef TPM_ALG_SHA256

   case TPM_ALG_SHA256:

       pcr = s_pcrs[pcrNumber].sha256Pcr;

       break;

#endif

#ifdef TPM_ALG_SHA384

   case TPM_ALG_SHA384:

       pcr = s_pcrs[pcrNumber].sha384Pcr;

       break;

#endif

#ifdef TPM_ALG_SHA512

   case TPM_ALG_SHA512:

       pcr = s_pcrs[pcrNumber].sha512Pcr;

       break;

#endif

#ifdef TPM_ALG_SM3_256

   case TPM_ALG_SM3_256:

       pcr = s_pcrs[pcrNumber].sm3_256Pcr;

       break;

#endif

   default:

       pAssert(FALSE);

       break;

   }

   return pcr;

//

}

//

//

//          IsPcrSelected()

//

//      This function indicates if an indicated PCR number is selected by the bit map in selection.

//

//      Return Value                     Meaning

//

//      FALSE                            PCR is not selected

//      TRUE                             PCR is selected

//

static BOOL

IsPcrSelected (

   UINT32                     pcr,                // IN: The number of the PCR

   TPMS_PCR_SELECTION        *selection           // IN: The selection structure

   )

{

   BOOL                 selected = FALSE;

   if(   pcr < IMPLEMENTATION_PCR

      && ((selection->pcrSelect[pcr/8]) & (1 << (pcr % 8))) != 0)

       selected = TRUE;

   return selected;

}

//

//

//          FilterPcr()

//

//      This function modifies a PCR selection array based on the implemented PCR.

//

static void

FilterPcr(

   TPMS_PCR_SELECTION        *selection           // IN: input PCR selection

   )

{

   UINT32     i;

   TPMS_PCR_SELECTION            *allocated = NULL;

   // If size of select is less than PCR_SELECT_MAX, zero the unspecified PCR

   for(i = selection->sizeofSelect; i < PCR_SELECT_MAX; i++)

       selection->pcrSelect[i] = 0;

   // Find the internal configuration for the bank

   for(i = 0; i < gp.pcrAllocated.count; i++)

   {

       if(gp.pcrAllocated.pcrSelections[i].hash == selection->hash)

       {

           allocated = &gp.pcrAllocated.pcrSelections[i];

           break;

       }

   }

   for (i = 0; i < selection->sizeofSelect; i++)

   {

       if(allocated == NULL)

       {

            // If the required bank does not exist, clear input selection

            selection->pcrSelect[i] = 0;

       }

       else

            selection->pcrSelect[i] &= allocated->pcrSelect[i];

   }

   return;

}

//

//

//           PcrDrtm()

//

//      This function does the DRTM and H-CRTM processing it is called from _TPM_Hash_End().

//

void

PcrDrtm(

   const TPMI_DH_PCR              pcrHandle,       // IN: the index of the PCR to be

                                                   //     modified

   const TPMI_ALG_HASH            hash,            // IN: the bank identifier

   const TPM2B_DIGEST            *digest           // IN: the digest to modify the PCR

   )

{

   BYTE           *pcrData = GetPcrPointer(hash, pcrHandle);

   if(pcrData != NULL)

   {

       // Rest the PCR to zeros

       MemorySet(pcrData, 0, digest->t.size);

          // if the TPM has not started, then set the PCR to 0...04 and then extend

          if(!TPMIsStarted())

          {

              pcrData[digest->t.size - 1] = 4;

          }

          // Now, extend the value

          PCRExtend(pcrHandle, hash, digest->t.size, (BYTE *)digest->t.buffer);

   }

}

//

//

//           PCRStartup()

//

//      This function initializes the PCR subsystem at TPM2_Startup().

//

void

PCRStartup(

   STARTUP_TYPE         type,              // IN: startup type

   BYTE                 locality           // IN: startup locality

   )

{

   UINT32                  pcr, j;

   UINT32                  saveIndex = 0;

   g_pcrReConfig = FALSE;

   if(type != SU_RESUME)

   {

       // PCR generation counter is cleared at TPM_RESET and TPM_RESTART

       gr.pcrCounter = 0;

   }

   // Initialize/Restore PCR values

   for(pcr = 0; pcr < IMPLEMENTATION_PCR; pcr++)

   {

       // On resume, need to know if this PCR had its state saved or not

       UINT32      stateSaved =

           (type == SU_RESUME && s_initAttributes[pcr].stateSave == SET) ? 1 : 0;

          // If this is the H-CRTM PCR and we are not doing a resume and we

          // had an H-CRTM event, then we don't change this PCR

          if(pcr == HCRTM_PCR && type != SU_RESUME && g_DrtmPreStartup == TRUE)

              continue;

          // Iterate each hash algorithm bank

          for(j = 0; j < gp.pcrAllocated.count; j++)

          {

              TPMI_ALG_HASH    hash = gp.pcrAllocated.pcrSelections[j].hash;

              BYTE            *pcrData = GetPcrPointer(hash, pcr);

              UINT16           pcrSize = CryptGetHashDigestSize(hash);

              if(pcrData != NULL)

              {

                  // if state was saved

                  if(stateSaved == 1)

                  {

                      // Restore saved PCR value

                      BYTE     *pcrSavedData;

                      pcrSavedData = GetSavedPcrPointer(

                                          gp.pcrAllocated.pcrSelections[j].hash,

                                          saveIndex);

                      MemoryCopy(pcrData, pcrSavedData, pcrSize, pcrSize);

                  }

                  else

                      // PCR was not restored by state save

                  {

                      // If the reset locality of the PCR is 4, then

                      // the reset value is all one's, otherwise it is

                      // all zero.

                      if((s_initAttributes[pcr].resetLocality & 0x10) != 0)

                           MemorySet(pcrData, 0xFF, pcrSize);

                      else

                      {

                           MemorySet(pcrData, 0, pcrSize);

                           if(pcr == HCRTM_PCR)

                               pcrData[pcrSize-1] = locality;

                      }

                  }

              }

          }

          saveIndex += stateSaved;

   }

   // Reset authValues

   if(type != SU_RESUME)

   {

       for(j = 0; j < NUM_AUTHVALUE_PCR_GROUP; j++)

       {

           gc.pcrAuthValues.auth[j].t.size = 0;

       }

   }

}

//

//

//           PCRStateSave()

//

//      This function is used to save the PCR values that will be restored on TPM Resume.

//

void

PCRStateSave(

   TPM_SU                 type             // IN: startup type

   )

{

   UINT32                 pcr, j;

   UINT32                 saveIndex = 0;

//

   // if state save CLEAR, nothing to be done.            Return here

   if(type == TPM_SU_CLEAR) return;

   // Copy PCR values to the structure that should be saved to NV

   for(pcr = 0; pcr < IMPLEMENTATION_PCR; pcr++)

   {

       UINT32 stateSaved = (s_initAttributes[pcr].stateSave == SET) ? 1 : 0;

          // Iterate each hash algorithm bank

          for(j = 0; j < gp.pcrAllocated.count; j++)

          {

              BYTE    *pcrData;

              UINT32 pcrSize;

              pcrData = GetPcrPointer(gp.pcrAllocated.pcrSelections[j].hash, pcr);

              if(pcrData != NULL)

              {

                  pcrSize

                      = CryptGetHashDigestSize(gp.pcrAllocated.pcrSelections[j].hash);

                  if(stateSaved == 1)

                  {

                      // Restore saved PCR value

                      BYTE     *pcrSavedData;

                      pcrSavedData

                           = GetSavedPcrPointer(gp.pcrAllocated.pcrSelections[j].hash,

                                                saveIndex);

                      MemoryCopy(pcrSavedData, pcrData, pcrSize, pcrSize);

                  }

              }

          }

          saveIndex += stateSaved;

   }

   return;

}

//

//

//           PCRIsStateSaved()

//

//      This function indicates if the selected PCR is a PCR that is state saved on TPM2_Shutdown(STATE). The

//      return value is based on PCR attributes.

//

//      Return Value                      Meaning

//

//      TRUE                              PCR is state saved

//      FALSE                             PCR is not state saved

//

BOOL

PCRIsStateSaved(

   TPMI_DH_PCR         handle                // IN: PCR handle to be extended

   )

{

   UINT32                  pcr = handle - PCR_FIRST;

   if(s_initAttributes[pcr].stateSave == SET)

       return TRUE;

   else

       return FALSE;

}

//

//

//

//          PCRIsResetAllowed()

//

//      This function indicates if a PCR may be reset by the current command locality. The return value is based

//      on PCR attributes, and not the PCR allocation.

//

//      Return Value                    Meaning

//

//      TRUE                            TPM2_PCR_Reset() is allowed

//      FALSE                           TPM2_PCR_Reset() is not allowed

//

BOOL

PCRIsResetAllowed(

   TPMI_DH_PCR          handle            // IN: PCR handle to be extended

   )

{

   UINT8                     commandLocality;

   UINT8                     localityBits = 1;

   UINT32                    pcr = handle - PCR_FIRST;

   // Check for the locality

   commandLocality = _plat__LocalityGet();

#ifdef DRTM_PCR

   // For a TPM that does DRTM, Reset is not allowed at locality 4

   if(commandLocality == 4)

       return FALSE;

#endif

   localityBits = localityBits << commandLocality;

   if((localityBits & s_initAttributes[pcr].resetLocality) == 0)

       return FALSE;

   else

       return TRUE;

}

//

//

//          PCRChanged()

//

//      This function checks a PCR handle to see if the attributes for the PCR are set so that any change to the

//      PCR causes an increment of the pcrCounter. If it does, then the function increments the counter.

//

void

PCRChanged(

   TPM_HANDLE           pcrHandle         // IN: the handle of the PCR that changed.

   )

{

   // For the reference implementation, the only change that does not cause

   // increment is a change to a PCR in the TCB group.

   if(!PCRBelongsTCBGroup(pcrHandle))

       gr.pcrCounter++;

}

//

//

//          PCRIsExtendAllowed()

//

//      This function indicates a PCR may be extended at the current command locality. The return value is

//      based on PCR attributes, and not the PCR allocation.

//

//

//

//

//      Return Value                      Meaning

//

//      TRUE                              extend is allowed

//      FALSE                             extend is not allowed

//

BOOL

PCRIsExtendAllowed(

   TPMI_DH_PCR          handle               // IN: PCR handle to be extended

   )

{

   UINT8                    commandLocality;

   UINT8                    localityBits = 1;

   UINT32                   pcr = handle - PCR_FIRST;

   // Check for the locality

   commandLocality = _plat__LocalityGet();

   localityBits = localityBits << commandLocality;

   if((localityBits & s_initAttributes[pcr].extendLocality) == 0)

       return FALSE;

   else

       return TRUE;

}

//

//

//          PCRIsExtended()

//

//      This function checks if the PCR value is non-zero.

//

//      Return Value                      Meaning

//

//      TRUE                              value is non-zero (PCR extended)

//      FALSE                             value is zero (PCR was not extended yet)

//

static BOOL

PCRIsExtended(BYTE *pcrValue, UINT16 pcrSize)

{

   UINT16 n;

   for(n = 0; n < pcrSize; ++n, ++pcrValue)

   {

       if((*pcrValue) != 0)

          return TRUE;

   }

   return FALSE;

}

//

//

//           PCRExtend()

//

//      This function is used to extend a PCR in a specific bank.

//

void

PCRExtend(

   TPMI_DH_PCR          handle,              //   IN:    PCR handle to be extended

   TPMI_ALG_HASH        hash,                //   IN:    hash algorithm of PCR

   UINT32               size,                //   IN:    size of data to be extended

   BYTE                *data                 //   IN:    data to be extended

   )

{

   UINT32                    pcr = handle - PCR_FIRST;

   BYTE                     *pcrData;

   HASH_STATE                hashState;

   UINT16                    pcrSize;

   pcrData = GetPcrPointer(hash, pcr);

   // Extend PCR if it is allocated

   if(pcrData != NULL)

   {

       pcrSize = CryptGetHashDigestSize(hash);

       // Prevent double-extend for PCR0 (b/271637992).

       // Return success, but do nothing, if a 2nd extend is requested.

       if(pcr == 0 && PCRIsExtended(pcrData, pcrSize))

          return;

       CryptStartHash(hash, &hashState);

       CryptUpdateDigest(&hashState, pcrSize, pcrData);

       CryptUpdateDigest(&hashState, size, data);

       CryptCompleteHash(&hashState, pcrSize, pcrData);

          // If PCR does not belong to TCB group, increment PCR counter

          if(!PCRBelongsTCBGroup(handle))

              gr.pcrCounter++;

   }

   return;

}

//

//

//

//          PCRComputeCurrentDigest()

//

//      This function computes the digest of the selected PCR.

//      As a side-effect, selection is modified so that only the implemented PCR will have their bits still set.

//

void

PCRComputeCurrentDigest(

    TPMI_ALG_HASH             hashAlg,            // IN: hash algorithm to compute digest

    TPML_PCR_SELECTION       *selection,          // IN/OUT: PCR selection (filtered on

                                                  //     output)

    TPM2B_DIGEST             *digest              // OUT: digest

    )

{

    HASH_STATE                      hashState;

    TPMS_PCR_SELECTION             *select;

    BYTE                           *pcrData;   // will point to a digest

    UINT32                          pcrSize;

    UINT32                          pcr;

    UINT32                          i;

    // Initialize the hash

    digest->t.size = CryptStartHash(hashAlg, &hashState);

    pAssert(digest->t.size > 0 && digest->t.size < UINT16_MAX);

    // Iterate through the list of PCR selection structures

    for(i = 0; i < selection->count; i++)

    {

        // Point to the current selection

        select = &selection->pcrSelections[i]; // Point to the current selection

        FilterPcr(select);      // Clear out the bits for unimplemented PCR

          // Need the size of each digest

          pcrSize = CryptGetHashDigestSize(selection->pcrSelections[i].hash);

          // Iterate through the selection

          for(pcr = 0; pcr < IMPLEMENTATION_PCR; pcr++)

          {

              if(IsPcrSelected(pcr, select))         // Is this PCR selected

              {

                  // Get pointer to the digest data for the bank

                  pcrData = GetPcrPointer(selection->pcrSelections[i].hash, pcr);

                  pAssert(pcrData != NULL);

                  CryptUpdateDigest(&hashState, pcrSize, pcrData); // add to digest

              }

          }

    }

    // Complete hash stack

    CryptCompleteHash2B(&hashState, &digest->b);

    return;

}

//

//

//          PCRRead()

//

//      This function is used to read a list of selected PCR. If the requested PCR number exceeds the maximum

//      number that can be output, the selection is adjusted to reflect the actual output PCR.

//

void

PCRRead(

    TPML_PCR_SELECTION       *selection,          // IN/OUT: PCR selection (filtered on

                                                  //     output)

    TPML_DIGEST              *digest,             // OUT: digest

    UINT32                   *pcrCounter          // OUT: the current value of PCR generation

                                             //     number

   )

{

   TPMS_PCR_SELECTION            *select;

   BYTE                          *pcrData;        // will point to a digest

   UINT32                         pcr;

   UINT32                         i;

   digest->count = 0;

   // Iterate through the list of PCR selection structures

   for(i = 0; i < selection->count; i++)

   {

       // Point to the current selection

       select = &selection->pcrSelections[i]; // Point to the current selection

       FilterPcr(select);      // Clear out the bits for unimplemented PCR

        // Iterate through the selection

        for (pcr = 0; pcr < IMPLEMENTATION_PCR; pcr++)

        {

            if(IsPcrSelected(pcr, select))          // Is this PCR selected

            {

                // Check if number of digest exceed upper bound

                if(digest->count > 7)

                {

                    // Clear rest of the current select bitmap

                    while(    pcr < IMPLEMENTATION_PCR

                              // do not round up!

                           && (pcr / 8) < select->sizeofSelect)

                    {

                        // do not round up!

                        select->pcrSelect[pcr/8] &= (BYTE) ~(1 << (pcr % 8));

                        pcr++;

                    }

                    // Exit inner loop

                    break;;

                }

                // Need the size of each digest

                digest->digests[digest->count].t.size =

                    CryptGetHashDigestSize(selection->pcrSelections[i].hash);

                  // Get pointer to the digest data for the bank

                  pcrData = GetPcrPointer(selection->pcrSelections[i].hash, pcr);

                  pAssert(pcrData != NULL);

                  // Add to the data to digest

                  MemoryCopy(digest->digests[digest->count].t.buffer,

                             pcrData,

                             digest->digests[digest->count].t.size,

                             digest->digests[digest->count].t.size);

                  digest->count++;

            }

        }

        // If we exit inner loop because we have exceed the output upper bound

        if(digest->count > 7 && pcr < IMPLEMENTATION_PCR)

        {

            // Clear rest of the selection

            while(i < selection->count)

            {

                MemorySet(selection->pcrSelections[i].pcrSelect, 0,

                          selection->pcrSelections[i].sizeofSelect);

                i++;

            }

            // exit outer loop

            break;

        }

   }

   *pcrCounter = gr.pcrCounter;

   return;

}

//

//

//          PcrWrite()

//

//      This function is used by _TPM_Hash_End() to set a PCR to the computed hash of the H-CRTM event.

//

void

PcrWrite(

   TPMI_DH_PCR           handle,            // IN: PCR handle to be extended

   TPMI_ALG_HASH         hash,              // IN: hash algorithm of PCR

   TPM2B_DIGEST         *digest             // IN: the new value

   )

{

   UINT32                     pcr = handle - PCR_FIRST;

   BYTE                      *pcrData;

   // Copy value to the PCR if it is allocated

   pcrData = GetPcrPointer(hash, pcr);

   if(pcrData != NULL)

   {

       MemoryCopy(pcrData, digest->t.buffer, digest->t.size, digest->t.size); ;

   }

   return;

}

//

//

//          PCRAllocate()

//

//      This function is used to change the PCR allocation.

//

//      Error Returns                   Meaning

//

//      TPM_RC_SUCCESS                  allocate success

//      TPM_RC_NO_RESULTS               allocate failed

//      TPM_RC_PCR                      improper allocation

//

TPM_RC

PCRAllocate(

   TPML_PCR_SELECTION        *allocate,           //   IN: required allocation

   UINT32                    *maxPCR,             //   OUT: Maximum number of PCR

   UINT32                    *sizeNeeded,         //   OUT: required space

   UINT32                    *sizeAvailable       //   OUT: available space

   )

{

   UINT32                        i, j, k;

   TPML_PCR_SELECTION            newAllocate;

   // Initialize the flags       to indicate if HCRTM PCR and DRTM PCR are allocated.

   BOOL                          pcrHcrtm = FALSE;

   BOOL                          pcrDrtm = FALSE;

   // Create the expected new PCR allocation based on the existing allocation

   // and the new input:

   // 1. if a PCR bank does not appear in the new allocation, the existing

   //     allocation of this PCR bank will be preserved.

   // 2. if a PCR bank appears multiple times in the new allocation, only the

   //     last one will be in effect.

   newAllocate = gp.pcrAllocated;

   for(i = 0; i < allocate->count; i++)

   {

       for(j = 0; j < newAllocate.count; j++)

       {

           // If hash matches, the new allocation covers the old allocation

           // for this particular bank.

           // The assumption is the initial PCR allocation (from manufacture)

           // has all the supported hash algorithms with an assigned bank

           // (possibly empty). So there must be a match for any new bank

           // allocation from the input.

           if(newAllocate.pcrSelections[j].hash ==

               allocate->pcrSelections[i].hash)

           {

               newAllocate.pcrSelections[j] = allocate->pcrSelections[i];

               break;

           }

       }

       // The j loop must exit with a match.

       pAssert(j < newAllocate.count);

   }

   // Max PCR in a bank is MIN(implemented PCR, PCR with attributes defined)

   *maxPCR = sizeof(s_initAttributes) / sizeof(PCR_Attributes);

   if(*maxPCR > IMPLEMENTATION_PCR)

       *maxPCR = IMPLEMENTATION_PCR;

   // Compute required size for allocation

   *sizeNeeded = 0;

   for(i = 0; i < newAllocate.count; i++)

   {

       UINT32      digestSize

           = CryptGetHashDigestSize(newAllocate.pcrSelections[i].hash);

#if defined(DRTM_PCR)

       // Make sure that we end up with at least one DRTM PCR

#   define PCR_DRTM (PCR_FIRST + DRTM_PCR)     // for cosmetics

       pcrDrtm =    pcrDrtm || TEST_BIT(PCR_DRTM, newAllocate.pcrSelections[i]);

#else   // if DRTM PCR is not required, indicate that the allocation is OK

       pcrDrtm = TRUE;

#endif

#if defined(HCRTM_PCR)

       // and one HCRTM PCR (since this is usually PCR 0...)

#   define PCR_HCRTM (PCR_FIRST + HCRTM_PCR)

       pcrHcrtm =    pcrDrtm || TEST_BIT(PCR_HCRTM, newAllocate.pcrSelections[i]);

#else

       pcrHcrtm = TRUE;

#endif

       for(j = 0; j < newAllocate.pcrSelections[i].sizeofSelect; j++)

       {

           BYTE         mask = 1;

           for(k = 0; k < 8; k++)

           {

               if((newAllocate.pcrSelections[i].pcrSelect[j] & mask) != 0)

                   *sizeNeeded += digestSize;

               mask = mask << 1;

           }

       }

   }

   if(!pcrDrtm || !pcrHcrtm)

       return TPM_RC_PCR;

   // In this particular implementation, we always have enough space to

   // allocate PCR. Different implementation may return a sizeAvailable less

   // than the sizeNeed.

   *sizeAvailable = sizeof(s_pcrs);

    // Save the required allocation to NV. Note that after NV is written, the

    // PCR allocation in NV is no longer consistent with the RAM data

    // gp.pcrAllocated. The NV version reflect the allocate after next

    // TPM_RESET, while the RAM version reflects the current allocation

    NvWriteReserved(NV_PCR_ALLOCATED, &newAllocate);

    return TPM_RC_SUCCESS;

}

//

//

//             PCRSetValue()

//

//      This function is used to set the designated PCR in all banks to an initial value. The initial value is signed

//      and will be sign extended into the entire PCR.

//

void

PCRSetValue(

    TPM_HANDLE           handle,            // IN: the handle of the PCR to set

    INT8                 initialValue       // IN: the value to set

    )

{

    int                  i;

    UINT32               pcr = handle - PCR_FIRST;

    TPMI_ALG_HASH        hash;

    UINT16               digestSize;

    BYTE                *pcrData;

    // Iterate supported PCR bank algorithms to reset

    for(i = 0; i < HASH_COUNT; i++)

    {

        hash = CryptGetHashAlgByIndex(i);

        // Prevent runaway

        if(hash == TPM_ALG_NULL)

            break;

          // Get a pointer to the data

          pcrData = GetPcrPointer(gp.pcrAllocated.pcrSelections[i].hash, pcr);

          // If the PCR is allocated

          if(pcrData != NULL)

          {

              // And the size of the digest

              digestSize = CryptGetHashDigestSize(hash);

               // Set the LSO to the input value

               pcrData[digestSize - 1] = initialValue;

               // Sign extend

               if(initialValue >= 0)

                   MemorySet(pcrData, 0, digestSize - 1);

               else

                   MemorySet(pcrData, -1, digestSize - 1);

          }

    }

}

//

//

//             PCRResetDynamics

//

//      This function is used to reset a dynamic PCR to 0. This function is used in DRTM sequence.

//

void

PCRResetDynamics(

      void

      )

{

      UINT32                  pcr, i;

      // Initialize PCR values