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

#include "InternalRoutines.h"

#include "Attest_spt_fp.h"

//

//

//          Functions

//

//          FillInAttestInfo()

//

//     Fill in common fields of TPMS_ATTEST structure.

//

//     Error Returns                     Meaning

//

//     TPM_RC_KEY                        key referenced by signHandle is not a signing key

//     TPM_RC_SCHEME                     both scheme and key's default scheme are empty; or scheme is

//                                       empty while key's default scheme requires explicit input scheme (split

//                                       signing); or non-empty default key scheme differs from scheme

//

TPM_RC

FillInAttestInfo(

     TPMI_DH_OBJECT         signHandle,            //   IN: handle of signing object

     TPMT_SIG_SCHEME       *scheme,                //   IN/OUT: scheme to be used for signing

     TPM2B_DATA            *data,                  //   IN: qualifying data

     TPMS_ATTEST           *attest                 //   OUT: attest structure

     )

{

     TPM_RC                         result;

     TPMI_RH_HIERARCHY              signHierarhcy;

     result = CryptSelectSignScheme(signHandle, scheme);

     if(result != TPM_RC_SUCCESS)

         return result;

     // Magic number

     attest->magic = TPM_GENERATED_VALUE;

     if(signHandle == TPM_RH_NULL)

     {

         BYTE     *buffer;

         INT32     bufferSize;

         // For null sign handle, the QN is TPM_RH_NULL

         buffer = attest->qualifiedSigner.t.name;

         bufferSize = sizeof(TPM_HANDLE);

         attest->qualifiedSigner.t.size =

              TPM_HANDLE_Marshal(&signHandle, &buffer, &bufferSize);

     }

     else

     {

         // Certifying object qualified name

         // if the scheme is anonymous, this is an empty buffer

         if(CryptIsSchemeAnonymous(scheme->scheme))

              attest->qualifiedSigner.t.size = 0;

         else

              ObjectGetQualifiedName(signHandle, &attest->qualifiedSigner);

   }

   // current clock in plain text

   TimeFillInfo(&attest->clockInfo);

   // Firmware version in plain text

   attest->firmwareVersion = ((UINT64) gp.firmwareV1 << (sizeof(UINT32) * 8));

   attest->firmwareVersion += gp.firmwareV2;

   // Get the hierarchy of sign object. For NULL sign handle, the hierarchy

   // will be TPM_RH_NULL

   signHierarhcy = EntityGetHierarchy(signHandle);

   if(signHierarhcy != TPM_RH_PLATFORM && signHierarhcy != TPM_RH_ENDORSEMENT)

   {

       // For sign object is not in platform or endorsement hierarchy,

       // obfuscate the clock and firmwereVersion information

       UINT64          obfuscation[2];

       TPMI_ALG_HASH   hashAlg;

         // Get hash algorithm

         if(signHandle == TPM_RH_NULL || signHandle == TPM_RH_OWNER)

         {

              hashAlg = CONTEXT_INTEGRITY_HASH_ALG;

         }

         else

         {

              OBJECT          *signObject = NULL;

              signObject = ObjectGet(signHandle);

              hashAlg = signObject->publicArea.nameAlg;

         }

         KDFa(hashAlg, &gp.shProof.b, "OBFUSCATE",

               &attest->qualifiedSigner.b, NULL, 128, (BYTE *)&obfuscation[0], NULL);

         // Obfuscate data

         attest->firmwareVersion += obfuscation[0];

         attest->clockInfo.resetCount += (UINT32)(obfuscation[1] >> 32);

         attest->clockInfo.restartCount += (UINT32)obfuscation[1];

   }

   // External data

   if(CryptIsSchemeAnonymous(scheme->scheme))

       attest->extraData.t.size = 0;

   else

   {

       // If we move the data to the attestation structure, then we will not use

       // it in the signing operation except as part of the signed data

       attest->extraData = *data;

       data->t.size = 0;

   }

   return TPM_RC_SUCCESS;

}

//

//

//          SignAttestInfo()

//

//     Sign a TPMS_ATTEST structure. If signHandle is TPM_RH_NULL, a null signature is returned.

//

//

//

//

//      Error Returns                     Meaning

//

//      TPM_RC_ATTRIBUTES                 signHandle references not a signing key

//      TPM_RC_SCHEME                     scheme is not compatible with signHandle type

//      TPM_RC_VALUE                      digest generated for the given scheme is greater than the modulus of

//                                        signHandle (for an RSA key); invalid commit status or failed to

//                                        generate r value (for an ECC key)

//

TPM_RC

SignAttestInfo(

   TPMI_DH_OBJECT           signHandle,                //   IN: handle of sign object

   TPMT_SIG_SCHEME         *scheme,                    //   IN: sign scheme

   TPMS_ATTEST             *certifyInfo,               //   IN: the data to be signed

   TPM2B_DATA              *qualifyingData,            //   IN: extra data for the signing proce

   TPM2B_ATTEST            *attest,                    //   OUT: marshaled attest blob to be

                                                       //       signed

   TPMT_SIGNATURE          *signature                  //   OUT: signature

   )

{

   TPM_RC                         result;

   TPMI_ALG_HASH                  hashAlg;

   BYTE                           *buffer;

   INT32                          bufferSize;

   HASH_STATE                     hashState;

   TPM2B_DIGEST                   digest;

   // Marshal TPMS_ATTEST structure for hash

   buffer = attest->t.attestationData;

   bufferSize = sizeof(TPMS_ATTEST);

   attest->t.size = TPMS_ATTEST_Marshal(certifyInfo, &buffer, &bufferSize);

   if(signHandle == TPM_RH_NULL)

   {

       signature->sigAlg = TPM_ALG_NULL;

   }

   else

   {

       // Attestation command may cause the orderlyState to be cleared due to

       // the reporting of clock info. If this is the case, check if NV is

       // available first

       if(gp.orderlyState != SHUTDOWN_NONE)

       {

           // The command needs NV update. Check if NV is available.

           // A TPM_RC_NV_UNAVAILABLE or TPM_RC_NV_RATE error may be returned at

           // this point

           result = NvIsAvailable();

           if(result != TPM_RC_SUCCESS)

               return result;

       }

         // Compute hash

         hashAlg = scheme->details.any.hashAlg;

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

         CryptUpdateDigest(&hashState, attest->t.size, attest->t.attestationData);

         CryptCompleteHash2B(&hashState, &digest.b);

         // If there is qualifying data, need to rehash the the data

         // hash(qualifyingData || hash(attestationData))

         if(qualifyingData->t.size != 0)

         {

             CryptStartHash(hashAlg, &hashState);

             CryptUpdateDigest(&hashState,

                               qualifyingData->t.size,

                               qualifyingData->t.buffer);

             CryptUpdateDigest(&hashState, digest.t.size, digest.t.buffer);

             CryptCompleteHash2B(&hashState, &digest.b);

          }

          // Sign the hash. A TPM_RC_VALUE, TPM_RC_SCHEME, or

          // TPM_RC_ATTRIBUTES error may be returned at this point

          return CryptSign(signHandle,

                           scheme,

                           &digest,

                           signature);

     }

     return TPM_RC_SUCCESS;

}