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

#include "Object_spt_fp.h"

//

//

//     Error Returns                Meaning

//

//     TPM_RC_ATTRIBUTES            key to duplicate has fixedParent SET

//     TPM_RC_HIERARCHY             encryptedDuplication is SET and newParentHandle specifies Null

//                                  Hierarchy

//     TPM_RC_KEY                   newParentHandle references invalid ECC key (public point not on the

//                                  curve)

//     TPM_RC_SIZE                  input encryption key size does not match the size specified in

//                                  symmetric algorithm

//     TPM_RC_SYMMETRIC             encryptedDuplication is SET but no symmetric algorithm is provided

//     TPM_RC_TYPE                  newParentHandle is neither a storage key nor TPM_RH_NULL; or

//                                  the object has a NULL nameAlg

//

TPM_RC

TPM2_Duplicate(

   Duplicate_In      *in,            // IN: input parameter list

   Duplicate_Out     *out            // OUT: output parameter list

   )

{

   TPM_RC                   result = TPM_RC_SUCCESS;

   TPMT_SENSITIVE           sensitive;

   UINT16                   innerKeySize = 0; // encrypt key size for inner wrap

   OBJECT                   *object;

   TPM2B_DATA               data;

// Input Validation

   // Get duplicate object pointer

   object = ObjectGet(in->objectHandle);

   // duplicate key must have fixParent bit CLEAR.

   if(object->publicArea.objectAttributes.fixedParent == SET)

       return TPM_RC_ATTRIBUTES + RC_Duplicate_objectHandle;

   // Do not duplicate object with NULL nameAlg

   if(object->publicArea.nameAlg == TPM_ALG_NULL)

       return TPM_RC_TYPE + RC_Duplicate_objectHandle;

   // new parent key must be a storage object or TPM_RH_NULL

   if(in->newParentHandle != TPM_RH_NULL

           && !ObjectIsStorage(in->newParentHandle))

       return TPM_RC_TYPE + RC_Duplicate_newParentHandle;

   // If the duplicates object has encryptedDuplication SET, then there must be

   // an inner wrapper and the new parent may not be TPM_RH_NULL

   if(object->publicArea.objectAttributes.encryptedDuplication == SET)

   {

       if(in->symmetricAlg.algorithm == TPM_ALG_NULL)

           return TPM_RC_SYMMETRIC + RC_Duplicate_symmetricAlg;

       if(in->newParentHandle == TPM_RH_NULL)

            return TPM_RC_HIERARCHY + RC_Duplicate_newParentHandle;

   }

   if(in->symmetricAlg.algorithm == TPM_ALG_NULL)

   {

       // if algorithm is TPM_ALG_NULL, input key size must be 0

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

           return TPM_RC_SIZE + RC_Duplicate_encryptionKeyIn;

   }

   else

   {

       // Get inner wrap key size

       innerKeySize = in->symmetricAlg.keyBits.sym;

       // If provided the input symmetric key must match the size of the algorithm

       if(in->encryptionKeyIn.t.size != 0

               && in->encryptionKeyIn.t.size != (innerKeySize + 7) / 8)

           return TPM_RC_SIZE + RC_Duplicate_encryptionKeyIn;

   }

// Command Output

   if(in->newParentHandle != TPM_RH_NULL)

   {

       // Make encrypt key and its associated secret structure. A TPM_RC_KEY

       // error may be returned at this point

       out->outSymSeed.t.size = sizeof(out->outSymSeed.t.secret);

       result = CryptSecretEncrypt(in->newParentHandle,

                                   "DUPLICATE", &data, &out->outSymSeed);

       pAssert(result != TPM_RC_VALUE);

       if(result != TPM_RC_SUCCESS)

           return result;

   }

   else

   {

       // Do not apply outer wrapper

       data.t.size = 0;

       out->outSymSeed.t.size = 0;

   }

   // Copy sensitive area

   sensitive = object->sensitive;

   // Prepare output private data from sensitive

   SensitiveToDuplicate(&sensitive, &object->name, in->newParentHandle,

                        object->publicArea.nameAlg, (TPM2B_SEED *) &data,

                        &in->symmetricAlg, &in->encryptionKeyIn,

                        &out->duplicate);

   out->encryptionKeyOut = in->encryptionKeyIn;

   return TPM_RC_SUCCESS;

}