stefanberger / libtpms / #2042

/********************************************************************************/

/*                                                                                */

/*                             Object Commands                                        */

/*                             Written by Ken Goldman                                */

/*                       IBM Thomas J. Watson Research Center                        */

/*                                                                                */

/*  Licenses and Notices                                                        */

/*                                                                                */

/*  1. Copyright Licenses:                                                        */

/*                                                                                */

/*  - Trusted Computing Group (TCG) grants to the user of the source code in        */

/*    this specification (the "Source Code") a worldwide, irrevocable,                 */

/*    nonexclusive, royalty free, copyright license to reproduce, create         */

/*    derivative works, distribute, display and perform the Source Code and        */

/*    derivative works thereof, and to grant others the rights granted herein.        */

/*                                                                                */

/*  - The TCG grants to the user of the other parts of the specification         */

/*    (other than the Source Code) the rights to reproduce, distribute,         */

/*    display, and perform the specification solely for the purpose of                 */

/*    developing products based on such documents.                                */

/*                                                                                */

/*  2. Source Code Distribution Conditions:                                        */

/*                                                                                */

/*  - Redistributions of Source Code must retain the above copyright licenses,         */

/*    this list of conditions and the following disclaimers.                        */

/*                                                                                */

/*  - Redistributions in binary form must reproduce the above copyright         */

/*    licenses, this list of conditions        and the following disclaimers in the         */

/*    documentation and/or other materials provided with the distribution.        */

/*                                                                                */

/*  3. Disclaimers:                                                                */

/*                                                                                */

/*  - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF        */

/*  LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH        */

/*  RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES)        */

/*  THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE.                */

/*  Contact TCG Administration (admin@trustedcomputinggroup.org) for                 */

/*  information on specification licensing rights available through TCG         */

/*  membership agreements.                                                        */

/*                                                                                */

/*  - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED         */

/*    WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR         */

/*    FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR                 */

/*    NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY                 */

/*    OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE.                */

/*                                                                                */

/*  - Without limitation, TCG and its members and licensors disclaim all         */

/*    liability, including liability for infringement of any proprietary         */

/*    rights, relating to use of information in this specification and to the        */

/*    implementation of this specification, and TCG disclaims all liability for        */

/*    cost of procurement of substitute goods or services, lost profits, loss         */

/*    of use, loss of data or any incidental, consequential, direct, indirect,         */

/*    or special damages, whether under contract, tort, warranty or otherwise,         */

/*    arising in any way out of use or reliance upon this specification or any         */

/*    information herein.                                                        */

/*                                                                                */

/*  (c) Copyright IBM Corp. and others, 2016 - 2024                                */

/*                                                                                */

/********************************************************************************/

#include "Tpm.h"

#include "Object_spt_fp.h"

#include "Create_fp.h"

#if CC_Create  // Conditional expansion of this file

/*(See part 3 specification)

// Create a regular object

*/

//  Return Type: TPM_RC

//      TPM_RC_ATTRIBUTES       'sensitiveDataOrigin' is CLEAR when 'sensitive.data'

//                              is an Empty Buffer, or is SET when 'sensitive.data' is

//                              not empty;

//                              'fixedTPM', 'fixedParent', or 'encryptedDuplication'

//                              attributes are inconsistent between themselves or with

//                              those of the parent object;

//                              inconsistent 'restricted', 'decrypt' and 'sign'

//                              attributes;

//                              attempt to inject sensitive data for an asymmetric

//                              key;

//      TPM_RC_HASH             non-duplicable storage key and its parent have

//                              different name algorithm

//      TPM_RC_KDF              incorrect KDF specified for decrypting keyed hash

//                              object

//      TPM_RC_KEY              invalid key size values in an asymmetric key public

//                              area or a provided symmetric key has a value that is

//                              not allowed

//      TPM_RC_KEY_SIZE         key size in public area for symmetric key differs from

//                              the size in the sensitive creation area; may also be

//                              returned if the TPM does not allow the key size to be

//                              used for a Storage Key

//      TPM_RC_OBJECT_MEMORY    a free slot is not available as scratch memory for

//                              object creation

//      TPM_RC_RANGE            the exponent value of an RSA key is not supported.

//      TPM_RC_SCHEME           inconsistent attributes 'decrypt', 'sign', or

//                              'restricted' and key's scheme ID; or hash algorithm is

//                              inconsistent with the scheme ID for keyed hash object

//      TPM_RC_SIZE             size of public authPolicy or sensitive authValue does

//                              not match digest size of the name algorithm

//                              sensitive data size for the keyed hash object is

//                              larger than is allowed for the scheme

//      TPM_RC_SYMMETRIC        a storage key with no symmetric algorithm specified;

//                              or non-storage key with symmetric algorithm different

//                              from TPM_ALG_NULL

//      TPM_RC_TYPE             unknown object type;

//                              'parentHandle' does not reference a restricted

//                              decryption key in the storage hierarchy with both

//                              public and sensitive portion loaded

//      TPM_RC_VALUE            exponent is not prime or could not find a prime using

//                              the provided parameters for an RSA key;

//                              unsupported name algorithm for an ECC key

//      TPM_RC_OBJECT_MEMORY    there is no free slot for the object

TPM_RC

            Create_Out* out  // OUT: output parameter list

            )

{

    // Input Validation

    // Does parent have the proper attributes?

        return TPM_RCS_TYPE + RC_Create_parentHandle;

    // Get a slot for the creation

        return TPM_RC_OBJECT_MEMORY;

    // If the TPM2B_PUBLIC was passed as a structure, marshal it into is canonical

    // form for processing

    // to save typing.

    // Copy the input structure to the allocated structure

    // Check attributes in input public area. CreateChecks() checks the things that

    // are unique to creation and then validates the attributes and values that are

    // common to create and load.

                          /* primaryHierarchy = */ 0,

                          publicArea,

    // Clean up the authValue if necessary

        return TPM_RCS_SIZE + RC_Create_inSensitive;

    // Command Output

    // Create the object using the default TPM random-number generator

        return result;

    // Fill in creation data

                       &in->creationPCR,

                       &in->outsideInfo,

                       &out->creationData,

                       &out->creationHash);

    // Compute creation ticket

                                   &newObject->name,

                                   &out->creationHash,

                                   &out->creationTicket);

        return result;

    // Prepare output private data from sensitive

                       &newObject->name,

                       parentObject,

                       &out->outPrivate);

    // Finish by copying the remaining return values

}

#endif  // CC_Create

#include "Tpm.h"

#include "Load_fp.h"

#if CC_Load  // Conditional expansion of this file

#include "Object_spt_fp.h"

/*(See part 3 specification)

// Load an ordinary or temporary object

*/

//  Return Type: TPM_RC

//      TPM_RC_ATTRIBUTES       'inPulblic' attributes are not allowed with selected

//                              parent

//      TPM_RC_BINDING          'inPrivate' and 'inPublic' are not

//                              cryptographically bound

//      TPM_RC_HASH             incorrect hash selection for signing key or

//                              the 'nameAlg' for 'inPublic' is not valid

//      TPM_RC_INTEGRITY        HMAC on 'inPrivate' was not valid

//      TPM_RC_KDF              KDF selection not allowed

//      TPM_RC_KEY              the size of the object's 'unique' field is not

//                              consistent with the indicated size in the object's

//                              parameters

//      TPM_RC_OBJECT_MEMORY    no available object slot

//      TPM_RC_SCHEME           the signing scheme is not valid for the key

//      TPM_RC_SENSITIVE        the 'inPrivate' did not unmarshal correctly

//      TPM_RC_SIZE             'inPrivate' missing, or 'authPolicy' size for

//                              'inPublic' or is not valid

//      TPM_RC_SYMMETRIC        symmetric algorithm not provided when required

//      TPM_RC_TYPE             'parentHandle' is not a storage key, or the object

//                              to load is a storage key but its parameters do not

//                              match the parameters of the parent.

//      TPM_RC_VALUE            decryption failure

TPM_RC

          Load_In         *in,            // IN: input parameter list

          Load_Out        *out            // OUT: output parameter list

          )

{

    // Input Validation

    // Don't get invested in loading if there is no place to put it.

        return TPM_RC_OBJECT_MEMORY;

        return TPM_RCS_SIZE + RC_Load_inPrivate;

    // Is the object that is being used as the parent actually a parent.

        return TPM_RCS_TYPE + RC_Load_parentHandle;

    // Compute the name of object. If there isn't one, it is because the nameAlg is

    // not valid.

        return TPM_RCS_HASH + RC_Load_inPublic;

    // Retrieve sensitive data.

                                &sensitive);

    // Internal Data Update

    // Load and validate object

                        &in->inPublic.publicArea, &sensitive,

                        RC_Load_inPublic, RC_Load_inPrivate,

                        &out->name);

        {

            // Set the common OBJECT attributes for a loaded object.

        }

    return result;

}

#endif // CC_Load

#include "Tpm.h"

#include "LoadExternal_fp.h"

#if CC_LoadExternal  // Conditional expansion of this file

#include "Object_spt_fp.h"

TPM_RC

                  LoadExternal_In     *in,            // IN: input parameter list

                  LoadExternal_Out    *out            // OUT: output parameter list

                  )

{

    // Input Validation

    // Don't get invested in loading if there is no place to put it.

        return TPM_RC_OBJECT_MEMORY;

    // If the hierarchy to be associated with this object is turned off, the object

    // cannot be loaded.

        return TPM_RCS_HIERARCHY + RC_LoadExternal_hierarchy;

    // For loading an object with both public and sensitive

        {

            // An external object with a sensitive area can only be loaded in the

            // NULL hierarchy

                return TPM_RCS_HIERARCHY + RC_LoadExternal_hierarchy;

            // An external object with a sensitive area must have fixedTPM == CLEAR

            // fixedParent == CLEAR so that it does not appear to be a key created by

            // this TPM.

               || IS_ATTRIBUTE(in->inPublic.publicArea.objectAttributes, TPMA_OBJECT,

                               fixedParent)

                               restricted))

                return TPM_RCS_ATTRIBUTES + RC_LoadExternal_inPublic;

            // Have sensitive point to something other than NULL so that object

            // initialization will load the sensitive part too

        }

    // Need the name to initialize the object structure

    // Load and validate key

                        &in->inPublic.publicArea, sensitive,

                        RC_LoadExternal_inPublic, RC_LoadExternal_inPrivate,

                        &out->name);

        {

            // Set the common OBJECT attributes for a loaded object.

                                      // if anything can be derived from an external object,

                                      // we make sure it always uses the old algorithm

                                      SEED_COMPAT_LEVEL_ORIGINAL); // libtpms added

        }

    return result;

}

#endif // CC_LoadExternal

#include "Tpm.h"

#include "ReadPublic_fp.h"

#if CC_ReadPublic  // Conditional expansion of this file

TPM_RC

                ReadPublic_In   *in,            // IN: input parameter list

                ReadPublic_Out  *out            // OUT: output parameter list

                )

{

    // Input Validation

    // Can not read public area of a sequence object

        return TPM_RC_SEQUENCE;

    // Command Output

}

#endif // CC_ReadPublic

#include "Tpm.h"

#include "ActivateCredential_fp.h"

#if CC_ActivateCredential  // Conditional expansion of this file

#include "Object_spt_fp.h"

TPM_RC

                        ActivateCredential_In   *in,            // IN: input parameter list

                        ActivateCredential_Out  *out            // OUT: output parameter list

                        )

{

    // Input Validation

    // Get decrypt key pointer

    // Get certificated object pointer

    // input decrypt key must be an asymmetric, restricted decryption key

       || !IS_ATTRIBUTE(object->publicArea.objectAttributes, TPMA_OBJECT, decrypt)

                        TPMA_OBJECT, restricted))

        return TPM_RCS_TYPE + RC_ActivateCredential_keyHandle;

    // Command output

    // Decrypt input credential data via asymmetric decryption.  A

    // TPM_RC_VALUE, TPM_RC_KEY or unmarshal errors may be returned at this

    // point

        {

                return TPM_RC_FAILURE;

        }

    // Retrieve secret data.  A TPM_RC_INTEGRITY error or unmarshal

    // errors may be returned at this point

                                &activateObject->name.b,

                                &data.b,

                                object,

                                &out->certInfo);

    return TPM_RC_SUCCESS;

}

#endif // CC_ActivateCredential

#include "Tpm.h"

#include "MakeCredential_fp.h"

#if CC_MakeCredential  // Conditional expansion of this file

#include "Object_spt_fp.h"

TPM_RC

                    MakeCredential_In   *in,            // IN: input parameter list

                    MakeCredential_Out  *out            // OUT: output parameter list

                    )

{

   // Input Validation

    // Get object pointer

    // input key must be an asymmetric, restricted decryption key

    // NOTE: Needs to be restricted to have a symmetric value.

       || !IS_ATTRIBUTE(object->publicArea.objectAttributes, TPMA_OBJECT, decrypt)

        return TPM_RCS_TYPE + RC_MakeCredential_handle;

    // The credential information may not be larger than the digest size used for

    // the Name of the key associated with handle.

        return TPM_RCS_SIZE + RC_MakeCredential_credential;

    // Command Output

    // Make encrypt key and its associated secret structure.

        return result;

    // Prepare output credential data from secret

                       object, &out->credentialBlob);

}

#endif // CC_MakeCredential

#include "Tpm.h"

#include "Unseal_fp.h"

#if CC_Unseal  // Conditional expansion of this file

TPM_RC

            Unseal_In           *in,

            Unseal_Out          *out

            )

{

    // Input Validation

    // Get pointer to loaded object

    // Input handle must be a data object

        return TPM_RCS_TYPE + RC_Unseal_itemHandle;

       || IS_ATTRIBUTE(object->publicArea.objectAttributes, TPMA_OBJECT, sign)

        return TPM_RCS_ATTRIBUTES + RC_Unseal_itemHandle;

    // Command Output

    // Copy data

}

#endif // CC_Unseal

#include "Tpm.h"

#include "ObjectChangeAuth_fp.h"

#if CC_ObjectChangeAuth  // Conditional expansion of this file

#include "Object_spt_fp.h"

TPM_RC

                      ObjectChangeAuth_In     *in,            // IN: input parameter list

                      ObjectChangeAuth_Out    *out            // OUT: output parameter list

                      )

{

    // Input Validation

    // Can not change authorization on sequence object

        return TPM_RCS_TYPE + RC_ObjectChangeAuth_objectHandle;

    // Make sure that the authorization value is consistent with the nameAlg

        return TPM_RCS_SIZE + RC_ObjectChangeAuth_newAuth;

    // Parent handle should be the parent of object handle.  In this

    // implementation we verify this by checking the QN of object.  Other

    // implementation may choose different method to verify this attribute.

                         &object->name, &QNCompare);

        return TPM_RCS_TYPE + RC_ObjectChangeAuth_parentHandle;

    // Command Output

    // Prepare the sensitive area with the new authorization value

    // Protect the sensitive area

                       &out->outPrivate);

}

#endif // CC_ObjectChangeAuth

#include "Tpm.h"

#include "CreateLoaded_fp.h"

#if CC_CreateLoaded  // Conditional expansion of this file

/*(See part 3 of specification)

 * Create and load any type of key, including a temporary key.

 * The input template is a marshaled public area rather than an unmarshaled one as

 * used in Create and CreatePrimary. This is so that the label and context that

 * could be in the template can be processed without changing the formats for the

 * calls to Create and CreatePrimary.

 */

//  Return Type: TPM_RC

//      TPM_RC_ATTRIBUTES       'sensitiveDataOrigin' is CLEAR when 'sensitive.data'

//                              is an Empty Buffer;

//                              'fixedTPM', 'fixedParent', or 'encryptedDuplication'

//                              attributes are inconsistent between themselves or with

//                              those of the parent object;

//                              inconsistent 'restricted', 'decrypt' and 'sign'

//                              attributes;

//                              attempt to inject sensitive data for an asymmetric

//                              key;

//                              attempt to create a symmetric cipher key that is not

//                              a decryption key

//      TPM_RC_FW_LIMITED       The requested hierarchy is FW-limited, but the TPM

//                              does not support FW-limited objects or the TPM failed

//                              to derive the Firmware Secret.

//      TPM_RC_SVN_LIMITED      The requested hierarchy is SVN-limited, but the TPM

//                              does not support SVN-limited objects or the TPM failed

//                              to derive the Firmware SVN Secret for the requested

//                              SVN.

//      TPM_RC_KDF              incorrect KDF specified for decrypting keyed hash

//                              object

//      TPM_RC_KEY              the value of a provided symmetric key is not allowed

//      TPM_RC_OBJECT_MEMORY    there is no free slot for the object

//      TPM_RC_SCHEME           inconsistent attributes 'decrypt', 'sign',

//                              'restricted' and key's scheme ID; or hash algorithm is

//                              inconsistent with the scheme ID for keyed hash object

//      TPM_RC_SIZE             size of public authorization policy or sensitive

//                              authorization value does not match digest size of the

//                              name algorithm sensitive data size for the keyed hash

//                              object is larger than is allowed for the scheme

//      TPM_RC_SYMMETRIC        a storage key with no symmetric algorithm specified;

//                              or non-storage key with symmetric algorithm different

//                              from TPM_ALG_NULL

//      TPM_RC_TYPE             cannot create the object of the indicated type

//                              (usually only occurs if trying to derive an RSA key).

TPM_RC

                  CreateLoaded_Out* out  // OUT: output parameter list

                  )

{

    // Input Validation

    // How the public area is unmarshaled is determined by the parent, so

    // see if parent is a derivation parent

    // If the parent is an object, then make sure that it is either a parent or

    // derivation parent

        return TPM_RCS_TYPE + RC_CreateLoaded_parentHandle;

    // Get a spot in which to create the newObject

        return TPM_RC_OBJECT_MEMORY;

    // Do this to save typing

    // Unmarshal the template into the object space. TPM2_Create() and

    // TPM2_CreatePrimary() have the publicArea unmarshaled by CommandDispatcher.

    // This command is different because of an unfortunate property of the

    // unique field of an ECC key. It is a structure rather than a single TPM2B. If

    // if had been a TPM2B, then the label and context could be within a TPM2B and

    // unmarshaled like other public areas. Since it is not, this command needs its

    // on template that is a TPM2B that is unmarshaled as a BYTE array with a

    // its own unmarshal function.

    // Validate that the authorization size is appropriate

        return TPM_RCS_SIZE + RC_CreateLoaded_inSensitive;

    // Command output

        {

            // SP800-108 is the only KDF supported by this implementation and there is

            // no default hash algorithm.

                    && scheme->details.xor.kdf == TPM_ALG_KDF1_SP800_108);

            // Don't derive RSA keys

                return TPM_RCS_TYPE + RC_CreateLoaded_inPublic;

                                                     RUNTIME_ATTRIBUTE_NO_ECC_KEY_DERIVATION))

                return TPM_RCS_TYPE + RC_CreateLoaded_inPublic;                // libtpms added end

            // sensitiveDataOrigin has to be CLEAR in a derived object. Since this

            // is specific to a derived object, it is checked here.

                            publicArea->objectAttributes, TPMA_OBJECT, sensitiveDataOrigin))

                return TPM_RCS_ATTRIBUTES;

            // Check the rest of the attributes

            // Process the template and sensitive areas to get the actual 'label' and

            // 'context' values to be used for this derivation.

                return result;

            // Set up the KDF for object generation

                                      &parent->sensitive.sensitive.bits.b,

                                      &labelContext.label.b,

                                      &labelContext.context.b,

                                      TPM_MAX_DERIVATION_BITS);

            // Clear the sensitive size so that the creation functions will not try

            // to use this value.

        }

    else

        {

            // Check attributes in input public area. CreateChecks() checks the things

            // that are unique to creation and then validates the attributes and values

            // that are common to create and load.

                                  (parent == NULL) ? in->parentHandle : 0,

                                  publicArea,

            // Creating a primary object

                {

                    // If so, use the primary seed and the digest of the template

                    // to seed the DRBG

                    // If so, use the primary seed and the digest of the template

                    // to seed the DRBG

                                                    (DRBG_STATE*)rand,

                                                    &primary_seed.b,

                                                    PRIMARY_OBJECT_CREATION,

                                                    seedCompatLevel);        // libtpms added

                        return result;

                }

            else

                {

                    // This is an ordinary object so use the normal random number generator

                    rand = NULL;

                }

        }

    // Internal data update

    // Create the object

        return result;

    // if this is not a Primary key and not a derived key, then return the sensitive

    // area

        // Prepare output private data from sensitive

                           &newObject->name,

                           parent,

                           &out->outPrivate);

    else

    // Set the remaining return values

    // Set the remaining attributes for a loaded object

                              seedCompatLevel); // libtpms added

}

#endif  // CC_CreateLoaded