PolicySigned.c

// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 3: Commands
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014

#include "InternalRoutines.h"
#include "Policy_spt_fp.h"
#include "PolicySigned_fp.h"
//
//
//     Error Returns                     Meaning
//
//     TPM_RC_CPHASH                     cpHash was previously set to a different value
//     TPM_RC_EXPIRED                    expiration indicates a time in the past or expiration is non-zero but no
//                                       nonceTPM is present
//     TPM_RC_HANDLE                     authObject need to have sensitive portion loaded
//     TPM_RC_KEY                        authObject is not a signing scheme
//     TPM_RC_NONCE                      nonceTPM is not the nonce associated with the policySession
//     TPM_RC_SCHEME                     the signing scheme of auth is not supported by the TPM
//     TPM_RC_SIGNATURE                  the signature is not genuine
//     TPM_RC_SIZE                       input cpHash has wrong size
//     TPM_RC_VALUE                      input policyID or expiration does not match the internal data in policy
//                                       session
//
TPM_RC
TPM2_PolicySigned(
   PolicySigned_In       *in,                  // IN: input parameter list
   PolicySigned_Out      *out                  // OUT: output parameter list
   )
{
   TPM_RC                     result = TPM_RC_SUCCESS;
   SESSION                   *session;
   TPM2B_NAME                 entityName;
   TPM2B_DIGEST               authHash;
   HASH_STATE                 hashState;
   UINT32                     expiration = (in->expiration < 0)
                                           ? -(in->expiration) : in->expiration;
   UINT64                     authTimeout = 0;

// Input Validation

   // Set up local pointers
   session = SessionGet(in->policySession);               // the session structure

   // Only do input validation if this is not a trial policy session
   if(session->attributes.isTrialPolicy == CLEAR)
   {
       if(expiration != 0)
           authTimeout = expiration * 1000 + session->startTime;

       result = PolicyParameterChecks(session, authTimeout,
                                       &in->cpHashA, &in->nonceTPM,
                                       RC_PolicySigned_nonceTPM,
                                       RC_PolicySigned_cpHashA,
                                       RC_PolicySigned_expiration);
       if(result != TPM_RC_SUCCESS)
           return result;

       // Re-compute the digest being signed
       /*(See part 3 specification)
       // The digest is computed as:
       //     aHash := hash ( nonceTPM | expiration | cpHashA | policyRef)
       // where:
       //      hash()      the hash associated with the signed auth
       //      nonceTPM    the nonceTPM value from the TPM2_StartAuthSession .
       //                  response If the authorization is not limited to this
       //                  session, the size of this value is zero.
       //      expiration time limit on authorization set by authorizing object.
       //                  This 32-bit value is set to zero if the expiration
       //                  time is not being set.
       //      cpHashA     hash of the command parameters for the command being
       //                  approved using the hash algorithm of the PSAP session.
       //                  Set to NULLauth if the authorization is not limited
       //                  to a specific command.
       //      policyRef   hash of an opaque value determined by the authorizing
       //                  object. Set to the NULLdigest if no hash is present.
       */
       // Start hash
       authHash.t.size = CryptStartHash(CryptGetSignHashAlg(&in->auth),
                                        &hashState);

       // add nonceTPM
       CryptUpdateDigest2B(&hashState, &in->nonceTPM.b);

       // add expiration
       CryptUpdateDigestInt(&hashState, sizeof(UINT32), (BYTE*) &in->expiration);

       // add cpHashA
       CryptUpdateDigest2B(&hashState, &in->cpHashA.b);

       // add policyRef
       CryptUpdateDigest2B(&hashState, &in->policyRef.b);

       // Complete digest
       CryptCompleteHash2B(&hashState, &authHash.b);

       // Validate Signature. A TPM_RC_SCHEME, TPM_RC_HANDLE or TPM_RC_SIGNATURE
       // error may be returned at this point
       result = CryptVerifySignature(in->authObject, &authHash, &in->auth);
       if(result != TPM_RC_SUCCESS)
           return RcSafeAddToResult(result, RC_PolicySigned_auth);
   }
// Internal Data Update
   // Need the Name of the signing entity
   entityName.t.size = EntityGetName(in->authObject, &entityName.t.name);

   // Update policy with input policyRef and name of auth key
   // These values are updated even if the session is a trial session
   PolicyContextUpdate(TPM_CC_PolicySigned, &entityName, &in->policyRef,
                       &in->cpHashA, authTimeout, session);

// Command Output

   // Create ticket and timeout buffer if in->expiration < 0 and this is not
   // a trial session.
   // NOTE: PolicyParameterChecks() makes sure that nonceTPM is present
   // when expiration is non-zero.
   if(   in->expiration < 0
      && session->attributes.isTrialPolicy == CLEAR
     )
   {
       // Generate timeout buffer. The format of output timeout buffer is
       // TPM-specific.
       // Note: can't do a direct copy because the output buffer is a byte
       // array and it may not be aligned to accept a 64-bit value. The method
       // used has the side-effect of making the returned value a big-endian,
       // 64-bit value that is byte aligned.
       out->timeout.t.size = sizeof(UINT64);
       UINT64_TO_BYTE_ARRAY(authTimeout, out->timeout.t.buffer);

       // Compute policy ticket
       TicketComputeAuth(TPM_ST_AUTH_SIGNED, EntityGetHierarchy(in->authObject),
                         authTimeout, &in->cpHashA, &in->policyRef, &entityName,
                         &out->policyTicket);
   }
   else
   {
       // Generate a null ticket.
       // timeout buffer is null
       out->timeout.t.size = 0;

       // auth ticket is null
       out->policyTicket.tag = TPM_ST_AUTH_SIGNED;
       out->policyTicket.hierarchy = TPM_RH_NULL;
       out->policyTicket.digest.t.size = 0;
   }

   return TPM_RC_SUCCESS;
}