stefanberger / libtpms / #2001

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

/*                                                                                */

/*                             Object Commands                                        */

/*                             Written by Ken Goldman                                */

/*                       IBM Thomas J. Watson Research Center                        */

/*            $Id: ObjectCommands.c 1259 2018-07-10 19:11:09Z kgoldman $        */

/*                                                                                */

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

/*                                                                                */

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

#include "Tpm.h"

#include "Object_spt_fp.h"

#include "Create_fp.h"

#if CC_Create  // Conditional expansion of this file

TPM_RC

            Create_In       *in,            // IN: input parameter list

            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.

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

                          &out->creationHash, &out->creationTicket);

    // Prepare output private data from sensitive

                       &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"

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.

        }

    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

TPM_RC

                  CreateLoaded_In    *in,            // IN: input parameter list

                  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.

                               &labelContext);

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

            // Don't derive RSA keys

                return TPM_RCS_TYPE + RC_CreateLoaded_inPublic;

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

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

                            sensitiveDataOrigin))

                return TPM_RCS_ATTRIBUTES;

            // Check the reset 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.

            // Creating a primary object

                {

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

                    // to seed the DRBG

                                           PRIMARY_OBJECT_CREATION,

                                                                                &name),

                }

            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

                           &out->outPrivate);

    else

    // Set the remaining return values

    // Set the remaining attributes for a loaded object

}

#endif // CC_CreateLoaded