// 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 "StartAuthSession_fp.h"

//

//

//     Error Returns                     Meaning

//

//     TPM_RC_ATTRIBUTES                 tpmKey does not reference a decrypt key

//     TPM_RC_CONTEXT_GAP                the difference between the most recently created active context and

//                                       the oldest active context is at the limits of the TPM

//     TPM_RC_HANDLE                     input decrypt key handle only has public portion loaded

//     TPM_RC_MODE                       symmetric specifies a block cipher but the mode is not

//                                       TPM_ALG_CFB.

//     TPM_RC_SESSION_HANDLES            no session handle is available

//     TPM_RC_SESSION_MEMORY             no more slots for loading a session

//     TPM_RC_SIZE                       nonce less than 16 octets or greater than the size of the digest

//                                       produced by authHash

//     TPM_RC_VALUE                      secret size does not match decrypt key type; or the recovered secret

//                                       is larger than the digest size of the nameAlg of tpmKey; or, for an

//                                       RSA decrypt key, if encryptedSecret is greater than the public

//                                       exponent of tpmKey.

//

TPM_RC

TPM2_StartAuthSession(

   StartAuthSession_In       *in,                   // IN: input parameter buffer

   StartAuthSession_Out      *out                   // OUT: output parameter buffer

   )

{

   TPM_RC                     result = TPM_RC_SUCCESS;

   OBJECT                    *tpmKey;                // TPM key for decrypt salt

   SESSION                   *session;               // session internal data

   TPM2B_DATA                 salt;

// Input Validation

   // Check input nonce size. IT should be at least 16 bytes but not larger

   // than the digest size of session hash.

   if(    in->nonceCaller.t.size < 16

       || in->nonceCaller.t.size > CryptGetHashDigestSize(in->authHash))

       return TPM_RC_SIZE + RC_StartAuthSession_nonceCaller;

   // If an decrypt key is passed in, check its validation

   if(in->tpmKey != TPM_RH_NULL)

   {

       // secret size cannot be 0

       if(in->encryptedSalt.t.size == 0)

           return TPM_RC_VALUE + RC_StartAuthSession_encryptedSalt;

       // Get pointer to loaded decrypt key

       tpmKey = ObjectGet(in->tpmKey);

       // Decrypting salt requires accessing the private portion of a key.

       // Therefore, tmpKey can not be a key with only public portion loaded

       if(tpmKey->attributes.publicOnly)

           return TPM_RC_HANDLE + RC_StartAuthSession_tpmKey;

       // HMAC session input handle check.

         // tpmKey should be a decryption key

         if(tpmKey->publicArea.objectAttributes.decrypt != SET)

             return TPM_RC_ATTRIBUTES + RC_StartAuthSession_tpmKey;

         // Secret Decryption. A TPM_RC_VALUE, TPM_RC_KEY or Unmarshal errors

         // may be returned at this point

         result = CryptSecretDecrypt(in->tpmKey, &in->nonceCaller, "SECRET",

                                     &in->encryptedSalt, &salt);

         if(result != TPM_RC_SUCCESS)

             return TPM_RC_VALUE + RC_StartAuthSession_encryptedSalt;

  }

  else

  {

      // secret size must be 0

      if(in->encryptedSalt.t.size != 0)

          return TPM_RC_VALUE + RC_StartAuthSession_encryptedSalt;

      salt.t.size = 0;

  }

  // If the bind handle references a transient object, make sure that the

  // sensitive area is loaded so that the authValue can be accessed.

  if(     HandleGetType(in->bind) == TPM_HT_TRANSIENT

      && ObjectGet(in->bind)->attributes.publicOnly == SET)

      return TPM_RC_HANDLE + RC_StartAuthSession_bind;

  // If 'symmetric' is a symmetric block cipher (not TPM_ALG_NULL or TPM_ALG_XOR)

  // then the mode must be CFB.

  if(    in->symmetric.algorithm != TPM_ALG_NULL

      && in->symmetric.algorithm != TPM_ALG_XOR

      && in->symmetric.mode.sym != TPM_ALG_CFB)

      return TPM_RC_MODE + RC_StartAuthSession_symmetric;

// Internal Data Update

  // Create internal session structure. TPM_RC_CONTEXT_GAP, TPM_RC_NO_HANDLES

  // or TPM_RC_SESSION_MEMORY errors may be returned returned at this point.

  //

  // The detailed actions for creating the session context are not shown here

  // as the details are implementation dependent

  // SessionCreate sets the output handle

  result = SessionCreate(in->sessionType, in->authHash,

                         &in->nonceCaller, &in->symmetric,

                         in->bind, &salt, &out->sessionHandle);

  if(result != TPM_RC_SUCCESS)

      return result;

// Command Output

  // Get session pointer

  session = SessionGet(out->sessionHandle);

  // Copy nonceTPM

  out->nonceTPM = session->nonceTPM;

   return TPM_RC_SUCCESS;

}